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.94.2) (envelope-from ) id 1unvGu-00Csia-Ek for pgsql-hackers@arkaria.postgresql.org; Mon, 18 Aug 2025 08:31:18 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.94.2) (envelope-from ) id 1unvGt-00EjKL-QI for pgsql-hackers@arkaria.postgresql.org; Mon, 18 Aug 2025 08:31:16 +0000 Received: from makus.postgresql.org ([2001:4800:3e1:1::229]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from <3danissimo@gmail.com>) id 1unvGt-00EjKC-40 for pgsql-hackers@lists.postgresql.org; Mon, 18 Aug 2025 08:31:16 +0000 Received: from mail-yb1-xb2b.google.com ([2607:f8b0:4864:20::b2b]) by makus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.96) (envelope-from <3danissimo@gmail.com>) id 1unvGp-000Qzi-2A for pgsql-hackers@lists.postgresql.org; Mon, 18 Aug 2025 08:31:14 +0000 Received: by mail-yb1-xb2b.google.com with SMTP id 3f1490d57ef6-e934735c552so1101415276.1 for ; Mon, 18 Aug 2025 01:31:11 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1755505871; x=1756110671; 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=PHwOQwg8jSbc0iJuaAfavNT3Nd0X5C1xNPqh3tsAcRU=; b=MkHrH9zhH/WUogadRR6fjVaeqYwITd3ECszsnplocPumcgrPbU0RVUWsARbmDaIhyi T3gRp9XqGidLs4vGZ7vwZ21B3kCVUfWNYCrjIhqiTzM68zzI7orgz817WJVxAjuuR90m bZED/qwW7Wb2jt/mtsx0rExZoGlsomUV9w/E8K4g762qODGfVMDNBxUxXE/VwixP0Yoo S732UYTDodIX0I60O/YrMLNCZc+QILl9Zpsewm8vV0haif39AkP+mVw0IJ84ohsn14BC 0IPIqlRrnz1MojAPJj8Jpjm+1pc5jY8mQqJNGPnhDp7CtAMcMrPPJejhxvi9l2vRoJi5 qR1g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1755505871; x=1756110671; 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=PHwOQwg8jSbc0iJuaAfavNT3Nd0X5C1xNPqh3tsAcRU=; b=dW04SRllt6xzfWy+aoTrS1Ux0rQnEaYGg2XLtAZF1gZT7CvqzdUSDeED9QKYmYNivj STwd9PvePNQW0HcX8dJHVv5y8fFGmmtF70i2vf2+rdCa7sdfOA7Qxfac9UK4S7Rz8kWg S6s7dtPixM2zZq9sa5KtF2d8kaaBBsjX4uoGNmHvKAJoLQTca2kEEy3gnxlfosXM2OZs J412mI5/yxDsloRYGmnWEQiPNDciQuB08uZWZiheHcQrLJ3eI/qgQzlVuC+DBOXDFNqm rrkE1uALo90i0DMHaexBB4/l9Zc34uQerZwsVFlHcIawls/gX8QiRJwiLDMVbSAdQ6MJ u4DA== X-Forwarded-Encrypted: i=1; AJvYcCWwPzSyNjT28Tz+kDhduTUu1xtBlbrRPGpVFcfIk72Rp5qORBdxXOFtKkes8EC/wbqx8Db3NnrITrw/gLq2@lists.postgresql.org X-Gm-Message-State: AOJu0Yxv7I8TGzKcdzsGqonC86x5JrMVas/DGjFi73U5lSVuY0v+7lVL EVInsJNh898l0HWRooviRM7KDboY8/nUdg+5aF2n6r73txpIjKcqUP1GRupcfSDBiMVJaBsfxkD OI2PB9XIoCRF/qFFXCZ3S+uU8TOr7yQ0= X-Gm-Gg: ASbGncugeNORbUWs8QZU7YXgrrOr4zEfDFm8EdQrZj0esg0xMcEkUobdlfGPMFXyBFb v+1eHSxVgmFUiNcZCThtQY7exI75y0S0ufkXssjs11hzUeiBI3+KbfmxkOMulFpD0pcVLBecgRs hT7X57L5c4HM+eLfIRYDoJ23rC7NU+HsJtvYQyg0jN6PLUz0jMORahQAGEM9/pqOxjspWgBmlhT NG3Lg== X-Google-Smtp-Source: AGHT+IFedg9NHALwVC7nM75eP/MMtIzvEtY4kHweqbXfRPSYus5M+y+PTnjPPDJuUbYPDIuZc9DZZTAqxEwBdpqKGxk= X-Received: by 2002:a05:6902:2b0b:b0:e93:1f88:a55a with SMTP id 3f1490d57ef6-e931f88a8c7mr19737411276.6.1755505870909; Mon, 18 Aug 2025 01:31:10 -0700 (PDT) MIME-Version: 1.0 References: In-Reply-To: From: Daniil Davydov <3danissimo@gmail.com> Date: Mon, 18 Aug 2025 15:30:49 +0700 X-Gm-Features: Ac12FXys4xoQu0mOhLq8yTNmr1CIB1AGMIim3FQFASfU9RqRzli0wpjedN4nZFA Message-ID: Subject: Re: POC: Parallel processing of indexes in autovacuum To: Masahiko Sawada Cc: Sami Imseih , Matheus Alcantara , Maxim Orlov , Postgres hackers Content-Type: multipart/mixed; boundary="000000000000d6bce0063c9f8f3a" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --000000000000d6bce0063c9f8f3a Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Hi, Thank you very much for your comments! In this letter I'll answer both of your recent letters. On Fri, Aug 8, 2025 at 6:38=E2=80=AFAM Masahiko Sawada wrote: > > Thank you for updating the patch. Here are some review comments. > > + /* Release all launched (i.e. reserved) parallel autovacuum work= ers. */ > + if (AmAutoVacuumWorkerProcess()) > + AutoVacuumReleaseParallelWorkers(nlaunched_workers); > + > > We release the reserved worker in parallel_vacuum_end(). However, > parallel_vacuum_end() is called only once at the end of vacuum. I > think we need to release the reserved worker after index vacuuming or > cleanup, otherwise we would end up holding the reserved workers until > the end of vacuum even if we invoke index vacuuming multiple times. > Yep, you are right. It was easy to miss because typically the autovacuum takes only one cycle to process a table. Since both index vacuum and index cleanup uses the parallel_vacuum_process_all_indexes function, I think that both releasing and reserving should be placed there. > --- > +void > +assign_autovacuum_max_parallel_workers(int newval, void *extra) > +{ > + autovacuum_max_parallel_workers =3D Min(newval, max_worker_proce= sses); > +} > > I don't think we need the assign hook for this GUC parameter. We can > internally cap the maximum value by max_worker_processes like other > GUC parameters such as max_parallel_maintenance_workers and > max_parallel_workers. Ok, I get it - we don't want to give a configuration error for no serious reason. Actually, we already internally capping autovacuum_max_parallel_workers by max_worker_processes (inside parallel_vacuum_compute_workers function). This is the same behavior as max_parallel_maintenance_workers got. I'll get rid of the assign hook and add one more capping inside autovacuum shmem initialization : Since max_worker_processes is PGC_POSTMASTER parameter, av_freeParallelWorkers must not exceed its value. > > ---+ /* Refresh autovacuum_max_parallel_workers paremeter */ > + CHECK_FOR_INTERRUPTS(); > + if (ConfigReloadPending) > + { > + ConfigReloadPending =3D false; > + ProcessConfigFile(PGC_SIGHUP); > + } > + > + LWLockAcquire(AutovacuumLock, LW_EXCLUSIVE); > + > + /* > + * If autovacuum_max_parallel_workers parameter was reduced duri= ng > + * parallel autovacuum execution, we must cap available > workers number by > + * its new value. > + */ > + AutoVacuumShmem->av_freeParallelWorkers =3D > + Min(AutoVacuumShmem->av_freeParallelWorkers + nworkers, > + autovacuum_max_parallel_workers); > + > + LWLockRelease(AutovacuumLock); > > I think another race condition could occur; suppose > autovacuum_max_parallel_workers is set to '5' and one autovacuum > worker reserved 5 workers, meaning that > AutoVacuumShmem->av_freeParallelWorkers is 0. Then, the user changes > autovacuum_max_parallel_workers to 3 and reloads the conf file right > after the autovacuum worker checks the interruption. The launcher > processes calls adjust_free_parallel_workers() but > av_freeParallelWorkers remains 0, and the autovacuum worker increments > it by 5 as its autovacuum_max_parallel_workers value is still 5. > I think this problem can be solved if we put AutovacuumLock acquiring before processing the config file, but I understand that this is a bad way. > I think that we can have the autovacuum_max_parallel_workers value on > shmem, and only the launcher process can modify its value if the GUC > is changed. Autovacuum workers simply increase or decrease the > av_freeParallelWorkers within the range of 0 and the > autovacuum_max_parallel_workers value on shmem. When changing > autovacuum_max_parallel_workers and av_freeParallelWorkers values on > shmem, the launcher process calculates the number of workers reserved > at that time and calculate the new av_freeParallelWorkers value by > subtracting the new autovacuum_max_parallel_workers by the number of > reserved workers. > Good idea, I agree. Replacing the GUC parameter with the variable in shmem leaves the current logic of free workers management unchanged. Essentially, this is the same solution as I described above, but we are holding lock no= t during config reloading, but during a simple value check. It makes much more sense. > --- > +AutoVacuumReserveParallelWorkers(int nworkers) > +{ > + int can_launch; > > How about renaming it to 'nreserved' or something? can_launch looks > like it's a boolean variable to indicate whether the process can > launch workers. > There are no objections. On Fri, Aug 15, 2025 at 3:41=E2=80=AFAM Masahiko Sawada wrote: > > While testing the patch, I found there are other two problems: > > 1. when an autovacuum worker who reserved workers fails with an error, > the reserved workers are not released. I think we need to ensure that > all reserved workers are surely released at the end of vacuum even > with an error. > Agree. I'll add a try/catch block to the parallel_vacuum_process_all_indexe= s (the only place where we are reserving workers). > 2. when an autovacuum worker (not parallel vacuum worker) who uses > parallel vacuum gets SIGHUP, it errors out with the error message > "parameter "max_stack_depth" cannot be set during a parallel > operation". Autovacuum checks the configuration file reload in > vacuum_delay_point(), and while reloading the configuration file, it > attempts to set max_stack_depth in > InitializeGUCOptionsFromEnvironment() (which is called by > ProcessConfigFileInternal()). However, it cannot change > max_stack_depth since the worker is in parallel mode but > max_stack_depth doesn't have GUC_ALLOW_IN_PARALLEL flag. This doesn't > happen in regular backends who are using parallel queries because they > check the configuration file reload at the end of each SQL command. > Hm, this is a really serious problem. I see only two ways to solve it (both= are not really good) : 1) Do not allow processing of the config file during parallel autovacuum execution. 2) Teach the autovacuum to enter parallel mode only during the index vacuum/cl= eanup phase. I'm a bit wary about it, because the design says that we should be in parallel mode during the whole parallel operation. But actually, if we can make sure that all launched workers are exited, I don't see reasons, why can't we just exit parallel mode at the end of parallel_vacuum_process_all_indexes. What do you think about it? By now, I haven't made any changes related to this problem. Again, thank you for the review. Please, see v10 patches (only 0001 has been changed) : 1) Reserve and release workers only inside parallel_vacuum_process_all_inde= xes. 2) Add try/catch block to the parallel_vacuum_process_all_indexes, so we ca= n release workers even after an error. This required adding a static variable to account for the total number of reserved workers (av_nworkers_reserved). 3) Cap autovacuum_max_parallel_workers by max_worker_processes only inside autovacuum code. Assign hook has been removed. 4) Use shmem value for determining the maximum number of parallel autovacuu= m workers (eliminate race condition between launcher and leader process). -- Best regards, Daniil Davydov --000000000000d6bce0063c9f8f3a Content-Type: text/x-patch; charset="US-ASCII"; name="v10-0002-Logging-for-parallel-autovacuum.patch" Content-Disposition: attachment; filename="v10-0002-Logging-for-parallel-autovacuum.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_meguq8101 RnJvbSBlOTkxZTA3MWQ0Nzk4ZThjMmVjNTc2Mzg5ZjVhODU5MmZlNzYyODJiIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBNb24sIDE4IEF1ZyAyMDI1IDE1OjE0OjI1ICswNzAwClN1YmplY3Q6IFtQQVRD SCB2MTAgMi8zXSBMb2dnaW5nIGZvciBwYXJhbGxlbCBhdXRvdmFjdXVtCgotLS0KIHNyYy9iYWNr ZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYyAgfCAyNyArKysrKysrKysrKysrKysrKysrKysr KystLQogc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYyB8IDI4ICsrKysrKysr KysrKysrKysrKy0tLS0tLS0tLQogc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmggICAgICAg ICB8IDE2ICsrKysrKysrKysrKystLQogMyBmaWxlcyBjaGFuZ2VkLCA1OCBpbnNlcnRpb25zKCsp LCAxMyBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92 YWN1dW1sYXp5LmMgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMKaW5kZXgg MTQwMzZjMjdlODcuLmYxYTY0NWU3OWE5IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nlc3Mv aGVhcC92YWN1dW1sYXp5LmMKKysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvdmFjdXVtbGF6 eS5jCkBAIC0zNDgsNiArMzQ4LDEyIEBAIHR5cGVkZWYgc3RydWN0IExWUmVsU3RhdGUKIAogCS8q IEluc3RydW1lbnRhdGlvbiBjb3VudGVycyAqLwogCWludAkJCW51bV9pbmRleF9zY2FuczsKKwor CS8qCisJICogTnVtYmVyIG9mIHBsYW5uZWQgYW5kIGFjdHVhbGx5IGxhdW5jaGVkIHBhcmFsbGVs IHdvcmtlcnMgZm9yIGFsbCBpbmRleAorCSAqIHNjYW5zLCBvciBOVUxMCisJICovCisJUFZXb3Jr ZXJzVXNhZ2UgKndvcmtlcnNfdXNhZ2U7CiAJLyogQ291bnRlcnMgdGhhdCBmb2xsb3cgYXJlIG9u bHkgZm9yIHNjYW5uZWRfcGFnZXMgKi8KIAlpbnQ2NAkJdHVwbGVzX2RlbGV0ZWQ7IC8qICMgZGVs ZXRlZCBmcm9tIHRhYmxlICovCiAJaW50NjQJCXR1cGxlc19mcm96ZW47CS8qICMgbmV3bHkgZnJv emVuICovCkBAIC02ODgsNiArNjk0LDE2IEBAIGhlYXBfdmFjdXVtX3JlbChSZWxhdGlvbiByZWws IGNvbnN0IFZhY3V1bVBhcmFtcyBwYXJhbXMsCiAJCWluZG5hbWVzID0gcGFsbG9jKHNpemVvZihj aGFyICopICogdmFjcmVsLT5uaW5kZXhlcyk7CiAJCWZvciAoaW50IGkgPSAwOyBpIDwgdmFjcmVs LT5uaW5kZXhlczsgaSsrKQogCQkJaW5kbmFtZXNbaV0gPSBwc3RyZHVwKFJlbGF0aW9uR2V0UmVs YXRpb25OYW1lKHZhY3JlbC0+aW5kcmVsc1tpXSkpOworCisJCS8qCisJCSAqIEFsbG9jYXRlIHNw YWNlIGZvciB3b3JrZXJzIHVzYWdlIHN0YXRpc3RpY3MuIFRodXMsIHdlIGV4cGxpY2l0bHkKKwkJ ICogbWFrZSBjbGVhciB0aGF0IHN1Y2ggc3RhdGlzdGljcyBtdXN0IGJlIGFjY3VtdWxhdGVkLiBG b3Igbm93LCB0aGlzCisJCSAqIGlzIHVzZWQgb25seSBieSBhdXRvdmFjdXVtIGxlYWRlciB3b3Jr ZXIsIGJlY2F1c2UgaXQgbXVzdCBsb2cgaXQgaW4KKwkJICogdGhlIGVuZCBvZiB0YWJsZSBwcm9j ZXNzaW5nLgorCQkgKi8KKwkJdmFjcmVsLT53b3JrZXJzX3VzYWdlID0gQW1BdXRvVmFjdXVtV29y a2VyUHJvY2VzcygpID8KKwkJCShQVldvcmtlcnNVc2FnZSAqKSBwYWxsb2MwKHNpemVvZihQVldv cmtlcnNVc2FnZSkpIDoKKwkJCU5VTEw7CiAJfQogCiAJLyoKQEAgLTEwMTIsNiArMTAyOCwxMSBA QCBoZWFwX3ZhY3V1bV9yZWwoUmVsYXRpb24gcmVsLCBjb25zdCBWYWN1dW1QYXJhbXMgcGFyYW1z LAogCQkJCQkJCSB2YWNyZWwtPnJlbG5hbWVzcGFjZSwKIAkJCQkJCQkgdmFjcmVsLT5yZWxuYW1l LAogCQkJCQkJCSB2YWNyZWwtPm51bV9pbmRleF9zY2Fucyk7CisJCQlpZiAodmFjcmVsLT53b3Jr ZXJzX3VzYWdlKQorCQkJCWFwcGVuZFN0cmluZ0luZm8oJmJ1ZiwKKwkJCQkJCQkJIF8oIndvcmtl cnMgdXNhZ2Ugc3RhdGlzdGljcyBmb3IgYWxsIG9mIGluZGV4IHNjYW5zIDogbGF1bmNoZWQgaW4g dG90YWwgPSAlZCwgcGxhbm5lZCBpbiB0b3RhbCA9ICVkXG4iKSwKKwkJCQkJCQkJIHZhY3JlbC0+ d29ya2Vyc191c2FnZS0+bmxhdW5jaGVkLAorCQkJCQkJCQkgdmFjcmVsLT53b3JrZXJzX3VzYWdl LT5ucGxhbm5lZCk7CiAJCQlhcHBlbmRTdHJpbmdJbmZvKCZidWYsIF8oInBhZ2VzOiAldSByZW1v dmVkLCAldSByZW1haW4sICV1IHNjYW5uZWQgKCUuMmYlJSBvZiB0b3RhbCksICV1IGVhZ2VybHkg c2Nhbm5lZFxuIiksCiAJCQkJCQkJIHZhY3JlbC0+cmVtb3ZlZF9wYWdlcywKIAkJCQkJCQkgbmV3 X3JlbF9wYWdlcywKQEAgLTI2MzQsNyArMjY1NSw4IEBAIGxhenlfdmFjdXVtX2FsbF9pbmRleGVz KExWUmVsU3RhdGUgKnZhY3JlbCkKIAl7CiAJCS8qIE91dHNvdXJjZSBldmVyeXRoaW5nIHRvIHBh cmFsbGVsIHZhcmlhbnQgKi8KIAkJcGFyYWxsZWxfdmFjdXVtX2J1bGtkZWxfYWxsX2luZGV4ZXMo dmFjcmVsLT5wdnMsIG9sZF9saXZlX3R1cGxlcywKLQkJCQkJCQkJCQkJdmFjcmVsLT5udW1faW5k ZXhfc2NhbnMpOworCQkJCQkJCQkJCQl2YWNyZWwtPm51bV9pbmRleF9zY2FucywKKwkJCQkJCQkJ CQkJdmFjcmVsLT53b3JrZXJzX3VzYWdlKTsKIAogCQkvKgogCQkgKiBEbyBhIHBvc3RjaGVjayB0 byBjb25zaWRlciBhcHBseWluZyB3cmFwYXJvdW5kIGZhaWxzYWZlIG5vdy4gIE5vdGUKQEAgLTMw NDcsNyArMzA2OSw4IEBAIGxhenlfY2xlYW51cF9hbGxfaW5kZXhlcyhMVlJlbFN0YXRlICp2YWNy ZWwpCiAJCS8qIE91dHNvdXJjZSBldmVyeXRoaW5nIHRvIHBhcmFsbGVsIHZhcmlhbnQgKi8KIAkJ cGFyYWxsZWxfdmFjdXVtX2NsZWFudXBfYWxsX2luZGV4ZXModmFjcmVsLT5wdnMsIHJlbHR1cGxl cywKIAkJCQkJCQkJCQkJdmFjcmVsLT5udW1faW5kZXhfc2NhbnMsCi0JCQkJCQkJCQkJCWVzdGlt YXRlZF9jb3VudCk7CisJCQkJCQkJCQkJCWVzdGltYXRlZF9jb3VudCwKKwkJCQkJCQkJCQkJdmFj cmVsLT53b3JrZXJzX3VzYWdlKTsKIAl9CiAKIAkvKiBSZXNldCB0aGUgcHJvZ3Jlc3MgY291bnRl cnMgKi8KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMg Yi9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCmluZGV4IDQyMjFlNjA4NGY1 Li4wMjg3MGVkMTI4OCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFy YWxsZWwuYworKysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCkBAIC0y MjcsOSArMjI3LDEwIEBAIHN0cnVjdCBQYXJhbGxlbFZhY3V1bVN0YXRlCiBzdGF0aWMgaW50CXBh cmFsbGVsX3ZhY3V1bV9jb21wdXRlX3dvcmtlcnMoUmVsYXRpb24gKmluZHJlbHMsIGludCBuaW5k ZXhlcywgaW50IG5yZXF1ZXN0ZWQsCiAJCQkJCQkJCQkJCWJvb2wgKndpbGxfcGFyYWxsZWxfdmFj dXVtKTsKIHN0YXRpYyB2b2lkIHBhcmFsbGVsX3ZhY3V1bV9wcm9jZXNzX2FsbF9pbmRleGVzKFBh cmFsbGVsVmFjdXVtU3RhdGUgKnB2cywgaW50IG51bV9pbmRleF9zY2FucywKLQkJCQkJCQkJCQkJ CWJvb2wgdmFjdXVtKTsKKwkJCQkJCQkJCQkJCWJvb2wgdmFjdXVtLCBQVldvcmtlcnNVc2FnZSAq IHd1c2FnZSk7CiBzdGF0aWMgdm9pZCBwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19hbGxfaW5kZXhl c19pbnRlcm5hbChQYXJhbGxlbFZhY3V1bVN0YXRlICpwdnMsCi0JCQkJCQkJCQkJCQkJCSBpbnQg bnVtX2luZGV4X3NjYW5zLCBib29sIHZhY3V1bSk7CisJCQkJCQkJCQkJCQkJCSBpbnQgbnVtX2lu ZGV4X3NjYW5zLCBib29sIHZhY3V1bSwKKwkJCQkJCQkJCQkJCQkJIFBWV29ya2Vyc1VzYWdlICog d3VzYWdlKTsKIHN0YXRpYyB2b2lkIHBhcmFsbGVsX3ZhY3V1bV9wcm9jZXNzX3NhZmVfaW5kZXhl cyhQYXJhbGxlbFZhY3V1bVN0YXRlICpwdnMpOwogc3RhdGljIHZvaWQgcGFyYWxsZWxfdmFjdXVt X3Byb2Nlc3NfdW5zYWZlX2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzKTsKIHN0YXRp YyB2b2lkIHBhcmFsbGVsX3ZhY3V1bV9wcm9jZXNzX29uZV9pbmRleChQYXJhbGxlbFZhY3V1bVN0 YXRlICpwdnMsIFJlbGF0aW9uIGluZHJlbCwKQEAgLTUwNCw3ICs1MDUsNyBAQCBwYXJhbGxlbF92 YWN1dW1fcmVzZXRfZGVhZF9pdGVtcyhQYXJhbGxlbFZhY3V1bVN0YXRlICpwdnMpCiAgKi8KIHZv aWQKIHBhcmFsbGVsX3ZhY3V1bV9idWxrZGVsX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3Rh dGUgKnB2cywgbG9uZyBudW1fdGFibGVfdHVwbGVzLAotCQkJCQkJCQkJaW50IG51bV9pbmRleF9z Y2FucykKKwkJCQkJCQkJCWludCBudW1faW5kZXhfc2NhbnMsIFBWV29ya2Vyc1VzYWdlICogd3Vz YWdlKQogewogCUFzc2VydCghSXNQYXJhbGxlbFdvcmtlcigpKTsKIApAQCAtNTE1LDcgKzUxNiw3 IEBAIHBhcmFsbGVsX3ZhY3V1bV9idWxrZGVsX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3Rh dGUgKnB2cywgbG9uZyBudW1fdGFibGVfdHVwCiAJcHZzLT5zaGFyZWQtPnJlbHR1cGxlcyA9IG51 bV90YWJsZV90dXBsZXM7CiAJcHZzLT5zaGFyZWQtPmVzdGltYXRlZF9jb3VudCA9IHRydWU7CiAK LQlwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19hbGxfaW5kZXhlcyhwdnMsIG51bV9pbmRleF9zY2Fu cywgdHJ1ZSk7CisJcGFyYWxsZWxfdmFjdXVtX3Byb2Nlc3NfYWxsX2luZGV4ZXMocHZzLCBudW1f aW5kZXhfc2NhbnMsIHRydWUsIHd1c2FnZSk7CiB9CiAKIC8qCkBAIC01MjMsNyArNTI0LDggQEAg cGFyYWxsZWxfdmFjdXVtX2J1bGtkZWxfYWxsX2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAq cHZzLCBsb25nIG51bV90YWJsZV90dXAKICAqLwogdm9pZAogcGFyYWxsZWxfdmFjdXVtX2NsZWFu dXBfYWxsX2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLCBsb25nIG51bV90YWJsZV90 dXBsZXMsCi0JCQkJCQkJCQlpbnQgbnVtX2luZGV4X3NjYW5zLCBib29sIGVzdGltYXRlZF9jb3Vu dCkKKwkJCQkJCQkJCWludCBudW1faW5kZXhfc2NhbnMsIGJvb2wgZXN0aW1hdGVkX2NvdW50LAor CQkJCQkJCQkJUFZXb3JrZXJzVXNhZ2UgKiB3dXNhZ2UpCiB7CiAJQXNzZXJ0KCFJc1BhcmFsbGVs V29ya2VyKCkpOwogCkBAIC01MzUsNyArNTM3LDcgQEAgcGFyYWxsZWxfdmFjdXVtX2NsZWFudXBf YWxsX2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLCBsb25nIG51bV90YWJsZV90dXAK IAlwdnMtPnNoYXJlZC0+cmVsdHVwbGVzID0gbnVtX3RhYmxlX3R1cGxlczsKIAlwdnMtPnNoYXJl ZC0+ZXN0aW1hdGVkX2NvdW50ID0gZXN0aW1hdGVkX2NvdW50OwogCi0JcGFyYWxsZWxfdmFjdXVt X3Byb2Nlc3NfYWxsX2luZGV4ZXMocHZzLCBudW1faW5kZXhfc2NhbnMsIGZhbHNlKTsKKwlwYXJh bGxlbF92YWN1dW1fcHJvY2Vzc19hbGxfaW5kZXhlcyhwdnMsIG51bV9pbmRleF9zY2FucywgZmFs c2UsIHd1c2FnZSk7CiB9CiAKIC8qCkBAIC02MjAsNyArNjIyLDcgQEAgcGFyYWxsZWxfdmFjdXVt X2NvbXB1dGVfd29ya2VycyhSZWxhdGlvbiAqaW5kcmVscywgaW50IG5pbmRleGVzLCBpbnQgbnJl cXVlc3RlZCwKICAqLwogc3RhdGljIHZvaWQKIHBhcmFsbGVsX3ZhY3V1bV9wcm9jZXNzX2FsbF9p bmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywgaW50IG51bV9pbmRleF9zY2FucywKLQkJ CQkJCQkJCWJvb2wgdmFjdXVtKQorCQkJCQkJCQkJYm9vbCB2YWN1dW0sIFBWV29ya2Vyc1VzYWdl ICogd3VzYWdlKQogewogCS8qCiAJICogUGFyYWxsZWwgYXV0b3ZhY3V1bSBjYW4gcmVzZXJ2ZSBw YXJhbGxlbCB3b3JrZXJzLiBVc2UgdHJ5L2NhdGNoIGJsb2NrCkBAIC02MjksNyArNjMxLDcgQEAg cGFyYWxsZWxfdmFjdXVtX3Byb2Nlc3NfYWxsX2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAq cHZzLCBpbnQgbnVtX2luZGV4X3NjYW4KIAlQR19UUlkoKTsKIAl7CiAJCXBhcmFsbGVsX3ZhY3V1 bV9wcm9jZXNzX2FsbF9pbmRleGVzX2ludGVybmFsKHB2cywgbnVtX2luZGV4X3NjYW5zLAotCQkJ CQkJCQkJCQkJCSBmYWxzZSk7CisJCQkJCQkJCQkJCQkJIGZhbHNlLCB3dXNhZ2UpOwogCX0KIAlQ R19DQVRDSCgpOwogCXsKQEAgLTY0NCw3ICs2NDYsOCBAQCBwYXJhbGxlbF92YWN1dW1fcHJvY2Vz c19hbGxfaW5kZXhlcyhQYXJhbGxlbFZhY3V1bVN0YXRlICpwdnMsIGludCBudW1faW5kZXhfc2Nh bgogCiBzdGF0aWMgdm9pZAogcGFyYWxsZWxfdmFjdXVtX3Byb2Nlc3NfYWxsX2luZGV4ZXNfaW50 ZXJuYWwoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLAotCQkJCQkJCQkJCQkgaW50IG51bV9pbmRl eF9zY2FucywgYm9vbCB2YWN1dW0pCisJCQkJCQkJCQkJCSBpbnQgbnVtX2luZGV4X3NjYW5zLCBi b29sIHZhY3V1bSwKKwkJCQkJCQkJCQkJIFBWV29ya2Vyc1VzYWdlICogd3VzYWdlKQogewogCWlu dAkJCW53b3JrZXJzOwogCVBWSW5kVmFjU3RhdHVzIG5ld19zdGF0dXM7CkBAIC03NjgsNiArNzcx LDEzIEBAIHBhcmFsbGVsX3ZhY3V1bV9wcm9jZXNzX2FsbF9pbmRleGVzX2ludGVybmFsKFBhcmFs bGVsVmFjdXVtU3RhdGUgKnB2cywKIAkJCQkJCQkJCSAibGF1bmNoZWQgJWQgcGFyYWxsZWwgdmFj dXVtIHdvcmtlcnMgZm9yIGluZGV4IGNsZWFudXAgKHBsYW5uZWQ6ICVkKSIsCiAJCQkJCQkJCQkg cHZzLT5wY3h0LT5ud29ya2Vyc19sYXVuY2hlZCksCiAJCQkJCQkJcHZzLT5wY3h0LT5ud29ya2Vy c19sYXVuY2hlZCwgbndvcmtlcnMpKSk7CisKKwkJLyogUmVtZW1iZXIgdGhlc2UgdmFsdWVzLCBp ZiB3ZSBhc2tlZCB0by4gKi8KKwkJaWYgKHd1c2FnZSAhPSBOVUxMKQorCQl7CisJCQl3dXNhZ2Ut Pm5sYXVuY2hlZCArPSBwdnMtPnBjeHQtPm53b3JrZXJzX2xhdW5jaGVkOworCQkJd3VzYWdlLT5u cGxhbm5lZCArPSBud29ya2VyczsKKwkJfQogCX0KIAogCS8qIFZhY3V1bSB0aGUgaW5kZXhlcyB0 aGF0IGNhbiBiZSBwcm9jZXNzZWQgYnkgb25seSBsZWFkZXIgcHJvY2VzcyAqLwpkaWZmIC0tZ2l0 IGEvc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmggYi9zcmMvaW5jbHVkZS9jb21tYW5kcy92 YWN1dW0uaAppbmRleCAxNGVlY2NiZDcxOC4uZDA1ZWY3NDYxZWEgMTAwNjQ0Ci0tLSBhL3NyYy9p bmNsdWRlL2NvbW1hbmRzL3ZhY3V1bS5oCisrKyBiL3NyYy9pbmNsdWRlL2NvbW1hbmRzL3ZhY3V1 bS5oCkBAIC0yOTUsNiArMjk1LDE2IEBAIHR5cGVkZWYgc3RydWN0IFZhY0RlYWRJdGVtc0luZm8K IAlpbnQ2NAkJbnVtX2l0ZW1zOwkJLyogY3VycmVudCAjIG9mIGVudHJpZXMgKi8KIH0gVmFjRGVh ZEl0ZW1zSW5mbzsKIAorLyoKKyAqIFBWV29ya2Vyc1VzYWdlIHN0b3JlcyBpbmZvcm1hdGlvbiBh Ym91dCB0b3RhbCBudW1iZXIgb2YgbGF1bmNoZWQgYW5kIHBsYW5uZWQKKyAqIHdvcmtlcnMgZHVy aW5nIHBhcmFsbGVsIHZhY3V1bS4KKyAqLwordHlwZWRlZiBzdHJ1Y3QgUFZXb3JrZXJzVXNhZ2UK K3sKKwlpbnQJCQlubGF1bmNoZWQ7CisJaW50CQkJbnBsYW5uZWQ7Cit9CQkJUFZXb3JrZXJzVXNh Z2U7CisKIC8qIEdVQyBwYXJhbWV0ZXJzICovCiBleHRlcm4gUEdETExJTVBPUlQgaW50IGRlZmF1 bHRfc3RhdGlzdGljc190YXJnZXQ7CS8qIFBHRExMSU1QT1JUIGZvciBQb3N0R0lTICovCiBleHRl cm4gUEdETExJTVBPUlQgaW50IHZhY3V1bV9mcmVlemVfbWluX2FnZTsKQEAgLTM4OSwxMSArMzk5 LDEzIEBAIGV4dGVybiBUaWRTdG9yZSAqcGFyYWxsZWxfdmFjdXVtX2dldF9kZWFkX2l0ZW1zKFBh cmFsbGVsVmFjdXVtU3RhdGUgKnB2cywKIGV4dGVybiB2b2lkIHBhcmFsbGVsX3ZhY3V1bV9yZXNl dF9kZWFkX2l0ZW1zKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cyk7CiBleHRlcm4gdm9pZCBwYXJh bGxlbF92YWN1dW1fYnVsa2RlbF9hbGxfaW5kZXhlcyhQYXJhbGxlbFZhY3V1bVN0YXRlICpwdnMs CiAJCQkJCQkJCQkJCQlsb25nIG51bV90YWJsZV90dXBsZXMsCi0JCQkJCQkJCQkJCQlpbnQgbnVt X2luZGV4X3NjYW5zKTsKKwkJCQkJCQkJCQkJCWludCBudW1faW5kZXhfc2NhbnMsCisJCQkJCQkJ CQkJCQlQVldvcmtlcnNVc2FnZSAqIHd1c2FnZSk7CiBleHRlcm4gdm9pZCBwYXJhbGxlbF92YWN1 dW1fY2xlYW51cF9hbGxfaW5kZXhlcyhQYXJhbGxlbFZhY3V1bVN0YXRlICpwdnMsCiAJCQkJCQkJ CQkJCQlsb25nIG51bV90YWJsZV90dXBsZXMsCiAJCQkJCQkJCQkJCQlpbnQgbnVtX2luZGV4X3Nj YW5zLAotCQkJCQkJCQkJCQkJYm9vbCBlc3RpbWF0ZWRfY291bnQpOworCQkJCQkJCQkJCQkJYm9v bCBlc3RpbWF0ZWRfY291bnQsCisJCQkJCQkJCQkJCQlQVldvcmtlcnNVc2FnZSAqIHd1c2FnZSk7 CiBleHRlcm4gdm9pZCBwYXJhbGxlbF92YWN1dW1fbWFpbihkc21fc2VnbWVudCAqc2VnLCBzaG1f dG9jICp0b2MpOwogCiAvKiBpbiBjb21tYW5kcy9hbmFseXplLmMgKi8KLS0gCjIuNDMuMAoK --000000000000d6bce0063c9f8f3a Content-Type: text/x-patch; charset="US-ASCII"; name="v10-0003-Documentation-for-parallel-autovacuum.patch" Content-Disposition: attachment; filename="v10-0003-Documentation-for-parallel-autovacuum.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_meguq8192 RnJvbSA2MmFiYjEyMGQ4ODhhODM3ZTUwYmI1NWJhMjZiYTc0MGNhYWQ4ZjdhIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBUdWUsIDIyIEp1bCAyMDI1IDEyOjMxOjIwICswNzAwClN1YmplY3Q6IFtQQVRD SCB2MTAgMy8zXSBEb2N1bWVudGF0aW9uIGZvciBwYXJhbGxlbCBhdXRvdmFjdXVtCgotLS0KIGRv Yy9zcmMvc2dtbC9jb25maWcuc2dtbCAgICAgICAgICAgfCAxOCArKysrKysrKysrKysrKysrKysK IGRvYy9zcmMvc2dtbC9tYWludGVuYW5jZS5zZ21sICAgICAgfCAxMiArKysrKysrKysrKysKIGRv Yy9zcmMvc2dtbC9yZWYvY3JlYXRlX3RhYmxlLnNnbWwgfCAyMCArKysrKysrKysrKysrKysrKysr KwogMyBmaWxlcyBjaGFuZ2VkLCA1MCBpbnNlcnRpb25zKCspCgpkaWZmIC0tZ2l0IGEvZG9jL3Ny Yy9zZ21sL2NvbmZpZy5zZ21sIGIvZG9jL3NyYy9zZ21sL2NvbmZpZy5zZ21sCmluZGV4IDIwY2Ni MmQ2YjU0Li5iNzQwNTMyODFkZSAxMDA2NDQKLS0tIGEvZG9jL3NyYy9zZ21sL2NvbmZpZy5zZ21s CisrKyBiL2RvYy9zcmMvc2dtbC9jb25maWcuc2dtbApAQCAtMjgzNSw2ICsyODM1LDcgQEAgaW5j bHVkZV9kaXIgJ2NvbmYuZCcKICAgICAgICAgPHBhcmE+CiAgICAgICAgICBXaGVuIGNoYW5naW5n IHRoaXMgdmFsdWUsIGNvbnNpZGVyIGFsc28gYWRqdXN0aW5nCiAgICAgICAgICA8eHJlZiBsaW5r ZW5kPSJndWMtbWF4LXBhcmFsbGVsLXdvcmtlcnMiLz4sCisgICAgICAgICA8eHJlZiBsaW5rZW5k PSJndWMtYXV0b3ZhY3V1bS1tYXgtcGFyYWxsZWwtd29ya2VycyIvPiwKICAgICAgICAgIDx4cmVm IGxpbmtlbmQ9Imd1Yy1tYXgtcGFyYWxsZWwtbWFpbnRlbmFuY2Utd29ya2VycyIvPiwgYW5kCiAg ICAgICAgICA8eHJlZiBsaW5rZW5kPSJndWMtbWF4LXBhcmFsbGVsLXdvcmtlcnMtcGVyLWdhdGhl ciIvPi4KICAgICAgICAgPC9wYXJhPgpAQCAtOTE4OSw2ICs5MTkwLDIzIEBAIENPUFkgcG9zdGdy ZXNfbG9nIEZST00gJy9mdWxsL3BhdGgvdG8vbG9nZmlsZS5jc3YnIFdJVEggY3N2OwogICAgICAg IDwvbGlzdGl0ZW0+CiAgICAgICA8L3Zhcmxpc3RlbnRyeT4KIAorICAgICAgPHZhcmxpc3RlbnRy eSBpZD0iZ3VjLWF1dG92YWN1dW0tbWF4LXBhcmFsbGVsLXdvcmtlcnMiIHhyZWZsYWJlbD0iYXV0 b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2VycyI+CisgICAgICAgIDx0ZXJtPjx2YXJuYW1lPmF1 dG92YWN1dW1fbWF4X3BhcmFsbGVsX3dvcmtlcnM8L3Zhcm5hbWU+ICg8dHlwZT5pbnRlZ2VyPC90 eXBlPikKKyAgICAgICAgPGluZGV4dGVybT4KKyAgICAgICAgIDxwcmltYXJ5Pjx2YXJuYW1lPmF1 dG92YWN1dW1fbWF4X3BhcmFsbGVsX3dvcmtlcnM8L3Zhcm5hbWU+PC9wcmltYXJ5PgorICAgICAg ICAgPHNlY29uZGFyeT5jb25maWd1cmF0aW9uIHBhcmFtZXRlcjwvc2Vjb25kYXJ5PgorICAgICAg ICA8L2luZGV4dGVybT4KKyAgICAgICAgPC90ZXJtPgorICAgICAgICA8bGlzdGl0ZW0+CisgICAg ICAgICA8cGFyYT4KKyAgICAgICAgICBTZXRzIHRoZSBtYXhpbXVtIG51bWJlciBvZiBwYXJhbGxl bCBhdXRvdmFjdXVtIHdvcmtlcnMgdGhhdAorICAgICAgICAgIGNhbiBiZSB1c2VkIGZvciBwYXJh bGxlbCBpbmRleCB2YWN1dW1pbmcgYXQgb25lIHRpbWUuIElzIGNhcHBlZCBieQorICAgICAgICAg IDx4cmVmIGxpbmtlbmQ9Imd1Yy1tYXgtd29ya2VyLXByb2Nlc3NlcyIvPi4gVGhlIGRlZmF1bHQg aXMgMCwKKyAgICAgICAgICB3aGljaCBtZWFucyBubyBwYXJhbGxlbCBpbmRleCB2YWN1dW1pbmcu CisgICAgICAgICA8L3BhcmE+CisgICAgICAgIDwvbGlzdGl0ZW0+CisgICAgIDwvdmFybGlzdGVu dHJ5PgorCiAgICAgIDwvdmFyaWFibGVsaXN0PgogICAgIDwvc2VjdDI+CiAKZGlmZiAtLWdpdCBh L2RvYy9zcmMvc2dtbC9tYWludGVuYW5jZS5zZ21sIGIvZG9jL3NyYy9zZ21sL21haW50ZW5hbmNl LnNnbWwKaW5kZXggZTdhOWY1OGMwMTUuLjRlNDUwYmE5MDY2IDEwMDY0NAotLS0gYS9kb2Mvc3Jj L3NnbWwvbWFpbnRlbmFuY2Uuc2dtbAorKysgYi9kb2Mvc3JjL3NnbWwvbWFpbnRlbmFuY2Uuc2dt bApAQCAtODk2LDYgKzg5NiwxOCBAQCBISU5UOiAgRXhlY3V0ZSBhIGRhdGFiYXNlLXdpZGUgVkFD VVVNIGluIHRoYXQgZGF0YWJhc2UuCiAgICAgYXV0b3ZhY3V1bSB3b3JrZXJzJyBhY3Rpdml0eS4K ICAgIDwvcGFyYT4KIAorICAgPHBhcmE+CisgICAgSWYgYW4gYXV0b3ZhY3V1bSB3b3JrZXIgcHJv Y2VzcyBjb21lcyBhY3Jvc3MgYSB0YWJsZSB3aXRoIHRoZSBlbmFibGVkCisgICAgPHhyZWYgbGlu a2VuZD0icmVsb3B0aW9uLWF1dG92YWN1dW0tcGFyYWxsZWwtd29ya2VycyIvPiBzdG9yYWdlIHBh cmFtZXRlciwKKyAgICBpdCB3aWxsIGxhdW5jaCBwYXJhbGxlbCB3b3JrZXJzIGluIG9yZGVyIHRv IHZhY3V1bSBpbmRleGVzIG9mIHRoaXMgdGFibGUKKyAgICBpbiBhIHBhcmFsbGVsIG1vZGUuIFBh cmFsbGVsIHdvcmtlcnMgYXJlIHRha2VuIGZyb20gdGhlIHBvb2wgb2YgcHJvY2Vzc2VzCisgICAg ZXN0YWJsaXNoZWQgYnkgPHhyZWYgbGlua2VuZD0iZ3VjLW1heC13b3JrZXItcHJvY2Vzc2VzIi8+ LCBsaW1pdGVkIGJ5CisgICAgPHhyZWYgbGlua2VuZD0iZ3VjLW1heC1wYXJhbGxlbC13b3JrZXJz Ii8+LgorICAgIFRoZSB0b3RhbCBudW1iZXIgb2YgcGFyYWxsZWwgYXV0b3ZhY3V1bSB3b3JrZXJz IHRoYXQgY2FuIGJlIGFjdGl2ZSBhdCBvbmUKKyAgICB0aW1lIGlzIGxpbWl0ZWQgYnkgdGhlIDx4 cmVmIGxpbmtlbmQ9Imd1Yy1hdXRvdmFjdXVtLW1heC1wYXJhbGxlbC13b3JrZXJzIi8+CisgICAg Y29uZmlndXJhdGlvbiBwYXJhbWV0ZXIuCisgICA8L3BhcmE+CisKICAgIDxwYXJhPgogICAgIElm IHNldmVyYWwgbGFyZ2UgdGFibGVzIGFsbCBiZWNvbWUgZWxpZ2libGUgZm9yIHZhY3V1bWluZyBp biBhIHNob3J0CiAgICAgYW1vdW50IG9mIHRpbWUsIGFsbCBhdXRvdmFjdXVtIHdvcmtlcnMgbWln aHQgYmVjb21lIG9jY3VwaWVkIHdpdGgKZGlmZiAtLWdpdCBhL2RvYy9zcmMvc2dtbC9yZWYvY3Jl YXRlX3RhYmxlLnNnbWwgYi9kb2Mvc3JjL3NnbWwvcmVmL2NyZWF0ZV90YWJsZS5zZ21sCmluZGV4 IGRjMDAwZTkxM2MxLi4yODhkZTZiMGZmZCAxMDA2NDQKLS0tIGEvZG9jL3NyYy9zZ21sL3JlZi9j cmVhdGVfdGFibGUuc2dtbAorKysgYi9kb2Mvc3JjL3NnbWwvcmVmL2NyZWF0ZV90YWJsZS5zZ21s CkBAIC0xNzE3LDYgKzE3MTcsMjYgQEAgV0lUSCAoIE1PRFVMVVMgPHJlcGxhY2VhYmxlIGNsYXNz PSJwYXJhbWV0ZXIiPm51bWVyaWNfbGl0ZXJhbDwvcmVwbGFjZWFibGU+LCBSRU0KICAgICA8L2xp c3RpdGVtPgogICAgPC92YXJsaXN0ZW50cnk+CiAKKyAgPHZhcmxpc3RlbnRyeSBpZD0icmVsb3B0 aW9uLWF1dG92YWN1dW0tcGFyYWxsZWwtd29ya2VycyIgeHJlZmxhYmVsPSJhdXRvdmFjdXVtX3Bh cmFsbGVsX3dvcmtlcnMiPgorICAgIDx0ZXJtPjxsaXRlcmFsPmF1dG92YWN1dW1fcGFyYWxsZWxf d29ya2VyczwvbGl0ZXJhbD4gKDx0eXBlPmludGVnZXI8L3R5cGU+KQorICAgIDxpbmRleHRlcm0+ CisgICAgIDxwcmltYXJ5Pjx2YXJuYW1lPmF1dG92YWN1dW1fcGFyYWxsZWxfd29ya2VyczwvdmFy bmFtZT4gc3RvcmFnZSBwYXJhbWV0ZXI8L3ByaW1hcnk+CisgICAgPC9pbmRleHRlcm0+CisgICAg PC90ZXJtPgorICAgIDxsaXN0aXRlbT4KKyAgICAgPHBhcmE+CisgICAgICBTZXRzIHRoZSBtYXhp bXVtIG51bWJlciBvZiBwYXJhbGxlbCBhdXRvdmFjdXVtIHdvcmtlcnMgdGhhdCBjYW4gcHJvY2Vz cworICAgICAgaW5kZXhlcyBvZiB0aGlzIHRhYmxlLgorICAgICAgVGhlIGRlZmF1bHQgdmFsdWUg aXMgLTEsIHdoaWNoIG1lYW5zIG5vIHBhcmFsbGVsIGluZGV4IHZhY3V1bWluZyBmb3IKKyAgICAg IHRoaXMgdGFibGUuIElmIHZhbHVlIGlzIDAgdGhlbiBwYXJhbGxlbCBkZWdyZWUgd2lsbCBjb21w dXRlZCBiYXNlZCBvbgorICAgICAgbnVtYmVyIG9mIGluZGV4ZXMuCisgICAgICBOb3RlIHRoYXQg dGhlIGNvbXB1dGVkIG51bWJlciBvZiB3b3JrZXJzIG1heSBub3QgYWN0dWFsbHkgYmUgYXZhaWxh YmxlIGF0CisgICAgICBydW4gdGltZS4gSWYgdGhpcyBvY2N1cnMsIHRoZSBhdXRvdmFjdXVtIHdp bGwgcnVuIHdpdGggZmV3ZXIgd29ya2VycworICAgICAgdGhhbiBleHBlY3RlZC4KKyAgICAgPC9w YXJhPgorICAgIDwvbGlzdGl0ZW0+CisgICA8L3Zhcmxpc3RlbnRyeT4KKwogICAgPHZhcmxpc3Rl bnRyeSBpZD0icmVsb3B0aW9uLWF1dG92YWN1dW0tdmFjdXVtLXRocmVzaG9sZCIgeHJlZmxhYmVs PSJhdXRvdmFjdXVtX3ZhY3V1bV90aHJlc2hvbGQiPgogICAgIDx0ZXJtPjxsaXRlcmFsPmF1dG92 YWN1dW1fdmFjdXVtX3RocmVzaG9sZDwvbGl0ZXJhbD4sIDxsaXRlcmFsPnRvYXN0LmF1dG92YWN1 dW1fdmFjdXVtX3RocmVzaG9sZDwvbGl0ZXJhbD4gKDx0eXBlPmludGVnZXI8L3R5cGU+KQogICAg IDxpbmRleHRlcm0+Ci0tIAoyLjQzLjAKCg== --000000000000d6bce0063c9f8f3a Content-Type: text/x-patch; charset="US-ASCII"; name="v10-0001-Parallel-index-autovacuum.patch" Content-Disposition: attachment; filename="v10-0001-Parallel-index-autovacuum.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_meguq80o0 RnJvbSBhNDcwZDk1NjAzYjQzN2VmNWFhNDU0NzBhZDdiZTYxZjAzNjgyNDkzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBTdW4sIDIwIEp1bCAyMDI1IDIzOjAzOjU3ICswNzAwClN1YmplY3Q6IFtQQVRD SCB2MTAgMS8zXSBQYXJhbGxlbCBpbmRleCBhdXRvdmFjdXVtCgotLS0KIHNyYy9iYWNrZW5kL2Fj Y2Vzcy9jb21tb24vcmVsb3B0aW9ucy5jICAgICAgICB8ICAxMSArKwogc3JjL2JhY2tlbmQvY29t bWFuZHMvdmFjdXVtcGFyYWxsZWwuYyAgICAgICAgIHwgIDY4ICsrKysrKysrLQogc3JjL2JhY2tl bmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMgICAgICAgICAgIHwgMTQ0ICsrKysrKysrKysrKysr KysrLQogc3JjL2JhY2tlbmQvdXRpbHMvaW5pdC9nbG9iYWxzLmMgICAgICAgICAgICAgIHwgICAx ICsKIHNyYy9iYWNrZW5kL3V0aWxzL21pc2MvZ3VjX3RhYmxlcy5jICAgICAgICAgICB8ICAxMCAr Kwogc3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9wb3N0Z3Jlc3FsLmNvbmYuc2FtcGxlIHwgICAxICsK IHNyYy9iaW4vcHNxbC90YWItY29tcGxldGUuaW4uYyAgICAgICAgICAgICAgICB8ICAgMSArCiBz cmMvaW5jbHVkZS9taXNjYWRtaW4uaCAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEgKwogc3Jj L2luY2x1ZGUvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmggICAgICAgICAgIHwgICA1ICsKIHNyYy9p bmNsdWRlL3V0aWxzL3JlbC5oICAgICAgICAgICAgICAgICAgICAgICB8ICAgNyArCiAxMCBmaWxl cyBjaGFuZ2VkLCAyNDEgaW5zZXJ0aW9ucygrKSwgOCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQg YS9zcmMvYmFja2VuZC9hY2Nlc3MvY29tbW9uL3JlbG9wdGlvbnMuYyBiL3NyYy9iYWNrZW5kL2Fj Y2Vzcy9jb21tb24vcmVsb3B0aW9ucy5jCmluZGV4IDBhZjNmZWE2OGZhLi4xYzk4ZDQzYzZlYiAx MDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvYWNjZXNzL2NvbW1vbi9yZWxvcHRpb25zLmMKKysrIGIv c3JjL2JhY2tlbmQvYWNjZXNzL2NvbW1vbi9yZWxvcHRpb25zLmMKQEAgLTIyMiw2ICsyMjIsMTUg QEAgc3RhdGljIHJlbG9wdF9pbnQgaW50UmVsT3B0c1tdID0KIAkJfSwKIAkJU1BHSVNUX0RFRkFV TFRfRklMTEZBQ1RPUiwgU1BHSVNUX01JTl9GSUxMRkFDVE9SLCAxMDAKIAl9LAorCXsKKwkJewor CQkJImF1dG92YWN1dW1fcGFyYWxsZWxfd29ya2VycyIsCisJCQkiTWF4aW11bSBudW1iZXIgb2Yg cGFyYWxsZWwgYXV0b3ZhY3V1bSB3b3JrZXJzIHRoYXQgY2FuIGJlIHVzZWQgZm9yIHByb2Nlc3Np bmcgdGhpcyB0YWJsZS4iLAorCQkJUkVMT1BUX0tJTkRfSEVBUCwKKwkJCVNoYXJlVXBkYXRlRXhj bHVzaXZlTG9jaworCQl9LAorCQktMSwgLTEsIDEwMjQKKwl9LAogCXsKIAkJewogCQkJImF1dG92 YWN1dW1fdmFjdXVtX3RocmVzaG9sZCIsCkBAIC0xODcyLDYgKzE4ODEsOCBAQCBkZWZhdWx0X3Jl bG9wdGlvbnMoRGF0dW0gcmVsb3B0aW9ucywgYm9vbCB2YWxpZGF0ZSwgcmVsb3B0X2tpbmQga2lu ZCkKIAkJeyJmaWxsZmFjdG9yIiwgUkVMT1BUX1RZUEVfSU5ULCBvZmZzZXRvZihTdGRSZE9wdGlv bnMsIGZpbGxmYWN0b3IpfSwKIAkJeyJhdXRvdmFjdXVtX2VuYWJsZWQiLCBSRUxPUFRfVFlQRV9C T09MLAogCQlvZmZzZXRvZihTdGRSZE9wdGlvbnMsIGF1dG92YWN1dW0pICsgb2Zmc2V0b2YoQXV0 b1ZhY09wdHMsIGVuYWJsZWQpfSwKKwkJeyJhdXRvdmFjdXVtX3BhcmFsbGVsX3dvcmtlcnMiLCBS RUxPUFRfVFlQRV9JTlQsCisJCW9mZnNldG9mKFN0ZFJkT3B0aW9ucywgYXV0b3ZhY3V1bSkgKyBv ZmZzZXRvZihBdXRvVmFjT3B0cywgYXV0b3ZhY3V1bV9wYXJhbGxlbF93b3JrZXJzKX0sCiAJCXsi YXV0b3ZhY3V1bV92YWN1dW1fdGhyZXNob2xkIiwgUkVMT1BUX1RZUEVfSU5ULAogCQlvZmZzZXRv ZihTdGRSZE9wdGlvbnMsIGF1dG92YWN1dW0pICsgb2Zmc2V0b2YoQXV0b1ZhY09wdHMsIHZhY3V1 bV90aHJlc2hvbGQpfSwKIAkJeyJhdXRvdmFjdXVtX3ZhY3V1bV9tYXhfdGhyZXNob2xkIiwgUkVM T1BUX1RZUEVfSU5ULApkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFy YWxsZWwuYyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMKaW5kZXggMGZl ZWExZDMwZWMuLjQyMjFlNjA4NGY1IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9jb21tYW5kcy92 YWN1dW1wYXJhbGxlbC5jCisrKyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVs LmMKQEAgLTEsNyArMSw5IEBACiAvKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KICAqCiAgKiB2YWN1dW1wYXJh bGxlbC5jCi0gKgkgIFN1cHBvcnQgcm91dGluZXMgZm9yIHBhcmFsbGVsIHZhY3V1bSBleGVjdXRp b24uCisgKgkgIFN1cHBvcnQgcm91dGluZXMgZm9yIHBhcmFsbGVsIHZhY3V1bSBhbmQgYXV0b3Zh Y3V1bSBleGVjdXRpb24uIEluIHRoZQorICoJICBmdXR1cmUgY29tbWVudHMsIHRoZSB3b3JkICJ2 YWN1dW0iIHdpbGwgcmVmZXIgdG8gYm90aCB2YWN1dW0gYW5kCisgKgkgIGF1dG92YWN1dW0uCiAg KgogICogVGhpcyBmaWxlIGNvbnRhaW5zIHJvdXRpbmVzIHRoYXQgYXJlIGludGVuZGVkIHRvIHN1 cHBvcnQgc2V0dGluZyB1cCwgdXNpbmcsCiAgKiBhbmQgdGVhcmluZyBkb3duIGEgUGFyYWxsZWxW YWN1dW1TdGF0ZS4KQEAgLTM0LDYgKzM2LDcgQEAKICNpbmNsdWRlICJleGVjdXRvci9pbnN0cnVt ZW50LmgiCiAjaW5jbHVkZSAib3B0aW1pemVyL3BhdGhzLmgiCiAjaW5jbHVkZSAicGdzdGF0Lmgi CisjaW5jbHVkZSAicG9zdG1hc3Rlci9hdXRvdmFjdXVtLmgiCiAjaW5jbHVkZSAic3RvcmFnZS9i dWZtZ3IuaCIKICNpbmNsdWRlICJ0Y29wL3Rjb3Bwcm90LmgiCiAjaW5jbHVkZSAidXRpbHMvbHN5 c2NhY2hlLmgiCkBAIC0yMjUsNiArMjI4LDggQEAgc3RhdGljIGludAlwYXJhbGxlbF92YWN1dW1f Y29tcHV0ZV93b3JrZXJzKFJlbGF0aW9uICppbmRyZWxzLCBpbnQgbmluZGV4ZXMsIGludAogCQkJ CQkJCQkJCQlib29sICp3aWxsX3BhcmFsbGVsX3ZhY3V1bSk7CiBzdGF0aWMgdm9pZCBwYXJhbGxl bF92YWN1dW1fcHJvY2Vzc19hbGxfaW5kZXhlcyhQYXJhbGxlbFZhY3V1bVN0YXRlICpwdnMsIGlu dCBudW1faW5kZXhfc2NhbnMsCiAJCQkJCQkJCQkJCQlib29sIHZhY3V1bSk7CitzdGF0aWMgdm9p ZCBwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19hbGxfaW5kZXhlc19pbnRlcm5hbChQYXJhbGxlbFZh Y3V1bVN0YXRlICpwdnMsCisJCQkJCQkJCQkJCQkJCSBpbnQgbnVtX2luZGV4X3NjYW5zLCBib29s IHZhY3V1bSk7CiBzdGF0aWMgdm9pZCBwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19zYWZlX2luZGV4 ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzKTsKIHN0YXRpYyB2b2lkIHBhcmFsbGVsX3ZhY3V1 bV9wcm9jZXNzX3Vuc2FmZV9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cyk7CiBzdGF0 aWMgdm9pZCBwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19vbmVfaW5kZXgoUGFyYWxsZWxWYWN1dW1T dGF0ZSAqcHZzLCBSZWxhdGlvbiBpbmRyZWwsCkBAIC0zNzMsOCArMzc4LDkgQEAgcGFyYWxsZWxf dmFjdXVtX2luaXQoUmVsYXRpb24gcmVsLCBSZWxhdGlvbiAqaW5kcmVscywgaW50IG5pbmRleGVz LAogCXNoYXJlZC0+cXVlcnlpZCA9IHBnc3RhdF9nZXRfbXlfcXVlcnlfaWQoKTsKIAlzaGFyZWQt Pm1haW50ZW5hbmNlX3dvcmtfbWVtX3dvcmtlciA9CiAJCShuaW5kZXhlc19td20gPiAwKSA/Ci0J CW1haW50ZW5hbmNlX3dvcmtfbWVtIC8gTWluKHBhcmFsbGVsX3dvcmtlcnMsIG5pbmRleGVzX213 bSkgOgotCQltYWludGVuYW5jZV93b3JrX21lbTsKKwkJdmFjX3dvcmtfbWVtIC8gTWluKHBhcmFs bGVsX3dvcmtlcnMsIG5pbmRleGVzX213bSkgOgorCQl2YWNfd29ya19tZW07CisKIAlzaGFyZWQt PmRlYWRfaXRlbXNfaW5mby5tYXhfYnl0ZXMgPSB2YWNfd29ya19tZW0gKiAoc2l6ZV90KSAxMDI0 OwogCiAJLyogUHJlcGFyZSBEU0Egc3BhY2UgZm9yIGRlYWQgaXRlbXMgKi8KQEAgLTU1MywxMiAr NTU5LDE3IEBAIHBhcmFsbGVsX3ZhY3V1bV9jb21wdXRlX3dvcmtlcnMoUmVsYXRpb24gKmluZHJl bHMsIGludCBuaW5kZXhlcywgaW50IG5yZXF1ZXN0ZWQsCiAJaW50CQkJbmluZGV4ZXNfcGFyYWxs ZWxfYnVsa2RlbCA9IDA7CiAJaW50CQkJbmluZGV4ZXNfcGFyYWxsZWxfY2xlYW51cCA9IDA7CiAJ aW50CQkJcGFyYWxsZWxfd29ya2VyczsKKwlpbnQJCQltYXhfd29ya2VyczsKKworCW1heF93b3Jr ZXJzID0gQW1BdXRvVmFjdXVtV29ya2VyUHJvY2VzcygpID8KKwkJYXV0b3ZhY3V1bV9tYXhfcGFy YWxsZWxfd29ya2VycyA6CisJCW1heF9wYXJhbGxlbF9tYWludGVuYW5jZV93b3JrZXJzOwogCiAJ LyoKIAkgKiBXZSBkb24ndCBhbGxvdyBwZXJmb3JtaW5nIHBhcmFsbGVsIG9wZXJhdGlvbiBpbiBz dGFuZGFsb25lIGJhY2tlbmQgb3IKIAkgKiB3aGVuIHBhcmFsbGVsaXNtIGlzIGRpc2FibGVkLgog CSAqLwotCWlmICghSXNVbmRlclBvc3RtYXN0ZXIgfHwgbWF4X3BhcmFsbGVsX21haW50ZW5hbmNl X3dvcmtlcnMgPT0gMCkKKwlpZiAoIUlzVW5kZXJQb3N0bWFzdGVyIHx8IG1heF93b3JrZXJzID09 IDApCiAJCXJldHVybiAwOwogCiAJLyoKQEAgLTU5Nyw4ICs2MDgsOCBAQCBwYXJhbGxlbF92YWN1 dW1fY29tcHV0ZV93b3JrZXJzKFJlbGF0aW9uICppbmRyZWxzLCBpbnQgbmluZGV4ZXMsIGludCBu cmVxdWVzdGVkLAogCXBhcmFsbGVsX3dvcmtlcnMgPSAobnJlcXVlc3RlZCA+IDApID8KIAkJTWlu KG5yZXF1ZXN0ZWQsIG5pbmRleGVzX3BhcmFsbGVsKSA6IG5pbmRleGVzX3BhcmFsbGVsOwogCi0J LyogQ2FwIGJ5IG1heF9wYXJhbGxlbF9tYWludGVuYW5jZV93b3JrZXJzICovCi0JcGFyYWxsZWxf d29ya2VycyA9IE1pbihwYXJhbGxlbF93b3JrZXJzLCBtYXhfcGFyYWxsZWxfbWFpbnRlbmFuY2Vf d29ya2Vycyk7CisJLyogQ2FwIGJ5IEdVQyB2YXJpYWJsZSAqLworCXBhcmFsbGVsX3dvcmtlcnMg PSBNaW4ocGFyYWxsZWxfd29ya2VycywgbWF4X3dvcmtlcnMpOwogCiAJcmV0dXJuIHBhcmFsbGVs X3dvcmtlcnM7CiB9CkBAIC02MTAsNiArNjIxLDMwIEBAIHBhcmFsbGVsX3ZhY3V1bV9jb21wdXRl X3dvcmtlcnMoUmVsYXRpb24gKmluZHJlbHMsIGludCBuaW5kZXhlcywgaW50IG5yZXF1ZXN0ZWQs CiBzdGF0aWMgdm9pZAogcGFyYWxsZWxfdmFjdXVtX3Byb2Nlc3NfYWxsX2luZGV4ZXMoUGFyYWxs ZWxWYWN1dW1TdGF0ZSAqcHZzLCBpbnQgbnVtX2luZGV4X3NjYW5zLAogCQkJCQkJCQkJYm9vbCB2 YWN1dW0pCit7CisJLyoKKwkgKiBQYXJhbGxlbCBhdXRvdmFjdXVtIGNhbiByZXNlcnZlIHBhcmFs bGVsIHdvcmtlcnMuIFVzZSB0cnkvY2F0Y2ggYmxvY2sKKwkgKiB0byBtYWtlIGVuc3VyZSB0aGF0 IGFsbCB3b3JrZXJzIGFyZSByZWxlYXNlZC4KKwkgKi8KKwlQR19UUlkoKTsKKwl7CisJCXBhcmFs bGVsX3ZhY3V1bV9wcm9jZXNzX2FsbF9pbmRleGVzX2ludGVybmFsKHB2cywgbnVtX2luZGV4X3Nj YW5zLAorCQkJCQkJCQkJCQkJCSBmYWxzZSk7CisJfQorCVBHX0NBVENIKCk7CisJeworCQkvKiBS ZWxlYXNlIGFsbCByZXNlcnZlZCBwYXJhbGxlbCB3b3JrZXJzLCBpZiBhbnkuICovCisJCWlmIChB bUF1dG9WYWN1dW1Xb3JrZXJQcm9jZXNzKCkpCisJCQlBdXRvVmFjdXVtUmVsZWFzZUFsbFBhcmFs bGVsV29ya2VycygpOworCisJCVBHX1JFX1RIUk9XKCk7CisJfQorCVBHX0VORF9UUlkoKTsKK30K Kworc3RhdGljIHZvaWQKK3BhcmFsbGVsX3ZhY3V1bV9wcm9jZXNzX2FsbF9pbmRleGVzX2ludGVy bmFsKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywKKwkJCQkJCQkJCQkJIGludCBudW1faW5kZXhf c2NhbnMsIGJvb2wgdmFjdXVtKQogewogCWludAkJCW53b3JrZXJzOwogCVBWSW5kVmFjU3RhdHVz IG5ld19zdGF0dXM7CkBAIC02NDYsNiArNjgxLDEzIEBAIHBhcmFsbGVsX3ZhY3V1bV9wcm9jZXNz X2FsbF9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywgaW50IG51bV9pbmRleF9zY2Fu CiAJICovCiAJbndvcmtlcnMgPSBNaW4obndvcmtlcnMsIHB2cy0+cGN4dC0+bndvcmtlcnMpOwog CisJLyoKKwkgKiBSZXNlcnZlIHdvcmtlcnMgaW4gYXV0b3ZhY3V1bSBnbG9iYWwgc3RhdGUuIE5v dGUsIHRoYXQgd2UgbWF5IGJlIGdpdmVuCisJICogZmV3ZXIgd29ya2VycyB0aGFuIHdlIHJlcXVl c3RlZC4KKwkgKi8KKwlpZiAoQW1BdXRvVmFjdXVtV29ya2VyUHJvY2VzcygpICYmIG53b3JrZXJz ID4gMCkKKwkJbndvcmtlcnMgPSBBdXRvVmFjdXVtUmVzZXJ2ZVBhcmFsbGVsV29ya2Vycyhud29y a2Vycyk7CisKIAkvKgogCSAqIFNldCBpbmRleCB2YWN1dW0gc3RhdHVzIGFuZCBtYXJrIHdoZXRo ZXIgcGFyYWxsZWwgdmFjdXVtIHdvcmtlciBjYW4KIAkgKiBwcm9jZXNzIGl0LgpAQCAtNjkwLDYg KzczMiwxNiBAQCBwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19hbGxfaW5kZXhlcyhQYXJhbGxlbFZh Y3V1bVN0YXRlICpwdnMsIGludCBudW1faW5kZXhfc2NhbgogCiAJCUxhdW5jaFBhcmFsbGVsV29y a2VycyhwdnMtPnBjeHQpOwogCisJCWlmIChBbUF1dG9WYWN1dW1Xb3JrZXJQcm9jZXNzKCkgJiYK KwkJCXB2cy0+cGN4dC0+bndvcmtlcnNfbGF1bmNoZWQgPCBud29ya2VycykKKwkJeworCQkJLyoK KwkJCSAqIFRlbGwgYXV0b3ZhY3V1bSB0aGF0IHdlIGNvdWxkIG5vdCBsYXVuY2ggYWxsIHRoZSBw cmV2aW91c2x5CisJCQkgKiByZXNlcnZlZCB3b3JrZXJzLgorCQkJICovCisJCQlBdXRvVmFjdXVt UmVsZWFzZVBhcmFsbGVsV29ya2Vycyhud29ya2VycyAtIHB2cy0+cGN4dC0+bndvcmtlcnNfbGF1 bmNoZWQpOworCQl9CisKIAkJaWYgKHB2cy0+cGN4dC0+bndvcmtlcnNfbGF1bmNoZWQgPiAwKQog CQl7CiAJCQkvKgpAQCAtNzM4LDYgKzc5MCwxMCBAQCBwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19h bGxfaW5kZXhlcyhQYXJhbGxlbFZhY3V1bVN0YXRlICpwdnMsIGludCBudW1faW5kZXhfc2Nhbgog CiAJCWZvciAoaW50IGkgPSAwOyBpIDwgcHZzLT5wY3h0LT5ud29ya2Vyc19sYXVuY2hlZDsgaSsr KQogCQkJSW5zdHJBY2N1bVBhcmFsbGVsUXVlcnkoJnB2cy0+YnVmZmVyX3VzYWdlW2ldLCAmcHZz LT53YWxfdXNhZ2VbaV0pOworCisJCS8qIEFsc28gcmVsZWFzZSBhbGwgcHJldmlvdXNseSByZXNl cnZlZCBwYXJhbGxlbCBhdXRvdmFjdXVtIHdvcmtlcnMgKi8KKwkJaWYgKEFtQXV0b1ZhY3V1bVdv cmtlclByb2Nlc3MoKSAmJiBwdnMtPnBjeHQtPm53b3JrZXJzX2xhdW5jaGVkID4gMCkKKwkJCUF1 dG9WYWN1dW1SZWxlYXNlUGFyYWxsZWxXb3JrZXJzKHB2cy0+cGN4dC0+bndvcmtlcnNfbGF1bmNo ZWQpOwogCX0KIAogCS8qCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92 YWN1dW0uYyBiL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCmluZGV4IGZmOTZi MzZkNzEwLi43OGNlYWM2NzMxOSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9h dXRvdmFjdXVtLmMKKysrIGIvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMKQEAg LTE1MSw2ICsxNTEsMTIgQEAgaW50CQkJTG9nX2F1dG92YWN1dW1fbWluX2R1cmF0aW9uID0gNjAw MDAwOwogc3RhdGljIGRvdWJsZSBhdl9zdG9yYWdlX3BhcmFtX2Nvc3RfZGVsYXkgPSAtMTsKIHN0 YXRpYyBpbnQJYXZfc3RvcmFnZV9wYXJhbV9jb3N0X2xpbWl0ID0gLTE7CiAKKy8qCisgKiBWYXJp YWJsZSB0byBrZWVwIG51bWJlciBvZiBjdXJyZW50bHkgcmVzZXJ2ZWQgcGFyYWxsZWwgYXV0b3Zh Y3V1bSB3b3JrZXJzLgorICogSXQgaXMgb25seSByZWxldmFudCBmb3IgcGFyYWxsZWwgYXV0b3Zh Y3V1bSBsZWFkZXIgcHJvY2Vzcy4KKyAqLworc3RhdGljIGludCBhdl9ud29ya2Vyc19yZXNlcnZl ZCA9IDA7CisKIC8qIEZsYWdzIHNldCBieSBzaWduYWwgaGFuZGxlcnMgKi8KIHN0YXRpYyB2b2xh dGlsZSBzaWdfYXRvbWljX3QgZ290X1NJR1VTUjIgPSBmYWxzZTsKIApAQCAtMjg1LDYgKzI5MSw4 IEBAIHR5cGVkZWYgc3RydWN0IEF1dG9WYWN1dW1Xb3JrSXRlbQogICogYXZfd29ya0l0ZW1zCQl3 b3JrIGl0ZW0gYXJyYXkKICAqIGF2X253b3JrZXJzRm9yQmFsYW5jZSB0aGUgbnVtYmVyIG9mIGF1 dG92YWN1dW0gd29ya2VycyB0byB1c2Ugd2hlbgogICogCQkJCQljYWxjdWxhdGluZyB0aGUgcGVy IHdvcmtlciBjb3N0IGxpbWl0CisgKiBhdl9mcmVlUGFyYWxsZWxXb3JrZXJzIHRoZSBudW1iZXIg b2YgZnJlZSBwYXJhbGxlbCBhdXRvdmFjdXVtIHdvcmtlcnMKKyAqIGF2X21heFBhcmFsbGVsV29y a2VycyB0aGUgbWF4aW11bSBudW1iZXIgb2YgcGFyYWxsZWwgYXV0b3ZhY3V1bSB3b3JrZXJzCiAg KgogICogVGhpcyBzdHJ1Y3QgaXMgcHJvdGVjdGVkIGJ5IEF1dG92YWN1dW1Mb2NrLCBleGNlcHQg Zm9yIGF2X3NpZ25hbCBhbmQgcGFydHMKICAqIG9mIHRoZSB3b3JrZXIgbGlzdCAoc2VlIGFib3Zl KS4KQEAgLTI5OSw2ICszMDcsOCBAQCB0eXBlZGVmIHN0cnVjdAogCVdvcmtlckluZm8JYXZfc3Rh cnRpbmdXb3JrZXI7CiAJQXV0b1ZhY3V1bVdvcmtJdGVtIGF2X3dvcmtJdGVtc1tOVU1fV09SS0lU RU1TXTsKIAlwZ19hdG9taWNfdWludDMyIGF2X253b3JrZXJzRm9yQmFsYW5jZTsKKwl1aW50MzIJ CWF2X2ZyZWVQYXJhbGxlbFdvcmtlcnM7CisJdWludDMyCQlhdl9tYXhQYXJhbGxlbFdvcmtlcnM7 CiB9IEF1dG9WYWN1dW1TaG1lbVN0cnVjdDsKIAogc3RhdGljIEF1dG9WYWN1dW1TaG1lbVN0cnVj dCAqQXV0b1ZhY3V1bVNobWVtOwpAQCAtMzY0LDYgKzM3NCw3IEBAIHN0YXRpYyB2b2lkIGF1dG92 YWNfcmVwb3J0X3dvcmtpdGVtKEF1dG9WYWN1dW1Xb3JrSXRlbSAqd29ya2l0ZW0sCiBzdGF0aWMg dm9pZCBhdmxfc2lndXNyMl9oYW5kbGVyKFNJR05BTF9BUkdTKTsKIHN0YXRpYyBib29sIGF2X3dv cmtlcl9hdmFpbGFibGUodm9pZCk7CiBzdGF0aWMgdm9pZCBjaGVja19hdl93b3JrZXJfZ3Vjcyh2 b2lkKTsKK3N0YXRpYyB2b2lkIGFkanVzdF9mcmVlX3BhcmFsbGVsX3dvcmtlcnMoaW50IHByZXZf bWF4X3BhcmFsbGVsX3dvcmtlcnMpOwogCiAKIApAQCAtNzYzLDYgKzc3NCw4IEBAIFByb2Nlc3NB dXRvVmFjTGF1bmNoZXJJbnRlcnJ1cHRzKHZvaWQpCiAJaWYgKENvbmZpZ1JlbG9hZFBlbmRpbmcp CiAJewogCQlpbnQJCQlhdXRvdmFjdXVtX21heF93b3JrZXJzX3ByZXYgPSBhdXRvdmFjdXVtX21h eF93b3JrZXJzOworCQlpbnQJCQlhdXRvdmFjdXVtX21heF9wYXJhbGxlbF93b3JrZXJzX3ByZXYg PQorCQkJYXV0b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2VyczsKIAogCQlDb25maWdSZWxvYWRQ ZW5kaW5nID0gZmFsc2U7CiAJCVByb2Nlc3NDb25maWdGaWxlKFBHQ19TSUdIVVApOwpAQCAtNzc5 LDYgKzc5MiwxNSBAQCBQcm9jZXNzQXV0b1ZhY0xhdW5jaGVySW50ZXJydXB0cyh2b2lkKQogCQlp ZiAoYXV0b3ZhY3V1bV9tYXhfd29ya2Vyc19wcmV2ICE9IGF1dG92YWN1dW1fbWF4X3dvcmtlcnMp CiAJCQljaGVja19hdl93b3JrZXJfZ3VjcygpOwogCisJCS8qCisJCSAqIElmIGF1dG92YWN1dW1f bWF4X3BhcmFsbGVsX3dvcmtlcnMgY2hhbmdlZCwgd2UgbXVzdCB0YWtlIGNhcmUgb2YKKwkJICog dGhlIGNvcnJlY3QgdmFsdWUgb2YgYXZhaWxhYmxlIHBhcmFsbGVsIGF1dG92YWN1dW0gd29ya2Vy cyBpbgorCQkgKiBzaG1lbS4KKwkJICovCisJCWlmIChhdXRvdmFjdXVtX21heF9wYXJhbGxlbF93 b3JrZXJzX3ByZXYgIT0KKwkJCWF1dG92YWN1dW1fbWF4X3BhcmFsbGVsX3dvcmtlcnMpCisJCQlh ZGp1c3RfZnJlZV9wYXJhbGxlbF93b3JrZXJzKGF1dG92YWN1dW1fbWF4X3BhcmFsbGVsX3dvcmtl cnNfcHJldik7CisKIAkJLyogcmVidWlsZCB0aGUgbGlzdCBpbiBjYXNlIHRoZSBuYXB0aW1lIGNo YW5nZWQgKi8KIAkJcmVidWlsZF9kYXRhYmFzZV9saXN0KEludmFsaWRPaWQpOwogCX0KQEAgLTI4 NzEsOCArMjg5MywxMiBAQCB0YWJsZV9yZWNoZWNrX2F1dG92YWMoT2lkIHJlbGlkLCBIVEFCICp0 YWJsZV90b2FzdF9tYXAsCiAJCSAqLwogCQl0YWItPmF0X3BhcmFtcy5pbmRleF9jbGVhbnVwID0g VkFDT1BUVkFMVUVfVU5TUEVDSUZJRUQ7CiAJCXRhYi0+YXRfcGFyYW1zLnRydW5jYXRlID0gVkFD T1BUVkFMVUVfVU5TUEVDSUZJRUQ7Ci0JCS8qIEFzIG9mIG5vdywgd2UgZG9uJ3Qgc3VwcG9ydCBw YXJhbGxlbCB2YWN1dW0gZm9yIGF1dG92YWN1dW0gKi8KLQkJdGFiLT5hdF9wYXJhbXMubndvcmtl cnMgPSAtMTsKKworCQkvKiBEZWNpZGUgd2hldGhlciB3ZSBuZWVkIHRvIHByb2Nlc3MgaW5kZXhl cyBvZiB0YWJsZSBpbiBwYXJhbGxlbC4gKi8KKwkJdGFiLT5hdF9wYXJhbXMubndvcmtlcnMgPSBh dm9wdHMKKwkJCT8gYXZvcHRzLT5hdXRvdmFjdXVtX3BhcmFsbGVsX3dvcmtlcnMKKwkJCTogLTE7 CisKIAkJdGFiLT5hdF9wYXJhbXMuZnJlZXplX21pbl9hZ2UgPSBmcmVlemVfbWluX2FnZTsKIAkJ dGFiLT5hdF9wYXJhbXMuZnJlZXplX3RhYmxlX2FnZSA9IGZyZWV6ZV90YWJsZV9hZ2U7CiAJCXRh Yi0+YXRfcGFyYW1zLm11bHRpeGFjdF9mcmVlemVfbWluX2FnZSA9IG11bHRpeGFjdF9mcmVlemVf bWluX2FnZTsKQEAgLTMzNTMsNiArMzM3OSw4NSBAQCBBdXRvVmFjdXVtUmVxdWVzdFdvcmsoQXV0 b1ZhY3V1bVdvcmtJdGVtVHlwZSB0eXBlLCBPaWQgcmVsYXRpb25JZCwKIAlyZXR1cm4gcmVzdWx0 OwogfQogCisvKgorICogSW4gb3JkZXIgdG8gbWVldCB0aGUgJ2F1dG92YWN1dW1fbWF4X3BhcmFs bGVsX3dvcmtlcnMnIGxpbWl0LCBsZWFkZXIKKyAqIGF1dG92YWN1dW0gcHJvY2VzcyBtdXN0IGNh bGwgdGhpcyBmdW5jdGlvbi4gSXQgcmV0dXJucyB0aGUgbnVtYmVyIG9mCisgKiBwYXJhbGxlbCB3 b3JrZXJzIHRoYXQgYWN0dWFsbHkgY2FuIGJlIGxhdW5jaGVkIGFuZCByZXNlcnZlcyB0aGVzZSB3 b3JrZXJzCisgKiAoaWYgYW55KSBpbiBnbG9iYWwgYXV0b3ZhY3V1bSBzdGF0ZS4KKyAqCisgKiBO T1RFOiBXZSB3aWxsIHRyeSB0byBwcm92aWRlIGFzIG1hbnkgd29ya2VycyBhcyByZXF1ZXN0ZWQs IGV2ZW4gaWYgY2FsbGVyCisgKiB3aWxsIG9jY3VweSBhbGwgYXZhaWxhYmxlIHdvcmtlcnMuCisg Ki8KK2ludAorQXV0b1ZhY3V1bVJlc2VydmVQYXJhbGxlbFdvcmtlcnMoaW50IG53b3JrZXJzKQor eworCWludAkJCW5yZXNlcnZlZDsKKworCS8qIE9ubHkgbGVhZGVyIHdvcmtlciBjYW4gY2FsbCB0 aGlzIGZ1bmN0aW9uLiAqLworCUFzc2VydChBbUF1dG9WYWN1dW1Xb3JrZXJQcm9jZXNzKCkgJiYg IUlzUGFyYWxsZWxXb3JrZXIoKSk7CisKKwkvKgorCSAqIFdlIGNhbiBvbmx5IHJlc2VydmUgd29y a2VycyBhdCB0aGUgYmVnaW5uaW5nIG9mIHBhcmFsbGVsIGluZGV4CisJICogcHJvY2Vzc2luZywg c28gd2UgbXVzdCBub3QgaGF2ZSBhbnkgcmVzZXJ2ZWQgd29ya2VycyByaWdodCBub3cuCisJICov CisJQXNzZXJ0KGF2X253b3JrZXJzX3Jlc2VydmVkID09IDApOworCisJTFdMb2NrQWNxdWlyZShB dXRvdmFjdXVtTG9jaywgTFdfRVhDTFVTSVZFKTsKKworCS8qIFByb3ZpZGUgYXMgbWFueSB3b3Jr ZXJzIGFzIHdlIGNhbi4gKi8KKwlucmVzZXJ2ZWQgPSBNaW4oQXV0b1ZhY3V1bVNobWVtLT5hdl9m cmVlUGFyYWxsZWxXb3JrZXJzLCBud29ya2Vycyk7CisJQXV0b1ZhY3V1bVNobWVtLT5hdl9mcmVl UGFyYWxsZWxXb3JrZXJzIC09IG53b3JrZXJzOworCisJLyogUmVtZW1iZXIgaG93IG1hbnkgd29y a2VycyB3ZSBoYXZlIHJlc2VydmVkLiAqLworCWF2X253b3JrZXJzX3Jlc2VydmVkICs9IG53b3Jr ZXJzOworCisJTFdMb2NrUmVsZWFzZShBdXRvdmFjdXVtTG9jayk7CisJcmV0dXJuIG5yZXNlcnZl ZDsKK30KKworLyoKKyAqIExlYWRlciBhdXRvdmFjdXVtIHByb2Nlc3MgbXVzdCBjYWxsIHRoaXMg ZnVuY3Rpb24gaW4gb3JkZXIgdG8gdXBkYXRlIGdsb2JhbAorICogYXV0b3ZhY3V1bSBzdGF0ZSwg c28gb3RoZXIgbGVhZGVycyB3aWxsIGJlIGFibGUgdG8gdXNlIHRoZXNlIHBhcmFsbGVsCisgKiB3 b3JrZXJzLgorICoKKyAqICdud29ya2VycycgLSBob3cgbWFueSB3b3JrZXJzIGNhbGxlciB3YW50 cyB0byByZWxlYXNlLgorICovCit2b2lkCitBdXRvVmFjdXVtUmVsZWFzZVBhcmFsbGVsV29ya2Vy cyhpbnQgbndvcmtlcnMpCit7CisJLyogT25seSBsZWFkZXIgd29ya2VyIGNhbiBjYWxsIHRoaXMg ZnVuY3Rpb24uICovCisJQXNzZXJ0KEFtQXV0b1ZhY3V1bVdvcmtlclByb2Nlc3MoKSAmJiAhSXNQ YXJhbGxlbFdvcmtlcigpKTsKKworCUxXTG9ja0FjcXVpcmUoQXV0b3ZhY3V1bUxvY2ssIExXX0VY Q0xVU0lWRSk7CisKKwkvKgorCSAqIElmIHRoZSBtYXhpbXVtIG51bWJlciBvZiBwYXJhbGxlbCB3 b3JrZXJzIHdhcyByZWR1Y2VkIGR1cmluZyBleGVjdXRpb24sCisJICogd2UgbXVzdCBjYXAgYXZh aWxhYmxlIHdvcmtlcnMgbnVtYmVyIGJ5IGl0cyBuZXcgdmFsdWUuCisJICovCisJQXV0b1ZhY3V1 bVNobWVtLT5hdl9mcmVlUGFyYWxsZWxXb3JrZXJzID0KKwkJTWluKEF1dG9WYWN1dW1TaG1lbS0+ YXZfZnJlZVBhcmFsbGVsV29ya2VycyArIG53b3JrZXJzLAorCQkJQXV0b1ZhY3V1bVNobWVtLT5h dl9tYXhQYXJhbGxlbFdvcmtlcnMpOworCisJLyogRG9uJ3QgaGF2ZSB0byByZW1lbWJlciB0aGVz ZSB3b3JrZXJzIGFueW1vcmUuICovCisJYXZfbndvcmtlcnNfcmVzZXJ2ZWQgLT0gbndvcmtlcnM7 CisKKwlMV0xvY2tSZWxlYXNlKEF1dG92YWN1dW1Mb2NrKTsKK30KKworLyoKKyAqIFNhbWUgYXMg YWJvdmUsIGJ1dCByZWxlYXNlICphbGwqIHBhcmFsbGVsIHdvcmtlcnMsIHRoYXQgd2VyZSByZXNl cnZlZCBieQorICogY3VycmVudCBsZWFkZXIgYXV0b3ZhY3V1bSBwcm9jZXNzLgorICovCit2b2lk CitBdXRvVmFjdXVtUmVsZWFzZUFsbFBhcmFsbGVsV29ya2Vycyh2b2lkKQoreworCS8qIE9ubHkg bGVhZGVyIHdvcmtlciBjYW4gY2FsbCB0aGlzIGZ1bmN0aW9uLiAqLworCUFzc2VydChBbUF1dG9W YWN1dW1Xb3JrZXJQcm9jZXNzKCkgJiYgIUlzUGFyYWxsZWxXb3JrZXIoKSk7CisKKwlpZiAoYXZf bndvcmtlcnNfcmVzZXJ2ZWQgPiAwKQorCQlBdXRvVmFjdXVtUmVsZWFzZVBhcmFsbGVsV29ya2Vy cyhhdl9ud29ya2Vyc19yZXNlcnZlZCk7Cit9CisKIC8qCiAgKiBhdXRvdmFjX2luaXQKICAqCQlU aGlzIGlzIGNhbGxlZCBhdCBwb3N0bWFzdGVyIGluaXRpYWxpemF0aW9uLgpAQCAtMzQxMyw2ICsz NTE4LDEwIEBAIEF1dG9WYWN1dW1TaG1lbUluaXQodm9pZCkKIAkJQXNzZXJ0KCFmb3VuZCk7CiAK IAkJQXV0b1ZhY3V1bVNobWVtLT5hdl9sYXVuY2hlcnBpZCA9IDA7CisJCUF1dG9WYWN1dW1TaG1l bS0+YXZfbWF4UGFyYWxsZWxXb3JrZXJzID0KKwkJCU1pbihhdXRvdmFjdXVtX21heF9wYXJhbGxl bF93b3JrZXJzLCBtYXhfd29ya2VyX3Byb2Nlc3Nlcyk7CisJCUF1dG9WYWN1dW1TaG1lbS0+YXZf ZnJlZVBhcmFsbGVsV29ya2VycyA9CisJCQlBdXRvVmFjdXVtU2htZW0tPmF2X21heFBhcmFsbGVs V29ya2VyczsKIAkJZGNsaXN0X2luaXQoJkF1dG9WYWN1dW1TaG1lbS0+YXZfZnJlZVdvcmtlcnMp OwogCQlkbGlzdF9pbml0KCZBdXRvVmFjdXVtU2htZW0tPmF2X3J1bm5pbmdXb3JrZXJzKTsKIAkJ QXV0b1ZhY3V1bVNobWVtLT5hdl9zdGFydGluZ1dvcmtlciA9IE5VTEw7CkBAIC0zNDk0LDMgKzM2 MDMsMzQgQEAgY2hlY2tfYXZfd29ya2VyX2d1Y3Modm9pZCkKIAkJCQkgZXJyZGV0YWlsKCJUaGUg c2VydmVyIHdpbGwgb25seSBzdGFydCB1cCB0byBcImF1dG92YWN1dW1fd29ya2VyX3Nsb3RzXCIg KCVkKSBhdXRvdmFjdXVtIHdvcmtlcnMgYXQgYSBnaXZlbiB0aW1lLiIsCiAJCQkJCQkgICBhdXRv dmFjdXVtX3dvcmtlcl9zbG90cykpKTsKIH0KKworLyoKKyAqIE1ha2Ugc3VyZSB0aGF0IG51bWJl ciBvZiBmcmVlIHBhcmFsbGVsIHdvcmtlcnMgY29ycmVzcG9uZHMgdG8gdGhlCisgKiBhdXRvdmFj dXVtX21heF9wYXJhbGxlbF93b3JrZXJzIHBhcmFtZXRlciAoYWZ0ZXIgaXQgd2FzIGNoYW5nZWQp LgorICovCitzdGF0aWMgdm9pZAorYWRqdXN0X2ZyZWVfcGFyYWxsZWxfd29ya2VycyhpbnQgcHJl dl9tYXhfcGFyYWxsZWxfd29ya2VycykKK3sKKwlMV0xvY2tBY3F1aXJlKEF1dG92YWN1dW1Mb2Nr LCBMV19FWENMVVNJVkUpOworCisJLyoKKwkgKiBDYXAgdGhlIG51bWJlciBvZiBmcmVlIHdvcmtl cnMgYnkgbmV3IHBhcmFtZXRlcidzIHZhbHVlLCBpZiBuZWVkZWQuCisJICovCisJQXV0b1ZhY3V1 bVNobWVtLT5hdl9mcmVlUGFyYWxsZWxXb3JrZXJzID0KKwkJTWluKEF1dG9WYWN1dW1TaG1lbS0+ YXZfZnJlZVBhcmFsbGVsV29ya2VycywKKwkJCWF1dG92YWN1dW1fbWF4X3BhcmFsbGVsX3dvcmtl cnMpOworCisJaWYgKGF1dG92YWN1dW1fbWF4X3BhcmFsbGVsX3dvcmtlcnMgPiBwcmV2X21heF9w YXJhbGxlbF93b3JrZXJzKQorCXsKKwkJLyoKKwkJICogSWYgdXNlciB3YW50cyB0byBpbmNyZWFz ZSBudW1iZXIgb2YgcGFyYWxsZWwgYXV0b3ZhY3V1bSB3b3JrZXJzLCB3ZQorCQkgKiBtdXN0IGlu Y3JlYXNlIG51bWJlciBvZiBmcmVlIHdvcmtlcnMuCisJCSAqLworCQlBdXRvVmFjdXVtU2htZW0t PmF2X2ZyZWVQYXJhbGxlbFdvcmtlcnMgKz0KKwkJCShhdXRvdmFjdXVtX21heF9wYXJhbGxlbF93 b3JrZXJzIC0gcHJldl9tYXhfcGFyYWxsZWxfd29ya2Vycyk7CisJfQorCisJQXV0b1ZhY3V1bVNo bWVtLT5hdl9tYXhQYXJhbGxlbFdvcmtlcnMgPSBhdXRvdmFjdXVtX21heF9wYXJhbGxlbF93b3Jr ZXJzOworCisJTFdMb2NrUmVsZWFzZShBdXRvdmFjdXVtTG9jayk7Cit9CmRpZmYgLS1naXQgYS9z cmMvYmFja2VuZC91dGlscy9pbml0L2dsb2JhbHMuYyBiL3NyYy9iYWNrZW5kL3V0aWxzL2luaXQv Z2xvYmFscy5jCmluZGV4IGQzMWNiNDVhMDU4Li5mZDAwZDZmODlkYyAxMDA2NDQKLS0tIGEvc3Jj L2JhY2tlbmQvdXRpbHMvaW5pdC9nbG9iYWxzLmMKKysrIGIvc3JjL2JhY2tlbmQvdXRpbHMvaW5p dC9nbG9iYWxzLmMKQEAgLTE0Myw2ICsxNDMsNyBAQCBpbnQJCQlOQnVmZmVycyA9IDE2Mzg0Owog aW50CQkJTWF4Q29ubmVjdGlvbnMgPSAxMDA7CiBpbnQJCQltYXhfd29ya2VyX3Byb2Nlc3NlcyA9 IDg7CiBpbnQJCQltYXhfcGFyYWxsZWxfd29ya2VycyA9IDg7CitpbnQJCQlhdXRvdmFjdXVtX21h eF9wYXJhbGxlbF93b3JrZXJzID0gMDsKIGludAkJCU1heEJhY2tlbmRzID0gMDsKIAogLyogR1VD IHBhcmFtZXRlcnMgZm9yIHZhY3V1bSAqLwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvdXRpbHMv bWlzYy9ndWNfdGFibGVzLmMgYi9zcmMvYmFja2VuZC91dGlscy9taXNjL2d1Y190YWJsZXMuYwpp bmRleCBkMTRiMTY3OGU3Zi4uOWVjYjE0MjI3ZTUgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3V0 aWxzL21pc2MvZ3VjX3RhYmxlcy5jCisrKyBiL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvZ3VjX3Rh Ymxlcy5jCkBAIC0zNjA0LDYgKzM2MDQsMTYgQEAgc3RydWN0IGNvbmZpZ19pbnQgQ29uZmlndXJl TmFtZXNJbnRbXSA9CiAJCU5VTEwsIE5VTEwsIE5VTEwKIAl9LAogCisJeworCQl7ImF1dG92YWN1 dW1fbWF4X3BhcmFsbGVsX3dvcmtlcnMiLCBQR0NfU0lHSFVQLCBWQUNVVU1fQVVUT1ZBQ1VVTSwK KwkJCWdldHRleHRfbm9vcCgiTWF4aW11bSBudW1iZXIgb2YgcGFyYWxsZWwgYXV0b3ZhY3V1bSB3 b3JrZXJzLCB0aGF0IGNhbiBiZSB0YWtlbiBmcm9tIGJnd29ya2VycyBwb29sLiIpLAorCQkJZ2V0 dGV4dF9ub29wKCJUaGlzIHBhcmFtZXRlciBpcyBjYXBwZWQgYnkgXCJtYXhfd29ya2VyX3Byb2Nl c3Nlc1wiIChub3QgYnkgXCJhdXRvdmFjdXVtX21heF93b3JrZXJzXCIhKS4iKSwKKwkJfSwKKwkJ JmF1dG92YWN1dW1fbWF4X3BhcmFsbGVsX3dvcmtlcnMsCisJCTAsIDAsIE1BWF9CQUNLRU5EUywK KwkJTlVMTCwgTlVMTCwgTlVMTAorCX0sCisKIAl7CiAJCXsibWF4X3BhcmFsbGVsX21haW50ZW5h bmNlX3dvcmtlcnMiLCBQR0NfVVNFUlNFVCwgUkVTT1VSQ0VTX1dPUktFUl9QUk9DRVNTRVMsCiAJ CQlnZXR0ZXh0X25vb3AoIlNldHMgdGhlIG1heGltdW0gbnVtYmVyIG9mIHBhcmFsbGVsIHByb2Nl c3NlcyBwZXIgbWFpbnRlbmFuY2Ugb3BlcmF0aW9uLiIpLApkaWZmIC0tZ2l0IGEvc3JjL2JhY2tl bmQvdXRpbHMvbWlzYy9wb3N0Z3Jlc3FsLmNvbmYuc2FtcGxlIGIvc3JjL2JhY2tlbmQvdXRpbHMv bWlzYy9wb3N0Z3Jlc3FsLmNvbmYuc2FtcGxlCmluZGV4IGE5ZDgyOTM0NzRhLi5iYmY1MzA3MDAw ZiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9wb3N0Z3Jlc3FsLmNvbmYuc2Ft cGxlCisrKyBiL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvcG9zdGdyZXNxbC5jb25mLnNhbXBsZQpA QCAtNjgzLDYgKzY4Myw3IEBACiBhdXRvdmFjdXVtX3dvcmtlcl9zbG90cyA9IDE2CSMgYXV0b3Zh Y3V1bSB3b3JrZXIgc2xvdHMgdG8gYWxsb2NhdGUKIAkJCQkJIyAoY2hhbmdlIHJlcXVpcmVzIHJl c3RhcnQpCiAjYXV0b3ZhY3V1bV9tYXhfd29ya2VycyA9IDMJCSMgbWF4IG51bWJlciBvZiBhdXRv dmFjdXVtIHN1YnByb2Nlc3NlcworI2F1dG92YWN1dW1fbWF4X3BhcmFsbGVsX3dvcmtlcnMgPSAw CSMgZGlzYWJsZWQgYnkgZGVmYXVsdCBhbmQgbGltaXRlZCBieSBtYXhfd29ya2VyX3Byb2Nlc3Nl cwogI2F1dG92YWN1dW1fbmFwdGltZSA9IDFtaW4JCSMgdGltZSBiZXR3ZWVuIGF1dG92YWN1dW0g cnVucwogI2F1dG92YWN1dW1fdmFjdXVtX3RocmVzaG9sZCA9IDUwCSMgbWluIG51bWJlciBvZiBy b3cgdXBkYXRlcyBiZWZvcmUKIAkJCQkJIyB2YWN1dW0KZGlmZiAtLWdpdCBhL3NyYy9iaW4vcHNx bC90YWItY29tcGxldGUuaW4uYyBiL3NyYy9iaW4vcHNxbC90YWItY29tcGxldGUuaW4uYwppbmRl eCA4YjEwZjIzMTNmMy4uMjkwZGQ1Y2I4ZWMgMTAwNjQ0Ci0tLSBhL3NyYy9iaW4vcHNxbC90YWIt Y29tcGxldGUuaW4uYworKysgYi9zcmMvYmluL3BzcWwvdGFiLWNvbXBsZXRlLmluLmMKQEAgLTE0 MDIsNiArMTQwMiw3IEBAIHN0YXRpYyBjb25zdCBjaGFyICpjb25zdCB0YWJsZV9zdG9yYWdlX3Bh cmFtZXRlcnNbXSA9IHsKIAkiYXV0b3ZhY3V1bV9tdWx0aXhhY3RfZnJlZXplX21heF9hZ2UiLAog CSJhdXRvdmFjdXVtX211bHRpeGFjdF9mcmVlemVfbWluX2FnZSIsCiAJImF1dG92YWN1dW1fbXVs dGl4YWN0X2ZyZWV6ZV90YWJsZV9hZ2UiLAorCSJhdXRvdmFjdXVtX3BhcmFsbGVsX3dvcmtlcnMi LAogCSJhdXRvdmFjdXVtX3ZhY3V1bV9jb3N0X2RlbGF5IiwKIAkiYXV0b3ZhY3V1bV92YWN1dW1f Y29zdF9saW1pdCIsCiAJImF1dG92YWN1dW1fdmFjdXVtX2luc2VydF9zY2FsZV9mYWN0b3IiLApk aWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvbWlzY2FkbWluLmggYi9zcmMvaW5jbHVkZS9taXNjYWRt aW4uaAppbmRleCAxYmVmOTg0NzFjMy4uODU5MjY0MTU2NTcgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNs dWRlL21pc2NhZG1pbi5oCisrKyBiL3NyYy9pbmNsdWRlL21pc2NhZG1pbi5oCkBAIC0xNzcsNiAr MTc3LDcgQEAgZXh0ZXJuIFBHRExMSU1QT1JUIGludCBNYXhCYWNrZW5kczsKIGV4dGVybiBQR0RM TElNUE9SVCBpbnQgTWF4Q29ubmVjdGlvbnM7CiBleHRlcm4gUEdETExJTVBPUlQgaW50IG1heF93 b3JrZXJfcHJvY2Vzc2VzOwogZXh0ZXJuIFBHRExMSU1QT1JUIGludCBtYXhfcGFyYWxsZWxfd29y a2VyczsKK2V4dGVybiBQR0RMTElNUE9SVCBpbnQgYXV0b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29y a2VyczsKIAogZXh0ZXJuIFBHRExMSU1QT1JUIGludCBjb21taXRfdGltZXN0YW1wX2J1ZmZlcnM7 CiBleHRlcm4gUEdETExJTVBPUlQgaW50IG11bHRpeGFjdF9tZW1iZXJfYnVmZmVyczsKZGlmZiAt LWdpdCBhL3NyYy9pbmNsdWRlL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5oIGIvc3JjL2luY2x1ZGUv cG9zdG1hc3Rlci9hdXRvdmFjdXVtLmgKaW5kZXggZTgxMzVmNDFhMWMuLjkwNGM1Y2UzN2Q4IDEw MDY0NAotLS0gYS9zcmMvaW5jbHVkZS9wb3N0bWFzdGVyL2F1dG92YWN1dW0uaAorKysgYi9zcmMv aW5jbHVkZS9wb3N0bWFzdGVyL2F1dG92YWN1dW0uaApAQCAtNjQsNiArNjQsMTEgQEAgcGdfbm9y ZXR1cm4gZXh0ZXJuIHZvaWQgQXV0b1ZhY1dvcmtlck1haW4oY29uc3Qgdm9pZCAqc3RhcnR1cF9k YXRhLCBzaXplX3Qgc3RhcnQKIGV4dGVybiBib29sIEF1dG9WYWN1dW1SZXF1ZXN0V29yayhBdXRv VmFjdXVtV29ya0l0ZW1UeXBlIHR5cGUsCiAJCQkJCQkJCSAgT2lkIHJlbGF0aW9uSWQsIEJsb2Nr TnVtYmVyIGJsa25vKTsKIAorLyogcGFyYWxsZWwgYXV0b3ZhY3V1bSBzdHVmZiAqLworZXh0ZXJu IGludAlBdXRvVmFjdXVtUmVzZXJ2ZVBhcmFsbGVsV29ya2VycyhpbnQgbndvcmtlcnMpOworZXh0 ZXJuIHZvaWQgQXV0b1ZhY3V1bVJlbGVhc2VQYXJhbGxlbFdvcmtlcnMoaW50IG53b3JrZXJzKTsK K2V4dGVybiB2b2lkIEF1dG9WYWN1dW1SZWxlYXNlQWxsUGFyYWxsZWxXb3JrZXJzKHZvaWQpOwor CiAvKiBzaGFyZWQgbWVtb3J5IHN0dWZmICovCiBleHRlcm4gU2l6ZSBBdXRvVmFjdXVtU2htZW1T aXplKHZvaWQpOwogZXh0ZXJuIHZvaWQgQXV0b1ZhY3V1bVNobWVtSW5pdCh2b2lkKTsKZGlmZiAt LWdpdCBhL3NyYy9pbmNsdWRlL3V0aWxzL3JlbC5oIGIvc3JjL2luY2x1ZGUvdXRpbHMvcmVsLmgK aW5kZXggYjU1MjM1OTkxNWYuLmVkZDI4NjgwOGJmIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS91 dGlscy9yZWwuaAorKysgYi9zcmMvaW5jbHVkZS91dGlscy9yZWwuaApAQCAtMzExLDYgKzMxMSwx MyBAQCB0eXBlZGVmIHN0cnVjdCBGb3JlaWduS2V5Q2FjaGVJbmZvCiB0eXBlZGVmIHN0cnVjdCBB dXRvVmFjT3B0cwogewogCWJvb2wJCWVuYWJsZWQ7CisKKwkvKgorCSAqIE1heCBudW1iZXIgb2Yg cGFyYWxsZWwgYXV0b3ZhY3V1bSB3b3JrZXJzLiBJZiB2YWx1ZSBpcyAwIHRoZW4gcGFyYWxsZWwK KwkgKiBkZWdyZWUgd2lsbCBjb21wdXRlZCBiYXNlZCBvbiBudW1iZXIgb2YgaW5kZXhlcy4KKwkg Ki8KKwlpbnQJCQlhdXRvdmFjdXVtX3BhcmFsbGVsX3dvcmtlcnM7CisKIAlpbnQJCQl2YWN1dW1f dGhyZXNob2xkOwogCWludAkJCXZhY3V1bV9tYXhfdGhyZXNob2xkOwogCWludAkJCXZhY3V1bV9p bnNfdGhyZXNob2xkOwotLSAKMi40My4wCgo= --000000000000d6bce0063c9f8f3a--