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 1vppHd-00GtLw-0K for pgsql-hackers@arkaria.postgresql.org; Tue, 10 Feb 2026 15:04:09 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1vppHb-00FkKA-0M for pgsql-hackers@arkaria.postgresql.org; Tue, 10 Feb 2026 15:04:06 +0000 Received: from magus.postgresql.org ([2a02:c0:301:0:ffff::29]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from <3danissimo@gmail.com>) id 1vppHa-00FkK1-1q for pgsql-hackers@lists.postgresql.org; Tue, 10 Feb 2026 15:04:06 +0000 Received: from mail-yw1-x1134.google.com ([2607:f8b0:4864:20::1134]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.98.2) (envelope-from <3danissimo@gmail.com>) id 1vppHW-000000021Nr-06jV for pgsql-hackers@lists.postgresql.org; Tue, 10 Feb 2026 15:04:05 +0000 Received: by mail-yw1-x1134.google.com with SMTP id 00721157ae682-79627af6349so10687827b3.0 for ; Tue, 10 Feb 2026 07:04:00 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1770735839; cv=none; d=google.com; s=arc-20240605; b=EXteNwpbkSSvZAduk03nhvf4W9CZcwdtqRezIHmAs7WPqAuglYQEbgTnQvOoVkaMLj IHgCtokDCxDeSMDsKJR1abQTwj27JxB27a2JLnqyLhQQtsuXXYGKrme3phB8dSBECqlW 4fRSy+r2VL3TnUiX71coYvDjFpGx8pO/gESARKTuXHcKlpF+OSHC9WOfpng2KGuJzjGf XIIb3NT/e/Rlt/nzZ9aMZ0zcozTJ4NfZnFGTl+wt2FMZSBKMMIN9ukmKx4oxOOueuH56 xK0Vs6fQa2brOcm0YnQF70kxO07+AlNdXSDAE2ToKG7/yN8+uvk9+XMI7c94XdhvwR/8 x3QA== 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=DcvebA4sNmfD0qmcYQ03RKEEHUMXPdngAJRJl96d3mM=; fh=GcrXIL/SRykUgTAXEUG2zP6ddqGsS9Ka/0eWKVn+KZQ=; b=YrFWIRTgO4MPYTgITk884bkPo0n2drxoSBNVJSIRjai5e0wSvcw6KOULQj2zVk8rqi pWTBwrWzvjRKhCthKShn06wYudnJRyK5Txa/cznj/80+9Wyg1C1+EOSEhc11oKESQq7v 4QeEtWsy8i2F97ATaG6YaCeDK5oRDp+6Qssme5N4Z/UgK4/FvDSZs7W+Vdfdpjnex87V FS5eRaqLaovlcw9+0qdt7Pcke5aV5HiXd0ileipHjHES9jVdAHzhsic4Vt5gX1LFKdpg oViY2Qua/TJH1LdR2py7Ku07JZY47OMM1MDpxHUVMDwtIwvbKnhyUlFWvoOh49fajCko qHqQ==; 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=1770735839; x=1771340639; 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=DcvebA4sNmfD0qmcYQ03RKEEHUMXPdngAJRJl96d3mM=; b=X/OhG7UQQtJFDo0cZ6uNPtuL/S2DgFG6DYzuK6hs+Z6ZfmYWyEID8LImmdeEU+bL3L zZ/ZPiIo/d3caQV/wi+Graq7cOjJJfbukjaAa9jqt1ToC8PTLjxN9/Cu4gPFPPsS+QYi IdbTwWmGuXZPnUR7EQKUu10RgCvr66/XrMoSicZ3OhcMmbKsgKI8SYIuxgvvwNYo9oqB nKCoPZzSuUWgSrVMRz9J/EQLsNPwAowdkfSY8huRtTt4KwxrhPATMtpEL0EDMkxBvRIQ MovwI+L98uGy8i/0fWo3uihiGdc30T0fjiBM+VoRlhcaBZgW3QK2Lcap2WhtbnPZFI8s 6CvA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1770735839; x=1771340639; 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=DcvebA4sNmfD0qmcYQ03RKEEHUMXPdngAJRJl96d3mM=; b=d1F+ZTZsJhUD9QMA5c4dlB9abHiJBeKX2Uwyx1ynrLZuRnX8G62+1UWpk25TdATqCS Yc+Aq6bW0EUd7JtDB+zug/p/tsde/WNQHwk9V8nPjfXsA1exwAkgYDnn/c/5ZMu2dV97 UttJ4Ci5DRCAC7No/fVeZHvmCwHnaKRH8FpOl6khpSZZslJKmZ0hHJoLuskn8ZdzGgAR 5XQxLR81oJW4bgTl+8S2bbsyNLT2f5Fd7RnOR03IkbXboidqAfz5zwcaUKmHWIeDJnt6 yo9RY6TwQlaq4Rya9px6DFVYwY+P3pZjjJ1tfTZmpYuLWfQnlCbWn8vUh/eyUF0FRW27 Mefg== X-Forwarded-Encrypted: i=1; AJvYcCU+RRFJ3wyRxoiDbfexQ/fXucb+WC4ChSjydJCaEM9TkAtTY65TpsOIBDVozMAA1uPlv+ZhLJwr4/jHyrnk@lists.postgresql.org X-Gm-Message-State: AOJu0YwkTmd0XYRDWnl1D4AHqvnWSwKrtEN7Y0zSOFhxkJnUd7A/CgM4 wN+TCmfYycSkoWnWkGjVD1e5vm6DtD4YPcU0TAqSeKBflu+AGdz+orVp+oBSKSy+E8sIwRO3Wfx iVV6H0bKWSTz1HA/gMzB1npm9lJsMHbI= X-Gm-Gg: AZuq6aLpnbnZ69+jfn4YBkfJWhvn18jaqykP7/30mdh8YkdYMV3cmVDFeliNvwKPETS CwAlMKEILc1zH/vb/+FY5UaxCrBgt7xI14BOXO/XzqbTwh5agZ31+TFBDDalZLhDBPty2zN6tu7 plGWBwB+L/JkXNg7HiA9JODC4WicJl3mrjfWZWm0TzsK6ppRUc+EPtReAGE9iqCCYghnC9LjHOA Rp6synESHEEEGjC2X5yt+KSCbtH19wpa4pep9osYZ2nyhxPv1HZFf1pt7+zlR6ptaMUmCUPRwYq 5l1Es7WCEiGNiDFXIQ== X-Received: by 2002:a05:690c:39d:b0:794:cf56:5bf7 with SMTP id 00721157ae682-7952ab2482amr294956937b3.33.1770735838695; Tue, 10 Feb 2026 07:03:58 -0800 (PST) MIME-Version: 1.0 References: In-Reply-To: From: Daniil Davydov <3danissimo@gmail.com> Date: Tue, 10 Feb 2026 22:03:45 +0700 X-Gm-Features: AZwV_Qgw79DHo7D9d-jz4iMKI36aK-d9HXE8B5U0aE8Nhly3_WGUQyFoqed9e3s 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="000000000000a87ec3064a7990c4" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --000000000000a87ec3064a7990c4 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Hi, Thanks everyone for the review! **Comments on the 0001 patch** On Thu, Jan 22, 2026 at 5:22=E2=80=AFAM Sami Imseih w= rote: > > > + AutoVacuumShmem->av_freeParallelWorkers =3D Max(nfree_workers, 0)= ; > + > + /* > + * Don't allow number of free workers to become less than zero if= the > + * patameter was decreased. > + */ > + AutoVacuumShmem->av_freeParallelWorkers =3D > + Max(AutoVacuumShmem->av_freeParallelWorkers, 0); > ``` > > This can probably be simplified to: > > ``` > AutoVacuumShmem->av_freeParallelWorkers =3D Max(nfree_workers, 0); > ``` On Thu, Jan 22, 2026 at 5:29=E2=80=AFAM Masahiko Sawada wrote: > > + /* > + * Cap or increase number of free parallel workers according to the > + * parameter change. > + */ > + AutoVacuumShmem->av_freeParallelWorkers =3D Max(nfree_workers, 0); > + > + /* > + * Don't allow number of free workers to become less than zero if the > + * patameter was decreased. > + */ > + AutoVacuumShmem->av_freeParallelWorkers =3D > + Max(AutoVacuumShmem->av_freeParallelWorkers, 0); > > Why does it do Max(x, 0) twice? Agreed, I missed this one. Surely it can be simplified. -- On Thu, Jan 22, 2026 at 5:29=E2=80=AFAM Masahiko Sawada wrote: > > On Sat, Jan 17, 2026 at 6:52=E2=80=AFAM Daniil Davydov <3danissimo@gmail.= com> wrote: > > > > I will keep the 'max_worker_processes' limit, so autovacuum will not > > waste time initializing a parallel context if there is no chance that > > the request will succeed. > > But it's worth remembering that actually the > > 'autovacuum_max_parallel_workers' parameter will always be implicitly > > capped by 'max_parallel_workers'. > > It doesn't make sense to me that we limit > autovacuum_max_parallel_workers by max_worker_processes TBH. When > users want to have more parallel vacuum workers for autovacuum and the > VACUUM command, they would have to consider max_worker_processes, > max_parallel_workers, and max_parallel_maintenance_workers separately. > Given that max_parallel_workers is controlling the number of > max_worker_processes that can be used in parallel operations, I > believe that parallel vacuum workers for autovacuum should also be > taken from that pool. Maybe I don't quite understand the meaning of "limited by". For example, we have a max_parallel_workers_per_gather parameter, which is limited by max_parallel_workers. But actually we can set this parameter to a value that is higher than max_parallel_workers. The limitation is that for Gather node we cannot request more workers than are available in bgworkers pool (where number of free workers is always <=3D max_parallel_workers). Thus, limitation actually exists only for bgworkers pool, on which other parallel operations depend. In particular, whatever values we set for the autovacuum_max_parallel_workers parameter, it always will depend only on bgworkers pool. I'll give in to your opinion and add a limitation by max_parallel_workers. But I still don't understand where the point is in explicit limitation by max_parallel_workers, if we already have this limitation implicitly? It seems a bit redundant for me. I hope I've conveyed my point correctly. **Comments on the 0002 patch** On Thu, Jan 22, 2026 at 5:22=E2=80=AFAM Sami Imseih w= rote: > > I don't think showing "reserved" in the logging is needed and could be > confusing. > The rationale for this is in the previous letter of Masahiko-san, and I agree with it. Do you think it can be confusing because users aren't familiar with the "reserved workers" in terms of postgres? I think that we can write about it in documentation, so users will be ready for it. -- On Thu, Jan 22, 2026 at 5:22=E2=80=AFAM Sami Imseih w= rote: > > I think it's better > to show separate lines for index vacuuming and index cleanup, just > like VACUUM VERBOSE. > > ``` > INFO: launched 2 parallel vacuum workers for index vacuuming (planned: 2= ) > INFO: launched 1 parallel vacuum worker for index cleanup (planned: 1) > ``` > Actually, we already have such a logging (see parallel_vacuum_process_all_indexes function) for both VACUUM PARALLEL and parallel autovacuum. I think that in addition we can split the final log message (with total parallel vacuum stats) into two lines : for vacuum and cleanup respectively. Please, see these changes in the 0002 patch. -- On Thu, Jan 22, 2026 at 5:29=E2=80=AFAM Masahiko Sawada wrote: > > Can we refactoring these codes to: > > if (vacrel->workers_usage.nplanned > 0)=D0=B2=D0=B2 > { > if (AmAutoVacuumWorkerProcess()) > appendStringInfo(...); > else > appendStringInfo(...); I agree. **Comments on the 0003 patch** On Thu, Jan 22, 2026 at 5:29=E2=80=AFAM Masahiko Sawada wrote: > > On Sat, Jan 17, 2026 at 6:52=E2=80=AFAM Daniil Davydov <3danissimo@gmail.= com> wrote: > > > > If behavior will be changed, then all comments for this function will n= eed 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. > > I still could not figure out why it should be mentioned here instead > of at the comment of parallel_vacuum_update_shared_delay_params(). > Readers can notice that calling > parallel_vacuum_update_shared_delay_params() for parallel vacuum > worker for the VACUUM command has no effect when reading the function. > In my opinion, we should mention here why we call > parallel_vacuum_update_shared_delay_params() but should not mention > what the called function does because it should have been described in > that function. > OK, I agree. > BTW can we expose pv_shared_cost_params so that we can check it in > vacuum_delay_point() before trying to call > parallel_vacuum_update_shared_delay_params()? > I would prefer not to do so. IMO it would be better if we'll encapsulate th= e shared delay parameters logic inside a single file. > + if (!AmAutoVacuumWorkerProcess() && IsParallelWorker()) > + { > > We can just check IsParallelWorker() here. I agree. -- On Thu, Jan 22, 2026 at 5:29=E2=80=AFAM Masahiko Sawada wrote: > > +extern void parallel_vacuum_update_shared_delay_params(void); > +extern void parallel_vacuum_propagate_cost_based_params(void); > > I think it's better to have similar names to these functions for > consistency and readability. How about the following? > > parallel_vacuum_update_delay_params(); > parallel_vacuum_propagate_delay_params(); > Yep, 100% agree - I just forgot to do it. if you don't mind, I would leave the word "shared" in the function names. -- On Thu, Jan 22, 2026 at 5:29=E2=80=AFAM Masahiko Sawada wrote: > > + params_generation =3D pg_atomic_read_u32(&pv_shared_cost_params->gene= ration); > + > + SpinLockAcquire(&pv_shared_cost_params->spinlock); > + > + pv_shared_cost_params->cost_delay =3D vacuum_cost_delay; > + pv_shared_cost_params->cost_limit =3D vacuum_cost_limit; > + pv_shared_cost_params->cost_page_dirty =3D VacuumCostPageDirty; > + pv_shared_cost_params->cost_page_hit =3D VacuumCostPageHit; > + pv_shared_cost_params->cost_page_miss =3D VacuumCostPageMiss; > > I think we can check if the new cost-based delay parameters are really > changed before changing the shared values. If users don't change > cost-based delay parameters, we don't need to increment the generation > at all. > I agree. -- On Thu, Jan 22, 2026 at 5:29=E2=80=AFAM Masahiko Sawada wrote: > > +/* > + * Only autovacuum leader can reload config file. We use this structure = in > + * parallel autovacuum for keeping worker's parameters in sync with lead= er's > + * parameters. > + */ > +typedef struct PVSharedCostParams > > I'd suggest writing the overall description first (e.g., what the > struct holds and what the function does etc), and then describing the > details and notes etc. For instance, readers might be confused when > reading the first sentence "Only autovacuum leader can reload config > file" as the struct definition is not related to the autovacuum > implementation fact that autovacuum workers can reload the config file > during the work. We would need to mention such detail somewhere in the > comments but I think it should not be the first sentence. How about > rewriting it to something like: > > +/* > + * Struct for cost-based vacuum delay related parameters to share among = an > + * autovacuum worker and its parallel vacuum workers. > + */ > Yep, you are right. > + slock_t spinlock; /* protects all fields below */ > > It's convention to name 'mutex' as a field name. > OK. -- > +static PVSharedCostParams * pv_shared_cost_params =3D NULL; > + > +/* See comments for structure above for the explanation. */ > +static uint32 shared_params_generation_local =3D 0; > > I think it's preferable to move these definitions of static variables > right before the function prototypes. > I agree. -- > + /* > + * If 'true' then we are running parallel autovacuum. Otherwise, we a= re > + * running parallel maintenence VACUUM. > + */ > + bool am_parallel_autovacuum; > > How about renaming it to use_shared_delay_params? I think it conveys > better what the field is used for. I think that we should leave this name, because in the future some other behavior differences may occur between manual VACUUM and autovacuum. If so, we will already have an "am_autovacuum" field which we can use in the code. The existing logic with the "am_autovacuum" name is also LGTM - we should use shared delay params only because we are running parallel autovacuum. -- On Thu, Jan 22, 2026 at 5:22=E2=80=AFAM Sami Imseih w= rote: > > inside vacuum_delay_point, I would re-organize the checks to > first run the code block for the a/v worker: > > ``` > if (ConfigReloadPending && AmAutoVacuumWorkerProcess()) > ``` > > then the a/v/ parallel worker: > > ``` > if (!AmAutoVacuumWorkerProcess() && IsParallelWorker()) > ``` > Besides ConfigReloadPending we also must check VacuumCostActive. I placed the call of update_shared_delay_params function *before* checking VacuumCostActive, because parallel worker can change value of this variable inside of this function. Also we should call functions related to a/v worke= r only *after* checking the VacuumCostActive. Thus, the parallel a/v worker logic should be called before leader a/v worker logic. Am I missing something? -- On Thu, Jan 22, 2026 at 5:22=E2=80=AFAM Sami Imseih w= rote: > > But I am also wondering if we should have a specific backend_type > for "autovacuum parallel worker" to differentiate that from the > existing "autovacuum worker". > > and also we can have a helper macro like: > ``` > #define AmAutoVacuumParallelWorkerProcess() (MyBackendType =3D=3D > B_AUTOVAC_PARALLEL_WORKER) > ``` > > What do you think? > I don't think that we should do it, because the workers (that are launched by a/v worker) are technically no different from other bgworkers, that are launched for other purposes. Since we easily can distinguish a/v parallel worker from others, I suggest we leave it as it is. -- On Thu, Jan 22, 2026 at 5:22=E2=80=AFAM Sami Imseih w= rote: > > Add > ``` > +typedef struct PVSharedCostParams > ```` > > to src/tools/pgindent/typedefs.list > I agree. I'll also add all new structures to the typedefs.list -- On Thu, Jan 22, 2026 at 5:22=E2=80=AFAM Sami Imseih w= rote: > > > + pg_atomic_init_u32(&shared->cost_params.generation, 0); > + SpinLockInit(&shared->cost_params.spinlock); > + pv_shared_cost_params =3D &(shared->cost_params); > > NIT: move SpinLockInit last I think that we should init the pointer to the shared->cost_params when all of this structure's fields are initialized. Thus, I guess that SpinLock= Init should be placed before the "pv_shared_cost_params =3D ...". Here it doesn't actually make any difference where to place it, but I think It's a little more beautiful. -- On Thu, Jan 22, 2026 at 5:22=E2=80=AFAM Sami Imseih w= rote: > > > Instead of: > > ``` > + params_generation =3D > pg_atomic_read_u32(&pv_shared_cost_params->generation); > + > ``` > and then later on: > ```` > + /* > + * Increase generation of the parameters, i.e. let parallel worke= rs know > + * that they should re-read shared cost params. > + */ > + pg_atomic_write_u32(&pv_shared_cost_params->generation, > + params_generation + 1); > + > + SpinLockRelease(&pv_shared_cost_params->spinlock); > ``` > > why can't we just do: > > pg_atomic_fetch_add_u32(&pv_shared_cost_params->generation, 1); > On Thu, Jan 22, 2026 at 5:29=E2=80=AFAM Masahiko Sawada wrote: > > + pg_atomic_write_u32(&pv_shared_cost_params->generation, > + params_generation + 1); > > We can use pg_atomic_add_fetch_u32() instead. > Yep, agreed. -- On Thu, Jan 22, 2026 at 5:22=E2=80=AFAM Sami Imseih w= rote: > > Also, do the pg_atomic_fetch_add_u32 outside of the spinlock. right? > Sure. Somehow I missed it. **Comments on the 0004 patch** On Thu, Jan 22, 2026 at 5:29=E2=80=AFAM Masahiko Sawada wrote: > > The patch introduces 5 injection points, which seems overkill to me > for implementing the tests. IIUC we can implement the test2 with two > injection points: 'autovacuum-start-parallel-vacuum' (set right before > lazy_scan_heap() call) and > 'autovacuum-leader-before-indexes-processing'. > > 1. stop the autovacuum worker at 'autovacuum-start-parallel-vacuum'. > 2. change delay params and reload the conf. > 3. let the autovacuum worker process tables (vacuum_delay_point() is > called during the heap scan). > 4. stop the autovacuum worker at 'autovacuum-leader-before-indexes-proces= sing'. > 5. let parallel workers process indexes (vacuum_delay_point() is > called during index vacuuming). OK, I'll do it. -- > For test3, I think we can write a DEBUG2 log in > adjust_free_parallel_workers() and check it during the test instead of > introducing the test-only function. > > Truncating all logs every after test would decrease the debuggability > much. We can pass the offset as the start point to wait for the > contents. > I've combined two of your above comments purposely. I agree that truncating all logs is a bad decision and we need to solve this in a different way. Bu= t the problem will occur If we want to 1) use logging instead of a test-only func= tion and 2) use offsets as the start point to wait for the contents in the logfi= le. Imagine that we (using the described approach) need to wait until the end o= f parallel index processing and determine the current number of free parallel workers. IIUC, It'll look like this : wait_for_av_log("autovacuum processing finished"); wait_for_av_log("number of free workers =3D N"); But when we call wait_for_av_log first time, we will advance "offset" to th= e end of logfile and thus we will miss the "number of free workers =3D N". Th= e only way to avoid it is to write a function that will determine the exact position of "autovacuum processing finished" in the logfile. Isn't it too m= uch? I think that using wait_for_av_log("autovacuum processing finished"); + SELECT get_parallel_autovacuum_free_workers(); will be much more demonstrably and simply. Moreover, the AutoVacuumGetFreeParallelWorkers function doesn't seem completely useless in isolation from tests. I suggest leaving this function and its usage in the tests. I can remove the "For testing purpose only!" comment, so everyone will be free to use this function in the future. > For test4 and test5, we check the number of free workers using > get_parallel_av_free_workers(). However, since autovacuum > could retry to vacuum the table again, the test could fail. Yep, good catch. 1) Test 5 can be stabilized as follows : We can attach to the "autovacuum-start-parallel-vacuum" injection point in the "wait" mode. Thereby when we terminate the first a/v leader, we are guaranteed that no other a/v leader will reach release/reserve functions. And then we are free to call the get_parallel_autovacuum_free_workers function. I'll additionally describe this logic in the test. 2) In the test 4 I found another problem : when a/v leader errors out, it will exit() pretty soon. And during exit() it will call the before_shmem_exit ho= ok. Thus, we cannot be sure that parallel workers has been released exactly in the try/catch block. In order to guarantee it, I think that we should lo= g something inside the try/catch block. I added a pretty controversial loggin code for it, but it is the best I came up with. In the test 4 the above idea will look something like this: $log_start =3D $node->wait_for_log( qr/error triggered for injection point / . qr/autovacuum-leader-before-indexes-processing/, $log_start ); $log_start =3D $node->wait_for_log( qr/2 parallel autovacuum workers has been released after occured error/= , $log_start ); Above I described a problem that may occur when we advance "logfile offset" too far after the first wait_for_log call. Here, this prob= lem doesn't occur because the autovacuum launcher infinitely tries to vacuum the table, so other "N workers released" messages occur. -- > And here are some general comments and suggestions: > > +use warnings FATAL =3D> 'all'; > +use PostgreSQL::Test::Cluster; > +use PostgreSQL::Test::Utils; > +use Test::More; > > We need comments to explain what we test with this test file. > OK, I'll add it. I suppose I can limit myself to a simple "Test parallel autovacuum behavior", because the specific test scenarios are described below. -- > + $node->safe_psql('postgres', qq{ > + UPDATE test_autovac SET col_1 =3D $test_number; > + ANALYZE test_autovac; > + }); > > Why do we need to execute ANALYZE as well? I added ANALYZE just in case. But I see that statistics of deleted and updated tuples is accumulated at the end of the transaction, so I agree that we can get rid of ANALYZE here. -- > +# Insert specified tuples num into the table > +$node->safe_psql('postgres', qq{ > + DO \$\$ > + DECLARE > + i INTEGER; > + BEGIN > + FOR i IN 1..$initial_rows_num LOOP > + INSERT INTO test_autovac VALUES (i, i + 1, i + 2, i + 3); > + END LOOP; > + END \$\$; > +}); > > We can use generate_series() here. And it's faster to load the data > and then create indexes. OK, I'll fix it. -- > +$node->psql('postgres', > + "SELECT get_parallel_autovacuum_free_workers();", > + stdout =3D> \$psql_out, > +); > > Please use pgsql_safe() instead. Sure! -- Again, thanks everyone for the review! I hope I didn't miss anything. Please, see updated sets of patches. This time I'll try something experimental - besides the patches I'll also post differences between corresponding patches from v20 and v21. I.e. you can apply v20--v21-diff-for-0001 on the v20-0001 patch and get the v21-0001 patch. There are a lot of changes, so I guess it will help you during review. Please, let me know whether it is useful for you. -- Best regards, Daniil Davydov --000000000000a87ec3064a7990c4 Content-Type: text/x-patch; charset="US-ASCII"; name="v21-0005-Documentation-for-parallel-autovacuum.patch" Content-Disposition: attachment; filename="v21-0005-Documentation-for-parallel-autovacuum.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mlgqd2kp0 RnJvbSBlZDMyYzEyYzA1ZGFjNWZiZmNhNTVjNzQyNGYwYzgwZDlkNThmZWY1IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBTdW4sIDIzIE5vdiAyMDI1IDAyOjMyOjQ0ICswNzAwClN1YmplY3Q6IFtQQVRD SCB2MjEgNS81XSBEb2N1bWVudGF0aW9uIGZvciBwYXJhbGxlbCBhdXRvdmFjdXVtCgotLS0KIGRv Yy9zcmMvc2dtbC9jb25maWcuc2dtbCAgICAgICAgICAgfCAxNyArKysrKysrKysrKysrKysrKwog ZG9jL3NyYy9zZ21sL21haW50ZW5hbmNlLnNnbWwgICAgICB8IDEyICsrKysrKysrKysrKwogZG9j L3NyYy9zZ21sL3JlZi9jcmVhdGVfdGFibGUuc2dtbCB8IDIwICsrKysrKysrKysrKysrKysrKysr CiAzIGZpbGVzIGNoYW5nZWQsIDQ5IGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9kb2Mvc3Jj L3NnbWwvY29uZmlnLnNnbWwgYi9kb2Mvc3JjL3NnbWwvY29uZmlnLnNnbWwKaW5kZXggMzczNDI5 ODY5NjkuLmE2ODY5YjAzNzUzIDEwMDY0NAotLS0gYS9kb2Mvc3JjL3NnbWwvY29uZmlnLnNnbWwK KysrIGIvZG9jL3NyYy9zZ21sL2NvbmZpZy5zZ21sCkBAIC0yODg2LDYgKzI4ODYsNyBAQCBpbmNs dWRlX2RpciAnY29uZi5kJwogICAgICAgICA8cGFyYT4KICAgICAgICAgIFdoZW4gY2hhbmdpbmcg dGhpcyB2YWx1ZSwgY29uc2lkZXIgYWxzbyBhZGp1c3RpbmcKICAgICAgICAgIDx4cmVmIGxpbmtl bmQ9Imd1Yy1tYXgtcGFyYWxsZWwtd29ya2VycyIvPiwKKyAgICAgICAgIDx4cmVmIGxpbmtlbmQ9 Imd1Yy1hdXRvdmFjdXVtLW1heC1wYXJhbGxlbC13b3JrZXJzIi8+LAogICAgICAgICAgPHhyZWYg bGlua2VuZD0iZ3VjLW1heC1wYXJhbGxlbC1tYWludGVuYW5jZS13b3JrZXJzIi8+LCBhbmQKICAg ICAgICAgIDx4cmVmIGxpbmtlbmQ9Imd1Yy1tYXgtcGFyYWxsZWwtd29ya2Vycy1wZXItZ2F0aGVy Ii8+LgogICAgICAgICA8L3BhcmE+CkBAIC05MzUxLDYgKzkzNTIsMjIgQEAgQ09QWSBwb3N0Z3Jl c19sb2cgRlJPTSAnL2Z1bGwvcGF0aC90by9sb2dmaWxlLmNzdicgV0lUSCBjc3Y7CiAgICAgICAg PC9saXN0aXRlbT4KICAgICAgIDwvdmFybGlzdGVudHJ5PgogCisgICAgICA8dmFybGlzdGVudHJ5 IGlkPSJndWMtYXV0b3ZhY3V1bS1tYXgtcGFyYWxsZWwtd29ya2VycyIgeHJlZmxhYmVsPSJhdXRv dmFjdXVtX21heF9wYXJhbGxlbF93b3JrZXJzIj4KKyAgICAgICAgPHRlcm0+PHZhcm5hbWU+YXV0 b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2VyczwvdmFybmFtZT4gKDx0eXBlPmludGVnZXI8L3R5 cGU+KQorICAgICAgICA8aW5kZXh0ZXJtPgorICAgICAgICAgPHByaW1hcnk+PHZhcm5hbWU+YXV0 b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2VyczwvdmFybmFtZT48L3ByaW1hcnk+CisgICAgICAg ICA8c2Vjb25kYXJ5PmNvbmZpZ3VyYXRpb24gcGFyYW1ldGVyPC9zZWNvbmRhcnk+CisgICAgICAg IDwvaW5kZXh0ZXJtPgorICAgICAgICA8L3Rlcm0+CisgICAgICAgIDxsaXN0aXRlbT4KKyAgICAg ICAgIDxwYXJhPgorICAgICAgICAgIFNldHMgdGhlIG1heGltdW0gbnVtYmVyIG9mIHBhcmFsbGVs IGF1dG92YWN1dW0gd29ya2VycyB0aGF0CisgICAgICAgICAgY2FuIGJlIHVzZWQgZm9yIHBhcmFs bGVsIGluZGV4IHZhY3V1bWluZyBhdCBvbmUgdGltZS4gSXMgY2FwcGVkIGJ5CisgICAgICAgICAg PHhyZWYgbGlua2VuZD0iZ3VjLW1heC1wYXJhbGxlbC13b3JrZXJzIi8+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= --000000000000a87ec3064a7990c4 Content-Type: text/x-patch; charset="US-ASCII"; name="v21-0001-Parallel-autovacuum.patch" Content-Disposition: attachment; filename="v21-0001-Parallel-autovacuum.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mlgqd2n14 RnJvbSAzMjA2NGIwOTVmNjMxOTAzM2JiODdlNjNjMTZjNWYxZTMyM2JmZTBmIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBTdW4sIDIzIE5vdiAyMDI1IDAxOjAzOjI0ICswNzAwClN1YmplY3Q6IFtQQVRD SCB2MjEgMS81XSBQYXJhbGxlbCBhdXRvdmFjdXVtCgotLS0KIHNyYy9iYWNrZW5kL2FjY2Vzcy9j b21tb24vcmVsb3B0aW9ucy5jICAgICAgICB8ICAxMSArKwogc3JjL2JhY2tlbmQvY29tbWFuZHMv dmFjdXVtcGFyYWxsZWwuYyAgICAgICAgIHwgIDQyICsrKystCiBzcmMvYmFja2VuZC9wb3N0bWFz dGVyL2F1dG92YWN1dW0uYyAgICAgICAgICAgfCAxNjQgKysrKysrKysrKysrKysrKystCiBzcmMv YmFja2VuZC91dGlscy9pbml0L2dsb2JhbHMuYyAgICAgICAgICAgICAgfCAgIDEgKwogc3JjL2Jh Y2tlbmQvdXRpbHMvbWlzYy9ndWMuYyAgICAgICAgICAgICAgICAgIHwgICA4ICstCiBzcmMvYmFj a2VuZC91dGlscy9taXNjL2d1Y19wYXJhbWV0ZXJzLmRhdCAgICAgfCAgIDggKwogc3JjL2JhY2tl bmQvdXRpbHMvbWlzYy9wb3N0Z3Jlc3FsLmNvbmYuc2FtcGxlIHwgICAxICsKIHNyYy9iaW4vcHNx bC90YWItY29tcGxldGUuaW4uYyAgICAgICAgICAgICAgICB8ICAgMSArCiBzcmMvaW5jbHVkZS9t aXNjYWRtaW4uaCAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEgKwogc3JjL2luY2x1ZGUvcG9z dG1hc3Rlci9hdXRvdmFjdXVtLmggICAgICAgICAgIHwgICA1ICsKIHNyYy9pbmNsdWRlL3V0aWxz L3JlbC5oICAgICAgICAgICAgICAgICAgICAgICB8ICAgNyArCiAxMSBmaWxlcyBjaGFuZ2VkLCAy MzkgaW5zZXJ0aW9ucygrKSwgMTAgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tl bmQvYWNjZXNzL2NvbW1vbi9yZWxvcHRpb25zLmMgYi9zcmMvYmFja2VuZC9hY2Nlc3MvY29tbW9u L3JlbG9wdGlvbnMuYwppbmRleCAyMzdhYjhkMGVkOS4uOTQ1OWEwMTBjYzMgMTAwNjQ0Ci0tLSBh L3NyYy9iYWNrZW5kL2FjY2Vzcy9jb21tb24vcmVsb3B0aW9ucy5jCisrKyBiL3NyYy9iYWNrZW5k L2FjY2Vzcy9jb21tb24vcmVsb3B0aW9ucy5jCkBAIC0yMzUsNiArMjM1LDE1IEBAIHN0YXRpYyBy ZWxvcHRfaW50IGludFJlbE9wdHNbXSA9CiAJCX0sCiAJCVNQR0lTVF9ERUZBVUxUX0ZJTExGQUNU T1IsIFNQR0lTVF9NSU5fRklMTEZBQ1RPUiwgMTAwCiAJfSwKKwl7CisJCXsKKwkJCSJhdXRvdmFj dXVtX3BhcmFsbGVsX3dvcmtlcnMiLAorCQkJIk1heGltdW0gbnVtYmVyIG9mIHBhcmFsbGVsIGF1 dG92YWN1dW0gd29ya2VycyB0aGF0IGNhbiBiZSB1c2VkIGZvciBwcm9jZXNzaW5nIHRoaXMgdGFi bGUuIiwKKwkJCVJFTE9QVF9LSU5EX0hFQVAsCisJCQlTaGFyZVVwZGF0ZUV4Y2x1c2l2ZUxvY2sK KwkJfSwKKwkJLTEsIC0xLCAxMDI0CisJfSwKIAl7CiAJCXsKIAkJCSJhdXRvdmFjdXVtX3ZhY3V1 bV90aHJlc2hvbGQiLApAQCAtMTk2OCw2ICsxOTc3LDggQEAgZGVmYXVsdF9yZWxvcHRpb25zKERh dHVtIHJlbG9wdGlvbnMsIGJvb2wgdmFsaWRhdGUsIHJlbG9wdF9raW5kIGtpbmQpCiAJCXsiZmls bGZhY3RvciIsIFJFTE9QVF9UWVBFX0lOVCwgb2Zmc2V0b2YoU3RkUmRPcHRpb25zLCBmaWxsZmFj dG9yKX0sCiAJCXsiYXV0b3ZhY3V1bV9lbmFibGVkIiwgUkVMT1BUX1RZUEVfQk9PTCwKIAkJb2Zm c2V0b2YoU3RkUmRPcHRpb25zLCBhdXRvdmFjdXVtKSArIG9mZnNldG9mKEF1dG9WYWNPcHRzLCBl bmFibGVkKX0sCisJCXsiYXV0b3ZhY3V1bV9wYXJhbGxlbF93b3JrZXJzIiwgUkVMT1BUX1RZUEVf SU5ULAorCQlvZmZzZXRvZihTdGRSZE9wdGlvbnMsIGF1dG92YWN1dW0pICsgb2Zmc2V0b2YoQXV0 b1ZhY09wdHMsIGF1dG92YWN1dW1fcGFyYWxsZWxfd29ya2Vycyl9LAogCQl7ImF1dG92YWN1dW1f dmFjdXVtX3RocmVzaG9sZCIsIFJFTE9QVF9UWVBFX0lOVCwKIAkJb2Zmc2V0b2YoU3RkUmRPcHRp b25zLCBhdXRvdmFjdXVtKSArIG9mZnNldG9mKEF1dG9WYWNPcHRzLCB2YWN1dW1fdGhyZXNob2xk KX0sCiAJCXsiYXV0b3ZhY3V1bV92YWN1dW1fbWF4X3RocmVzaG9sZCIsIFJFTE9QVF9UWVBFX0lO VCwKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMgYi9z cmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCmluZGV4IGMzYjNjOWVhMjFhLi5k M2UwYzMyYjdlZSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxs ZWwuYworKysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCkBAIC0xLDcg KzEsOSBAQAogLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgKgogICogdmFjdXVtcGFyYWxsZWwuYwotICoJ ICBTdXBwb3J0IHJvdXRpbmVzIGZvciBwYXJhbGxlbCB2YWN1dW0gZXhlY3V0aW9uLgorICoJICBT dXBwb3J0IHJvdXRpbmVzIGZvciBwYXJhbGxlbCB2YWN1dW0gYW5kIGF1dG92YWN1dW0gZXhlY3V0 aW9uLiBJbiB0aGUKKyAqCSAgY29tbWVudHMgYmVsb3csIHRoZSB3b3JkICJ2YWN1dW0iIHdpbGwg cmVmZXIgdG8gYm90aCB2YWN1dW0gYW5kCisgKgkgIGF1dG92YWN1dW0uCiAgKgogICogVGhpcyBm aWxlIGNvbnRhaW5zIHJvdXRpbmVzIHRoYXQgYXJlIGludGVuZGVkIHRvIHN1cHBvcnQgc2V0dGlu ZyB1cCwgdXNpbmcsCiAgKiBhbmQgdGVhcmluZyBkb3duIGEgUGFyYWxsZWxWYWN1dW1TdGF0ZS4K QEAgLTM0LDYgKzM2LDcgQEAKICNpbmNsdWRlICJleGVjdXRvci9pbnN0cnVtZW50LmgiCiAjaW5j bHVkZSAib3B0aW1pemVyL3BhdGhzLmgiCiAjaW5jbHVkZSAicGdzdGF0LmgiCisjaW5jbHVkZSAi cG9zdG1hc3Rlci9hdXRvdmFjdXVtLmgiCiAjaW5jbHVkZSAic3RvcmFnZS9idWZtZ3IuaCIKICNp bmNsdWRlICJ0Y29wL3Rjb3Bwcm90LmgiCiAjaW5jbHVkZSAidXRpbHMvbHN5c2NhY2hlLmgiCkBA IC0zNzMsOCArMzc2LDkgQEAgcGFyYWxsZWxfdmFjdXVtX2luaXQoUmVsYXRpb24gcmVsLCBSZWxh dGlvbiAqaW5kcmVscywgaW50IG5pbmRleGVzLAogCXNoYXJlZC0+cXVlcnlpZCA9IHBnc3RhdF9n ZXRfbXlfcXVlcnlfaWQoKTsKIAlzaGFyZWQtPm1haW50ZW5hbmNlX3dvcmtfbWVtX3dvcmtlciA9 CiAJCShuaW5kZXhlc19td20gPiAwKSA/Ci0JCW1haW50ZW5hbmNlX3dvcmtfbWVtIC8gTWluKHBh cmFsbGVsX3dvcmtlcnMsIG5pbmRleGVzX213bSkgOgotCQltYWludGVuYW5jZV93b3JrX21lbTsK KwkJdmFjX3dvcmtfbWVtIC8gTWluKHBhcmFsbGVsX3dvcmtlcnMsIG5pbmRleGVzX213bSkgOgor CQl2YWNfd29ya19tZW07CisKIAlzaGFyZWQtPmRlYWRfaXRlbXNfaW5mby5tYXhfYnl0ZXMgPSB2 YWNfd29ya19tZW0gKiAoc2l6ZV90KSAxMDI0OwogCiAJLyogUHJlcGFyZSBEU0Egc3BhY2UgZm9y IGRlYWQgaXRlbXMgKi8KQEAgLTU1MywxMiArNTU3LDE3IEBAIHBhcmFsbGVsX3ZhY3V1bV9jb21w dXRlX3dvcmtlcnMoUmVsYXRpb24gKmluZHJlbHMsIGludCBuaW5kZXhlcywgaW50IG5yZXF1ZXN0 ZWQsCiAJaW50CQkJbmluZGV4ZXNfcGFyYWxsZWxfYnVsa2RlbCA9IDA7CiAJaW50CQkJbmluZGV4 ZXNfcGFyYWxsZWxfY2xlYW51cCA9IDA7CiAJaW50CQkJcGFyYWxsZWxfd29ya2VyczsKKwlpbnQJ CQltYXhfd29ya2VyczsKKworCW1heF93b3JrZXJzID0gQW1BdXRvVmFjdXVtV29ya2VyUHJvY2Vz cygpID8KKwkJYXV0b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2VycyA6CisJCW1heF9wYXJhbGxl bF9tYWludGVuYW5jZV93b3JrZXJzOwogCiAJLyoKIAkgKiBXZSBkb24ndCBhbGxvdyBwZXJmb3Jt aW5nIHBhcmFsbGVsIG9wZXJhdGlvbiBpbiBzdGFuZGFsb25lIGJhY2tlbmQgb3IKIAkgKiB3aGVu IHBhcmFsbGVsaXNtIGlzIGRpc2FibGVkLgogCSAqLwotCWlmICghSXNVbmRlclBvc3RtYXN0ZXIg fHwgbWF4X3BhcmFsbGVsX21haW50ZW5hbmNlX3dvcmtlcnMgPT0gMCkKKwlpZiAoIUlzVW5kZXJQ b3N0bWFzdGVyIHx8IG1heF93b3JrZXJzID09IDApCiAJCXJldHVybiAwOwogCiAJLyoKQEAgLTU5 Nyw4ICs2MDYsOCBAQCBwYXJhbGxlbF92YWN1dW1fY29tcHV0ZV93b3JrZXJzKFJlbGF0aW9uICpp bmRyZWxzLCBpbnQgbmluZGV4ZXMsIGludCBucmVxdWVzdGVkLAogCXBhcmFsbGVsX3dvcmtlcnMg PSAobnJlcXVlc3RlZCA+IDApID8KIAkJTWluKG5yZXF1ZXN0ZWQsIG5pbmRleGVzX3BhcmFsbGVs KSA6IG5pbmRleGVzX3BhcmFsbGVsOwogCi0JLyogQ2FwIGJ5IG1heF9wYXJhbGxlbF9tYWludGVu YW5jZV93b3JrZXJzICovCi0JcGFyYWxsZWxfd29ya2VycyA9IE1pbihwYXJhbGxlbF93b3JrZXJz LCBtYXhfcGFyYWxsZWxfbWFpbnRlbmFuY2Vfd29ya2Vycyk7CisJLyogQ2FwIGJ5IEdVQyB2YXJp YWJsZSAqLworCXBhcmFsbGVsX3dvcmtlcnMgPSBNaW4ocGFyYWxsZWxfd29ya2VycywgbWF4X3dv cmtlcnMpOwogCiAJcmV0dXJuIHBhcmFsbGVsX3dvcmtlcnM7CiB9CkBAIC02NDYsNiArNjU1LDEz IEBAIHBhcmFsbGVsX3ZhY3V1bV9wcm9jZXNzX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3Rh dGUgKnB2cywgaW50IG51bV9pbmRleF9zY2FuCiAJICovCiAJbndvcmtlcnMgPSBNaW4obndvcmtl cnMsIHB2cy0+cGN4dC0+bndvcmtlcnMpOwogCisJLyoKKwkgKiBSZXNlcnZlIHdvcmtlcnMgaW4g YXV0b3ZhY3V1bSBnbG9iYWwgc3RhdGUuIE5vdGUgdGhhdCB3ZSBtYXkgYmUgZ2l2ZW4KKwkgKiBm ZXdlciB3b3JrZXJzIHRoYW4gd2UgcmVxdWVzdGVkLgorCSAqLworCWlmIChBbUF1dG9WYWN1dW1X b3JrZXJQcm9jZXNzKCkgJiYgbndvcmtlcnMgPiAwKQorCQlBdXRvVmFjdXVtUmVzZXJ2ZVBhcmFs bGVsV29ya2VycygmbndvcmtlcnMpOworCiAJLyoKIAkgKiBTZXQgaW5kZXggdmFjdXVtIHN0YXR1 cyBhbmQgbWFyayB3aGV0aGVyIHBhcmFsbGVsIHZhY3V1bSB3b3JrZXIgY2FuCiAJICogcHJvY2Vz cyBpdC4KQEAgLTY5MCw2ICs3MDYsMTYgQEAgcGFyYWxsZWxfdmFjdXVtX3Byb2Nlc3NfYWxsX2lu ZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLCBpbnQgbnVtX2luZGV4X3NjYW4KIAogCQlM YXVuY2hQYXJhbGxlbFdvcmtlcnMocHZzLT5wY3h0KTsKIAorCQkvKgorCQkgKiBUZWxsIGF1dG92 YWN1dW0gdGhhdCB3ZSBjb3VsZCBub3QgbGF1bmNoIGFsbCB0aGUgcHJldmlvdXNseQorCQkgKiBy ZXNlcnZlZCB3b3JrZXJzLgorCQkgKi8KKwkJaWYgKEFtQXV0b1ZhY3V1bVdvcmtlclByb2Nlc3Mo KSAmJgorCQkJcHZzLT5wY3h0LT5ud29ya2Vyc19sYXVuY2hlZCA8IG53b3JrZXJzKQorCQl7CisJ CQlBdXRvVmFjdXVtUmVsZWFzZVBhcmFsbGVsV29ya2Vycyhud29ya2VycyAtIHB2cy0+cGN4dC0+ bndvcmtlcnNfbGF1bmNoZWQpOworCQl9CisKIAkJaWYgKHB2cy0+cGN4dC0+bndvcmtlcnNfbGF1 bmNoZWQgPiAwKQogCQl7CiAJCQkvKgpAQCAtNzM4LDYgKzc2NCwxMCBAQCBwYXJhbGxlbF92YWN1 dW1fcHJvY2Vzc19hbGxfaW5kZXhlcyhQYXJhbGxlbFZhY3V1bVN0YXRlICpwdnMsIGludCBudW1f aW5kZXhfc2NhbgogCiAJCWZvciAoaW50IGkgPSAwOyBpIDwgcHZzLT5wY3h0LT5ud29ya2Vyc19s YXVuY2hlZDsgaSsrKQogCQkJSW5zdHJBY2N1bVBhcmFsbGVsUXVlcnkoJnB2cy0+YnVmZmVyX3Vz YWdlW2ldLCAmcHZzLT53YWxfdXNhZ2VbaV0pOworCisJCS8qIFJlbGVhc2UgYWxsIHRoZSByZXNl cnZlZCBwYXJhbGxlbCB3b3JrZXJzIGZvciBhdXRvdmFjdXVtICovCisJCWlmIChBbUF1dG9WYWN1 dW1Xb3JrZXJQcm9jZXNzKCkgJiYgcHZzLT5wY3h0LT5ud29ya2Vyc19sYXVuY2hlZCA+IDApCisJ CQlBdXRvVmFjdXVtUmVsZWFzZUFsbFBhcmFsbGVsV29ya2VycygpOwogCX0KIAogCS8qCmRpZmYg LS1naXQgYS9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYyBiL3NyYy9iYWNrZW5k L3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCmluZGV4IDZmZGU3NDA0NjVmLi5mNDBhYmU5MGVkNSAx MDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMKKysrIGIvc3Jj L2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMKQEAgLTE1MSw2ICsxNTEsMTMgQEAgaW50 CQkJTG9nX2F1dG9hbmFseXplX21pbl9kdXJhdGlvbiA9IDYwMDAwMDsKIHN0YXRpYyBkb3VibGUg YXZfc3RvcmFnZV9wYXJhbV9jb3N0X2RlbGF5ID0gLTE7CiBzdGF0aWMgaW50CWF2X3N0b3JhZ2Vf cGFyYW1fY29zdF9saW1pdCA9IC0xOwogCisvKgorICogVHJhY2tzIHRoZSBudW1iZXIgb2YgcGFy YWxsZWwgd29ya2VycyBjdXJyZW50bHkgcmVzZXJ2ZWQgYnkgdGhlCisgKiBhdXRvdmFjdXVtIHdv cmtlci4gVGhpcyBpcyBub24temVybyBvbmx5IGZvciB0aGUgcGFyYWxsZWwgYXV0b3ZhY3V1bQor ICogbGVhZGVyIHByb2Nlc3MuCisgKi8KK3N0YXRpYyBpbnQJYXZfbndvcmtlcnNfcmVzZXJ2ZWQg PSAwOworCiAvKiBGbGFncyBzZXQgYnkgc2lnbmFsIGhhbmRsZXJzICovCiBzdGF0aWMgdm9sYXRp bGUgc2lnX2F0b21pY190IGdvdF9TSUdVU1IyID0gZmFsc2U7CiAKQEAgLTI4NSw2ICsyOTIsOCBA QCB0eXBlZGVmIHN0cnVjdCBBdXRvVmFjdXVtV29ya0l0ZW0KICAqIGF2X3dvcmtJdGVtcwkJd29y ayBpdGVtIGFycmF5CiAgKiBhdl9ud29ya2Vyc0ZvckJhbGFuY2UgdGhlIG51bWJlciBvZiBhdXRv dmFjdXVtIHdvcmtlcnMgdG8gdXNlIHdoZW4KICAqIAkJCQkJY2FsY3VsYXRpbmcgdGhlIHBlciB3 b3JrZXIgY29zdCBsaW1pdAorICogYXZfZnJlZVBhcmFsbGVsV29ya2VycyB0aGUgbnVtYmVyIG9m IGZyZWUgcGFyYWxsZWwgYXV0b3ZhY3V1bSB3b3JrZXJzCisgKiBhdl9tYXhQYXJhbGxlbFdvcmtl cnMgdGhlIG1heGltdW0gbnVtYmVyIG9mIHBhcmFsbGVsIGF1dG92YWN1dW0gd29ya2VycwogICoK ICAqIFRoaXMgc3RydWN0IGlzIHByb3RlY3RlZCBieSBBdXRvdmFjdXVtTG9jaywgZXhjZXB0IGZv ciBhdl9zaWduYWwgYW5kIHBhcnRzCiAgKiBvZiB0aGUgd29ya2VyIGxpc3QgKHNlZSBhYm92ZSku CkBAIC0yOTksNiArMzA4LDggQEAgdHlwZWRlZiBzdHJ1Y3QKIAlXb3JrZXJJbmZvCWF2X3N0YXJ0 aW5nV29ya2VyOwogCUF1dG9WYWN1dW1Xb3JrSXRlbSBhdl93b3JrSXRlbXNbTlVNX1dPUktJVEVN U107CiAJcGdfYXRvbWljX3VpbnQzMiBhdl9ud29ya2Vyc0ZvckJhbGFuY2U7CisJdWludDMyCQlh dl9mcmVlUGFyYWxsZWxXb3JrZXJzOworCXVpbnQzMgkJYXZfbWF4UGFyYWxsZWxXb3JrZXJzOwog fSBBdXRvVmFjdXVtU2htZW1TdHJ1Y3Q7CiAKIHN0YXRpYyBBdXRvVmFjdXVtU2htZW1TdHJ1Y3Qg KkF1dG9WYWN1dW1TaG1lbTsKQEAgLTM2MSw2ICszNzIsNyBAQCBzdGF0aWMgdm9pZCBhdXRvdmFj X3JlcG9ydF93b3JraXRlbShBdXRvVmFjdXVtV29ya0l0ZW0gKndvcmtpdGVtLAogc3RhdGljIHZv aWQgYXZsX3NpZ3VzcjJfaGFuZGxlcihTSUdOQUxfQVJHUyk7CiBzdGF0aWMgYm9vbCBhdl93b3Jr ZXJfYXZhaWxhYmxlKHZvaWQpOwogc3RhdGljIHZvaWQgY2hlY2tfYXZfd29ya2VyX2d1Y3Modm9p ZCk7CitzdGF0aWMgdm9pZCBhZGp1c3RfZnJlZV9wYXJhbGxlbF93b3JrZXJzKGludCBwcmV2X21h eF9wYXJhbGxlbF93b3JrZXJzKTsKIAogCiAKQEAgLTc1OSw2ICs3NzEsOCBAQCBQcm9jZXNzQXV0 b1ZhY0xhdW5jaGVySW50ZXJydXB0cyh2b2lkKQogCWlmIChDb25maWdSZWxvYWRQZW5kaW5nKQog CXsKIAkJaW50CQkJYXV0b3ZhY3V1bV9tYXhfd29ya2Vyc19wcmV2ID0gYXV0b3ZhY3V1bV9tYXhf d29ya2VyczsKKwkJaW50CQkJYXV0b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2Vyc19wcmV2ID0K KwkJCWF1dG92YWN1dW1fbWF4X3BhcmFsbGVsX3dvcmtlcnM7CiAKIAkJQ29uZmlnUmVsb2FkUGVu ZGluZyA9IGZhbHNlOwogCQlQcm9jZXNzQ29uZmlnRmlsZShQR0NfU0lHSFVQKTsKQEAgLTc3NSw2 ICs3ODksMTUgQEAgUHJvY2Vzc0F1dG9WYWNMYXVuY2hlckludGVycnVwdHModm9pZCkKIAkJaWYg KGF1dG92YWN1dW1fbWF4X3dvcmtlcnNfcHJldiAhPSBhdXRvdmFjdXVtX21heF93b3JrZXJzKQog CQkJY2hlY2tfYXZfd29ya2VyX2d1Y3MoKTsKIAorCQkvKgorCQkgKiBJZiBhdXRvdmFjdXVtX21h eF9wYXJhbGxlbF93b3JrZXJzIGNoYW5nZWQsIHdlIG11c3QgdGFrZSBjYXJlIG9mCisJCSAqIHRo ZSBjb3JyZWN0IHZhbHVlIG9mIGF2YWlsYWJsZSBwYXJhbGxlbCBhdXRvdmFjdXVtIHdvcmtlcnMg aW4KKwkJICogc2htZW0uCisJCSAqLworCQlpZiAoYXV0b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29y a2Vyc19wcmV2ICE9CisJCQlhdXRvdmFjdXVtX21heF9wYXJhbGxlbF93b3JrZXJzKQorCQkJYWRq dXN0X2ZyZWVfcGFyYWxsZWxfd29ya2VycyhhdXRvdmFjdXVtX21heF9wYXJhbGxlbF93b3JrZXJz X3ByZXYpOworCiAJCS8qIHJlYnVpbGQgdGhlIGxpc3QgaW4gY2FzZSB0aGUgbmFwdGltZSBjaGFu Z2VkICovCiAJCXJlYnVpbGRfZGF0YWJhc2VfbGlzdChJbnZhbGlkT2lkKTsKIAl9CkBAIC0xMzc5 LDYgKzE0MDIsMTYgQEAgYXZsX3NpZ3VzcjJfaGFuZGxlcihTSUdOQUxfQVJHUykKICAqCQkJCQkg IEFVVE9WQUNVVU0gV09SS0VSIENPREUKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAorLyoKKyAqIE1ha2Ugc3Vy ZSB0aGF0IGFsbCByZXNlcnZlZCB3b3JrZXJzIGFyZSByZWxlYXNlZCwgZXZlbiBpZiBwYXJhbGxl bAorICogYXV0b3ZhY3V1bSBsZWFkZXIgaXMgZmluaXNoaW5nIGR1ZSB0byBGQVRBTCBlcnJvci4K KyAqLworc3RhdGljIHZvaWQKK2F1dG92YWN1dW1fd29ya2VyX2JlZm9yZV9zaG1lbV9leGl0KGlu dCBjb2RlLCBEYXR1bSBhcmcpCit7CisJQXV0b1ZhY3V1bVJlbGVhc2VBbGxQYXJhbGxlbFdvcmtl cnMoKTsKK30KKwogLyoKICAqIE1haW4gZW50cnkgcG9pbnQgZm9yIGF1dG92YWN1dW0gd29ya2Vy IHByb2Nlc3Nlcy4KICAqLwpAQCAtMjI3NSw2ICsyMzA4LDEyIEBAIGRvX2F1dG92YWN1dW0odm9p ZCkKIAkJCQkJCQkJCQkgICJBdXRvdmFjdXVtIFBvcnRhbCIsCiAJCQkJCQkJCQkJICBBTExPQ1NF VF9ERUZBVUxUX1NJWkVTKTsKIAorCS8qCisJICogUGFyYWxsZWwgYXV0b3ZhY3V1bSBjYW4gcmVz ZXJ2ZSBwYXJhbGxlbCB3b3JrZXJzLiBNYWtlIHN1cmUgdGhhdCBhbGwKKwkgKiByZXNlcnZlZCB3 b3JrZXJzIGFyZSByZWxlYXNlZCBldmVuIGFmdGVyIEZBVEFMIGVycm9yLgorCSAqLworCWJlZm9y ZV9zaG1lbV9leGl0KGF1dG92YWN1dW1fd29ya2VyX2JlZm9yZV9zaG1lbV9leGl0LCAwKTsKKwog CS8qCiAJICogUGVyZm9ybSBvcGVyYXRpb25zIG9uIGNvbGxlY3RlZCB0YWJsZXMuCiAJICovCkBA IC0yNDU2LDYgKzI0OTUsMTIgQEAgZG9fYXV0b3ZhY3V1bSh2b2lkKQogCQl9CiAJCVBHX0NBVENI KCk7CiAJCXsKKwkJCS8qCisJCQkgKiBQYXJhbGxlbCBhdXRvdmFjdXVtIGNhbiByZXNlcnZlIHBh cmFsbGVsIHdvcmtlcnMuIE1ha2Ugc3VyZQorCQkJICogdGhhdCBhbGwgcmVzZXJ2ZWQgd29ya2Vy cyBhcmUgcmVsZWFzZWQuCisJCQkgKi8KKwkJCUF1dG9WYWN1dW1SZWxlYXNlQWxsUGFyYWxsZWxX b3JrZXJzKCk7CisKIAkJCS8qCiAJCQkgKiBBYm9ydCB0aGUgdHJhbnNhY3Rpb24sIHN0YXJ0IGEg bmV3IG9uZSwgYW5kIHByb2NlZWQgd2l0aCB0aGUKIAkJCSAqIG5leHQgdGFibGUgaW4gb3VyIGxp c3QuCkBAIC0yODU2LDggKzI5MDEsMTIgQEAgdGFibGVfcmVjaGVja19hdXRvdmFjKE9pZCByZWxp ZCwgSFRBQiAqdGFibGVfdG9hc3RfbWFwLAogCQkgKi8KIAkJdGFiLT5hdF9wYXJhbXMuaW5kZXhf Y2xlYW51cCA9IFZBQ09QVFZBTFVFX1VOU1BFQ0lGSUVEOwogCQl0YWItPmF0X3BhcmFtcy50cnVu Y2F0ZSA9IFZBQ09QVFZBTFVFX1VOU1BFQ0lGSUVEOwotCQkvKiBBcyBvZiBub3csIHdlIGRvbid0 IHN1cHBvcnQgcGFyYWxsZWwgdmFjdXVtIGZvciBhdXRvdmFjdXVtICovCi0JCXRhYi0+YXRfcGFy YW1zLm53b3JrZXJzID0gLTE7CisKKwkJLyogRGVjaWRlIHdoZXRoZXIgd2UgbmVlZCB0byBwcm9j ZXNzIGluZGV4ZXMgb2YgdGFibGUgaW4gcGFyYWxsZWwuICovCisJCXRhYi0+YXRfcGFyYW1zLm53 b3JrZXJzID0gYXZvcHRzCisJCQk/IGF2b3B0cy0+YXV0b3ZhY3V1bV9wYXJhbGxlbF93b3JrZXJz CisJCQk6IC0xOworCiAJCXRhYi0+YXRfcGFyYW1zLmZyZWV6ZV9taW5fYWdlID0gZnJlZXplX21p bl9hZ2U7CiAJCXRhYi0+YXRfcGFyYW1zLmZyZWV6ZV90YWJsZV9hZ2UgPSBmcmVlemVfdGFibGVf YWdlOwogCQl0YWItPmF0X3BhcmFtcy5tdWx0aXhhY3RfZnJlZXplX21pbl9hZ2UgPSBtdWx0aXhh Y3RfZnJlZXplX21pbl9hZ2U7CkBAIC0zMzM0LDYgKzMzODMsODggQEAgQXV0b1ZhY3V1bVJlcXVl c3RXb3JrKEF1dG9WYWN1dW1Xb3JrSXRlbVR5cGUgdHlwZSwgT2lkIHJlbGF0aW9uSWQsCiAJcmV0 dXJuIHJlc3VsdDsKIH0KIAorLyoKKyAqIFJlc2VydmVzIHBhcmFsbGVsIHdvcmtlcnMgZm9yIGF1 dG92YWN1dW0uCisgKgorICogbndvcmtlcnMgaXMgYW4gaW4vb3V0IHBhcmFtZXRlcjsgdGhlIHJl cXVlc3RlZCBudW1iZXIgb2YgcGFyYWxsZWwgd29ya2VycworICogdG8gcmVzZXJ2ZSBieSB0aGUg Y2FsbGVyLCBhbmQgc2V0IHRvIHRoZSBhY3R1YWwgbnVtYmVyIG9mIHJlc2VydmVkIHdvcmtlcnMu CisgKgorICogVGhlIGNhbGxlciBtdXN0IGNhbGwgQXV0b1ZhY3V1bVJlbGVhc2VbQWxsXVBhcmFs bGVsV29ya2VycygpIHRvIHJlbGVhc2UgdGhlCisgKiByZXNlcnZlZCB3b3JrZXJzLgorICoKKyAq IE5PVEU6IFdlIHdpbGwgdHJ5IHRvIHByb3ZpZGUgYXMgbWFueSB3b3JrZXJzIGFzIHJlcXVlc3Rl ZCwgZXZlbiBpZiBjYWxsZXIKKyAqIHdpbGwgb2NjdXB5IGFsbCBhdmFpbGFibGUgd29ya2Vycy4K KyAqLwordm9pZAorQXV0b1ZhY3V1bVJlc2VydmVQYXJhbGxlbFdvcmtlcnMoaW50ICpud29ya2Vy cykKK3sKKwkvKiBPbmx5IGxlYWRlciBhdXRvdmFjdXVtIHdvcmtlciBjYW4gY2FsbCB0aGlzIGZ1 bmN0aW9uLiAqLworCUFzc2VydChBbUF1dG9WYWN1dW1Xb3JrZXJQcm9jZXNzKCkpOworCisJLyog VGhlIHdvcmtlciBtdXN0IG5vdCBoYXZlIGFueSByZXNlcnZlZCB3b3JrZXJzIHlldCAqLworCUFz c2VydChhdl9ud29ya2Vyc19yZXNlcnZlZCA9PSAwKTsKKworCUxXTG9ja0FjcXVpcmUoQXV0b3Zh Y3V1bUxvY2ssIExXX0VYQ0xVU0lWRSk7CisKKwkvKiBQcm92aWRlIGFzIG1hbnkgd29ya2VycyBh cyB3ZSBjYW4uICovCisJKm53b3JrZXJzID0gTWluKEF1dG9WYWN1dW1TaG1lbS0+YXZfZnJlZVBh cmFsbGVsV29ya2VycywgKm53b3JrZXJzKTsKKwlBdXRvVmFjdXVtU2htZW0tPmF2X2ZyZWVQYXJh bGxlbFdvcmtlcnMgLT0gKm53b3JrZXJzOworCisJTFdMb2NrUmVsZWFzZShBdXRvdmFjdXVtTG9j ayk7CisKKwkvKiBSZW1lbWJlciBob3cgbWFueSB3b3JrZXJzIHdlIGhhdmUgcmVzZXJ2ZWQuICov CisJYXZfbndvcmtlcnNfcmVzZXJ2ZWQgPSAqbndvcmtlcnM7Cit9CisKKy8qCisgKiBSZWxlYXNl cyB0aGUgcmVzZXJ2ZWQgcGFyYWxsZWwgd29ya2VycyBmb3IgYXV0b3ZhY3V1bS4KKyAqCisgKiBU aGlzIGZ1bmN0aW9uIHNob3VsZCBiZSB1c2VkIHRvIHJlbGVhc2UgdGhlIHBhcmFsbGVsIHdvcmtl cnMgdGhhdCBhbgorICogYXV0b3ZhY3V1bSB3b3JrZXIgcmVzZXJ2ZWQgYnkgQXV0b1ZhY3V1bVJl c2VydmVQYXJhbGxlbFdvcmtlcnMoKS4gbndvcmtlcnMKKyAqIGlzIHRoZSBudW1iZXIgb2Ygd29y a2VycyB0byByZWxlYXNlLCB3aGljaCBtdXN0IG5vdCBiZSBncmVhdGVyIHRoYW4gdGhlCisgKiBu dW1iZXIgb2Ygd29ya2VycyBjdXJyZW50bHkgcmVzZXJ2ZWQsIGF2X253b3JrZXJzX3Jlc2VydmVk LgorICovCit2b2lkCitBdXRvVmFjdXVtUmVsZWFzZVBhcmFsbGVsV29ya2VycyhpbnQgbndvcmtl cnMpCit7CisJLyogT25seSBsZWFkZXIgd29ya2VyIGNhbiBjYWxsIHRoaXMgZnVuY3Rpb24uICov CisJQXNzZXJ0KEFtQXV0b1ZhY3V1bVdvcmtlclByb2Nlc3MoKSk7CisKKwkvKiBDYW5ub3QgcmVs ZWFzZSBtb3JlIHdvcmtlcnMgdGhhbiByZXNlcnZlZCAqLworCUFzc2VydChud29ya2VycyA8PSBh dl9ud29ya2Vyc19yZXNlcnZlZCk7CisKKwlMV0xvY2tBY3F1aXJlKEF1dG92YWN1dW1Mb2NrLCBM V19FWENMVVNJVkUpOworCisJLyoKKwkgKiBJZiB0aGUgbWF4aW11bSBudW1iZXIgb2YgcGFyYWxs ZWwgd29ya2VycyB3YXMgcmVkdWNlZCBkdXJpbmcgZXhlY3V0aW9uLAorCSAqIHdlIG11c3QgY2Fw IGF2YWlsYWJsZSB3b3JrZXJzIG51bWJlciBieSBpdHMgbmV3IHZhbHVlLgorCSAqLworCUF1dG9W YWN1dW1TaG1lbS0+YXZfZnJlZVBhcmFsbGVsV29ya2VycyA9CisJCU1pbihBdXRvVmFjdXVtU2ht ZW0tPmF2X2ZyZWVQYXJhbGxlbFdvcmtlcnMgKyBud29ya2VycywKKwkJCUF1dG9WYWN1dW1TaG1l bS0+YXZfbWF4UGFyYWxsZWxXb3JrZXJzKTsKKworCUxXTG9ja1JlbGVhc2UoQXV0b3ZhY3V1bUxv Y2spOworCisJLyogRG9uJ3QgaGF2ZSB0byByZW1lbWJlciB0aGVzZSB3b3JrZXJzIGFueW1vcmUu ICovCisJYXZfbndvcmtlcnNfcmVzZXJ2ZWQgLT0gbndvcmtlcnM7Cit9CisKKy8qCisgKiBTYW1l IGFzIGFib3ZlLCBidXQgdGhpcyBmdW5jdGlvbiByZWxlYXNlcyBhbGwgdGhlIHBhcmFsbGVsIHdv cmtlcnMgdGhhdAorICogdGhpcyBhdXRvdmFjdXVtIHdvcmtlciByZXNlcnZlZC4KKyAqLwordm9p ZAorQXV0b1ZhY3V1bVJlbGVhc2VBbGxQYXJhbGxlbFdvcmtlcnModm9pZCkKK3sKKwkvKiBPbmx5 IGxlYWRlciB3b3JrZXIgY2FuIGNhbGwgdGhpcyBmdW5jdGlvbi4gKi8KKwlBc3NlcnQoQW1BdXRv VmFjdXVtV29ya2VyUHJvY2VzcygpKTsKKworCWlmIChhdl9ud29ya2Vyc19yZXNlcnZlZCA+IDAp CisJCUF1dG9WYWN1dW1SZWxlYXNlUGFyYWxsZWxXb3JrZXJzKGF2X253b3JrZXJzX3Jlc2VydmVk KTsKKworCUFzc2VydChhdl9ud29ya2Vyc19yZXNlcnZlZCA9PSAwKTsKK30KKwogLyoKICAqIGF1 dG92YWNfaW5pdAogICoJCVRoaXMgaXMgY2FsbGVkIGF0IHBvc3RtYXN0ZXIgaW5pdGlhbGl6YXRp b24uCkBAIC0zMzk0LDYgKzM1MjUsMTAgQEAgQXV0b1ZhY3V1bVNobWVtSW5pdCh2b2lkKQogCQlB c3NlcnQoIWZvdW5kKTsKIAogCQlBdXRvVmFjdXVtU2htZW0tPmF2X2xhdW5jaGVycGlkID0gMDsK KwkJQXV0b1ZhY3V1bVNobWVtLT5hdl9tYXhQYXJhbGxlbFdvcmtlcnMgPQorCQkJTWluKGF1dG92 YWN1dW1fbWF4X3BhcmFsbGVsX3dvcmtlcnMsIG1heF9wYXJhbGxlbF93b3JrZXJzKTsKKwkJQXV0 b1ZhY3V1bVNobWVtLT5hdl9mcmVlUGFyYWxsZWxXb3JrZXJzID0KKwkJCUF1dG9WYWN1dW1TaG1l bS0+YXZfbWF4UGFyYWxsZWxXb3JrZXJzOwogCQlkY2xpc3RfaW5pdCgmQXV0b1ZhY3V1bVNobWVt LT5hdl9mcmVlV29ya2Vycyk7CiAJCWRsaXN0X2luaXQoJkF1dG9WYWN1dW1TaG1lbS0+YXZfcnVu bmluZ1dvcmtlcnMpOwogCQlBdXRvVmFjdXVtU2htZW0tPmF2X3N0YXJ0aW5nV29ya2VyID0gTlVM TDsKQEAgLTM0NzUsMyArMzYxMCwyOCBAQCBjaGVja19hdl93b3JrZXJfZ3Vjcyh2b2lkKQogCQkJ CSBlcnJkZXRhaWwoIlRoZSBzZXJ2ZXIgd2lsbCBvbmx5IHN0YXJ0IHVwIHRvIFwiYXV0b3ZhY3V1 bV93b3JrZXJfc2xvdHNcIiAoJWQpIGF1dG92YWN1dW0gd29ya2VycyBhdCBhIGdpdmVuIHRpbWUu IiwKIAkJCQkJCSAgIGF1dG92YWN1dW1fd29ya2VyX3Nsb3RzKSkpOwogfQorCisvKgorICogQWRq dXN0cyB0aGUgbnVtYmVyIG9mIGZyZWUgcGFyYWxsZWwgd29ya2VycyBjb3JyZXNwb25kcyB0byB0 aGUgbmV3CisgKiBhdXRvdmFjdXVtX21heF9wYXJhbGxlbF93b3JrZXJzIHZhbHVlLgorICovCitz dGF0aWMgdm9pZAorYWRqdXN0X2ZyZWVfcGFyYWxsZWxfd29ya2VycyhpbnQgcHJldl9tYXhfcGFy YWxsZWxfd29ya2VycykKK3sKKwlpbnQJbmZyZWVfd29ya2VyczsKKworCUxXTG9ja0FjcXVpcmUo QXV0b3ZhY3V1bUxvY2ssIExXX0VYQ0xVU0lWRSk7CisKKwkvKgorCSAqIENhcCBvciBpbmNyZWFz ZSBudW1iZXIgb2YgZnJlZSBwYXJhbGxlbCB3b3JrZXJzIGFjY29yZGluZyB0byB0aGUKKwkgKiBw YXJhbWV0ZXIgY2hhbmdlLgorCSAqLworCW5mcmVlX3dvcmtlcnMgPQorCQlhdXRvdmFjdXVtX21h eF9wYXJhbGxlbF93b3JrZXJzIC0gcHJldl9tYXhfcGFyYWxsZWxfd29ya2VycyArCisJCUF1dG9W YWN1dW1TaG1lbS0+YXZfZnJlZVBhcmFsbGVsV29ya2VyczsKKworCUF1dG9WYWN1dW1TaG1lbS0+ YXZfZnJlZVBhcmFsbGVsV29ya2VycyA9IE1heChuZnJlZV93b3JrZXJzLCAwKTsKKwlBdXRvVmFj dXVtU2htZW0tPmF2X21heFBhcmFsbGVsV29ya2VycyA9IGF1dG92YWN1dW1fbWF4X3BhcmFsbGVs X3dvcmtlcnM7CisKKwlMV0xvY2tSZWxlYXNlKEF1dG92YWN1dW1Mb2NrKTsKK30KZGlmZiAtLWdp dCBhL3NyYy9iYWNrZW5kL3V0aWxzL2luaXQvZ2xvYmFscy5jIGIvc3JjL2JhY2tlbmQvdXRpbHMv aW5pdC9nbG9iYWxzLmMKaW5kZXggMzZhZDcwOGIzNjAuLjgyNjVhODJiNjM5IDEwMDY0NAotLS0g YS9zcmMvYmFja2VuZC91dGlscy9pbml0L2dsb2JhbHMuYworKysgYi9zcmMvYmFja2VuZC91dGls cy9pbml0L2dsb2JhbHMuYwpAQCAtMTQzLDYgKzE0Myw3IEBAIGludAkJCU5CdWZmZXJzID0gMTYz ODQ7CiBpbnQJCQlNYXhDb25uZWN0aW9ucyA9IDEwMDsKIGludAkJCW1heF93b3JrZXJfcHJvY2Vz c2VzID0gODsKIGludAkJCW1heF9wYXJhbGxlbF93b3JrZXJzID0gODsKK2ludAkJCWF1dG92YWN1 dW1fbWF4X3BhcmFsbGVsX3dvcmtlcnMgPSAyOwogaW50CQkJTWF4QmFja2VuZHMgPSAwOwogCiAv KiBHVUMgcGFyYW1ldGVycyBmb3IgdmFjdXVtICovCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC91 dGlscy9taXNjL2d1Yy5jIGIvc3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9ndWMuYwppbmRleCBhZTlk NWYzZmI3MC4uYzhhOTlhNjc3NjcgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3V0aWxzL21pc2Mv Z3VjLmMKKysrIGIvc3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9ndWMuYwpAQCAtMzMyNiw5ICszMzI2 LDEzIEBAIHNldF9jb25maWdfd2l0aF9oYW5kbGUoY29uc3QgY2hhciAqbmFtZSwgY29uZmlnX2hh bmRsZSAqaGFuZGxlLAogCSAqCiAJICogQWxzbyBhbGxvdyBub3JtYWwgc2V0dGluZyBpZiB0aGUg R1VDIGlzIG1hcmtlZCBHVUNfQUxMT1dfSU5fUEFSQUxMRUwuCiAJICoKLQkgKiBPdGhlciBjaGFu Z2VzIG1pZ2h0IG5lZWQgdG8gYWZmZWN0IG90aGVyIHdvcmtlcnMsIHNvIGZvcmJpZCB0aGVtLgor CSAqIE90aGVyIGNoYW5nZXMgbWlnaHQgbmVlZCB0byBhZmZlY3Qgb3RoZXIgd29ya2Vycywgc28g Zm9yYmlkIHRoZW0uIE5vdGUsCisJICogdGhhdCBwYXJhbGxlbCBhdXRvdmFjdXVtIGxlYWRlciBp cyBhbiBleGNlcHRpb24sIGJlY2F1c2Ugb25seQorCSAqIGNvc3QtYmFzZWQgZGVsYXlzIG5lZWQg dG8gYmUgYWZmZWN0ZWQgYWxzbyB0byBwYXJhbGxlbCB2YWN1dW0gd29ya2VycywKKwkgKiBhbmQg d2Ugd2lsbCBoYW5kbGUgaXQgZWxzZXdoZXJlIGlmIGFwcHJvcHJpYXRlLgogCSAqLwotCWlmIChJ c0luUGFyYWxsZWxNb2RlKCkgJiYgY2hhbmdlVmFsICYmIGFjdGlvbiAhPSBHVUNfQUNUSU9OX1NB VkUgJiYKKwlpZiAoSXNJblBhcmFsbGVsTW9kZSgpICYmICFBbUF1dG9WYWN1dW1Xb3JrZXJQcm9j ZXNzKCkgJiYgY2hhbmdlVmFsICYmCisJCWFjdGlvbiAhPSBHVUNfQUNUSU9OX1NBVkUgJiYKIAkJ KHJlY29yZC0+ZmxhZ3MgJiBHVUNfQUxMT1dfSU5fUEFSQUxMRUwpID09IDApCiAJewogCQllcmVw b3J0KGVsZXZlbCwKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvZ3VjX3BhcmFt ZXRlcnMuZGF0IGIvc3JjL2JhY2tlbmQvdXRpbHMvbWlzYy9ndWNfcGFyYW1ldGVycy5kYXQKaW5k ZXggNzYyYjhlZmU2YjAuLjM2MWJkYjlhNzIwIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC91dGls cy9taXNjL2d1Y19wYXJhbWV0ZXJzLmRhdAorKysgYi9zcmMvYmFja2VuZC91dGlscy9taXNjL2d1 Y19wYXJhbWV0ZXJzLmRhdApAQCAtMTU0LDYgKzE1NCwxNCBAQAogICBtYXggPT4gJzIwMDAwMDAw MDAnLAogfSwKIAoreyBuYW1lID0+ICdhdXRvdmFjdXVtX21heF9wYXJhbGxlbF93b3JrZXJzJywg dHlwZSA9PiAnaW50JywgY29udGV4dCA9PiAnUEdDX1NJR0hVUCcsIGdyb3VwID0+ICdWQUNVVU1f QVVUT1ZBQ1VVTScsCisgIHNob3J0X2Rlc2MgPT4gJ01heGltdW0gbnVtYmVyIG9mIHBhcmFsbGVs IGF1dG92YWN1dW0gd29ya2VycywgdGhhdCBjYW4gYmUgdGFrZW4gZnJvbSBiZ3dvcmtlcnMgcG9v bC4nLAorICB2YXJpYWJsZSA9PiAnYXV0b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2VycycsCisg IGJvb3RfdmFsID0+ICcyJywKKyAgbWluID0+ICcwJywKKyAgbWF4ID0+ICdNQVhfQkFDS0VORFMn LAorfSwKKwogeyBuYW1lID0+ICdhdXRvdmFjdXVtX21heF93b3JrZXJzJywgdHlwZSA9PiAnaW50 JywgY29udGV4dCA9PiAnUEdDX1NJR0hVUCcsIGdyb3VwID0+ICdWQUNVVU1fQVVUT1ZBQ1VVTScs CiAgIHNob3J0X2Rlc2MgPT4gJ1NldHMgdGhlIG1heGltdW0gbnVtYmVyIG9mIHNpbXVsdGFuZW91 c2x5IHJ1bm5pbmcgYXV0b3ZhY3V1bSB3b3JrZXIgcHJvY2Vzc2VzLicsCiAgIHZhcmlhYmxlID0+ ICdhdXRvdmFjdXVtX21heF93b3JrZXJzJywKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3V0aWxz L21pc2MvcG9zdGdyZXNxbC5jb25mLnNhbXBsZSBiL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvcG9z dGdyZXNxbC5jb25mLnNhbXBsZQppbmRleCA2ZTgyYzhlMDU1ZC4uMmQ0YjlkMjdlOGIgMTAwNjQ0 Ci0tLSBhL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvcG9zdGdyZXNxbC5jb25mLnNhbXBsZQorKysg Yi9zcmMvYmFja2VuZC91dGlscy9taXNjL3Bvc3RncmVzcWwuY29uZi5zYW1wbGUKQEAgLTcwOSw2 ICs3MDksNyBAQAogI2F1dG92YWN1dW1fd29ya2VyX3Nsb3RzID0gMTYgICAgICAgICAgICMgYXV0 b3ZhY3V1bSB3b3JrZXIgc2xvdHMgdG8gYWxsb2NhdGUKICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAjIChjaGFuZ2UgcmVxdWlyZXMgcmVzdGFydCkKICNhdXRvdmFjdXVt X21heF93b3JrZXJzID0gMyAgICAgICAgICAgICAjIG1heCBudW1iZXIgb2YgYXV0b3ZhY3V1bSBz dWJwcm9jZXNzZXMKKyNhdXRvdmFjdXVtX21heF9wYXJhbGxlbF93b3JrZXJzID0gMiAgICAjIGxp bWl0ZWQgYnkgbWF4X3BhcmFsbGVsX3dvcmtlcnMKICNhdXRvdmFjdXVtX25hcHRpbWUgPSAxbWlu ICAgICAgICAgICAgICAjIHRpbWUgYmV0d2VlbiBhdXRvdmFjdXVtIHJ1bnMKICNhdXRvdmFjdXVt X3ZhY3V1bV90aHJlc2hvbGQgPSA1MCAgICAgICAjIG1pbiBudW1iZXIgb2Ygcm93IHVwZGF0ZXMg YmVmb3JlCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIyB2YWN1dW0K ZGlmZiAtLWdpdCBhL3NyYy9iaW4vcHNxbC90YWItY29tcGxldGUuaW4uYyBiL3NyYy9iaW4vcHNx bC90YWItY29tcGxldGUuaW4uYwppbmRleCA4YjkxYmMwMDA2Mi4uZWQ1OWEyMTI4OWMgMTAwNjQ0 Ci0tLSBhL3NyYy9iaW4vcHNxbC90YWItY29tcGxldGUuaW4uYworKysgYi9zcmMvYmluL3BzcWwv dGFiLWNvbXBsZXRlLmluLmMKQEAgLTE0MjMsNiArMTQyMyw3IEBAIHN0YXRpYyBjb25zdCBjaGFy ICpjb25zdCB0YWJsZV9zdG9yYWdlX3BhcmFtZXRlcnNbXSA9IHsKIAkiYXV0b3ZhY3V1bV9tdWx0 aXhhY3RfZnJlZXplX21heF9hZ2UiLAogCSJhdXRvdmFjdXVtX211bHRpeGFjdF9mcmVlemVfbWlu X2FnZSIsCiAJImF1dG92YWN1dW1fbXVsdGl4YWN0X2ZyZWV6ZV90YWJsZV9hZ2UiLAorCSJhdXRv dmFjdXVtX3BhcmFsbGVsX3dvcmtlcnMiLAogCSJhdXRvdmFjdXVtX3ZhY3V1bV9jb3N0X2RlbGF5 IiwKIAkiYXV0b3ZhY3V1bV92YWN1dW1fY29zdF9saW1pdCIsCiAJImF1dG92YWN1dW1fdmFjdXVt X2luc2VydF9zY2FsZV9mYWN0b3IiLApkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvbWlzY2FkbWlu LmggYi9zcmMvaW5jbHVkZS9taXNjYWRtaW4uaAppbmRleCBkYjU1OWIzOWM0ZC4uYWQ2ZTE5ZjQy NmMgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL21pc2NhZG1pbi5oCisrKyBiL3NyYy9pbmNsdWRl L21pc2NhZG1pbi5oCkBAIC0xNzgsNiArMTc4LDcgQEAgZXh0ZXJuIFBHRExMSU1QT1JUIGludCBN YXhCYWNrZW5kczsKIGV4dGVybiBQR0RMTElNUE9SVCBpbnQgTWF4Q29ubmVjdGlvbnM7CiBleHRl cm4gUEdETExJTVBPUlQgaW50IG1heF93b3JrZXJfcHJvY2Vzc2VzOwogZXh0ZXJuIFBHRExMSU1Q T1JUIGludCBtYXhfcGFyYWxsZWxfd29ya2VyczsKK2V4dGVybiBQR0RMTElNUE9SVCBpbnQgYXV0 b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2VyczsKIAogZXh0ZXJuIFBHRExMSU1QT1JUIGludCBj b21taXRfdGltZXN0YW1wX2J1ZmZlcnM7CiBleHRlcm4gUEdETExJTVBPUlQgaW50IG11bHRpeGFj dF9tZW1iZXJfYnVmZmVyczsKZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL3Bvc3RtYXN0ZXIvYXV0 b3ZhY3V1bS5oIGIvc3JjL2luY2x1ZGUvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmgKaW5kZXggNWFh MGYzYThhYzEuLmYzNzgzYWZiNTFiIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9wb3N0bWFzdGVy L2F1dG92YWN1dW0uaAorKysgYi9zcmMvaW5jbHVkZS9wb3N0bWFzdGVyL2F1dG92YWN1dW0uaApA QCAtNjIsNiArNjIsMTEgQEAgcGdfbm9yZXR1cm4gZXh0ZXJuIHZvaWQgQXV0b1ZhY1dvcmtlck1h aW4oY29uc3Qgdm9pZCAqc3RhcnR1cF9kYXRhLCBzaXplX3Qgc3RhcnQKIGV4dGVybiBib29sIEF1 dG9WYWN1dW1SZXF1ZXN0V29yayhBdXRvVmFjdXVtV29ya0l0ZW1UeXBlIHR5cGUsCiAJCQkJCQkJ CSAgT2lkIHJlbGF0aW9uSWQsIEJsb2NrTnVtYmVyIGJsa25vKTsKIAorLyogcGFyYWxsZWwgYXV0 b3ZhY3V1bSBzdHVmZiAqLworZXh0ZXJuIHZvaWQJQXV0b1ZhY3V1bVJlc2VydmVQYXJhbGxlbFdv cmtlcnMoaW50ICpud29ya2Vycyk7CitleHRlcm4gdm9pZCBBdXRvVmFjdXVtUmVsZWFzZVBhcmFs bGVsV29ya2VycyhpbnQgbndvcmtlcnMpOworZXh0ZXJuIHZvaWQgQXV0b1ZhY3V1bVJlbGVhc2VB bGxQYXJhbGxlbFdvcmtlcnModm9pZCk7CisKIC8qIHNoYXJlZCBtZW1vcnkgc3R1ZmYgKi8KIGV4 dGVybiBTaXplIEF1dG9WYWN1dW1TaG1lbVNpemUodm9pZCk7CiBleHRlcm4gdm9pZCBBdXRvVmFj dXVtU2htZW1Jbml0KHZvaWQpOwpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvdXRpbHMvcmVsLmgg Yi9zcmMvaW5jbHVkZS91dGlscy9yZWwuaAppbmRleCAyMzY4MzBmNmI5My4uN2M1ZTM1YTQ4NmMg MTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL3V0aWxzL3JlbC5oCisrKyBiL3NyYy9pbmNsdWRlL3V0 aWxzL3JlbC5oCkBAIC0zMTEsNiArMzExLDEzIEBAIHR5cGVkZWYgc3RydWN0IEZvcmVpZ25LZXlD YWNoZUluZm8KIHR5cGVkZWYgc3RydWN0IEF1dG9WYWNPcHRzCiB7CiAJYm9vbAkJZW5hYmxlZDsK KworCS8qCisJICogTWF4IG51bWJlciBvZiBwYXJhbGxlbCBhdXRvdmFjdXVtIHdvcmtlcnMuIElm IHZhbHVlIGlzIDAgdGhlbiBwYXJhbGxlbAorCSAqIGRlZ3JlZSB3aWxsIGNvbXB1dGVkIGJhc2Vk IG9uIG51bWJlciBvZiBpbmRleGVzLgorCSAqLworCWludAkJCWF1dG92YWN1dW1fcGFyYWxsZWxf d29ya2VyczsKKwogCWludAkJCXZhY3V1bV90aHJlc2hvbGQ7CiAJaW50CQkJdmFjdXVtX21heF90 aHJlc2hvbGQ7CiAJaW50CQkJdmFjdXVtX2luc190aHJlc2hvbGQ7Ci0tIAoyLjQzLjAKCg== --000000000000a87ec3064a7990c4 Content-Type: text/x-patch; charset="US-ASCII"; name="v21-0002-Logging-for-parallel-autovacuum.patch" Content-Disposition: attachment; filename="v21-0002-Logging-for-parallel-autovacuum.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mlgqd2mh3 RnJvbSBiYTJhMjExMTQxMjZkNmMyYjllYTg2MjlhNzI5OTMzMmU1NzMxMzZhIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBTdW4sIDIzIE5vdiAyMDI1IDAxOjA3OjQ3ICswNzAwClN1YmplY3Q6IFtQQVRD SCB2MjEgMi81XSBMb2dnaW5nIGZvciBwYXJhbGxlbCBhdXRvdmFjdXVtCgotLS0KIHNyYy9iYWNr ZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYyAgfCA2MSArKysrKysrKysrKysrKysrKysrKysr KysrKy0KIHNyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMgfCAyOSArKysrKysr KysrLS0tCiBzcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0uaCAgICAgICAgIHwgMjggKysrKysr KysrKystCiBzcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdCAgICAgIHwgIDMgKysKIDQg ZmlsZXMgY2hhbmdlZCwgMTExIGluc2VydGlvbnMoKyksIDEwIGRlbGV0aW9ucygtKQoKZGlmZiAt LWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYyBiL3NyYy9iYWNrZW5k L2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYwppbmRleCA0YmUyNjdmZjY1Ny4uZDE5ZTE1Y2JjY2Ug MTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYworKysgYi9z cmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMKQEAgLTM0MCw2ICszNDAsMTIgQEAg dHlwZWRlZiBzdHJ1Y3QgTFZSZWxTdGF0ZQogCWludAkJCW51bV9pbmRleF9zY2FuczsKIAlpbnQJ CQludW1fZGVhZF9pdGVtc19yZXNldHM7CiAJU2l6ZQkJdG90YWxfZGVhZF9pdGVtc19ieXRlczsK KworCS8qCisJICogVG90YWwgbnVtYmVyIG9mIHBsYW5uZWQgYW5kIGFjdHVhbGx5IGxhdW5jaGVk IHBhcmFsbGVsIHdvcmtlcnMgZm9yCisJICogaW5kZXggc2NhbnMuCisJICovCisJUFZXb3JrZXJz VXNhZ2Ugd29ya2Vyc191c2FnZTsKIAkvKiBDb3VudGVycyB0aGF0IGZvbGxvdyBhcmUgb25seSBm b3Igc2Nhbm5lZF9wYWdlcyAqLwogCWludDY0CQl0dXBsZXNfZGVsZXRlZDsgLyogIyBkZWxldGVk IGZyb20gdGFibGUgKi8KIAlpbnQ2NAkJdHVwbGVzX2Zyb3plbjsJLyogIyBuZXdseSBmcm96ZW4g Ki8KQEAgLTc3OCw2ICs3ODQsMTEgQEAgaGVhcF92YWN1dW1fcmVsKFJlbGF0aW9uIHJlbCwgY29u c3QgVmFjdXVtUGFyYW1zIHBhcmFtcywKIAl2YWNyZWwtPnZtX25ld192aXNpYmxlX2Zyb3plbl9w YWdlcyA9IDA7CiAJdmFjcmVsLT52bV9uZXdfZnJvemVuX3BhZ2VzID0gMDsKIAorCXZhY3JlbC0+ d29ya2Vyc191c2FnZS52YWN1dW0ubmxhdW5jaGVkID0gMDsKKwl2YWNyZWwtPndvcmtlcnNfdXNh Z2UudmFjdXVtLm5wbGFubmVkID0gMDsKKwl2YWNyZWwtPndvcmtlcnNfdXNhZ2UuY2xlYW51cC5u bGF1bmNoZWQgPSAwOworCXZhY3JlbC0+d29ya2Vyc191c2FnZS5jbGVhbnVwLm5wbGFubmVkID0g MDsKKwogCS8qCiAJICogR2V0IGN1dG9mZnMgdGhhdCBkZXRlcm1pbmUgd2hpY2ggZGVsZXRlZCB0 dXBsZXMgYXJlIGNvbnNpZGVyZWQgREVBRCwKIAkgKiBub3QganVzdCBSRUNFTlRMWV9ERUFELCBh bmQgd2hpY2ggWElEcy9NWElEcyB0byBmcmVlemUuICBUaGVuIGRldGVybWluZQpAQCAtMTEyMCw2 ICsxMTMxLDUwIEBAIGhlYXBfdmFjdXVtX3JlbChSZWxhdGlvbiByZWwsIGNvbnN0IFZhY3V1bVBh cmFtcyBwYXJhbXMsCiAJCQkJCQkJIG9yaWdfcmVsX3BhZ2VzID09IDAgPyAxMDAuMCA6CiAJCQkJ CQkJIDEwMC4wICogdmFjcmVsLT5scGRlYWRfaXRlbV9wYWdlcyAvIG9yaWdfcmVsX3BhZ2VzLAog CQkJCQkJCSB2YWNyZWwtPmxwZGVhZF9pdGVtcyk7CisJCQlpZiAodmFjcmVsLT53b3JrZXJzX3Vz YWdlLnZhY3V1bS5ucGxhbm5lZCA+IDApCisJCQl7CisJCQkJLyogU3RhdHMgZm9yIHZhY3V1bSBw aGFzZSBvZiBpbmRleCB2YWN1dW1pbmcuICovCisKKwkJCQlpZiAoQW1BdXRvVmFjdXVtV29ya2Vy UHJvY2VzcygpKQorCQkJCXsKKwkJCQkJLyogV29ya2VyIHVzYWdlIHN0YXRzIGZvciBwYXJhbGxl bCBhdXRvdmFjdXVtLiAqLworCQkJCQlhcHBlbmRTdHJpbmdJbmZvKCZidWYsCisJCQkJCQkJCQkg XygicGFyYWxsZWwgaW5kZXggdmFjdXVtOiAlZCB3b3JrZXJzIHdlcmUgcGxhbm5lZCwgJWQgd29y a2VycyB3ZXJlIHJlc2VydmVkIGFuZCAlZCB3b3JrZXJzIHdlcmUgbGF1bmNoZWQgaW4gdG90YWxc biIpLAorCQkJCQkJCQkJIHZhY3JlbC0+d29ya2Vyc191c2FnZS52YWN1dW0ubnBsYW5uZWQsCisJ CQkJCQkJCQkgdmFjcmVsLT53b3JrZXJzX3VzYWdlLnZhY3V1bS5ucmVzZXJ2ZWQsCisJCQkJCQkJ CQkgdmFjcmVsLT53b3JrZXJzX3VzYWdlLnZhY3V1bS5ubGF1bmNoZWQpOworCQkJCX0KKwkJCQll bHNlCisJCQkJeworCQkJCQkvKiBXb3JrZXIgdXNhZ2Ugc3RhdHMgZm9yIG1hbnVhbCBWQUNVVU0g KFBBUkFMTEVMKS4gKi8KKwkJCQkJYXBwZW5kU3RyaW5nSW5mbygmYnVmLAorCQkJCQkJCQkJIF8o InBhcmFsbGVsIGluZGV4IHZhY3V1bTogJWQgd29ya2VycyB3ZXJlIHBsYW5uZWQgYW5kICVkIHdv cmtlcnMgd2VyZSBsYXVuY2hlZCBpbiB0b3RhbFxuIiksCisJCQkJCQkJCQkgdmFjcmVsLT53b3Jr ZXJzX3VzYWdlLnZhY3V1bS5ucGxhbm5lZCwKKwkJCQkJCQkJCSB2YWNyZWwtPndvcmtlcnNfdXNh Z2UudmFjdXVtLm5sYXVuY2hlZCk7CisJCQkJfQorCQkJfQorCQkJaWYgKHZhY3JlbC0+d29ya2Vy c191c2FnZS5jbGVhbnVwLm5wbGFubmVkID4gMCkKKwkJCXsKKwkJCQkvKiBTdGF0cyBmb3IgY2xl YW51cCBwaGFzZSBvZiBpbmRleCB2YWN1dW1pbmcuICovCisKKwkJCQlpZiAoQW1BdXRvVmFjdXVt V29ya2VyUHJvY2VzcygpKQorCQkJCXsKKwkJCQkJLyogV29ya2VyIHVzYWdlIHN0YXRzIGZvciBw YXJhbGxlbCBhdXRvdmFjdXVtLiAqLworCQkJCQlhcHBlbmRTdHJpbmdJbmZvKCZidWYsCisJCQkJ CQkJCQkgXygicGFyYWxsZWwgaW5kZXggY2xlYW51cDogJWQgd29ya2VycyB3ZXJlIHBsYW5uZWQs ICVkIHdvcmtlcnMgd2VyZSByZXNlcnZlZCBhbmQgJWQgd29ya2VycyB3ZXJlIGxhdW5jaGVkIGlu IHRvdGFsXG4iKSwKKwkJCQkJCQkJCSB2YWNyZWwtPndvcmtlcnNfdXNhZ2UuY2xlYW51cC5ucGxh bm5lZCwKKwkJCQkJCQkJCSB2YWNyZWwtPndvcmtlcnNfdXNhZ2UuY2xlYW51cC5ucmVzZXJ2ZWQs CisJCQkJCQkJCQkgdmFjcmVsLT53b3JrZXJzX3VzYWdlLmNsZWFudXAubmxhdW5jaGVkKTsKKwkJ CQl9CisJCQkJZWxzZQorCQkJCXsKKwkJCQkJLyogV29ya2VyIHVzYWdlIHN0YXRzIGZvciBtYW51 YWwgVkFDVVVNIChQQVJBTExFTCkuICovCisJCQkJCWFwcGVuZFN0cmluZ0luZm8oJmJ1ZiwKKwkJ CQkJCQkJCSBfKCJwYXJhbGxlbCBpbmRleCBjbGVhbnVwOiAlZCB3b3JrZXJzIHdlcmUgcGxhbm5l ZCBhbmQgJWQgd29ya2VycyB3ZXJlIGxhdW5jaGVkIGluIHRvdGFsXG4iKSwKKwkJCQkJCQkJCSB2 YWNyZWwtPndvcmtlcnNfdXNhZ2UuY2xlYW51cC5ucGxhbm5lZCwKKwkJCQkJCQkJCSB2YWNyZWwt PndvcmtlcnNfdXNhZ2UuY2xlYW51cC5ubGF1bmNoZWQpOworCQkJCX0KKwkJCX0KIAkJCWZvciAo aW50IGkgPSAwOyBpIDwgdmFjcmVsLT5uaW5kZXhlczsgaSsrKQogCQkJewogCQkJCUluZGV4QnVs a0RlbGV0ZVJlc3VsdCAqaXN0YXQgPSB2YWNyZWwtPmluZHN0YXRzW2ldOwpAQCAtMjY2NCw3ICsy NzE5LDggQEAgbGF6eV92YWN1dW1fYWxsX2luZGV4ZXMoTFZSZWxTdGF0ZSAqdmFjcmVsKQogCXsK IAkJLyogT3V0c291cmNlIGV2ZXJ5dGhpbmcgdG8gcGFyYWxsZWwgdmFyaWFudCAqLwogCQlwYXJh bGxlbF92YWN1dW1fYnVsa2RlbF9hbGxfaW5kZXhlcyh2YWNyZWwtPnB2cywgb2xkX2xpdmVfdHVw bGVzLAotCQkJCQkJCQkJCQl2YWNyZWwtPm51bV9pbmRleF9zY2Fucyk7CisJCQkJCQkJCQkJCXZh Y3JlbC0+bnVtX2luZGV4X3NjYW5zLAorCQkJCQkJCQkJCQkmdmFjcmVsLT53b3JrZXJzX3VzYWdl KTsKIAogCQkvKgogCQkgKiBEbyBhIHBvc3RjaGVjayB0byBjb25zaWRlciBhcHBseWluZyB3cmFw YXJvdW5kIGZhaWxzYWZlIG5vdy4gIE5vdGUKQEAgLTMwOTcsNyArMzE1Myw4IEBAIGxhenlfY2xl YW51cF9hbGxfaW5kZXhlcyhMVlJlbFN0YXRlICp2YWNyZWwpCiAJCS8qIE91dHNvdXJjZSBldmVy eXRoaW5nIHRvIHBhcmFsbGVsIHZhcmlhbnQgKi8KIAkJcGFyYWxsZWxfdmFjdXVtX2NsZWFudXBf YWxsX2luZGV4ZXModmFjcmVsLT5wdnMsIHJlbHR1cGxlcywKIAkJCQkJCQkJCQkJdmFjcmVsLT5u dW1faW5kZXhfc2NhbnMsCi0JCQkJCQkJCQkJCWVzdGltYXRlZF9jb3VudCk7CisJCQkJCQkJCQkJ CWVzdGltYXRlZF9jb3VudCwKKwkJCQkJCQkJCQkJJnZhY3JlbC0+d29ya2Vyc191c2FnZSk7CiAJ fQogCiAJLyogUmVzZXQgdGhlIHByb2dyZXNzIGNvdW50ZXJzICovCmRpZmYgLS1naXQgYS9zcmMv YmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMv dmFjdXVtcGFyYWxsZWwuYwppbmRleCBkM2UwYzMyYjdlZS4uODZkOWYyYjc0YzkgMTAwNjQ0Ci0t LSBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMKKysrIGIvc3JjL2JhY2tl bmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYwpAQCAtMjI3LDcgKzIyNyw3IEBAIHN0cnVjdCBQ YXJhbGxlbFZhY3V1bVN0YXRlCiBzdGF0aWMgaW50CXBhcmFsbGVsX3ZhY3V1bV9jb21wdXRlX3dv cmtlcnMoUmVsYXRpb24gKmluZHJlbHMsIGludCBuaW5kZXhlcywgaW50IG5yZXF1ZXN0ZWQsCiAJ CQkJCQkJCQkJCWJvb2wgKndpbGxfcGFyYWxsZWxfdmFjdXVtKTsKIHN0YXRpYyB2b2lkIHBhcmFs bGVsX3ZhY3V1bV9wcm9jZXNzX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywg aW50IG51bV9pbmRleF9zY2FucywKLQkJCQkJCQkJCQkJCWJvb2wgdmFjdXVtKTsKKwkJCQkJCQkJ CQkJCWJvb2wgdmFjdXVtLCBQVldvcmtlcnNTdGF0cyAqd3N0YXRzKTsKIHN0YXRpYyB2b2lkIHBh cmFsbGVsX3ZhY3V1bV9wcm9jZXNzX3NhZmVfaW5kZXhlcyhQYXJhbGxlbFZhY3V1bVN0YXRlICpw dnMpOwogc3RhdGljIHZvaWQgcGFyYWxsZWxfdmFjdXVtX3Byb2Nlc3NfdW5zYWZlX2luZGV4ZXMo UGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzKTsKIHN0YXRpYyB2b2lkIHBhcmFsbGVsX3ZhY3V1bV9w cm9jZXNzX29uZV9pbmRleChQYXJhbGxlbFZhY3V1bVN0YXRlICpwdnMsIFJlbGF0aW9uIGluZHJl bCwKQEAgLTUwMiw3ICs1MDIsNyBAQCBwYXJhbGxlbF92YWN1dW1fcmVzZXRfZGVhZF9pdGVtcyhQ YXJhbGxlbFZhY3V1bVN0YXRlICpwdnMpCiAgKi8KIHZvaWQKIHBhcmFsbGVsX3ZhY3V1bV9idWxr ZGVsX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywgbG9uZyBudW1fdGFibGVf dHVwbGVzLAotCQkJCQkJCQkJaW50IG51bV9pbmRleF9zY2FucykKKwkJCQkJCQkJCWludCBudW1f aW5kZXhfc2NhbnMsIFBWV29ya2Vyc1VzYWdlICp3dXNhZ2UpCiB7CiAJQXNzZXJ0KCFJc1BhcmFs bGVsV29ya2VyKCkpOwogCkBAIC01MTMsNyArNTEzLDggQEAgcGFyYWxsZWxfdmFjdXVtX2J1bGtk ZWxfYWxsX2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLCBsb25nIG51bV90YWJsZV90 dXAKIAlwdnMtPnNoYXJlZC0+cmVsdHVwbGVzID0gbnVtX3RhYmxlX3R1cGxlczsKIAlwdnMtPnNo YXJlZC0+ZXN0aW1hdGVkX2NvdW50ID0gdHJ1ZTsKIAotCXBhcmFsbGVsX3ZhY3V1bV9wcm9jZXNz X2FsbF9pbmRleGVzKHB2cywgbnVtX2luZGV4X3NjYW5zLCB0cnVlKTsKKwlwYXJhbGxlbF92YWN1 dW1fcHJvY2Vzc19hbGxfaW5kZXhlcyhwdnMsIG51bV9pbmRleF9zY2FucywgdHJ1ZSwKKwkJCQkJ CQkJCQkmd3VzYWdlLT52YWN1dW0pOwogfQogCiAvKgpAQCAtNTIxLDcgKzUyMiw4IEBAIHBhcmFs bGVsX3ZhY3V1bV9idWxrZGVsX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywg bG9uZyBudW1fdGFibGVfdHVwCiAgKi8KIHZvaWQKIHBhcmFsbGVsX3ZhY3V1bV9jbGVhbnVwX2Fs bF9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywgbG9uZyBudW1fdGFibGVfdHVwbGVz LAotCQkJCQkJCQkJaW50IG51bV9pbmRleF9zY2FucywgYm9vbCBlc3RpbWF0ZWRfY291bnQpCisJ CQkJCQkJCQlpbnQgbnVtX2luZGV4X3NjYW5zLCBib29sIGVzdGltYXRlZF9jb3VudCwKKwkJCQkJ CQkJCVBWV29ya2Vyc1VzYWdlICp3dXNhZ2UpCiB7CiAJQXNzZXJ0KCFJc1BhcmFsbGVsV29ya2Vy KCkpOwogCkBAIC01MzMsNyArNTM1LDggQEAgcGFyYWxsZWxfdmFjdXVtX2NsZWFudXBfYWxsX2lu ZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLCBsb25nIG51bV90YWJsZV90dXAKIAlwdnMt PnNoYXJlZC0+cmVsdHVwbGVzID0gbnVtX3RhYmxlX3R1cGxlczsKIAlwdnMtPnNoYXJlZC0+ZXN0 aW1hdGVkX2NvdW50ID0gZXN0aW1hdGVkX2NvdW50OwogCi0JcGFyYWxsZWxfdmFjdXVtX3Byb2Nl c3NfYWxsX2luZGV4ZXMocHZzLCBudW1faW5kZXhfc2NhbnMsIGZhbHNlKTsKKwlwYXJhbGxlbF92 YWN1dW1fcHJvY2Vzc19hbGxfaW5kZXhlcyhwdnMsIG51bV9pbmRleF9zY2FucywgZmFsc2UsCisJ CQkJCQkJCQkJJnd1c2FnZS0+Y2xlYW51cCk7CiB9CiAKIC8qCkBAIC02MTgsNyArNjIxLDcgQEAg cGFyYWxsZWxfdmFjdXVtX2NvbXB1dGVfd29ya2VycyhSZWxhdGlvbiAqaW5kcmVscywgaW50IG5p bmRleGVzLCBpbnQgbnJlcXVlc3RlZCwKICAqLwogc3RhdGljIHZvaWQKIHBhcmFsbGVsX3ZhY3V1 bV9wcm9jZXNzX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywgaW50IG51bV9p bmRleF9zY2FucywKLQkJCQkJCQkJCWJvb2wgdmFjdXVtKQorCQkJCQkJCQkJYm9vbCB2YWN1dW0s IFBWV29ya2Vyc1N0YXRzICp3c3RhdHMpCiB7CiAJaW50CQkJbndvcmtlcnM7CiAJUFZJbmRWYWNT dGF0dXMgbmV3X3N0YXR1czsKQEAgLTY1NSwxMyArNjU4LDIzIEBAIHBhcmFsbGVsX3ZhY3V1bV9w cm9jZXNzX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywgaW50IG51bV9pbmRl eF9zY2FuCiAJICovCiAJbndvcmtlcnMgPSBNaW4obndvcmtlcnMsIHB2cy0+cGN4dC0+bndvcmtl cnMpOwogCisJLyogUmVtZW1iZXIgdGhpcyB2YWx1ZSwgaWYgd2UgYXNrZWQgdG8gKi8KKwlpZiAo d3N0YXRzICE9IE5VTEwgJiYgbndvcmtlcnMgPiAwKQorCQl3c3RhdHMtPm5wbGFubmVkICs9IG53 b3JrZXJzOworCiAJLyoKIAkgKiBSZXNlcnZlIHdvcmtlcnMgaW4gYXV0b3ZhY3V1bSBnbG9iYWwg c3RhdGUuIE5vdGUgdGhhdCB3ZSBtYXkgYmUgZ2l2ZW4KIAkgKiBmZXdlciB3b3JrZXJzIHRoYW4g d2UgcmVxdWVzdGVkLgogCSAqLwogCWlmIChBbUF1dG9WYWN1dW1Xb3JrZXJQcm9jZXNzKCkgJiYg bndvcmtlcnMgPiAwKQorCXsKIAkJQXV0b1ZhY3V1bVJlc2VydmVQYXJhbGxlbFdvcmtlcnMoJm53 b3JrZXJzKTsKIAorCQkvKiBSZW1lbWJlciB0aGlzIHZhbHVlLCBpZiB3ZSBhc2tlZCB0byAqLwor CQlpZiAod3N0YXRzICE9IE5VTEwpCisJCQl3c3RhdHMtPm5yZXNlcnZlZCArPSBud29ya2VyczsK Kwl9CisKIAkvKgogCSAqIFNldCBpbmRleCB2YWN1dW0gc3RhdHVzIGFuZCBtYXJrIHdoZXRoZXIg cGFyYWxsZWwgdmFjdXVtIHdvcmtlciBjYW4KIAkgKiBwcm9jZXNzIGl0LgpAQCAtNzI4LDYgKzc0 MSwxMCBAQCBwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19hbGxfaW5kZXhlcyhQYXJhbGxlbFZhY3V1 bVN0YXRlICpwdnMsIGludCBudW1faW5kZXhfc2NhbgogCQkJLyogRW5hYmxlIHNoYXJlZCBjb3N0 IGJhbGFuY2UgZm9yIGxlYWRlciBiYWNrZW5kICovCiAJCQlWYWN1dW1TaGFyZWRDb3N0QmFsYW5j ZSA9ICYocHZzLT5zaGFyZWQtPmNvc3RfYmFsYW5jZSk7CiAJCQlWYWN1dW1BY3RpdmVOV29ya2Vy cyA9ICYocHZzLT5zaGFyZWQtPmFjdGl2ZV9ud29ya2Vycyk7CisKKwkJCS8qIFJlbWVtYmVyIHRo aXMgdmFsdWUsIGlmIHdlIGFza2VkIHRvICovCisJCQlpZiAod3N0YXRzICE9IE5VTEwpCisJCQkJ d3N0YXRzLT5ubGF1bmNoZWQgKz0gcHZzLT5wY3h0LT5ud29ya2Vyc19sYXVuY2hlZDsKIAkJfQog CiAJCWlmICh2YWN1dW0pCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0u aCBiL3NyYy9pbmNsdWRlL2NvbW1hbmRzL3ZhY3V1bS5oCmluZGV4IGU4ODVhNGI5Yzc3Li5kM2Rj NGU4Y2M2NyAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmgKKysrIGIv c3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmgKQEAgLTMwMCw2ICszMDAsMjggQEAgdHlwZWRl ZiBzdHJ1Y3QgVmFjRGVhZEl0ZW1zSW5mbwogCWludDY0CQludW1faXRlbXM7CQkvKiBjdXJyZW50 ICMgb2YgZW50cmllcyAqLwogfSBWYWNEZWFkSXRlbXNJbmZvOwogCisvKgorICogSGVscGVyIGZv ciB0aGUgUFZXb3JrZXJzVXNhZ2Ugc3RydWN0dXJlIChzZWUgYmVsb3cpLCB0byBhdm9pZCByZXBl dGl0aW9uLgorICovCit0eXBlZGVmIHN0cnVjdCBQVldvcmtlcnNTdGF0cworeworCWludAkJCW5w bGFubmVkOwkJLyogIyBvZiBwYXJhbGxlbCB3b3JrZXJzIHdlIGFyZSBwbGFubmVkIHRvCisJCQkJ CQkJCSAqIGxhdW5jaCAqLworCWludAkJCW5yZXNlcnZlZDsJCS8qIGZvciBhdXRvdmFjdXVtIG9u bHkgLSAjIG9mIHBhcmFsbGVsIHdvcmtlcnMKKwkJCQkJCQkJICogd2UgaGF2ZSBtYW5hZ2VkIHRv IHJlc2VydmUgKi8KKwlpbnQJCQlubGF1bmNoZWQ7CQkvKiAjIG9mIGxhdW5jaGVkIHBhcmFsbGVs IHdvcmtlcnMgKi8KK30gUFZXb3JrZXJzU3RhdHM7CisKKy8qCisgKiBQVldvcmtlcnNVc2FnZSBz dG9yZXMgaW5mb3JtYXRpb24gYWJvdXQgdG90YWwgbnVtYmVyIG9mIGxhdW5jaGVkLCByZXNlcnZl ZAorICogYW5kIHBsYW5uZWQgd29ya2VycyBkdXJpbmcgcGFyYWxsZWwgdmFjdXVtIChib3RoIGZv ciB2YWN1dW0gYW5kIGNsZWFudXApLgorICovCit0eXBlZGVmIHN0cnVjdCBQVldvcmtlcnNVc2Fn ZQoreworCVBWV29ya2Vyc1N0YXRzIHZhY3V1bTsKKwlQVldvcmtlcnNTdGF0cyBjbGVhbnVwOwor fSBQVldvcmtlcnNVc2FnZTsKKwogLyogR1VDIHBhcmFtZXRlcnMgKi8KIGV4dGVybiBQR0RMTElN UE9SVCBpbnQgZGVmYXVsdF9zdGF0aXN0aWNzX3RhcmdldDsJLyogUEdETExJTVBPUlQgZm9yIFBv c3RHSVMgKi8KIGV4dGVybiBQR0RMTElNUE9SVCBpbnQgdmFjdXVtX2ZyZWV6ZV9taW5fYWdlOwpA QCAtMzk0LDExICs0MTYsMTMgQEAgZXh0ZXJuIFRpZFN0b3JlICpwYXJhbGxlbF92YWN1dW1fZ2V0 X2RlYWRfaXRlbXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLAogZXh0ZXJuIHZvaWQgcGFyYWxs ZWxfdmFjdXVtX3Jlc2V0X2RlYWRfaXRlbXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzKTsKIGV4 dGVybiB2b2lkIHBhcmFsbGVsX3ZhY3V1bV9idWxrZGVsX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFj dXVtU3RhdGUgKnB2cywKIAkJCQkJCQkJCQkJCWxvbmcgbnVtX3RhYmxlX3R1cGxlcywKLQkJCQkJ CQkJCQkJCWludCBudW1faW5kZXhfc2NhbnMpOworCQkJCQkJCQkJCQkJaW50IG51bV9pbmRleF9z Y2FucywKKwkJCQkJCQkJCQkJCVBWV29ya2Vyc1VzYWdlICp3dXNhZ2UpOwogZXh0ZXJuIHZvaWQg cGFyYWxsZWxfdmFjdXVtX2NsZWFudXBfYWxsX2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAq cHZzLAogCQkJCQkJCQkJCQkJbG9uZyBudW1fdGFibGVfdHVwbGVzLAogCQkJCQkJCQkJCQkJaW50 IG51bV9pbmRleF9zY2FucywKLQkJCQkJCQkJCQkJCWJvb2wgZXN0aW1hdGVkX2NvdW50KTsKKwkJ CQkJCQkJCQkJCWJvb2wgZXN0aW1hdGVkX2NvdW50LAorCQkJCQkJCQkJCQkJUFZXb3JrZXJzVXNh Z2UgKnd1c2FnZSk7CiBleHRlcm4gdm9pZCBwYXJhbGxlbF92YWN1dW1fbWFpbihkc21fc2VnbWVu dCAqc2VnLCBzaG1fdG9jICp0b2MpOwogCiAvKiBpbiBjb21tYW5kcy9hbmFseXplLmMgKi8KZGlm ZiAtLWdpdCBhL3NyYy90b29scy9wZ2luZGVudC90eXBlZGVmcy5saXN0IGIvc3JjL3Rvb2xzL3Bn aW5kZW50L3R5cGVkZWZzLmxpc3QKaW5kZXggZGY0MmI3OGJjOWQuLmQ4NDMwOGM4N2FkIDEwMDY0 NAotLS0gYS9zcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdAorKysgYi9zcmMvdG9vbHMv cGdpbmRlbnQvdHlwZWRlZnMubGlzdApAQCAtMjA2Nyw2ICsyMDY3LDggQEAgUFZJbmRTdGF0cwog UFZJbmRWYWNTdGF0dXMKIFBWT0lECiBQVlNoYXJlZAorUFZXb3JrZXJzVXNhZ2UKK1BWV29ya2Vy c1N0YXRzCiBQWF9BbGlhcwogUFhfQ2lwaGVyCiBQWF9Db21ibwpAQCAtMjQwNSw2ICsyNDA3LDcg QEAgUHVsbEZpbHRlck9wcwogUHVzaEZpbHRlcgogUHVzaEZpbHRlck9wcwogUHVzaEZ1bmN0aW9u CitQVldvcmtlcnNVc2FnZQogUHlDRnVuY3Rpb24KIFB5TWV0aG9kRGVmCiBQeU1vZHVsZURlZgot LSAKMi40My4wCgo= --000000000000a87ec3064a7990c4 Content-Type: text/x-patch; charset="US-ASCII"; name="v21-0004-Tests-for-parallel-autovacuum.patch" Content-Disposition: attachment; filename="v21-0004-Tests-for-parallel-autovacuum.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mlgqd2le1 RnJvbSA2YTk5MDBhNzllNzJlN2U1MzY2MjY1YWUwNzQ5Mzk3NDIwMDZlYTA4IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBTdW4sIDIzIE5vdiAyMDI1IDAxOjA4OjE0ICswNzAwClN1YmplY3Q6IFtQQVRD SCB2MjEgNC81XSBUZXN0cyBmb3IgcGFyYWxsZWwgYXV0b3ZhY3V1bQoKLS0tCiBzcmMvYmFja2Vu ZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMgICAgICAgICAgfCAgIDcgKwogc3JjL2JhY2tlbmQv Y29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYyAgICAgICAgIHwgIDU1ICsrKwogc3JjL2JhY2tlbmQv cG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMgICAgICAgICAgIHwgIDI4ICsrCiBzcmMvaW5jbHVkZS9w b3N0bWFzdGVyL2F1dG92YWN1dW0uaCAgICAgICAgICAgfCAgIDEgKwogc3JjL3Rlc3QvbW9kdWxl cy9NYWtlZmlsZSAgICAgICAgICAgICAgICAgICAgIHwgICAxICsKIHNyYy90ZXN0L21vZHVsZXMv bWVzb24uYnVpbGQgICAgICAgICAgICAgICAgICB8ICAgMSArCiBzcmMvdGVzdC9tb2R1bGVzL3Rl c3RfYXV0b3ZhY3V1bS8uZ2l0aWdub3JlICAgfCAgIDIgKwogc3JjL3Rlc3QvbW9kdWxlcy90ZXN0 X2F1dG92YWN1dW0vTWFrZWZpbGUgICAgIHwgIDI4ICsrCiBzcmMvdGVzdC9tb2R1bGVzL3Rlc3Rf YXV0b3ZhY3V1bS9tZXNvbi5idWlsZCAgfCAgMzYgKysKIC4uLi9tb2R1bGVzL3Rlc3RfYXV0b3Zh Y3V1bS90LzAwMV9iYXNpYy5wbCAgICB8IDMzMiArKysrKysrKysrKysrKysrKysKIC4uLi90ZXN0 X2F1dG92YWN1dW0vdGVzdF9hdXRvdmFjdXVtLS0xLjAuc3FsICB8ICAxMiArCiAuLi4vbW9kdWxl cy90ZXN0X2F1dG92YWN1dW0vdGVzdF9hdXRvdmFjdXVtLmMgfCAgNDEgKysrCiAuLi4vdGVzdF9h dXRvdmFjdXVtL3Rlc3RfYXV0b3ZhY3V1bS5jb250cm9sICAgfCAgIDMgKwogMTMgZmlsZXMgY2hh bmdlZCwgNTQ3IGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0NCBzcmMvdGVzdC9tb2R1 bGVzL3Rlc3RfYXV0b3ZhY3V1bS8uZ2l0aWdub3JlCiBjcmVhdGUgbW9kZSAxMDA2NDQgc3JjL3Rl c3QvbW9kdWxlcy90ZXN0X2F1dG92YWN1dW0vTWFrZWZpbGUKIGNyZWF0ZSBtb2RlIDEwMDY0NCBz cmMvdGVzdC9tb2R1bGVzL3Rlc3RfYXV0b3ZhY3V1bS9tZXNvbi5idWlsZAogY3JlYXRlIG1vZGUg MTAwNjQ0IHNyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVtL3QvMDAxX2Jhc2ljLnBsCiBj cmVhdGUgbW9kZSAxMDA2NDQgc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2F1dG92YWN1dW0vdGVzdF9h dXRvdmFjdXVtLS0xLjAuc3FsCiBjcmVhdGUgbW9kZSAxMDA2NDQgc3JjL3Rlc3QvbW9kdWxlcy90 ZXN0X2F1dG92YWN1dW0vdGVzdF9hdXRvdmFjdXVtLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBzcmMv dGVzdC9tb2R1bGVzL3Rlc3RfYXV0b3ZhY3V1bS90ZXN0X2F1dG92YWN1dW0uY29udHJvbAoKZGlm ZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYyBiL3NyYy9iYWNr ZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYwppbmRleCBkMTllMTVjYmNjZS4uMmU4NWY3ZjE3 ZjcgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYworKysg Yi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMKQEAgLTE1MSw2ICsxNTEsNyBA QAogI2luY2x1ZGUgInN0b3JhZ2UvZnJlZXNwYWNlLmgiCiAjaW5jbHVkZSAic3RvcmFnZS9sbWdy LmgiCiAjaW5jbHVkZSAic3RvcmFnZS9yZWFkX3N0cmVhbS5oIgorI2luY2x1ZGUgInV0aWxzL2lu amVjdGlvbl9wb2ludC5oIgogI2luY2x1ZGUgInV0aWxzL2xzeXNjYWNoZS5oIgogI2luY2x1ZGUg InV0aWxzL3BnX3J1c2FnZS5oIgogI2luY2x1ZGUgInV0aWxzL3RpbWVzdGFtcC5oIgpAQCAtODY5 LDYgKzg3MCwxMiBAQCBoZWFwX3ZhY3V1bV9yZWwoUmVsYXRpb24gcmVsLCBjb25zdCBWYWN1dW1Q YXJhbXMgcGFyYW1zLAogCWxhenlfY2hlY2tfd3JhcGFyb3VuZF9mYWlsc2FmZSh2YWNyZWwpOwog CWRlYWRfaXRlbXNfYWxsb2ModmFjcmVsLCBwYXJhbXMubndvcmtlcnMpOwogCisJLyoKKwkgKiBU cmlnZ2VyIGluamVjdGlvbiBwb2ludCwgaWYgcGFyYWxsZWwgYXV0b3ZhY3V1bSBpcyBhYm91dCB0 byBiZSBzdGFydGVkLgorCSAqLworCWlmIChBbUF1dG9WYWN1dW1Xb3JrZXJQcm9jZXNzKCkgJiYg UGFyYWxsZWxWYWN1dW1Jc0FjdGl2ZSh2YWNyZWwpKQorCQlJTkpFQ1RJT05fUE9JTlQoImF1dG92 YWN1dW0tc3RhcnQtcGFyYWxsZWwtdmFjdXVtIiwgTlVMTCk7CisKIAkvKgogCSAqIENhbGwgbGF6 eV9zY2FuX2hlYXAgdG8gcGVyZm9ybSBhbGwgcmVxdWlyZWQgaGVhcCBwcnVuaW5nLCBpbmRleAog CSAqIHZhY3V1bWluZywgYW5kIGhlYXAgdmFjdXVtaW5nIChwbHVzIHJlbGF0ZWQgcHJvY2Vzc2lu ZykKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMgYi9z cmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCmluZGV4IGNjYjM4MTIxNjVjLi5m OWYyOWY5NDBjOSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxs ZWwuYworKysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCkBAIC0zOSw2 ICszOSw3IEBACiAjaW5jbHVkZSAicG9zdG1hc3Rlci9hdXRvdmFjdXVtLmgiCiAjaW5jbHVkZSAi c3RvcmFnZS9idWZtZ3IuaCIKICNpbmNsdWRlICJ0Y29wL3Rjb3Bwcm90LmgiCisjaW5jbHVkZSAi dXRpbHMvaW5qZWN0aW9uX3BvaW50LmgiCiAjaW5jbHVkZSAidXRpbHMvbHN5c2NhY2hlLmgiCiAj aW5jbHVkZSAidXRpbHMvcmVsLmgiCiAKQEAgLTMwMyw2ICszMDQsMTAgQEAgc3RhdGljIGJvb2wg cGFyYWxsZWxfdmFjdXVtX2luZGV4X2lzX3BhcmFsbGVsX3NhZmUoUmVsYXRpb24gaW5kcmVsLCBp bnQgbnVtX2luZGUKIAkJCQkJCQkJCQkJCSAgIGJvb2wgdmFjdXVtKTsKIHN0YXRpYyB2b2lkIHBh cmFsbGVsX3ZhY3V1bV9lcnJvcl9jYWxsYmFjayh2b2lkICphcmcpOwogCisjaWZkZWYgVVNFX0lO SkVDVElPTl9QT0lOVFMKK3N0YXRpYyB2b2lkIHBhcmFsbGVsX3ZhY3V1bV9yZXBvcnRfY29zdF9i YXNlZF9wYXJhbXModm9pZCk7CisjZW5kaWYKKwogLyoKICAqIFRyeSB0byBlbnRlciBwYXJhbGxl bCBtb2RlIGFuZCBjcmVhdGUgYSBwYXJhbGxlbCBjb250ZXh0LiAgVGhlbiBpbml0aWFsaXplCiAg KiBzaGFyZWQgbWVtb3J5IHN0YXRlLgpAQCAtOTIyLDYgKzkyNywxNyBAQCBwYXJhbGxlbF92YWN1 dW1fcHJvY2Vzc19hbGxfaW5kZXhlcyhQYXJhbGxlbFZhY3V1bVN0YXRlICpwdnMsIGludCBudW1f aW5kZXhfc2NhbgogCQkJCQkJCXB2cy0+cGN4dC0+bndvcmtlcnNfbGF1bmNoZWQsIG53b3JrZXJz KSkpOwogCX0KIAorCS8qCisJICogVG8gYmUgYWJsZSB0byBleGVyY2lzZSB3aGV0aGVyIGFsbCBy ZXNlcnZlZCBwYXJhbGxlbCB3b3JrZXJzIGFyZSBiZWluZworCSAqIHJlbGVhc2VkIGFueXdheSwg YWxsb3cgaW5qZWN0aW9uIHBvaW50cyB0byB0cmlnZ2VyIGEgZmFpbHVyZSBhdCB0aGlzCisJICog cG9pbnQuCisJICoKKwkgKiBUaGlzIGluamVjdGlvbiBwb2ludCBpcyBhbHNvIHVzZWQgdG8gd2Fp dCB1bnRpbCBwYXJhbGxlbCB3b3JrZXJzCisJICogZmluaXNoZXMgdGhlaXIgcGFydCBvZiBpbmRl eCBwcm9jZXNzaW5nLgorCSAqLworCWlmIChud29ya2VycyA+IDApCisJCUlOSkVDVElPTl9QT0lO VCgiYXV0b3ZhY3V1bS1sZWFkZXItYmVmb3JlLWluZGV4ZXMtcHJvY2Vzc2luZyIsIE5VTEwpOwor CiAJLyogVmFjdXVtIHRoZSBpbmRleGVzIHRoYXQgY2FuIGJlIHByb2Nlc3NlZCBieSBvbmx5IGxl YWRlciBwcm9jZXNzICovCiAJcGFyYWxsZWxfdmFjdXVtX3Byb2Nlc3NfdW5zYWZlX2luZGV4ZXMo cHZzKTsKIApAQCAtMTI5OSw2ICsxMzE1LDE2IEBAIHBhcmFsbGVsX3ZhY3V1bV9tYWluKGRzbV9z ZWdtZW50ICpzZWcsIHNobV90b2MgKnRvYykKIAkvKiBQcm9jZXNzIGluZGV4ZXMgdG8gcGVyZm9y bSB2YWN1dW0vY2xlYW51cCAqLwogCXBhcmFsbGVsX3ZhY3V1bV9wcm9jZXNzX3NhZmVfaW5kZXhl cygmcHZzKTsKIAorI2lmZGVmIFVTRV9JTkpFQ1RJT05fUE9JTlRTCisJLyoKKwkgKiBJZiB3ZSBh cmUgcGFyYWxsZWwgYXV0b3ZhY3V1bSB3b3JrZXIsIHdlIGNhbiBjb25zdW1lIGRlbGF5IHBhcmFt ZXRlcnMKKwkgKiBkdXJpbmcgaW5kZXggcHJvY2Vzc2luZyAodmlhIHZhY3V1bV9kZWxheV9wb2lu dCBjYWxsKS4gVGhpcyBsb2dnaW5nCisJICogYWxsb3dzIHRlc3RzIHRvIGVuc3VyZSB0aGlzLgor CSAqLworCWlmIChzaGFyZWQtPmFtX3BhcmFsbGVsX2F1dG92YWN1dW0pCisJCXBhcmFsbGVsX3Zh Y3V1bV9yZXBvcnRfY29zdF9iYXNlZF9wYXJhbXMoKTsKKyNlbmRpZgorCiAJLyogUmVwb3J0IGJ1 ZmZlci9XQUwgdXNhZ2UgZHVyaW5nIHBhcmFsbGVsIGV4ZWN1dGlvbiAqLwogCWJ1ZmZlcl91c2Fn ZSA9IHNobV90b2NfbG9va3VwKHRvYywgUEFSQUxMRUxfVkFDVVVNX0tFWV9CVUZGRVJfVVNBR0Us IGZhbHNlKTsKIAl3YWxfdXNhZ2UgPSBzaG1fdG9jX2xvb2t1cCh0b2MsIFBBUkFMTEVMX1ZBQ1VV TV9LRVlfV0FMX1VTQUdFLCBmYWxzZSk7CkBAIC0xMzUxLDMgKzEzNzcsMzIgQEAgcGFyYWxsZWxf dmFjdXVtX2Vycm9yX2NhbGxiYWNrKHZvaWQgKmFyZykKIAkJCXJldHVybjsKIAl9CiB9CisKKyNp ZmRlZiBVU0VfSU5KRUNUSU9OX1BPSU5UUworLyoKKyAqIExvZyB2YWx1ZXMgb2YgdGhlIHJlbGF0 ZWQgdG8gY29zdC1iYXNlZCBkZWxheSBwYXJhbWV0ZXJzLiBJdCBpcyB1c2VkIGZvcgorICogdGVz dGluZyBwdXJwb3NlLgorICovCitzdGF0aWMgdm9pZAorcGFyYWxsZWxfdmFjdXVtX3JlcG9ydF9j b3N0X2Jhc2VkX3BhcmFtcyh2b2lkKQoreworCVN0cmluZ0luZm9EYXRhIGJ1ZjsKKworCS8qIFNp bXVsYXRlIGNvbmZpZyByZWxvYWQgZHVyaW5nIG5vcm1hbCBwcm9jZXNzaW5nICovCisJcGdfYXRv bWljX2FkZF9mZXRjaF91MzIoVmFjdXVtQWN0aXZlTldvcmtlcnMsIDEpOworCXZhY3V1bV9kZWxh eV9wb2ludChmYWxzZSk7CisJcGdfYXRvbWljX3N1Yl9mZXRjaF91MzIoVmFjdXVtQWN0aXZlTldv cmtlcnMsIDEpOworCisJaW5pdFN0cmluZ0luZm8oJmJ1Zik7CisKKwlhcHBlbmRTdHJpbmdJbmZv KCZidWYsICJWYWN1dW0gY29zdC1iYXNlZCBkZWxheSBwYXJhbWV0ZXJzIG9mIHBhcmFsbGVsIHdv cmtlcjpcbiIpOworCWFwcGVuZFN0cmluZ0luZm8oJmJ1ZiwgInZhY3V1bV9jb3N0X2xpbWl0ID0g JWRcbiIsdmFjdXVtX2Nvc3RfbGltaXQpOworCWFwcGVuZFN0cmluZ0luZm8oJmJ1ZiwgInZhY3V1 bV9jb3N0X2RlbGF5ID0gJWdcbiIsIHZhY3V1bV9jb3N0X2RlbGF5KTsKKwlhcHBlbmRTdHJpbmdJ bmZvKCZidWYsICJ2YWN1dW1fY29zdF9wYWdlX21pc3MgPSAlZFxuIiwgVmFjdXVtQ29zdFBhZ2VN aXNzKTsKKwlhcHBlbmRTdHJpbmdJbmZvKCZidWYsICJ2YWN1dW1fY29zdF9wYWdlX2RpcnR5ID0g JWRcbiIsIFZhY3V1bUNvc3RQYWdlRGlydHkpOworCWFwcGVuZFN0cmluZ0luZm8oJmJ1ZiwgInZh Y3V1bV9jb3N0X3BhZ2VfaGl0ID0gJWRcbiIsIFZhY3V1bUNvc3RQYWdlSGl0KTsKKworCWVyZXBv cnQoREVCVUcyLCBlcnJtc2coIiVzIiwgYnVmLmRhdGEpKTsKKwlwZnJlZShidWYuZGF0YSk7Cit9 CisjZW5kaWYKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5j IGIvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMKaW5kZXggMGQ3OGQwMmJkMDku LjdiMjRhNWQ2ZTY3IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1 dW0uYworKysgYi9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYwpAQCAtMjQ5NSwx MiArMjQ5NSwyMCBAQCBkb19hdXRvdmFjdXVtKHZvaWQpCiAJCX0KIAkJUEdfQ0FUQ0goKTsKIAkJ eworCQkJaW50CW5yZXNlcnZlZF93b3JrZXJzID0gYXZfbndvcmtlcnNfcmVzZXJ2ZWQ7CisKIAkJ CS8qCiAJCQkgKiBQYXJhbGxlbCBhdXRvdmFjdXVtIGNhbiByZXNlcnZlIHBhcmFsbGVsIHdvcmtl cnMuIE1ha2Ugc3VyZQogCQkJICogdGhhdCBhbGwgcmVzZXJ2ZWQgd29ya2VycyBhcmUgcmVsZWFz ZWQuCiAJCQkgKi8KIAkJCUF1dG9WYWN1dW1SZWxlYXNlQWxsUGFyYWxsZWxXb3JrZXJzKCk7CiAK KwkJCWlmIChucmVzZXJ2ZWRfd29ya2VycyA+IDApCisJCQkJZXJlcG9ydChERUJVRzIsCisJCQkJ CQkoZXJybXNnKCIlZCBwYXJhbGxlbCBhdXRvdmFjdXVtIHdvcmtlcnMgaGFzIGJlZW4gcmVsZWFz ZWQgYWZ0ZXIgb2NjdXJlZCBlcnJvciIsCisJCQkJCQkJCW5yZXNlcnZlZF93b3JrZXJzKSwKKwkJ CQkJCSBlcnJoaWRlY29udGV4dCh0cnVlKSkpOworCiAJCQkvKgogCQkJICogQWJvcnQgdGhlIHRy YW5zYWN0aW9uLCBzdGFydCBhIG5ldyBvbmUsIGFuZCBwcm9jZWVkIHdpdGggdGhlCiAJCQkgKiBu ZXh0IHRhYmxlIGluIG91ciBsaXN0LgpAQCAtMzQ2NSw2ICszNDczLDIxIEBAIEF1dG9WYWN1dW1S ZWxlYXNlQWxsUGFyYWxsZWxXb3JrZXJzKHZvaWQpCiAJQXNzZXJ0KGF2X253b3JrZXJzX3Jlc2Vy dmVkID09IDApOwogfQogCisvKgorICogR2V0IG51bWJlciBvZiBmcmVlIGF1dG92YWN1dW0gcGFy YWxsZWwgd29ya2Vycy4KKyAqLwordWludDMyCitBdXRvVmFjdXVtR2V0RnJlZVBhcmFsbGVsV29y a2Vycyh2b2lkKQoreworCXVpbnQzMgkJbmZyZWVfd29ya2VyczsKKworCUxXTG9ja0FjcXVpcmUo QXV0b3ZhY3V1bUxvY2ssIExXX1NIQVJFRCk7CisJbmZyZWVfd29ya2VycyA9IEF1dG9WYWN1dW1T aG1lbS0+YXZfZnJlZVBhcmFsbGVsV29ya2VyczsKKwlMV0xvY2tSZWxlYXNlKEF1dG92YWN1dW1M b2NrKTsKKworCXJldHVybiBuZnJlZV93b3JrZXJzOworfQorCiAvKgogICogYXV0b3ZhY19pbml0 CiAgKgkJVGhpcyBpcyBjYWxsZWQgYXQgcG9zdG1hc3RlciBpbml0aWFsaXphdGlvbi4KQEAgLTM2 MzMsNSArMzY1NiwxMCBAQCBhZGp1c3RfZnJlZV9wYXJhbGxlbF93b3JrZXJzKGludCBwcmV2X21h eF9wYXJhbGxlbF93b3JrZXJzKQogCUF1dG9WYWN1dW1TaG1lbS0+YXZfZnJlZVBhcmFsbGVsV29y a2VycyA9IE1heChuZnJlZV93b3JrZXJzLCAwKTsKIAlBdXRvVmFjdXVtU2htZW0tPmF2X21heFBh cmFsbGVsV29ya2VycyA9IGF1dG92YWN1dW1fbWF4X3BhcmFsbGVsX3dvcmtlcnM7CiAKKwllcmVw b3J0KERFQlVHMiwKKwkJCShlcnJtc2coIm51bWJlciBvZiBmcmVlIHBhcmFsbGVsIGF1dG92YWN1 dW0gd29ya2VycyBpcyBzZXQgdG8gJXUgZHVlIHRvIGNvbmZpZyByZWxvYWQiLAorCQkJCQlBdXRv VmFjdXVtU2htZW0tPmF2X2ZyZWVQYXJhbGxlbFdvcmtlcnMpLAorCQkJIGVycmhpZGVjb250ZXh0 KHRydWUpKSk7CisKIAlMV0xvY2tSZWxlYXNlKEF1dG92YWN1dW1Mb2NrKTsKIH0KZGlmZiAtLWdp dCBhL3NyYy9pbmNsdWRlL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5oIGIvc3JjL2luY2x1ZGUvcG9z dG1hc3Rlci9hdXRvdmFjdXVtLmgKaW5kZXggZjM3ODNhZmI1MWIuLjUyYmUyNjBlMTVmIDEwMDY0 NAotLS0gYS9zcmMvaW5jbHVkZS9wb3N0bWFzdGVyL2F1dG92YWN1dW0uaAorKysgYi9zcmMvaW5j bHVkZS9wb3N0bWFzdGVyL2F1dG92YWN1dW0uaApAQCAtNjYsNiArNjYsNyBAQCBleHRlcm4gYm9v bCBBdXRvVmFjdXVtUmVxdWVzdFdvcmsoQXV0b1ZhY3V1bVdvcmtJdGVtVHlwZSB0eXBlLAogZXh0 ZXJuIHZvaWQJQXV0b1ZhY3V1bVJlc2VydmVQYXJhbGxlbFdvcmtlcnMoaW50ICpud29ya2Vycyk7 CiBleHRlcm4gdm9pZCBBdXRvVmFjdXVtUmVsZWFzZVBhcmFsbGVsV29ya2VycyhpbnQgbndvcmtl cnMpOwogZXh0ZXJuIHZvaWQgQXV0b1ZhY3V1bVJlbGVhc2VBbGxQYXJhbGxlbFdvcmtlcnModm9p ZCk7CitleHRlcm4gdWludDMyIEF1dG9WYWN1dW1HZXRGcmVlUGFyYWxsZWxXb3JrZXJzKHZvaWQp OwogCiAvKiBzaGFyZWQgbWVtb3J5IHN0dWZmICovCiBleHRlcm4gU2l6ZSBBdXRvVmFjdXVtU2ht ZW1TaXplKHZvaWQpOwpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvbW9kdWxlcy9NYWtlZmlsZSBiL3Ny Yy90ZXN0L21vZHVsZXMvTWFrZWZpbGUKaW5kZXggNDRjNzE2M2MxY2QuLjkzN2RiYjY0ZmQyIDEw MDY0NAotLS0gYS9zcmMvdGVzdC9tb2R1bGVzL01ha2VmaWxlCisrKyBiL3NyYy90ZXN0L21vZHVs ZXMvTWFrZWZpbGUKQEAgLTE2LDYgKzE2LDcgQEAgU1VCRElSUyA9IFwKIAkJICBwbHNhbXBsZSBc CiAJCSAgc3BnaXN0X25hbWVfb3BzIFwKIAkJICB0ZXN0X2FpbyBcCisJCSAgdGVzdF9hdXRvdmFj dXVtIFwKIAkJICB0ZXN0X2JpbmFyeWhlYXAgXAogCQkgIHRlc3RfYml0bWFwc2V0IFwKIAkJICB0 ZXN0X2Jsb29tZmlsdGVyIFwKZGlmZiAtLWdpdCBhL3NyYy90ZXN0L21vZHVsZXMvbWVzb24uYnVp bGQgYi9zcmMvdGVzdC9tb2R1bGVzL21lc29uLmJ1aWxkCmluZGV4IDI2MzRhNTE5OTM1Li41YWM4 ZDg3NzAyZCAxMDA2NDQKLS0tIGEvc3JjL3Rlc3QvbW9kdWxlcy9tZXNvbi5idWlsZAorKysgYi9z cmMvdGVzdC9tb2R1bGVzL21lc29uLmJ1aWxkCkBAIC0xNiw2ICsxNiw3IEBAIHN1YmRpcigncGxz YW1wbGUnKQogc3ViZGlyKCdzcGdpc3RfbmFtZV9vcHMnKQogc3ViZGlyKCdzc2xfcGFzc3BocmFz ZV9jYWxsYmFjaycpCiBzdWJkaXIoJ3Rlc3RfYWlvJykKK3N1YmRpcigndGVzdF9hdXRvdmFjdXVt JykKIHN1YmRpcigndGVzdF9iaW5hcnloZWFwJykKIHN1YmRpcigndGVzdF9iaXRtYXBzZXQnKQog c3ViZGlyKCd0ZXN0X2Jsb29tZmlsdGVyJykKZGlmZiAtLWdpdCBhL3NyYy90ZXN0L21vZHVsZXMv dGVzdF9hdXRvdmFjdXVtLy5naXRpZ25vcmUgYi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYXV0b3Zh Y3V1bS8uZ2l0aWdub3JlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi43 MTZlMTdmNWEyYQotLS0gL2Rldi9udWxsCisrKyBiL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRv dmFjdXVtLy5naXRpZ25vcmUKQEAgLTAsMCArMSwyIEBACisjIEdlbmVyYXRlZCBzdWJkaXJlY3Rv cmllcworL3RtcF9jaGVjay8KZGlmZiAtLWdpdCBhL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRv dmFjdXVtL01ha2VmaWxlIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2F1dG92YWN1dW0vTWFrZWZp bGUKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLjMyMjU0YzUzYTVkCi0t LSAvZGV2L251bGwKKysrIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2F1dG92YWN1dW0vTWFrZWZp bGUKQEAgLTAsMCArMSwyOCBAQAorIyBzcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYXV0b3ZhY3V1bS9N YWtlZmlsZQorCitQR0ZJTEVERVNDID0gInRlc3RfYXV0b3ZhY3V1bSAtIHRlc3QgY29kZSBmb3Ig cGFyYWxsZWwgYXV0b3ZhY3V1bSIKKworTU9EVUxFX2JpZyA9IHRlc3RfYXV0b3ZhY3V1bQorT0JK UyA9IFwKKwkkKFdJTjMyUkVTKSBcCisJdGVzdF9hdXRvdmFjdXVtLm8KKworRVhURU5TSU9OID0g dGVzdF9hdXRvdmFjdXVtCitEQVRBID0gdGVzdF9hdXRvdmFjdXVtLS0xLjAuc3FsCisKK1RBUF9U RVNUUyA9IDEKKworRVhUUkFfSU5TVEFMTCA9IHNyYy90ZXN0L21vZHVsZXMvaW5qZWN0aW9uX3Bv aW50cworCitleHBvcnQgZW5hYmxlX2luamVjdGlvbl9wb2ludHMKKworaWZkZWYgVVNFX1BHWFMK K1BHX0NPTkZJRyA9IHBnX2NvbmZpZworUEdYUyA6PSAkKHNoZWxsICQoUEdfQ09ORklHKSAtLXBn eHMpCitpbmNsdWRlICQoUEdYUykKK2Vsc2UKK3N1YmRpciA9IHNyYy90ZXN0L21vZHVsZXMvdGVz dF9hdXRvdmFjdXVtCit0b3BfYnVpbGRkaXIgPSAuLi8uLi8uLi8uLgoraW5jbHVkZSAkKHRvcF9i dWlsZGRpcikvc3JjL01ha2VmaWxlLmdsb2JhbAoraW5jbHVkZSAkKHRvcF9zcmNkaXIpL2NvbnRy aWIvY29udHJpYi1nbG9iYWwubWsKK2VuZGlmCmRpZmYgLS1naXQgYS9zcmMvdGVzdC9tb2R1bGVz L3Rlc3RfYXV0b3ZhY3V1bS9tZXNvbi5idWlsZCBiL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRv dmFjdXVtL21lc29uLmJ1aWxkCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw Li4zNDQxZTVlNDljZgotLS0gL2Rldi9udWxsCisrKyBiL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9h dXRvdmFjdXVtL21lc29uLmJ1aWxkCkBAIC0wLDAgKzEsMzYgQEAKKyMgQ29weXJpZ2h0IChjKSAy MDI0LTIwMjUsIFBvc3RncmVTUUwgR2xvYmFsIERldmVsb3BtZW50IEdyb3VwCisKK3Rlc3RfYXV0 b3ZhY3V1bV9zb3VyY2VzID0gZmlsZXMoCisgICd0ZXN0X2F1dG92YWN1dW0uYycsCispCisKK2lm IGhvc3Rfc3lzdGVtID09ICd3aW5kb3dzJworICB0ZXN0X2F1dG92YWN1dW1fc291cmNlcyArPSBy Y19saWJfZ2VuLnByb2Nlc3Mod2luMzJ2ZXJfcmMsIGV4dHJhX2FyZ3M6IFsKKyAgICAnLS1OQU1F JywgJ3Rlc3RfYXV0b3ZhY3V1bScsCisgICAgJy0tRklMRURFU0MnLCAndGVzdF9hdXRvdmFjdXVt IC0gdGVzdCBjb2RlIGZvciBwYXJhbGxlbCBhdXRvdmFjdXVtJyxdKQorZW5kaWYKKwordGVzdF9h dXRvdmFjdXVtID0gc2hhcmVkX21vZHVsZSgndGVzdF9hdXRvdmFjdXVtJywKKyAgdGVzdF9hdXRv dmFjdXVtX3NvdXJjZXMsCisgIGt3YXJnczogcGdfdGVzdF9tb2RfYXJncywKKykKK3Rlc3RfaW5z dGFsbF9saWJzICs9IHRlc3RfYXV0b3ZhY3V1bQorCit0ZXN0X2luc3RhbGxfZGF0YSArPSBmaWxl cygKKyAgJ3Rlc3RfYXV0b3ZhY3V1bS5jb250cm9sJywKKyAgJ3Rlc3RfYXV0b3ZhY3V1bS0tMS4w LnNxbCcsCispCisKK3Rlc3RzICs9IHsKKyAgJ25hbWUnOiAndGVzdF9hdXRvdmFjdXVtJywKKyAg J3NkJzogbWVzb24uY3VycmVudF9zb3VyY2VfZGlyKCksCisgICdiZCc6IG1lc29uLmN1cnJlbnRf YnVpbGRfZGlyKCksCisgICd0YXAnOiB7CisgICAgJ2Vudic6IHsKKyAgICAgICAnZW5hYmxlX2lu amVjdGlvbl9wb2ludHMnOiBnZXRfb3B0aW9uKCdpbmplY3Rpb25fcG9pbnRzJykgPyAneWVzJyA6 ICdubycsCisgICAgfSwKKyAgICAndGVzdHMnOiBbCisgICAgICAndC8wMDFfYmFzaWMucGwnLAor ICAgIF0sCisgIH0sCit9CmRpZmYgLS1naXQgYS9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYXV0b3Zh Y3V1bS90LzAwMV9iYXNpYy5wbCBiL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVtL3Qv MDAxX2Jhc2ljLnBsCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi5iM2Qy MjM2MWRjZgotLS0gL2Rldi9udWxsCisrKyBiL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFj dXVtL3QvMDAxX2Jhc2ljLnBsCkBAIC0wLDAgKzEsMzMyIEBACisjIFRlc3QgcGFyYWxsZWwgYXV0 b3ZhY3V1bSBiZWhhdmlvcgorCit1c2Ugd2FybmluZ3MgRkFUQUwgPT4gJ2FsbCc7Cit1c2UgUG9z dGdyZVNRTDo6VGVzdDo6Q2x1c3RlcjsKK3VzZSBQb3N0Z3JlU1FMOjpUZXN0OjpVdGlsczsKK3Vz ZSBUZXN0OjpNb3JlOworCitpZiAoJEVOVntlbmFibGVfaW5qZWN0aW9uX3BvaW50c30gbmUgJ3ll cycpCit7CisJcGxhbiBza2lwX2FsbCA9PiAnSW5qZWN0aW9uIHBvaW50cyBub3Qgc3VwcG9ydGVk IGJ5IHRoaXMgYnVpbGQnOworfQorCisjIEJlZm9yZSBlYWNoIHRlc3Qgd2Ugc2hvdWxkIGRpc2Fi bGUgYXV0b3ZhY3V1bSBmb3IgJ3Rlc3RfYXV0b3ZhYycgdGFibGUgYW5kCisjIGdlbmVyYXRlIHNv bWUgZGVhZCB0dXBsZXMgaW4gaXQuCisKK3N1YiBwcmVwYXJlX2Zvcl9uZXh0X3Rlc3QKK3sKKwlt eSAoJG5vZGUsICR0ZXN0X251bWJlcikgPSBAXzsKKworCSRub2RlLT5zYWZlX3BzcWwoJ3Bvc3Rn cmVzJywgcXF7CisJCUFMVEVSIFRBQkxFIHRlc3RfYXV0b3ZhYyBTRVQgKGF1dG92YWN1dW1fZW5h YmxlZCA9IGZhbHNlKTsKKwl9KTsKKworCSRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgcXF7 CisJCVVQREFURSB0ZXN0X2F1dG92YWMgU0VUIGNvbF8xID0gJHRlc3RfbnVtYmVyOworCX0pOwor fQorCisKK215ICRwc3FsX291dDsKKworbXkgJG5vZGUgPSBQb3N0Z3JlU1FMOjpUZXN0OjpDbHVz dGVyLT5uZXcoJ25vZGUxJyk7Ciskbm9kZS0+aW5pdDsKKworIyBDb25maWd1cmUgcG9zdGdyZXMs IHNvIGl0IGNhbiBsYXVuY2ggcGFyYWxsZWwgYXV0b3ZhY3V1bSB3b3JrZXJzLCBsb2cgYWxsCisj IGluZm9ybWF0aW9uIHdlIGFyZSBpbnRlcmVzdGVkIGluIGFuZCBhdXRvdmFjdXVtIHdvcmtzIGZy ZXF1ZW50bHkKKyRub2RlLT5hcHBlbmRfY29uZigncG9zdGdyZXNxbC5jb25mJywgcXF7CisJbWF4 X3dvcmtlcl9wcm9jZXNzZXMgPSAyMAorCW1heF9wYXJhbGxlbF93b3JrZXJzID0gMjAKKwltYXhf cGFyYWxsZWxfbWFpbnRlbmFuY2Vfd29ya2VycyA9IDIwCisJYXV0b3ZhY3V1bV9tYXhfcGFyYWxs ZWxfd29ya2VycyA9IDIwCisJbG9nX21pbl9tZXNzYWdlcyA9IGRlYnVnMgorCWxvZ19hdXRvdmFj dXVtX21pbl9kdXJhdGlvbiA9IDAKKwlhdXRvdmFjdXVtX25hcHRpbWUgPSAnMXMnCisJbWluX3Bh cmFsbGVsX2luZGV4X3NjYW5fc2l6ZSA9IDAKKwlzaGFyZWRfcHJlbG9hZF9saWJyYXJpZXM9dGVz dF9hdXRvdmFjdXVtCit9KTsKKyRub2RlLT5zdGFydDsKKworIyBDaGVjayBpZiB0aGUgZXh0ZW5z aW9uIGluamVjdGlvbl9wb2ludHMgaXMgYXZhaWxhYmxlLCBhcyBpdCBtYXkgYmUKKyMgcG9zc2li bGUgdGhhdCB0aGlzIHNjcmlwdCBpcyBydW4gd2l0aCBpbnN0YWxsY2hlY2ssIHdoZXJlIHRoZSBt b2R1bGUKKyMgd291bGQgbm90IGJlIGluc3RhbGxlZCBieSBkZWZhdWx0LgoraWYgKCEkbm9kZS0+ Y2hlY2tfZXh0ZW5zaW9uKCdpbmplY3Rpb25fcG9pbnRzJykpCit7CisJcGxhbiBza2lwX2FsbCA9 PiAnRXh0ZW5zaW9uIGluamVjdGlvbl9wb2ludHMgbm90IGluc3RhbGxlZCc7Cit9CisKKyMgQ3Jl YXRlIGFsbCBmdW5jdGlvbnMgbmVlZGVkIGZvciB0ZXN0aW5nCiskbm9kZS0+c2FmZV9wc3FsKCdw b3N0Z3JlcycsIHFxeworCUNSRUFURSBFWFRFTlNJT04gdGVzdF9hdXRvdmFjdXVtOworCUNSRUFU RSBFWFRFTlNJT04gaW5qZWN0aW9uX3BvaW50czsKK30pOworCitteSAkaW5kZXhlc19udW0gPSA0 OworbXkgJGluaXRpYWxfcm93c19udW0gPSAxMF8wMDA7CitteSAkYXV0b3ZhY3V1bV9wYXJhbGxl bF93b3JrZXJzID0gMjsKKworIyBDcmVhdGUgdGFibGUgYW5kIGZpbGwgaXQgd2l0aCBzb21lIGRh dGEKKyRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgcXF7CisJQ1JFQVRFIFRBQkxFIHRlc3Rf YXV0b3ZhYyAoCisJCWlkIFNFUklBTCBQUklNQVJZIEtFWSwKKwkJY29sXzEgSU5URUdFUiwgIGNv bF8yIElOVEVHRVIsICBjb2xfMyBJTlRFR0VSLCAgY29sXzQgSU5URUdFUgorCSkgV0lUSCAoYXV0 b3ZhY3V1bV9wYXJhbGxlbF93b3JrZXJzID0gJGF1dG92YWN1dW1fcGFyYWxsZWxfd29ya2Vycyk7 CisKKwlJTlNFUlQgSU5UTyB0ZXN0X2F1dG92YWMKKwlTRUxFQ1QKKwkJZyBBUyBjb2wxLAorCQln ICsgMSBBUyBjb2wyLAorCQlnICsgMiBBUyBjb2wzLAorCQlnICsgMyBBUyBjb2w0CisJRlJPTSBn ZW5lcmF0ZV9zZXJpZXMoMSwgJGluaXRpYWxfcm93c19udW0pIEFTIGc7Cit9KTsKKworIyBDcmVh dGUgc3BlY2lmaWVkIG51bWJlciBvZiBiLXRyZWUgaW5kZXhlcyBvbiB0aGUgdGFibGUKKyRub2Rl LT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgcXF7CisJRE8gXCRcJAorCURFQ0xBUkUKKwkJaSBJTlRF R0VSOworCUJFR0lOCisJCUZPUiBpIElOIDEuLiRpbmRleGVzX251bSBMT09QCisJCQlFWEVDVVRF IGZvcm1hdCgnQ1JFQVRFIElOREVYIGlkeF9jb2xfXCVzIE9OIHRlc3RfYXV0b3ZhYyAoY29sX1wl cyk7JywgaSwgaSk7CisJCUVORCBMT09QOworCUVORCBcJFwkOworfSk7CisKKyMgVGVzdCAxIDoK KyMgT3VyIHRhYmxlIGhhcyBlbm91Z2ggaW5kZXhlcyBhbmQgYXBwcm9wcmlhdGUgcmVsb3B0aW9u cywgc28gYXV0b3ZhY3V1bSBtdXN0CisjIGJlIGFibGUgdG8gcHJvY2VzcyBpdCBpbiBwYXJhbGxl bCBtb2RlLiBKdXN0IGNoZWNrIGlmIGl0IGNhbi4KKyMgQWxzbyBjaGVjayB3aGV0aGVyIGFsbCBy ZXF1ZXN0ZWQgd29ya2VyczoKKyMgCTEpIGxhdW5jaGVkCisjIAkyKSBjb3JyZWN0bHkgcmVsZWFz ZWQKKworcHJlcGFyZV9mb3JfbmV4dF90ZXN0KCRub2RlLCAxKTsKKworJG5vZGUtPnNhZmVfcHNx bCgncG9zdGdyZXMnLCBxcXsKKwlBTFRFUiBUQUJMRSB0ZXN0X2F1dG92YWMgU0VUIChhdXRvdmFj dXVtX2VuYWJsZWQgPSB0cnVlKTsKK30pOworCisjIFdhaXQgdW50aWwgdGhlIHBhcmFsbGVsIGF1 dG92YWN1dW0gb24gdGFibGUgaXMgY29tcGxldGVkLiBBdCB0aGUgc2FtZSB0aW1lLAorIyB3ZSBj aGVjayB0aGF0IHRoZSByZXF1aXJlZCBudW1iZXIgb2YgcGFyYWxsZWwgd29ya2VycyBoYXMgYmVl biBzdGFydGVkLgorJGxvZ19zdGFydCA9ICRub2RlLT53YWl0X2Zvcl9sb2coCisJcXIvcGFyYWxs ZWwgaW5kZXggdmFjdXVtOiAyIHdvcmtlcnMgd2VyZSBwbGFubmVkLCAvIC4KKwlxci8yIHdvcmtl cnMgd2VyZSByZXNlcnZlZCBhbmQgMiB3b3JrZXJzIHdlcmUgbGF1bmNoZWQgaW4gdG90YWwvLAor CSRsb2dfc3RhcnQKKyk7CisKKyRwc3FsX291dCA9ICRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVz JywgcXF7CisJU0VMRUNUIGdldF9wYXJhbGxlbF9hdXRvdmFjdXVtX2ZyZWVfd29ya2VycygpOwor fSk7CitpcygkcHNxbF9vdXQsIDIwLCAnQWxsIHBhcmFsbGVsIHdvcmtlcnMgaGFzIGJlZW4gcmVs ZWFzZWQgYnkgdGhlIGxlYWRlcicpOworCisjIFRlc3QgMjoKKyMgQ2hlY2sgd2hldGhlciBwYXJh bGxlbCBhdXRvdmFjdXVtIGxlYWRlciBjYW4gcHJvcGFnYXRlIGNvc3QtYmFzZWQgcGFyYW1ldGVy cworIyB0byBwYXJhbGxlbCB3b3JrZXJzLgorCitwcmVwYXJlX2Zvcl9uZXh0X3Rlc3QoJG5vZGUs IDIpOworCiskbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFxeworCVNFTEVDVCBpbmplY3Rp b25fcG9pbnRzX2F0dGFjaCgnYXV0b3ZhY3V1bS1zdGFydC1wYXJhbGxlbC12YWN1dW0nLCAnd2Fp dCcpOworCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX2F0dGFjaCgnYXV0b3ZhY3V1bS1sZWFkZXIt YmVmb3JlLWluZGV4ZXMtcHJvY2Vzc2luZycsICd3YWl0Jyk7CisKKwlBTFRFUiBUQUJMRSB0ZXN0 X2F1dG92YWMgU0VUIChhdXRvdmFjdXVtX3BhcmFsbGVsX3dvcmtlcnMgPSAxLCBhdXRvdmFjdXVt X2VuYWJsZWQgPSB0cnVlKTsKK30pOworCisjIFdhaXQgdW50aWwgcGFyYWxsZWwgYXV0b3ZhY3V1 bSBpcyBpbml0ZWQKKyRub2RlLT53YWl0X2Zvcl9ldmVudCgKKwknYXV0b3ZhY3V1bSB3b3JrZXIn LAorCSdhdXRvdmFjdXVtLXN0YXJ0LXBhcmFsbGVsLXZhY3V1bScKKyk7CisKKyMgUmVsb2FkIGNv bmZpZyAtIGxlYWRlciB3b3JrZXIgbXVzdCB1cGRhdGUgaXRzIG93biBwYXJhbWV0ZXJzIGR1cmlu ZyBpbmRleGVzCisjIHByb2Nlc3NpbmcKKyRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgcXF7 CisJQUxURVIgU1lTVEVNIFNFVCB2YWN1dW1fY29zdF9saW1pdCA9IDUwMDsKKwlBTFRFUiBTWVNU RU0gU0VUIHZhY3V1bV9jb3N0X3BhZ2VfbWlzcyA9IDEwOworCUFMVEVSIFNZU1RFTSBTRVQgdmFj dXVtX2Nvc3RfcGFnZV9kaXJ0eSA9IDEwOworCUFMVEVSIFNZU1RFTSBTRVQgdmFjdXVtX2Nvc3Rf cGFnZV9oaXQgPSAxMDsKKwlTRUxFQ1QgcGdfcmVsb2FkX2NvbmYoKTsKK30pOworCiskbm9kZS0+ c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFxeworCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX3dha2V1 cCgnYXV0b3ZhY3V1bS1zdGFydC1wYXJhbGxlbC12YWN1dW0nKTsKK30pOworCisjIE5vdyB3YWl0 IHVudGlsIHBhcmFsbGVsIGF1dG92YWN1dW0gbGVhZGVyIGNvbXBsZXRlcyBwcm9jZXNzaW5nIHRh YmxlIChpLmUuCisjIGd1YXJhbnRlZWQgdG8gY2FsbCB2YWN1dW1fZGVsYXlfcG9pbnQpIGFuZCBs YXVuY2hlcyBwYXJhbGxlbCB3b3JrZXIuCiskbm9kZS0+d2FpdF9mb3JfZXZlbnQoCisJJ2F1dG92 YWN1dW0gd29ya2VyJywKKwknYXV0b3ZhY3V1bS1sZWFkZXItYmVmb3JlLWluZGV4ZXMtcHJvY2Vz c2luZycKKyk7CisKKyMgQ2hlY2sgd2hldGhlciBwYXJhbGxlbCB3b3JrZXIgc3VjY2Vzc2Z1bGx5 IHVwZGF0ZWQgYWxsIHBhcmFtZXRlcnMgZHVyaW5nCisjIGluZGV4IHByb2Nlc3NpbmcKKyRsb2df c3RhcnQgPSAkbm9kZS0+d2FpdF9mb3JfbG9nKAorCXFyL1ZhY3V1bSBjb3N0LWJhc2VkIGRlbGF5 IHBhcmFtZXRlcnMgb2YgcGFyYWxsZWwgd29ya2VyOlxuLyAuCisJcXIvXHR2YWN1dW1fY29zdF9s aW1pdCA9IDUwMFxuLyAuCisJcXIvXHR2YWN1dW1fY29zdF9kZWxheSA9IDJcbi8gLgorCXFyL1x0 dmFjdXVtX2Nvc3RfcGFnZV9taXNzID0gMTBcbi8gLgorCXFyL1x0dmFjdXVtX2Nvc3RfcGFnZV9k aXJ0eSA9IDEwXG4vIC4KKwlxci9cdHZhY3V1bV9jb3N0X3BhZ2VfaGl0ID0gMTBcbi8sCisJJGxv Z19zdGFydAorKTsKKworIyBDbGVhbnVwCiskbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFx eworCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX3dha2V1cCgnYXV0b3ZhY3V1bS1sZWFkZXItYmVm b3JlLWluZGV4ZXMtcHJvY2Vzc2luZycpOworCisJU0VMRUNUIGluamVjdGlvbl9wb2ludHNfZGV0 YWNoKCdhdXRvdmFjdXVtLXN0YXJ0LXBhcmFsbGVsLXZhY3V1bScpOworCVNFTEVDVCBpbmplY3Rp b25fcG9pbnRzX2RldGFjaCgnYXV0b3ZhY3V1bS1sZWFkZXItYmVmb3JlLWluZGV4ZXMtcHJvY2Vz c2luZycpOworCisJQUxURVIgVEFCTEUgdGVzdF9hdXRvdmFjIFNFVCAoYXV0b3ZhY3V1bV9wYXJh bGxlbF93b3JrZXJzID0gJGF1dG92YWN1dW1fcGFyYWxsZWxfd29ya2Vycyk7Cit9KTsKKworIyBU ZXN0IDM6CisjIFRlc3QgYWRqdXN0bWVudCBvZiBmcmVlIHBhcmFsbGVsIHdvcmtlcnMgbnVtYmVy IHdoZW4gY2hhbmdpbmcKKyMgYXV0b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2VycyBwYXJhbWV0 ZXIKKworcHJlcGFyZV9mb3JfbmV4dF90ZXN0KCRub2RlLCA0KTsKKworJG5vZGUtPnNhZmVfcHNx bCgncG9zdGdyZXMnLCBxcXsKKwlTRUxFQ1QgaW5qZWN0aW9uX3BvaW50c19hdHRhY2goJ2F1dG92 YWN1dW0tbGVhZGVyLWJlZm9yZS1pbmRleGVzLXByb2Nlc3NpbmcnLCAnd2FpdCcpOworCUFMVEVS IFRBQkxFIHRlc3RfYXV0b3ZhYyBTRVQgKGF1dG92YWN1dW1fZW5hYmxlZCA9IHRydWUpOworfSk7 CisKKyRub2RlLT53YWl0X2Zvcl9ldmVudCgKKwknYXV0b3ZhY3V1bSB3b3JrZXInLAorCSdhdXRv dmFjdXVtLWxlYWRlci1iZWZvcmUtaW5kZXhlcy1wcm9jZXNzaW5nJworKTsKKworJG5vZGUtPnNh ZmVfcHNxbCgncG9zdGdyZXMnLCBxcXsKKwlBTFRFUiBTWVNURU0gU0VUIGF1dG92YWN1dW1fbWF4 X3BhcmFsbGVsX3dvcmtlcnMgPSAxOworCVNFTEVDVCBwZ19yZWxvYWRfY29uZigpOworfSk7CisK KyMgU2luY2UgMiBwYXJhbGxlbCB3b3JrZXJzIGFscmVhZHkgbGF1bmNoZWQgYW5kIHdpbGwgYmUg cmVsZWFzZWQgaW4gdGhlIGZ1dHVyZSwKKyMgd2UgYXJlIGV4cGVjdGluZyB0aGF0IDoKKyMgMSkg bnVtYmVyIG9mIGZyZWUgd29ya2VycyB3aWxsIGJlICcwJyBhZnRlciBjb25maWcgcmVsb2FkCisj IDIpIG51bWJlciBvZiBmcmVlIHdvcmtlcnMgd2lsbCBiZSAnMScgYWZ0ZXIgcmVsZWFzaW5nIHdv cmtlcnMKKworIyBDaGVjayBzdGF0ZW1lbnQgKDEpCiskbG9nX3N0YXJ0ID0gJG5vZGUtPndhaXRf Zm9yX2xvZygKKwlxci9udW1iZXIgb2YgZnJlZSBwYXJhbGxlbCBhdXRvdmFjdXVtIHdvcmtlcnMg aXMgc2V0IHRvIDAgZHVlIHRvIGNvbmZpZyByZWxvYWQvLAorCSRsb2dfc3RhcnQKKyk7CisKKyRu b2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgcXF7CisJU0VMRUNUIGluamVjdGlvbl9wb2ludHNf d2FrZXVwKCdhdXRvdmFjdXVtLWxlYWRlci1iZWZvcmUtaW5kZXhlcy1wcm9jZXNzaW5nJyk7Cit9 KTsKKworIyBXYWl0IHVudGlsIHRoZSBlbmQgb2YgcGFyYWxsZWwgcHJvY2Vzc2luZworJGxvZ19z dGFydCA9ICRub2RlLT53YWl0X2Zvcl9sb2coCisJcXIvcGFyYWxsZWwgaW5kZXggdmFjdXVtOiAy IHdvcmtlcnMgd2VyZSBwbGFubmVkLCAvIC4KKwlxci8yIHdvcmtlcnMgd2VyZSByZXNlcnZlZCBh bmQgMiB3b3JrZXJzIHdlcmUgbGF1bmNoZWQgaW4gdG90YWwvLAorCSRsb2dfc3RhcnQKKyk7CisK KyMgQ2hlY2sgc3RhdGVtZW50ICgyKQorJHBzcWxfb3V0ID0gJG5vZGUtPnNhZmVfcHNxbCgncG9z dGdyZXMnLCBxcXsKKwlTRUxFQ1QgZ2V0X3BhcmFsbGVsX2F1dG92YWN1dW1fZnJlZV93b3JrZXJz KCk7Cit9KTsKK2lzKCRwc3FsX291dCwgMSwgJ051bWJlciBvZiBmcmVlIHBhcmFsbGVsIHdvcmtl cnMgaXMgY29uc2lzdGVudCcpOworCisjIENsZWFudXAKKyRub2RlLT5zYWZlX3BzcWwoJ3Bvc3Rn cmVzJywgcXF7CisJU0VMRUNUIGluamVjdGlvbl9wb2ludHNfZGV0YWNoKCdhdXRvdmFjdXVtLWxl YWRlci1iZWZvcmUtaW5kZXhlcy1wcm9jZXNzaW5nJyk7CisJQUxURVIgU1lTVEVNIFNFVCBhdXRv dmFjdXVtX21heF9wYXJhbGxlbF93b3JrZXJzID0gMTA7CisJU0VMRUNUIHBnX3JlbG9hZF9jb25m KCk7Cit9KTsKKworIyBUZXN0IDQ6CisjIFdlIHdhbnQgcGFyYWxsZWwgYXV0b3ZhY3V1bSB3b3Jr ZXJzIHRvIGJlIHJlbGVhc2VkIGV2ZW4gaWYgbGVhZGVyIGdldHMgYW4KKyMgZXJyb3IuIEF0IGZp cnN0LCBzaW11bGF0ZSBzaXR1YXRpb24sIHdoZW4gbGVhZGVyIGV4aXRzIGR1ZSB0byBhbiBFUlJP Ui4KKworcHJlcGFyZV9mb3JfbmV4dF90ZXN0KCRub2RlLCA0KTsKKworJG5vZGUtPnNhZmVfcHNx bCgncG9zdGdyZXMnLCBxcXsKKwlTRUxFQ1QgaW5qZWN0aW9uX3BvaW50c19hdHRhY2goJ2F1dG92 YWN1dW0tbGVhZGVyLWJlZm9yZS1pbmRleGVzLXByb2Nlc3NpbmcnLCAnZXJyb3InKTsKKwlBTFRF UiBUQUJMRSB0ZXN0X2F1dG92YWMgU0VUIChhdXRvdmFjdXVtX2VuYWJsZWQgPSB0cnVlKTsKK30p OworCiskbG9nX3N0YXJ0ID0gJG5vZGUtPndhaXRfZm9yX2xvZygKKwlxci9lcnJvciB0cmlnZ2Vy ZWQgZm9yIGluamVjdGlvbiBwb2ludCAvIC4KKwlxci9hdXRvdmFjdXVtLWxlYWRlci1iZWZvcmUt aW5kZXhlcy1wcm9jZXNzaW5nLywKKwkkbG9nX3N0YXJ0CispOworCiskbG9nX3N0YXJ0ID0gJG5v ZGUtPndhaXRfZm9yX2xvZygKKwlxci8yIHBhcmFsbGVsIGF1dG92YWN1dW0gd29ya2VycyBoYXMg YmVlbiByZWxlYXNlZCBhZnRlciBvY2N1cmVkIGVycm9yLywKKwkkbG9nX3N0YXJ0CispOworCisj IENsZWFudXAKKyRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgcXF7CisJU0VMRUNUIGluamVj dGlvbl9wb2ludHNfZGV0YWNoKCdhdXRvdmFjdXVtLWxlYWRlci1iZWZvcmUtaW5kZXhlcy1wcm9j ZXNzaW5nJyk7Cit9KTsKKworIyBUZXN0IDU6CisjIFNhbWUgYXMgYWJvdmUgdGVzdCwgYnV0IHNp bXVsYXRlIHNpdHVhdGlvbiwgd2hlbiBsZWFkZXIgZXhpdHMgZHVlIHRvIEZBVEFMLgorCitwcmVw YXJlX2Zvcl9uZXh0X3Rlc3QoJG5vZGUsIDUpOworCiskbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3Jl cycsIHFxeworCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX2F0dGFjaCgnYXV0b3ZhY3V1bS1zdGFy dC1wYXJhbGxlbC12YWN1dW0nLCAnd2FpdCcpOworCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX2F0 dGFjaCgnYXV0b3ZhY3V1bS1sZWFkZXItYmVmb3JlLWluZGV4ZXMtcHJvY2Vzc2luZycsICd3YWl0 Jyk7CisJQUxURVIgVEFCTEUgdGVzdF9hdXRvdmFjIFNFVCAoYXV0b3ZhY3V1bV9lbmFibGVkID0g dHJ1ZSk7Cit9KTsKKworIyBXYWl0IHVudGlsIHBhcmFsbGVsIGF1dG92YWN1dW0gaXMgaW5pdGVk IGFuZCB3YWtlIHVwIHRoZSBsZWFkZXIKKyRub2RlLT53YWl0X2Zvcl9ldmVudCgKKwknYXV0b3Zh Y3V1bSB3b3JrZXInLAorCSdhdXRvdmFjdXVtLXN0YXJ0LXBhcmFsbGVsLXZhY3V1bScKKyk7Cisk bm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFxeworCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRz X3dha2V1cCgnYXV0b3ZhY3V1bS1zdGFydC1wYXJhbGxlbC12YWN1dW0nKTsKK30pOworCiskbm9k ZS0+d2FpdF9mb3JfZXZlbnQoCisJJ2F1dG92YWN1dW0gd29ya2VyJywKKwknYXV0b3ZhY3V1bS1s ZWFkZXItYmVmb3JlLWluZGV4ZXMtcHJvY2Vzc2luZycKKyk7CisKK215ICRhdl9waWQgPSAkbm9k ZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFxeworCVNFTEVDVCBwaWQgRlJPTSBwZ19zdGF0X2Fj dGl2aXR5CisJV0hFUkUgYmFja2VuZF90eXBlID0gJ2F1dG92YWN1dW0gd29ya2VyJworCSAgQU5E IHdhaXRfZXZlbnQgPSAnYXV0b3ZhY3V1bS1sZWFkZXItYmVmb3JlLWluZGV4ZXMtcHJvY2Vzc2lu ZycKKwlMSU1JVCAxOworfSk7CisKKyMgQ3JlYXRlIHJvbGUgd2l0aCBwZ19zaWduYWxfYXV0b3Zh Y3V1bV93b3JrZXIgZm9yIHRlcm1pbmF0aW5nIGF1dG92YWN1dW0gd29ya2VyLgorJG5vZGUtPnNh ZmVfcHNxbCgncG9zdGdyZXMnLCBxcXsKKwlDUkVBVEUgUk9MRSByZWdyZXNzX3dvcmtlcl9yb2xl OworCUdSQU5UIHBnX3NpZ25hbF9hdXRvdmFjdXVtX3dvcmtlciBUTyByZWdyZXNzX3dvcmtlcl9y b2xlOworCVNFVCBST0xFIHJlZ3Jlc3Nfd29ya2VyX3JvbGU7Cit9KTsKKworJG5vZGUtPnNhZmVf cHNxbCgncG9zdGdyZXMnLCBxcXsKKwlTRUxFQ1QgcGdfdGVybWluYXRlX2JhY2tlbmQoJyRhdl9w aWQnKTsKK30pOworCiskbG9nX3N0YXJ0ID0gJG5vZGUtPndhaXRfZm9yX2xvZygKKwlxci90ZXJt aW5hdGluZyBhdXRvdmFjdXVtIHByb2Nlc3MgZHVlIHRvIGFkbWluaXN0cmF0b3IgY29tbWFuZC8s CisJJGxvZ19zdGFydAorKTsKKworIyBOb3cgaXQgaXMgc2FmZSB0byBjaGVjayB0aGUgbnVtYmVy IG9mIGZyZWUgcGFyYWxsZWwgd29ya2VycywgYmVjYXVzZSBldmVuIGlmCisjIGF1dG92YWN1dW0g aXMgdHJ5aW5nIHRvIHZhY3V1bSB0YWJsZSBpbiBwYXJhbGxlbCBtb2RlIGFnYWluLCB0aGUgbGVh ZGVyCisjIHdvcmtlciBjYW5ub3QgZ28gYW55IGZ1cnRoZXIgdGhhbiAiYXV0b3ZhY3V1bS1zdGFy dC1wYXJhbGxlbC12YWN1dW0iIHBvaW50LgorIyBJLmUuIG5vIG9uZSBjYW4gaW50ZXJmZXJlIGFu ZCBjaGFuZ2UgdGhlIG51bWJlciBvZiBmcmVlIHBhcmFsbGVsIHdvcmtlcnMuCisKKyRwc3FsX291 dCA9ICRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgcXF7CisJU0VMRUNUIGdldF9wYXJhbGxl bF9hdXRvdmFjdXVtX2ZyZWVfd29ya2VycygpOworfSk7CitpcygkcHNxbF9vdXQsIDEwLCAnQWxs IHBhcmFsbGVsIHdvcmtlcnMgaGFzIGJlZW4gcmVsZWFzZWQgYnkgdGhlIGxlYWRlciBhZnRlciBG QVRBTCcpOworCisjIENsZWFudXAKKyRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgcXF7CisJ U0VMRUNUIGluamVjdGlvbl9wb2ludHNfZGV0YWNoKCdhdXRvdmFjdXVtLXN0YXJ0LXBhcmFsbGVs LXZhY3V1bScpOworCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX2RldGFjaCgnYXV0b3ZhY3V1bS1s ZWFkZXItYmVmb3JlLWluZGV4ZXMtcHJvY2Vzc2luZycpOworfSk7CisKKyRub2RlLT5zdG9wOwor ZG9uZV90ZXN0aW5nKCk7CmRpZmYgLS1naXQgYS9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYXV0b3Zh Y3V1bS90ZXN0X2F1dG92YWN1dW0tLTEuMC5zcWwgYi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYXV0 b3ZhY3V1bS90ZXN0X2F1dG92YWN1dW0tLTEuMC5zcWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAuLmU1NjQ2ZTBkZWY1Ci0tLSAvZGV2L251bGwKKysrIGIvc3JjL3Rlc3Qv bW9kdWxlcy90ZXN0X2F1dG92YWN1dW0vdGVzdF9hdXRvdmFjdXVtLS0xLjAuc3FsCkBAIC0wLDAg KzEsMTIgQEAKKy8qIHNyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVtL3Rlc3RfYXV0b3Zh Y3V1bS0tMS4wLnNxbCAqLworCistLSBjb21wbGFpbiBpZiBzY3JpcHQgaXMgc291cmNlZCBpbiBw c3FsLCByYXRoZXIgdGhhbiB2aWEgQ1JFQVRFIEVYVEVOU0lPTgorXGVjaG8gVXNlICJDUkVBVEUg RVhURU5TSU9OIHRlc3RfYXV0b3ZhY3V1bSIgdG8gbG9hZCB0aGlzIGZpbGUuIFxxdWl0CisKKy8q CisgKiBGdW5jdGlvbnMgZm9yIGV4cGVjdGluZyBzaGFyZWQgYXV0b3ZhY3V1bSBzdGF0ZQorICov CisKK0NSRUFURSBGVU5DVElPTiBnZXRfcGFyYWxsZWxfYXV0b3ZhY3V1bV9mcmVlX3dvcmtlcnMo KQorUkVUVVJOUyBJTlRFR0VSIFNUUklDVAorQVMgJ01PRFVMRV9QQVRITkFNRScgTEFOR1VBR0Ug QzsKZGlmZiAtLWdpdCBhL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVtL3Rlc3RfYXV0 b3ZhY3V1bS5jIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2F1dG92YWN1dW0vdGVzdF9hdXRvdmFj dXVtLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLjk1OTYyOWM3Njg1 Ci0tLSAvZGV2L251bGwKKysrIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2F1dG92YWN1dW0vdGVz dF9hdXRvdmFjdXVtLmMKQEAgLTAsMCArMSw0MSBAQAorLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgKgor ICogdGVzdF9hdXRvdmFjdXVtLmMKKyAqCQlIZWxwZXJzIHRvIHdyaXRlIHRlc3RzIGZvciBwYXJh bGxlbCBhdXRvdmFjdXVtCisgKgorICogQ29weXJpZ2h0IChjKSAyMDIwLTIwMjUsIFBvc3RncmVT UUwgR2xvYmFsIERldmVsb3BtZW50IEdyb3VwCisgKgorICogSURFTlRJRklDQVRJT04KKyAqCSAg c3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2F1dG92YWN1dW0vdGVzdF9hdXRvdmFjdXVtLmMKKyAqCisg Ki0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0KKyAqLworCisjaW5jbHVkZSAicG9zdGdyZXMuaCIKKworI2luY2x1 ZGUgImNvbW1hbmRzL3ZhY3V1bS5oIgorI2luY2x1ZGUgImZtZ3IuaCIKKyNpbmNsdWRlICJtaXNj YWRtaW4uaCIKKyNpbmNsdWRlICJwb3N0bWFzdGVyL2F1dG92YWN1dW0uaCIKKyNpbmNsdWRlICJz dG9yYWdlL3NobWVtLmgiCisjaW5jbHVkZSAic3RvcmFnZS9pcGMuaCIKKyNpbmNsdWRlICJzdG9y YWdlL2x3bG9jay5oIgorI2luY2x1ZGUgInV0aWxzL2J1aWx0aW5zLmgiCisjaW5jbHVkZSAidXRp bHMvaW5qZWN0aW9uX3BvaW50LmgiCisKK1BHX01PRFVMRV9NQUdJQzsKKworUEdfRlVOQ1RJT05f SU5GT19WMShnZXRfcGFyYWxsZWxfYXV0b3ZhY3V1bV9mcmVlX3dvcmtlcnMpOworRGF0dW0KK2dl dF9wYXJhbGxlbF9hdXRvdmFjdXVtX2ZyZWVfd29ya2VycyhQR19GVU5DVElPTl9BUkdTKQorewor CXVpbnQzMgkJbmZyZWVfd29ya2VyczsKKworI2lmbmRlZiBVU0VfSU5KRUNUSU9OX1BPSU5UUwor CWVyZXBvcnQoRVJST1IsIGVycm1zZygiaW5qZWN0aW9uIHBvaW50cyBub3Qgc3VwcG9ydGVkIikp OworI2VuZGlmCisKKwluZnJlZV93b3JrZXJzID0gQXV0b1ZhY3V1bUdldEZyZWVQYXJhbGxlbFdv cmtlcnMoKTsKKworCVBHX1JFVFVSTl9VSU5UMzIobmZyZWVfd29ya2Vycyk7Cit9CmRpZmYgLS1n aXQgYS9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYXV0b3ZhY3V1bS90ZXN0X2F1dG92YWN1dW0uY29u dHJvbCBiL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVtL3Rlc3RfYXV0b3ZhY3V1bS5j b250cm9sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi4xYjdmYWQyNThm MAotLS0gL2Rldi9udWxsCisrKyBiL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVtL3Rl c3RfYXV0b3ZhY3V1bS5jb250cm9sCkBAIC0wLDAgKzEsMyBAQAorY29tbWVudCA9ICdUZXN0IGNv ZGUgZm9yIHBhcmFsbGVsIGF1dG92YWN1dW0nCitkZWZhdWx0X3ZlcnNpb24gPSAnMS4wJworbW9k dWxlX3BhdGhuYW1lID0gJyRsaWJkaXIvdGVzdF9hdXRvdmFjdXVtJwotLSAKMi40My4wCgo= --000000000000a87ec3064a7990c4 Content-Type: text/x-patch; charset="US-ASCII"; name="v21-0003-Cost-based-parameters-propagation-for-parallel-a.patch" Content-Disposition: attachment; filename="v21-0003-Cost-based-parameters-propagation-for-parallel-a.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mlgqd2lz2 RnJvbSAyMWNiYmJlMzdlMzZiNTNhYzcwYjk4MjcyOTZhMzQzMGFiYTQ2ODBmIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBUaHUsIDE1IEphbiAyMDI2IDIzOjE1OjQ4ICswNzAwClN1YmplY3Q6IFtQQVRD SCB2MjEgMy81XSBDb3N0IGJhc2VkIHBhcmFtZXRlcnMgcHJvcGFnYXRpb24gZm9yIHBhcmFsbGVs CiBhdXRvdmFjdXVtCgotLS0KIHNyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jICAgICAgICAg fCAgMjMgKysrLQogc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYyB8IDE2NCAr KysrKysrKysrKysrKysrKysrKysrKysrKwogc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFj dXVtLmMgICB8ICAgMiArLQogc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmggICAgICAgICB8 ICAgMiArCiBzcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdCAgICAgIHwgICAyICsKIDUg ZmlsZXMgY2hhbmdlZCwgMTkwIGluc2VydGlvbnMoKyksIDMgZGVsZXRpb25zKC0pCgpkaWZmIC0t Z2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMgYi9zcmMvYmFja2VuZC9jb21tYW5k cy92YWN1dW0uYwppbmRleCAwMzkzMmY0NWM4YS4uNzA4ODI1NDRkMDUgMTAwNjQ0Ci0tLSBhL3Ny Yy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jCisrKyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3Zh Y3V1bS5jCkBAIC0yNDMwLDggKzI0MzAsMjEgQEAgdmFjdXVtX2RlbGF5X3BvaW50KGJvb2wgaXNf YW5hbHl6ZSkKIAkvKiBBbHdheXMgY2hlY2sgZm9yIGludGVycnVwdHMgKi8KIAlDSEVDS19GT1Jf SU5URVJSVVBUUygpOwogCi0JaWYgKEludGVycnVwdFBlbmRpbmcgfHwKLQkJKCFWYWN1dW1Db3N0 QWN0aXZlICYmICFDb25maWdSZWxvYWRQZW5kaW5nKSkKKwlpZiAoSW50ZXJydXB0UGVuZGluZykK KwkJcmV0dXJuOworCisJaWYgKElzUGFyYWxsZWxXb3JrZXIoKSkKKwl7CisJCS8qCisJCSAqIFBv c3NpYmx5IHVwZGF0ZSBjb3N0LWJhc2VkIGRlbGF5IHBhcmFtZXRlcnMuCisJCSAqCisJCSAqIERv IGl0IGJlZm9yZSBjaGVja2luZyBWYWN1dW1Db3N0QWN0aXZlLCBiZWNhdXNlIGl0cyB2YWx1ZSBt aWdodCBiZQorCQkgKiBjaGFuZ2VkIGFmdGVyIGNhbGxpbmcgdGhpcyBmdW5jdGlvbi4KKwkJICov CisJCXBhcmFsbGVsX3ZhY3V1bV91cGRhdGVfc2hhcmVkX2RlbGF5X3BhcmFtcygpOworCX0KKwor CWlmICghVmFjdXVtQ29zdEFjdGl2ZSAmJiAhQ29uZmlnUmVsb2FkUGVuZGluZykKIAkJcmV0dXJu OwogCiAJLyoKQEAgLTI0NDUsNiArMjQ1OCwxMiBAQCB2YWN1dW1fZGVsYXlfcG9pbnQoYm9vbCBp c19hbmFseXplKQogCQlDb25maWdSZWxvYWRQZW5kaW5nID0gZmFsc2U7CiAJCVByb2Nlc3NDb25m aWdGaWxlKFBHQ19TSUdIVVApOwogCQlWYWN1dW1VcGRhdGVDb3N0cygpOworCisJCS8qCisJCSAq IElmIHdlIGFyZSBwYXJhbGxlbCBhdXRvdmFjdXVtIGxlYWRlciBhbmQgc29tZSBvZiBjb3N0LWJh c2VkCisJCSAqIHBhcmFtZXRlcnMgaGFkIGNoYW5nZWQsIGxldCBvdGhlciBwYXJhbGxlbCB3b3Jr ZXJzIGtub3cuCisJCSAqLworCQlwYXJhbGxlbF92YWN1dW1fcHJvcGFnYXRlX3NoYXJlZF9kZWxh eV9wYXJhbXMoKTsKIAl9CiAKIAkvKgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMv dmFjdXVtcGFyYWxsZWwuYyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMK aW5kZXggODZkOWYyYjc0YzkuLmNjYjM4MTIxNjVjIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9j b21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCisrKyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1 bXBhcmFsbGVsLmMKQEAgLTUzLDYgKzUzLDU2IEBACiAjZGVmaW5lIFBBUkFMTEVMX1ZBQ1VVTV9L RVlfV0FMX1VTQUdFCQk0CiAjZGVmaW5lIFBBUkFMTEVMX1ZBQ1VVTV9LRVlfSU5ERVhfU1RBVFMJ CTUKIAorLyoKKyAqIEhlbHBlciBmb3IgdGhlIFBWU2hhcmVkQ29zdFBhcmFtcyBzdHJ1Y3R1cmUg KHNlZSBiZWxvdyksIHRvIGF2b2lkCisgKiByZXBldGl0aW9uLgorICovCit0eXBlZGVmIHN0cnVj dCBDb3N0UGFyYW1zRGF0YQoreworCWRvdWJsZQkJY29zdF9kZWxheTsKKwlpbnQJCQljb3N0X2xp bWl0OworCWludAkJCWNvc3RfcGFnZV9kaXJ0eTsKKwlpbnQJCQljb3N0X3BhZ2VfaGl0OworCWlu dAkJCWNvc3RfcGFnZV9taXNzOworfSBDb3N0UGFyYW1zRGF0YTsKKworI2RlZmluZQlGaWxsQ29z dFBhcmFtc0RhdGEoY29zdF9wYXJhbXMpIFwKKwkoY29zdF9wYXJhbXMpLT5jb3N0X2RlbGF5ID0g dmFjdXVtX2Nvc3RfZGVsYXk7IFwKKwkoY29zdF9wYXJhbXMpLT5jb3N0X2xpbWl0ID0gdmFjdXVt X2Nvc3RfbGltaXQ7IFwKKwkoY29zdF9wYXJhbXMpLT5jb3N0X3BhZ2VfZGlydHkgPSBWYWN1dW1D b3N0UGFnZURpcnR5OyBcCisJKGNvc3RfcGFyYW1zKS0+Y29zdF9wYWdlX2hpdCA9IFZhY3V1bUNv c3RQYWdlSGl0OyBcCisJKGNvc3RfcGFyYW1zKS0+Y29zdF9wYWdlX21pc3MgPSBWYWN1dW1Db3N0 UGFnZU1pc3MKKworI2RlZmluZSBDb3N0UGFyYW1zRGF0YUVxdWFsKHBhcmFtc18xLCBwYXJhbXNf MikgXAorCSgocGFyYW1zXzEpLmNvc3RfZGVsYXkgPT0gKHBhcmFtc18yKS5jb3N0X2RlbGF5ICYm IFwKKwkgKHBhcmFtc18xKS5jb3N0X2xpbWl0ID09IChwYXJhbXNfMikuY29zdF9saW1pdCAmJiBc CisJIChwYXJhbXNfMSkuY29zdF9wYWdlX2RpcnR5ID09IChwYXJhbXNfMikuY29zdF9wYWdlX2Rp cnR5ICYmIFwKKwkgKHBhcmFtc18xKS5jb3N0X3BhZ2VfaGl0ID09IChwYXJhbXNfMikuY29zdF9w YWdlX2hpdCAmJiBcCisJIChwYXJhbXNfMSkuY29zdF9wYWdlX21pc3MgPT0gKHBhcmFtc18yKS5j b3N0X3BhZ2VfbWlzcykKKworLyoKKyAqIFN0cnVjdCBmb3IgY29zdC1iYXNlZCB2YWN1dW0gZGVs YXkgcmVsYXRlZCBwYXJhbWV0ZXJzIHRvIHNoYXJlIGFtb25nIGFuCisgKiBhdXRvdmFjdXVtIHdv cmtlciBhbmQgaXRzIHBhcmFsbGVsIHZhY3V1bSB3b3JrZXJzLgorICovCit0eXBlZGVmIHN0cnVj dCBQVlNoYXJlZENvc3RQYXJhbXMKK3sKKwkvKgorCSAqIEVhY2ggdGltZSBsZWFkZXIgd29ya2Vy IHVwZGF0ZXMgaXRzIHBhcmFtZXRlcnMsIGl0IG11c3QgaW5jcmVhc2UKKwkgKiBnZW5lcmF0aW9u LiBFdmVyeSBwYXJhbGxlbCB3b3JrZXIga2VlcHMgdGhlIGdlbmVyYXRpb24KKwkgKiAoc2hhcmVk X3BhcmFtc19sb2NhbF9nZW5lcmF0aW9uKSBhdCB3aGljaCBpdCBoYWQgbGFzdCB0aW1lIHJlY2Vp dmVkCisJICogcGFyYW1ldGVycyBmcm9tIHRoZSBsZWFkZXIuCisJICoKKwkgKiBJdCBpcyBlbm91 Z2ggZm9yIHdvcmtlciB0byBjb21wYXJlIGl0J3MgbG9jYWxfZ2VuZXJhdGlvbiB3aXRoIHRoZSBm aWVsZAorCSAqIGJlbG93IHRvIGRldGVybWluZSB3aGV0aGVyIGl0IG5lZWRzIHRvIHJlY2VpdmUg bmV3IHBhcmFtZXRlcnMnIHZhbHVlcy4KKwkgKi8KKwlwZ19hdG9taWNfdWludDMyIGdlbmVyYXRp b247CisKKwlzbG9ja190CQltdXRleDsJCQkvKiBwcm90ZWN0cyBhbGwgZmllbGRzIGJlbG93ICov CisKKwkvKiBDb3BpZXMgb2YgY29ycmVzcG9uZGluZyBwYXJhbWV0ZXJzIGZyb20gYXV0b3ZhY3V1 bSBsZWFkZXIgcHJvY2VzcyAqLworCUNvc3RQYXJhbXNEYXRhIHBhcmFtc19kYXRhOworfSBQVlNo YXJlZENvc3RQYXJhbXM7CisKIC8qCiAgKiBTaGFyZWQgaW5mb3JtYXRpb24gYW1vbmcgcGFyYWxs ZWwgd29ya2Vycy4gIFNvIHRoaXMgaXMgYWxsb2NhdGVkIGluIHRoZSBEU00KICAqIHNlZ21lbnQu CkBAIC0xMjIsNiArMTcyLDE4IEBAIHR5cGVkZWYgc3RydWN0IFBWU2hhcmVkCiAKIAkvKiBTdGF0 aXN0aWNzIG9mIHNoYXJlZCBkZWFkIGl0ZW1zICovCiAJVmFjRGVhZEl0ZW1zSW5mbyBkZWFkX2l0 ZW1zX2luZm87CisKKwkvKgorCSAqIElmICd0cnVlJyB0aGVuIHdlIGFyZSBydW5uaW5nIHBhcmFs bGVsIGF1dG92YWN1dW0uIE90aGVyd2lzZSwgd2UgYXJlCisJICogcnVubmluZyBwYXJhbGxlbCBt YWludGVuZW5jZSBWQUNVVU0uCisJICovCisJYm9vbAkJYW1fcGFyYWxsZWxfYXV0b3ZhY3V1bTsK KworCS8qCisJICogU3RydWN0IGZvciBzeW5jaW5nIHBhcmFtZXRlcnMgYmV0d2VlbiBzdXBwb3J0 aXZlIHBhcmFsbGVsIGF1dG92YWN1dW0KKwkgKiB3b3JrZXJzIHdpdGggbGVhZGVyIHdvcmtlci4K KwkgKi8KKwlQVlNoYXJlZENvc3RQYXJhbXMgY29zdF9wYXJhbXM7CiB9IFBWU2hhcmVkOwogCiAv KiBTdGF0dXMgdXNlZCBkdXJpbmcgcGFyYWxsZWwgaW5kZXggdmFjdXVtIG9yIGNsZWFudXAgKi8K QEAgLTIyNCw2ICsyODYsMTEgQEAgc3RydWN0IFBhcmFsbGVsVmFjdXVtU3RhdGUKIAlQVkluZFZh Y1N0YXR1cyBzdGF0dXM7CiB9OwogCitzdGF0aWMgUFZTaGFyZWRDb3N0UGFyYW1zICpwdl9zaGFy ZWRfY29zdF9wYXJhbXMgPSBOVUxMOworCisvKiBTZWUgY29tbWVudHMgZm9yIHRoZSBQVlNoYXJl ZENvc3RQYXJhbXMgc3RydWN0dXJlIGZvciB0aGUgZXhwbGFuYXRpb24uICovCitzdGF0aWMgdWlu dDMyIHNoYXJlZF9wYXJhbXNfZ2VuZXJhdGlvbl9sb2NhbCA9IDA7CisKIHN0YXRpYyBpbnQJcGFy YWxsZWxfdmFjdXVtX2NvbXB1dGVfd29ya2VycyhSZWxhdGlvbiAqaW5kcmVscywgaW50IG5pbmRl eGVzLCBpbnQgbnJlcXVlc3RlZCwKIAkJCQkJCQkJCQkJYm9vbCAqd2lsbF9wYXJhbGxlbF92YWN1 dW0pOwogc3RhdGljIHZvaWQgcGFyYWxsZWxfdmFjdXVtX3Byb2Nlc3NfYWxsX2luZGV4ZXMoUGFy YWxsZWxWYWN1dW1TdGF0ZSAqcHZzLCBpbnQgbnVtX2luZGV4X3NjYW5zLApAQCAtMzk1LDYgKzQ2 MiwxNyBAQCBwYXJhbGxlbF92YWN1dW1faW5pdChSZWxhdGlvbiByZWwsIFJlbGF0aW9uICppbmRy ZWxzLCBpbnQgbmluZGV4ZXMsCiAJcGdfYXRvbWljX2luaXRfdTMyKCYoc2hhcmVkLT5hY3RpdmVf bndvcmtlcnMpLCAwKTsKIAlwZ19hdG9taWNfaW5pdF91MzIoJihzaGFyZWQtPmlkeCksIDApOwog CisJc2hhcmVkLT5hbV9wYXJhbGxlbF9hdXRvdmFjdXVtID0gQW1BdXRvVmFjdXVtV29ya2VyUHJv Y2VzcygpOworCisJaWYgKHNoYXJlZC0+YW1fcGFyYWxsZWxfYXV0b3ZhY3V1bSkKKwl7CisJCUZp bGxDb3N0UGFyYW1zRGF0YSgmc2hhcmVkLT5jb3N0X3BhcmFtcy5wYXJhbXNfZGF0YSk7CisJCXBn X2F0b21pY19pbml0X3UzMigmc2hhcmVkLT5jb3N0X3BhcmFtcy5nZW5lcmF0aW9uLCAwKTsKKwkJ U3BpbkxvY2tJbml0KCZzaGFyZWQtPmNvc3RfcGFyYW1zLm11dGV4KTsKKworCQlwdl9zaGFyZWRf Y29zdF9wYXJhbXMgPSAmKHNoYXJlZC0+Y29zdF9wYXJhbXMpOworCX0KKwogCXNobV90b2NfaW5z ZXJ0KHBjeHQtPnRvYywgUEFSQUxMRUxfVkFDVVVNX0tFWV9TSEFSRUQsIHNoYXJlZCk7CiAJcHZz LT5zaGFyZWQgPSBzaGFyZWQ7CiAKQEAgLTUzOSw2ICs2MTcsODkgQEAgcGFyYWxsZWxfdmFjdXVt X2NsZWFudXBfYWxsX2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLCBsb25nIG51bV90 YWJsZV90dXAKIAkJCQkJCQkJCQkmd3VzYWdlLT5jbGVhbnVwKTsKIH0KIAorLyoKKyAqIElmIHdl IGFyZSBwYXJhbGxlbCAqYXV0b3ZhY3V1bSogd29ya2VyLCBjaGVjayB3aGV0aGVyIHJlbGF0ZWQg dG8KKyAqIGNvc3QtYmFzZWQgZGVsYXkgcGFyYW1ldGVycyBoYWQgY2hhbmdlZCBpbiB0aGUgbGVh ZGVyIHdvcmtlci4gSWYKKyAqIHNvLCBjb3JyZXNwb25kaW5nIHBhcmFtZXRlcnMgd2lsbCBiZSB1 cGRhdGVkIHRvIHRoZSB2YWx1ZXMgd2hpY2gKKyAqIGxlYWRlciB3b3JrZXIgaXMgb3BlcmF0aW5n IG9uLgorICoKKyAqIEZvciBub24tYXV0b3ZhY3V1bSBwYXJhbGxlbCB3b3JrZXIgdGhpcyBmdW5j dGlvbiB3aWxsIGhhdmUgbm8gZWZmZWN0LgorICovCit2b2lkCitwYXJhbGxlbF92YWN1dW1fdXBk YXRlX3NoYXJlZF9kZWxheV9wYXJhbXModm9pZCkKK3sKKwl1aW50MzIJCXBhcmFtc19nZW5lcmF0 aW9uOworCUNvc3RQYXJhbXNEYXRhIHNoYXJlZF9wYXJhbXNfZGF0YTsKKworCUFzc2VydChJc1Bh cmFsbGVsV29ya2VyKCkpOworCisJLyogQ2hlY2sgd2hldGhlciB3ZSBhcmUgcnVubmluZyBwYXJh bGxlbCBhdXRvdmFjdXVtICovCisJaWYgKHB2X3NoYXJlZF9jb3N0X3BhcmFtcyA9PSBOVUxMKQor CQlyZXR1cm47CisKKwlwYXJhbXNfZ2VuZXJhdGlvbiA9IHBnX2F0b21pY19yZWFkX3UzMigmcHZf c2hhcmVkX2Nvc3RfcGFyYW1zLT5nZW5lcmF0aW9uKTsKKwlBc3NlcnQoc2hhcmVkX3BhcmFtc19n ZW5lcmF0aW9uX2xvY2FsIDw9IHBhcmFtc19nZW5lcmF0aW9uKTsKKworCS8qIFJldHVybiBpZiBw YXJhbWV0ZXJzIGhhZCBub3QgY2hhbmdlZCBpbiB0aGUgbGVhZGVyICovCisJaWYgKHBhcmFtc19n ZW5lcmF0aW9uID09IHNoYXJlZF9wYXJhbXNfZ2VuZXJhdGlvbl9sb2NhbCkKKwkJcmV0dXJuOwor CisJU3BpbkxvY2tBY3F1aXJlKCZwdl9zaGFyZWRfY29zdF9wYXJhbXMtPm11dGV4KTsKKworCXNo YXJlZF9wYXJhbXNfZGF0YSA9IHB2X3NoYXJlZF9jb3N0X3BhcmFtcy0+cGFyYW1zX2RhdGE7CisK KwlWYWN1dW1Db3N0RGVsYXkgPSBzaGFyZWRfcGFyYW1zX2RhdGEuY29zdF9kZWxheTsKKwlWYWN1 dW1Db3N0TGltaXQgPSBzaGFyZWRfcGFyYW1zX2RhdGEuY29zdF9saW1pdDsKKwlWYWN1dW1Db3N0 UGFnZURpcnR5ID0gc2hhcmVkX3BhcmFtc19kYXRhLmNvc3RfcGFnZV9kaXJ0eTsKKwlWYWN1dW1D b3N0UGFnZUhpdCA9IHNoYXJlZF9wYXJhbXNfZGF0YS5jb3N0X3BhZ2VfaGl0OworCVZhY3V1bUNv c3RQYWdlTWlzcyA9IHNoYXJlZF9wYXJhbXNfZGF0YS5jb3N0X3BhZ2VfbWlzczsKKworCVNwaW5M b2NrUmVsZWFzZSgmcHZfc2hhcmVkX2Nvc3RfcGFyYW1zLT5tdXRleCk7CisKKwlWYWN1dW1VcGRh dGVDb3N0cygpOworCisJc2hhcmVkX3BhcmFtc19nZW5lcmF0aW9uX2xvY2FsID0gcGFyYW1zX2dl bmVyYXRpb247Cit9CisKKy8qCisgKiBGdW5jdGlvbiB0byBiZSBjYWxsZWQgZnJvbSBwYXJhbGxl bCBhdXRvdmFjdXVtIGxlYWRlciBpbiBvcmRlciB0byBwcm9wYWdhdGUKKyAqIHNvbWUgY29zdC1i YXNlZCBwYXJhbWV0ZXJzIHRvIHRoZSBzdXBwb3J0aXZlIHdvcmtlcnMuCisgKi8KK3ZvaWQKK3Bh cmFsbGVsX3ZhY3V1bV9wcm9wYWdhdGVfc2hhcmVkX2RlbGF5X3BhcmFtcyh2b2lkKQoreworCUNv c3RQYXJhbXNEYXRhIGxvY2FsX3BhcmFtc19kYXRhOworCisJQXNzZXJ0KEFtQXV0b1ZhY3V1bVdv cmtlclByb2Nlc3MoKSk7CisKKwkvKiBDaGVjayB3aGV0aGVyIHdlIGFyZSBydW5uaW5nIHBhcmFs bGVsIGF1dG92YWN1dW0gKi8KKwlpZiAocHZfc2hhcmVkX2Nvc3RfcGFyYW1zID09IE5VTEwpCisJ CXJldHVybjsKKworCUZpbGxDb3N0UGFyYW1zRGF0YSgmbG9jYWxfcGFyYW1zX2RhdGEpOworCVNw aW5Mb2NrQWNxdWlyZSgmcHZfc2hhcmVkX2Nvc3RfcGFyYW1zLT5tdXRleCk7CisKKwlpZiAoQ29z dFBhcmFtc0RhdGFFcXVhbChwdl9zaGFyZWRfY29zdF9wYXJhbXMtPnBhcmFtc19kYXRhLAorCQkJ CQkJCWxvY2FsX3BhcmFtc19kYXRhKSkKKwl7CisJCS8qCisJCSAqIFdlIGRvbid0IG5lZWQgdG8g dXBkYXRlIHNoYXJlZCBkZWxheSBwYXJhbXMgaWYgdGhleSBoYXZlbid0CisJCSAqIGNoYW5nZWQu CisJCSAqLworCQlTcGluTG9ja1JlbGVhc2UoJnB2X3NoYXJlZF9jb3N0X3BhcmFtcy0+bXV0ZXgp OworCQlyZXR1cm47CisJfQorCisJRmlsbENvc3RQYXJhbXNEYXRhKCZwdl9zaGFyZWRfY29zdF9w YXJhbXMtPnBhcmFtc19kYXRhKTsKKwlTcGluTG9ja1JlbGVhc2UoJnB2X3NoYXJlZF9jb3N0X3Bh cmFtcy0+bXV0ZXgpOworCisJLyoKKwkgKiBJbmNyZWFzZSBnZW5lcmF0aW9uIG9mIHRoZSBwYXJh bWV0ZXJzLCBpLmUuIGxldCBwYXJhbGxlbCB3b3JrZXJzIGtub3cKKwkgKiB0aGF0IHRoZXkgc2hv dWxkIHJlLXJlYWQgc2hhcmVkIGNvc3QgcGFyYW1zLgorCSAqLworCXBnX2F0b21pY19mZXRjaF9h ZGRfdTMyKCZwdl9zaGFyZWRfY29zdF9wYXJhbXMtPmdlbmVyYXRpb24sIDEpOworfQorCiAvKgog ICogQ29tcHV0ZSB0aGUgbnVtYmVyIG9mIHBhcmFsbGVsIHdvcmtlciBwcm9jZXNzZXMgdG8gcmVx dWVzdC4gIEJvdGggaW5kZXgKICAqIHZhY3V1bSBhbmQgaW5kZXggY2xlYW51cCBjYW4gYmUgZXhl Y3V0ZWQgd2l0aCBwYXJhbGxlbCB3b3JrZXJzLgpAQCAtMTEwNSw2ICsxMjY2LDkgQEAgcGFyYWxs ZWxfdmFjdXVtX21haW4oZHNtX3NlZ21lbnQgKnNlZywgc2htX3RvYyAqdG9jKQogCVZhY3V1bVNo YXJlZENvc3RCYWxhbmNlID0gJihzaGFyZWQtPmNvc3RfYmFsYW5jZSk7CiAJVmFjdXVtQWN0aXZl TldvcmtlcnMgPSAmKHNoYXJlZC0+YWN0aXZlX253b3JrZXJzKTsKIAorCWlmIChzaGFyZWQtPmFt X3BhcmFsbGVsX2F1dG92YWN1dW0pCisJCXB2X3NoYXJlZF9jb3N0X3BhcmFtcyA9ICYoc2hhcmVk LT5jb3N0X3BhcmFtcyk7CisKIAkvKiBTZXQgcGFyYWxsZWwgdmFjdXVtIHN0YXRlICovCiAJcHZz LmluZHJlbHMgPSBpbmRyZWxzOwogCXB2cy5uaW5kZXhlcyA9IG5pbmRleGVzOwpkaWZmIC0tZ2l0 IGEvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMgYi9zcmMvYmFja2VuZC9wb3N0 bWFzdGVyL2F1dG92YWN1dW0uYwppbmRleCBmNDBhYmU5MGVkNS4uMGQ3OGQwMmJkMDkgMTAwNjQ0 Ci0tLSBhL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCisrKyBiL3NyYy9iYWNr ZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1bS5jCkBAIC0xNjkwLDcgKzE2OTAsNyBAQCBWYWN1dW1V cGRhdGVDb3N0cyh2b2lkKQogCX0KIAllbHNlCiAJewotCQkvKiBNdXN0IGJlIGV4cGxpY2l0IFZB Q1VVTSBvciBBTkFMWVpFICovCisJCS8qIE11c3QgYmUgZXhwbGljaXQgVkFDVVVNIG9yIEFOQUxZ WkUgb3IgcGFyYWxsZWwgYXV0b3ZhY3V1bSB3b3JrZXIgKi8KIAkJdmFjdXVtX2Nvc3RfZGVsYXkg PSBWYWN1dW1Db3N0RGVsYXk7CiAJCXZhY3V1bV9jb3N0X2xpbWl0ID0gVmFjdXVtQ29zdExpbWl0 OwogCX0KZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL2NvbW1hbmRzL3ZhY3V1bS5oIGIvc3JjL2lu Y2x1ZGUvY29tbWFuZHMvdmFjdXVtLmgKaW5kZXggZDNkYzRlOGNjNjcuLmIxMDgyOWE5Mzc5IDEw MDY0NAotLS0gYS9zcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0uaAorKysgYi9zcmMvaW5jbHVk ZS9jb21tYW5kcy92YWN1dW0uaApAQCAtNDIzLDYgKzQyMyw4IEBAIGV4dGVybiB2b2lkIHBhcmFs bGVsX3ZhY3V1bV9jbGVhbnVwX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywK IAkJCQkJCQkJCQkJCWludCBudW1faW5kZXhfc2NhbnMsCiAJCQkJCQkJCQkJCQlib29sIGVzdGlt YXRlZF9jb3VudCwKIAkJCQkJCQkJCQkJCVBWV29ya2Vyc1VzYWdlICp3dXNhZ2UpOworZXh0ZXJu IHZvaWQgcGFyYWxsZWxfdmFjdXVtX3VwZGF0ZV9zaGFyZWRfZGVsYXlfcGFyYW1zKHZvaWQpOwor ZXh0ZXJuIHZvaWQgcGFyYWxsZWxfdmFjdXVtX3Byb3BhZ2F0ZV9zaGFyZWRfZGVsYXlfcGFyYW1z KHZvaWQpOwogZXh0ZXJuIHZvaWQgcGFyYWxsZWxfdmFjdXVtX21haW4oZHNtX3NlZ21lbnQgKnNl Zywgc2htX3RvYyAqdG9jKTsKIAogLyogaW4gY29tbWFuZHMvYW5hbHl6ZS5jICovCmRpZmYgLS1n aXQgYS9zcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdCBiL3NyYy90b29scy9wZ2luZGVu dC90eXBlZGVmcy5saXN0CmluZGV4IGQ4NDMwOGM4N2FkLi5kMDBiNTdkMzE4NiAxMDA2NDQKLS0t IGEvc3JjL3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZzLmxpc3QKKysrIGIvc3JjL3Rvb2xzL3BnaW5k ZW50L3R5cGVkZWZzLmxpc3QKQEAgLTU0NCw2ICs1NDQsNyBAQCBDb3B5VG9Sb3V0aW5lCiBDb3B5 VG9TdGF0ZQogQ29weVRvU3RhdGVEYXRhCiBDb3N0CitDb3N0UGFyYW1zRGF0YQogQ29zdFNlbGVj dG9yCiBDb3VudGVycwogQ292ZXJFeHQKQEAgLTIwNjcsNiArMjA2OCw3IEBAIFBWSW5kU3RhdHMK IFBWSW5kVmFjU3RhdHVzCiBQVk9JRAogUFZTaGFyZWQKK1BWU2hhcmVkQ29zdFBhcmFtcwogUFZX b3JrZXJzVXNhZ2UKIFBWV29ya2Vyc1N0YXRzCiBQWF9BbGlhcwotLSAKMi40My4wCgo= --000000000000a87ec3064a7990c4 Content-Type: text/x-patch; charset="US-ASCII"; name="v20--v21-diff-for-0003.patch" Content-Disposition: attachment; filename="v20--v21-diff-for-0003.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mlgqdspi6 RnJvbSA1ZTJiNDcwZGIxMDI1NDZjMzEyNGRhMWVlZjhhY2M0MmQ1YzJmZWFkIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBTYXQsIDcgRmViIDIwMjYgMTE6MDc6NDQgKzA3MDAKU3ViamVjdDogW1BBVENI IDUvN10gZml4ZXMgZm9yIHBhdGNoIDMKCi0tLQogc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVt LmMgICAgICAgICB8ICAxNCArLS0KIHNyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVs LmMgfCAxMjAgKysrKysrKysrKysrKysrKy0tLS0tLS0tLS0KIHNyYy9pbmNsdWRlL2NvbW1hbmRz L3ZhY3V1bS5oICAgICAgICAgfCAgIDIgKy0KIHNyYy90b29scy9wZ2luZGVudC90eXBlZGVmcy5s aXN0ICAgICAgfCAgIDIgKwogNCBmaWxlcyBjaGFuZ2VkLCA4MiBpbnNlcnRpb25zKCspLCA1NiBk ZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW0uYyBi L3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bS5jCmluZGV4IDk4NDdlZDFjMmRhLi43MDg4MjU0 NGQwNSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMKKysrIGIvc3Jj L2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtLmMKQEAgLTI0MzMsMTkgKzI0MzMsMTMgQEAgdmFjdXVt X2RlbGF5X3BvaW50KGJvb2wgaXNfYW5hbHl6ZSkKIAlpZiAoSW50ZXJydXB0UGVuZGluZykKIAkJ cmV0dXJuOwogCi0JaWYgKCFBbUF1dG9WYWN1dW1Xb3JrZXJQcm9jZXNzKCkgJiYgSXNQYXJhbGxl bFdvcmtlcigpKQorCWlmIChJc1BhcmFsbGVsV29ya2VyKCkpCiAJewogCQkvKgotCQkgKiBJZiB3 ZSBhcmUgcGFyYWxsZWwgKmF1dG92YWN1dW0qIHdvcmtlciwgY2hlY2sgd2hldGhlciByZWxhdGVk IHRvCi0JCSAqIGNvc3QtYmFzZWQgZGVsYXkgcGFyYW1ldGVycyBoYWQgY2hhbmdlZCBpbiB0aGUg bGVhZGVyIHdvcmtlci4gSWYKLQkJICogc28sIGNvcnJlc3BvbmRpbmcgcGFyYW1ldGVycyB3aWxs IGJlIHVwZGF0ZWQgdG8gdGhlIHZhbHVlcyB3aGljaAotCQkgKiBsZWFkZXIgd29ya2VyIGlzIG9w ZXJhdGluZyBvbi4KKwkJICogUG9zc2libHkgdXBkYXRlIGNvc3QtYmFzZWQgZGVsYXkgcGFyYW1l dGVycy4KIAkJICoKIAkJICogRG8gaXQgYmVmb3JlIGNoZWNraW5nIFZhY3V1bUNvc3RBY3RpdmUs IGJlY2F1c2UgaXRzIHZhbHVlIG1pZ2h0IGJlCi0JCSAqIGNoYW5nZWQgYWZ0ZXIgbGVhZGVyJ3Mg cGFyYW1ldGVycyBjb25zdW1wdGlvbi4KLQkJICoKLQkJICogTm90ZSwgdGhhdCB0aGlzIGZ1bmN0 aW9uIGhhcyBubyBlZmZlY3QgaWYgd2UgYXJlIG5vbi1hdXRvdmFjdXVtCi0JCSAqIHBhcmFsbGVs IHdvcmtlci4KKwkJICogY2hhbmdlZCBhZnRlciBjYWxsaW5nIHRoaXMgZnVuY3Rpb24uCiAJCSAq LwogCQlwYXJhbGxlbF92YWN1dW1fdXBkYXRlX3NoYXJlZF9kZWxheV9wYXJhbXMoKTsKIAl9CkBA IC0yNDY5LDcgKzI0NjMsNyBAQCB2YWN1dW1fZGVsYXlfcG9pbnQoYm9vbCBpc19hbmFseXplKQog CQkgKiBJZiB3ZSBhcmUgcGFyYWxsZWwgYXV0b3ZhY3V1bSBsZWFkZXIgYW5kIHNvbWUgb2YgY29z dC1iYXNlZAogCQkgKiBwYXJhbWV0ZXJzIGhhZCBjaGFuZ2VkLCBsZXQgb3RoZXIgcGFyYWxsZWwg d29ya2VycyBrbm93LgogCQkgKi8KLQkJcGFyYWxsZWxfdmFjdXVtX3Byb3BhZ2F0ZV9jb3N0X2Jh c2VkX3BhcmFtcygpOworCQlwYXJhbGxlbF92YWN1dW1fcHJvcGFnYXRlX3NoYXJlZF9kZWxheV9w YXJhbXMoKTsKIAl9CiAKIAkvKgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFj dXVtcGFyYWxsZWwuYyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMKaW5k ZXggNjQwMTczZWFkYTguLmNjYjM4MTIxNjVjIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9jb21t YW5kcy92YWN1dW1wYXJhbGxlbC5jCisrKyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBh cmFsbGVsLmMKQEAgLTU0LDkgKzU0LDM1IEBACiAjZGVmaW5lIFBBUkFMTEVMX1ZBQ1VVTV9LRVlf SU5ERVhfU1RBVFMJCTUKIAogLyoKLSAqIE9ubHkgYXV0b3ZhY3V1bSBsZWFkZXIgY2FuIHJlbG9h ZCBjb25maWcgZmlsZS4gV2UgdXNlIHRoaXMgc3RydWN0dXJlIGluCi0gKiBwYXJhbGxlbCBhdXRv dmFjdXVtIGZvciBrZWVwaW5nIHdvcmtlcidzIHBhcmFtZXRlcnMgaW4gc3luYyB3aXRoIGxlYWRl cidzCi0gKiBwYXJhbWV0ZXJzLgorICogSGVscGVyIGZvciB0aGUgUFZTaGFyZWRDb3N0UGFyYW1z IHN0cnVjdHVyZSAoc2VlIGJlbG93KSwgdG8gYXZvaWQKKyAqIHJlcGV0aXRpb24uCisgKi8KK3R5 cGVkZWYgc3RydWN0IENvc3RQYXJhbXNEYXRhCit7CisJZG91YmxlCQljb3N0X2RlbGF5OworCWlu dAkJCWNvc3RfbGltaXQ7CisJaW50CQkJY29zdF9wYWdlX2RpcnR5OworCWludAkJCWNvc3RfcGFn ZV9oaXQ7CisJaW50CQkJY29zdF9wYWdlX21pc3M7Cit9IENvc3RQYXJhbXNEYXRhOworCisjZGVm aW5lCUZpbGxDb3N0UGFyYW1zRGF0YShjb3N0X3BhcmFtcykgXAorCShjb3N0X3BhcmFtcyktPmNv c3RfZGVsYXkgPSB2YWN1dW1fY29zdF9kZWxheTsgXAorCShjb3N0X3BhcmFtcyktPmNvc3RfbGlt aXQgPSB2YWN1dW1fY29zdF9saW1pdDsgXAorCShjb3N0X3BhcmFtcyktPmNvc3RfcGFnZV9kaXJ0 eSA9IFZhY3V1bUNvc3RQYWdlRGlydHk7IFwKKwkoY29zdF9wYXJhbXMpLT5jb3N0X3BhZ2VfaGl0 ID0gVmFjdXVtQ29zdFBhZ2VIaXQ7IFwKKwkoY29zdF9wYXJhbXMpLT5jb3N0X3BhZ2VfbWlzcyA9 IFZhY3V1bUNvc3RQYWdlTWlzcworCisjZGVmaW5lIENvc3RQYXJhbXNEYXRhRXF1YWwocGFyYW1z XzEsIHBhcmFtc18yKSBcCisJKChwYXJhbXNfMSkuY29zdF9kZWxheSA9PSAocGFyYW1zXzIpLmNv c3RfZGVsYXkgJiYgXAorCSAocGFyYW1zXzEpLmNvc3RfbGltaXQgPT0gKHBhcmFtc18yKS5jb3N0 X2xpbWl0ICYmIFwKKwkgKHBhcmFtc18xKS5jb3N0X3BhZ2VfZGlydHkgPT0gKHBhcmFtc18yKS5j b3N0X3BhZ2VfZGlydHkgJiYgXAorCSAocGFyYW1zXzEpLmNvc3RfcGFnZV9oaXQgPT0gKHBhcmFt c18yKS5jb3N0X3BhZ2VfaGl0ICYmIFwKKwkgKHBhcmFtc18xKS5jb3N0X3BhZ2VfbWlzcyA9PSAo cGFyYW1zXzIpLmNvc3RfcGFnZV9taXNzKQorCisvKgorICogU3RydWN0IGZvciBjb3N0LWJhc2Vk IHZhY3V1bSBkZWxheSByZWxhdGVkIHBhcmFtZXRlcnMgdG8gc2hhcmUgYW1vbmcgYW4KKyAqIGF1 dG92YWN1dW0gd29ya2VyIGFuZCBpdHMgcGFyYWxsZWwgdmFjdXVtIHdvcmtlcnMuCiAgKi8KIHR5 cGVkZWYgc3RydWN0IFBWU2hhcmVkQ29zdFBhcmFtcwogewpAQCAtNzEsMjAgKzk3LDExIEBAIHR5 cGVkZWYgc3RydWN0IFBWU2hhcmVkQ29zdFBhcmFtcwogCSAqLwogCXBnX2F0b21pY191aW50MzIg Z2VuZXJhdGlvbjsKIAotCXNsb2NrX3QJCXNwaW5sb2NrOwkJLyogcHJvdGVjdHMgYWxsIGZpZWxk cyBiZWxvdyAqLworCXNsb2NrX3QJCW11dGV4OwkJCS8qIHByb3RlY3RzIGFsbCBmaWVsZHMgYmVs b3cgKi8KIAogCS8qIENvcGllcyBvZiBjb3JyZXNwb25kaW5nIHBhcmFtZXRlcnMgZnJvbSBhdXRv dmFjdXVtIGxlYWRlciBwcm9jZXNzICovCi0JZG91YmxlCQljb3N0X2RlbGF5OwotCWludAkJCWNv c3RfbGltaXQ7Ci0JaW50CQkJY29zdF9wYWdlX2RpcnR5OwotCWludAkJCWNvc3RfcGFnZV9oaXQ7 Ci0JaW50CQkJY29zdF9wYWdlX21pc3M7Ci19CQkJUFZTaGFyZWRDb3N0UGFyYW1zOwotCi1zdGF0 aWMgUFZTaGFyZWRDb3N0UGFyYW1zICogcHZfc2hhcmVkX2Nvc3RfcGFyYW1zID0gTlVMTDsKLQot LyogU2VlIGNvbW1lbnRzIGZvciBzdHJ1Y3R1cmUgYWJvdmUgZm9yIHRoZSBleHBsYW5hdGlvbi4g Ki8KLXN0YXRpYyB1aW50MzIgc2hhcmVkX3BhcmFtc19nZW5lcmF0aW9uX2xvY2FsID0gMDsKKwlD b3N0UGFyYW1zRGF0YSBwYXJhbXNfZGF0YTsKK30gUFZTaGFyZWRDb3N0UGFyYW1zOwogCiAvKgog ICogU2hhcmVkIGluZm9ybWF0aW9uIGFtb25nIHBhcmFsbGVsIHdvcmtlcnMuICBTbyB0aGlzIGlz IGFsbG9jYXRlZCBpbiB0aGUgRFNNCkBAIC0yNjksNiArMjg2LDExIEBAIHN0cnVjdCBQYXJhbGxl bFZhY3V1bVN0YXRlCiAJUFZJbmRWYWNTdGF0dXMgc3RhdHVzOwogfTsKIAorc3RhdGljIFBWU2hh cmVkQ29zdFBhcmFtcyAqcHZfc2hhcmVkX2Nvc3RfcGFyYW1zID0gTlVMTDsKKworLyogU2VlIGNv bW1lbnRzIGZvciB0aGUgUFZTaGFyZWRDb3N0UGFyYW1zIHN0cnVjdHVyZSBmb3IgdGhlIGV4cGxh bmF0aW9uLiAqLworc3RhdGljIHVpbnQzMiBzaGFyZWRfcGFyYW1zX2dlbmVyYXRpb25fbG9jYWwg PSAwOworCiBzdGF0aWMgaW50CXBhcmFsbGVsX3ZhY3V1bV9jb21wdXRlX3dvcmtlcnMoUmVsYXRp b24gKmluZHJlbHMsIGludCBuaW5kZXhlcywgaW50IG5yZXF1ZXN0ZWQsCiAJCQkJCQkJCQkJCWJv b2wgKndpbGxfcGFyYWxsZWxfdmFjdXVtKTsKIHN0YXRpYyB2b2lkIHBhcmFsbGVsX3ZhY3V1bV9w cm9jZXNzX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywgaW50IG51bV9pbmRl eF9zY2FucywKQEAgLTQ0NCwxMyArNDY2LDEwIEBAIHBhcmFsbGVsX3ZhY3V1bV9pbml0KFJlbGF0 aW9uIHJlbCwgUmVsYXRpb24gKmluZHJlbHMsIGludCBuaW5kZXhlcywKIAogCWlmIChzaGFyZWQt PmFtX3BhcmFsbGVsX2F1dG92YWN1dW0pCiAJewotCQlzaGFyZWQtPmNvc3RfcGFyYW1zLmNvc3Rf ZGVsYXkgPSB2YWN1dW1fY29zdF9kZWxheTsKLQkJc2hhcmVkLT5jb3N0X3BhcmFtcy5jb3N0X2xp bWl0ID0gdmFjdXVtX2Nvc3RfbGltaXQ7Ci0JCXNoYXJlZC0+Y29zdF9wYXJhbXMuY29zdF9wYWdl X2RpcnR5ID0gVmFjdXVtQ29zdFBhZ2VEaXJ0eTsKLQkJc2hhcmVkLT5jb3N0X3BhcmFtcy5jb3N0 X3BhZ2VfaGl0ID0gVmFjdXVtQ29zdFBhZ2VIaXQ7Ci0JCXNoYXJlZC0+Y29zdF9wYXJhbXMuY29z dF9wYWdlX21pc3MgPSBWYWN1dW1Db3N0UGFnZU1pc3M7CisJCUZpbGxDb3N0UGFyYW1zRGF0YSgm c2hhcmVkLT5jb3N0X3BhcmFtcy5wYXJhbXNfZGF0YSk7CiAJCXBnX2F0b21pY19pbml0X3UzMigm c2hhcmVkLT5jb3N0X3BhcmFtcy5nZW5lcmF0aW9uLCAwKTsKLQkJU3BpbkxvY2tJbml0KCZzaGFy ZWQtPmNvc3RfcGFyYW1zLnNwaW5sb2NrKTsKKwkJU3BpbkxvY2tJbml0KCZzaGFyZWQtPmNvc3Rf cGFyYW1zLm11dGV4KTsKKwogCQlwdl9zaGFyZWRfY29zdF9wYXJhbXMgPSAmKHNoYXJlZC0+Y29z dF9wYXJhbXMpOwogCX0KIApAQCAtNTk5LDEzICs2MTgsMTggQEAgcGFyYWxsZWxfdmFjdXVtX2Ns ZWFudXBfYWxsX2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLCBsb25nIG51bV90YWJs ZV90dXAKIH0KIAogLyoKLSAqIEZ1bmN0aW9uIHRvIGJlIGNhbGxlZCBmcm9tIHBhcmFsbGVsIGF1 dG92YWN1dW0gd29ya2VyIGluIG9yZGVyIHRvIHN5bmMKLSAqIHNvbWUgY29zdC1iYXNlZCBkZWxh eSBwYXJhbWV0ZXIgd2l0aCB0aGUgbGVhZGVyIHdvcmtlci4KKyAqIElmIHdlIGFyZSBwYXJhbGxl bCAqYXV0b3ZhY3V1bSogd29ya2VyLCBjaGVjayB3aGV0aGVyIHJlbGF0ZWQgdG8KKyAqIGNvc3Qt YmFzZWQgZGVsYXkgcGFyYW1ldGVycyBoYWQgY2hhbmdlZCBpbiB0aGUgbGVhZGVyIHdvcmtlci4g SWYKKyAqIHNvLCBjb3JyZXNwb25kaW5nIHBhcmFtZXRlcnMgd2lsbCBiZSB1cGRhdGVkIHRvIHRo ZSB2YWx1ZXMgd2hpY2gKKyAqIGxlYWRlciB3b3JrZXIgaXMgb3BlcmF0aW5nIG9uLgorICoKKyAq IEZvciBub24tYXV0b3ZhY3V1bSBwYXJhbGxlbCB3b3JrZXIgdGhpcyBmdW5jdGlvbiB3aWxsIGhh dmUgbm8gZWZmZWN0LgogICovCiB2b2lkCiBwYXJhbGxlbF92YWN1dW1fdXBkYXRlX3NoYXJlZF9k ZWxheV9wYXJhbXModm9pZCkKIHsKLQl1aW50MzIJcGFyYW1zX2dlbmVyYXRpb247CisJdWludDMy CQlwYXJhbXNfZ2VuZXJhdGlvbjsKKwlDb3N0UGFyYW1zRGF0YSBzaGFyZWRfcGFyYW1zX2RhdGE7 CiAKIAlBc3NlcnQoSXNQYXJhbGxlbFdvcmtlcigpKTsKIApAQCAtNjEzLDIyICs2MzcsMjQgQEAg cGFyYWxsZWxfdmFjdXVtX3VwZGF0ZV9zaGFyZWRfZGVsYXlfcGFyYW1zKHZvaWQpCiAJaWYgKHB2 X3NoYXJlZF9jb3N0X3BhcmFtcyA9PSBOVUxMKQogCQlyZXR1cm47CiAKLQlwYXJhbXNfZ2VuZXJh dGlvbiA9CXBnX2F0b21pY19yZWFkX3UzMigmcHZfc2hhcmVkX2Nvc3RfcGFyYW1zLT5nZW5lcmF0 aW9uKTsKKwlwYXJhbXNfZ2VuZXJhdGlvbiA9IHBnX2F0b21pY19yZWFkX3UzMigmcHZfc2hhcmVk X2Nvc3RfcGFyYW1zLT5nZW5lcmF0aW9uKTsKIAlBc3NlcnQoc2hhcmVkX3BhcmFtc19nZW5lcmF0 aW9uX2xvY2FsIDw9IHBhcmFtc19nZW5lcmF0aW9uKTsKIAogCS8qIFJldHVybiBpZiBwYXJhbWV0 ZXJzIGhhZCBub3QgY2hhbmdlZCBpbiB0aGUgbGVhZGVyICovCiAJaWYgKHBhcmFtc19nZW5lcmF0 aW9uID09IHNoYXJlZF9wYXJhbXNfZ2VuZXJhdGlvbl9sb2NhbCkKIAkJcmV0dXJuOwogCi0JU3Bp bkxvY2tBY3F1aXJlKCZwdl9zaGFyZWRfY29zdF9wYXJhbXMtPnNwaW5sb2NrKTsKKwlTcGluTG9j a0FjcXVpcmUoJnB2X3NoYXJlZF9jb3N0X3BhcmFtcy0+bXV0ZXgpOwogCi0JVmFjdXVtQ29zdERl bGF5ID0gcHZfc2hhcmVkX2Nvc3RfcGFyYW1zLT5jb3N0X2RlbGF5OwotCVZhY3V1bUNvc3RMaW1p dCA9IHB2X3NoYXJlZF9jb3N0X3BhcmFtcy0+Y29zdF9saW1pdDsKLQlWYWN1dW1Db3N0UGFnZURp cnR5ID0gcHZfc2hhcmVkX2Nvc3RfcGFyYW1zLT5jb3N0X3BhZ2VfZGlydHk7Ci0JVmFjdXVtQ29z dFBhZ2VIaXQgPSBwdl9zaGFyZWRfY29zdF9wYXJhbXMtPmNvc3RfcGFnZV9oaXQ7Ci0JVmFjdXVt Q29zdFBhZ2VNaXNzID0gcHZfc2hhcmVkX2Nvc3RfcGFyYW1zLT5jb3N0X3BhZ2VfbWlzczsKKwlz aGFyZWRfcGFyYW1zX2RhdGEgPSBwdl9zaGFyZWRfY29zdF9wYXJhbXMtPnBhcmFtc19kYXRhOwog Ci0JU3BpbkxvY2tSZWxlYXNlKCZwdl9zaGFyZWRfY29zdF9wYXJhbXMtPnNwaW5sb2NrKTsKKwlW YWN1dW1Db3N0RGVsYXkgPSBzaGFyZWRfcGFyYW1zX2RhdGEuY29zdF9kZWxheTsKKwlWYWN1dW1D b3N0TGltaXQgPSBzaGFyZWRfcGFyYW1zX2RhdGEuY29zdF9saW1pdDsKKwlWYWN1dW1Db3N0UGFn ZURpcnR5ID0gc2hhcmVkX3BhcmFtc19kYXRhLmNvc3RfcGFnZV9kaXJ0eTsKKwlWYWN1dW1Db3N0 UGFnZUhpdCA9IHNoYXJlZF9wYXJhbXNfZGF0YS5jb3N0X3BhZ2VfaGl0OworCVZhY3V1bUNvc3RQ YWdlTWlzcyA9IHNoYXJlZF9wYXJhbXNfZGF0YS5jb3N0X3BhZ2VfbWlzczsKKworCVNwaW5Mb2Nr UmVsZWFzZSgmcHZfc2hhcmVkX2Nvc3RfcGFyYW1zLT5tdXRleCk7CiAKIAlWYWN1dW1VcGRhdGVD b3N0cygpOwogCkBAIC02NDAsOSArNjY2LDkgQEAgcGFyYWxsZWxfdmFjdXVtX3VwZGF0ZV9zaGFy ZWRfZGVsYXlfcGFyYW1zKHZvaWQpCiAgKiBzb21lIGNvc3QtYmFzZWQgcGFyYW1ldGVycyB0byB0 aGUgc3VwcG9ydGl2ZSB3b3JrZXJzLgogICovCiB2b2lkCi1wYXJhbGxlbF92YWN1dW1fcHJvcGFn YXRlX2Nvc3RfYmFzZWRfcGFyYW1zKHZvaWQpCitwYXJhbGxlbF92YWN1dW1fcHJvcGFnYXRlX3No YXJlZF9kZWxheV9wYXJhbXModm9pZCkKIHsKLQl1aW50MzIJcGFyYW1zX2dlbmVyYXRpb247CisJ Q29zdFBhcmFtc0RhdGEgbG9jYWxfcGFyYW1zX2RhdGE7CiAKIAlBc3NlcnQoQW1BdXRvVmFjdXVt V29ya2VyUHJvY2VzcygpKTsKIApAQCAtNjUwLDI0ICs2NzYsMjggQEAgcGFyYWxsZWxfdmFjdXVt X3Byb3BhZ2F0ZV9jb3N0X2Jhc2VkX3BhcmFtcyh2b2lkKQogCWlmIChwdl9zaGFyZWRfY29zdF9w YXJhbXMgPT0gTlVMTCkKIAkJcmV0dXJuOwogCi0JcGFyYW1zX2dlbmVyYXRpb24gPQlwZ19hdG9t aWNfcmVhZF91MzIoJnB2X3NoYXJlZF9jb3N0X3BhcmFtcy0+Z2VuZXJhdGlvbik7CisJRmlsbENv c3RQYXJhbXNEYXRhKCZsb2NhbF9wYXJhbXNfZGF0YSk7CisJU3BpbkxvY2tBY3F1aXJlKCZwdl9z aGFyZWRfY29zdF9wYXJhbXMtPm11dGV4KTsKIAotCVNwaW5Mb2NrQWNxdWlyZSgmcHZfc2hhcmVk X2Nvc3RfcGFyYW1zLT5zcGlubG9jayk7CisJaWYgKENvc3RQYXJhbXNEYXRhRXF1YWwocHZfc2hh cmVkX2Nvc3RfcGFyYW1zLT5wYXJhbXNfZGF0YSwKKwkJCQkJCQlsb2NhbF9wYXJhbXNfZGF0YSkp CisJeworCQkvKgorCQkgKiBXZSBkb24ndCBuZWVkIHRvIHVwZGF0ZSBzaGFyZWQgZGVsYXkgcGFy YW1zIGlmIHRoZXkgaGF2ZW4ndAorCQkgKiBjaGFuZ2VkLgorCQkgKi8KKwkJU3BpbkxvY2tSZWxl YXNlKCZwdl9zaGFyZWRfY29zdF9wYXJhbXMtPm11dGV4KTsKKwkJcmV0dXJuOworCX0KIAotCXB2 X3NoYXJlZF9jb3N0X3BhcmFtcy0+Y29zdF9kZWxheSA9IHZhY3V1bV9jb3N0X2RlbGF5OwotCXB2 X3NoYXJlZF9jb3N0X3BhcmFtcy0+Y29zdF9saW1pdCA9IHZhY3V1bV9jb3N0X2xpbWl0OwotCXB2 X3NoYXJlZF9jb3N0X3BhcmFtcy0+Y29zdF9wYWdlX2RpcnR5ID0gVmFjdXVtQ29zdFBhZ2VEaXJ0 eTsKLQlwdl9zaGFyZWRfY29zdF9wYXJhbXMtPmNvc3RfcGFnZV9oaXQgPSBWYWN1dW1Db3N0UGFn ZUhpdDsKLQlwdl9zaGFyZWRfY29zdF9wYXJhbXMtPmNvc3RfcGFnZV9taXNzID0gVmFjdXVtQ29z dFBhZ2VNaXNzOworCUZpbGxDb3N0UGFyYW1zRGF0YSgmcHZfc2hhcmVkX2Nvc3RfcGFyYW1zLT5w YXJhbXNfZGF0YSk7CisJU3BpbkxvY2tSZWxlYXNlKCZwdl9zaGFyZWRfY29zdF9wYXJhbXMtPm11 dGV4KTsKIAogCS8qCiAJICogSW5jcmVhc2UgZ2VuZXJhdGlvbiBvZiB0aGUgcGFyYW1ldGVycywg aS5lLiBsZXQgcGFyYWxsZWwgd29ya2VycyBrbm93CiAJICogdGhhdCB0aGV5IHNob3VsZCByZS1y ZWFkIHNoYXJlZCBjb3N0IHBhcmFtcy4KIAkgKi8KLQlwZ19hdG9taWNfd3JpdGVfdTMyKCZwdl9z aGFyZWRfY29zdF9wYXJhbXMtPmdlbmVyYXRpb24sCi0JCQkJCQlwYXJhbXNfZ2VuZXJhdGlvbiAr IDEpOwotCi0JU3BpbkxvY2tSZWxlYXNlKCZwdl9zaGFyZWRfY29zdF9wYXJhbXMtPnNwaW5sb2Nr KTsKKwlwZ19hdG9taWNfZmV0Y2hfYWRkX3UzMigmcHZfc2hhcmVkX2Nvc3RfcGFyYW1zLT5nZW5l cmF0aW9uLCAxKTsKIH0KIAogLyoKZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL2NvbW1hbmRzL3Zh Y3V1bS5oIGIvc3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmgKaW5kZXggYmQ2N2U3NzQ4ZjAu LmIxMDgyOWE5Mzc5IDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0uaAor KysgYi9zcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0uaApAQCAtNDI0LDcgKzQyNCw3IEBAIGV4 dGVybiB2b2lkIHBhcmFsbGVsX3ZhY3V1bV9jbGVhbnVwX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFj dXVtU3RhdGUgKnB2cywKIAkJCQkJCQkJCQkJCWJvb2wgZXN0aW1hdGVkX2NvdW50LAogCQkJCQkJ CQkJCQkJUFZXb3JrZXJzVXNhZ2UgKnd1c2FnZSk7CiBleHRlcm4gdm9pZCBwYXJhbGxlbF92YWN1 dW1fdXBkYXRlX3NoYXJlZF9kZWxheV9wYXJhbXModm9pZCk7Ci1leHRlcm4gdm9pZCBwYXJhbGxl bF92YWN1dW1fcHJvcGFnYXRlX2Nvc3RfYmFzZWRfcGFyYW1zKHZvaWQpOworZXh0ZXJuIHZvaWQg cGFyYWxsZWxfdmFjdXVtX3Byb3BhZ2F0ZV9zaGFyZWRfZGVsYXlfcGFyYW1zKHZvaWQpOwogZXh0 ZXJuIHZvaWQgcGFyYWxsZWxfdmFjdXVtX21haW4oZHNtX3NlZ21lbnQgKnNlZywgc2htX3RvYyAq dG9jKTsKIAogLyogaW4gY29tbWFuZHMvYW5hbHl6ZS5jICovCmRpZmYgLS1naXQgYS9zcmMvdG9v bHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdCBiL3NyYy90b29scy9wZ2luZGVudC90eXBlZGVmcy5s aXN0CmluZGV4IDg0YmZhMjk3MGRlLi4yOGI5MWQ2OTA4NiAxMDA2NDQKLS0tIGEvc3JjL3Rvb2xz L3BnaW5kZW50L3R5cGVkZWZzLmxpc3QKKysrIGIvc3JjL3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZz Lmxpc3QKQEAgLTU0NCw2ICs1NDQsNyBAQCBDb3B5VG9Sb3V0aW5lCiBDb3B5VG9TdGF0ZQogQ29w eVRvU3RhdGVEYXRhCiBDb3N0CitDb3N0UGFyYW1zRGF0YQogQ29zdFNlbGVjdG9yCiBDb3VudGVy cwogQ292ZXJFeHQKQEAgLTIwNjYsNiArMjA2Nyw3IEBAIFBWSW5kU3RhdHMKIFBWSW5kVmFjU3Rh dHVzCiBQVk9JRAogUFZTaGFyZWQKK1BWU2hhcmVkQ29zdFBhcmFtcwogUFZXb3JrZXJzVXNhZ2UK IFBWV29ya2Vyc1N0YXRzCiBQWF9BbGlhcwotLSAKMi40My4wCgo= --000000000000a87ec3064a7990c4 Content-Type: text/x-patch; charset="US-ASCII"; name="v20--v21-diff-for-0001.patch" Content-Disposition: attachment; filename="v20--v21-diff-for-0001.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mlgqdsqh8 RnJvbSBjYjZmNjZmOTQ0ZGJiNDhhMzFjOTA4MjNkZDIzYTZhNWQ2MzEzMjUwIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBTYXQsIDcgRmViIDIwMjYgMDA6MDQ6MTcgKzA3MDAKU3ViamVjdDogW1BBVENI IDEvN10gZml4ZXMgZm9yIHBhdGNoIDEKCi0tLQogc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVt cGFyYWxsZWwuYyAgICAgICAgIHwgIDUgKysrKy0KIHNyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0 b3ZhY3V1bS5jICAgICAgICAgICB8IDE4ICsrKysrLS0tLS0tLS0tLS0tLQogc3JjL2JhY2tlbmQv dXRpbHMvbWlzYy9wb3N0Z3Jlc3FsLmNvbmYuc2FtcGxlIHwgIDIgKy0KIDMgZmlsZXMgY2hhbmdl ZCwgMTAgaW5zZXJ0aW9ucygrKSwgMTUgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2Jh Y2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3Zh Y3V1bXBhcmFsbGVsLmMKaW5kZXggMWUzNWI4MmFlYWYuLmQzZTBjMzJiN2VlIDEwMDY0NAotLS0g YS9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCisrKyBiL3NyYy9iYWNrZW5k L2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMKQEAgLTcxMCw4ICs3MTAsMTEgQEAgcGFyYWxsZWxf dmFjdXVtX3Byb2Nlc3NfYWxsX2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLCBpbnQg bnVtX2luZGV4X3NjYW4KIAkJICogVGVsbCBhdXRvdmFjdXVtIHRoYXQgd2UgY291bGQgbm90IGxh dW5jaCBhbGwgdGhlIHByZXZpb3VzbHkKIAkJICogcmVzZXJ2ZWQgd29ya2Vycy4KIAkJICovCi0J CWlmIChBbUF1dG9WYWN1dW1Xb3JrZXJQcm9jZXNzKCkgJiYgcHZzLT5wY3h0LT5ud29ya2Vyc19s YXVuY2hlZCA8IG53b3JrZXJzKQorCQlpZiAoQW1BdXRvVmFjdXVtV29ya2VyUHJvY2VzcygpICYm CisJCQlwdnMtPnBjeHQtPm53b3JrZXJzX2xhdW5jaGVkIDwgbndvcmtlcnMpCisJCXsKIAkJCUF1 dG9WYWN1dW1SZWxlYXNlUGFyYWxsZWxXb3JrZXJzKG53b3JrZXJzIC0gcHZzLT5wY3h0LT5ud29y a2Vyc19sYXVuY2hlZCk7CisJCX0KIAogCQlpZiAocHZzLT5wY3h0LT5ud29ya2Vyc19sYXVuY2hl ZCA+IDApCiAJCXsKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvYXV0b3ZhY3V1 bS5jIGIvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMKaW5kZXggNzg0YzExNzhk NjEuLmY0MGFiZTkwZWQ1IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92 YWN1dW0uYworKysgYi9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0uYwpAQCAtMzUy Niw3ICszNTI2LDcgQEAgQXV0b1ZhY3V1bVNobWVtSW5pdCh2b2lkKQogCiAJCUF1dG9WYWN1dW1T aG1lbS0+YXZfbGF1bmNoZXJwaWQgPSAwOwogCQlBdXRvVmFjdXVtU2htZW0tPmF2X21heFBhcmFs bGVsV29ya2VycyA9Ci0JCQlNaW4oYXV0b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2VycywgbWF4 X3dvcmtlcl9wcm9jZXNzZXMpOworCQkJTWluKGF1dG92YWN1dW1fbWF4X3BhcmFsbGVsX3dvcmtl cnMsIG1heF9wYXJhbGxlbF93b3JrZXJzKTsKIAkJQXV0b1ZhY3V1bVNobWVtLT5hdl9mcmVlUGFy YWxsZWxXb3JrZXJzID0KIAkJCUF1dG9WYWN1dW1TaG1lbS0+YXZfbWF4UGFyYWxsZWxXb3JrZXJz OwogCQlkY2xpc3RfaW5pdCgmQXV0b1ZhY3V1bVNobWVtLT5hdl9mcmVlV29ya2Vycyk7CkBAIC0z NjIyLDIzICszNjIyLDE1IEBAIGFkanVzdF9mcmVlX3BhcmFsbGVsX3dvcmtlcnMoaW50IHByZXZf bWF4X3BhcmFsbGVsX3dvcmtlcnMpCiAKIAlMV0xvY2tBY3F1aXJlKEF1dG92YWN1dW1Mb2NrLCBM V19FWENMVVNJVkUpOwogCi0JbmZyZWVfd29ya2VycyA9Ci0JCWF1dG92YWN1dW1fbWF4X3BhcmFs bGVsX3dvcmtlcnMgLSBwcmV2X21heF9wYXJhbGxlbF93b3JrZXJzICsKLQkJQXV0b1ZhY3V1bVNo bWVtLT5hdl9mcmVlUGFyYWxsZWxXb3JrZXJzOwotCiAJLyoKIAkgKiBDYXAgb3IgaW5jcmVhc2Ug bnVtYmVyIG9mIGZyZWUgcGFyYWxsZWwgd29ya2VycyBhY2NvcmRpbmcgdG8gdGhlCiAJICogcGFy YW1ldGVyIGNoYW5nZS4KIAkgKi8KLQlBdXRvVmFjdXVtU2htZW0tPmF2X2ZyZWVQYXJhbGxlbFdv cmtlcnMgPSBNYXgobmZyZWVfd29ya2VycywgMCk7Ci0KLQkvKgotCSAqIERvbid0IGFsbG93IG51 bWJlciBvZiBmcmVlIHdvcmtlcnMgdG8gYmVjb21lIGxlc3MgdGhhbiB6ZXJvIGlmIHRoZQotCSAq IHBhdGFtZXRlciB3YXMgZGVjcmVhc2VkLgotCSAqLwotCUF1dG9WYWN1dW1TaG1lbS0+YXZfZnJl ZVBhcmFsbGVsV29ya2VycyA9Ci0JCU1heChBdXRvVmFjdXVtU2htZW0tPmF2X2ZyZWVQYXJhbGxl bFdvcmtlcnMsIDApOworCW5mcmVlX3dvcmtlcnMgPQorCQlhdXRvdmFjdXVtX21heF9wYXJhbGxl bF93b3JrZXJzIC0gcHJldl9tYXhfcGFyYWxsZWxfd29ya2VycyArCisJCUF1dG9WYWN1dW1TaG1l bS0+YXZfZnJlZVBhcmFsbGVsV29ya2VyczsKIAorCUF1dG9WYWN1dW1TaG1lbS0+YXZfZnJlZVBh cmFsbGVsV29ya2VycyA9IE1heChuZnJlZV93b3JrZXJzLCAwKTsKIAlBdXRvVmFjdXVtU2htZW0t PmF2X21heFBhcmFsbGVsV29ya2VycyA9IGF1dG92YWN1dW1fbWF4X3BhcmFsbGVsX3dvcmtlcnM7 CiAKIAlMV0xvY2tSZWxlYXNlKEF1dG92YWN1dW1Mb2NrKTsKZGlmZiAtLWdpdCBhL3NyYy9iYWNr ZW5kL3V0aWxzL21pc2MvcG9zdGdyZXNxbC5jb25mLnNhbXBsZSBiL3NyYy9iYWNrZW5kL3V0aWxz L21pc2MvcG9zdGdyZXNxbC5jb25mLnNhbXBsZQppbmRleCAzNWMzN2YyMTIzOS4uZTQ1NmZkNzU5 ZWIgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvcG9zdGdyZXNxbC5jb25mLnNh bXBsZQorKysgYi9zcmMvYmFja2VuZC91dGlscy9taXNjL3Bvc3RncmVzcWwuY29uZi5zYW1wbGUK QEAgLTY5NSw3ICs2OTUsNyBAQAogI2F1dG92YWN1dW1fd29ya2VyX3Nsb3RzID0gMTYgICAgICAg ICAgICMgYXV0b3ZhY3V1bSB3b3JrZXIgc2xvdHMgdG8gYWxsb2NhdGUKICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAjIChjaGFuZ2UgcmVxdWlyZXMgcmVzdGFydCkKICNh dXRvdmFjdXVtX21heF93b3JrZXJzID0gMyAgICAgICAgICAgICAjIG1heCBudW1iZXIgb2YgYXV0 b3ZhY3V1bSBzdWJwcm9jZXNzZXMKLSNhdXRvdmFjdXVtX21heF9wYXJhbGxlbF93b3JrZXJzID0g MiAgICAjIGxpbWl0ZWQgYnkgbWF4X3dvcmtlcl9wcm9jZXNzZXMKKyNhdXRvdmFjdXVtX21heF9w YXJhbGxlbF93b3JrZXJzID0gMiAgICAjIGxpbWl0ZWQgYnkgbWF4X3BhcmFsbGVsX3dvcmtlcnMK ICNhdXRvdmFjdXVtX25hcHRpbWUgPSAxbWluICAgICAgICAgICAgICAjIHRpbWUgYmV0d2VlbiBh dXRvdmFjdXVtIHJ1bnMKICNhdXRvdmFjdXVtX3ZhY3V1bV90aHJlc2hvbGQgPSA1MCAgICAgICAj IG1pbiBudW1iZXIgb2Ygcm93IHVwZGF0ZXMgYmVmb3JlCiAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIyB2YWN1dW0KLS0gCjIuNDMuMAoK --000000000000a87ec3064a7990c4 Content-Type: text/x-patch; charset="US-ASCII"; name="v20--v21-diff-for-0002.patch" Content-Disposition: attachment; filename="v20--v21-diff-for-0002.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mlgqdspz7 RnJvbSBiN2EwMjI2NjQ2ZWUzMDY0MDBjYTUwYzU0MDRmM2YwMmIwYzdmZGEwIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBTYXQsIDcgRmViIDIwMjYgMDA6MTE6NDkgKzA3MDAKU3ViamVjdDogW1BBVENI IDMvN10gZml4ZXMgZm9yIHBhdGNoIDIKCi0tLQogc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvdmFj dXVtbGF6eS5jICB8IDYwICsrKysrKysrKysrKysrKysrKysrLS0tLS0tLQogc3JjL2JhY2tlbmQv Y29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYyB8IDIyICsrKysrLS0tLS0KIHNyYy9pbmNsdWRlL2Nv bW1hbmRzL3ZhY3V1bS5oICAgICAgICAgfCAxNSArKysrKy0tCiBzcmMvdG9vbHMvcGdpbmRlbnQv dHlwZWRlZnMubGlzdCAgICAgIHwgIDIgKwogNCBmaWxlcyBjaGFuZ2VkLCA3MCBpbnNlcnRpb25z KCspLCAyOSBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVh cC92YWN1dW1sYXp5LmMgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMKaW5k ZXggZDE0ZjA1NWI0MGQuLmQxOWUxNWNiY2NlIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nl c3MvaGVhcC92YWN1dW1sYXp5LmMKKysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvdmFjdXVt bGF6eS5jCkBAIC03ODQsOCArNzg0LDEwIEBAIGhlYXBfdmFjdXVtX3JlbChSZWxhdGlvbiByZWws IGNvbnN0IFZhY3V1bVBhcmFtcyBwYXJhbXMsCiAJdmFjcmVsLT52bV9uZXdfdmlzaWJsZV9mcm96 ZW5fcGFnZXMgPSAwOwogCXZhY3JlbC0+dm1fbmV3X2Zyb3plbl9wYWdlcyA9IDA7CiAKLQl2YWNy ZWwtPndvcmtlcnNfdXNhZ2UubmxhdW5jaGVkID0gMDsKLQl2YWNyZWwtPndvcmtlcnNfdXNhZ2Uu bnBsYW5uZWQgPSAwOworCXZhY3JlbC0+d29ya2Vyc191c2FnZS52YWN1dW0ubmxhdW5jaGVkID0g MDsKKwl2YWNyZWwtPndvcmtlcnNfdXNhZ2UudmFjdXVtLm5wbGFubmVkID0gMDsKKwl2YWNyZWwt PndvcmtlcnNfdXNhZ2UuY2xlYW51cC5ubGF1bmNoZWQgPSAwOworCXZhY3JlbC0+d29ya2Vyc191 c2FnZS5jbGVhbnVwLm5wbGFubmVkID0gMDsKIAogCS8qCiAJICogR2V0IGN1dG9mZnMgdGhhdCBk ZXRlcm1pbmUgd2hpY2ggZGVsZXRlZCB0dXBsZXMgYXJlIGNvbnNpZGVyZWQgREVBRCwKQEAgLTEx MjksMjMgKzExMzEsNDkgQEAgaGVhcF92YWN1dW1fcmVsKFJlbGF0aW9uIHJlbCwgY29uc3QgVmFj dXVtUGFyYW1zIHBhcmFtcywKIAkJCQkJCQkgb3JpZ19yZWxfcGFnZXMgPT0gMCA/IDEwMC4wIDoK IAkJCQkJCQkgMTAwLjAgKiB2YWNyZWwtPmxwZGVhZF9pdGVtX3BhZ2VzIC8gb3JpZ19yZWxfcGFn ZXMsCiAJCQkJCQkJIHZhY3JlbC0+bHBkZWFkX2l0ZW1zKTsKLQkJCWlmICh2YWNyZWwtPndvcmtl cnNfdXNhZ2UubnBsYW5uZWQgPiAwICYmCi0JCQkJQW1BdXRvVmFjdXVtV29ya2VyUHJvY2Vzcygp KQorCQkJaWYgKHZhY3JlbC0+d29ya2Vyc191c2FnZS52YWN1dW0ubnBsYW5uZWQgPiAwKQogCQkJ ewotCQkJCS8qIFdvcmtlciB1c2FnZSBzdGF0cyBmb3IgcGFyYWxsZWwgYXV0b3ZhY3V1bSAqLwot CQkJCWFwcGVuZFN0cmluZ0luZm8oJmJ1ZiwKLQkJCQkJCQkJIF8oInBhcmFsbGVsIGluZGV4IHZh Y3V1bS9jbGVhbnVwOiAlZCB3b3JrZXJzIHdlcmUgcGxhbm5lZCwgJWQgd29ya2VycyB3ZXJlIHJl c2VydmVkIGFuZCAlZCB3b3JrZXJzIHdlcmUgbGF1bmNoZWQgaW4gdG90YWxcbiIpLAotCQkJCQkJ CQkgdmFjcmVsLT53b3JrZXJzX3VzYWdlLm5wbGFubmVkLAotCQkJCQkJCQkgdmFjcmVsLT53b3Jr ZXJzX3VzYWdlLm5yZXNlcnZlZCwKLQkJCQkJCQkJIHZhY3JlbC0+d29ya2Vyc191c2FnZS5ubGF1 bmNoZWQpOworCQkJCS8qIFN0YXRzIGZvciB2YWN1dW0gcGhhc2Ugb2YgaW5kZXggdmFjdXVtaW5n LiAqLworCisJCQkJaWYgKEFtQXV0b1ZhY3V1bVdvcmtlclByb2Nlc3MoKSkKKwkJCQl7CisJCQkJ CS8qIFdvcmtlciB1c2FnZSBzdGF0cyBmb3IgcGFyYWxsZWwgYXV0b3ZhY3V1bS4gKi8KKwkJCQkJ YXBwZW5kU3RyaW5nSW5mbygmYnVmLAorCQkJCQkJCQkJIF8oInBhcmFsbGVsIGluZGV4IHZhY3V1 bTogJWQgd29ya2VycyB3ZXJlIHBsYW5uZWQsICVkIHdvcmtlcnMgd2VyZSByZXNlcnZlZCBhbmQg JWQgd29ya2VycyB3ZXJlIGxhdW5jaGVkIGluIHRvdGFsXG4iKSwKKwkJCQkJCQkJCSB2YWNyZWwt PndvcmtlcnNfdXNhZ2UudmFjdXVtLm5wbGFubmVkLAorCQkJCQkJCQkJIHZhY3JlbC0+d29ya2Vy c191c2FnZS52YWN1dW0ubnJlc2VydmVkLAorCQkJCQkJCQkJIHZhY3JlbC0+d29ya2Vyc191c2Fn ZS52YWN1dW0ubmxhdW5jaGVkKTsKKwkJCQl9CisJCQkJZWxzZQorCQkJCXsKKwkJCQkJLyogV29y a2VyIHVzYWdlIHN0YXRzIGZvciBtYW51YWwgVkFDVVVNIChQQVJBTExFTCkuICovCisJCQkJCWFw cGVuZFN0cmluZ0luZm8oJmJ1ZiwKKwkJCQkJCQkJCSBfKCJwYXJhbGxlbCBpbmRleCB2YWN1dW06 ICVkIHdvcmtlcnMgd2VyZSBwbGFubmVkIGFuZCAlZCB3b3JrZXJzIHdlcmUgbGF1bmNoZWQgaW4g dG90YWxcbiIpLAorCQkJCQkJCQkJIHZhY3JlbC0+d29ya2Vyc191c2FnZS52YWN1dW0ubnBsYW5u ZWQsCisJCQkJCQkJCQkgdmFjcmVsLT53b3JrZXJzX3VzYWdlLnZhY3V1bS5ubGF1bmNoZWQpOwor CQkJCX0KIAkJCX0KLQkJCWVsc2UgaWYgKHZhY3JlbC0+d29ya2Vyc191c2FnZS5ucGxhbm5lZCA+ IDApCisJCQlpZiAodmFjcmVsLT53b3JrZXJzX3VzYWdlLmNsZWFudXAubnBsYW5uZWQgPiAwKQog CQkJewotCQkJCS8qIFdvcmtlciB1c2FnZSBzdGF0cyBmb3IgbWFudWFsIFZBQ1VVTSAoUEFSQUxM RUwpICovCi0JCQkJYXBwZW5kU3RyaW5nSW5mbygmYnVmLAotCQkJCQkJCQkgXygicGFyYWxsZWwg aW5kZXggdmFjdXVtL2NsZWFudXA6ICVkIHdvcmtlcnMgd2VyZSBwbGFubmVkIGFuZCAlZCB3b3Jr ZXJzIHdlcmUgbGF1bmNoZWQgaW4gdG90YWxcbiIpLAotCQkJCQkJCQkgdmFjcmVsLT53b3JrZXJz X3VzYWdlLm5wbGFubmVkLAotCQkJCQkJCQkgdmFjcmVsLT53b3JrZXJzX3VzYWdlLm5sYXVuY2hl ZCk7CisJCQkJLyogU3RhdHMgZm9yIGNsZWFudXAgcGhhc2Ugb2YgaW5kZXggdmFjdXVtaW5nLiAq LworCisJCQkJaWYgKEFtQXV0b1ZhY3V1bVdvcmtlclByb2Nlc3MoKSkKKwkJCQl7CisJCQkJCS8q IFdvcmtlciB1c2FnZSBzdGF0cyBmb3IgcGFyYWxsZWwgYXV0b3ZhY3V1bS4gKi8KKwkJCQkJYXBw ZW5kU3RyaW5nSW5mbygmYnVmLAorCQkJCQkJCQkJIF8oInBhcmFsbGVsIGluZGV4IGNsZWFudXA6 ICVkIHdvcmtlcnMgd2VyZSBwbGFubmVkLCAlZCB3b3JrZXJzIHdlcmUgcmVzZXJ2ZWQgYW5kICVk IHdvcmtlcnMgd2VyZSBsYXVuY2hlZCBpbiB0b3RhbFxuIiksCisJCQkJCQkJCQkgdmFjcmVsLT53 b3JrZXJzX3VzYWdlLmNsZWFudXAubnBsYW5uZWQsCisJCQkJCQkJCQkgdmFjcmVsLT53b3JrZXJz X3VzYWdlLmNsZWFudXAubnJlc2VydmVkLAorCQkJCQkJCQkJIHZhY3JlbC0+d29ya2Vyc191c2Fn ZS5jbGVhbnVwLm5sYXVuY2hlZCk7CisJCQkJfQorCQkJCWVsc2UKKwkJCQl7CisJCQkJCS8qIFdv cmtlciB1c2FnZSBzdGF0cyBmb3IgbWFudWFsIFZBQ1VVTSAoUEFSQUxMRUwpLiAqLworCQkJCQlh cHBlbmRTdHJpbmdJbmZvKCZidWYsCisJCQkJCQkJCQkgXygicGFyYWxsZWwgaW5kZXggY2xlYW51 cDogJWQgd29ya2VycyB3ZXJlIHBsYW5uZWQgYW5kICVkIHdvcmtlcnMgd2VyZSBsYXVuY2hlZCBp biB0b3RhbFxuIiksCisJCQkJCQkJCQkgdmFjcmVsLT53b3JrZXJzX3VzYWdlLmNsZWFudXAubnBs YW5uZWQsCisJCQkJCQkJCQkgdmFjcmVsLT53b3JrZXJzX3VzYWdlLmNsZWFudXAubmxhdW5jaGVk KTsKKwkJCQl9CiAJCQl9CiAJCQlmb3IgKGludCBpID0gMDsgaSA8IHZhY3JlbC0+bmluZGV4ZXM7 IGkrKykKIAkJCXsKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFs bGVsLmMgYi9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCmluZGV4IGVhNDVk YzNmYzM3Li44NmQ5ZjJiNzRjOSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFj dXVtcGFyYWxsZWwuYworKysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5j CkBAIC0yMjcsNyArMjI3LDcgQEAgc3RydWN0IFBhcmFsbGVsVmFjdXVtU3RhdGUKIHN0YXRpYyBp bnQJcGFyYWxsZWxfdmFjdXVtX2NvbXB1dGVfd29ya2VycyhSZWxhdGlvbiAqaW5kcmVscywgaW50 IG5pbmRleGVzLCBpbnQgbnJlcXVlc3RlZCwKIAkJCQkJCQkJCQkJYm9vbCAqd2lsbF9wYXJhbGxl bF92YWN1dW0pOwogc3RhdGljIHZvaWQgcGFyYWxsZWxfdmFjdXVtX3Byb2Nlc3NfYWxsX2luZGV4 ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLCBpbnQgbnVtX2luZGV4X3NjYW5zLAotCQkJCQkJ CQkJCQkJYm9vbCB2YWN1dW0sIFBWV29ya2Vyc1VzYWdlICp3dXNhZ2UpOworCQkJCQkJCQkJCQkJ Ym9vbCB2YWN1dW0sIFBWV29ya2Vyc1N0YXRzICp3c3RhdHMpOwogc3RhdGljIHZvaWQgcGFyYWxs ZWxfdmFjdXVtX3Byb2Nlc3Nfc2FmZV9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cyk7 CiBzdGF0aWMgdm9pZCBwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc191bnNhZmVfaW5kZXhlcyhQYXJh bGxlbFZhY3V1bVN0YXRlICpwdnMpOwogc3RhdGljIHZvaWQgcGFyYWxsZWxfdmFjdXVtX3Byb2Nl c3Nfb25lX2luZGV4KFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywgUmVsYXRpb24gaW5kcmVsLApA QCAtNTEzLDcgKzUxMyw4IEBAIHBhcmFsbGVsX3ZhY3V1bV9idWxrZGVsX2FsbF9pbmRleGVzKFBh cmFsbGVsVmFjdXVtU3RhdGUgKnB2cywgbG9uZyBudW1fdGFibGVfdHVwCiAJcHZzLT5zaGFyZWQt PnJlbHR1cGxlcyA9IG51bV90YWJsZV90dXBsZXM7CiAJcHZzLT5zaGFyZWQtPmVzdGltYXRlZF9j b3VudCA9IHRydWU7CiAKLQlwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19hbGxfaW5kZXhlcyhwdnMs IG51bV9pbmRleF9zY2FucywgdHJ1ZSwgd3VzYWdlKTsKKwlwYXJhbGxlbF92YWN1dW1fcHJvY2Vz c19hbGxfaW5kZXhlcyhwdnMsIG51bV9pbmRleF9zY2FucywgdHJ1ZSwKKwkJCQkJCQkJCQkmd3Vz YWdlLT52YWN1dW0pOwogfQogCiAvKgpAQCAtNTM0LDcgKzUzNSw4IEBAIHBhcmFsbGVsX3ZhY3V1 bV9jbGVhbnVwX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywgbG9uZyBudW1f dGFibGVfdHVwCiAJcHZzLT5zaGFyZWQtPnJlbHR1cGxlcyA9IG51bV90YWJsZV90dXBsZXM7CiAJ cHZzLT5zaGFyZWQtPmVzdGltYXRlZF9jb3VudCA9IGVzdGltYXRlZF9jb3VudDsKIAotCXBhcmFs bGVsX3ZhY3V1bV9wcm9jZXNzX2FsbF9pbmRleGVzKHB2cywgbnVtX2luZGV4X3NjYW5zLCBmYWxz ZSwgd3VzYWdlKTsKKwlwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19hbGxfaW5kZXhlcyhwdnMsIG51 bV9pbmRleF9zY2FucywgZmFsc2UsCisJCQkJCQkJCQkJJnd1c2FnZS0+Y2xlYW51cCk7CiB9CiAK IC8qCkBAIC02MTksNyArNjIxLDcgQEAgcGFyYWxsZWxfdmFjdXVtX2NvbXB1dGVfd29ya2VycyhS ZWxhdGlvbiAqaW5kcmVscywgaW50IG5pbmRleGVzLCBpbnQgbnJlcXVlc3RlZCwKICAqLwogc3Rh dGljIHZvaWQKIHBhcmFsbGVsX3ZhY3V1bV9wcm9jZXNzX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFj dXVtU3RhdGUgKnB2cywgaW50IG51bV9pbmRleF9zY2FucywKLQkJCQkJCQkJCWJvb2wgdmFjdXVt LCBQVldvcmtlcnNVc2FnZSAqd3VzYWdlKQorCQkJCQkJCQkJYm9vbCB2YWN1dW0sIFBWV29ya2Vy c1N0YXRzICp3c3RhdHMpCiB7CiAJaW50CQkJbndvcmtlcnM7CiAJUFZJbmRWYWNTdGF0dXMgbmV3 X3N0YXR1czsKQEAgLTY1Nyw4ICs2NTksOCBAQCBwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19hbGxf aW5kZXhlcyhQYXJhbGxlbFZhY3V1bVN0YXRlICpwdnMsIGludCBudW1faW5kZXhfc2NhbgogCW53 b3JrZXJzID0gTWluKG53b3JrZXJzLCBwdnMtPnBjeHQtPm53b3JrZXJzKTsKIAogCS8qIFJlbWVt YmVyIHRoaXMgdmFsdWUsIGlmIHdlIGFza2VkIHRvICovCi0JaWYgKHd1c2FnZSAhPSBOVUxMICYm IG53b3JrZXJzID4gMCkKLQkJd3VzYWdlLT5ucGxhbm5lZCArPSBud29ya2VyczsKKwlpZiAod3N0 YXRzICE9IE5VTEwgJiYgbndvcmtlcnMgPiAwKQorCQl3c3RhdHMtPm5wbGFubmVkICs9IG53b3Jr ZXJzOwogCiAJLyoKIAkgKiBSZXNlcnZlIHdvcmtlcnMgaW4gYXV0b3ZhY3V1bSBnbG9iYWwgc3Rh dGUuIE5vdGUgdGhhdCB3ZSBtYXkgYmUgZ2l2ZW4KQEAgLTY2OSw4ICs2NzEsOCBAQCBwYXJhbGxl bF92YWN1dW1fcHJvY2Vzc19hbGxfaW5kZXhlcyhQYXJhbGxlbFZhY3V1bVN0YXRlICpwdnMsIGlu dCBudW1faW5kZXhfc2NhbgogCQlBdXRvVmFjdXVtUmVzZXJ2ZVBhcmFsbGVsV29ya2Vycygmbndv cmtlcnMpOwogCiAJCS8qIFJlbWVtYmVyIHRoaXMgdmFsdWUsIGlmIHdlIGFza2VkIHRvICovCi0J CWlmICh3dXNhZ2UgIT0gTlVMTCkKLQkJCXd1c2FnZS0+bnJlc2VydmVkICs9IG53b3JrZXJzOwor CQlpZiAod3N0YXRzICE9IE5VTEwpCisJCQl3c3RhdHMtPm5yZXNlcnZlZCArPSBud29ya2VyczsK IAl9CiAKIAkvKgpAQCAtNzQxLDggKzc0Myw4IEBAIHBhcmFsbGVsX3ZhY3V1bV9wcm9jZXNzX2Fs bF9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywgaW50IG51bV9pbmRleF9zY2FuCiAJ CQlWYWN1dW1BY3RpdmVOV29ya2VycyA9ICYocHZzLT5zaGFyZWQtPmFjdGl2ZV9ud29ya2Vycyk7 CiAKIAkJCS8qIFJlbWVtYmVyIHRoaXMgdmFsdWUsIGlmIHdlIGFza2VkIHRvICovCi0JCQlpZiAo d3VzYWdlICE9IE5VTEwpCi0JCQkJd3VzYWdlLT5ubGF1bmNoZWQgKz0gcHZzLT5wY3h0LT5ud29y a2Vyc19sYXVuY2hlZDsKKwkJCWlmICh3c3RhdHMgIT0gTlVMTCkKKwkJCQl3c3RhdHMtPm5sYXVu Y2hlZCArPSBwdnMtPnBjeHQtPm53b3JrZXJzX2xhdW5jaGVkOwogCQl9CiAKIAkJaWYgKHZhY3V1 bSkKZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL2NvbW1hbmRzL3ZhY3V1bS5oIGIvc3JjL2luY2x1 ZGUvY29tbWFuZHMvdmFjdXVtLmgKaW5kZXggN2NiYjU5ZDEyNGYuLmQzZGM0ZThjYzY3IDEwMDY0 NAotLS0gYS9zcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1dW0uaAorKysgYi9zcmMvaW5jbHVkZS9j b21tYW5kcy92YWN1dW0uaApAQCAtMzAxLDE2ICszMDEsMjUgQEAgdHlwZWRlZiBzdHJ1Y3QgVmFj RGVhZEl0ZW1zSW5mbwogfSBWYWNEZWFkSXRlbXNJbmZvOwogCiAvKgotICogUFZXb3JrZXJzVXNh Z2Ugc3RvcmVzIGluZm9ybWF0aW9uIGFib3V0IHRvdGFsIG51bWJlciBvZiBsYXVuY2hlZCwgcmVz ZXJ2ZWQKLSAqIGFuZCBwbGFubmVkIHdvcmtlcnMgZHVyaW5nIHBhcmFsbGVsIHZhY3V1bS4KKyAq IEhlbHBlciBmb3IgdGhlIFBWV29ya2Vyc1VzYWdlIHN0cnVjdHVyZSAoc2VlIGJlbG93KSwgdG8g YXZvaWQgcmVwZXRpdGlvbi4KICAqLwotdHlwZWRlZiBzdHJ1Y3QgUFZXb3JrZXJzVXNhZ2UKK3R5 cGVkZWYgc3RydWN0IFBWV29ya2Vyc1N0YXRzCiB7CiAJaW50CQkJbnBsYW5uZWQ7CQkvKiAjIG9m IHBhcmFsbGVsIHdvcmtlcnMgd2UgYXJlIHBsYW5uZWQgdG8KIAkJCQkJCQkJICogbGF1bmNoICov CiAJaW50CQkJbnJlc2VydmVkOwkJLyogZm9yIGF1dG92YWN1dW0gb25seSAtICMgb2YgcGFyYWxs ZWwgd29ya2VycwogCQkJCQkJCQkgKiB3ZSBoYXZlIG1hbmFnZWQgdG8gcmVzZXJ2ZSAqLwogCWlu dAkJCW5sYXVuY2hlZDsJCS8qICMgb2YgbGF1bmNoZWQgcGFyYWxsZWwgd29ya2VycyAqLworfSBQ VldvcmtlcnNTdGF0czsKKworLyoKKyAqIFBWV29ya2Vyc1VzYWdlIHN0b3JlcyBpbmZvcm1hdGlv biBhYm91dCB0b3RhbCBudW1iZXIgb2YgbGF1bmNoZWQsIHJlc2VydmVkCisgKiBhbmQgcGxhbm5l ZCB3b3JrZXJzIGR1cmluZyBwYXJhbGxlbCB2YWN1dW0gKGJvdGggZm9yIHZhY3V1bSBhbmQgY2xl YW51cCkuCisgKi8KK3R5cGVkZWYgc3RydWN0IFBWV29ya2Vyc1VzYWdlCit7CisJUFZXb3JrZXJz U3RhdHMgdmFjdXVtOworCVBWV29ya2Vyc1N0YXRzIGNsZWFudXA7CiB9IFBWV29ya2Vyc1VzYWdl OwogCiAvKiBHVUMgcGFyYW1ldGVycyAqLwpkaWZmIC0tZ2l0IGEvc3JjL3Rvb2xzL3BnaW5kZW50 L3R5cGVkZWZzLmxpc3QgYi9zcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdAppbmRleCAx OTg4Y2Q4NzRmZC4uODRiZmEyOTcwZGUgMTAwNjQ0Ci0tLSBhL3NyYy90b29scy9wZ2luZGVudC90 eXBlZGVmcy5saXN0CisrKyBiL3NyYy90b29scy9wZ2luZGVudC90eXBlZGVmcy5saXN0CkBAIC0y MDY2LDYgKzIwNjYsOCBAQCBQVkluZFN0YXRzCiBQVkluZFZhY1N0YXR1cwogUFZPSUQKIFBWU2hh cmVkCitQVldvcmtlcnNVc2FnZQorUFZXb3JrZXJzU3RhdHMKIFBYX0FsaWFzCiBQWF9DaXBoZXIK IFBYX0NvbWJvCi0tIAoyLjQzLjAKCg== --000000000000a87ec3064a7990c4 Content-Type: text/x-patch; charset="US-ASCII"; name="v20--v21-diff-for-0004.patch" Content-Disposition: attachment; filename="v20--v21-diff-for-0004.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mlgqdsou5 RnJvbSA4MmMxZjQ0MmJhNWUxOGUzZDZkYzNjYjRlZDRmMjRjZDNhOGQ5MTBmIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBUdWUsIDEwIEZlYiAyMDI2IDIxOjMxOjE0ICswNzAwClN1YmplY3Q6IFtQQVRD SCA3LzddIGZpeGVzIGZvciBwYXRjaCA0CgotLS0KIHNyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3Zh Y3V1bWxhenkuYyAgICAgICAgICB8ICAgNyArCiBzcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1w YXJhbGxlbC5jICAgICAgICAgfCAgMzIgKystCiBzcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92 YWN1dW0uYyAgICAgICAgICAgfCAgMTkgKy0KIC4uLi9tb2R1bGVzL3Rlc3RfYXV0b3ZhY3V1bS90 LzAwMV9iYXNpYy5wbCAgICB8IDE4OCArKysrKysrKy0tLS0tLS0tLS0KIDQgZmlsZXMgY2hhbmdl ZCwgMTIxIGluc2VydGlvbnMoKyksIDEyNSBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zcmMv YmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVh cC92YWN1dW1sYXp5LmMKaW5kZXggZDE5ZTE1Y2JjY2UuLjJlODVmN2YxN2Y3IDEwMDY0NAotLS0g YS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMKKysrIGIvc3JjL2JhY2tlbmQv YWNjZXNzL2hlYXAvdmFjdXVtbGF6eS5jCkBAIC0xNTEsNiArMTUxLDcgQEAKICNpbmNsdWRlICJz dG9yYWdlL2ZyZWVzcGFjZS5oIgogI2luY2x1ZGUgInN0b3JhZ2UvbG1nci5oIgogI2luY2x1ZGUg InN0b3JhZ2UvcmVhZF9zdHJlYW0uaCIKKyNpbmNsdWRlICJ1dGlscy9pbmplY3Rpb25fcG9pbnQu aCIKICNpbmNsdWRlICJ1dGlscy9sc3lzY2FjaGUuaCIKICNpbmNsdWRlICJ1dGlscy9wZ19ydXNh Z2UuaCIKICNpbmNsdWRlICJ1dGlscy90aW1lc3RhbXAuaCIKQEAgLTg2OSw2ICs4NzAsMTIgQEAg aGVhcF92YWN1dW1fcmVsKFJlbGF0aW9uIHJlbCwgY29uc3QgVmFjdXVtUGFyYW1zIHBhcmFtcywK IAlsYXp5X2NoZWNrX3dyYXBhcm91bmRfZmFpbHNhZmUodmFjcmVsKTsKIAlkZWFkX2l0ZW1zX2Fs bG9jKHZhY3JlbCwgcGFyYW1zLm53b3JrZXJzKTsKIAorCS8qCisJICogVHJpZ2dlciBpbmplY3Rp b24gcG9pbnQsIGlmIHBhcmFsbGVsIGF1dG92YWN1dW0gaXMgYWJvdXQgdG8gYmUgc3RhcnRlZC4K KwkgKi8KKwlpZiAoQW1BdXRvVmFjdXVtV29ya2VyUHJvY2VzcygpICYmIFBhcmFsbGVsVmFjdXVt SXNBY3RpdmUodmFjcmVsKSkKKwkJSU5KRUNUSU9OX1BPSU5UKCJhdXRvdmFjdXVtLXN0YXJ0LXBh cmFsbGVsLXZhY3V1bSIsIE5VTEwpOworCiAJLyoKIAkgKiBDYWxsIGxhenlfc2Nhbl9oZWFwIHRv IHBlcmZvcm0gYWxsIHJlcXVpcmVkIGhlYXAgcHJ1bmluZywgaW5kZXgKIAkgKiB2YWN1dW1pbmcs IGFuZCBoZWFwIHZhY3V1bWluZyAocGx1cyByZWxhdGVkIHByb2Nlc3NpbmcpCmRpZmYgLS1naXQg YS9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jIGIvc3JjL2JhY2tlbmQvY29t bWFuZHMvdmFjdXVtcGFyYWxsZWwuYwppbmRleCAxMzY0OTc0NzMyMi4uNWRhZDE5ZDhlZDggMTAw NjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMKKysrIGIvc3Jj L2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYwpAQCAtOTI4LDYgKzkyOCw5IEBAIHBh cmFsbGVsX3ZhY3V1bV9wcm9jZXNzX2FsbF9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2 cywgaW50IG51bV9pbmRleF9zY2FuCiAJICogVG8gYmUgYWJsZSB0byBleGVyY2lzZSB3aGV0aGVy IGFsbCByZXNlcnZlZCBwYXJhbGxlbCB3b3JrZXJzIGFyZSBiZWluZwogCSAqIHJlbGVhc2VkIGFu eXdheSwgYWxsb3cgaW5qZWN0aW9uIHBvaW50cyB0byB0cmlnZ2VyIGEgZmFpbHVyZSBhdCB0aGlz CiAJICogcG9pbnQuCisJICoKKwkgKiBUaGlzIGluamVjdGlvbiBwb2ludCBpcyBhbHNvIHVzZWQg dG8gd2FpdCB1bnRpbCBwYXJhbGxlbCB3b3JrZXJzCisJICogZmluaXNoZXMgdGhlaXIgcGFydCBv ZiBpbmRleCBwcm9jZXNzaW5nLgogCSAqLwogCWlmIChud29ya2VycyA+IDApCiAJCUlOSkVDVElP Tl9QT0lOVCgiYXV0b3ZhY3V1bS1sZWFkZXItYmVmb3JlLWluZGV4ZXMtcHJvY2Vzc2luZyIsIE5V TEwpOwpAQCAtOTQxLDE1ICs5NDQsNiBAQCBwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19hbGxfaW5k ZXhlcyhQYXJhbGxlbFZhY3V1bVN0YXRlICpwdnMsIGludCBudW1faW5kZXhfc2NhbgogCSAqLwog CXBhcmFsbGVsX3ZhY3V1bV9wcm9jZXNzX3NhZmVfaW5kZXhlcyhwdnMpOwogCi0JLyoKLQkgKiBU byBiZSBhYmxlIHRvIGV4ZXJjaXNlIHdoZXRoZXIgbGVhZGVyIHBhcmFsbGVsIGF1dG92YWN1dW0g d29ya2VyIGNhbgotCSAqIHByb3BhZ2F0ZSBjb3N0LWJhc2VkIHBhcmFtcyB0byBwYXJhbGxlbCB3 b3JrZXJzLCB3YWl0IGhlcmUgdW50aWwKLQkgKiBjb25maWd1cmF0aW9uIGlzIGNoYW5nZWQuIEku ZS4gdGVzdHMgYXJlIGV4cGVjdGluZywgdGhhdCBkdXJpbmcgaW5kZXgKLQkgKiBwcm9jZXNzaW5n IHZhY3V1bV9kZWxheV9wb2ludCBoYXZlIGJlZW4gY2FsbGVkIChpZiBjb25maWcgd2FzIGNoYW5n ZWQpLgotCSAqLwotCWlmIChud29ya2VycyA+IDApCi0JCUlOSkVDVElPTl9QT0lOVCgiYXV0b3Zh Y3V1bS1sZWFkZXItYWZ0ZXItaW5kZXhlcy1wcm9jZXNzaW5nIiwgTlVMTCk7Ci0KIAkvKgogCSAq IE5leHQsIGFjY3VtdWxhdGUgYnVmZmVyIGFuZCBXQUwgdXNhZ2UuICAoVGhpcyBtdXN0IHdhaXQg Zm9yIHRoZSB3b3JrZXJzCiAJICogdG8gZmluaXNoLCBvciB3ZSBtaWdodCBnZXQgaW5jb21wbGV0 ZSBkYXRhLikKQEAgLTEzMTUsMjAgKzEzMDksMTYgQEAgcGFyYWxsZWxfdmFjdXVtX21haW4oZHNt X3NlZ21lbnQgKnNlZywgc2htX3RvYyAqdG9jKQogCS8qIFByZXBhcmUgdG8gdHJhY2sgYnVmZmVy IHVzYWdlIGR1cmluZyBwYXJhbGxlbCBleGVjdXRpb24gKi8KIAlJbnN0clN0YXJ0UGFyYWxsZWxR dWVyeSgpOwogCi0JSU5KRUNUSU9OX1BPSU5UKCJwYXJhbGxlbC13b3JrZXItYmVmb3JlLWluZGV4 ZXMtcHJvY2Vzc2luZyIsIE5VTEwpOwotCiAJLyogUHJvY2VzcyBpbmRleGVzIHRvIHBlcmZvcm0g dmFjdXVtL2NsZWFudXAgKi8KIAlwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19zYWZlX2luZGV4ZXMo JnB2cyk7CiAKICNpZmRlZiBVU0VfSU5KRUNUSU9OX1BPSU5UUwogCS8qCi0JICogVGhlcmUgaXMg bm8gZ3VhcmFudGVlIHRoYXQgZWFjaCBwYXJhbGxlbCB3b3JrZXIgd2lsbCBuZWNlc3NhcmlseQot CSAqIHByb2Nlc3MgYXQgbGVhc3Qgb25lIGluZGV4LiBUaHVzLCBhdCB0aGlzIHBvaW50IHdlIGNh bm5vdCBiZSBzdXJlIHRoYXQKLQkgKiB3b3JrZXIgY2FsbGVkIHZhY3V1bV9jb3N0X2RlbGF5LiBJ biBvcmRlciB0byB0ZXN0IGNvc3QtYmFzZWQgcGFyYW1ldGVycwotCSAqIHByb3BhZ2F0aW9uIChm cm9tIGxlYWRlciB3b3JrZXIpLCBjYWxsIHZhY3V1bV9kZWxheV9wb2ludCBoZXJlLCBpZgotCSAq IGluamVjdGlvbiBwb2ludCBpcyBhY3RpdmUuCisJICogSWYgd2UgYXJlIHBhcmFsbGVsIGF1dG92 YWN1dW0gd29ya2VyLCB3ZSBjYW4gY29uc3VtZSBkZWxheSBwYXJhbWV0ZXJzCisJICogZHVyaW5n IGluZGV4IHByb2Nlc3NpbmcgKHZpYSB2YWN1dW1fZGVsYXlfcG9pbnQgY2FsbCkuIFRoaXMgbG9n Z2luZworCSAqIGFsbG93cyB0ZXN0cyB0byBlbnN1cmUgdGhpcy4KIAkgKi8KLQlpZiAoSVNfSU5K RUNUSU9OX1BPSU5UX0FUVEFDSEVEKCJwYXJhbGxlbC1hdXRvdmFjdXVtLWZvcmNlLWRlbGF5LXBv aW50IikpCisJaWYgKHNoYXJlZC0+YW1fcGFyYWxsZWxfYXV0b3ZhY3V1bSkKIAkJcGFyYWxsZWxf dmFjdXVtX3JlcG9ydF9jb3N0X2Jhc2VkX3BhcmFtcygpOwogI2VuZGlmCiAKQEAgLTEzOTIsNiAr MTM4Miw3IEBAIHBhcmFsbGVsX3ZhY3V1bV9lcnJvcl9jYWxsYmFjayh2b2lkICphcmcpCiBzdGF0 aWMgdm9pZAogcGFyYWxsZWxfdmFjdXVtX3JlcG9ydF9jb3N0X2Jhc2VkX3BhcmFtcyh2b2lkKQog eworI2lmZGVmIFVTRV9JTkpFQ1RJT05fUE9JTlRTCiAJU3RyaW5nSW5mb0RhdGEgYnVmOwogCiAJ LyogU2ltdWxhdGUgY29uZmlnIHJlbG9hZCBkdXJpbmcgbm9ybWFsIHByb2Nlc3NpbmcgKi8KQEAg LTE0MDIsMTIgKzEzOTMsMTUgQEAgcGFyYWxsZWxfdmFjdXVtX3JlcG9ydF9jb3N0X2Jhc2VkX3Bh cmFtcyh2b2lkKQogCWluaXRTdHJpbmdJbmZvKCZidWYpOwogCiAJYXBwZW5kU3RyaW5nSW5mbygm YnVmLCAiVmFjdXVtIGNvc3QtYmFzZWQgZGVsYXkgcGFyYW1ldGVycyBvZiBwYXJhbGxlbCB3b3Jr ZXI6XG4iKTsKLQlhcHBlbmRTdHJpbmdJbmZvKCZidWYsInZhY3V1bV9jb3N0X2xpbWl0ID0gJWRc biIsdmFjdXVtX2Nvc3RfbGltaXQpOworCWFwcGVuZFN0cmluZ0luZm8oJmJ1ZiwgInZhY3V1bV9j b3N0X2xpbWl0ID0gJWRcbiIsdmFjdXVtX2Nvc3RfbGltaXQpOwogCWFwcGVuZFN0cmluZ0luZm8o JmJ1ZiwgInZhY3V1bV9jb3N0X2RlbGF5ID0gJWdcbiIsIHZhY3V1bV9jb3N0X2RlbGF5KTsKIAlh cHBlbmRTdHJpbmdJbmZvKCZidWYsICJ2YWN1dW1fY29zdF9wYWdlX21pc3MgPSAlZFxuIiwgVmFj dXVtQ29zdFBhZ2VNaXNzKTsKIAlhcHBlbmRTdHJpbmdJbmZvKCZidWYsICJ2YWN1dW1fY29zdF9w YWdlX2RpcnR5ID0gJWRcbiIsIFZhY3V1bUNvc3RQYWdlRGlydHkpOwogCWFwcGVuZFN0cmluZ0lu Zm8oJmJ1ZiwgInZhY3V1bV9jb3N0X3BhZ2VfaGl0ID0gJWRcbiIsIFZhY3V1bUNvc3RQYWdlSGl0 KTsKIAotCWVyZXBvcnQoTE9HLCBlcnJtc2coIiVzIiwgYnVmLmRhdGEpKTsKKwllcmVwb3J0KERF QlVHMiwgZXJybXNnKCIlcyIsIGJ1Zi5kYXRhKSk7CiAJcGZyZWUoYnVmLmRhdGEpOworI2Vsc2UK KwllbG9nKEVSUk9SLCAiSW5qZWN0aW9uIHBvaW50cyBhcmUgbm90IHN1cHBvcnRlZCBieSB0aGlz IGJ1aWxkIik7CisjZW5kaWYKIH0KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIv YXV0b3ZhY3V1bS5jIGIvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9hdXRvdmFjdXVtLmMKaW5kZXgg YjlmZjYwYmUwZjIuLjdiMjRhNWQ2ZTY3IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9wb3N0bWFz dGVyL2F1dG92YWN1dW0uYworKysgYi9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL2F1dG92YWN1dW0u YwpAQCAtODAwLDggKzgwMCw2IEBAIFByb2Nlc3NBdXRvVmFjTGF1bmNoZXJJbnRlcnJ1cHRzKHZv aWQpCiAKIAkJLyogcmVidWlsZCB0aGUgbGlzdCBpbiBjYXNlIHRoZSBuYXB0aW1lIGNoYW5nZWQg Ki8KIAkJcmVidWlsZF9kYXRhYmFzZV9saXN0KEludmFsaWRPaWQpOwotCi0JCUlOSkVDVElPTl9Q T0lOVCgiYXV0b3ZhY3V1bS1sYXVuY2hlci1hZnRlci1yZWxvYWQtY29uZmlnIiwgTlVMTCk7CiAJ fQogCiAJLyogUHJvY2VzcyBiYXJyaWVyIGV2ZW50cyAqLwpAQCAtMjQ5NywxMiArMjQ5NSwyMCBA QCBkb19hdXRvdmFjdXVtKHZvaWQpCiAJCX0KIAkJUEdfQ0FUQ0goKTsKIAkJeworCQkJaW50CW5y ZXNlcnZlZF93b3JrZXJzID0gYXZfbndvcmtlcnNfcmVzZXJ2ZWQ7CisKIAkJCS8qCiAJCQkgKiBQ YXJhbGxlbCBhdXRvdmFjdXVtIGNhbiByZXNlcnZlIHBhcmFsbGVsIHdvcmtlcnMuIE1ha2Ugc3Vy ZQogCQkJICogdGhhdCBhbGwgcmVzZXJ2ZWQgd29ya2VycyBhcmUgcmVsZWFzZWQuCiAJCQkgKi8K IAkJCUF1dG9WYWN1dW1SZWxlYXNlQWxsUGFyYWxsZWxXb3JrZXJzKCk7CiAKKwkJCWlmIChucmVz ZXJ2ZWRfd29ya2VycyA+IDApCisJCQkJZXJlcG9ydChERUJVRzIsCisJCQkJCQkoZXJybXNnKCIl ZCBwYXJhbGxlbCBhdXRvdmFjdXVtIHdvcmtlcnMgaGFzIGJlZW4gcmVsZWFzZWQgYWZ0ZXIgb2Nj dXJlZCBlcnJvciIsCisJCQkJCQkJCW5yZXNlcnZlZF93b3JrZXJzKSwKKwkJCQkJCSBlcnJoaWRl Y29udGV4dCh0cnVlKSkpOworCiAJCQkvKgogCQkJICogQWJvcnQgdGhlIHRyYW5zYWN0aW9uLCBz dGFydCBhIG5ldyBvbmUsIGFuZCBwcm9jZWVkIHdpdGggdGhlCiAJCQkgKiBuZXh0IHRhYmxlIGlu IG91ciBsaXN0LgpAQCAtMzQ2OSwxNSArMzQ3NSwxMyBAQCBBdXRvVmFjdXVtUmVsZWFzZUFsbFBh cmFsbGVsV29ya2Vycyh2b2lkKQogCiAvKgogICogR2V0IG51bWJlciBvZiBmcmVlIGF1dG92YWN1 dW0gcGFyYWxsZWwgd29ya2Vycy4KLSAqCi0gKiBGb3IgdGVzdGluZyBwdXJwb3NlIG9ubHkhCiAg Ki8KIHVpbnQzMgogQXV0b1ZhY3V1bUdldEZyZWVQYXJhbGxlbFdvcmtlcnModm9pZCkKIHsKIAl1 aW50MzIJCW5mcmVlX3dvcmtlcnM7CiAKLQlMV0xvY2tBY3F1aXJlKEF1dG92YWN1dW1Mb2NrLCBM V19FWENMVVNJVkUpOworCUxXTG9ja0FjcXVpcmUoQXV0b3ZhY3V1bUxvY2ssIExXX1NIQVJFRCk7 CiAJbmZyZWVfd29ya2VycyA9IEF1dG9WYWN1dW1TaG1lbS0+YXZfZnJlZVBhcmFsbGVsV29ya2Vy czsKIAlMV0xvY2tSZWxlYXNlKEF1dG92YWN1dW1Mb2NrKTsKIApAQCAtMzY1Miw1ICszNjU2LDEw IEBAIGFkanVzdF9mcmVlX3BhcmFsbGVsX3dvcmtlcnMoaW50IHByZXZfbWF4X3BhcmFsbGVsX3dv cmtlcnMpCiAJQXV0b1ZhY3V1bVNobWVtLT5hdl9mcmVlUGFyYWxsZWxXb3JrZXJzID0gTWF4KG5m cmVlX3dvcmtlcnMsIDApOwogCUF1dG9WYWN1dW1TaG1lbS0+YXZfbWF4UGFyYWxsZWxXb3JrZXJz ID0gYXV0b3ZhY3V1bV9tYXhfcGFyYWxsZWxfd29ya2VyczsKIAorCWVyZXBvcnQoREVCVUcyLAor CQkJKGVycm1zZygibnVtYmVyIG9mIGZyZWUgcGFyYWxsZWwgYXV0b3ZhY3V1bSB3b3JrZXJzIGlz IHNldCB0byAldSBkdWUgdG8gY29uZmlnIHJlbG9hZCIsCisJCQkJCUF1dG9WYWN1dW1TaG1lbS0+ YXZfZnJlZVBhcmFsbGVsV29ya2VycyksCisJCQkgZXJyaGlkZWNvbnRleHQodHJ1ZSkpKTsKKwog CUxXTG9ja1JlbGVhc2UoQXV0b3ZhY3V1bUxvY2spOwogfQpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3Qv bW9kdWxlcy90ZXN0X2F1dG92YWN1dW0vdC8wMDFfYmFzaWMucGwgYi9zcmMvdGVzdC9tb2R1bGVz L3Rlc3RfYXV0b3ZhY3V1bS90LzAwMV9iYXNpYy5wbAppbmRleCAwNjVhNThlZjJlNi4uYzVkOGZm ZmM0N2MgMTAwNjQ0Ci0tLSBhL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVtL3QvMDAx X2Jhc2ljLnBsCisrKyBiL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9hdXRvdmFjdXVtL3QvMDAxX2Jh c2ljLnBsCkBAIC0xLDMgKzEsNSBAQAorIyBUZXN0IHBhcmFsbGVsIGF1dG92YWN1dW0gYmVoYXZp b3IKKwogdXNlIHdhcm5pbmdzIEZBVEFMID0+ICdhbGwnOwogdXNlIFBvc3RncmVTUUw6OlRlc3Q6 OkNsdXN0ZXI7CiB1c2UgUG9zdGdyZVNRTDo6VGVzdDo6VXRpbHM7CkBAIC0yMSwxNyArMjMsOSBA QCBzdWIgcHJlcGFyZV9mb3JfbmV4dF90ZXN0CiAKIAkkbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3Jl cycsIHFxewogCQlVUERBVEUgdGVzdF9hdXRvdmFjIFNFVCBjb2xfMSA9ICR0ZXN0X251bWJlcjsK LQkJQU5BTFlaRSB0ZXN0X2F1dG92YWM7CiAJfSk7CiB9CiAKLXN1YiB3YWl0X2Zvcl9hdl9sb2cK LXsKLQlteSAoJG5vZGUsICRleHBlY3RlZF9sb2cpID0gQF87Ci0KLQkkbm9kZS0+d2FpdF9mb3Jf bG9nKCRleHBlY3RlZF9sb2cpOwotCXRydW5jYXRlICRub2RlLT5sb2dmaWxlLCAwIG9yIGRpZSAi dHJ1bmNhdGUgZmFpbGVkOiAkISI7Ci19CiAKIG15ICRwc3FsX291dDsKIApAQCAtNzEsMzEgKzY1 LDMwIEBAIG15ICRpbmRleGVzX251bSA9IDQ7CiBteSAkaW5pdGlhbF9yb3dzX251bSA9IDEwXzAw MDsKIG15ICRhdXRvdmFjdXVtX3BhcmFsbGVsX3dvcmtlcnMgPSAyOwogCi0jIENyZWF0ZSB0YWJs ZSB3aXRoIHNwZWNpZmllZCBudW1iZXIgb2YgYi10cmVlIGluZGV4ZXMgb24gaXQKKyMgQ3JlYXRl IHRhYmxlIGFuZCBmaWxsIGl0IHdpdGggc29tZSBkYXRhCiAkbm9kZS0+c2FmZV9wc3FsKCdwb3N0 Z3JlcycsIHFxewogCUNSRUFURSBUQUJMRSB0ZXN0X2F1dG92YWMgKAogCQlpZCBTRVJJQUwgUFJJ TUFSWSBLRVksCiAJCWNvbF8xIElOVEVHRVIsICBjb2xfMiBJTlRFR0VSLCAgY29sXzMgSU5URUdF UiwgIGNvbF80IElOVEVHRVIKIAkpIFdJVEggKGF1dG92YWN1dW1fcGFyYWxsZWxfd29ya2VycyA9 ICRhdXRvdmFjdXVtX3BhcmFsbGVsX3dvcmtlcnMpOwogCi0JRE8gXCRcJAotCURFQ0xBUkUKLQkJ aSBJTlRFR0VSOwotCUJFR0lOCi0JCUZPUiBpIElOIDEuLiRpbmRleGVzX251bSBMT09QCi0JCQlF WEVDVVRFIGZvcm1hdCgnQ1JFQVRFIElOREVYIGlkeF9jb2xfXCVzIE9OIHRlc3RfYXV0b3ZhYyAo Y29sX1wlcyk7JywgaSwgaSk7Ci0JCUVORCBMT09QOwotCUVORCBcJFwkOworCUlOU0VSVCBJTlRP IHRlc3RfYXV0b3ZhYworCVNFTEVDVAorCQlnIEFTIGNvbDEsCisJCWcgKyAxIEFTIGNvbDIsCisJ CWcgKyAyIEFTIGNvbDMsCisJCWcgKyAzIEFTIGNvbDQKKwlGUk9NIGdlbmVyYXRlX3Nlcmllcygx LCAkaW5pdGlhbF9yb3dzX251bSkgQVMgZzsKIH0pOwogCi0jIEluc2VydCBzcGVjaWZpZWQgdHVw bGVzIG51bSBpbnRvIHRoZSB0YWJsZQorIyBDcmVhdGUgc3BlY2lmaWVkIG51bWJlciBvZiBiLXRy ZWUgaW5kZXhlcyBvbiB0aGUgdGFibGUKICRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgcXF7 CiAJRE8gXCRcJAogCURFQ0xBUkUKIAkJaSBJTlRFR0VSOwogCUJFR0lOCi0JCUZPUiBpIElOIDEu LiRpbml0aWFsX3Jvd3NfbnVtIExPT1AKLQkJCUlOU0VSVCBJTlRPIHRlc3RfYXV0b3ZhYyBWQUxV RVMgKGksIGkgKyAxLCBpICsgMiwgaSArIDMpOworCQlGT1IgaSBJTiAxLi4kaW5kZXhlc19udW0g TE9PUAorCQkJRVhFQ1VURSBmb3JtYXQoJ0NSRUFURSBJTkRFWCBpZHhfY29sX1wlcyBPTiB0ZXN0 X2F1dG92YWMgKGNvbF9cJXMpOycsIGksIGkpOwogCQlFTkQgTE9PUDsKIAlFTkQgXCRcJDsKIH0p OwpAQCAtMTE1LDE0ICsxMDgsMTUgQEAgJG5vZGUtPnNhZmVfcHNxbCgncG9zdGdyZXMnLCBxcXsK IAogIyBXYWl0IHVudGlsIHRoZSBwYXJhbGxlbCBhdXRvdmFjdXVtIG9uIHRhYmxlIGlzIGNvbXBs ZXRlZC4gQXQgdGhlIHNhbWUgdGltZSwKICMgd2UgY2hlY2sgdGhhdCB0aGUgcmVxdWlyZWQgbnVt YmVyIG9mIHBhcmFsbGVsIHdvcmtlcnMgaGFzIGJlZW4gc3RhcnRlZC4KLXdhaXRfZm9yX2F2X2xv Zygkbm9kZSwKLQkJCQlxci9wYXJhbGxlbCBpbmRleCB2YWN1dW1cL2NsZWFudXA6IDIgd29ya2Vy cyB3ZXJlIHBsYW5uZWQsIC8gLgotCQkJCXFyLzIgd29ya2VycyB3ZXJlIHJlc2VydmVkIGFuZCAy IHdvcmtlcnMgd2VyZSBsYXVuY2hlZCBpbiB0b3RhbC8pOwotCi0kbm9kZS0+cHNxbCgncG9zdGdy ZXMnLAotCSJTRUxFQ1QgZ2V0X3BhcmFsbGVsX2F1dG92YWN1dW1fZnJlZV93b3JrZXJzKCk7IiwK LQlzdGRvdXQgPT4gXCRwc3FsX291dCwKKyRsb2dfc3RhcnQgPSAkbm9kZS0+d2FpdF9mb3JfbG9n KAorCXFyL3BhcmFsbGVsIGluZGV4IHZhY3V1bTogMiB3b3JrZXJzIHdlcmUgcGxhbm5lZCwgLyAu CisJcXIvMiB3b3JrZXJzIHdlcmUgcmVzZXJ2ZWQgYW5kIDIgd29ya2VycyB3ZXJlIGxhdW5jaGVk IGluIHRvdGFsLywKKwkkbG9nX3N0YXJ0CiApOworCiskcHNxbF9vdXQgPSAkbm9kZS0+c2FmZV9w c3FsKCdwb3N0Z3JlcycsIHFxeworCVNFTEVDVCBnZXRfcGFyYWxsZWxfYXV0b3ZhY3V1bV9mcmVl X3dvcmtlcnMoKTsKK30pOwogaXMoJHBzcWxfb3V0LCAyMCwgJ0FsbCBwYXJhbGxlbCB3b3JrZXJz IGhhcyBiZWVuIHJlbGVhc2VkIGJ5IHRoZSBsZWFkZXInKTsKIAogIyBUZXN0IDI6CkBAIC0xMzIs MTkgKzEyNiwxNiBAQCBpcygkcHNxbF9vdXQsIDIwLCAnQWxsIHBhcmFsbGVsIHdvcmtlcnMgaGFz IGJlZW4gcmVsZWFzZWQgYnkgdGhlIGxlYWRlcicpOwogcHJlcGFyZV9mb3JfbmV4dF90ZXN0KCRu b2RlLCAyKTsKIAogJG5vZGUtPnNhZmVfcHNxbCgncG9zdGdyZXMnLCBxcXsKKwlTRUxFQ1QgaW5q ZWN0aW9uX3BvaW50c19hdHRhY2goJ2F1dG92YWN1dW0tc3RhcnQtcGFyYWxsZWwtdmFjdXVtJywg J3dhaXQnKTsKIAlTRUxFQ1QgaW5qZWN0aW9uX3BvaW50c19hdHRhY2goJ2F1dG92YWN1dW0tbGVh ZGVyLWJlZm9yZS1pbmRleGVzLXByb2Nlc3NpbmcnLCAnd2FpdCcpOwotCVNFTEVDVCBpbmplY3Rp b25fcG9pbnRzX2F0dGFjaCgnYXV0b3ZhY3V1bS1sZWFkZXItYWZ0ZXItaW5kZXhlcy1wcm9jZXNz aW5nJywgJ3dhaXQnKTsKLQlTRUxFQ1QgaW5qZWN0aW9uX3BvaW50c19hdHRhY2goJ3BhcmFsbGVs LXdvcmtlci1iZWZvcmUtaW5kZXhlcy1wcm9jZXNzaW5nJywgJ3dhaXQnKTsKLQlTRUxFQ1QgaW5q ZWN0aW9uX3BvaW50c19hdHRhY2goJ3BhcmFsbGVsLWF1dG92YWN1dW0tZm9yY2UtZGVsYXktcG9p bnQnLCAnd2FpdCcpOwogCiAJQUxURVIgVEFCTEUgdGVzdF9hdXRvdmFjIFNFVCAoYXV0b3ZhY3V1 bV9wYXJhbGxlbF93b3JrZXJzID0gMSwgYXV0b3ZhY3V1bV9lbmFibGVkID0gdHJ1ZSk7CiB9KTsK IAotIyBXYWl0IHVudGlsIHBhcmFsbGVsIGF1dG92YWN1dW0gbGVhZGVyIGxhdW5jaGVzIHBhcmFs bGVsIHdvcmtlciBhbmQgZmFsbHMKLSMgYXNsZWVwIG9uIHRoZSBpbmplY3Rpb24gcG9pbnQKKyMg V2FpdCB1bnRpbCBwYXJhbGxlbCBhdXRvdmFjdXVtIGlzIGluaXRlZAogJG5vZGUtPndhaXRfZm9y X2V2ZW50KAogCSdhdXRvdmFjdXVtIHdvcmtlcicsCi0JJ2F1dG92YWN1dW0tbGVhZGVyLWJlZm9y ZS1pbmRleGVzLXByb2Nlc3NpbmcnCisJJ2F1dG92YWN1dW0tc3RhcnQtcGFyYWxsZWwtdmFjdXVt JwogKTsKIAogIyBSZWxvYWQgY29uZmlnIC0gbGVhZGVyIHdvcmtlciBtdXN0IHVwZGF0ZSBpdHMg b3duIHBhcmFtZXRlcnMgZHVyaW5nIGluZGV4ZXMKQEAgLTE1OCw0NSArMTQ5LDM0IEBAICRub2Rl LT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgcXF7CiB9KTsKIAogJG5vZGUtPnNhZmVfcHNxbCgncG9z dGdyZXMnLCBxcXsKLQlTRUxFQ1QgaW5qZWN0aW9uX3BvaW50c193YWtldXAoJ2F1dG92YWN1dW0t bGVhZGVyLWJlZm9yZS1pbmRleGVzLXByb2Nlc3NpbmcnKTsKKwlTRUxFQ1QgaW5qZWN0aW9uX3Bv aW50c193YWtldXAoJ2F1dG92YWN1dW0tc3RhcnQtcGFyYWxsZWwtdmFjdXVtJyk7CiB9KTsKIAot IyBXYWl0IHVudGlsIGxlYWRlciB3b3JrZXIgaXMgZ3VhcmFudGVlZCB0byB1cGRhdGUgcGFyYW1l dGVycyBhbmQgcHJvcGFnYXRlCi0jIHRoZWlyIHZhbHVlcyB0byB0aGUgcGFyYWxsZWwgd29ya2Vy CisjIE5vdyB3YWl0IHVudGlsIHBhcmFsbGVsIGF1dG92YWN1dW0gbGVhZGVyIGNvbXBsZXRlcyBw cm9jZXNzaW5nIHRhYmxlIChpLmUuCisjIGd1YXJhbnRlZWQgdG8gY2FsbCB2YWN1dW1fZGVsYXlf cG9pbnQpIGFuZCBsYXVuY2hlcyBwYXJhbGxlbCB3b3JrZXIuCiAkbm9kZS0+d2FpdF9mb3JfZXZl bnQoCiAJJ2F1dG92YWN1dW0gd29ya2VyJywKLQknYXV0b3ZhY3V1bS1sZWFkZXItYWZ0ZXItaW5k ZXhlcy1wcm9jZXNzaW5nJworCSdhdXRvdmFjdXVtLWxlYWRlci1iZWZvcmUtaW5kZXhlcy1wcm9j ZXNzaW5nJwogKTsKIAotJG5vZGUtPnNhZmVfcHNxbCgncG9zdGdyZXMnLCBxcXsKLQlTRUxFQ1Qg aW5qZWN0aW9uX3BvaW50c193YWtldXAoJ2F1dG92YWN1dW0tbGVhZGVyLWFmdGVyLWluZGV4ZXMt cHJvY2Vzc2luZycpOwotfSk7Ci0KLSMgTm93IHdha2UgdXAgdGhlIHBhcmFsbGVsIHdvcmtlciBh bmQgZm9yY2UgaXQgdG8gY2FsbCB2YWN1dW1fZGVsYXlfcG9pbnQKLSRub2RlLT53YWl0X2Zvcl9l dmVudCgKLQkncGFyYWxsZWwgd29ya2VyJywKLQkncGFyYWxsZWwtd29ya2VyLWJlZm9yZS1pbmRl eGVzLXByb2Nlc3NpbmcnCisjIENoZWNrIHdoZXRoZXIgcGFyYWxsZWwgd29ya2VyIHN1Y2Nlc3Nm dWxseSB1cGRhdGVkIGFsbCBwYXJhbWV0ZXJzIGR1cmluZworIyBpbmRleCBwcm9jZXNzaW5nCisk bG9nX3N0YXJ0ID0gJG5vZGUtPndhaXRfZm9yX2xvZygKKwlxci9WYWN1dW0gY29zdC1iYXNlZCBk ZWxheSBwYXJhbWV0ZXJzIG9mIHBhcmFsbGVsIHdvcmtlcjpcbi8gLgorCXFyL1x0dmFjdXVtX2Nv c3RfbGltaXQgPSA1MDBcbi8gLgorCXFyL1x0dmFjdXVtX2Nvc3RfZGVsYXkgPSAyXG4vIC4KKwlx ci9cdHZhY3V1bV9jb3N0X3BhZ2VfbWlzcyA9IDEwXG4vIC4KKwlxci9cdHZhY3V1bV9jb3N0X3Bh Z2VfZGlydHkgPSAxMFxuLyAuCisJcXIvXHR2YWN1dW1fY29zdF9wYWdlX2hpdCA9IDEwXG4vLAor CSRsb2dfc3RhcnQKICk7CiAKLSRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgcXF7Ci0JU0VM RUNUIGluamVjdGlvbl9wb2ludHNfd2FrZXVwKCdwYXJhbGxlbC13b3JrZXItYmVmb3JlLWluZGV4 ZXMtcHJvY2Vzc2luZycpOwotfSk7Ci0KLSMgQ2hlY2sgd2hldGhlciB3b3JrZXIgc3VjY2Vzc2Z1 bGx5IHVwZGF0ZWQgYWxsIHBhcmFtZXRlcnMKLXdhaXRfZm9yX2F2X2xvZygkbm9kZSwKLQkJCQlx ci9WYWN1dW0gY29zdC1iYXNlZCBkZWxheSBwYXJhbWV0ZXJzIG9mIHBhcmFsbGVsIHdvcmtlcjpc bi8gLgotCQkJCXFyL1x0dmFjdXVtX2Nvc3RfbGltaXQgPSA1MDBcbi8gLgotCQkJCXFyL1x0dmFj dXVtX2Nvc3RfZGVsYXkgPSAyXG4vIC4KLQkJCQlxci9cdHZhY3V1bV9jb3N0X3BhZ2VfbWlzcyA9 IDEwXG4vIC4KLQkJCQlxci9cdHZhY3V1bV9jb3N0X3BhZ2VfZGlydHkgPSAxMFxuLyAuCi0JCQkJ cXIvXHR2YWN1dW1fY29zdF9wYWdlX2hpdCA9IDEwXG4vKTsKLQogIyBDbGVhbnVwCiAkbm9kZS0+ c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFxeworCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX3dha2V1 cCgnYXV0b3ZhY3V1bS1sZWFkZXItYmVmb3JlLWluZGV4ZXMtcHJvY2Vzc2luZycpOworCisJU0VM RUNUIGluamVjdGlvbl9wb2ludHNfZGV0YWNoKCdhdXRvdmFjdXVtLXN0YXJ0LXBhcmFsbGVsLXZh Y3V1bScpOwogCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX2RldGFjaCgnYXV0b3ZhY3V1bS1sZWFk ZXItYmVmb3JlLWluZGV4ZXMtcHJvY2Vzc2luZycpOwotCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRz X2RldGFjaCgnYXV0b3ZhY3V1bS1sZWFkZXItYWZ0ZXItaW5kZXhlcy1wcm9jZXNzaW5nJyk7Ci0J U0VMRUNUIGluamVjdGlvbl9wb2ludHNfZGV0YWNoKCdwYXJhbGxlbC13b3JrZXItYmVmb3JlLWlu ZGV4ZXMtcHJvY2Vzc2luZycpOwotCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX2RldGFjaCgncGFy YWxsZWwtYXV0b3ZhY3V1bS1mb3JjZS1kZWxheS1wb2ludCcpOwogCiAJQUxURVIgVEFCTEUgdGVz dF9hdXRvdmFjIFNFVCAoYXV0b3ZhY3V1bV9wYXJhbGxlbF93b3JrZXJzID0gJGF1dG92YWN1dW1f cGFyYWxsZWxfd29ya2Vycyk7CiB9KTsKQEAgLTIwOSw3ICsxODksNiBAQCBwcmVwYXJlX2Zvcl9u ZXh0X3Rlc3QoJG5vZGUsIDQpOwogCiAkbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFxewog CVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX2F0dGFjaCgnYXV0b3ZhY3V1bS1sZWFkZXItYmVmb3Jl LWluZGV4ZXMtcHJvY2Vzc2luZycsICd3YWl0Jyk7Ci0JU0VMRUNUIGluamVjdGlvbl9wb2ludHNf YXR0YWNoKCdhdXRvdmFjdXVtLWxhdW5jaGVyLWFmdGVyLXJlbG9hZC1jb25maWcnLCAnd2FpdCcp OwogCUFMVEVSIFRBQkxFIHRlc3RfYXV0b3ZhYyBTRVQgKGF1dG92YWN1dW1fZW5hYmxlZCA9IHRy dWUpOwogfSk7CiAKQEAgLTIyMyw1MyArMjAyLDQ0IEBAICRub2RlLT5zYWZlX3BzcWwoJ3Bvc3Rn cmVzJywgcXF7CiAJU0VMRUNUIHBnX3JlbG9hZF9jb25mKCk7CiB9KTsKIAotJG5vZGUtPndhaXRf Zm9yX2V2ZW50KAotCSdhdXRvdmFjdXVtIGxhdW5jaGVyJywKLQknYXV0b3ZhY3V1bS1sYXVuY2hl ci1hZnRlci1yZWxvYWQtY29uZmlnJwotKTsKLQogIyBTaW5jZSAyIHBhcmFsbGVsIHdvcmtlcnMg YWxyZWFkeSBsYXVuY2hlZCBhbmQgd2lsbCBiZSByZWxlYXNlZCBpbiB0aGUgZnV0dXJlLAogIyB3 ZSBhcmUgZXhwZWN0aW5nIHRoYXQgOgogIyAxKSBudW1iZXIgb2YgZnJlZSB3b3JrZXJzIHdpbGwg YmUgJzAnIGFmdGVyIGNvbmZpZyByZWxvYWQKICMgMikgbnVtYmVyIG9mIGZyZWUgd29ya2VycyB3 aWxsIGJlICcxJyBhZnRlciByZWxlYXNpbmcgd29ya2VycwogCiAjIENoZWNrIHN0YXRlbWVudCAo MSkKLSRub2RlLT5wc3FsKCdwb3N0Z3JlcycsCi0JIlNFTEVDVCBnZXRfcGFyYWxsZWxfYXV0b3Zh Y3V1bV9mcmVlX3dvcmtlcnMoKTsiLAotCXN0ZG91dCA9PiBcJHBzcWxfb3V0LAorJGxvZ19zdGFy dCA9ICRub2RlLT53YWl0X2Zvcl9sb2coCisJcXIvbnVtYmVyIG9mIGZyZWUgcGFyYWxsZWwgYXV0 b3ZhY3V1bSB3b3JrZXJzIGlzIHNldCB0byAwIGR1ZSB0byBjb25maWcgcmVsb2FkLywKKwkkbG9n X3N0YXJ0CiApOwotaXMoJHBzcWxfb3V0LCAwLAotCSdOdW1iZXIgb2YgZnJlZSBwYXJhbGxlbCB3 b3JrZXJzIGlzIGNvbnNpc3RlbnQnKTsKIAogJG5vZGUtPnNhZmVfcHNxbCgncG9zdGdyZXMnLCBx cXsKLQlTRUxFQ1QgaW5qZWN0aW9uX3BvaW50c193YWtldXAoJ2F1dG92YWN1dW0tbGF1bmNoZXIt YWZ0ZXItcmVsb2FkLWNvbmZpZycpOwogCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX3dha2V1cCgn YXV0b3ZhY3V1bS1sZWFkZXItYmVmb3JlLWluZGV4ZXMtcHJvY2Vzc2luZycpOwogfSk7CiAKICMg V2FpdCB1bnRpbCB0aGUgZW5kIG9mIHBhcmFsbGVsIHByb2Nlc3NpbmcKLXdhaXRfZm9yX2F2X2xv Zygkbm9kZSwKLQkJCQlxci9wYXJhbGxlbCBpbmRleCB2YWN1dW1cL2NsZWFudXA6IDIgd29ya2Vy cyB3ZXJlIHBsYW5uZWQsIC8gLgotCQkJCXFyLzIgd29ya2VycyB3ZXJlIHJlc2VydmVkIGFuZCAy IHdvcmtlcnMgd2VyZSBsYXVuY2hlZCBpbiB0b3RhbC8pOworJGxvZ19zdGFydCA9ICRub2RlLT53 YWl0X2Zvcl9sb2coCisJcXIvcGFyYWxsZWwgaW5kZXggdmFjdXVtOiAyIHdvcmtlcnMgd2VyZSBw bGFubmVkLCAvIC4KKwlxci8yIHdvcmtlcnMgd2VyZSByZXNlcnZlZCBhbmQgMiB3b3JrZXJzIHdl cmUgbGF1bmNoZWQgaW4gdG90YWwvLAorCSRsb2dfc3RhcnQKKyk7CiAKICMgQ2hlY2sgc3RhdGVt ZW50ICgyKQotJG5vZGUtPnBzcWwoJ3Bvc3RncmVzJywKLQkiU0VMRUNUIGdldF9wYXJhbGxlbF9h dXRvdmFjdXVtX2ZyZWVfd29ya2VycygpOyIsCi0Jc3Rkb3V0ID0+IFwkcHNxbF9vdXQsCi0pOwot aXMoJHBzcWxfb3V0LCAxLAotCSdOdW1iZXIgb2YgZnJlZSBwYXJhbGxlbCB3b3JrZXJzIGlzIGNv bnNpc3RlbnQnKTsKKyRwc3FsX291dCA9ICRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgcXF7 CisJU0VMRUNUIGdldF9wYXJhbGxlbF9hdXRvdmFjdXVtX2ZyZWVfd29ya2VycygpOworfSk7Citp cygkcHNxbF9vdXQsIDEsICdOdW1iZXIgb2YgZnJlZSBwYXJhbGxlbCB3b3JrZXJzIGlzIGNvbnNp c3RlbnQnKTsKIAogIyBDbGVhbnVwCiAkbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFxewog CVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX2RldGFjaCgnYXV0b3ZhY3V1bS1sZWFkZXItYmVmb3Jl LWluZGV4ZXMtcHJvY2Vzc2luZycpOwotCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX2RldGFjaCgn YXV0b3ZhY3V1bS1sYXVuY2hlci1hZnRlci1yZWxvYWQtY29uZmlnJyk7CiAJQUxURVIgU1lTVEVN IFNFVCBhdXRvdmFjdXVtX21heF9wYXJhbGxlbF93b3JrZXJzID0gMTA7CiAJU0VMRUNUIHBnX3Jl bG9hZF9jb25mKCk7CiB9KTsKIAogIyBUZXN0IDQ6CiAjIFdlIHdhbnQgcGFyYWxsZWwgYXV0b3Zh Y3V1bSB3b3JrZXJzIHRvIGJlIHJlbGVhc2VkIGV2ZW4gaWYgbGVhZGVyIGdldHMgYW4KLSMgZXJy b3IuIEF0IGZpcnN0LCBzaW11bGF0ZSBzaXR1YXRpb24sIHdoZW4gbGVhZGVyIGV4aXRlcyBkdWUg dG8gYW4gRVJST1IuCisjIGVycm9yLiBBdCBmaXJzdCwgc2ltdWxhdGUgc2l0dWF0aW9uLCB3aGVu IGxlYWRlciBleGl0cyBkdWUgdG8gYW4gRVJST1IuCiAKIHByZXBhcmVfZm9yX25leHRfdGVzdCgk bm9kZSwgNCk7CiAKQEAgLTI3OCwxNiArMjQ4LDE2IEBAICRub2RlLT5zYWZlX3BzcWwoJ3Bvc3Rn cmVzJywgcXF7CiAJQUxURVIgVEFCTEUgdGVzdF9hdXRvdmFjIFNFVCAoYXV0b3ZhY3V1bV9lbmFi bGVkID0gdHJ1ZSk7CiB9KTsKIAotd2FpdF9mb3JfYXZfbG9nKCRub2RlLAotCQkJCXFyL2Vycm9y IHRyaWdnZXJlZCBmb3IgaW5qZWN0aW9uIHBvaW50IC8gLgotCQkJCXFyL2F1dG92YWN1dW0tbGVh ZGVyLWJlZm9yZS1pbmRleGVzLXByb2Nlc3NpbmcvKTsKKyRsb2dfc3RhcnQgPSAkbm9kZS0+d2Fp dF9mb3JfbG9nKAorCXFyL2Vycm9yIHRyaWdnZXJlZCBmb3IgaW5qZWN0aW9uIHBvaW50IC8gLgor CXFyL2F1dG92YWN1dW0tbGVhZGVyLWJlZm9yZS1pbmRleGVzLXByb2Nlc3NpbmcvLAorCSRsb2df c3RhcnQKKyk7CiAKLSRub2RlLT5wc3FsKCdwb3N0Z3JlcycsCi0JIlNFTEVDVCBnZXRfcGFyYWxs ZWxfYXV0b3ZhY3V1bV9mcmVlX3dvcmtlcnMoKTsiLAotCXN0ZG91dCA9PiBcJHBzcWxfb3V0LAor JGxvZ19zdGFydCA9ICRub2RlLT53YWl0X2Zvcl9sb2coCisJcXIvMiBwYXJhbGxlbCBhdXRvdmFj dXVtIHdvcmtlcnMgaGFzIGJlZW4gcmVsZWFzZWQgYWZ0ZXIgb2NjdXJlZCBlcnJvci8sCisJJGxv Z19zdGFydAogKTsKLWlzKCRwc3FsX291dCwgMTAsCi0gICAnQWxsIHBhcmFsbGVsIHdvcmtlcnMg aGFzIGJlZW4gcmVsZWFzZWQgYnkgdGhlIGxlYWRlciBhZnRlciBFUlJPUicpOwogCiAjIENsZWFu dXAKICRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgcXF7CkBAIC0yOTUsMTUgKzI2NSwyNSBA QCAkbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFxewogfSk7CiAKICMgVGVzdCA1OgotIyBT YW1lIGFzIGFib3ZlIHRlc3QsIGJ1dCBzaW11bGF0ZSBzaXR1YXRpb24sIHdoZW4gbGVhZGVyIGV4 aXRlcyBkdWUgdG8gRkFUQUwuCisjIFNhbWUgYXMgYWJvdmUgdGVzdCwgYnV0IHNpbXVsYXRlIHNp dHVhdGlvbiwgd2hlbiBsZWFkZXIgZXhpdHMgZHVlIHRvIEZBVEFMLgogCiBwcmVwYXJlX2Zvcl9u ZXh0X3Rlc3QoJG5vZGUsIDUpOwogCiAkbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFxewor CVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX2F0dGFjaCgnYXV0b3ZhY3V1bS1zdGFydC1wYXJhbGxl bC12YWN1dW0nLCAnd2FpdCcpOwogCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX2F0dGFjaCgnYXV0 b3ZhY3V1bS1sZWFkZXItYmVmb3JlLWluZGV4ZXMtcHJvY2Vzc2luZycsICd3YWl0Jyk7CiAJQUxU RVIgVEFCTEUgdGVzdF9hdXRvdmFjIFNFVCAoYXV0b3ZhY3V1bV9lbmFibGVkID0gdHJ1ZSk7CiB9 KTsKIAorIyBXYWl0IHVudGlsIHBhcmFsbGVsIGF1dG92YWN1dW0gaXMgaW5pdGVkIGFuZCB3YWtl IHVwIHRoZSBsZWFkZXIKKyRub2RlLT53YWl0X2Zvcl9ldmVudCgKKwknYXV0b3ZhY3V1bSB3b3Jr ZXInLAorCSdhdXRvdmFjdXVtLXN0YXJ0LXBhcmFsbGVsLXZhY3V1bScKKyk7Ciskbm9kZS0+c2Fm ZV9wc3FsKCdwb3N0Z3JlcycsIHFxeworCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX3dha2V1cCgn YXV0b3ZhY3V1bS1zdGFydC1wYXJhbGxlbC12YWN1dW0nKTsKK30pOworCiAkbm9kZS0+d2FpdF9m b3JfZXZlbnQoCiAJJ2F1dG92YWN1dW0gd29ya2VyJywKIAknYXV0b3ZhY3V1bS1sZWFkZXItYmVm b3JlLWluZGV4ZXMtcHJvY2Vzc2luZycKQEAgLTMyNywxOCArMzA3LDI0IEBAICRub2RlLT5zYWZl X3BzcWwoJ3Bvc3RncmVzJywgcXF7CiAJU0VMRUNUIHBnX3Rlcm1pbmF0ZV9iYWNrZW5kKCckYXZf cGlkJyk7CiB9KTsKIAotd2FpdF9mb3JfYXZfbG9nKCRub2RlLAotCQkJCXFyL3Rlcm1pbmF0aW5n IGF1dG92YWN1dW0gcHJvY2VzcyBkdWUgdG8gYWRtaW5pc3RyYXRvciBjb21tYW5kLyk7Ci0KLSRu b2RlLT5wc3FsKCdwb3N0Z3JlcycsCi0JIlNFTEVDVCBnZXRfcGFyYWxsZWxfYXV0b3ZhY3V1bV9m cmVlX3dvcmtlcnMoKTsiLAotCXN0ZG91dCA9PiBcJHBzcWxfb3V0LAorJGxvZ19zdGFydCA9ICRu b2RlLT53YWl0X2Zvcl9sb2coCisJcXIvdGVybWluYXRpbmcgYXV0b3ZhY3V1bSBwcm9jZXNzIGR1 ZSB0byBhZG1pbmlzdHJhdG9yIGNvbW1hbmQvLAorCSRsb2dfc3RhcnQKICk7Ci1pcygkcHNxbF9v dXQsIDEwLAotCSdBbGwgcGFyYWxsZWwgd29ya2VycyBoYXMgYmVlbiByZWxlYXNlZCBieSB0aGUg bGVhZGVyIGFmdGVyIEZBVEFMJyk7CisKKyMgTm93IGl0IGlzIHNhZmUgdG8gY2hlY2sgdGhlIG51 bWJlciBvZiBmcmVlIHBhcmFsbGVsIHdvcmtlcnMsIGJlY2F1c2UgZXZlbiBpZgorIyBhdXRvdmFj dXVtIGlzIHRyeWluZyB0byB2YWN1dW0gdGFibGUgaW4gcGFyYWxsZWwgbW9kZSBhZ2FpbiwgdGhl IGxlYWRlcgorIyB3b3JrZXIgY2Fubm90IGdvIGFueSBmdXJ0aGVyIHRoYW4gImF1dG92YWN1dW0t c3RhcnQtcGFyYWxsZWwtdmFjdXVtIiBwb2ludC4KKyMgSS5lLiBubyBvbmUgY2FuIGludGVyZmVy ZSBhbmQgY2hhbmdlIHRoZSBudW1iZXIgb2YgZnJlZSBwYXJhbGxlbCB3b3JrZXJzLgorCiskcHNx bF9vdXQgPSAkbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFxeworCVNFTEVDVCBnZXRfcGFy YWxsZWxfYXV0b3ZhY3V1bV9mcmVlX3dvcmtlcnMoKTsKK30pOworaXMoJHBzcWxfb3V0LCAxMCwg J0FsbCBwYXJhbGxlbCB3b3JrZXJzIGhhcyBiZWVuIHJlbGVhc2VkIGJ5IHRoZSBsZWFkZXIgYWZ0 ZXIgRkFUQUwnKTsKIAogIyBDbGVhbnVwCiAkbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3JlcycsIHFx eworCVNFTEVDVCBpbmplY3Rpb25fcG9pbnRzX2RldGFjaCgnYXV0b3ZhY3V1bS1zdGFydC1wYXJh bGxlbC12YWN1dW0nKTsKIAlTRUxFQ1QgaW5qZWN0aW9uX3BvaW50c19kZXRhY2goJ2F1dG92YWN1 dW0tbGVhZGVyLWJlZm9yZS1pbmRleGVzLXByb2Nlc3NpbmcnKTsKIH0pOwogCi0tIAoyLjQzLjAK Cg== --000000000000a87ec3064a7990c4--