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 1uI0bA-00E2wi-DV for pgsql-hackers@arkaria.postgresql.org; Thu, 22 May 2025 07:44:16 +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 1uI0b8-00GO6W-Sb for pgsql-hackers@arkaria.postgresql.org; Thu, 22 May 2025 07:44:14 +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.94.2) (envelope-from <3danissimo@gmail.com>) id 1uI0b8-00GO6O-F7 for pgsql-hackers@lists.postgresql.org; Thu, 22 May 2025 07:44:14 +0000 Received: from mail-yb1-xb2a.google.com ([2607:f8b0:4864:20::b2a]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.96) (envelope-from <3danissimo@gmail.com>) id 1uI0b5-000J01-0I for pgsql-hackers@lists.postgresql.org; Thu, 22 May 2025 07:44:13 +0000 Received: by mail-yb1-xb2a.google.com with SMTP id 3f1490d57ef6-e7b99f387e8so3800407276.0 for ; Thu, 22 May 2025 00:44:10 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1747899849; x=1748504649; 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=ZdUfc/l4Xub3A8Gf+VrAFnHasSDRFxSTU+KeUNQu6bw=; b=EEHnE66Q9F3VKJr8caZYVG79Dc4haMLTij03OlrIHKRJ5Ua5JHjTYCBA5+5r4vH1lr b4jHeYJXFSry+7PKL6TYfhqCB47f2QvzJBEVylc3eThsHbM4L5UXvcEBTo1UnnCj8WDy HUh6ZHJKU+wrtOgyznMZxHtfj4ECsGiqlRUuQYHuvGPqxB9X/ne1ZABFYqBEwWUff326 poHkC8LVjcsyRfw3qNUoNVMxdABFSbrzfxv6qRNtGD3PGy9kDFjQrDeJxV3097IXNTNQ /awOXdAh677e35eDiC0Ne7KWpvxmd2DrBMKI20i3rSJTLPcIxrntfpM0TwhMHD7PbpNX r57w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1747899849; x=1748504649; 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=ZdUfc/l4Xub3A8Gf+VrAFnHasSDRFxSTU+KeUNQu6bw=; b=Rzw0iN0pjY9+OGaXclK3sKYPkh8oJtFnV/Mu9P3IvwTkkUJUDrO6iJNLT0xjJt2i9e tNI0P5JlBjxicwZ9KEq/Ug5064weSqs+WkrkY94jJejMbDycpybyX8VF1NB2mI3IJzJv 4B4lwkvYr1JpZhprZ/05lG4vRVvyAwBd5OB7MCrHf9E7WADbycOIruE6ei910WzBDZwI C+Fe/LLh8lqdAFPkZE1F9jeOznoMb68Q4hUQUWvmcCP5SeHOXbv8iUho3fxKpbyYedFM IN+Q3msYIX5W+T82pXUI0mKZzYXDvqgEbCYvuLN0/zPRXbZ/YqkuNtkvi0N0oemEonIe aEpg== X-Forwarded-Encrypted: i=1; AJvYcCXFzb4FQMjw1GaTH5Vyyp9revhLuL9sDM1NnYPXrMw9eb7h/pUmyEISEzjBuImg2NP94kep7S3QYzBQoH7h@lists.postgresql.org X-Gm-Message-State: AOJu0YxstpjqTou/3V3Jmt3VB4PNA/TKrh9SlFs7vs0Rjjpm3MRIUIuA LY/CJ72/84x5NBs/aWOLAVZrVNe21O+xfLOIP0QRrFsSd7+2U/fl1WD5Ya1KB2zsBQpZS+RwcG2 4ksWmeNHZWp0zu0rfTHDBGnQLvHgVAvQ2b7ih X-Gm-Gg: ASbGnctgUhSBNmgOrEEQYp+F2Eu91Klq7fTDhn/nAlJ+Vt9V2GSSR5OpGg9LIjZmhb+ oX8rkLFpuDN+ECBTCS1BCGz3gzYO6NKjRn78ULNjCQy63Dk4cm2lD9+nEXcP9MQiHacNCFhcoaV IQyyJ879Z+hcF90FCRLe19MLnEZoNMnQ09u3onJ0os/w== X-Google-Smtp-Source: AGHT+IGdOJM1U+yMQV31hRYNZuk0ixFD0vCf3QzzSKgAvD0O73zeGpQ3nQmzwEKPALsl50O+lMZ4f6lptlyd+H08LzY= X-Received: by 2002:a05:6902:100d:b0:e7d:6a66:d0cd with SMTP id 3f1490d57ef6-e7d6a66d1edmr3554133276.35.1747899849231; Thu, 22 May 2025 00:44:09 -0700 (PDT) MIME-Version: 1.0 References: In-Reply-To: From: Daniil Davydov <3danissimo@gmail.com> Date: Thu, 22 May 2025 14:43:57 +0700 X-Gm-Features: AX0GCFuheor-5nc4vfLmWbLndSZJDVZBcCx-gvsm8xqnwOqOv821HcatJmMoVeQ Message-ID: Subject: Re: POC: Parallel processing of indexes in autovacuum To: Masahiko Sawada Cc: Matheus Alcantara , Sami Imseih , Maxim Orlov , Postgres hackers Content-Type: multipart/mixed; boundary="0000000000009e25860635b4a5ed" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --0000000000009e25860635b4a5ed Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Hi, On Wed, May 21, 2025 at 5:30=E2=80=AFAM Masahiko Sawada wrote: > > I have some comments on v2-0001 patch Thank you for reviewing this patch! > + { > + {"autovacuum_reserved_workers_num", PGC_USERSET, > RESOURCES_WORKER_PROCESSES, > + gettext_noop("Number of worker processes, reserved for > participation in parallel index processing during autovacuum."), > + gettext_noop("This parameter is depending on > \"max_worker_processes\" (not on \"autovacuum_max_workers\"). " > + "*Only* autovacuum workers can use these > additional processes. " > + "Also, these processes are taken into account > in \"max_parallel_workers\"."), > + }, > + &av_reserved_workers_num, > + 0, 0, MAX_BACKENDS, > + check_autovacuum_reserved_workers_num, NULL, NULL > + }, > > I find that the name "autovacuum_reserved_workers_num" is generic. It > would be better to have a more specific name for parallel vacuum such > as autovacuum_max_parallel_workers. This parameter is related to > neither autovacuum_worker_slots nor autovacuum_max_workers, which > seems fine to me. Also, max_parallel_maintenance_workers doesn't > affect this parameter. > ....... > I've also considered some alternative names. If we were to use > parallel_maintenance_workers, it sounds like it controls the parallel > degree for all operations using max_parallel_maintenance_workers, > including CREATE INDEX. Similarly, vacuum_parallel_workers could be > interpreted as affecting both autovacuum and manual VACUUM commands, > suggesting that when users run "VACUUM (PARALLEL) t", the system would > use their specified value for the parallel degree. I prefer > autovacuum_parallel_workers or vacuum_parallel_workers. > This was my headache when I created names for variables. Autovacuum initially implies parallelism, because we have several parallel a/v workers. So I think that parameter like `autovacuum_max_parallel_workers` will confuse somebody. If we want to have a more specific name, I would prefer `max_parallel_index_autovacuum_workers`. > Which number does this parameter mean to specify: the maximum number > of parallel vacuum workers that can be used during autovacuum or the > maximum number of parallel vacuum workers that each autovacuum can > use? First variant. I will concrete this in the variable's description. > + { > + { > + "parallel_idx_autovac_enabled", > + "Allows autovacuum to process indexes of this table in > parallel mode", > + RELOPT_KIND_HEAP, > + ShareUpdateExclusiveLock > + }, > + false > + }, > > The proposed reloption name doesn't align with our naming conventions. > Looking at our existing reloptions, we typically write out full words > rather than using abbreviations like 'autovac' or 'idx'. > > The new reloption name seems not to follow the conventional naming > style for existing reloption. For instance, we don't use abbreviations > such as 'autovac' and 'idx'. OK, I'll fix it. > + /* > + * If we are running autovacuum - decide whether we need to process i= ndexes > + * of table with given oid in parallel. > + */ > + if (AmAutoVacuumWorkerProcess() && > + params->index_cleanup !=3D VACOPTVALUE_DISABLED && > + RelationAllowsParallelIdxAutovac(rel)) > > I think that this should be done in autovacuum code. We need params->index cleanup variable to decide whether we need to use parallel index a/v. In autovacuum.c we have this code : *** /* * index_cleanup and truncate are unspecified at first in autovacuum. * They will be filled in with usable values using their reloptions * (or reloption defaults) later. */ tab->at_params.index_cleanup =3D VACOPTVALUE_UNSPECIFIED; tab->at_params.truncate =3D VACOPTVALUE_UNSPECIFIED; *** This variable is filled in inside the `vacuum_rel` function, so I think we should keep the above logic in vacuum.c. > +#define AV_PARALLEL_DEADTUP_THRESHOLD 1024 > > These fixed values really useful in common cases? I think we already > have an optimization where we skip vacuum indexes if the table has > fewer dead tuples (see BYPASS_THRESHOLD_PAGES). When we allocate dead items (and optionally init parallel autocuum) we don't have sane value for `vacrel->lpdead_item_pages` (which should be compared with BYPASS_THRESHOLD_PAGES). The only criterion that we can focus on is the number of dead tuples indicated in the PgStat_StatTabEntry. ---- > I guess we can implement this parameter as an integer parameter so > that the user can specify the number of parallel vacuum workers for > the table. For example, we can have a reloption > autovacuum_parallel_workers. Setting 0 (by default) means to disable > parallel vacuum during autovacuum, and setting special value -1 means > to let PostgreSQL calculate the parallel degree for the table (same as > the default VACUUM command behavior). > ........... > The patch includes the changes to bgworker.c so that we can reserve > some slots for autovacuums. I guess that this change is not > necessarily necessary because if the user sets the related GUC > parameters correctly the autovacuum workers can use parallel vacuum as > expected. Even if we need this change, I would suggest implementing > it as a separate patch. > .......... > +#define AV_PARALLEL_DEADTUP_THRESHOLD 1024 > +#define NUM_INDEXES_PER_PARALLEL_WORKER 30 > > These fixed values really useful in common cases? Given that we rely on > users' heuristics which table needs to use parallel vacuum during > autovacuum, I think we don't need to apply these conditions. > .......... I grouped these comments together, because they all relate to a single question : how much freedom will we give to the user? Your opinion (as far as I understand) is that we allow users to specify any number of parallel workers for tables, and it is the user's responsibility to configure appropriate GUC variables, so that autovacuum can always process indexes in parallel. And we don't need to think about thresholds. Even if the table has a small number of indexes and dead rows - if the user specified table option, we must do a parallel index a/v with requested number of parallel workers. Please correct me if I messed something up. I think that this logic is well suited for the `VACUUM (PARALLEL)` sql command, which is manually called by the user. But autovacuum (as I think) should work as stable as possible and `unnoticed` by other processes. Thus, we must : 1) Compute resources (such as the number of parallel workers for a single table's indexes vacuuming) as efficiently as possible. 2) Provide a guarantee that as many tables as possible (among requested) will be processed in parallel. (1) can be achieved by calculating the parameters on the fly. NUM_INDEXES_PER_PARALLEL_WORKER is a rough mock. I can provide more accurate value in the near future. (2) can be achieved by workers reserving - we know that N workers (from bgworkers pool) are *always* at our disposal. And when we use such workers we are not dependent on other operations in the cluster and we don't interfere with other operations by taking resources away from them. If we give the user too much freedom in parallel index a/v tuning, all these requirements may be violated. This is only my opinion, and I can agree with yours. Maybe we need another person to judge us? Please see v3 patches that contain changes related to GUC parameter and table option (no changes in global logic by now). -- Best regards, Daniil Davydov --0000000000009e25860635b4a5ed Content-Type: text/x-patch; charset="US-ASCII"; name="v3-0001-Parallel-index-autovacuum-with-bgworkers.patch" Content-Disposition: attachment; filename="v3-0001-Parallel-index-autovacuum-with-bgworkers.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_maz2dh0c0 RnJvbSAyMjIzZGE3YTliMmVmOGM4ZDcxNzgwYWQ3MmIyNGVhZjZkNmMxMTQxIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBGcmksIDE2IE1heSAyMDI1IDExOjU4OjQwICswNzAwClN1YmplY3Q6IFtQQVRD SCB2MyAxLzJdIFBhcmFsbGVsIGluZGV4IGF1dG92YWN1dW0gd2l0aCBiZ3dvcmtlcnMKCi0tLQog c3JjL2JhY2tlbmQvYWNjZXNzL2NvbW1vbi9yZWxvcHRpb25zLmMgICAgICAgIHwgMTEgKysrKwog c3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMgICAgICAgICAgICAgICAgIHwgNTUgKysrKysr KysrKysrKysrKysrKwogc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYyAgICAg ICAgIHwgNDYgKysrKysrKysrKy0tLS0tLQogc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFj dXVtLmMgICAgICAgICAgIHwgMTQgKysrKy0KIHNyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYmd3b3Jr ZXIuYyAgICAgICAgICAgICB8IDMzICsrKysrKysrKystCiBzcmMvYmFja2VuZC91dGlscy9pbml0 L2dsb2JhbHMuYyAgICAgICAgICAgICAgfCAgMSArCiBzcmMvYmFja2VuZC91dGlscy9taXNjL2d1 Y190YWJsZXMuYyAgICAgICAgICAgfCAxMiArKysrCiBzcmMvYmFja2VuZC91dGlscy9taXNjL3Bv c3RncmVzcWwuY29uZi5zYW1wbGUgfCAgMSArCiBzcmMvaW5jbHVkZS9taXNjYWRtaW4uaCAgICAg ICAgICAgICAgICAgICAgICAgfCAgMSArCiBzcmMvaW5jbHVkZS91dGlscy9ndWNfaG9va3MuaCAg ICAgICAgICAgICAgICAgfCAgMiArCiBzcmMvaW5jbHVkZS91dGlscy9yZWwuaCAgICAgICAgICAg ICAgICAgICAgICAgfCAxMCArKysrCiAxMSBmaWxlcyBjaGFuZ2VkLCAxNjYgaW5zZXJ0aW9ucygr KSwgMjAgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvYWNjZXNzL2NvbW1v bi9yZWxvcHRpb25zLmMgYi9zcmMvYmFja2VuZC9hY2Nlc3MvY29tbW9uL3JlbG9wdGlvbnMuYwpp bmRleCA0NmMxZGNlMjIyZC4uNzMwMDk2MDAyYjEgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2Fj Y2Vzcy9jb21tb24vcmVsb3B0aW9ucy5jCisrKyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9jb21tb24v cmVsb3B0aW9ucy5jCkBAIC0xNjYsNiArMTY2LDE1IEBAIHN0YXRpYyByZWxvcHRfYm9vbCBib29s UmVsT3B0c1tdID0KIAkJfSwKIAkJdHJ1ZQogCX0sCisJeworCQl7CisJCQkicGFyYWxsZWxfaW5k ZXhfYXV0b3ZhY3V1bV9lbmFibGVkIiwKKwkJCSJBbGxvd3MgYXV0b3ZhY3V1bSB0byBwcm9jZXNz IGluZGV4ZXMgb2YgdGhpcyB0YWJsZSBpbiBwYXJhbGxlbCBtb2RlIiwKKwkJCVJFTE9QVF9LSU5E X0hFQVAsCisJCQlTaGFyZVVwZGF0ZUV4Y2x1c2l2ZUxvY2sKKwkJfSwKKwkJZmFsc2UKKwl9LAog CS8qIGxpc3QgdGVybWluYXRvciAqLwogCXt7TlVMTH19CiB9OwpAQCAtMTg2Myw2ICsxODcyLDgg QEAgZGVmYXVsdF9yZWxvcHRpb25zKERhdHVtIHJlbG9wdGlvbnMsIGJvb2wgdmFsaWRhdGUsIHJl bG9wdF9raW5kIGtpbmQpCiAJCXsiZmlsbGZhY3RvciIsIFJFTE9QVF9UWVBFX0lOVCwgb2Zmc2V0 b2YoU3RkUmRPcHRpb25zLCBmaWxsZmFjdG9yKX0sCiAJCXsiYXV0b3ZhY3V1bV9lbmFibGVkIiwg UkVMT1BUX1RZUEVfQk9PTCwKIAkJb2Zmc2V0b2YoU3RkUmRPcHRpb25zLCBhdXRvdmFjdXVtKSAr IG9mZnNldG9mKEF1dG9WYWNPcHRzLCBlbmFibGVkKX0sCisJCXsicGFyYWxsZWxfaW5kZXhfYXV0 b3ZhY3V1bV9lbmFibGVkIiwgUkVMT1BUX1RZUEVfQk9PTCwKKwkJb2Zmc2V0b2YoU3RkUmRPcHRp b25zLCBhdXRvdmFjdXVtKSArIG9mZnNldG9mKEF1dG9WYWNPcHRzLCBwYXJhbGxlbF9pbmRleF9h dXRvdmFjdXVtX2VuYWJsZWQpfSwKIAkJeyJhdXRvdmFjdXVtX3ZhY3V1bV90aHJlc2hvbGQiLCBS RUxPUFRfVFlQRV9JTlQsCiAJCW9mZnNldG9mKFN0ZFJkT3B0aW9ucywgYXV0b3ZhY3V1bSkgKyBv ZmZzZXRvZihBdXRvVmFjT3B0cywgdmFjdXVtX3RocmVzaG9sZCl9LAogCQl7ImF1dG92YWN1dW1f dmFjdXVtX21heF90aHJlc2hvbGQiLCBSRUxPUFRfVFlQRV9JTlQsCmRpZmYgLS1naXQgYS9zcmMv YmFja2VuZC9jb21tYW5kcy92YWN1dW0uYyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5j CmluZGV4IDMzYTMzYmY2YjFjLi42YzJmNDlmMjAzZiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQv Y29tbWFuZHMvdmFjdXVtLmMKKysrIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMKQEAg LTU3LDkgKzU3LDIxIEBACiAjaW5jbHVkZSAidXRpbHMvZ3VjLmgiCiAjaW5jbHVkZSAidXRpbHMv Z3VjX2hvb2tzLmgiCiAjaW5jbHVkZSAidXRpbHMvbWVtdXRpbHMuaCIKKyNpbmNsdWRlICJ1dGls cy9yZWwuaCIKICNpbmNsdWRlICJ1dGlscy9zbmFwbWdyLmgiCiAjaW5jbHVkZSAidXRpbHMvc3lz Y2FjaGUuaCIKIAorLyoKKyAqIE1pbmltdW0gbnVtYmVyIG9mIGRlYWQgdHVwbGVzIHJlcXVpcmVk IGZvciB0aGUgdGFibGUncyBpbmRleGVzIHRvIGJlCisgKiBwcm9jZXNzZWQgaW4gcGFyYWxsZWwg ZHVyaW5nIGF1dG92YWN1dW0uCisgKi8KKyNkZWZpbmUgQVZfUEFSQUxMRUxfREVBRFRVUF9USFJF U0hPTEQJMTAyNAorCisvKgorICogSG93IG1hbnkgaW5kZXhlcyBzaG91bGQgcHJvY2VzcyBlYWNo IHBhcmFsbGVsIHdvcmtlciBkdXJpbmcgYXV0b3ZhY3V1bS4KKyAqLworI2RlZmluZSBOVU1fSU5E RVhFU19QRVJfUEFSQUxMRUxfV09SS0VSIDMwCisKIC8qCiAgKiBNaW5pbXVtIGludGVydmFsIGZv ciBjb3N0LWJhc2VkIHZhY3V1bSBkZWxheSByZXBvcnRzIGZyb20gYSBwYXJhbGxlbCB3b3JrZXIu CiAgKiBUaGlzIGFpbXMgdG8gYXZvaWQgc2VuZGluZyB0b28gbWFueSBtZXNzYWdlcyBhbmQgd2Fr aW5nIHVwIHRoZSBsZWFkZXIgdG9vCkBAIC0yMjM0LDYgKzIyNDYsNDkgQEAgdmFjdXVtX3JlbChP aWQgcmVsaWQsIFJhbmdlVmFyICpyZWxhdGlvbiwgVmFjdXVtUGFyYW1zICpwYXJhbXMsCiAJZWxz ZQogCQl0b2FzdF9yZWxpZCA9IEludmFsaWRPaWQ7CiAKKwkvKgorCSAqIElmIHdlIGFyZSBydW5u aW5nIGF1dG92YWN1dW0gLSBkZWNpZGUgd2hldGhlciB3ZSBuZWVkIHRvIHByb2Nlc3MgaW5kZXhl cworCSAqIG9mIHRhYmxlIHdpdGggZ2l2ZW4gb2lkIGluIHBhcmFsbGVsLgorCSAqLworCWlmIChB bUF1dG9WYWN1dW1Xb3JrZXJQcm9jZXNzKCkgJiYKKwkJcGFyYW1zLT5pbmRleF9jbGVhbnVwICE9 IFZBQ09QVFZBTFVFX0RJU0FCTEVEICYmCisJCVJlbGF0aW9uQWxsb3dzUGFyYWxsZWxJZHhBdXRv dmFjKHJlbCkpCisJeworCQlQZ1N0YXRfU3RhdFRhYkVudHJ5ICp0YWJlbnRyeTsKKworCQkvKiBm ZXRjaCB0aGUgcGdzdGF0IHRhYmxlIGVudHJ5ICovCisJCXRhYmVudHJ5ID0gcGdzdGF0X2ZldGNo X3N0YXRfdGFiZW50cnlfZXh0KHJlbC0+cmRfcmVsLT5yZWxpc3NoYXJlZCwKKwkJCQkJCQkJCQkJ CSAgcmVsLT5yZF9pZCk7CisJCWlmICh0YWJlbnRyeSAmJiB0YWJlbnRyeS0+ZGVhZF90dXBsZXMg Pj0gQVZfUEFSQUxMRUxfREVBRFRVUF9USFJFU0hPTEQpCisJCXsKKwkJCUxpc3QgICAqaW5kZXhl cyA9IFJlbGF0aW9uR2V0SW5kZXhMaXN0KHJlbCk7CisJCQlpbnQJCW51bV9pbmRleGVzID0gbGlz dF9sZW5ndGgoaW5kZXhlcyk7CisKKwkJCWxpc3RfZnJlZShpbmRleGVzKTsKKworCQkJaWYgKHBp YV9yZXNlcnZlZF93b3JrZXJzID4gMCkKKwkJCXsKKwkJCQkvKgorCQkJCSAqIFdlIHJlcXVlc3Qg YXQgbGVhc3Qgb25lIHBhcmFsbGVsIHdvcmtlciwgaWYgdXNlciBzZXQKKwkJCQkgKiAncGFyYWxs ZWxfaWR4X2F1dG92YWNfZW5hYmxlZCcgb3B0aW9uLiBUaGUgdG90YWwgbnVtYmVyIG9mCisJCQkJ ICogYWRkaXRpb25hbCBwYXJhbGxlbCB3b3JrZXJzIGRlcGVuZHMgb24gaG93IG1hbnkgaW5kZXhl cyB0aGUKKwkJCQkgKiB0YWJsZSBoYXMuIEZvciBub3cgd2UgYXNzdW1lIHRoYXQgZWFjaCBwYXJh bGxlbCB3b3JrZXIgc2hvdWxkCisJCQkJICogcHJvY2VzcyBOVU1fSU5ERVhFU19QRVJfUEFSQUxM RUxfV09SS0VSIGluZGV4ZXMuCisJCQkJICovCisJCQkJcGFyYW1zLT5ud29ya2VycyA9CisJCQkJ CU1pbigobnVtX2luZGV4ZXMgLyBOVU1fSU5ERVhFU19QRVJfUEFSQUxMRUxfV09SS0VSKSArIDEs CisJCQkJCQlwaWFfcmVzZXJ2ZWRfd29ya2Vycyk7CisJCQl9CisJCQllbHNlCisJCQkJZXJlcG9y dChXQVJOSU5HLAorCQkJCQkoZXJyY29kZShFUlJDT0RFX0NPTkZJR1VSQVRJT05fTElNSVRfRVhD RUVERUQpLAorCQkJCQkgZXJybXNnKCJDYW5ub3QgbGF1bmNoIGFueSBzdXBwb3J0aXZlIHdvcmtl cnMgZm9yIHBhcmFsbGVsIGluZGV4IGNsZWFudXAgb2YgcmVsICVzIiwKKwkJCQkJCQlSZWxhdGlv bkdldFJlbGF0aW9uTmFtZShyZWwpKSwKKwkJCQkJZXJyaGludCgiWW91IG1pZ2h0IG5lZWQgdG8g c2V0IHBhcmFtZXRlciBcInBpYV9yZXNlcnZlZF93b3JrZXJzXCIgdG8gYSB2YWx1ZSA+IDAiKSkp OworCisJCX0KKwl9CisKIAkvKgogCSAqIFN3aXRjaCB0byB0aGUgdGFibGUgb3duZXIncyB1c2Vy aWQsIHNvIHRoYXQgYW55IGluZGV4IGZ1bmN0aW9ucyBhcmUgcnVuCiAJICogYXMgdGhhdCB1c2Vy LiAgQWxzbyBsb2NrIGRvd24gc2VjdXJpdHktcmVzdHJpY3RlZCBvcGVyYXRpb25zIGFuZApkaWZm IC0tZ2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYyBiL3NyYy9iYWNr ZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMKaW5kZXggMmI5ZDU0OGNkZWIuLjVjNDhhMWU3 NDBlIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCisr KyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMKQEAgLTEsMTUgKzEsMTUg QEAKIC8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogICoKICAqIHZhY3V1bXBhcmFsbGVsLmMKLSAqCSAgU3Vw cG9ydCByb3V0aW5lcyBmb3IgcGFyYWxsZWwgdmFjdXVtIGV4ZWN1dGlvbi4KKyAqCSAgU3VwcG9y dCByb3V0aW5lcyBmb3IgcGFyYWxsZWwgW2F1dG9ddmFjdXVtIGV4ZWN1dGlvbi4KICAqCiAgKiBU aGlzIGZpbGUgY29udGFpbnMgcm91dGluZXMgdGhhdCBhcmUgaW50ZW5kZWQgdG8gc3VwcG9ydCBz ZXR0aW5nIHVwLCB1c2luZywKICAqIGFuZCB0ZWFyaW5nIGRvd24gYSBQYXJhbGxlbFZhY3V1bVN0 YXRlLgogICoKLSAqIEluIGEgcGFyYWxsZWwgdmFjdXVtLCB3ZSBwZXJmb3JtIGJvdGggaW5kZXgg YnVsayBkZWxldGlvbiBhbmQgaW5kZXggY2xlYW51cAotICogd2l0aCBwYXJhbGxlbCB3b3JrZXIg cHJvY2Vzc2VzLiAgSW5kaXZpZHVhbCBpbmRleGVzIGFyZSBwcm9jZXNzZWQgYnkgb25lCi0gKiB2 YWN1dW0gcHJvY2Vzcy4gIFBhcmFsbGVsVmFjdXVtU3RhdGUgY29udGFpbnMgc2hhcmVkIGluZm9y bWF0aW9uIGFzIHdlbGwgYXMKLSAqIHRoZSBtZW1vcnkgc3BhY2UgZm9yIHN0b3JpbmcgZGVhZCBp dGVtcyBhbGxvY2F0ZWQgaW4gdGhlIERTQSBhcmVhLiAgV2UKKyAqIEluIGEgcGFyYWxsZWwgW2F1 dG9ddmFjdXVtLCB3ZSBwZXJmb3JtIGJvdGggaW5kZXggYnVsayBkZWxldGlvbiBhbmQgaW5kZXgK KyAqIGNsZWFudXAgd2l0aCBwYXJhbGxlbCB3b3JrZXIgcHJvY2Vzc2VzLiAgSW5kaXZpZHVhbCBp bmRleGVzIGFyZSBwcm9jZXNzZWQgYnkKKyAqIG9uZSB2YWN1dW0gcHJvY2Vzcy4gIFBhcmFsbGVs VmFjdXVtU3RhdGUgY29udGFpbnMgc2hhcmVkIGluZm9ybWF0aW9uIGFzIHdlbGwKKyAqIGFzIHRo ZSBtZW1vcnkgc3BhY2UgZm9yIHN0b3JpbmcgZGVhZCBpdGVtcyBhbGxvY2F0ZWQgaW4gdGhlIERT QSBhcmVhLiAgV2UKICAqIGxhdW5jaCBwYXJhbGxlbCB3b3JrZXIgcHJvY2Vzc2VzIGF0IHRoZSBz dGFydCBvZiBwYXJhbGxlbCBpbmRleAogICogYnVsay1kZWxldGlvbiBhbmQgaW5kZXggY2xlYW51 cCBhbmQgb25jZSBhbGwgaW5kZXhlcyBhcmUgcHJvY2Vzc2VkLCB0aGUKICAqIHBhcmFsbGVsIHdv cmtlciBwcm9jZXNzZXMgZXhpdC4gIEVhY2ggdGltZSB3ZSBwcm9jZXNzIGluZGV4ZXMgaW4gcGFy YWxsZWwsCkBAIC0zNCw2ICszNCw3IEBACiAjaW5jbHVkZSAiZXhlY3V0b3IvaW5zdHJ1bWVudC5o IgogI2luY2x1ZGUgIm9wdGltaXplci9wYXRocy5oIgogI2luY2x1ZGUgInBnc3RhdC5oIgorI2lu Y2x1ZGUgInBvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5oIgogI2luY2x1ZGUgInN0b3JhZ2UvYnVmbWdy LmgiCiAjaW5jbHVkZSAidGNvcC90Y29wcHJvdC5oIgogI2luY2x1ZGUgInV0aWxzL2xzeXNjYWNo ZS5oIgpAQCAtMTU3LDcgKzE1OCw4IEBAIHR5cGVkZWYgc3RydWN0IFBWSW5kU3RhdHMKIH0gUFZJ bmRTdGF0czsKIAogLyoKLSAqIFN0cnVjdCBmb3IgbWFpbnRhaW5pbmcgYSBwYXJhbGxlbCB2YWN1 dW0gc3RhdGUuIHR5cGVkZWYgYXBwZWFycyBpbiB2YWN1dW0uaC4KKyAqIFN0cnVjdCBmb3IgbWFp bnRhaW5pbmcgYSBwYXJhbGxlbCBbYXV0b112YWN1dW0gc3RhdGUuIHR5cGVkZWYgYXBwZWFycyBp bgorICogdmFjdXVtLmguCiAgKi8KIHN0cnVjdCBQYXJhbGxlbFZhY3V1bVN0YXRlCiB7CkBAIC0z NzEsMTAgKzM3MywxOCBAQCBwYXJhbGxlbF92YWN1dW1faW5pdChSZWxhdGlvbiByZWwsIFJlbGF0 aW9uICppbmRyZWxzLCBpbnQgbmluZGV4ZXMsCiAJc2hhcmVkLT5yZWxpZCA9IFJlbGF0aW9uR2V0 UmVsaWQocmVsKTsKIAlzaGFyZWQtPmVsZXZlbCA9IGVsZXZlbDsKIAlzaGFyZWQtPnF1ZXJ5aWQg PSBwZ3N0YXRfZ2V0X215X3F1ZXJ5X2lkKCk7Ci0Jc2hhcmVkLT5tYWludGVuYW5jZV93b3JrX21l bV93b3JrZXIgPQotCQkobmluZGV4ZXNfbXdtID4gMCkgPwotCQltYWludGVuYW5jZV93b3JrX21l bSAvIE1pbihwYXJhbGxlbF93b3JrZXJzLCBuaW5kZXhlc19td20pIDoKLQkJbWFpbnRlbmFuY2Vf d29ya19tZW07CisKKwlpZiAoQW1BdXRvVmFjdXVtV29ya2VyUHJvY2VzcygpKQorCQlzaGFyZWQt Pm1haW50ZW5hbmNlX3dvcmtfbWVtX3dvcmtlciA9CisJCQkobmluZGV4ZXNfbXdtID4gMCkgPwor CQkJYXV0b3ZhY3V1bV93b3JrX21lbSAvIE1pbihwYXJhbGxlbF93b3JrZXJzLCBuaW5kZXhlc19t d20pIDoKKwkJCWF1dG92YWN1dW1fd29ya19tZW07CisJZWxzZQorCQlzaGFyZWQtPm1haW50ZW5h bmNlX3dvcmtfbWVtX3dvcmtlciA9CisJCQkobmluZGV4ZXNfbXdtID4gMCkgPworCQkJbWFpbnRl bmFuY2Vfd29ya19tZW0gLyBNaW4ocGFyYWxsZWxfd29ya2VycywgbmluZGV4ZXNfbXdtKSA6CisJ CQltYWludGVuYW5jZV93b3JrX21lbTsKKwogCXNoYXJlZC0+ZGVhZF9pdGVtc19pbmZvLm1heF9i eXRlcyA9IHZhY193b3JrX21lbSAqIChzaXplX3QpIDEwMjQ7CiAKIAkvKiBQcmVwYXJlIERTQSBz cGFjZSBmb3IgZGVhZCBpdGVtcyAqLwpAQCAtNTU4LDcgKzU2OCw5IEBAIHBhcmFsbGVsX3ZhY3V1 bV9jb21wdXRlX3dvcmtlcnMoUmVsYXRpb24gKmluZHJlbHMsIGludCBuaW5kZXhlcywgaW50IG5y ZXF1ZXN0ZWQsCiAJICogV2UgZG9uJ3QgYWxsb3cgcGVyZm9ybWluZyBwYXJhbGxlbCBvcGVyYXRp b24gaW4gc3RhbmRhbG9uZSBiYWNrZW5kIG9yCiAJICogd2hlbiBwYXJhbGxlbGlzbSBpcyBkaXNh YmxlZC4KIAkgKi8KLQlpZiAoIUlzVW5kZXJQb3N0bWFzdGVyIHx8IG1heF9wYXJhbGxlbF9tYWlu dGVuYW5jZV93b3JrZXJzID09IDApCisJaWYgKCFJc1VuZGVyUG9zdG1hc3RlciB8fAorCQkocGlh X3Jlc2VydmVkX3dvcmtlcnMgPT0gMCAmJiBBbUF1dG9WYWN1dW1Xb3JrZXJQcm9jZXNzKCkpIHx8 CisJCShtYXhfcGFyYWxsZWxfbWFpbnRlbmFuY2Vfd29ya2VycyA9PSAwICYmICFBbUF1dG9WYWN1 dW1Xb3JrZXJQcm9jZXNzKCkpKQogCQlyZXR1cm4gMDsKIAogCS8qCkBAIC01OTcsMTUgKzYwOSwx NyBAQCBwYXJhbGxlbF92YWN1dW1fY29tcHV0ZV93b3JrZXJzKFJlbGF0aW9uICppbmRyZWxzLCBp bnQgbmluZGV4ZXMsIGludCBucmVxdWVzdGVkLAogCXBhcmFsbGVsX3dvcmtlcnMgPSAobnJlcXVl c3RlZCA+IDApID8KIAkJTWluKG5yZXF1ZXN0ZWQsIG5pbmRleGVzX3BhcmFsbGVsKSA6IG5pbmRl eGVzX3BhcmFsbGVsOwogCi0JLyogQ2FwIGJ5IG1heF9wYXJhbGxlbF9tYWludGVuYW5jZV93b3Jr ZXJzICovCi0JcGFyYWxsZWxfd29ya2VycyA9IE1pbihwYXJhbGxlbF93b3JrZXJzLCBtYXhfcGFy YWxsZWxfbWFpbnRlbmFuY2Vfd29ya2Vycyk7CisJLyogQ2FwIGJ5IEdVQyB2YXJpYWJsZSAqLwor CXBhcmFsbGVsX3dvcmtlcnMgPSBBbUF1dG9WYWN1dW1Xb3JrZXJQcm9jZXNzKCkgPworCQlNaW4o cGFyYWxsZWxfd29ya2VycywgcGlhX3Jlc2VydmVkX3dvcmtlcnMpIDoKKwkJTWluKHBhcmFsbGVs X3dvcmtlcnMsIG1heF9wYXJhbGxlbF9tYWludGVuYW5jZV93b3JrZXJzKTsKIAogCXJldHVybiBw YXJhbGxlbF93b3JrZXJzOwogfQogCiAvKgogICogUGVyZm9ybSBpbmRleCB2YWN1dW0gb3IgaW5k ZXggY2xlYW51cCB3aXRoIHBhcmFsbGVsIHdvcmtlcnMuICBUaGlzIGZ1bmN0aW9uCi0gKiBtdXN0 IGJlIHVzZWQgYnkgdGhlIHBhcmFsbGVsIHZhY3V1bSBsZWFkZXIgcHJvY2Vzcy4KKyAqIG11c3Qg YmUgdXNlZCBieSB0aGUgcGFyYWxsZWwgW2F1dG9ddmFjdXVtIGxlYWRlciBwcm9jZXNzLgogICov CiBzdGF0aWMgdm9pZAogcGFyYWxsZWxfdmFjdXVtX3Byb2Nlc3NfYWxsX2luZGV4ZXMoUGFyYWxs ZWxWYWN1dW1TdGF0ZSAqcHZzLCBpbnQgbnVtX2luZGV4X3NjYW5zLApAQCAtOTgyLDggKzk5Niw4 IEBAIHBhcmFsbGVsX3ZhY3V1bV9pbmRleF9pc19wYXJhbGxlbF9zYWZlKFJlbGF0aW9uIGluZHJl bCwgaW50IG51bV9pbmRleF9zY2FucywKIC8qCiAgKiBQZXJmb3JtIHdvcmsgd2l0aGluIGEgbGF1 bmNoZWQgcGFyYWxsZWwgcHJvY2Vzcy4KICAqCi0gKiBTaW5jZSBwYXJhbGxlbCB2YWN1dW0gd29y a2VycyBwZXJmb3JtIG9ubHkgaW5kZXggdmFjdXVtIG9yIGluZGV4IGNsZWFudXAsCi0gKiB3ZSBk b24ndCBuZWVkIHRvIHJlcG9ydCBwcm9ncmVzcyBpbmZvcm1hdGlvbi4KKyAqIFNpbmNlIHBhcmFs bGVsIFthdXRvXXZhY3V1bSB3b3JrZXJzIHBlcmZvcm0gb25seSBpbmRleCB2YWN1dW0gb3IgaW5k ZXgKKyAqIGNsZWFudXAsIHdlIGRvbid0IG5lZWQgdG8gcmVwb3J0IHByb2dyZXNzIGluZm9ybWF0 aW9uLgogICovCiB2b2lkCiBwYXJhbGxlbF92YWN1dW1fbWFpbihkc21fc2VnbWVudCAqc2VnLCBz aG1fdG9jICp0b2MpCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1 dW0uYyBiL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCmluZGV4IDRkNGExYTMx OTdlLi41OWZiNTJhYTQ0MyAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRv dmFjdXVtLmMKKysrIGIvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMKQEAgLTI4 MjQsNyArMjgyNCwxMSBAQCB0YWJsZV9yZWNoZWNrX2F1dG92YWMoT2lkIHJlbGlkLCBIVEFCICp0 YWJsZV90b2FzdF9tYXAsCiAJCSAqLwogCQl0YWItPmF0X3BhcmFtcy5pbmRleF9jbGVhbnVwID0g VkFDT1BUVkFMVUVfVU5TUEVDSUZJRUQ7CiAJCXRhYi0+YXRfcGFyYW1zLnRydW5jYXRlID0gVkFD T1BUVkFMVUVfVU5TUEVDSUZJRUQ7Ci0JCS8qIEFzIG9mIG5vdywgd2UgZG9uJ3Qgc3VwcG9ydCBw YXJhbGxlbCB2YWN1dW0gZm9yIGF1dG92YWN1dW0gKi8KKwkJLyoKKwkJICogRG9uJ3QgcmVxdWVz dCBwYXJhbGxlbCBtb2RlIGJ5IG5vdy4gbndvcmtlcnMgbWlnaHQgYmUgc2V0IHRvCisJCSAqIHBv c2l0aXZlIHZhbHVlIGlmIHdlIHdpbGwgbWVldCBhcHByb3ByaWF0ZSBmb3IgcGFyYWxsZWwgaW5k ZXgKKwkJICogcHJvY2Vzc2luZyB0YWJsZS4KKwkJICovCiAJCXRhYi0+YXRfcGFyYW1zLm53b3Jr ZXJzID0gLTE7CiAJCXRhYi0+YXRfcGFyYW1zLmZyZWV6ZV9taW5fYWdlID0gZnJlZXplX21pbl9h Z2U7CiAJCXRhYi0+YXRfcGFyYW1zLmZyZWV6ZV90YWJsZV9hZ2UgPSBmcmVlemVfdGFibGVfYWdl OwpAQCAtMzQwNiw2ICszNDEwLDE0IEBAIGNoZWNrX2F1dG92YWN1dW1fd29ya19tZW0oaW50ICpu ZXd2YWwsIHZvaWQgKipleHRyYSwgR3VjU291cmNlIHNvdXJjZSkKIAlyZXR1cm4gdHJ1ZTsKIH0K IAorYm9vbAorY2hlY2tfcGlhX3Jlc2VydmVkX3dvcmtlcnMoaW50ICpuZXd2YWwsIHZvaWQgKipl eHRyYSwgR3VjU291cmNlIHNvdXJjZSkKK3sKKwlpZiAoKm5ld3ZhbCA+IChtYXhfd29ya2VyX3By b2Nlc3NlcyAtIDgpKQorCQlyZXR1cm4gZmFsc2U7CisJcmV0dXJuIHRydWU7Cit9CisKIC8qCiAg KiBSZXR1cm5zIHdoZXRoZXIgdGhlcmUgaXMgYSBmcmVlIGF1dG92YWN1dW0gd29ya2VyIHNsb3Qg YXZhaWxhYmxlLgogICovCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2Jnd29y a2VyLmMgYi9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2Jnd29ya2VyLmMKaW5kZXggMTE2ZGRmN2I4 MzUuLmU2MjA3NjkzOWVjIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2Jnd29y a2VyLmMKKysrIGIvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9iZ3dvcmtlci5jCkBAIC0xMDQ2LDYg KzEwNDYsOCBAQCBSZWdpc3RlckR5bmFtaWNCYWNrZ3JvdW5kV29ya2VyKEJhY2tncm91bmRXb3Jr ZXIgKndvcmtlciwKIAkJCQkJCQkJQmFja2dyb3VuZFdvcmtlckhhbmRsZSAqKmhhbmRsZSkKIHsK IAlpbnQJCQlzbG90bm87CisJaW50CQkJZnJvbTsKKwlpbnQJCQl1cHRvOwogCWJvb2wJCXN1Y2Nl c3MgPSBmYWxzZTsKIAlib29sCQlwYXJhbGxlbDsKIAl1aW50NjQJCWdlbmVyYXRpb24gPSAwOwpA QCAtMTA4OCwxMCArMTA5MCwyMyBAQCBSZWdpc3RlckR5bmFtaWNCYWNrZ3JvdW5kV29ya2VyKEJh Y2tncm91bmRXb3JrZXIgKndvcmtlciwKIAkJcmV0dXJuIGZhbHNlOwogCX0KIAorCS8qCisJICog RGV0ZXJtaW5lIHJhbmdlIG9mIHdvcmtlcnMgaW4gcG9vbCwgdGhhdCB3ZSBjYW4gdXNlIChsYXN0 CisJICogJ3BpYV9yZXNlcnZlZF93b3JrZXJzJyBpcyByZXNlcnZlZCBmb3IgYXV0b3ZhY3V1bSB3 b3JrZXJzKS4KKwkgKi8KKworCWZyb20gPSBBbUF1dG9WYWN1dW1Xb3JrZXJQcm9jZXNzKCkgPwor CQlCYWNrZ3JvdW5kV29ya2VyRGF0YS0+dG90YWxfc2xvdHMgLSBwaWFfcmVzZXJ2ZWRfd29ya2Vy cyA6CisJCTA7CisKKwl1cHRvID0gQW1BdXRvVmFjdXVtV29ya2VyUHJvY2VzcygpID8KKwkJQmFj a2dyb3VuZFdvcmtlckRhdGEtPnRvdGFsX3Nsb3RzIDoKKwkJQmFja2dyb3VuZFdvcmtlckRhdGEt PnRvdGFsX3Nsb3RzIC0gcGlhX3Jlc2VydmVkX3dvcmtlcnM7CisKIAkvKgogCSAqIExvb2sgZm9y IGFuIHVudXNlZCBzbG90LiAgSWYgd2UgZmluZCBvbmUsIGdyYWIgaXQuCiAJICovCi0JZm9yIChz bG90bm8gPSAwOyBzbG90bm8gPCBCYWNrZ3JvdW5kV29ya2VyRGF0YS0+dG90YWxfc2xvdHM7ICsr c2xvdG5vKQorCWZvciAoc2xvdG5vID0gZnJvbTsgc2xvdG5vIDwgdXB0bzsgKytzbG90bm8pCiAJ ewogCQlCYWNrZ3JvdW5kV29ya2VyU2xvdCAqc2xvdCA9ICZCYWNrZ3JvdW5kV29ya2VyRGF0YS0+ c2xvdFtzbG90bm9dOwogCkBAIC0xMTU5LDcgKzExNzQsMTMgQEAgR2V0QmFja2dyb3VuZFdvcmtl clBpZChCYWNrZ3JvdW5kV29ya2VySGFuZGxlICpoYW5kbGUsIHBpZF90ICpwaWRwKQogCUJhY2tn cm91bmRXb3JrZXJTbG90ICpzbG90OwogCXBpZF90CQlwaWQ7CiAKLQlBc3NlcnQoaGFuZGxlLT5z bG90IDwgbWF4X3dvcmtlcl9wcm9jZXNzZXMpOworCS8qIE9ubHkgYXV0b3ZhY3V1bSBjYW4gdXNl IGxhc3QgJ3BpYV9yZXNlcnZlZF93b3JrZXJzJyB3b3JrZXJzIGluIHBvb2wuICovCisJaWYgKCFB bUF1dG9WYWN1dW1Xb3JrZXJQcm9jZXNzKCkpCisJCUFzc2VydChoYW5kbGUtPnNsb3QgPCBtYXhf d29ya2VyX3Byb2Nlc3NlcyAtIHBpYV9yZXNlcnZlZF93b3JrZXJzKTsKKwllbHNlCisJCUFzc2Vy dChoYW5kbGUtPnNsb3QgPCBtYXhfd29ya2VyX3Byb2Nlc3NlcyAmJgorCQkJICAgaGFuZGxlLT5z bG90ID49IG1heF93b3JrZXJfcHJvY2Vzc2VzIC0gcGlhX3Jlc2VydmVkX3dvcmtlcnMpOworCiAJ c2xvdCA9ICZCYWNrZ3JvdW5kV29ya2VyRGF0YS0+c2xvdFtoYW5kbGUtPnNsb3RdOwogCiAJLyoK QEAgLTEyOTgsNyArMTMxOSwxMyBAQCBUZXJtaW5hdGVCYWNrZ3JvdW5kV29ya2VyKEJhY2tncm91 bmRXb3JrZXJIYW5kbGUgKmhhbmRsZSkKIAlCYWNrZ3JvdW5kV29ya2VyU2xvdCAqc2xvdDsKIAli b29sCQlzaWduYWxfcG9zdG1hc3RlciA9IGZhbHNlOwogCi0JQXNzZXJ0KGhhbmRsZS0+c2xvdCA8 IG1heF93b3JrZXJfcHJvY2Vzc2VzKTsKKwkvKiBPbmx5IGF1dG92YWN1dW0gY2FuIHVzZSBsYXN0 ICdwaWFfcmVzZXJ2ZWRfd29ya2Vycycgd29ya2VycyBpbiBwb29sLiAqLworCWlmICghQW1BdXRv VmFjdXVtV29ya2VyUHJvY2VzcygpKQorCQlBc3NlcnQoaGFuZGxlLT5zbG90IDwgbWF4X3dvcmtl cl9wcm9jZXNzZXMgLSBwaWFfcmVzZXJ2ZWRfd29ya2Vycyk7CisJZWxzZQorCQlBc3NlcnQoaGFu ZGxlLT5zbG90IDwgbWF4X3dvcmtlcl9wcm9jZXNzZXMgJiYKKwkJCSAgIGhhbmRsZS0+c2xvdCA+ PSBtYXhfd29ya2VyX3Byb2Nlc3NlcyAtIHBpYV9yZXNlcnZlZF93b3JrZXJzKTsKKwogCXNsb3Qg PSAmQmFja2dyb3VuZFdvcmtlckRhdGEtPnNsb3RbaGFuZGxlLT5zbG90XTsKIAogCS8qIFNldCB0 ZXJtaW5hdGUgZmxhZyBpbiBzaGFyZWQgbWVtb3J5LCB1bmxlc3Mgc2xvdCBoYXMgYmVlbiByZXVz ZWQuICovCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC91dGlscy9pbml0L2dsb2JhbHMuYyBiL3Ny Yy9iYWNrZW5kL3V0aWxzL2luaXQvZ2xvYmFscy5jCmluZGV4IDkyYjA0NDZiODBjLi5hNmZkY2Qy ZGU1YiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvdXRpbHMvaW5pdC9nbG9iYWxzLmMKKysrIGIv c3JjL2JhY2tlbmQvdXRpbHMvaW5pdC9nbG9iYWxzLmMKQEAgLTE0NCw2ICsxNDQsNyBAQCBpbnQJ CQlOQnVmZmVycyA9IDE2Mzg0OwogaW50CQkJTWF4Q29ubmVjdGlvbnMgPSAxMDA7CiBpbnQJCQlt YXhfd29ya2VyX3Byb2Nlc3NlcyA9IDg7CiBpbnQJCQltYXhfcGFyYWxsZWxfd29ya2VycyA9IDg7 CitpbnQgICAgICAgICBwaWFfcmVzZXJ2ZWRfd29ya2VycyA9IDA7CiBpbnQJCQlNYXhCYWNrZW5k cyA9IDA7CiAKIC8qIEdVQyBwYXJhbWV0ZXJzIGZvciB2YWN1dW0gKi8KZGlmZiAtLWdpdCBhL3Ny Yy9iYWNrZW5kL3V0aWxzL21pc2MvZ3VjX3RhYmxlcy5jIGIvc3JjL2JhY2tlbmQvdXRpbHMvbWlz Yy9ndWNfdGFibGVzLmMKaW5kZXggMmY4Y2JkODY3NTkuLmRmYzE4MDk1ZDdiIDEwMDY0NAotLS0g YS9zcmMvYmFja2VuZC91dGlscy9taXNjL2d1Y190YWJsZXMuYworKysgYi9zcmMvYmFja2VuZC91 dGlscy9taXNjL2d1Y190YWJsZXMuYwpAQCAtMzYwNCw2ICszNjA0LDE4IEBAIHN0cnVjdCBjb25m aWdfaW50IENvbmZpZ3VyZU5hbWVzSW50W10gPQogCQlOVUxMLCBOVUxMLCBOVUxMCiAJfSwKIAor CXsKKwkJeyJwYXJhbGxlbF9pbmRleF9hdXRvdmFjdXVtX3Jlc2VydmVkX3dvcmtlcnMiLCBQR0Nf VVNFUlNFVCwgUkVTT1VSQ0VTX1dPUktFUl9QUk9DRVNTRVMsCisJCQlnZXR0ZXh0X25vb3AoIk1h eGltdW0gbnVtYmVyIG9mIHdvcmtlciBwcm9jZXNzZXMgKGZyb20gYmd3b3JrZXJzIHBvb2wpLCBy ZXNlcnZlZCBmb3IgcGFydGljaXBhdGlvbiBpbiBwYXJhbGxlbCBpbmRleCBhdXRvdmFjdXVtLiIp LAorCQkJZ2V0dGV4dF9ub29wKCJUaGlzIHBhcmFtZXRlciBpcyBkZXBlbmRpbmcgb24gXCJtYXhf d29ya2VyX3Byb2Nlc3Nlc1wiIChub3Qgb24gXCJhdXRvdmFjdXVtX21heF93b3JrZXJzXCIpLiAi CisJCQkJCQkgIipPbmx5KiBhdXRvdmFjdXVtIHdvcmtlcnMgY2FuIHVzZSB0aGVzZSBzdXBwb3J0 aXZlIHByb2Nlc3Nlcy4gIgorCQkJCQkJICJBbHNvLCB0aGVzZSBwcm9jZXNzZXMgYXJlIHRha2Vu IGludG8gYWNjb3VudCBpbiBcIm1heF9wYXJhbGxlbF93b3JrZXJzXCIuIiksCisJCX0sCisJCSZw aWFfcmVzZXJ2ZWRfd29ya2VycywKKwkJMCwgMCwgTUFYX0JBQ0tFTkRTLAorCQljaGVja19waWFf cmVzZXJ2ZWRfd29ya2VycywgTlVMTCwgTlVMTAorCX0sCisKIAl7CiAJCXsibWF4X3BhcmFsbGVs X21haW50ZW5hbmNlX3dvcmtlcnMiLCBQR0NfVVNFUlNFVCwgUkVTT1VSQ0VTX1dPUktFUl9QUk9D RVNTRVMsCiAJCQlnZXR0ZXh0X25vb3AoIlNldHMgdGhlIG1heGltdW0gbnVtYmVyIG9mIHBhcmFs bGVsIHByb2Nlc3NlcyBwZXIgbWFpbnRlbmFuY2Ugb3BlcmF0aW9uLiIpLApkaWZmIC0tZ2l0IGEv c3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9wb3N0Z3Jlc3FsLmNvbmYuc2FtcGxlIGIvc3JjL2JhY2tl bmQvdXRpbHMvbWlzYy9wb3N0Z3Jlc3FsLmNvbmYuc2FtcGxlCmluZGV4IDM0ODI2ZDAxMzgwLi4z ZDk2YWYxNTQ3ZiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9wb3N0Z3Jlc3Fs LmNvbmYuc2FtcGxlCisrKyBiL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvcG9zdGdyZXNxbC5jb25m LnNhbXBsZQpAQCAtMjIzLDYgKzIyMyw3IEBACiAjbWF4X3BhcmFsbGVsX21haW50ZW5hbmNlX3dv cmtlcnMgPSAyCSMgbGltaXRlZCBieSBtYXhfcGFyYWxsZWxfd29ya2VycwogI21heF9wYXJhbGxl bF93b3JrZXJzID0gOAkJIyBudW1iZXIgb2YgbWF4X3dvcmtlcl9wcm9jZXNzZXMgdGhhdAogCQkJ CQkjIGNhbiBiZSB1c2VkIGluIHBhcmFsbGVsIG9wZXJhdGlvbnMKKyNwYXJhbGxlbF9pbmRleF9h dXRvdmFjdXVtX3Jlc2VydmVkX3dvcmtlcnMgPSAwCSMgZGlzYWJsZWQgYnkgZGVmYXVsdCBhbmQg bGltaXRlZCBieSBtYXhfcGFyYWxsZWxfd29ya2VycwogI3BhcmFsbGVsX2xlYWRlcl9wYXJ0aWNp cGF0aW9uID0gb24KIAogCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9taXNjYWRtaW4uaCBiL3Ny Yy9pbmNsdWRlL21pc2NhZG1pbi5oCmluZGV4IDFlNTlhN2Y5MTBmLi40NjVkZmUyNTAwOSAxMDA2 NDQKLS0tIGEvc3JjL2luY2x1ZGUvbWlzY2FkbWluLmgKKysrIGIvc3JjL2luY2x1ZGUvbWlzY2Fk bWluLmgKQEAgLTE3Nyw2ICsxNzcsNyBAQCBleHRlcm4gUEdETExJTVBPUlQgaW50IE5CdWZmZXJz OwogZXh0ZXJuIFBHRExMSU1QT1JUIGludCBNYXhCYWNrZW5kczsKIGV4dGVybiBQR0RMTElNUE9S VCBpbnQgTWF4Q29ubmVjdGlvbnM7CiBleHRlcm4gUEdETExJTVBPUlQgaW50IG1heF93b3JrZXJf cHJvY2Vzc2VzOworZXh0ZXJuIFBHRExMSU1QT1JUIGludCBwaWFfcmVzZXJ2ZWRfd29ya2VyczsK IGV4dGVybiBQR0RMTElNUE9SVCBpbnQgbWF4X3BhcmFsbGVsX3dvcmtlcnM7CiAKIGV4dGVybiBQ R0RMTElNUE9SVCBpbnQgY29tbWl0X3RpbWVzdGFtcF9idWZmZXJzOwpkaWZmIC0tZ2l0IGEvc3Jj L2luY2x1ZGUvdXRpbHMvZ3VjX2hvb2tzLmggYi9zcmMvaW5jbHVkZS91dGlscy9ndWNfaG9va3Mu aAppbmRleCA3OTlmYTdhY2U2OC4uODUwN2Y5NWIyZWEgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRl L3V0aWxzL2d1Y19ob29rcy5oCisrKyBiL3NyYy9pbmNsdWRlL3V0aWxzL2d1Y19ob29rcy5oCkBA IC0zMSw2ICszMSw4IEBAIGV4dGVybiB2b2lkIGFzc2lnbl9hcHBsaWNhdGlvbl9uYW1lKGNvbnN0 IGNoYXIgKm5ld3ZhbCwgdm9pZCAqZXh0cmEpOwogZXh0ZXJuIGNvbnN0IGNoYXIgKnNob3dfYXJj aGl2ZV9jb21tYW5kKHZvaWQpOwogZXh0ZXJuIGJvb2wgY2hlY2tfYXV0b3ZhY3V1bV93b3JrX21l bShpbnQgKm5ld3ZhbCwgdm9pZCAqKmV4dHJhLAogCQkJCQkJCQkJICBHdWNTb3VyY2Ugc291cmNl KTsKK2V4dGVybiBib29sIGNoZWNrX3BpYV9yZXNlcnZlZF93b3JrZXJzKGludCAqbmV3dmFsLCB2 b2lkICoqZXh0cmEsCisJCQkJCQkJCQkgICBHdWNTb3VyY2Ugc291cmNlKTsKIGV4dGVybiBib29s IGNoZWNrX3ZhY3V1bV9idWZmZXJfdXNhZ2VfbGltaXQoaW50ICpuZXd2YWwsIHZvaWQgKipleHRy YSwKIAkJCQkJCQkJCQkJR3VjU291cmNlIHNvdXJjZSk7CiBleHRlcm4gYm9vbCBjaGVja19iYWNr dHJhY2VfZnVuY3Rpb25zKGNoYXIgKipuZXd2YWwsIHZvaWQgKipleHRyYSwKZGlmZiAtLWdpdCBh L3NyYy9pbmNsdWRlL3V0aWxzL3JlbC5oIGIvc3JjL2luY2x1ZGUvdXRpbHMvcmVsLmgKaW5kZXgg YjU1MjM1OTkxNWYuLjk4MGMzNDU5NDY5IDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS91dGlscy9y ZWwuaAorKysgYi9zcmMvaW5jbHVkZS91dGlscy9yZWwuaApAQCAtMzExLDYgKzMxMSw3IEBAIHR5 cGVkZWYgc3RydWN0IEZvcmVpZ25LZXlDYWNoZUluZm8KIHR5cGVkZWYgc3RydWN0IEF1dG9WYWNP cHRzCiB7CiAJYm9vbAkJZW5hYmxlZDsKKwlib29sCQlwYXJhbGxlbF9pbmRleF9hdXRvdmFjdXVt X2VuYWJsZWQ7CiAJaW50CQkJdmFjdXVtX3RocmVzaG9sZDsKIAlpbnQJCQl2YWN1dW1fbWF4X3Ro cmVzaG9sZDsKIAlpbnQJCQl2YWN1dW1faW5zX3RocmVzaG9sZDsKQEAgLTQwOSw2ICs0MTAsMTUg QEAgdHlwZWRlZiBzdHJ1Y3QgU3RkUmRPcHRpb25zCiAJKChyZWxhdGlvbiktPnJkX29wdGlvbnMg PyBcCiAJICgoU3RkUmRPcHRpb25zICopIChyZWxhdGlvbiktPnJkX29wdGlvbnMpLT5wYXJhbGxl bF93b3JrZXJzIDogKGRlZmF1bHRwdykpCiAKKy8qCisgKiBSZWxhdGlvbkFsbG93c1BhcmFsbGVs SWR4QXV0b3ZhYworICoJCVJldHVybnMgd2hldGhlciB0aGUgcmVsYXRpb24ncyBpbmRleGVzIGNh biBiZSBwcm9jZXNzZWQgaW4gcGFyYWxsZWwKKyAqCQlkdXJpbmcgYXV0b3ZhY3V1bS4gTm90ZSBt dWx0aXBsZSBldmFsIG9mIGFyZ3VtZW50IQorICovCisjZGVmaW5lIFJlbGF0aW9uQWxsb3dzUGFy YWxsZWxJZHhBdXRvdmFjKHJlbGF0aW9uKSBcCisJKChyZWxhdGlvbiktPnJkX29wdGlvbnMgPyBc CisJICgoU3RkUmRPcHRpb25zICopIChyZWxhdGlvbiktPnJkX29wdGlvbnMpLT5hdXRvdmFjdXVt LnBhcmFsbGVsX2luZGV4X2F1dG92YWN1dW1fZW5hYmxlZCA6IGZhbHNlKQorCiAvKiBWaWV3T3B0 aW9ucy0+Y2hlY2tfb3B0aW9uIHZhbHVlcyAqLwogdHlwZWRlZiBlbnVtIFZpZXdPcHRDaGVja09w dGlvbgogewotLSAKMi40My4wCgo= --0000000000009e25860635b4a5ed Content-Type: text/x-patch; charset="US-ASCII"; name="v3-0002-Sandbox-for-parallel-index-autovacuum.patch" Content-Disposition: attachment; filename="v3-0002-Sandbox-for-parallel-index-autovacuum.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_maz2dh0x1 RnJvbSBkMTdhMDFlZjJhY2U1ZmM2Y2ZkMWQyMjkzMDQ1NGQ5MGNmYmU2M2RkIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBGcmksIDE2IE1heSAyMDI1IDExOjU5OjAzICswNzAwClN1YmplY3Q6IFtQQVRD SCB2MyAyLzJdIFNhbmRib3ggZm9yIHBhcmFsbGVsIGluZGV4IGF1dG92YWN1dW0KCi0tLQogc3Jj L3Rlc3QvbW9kdWxlcy9NYWtlZmlsZSAgICAgICAgICAgICAgICAgICAgIHwgICAxICsKIHNyYy90 ZXN0L21vZHVsZXMvYXV0b3ZhY3V1bS8uZ2l0aWdub3JlICAgICAgICB8ICAgMSArCiBzcmMvdGVz dC9tb2R1bGVzL2F1dG92YWN1dW0vTWFrZWZpbGUgICAgICAgICAgfCAgMTQgKysKIHNyYy90ZXN0 L21vZHVsZXMvYXV0b3ZhY3V1bS9tZXNvbi5idWlsZCAgICAgICB8ICAxMiArKwogLi4uL2F1dG92 YWN1dW0vdC8wMDFfYXV0b3ZhY19wYXJhbGxlbC5wbCAgICAgIHwgMTI5ICsrKysrKysrKysrKysr KysrKwogc3JjL3Rlc3QvbW9kdWxlcy9tZXNvbi5idWlsZCAgICAgICAgICAgICAgICAgIHwgICAx ICsKIDYgZmlsZXMgY2hhbmdlZCwgMTU4IGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0 NCBzcmMvdGVzdC9tb2R1bGVzL2F1dG92YWN1dW0vLmdpdGlnbm9yZQogY3JlYXRlIG1vZGUgMTAw NjQ0IHNyYy90ZXN0L21vZHVsZXMvYXV0b3ZhY3V1bS9NYWtlZmlsZQogY3JlYXRlIG1vZGUgMTAw NjQ0IHNyYy90ZXN0L21vZHVsZXMvYXV0b3ZhY3V1bS9tZXNvbi5idWlsZAogY3JlYXRlIG1vZGUg MTAwNjQ0IHNyYy90ZXN0L21vZHVsZXMvYXV0b3ZhY3V1bS90LzAwMV9hdXRvdmFjX3BhcmFsbGVs LnBsCgpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvbW9kdWxlcy9NYWtlZmlsZSBiL3NyYy90ZXN0L21v ZHVsZXMvTWFrZWZpbGUKaW5kZXggYWExZDI3YmJlZDMuLmI3ZjNlMzQyZTgyIDEwMDY0NAotLS0g YS9zcmMvdGVzdC9tb2R1bGVzL01ha2VmaWxlCisrKyBiL3NyYy90ZXN0L21vZHVsZXMvTWFrZWZp bGUKQEAgLTUsNiArNSw3IEBAIHRvcF9idWlsZGRpciA9IC4uLy4uLy4uCiBpbmNsdWRlICQodG9w X2J1aWxkZGlyKS9zcmMvTWFrZWZpbGUuZ2xvYmFsCiAKIFNVQkRJUlMgPSBcCisJCSAgYXV0b3Zh Y3V1bSBcCiAJCSAgYnJpbiBcCiAJCSAgY29tbWl0X3RzIFwKIAkJICBkZWxheV9leGVjdXRpb24g XApkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvbW9kdWxlcy9hdXRvdmFjdXVtLy5naXRpZ25vcmUgYi9z cmMvdGVzdC9tb2R1bGVzL2F1dG92YWN1dW0vLmdpdGlnbm9yZQpuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwMDAwMC4uMGI1NDY0MWJjZWIKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMv dGVzdC9tb2R1bGVzL2F1dG92YWN1dW0vLmdpdGlnbm9yZQpAQCAtMCwwICsxIEBACisvdG1wX2No ZWNrLwpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL3NyYy90ZXN0L21v ZHVsZXMvYXV0b3ZhY3V1bS9NYWtlZmlsZSBiL3NyYy90ZXN0L21vZHVsZXMvYXV0b3ZhY3V1bS9N YWtlZmlsZQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMC4uOTBjMDBmZjM1 MGIKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvdGVzdC9tb2R1bGVzL2F1dG92YWN1dW0vTWFrZWZp bGUKQEAgLTAsMCArMSwxNCBAQAorIyBzcmMvdGVzdC9tb2R1bGVzL2F1dG92YWN1dW0vTWFrZWZp bGUKKworVEFQX1RFU1RTID0gMQorCitpZmRlZiBVU0VfUEdYUworUEdfQ09ORklHID0gcGdfY29u ZmlnCitQR1hTIDo9ICQoc2hlbGwgJChQR19DT05GSUcpIC0tcGd4cykKK2luY2x1ZGUgJChQR1hT KQorZWxzZQorc3ViZGlyID0gc3JjL3Rlc3QvbW9kdWxlcy9hdXRvdmFjdXVtCit0b3BfYnVpbGRk aXIgPSAuLi8uLi8uLi8uLgoraW5jbHVkZSAkKHRvcF9idWlsZGRpcikvc3JjL01ha2VmaWxlLmds b2JhbAoraW5jbHVkZSAkKHRvcF9zcmNkaXIpL2NvbnRyaWIvY29udHJpYi1nbG9iYWwubWsKK2Vu ZGlmClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvbW9k dWxlcy9hdXRvdmFjdXVtL21lc29uLmJ1aWxkIGIvc3JjL3Rlc3QvbW9kdWxlcy9hdXRvdmFjdXVt L21lc29uLmJ1aWxkCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi5mOTFj MWExNGQyYgotLS0gL2Rldi9udWxsCisrKyBiL3NyYy90ZXN0L21vZHVsZXMvYXV0b3ZhY3V1bS9t ZXNvbi5idWlsZApAQCAtMCwwICsxLDEyIEBACisjIENvcHlyaWdodCAoYykgMjAyMi0yMDI1LCBQ b3N0Z3JlU1FMIEdsb2JhbCBEZXZlbG9wbWVudCBHcm91cAorCit0ZXN0cyArPSB7CisgICduYW1l JzogJ2F1dG92YWN1dW0nLAorICAnc2QnOiBtZXNvbi5jdXJyZW50X3NvdXJjZV9kaXIoKSwKKyAg J2JkJzogbWVzb24uY3VycmVudF9idWlsZF9kaXIoKSwKKyAgJ3RhcCc6IHsKKyAgICAndGVzdHMn OiBbCisgICAgICAndC8wMDFfYXV0b3ZhY19wYXJhbGxlbC5wbCcsCisgICAgXSwKKyAgfSwKK30K ZGlmZiAtLWdpdCBhL3NyYy90ZXN0L21vZHVsZXMvYXV0b3ZhY3V1bS90LzAwMV9hdXRvdmFjX3Bh cmFsbGVsLnBsIGIvc3JjL3Rlc3QvbW9kdWxlcy9hdXRvdmFjdXVtL3QvMDAxX2F1dG92YWNfcGFy YWxsZWwucGwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLjVhZWEzZjEw ZTM4Ci0tLSAvZGV2L251bGwKKysrIGIvc3JjL3Rlc3QvbW9kdWxlcy9hdXRvdmFjdXVtL3QvMDAx X2F1dG92YWNfcGFyYWxsZWwucGwKQEAgLTAsMCArMSwxMjkgQEAKK3VzZSB3YXJuaW5ncyBGQVRB TCA9PiAnYWxsJzsKK3VzZSBQb3N0Z3JlU1FMOjpUZXN0OjpDbHVzdGVyOwordXNlIFBvc3RncmVT UUw6OlRlc3Q6OlV0aWxzOwordXNlIFRlc3Q6Ok1vcmU7CisKK215ICRwc3FsX291dDsKKworbXkg JG5vZGUgPSBQb3N0Z3JlU1FMOjpUZXN0OjpDbHVzdGVyLT5uZXcoJ25vZGUxJyk7Ciskbm9kZS0+ aW5pdDsKKyRub2RlLT5hcHBlbmRfY29uZigncG9zdGdyZXNxbC5jb25mJywgcXF7CisJYXV0b3Zh Y3V1bSA9IG9mZgorCW1heF93YWxfc2l6ZSA9IDQwOTYKKwltYXhfd29ya2VyX3Byb2Nlc3NlcyA9 IDIwCisJbWF4X3BhcmFsbGVsX3dvcmtlcnMgPSAyMAorCW1heF9wYXJhbGxlbF9tYWludGVuYW5j ZV93b3JrZXJzID0gMjAKKwlwYXJhbGxlbF9pbmRleF9hdXRvdmFjdXVtX3Jlc2VydmVkX3dvcmtl cnMgPSAxCit9KTsKKyRub2RlLT5zdGFydDsKKworbXkgJGluZGV4ZXNfbnVtID0gODA7CitteSAk aW5pdGlhbF9yb3dzX251bSA9IDEwMF8wMDA7CisKKyMgQ3JlYXRlIGJpZyB0YWJsZSBhbmQgY3Jl YXRlIHNwZWNpZmllZCBudW1iZXIgb2YgYi10cmVlIGluZGV4ZXMgb24gaXQKKyRub2RlLT5zYWZl X3BzcWwoJ3Bvc3RncmVzJywgcXF7CisJQ1JFQVRFIFRBQkxFIHRlc3RfYXV0b3ZhYyAoCisJCWlk IFNFUklBTCBQUklNQVJZIEtFWSwKKwkJY29sXzEgSU5URUdFUiwgIGNvbF8yIElOVEVHRVIsICBj b2xfMyBJTlRFR0VSLCAgY29sXzQgSU5URUdFUiwgIGNvbF81IElOVEVHRVIsCisJCWNvbF82IElO VEVHRVIsICBjb2xfNyBJTlRFR0VSLCAgY29sXzggSU5URUdFUiwgIGNvbF85IElOVEVHRVIsICBj b2xfMTAgSU5URUdFUiwKKwkJY29sXzExIElOVEVHRVIsIGNvbF8xMiBJTlRFR0VSLCBjb2xfMTMg SU5URUdFUiwgY29sXzE0IElOVEVHRVIsIGNvbF8xNSBJTlRFR0VSLAorCQljb2xfMTYgSU5URUdF UiwgY29sXzE3IElOVEVHRVIsIGNvbF8xOCBJTlRFR0VSLCBjb2xfMTkgSU5URUdFUiwgY29sXzIw IElOVEVHRVIsCisJCWNvbF8yMSBJTlRFR0VSLCBjb2xfMjIgSU5URUdFUiwgY29sXzIzIElOVEVH RVIsIGNvbF8yNCBJTlRFR0VSLCBjb2xfMjUgSU5URUdFUiwKKwkJY29sXzI2IElOVEVHRVIsIGNv bF8yNyBJTlRFR0VSLCBjb2xfMjggSU5URUdFUiwgY29sXzI5IElOVEVHRVIsIGNvbF8zMCBJTlRF R0VSLAorCQljb2xfMzEgSU5URUdFUiwgY29sXzMyIElOVEVHRVIsIGNvbF8zMyBJTlRFR0VSLCBj b2xfMzQgSU5URUdFUiwgY29sXzM1IElOVEVHRVIsCisJCWNvbF8zNiBJTlRFR0VSLCBjb2xfMzcg SU5URUdFUiwgY29sXzM4IElOVEVHRVIsIGNvbF8zOSBJTlRFR0VSLCBjb2xfNDAgSU5URUdFUiwK KwkJY29sXzQxIElOVEVHRVIsIGNvbF80MiBJTlRFR0VSLCBjb2xfNDMgSU5URUdFUiwgY29sXzQ0 IElOVEVHRVIsIGNvbF80NSBJTlRFR0VSLAorCQljb2xfNDYgSU5URUdFUiwgY29sXzQ3IElOVEVH RVIsIGNvbF80OCBJTlRFR0VSLCBjb2xfNDkgSU5URUdFUiwgY29sXzUwIElOVEVHRVIsCisJCWNv bF81MSBJTlRFR0VSLCBjb2xfNTIgSU5URUdFUiwgY29sXzUzIElOVEVHRVIsIGNvbF81NCBJTlRF R0VSLCBjb2xfNTUgSU5URUdFUiwKKwkJY29sXzU2IElOVEVHRVIsIGNvbF81NyBJTlRFR0VSLCBj b2xfNTggSU5URUdFUiwgY29sXzU5IElOVEVHRVIsIGNvbF82MCBJTlRFR0VSLAorCQljb2xfNjEg SU5URUdFUiwgY29sXzYyIElOVEVHRVIsIGNvbF82MyBJTlRFR0VSLCBjb2xfNjQgSU5URUdFUiwg Y29sXzY1IElOVEVHRVIsCisJCWNvbF82NiBJTlRFR0VSLCBjb2xfNjcgSU5URUdFUiwgY29sXzY4 IElOVEVHRVIsIGNvbF82OSBJTlRFR0VSLCBjb2xfNzAgSU5URUdFUiwKKwkJY29sXzcxIElOVEVH RVIsIGNvbF83MiBJTlRFR0VSLCBjb2xfNzMgSU5URUdFUiwgY29sXzc0IElOVEVHRVIsIGNvbF83 NSBJTlRFR0VSLAorCQljb2xfNzYgSU5URUdFUiwgY29sXzc3IElOVEVHRVIsIGNvbF83OCBJTlRF R0VSLCBjb2xfNzkgSU5URUdFUiwgY29sXzgwIElOVEVHRVIsCisJCWNvbF84MSBJTlRFR0VSLCBj b2xfODIgSU5URUdFUiwgY29sXzgzIElOVEVHRVIsIGNvbF84NCBJTlRFR0VSLCBjb2xfODUgSU5U RUdFUiwKKwkJY29sXzg2IElOVEVHRVIsIGNvbF84NyBJTlRFR0VSLCBjb2xfODggSU5URUdFUiwg Y29sXzg5IElOVEVHRVIsIGNvbF85MCBJTlRFR0VSLAorCQljb2xfOTEgSU5URUdFUiwgY29sXzky IElOVEVHRVIsIGNvbF85MyBJTlRFR0VSLCBjb2xfOTQgSU5URUdFUiwgY29sXzk1IElOVEVHRVIs CisJCWNvbF85NiBJTlRFR0VSLCBjb2xfOTcgSU5URUdFUiwgY29sXzk4IElOVEVHRVIsIGNvbF85 OSBJTlRFR0VSLCBjb2xfMTAwIElOVEVHRVIKKwkpIFdJVEggKHBhcmFsbGVsX2lkeF9hdXRvdmFj X2VuYWJsZWQgPSB0cnVlKTsKKworCURPIFwkXCQKKwlERUNMQVJFCisJCWkgSU5URUdFUjsKKwlC RUdJTgorCQlGT1IgaSBJTiAxLi4kaW5kZXhlc19udW0gTE9PUAorCQkJRVhFQ1VURSBmb3JtYXQo J0NSRUFURSBJTkRFWCBpZHhfY29sX1wlcyBPTiB0ZXN0X2F1dG92YWMgKGNvbF9cJXMpOycsIGks IGkpOworCQlFTkQgTE9PUDsKKwlFTkQgXCRcJDsKK30pOworCiskbm9kZS0+cHNxbCgncG9zdGdy ZXMnLAorCSJTRUxFQ1QgQ09VTlQoKikgRlJPTSBwZ19pbmRleCBpCisJICAgSk9JTiBwZ19jbGFz cyBjIE9OIGMub2lkID0gaS5pbmRyZWxpZAorCSAgV0hFUkUgYy5yZWxuYW1lID0gJ3Rlc3RfYXV0 b3ZhYyc7IiwKKwlzdGRvdXQgPT4gXCRwc3FsX291dAorKTsKK2lzKCRwc3FsX291dCwgJGluZGV4 ZXNfbnVtICsgMSwgIkFsbCBpbmRleGVzIGNyZWF0ZWQgc3VjY2Vzc2Z1bGx5Iik7CisKKyRub2Rl LT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgcXF7CisJRE8gXCRcJAorCURFQ0xBUkUKKwkgICAgaSBJ TlRFR0VSOworCUJFR0lOCisJICAgIEZPUiBpIElOIDEuLiRpbml0aWFsX3Jvd3NfbnVtIExPT1AK KwkgICAgICAgIElOU0VSVCBJTlRPIHRlc3RfYXV0b3ZhYyAoCisJICAgICAgICAgICAgY29sXzEs IGNvbF8yLCBjb2xfMywgY29sXzQsIGNvbF81LCBjb2xfNiwgY29sXzcsIGNvbF84LCBjb2xfOSwg Y29sXzEwLAorCSAgICAgICAgICAgIGNvbF8xMSwgY29sXzEyLCBjb2xfMTMsIGNvbF8xNCwgY29s XzE1LCBjb2xfMTYsIGNvbF8xNywgY29sXzE4LCBjb2xfMTksIGNvbF8yMCwKKwkgICAgICAgICAg ICBjb2xfMjEsIGNvbF8yMiwgY29sXzIzLCBjb2xfMjQsIGNvbF8yNSwgY29sXzI2LCBjb2xfMjcs IGNvbF8yOCwgY29sXzI5LCBjb2xfMzAsCisJICAgICAgICAgICAgY29sXzMxLCBjb2xfMzIsIGNv bF8zMywgY29sXzM0LCBjb2xfMzUsIGNvbF8zNiwgY29sXzM3LCBjb2xfMzgsIGNvbF8zOSwgY29s XzQwLAorCSAgICAgICAgICAgIGNvbF80MSwgY29sXzQyLCBjb2xfNDMsIGNvbF80NCwgY29sXzQ1 LCBjb2xfNDYsIGNvbF80NywgY29sXzQ4LCBjb2xfNDksIGNvbF81MCwKKwkgICAgICAgICAgICBj b2xfNTEsIGNvbF81MiwgY29sXzUzLCBjb2xfNTQsIGNvbF81NSwgY29sXzU2LCBjb2xfNTcsIGNv bF81OCwgY29sXzU5LCBjb2xfNjAsCisJICAgICAgICAgICAgY29sXzYxLCBjb2xfNjIsIGNvbF82 MywgY29sXzY0LCBjb2xfNjUsIGNvbF82NiwgY29sXzY3LCBjb2xfNjgsIGNvbF82OSwgY29sXzcw LAorCSAgICAgICAgICAgIGNvbF83MSwgY29sXzcyLCBjb2xfNzMsIGNvbF83NCwgY29sXzc1LCBj b2xfNzYsIGNvbF83NywgY29sXzc4LCBjb2xfNzksIGNvbF84MCwKKwkgICAgICAgICAgICBjb2xf ODEsIGNvbF84MiwgY29sXzgzLCBjb2xfODQsIGNvbF84NSwgY29sXzg2LCBjb2xfODcsIGNvbF84 OCwgY29sXzg5LCBjb2xfOTAsCisJICAgICAgICAgICAgY29sXzkxLCBjb2xfOTIsIGNvbF85Mywg Y29sXzk0LCBjb2xfOTUsIGNvbF85NiwgY29sXzk3LCBjb2xfOTgsIGNvbF85OSwgY29sXzEwMAor CSAgICAgICAgKSBWQUxVRVMgKAorCSAgICAgICAgICAgIGksIGkgKyAxLCBpICsgMiwgaSArIDMs IGkgKyA0LCBpICsgNSwgaSArIDYsIGkgKyA3LCBpICsgOCwgaSArIDksCisJICAgICAgICAgICAg aSArIDEwLCBpICsgMTEsIGkgKyAxMiwgaSArIDEzLCBpICsgMTQsIGkgKyAxNSwgaSArIDE2LCBp ICsgMTcsIGkgKyAxOCwgaSArIDE5LAorCSAgICAgICAgICAgIGkgKyAyMCwgaSArIDIxLCBpICsg MjIsIGkgKyAyMywgaSArIDI0LCBpICsgMjUsIGkgKyAyNiwgaSArIDI3LCBpICsgMjgsIGkgKyAy OSwKKwkgICAgICAgICAgICBpICsgMzAsIGkgKyAzMSwgaSArIDMyLCBpICsgMzMsIGkgKyAzNCwg aSArIDM1LCBpICsgMzYsIGkgKyAzNywgaSArIDM4LCBpICsgMzksCisJICAgICAgICAgICAgaSAr IDQwLCBpICsgNDEsIGkgKyA0MiwgaSArIDQzLCBpICsgNDQsIGkgKyA0NSwgaSArIDQ2LCBpICsg NDcsIGkgKyA0OCwgaSArIDQ5LAorCSAgICAgICAgICAgIGkgKyA1MCwgaSArIDUxLCBpICsgNTIs IGkgKyA1MywgaSArIDU0LCBpICsgNTUsIGkgKyA1NiwgaSArIDU3LCBpICsgNTgsIGkgKyA1OSwK KwkgICAgICAgICAgICBpICsgNjAsIGkgKyA2MSwgaSArIDYyLCBpICsgNjMsIGkgKyA2NCwgaSAr IDY1LCBpICsgNjYsIGkgKyA2NywgaSArIDY4LCBpICsgNjksCisJICAgICAgICAgICAgaSArIDcw LCBpICsgNzEsIGkgKyA3MiwgaSArIDczLCBpICsgNzQsIGkgKyA3NSwgaSArIDc2LCBpICsgNzcs IGkgKyA3OCwgaSArIDc5LAorCSAgICAgICAgICAgIGkgKyA4MCwgaSArIDgxLCBpICsgODIsIGkg KyA4MywgaSArIDg0LCBpICsgODUsIGkgKyA4NiwgaSArIDg3LCBpICsgODgsIGkgKyA4OSwKKwkg ICAgICAgICAgICBpICsgOTAsIGkgKyA5MSwgaSArIDkyLCBpICsgOTMsIGkgKyA5NCwgaSArIDk1 LCBpICsgOTYsIGkgKyA5NywgaSArIDk4LCBpICsgOTkKKwkgICAgICAgICk7CisJICAgIEVORCBM T09QOworCUVORCBcJFwkOworfSk7CisKKyRub2RlLT5wc3FsKCdwb3N0Z3JlcycsCisJIlNFTEVD VCBDT1VOVCgqKSBGUk9NIHRlc3RfYXV0b3ZhYzsiLAorCXN0ZG91dCA9PiBcJHBzcWxfb3V0Cisp OworaXMoJHBzcWxfb3V0LCAkaW5pdGlhbF9yb3dzX251bSwgIkFsbCBkYXRhIGluc2VydGVkIGlu dG8gdGFibGUgc3VjY2Vzc2Z1bGx5Iik7CisKKyRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywg cXF7CisJVVBEQVRFIHRlc3RfYXV0b3ZhYyBTRVQgY29sXzEgPSAwIFdIRVJFIChjb2xfMSAlIDMp ID0gMDsKKwlBTkFMWVpFIHRlc3RfYXV0b3ZhYzsKK30pOworCisjIFJlZHVjZSBhdXRvdmFjdXVt X3dvcmtfbWVtLCBzbyBsZWFkZXIgcHJvY2VzcyB3aWxsIHBlcmZvcm0gcGFyYWxsZWwgaW5kZXhp CisjIHZhY3V1bSBwaGFzZSBzZXZlcmFsIHRpbWVzCiskbm9kZS0+YXBwZW5kX2NvbmYoJ3Bvc3Rn cmVzcWwuY29uZicsIHFxeworCWF1dG92YWN1dW1fbmFwdGltZSA9ICcxcycKKwlhdXRvdmFjdXVt X3ZhY3V1bV90aHJlc2hvbGQgPSAxCisJYXV0b3ZhY3V1bV9hbmFseXplX3RocmVzaG9sZCA9IDEK KwlhdXRvdmFjdXVtX3ZhY3V1bV9zY2FsZV9mYWN0b3IgPSAwLjEKKwlhdXRvdmFjdXVtX2FuYWx5 emVfc2NhbGVfZmFjdG9yID0gMC4xCisJYXV0b3ZhY3V1bSA9IG9uCit9KTsKKworJG5vZGUtPnJl c3RhcnQ7CisKKyMgc2xlZXAoMzYwMCk7CisKK29rKDEsICJUaGVyZSBhcmUgbm8gc2VnZmF1bHRz Iik7CisKKyRub2RlLT5zdG9wOworZG9uZV90ZXN0aW5nKCk7CmRpZmYgLS1naXQgYS9zcmMvdGVz dC9tb2R1bGVzL21lc29uLmJ1aWxkIGIvc3JjL3Rlc3QvbW9kdWxlcy9tZXNvbi5idWlsZAppbmRl eCA5ZGUwMDU3YmQxZC4uN2YyYWQ4MTBjYTAgMTAwNjQ0Ci0tLSBhL3NyYy90ZXN0L21vZHVsZXMv bWVzb24uYnVpbGQKKysrIGIvc3JjL3Rlc3QvbW9kdWxlcy9tZXNvbi5idWlsZApAQCAtMSw1ICsx LDYgQEAKICMgQ29weXJpZ2h0IChjKSAyMDIyLTIwMjUsIFBvc3RncmVTUUwgR2xvYmFsIERldmVs b3BtZW50IEdyb3VwCiAKK3N1YmRpcignYXV0b3ZhY3V1bScpCiBzdWJkaXIoJ2JyaW4nKQogc3Vi ZGlyKCdjb21taXRfdHMnKQogc3ViZGlyKCdkZWxheV9leGVjdXRpb24nKQotLSAKMi40My4wCgo= --0000000000009e25860635b4a5ed--