Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1vgkXj-002WvE-0s for pgsql-hackers@arkaria.postgresql.org; Fri, 16 Jan 2026 14:11:16 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1vgkXi-003TTN-0Q for pgsql-hackers@arkaria.postgresql.org; Fri, 16 Jan 2026 14:11:14 +0000 Received: from makus.postgresql.org ([2001:4800:3e1:1::229]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from <3danissimo@gmail.com>) id 1vgkXh-003TTA-0Y for pgsql-hackers@lists.postgresql.org; Fri, 16 Jan 2026 14:11:14 +0000 Received: from mail-yw1-x112f.google.com ([2607:f8b0:4864:20::112f]) by makus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.96) (envelope-from <3danissimo@gmail.com>) id 1vgkXc-000lU7-00 for pgsql-hackers@lists.postgresql.org; Fri, 16 Jan 2026 14:11:12 +0000 Received: by mail-yw1-x112f.google.com with SMTP id 00721157ae682-7926d5dbdf7so16750547b3.2 for ; Fri, 16 Jan 2026 06:11:08 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1768572668; x=1769177468; 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=8LcAIs6SwiUxr3IqubrJ9X3wYefo17p1W17hR2xYKeg=; b=lxb1mR5Kdwy16iW8VvgLhNSZ9SL3eD0MP3lfAiOxQyI23u+HFlzJ1y1PNihy+vAJa1 LcM/FUVAkfTC0v/Se1nxn8N0M1KcTz8M0uObgYHybX0bYUKd5lE9CgjvXDdgngkyK9DZ U9yiZLj1eJThaoGn+GU1J5KafW7bGzS4rLPDV9RWOPe6IXzfTVWkhtUARQYV5HUiYNQT 9EvGSL4m3LcLjGYN1yE2ZU9tYSDl5Xm5dl1oolTkFjRNchNlSbgcleb3mARicVre5pDv sxMtvxNSkGxpbUWKGRFvVd3XmLBwYDUD/09S9DQg5+yrInMbxIlJe/MqYFleVGxnUF5O 43fg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1768572668; x=1769177468; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:x-gm-gg:x-gm-message-state:from:to:cc:subject:date :message-id:reply-to; bh=8LcAIs6SwiUxr3IqubrJ9X3wYefo17p1W17hR2xYKeg=; b=FLZLqLWOyhamSh/6lHX7ouZFu7KHApPMVLNGc0Ugfw9ONcPMPEo0RQLdQphaFotKNw 5kGU2q1d15kIcns2PZVyMN5crNnarKG5Xzrq+NHHR6vbJIW72vFrnUSpFoWNwJ5MyM5d Kbi/SnHCG7wGeCRxYzzPAR1OGi7gXgslnhYOParOspViIVHZR2dgRi3xNONYFAyUjb4V PXrUy4fhKJK8Dguk2XAi0R41MuaYRuqGIWsZMmlVoxJuccIGuw96Vq4Jz+FFwgBkdTd1 sH+jEppcD2CCbS+W4Gs8glT/IbkDsb+qYptQRWbq8inV2iPuuCgHFUTrs/r+26l0OC02 7SmA== X-Forwarded-Encrypted: i=1; AJvYcCVfoUS2r5hPq4fzvUMb3f1GcqXse+tJWWqlNCJvXtfOK1H9OTHOeT4kS1yLCSuBZBXHbYFWPUXGou8njRgG@lists.postgresql.org X-Gm-Message-State: AOJu0YwhXThHv9M07JhmqYgk8yxYrU3WSDRrctUGrFujCtTQ08u+Lu2t BOvaa8QwgmOS87ZFcHlMtlMoTvQds455qHqpZ3zwjaxRE0WawFyIdZStEKdZv8yDPfYeOxBXJ2a p+dSCploPfRkbbS6dHK5XqjxZ8sEZGek= X-Gm-Gg: AY/fxX7Hre6Szi8/UgIOXv/HK2cMAnjKApJOad6cs1M634QvBo9ES2MO8HaTgDM5zuy b2g3XpmQAQd4Qs6N+a6LKStX9AT06Y6XNgcdJPjE8nREPOB2ZxkGeM5AOxHX2O1S3HQvKOUidTS 93V4iDNT/+JeGloA5ZrA4eYJiijDajvoQQgU4ZTA4zsTztI+3yZNwexKuxbg6hDoRRumP7yDNUo xXIgLgnTKRDkInTLkovxKEd6KltU0JlivBG3F8+zqcSdNE3Sr6Pya7+u+inWYdIkK4jDakozw== X-Received: by 2002:a53:b98b:0:b0:644:60d9:7507 with SMTP id 956f58d0204a3-6491650777bmr1898984d50.87.1768572667584; Fri, 16 Jan 2026 06:11:07 -0800 (PST) MIME-Version: 1.0 References: In-Reply-To: From: Daniil Davydov <3danissimo@gmail.com> Date: Fri, 16 Jan 2026 21:10:54 +0700 X-Gm-Features: AZwV_Qhvpe3WCU5NAl__BD51LZy2fNCnahvw621b_cD2m4lvRNzKWWtScjw_0bM Message-ID: Subject: Re: POC: Parallel processing of indexes in autovacuum To: Masahiko Sawada Cc: Sami Imseih , Alexander Korotkov , Matheus Alcantara , Maxim Orlov , Postgres hackers Content-Type: multipart/mixed; boundary="0000000000009cbd1f064881e9cc" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --0000000000009cbd1f064881e9cc Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Hi, On Thu, Jan 15, 2026 at 9:13=E2=80=AFAM Masahiko Sawada wrote: > > Thank you for updating the patches! Here are review comments. > Thank you for the review! > > +static void > +autovacuum_worker_before_shmem_exit(int code, Datum arg) > +{ > + if (code !=3D 0) > + AutoVacuumReleaseAllParallelWorkers(); > + > + Assert(av_nworkers_reserved =3D=3D 0); > +} > > While adding the assertion here makes sense, the assertion won't work > in non-assertion builds. I guess it's safer to call > AutoVacuumReleaseAllParallelWorkers() regardless of the code to ensure > that no autovacuum workers exit while holding parallel workers. > OK, I agree. > --- > + before_shmem_exit(autovacuum_worker_before_shmem_exit, 0); > > I think it would be better to set this callback later like before the > main loop of processing the tables as it makes no sense even if we set > it very early. Yeah, agree. I'll also add a comment for it, because we already have a "ReleaseAllParallelWorkers" function call in the try/catch block below. > > --- > + /* > + * Cap the number of free workers by new parameter's value, if needed= . > + */ > + AutoVacuumShmem->av_freeParallelWorkers =3D > + Min(AutoVacuumShmem->av_freeParallelWorkers, > + autovacuum_max_parallel_workers); > + > + if (autovacuum_max_parallel_workers > prev_max_parallel_workers) > + { > + /* > + * If user wants to increase number of parallel autovacuum worker= s, we > + * must increase number of free workers. > + */ > + AutoVacuumShmem->av_freeParallelWorkers +=3D > + (autovacuum_max_parallel_workers - prev_max_parallel_workers)= ; > + } > > Suppose the previous autovacuum_max_parallel_workers is 5 and there > are 2 workers are reserved (i.e., there are 3 free parallel workers), > if the autovacuum_max_parallel_workers changes to 2, the new > AutoVacuumShmem->av_freeParallelWorkers would be 2 based on the above > codes, but I believe that the new number of free workers should be 0 > as there are already 2 workers are running. What do you think? I guess > we can calculate the new number of free workers by: > > Max((autovacuum_max_parallel_workers - prev_max_parallel_workers) + > AutoVacuumShmem->av_freeParallelWorkers), 0) > If av_max_parallel_workers was changed to 2, then we not only set freeParallelWorkers to 2 but also set maxParallelWorkers to 2. Thus, when previously reserved two workers are released, av leader will encounter this code: /* * If the maximum number of parallel workers was reduced during execution, * we must cap available workers number by its new value. */ AutoVacuumShmem->av_freeParallelWorkers =3D Min(AutoVacuumShmem->av_freeParallelWorkers + nworkers, AutoVacuumShmem->av_maxParallelWorkers); I.e. freeParallelWorkers will be left as "2". The formula you suggested is also correct, but if you have no objections, I would prefer not to change the existing logic. It seems more reliable for me when av leader explicitly can consider such a situation. > --- > I've attached a patch proposing some minor changes. > Thanks! I agree with all fixes except a single one: - * NOTE: We will try to provide as many workers as requested, even if call= er - * will occupy all available workers. I think that this is a pretty important point. I'll leave this NOTE in the v19 patch set. Do you mind? > > + /* > + * Number of planned and actually launched parallel workers for all i= ndex > + * scans, or NULL > + */ > + PVWorkersUsage *workers_usage; > > I think that LVRelState can have PVWorkersUsage instead of a pointer to i= t. > Previously I used the NULL value of this pointer as a flag that we don't ne= ed to log workers usage. Now I'll add boolean flag for this purpose (IIUC, "nplanned > 0" condition is not enough to determine whether we should log workers usage, because VACUUM PARALLEL can be called without VERBOSE). > --- > + /* > + * Allocate space for workers usage statistics. Thus, we explicit= ly > + * make clear that such statistics must be accumulated. For now, = this > + * is used only by autovacuum leader worker, because it must log = it in > + * the end of table processing. > + */ > + vacrel->workers_usage =3D AmAutoVacuumWorkerProcess() ? > + (PVWorkersUsage *) palloc0(sizeof(PVWorkersUsage)) : > + NULL; > > I think we can report the worker statistics even in VACUUM VERBOSE > logs. Currently VACUUM VERBOSE reports the worker usage just during > index vacuuming but it would make sense to report the overall > statistics in vacuum logs. It would help make VACUUM VERBOSE logs and > autovacuum logs consistent. > Agree. > But we don't need to report the worker usage if we didn't use the > parallel vacuum (i.e., if npanned =3D=3D 0). > As I wrote above - we don't need to log workers usage if the VERBOSE option is not specified (even if nplanned > 0). Am I missing something? > --- > + /* Remember these values, if we asked to. */ > + if (wusage !=3D NULL) > + { > + wusage->nlaunched +=3D pvs->pcxt->nworkers_launched; > + wusage->nplanned +=3D nworkers; > + } > > This code runs after the attempt to reserve parallel workers. > Consequently, if we fail to reserve any workers due to > autovacuum_max_parallel_workers, we report the status as if parallel > vacuum wasn't planned at all. I think knowing the number of workers > that were planned but not reserved would provide valuable insight for > users tuning autovacuum_max_parallel_workers. > 100% agree. > --- > + if (vacrel->workers_usage) > + appendStringInfo(&buf, > + _("parallel index vacuum/cleanup : > workers planned =3D %d, workers launched =3D %d\n"), > + vacrel->workers_usage->nplanned, > + vacrel->workers_usage->nlaunched); > > Since these numbers are the total number of workers planned and > launched, how about changing it to something "parallel index > vacuum/cleanup: %d workers were planned and %d workers were launched > in total"? > Agree. > > +typedef enum AVLeaderFaulureType > +{ > + FAIL_NONE, > + FAIL_ERROR, > + FAIL_FATAL, > +} AVLeaderFaulureType; > > I'm concerned that it is somewhat overwrapped with what injection > points does as we can set 'error' to injection_points_attach(). For > the FATAL error, we can terminate the autovacuum worker by using > pg_terminate_backend() that keeps waiting due to > injection_point_attach() with action=3D'wait'. > Oh, I didn't know about the possibility of testing FATAL errors with pg_terminate_backend. After reading your letter I found this pattern in signal_autovacuum.pl. This is beautiful. Thank you, I'll rework these tests. > --- > + /* > + * Injection point to help exercising number of available parallel > + * autovacuum workers. > + */ > + INJECTION_POINT("autovacuum-set-free-parallel-workers-num", > + &AutoVacuumShmem->av_freeParallelWorkers); > > This injection point is added to two places. IIUC the purpose of this > function is to update the free_parallel_workers of InjPointState. And > that value is taken by get_parallel_autovacuum_free_workers() SQL > function during the TAP test. I guess it's better to have > get_parallel_autovacuum_free_workers() function to direcly check > av_freeParallelWorkers with a proper locking. > Agree. > --- > It would be great if we could test the av_freeParallelWorkers > adjustment when max_parallel_maintenance_workers changes. > You mean "when autovacuum_max_parallel_workers changes"? I'll add a test for it. > > * 0005 patch > > +typedef struct PVSharedCostParams > +{ > + slock_t spinlock; /* protects all fields below */ > + > + /* Copies of corresponding parameters from autovacuum leader process = */ > + double cost_delay; > + int cost_limit; > +} PVSharedCostParams; > > Since Parallel workers don't reload the config file I think other > vacuum delay related parameters such as VacuumCostPage{Miss|Hit|Dirty} > also needs to be shared by the leader. > Yes, I remember it. I didn't add them in the previous patch because it was experimental. I'll add all appropriate parameters in v19. > --- > + if (!AmAutoVacuumWorkerProcess()) > + { > + /* > + * If we are autovacuum parallel worker, check whether cost-based > + * parameters had changed in leader worker. > + * If so, vacuum_cost_delay and vacuum_cost_limit will be set to = the > + * values which leader worker is operating on. > + * > + * Do it before checking VacuumCostActive, because its value migh= t be > + * changed after leader's parameters consumption. > + */ > + parallel_vacuum_fix_cost_based_params(); > + } > > We need to add checks to prevent the normal backend running the VACUUM > command from calling parallel_vacuum_fix_cost_based_params(). > We already have such check inside the "fix_cost_based" function : /* Check whether we are running parallel autovacuum */ if (pv_shared_cost_params =3D=3D NULL) return false; We also have this comment: * If we are autovacuum parallel worker, check whether cost-based * parameters had changed in leader worker. As an alternative, I'll add comment explicitly saying that process will immediately return if it not parallel autovacuum participant. > IIUC autovacuum parallel workers would call > parallel_vacuum_fix_cost_based_params() and update their > vacuum_cost_{delay|limit} every vacuum_delay_point(). > Yep. > --- > +/* > + * Function to be called from parallel autovacuum worker in order to syn= c > + * some cost-based delay parameter with the leader worker. > + */ > +bool > +parallel_vacuum_fix_cost_based_params(void) > +{ > > The 'fix' doesn't sound right to me as it's not broken actually. How > about something like parallel_vacuum_update_shared_delay_params? > Agree. > + Assert(IsParallelWorker() && !AmAutoVacuumWorkerProcess()); > + > + SpinLockAcquire(&pv_shared_cost_params->spinlock); > + > + vacuum_cost_delay =3D pv_shared_cost_params->cost_delay; > + vacuum_cost_limit =3D pv_shared_cost_params->cost_limit; > + > + SpinLockRelease(&pv_shared_cost_params->spinlock); > > IIUC autovacuum parallel workers seems to update their > vacuum_cost_{delay|limit} every vacuum_delay_point(), which seems not > good. Can we somehow avoid unnecessary updates? More precisely, parallel worker *reads* leader's parameters every delay_poi= nt. Obviously, this does not mean that the parameters will necessarily be updat= ed. But I don't see anything wrong with this logic. We just every time get the = most relevant parameters from the leader. Of course we can introduce some signaling mechanism, but it will have the same effect as in the current cod= e. > --- > + > + if (vacuum_cost_delay > 0 && !VacuumFailsafeActive) > + VacuumCostActive =3D true; > + > > Should we consider the case of disabling VacuumCostActive as well? > I think that we should. I'll add VacuumUpdateCosts function call instead of write this logic manually. IIUC, it will not break anything. Again, thank you very much for the review! Please, see v19 patches which including all above comments and zengman's notice. Main changes : 1) Fixes for before_shmem_exit callback 2) Some comments reword + pgindent on all files 3) Workers usage can also be reported for VACUUM PARALLEL 4) Deeply reworked tests 5) Propagation (from leader to worker) of all cost-based delay parameters I have also changed structure of the patch set - now test and documentation are the last patches to be applied. -- Best regards, Daniil Davydov --0000000000009cbd1f064881e9cc Content-Type: text/x-patch; charset="US-ASCII"; name="v19-0005-Documentation-for-parallel-autovacuum.patch" Content-Disposition: attachment; filename="v19-0005-Documentation-for-parallel-autovacuum.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mkgyhkes0 RnJvbSA5NjE4MGExYjRhNzhjNjIwMmM5NTEzMWFmZWUyYjc1YmU4ZmNjNTM0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBTdW4sIDIzIE5vdiAyMDI1IDAyOjMyOjQ0ICswNzAwClN1YmplY3Q6IFtQQVRD SCB2MTkgNS81XSBEb2N1bWVudGF0aW9uIGZvciBwYXJhbGxlbCBhdXRvdmFjdXVtCgotLS0KIGRv Yy9zcmMvc2dtbC9jb25maWcuc2dtbCAgICAgICAgICAgfCAxNyArKysrKysrKysrKysrKysrKwog ZG9jL3NyYy9zZ21sL21haW50ZW5hbmNlLnNnbWwgICAgICB8IDEyICsrKysrKysrKysrKwogZG9j L3NyYy9zZ21sL3JlZi9jcmVhdGVfdGFibGUuc2dtbCB8IDIwICsrKysrKysrKysrKysrKysrKysr CiAzIGZpbGVzIGNoYW5nZWQsIDQ5IGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9kb2Mvc3Jj L3NnbWwvY29uZmlnLnNnbWwgYi9kb2Mvc3JjL3NnbWwvY29uZmlnLnNnbWwKaW5kZXggMGZhZDM0 ZGE2ZWIuLmM2NDg5N2Y0NzA3IDEwMDY0NAotLS0gYS9kb2Mvc3JjL3NnbWwvY29uZmlnLnNnbWwK KysrIGIvZG9jL3NyYy9zZ21sL2NvbmZpZy5zZ21sCkBAIC0yODQ5LDYgKzI4NDksNyBAQCBpbmNs dWRlX2RpciAnY29uZi5kJwogICAgICAgICA8cGFyYT4KICAgICAgICAgIFdoZW4gY2hhbmdpbmcg dGhpcyB2YWx1ZSwgY29uc2lkZXIgYWxzbyBhZGp1c3RpbmcKICAgICAgICAgIDx4cmVmIGxpbmtl bmQ9Imd1Yy1tYXgtcGFyYWxsZWwtd29ya2VycyIvPiwKKyAgICAgICAgIDx4cmVmIGxpbmtlbmQ9 Imd1Yy1hdXRvdmFjdXVtLW1heC1wYXJhbGxlbC13b3JrZXJzIi8+LAogICAgICAgICAgPHhyZWYg bGlua2VuZD0iZ3VjLW1heC1wYXJhbGxlbC1tYWludGVuYW5jZS13b3JrZXJzIi8+LCBhbmQKICAg ICAgICAgIDx4cmVmIGxpbmtlbmQ9Imd1Yy1tYXgtcGFyYWxsZWwtd29ya2Vycy1wZXItZ2F0aGVy Ii8+LgogICAgICAgICA8L3BhcmE+CkBAIC05Mjg0LDYgKzkyODUsMjIgQEAgQ09QWSBwb3N0Z3Jl c19sb2cgRlJPTSAnL2Z1bGwvcGF0aC90by9sb2dmaWxlLmNzdicgV0lUSCBjc3Y7CiAgICAgICAg PC9saXN0aXRlbT4KICAgICAgIDwvdmFybGlzdGVudHJ5PgogCisgICAgICA8dmFybGlzdGVudHJ5 IGlkPSJndWMtYXV0b3ZhY3V1bS1tYXgtcGFyYWxsZWwtd29ya2VycyIgeHJlZmxhYmVsPSJhdXRv dmFjdXVtX21heF9wYXJhbGxlbF93b3JrZXJzIj4KKyAgICAgICAgPHRlcm0+PHZhcm5hbWU+YXV0 b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2VyczwvdmFybmFtZT4gKDx0eXBlPmludGVnZXI8L3R5 cGU+KQorICAgICAgICA8aW5kZXh0ZXJtPgorICAgICAgICAgPHByaW1hcnk+PHZhcm5hbWU+YXV0 b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2VyczwvdmFybmFtZT48L3ByaW1hcnk+CisgICAgICAg ICA8c2Vjb25kYXJ5PmNvbmZpZ3VyYXRpb24gcGFyYW1ldGVyPC9zZWNvbmRhcnk+CisgICAgICAg IDwvaW5kZXh0ZXJtPgorICAgICAgICA8L3Rlcm0+CisgICAgICAgIDxsaXN0aXRlbT4KKyAgICAg ICAgIDxwYXJhPgorICAgICAgICAgIFNldHMgdGhlIG1heGltdW0gbnVtYmVyIG9mIHBhcmFsbGVs IGF1dG92YWN1dW0gd29ya2VycyB0aGF0CisgICAgICAgICAgY2FuIGJlIHVzZWQgZm9yIHBhcmFs bGVsIGluZGV4IHZhY3V1bWluZyBhdCBvbmUgdGltZS4gSXMgY2FwcGVkIGJ5CisgICAgICAgICAg PHhyZWYgbGlua2VuZD0iZ3VjLW1heC13b3JrZXItcHJvY2Vzc2VzIi8+LiBUaGUgZGVmYXVsdCBp cyAyLgorICAgICAgICAgPC9wYXJhPgorICAgICAgICA8L2xpc3RpdGVtPgorICAgICA8L3Zhcmxp c3RlbnRyeT4KKwogICAgICA8L3ZhcmlhYmxlbGlzdD4KICAgICA8L3NlY3QyPgogCmRpZmYgLS1n aXQgYS9kb2Mvc3JjL3NnbWwvbWFpbnRlbmFuY2Uuc2dtbCBiL2RvYy9zcmMvc2dtbC9tYWludGVu YW5jZS5zZ21sCmluZGV4IDdjOTU4YjA2MjczLi5jOWY5MTYzYzU1MSAxMDA2NDQKLS0tIGEvZG9j L3NyYy9zZ21sL21haW50ZW5hbmNlLnNnbWwKKysrIGIvZG9jL3NyYy9zZ21sL21haW50ZW5hbmNl LnNnbWwKQEAgLTkyNiw2ICs5MjYsMTggQEAgSElOVDogIEV4ZWN1dGUgYSBkYXRhYmFzZS13aWRl IFZBQ1VVTSBpbiB0aGF0IGRhdGFiYXNlLgogICAgIGF1dG92YWN1dW0gd29ya2VycycgYWN0aXZp dHkuCiAgICA8L3BhcmE+CiAKKyAgIDxwYXJhPgorICAgIElmIGFuIGF1dG92YWN1dW0gd29ya2Vy IHByb2Nlc3MgY29tZXMgYWNyb3NzIGEgdGFibGUgd2l0aCB0aGUgZW5hYmxlZAorICAgIDx4cmVm IGxpbmtlbmQ9InJlbG9wdGlvbi1hdXRvdmFjdXVtLXBhcmFsbGVsLXdvcmtlcnMiLz4gc3RvcmFn ZSBwYXJhbWV0ZXIsCisgICAgaXQgd2lsbCBsYXVuY2ggcGFyYWxsZWwgd29ya2VycyBpbiBvcmRl ciB0byB2YWN1dW0gaW5kZXhlcyBvZiB0aGlzIHRhYmxlCisgICAgaW4gYSBwYXJhbGxlbCBtb2Rl LiBQYXJhbGxlbCB3b3JrZXJzIGFyZSB0YWtlbiBmcm9tIHRoZSBwb29sIG9mIHByb2Nlc3Nlcwor ICAgIGVzdGFibGlzaGVkIGJ5IDx4cmVmIGxpbmtlbmQ9Imd1Yy1tYXgtd29ya2VyLXByb2Nlc3Nl cyIvPiwgbGltaXRlZCBieQorICAgIDx4cmVmIGxpbmtlbmQ9Imd1Yy1tYXgtcGFyYWxsZWwtd29y a2VycyIvPi4KKyAgICBUaGUgdG90YWwgbnVtYmVyIG9mIHBhcmFsbGVsIGF1dG92YWN1dW0gd29y a2VycyB0aGF0IGNhbiBiZSBhY3RpdmUgYXQgb25lCisgICAgdGltZSBpcyBsaW1pdGVkIGJ5IHRo ZSA8eHJlZiBsaW5rZW5kPSJndWMtYXV0b3ZhY3V1bS1tYXgtcGFyYWxsZWwtd29ya2VycyIvPgor ICAgIGNvbmZpZ3VyYXRpb24gcGFyYW1ldGVyLgorICAgPC9wYXJhPgorCiAgICA8cGFyYT4KICAg ICBJZiBzZXZlcmFsIGxhcmdlIHRhYmxlcyBhbGwgYmVjb21lIGVsaWdpYmxlIGZvciB2YWN1dW1p bmcgaW4gYSBzaG9ydAogICAgIGFtb3VudCBvZiB0aW1lLCBhbGwgYXV0b3ZhY3V1bSB3b3JrZXJz IG1pZ2h0IGJlY29tZSBvY2N1cGllZCB3aXRoCmRpZmYgLS1naXQgYS9kb2Mvc3JjL3NnbWwvcmVm L2NyZWF0ZV90YWJsZS5zZ21sIGIvZG9jL3NyYy9zZ21sL3JlZi9jcmVhdGVfdGFibGUuc2dtbApp bmRleCA3N2M1YTc2M2Q0NS4uMzU5MmM5YWNmZjkgMTAwNjQ0Ci0tLSBhL2RvYy9zcmMvc2dtbC9y ZWYvY3JlYXRlX3RhYmxlLnNnbWwKKysrIGIvZG9jL3NyYy9zZ21sL3JlZi9jcmVhdGVfdGFibGUu c2dtbApAQCAtMTcxNyw2ICsxNzE3LDI2IEBAIFdJVEggKCBNT0RVTFVTIDxyZXBsYWNlYWJsZSBj bGFzcz0icGFyYW1ldGVyIj5udW1lcmljX2xpdGVyYWw8L3JlcGxhY2VhYmxlPiwgUkVNCiAgICAg PC9saXN0aXRlbT4KICAgIDwvdmFybGlzdGVudHJ5PgogCisgIDx2YXJsaXN0ZW50cnkgaWQ9InJl bG9wdGlvbi1hdXRvdmFjdXVtLXBhcmFsbGVsLXdvcmtlcnMiIHhyZWZsYWJlbD0iYXV0b3ZhY3V1 bV9wYXJhbGxlbF93b3JrZXJzIj4KKyAgICA8dGVybT48bGl0ZXJhbD5hdXRvdmFjdXVtX3BhcmFs bGVsX3dvcmtlcnM8L2xpdGVyYWw+ICg8dHlwZT5pbnRlZ2VyPC90eXBlPikKKyAgICA8aW5kZXh0 ZXJtPgorICAgICA8cHJpbWFyeT48dmFybmFtZT5hdXRvdmFjdXVtX3BhcmFsbGVsX3dvcmtlcnM8 L3Zhcm5hbWU+IHN0b3JhZ2UgcGFyYW1ldGVyPC9wcmltYXJ5PgorICAgIDwvaW5kZXh0ZXJtPgor ICAgIDwvdGVybT4KKyAgICA8bGlzdGl0ZW0+CisgICAgIDxwYXJhPgorICAgICAgU2V0cyB0aGUg bWF4aW11bSBudW1iZXIgb2YgcGFyYWxsZWwgYXV0b3ZhY3V1bSB3b3JrZXJzIHRoYXQgY2FuIHBy b2Nlc3MKKyAgICAgIGluZGV4ZXMgb2YgdGhpcyB0YWJsZS4KKyAgICAgIFRoZSBkZWZhdWx0IHZh bHVlIGlzIC0xLCB3aGljaCBtZWFucyBubyBwYXJhbGxlbCBpbmRleCB2YWN1dW1pbmcgZm9yCisg ICAgICB0aGlzIHRhYmxlLiBJZiB2YWx1ZSBpcyAwIHRoZW4gcGFyYWxsZWwgZGVncmVlIHdpbGwg Y29tcHV0ZWQgYmFzZWQgb24KKyAgICAgIG51bWJlciBvZiBpbmRleGVzLgorICAgICAgTm90ZSB0 aGF0IHRoZSBjb21wdXRlZCBudW1iZXIgb2Ygd29ya2VycyBtYXkgbm90IGFjdHVhbGx5IGJlIGF2 YWlsYWJsZSBhdAorICAgICAgcnVuIHRpbWUuIElmIHRoaXMgb2NjdXJzLCB0aGUgYXV0b3ZhY3V1 bSB3aWxsIHJ1biB3aXRoIGZld2VyIHdvcmtlcnMKKyAgICAgIHRoYW4gZXhwZWN0ZWQuCisgICAg IDwvcGFyYT4KKyAgICA8L2xpc3RpdGVtPgorICAgPC92YXJsaXN0ZW50cnk+CisKICAgIDx2YXJs aXN0ZW50cnkgaWQ9InJlbG9wdGlvbi1hdXRvdmFjdXVtLXZhY3V1bS10aHJlc2hvbGQiIHhyZWZs YWJlbD0iYXV0b3ZhY3V1bV92YWN1dW1fdGhyZXNob2xkIj4KICAgICA8dGVybT48bGl0ZXJhbD5h dXRvdmFjdXVtX3ZhY3V1bV90aHJlc2hvbGQ8L2xpdGVyYWw+LCA8bGl0ZXJhbD50b2FzdC5hdXRv dmFjdXVtX3ZhY3V1bV90aHJlc2hvbGQ8L2xpdGVyYWw+ICg8dHlwZT5pbnRlZ2VyPC90eXBlPikK ICAgICA8aW5kZXh0ZXJtPgotLSAKMi40My4wCgo= --0000000000009cbd1f064881e9cc Content-Type: text/x-patch; charset="US-ASCII"; name="v19-0003-Cost-based-parameters-propagation-for-parallel-a.patch" Content-Disposition: attachment; filename="v19-0003-Cost-based-parameters-propagation-for-parallel-a.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mkgyhkfs2 RnJvbSBiYTMwZTIxNzA3M2NlZTgyMWNkODQyZjEyZWQ5MWU0YzEwYWRiMjU1IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBUaHUsIDE1IEphbiAyMDI2IDIzOjE1OjQ4ICswNzAwClN1YmplY3Q6IFtQQVRD SCB2MTkgMy81XSBDb3N0IGJhc2VkIHBhcmFtZXRlcnMgcHJvcGFnYXRpb24gZm9yIHBhcmFsbGVs CiBhdXRvdmFjdXVtCgotLS0KIHNyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jICAgICAgICAg fCAyOSArKysrKysrLQogc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYyB8IDk5 ICsrKysrKysrKysrKysrKysrKysrKysrKysrKwogc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRv dmFjdXVtLmMgICB8ICAyICstCiBzcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0uaCAgICAgICAg IHwgIDIgKwogNCBmaWxlcyBjaGFuZ2VkLCAxMjkgaW5zZXJ0aW9ucygrKSwgMyBkZWxldGlvbnMo LSkKCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW0uYyBiL3NyYy9iYWNr ZW5kL2NvbW1hbmRzL3ZhY3V1bS5jCmluZGV4IGFhNGZiZWMxNDNmLi40NjIyMTA3NzM0ZiAxMDA2 NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMKKysrIGIvc3JjL2JhY2tlbmQv Y29tbWFuZHMvdmFjdXVtLmMKQEAgLTI0MzAsOCArMjQzMCwyNyBAQCB2YWN1dW1fZGVsYXlfcG9p bnQoYm9vbCBpc19hbmFseXplKQogCS8qIEFsd2F5cyBjaGVjayBmb3IgaW50ZXJydXB0cyAqLwog CUNIRUNLX0ZPUl9JTlRFUlJVUFRTKCk7CiAKLQlpZiAoSW50ZXJydXB0UGVuZGluZyB8fAotCQko IVZhY3V1bUNvc3RBY3RpdmUgJiYgIUNvbmZpZ1JlbG9hZFBlbmRpbmcpKQorCWlmIChJbnRlcnJ1 cHRQZW5kaW5nKQorCQlyZXR1cm47CisKKwlpZiAoIUFtQXV0b1ZhY3V1bVdvcmtlclByb2Nlc3Mo KSkKKwl7CisJCS8qCisJCSAqIElmIHdlIGFyZSBwYXJhbGxlbCAqYXV0b3ZhY3V1bSogd29ya2Vy LCBjaGVjayB3aGV0aGVyIHJlbGF0ZWQgdG8KKwkJICogY29zdC1iYXNlZCBkZWxheSBwYXJhbWV0 ZXJzIGhhZCBjaGFuZ2VkIGluIHRoZSBsZWFkZXIgd29ya2VyLiBJZgorCQkgKiBzbywgY29ycmVz cG9uZGluZyBwYXJhbWV0ZXJzIHdpbGwgYmUgdXBkYXRlZCB0byB0aGUgdmFsdWVzIHdoaWNoCisJ CSAqIGxlYWRlciB3b3JrZXIgaXMgb3BlcmF0aW5nIG9uLgorCQkgKgorCQkgKiBEbyBpdCBiZWZv cmUgY2hlY2tpbmcgVmFjdXVtQ29zdEFjdGl2ZSwgYmVjYXVzZSBpdHMgdmFsdWUgbWlnaHQgYmUK KwkJICogY2hhbmdlZCBhZnRlciBsZWFkZXIncyBwYXJhbWV0ZXJzIGNvbnN1bXB0aW9uLgorCQkg KgorCQkgKiBOb3RlLCB0aGF0IHRoaXMgZnVuY3Rpb24gaGFzIG5vIGVmZmVjdCBpZiB3ZSBhcmUg bm9uLWF1dG92YWN1dW0KKwkJICogcGFyYWxsZWwgd29ya2VyLgorCQkgKi8KKwkJcGFyYWxsZWxf dmFjdXVtX3VwZGF0ZV9zaGFyZWRfZGVsYXlfcGFyYW1zKCk7CisJfQorCisJaWYgKCFWYWN1dW1D b3N0QWN0aXZlICYmICFDb25maWdSZWxvYWRQZW5kaW5nKQogCQlyZXR1cm47CiAKIAkvKgpAQCAt MjQ0NSw2ICsyNDY0LDEyIEBAIHZhY3V1bV9kZWxheV9wb2ludChib29sIGlzX2FuYWx5emUpCiAJ CUNvbmZpZ1JlbG9hZFBlbmRpbmcgPSBmYWxzZTsKIAkJUHJvY2Vzc0NvbmZpZ0ZpbGUoUEdDX1NJ R0hVUCk7CiAJCVZhY3V1bVVwZGF0ZUNvc3RzKCk7CisKKwkJLyoKKwkJICogSWYgd2UgYXJlIHBh cmFsbGVsIGF1dG92YWN1dW0gbGVhZGVyIGFuZCBzb21lIG9mIGNvc3QtYmFzZWQKKwkJICogcGFy YW1ldGVycyBoYWQgY2hhbmdlZCwgbGV0IG90aGVyIHBhcmFsbGVsIHdvcmtlcnMga25vdy4KKwkJ ICovCisJCXBhcmFsbGVsX3ZhY3V1bV9wcm9wYWdhdGVfY29zdF9iYXNlZF9wYXJhbXMoKTsKIAl9 CiAKIAkvKgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwu YyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMKaW5kZXggYzMyMzE0Zjk3 MzEuLjcxNDQ5NjMwYjYzIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1w YXJhbGxlbC5jCisrKyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMKQEAg LTUzLDYgKzUzLDI1IEBACiAjZGVmaW5lIFBBUkFMTEVMX1ZBQ1VVTV9LRVlfV0FMX1VTQUdFCQk0 CiAjZGVmaW5lIFBBUkFMTEVMX1ZBQ1VVTV9LRVlfSU5ERVhfU1RBVFMJCTUKIAorLyoKKyAqIE9u bHkgYXV0b3ZhY3V1bSBsZWFkZXIgY2FuIHJlbG9hZCBjb25maWcgZmlsZS4gV2UgdXNlIHRoaXMg c3RydWN0dXJlIGluCisgKiBwYXJhbGxlbCBhdXRvdmFjdXVtIGZvciBrZWVwaW5nIHdvcmtlcidz IHBhcmFtZXRlcnMgaW4gc3luYyB3aXRoIGxlYWRlcidzCisgKiBwYXJhbWV0ZXJzLgorICovCit0 eXBlZGVmIHN0cnVjdCBQVlNoYXJlZENvc3RQYXJhbXMKK3sKKwlzbG9ja190CQlzcGlubG9jazsJ CS8qIHByb3RlY3RzIGFsbCBmaWVsZHMgYmVsb3cgKi8KKworCS8qIENvcGllcyBvZiBjb3JyZXNw b25kaW5nIHBhcmFtZXRlcnMgZnJvbSBhdXRvdmFjdXVtIGxlYWRlciBwcm9jZXNzICovCisJZG91 YmxlCQljb3N0X2RlbGF5OworCWludAkJCWNvc3RfbGltaXQ7CisJaW50CQkJY29zdF9wYWdlX2Rp cnR5OworCWludAkJCWNvc3RfcGFnZV9oaXQ7CisJaW50CQkJY29zdF9wYWdlX21pc3M7Cit9CQkJ UFZTaGFyZWRDb3N0UGFyYW1zOworCitzdGF0aWMgUFZTaGFyZWRDb3N0UGFyYW1zICogcHZfc2hh cmVkX2Nvc3RfcGFyYW1zID0gTlVMTDsKKwogLyoKICAqIFNoYXJlZCBpbmZvcm1hdGlvbiBhbW9u ZyBwYXJhbGxlbCB3b3JrZXJzLiAgU28gdGhpcyBpcyBhbGxvY2F0ZWQgaW4gdGhlIERTTQogICog c2VnbWVudC4KQEAgLTEyMiw2ICsxNDEsMTggQEAgdHlwZWRlZiBzdHJ1Y3QgUFZTaGFyZWQKIAog CS8qIFN0YXRpc3RpY3Mgb2Ygc2hhcmVkIGRlYWQgaXRlbXMgKi8KIAlWYWNEZWFkSXRlbXNJbmZv IGRlYWRfaXRlbXNfaW5mbzsKKworCS8qCisJICogSWYgJ3RydWUnIHRoZW4gd2UgYXJlIHJ1bm5p bmcgcGFyYWxsZWwgYXV0b3ZhY3V1bS4gT3RoZXJ3aXNlLCB3ZSBhcmUKKwkgKiBydW5uaW5nIHBh cmFsbGVsIG1haW50ZW5lbmNlIFZBQ1VVTS4KKwkgKi8KKwlib29sCQlhbV9wYXJhbGxlbF9hdXRv dmFjdXVtOworCisJLyoKKwkgKiBTdHJ1Y3QgZm9yIHN5bmNpbmcgcGFyYW1ldGVycyBiZXR3ZWVu IHN1cHBvcnRpdmUgcGFyYWxsZWwgYXV0b3ZhY3V1bQorCSAqIHdvcmtlcnMgd2l0aCBsZWFkZXIg d29ya2VyLgorCSAqLworCVBWU2hhcmVkQ29zdFBhcmFtcyBjb3N0X3BhcmFtczsKIH0gUFZTaGFy ZWQ7CiAKIC8qIFN0YXR1cyB1c2VkIGR1cmluZyBwYXJhbGxlbCBpbmRleCB2YWN1dW0gb3IgY2xl YW51cCAqLwpAQCAtMzk1LDYgKzQyNiwxOSBAQCBwYXJhbGxlbF92YWN1dW1faW5pdChSZWxhdGlv biByZWwsIFJlbGF0aW9uICppbmRyZWxzLCBpbnQgbmluZGV4ZXMsCiAJcGdfYXRvbWljX2luaXRf dTMyKCYoc2hhcmVkLT5hY3RpdmVfbndvcmtlcnMpLCAwKTsKIAlwZ19hdG9taWNfaW5pdF91MzIo JihzaGFyZWQtPmlkeCksIDApOwogCisJc2hhcmVkLT5hbV9wYXJhbGxlbF9hdXRvdmFjdXVtID0g QW1BdXRvVmFjdXVtV29ya2VyUHJvY2VzcygpOworCisJaWYgKHNoYXJlZC0+YW1fcGFyYWxsZWxf YXV0b3ZhY3V1bSkKKwl7CisJCXNoYXJlZC0+Y29zdF9wYXJhbXMuY29zdF9kZWxheSA9IHZhY3V1 bV9jb3N0X2RlbGF5OworCQlzaGFyZWQtPmNvc3RfcGFyYW1zLmNvc3RfbGltaXQgPSB2YWN1dW1f Y29zdF9saW1pdDsKKwkJc2hhcmVkLT5jb3N0X3BhcmFtcy5jb3N0X3BhZ2VfZGlydHkgPSBWYWN1 dW1Db3N0UGFnZURpcnR5OworCQlzaGFyZWQtPmNvc3RfcGFyYW1zLmNvc3RfcGFnZV9oaXQgPSBW YWN1dW1Db3N0UGFnZUhpdDsKKwkJc2hhcmVkLT5jb3N0X3BhcmFtcy5jb3N0X3BhZ2VfbWlzcyA9 IFZhY3V1bUNvc3RQYWdlTWlzczsKKwkJU3BpbkxvY2tJbml0KCZzaGFyZWQtPmNvc3RfcGFyYW1z LnNwaW5sb2NrKTsKKwkJcHZfc2hhcmVkX2Nvc3RfcGFyYW1zID0gJihzaGFyZWQtPmNvc3RfcGFy YW1zKTsKKwl9CisKIAlzaG1fdG9jX2luc2VydChwY3h0LT50b2MsIFBBUkFMTEVMX1ZBQ1VVTV9L RVlfU0hBUkVELCBzaGFyZWQpOwogCXB2cy0+c2hhcmVkID0gc2hhcmVkOwogCkBAIC01MzcsNiAr NTgxLDU4IEBAIHBhcmFsbGVsX3ZhY3V1bV9jbGVhbnVwX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFj dXVtU3RhdGUgKnB2cywgbG9uZyBudW1fdGFibGVfdHVwCiAJcGFyYWxsZWxfdmFjdXVtX3Byb2Nl c3NfYWxsX2luZGV4ZXMocHZzLCBudW1faW5kZXhfc2NhbnMsIGZhbHNlLCB3dXNhZ2UpOwogfQog CisvKgorICogRnVuY3Rpb24gdG8gYmUgY2FsbGVkIGZyb20gcGFyYWxsZWwgYXV0b3ZhY3V1bSB3 b3JrZXIgaW4gb3JkZXIgdG8gc3luYworICogc29tZSBjb3N0LWJhc2VkIGRlbGF5IHBhcmFtZXRl ciB3aXRoIHRoZSBsZWFkZXIgd29ya2VyLgorICovCitib29sCitwYXJhbGxlbF92YWN1dW1fdXBk YXRlX3NoYXJlZF9kZWxheV9wYXJhbXModm9pZCkKK3sKKwkvKiBDaGVjayB3aGV0aGVyIHdlIGFy ZSBydW5uaW5nIHBhcmFsbGVsIGF1dG92YWN1dW0gKi8KKwlpZiAocHZfc2hhcmVkX2Nvc3RfcGFy YW1zID09IE5VTEwpCisJCXJldHVybiBmYWxzZTsKKworCUFzc2VydChJc1BhcmFsbGVsV29ya2Vy KCkgJiYgIUFtQXV0b1ZhY3V1bVdvcmtlclByb2Nlc3MoKSk7CisKKwlTcGluTG9ja0FjcXVpcmUo JnB2X3NoYXJlZF9jb3N0X3BhcmFtcy0+c3BpbmxvY2spOworCisJVmFjdXVtQ29zdERlbGF5ID0g cHZfc2hhcmVkX2Nvc3RfcGFyYW1zLT5jb3N0X2RlbGF5OworCVZhY3V1bUNvc3RMaW1pdCA9IHB2 X3NoYXJlZF9jb3N0X3BhcmFtcy0+Y29zdF9saW1pdDsKKwlWYWN1dW1Db3N0UGFnZURpcnR5ID0g cHZfc2hhcmVkX2Nvc3RfcGFyYW1zLT5jb3N0X3BhZ2VfZGlydHk7CisJVmFjdXVtQ29zdFBhZ2VI aXQgPSBwdl9zaGFyZWRfY29zdF9wYXJhbXMtPmNvc3RfcGFnZV9oaXQ7CisJVmFjdXVtQ29zdFBh Z2VNaXNzID0gcHZfc2hhcmVkX2Nvc3RfcGFyYW1zLT5jb3N0X3BhZ2VfbWlzczsKKworCVNwaW5M b2NrUmVsZWFzZSgmcHZfc2hhcmVkX2Nvc3RfcGFyYW1zLT5zcGlubG9jayk7CisKKwlWYWN1dW1V cGRhdGVDb3N0cygpOworCisJcmV0dXJuIHRydWU7Cit9CisKKy8qCisgKiBGdW5jdGlvbiB0byBi ZSBjYWxsZWQgZnJvbSBwYXJhbGxlbCBhdXRvdmFjdXVtIGxlYWRlciBpbiBvcmRlciB0byBwcm9w YWdhdGUKKyAqIHNvbWUgY29zdC1iYXNlZCBwYXJhbWV0ZXJzIHRvIHRoZSBzdXBwb3J0aXZlIHdv cmtlcnMuCisgKi8KK3ZvaWQKK3BhcmFsbGVsX3ZhY3V1bV9wcm9wYWdhdGVfY29zdF9iYXNlZF9w YXJhbXModm9pZCkKK3sKKwkvKiBDaGVjayB3aGV0aGVyIHdlIGFyZSBydW5uaW5nIHBhcmFsbGVs IGF1dG92YWN1dW0gKi8KKwlpZiAocHZfc2hhcmVkX2Nvc3RfcGFyYW1zID09IE5VTEwpCisJCXJl dHVybjsKKworCUFzc2VydChBbUF1dG9WYWN1dW1Xb3JrZXJQcm9jZXNzKCkpOworCisJU3Bpbkxv Y2tBY3F1aXJlKCZwdl9zaGFyZWRfY29zdF9wYXJhbXMtPnNwaW5sb2NrKTsKKworCXB2X3NoYXJl ZF9jb3N0X3BhcmFtcy0+Y29zdF9kZWxheSA9IHZhY3V1bV9jb3N0X2RlbGF5OworCXB2X3NoYXJl ZF9jb3N0X3BhcmFtcy0+Y29zdF9saW1pdCA9IHZhY3V1bV9jb3N0X2xpbWl0OworCXB2X3NoYXJl ZF9jb3N0X3BhcmFtcy0+Y29zdF9wYWdlX2RpcnR5ID0gVmFjdXVtQ29zdFBhZ2VEaXJ0eTsKKwlw dl9zaGFyZWRfY29zdF9wYXJhbXMtPmNvc3RfcGFnZV9oaXQgPSBWYWN1dW1Db3N0UGFnZUhpdDsK Kwlwdl9zaGFyZWRfY29zdF9wYXJhbXMtPmNvc3RfcGFnZV9taXNzID0gVmFjdXVtQ29zdFBhZ2VN aXNzOworCisJU3BpbkxvY2tSZWxlYXNlKCZwdl9zaGFyZWRfY29zdF9wYXJhbXMtPnNwaW5sb2Nr KTsKK30KKwogLyoKICAqIENvbXB1dGUgdGhlIG51bWJlciBvZiBwYXJhbGxlbCB3b3JrZXIgcHJv Y2Vzc2VzIHRvIHJlcXVlc3QuICBCb3RoIGluZGV4CiAgKiB2YWN1dW0gYW5kIGluZGV4IGNsZWFu dXAgY2FuIGJlIGV4ZWN1dGVkIHdpdGggcGFyYWxsZWwgd29ya2Vycy4KQEAgLTEwOTQsNiArMTE5 MCw5IEBAIHBhcmFsbGVsX3ZhY3V1bV9tYWluKGRzbV9zZWdtZW50ICpzZWcsIHNobV90b2MgKnRv YykKIAlWYWN1dW1TaGFyZWRDb3N0QmFsYW5jZSA9ICYoc2hhcmVkLT5jb3N0X2JhbGFuY2UpOwog CVZhY3V1bUFjdGl2ZU5Xb3JrZXJzID0gJihzaGFyZWQtPmFjdGl2ZV9ud29ya2Vycyk7CiAKKwlp ZiAoc2hhcmVkLT5hbV9wYXJhbGxlbF9hdXRvdmFjdXVtKQorCQlwdl9zaGFyZWRfY29zdF9wYXJh bXMgPSAmKHNoYXJlZC0+Y29zdF9wYXJhbXMpOworCiAJLyogU2V0IHBhcmFsbGVsIHZhY3V1bSBz dGF0ZSAqLwogCXB2cy5pbmRyZWxzID0gaW5kcmVsczsKIAlwdnMubmluZGV4ZXMgPSBuaW5kZXhl czsKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jIGIvc3Jj L2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMKaW5kZXggMDk3YjFkZDU1Y2YuLjk4OTY1 ZmQ4ZTJkIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYwor KysgYi9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYwpAQCAtMTY5Myw3ICsxNjkz LDcgQEAgVmFjdXVtVXBkYXRlQ29zdHModm9pZCkKIAl9CiAJZWxzZQogCXsKLQkJLyogTXVzdCBi ZSBleHBsaWNpdCBWQUNVVU0gb3IgQU5BTFlaRSAqLworCQkvKiBNdXN0IGJlIGV4cGxpY2l0IFZB Q1VVTSBvciBBTkFMWVpFIG9yIHBhcmFsbGVsIGF1dG92YWN1dW0gd29ya2VyICovCiAJCXZhY3V1 bV9jb3N0X2RlbGF5ID0gVmFjdXVtQ29zdERlbGF5OwogCQl2YWN1dW1fY29zdF9saW1pdCA9IFZh Y3V1bUNvc3RMaW1pdDsKIAl9CmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1 dW0uaCBiL3NyYy9pbmNsdWRlL2NvbW1hbmRzL3ZhY3V1bS5oCmluZGV4IGVjNWQ3MGFhY2RjLi4w OTY5NmE4ZWFmZSAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmgKKysr IGIvc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmgKQEAgLTQxMSw2ICs0MTEsOCBAQCBleHRl cm4gdm9pZCBwYXJhbGxlbF92YWN1dW1fY2xlYW51cF9hbGxfaW5kZXhlcyhQYXJhbGxlbFZhY3V1 bVN0YXRlICpwdnMsCiAJCQkJCQkJCQkJCQlpbnQgbnVtX2luZGV4X3NjYW5zLAogCQkJCQkJCQkJ CQkJYm9vbCBlc3RpbWF0ZWRfY291bnQsCiAJCQkJCQkJCQkJCQlQVldvcmtlcnNVc2FnZSAqd3Vz YWdlKTsKK2V4dGVybiBib29sIHBhcmFsbGVsX3ZhY3V1bV91cGRhdGVfc2hhcmVkX2RlbGF5X3Bh cmFtcyh2b2lkKTsKK2V4dGVybiB2b2lkIHBhcmFsbGVsX3ZhY3V1bV9wcm9wYWdhdGVfY29zdF9i YXNlZF9wYXJhbXModm9pZCk7CiBleHRlcm4gdm9pZCBwYXJhbGxlbF92YWN1dW1fbWFpbihkc21f c2VnbWVudCAqc2VnLCBzaG1fdG9jICp0b2MpOwogCiAvKiBpbiBjb21tYW5kcy9hbmFseXplLmMg Ki8KLS0gCjIuNDMuMAoK --0000000000009cbd1f064881e9cc Content-Type: text/x-patch; charset="US-ASCII"; name="v19-0001-Parallel-autovacuum.patch" Content-Disposition: attachment; filename="v19-0001-Parallel-autovacuum.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mkgyhkgk4 RnJvbSBjOTYxYzIwYmExMjRhZDkyNTcxMWRmNzlhODJlZjQwMjZiOTIwNzI0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBTdW4sIDIzIE5vdiAyMDI1IDAxOjAzOjI0ICswNzAwClN1YmplY3Q6IFtQQVRD SCB2MTkgMS81XSBQYXJhbGxlbCBhdXRvdmFjdXVtCgotLS0KIHNyYy9iYWNrZW5kL2FjY2Vzcy9j b21tb24vcmVsb3B0aW9ucy5jICAgICAgICB8ICAxMSArKwogc3JjL2JhY2tlbmQvY29tbWFuZHMv dmFjdXVtcGFyYWxsZWwuYyAgICAgICAgIHwgIDM5ICsrKystCiBzcmMvYmFja2VuZC9wb3N0bWFz dGVyL2F1dG92YWN1dW0uYyAgICAgICAgICAgfCAxNTkgKysrKysrKysrKysrKysrKystCiBzcmMv YmFja2VuZC91dGlscy9pbml0L2dsb2JhbHMuYyAgICAgICAgICAgICAgfCAgIDEgKwogc3JjL2Jh Y2tlbmQvdXRpbHMvbWlzYy9ndWMuYyAgICAgICAgICAgICAgICAgIHwgICA4ICstCiBzcmMvYmFj a2VuZC91dGlscy9taXNjL2d1Y19wYXJhbWV0ZXJzLmRhdCAgICAgfCAgIDkgKwogc3JjL2JhY2tl bmQvdXRpbHMvbWlzYy9wb3N0Z3Jlc3FsLmNvbmYuc2FtcGxlIHwgICAyICsKIHNyYy9iaW4vcHNx bC90YWItY29tcGxldGUuaW4uYyAgICAgICAgICAgICAgICB8ICAgMSArCiBzcmMvaW5jbHVkZS9t aXNjYWRtaW4uaCAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEgKwogc3JjL2luY2x1ZGUvcG9z dG1hc3Rlci9hdXRvdmFjdXVtLmggICAgICAgICAgIHwgICA0ICsKIHNyYy9pbmNsdWRlL3V0aWxz L3JlbC5oICAgICAgICAgICAgICAgICAgICAgICB8ICAgNyArCiAxMSBmaWxlcyBjaGFuZ2VkLCAy MzIgaW5zZXJ0aW9ucygrKSwgMTAgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tl bmQvYWNjZXNzL2NvbW1vbi9yZWxvcHRpb25zLmMgYi9zcmMvYmFja2VuZC9hY2Nlc3MvY29tbW9u L3JlbG9wdGlvbnMuYwppbmRleCAwYjgzZjk4ZWQ1Zi4uNjkyYWM0NjczM2UgMTAwNjQ0Ci0tLSBh L3NyYy9iYWNrZW5kL2FjY2Vzcy9jb21tb24vcmVsb3B0aW9ucy5jCisrKyBiL3NyYy9iYWNrZW5k L2FjY2Vzcy9jb21tb24vcmVsb3B0aW9ucy5jCkBAIC0yMjIsNiArMjIyLDE1IEBAIHN0YXRpYyBy ZWxvcHRfaW50IGludFJlbE9wdHNbXSA9CiAJCX0sCiAJCVNQR0lTVF9ERUZBVUxUX0ZJTExGQUNU T1IsIFNQR0lTVF9NSU5fRklMTEZBQ1RPUiwgMTAwCiAJfSwKKwl7CisJCXsKKwkJCSJhdXRvdmFj dXVtX3BhcmFsbGVsX3dvcmtlcnMiLAorCQkJIk1heGltdW0gbnVtYmVyIG9mIHBhcmFsbGVsIGF1 dG92YWN1dW0gd29ya2VycyB0aGF0IGNhbiBiZSB1c2VkIGZvciBwcm9jZXNzaW5nIHRoaXMgdGFi bGUuIiwKKwkJCVJFTE9QVF9LSU5EX0hFQVAsCisJCQlTaGFyZVVwZGF0ZUV4Y2x1c2l2ZUxvY2sK KwkJfSwKKwkJLTEsIC0xLCAxMDI0CisJfSwKIAl7CiAJCXsKIAkJCSJhdXRvdmFjdXVtX3ZhY3V1 bV90aHJlc2hvbGQiLApAQCAtMTg4MSw2ICsxODkwLDggQEAgZGVmYXVsdF9yZWxvcHRpb25zKERh dHVtIHJlbG9wdGlvbnMsIGJvb2wgdmFsaWRhdGUsIHJlbG9wdF9raW5kIGtpbmQpCiAJCXsiZmls bGZhY3RvciIsIFJFTE9QVF9UWVBFX0lOVCwgb2Zmc2V0b2YoU3RkUmRPcHRpb25zLCBmaWxsZmFj dG9yKX0sCiAJCXsiYXV0b3ZhY3V1bV9lbmFibGVkIiwgUkVMT1BUX1RZUEVfQk9PTCwKIAkJb2Zm c2V0b2YoU3RkUmRPcHRpb25zLCBhdXRvdmFjdXVtKSArIG9mZnNldG9mKEF1dG9WYWNPcHRzLCBl bmFibGVkKX0sCisJCXsiYXV0b3ZhY3V1bV9wYXJhbGxlbF93b3JrZXJzIiwgUkVMT1BUX1RZUEVf SU5ULAorCQlvZmZzZXRvZihTdGRSZE9wdGlvbnMsIGF1dG92YWN1dW0pICsgb2Zmc2V0b2YoQXV0 b1ZhY09wdHMsIGF1dG92YWN1dW1fcGFyYWxsZWxfd29ya2Vycyl9LAogCQl7ImF1dG92YWN1dW1f dmFjdXVtX3RocmVzaG9sZCIsIFJFTE9QVF9UWVBFX0lOVCwKIAkJb2Zmc2V0b2YoU3RkUmRPcHRp b25zLCBhdXRvdmFjdXVtKSArIG9mZnNldG9mKEF1dG9WYWNPcHRzLCB2YWN1dW1fdGhyZXNob2xk KX0sCiAJCXsiYXV0b3ZhY3V1bV92YWN1dW1fbWF4X3RocmVzaG9sZCIsIFJFTE9QVF9UWVBFX0lO VCwKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMgYi9z cmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCmluZGV4IGMzYjNjOWVhMjFhLi5j YjQyZDRlNTcyZiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxs ZWwuYworKysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCkBAIC0xLDcg KzEsOSBAQAogLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgKgogICogdmFjdXVtcGFyYWxsZWwuYwotICoJ ICBTdXBwb3J0IHJvdXRpbmVzIGZvciBwYXJhbGxlbCB2YWN1dW0gZXhlY3V0aW9uLgorICoJICBT dXBwb3J0IHJvdXRpbmVzIGZvciBwYXJhbGxlbCB2YWN1dW0gYW5kIGF1dG92YWN1dW0gZXhlY3V0 aW9uLiBJbiB0aGUKKyAqCSAgY29tbWVudHMgYmVsb3csIHRoZSB3b3JkICJ2YWN1dW0iIHdpbGwg cmVmZXIgdG8gYm90aCB2YWN1dW0gYW5kCisgKgkgIGF1dG92YWN1dW0uCiAgKgogICogVGhpcyBm aWxlIGNvbnRhaW5zIHJvdXRpbmVzIHRoYXQgYXJlIGludGVuZGVkIHRvIHN1cHBvcnQgc2V0dGlu ZyB1cCwgdXNpbmcsCiAgKiBhbmQgdGVhcmluZyBkb3duIGEgUGFyYWxsZWxWYWN1dW1TdGF0ZS4K QEAgLTM0LDYgKzM2LDcgQEAKICNpbmNsdWRlICJleGVjdXRvci9pbnN0cnVtZW50LmgiCiAjaW5j bHVkZSAib3B0aW1pemVyL3BhdGhzLmgiCiAjaW5jbHVkZSAicGdzdGF0LmgiCisjaW5jbHVkZSAi cG9zdG1hc3Rlci9hdXRvdmFjdXVtLmgiCiAjaW5jbHVkZSAic3RvcmFnZS9idWZtZ3IuaCIKICNp bmNsdWRlICJ0Y29wL3Rjb3Bwcm90LmgiCiAjaW5jbHVkZSAidXRpbHMvbHN5c2NhY2hlLmgiCkBA IC0zNzMsOCArMzc2LDkgQEAgcGFyYWxsZWxfdmFjdXVtX2luaXQoUmVsYXRpb24gcmVsLCBSZWxh dGlvbiAqaW5kcmVscywgaW50IG5pbmRleGVzLAogCXNoYXJlZC0+cXVlcnlpZCA9IHBnc3RhdF9n ZXRfbXlfcXVlcnlfaWQoKTsKIAlzaGFyZWQtPm1haW50ZW5hbmNlX3dvcmtfbWVtX3dvcmtlciA9 CiAJCShuaW5kZXhlc19td20gPiAwKSA/Ci0JCW1haW50ZW5hbmNlX3dvcmtfbWVtIC8gTWluKHBh cmFsbGVsX3dvcmtlcnMsIG5pbmRleGVzX213bSkgOgotCQltYWludGVuYW5jZV93b3JrX21lbTsK KwkJdmFjX3dvcmtfbWVtIC8gTWluKHBhcmFsbGVsX3dvcmtlcnMsIG5pbmRleGVzX213bSkgOgor CQl2YWNfd29ya19tZW07CisKIAlzaGFyZWQtPmRlYWRfaXRlbXNfaW5mby5tYXhfYnl0ZXMgPSB2 YWNfd29ya19tZW0gKiAoc2l6ZV90KSAxMDI0OwogCiAJLyogUHJlcGFyZSBEU0Egc3BhY2UgZm9y IGRlYWQgaXRlbXMgKi8KQEAgLTU1MywxMiArNTU3LDE3IEBAIHBhcmFsbGVsX3ZhY3V1bV9jb21w dXRlX3dvcmtlcnMoUmVsYXRpb24gKmluZHJlbHMsIGludCBuaW5kZXhlcywgaW50IG5yZXF1ZXN0 ZWQsCiAJaW50CQkJbmluZGV4ZXNfcGFyYWxsZWxfYnVsa2RlbCA9IDA7CiAJaW50CQkJbmluZGV4 ZXNfcGFyYWxsZWxfY2xlYW51cCA9IDA7CiAJaW50CQkJcGFyYWxsZWxfd29ya2VyczsKKwlpbnQJ CQltYXhfd29ya2VyczsKKworCW1heF93b3JrZXJzID0gQW1BdXRvVmFjdXVtV29ya2VyUHJvY2Vz cygpID8KKwkJYXV0b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2VycyA6CisJCW1heF9wYXJhbGxl bF9tYWludGVuYW5jZV93b3JrZXJzOwogCiAJLyoKIAkgKiBXZSBkb24ndCBhbGxvdyBwZXJmb3Jt aW5nIHBhcmFsbGVsIG9wZXJhdGlvbiBpbiBzdGFuZGFsb25lIGJhY2tlbmQgb3IKIAkgKiB3aGVu IHBhcmFsbGVsaXNtIGlzIGRpc2FibGVkLgogCSAqLwotCWlmICghSXNVbmRlclBvc3RtYXN0ZXIg fHwgbWF4X3BhcmFsbGVsX21haW50ZW5hbmNlX3dvcmtlcnMgPT0gMCkKKwlpZiAoIUlzVW5kZXJQ b3N0bWFzdGVyIHx8IG1heF93b3JrZXJzID09IDApCiAJCXJldHVybiAwOwogCiAJLyoKQEAgLTU5 Nyw4ICs2MDYsOCBAQCBwYXJhbGxlbF92YWN1dW1fY29tcHV0ZV93b3JrZXJzKFJlbGF0aW9uICpp bmRyZWxzLCBpbnQgbmluZGV4ZXMsIGludCBucmVxdWVzdGVkLAogCXBhcmFsbGVsX3dvcmtlcnMg PSAobnJlcXVlc3RlZCA+IDApID8KIAkJTWluKG5yZXF1ZXN0ZWQsIG5pbmRleGVzX3BhcmFsbGVs KSA6IG5pbmRleGVzX3BhcmFsbGVsOwogCi0JLyogQ2FwIGJ5IG1heF9wYXJhbGxlbF9tYWludGVu YW5jZV93b3JrZXJzICovCi0JcGFyYWxsZWxfd29ya2VycyA9IE1pbihwYXJhbGxlbF93b3JrZXJz LCBtYXhfcGFyYWxsZWxfbWFpbnRlbmFuY2Vfd29ya2Vycyk7CisJLyogQ2FwIGJ5IEdVQyB2YXJp YWJsZSAqLworCXBhcmFsbGVsX3dvcmtlcnMgPSBNaW4ocGFyYWxsZWxfd29ya2VycywgbWF4X3dv cmtlcnMpOwogCiAJcmV0dXJuIHBhcmFsbGVsX3dvcmtlcnM7CiB9CkBAIC02NDYsNiArNjU1LDEz IEBAIHBhcmFsbGVsX3ZhY3V1bV9wcm9jZXNzX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3Rh dGUgKnB2cywgaW50IG51bV9pbmRleF9zY2FuCiAJICovCiAJbndvcmtlcnMgPSBNaW4obndvcmtl cnMsIHB2cy0+cGN4dC0+bndvcmtlcnMpOwogCisJLyoKKwkgKiBSZXNlcnZlIHdvcmtlcnMgaW4g YXV0b3ZhY3V1bSBnbG9iYWwgc3RhdGUuIE5vdGUgdGhhdCB3ZSBtYXkgYmUgZ2l2ZW4KKwkgKiBm ZXdlciB3b3JrZXJzIHRoYW4gd2UgcmVxdWVzdGVkLgorCSAqLworCWlmIChBbUF1dG9WYWN1dW1X b3JrZXJQcm9jZXNzKCkgJiYgbndvcmtlcnMgPiAwKQorCQlBdXRvVmFjdXVtUmVzZXJ2ZVBhcmFs bGVsV29ya2VycygmbndvcmtlcnMpOworCiAJLyoKIAkgKiBTZXQgaW5kZXggdmFjdXVtIHN0YXR1 cyBhbmQgbWFyayB3aGV0aGVyIHBhcmFsbGVsIHZhY3V1bSB3b3JrZXIgY2FuCiAJICogcHJvY2Vz cyBpdC4KQEAgLTY5MCw2ICs3MDYsMTMgQEAgcGFyYWxsZWxfdmFjdXVtX3Byb2Nlc3NfYWxsX2lu ZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLCBpbnQgbnVtX2luZGV4X3NjYW4KIAogCQlM YXVuY2hQYXJhbGxlbFdvcmtlcnMocHZzLT5wY3h0KTsKIAorCQkvKgorCQkgKiBUZWxsIGF1dG92 YWN1dW0gdGhhdCB3ZSBjb3VsZCBub3QgbGF1bmNoIGFsbCB0aGUgcHJldmlvdXNseQorCQkgKiBy ZXNlcnZlZCB3b3JrZXJzLgorCQkgKi8KKwkJaWYgKEFtQXV0b1ZhY3V1bVdvcmtlclByb2Nlc3Mo KSAmJiBwdnMtPnBjeHQtPm53b3JrZXJzX2xhdW5jaGVkIDwgbndvcmtlcnMpCisJCQlBdXRvVmFj dXVtUmVsZWFzZVBhcmFsbGVsV29ya2Vycyhud29ya2VycyAtIHB2cy0+cGN4dC0+bndvcmtlcnNf bGF1bmNoZWQpOworCiAJCWlmIChwdnMtPnBjeHQtPm53b3JrZXJzX2xhdW5jaGVkID4gMCkKIAkJ ewogCQkJLyoKQEAgLTczOCw2ICs3NjEsMTAgQEAgcGFyYWxsZWxfdmFjdXVtX3Byb2Nlc3NfYWxs X2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLCBpbnQgbnVtX2luZGV4X3NjYW4KIAog CQlmb3IgKGludCBpID0gMDsgaSA8IHB2cy0+cGN4dC0+bndvcmtlcnNfbGF1bmNoZWQ7IGkrKykK IAkJCUluc3RyQWNjdW1QYXJhbGxlbFF1ZXJ5KCZwdnMtPmJ1ZmZlcl91c2FnZVtpXSwgJnB2cy0+ d2FsX3VzYWdlW2ldKTsKKworCQkvKiBSZWxlYXNlIGFsbCB0aGUgcmVzZXJ2ZWQgcGFyYWxsZWwg d29ya2VycyBmb3IgYXV0b3ZhY3V1bSAqLworCQlpZiAoQW1BdXRvVmFjdXVtV29ya2VyUHJvY2Vz cygpICYmIHB2cy0+cGN4dC0+bndvcmtlcnNfbGF1bmNoZWQgPiAwKQorCQkJQXV0b1ZhY3V1bVJl bGVhc2VQYXJhbGxlbFdvcmtlcnMocHZzLT5wY3h0LT5ud29ya2Vyc19sYXVuY2hlZCk7CiAJfQog CiAJLyoKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jIGIv c3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMKaW5kZXggMjIzNzlkZTFlMzEuLjA5 N2IxZGQ1NWNmIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0u YworKysgYi9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYwpAQCAtMTUxLDYgKzE1 MSwxMyBAQCBpbnQJCQlMb2dfYXV0b2FuYWx5emVfbWluX2R1cmF0aW9uID0gNjAwMDAwOwogc3Rh dGljIGRvdWJsZSBhdl9zdG9yYWdlX3BhcmFtX2Nvc3RfZGVsYXkgPSAtMTsKIHN0YXRpYyBpbnQJ YXZfc3RvcmFnZV9wYXJhbV9jb3N0X2xpbWl0ID0gLTE7CiAKKy8qCisgKiBUcmFja3MgdGhlIG51 bWJlciBvZiBwYXJhbGxlbCB3b3JrZXJzIGN1cnJlbnRseSByZXNlcnZlZCBieSB0aGUKKyAqIGF1 dG92YWN1dW0gd29ya2VyLiBUaGlzIGlzIG5vbi16ZXJvIG9ubHkgZm9yIHRoZSBwYXJhbGxlbCBh dXRvdmFjdXVtCisgKiBsZWFkZXIgcHJvY2Vzcy4KKyAqLworc3RhdGljIGludAlhdl9ud29ya2Vy c19yZXNlcnZlZCA9IDA7CisKIC8qIEZsYWdzIHNldCBieSBzaWduYWwgaGFuZGxlcnMgKi8KIHN0 YXRpYyB2b2xhdGlsZSBzaWdfYXRvbWljX3QgZ290X1NJR1VTUjIgPSBmYWxzZTsKIApAQCAtMjg1 LDYgKzI5Miw4IEBAIHR5cGVkZWYgc3RydWN0IEF1dG9WYWN1dW1Xb3JrSXRlbQogICogYXZfd29y a0l0ZW1zCQl3b3JrIGl0ZW0gYXJyYXkKICAqIGF2X253b3JrZXJzRm9yQmFsYW5jZSB0aGUgbnVt YmVyIG9mIGF1dG92YWN1dW0gd29ya2VycyB0byB1c2Ugd2hlbgogICogCQkJCQljYWxjdWxhdGlu ZyB0aGUgcGVyIHdvcmtlciBjb3N0IGxpbWl0CisgKiBhdl9mcmVlUGFyYWxsZWxXb3JrZXJzIHRo ZSBudW1iZXIgb2YgZnJlZSBwYXJhbGxlbCBhdXRvdmFjdXVtIHdvcmtlcnMKKyAqIGF2X21heFBh cmFsbGVsV29ya2VycyB0aGUgbWF4aW11bSBudW1iZXIgb2YgcGFyYWxsZWwgYXV0b3ZhY3V1bSB3 b3JrZXJzCiAgKgogICogVGhpcyBzdHJ1Y3QgaXMgcHJvdGVjdGVkIGJ5IEF1dG92YWN1dW1Mb2Nr LCBleGNlcHQgZm9yIGF2X3NpZ25hbCBhbmQgcGFydHMKICAqIG9mIHRoZSB3b3JrZXIgbGlzdCAo c2VlIGFib3ZlKS4KQEAgLTI5OSw2ICszMDgsOCBAQCB0eXBlZGVmIHN0cnVjdAogCVdvcmtlcklu Zm8JYXZfc3RhcnRpbmdXb3JrZXI7CiAJQXV0b1ZhY3V1bVdvcmtJdGVtIGF2X3dvcmtJdGVtc1tO VU1fV09SS0lURU1TXTsKIAlwZ19hdG9taWNfdWludDMyIGF2X253b3JrZXJzRm9yQmFsYW5jZTsK Kwl1aW50MzIJCWF2X2ZyZWVQYXJhbGxlbFdvcmtlcnM7CisJdWludDMyCQlhdl9tYXhQYXJhbGxl bFdvcmtlcnM7CiB9IEF1dG9WYWN1dW1TaG1lbVN0cnVjdDsKIAogc3RhdGljIEF1dG9WYWN1dW1T aG1lbVN0cnVjdCAqQXV0b1ZhY3V1bVNobWVtOwpAQCAtMzYxLDYgKzM3Miw4IEBAIHN0YXRpYyB2 b2lkIGF1dG92YWNfcmVwb3J0X3dvcmtpdGVtKEF1dG9WYWN1dW1Xb3JrSXRlbSAqd29ya2l0ZW0s CiBzdGF0aWMgdm9pZCBhdmxfc2lndXNyMl9oYW5kbGVyKFNJR05BTF9BUkdTKTsKIHN0YXRpYyBi b29sIGF2X3dvcmtlcl9hdmFpbGFibGUodm9pZCk7CiBzdGF0aWMgdm9pZCBjaGVja19hdl93b3Jr ZXJfZ3Vjcyh2b2lkKTsKK3N0YXRpYyB2b2lkIGFkanVzdF9mcmVlX3BhcmFsbGVsX3dvcmtlcnMo aW50IHByZXZfbWF4X3BhcmFsbGVsX3dvcmtlcnMpOworc3RhdGljIHZvaWQgQXV0b1ZhY3V1bVJl bGVhc2VBbGxQYXJhbGxlbFdvcmtlcnModm9pZCk7CiAKIAogCkBAIC03NjAsNiArNzczLDggQEAg UHJvY2Vzc0F1dG9WYWNMYXVuY2hlckludGVycnVwdHModm9pZCkKIAlpZiAoQ29uZmlnUmVsb2Fk UGVuZGluZykKIAl7CiAJCWludAkJCWF1dG92YWN1dW1fbWF4X3dvcmtlcnNfcHJldiA9IGF1dG92 YWN1dW1fbWF4X3dvcmtlcnM7CisJCWludAkJCWF1dG92YWN1dW1fbWF4X3BhcmFsbGVsX3dvcmtl cnNfcHJldiA9CisJCQlhdXRvdmFjdXVtX21heF9wYXJhbGxlbF93b3JrZXJzOwogCiAJCUNvbmZp Z1JlbG9hZFBlbmRpbmcgPSBmYWxzZTsKIAkJUHJvY2Vzc0NvbmZpZ0ZpbGUoUEdDX1NJR0hVUCk7 CkBAIC03NzYsNiArNzkxLDE1IEBAIFByb2Nlc3NBdXRvVmFjTGF1bmNoZXJJbnRlcnJ1cHRzKHZv aWQpCiAJCWlmIChhdXRvdmFjdXVtX21heF93b3JrZXJzX3ByZXYgIT0gYXV0b3ZhY3V1bV9tYXhf d29ya2VycykKIAkJCWNoZWNrX2F2X3dvcmtlcl9ndWNzKCk7CiAKKwkJLyoKKwkJICogSWYgYXV0 b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2VycyBjaGFuZ2VkLCB3ZSBtdXN0IHRha2UgY2FyZSBv ZgorCQkgKiB0aGUgY29ycmVjdCB2YWx1ZSBvZiBhdmFpbGFibGUgcGFyYWxsZWwgYXV0b3ZhY3V1 bSB3b3JrZXJzIGluCisJCSAqIHNobWVtLgorCQkgKi8KKwkJaWYgKGF1dG92YWN1dW1fbWF4X3Bh cmFsbGVsX3dvcmtlcnNfcHJldiAhPQorCQkJYXV0b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2Vy cykKKwkJCWFkanVzdF9mcmVlX3BhcmFsbGVsX3dvcmtlcnMoYXV0b3ZhY3V1bV9tYXhfcGFyYWxs ZWxfd29ya2Vyc19wcmV2KTsKKwogCQkvKiByZWJ1aWxkIHRoZSBsaXN0IGluIGNhc2UgdGhlIG5h cHRpbWUgY2hhbmdlZCAqLwogCQlyZWJ1aWxkX2RhdGFiYXNlX2xpc3QoSW52YWxpZE9pZCk7CiAJ fQpAQCAtMTM4MCw2ICsxNDA0LDE2IEBAIGF2bF9zaWd1c3IyX2hhbmRsZXIoU0lHTkFMX0FSR1Mp CiAgKgkJCQkJICBBVVRPVkFDVVVNIFdPUktFUiBDT0RFCiAgKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKKy8qCisg KiBNYWtlIHN1cmUgdGhhdCBhbGwgcmVzZXJ2ZWQgd29ya2VycyBhcmUgcmVsZWFzZWQsIGV2ZW4g aWYgcGFyYWxsZWwKKyAqIGF1dG92YWN1dW0gbGVhZGVyIGlzIGZpbmlzaGluZyBkdWUgdG8gRkFU QUwgZXJyb3IuCisgKi8KK3N0YXRpYyB2b2lkCithdXRvdmFjdXVtX3dvcmtlcl9iZWZvcmVfc2ht ZW1fZXhpdChpbnQgY29kZSwgRGF0dW0gYXJnKQoreworCUF1dG9WYWN1dW1SZWxlYXNlQWxsUGFy YWxsZWxXb3JrZXJzKCk7Cit9CisKIC8qCiAgKiBNYWluIGVudHJ5IHBvaW50IGZvciBhdXRvdmFj dXVtIHdvcmtlciBwcm9jZXNzZXMuCiAgKi8KQEAgLTIyNzcsNiArMjMxMSwxMiBAQCBkb19hdXRv dmFjdXVtKHZvaWQpCiAJCQkJCQkJCQkJICAiQXV0b3ZhY3V1bSBQb3J0YWwiLAogCQkJCQkJCQkJ CSAgQUxMT0NTRVRfREVGQVVMVF9TSVpFUyk7CiAKKwkvKgorCSAqIFBhcmFsbGVsIGF1dG92YWN1 dW0gY2FuIHJlc2VydmUgcGFyYWxsZWwgd29ya2Vycy4gTWFrZSBzdXJlIHRoYXQgYWxsCisJICog cmVzZXJ2ZWQgd29ya2VycyBhcmUgcmVsZWFzZWQgZXZlbiBhZnRlciBGQVRBTCBlcnJvci4KKwkg Ki8KKwliZWZvcmVfc2htZW1fZXhpdChhdXRvdmFjdXVtX3dvcmtlcl9iZWZvcmVfc2htZW1fZXhp dCwgMCk7CisKIAkvKgogCSAqIFBlcmZvcm0gb3BlcmF0aW9ucyBvbiBjb2xsZWN0ZWQgdGFibGVz LgogCSAqLwpAQCAtMjQ1OCw2ICsyNDk4LDEyIEBAIGRvX2F1dG92YWN1dW0odm9pZCkKIAkJfQog CQlQR19DQVRDSCgpOwogCQl7CisJCQkvKgorCQkJICogUGFyYWxsZWwgYXV0b3ZhY3V1bSBjYW4g cmVzZXJ2ZSBwYXJhbGxlbCB3b3JrZXJzLiBNYWtlIHN1cmUKKwkJCSAqIHRoYXQgYWxsIHJlc2Vy dmVkIHdvcmtlcnMgYXJlIHJlbGVhc2VkLgorCQkJICovCisJCQlBdXRvVmFjdXVtUmVsZWFzZUFs bFBhcmFsbGVsV29ya2VycygpOworCiAJCQkvKgogCQkJICogQWJvcnQgdGhlIHRyYW5zYWN0aW9u LCBzdGFydCBhIG5ldyBvbmUsIGFuZCBwcm9jZWVkIHdpdGggdGhlCiAJCQkgKiBuZXh0IHRhYmxl IGluIG91ciBsaXN0LgpAQCAtMjg1OCw4ICsyOTA0LDEyIEBAIHRhYmxlX3JlY2hlY2tfYXV0b3Zh YyhPaWQgcmVsaWQsIEhUQUIgKnRhYmxlX3RvYXN0X21hcCwKIAkJICovCiAJCXRhYi0+YXRfcGFy YW1zLmluZGV4X2NsZWFudXAgPSBWQUNPUFRWQUxVRV9VTlNQRUNJRklFRDsKIAkJdGFiLT5hdF9w YXJhbXMudHJ1bmNhdGUgPSBWQUNPUFRWQUxVRV9VTlNQRUNJRklFRDsKLQkJLyogQXMgb2Ygbm93 LCB3ZSBkb24ndCBzdXBwb3J0IHBhcmFsbGVsIHZhY3V1bSBmb3IgYXV0b3ZhY3V1bSAqLwotCQl0 YWItPmF0X3BhcmFtcy5ud29ya2VycyA9IC0xOworCisJCS8qIERlY2lkZSB3aGV0aGVyIHdlIG5l ZWQgdG8gcHJvY2VzcyBpbmRleGVzIG9mIHRhYmxlIGluIHBhcmFsbGVsLiAqLworCQl0YWItPmF0 X3BhcmFtcy5ud29ya2VycyA9IGF2b3B0cworCQkJPyBhdm9wdHMtPmF1dG92YWN1dW1fcGFyYWxs ZWxfd29ya2VycworCQkJOiAtMTsKKwogCQl0YWItPmF0X3BhcmFtcy5mcmVlemVfbWluX2FnZSA9 IGZyZWV6ZV9taW5fYWdlOwogCQl0YWItPmF0X3BhcmFtcy5mcmVlemVfdGFibGVfYWdlID0gZnJl ZXplX3RhYmxlX2FnZTsKIAkJdGFiLT5hdF9wYXJhbXMubXVsdGl4YWN0X2ZyZWV6ZV9taW5fYWdl ID0gbXVsdGl4YWN0X2ZyZWV6ZV9taW5fYWdlOwpAQCAtMzMzNiw2ICszMzg2LDc2IEBAIEF1dG9W YWN1dW1SZXF1ZXN0V29yayhBdXRvVmFjdXVtV29ya0l0ZW1UeXBlIHR5cGUsIE9pZCByZWxhdGlv bklkLAogCXJldHVybiByZXN1bHQ7CiB9CiAKKy8qCisgKiBSZXNlcnZlcyBwYXJhbGxlbCB3b3Jr ZXJzIGZvciBhdXRvdmFjdXVtLgorICoKKyAqIG53b3JrZXJzIGlzIGFuIGluL291dCBwYXJhbWV0 ZXI7IHRoZSByZXF1ZXN0ZWQgbnVtYmVyIG9mIHBhcmFsbGVsIHdvcmtlcnMKKyAqIHRvIHJlc2Vy dmUgYnkgdGhlIGNhbGxlciwgYW5kIHNldCB0byB0aGUgYWN0dWFsIG51bWJlciBvZiByZXNlcnZl ZCB3b3JrZXJzLgorICovCit2b2lkCitBdXRvVmFjdXVtUmVzZXJ2ZVBhcmFsbGVsV29ya2Vycyhp bnQgKm53b3JrZXJzKQoreworCS8qIE9ubHkgbGVhZGVyIGF1dG92YWN1dW0gd29ya2VyIGNhbiBj YWxsIHRoaXMgZnVuY3Rpb24uICovCisJQXNzZXJ0KEFtQXV0b1ZhY3V1bVdvcmtlclByb2Nlc3Mo KSAmJiAhSXNQYXJhbGxlbFdvcmtlcigpKTsKKworCS8qIFRoZSB3b3JrZXIgbXVzdCBub3QgaGF2 ZSBhbnkgcmVzZXJ2ZWQgd29ya2VycyB5ZXQgKi8KKwlBc3NlcnQoYXZfbndvcmtlcnNfcmVzZXJ2 ZWQgPT0gMCk7CisKKwlMV0xvY2tBY3F1aXJlKEF1dG92YWN1dW1Mb2NrLCBMV19FWENMVVNJVkUp OworCisJLyogUHJvdmlkZSBhcyBtYW55IHdvcmtlcnMgYXMgd2UgY2FuLiAqLworCSpud29ya2Vy cyA9IE1pbihBdXRvVmFjdXVtU2htZW0tPmF2X2ZyZWVQYXJhbGxlbFdvcmtlcnMsICpud29ya2Vy cyk7CisJQXV0b1ZhY3V1bVNobWVtLT5hdl9mcmVlUGFyYWxsZWxXb3JrZXJzIC09ICpud29ya2Vy czsKKworCS8qIFJlbWVtYmVyIGhvdyBtYW55IHdvcmtlcnMgd2UgaGF2ZSByZXNlcnZlZC4gKi8K Kwlhdl9ud29ya2Vyc19yZXNlcnZlZCA9ICpud29ya2VyczsKKworCUxXTG9ja1JlbGVhc2UoQXV0 b3ZhY3V1bUxvY2spOworfQorCisvKgorICogTGVhZGVyIGF1dG92YWN1dW0gcHJvY2VzcyBtdXN0 IGNhbGwgdGhpcyBmdW5jdGlvbiBpbiBvcmRlciB0byB1cGRhdGUgZ2xvYmFsCisgKiBhdXRvdmFj dXVtIHN0YXRlLCBzbyBvdGhlciBsZWFkZXJzIHdpbGwgYmUgYWJsZSB0byB1c2UgdGhlc2UgcGFy YWxsZWwKKyAqIHdvcmtlcnMuCisgKgorICogJ253b3JrZXJzJyAtIGhvdyBtYW55IHdvcmtlcnMg Y2FsbGVyIHdhbnRzIHRvIHJlbGVhc2UuCisgKi8KK3ZvaWQKK0F1dG9WYWN1dW1SZWxlYXNlUGFy YWxsZWxXb3JrZXJzKGludCBud29ya2VycykKK3sKKwkvKiBPbmx5IGxlYWRlciB3b3JrZXIgY2Fu IGNhbGwgdGhpcyBmdW5jdGlvbi4gKi8KKwlBc3NlcnQoQW1BdXRvVmFjdXVtV29ya2VyUHJvY2Vz cygpICYmICFJc1BhcmFsbGVsV29ya2VyKCkpOworCisJTFdMb2NrQWNxdWlyZShBdXRvdmFjdXVt TG9jaywgTFdfRVhDTFVTSVZFKTsKKworCS8qCisJICogSWYgdGhlIG1heGltdW0gbnVtYmVyIG9m IHBhcmFsbGVsIHdvcmtlcnMgd2FzIHJlZHVjZWQgZHVyaW5nIGV4ZWN1dGlvbiwKKwkgKiB3ZSBt dXN0IGNhcCBhdmFpbGFibGUgd29ya2VycyBudW1iZXIgYnkgaXRzIG5ldyB2YWx1ZS4KKwkgKi8K KwlBdXRvVmFjdXVtU2htZW0tPmF2X2ZyZWVQYXJhbGxlbFdvcmtlcnMgPQorCQlNaW4oQXV0b1Zh Y3V1bVNobWVtLT5hdl9mcmVlUGFyYWxsZWxXb3JrZXJzICsgbndvcmtlcnMsCisJCQlBdXRvVmFj dXVtU2htZW0tPmF2X21heFBhcmFsbGVsV29ya2Vycyk7CisKKwkvKiBEb24ndCBoYXZlIHRvIHJl bWVtYmVyIHRoZXNlIHdvcmtlcnMgYW55bW9yZS4gKi8KKwlhdl9ud29ya2Vyc19yZXNlcnZlZCAt PSBud29ya2VyczsKKworCUxXTG9ja1JlbGVhc2UoQXV0b3ZhY3V1bUxvY2spOworfQorCisvKgor ICogU2FtZSBhcyBhYm92ZSwgYnV0IHJlbGVhc2UgKmFsbCogcGFyYWxsZWwgd29ya2VycywgdGhh dCB3ZXJlIHJlc2VydmVkIGJ5CisgKiBjdXJyZW50IGxlYWRlciBhdXRvdmFjdXVtIHByb2Nlc3Mu CisgKi8KK3N0YXRpYyB2b2lkCitBdXRvVmFjdXVtUmVsZWFzZUFsbFBhcmFsbGVsV29ya2Vycyh2 b2lkKQoreworCS8qIE9ubHkgbGVhZGVyIHdvcmtlciBjYW4gY2FsbCB0aGlzIGZ1bmN0aW9uLiAq LworCUFzc2VydChBbUF1dG9WYWN1dW1Xb3JrZXJQcm9jZXNzKCkgJiYgIUlzUGFyYWxsZWxXb3Jr ZXIoKSk7CisKKwlpZiAoYXZfbndvcmtlcnNfcmVzZXJ2ZWQgPiAwKQorCQlBdXRvVmFjdXVtUmVs ZWFzZVBhcmFsbGVsV29ya2Vycyhhdl9ud29ya2Vyc19yZXNlcnZlZCk7Cit9CisKIC8qCiAgKiBh dXRvdmFjX2luaXQKICAqCQlUaGlzIGlzIGNhbGxlZCBhdCBwb3N0bWFzdGVyIGluaXRpYWxpemF0 aW9uLgpAQCAtMzM5Niw2ICszNTE2LDEwIEBAIEF1dG9WYWN1dW1TaG1lbUluaXQodm9pZCkKIAkJ QXNzZXJ0KCFmb3VuZCk7CiAKIAkJQXV0b1ZhY3V1bVNobWVtLT5hdl9sYXVuY2hlcnBpZCA9IDA7 CisJCUF1dG9WYWN1dW1TaG1lbS0+YXZfbWF4UGFyYWxsZWxXb3JrZXJzID0KKwkJCU1pbihhdXRv dmFjdXVtX21heF9wYXJhbGxlbF93b3JrZXJzLCBtYXhfd29ya2VyX3Byb2Nlc3Nlcyk7CisJCUF1 dG9WYWN1dW1TaG1lbS0+YXZfZnJlZVBhcmFsbGVsV29ya2VycyA9CisJCQlBdXRvVmFjdXVtU2ht ZW0tPmF2X21heFBhcmFsbGVsV29ya2VyczsKIAkJZGNsaXN0X2luaXQoJkF1dG9WYWN1dW1TaG1l bS0+YXZfZnJlZVdvcmtlcnMpOwogCQlkbGlzdF9pbml0KCZBdXRvVmFjdXVtU2htZW0tPmF2X3J1 bm5pbmdXb3JrZXJzKTsKIAkJQXV0b1ZhY3V1bVNobWVtLT5hdl9zdGFydGluZ1dvcmtlciA9IE5V TEw7CkBAIC0zNDc3LDMgKzM2MDEsMzQgQEAgY2hlY2tfYXZfd29ya2VyX2d1Y3Modm9pZCkKIAkJ CQkgZXJyZGV0YWlsKCJUaGUgc2VydmVyIHdpbGwgb25seSBzdGFydCB1cCB0byBcImF1dG92YWN1 dW1fd29ya2VyX3Nsb3RzXCIgKCVkKSBhdXRvdmFjdXVtIHdvcmtlcnMgYXQgYSBnaXZlbiB0aW1l LiIsCiAJCQkJCQkgICBhdXRvdmFjdXVtX3dvcmtlcl9zbG90cykpKTsKIH0KKworLyoKKyAqIEFk anVzdHMgdGhlIG51bWJlciBvZiBmcmVlIHBhcmFsbGVsIHdvcmtlcnMgY29ycmVzcG9uZHMgdG8g dGhlIG5ldworICogYXV0b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2VycyB2YWx1ZS4KKyAqLwor c3RhdGljIHZvaWQKK2FkanVzdF9mcmVlX3BhcmFsbGVsX3dvcmtlcnMoaW50IHByZXZfbWF4X3Bh cmFsbGVsX3dvcmtlcnMpCit7CisJTFdMb2NrQWNxdWlyZShBdXRvdmFjdXVtTG9jaywgTFdfRVhD TFVTSVZFKTsKKworCS8qCisJICogQ2FwIHRoZSBudW1iZXIgb2YgZnJlZSB3b3JrZXJzIGJ5IG5l dyBwYXJhbWV0ZXIncyB2YWx1ZSwgaWYgbmVlZGVkLgorCSAqLworCUF1dG9WYWN1dW1TaG1lbS0+ YXZfZnJlZVBhcmFsbGVsV29ya2VycyA9CisJCU1pbihBdXRvVmFjdXVtU2htZW0tPmF2X2ZyZWVQ YXJhbGxlbFdvcmtlcnMsCisJCQlhdXRvdmFjdXVtX21heF9wYXJhbGxlbF93b3JrZXJzKTsKKwor CWlmIChhdXRvdmFjdXVtX21heF9wYXJhbGxlbF93b3JrZXJzID4gcHJldl9tYXhfcGFyYWxsZWxf d29ya2VycykKKwl7CisJCS8qCisJCSAqIElmIHVzZXIgd2FudHMgdG8gaW5jcmVhc2UgbnVtYmVy IG9mIHBhcmFsbGVsIGF1dG92YWN1dW0gd29ya2Vycywgd2UKKwkJICogbXVzdCBpbmNyZWFzZSBu dW1iZXIgb2YgZnJlZSB3b3JrZXJzLgorCQkgKi8KKwkJQXV0b1ZhY3V1bVNobWVtLT5hdl9mcmVl UGFyYWxsZWxXb3JrZXJzICs9CisJCQkoYXV0b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2VycyAt IHByZXZfbWF4X3BhcmFsbGVsX3dvcmtlcnMpOworCX0KKworCUF1dG9WYWN1dW1TaG1lbS0+YXZf bWF4UGFyYWxsZWxXb3JrZXJzID0gYXV0b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2VyczsKKwor CUxXTG9ja1JlbGVhc2UoQXV0b3ZhY3V1bUxvY2spOworfQpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tl bmQvdXRpbHMvaW5pdC9nbG9iYWxzLmMgYi9zcmMvYmFja2VuZC91dGlscy9pbml0L2dsb2JhbHMu YwppbmRleCAzNmFkNzA4YjM2MC4uODI2NWE4MmI2MzkgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5k L3V0aWxzL2luaXQvZ2xvYmFscy5jCisrKyBiL3NyYy9iYWNrZW5kL3V0aWxzL2luaXQvZ2xvYmFs cy5jCkBAIC0xNDMsNiArMTQzLDcgQEAgaW50CQkJTkJ1ZmZlcnMgPSAxNjM4NDsKIGludAkJCU1h eENvbm5lY3Rpb25zID0gMTAwOwogaW50CQkJbWF4X3dvcmtlcl9wcm9jZXNzZXMgPSA4OwogaW50 CQkJbWF4X3BhcmFsbGVsX3dvcmtlcnMgPSA4OworaW50CQkJYXV0b3ZhY3V1bV9tYXhfcGFyYWxs ZWxfd29ya2VycyA9IDI7CiBpbnQJCQlNYXhCYWNrZW5kcyA9IDA7CiAKIC8qIEdVQyBwYXJhbWV0 ZXJzIGZvciB2YWN1dW0gKi8KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvZ3Vj LmMgYi9zcmMvYmFja2VuZC91dGlscy9taXNjL2d1Yy5jCmluZGV4IGFlOWQ1ZjNmYjcwLi5jOGE5 OWE2Nzc2NyAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9ndWMuYworKysgYi9z cmMvYmFja2VuZC91dGlscy9taXNjL2d1Yy5jCkBAIC0zMzI2LDkgKzMzMjYsMTMgQEAgc2V0X2Nv bmZpZ193aXRoX2hhbmRsZShjb25zdCBjaGFyICpuYW1lLCBjb25maWdfaGFuZGxlICpoYW5kbGUs CiAJICoKIAkgKiBBbHNvIGFsbG93IG5vcm1hbCBzZXR0aW5nIGlmIHRoZSBHVUMgaXMgbWFya2Vk IEdVQ19BTExPV19JTl9QQVJBTExFTC4KIAkgKgotCSAqIE90aGVyIGNoYW5nZXMgbWlnaHQgbmVl ZCB0byBhZmZlY3Qgb3RoZXIgd29ya2Vycywgc28gZm9yYmlkIHRoZW0uCisJICogT3RoZXIgY2hh bmdlcyBtaWdodCBuZWVkIHRvIGFmZmVjdCBvdGhlciB3b3JrZXJzLCBzbyBmb3JiaWQgdGhlbS4g Tm90ZSwKKwkgKiB0aGF0IHBhcmFsbGVsIGF1dG92YWN1dW0gbGVhZGVyIGlzIGFuIGV4Y2VwdGlv biwgYmVjYXVzZSBvbmx5CisJICogY29zdC1iYXNlZCBkZWxheXMgbmVlZCB0byBiZSBhZmZlY3Rl ZCBhbHNvIHRvIHBhcmFsbGVsIHZhY3V1bSB3b3JrZXJzLAorCSAqIGFuZCB3ZSB3aWxsIGhhbmRs ZSBpdCBlbHNld2hlcmUgaWYgYXBwcm9wcmlhdGUuCiAJICovCi0JaWYgKElzSW5QYXJhbGxlbE1v ZGUoKSAmJiBjaGFuZ2VWYWwgJiYgYWN0aW9uICE9IEdVQ19BQ1RJT05fU0FWRSAmJgorCWlmIChJ c0luUGFyYWxsZWxNb2RlKCkgJiYgIUFtQXV0b1ZhY3V1bVdvcmtlclByb2Nlc3MoKSAmJiBjaGFu Z2VWYWwgJiYKKwkJYWN0aW9uICE9IEdVQ19BQ1RJT05fU0FWRSAmJgogCQkocmVjb3JkLT5mbGFn cyAmIEdVQ19BTExPV19JTl9QQVJBTExFTCkgPT0gMCkKIAl7CiAJCWVyZXBvcnQoZWxldmVsLApk aWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9ndWNfcGFyYW1ldGVycy5kYXQgYi9z cmMvYmFja2VuZC91dGlscy9taXNjL2d1Y19wYXJhbWV0ZXJzLmRhdAppbmRleCA3YzYwYjEyNTU2 NC4uZTkzM2Y1MDQ4ZjcgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvZ3VjX3Bh cmFtZXRlcnMuZGF0CisrKyBiL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvZ3VjX3BhcmFtZXRlcnMu ZGF0CkBAIC0xNTQsNiArMTU0LDE1IEBACiAgIG1heCA9PiAnMjAwMDAwMDAwMCcsCiB9LAogCit7 IG5hbWUgPT4gJ2F1dG92YWN1dW1fbWF4X3BhcmFsbGVsX3dvcmtlcnMnLCB0eXBlID0+ICdpbnQn LCBjb250ZXh0ID0+ICdQR0NfU0lHSFVQJywgZ3JvdXAgPT4gJ1ZBQ1VVTV9BVVRPVkFDVVVNJywK KyAgc2hvcnRfZGVzYyA9PiAnTWF4aW11bSBudW1iZXIgb2YgcGFyYWxsZWwgYXV0b3ZhY3V1bSB3 b3JrZXJzLCB0aGF0IGNhbiBiZSB0YWtlbiBmcm9tIGJnd29ya2VycyBwb29sLicsCisgIGxvbmdf ZGVzYyA9PiAnVGhpcyBwYXJhbWV0ZXIgaXMgY2FwcGVkIGJ5ICJtYXhfd29ya2VyX3Byb2Nlc3Nl cyIgKG5vdCBieSAiYXV0b3ZhY3V1bV9tYXhfd29ya2VycyIhKS4nLAorICB2YXJpYWJsZSA9PiAn YXV0b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2VycycsCisgIGJvb3RfdmFsID0+ICcyJywKKyAg bWluID0+ICcwJywKKyAgbWF4ID0+ICdNQVhfQkFDS0VORFMnLAorfSwKKwogeyBuYW1lID0+ICdh dXRvdmFjdXVtX21heF93b3JrZXJzJywgdHlwZSA9PiAnaW50JywgY29udGV4dCA9PiAnUEdDX1NJ R0hVUCcsIGdyb3VwID0+ICdWQUNVVU1fQVVUT1ZBQ1VVTScsCiAgIHNob3J0X2Rlc2MgPT4gJ1Nl dHMgdGhlIG1heGltdW0gbnVtYmVyIG9mIHNpbXVsdGFuZW91c2x5IHJ1bm5pbmcgYXV0b3ZhY3V1 bSB3b3JrZXIgcHJvY2Vzc2VzLicsCiAgIHZhcmlhYmxlID0+ICdhdXRvdmFjdXVtX21heF93b3Jr ZXJzJywKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvcG9zdGdyZXNxbC5jb25m LnNhbXBsZSBiL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvcG9zdGdyZXNxbC5jb25mLnNhbXBsZQpp bmRleCBkYzllMjI1NWY4YS4uODZjNjdiNzkwYjAgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3V0 aWxzL21pc2MvcG9zdGdyZXNxbC5jb25mLnNhbXBsZQorKysgYi9zcmMvYmFja2VuZC91dGlscy9t aXNjL3Bvc3RncmVzcWwuY29uZi5zYW1wbGUKQEAgLTY5MSw2ICs2OTEsOCBAQAogI2F1dG92YWN1 dW1fd29ya2VyX3Nsb3RzID0gMTYgICAgICAgICAgICMgYXV0b3ZhY3V1bSB3b3JrZXIgc2xvdHMg dG8gYWxsb2NhdGUKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAjIChj aGFuZ2UgcmVxdWlyZXMgcmVzdGFydCkKICNhdXRvdmFjdXVtX21heF93b3JrZXJzID0gMyAgICAg ICAgICAgICAjIG1heCBudW1iZXIgb2YgYXV0b3ZhY3V1bSBzdWJwcm9jZXNzZXMKKyNhdXRvdmFj dXVtX21heF9wYXJhbGxlbF93b3JrZXJzID0gMiAgICAjIGRpc2FibGVkIGJ5IGRlZmF1bHQgYW5k IGxpbWl0ZWQgYnkKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAjIG1h eF93b3JrZXJfcHJvY2Vzc2VzCiAjYXV0b3ZhY3V1bV9uYXB0aW1lID0gMW1pbiAgICAgICAgICAg ICAgIyB0aW1lIGJldHdlZW4gYXV0b3ZhY3V1bSBydW5zCiAjYXV0b3ZhY3V1bV92YWN1dW1fdGhy ZXNob2xkID0gNTAgICAgICAgIyBtaW4gbnVtYmVyIG9mIHJvdyB1cGRhdGVzIGJlZm9yZQogICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICMgdmFjdXVtCmRpZmYgLS1naXQg YS9zcmMvYmluL3BzcWwvdGFiLWNvbXBsZXRlLmluLmMgYi9zcmMvYmluL3BzcWwvdGFiLWNvbXBs ZXRlLmluLmMKaW5kZXggOGI5MWJjMDAwNjIuLmVkNTlhMjEyODljIDEwMDY0NAotLS0gYS9zcmMv YmluL3BzcWwvdGFiLWNvbXBsZXRlLmluLmMKKysrIGIvc3JjL2Jpbi9wc3FsL3RhYi1jb21wbGV0 ZS5pbi5jCkBAIC0xNDIzLDYgKzE0MjMsNyBAQCBzdGF0aWMgY29uc3QgY2hhciAqY29uc3QgdGFi bGVfc3RvcmFnZV9wYXJhbWV0ZXJzW10gPSB7CiAJImF1dG92YWN1dW1fbXVsdGl4YWN0X2ZyZWV6 ZV9tYXhfYWdlIiwKIAkiYXV0b3ZhY3V1bV9tdWx0aXhhY3RfZnJlZXplX21pbl9hZ2UiLAogCSJh dXRvdmFjdXVtX211bHRpeGFjdF9mcmVlemVfdGFibGVfYWdlIiwKKwkiYXV0b3ZhY3V1bV9wYXJh bGxlbF93b3JrZXJzIiwKIAkiYXV0b3ZhY3V1bV92YWN1dW1fY29zdF9kZWxheSIsCiAJImF1dG92 YWN1dW1fdmFjdXVtX2Nvc3RfbGltaXQiLAogCSJhdXRvdmFjdXVtX3ZhY3V1bV9pbnNlcnRfc2Nh bGVfZmFjdG9yIiwKZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL21pc2NhZG1pbi5oIGIvc3JjL2lu Y2x1ZGUvbWlzY2FkbWluLmgKaW5kZXggZGI1NTliMzljNGQuLmFkNmUxOWY0MjZjIDEwMDY0NAot LS0gYS9zcmMvaW5jbHVkZS9taXNjYWRtaW4uaAorKysgYi9zcmMvaW5jbHVkZS9taXNjYWRtaW4u aApAQCAtMTc4LDYgKzE3OCw3IEBAIGV4dGVybiBQR0RMTElNUE9SVCBpbnQgTWF4QmFja2VuZHM7 CiBleHRlcm4gUEdETExJTVBPUlQgaW50IE1heENvbm5lY3Rpb25zOwogZXh0ZXJuIFBHRExMSU1Q T1JUIGludCBtYXhfd29ya2VyX3Byb2Nlc3NlczsKIGV4dGVybiBQR0RMTElNUE9SVCBpbnQgbWF4 X3BhcmFsbGVsX3dvcmtlcnM7CitleHRlcm4gUEdETExJTVBPUlQgaW50IGF1dG92YWN1dW1fbWF4 X3BhcmFsbGVsX3dvcmtlcnM7CiAKIGV4dGVybiBQR0RMTElNUE9SVCBpbnQgY29tbWl0X3RpbWVz dGFtcF9idWZmZXJzOwogZXh0ZXJuIFBHRExMSU1QT1JUIGludCBtdWx0aXhhY3RfbWVtYmVyX2J1 ZmZlcnM7CmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9wb3N0bWFzdGVyL2F1dG92YWN1dW0uaCBi L3NyYy9pbmNsdWRlL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5oCmluZGV4IDVhYTBmM2E4YWMxLi4z ZjViNTlhMTViZCAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvcG9zdG1hc3Rlci9hdXRvdmFjdXVt LmgKKysrIGIvc3JjL2luY2x1ZGUvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmgKQEAgLTYyLDYgKzYy LDEwIEBAIHBnX25vcmV0dXJuIGV4dGVybiB2b2lkIEF1dG9WYWNXb3JrZXJNYWluKGNvbnN0IHZv aWQgKnN0YXJ0dXBfZGF0YSwgc2l6ZV90IHN0YXJ0CiBleHRlcm4gYm9vbCBBdXRvVmFjdXVtUmVx dWVzdFdvcmsoQXV0b1ZhY3V1bVdvcmtJdGVtVHlwZSB0eXBlLAogCQkJCQkJCQkgIE9pZCByZWxh dGlvbklkLCBCbG9ja051bWJlciBibGtubyk7CiAKKy8qIHBhcmFsbGVsIGF1dG92YWN1dW0gc3R1 ZmYgKi8KK2V4dGVybiB2b2lkCUF1dG9WYWN1dW1SZXNlcnZlUGFyYWxsZWxXb3JrZXJzKGludCAq bndvcmtlcnMpOworZXh0ZXJuIHZvaWQgQXV0b1ZhY3V1bVJlbGVhc2VQYXJhbGxlbFdvcmtlcnMo aW50IG53b3JrZXJzKTsKKwogLyogc2hhcmVkIG1lbW9yeSBzdHVmZiAqLwogZXh0ZXJuIFNpemUg QXV0b1ZhY3V1bVNobWVtU2l6ZSh2b2lkKTsKIGV4dGVybiB2b2lkIEF1dG9WYWN1dW1TaG1lbUlu aXQodm9pZCk7CmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS91dGlscy9yZWwuaCBiL3NyYy9pbmNs dWRlL3V0aWxzL3JlbC5oCmluZGV4IGQwM2FiMjQ3Nzg4Li5jMWQ4ODI2NTlmOSAxMDA2NDQKLS0t IGEvc3JjL2luY2x1ZGUvdXRpbHMvcmVsLmgKKysrIGIvc3JjL2luY2x1ZGUvdXRpbHMvcmVsLmgK QEAgLTMxMSw2ICszMTEsMTMgQEAgdHlwZWRlZiBzdHJ1Y3QgRm9yZWlnbktleUNhY2hlSW5mbwog dHlwZWRlZiBzdHJ1Y3QgQXV0b1ZhY09wdHMKIHsKIAlib29sCQllbmFibGVkOworCisJLyoKKwkg KiBNYXggbnVtYmVyIG9mIHBhcmFsbGVsIGF1dG92YWN1dW0gd29ya2Vycy4gSWYgdmFsdWUgaXMg MCB0aGVuIHBhcmFsbGVsCisJICogZGVncmVlIHdpbGwgY29tcHV0ZWQgYmFzZWQgb24gbnVtYmVy IG9mIGluZGV4ZXMuCisJICovCisJaW50CQkJYXV0b3ZhY3V1bV9wYXJhbGxlbF93b3JrZXJzOwor CiAJaW50CQkJdmFjdXVtX3RocmVzaG9sZDsKIAlpbnQJCQl2YWN1dW1fbWF4X3RocmVzaG9sZDsK IAlpbnQJCQl2YWN1dW1faW5zX3RocmVzaG9sZDsKLS0gCjIuNDMuMAoK --0000000000009cbd1f064881e9cc Content-Type: text/x-patch; charset="US-ASCII"; name="v19-0002-Logging-for-parallel-autovacuum.patch" Content-Disposition: attachment; filename="v19-0002-Logging-for-parallel-autovacuum.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mkgyhkg63 RnJvbSA4OTUxMzEwNDliMjQxNjU2Njc4MWZmNTg1YTU3N2JjMDM0MmY1ZjcxIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBTdW4sIDIzIE5vdiAyMDI1IDAxOjA3OjQ3ICswNzAwClN1YmplY3Q6IFtQQVRD SCB2MTkgMi81XSBMb2dnaW5nIGZvciBwYXJhbGxlbCBhdXRvdmFjdXVtCgotLS0KIHNyYy9iYWNr ZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYyAgfCAyNyArKysrKysrKysrKysrKysrKysrKysr KysrLS0KIHNyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMgfCAyMSArKysrKysr KysrKysrKystLS0tLS0KIHNyYy9pbmNsdWRlL2NvbW1hbmRzL3ZhY3V1bS5oICAgICAgICAgfCAx NiArKysrKysrKysrKysrKy0tCiBzcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdCAgICAg IHwgIDEgKwogNCBmaWxlcyBjaGFuZ2VkLCA1NSBpbnNlcnRpb25zKCspLCAxMCBkZWxldGlvbnMo LSkKCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMgYi9z cmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMKaW5kZXggMWZjYjIxMmFiM2QuLjBi ZTMzY2I4NGE2IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5 LmMKKysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvdmFjdXVtbGF6eS5jCkBAIC0zNDcsNiAr MzQ3LDEyIEBAIHR5cGVkZWYgc3RydWN0IExWUmVsU3RhdGUKIAlpbnQJCQludW1faW5kZXhfc2Nh bnM7CiAJaW50CQkJbnVtX2RlYWRfaXRlbXNfcmVzZXRzOwogCVNpemUJCXRvdGFsX2RlYWRfaXRl bXNfYnl0ZXM7CisKKwkvKgorCSAqIFRvdGFsIG51bWJlciBvZiBwbGFubmVkIGFuZCBhY3R1YWxs eSBsYXVuY2hlZCBwYXJhbGxlbCB3b3JrZXJzIGZvcgorCSAqIGluZGV4IHNjYW5zLgorCSAqLwor CVBWV29ya2Vyc1VzYWdlIHdvcmtlcnNfdXNhZ2U7CiAJLyogQ291bnRlcnMgdGhhdCBmb2xsb3cg YXJlIG9ubHkgZm9yIHNjYW5uZWRfcGFnZXMgKi8KIAlpbnQ2NAkJdHVwbGVzX2RlbGV0ZWQ7IC8q ICMgZGVsZXRlZCBmcm9tIHRhYmxlICovCiAJaW50NjQJCXR1cGxlc19mcm96ZW47CS8qICMgbmV3 bHkgZnJvemVuICovCkBAIC02MzAsNiArNjM2LDcgQEAgaGVhcF92YWN1dW1fcmVsKFJlbGF0aW9u IHJlbCwgY29uc3QgVmFjdXVtUGFyYW1zIHBhcmFtcywKIAlMVlJlbFN0YXRlICp2YWNyZWw7CiAJ Ym9vbAkJdmVyYm9zZSwKIAkJCQlpbnN0cnVtZW50LAorCQkJCWxvZ193b3JrZXJzX3VzYWdlID0g ZmFsc2UsCS8qIGZvciBwYXJhbGxlbCBbYXV0b112YWN1dW0gb25seSAqLwogCQkJCXNraXB3aXRo dm0sCiAJCQkJZnJvemVueGlkX3VwZGF0ZWQsCiAJCQkJbWlubXVsdGlfdXBkYXRlZDsKQEAgLTcw OSw2ICs3MTYsMTIgQEAgaGVhcF92YWN1dW1fcmVsKFJlbGF0aW9uIHJlbCwgY29uc3QgVmFjdXVt UGFyYW1zIHBhcmFtcywKIAkJaW5kbmFtZXMgPSBwYWxsb2NfYXJyYXkoY2hhciAqLCB2YWNyZWwt Pm5pbmRleGVzKTsKIAkJZm9yIChpbnQgaSA9IDA7IGkgPCB2YWNyZWwtPm5pbmRleGVzOyBpKysp CiAJCQlpbmRuYW1lc1tpXSA9IHBzdHJkdXAoUmVsYXRpb25HZXRSZWxhdGlvbk5hbWUodmFjcmVs LT5pbmRyZWxzW2ldKSk7CisKKwkJLyoKKwkJICogV29ya2VyIHVzYWdlIHN0YXRpc3RpY3MgbXVz dCBiZSBhY2N1bXVsYXRlZCBmb3IgcGFyYWxsZWwgYXV0b3ZhY3V1bQorCQkgKiBhbmQgZm9yIFZB Q1VVTSAoUEFSQUxMRUwsIFZFUkJPU0UpLgorCQkgKi8KKwkJbG9nX3dvcmtlcnNfdXNhZ2UgPSAo cGFyYW1zLm53b3JrZXJzID4gLTEpOwogCX0KIAogCS8qCkBAIC03ODEsNiArNzk0LDkgQEAgaGVh cF92YWN1dW1fcmVsKFJlbGF0aW9uIHJlbCwgY29uc3QgVmFjdXVtUGFyYW1zIHBhcmFtcywKIAl2 YWNyZWwtPnZtX25ld192aXNpYmxlX2Zyb3plbl9wYWdlcyA9IDA7CiAJdmFjcmVsLT52bV9uZXdf ZnJvemVuX3BhZ2VzID0gMDsKIAorCXZhY3JlbC0+d29ya2Vyc191c2FnZS5ubGF1bmNoZWQgPSAw OworCXZhY3JlbC0+d29ya2Vyc191c2FnZS5ucGxhbm5lZCA9IDA7CisKIAkvKgogCSAqIEdldCBj dXRvZmZzIHRoYXQgZGV0ZXJtaW5lIHdoaWNoIGRlbGV0ZWQgdHVwbGVzIGFyZSBjb25zaWRlcmVk IERFQUQsCiAJICogbm90IGp1c3QgUkVDRU5UTFlfREVBRCwgYW5kIHdoaWNoIFhJRHMvTVhJRHMg dG8gZnJlZXplLiAgVGhlbiBkZXRlcm1pbmUKQEAgLTExMjMsNiArMTEzOSwxMSBAQCBoZWFwX3Zh Y3V1bV9yZWwoUmVsYXRpb24gcmVsLCBjb25zdCBWYWN1dW1QYXJhbXMgcGFyYW1zLAogCQkJCQkJ CSBvcmlnX3JlbF9wYWdlcyA9PSAwID8gMTAwLjAgOgogCQkJCQkJCSAxMDAuMCAqIHZhY3JlbC0+ bHBkZWFkX2l0ZW1fcGFnZXMgLyBvcmlnX3JlbF9wYWdlcywKIAkJCQkJCQkgdmFjcmVsLT5scGRl YWRfaXRlbXMpOworCQkJaWYgKGxvZ193b3JrZXJzX3VzYWdlKQorCQkJCWFwcGVuZFN0cmluZ0lu Zm8oJmJ1ZiwKKwkJCQkJCQkJIF8oInBhcmFsbGVsIGluZGV4IHZhY3V1bS9jbGVhbnVwOiAlZCB3 b3JrZXJzIHdlcmUgcGxhbm5lZCBhbmQgJWQgd29ya2VycyB3ZXJlIGxhdW5jaGVkIGluIHRvdGFs XG4iKSwKKwkJCQkJCQkJIHZhY3JlbC0+d29ya2Vyc191c2FnZS5ucGxhbm5lZCwKKwkJCQkJCQkJ IHZhY3JlbC0+d29ya2Vyc191c2FnZS5ubGF1bmNoZWQpOwogCQkJZm9yIChpbnQgaSA9IDA7IGkg PCB2YWNyZWwtPm5pbmRleGVzOyBpKyspCiAJCQl7CiAJCQkJSW5kZXhCdWxrRGVsZXRlUmVzdWx0 ICppc3RhdCA9IHZhY3JlbC0+aW5kc3RhdHNbaV07CkBAIC0yNjk4LDcgKzI3MTksOCBAQCBsYXp5 X3ZhY3V1bV9hbGxfaW5kZXhlcyhMVlJlbFN0YXRlICp2YWNyZWwpCiAJewogCQkvKiBPdXRzb3Vy Y2UgZXZlcnl0aGluZyB0byBwYXJhbGxlbCB2YXJpYW50ICovCiAJCXBhcmFsbGVsX3ZhY3V1bV9i dWxrZGVsX2FsbF9pbmRleGVzKHZhY3JlbC0+cHZzLCBvbGRfbGl2ZV90dXBsZXMsCi0JCQkJCQkJ CQkJCXZhY3JlbC0+bnVtX2luZGV4X3NjYW5zKTsKKwkJCQkJCQkJCQkJdmFjcmVsLT5udW1faW5k ZXhfc2NhbnMsCisJCQkJCQkJCQkJCSZ2YWNyZWwtPndvcmtlcnNfdXNhZ2UpOwogCiAJCS8qCiAJ CSAqIERvIGEgcG9zdGNoZWNrIHRvIGNvbnNpZGVyIGFwcGx5aW5nIHdyYXBhcm91bmQgZmFpbHNh ZmUgbm93LiAgTm90ZQpAQCAtMzEzMSw3ICszMTUzLDggQEAgbGF6eV9jbGVhbnVwX2FsbF9pbmRl eGVzKExWUmVsU3RhdGUgKnZhY3JlbCkKIAkJLyogT3V0c291cmNlIGV2ZXJ5dGhpbmcgdG8gcGFy YWxsZWwgdmFyaWFudCAqLwogCQlwYXJhbGxlbF92YWN1dW1fY2xlYW51cF9hbGxfaW5kZXhlcyh2 YWNyZWwtPnB2cywgcmVsdHVwbGVzLAogCQkJCQkJCQkJCQl2YWNyZWwtPm51bV9pbmRleF9zY2Fu cywKLQkJCQkJCQkJCQkJZXN0aW1hdGVkX2NvdW50KTsKKwkJCQkJCQkJCQkJZXN0aW1hdGVkX2Nv dW50LAorCQkJCQkJCQkJCQkmdmFjcmVsLT53b3JrZXJzX3VzYWdlKTsKIAl9CiAKIAkvKiBSZXNl dCB0aGUgcHJvZ3Jlc3MgY291bnRlcnMgKi8KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2NvbW1h bmRzL3ZhY3V1bXBhcmFsbGVsLmMgYi9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxl bC5jCmluZGV4IGNiNDJkNGU1NzJmLi5jMzIzMTRmOTczMSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tl bmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYworKysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy92 YWN1dW1wYXJhbGxlbC5jCkBAIC0yMjcsNyArMjI3LDcgQEAgc3RydWN0IFBhcmFsbGVsVmFjdXVt U3RhdGUKIHN0YXRpYyBpbnQJcGFyYWxsZWxfdmFjdXVtX2NvbXB1dGVfd29ya2VycyhSZWxhdGlv biAqaW5kcmVscywgaW50IG5pbmRleGVzLCBpbnQgbnJlcXVlc3RlZCwKIAkJCQkJCQkJCQkJYm9v bCAqd2lsbF9wYXJhbGxlbF92YWN1dW0pOwogc3RhdGljIHZvaWQgcGFyYWxsZWxfdmFjdXVtX3By b2Nlc3NfYWxsX2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLCBpbnQgbnVtX2luZGV4 X3NjYW5zLAotCQkJCQkJCQkJCQkJYm9vbCB2YWN1dW0pOworCQkJCQkJCQkJCQkJYm9vbCB2YWN1 dW0sIFBWV29ya2Vyc1VzYWdlICp3dXNhZ2UpOwogc3RhdGljIHZvaWQgcGFyYWxsZWxfdmFjdXVt X3Byb2Nlc3Nfc2FmZV9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cyk7CiBzdGF0aWMg dm9pZCBwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc191bnNhZmVfaW5kZXhlcyhQYXJhbGxlbFZhY3V1 bVN0YXRlICpwdnMpOwogc3RhdGljIHZvaWQgcGFyYWxsZWxfdmFjdXVtX3Byb2Nlc3Nfb25lX2lu ZGV4KFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywgUmVsYXRpb24gaW5kcmVsLApAQCAtNTAyLDcg KzUwMiw3IEBAIHBhcmFsbGVsX3ZhY3V1bV9yZXNldF9kZWFkX2l0ZW1zKFBhcmFsbGVsVmFjdXVt U3RhdGUgKnB2cykKICAqLwogdm9pZAogcGFyYWxsZWxfdmFjdXVtX2J1bGtkZWxfYWxsX2luZGV4 ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLCBsb25nIG51bV90YWJsZV90dXBsZXMsCi0JCQkJ CQkJCQlpbnQgbnVtX2luZGV4X3NjYW5zKQorCQkJCQkJCQkJaW50IG51bV9pbmRleF9zY2Fucywg UFZXb3JrZXJzVXNhZ2UgKnd1c2FnZSkKIHsKIAlBc3NlcnQoIUlzUGFyYWxsZWxXb3JrZXIoKSk7 CiAKQEAgLTUxMyw3ICs1MTMsNyBAQCBwYXJhbGxlbF92YWN1dW1fYnVsa2RlbF9hbGxfaW5kZXhl cyhQYXJhbGxlbFZhY3V1bVN0YXRlICpwdnMsIGxvbmcgbnVtX3RhYmxlX3R1cAogCXB2cy0+c2hh cmVkLT5yZWx0dXBsZXMgPSBudW1fdGFibGVfdHVwbGVzOwogCXB2cy0+c2hhcmVkLT5lc3RpbWF0 ZWRfY291bnQgPSB0cnVlOwogCi0JcGFyYWxsZWxfdmFjdXVtX3Byb2Nlc3NfYWxsX2luZGV4ZXMo cHZzLCBudW1faW5kZXhfc2NhbnMsIHRydWUpOworCXBhcmFsbGVsX3ZhY3V1bV9wcm9jZXNzX2Fs bF9pbmRleGVzKHB2cywgbnVtX2luZGV4X3NjYW5zLCB0cnVlLCB3dXNhZ2UpOwogfQogCiAvKgpA QCAtNTIxLDcgKzUyMSw4IEBAIHBhcmFsbGVsX3ZhY3V1bV9idWxrZGVsX2FsbF9pbmRleGVzKFBh cmFsbGVsVmFjdXVtU3RhdGUgKnB2cywgbG9uZyBudW1fdGFibGVfdHVwCiAgKi8KIHZvaWQKIHBh cmFsbGVsX3ZhY3V1bV9jbGVhbnVwX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2 cywgbG9uZyBudW1fdGFibGVfdHVwbGVzLAotCQkJCQkJCQkJaW50IG51bV9pbmRleF9zY2Fucywg Ym9vbCBlc3RpbWF0ZWRfY291bnQpCisJCQkJCQkJCQlpbnQgbnVtX2luZGV4X3NjYW5zLCBib29s IGVzdGltYXRlZF9jb3VudCwKKwkJCQkJCQkJCVBWV29ya2Vyc1VzYWdlICp3dXNhZ2UpCiB7CiAJ QXNzZXJ0KCFJc1BhcmFsbGVsV29ya2VyKCkpOwogCkBAIC01MzMsNyArNTM0LDcgQEAgcGFyYWxs ZWxfdmFjdXVtX2NsZWFudXBfYWxsX2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLCBs b25nIG51bV90YWJsZV90dXAKIAlwdnMtPnNoYXJlZC0+cmVsdHVwbGVzID0gbnVtX3RhYmxlX3R1 cGxlczsKIAlwdnMtPnNoYXJlZC0+ZXN0aW1hdGVkX2NvdW50ID0gZXN0aW1hdGVkX2NvdW50Owog Ci0JcGFyYWxsZWxfdmFjdXVtX3Byb2Nlc3NfYWxsX2luZGV4ZXMocHZzLCBudW1faW5kZXhfc2Nh bnMsIGZhbHNlKTsKKwlwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19hbGxfaW5kZXhlcyhwdnMsIG51 bV9pbmRleF9zY2FucywgZmFsc2UsIHd1c2FnZSk7CiB9CiAKIC8qCkBAIC02MTgsNyArNjE5LDcg QEAgcGFyYWxsZWxfdmFjdXVtX2NvbXB1dGVfd29ya2VycyhSZWxhdGlvbiAqaW5kcmVscywgaW50 IG5pbmRleGVzLCBpbnQgbnJlcXVlc3RlZCwKICAqLwogc3RhdGljIHZvaWQKIHBhcmFsbGVsX3Zh Y3V1bV9wcm9jZXNzX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywgaW50IG51 bV9pbmRleF9zY2FucywKLQkJCQkJCQkJCWJvb2wgdmFjdXVtKQorCQkJCQkJCQkJYm9vbCB2YWN1 dW0sIFBWV29ya2Vyc1VzYWdlICp3dXNhZ2UpCiB7CiAJaW50CQkJbndvcmtlcnM7CiAJUFZJbmRW YWNTdGF0dXMgbmV3X3N0YXR1czsKQEAgLTY1NSw2ICs2NTYsMTAgQEAgcGFyYWxsZWxfdmFjdXVt X3Byb2Nlc3NfYWxsX2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLCBpbnQgbnVtX2lu ZGV4X3NjYW4KIAkgKi8KIAlud29ya2VycyA9IE1pbihud29ya2VycywgcHZzLT5wY3h0LT5ud29y a2Vycyk7CiAKKwkvKiBSZW1lbWJlciB0aGlzIHZhbHVlLCBpZiB3ZSBhc2tlZCB0byAqLworCWlm ICh3dXNhZ2UgIT0gTlVMTCAmJiBud29ya2VycyA+IDApCisJCXd1c2FnZS0+bnBsYW5uZWQgKz0g bndvcmtlcnM7CisKIAkvKgogCSAqIFJlc2VydmUgd29ya2VycyBpbiBhdXRvdmFjdXVtIGdsb2Jh bCBzdGF0ZS4gTm90ZSB0aGF0IHdlIG1heSBiZSBnaXZlbgogCSAqIGZld2VyIHdvcmtlcnMgdGhh biB3ZSByZXF1ZXN0ZWQuCkBAIC03MjUsNiArNzMwLDEwIEBAIHBhcmFsbGVsX3ZhY3V1bV9wcm9j ZXNzX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywgaW50IG51bV9pbmRleF9z Y2FuCiAJCQkvKiBFbmFibGUgc2hhcmVkIGNvc3QgYmFsYW5jZSBmb3IgbGVhZGVyIGJhY2tlbmQg Ki8KIAkJCVZhY3V1bVNoYXJlZENvc3RCYWxhbmNlID0gJihwdnMtPnNoYXJlZC0+Y29zdF9iYWxh bmNlKTsKIAkJCVZhY3V1bUFjdGl2ZU5Xb3JrZXJzID0gJihwdnMtPnNoYXJlZC0+YWN0aXZlX253 b3JrZXJzKTsKKworCQkJLyogUmVtZW1iZXIgdGhpcyB2YWx1ZSwgaWYgd2UgYXNrZWQgdG8gKi8K KwkJCWlmICh3dXNhZ2UgIT0gTlVMTCkKKwkJCQl3dXNhZ2UtPm5sYXVuY2hlZCArPSBwdnMtPnBj eHQtPm53b3JrZXJzX2xhdW5jaGVkOwogCQl9CiAKIAkJaWYgKHZhY3V1bSkKZGlmZiAtLWdpdCBh L3NyYy9pbmNsdWRlL2NvbW1hbmRzL3ZhY3V1bS5oIGIvc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFj dXVtLmgKaW5kZXggZTg4NWE0YjljNzcuLmVjNWQ3MGFhY2RjIDEwMDY0NAotLS0gYS9zcmMvaW5j bHVkZS9jb21tYW5kcy92YWN1dW0uaAorKysgYi9zcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0u aApAQCAtMzAwLDYgKzMwMCwxNiBAQCB0eXBlZGVmIHN0cnVjdCBWYWNEZWFkSXRlbXNJbmZvCiAJ aW50NjQJCW51bV9pdGVtczsJCS8qIGN1cnJlbnQgIyBvZiBlbnRyaWVzICovCiB9IFZhY0RlYWRJ dGVtc0luZm87CiAKKy8qCisgKiBQVldvcmtlcnNVc2FnZSBzdG9yZXMgaW5mb3JtYXRpb24gYWJv dXQgdG90YWwgbnVtYmVyIG9mIGxhdW5jaGVkIGFuZCBwbGFubmVkCisgKiB3b3JrZXJzIGR1cmlu ZyBwYXJhbGxlbCB2YWN1dW0uCisgKi8KK3R5cGVkZWYgc3RydWN0IFBWV29ya2Vyc1VzYWdlCit7 CisJaW50CQkJbmxhdW5jaGVkOworCWludAkJCW5wbGFubmVkOworfSBQVldvcmtlcnNVc2FnZTsK KwogLyogR1VDIHBhcmFtZXRlcnMgKi8KIGV4dGVybiBQR0RMTElNUE9SVCBpbnQgZGVmYXVsdF9z dGF0aXN0aWNzX3RhcmdldDsJLyogUEdETExJTVBPUlQgZm9yIFBvc3RHSVMgKi8KIGV4dGVybiBQ R0RMTElNUE9SVCBpbnQgdmFjdXVtX2ZyZWV6ZV9taW5fYWdlOwpAQCAtMzk0LDExICs0MDQsMTMg QEAgZXh0ZXJuIFRpZFN0b3JlICpwYXJhbGxlbF92YWN1dW1fZ2V0X2RlYWRfaXRlbXMoUGFyYWxs ZWxWYWN1dW1TdGF0ZSAqcHZzLAogZXh0ZXJuIHZvaWQgcGFyYWxsZWxfdmFjdXVtX3Jlc2V0X2Rl YWRfaXRlbXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzKTsKIGV4dGVybiB2b2lkIHBhcmFsbGVs X3ZhY3V1bV9idWxrZGVsX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywKIAkJ CQkJCQkJCQkJCWxvbmcgbnVtX3RhYmxlX3R1cGxlcywKLQkJCQkJCQkJCQkJCWludCBudW1faW5k ZXhfc2NhbnMpOworCQkJCQkJCQkJCQkJaW50IG51bV9pbmRleF9zY2FucywKKwkJCQkJCQkJCQkJ CVBWV29ya2Vyc1VzYWdlICp3dXNhZ2UpOwogZXh0ZXJuIHZvaWQgcGFyYWxsZWxfdmFjdXVtX2Ns ZWFudXBfYWxsX2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLAogCQkJCQkJCQkJCQkJ bG9uZyBudW1fdGFibGVfdHVwbGVzLAogCQkJCQkJCQkJCQkJaW50IG51bV9pbmRleF9zY2FucywK LQkJCQkJCQkJCQkJCWJvb2wgZXN0aW1hdGVkX2NvdW50KTsKKwkJCQkJCQkJCQkJCWJvb2wgZXN0 aW1hdGVkX2NvdW50LAorCQkJCQkJCQkJCQkJUFZXb3JrZXJzVXNhZ2UgKnd1c2FnZSk7CiBleHRl cm4gdm9pZCBwYXJhbGxlbF92YWN1dW1fbWFpbihkc21fc2VnbWVudCAqc2VnLCBzaG1fdG9jICp0 b2MpOwogCiAvKiBpbiBjb21tYW5kcy9hbmFseXplLmMgKi8KZGlmZiAtLWdpdCBhL3NyYy90b29s cy9wZ2luZGVudC90eXBlZGVmcy5saXN0IGIvc3JjL3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZzLmxp c3QKaW5kZXggM2YzYTg4OGZkMGUuLmFmZWJkZTcyMjM1IDEwMDY0NAotLS0gYS9zcmMvdG9vbHMv cGdpbmRlbnQvdHlwZWRlZnMubGlzdAorKysgYi9zcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMu bGlzdApAQCAtMjQwNCw2ICsyNDA0LDcgQEAgUHVsbEZpbHRlck9wcwogUHVzaEZpbHRlcgogUHVz aEZpbHRlck9wcwogUHVzaEZ1bmN0aW9uCitQVldvcmtlcnNVc2FnZQogUHlDRnVuY3Rpb24KIFB5 TWV0aG9kRGVmCiBQeU1vZHVsZURlZgotLSAKMi40My4wCgo= --0000000000009cbd1f064881e9cc Content-Type: text/x-patch; charset="US-ASCII"; name="v19-0004-Tests-for-parallel-autovacuum.patch" Content-Disposition: attachment; filename="v19-0004-Tests-for-parallel-autovacuum.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mkgyhkff1 RnJvbSBjZjA2YTQwOGFmZTMzMzczYTgwMmZiMTY1MDdjOTE4NTAyNDRlNjM4IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBTdW4sIDIzIE5vdiAyMDI1IDAxOjA4OjE0ICswNzAwClN1YmplY3Q6IFtQQVRD SCB2MTkgNC81XSBUZXN0cyBmb3IgcGFyYWxsZWwgYXV0b3ZhY3V1bQoKLS0tCiBzcmMvYmFja2Vu ZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jICAgICAgICAgfCAgMjkgKysKIHNyYy9iYWNrZW5k L3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jICAgICAgICAgICB8ICAxNyArCiBzcmMvaW5jbHVkZS9w b3N0bWFzdGVyL2F1dG92YWN1dW0uaCAgICAgICAgICAgfCAgIDEgKwogc3JjL3Rlc3QvbW9kdWxl cy9NYWtlZmlsZSAgICAgICAgICAgICAgICAgICAgIHwgICAxICsKIHNyYy90ZXN0L21vZHVsZXMv bWVzb24uYnVpbGQgICAgICAgICAgICAgICAgICB8ICAgMSArCiBzcmMvdGVzdC9tb2R1bGVzL3Rl c3RfYXV0b3ZhY3V1bS8uZ2l0aWdub3JlICAgfCAgIDIgKwogc3JjL3Rlc3QvbW9kdWxlcy90ZXN0 X2F1dG92YWN1dW0vTWFrZWZpbGUgICAgIHwgIDI4ICsrCiBzcmMvdGVzdC9tb2R1bGVzL3Rlc3Rf YXV0b3ZhY3V1bS9tZXNvbi5idWlsZCAgfCAgMzYgKysKIC4uLi9tb2R1bGVzL3Rlc3RfYXV0b3Zh Y3V1bS90LzAwMV9iYXNpYy5wbCAgICB8IDMyNSArKysrKysrKysrKysrKysrKysKIC4uLi90ZXN0 X2F1dG92YWN1dW0vdGVzdF9hdXRvdmFjdXVtLS0xLjAuc3FsICB8ICAyMCArKwogLi4uL21vZHVs ZXMvdGVzdF9hdXRvdmFjdXVtL3Rlc3RfYXV0b3ZhY3V1bS5jIHwgMTY2ICsrKysrKysrKwogLi4u L3Rlc3RfYXV0b3ZhY3V1bS90ZXN0X2F1dG92YWN1dW0uY29udHJvbCAgIHwgICAzICsKIDEyIGZp bGVzIGNoYW5nZWQsIDYyOSBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgc3JjL3Rl c3QvbW9kdWxlcy90ZXN0X2F1dG92YWN1dW0vLmdpdGlnbm9yZQogY3JlYXRlIG1vZGUgMTAwNjQ0 IHNyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVtL01ha2VmaWxlCiBjcmVhdGUgbW9kZSAx MDA2NDQgc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2F1dG92YWN1dW0vbWVzb24uYnVpbGQKIGNyZWF0 ZSBtb2RlIDEwMDY0NCBzcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYXV0b3ZhY3V1bS90LzAwMV9iYXNp Yy5wbAogY3JlYXRlIG1vZGUgMTAwNjQ0IHNyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVt L3Rlc3RfYXV0b3ZhY3V1bS0tMS4wLnNxbAogY3JlYXRlIG1vZGUgMTAwNjQ0IHNyYy90ZXN0L21v ZHVsZXMvdGVzdF9hdXRvdmFjdXVtL3Rlc3RfYXV0b3ZhY3V1bS5jCiBjcmVhdGUgbW9kZSAxMDA2 NDQgc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2F1dG92YWN1dW0vdGVzdF9hdXRvdmFjdXVtLmNvbnRy b2wKCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jIGIv c3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYwppbmRleCA3MTQ0OTYzMGI2My4u MWVhZDZlMTE5M2IgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFs bGVsLmMKKysrIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYwpAQCAtMzks NiArMzksNyBAQAogI2luY2x1ZGUgInBvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5oIgogI2luY2x1ZGUg InN0b3JhZ2UvYnVmbWdyLmgiCiAjaW5jbHVkZSAidGNvcC90Y29wcHJvdC5oIgorI2luY2x1ZGUg InV0aWxzL2luamVjdGlvbl9wb2ludC5oIgogI2luY2x1ZGUgInV0aWxzL2xzeXNjYWNoZS5oIgog I2luY2x1ZGUgInV0aWxzL3JlbC5oIgogCkBAIC04NDYsNiArODQ3LDE0IEBAIHBhcmFsbGVsX3Zh Y3V1bV9wcm9jZXNzX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywgaW50IG51 bV9pbmRleF9zY2FuCiAJCQkJCQkJcHZzLT5wY3h0LT5ud29ya2Vyc19sYXVuY2hlZCwgbndvcmtl cnMpKSk7CiAJfQogCisJLyoKKwkgKiBUbyBiZSBhYmxlIHRvIGV4ZXJjaXNlIHdoZXRoZXIgYWxs IHJlc2VydmVkIHBhcmFsbGVsIHdvcmtlcnMgYXJlIGJlaW5nCisJICogcmVsZWFzZWQgYW55d2F5 LCBhbGxvdyBpbmplY3Rpb24gcG9pbnRzIHRvIHRyaWdnZXIgYSBmYWlsdXJlIGF0IHRoaXMKKwkg KiBwb2ludC4KKwkgKi8KKwlpZiAobndvcmtlcnMgPiAwKQorCQlJTkpFQ1RJT05fUE9JTlQoImF1 dG92YWN1dW0tbGVhZGVyLWJlZm9yZS1pbmRleGVzLXByb2Nlc3NpbmciLCBOVUxMKTsKKwogCS8q IFZhY3V1bSB0aGUgaW5kZXhlcyB0aGF0IGNhbiBiZSBwcm9jZXNzZWQgYnkgb25seSBsZWFkZXIg cHJvY2VzcyAqLwogCXBhcmFsbGVsX3ZhY3V1bV9wcm9jZXNzX3Vuc2FmZV9pbmRleGVzKHB2cyk7 CiAKQEAgLTg1NSw2ICs4NjQsMTUgQEAgcGFyYWxsZWxfdmFjdXVtX3Byb2Nlc3NfYWxsX2luZGV4 ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLCBpbnQgbnVtX2luZGV4X3NjYW4KIAkgKi8KIAlw YXJhbGxlbF92YWN1dW1fcHJvY2Vzc19zYWZlX2luZGV4ZXMocHZzKTsKIAorCS8qCisJICogVG8g YmUgYWJsZSB0byBleGVyY2lzZSB3aGV0aGVyIGxlYWRlciBwYXJhbGxlbCBhdXRvdmFjdXVtIHdv cmtlciBjYW4KKwkgKiBwcm9wYWdhdGUgY29zdC1iYXNlZCBwYXJhbXMgdG8gcGFyYWxsZWwgd29y a2Vycywgd2FpdCBoZXJlIHVudGlsCisJICogY29uZmlndXJhdGlvbiBpcyBjaGFuZ2VkLiBJLmUu IHRlc3RzIGFyZSBleHBlY3RpbmcsIHRoYXQgZHVyaW5nIGluZGV4CisJICogcHJvY2Vzc2luZyB2 YWN1dW1fZGVsYXlfcG9pbnQgaGF2ZSBiZWVuIGNhbGxlZCAoaWYgY29uZmlnIHdhcyBjaGFuZ2Vk KS4KKwkgKi8KKwlpZiAobndvcmtlcnMgPiAwKQorCQlJTkpFQ1RJT05fUE9JTlQoImF1dG92YWN1 dW0tbGVhZGVyLWFmdGVyLWluZGV4ZXMtcHJvY2Vzc2luZyIsIE5VTEwpOworCiAJLyoKIAkgKiBO ZXh0LCBhY2N1bXVsYXRlIGJ1ZmZlciBhbmQgV0FMIHVzYWdlLiAgKFRoaXMgbXVzdCB3YWl0IGZv ciB0aGUgd29ya2VycwogCSAqIHRvIGZpbmlzaCwgb3Igd2UgbWlnaHQgZ2V0IGluY29tcGxldGUg ZGF0YS4pCkBAIC0xMjIwLDkgKzEyMzgsMjAgQEAgcGFyYWxsZWxfdmFjdXVtX21haW4oZHNtX3Nl Z21lbnQgKnNlZywgc2htX3RvYyAqdG9jKQogCS8qIFByZXBhcmUgdG8gdHJhY2sgYnVmZmVyIHVz YWdlIGR1cmluZyBwYXJhbGxlbCBleGVjdXRpb24gKi8KIAlJbnN0clN0YXJ0UGFyYWxsZWxRdWVy eSgpOwogCisJSU5KRUNUSU9OX1BPSU5UKCJwYXJhbGxlbC13b3JrZXItYmVmb3JlLWluZGV4ZXMt cHJvY2Vzc2luZyIsIE5VTEwpOworCiAJLyogUHJvY2VzcyBpbmRleGVzIHRvIHBlcmZvcm0gdmFj dXVtL2NsZWFudXAgKi8KIAlwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19zYWZlX2luZGV4ZXMoJnB2 cyk7CiAKKwkvKgorCSAqIFRoZXJlIGlzIG5vIGd1YXJhbnRlZSB0aGF0IGVhY2ggcGFyYWxsZWwg d29ya2VyIHdpbGwgbmVjZXNzYXJpbHkKKwkgKiBwcm9jZXNzIGF0IGxlYXN0IG9uZSBpbmRleC4g VGh1cywgYXQgdGhpcyBwb2ludCB3ZSBjYW5ub3QgYmUgc3VyZSB0aGF0CisJICogd29ya2VyIGNh bGxlZCB2YWN1dW1fY29zdF9kZWxheS4gSW4gb3JkZXIgdG8gdGVzdCBjb3N0LWJhc2VkIHBhcmFt ZXRlcnMKKwkgKiBwcm9wYWdhdGlvbiAoZnJvbSBsZWFkZXIgd29ya2VyKSwgY2FsbCB2YWN1dW1f ZGVsYXlfcG9pbnQgaGVyZSwgaWYKKwkgKiBpbmplY3Rpb24gcG9pbnQgaXMgYWN0aXZlLgorCSAq LworCUlOSkVDVElPTl9QT0lOVCgicGFyYWxsZWwtYXV0b3ZhY3V1bS1mb3JjZS1kZWxheS1wb2lu dCIsIE5VTEwpOworCiAJLyogUmVwb3J0IGJ1ZmZlci9XQUwgdXNhZ2UgZHVyaW5nIHBhcmFsbGVs IGV4ZWN1dGlvbiAqLwogCWJ1ZmZlcl91c2FnZSA9IHNobV90b2NfbG9va3VwKHRvYywgUEFSQUxM RUxfVkFDVVVNX0tFWV9CVUZGRVJfVVNBR0UsIGZhbHNlKTsKIAl3YWxfdXNhZ2UgPSBzaG1fdG9j X2xvb2t1cCh0b2MsIFBBUkFMTEVMX1ZBQ1VVTV9LRVlfV0FMX1VTQUdFLCBmYWxzZSk7CmRpZmYg LS1naXQgYS9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYyBiL3NyYy9iYWNrZW5k L3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCmluZGV4IDk4OTY1ZmQ4ZTJkLi5kYjk5MjQxZGYzZSAx MDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMKKysrIGIvc3Jj L2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMKQEAgLTM0NTYsNiArMzQ1NiwyMyBAQCBB dXRvVmFjdXVtUmVsZWFzZUFsbFBhcmFsbGVsV29ya2Vycyh2b2lkKQogCQlBdXRvVmFjdXVtUmVs ZWFzZVBhcmFsbGVsV29ya2Vycyhhdl9ud29ya2Vyc19yZXNlcnZlZCk7CiB9CiAKKy8qCisgKiBH ZXQgbnVtYmVyIG9mIGZyZWUgYXV0b3ZhY3V1bSBwYXJhbGxlbCB3b3JrZXJzLgorICoKKyAqIEZv ciB0ZXN0aW5nIHB1cnBvc2Ugb25seSEKKyAqLwordWludDMyCitBdXRvVmFjdXVtR2V0RnJlZVBh cmFsbGVsV29ya2Vycyh2b2lkKQoreworCXVpbnQzMgkJbmZyZWVfd29ya2VyczsKKworCUxXTG9j a0FjcXVpcmUoQXV0b3ZhY3V1bUxvY2ssIExXX0VYQ0xVU0lWRSk7CisJbmZyZWVfd29ya2VycyA9 IEF1dG9WYWN1dW1TaG1lbS0+YXZfZnJlZVBhcmFsbGVsV29ya2VyczsKKwlMV0xvY2tSZWxlYXNl KEF1dG92YWN1dW1Mb2NrKTsKKworCXJldHVybiBuZnJlZV93b3JrZXJzOworfQorCiAvKgogICog YXV0b3ZhY19pbml0CiAgKgkJVGhpcyBpcyBjYWxsZWQgYXQgcG9zdG1hc3RlciBpbml0aWFsaXph dGlvbi4KZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5oIGIv c3JjL2luY2x1ZGUvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmgKaW5kZXggM2Y1YjU5YTE1YmQuLmY1 MGM3NDYyY2Q0IDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9wb3N0bWFzdGVyL2F1dG92YWN1dW0u aAorKysgYi9zcmMvaW5jbHVkZS9wb3N0bWFzdGVyL2F1dG92YWN1dW0uaApAQCAtNjUsNiArNjUs NyBAQCBleHRlcm4gYm9vbCBBdXRvVmFjdXVtUmVxdWVzdFdvcmsoQXV0b1ZhY3V1bVdvcmtJdGVt VHlwZSB0eXBlLAogLyogcGFyYWxsZWwgYXV0b3ZhY3V1bSBzdHVmZiAqLwogZXh0ZXJuIHZvaWQJ QXV0b1ZhY3V1bVJlc2VydmVQYXJhbGxlbFdvcmtlcnMoaW50ICpud29ya2Vycyk7CiBleHRlcm4g dm9pZCBBdXRvVmFjdXVtUmVsZWFzZVBhcmFsbGVsV29ya2VycyhpbnQgbndvcmtlcnMpOworZXh0 ZXJuIHVpbnQzMiBBdXRvVmFjdXVtR2V0RnJlZVBhcmFsbGVsV29ya2Vycyh2b2lkKTsKIAogLyog c2hhcmVkIG1lbW9yeSBzdHVmZiAqLwogZXh0ZXJuIFNpemUgQXV0b1ZhY3V1bVNobWVtU2l6ZSh2 b2lkKTsKZGlmZiAtLWdpdCBhL3NyYy90ZXN0L21vZHVsZXMvTWFrZWZpbGUgYi9zcmMvdGVzdC9t b2R1bGVzL01ha2VmaWxlCmluZGV4IDRjNmQ1NmQ5N2Q4Li5iZmUzNjVmYTU3NSAxMDA2NDQKLS0t IGEvc3JjL3Rlc3QvbW9kdWxlcy9NYWtlZmlsZQorKysgYi9zcmMvdGVzdC9tb2R1bGVzL01ha2Vm aWxlCkBAIC0xNiw2ICsxNiw3IEBAIFNVQkRJUlMgPSBcCiAJCSAgcGxzYW1wbGUgXAogCQkgIHNw Z2lzdF9uYW1lX29wcyBcCiAJCSAgdGVzdF9haW8gXAorCQkgIHRlc3RfYXV0b3ZhY3V1bSBcCiAJ CSAgdGVzdF9iaW5hcnloZWFwIFwKIAkJICB0ZXN0X2JpdG1hcHNldCBcCiAJCSAgdGVzdF9ibG9v bWZpbHRlciBcCmRpZmYgLS1naXQgYS9zcmMvdGVzdC9tb2R1bGVzL21lc29uLmJ1aWxkIGIvc3Jj L3Rlc3QvbW9kdWxlcy9tZXNvbi5idWlsZAppbmRleCAxYjMxYzViOThkNi4uMDFhM2UzZWMwNDQg MTAwNjQ0Ci0tLSBhL3NyYy90ZXN0L21vZHVsZXMvbWVzb24uYnVpbGQKKysrIGIvc3JjL3Rlc3Qv bW9kdWxlcy9tZXNvbi5idWlsZApAQCAtMTYsNiArMTYsNyBAQCBzdWJkaXIoJ3Bsc2FtcGxlJykK IHN1YmRpcignc3BnaXN0X25hbWVfb3BzJykKIHN1YmRpcignc3NsX3Bhc3NwaHJhc2VfY2FsbGJh Y2snKQogc3ViZGlyKCd0ZXN0X2FpbycpCitzdWJkaXIoJ3Rlc3RfYXV0b3ZhY3V1bScpCiBzdWJk aXIoJ3Rlc3RfYmluYXJ5aGVhcCcpCiBzdWJkaXIoJ3Rlc3RfYml0bWFwc2V0JykKIHN1YmRpcign dGVzdF9ibG9vbWZpbHRlcicpCmRpZmYgLS1naXQgYS9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYXV0 b3ZhY3V1bS8uZ2l0aWdub3JlIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2F1dG92YWN1dW0vLmdp dGlnbm9yZQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMC4uNzE2ZTE3ZjVh MmEKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYXV0b3ZhY3V1bS8u Z2l0aWdub3JlCkBAIC0wLDAgKzEsMiBAQAorIyBHZW5lcmF0ZWQgc3ViZGlyZWN0b3JpZXMKKy90 bXBfY2hlY2svCmRpZmYgLS1naXQgYS9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYXV0b3ZhY3V1bS9N YWtlZmlsZSBiL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVtL01ha2VmaWxlCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi4zMjI1NGM1M2E1ZAotLS0gL2Rldi9u dWxsCisrKyBiL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVtL01ha2VmaWxlCkBAIC0w LDAgKzEsMjggQEAKKyMgc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2F1dG92YWN1dW0vTWFrZWZpbGUK KworUEdGSUxFREVTQyA9ICJ0ZXN0X2F1dG92YWN1dW0gLSB0ZXN0IGNvZGUgZm9yIHBhcmFsbGVs IGF1dG92YWN1dW0iCisKK01PRFVMRV9iaWcgPSB0ZXN0X2F1dG92YWN1dW0KK09CSlMgPSBcCisJ JChXSU4zMlJFUykgXAorCXRlc3RfYXV0b3ZhY3V1bS5vCisKK0VYVEVOU0lPTiA9IHRlc3RfYXV0 b3ZhY3V1bQorREFUQSA9IHRlc3RfYXV0b3ZhY3V1bS0tMS4wLnNxbAorCitUQVBfVEVTVFMgPSAx CisKK0VYVFJBX0lOU1RBTEwgPSBzcmMvdGVzdC9tb2R1bGVzL2luamVjdGlvbl9wb2ludHMKKwor ZXhwb3J0IGVuYWJsZV9pbmplY3Rpb25fcG9pbnRzCisKK2lmZGVmIFVTRV9QR1hTCitQR19DT05G SUcgPSBwZ19jb25maWcKK1BHWFMgOj0gJChzaGVsbCAkKFBHX0NPTkZJRykgLS1wZ3hzKQoraW5j bHVkZSAkKFBHWFMpCitlbHNlCitzdWJkaXIgPSBzcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYXV0b3Zh Y3V1bQordG9wX2J1aWxkZGlyID0gLi4vLi4vLi4vLi4KK2luY2x1ZGUgJCh0b3BfYnVpbGRkaXIp L3NyYy9NYWtlZmlsZS5nbG9iYWwKK2luY2x1ZGUgJCh0b3Bfc3JjZGlyKS9jb250cmliL2NvbnRy aWItZ2xvYmFsLm1rCitlbmRpZgpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2F1 dG92YWN1dW0vbWVzb24uYnVpbGQgYi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYXV0b3ZhY3V1bS9t ZXNvbi5idWlsZApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMC4uMzQ0MWU1 ZTQ5Y2YKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYXV0b3ZhY3V1 bS9tZXNvbi5idWlsZApAQCAtMCwwICsxLDM2IEBACisjIENvcHlyaWdodCAoYykgMjAyNC0yMDI1 LCBQb3N0Z3JlU1FMIEdsb2JhbCBEZXZlbG9wbWVudCBHcm91cAorCit0ZXN0X2F1dG92YWN1dW1f c291cmNlcyA9IGZpbGVzKAorICAndGVzdF9hdXRvdmFjdXVtLmMnLAorKQorCitpZiBob3N0X3N5 c3RlbSA9PSAnd2luZG93cycKKyAgdGVzdF9hdXRvdmFjdXVtX3NvdXJjZXMgKz0gcmNfbGliX2dl bi5wcm9jZXNzKHdpbjMydmVyX3JjLCBleHRyYV9hcmdzOiBbCisgICAgJy0tTkFNRScsICd0ZXN0 X2F1dG92YWN1dW0nLAorICAgICctLUZJTEVERVNDJywgJ3Rlc3RfYXV0b3ZhY3V1bSAtIHRlc3Qg Y29kZSBmb3IgcGFyYWxsZWwgYXV0b3ZhY3V1bScsXSkKK2VuZGlmCisKK3Rlc3RfYXV0b3ZhY3V1 bSA9IHNoYXJlZF9tb2R1bGUoJ3Rlc3RfYXV0b3ZhY3V1bScsCisgIHRlc3RfYXV0b3ZhY3V1bV9z b3VyY2VzLAorICBrd2FyZ3M6IHBnX3Rlc3RfbW9kX2FyZ3MsCispCit0ZXN0X2luc3RhbGxfbGli cyArPSB0ZXN0X2F1dG92YWN1dW0KKwordGVzdF9pbnN0YWxsX2RhdGEgKz0gZmlsZXMoCisgICd0 ZXN0X2F1dG92YWN1dW0uY29udHJvbCcsCisgICd0ZXN0X2F1dG92YWN1dW0tLTEuMC5zcWwnLAor KQorCit0ZXN0cyArPSB7CisgICduYW1lJzogJ3Rlc3RfYXV0b3ZhY3V1bScsCisgICdzZCc6IG1l c29uLmN1cnJlbnRfc291cmNlX2RpcigpLAorICAnYmQnOiBtZXNvbi5jdXJyZW50X2J1aWxkX2Rp cigpLAorICAndGFwJzogeworICAgICdlbnYnOiB7CisgICAgICAgJ2VuYWJsZV9pbmplY3Rpb25f cG9pbnRzJzogZ2V0X29wdGlvbignaW5qZWN0aW9uX3BvaW50cycpID8gJ3llcycgOiAnbm8nLAor ICAgIH0sCisgICAgJ3Rlc3RzJzogWworICAgICAgJ3QvMDAxX2Jhc2ljLnBsJywKKyAgICBdLAor ICB9LAorfQpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2F1dG92YWN1dW0vdC8w MDFfYmFzaWMucGwgYi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYXV0b3ZhY3V1bS90LzAwMV9iYXNp Yy5wbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMC4uMzY5ZDI5MDVhMmIK LS0tIC9kZXYvbnVsbAorKysgYi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYXV0b3ZhY3V1bS90LzAw MV9iYXNpYy5wbApAQCAtMCwwICsxLDMyNSBAQAordXNlIHdhcm5pbmdzIEZBVEFMID0+ICdhbGwn OwordXNlIFBvc3RncmVTUUw6OlRlc3Q6OkNsdXN0ZXI7Cit1c2UgUG9zdGdyZVNRTDo6VGVzdDo6 VXRpbHM7Cit1c2UgVGVzdDo6TW9yZTsKKworaWYgKCRFTlZ7ZW5hYmxlX2luamVjdGlvbl9wb2lu dHN9IG5lICd5ZXMnKQoreworCXBsYW4gc2tpcF9hbGwgPT4gJ0luamVjdGlvbiBwb2ludHMgbm90 IHN1cHBvcnRlZCBieSB0aGlzIGJ1aWxkJzsKK30KKworIyBCZWZvcmUgZWFjaCB0ZXN0IHdlIHNo b3VsZCBkaXNhYmxlIGF1dG92YWN1dW0gZm9yICd0ZXN0X2F1dG92YWMnIHRhYmxlIGFuZAorIyBn ZW5lcmF0ZSBzb21lIGRlYWQgdHVwbGVzIGluIGl0LgorCitzdWIgcHJlcGFyZV9mb3JfbmV4dF90 ZXN0Cit7CisJbXkgKCRub2RlLCAkdGVzdF9udW1iZXIpID0gQF87CisKKwkkbm9kZS0+c2FmZV9w c3FsKCdwb3N0Z3JlcycsIHFxeworCQlBTFRFUiBUQUJMRSB0ZXN0X2F1dG92YWMgU0VUIChhdXRv dmFjdXVtX2VuYWJsZWQgPSBmYWxzZSk7CisJfSk7CisKKwkkbm9kZS0+c2FmZV9wc3FsKCdwb3N0 Z3JlcycsIHFxeworCQlVUERBVEUgdGVzdF9hdXRvdmFjIFNFVCBjb2xfMSA9ICR0ZXN0X251bWJl cjsKKwkJQU5BTFlaRSB0ZXN0X2F1dG92YWM7CisJfSk7Cit9CisKK3N1YiB3YWl0X2Zvcl9hdl9s b2cKK3sKKwlteSAoJG5vZGUsICRleHBlY3RlZF9sb2cpID0gQF87CisKKwkkbm9kZS0+d2FpdF9m b3JfbG9nKCRleHBlY3RlZF9sb2cpOworCXRydW5jYXRlICRub2RlLT5sb2dmaWxlLCAwIG9yIGRp ZSAidHJ1bmNhdGUgZmFpbGVkOiAkISI7Cit9CisKK215ICRwc3FsX291dDsKKworbXkgJG5vZGUg PSBQb3N0Z3JlU1FMOjpUZXN0OjpDbHVzdGVyLT5uZXcoJ25vZGUxJyk7Ciskbm9kZS0+aW5pdDsK KworIyBDb25maWd1cmUgcG9zdGdyZXMsIHNvIGl0IGNhbiBsYXVuY2ggcGFyYWxsZWwgYXV0b3Zh Y3V1bSB3b3JrZXJzLCBsb2cgYWxsCisjIGluZm9ybWF0aW9uIHdlIGFyZSBpbnRlcmVzdGVkIGlu IGFuZCBhdXRvdmFjdXVtIHdvcmtzIGZyZXF1ZW50bHkKKyRub2RlLT5hcHBlbmRfY29uZigncG9z dGdyZXNxbC5jb25mJywgcXF7CisJbWF4X3dvcmtlcl9wcm9jZXNzZXMgPSAyMAorCW1heF9wYXJh bGxlbF93b3JrZXJzID0gMjAKKwltYXhfcGFyYWxsZWxfbWFpbnRlbmFuY2Vfd29ya2VycyA9IDIw CisJYXV0b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2VycyA9IDIwCisJbG9nX21pbl9tZXNzYWdl cyA9IGRlYnVnMgorCWxvZ19hdXRvdmFjdXVtX21pbl9kdXJhdGlvbiA9IDAKKwlhdXRvdmFjdXVt X25hcHRpbWUgPSAnMXMnCisJbWluX3BhcmFsbGVsX2luZGV4X3NjYW5fc2l6ZSA9IDAKKwlzaGFy ZWRfcHJlbG9hZF9saWJyYXJpZXM9dGVzdF9hdXRvdmFjdXVtCit9KTsKKyRub2RlLT5zdGFydDsK KworIyBDaGVjayBpZiB0aGUgZXh0ZW5zaW9uIGluamVjdGlvbl9wb2ludHMgaXMgYXZhaWxhYmxl LCBhcyBpdCBtYXkgYmUKKyMgcG9zc2libGUgdGhhdCB0aGlzIHNjcmlwdCBpcyBydW4gd2l0aCBp bnN0YWxsY2hlY2ssIHdoZXJlIHRoZSBtb2R1bGUKKyMgd291bGQgbm90IGJlIGluc3RhbGxlZCBi eSBkZWZhdWx0LgoraWYgKCEkbm9kZS0+Y2hlY2tfZXh0ZW5zaW9uKCdpbmplY3Rpb25fcG9pbnRz JykpCit7CisJcGxhbiBza2lwX2FsbCA9PiAnRXh0ZW5zaW9uIGluamVjdGlvbl9wb2ludHMgbm90 IGluc3RhbGxlZCc7Cit9CisKKyMgQ3JlYXRlIGFsbCBmdW5jdGlvbnMgbmVlZGVkIGZvciB0ZXN0 aW5nCiskbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFxeworCUNSRUFURSBFWFRFTlNJT04g dGVzdF9hdXRvdmFjdXVtOworCUNSRUFURSBFWFRFTlNJT04gaW5qZWN0aW9uX3BvaW50czsKK30p OworCitteSAkaW5kZXhlc19udW0gPSA0OworbXkgJGluaXRpYWxfcm93c19udW0gPSAxMF8wMDA7 CitteSAkYXV0b3ZhY3V1bV9wYXJhbGxlbF93b3JrZXJzID0gMjsKKworIyBDcmVhdGUgdGFibGUg d2l0aCBzcGVjaWZpZWQgbnVtYmVyIG9mIGItdHJlZSBpbmRleGVzIG9uIGl0Ciskbm9kZS0+c2Fm ZV9wc3FsKCdwb3N0Z3JlcycsIHFxeworCUNSRUFURSBUQUJMRSB0ZXN0X2F1dG92YWMgKAorCQlp ZCBTRVJJQUwgUFJJTUFSWSBLRVksCisJCWNvbF8xIElOVEVHRVIsICBjb2xfMiBJTlRFR0VSLCAg Y29sXzMgSU5URUdFUiwgIGNvbF80IElOVEVHRVIKKwkpIFdJVEggKGF1dG92YWN1dW1fcGFyYWxs ZWxfd29ya2VycyA9ICRhdXRvdmFjdXVtX3BhcmFsbGVsX3dvcmtlcnMpOworCisJRE8gXCRcJAor CURFQ0xBUkUKKwkJaSBJTlRFR0VSOworCUJFR0lOCisJCUZPUiBpIElOIDEuLiRpbmRleGVzX251 bSBMT09QCisJCQlFWEVDVVRFIGZvcm1hdCgnQ1JFQVRFIElOREVYIGlkeF9jb2xfXCVzIE9OIHRl c3RfYXV0b3ZhYyAoY29sX1wlcyk7JywgaSwgaSk7CisJCUVORCBMT09QOworCUVORCBcJFwkOwor fSk7CisKKyMgSW5zZXJ0IHNwZWNpZmllZCB0dXBsZXMgbnVtIGludG8gdGhlIHRhYmxlCiskbm9k ZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFxeworCURPIFwkXCQKKwlERUNMQVJFCisJCWkgSU5U RUdFUjsKKwlCRUdJTgorCQlGT1IgaSBJTiAxLi4kaW5pdGlhbF9yb3dzX251bSBMT09QCisJCQlJ TlNFUlQgSU5UTyB0ZXN0X2F1dG92YWMgVkFMVUVTIChpLCBpICsgMSwgaSArIDIsIGkgKyAzKTsK KwkJRU5EIExPT1A7CisJRU5EIFwkXCQ7Cit9KTsKKworIyBUZXN0IDEgOgorIyBPdXIgdGFibGUg aGFzIGVub3VnaCBpbmRleGVzIGFuZCBhcHByb3ByaWF0ZSByZWxvcHRpb25zLCBzbyBhdXRvdmFj dXVtIG11c3QKKyMgYmUgYWJsZSB0byBwcm9jZXNzIGl0IGluIHBhcmFsbGVsIG1vZGUuIEp1c3Qg Y2hlY2sgaWYgaXQgY2FuLgorIyBBbHNvIGNoZWNrIHdoZXRoZXIgYWxsIHJlcXVlc3RlZCB3b3Jr ZXJzOgorIyAJMSkgbGF1bmNoZWQKKyMgCTIpIGNvcnJlY3RseSByZWxlYXNlZAorCitwcmVwYXJl X2Zvcl9uZXh0X3Rlc3QoJG5vZGUsIDEpOworCiskbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3Jlcycs IHFxeworCUFMVEVSIFRBQkxFIHRlc3RfYXV0b3ZhYyBTRVQgKGF1dG92YWN1dW1fZW5hYmxlZCA9 IHRydWUpOworfSk7CisKKyMgV2FpdCB1bnRpbCB0aGUgcGFyYWxsZWwgYXV0b3ZhY3V1bSBvbiB0 YWJsZSBpcyBjb21wbGV0ZWQuIEF0IHRoZSBzYW1lIHRpbWUsCisjIHdlIGNoZWNrIHRoYXQgdGhl IHJlcXVpcmVkIG51bWJlciBvZiBwYXJhbGxlbCB3b3JrZXJzIGhhcyBiZWVuIHN0YXJ0ZWQuCit3 YWl0X2Zvcl9hdl9sb2coJG5vZGUsCisJCQkJcXIvcGFyYWxsZWwgaW5kZXggdmFjdXVtXC9jbGVh bnVwOiAyIHdvcmtlcnMgd2VyZSBwbGFubmVkIC8gLgorCQkJCXFyL2FuZCAyIHdvcmtlcnMgd2Vy ZSBsYXVuY2hlZCBpbiB0b3RhbC8pOworCiskbm9kZS0+cHNxbCgncG9zdGdyZXMnLAorCSJTRUxF Q1QgZ2V0X3BhcmFsbGVsX2F1dG92YWN1dW1fZnJlZV93b3JrZXJzKCk7IiwKKwlzdGRvdXQgPT4g XCRwc3FsX291dCwKKyk7CitpcygkcHNxbF9vdXQsIDIwLCAnQWxsIHBhcmFsbGVsIHdvcmtlcnMg aGFzIGJlZW4gcmVsZWFzZWQgYnkgdGhlIGxlYWRlcicpOworCisjIFRlc3QgMjoKKyMgQ2hlY2sg d2hldGhlciBwYXJhbGxlbCBhdXRvdmFjdXVtIGxlYWRlciBjYW4gcHJvcGFnYXRlIGNvc3QtYmFz ZWQgcGFyYW1ldGVycworIyB0byBwYXJhbGxlbCB3b3JrZXJzLgorCitwcmVwYXJlX2Zvcl9uZXh0 X3Rlc3QoJG5vZGUsIDIpOworCiskbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFxeworCVNF TEVDVCBpbmplY3Rpb25fcG9pbnRzX2F0dGFjaCgnYXV0b3ZhY3V1bS1sZWFkZXItYmVmb3JlLWlu ZGV4ZXMtcHJvY2Vzc2luZycsICd3YWl0Jyk7CisJU0VMRUNUIGluamVjdGlvbl9wb2ludHNfYXR0 YWNoKCdhdXRvdmFjdXVtLWxlYWRlci1hZnRlci1pbmRleGVzLXByb2Nlc3NpbmcnLCAnd2FpdCcp OworCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX2F0dGFjaCgncGFyYWxsZWwtd29ya2VyLWJlZm9y ZS1pbmRleGVzLXByb2Nlc3NpbmcnLCAnd2FpdCcpOworCVNFTEVDVCBpbmpfZm9yY2VfZGVsYXlf cG9pbnRfYXR0YWNoKCk7CisKKwlBTFRFUiBUQUJMRSB0ZXN0X2F1dG92YWMgU0VUIChhdXRvdmFj dXVtX3BhcmFsbGVsX3dvcmtlcnMgPSAxLCBhdXRvdmFjdXVtX2VuYWJsZWQgPSB0cnVlKTsKK30p OworCisjIFdhaXQgdW50aWwgcGFyYWxsZWwgYXV0b3ZhY3V1bSBsZWFkZXIgbGF1bmNoZXMgcGFy YWxsZWwgd29ya2VyIGFuZCBmYWxscworIyBhc2xlZXAgb24gdGhlIGluamVjdGlvbiBwb2ludAor JG5vZGUtPndhaXRfZm9yX2V2ZW50KAorCSdhdXRvdmFjdXVtIHdvcmtlcicsCisJJ2F1dG92YWN1 dW0tbGVhZGVyLWJlZm9yZS1pbmRleGVzLXByb2Nlc3NpbmcnCispOworCisjIFJlbG9hZCBjb25m aWcgLSBsZWFkZXIgd29ya2VyIG11c3QgdXBkYXRlIGl0cyBvd24gcGFyYW1ldGVycyBkdXJpbmcg aW5kZXhlcworIyBwcm9jZXNzaW5nCiskbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFxewor CUFMVEVSIFNZU1RFTSBTRVQgdmFjdXVtX2Nvc3RfbGltaXQgPSA1MDA7CisJQUxURVIgU1lTVEVN IFNFVCB2YWN1dW1fY29zdF9wYWdlX21pc3MgPSAxMDsKKwlBTFRFUiBTWVNURU0gU0VUIHZhY3V1 bV9jb3N0X3BhZ2VfZGlydHkgPSAxMDsKKwlBTFRFUiBTWVNURU0gU0VUIHZhY3V1bV9jb3N0X3Bh Z2VfaGl0ID0gMTA7CisJU0VMRUNUIHBnX3JlbG9hZF9jb25mKCk7Cit9KTsKKworJG5vZGUtPnNh ZmVfcHNxbCgncG9zdGdyZXMnLCBxcXsKKwlTRUxFQ1QgaW5qZWN0aW9uX3BvaW50c193YWtldXAo J2F1dG92YWN1dW0tbGVhZGVyLWJlZm9yZS1pbmRleGVzLXByb2Nlc3NpbmcnKTsKK30pOworCisj IFdhaXQgdW50aWwgbGVhZGVyIHdvcmtlciBpcyBndWFyYW50ZWVkIHRvIHVwZGF0ZSBwYXJhbWV0 ZXJzIGFuZCBwcm9wYWdhdGUKKyMgdGhlaXIgdmFsdWVzIHRvIHRoZSBwYXJhbGxlbCB3b3JrZXIK KyRub2RlLT53YWl0X2Zvcl9ldmVudCgKKwknYXV0b3ZhY3V1bSB3b3JrZXInLAorCSdhdXRvdmFj dXVtLWxlYWRlci1hZnRlci1pbmRleGVzLXByb2Nlc3NpbmcnCispOworCiskbm9kZS0+c2FmZV9w c3FsKCdwb3N0Z3JlcycsIHFxeworCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX3dha2V1cCgnYXV0 b3ZhY3V1bS1sZWFkZXItYWZ0ZXItaW5kZXhlcy1wcm9jZXNzaW5nJyk7Cit9KTsKKworIyBOb3cg d2FrZSB1cCB0aGUgcGFyYWxsZWwgd29ya2VyIGFuZCBmb3JjZSBpdCB0byBjYWxsIHZhY3V1bV9k ZWxheV9wb2ludAorJG5vZGUtPndhaXRfZm9yX2V2ZW50KAorCSdwYXJhbGxlbCB3b3JrZXInLAor CSdwYXJhbGxlbC13b3JrZXItYmVmb3JlLWluZGV4ZXMtcHJvY2Vzc2luZycKKyk7CisKKyRub2Rl LT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgcXF7CisJU0VMRUNUIGluamVjdGlvbl9wb2ludHNfd2Fr ZXVwKCdwYXJhbGxlbC13b3JrZXItYmVmb3JlLWluZGV4ZXMtcHJvY2Vzc2luZycpOworfSk7CisK KyMgQ2hlY2sgd2hldGhlciB3b3JrZXIgc3VjY2Vzc2Z1bGx5IHVwZGF0ZWQgYWxsIHBhcmFtZXRl cnMKK3dhaXRfZm9yX2F2X2xvZygkbm9kZSwKKwkJCQlxci9WYWN1dW0gY29zdC1iYXNlZCBkZWxh eSBwYXJhbWV0ZXJzIG9mIHBhcmFsbGVsIHdvcmtlcjpcbi8gLgorCQkJCXFyL1x0dmFjdXVtX2Nv c3RfbGltaXQgPSA1MDBcbi8gLgorCQkJCXFyL1x0dmFjdXVtX2Nvc3RfZGVsYXkgPSAyXG4vIC4K KwkJCQlxci9cdHZhY3V1bV9jb3N0X3BhZ2VfbWlzcyA9IDEwXG4vIC4KKwkJCQlxci9cdHZhY3V1 bV9jb3N0X3BhZ2VfZGlydHkgPSAxMFxuLyAuCisJCQkJcXIvXHR2YWN1dW1fY29zdF9wYWdlX2hp dCA9IDEwXG4vKTsKKworIyBDbGVhbnVwCiskbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFx eworCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX2RldGFjaCgnYXV0b3ZhY3V1bS1sZWFkZXItYmVm b3JlLWluZGV4ZXMtcHJvY2Vzc2luZycpOworCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX2RldGFj aCgnYXV0b3ZhY3V1bS1sZWFkZXItYWZ0ZXItaW5kZXhlcy1wcm9jZXNzaW5nJyk7CisJU0VMRUNU IGluamVjdGlvbl9wb2ludHNfZGV0YWNoKCdwYXJhbGxlbC13b3JrZXItYmVmb3JlLWluZGV4ZXMt cHJvY2Vzc2luZycpOworCVNFTEVDVCBpbmpfZm9yY2VfZGVsYXlfcG9pbnRfZGV0YWNoKCk7CisK KwlBTFRFUiBUQUJMRSB0ZXN0X2F1dG92YWMgU0VUIChhdXRvdmFjdXVtX3BhcmFsbGVsX3dvcmtl cnMgPSAkYXV0b3ZhY3V1bV9wYXJhbGxlbF93b3JrZXJzKTsKK30pOworCisKKyMgVGVzdCAzOgor IyBUZXN0IGFkanVzdG1lbnQgb2YgZnJlZSBwYXJhbGxlbCB3b3JrZXJzIG51bWJlciB3aGVuIGNo YW5naW5nCisjIGF1dG92YWN1dW1fbWF4X3BhcmFsbGVsX3dvcmtlcnMgcGFyYW1ldGVyCisKK3By ZXBhcmVfZm9yX25leHRfdGVzdCgkbm9kZSwgNCk7CisKKyRub2RlLT5zYWZlX3BzcWwoJ3Bvc3Rn cmVzJywgcXF7CisJU0VMRUNUIGluamVjdGlvbl9wb2ludHNfYXR0YWNoKCdhdXRvdmFjdXVtLWxl YWRlci1iZWZvcmUtaW5kZXhlcy1wcm9jZXNzaW5nJywgJ3dhaXQnKTsKKwlBTFRFUiBUQUJMRSB0 ZXN0X2F1dG92YWMgU0VUIChhdXRvdmFjdXVtX2VuYWJsZWQgPSB0cnVlKTsKK30pOworCiskbm9k ZS0+d2FpdF9mb3JfZXZlbnQoCisJJ2F1dG92YWN1dW0gd29ya2VyJywKKwknYXV0b3ZhY3V1bS1s ZWFkZXItYmVmb3JlLWluZGV4ZXMtcHJvY2Vzc2luZycKKyk7CisKKyRub2RlLT5zYWZlX3BzcWwo J3Bvc3RncmVzJywgcXF7CisJQUxURVIgU1lTVEVNIFNFVCBhdXRvdmFjdXVtX21heF9wYXJhbGxl bF93b3JrZXJzID0gMTA7CisJU0VMRUNUIHBnX3JlbG9hZF9jb25mKCk7Cit9KTsKKworJG5vZGUt PnNhZmVfcHNxbCgncG9zdGdyZXMnLCBxcXsKKwlTRUxFQ1QgaW5qZWN0aW9uX3BvaW50c193YWtl dXAoJ2F1dG92YWN1dW0tbGVhZGVyLWJlZm9yZS1pbmRleGVzLXByb2Nlc3NpbmcnKTsKK30pOwor CisjIFdhaXQgdW50aWwgdGhlIGVuZCBvZiBwYXJhbGxlbCBwcm9jZXNzaW5nCit3YWl0X2Zvcl9h dl9sb2coJG5vZGUsCisJCQkJcXIvcGFyYWxsZWwgaW5kZXggdmFjdXVtXC9jbGVhbnVwOiAyIHdv cmtlcnMgd2VyZSBwbGFubmVkIC8gLgorCQkJCXFyL2FuZCAyIHdvcmtlcnMgd2VyZSBsYXVuY2hl ZCBpbiB0b3RhbC8pOworCisjIFdoZW4gYWxsIHBhcmFsbGVsIHdvcmtlcnMgd2VyZSByZWxlYXNl ZCwgdGhlIG51bWJlciBvZiBmcmVlIHBhcmFsbGVsIHdvcmtlcnMKKyMgbXVzdCBub3QgZXhjZWVk IGF1dG92YWN1dW1fbWF4X3BhcmFsbGVsX3dvcmtlcnMgbGltaXQKKyRub2RlLT5wc3FsKCdwb3N0 Z3JlcycsCisJIlNFTEVDVCBnZXRfcGFyYWxsZWxfYXV0b3ZhY3V1bV9mcmVlX3dvcmtlcnMoKTsi LAorCXN0ZG91dCA9PiBcJHBzcWxfb3V0LAorKTsKK2lzKCRwc3FsX291dCwgMTAsCisJJ051bWJl ciBvZiBmcmVlIHBhcmFsbGVsIHdvcmtlcnMgaXMgY29uc2lzdGVudCcpOworCisjIENsZWFudXAK KyRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgcXF7CisJU0VMRUNUIGluamVjdGlvbl9wb2lu dHNfZGV0YWNoKCdhdXRvdmFjdXVtLWxlYWRlci1iZWZvcmUtaW5kZXhlcy1wcm9jZXNzaW5nJyk7 Cit9KTsKKworIyBUZXN0IDQ6CisjIFdlIHdhbnQgcGFyYWxsZWwgYXV0b3ZhY3V1bSB3b3JrZXJz IHRvIGJlIHJlbGVhc2VkIGV2ZW4gaWYgbGVhZGVyIGdldHMgYW4KKyMgZXJyb3IuIEF0IGZpcnN0 LCBzaW11bGF0ZSBzaXR1YXRpb24sIHdoZW4gbGVhZGVyIGV4aXRlcyBkdWUgdG8gYW4gRVJST1Iu CisKK3ByZXBhcmVfZm9yX25leHRfdGVzdCgkbm9kZSwgNCk7CisKKyRub2RlLT5zYWZlX3BzcWwo J3Bvc3RncmVzJywgcXF7CisJU0VMRUNUIGluamVjdGlvbl9wb2ludHNfYXR0YWNoKCdhdXRvdmFj dXVtLWxlYWRlci1iZWZvcmUtaW5kZXhlcy1wcm9jZXNzaW5nJywgJ2Vycm9yJyk7CisJQUxURVIg VEFCTEUgdGVzdF9hdXRvdmFjIFNFVCAoYXV0b3ZhY3V1bV9lbmFibGVkID0gdHJ1ZSk7Cit9KTsK Kword2FpdF9mb3JfYXZfbG9nKCRub2RlLAorCQkJCXFyL2Vycm9yIHRyaWdnZXJlZCBmb3IgaW5q ZWN0aW9uIHBvaW50IC8gLgorCQkJCXFyL2F1dG92YWN1dW0tbGVhZGVyLWJlZm9yZS1pbmRleGVz LXByb2Nlc3NpbmcvKTsKKworJG5vZGUtPnBzcWwoJ3Bvc3RncmVzJywKKwkiU0VMRUNUIGdldF9w YXJhbGxlbF9hdXRvdmFjdXVtX2ZyZWVfd29ya2VycygpOyIsCisJc3Rkb3V0ID0+IFwkcHNxbF9v dXQsCispOworaXMoJHBzcWxfb3V0LCAxMCwKKyAgICdBbGwgcGFyYWxsZWwgd29ya2VycyBoYXMg YmVlbiByZWxlYXNlZCBieSB0aGUgbGVhZGVyIGFmdGVyIEVSUk9SJyk7CisKKyMgQ2xlYW51cAor JG5vZGUtPnNhZmVfcHNxbCgncG9zdGdyZXMnLCBxcXsKKwlTRUxFQ1QgaW5qZWN0aW9uX3BvaW50 c19kZXRhY2goJ2F1dG92YWN1dW0tbGVhZGVyLWJlZm9yZS1pbmRleGVzLXByb2Nlc3NpbmcnKTsK K30pOworCisjIFRlc3QgNToKKyMgU2FtZSBhcyBhYm92ZSB0ZXN0LCBidXQgc2ltdWxhdGUgc2l0 dWF0aW9uLCB3aGVuIGxlYWRlciBleGl0ZXMgZHVlIHRvIEZBVEFMLgorCitwcmVwYXJlX2Zvcl9u ZXh0X3Rlc3QoJG5vZGUsIDUpOworCiskbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFxewor CVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX2F0dGFjaCgnYXV0b3ZhY3V1bS1sZWFkZXItYmVmb3Jl LWluZGV4ZXMtcHJvY2Vzc2luZycsICd3YWl0Jyk7CisJQUxURVIgVEFCTEUgdGVzdF9hdXRvdmFj IFNFVCAoYXV0b3ZhY3V1bV9lbmFibGVkID0gdHJ1ZSk7Cit9KTsKKworJG5vZGUtPndhaXRfZm9y X2V2ZW50KAorCSdhdXRvdmFjdXVtIHdvcmtlcicsCisJJ2F1dG92YWN1dW0tbGVhZGVyLWJlZm9y ZS1pbmRleGVzLXByb2Nlc3NpbmcnCispOworCitteSAkYXZfcGlkID0gJG5vZGUtPnNhZmVfcHNx bCgncG9zdGdyZXMnLCBxcXsKKwlTRUxFQ1QgcGlkIEZST00gcGdfc3RhdF9hY3Rpdml0eQorCVdI RVJFIGJhY2tlbmRfdHlwZSA9ICdhdXRvdmFjdXVtIHdvcmtlcicKKwkgIEFORCB3YWl0X2V2ZW50 ID0gJ2F1dG92YWN1dW0tbGVhZGVyLWJlZm9yZS1pbmRleGVzLXByb2Nlc3NpbmcnCisJTElNSVQg MTsKK30pOworCisjIENyZWF0ZSByb2xlIHdpdGggcGdfc2lnbmFsX2F1dG92YWN1dW1fd29ya2Vy IGZvciB0ZXJtaW5hdGluZyBhdXRvdmFjdXVtIHdvcmtlci4KKyRub2RlLT5zYWZlX3BzcWwoJ3Bv c3RncmVzJywgcXF7CisJQ1JFQVRFIFJPTEUgcmVncmVzc193b3JrZXJfcm9sZTsKKwlHUkFOVCBw Z19zaWduYWxfYXV0b3ZhY3V1bV93b3JrZXIgVE8gcmVncmVzc193b3JrZXJfcm9sZTsKKwlTRVQg Uk9MRSByZWdyZXNzX3dvcmtlcl9yb2xlOworfSk7CisKKyRub2RlLT5zYWZlX3BzcWwoJ3Bvc3Rn cmVzJywgcXF7CisJU0VMRUNUIHBnX3Rlcm1pbmF0ZV9iYWNrZW5kKCckYXZfcGlkJyk7Cit9KTsK Kword2FpdF9mb3JfYXZfbG9nKCRub2RlLAorCQkJCXFyL3Rlcm1pbmF0aW5nIGF1dG92YWN1dW0g cHJvY2VzcyBkdWUgdG8gYWRtaW5pc3RyYXRvciBjb21tYW5kLyk7CisKKyRub2RlLT5wc3FsKCdw b3N0Z3JlcycsCisJIlNFTEVDVCBnZXRfcGFyYWxsZWxfYXV0b3ZhY3V1bV9mcmVlX3dvcmtlcnMo KTsiLAorCXN0ZG91dCA9PiBcJHBzcWxfb3V0LAorKTsKK2lzKCRwc3FsX291dCwgMTAsCisJJ0Fs bCBwYXJhbGxlbCB3b3JrZXJzIGhhcyBiZWVuIHJlbGVhc2VkIGJ5IHRoZSBsZWFkZXIgYWZ0ZXIg RkFUQUwnKTsKKworIyBDbGVhbnVwCiskbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFxewor CVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX2RldGFjaCgnYXV0b3ZhY3V1bS1sZWFkZXItYmVmb3Jl LWluZGV4ZXMtcHJvY2Vzc2luZycpOworfSk7CisKKyRub2RlLT5zdG9wOworZG9uZV90ZXN0aW5n KCk7CmRpZmYgLS1naXQgYS9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYXV0b3ZhY3V1bS90ZXN0X2F1 dG92YWN1dW0tLTEuMC5zcWwgYi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYXV0b3ZhY3V1bS90ZXN0 X2F1dG92YWN1dW0tLTEuMC5zcWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAuLjY3OTM3NWZjODJmCi0tLSAvZGV2L251bGwKKysrIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0 X2F1dG92YWN1dW0vdGVzdF9hdXRvdmFjdXVtLS0xLjAuc3FsCkBAIC0wLDAgKzEsMjAgQEAKKy8q IHNyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVtL3Rlc3RfYXV0b3ZhY3V1bS0tMS4wLnNx bCAqLworCistLSBjb21wbGFpbiBpZiBzY3JpcHQgaXMgc291cmNlZCBpbiBwc3FsLCByYXRoZXIg dGhhbiB2aWEgQ1JFQVRFIEVYVEVOU0lPTgorXGVjaG8gVXNlICJDUkVBVEUgRVhURU5TSU9OIHRl c3RfYXV0b3ZhY3V1bSIgdG8gbG9hZCB0aGlzIGZpbGUuIFxxdWl0CisKKy8qCisgKiBGdW5jdGlv bnMgZm9yIGV4cGVjdGluZyBzaGFyZWQgYXV0b3ZhY3V1bSBzdGF0ZQorICovCisKK0NSRUFURSBG VU5DVElPTiBnZXRfcGFyYWxsZWxfYXV0b3ZhY3V1bV9mcmVlX3dvcmtlcnMoKQorUkVUVVJOUyBJ TlRFR0VSIFNUUklDVAorQVMgJ01PRFVMRV9QQVRITkFNRScgTEFOR1VBR0UgQzsKKworQ1JFQVRF IEZVTkNUSU9OIGlual9mb3JjZV9kZWxheV9wb2ludF9hdHRhY2goKQorUkVUVVJOUyBWT0lEIFNU UklDVAorQVMgJ01PRFVMRV9QQVRITkFNRScgTEFOR1VBR0UgQzsKKworQ1JFQVRFIEZVTkNUSU9O IGlual9mb3JjZV9kZWxheV9wb2ludF9kZXRhY2goKQorUkVUVVJOUyBWT0lEIFNUUklDVAorQVMg J01PRFVMRV9QQVRITkFNRScgTEFOR1VBR0UgQzsKZGlmZiAtLWdpdCBhL3NyYy90ZXN0L21vZHVs ZXMvdGVzdF9hdXRvdmFjdXVtL3Rlc3RfYXV0b3ZhY3V1bS5jIGIvc3JjL3Rlc3QvbW9kdWxlcy90 ZXN0X2F1dG92YWN1dW0vdGVzdF9hdXRvdmFjdXVtLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAuLjQ1MDUwOTI0ZjE3Ci0tLSAvZGV2L251bGwKKysrIGIvc3JjL3Rlc3Qv bW9kdWxlcy90ZXN0X2F1dG92YWN1dW0vdGVzdF9hdXRvdmFjdXVtLmMKQEAgLTAsMCArMSwxNjYg QEAKKy8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICoKKyAqIHRlc3RfYXV0b3ZhY3V1bS5jCisgKgkJSGVs cGVycyB0byB3cml0ZSB0ZXN0cyBmb3IgcGFyYWxsZWwgYXV0b3ZhY3V1bQorICoKKyAqIENvcHly aWdodCAoYykgMjAyMC0yMDI1LCBQb3N0Z3JlU1FMIEdsb2JhbCBEZXZlbG9wbWVudCBHcm91cAor ICoKKyAqIElERU5USUZJQ0FUSU9OCisgKgkgIHNyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFj dXVtL3Rlc3RfYXV0b3ZhY3V1bS5jCisgKgorICotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgKi8KKworI2lu Y2x1ZGUgInBvc3RncmVzLmgiCisKKyNpbmNsdWRlICJjb21tYW5kcy92YWN1dW0uaCIKKyNpbmNs dWRlICJmbWdyLmgiCisjaW5jbHVkZSAibWlzY2FkbWluLmgiCisjaW5jbHVkZSAicG9zdG1hc3Rl ci9hdXRvdmFjdXVtLmgiCisjaW5jbHVkZSAic3RvcmFnZS9zaG1lbS5oIgorI2luY2x1ZGUgInN0 b3JhZ2UvaXBjLmgiCisjaW5jbHVkZSAic3RvcmFnZS9sd2xvY2suaCIKKyNpbmNsdWRlICJ1dGls cy9idWlsdGlucy5oIgorI2luY2x1ZGUgInV0aWxzL2luamVjdGlvbl9wb2ludC5oIgorCitQR19N T0RVTEVfTUFHSUM7CisKK3R5cGVkZWYgc3RydWN0IElualBvaW50U3RhdGUKK3sKKwlib29sCQll bmFibGVkX2ZvcmNlX2RlbGF5X3BvaW50OworfQkJCUlualBvaW50U3RhdGU7CisKK3N0YXRpYyBJ bmpQb2ludFN0YXRlICogaW5qX3BvaW50X3N0YXRlOworCisvKiBTaGFyZWQgbWVtb3J5IGluaXQg Y2FsbGJhY2tzICovCitzdGF0aWMgc2htZW1fcmVxdWVzdF9ob29rX3R5cGUgcHJldl9zaG1lbV9y ZXF1ZXN0X2hvb2sgPSBOVUxMOworc3RhdGljIHNobWVtX3N0YXJ0dXBfaG9va190eXBlIHByZXZf c2htZW1fc3RhcnR1cF9ob29rID0gTlVMTDsKKworc3RhdGljIHZvaWQKK3Rlc3RfYXV0b3ZhY3V1 bV9zaG1lbV9yZXF1ZXN0KHZvaWQpCit7CisJaWYgKHByZXZfc2htZW1fcmVxdWVzdF9ob29rKQor CQlwcmV2X3NobWVtX3JlcXVlc3RfaG9vaygpOworCisJUmVxdWVzdEFkZGluU2htZW1TcGFjZShz aXplb2YoSW5qUG9pbnRTdGF0ZSkpOworfQorCitzdGF0aWMgdm9pZAordGVzdF9hdXRvdmFjdXVt X3NobWVtX3N0YXJ0dXAodm9pZCkKK3sKKwlib29sCQlmb3VuZDsKKworCWlmIChwcmV2X3NobWVt X3N0YXJ0dXBfaG9vaykKKwkJcHJldl9zaG1lbV9zdGFydHVwX2hvb2soKTsKKworCS8qIENyZWF0 ZSBvciBhdHRhY2ggdG8gdGhlIHNoYXJlZCBtZW1vcnkgc3RhdGUgKi8KKwlMV0xvY2tBY3F1aXJl KEFkZGluU2htZW1Jbml0TG9jaywgTFdfRVhDTFVTSVZFKTsKKworCWlual9wb2ludF9zdGF0ZSA9 IFNobWVtSW5pdFN0cnVjdCgiaW5qZWN0aW9uX3BvaW50cyIsCisJCQkJCQkJCQkgIHNpemVvZihJ bmpQb2ludFN0YXRlKSwKKwkJCQkJCQkJCSAgJmZvdW5kKTsKKworCWlmICghZm91bmQpCisJewor CQkvKiBGaXJzdCB0aW1lIHRocm91Z2gsIGluaXRpYWxpemUgKi8KKwkJaW5qX3BvaW50X3N0YXRl LT5lbmFibGVkX2ZvcmNlX2RlbGF5X3BvaW50ID0gZmFsc2U7CisKKwkJSW5qZWN0aW9uUG9pbnRB dHRhY2goInBhcmFsbGVsLWF1dG92YWN1dW0tZm9yY2UtZGVsYXktcG9pbnQiLAorCQkJCQkJCSAi dGVzdF9hdXRvdmFjdXVtIiwKKwkJCQkJCQkgImlual9mb3JjZV9kZWxheV9wb2ludCIsCisJCQkJ CQkJIE5VTEwsCisJCQkJCQkJIDApOworCX0KKworCUxXTG9ja1JlbGVhc2UoQWRkaW5TaG1lbUlu aXRMb2NrKTsKK30KKwordm9pZAorX1BHX2luaXQodm9pZCkKK3sKKwlpZiAoIXByb2Nlc3Nfc2hh cmVkX3ByZWxvYWRfbGlicmFyaWVzX2luX3Byb2dyZXNzKQorCQlyZXR1cm47CisKKwlwcmV2X3No bWVtX3JlcXVlc3RfaG9vayA9IHNobWVtX3JlcXVlc3RfaG9vazsKKwlzaG1lbV9yZXF1ZXN0X2hv b2sgPSB0ZXN0X2F1dG92YWN1dW1fc2htZW1fcmVxdWVzdDsKKwlwcmV2X3NobWVtX3N0YXJ0dXBf aG9vayA9IHNobWVtX3N0YXJ0dXBfaG9vazsKKwlzaG1lbV9zdGFydHVwX2hvb2sgPSB0ZXN0X2F1 dG92YWN1dW1fc2htZW1fc3RhcnR1cDsKK30KKworZXh0ZXJuIFBHRExMRVhQT1JUIHZvaWQgaW5q X2ZvcmNlX2RlbGF5X3BvaW50KGNvbnN0IGNoYXIgKm5hbWUsCisJCQkJCQkJCQkJCSAgY29uc3Qg dm9pZCAqcHJpdmF0ZV9kYXRhLAorCQkJCQkJCQkJCQkgIHZvaWQgKmFyZyk7CisKKworUEdfRlVO Q1RJT05fSU5GT19WMShnZXRfcGFyYWxsZWxfYXV0b3ZhY3V1bV9mcmVlX3dvcmtlcnMpOworRGF0 dW0KK2dldF9wYXJhbGxlbF9hdXRvdmFjdXVtX2ZyZWVfd29ya2VycyhQR19GVU5DVElPTl9BUkdT KQoreworCXVpbnQzMgkJbmZyZWVfd29ya2VyczsKKworI2lmbmRlZiBVU0VfSU5KRUNUSU9OX1BP SU5UUworCWVyZXBvcnQoRVJST1IsIGVycm1zZygiaW5qZWN0aW9uIHBvaW50cyBub3Qgc3VwcG9y dGVkIikpOworI2VuZGlmCisKKwluZnJlZV93b3JrZXJzID0gQXV0b1ZhY3V1bUdldEZyZWVQYXJh bGxlbFdvcmtlcnMoKTsKKworCVBHX1JFVFVSTl9VSU5UMzIobmZyZWVfd29ya2Vycyk7Cit9CisK Ky8qCisgKi8KK3ZvaWQKK2lual9mb3JjZV9kZWxheV9wb2ludChjb25zdCBjaGFyICpuYW1lLCBj b25zdCB2b2lkICpwcml2YXRlX2RhdGEsIHZvaWQgKmFyZykKK3sKKwllcmVwb3J0KExPRywKKwkJ CWVycm1zZygiZm9yY2UgZGVsYXkgcG9pbnQgaW5qZWN0aW9uIHBvaW50IGNhbGxlZCIpLAorCQkJ ZXJyaGlkZXN0bXQodHJ1ZSksIGVycmhpZGVjb250ZXh0KHRydWUpKTsKKworCWlmIChpbmpfcG9p bnRfc3RhdGUtPmVuYWJsZWRfZm9yY2VfZGVsYXlfcG9pbnQpCisJeworCQlTdHJpbmdJbmZvRGF0 YSBidWY7CisKKwkJQXNzZXJ0KElzUGFyYWxsZWxXb3JrZXIoKSAmJiAhQW1BdXRvVmFjdXVtV29y a2VyUHJvY2VzcygpKTsKKworCQkvKiBTaW11bGF0ZSBjb25maWcgcmVsb2FkIGR1cmluZyBub3Jt YWwgcHJvY2Vzc2luZyAqLworCQlwZ19hdG9taWNfYWRkX2ZldGNoX3UzMihWYWN1dW1BY3RpdmVO V29ya2VycywgMSk7CisJCXZhY3V1bV9kZWxheV9wb2ludChmYWxzZSk7CisJCXBnX2F0b21pY19z dWJfZmV0Y2hfdTMyKFZhY3V1bUFjdGl2ZU5Xb3JrZXJzLCAxKTsKKworCQlpbml0U3RyaW5nSW5m bygmYnVmKTsKKworCQlhcHBlbmRTdHJpbmdJbmZvKCZidWYsICJWYWN1dW0gY29zdC1iYXNlZCBk ZWxheSBwYXJhbWV0ZXJzIG9mIHBhcmFsbGVsIHdvcmtlcjpcbiIpOworCQlhcHBlbmRTdHJpbmdJ bmZvKCZidWYsICJ2YWN1dW1fY29zdF9saW1pdCA9ICVkXG4iLCB2YWN1dW1fY29zdF9saW1pdCk7 CisJCWFwcGVuZFN0cmluZ0luZm8oJmJ1ZiwgInZhY3V1bV9jb3N0X2RlbGF5ID0gJWdcbiIsIHZh Y3V1bV9jb3N0X2RlbGF5KTsKKwkJYXBwZW5kU3RyaW5nSW5mbygmYnVmLCAidmFjdXVtX2Nvc3Rf cGFnZV9taXNzID0gJWRcbiIsIFZhY3V1bUNvc3RQYWdlTWlzcyk7CisJCWFwcGVuZFN0cmluZ0lu Zm8oJmJ1ZiwgInZhY3V1bV9jb3N0X3BhZ2VfZGlydHkgPSAlZFxuIiwgVmFjdXVtQ29zdFBhZ2VE aXJ0eSk7CisJCWFwcGVuZFN0cmluZ0luZm8oJmJ1ZiwgInZhY3V1bV9jb3N0X3BhZ2VfaGl0ID0g JWRcbiIsIFZhY3V1bUNvc3RQYWdlSGl0KTsKKworCQllcmVwb3J0KExPRywgZXJybXNnKCIlcyIs IGJ1Zi5kYXRhKSk7CisJCXBmcmVlKGJ1Zi5kYXRhKTsKKwl9Cit9CisKK1BHX0ZVTkNUSU9OX0lO Rk9fVjEoaW5qX2ZvcmNlX2RlbGF5X3BvaW50X2F0dGFjaCk7CitEYXR1bQoraW5qX2ZvcmNlX2Rl bGF5X3BvaW50X2F0dGFjaChQR19GVU5DVElPTl9BUkdTKQoreworI2lmZGVmIFVTRV9JTkpFQ1RJ T05fUE9JTlRTCisJaW5qX3BvaW50X3N0YXRlLT5lbmFibGVkX2ZvcmNlX2RlbGF5X3BvaW50ID0g dHJ1ZTsKKyNlbHNlCisJZXJlcG9ydChFUlJPUiwgZXJybXNnKCJpbmplY3Rpb24gcG9pbnRzIG5v dCBzdXBwb3J0ZWQiKSk7CisjZW5kaWYKKwlQR19SRVRVUk5fVk9JRCgpOworfQorCitQR19GVU5D VElPTl9JTkZPX1YxKGlual9mb3JjZV9kZWxheV9wb2ludF9kZXRhY2gpOworRGF0dW0KK2lual9m b3JjZV9kZWxheV9wb2ludF9kZXRhY2goUEdfRlVOQ1RJT05fQVJHUykKK3sKKyNpZmRlZiBVU0Vf SU5KRUNUSU9OX1BPSU5UUworCWlual9wb2ludF9zdGF0ZS0+ZW5hYmxlZF9mb3JjZV9kZWxheV9w b2ludCA9IGZhbHNlOworI2Vsc2UKKwllcmVwb3J0KEVSUk9SLCBlcnJtc2coImluamVjdGlvbiBw b2ludHMgbm90IHN1cHBvcnRlZCIpKTsKKyNlbmRpZgorCVBHX1JFVFVSTl9WT0lEKCk7Cit9CmRp ZmYgLS1naXQgYS9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYXV0b3ZhY3V1bS90ZXN0X2F1dG92YWN1 dW0uY29udHJvbCBiL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVtL3Rlc3RfYXV0b3Zh Y3V1bS5jb250cm9sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi4xYjdm YWQyNThmMAotLS0gL2Rldi9udWxsCisrKyBiL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFj dXVtL3Rlc3RfYXV0b3ZhY3V1bS5jb250cm9sCkBAIC0wLDAgKzEsMyBAQAorY29tbWVudCA9ICdU ZXN0IGNvZGUgZm9yIHBhcmFsbGVsIGF1dG92YWN1dW0nCitkZWZhdWx0X3ZlcnNpb24gPSAnMS4w JworbW9kdWxlX3BhdGhuYW1lID0gJyRsaWJkaXIvdGVzdF9hdXRvdmFjdXVtJwotLSAKMi40My4w Cgo= --0000000000009cbd1f064881e9cc--