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 1vh7fX-009xjV-2Z for pgsql-hackers@arkaria.postgresql.org; Sat, 17 Jan 2026 14:52:52 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1vh7fW-008Vv2-2u for pgsql-hackers@arkaria.postgresql.org; Sat, 17 Jan 2026 14:52:51 +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 1vh7fW-008Vug-0Y for pgsql-hackers@lists.postgresql.org; Sat, 17 Jan 2026 14:52:50 +0000 Received: from mail-yx1-xb12b.google.com ([2607:f8b0:4864:20::b12b]) 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 1vh7fQ-000w12-1c for pgsql-hackers@lists.postgresql.org; Sat, 17 Jan 2026 14:52:49 +0000 Received: by mail-yx1-xb12b.google.com with SMTP id 956f58d0204a3-64760131fc1so2552486d50.2 for ; Sat, 17 Jan 2026 06:52:45 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1768661564; cv=none; d=google.com; s=arc-20240605; b=iws2l4e40NKKceNoaXf0Y1qIhGBGMPedmhQREhiDjduPll5HBdxQaAJuHvQDf0tyN3 69tYP+sSJDwKGLKgEpKKQp9g2LccydorgZSaSjMCV4HUTHykPzfPvw0k56uLZMQ3nYOA sg3fdS/J19KzGYIUEAKuqkQ3jsgAUQjSRy+cjiR3aHd27sYg64Aod65xZFiHCpLxWnh6 jCf/9lVPLH3OPNjIJtv9eJ0/Nyf33bGdW7QxezXDH2HlMjx1xBLjYQ++Ubc8RmXj1x4l LuhfkMXdjmt+jlFyVSwLn8FjTLTHni5MwdWxG5rsxE3+ImlMjb8iKGLzTLmROqYhArQ3 CMCg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20240605; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:dkim-signature; bh=U+EidPceUKpdZ1yIVj+CdWZn5ED9E+VPLePn4axJvUo=; fh=TV0ncZsEgIIST9Gq7DNHseCE+WCtbPyKLVBzJkCi8Jk=; b=hvlyiHOMHxchxzGsYCCoq361SdugNGWsc/Dv9zEIEkSOoHzWcHQrbJTDQH2b2UYe4m DdlZ9ZkcvZ6wfIF3vYDoOT4C05IjqpmIxDCgQe9VgEAcayCj/uUWhECYT47diWC0T9am xPBp0HvkYsx3K9BWJ8PAoBnX++judRz2LkZBthcHqCJJ81MtTQb1gMdn77qY8Uc47Rs7 gOdCnBacXUjT5rsmkvv9uHuUDK/9a3tzRuB5LYtN7j0BlK265QCyfK3cAuYpru1RMhoc b1+K7e+ysrhKhwIYCEC8kEzRuQR/PcdXHdwDqzvGbZwiSeFkcpoyUQaKKPffKJidLPoG fiIw==; darn=lists.postgresql.org ARC-Authentication-Results: i=1; mx.google.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1768661564; x=1769266364; 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=U+EidPceUKpdZ1yIVj+CdWZn5ED9E+VPLePn4axJvUo=; b=OyFP1QH2Stsu+YXFikJbw2CfHycxRzKk4ok1JFDC/cCiuBrgfLJ1W0SwyFEqoVSotr YEjp5mLWgznGtCzNWigHrMeeWFzcCluYTtdYCVbHPBoJ1EvuewRaMYUV9WslUAr4ANsc bptTlXZjvrWAGiJsbBZWvPRztezi2vfNcnafohohBlWF7yEyCFddJGlsWLbzZe6jw+va /ZsCf/eFRCwD82sm6cn2k6PqQ78TBJ2MaFi2ZfH2rlPtGFZe2dtAamRetVh/SScuaR7I BYp44GFvspZjZPmb+oMxgGNWhOkMx/SeAQdrHDyO5D3HnoU7r/51ffoqbJQOzw1N0+OT f+eA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1768661564; x=1769266364; 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=U+EidPceUKpdZ1yIVj+CdWZn5ED9E+VPLePn4axJvUo=; b=IHaM9G47zQyRuiVirxGJnY4SZL6b+6VZCM4yNDCahVWs9sO869+O4MXxwXN1/GaW/S TuYrkCKS3ZI5Zn/yTmXMMYVz+CieFYQVKDdqxDANexSwS20AluwhPYxYxNdSPI7KXNBa 00unpAhBmxnexp/LVU6k514KVqtJzXQ/q6REN2WCGafnhnfGU6e/czD6q4WqV4muLKDB iEyxgBf31XVCAazKBy2UQel7e88UN8O9BUBFeX+8hFGqYr2jV8tBNNo5VU0ORWZHoIah nSJpSnubFrFZ878Q7ynRTrWJ3whowuTs9PI+f39xHCALLk7u4Ws3Nagq3UOWbWiPWTre F8CQ== X-Forwarded-Encrypted: i=1; AJvYcCXM1uxkTSJrUkxV/HTPzI33VipSS+SdrQ8fHjhcya9cV89Eo6+SQgzdOleQahBgDV35GPhwQ7gLC/13CiDm@lists.postgresql.org X-Gm-Message-State: AOJu0YxZhMQRRcONDH/36Q8hY+sWx9sdcnajpuWWMARksP34Wn7f7Nek Dsrtzj4e/9gehijK9MQcJq23RaUmI6EG1BE4Qr/nk+EmwYdBTf8mPBlVDj66/+xrk0aAgBTTCii diUgir7we0o4bnQ/P6kN47xkXjIKSupU= X-Gm-Gg: AY/fxX4C5/ypIVV+tezDRjoikKd9FkbOayemD9S+Ajrqb39MOnM0s7Cp2EDOtsNbFTc GXNzYCGfXFGfJdAuRhVFk5XtnYPpvp5qTEyNe6ro5uuwCx7KpSjphAqZk8D2OEGfIfSD3Uq5lXj koGP1WpVmhlz9iCMmAjeSsKkOYeRajqe1tdy1gk8aW6dfF75xOuff9xs2ryOpfkTCD5qqh7ai+p oOmMItNveDGtg5mRChYL4r+6EQaQzG4rPVUctTzb63/3GDwkcmUrZTzuGFKStUGTYo8xOQ= X-Received: by 2002:a05:690c:4d08:b0:78f:a615:2724 with SMTP id 00721157ae682-793c53bbc89mr109046517b3.48.1768661564241; Sat, 17 Jan 2026 06:52:44 -0800 (PST) MIME-Version: 1.0 References: In-Reply-To: From: Daniil Davydov <3danissimo@gmail.com> Date: Sat, 17 Jan 2026 21:52:32 +0700 X-Gm-Features: AZwV_QgbyKeAOMzXbK8o6KEorCUswggiGMUtXvN7u8EqK9kP8r06sHtKFZ5L8ZI 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="0000000000004477530648969c39" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --0000000000004477530648969c39 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Hi, On Sat, Jan 17, 2026 at 5:20=E2=80=AFAM Masahiko Sawada wrote: > > Looking at AutoVacuumReserveParallelWorkers(), it seems that we don't > check the av_maxParallelWorkers() there. Is it possible that two more > workers would be reserved even while the existing 2 workers are > running? > > /* Provide as many workers as we can. */ > *nworkers =3D Min(AutoVacuumShmem->av_freeParallelWorkers, *nworkers); > AutoVacuumShmem->av_freeParallelWorkers -=3D *nworkers; > OK, I got it. You are right. I'll use the formula that you mentioned in the previous letter. I'll also add a test for it. > > + /* Release all the reserved parallel workers for autovacuum */ > + if (AmAutoVacuumWorkerProcess() && pvs->pcxt->nworkers_launched >= 0) > + AutoVacuumReleaseParallelWorkers(pvs->pcxt->nworkers_launched= ); > > Since we want to release all reserved workers here, I think it's clear > if we use AutoVacuumReleaseAllParallelWorkers() and we add > Assert(av_nworkers_reserved =3D=3D 0) at the end of > AutoVacuumReleaseAllParallelWorkers(). This way, we can ensure that > all workers are released and it makes the codes more readable. What do > you think? > Agree that this will be more clear for the readers. > I've attached the patch proposing this change (please find > v19-0001_masahiko.patch). Thank you, I'll apply this patch. A few things in the patch that I changed = : 1) + * The caller must call AutoVacuumReleaseParallelWorkers() to release the.= .. I think that we also should mention AutoVacuumReleaseAllParallelWorkers. 2) + * Similar to AutoVacuumReleaseParallelWorkers(), but this function releas= es... If you don't mind, I'll leave the "same as above" formulation since this is typical for the postgres code. > > +#autovacuum_max_parallel_workers =3D 2 # disabled by default and limi= ted by > + # max_worker_processes > > It's odd to me that the comment says it's disabled by default while > being set to 2. I think we can rewrite the comment to: > > +#autovacuum_max_parallel_workers =3D 2 # limited by max_worker_proces= ses > Good catch. I forgot to change this comment. > BTW it seems to me that this GUC should be capped by > max_parallel_workers instead of max_worker_processes, no? > I explained my point about it here [1] and here [2]. What do you think? > --- > + long_desc =3D> 'This parameter is capped by "max_worker_processes" > (not by "autovacuum_max_workers"!).', > > I'm concerned that this kind of description might not be appropriate > to the description in long_desc. Looking at long_desc contents of > other GUC parameters, we describe the detail of the parameters (e.g., > "0 means xxx" or detailed explanation of the effect). Probably we can > remove this line. > Agree. > > > > Previously I used the NULL value of this pointer as a flag that we don'= t need > > 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 l= og > > workers usage, because VACUUM PARALLEL can be called without VERBOSE). > > Can't we simply not report the worker usage if nplanned is 0? > > > > > As I wrote above - we don't need to log workers usage if the VERBOSE op= tion > > is not specified (even if nplanned > 0). Am I missing something? > > No. My point is that even when the VERBOSE option is specified, we can > skip reporting the worker usage if the parallel vacuum is not even > planned. That is, I think we can do like: > > if (vacrel->workers_usage.nplanned > 0) > appendStringInfo(&buf, > _("parallel index vacuum/cleanup: %d workers > were planned and %d workers were launched in total\n"), > vacrel->workers_usage.nplanned, > vacrel->workers_usage.nlaunched); > Sorry, I forgot that we accumulate the messages for logging only if "instrument =3D=3D true". It will cut off the case when manual vacuum is called without the VERBOSE option. > > Thank you for updating the patch. I think that we need the explanation > of what nlaunched and nplanned actually mean in the PVWorkersUsage > definition > > +typedef struct PVWorkersUsage > +{ > + int nlaunched; > + int nplanned; > +} PVWorkersUsage; > > I'm concerned that readers might be confused that nplanned is not the > number of parallel workers we actually planned to launch. > > Or it might make sense to track these three values: planned, reserved, > and launched. For example, suppose max_worker_processes =3D 10 and > autovacuum_max_parallel_workers =3D 5, if two autovacuum workers try to > reserve 3 workers each, one worker can reserve and launch 3 and > another worker can reserve and launch 2. The autovacuum logs would be > "3 planned and 3 launched" and "3 planned and 2 launched". Users can > deal with the shortage of parallel workers by increasing > autovacuum_max_parallel_workers. On the other hand, if some bgworkers > are being used by other components (.e.g, parallel queries, logical > replication etc.) and there are only 2 free bgworkers, the autovacuum > worker can reserve 3 but can launch only 2, and other worker can > reserve 2 but cannot launch any workers. The autovacuum logs would be > "3 planned and 2 launched" and "3 planned and 0 launched". Here > increasing autovacuum_max_parallel_workers resolves the shortage of > parallel workers, but users would have to increase > max_worker_processes instead. If we can report the worker usage like > "3 planned, 3 reserved, and 2 launched" and "3 planned, 2 reserved, > and 0 launched", users would realize the need to increase > max_worker_processes. Of course, the "xxx reserved" information would > not be necessary for VACUUM VERBOSE logs. > Hm, I think that reporting of "nreserved" would make it easier for the user= to understand what is going on. Thanks for the detailed explanation, I'll implement it. > > > > 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. > > Why don't we add IsInParallelMode() or IsParallelWorker() check before > calling parallel_vacuum_update_shared_delay_params()? Considering your suggestion below, I will add this check. > > +bool > +parallel_vacuum_update_shared_delay_params(void) > +{ > + /* Check whether we are running parallel autovacuum */ > + if (pv_shared_cost_params =3D=3D NULL) > + return false; > + > + Assert(IsParallelWorker() && !AmAutoVacuumWorkerProcess()); > > These codes are a bit odd to me in two points: > > 1. A process can never be both a parallel worker and an autovacuum worker= . > > 2. If pv_shared_cost_parame =3D=3D NULL, even autovacuum workers and > non-parallel workers can call this function, but it seems to be > unexpected function call given the subsequent assertion. If we want to > have an assertion to ensure that a function is called only by > processes we expect or allow, I think we should add an assertion to > the beginning of function. How about rewriting these parts to: > > Assert(IsParallelWorker()); > > /* Check whether we are running parallel autovacuum */ > if (pv_shared_cost_params =3D=3D NULL) > return false; > Agree, it will be much more clear. > --- > + * Note, that this function has no effect if we are non-autovacuu= m > + * parallel worker. > + */ > > I don't think this kind of comment should be noted here since if we > change the parallel_vacuum_update_shared_delay_params() behavior in > the future, such comments would get easily out-of-sync. > If behavior will be changed, then all comments for this function will need = to be changed, actually. Don't get me wrong - I just think that this Note is important for the readers. But if you doubt its usefulness, I don't mind deleting it. > > > 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= _point. > > Obviously, this does not mean that the parameters will necessarily be u= pdated. > > > > 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= code. > > Although the parameter propagation itself is working correctly, the > current implementation seems suboptimal performance-wise. Acquiring an > additional spinlock and updating the local variables for every block > seems too costly to me. IIUC we would end up incurring these costs > even when vacuum delays are disabled. I think we need to find a better > way. > > For example, we can have a generation of these parameters. That is, > the leader increments the generation (stored in PVSharedCostParams) > whenever updating them after reloading the configuration file, and > workers maintain its generation of the parameters currently used. If > the worker's generation < the global generation, it updates its > parameters along with its generation. I think we can implement the > generation using pg_atomic_u32, making the check for parameter updates > lock-free. There might be better ideas, though. > OK, I see your point. Considering that we need to check some shared state (= in order to understand whether we should update our params), an atomic variabl= e seem to be the best solution. Thank you for the review! Please, see v20 patches. Main changes : 1) Add new formula for freeParallelWorkers computation 2) Add 'nreserved' logging for parallel autovacuum 3) Add atomic variable to speed up checking shared params state change 4) New test for autovacuum_max_parallel_workers parameter change 5) Fully get rid of "custom" injection points in tests BTW, I think that we need more fixes for documentation, so I'll take a look at it in the near future. [1] https://www.postgresql.org/message-id/CAJDiXgiYiX%2BazuR76DcVx8fZn57m_4= v6cB14-GW34mWa%3DqudFQ%40mail.gmail.com [2] https://www.postgresql.org/message-id/CAJDiXgjX%2BbO%3DdEZxpnsh588N3BsQ= %3D7MHX3YQSJS6FxqGq4zMqQ%40mail.gmail.com -- Best regards, Daniil Davydov --0000000000004477530648969c39 Content-Type: text/x-patch; charset="US-ASCII"; name="v20-0005-Documentation-for-parallel-autovacuum.patch" Content-Disposition: attachment; filename="v20-0005-Documentation-for-parallel-autovacuum.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mkifeqz00 RnJvbSA4MzEyZTJhMzVmZDA3MDg3NmY5MWU3ZTk1NTVhNDZlNmE3MWQ1NmU2IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBTdW4sIDIzIE5vdiAyMDI1IDAyOjMyOjQ0ICswNzAwClN1YmplY3Q6IFtQQVRD SCB2MjAgNS81XSBEb2N1bWVudGF0aW9uIGZvciBwYXJhbGxlbCBhdXRvdmFjdXVtCgotLS0KIGRv 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= --0000000000004477530648969c39 Content-Type: text/x-patch; charset="US-ASCII"; name="v20-0004-Tests-for-parallel-autovacuum.patch" Content-Disposition: attachment; filename="v20-0004-Tests-for-parallel-autovacuum.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mkifeqzn1 RnJvbSA0MTFkNjliNzIwNzIzMTZmMWU0OTlhNTkwMzRiN2VlZGVkOTJjZTdlIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBTdW4sIDIzIE5vdiAyMDI1IDAxOjA4OjE0ICswNzAwClN1YmplY3Q6IFtQQVRD SCB2MjAgNC81XSBUZXN0cyBmb3IgcGFyYWxsZWwgYXV0b3ZhY3V1bQoKLS0tCiBzcmMvYmFja2Vu ZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jICAgICAgICAgfCAgNjAgKysrCiBzcmMvYmFja2Vu ZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYyAgICAgICAgICAgfCAgMTkgKwogc3JjL2luY2x1ZGUv cG9zdG1hc3Rlci9hdXRvdmFjdXVtLmggICAgICAgICAgIHwgICAxICsKIHNyYy90ZXN0L21vZHVs ZXMvTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICB8ICAgMSArCiBzcmMvdGVzdC9tb2R1bGVz L21lc29uLmJ1aWxkICAgICAgICAgICAgICAgICAgfCAgIDEgKwogc3JjL3Rlc3QvbW9kdWxlcy90 ZXN0X2F1dG92YWN1dW0vLmdpdGlnbm9yZSAgIHwgICAyICsKIHNyYy90ZXN0L21vZHVsZXMvdGVz dF9hdXRvdmFjdXVtL01ha2VmaWxlICAgICB8ICAyOCArKwogc3JjL3Rlc3QvbW9kdWxlcy90ZXN0 X2F1dG92YWN1dW0vbWVzb24uYnVpbGQgIHwgIDM2ICsrCiAuLi4vbW9kdWxlcy90ZXN0X2F1dG92 YWN1dW0vdC8wMDFfYmFzaWMucGwgICAgfCAzNDYgKysrKysrKysrKysrKysrKysrCiAuLi4vdGVz dF9hdXRvdmFjdXVtL3Rlc3RfYXV0b3ZhY3V1bS0tMS4wLnNxbCAgfCAgMTIgKwogLi4uL21vZHVs ZXMvdGVzdF9hdXRvdmFjdXVtL3Rlc3RfYXV0b3ZhY3V1bS5jIHwgIDQxICsrKwogLi4uL3Rlc3Rf YXV0b3ZhY3V1bS90ZXN0X2F1dG92YWN1dW0uY29udHJvbCAgIHwgICAzICsKIDEyIGZpbGVzIGNo YW5nZWQsIDU1MCBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgc3JjL3Rlc3QvbW9k dWxlcy90ZXN0X2F1dG92YWN1dW0vLmdpdGlnbm9yZQogY3JlYXRlIG1vZGUgMTAwNjQ0IHNyYy90 ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVtL01ha2VmaWxlCiBjcmVhdGUgbW9kZSAxMDA2NDQg c3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2F1dG92YWN1dW0vbWVzb24uYnVpbGQKIGNyZWF0ZSBtb2Rl IDEwMDY0NCBzcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYXV0b3ZhY3V1bS90LzAwMV9iYXNpYy5wbAog Y3JlYXRlIG1vZGUgMTAwNjQ0IHNyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVtL3Rlc3Rf YXV0b3ZhY3V1bS0tMS4wLnNxbAogY3JlYXRlIG1vZGUgMTAwNjQ0IHNyYy90ZXN0L21vZHVsZXMv dGVzdF9hdXRvdmFjdXVtL3Rlc3RfYXV0b3ZhY3V1bS5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgc3Jj L3Rlc3QvbW9kdWxlcy90ZXN0X2F1dG92YWN1dW0vdGVzdF9hdXRvdmFjdXVtLmNvbnRyb2wKCmRp ZmYgLS1naXQgYS9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jIGIvc3JjL2Jh Y2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYwppbmRleCBlMzU2MTA1NzMzNC4uYmI0ZDJl ZjNiZWEgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMK KysrIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYwpAQCAtMzksNiArMzks NyBAQAogI2luY2x1ZGUgInBvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5oIgogI2luY2x1ZGUgInN0b3Jh Z2UvYnVmbWdyLmgiCiAjaW5jbHVkZSAidGNvcC90Y29wcHJvdC5oIgorI2luY2x1ZGUgInV0aWxz L2luamVjdGlvbl9wb2ludC5oIgogI2luY2x1ZGUgInV0aWxzL2xzeXNjYWNoZS5oIgogI2luY2x1 ZGUgInV0aWxzL3JlbC5oIgogCkBAIC0yODAsNiArMjgxLDcgQEAgc3RhdGljIHZvaWQgcGFyYWxs ZWxfdmFjdXVtX3Byb2Nlc3Nfb25lX2luZGV4KFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywgUmVs YXRpb24KIHN0YXRpYyBib29sIHBhcmFsbGVsX3ZhY3V1bV9pbmRleF9pc19wYXJhbGxlbF9zYWZl KFJlbGF0aW9uIGluZHJlbCwgaW50IG51bV9pbmRleF9zY2FucywKIAkJCQkJCQkJCQkJCSAgIGJv b2wgdmFjdXVtKTsKIHN0YXRpYyB2b2lkIHBhcmFsbGVsX3ZhY3V1bV9lcnJvcl9jYWxsYmFjayh2 b2lkICphcmcpOworc3RhdGljIHZvaWQgcGFyYWxsZWxfdmFjdXVtX3JlcG9ydF9jb3N0X2Jhc2Vk X3BhcmFtcyh2b2lkKTsKIAogLyoKICAqIFRyeSB0byBlbnRlciBwYXJhbGxlbCBtb2RlIGFuZCBj cmVhdGUgYSBwYXJhbGxlbCBjb250ZXh0LiAgVGhlbiBpbml0aWFsaXplCkBAIC04ODcsNiArODg5 LDE0IEBAIHBhcmFsbGVsX3ZhY3V1bV9wcm9jZXNzX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFjdXVt U3RhdGUgKnB2cywgaW50IG51bV9pbmRleF9zY2FuCiAJCQkJCQkJcHZzLT5wY3h0LT5ud29ya2Vy c19sYXVuY2hlZCwgbndvcmtlcnMpKSk7CiAJfQogCisJLyoKKwkgKiBUbyBiZSBhYmxlIHRvIGV4 ZXJjaXNlIHdoZXRoZXIgYWxsIHJlc2VydmVkIHBhcmFsbGVsIHdvcmtlcnMgYXJlIGJlaW5nCisJ ICogcmVsZWFzZWQgYW55d2F5LCBhbGxvdyBpbmplY3Rpb24gcG9pbnRzIHRvIHRyaWdnZXIgYSBm YWlsdXJlIGF0IHRoaXMKKwkgKiBwb2ludC4KKwkgKi8KKwlpZiAobndvcmtlcnMgPiAwKQorCQlJ TkpFQ1RJT05fUE9JTlQoImF1dG92YWN1dW0tbGVhZGVyLWJlZm9yZS1pbmRleGVzLXByb2Nlc3Np bmciLCBOVUxMKTsKKwogCS8qIFZhY3V1bSB0aGUgaW5kZXhlcyB0aGF0IGNhbiBiZSBwcm9jZXNz ZWQgYnkgb25seSBsZWFkZXIgcHJvY2VzcyAqLwogCXBhcmFsbGVsX3ZhY3V1bV9wcm9jZXNzX3Vu c2FmZV9pbmRleGVzKHB2cyk7CiAKQEAgLTg5Niw2ICs5MDYsMTUgQEAgcGFyYWxsZWxfdmFjdXVt X3Byb2Nlc3NfYWxsX2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLCBpbnQgbnVtX2lu ZGV4X3NjYW4KIAkgKi8KIAlwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19zYWZlX2luZGV4ZXMocHZz KTsKIAorCS8qCisJICogVG8gYmUgYWJsZSB0byBleGVyY2lzZSB3aGV0aGVyIGxlYWRlciBwYXJh bGxlbCBhdXRvdmFjdXVtIHdvcmtlciBjYW4KKwkgKiBwcm9wYWdhdGUgY29zdC1iYXNlZCBwYXJh bXMgdG8gcGFyYWxsZWwgd29ya2Vycywgd2FpdCBoZXJlIHVudGlsCisJICogY29uZmlndXJhdGlv biBpcyBjaGFuZ2VkLiBJLmUuIHRlc3RzIGFyZSBleHBlY3RpbmcsIHRoYXQgZHVyaW5nIGluZGV4 CisJICogcHJvY2Vzc2luZyB2YWN1dW1fZGVsYXlfcG9pbnQgaGF2ZSBiZWVuIGNhbGxlZCAoaWYg Y29uZmlnIHdhcyBjaGFuZ2VkKS4KKwkgKi8KKwlpZiAobndvcmtlcnMgPiAwKQorCQlJTkpFQ1RJ T05fUE9JTlQoImF1dG92YWN1dW0tbGVhZGVyLWFmdGVyLWluZGV4ZXMtcHJvY2Vzc2luZyIsIE5V TEwpOworCiAJLyoKIAkgKiBOZXh0LCBhY2N1bXVsYXRlIGJ1ZmZlciBhbmQgV0FMIHVzYWdlLiAg KFRoaXMgbXVzdCB3YWl0IGZvciB0aGUgd29ya2VycwogCSAqIHRvIGZpbmlzaCwgb3Igd2UgbWln aHQgZ2V0IGluY29tcGxldGUgZGF0YS4pCkBAIC0xMjYxLDkgKzEyODAsMjMgQEAgcGFyYWxsZWxf dmFjdXVtX21haW4oZHNtX3NlZ21lbnQgKnNlZywgc2htX3RvYyAqdG9jKQogCS8qIFByZXBhcmUg dG8gdHJhY2sgYnVmZmVyIHVzYWdlIGR1cmluZyBwYXJhbGxlbCBleGVjdXRpb24gKi8KIAlJbnN0 clN0YXJ0UGFyYWxsZWxRdWVyeSgpOwogCisJSU5KRUNUSU9OX1BPSU5UKCJwYXJhbGxlbC13b3Jr ZXItYmVmb3JlLWluZGV4ZXMtcHJvY2Vzc2luZyIsIE5VTEwpOworCiAJLyogUHJvY2VzcyBpbmRl eGVzIHRvIHBlcmZvcm0gdmFjdXVtL2NsZWFudXAgKi8KIAlwYXJhbGxlbF92YWN1dW1fcHJvY2Vz c19zYWZlX2luZGV4ZXMoJnB2cyk7CiAKKyNpZmRlZiBVU0VfSU5KRUNUSU9OX1BPSU5UUworCS8q CisJICogVGhlcmUgaXMgbm8gZ3VhcmFudGVlIHRoYXQgZWFjaCBwYXJhbGxlbCB3b3JrZXIgd2ls bCBuZWNlc3NhcmlseQorCSAqIHByb2Nlc3MgYXQgbGVhc3Qgb25lIGluZGV4LiBUaHVzLCBhdCB0 aGlzIHBvaW50IHdlIGNhbm5vdCBiZSBzdXJlIHRoYXQKKwkgKiB3b3JrZXIgY2FsbGVkIHZhY3V1 bV9jb3N0X2RlbGF5LiBJbiBvcmRlciB0byB0ZXN0IGNvc3QtYmFzZWQgcGFyYW1ldGVycworCSAq IHByb3BhZ2F0aW9uIChmcm9tIGxlYWRlciB3b3JrZXIpLCBjYWxsIHZhY3V1bV9kZWxheV9wb2lu dCBoZXJlLCBpZgorCSAqIGluamVjdGlvbiBwb2ludCBpcyBhY3RpdmUuCisJICovCisJaWYgKElT X0lOSkVDVElPTl9QT0lOVF9BVFRBQ0hFRCgicGFyYWxsZWwtYXV0b3ZhY3V1bS1mb3JjZS1kZWxh eS1wb2ludCIpKQorCQlwYXJhbGxlbF92YWN1dW1fcmVwb3J0X2Nvc3RfYmFzZWRfcGFyYW1zKCk7 CisjZW5kaWYKKwogCS8qIFJlcG9ydCBidWZmZXIvV0FMIHVzYWdlIGR1cmluZyBwYXJhbGxlbCBl eGVjdXRpb24gKi8KIAlidWZmZXJfdXNhZ2UgPSBzaG1fdG9jX2xvb2t1cCh0b2MsIFBBUkFMTEVM X1ZBQ1VVTV9LRVlfQlVGRkVSX1VTQUdFLCBmYWxzZSk7CiAJd2FsX3VzYWdlID0gc2htX3RvY19s b29rdXAodG9jLCBQQVJBTExFTF9WQUNVVU1fS0VZX1dBTF9VU0FHRSwgZmFsc2UpOwpAQCAtMTMx NiwzICsxMzQ5LDMwIEBAIHBhcmFsbGVsX3ZhY3V1bV9lcnJvcl9jYWxsYmFjayh2b2lkICphcmcp CiAJCQlyZXR1cm47CiAJfQogfQorCisvKgorICogTG9nIHZhbHVlcyBvZiB0aGUgcmVsYXRlZCB0 byBjb3N0LWJhc2VkIGRlbGF5IHBhcmFtZXRlcnMuIEl0IGlzIHVzZWQgZm9yCisgKiB0ZXN0aW5n IHB1cnBvc2UuCisgKi8KK3N0YXRpYyB2b2lkCitwYXJhbGxlbF92YWN1dW1fcmVwb3J0X2Nvc3Rf YmFzZWRfcGFyYW1zKHZvaWQpCit7CisJU3RyaW5nSW5mb0RhdGEgYnVmOworCisJLyogU2ltdWxh dGUgY29uZmlnIHJlbG9hZCBkdXJpbmcgbm9ybWFsIHByb2Nlc3NpbmcgKi8KKwlwZ19hdG9taWNf YWRkX2ZldGNoX3UzMihWYWN1dW1BY3RpdmVOV29ya2VycywgMSk7CisJdmFjdXVtX2RlbGF5X3Bv aW50KGZhbHNlKTsKKwlwZ19hdG9taWNfc3ViX2ZldGNoX3UzMihWYWN1dW1BY3RpdmVOV29ya2Vy cywgMSk7CisKKwlpbml0U3RyaW5nSW5mbygmYnVmKTsKKworCWFwcGVuZFN0cmluZ0luZm8oJmJ1 ZiwgIlZhY3V1bSBjb3N0LWJhc2VkIGRlbGF5IHBhcmFtZXRlcnMgb2YgcGFyYWxsZWwgd29ya2Vy OlxuIik7CisJYXBwZW5kU3RyaW5nSW5mbygmYnVmLCJ2YWN1dW1fY29zdF9saW1pdCA9ICVkXG4i LHZhY3V1bV9jb3N0X2xpbWl0KTsKKwlhcHBlbmRTdHJpbmdJbmZvKCZidWYsICJ2YWN1dW1fY29z dF9kZWxheSA9ICVnXG4iLCB2YWN1dW1fY29zdF9kZWxheSk7CisJYXBwZW5kU3RyaW5nSW5mbygm YnVmLCAidmFjdXVtX2Nvc3RfcGFnZV9taXNzID0gJWRcbiIsIFZhY3V1bUNvc3RQYWdlTWlzcyk7 CisJYXBwZW5kU3RyaW5nSW5mbygmYnVmLCAidmFjdXVtX2Nvc3RfcGFnZV9kaXJ0eSA9ICVkXG4i LCBWYWN1dW1Db3N0UGFnZURpcnR5KTsKKwlhcHBlbmRTdHJpbmdJbmZvKCZidWYsICJ2YWN1dW1f Y29zdF9wYWdlX2hpdCA9ICVkXG4iLCBWYWN1dW1Db3N0UGFnZUhpdCk7CisKKwllcmVwb3J0KExP RywgZXJybXNnKCIlcyIsIGJ1Zi5kYXRhKSk7CisJcGZyZWUoYnVmLmRhdGEpOworfQpkaWZmIC0t Z2l0IGEvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMgYi9zcmMvYmFja2VuZC9w b3N0bWFzdGVyL2F1dG92YWN1dW0uYwppbmRleCAzZWU4NThjNWZiZC4uZTZkNjA0MzRiYzUgMTAw NjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCisrKyBiL3NyYy9i YWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCkBAIC04MDEsNiArODAxLDggQEAgUHJvY2Vz c0F1dG9WYWNMYXVuY2hlckludGVycnVwdHModm9pZCkKIAogCQkvKiByZWJ1aWxkIHRoZSBsaXN0 IGluIGNhc2UgdGhlIG5hcHRpbWUgY2hhbmdlZCAqLwogCQlyZWJ1aWxkX2RhdGFiYXNlX2xpc3Qo SW52YWxpZE9pZCk7CisKKwkJSU5KRUNUSU9OX1BPSU5UKCJhdXRvdmFjdXVtLWxhdW5jaGVyLWFm dGVyLXJlbG9hZC1jb25maWciLCBOVUxMKTsKIAl9CiAKIAkvKiBQcm9jZXNzIGJhcnJpZXIgZXZl bnRzICovCkBAIC0zNDY3LDYgKzM0NjksMjMgQEAgQXV0b1ZhY3V1bVJlbGVhc2VBbGxQYXJhbGxl bFdvcmtlcnModm9pZCkKIAlBc3NlcnQoYXZfbndvcmtlcnNfcmVzZXJ2ZWQgPT0gMCk7CiB9CiAK Ky8qCisgKiBHZXQgbnVtYmVyIG9mIGZyZWUgYXV0b3ZhY3V1bSBwYXJhbGxlbCB3b3JrZXJzLgor ICoKKyAqIEZvciB0ZXN0aW5nIHB1cnBvc2Ugb25seSEKKyAqLwordWludDMyCitBdXRvVmFjdXVt R2V0RnJlZVBhcmFsbGVsV29ya2Vycyh2b2lkKQoreworCXVpbnQzMgkJbmZyZWVfd29ya2VyczsK KworCUxXTG9ja0FjcXVpcmUoQXV0b3ZhY3V1bUxvY2ssIExXX0VYQ0xVU0lWRSk7CisJbmZyZWVf d29ya2VycyA9IEF1dG9WYWN1dW1TaG1lbS0+YXZfZnJlZVBhcmFsbGVsV29ya2VyczsKKwlMV0xv Y2tSZWxlYXNlKEF1dG92YWN1dW1Mb2NrKTsKKworCXJldHVybiBuZnJlZV93b3JrZXJzOworfQor CiAvKgogICogYXV0b3ZhY19pbml0CiAgKgkJVGhpcyBpcyBjYWxsZWQgYXQgcG9zdG1hc3RlciBp bml0aWFsaXphdGlvbi4KZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL3Bvc3RtYXN0ZXIvYXV0b3Zh Y3V1bS5oIGIvc3JjL2luY2x1ZGUvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmgKaW5kZXggZjM3ODNh ZmI1MWIuLjUyYmUyNjBlMTVmIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9wb3N0bWFzdGVyL2F1 dG92YWN1dW0uaAorKysgYi9zcmMvaW5jbHVkZS9wb3N0bWFzdGVyL2F1dG92YWN1dW0uaApAQCAt NjYsNiArNjYsNyBAQCBleHRlcm4gYm9vbCBBdXRvVmFjdXVtUmVxdWVzdFdvcmsoQXV0b1ZhY3V1 bVdvcmtJdGVtVHlwZSB0eXBlLAogZXh0ZXJuIHZvaWQJQXV0b1ZhY3V1bVJlc2VydmVQYXJhbGxl bFdvcmtlcnMoaW50ICpud29ya2Vycyk7CiBleHRlcm4gdm9pZCBBdXRvVmFjdXVtUmVsZWFzZVBh cmFsbGVsV29ya2VycyhpbnQgbndvcmtlcnMpOwogZXh0ZXJuIHZvaWQgQXV0b1ZhY3V1bVJlbGVh c2VBbGxQYXJhbGxlbFdvcmtlcnModm9pZCk7CitleHRlcm4gdWludDMyIEF1dG9WYWN1dW1HZXRG cmVlUGFyYWxsZWxXb3JrZXJzKHZvaWQpOwogCiAvKiBzaGFyZWQgbWVtb3J5IHN0dWZmICovCiBl eHRlcm4gU2l6ZSBBdXRvVmFjdXVtU2htZW1TaXplKHZvaWQpOwpkaWZmIC0tZ2l0IGEvc3JjL3Rl c3QvbW9kdWxlcy9NYWtlZmlsZSBiL3NyYy90ZXN0L21vZHVsZXMvTWFrZWZpbGUKaW5kZXggNGM2 ZDU2ZDk3ZDguLmJmZTM2NWZhNTc1IDEwMDY0NAotLS0gYS9zcmMvdGVzdC9tb2R1bGVzL01ha2Vm aWxlCisrKyBiL3NyYy90ZXN0L21vZHVsZXMvTWFrZWZpbGUKQEAgLTE2LDYgKzE2LDcgQEAgU1VC RElSUyA9IFwKIAkJICBwbHNhbXBsZSBcCiAJCSAgc3BnaXN0X25hbWVfb3BzIFwKIAkJICB0ZXN0 X2FpbyBcCisJCSAgdGVzdF9hdXRvdmFjdXVtIFwKIAkJICB0ZXN0X2JpbmFyeWhlYXAgXAogCQkg IHRlc3RfYml0bWFwc2V0IFwKIAkJICB0ZXN0X2Jsb29tZmlsdGVyIFwKZGlmZiAtLWdpdCBhL3Ny Yy90ZXN0L21vZHVsZXMvbWVzb24uYnVpbGQgYi9zcmMvdGVzdC9tb2R1bGVzL21lc29uLmJ1aWxk CmluZGV4IDFiMzFjNWI5OGQ2Li4wMWEzZTNlYzA0NCAxMDA2NDQKLS0tIGEvc3JjL3Rlc3QvbW9k dWxlcy9tZXNvbi5idWlsZAorKysgYi9zcmMvdGVzdC9tb2R1bGVzL21lc29uLmJ1aWxkCkBAIC0x Niw2ICsxNiw3IEBAIHN1YmRpcigncGxzYW1wbGUnKQogc3ViZGlyKCdzcGdpc3RfbmFtZV9vcHMn KQogc3ViZGlyKCdzc2xfcGFzc3BocmFzZV9jYWxsYmFjaycpCiBzdWJkaXIoJ3Rlc3RfYWlvJykK K3N1YmRpcigndGVzdF9hdXRvdmFjdXVtJykKIHN1YmRpcigndGVzdF9iaW5hcnloZWFwJykKIHN1 YmRpcigndGVzdF9iaXRtYXBzZXQnKQogc3ViZGlyKCd0ZXN0X2Jsb29tZmlsdGVyJykKZGlmZiAt LWdpdCBhL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVtLy5naXRpZ25vcmUgYi9zcmMv dGVzdC9tb2R1bGVzL3Rlc3RfYXV0b3ZhY3V1bS8uZ2l0aWdub3JlCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwLi43MTZlMTdmNWEyYQotLS0gL2Rldi9udWxsCisrKyBiL3Ny Yy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVtLy5naXRpZ25vcmUKQEAgLTAsMCArMSwyIEBA CisjIEdlbmVyYXRlZCBzdWJkaXJlY3RvcmllcworL3RtcF9jaGVjay8KZGlmZiAtLWdpdCBhL3Ny Yy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVtL01ha2VmaWxlIGIvc3JjL3Rlc3QvbW9kdWxl cy90ZXN0X2F1dG92YWN1dW0vTWFrZWZpbGUKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAuLjMyMjU0YzUzYTVkCi0tLSAvZGV2L251bGwKKysrIGIvc3JjL3Rlc3QvbW9kdWxl cy90ZXN0X2F1dG92YWN1dW0vTWFrZWZpbGUKQEAgLTAsMCArMSwyOCBAQAorIyBzcmMvdGVzdC9t b2R1bGVzL3Rlc3RfYXV0b3ZhY3V1bS9NYWtlZmlsZQorCitQR0ZJTEVERVNDID0gInRlc3RfYXV0 b3ZhY3V1bSAtIHRlc3QgY29kZSBmb3IgcGFyYWxsZWwgYXV0b3ZhY3V1bSIKKworTU9EVUxFX2Jp ZyA9IHRlc3RfYXV0b3ZhY3V1bQorT0JKUyA9IFwKKwkkKFdJTjMyUkVTKSBcCisJdGVzdF9hdXRv dmFjdXVtLm8KKworRVhURU5TSU9OID0gdGVzdF9hdXRvdmFjdXVtCitEQVRBID0gdGVzdF9hdXRv dmFjdXVtLS0xLjAuc3FsCisKK1RBUF9URVNUUyA9IDEKKworRVhUUkFfSU5TVEFMTCA9IHNyYy90 ZXN0L21vZHVsZXMvaW5qZWN0aW9uX3BvaW50cworCitleHBvcnQgZW5hYmxlX2luamVjdGlvbl9w b2ludHMKKworaWZkZWYgVVNFX1BHWFMKK1BHX0NPTkZJRyA9IHBnX2NvbmZpZworUEdYUyA6PSAk KHNoZWxsICQoUEdfQ09ORklHKSAtLXBneHMpCitpbmNsdWRlICQoUEdYUykKK2Vsc2UKK3N1YmRp ciA9IHNyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVtCit0b3BfYnVpbGRkaXIgPSAuLi8u Li8uLi8uLgoraW5jbHVkZSAkKHRvcF9idWlsZGRpcikvc3JjL01ha2VmaWxlLmdsb2JhbAoraW5j bHVkZSAkKHRvcF9zcmNkaXIpL2NvbnRyaWIvY29udHJpYi1nbG9iYWwubWsKK2VuZGlmCmRpZmYg LS1naXQgYS9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYXV0b3ZhY3V1bS9tZXNvbi5idWlsZCBiL3Ny Yy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVtL21lc29uLmJ1aWxkCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi4zNDQxZTVlNDljZgotLS0gL2Rldi9udWxsCisrKyBi L3NyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVtL21lc29uLmJ1aWxkCkBAIC0wLDAgKzEs MzYgQEAKKyMgQ29weXJpZ2h0IChjKSAyMDI0LTIwMjUsIFBvc3RncmVTUUwgR2xvYmFsIERldmVs b3BtZW50IEdyb3VwCisKK3Rlc3RfYXV0b3ZhY3V1bV9zb3VyY2VzID0gZmlsZXMoCisgICd0ZXN0 X2F1dG92YWN1dW0uYycsCispCisKK2lmIGhvc3Rfc3lzdGVtID09ICd3aW5kb3dzJworICB0ZXN0 X2F1dG92YWN1dW1fc291cmNlcyArPSByY19saWJfZ2VuLnByb2Nlc3Mod2luMzJ2ZXJfcmMsIGV4 dHJhX2FyZ3M6IFsKKyAgICAnLS1OQU1FJywgJ3Rlc3RfYXV0b3ZhY3V1bScsCisgICAgJy0tRklM RURFU0MnLCAndGVzdF9hdXRvdmFjdXVtIC0gdGVzdCBjb2RlIGZvciBwYXJhbGxlbCBhdXRvdmFj dXVtJyxdKQorZW5kaWYKKwordGVzdF9hdXRvdmFjdXVtID0gc2hhcmVkX21vZHVsZSgndGVzdF9h dXRvdmFjdXVtJywKKyAgdGVzdF9hdXRvdmFjdXVtX3NvdXJjZXMsCisgIGt3YXJnczogcGdfdGVz dF9tb2RfYXJncywKKykKK3Rlc3RfaW5zdGFsbF9saWJzICs9IHRlc3RfYXV0b3ZhY3V1bQorCit0 ZXN0X2luc3RhbGxfZGF0YSArPSBmaWxlcygKKyAgJ3Rlc3RfYXV0b3ZhY3V1bS5jb250cm9sJywK KyAgJ3Rlc3RfYXV0b3ZhY3V1bS0tMS4wLnNxbCcsCispCisKK3Rlc3RzICs9IHsKKyAgJ25hbWUn OiAndGVzdF9hdXRvdmFjdXVtJywKKyAgJ3NkJzogbWVzb24uY3VycmVudF9zb3VyY2VfZGlyKCks CisgICdiZCc6IG1lc29uLmN1cnJlbnRfYnVpbGRfZGlyKCksCisgICd0YXAnOiB7CisgICAgJ2Vu dic6IHsKKyAgICAgICAnZW5hYmxlX2luamVjdGlvbl9wb2ludHMnOiBnZXRfb3B0aW9uKCdpbmpl Y3Rpb25fcG9pbnRzJykgPyAneWVzJyA6ICdubycsCisgICAgfSwKKyAgICAndGVzdHMnOiBbCisg ICAgICAndC8wMDFfYmFzaWMucGwnLAorICAgIF0sCisgIH0sCit9CmRpZmYgLS1naXQgYS9zcmMv dGVzdC9tb2R1bGVzL3Rlc3RfYXV0b3ZhY3V1bS90LzAwMV9iYXNpYy5wbCBiL3NyYy90ZXN0L21v ZHVsZXMvdGVzdF9hdXRvdmFjdXVtL3QvMDAxX2Jhc2ljLnBsCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwLi4wNjVhNThlZjJlNgotLS0gL2Rldi9udWxsCisrKyBiL3NyYy90 ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVtL3QvMDAxX2Jhc2ljLnBsCkBAIC0wLDAgKzEsMzQ2 IEBACit1c2Ugd2FybmluZ3MgRkFUQUwgPT4gJ2FsbCc7Cit1c2UgUG9zdGdyZVNRTDo6VGVzdDo6 Q2x1c3RlcjsKK3VzZSBQb3N0Z3JlU1FMOjpUZXN0OjpVdGlsczsKK3VzZSBUZXN0OjpNb3JlOwor CitpZiAoJEVOVntlbmFibGVfaW5qZWN0aW9uX3BvaW50c30gbmUgJ3llcycpCit7CisJcGxhbiBz a2lwX2FsbCA9PiAnSW5qZWN0aW9uIHBvaW50cyBub3Qgc3VwcG9ydGVkIGJ5IHRoaXMgYnVpbGQn OworfQorCisjIEJlZm9yZSBlYWNoIHRlc3Qgd2Ugc2hvdWxkIGRpc2FibGUgYXV0b3ZhY3V1bSBm b3IgJ3Rlc3RfYXV0b3ZhYycgdGFibGUgYW5kCisjIGdlbmVyYXRlIHNvbWUgZGVhZCB0dXBsZXMg aW4gaXQuCisKK3N1YiBwcmVwYXJlX2Zvcl9uZXh0X3Rlc3QKK3sKKwlteSAoJG5vZGUsICR0ZXN0 X251bWJlcikgPSBAXzsKKworCSRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgcXF7CisJCUFM VEVSIFRBQkxFIHRlc3RfYXV0b3ZhYyBTRVQgKGF1dG92YWN1dW1fZW5hYmxlZCA9IGZhbHNlKTsK Kwl9KTsKKworCSRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgcXF7CisJCVVQREFURSB0ZXN0 X2F1dG92YWMgU0VUIGNvbF8xID0gJHRlc3RfbnVtYmVyOworCQlBTkFMWVpFIHRlc3RfYXV0b3Zh YzsKKwl9KTsKK30KKworc3ViIHdhaXRfZm9yX2F2X2xvZworeworCW15ICgkbm9kZSwgJGV4cGVj dGVkX2xvZykgPSBAXzsKKworCSRub2RlLT53YWl0X2Zvcl9sb2coJGV4cGVjdGVkX2xvZyk7CisJ dHJ1bmNhdGUgJG5vZGUtPmxvZ2ZpbGUsIDAgb3IgZGllICJ0cnVuY2F0ZSBmYWlsZWQ6ICQhIjsK K30KKworbXkgJHBzcWxfb3V0OworCitteSAkbm9kZSA9IFBvc3RncmVTUUw6OlRlc3Q6OkNsdXN0 ZXItPm5ldygnbm9kZTEnKTsKKyRub2RlLT5pbml0OworCisjIENvbmZpZ3VyZSBwb3N0Z3Jlcywg c28gaXQgY2FuIGxhdW5jaCBwYXJhbGxlbCBhdXRvdmFjdXVtIHdvcmtlcnMsIGxvZyBhbGwKKyMg aW5mb3JtYXRpb24gd2UgYXJlIGludGVyZXN0ZWQgaW4gYW5kIGF1dG92YWN1dW0gd29ya3MgZnJl cXVlbnRseQorJG5vZGUtPmFwcGVuZF9jb25mKCdwb3N0Z3Jlc3FsLmNvbmYnLCBxcXsKKwltYXhf d29ya2VyX3Byb2Nlc3NlcyA9IDIwCisJbWF4X3BhcmFsbGVsX3dvcmtlcnMgPSAyMAorCW1heF9w YXJhbGxlbF9tYWludGVuYW5jZV93b3JrZXJzID0gMjAKKwlhdXRvdmFjdXVtX21heF9wYXJhbGxl bF93b3JrZXJzID0gMjAKKwlsb2dfbWluX21lc3NhZ2VzID0gZGVidWcyCisJbG9nX2F1dG92YWN1 dW1fbWluX2R1cmF0aW9uID0gMAorCWF1dG92YWN1dW1fbmFwdGltZSA9ICcxcycKKwltaW5fcGFy YWxsZWxfaW5kZXhfc2Nhbl9zaXplID0gMAorCXNoYXJlZF9wcmVsb2FkX2xpYnJhcmllcz10ZXN0 X2F1dG92YWN1dW0KK30pOworJG5vZGUtPnN0YXJ0OworCisjIENoZWNrIGlmIHRoZSBleHRlbnNp b24gaW5qZWN0aW9uX3BvaW50cyBpcyBhdmFpbGFibGUsIGFzIGl0IG1heSBiZQorIyBwb3NzaWJs ZSB0aGF0IHRoaXMgc2NyaXB0IGlzIHJ1biB3aXRoIGluc3RhbGxjaGVjaywgd2hlcmUgdGhlIG1v ZHVsZQorIyB3b3VsZCBub3QgYmUgaW5zdGFsbGVkIGJ5IGRlZmF1bHQuCitpZiAoISRub2RlLT5j aGVja19leHRlbnNpb24oJ2luamVjdGlvbl9wb2ludHMnKSkKK3sKKwlwbGFuIHNraXBfYWxsID0+ ICdFeHRlbnNpb24gaW5qZWN0aW9uX3BvaW50cyBub3QgaW5zdGFsbGVkJzsKK30KKworIyBDcmVh dGUgYWxsIGZ1bmN0aW9ucyBuZWVkZWQgZm9yIHRlc3RpbmcKKyRub2RlLT5zYWZlX3BzcWwoJ3Bv c3RncmVzJywgcXF7CisJQ1JFQVRFIEVYVEVOU0lPTiB0ZXN0X2F1dG92YWN1dW07CisJQ1JFQVRF IEVYVEVOU0lPTiBpbmplY3Rpb25fcG9pbnRzOworfSk7CisKK215ICRpbmRleGVzX251bSA9IDQ7 CitteSAkaW5pdGlhbF9yb3dzX251bSA9IDEwXzAwMDsKK215ICRhdXRvdmFjdXVtX3BhcmFsbGVs X3dvcmtlcnMgPSAyOworCisjIENyZWF0ZSB0YWJsZSB3aXRoIHNwZWNpZmllZCBudW1iZXIgb2Yg Yi10cmVlIGluZGV4ZXMgb24gaXQKKyRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgcXF7CisJ Q1JFQVRFIFRBQkxFIHRlc3RfYXV0b3ZhYyAoCisJCWlkIFNFUklBTCBQUklNQVJZIEtFWSwKKwkJ Y29sXzEgSU5URUdFUiwgIGNvbF8yIElOVEVHRVIsICBjb2xfMyBJTlRFR0VSLCAgY29sXzQgSU5U RUdFUgorCSkgV0lUSCAoYXV0b3ZhY3V1bV9wYXJhbGxlbF93b3JrZXJzID0gJGF1dG92YWN1dW1f cGFyYWxsZWxfd29ya2Vycyk7CisKKwlETyBcJFwkCisJREVDTEFSRQorCQlpIElOVEVHRVI7CisJ QkVHSU4KKwkJRk9SIGkgSU4gMS4uJGluZGV4ZXNfbnVtIExPT1AKKwkJCUVYRUNVVEUgZm9ybWF0 KCdDUkVBVEUgSU5ERVggaWR4X2NvbF9cJXMgT04gdGVzdF9hdXRvdmFjIChjb2xfXCVzKTsnLCBp LCBpKTsKKwkJRU5EIExPT1A7CisJRU5EIFwkXCQ7Cit9KTsKKworIyBJbnNlcnQgc3BlY2lmaWVk IHR1cGxlcyBudW0gaW50byB0aGUgdGFibGUKKyRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywg cXF7CisJRE8gXCRcJAorCURFQ0xBUkUKKwkJaSBJTlRFR0VSOworCUJFR0lOCisJCUZPUiBpIElO IDEuLiRpbml0aWFsX3Jvd3NfbnVtIExPT1AKKwkJCUlOU0VSVCBJTlRPIHRlc3RfYXV0b3ZhYyBW QUxVRVMgKGksIGkgKyAxLCBpICsgMiwgaSArIDMpOworCQlFTkQgTE9PUDsKKwlFTkQgXCRcJDsK K30pOworCisjIFRlc3QgMSA6CisjIE91ciB0YWJsZSBoYXMgZW5vdWdoIGluZGV4ZXMgYW5kIGFw cHJvcHJpYXRlIHJlbG9wdGlvbnMsIHNvIGF1dG92YWN1dW0gbXVzdAorIyBiZSBhYmxlIHRvIHBy b2Nlc3MgaXQgaW4gcGFyYWxsZWwgbW9kZS4gSnVzdCBjaGVjayBpZiBpdCBjYW4uCisjIEFsc28g Y2hlY2sgd2hldGhlciBhbGwgcmVxdWVzdGVkIHdvcmtlcnM6CisjIAkxKSBsYXVuY2hlZAorIyAJ MikgY29ycmVjdGx5IHJlbGVhc2VkCisKK3ByZXBhcmVfZm9yX25leHRfdGVzdCgkbm9kZSwgMSk7 CisKKyRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgcXF7CisJQUxURVIgVEFCTEUgdGVzdF9h dXRvdmFjIFNFVCAoYXV0b3ZhY3V1bV9lbmFibGVkID0gdHJ1ZSk7Cit9KTsKKworIyBXYWl0IHVu dGlsIHRoZSBwYXJhbGxlbCBhdXRvdmFjdXVtIG9uIHRhYmxlIGlzIGNvbXBsZXRlZC4gQXQgdGhl IHNhbWUgdGltZSwKKyMgd2UgY2hlY2sgdGhhdCB0aGUgcmVxdWlyZWQgbnVtYmVyIG9mIHBhcmFs bGVsIHdvcmtlcnMgaGFzIGJlZW4gc3RhcnRlZC4KK3dhaXRfZm9yX2F2X2xvZygkbm9kZSwKKwkJ CQlxci9wYXJhbGxlbCBpbmRleCB2YWN1dW1cL2NsZWFudXA6IDIgd29ya2VycyB3ZXJlIHBsYW5u ZWQsIC8gLgorCQkJCXFyLzIgd29ya2VycyB3ZXJlIHJlc2VydmVkIGFuZCAyIHdvcmtlcnMgd2Vy ZSBsYXVuY2hlZCBpbiB0b3RhbC8pOworCiskbm9kZS0+cHNxbCgncG9zdGdyZXMnLAorCSJTRUxF Q1QgZ2V0X3BhcmFsbGVsX2F1dG92YWN1dW1fZnJlZV93b3JrZXJzKCk7IiwKKwlzdGRvdXQgPT4g XCRwc3FsX291dCwKKyk7CitpcygkcHNxbF9vdXQsIDIwLCAnQWxsIHBhcmFsbGVsIHdvcmtlcnMg aGFzIGJlZW4gcmVsZWFzZWQgYnkgdGhlIGxlYWRlcicpOworCisjIFRlc3QgMjoKKyMgQ2hlY2sg d2hldGhlciBwYXJhbGxlbCBhdXRvdmFjdXVtIGxlYWRlciBjYW4gcHJvcGFnYXRlIGNvc3QtYmFz ZWQgcGFyYW1ldGVycworIyB0byBwYXJhbGxlbCB3b3JrZXJzLgorCitwcmVwYXJlX2Zvcl9uZXh0 X3Rlc3QoJG5vZGUsIDIpOworCiskbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFxeworCVNF TEVDVCBpbmplY3Rpb25fcG9pbnRzX2F0dGFjaCgnYXV0b3ZhY3V1bS1sZWFkZXItYmVmb3JlLWlu ZGV4ZXMtcHJvY2Vzc2luZycsICd3YWl0Jyk7CisJU0VMRUNUIGluamVjdGlvbl9wb2ludHNfYXR0 YWNoKCdhdXRvdmFjdXVtLWxlYWRlci1hZnRlci1pbmRleGVzLXByb2Nlc3NpbmcnLCAnd2FpdCcp OworCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX2F0dGFjaCgncGFyYWxsZWwtd29ya2VyLWJlZm9y ZS1pbmRleGVzLXByb2Nlc3NpbmcnLCAnd2FpdCcpOworCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRz X2F0dGFjaCgncGFyYWxsZWwtYXV0b3ZhY3V1bS1mb3JjZS1kZWxheS1wb2ludCcsICd3YWl0Jyk7 CisKKwlBTFRFUiBUQUJMRSB0ZXN0X2F1dG92YWMgU0VUIChhdXRvdmFjdXVtX3BhcmFsbGVsX3dv cmtlcnMgPSAxLCBhdXRvdmFjdXVtX2VuYWJsZWQgPSB0cnVlKTsKK30pOworCisjIFdhaXQgdW50 aWwgcGFyYWxsZWwgYXV0b3ZhY3V1bSBsZWFkZXIgbGF1bmNoZXMgcGFyYWxsZWwgd29ya2VyIGFu ZCBmYWxscworIyBhc2xlZXAgb24gdGhlIGluamVjdGlvbiBwb2ludAorJG5vZGUtPndhaXRfZm9y X2V2ZW50KAorCSdhdXRvdmFjdXVtIHdvcmtlcicsCisJJ2F1dG92YWN1dW0tbGVhZGVyLWJlZm9y ZS1pbmRleGVzLXByb2Nlc3NpbmcnCispOworCisjIFJlbG9hZCBjb25maWcgLSBsZWFkZXIgd29y a2VyIG11c3QgdXBkYXRlIGl0cyBvd24gcGFyYW1ldGVycyBkdXJpbmcgaW5kZXhlcworIyBwcm9j ZXNzaW5nCiskbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFxeworCUFMVEVSIFNZU1RFTSBT RVQgdmFjdXVtX2Nvc3RfbGltaXQgPSA1MDA7CisJQUxURVIgU1lTVEVNIFNFVCB2YWN1dW1fY29z dF9wYWdlX21pc3MgPSAxMDsKKwlBTFRFUiBTWVNURU0gU0VUIHZhY3V1bV9jb3N0X3BhZ2VfZGly dHkgPSAxMDsKKwlBTFRFUiBTWVNURU0gU0VUIHZhY3V1bV9jb3N0X3BhZ2VfaGl0ID0gMTA7CisJ U0VMRUNUIHBnX3JlbG9hZF9jb25mKCk7Cit9KTsKKworJG5vZGUtPnNhZmVfcHNxbCgncG9zdGdy ZXMnLCBxcXsKKwlTRUxFQ1QgaW5qZWN0aW9uX3BvaW50c193YWtldXAoJ2F1dG92YWN1dW0tbGVh ZGVyLWJlZm9yZS1pbmRleGVzLXByb2Nlc3NpbmcnKTsKK30pOworCisjIFdhaXQgdW50aWwgbGVh ZGVyIHdvcmtlciBpcyBndWFyYW50ZWVkIHRvIHVwZGF0ZSBwYXJhbWV0ZXJzIGFuZCBwcm9wYWdh dGUKKyMgdGhlaXIgdmFsdWVzIHRvIHRoZSBwYXJhbGxlbCB3b3JrZXIKKyRub2RlLT53YWl0X2Zv cl9ldmVudCgKKwknYXV0b3ZhY3V1bSB3b3JrZXInLAorCSdhdXRvdmFjdXVtLWxlYWRlci1hZnRl ci1pbmRleGVzLXByb2Nlc3NpbmcnCispOworCiskbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3Jlcycs IHFxeworCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX3dha2V1cCgnYXV0b3ZhY3V1bS1sZWFkZXIt YWZ0ZXItaW5kZXhlcy1wcm9jZXNzaW5nJyk7Cit9KTsKKworIyBOb3cgd2FrZSB1cCB0aGUgcGFy YWxsZWwgd29ya2VyIGFuZCBmb3JjZSBpdCB0byBjYWxsIHZhY3V1bV9kZWxheV9wb2ludAorJG5v ZGUtPndhaXRfZm9yX2V2ZW50KAorCSdwYXJhbGxlbCB3b3JrZXInLAorCSdwYXJhbGxlbC13b3Jr ZXItYmVmb3JlLWluZGV4ZXMtcHJvY2Vzc2luZycKKyk7CisKKyRub2RlLT5zYWZlX3BzcWwoJ3Bv c3RncmVzJywgcXF7CisJU0VMRUNUIGluamVjdGlvbl9wb2ludHNfd2FrZXVwKCdwYXJhbGxlbC13 b3JrZXItYmVmb3JlLWluZGV4ZXMtcHJvY2Vzc2luZycpOworfSk7CisKKyMgQ2hlY2sgd2hldGhl ciB3b3JrZXIgc3VjY2Vzc2Z1bGx5IHVwZGF0ZWQgYWxsIHBhcmFtZXRlcnMKK3dhaXRfZm9yX2F2 X2xvZygkbm9kZSwKKwkJCQlxci9WYWN1dW0gY29zdC1iYXNlZCBkZWxheSBwYXJhbWV0ZXJzIG9m IHBhcmFsbGVsIHdvcmtlcjpcbi8gLgorCQkJCXFyL1x0dmFjdXVtX2Nvc3RfbGltaXQgPSA1MDBc bi8gLgorCQkJCXFyL1x0dmFjdXVtX2Nvc3RfZGVsYXkgPSAyXG4vIC4KKwkJCQlxci9cdHZhY3V1 bV9jb3N0X3BhZ2VfbWlzcyA9IDEwXG4vIC4KKwkJCQlxci9cdHZhY3V1bV9jb3N0X3BhZ2VfZGly dHkgPSAxMFxuLyAuCisJCQkJcXIvXHR2YWN1dW1fY29zdF9wYWdlX2hpdCA9IDEwXG4vKTsKKwor IyBDbGVhbnVwCiskbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFxeworCVNFTEVDVCBpbmpl Y3Rpb25fcG9pbnRzX2RldGFjaCgnYXV0b3ZhY3V1bS1sZWFkZXItYmVmb3JlLWluZGV4ZXMtcHJv Y2Vzc2luZycpOworCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX2RldGFjaCgnYXV0b3ZhY3V1bS1s ZWFkZXItYWZ0ZXItaW5kZXhlcy1wcm9jZXNzaW5nJyk7CisJU0VMRUNUIGluamVjdGlvbl9wb2lu dHNfZGV0YWNoKCdwYXJhbGxlbC13b3JrZXItYmVmb3JlLWluZGV4ZXMtcHJvY2Vzc2luZycpOwor CVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX2RldGFjaCgncGFyYWxsZWwtYXV0b3ZhY3V1bS1mb3Jj ZS1kZWxheS1wb2ludCcpOworCisJQUxURVIgVEFCTEUgdGVzdF9hdXRvdmFjIFNFVCAoYXV0b3Zh Y3V1bV9wYXJhbGxlbF93b3JrZXJzID0gJGF1dG92YWN1dW1fcGFyYWxsZWxfd29ya2Vycyk7Cit9 KTsKKworIyBUZXN0IDM6CisjIFRlc3QgYWRqdXN0bWVudCBvZiBmcmVlIHBhcmFsbGVsIHdvcmtl cnMgbnVtYmVyIHdoZW4gY2hhbmdpbmcKKyMgYXV0b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2Vy cyBwYXJhbWV0ZXIKKworcHJlcGFyZV9mb3JfbmV4dF90ZXN0KCRub2RlLCA0KTsKKworJG5vZGUt PnNhZmVfcHNxbCgncG9zdGdyZXMnLCBxcXsKKwlTRUxFQ1QgaW5qZWN0aW9uX3BvaW50c19hdHRh Y2goJ2F1dG92YWN1dW0tbGVhZGVyLWJlZm9yZS1pbmRleGVzLXByb2Nlc3NpbmcnLCAnd2FpdCcp OworCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX2F0dGFjaCgnYXV0b3ZhY3V1bS1sYXVuY2hlci1h ZnRlci1yZWxvYWQtY29uZmlnJywgJ3dhaXQnKTsKKwlBTFRFUiBUQUJMRSB0ZXN0X2F1dG92YWMg U0VUIChhdXRvdmFjdXVtX2VuYWJsZWQgPSB0cnVlKTsKK30pOworCiskbm9kZS0+d2FpdF9mb3Jf ZXZlbnQoCisJJ2F1dG92YWN1dW0gd29ya2VyJywKKwknYXV0b3ZhY3V1bS1sZWFkZXItYmVmb3Jl LWluZGV4ZXMtcHJvY2Vzc2luZycKKyk7CisKKyRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywg cXF7CisJQUxURVIgU1lTVEVNIFNFVCBhdXRvdmFjdXVtX21heF9wYXJhbGxlbF93b3JrZXJzID0g MTsKKwlTRUxFQ1QgcGdfcmVsb2FkX2NvbmYoKTsKK30pOworCiskbm9kZS0+d2FpdF9mb3JfZXZl bnQoCisJJ2F1dG92YWN1dW0gbGF1bmNoZXInLAorCSdhdXRvdmFjdXVtLWxhdW5jaGVyLWFmdGVy LXJlbG9hZC1jb25maWcnCispOworCisjIFNpbmNlIDIgcGFyYWxsZWwgd29ya2VycyBhbHJlYWR5 IGxhdW5jaGVkIGFuZCB3aWxsIGJlIHJlbGVhc2VkIGluIHRoZSBmdXR1cmUsCisjIHdlIGFyZSBl eHBlY3RpbmcgdGhhdCA6CisjIDEpIG51bWJlciBvZiBmcmVlIHdvcmtlcnMgd2lsbCBiZSAnMCcg YWZ0ZXIgY29uZmlnIHJlbG9hZAorIyAyKSBudW1iZXIgb2YgZnJlZSB3b3JrZXJzIHdpbGwgYmUg JzEnIGFmdGVyIHJlbGVhc2luZyB3b3JrZXJzCisKKyMgQ2hlY2sgc3RhdGVtZW50ICgxKQorJG5v ZGUtPnBzcWwoJ3Bvc3RncmVzJywKKwkiU0VMRUNUIGdldF9wYXJhbGxlbF9hdXRvdmFjdXVtX2Zy ZWVfd29ya2VycygpOyIsCisJc3Rkb3V0ID0+IFwkcHNxbF9vdXQsCispOworaXMoJHBzcWxfb3V0 LCAwLAorCSdOdW1iZXIgb2YgZnJlZSBwYXJhbGxlbCB3b3JrZXJzIGlzIGNvbnNpc3RlbnQnKTsK KworJG5vZGUtPnNhZmVfcHNxbCgncG9zdGdyZXMnLCBxcXsKKwlTRUxFQ1QgaW5qZWN0aW9uX3Bv aW50c193YWtldXAoJ2F1dG92YWN1dW0tbGF1bmNoZXItYWZ0ZXItcmVsb2FkLWNvbmZpZycpOwor CVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX3dha2V1cCgnYXV0b3ZhY3V1bS1sZWFkZXItYmVmb3Jl LWluZGV4ZXMtcHJvY2Vzc2luZycpOworfSk7CisKKyMgV2FpdCB1bnRpbCB0aGUgZW5kIG9mIHBh cmFsbGVsIHByb2Nlc3NpbmcKK3dhaXRfZm9yX2F2X2xvZygkbm9kZSwKKwkJCQlxci9wYXJhbGxl bCBpbmRleCB2YWN1dW1cL2NsZWFudXA6IDIgd29ya2VycyB3ZXJlIHBsYW5uZWQsIC8gLgorCQkJ CXFyLzIgd29ya2VycyB3ZXJlIHJlc2VydmVkIGFuZCAyIHdvcmtlcnMgd2VyZSBsYXVuY2hlZCBp biB0b3RhbC8pOworCisjIENoZWNrIHN0YXRlbWVudCAoMikKKyRub2RlLT5wc3FsKCdwb3N0Z3Jl cycsCisJIlNFTEVDVCBnZXRfcGFyYWxsZWxfYXV0b3ZhY3V1bV9mcmVlX3dvcmtlcnMoKTsiLAor CXN0ZG91dCA9PiBcJHBzcWxfb3V0LAorKTsKK2lzKCRwc3FsX291dCwgMSwKKwknTnVtYmVyIG9m IGZyZWUgcGFyYWxsZWwgd29ya2VycyBpcyBjb25zaXN0ZW50Jyk7CisKKyMgQ2xlYW51cAorJG5v ZGUtPnNhZmVfcHNxbCgncG9zdGdyZXMnLCBxcXsKKwlTRUxFQ1QgaW5qZWN0aW9uX3BvaW50c19k ZXRhY2goJ2F1dG92YWN1dW0tbGVhZGVyLWJlZm9yZS1pbmRleGVzLXByb2Nlc3NpbmcnKTsKKwlT RUxFQ1QgaW5qZWN0aW9uX3BvaW50c19kZXRhY2goJ2F1dG92YWN1dW0tbGF1bmNoZXItYWZ0ZXIt cmVsb2FkLWNvbmZpZycpOworCUFMVEVSIFNZU1RFTSBTRVQgYXV0b3ZhY3V1bV9tYXhfcGFyYWxs ZWxfd29ya2VycyA9IDEwOworCVNFTEVDVCBwZ19yZWxvYWRfY29uZigpOworfSk7CisKKyMgVGVz dCA0OgorIyBXZSB3YW50IHBhcmFsbGVsIGF1dG92YWN1dW0gd29ya2VycyB0byBiZSByZWxlYXNl ZCBldmVuIGlmIGxlYWRlciBnZXRzIGFuCisjIGVycm9yLiBBdCBmaXJzdCwgc2ltdWxhdGUgc2l0 dWF0aW9uLCB3aGVuIGxlYWRlciBleGl0ZXMgZHVlIHRvIGFuIEVSUk9SLgorCitwcmVwYXJlX2Zv cl9uZXh0X3Rlc3QoJG5vZGUsIDQpOworCiskbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFx eworCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX2F0dGFjaCgnYXV0b3ZhY3V1bS1sZWFkZXItYmVm b3JlLWluZGV4ZXMtcHJvY2Vzc2luZycsICdlcnJvcicpOworCUFMVEVSIFRBQkxFIHRlc3RfYXV0 b3ZhYyBTRVQgKGF1dG92YWN1dW1fZW5hYmxlZCA9IHRydWUpOworfSk7CisKK3dhaXRfZm9yX2F2 X2xvZygkbm9kZSwKKwkJCQlxci9lcnJvciB0cmlnZ2VyZWQgZm9yIGluamVjdGlvbiBwb2ludCAv IC4KKwkJCQlxci9hdXRvdmFjdXVtLWxlYWRlci1iZWZvcmUtaW5kZXhlcy1wcm9jZXNzaW5nLyk7 CisKKyRub2RlLT5wc3FsKCdwb3N0Z3JlcycsCisJIlNFTEVDVCBnZXRfcGFyYWxsZWxfYXV0b3Zh Y3V1bV9mcmVlX3dvcmtlcnMoKTsiLAorCXN0ZG91dCA9PiBcJHBzcWxfb3V0LAorKTsKK2lzKCRw c3FsX291dCwgMTAsCisgICAnQWxsIHBhcmFsbGVsIHdvcmtlcnMgaGFzIGJlZW4gcmVsZWFzZWQg YnkgdGhlIGxlYWRlciBhZnRlciBFUlJPUicpOworCisjIENsZWFudXAKKyRub2RlLT5zYWZlX3Bz cWwoJ3Bvc3RncmVzJywgcXF7CisJU0VMRUNUIGluamVjdGlvbl9wb2ludHNfZGV0YWNoKCdhdXRv dmFjdXVtLWxlYWRlci1iZWZvcmUtaW5kZXhlcy1wcm9jZXNzaW5nJyk7Cit9KTsKKworIyBUZXN0 IDU6CisjIFNhbWUgYXMgYWJvdmUgdGVzdCwgYnV0IHNpbXVsYXRlIHNpdHVhdGlvbiwgd2hlbiBs ZWFkZXIgZXhpdGVzIGR1ZSB0byBGQVRBTC4KKworcHJlcGFyZV9mb3JfbmV4dF90ZXN0KCRub2Rl LCA1KTsKKworJG5vZGUtPnNhZmVfcHNxbCgncG9zdGdyZXMnLCBxcXsKKwlTRUxFQ1QgaW5qZWN0 aW9uX3BvaW50c19hdHRhY2goJ2F1dG92YWN1dW0tbGVhZGVyLWJlZm9yZS1pbmRleGVzLXByb2Nl c3NpbmcnLCAnd2FpdCcpOworCUFMVEVSIFRBQkxFIHRlc3RfYXV0b3ZhYyBTRVQgKGF1dG92YWN1 dW1fZW5hYmxlZCA9IHRydWUpOworfSk7CisKKyRub2RlLT53YWl0X2Zvcl9ldmVudCgKKwknYXV0 b3ZhY3V1bSB3b3JrZXInLAorCSdhdXRvdmFjdXVtLWxlYWRlci1iZWZvcmUtaW5kZXhlcy1wcm9j ZXNzaW5nJworKTsKKworbXkgJGF2X3BpZCA9ICRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywg cXF7CisJU0VMRUNUIHBpZCBGUk9NIHBnX3N0YXRfYWN0aXZpdHkKKwlXSEVSRSBiYWNrZW5kX3R5 cGUgPSAnYXV0b3ZhY3V1bSB3b3JrZXInCisJICBBTkQgd2FpdF9ldmVudCA9ICdhdXRvdmFjdXVt LWxlYWRlci1iZWZvcmUtaW5kZXhlcy1wcm9jZXNzaW5nJworCUxJTUlUIDE7Cit9KTsKKworIyBD cmVhdGUgcm9sZSB3aXRoIHBnX3NpZ25hbF9hdXRvdmFjdXVtX3dvcmtlciBmb3IgdGVybWluYXRp bmcgYXV0b3ZhY3V1bSB3b3JrZXIuCiskbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFxewor CUNSRUFURSBST0xFIHJlZ3Jlc3Nfd29ya2VyX3JvbGU7CisJR1JBTlQgcGdfc2lnbmFsX2F1dG92 YWN1dW1fd29ya2VyIFRPIHJlZ3Jlc3Nfd29ya2VyX3JvbGU7CisJU0VUIFJPTEUgcmVncmVzc193 b3JrZXJfcm9sZTsKK30pOworCiskbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFxeworCVNF TEVDVCBwZ190ZXJtaW5hdGVfYmFja2VuZCgnJGF2X3BpZCcpOworfSk7CisKK3dhaXRfZm9yX2F2 X2xvZygkbm9kZSwKKwkJCQlxci90ZXJtaW5hdGluZyBhdXRvdmFjdXVtIHByb2Nlc3MgZHVlIHRv IGFkbWluaXN0cmF0b3IgY29tbWFuZC8pOworCiskbm9kZS0+cHNxbCgncG9zdGdyZXMnLAorCSJT RUxFQ1QgZ2V0X3BhcmFsbGVsX2F1dG92YWN1dW1fZnJlZV93b3JrZXJzKCk7IiwKKwlzdGRvdXQg PT4gXCRwc3FsX291dCwKKyk7CitpcygkcHNxbF9vdXQsIDEwLAorCSdBbGwgcGFyYWxsZWwgd29y a2VycyBoYXMgYmVlbiByZWxlYXNlZCBieSB0aGUgbGVhZGVyIGFmdGVyIEZBVEFMJyk7CisKKyMg Q2xlYW51cAorJG5vZGUtPnNhZmVfcHNxbCgncG9zdGdyZXMnLCBxcXsKKwlTRUxFQ1QgaW5qZWN0 aW9uX3BvaW50c19kZXRhY2goJ2F1dG92YWN1dW0tbGVhZGVyLWJlZm9yZS1pbmRleGVzLXByb2Nl c3NpbmcnKTsKK30pOworCiskbm9kZS0+c3RvcDsKK2RvbmVfdGVzdGluZygpOwpkaWZmIC0tZ2l0 IGEvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2F1dG92YWN1dW0vdGVzdF9hdXRvdmFjdXVtLS0xLjAu c3FsIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2F1dG92YWN1dW0vdGVzdF9hdXRvdmFjdXVtLS0x LjAuc3FsCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi5lNTY0NmUwZGVm NQotLS0gL2Rldi9udWxsCisrKyBiL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVtL3Rl c3RfYXV0b3ZhY3V1bS0tMS4wLnNxbApAQCAtMCwwICsxLDEyIEBACisvKiBzcmMvdGVzdC9tb2R1 bGVzL3Rlc3RfYXV0b3ZhY3V1bS90ZXN0X2F1dG92YWN1dW0tLTEuMC5zcWwgKi8KKworLS0gY29t cGxhaW4gaWYgc2NyaXB0IGlzIHNvdXJjZWQgaW4gcHNxbCwgcmF0aGVyIHRoYW4gdmlhIENSRUFU RSBFWFRFTlNJT04KK1xlY2hvIFVzZSAiQ1JFQVRFIEVYVEVOU0lPTiB0ZXN0X2F1dG92YWN1dW0i IHRvIGxvYWQgdGhpcyBmaWxlLiBccXVpdAorCisvKgorICogRnVuY3Rpb25zIGZvciBleHBlY3Rp bmcgc2hhcmVkIGF1dG92YWN1dW0gc3RhdGUKKyAqLworCitDUkVBVEUgRlVOQ1RJT04gZ2V0X3Bh cmFsbGVsX2F1dG92YWN1dW1fZnJlZV93b3JrZXJzKCkKK1JFVFVSTlMgSU5URUdFUiBTVFJJQ1QK K0FTICdNT0RVTEVfUEFUSE5BTUUnIExBTkdVQUdFIEM7CmRpZmYgLS1naXQgYS9zcmMvdGVzdC9t b2R1bGVzL3Rlc3RfYXV0b3ZhY3V1bS90ZXN0X2F1dG92YWN1dW0uYyBiL3NyYy90ZXN0L21vZHVs ZXMvdGVzdF9hdXRvdmFjdXVtL3Rlc3RfYXV0b3ZhY3V1bS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwLi45NTk2MjljNzY4NQotLS0gL2Rldi9udWxsCisrKyBiL3NyYy90 ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVtL3Rlc3RfYXV0b3ZhY3V1bS5jCkBAIC0wLDAgKzEs NDEgQEAKKy8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICoKKyAqIHRlc3RfYXV0b3ZhY3V1bS5jCisgKgkJ SGVscGVycyB0byB3cml0ZSB0ZXN0cyBmb3IgcGFyYWxsZWwgYXV0b3ZhY3V1bQorICoKKyAqIENv cHlyaWdodCAoYykgMjAyMC0yMDI1LCBQb3N0Z3JlU1FMIEdsb2JhbCBEZXZlbG9wbWVudCBHcm91 cAorICoKKyAqIElERU5USUZJQ0FUSU9OCisgKgkgIHNyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRv dmFjdXVtL3Rlc3RfYXV0b3ZhY3V1bS5jCisgKgorICotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgKi8KKwor I2luY2x1ZGUgInBvc3RncmVzLmgiCisKKyNpbmNsdWRlICJjb21tYW5kcy92YWN1dW0uaCIKKyNp bmNsdWRlICJmbWdyLmgiCisjaW5jbHVkZSAibWlzY2FkbWluLmgiCisjaW5jbHVkZSAicG9zdG1h c3Rlci9hdXRvdmFjdXVtLmgiCisjaW5jbHVkZSAic3RvcmFnZS9zaG1lbS5oIgorI2luY2x1ZGUg InN0b3JhZ2UvaXBjLmgiCisjaW5jbHVkZSAic3RvcmFnZS9sd2xvY2suaCIKKyNpbmNsdWRlICJ1 dGlscy9idWlsdGlucy5oIgorI2luY2x1ZGUgInV0aWxzL2luamVjdGlvbl9wb2ludC5oIgorCitQ R19NT0RVTEVfTUFHSUM7CisKK1BHX0ZVTkNUSU9OX0lORk9fVjEoZ2V0X3BhcmFsbGVsX2F1dG92 YWN1dW1fZnJlZV93b3JrZXJzKTsKK0RhdHVtCitnZXRfcGFyYWxsZWxfYXV0b3ZhY3V1bV9mcmVl X3dvcmtlcnMoUEdfRlVOQ1RJT05fQVJHUykKK3sKKwl1aW50MzIJCW5mcmVlX3dvcmtlcnM7CisK KyNpZm5kZWYgVVNFX0lOSkVDVElPTl9QT0lOVFMKKwllcmVwb3J0KEVSUk9SLCBlcnJtc2coImlu amVjdGlvbiBwb2ludHMgbm90IHN1cHBvcnRlZCIpKTsKKyNlbmRpZgorCisJbmZyZWVfd29ya2Vy cyA9IEF1dG9WYWN1dW1HZXRGcmVlUGFyYWxsZWxXb3JrZXJzKCk7CisKKwlQR19SRVRVUk5fVUlO VDMyKG5mcmVlX3dvcmtlcnMpOworfQpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0 X2F1dG92YWN1dW0vdGVzdF9hdXRvdmFjdXVtLmNvbnRyb2wgYi9zcmMvdGVzdC9tb2R1bGVzL3Rl c3RfYXV0b3ZhY3V1bS90ZXN0X2F1dG92YWN1dW0uY29udHJvbApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwMDAwMC4uMWI3ZmFkMjU4ZjAKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMv dGVzdC9tb2R1bGVzL3Rlc3RfYXV0b3ZhY3V1bS90ZXN0X2F1dG92YWN1dW0uY29udHJvbApAQCAt MCwwICsxLDMgQEAKK2NvbW1lbnQgPSAnVGVzdCBjb2RlIGZvciBwYXJhbGxlbCBhdXRvdmFjdXVt JworZGVmYXVsdF92ZXJzaW9uID0gJzEuMCcKK21vZHVsZV9wYXRobmFtZSA9ICckbGliZGlyL3Rl c3RfYXV0b3ZhY3V1bScKLS0gCjIuNDMuMAoK --0000000000004477530648969c39 Content-Type: text/x-patch; charset="US-ASCII"; name="v20-0001-Parallel-autovacuum.patch" Content-Disposition: attachment; filename="v20-0001-Parallel-autovacuum.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mkifer0m4 RnJvbSBiYmI1ZGY5NjQ1ZGRlNzJmY2JiNDVmN2FlZjE0MTAwOGUwMzIyNmZhIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBTdW4sIDIzIE5vdiAyMDI1IDAxOjAzOjI0ICswNzAwClN1YmplY3Q6IFtQQVRD SCB2MjAgMS81XSBQYXJhbGxlbCBhdXRvdmFjdXVtCgotLS0KIHNyYy9iYWNrZW5kL2FjY2Vzcy9j b21tb24vcmVsb3B0aW9ucy5jICAgICAgICB8ICAxMSArKwogc3JjL2JhY2tlbmQvY29tbWFuZHMv dmFjdXVtcGFyYWxsZWwuYyAgICAgICAgIHwgIDM5ICsrKy0KIHNyYy9iYWNrZW5kL3Bvc3RtYXN0 ZXIvYXV0b3ZhY3V1bS5jICAgICAgICAgICB8IDE3MiArKysrKysrKysrKysrKysrKy0KIHNyYy9i YWNrZW5kL3V0aWxzL2luaXQvZ2xvYmFscy5jICAgICAgICAgICAgICB8ICAgMSArCiBzcmMvYmFj a2VuZC91dGlscy9taXNjL2d1Yy5jICAgICAgICAgICAgICAgICAgfCAgIDggKy0KIHNyYy9iYWNr ZW5kL3V0aWxzL21pc2MvZ3VjX3BhcmFtZXRlcnMuZGF0ICAgICB8ICAgOCArCiBzcmMvYmFja2Vu ZC91dGlscy9taXNjL3Bvc3RncmVzcWwuY29uZi5zYW1wbGUgfCAgIDEgKwogc3JjL2Jpbi9wc3Fs L3RhYi1jb21wbGV0ZS5pbi5jICAgICAgICAgICAgICAgIHwgICAxICsKIHNyYy9pbmNsdWRlL21p c2NhZG1pbi5oICAgICAgICAgICAgICAgICAgICAgICB8ICAgMSArCiBzcmMvaW5jbHVkZS9wb3N0 bWFzdGVyL2F1dG92YWN1dW0uaCAgICAgICAgICAgfCAgIDUgKwogc3JjL2luY2x1ZGUvdXRpbHMv cmVsLmggICAgICAgICAgICAgICAgICAgICAgIHwgICA3ICsKIDExIGZpbGVzIGNoYW5nZWQsIDI0 NCBpbnNlcnRpb25zKCspLCAxMCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zcmMvYmFja2Vu ZC9hY2Nlc3MvY29tbW9uL3JlbG9wdGlvbnMuYyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9jb21tb24v cmVsb3B0aW9ucy5jCmluZGV4IDBiODNmOThlZDVmLi42OTJhYzQ2NzMzZSAxMDA2NDQKLS0tIGEv c3JjL2JhY2tlbmQvYWNjZXNzL2NvbW1vbi9yZWxvcHRpb25zLmMKKysrIGIvc3JjL2JhY2tlbmQv YWNjZXNzL2NvbW1vbi9yZWxvcHRpb25zLmMKQEAgLTIyMiw2ICsyMjIsMTUgQEAgc3RhdGljIHJl bG9wdF9pbnQgaW50UmVsT3B0c1tdID0KIAkJfSwKIAkJU1BHSVNUX0RFRkFVTFRfRklMTEZBQ1RP UiwgU1BHSVNUX01JTl9GSUxMRkFDVE9SLCAxMDAKIAl9LAorCXsKKwkJeworCQkJImF1dG92YWN1 dW1fcGFyYWxsZWxfd29ya2VycyIsCisJCQkiTWF4aW11bSBudW1iZXIgb2YgcGFyYWxsZWwgYXV0 b3ZhY3V1bSB3b3JrZXJzIHRoYXQgY2FuIGJlIHVzZWQgZm9yIHByb2Nlc3NpbmcgdGhpcyB0YWJs ZS4iLAorCQkJUkVMT1BUX0tJTkRfSEVBUCwKKwkJCVNoYXJlVXBkYXRlRXhjbHVzaXZlTG9jawor CQl9LAorCQktMSwgLTEsIDEwMjQKKwl9LAogCXsKIAkJewogCQkJImF1dG92YWN1dW1fdmFjdXVt X3RocmVzaG9sZCIsCkBAIC0xODgxLDYgKzE4OTAsOCBAQCBkZWZhdWx0X3JlbG9wdGlvbnMoRGF0 dW0gcmVsb3B0aW9ucywgYm9vbCB2YWxpZGF0ZSwgcmVsb3B0X2tpbmQga2luZCkKIAkJeyJmaWxs ZmFjdG9yIiwgUkVMT1BUX1RZUEVfSU5ULCBvZmZzZXRvZihTdGRSZE9wdGlvbnMsIGZpbGxmYWN0 b3IpfSwKIAkJeyJhdXRvdmFjdXVtX2VuYWJsZWQiLCBSRUxPUFRfVFlQRV9CT09MLAogCQlvZmZz ZXRvZihTdGRSZE9wdGlvbnMsIGF1dG92YWN1dW0pICsgb2Zmc2V0b2YoQXV0b1ZhY09wdHMsIGVu YWJsZWQpfSwKKwkJeyJhdXRvdmFjdXVtX3BhcmFsbGVsX3dvcmtlcnMiLCBSRUxPUFRfVFlQRV9J TlQsCisJCW9mZnNldG9mKFN0ZFJkT3B0aW9ucywgYXV0b3ZhY3V1bSkgKyBvZmZzZXRvZihBdXRv VmFjT3B0cywgYXV0b3ZhY3V1bV9wYXJhbGxlbF93b3JrZXJzKX0sCiAJCXsiYXV0b3ZhY3V1bV92 YWN1dW1fdGhyZXNob2xkIiwgUkVMT1BUX1RZUEVfSU5ULAogCQlvZmZzZXRvZihTdGRSZE9wdGlv bnMsIGF1dG92YWN1dW0pICsgb2Zmc2V0b2YoQXV0b1ZhY09wdHMsIHZhY3V1bV90aHJlc2hvbGQp fSwKIAkJeyJhdXRvdmFjdXVtX3ZhY3V1bV9tYXhfdGhyZXNob2xkIiwgUkVMT1BUX1RZUEVfSU5U LApkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYyBiL3Ny Yy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMKaW5kZXggYzNiM2M5ZWEyMWEuLjFl MzViODJhZWFmIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxl bC5jCisrKyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMKQEAgLTEsNyAr MSw5IEBACiAvKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KICAqCiAgKiB2YWN1dW1wYXJhbGxlbC5jCi0gKgkg IFN1cHBvcnQgcm91dGluZXMgZm9yIHBhcmFsbGVsIHZhY3V1bSBleGVjdXRpb24uCisgKgkgIFN1 cHBvcnQgcm91dGluZXMgZm9yIHBhcmFsbGVsIHZhY3V1bSBhbmQgYXV0b3ZhY3V1bSBleGVjdXRp b24uIEluIHRoZQorICoJICBjb21tZW50cyBiZWxvdywgdGhlIHdvcmQgInZhY3V1bSIgd2lsbCBy ZWZlciB0byBib3RoIHZhY3V1bSBhbmQKKyAqCSAgYXV0b3ZhY3V1bS4KICAqCiAgKiBUaGlzIGZp bGUgY29udGFpbnMgcm91dGluZXMgdGhhdCBhcmUgaW50ZW5kZWQgdG8gc3VwcG9ydCBzZXR0aW5n IHVwLCB1c2luZywKICAqIGFuZCB0ZWFyaW5nIGRvd24gYSBQYXJhbGxlbFZhY3V1bVN0YXRlLgpA QCAtMzQsNiArMzYsNyBAQAogI2luY2x1ZGUgImV4ZWN1dG9yL2luc3RydW1lbnQuaCIKICNpbmNs dWRlICJvcHRpbWl6ZXIvcGF0aHMuaCIKICNpbmNsdWRlICJwZ3N0YXQuaCIKKyNpbmNsdWRlICJw b3N0bWFzdGVyL2F1dG92YWN1dW0uaCIKICNpbmNsdWRlICJzdG9yYWdlL2J1Zm1nci5oIgogI2lu Y2x1ZGUgInRjb3AvdGNvcHByb3QuaCIKICNpbmNsdWRlICJ1dGlscy9sc3lzY2FjaGUuaCIKQEAg LTM3Myw4ICszNzYsOSBAQCBwYXJhbGxlbF92YWN1dW1faW5pdChSZWxhdGlvbiByZWwsIFJlbGF0 aW9uICppbmRyZWxzLCBpbnQgbmluZGV4ZXMsCiAJc2hhcmVkLT5xdWVyeWlkID0gcGdzdGF0X2dl dF9teV9xdWVyeV9pZCgpOwogCXNoYXJlZC0+bWFpbnRlbmFuY2Vfd29ya19tZW1fd29ya2VyID0K IAkJKG5pbmRleGVzX213bSA+IDApID8KLQkJbWFpbnRlbmFuY2Vfd29ya19tZW0gLyBNaW4ocGFy YWxsZWxfd29ya2VycywgbmluZGV4ZXNfbXdtKSA6Ci0JCW1haW50ZW5hbmNlX3dvcmtfbWVtOwor CQl2YWNfd29ya19tZW0gLyBNaW4ocGFyYWxsZWxfd29ya2VycywgbmluZGV4ZXNfbXdtKSA6CisJ CXZhY193b3JrX21lbTsKKwogCXNoYXJlZC0+ZGVhZF9pdGVtc19pbmZvLm1heF9ieXRlcyA9IHZh Y193b3JrX21lbSAqIChzaXplX3QpIDEwMjQ7CiAKIAkvKiBQcmVwYXJlIERTQSBzcGFjZSBmb3Ig ZGVhZCBpdGVtcyAqLwpAQCAtNTUzLDEyICs1NTcsMTcgQEAgcGFyYWxsZWxfdmFjdXVtX2NvbXB1 dGVfd29ya2VycyhSZWxhdGlvbiAqaW5kcmVscywgaW50IG5pbmRleGVzLCBpbnQgbnJlcXVlc3Rl ZCwKIAlpbnQJCQluaW5kZXhlc19wYXJhbGxlbF9idWxrZGVsID0gMDsKIAlpbnQJCQluaW5kZXhl c19wYXJhbGxlbF9jbGVhbnVwID0gMDsKIAlpbnQJCQlwYXJhbGxlbF93b3JrZXJzOworCWludAkJ CW1heF93b3JrZXJzOworCisJbWF4X3dvcmtlcnMgPSBBbUF1dG9WYWN1dW1Xb3JrZXJQcm9jZXNz KCkgPworCQlhdXRvdmFjdXVtX21heF9wYXJhbGxlbF93b3JrZXJzIDoKKwkJbWF4X3BhcmFsbGVs X21haW50ZW5hbmNlX3dvcmtlcnM7CiAKIAkvKgogCSAqIFdlIGRvbid0IGFsbG93IHBlcmZvcm1p bmcgcGFyYWxsZWwgb3BlcmF0aW9uIGluIHN0YW5kYWxvbmUgYmFja2VuZCBvcgogCSAqIHdoZW4g cGFyYWxsZWxpc20gaXMgZGlzYWJsZWQuCiAJICovCi0JaWYgKCFJc1VuZGVyUG9zdG1hc3RlciB8 fCBtYXhfcGFyYWxsZWxfbWFpbnRlbmFuY2Vfd29ya2VycyA9PSAwKQorCWlmICghSXNVbmRlclBv c3RtYXN0ZXIgfHwgbWF4X3dvcmtlcnMgPT0gMCkKIAkJcmV0dXJuIDA7CiAKIAkvKgpAQCAtNTk3 LDggKzYwNiw4IEBAIHBhcmFsbGVsX3ZhY3V1bV9jb21wdXRlX3dvcmtlcnMoUmVsYXRpb24gKmlu ZHJlbHMsIGludCBuaW5kZXhlcywgaW50IG5yZXF1ZXN0ZWQsCiAJcGFyYWxsZWxfd29ya2VycyA9 IChucmVxdWVzdGVkID4gMCkgPwogCQlNaW4obnJlcXVlc3RlZCwgbmluZGV4ZXNfcGFyYWxsZWwp IDogbmluZGV4ZXNfcGFyYWxsZWw7CiAKLQkvKiBDYXAgYnkgbWF4X3BhcmFsbGVsX21haW50ZW5h bmNlX3dvcmtlcnMgKi8KLQlwYXJhbGxlbF93b3JrZXJzID0gTWluKHBhcmFsbGVsX3dvcmtlcnMs IG1heF9wYXJhbGxlbF9tYWludGVuYW5jZV93b3JrZXJzKTsKKwkvKiBDYXAgYnkgR1VDIHZhcmlh YmxlICovCisJcGFyYWxsZWxfd29ya2VycyA9IE1pbihwYXJhbGxlbF93b3JrZXJzLCBtYXhfd29y a2Vycyk7CiAKIAlyZXR1cm4gcGFyYWxsZWxfd29ya2VyczsKIH0KQEAgLTY0Niw2ICs2NTUsMTMg QEAgcGFyYWxsZWxfdmFjdXVtX3Byb2Nlc3NfYWxsX2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0 ZSAqcHZzLCBpbnQgbnVtX2luZGV4X3NjYW4KIAkgKi8KIAlud29ya2VycyA9IE1pbihud29ya2Vy cywgcHZzLT5wY3h0LT5ud29ya2Vycyk7CiAKKwkvKgorCSAqIFJlc2VydmUgd29ya2VycyBpbiBh dXRvdmFjdXVtIGdsb2JhbCBzdGF0ZS4gTm90ZSB0aGF0IHdlIG1heSBiZSBnaXZlbgorCSAqIGZl d2VyIHdvcmtlcnMgdGhhbiB3ZSByZXF1ZXN0ZWQuCisJICovCisJaWYgKEFtQXV0b1ZhY3V1bVdv cmtlclByb2Nlc3MoKSAmJiBud29ya2VycyA+IDApCisJCUF1dG9WYWN1dW1SZXNlcnZlUGFyYWxs ZWxXb3JrZXJzKCZud29ya2Vycyk7CisKIAkvKgogCSAqIFNldCBpbmRleCB2YWN1dW0gc3RhdHVz IGFuZCBtYXJrIHdoZXRoZXIgcGFyYWxsZWwgdmFjdXVtIHdvcmtlciBjYW4KIAkgKiBwcm9jZXNz IGl0LgpAQCAtNjkwLDYgKzcwNiwxMyBAQCBwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19hbGxfaW5k ZXhlcyhQYXJhbGxlbFZhY3V1bVN0YXRlICpwdnMsIGludCBudW1faW5kZXhfc2NhbgogCiAJCUxh dW5jaFBhcmFsbGVsV29ya2VycyhwdnMtPnBjeHQpOwogCisJCS8qCisJCSAqIFRlbGwgYXV0b3Zh Y3V1bSB0aGF0IHdlIGNvdWxkIG5vdCBsYXVuY2ggYWxsIHRoZSBwcmV2aW91c2x5CisJCSAqIHJl c2VydmVkIHdvcmtlcnMuCisJCSAqLworCQlpZiAoQW1BdXRvVmFjdXVtV29ya2VyUHJvY2Vzcygp ICYmIHB2cy0+cGN4dC0+bndvcmtlcnNfbGF1bmNoZWQgPCBud29ya2VycykKKwkJCUF1dG9WYWN1 dW1SZWxlYXNlUGFyYWxsZWxXb3JrZXJzKG53b3JrZXJzIC0gcHZzLT5wY3h0LT5ud29ya2Vyc19s YXVuY2hlZCk7CisKIAkJaWYgKHB2cy0+cGN4dC0+bndvcmtlcnNfbGF1bmNoZWQgPiAwKQogCQl7 CiAJCQkvKgpAQCAtNzM4LDYgKzc2MSwxMCBAQCBwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19hbGxf aW5kZXhlcyhQYXJhbGxlbFZhY3V1bVN0YXRlICpwdnMsIGludCBudW1faW5kZXhfc2NhbgogCiAJ CWZvciAoaW50IGkgPSAwOyBpIDwgcHZzLT5wY3h0LT5ud29ya2Vyc19sYXVuY2hlZDsgaSsrKQog CQkJSW5zdHJBY2N1bVBhcmFsbGVsUXVlcnkoJnB2cy0+YnVmZmVyX3VzYWdlW2ldLCAmcHZzLT53 YWxfdXNhZ2VbaV0pOworCisJCS8qIFJlbGVhc2UgYWxsIHRoZSByZXNlcnZlZCBwYXJhbGxlbCB3 b3JrZXJzIGZvciBhdXRvdmFjdXVtICovCisJCWlmIChBbUF1dG9WYWN1dW1Xb3JrZXJQcm9jZXNz KCkgJiYgcHZzLT5wY3h0LT5ud29ya2Vyc19sYXVuY2hlZCA+IDApCisJCQlBdXRvVmFjdXVtUmVs ZWFzZUFsbFBhcmFsbGVsV29ya2VycygpOwogCX0KIAogCS8qCmRpZmYgLS1naXQgYS9zcmMvYmFj a2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYyBiL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0 b3ZhY3V1bS5jCmluZGV4IDIyMzc5ZGUxZTMxLi5kZGQ3YmJkZjUyMCAxMDA2NDQKLS0tIGEvc3Jj L2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMKKysrIGIvc3JjL2JhY2tlbmQvcG9zdG1h c3Rlci9hdXRvdmFjdXVtLmMKQEAgLTE1MSw2ICsxNTEsMTMgQEAgaW50CQkJTG9nX2F1dG9hbmFs eXplX21pbl9kdXJhdGlvbiA9IDYwMDAwMDsKIHN0YXRpYyBkb3VibGUgYXZfc3RvcmFnZV9wYXJh bV9jb3N0X2RlbGF5ID0gLTE7CiBzdGF0aWMgaW50CWF2X3N0b3JhZ2VfcGFyYW1fY29zdF9saW1p dCA9IC0xOwogCisvKgorICogVHJhY2tzIHRoZSBudW1iZXIgb2YgcGFyYWxsZWwgd29ya2VycyBj dXJyZW50bHkgcmVzZXJ2ZWQgYnkgdGhlCisgKiBhdXRvdmFjdXVtIHdvcmtlci4gVGhpcyBpcyBu b24temVybyBvbmx5IGZvciB0aGUgcGFyYWxsZWwgYXV0b3ZhY3V1bQorICogbGVhZGVyIHByb2Nl c3MuCisgKi8KK3N0YXRpYyBpbnQJYXZfbndvcmtlcnNfcmVzZXJ2ZWQgPSAwOworCiAvKiBGbGFn cyBzZXQgYnkgc2lnbmFsIGhhbmRsZXJzICovCiBzdGF0aWMgdm9sYXRpbGUgc2lnX2F0b21pY190 IGdvdF9TSUdVU1IyID0gZmFsc2U7CiAKQEAgLTI4NSw2ICsyOTIsOCBAQCB0eXBlZGVmIHN0cnVj dCBBdXRvVmFjdXVtV29ya0l0ZW0KICAqIGF2X3dvcmtJdGVtcwkJd29yayBpdGVtIGFycmF5CiAg KiBhdl9ud29ya2Vyc0ZvckJhbGFuY2UgdGhlIG51bWJlciBvZiBhdXRvdmFjdXVtIHdvcmtlcnMg dG8gdXNlIHdoZW4KICAqIAkJCQkJY2FsY3VsYXRpbmcgdGhlIHBlciB3b3JrZXIgY29zdCBsaW1p dAorICogYXZfZnJlZVBhcmFsbGVsV29ya2VycyB0aGUgbnVtYmVyIG9mIGZyZWUgcGFyYWxsZWwg YXV0b3ZhY3V1bSB3b3JrZXJzCisgKiBhdl9tYXhQYXJhbGxlbFdvcmtlcnMgdGhlIG1heGltdW0g bnVtYmVyIG9mIHBhcmFsbGVsIGF1dG92YWN1dW0gd29ya2VycwogICoKICAqIFRoaXMgc3RydWN0 IGlzIHByb3RlY3RlZCBieSBBdXRvdmFjdXVtTG9jaywgZXhjZXB0IGZvciBhdl9zaWduYWwgYW5k IHBhcnRzCiAgKiBvZiB0aGUgd29ya2VyIGxpc3QgKHNlZSBhYm92ZSkuCkBAIC0yOTksNiArMzA4 LDggQEAgdHlwZWRlZiBzdHJ1Y3QKIAlXb3JrZXJJbmZvCWF2X3N0YXJ0aW5nV29ya2VyOwogCUF1 dG9WYWN1dW1Xb3JrSXRlbSBhdl93b3JrSXRlbXNbTlVNX1dPUktJVEVNU107CiAJcGdfYXRvbWlj X3VpbnQzMiBhdl9ud29ya2Vyc0ZvckJhbGFuY2U7CisJdWludDMyCQlhdl9mcmVlUGFyYWxsZWxX b3JrZXJzOworCXVpbnQzMgkJYXZfbWF4UGFyYWxsZWxXb3JrZXJzOwogfSBBdXRvVmFjdXVtU2ht ZW1TdHJ1Y3Q7CiAKIHN0YXRpYyBBdXRvVmFjdXVtU2htZW1TdHJ1Y3QgKkF1dG9WYWN1dW1TaG1l bTsKQEAgLTM2MSw2ICszNzIsNyBAQCBzdGF0aWMgdm9pZCBhdXRvdmFjX3JlcG9ydF93b3JraXRl bShBdXRvVmFjdXVtV29ya0l0ZW0gKndvcmtpdGVtLAogc3RhdGljIHZvaWQgYXZsX3NpZ3VzcjJf aGFuZGxlcihTSUdOQUxfQVJHUyk7CiBzdGF0aWMgYm9vbCBhdl93b3JrZXJfYXZhaWxhYmxlKHZv aWQpOwogc3RhdGljIHZvaWQgY2hlY2tfYXZfd29ya2VyX2d1Y3Modm9pZCk7CitzdGF0aWMgdm9p ZCBhZGp1c3RfZnJlZV9wYXJhbGxlbF93b3JrZXJzKGludCBwcmV2X21heF9wYXJhbGxlbF93b3Jr ZXJzKTsKIAogCiAKQEAgLTc2MCw2ICs3NzIsOCBAQCBQcm9jZXNzQXV0b1ZhY0xhdW5jaGVySW50 ZXJydXB0cyh2b2lkKQogCWlmIChDb25maWdSZWxvYWRQZW5kaW5nKQogCXsKIAkJaW50CQkJYXV0 b3ZhY3V1bV9tYXhfd29ya2Vyc19wcmV2ID0gYXV0b3ZhY3V1bV9tYXhfd29ya2VyczsKKwkJaW50 CQkJYXV0b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2Vyc19wcmV2ID0KKwkJCWF1dG92YWN1dW1f bWF4X3BhcmFsbGVsX3dvcmtlcnM7CiAKIAkJQ29uZmlnUmVsb2FkUGVuZGluZyA9IGZhbHNlOwog CQlQcm9jZXNzQ29uZmlnRmlsZShQR0NfU0lHSFVQKTsKQEAgLTc3Niw2ICs3OTAsMTUgQEAgUHJv Y2Vzc0F1dG9WYWNMYXVuY2hlckludGVycnVwdHModm9pZCkKIAkJaWYgKGF1dG92YWN1dW1fbWF4 X3dvcmtlcnNfcHJldiAhPSBhdXRvdmFjdXVtX21heF93b3JrZXJzKQogCQkJY2hlY2tfYXZfd29y a2VyX2d1Y3MoKTsKIAorCQkvKgorCQkgKiBJZiBhdXRvdmFjdXVtX21heF9wYXJhbGxlbF93b3Jr ZXJzIGNoYW5nZWQsIHdlIG11c3QgdGFrZSBjYXJlIG9mCisJCSAqIHRoZSBjb3JyZWN0IHZhbHVl IG9mIGF2YWlsYWJsZSBwYXJhbGxlbCBhdXRvdmFjdXVtIHdvcmtlcnMgaW4KKwkJICogc2htZW0u CisJCSAqLworCQlpZiAoYXV0b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2Vyc19wcmV2ICE9CisJ CQlhdXRvdmFjdXVtX21heF9wYXJhbGxlbF93b3JrZXJzKQorCQkJYWRqdXN0X2ZyZWVfcGFyYWxs ZWxfd29ya2VycyhhdXRvdmFjdXVtX21heF9wYXJhbGxlbF93b3JrZXJzX3ByZXYpOworCiAJCS8q IHJlYnVpbGQgdGhlIGxpc3QgaW4gY2FzZSB0aGUgbmFwdGltZSBjaGFuZ2VkICovCiAJCXJlYnVp bGRfZGF0YWJhc2VfbGlzdChJbnZhbGlkT2lkKTsKIAl9CkBAIC0xMzgwLDYgKzE0MDMsMTYgQEAg YXZsX3NpZ3VzcjJfaGFuZGxlcihTSUdOQUxfQVJHUykKICAqCQkJCQkgIEFVVE9WQUNVVU0gV09S S0VSIENPREUKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKi8KIAorLyoKKyAqIE1ha2Ugc3VyZSB0aGF0IGFsbCByZXNl cnZlZCB3b3JrZXJzIGFyZSByZWxlYXNlZCwgZXZlbiBpZiBwYXJhbGxlbAorICogYXV0b3ZhY3V1 bSBsZWFkZXIgaXMgZmluaXNoaW5nIGR1ZSB0byBGQVRBTCBlcnJvci4KKyAqLworc3RhdGljIHZv aWQKK2F1dG92YWN1dW1fd29ya2VyX2JlZm9yZV9zaG1lbV9leGl0KGludCBjb2RlLCBEYXR1bSBh cmcpCit7CisJQXV0b1ZhY3V1bVJlbGVhc2VBbGxQYXJhbGxlbFdvcmtlcnMoKTsKK30KKwogLyoK ICAqIE1haW4gZW50cnkgcG9pbnQgZm9yIGF1dG92YWN1dW0gd29ya2VyIHByb2Nlc3Nlcy4KICAq LwpAQCAtMjI3Nyw2ICsyMzEwLDEyIEBAIGRvX2F1dG92YWN1dW0odm9pZCkKIAkJCQkJCQkJCQkg ICJBdXRvdmFjdXVtIFBvcnRhbCIsCiAJCQkJCQkJCQkJICBBTExPQ1NFVF9ERUZBVUxUX1NJWkVT KTsKIAorCS8qCisJICogUGFyYWxsZWwgYXV0b3ZhY3V1bSBjYW4gcmVzZXJ2ZSBwYXJhbGxlbCB3 b3JrZXJzLiBNYWtlIHN1cmUgdGhhdCBhbGwKKwkgKiByZXNlcnZlZCB3b3JrZXJzIGFyZSByZWxl YXNlZCBldmVuIGFmdGVyIEZBVEFMIGVycm9yLgorCSAqLworCWJlZm9yZV9zaG1lbV9leGl0KGF1 dG92YWN1dW1fd29ya2VyX2JlZm9yZV9zaG1lbV9leGl0LCAwKTsKKwogCS8qCiAJICogUGVyZm9y bSBvcGVyYXRpb25zIG9uIGNvbGxlY3RlZCB0YWJsZXMuCiAJICovCkBAIC0yNDU4LDYgKzI0OTcs MTIgQEAgZG9fYXV0b3ZhY3V1bSh2b2lkKQogCQl9CiAJCVBHX0NBVENIKCk7CiAJCXsKKwkJCS8q CisJCQkgKiBQYXJhbGxlbCBhdXRvdmFjdXVtIGNhbiByZXNlcnZlIHBhcmFsbGVsIHdvcmtlcnMu IE1ha2Ugc3VyZQorCQkJICogdGhhdCBhbGwgcmVzZXJ2ZWQgd29ya2VycyBhcmUgcmVsZWFzZWQu CisJCQkgKi8KKwkJCUF1dG9WYWN1dW1SZWxlYXNlQWxsUGFyYWxsZWxXb3JrZXJzKCk7CisKIAkJ CS8qCiAJCQkgKiBBYm9ydCB0aGUgdHJhbnNhY3Rpb24sIHN0YXJ0IGEgbmV3IG9uZSwgYW5kIHBy b2NlZWQgd2l0aCB0aGUKIAkJCSAqIG5leHQgdGFibGUgaW4gb3VyIGxpc3QuCkBAIC0yODU4LDgg KzI5MDMsMTIgQEAgdGFibGVfcmVjaGVja19hdXRvdmFjKE9pZCByZWxpZCwgSFRBQiAqdGFibGVf dG9hc3RfbWFwLAogCQkgKi8KIAkJdGFiLT5hdF9wYXJhbXMuaW5kZXhfY2xlYW51cCA9IFZBQ09Q VFZBTFVFX1VOU1BFQ0lGSUVEOwogCQl0YWItPmF0X3BhcmFtcy50cnVuY2F0ZSA9IFZBQ09QVFZB TFVFX1VOU1BFQ0lGSUVEOwotCQkvKiBBcyBvZiBub3csIHdlIGRvbid0IHN1cHBvcnQgcGFyYWxs ZWwgdmFjdXVtIGZvciBhdXRvdmFjdXVtICovCi0JCXRhYi0+YXRfcGFyYW1zLm53b3JrZXJzID0g LTE7CisKKwkJLyogRGVjaWRlIHdoZXRoZXIgd2UgbmVlZCB0byBwcm9jZXNzIGluZGV4ZXMgb2Yg dGFibGUgaW4gcGFyYWxsZWwuICovCisJCXRhYi0+YXRfcGFyYW1zLm53b3JrZXJzID0gYXZvcHRz CisJCQk/IGF2b3B0cy0+YXV0b3ZhY3V1bV9wYXJhbGxlbF93b3JrZXJzCisJCQk6IC0xOworCiAJ CXRhYi0+YXRfcGFyYW1zLmZyZWV6ZV9taW5fYWdlID0gZnJlZXplX21pbl9hZ2U7CiAJCXRhYi0+ YXRfcGFyYW1zLmZyZWV6ZV90YWJsZV9hZ2UgPSBmcmVlemVfdGFibGVfYWdlOwogCQl0YWItPmF0 X3BhcmFtcy5tdWx0aXhhY3RfZnJlZXplX21pbl9hZ2UgPSBtdWx0aXhhY3RfZnJlZXplX21pbl9h Z2U7CkBAIC0zMzM2LDYgKzMzODUsODggQEAgQXV0b1ZhY3V1bVJlcXVlc3RXb3JrKEF1dG9WYWN1 dW1Xb3JrSXRlbVR5cGUgdHlwZSwgT2lkIHJlbGF0aW9uSWQsCiAJcmV0dXJuIHJlc3VsdDsKIH0K IAorLyoKKyAqIFJlc2VydmVzIHBhcmFsbGVsIHdvcmtlcnMgZm9yIGF1dG92YWN1dW0uCisgKgor ICogbndvcmtlcnMgaXMgYW4gaW4vb3V0IHBhcmFtZXRlcjsgdGhlIHJlcXVlc3RlZCBudW1iZXIg b2YgcGFyYWxsZWwgd29ya2VycworICogdG8gcmVzZXJ2ZSBieSB0aGUgY2FsbGVyLCBhbmQgc2V0 IHRvIHRoZSBhY3R1YWwgbnVtYmVyIG9mIHJlc2VydmVkIHdvcmtlcnMuCisgKgorICogVGhlIGNh bGxlciBtdXN0IGNhbGwgQXV0b1ZhY3V1bVJlbGVhc2VbQWxsXVBhcmFsbGVsV29ya2VycygpIHRv IHJlbGVhc2UgdGhlCisgKiByZXNlcnZlZCB3b3JrZXJzLgorICoKKyAqIE5PVEU6IFdlIHdpbGwg dHJ5IHRvIHByb3ZpZGUgYXMgbWFueSB3b3JrZXJzIGFzIHJlcXVlc3RlZCwgZXZlbiBpZiBjYWxs ZXIKKyAqIHdpbGwgb2NjdXB5IGFsbCBhdmFpbGFibGUgd29ya2Vycy4KKyAqLwordm9pZAorQXV0 b1ZhY3V1bVJlc2VydmVQYXJhbGxlbFdvcmtlcnMoaW50ICpud29ya2VycykKK3sKKwkvKiBPbmx5 IGxlYWRlciBhdXRvdmFjdXVtIHdvcmtlciBjYW4gY2FsbCB0aGlzIGZ1bmN0aW9uLiAqLworCUFz c2VydChBbUF1dG9WYWN1dW1Xb3JrZXJQcm9jZXNzKCkpOworCisJLyogVGhlIHdvcmtlciBtdXN0 IG5vdCBoYXZlIGFueSByZXNlcnZlZCB3b3JrZXJzIHlldCAqLworCUFzc2VydChhdl9ud29ya2Vy c19yZXNlcnZlZCA9PSAwKTsKKworCUxXTG9ja0FjcXVpcmUoQXV0b3ZhY3V1bUxvY2ssIExXX0VY Q0xVU0lWRSk7CisKKwkvKiBQcm92aWRlIGFzIG1hbnkgd29ya2VycyBhcyB3ZSBjYW4uICovCisJ Km53b3JrZXJzID0gTWluKEF1dG9WYWN1dW1TaG1lbS0+YXZfZnJlZVBhcmFsbGVsV29ya2Vycywg Km53b3JrZXJzKTsKKwlBdXRvVmFjdXVtU2htZW0tPmF2X2ZyZWVQYXJhbGxlbFdvcmtlcnMgLT0g Km53b3JrZXJzOworCisJTFdMb2NrUmVsZWFzZShBdXRvdmFjdXVtTG9jayk7CisKKwkvKiBSZW1l bWJlciBob3cgbWFueSB3b3JrZXJzIHdlIGhhdmUgcmVzZXJ2ZWQuICovCisJYXZfbndvcmtlcnNf cmVzZXJ2ZWQgPSAqbndvcmtlcnM7Cit9CisKKy8qCisgKiBSZWxlYXNlcyB0aGUgcmVzZXJ2ZWQg cGFyYWxsZWwgd29ya2VycyBmb3IgYXV0b3ZhY3V1bS4KKyAqCisgKiBUaGlzIGZ1bmN0aW9uIHNo b3VsZCBiZSB1c2VkIHRvIHJlbGVhc2UgdGhlIHBhcmFsbGVsIHdvcmtlcnMgdGhhdCBhbgorICog YXV0b3ZhY3V1bSB3b3JrZXIgcmVzZXJ2ZWQgYnkgQXV0b1ZhY3V1bVJlc2VydmVQYXJhbGxlbFdv cmtlcnMoKS4gbndvcmtlcnMKKyAqIGlzIHRoZSBudW1iZXIgb2Ygd29ya2VycyB0byByZWxlYXNl LCB3aGljaCBtdXN0IG5vdCBiZSBncmVhdGVyIHRoYW4gdGhlCisgKiBudW1iZXIgb2Ygd29ya2Vy cyBjdXJyZW50bHkgcmVzZXJ2ZWQsIGF2X253b3JrZXJzX3Jlc2VydmVkLgorICovCit2b2lkCitB dXRvVmFjdXVtUmVsZWFzZVBhcmFsbGVsV29ya2VycyhpbnQgbndvcmtlcnMpCit7CisJLyogT25s eSBsZWFkZXIgd29ya2VyIGNhbiBjYWxsIHRoaXMgZnVuY3Rpb24uICovCisJQXNzZXJ0KEFtQXV0 b1ZhY3V1bVdvcmtlclByb2Nlc3MoKSk7CisKKwkvKiBDYW5ub3QgcmVsZWFzZSBtb3JlIHdvcmtl cnMgdGhhbiByZXNlcnZlZCAqLworCUFzc2VydChud29ya2VycyA8PSBhdl9ud29ya2Vyc19yZXNl cnZlZCk7CisKKwlMV0xvY2tBY3F1aXJlKEF1dG92YWN1dW1Mb2NrLCBMV19FWENMVVNJVkUpOwor CisJLyoKKwkgKiBJZiB0aGUgbWF4aW11bSBudW1iZXIgb2YgcGFyYWxsZWwgd29ya2VycyB3YXMg cmVkdWNlZCBkdXJpbmcgZXhlY3V0aW9uLAorCSAqIHdlIG11c3QgY2FwIGF2YWlsYWJsZSB3b3Jr ZXJzIG51bWJlciBieSBpdHMgbmV3IHZhbHVlLgorCSAqLworCUF1dG9WYWN1dW1TaG1lbS0+YXZf ZnJlZVBhcmFsbGVsV29ya2VycyA9CisJCU1pbihBdXRvVmFjdXVtU2htZW0tPmF2X2ZyZWVQYXJh bGxlbFdvcmtlcnMgKyBud29ya2VycywKKwkJCUF1dG9WYWN1dW1TaG1lbS0+YXZfbWF4UGFyYWxs ZWxXb3JrZXJzKTsKKworCUxXTG9ja1JlbGVhc2UoQXV0b3ZhY3V1bUxvY2spOworCisJLyogRG9u J3QgaGF2ZSB0byByZW1lbWJlciB0aGVzZSB3b3JrZXJzIGFueW1vcmUuICovCisJYXZfbndvcmtl cnNfcmVzZXJ2ZWQgLT0gbndvcmtlcnM7Cit9CisKKy8qCisgKiBTYW1lIGFzIGFib3ZlLCBidXQg dGhpcyBmdW5jdGlvbiByZWxlYXNlcyBhbGwgdGhlIHBhcmFsbGVsIHdvcmtlcnMgdGhhdAorICog dGhpcyBhdXRvdmFjdXVtIHdvcmtlciByZXNlcnZlZC4KKyAqLwordm9pZAorQXV0b1ZhY3V1bVJl bGVhc2VBbGxQYXJhbGxlbFdvcmtlcnModm9pZCkKK3sKKwkvKiBPbmx5IGxlYWRlciB3b3JrZXIg Y2FuIGNhbGwgdGhpcyBmdW5jdGlvbi4gKi8KKwlBc3NlcnQoQW1BdXRvVmFjdXVtV29ya2VyUHJv Y2VzcygpKTsKKworCWlmIChhdl9ud29ya2Vyc19yZXNlcnZlZCA+IDApCisJCUF1dG9WYWN1dW1S ZWxlYXNlUGFyYWxsZWxXb3JrZXJzKGF2X253b3JrZXJzX3Jlc2VydmVkKTsKKworCUFzc2VydChh dl9ud29ya2Vyc19yZXNlcnZlZCA9PSAwKTsKK30KKwogLyoKICAqIGF1dG92YWNfaW5pdAogICoJ CVRoaXMgaXMgY2FsbGVkIGF0IHBvc3RtYXN0ZXIgaW5pdGlhbGl6YXRpb24uCkBAIC0zMzk2LDYg KzM1MjcsMTAgQEAgQXV0b1ZhY3V1bVNobWVtSW5pdCh2b2lkKQogCQlBc3NlcnQoIWZvdW5kKTsK IAogCQlBdXRvVmFjdXVtU2htZW0tPmF2X2xhdW5jaGVycGlkID0gMDsKKwkJQXV0b1ZhY3V1bVNo bWVtLT5hdl9tYXhQYXJhbGxlbFdvcmtlcnMgPQorCQkJTWluKGF1dG92YWN1dW1fbWF4X3BhcmFs bGVsX3dvcmtlcnMsIG1heF93b3JrZXJfcHJvY2Vzc2VzKTsKKwkJQXV0b1ZhY3V1bVNobWVtLT5h dl9mcmVlUGFyYWxsZWxXb3JrZXJzID0KKwkJCUF1dG9WYWN1dW1TaG1lbS0+YXZfbWF4UGFyYWxs ZWxXb3JrZXJzOwogCQlkY2xpc3RfaW5pdCgmQXV0b1ZhY3V1bVNobWVtLT5hdl9mcmVlV29ya2Vy cyk7CiAJCWRsaXN0X2luaXQoJkF1dG9WYWN1dW1TaG1lbS0+YXZfcnVubmluZ1dvcmtlcnMpOwog CQlBdXRvVmFjdXVtU2htZW0tPmF2X3N0YXJ0aW5nV29ya2VyID0gTlVMTDsKQEAgLTM0NzcsMyAr MzYxMiwzNiBAQCBjaGVja19hdl93b3JrZXJfZ3Vjcyh2b2lkKQogCQkJCSBlcnJkZXRhaWwoIlRo ZSBzZXJ2ZXIgd2lsbCBvbmx5IHN0YXJ0IHVwIHRvIFwiYXV0b3ZhY3V1bV93b3JrZXJfc2xvdHNc IiAoJWQpIGF1dG92YWN1dW0gd29ya2VycyBhdCBhIGdpdmVuIHRpbWUuIiwKIAkJCQkJCSAgIGF1 dG92YWN1dW1fd29ya2VyX3Nsb3RzKSkpOwogfQorCisvKgorICogQWRqdXN0cyB0aGUgbnVtYmVy IG9mIGZyZWUgcGFyYWxsZWwgd29ya2VycyBjb3JyZXNwb25kcyB0byB0aGUgbmV3CisgKiBhdXRv dmFjdXVtX21heF9wYXJhbGxlbF93b3JrZXJzIHZhbHVlLgorICovCitzdGF0aWMgdm9pZAorYWRq dXN0X2ZyZWVfcGFyYWxsZWxfd29ya2VycyhpbnQgcHJldl9tYXhfcGFyYWxsZWxfd29ya2VycykK K3sKKwlpbnQJbmZyZWVfd29ya2VyczsKKworCUxXTG9ja0FjcXVpcmUoQXV0b3ZhY3V1bUxvY2ss IExXX0VYQ0xVU0lWRSk7CisKKwluZnJlZV93b3JrZXJzID0KKwkJYXV0b3ZhY3V1bV9tYXhfcGFy YWxsZWxfd29ya2VycyAtIHByZXZfbWF4X3BhcmFsbGVsX3dvcmtlcnMgKworCQlBdXRvVmFjdXVt U2htZW0tPmF2X2ZyZWVQYXJhbGxlbFdvcmtlcnM7CisKKwkvKgorCSAqIENhcCBvciBpbmNyZWFz ZSBudW1iZXIgb2YgZnJlZSBwYXJhbGxlbCB3b3JrZXJzIGFjY29yZGluZyB0byB0aGUKKwkgKiBw YXJhbWV0ZXIgY2hhbmdlLgorCSAqLworCUF1dG9WYWN1dW1TaG1lbS0+YXZfZnJlZVBhcmFsbGVs V29ya2VycyA9IE1heChuZnJlZV93b3JrZXJzLCAwKTsKKworCS8qCisJICogRG9uJ3QgYWxsb3cg bnVtYmVyIG9mIGZyZWUgd29ya2VycyB0byBiZWNvbWUgbGVzcyB0aGFuIHplcm8gaWYgdGhlCisJ ICogcGF0YW1ldGVyIHdhcyBkZWNyZWFzZWQuCisJICovCisJQXV0b1ZhY3V1bVNobWVtLT5hdl9m cmVlUGFyYWxsZWxXb3JrZXJzID0KKwkJTWF4KEF1dG9WYWN1dW1TaG1lbS0+YXZfZnJlZVBhcmFs bGVsV29ya2VycywgMCk7CisKKwlBdXRvVmFjdXVtU2htZW0tPmF2X21heFBhcmFsbGVsV29ya2Vy cyA9IGF1dG92YWN1dW1fbWF4X3BhcmFsbGVsX3dvcmtlcnM7CisKKwlMV0xvY2tSZWxlYXNlKEF1 dG92YWN1dW1Mb2NrKTsKK30KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3V0aWxzL2luaXQvZ2xv YmFscy5jIGIvc3JjL2JhY2tlbmQvdXRpbHMvaW5pdC9nbG9iYWxzLmMKaW5kZXggMzZhZDcwOGIz NjAuLjgyNjVhODJiNjM5IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC91dGlscy9pbml0L2dsb2Jh bHMuYworKysgYi9zcmMvYmFja2VuZC91dGlscy9pbml0L2dsb2JhbHMuYwpAQCAtMTQzLDYgKzE0 Myw3IEBAIGludAkJCU5CdWZmZXJzID0gMTYzODQ7CiBpbnQJCQlNYXhDb25uZWN0aW9ucyA9IDEw MDsKIGludAkJCW1heF93b3JrZXJfcHJvY2Vzc2VzID0gODsKIGludAkJCW1heF9wYXJhbGxlbF93 b3JrZXJzID0gODsKK2ludAkJCWF1dG92YWN1dW1fbWF4X3BhcmFsbGVsX3dvcmtlcnMgPSAyOwog aW50CQkJTWF4QmFja2VuZHMgPSAwOwogCiAvKiBHVUMgcGFyYW1ldGVycyBmb3IgdmFjdXVtICov CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC91dGlscy9taXNjL2d1Yy5jIGIvc3JjL2JhY2tlbmQv dXRpbHMvbWlzYy9ndWMuYwppbmRleCBhZTlkNWYzZmI3MC4uYzhhOTlhNjc3NjcgMTAwNjQ0Ci0t LSBhL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvZ3VjLmMKKysrIGIvc3JjL2JhY2tlbmQvdXRpbHMv bWlzYy9ndWMuYwpAQCAtMzMyNiw5ICszMzI2LDEzIEBAIHNldF9jb25maWdfd2l0aF9oYW5kbGUo Y29uc3QgY2hhciAqbmFtZSwgY29uZmlnX2hhbmRsZSAqaGFuZGxlLAogCSAqCiAJICogQWxzbyBh bGxvdyBub3JtYWwgc2V0dGluZyBpZiB0aGUgR1VDIGlzIG1hcmtlZCBHVUNfQUxMT1dfSU5fUEFS QUxMRUwuCiAJICoKLQkgKiBPdGhlciBjaGFuZ2VzIG1pZ2h0IG5lZWQgdG8gYWZmZWN0IG90aGVy IHdvcmtlcnMsIHNvIGZvcmJpZCB0aGVtLgorCSAqIE90aGVyIGNoYW5nZXMgbWlnaHQgbmVlZCB0 byBhZmZlY3Qgb3RoZXIgd29ya2Vycywgc28gZm9yYmlkIHRoZW0uIE5vdGUsCisJICogdGhhdCBw YXJhbGxlbCBhdXRvdmFjdXVtIGxlYWRlciBpcyBhbiBleGNlcHRpb24sIGJlY2F1c2Ugb25seQor CSAqIGNvc3QtYmFzZWQgZGVsYXlzIG5lZWQgdG8gYmUgYWZmZWN0ZWQgYWxzbyB0byBwYXJhbGxl bCB2YWN1dW0gd29ya2VycywKKwkgKiBhbmQgd2Ugd2lsbCBoYW5kbGUgaXQgZWxzZXdoZXJlIGlm IGFwcHJvcHJpYXRlLgogCSAqLwotCWlmIChJc0luUGFyYWxsZWxNb2RlKCkgJiYgY2hhbmdlVmFs ICYmIGFjdGlvbiAhPSBHVUNfQUNUSU9OX1NBVkUgJiYKKwlpZiAoSXNJblBhcmFsbGVsTW9kZSgp ICYmICFBbUF1dG9WYWN1dW1Xb3JrZXJQcm9jZXNzKCkgJiYgY2hhbmdlVmFsICYmCisJCWFjdGlv biAhPSBHVUNfQUNUSU9OX1NBVkUgJiYKIAkJKHJlY29yZC0+ZmxhZ3MgJiBHVUNfQUxMT1dfSU5f UEFSQUxMRUwpID09IDApCiAJewogCQllcmVwb3J0KGVsZXZlbCwKZGlmZiAtLWdpdCBhL3NyYy9i YWNrZW5kL3V0aWxzL21pc2MvZ3VjX3BhcmFtZXRlcnMuZGF0IGIvc3JjL2JhY2tlbmQvdXRpbHMv bWlzYy9ndWNfcGFyYW1ldGVycy5kYXQKaW5kZXggN2M2MGIxMjU1NjQuLjQ5MmY2NmE2ODcyIDEw MDY0NAotLS0gYS9zcmMvYmFja2VuZC91dGlscy9taXNjL2d1Y19wYXJhbWV0ZXJzLmRhdAorKysg Yi9zcmMvYmFja2VuZC91dGlscy9taXNjL2d1Y19wYXJhbWV0ZXJzLmRhdApAQCAtMTU0LDYgKzE1 NCwxNCBAQAogICBtYXggPT4gJzIwMDAwMDAwMDAnLAogfSwKIAoreyBuYW1lID0+ICdhdXRvdmFj dXVtX21heF9wYXJhbGxlbF93b3JrZXJzJywgdHlwZSA9PiAnaW50JywgY29udGV4dCA9PiAnUEdD X1NJR0hVUCcsIGdyb3VwID0+ICdWQUNVVU1fQVVUT1ZBQ1VVTScsCisgIHNob3J0X2Rlc2MgPT4g J01heGltdW0gbnVtYmVyIG9mIHBhcmFsbGVsIGF1dG92YWN1dW0gd29ya2VycywgdGhhdCBjYW4g YmUgdGFrZW4gZnJvbSBiZ3dvcmtlcnMgcG9vbC4nLAorICB2YXJpYWJsZSA9PiAnYXV0b3ZhY3V1 bV9tYXhfcGFyYWxsZWxfd29ya2VycycsCisgIGJvb3RfdmFsID0+ICcyJywKKyAgbWluID0+ICcw JywKKyAgbWF4ID0+ICdNQVhfQkFDS0VORFMnLAorfSwKKwogeyBuYW1lID0+ICdhdXRvdmFjdXVt X21heF93b3JrZXJzJywgdHlwZSA9PiAnaW50JywgY29udGV4dCA9PiAnUEdDX1NJR0hVUCcsIGdy b3VwID0+ICdWQUNVVU1fQVVUT1ZBQ1VVTScsCiAgIHNob3J0X2Rlc2MgPT4gJ1NldHMgdGhlIG1h eGltdW0gbnVtYmVyIG9mIHNpbXVsdGFuZW91c2x5IHJ1bm5pbmcgYXV0b3ZhY3V1bSB3b3JrZXIg cHJvY2Vzc2VzLicsCiAgIHZhcmlhYmxlID0+ICdhdXRvdmFjdXVtX21heF93b3JrZXJzJywKZGlm ZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvcG9zdGdyZXNxbC5jb25mLnNhbXBsZSBi L3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvcG9zdGdyZXNxbC5jb25mLnNhbXBsZQppbmRleCBkYzll MjI1NWY4YS4uN2I1MzZlODE3OTEgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3V0aWxzL21pc2Mv cG9zdGdyZXNxbC5jb25mLnNhbXBsZQorKysgYi9zcmMvYmFja2VuZC91dGlscy9taXNjL3Bvc3Rn cmVzcWwuY29uZi5zYW1wbGUKQEAgLTY5MSw2ICs2OTEsNyBAQAogI2F1dG92YWN1dW1fd29ya2Vy X3Nsb3RzID0gMTYgICAgICAgICAgICMgYXV0b3ZhY3V1bSB3b3JrZXIgc2xvdHMgdG8gYWxsb2Nh dGUKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAjIChjaGFuZ2UgcmVx dWlyZXMgcmVzdGFydCkKICNhdXRvdmFjdXVtX21heF93b3JrZXJzID0gMyAgICAgICAgICAgICAj IG1heCBudW1iZXIgb2YgYXV0b3ZhY3V1bSBzdWJwcm9jZXNzZXMKKyNhdXRvdmFjdXVtX21heF9w YXJhbGxlbF93b3JrZXJzID0gMiAgICAjIGxpbWl0ZWQgYnkgbWF4X3dvcmtlcl9wcm9jZXNzZXMK ICNhdXRvdmFjdXVtX25hcHRpbWUgPSAxbWluICAgICAgICAgICAgICAjIHRpbWUgYmV0d2VlbiBh dXRvdmFjdXVtIHJ1bnMKICNhdXRvdmFjdXVtX3ZhY3V1bV90aHJlc2hvbGQgPSA1MCAgICAgICAj IG1pbiBudW1iZXIgb2Ygcm93IHVwZGF0ZXMgYmVmb3JlCiAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIyB2YWN1dW0KZGlmZiAtLWdpdCBhL3NyYy9iaW4vcHNxbC90YWIt Y29tcGxldGUuaW4uYyBiL3NyYy9iaW4vcHNxbC90YWItY29tcGxldGUuaW4uYwppbmRleCA4Yjkx YmMwMDA2Mi4uZWQ1OWEyMTI4OWMgMTAwNjQ0Ci0tLSBhL3NyYy9iaW4vcHNxbC90YWItY29tcGxl dGUuaW4uYworKysgYi9zcmMvYmluL3BzcWwvdGFiLWNvbXBsZXRlLmluLmMKQEAgLTE0MjMsNiAr MTQyMyw3IEBAIHN0YXRpYyBjb25zdCBjaGFyICpjb25zdCB0YWJsZV9zdG9yYWdlX3BhcmFtZXRl cnNbXSA9IHsKIAkiYXV0b3ZhY3V1bV9tdWx0aXhhY3RfZnJlZXplX21heF9hZ2UiLAogCSJhdXRv dmFjdXVtX211bHRpeGFjdF9mcmVlemVfbWluX2FnZSIsCiAJImF1dG92YWN1dW1fbXVsdGl4YWN0 X2ZyZWV6ZV90YWJsZV9hZ2UiLAorCSJhdXRvdmFjdXVtX3BhcmFsbGVsX3dvcmtlcnMiLAogCSJh dXRvdmFjdXVtX3ZhY3V1bV9jb3N0X2RlbGF5IiwKIAkiYXV0b3ZhY3V1bV92YWN1dW1fY29zdF9s aW1pdCIsCiAJImF1dG92YWN1dW1fdmFjdXVtX2luc2VydF9zY2FsZV9mYWN0b3IiLApkaWZmIC0t Z2l0IGEvc3JjL2luY2x1ZGUvbWlzY2FkbWluLmggYi9zcmMvaW5jbHVkZS9taXNjYWRtaW4uaApp bmRleCBkYjU1OWIzOWM0ZC4uYWQ2ZTE5ZjQyNmMgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL21p c2NhZG1pbi5oCisrKyBiL3NyYy9pbmNsdWRlL21pc2NhZG1pbi5oCkBAIC0xNzgsNiArMTc4LDcg QEAgZXh0ZXJuIFBHRExMSU1QT1JUIGludCBNYXhCYWNrZW5kczsKIGV4dGVybiBQR0RMTElNUE9S VCBpbnQgTWF4Q29ubmVjdGlvbnM7CiBleHRlcm4gUEdETExJTVBPUlQgaW50IG1heF93b3JrZXJf cHJvY2Vzc2VzOwogZXh0ZXJuIFBHRExMSU1QT1JUIGludCBtYXhfcGFyYWxsZWxfd29ya2VyczsK K2V4dGVybiBQR0RMTElNUE9SVCBpbnQgYXV0b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2VyczsK IAogZXh0ZXJuIFBHRExMSU1QT1JUIGludCBjb21taXRfdGltZXN0YW1wX2J1ZmZlcnM7CiBleHRl cm4gUEdETExJTVBPUlQgaW50IG11bHRpeGFjdF9tZW1iZXJfYnVmZmVyczsKZGlmZiAtLWdpdCBh L3NyYy9pbmNsdWRlL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5oIGIvc3JjL2luY2x1ZGUvcG9zdG1h c3Rlci9hdXRvdmFjdXVtLmgKaW5kZXggNWFhMGYzYThhYzEuLmYzNzgzYWZiNTFiIDEwMDY0NAot LS0gYS9zcmMvaW5jbHVkZS9wb3N0bWFzdGVyL2F1dG92YWN1dW0uaAorKysgYi9zcmMvaW5jbHVk ZS9wb3N0bWFzdGVyL2F1dG92YWN1dW0uaApAQCAtNjIsNiArNjIsMTEgQEAgcGdfbm9yZXR1cm4g ZXh0ZXJuIHZvaWQgQXV0b1ZhY1dvcmtlck1haW4oY29uc3Qgdm9pZCAqc3RhcnR1cF9kYXRhLCBz aXplX3Qgc3RhcnQKIGV4dGVybiBib29sIEF1dG9WYWN1dW1SZXF1ZXN0V29yayhBdXRvVmFjdXVt V29ya0l0ZW1UeXBlIHR5cGUsCiAJCQkJCQkJCSAgT2lkIHJlbGF0aW9uSWQsIEJsb2NrTnVtYmVy IGJsa25vKTsKIAorLyogcGFyYWxsZWwgYXV0b3ZhY3V1bSBzdHVmZiAqLworZXh0ZXJuIHZvaWQJ QXV0b1ZhY3V1bVJlc2VydmVQYXJhbGxlbFdvcmtlcnMoaW50ICpud29ya2Vycyk7CitleHRlcm4g dm9pZCBBdXRvVmFjdXVtUmVsZWFzZVBhcmFsbGVsV29ya2VycyhpbnQgbndvcmtlcnMpOworZXh0 ZXJuIHZvaWQgQXV0b1ZhY3V1bVJlbGVhc2VBbGxQYXJhbGxlbFdvcmtlcnModm9pZCk7CisKIC8q IHNoYXJlZCBtZW1vcnkgc3R1ZmYgKi8KIGV4dGVybiBTaXplIEF1dG9WYWN1dW1TaG1lbVNpemUo dm9pZCk7CiBleHRlcm4gdm9pZCBBdXRvVmFjdXVtU2htZW1Jbml0KHZvaWQpOwpkaWZmIC0tZ2l0 IGEvc3JjL2luY2x1ZGUvdXRpbHMvcmVsLmggYi9zcmMvaW5jbHVkZS91dGlscy9yZWwuaAppbmRl eCBkMDNhYjI0Nzc4OC4uYzFkODgyNjU5ZjkgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL3V0aWxz L3JlbC5oCisrKyBiL3NyYy9pbmNsdWRlL3V0aWxzL3JlbC5oCkBAIC0zMTEsNiArMzExLDEzIEBA IHR5cGVkZWYgc3RydWN0IEZvcmVpZ25LZXlDYWNoZUluZm8KIHR5cGVkZWYgc3RydWN0IEF1dG9W YWNPcHRzCiB7CiAJYm9vbAkJZW5hYmxlZDsKKworCS8qCisJICogTWF4IG51bWJlciBvZiBwYXJh bGxlbCBhdXRvdmFjdXVtIHdvcmtlcnMuIElmIHZhbHVlIGlzIDAgdGhlbiBwYXJhbGxlbAorCSAq IGRlZ3JlZSB3aWxsIGNvbXB1dGVkIGJhc2VkIG9uIG51bWJlciBvZiBpbmRleGVzLgorCSAqLwor CWludAkJCWF1dG92YWN1dW1fcGFyYWxsZWxfd29ya2VyczsKKwogCWludAkJCXZhY3V1bV90aHJl c2hvbGQ7CiAJaW50CQkJdmFjdXVtX21heF90aHJlc2hvbGQ7CiAJaW50CQkJdmFjdXVtX2luc190 aHJlc2hvbGQ7Ci0tIAoyLjQzLjAKCg== --0000000000004477530648969c39 Content-Type: text/x-patch; charset="US-ASCII"; name="v20-0003-Cost-based-parameters-propagation-for-parallel-a.patch" Content-Disposition: attachment; filename="v20-0003-Cost-based-parameters-propagation-for-parallel-a.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mkifeqzz2 RnJvbSBhYTg2ZTQyNWU1ZjdhNGM4MjQ3YjhmNmQzOWQ4NTJkZTM2ZTM3NDU2IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBUaHUsIDE1IEphbiAyMDI2IDIzOjE1OjQ4ICswNzAwClN1YmplY3Q6IFtQQVRD SCB2MjAgMy81XSBDb3N0IGJhc2VkIHBhcmFtZXRlcnMgcHJvcGFnYXRpb24gZm9yIHBhcmFsbGVs CiBhdXRvdmFjdXVtCgotLS0KIHNyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jICAgICAgICAg fCAgMjkgKysrKystCiBzcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jIHwgMTM0 ICsrKysrKysrKysrKysrKysrKysrKysrKysrCiBzcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92 YWN1dW0uYyAgIHwgICAyICstCiBzcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0uaCAgICAgICAg IHwgICAyICsKIDQgZmlsZXMgY2hhbmdlZCwgMTY0IGluc2VydGlvbnMoKyksIDMgZGVsZXRpb25z KC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMgYi9zcmMvYmFj a2VuZC9jb21tYW5kcy92YWN1dW0uYwppbmRleCBhYTRmYmVjMTQzZi4uM2NjODRiZWRmYjcgMTAw NjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jCisrKyBiL3NyYy9iYWNrZW5k L2NvbW1hbmRzL3ZhY3V1bS5jCkBAIC0yNDMwLDggKzI0MzAsMjcgQEAgdmFjdXVtX2RlbGF5X3Bv aW50KGJvb2wgaXNfYW5hbHl6ZSkKIAkvKiBBbHdheXMgY2hlY2sgZm9yIGludGVycnVwdHMgKi8K IAlDSEVDS19GT1JfSU5URVJSVVBUUygpOwogCi0JaWYgKEludGVycnVwdFBlbmRpbmcgfHwKLQkJ KCFWYWN1dW1Db3N0QWN0aXZlICYmICFDb25maWdSZWxvYWRQZW5kaW5nKSkKKwlpZiAoSW50ZXJy dXB0UGVuZGluZykKKwkJcmV0dXJuOworCisJaWYgKCFBbUF1dG9WYWN1dW1Xb3JrZXJQcm9jZXNz KCkgJiYgSXNQYXJhbGxlbFdvcmtlcigpKQorCXsKKwkJLyoKKwkJICogSWYgd2UgYXJlIHBhcmFs bGVsICphdXRvdmFjdXVtKiB3b3JrZXIsIGNoZWNrIHdoZXRoZXIgcmVsYXRlZCB0bworCQkgKiBj b3N0LWJhc2VkIGRlbGF5IHBhcmFtZXRlcnMgaGFkIGNoYW5nZWQgaW4gdGhlIGxlYWRlciB3b3Jr ZXIuIElmCisJCSAqIHNvLCBjb3JyZXNwb25kaW5nIHBhcmFtZXRlcnMgd2lsbCBiZSB1cGRhdGVk IHRvIHRoZSB2YWx1ZXMgd2hpY2gKKwkJICogbGVhZGVyIHdvcmtlciBpcyBvcGVyYXRpbmcgb24u CisJCSAqCisJCSAqIERvIGl0IGJlZm9yZSBjaGVja2luZyBWYWN1dW1Db3N0QWN0aXZlLCBiZWNh dXNlIGl0cyB2YWx1ZSBtaWdodCBiZQorCQkgKiBjaGFuZ2VkIGFmdGVyIGxlYWRlcidzIHBhcmFt ZXRlcnMgY29uc3VtcHRpb24uCisJCSAqCisJCSAqIE5vdGUsIHRoYXQgdGhpcyBmdW5jdGlvbiBo YXMgbm8gZWZmZWN0IGlmIHdlIGFyZSBub24tYXV0b3ZhY3V1bQorCQkgKiBwYXJhbGxlbCB3b3Jr ZXIuCisJCSAqLworCQlwYXJhbGxlbF92YWN1dW1fdXBkYXRlX3NoYXJlZF9kZWxheV9wYXJhbXMo KTsKKwl9CisKKwlpZiAoIVZhY3V1bUNvc3RBY3RpdmUgJiYgIUNvbmZpZ1JlbG9hZFBlbmRpbmcp CiAJCXJldHVybjsKIAogCS8qCkBAIC0yNDQ1LDYgKzI0NjQsMTIgQEAgdmFjdXVtX2RlbGF5X3Bv aW50KGJvb2wgaXNfYW5hbHl6ZSkKIAkJQ29uZmlnUmVsb2FkUGVuZGluZyA9IGZhbHNlOwogCQlQ cm9jZXNzQ29uZmlnRmlsZShQR0NfU0lHSFVQKTsKIAkJVmFjdXVtVXBkYXRlQ29zdHMoKTsKKwor CQkvKgorCQkgKiBJZiB3ZSBhcmUgcGFyYWxsZWwgYXV0b3ZhY3V1bSBsZWFkZXIgYW5kIHNvbWUg b2YgY29zdC1iYXNlZAorCQkgKiBwYXJhbWV0ZXJzIGhhZCBjaGFuZ2VkLCBsZXQgb3RoZXIgcGFy YWxsZWwgd29ya2VycyBrbm93LgorCQkgKi8KKwkJcGFyYWxsZWxfdmFjdXVtX3Byb3BhZ2F0ZV9j b3N0X2Jhc2VkX3BhcmFtcygpOwogCX0KIAogCS8qCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9j b21tYW5kcy92YWN1dW1wYXJhbGxlbC5jIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFy YWxsZWwuYwppbmRleCA0NGMxMjU4YjY5ZS4uZTM1NjEwNTczMzQgMTAwNjQ0Ci0tLSBhL3NyYy9i YWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMKKysrIGIvc3JjL2JhY2tlbmQvY29tbWFu ZHMvdmFjdXVtcGFyYWxsZWwuYwpAQCAtNTMsNiArNTMsMzkgQEAKICNkZWZpbmUgUEFSQUxMRUxf VkFDVVVNX0tFWV9XQUxfVVNBR0UJCTQKICNkZWZpbmUgUEFSQUxMRUxfVkFDVVVNX0tFWV9JTkRF WF9TVEFUUwkJNQogCisvKgorICogT25seSBhdXRvdmFjdXVtIGxlYWRlciBjYW4gcmVsb2FkIGNv bmZpZyBmaWxlLiBXZSB1c2UgdGhpcyBzdHJ1Y3R1cmUgaW4KKyAqIHBhcmFsbGVsIGF1dG92YWN1 dW0gZm9yIGtlZXBpbmcgd29ya2VyJ3MgcGFyYW1ldGVycyBpbiBzeW5jIHdpdGggbGVhZGVyJ3MK KyAqIHBhcmFtZXRlcnMuCisgKi8KK3R5cGVkZWYgc3RydWN0IFBWU2hhcmVkQ29zdFBhcmFtcwor eworCS8qCisJICogRWFjaCB0aW1lIGxlYWRlciB3b3JrZXIgdXBkYXRlcyBpdHMgcGFyYW1ldGVy cywgaXQgbXVzdCBpbmNyZWFzZQorCSAqIGdlbmVyYXRpb24uIEV2ZXJ5IHBhcmFsbGVsIHdvcmtl ciBrZWVwcyB0aGUgZ2VuZXJhdGlvbgorCSAqIChzaGFyZWRfcGFyYW1zX2xvY2FsX2dlbmVyYXRp b24pIGF0IHdoaWNoIGl0IGhhZCBsYXN0IHRpbWUgcmVjZWl2ZWQKKwkgKiBwYXJhbWV0ZXJzIGZy b20gdGhlIGxlYWRlci4KKwkgKgorCSAqIEl0IGlzIGVub3VnaCBmb3Igd29ya2VyIHRvIGNvbXBh cmUgaXQncyBsb2NhbF9nZW5lcmF0aW9uIHdpdGggdGhlIGZpZWxkCisJICogYmVsb3cgdG8gZGV0 ZXJtaW5lIHdoZXRoZXIgaXQgbmVlZHMgdG8gcmVjZWl2ZSBuZXcgcGFyYW1ldGVycycgdmFsdWVz LgorCSAqLworCXBnX2F0b21pY191aW50MzIgZ2VuZXJhdGlvbjsKKworCXNsb2NrX3QJCXNwaW5s b2NrOwkJLyogcHJvdGVjdHMgYWxsIGZpZWxkcyBiZWxvdyAqLworCisJLyogQ29waWVzIG9mIGNv cnJlc3BvbmRpbmcgcGFyYW1ldGVycyBmcm9tIGF1dG92YWN1dW0gbGVhZGVyIHByb2Nlc3MgKi8K Kwlkb3VibGUJCWNvc3RfZGVsYXk7CisJaW50CQkJY29zdF9saW1pdDsKKwlpbnQJCQljb3N0X3Bh Z2VfZGlydHk7CisJaW50CQkJY29zdF9wYWdlX2hpdDsKKwlpbnQJCQljb3N0X3BhZ2VfbWlzczsK K30JCQlQVlNoYXJlZENvc3RQYXJhbXM7CisKK3N0YXRpYyBQVlNoYXJlZENvc3RQYXJhbXMgKiBw dl9zaGFyZWRfY29zdF9wYXJhbXMgPSBOVUxMOworCisvKiBTZWUgY29tbWVudHMgZm9yIHN0cnVj dHVyZSBhYm92ZSBmb3IgdGhlIGV4cGxhbmF0aW9uLiAqLworc3RhdGljIHVpbnQzMiBzaGFyZWRf cGFyYW1zX2dlbmVyYXRpb25fbG9jYWwgPSAwOworCiAvKgogICogU2hhcmVkIGluZm9ybWF0aW9u IGFtb25nIHBhcmFsbGVsIHdvcmtlcnMuICBTbyB0aGlzIGlzIGFsbG9jYXRlZCBpbiB0aGUgRFNN CiAgKiBzZWdtZW50LgpAQCAtMTIyLDYgKzE1NSwxOCBAQCB0eXBlZGVmIHN0cnVjdCBQVlNoYXJl ZAogCiAJLyogU3RhdGlzdGljcyBvZiBzaGFyZWQgZGVhZCBpdGVtcyAqLwogCVZhY0RlYWRJdGVt c0luZm8gZGVhZF9pdGVtc19pbmZvOworCisJLyoKKwkgKiBJZiAndHJ1ZScgdGhlbiB3ZSBhcmUg cnVubmluZyBwYXJhbGxlbCBhdXRvdmFjdXVtLiBPdGhlcndpc2UsIHdlIGFyZQorCSAqIHJ1bm5p bmcgcGFyYWxsZWwgbWFpbnRlbmVuY2UgVkFDVVVNLgorCSAqLworCWJvb2wJCWFtX3BhcmFsbGVs X2F1dG92YWN1dW07CisKKwkvKgorCSAqIFN0cnVjdCBmb3Igc3luY2luZyBwYXJhbWV0ZXJzIGJl dHdlZW4gc3VwcG9ydGl2ZSBwYXJhbGxlbCBhdXRvdmFjdXVtCisJICogd29ya2VycyB3aXRoIGxl YWRlciB3b3JrZXIuCisJICovCisJUFZTaGFyZWRDb3N0UGFyYW1zIGNvc3RfcGFyYW1zOwogfSBQ VlNoYXJlZDsKIAogLyogU3RhdHVzIHVzZWQgZHVyaW5nIHBhcmFsbGVsIGluZGV4IHZhY3V1bSBv ciBjbGVhbnVwICovCkBAIC0zOTUsNiArNDQwLDIwIEBAIHBhcmFsbGVsX3ZhY3V1bV9pbml0KFJl bGF0aW9uIHJlbCwgUmVsYXRpb24gKmluZHJlbHMsIGludCBuaW5kZXhlcywKIAlwZ19hdG9taWNf aW5pdF91MzIoJihzaGFyZWQtPmFjdGl2ZV9ud29ya2VycyksIDApOwogCXBnX2F0b21pY19pbml0 X3UzMigmKHNoYXJlZC0+aWR4KSwgMCk7CiAKKwlzaGFyZWQtPmFtX3BhcmFsbGVsX2F1dG92YWN1 dW0gPSBBbUF1dG9WYWN1dW1Xb3JrZXJQcm9jZXNzKCk7CisKKwlpZiAoc2hhcmVkLT5hbV9wYXJh bGxlbF9hdXRvdmFjdXVtKQorCXsKKwkJc2hhcmVkLT5jb3N0X3BhcmFtcy5jb3N0X2RlbGF5ID0g dmFjdXVtX2Nvc3RfZGVsYXk7CisJCXNoYXJlZC0+Y29zdF9wYXJhbXMuY29zdF9saW1pdCA9IHZh Y3V1bV9jb3N0X2xpbWl0OworCQlzaGFyZWQtPmNvc3RfcGFyYW1zLmNvc3RfcGFnZV9kaXJ0eSA9 IFZhY3V1bUNvc3RQYWdlRGlydHk7CisJCXNoYXJlZC0+Y29zdF9wYXJhbXMuY29zdF9wYWdlX2hp dCA9IFZhY3V1bUNvc3RQYWdlSGl0OworCQlzaGFyZWQtPmNvc3RfcGFyYW1zLmNvc3RfcGFnZV9t aXNzID0gVmFjdXVtQ29zdFBhZ2VNaXNzOworCQlwZ19hdG9taWNfaW5pdF91MzIoJnNoYXJlZC0+ Y29zdF9wYXJhbXMuZ2VuZXJhdGlvbiwgMCk7CisJCVNwaW5Mb2NrSW5pdCgmc2hhcmVkLT5jb3N0 X3BhcmFtcy5zcGlubG9jayk7CisJCXB2X3NoYXJlZF9jb3N0X3BhcmFtcyA9ICYoc2hhcmVkLT5j b3N0X3BhcmFtcyk7CisJfQorCiAJc2htX3RvY19pbnNlcnQocGN4dC0+dG9jLCBQQVJBTExFTF9W QUNVVU1fS0VZX1NIQVJFRCwgc2hhcmVkKTsKIAlwdnMtPnNoYXJlZCA9IHNoYXJlZDsKIApAQCAt NTM3LDYgKzU5Niw3OCBAQCBwYXJhbGxlbF92YWN1dW1fY2xlYW51cF9hbGxfaW5kZXhlcyhQYXJh bGxlbFZhY3V1bVN0YXRlICpwdnMsIGxvbmcgbnVtX3RhYmxlX3R1cAogCXBhcmFsbGVsX3ZhY3V1 bV9wcm9jZXNzX2FsbF9pbmRleGVzKHB2cywgbnVtX2luZGV4X3NjYW5zLCBmYWxzZSwgd3VzYWdl KTsKIH0KIAorLyoKKyAqIEZ1bmN0aW9uIHRvIGJlIGNhbGxlZCBmcm9tIHBhcmFsbGVsIGF1dG92 YWN1dW0gd29ya2VyIGluIG9yZGVyIHRvIHN5bmMKKyAqIHNvbWUgY29zdC1iYXNlZCBkZWxheSBw YXJhbWV0ZXIgd2l0aCB0aGUgbGVhZGVyIHdvcmtlci4KKyAqLwordm9pZAorcGFyYWxsZWxfdmFj dXVtX3VwZGF0ZV9zaGFyZWRfZGVsYXlfcGFyYW1zKHZvaWQpCit7CisJdWludDMyCXBhcmFtc19n ZW5lcmF0aW9uOworCisJQXNzZXJ0KElzUGFyYWxsZWxXb3JrZXIoKSk7CisKKwkvKiBDaGVjayB3 aGV0aGVyIHdlIGFyZSBydW5uaW5nIHBhcmFsbGVsIGF1dG92YWN1dW0gKi8KKwlpZiAocHZfc2hh cmVkX2Nvc3RfcGFyYW1zID09IE5VTEwpCisJCXJldHVybjsKKworCXBhcmFtc19nZW5lcmF0aW9u ID0JcGdfYXRvbWljX3JlYWRfdTMyKCZwdl9zaGFyZWRfY29zdF9wYXJhbXMtPmdlbmVyYXRpb24p OworCUFzc2VydChzaGFyZWRfcGFyYW1zX2dlbmVyYXRpb25fbG9jYWwgPD0gcGFyYW1zX2dlbmVy YXRpb24pOworCisJLyogUmV0dXJuIGlmIHBhcmFtZXRlcnMgaGFkIG5vdCBjaGFuZ2VkIGluIHRo ZSBsZWFkZXIgKi8KKwlpZiAocGFyYW1zX2dlbmVyYXRpb24gPT0gc2hhcmVkX3BhcmFtc19nZW5l cmF0aW9uX2xvY2FsKQorCQlyZXR1cm47CisKKwlTcGluTG9ja0FjcXVpcmUoJnB2X3NoYXJlZF9j b3N0X3BhcmFtcy0+c3BpbmxvY2spOworCisJVmFjdXVtQ29zdERlbGF5ID0gcHZfc2hhcmVkX2Nv c3RfcGFyYW1zLT5jb3N0X2RlbGF5OworCVZhY3V1bUNvc3RMaW1pdCA9IHB2X3NoYXJlZF9jb3N0 X3BhcmFtcy0+Y29zdF9saW1pdDsKKwlWYWN1dW1Db3N0UGFnZURpcnR5ID0gcHZfc2hhcmVkX2Nv c3RfcGFyYW1zLT5jb3N0X3BhZ2VfZGlydHk7CisJVmFjdXVtQ29zdFBhZ2VIaXQgPSBwdl9zaGFy ZWRfY29zdF9wYXJhbXMtPmNvc3RfcGFnZV9oaXQ7CisJVmFjdXVtQ29zdFBhZ2VNaXNzID0gcHZf c2hhcmVkX2Nvc3RfcGFyYW1zLT5jb3N0X3BhZ2VfbWlzczsKKworCVNwaW5Mb2NrUmVsZWFzZSgm cHZfc2hhcmVkX2Nvc3RfcGFyYW1zLT5zcGlubG9jayk7CisKKwlWYWN1dW1VcGRhdGVDb3N0cygp OworCisJc2hhcmVkX3BhcmFtc19nZW5lcmF0aW9uX2xvY2FsID0gcGFyYW1zX2dlbmVyYXRpb247 Cit9CisKKy8qCisgKiBGdW5jdGlvbiB0byBiZSBjYWxsZWQgZnJvbSBwYXJhbGxlbCBhdXRvdmFj dXVtIGxlYWRlciBpbiBvcmRlciB0byBwcm9wYWdhdGUKKyAqIHNvbWUgY29zdC1iYXNlZCBwYXJh bWV0ZXJzIHRvIHRoZSBzdXBwb3J0aXZlIHdvcmtlcnMuCisgKi8KK3ZvaWQKK3BhcmFsbGVsX3Zh Y3V1bV9wcm9wYWdhdGVfY29zdF9iYXNlZF9wYXJhbXModm9pZCkKK3sKKwl1aW50MzIJcGFyYW1z X2dlbmVyYXRpb247CisKKwlBc3NlcnQoQW1BdXRvVmFjdXVtV29ya2VyUHJvY2VzcygpKTsKKwor CS8qIENoZWNrIHdoZXRoZXIgd2UgYXJlIHJ1bm5pbmcgcGFyYWxsZWwgYXV0b3ZhY3V1bSAqLwor CWlmIChwdl9zaGFyZWRfY29zdF9wYXJhbXMgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJcGFyYW1z X2dlbmVyYXRpb24gPQlwZ19hdG9taWNfcmVhZF91MzIoJnB2X3NoYXJlZF9jb3N0X3BhcmFtcy0+ Z2VuZXJhdGlvbik7CisKKwlTcGluTG9ja0FjcXVpcmUoJnB2X3NoYXJlZF9jb3N0X3BhcmFtcy0+ c3BpbmxvY2spOworCisJcHZfc2hhcmVkX2Nvc3RfcGFyYW1zLT5jb3N0X2RlbGF5ID0gdmFjdXVt X2Nvc3RfZGVsYXk7CisJcHZfc2hhcmVkX2Nvc3RfcGFyYW1zLT5jb3N0X2xpbWl0ID0gdmFjdXVt X2Nvc3RfbGltaXQ7CisJcHZfc2hhcmVkX2Nvc3RfcGFyYW1zLT5jb3N0X3BhZ2VfZGlydHkgPSBW YWN1dW1Db3N0UGFnZURpcnR5OworCXB2X3NoYXJlZF9jb3N0X3BhcmFtcy0+Y29zdF9wYWdlX2hp dCA9IFZhY3V1bUNvc3RQYWdlSGl0OworCXB2X3NoYXJlZF9jb3N0X3BhcmFtcy0+Y29zdF9wYWdl X21pc3MgPSBWYWN1dW1Db3N0UGFnZU1pc3M7CisKKwkvKgorCSAqIEluY3JlYXNlIGdlbmVyYXRp b24gb2YgdGhlIHBhcmFtZXRlcnMsIGkuZS4gbGV0IHBhcmFsbGVsIHdvcmtlcnMga25vdworCSAq IHRoYXQgdGhleSBzaG91bGQgcmUtcmVhZCBzaGFyZWQgY29zdCBwYXJhbXMuCisJICovCisJcGdf YXRvbWljX3dyaXRlX3UzMigmcHZfc2hhcmVkX2Nvc3RfcGFyYW1zLT5nZW5lcmF0aW9uLAorCQkJ CQkJcGFyYW1zX2dlbmVyYXRpb24gKyAxKTsKKworCVNwaW5Mb2NrUmVsZWFzZSgmcHZfc2hhcmVk X2Nvc3RfcGFyYW1zLT5zcGlubG9jayk7Cit9CisKIC8qCiAgKiBDb21wdXRlIHRoZSBudW1iZXIg b2YgcGFyYWxsZWwgd29ya2VyIHByb2Nlc3NlcyB0byByZXF1ZXN0LiAgQm90aCBpbmRleAogICog dmFjdXVtIGFuZCBpbmRleCBjbGVhbnVwIGNhbiBiZSBleGVjdXRlZCB3aXRoIHBhcmFsbGVsIHdv cmtlcnMuCkBAIC0xMTAwLDYgKzEyMzEsOSBAQCBwYXJhbGxlbF92YWN1dW1fbWFpbihkc21fc2Vn bWVudCAqc2VnLCBzaG1fdG9jICp0b2MpCiAJVmFjdXVtU2hhcmVkQ29zdEJhbGFuY2UgPSAmKHNo YXJlZC0+Y29zdF9iYWxhbmNlKTsKIAlWYWN1dW1BY3RpdmVOV29ya2VycyA9ICYoc2hhcmVkLT5h Y3RpdmVfbndvcmtlcnMpOwogCisJaWYgKHNoYXJlZC0+YW1fcGFyYWxsZWxfYXV0b3ZhY3V1bSkK KwkJcHZfc2hhcmVkX2Nvc3RfcGFyYW1zID0gJihzaGFyZWQtPmNvc3RfcGFyYW1zKTsKKwogCS8q IFNldCBwYXJhbGxlbCB2YWN1dW0gc3RhdGUgKi8KIAlwdnMuaW5kcmVscyA9IGluZHJlbHM7CiAJ cHZzLm5pbmRleGVzID0gbmluZGV4ZXM7CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9wb3N0bWFz dGVyL2F1dG92YWN1dW0uYyBiL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCmlu ZGV4IGRkZDdiYmRmNTIwLi4zZWU4NThjNWZiZCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvcG9z dG1hc3Rlci9hdXRvdmFjdXVtLmMKKysrIGIvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFj dXVtLmMKQEAgLTE2OTIsNyArMTY5Miw3IEBAIFZhY3V1bVVwZGF0ZUNvc3RzKHZvaWQpCiAJfQog CWVsc2UKIAl7Ci0JCS8qIE11c3QgYmUgZXhwbGljaXQgVkFDVVVNIG9yIEFOQUxZWkUgKi8KKwkJ LyogTXVzdCBiZSBleHBsaWNpdCBWQUNVVU0gb3IgQU5BTFlaRSBvciBwYXJhbGxlbCBhdXRvdmFj dXVtIHdvcmtlciAqLwogCQl2YWN1dW1fY29zdF9kZWxheSA9IFZhY3V1bUNvc3REZWxheTsKIAkJ dmFjdXVtX2Nvc3RfbGltaXQgPSBWYWN1dW1Db3N0TGltaXQ7CiAJfQpkaWZmIC0tZ2l0IGEvc3Jj L2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmggYi9zcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0u aAppbmRleCA3Y2JiNTlkMTI0Zi4uNzEyZTEyNTQ2MTMgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRl L2NvbW1hbmRzL3ZhY3V1bS5oCisrKyBiL3NyYy9pbmNsdWRlL2NvbW1hbmRzL3ZhY3V1bS5oCkBA IC00MTQsNiArNDE0LDggQEAgZXh0ZXJuIHZvaWQgcGFyYWxsZWxfdmFjdXVtX2NsZWFudXBfYWxs X2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLAogCQkJCQkJCQkJCQkJaW50IG51bV9p bmRleF9zY2FucywKIAkJCQkJCQkJCQkJCWJvb2wgZXN0aW1hdGVkX2NvdW50LAogCQkJCQkJCQkJ CQkJUFZXb3JrZXJzVXNhZ2UgKnd1c2FnZSk7CitleHRlcm4gdm9pZCBwYXJhbGxlbF92YWN1dW1f dXBkYXRlX3NoYXJlZF9kZWxheV9wYXJhbXModm9pZCk7CitleHRlcm4gdm9pZCBwYXJhbGxlbF92 YWN1dW1fcHJvcGFnYXRlX2Nvc3RfYmFzZWRfcGFyYW1zKHZvaWQpOwogZXh0ZXJuIHZvaWQgcGFy YWxsZWxfdmFjdXVtX21haW4oZHNtX3NlZ21lbnQgKnNlZywgc2htX3RvYyAqdG9jKTsKIAogLyog aW4gY29tbWFuZHMvYW5hbHl6ZS5jICovCi0tIAoyLjQzLjAKCg== --0000000000004477530648969c39 Content-Type: text/x-patch; charset="US-ASCII"; name="v20-0002-Logging-for-parallel-autovacuum.patch" Content-Disposition: attachment; filename="v20-0002-Logging-for-parallel-autovacuum.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mkifer0a3 RnJvbSA1ZDNhMjZhNjQ0MWY2MzU4NTA1ZTg1M2QxNTYzNGU4MjlhYzA2YjA1IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBTdW4sIDIzIE5vdiAyMDI1IDAxOjA3OjQ3ICswNzAwClN1YmplY3Q6IFtQQVRD SCB2MjAgMi81XSBMb2dnaW5nIGZvciBwYXJhbGxlbCBhdXRvdmFjdXVtCgotLS0KIHNyYy9iYWNr ZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYyAgfCAzMyArKysrKysrKysrKysrKysrKysrKysr KysrLS0KIHNyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMgfCAyNyArKysrKysr KysrKysrKysrKy0tLS0tCiBzcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0uaCAgICAgICAgIHwg MTkgKysrKysrKysrKysrKy0tCiBzcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdCAgICAg IHwgIDEgKwogNCBmaWxlcyBjaGFuZ2VkLCA3MCBpbnNlcnRpb25zKCspLCAxMCBkZWxldGlvbnMo LSkKCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMgYi9z cmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMKaW5kZXggMWZjYjIxMmFiM2QuLjhk Njk5OGM2ZjZmIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5 LmMKKysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvdmFjdXVtbGF6eS5jCkBAIC0zNDcsNiAr MzQ3LDEyIEBAIHR5cGVkZWYgc3RydWN0IExWUmVsU3RhdGUKIAlpbnQJCQludW1faW5kZXhfc2Nh bnM7CiAJaW50CQkJbnVtX2RlYWRfaXRlbXNfcmVzZXRzOwogCVNpemUJCXRvdGFsX2RlYWRfaXRl bXNfYnl0ZXM7CisKKwkvKgorCSAqIFRvdGFsIG51bWJlciBvZiBwbGFubmVkIGFuZCBhY3R1YWxs eSBsYXVuY2hlZCBwYXJhbGxlbCB3b3JrZXJzIGZvcgorCSAqIGluZGV4IHNjYW5zLgorCSAqLwor CVBWV29ya2Vyc1VzYWdlIHdvcmtlcnNfdXNhZ2U7CiAJLyogQ291bnRlcnMgdGhhdCBmb2xsb3cg YXJlIG9ubHkgZm9yIHNjYW5uZWRfcGFnZXMgKi8KIAlpbnQ2NAkJdHVwbGVzX2RlbGV0ZWQ7IC8q ICMgZGVsZXRlZCBmcm9tIHRhYmxlICovCiAJaW50NjQJCXR1cGxlc19mcm96ZW47CS8qICMgbmV3 bHkgZnJvemVuICovCkBAIC03ODEsNiArNzg3LDkgQEAgaGVhcF92YWN1dW1fcmVsKFJlbGF0aW9u IHJlbCwgY29uc3QgVmFjdXVtUGFyYW1zIHBhcmFtcywKIAl2YWNyZWwtPnZtX25ld192aXNpYmxl X2Zyb3plbl9wYWdlcyA9IDA7CiAJdmFjcmVsLT52bV9uZXdfZnJvemVuX3BhZ2VzID0gMDsKIAor CXZhY3JlbC0+d29ya2Vyc191c2FnZS5ubGF1bmNoZWQgPSAwOworCXZhY3JlbC0+d29ya2Vyc191 c2FnZS5ucGxhbm5lZCA9IDA7CisKIAkvKgogCSAqIEdldCBjdXRvZmZzIHRoYXQgZGV0ZXJtaW5l IHdoaWNoIGRlbGV0ZWQgdHVwbGVzIGFyZSBjb25zaWRlcmVkIERFQUQsCiAJICogbm90IGp1c3Qg UkVDRU5UTFlfREVBRCwgYW5kIHdoaWNoIFhJRHMvTVhJRHMgdG8gZnJlZXplLiAgVGhlbiBkZXRl cm1pbmUKQEAgLTExMjMsNiArMTEzMiwyNCBAQCBoZWFwX3ZhY3V1bV9yZWwoUmVsYXRpb24gcmVs LCBjb25zdCBWYWN1dW1QYXJhbXMgcGFyYW1zLAogCQkJCQkJCSBvcmlnX3JlbF9wYWdlcyA9PSAw ID8gMTAwLjAgOgogCQkJCQkJCSAxMDAuMCAqIHZhY3JlbC0+bHBkZWFkX2l0ZW1fcGFnZXMgLyBv cmlnX3JlbF9wYWdlcywKIAkJCQkJCQkgdmFjcmVsLT5scGRlYWRfaXRlbXMpOworCQkJaWYgKHZh Y3JlbC0+d29ya2Vyc191c2FnZS5ucGxhbm5lZCA+IDAgJiYKKwkJCQlBbUF1dG9WYWN1dW1Xb3Jr ZXJQcm9jZXNzKCkpCisJCQl7CisJCQkJLyogV29ya2VyIHVzYWdlIHN0YXRzIGZvciBwYXJhbGxl bCBhdXRvdmFjdXVtICovCisJCQkJYXBwZW5kU3RyaW5nSW5mbygmYnVmLAorCQkJCQkJCQkgXygi cGFyYWxsZWwgaW5kZXggdmFjdXVtL2NsZWFudXA6ICVkIHdvcmtlcnMgd2VyZSBwbGFubmVkLCAl ZCB3b3JrZXJzIHdlcmUgcmVzZXJ2ZWQgYW5kICVkIHdvcmtlcnMgd2VyZSBsYXVuY2hlZCBpbiB0 b3RhbFxuIiksCisJCQkJCQkJCSB2YWNyZWwtPndvcmtlcnNfdXNhZ2UubnBsYW5uZWQsCisJCQkJ CQkJCSB2YWNyZWwtPndvcmtlcnNfdXNhZ2UubnJlc2VydmVkLAorCQkJCQkJCQkgdmFjcmVsLT53 b3JrZXJzX3VzYWdlLm5sYXVuY2hlZCk7CisJCQl9CisJCQllbHNlIGlmICh2YWNyZWwtPndvcmtl cnNfdXNhZ2UubnBsYW5uZWQgPiAwKQorCQkJeworCQkJCS8qIFdvcmtlciB1c2FnZSBzdGF0cyBm b3IgbWFudWFsIFZBQ1VVTSAoUEFSQUxMRUwpICovCisJCQkJYXBwZW5kU3RyaW5nSW5mbygmYnVm LAorCQkJCQkJCQkgXygicGFyYWxsZWwgaW5kZXggdmFjdXVtL2NsZWFudXA6ICVkIHdvcmtlcnMg d2VyZSBwbGFubmVkIGFuZCAlZCB3b3JrZXJzIHdlcmUgbGF1bmNoZWQgaW4gdG90YWxcbiIpLAor CQkJCQkJCQkgdmFjcmVsLT53b3JrZXJzX3VzYWdlLm5wbGFubmVkLAorCQkJCQkJCQkgdmFjcmVs LT53b3JrZXJzX3VzYWdlLm5sYXVuY2hlZCk7CisJCQl9CiAJCQlmb3IgKGludCBpID0gMDsgaSA8 IHZhY3JlbC0+bmluZGV4ZXM7IGkrKykKIAkJCXsKIAkJCQlJbmRleEJ1bGtEZWxldGVSZXN1bHQg KmlzdGF0ID0gdmFjcmVsLT5pbmRzdGF0c1tpXTsKQEAgLTI2OTgsNyArMjcyNSw4IEBAIGxhenlf dmFjdXVtX2FsbF9pbmRleGVzKExWUmVsU3RhdGUgKnZhY3JlbCkKIAl7CiAJCS8qIE91dHNvdXJj ZSBldmVyeXRoaW5nIHRvIHBhcmFsbGVsIHZhcmlhbnQgKi8KIAkJcGFyYWxsZWxfdmFjdXVtX2J1 bGtkZWxfYWxsX2luZGV4ZXModmFjcmVsLT5wdnMsIG9sZF9saXZlX3R1cGxlcywKLQkJCQkJCQkJ CQkJdmFjcmVsLT5udW1faW5kZXhfc2NhbnMpOworCQkJCQkJCQkJCQl2YWNyZWwtPm51bV9pbmRl eF9zY2FucywKKwkJCQkJCQkJCQkJJnZhY3JlbC0+d29ya2Vyc191c2FnZSk7CiAKIAkJLyoKIAkJ ICogRG8gYSBwb3N0Y2hlY2sgdG8gY29uc2lkZXIgYXBwbHlpbmcgd3JhcGFyb3VuZCBmYWlsc2Fm ZSBub3cuICBOb3RlCkBAIC0zMTMxLDcgKzMxNTksOCBAQCBsYXp5X2NsZWFudXBfYWxsX2luZGV4 ZXMoTFZSZWxTdGF0ZSAqdmFjcmVsKQogCQkvKiBPdXRzb3VyY2UgZXZlcnl0aGluZyB0byBwYXJh bGxlbCB2YXJpYW50ICovCiAJCXBhcmFsbGVsX3ZhY3V1bV9jbGVhbnVwX2FsbF9pbmRleGVzKHZh Y3JlbC0+cHZzLCByZWx0dXBsZXMsCiAJCQkJCQkJCQkJCXZhY3JlbC0+bnVtX2luZGV4X3NjYW5z LAotCQkJCQkJCQkJCQllc3RpbWF0ZWRfY291bnQpOworCQkJCQkJCQkJCQllc3RpbWF0ZWRfY291 bnQsCisJCQkJCQkJCQkJCSZ2YWNyZWwtPndvcmtlcnNfdXNhZ2UpOwogCX0KIAogCS8qIFJlc2V0 IHRoZSBwcm9ncmVzcyBjb3VudGVycyAqLwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvY29tbWFu ZHMvdmFjdXVtcGFyYWxsZWwuYyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVs LmMKaW5kZXggMWUzNWI4MmFlYWYuLjQ0YzEyNThiNjllIDEwMDY0NAotLS0gYS9zcmMvYmFja2Vu ZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCisrKyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3Zh Y3V1bXBhcmFsbGVsLmMKQEAgLTIyNyw3ICsyMjcsNyBAQCBzdHJ1Y3QgUGFyYWxsZWxWYWN1dW1T dGF0ZQogc3RhdGljIGludAlwYXJhbGxlbF92YWN1dW1fY29tcHV0ZV93b3JrZXJzKFJlbGF0aW9u ICppbmRyZWxzLCBpbnQgbmluZGV4ZXMsIGludCBucmVxdWVzdGVkLAogCQkJCQkJCQkJCQlib29s ICp3aWxsX3BhcmFsbGVsX3ZhY3V1bSk7CiBzdGF0aWMgdm9pZCBwYXJhbGxlbF92YWN1dW1fcHJv Y2Vzc19hbGxfaW5kZXhlcyhQYXJhbGxlbFZhY3V1bVN0YXRlICpwdnMsIGludCBudW1faW5kZXhf c2NhbnMsCi0JCQkJCQkJCQkJCQlib29sIHZhY3V1bSk7CisJCQkJCQkJCQkJCQlib29sIHZhY3V1 bSwgUFZXb3JrZXJzVXNhZ2UgKnd1c2FnZSk7CiBzdGF0aWMgdm9pZCBwYXJhbGxlbF92YWN1dW1f cHJvY2Vzc19zYWZlX2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzKTsKIHN0YXRpYyB2 b2lkIHBhcmFsbGVsX3ZhY3V1bV9wcm9jZXNzX3Vuc2FmZV9pbmRleGVzKFBhcmFsbGVsVmFjdXVt U3RhdGUgKnB2cyk7CiBzdGF0aWMgdm9pZCBwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19vbmVfaW5k ZXgoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLCBSZWxhdGlvbiBpbmRyZWwsCkBAIC01MDIsNyAr NTAyLDcgQEAgcGFyYWxsZWxfdmFjdXVtX3Jlc2V0X2RlYWRfaXRlbXMoUGFyYWxsZWxWYWN1dW1T dGF0ZSAqcHZzKQogICovCiB2b2lkCiBwYXJhbGxlbF92YWN1dW1fYnVsa2RlbF9hbGxfaW5kZXhl cyhQYXJhbGxlbFZhY3V1bVN0YXRlICpwdnMsIGxvbmcgbnVtX3RhYmxlX3R1cGxlcywKLQkJCQkJ CQkJCWludCBudW1faW5kZXhfc2NhbnMpCisJCQkJCQkJCQlpbnQgbnVtX2luZGV4X3NjYW5zLCBQ VldvcmtlcnNVc2FnZSAqd3VzYWdlKQogewogCUFzc2VydCghSXNQYXJhbGxlbFdvcmtlcigpKTsK IApAQCAtNTEzLDcgKzUxMyw3IEBAIHBhcmFsbGVsX3ZhY3V1bV9idWxrZGVsX2FsbF9pbmRleGVz KFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywgbG9uZyBudW1fdGFibGVfdHVwCiAJcHZzLT5zaGFy ZWQtPnJlbHR1cGxlcyA9IG51bV90YWJsZV90dXBsZXM7CiAJcHZzLT5zaGFyZWQtPmVzdGltYXRl ZF9jb3VudCA9IHRydWU7CiAKLQlwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19hbGxfaW5kZXhlcyhw dnMsIG51bV9pbmRleF9zY2FucywgdHJ1ZSk7CisJcGFyYWxsZWxfdmFjdXVtX3Byb2Nlc3NfYWxs X2luZGV4ZXMocHZzLCBudW1faW5kZXhfc2NhbnMsIHRydWUsIHd1c2FnZSk7CiB9CiAKIC8qCkBA IC01MjEsNyArNTIxLDggQEAgcGFyYWxsZWxfdmFjdXVtX2J1bGtkZWxfYWxsX2luZGV4ZXMoUGFy YWxsZWxWYWN1dW1TdGF0ZSAqcHZzLCBsb25nIG51bV90YWJsZV90dXAKICAqLwogdm9pZAogcGFy YWxsZWxfdmFjdXVtX2NsZWFudXBfYWxsX2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZz LCBsb25nIG51bV90YWJsZV90dXBsZXMsCi0JCQkJCQkJCQlpbnQgbnVtX2luZGV4X3NjYW5zLCBi b29sIGVzdGltYXRlZF9jb3VudCkKKwkJCQkJCQkJCWludCBudW1faW5kZXhfc2NhbnMsIGJvb2wg ZXN0aW1hdGVkX2NvdW50LAorCQkJCQkJCQkJUFZXb3JrZXJzVXNhZ2UgKnd1c2FnZSkKIHsKIAlB c3NlcnQoIUlzUGFyYWxsZWxXb3JrZXIoKSk7CiAKQEAgLTUzMyw3ICs1MzQsNyBAQCBwYXJhbGxl bF92YWN1dW1fY2xlYW51cF9hbGxfaW5kZXhlcyhQYXJhbGxlbFZhY3V1bVN0YXRlICpwdnMsIGxv bmcgbnVtX3RhYmxlX3R1cAogCXB2cy0+c2hhcmVkLT5yZWx0dXBsZXMgPSBudW1fdGFibGVfdHVw bGVzOwogCXB2cy0+c2hhcmVkLT5lc3RpbWF0ZWRfY291bnQgPSBlc3RpbWF0ZWRfY291bnQ7CiAK LQlwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19hbGxfaW5kZXhlcyhwdnMsIG51bV9pbmRleF9zY2Fu cywgZmFsc2UpOworCXBhcmFsbGVsX3ZhY3V1bV9wcm9jZXNzX2FsbF9pbmRleGVzKHB2cywgbnVt X2luZGV4X3NjYW5zLCBmYWxzZSwgd3VzYWdlKTsKIH0KIAogLyoKQEAgLTYxOCw3ICs2MTksNyBA QCBwYXJhbGxlbF92YWN1dW1fY29tcHV0ZV93b3JrZXJzKFJlbGF0aW9uICppbmRyZWxzLCBpbnQg bmluZGV4ZXMsIGludCBucmVxdWVzdGVkLAogICovCiBzdGF0aWMgdm9pZAogcGFyYWxsZWxfdmFj dXVtX3Byb2Nlc3NfYWxsX2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLCBpbnQgbnVt X2luZGV4X3NjYW5zLAotCQkJCQkJCQkJYm9vbCB2YWN1dW0pCisJCQkJCQkJCQlib29sIHZhY3V1 bSwgUFZXb3JrZXJzVXNhZ2UgKnd1c2FnZSkKIHsKIAlpbnQJCQlud29ya2VyczsKIAlQVkluZFZh Y1N0YXR1cyBuZXdfc3RhdHVzOwpAQCAtNjU1LDEzICs2NTYsMjMgQEAgcGFyYWxsZWxfdmFjdXVt X3Byb2Nlc3NfYWxsX2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLCBpbnQgbnVtX2lu ZGV4X3NjYW4KIAkgKi8KIAlud29ya2VycyA9IE1pbihud29ya2VycywgcHZzLT5wY3h0LT5ud29y a2Vycyk7CiAKKwkvKiBSZW1lbWJlciB0aGlzIHZhbHVlLCBpZiB3ZSBhc2tlZCB0byAqLworCWlm ICh3dXNhZ2UgIT0gTlVMTCAmJiBud29ya2VycyA+IDApCisJCXd1c2FnZS0+bnBsYW5uZWQgKz0g bndvcmtlcnM7CisKIAkvKgogCSAqIFJlc2VydmUgd29ya2VycyBpbiBhdXRvdmFjdXVtIGdsb2Jh bCBzdGF0ZS4gTm90ZSB0aGF0IHdlIG1heSBiZSBnaXZlbgogCSAqIGZld2VyIHdvcmtlcnMgdGhh biB3ZSByZXF1ZXN0ZWQuCiAJICovCiAJaWYgKEFtQXV0b1ZhY3V1bVdvcmtlclByb2Nlc3MoKSAm JiBud29ya2VycyA+IDApCisJewogCQlBdXRvVmFjdXVtUmVzZXJ2ZVBhcmFsbGVsV29ya2Vycygm bndvcmtlcnMpOwogCisJCS8qIFJlbWVtYmVyIHRoaXMgdmFsdWUsIGlmIHdlIGFza2VkIHRvICov CisJCWlmICh3dXNhZ2UgIT0gTlVMTCkKKwkJCXd1c2FnZS0+bnJlc2VydmVkICs9IG53b3JrZXJz OworCX0KKwogCS8qCiAJICogU2V0IGluZGV4IHZhY3V1bSBzdGF0dXMgYW5kIG1hcmsgd2hldGhl ciBwYXJhbGxlbCB2YWN1dW0gd29ya2VyIGNhbgogCSAqIHByb2Nlc3MgaXQuCkBAIC03MjUsNiAr NzM2LDEwIEBAIHBhcmFsbGVsX3ZhY3V1bV9wcm9jZXNzX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFj dXVtU3RhdGUgKnB2cywgaW50IG51bV9pbmRleF9zY2FuCiAJCQkvKiBFbmFibGUgc2hhcmVkIGNv c3QgYmFsYW5jZSBmb3IgbGVhZGVyIGJhY2tlbmQgKi8KIAkJCVZhY3V1bVNoYXJlZENvc3RCYWxh bmNlID0gJihwdnMtPnNoYXJlZC0+Y29zdF9iYWxhbmNlKTsKIAkJCVZhY3V1bUFjdGl2ZU5Xb3Jr ZXJzID0gJihwdnMtPnNoYXJlZC0+YWN0aXZlX253b3JrZXJzKTsKKworCQkJLyogUmVtZW1iZXIg dGhpcyB2YWx1ZSwgaWYgd2UgYXNrZWQgdG8gKi8KKwkJCWlmICh3dXNhZ2UgIT0gTlVMTCkKKwkJ CQl3dXNhZ2UtPm5sYXVuY2hlZCArPSBwdnMtPnBjeHQtPm53b3JrZXJzX2xhdW5jaGVkOwogCQl9 CiAKIAkJaWYgKHZhY3V1bSkKZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL2NvbW1hbmRzL3ZhY3V1 bS5oIGIvc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmgKaW5kZXggZTg4NWE0YjljNzcuLjdj YmI1OWQxMjRmIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0uaAorKysg Yi9zcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0uaApAQCAtMzAwLDYgKzMwMCwxOSBAQCB0eXBl ZGVmIHN0cnVjdCBWYWNEZWFkSXRlbXNJbmZvCiAJaW50NjQJCW51bV9pdGVtczsJCS8qIGN1cnJl bnQgIyBvZiBlbnRyaWVzICovCiB9IFZhY0RlYWRJdGVtc0luZm87CiAKKy8qCisgKiBQVldvcmtl cnNVc2FnZSBzdG9yZXMgaW5mb3JtYXRpb24gYWJvdXQgdG90YWwgbnVtYmVyIG9mIGxhdW5jaGVk LCByZXNlcnZlZAorICogYW5kIHBsYW5uZWQgd29ya2VycyBkdXJpbmcgcGFyYWxsZWwgdmFjdXVt LgorICovCit0eXBlZGVmIHN0cnVjdCBQVldvcmtlcnNVc2FnZQoreworCWludAkJCW5wbGFubmVk OwkJLyogIyBvZiBwYXJhbGxlbCB3b3JrZXJzIHdlIGFyZSBwbGFubmVkIHRvCisJCQkJCQkJCSAq IGxhdW5jaCAqLworCWludAkJCW5yZXNlcnZlZDsJCS8qIGZvciBhdXRvdmFjdXVtIG9ubHkgLSAj IG9mIHBhcmFsbGVsIHdvcmtlcnMKKwkJCQkJCQkJICogd2UgaGF2ZSBtYW5hZ2VkIHRvIHJlc2Vy dmUgKi8KKwlpbnQJCQlubGF1bmNoZWQ7CQkvKiAjIG9mIGxhdW5jaGVkIHBhcmFsbGVsIHdvcmtl cnMgKi8KK30gUFZXb3JrZXJzVXNhZ2U7CisKIC8qIEdVQyBwYXJhbWV0ZXJzICovCiBleHRlcm4g UEdETExJTVBPUlQgaW50IGRlZmF1bHRfc3RhdGlzdGljc190YXJnZXQ7CS8qIFBHRExMSU1QT1JU IGZvciBQb3N0R0lTICovCiBleHRlcm4gUEdETExJTVBPUlQgaW50IHZhY3V1bV9mcmVlemVfbWlu X2FnZTsKQEAgLTM5NCwxMSArNDA3LDEzIEBAIGV4dGVybiBUaWRTdG9yZSAqcGFyYWxsZWxfdmFj dXVtX2dldF9kZWFkX2l0ZW1zKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywKIGV4dGVybiB2b2lk IHBhcmFsbGVsX3ZhY3V1bV9yZXNldF9kZWFkX2l0ZW1zKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2 cyk7CiBleHRlcm4gdm9pZCBwYXJhbGxlbF92YWN1dW1fYnVsa2RlbF9hbGxfaW5kZXhlcyhQYXJh bGxlbFZhY3V1bVN0YXRlICpwdnMsCiAJCQkJCQkJCQkJCQlsb25nIG51bV90YWJsZV90dXBsZXMs Ci0JCQkJCQkJCQkJCQlpbnQgbnVtX2luZGV4X3NjYW5zKTsKKwkJCQkJCQkJCQkJCWludCBudW1f aW5kZXhfc2NhbnMsCisJCQkJCQkJCQkJCQlQVldvcmtlcnNVc2FnZSAqd3VzYWdlKTsKIGV4dGVy biB2b2lkIHBhcmFsbGVsX3ZhY3V1bV9jbGVhbnVwX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFjdXVt U3RhdGUgKnB2cywKIAkJCQkJCQkJCQkJCWxvbmcgbnVtX3RhYmxlX3R1cGxlcywKIAkJCQkJCQkJ CQkJCWludCBudW1faW5kZXhfc2NhbnMsCi0JCQkJCQkJCQkJCQlib29sIGVzdGltYXRlZF9jb3Vu dCk7CisJCQkJCQkJCQkJCQlib29sIGVzdGltYXRlZF9jb3VudCwKKwkJCQkJCQkJCQkJCVBWV29y a2Vyc1VzYWdlICp3dXNhZ2UpOwogZXh0ZXJuIHZvaWQgcGFyYWxsZWxfdmFjdXVtX21haW4oZHNt X3NlZ21lbnQgKnNlZywgc2htX3RvYyAqdG9jKTsKIAogLyogaW4gY29tbWFuZHMvYW5hbHl6ZS5j ICovCmRpZmYgLS1naXQgYS9zcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdCBiL3NyYy90 b29scy9wZ2luZGVudC90eXBlZGVmcy5saXN0CmluZGV4IDNmM2E4ODhmZDBlLi5hZmViZGU3MjIz NSAxMDA2NDQKLS0tIGEvc3JjL3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZzLmxpc3QKKysrIGIvc3Jj L3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZzLmxpc3QKQEAgLTI0MDQsNiArMjQwNCw3IEBAIFB1bGxG aWx0ZXJPcHMKIFB1c2hGaWx0ZXIKIFB1c2hGaWx0ZXJPcHMKIFB1c2hGdW5jdGlvbgorUFZXb3Jr ZXJzVXNhZ2UKIFB5Q0Z1bmN0aW9uCiBQeU1ldGhvZERlZgogUHlNb2R1bGVEZWYKLS0gCjIuNDMu MAoK --0000000000004477530648969c39--