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 1phbyy-0002Qj-G3 for pgsql-hackers@arkaria.postgresql.org; Wed, 29 Mar 2023 20:01:20 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.92) (envelope-from ) id 1phbyx-0005qE-CN for pgsql-hackers@arkaria.postgresql.org; Wed, 29 Mar 2023 20:01:19 +0000 Received: from makus.postgresql.org ([2001:4800:3e1:1::229]) by malur.postgresql.org with esmtps (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1phbyw-0005k4-MI for pgsql-hackers@lists.postgresql.org; Wed, 29 Mar 2023 20:01:19 +0000 Received: from mail-pg1-x535.google.com ([2607:f8b0:4864:20::535]) by makus.postgresql.org with esmtps (TLS1.3:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.92) (envelope-from ) id 1phbys-00025u-AV for pgsql-hackers@postgresql.org; Wed, 29 Mar 2023 20:01:17 +0000 Received: by mail-pg1-x535.google.com with SMTP id z10so10011682pgr.8 for ; Wed, 29 Mar 2023 13:01:14 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; t=1680120073; x=1682712073; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:from:to:cc:subject:date:message-id:reply-to; bh=tCEmrQvj4ptWsy0vyA++tzu+xolcdtMVc44caIhGOv8=; b=FKQ9Cp0V5x6QJLSx4X81OTwQTgi8W3RjKuds4VjJtF8MX7jH4oc4K22flBz0SZj9jG 9+h1J22VE0bftL90KMxEl7VOhHM+ooRmGUwYNTAnSwxhwAfp1jxLHelykVsRhFWKWsj4 1/9MwH1ac8/VCK1JNCQwVgRplq4jDrakTuEvZbRobGEf+8THtCO1D6JRWv0gZC/oguuN SdZd/8XRixsKn/fK8BMTqobXSKr60EK23Z48UY8hBLvErUuFjypKU00ON36AnEekKInt GOrrQaaSTmBGoKNPQK4WBDAd/eHNAiu2i+Li9k7FwQRSvNPuX72YHxGeI1GSSMzpELY1 cf4Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; t=1680120073; x=1682712073; 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=tCEmrQvj4ptWsy0vyA++tzu+xolcdtMVc44caIhGOv8=; b=fi0Bo43a/WB2X9McHlYVIrxdflpfRnEB+zvFyiG5SGsbt/bp9ynvCQrelCSmF914cv dI3oKk3XyiISL4jwCRJfFLQz4YX6tp2LdePzP2SUIrV9HOvWg58O9EdiF6pDXUB8ESHI 3jEk60xZZlpfxLF1Nvg7Hfe8vtU8m+J/qtWgTILiDXeVsGc+pUlPOD5E5DIXIvVfdEki rmE37/NxoSUuk6eK2M9TXONMDkwOGU2W2JsLPnKUUIAH/DvFttllaFqt3B+G2P6qDuPe amNTG+0uTdSI3plmEBPGus53sI3bNpqgD9H9JgATbvRCbolkkGNeF/XOX92eBnGqS9au rAqg== X-Gm-Message-State: AAQBX9fzXbdwu3rdlwcLv97RUDplZY8KZ5dnflot9n6tVFzoNgHxV1eY HqaRtRnkwPhYlzXNN+cRieNw9Z3PSGN7tKA0sMo= X-Google-Smtp-Source: AKy350al+S0D+3pfBndgoX4x2un5FL1KxNS4AqLV/LDnV969557kGIn/trBenQFADkyKiRk3kiVcP/dKO6JvMiISdrM= X-Received: by 2002:a05:6a00:21d3:b0:62c:d6ef:eb35 with SMTP id t19-20020a056a0021d300b0062cd6efeb35mr8131443pfj.2.1680120072863; Wed, 29 Mar 2023 13:01:12 -0700 (PDT) MIME-Version: 1.0 References: <20230329.120908.350115307125624430.horikyota.ntt@gmail.com> <20230329.132155.629765142788133576.horikyota.ntt@gmail.com> <20230329.173456.1185961934810139447.horikyota.ntt@gmail.com> In-Reply-To: <20230329.173456.1185961934810139447.horikyota.ntt@gmail.com> From: Melanie Plageman Date: Wed, 29 Mar 2023 16:01:00 -0400 Message-ID: Subject: Re: Should vacuum process config file reload more often To: Kyotaro Horiguchi Cc: sawada.mshk@gmail.com, daniel@yesql.se, pgsql-hackers@postgresql.org, andres@anarazel.de, amit.kapila16@gmail.com Content-Type: multipart/mixed; boundary="00000000000020347705f80f706d" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --00000000000020347705f80f706d Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Thanks for the detailed review! On Tue, Mar 28, 2023 at 11:09=E2=80=AFPM Kyotaro Horiguchi wrote: > > At Tue, 28 Mar 2023 20:35:28 -0400, Melanie Plageman wrote in > > On Tue, Mar 28, 2023 at 4:21=E2=80=AFAM Kyotaro Horiguchi wrote: > > > > > > At Mon, 27 Mar 2023 14:12:03 -0400, Melanie Plageman wrote in > > > > > > 0002: > > > > > > I felt a bit uneasy on this. It seems somewhat complex (and makes the > > > succeeding patches complex), > > > > Even if we introduced a second global variable to indicate that failsaf= e > > mode has been engaged, we would still require the additional checks > > of VacuumCostInactive. > > > > > has confusing names, > > > > I would be happy to rename the values of the enum to make them less > > confusing. Are you thinking "force" instead of "locked"? > > maybe: > > VACUUM_COST_FORCE_INACTIVE and > > VACUUM_COST_INACTIVE > > ? > > > > > and doesn't seem like self-contained. > > > > By changing the variable from VacuumCostActive to VacuumCostInactive, I > > have kept all non-vacuum code from having to distinguish between it > > being inactive due to failsafe mode or due to user settings. > > My concern is that VacuumCostActive is logic-inverted and turned into > a ternary variable in a subtle way. The expression > "!VacuumCostInactive" is quite confusing. (I sometimes feel the same > way about "!XLogRecPtrIsInvalid(lsn)", and I believe most people write > it with another macro like "lsn !=3D InvalidXLogrecPtr"). Additionally, > the constraint in this patch will be implemented as open code. So I > wanted to suggest something like the attached. The main idea is to use > a wrapper function to enforce the restriction, and by doing so, we > eliminated the need to make the variable into a ternary without a good > reason. So, the rationale for making it a ternary is that the variable is the combination of two pieces of information which has only has 3 valid states: failsafe inactive + cost active =3D cost active failsafe inactive + cost inactive =3D cost inactive failsafe active + cost inactive =3D cost inactive and locked the fourth is invalid failsafe active + cost active =3D invalid That is harder to enforce with two variables. Also, the two pieces of information are not meaningful individually. So, I thought it made sense to make a single variable. Your suggested patch introduces an additional variable which shadows LVRelState->failsafe_active but doesn't actually get set/reset at all of the correct places. If we did introduce a second global variable, I don't think we should also keep LVRelState->failsafe_active, as keeping them in sync will be difficult. As for the double negative (!VacuumCostInactive), I agree that it is not ideal, however, if we use a ternary and keep VacuumCostActive, there is no way for non-vacuum code to treat it as a boolean. With the ternary VacuumCostInactive, only vacuum code has to know about the distinction between inactive+failsafe active and inactive+failsafe inactive. As for the setter function, I think that having a function to set VacuumCostActive based on failsafe_active is actually doing more harm than good. Only vacuum code has to know about the distinction as it is, so we aren't really saving any trouble (there would really only be two callers of the suggested function). And, since the function hides whether or not VacuumCostActive was actually set to the passed-in value, we can't easily do other necessary maintenance -- like zero out VacuumCostBalance if we disabled vacuum cost. > > > 0003: > > > > > > + * Reload the configuration file if requested. This allows ch= anges to > > > + * vacuum_cost_limit and vacuum_cost_delay to take effect whi= le a table is > > > + * being vacuumed or analyzed. Analyze should not reload conf= iguration > > > + * file if it is in an outer transaction, as GUC values shoul= dn't be > > > + * allowed to refer to some uncommitted state (e.g. database = objects > > > + * created in this transaction). > > > > > > I'm not sure GUC reload is or should be related to transactions. For > > > instance, work_mem can be changed by a reload during a transaction > > > unless it has been set in the current transaction. I don't think we > > > need to deliberately suppress changes in variables caused by realods > > > during transactions only for analzye. If analyze doesn't like changes > > > to certain GUC variables, their values should be snapshotted before > > > starting the process. > > > > Currently, we only reload the config file in top-level statements. We > > don't reload the configuration file from within a nested transaction > > command. BEGIN starts a transaction but not a transaction command. So > > BEGIN; ANALYZE; probably wouldn't violate this rule. But it is simpler > > to just forbid reloading when it is not a top-level transaction command= . > > I have updated the comment to reflect this. > > I feel it's a bit fragile. We may not be able to manage the reload > timeing perfectly. I think we might accidentally add a reload > timing. In that case, the assumption could break. In most cases, I > think we use snapshotting in various ways to avoid unintended variable > changes. (And I beilieve the analyze code also does that.) I'm not sure I fully understand the problem you are thinking of. What do you mean about managing the reload timing? Are you suggesting there is a problem with excluding analzye in an outer transaction from doing the reload or with doing the reload during vacuum and analyze when they are top-level statements? And, by snapshotting do you mean how vacuum_rel() and do_analyze_rel() do NewGUCNestLevel() so that they can then do AtEOXact_GUC() and rollback guc changes done during that operation? How are you envisioning that being used here? On Wed, Mar 29, 2023 at 2:00=E2=80=AFAM Kyotaro Horiguchi wrote: > > At Wed, 29 Mar 2023 13:21:55 +0900 (JST), Kyotaro Horiguchi wrote in > > autovacuum.c:2893 > > /* > > * If any of the cost delay parameters has been set indiv= idually for > > * this table, disable the balancing algorithm. > > */ > > tab->at_dobalance =3D > > !(avopts && (avopts->vacuum_cost_limit > 0 || > > avopts->vacuum_cost_dela= y > 0)); > > > > So, sorry for the noise. I'll review it while this into cnosideration. > > Then I found that the code is quite confusing as it is. > > For the tables that don't have cost_delay and cost_limit specified > indificually, at_vacuum_cost_limit and _delay store the system global > values detemined by GUCs. wi_cost_delay, _limit and _limit_base stores > the same values with them. As the result I concluded tha > autovac_balance_cost() does exactly what Melanie's patch does, except > that nworkers_for_balance is not stored in shared memory. > > I discovered that commit 1021bd6a89 brought in do_balance. > > > Since the mechanism is already complicated, just disable it for thos= e > > cases rather than trying to make it cope. There are undesirable > > After reading this, I get why the code is so complex. It is a remnant > of when balancing was done with tables that had individually specified > cost parameters. And I found the following description in the doc. > > https://www.postgresql.org/docs/devel/routine-vacuuming.html > > When multiple workers are running, the autovacuum cost delay > > parameters (see Section 20.4.4) are =E2=80=9Cbalanced=E2=80=9D among al= l the running > > workers, so that the total I/O impact on the system is the same > > regardless of the number of workers actually running. However, any > > workers processing tables whose per-table > > autovacuum_vacuum_cost_delay or autovacuum_vacuum_cost_limit storage > > parameters have been set are not considered in the balancing > > algorithm. > > The initial balancing mechanism was brought in by e2a186b03c back in > 2007. The balancing code has had that unnecessarily complexity ever > since. > > Since I can't think of a better idea than Melanie's proposal for > handling this code, I'll keep reviewing it with that approach in mind. Thanks for doing this archaeology. I didn't know the history of dobalance and hadn't looked into 1021bd6a89. I was a bit confused by why dobalance was false even if only table option cost delay is set and not table option cost limit. I think we can retain this behavior for now, but it may be worth re-examining in the future. On Wed, Mar 29, 2023 at 4:35=E2=80=AFAM Kyotaro Horiguchi wrote: > > At Wed, 29 Mar 2023 13:21:55 +0900 (JST), Kyotaro Horiguchi wrote in > > So, sorry for the noise. I'll review it while this into cnosideration. > > 0003: > > It's not this patche's fault, but I don't like the fact that the > variables used for GUC, VacuumCostDelay and VacuumCostLimit, are > updated outside the GUC mechanism. Also I don't like the incorrect > sorting of variables, where some working variables are referred to as > GUC parameters or vise versa. > > Although it's somewhat unrelated to the goal of this patch, I think we > should clean up the code tidy before proceeding. Shouldn't we separate > the actual parameters from the GUC base variables, and sort out the > all related variaghble? (something like the attached, on top of your > patch.) So, I agree we should separate the parameters used in the code from the GUC variables -- since there are multiple users with different needs (autovac workers, parallel vac workers, and vacuum). However, I was hesitant to tackle that here. I'm not sure how these changes will impact extensions that rely on these vacuum parameters and their direct relationship to the guc values. In your patch, you didn't update the parameter with the guc value of vacuum_cost_limit and vacuum_cost_delay, but were we to do so, we would need to make sure it was updated every time after a config reload. This isn't hard to do in the current code, but I'm not sure how we can ensure that future callers of ProcessConfigFile() in vacuum code always update these values afterward. Perhaps we could add some after_reload hook? Which does seem like a larger project. > I have some comments on 0003 as-is. > > + tab->at_relopt_vac_cost_limit =3D avopts ? > + avopts->vacuum_cost_limit : 0; > + tab->at_relopt_vac_cost_delay =3D avopts ? > + avopts->vacuum_cost_delay : -1; > > The value is not used when do_balance is false, so I don't see a > specific reason for these variables to be different when avopts is > null. Actually we need to set these to 0 and -1, because we set av_relopt_cost_limit and av_relopt_cost_delay with them and those values are checked regardless of wi_dobalance. We need to do this because we want to use the correct value to override VacuumCostLimit and VacuumCostDelay. wi_dobalance may be false because we have a table option cost delay but we have no table option cost limit. When we override VacuumCostDelay, we want to use the table option value but when we override VacuumCostLimit, we want to use the regular value. We need these initialized to values that will allow us to do that. > +autovac_recalculate_workers_for_balance(void) > +{ > + dlist_iter iter; > + int orig_nworkers_for_balance; > + int nworkers_for_balance =3D 0; > + > + if (autovacuum_vac_cost_delay =3D=3D 0 || > + (autovacuum_vac_cost_delay =3D=3D -1 && VacuumCostDelay = =3D=3D 0)) > return; > + if (autovacuum_vac_cost_limit <=3D 0 && VacuumCostLimit <=3D 0) > + return; > + > > I'm not quite sure how these conditions relate to the need to count > workers that shares the global I/O cost. Ah, this is a good point, we should still keep this number up-to-date even if the costs are disabled at the time we are checking it in case cost-based delays are re-enabled later before we recalculate this number. I had this code originally because autovac_balance_cost() would exit early if cost-based delays were disabled -- but this only worked because they couldn't be re-enabled during vacuuming a table and autovac_balance_cost() was called always in between vacuuming tables. I've removed these lines. And perhaps there is an argument for calling autovac_recalculate_workers_for_balance() in vacuum_delay_point() after reloading the config file... I have not done so in attached version. > (Though I still believe this funtion might not be necessary.) I don't see how we can do without this function. We need an up-to-date count of the number of autovacuum workers vacuuming tables which do not have vacuum cost-related table options. > + if (av_relopt_cost_limit > 0) > + VacuumCostLimit =3D av_relopt_cost_limit; > + else > + { > + av_base_cost_limit =3D autovacuum_vac_cost_limit > 0 ? > + autovacuum_vac_cost_limit : VacuumCostLimit; > + > + AutoVacuumBalanceLimit(); > > I think each worker should use MyWorkerInfo->wi_dobalance to identyify > whether the worker needs to use balanced cost values. Ah, there is a bug here. I have fixed it by making wi_dobalance an atomic flag so that we can check it before calling AutoVacuumBalanceLimit() (without taking a lock). I don't see other (non-test code) callers using atomic flags, so I can't tell if we need to loop to ensure that pg_atomic_test_set_flag() returns true. > +void > +AutoVacuumBalanceLimit(void) > > I'm not sure this function needs to be a separate function. We need to call it more often than we can call AutoVacuumUpdateLimit(), so the logic needs to be separate. Are you suggesting we inline the logic in the two places it is needed? v11 attached with updates mentioned above. - Melanie --00000000000020347705f80f706d Content-Type: text/x-patch; charset="US-ASCII"; name="v11-0003-Autovacuum-refreshes-cost-based-delay-params-mor.patch" Content-Disposition: attachment; filename="v11-0003-Autovacuum-refreshes-cost-based-delay-params-mor.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lfu3z0l02 RnJvbSBhMWRiMzAxYzEyMjY0MWFjZDI5N2EwNWQyOWJjYjMyYmM3Yjc2OWUyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBTYXQsIDI1IE1hciAyMDIzIDE0OjE0OjU1IC0wNDAwClN1YmplY3Q6IFtQ QVRDSCB2MTEgMy8zXSBBdXRvdmFjdXVtIHJlZnJlc2hlcyBjb3N0LWJhc2VkIGRlbGF5IHBhcmFt cyBtb3JlCiBvZnRlbgoKVGhlIHByZXZpb3VzIGNvbW1pdCBhbGxvd2VkIFZBQ1VVTSB0byByZWxv YWQgdGhlIGNvbmZpZyBmaWxlIG1vcmUgb2Z0ZW4Kc28gdGhhdCBjb3N0LWJhc2VkIGRlbGF5IHBh cmFtZXRlcnMgY291bGQgdGFrZSBlZmZlY3Qgd2hpbGUgVkFDVVVNaW5nIGEKcmVsYXRpb24uIEF1 dG92YWN1dW0sIGhvd2V2ZXIgZGlkIG5vdCBiZW5lZml0IGZyb20gdGhpcyBjaGFuZ2UuCgpJbiBv cmRlciBmb3IgYXV0b3ZhY3V1bSB3b3JrZXJzIHRvIHNhZmVseSB1cGRhdGUgdGhlaXIgb3duIGNv c3QgZGVsYXkKYW5kIGNvc3QgbGltaXQgcGFyYW1ldGVycyB3aXRob3V0IGltcGFjdGluZyBwZXJm b3JtYW5jZSwgd2UgaGFkIHRvCnJldGhpbmsgd2hlbiBhbmQgaG93IHRoZXNlIHZhbHVlcyB3ZXJl IGFjY2Vzc2VkLgoKUHJldmlvdXNseSwgYW4gYXV0b3ZhY3V1bSB3b3JrZXIncyB3aV9jb3N0X2xp bWl0IHdhcyBzZXQgb25seSBhdCB0aGUKYmVnaW5uaW5nIG9mIHZhY3V1bWluZyBhIHRhYmxlLCBh ZnRlciByZWxvYWRpbmcgdGhlIGNvbmZpZyBmaWxlLgpUaGVyZWZvcmUsIGF0IHRoZSB0aW1lIHRo YXQgYXV0b3ZhY19iYWxhbmNlX2Nvc3QoKSBpcyBjYWxsZWQsIHdvcmtlcnMKdmFjdXVtaW5nIHRh YmxlcyB3aXRoIG5vIHRhYmxlIG9wdGlvbnMgY291bGQgc3RpbGwgaGF2ZSBkaWZmZXJlbnQgdmFs dWVzCmZvciB0aGVpciB3aV9jb3N0X2xpbWl0X2Jhc2UgYW5kIHdpX2Nvc3RfZGVsYXkuCgpOb3cg dGhhdCB0aGUgY29zdCBwYXJhbWV0ZXJzIGNhbiBiZSB1cGRhdGVkIHdoaWxlIHZhY3V1bWluZyBh IHRhYmxlLAp3b3JrZXJzIHdpbGwgKHdpdGhpbiBzb21lIG1hcmdpbiBvZiBlcnJvcikgaGF2ZSBu byByZWFzb24gdG8gaGF2ZQpkaWZmZXJlbnQgdmFsdWVzIGZvciBjb3N0IGxpbWl0IGFuZCBjb3N0 IGRlbGF5IChpbiB0aGUgYWJzZW5jZSBvZiB0YWJsZQpvcHRpb25zKS4gVGhpcyByZW1vdmVzIHRo ZSByYXRpb25hbGUgZm9yIGtlZXBpbmcgY29zdCBsaW1pdCBhbmQgY29zdApkZWxheSBpbiBzaGFy ZWQgbWVtb3J5LiBCYWxhbmNpbmcgdGhlIGNvc3QgbGltaXQgcmVxdWlyZXMgb25seSB0aGUKbnVt YmVyIG9mIGFjdGl2ZSBhdXRvdmFjdXVtIHdvcmtlcnMgdmFjdXVtaW5nIGEgdGFibGUgd2l0aCBu byBjb3N0LWJhc2VkCnRhYmxlIG9wdGlvbnMuCgpSZXZpZXdlZC1ieTogS3lvdGFybyBIb3JpZ3Vj aGkgPGhvcmlreW90YS5udHRAZ21haWwuY29tPgotLS0KIHNyYy9iYWNrZW5kL2NvbW1hbmRzL3Zh Y3V1bS5jICAgICAgIHwgIDIyICsrLQogc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVt LmMgfCAyODYgKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0tLQogc3JjL2luY2x1ZGUvcG9zdG1h c3Rlci9hdXRvdmFjdXVtLmggfCAgIDIgKwogMyBmaWxlcyBjaGFuZ2VkLCAxNzUgaW5zZXJ0aW9u cygrKSwgMTM1IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2NvbW1hbmRz L3ZhY3V1bS5jIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMKaW5kZXggN2UzYThlNDA0 ZS4uZTliNjgzODA1YSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMK KysrIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMKQEAgLTIyNDEsMTAgKzIyNDEsMTAg QEAgdmFjdXVtX2RlbGF5X3BvaW50KHZvaWQpCiAKIAkvKgogCSAqIFJlbG9hZCB0aGUgY29uZmln dXJhdGlvbiBmaWxlIGlmIHJlcXVlc3RlZC4gVGhpcyBhbGxvd3MgY2hhbmdlcyB0bwotCSAqIHZh Y3V1bV9jb3N0X2xpbWl0IGFuZCB2YWN1dW1fY29zdF9kZWxheSB0byB0YWtlIGVmZmVjdCB3aGls ZSBhIHRhYmxlIGlzCi0JICogYmVpbmcgdmFjdXVtZWQgb3IgYW5hbHl6ZWQuIEFuYWx5emUgc2hv dWxkIG5vdCByZWxvYWQgY29uZmlndXJhdGlvbiBmaWxlCi0JICogaWYgaXQgaXMgaW4gYW4gb3V0 ZXIgdHJhbnNhY3Rpb24sIGFzIHdlIGN1cnJlbnRseSBvbmx5IGFsbG93Ci0JICogY29uZmlndXJh dGlvbiByZWxvYWQgd2hlbiBpbiB0b3AtbGV2ZWwgc3RhdGVtZW50cy4KKwkgKiBbYXV0b3ZhY3V1 bV9ddmFjdXVtX2Nvc3RfbGltaXQgYW5kIFthdXRvdmFjdXVtX112YWN1dW1fY29zdF9kZWxheSB0 bworCSAqIHRha2UgZWZmZWN0IHdoaWxlIGEgdGFibGUgaXMgYmVpbmcgdmFjdXVtZWQgb3IgYW5h bHl6ZWQuIEFuYWx5emUgc2hvdWxkCisJICogbm90IHJlbG9hZCBjb25maWd1cmF0aW9uIGZpbGUg aWYgaXQgaXMgaW4gYW4gb3V0ZXIgdHJhbnNhY3Rpb24sIGFzIHdlCisJICogY3VycmVudGx5IG9u bHkgYWxsb3cgY29uZmlndXJhdGlvbiByZWxvYWQgd2hlbiBpbiB0b3AtbGV2ZWwgc3RhdGVtZW50 cy4KIAkgKi8KIAlpZiAoQ29uZmlnUmVsb2FkUGVuZGluZyAmJiAhYW5hbHl6ZV9pbl9vdXRlcl94 YWN0KQogCXsKQEAgLTIyNTcsMTAgKzIyNTcsMTIgQEAgdmFjdXVtX2RlbGF5X3BvaW50KHZvaWQp CiAJCSAqIGJ5IHJlbG9hZC4KIAkJICovCiAJCUF1dG9WYWN1dW1VcGRhdGVEZWxheSgpOworCQlB dXRvVmFjdXVtVXBkYXRlTGltaXQoKTsKIAogCQkvKgogCQkgKiBJZiBjb25maWd1cmF0aW9uIGNo YW5nZXMgYXJlIGFsbG93ZWQgdG8gaW1wYWN0IFZhY3V1bUNvc3RJbmFjdGl2ZSwKLQkJICogbWFr ZSBzdXJlIGl0IGlzIHVwZGF0ZWQuCisJCSAqIG1ha2Ugc3VyZSBpdCBpcyB1cGRhdGVkLiBBdXRv dmFjdXVtIHdvcmtlcnMgd2lsbCBoYXZlIGFscmVhZHkgZG9uZQorCQkgKiB0aGlzIGluIEF1dG9W YWN1dW1VcGRhdGVEZWxheSgpCiAJCSAqLwogCQlpZiAoVmFjdXVtQ29zdEluYWN0aXZlID09IFZB Q1VVTV9DT1NUX0lOQUNUSVZFX0FORF9MT0NLRUQpCiAJCQlyZXR1cm47CkBAIC0yMzExLDggKzIz MTMsMTQgQEAgdmFjdXVtX2RlbGF5X3BvaW50KHZvaWQpCiAKIAkJVmFjdXVtQ29zdEJhbGFuY2Ug PSAwOwogCi0JCS8qIHVwZGF0ZSBiYWxhbmNlIHZhbHVlcyBmb3Igd29ya2VycyAqLwotCQlBdXRv VmFjdXVtVXBkYXRlRGVsYXkoKTsKKwkJLyoKKwkJICogQmFsYW5jZSBhbmQgdXBkYXRlIGxpbWl0 IHZhbHVlcyBmb3IgYXV0b3ZhY3V1bSB3b3JrZXJzLiBXZSBtdXN0CisJCSAqIGFsd2F5cyBkbyB0 aGlzIGluIGNhc2UgdGhlIGF1dG92YWN1dW0gbGF1bmNoZXIgb3IgYW5vdGhlcgorCQkgKiBhdXRv dmFjdXVtIHdvcmtlciBoYXMgcmVjYWxjdWxhdGVkIHRoZSBudW1iZXIgb2Ygd29ya2VycyBhY3Jv c3MKKwkJICogd2hpY2ggd2UgbXVzdCBiYWxhbmNlIHRoZSBsaW1pdC4gVGhpcyBpcyBkb25lIGJ5 IHRoZSBsYXVuY2hlciB3aGVuCisJCSAqIGxhdW5jaGluZyBhIG5ldyB3b3JrZXIgYW5kIGJ5IHdv cmtlcnMgYmVmb3JlIHZhY3V1bWluZyBlYWNoIHRhYmxlLgorCQkgKi8KKwkJQXV0b1ZhY3V1bUJh bGFuY2VMaW1pdCgpOwogCiAJCS8qIE1pZ2h0IGhhdmUgZ290dGVuIGFuIGludGVycnVwdCB3aGls ZSBzbGVlcGluZyAqLwogCQlDSEVDS19GT1JfSU5URVJSVVBUUygpOwpkaWZmIC0tZ2l0IGEvc3Jj L2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMgYi9zcmMvYmFja2VuZC9wb3N0bWFzdGVy L2F1dG92YWN1dW0uYwppbmRleCA1ODVkMjgxNDhjLi45Nzc1NzY0ZmM0IDEwMDY0NAotLS0gYS9z cmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYworKysgYi9zcmMvYmFja2VuZC9wb3N0 bWFzdGVyL2F1dG92YWN1dW0uYwpAQCAtMTM5LDYgKzEzOSwxMCBAQCBpbnQJCQlMb2dfYXV0b3Zh Y3V1bV9taW5fZHVyYXRpb24gPSA2MDAwMDA7CiBzdGF0aWMgYm9vbCBhbV9hdXRvdmFjdXVtX2xh dW5jaGVyID0gZmFsc2U7CiBzdGF0aWMgYm9vbCBhbV9hdXRvdmFjdXVtX3dvcmtlciA9IGZhbHNl OwogCitzdGF0aWMgZG91YmxlIGF2X3JlbG9wdF9jb3N0X2RlbGF5ID0gLTE7CitzdGF0aWMgaW50 CWF2X3JlbG9wdF9jb3N0X2xpbWl0ID0gMDsKK3N0YXRpYyBpbnQJYXZfYmFzZV9jb3N0X2xpbWl0 ID0gMDsKKwogLyogRmxhZ3Mgc2V0IGJ5IHNpZ25hbCBoYW5kbGVycyAqLwogc3RhdGljIHZvbGF0 aWxlIHNpZ19hdG9taWNfdCBnb3RfU0lHVVNSMiA9IGZhbHNlOwogCkBAIC0xODksOCArMTkzLDgg QEAgdHlwZWRlZiBzdHJ1Y3QgYXV0b3ZhY190YWJsZQogewogCU9pZAkJCWF0X3JlbGlkOwogCVZh Y3V1bVBhcmFtcyBhdF9wYXJhbXM7Ci0JZG91YmxlCQlhdF92YWN1dW1fY29zdF9kZWxheTsKLQlp bnQJCQlhdF92YWN1dW1fY29zdF9saW1pdDsKKwlkb3VibGUJCWF0X3JlbG9wdF92YWNfY29zdF9k ZWxheTsKKwlpbnQJCQlhdF9yZWxvcHRfdmFjX2Nvc3RfbGltaXQ7CiAJYm9vbAkJYXRfZG9iYWxh bmNlOwogCWJvb2wJCWF0X3NoYXJlZHJlbDsKIAljaGFyCSAgICphdF9yZWxuYW1lOwpAQCAtMjA5 LDcgKzIxMyw3IEBAIHR5cGVkZWYgc3RydWN0IGF1dG92YWNfdGFibGUKICAqIHdpX3NoYXJlZHJl bCBmbGFnIGluZGljYXRpbmcgd2hldGhlciB0YWJsZSBpcyBtYXJrZWQgcmVsaXNzaGFyZWQKICAq IHdpX3Byb2MJCXBvaW50ZXIgdG8gUEdQUk9DIG9mIHRoZSBydW5uaW5nIHdvcmtlciwgTlVMTCBp ZiBub3Qgc3RhcnRlZAogICogd2lfbGF1bmNodGltZSBUaW1lIGF0IHdoaWNoIHRoaXMgd29ya2Vy IHdhcyBsYXVuY2hlZAotICogd2lfY29zdF8qCVZhY3V1bSBjb3N0LWJhc2VkIGRlbGF5IHBhcmFt ZXRlcnMgY3VycmVudCBpbiB0aGlzIHdvcmtlcgorICogd2lfZG9iYWxhbmNlIFdoZXRoZXIgdGhp cyB3b3JrZXIgc2hvdWxkIGJlIGluY2x1ZGVkIGluIGJhbGFuY2UgY2FsY3VsYXRpb25zCiAgKgog ICogQWxsIGZpZWxkcyBhcmUgcHJvdGVjdGVkIGJ5IEF1dG92YWN1dW1Mb2NrLCBleGNlcHQgZm9y IHdpX3RhYmxlb2lkIGFuZAogICogd2lfc2hhcmVkcmVsIHdoaWNoIGFyZSBwcm90ZWN0ZWQgYnkg QXV0b3ZhY3V1bVNjaGVkdWxlTG9jayAobm90ZSB0aGVzZQpAQCAtMjIzLDExICsyMjcsOCBAQCB0 eXBlZGVmIHN0cnVjdCBXb3JrZXJJbmZvRGF0YQogCU9pZAkJCXdpX3RhYmxlb2lkOwogCVBHUFJP QwkgICAqd2lfcHJvYzsKIAlUaW1lc3RhbXBUeiB3aV9sYXVuY2h0aW1lOwotCWJvb2wJCXdpX2Rv YmFsYW5jZTsKKwlwZ19hdG9taWNfZmxhZyB3aV9kb2JhbGFuY2U7CiAJYm9vbAkJd2lfc2hhcmVk cmVsOwotCWRvdWJsZQkJd2lfY29zdF9kZWxheTsKLQlpbnQJCQl3aV9jb3N0X2xpbWl0OwotCWlu dAkJCXdpX2Nvc3RfbGltaXRfYmFzZTsKIH0gV29ya2VySW5mb0RhdGE7CiAKIHR5cGVkZWYgc3Ry dWN0IFdvcmtlckluZm9EYXRhICpXb3JrZXJJbmZvOwpAQCAtMjczLDYgKzI3NCw4IEBAIHR5cGVk ZWYgc3RydWN0IEF1dG9WYWN1dW1Xb3JrSXRlbQogICogYXZfc3RhcnRpbmdXb3JrZXIgcG9pbnRl ciB0byBXb3JrZXJJbmZvIGN1cnJlbnRseSBiZWluZyBzdGFydGVkIChjbGVhcmVkIGJ5CiAgKgkJ CQkJdGhlIHdvcmtlciBpdHNlbGYgYXMgc29vbiBhcyBpdCdzIHVwIGFuZCBydW5uaW5nKQogICog YXZfd29ya0l0ZW1zCQl3b3JrIGl0ZW0gYXJyYXkKKyAqIGF2X253b3JrZXJzRm9yQmFsYW5jZSB0 aGUgbnVtYmVyIG9mIGF1dG92YWN1dW0gd29ya2VycyB0byB1c2Ugd2hlbgorICogCQkJCQljYWxj dWxhdGluZyB0aGUgcGVyIHdvcmtlciBjb3N0IGxpbWl0CiAgKgogICogVGhpcyBzdHJ1Y3QgaXMg cHJvdGVjdGVkIGJ5IEF1dG92YWN1dW1Mb2NrLCBleGNlcHQgZm9yIGF2X3NpZ25hbCBhbmQgcGFy dHMKICAqIG9mIHRoZSB3b3JrZXIgbGlzdCAoc2VlIGFib3ZlKS4KQEAgLTI4Niw2ICsyODksNyBA QCB0eXBlZGVmIHN0cnVjdAogCWRsaXN0X2hlYWQJYXZfcnVubmluZ1dvcmtlcnM7CiAJV29ya2Vy SW5mbwlhdl9zdGFydGluZ1dvcmtlcjsKIAlBdXRvVmFjdXVtV29ya0l0ZW0gYXZfd29ya0l0ZW1z W05VTV9XT1JLSVRFTVNdOworCXBnX2F0b21pY191aW50MzIgYXZfbndvcmtlcnNGb3JCYWxhbmNl OwogfSBBdXRvVmFjdXVtU2htZW1TdHJ1Y3Q7CiAKIHN0YXRpYyBBdXRvVmFjdXVtU2htZW1TdHJ1 Y3QgKkF1dG9WYWN1dW1TaG1lbTsKQEAgLTMxOSw3ICszMjMsNyBAQCBzdGF0aWMgdm9pZCBsYXVu Y2hfd29ya2VyKFRpbWVzdGFtcFR6IG5vdyk7CiBzdGF0aWMgTGlzdCAqZ2V0X2RhdGFiYXNlX2xp c3Qodm9pZCk7CiBzdGF0aWMgdm9pZCByZWJ1aWxkX2RhdGFiYXNlX2xpc3QoT2lkIG5ld2RiKTsK IHN0YXRpYyBpbnQJZGJfY29tcGFyYXRvcihjb25zdCB2b2lkICphLCBjb25zdCB2b2lkICpiKTsK LXN0YXRpYyB2b2lkIGF1dG92YWNfYmFsYW5jZV9jb3N0KHZvaWQpOworc3RhdGljIHZvaWQgYXV0 b3ZhY19yZWNhbGN1bGF0ZV93b3JrZXJzX2Zvcl9iYWxhbmNlKHZvaWQpOwogCiBzdGF0aWMgdm9p ZCBkb19hdXRvdmFjdXVtKHZvaWQpOwogc3RhdGljIHZvaWQgRnJlZVdvcmtlckluZm8oaW50IGNv ZGUsIERhdHVtIGFyZyk7CkBAIC02NzAsNyArNjc0LDcgQEAgQXV0b1ZhY0xhdW5jaGVyTWFpbihp bnQgYXJnYywgY2hhciAqYXJndltdKQogCQkJewogCQkJCUxXTG9ja0FjcXVpcmUoQXV0b3ZhY3V1 bUxvY2ssIExXX0VYQ0xVU0lWRSk7CiAJCQkJQXV0b1ZhY3V1bVNobWVtLT5hdl9zaWduYWxbQXV0 b1ZhY1JlYmFsYW5jZV0gPSBmYWxzZTsKLQkJCQlhdXRvdmFjX2JhbGFuY2VfY29zdCgpOworCQkJ CWF1dG92YWNfcmVjYWxjdWxhdGVfd29ya2Vyc19mb3JfYmFsYW5jZSgpOwogCQkJCUxXTG9ja1Jl bGVhc2UoQXV0b3ZhY3V1bUxvY2spOwogCQkJfQogCkBAIC04MjAsOCArODI0LDggQEAgSGFuZGxl QXV0b1ZhY0xhdW5jaGVySW50ZXJydXB0cyh2b2lkKQogCQkJQXV0b1ZhY0xhdW5jaGVyU2h1dGRv d24oKTsKIAogCQkvKiByZWJhbGFuY2UgaW4gY2FzZSB0aGUgZGVmYXVsdCBjb3N0IHBhcmFtZXRl cnMgY2hhbmdlZCAqLwotCQlMV0xvY2tBY3F1aXJlKEF1dG92YWN1dW1Mb2NrLCBMV19FWENMVVNJ VkUpOwotCQlhdXRvdmFjX2JhbGFuY2VfY29zdCgpOworCQlMV0xvY2tBY3F1aXJlKEF1dG92YWN1 dW1Mb2NrLCBMV19TSEFSRUQpOworCQlhdXRvdmFjX3JlY2FsY3VsYXRlX3dvcmtlcnNfZm9yX2Jh bGFuY2UoKTsKIAkJTFdMb2NrUmVsZWFzZShBdXRvdmFjdXVtTG9jayk7CiAKIAkJLyogcmVidWls ZCB0aGUgbGlzdCBpbiBjYXNlIHRoZSBuYXB0aW1lIGNoYW5nZWQgKi8KQEAgLTE3NTUsMTAgKzE3 NTksNyBAQCBGcmVlV29ya2VySW5mbyhpbnQgY29kZSwgRGF0dW0gYXJnKQogCQlNeVdvcmtlcklu Zm8tPndpX3NoYXJlZHJlbCA9IGZhbHNlOwogCQlNeVdvcmtlckluZm8tPndpX3Byb2MgPSBOVUxM OwogCQlNeVdvcmtlckluZm8tPndpX2xhdW5jaHRpbWUgPSAwOwotCQlNeVdvcmtlckluZm8tPndp X2RvYmFsYW5jZSA9IGZhbHNlOwotCQlNeVdvcmtlckluZm8tPndpX2Nvc3RfZGVsYXkgPSAwOwot CQlNeVdvcmtlckluZm8tPndpX2Nvc3RfbGltaXQgPSAwOwotCQlNeVdvcmtlckluZm8tPndpX2Nv c3RfbGltaXRfYmFzZSA9IDA7CisJCXBnX2F0b21pY19jbGVhcl9mbGFnKCZNeVdvcmtlckluZm8t PndpX2RvYmFsYW5jZSk7CiAJCWRsaXN0X3B1c2hfaGVhZCgmQXV0b1ZhY3V1bVNobWVtLT5hdl9m cmVlV29ya2VycywKIAkJCQkJCSZNeVdvcmtlckluZm8tPndpX2xpbmtzKTsKIAkJLyogbm90IG1p bmUgYW55bW9yZSAqLwpAQCAtMTc3MywxMDAgKzE3NzQsMTQwIEBAIEZyZWVXb3JrZXJJbmZvKGlu dCBjb2RlLCBEYXR1bSBhcmcpCiAJfQogfQogCisKIC8qCi0gKiBVcGRhdGUgdGhlIGNvc3QtYmFz ZWQgZGVsYXkgcGFyYW1ldGVycywgc28gdGhhdCBtdWx0aXBsZSB3b3JrZXJzIGNvbnN1bWUKLSAq IGVhY2ggYSBmcmFjdGlvbiBvZiB0aGUgdG90YWwgYXZhaWxhYmxlIEkvTy4KKyAqIFVwZGF0ZSBW YWN1dW1Db3N0RGVsYXkgd2l0aCB0aGUgY29ycmVjdCB2YWx1ZSBmb3IgYW4gYXV0b3ZhY3V1bSB3 b3JrZXIsCisgKiBnaXZlbiB0aGUgdmFsdWUgb2Ygb3RoZXIgcmVsZXZhbnQgY29zdC1iYXNlZCBk ZWxheSBwYXJhbWV0ZXJzLiBBdXRvdmFjdXVtCisgKiB3b3JrZXJzIHNob3VsZCBjYWxsIHRoaXMg YWZ0ZXIgZXZlcnkgY29uZmlnIHJlbG9hZCwgaW4gY2FzZSBWYWN1dW1Db3N0RGVsYXkKKyAqIHdh cyBvdmVyd3JpdHRlbi4KICAqLwogdm9pZAogQXV0b1ZhY3V1bVVwZGF0ZURlbGF5KHZvaWQpCiB7 Ci0JaWYgKE15V29ya2VySW5mbykKKwlpZiAoIWFtX2F1dG92YWN1dW1fd29ya2VyKQorCQlyZXR1 cm47CisKKwlpZiAoYXZfcmVsb3B0X2Nvc3RfZGVsYXkgPj0gMCkKKwkJVmFjdXVtQ29zdERlbGF5 ID0gYXZfcmVsb3B0X2Nvc3RfZGVsYXk7CisJZWxzZSBpZiAoYXV0b3ZhY3V1bV92YWNfY29zdF9k ZWxheSA+PSAwKQorCQlWYWN1dW1Db3N0RGVsYXkgPSBhdXRvdmFjdXVtX3ZhY19jb3N0X2RlbGF5 OworCisJLyoKKwkgKiBJZiBjb25maWd1cmF0aW9uIGNoYW5nZXMgYXJlIGFsbG93ZWQgdG8gaW1w YWN0IFZhY3V1bUNvc3RJbmFjdGl2ZSwgbWFrZQorCSAqIHN1cmUgaXQgaXMgdXBkYXRlZC4KKwkg Ki8KKwlpZiAoVmFjdXVtQ29zdEluYWN0aXZlID09IFZBQ1VVTV9DT1NUX0lOQUNUSVZFX0FORF9M T0NLRUQpCisJCXJldHVybjsKKworCWlmIChWYWN1dW1Db3N0RGVsYXkgPiAwKQorCQlWYWN1dW1D b3N0SW5hY3RpdmUgPSBWQUNVVU1fQ09TVF9BQ1RJVkU7CisJZWxzZQogCXsKLQkJVmFjdXVtQ29z dERlbGF5ID0gTXlXb3JrZXJJbmZvLT53aV9jb3N0X2RlbGF5OwotCQlWYWN1dW1Db3N0TGltaXQg PSBNeVdvcmtlckluZm8tPndpX2Nvc3RfbGltaXQ7CisJCVZhY3V1bUNvc3RJbmFjdGl2ZSA9IFZB Q1VVTV9DT1NUX0lOQUNUSVZFX0FORF9VTkxPQ0tFRDsKKwkJVmFjdXVtQ29zdEJhbGFuY2UgPSAw OwogCX0KIH0KIAorCiAvKgotICogYXV0b3ZhY19iYWxhbmNlX2Nvc3QKLSAqCQlSZWNhbGN1bGF0 ZSB0aGUgY29zdCBsaW1pdCBzZXR0aW5nIGZvciBlYWNoIGFjdGl2ZSB3b3JrZXIuCi0gKgotICog Q2FsbGVyIG11c3QgaG9sZCB0aGUgQXV0b3ZhY3V1bUxvY2sgaW4gZXhjbHVzaXZlIG1vZGUuCisg KiBUaGlzIG11c3QgYmUgY2FsbGVkIGRpcmVjdGx5IGFmdGVyIGEgY29uZmlnIHJlbG9hZCBiZWZv cmUgdXNpbmcgdGhlIHZhbHVlIG9mCisgKiBWYWN1dW1Db3N0TGltaXQgYW5kIGJlZm9yZSBjYWxs aW5nIEF1dG9WYWN1dW1CYWxhbmNlTGltaXQoKSwgYXMgaXQgdXNlcyB0aGUKKyAqIHZhbHVlIG9m IFZhY3V1bUNvc3RMaW1pdCB0byBkZXRlcm1pbmUgd2hhdCB0aGUgYmFzZSBhdl9iYXNlX2Nvc3Rf bGltaXQKKyAqIHNob3VsZCBiZS4gQXV0b1ZhY3V1bUJhbGFuY2VMaW1pdCgpIHdpbGwgb3ZlcnJp ZGUgdGhlIHZhbHVlIG9mCisgKiBWYWN1dW1Db3N0TGltaXQsIHNvIGNhbGxpbmcgaXQgbXVsdGlw bGUgdGltZXMgYWZ0ZXIgYSBjb25maWcgcmVsb2FkIGlzCisgKiBpbmNvcnJlY3QuCiAgKi8KLXN0 YXRpYyB2b2lkCi1hdXRvdmFjX2JhbGFuY2VfY29zdCh2b2lkKQordm9pZAorQXV0b1ZhY3V1bVVw ZGF0ZUxpbWl0KHZvaWQpCiB7CisJaWYgKCFhbV9hdXRvdmFjdXVtX3dvcmtlcikKKwkJcmV0dXJu OworCiAJLyoKLQkgKiBUaGUgaWRlYSBoZXJlIGlzIHRoYXQgd2UgcmF0aW9uIG91dCBJL08gZXF1 YWxseS4gIFRoZSBhbW91bnQgb2YgSS9PCi0JICogdGhhdCBhIHdvcmtlciBjYW4gY29uc3VtZSBp cyBkZXRlcm1pbmVkIGJ5IGNvc3RfbGltaXQvY29zdF9kZWxheSwgc28gd2UKLQkgKiB0cnkgdG8g ZXF1YWxpemUgdGhvc2UgcmF0aW9zIHJhdGhlciB0aGFuIHRoZSByYXcgbGltaXQgc2V0dGluZ3Mu Ci0JICoKIAkgKiBub3RlOiBpbiBjb3N0X2xpbWl0LCB6ZXJvIGFsc28gbWVhbnMgdXNlIHZhbHVl IGZyb20gZWxzZXdoZXJlLCBiZWNhdXNlCiAJICogemVybyBpcyBub3QgYSB2YWxpZCB2YWx1ZS4K IAkgKi8KLQlpbnQJCQl2YWNfY29zdF9saW1pdCA9IChhdXRvdmFjdXVtX3ZhY19jb3N0X2xpbWl0 ID4gMCA/Ci0JCQkJCQkJCSAgYXV0b3ZhY3V1bV92YWNfY29zdF9saW1pdCA6IFZhY3V1bUNvc3RM aW1pdCk7Ci0JZG91YmxlCQl2YWNfY29zdF9kZWxheSA9IChhdXRvdmFjdXVtX3ZhY19jb3N0X2Rl bGF5ID49IDAgPwotCQkJCQkJCQkgIGF1dG92YWN1dW1fdmFjX2Nvc3RfZGVsYXkgOiBWYWN1dW1D b3N0RGVsYXkpOwotCWRvdWJsZQkJY29zdF90b3RhbDsKLQlkb3VibGUJCWNvc3RfYXZhaWw7Ci0J ZGxpc3RfaXRlcglpdGVyOwotCi0JLyogbm90IHNldD8gbm90aGluZyB0byBkbyAqLwotCWlmICh2 YWNfY29zdF9saW1pdCA8PSAwIHx8IHZhY19jb3N0X2RlbGF5IDw9IDApCi0JCXJldHVybjsKLQot CS8qIGNhbGN1bGF0ZSB0aGUgdG90YWwgYmFzZSBjb3N0IGxpbWl0IG9mIHBhcnRpY2lwYXRpbmcg YWN0aXZlIHdvcmtlcnMgKi8KLQljb3N0X3RvdGFsID0gMC4wOwotCWRsaXN0X2ZvcmVhY2goaXRl ciwgJkF1dG9WYWN1dW1TaG1lbS0+YXZfcnVubmluZ1dvcmtlcnMpCisJaWYgKGF2X3JlbG9wdF9j b3N0X2xpbWl0ID4gMCkKKwkJVmFjdXVtQ29zdExpbWl0ID0gYXZfcmVsb3B0X2Nvc3RfbGltaXQ7 CisJZWxzZQogCXsKLQkJV29ya2VySW5mbwl3b3JrZXIgPSBkbGlzdF9jb250YWluZXIoV29ya2Vy SW5mb0RhdGEsIHdpX2xpbmtzLCBpdGVyLmN1cik7CisJCWF2X2Jhc2VfY29zdF9saW1pdCA9IGF1 dG92YWN1dW1fdmFjX2Nvc3RfbGltaXQgPiAwID8KKwkJCWF1dG92YWN1dW1fdmFjX2Nvc3RfbGlt aXQgOiBWYWN1dW1Db3N0TGltaXQ7CiAKLQkJaWYgKHdvcmtlci0+d2lfcHJvYyAhPSBOVUxMICYm Ci0JCQl3b3JrZXItPndpX2RvYmFsYW5jZSAmJgotCQkJd29ya2VyLT53aV9jb3N0X2xpbWl0X2Jh c2UgPiAwICYmIHdvcmtlci0+d2lfY29zdF9kZWxheSA+IDApCi0JCQljb3N0X3RvdGFsICs9Ci0J CQkJKGRvdWJsZSkgd29ya2VyLT53aV9jb3N0X2xpbWl0X2Jhc2UgLyB3b3JrZXItPndpX2Nvc3Rf ZGVsYXk7CisJCUF1dG9WYWN1dW1CYWxhbmNlTGltaXQoKTsKIAl9Cit9CiAKLQkvKiB0aGVyZSBh cmUgbm8gY29zdCBsaW1pdHMgLS0gbm90aGluZyB0byBkbyAqLwotCWlmIChjb3N0X3RvdGFsIDw9 IDApCisvKgorICogVXBkYXRlIFZhY3V1bUNvc3RMaW1pdCB3aXRoIHRoZSBjb3JyZWN0IHZhbHVl IGZvciBhbiBhdXRvdmFjdXVtIHdvcmtlciwKKyAqIGdpdmVuIHRoZSB2YWx1ZSBvZiBvdGhlciBy ZWxldmFudCBjb3N0IGxpbWl0IHBhcmFtZXRlcnMgYW5kIHRoZSBudW1iZXIgb2YKKyAqIHdvcmtl cnMgYWNyb3NzIHdoaWNoIHRoZSBsaW1pdCBtdXN0IGJlIGJhbGFuY2VkLiBBdXRvdmFjdXVtIHdv cmtlcnMgbXVzdAorICogY2FsbCB0aGlzIHJlZ3VsYXJseSBpbiBjYXNlIGF2X253b3JrZXJzX2Zv cl9iYWxhbmNlIGhhcyBiZWVuIHVwZGF0ZWQgYnkKKyAqIGFub3RoZXIgd29ya2VyIG9yIGJ5IHRo ZSBhdXRvdmFjdXVtIGxhdW5jaGVyLiBBZnRlciBhIGNvbmZpZyByZWxvYWQsIHRoZXkKKyAqIG11 c3QgY2FsbCBBdXRvVmFjdXVtVXBkYXRlTGltaXQoKSB3aGljaCB3aWxsIGNhbGwgQXV0b1ZhY3V1 bUJhbGFuY2VMaW1pdCgpLAorICogaW4gY2FzZSBWYWN1dW1Db3N0TGltaXQgd2FzIG92ZXJ3cml0 dGVuLgorICovCit2b2lkCitBdXRvVmFjdXVtQmFsYW5jZUxpbWl0KHZvaWQpCit7CisJaW50CQkJ bndvcmtlcnNfZm9yX2JhbGFuY2U7CisJaW50CQkJdG90YWxfY29zdF9saW1pdDsKKwlpbnQJCQli YWxhbmNlZF9jb3N0X2xpbWl0OworCisJaWYgKCFNeVdvcmtlckluZm8pCiAJCXJldHVybjsKIAot CS8qCi0JICogQWRqdXN0IGNvc3QgbGltaXQgb2YgZWFjaCBhY3RpdmUgd29ya2VyIHRvIGJhbGFu Y2UgdGhlIHRvdGFsIG9mIGNvc3QKLQkgKiBsaW1pdCB0byBhdXRvdmFjdXVtX3ZhY3V1bV9jb3N0 X2xpbWl0LgotCSAqLwotCWNvc3RfYXZhaWwgPSAoZG91YmxlKSB2YWNfY29zdF9saW1pdCAvIHZh Y19jb3N0X2RlbGF5OworCWlmIChwZ19hdG9taWNfdW5sb2NrZWRfdGVzdF9mbGFnKCZNeVdvcmtl ckluZm8tPndpX2RvYmFsYW5jZSkpCisJCXJldHVybjsKKworCUFzc2VydChhdl9iYXNlX2Nvc3Rf bGltaXQgPiAwKTsKKworCW53b3JrZXJzX2Zvcl9iYWxhbmNlID0gcGdfYXRvbWljX3JlYWRfdTMy KAorCQkJCQkJCSZBdXRvVmFjdXVtU2htZW0tPmF2X253b3JrZXJzRm9yQmFsYW5jZSk7CisKKwkv KiBUaGVyZSBpcyBhdCBsZWFzdCAxIGF1dG92YWMgd29ya2VyICh0aGlzIHdvcmtlcikuICovCisJ QXNzZXJ0KG53b3JrZXJzX2Zvcl9iYWxhbmNlID4gMCk7CisKKwl0b3RhbF9jb3N0X2xpbWl0ID0g YXV0b3ZhY3V1bV92YWNfY29zdF9saW1pdCA+IDAgPworCQlhdXRvdmFjdXVtX3ZhY19jb3N0X2xp bWl0IDogYXZfYmFzZV9jb3N0X2xpbWl0OworCisJYmFsYW5jZWRfY29zdF9saW1pdCA9IHRvdGFs X2Nvc3RfbGltaXQgLyBud29ya2Vyc19mb3JfYmFsYW5jZTsKKworCVZhY3V1bUNvc3RMaW1pdCA9 IE1heChNaW4oYmFsYW5jZWRfY29zdF9saW1pdCwgdG90YWxfY29zdF9saW1pdCksIDEpOworfQor CisvKgorICogYXV0b3ZhY19yZWNhbGN1bGF0ZV93b3JrZXJzX2Zvcl9iYWxhbmNlCisgKgkJUmVj YWxjdWxhdGUgdGhlIG51bWJlciBvZiB3b3JrZXJzIHRvIGNvbnNpZGVyLCBnaXZlbiB0YWJsZSBv cHRpb25zIGFuZAorICoJCXRoZSBjdXJyZW50IG51bWJlciBvZiBhY3RpdmUgd29ya2Vycy4KKyAq CisgKiBDYWxsZXIgbXVzdCBob2xkIHRoZSBBdXRvdmFjdXVtTG9jayBpbiBhdCBsZWFzdCBzaGFy ZWQgbW9kZSB0byBhY2Nlc3MKKyAqIHdvcmtlci0+d2lfcHJvYy4KKyAqLworc3RhdGljIHZvaWQK K2F1dG92YWNfcmVjYWxjdWxhdGVfd29ya2Vyc19mb3JfYmFsYW5jZSh2b2lkKQoreworCWRsaXN0 X2l0ZXIJaXRlcjsKKwlpbnQJCQlvcmlnX253b3JrZXJzX2Zvcl9iYWxhbmNlOworCWludAkJCW53 b3JrZXJzX2Zvcl9iYWxhbmNlID0gMDsKKworCW9yaWdfbndvcmtlcnNfZm9yX2JhbGFuY2UgPQor CQlwZ19hdG9taWNfcmVhZF91MzIoJkF1dG9WYWN1dW1TaG1lbS0+YXZfbndvcmtlcnNGb3JCYWxh bmNlKTsKKwogCWRsaXN0X2ZvcmVhY2goaXRlciwgJkF1dG9WYWN1dW1TaG1lbS0+YXZfcnVubmlu Z1dvcmtlcnMpCiAJewogCQlXb3JrZXJJbmZvCXdvcmtlciA9IGRsaXN0X2NvbnRhaW5lcihXb3Jr ZXJJbmZvRGF0YSwgd2lfbGlua3MsIGl0ZXIuY3VyKTsKIAotCQlpZiAod29ya2VyLT53aV9wcm9j ICE9IE5VTEwgJiYKLQkJCXdvcmtlci0+d2lfZG9iYWxhbmNlICYmCi0JCQl3b3JrZXItPndpX2Nv c3RfbGltaXRfYmFzZSA+IDAgJiYgd29ya2VyLT53aV9jb3N0X2RlbGF5ID4gMCkKLQkJewotCQkJ aW50CQkJbGltaXQgPSAoaW50KQotCQkJKGNvc3RfYXZhaWwgKiB3b3JrZXItPndpX2Nvc3RfbGlt aXRfYmFzZSAvIGNvc3RfdG90YWwpOwotCi0JCQkvKgotCQkJICogV2UgcHV0IGEgbG93ZXIgYm91 bmQgb2YgMSBvbiB0aGUgY29zdF9saW1pdCwgdG8gYXZvaWQgZGl2aXNpb24tCi0JCQkgKiBieS16 ZXJvIGluIHRoZSB2YWN1dW0gY29kZS4gIEFsc28sIGluIGNhc2Ugb2Ygcm91bmRvZmYgdHJvdWJs ZQotCQkJICogaW4gdGhlc2UgY2FsY3VsYXRpb25zLCBsZXQncyBiZSBzdXJlIHdlIGRvbid0IGV2 ZXIgc2V0Ci0JCQkgKiBjb3N0X2xpbWl0IHRvIG1vcmUgdGhhbiB0aGUgYmFzZSB2YWx1ZS4KLQkJ CSAqLwotCQkJd29ya2VyLT53aV9jb3N0X2xpbWl0ID0gTWF4KE1pbihsaW1pdCwKLQkJCQkJCQkJ CQkJd29ya2VyLT53aV9jb3N0X2xpbWl0X2Jhc2UpLAotCQkJCQkJCQkJCTEpOwotCQl9CisJCWlm ICh3b3JrZXItPndpX3Byb2MgPT0gTlVMTCB8fAorCQkJcGdfYXRvbWljX3VubG9ja2VkX3Rlc3Rf ZmxhZygmd29ya2VyLT53aV9kb2JhbGFuY2UpKQorCQkJY29udGludWU7CiAKLQkJaWYgKHdvcmtl ci0+d2lfcHJvYyAhPSBOVUxMKQotCQkJZWxvZyhERUJVRzIsICJhdXRvdmFjX2JhbGFuY2VfY29z dChwaWQ9JWQgZGI9JXUsIHJlbD0ldSwgZG9iYWxhbmNlPSVzIGNvc3RfbGltaXQ9JWQsIGNvc3Rf bGltaXRfYmFzZT0lZCwgY29zdF9kZWxheT0lZykiLAotCQkJCSB3b3JrZXItPndpX3Byb2MtPnBp ZCwgd29ya2VyLT53aV9kYm9pZCwgd29ya2VyLT53aV90YWJsZW9pZCwKLQkJCQkgd29ya2VyLT53 aV9kb2JhbGFuY2UgPyAieWVzIiA6ICJubyIsCi0JCQkJIHdvcmtlci0+d2lfY29zdF9saW1pdCwg d29ya2VyLT53aV9jb3N0X2xpbWl0X2Jhc2UsCi0JCQkJIHdvcmtlci0+d2lfY29zdF9kZWxheSk7 CisJCW53b3JrZXJzX2Zvcl9iYWxhbmNlKys7CiAJfQorCisJaWYgKG53b3JrZXJzX2Zvcl9iYWxh bmNlICE9IG9yaWdfbndvcmtlcnNfZm9yX2JhbGFuY2UpCisJCXBnX2F0b21pY193cml0ZV91MzIo JkF1dG9WYWN1dW1TaG1lbS0+YXZfbndvcmtlcnNGb3JCYWxhbmNlLAorCQkJCQkJCW53b3JrZXJz X2Zvcl9iYWxhbmNlKTsKIH0KIAogLyoKQEAgLTIzMTIsOCArMjM1Myw2IEBAIGRvX2F1dG92YWN1 dW0odm9pZCkKIAkJYXV0b3ZhY190YWJsZSAqdGFiOwogCQlib29sCQlpc3NoYXJlZDsKIAkJYm9v bAkJc2tpcGl0OwotCQlkb3VibGUJCXN0ZFZhY3V1bUNvc3REZWxheTsKLQkJaW50CQkJc3RkVmFj dXVtQ29zdExpbWl0OwogCQlkbGlzdF9pdGVyCWl0ZXI7CiAKIAkJQ0hFQ0tfRk9SX0lOVEVSUlVQ VFMoKTsKQEAgLTI0MTcsMzAgKzI0NTYsMjkgQEAgZG9fYXV0b3ZhY3V1bSh2b2lkKQogCQl9CiAK IAkJLyoKLQkJICogUmVtZW1iZXIgdGhlIHByZXZhaWxpbmcgdmFsdWVzIG9mIHRoZSB2YWN1dW0g Y29zdCBHVUNzLiAgV2UgaGF2ZSB0bwotCQkgKiByZXN0b3JlIHRoZXNlIGF0IHRoZSBib3R0b20g b2YgdGhlIGxvb3AsIGVsc2Ugd2UnbGwgY29tcHV0ZSB3cm9uZwotCQkgKiB2YWx1ZXMgaW4gdGhl IG5leHQgaXRlcmF0aW9uIG9mIGF1dG92YWNfYmFsYW5jZV9jb3N0KCkuCisJCSAqIFNhdmUgdGhl IGNvc3QtcmVsYXRlZCB0YWJsZSBvcHRpb25zIGluIGdsb2JhbCB2YXJpYWJsZXMgZm9yCisJCSAq IHJlZmVyZW5jZSB3aGVuIHVwZGF0aW5nIFZhY3V1bUNvc3RMaW1pdCBhbmQgVmFjdXVtQ29zdERl bGF5IGR1cmluZworCQkgKiB2YWN1dW1pbmcgdGhpcyB0YWJsZS4KIAkJICovCi0JCXN0ZFZhY3V1 bUNvc3REZWxheSA9IFZhY3V1bUNvc3REZWxheTsKLQkJc3RkVmFjdXVtQ29zdExpbWl0ID0gVmFj dXVtQ29zdExpbWl0OworCQlhdl9yZWxvcHRfY29zdF9saW1pdCA9IHRhYi0+YXRfcmVsb3B0X3Zh Y19jb3N0X2xpbWl0OworCQlhdl9yZWxvcHRfY29zdF9kZWxheSA9IHRhYi0+YXRfcmVsb3B0X3Zh Y19jb3N0X2RlbGF5OwogCi0JCS8qIE11c3QgaG9sZCBBdXRvdmFjdXVtTG9jayB3aGlsZSBtdWNr aW5nIHdpdGggY29zdCBiYWxhbmNlIGluZm8gKi8KLQkJTFdMb2NrQWNxdWlyZShBdXRvdmFjdXVt TG9jaywgTFdfRVhDTFVTSVZFKTsKLQotCQkvKiBhZHZlcnRpc2UgbXkgY29zdCBkZWxheSBwYXJh bWV0ZXJzIGZvciB0aGUgYmFsYW5jaW5nIGFsZ29yaXRobSAqLwotCQlNeVdvcmtlckluZm8tPndp X2RvYmFsYW5jZSA9IHRhYi0+YXRfZG9iYWxhbmNlOwotCQlNeVdvcmtlckluZm8tPndpX2Nvc3Rf ZGVsYXkgPSB0YWItPmF0X3ZhY3V1bV9jb3N0X2RlbGF5OwotCQlNeVdvcmtlckluZm8tPndpX2Nv c3RfbGltaXQgPSB0YWItPmF0X3ZhY3V1bV9jb3N0X2xpbWl0OwotCQlNeVdvcmtlckluZm8tPndp X2Nvc3RfbGltaXRfYmFzZSA9IHRhYi0+YXRfdmFjdXVtX2Nvc3RfbGltaXQ7CisJCWlmICh0YWIt PmF0X2RvYmFsYW5jZSkKKwkJCXBnX2F0b21pY190ZXN0X3NldF9mbGFnKCZNeVdvcmtlckluZm8t PndpX2RvYmFsYW5jZSk7CisJCWVsc2UKKwkJCXBnX2F0b21pY19jbGVhcl9mbGFnKCZNeVdvcmtl ckluZm8tPndpX2RvYmFsYW5jZSk7CiAKLQkJLyogZG8gYSBiYWxhbmNlICovCi0JCWF1dG92YWNf YmFsYW5jZV9jb3N0KCk7CisJCUxXTG9ja0FjcXVpcmUoQXV0b3ZhY3V1bUxvY2ssIExXX1NIQVJF RCk7CisJCWF1dG92YWNfcmVjYWxjdWxhdGVfd29ya2Vyc19mb3JfYmFsYW5jZSgpOworCQlMV0xv Y2tSZWxlYXNlKEF1dG92YWN1dW1Mb2NrKTsKIAotCQkvKiBzZXQgdGhlIGFjdGl2ZSBjb3N0IHBh cmFtZXRlcnMgZnJvbSB0aGUgcmVzdWx0IG9mIHRoYXQgKi8KKwkJLyoKKwkJICogV2Ugd2FpdCB1 bnRpbCB0aGlzIHBvaW50IHRvIHVwZGF0ZSBjb3N0IGRlbGF5IGFuZCBjb3N0IGxpbWl0CisJCSAq IHZhbHVlcywgZXZlbiB0aG91Z2ggd2UgcmVsb2FkZWQgdGhlIGNvbmZpZ3VyYXRpb24gZmlsZSBh Ym92ZSwgc28KKwkJICogdGhhdCB3ZSBjYW4gdGFrZSBpbnRvIGFjY291bnQgdGhlIGNvc3QtcmVs YXRlZCB0YWJsZSBvcHRpb25zLgorCQkgKi8KIAkJQXV0b1ZhY3V1bVVwZGF0ZURlbGF5KCk7Ci0K LQkJLyogZG9uZSAqLwotCQlMV0xvY2tSZWxlYXNlKEF1dG92YWN1dW1Mb2NrKTsKKwkJQXV0b1Zh Y3V1bVVwZGF0ZUxpbWl0KCk7CiAKIAkJLyogY2xlYW4gdXAgbWVtb3J5IGJlZm9yZSBlYWNoIGl0 ZXJhdGlvbiAqLwogCQlNZW1vcnlDb250ZXh0UmVzZXRBbmREZWxldGVDaGlsZHJlbihQb3J0YWxD b250ZXh0KTsKQEAgLTI1MjUsMTkgKzI1NjMsMTUgQEAgZGVsZXRlZDoKIAogCQkvKgogCQkgKiBS ZW1vdmUgbXkgaW5mbyBmcm9tIHNoYXJlZCBtZW1vcnkuICBXZSBjb3VsZCwgYnV0IGludGVudGlv bmFsbHkKLQkJICogZG9uJ3QsIGNsZWFyIHdpX2Nvc3RfbGltaXQgYW5kIGZyaWVuZHMgLS0tIHRo aXMgaXMgb24gdGhlCi0JCSAqIGFzc3VtcHRpb24gdGhhdCB3ZSBwcm9iYWJseSBoYXZlIG1vcmUg dG8gZG8gd2l0aCBzaW1pbGFyIGNvc3QKLQkJICogc2V0dGluZ3MsIHNvIHdlIGRvbid0IHdhbnQg dG8gZ2l2ZSB1cCBvdXIgc2hhcmUgb2YgSS9PIGZvciBhIHZlcnkKLQkJICogc2hvcnQgaW50ZXJ2 YWwgYW5kIHRoZXJlYnkgdGhyYXNoIHRoZSBnbG9iYWwgYmFsYW5jZS4KKwkJICogZG9uJ3QsIHVu c2V0IHdpX2RvYmFsYW5jZSBvbiB0aGUgYXNzdW1wdGlvbiB0aGF0IHdlIGFyZSBtb3JlIGxpa2Vs eQorCQkgKiB0aGFuIG5vdCB0byB2YWN1dW0gYSB0YWJsZSB3aXRoIG5vIHRhYmxlIG9wdGlvbnMg bmV4dCwgc28gd2UgZG9uJ3QKKwkJICogd2FudCB0byBnaXZlIHVwIG91ciBzaGFyZSBvZiBJL08g Zm9yIGEgdmVyeSBzaG9ydCBpbnRlcnZhbCBhbmQKKwkJICogdGhlcmVieSB0aHJhc2ggdGhlIGds b2JhbCBiYWxhbmNlLgogCQkgKi8KIAkJTFdMb2NrQWNxdWlyZShBdXRvdmFjdXVtU2NoZWR1bGVM b2NrLCBMV19FWENMVVNJVkUpOwogCQlNeVdvcmtlckluZm8tPndpX3RhYmxlb2lkID0gSW52YWxp ZE9pZDsKIAkJTXlXb3JrZXJJbmZvLT53aV9zaGFyZWRyZWwgPSBmYWxzZTsKIAkJTFdMb2NrUmVs ZWFzZShBdXRvdmFjdXVtU2NoZWR1bGVMb2NrKTsKLQotCQkvKiByZXN0b3JlIHZhY3V1bSBjb3N0 IEdVQ3MgZm9yIHRoZSBuZXh0IGl0ZXJhdGlvbiAqLwotCQlWYWN1dW1Db3N0RGVsYXkgPSBzdGRW YWN1dW1Db3N0RGVsYXk7Ci0JCVZhY3V1bUNvc3RMaW1pdCA9IHN0ZFZhY3V1bUNvc3RMaW1pdDsK IAl9CiAKIAkvKgpAQCAtMjU2OSw2ICsyNjAzLDggQEAgZGVsZXRlZDoKIAkJewogCQkJQ29uZmln UmVsb2FkUGVuZGluZyA9IGZhbHNlOwogCQkJUHJvY2Vzc0NvbmZpZ0ZpbGUoUEdDX1NJR0hVUCk7 CisJCQlBdXRvVmFjdXVtVXBkYXRlRGVsYXkoKTsKKwkJCUF1dG9WYWN1dW1VcGRhdGVMaW1pdCgp OwogCQl9CiAKIAkJTFdMb2NrQWNxdWlyZShBdXRvdmFjdXVtTG9jaywgTFdfRVhDTFVTSVZFKTsK QEAgLTI4MDQsOCArMjg0MCw2IEBAIHRhYmxlX3JlY2hlY2tfYXV0b3ZhYyhPaWQgcmVsaWQsIEhU QUIgKnRhYmxlX3RvYXN0X21hcCwKIAkJaW50CQkJZnJlZXplX3RhYmxlX2FnZTsKIAkJaW50CQkJ bXVsdGl4YWN0X2ZyZWV6ZV9taW5fYWdlOwogCQlpbnQJCQltdWx0aXhhY3RfZnJlZXplX3RhYmxl X2FnZTsKLQkJaW50CQkJdmFjX2Nvc3RfbGltaXQ7Ci0JCWRvdWJsZQkJdmFjX2Nvc3RfZGVsYXk7 CiAJCWludAkJCWxvZ19taW5fZHVyYXRpb247CiAKIAkJLyoKQEAgLTI4MTUsMjAgKzI4NDksNiBA QCB0YWJsZV9yZWNoZWNrX2F1dG92YWMoT2lkIHJlbGlkLCBIVEFCICp0YWJsZV90b2FzdF9tYXAs CiAJCSAqIGRlZmF1bHRzLCBhdXRvdmFjdXVtJ3Mgb3duIGZpcnN0IGFuZCBwbGFpbiB2YWN1dW0g c2Vjb25kLgogCQkgKi8KIAotCQkvKiAtMSBpbiBhdXRvdmFjIHNldHRpbmcgbWVhbnMgdXNlIHBs YWluIHZhY3V1bV9jb3N0X2RlbGF5ICovCi0JCXZhY19jb3N0X2RlbGF5ID0gKGF2b3B0cyAmJiBh dm9wdHMtPnZhY3V1bV9jb3N0X2RlbGF5ID49IDApCi0JCQk/IGF2b3B0cy0+dmFjdXVtX2Nvc3Rf ZGVsYXkKLQkJCTogKGF1dG92YWN1dW1fdmFjX2Nvc3RfZGVsYXkgPj0gMCkKLQkJCT8gYXV0b3Zh Y3V1bV92YWNfY29zdF9kZWxheQotCQkJOiBWYWN1dW1Db3N0RGVsYXk7Ci0KLQkJLyogMCBvciAt MSBpbiBhdXRvdmFjIHNldHRpbmcgbWVhbnMgdXNlIHBsYWluIHZhY3V1bV9jb3N0X2xpbWl0ICov Ci0JCXZhY19jb3N0X2xpbWl0ID0gKGF2b3B0cyAmJiBhdm9wdHMtPnZhY3V1bV9jb3N0X2xpbWl0 ID4gMCkKLQkJCT8gYXZvcHRzLT52YWN1dW1fY29zdF9saW1pdAotCQkJOiAoYXV0b3ZhY3V1bV92 YWNfY29zdF9saW1pdCA+IDApCi0JCQk/IGF1dG92YWN1dW1fdmFjX2Nvc3RfbGltaXQKLQkJCTog VmFjdXVtQ29zdExpbWl0OwotCiAJCS8qIC0xIGluIGF1dG92YWMgc2V0dGluZyBtZWFucyB1c2Ug bG9nX2F1dG92YWN1dW1fbWluX2R1cmF0aW9uICovCiAJCWxvZ19taW5fZHVyYXRpb24gPSAoYXZv cHRzICYmIGF2b3B0cy0+bG9nX21pbl9kdXJhdGlvbiA+PSAwKQogCQkJPyBhdm9wdHMtPmxvZ19t aW5fZHVyYXRpb24KQEAgLTI4ODQsOCArMjkwNCwxMCBAQCB0YWJsZV9yZWNoZWNrX2F1dG92YWMo T2lkIHJlbGlkLCBIVEFCICp0YWJsZV90b2FzdF9tYXAsCiAJCXRhYi0+YXRfcGFyYW1zLm11bHRp eGFjdF9mcmVlemVfdGFibGVfYWdlID0gbXVsdGl4YWN0X2ZyZWV6ZV90YWJsZV9hZ2U7CiAJCXRh Yi0+YXRfcGFyYW1zLmlzX3dyYXBhcm91bmQgPSB3cmFwYXJvdW5kOwogCQl0YWItPmF0X3BhcmFt cy5sb2dfbWluX2R1cmF0aW9uID0gbG9nX21pbl9kdXJhdGlvbjsKLQkJdGFiLT5hdF92YWN1dW1f Y29zdF9saW1pdCA9IHZhY19jb3N0X2xpbWl0OwotCQl0YWItPmF0X3ZhY3V1bV9jb3N0X2RlbGF5 ID0gdmFjX2Nvc3RfZGVsYXk7CisJCXRhYi0+YXRfcmVsb3B0X3ZhY19jb3N0X2xpbWl0ID0gYXZv cHRzID8KKwkJCWF2b3B0cy0+dmFjdXVtX2Nvc3RfbGltaXQgOiAwOworCQl0YWItPmF0X3JlbG9w dF92YWNfY29zdF9kZWxheSA9IGF2b3B0cyA/CisJCQlhdm9wdHMtPnZhY3V1bV9jb3N0X2RlbGF5 IDogLTE7CiAJCXRhYi0+YXRfcmVsbmFtZSA9IE5VTEw7CiAJCXRhYi0+YXRfbnNwbmFtZSA9IE5V TEw7CiAJCXRhYi0+YXRfZGF0bmFtZSA9IE5VTEw7CkBAIC0zMzc3LDEwICszMzk5LDE4IEBAIEF1 dG9WYWN1dW1TaG1lbUluaXQodm9pZCkKIAkJd29ya2VyID0gKFdvcmtlckluZm8pICgoY2hhciAq KSBBdXRvVmFjdXVtU2htZW0gKwogCQkJCQkJCSAgIE1BWEFMSUdOKHNpemVvZihBdXRvVmFjdXVt U2htZW1TdHJ1Y3QpKSk7CiAKKwogCQkvKiBpbml0aWFsaXplIHRoZSBXb3JrZXJJbmZvIGZyZWUg bGlzdCAqLwogCQlmb3IgKGkgPSAwOyBpIDwgYXV0b3ZhY3V1bV9tYXhfd29ya2VyczsgaSsrKQor CQl7CiAJCQlkbGlzdF9wdXNoX2hlYWQoJkF1dG9WYWN1dW1TaG1lbS0+YXZfZnJlZVdvcmtlcnMs CiAJCQkJCQkJJndvcmtlcltpXS53aV9saW5rcyk7CisKKwkJCXBnX2F0b21pY19pbml0X2ZsYWco JndvcmtlcltpXS53aV9kb2JhbGFuY2UpOworCQl9CisKKwkJcGdfYXRvbWljX2luaXRfdTMyKCZB dXRvVmFjdXVtU2htZW0tPmF2X253b3JrZXJzRm9yQmFsYW5jZSwgMCk7CisKIAl9CiAJZWxzZQog CQlBc3NlcnQoZm91bmQpOwpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvcG9zdG1hc3Rlci9hdXRv dmFjdXVtLmggYi9zcmMvaW5jbHVkZS9wb3N0bWFzdGVyL2F1dG92YWN1dW0uaAppbmRleCBjMTQw MzcxYjUxLi44MGJkZmIyY2MwIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9wb3N0bWFzdGVyL2F1 dG92YWN1dW0uaAorKysgYi9zcmMvaW5jbHVkZS9wb3N0bWFzdGVyL2F1dG92YWN1dW0uaApAQCAt NjQsNyArNjQsOSBAQCBleHRlcm4gaW50CVN0YXJ0QXV0b1ZhY1dvcmtlcih2b2lkKTsKIGV4dGVy biB2b2lkIEF1dG9WYWNXb3JrZXJGYWlsZWQodm9pZCk7CiAKIC8qIGF1dG92YWN1dW0gY29zdC1k ZWxheSBiYWxhbmNlciAqLworZXh0ZXJuIHZvaWQgQXV0b1ZhY3V1bUJhbGFuY2VMaW1pdCh2b2lk KTsKIGV4dGVybiB2b2lkIEF1dG9WYWN1dW1VcGRhdGVEZWxheSh2b2lkKTsKK2V4dGVybiB2b2lk IEF1dG9WYWN1dW1VcGRhdGVMaW1pdCh2b2lkKTsKIAogI2lmZGVmIEVYRUNfQkFDS0VORAogZXh0 ZXJuIHZvaWQgQXV0b1ZhY0xhdW5jaGVyTWFpbihpbnQgYXJnYywgY2hhciAqYXJndltdKSBwZ19h dHRyaWJ1dGVfbm9yZXR1cm4oKTsKLS0gCjIuMzcuMgoK --00000000000020347705f80f706d Content-Type: text/x-patch; charset="US-ASCII"; name="v11-0001-Make-VacuumCostActive-failsafe-aware.patch" Content-Disposition: attachment; filename="v11-0001-Make-VacuumCostActive-failsafe-aware.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lfu3z0ku0 RnJvbSBhNDZmMTM1MTdkMTY1NDc5ZWM1MThiNDZmZTk4NTkxYWE3NWYzNWQ2IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBTYXQsIDI1IE1hciAyMDIzIDEyOjA1OjE4IC0wNDAwClN1YmplY3Q6IFtQ QVRDSCB2MTEgMS8zXSBNYWtlIFZhY3V1bUNvc3RBY3RpdmUgZmFpbHNhZmUtYXdhcmUKCldoaWxl IHZhY3V1bWluZyBhIHRhYmxlIGluIGZhaWxzYWZlIG1vZGUsIFZhY3V1bUNvc3RBY3RpdmUgc2hv dWxkIG5vdCBiZQpyZS1lbmFibGVkLiBUaGlzIGN1cnJlbnRseSBpc24ndCBhIHByb2JsZW0gYmVj YXVzZSB2YWN1dW0gY29zdApwYXJhbWV0ZXJzIGFyZSBvbmx5IHJlZnJlc2hlZCBpbiBiZXR3ZWVu IHZhY3V1bWluZyB0YWJsZXMgYW5kIGZhaWxzYWZlCnN0YXR1cyBpcyByZXNldCBmb3IgZXZlcnkg dGFibGUuIEluIHByZXBhcmF0aW9uIGZvciBhbGxvd2luZyB2YWN1dW0gY29zdApwYXJhbWV0ZXJz IHRvIGJlIHVwZGF0ZWQgbW9yZSBmcmVxdWVudGx5LCBtYWtlIHZhY3V1bSBjb3N0IHN0YXR1cyBt b3JlCmV4cHJlc3NpdmUuCgpWYWN1dW1Db3N0QWN0aXZlIGlzIG5vdyBWYWN1dW1Db3N0SW5hY3Rp dmUsIGFzIGl0IGNhbiBvbmx5IGJlIGFjdGl2ZSBpbgpvbmUgd2F5IGJ1dCBpdCBjYW4gYmUgaW5h Y3RpdmUgaW4gdHdvIHdheXMuIElmIHBlcmZvcm1pbmcgYSBmYWlsc2FmZQp2YWN1dW0sIHRoZSB2 YWN1dW0gY29zdCBzdGF0dXMgY2Fubm90IGJlIGVuYWJsZWQgYW5kIGlzIGVmZmVjdGl2ZWx5CiJs b2NrZWQiLiBJZiBwZXJmb3JtaW5nIGEgbm9uLWZhaWxzYWZlIHZhY3V1bSwgdGhlIHZhY3V1bSBj b3N0IHN0YXR1cwptYXkgYmUgYWN0aXZlIG9yIGluYWN0aXZlLiBUbyBleHByZXNzIHRoaXMsIFZh Y3V1bUNvc3RJbmFjdGl2ZSBjYW4gYmUKb25lIG9mIHRocmVlIHN0YXR1c2VzOiBWQUNVVU1fQ09T VF9JTkFDVElWRV9BTkRfTE9DS0VELApWQUNVVU1fQ09TVF9BQ1RJVkVfQU5EX0xPQ0tFRCwgYW5k IFZBQ1VVTV9DT1NUX0FDVElWRS4KClZhY3V1bUNvc3RJbmFjdGl2ZSBpcyBkZWZpbmVkIGFzIGFu IGludGVnZXIgYmVjYXVzZSB3ZSBkbyBub3Qgd2FudApub24tdmFjdXVtIGNvZGUgY29uY2Vybmlu ZyBpdHNlbGYgd2l0aCB0aGUgZGlzdGluY3Rpb24gYmV0d2VlbiB0aGUgdGhyZWUKc3RhdHVzZXMg LS0gb25seSB3aXRoIHdoZXRoZXIgb3Igbm90IFZhY3V1bUNvc3RJbmFjdGl2ZSA9PSAwIG9yIG5v dC4KLS0tCiBzcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMgIHwgIDIgKy0KIHNy Yy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jICAgICAgICAgfCAyNCArKysrKysrKysrKysrKysr KysrKystLS0KIHNyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMgfCAgOCArKysr KystLQogc3JjL2JhY2tlbmQvc3RvcmFnZS9idWZmZXIvYnVmbWdyLmMgICB8ICA4ICsrKystLS0t CiBzcmMvYmFja2VuZC91dGlscy9pbml0L2dsb2JhbHMuYyAgICAgIHwgIDIgKy0KIHNyYy9pbmNs dWRlL2NvbW1hbmRzL3ZhY3V1bS5oICAgICAgICAgfCAgOCArKysrKysrKwogc3JjL2luY2x1ZGUv bWlzY2FkbWluLmggICAgICAgICAgICAgICB8ICAzICstLQogNyBmaWxlcyBjaGFuZ2VkLCA0MiBp bnNlcnRpb25zKCspLCAxMyBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9h Y2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1s YXp5LmMKaW5kZXggOGYxNGNmODVmMy4uMDQwYTRlOTMxYiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tl bmQvYWNjZXNzL2hlYXAvdmFjdXVtbGF6eS5jCisrKyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFw L3ZhY3V1bWxhenkuYwpAQCAtMjYzNyw3ICsyNjM3LDcgQEAgbGF6eV9jaGVja193cmFwYXJvdW5k X2ZhaWxzYWZlKExWUmVsU3RhdGUgKnZhY3JlbCkKIAkJCQkJCSAiWW91IG1pZ2h0IGFsc28gbmVl ZCB0byBjb25zaWRlciBvdGhlciB3YXlzIGZvciBWQUNVVU0gdG8ga2VlcCB1cCB3aXRoIHRoZSBh bGxvY2F0aW9uIG9mIHRyYW5zYWN0aW9uIElEcy4iKSkpOwogCiAJCS8qIFN0b3AgYXBwbHlpbmcg Y29zdCBsaW1pdHMgZnJvbSB0aGlzIHBvaW50IG9uICovCi0JCVZhY3V1bUNvc3RBY3RpdmUgPSBm YWxzZTsKKwkJVmFjdXVtQ29zdEluYWN0aXZlID0gVkFDVVVNX0NPU1RfSU5BQ1RJVkVfQU5EX0xP Q0tFRDsKIAkJVmFjdXVtQ29zdEJhbGFuY2UgPSAwOwogCiAJCXJldHVybiB0cnVlOwpkaWZmIC0t Z2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMgYi9zcmMvYmFja2VuZC9jb21tYW5k cy92YWN1dW0uYwppbmRleCBjNTQzNjBhNmEwLi5lYjEyNmYyMjQ3IDEwMDY0NAotLS0gYS9zcmMv YmFja2VuZC9jb21tYW5kcy92YWN1dW0uYworKysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1 dW0uYwpAQCAtNDkxLDcgKzQ5MSw2IEBAIHZhY3V1bShMaXN0ICpyZWxhdGlvbnMsIFZhY3V1bVBh cmFtcyAqcGFyYW1zLAogCQlMaXN0Q2VsbCAgICpjdXI7CiAKIAkJaW5fdmFjdXVtID0gdHJ1ZTsK LQkJVmFjdXVtQ29zdEFjdGl2ZSA9IChWYWN1dW1Db3N0RGVsYXkgPiAwKTsKIAkJVmFjdXVtQ29z dEJhbGFuY2UgPSAwOwogCQlWYWN1dW1QYWdlSGl0ID0gMDsKIAkJVmFjdXVtUGFnZU1pc3MgPSAw OwpAQCAtNTA3LDYgKzUwNiwyNCBAQCB2YWN1dW0oTGlzdCAqcmVsYXRpb25zLCBWYWN1dW1QYXJh bXMgKnBhcmFtcywKIAkJewogCQkJVmFjdXVtUmVsYXRpb24gKnZyZWwgPSBsZmlyc3Rfbm9kZShW YWN1dW1SZWxhdGlvbiwgY3VyKTsKIAorCQkJLyoKKwkJCSAqIGZhaWxzYWZlX2FjdGl2ZSBpcyBy ZXNldCBwZXIgcmVsYXRpb24sIHNvIHdlIG11c3QgYmUgc3VyZSB0aGF0CisJCQkgKiBWYWN1dW1D b3N0SW5hY3RpdmUgaXMgc2V0IHRvIGVpdGhlciBWQUNVVU1fQ09TVF9JTkFDVElWRSBvcgorCQkJ ICogVkFDVVVNX0NPU1RfSU5BQ1RJVkVfQU5EX1VOTE9DS0VEIGluIGJldHdlZW4gdmFjdXVtaW5n CisJCQkgKiByZWxhdGlvbnMuCisJCQkgKi8KKwkJCVZhY3V1bUNvc3RJbmFjdGl2ZSA9IFZhY3V1 bUNvc3REZWxheSA+IDAgPyBWQUNVVU1fQ09TVF9BQ1RJVkUgOgorCQkJCVZBQ1VVTV9DT1NUX0lO QUNUSVZFX0FORF9VTkxPQ0tFRDsKKworCQkJLyoKKwkJCSAqIFdlIHNob3VsZCBub3QgaGF2ZSB0 cmFuc2l0aW9uZWQgVmFjdXVtQ29zdEluYWN0aXZlIGZyb20KKwkJCSAqIFZBQ1VVTV9DT1NUX0FD VElWRSB0byBWQUNVVU1fQ09TVF9JTkFDVElWRV9BTkRfVU5MT0NLRUQgYWJvdmUsCisJCQkgKiBh cyB0aGF0IHNob3VsZCBoYXZlIGhhcHBlbmVkIHdoZW4gd2UgY2hhbmdlZCB0aGUgdmFsdWUgb2YK KwkJCSAqIFZhY3V1bUNvc3REZWxheS4KKwkJCSAqLworCQkJQXNzZXJ0KFZhY3V1bUNvc3RJbmFj dGl2ZSA9PSBWQUNVVU1fQ09TVF9BQ1RJVkUgfHwKKwkJCQkgICBWYWN1dW1Db3N0QmFsYW5jZSA9 PSAwKTsKKwogCQkJaWYgKHBhcmFtcy0+b3B0aW9ucyAmIFZBQ09QVF9WQUNVVU0pCiAJCQl7CiAJ CQkJaWYgKCF2YWN1dW1fcmVsKHZyZWwtPm9pZCwgdnJlbC0+cmVsYXRpb24sIHBhcmFtcywgZmFs c2UpKQpAQCAtNTQ5LDcgKzU2Niw4IEBAIHZhY3V1bShMaXN0ICpyZWxhdGlvbnMsIFZhY3V1bVBh cmFtcyAqcGFyYW1zLAogCVBHX0ZJTkFMTFkoKTsKIAl7CiAJCWluX3ZhY3V1bSA9IGZhbHNlOwot CQlWYWN1dW1Db3N0QWN0aXZlID0gZmFsc2U7CisJCVZhY3V1bUNvc3RJbmFjdGl2ZSA9IFZBQ1VV TV9DT1NUX0lOQUNUSVZFX0FORF9VTkxPQ0tFRDsKKwkJVmFjdXVtQ29zdEJhbGFuY2UgPSAwOwog CX0KIAlQR19FTkRfVFJZKCk7CiAKQEAgLTIyMTUsNyArMjIzMyw3IEBAIHZhY3V1bV9kZWxheV9w b2ludCh2b2lkKQogCS8qIEFsd2F5cyBjaGVjayBmb3IgaW50ZXJydXB0cyAqLwogCUNIRUNLX0ZP Ul9JTlRFUlJVUFRTKCk7CiAKLQlpZiAoIVZhY3V1bUNvc3RBY3RpdmUgfHwgSW50ZXJydXB0UGVu ZGluZykKKwlpZiAoVmFjdXVtQ29zdEluYWN0aXZlIHx8IEludGVycnVwdFBlbmRpbmcpCiAJCXJl dHVybjsKIAogCS8qCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJh bGxlbC5jIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYwppbmRleCBiY2Q0 MGM4MGExLi4yNjZiZjZiYjRjIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1 dW1wYXJhbGxlbC5jCisrKyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMK QEAgLTk4OSw4ICs5ODksMTIgQEAgcGFyYWxsZWxfdmFjdXVtX21haW4oZHNtX3NlZ21lbnQgKnNl Zywgc2htX3RvYyAqdG9jKQogCQkJCQkJCQkJCQkJIFBBUkFMTEVMX1ZBQ1VVTV9LRVlfREVBRF9J VEVNUywKIAkJCQkJCQkJCQkJCSBmYWxzZSk7CiAKLQkvKiBTZXQgY29zdC1iYXNlZCB2YWN1dW0g ZGVsYXkgKi8KLQlWYWN1dW1Db3N0QWN0aXZlID0gKFZhY3V1bUNvc3REZWxheSA+IDApOworCS8q CisJICogU2V0IGNvc3QtYmFzZWQgdmFjdXVtIGRlbGF5IFBhcmFsbGVsIHZhY3V1bSB3b3JrZXJz IHdpbGwgbm90IGV4ZWN1dGUKKwkgKiBmYWlsc2FmZSBWQUNVVU0uCisJICovCisJVmFjdXVtQ29z dEluYWN0aXZlID0gVmFjdXVtQ29zdERlbGF5ID4gMCA/IFZBQ1VVTV9DT1NUX0FDVElWRSA6CisJ CVZBQ1VVTV9DT1NUX0lOQUNUSVZFX0FORF9VTkxPQ0tFRDsKIAlWYWN1dW1Db3N0QmFsYW5jZSA9 IDA7CiAJVmFjdXVtUGFnZUhpdCA9IDA7CiAJVmFjdXVtUGFnZU1pc3MgPSAwOwpkaWZmIC0tZ2l0 IGEvc3JjL2JhY2tlbmQvc3RvcmFnZS9idWZmZXIvYnVmbWdyLmMgYi9zcmMvYmFja2VuZC9zdG9y YWdlL2J1ZmZlci9idWZtZ3IuYwppbmRleCBmZTAyOWQyZWE2Li40OTVlZThmODE1IDEwMDY0NAot LS0gYS9zcmMvYmFja2VuZC9zdG9yYWdlL2J1ZmZlci9idWZtZ3IuYworKysgYi9zcmMvYmFja2Vu ZC9zdG9yYWdlL2J1ZmZlci9idWZtZ3IuYwpAQCAtODkzLDcgKzg5Myw3IEBAIFJlYWRCdWZmZXJf Y29tbW9uKFNNZ3JSZWxhdGlvbiBzbWdyLCBjaGFyIHJlbHBlcnNpc3RlbmNlLCBGb3JrTnVtYmVy IGZvcmtOdW0sCiAJCQkqaGl0ID0gdHJ1ZTsKIAkJCVZhY3V1bVBhZ2VIaXQrKzsKIAotCQkJaWYg KFZhY3V1bUNvc3RBY3RpdmUpCisJCQlpZiAoIVZhY3V1bUNvc3RJbmFjdGl2ZSkKIAkJCQlWYWN1 dW1Db3N0QmFsYW5jZSArPSBWYWN1dW1Db3N0UGFnZUhpdDsKIAogCQkJVFJBQ0VfUE9TVEdSRVNR TF9CVUZGRVJfUkVBRF9ET05FKGZvcmtOdW0sIGJsb2NrTnVtLApAQCAtMTA5OCw3ICsxMDk4LDcg QEAgUmVhZEJ1ZmZlcl9jb21tb24oU01nclJlbGF0aW9uIHNtZ3IsIGNoYXIgcmVscGVyc2lzdGVu Y2UsIEZvcmtOdW1iZXIgZm9ya051bSwKIAl9CiAKIAlWYWN1dW1QYWdlTWlzcysrOwotCWlmIChW YWN1dW1Db3N0QWN0aXZlKQorCWlmICghVmFjdXVtQ29zdEluYWN0aXZlKQogCQlWYWN1dW1Db3N0 QmFsYW5jZSArPSBWYWN1dW1Db3N0UGFnZU1pc3M7CiAKIAlUUkFDRV9QT1NUR1JFU1FMX0JVRkZF Ul9SRUFEX0RPTkUoZm9ya051bSwgYmxvY2tOdW0sCkBAIC0xNjcyLDcgKzE2NzIsNyBAQCBNYXJr QnVmZmVyRGlydHkoQnVmZmVyIGJ1ZmZlcikKIAl7CiAJCVZhY3V1bVBhZ2VEaXJ0eSsrOwogCQlw Z0J1ZmZlclVzYWdlLnNoYXJlZF9ibGtzX2RpcnRpZWQrKzsKLQkJaWYgKFZhY3V1bUNvc3RBY3Rp dmUpCisJCWlmICghVmFjdXVtQ29zdEluYWN0aXZlKQogCQkJVmFjdXVtQ29zdEJhbGFuY2UgKz0g VmFjdXVtQ29zdFBhZ2VEaXJ0eTsKIAl9CiB9CkBAIC00MTg5LDcgKzQxODksNyBAQCBNYXJrQnVm ZmVyRGlydHlIaW50KEJ1ZmZlciBidWZmZXIsIGJvb2wgYnVmZmVyX3N0ZCkKIAkJewogCQkJVmFj dXVtUGFnZURpcnR5Kys7CiAJCQlwZ0J1ZmZlclVzYWdlLnNoYXJlZF9ibGtzX2RpcnRpZWQrKzsK LQkJCWlmIChWYWN1dW1Db3N0QWN0aXZlKQorCQkJaWYgKCFWYWN1dW1Db3N0SW5hY3RpdmUpCiAJ CQkJVmFjdXVtQ29zdEJhbGFuY2UgKz0gVmFjdXVtQ29zdFBhZ2VEaXJ0eTsKIAkJfQogCX0KZGlm ZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3V0aWxzL2luaXQvZ2xvYmFscy5jIGIvc3JjL2JhY2tlbmQv dXRpbHMvaW5pdC9nbG9iYWxzLmMKaW5kZXggMWIxZDgxNDI1NC4uNjA4ZWJiOTE4MiAxMDA2NDQK LS0tIGEvc3JjL2JhY2tlbmQvdXRpbHMvaW5pdC9nbG9iYWxzLmMKKysrIGIvc3JjL2JhY2tlbmQv dXRpbHMvaW5pdC9nbG9iYWxzLmMKQEAgLTE1MCw0ICsxNTAsNCBAQCBpbnQ2NAkJVmFjdXVtUGFn ZU1pc3MgPSAwOwogaW50NjQJCVZhY3V1bVBhZ2VEaXJ0eSA9IDA7CiAKIGludAkJCVZhY3V1bUNv c3RCYWxhbmNlID0gMDsJLyogd29ya2luZyBzdGF0ZSBmb3IgdmFjdXVtICovCi1ib29sCQlWYWN1 dW1Db3N0QWN0aXZlID0gZmFsc2U7CitpbnQJCQlWYWN1dW1Db3N0SW5hY3RpdmUgPSAxOwpkaWZm IC0tZ2l0IGEvc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmggYi9zcmMvaW5jbHVkZS9jb21t YW5kcy92YWN1dW0uaAppbmRleCBiZGZkOTZjZmVjLi41YzNlMjUwYjA2IDEwMDY0NAotLS0gYS9z cmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0uaAorKysgYi9zcmMvaW5jbHVkZS9jb21tYW5kcy92 YWN1dW0uaApAQCAtMzAyLDYgKzMwMiwxNCBAQCBleHRlcm4gUEdETExJTVBPUlQgaW50IHZhY3V1 bV9mYWlsc2FmZV9hZ2U7CiBleHRlcm4gUEdETExJTVBPUlQgaW50IHZhY3V1bV9tdWx0aXhhY3Rf ZmFpbHNhZmVfYWdlOwogCiAvKiBWYXJpYWJsZXMgZm9yIGNvc3QtYmFzZWQgcGFyYWxsZWwgdmFj dXVtICovCisKK3R5cGVkZWYgZW51bSBWYWN1dW1Db3N0U3RhdHVzCit7CisJVkFDVVVNX0NPU1Rf SU5BQ1RJVkVfQU5EX0xPQ0tFRCA9IC0xLAorCVZBQ1VVTV9DT1NUX0FDVElWRSA9IDAsCisJVkFD VVVNX0NPU1RfSU5BQ1RJVkVfQU5EX1VOTE9DS0VEID0gMSwKK30JCQlWYWN1dW1Db3N0U3RhdHVz OworCiBleHRlcm4gUEdETExJTVBPUlQgcGdfYXRvbWljX3VpbnQzMiAqVmFjdXVtU2hhcmVkQ29z dEJhbGFuY2U7CiBleHRlcm4gUEdETExJTVBPUlQgcGdfYXRvbWljX3VpbnQzMiAqVmFjdXVtQWN0 aXZlTldvcmtlcnM7CiBleHRlcm4gUEdETExJTVBPUlQgaW50IFZhY3V1bUNvc3RCYWxhbmNlTG9j YWw7CmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9taXNjYWRtaW4uaCBiL3NyYy9pbmNsdWRlL21p c2NhZG1pbi5oCmluZGV4IDA2YTg2ZjlhYzEuLjMzZTIyNzMzYWUgMTAwNjQ0Ci0tLSBhL3NyYy9p bmNsdWRlL21pc2NhZG1pbi5oCisrKyBiL3NyYy9pbmNsdWRlL21pc2NhZG1pbi5oCkBAIC0yNzQs OCArMjc0LDcgQEAgZXh0ZXJuIFBHRExMSU1QT1JUIGludDY0IFZhY3V1bVBhZ2VNaXNzOwogZXh0 ZXJuIFBHRExMSU1QT1JUIGludDY0IFZhY3V1bVBhZ2VEaXJ0eTsKIAogZXh0ZXJuIFBHRExMSU1Q T1JUIGludCBWYWN1dW1Db3N0QmFsYW5jZTsKLWV4dGVybiBQR0RMTElNUE9SVCBib29sIFZhY3V1 bUNvc3RBY3RpdmU7Ci0KK2V4dGVybiBQR0RMTElNUE9SVCBpbnQgVmFjdXVtQ29zdEluYWN0aXZl OwogCiAvKiBpbiB0Y29wL3Bvc3RncmVzLmMgKi8KIAotLSAKMi4zNy4yCgo= --00000000000020347705f80f706d Content-Type: text/x-patch; charset="US-ASCII"; name="v11-0002-VACUUM-reloads-config-file-more-often.patch" Content-Disposition: attachment; filename="v11-0002-VACUUM-reloads-config-file-more-often.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lfu3z0kz1 RnJvbSAzZjRhMzlmZjM2NmY0OTFlY2RmMjM2MWFlMTE3MDRiYzk4MTc1YTMwIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBNb24sIDI3IE1hciAyMDIzIDEzOjMzOjE5IC0wNDAwClN1YmplY3Q6IFtQ QVRDSCB2MTEgMi8zXSBWQUNVVU0gcmVsb2FkcyBjb25maWcgZmlsZSBtb3JlIG9mdGVuCgpQcmV2 aW91c2x5LCBWQUNVVU0gd291bGQgbm90IHJlbG9hZCB0aGUgY29uZmlndXJhdGlvbiBmaWxlLiBT bywgY2hhbmdlcwp0byBjb3N0LWJhc2VkIGRlbGF5IHBhcmFtZXRlcnMgY291bGQgb25seSB0YWtl IGVmZmVjdCBvbiB0aGUgbmV4dAppbnZvY2F0aW9uIG9mIFZBQ1VVTS4KCkNoZWNrIGlmIGEgcmVs b2FkIGlzIHBlbmRpbmcgcm91Z2hseSBvbmNlIHBlciBibG9jayBub3csIHdoZW4gY2hlY2tpbmcK aWYgd2UgbmVlZCB0byBkZWxheS4KCk5vdGUgdGhhdCBhdXRvdmFjdXVtIGlzIHVuYWZmZWN0ZWQg YnkgdGhpcyBjaGFuZ2UuIEF1dG92YWN1dW0gd29ya2VycwpvdmVyd3JpdGUgdGhlIHZhbHVlIG9m IFZhY3V1bUNvc3RMaW1pdCBhbmQgVmFjdXVtQ29zdERlbGF5IHdpdGggdGhlaXIKb3duIFdvcmtl ckluZm8tPndpX2Nvc3RfbGltaXQgYW5kIHdpX2Nvc3RfZGVsYXkuIFdyaXRpbmcgdG8gdGhlaXIK d2lfY29zdF9kZWxheSBtb3JlIG9mdGVuIG1ha2VzIHJlYWRpbmcgd2lfY29zdF9kZWxheSB3aXRo b3V0IGEgbG9jayB0bwp1cGRhdGUgVmFjdXVtQ29zdERlbGF5IGFuIGV2ZW4gd29yc2UgaWRlYS4K ClJldmlld2VkLWJ5OiBNYXNhaGlrbyBTYXdhZGEgPHNhd2FkYS5tc2hrQGdtYWlsLmNvbT4KUmV2 aWV3ZWQtYnk6IERhbmllbCBHdXN0YWZzc29uIDxkYW5pZWxAeWVzcWwuc2U+CkRpc2N1c3Npb246 IGh0dHBzOi8vd3d3LnBvc3RncmVzcWwub3JnL21lc3NhZ2UtaWQvZmxhdC9DQUFLUnVfYnVQNXd6 c2hvM3FOdzVvOV9SMHBGNjlGUk01aGdDbXItbXZYbUdYd2RBN0ElNDBtYWlsLmdtYWlsLmNvbSM1 ZTY3NzFkNGNkY2E0ZGI2ZWZjMmFjZWMyZGNlMGJjNwotLS0KIHNyYy9iYWNrZW5kL2NvbW1hbmRz L3ZhY3V1bS5jIHwgNjEgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0tLS0KIDEgZmls ZSBjaGFuZ2VkLCA1MyBpbnNlcnRpb25zKCspLCA4IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBh L3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFj dXVtLmMKaW5kZXggZWIxMjZmMjI0Ny4uN2UzYThlNDA0ZSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tl bmQvY29tbWFuZHMvdmFjdXVtLmMKKysrIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMK QEAgLTQ4LDYgKzQ4LDcgQEAKICNpbmNsdWRlICJwZ3N0YXQuaCIKICNpbmNsdWRlICJwb3N0bWFz dGVyL2F1dG92YWN1dW0uaCIKICNpbmNsdWRlICJwb3N0bWFzdGVyL2Jnd29ya2VyX2ludGVybmFs cy5oIgorI2luY2x1ZGUgInBvc3RtYXN0ZXIvaW50ZXJydXB0LmgiCiAjaW5jbHVkZSAic3RvcmFn ZS9idWZtZ3IuaCIKICNpbmNsdWRlICJzdG9yYWdlL2xtZ3IuaCIKICNpbmNsdWRlICJzdG9yYWdl L3Btc2lnbmFsLmgiCkBAIC03Niw2ICs3Nyw3IEBAIGludAkJCXZhY3V1bV9tdWx0aXhhY3RfZmFp bHNhZmVfYWdlOwogLyogQSBmZXcgdmFyaWFibGVzIHRoYXQgZG9uJ3Qgc2VlbSB3b3J0aCBwYXNz aW5nIGFyb3VuZCBhcyBwYXJhbWV0ZXJzICovCiBzdGF0aWMgTWVtb3J5Q29udGV4dCB2YWNfY29u dGV4dCA9IE5VTEw7CiBzdGF0aWMgQnVmZmVyQWNjZXNzU3RyYXRlZ3kgdmFjX3N0cmF0ZWd5Owor c3RhdGljIGJvb2wgYW5hbHl6ZV9pbl9vdXRlcl94YWN0ID0gZmFsc2U7CiAKIAogLyoKQEAgLTMx NCw4ICszMTYsNyBAQCB2YWN1dW0oTGlzdCAqcmVsYXRpb25zLCBWYWN1dW1QYXJhbXMgKnBhcmFt cywKIAlzdGF0aWMgYm9vbCBpbl92YWN1dW0gPSBmYWxzZTsKIAogCWNvbnN0IGNoYXIgKnN0bXR0 eXBlOwotCXZvbGF0aWxlIGJvb2wgaW5fb3V0ZXJfeGFjdCwKLQkJCQl1c2Vfb3duX3hhY3RzOwor CXZvbGF0aWxlIGJvb2wgdXNlX293bl94YWN0czsKIAogCUFzc2VydChwYXJhbXMgIT0gTlVMTCk7 CiAKQEAgLTMzMiwxMCArMzMzLDEwIEBAIHZhY3V1bShMaXN0ICpyZWxhdGlvbnMsIFZhY3V1bVBh cmFtcyAqcGFyYW1zLAogCWlmIChwYXJhbXMtPm9wdGlvbnMgJiBWQUNPUFRfVkFDVVVNKQogCXsK IAkJUHJldmVudEluVHJhbnNhY3Rpb25CbG9jayhpc1RvcExldmVsLCBzdG10dHlwZSk7Ci0JCWlu X291dGVyX3hhY3QgPSBmYWxzZTsKKwkJYW5hbHl6ZV9pbl9vdXRlcl94YWN0ID0gZmFsc2U7CiAJ fQogCWVsc2UKLQkJaW5fb3V0ZXJfeGFjdCA9IElzSW5UcmFuc2FjdGlvbkJsb2NrKGlzVG9wTGV2 ZWwpOworCQlhbmFseXplX2luX291dGVyX3hhY3QgPSBJc0luVHJhbnNhY3Rpb25CbG9jayhpc1Rv cExldmVsKTsKIAogCS8qCiAJICogRHVlIHRvIHN0YXRpYyB2YXJpYWJsZXMgdmFjX2NvbnRleHQs IGFubF9jb250ZXh0IGFuZCB2YWNfc3RyYXRlZ3ksCkBAIC00NTcsNyArNDU4LDcgQEAgdmFjdXVt KExpc3QgKnJlbGF0aW9ucywgVmFjdXVtUGFyYW1zICpwYXJhbXMsCiAJCUFzc2VydChwYXJhbXMt Pm9wdGlvbnMgJiBWQUNPUFRfQU5BTFlaRSk7CiAJCWlmIChJc0F1dG9WYWN1dW1Xb3JrZXJQcm9j ZXNzKCkpCiAJCQl1c2Vfb3duX3hhY3RzID0gdHJ1ZTsKLQkJZWxzZSBpZiAoaW5fb3V0ZXJfeGFj dCkKKwkJZWxzZSBpZiAoYW5hbHl6ZV9pbl9vdXRlcl94YWN0KQogCQkJdXNlX293bl94YWN0cyA9 IGZhbHNlOwogCQllbHNlIGlmIChsaXN0X2xlbmd0aChyZWxhdGlvbnMpID4gMSkKIAkJCXVzZV9v d25feGFjdHMgPSB0cnVlOwpAQCAtNDc1LDcgKzQ3Niw3IEBAIHZhY3V1bShMaXN0ICpyZWxhdGlv bnMsIFZhY3V1bVBhcmFtcyAqcGFyYW1zLAogCSAqLwogCWlmICh1c2Vfb3duX3hhY3RzKQogCXsK LQkJQXNzZXJ0KCFpbl9vdXRlcl94YWN0KTsKKwkJQXNzZXJ0KCFhbmFseXplX2luX291dGVyX3hh Y3QpOwogCiAJCS8qIEFjdGl2ZVNuYXBzaG90IGlzIG5vdCBzZXQgYnkgYXV0b3ZhY3V1bSAqLwog CQlpZiAoQWN0aXZlU25hcHNob3RTZXQoKSkKQEAgLTU0NCw3ICs1NDUsNyBAQCB2YWN1dW0oTGlz dCAqcmVsYXRpb25zLCBWYWN1dW1QYXJhbXMgKnBhcmFtcywKIAkJCQl9CiAKIAkJCQlhbmFseXpl X3JlbCh2cmVsLT5vaWQsIHZyZWwtPnJlbGF0aW9uLCBwYXJhbXMsCi0JCQkJCQkJdnJlbC0+dmFf Y29scywgaW5fb3V0ZXJfeGFjdCwgdmFjX3N0cmF0ZWd5KTsKKwkJCQkJCQl2cmVsLT52YV9jb2xz LCBhbmFseXplX2luX291dGVyX3hhY3QsIHZhY19zdHJhdGVneSk7CiAKIAkJCQlpZiAodXNlX293 bl94YWN0cykKIAkJCQl7CkBAIC01NjgsNiArNTY5LDcgQEAgdmFjdXVtKExpc3QgKnJlbGF0aW9u cywgVmFjdXVtUGFyYW1zICpwYXJhbXMsCiAJCWluX3ZhY3V1bSA9IGZhbHNlOwogCQlWYWN1dW1D b3N0SW5hY3RpdmUgPSBWQUNVVU1fQ09TVF9JTkFDVElWRV9BTkRfVU5MT0NLRUQ7CiAJCVZhY3V1 bUNvc3RCYWxhbmNlID0gMDsKKwkJYW5hbHl6ZV9pbl9vdXRlcl94YWN0ID0gZmFsc2U7CiAJfQog CVBHX0VORF9UUlkoKTsKIApAQCAtMjIzMyw3ICsyMjM1LDUwIEBAIHZhY3V1bV9kZWxheV9wb2lu dCh2b2lkKQogCS8qIEFsd2F5cyBjaGVjayBmb3IgaW50ZXJydXB0cyAqLwogCUNIRUNLX0ZPUl9J TlRFUlJVUFRTKCk7CiAKLQlpZiAoVmFjdXVtQ29zdEluYWN0aXZlIHx8IEludGVycnVwdFBlbmRp bmcpCisJaWYgKEludGVycnVwdFBlbmRpbmcgfHwKKwkJKFZhY3V1bUNvc3RJbmFjdGl2ZSAmJiAh Q29uZmlnUmVsb2FkUGVuZGluZykpCisJCXJldHVybjsKKworCS8qCisJICogUmVsb2FkIHRoZSBj b25maWd1cmF0aW9uIGZpbGUgaWYgcmVxdWVzdGVkLiBUaGlzIGFsbG93cyBjaGFuZ2VzIHRvCisJ ICogdmFjdXVtX2Nvc3RfbGltaXQgYW5kIHZhY3V1bV9jb3N0X2RlbGF5IHRvIHRha2UgZWZmZWN0 IHdoaWxlIGEgdGFibGUgaXMKKwkgKiBiZWluZyB2YWN1dW1lZCBvciBhbmFseXplZC4gQW5hbHl6 ZSBzaG91bGQgbm90IHJlbG9hZCBjb25maWd1cmF0aW9uIGZpbGUKKwkgKiBpZiBpdCBpcyBpbiBh biBvdXRlciB0cmFuc2FjdGlvbiwgYXMgd2UgY3VycmVudGx5IG9ubHkgYWxsb3cKKwkgKiBjb25m aWd1cmF0aW9uIHJlbG9hZCB3aGVuIGluIHRvcC1sZXZlbCBzdGF0ZW1lbnRzLgorCSAqLworCWlm IChDb25maWdSZWxvYWRQZW5kaW5nICYmICFhbmFseXplX2luX291dGVyX3hhY3QpCisJeworCQlD b25maWdSZWxvYWRQZW5kaW5nID0gZmFsc2U7CisJCVByb2Nlc3NDb25maWdGaWxlKFBHQ19TSUdI VVApOworCisJCS8qCisJCSAqIEF1dG92YWN1dW0gd29ya2VycyBtdXN0IHJlc3RvcmUgdGhlIGNv cnJlY3QgdmFsdWVzIG9mCisJCSAqIFZhY3V1bUNvc3RMaW1pdCBhbmQgVmFjdXVtQ29zdERlbGF5 IGluIGNhc2UgdGhleSB3ZXJlIG92ZXJ3cml0dGVuCisJCSAqIGJ5IHJlbG9hZC4KKwkJICovCisJ CUF1dG9WYWN1dW1VcGRhdGVEZWxheSgpOworCisJCS8qCisJCSAqIElmIGNvbmZpZ3VyYXRpb24g Y2hhbmdlcyBhcmUgYWxsb3dlZCB0byBpbXBhY3QgVmFjdXVtQ29zdEluYWN0aXZlLAorCQkgKiBt YWtlIHN1cmUgaXQgaXMgdXBkYXRlZC4KKwkJICovCisJCWlmIChWYWN1dW1Db3N0SW5hY3RpdmUg PT0gVkFDVVVNX0NPU1RfSU5BQ1RJVkVfQU5EX0xPQ0tFRCkKKwkJCXJldHVybjsKKworCQlpZiAo VmFjdXVtQ29zdERlbGF5ID4gMCkKKwkJCVZhY3V1bUNvc3RJbmFjdGl2ZSA9IFZBQ1VVTV9DT1NU X0FDVElWRTsKKwkJZWxzZQorCQl7CisJCQlWYWN1dW1Db3N0SW5hY3RpdmUgPSBWQUNVVU1fQ09T VF9JTkFDVElWRV9BTkRfVU5MT0NLRUQ7CisJCQlWYWN1dW1Db3N0QmFsYW5jZSA9IDA7CisJCX0K Kwl9CisKKwkvKgorCSAqIElmIHdlIGRpc2FibGVkIGNvc3QtYmFzZWQgZGVsYXlzIGFmdGVyIHJl bG9hZGluZyB0aGUgY29uZmlnIGZpbGUsCisJICogcmV0dXJuLgorCSAqLworCWlmIChWYWN1dW1D b3N0SW5hY3RpdmUpCiAJCXJldHVybjsKIAogCS8qCi0tIAoyLjM3LjIKCg== --00000000000020347705f80f706d--