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 1phJn8-0008Ic-O8 for pgsql-hackers@arkaria.postgresql.org; Wed, 29 Mar 2023 00:35:55 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.92) (envelope-from ) id 1phJn5-0005BE-Rx for pgsql-hackers@arkaria.postgresql.org; Wed, 29 Mar 2023 00:35:51 +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 1phJn5-0005AX-2r for pgsql-hackers@lists.postgresql.org; Wed, 29 Mar 2023 00:35:51 +0000 Received: from mail-pl1-x62d.google.com ([2607:f8b0:4864:20::62d]) by makus.postgresql.org with esmtps (TLS1.3:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.92) (envelope-from ) id 1phJmw-00008U-Ly for pgsql-hackers@postgresql.org; Wed, 29 Mar 2023 00:35:49 +0000 Received: by mail-pl1-x62d.google.com with SMTP id f22so9246967plr.0 for ; Tue, 28 Mar 2023 17:35:42 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; t=1680050141; x=1682642141; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:from:to:cc:subject:date:message-id:reply-to; bh=t6yNERDQmdi/yqYd4txVTSNahZ7SXoolqzupePIo3kg=; b=HdtelO6fVEBitNTmkRo+rr35UNDLf9qsQX6xkdekCHfzlLtyimXhfKDvp4jf2EffEd ki6uW0JwBItDunJ4kvDv5WRtLIWFtJXT1Zh1KOK5g326LPKiPzzl1IfSAIsPJKU0tA71 6gW9mtWzK67XoZpsmINZ/bk74kJdnClMS4de9nDq8leTW6v1UYJW+qnQTAmymJeEpbX7 RtblpU+kPoHuy8SvOgE9T6zOopL0eg1l91oe+orc1uz0YFxv3GjS4GsPVbjucDBpGBCw gdpL3Rn3ygyrcvOJf98077zZ0mXCJskLD0Tn8h7N492cuUN54U/9a3HGKsXNxk4FOtta IbqQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; t=1680050141; x=1682642141; 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=t6yNERDQmdi/yqYd4txVTSNahZ7SXoolqzupePIo3kg=; b=JvJ5BdoC0D4Y37gHsnW+gXKF29h8kRXu+/oQ70OCV4VG9zkw5Rcl3I1nyABCn2pa/5 NV66tpIdUT4q9he21vqqlYgz7Sa/dYqQREeZRB4/15gRNOLnmzr61aihBQiVhu4rqHAe cVfaT4NBVDt+E7L0EVugbjSWtvdb1Euk09JPuvFg7DT6r0EgzjmqnmoqMzSn87FQk5tB fAciYYadLJ7Qzzb16h9dik2eLZHlqmSYJQYc6WZk3fJemsHLmbMfX4nWw9NkD75jYHYJ MUYs8/ZXxp8a5VolyjZ31p+UhBVQlZudbRPZbvc3VibZ+P0rSQCegAKKZ0LHhQ5GyTv+ xX4g== X-Gm-Message-State: AAQBX9f0RePkkWuNDMMvRQSlzMRVIv5NiYCQEL7JHpJhFdzLpi/uGWXP t50xvbwqb230CVRqwazmbFzO5jJ0lLjPM7FD1hc= X-Google-Smtp-Source: AKy350ZkbAqofyNivcWuMBrjoTUmIMg/14f9eR0jf6/Cauxoy9ONzvJULJC1zL855ur961SuixWNoBggWRRo5qtE/04= X-Received: by 2002:a17:902:da8e:b0:1a1:d366:b0b2 with SMTP id j14-20020a170902da8e00b001a1d366b0b2mr6162342plx.11.1680050140862; Tue, 28 Mar 2023 17:35:40 -0700 (PDT) MIME-Version: 1.0 References: <20230328.172147.1984729741959637354.horikyota.ntt@gmail.com> In-Reply-To: <20230328.172147.1984729741959637354.horikyota.ntt@gmail.com> From: Melanie Plageman Date: Tue, 28 Mar 2023 20:35:28 -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="000000000000daa23105f7ff275b" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --000000000000daa23105f7ff275b Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable 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 > > So, I've attached an alternate version of the patchset which takes the > > approach of having one commit which only enables cost-based delay GUC > > refresh for VACUUM and another commit which enables it for autovacuum > > and makes the changes to balancing variables. > > > > I still think the commit which has workers updating their own > > wi_cost_delay in vacuum_delay_point() is a bit weird. It relies on no o= ne > > else emulating our bad behavior and reading from wi_cost_delay without = a > > lock and on no one else deciding to ever write to wi_cost_delay (even > > though it is in shared memory [this is the same as master]). It is only > > safe because our process is the only one (right now) writing to > > wi_cost_delay, so when we read from it without a lock, we know it isn't > > being written to. And everyone else takes a lock when reading from > > wi_cost_delay right now. So, it seems...not great. > > > > This approach also introduces a function that is only around for > > one commit until the next commit obsoletes it, which seems a bit silly. > > (I'm not sure what this refers to, though..) I don't think it's silly > if a later patch removes something that the preceding patches > introdcued, as long as that contributes to readability. Untimately, > they will be merged together on committing. I was under the impression that reviewers thought config reload and worker balance changes should be committed in separate commits. Either way, the ephemeral function is not my primary concern. I felt more uncomfortable with increasing how often we update a double in shared memory which is read without acquiring a lock. > > Basically, I think it is probably better to just have one commit > > enabling guc refresh for VACUUM and then another which correctly > > implements what is needed for autovacuum to do the same. > > Attached v9 does this. > > > > I've provided both complete versions of both approaches (v9 and v8). > > I took a look at v9 and have a few comments. > > 0001: > > I don't believe it is necessary, as mentioned in the commit > message. It apperas that we are resetting it at the appropriate times. VacuumCostBalance must be zeroed out when we disable vacuum cost. Previously, we did not reenable VacuumCostActive once it was disabled, but now that we do, I think it is good practice to always zero out VacuumCostBalance when we disable vacuum cost. I will squash this commit into the one introducing VacuumCostInactive, though. > > 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 failsafe 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. > I think it'd be simpler to add a global boolean (maybe > VacuumCostActiveForceDisable or such) that forces VacuumCostActive to > be false and set VacuumCostActive using a setter function that follows > the boolean. I think maintaining an additional global variable is more brittle than including the information in a single variable. > 0003: > > + * Reload the configuration file if requested. This allows change= s to > + * vacuum_cost_limit and vacuum_cost_delay to take effect while a= table is > + * being vacuumed or analyzed. Analyze should not reload configur= ation > + * file if it is in an outer transaction, as GUC values shouldn't= be > + * allowed to refer to some uncommitted state (e.g. database obje= cts > + * 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. > 0004: > - double at_vacuum_cost_delay; > - int at_vacuum_cost_limit; > + double at_table_option_vac_cost_delay; > + int at_table_option_vac_cost_limit; > > We call that options "relopt(ion)". I don't think there's any reason > to use different names. I've updated the names. > dlist_head av_runningWorkers; > WorkerInfo av_startingWorker; > AutoVacuumWorkItem av_workItems[NUM_WORKITEMS]; > + pg_atomic_uint32 av_nworkers_for_balance; > > The name of the new member doesn't seem to follow the surrounding > convention. (However, I don't think the member is needed. See below.) I've updated the name to fit the convention better. > - /* > - * Remember the prevailing values of the vacuum cost GUCs= . We have to > - * restore these at the bottom of the loop, else we'll co= mpute wrong > - * values in the next iteration of autovac_balance_cost()= . > - */ > - stdVacuumCostDelay =3D VacuumCostDelay; > - stdVacuumCostLimit =3D VacuumCostLimit; > + av_table_option_cost_limit =3D tab->at_table_option_vac_c= ost_limit; > + av_table_option_cost_delay =3D tab->at_table_option_vac_c= ost_delay; > > I think this requires a comment. I've added one. > > + /* There is at least 1 autovac worker (this worker). */ > + int nworkers_for_balance =3D Max(pg_a= tomic_read_u32( > + &AutoVacu= umShmem->av_nworkers_for_balance), 1); > > I think it *must* be greater than 0. However, to begin with, I don't > think we need that variable to be shared. I don't believe it matters > if we count involved workers every time we calculate the delay. We are not calculating the delay but the cost limit. The cost limit must be balanced across all of the workers currently actively vacuuming tables without cost-related table options. There shouldn't be a way for this to be zero, since this worker calls autovac_balance_cost() before it starts vacuuming the table. I wanted to rule out any possibility of a divide by 0 issue. I have changed it to an assert instead. > +/* > + * autovac_balance_cost > + * Recalculate the number of workers to consider, given tabl= e options and > + * the current number of active workers. > + * > + * Caller must hold the AutovacuumLock in at least shared mode. > > The function name doesn't seem align with what it does. However, I > mentioned above that it might be unnecessary. This is the same name as the function had previously. However, I think it does make sense to rename it. The cost limit must be balanced across the workers. This function calculated how many workers the cost limit should be balanced across. I renamed it to autovac_recalculate_workers_for_balance() > +AutoVacuumUpdateLimit(void) > > If I'm not missing anything, this function does something quite > different from the original autovac_balance_cost(). The original > function distributes the total cost based on the GUC variables among > workers proportionally according to each worker's cost > parameters. Howevwer, this function distributes the total cost > equally. Yes, as I mentioned in the commit message, because all the workers now have no reason to have different cost parameters (due to reloading the config file on almost every page), there is no reason to use ratios. Workers vacuuming a table with no cost-related table options simply need to divide the limit equally amongst themselves because they all will have the same limit and delay values. > > + int vac_cost_limit =3D autovacuum_vac= _cost_limit > 0 ? > + autovacuum_vac_cost_limit : VacuumCostLimit; > ... > + int balanced_cost_limit =3D vac_cost_= limit / nworkers_for_balance; > ... > + VacuumCostLimit =3D Max(Min(balanced_cost_limit, vac_cost= _limit), 1); > } > > This seems to repeatedly divide VacuumCostLimit by > nworkers_for_balance. I'm not sure, but this function might only be > called after a reload. If that's the case, I don't think it's safe > coding, even if it works. Good point about repeatedly dividing VacuumCostLimit by nworkers_for_balance. I've added a variable to keep track of the base cost limit and separated the functionality of updating the limit into two parts -- one AutoVacuumUpdateLimit() which is only meant to be called after reload and references VacuumCostLimit to set the av_base_cost_limit and another, AutoVacuumBalanceLimit(), which only overrides VacuumCostLimit but uses av_base_cost_limit. I've noted in the comments that AutoVacuumBalanceLimit() should be called to adjust to a potential change in nworkers_for_balance (currently every time after we sleep in vacuum_delay_point()) and AutoVacuumUpdateLimit() should only be called once after a config reload, as it references VacuumCostLimit. I will note that this problem also exists in master, as autovac_balance_cost references VacuumCostLimit in order to set worker cost limits and then AutoVacuumUpdateDelay() overrides VacuumCostLimit with the value calculated in autovac_balance_cost() from VacuumCostLimit. v10 attached with mentioned updates. - Melanie --000000000000daa23105f7ff275b Content-Type: text/x-patch; charset="US-ASCII"; name="v10-0001-Make-VacuumCostActive-failsafe-aware.patch" Content-Disposition: attachment; filename="v10-0001-Make-VacuumCostActive-failsafe-aware.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lfsyezhu0 RnJvbSBjZmE3M2M5MDg2ZjczN2VjMTAzYjNjYWEwMzE3NWI4MzdjNTU2NWNiIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBTYXQsIDI1IE1hciAyMDIzIDEyOjA1OjE4IC0wNDAwClN1YmplY3Q6IFtQ QVRDSCB2MTAgMS8zXSBNYWtlIFZhY3V1bUNvc3RBY3RpdmUgZmFpbHNhZmUtYXdhcmUKCldoaWxl 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 YWdlL2J1ZmZlci9idWZtZ3IuYwppbmRleCA5NTIxMmEzOTQxLi42ZDNkZDI2ZmM3IDEwMDY0NAot LS0gYS9zcmMvYmFja2VuZC9zdG9yYWdlL2J1ZmZlci9idWZtZ3IuYworKysgYi9zcmMvYmFja2Vu ZC9zdG9yYWdlL2J1ZmZlci9idWZtZ3IuYwpAQCAtODkzLDcgKzg5Myw3IEBAIFJlYWRCdWZmZXJf Y29tbW9uKFNNZ3JSZWxhdGlvbiBzbWdyLCBjaGFyIHJlbHBlcnNpc3RlbmNlLCBGb3JrTnVtYmVy IGZvcmtOdW0sCiAJCQkqaGl0ID0gdHJ1ZTsKIAkJCVZhY3V1bVBhZ2VIaXQrKzsKIAotCQkJaWYg KFZhY3V1bUNvc3RBY3RpdmUpCisJCQlpZiAoIVZhY3V1bUNvc3RJbmFjdGl2ZSkKIAkJCQlWYWN1 dW1Db3N0QmFsYW5jZSArPSBWYWN1dW1Db3N0UGFnZUhpdDsKIAogCQkJVFJBQ0VfUE9TVEdSRVNR TF9CVUZGRVJfUkVBRF9ET05FKGZvcmtOdW0sIGJsb2NrTnVtLApAQCAtMTA5OCw3ICsxMDk4LDcg QEAgUmVhZEJ1ZmZlcl9jb21tb24oU01nclJlbGF0aW9uIHNtZ3IsIGNoYXIgcmVscGVyc2lzdGVu Y2UsIEZvcmtOdW1iZXIgZm9ya051bSwKIAl9CiAKIAlWYWN1dW1QYWdlTWlzcysrOwotCWlmIChW YWN1dW1Db3N0QWN0aXZlKQorCWlmICghVmFjdXVtQ29zdEluYWN0aXZlKQogCQlWYWN1dW1Db3N0 QmFsYW5jZSArPSBWYWN1dW1Db3N0UGFnZU1pc3M7CiAKIAlUUkFDRV9QT1NUR1JFU1FMX0JVRkZF Ul9SRUFEX0RPTkUoZm9ya051bSwgYmxvY2tOdW0sCkBAIC0xNjcyLDcgKzE2NzIsNyBAQCBNYXJr QnVmZmVyRGlydHkoQnVmZmVyIGJ1ZmZlcikKIAl7CiAJCVZhY3V1bVBhZ2VEaXJ0eSsrOwogCQlw Z0J1ZmZlclVzYWdlLnNoYXJlZF9ibGtzX2RpcnRpZWQrKzsKLQkJaWYgKFZhY3V1bUNvc3RBY3Rp dmUpCisJCWlmICghVmFjdXVtQ29zdEluYWN0aXZlKQogCQkJVmFjdXVtQ29zdEJhbGFuY2UgKz0g VmFjdXVtQ29zdFBhZ2VEaXJ0eTsKIAl9CiB9CkBAIC00MTk5LDcgKzQxOTksNyBAQCBNYXJrQnVm 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= --000000000000daa23105f7ff275b Content-Type: text/x-patch; charset="US-ASCII"; name="v10-0003-Autovacuum-refreshes-cost-based-delay-params-mor.patch" Content-Disposition: attachment; filename="v10-0003-Autovacuum-refreshes-cost-based-delay-params-mor.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lfsyezi02 RnJvbSBiNDQxYmM1NmE4MjdlMGRkNWM1MDc4ZmRmODNkYjc5YmQ5YzkzOGVjIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBTYXQsIDI1IE1hciAyMDIzIDE0OjE0OjU1IC0wNDAwClN1YmplY3Q6IFtQ QVRDSCB2MTAgMy8zXSBBdXRvdmFjdXVtIHJlZnJlc2hlcyBjb3N0LWJhc2VkIGRlbGF5IHBhcmFt cyBtb3JlCiBvZnRlbgoKVGhlIHByZXZpb3VzIGNvbW1pdCBhbGxvd2VkIFZBQ1VVTSB0byByZWxv YWQgdGhlIGNvbmZpZyBmaWxlIG1vcmUgb2Z0ZW4Kc28gdGhhdCBjb3N0LWJhc2VkIGRlbGF5IHBh cmFtZXRlcnMgY291bGQgdGFrZSBlZmZlY3Qgd2hpbGUgVkFDVVVNaW5nIGEKcmVsYXRpb24uIEF1 dG92YWN1dW0sIGhvd2V2ZXIgZGlkIG5vdCBiZW5lZml0IGZyb20gdGhpcyBjaGFuZ2UuCgpJbiBv cmRlciBmb3IgYXV0b3ZhY3V1bSB3b3JrZXJzIHRvIHNhZmVseSB1cGRhdGUgdGhlaXIgb3duIGNv c3QgZGVsYXkKYW5kIGNvc3QgbGltaXQgcGFyYW1ldGVycyB3aXRob3V0IGltcGFjdGluZyBwZXJm b3JtYW5jZSwgd2UgaGFkIHRvCnJldGhpbmsgd2hlbiBhbmQgaG93IHRoZXNlIHZhbHVlcyB3ZXJl IGFjY2Vzc2VkLgoKUHJldmlvdXNseSwgYW4gYXV0b3ZhY3V1bSB3b3JrZXIncyB3aV9jb3N0X2xp bWl0IHdhcyBzZXQgb25seSBhdCB0aGUKYmVnaW5uaW5nIG9mIHZhY3V1bWluZyBhIHRhYmxlLCBh ZnRlciByZWxvYWRpbmcgdGhlIGNvbmZpZyBmaWxlLgpUaGVyZWZvcmUsIGF0IHRoZSB0aW1lIHRo YXQgYXV0b3ZhY19iYWxhbmNlX2Nvc3QoKSBpcyBjYWxsZWQsIHdvcmtlcnMKdmFjdXVtaW5nIHRh YmxlcyB3aXRoIG5vIHRhYmxlIG9wdGlvbnMgY291bGQgc3RpbGwgaGF2ZSBkaWZmZXJlbnQgdmFs dWVzCmZvciB0aGVpciB3aV9jb3N0X2xpbWl0X2Jhc2UgYW5kIHdpX2Nvc3RfZGVsYXkuCgpOb3cg dGhhdCB0aGUgY29zdCBwYXJhbWV0ZXJzIGNhbiBiZSB1cGRhdGVkIHdoaWxlIHZhY3V1bWluZyBh IHRhYmxlLAp3b3JrZXJzIHdpbGwgKHdpdGhpbiBzb21lIG1hcmdpbiBvZiBlcnJvcikgaGF2ZSBu byByZWFzb24gdG8gaGF2ZQpkaWZmZXJlbnQgdmFsdWVzIGZvciBjb3N0IGxpbWl0IGFuZCBjb3N0 IGRlbGF5IChpbiB0aGUgYWJzZW5jZSBvZiB0YWJsZQpvcHRpb25zKS4gVGhpcyByZW1vdmVzIHRo ZSByYXRpb25hbGUgZm9yIGtlZXBpbmcgY29zdCBsaW1pdCBhbmQgY29zdApkZWxheSBpbiBzaGFy ZWQgbWVtb3J5LiBCYWxhbmNpbmcgdGhlIGNvc3QgbGltaXQgcmVxdWlyZXMgb25seSB0aGUKbnVt YmVyIG9mIGFjdGl2ZSBhdXRvdmFjdXVtIHdvcmtlcnMgdmFjdXVtaW5nIGEgdGFibGUgd2l0aCBu byBjb3N0LWJhc2VkCnRhYmxlIG9wdGlvbnMuCi0tLQogc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFj dXVtLmMgICAgICAgfCAgMjIgKystCiBzcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0u YyB8IDI3MSArKysrKysrKysrKysrKystLS0tLS0tLS0tLS0tCiBzcmMvaW5jbHVkZS9wb3N0bWFz dGVyL2F1dG92YWN1dW0uaCB8ICAgMiArCiAzIGZpbGVzIGNoYW5nZWQsIDE2NSBpbnNlcnRpb25z KCspLCAxMzAgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMv dmFjdXVtLmMgYi9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW0uYwppbmRleCA3ZTNhOGU0MDRl Li5lOWI2ODM4MDVhIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW0uYwor KysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW0uYwpAQCAtMjI0MSwxMCArMjI0MSwxMCBA QCB2YWN1dW1fZGVsYXlfcG9pbnQodm9pZCkKIAogCS8qCiAJICogUmVsb2FkIHRoZSBjb25maWd1 cmF0aW9uIGZpbGUgaWYgcmVxdWVzdGVkLiBUaGlzIGFsbG93cyBjaGFuZ2VzIHRvCi0JICogdmFj dXVtX2Nvc3RfbGltaXQgYW5kIHZhY3V1bV9jb3N0X2RlbGF5IHRvIHRha2UgZWZmZWN0IHdoaWxl IGEgdGFibGUgaXMKLQkgKiBiZWluZyB2YWN1dW1lZCBvciBhbmFseXplZC4gQW5hbHl6ZSBzaG91 bGQgbm90IHJlbG9hZCBjb25maWd1cmF0aW9uIGZpbGUKLQkgKiBpZiBpdCBpcyBpbiBhbiBvdXRl ciB0cmFuc2FjdGlvbiwgYXMgd2UgY3VycmVudGx5IG9ubHkgYWxsb3cKLQkgKiBjb25maWd1cmF0 aW9uIHJlbG9hZCB3aGVuIGluIHRvcC1sZXZlbCBzdGF0ZW1lbnRzLgorCSAqIFthdXRvdmFjdXVt X112YWN1dW1fY29zdF9saW1pdCBhbmQgW2F1dG92YWN1dW1fXXZhY3V1bV9jb3N0X2RlbGF5IHRv CisJICogdGFrZSBlZmZlY3Qgd2hpbGUgYSB0YWJsZSBpcyBiZWluZyB2YWN1dW1lZCBvciBhbmFs eXplZC4gQW5hbHl6ZSBzaG91bGQKKwkgKiBub3QgcmVsb2FkIGNvbmZpZ3VyYXRpb24gZmlsZSBp ZiBpdCBpcyBpbiBhbiBvdXRlciB0cmFuc2FjdGlvbiwgYXMgd2UKKwkgKiBjdXJyZW50bHkgb25s eSBhbGxvdyBjb25maWd1cmF0aW9uIHJlbG9hZCB3aGVuIGluIHRvcC1sZXZlbCBzdGF0ZW1lbnRz LgogCSAqLwogCWlmIChDb25maWdSZWxvYWRQZW5kaW5nICYmICFhbmFseXplX2luX291dGVyX3hh Y3QpCiAJewpAQCAtMjI1NywxMCArMjI1NywxMiBAQCB2YWN1dW1fZGVsYXlfcG9pbnQodm9pZCkK IAkJICogYnkgcmVsb2FkLgogCQkgKi8KIAkJQXV0b1ZhY3V1bVVwZGF0ZURlbGF5KCk7CisJCUF1 dG9WYWN1dW1VcGRhdGVMaW1pdCgpOwogCiAJCS8qCiAJCSAqIElmIGNvbmZpZ3VyYXRpb24gY2hh bmdlcyBhcmUgYWxsb3dlZCB0byBpbXBhY3QgVmFjdXVtQ29zdEluYWN0aXZlLAotCQkgKiBtYWtl IHN1cmUgaXQgaXMgdXBkYXRlZC4KKwkJICogbWFrZSBzdXJlIGl0IGlzIHVwZGF0ZWQuIEF1dG92 YWN1dW0gd29ya2VycyB3aWxsIGhhdmUgYWxyZWFkeSBkb25lCisJCSAqIHRoaXMgaW4gQXV0b1Zh Y3V1bVVwZGF0ZURlbGF5KCkKIAkJICovCiAJCWlmIChWYWN1dW1Db3N0SW5hY3RpdmUgPT0gVkFD VVVNX0NPU1RfSU5BQ1RJVkVfQU5EX0xPQ0tFRCkKIAkJCXJldHVybjsKQEAgLTIzMTEsOCArMjMx MywxNCBAQCB2YWN1dW1fZGVsYXlfcG9pbnQodm9pZCkKIAogCQlWYWN1dW1Db3N0QmFsYW5jZSA9 IDA7CiAKLQkJLyogdXBkYXRlIGJhbGFuY2UgdmFsdWVzIGZvciB3b3JrZXJzICovCi0JCUF1dG9W YWN1dW1VcGRhdGVEZWxheSgpOworCQkvKgorCQkgKiBCYWxhbmNlIGFuZCB1cGRhdGUgbGltaXQg dmFsdWVzIGZvciBhdXRvdmFjdXVtIHdvcmtlcnMuIFdlIG11c3QKKwkJICogYWx3YXlzIGRvIHRo aXMgaW4gY2FzZSB0aGUgYXV0b3ZhY3V1bSBsYXVuY2hlciBvciBhbm90aGVyCisJCSAqIGF1dG92 YWN1dW0gd29ya2VyIGhhcyByZWNhbGN1bGF0ZWQgdGhlIG51bWJlciBvZiB3b3JrZXJzIGFjcm9z cworCQkgKiB3aGljaCB3ZSBtdXN0IGJhbGFuY2UgdGhlIGxpbWl0LiBUaGlzIGlzIGRvbmUgYnkg dGhlIGxhdW5jaGVyIHdoZW4KKwkJICogbGF1bmNoaW5nIGEgbmV3IHdvcmtlciBhbmQgYnkgd29y a2VycyBiZWZvcmUgdmFjdXVtaW5nIGVhY2ggdGFibGUuCisJCSAqLworCQlBdXRvVmFjdXVtQmFs YW5jZUxpbWl0KCk7CiAKIAkJLyogTWlnaHQgaGF2ZSBnb3R0ZW4gYW4gaW50ZXJydXB0IHdoaWxl IHNsZWVwaW5nICovCiAJCUNIRUNLX0ZPUl9JTlRFUlJVUFRTKCk7CmRpZmYgLS1naXQgYS9zcmMv YmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYyBiL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIv YXV0b3ZhY3V1bS5jCmluZGV4IDU4NWQyODE0OGMuLmM4ZGFlNTQ2NWEgMTAwNjQ0Ci0tLSBhL3Ny Yy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCisrKyBiL3NyYy9iYWNrZW5kL3Bvc3Rt YXN0ZXIvYXV0b3ZhY3V1bS5jCkBAIC0xMzksNiArMTM5LDEwIEBAIGludAkJCUxvZ19hdXRvdmFj dXVtX21pbl9kdXJhdGlvbiA9IDYwMDAwMDsKIHN0YXRpYyBib29sIGFtX2F1dG92YWN1dW1fbGF1 bmNoZXIgPSBmYWxzZTsKIHN0YXRpYyBib29sIGFtX2F1dG92YWN1dW1fd29ya2VyID0gZmFsc2U7 CiAKK3N0YXRpYyBkb3VibGUgYXZfcmVsb3B0X2Nvc3RfZGVsYXkgPSAtMTsKK3N0YXRpYyBpbnQJ YXZfcmVsb3B0X2Nvc3RfbGltaXQgPSAwOworc3RhdGljIGludAlhdl9iYXNlX2Nvc3RfbGltaXQg PSAwOworCiAvKiBGbGFncyBzZXQgYnkgc2lnbmFsIGhhbmRsZXJzICovCiBzdGF0aWMgdm9sYXRp bGUgc2lnX2F0b21pY190IGdvdF9TSUdVU1IyID0gZmFsc2U7CiAKQEAgLTE4OSw4ICsxOTMsOCBA QCB0eXBlZGVmIHN0cnVjdCBhdXRvdmFjX3RhYmxlCiB7CiAJT2lkCQkJYXRfcmVsaWQ7CiAJVmFj dXVtUGFyYW1zIGF0X3BhcmFtczsKLQlkb3VibGUJCWF0X3ZhY3V1bV9jb3N0X2RlbGF5OwotCWlu dAkJCWF0X3ZhY3V1bV9jb3N0X2xpbWl0OworCWRvdWJsZQkJYXRfcmVsb3B0X3ZhY19jb3N0X2Rl bGF5OworCWludAkJCWF0X3JlbG9wdF92YWNfY29zdF9saW1pdDsKIAlib29sCQlhdF9kb2JhbGFu Y2U7CiAJYm9vbAkJYXRfc2hhcmVkcmVsOwogCWNoYXIJICAgKmF0X3JlbG5hbWU7CkBAIC0yMDks NyArMjEzLDcgQEAgdHlwZWRlZiBzdHJ1Y3QgYXV0b3ZhY190YWJsZQogICogd2lfc2hhcmVkcmVs IGZsYWcgaW5kaWNhdGluZyB3aGV0aGVyIHRhYmxlIGlzIG1hcmtlZCByZWxpc3NoYXJlZAogICog d2lfcHJvYwkJcG9pbnRlciB0byBQR1BST0Mgb2YgdGhlIHJ1bm5pbmcgd29ya2VyLCBOVUxMIGlm IG5vdCBzdGFydGVkCiAgKiB3aV9sYXVuY2h0aW1lIFRpbWUgYXQgd2hpY2ggdGhpcyB3b3JrZXIg d2FzIGxhdW5jaGVkCi0gKiB3aV9jb3N0XyoJVmFjdXVtIGNvc3QtYmFzZWQgZGVsYXkgcGFyYW1l dGVycyBjdXJyZW50IGluIHRoaXMgd29ya2VyCisgKiB3aV9kb2JhbGFuY2UgV2hldGhlciB0aGlz IHdvcmtlciBzaG91bGQgYmUgaW5jbHVkZWQgaW4gYmFsYW5jZSBjYWxjdWxhdGlvbnMKICAqCiAg KiBBbGwgZmllbGRzIGFyZSBwcm90ZWN0ZWQgYnkgQXV0b3ZhY3V1bUxvY2ssIGV4Y2VwdCBmb3Ig d2lfdGFibGVvaWQgYW5kCiAgKiB3aV9zaGFyZWRyZWwgd2hpY2ggYXJlIHByb3RlY3RlZCBieSBB dXRvdmFjdXVtU2NoZWR1bGVMb2NrIChub3RlIHRoZXNlCkBAIC0yMjUsOSArMjI5LDYgQEAgdHlw ZWRlZiBzdHJ1Y3QgV29ya2VySW5mb0RhdGEKIAlUaW1lc3RhbXBUeiB3aV9sYXVuY2h0aW1lOwog CWJvb2wJCXdpX2RvYmFsYW5jZTsKIAlib29sCQl3aV9zaGFyZWRyZWw7Ci0JZG91YmxlCQl3aV9j b3N0X2RlbGF5OwotCWludAkJCXdpX2Nvc3RfbGltaXQ7Ci0JaW50CQkJd2lfY29zdF9saW1pdF9i YXNlOwogfSBXb3JrZXJJbmZvRGF0YTsKIAogdHlwZWRlZiBzdHJ1Y3QgV29ya2VySW5mb0RhdGEg KldvcmtlckluZm87CkBAIC0yNzMsNiArMjc0LDggQEAgdHlwZWRlZiBzdHJ1Y3QgQXV0b1ZhY3V1 bVdvcmtJdGVtCiAgKiBhdl9zdGFydGluZ1dvcmtlciBwb2ludGVyIHRvIFdvcmtlckluZm8gY3Vy cmVudGx5IGJlaW5nIHN0YXJ0ZWQgKGNsZWFyZWQgYnkKICAqCQkJCQl0aGUgd29ya2VyIGl0c2Vs ZiBhcyBzb29uIGFzIGl0J3MgdXAgYW5kIHJ1bm5pbmcpCiAgKiBhdl93b3JrSXRlbXMJCXdvcmsg aXRlbSBhcnJheQorICogYXZfbndvcmtlcnNGb3JCYWxhbmNlIHRoZSBudW1iZXIgb2YgYXV0b3Zh Y3V1bSB3b3JrZXJzIHRvIHVzZSB3aGVuCisgKiAJCQkJCWNhbGN1bGF0aW5nIHRoZSBwZXIgd29y a2VyIGNvc3QgbGltaXQKICAqCiAgKiBUaGlzIHN0cnVjdCBpcyBwcm90ZWN0ZWQgYnkgQXV0b3Zh Y3V1bUxvY2ssIGV4Y2VwdCBmb3IgYXZfc2lnbmFsIGFuZCBwYXJ0cwogICogb2YgdGhlIHdvcmtl ciBsaXN0IChzZWUgYWJvdmUpLgpAQCAtMjg2LDYgKzI4OSw3IEBAIHR5cGVkZWYgc3RydWN0CiAJ ZGxpc3RfaGVhZAlhdl9ydW5uaW5nV29ya2VyczsKIAlXb3JrZXJJbmZvCWF2X3N0YXJ0aW5nV29y a2VyOwogCUF1dG9WYWN1dW1Xb3JrSXRlbSBhdl93b3JrSXRlbXNbTlVNX1dPUktJVEVNU107CisJ cGdfYXRvbWljX3VpbnQzMiBhdl9ud29ya2Vyc0ZvckJhbGFuY2U7CiB9IEF1dG9WYWN1dW1TaG1l bVN0cnVjdDsKIAogc3RhdGljIEF1dG9WYWN1dW1TaG1lbVN0cnVjdCAqQXV0b1ZhY3V1bVNobWVt OwpAQCAtMzE5LDcgKzMyMyw3IEBAIHN0YXRpYyB2b2lkIGxhdW5jaF93b3JrZXIoVGltZXN0YW1w VHogbm93KTsKIHN0YXRpYyBMaXN0ICpnZXRfZGF0YWJhc2VfbGlzdCh2b2lkKTsKIHN0YXRpYyB2 b2lkIHJlYnVpbGRfZGF0YWJhc2VfbGlzdChPaWQgbmV3ZGIpOwogc3RhdGljIGludAlkYl9jb21w YXJhdG9yKGNvbnN0IHZvaWQgKmEsIGNvbnN0IHZvaWQgKmIpOwotc3RhdGljIHZvaWQgYXV0b3Zh Y19iYWxhbmNlX2Nvc3Qodm9pZCk7CitzdGF0aWMgdm9pZCBhdXRvdmFjX3JlY2FsY3VsYXRlX3dv cmtlcnNfZm9yX2JhbGFuY2Uodm9pZCk7CiAKIHN0YXRpYyB2b2lkIGRvX2F1dG92YWN1dW0odm9p ZCk7CiBzdGF0aWMgdm9pZCBGcmVlV29ya2VySW5mbyhpbnQgY29kZSwgRGF0dW0gYXJnKTsKQEAg LTY3MCw3ICs2NzQsNyBAQCBBdXRvVmFjTGF1bmNoZXJNYWluKGludCBhcmdjLCBjaGFyICphcmd2 W10pCiAJCQl7CiAJCQkJTFdMb2NrQWNxdWlyZShBdXRvdmFjdXVtTG9jaywgTFdfRVhDTFVTSVZF KTsKIAkJCQlBdXRvVmFjdXVtU2htZW0tPmF2X3NpZ25hbFtBdXRvVmFjUmViYWxhbmNlXSA9IGZh bHNlOwotCQkJCWF1dG92YWNfYmFsYW5jZV9jb3N0KCk7CisJCQkJYXV0b3ZhY19yZWNhbGN1bGF0 ZV93b3JrZXJzX2Zvcl9iYWxhbmNlKCk7CiAJCQkJTFdMb2NrUmVsZWFzZShBdXRvdmFjdXVtTG9j ayk7CiAJCQl9CiAKQEAgLTgyMCw4ICs4MjQsOCBAQCBIYW5kbGVBdXRvVmFjTGF1bmNoZXJJbnRl cnJ1cHRzKHZvaWQpCiAJCQlBdXRvVmFjTGF1bmNoZXJTaHV0ZG93bigpOwogCiAJCS8qIHJlYmFs YW5jZSBpbiBjYXNlIHRoZSBkZWZhdWx0IGNvc3QgcGFyYW1ldGVycyBjaGFuZ2VkICovCi0JCUxX TG9ja0FjcXVpcmUoQXV0b3ZhY3V1bUxvY2ssIExXX0VYQ0xVU0lWRSk7Ci0JCWF1dG92YWNfYmFs YW5jZV9jb3N0KCk7CisJCUxXTG9ja0FjcXVpcmUoQXV0b3ZhY3V1bUxvY2ssIExXX1NIQVJFRCk7 CisJCWF1dG92YWNfcmVjYWxjdWxhdGVfd29ya2Vyc19mb3JfYmFsYW5jZSgpOwogCQlMV0xvY2tS ZWxlYXNlKEF1dG92YWN1dW1Mb2NrKTsKIAogCQkvKiByZWJ1aWxkIHRoZSBsaXN0IGluIGNhc2Ug dGhlIG5hcHRpbWUgY2hhbmdlZCAqLwpAQCAtMTc1Niw5ICsxNzYwLDYgQEAgRnJlZVdvcmtlcklu Zm8oaW50IGNvZGUsIERhdHVtIGFyZykKIAkJTXlXb3JrZXJJbmZvLT53aV9wcm9jID0gTlVMTDsK IAkJTXlXb3JrZXJJbmZvLT53aV9sYXVuY2h0aW1lID0gMDsKIAkJTXlXb3JrZXJJbmZvLT53aV9k b2JhbGFuY2UgPSBmYWxzZTsKLQkJTXlXb3JrZXJJbmZvLT53aV9jb3N0X2RlbGF5ID0gMDsKLQkJ TXlXb3JrZXJJbmZvLT53aV9jb3N0X2xpbWl0ID0gMDsKLQkJTXlXb3JrZXJJbmZvLT53aV9jb3N0 X2xpbWl0X2Jhc2UgPSAwOwogCQlkbGlzdF9wdXNoX2hlYWQoJkF1dG9WYWN1dW1TaG1lbS0+YXZf ZnJlZVdvcmtlcnMsCiAJCQkJCQkmTXlXb3JrZXJJbmZvLT53aV9saW5rcyk7CiAJCS8qIG5vdCBt aW5lIGFueW1vcmUgKi8KQEAgLTE3NzMsMTAwICsxNzc0LDE0MiBAQCBGcmVlV29ya2VySW5mbyhp bnQgY29kZSwgRGF0dW0gYXJnKQogCX0KIH0KIAorCiAvKgotICogVXBkYXRlIHRoZSBjb3N0LWJh c2VkIGRlbGF5IHBhcmFtZXRlcnMsIHNvIHRoYXQgbXVsdGlwbGUgd29ya2VycyBjb25zdW1lCi0g KiBlYWNoIGEgZnJhY3Rpb24gb2YgdGhlIHRvdGFsIGF2YWlsYWJsZSBJL08uCisgKiBVcGRhdGUg VmFjdXVtQ29zdERlbGF5IHdpdGggdGhlIGNvcnJlY3QgdmFsdWUgZm9yIGFuIGF1dG92YWN1dW0g d29ya2VyLAorICogZ2l2ZW4gdGhlIHZhbHVlIG9mIG90aGVyIHJlbGV2YW50IGNvc3QtYmFzZWQg ZGVsYXkgcGFyYW1ldGVycy4gQXV0b3ZhY3V1bQorICogd29ya2VycyBzaG91bGQgY2FsbCB0aGlz IGFmdGVyIGV2ZXJ5IGNvbmZpZyByZWxvYWQsIGluIGNhc2UgVmFjdXVtQ29zdERlbGF5CisgKiB3 YXMgb3ZlcndyaXR0ZW4uCiAgKi8KIHZvaWQKIEF1dG9WYWN1dW1VcGRhdGVEZWxheSh2b2lkKQog ewotCWlmIChNeVdvcmtlckluZm8pCisJaWYgKCFhbV9hdXRvdmFjdXVtX3dvcmtlcikKKwkJcmV0 dXJuOworCisJaWYgKGF2X3JlbG9wdF9jb3N0X2RlbGF5ID49IDApCisJCVZhY3V1bUNvc3REZWxh eSA9IGF2X3JlbG9wdF9jb3N0X2RlbGF5OworCWVsc2UgaWYgKGF1dG92YWN1dW1fdmFjX2Nvc3Rf ZGVsYXkgPj0gMCkKKwkJVmFjdXVtQ29zdERlbGF5ID0gYXV0b3ZhY3V1bV92YWNfY29zdF9kZWxh eTsKKworCS8qCisJICogSWYgY29uZmlndXJhdGlvbiBjaGFuZ2VzIGFyZSBhbGxvd2VkIHRvIGlt cGFjdCBWYWN1dW1Db3N0SW5hY3RpdmUsIG1ha2UKKwkgKiBzdXJlIGl0IGlzIHVwZGF0ZWQuCisJ ICovCisJaWYgKFZhY3V1bUNvc3RJbmFjdGl2ZSA9PSBWQUNVVU1fQ09TVF9JTkFDVElWRV9BTkRf TE9DS0VEKQorCQlyZXR1cm47CisKKwlpZiAoVmFjdXVtQ29zdERlbGF5ID4gMCkKKwkJVmFjdXVt Q29zdEluYWN0aXZlID0gVkFDVVVNX0NPU1RfQUNUSVZFOworCWVsc2UKIAl7Ci0JCVZhY3V1bUNv c3REZWxheSA9IE15V29ya2VySW5mby0+d2lfY29zdF9kZWxheTsKLQkJVmFjdXVtQ29zdExpbWl0 ID0gTXlXb3JrZXJJbmZvLT53aV9jb3N0X2xpbWl0OworCQlWYWN1dW1Db3N0SW5hY3RpdmUgPSBW QUNVVU1fQ09TVF9JTkFDVElWRV9BTkRfVU5MT0NLRUQ7CisJCVZhY3V1bUNvc3RCYWxhbmNlID0g MDsKIAl9CiB9CiAKKwogLyoKLSAqIGF1dG92YWNfYmFsYW5jZV9jb3N0Ci0gKgkJUmVjYWxjdWxh dGUgdGhlIGNvc3QgbGltaXQgc2V0dGluZyBmb3IgZWFjaCBhY3RpdmUgd29ya2VyLgotICoKLSAq IENhbGxlciBtdXN0IGhvbGQgdGhlIEF1dG92YWN1dW1Mb2NrIGluIGV4Y2x1c2l2ZSBtb2RlLgor ICogVGhpcyBtdXN0IGJlIGNhbGxlZCBkaXJlY3RseSBhZnRlciBhIGNvbmZpZyByZWxvYWQgYmVm b3JlIHVzaW5nIHRoZSB2YWx1ZSBvZgorICogVmFjdXVtQ29zdExpbWl0IGFuZCBiZWZvcmUgY2Fs bGluZyBBdXRvVmFjdXVtQmFsYW5jZUxpbWl0KCksIGFzIGl0IHVzZXMgdGhlCisgKiB2YWx1ZSBv ZiBWYWN1dW1Db3N0TGltaXQgdG8gZGV0ZXJtaW5lIHdoYXQgdGhlIGJhc2UgYXZfYmFzZV9jb3N0 X2xpbWl0CisgKiBzaG91bGQgYmUuIEF1dG9WYWN1dW1CYWxhbmNlTGltaXQoKSB3aWxsIG92ZXJy aWRlIHRoZSB2YWx1ZSBvZgorICogVmFjdXVtQ29zdExpbWl0LCBzbyBjYWxsaW5nIGl0IG11bHRp cGxlIHRpbWVzIGFmdGVyIGEgY29uZmlnIHJlbG9hZCBpcworICogaW5jb3JyZWN0LgogICovCi1z dGF0aWMgdm9pZAotYXV0b3ZhY19iYWxhbmNlX2Nvc3Qodm9pZCkKK3ZvaWQKK0F1dG9WYWN1dW1V cGRhdGVMaW1pdCh2b2lkKQogeworCWlmICghYW1fYXV0b3ZhY3V1bV93b3JrZXIpCisJCXJldHVy bjsKKwogCS8qCi0JICogVGhlIGlkZWEgaGVyZSBpcyB0aGF0IHdlIHJhdGlvbiBvdXQgSS9PIGVx dWFsbHkuICBUaGUgYW1vdW50IG9mIEkvTwotCSAqIHRoYXQgYSB3b3JrZXIgY2FuIGNvbnN1bWUg aXMgZGV0ZXJtaW5lZCBieSBjb3N0X2xpbWl0L2Nvc3RfZGVsYXksIHNvIHdlCi0JICogdHJ5IHRv IGVxdWFsaXplIHRob3NlIHJhdGlvcyByYXRoZXIgdGhhbiB0aGUgcmF3IGxpbWl0IHNldHRpbmdz LgotCSAqCiAJICogbm90ZTogaW4gY29zdF9saW1pdCwgemVybyBhbHNvIG1lYW5zIHVzZSB2YWx1 ZSBmcm9tIGVsc2V3aGVyZSwgYmVjYXVzZQogCSAqIHplcm8gaXMgbm90IGEgdmFsaWQgdmFsdWUu CiAJICovCi0JaW50CQkJdmFjX2Nvc3RfbGltaXQgPSAoYXV0b3ZhY3V1bV92YWNfY29zdF9saW1p dCA+IDAgPwotCQkJCQkJCQkgIGF1dG92YWN1dW1fdmFjX2Nvc3RfbGltaXQgOiBWYWN1dW1Db3N0 TGltaXQpOwotCWRvdWJsZQkJdmFjX2Nvc3RfZGVsYXkgPSAoYXV0b3ZhY3V1bV92YWNfY29zdF9k ZWxheSA+PSAwID8KLQkJCQkJCQkJICBhdXRvdmFjdXVtX3ZhY19jb3N0X2RlbGF5IDogVmFjdXVt Q29zdERlbGF5KTsKLQlkb3VibGUJCWNvc3RfdG90YWw7Ci0JZG91YmxlCQljb3N0X2F2YWlsOwot CWRsaXN0X2l0ZXIJaXRlcjsKKwlpZiAoYXZfcmVsb3B0X2Nvc3RfbGltaXQgPiAwKQorCQlWYWN1 dW1Db3N0TGltaXQgPSBhdl9yZWxvcHRfY29zdF9saW1pdDsKKwllbHNlCisJeworCQlhdl9iYXNl X2Nvc3RfbGltaXQgPSBhdXRvdmFjdXVtX3ZhY19jb3N0X2xpbWl0ID4gMCA/CisJCQlhdXRvdmFj dXVtX3ZhY19jb3N0X2xpbWl0IDogVmFjdXVtQ29zdExpbWl0OworCisJCUF1dG9WYWN1dW1CYWxh bmNlTGltaXQoKTsKKwl9Cit9CisKKy8qCisgKiBVcGRhdGUgVmFjdXVtQ29zdExpbWl0IHdpdGgg dGhlIGNvcnJlY3QgdmFsdWUgZm9yIGFuIGF1dG92YWN1dW0gd29ya2VyLAorICogZ2l2ZW4gdGhl IHZhbHVlIG9mIG90aGVyIHJlbGV2YW50IGNvc3QgbGltaXQgcGFyYW1ldGVycyBhbmQgdGhlIG51 bWJlciBvZgorICogd29ya2VycyBhY3Jvc3Mgd2hpY2ggdGhlIGxpbWl0IG11c3QgYmUgYmFsYW5j ZWQuIEF1dG92YWN1dW0gd29ya2VycyBtdXN0CisgKiBjYWxsIHRoaXMgcmVndWxhcmx5IGluIGNh c2UgYXZfbndvcmtlcnNfZm9yX2JhbGFuY2UgaGFzIGJlZW4gdXBkYXRlZCBieQorICogYW5vdGhl ciB3b3JrZXIgb3IgYnkgdGhlIGF1dG92YWN1dW0gbGF1bmNoZXIuIEFmdGVyIGEgY29uZmlnIHJl bG9hZCwgdGhleQorICogbXVzdCBjYWxsIEF1dG9WYWN1dW1VcGRhdGVMaW1pdCgpIHdoaWNoIHdp bGwgY2FsbCBBdXRvVmFjdXVtQmFsYW5jZUxpbWl0KCksCisgKiBpbiBjYXNlIFZhY3V1bUNvc3RM aW1pdCB3YXMgb3ZlcndyaXR0ZW4uCisgKi8KK3ZvaWQKK0F1dG9WYWN1dW1CYWxhbmNlTGltaXQo dm9pZCkKK3sKKwlpbnQJCQlud29ya2Vyc19mb3JfYmFsYW5jZTsKKwlpbnQJCQl0b3RhbF9jb3N0 X2xpbWl0OworCWludAkJCWJhbGFuY2VkX2Nvc3RfbGltaXQ7CiAKLQkvKiBub3Qgc2V0PyBub3Ro aW5nIHRvIGRvICovCi0JaWYgKHZhY19jb3N0X2xpbWl0IDw9IDAgfHwgdmFjX2Nvc3RfZGVsYXkg PD0gMCkKKwlpZiAoIWFtX2F1dG92YWN1dW1fd29ya2VyKQogCQlyZXR1cm47CiAKLQkvKiBjYWxj dWxhdGUgdGhlIHRvdGFsIGJhc2UgY29zdCBsaW1pdCBvZiBwYXJ0aWNpcGF0aW5nIGFjdGl2ZSB3 b3JrZXJzICovCi0JY29zdF90b3RhbCA9IDAuMDsKLQlkbGlzdF9mb3JlYWNoKGl0ZXIsICZBdXRv VmFjdXVtU2htZW0tPmF2X3J1bm5pbmdXb3JrZXJzKQotCXsKLQkJV29ya2VySW5mbwl3b3JrZXIg PSBkbGlzdF9jb250YWluZXIoV29ya2VySW5mb0RhdGEsIHdpX2xpbmtzLCBpdGVyLmN1cik7CisJ QXNzZXJ0KGF2X2Jhc2VfY29zdF9saW1pdCA+IDApOwogCi0JCWlmICh3b3JrZXItPndpX3Byb2Mg IT0gTlVMTCAmJgotCQkJd29ya2VyLT53aV9kb2JhbGFuY2UgJiYKLQkJCXdvcmtlci0+d2lfY29z dF9saW1pdF9iYXNlID4gMCAmJiB3b3JrZXItPndpX2Nvc3RfZGVsYXkgPiAwKQotCQkJY29zdF90 b3RhbCArPQotCQkJCShkb3VibGUpIHdvcmtlci0+d2lfY29zdF9saW1pdF9iYXNlIC8gd29ya2Vy LT53aV9jb3N0X2RlbGF5OwotCX0KKwlud29ya2Vyc19mb3JfYmFsYW5jZSA9IHBnX2F0b21pY19y ZWFkX3UzMigKKwkJCQkJCQkmQXV0b1ZhY3V1bVNobWVtLT5hdl9ud29ya2Vyc0ZvckJhbGFuY2Up OworCisJLyogVGhlcmUgaXMgYXQgbGVhc3QgMSBhdXRvdmFjIHdvcmtlciAodGhpcyB3b3JrZXIp LiAqLworCUFzc2VydChud29ya2Vyc19mb3JfYmFsYW5jZSA+IDApOworCisJdG90YWxfY29zdF9s aW1pdCA9IGF1dG92YWN1dW1fdmFjX2Nvc3RfbGltaXQgPiAwID8KKwkJYXV0b3ZhY3V1bV92YWNf Y29zdF9saW1pdCA6IGF2X2Jhc2VfY29zdF9saW1pdDsKIAotCS8qIHRoZXJlIGFyZSBubyBjb3N0 IGxpbWl0cyAtLSBub3RoaW5nIHRvIGRvICovCi0JaWYgKGNvc3RfdG90YWwgPD0gMCkKKwliYWxh bmNlZF9jb3N0X2xpbWl0ID0gdG90YWxfY29zdF9saW1pdCAvIG53b3JrZXJzX2Zvcl9iYWxhbmNl OworCisJVmFjdXVtQ29zdExpbWl0ID0gTWF4KE1pbihiYWxhbmNlZF9jb3N0X2xpbWl0LCB0b3Rh bF9jb3N0X2xpbWl0KSwgMSk7Cit9CisKKy8qCisgKiBhdXRvdmFjX3JlY2FsY3VsYXRlX3dvcmtl cnNfZm9yX2JhbGFuY2UKKyAqCQlSZWNhbGN1bGF0ZSB0aGUgbnVtYmVyIG9mIHdvcmtlcnMgdG8g Y29uc2lkZXIsIGdpdmVuIHRhYmxlIG9wdGlvbnMgYW5kCisgKgkJdGhlIGN1cnJlbnQgbnVtYmVy IG9mIGFjdGl2ZSB3b3JrZXJzLgorICoKKyAqIENhbGxlciBtdXN0IGhvbGQgdGhlIEF1dG92YWN1 dW1Mb2NrIGluIGF0IGxlYXN0IHNoYXJlZCBtb2RlLgorICovCitzdGF0aWMgdm9pZAorYXV0b3Zh Y19yZWNhbGN1bGF0ZV93b3JrZXJzX2Zvcl9iYWxhbmNlKHZvaWQpCit7CisJZGxpc3RfaXRlcglp dGVyOworCWludAkJCW9yaWdfbndvcmtlcnNfZm9yX2JhbGFuY2U7CisJaW50CQkJbndvcmtlcnNf Zm9yX2JhbGFuY2UgPSAwOworCisJaWYgKGF1dG92YWN1dW1fdmFjX2Nvc3RfZGVsYXkgPT0gMCB8 fAorCQkoYXV0b3ZhY3V1bV92YWNfY29zdF9kZWxheSA9PSAtMSAmJiBWYWN1dW1Db3N0RGVsYXkg PT0gMCkpCiAJCXJldHVybjsKIAotCS8qCi0JICogQWRqdXN0IGNvc3QgbGltaXQgb2YgZWFjaCBh Y3RpdmUgd29ya2VyIHRvIGJhbGFuY2UgdGhlIHRvdGFsIG9mIGNvc3QKLQkgKiBsaW1pdCB0byBh dXRvdmFjdXVtX3ZhY3V1bV9jb3N0X2xpbWl0LgotCSAqLwotCWNvc3RfYXZhaWwgPSAoZG91Ymxl KSB2YWNfY29zdF9saW1pdCAvIHZhY19jb3N0X2RlbGF5OworCWlmIChhdXRvdmFjdXVtX3ZhY19j b3N0X2xpbWl0IDw9IDAgJiYgVmFjdXVtQ29zdExpbWl0IDw9IDApCisJCXJldHVybjsKKworCW9y aWdfbndvcmtlcnNfZm9yX2JhbGFuY2UgPQorCQlwZ19hdG9taWNfcmVhZF91MzIoJkF1dG9WYWN1 dW1TaG1lbS0+YXZfbndvcmtlcnNGb3JCYWxhbmNlKTsKKwogCWRsaXN0X2ZvcmVhY2goaXRlciwg JkF1dG9WYWN1dW1TaG1lbS0+YXZfcnVubmluZ1dvcmtlcnMpCiAJewogCQlXb3JrZXJJbmZvCXdv cmtlciA9IGRsaXN0X2NvbnRhaW5lcihXb3JrZXJJbmZvRGF0YSwgd2lfbGlua3MsIGl0ZXIuY3Vy KTsKIAotCQlpZiAod29ya2VyLT53aV9wcm9jICE9IE5VTEwgJiYKLQkJCXdvcmtlci0+d2lfZG9i YWxhbmNlICYmCi0JCQl3b3JrZXItPndpX2Nvc3RfbGltaXRfYmFzZSA+IDAgJiYgd29ya2VyLT53 aV9jb3N0X2RlbGF5ID4gMCkKLQkJewotCQkJaW50CQkJbGltaXQgPSAoaW50KQotCQkJKGNvc3Rf YXZhaWwgKiB3b3JrZXItPndpX2Nvc3RfbGltaXRfYmFzZSAvIGNvc3RfdG90YWwpOwotCi0JCQkv KgotCQkJICogV2UgcHV0IGEgbG93ZXIgYm91bmQgb2YgMSBvbiB0aGUgY29zdF9saW1pdCwgdG8g YXZvaWQgZGl2aXNpb24tCi0JCQkgKiBieS16ZXJvIGluIHRoZSB2YWN1dW0gY29kZS4gIEFsc28s IGluIGNhc2Ugb2Ygcm91bmRvZmYgdHJvdWJsZQotCQkJICogaW4gdGhlc2UgY2FsY3VsYXRpb25z LCBsZXQncyBiZSBzdXJlIHdlIGRvbid0IGV2ZXIgc2V0Ci0JCQkgKiBjb3N0X2xpbWl0IHRvIG1v cmUgdGhhbiB0aGUgYmFzZSB2YWx1ZS4KLQkJCSAqLwotCQkJd29ya2VyLT53aV9jb3N0X2xpbWl0 ID0gTWF4KE1pbihsaW1pdCwKLQkJCQkJCQkJCQkJd29ya2VyLT53aV9jb3N0X2xpbWl0X2Jhc2Up LAotCQkJCQkJCQkJCTEpOwotCQl9CisJCWlmICh3b3JrZXItPndpX3Byb2MgPT0gTlVMTCB8fCAh d29ya2VyLT53aV9kb2JhbGFuY2UpCisJCQljb250aW51ZTsKIAotCQlpZiAod29ya2VyLT53aV9w cm9jICE9IE5VTEwpCi0JCQllbG9nKERFQlVHMiwgImF1dG92YWNfYmFsYW5jZV9jb3N0KHBpZD0l ZCBkYj0ldSwgcmVsPSV1LCBkb2JhbGFuY2U9JXMgY29zdF9saW1pdD0lZCwgY29zdF9saW1pdF9i YXNlPSVkLCBjb3N0X2RlbGF5PSVnKSIsCi0JCQkJIHdvcmtlci0+d2lfcHJvYy0+cGlkLCB3b3Jr ZXItPndpX2Rib2lkLCB3b3JrZXItPndpX3RhYmxlb2lkLAotCQkJCSB3b3JrZXItPndpX2RvYmFs YW5jZSA/ICJ5ZXMiIDogIm5vIiwKLQkJCQkgd29ya2VyLT53aV9jb3N0X2xpbWl0LCB3b3JrZXIt PndpX2Nvc3RfbGltaXRfYmFzZSwKLQkJCQkgd29ya2VyLT53aV9jb3N0X2RlbGF5KTsKKwkJbndv cmtlcnNfZm9yX2JhbGFuY2UrKzsKIAl9CisKKwlpZiAobndvcmtlcnNfZm9yX2JhbGFuY2UgIT0g b3JpZ19ud29ya2Vyc19mb3JfYmFsYW5jZSkKKwkJcGdfYXRvbWljX3dyaXRlX3UzMigmQXV0b1Zh Y3V1bVNobWVtLT5hdl9ud29ya2Vyc0ZvckJhbGFuY2UsCisJCQkJCQkJbndvcmtlcnNfZm9yX2Jh bGFuY2UpOwogfQogCiAvKgpAQCAtMjMxMiw4ICsyMzU1LDYgQEAgZG9fYXV0b3ZhY3V1bSh2b2lk KQogCQlhdXRvdmFjX3RhYmxlICp0YWI7CiAJCWJvb2wJCWlzc2hhcmVkOwogCQlib29sCQlza2lw aXQ7Ci0JCWRvdWJsZQkJc3RkVmFjdXVtQ29zdERlbGF5OwotCQlpbnQJCQlzdGRWYWN1dW1Db3N0 TGltaXQ7CiAJCWRsaXN0X2l0ZXIJaXRlcjsKIAogCQlDSEVDS19GT1JfSU5URVJSVVBUUygpOwpA QCAtMjQxNywzMCArMjQ1OCwyNiBAQCBkb19hdXRvdmFjdXVtKHZvaWQpCiAJCX0KIAogCQkvKgot CQkgKiBSZW1lbWJlciB0aGUgcHJldmFpbGluZyB2YWx1ZXMgb2YgdGhlIHZhY3V1bSBjb3N0IEdV Q3MuICBXZSBoYXZlIHRvCi0JCSAqIHJlc3RvcmUgdGhlc2UgYXQgdGhlIGJvdHRvbSBvZiB0aGUg bG9vcCwgZWxzZSB3ZSdsbCBjb21wdXRlIHdyb25nCi0JCSAqIHZhbHVlcyBpbiB0aGUgbmV4dCBp dGVyYXRpb24gb2YgYXV0b3ZhY19iYWxhbmNlX2Nvc3QoKS4KKwkJICogU2F2ZSB0aGUgY29zdC1y ZWxhdGVkIHRhYmxlIG9wdGlvbnMgaW4gZ2xvYmFsIHZhcmlhYmxlcyBmb3IKKwkJICogcmVmZXJl bmNlIHdoZW4gdXBkYXRpbmcgVmFjdXVtQ29zdExpbWl0IGFuZCBWYWN1dW1Db3N0RGVsYXkgZHVy aW5nCisJCSAqIHZhY3V1bWluZyB0aGlzIHRhYmxlLgogCQkgKi8KLQkJc3RkVmFjdXVtQ29zdERl bGF5ID0gVmFjdXVtQ29zdERlbGF5OwotCQlzdGRWYWN1dW1Db3N0TGltaXQgPSBWYWN1dW1Db3N0 TGltaXQ7CisJCWF2X3JlbG9wdF9jb3N0X2xpbWl0ID0gdGFiLT5hdF9yZWxvcHRfdmFjX2Nvc3Rf bGltaXQ7CisJCWF2X3JlbG9wdF9jb3N0X2RlbGF5ID0gdGFiLT5hdF9yZWxvcHRfdmFjX2Nvc3Rf ZGVsYXk7CiAKIAkJLyogTXVzdCBob2xkIEF1dG92YWN1dW1Mb2NrIHdoaWxlIG11Y2tpbmcgd2l0 aCBjb3N0IGJhbGFuY2UgaW5mbyAqLwogCQlMV0xvY2tBY3F1aXJlKEF1dG92YWN1dW1Mb2NrLCBM V19FWENMVVNJVkUpOwotCi0JCS8qIGFkdmVydGlzZSBteSBjb3N0IGRlbGF5IHBhcmFtZXRlcnMg Zm9yIHRoZSBiYWxhbmNpbmcgYWxnb3JpdGhtICovCiAJCU15V29ya2VySW5mby0+d2lfZG9iYWxh bmNlID0gdGFiLT5hdF9kb2JhbGFuY2U7Ci0JCU15V29ya2VySW5mby0+d2lfY29zdF9kZWxheSA9 IHRhYi0+YXRfdmFjdXVtX2Nvc3RfZGVsYXk7Ci0JCU15V29ya2VySW5mby0+d2lfY29zdF9saW1p dCA9IHRhYi0+YXRfdmFjdXVtX2Nvc3RfbGltaXQ7Ci0JCU15V29ya2VySW5mby0+d2lfY29zdF9s aW1pdF9iYXNlID0gdGFiLT5hdF92YWN1dW1fY29zdF9saW1pdDsKLQotCQkvKiBkbyBhIGJhbGFu Y2UgKi8KLQkJYXV0b3ZhY19iYWxhbmNlX2Nvc3QoKTsKKwkJYXV0b3ZhY19yZWNhbGN1bGF0ZV93 b3JrZXJzX2Zvcl9iYWxhbmNlKCk7CisJCUxXTG9ja1JlbGVhc2UoQXV0b3ZhY3V1bUxvY2spOwog Ci0JCS8qIHNldCB0aGUgYWN0aXZlIGNvc3QgcGFyYW1ldGVycyBmcm9tIHRoZSByZXN1bHQgb2Yg dGhhdCAqLworCQkvKgorCQkgKiBXZSB3YWl0IHVudGlsIHRoaXMgcG9pbnQgdG8gdXBkYXRlIGNv c3QgZGVsYXkgYW5kIGNvc3QgbGltaXQKKwkJICogdmFsdWVzLCBldmVuIHRob3VnaCB3ZSByZWxv YWRlZCB0aGUgY29uZmlndXJhdGlvbiBmaWxlIGFib3ZlLCBzbworCQkgKiB0aGF0IHdlIGNhbiB0 YWtlIGludG8gYWNjb3VudCB0aGUgY29zdC1yZWxhdGVkIHRhYmxlIG9wdGlvbnMuCisJCSAqLwog CQlBdXRvVmFjdXVtVXBkYXRlRGVsYXkoKTsKLQotCQkvKiBkb25lICovCi0JCUxXTG9ja1JlbGVh c2UoQXV0b3ZhY3V1bUxvY2spOworCQlBdXRvVmFjdXVtVXBkYXRlTGltaXQoKTsKIAogCQkvKiBj bGVhbiB1cCBtZW1vcnkgYmVmb3JlIGVhY2ggaXRlcmF0aW9uICovCiAJCU1lbW9yeUNvbnRleHRS ZXNldEFuZERlbGV0ZUNoaWxkcmVuKFBvcnRhbENvbnRleHQpOwpAQCAtMjUyNSwxOSArMjU2Miwx NSBAQCBkZWxldGVkOgogCiAJCS8qCiAJCSAqIFJlbW92ZSBteSBpbmZvIGZyb20gc2hhcmVkIG1l bW9yeS4gIFdlIGNvdWxkLCBidXQgaW50ZW50aW9uYWxseQotCQkgKiBkb24ndCwgY2xlYXIgd2lf Y29zdF9saW1pdCBhbmQgZnJpZW5kcyAtLS0gdGhpcyBpcyBvbiB0aGUKLQkJICogYXNzdW1wdGlv biB0aGF0IHdlIHByb2JhYmx5IGhhdmUgbW9yZSB0byBkbyB3aXRoIHNpbWlsYXIgY29zdAotCQkg KiBzZXR0aW5ncywgc28gd2UgZG9uJ3Qgd2FudCB0byBnaXZlIHVwIG91ciBzaGFyZSBvZiBJL08g Zm9yIGEgdmVyeQotCQkgKiBzaG9ydCBpbnRlcnZhbCBhbmQgdGhlcmVieSB0aHJhc2ggdGhlIGds b2JhbCBiYWxhbmNlLgorCQkgKiBkb24ndCwgc2V0IHdpX2RvYmFsYW5jZSB0byBmYWxzZSBvbiB0 aGUgYXNzdW1wdGlvbiB0aGF0IHdlIGFyZSBtb3JlCisJCSAqIGxpa2VseSB0aGFuIG5vdCB0byB2 YWN1dW0gYSB0YWJsZSB3aXRoIG5vIHRhYmxlIG9wdGlvbnMgbmV4dCwgc28gd2UKKwkJICogZG9u J3Qgd2FudCB0byBnaXZlIHVwIG91ciBzaGFyZSBvZiBJL08gZm9yIGEgdmVyeSBzaG9ydCBpbnRl cnZhbAorCQkgKiBhbmQgdGhlcmVieSB0aHJhc2ggdGhlIGdsb2JhbCBiYWxhbmNlLgogCQkgKi8K IAkJTFdMb2NrQWNxdWlyZShBdXRvdmFjdXVtU2NoZWR1bGVMb2NrLCBMV19FWENMVVNJVkUpOwog CQlNeVdvcmtlckluZm8tPndpX3RhYmxlb2lkID0gSW52YWxpZE9pZDsKIAkJTXlXb3JrZXJJbmZv LT53aV9zaGFyZWRyZWwgPSBmYWxzZTsKIAkJTFdMb2NrUmVsZWFzZShBdXRvdmFjdXVtU2NoZWR1 bGVMb2NrKTsKLQotCQkvKiByZXN0b3JlIHZhY3V1bSBjb3N0IEdVQ3MgZm9yIHRoZSBuZXh0IGl0 ZXJhdGlvbiAqLwotCQlWYWN1dW1Db3N0RGVsYXkgPSBzdGRWYWN1dW1Db3N0RGVsYXk7Ci0JCVZh Y3V1bUNvc3RMaW1pdCA9IHN0ZFZhY3V1bUNvc3RMaW1pdDsKIAl9CiAKIAkvKgpAQCAtMjU2OSw2 ICsyNjAyLDggQEAgZGVsZXRlZDoKIAkJewogCQkJQ29uZmlnUmVsb2FkUGVuZGluZyA9IGZhbHNl OwogCQkJUHJvY2Vzc0NvbmZpZ0ZpbGUoUEdDX1NJR0hVUCk7CisJCQlBdXRvVmFjdXVtVXBkYXRl RGVsYXkoKTsKKwkJCUF1dG9WYWN1dW1VcGRhdGVMaW1pdCgpOwogCQl9CiAKIAkJTFdMb2NrQWNx dWlyZShBdXRvdmFjdXVtTG9jaywgTFdfRVhDTFVTSVZFKTsKQEAgLTI4MDQsOCArMjgzOSw2IEBA IHRhYmxlX3JlY2hlY2tfYXV0b3ZhYyhPaWQgcmVsaWQsIEhUQUIgKnRhYmxlX3RvYXN0X21hcCwK IAkJaW50CQkJZnJlZXplX3RhYmxlX2FnZTsKIAkJaW50CQkJbXVsdGl4YWN0X2ZyZWV6ZV9taW5f YWdlOwogCQlpbnQJCQltdWx0aXhhY3RfZnJlZXplX3RhYmxlX2FnZTsKLQkJaW50CQkJdmFjX2Nv c3RfbGltaXQ7Ci0JCWRvdWJsZQkJdmFjX2Nvc3RfZGVsYXk7CiAJCWludAkJCWxvZ19taW5fZHVy YXRpb247CiAKIAkJLyoKQEAgLTI4MTUsMjAgKzI4NDgsNiBAQCB0YWJsZV9yZWNoZWNrX2F1dG92 YWMoT2lkIHJlbGlkLCBIVEFCICp0YWJsZV90b2FzdF9tYXAsCiAJCSAqIGRlZmF1bHRzLCBhdXRv dmFjdXVtJ3Mgb3duIGZpcnN0IGFuZCBwbGFpbiB2YWN1dW0gc2Vjb25kLgogCQkgKi8KIAotCQkv KiAtMSBpbiBhdXRvdmFjIHNldHRpbmcgbWVhbnMgdXNlIHBsYWluIHZhY3V1bV9jb3N0X2RlbGF5 ICovCi0JCXZhY19jb3N0X2RlbGF5ID0gKGF2b3B0cyAmJiBhdm9wdHMtPnZhY3V1bV9jb3N0X2Rl bGF5ID49IDApCi0JCQk/IGF2b3B0cy0+dmFjdXVtX2Nvc3RfZGVsYXkKLQkJCTogKGF1dG92YWN1 dW1fdmFjX2Nvc3RfZGVsYXkgPj0gMCkKLQkJCT8gYXV0b3ZhY3V1bV92YWNfY29zdF9kZWxheQot CQkJOiBWYWN1dW1Db3N0RGVsYXk7Ci0KLQkJLyogMCBvciAtMSBpbiBhdXRvdmFjIHNldHRpbmcg bWVhbnMgdXNlIHBsYWluIHZhY3V1bV9jb3N0X2xpbWl0ICovCi0JCXZhY19jb3N0X2xpbWl0ID0g KGF2b3B0cyAmJiBhdm9wdHMtPnZhY3V1bV9jb3N0X2xpbWl0ID4gMCkKLQkJCT8gYXZvcHRzLT52 YWN1dW1fY29zdF9saW1pdAotCQkJOiAoYXV0b3ZhY3V1bV92YWNfY29zdF9saW1pdCA+IDApCi0J CQk/IGF1dG92YWN1dW1fdmFjX2Nvc3RfbGltaXQKLQkJCTogVmFjdXVtQ29zdExpbWl0OwotCiAJ CS8qIC0xIGluIGF1dG92YWMgc2V0dGluZyBtZWFucyB1c2UgbG9nX2F1dG92YWN1dW1fbWluX2R1 cmF0aW9uICovCiAJCWxvZ19taW5fZHVyYXRpb24gPSAoYXZvcHRzICYmIGF2b3B0cy0+bG9nX21p bl9kdXJhdGlvbiA+PSAwKQogCQkJPyBhdm9wdHMtPmxvZ19taW5fZHVyYXRpb24KQEAgLTI4ODQs OCArMjkwMywxMCBAQCB0YWJsZV9yZWNoZWNrX2F1dG92YWMoT2lkIHJlbGlkLCBIVEFCICp0YWJs ZV90b2FzdF9tYXAsCiAJCXRhYi0+YXRfcGFyYW1zLm11bHRpeGFjdF9mcmVlemVfdGFibGVfYWdl ID0gbXVsdGl4YWN0X2ZyZWV6ZV90YWJsZV9hZ2U7CiAJCXRhYi0+YXRfcGFyYW1zLmlzX3dyYXBh cm91bmQgPSB3cmFwYXJvdW5kOwogCQl0YWItPmF0X3BhcmFtcy5sb2dfbWluX2R1cmF0aW9uID0g bG9nX21pbl9kdXJhdGlvbjsKLQkJdGFiLT5hdF92YWN1dW1fY29zdF9saW1pdCA9IHZhY19jb3N0 X2xpbWl0OwotCQl0YWItPmF0X3ZhY3V1bV9jb3N0X2RlbGF5ID0gdmFjX2Nvc3RfZGVsYXk7CisJ CXRhYi0+YXRfcmVsb3B0X3ZhY19jb3N0X2xpbWl0ID0gYXZvcHRzID8KKwkJCWF2b3B0cy0+dmFj dXVtX2Nvc3RfbGltaXQgOiAwOworCQl0YWItPmF0X3JlbG9wdF92YWNfY29zdF9kZWxheSA9IGF2 b3B0cyA/CisJCQlhdm9wdHMtPnZhY3V1bV9jb3N0X2RlbGF5IDogLTE7CiAJCXRhYi0+YXRfcmVs bmFtZSA9IE5VTEw7CiAJCXRhYi0+YXRfbnNwbmFtZSA9IE5VTEw7CiAJCXRhYi0+YXRfZGF0bmFt ZSA9IE5VTEw7CkBAIC0zMzc3LDEwICszMzk4LDE0IEBAIEF1dG9WYWN1dW1TaG1lbUluaXQodm9p ZCkKIAkJd29ya2VyID0gKFdvcmtlckluZm8pICgoY2hhciAqKSBBdXRvVmFjdXVtU2htZW0gKwog CQkJCQkJCSAgIE1BWEFMSUdOKHNpemVvZihBdXRvVmFjdXVtU2htZW1TdHJ1Y3QpKSk7CiAKKwog CQkvKiBpbml0aWFsaXplIHRoZSBXb3JrZXJJbmZvIGZyZWUgbGlzdCAqLwogCQlmb3IgKGkgPSAw OyBpIDwgYXV0b3ZhY3V1bV9tYXhfd29ya2VyczsgaSsrKQogCQkJZGxpc3RfcHVzaF9oZWFkKCZB dXRvVmFjdXVtU2htZW0tPmF2X2ZyZWVXb3JrZXJzLAogCQkJCQkJCSZ3b3JrZXJbaV0ud2lfbGlu a3MpOworCisJCXBnX2F0b21pY19pbml0X3UzMigmQXV0b1ZhY3V1bVNobWVtLT5hdl9ud29ya2Vy c0ZvckJhbGFuY2UsIDApOworCiAJfQogCWVsc2UKIAkJQXNzZXJ0KGZvdW5kKTsKZGlmZiAtLWdp dCBhL3NyYy9pbmNsdWRlL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5oIGIvc3JjL2luY2x1ZGUvcG9z dG1hc3Rlci9hdXRvdmFjdXVtLmgKaW5kZXggYzE0MDM3MWI1MS4uODBiZGZiMmNjMCAxMDA2NDQK LS0tIGEvc3JjL2luY2x1ZGUvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmgKKysrIGIvc3JjL2luY2x1 ZGUvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmgKQEAgLTY0LDcgKzY0LDkgQEAgZXh0ZXJuIGludAlT dGFydEF1dG9WYWNXb3JrZXIodm9pZCk7CiBleHRlcm4gdm9pZCBBdXRvVmFjV29ya2VyRmFpbGVk KHZvaWQpOwogCiAvKiBhdXRvdmFjdXVtIGNvc3QtZGVsYXkgYmFsYW5jZXIgKi8KK2V4dGVybiB2 b2lkIEF1dG9WYWN1dW1CYWxhbmNlTGltaXQodm9pZCk7CiBleHRlcm4gdm9pZCBBdXRvVmFjdXVt VXBkYXRlRGVsYXkodm9pZCk7CitleHRlcm4gdm9pZCBBdXRvVmFjdXVtVXBkYXRlTGltaXQodm9p ZCk7CiAKICNpZmRlZiBFWEVDX0JBQ0tFTkQKIGV4dGVybiB2b2lkIEF1dG9WYWNMYXVuY2hlck1h aW4oaW50IGFyZ2MsIGNoYXIgKmFyZ3ZbXSkgcGdfYXR0cmlidXRlX25vcmV0dXJuKCk7Ci0tIAoy LjM3LjIKCg== --000000000000daa23105f7ff275b Content-Type: text/x-patch; charset="US-ASCII"; name="v10-0002-VACUUM-reloads-config-file-more-often.patch" Content-Disposition: attachment; filename="v10-0002-VACUUM-reloads-config-file-more-often.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lfsyezhz1 RnJvbSBkZjcyNDE0NGI2ZmJkYzgwNGZiOTEwMzNiZDg4ZGYwZjgyYmE2ZjMwIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBNb24sIDI3IE1hciAyMDIzIDEzOjMzOjE5IC0wNDAwClN1YmplY3Q6IFtQ QVRDSCB2MTAgMi8zXSBWQUNVVU0gcmVsb2FkcyBjb25maWcgZmlsZSBtb3JlIG9mdGVuCgpQcmV2 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== --000000000000daa23105f7ff275b--