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 1paltm-0006oR-Db for pgsql-hackers@arkaria.postgresql.org; Fri, 10 Mar 2023 23:11:42 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.92) (envelope-from ) id 1paltl-0006S0-1L for pgsql-hackers@arkaria.postgresql.org; Fri, 10 Mar 2023 23:11:41 +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 1paltk-0006Rr-ED for pgsql-hackers@lists.postgresql.org; Fri, 10 Mar 2023 23:11:40 +0000 Received: from mail-pf1-x433.google.com ([2607:f8b0:4864:20::433]) by makus.postgresql.org with esmtps (TLS1.3:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.92) (envelope-from ) id 1palth-0006sX-3S for pgsql-hackers@postgresql.org; Fri, 10 Mar 2023 23:11:39 +0000 Received: by mail-pf1-x433.google.com with SMTP id bd34so4626619pfb.3 for ; Fri, 10 Mar 2023 15:11:36 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; t=1678489896; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:from:to:cc:subject:date:message-id:reply-to; bh=sD9/kDrl2kQ/APIbD6R+JKwdWu/v2nxEKweV5UNdIy4=; b=YaGT7U1kDYNoYiAez89duo+YQAdTHIfe0O7qRmv+qUAejgMpEoKSrZ1yFAHpwy4WTS 7sN+4EB8U7Z2N+7ViBRR7a3GSlK0PcmWiCCz4DN3CoZbddxBPBB5YTBZWN29L8vWqG86 079JqQ0mYh08tgWpUZZ573Lh0WNIbSbmP7HOkFPey2bBb5PJ6bubXnZHtfieNse7ZJ7l n180S491x+jV1m9Zs9G2RqPB5e6wjP3ISdaVnIbG4Ff0Gybo0I04p901Sgxf7RZsPcJE SIhndeAMzFV3nKtNw30gkTZjPDvaJeT2KYPBul3ZfmmGaSP37NByL8TaYz7aXIzmkI2q qffw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; t=1678489896; 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=sD9/kDrl2kQ/APIbD6R+JKwdWu/v2nxEKweV5UNdIy4=; b=bJDKohk+a0laSwUMDcEF1xP1vm0l0wZwAVk5SIZYNR1VjCPzV4BJWFGkNwOqW4aMWr j6FSxlfIdbduT5Caj0UHQaFHVKKRBGgAfO6U1QCt8xWjpKhdIQRRpSfHA8Vum5A//6+l /MhqLZRSAupz3VkCNTX8DjsIkLFE979baeatCdCJ6i++H5WXV7TQ14Rcb2zapghoaaZo aDjIm+sElMJuaPKklwKEYqrWaabGkpJCsqPhsIqVZE6yPjKMqKZ6uWhLnTLxcE2DhzXh tMLtbiLQE8jvXAcnxyCS4iYh9i3PWT/gAavwMQCyEkq4z+vx/VirpLCeXKgrAzd/DSrc eh/Q== X-Gm-Message-State: AO0yUKU5UmKJo18zv66HM/9I639hYaDiD38bGjBNUw5K7V/M12P0seSX gPY3na3LcpMjrBjmWv8Pa6pHOX1PE+3r6Dao+uM= X-Google-Smtp-Source: AK7set+8SPS5B+MmT+LjKK85aVGKc7k+vuCICm8Wbmce/6l1K84PEKWo6AqEe2HpeAf2DYDEbf39OY8aBzI64irYUWo= X-Received: by 2002:a63:ee12:0:b0:503:77cd:8748 with SMTP id e18-20020a63ee12000000b0050377cd8748mr8911030pgi.8.1678489895619; Fri, 10 Mar 2023 15:11:35 -0800 (PST) MIME-Version: 1.0 References: In-Reply-To: From: Melanie Plageman Date: Fri, 10 Mar 2023 18:11:23 -0500 Message-ID: Subject: Re: Should vacuum process config file reload more often To: Masahiko Sawada Cc: Pg Hackers , Andres Freund , Amit Kapila Content-Type: multipart/mixed; boundary="000000000000fd26a305f693e1f1" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --000000000000fd26a305f693e1f1 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Quotes below are combined from two of Sawada-san's emails. I've also attached a patch with my suggested current version. On Thu, Mar 9, 2023 at 10:27=E2=80=AFPM Masahiko Sawada wrote: > > On Fri, Mar 10, 2023 at 11:23=E2=80=AFAM Melanie Plageman > wrote: > > > > On Tue, Mar 7, 2023 at 12:10=E2=80=AFAM Masahiko Sawada wrote: > > > > > > On Mon, Mar 6, 2023 at 5:26=E2=80=AFAM Melanie Plageman > > > wrote: > > > > > > > > On Thu, Mar 2, 2023 at 6:37=E2=80=AFPM Melanie Plageman > > > > In this version I've removed wi_cost_delay from WorkerInfoData. The= re is > > > > no synchronization of cost_delay amongst workers, so there is no re= ason > > > > to keep it in shared memory. > > > > > > > > One consequence of not updating VacuumCostDelay from wi_cost_delay = is > > > > that we have to have a way to keep track of whether or not autovacu= um > > > > table options are in use. > > > > > > > > This patch does this in a cringeworthy way. I added two global > > > > variables, one to track whether or not cost delay table options are= in > > > > use and the other to store the value of the table option cost delay= . I > > > > didn't want to use a single variable with a special value to indica= te > > > > that table option cost delay is in use because > > > > autovacuum_vacuum_cost_delay already has special values that mean > > > > certain things. My code needs a better solution. > > > > > > While it's true that wi_cost_delay doesn't need to be shared, it seem= s > > > to make the logic somewhat complex. We need to handle cost_delay in a > > > different way from other vacuum-related parameters and we need to mak= e > > > sure av[_use]_table_option_cost_delay are set properly. Removing > > > wi_cost_delay from WorkerInfoData saves 8 bytes shared memory per > > > autovacuum worker but it might be worth considering to keep > > > wi_cost_delay for simplicity. > > > > Ah, it turns out we can't really remove wi_cost_delay from WorkerInfo > > anyway because the launcher doesn't know anything about table options > > and so the workers have to keep an updated wi_cost_delay that the > > launcher or other autovac workers who are not vacuuming that table can > > read from when calculating the new limit in autovac_balance_cost(). > > IIUC if any of the cost delay parameters has been set individually, > the autovacuum worker is excluded from the balance algorithm. Ah, yes! That's right. So it is not a problem. Then I still think removing wi_cost_delay from the worker info makes sense. wi_cost_delay is a double and can't easily be accessed atomically the way wi_cost_limit can be. Keeping the cost delay local to the backends also makes it clear that cost delay is not something that should be written to by other backends or that can differ from worker to worker. Without table options in the picture, the cost delay should be the same for any worker who has reloaded the config file. As for the cost limit safe access issue, maybe we can avoid a LWLock acquisition for reading wi_cost_limit by using an atomic similar to what you suggested here for "did_rebalance". > > I've added in a shared lock for reading from wi_cost_limit in this > > patch. However, AutoVacuumUpdateLimit() is called unconditionally in > > vacuum_delay_point(), which is called quite often (per block-ish), so I > > was trying to think if there is a way we could avoid having to check > > this shared memory variable on every call to vacuum_delay_point(). > > Rebalances shouldn't happen very often (done by the launcher when a new > > worker is launched and by workers between vacuuming tables). Maybe we > > can read from it less frequently? > > Yeah, acquiring the lwlock for every call to vacuum_delay_point() > seems to be harmful. One idea would be to have one sig_atomic_t > variable in WorkerInfoData and autovac_balance_cost() set it to true > after rebalancing the worker's cost-limit. The worker can check it > without locking and update its delay parameters if the flag is true. Instead of having the atomic indicate whether or not someone (launcher or another worker) did a rebalance, it would simply store the current cost limit. Then the worker can normally access it with a simple read. My rationale is that if we used an atomic to indicate whether or not we did a rebalance ("did_rebalance"), we would have the same cache coherency guarantees as if we just used the atomic for the cost limit. If we read from the "did_rebalance" variable and missed someone having written to it on another core, we still wouldn't get around to checking the wi_cost_limit variable in shared memory, so it doesn't matter that we bothered to keep it in shared memory and use a lock to access it. I noticed we don't allow wi_cost_limit to ever be less than 0, so we could store wi_cost_limit in an atomic uint32. I'm not sure if it is okay to do pg_atomic_read_u32() and pg_atomic_unlocked_write_u32() or if we need pg_atomic_write_u32() in most cases. I've implemented the atomic cost limit in the attached patch. Though, I'm pretty unsure about how I initialized the atomics in AutoVacuumShmemInit()... If the consensus is that it is simply too confusing to take wi_cost_delay out of WorkerInfo, we might be able to afford using a shared lock to access it because we won't call AutoVacuumUpdateDelay() on every invocation of vacuum_delay_point() -- only when we've reloaded the config file. One potential option to avoid taking a shared lock on every call to AutoVacuumUpdateDelay() is to set a global variable to indicate that we did update it (since we are the only ones updating it) and then only take the shared LWLock in AutoVacuumUpdateDelay() if that flag is true. > --- > void > AutoVacuumUpdateDelay(void) > { > - if (MyWorkerInfo) > + /* > + * We are using autovacuum-related GUCs to update > VacuumCostDelay, so we > + * only want autovacuum workers and autovacuum launcher to do th= is. > + */ > + if (!(am_autovacuum_worker || am_autovacuum_launcher)) > + return; > > Is there any case where the autovacuum launcher calls > AutoVacuumUpdateDelay() function? I had meant to add it to HandleAutoVacLauncherInterrupts() after reloading the config file (done in attached patch). When using the global variables for cost delay (instead of wi_cost_delay in worker info), the autovac launcher also has to do the check in the else branch of AutoVacuumUpdateDelay() VacuumCostDelay =3D autovacuum_vac_cost_delay >=3D 0 ? autovacuum_vac_cost_delay : VacuumCostDelay; to make sure VacuumCostDelay is correct for when it calls autovac_balance_cost(). This also made me think about whether or not we still need cost_limit_base. It is used to ensure that autovac_balance_cost() never ends up setting workers' wi_cost_limits above the current autovacuum_vacuum_cost_limit (or VacuumCostLimit). However, the launcher and all the workers should know what the value is without cost_limit_base, no? > --- > In at autovac_balance_cost(), we have, > > int vac_cost_limit =3D (autovacuum_vac_cost_limit > 0 ? > autovacuum_vac_cost_limit : VacuumCostL= imit); > double vac_cost_delay =3D (autovacuum_vac_cost_delay >=3D 0 ? > autovacuum_vac_cost_delay : VacuumCostD= elay); > : > /* not set? nothing to do */ > if (vac_cost_limit <=3D 0 || vac_cost_delay <=3D 0) > return; > > IIUC if autovacuum_vac_cost_delay is changed to 0 during autovacuums > running, their vacuum delay parameters are not changed. It's not a bug > of the patch but I think we can fix it in this patch. Yes, currently (in master) wi_cost_delay does not get updated anywhere. In my patch, the global variable we are using for delay is updated but it is not done in autovac_balance_cost(). > > Also not sure how the patch interacts with failsafe autovac and paralle= l > > vacuum. > > Good point. > > When entering the failsafe mode, we disable the vacuum delays (see > lazy_check_wraparound_failsafe()). We need to keep disabling the > vacuum delays even after reloading the config file. One idea is to > have another global variable indicating we're in the failsafe mode. > vacuum_delay_point() doesn't update VacuumCostActive if the flag is > true. I think we might not need to do this. Other than in lazy_check_wraparound_failsafe(), VacuumCostActive is only updated in two places: 1) in vacuum() which autovacuum will call per table. And failsafe is reset per table as well. 2) in vacuum_delay_point(), but, since VacuumCostActive will already be false when we enter vacuum_delay_point() the next time after lazy_check_wraparound_failsafe(), we won't set VacuumCostActive there. Thanks again for the detailed feedback! - Melanie --000000000000fd26a305f693e1f1 Content-Type: text/x-patch; charset="US-ASCII"; name="v3-0001-Reload-config-file-more-often-while-vacuuming.patch" Content-Disposition: attachment; filename="v3-0001-Reload-config-file-more-often-while-vacuuming.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_lf34pfvv0 RnJvbSA5N2I2ZWJjM2VhYTNkOGVjNTNjMjU4MjJjNmNhZDJkMmJiZTIyODM3IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBTdW4sIDUgTWFyIDIwMjMgMTQ6Mzk6MTYgLTA1MDAKU3ViamVjdDogW1BB VENIIHYzXSBSZWxvYWQgY29uZmlnIGZpbGUgbW9yZSBvZnRlbiB3aGlsZSB2YWN1dW1pbmcKCi0t LQogc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMgICAgICAgfCAgMzggKysrKysrKy0tLQog c3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMgfCAxMTMgKysrKysrKysrKysrKysr KysrKystLS0tLS0tLQogc3JjL2luY2x1ZGUvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmggfCAgIDIg KwogMyBmaWxlcyBjaGFuZ2VkLCAxMTQgaW5zZXJ0aW9ucygrKSwgMzkgZGVsZXRpb25zKC0pCgpk aWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMgYi9zcmMvYmFja2VuZC9j b21tYW5kcy92YWN1dW0uYwppbmRleCAyZTEyYmFmOGViLi45ZDVjZTg0NmE1IDEwMDY0NAotLS0g YS9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW0uYworKysgYi9zcmMvYmFja2VuZC9jb21tYW5k cy92YWN1dW0uYwpAQCAtNDgsNiArNDgsNyBAQAogI2luY2x1ZGUgInBnc3RhdC5oIgogI2luY2x1 ZGUgInBvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5oIgogI2luY2x1ZGUgInBvc3RtYXN0ZXIvYmd3b3Jr ZXJfaW50ZXJuYWxzLmgiCisjaW5jbHVkZSAicG9zdG1hc3Rlci9pbnRlcnJ1cHQuaCIKICNpbmNs dWRlICJzdG9yYWdlL2J1Zm1nci5oIgogI2luY2x1ZGUgInN0b3JhZ2UvbG1nci5oIgogI2luY2x1 ZGUgInN0b3JhZ2UvcHJvYy5oIgpAQCAtNzUsNiArNzYsNyBAQCBpbnQJCQl2YWN1dW1fbXVsdGl4 YWN0X2ZhaWxzYWZlX2FnZTsKIC8qIEEgZmV3IHZhcmlhYmxlcyB0aGF0IGRvbid0IHNlZW0gd29y dGggcGFzc2luZyBhcm91bmQgYXMgcGFyYW1ldGVycyAqLwogc3RhdGljIE1lbW9yeUNvbnRleHQg dmFjX2NvbnRleHQgPSBOVUxMOwogc3RhdGljIEJ1ZmZlckFjY2Vzc1N0cmF0ZWd5IHZhY19zdHJh dGVneTsKK3N0YXRpYyBib29sIGFuYWx5emVfaW5fb3V0ZXJfeGFjdCA9IGZhbHNlOwogCiAKIC8q CkBAIC0zMTMsOCArMzE1LDcgQEAgdmFjdXVtKExpc3QgKnJlbGF0aW9ucywgVmFjdXVtUGFyYW1z ICpwYXJhbXMsCiAJc3RhdGljIGJvb2wgaW5fdmFjdXVtID0gZmFsc2U7CiAKIAljb25zdCBjaGFy ICpzdG10dHlwZTsKLQl2b2xhdGlsZSBib29sIGluX291dGVyX3hhY3QsCi0JCQkJdXNlX293bl94 YWN0czsKKwl2b2xhdGlsZSBib29sIHVzZV9vd25feGFjdHM7CiAKIAlBc3NlcnQocGFyYW1zICE9 IE5VTEwpOwogCkBAIC0zMzEsMTAgKzMzMiwxMCBAQCB2YWN1dW0oTGlzdCAqcmVsYXRpb25zLCBW YWN1dW1QYXJhbXMgKnBhcmFtcywKIAlpZiAocGFyYW1zLT5vcHRpb25zICYgVkFDT1BUX1ZBQ1VV TSkKIAl7CiAJCVByZXZlbnRJblRyYW5zYWN0aW9uQmxvY2soaXNUb3BMZXZlbCwgc3RtdHR5cGUp OwotCQlpbl9vdXRlcl94YWN0ID0gZmFsc2U7CisJCWFuYWx5emVfaW5fb3V0ZXJfeGFjdCA9IGZh bHNlOwogCX0KIAllbHNlCi0JCWluX291dGVyX3hhY3QgPSBJc0luVHJhbnNhY3Rpb25CbG9jayhp c1RvcExldmVsKTsKKwkJYW5hbHl6ZV9pbl9vdXRlcl94YWN0ID0gSXNJblRyYW5zYWN0aW9uQmxv Y2soaXNUb3BMZXZlbCk7CiAKIAkvKgogCSAqIER1ZSB0byBzdGF0aWMgdmFyaWFibGVzIHZhY19j b250ZXh0LCBhbmxfY29udGV4dCBhbmQgdmFjX3N0cmF0ZWd5LApAQCAtNDU2LDcgKzQ1Nyw3IEBA IHZhY3V1bShMaXN0ICpyZWxhdGlvbnMsIFZhY3V1bVBhcmFtcyAqcGFyYW1zLAogCQlBc3NlcnQo cGFyYW1zLT5vcHRpb25zICYgVkFDT1BUX0FOQUxZWkUpOwogCQlpZiAoSXNBdXRvVmFjdXVtV29y a2VyUHJvY2VzcygpKQogCQkJdXNlX293bl94YWN0cyA9IHRydWU7Ci0JCWVsc2UgaWYgKGluX291 dGVyX3hhY3QpCisJCWVsc2UgaWYgKGFuYWx5emVfaW5fb3V0ZXJfeGFjdCkKIAkJCXVzZV9vd25f eGFjdHMgPSBmYWxzZTsKIAkJZWxzZSBpZiAobGlzdF9sZW5ndGgocmVsYXRpb25zKSA+IDEpCiAJ CQl1c2Vfb3duX3hhY3RzID0gdHJ1ZTsKQEAgLTQ3NCw3ICs0NzUsNyBAQCB2YWN1dW0oTGlzdCAq cmVsYXRpb25zLCBWYWN1dW1QYXJhbXMgKnBhcmFtcywKIAkgKi8KIAlpZiAodXNlX293bl94YWN0 cykKIAl7Ci0JCUFzc2VydCghaW5fb3V0ZXJfeGFjdCk7CisJCUFzc2VydCghYW5hbHl6ZV9pbl9v dXRlcl94YWN0KTsKIAogCQkvKiBBY3RpdmVTbmFwc2hvdCBpcyBub3Qgc2V0IGJ5IGF1dG92YWN1 dW0gKi8KIAkJaWYgKEFjdGl2ZVNuYXBzaG90U2V0KCkpCkBAIC01MjYsNyArNTI3LDcgQEAgdmFj dXVtKExpc3QgKnJlbGF0aW9ucywgVmFjdXVtUGFyYW1zICpwYXJhbXMsCiAJCQkJfQogCiAJCQkJ YW5hbHl6ZV9yZWwodnJlbC0+b2lkLCB2cmVsLT5yZWxhdGlvbiwgcGFyYW1zLAotCQkJCQkJCXZy ZWwtPnZhX2NvbHMsIGluX291dGVyX3hhY3QsIHZhY19zdHJhdGVneSk7CisJCQkJCQkJdnJlbC0+ dmFfY29scywgYW5hbHl6ZV9pbl9vdXRlcl94YWN0LCB2YWNfc3RyYXRlZ3kpOwogCiAJCQkJaWYg KHVzZV9vd25feGFjdHMpCiAJCQkJewpAQCAtNTQ5LDYgKzU1MCw3IEBAIHZhY3V1bShMaXN0ICpy ZWxhdGlvbnMsIFZhY3V1bVBhcmFtcyAqcGFyYW1zLAogCXsKIAkJaW5fdmFjdXVtID0gZmFsc2U7 CiAJCVZhY3V1bUNvc3RBY3RpdmUgPSBmYWxzZTsKKwkJYW5hbHl6ZV9pbl9vdXRlcl94YWN0ID0g ZmFsc2U7CiAJfQogCVBHX0VORF9UUlkoKTsKIApAQCAtMjIzOCwxMCArMjI0MCwyOCBAQCB2YWN1 dW1fZGVsYXlfcG9pbnQodm9pZCkKIAkJCQkJCSBXQUlUX0VWRU5UX1ZBQ1VVTV9ERUxBWSk7CiAJ CVJlc2V0TGF0Y2goTXlMYXRjaCk7CiAKKwkJLyoKKwkJICogUmVsb2FkIHRoZSBjb25maWd1cmF0 aW9uIGZpbGUgaWYgcmVxdWVzdGVkLiBUaGlzIGFsbG93cyBjaGFuZ2VzIHRvCisJCSAqIFthdXRv dmFjdXVtX112YWN1dW1fY29zdF9saW1pdCBhbmQgW2F1dG92YWN1dW1fXXZhY3V1bV9jb3N0X2Rl bGF5CisJCSAqIHRvIHRha2UgZWZmZWN0IHdoaWxlIGEgdGFibGUgaXMgYmVpbmcgdmFjdXVtZWQg b3IgYW5hbHl6ZWQuCisJCSAqLworCQlpZiAoQ29uZmlnUmVsb2FkUGVuZGluZyAmJiAhYW5hbHl6 ZV9pbl9vdXRlcl94YWN0KQorCQl7CisJCQlDb25maWdSZWxvYWRQZW5kaW5nID0gZmFsc2U7CisJ CQlQcm9jZXNzQ29uZmlnRmlsZShQR0NfU0lHSFVQKTsKKwkJCUF1dG9WYWN1dW1VcGRhdGVEZWxh eSgpOworCQl9CisKIAkJVmFjdXVtQ29zdEJhbGFuY2UgPSAwOwogCi0JCS8qIHVwZGF0ZSBiYWxh bmNlIHZhbHVlcyBmb3Igd29ya2VycyAqLwotCQlBdXRvVmFjdXVtVXBkYXRlRGVsYXkoKTsKKwkJ LyoKKwkJICogVXBkYXRlIGJhbGFuY2UgdmFsdWVzIGZvciB3b3JrZXJzLiBXZSBtdXN0IGFsd2F5 cyBkbyB0aGlzIGluIGNhc2UKKwkJICogdGhlIGF1dG92YWN1dW0gbGF1bmNoZXIgaGFzIGRvbmUg YSByZWJhbGFuY2UgKGFzIGl0IGRvZXMgd2hlbgorCQkgKiBsYXVuY2hpbmcgYSBuZXcgd29ya2Vy KS4KKwkJICovCisJCUF1dG9WYWN1dW1VcGRhdGVMaW1pdCgpOworCisJCVZhY3V1bUNvc3RBY3Rp dmUgPSAoVmFjdXVtQ29zdERlbGF5ID4gMCk7CiAKIAkJLyogTWlnaHQgaGF2ZSBnb3R0ZW4gYW4g aW50ZXJydXB0IHdoaWxlIHNsZWVwaW5nICovCiAJCUNIRUNLX0ZPUl9JTlRFUlJVUFRTKCk7CmRp ZmYgLS1naXQgYS9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYyBiL3NyYy9iYWNr ZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCmluZGV4IGMwZTJlMDBhN2UuLmE5YjcyMTc2Mzgg MTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCisrKyBiL3Ny Yy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCkBAIC0xMzksNiArMTM5LDkgQEAgaW50 CQkJTG9nX2F1dG92YWN1dW1fbWluX2R1cmF0aW9uID0gNjAwMDAwOwogc3RhdGljIGJvb2wgYW1f YXV0b3ZhY3V1bV9sYXVuY2hlciA9IGZhbHNlOwogc3RhdGljIGJvb2wgYW1fYXV0b3ZhY3V1bV93 b3JrZXIgPSBmYWxzZTsKIAorc3RhdGljIGJvb2wgYXZfdXNlX3RhYmxlX29wdGlvbl9jb3N0X2Rl bGF5ID0gZmFsc2U7CitzdGF0aWMgZG91YmxlIGF2X3RhYmxlX29wdGlvbl9jb3N0X2RlbGF5ID0g MDsKKwogLyogRmxhZ3Mgc2V0IGJ5IHNpZ25hbCBoYW5kbGVycyAqLwogc3RhdGljIHZvbGF0aWxl IHNpZ19hdG9taWNfdCBnb3RfU0lHVVNSMiA9IGZhbHNlOwogCkBAIC0xODksNyArMTkyLDYgQEAg dHlwZWRlZiBzdHJ1Y3QgYXV0b3ZhY190YWJsZQogewogCU9pZAkJCWF0X3JlbGlkOwogCVZhY3V1 bVBhcmFtcyBhdF9wYXJhbXM7Ci0JZG91YmxlCQlhdF92YWN1dW1fY29zdF9kZWxheTsKIAlpbnQJ CQlhdF92YWN1dW1fY29zdF9saW1pdDsKIAlib29sCQlhdF9kb2JhbGFuY2U7CiAJYm9vbAkJYXRf c2hhcmVkcmVsOwpAQCAtMjI1LDggKzIyNyw3IEBAIHR5cGVkZWYgc3RydWN0IFdvcmtlckluZm9E YXRhCiAJVGltZXN0YW1wVHogd2lfbGF1bmNodGltZTsKIAlib29sCQl3aV9kb2JhbGFuY2U7CiAJ Ym9vbAkJd2lfc2hhcmVkcmVsOwotCWRvdWJsZQkJd2lfY29zdF9kZWxheTsKLQlpbnQJCQl3aV9j b3N0X2xpbWl0OworCXBnX2F0b21pY191aW50MzIgd2lfY29zdF9saW1pdDsKIAlpbnQJCQl3aV9j b3N0X2xpbWl0X2Jhc2U7CiB9IFdvcmtlckluZm9EYXRhOwogCkBAIC03NDMsNiArNzQ0LDcgQEAg QXV0b1ZhY0xhdW5jaGVyTWFpbihpbnQgYXJnYywgY2hhciAqYXJndltdKQogCQkJCQl3b3JrZXIg PSBBdXRvVmFjdXVtU2htZW0tPmF2X3N0YXJ0aW5nV29ya2VyOwogCQkJCQl3b3JrZXItPndpX2Ri b2lkID0gSW52YWxpZE9pZDsKIAkJCQkJd29ya2VyLT53aV90YWJsZW9pZCA9IEludmFsaWRPaWQ7 CisJCQkJCXBnX2F0b21pY193cml0ZV91MzIoJk15V29ya2VySW5mby0+d2lfY29zdF9saW1pdCwg MCk7CiAJCQkJCXdvcmtlci0+d2lfc2hhcmVkcmVsID0gZmFsc2U7CiAJCQkJCXdvcmtlci0+d2lf cHJvYyA9IE5VTEw7CiAJCQkJCXdvcmtlci0+d2lfbGF1bmNodGltZSA9IDA7CkBAIC04MTUsNiAr ODE3LDcgQEAgSGFuZGxlQXV0b1ZhY0xhdW5jaGVySW50ZXJydXB0cyh2b2lkKQogCQlDb25maWdS ZWxvYWRQZW5kaW5nID0gZmFsc2U7CiAJCVByb2Nlc3NDb25maWdGaWxlKFBHQ19TSUdIVVApOwog CisJCUF1dG9WYWN1dW1VcGRhdGVEZWxheSgpOwogCQkvKiBzaHV0ZG93biByZXF1ZXN0ZWQgaW4g Y29uZmlnIGZpbGU/ICovCiAJCWlmICghQXV0b1ZhY3V1bWluZ0FjdGl2ZSgpKQogCQkJQXV0b1Zh Y0xhdW5jaGVyU2h1dGRvd24oKTsKQEAgLTE3NTYsOCArMTc1OSw3IEBAIEZyZWVXb3JrZXJJbmZv KGludCBjb2RlLCBEYXR1bSBhcmcpCiAJCU15V29ya2VySW5mby0+d2lfcHJvYyA9IE5VTEw7CiAJ CU15V29ya2VySW5mby0+d2lfbGF1bmNodGltZSA9IDA7CiAJCU15V29ya2VySW5mby0+d2lfZG9i YWxhbmNlID0gZmFsc2U7Ci0JCU15V29ya2VySW5mby0+d2lfY29zdF9kZWxheSA9IDA7Ci0JCU15 V29ya2VySW5mby0+d2lfY29zdF9saW1pdCA9IDA7CisJCXBnX2F0b21pY193cml0ZV91MzIoJk15 V29ya2VySW5mby0+d2lfY29zdF9saW1pdCwgMCk7CiAJCU15V29ya2VySW5mby0+d2lfY29zdF9s aW1pdF9iYXNlID0gMDsKIAkJZGxpc3RfcHVzaF9oZWFkKCZBdXRvVmFjdXVtU2htZW0tPmF2X2Zy ZWVXb3JrZXJzLAogCQkJCQkJJk15V29ya2VySW5mby0+d2lfbGlua3MpOwpAQCAtMTc4MCwxMyAr MTc4MiwzNyBAQCBGcmVlV29ya2VySW5mbyhpbnQgY29kZSwgRGF0dW0gYXJnKQogdm9pZAogQXV0 b1ZhY3V1bVVwZGF0ZURlbGF5KHZvaWQpCiB7Ci0JaWYgKE15V29ya2VySW5mbykKKwkvKgorCSAq IFdlIGFyZSB1c2luZyBhdXRvdmFjdXVtLXJlbGF0ZWQgR1VDcyB0byB1cGRhdGUgVmFjdXVtQ29z dERlbGF5LCBzbyB3ZQorCSAqIG9ubHkgd2FudCBhdXRvdmFjdXVtIHdvcmtlcnMgYW5kIGF1dG92 YWN1dW0gbGF1bmNoZXIgdG8gZG8gdGhpcy4KKwkgKi8KKwlpZiAoIShhbV9hdXRvdmFjdXVtX3dv cmtlciB8fCBhbV9hdXRvdmFjdXVtX2xhdW5jaGVyKSkKKwkJcmV0dXJuOworCisJaWYgKGF2X3Vz ZV90YWJsZV9vcHRpb25fY29zdF9kZWxheSkKIAl7Ci0JCVZhY3V1bUNvc3REZWxheSA9IE15V29y a2VySW5mby0+d2lfY29zdF9kZWxheTsKLQkJVmFjdXVtQ29zdExpbWl0ID0gTXlXb3JrZXJJbmZv LT53aV9jb3N0X2xpbWl0OworCQlWYWN1dW1Db3N0RGVsYXkgPSBhdl90YWJsZV9vcHRpb25fY29z dF9kZWxheTsKKwl9CisJZWxzZQorCXsKKwkJVmFjdXVtQ29zdERlbGF5ID0gYXV0b3ZhY3V1bV92 YWNfY29zdF9kZWxheSA+PSAwID8KKwkJCWF1dG92YWN1dW1fdmFjX2Nvc3RfZGVsYXkgOiBWYWN1 dW1Db3N0RGVsYXk7CiAJfQogfQogCisvKgorICogSGVscGVyIGZvciB2YWN1dW1fZGVsYXlfcG9p bnQoKSB0byBhbGxvdyB3b3JrZXJzIHRvIHJlYWQgdGhlaXIKKyAqIHdpX2Nvc3RfbGltaXQuCisg Ki8KK3ZvaWQKK0F1dG9WYWN1dW1VcGRhdGVMaW1pdCh2b2lkKQoreworCWlmICghTXlXb3JrZXJJ bmZvKQorCQlyZXR1cm47CisKKwlWYWN1dW1Db3N0TGltaXQgPSBwZ19hdG9taWNfcmVhZF91MzIo Jk15V29ya2VySW5mby0+d2lfY29zdF9saW1pdCk7Cit9CisKIC8qCiAgKiBhdXRvdmFjX2JhbGFu Y2VfY29zdAogICoJCVJlY2FsY3VsYXRlIHRoZSBjb3N0IGxpbWl0IHNldHRpbmcgZm9yIGVhY2gg YWN0aXZlIHdvcmtlci4KQEAgLTE4MjQsOSArMTg1MCw5IEBAIGF1dG92YWNfYmFsYW5jZV9jb3N0 KHZvaWQpCiAKIAkJaWYgKHdvcmtlci0+d2lfcHJvYyAhPSBOVUxMICYmCiAJCQl3b3JrZXItPndp X2RvYmFsYW5jZSAmJgotCQkJd29ya2VyLT53aV9jb3N0X2xpbWl0X2Jhc2UgPiAwICYmIHdvcmtl ci0+d2lfY29zdF9kZWxheSA+IDApCisJCQl3b3JrZXItPndpX2Nvc3RfbGltaXRfYmFzZSA+IDAg JiYgdmFjX2Nvc3RfZGVsYXkgPiAwKQogCQkJY29zdF90b3RhbCArPQotCQkJCShkb3VibGUpIHdv cmtlci0+d2lfY29zdF9saW1pdF9iYXNlIC8gd29ya2VyLT53aV9jb3N0X2RlbGF5OworCQkJCShk b3VibGUpIHdvcmtlci0+d2lfY29zdF9saW1pdF9iYXNlIC8gdmFjX2Nvc3RfZGVsYXk7CiAJfQog CiAJLyogdGhlcmUgYXJlIG5vIGNvc3QgbGltaXRzIC0tIG5vdGhpbmcgdG8gZG8gKi8KQEAgLTE4 NDQsNyArMTg3MCw3IEBAIGF1dG92YWNfYmFsYW5jZV9jb3N0KHZvaWQpCiAKIAkJaWYgKHdvcmtl ci0+d2lfcHJvYyAhPSBOVUxMICYmCiAJCQl3b3JrZXItPndpX2RvYmFsYW5jZSAmJgotCQkJd29y a2VyLT53aV9jb3N0X2xpbWl0X2Jhc2UgPiAwICYmIHdvcmtlci0+d2lfY29zdF9kZWxheSA+IDAp CisJCQl3b3JrZXItPndpX2Nvc3RfbGltaXRfYmFzZSA+IDAgJiYgdmFjX2Nvc3RfZGVsYXkgPiAw KQogCQl7CiAJCQlpbnQJCQlsaW1pdCA9IChpbnQpCiAJCQkoY29zdF9hdmFpbCAqIHdvcmtlci0+ d2lfY29zdF9saW1pdF9iYXNlIC8gY29zdF90b3RhbCk7CkBAIC0xODU1LDE3ICsxODgxLDE1IEBA IGF1dG92YWNfYmFsYW5jZV9jb3N0KHZvaWQpCiAJCQkgKiBpbiB0aGVzZSBjYWxjdWxhdGlvbnMs IGxldCdzIGJlIHN1cmUgd2UgZG9uJ3QgZXZlciBzZXQKIAkJCSAqIGNvc3RfbGltaXQgdG8gbW9y ZSB0aGFuIHRoZSBiYXNlIHZhbHVlLgogCQkJICovCi0JCQl3b3JrZXItPndpX2Nvc3RfbGltaXQg PSBNYXgoTWluKGxpbWl0LAotCQkJCQkJCQkJCQl3b3JrZXItPndpX2Nvc3RfbGltaXRfYmFzZSks Ci0JCQkJCQkJCQkJMSk7CisJCQlwZ19hdG9taWNfdW5sb2NrZWRfd3JpdGVfdTMyKCZ3b3JrZXIt PndpX2Nvc3RfbGltaXQsCisJCQkJCQkJCQkJIE1heChNaW4obGltaXQsIHdvcmtlci0+d2lfY29z dF9saW1pdF9iYXNlKSwgMSkpOwogCQl9CiAKIAkJaWYgKHdvcmtlci0+d2lfcHJvYyAhPSBOVUxM KQotCQkJZWxvZyhERUJVRzIsICJhdXRvdmFjX2JhbGFuY2VfY29zdChwaWQ9JWQgZGI9JXUsIHJl bD0ldSwgZG9iYWxhbmNlPSVzIGNvc3RfbGltaXQ9JWQsIGNvc3RfbGltaXRfYmFzZT0lZCwgY29z dF9kZWxheT0lZykiLAorCQkJZWxvZyhERUJVRzIsICJhdXRvdmFjX2JhbGFuY2VfY29zdChwaWQ9 JWQgZGI9JXUsIHJlbD0ldSwgZG9iYWxhbmNlPSVzIGNvc3RfbGltaXQ9JWQsIGNvc3RfbGltaXRf YmFzZT0lZCkiLAogCQkJCSB3b3JrZXItPndpX3Byb2MtPnBpZCwgd29ya2VyLT53aV9kYm9pZCwg d29ya2VyLT53aV90YWJsZW9pZCwKIAkJCQkgd29ya2VyLT53aV9kb2JhbGFuY2UgPyAieWVzIiA6 ICJubyIsCi0JCQkJIHdvcmtlci0+d2lfY29zdF9saW1pdCwgd29ya2VyLT53aV9jb3N0X2xpbWl0 X2Jhc2UsCi0JCQkJIHdvcmtlci0+d2lfY29zdF9kZWxheSk7CisJCQkJIHBnX2F0b21pY19yZWFk X3UzMigmd29ya2VyLT53aV9jb3N0X2xpbWl0KSwgd29ya2VyLT53aV9jb3N0X2xpbWl0X2Jhc2Up OwogCX0KIH0KIApAQCAtMjMyNiw2ICsyMzUwLDEzIEBAIGRvX2F1dG92YWN1dW0odm9pZCkKIAkJ CUNvbmZpZ1JlbG9hZFBlbmRpbmcgPSBmYWxzZTsKIAkJCVByb2Nlc3NDb25maWdGaWxlKFBHQ19T SUdIVVApOwogCisJCQkvKgorCQkJICogQXV0b3ZhY3V1bSB3b3JrZXJzIHNob3VsZCBhbHdheXMg dXBkYXRlIFZhY3V1bUNvc3REZWxheSBhbmQKKwkJCSAqIFZhY3V1bUNvc3RMaW1pdCBpbiBjYXNl IHRoZXkgd2VyZSBvdmVycmlkZGVuIGJ5IHRoZSByZWxvYWQuCisJCQkgKi8KKwkJCUF1dG9WYWN1 dW1VcGRhdGVEZWxheSgpOworCQkJQXV0b1ZhY3V1bVVwZGF0ZUxpbWl0KCk7CisKIAkJCS8qCiAJ CQkgKiBZb3UgbWlnaHQgYmUgdGVtcHRlZCB0byBiYWlsIG91dCBpZiB3ZSBzZWUgYXV0b3ZhY3V1 bSBpcyBub3cKIAkJCSAqIGRpc2FibGVkLiAgTXVzdCByZXNpc3QgdGhhdCB0ZW1wdGF0aW9uIC0t IHRoaXMgbWlnaHQgYmUgYQpAQCAtMjQyNCwyMSArMjQ1NSwyMiBAQCBkb19hdXRvdmFjdXVtKHZv aWQpCiAJCXN0ZFZhY3V1bUNvc3REZWxheSA9IFZhY3V1bUNvc3REZWxheTsKIAkJc3RkVmFjdXVt Q29zdExpbWl0ID0gVmFjdXVtQ29zdExpbWl0OwogCisJCUF1dG9WYWN1dW1VcGRhdGVEZWxheSgp OworCiAJCS8qIE11c3QgaG9sZCBBdXRvdmFjdXVtTG9jayB3aGlsZSBtdWNraW5nIHdpdGggY29z dCBiYWxhbmNlIGluZm8gKi8KIAkJTFdMb2NrQWNxdWlyZShBdXRvdmFjdXVtTG9jaywgTFdfRVhD TFVTSVZFKTsKIAogCQkvKiBhZHZlcnRpc2UgbXkgY29zdCBkZWxheSBwYXJhbWV0ZXJzIGZvciB0 aGUgYmFsYW5jaW5nIGFsZ29yaXRobSAqLwogCQlNeVdvcmtlckluZm8tPndpX2RvYmFsYW5jZSA9 IHRhYi0+YXRfZG9iYWxhbmNlOwotCQlNeVdvcmtlckluZm8tPndpX2Nvc3RfZGVsYXkgPSB0YWIt PmF0X3ZhY3V1bV9jb3N0X2RlbGF5OwotCQlNeVdvcmtlckluZm8tPndpX2Nvc3RfbGltaXQgPSB0 YWItPmF0X3ZhY3V1bV9jb3N0X2xpbWl0OworCQkvKiB0aGlzIGNhbm5vdCBleGNlZWQgMTAwMDAg YW55d2F5ICovCisJCXBnX2F0b21pY191bmxvY2tlZF93cml0ZV91MzIoJk15V29ya2VySW5mby0+ d2lfY29zdF9saW1pdCwKKwkJCQkJCQkJCSB0YWItPmF0X3ZhY3V1bV9jb3N0X2xpbWl0KTsKIAkJ TXlXb3JrZXJJbmZvLT53aV9jb3N0X2xpbWl0X2Jhc2UgPSB0YWItPmF0X3ZhY3V1bV9jb3N0X2xp bWl0OworCQlBdXRvVmFjdXVtVXBkYXRlTGltaXQoKTsKIAogCQkvKiBkbyBhIGJhbGFuY2UgKi8K IAkJYXV0b3ZhY19iYWxhbmNlX2Nvc3QoKTsKIAotCQkvKiBzZXQgdGhlIGFjdGl2ZSBjb3N0IHBh cmFtZXRlcnMgZnJvbSB0aGUgcmVzdWx0IG9mIHRoYXQgKi8KLQkJQXV0b1ZhY3V1bVVwZGF0ZURl bGF5KCk7Ci0KIAkJLyogZG9uZSAqLwogCQlMV0xvY2tSZWxlYXNlKEF1dG92YWN1dW1Mb2NrKTsK IApAQCAtMjU2OSw2ICsyNjAxLDggQEAgZGVsZXRlZDoKIAkJewogCQkJQ29uZmlnUmVsb2FkUGVu ZGluZyA9IGZhbHNlOwogCQkJUHJvY2Vzc0NvbmZpZ0ZpbGUoUEdDX1NJR0hVUCk7CisJCQlBdXRv VmFjdXVtVXBkYXRlRGVsYXkoKTsKKwkJCUF1dG9WYWN1dW1VcGRhdGVMaW1pdCgpOwogCQl9CiAK IAkJTFdMb2NrQWNxdWlyZShBdXRvdmFjdXVtTG9jaywgTFdfRVhDTFVTSVZFKTsKQEAgLTI3NzEs NyArMjgwNSwxMSBAQCB0YWJsZV9yZWNoZWNrX2F1dG92YWMoT2lkIHJlbGlkLCBIVEFCICp0YWJs ZV90b2FzdF9tYXAsCiAJLyogZmV0Y2ggdGhlIHJlbGF0aW9uJ3MgcmVsY2FjaGUgZW50cnkgKi8K IAljbGFzc1R1cCA9IFNlYXJjaFN5c0NhY2hlQ29weTEoUkVMT0lELCBPYmplY3RJZEdldERhdHVt KHJlbGlkKSk7CiAJaWYgKCFIZWFwVHVwbGVJc1ZhbGlkKGNsYXNzVHVwKSkKKwl7CisJCWF2X3Vz ZV90YWJsZV9vcHRpb25fY29zdF9kZWxheSA9IGZhbHNlOworCQlhdl90YWJsZV9vcHRpb25fY29z dF9kZWxheSA9IDA7CiAJCXJldHVybiBOVUxMOworCX0KIAljbGFzc0Zvcm0gPSAoRm9ybV9wZ19j bGFzcykgR0VUU1RSVUNUKGNsYXNzVHVwKTsKIAogCS8qCkBAIC0yODAyLDcgKzI4NDAsNiBAQCB0 YWJsZV9yZWNoZWNrX2F1dG92YWMoT2lkIHJlbGlkLCBIVEFCICp0YWJsZV90b2FzdF9tYXAsCiAJ CWludAkJCW11bHRpeGFjdF9mcmVlemVfbWluX2FnZTsKIAkJaW50CQkJbXVsdGl4YWN0X2ZyZWV6 ZV90YWJsZV9hZ2U7CiAJCWludAkJCXZhY19jb3N0X2xpbWl0OwotCQlkb3VibGUJCXZhY19jb3N0 X2RlbGF5OwogCQlpbnQJCQlsb2dfbWluX2R1cmF0aW9uOwogCiAJCS8qCkBAIC0yODEyLDEyICsy ODQ5LDE2IEBAIHRhYmxlX3JlY2hlY2tfYXV0b3ZhYyhPaWQgcmVsaWQsIEhUQUIgKnRhYmxlX3Rv YXN0X21hcCwKIAkJICogZGVmYXVsdHMsIGF1dG92YWN1dW0ncyBvd24gZmlyc3QgYW5kIHBsYWlu IHZhY3V1bSBzZWNvbmQuCiAJCSAqLwogCi0JCS8qIC0xIGluIGF1dG92YWMgc2V0dGluZyBtZWFu cyB1c2UgcGxhaW4gdmFjdXVtX2Nvc3RfZGVsYXkgKi8KLQkJdmFjX2Nvc3RfZGVsYXkgPSAoYXZv cHRzICYmIGF2b3B0cy0+dmFjdXVtX2Nvc3RfZGVsYXkgPj0gMCkKLQkJCT8gYXZvcHRzLT52YWN1 dW1fY29zdF9kZWxheQotCQkJOiAoYXV0b3ZhY3V1bV92YWNfY29zdF9kZWxheSA+PSAwKQotCQkJ PyBhdXRvdmFjdXVtX3ZhY19jb3N0X2RlbGF5Ci0JCQk6IFZhY3V1bUNvc3REZWxheTsKKwkJaWYg KGF2b3B0cyAmJiBhdm9wdHMtPnZhY3V1bV9jb3N0X2RlbGF5ID49IDApCisJCXsKKwkJCWF2X3Vz ZV90YWJsZV9vcHRpb25fY29zdF9kZWxheSA9IHRydWU7CisJCQlhdl90YWJsZV9vcHRpb25fY29z dF9kZWxheSA9IGF2b3B0cy0+dmFjdXVtX2Nvc3RfZGVsYXk7CisJCX0KKwkJZWxzZQorCQl7CisJ CQlhdl91c2VfdGFibGVfb3B0aW9uX2Nvc3RfZGVsYXkgPSBmYWxzZTsKKwkJCWF2X3RhYmxlX29w dGlvbl9jb3N0X2RlbGF5ID0gMDsKKwkJfQogCiAJCS8qIDAgb3IgLTEgaW4gYXV0b3ZhYyBzZXR0 aW5nIG1lYW5zIHVzZSBwbGFpbiB2YWN1dW1fY29zdF9saW1pdCAqLwogCQl2YWNfY29zdF9saW1p dCA9IChhdm9wdHMgJiYgYXZvcHRzLT52YWN1dW1fY29zdF9saW1pdCA+IDApCkBAIC0yODgyLDcg KzI5MjMsNiBAQCB0YWJsZV9yZWNoZWNrX2F1dG92YWMoT2lkIHJlbGlkLCBIVEFCICp0YWJsZV90 b2FzdF9tYXAsCiAJCXRhYi0+YXRfcGFyYW1zLmlzX3dyYXBhcm91bmQgPSB3cmFwYXJvdW5kOwog CQl0YWItPmF0X3BhcmFtcy5sb2dfbWluX2R1cmF0aW9uID0gbG9nX21pbl9kdXJhdGlvbjsKIAkJ dGFiLT5hdF92YWN1dW1fY29zdF9saW1pdCA9IHZhY19jb3N0X2xpbWl0OwotCQl0YWItPmF0X3Zh Y3V1bV9jb3N0X2RlbGF5ID0gdmFjX2Nvc3RfZGVsYXk7CiAJCXRhYi0+YXRfcmVsbmFtZSA9IE5V TEw7CiAJCXRhYi0+YXRfbnNwbmFtZSA9IE5VTEw7CiAJCXRhYi0+YXRfZGF0bmFtZSA9IE5VTEw7 CkBAIC0yODk1LDYgKzI5MzUsMTEgQEAgdGFibGVfcmVjaGVja19hdXRvdmFjKE9pZCByZWxpZCwg SFRBQiAqdGFibGVfdG9hc3RfbWFwLAogCQkJIShhdm9wdHMgJiYgKGF2b3B0cy0+dmFjdXVtX2Nv c3RfbGltaXQgPiAwIHx8CiAJCQkJCQkgYXZvcHRzLT52YWN1dW1fY29zdF9kZWxheSA+IDApKTsK IAl9CisJZWxzZQorCXsKKwkJYXZfdXNlX3RhYmxlX29wdGlvbl9jb3N0X2RlbGF5ID0gZmFsc2U7 CisJCWF2X3RhYmxlX29wdGlvbl9jb3N0X2RlbGF5ID0gMDsKKwl9CiAKIAloZWFwX2ZyZWV0dXBs ZShjbGFzc1R1cCk7CiAJcmV0dXJuIHRhYjsKQEAgLTMzNjEsNiArMzQwNiw3IEBAIEF1dG9WYWN1 dW1TaG1lbUluaXQodm9pZCkKIAl7CiAJCVdvcmtlckluZm8Jd29ya2VyOwogCQlpbnQJCQlpOwor CQlkbGlzdF9pdGVyCWl0ZXI7CiAKIAkJQXNzZXJ0KCFmb3VuZCk7CiAKQEAgLTMzNzQsMTAgKzM0 MjAsMTcgQEAgQXV0b1ZhY3V1bVNobWVtSW5pdCh2b2lkKQogCQl3b3JrZXIgPSAoV29ya2VySW5m bykgKChjaGFyICopIEF1dG9WYWN1dW1TaG1lbSArCiAJCQkJCQkJICAgTUFYQUxJR04oc2l6ZW9m KEF1dG9WYWN1dW1TaG1lbVN0cnVjdCkpKTsKIAorCiAJCS8qIGluaXRpYWxpemUgdGhlIFdvcmtl ckluZm8gZnJlZSBsaXN0ICovCiAJCWZvciAoaSA9IDA7IGkgPCBhdXRvdmFjdXVtX21heF93b3Jr ZXJzOyBpKyspCiAJCQlkbGlzdF9wdXNoX2hlYWQoJkF1dG9WYWN1dW1TaG1lbS0+YXZfZnJlZVdv cmtlcnMsCiAJCQkJCQkJJndvcmtlcltpXS53aV9saW5rcyk7CisKKwkJZGxpc3RfZm9yZWFjaChp dGVyLCAmQXV0b1ZhY3V1bVNobWVtLT5hdl9mcmVlV29ya2VycykKKwkJCXBnX2F0b21pY19pbml0 X3UzMigKKwkJCQkJCQkgICAmKGRsaXN0X2NvbnRhaW5lcihXb3JrZXJJbmZvRGF0YSwgd2lfbGlu a3MsIGl0ZXIuY3VyKSktPndpX2Nvc3RfbGltaXQsCisJCQkJCQkJICAgMCk7CisKIAl9CiAJZWxz ZQogCQlBc3NlcnQoZm91bmQpOwpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvcG9zdG1hc3Rlci9h dXRvdmFjdXVtLmggYi9zcmMvaW5jbHVkZS9wb3N0bWFzdGVyL2F1dG92YWN1dW0uaAppbmRleCBj MTQwMzcxYjUxLi41NTgzNTg5MTFjIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9wb3N0bWFzdGVy L2F1dG92YWN1dW0uaAorKysgYi9zcmMvaW5jbHVkZS9wb3N0bWFzdGVyL2F1dG92YWN1dW0uaApA QCAtNjYsNiArNjYsOCBAQCBleHRlcm4gdm9pZCBBdXRvVmFjV29ya2VyRmFpbGVkKHZvaWQpOwog LyogYXV0b3ZhY3V1bSBjb3N0LWRlbGF5IGJhbGFuY2VyICovCiBleHRlcm4gdm9pZCBBdXRvVmFj dXVtVXBkYXRlRGVsYXkodm9pZCk7CiAKK2V4dGVybiB2b2lkIEF1dG9WYWN1dW1VcGRhdGVMaW1p dCh2b2lkKTsKKwogI2lmZGVmIEVYRUNfQkFDS0VORAogZXh0ZXJuIHZvaWQgQXV0b1ZhY0xhdW5j aGVyTWFpbihpbnQgYXJnYywgY2hhciAqYXJndltdKSBwZ19hdHRyaWJ1dGVfbm9yZXR1cm4oKTsK IGV4dGVybiB2b2lkIEF1dG9WYWNXb3JrZXJNYWluKGludCBhcmdjLCBjaGFyICphcmd2W10pIHBn X2F0dHJpYnV0ZV9ub3JldHVybigpOwotLSAKMi4zNy4yCgo= --000000000000fd26a305f693e1f1--