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 1uJF3u-001Jf8-IW for pgsql-hackers@arkaria.postgresql.org; Sun, 25 May 2025 17:23:02 +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 1uJF3r-000UXF-U6 for pgsql-hackers@arkaria.postgresql.org; Sun, 25 May 2025 17:22:59 +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 1uJF3r-000UX7-Ej for pgsql-hackers@lists.postgresql.org; Sun, 25 May 2025 17:22:59 +0000 Received: from mail-yb1-xb2e.google.com ([2607:f8b0:4864:20::b2e]) 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 1uJF3n-0003T9-1o for pgsql-hackers@lists.postgresql.org; Sun, 25 May 2025 17:22:58 +0000 Received: by mail-yb1-xb2e.google.com with SMTP id 3f1490d57ef6-e7da099de49so456018276.2 for ; Sun, 25 May 2025 10:22:55 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1748193774; x=1748798574; 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=7o46JAmS2+k40ZYqNRmnwmddqEAmw2Jyb3/0raixHT0=; b=NWxCoCzDgBuZYbjWCpv8qq38iQMMMy+Ofnghvn638vsYsljX+l/cwANHapphnJjloF 7wY005fKIS1G5wq+DP6xrVJ9MU2LIqsIRv8GgKUcGkl7RBvXq3B33OsZdjn7VrXxDdhJ 5WUW3N5cSlSINeckTis2ctpaeutRZHstrsXEd8KWe8VTfJ7Izye32SBMCKm4kVZjAH15 Iul8GiQx7DZtgbyGDDExLgUeCsUpevy+S5Nwk6mXWKTMK4+Jc2HWWBOJ+c+TccHdWi/i IwuUU4ysMo7ydJqYdP3hIYFLwncEqNs7H2llJqIxMMoW3F216qDFhYfaPhJIop0LMgRF KlSg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1748193774; x=1748798574; 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=7o46JAmS2+k40ZYqNRmnwmddqEAmw2Jyb3/0raixHT0=; b=HSd2PCazZtXDPgCvMoOL5s35SZ6MUx4hHv6u44K3cbeyPdJW/VN4ktCTgNWJOUWSmg oSoLmwnjtLphvvvUq+v3fApxCtEIule90j0hHRtYk+ZoVGpBpZoeBouXzP41bEMFnFWV 8Qp203bXZRvwzn7mgnSneFGedH/yAlASi6BfvLy5tIIjH1ohR8mv/Ul2moXyHVsC2iMh Pel/fmHvfEm+s8wSsmOEJF/kLYzv3AY8J4RiwmnC8CSfI8HC2SMLePmtR6cb/jhnCcGo tETbcYunzjXGkivGTTYStuKOv173Bwk5PkmJRJyxCwzGTaBFS7bjFe5JedwATWBmnnxh kSjg== X-Forwarded-Encrypted: i=1; AJvYcCVuIPqTLodqatnPBIi0q2sQwsT5lzdQXPB15xl9qvbRuskOIJdXcLIQwwGBJiD0X3XtcxP17X+78hGbqL51@lists.postgresql.org X-Gm-Message-State: AOJu0Yw5Z5KxRtSuzVnv7ae/8wZUoV8jFu0eb01WOI2yZHlHlYm6eUPe jQzcjpBDUaYkZ7BARvc1SFljp9+YMBw73SoZCr1FOlH6hGePg1PB/7WaTpyQuGt7A6pmHir+X60 d+Rky88ksUltnNUTTlxEFqMoJ7cm9VktIsg== X-Gm-Gg: ASbGncv0EyLEX5E9DqmUKTyQam506BuI4eiGoqi3vj6ZQIu388fTIth3BdtJmmNI/HA veLQaov0nckSREu001iIduQmDDgskqIBDN34DiRM2Nh0tVI2iOqFDMzjAcg6Z6j6XUEakxO6/QH vXljMmWyOfpabljoWQtr5iizbcy5yGrLnBEw== X-Google-Smtp-Source: AGHT+IEEmGJ8bgf06v+A8NrEz+ah1oJC17/zd30JNtEI2W4aCzdB+wtELJWXvuctY3kjBUb7rIOzxokX7Ei88g9vXXw= X-Received: by 2002:a05:6902:120f:b0:e73:520:ab44 with SMTP id 3f1490d57ef6-e7d919abe88mr6800295276.16.1748193774001; Sun, 25 May 2025 10:22:54 -0700 (PDT) MIME-Version: 1.0 References: In-Reply-To: From: Daniil Davydov <3danissimo@gmail.com> Date: Mon, 26 May 2025 00:22:42 +0700 X-Gm-Features: AX0GCFt_gBRrv-Uk0_R1UgdPmQeBpThanLTv9lENLCaBB4ggdBWykRT1pfNmJFk 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="000000000000e624920635f914b8" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --000000000000e624920635f914b8 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Hi, On Fri, May 23, 2025 at 6:12=E2=80=AFAM Masahiko Sawada wrote: > > On Thu, May 22, 2025 at 12:44=E2=80=AFAM Daniil Davydov <3danissimo@gmail= .com> wrote: > > > > On Wed, May 21, 2025 at 5:30=E2=80=AFAM Masahiko Sawada wrote: > > > > > > 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. > > > > This was my headache when I created names for variables. Autovacuum > > initially implies parallelism, because we have several parallel a/v > > workers. > > I'm not sure if it's parallelism. We can have multiple autovacuum > workers simultaneously working on different tables, which seems not > parallelism to me. Hm, I didn't thought about the 'parallelism' definition in this way. But I see your point - the next v4 patch will contain the naming that you suggest. > > > 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`. > > It's better not to use 'index' as we're trying to extend parallel > vacuum to heap scanning/vacuuming as well[1]. OK, I'll fix it. > > > + /* > > > + * If we are running autovacuum - decide whether we need to proce= ss indexes > > > + * 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. > > I guess that we can specify the parallel degree even if index_cleanup > is still UNSPECIFIED. vacuum_rel() would then decide whether to use > index vacuuming and vacuumlazy.c would decide whether to use parallel > vacuum based on the specified parallel degree and index_cleanup value. > > > > > > +#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. > > My point is that this criterion might not be useful. We have the > bypass optimization for index vacuuming and having many dead tuples > doesn't necessarily mean index vacuuming taking a long time. For > example, even if the table has a few dead tuples, index vacuuming > could take a very long time and parallel index vacuuming would help > the situation, if the table is very large and has many indexes. That sounds reasonable. I'll fix it. > > 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. > > I think it requires more things than the number of indexes on the > table to achieve (1). Suppose that there is a very large table that > gets updates heavily and has a few indexes. If users want to avoid the > table from being bloated, it would be a reasonable idea to use > parallel vacuum during autovacuum and it would not be a good idea to > disallow using parallel vacuum solely because it doesn't have more > than 30 indexes. On the other hand, if the table had got many updates > but not so now, users might want to use resources for autovacuums on > other tables. We might need to consider autovacuum frequencies per > table, the statistics of the previous autovacuum, or system loads etc. > So I think that in order to achieve (1) we might need more statistics > and using only NUM_INDEXES_PER_PARALLEL_WORKER would not work fine. > It's hard for me to imagine exactly how extended statistics will help us track such situations. It seems that for any of our heuristics, it will be possible to come up with a counter example. Maybe we can give advices (via logs) to the user? But for such an idea, tests should be conducted so that we can understand when resource consumption becomes ineffective. I guess that we need to agree on an implementation before conducting such t= ests. > > (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. > > Reserving some bgworkers for autovacuum could make sense. But I think > it's better to implement it in a general way as it could be useful in > other use cases too. That is, it might be a good to implement > infrastructure so that any PostgreSQL code (possibly including > extensions) can request allocating a pool of bgworkers for specific > usage and use bgworkers from them. Reserving infrastructure is an ambitious idea. I am not sure that we should implement it within this thread and feature. Maybe we should create a separate thread for it and as a justification, refer to parallel autovacuum? ----- Thanks everybody for feedback! I attach a v4 patch to this letter. Main features : 1) 'parallel_autovacuum_workers' reloption - integer value, that sets the maximum number of parallel a/v workers that can be taken from bgworkers pool in order to process this table. 2) 'max_parallel_autovacuum_workers' - GUC variable, that sets the maximum total number of parallel a/v workers, that can be taken from bgworkers pool. 3) Parallel autovacuum does not try to use thresholds like NUM_INDEXES_PER_PARALLEL_WORKER and AV_PARALLEL_DEADTUP_THRESHOLD. 4) Parallel autovacuum now can report statistics like "planned vs. launched= ". 5) For now I got rid of the 'reserving' idea, so now autovacuum leaders are competing with everyone for parallel workers from the bgworkers pool. What do you think about this implementation? -- Best regards, Daniil Davydov --000000000000e624920635f914b8 Content-Type: text/x-patch; charset="US-ASCII"; name="v4-0001-Parallel-index-autovacuum-with-bgworkers.patch" Content-Disposition: attachment; filename="v4-0001-Parallel-index-autovacuum-with-bgworkers.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mb3x6qlk0 RnJvbSBhZmEzZjRjM2Q4OTkzYjc3NTgzN2NkMDRlNWQxNzAwMTJiOWQyNjkxIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBGcmksIDE2IE1heSAyMDI1IDExOjU4OjQwICswNzAwClN1YmplY3Q6IFtQQVRD SCB2NCAxLzJdIFBhcmFsbGVsIGluZGV4IGF1dG92YWN1dW0gd2l0aCBiZ3dvcmtlcnMKCi0tLQog c3JjL2JhY2tlbmQvYWNjZXNzL2NvbW1vbi9yZWxvcHRpb25zLmMgICAgICAgIHwgMTIgKysrCiBz cmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMgICAgICAgICAgfCAgNiArLQogc3Jj L2JhY2tlbmQvYWNjZXNzL3RyYW5zYW0vcGFyYWxsZWwuYyAgICAgICAgIHwgMTEgKysrCiBzcmMv YmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jICAgICAgICAgfCA3NiArKysrKysrKysr KysrLS0tLS0tCiBzcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYyAgICAgICAgICAg fCA3NiArKysrKysrKysrKysrKysrKystCiBzcmMvYmFja2VuZC91dGlscy9pbml0L2dsb2JhbHMu YyAgICAgICAgICAgICAgfCAgMSArCiBzcmMvYmFja2VuZC91dGlscy9taXNjL2d1Y190YWJsZXMu YyAgICAgICAgICAgfCAxMCArKysKIHNyYy9iYWNrZW5kL3V0aWxzL21pc2MvcG9zdGdyZXNxbC5j b25mLnNhbXBsZSB8ICAyICsKIHNyYy9pbmNsdWRlL21pc2NhZG1pbi5oICAgICAgICAgICAgICAg ICAgICAgICB8ICAxICsKIHNyYy9pbmNsdWRlL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5oICAgICAg ICAgICB8ICA0ICsKIHNyYy9pbmNsdWRlL3V0aWxzL2d1Y19ob29rcy5oICAgICAgICAgICAgICAg ICB8ICAyICsKIHNyYy9pbmNsdWRlL3V0aWxzL3JlbC5oICAgICAgICAgICAgICAgICAgICAgICB8 IDEyICsrKwogMTIgZmlsZXMgY2hhbmdlZCwgMTg2IGluc2VydGlvbnMoKyksIDI3IGRlbGV0aW9u cygtKQoKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9jb21tb24vcmVsb3B0aW9ucy5j IGIvc3JjL2JhY2tlbmQvYWNjZXNzL2NvbW1vbi9yZWxvcHRpb25zLmMKaW5kZXggNDZjMWRjZTIy MmQuLjZiYThkYTYyNTQ2IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nlc3MvY29tbW9uL3Jl bG9wdGlvbnMuYworKysgYi9zcmMvYmFja2VuZC9hY2Nlc3MvY29tbW9uL3JlbG9wdGlvbnMuYwpA QCAtMjIyLDYgKzIyMiwxNiBAQCBzdGF0aWMgcmVsb3B0X2ludCBpbnRSZWxPcHRzW10gPQogCQl9 LAogCQlTUEdJU1RfREVGQVVMVF9GSUxMRkFDVE9SLCBTUEdJU1RfTUlOX0ZJTExGQUNUT1IsIDEw MAogCX0sCisJeworCQl7CisJCQkicGFyYWxsZWxfYXV0b3ZhY3V1bV93b3JrZXJzIiwKKwkJCSJN YXhpbXVtIG51bWJlciBvZiBwYXJhbGxlbCBhdXRvdmFjdXVtIHdvcmtlcnMgdGhhdCBjYW4gYmUg dGFrZW4gZnJvbSBiZ3dvcmtlcnMgcG9vbCBmb3IgcHJvY2Vzc2luZyB0aGlzIHRhYmxlLiAiCisJ CQkiSWYgdmFsdWUgaXMgMCB0aGVuIHBhcmFsbGVsIGRlZ3JlZSB3aWxsIGNvbXB1dGVkIGJhc2Vk IG9uIG51bWJlciBvZiBpbmRleGVzLiIsCisJCQlSRUxPUFRfS0lORF9IRUFQLAorCQkJU2hhcmVV cGRhdGVFeGNsdXNpdmVMb2NrCisJCX0sCisJCS0xLCAtMSwgMTAyNAorCX0sCiAJewogCQl7CiAJ CQkiYXV0b3ZhY3V1bV92YWN1dW1fdGhyZXNob2xkIiwKQEAgLTE4NjMsNiArMTg3Myw4IEBAIGRl ZmF1bHRfcmVsb3B0aW9ucyhEYXR1bSByZWxvcHRpb25zLCBib29sIHZhbGlkYXRlLCByZWxvcHRf a2luZCBraW5kKQogCQl7ImZpbGxmYWN0b3IiLCBSRUxPUFRfVFlQRV9JTlQsIG9mZnNldG9mKFN0 ZFJkT3B0aW9ucywgZmlsbGZhY3Rvcil9LAogCQl7ImF1dG92YWN1dW1fZW5hYmxlZCIsIFJFTE9Q VF9UWVBFX0JPT0wsCiAJCW9mZnNldG9mKFN0ZFJkT3B0aW9ucywgYXV0b3ZhY3V1bSkgKyBvZmZz ZXRvZihBdXRvVmFjT3B0cywgZW5hYmxlZCl9LAorCQl7InBhcmFsbGVsX2F1dG92YWN1dW1fd29y a2VycyIsIFJFTE9QVF9UWVBFX0lOVCwKKwkJb2Zmc2V0b2YoU3RkUmRPcHRpb25zLCBhdXRvdmFj dXVtKSArIG9mZnNldG9mKEF1dG9WYWNPcHRzLCBwYXJhbGxlbF9hdXRvdmFjdXVtX3dvcmtlcnMp fSwKIAkJeyJhdXRvdmFjdXVtX3ZhY3V1bV90aHJlc2hvbGQiLCBSRUxPUFRfVFlQRV9JTlQsCiAJ CW9mZnNldG9mKFN0ZFJkT3B0aW9ucywgYXV0b3ZhY3V1bSkgKyBvZmZzZXRvZihBdXRvVmFjT3B0 cywgdmFjdXVtX3RocmVzaG9sZCl9LAogCQl7ImF1dG92YWN1dW1fdmFjdXVtX21heF90aHJlc2hv bGQiLCBSRUxPUFRfVFlQRV9JTlQsCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVh cC92YWN1dW1sYXp5LmMgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMKaW5k ZXggZjI4MzI2YmFkMDkuLjI2MTRjZWJhMTM5IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nl c3MvaGVhcC92YWN1dW1sYXp5LmMKKysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvdmFjdXVt bGF6eS5jCkBAIC0zNDg3LDYgKzM0ODcsMTAgQEAgZGVhZF9pdGVtc19hbGxvYyhMVlJlbFN0YXRl ICp2YWNyZWwsIGludCBud29ya2VycykKIAkJYXV0b3ZhY3V1bV93b3JrX21lbSAhPSAtMSA/CiAJ CWF1dG92YWN1dW1fd29ya19tZW0gOiBtYWludGVuYW5jZV93b3JrX21lbTsKIAorCWludAkJCWVs ZXZlbCA9IEFtQXV0b1ZhY3V1bVdvcmtlclByb2Nlc3MoKSB8fAorCQl2YWNyZWwtPnZlcmJvc2Ug PworCQlJTkZPIDogREVCVUcyOworCiAJLyoKIAkgKiBJbml0aWFsaXplIHN0YXRlIGZvciBhIHBh cmFsbGVsIHZhY3V1bS4gIEFzIG9mIG5vdywgb25seSBvbmUgd29ya2VyIGNhbgogCSAqIGJlIHVz ZWQgZm9yIGFuIGluZGV4LCBzbyB3ZSBpbnZva2UgcGFyYWxsZWxpc20gb25seSBpZiB0aGVyZSBh cmUgYXQKQEAgLTM1MTMsNyArMzUxNyw3IEBAIGRlYWRfaXRlbXNfYWxsb2MoTFZSZWxTdGF0ZSAq dmFjcmVsLCBpbnQgbndvcmtlcnMpCiAJCQl2YWNyZWwtPnB2cyA9IHBhcmFsbGVsX3ZhY3V1bV9p bml0KHZhY3JlbC0+cmVsLCB2YWNyZWwtPmluZHJlbHMsCiAJCQkJCQkJCQkJCSAgIHZhY3JlbC0+ bmluZGV4ZXMsIG53b3JrZXJzLAogCQkJCQkJCQkJCQkgICB2YWNfd29ya19tZW0sCi0JCQkJCQkJ CQkJCSAgIHZhY3JlbC0+dmVyYm9zZSA/IElORk8gOiBERUJVRzIsCisJCQkJCQkJCQkJCSAgIGVs ZXZlbCwKIAkJCQkJCQkJCQkJICAgdmFjcmVsLT5ic3RyYXRlZ3kpOwogCiAJCS8qCmRpZmYgLS1n aXQgYS9zcmMvYmFja2VuZC9hY2Nlc3MvdHJhbnNhbS9wYXJhbGxlbC5jIGIvc3JjL2JhY2tlbmQv YWNjZXNzL3RyYW5zYW0vcGFyYWxsZWwuYwppbmRleCA5NGRiMWVjMzAxMi4uZDMzMTM3NzRhNGIg MTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2FjY2Vzcy90cmFuc2FtL3BhcmFsbGVsLmMKKysrIGIv c3JjL2JhY2tlbmQvYWNjZXNzL3RyYW5zYW0vcGFyYWxsZWwuYwpAQCAtMzQsNiArMzQsNyBAQAog I2luY2x1ZGUgIm1pc2NhZG1pbi5oIgogI2luY2x1ZGUgIm9wdGltaXplci9vcHRpbWl6ZXIuaCIK ICNpbmNsdWRlICJwZ3N0YXQuaCIKKyNpbmNsdWRlICJwb3N0bWFzdGVyL2F1dG92YWN1dW0uaCIK ICNpbmNsdWRlICJzdG9yYWdlL2lwYy5oIgogI2luY2x1ZGUgInN0b3JhZ2UvcHJlZGljYXRlLmgi CiAjaW5jbHVkZSAic3RvcmFnZS9zcGluLmgiCkBAIC01MTQsNiArNTE1LDExIEBAIFJlaW5pdGlh bGl6ZVBhcmFsbGVsRFNNKFBhcmFsbGVsQ29udGV4dCAqcGN4dCkKIAl7CiAJCVdhaXRGb3JQYXJh bGxlbFdvcmtlcnNUb0ZpbmlzaChwY3h0KTsKIAkJV2FpdEZvclBhcmFsbGVsV29ya2Vyc1RvRXhp dChwY3h0KTsKKworCQkvKiBSZWxlYXNlIGFsbCBsYXVuY2hlZCAoaS5lLiByZXNlcnZlZCkgcGFy YWxsZWwgYXV0b3ZhY3V1bSB3b3JrZXJzLiAqLworCQlpZiAoQW1BdXRvVmFjdXVtV29ya2VyUHJv Y2VzcygpKQorCQkJUGFyYWxsZWxBdXRvVmFjdXVtUmVsZWFzZVdvcmtlcnMocGN4dC0+bndvcmtl cnNfbGF1bmNoZWQpOworCiAJCXBjeHQtPm53b3JrZXJzX2xhdW5jaGVkID0gMDsKIAkJaWYgKHBj eHQtPmtub3duX2F0dGFjaGVkX3dvcmtlcnMpCiAJCXsKQEAgLTEwMDIsNiArMTAwOCwxMSBAQCBE ZXN0cm95UGFyYWxsZWxDb250ZXh0KFBhcmFsbGVsQ29udGV4dCAqcGN4dCkKIAkgKi8KIAlIT0xE X0lOVEVSUlVQVFMoKTsKIAlXYWl0Rm9yUGFyYWxsZWxXb3JrZXJzVG9FeGl0KHBjeHQpOworCisJ LyogUmVsZWFzZSBhbGwgbGF1bmNoZWQgKGkuZS4gcmVzZXJ2ZWQpIHBhcmFsbGVsIGF1dG92YWN1 dW0gd29ya2Vycy4gKi8KKwlpZiAoQW1BdXRvVmFjdXVtV29ya2VyUHJvY2VzcygpKQorCQlQYXJh bGxlbEF1dG9WYWN1dW1SZWxlYXNlV29ya2VycyhwY3h0LT5ud29ya2Vyc19sYXVuY2hlZCk7CisK IAlSRVNVTUVfSU5URVJSVVBUUygpOwogCiAJLyogRnJlZSB0aGUgd29ya2VyIGFycmF5IGl0c2Vs Zi4gKi8KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMg Yi9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCmluZGV4IDJiOWQ1NDhjZGVi Li5jNjM4MzBmZDJhNSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFy YWxsZWwuYworKysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCkBAIC0x LDE2ICsxLDE2IEBACiAvKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KICAqCiAgKiB2YWN1dW1wYXJhbGxlbC5j Ci0gKgkgIFN1cHBvcnQgcm91dGluZXMgZm9yIHBhcmFsbGVsIHZhY3V1bSBleGVjdXRpb24uCisg KgkgIFN1cHBvcnQgcm91dGluZXMgZm9yIHBhcmFsbGVsIFthdXRvXXZhY3V1bSBleGVjdXRpb24u CiAgKgogICogVGhpcyBmaWxlIGNvbnRhaW5zIHJvdXRpbmVzIHRoYXQgYXJlIGludGVuZGVkIHRv IHN1cHBvcnQgc2V0dGluZyB1cCwgdXNpbmcsCiAgKiBhbmQgdGVhcmluZyBkb3duIGEgUGFyYWxs ZWxWYWN1dW1TdGF0ZS4KICAqCi0gKiBJbiBhIHBhcmFsbGVsIHZhY3V1bSwgd2UgcGVyZm9ybSBi b3RoIGluZGV4IGJ1bGsgZGVsZXRpb24gYW5kIGluZGV4IGNsZWFudXAKLSAqIHdpdGggcGFyYWxs ZWwgd29ya2VyIHByb2Nlc3Nlcy4gIEluZGl2aWR1YWwgaW5kZXhlcyBhcmUgcHJvY2Vzc2VkIGJ5 IG9uZQotICogdmFjdXVtIHByb2Nlc3MuICBQYXJhbGxlbFZhY3V1bVN0YXRlIGNvbnRhaW5zIHNo YXJlZCBpbmZvcm1hdGlvbiBhcyB3ZWxsIGFzCi0gKiB0aGUgbWVtb3J5IHNwYWNlIGZvciBzdG9y aW5nIGRlYWQgaXRlbXMgYWxsb2NhdGVkIGluIHRoZSBEU0EgYXJlYS4gIFdlCi0gKiBsYXVuY2gg cGFyYWxsZWwgd29ya2VyIHByb2Nlc3NlcyBhdCB0aGUgc3RhcnQgb2YgcGFyYWxsZWwgaW5kZXgK KyAqIEluIGEgcGFyYWxsZWwgW2F1dG9ddmFjdXVtLCB3ZSBwZXJmb3JtIGJvdGggaW5kZXggYnVs ayBkZWxldGlvbiBhbmQgaW5kZXgKKyAqIGNsZWFudXAgd2l0aCBwYXJhbGxlbCB3b3JrZXIgcHJv Y2Vzc2VzLiAgSW5kaXZpZHVhbCBpbmRleGVzIGFyZSBwcm9jZXNzZWQgYnkKKyAqIG9uZSBbYXV0 b112YWN1dW0gcHJvY2Vzcy4gIFBhcmFsbGVsVmFjdXVtU3RhdGUgY29udGFpbnMgc2hhcmVkIGlu Zm9ybWF0aW9uCisgKiBhcyB3ZWxsIGFzIHRoZSBtZW1vcnkgc3BhY2UgZm9yIHN0b3JpbmcgZGVh ZCBpdGVtcyBhbGxvY2F0ZWQgaW4gdGhlIERTQSBhcmVhLgorICogV2UgbGF1bmNoIHBhcmFsbGVs IHdvcmtlciBwcm9jZXNzZXMgYXQgdGhlIHN0YXJ0IG9mIHBhcmFsbGVsIGluZGV4CiAgKiBidWxr LWRlbGV0aW9uIGFuZCBpbmRleCBjbGVhbnVwIGFuZCBvbmNlIGFsbCBpbmRleGVzIGFyZSBwcm9j ZXNzZWQsIHRoZQogICogcGFyYWxsZWwgd29ya2VyIHByb2Nlc3NlcyBleGl0LiAgRWFjaCB0aW1l IHdlIHByb2Nlc3MgaW5kZXhlcyBpbiBwYXJhbGxlbCwKICAqIHRoZSBwYXJhbGxlbCBjb250ZXh0 IGlzIHJlLWluaXRpYWxpemVkIHNvIHRoYXQgdGhlIHNhbWUgRFNNIGNhbiBiZSB1c2VkIGZvcgpA QCAtMzQsNiArMzQsNyBAQAogI2luY2x1ZGUgImV4ZWN1dG9yL2luc3RydW1lbnQuaCIKICNpbmNs dWRlICJvcHRpbWl6ZXIvcGF0aHMuaCIKICNpbmNsdWRlICJwZ3N0YXQuaCIKKyNpbmNsdWRlICJw b3N0bWFzdGVyL2F1dG92YWN1dW0uaCIKICNpbmNsdWRlICJzdG9yYWdlL2J1Zm1nci5oIgogI2lu Y2x1ZGUgInRjb3AvdGNvcHByb3QuaCIKICNpbmNsdWRlICJ1dGlscy9sc3lzY2FjaGUuaCIKQEAg LTE1Nyw3ICsxNTgsOCBAQCB0eXBlZGVmIHN0cnVjdCBQVkluZFN0YXRzCiB9IFBWSW5kU3RhdHM7 CiAKIC8qCi0gKiBTdHJ1Y3QgZm9yIG1haW50YWluaW5nIGEgcGFyYWxsZWwgdmFjdXVtIHN0YXRl LiB0eXBlZGVmIGFwcGVhcnMgaW4gdmFjdXVtLmguCisgKiBTdHJ1Y3QgZm9yIG1haW50YWluaW5n IGEgcGFyYWxsZWwgW2F1dG9ddmFjdXVtIHN0YXRlLiB0eXBlZGVmIGFwcGVhcnMgaW4KKyAqIHZh Y3V1bS5oLgogICovCiBzdHJ1Y3QgUGFyYWxsZWxWYWN1dW1TdGF0ZQogewpAQCAtMzcxLDEwICsz NzMsMTggQEAgcGFyYWxsZWxfdmFjdXVtX2luaXQoUmVsYXRpb24gcmVsLCBSZWxhdGlvbiAqaW5k cmVscywgaW50IG5pbmRleGVzLAogCXNoYXJlZC0+cmVsaWQgPSBSZWxhdGlvbkdldFJlbGlkKHJl bCk7CiAJc2hhcmVkLT5lbGV2ZWwgPSBlbGV2ZWw7CiAJc2hhcmVkLT5xdWVyeWlkID0gcGdzdGF0 X2dldF9teV9xdWVyeV9pZCgpOwotCXNoYXJlZC0+bWFpbnRlbmFuY2Vfd29ya19tZW1fd29ya2Vy ID0KLQkJKG5pbmRleGVzX213bSA+IDApID8KLQkJbWFpbnRlbmFuY2Vfd29ya19tZW0gLyBNaW4o cGFyYWxsZWxfd29ya2VycywgbmluZGV4ZXNfbXdtKSA6Ci0JCW1haW50ZW5hbmNlX3dvcmtfbWVt OworCisJaWYgKEFtQXV0b1ZhY3V1bVdvcmtlclByb2Nlc3MoKSkKKwkJc2hhcmVkLT5tYWludGVu YW5jZV93b3JrX21lbV93b3JrZXIgPQorCQkJKG5pbmRleGVzX213bSA+IDApID8KKwkJCWF1dG92 YWN1dW1fd29ya19tZW0gLyBNaW4ocGFyYWxsZWxfd29ya2VycywgbmluZGV4ZXNfbXdtKSA6CisJ CQlhdXRvdmFjdXVtX3dvcmtfbWVtOworCWVsc2UKKwkJc2hhcmVkLT5tYWludGVuYW5jZV93b3Jr X21lbV93b3JrZXIgPQorCQkJKG5pbmRleGVzX213bSA+IDApID8KKwkJCW1haW50ZW5hbmNlX3dv cmtfbWVtIC8gTWluKHBhcmFsbGVsX3dvcmtlcnMsIG5pbmRleGVzX213bSkgOgorCQkJbWFpbnRl bmFuY2Vfd29ya19tZW07CisKIAlzaGFyZWQtPmRlYWRfaXRlbXNfaW5mby5tYXhfYnl0ZXMgPSB2 YWNfd29ya19tZW0gKiAoc2l6ZV90KSAxMDI0OwogCiAJLyogUHJlcGFyZSBEU0Egc3BhY2UgZm9y IGRlYWQgaXRlbXMgKi8KQEAgLTU0MSw3ICs1NTEsNyBAQCBwYXJhbGxlbF92YWN1dW1fY2xlYW51 cF9hbGxfaW5kZXhlcyhQYXJhbGxlbFZhY3V1bVN0YXRlICpwdnMsIGxvbmcgbnVtX3RhYmxlX3R1 cAogICoKICAqIG5yZXF1ZXN0ZWQgaXMgdGhlIG51bWJlciBvZiBwYXJhbGxlbCB3b3JrZXJzIHRo YXQgdXNlciByZXF1ZXN0ZWQuICBJZgogICogbnJlcXVlc3RlZCBpcyAwLCB3ZSBjb21wdXRlIHRo ZSBwYXJhbGxlbCBkZWdyZWUgYmFzZWQgb24gbmluZGV4ZXMsIHRoYXQgaXMKLSAqIHRoZSBudW1i ZXIgb2YgaW5kZXhlcyB0aGF0IHN1cHBvcnQgcGFyYWxsZWwgdmFjdXVtLiAgVGhpcyBmdW5jdGlv biBhbHNvCisgKiB0aGUgbnVtYmVyIG9mIGluZGV4ZXMgdGhhdCBzdXBwb3J0IHBhcmFsbGVsIFth dXRvXXZhY3V1bS4gIFRoaXMgZnVuY3Rpb24gYWxzbwogICogc2V0cyB3aWxsX3BhcmFsbGVsX3Zh Y3V1bSB0byByZW1lbWJlciBpbmRleGVzIHRoYXQgcGFydGljaXBhdGUgaW4gcGFyYWxsZWwKICAq IHZhY3V1bS4KICAqLwpAQCAtNTU4LDcgKzU2OCw5IEBAIHBhcmFsbGVsX3ZhY3V1bV9jb21wdXRl X3dvcmtlcnMoUmVsYXRpb24gKmluZHJlbHMsIGludCBuaW5kZXhlcywgaW50IG5yZXF1ZXN0ZWQs CiAJICogV2UgZG9uJ3QgYWxsb3cgcGVyZm9ybWluZyBwYXJhbGxlbCBvcGVyYXRpb24gaW4gc3Rh bmRhbG9uZSBiYWNrZW5kIG9yCiAJICogd2hlbiBwYXJhbGxlbGlzbSBpcyBkaXNhYmxlZC4KIAkg Ki8KLQlpZiAoIUlzVW5kZXJQb3N0bWFzdGVyIHx8IG1heF9wYXJhbGxlbF9tYWludGVuYW5jZV93 b3JrZXJzID09IDApCisJaWYgKCFJc1VuZGVyUG9zdG1hc3RlciB8fAorCQkobWF4X3BhcmFsbGVs X2F1dG92YWN1dW1fd29ya2VycyA9PSAwICYmIEFtQXV0b1ZhY3V1bVdvcmtlclByb2Nlc3MoKSkg fHwKKwkJKG1heF9wYXJhbGxlbF9tYWludGVuYW5jZV93b3JrZXJzID09IDAgJiYgIUFtQXV0b1Zh Y3V1bVdvcmtlclByb2Nlc3MoKSkpCiAJCXJldHVybiAwOwogCiAJLyoKQEAgLTU5NywxNSArNjA5 LDE3IEBAIHBhcmFsbGVsX3ZhY3V1bV9jb21wdXRlX3dvcmtlcnMoUmVsYXRpb24gKmluZHJlbHMs IGludCBuaW5kZXhlcywgaW50IG5yZXF1ZXN0ZWQsCiAJcGFyYWxsZWxfd29ya2VycyA9IChucmVx dWVzdGVkID4gMCkgPwogCQlNaW4obnJlcXVlc3RlZCwgbmluZGV4ZXNfcGFyYWxsZWwpIDogbmlu ZGV4ZXNfcGFyYWxsZWw7CiAKLQkvKiBDYXAgYnkgbWF4X3BhcmFsbGVsX21haW50ZW5hbmNlX3dv cmtlcnMgKi8KLQlwYXJhbGxlbF93b3JrZXJzID0gTWluKHBhcmFsbGVsX3dvcmtlcnMsIG1heF9w YXJhbGxlbF9tYWludGVuYW5jZV93b3JrZXJzKTsKKwkvKiBDYXAgYnkgR1VDIHZhcmlhYmxlICov CisJcGFyYWxsZWxfd29ya2VycyA9IEFtQXV0b1ZhY3V1bVdvcmtlclByb2Nlc3MoKSA/CisJCU1p bihwYXJhbGxlbF93b3JrZXJzLCBtYXhfcGFyYWxsZWxfYXV0b3ZhY3V1bV93b3JrZXJzKSA6CisJ CU1pbihwYXJhbGxlbF93b3JrZXJzLCBtYXhfcGFyYWxsZWxfbWFpbnRlbmFuY2Vfd29ya2Vycyk7 CiAKIAlyZXR1cm4gcGFyYWxsZWxfd29ya2VyczsKIH0KIAogLyoKICAqIFBlcmZvcm0gaW5kZXgg dmFjdXVtIG9yIGluZGV4IGNsZWFudXAgd2l0aCBwYXJhbGxlbCB3b3JrZXJzLiAgVGhpcyBmdW5j dGlvbgotICogbXVzdCBiZSB1c2VkIGJ5IHRoZSBwYXJhbGxlbCB2YWN1dW0gbGVhZGVyIHByb2Nl c3MuCisgKiBtdXN0IGJlIHVzZWQgYnkgdGhlIHBhcmFsbGVsIFthdXRvXXZhY3V1bSBsZWFkZXIg cHJvY2Vzcy4KICAqLwogc3RhdGljIHZvaWQKIHBhcmFsbGVsX3ZhY3V1bV9wcm9jZXNzX2FsbF9p bmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywgaW50IG51bV9pbmRleF9zY2FucywKQEAg LTY2Niw2ICs2ODAsMTAgQEAgcGFyYWxsZWxfdmFjdXVtX3Byb2Nlc3NfYWxsX2luZGV4ZXMoUGFy YWxsZWxWYWN1dW1TdGF0ZSAqcHZzLCBpbnQgbnVtX2luZGV4X3NjYW4KIAkvKiBSZXNldCB0aGUg cGFyYWxsZWwgaW5kZXggcHJvY2Vzc2luZyBhbmQgcHJvZ3Jlc3MgY291bnRlcnMgKi8KIAlwZ19h dG9taWNfd3JpdGVfdTMyKCYocHZzLT5zaGFyZWQtPmlkeCksIDApOwogCisJLyogQ2hlY2sgaG93 IG1hbnkgd29ya2VycyBjYW4gcHJvdmlkZSBhdXRvdmFjdXVtLiAqLworCWlmIChBbUF1dG9WYWN1 dW1Xb3JrZXJQcm9jZXNzKCkgJiYgbndvcmtlcnMgPiAwKQorCQlud29ya2VycyA9IFBhcmFsbGVs QXV0b1ZhY3V1bVJlc2VydmVXb3JrZXJzKG53b3JrZXJzKTsKKwogCS8qIFNldHVwIHRoZSBzaGFy ZWQgY29zdC1iYXNlZCB2YWN1dW0gZGVsYXkgYW5kIGxhdW5jaCB3b3JrZXJzICovCiAJaWYgKG53 b3JrZXJzID4gMCkKIAl7CkBAIC02OTAsNiArNzA4LDE2IEBAIHBhcmFsbGVsX3ZhY3V1bV9wcm9j ZXNzX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywgaW50IG51bV9pbmRleF9z Y2FuCiAKIAkJTGF1bmNoUGFyYWxsZWxXb3JrZXJzKHB2cy0+cGN4dCk7CiAKKwkJaWYgKEFtQXV0 b1ZhY3V1bVdvcmtlclByb2Nlc3MoKSAmJgorCQkJcHZzLT5wY3h0LT5ud29ya2Vyc19sYXVuY2hl ZCA8IG53b3JrZXJzKQorCQl7CisJCQkvKgorCQkJICogVGVsbCBhdXRvdmFjdXVtIHRoYXQgd2Ug Y291bGQgbm90IGxhdW5jaCBhbGwgdGhlIHByZXZpb3VzbHkKKwkJCSAqIHJlc2VydmVkIHdvcmtl cnMuCisJCQkgKi8KKwkJCVBhcmFsbGVsQXV0b1ZhY3V1bVJlbGVhc2VXb3JrZXJzKHB2cy0+cGN4 dC0+bndvcmtlcnNfbGF1bmNoZWQgLSBud29ya2Vycyk7CisJCX0KKwogCQlpZiAocHZzLT5wY3h0 LT5ud29ya2Vyc19sYXVuY2hlZCA+IDApCiAJCXsKIAkJCS8qCkBAIC03MDYsMTYgKzczNCwxNiBA QCBwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19hbGxfaW5kZXhlcyhQYXJhbGxlbFZhY3V1bVN0YXRl ICpwdnMsIGludCBudW1faW5kZXhfc2NhbgogCiAJCWlmICh2YWN1dW0pCiAJCQllcmVwb3J0KHB2 cy0+c2hhcmVkLT5lbGV2ZWwsCi0JCQkJCShlcnJtc2cobmdldHRleHQoImxhdW5jaGVkICVkIHBh cmFsbGVsIHZhY3V1bSB3b3JrZXIgZm9yIGluZGV4IHZhY3V1bWluZyAocGxhbm5lZDogJWQpIiwK LQkJCQkJCQkJCSAibGF1bmNoZWQgJWQgcGFyYWxsZWwgdmFjdXVtIHdvcmtlcnMgZm9yIGluZGV4 IHZhY3V1bWluZyAocGxhbm5lZDogJWQpIiwKKwkJCQkJKGVycm1zZyhuZ2V0dGV4dCgibGF1bmNo ZWQgJWQgcGFyYWxsZWwgJXN2YWN1dW0gd29ya2VyIGZvciBpbmRleCB2YWN1dW1pbmcgKHBsYW5u ZWQ6ICVkKSIsCisJCQkJCQkJCQkgImxhdW5jaGVkICVkIHBhcmFsbGVsICVzdmFjdXVtIHdvcmtl cnMgZm9yIGluZGV4IHZhY3V1bWluZyAocGxhbm5lZDogJWQpIiwKIAkJCQkJCQkJCSBwdnMtPnBj eHQtPm53b3JrZXJzX2xhdW5jaGVkKSwKLQkJCQkJCQlwdnMtPnBjeHQtPm53b3JrZXJzX2xhdW5j aGVkLCBud29ya2VycykpKTsKKwkJCQkJCQlwdnMtPnBjeHQtPm53b3JrZXJzX2xhdW5jaGVkLCBB bUF1dG9WYWN1dW1Xb3JrZXJQcm9jZXNzKCkgPyAiYXV0byIgOiAiIiwgbndvcmtlcnMpKSk7CiAJ CWVsc2UKIAkJCWVyZXBvcnQocHZzLT5zaGFyZWQtPmVsZXZlbCwKLQkJCQkJKGVycm1zZyhuZ2V0 dGV4dCgibGF1bmNoZWQgJWQgcGFyYWxsZWwgdmFjdXVtIHdvcmtlciBmb3IgaW5kZXggY2xlYW51 cCAocGxhbm5lZDogJWQpIiwKLQkJCQkJCQkJCSAibGF1bmNoZWQgJWQgcGFyYWxsZWwgdmFjdXVt IHdvcmtlcnMgZm9yIGluZGV4IGNsZWFudXAgKHBsYW5uZWQ6ICVkKSIsCisJCQkJCShlcnJtc2co bmdldHRleHQoImxhdW5jaGVkICVkIHBhcmFsbGVsICVzdmFjdXVtIHdvcmtlciBmb3IgaW5kZXgg Y2xlYW51cCAocGxhbm5lZDogJWQpIiwKKwkJCQkJCQkJCSAibGF1bmNoZWQgJWQgcGFyYWxsZWwg JXN2YWN1dW0gd29ya2VycyBmb3IgaW5kZXggY2xlYW51cCAocGxhbm5lZDogJWQpIiwKIAkJCQkJ CQkJCSBwdnMtPnBjeHQtPm53b3JrZXJzX2xhdW5jaGVkKSwKLQkJCQkJCQlwdnMtPnBjeHQtPm53 b3JrZXJzX2xhdW5jaGVkLCBud29ya2VycykpKTsKKwkJCQkJCQlwdnMtPnBjeHQtPm53b3JrZXJz X2xhdW5jaGVkLCBBbUF1dG9WYWN1dW1Xb3JrZXJQcm9jZXNzKCkgPyAiYXV0byIgOiAiIiwgbndv cmtlcnMpKSk7CiAJfQogCiAJLyogVmFjdXVtIHRoZSBpbmRleGVzIHRoYXQgY2FuIGJlIHByb2Nl c3NlZCBieSBvbmx5IGxlYWRlciBwcm9jZXNzICovCkBAIC05ODIsOCArMTAxMCw4IEBAIHBhcmFs bGVsX3ZhY3V1bV9pbmRleF9pc19wYXJhbGxlbF9zYWZlKFJlbGF0aW9uIGluZHJlbCwgaW50IG51 bV9pbmRleF9zY2FucywKIC8qCiAgKiBQZXJmb3JtIHdvcmsgd2l0aGluIGEgbGF1bmNoZWQgcGFy YWxsZWwgcHJvY2Vzcy4KICAqCi0gKiBTaW5jZSBwYXJhbGxlbCB2YWN1dW0gd29ya2VycyBwZXJm b3JtIG9ubHkgaW5kZXggdmFjdXVtIG9yIGluZGV4IGNsZWFudXAsCi0gKiB3ZSBkb24ndCBuZWVk IHRvIHJlcG9ydCBwcm9ncmVzcyBpbmZvcm1hdGlvbi4KKyAqIFNpbmNlIHBhcmFsbGVsIFthdXRv XXZhY3V1bSB3b3JrZXJzIHBlcmZvcm0gb25seSBpbmRleCB2YWN1dW0gb3IgaW5kZXgKKyAqIGNs ZWFudXAsIHdlIGRvbid0IG5lZWQgdG8gcmVwb3J0IHByb2dyZXNzIGluZm9ybWF0aW9uLgogICov CiB2b2lkCiBwYXJhbGxlbF92YWN1dW1fbWFpbihkc21fc2VnbWVudCAqc2VnLCBzaG1fdG9jICp0 b2MpCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYyBiL3Ny Yy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCmluZGV4IDk4MWJlNDJlM2FmLi43ZjM0 ZTIwMjU4OSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMK KysrIGIvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMKQEAgLTI4NSw2ICsyODUs NyBAQCB0eXBlZGVmIHN0cnVjdCBBdXRvVmFjdXVtV29ya0l0ZW0KICAqIGF2X3dvcmtJdGVtcwkJ d29yayBpdGVtIGFycmF5CiAgKiBhdl9ud29ya2Vyc0ZvckJhbGFuY2UgdGhlIG51bWJlciBvZiBh dXRvdmFjdXVtIHdvcmtlcnMgdG8gdXNlIHdoZW4KICAqIAkJCQkJY2FsY3VsYXRpbmcgdGhlIHBl ciB3b3JrZXIgY29zdCBsaW1pdAorICogYXZfYWN0aXZlX3BhcmFsbGVsX3dvcmtlcnMgdGhlIG51 bWJlciBvZiBhY3RpdmUgcGFyYWxsZWwgYXV0b3ZhY3V1bSB3b3JrZXJzCiAgKgogICogVGhpcyBz dHJ1Y3QgaXMgcHJvdGVjdGVkIGJ5IEF1dG92YWN1dW1Mb2NrLCBleGNlcHQgZm9yIGF2X3NpZ25h bCBhbmQgcGFydHMKICAqIG9mIHRoZSB3b3JrZXIgbGlzdCAoc2VlIGFib3ZlKS4KQEAgLTI5OSw2 ICszMDAsNyBAQCB0eXBlZGVmIHN0cnVjdAogCVdvcmtlckluZm8JYXZfc3RhcnRpbmdXb3JrZXI7 CiAJQXV0b1ZhY3V1bVdvcmtJdGVtIGF2X3dvcmtJdGVtc1tOVU1fV09SS0lURU1TXTsKIAlwZ19h dG9taWNfdWludDMyIGF2X253b3JrZXJzRm9yQmFsYW5jZTsKKwl1aW50MzIgYXZfYWN0aXZlX3Bh cmFsbGVsX3dvcmtlcnM7CiB9IEF1dG9WYWN1dW1TaG1lbVN0cnVjdDsKIAogc3RhdGljIEF1dG9W YWN1dW1TaG1lbVN0cnVjdCAqQXV0b1ZhY3V1bVNobWVtOwpAQCAtMjg0MCw4ICsyODQyLDEyIEBA IHRhYmxlX3JlY2hlY2tfYXV0b3ZhYyhPaWQgcmVsaWQsIEhUQUIgKnRhYmxlX3RvYXN0X21hcCwK IAkJICovCiAJCXRhYi0+YXRfcGFyYW1zLmluZGV4X2NsZWFudXAgPSBWQUNPUFRWQUxVRV9VTlNQ RUNJRklFRDsKIAkJdGFiLT5hdF9wYXJhbXMudHJ1bmNhdGUgPSBWQUNPUFRWQUxVRV9VTlNQRUNJ RklFRDsKLQkJLyogQXMgb2Ygbm93LCB3ZSBkb24ndCBzdXBwb3J0IHBhcmFsbGVsIHZhY3V1bSBm b3IgYXV0b3ZhY3V1bSAqLwotCQl0YWItPmF0X3BhcmFtcy5ud29ya2VycyA9IC0xOworCisJCS8q IERlY2lkZSB3aGV0aGVyIHdlIG5lZWQgdG8gcHJvY2VzcyBpbmRleGVzIG9mIHRhYmxlIGluIHBh cmFsbGVsLiAqLworCQl0YWItPmF0X3BhcmFtcy5ud29ya2VycyA9IGF2b3B0cworCQkJPyBhdm9w dHMtPnBhcmFsbGVsX2F1dG92YWN1dW1fd29ya2VycworCQkJOiAtMTsKKwogCQl0YWItPmF0X3Bh cmFtcy5mcmVlemVfbWluX2FnZSA9IGZyZWV6ZV9taW5fYWdlOwogCQl0YWItPmF0X3BhcmFtcy5m cmVlemVfdGFibGVfYWdlID0gZnJlZXplX3RhYmxlX2FnZTsKIAkJdGFiLT5hdF9wYXJhbXMubXVs dGl4YWN0X2ZyZWV6ZV9taW5fYWdlID0gbXVsdGl4YWN0X2ZyZWV6ZV9taW5fYWdlOwpAQCAtMzMy Miw2ICszMzI4LDYxIEBAIEF1dG9WYWN1dW1SZXF1ZXN0V29yayhBdXRvVmFjdXVtV29ya0l0ZW1U eXBlIHR5cGUsIE9pZCByZWxhdGlvbklkLAogCXJldHVybiByZXN1bHQ7CiB9CiAKKy8qCisgKiBJ biBvcmRlciB0byBtZWV0IHRoZSAnbWF4X3BhcmFsbGVsX2F1dG92YWN1dW1fd29ya2VycycgbGlt aXQsIGxlYWRlciB3b3JrZXIKKyAqIG11c3QgY2FsbCB0aGlzIGZ1bmN0aW9uLiBJdCByZXR1cm5z IHRoZSBudW1iZXIgb2YgcGFyYWxsZWwgd29ya2VycyB0aGF0CisgKiBhY3R1YWxseSBjYW4gYmUg bGF1bmNoZWQgYW5kIHJlc2VydmVzIChpZiBhbnkpIHRoZXNlIHdvcmtlcnMgaW4gZ2xvYmFsCisg KiBhdXRvdmFjdXVtIHN0YXRlLgorICoKKyAqIE5PVEU6IFdlIHdpbGwgdHJ5IHRvIHByb3ZpZGUg YXMgbWFueSB3b3JrZXJzIGFzIHJlcXVlc3RlZCwgZXZlbiBpZiBjYWxsZXIKKyAqIHdpbGwgb2Nj dXB5IGFsbCBhdmFpbGFibGUgd29ya2Vycy4KKyAqLworaW50CitQYXJhbGxlbEF1dG9WYWN1dW1S ZXNlcnZlV29ya2VycyhpbnQgbndvcmtlcnMpCit7CisJaW50IGNhbl9sYXVuY2g7CisKKwkvKiBP bmx5IGxlYWRlciB3b3JrZXIgY2FuIGNhbGwgdGhpcyBmdW5jdGlvbi4gKi8KKwlBc3NlcnQoQW1B dXRvVmFjdXVtV29ya2VyUHJvY2VzcygpICYmICFJc1BhcmFsbGVsV29ya2VyKCkpOworCisJTFdM b2NrQWNxdWlyZShBdXRvdmFjdXVtTG9jaywgTFdfRVhDTFVTSVZFKTsKKwlpZiAoQXV0b1ZhY3V1 bVNobWVtLT5hdl9hY3RpdmVfcGFyYWxsZWxfd29ya2VycyA8IG53b3JrZXJzKQorCXsKKwkJLyog UHJvdmlkZSBhcyBtYW55IHdvcmtlcnMgYXMgd2UgY2FuLiAqLworCQljYW5fbGF1bmNoID0gQXV0 b1ZhY3V1bVNobWVtLT5hdl9hY3RpdmVfcGFyYWxsZWxfd29ya2VyczsKKwkJQXV0b1ZhY3V1bVNo bWVtLT5hdl9hY3RpdmVfcGFyYWxsZWxfd29ya2VycyA9IDA7CisJfQorCWVsc2UKKwl7CisJCS8q IE9LLCB3ZSBjYW4gcHJvdmlkZSBhbGwgcmVxdWVzdGVkIHdvcmtlcnMuICovCisJCWNhbl9sYXVu Y2ggPSBud29ya2VyczsKKwkJQXV0b1ZhY3V1bVNobWVtLT5hdl9hY3RpdmVfcGFyYWxsZWxfd29y a2VycyAtPSBud29ya2VyczsKKwl9CisJTFdMb2NrUmVsZWFzZShBdXRvdmFjdXVtTG9jayk7CisK KwlyZXR1cm4gY2FuX2xhdW5jaDsKK30KKworLyoKKyAqIFdoZW4gcGFyYWxsZWwgYXV0b3ZhY3V1 bSB3b3JrZXIgZGllLCBsZWFkZXIgd29ya2VyIG11c3QgY2FsbCB0aGlzIGZ1bmN0aW9uCisgKiBp biBvcmRlciB0byByZWZyZXNoIGdsb2JhbCBhdXRvdmFjdXVtIHN0YXRlLiBUaHVzLCBvdGhlciBs ZWFkZXJzIHdpbGwgYmUgYWJsZQorICogdG8gdXNlIHRoZXNlIHdvcmtlcnMuCisgKgorICogJ253 b3JrZXJzJyAtIGhvdyBtYW55IHdvcmtlcnMgY2FsbGVyIHdhbnRzIHRvIHJlbGVhc2UuCisgKi8K K3ZvaWQKK1BhcmFsbGVsQXV0b1ZhY3V1bVJlbGVhc2VXb3JrZXJzKGludCBud29ya2VycykKK3sK KwkvKiBPbmx5IGxlYWRlciB3b3JrZXIgY2FuIGNhbGwgdGhpcyBmdW5jdGlvbi4gKi8KKwlBc3Nl cnQoQW1BdXRvVmFjdXVtV29ya2VyUHJvY2VzcygpICYmICFJc1BhcmFsbGVsV29ya2VyKCkpOwor CisJTFdMb2NrQWNxdWlyZShBdXRvdmFjdXVtTG9jaywgTFdfRVhDTFVTSVZFKTsKKwlBdXRvVmFj dXVtU2htZW0tPmF2X2FjdGl2ZV9wYXJhbGxlbF93b3JrZXJzICs9IG53b3JrZXJzOworCUFzc2Vy dChBdXRvVmFjdXVtU2htZW0tPmF2X2FjdGl2ZV9wYXJhbGxlbF93b3JrZXJzIDw9CisJCSAgIG1h eF9wYXJhbGxlbF9hdXRvdmFjdXVtX3dvcmtlcnMpOworCUxXTG9ja1JlbGVhc2UoQXV0b3ZhY3V1 bUxvY2spOworfQorCiAvKgogICogYXV0b3ZhY19pbml0CiAgKgkJVGhpcyBpcyBjYWxsZWQgYXQg cG9zdG1hc3RlciBpbml0aWFsaXphdGlvbi4KQEAgLTMzODIsNiArMzQ0Myw4IEBAIEF1dG9WYWN1 dW1TaG1lbUluaXQodm9pZCkKIAkJQXNzZXJ0KCFmb3VuZCk7CiAKIAkJQXV0b1ZhY3V1bVNobWVt LT5hdl9sYXVuY2hlcnBpZCA9IDA7CisJCUF1dG9WYWN1dW1TaG1lbS0+YXZfYWN0aXZlX3BhcmFs bGVsX3dvcmtlcnMgPQorCQkJbWF4X3BhcmFsbGVsX2F1dG92YWN1dW1fd29ya2VyczsKIAkJZGNs aXN0X2luaXQoJkF1dG9WYWN1dW1TaG1lbS0+YXZfZnJlZVdvcmtlcnMpOwogCQlkbGlzdF9pbml0 KCZBdXRvVmFjdXVtU2htZW0tPmF2X3J1bm5pbmdXb3JrZXJzKTsKIAkJQXV0b1ZhY3V1bVNobWVt LT5hdl9zdGFydGluZ1dvcmtlciA9IE5VTEw7CkBAIC0zNDMyLDYgKzM0OTUsMTUgQEAgY2hlY2tf YXV0b3ZhY3V1bV93b3JrX21lbShpbnQgKm5ld3ZhbCwgdm9pZCAqKmV4dHJhLCBHdWNTb3VyY2Ug c291cmNlKQogCXJldHVybiB0cnVlOwogfQogCitib29sCitjaGVja19tYXhfcGFyYWxsZWxfYXV0 b3ZhY3V1bV93b3JrZXJzKGludCAqbmV3dmFsLCB2b2lkICoqZXh0cmEsCisJCQkJCQkJCQkgIEd1 Y1NvdXJjZSBzb3VyY2UpCit7CisJaWYgKCpuZXd2YWwgPj0gbWF4X3dvcmtlcl9wcm9jZXNzZXMp CisJCXJldHVybiBmYWxzZTsKKwlyZXR1cm4gdHJ1ZTsKK30KKwogLyoKICAqIFJldHVybnMgd2hl dGhlciB0aGVyZSBpcyBhIGZyZWUgYXV0b3ZhY3V1bSB3b3JrZXIgc2xvdCBhdmFpbGFibGUuCiAg Ki8KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3V0aWxzL2luaXQvZ2xvYmFscy5jIGIvc3JjL2Jh Y2tlbmQvdXRpbHMvaW5pdC9nbG9iYWxzLmMKaW5kZXggZDMxY2I0NWEwNTguLjQwYTkyY2VlY2Q1 IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC91dGlscy9pbml0L2dsb2JhbHMuYworKysgYi9zcmMv YmFja2VuZC91dGlscy9pbml0L2dsb2JhbHMuYwpAQCAtMTQzLDYgKzE0Myw3IEBAIGludAkJCU5C dWZmZXJzID0gMTYzODQ7CiBpbnQJCQlNYXhDb25uZWN0aW9ucyA9IDEwMDsKIGludAkJCW1heF93 b3JrZXJfcHJvY2Vzc2VzID0gODsKIGludAkJCW1heF9wYXJhbGxlbF93b3JrZXJzID0gODsKK2lu dCAgICAgICAgIG1heF9wYXJhbGxlbF9hdXRvdmFjdXVtX3dvcmtlcnMgPSAwOwogaW50CQkJTWF4 QmFja2VuZHMgPSAwOwogCiAvKiBHVUMgcGFyYW1ldGVycyBmb3IgdmFjdXVtICovCmRpZmYgLS1n aXQgYS9zcmMvYmFja2VuZC91dGlscy9taXNjL2d1Y190YWJsZXMuYyBiL3NyYy9iYWNrZW5kL3V0 aWxzL21pc2MvZ3VjX3RhYmxlcy5jCmluZGV4IDJmOGNiZDg2NzU5Li45NTBiNDMwMDEwMCAxMDA2 NDQKLS0tIGEvc3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9ndWNfdGFibGVzLmMKKysrIGIvc3JjL2Jh Y2tlbmQvdXRpbHMvbWlzYy9ndWNfdGFibGVzLmMKQEAgLTM2MDQsNiArMzYwNCwxNiBAQCBzdHJ1 Y3QgY29uZmlnX2ludCBDb25maWd1cmVOYW1lc0ludFtdID0KIAkJTlVMTCwgTlVMTCwgTlVMTAog CX0sCiAKKwl7CisJCXsibWF4X3BhcmFsbGVsX2F1dG92YWN1dW1fd29ya2VycyIsIFBHQ19QT1NU TUFTVEVSLCBSRVNPVVJDRVNfV09SS0VSX1BST0NFU1NFUywKKwkJCWdldHRleHRfbm9vcCgiTWF4 aW11bSBudW1iZXIgb2YgcGFyYWxsZWwgYXV0b3ZhY3V1bSB3b3JrZXJzLCB0aGF0IGNhbiBiZSB0 YWtlbiBmcm9tIGJnd29ya2VycyBwb29sLiIpLAorCQkJZ2V0dGV4dF9ub29wKCJUaGlzIHBhcmFt ZXRlciBpcyBjYXBwZWQgYnkgXCJtYXhfd29ya2VyX3Byb2Nlc3Nlc1wiIChub3QgYnkgXCJhdXRv dmFjdXVtX21heF93b3JrZXJzXCIhKS4iKSwKKwkJfSwKKwkJJm1heF9wYXJhbGxlbF9hdXRvdmFj dXVtX3dvcmtlcnMsCisJCTAsIDAsIE1BWF9CQUNLRU5EUywKKwkJY2hlY2tfbWF4X3BhcmFsbGVs X2F1dG92YWN1dW1fd29ya2VycywgTlVMTCwgTlVMTAorCX0sCisKIAl7CiAJCXsibWF4X3BhcmFs bGVsX21haW50ZW5hbmNlX3dvcmtlcnMiLCBQR0NfVVNFUlNFVCwgUkVTT1VSQ0VTX1dPUktFUl9Q Uk9DRVNTRVMsCiAJCQlnZXR0ZXh0X25vb3AoIlNldHMgdGhlIG1heGltdW0gbnVtYmVyIG9mIHBh cmFsbGVsIHByb2Nlc3NlcyBwZXIgbWFpbnRlbmFuY2Ugb3BlcmF0aW9uLiIpLApkaWZmIC0tZ2l0 IGEvc3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9wb3N0Z3Jlc3FsLmNvbmYuc2FtcGxlIGIvc3JjL2Jh Y2tlbmQvdXRpbHMvbWlzYy9wb3N0Z3Jlc3FsLmNvbmYuc2FtcGxlCmluZGV4IDYzZjk5MWM0Zjkz Li4yM2Y1Yzg5MGY3OCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9wb3N0Z3Jl c3FsLmNvbmYuc2FtcGxlCisrKyBiL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvcG9zdGdyZXNxbC5j b25mLnNhbXBsZQpAQCAtMjIxLDYgKzIyMSw4IEBACiAjbWF4X3BhcmFsbGVsX21haW50ZW5hbmNl X3dvcmtlcnMgPSAyCSMgbGltaXRlZCBieSBtYXhfcGFyYWxsZWxfd29ya2VycwogI21heF9wYXJh bGxlbF93b3JrZXJzID0gOAkJIyBudW1iZXIgb2YgbWF4X3dvcmtlcl9wcm9jZXNzZXMgdGhhdAog CQkJCQkjIGNhbiBiZSB1c2VkIGluIHBhcmFsbGVsIG9wZXJhdGlvbnMKKyNtYXhfcGFyYWxsZWxf YXV0b3ZhY3V1bV93b3JrZXJzID0gMAkjIGRpc2FibGVkIGJ5IGRlZmF1bHQgYW5kIGxpbWl0ZWQg YnkgbWF4X3BhcmFsbGVsX3dvcmtlcnMKKwkJCQkJIyAoY2hhbmdlIHJlcXVpcmVzIHJlc3RhcnQp CiAjcGFyYWxsZWxfbGVhZGVyX3BhcnRpY2lwYXRpb24gPSBvbgogCiAKZGlmZiAtLWdpdCBhL3Ny Yy9pbmNsdWRlL21pc2NhZG1pbi5oIGIvc3JjL2luY2x1ZGUvbWlzY2FkbWluLmgKaW5kZXggMWJl Zjk4NDcxYzMuLjdjMzU3NWI2ODQ5IDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9taXNjYWRtaW4u aAorKysgYi9zcmMvaW5jbHVkZS9taXNjYWRtaW4uaApAQCAtMTc3LDYgKzE3Nyw3IEBAIGV4dGVy biBQR0RMTElNUE9SVCBpbnQgTWF4QmFja2VuZHM7CiBleHRlcm4gUEdETExJTVBPUlQgaW50IE1h eENvbm5lY3Rpb25zOwogZXh0ZXJuIFBHRExMSU1QT1JUIGludCBtYXhfd29ya2VyX3Byb2Nlc3Nl czsKIGV4dGVybiBQR0RMTElNUE9SVCBpbnQgbWF4X3BhcmFsbGVsX3dvcmtlcnM7CitleHRlcm4g UEdETExJTVBPUlQgaW50IG1heF9wYXJhbGxlbF9hdXRvdmFjdXVtX3dvcmtlcnM7CiAKIGV4dGVy biBQR0RMTElNUE9SVCBpbnQgY29tbWl0X3RpbWVzdGFtcF9idWZmZXJzOwogZXh0ZXJuIFBHRExM SU1QT1JUIGludCBtdWx0aXhhY3RfbWVtYmVyX2J1ZmZlcnM7CmRpZmYgLS1naXQgYS9zcmMvaW5j bHVkZS9wb3N0bWFzdGVyL2F1dG92YWN1dW0uaCBiL3NyYy9pbmNsdWRlL3Bvc3RtYXN0ZXIvYXV0 b3ZhY3V1bS5oCmluZGV4IGU4MTM1ZjQxYTFjLi5iNTc2M2U2YWMzNiAxMDA2NDQKLS0tIGEvc3Jj L2luY2x1ZGUvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmgKKysrIGIvc3JjL2luY2x1ZGUvcG9zdG1h c3Rlci9hdXRvdmFjdXVtLmgKQEAgLTY0LDYgKzY0LDEwIEBAIHBnX25vcmV0dXJuIGV4dGVybiB2 b2lkIEF1dG9WYWNXb3JrZXJNYWluKGNvbnN0IHZvaWQgKnN0YXJ0dXBfZGF0YSwgc2l6ZV90IHN0 YXJ0CiBleHRlcm4gYm9vbCBBdXRvVmFjdXVtUmVxdWVzdFdvcmsoQXV0b1ZhY3V1bVdvcmtJdGVt VHlwZSB0eXBlLAogCQkJCQkJCQkgIE9pZCByZWxhdGlvbklkLCBCbG9ja051bWJlciBibGtubyk7 CiAKKy8qIHBhcmFsbGVsIGF1dG92YWN1dW0gc3R1ZmYgKi8KK2V4dGVybiBpbnQgUGFyYWxsZWxB dXRvVmFjdXVtUmVzZXJ2ZVdvcmtlcnMoaW50IG53b3JrZXJzKTsKK2V4dGVybiB2b2lkIFBhcmFs bGVsQXV0b1ZhY3V1bVJlbGVhc2VXb3JrZXJzKGludCBud29ya2Vycyk7CisKIC8qIHNoYXJlZCBt ZW1vcnkgc3R1ZmYgKi8KIGV4dGVybiBTaXplIEF1dG9WYWN1dW1TaG1lbVNpemUodm9pZCk7CiBl eHRlcm4gdm9pZCBBdXRvVmFjdXVtU2htZW1Jbml0KHZvaWQpOwpkaWZmIC0tZ2l0IGEvc3JjL2lu Y2x1ZGUvdXRpbHMvZ3VjX2hvb2tzLmggYi9zcmMvaW5jbHVkZS91dGlscy9ndWNfaG9va3MuaApp bmRleCA3OTlmYTdhY2U2OC4uZDRlNjE3MGQ0NWMgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL3V0 aWxzL2d1Y19ob29rcy5oCisrKyBiL3NyYy9pbmNsdWRlL3V0aWxzL2d1Y19ob29rcy5oCkBAIC0z MSw2ICszMSw4IEBAIGV4dGVybiB2b2lkIGFzc2lnbl9hcHBsaWNhdGlvbl9uYW1lKGNvbnN0IGNo YXIgKm5ld3ZhbCwgdm9pZCAqZXh0cmEpOwogZXh0ZXJuIGNvbnN0IGNoYXIgKnNob3dfYXJjaGl2 ZV9jb21tYW5kKHZvaWQpOwogZXh0ZXJuIGJvb2wgY2hlY2tfYXV0b3ZhY3V1bV93b3JrX21lbShp bnQgKm5ld3ZhbCwgdm9pZCAqKmV4dHJhLAogCQkJCQkJCQkJICBHdWNTb3VyY2Ugc291cmNlKTsK K2V4dGVybiBib29sIGNoZWNrX21heF9wYXJhbGxlbF9hdXRvdmFjdXVtX3dvcmtlcnMoaW50ICpu ZXd2YWwsIHZvaWQgKipleHRyYSwKKwkJCQkJCQkJCQkJCSAgR3VjU291cmNlIHNvdXJjZSk7CiBl eHRlcm4gYm9vbCBjaGVja192YWN1dW1fYnVmZmVyX3VzYWdlX2xpbWl0KGludCAqbmV3dmFsLCB2 b2lkICoqZXh0cmEsCiAJCQkJCQkJCQkJCUd1Y1NvdXJjZSBzb3VyY2UpOwogZXh0ZXJuIGJvb2wg Y2hlY2tfYmFja3RyYWNlX2Z1bmN0aW9ucyhjaGFyICoqbmV3dmFsLCB2b2lkICoqZXh0cmEsCmRp ZmYgLS1naXQgYS9zcmMvaW5jbHVkZS91dGlscy9yZWwuaCBiL3NyYy9pbmNsdWRlL3V0aWxzL3Jl bC5oCmluZGV4IGI1NTIzNTk5MTVmLi4xNjA5MWU2YTc3MyAxMDA2NDQKLS0tIGEvc3JjL2luY2x1 ZGUvdXRpbHMvcmVsLmgKKysrIGIvc3JjL2luY2x1ZGUvdXRpbHMvcmVsLmgKQEAgLTMxMSw2ICsz MTEsOCBAQCB0eXBlZGVmIHN0cnVjdCBGb3JlaWduS2V5Q2FjaGVJbmZvCiB0eXBlZGVmIHN0cnVj dCBBdXRvVmFjT3B0cwogewogCWJvb2wJCWVuYWJsZWQ7CisJaW50CQkJcGFyYWxsZWxfYXV0b3Zh Y3V1bV93b3JrZXJzOyAvKiBtYXggbnVtYmVyIG9mIHBhcmFsbGVsCisJCQkJCQkJCQkJCQlhdXRv dmFjdXVtIHdvcmtlcnMgKi8KIAlpbnQJCQl2YWN1dW1fdGhyZXNob2xkOwogCWludAkJCXZhY3V1 bV9tYXhfdGhyZXNob2xkOwogCWludAkJCXZhY3V1bV9pbnNfdGhyZXNob2xkOwpAQCAtNDA5LDYg KzQxMSwxNiBAQCB0eXBlZGVmIHN0cnVjdCBTdGRSZE9wdGlvbnMKIAkoKHJlbGF0aW9uKS0+cmRf b3B0aW9ucyA/IFwKIAkgKChTdGRSZE9wdGlvbnMgKikgKHJlbGF0aW9uKS0+cmRfb3B0aW9ucykt PnBhcmFsbGVsX3dvcmtlcnMgOiAoZGVmYXVsdHB3KSkKIAorLyoKKyAqIFJlbGF0aW9uR2V0UGFy YWxsZWxBdXRvdmFjdXVtV29ya2VycworICoJCVJldHVybnMgdGhlIHJlbGF0aW9uJ3MgcGFyYWxs ZWxfYXV0b3ZhY3V1bV93b3JrZXJzIHJlbG9wdGlvbiBzZXR0aW5nLgorICoJCU5vdGUgbXVsdGlw bGUgZXZhbCBvZiBhcmd1bWVudCEKKyAqLworI2RlZmluZSBSZWxhdGlvbkdldFBhcmFsbGVsQXV0 b3ZhY3V1bVdvcmtlcnMocmVsYXRpb24sIGRlZmF1bHRwdykgXAorCSgocmVsYXRpb24pLT5yZF9v cHRpb25zID8gXAorCSAoKFN0ZFJkT3B0aW9ucyAqKSAocmVsYXRpb24pLT5yZF9vcHRpb25zKS0+ YXV0b3ZhY3V1bS5wYXJhbGxlbF9hdXRvdmFjdXVtX3dvcmtlcnMgOiBcCisJIChkZWZhdWx0cHcp KQorCiAvKiBWaWV3T3B0aW9ucy0+Y2hlY2tfb3B0aW9uIHZhbHVlcyAqLwogdHlwZWRlZiBlbnVt IFZpZXdPcHRDaGVja09wdGlvbgogewotLSAKMi40My4wCgo= --000000000000e624920635f914b8 Content-Type: text/x-patch; charset="US-ASCII"; name="v4-0002-Sandbox-for-parallel-index-autovacuum.patch" Content-Disposition: attachment; filename="v4-0002-Sandbox-for-parallel-index-autovacuum.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mb3x6qly1 RnJvbSA0YTAyN2NlMDgyYjBiMDk2NGZjMmYyZjFlN2MzNDFhZGZmMTRmNDNiIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBGcmksIDE2IE1heSAyMDI1IDExOjU5OjAzICswNzAwClN1YmplY3Q6IFtQQVRD SCB2NCAyLzJdIFNhbmRib3ggZm9yIHBhcmFsbGVsIGluZGV4IGF1dG92YWN1dW0KCi0tLQogc3Jj L3Rlc3QvbW9kdWxlcy9NYWtlZmlsZSAgICAgICAgICAgICAgICAgICAgIHwgICAxICsKIHNyYy90 ZXN0L21vZHVsZXMvYXV0b3ZhY3V1bS8uZ2l0aWdub3JlICAgICAgICB8ICAgMSArCiBzcmMvdGVz dC9tb2R1bGVzL2F1dG92YWN1dW0vTWFrZWZpbGUgICAgICAgICAgfCAgMTQgKysKIHNyYy90ZXN0 L21vZHVsZXMvYXV0b3ZhY3V1bS9tZXNvbi5idWlsZCAgICAgICB8ICAxMiArKwogLi4uL2F1dG92 YWN1dW0vdC8wMDFfYXV0b3ZhY19wYXJhbGxlbC5wbCAgICAgIHwgMTMxICsrKysrKysrKysrKysr KysrKwogc3JjL3Rlc3QvbW9kdWxlcy9tZXNvbi5idWlsZCAgICAgICAgICAgICAgICAgIHwgICAx ICsKIDYgZmlsZXMgY2hhbmdlZCwgMTYwIGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0 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 YWxsZWwucGwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLmI0MDIyZjIz OTQ4Ci0tLSAvZGV2L251bGwKKysrIGIvc3JjL3Rlc3QvbW9kdWxlcy9hdXRvdmFjdXVtL3QvMDAx X2F1dG92YWNfcGFyYWxsZWwucGwKQEAgLTAsMCArMSwxMzEgQEAKK3VzZSB3YXJuaW5ncyBGQVRB TCA9PiAnYWxsJzsKK3VzZSBQb3N0Z3JlU1FMOjpUZXN0OjpDbHVzdGVyOwordXNlIFBvc3RncmVT UUw6OlRlc3Q6OlV0aWxzOwordXNlIFRlc3Q6Ok1vcmU7CisKK215ICRwc3FsX291dDsKKworbXkg JG5vZGUgPSBQb3N0Z3JlU1FMOjpUZXN0OjpDbHVzdGVyLT5uZXcoJ25vZGUxJyk7Ciskbm9kZS0+ aW5pdDsKKyRub2RlLT5hcHBlbmRfY29uZigncG9zdGdyZXNxbC5jb25mJywgcXF7CisJYXV0b3Zh Y3V1bSA9IG9mZgorCW1heF93YWxfc2l6ZSA9IDQwOTYKKwltYXhfd29ya2VyX3Byb2Nlc3NlcyA9 IDIwCisJbWF4X3BhcmFsbGVsX3dvcmtlcnMgPSAyMAorCW1heF9wYXJhbGxlbF9tYWludGVuYW5j ZV93b3JrZXJzID0gMjAKKwltYXhfcGFyYWxsZWxfYXV0b3ZhY3V1bV93b3JrZXJzID0gMTAKKwls b2dfbWluX21lc3NhZ2VzID0gaW5mbworfSk7Ciskbm9kZS0+c3RhcnQ7CisKK215ICRpbmRleGVz X251bSA9IDgwOworbXkgJGluaXRpYWxfcm93c19udW0gPSAxMDBfMDAwOworbXkgJHBhcmFsbGVs X2F1dG92YWN1dW1fd29ya2VycyA9IDU7CisKKyMgQ3JlYXRlIGJpZyB0YWJsZSBhbmQgY3JlYXRl IHNwZWNpZmllZCBudW1iZXIgb2YgYi10cmVlIGluZGV4ZXMgb24gaXQKKyRub2RlLT5zYWZlX3Bz cWwoJ3Bvc3RncmVzJywgcXF7CisJQ1JFQVRFIFRBQkxFIHRlc3RfYXV0b3ZhYyAoCisJCWlkIFNF UklBTCBQUklNQVJZIEtFWSwKKwkJY29sXzEgSU5URUdFUiwgIGNvbF8yIElOVEVHRVIsICBjb2xf MyBJTlRFR0VSLCAgY29sXzQgSU5URUdFUiwgIGNvbF81IElOVEVHRVIsCisJCWNvbF82IElOVEVH RVIsICBjb2xfNyBJTlRFR0VSLCAgY29sXzggSU5URUdFUiwgIGNvbF85IElOVEVHRVIsICBjb2xf MTAgSU5URUdFUiwKKwkJY29sXzExIElOVEVHRVIsIGNvbF8xMiBJTlRFR0VSLCBjb2xfMTMgSU5U RUdFUiwgY29sXzE0IElOVEVHRVIsIGNvbF8xNSBJTlRFR0VSLAorCQljb2xfMTYgSU5URUdFUiwg Y29sXzE3IElOVEVHRVIsIGNvbF8xOCBJTlRFR0VSLCBjb2xfMTkgSU5URUdFUiwgY29sXzIwIElO VEVHRVIsCisJCWNvbF8yMSBJTlRFR0VSLCBjb2xfMjIgSU5URUdFUiwgY29sXzIzIElOVEVHRVIs IGNvbF8yNCBJTlRFR0VSLCBjb2xfMjUgSU5URUdFUiwKKwkJY29sXzI2IElOVEVHRVIsIGNvbF8y NyBJTlRFR0VSLCBjb2xfMjggSU5URUdFUiwgY29sXzI5IElOVEVHRVIsIGNvbF8zMCBJTlRFR0VS LAorCQljb2xfMzEgSU5URUdFUiwgY29sXzMyIElOVEVHRVIsIGNvbF8zMyBJTlRFR0VSLCBjb2xf MzQgSU5URUdFUiwgY29sXzM1IElOVEVHRVIsCisJCWNvbF8zNiBJTlRFR0VSLCBjb2xfMzcgSU5U RUdFUiwgY29sXzM4IElOVEVHRVIsIGNvbF8zOSBJTlRFR0VSLCBjb2xfNDAgSU5URUdFUiwKKwkJ Y29sXzQxIElOVEVHRVIsIGNvbF80MiBJTlRFR0VSLCBjb2xfNDMgSU5URUdFUiwgY29sXzQ0IElO VEVHRVIsIGNvbF80NSBJTlRFR0VSLAorCQljb2xfNDYgSU5URUdFUiwgY29sXzQ3IElOVEVHRVIs IGNvbF80OCBJTlRFR0VSLCBjb2xfNDkgSU5URUdFUiwgY29sXzUwIElOVEVHRVIsCisJCWNvbF81 MSBJTlRFR0VSLCBjb2xfNTIgSU5URUdFUiwgY29sXzUzIElOVEVHRVIsIGNvbF81NCBJTlRFR0VS LCBjb2xfNTUgSU5URUdFUiwKKwkJY29sXzU2IElOVEVHRVIsIGNvbF81NyBJTlRFR0VSLCBjb2xf NTggSU5URUdFUiwgY29sXzU5IElOVEVHRVIsIGNvbF82MCBJTlRFR0VSLAorCQljb2xfNjEgSU5U RUdFUiwgY29sXzYyIElOVEVHRVIsIGNvbF82MyBJTlRFR0VSLCBjb2xfNjQgSU5URUdFUiwgY29s XzY1IElOVEVHRVIsCisJCWNvbF82NiBJTlRFR0VSLCBjb2xfNjcgSU5URUdFUiwgY29sXzY4IElO VEVHRVIsIGNvbF82OSBJTlRFR0VSLCBjb2xfNzAgSU5URUdFUiwKKwkJY29sXzcxIElOVEVHRVIs IGNvbF83MiBJTlRFR0VSLCBjb2xfNzMgSU5URUdFUiwgY29sXzc0IElOVEVHRVIsIGNvbF83NSBJ TlRFR0VSLAorCQljb2xfNzYgSU5URUdFUiwgY29sXzc3IElOVEVHRVIsIGNvbF83OCBJTlRFR0VS LCBjb2xfNzkgSU5URUdFUiwgY29sXzgwIElOVEVHRVIsCisJCWNvbF84MSBJTlRFR0VSLCBjb2xf ODIgSU5URUdFUiwgY29sXzgzIElOVEVHRVIsIGNvbF84NCBJTlRFR0VSLCBjb2xfODUgSU5URUdF UiwKKwkJY29sXzg2IElOVEVHRVIsIGNvbF84NyBJTlRFR0VSLCBjb2xfODggSU5URUdFUiwgY29s Xzg5IElOVEVHRVIsIGNvbF85MCBJTlRFR0VSLAorCQljb2xfOTEgSU5URUdFUiwgY29sXzkyIElO VEVHRVIsIGNvbF85MyBJTlRFR0VSLCBjb2xfOTQgSU5URUdFUiwgY29sXzk1IElOVEVHRVIsCisJ CWNvbF85NiBJTlRFR0VSLCBjb2xfOTcgSU5URUdFUiwgY29sXzk4IElOVEVHRVIsIGNvbF85OSBJ TlRFR0VSLCBjb2xfMTAwIElOVEVHRVIKKwkpIFdJVEggKHBhcmFsbGVsX2F1dG92YWN1dW1fd29y a2VycyA9ICRwYXJhbGxlbF9hdXRvdmFjdXVtX3dvcmtlcnMpOworCisJRE8gXCRcJAorCURFQ0xB UkUKKwkJaSBJTlRFR0VSOworCUJFR0lOCisJCUZPUiBpIElOIDEuLiRpbmRleGVzX251bSBMT09Q CisJCQlFWEVDVVRFIGZvcm1hdCgnQ1JFQVRFIElOREVYIGlkeF9jb2xfXCVzIE9OIHRlc3RfYXV0 b3ZhYyAoY29sX1wlcyk7JywgaSwgaSk7CisJCUVORCBMT09QOworCUVORCBcJFwkOworfSk7CisK KyRub2RlLT5wc3FsKCdwb3N0Z3JlcycsCisJIlNFTEVDVCBDT1VOVCgqKSBGUk9NIHBnX2luZGV4 IGkKKwkgICBKT0lOIHBnX2NsYXNzIGMgT04gYy5vaWQgPSBpLmluZHJlbGlkCisJICBXSEVSRSBj LnJlbG5hbWUgPSAndGVzdF9hdXRvdmFjJzsiLAorCXN0ZG91dCA9PiBcJHBzcWxfb3V0CispOwor aXMoJHBzcWxfb3V0LCAkaW5kZXhlc19udW0gKyAxLCAiQWxsIGluZGV4ZXMgY3JlYXRlZCBzdWNj ZXNzZnVsbHkiKTsKKworJG5vZGUtPnNhZmVfcHNxbCgncG9zdGdyZXMnLCBxcXsKKwlETyBcJFwk CisJREVDTEFSRQorCSAgICBpIElOVEVHRVI7CisJQkVHSU4KKwkgICAgRk9SIGkgSU4gMS4uJGlu aXRpYWxfcm93c19udW0gTE9PUAorCSAgICAgICAgSU5TRVJUIElOVE8gdGVzdF9hdXRvdmFjICgK KwkgICAgICAgICAgICBjb2xfMSwgY29sXzIsIGNvbF8zLCBjb2xfNCwgY29sXzUsIGNvbF82LCBj b2xfNywgY29sXzgsIGNvbF85LCBjb2xfMTAsCisJICAgICAgICAgICAgY29sXzExLCBjb2xfMTIs IGNvbF8xMywgY29sXzE0LCBjb2xfMTUsIGNvbF8xNiwgY29sXzE3LCBjb2xfMTgsIGNvbF8xOSwg Y29sXzIwLAorCSAgICAgICAgICAgIGNvbF8yMSwgY29sXzIyLCBjb2xfMjMsIGNvbF8yNCwgY29s XzI1LCBjb2xfMjYsIGNvbF8yNywgY29sXzI4LCBjb2xfMjksIGNvbF8zMCwKKwkgICAgICAgICAg ICBjb2xfMzEsIGNvbF8zMiwgY29sXzMzLCBjb2xfMzQsIGNvbF8zNSwgY29sXzM2LCBjb2xfMzcs IGNvbF8zOCwgY29sXzM5LCBjb2xfNDAsCisJICAgICAgICAgICAgY29sXzQxLCBjb2xfNDIsIGNv bF80MywgY29sXzQ0LCBjb2xfNDUsIGNvbF80NiwgY29sXzQ3LCBjb2xfNDgsIGNvbF80OSwgY29s XzUwLAorCSAgICAgICAgICAgIGNvbF81MSwgY29sXzUyLCBjb2xfNTMsIGNvbF81NCwgY29sXzU1 LCBjb2xfNTYsIGNvbF81NywgY29sXzU4LCBjb2xfNTksIGNvbF82MCwKKwkgICAgICAgICAgICBj b2xfNjEsIGNvbF82MiwgY29sXzYzLCBjb2xfNjQsIGNvbF82NSwgY29sXzY2LCBjb2xfNjcsIGNv bF82OCwgY29sXzY5LCBjb2xfNzAsCisJICAgICAgICAgICAgY29sXzcxLCBjb2xfNzIsIGNvbF83 MywgY29sXzc0LCBjb2xfNzUsIGNvbF83NiwgY29sXzc3LCBjb2xfNzgsIGNvbF83OSwgY29sXzgw LAorCSAgICAgICAgICAgIGNvbF84MSwgY29sXzgyLCBjb2xfODMsIGNvbF84NCwgY29sXzg1LCBj b2xfODYsIGNvbF84NywgY29sXzg4LCBjb2xfODksIGNvbF85MCwKKwkgICAgICAgICAgICBjb2xf OTEsIGNvbF85MiwgY29sXzkzLCBjb2xfOTQsIGNvbF85NSwgY29sXzk2LCBjb2xfOTcsIGNvbF85 OCwgY29sXzk5LCBjb2xfMTAwCisJICAgICAgICApIFZBTFVFUyAoCisJICAgICAgICAgICAgaSwg aSArIDEsIGkgKyAyLCBpICsgMywgaSArIDQsIGkgKyA1LCBpICsgNiwgaSArIDcsIGkgKyA4LCBp ICsgOSwKKwkgICAgICAgICAgICBpICsgMTAsIGkgKyAxMSwgaSArIDEyLCBpICsgMTMsIGkgKyAx NCwgaSArIDE1LCBpICsgMTYsIGkgKyAxNywgaSArIDE4LCBpICsgMTksCisJICAgICAgICAgICAg aSArIDIwLCBpICsgMjEsIGkgKyAyMiwgaSArIDIzLCBpICsgMjQsIGkgKyAyNSwgaSArIDI2LCBp ICsgMjcsIGkgKyAyOCwgaSArIDI5LAorCSAgICAgICAgICAgIGkgKyAzMCwgaSArIDMxLCBpICsg MzIsIGkgKyAzMywgaSArIDM0LCBpICsgMzUsIGkgKyAzNiwgaSArIDM3LCBpICsgMzgsIGkgKyAz OSwKKwkgICAgICAgICAgICBpICsgNDAsIGkgKyA0MSwgaSArIDQyLCBpICsgNDMsIGkgKyA0NCwg aSArIDQ1LCBpICsgNDYsIGkgKyA0NywgaSArIDQ4LCBpICsgNDksCisJICAgICAgICAgICAgaSAr IDUwLCBpICsgNTEsIGkgKyA1MiwgaSArIDUzLCBpICsgNTQsIGkgKyA1NSwgaSArIDU2LCBpICsg NTcsIGkgKyA1OCwgaSArIDU5LAorCSAgICAgICAgICAgIGkgKyA2MCwgaSArIDYxLCBpICsgNjIs IGkgKyA2MywgaSArIDY0LCBpICsgNjUsIGkgKyA2NiwgaSArIDY3LCBpICsgNjgsIGkgKyA2OSwK KwkgICAgICAgICAgICBpICsgNzAsIGkgKyA3MSwgaSArIDcyLCBpICsgNzMsIGkgKyA3NCwgaSAr IDc1LCBpICsgNzYsIGkgKyA3NywgaSArIDc4LCBpICsgNzksCisJICAgICAgICAgICAgaSArIDgw LCBpICsgODEsIGkgKyA4MiwgaSArIDgzLCBpICsgODQsIGkgKyA4NSwgaSArIDg2LCBpICsgODcs IGkgKyA4OCwgaSArIDg5LAorCSAgICAgICAgICAgIGkgKyA5MCwgaSArIDkxLCBpICsgOTIsIGkg KyA5MywgaSArIDk0LCBpICsgOTUsIGkgKyA5NiwgaSArIDk3LCBpICsgOTgsIGkgKyA5OQorCSAg ICAgICAgKTsKKwkgICAgRU5EIExPT1A7CisJRU5EIFwkXCQ7Cit9KTsKKworJG5vZGUtPnBzcWwo J3Bvc3RncmVzJywKKwkiU0VMRUNUIENPVU5UKCopIEZST00gdGVzdF9hdXRvdmFjOyIsCisJc3Rk b3V0ID0+IFwkcHNxbF9vdXQKKyk7CitpcygkcHNxbF9vdXQsICRpbml0aWFsX3Jvd3NfbnVtLCAi QWxsIGRhdGEgaW5zZXJ0ZWQgaW50byB0YWJsZSBzdWNjZXNzZnVsbHkiKTsKKworJG5vZGUtPnNh ZmVfcHNxbCgncG9zdGdyZXMnLCBxcXsKKwlVUERBVEUgdGVzdF9hdXRvdmFjIFNFVCBjb2xfMSA9 IDAgV0hFUkUgKGNvbF8xICUgMykgPSAwOworCUFOQUxZWkUgdGVzdF9hdXRvdmFjOworfSk7CisK KyMgUmVkdWNlIGF1dG92YWN1dW1fd29ya19tZW0sIHNvIGxlYWRlciBwcm9jZXNzIHdpbGwgcGVy Zm9ybSBwYXJhbGxlbCBpbmRleGkKKyMgdmFjdXVtIHBoYXNlIHNldmVyYWwgdGltZXMKKyRub2Rl LT5hcHBlbmRfY29uZigncG9zdGdyZXNxbC5jb25mJywgcXF7CisJYXV0b3ZhY3V1bV9uYXB0aW1l ID0gJzFzJworCWF1dG92YWN1dW1fdmFjdXVtX3RocmVzaG9sZCA9IDEKKwlhdXRvdmFjdXVtX2Fu YWx5emVfdGhyZXNob2xkID0gMQorCWF1dG92YWN1dW1fdmFjdXVtX3NjYWxlX2ZhY3RvciA9IDAu MQorCWF1dG92YWN1dW1fYW5hbHl6ZV9zY2FsZV9mYWN0b3IgPSAwLjEKKwlhdXRvdmFjdXVtID0g b24KK30pOworCiskbm9kZS0+cmVzdGFydDsKKworIyBzbGVlcCgzNjAwKTsKKworb2soMSwgIlRo ZXJlIGFyZSBubyBzZWdmYXVsdHMiKTsKKworJG5vZGUtPnN0b3A7Citkb25lX3Rlc3RpbmcoKTsK ZGlmZiAtLWdpdCBhL3NyYy90ZXN0L21vZHVsZXMvbWVzb24uYnVpbGQgYi9zcmMvdGVzdC9tb2R1 bGVzL21lc29uLmJ1aWxkCmluZGV4IDlkZTAwNTdiZDFkLi43ZjJhZDgxMGNhMCAxMDA2NDQKLS0t IGEvc3JjL3Rlc3QvbW9kdWxlcy9tZXNvbi5idWlsZAorKysgYi9zcmMvdGVzdC9tb2R1bGVzL21l c29uLmJ1aWxkCkBAIC0xLDUgKzEsNiBAQAogIyBDb3B5cmlnaHQgKGMpIDIwMjItMjAyNSwgUG9z dGdyZVNRTCBHbG9iYWwgRGV2ZWxvcG1lbnQgR3JvdXAKIAorc3ViZGlyKCdhdXRvdmFjdXVtJykK IHN1YmRpcignYnJpbicpCiBzdWJkaXIoJ2NvbW1pdF90cycpCiBzdWJkaXIoJ2RlbGF5X2V4ZWN1 dGlvbicpCi0tIAoyLjQzLjAKCg== --000000000000e624920635f914b8--