Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1vxBiZ-002C4b-0X for pgsql-hackers@arkaria.postgresql.org; Mon, 02 Mar 2026 22:26:23 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1vxBiX-003G9e-1L for pgsql-hackers@arkaria.postgresql.org; Mon, 02 Mar 2026 22:26:21 +0000 Received: from magus.postgresql.org ([2a02:c0:301:0:ffff::29]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1vxBiX-003G9U-04 for pgsql-hackers@lists.postgresql.org; Mon, 02 Mar 2026 22:26:21 +0000 Received: from mail-lj1-x230.google.com ([2a00:1450:4864:20::230]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.98.2) (envelope-from ) id 1vxBiU-000000005Ff-0fbb for pgsql-hackers@lists.postgresql.org; Mon, 02 Mar 2026 22:26:21 +0000 Received: by mail-lj1-x230.google.com with SMTP id 38308e7fff4ca-3870778358aso51710251fa.1 for ; Mon, 02 Mar 2026 14:26:17 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1772490377; cv=none; d=google.com; s=arc-20240605; b=ewmAE7+Utfd4OxS4dFDfcvtwyvIVXJxYrh/+231Z3ogCIxBQHS3FkUn5zxIhEZY7OL CMYpqO3HBNZihnSkeVI/GFvWdYZPM389woJ1dwlf7XP7KFRLecopW2NCk6UVSkHpZyPE VpVih8D8q8T3H9/MiYr3KDNkf2FMzFadXGzQzGMsqGmJ12EFk44MgDr1QuCRno/oxNtA fxp5X2AFt0hGtyhpWgNtrJtkrdmyCb5aXMgfMMeGZzr+kMBQpqTQGRr6GcisxCfjafNZ lUcLNs4u4VoQTlt/LJMazFkraFflX7lcbS8DlCjGQw9atMOBBWzaDv69Og2XArioqL+c O1pg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20240605; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:dkim-signature; bh=91VhGFlqv3QhijYMahQ2cXLAc+8Dg18hlq7fTPikLPc=; fh=OsqwkWgZfYHQBLhIYl3m+zubuvDrQvjhmzh07nyWAmI=; b=KCIr1LeFzNwvPYUn1gzBUzzB7pzEqfkNHZ4tDC/H9gY2bLc4iDpKlCbcrbgV3Xhl8s XBnQexpWcKXrM2QhNJEbukYSrU5hx1emRrIWqBHvLKsVM7e+JDPyq4hCTZY7UqJfqE00 cienC48x6s+vcRwPL4hW0gbS3JJPDXBZmUULDusOM8XCMTVwA6SL8TQp5W3w0AsgKhm8 24HvwmcIrd/GMTqdLyvsIvd9k9VJRluq38onviZJw8Fm/KTEEnCKXQxmaiCV8RE/Sjwz 4HonT2QVICRa7nJ/n0Tj8hBTLgz5SmLQTTRUhPi/kRDWuVYA+8UnJuql0UIMcTGRKjy5 r76g==; darn=lists.postgresql.org ARC-Authentication-Results: i=1; mx.google.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1772490377; x=1773095177; darn=lists.postgresql.org; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:from:to:cc:subject:date:message-id:reply-to; bh=91VhGFlqv3QhijYMahQ2cXLAc+8Dg18hlq7fTPikLPc=; b=Mu+WKeVOm+1dCyZ/fJ7II08On2QYiEtCXEZUvXwQ9go4cBjtP4aAhWSiwh4urqyxI6 kXV6DmQQtvZun9MFyArGsrX0m9+/EIY9rhhqrmEKgvrtpIvkYRf3gpbpdWp/Rxr7Daxc +GuzXHCdlmTwkDFXKf2DTFsQb7CbRjLB5X6KE2p2Y7nQGfsCjHhGxKp7+MEocnQwUbt4 5Wj9/OUDgyIyszw8TQUCFp2DwHoy75BIXh6yhjx59nL1+F6yflj537AyWBWWoaR1C03h kFcrjFrOWnL2QM5X1w9/BjRpClk3Vg+7wREla4y8BTzTGnJaXSvxavaGm7Y+H/j/4aqj LJbg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1772490377; x=1773095177; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:x-gm-gg:x-gm-message-state:from:to:cc:subject:date :message-id:reply-to; bh=91VhGFlqv3QhijYMahQ2cXLAc+8Dg18hlq7fTPikLPc=; b=IndMszd2fgxLPXBy1xtLotGth2M7EFcsdmJ+r9JPTcNhxNX1FT2NBVW34C6MLCbvNt OPCiH2eqX7gyJhhjBuXZbolbj82o1121fpSMLLpnWOmudld9Z1rjJ/5MZ5942Rfit5B2 wSE0UuE01jgwveZHFgQc5vTRtnj4KL9rkhJ2K4Dxfq/X21nUcuX5H0XOeS7TUAuSnie/ VB9ROKM7WNMgYdZ1Y2t9EPQkS8wd7pMiyako3jtrifiaIk0/hU7VFhjhlxM9m/8h6G8J 7ilsH6xG/EBU2xJRR5LC3uJJmEZO0tovsWwF5CuzEZnTj24pgE0Wrn1Dod/d4ek8OhWs Ingw== X-Forwarded-Encrypted: i=1; AJvYcCVIkfTAgp1A9Pk+zkIa9jY45uMjAt7fSjheuXMG+Oc1VqH+ulmqK1izk2xxj1oD5IEHN0qWYL1gLvv5/JF0@lists.postgresql.org X-Gm-Message-State: AOJu0YyB7eD2ObAnyh5xjmGaj9QbZ+XFCVUzDjFX9jhlrnes52a5FMEV ezAK4BKcNRPqb4x48FFExmZdShS2frq6izL1hwgrvhDGSFsa4wYgWwCOd6WCSDdxmFePA74tij5 rES3u4VF9tD9BiOSysE841jGnd1aczzU= X-Gm-Gg: ATEYQzyZ8VyHAAy3uuy3nH9NXGi8+drqdt/h96ahRdKUkNSNCrbkm9KM9GGZqcMRVd9 2EoAyFGTZ4267bkv/Um+9x+NS0QRrQv5F/E7+GGpXcl9lD9LlY1HIhFN5nfB989wP6KWTGWPK6h i4YTSJNJg9XH4RdYAMCjWQrysqaWtvGvjYbXHmff1wQjazwKXEUtWPqV/IqWJ7YOvA67Vb8aWqm h2W0RcSsRcATTBQySAGiV+oYId2NLeNGisI3Ib1U300y8qp6zQk983Q6COC6B0j57EC3teHHL0P 9isL1P54 X-Received: by 2002:a05:651c:2101:b0:38a:b18:f41e with SMTP id 38308e7fff4ca-38a0b18f6a9mr55385581fa.6.1772490376908; Mon, 02 Mar 2026 14:26:16 -0800 (PST) MIME-Version: 1.0 References: In-Reply-To: From: Masahiko Sawada Date: Mon, 2 Mar 2026 14:25:39 -0800 X-Gm-Features: AaiRm528PfhXXtBTHjxT8h7kX5kX62ghgrwbrbnQeTZ67QiwSCpQF6PvgYg4kjo Message-ID: Subject: Re: POC: Parallel processing of indexes in autovacuum To: Daniil Davydov <3danissimo@gmail.com> Cc: Sami Imseih , Alexander Korotkov , Matheus Alcantara , Maxim Orlov , Postgres hackers Content-Type: multipart/mixed; boundary="00000000000048ac85064c1213e3" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --00000000000048ac85064c1213e3 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable On Sun, Mar 1, 2026 at 6:46=E2=80=AFAM Daniil Davydov <3danissimo@gmail.com= > wrote: > > Hi, > > On Sat, Feb 28, 2026 at 8:57=E2=80=AFAM Masahiko Sawada wrote: > > > > IIUC earlier patches defined autovacuum_max_parallel_workers with the > > limit by max_worker_processes. Suppose we set: > > > > - max_worker_processes =3D 8 > > - autovacuum_max_parallel_workers =3D 4 > > - max_parallel_workers =3D 4 > > > > If we want to disable all parallel operations, we would need to set > > max_parallel_workers to 0 as well as either > > autovacuum_max_parallel_workers to 0, no? This is because if we set > > only max_parallel_workers to 0, autovacuum workers still can take > > parallel vacuum workers from the max_worker_processes pool. I might be > > missing something though. > > > > Even if av_max_parallel_workers is limited by max_worker_processes, > it is enough to set max_parallel_workers to 0 to disable parallel > autovacuum. > > When a/v leader wants to create supportive workers, it calls > "RegisterDynamicBackgroundWorker" function, which contain following > logic : > /* > * If this is a parallel worker, check whether there are already too many > * parallel workers; if so, don't register another one. > */ > if (parallel && (BackgroundWorkerData->parallel_register_count - > BackgroundWorkerData->parallel_terminate_count) >= =3D > max_parallel_workers) > { > .... > } > > Thus, a/v leader cannot launch any workers if max_parallel_workers is set= to 0. Right. But this fact would actually support that limiting autovacuum_max_parallel_workers by max_parallel_workers is more appropriate, no? > > > > > If we write the log "%d parallel autovacuum workers have been > > > > released" in AutoVacuumReleaseParallelWorkres(), can we simplify bo= th > > > > tests (4 and 5) further? > > > > > > > > > > It won't help the 4th test, because ReleaseParallelWorkers is called > > > due to both ERROR and shmem_exit, but we want to be sure that > > > workers are released in the try/catch block (i.e. before the shmem_ex= it). > > > > We already call AutoVacuumReleaseAllParallelWorker() in the PG_CATCH() > > block in do_autovacuum(). If we write the log in > > AutoVacuumReleaseParallelWorkers(), the tap test is able to check the > > log, no? > > > > Not quite. Assume that we add "%d workers have been released" log to the > ReleaseAllParallelWorkers. Then we trigger an error for a/v leader and wa= it > for this log (we are expecting that workers will be released inside the > try/catch block). > > Even if there is a bug in the code and a/v leader cannot release parallel > workers due to occured error, one day it will finish vacuuming and call > "proc_exit". During "proc_exit" the "before_shmem_exit_hook" along with > the "ReleaseAllParallelWorkers" will be called. What bugs are you concerned about in this case? I'm not sure what you meant by "a/v leader cannot release parallel workers due to occured error". It sounds like you mentioned a case where there is a bug in AutoVacuumReleaseParallelWorkers() but if there is the bug and the leader failed to release parallel workers, we would end up not writing these elogs in either case. > > > > Also, I don't know whether the 5th test needs this log at all, becaus= e in > > > the end we are checking the number of free parallel workers. If a kil= led > > > a/v leader doesn't release parallel workers, we'll notice it. > > > > If we can check the log written at process shutdown time, I think we > > can somewhat simplify the test 5 logic by not attaching > > 'autovacuum-start-parallel-vacuum' injection point. > > > > 1. attach 'autovacuum-leader-before-indexes-processing' injection point= . > > 2. wait for an av worker to stop at the injection point. > > 3. terminate the av worker. > > 4. verify from the log if the workers have been released. > > 5. disable parallel autovacuum. > > 6. check the free workers (should be 10). > > > > Step 5 and 6 seems to be optional though. > > OK, I see your point. But I'm afraid that the "%d released" log can't hel= p > us here for the reason I described above : > "%d released" can be called from several places and we cannot be sure > which one has emitted this log. > > I suppose to do the same as we did for try/catch block - add logging insi= de > the "autovacuum_worker_before_shmem_exit" with some unique message. > Thus, we will be sure that the workers are released precisely in the > "before_shmem_exit_hook". > > The alternative is to pass some additional information to the > "ReleaseAllParallelWorkers" function (to supplement the log it emits), bu= t it > doesn't seem like a good solution to me. I'm not sure if it's important to check how AutoVacuumReleaseAllParallelWorkers() has been called (either in PG_CATCH() block or by autovacuum_worker_before_shmem_exit()). We would end up having to add a unique message to each caller of AutoVacuumReleaseAllParallelWorkers() in the future. I guess it's more important to make sure that all workers have been released in the end. In that sense, it would make more sense to check that all workers have actually been released (i.e., checking by get_parallel_autovacuum_free_workers()) after a parallel vacuum instead of checking workers being released by debug logs. That is, we can check at each test end if get_parallel_autovacuum_free_workers() returns the expected number after disabling parallel autovacuum. > > > + if (AmAutoVacuumWorkerProcess()) > > + { > > + /* Worker usage stats for parallel autovacuum. */ > > + appendStringInfo(&buf, > > + _("parallel workers: index > > vacuum: %d planned, %d reserved, %d launched in total\n"), > > + vacrel->workers_usage.vacuum.nplan= ned, > > + vacrel->workers_usage.vacuum.nrese= rved, > > + vacrel->workers_usage.vacuum.nlaun= ched); > > + } > > + else > > + { > > + /* Worker usage stats for manual VACUUM (PARALLEL).= */ > > + appendStringInfo(&buf, > > + _("parallel workers: index > > vacuum: %d planned, %d launched in total\n"), > > + vacrel->workers_usage.vacuum.nplan= ned, > > + vacrel->workers_usage.vacuum.nlaun= ched); > > + } > > + } > > > > These comments are very obvious so I don't think we need them. > > I agree. > > > Instead, I think it would be good to explain why we don't need to > > report "reserved" numbers in the manual vacuum cases. > > > > I think that we can clarify somewhere why the "reserved" statistic > is collected only for autovacuum. PVWorkersStats is an appropriate > place for it. Thus, there will be no need to write something during > constructing the log. On second thoughts on the "planned" and "reserved", can we consider what the patch implemented as "reserved" as the "planned" in autovacuum cases? That is, in autovacuum cases, the "planned" number considers the number of parallel degrees based on the number of indexes (or autovacuum_parallel_workers value) as well as the number of workers that have actually been reserved. In cases of autovacuum_max_parallel_workers shortage, users would notice by seeing logs that enough workers are not planned in the first place against the number of indexes on the table. That might be less confusing for users rather than introducing a new "reserved" concept in the vacuum logs. Also, it slightly helps simplify the codes. > > **Comments on the 0003 patch** > > > > > +#define VacCostParamsEquals(params) \ > > + (vacuum_cost_delay =3D=3D (params).cost_delay && \ > > + vacuum_cost_limit =3D=3D (params).cost_limit && \ > > + VacuumCostPageDirty =3D=3D (params).cost_page_dirty && \ > > + VacuumCostPageHit =3D=3D (params).cost_page_hit && \ > > + VacuumCostPageMiss =3D=3D (params).cost_page_miss) > > > > I'm not sure this macro helps reduce lines of code or improve > > readability as it's used only once and it's slightly unnatural to me > > that *Equals macro takes only one argument. > > > > I agree, it looks a bit odd. I'll remove it. > Moreover, this shmem state can be updated only by the a/v leader worker, > so I'll allow it to read shared variables without holding a spinlock. > It seems pretty reliable, what do you think? Right. It's safe for the leader to read these fields without locks. > > --- > > + ereport(DEBUG2, > > + (errmsg("number of free parallel autovacuum workers is set > > to %u due to config reload", > > + AutoVacuumShmem->av_freeParallelWorkers), > > + errhidecontext(true))); > > > > Why do we need to add errhidecontext(true) here? > > > > I thought we don't need to write redundant info to the logfile. But I > don't see that other DEBUG2 messages are hiding context, so > I'll remove it. > > BTW, do we want to use "elog" here too? +1 Here are some comments: * 0001 patch: * of the worker list (see above). @@ -299,6 +308,8 @@ typedef struct WorkerInfo av_startingWorker; AutoVacuumWorkItem av_workItems[NUM_WORKITEMS]; pg_atomic_uint32 av_nworkersForBalance; + uint32 av_freeParallelWorkers; + uint32 av_maxParallelWorkers; } AutoVacuumShmemStruct; We should use int32 instead of uint32. * 0003 patch: I've attached the proposed changes to the 0003 patch, which includes: - removal of VacuumCostParams as it's not necessary. - comment updates. - other cosmetic updates. * 0004 patch: +#ifdef USE_INJECTION_POINTS + /* + * If we are parallel autovacuum worker, we can consume delay parameter= s + * during index processing (via vacuum_delay_point call). This logging + * allows tests to ensure this. + */ + if (shared->is_autovacuum) + elog(DEBUG2, + "parallel autovacuum worker cost params: cost_limit=3D%d, cost_delay=3D%g, cost_page_miss=3D%d, cost_page_dirty=3D%d, cost_page_hit=3D%d", + vacuum_cost_limit, + vacuum_cost_delay, + VacuumCostPageMiss, + VacuumCostPageDirty, + VacuumCostPageHit); +#endif While it's true that we use these logs only during the regression tests that are enabled only when injection points are also enabled, these logs themselves are not related to the injection points. I'd recommend writing these logs when the worker refreshes its local delay parameters (i.e., in parallel_vacuum_update_shared_delay_params()). --- +$node->append_conf('postgresql.conf', qq{ + max_worker_processes =3D 20 + max_parallel_workers =3D 20 + max_parallel_maintenance_workers =3D 20 + autovacuum_max_parallel_workers =3D 20 + log_min_messages =3D debug2 + log_autovacuum_min_duration =3D 0 + autovacuum_naptime =3D '1s' + min_parallel_index_scan_size =3D 0 + shared_preload_libraries=3Dtest_autovacuum +}); It would be better to set log_autovacuum_min_duration =3D 0 to the specific table instead of setting globally. --- + uint32 nfree_workers; + +#ifndef USE_INJECTION_POINTS + ereport(ERROR, errmsg("injection points not supported")); +#endif + + nfree_workers =3D AutoVacuumGetFreeParallelWorkers(); + + PG_RETURN_UINT32(nfree_workers); +} As I commented above, I think we should use int32 for the number of parallel free workers. So let's change it here too. --- +PG_FUNCTION_INFO_V1(get_parallel_autovacuum_free_workers); +Datum +get_parallel_autovacuum_free_workers(PG_FUNCTION_ARGS) +{ + uint32 nfree_workers; + +#ifndef USE_INJECTION_POINTS + ereport(ERROR, errmsg("injection points not supported")); +#endif + I think we don't necessarily need to check the USE_INJECTION_POINTS in this function as we already have the check in the tap tests. The function itself is actually workable even without injection points. --- +# Copyright (c) 2024-2025, PostgreSQL Global Development Group + Please update the copyright year here too. Regards, --=20 Masahiko Sawada Amazon Web Services: https://aws.amazon.com --00000000000048ac85064c1213e3 Content-Type: text/x-patch; charset="US-ASCII"; name="change_0003_masahiko.patch" Content-Disposition: attachment; filename="change_0003_masahiko.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mm9qwidu0 Y29tbWl0IGIyNjljNWViM2NhMDM5ZjNhOWI3YjU5ODc4YjFhNTc1YTk3YmE2MDcKQXV0aG9yOiBN YXNhaGlrbyBTYXdhZGEgPHNhd2FkYS5tc2hrQGdtYWlsLmNvbT4KRGF0ZTogICBNb24gTWFyIDIg MTQ6MDU6MDIgMjAyNiAtMDgwMAoKICAgIFByb3Bvc2VkIGNoYW5nZXMgZm9yIDAwMDMgcGF0Y2gu CgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMgYi9zcmMvYmFja2Vu ZC9jb21tYW5kcy92YWN1dW0uYwppbmRleCA3MDg4MjU0NGQwNS4uNjQ0NzM5NDgzYzggMTAwNjQ0 Ci0tLSBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jCisrKyBiL3NyYy9iYWNrZW5kL2Nv bW1hbmRzL3ZhY3V1bS5jCkBAIC0yNDM2LDEwICsyNDM2LDggQEAgdmFjdXVtX2RlbGF5X3BvaW50 KGJvb2wgaXNfYW5hbHl6ZSkKIAlpZiAoSXNQYXJhbGxlbFdvcmtlcigpKQogCXsKIAkJLyoKLQkJ ICogUG9zc2libHkgdXBkYXRlIGNvc3QtYmFzZWQgZGVsYXkgcGFyYW1ldGVycy4KLQkJICoKLQkJ ICogRG8gaXQgYmVmb3JlIGNoZWNraW5nIFZhY3V1bUNvc3RBY3RpdmUsIGJlY2F1c2UgaXRzIHZh bHVlIG1pZ2h0IGJlCi0JCSAqIGNoYW5nZWQgYWZ0ZXIgY2FsbGluZyB0aGlzIGZ1bmN0aW9uLgor CQkgKiBVcGRhdGUgY29zdC1iYXNlZCBkZWxheSBwYXJhbWV0ZXJzIGZvciBhIHBhcmFsbGVsIGF1 dG92YWN1dW0gd29ya2VyCisJCSAqIGlmIGFueSBjaGFuZ2VzIGFyZSBkZXRlY3RlZC4KIAkJICov CiAJCXBhcmFsbGVsX3ZhY3V1bV91cGRhdGVfc2hhcmVkX2RlbGF5X3BhcmFtcygpOwogCX0KQEAg LTI0NjAsOCArMjQ1OCw4IEBAIHZhY3V1bV9kZWxheV9wb2ludChib29sIGlzX2FuYWx5emUpCiAJ CVZhY3V1bVVwZGF0ZUNvc3RzKCk7CiAKIAkJLyoKLQkJICogSWYgd2UgYXJlIHBhcmFsbGVsIGF1 dG92YWN1dW0gbGVhZGVyIGFuZCBzb21lIG9mIGNvc3QtYmFzZWQKLQkJICogcGFyYW1ldGVycyBo YWQgY2hhbmdlZCwgbGV0IG90aGVyIHBhcmFsbGVsIHdvcmtlcnMga25vdy4KKwkJICogUHJvcGFn YXRlIGNvc3QtYmFzZWQgcGFyYW1ldGVycyB0byBzaGFyZWQgbWVtb3J5IGlmIGFueSBvZiB0aGVt CisJCSAqIGhhdmUgY2hhbmdlZCBkdXJpbmcgdGhlIGNvbmZpZyByZWxvYWQuCiAJCSAqLwogCQlw YXJhbGxlbF92YWN1dW1fcHJvcGFnYXRlX3NoYXJlZF9kZWxheV9wYXJhbXMoKTsKIAl9CmRpZmYg LS1naXQgYS9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jIGIvc3JjL2JhY2tl bmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYwppbmRleCA4MGI1N2JmOWRhMy4uYzQxMWRlZDJl N2YgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMKKysr IGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYwpAQCAtMTgsNiArMTgsMTMg QEAKICAqIHRoZSBwYXJhbGxlbCBjb250ZXh0IGlzIHJlLWluaXRpYWxpemVkIHNvIHRoYXQgdGhl IHNhbWUgRFNNIGNhbiBiZSB1c2VkIGZvcgogICogbXVsdGlwbGUgcGFzc2VzIG9mIGluZGV4IGJ1 bGstZGVsZXRpb24gYW5kIGluZGV4IGNsZWFudXAuCiAgKgorICogRm9yIHBhcmFsbGVsIGF1dG92 YWN1dW0sIHdlIG5lZWQgdG8gcHJvcGFnYXRlIGNvc3QtYmFzZWQgZGVsYXkgcGFyYW1ldGVycwor ICogZnJvbSB0aGUgbGVhZGVyIHRvIGl0cyB3b3JrZXJzLCBhcyB0aGUgbGVhZGVyJ3MgcGFyYW1l dGVycyBjYW4gY2hhbmdlCisgKiBldmVuIHdoaWxlIHByb2Nlc3NpbmcgYSB0YWJsZSAoZS5nLiwg ZHVlIHRvIGEgY29uZmlnIHJlbG9hZCkuCisgKiBUaGUgUFZTaGFyZWRDb3N0UGFyYW1zIHN0cnVj dCBtYW5hZ2VzIHRoZXNlIHBhcmFtZXRlcnMgdXNpbmcgYQorICogZ2VuZXJhdGlvbiBjb3VudGVy LiBFYWNoIHBhcmFsbGVsIHdvcmtlciBwb2xscyB0aGlzIHNoYXJlZCBzdGF0ZSBhbmQKKyAqIHJl ZnJlc2hlcyBpdHMgbG9jYWwgZGVsYXkgcGFyYW1ldGVycyB3aGVuZXZlciBhIGNoYW5nZSBpcyBk ZXRlY3RlZC4KKyAqCiAgKiBQb3J0aW9ucyBDb3B5cmlnaHQgKGMpIDE5OTYtMjAyNiwgUG9zdGdy ZVNRTCBHbG9iYWwgRGV2ZWxvcG1lbnQgR3JvdXAKICAqIFBvcnRpb25zIENvcHlyaWdodCAoYykg MTk5NCwgUmVnZW50cyBvZiB0aGUgVW5pdmVyc2l0eSBvZiBDYWxpZm9ybmlhCiAgKgpAQCAtNTQs MjYgKzYxLDYgQEAKICNkZWZpbmUgUEFSQUxMRUxfVkFDVVVNX0tFWV9XQUxfVVNBR0UJCTQKICNk ZWZpbmUgUEFSQUxMRUxfVkFDVVVNX0tFWV9JTkRFWF9TVEFUUwkJNQogCi0vKgotICogSGVscGVy IGZvciB0aGUgUFZTaGFyZWRDb3N0UGFyYW1zIHN0cnVjdHVyZSAoc2VlIGJlbG93KSwgdG8gYXZv aWQKLSAqIHJlcGV0aXRpb24uCi0gKi8KLXR5cGVkZWYgc3RydWN0IFZhY3V1bUNvc3RQYXJhbXMK LXsKLQlkb3VibGUJCWNvc3RfZGVsYXk7Ci0JaW50CQkJY29zdF9saW1pdDsKLQlpbnQJCQljb3N0 X3BhZ2VfZGlydHk7Ci0JaW50CQkJY29zdF9wYWdlX2hpdDsKLQlpbnQJCQljb3N0X3BhZ2VfbWlz czsKLX0gVmFjdXVtQ29zdFBhcmFtczsKLQotI2RlZmluZQlGaWxsVmFjQ29zdFBhcmFtcyhjb3N0 X3BhcmFtcykgXAotCShjb3N0X3BhcmFtcyktPmNvc3RfZGVsYXkgPSB2YWN1dW1fY29zdF9kZWxh eTsgXAotCShjb3N0X3BhcmFtcyktPmNvc3RfbGltaXQgPSB2YWN1dW1fY29zdF9saW1pdDsgXAot CShjb3N0X3BhcmFtcyktPmNvc3RfcGFnZV9kaXJ0eSA9IFZhY3V1bUNvc3RQYWdlRGlydHk7IFwK LQkoY29zdF9wYXJhbXMpLT5jb3N0X3BhZ2VfaGl0ID0gVmFjdXVtQ29zdFBhZ2VIaXQ7IFwKLQko Y29zdF9wYXJhbXMpLT5jb3N0X3BhZ2VfbWlzcyA9IFZhY3V1bUNvc3RQYWdlTWlzcwotCiAvKgog ICogU3RydWN0IGZvciBjb3N0LWJhc2VkIHZhY3V1bSBkZWxheSByZWxhdGVkIHBhcmFtZXRlcnMg dG8gc2hhcmUgYW1vbmcgYW4KICAqIGF1dG92YWN1dW0gd29ya2VyIGFuZCBpdHMgcGFyYWxsZWwg dmFjdXVtIHdvcmtlcnMuCkBAIC04MSwyMyArNjgsMjIgQEAgdHlwZWRlZiBzdHJ1Y3QgVmFjdXVt Q29zdFBhcmFtcwogdHlwZWRlZiBzdHJ1Y3QgUFZTaGFyZWRDb3N0UGFyYW1zCiB7CiAJLyoKLQkg KiBFYWNoIHRpbWUgbGVhZGVyIHdvcmtlciB1cGRhdGVzIGl0cyBwYXJhbWV0ZXJzLCBpdCBtdXN0 IGluY3JlYXNlCi0JICogZ2VuZXJhdGlvbi4gRXZlcnkgcGFyYWxsZWwgd29ya2VyIGtlZXBzIHRo ZSBnZW5lcmF0aW9uCi0JICogKHNoYXJlZF9wYXJhbXNfbG9jYWxfZ2VuZXJhdGlvbikgYXQgd2hp Y2ggaXQgaGFkIGxhc3QgdGltZSByZWNlaXZlZAotCSAqIHBhcmFtZXRlcnMgZnJvbSB0aGUgbGVh ZGVyLgotCSAqCi0JICogSXQgaXMgZW5vdWdoIGZvciB3b3JrZXIgdG8gY29tcGFyZSBpdCdzIGxv Y2FsX2dlbmVyYXRpb24gd2l0aCB0aGUgZmllbGQKLQkgKiBiZWxvdyB0byBkZXRlcm1pbmUgd2hl dGhlciBpdCBuZWVkcyB0byByZWNlaXZlIG5ldyBwYXJhbWV0ZXJzJyB2YWx1ZXMuCisJICogVGhl IGdlbmVyYXRpb24gY291bnRlciBpcyBpbmNyZW1lbnRlZCBieSB0aGUgbGVhZGVyIHByb2Nlc3Mg ZWFjaCB0aW1lCisJICogaXQgdXBkYXRlcyB0aGUgc2hhcmVkIGNvc3QtYmFzZWQgcGFyYW1ldGVy cy4gUGFyYWxlbGwgdmFjdXVtIHdvcmtlcnMKKwkgKiBjb21wYXJlIHRoaXMgd2l0aCB0aGVpciBs b2NhbCBnZW5lcmF0aW9uLAorCSAqIHNoYXJlZF9wYXJhbXNfZ2VuZXJhdGlvbl9sb2NhbHRvLCBk ZXRlY3QgaWYgdGhleSBuZWVkIHRvIHJlZnJlc2ggdGhlaXIKKwkgKiBsb2NhbCBwYXJhbWV0ZXIg Y29waWVzLgogCSAqLwogCXBnX2F0b21pY191aW50MzIgZ2VuZXJhdGlvbjsKIAogCXNsb2NrX3QJ CW11dGV4OwkJCS8qIHByb3RlY3RzIGFsbCBmaWVsZHMgYmVsb3cgKi8KIAotCS8qCi0JICogQ29w aWVzIG9mIHRoZSBjb3JyZXNwb25kaW5nIGNvc3QtYmFzZWQgdmFjdXVtIGRlbGF5IHBhcmFtZXRl cnMgZnJvbQotCSAqIGF1dG92YWN1dW0gbGVhZGVyIHByb2Nlc3MuCi0JICovCi0JVmFjdXVtQ29z dFBhcmFtcyBwYXJhbXNfZGF0YTsKKwkvKiBQYXJhbWV0ZXJzIHRvIHNoYXJlIHdpdGggcGFyYWxs ZWwgd29ya2VycyAqLworCWRvdWJsZQkJY29zdF9kZWxheTsKKwlpbnQJCQljb3N0X2xpbWl0Owor CWludAkJCWNvc3RfcGFnZV9kaXJ0eTsKKwlpbnQJCQljb3N0X3BhZ2VfaGl0OworCWludAkJCWNv c3RfcGFnZV9taXNzOwogfSBQVlNoYXJlZENvc3RQYXJhbXM7CiAKIC8qCkBAIC0yODUsNyArMjcx LDcgQEAgc3RydWN0IFBhcmFsbGVsVmFjdXVtU3RhdGUKIAogc3RhdGljIFBWU2hhcmVkQ29zdFBh cmFtcyAqcHZfc2hhcmVkX2Nvc3RfcGFyYW1zID0gTlVMTDsKIAotLyogU2VlIGNvbW1lbnRzIGZv ciB0aGUgUFZTaGFyZWRDb3N0UGFyYW1zIHN0cnVjdHVyZSBmb3IgdGhlIGV4cGxhbmF0aW9uLiAq LworLyogU2VlIGNvbW1lbnRzIGluIHRoZSBQVlNoYXJlZENvc3RQYXJhbXMgZm9yIGRlYXRpbHMg Ki8KIHN0YXRpYyB1aW50MzIgc2hhcmVkX3BhcmFtc19nZW5lcmF0aW9uX2xvY2FsID0gMDsKIAog c3RhdGljIGludAlwYXJhbGxlbF92YWN1dW1fY29tcHV0ZV93b3JrZXJzKFJlbGF0aW9uICppbmRy ZWxzLCBpbnQgbmluZGV4ZXMsIGludCBucmVxdWVzdGVkLApAQCAtMjk5LDYgKzI4NSw3IEBAIHN0 YXRpYyB2b2lkIHBhcmFsbGVsX3ZhY3V1bV9wcm9jZXNzX29uZV9pbmRleChQYXJhbGxlbFZhY3V1 bVN0YXRlICpwdnMsIFJlbGF0aW9uCiBzdGF0aWMgYm9vbCBwYXJhbGxlbF92YWN1dW1faW5kZXhf aXNfcGFyYWxsZWxfc2FmZShSZWxhdGlvbiBpbmRyZWwsIGludCBudW1faW5kZXhfc2NhbnMsCiAJ CQkJCQkJCQkJCQkgICBib29sIHZhY3V1bSk7CiBzdGF0aWMgdm9pZCBwYXJhbGxlbF92YWN1dW1f ZXJyb3JfY2FsbGJhY2sodm9pZCAqYXJnKTsKK3N0YXRpYyBpbmxpbmUgdm9pZCBwYXJhbGxlbF92 YWN1dW1fc2V0X2Nvc3RfcGFyYW1ldGVycyhQVlNoYXJlZENvc3RQYXJhbXMgKnBhcmFtcyk7CiAK IC8qCiAgKiBUcnkgdG8gZW50ZXIgcGFyYWxsZWwgbW9kZSBhbmQgY3JlYXRlIGEgcGFyYWxsZWwg Y29udGV4dC4gIFRoZW4gaW5pdGlhbGl6ZQpAQCAtNDYxLDkgKzQ0OCwxMCBAQCBwYXJhbGxlbF92 YWN1dW1faW5pdChSZWxhdGlvbiByZWwsIFJlbGF0aW9uICppbmRyZWxzLCBpbnQgbmluZGV4ZXMs CiAKIAlzaGFyZWQtPmlzX2F1dG92YWN1dW0gPSBBbUF1dG9WYWN1dW1Xb3JrZXJQcm9jZXNzKCk7 CiAKKwkvKiBJbml0aWFsaXplIHNoYXJlZCBjb3N0LWJhc2VkIHBhcmFtZXRlcnMgaWYgaXQncyBm b3IgYXV0b3ZhY3V1bSAqLwogCWlmIChzaGFyZWQtPmlzX2F1dG92YWN1dW0pCiAJewotCQlGaWxs VmFjQ29zdFBhcmFtcygmc2hhcmVkLT5jb3N0X3BhcmFtcy5wYXJhbXNfZGF0YSk7CisJCXBhcmFs bGVsX3ZhY3V1bV9zZXRfY29zdF9wYXJhbWV0ZXJzKCZzaGFyZWQtPmNvc3RfcGFyYW1zKTsKIAkJ cGdfYXRvbWljX2luaXRfdTMyKCZzaGFyZWQtPmNvc3RfcGFyYW1zLmdlbmVyYXRpb24sIDApOwog CQlTcGluTG9ja0luaXQoJnNoYXJlZC0+Y29zdF9wYXJhbXMubXV0ZXgpOwogCkBAIC02MTUsMTAg KzYwMywyMSBAQCBwYXJhbGxlbF92YWN1dW1fY2xlYW51cF9hbGxfaW5kZXhlcyhQYXJhbGxlbFZh Y3V1bVN0YXRlICpwdnMsIGxvbmcgbnVtX3RhYmxlX3R1cAogfQogCiAvKgotICogSWYgd2UgYXJl IHBhcmFsbGVsICphdXRvdmFjdXVtKiB3b3JrZXIsIGNoZWNrIHdoZXRoZXIgcmVsYXRlZCB0byBj b3N0LWJhc2VkCi0gKiB2YWN1dW0gZGVsYXkgcGFyYW1ldGVycyBoYWQgY2hhbmdlZCBpbiB0aGUg bGVhZGVyIHdvcmtlci4gSWYgc28sCi0gKiBjb3JyZXNwb25kaW5nIHBhcmFtZXRlcnMgd2lsbCBi ZSB1cGRhdGVkIHRvIHRoZSB2YWx1ZXMgd2hpY2ggbGVhZGVyIHdvcmtlcgotICogaXMgb3BlcmF0 aW5nIG9uLgorICogU2V0IGNvc3QtYmFzZWQgZGVsYXkgcGFyYW1ldGVyIHZhbHVlcyB0byB0aGUg Z2l2ZW4gJ3BhcmFtcycuCisgKi8KK3N0YXRpYyBpbmxpbmUgdm9pZAorcGFyYWxsZWxfdmFjdXVt X3NldF9jb3N0X3BhcmFtZXRlcnMoUFZTaGFyZWRDb3N0UGFyYW1zICpwYXJhbXMpCit7CisJcGFy YW1zLT5jb3N0X2RlbGF5ID0gdmFjdXVtX2Nvc3RfZGVsYXk7CisJcGFyYW1zLT5jb3N0X2xpbWl0 ID0gdmFjdXVtX2Nvc3RfbGltaXQ7CisJcGFyYW1zLT5jb3N0X3BhZ2VfZGlydHkgPSBWYWN1dW1D b3N0UGFnZURpcnR5OworCXBhcmFtcy0+Y29zdF9wYWdlX2hpdCA9IFZhY3V1bUNvc3RQYWdlSGl0 OworCXBhcmFtcy0+Y29zdF9wYWdlX21pc3MgPSBWYWN1dW1Db3N0UGFnZU1pc3M7Cit9CisKKy8q CisgKiBVcGRhdGVzIHRoZSBjb3N0LWJhc2VkIHZhY3V1bSBkZWxheSBwYXJhbWV0ZXJzIGZvciBw YXJhbGxlbCB2YWN1dW0gd29ya2VycworICogbGF1bmNoZWQgYnkgYW4gYXV0b3ZhY3V1bSB3b3Jr ZXIuCiAgKgogICogRm9yIG5vbi1hdXRvdmFjdXVtIHBhcmFsbGVsIHdvcmtlciB0aGlzIGZ1bmN0 aW9uIHdpbGwgaGF2ZSBubyBlZmZlY3QuCiAgKi8KQEAgLTYyOSw3ICs2MjgsNyBAQCBwYXJhbGxl bF92YWN1dW1fdXBkYXRlX3NoYXJlZF9kZWxheV9wYXJhbXModm9pZCkKIAogCUFzc2VydChJc1Bh cmFsbGVsV29ya2VyKCkpOwogCi0JLyogQ2hlY2sgd2hldGhlciB3ZSBhcmUgcnVubmluZyBwYXJh bGxlbCBhdXRvdmFjdXVtICovCisJLyogUXVpY2sgcmV0dXJuIGlmIHRoZSB3b2tyZXIgaXMgbm90 IHJ1bm5pbmcgZm9yIHRoZSBhdXRvdmFjdXVtICovCiAJaWYgKHB2X3NoYXJlZF9jb3N0X3BhcmFt cyA9PSBOVUxMKQogCQlyZXR1cm47CiAKQEAgLTY0MSwxMyArNjQwLDExIEBAIHBhcmFsbGVsX3Zh Y3V1bV91cGRhdGVfc2hhcmVkX2RlbGF5X3BhcmFtcyh2b2lkKQogCQlyZXR1cm47CiAKIAlTcGlu TG9ja0FjcXVpcmUoJnB2X3NoYXJlZF9jb3N0X3BhcmFtcy0+bXV0ZXgpOwotCi0JVmFjdXVtQ29z dERlbGF5ID0gcHZfc2hhcmVkX2Nvc3RfcGFyYW1zLT5wYXJhbXNfZGF0YS5jb3N0X2RlbGF5Owot CVZhY3V1bUNvc3RMaW1pdCA9IHB2X3NoYXJlZF9jb3N0X3BhcmFtcy0+cGFyYW1zX2RhdGEuY29z dF9saW1pdDsKLQlWYWN1dW1Db3N0UGFnZURpcnR5ID0gcHZfc2hhcmVkX2Nvc3RfcGFyYW1zLT5w YXJhbXNfZGF0YS5jb3N0X3BhZ2VfZGlydHk7Ci0JVmFjdXVtQ29zdFBhZ2VIaXQgPSBwdl9zaGFy ZWRfY29zdF9wYXJhbXMtPnBhcmFtc19kYXRhLmNvc3RfcGFnZV9oaXQ7Ci0JVmFjdXVtQ29zdFBh Z2VNaXNzID0gcHZfc2hhcmVkX2Nvc3RfcGFyYW1zLT5wYXJhbXNfZGF0YS5jb3N0X3BhZ2VfbWlz czsKLQorCVZhY3V1bUNvc3REZWxheSA9IHB2X3NoYXJlZF9jb3N0X3BhcmFtcy0+Y29zdF9kZWxh eTsKKwlWYWN1dW1Db3N0TGltaXQgPSBwdl9zaGFyZWRfY29zdF9wYXJhbXMtPmNvc3RfbGltaXQ7 CisJVmFjdXVtQ29zdFBhZ2VEaXJ0eSA9IHB2X3NoYXJlZF9jb3N0X3BhcmFtcy0+Y29zdF9wYWdl X2RpcnR5OworCVZhY3V1bUNvc3RQYWdlSGl0ID0gcHZfc2hhcmVkX2Nvc3RfcGFyYW1zLT5jb3N0 X3BhZ2VfaGl0OworCVZhY3V1bUNvc3RQYWdlTWlzcyA9IHB2X3NoYXJlZF9jb3N0X3BhcmFtcy0+ Y29zdF9wYWdlX21pc3M7CiAJU3BpbkxvY2tSZWxlYXNlKCZwdl9zaGFyZWRfY29zdF9wYXJhbXMt Pm11dGV4KTsKIAogCVZhY3V1bVVwZGF0ZUNvc3RzKCk7CkBAIC02NTYsNDYgKzY1Myw0MSBAQCBw YXJhbGxlbF92YWN1dW1fdXBkYXRlX3NoYXJlZF9kZWxheV9wYXJhbXModm9pZCkKIH0KIAogLyoK LSAqIEZ1bmN0aW9uIHRvIGJlIGNhbGxlZCBmcm9tIHBhcmFsbGVsIGF1dG92YWN1dW0gbGVhZGVy IGluIG9yZGVyIHRvIHByb3BhZ2F0ZQotICogc29tZSBjb3N0LWJhc2VkIHZhY3V1bSBkZWxheSBw YXJhbWV0ZXJzIHRvIHRoZSBzdXBwb3J0aXZlIHdvcmtlcnMuCisgKiBTdG9yZSB0aGUgY29zdC1i YXNlZCB2YWN1dW0gZGVsYXkgcGFyYW1ldGVycyBvbiB0aGUgc2hhcmVkIG1lbW9yeSBzbyB0aGF0 CisgKiBwYXJhbGxlbCB2YWN1dW0gd29ya2VycyBjYW4gcmVmbGVjdCB0aGVtIChzZWUKKyAqIHBh cmFsbGVsX3ZhY3V1bV91cGRhdGVfc2hhcmVkX2RlbGF5X3BhcmFtcygpKS4KICAqLwogdm9pZAog cGFyYWxsZWxfdmFjdXVtX3Byb3BhZ2F0ZV9zaGFyZWRfZGVsYXlfcGFyYW1zKHZvaWQpCiB7Ci0J VmFjdXVtQ29zdFBhcmFtcyAqcGFyYW1zX2RhdGE7Ci0KIAlBc3NlcnQoQW1BdXRvVmFjdXVtV29y a2VyUHJvY2VzcygpKTsKIAotCS8qIENoZWNrIHdoZXRoZXIgd2UgYXJlIHJ1bm5pbmcgcGFyYWxs ZWwgYXV0b3ZhY3V1bSAqLworCS8qCisJICogUXVpY2sgcmV0dXJuIGlmIHRoZSBsZWFkZXIgcHJv Y2VzcyBpcyBub3Qgc2hhcmVpbmcgdGhlIGRlbGF5CisJICogcGFyYW1ldGVycy4KKwkgKi8KIAlp ZiAocHZfc2hhcmVkX2Nvc3RfcGFyYW1zID09IE5VTEwpCiAJCXJldHVybjsKIAogCS8qCi0JICog T25seSBsZWFkZXIgd29ya2VyIGNhbiBtb2RpZnkgdGhpcyBzaGFyZWQgc3RydWN0dXJlLCBzbyB3 ZSBjYW4gcmVhZCBpdAotCSAqIHdpdGhvdXQgYWNxdWlyaW5nIGEgbG9jay4KKwkgKiBDaGVjayBp ZiBhbnkgZGVsYXkgcGFyYW1ldGVycyBoYXMgY2hhbmdlZC4gV2UgY2FuIHJlYWQgdGhlbSB3aXRo b3V0CisJICogbG9ja3MgYXMgb25seSB0aGUgbGVhZGVyIGNhbiBtb2RpZnkgdGhlbS4KIAkgKi8K LQlwYXJhbXNfZGF0YSA9ICZwdl9zaGFyZWRfY29zdF9wYXJhbXMtPnBhcmFtc19kYXRhOwotCi0J aWYgKHZhY3V1bV9jb3N0X2RlbGF5ID09IHBhcmFtc19kYXRhLT5jb3N0X2RlbGF5ICYmCi0JCXZh Y3V1bV9jb3N0X2xpbWl0ID09IHBhcmFtc19kYXRhLT5jb3N0X2xpbWl0ICYmCi0JCVZhY3V1bUNv c3RQYWdlRGlydHkgPT0gcGFyYW1zX2RhdGEtPmNvc3RfcGFnZV9kaXJ0eSAmJgotCQlWYWN1dW1D b3N0UGFnZUhpdCA9PSBwYXJhbXNfZGF0YS0+Y29zdF9wYWdlX2hpdCAmJgotCQlWYWN1dW1Db3N0 UGFnZU1pc3MgPT0gcGFyYW1zX2RhdGEtPmNvc3RfcGFnZV9taXNzKQotCXsKLQkJLyoKLQkJICog V2UgZG9uJ3QgbmVlZCB0byB1cGRhdGUgc2hhcmVkIGNvc3QtYmFzZWQgdmFjdXVtIGRlbGF5IHBh cmFtcyBpZgotCQkgKiB0aGV5IGhhdmVuJ3QgY2hhbmdlZC4KLQkJICovCisJaWYgKHZhY3V1bV9j b3N0X2RlbGF5ID09IHB2X3NoYXJlZF9jb3N0X3BhcmFtcy0+Y29zdF9kZWxheSAmJgorCQl2YWN1 dW1fY29zdF9saW1pdCA9PSBwdl9zaGFyZWRfY29zdF9wYXJhbXMtPmNvc3RfbGltaXQgJiYKKwkJ VmFjdXVtQ29zdFBhZ2VEaXJ0eSA9PSBwdl9zaGFyZWRfY29zdF9wYXJhbXMtPmNvc3RfcGFnZV9k aXJ0eSAmJgorCQlWYWN1dW1Db3N0UGFnZUhpdCA9PSBwdl9zaGFyZWRfY29zdF9wYXJhbXMtPmNv c3RfcGFnZV9oaXQgJiYKKwkJVmFjdXVtQ29zdFBhZ2VNaXNzID09IHB2X3NoYXJlZF9jb3N0X3Bh cmFtcy0+Y29zdF9wYWdlX21pc3MpCiAJCXJldHVybjsKLQl9CiAKKwkvKiBVcGRhdGUgdGhlIHNo YXJlZCBkZWxheSBwYXJhbWV0ZXJzICovCiAJU3BpbkxvY2tBY3F1aXJlKCZwdl9zaGFyZWRfY29z dF9wYXJhbXMtPm11dGV4KTsKLQlGaWxsVmFjQ29zdFBhcmFtcygmcHZfc2hhcmVkX2Nvc3RfcGFy YW1zLT5wYXJhbXNfZGF0YSk7CisJcGFyYWxsZWxfdmFjdXVtX3NldF9jb3N0X3BhcmFtZXRlcnMo JnB2X3NoYXJlZF9jb3N0X3BhcmFtcyk7CiAJU3BpbkxvY2tSZWxlYXNlKCZwdl9zaGFyZWRfY29z dF9wYXJhbXMtPm11dGV4KTsKIAogCS8qCi0JICogSW5jcmVhc2UgZ2VuZXJhdGlvbiBvZiB0aGUg cGFyYW1ldGVycywgaS5lLiBsZXQgcGFyYWxsZWwgd29ya2VycyBrbm93Ci0JICogdGhhdCB0aGV5 IHNob3VsZCByZS1yZWFkIHNoYXJlZCBjb3N0IHBhcmFtcy4KKwkgKiBJbmNyZW1lbnQgdGhlIGdl bmVyYXRpb24gb2YgdGhlIHBhcmFtZXRlcnMsIGkuZS4gbGV0IHBhcmFsbGVsIHdvcmtlcnMKKwkg KiBrbm93IHRoYXQgdGhleSBzaG91bGQgcmUtcmVhZCBzaGFyZWQgY29zdCBwYXJhbXMuCiAJICov CiAJcGdfYXRvbWljX2ZldGNoX2FkZF91MzIoJnB2X3NoYXJlZF9jb3N0X3BhcmFtcy0+Z2VuZXJh dGlvbiwgMSk7CiB9CmRpZmYgLS1naXQgYS9zcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlz dCBiL3NyYy90b29scy9wZ2luZGVudC90eXBlZGVmcy5saXN0CmluZGV4IGRlOWY1NzZlMGYzLi4x MTIwNjQ2ZjJjOCAxMDA2NDQKLS0tIGEvc3JjL3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZzLmxpc3QK KysrIGIvc3JjL3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZzLmxpc3QKQEAgLTMyNTAsNyArMzI1MCw2 IEBAIFZhY0F0dHJTdGF0c1AKIFZhY0RlYWRJdGVtc0luZm8KIFZhY0VyclBoYXNlCiBWYWNPcHRW YWx1ZQotVmFjdXVtQ29zdFBhcmFtcwogVmFjdXVtUGFyYW1zCiBWYWN1dW1SZWxhdGlvbgogVmFj dXVtU3RtdAo= --00000000000048ac85064c1213e3--