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 1w9Med-001NRX-0C for pgsql-hackers@arkaria.postgresql.org; Sun, 05 Apr 2026 12:32:39 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1w9Meb-002j0f-22 for pgsql-hackers@arkaria.postgresql.org; Sun, 05 Apr 2026 12:32:38 +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 ) id 1w9Mea-002j0W-38 for pgsql-hackers@lists.postgresql.org; Sun, 05 Apr 2026 12:32:37 +0000 Received: from mail-qv1-xf29.google.com ([2607:f8b0:4864:20::f29]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.98.2) (envelope-from ) id 1w9MeX-00000000j0p-2rTk for pgsql-hackers@lists.postgresql.org; Sun, 05 Apr 2026 12:32:37 +0000 Received: by mail-qv1-xf29.google.com with SMTP id 6a1803df08f44-8a00566c11bso48862796d6.2 for ; Sun, 05 Apr 2026 05:32:33 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1775392352; cv=none; d=google.com; s=arc-20240605; b=HmgqKWDrymopgMJFmL/dhnARNES6YwkyxkCZTp/pa3vH8pNK9rSVM2hAvq7+jvE1fZ UqsGZwrf42Nkg/5xBIWkRBg19Ff+/EpAZgK8KrlGr6+WhD4NcOzYAgRPuBKrALQvpDTR Z48z537jT/KJrI7gk/cIQsMcheQYEYSRJq0cVIaJldeLwj5Ofs9Gh5WGOdctuvN7ypxF OfJmbC2vhRd5K4wtGAX4Kk29YrLrQ9t/MvXXmvEkzIJSz9zc57LZPvYLItxVXbZwMuBG DBUMuSasR2Vn9RcHyMeX2P6bBLPgjQF3k6G41N92i+C3oCP661HbgBNmNWeiVdS6wYWB 7Xvg== 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=dghjYrdUAjaOwG7MUyYNkrBlnsYIyuYMZ4SzEabnPCY=; fh=cPvjZI5Hoabvyl6hd2S3cdrfzl+MivxxO4gHoYHHbno=; b=EFbYIvEPM3KsoG7EJBjoBdss6Sb4fpUb06IOq+6CV34rA0+Z4gKm1B5ET4ER/BbZfz ht9b7YyenNa8C9Dgoex/bzyhUCGBbCEstoh+dB2pokP3OLgbkHX5P07lIKUuW01q1Lsw 3sMLUrbp/Zgrnbjf/xYDB78x67erka37ATRtR9b49WyHExjmPOjr0/Uv4oWB+YDNJ7ca m28kxjcfQeV4GHnWf//3rMDDnkPqQpkyW0ZrdX+TK3bwOd0+/25y7+Z8GxBIt29wWl9H XjTiQ3VMH+dZTE24B+YbNfRXHj2Tgui/yFEi8kojM6H3qSw88Kc+32m2YM6MQe45lJp9 B46Q==; 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=fittl.com; s=google; t=1775392352; x=1775997152; 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=dghjYrdUAjaOwG7MUyYNkrBlnsYIyuYMZ4SzEabnPCY=; b=coVJyfJtWtTjtTsTMmkWAHyGOaMr/y99vQCOVlcS+7bD6PQ80E6x8JPfuOd6XL2VRs RRl3BuTQQsmf5zFLnBe2KTRqSw2msPRXOhvggvfblQCS2W3ii/dJP4UAE0qiS88JyTXS siXbrFW4wkfpyfu8kRNGUAH8DoLEq7eGBOOyw= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1775392352; x=1775997152; 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=dghjYrdUAjaOwG7MUyYNkrBlnsYIyuYMZ4SzEabnPCY=; b=AkO5S5iDZbTgVnVE6O+PhVuRXGx5YOCgtRiKEa6mVwdz6ubcSIghQ8ZAx96AUREYyQ DaBtGDix7LXBBGZwhhlMCrBoSve+LkEdccnGPajHidBTs7VJymiM4ttPhN4+c93HuU/J JRmaeSIEBtt5FadPN2rRVvznfx96peruE3qJdnPB0mBwcXT2kg3oJelPAmDJxL2W9YEK mmzfDwF+wjC9alQkH2d/PhypmdmeKejhdxBag6Er/O8xnW8AYvFauuWEEIQJSYhueMtm 7HBNi1K6Y0Rl9MRYWzN0iHkQh5PdWHYGRJp5Nu3za71MoekJ3j4h2C43M5cn2Z1lwYYR y6Og== X-Gm-Message-State: AOJu0YxZGSL3CbMNoaU3h9E5Jc2w2RlFHDrjHmiN7iK85jwKb+zJzykU crmT9b3aQ1BXJK5LQlT+oxR6CbpJZwPMmHmy5TB6EUDYOqxqwY/zt0CDqLxg5SWOSGwID+qmPoa KHST3mESpB9Lv4AkEdGVjrTRt/kvg4AO0PIWTUlCU X-Gm-Gg: AeBDietHmR8qhS008CNUw7V0NMCL29uCCt+tU87AV92Ggb18NB6HlLXeq4SfNpTAklQ Qz1cBgc4bffHdXjcfrECO+BevEa8BVA4JTCqKA3WDqj7T8Cn4oByvD+b1taczB0eT8N3EMBSFZC j2x92aPd+ZenDYPCH+zCpATvj9ky7+OCm2m/1U6XaAvNatBQSUOTO9PFmkiTOQ6XRE7ewv7HNve sXvnEFgCFBNWZEZvB5pE8+UFGxPYs3wRd9TCDXyuLmXJ0hD7lpFq01tTuHGpVsiLMZMFbppalT6 IP6a/SgqbJxT9ETa8Gep5sONx3s5UZ0cgJqxxiIp X-Received: by 2002:ad4:5d6b:0:b0:89c:8709:d238 with SMTP id 6a1803df08f44-8a7042f7e3dmr145035626d6.40.1775392351014; Sun, 05 Apr 2026 05:32:31 -0700 (PDT) MIME-Version: 1.0 References: <57biou6l65r7gr4nunoe6lignz2x6m3w45gihoypaez4pc46di@txj3bakhj66l> In-Reply-To: <57biou6l65r7gr4nunoe6lignz2x6m3w45gihoypaez4pc46di@txj3bakhj66l> From: Lukas Fittl Date: Sun, 5 Apr 2026 05:31:53 -0700 X-Gm-Features: AQROBzB4nMyw6BAGZcAuOHhYXahMV2l7RZSsZ8XQHZOJF_NGCTRX3Vf_VQl5ARU Message-ID: Subject: Re: Stack-based tracking of per-node WAL/buffer usage To: Andres Freund , Heikki Linnakangas Cc: PostgreSQL Hackers , Zsolt Parragi , Tomas Vondra , Peter Smith Content-Type: multipart/mixed; boundary="0000000000006d0cb0064eb5be7d" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --0000000000006d0cb0064eb5be7d Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Hi Andres, Thanks for reviewing! On Sat, Apr 4, 2026 at 12:39=E2=80=AFPM Andres Freund = wrote: > > Hi, > > On 2026-04-04 02:43:50 -0700, Lukas Fittl wrote: > > Attached v12, rebased, otherwise no changes. > > > > I realize time to freeze is getting close, and whilst I'd love to see > > this go in, I'm also realistic - so I'll just do my best to support > > review in the off chance we can make it for this release. > > I unfortunately think there's enough nontrivial design decisions - that I > don't have a sufficiently confident assesment of - that I would be pretty > hesitant to commit this at this stage of the cycle without some architect= ural > review by senior folks. If Heikki did another round or two of review, it= 'd be a > different story. Ack - I'll keep it updated as needed in the next days to help, but understand that there many competing priorities :) FWIW, I do feel like Heikki has taken a look at the memory management aspects, and Zsolt also had some good detailed feedback on lower level logic and OOM behaviour - so I'm actually less worried about these now. Heikki, your further review is very welcome, if you have the time. It'd also be great if you could review the README.instrument (now in v13/0008) to see if that makes sense to you. > I think the high level design is a huge improvement and goes in the right > direction, but some of the lower level stuff I'm far less confident about= . Glad to hear - I also think that the direction here is right, and I don't think there is a lot of variance on architectural choices anymore. > > > On that note, I think 0001 and 0002 are independently useful > > refactorings to split the different kinds of instrumentation that > > should be ready to go, and I don't think should conflict much with > > other patches in this commitfest. > > Yea, I'll see that those get committed. > > I could also see 0004 as potentially worth getting committed separately, > although I'm a bit worried about test stability. Yeah, I understand. FWIW, the current approach has been stable in CI runs, but that doesn't mean something in the buildfarm won't complain. > I recently looked at a coverage report, in the context of the index > prefetching patch, and was a it surprised that prominent parallel executo= r > nodes have no coverage for EXPLAIN ANALYZE. > parallel BHS is not covered: > https://coverage.postgresql.org/src/backend/executor/nodeBitmapHeapscan.c= .gcov.html#L536 > parallel IOS is not covered: > https://coverage.postgresql.org/src/backend/executor/nodeIndexonlyscan.c.= gcov.html#L430 Ugh. Good catch, that lack of coverage is not good. I've added two tests for that, and guess what, I found a bug (unrelated to stack-based instrumentation) - show_tidbitmap_info doesn't correctly accumulate Heap Blocks information from the worker instrumentation - it only ever shows that of the leader. For such auxiliary information in a parallel context it needs to do the extra work, e.g. like show_indexsearches_info does. I've put that bugfix and BHS coverage into its own commit (0004) before the other tests, because I suspect we may even want to backpatch that. I've added coverage of IOS via a check for Index Searches as a new patch as well (0005). Let me know if you prefer if I start a new thread for those. See attached v13, with feedback addressed, unless otherwise noted below. I've also slightly simplified InstrAggNode, since I realized it is never called when running=3Dtrue. > > > From 90a7ed18f14c09c8a1299db3a015747fc6b6761c Mon Sep 17 00:00:00 2001 > > From: Lukas Fittl > > Date: Tue, 9 Sep 2025 02:16:59 -0700 > > Subject: [PATCH v12 5/9] Optimize measuring WAL/buffer usage through > > stack-based instrumentation > > > > Previously, in order to determine the buffer/WAL usage of a given code > > section, we utilized continuously incrementing global counters that get > > updated when the actual activity (e.g. shared block read) occurred, and > > then calculated a diff when the code section ended. This resulted in a > > bottleneck for executor node instrumentation specifically, with the > > function BufferUsageAccumDiff showing up in profiles and in some cases > > adding up to 10% overhead to an EXPLAIN (ANALYZE, BUFFERS) run. > > > > Instead, introduce a stack-based mechanism, where the actual activity > > writes into the current stack entry. In the case of executor nodes, thi= s > > means that each node gets its own stack entry that is pushed at > > InstrStartNode, and popped at InstrEndNode. Stack entries are zero > > initialized (avoiding the diff mechanism) and get added to their parent > > entry when they are finalized, i.e. no more modifications can occur. > > > > To correctly handle abort situations, any use of instrumentation stacks > > must involve either a top-level QueryInstrumentation struct, and its > > associated InstrQueryStart/InstrQueryStop helpers (which use resource > > owners to handle aborts), or the Instrumentation struct itself with > > dedicated PG_TRY/PG_FINALLY calls that ensure the stack is in a > > consistent state after an abort. > > > > This also drops the global pgBufferUsage, any callers interested in > > measuring buffer activity should instead utilize InstrStart/InstrStop. > > > > The related global pgWalUsage is kept for now due to its use in pgstat > > to track aggregate WAL activity and heap_page_prune_and_freeze for > > measuring FPIs. > > Probably worth stating what the performance overhead of WAL and BUFFERS i= s > after this patch? I've added a note re: BUFFERS referencing the COUNT(*) numbers from earlier in the thread - not sure if WAL is really worth it to talk about (its already quite a long commit message). > > > > @@ -1015,19 +994,9 @@ pgss_ExecutorStart(QueryDesc *queryDesc, int efla= gs) > > */ > > if (pgss_enabled(nesting_level) && queryDesc->plannedstmt->queryI= d !=3D INT64CONST(0)) > > { > > - /* > > - * Set up to track total elapsed time in ExecutorRun. Ma= ke sure the > > - * space is allocated in the per-query context so it will= go away at > > - * ExecutorEnd. > > - */ > > + /* Set up to track total elapsed time in ExecutorRun. */ > > if (queryDesc->totaltime =3D=3D NULL) > > - { > > - MemoryContext oldcxt; > > - > > - oldcxt =3D MemoryContextSwitchTo(queryDesc->estat= e->es_query_cxt); > > - queryDesc->totaltime =3D InstrAlloc(INSTRUMENT_AL= L); > > - MemoryContextSwitchTo(oldcxt); > > - } > > + queryDesc->totaltime =3D InstrQueryAlloc(INSTRUME= NT_ALL); > > } > > } > > Not at all the fault of this patch, but it does seem somewhat odd to me t= hat > we handle pgss/auto_explain wanting instrumentation by them updating the > QueryDesc->totaltime, rather than having extensions add an eflag to ask > standard_ExecutorStart to do so. Agreed, that interaction is a bit odd. I think it'd be reasonable to do this as a separate refactoring, especially now that I've stopped utilizing totaltime as the parent for per-node instrumentation, per later notes. > > > @@ -2434,8 +2434,8 @@ _brin_begin_parallel(BrinBuildState *buildstate, = Relation heap, Relation index, > > * and PARALLEL_KEY_BUFFER_USAGE. > > * > > * If there are no extensions loaded that care, we could skip thi= s. We > > - * have no way of knowing whether anyone's looking at pgWalUsage = or > > - * pgBufferUsage, so do it unconditionally. > > + * have no way of knowing whether anyone's looking at instrumenta= tion, so > > + * do it unconditionally. > > */ > > shm_toc_estimate_chunk(&pcxt->estimator, > > mul_size(sizeof(WalUsa= ge), pcxt->nworkers)); > > @@ -2887,6 +2887,7 @@ _brin_parallel_build_main(dsm_segment *seg, shm_t= oc *toc) > > Relation indexRel; > > LOCKMODE heapLockmode; > > LOCKMODE indexLockmode; > > + QueryInstrumentation *instr; > > WalUsage *walusage; > > BufferUsage *bufferusage; > > int sortmem; > > @@ -2936,7 +2937,7 @@ _brin_parallel_build_main(dsm_segment *seg, shm_t= oc *toc) > > tuplesort_attach_shared(sharedsort, seg); > > > > /* Prepare to track buffer usage during parallel execution */ > > - InstrStartParallelQuery(); > > + instr =3D InstrStartParallelQuery(); > > > > /* > > * Might as well use reliable figure when doling out maintenance_= work_mem > > @@ -2951,7 +2952,8 @@ _brin_parallel_build_main(dsm_segment *seg, shm_t= oc *toc) > > /* Report WAL/buffer usage during parallel execution */ > > bufferusage =3D shm_toc_lookup(toc, PARALLEL_KEY_BUFFER_USAGE, fa= lse); > > walusage =3D shm_toc_lookup(toc, PARALLEL_KEY_WAL_USAGE, false); > > - InstrEndParallelQuery(&bufferusage[ParallelWorkerNumber], > > + InstrEndParallelQuery(instr, > > + &bufferusage[ParallelWo= rkerNumber], > > &walusage[ParallelWorke= rNumber]); > > > > index_close(indexRel, indexLockmode); > > Again not your fault, but it feels like the parallel index build > infrastructure is all wrong. Reimplementing this stuff for every index ty= pe > makes no sense. Fully agreed, the duplication here is quite something. The 0006 patch cleans this up a little bit by at least using the Instrumentation struct consistently. That is not required for the stack-based commit, but would be helpful if e.g. we were to put IO stats next to Buffer/WAL stats in the future. > > +For example, when Seq Scan A gets finalized in regular execution via E= xecutorFinish, > > +its instrumentation data gets added to the immediate parent in > > +the execution tree, the NestLoop, which will then get added to Query A= 's > > +QueryInstrumentation, which then accumulates to the parent. > > + > > +While we can typically think of this as a tree, the NodeInstrumentatio= n > > +underneath a particular QueryInstrumentation could behave differently = -- > > +for example, it could propagate directly to the QueryInstrumentation, = in > > +order to not show cumulative numbers in EXPLAIN ANALYZE. > > Hm. This seems like a somewhat random example, why would one want this? > Hmm, yeah. I mainly included this because the fact that accumulation for the individual nodes in the EXPLAIN happens to be in a tree-like structure is a choice, no longer a requirement. It would be just as easy to only accumulate to the parent QueryInstrumentation, and let explain.c present you a choice of "BUFFERS SELF" / etc - we couldn't have done that previously. I've left this in for now, but maybe its better to drop it to avoid confusi= on? > > +If multiple QueryInstrumentations are active on the stack (e.g. nested > > +portals), each one's abort handler uses InstrStopFinalize to unwind to > > +whichever entry is higher up, so they compose correctly regardless of > > +release order. > > Maybe "the abort handler of each uses InstrStopFinalize() to accumulate t= he > statics to its parent entry"? I revised this as follows: If multiple QueryInstrumentations are active on the stack (e.g. nested portals), the abort handler of each uses InstrStopFinalize() to accumulate the statistics to the parent entry of either the entry being released, or a previously released entry if it was higher up in the stack, so they compose correctly regardless of release order. i.e. its worth noting that its explicitly not the parent of the stack entry being released, since that parent may already have been released itself (since cleanup can be out of order). > > +Memory Handling > > +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D > > + > > +Instrumentation objects that use the stack must survive until finaliza= tion > > +runs, including the abort case. To ensure this, QueryInstrumentation > > +creates a dedicated "Instrumentation" MemoryContext (instr_cxt) as a c= hild > > +of TopMemoryContext. All child instrumentation (nodes, triggers) shou= ld be > > +allocated in this context. > > > +On successful completion, instr_cxt is reparented to CurrentMemoryCont= ext > > +so its lifetime is tied to the caller's context. On abort, the > > +ResourceOwner cleanup frees it after accumulating the instrumentation = data > > +to the current stack entry after resetting the stack. > > Makes sense. > > I mildly wonder if we should create one minimally sized "Instrumentations= " > node under TopMemoryContext, below which the "Instrumentation" contexts a= re > created, instead of doing so directly under TopMemoryContext. But that's > something that can easily be evolved later. > Sure, grouping the instrumentation memory contexts could make sense, though the existing handling already serves the purpose of clearly showing when there is an instrumentation leak. I'll not make this change for now to avoid code churn, but as you note we could always adjust that part later. > > > @@ -247,9 +248,19 @@ standard_ExecutorStart(QueryDesc *queryDesc, int e= flags) > > estate->es_snapshot =3D RegisterSnapshot(queryDesc->snapshot); > > estate->es_crosscheck_snapshot =3D RegisterSnapshot(queryDesc->cr= osscheck_snapshot); > > estate->es_top_eflags =3D eflags; > > - estate->es_instrument =3D queryDesc->instrument_options; > > estate->es_jit_flags =3D queryDesc->plannedstmt->jitFlags; > > > > + /* > > + * Set up query-level instrumentation if needed. We do this befor= e > > + * InitPlan so that node and trigger instrumentation can be alloc= ated > > + * within the query's dedicated instrumentation memory context. > > + */ > > + if (!queryDesc->totaltime && queryDesc->instrument_options) > > + { > > + queryDesc->totaltime =3D InstrQueryAlloc(queryDesc->instr= ument_options); > > + estate->es_instrument =3D queryDesc->totaltime; > > + } > > + > > /* > > * Set up an AFTER-trigger statement context, unless told not to,= or > > * unless it's EXPLAIN-only mode (when ExecutorFinish won't be ca= lled). > > It seems pretty weird to still have queryDesc->totaltime *sometimes* crea= ted > by pgss etc, but also create it in standard_ExecutorStart if not already > created. What if the explain options aren't compatible? Sure > pgss/auto_explain use ALL, but that's not a given. Yeah, I think in practice all use cases I've ever seen pass INSTRUMENT_ALL (and in fact it won't behave sane if this differs between extensions), but you're right there is no guarantee. Overall, there are two aspects to this: 1) Query instrumentation as the parent for node instrumentation, driven by use of EXPLAIN or auto_explain setting queryDesc->instrument_options 2) Instrumentation as a mechanism to measure the activity of a query, as used by pg_stat_statements or auto_explain (to get the runtime / aggregate buffer usage) I could see two solutions: A) Keep two separate QueryInstrumentations (EXPLAIN/auto_explain get es_instrument, any extensions measuring aggregate activity get query->totaltime) B) Have one internal QueryInstrumentation (that's responsible to be the abort "parent" to both node instrumentation, and query->totaltime) I was initially thinking we could maybe combine them creatively (i.e. expand on what we've done so far), but I'm not sure there is a reasonable design that isn't convoluted. We could also have a way for extensions to "request" a certain level of instrumentation (instead of directly allocating it), but it seems the current hooks are insufficient for that. I've gone with solution (A) for now, with es_instrument being allocated when per-node instrumentation is needed. Obviously that gets us two ResOwner cleanups instead of one when e.g. auto_explain is active, but I think that's still acceptable. It also shows how its easy to do an extra level of nesting with the stack-based instrumentation, without too much expense. With this in place, I do wonder if we should avoid the full memory context setup in InstrQueryAlloc (i.e. instead just make a direct allocation), unless we know that children are going to be attached. The downside of that would be that we can't just re-assign the instr_cxt in InstrQueryStopFinalize (we'd have to go back to the previous logic of doing a memcpy into the callers context, for the no-children case), but it might make a notable performance difference? > > > + /* Start up instrumentation for this execution run */ > > if (queryDesc->totaltime) > > - InstrStart(queryDesc->totaltime); > > + { > > + InstrQueryStart(queryDesc->totaltime); > > + > > + /* > > + * Remember all node entries for abort recovery. We do th= is once here > > + * after InstrQueryStart has pushed the parent stack entr= y. > > + */ > > + if (estate->es_instrument && > > + estate->es_instrument->instr.need_stack && > > + !queryDesc->already_executed) > > + ExecRememberNodeInstrumentation(queryDesc->planst= ate, > > + = queryDesc->totaltime); > > + } > > Hm. Was briefly worried about the overhead of > ExecRememberNodeInstrumentation() in the context of cursors. But I see it= 's > only done once. > > But why do we not just associate the NodeInstrumentation's with the > QueryInstrumentation during the creation of the NodeInstrumentation? That's a good point - if I recall correctly that was structured differently in an earlier commit, hence the complexity. But this is no longer necessary, and allows us to drop the ExecRememberNodeInstrumentation machinery. Nice :) > > > + /* > > + * Accumulate per-node and trigger statistics to their respective= parent > > + * instrumentation stacks. > > > > + * We skip this in parallel workers because their per-node stats = are > > + * reported individually via ExecParallelReportInstrumentation, a= nd the > > + * leader's own ExecFinalizeNodeInstrumentation handles propagati= on. If > > + * we accumulated here, the leader would double-count: worker par= ent nodes > > + * would already include their children's stats, and then the lea= der's > > + * accumulation would add the children again. > > + */ > > Haven't looked into how this all works in sufficient detail, so I'm just > asking you: This works correctly even when using EXPLAIN (ANALYZE, VERBOS= E) > showing per-worker "subtrees"? Yeah, that's a good question, and you indeed found a bug - that was not correctly accumulating up for the per-worker node information. The main complexity here is the avoidance of double counting. I can think of two very different approaches to solve this: 1) Have finalization only be responsible for accumulating into the overall query instrumentation (or whichever instrumentation is active), and not bother with adding per-node instrumentation to the parent node at all. Then, in explain.c, do the accumulation. If we ever wanted to invent a "BUFFERS SELF" type option (i.e. don't add them to the parent), that would be the way to go. It'd also make it easier to support accumulation for other types of statistics being added (e.g. "EXPLAIN (IO)"). 2) Specifically walk the worker instrumentation after it has been retrieved (to avoid double counting), and add to each nodes parents. For now I've gone with (2) and added a dedicated ExecFinalizeWorkerInstrumentation function to deal with this. > > > > @@ -1284,8 +1325,8 @@ InitResultRelInfo(ResultRelInfo *resultRelInfo, > > palloc0_array(FmgrInfo, n); > > resultRelInfo->ri_TrigWhenExprs =3D (ExprState **) > > palloc0_array(ExprState *, n); > > - if (instrument_options) > > - resultRelInfo->ri_TrigInstrument =3D InstrAllocTr= igger(n, instrument_options); > > + if (qinstr) > > + resultRelInfo->ri_TrigInstrument =3D InstrAllocTr= igger(qinstr, n); > > Hm. Why do we not need to pass down the instrument_options anymore? I gue= ss > the assumption is that we always are going to use the flags from qinstr? > > Is that right? Because right now pgss/auto_explain use _ALL, even when an > EXPLAIN ANALYZE doesn't. > With the solution mentioned earlier, where es_instrument is a separate allocation, this problem now goes away without any extra changes needed. Overall, I think its reasonable to make node/trigger instrumentation be attached to a query instrumentation that has the instrumentation options set that should be applied. That way we don't have think about edge cases like a query instrumentation that doesn't need a stack, but children that do. > > > @@ -1081,14 +1081,28 @@ ExecParallelRetrieveInstrumentation(PlanState *= planstate, > > instrument =3D GetInstrumentationArray(instrumentation); > > instrument +=3D i * instrumentation->num_workers; > > for (n =3D 0; n < instrumentation->num_workers; ++n) > > + { > > InstrAggNode(planstate->instrument, &instrument[n]); > > > > + /* > > + * Also add worker WAL usage to the global pgWalUsage cou= nter. > > + * > > + * When per-node instrumentation is active, parallel work= ers skip > > + * ExecFinalizeNodeInstrumentation (to avoid double-count= ing in > > + * EXPLAIN), so per-node WAL activity is not rolled up in= to the > > + * query-level stats that InstrAccumParallelQuery receive= s. Without > > + * this, pgWalUsage would under-report WAL generated by p= arallel > > + * workers when instrumentation is active. > > + */ > > + WalUsageAdd(&pgWalUsage, &instrument[n].instr.walusage); > > + } > > I'm not sure I understand why this doesn't also lead to double counting, = given > that InstrAccumParallelQuery() does also add the worker's usage to pgWalU= sage? > That can be explained by the somewhat hard to follow difference between InstrAccumParallelQuery and InstrAggNode, which is a pre-existing situation: InstrAccumParallelQuery is used for accumulating the top level worker instrumentation into the instrumentation that's active when ExecParallelFinish runs. The active instrumentation at that point is either the query's instrumentation (or if not used, instr_top), or the Gather node. InstrAggNode is used for accumulating each worker's per-node instrumentation into the leader's per-node instrumentation. When per-node instrumentation is active (node->instrument is initialized), the WalUsageAdd occurs in both InstrAccumParallelQuery and InstrAggNode - but per the comment in standard_ExecutorFinish, we don't aggregate the per-node instrumentation to the top level of the parallel worker - and therefore InstrAccumParallelQuery would report basically no activity. I tried to explain this in the comment above WalUsageAdd, but maybe this needs further clarification? > > > +static bool > > +ExecFinalizeNodeInstrumentation_walker(PlanState *node, void *context) > > +{ > > + Instrumentation *parent =3D (Instrumentation *) context; > > + > > + Assert(parent !=3D NULL); > > + > > + if (node =3D=3D NULL) > > + return false; > > + > > + /* > > + * Recurse into children first (bottom-up accumulation), passing = our > > + * instrumentation as the parent context. This ensures children = can > > + * accumulate to us even if they were never executed by the leade= r (e.g. > > + * nodes beneath Gather that only workers ran). > > + */ > > + planstate_tree_walker(node, ExecFinalizeNodeInstrumentation_walke= r, > > + node->instrument ? &nod= e->instrument->instr : parent); > > I don't think I understand that comment. What changes if the leader's no= de > was never executed? I think that was a timing issue in an earlier iteration, where the stack-based instrumentation data was a separate allocation from the main node instrumentation. Since that is no longer an issue, we can just require node->instrument to be initialized here. Reworded the comment and added an assert. > > > diff --git a/src/backend/executor/instrument.c b/src/backend/executor/i= nstrument.c > > index bc551f95a08..6892706a83a 100644 > > --- a/src/backend/executor/instrument.c > > +++ b/src/backend/executor/instrument.c > > @@ -16,30 +16,46 @@ > > #include > > > > #include "executor/instrument.h" > > +#include "utils/memutils.h" > > +#include "utils/resowner.h" > > > > -BufferUsage pgBufferUsage; > > -static BufferUsage save_pgBufferUsage; > > WalUsage pgWalUsage; > > Why do we still need pgWalUsage if we have the same data in instr_stack. Yeah. That is because of two reasons: 1) The questionable use of pgWalUsage to inform pruneheap.c whether an FPI occurred. I think using pgWalUsage for this is just wrong, it should use its own flag/counter. This can't use the top level instrumentation stack since it'd be updated too late (only on executor finish, not as writes are going on). 2) The use of pgWalUsage to update cumulative WAL usage statistics. We could adjust this by having separate "pgstat_count_wal_.." functions (mirroring how we deal with cumulative buffer usage statistics), or by pulling the information from instrumentation stack and accepting that WAL statistics won't be refreshed whilst a query is executing (which is probably not okay? i.e. we might then have to invent some mechanism to periodically "flush" before the actual finalize). Addressing (1) would be somewhat straightforward, so maybe the best way fowrard is to do that, and then refactor this to use separate "pgstat_count_wal_.." functions instead of keeping the pgWalUsage global. I'll not do that here for now, since I don't think the double writing of WAL stats is performance critical, and we'd still do that anyway when having separate "pgstat_count_wal_.." functions. > > > +/* > > + * Stops instrumentation, finalizes the stack entry and accumulates to= its parent. > > + * > > + * Note that this intentionally allows passing a stack that is not the= current > > + * top, as can happen with PG_FINALLY, or resource owners, which don't= have a > > + * guaranteed cleanup order. > > + * > > + * We are careful here to achieve two goals: > > + * > > + * 1) Reset the stack to the parent of whichever of the released stack= entries > > + * has the lowest index > > + * 2) Accumulate all instrumentation to the currently active instrumen= tation, > > + * so that callers get a complete picture of activity, even after a= n abort > > + */ > > +void > > +InstrStopFinalize(Instrumentation *instr) > > +{ > > + int idx =3D -1; > > + > > + for (int i =3D instr_stack.stack_size - 1; i >=3D 0; i--) > > + { > > + if (instr_stack.entries[i] =3D=3D instr) > > + { > > + idx =3D i; > > + break; > > + } > > + } > > So this may not find a stack entry, because a prior call to > InstrStopFinalize() already removed it from the stack, right? > > Makes it a bit more error prone. Maybe we should store whether the elemen= t is > still on the stack in the Instrumentation, that way we a) can error out i= f we > don't find it on the stack b) avoid searching the stack if already remove= d. Yeah, that seems doable, added that as suggested. It does add an extra instruction to InstrPushStack/InstrPopStack, but that's probably not significant enough. We could always turn it into an assert-only check if that's the case. > > if (instr->need_timer) > > + InstrStopTimer(instr); > > + > > + InstrAccumStack(instr_stack.current, instr); > > +} > > Not that it's a huge issue, but seems like it'd be neater if the need_tim= er > thing weren't duplicated, but implemented by calling InstrStop()? That'd be a problem since InstrStop also pops the stack (if need_stack=3Dtrue), and InstrStopFinalize already popped the stack right before. I think the only alternative here would be adding a flag on InstrStop, but that seems worse to me. > > > +void > > +InstrQueryStart(QueryInstrumentation *qinstr) > > +{ > > + InstrStart(&qinstr->instr); > > + > > + if (qinstr->instr.need_stack) > > + { > > + Assert(CurrentResourceOwner !=3D NULL); > > + qinstr->owner =3D CurrentResourceOwner; > > + > > + ResourceOwnerEnlarge(qinstr->owner); > > + ResourceOwnerRememberInstrumentation(qinstr->owner, qinst= r); > > + } > > +} > > + > > +void > > +InstrQueryStop(QueryInstrumentation *qinstr) > > +{ > > + InstrStop(&qinstr->instr); > > + > > + if (qinstr->instr.need_stack) > > + { > > + Assert(qinstr->owner !=3D NULL); > > + ResourceOwnerForgetInstrumentation(qinstr->owner, qinstr)= ; > > + qinstr->owner =3D NULL; > > + } > > +} > > + > > +void > > +InstrQueryStopFinalize(QueryInstrumentation *qinstr) > > +{ > > + InstrStopFinalize(&qinstr->instr); > > Why are these Instr[Query]StopFinalize() rather than just > Instr[Query]Finalize()? If you're coming at this from a naming perspective: Mainly to make it clear that these both stop the instrumentation, and finalize it. If we only called it "Instr[Query]Finalize" it wouldn't be clear that there isn't a missing "Stop" call. Alternatively we could: 1) Require callers to do two separate function calls 2) Have a "finalize" argument to the Stop function. I had that in a prior iteration, but felt it was easier to miss the subtle true/false difference. > > +/* start instrumentation during parallel executor startup */ > > +QueryInstrumentation * > > +InstrStartParallelQuery(void) > > +{ > > + QueryInstrumentation *qinstr =3D InstrQueryAlloc(INSTRUMENT_BUFFE= RS | INSTRUMENT_WAL); > > + > > + InstrQueryStart(qinstr); > > + return qinstr; > > +} > > Why do we hardcode INSTRUMENT_BUFFERS | INSTRUMENT_WAL? > That's reflecting the fact that parallel workers can only transport these two instrumentation types. The 0006 patch removes that hardcoding. I'll add a comment in the earlier patch for now, for clarity. > > > From 16e44d5508f91dd23da780901f3ec0126965628d Mon Sep 17 00:00:00 2001 > > From: Lukas Fittl > > Date: Sat, 7 Mar 2026 17:52:24 -0800 > > Subject: [PATCH v12 7/9] instrumentation: Optimize ExecProcNodeInstr > > instructions by inlining > > > > For most queries, the bulk of the overhead of EXPLAIN ANALYZE happens i= n > > ExecProcNodeInstr when starting/stopping instrumentation for that node. > > > > Previously each ExecProcNodeInstr would check which instrumentation > > options are active in the InstrStartNode/InstrStopNode calls, and do th= e > > corresponding work (timers, instrumentation stack, etc.). These > > conditionals being checked for each tuple being emitted add up, and cau= se > > non-optimal set of instructions to be generated by the compiler. > > > > Because we already have an existing mechanism to specify a function > > pointer when instrumentation is enabled, we can instead create speciali= zed > > functions that are tailored to the instrumentation options enabled, and > > avoid conditionals on subsequent ExecProcNodeInstr calls. This results = in > > the overhead for EXPLAIN (ANALYZE, TIMING OFF, BUFFERS OFF) for a stres= s > > test with a large COUNT(*) that does many ExecProcNode calls from ~ 20%= on > > top of actual runtime to ~ 3%. When using BUFFERS ON the same query goe= s > > from ~ 20% to ~ 10% on top of actual runtime. > > I assume this is to a significant degree due to to allowing for inlining.= Have > you checked how much of the effort you get by just putting ExecProcNodeIn= str() > into instrument.c? Worth a try - I haven't tested that yet - I'll come back to this separately and verify how much that buys us, vs spelling out the different variants. > > > @@ -1014,7 +1016,9 @@ EXPLAIN ANALYZE SELECT * FROM polygon_tbl WHERE f= 1 @> polygon '(0.5,2.0)'; > > then rejected by a recheck of the index condition. This happens b= ecause a > > GiST index is lossy for polygon containment tests: = it actually > > returns the rows with polygons that overlap the target, and then w= e have > > - to do the exact containment test on those rows. > > + to do the exact containment test on those rows. The Table= Buffers > > + counts indicate how many operations were performed on the table in= stead of > > + the index. This number is included in the Buffers counts. > > > > > > > > I wonder if listing "Index Buffers" separately, instead of "Table Buffers= " > would make more sense, because normally the number of index accesses is m= uch > smaller and therefore a bit easier to put into relation to "Buffers". > I don't think changing this to be focused on index buffers makes sense (but my opinion is weakly held). My arguments for why it doesn't make sense: 1) The primary activity of the node is the index (only) scan. The fact that it also does table access is what we're trying to call out, just like we're calling out heap fetches. 2) For index only scans the inverse of what you noted is true, i.e. you'd expect many more index buffers with very little table buffers. The fact that there were any table buffers at all is worth calling out. > > > @@ -165,11 +169,22 @@ IndexOnlyNext(IndexOnlyScanState *node) > > ItemPointerGetBlo= ckNumber(tid), > > &node->ioss_VMBuf= fer)) > > { > > + bool found; > > + > > /* > > * Rats, we have to visit the heap to check visib= ility. > > */ > > InstrCountTuples2(node, 1); > > - if (!index_fetch_heap(scandesc, node->ioss_TableS= lot)) > > + > > + if (table_instr) > > + InstrPushStack(table_instr); > > + > > + found =3D index_fetch_heap(scandesc, node->ioss_T= ableSlot); > > + > > + if (table_instr) > > + InstrPopStack(table_instr); > > + > > + if (!found) > > continue; /* no visible tup= le, try next index entry */ > > > > ExecClearTuple(node->ioss_TableSlot); > > As-is this will unfortunately rather terribly conflict with the way the i= ndex > prefetching patch is restructuring things, as after it neither index nor > indexonly scan does the equivalent of index_fetch_heap() anymore. This a= ll > goes through a tableam interface, which in turn will call to the index to= get > the tids (to allow for tableam specific prefetching logic, obviously). > > I think this would require putting this into the IndexScanDesc via the > IndexScanInstrumentation etc. > > > Might be good for you to look at how that stuff works after the index > prefetching patch and comment if you see a problem. Agreed, I'll look at that tomorrow. Well, today, I suppose, looking at the clock.. Thanks, Lukas -- Lukas Fittl --0000000000006d0cb0064eb5be7d Content-Type: application/octet-stream; name="v13-0002-instrumentation-Separate-per-node-logic-from-oth.patch" Content-Disposition: attachment; filename="v13-0002-instrumentation-Separate-per-node-logic-from-oth.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mnlqag5g1 RnJvbSBiZjYyMDY0MzIzODMyN2RkNmFhNTE5MmFhNDk0MGI1ZmY1NzkxMzI4IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBMdWthcyBGaXR0bCA8bHVrYXNAZml0dGwuY29tPgpEYXRlOiBT YXQsIDcgTWFyIDIwMjYgMDE6MTk6NTAgLTA4MDAKU3ViamVjdDogW1BBVENIIHYxMyAwMi8xMl0g aW5zdHJ1bWVudGF0aW9uOiBTZXBhcmF0ZSBwZXItbm9kZSBsb2dpYyBmcm9tIG90aGVyCiB1c2Vz CgpQcmV2aW91c2x5IGRpZmZlcmVudCBwbGFjZXMgKGUuZy4gcXVlcnkgInRvdGFsIHRpbWUiKSB3 ZXJlIHJlcHVycG9zaW5nCnRoZSBJbnN0cnVtZW50YXRpb24gc3RydWN0IGluaXRpYWxseSBpbnRy b2R1Y2VkIGZvciBjYXB0dXJpbmcgcGVyLW5vZGUKc3RhdGlzdGljcyBkdXJpbmcgZXhlY3V0aW9u LiBUaGlzIG92ZXJ1c2Ugb2YgdGhlIHNhbWUgc3RydWN0IGlzIGNvbmZ1c2luZywKZS5nLiBieSBj bHV0dGVyaW5nIGNhbGxzIG9mIEluc3RyU3RhcnROb2RlL0luc3RyU3RvcE5vZGUgaW4gdW5yZWxh dGVkCmNvZGUgcGF0aHMsIGFuZCBwcmV2ZW50cyBmdXR1cmUgcmVmYWN0b3JpbmdzLgoKSW5zdGVh ZCwgc2ltcGxpZnkgdGhlIEluc3RydW1lbnRhdGlvbiBzdHJ1Y3QgdG8gb25seSB0cmFjayB0aW1l IGFuZApXQUwvYnVmZmVyIHVzYWdlLiBTaW1pbGFybHksIGRyb3AgdGhlIHVzZSBvZiBJbnN0ckVu ZExvb3Agb3V0c2lkZSBvZgpwZXItbm9kZSBpbnN0cnVtZW50YXRpb24gLSB0aGVzZSBjYWxscyB3 ZXJlIGFkZGVkIHdpdGhvdXQgYW55IGFwcGFyZW50CmJlbmVmaXQgc2luY2UgdGhlIHJlbGV2YW50 IGZpZWxkcyB3ZXJlIG5ldmVyIHJlYWQuCgpJbnRyb2R1Y2UgdGhlIE5vZGVJbnN0cnVtZW50YXRp b24gc3RydWN0IHRvIGNhcnJ5IGZvcndhcmQgdGhlIHBlci1ub2RlCmluc3RydW1lbnRhdGlvbiBp bmZvcm1hdGlvbi4gV29ya2VySW5zdHJ1bWVudGF0aW9uIGlzIHJlbmFtZWQgdG8KV29ya2VyTm9k ZUluc3RydW1lbnRhdGlvbiBmb3IgY2xhcml0eS4KCkluIHBhc3NpbmcsIGRyb3AgdGhlICJuIiBh cmd1bWVudCB0byBJbnN0ckFsbG9jLCBhcyBhbGwgcmVtYWluaW5nIGNhbGxlcnMKbmVlZCBleGFj dGx5IG9uZSBJbnN0cnVtZW50YXRpb24gc3RydWN0LiBBZGRpdGlvbmFsbHksIGNsYXJpZnkgdGhh dApJbnN0ckFnZ05vZGUgaXMgZXhwZWN0ZWQgdG8gb25seSBydW4gYWZ0ZXIgSW5zdHJFbmRMb29w IChhcyBpdCBkb2VzIGluCnByYWN0aWNlKSwgYW5kIGRyb3AgdW51c2VkIGNvZGUuCgpBdXRob3I6 IEx1a2FzIEZpdHRsIDxsdWthc0BmaXR0bC5jb20+ClJldmlld2VkLWJ5OgpEaXNjdXNzaW9uOgot LS0KIGNvbnRyaWIvYXV0b19leHBsYWluL2F1dG9fZXhwbGFpbi5jICAgICAgICAgICB8ICAgOCAr LQogLi4uL3BnX3N0YXRfc3RhdGVtZW50cy9wZ19zdGF0X3N0YXRlbWVudHMuYyAgIHwgICA4ICst CiBjb250cmliL3Bvc3RncmVzX2Zkdy9wb3N0Z3Jlc19mZHcuYyAgICAgICAgICAgfCAgIDIgKy0K IHNyYy9iYWNrZW5kL2NvbW1hbmRzL2V4cGxhaW4uYyAgICAgICAgICAgICAgICB8ICAyMCArLS0K IHNyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNNYWluLmMgICAgICAgICAgICAgICB8ICAgOCArLQog c3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY1BhcmFsbGVsLmMgICAgICAgICAgIHwgIDI0ICstLQog c3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY1Byb2Nub2RlLmMgICAgICAgICAgIHwgICA0ICstCiBz cmMvYmFja2VuZC9leGVjdXRvci9pbnN0cnVtZW50LmMgICAgICAgICAgICAgfCAxNTggKysrKysr KysrKystLS0tLS0tCiBzcmMvaW5jbHVkZS9leGVjdXRvci9pbnN0cnVtZW50LmggICAgICAgICAg ICAgfCAgNjAgKysrKy0tLQogc3JjL2luY2x1ZGUvbm9kZXMvZXhlY25vZGVzLmggICAgICAgICAg ICAgICAgIHwgICA5ICstCiBzcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdCAgICAgICAg ICAgICAgfCAgIDMgKy0KIDExIGZpbGVzIGNoYW5nZWQsIDE3OSBpbnNlcnRpb25zKCspLCAxMjUg ZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvY29udHJpYi9hdXRvX2V4cGxhaW4vYXV0b19leHBs YWluLmMgYi9jb250cmliL2F1dG9fZXhwbGFpbi9hdXRvX2V4cGxhaW4uYwppbmRleCBlODU2Y2Qz NWE2Zi4uMzliZjI1NDNiNzAgMTAwNjQ0Ci0tLSBhL2NvbnRyaWIvYXV0b19leHBsYWluL2F1dG9f ZXhwbGFpbi5jCisrKyBiL2NvbnRyaWIvYXV0b19leHBsYWluL2F1dG9fZXhwbGFpbi5jCkBAIC0z MTUsNyArMzE1LDcgQEAgZXhwbGFpbl9FeGVjdXRvclN0YXJ0KFF1ZXJ5RGVzYyAqcXVlcnlEZXNj LCBpbnQgZWZsYWdzKQogCQkJTWVtb3J5Q29udGV4dCBvbGRjeHQ7CiAKIAkJCW9sZGN4dCA9IE1l bW9yeUNvbnRleHRTd2l0Y2hUbyhxdWVyeURlc2MtPmVzdGF0ZS0+ZXNfcXVlcnlfY3h0KTsKLQkJ CXF1ZXJ5RGVzYy0+dG90YWx0aW1lID0gSW5zdHJBbGxvYygxLCBJTlNUUlVNRU5UX0FMTCwgZmFs c2UpOworCQkJcXVlcnlEZXNjLT50b3RhbHRpbWUgPSBJbnN0ckFsbG9jKElOU1RSVU1FTlRfQUxM KTsKIAkJCU1lbW9yeUNvbnRleHRTd2l0Y2hUbyhvbGRjeHQpOwogCQl9CiAJfQpAQCAtMzgxLDEy ICszODEsNiBAQCBleHBsYWluX0V4ZWN1dG9yRW5kKFF1ZXJ5RGVzYyAqcXVlcnlEZXNjKQogCQkg Ki8KIAkJb2xkY3h0ID0gTWVtb3J5Q29udGV4dFN3aXRjaFRvKHF1ZXJ5RGVzYy0+ZXN0YXRlLT5l c19xdWVyeV9jeHQpOwogCi0JCS8qCi0JCSAqIE1ha2Ugc3VyZSBzdGF0cyBhY2N1bXVsYXRpb24g aXMgZG9uZS4gIChOb3RlOiBpdCdzIG9rYXkgaWYgc2V2ZXJhbAotCQkgKiBsZXZlbHMgb2YgaG9v ayBhbGwgZG8gdGhpcy4pCi0JCSAqLwotCQlJbnN0ckVuZExvb3AocXVlcnlEZXNjLT50b3RhbHRp bWUpOwotCiAJCS8qIExvZyBwbGFuIGlmIGR1cmF0aW9uIGlzIGV4Y2VlZGVkLiAqLwogCQltc2Vj ID0gSU5TVFJfVElNRV9HRVRfTUlMTElTRUMocXVlcnlEZXNjLT50b3RhbHRpbWUtPnRvdGFsKTsK IAkJaWYgKG1zZWMgPj0gYXV0b19leHBsYWluX2xvZ19taW5fZHVyYXRpb24pCmRpZmYgLS1naXQg YS9jb250cmliL3BnX3N0YXRfc3RhdGVtZW50cy9wZ19zdGF0X3N0YXRlbWVudHMuYyBiL2NvbnRy aWIvcGdfc3RhdF9zdGF0ZW1lbnRzL3BnX3N0YXRfc3RhdGVtZW50cy5jCmluZGV4IDU0OTRkNDFk Y2ExLi5mYmYzMmYwZTcyYyAxMDA2NDQKLS0tIGEvY29udHJpYi9wZ19zdGF0X3N0YXRlbWVudHMv cGdfc3RhdF9zdGF0ZW1lbnRzLmMKKysrIGIvY29udHJpYi9wZ19zdGF0X3N0YXRlbWVudHMvcGdf c3RhdF9zdGF0ZW1lbnRzLmMKQEAgLTEwMjUsNyArMTAyNSw3IEBAIHBnc3NfRXhlY3V0b3JTdGFy dChRdWVyeURlc2MgKnF1ZXJ5RGVzYywgaW50IGVmbGFncykKIAkJCU1lbW9yeUNvbnRleHQgb2xk Y3h0OwogCiAJCQlvbGRjeHQgPSBNZW1vcnlDb250ZXh0U3dpdGNoVG8ocXVlcnlEZXNjLT5lc3Rh dGUtPmVzX3F1ZXJ5X2N4dCk7Ci0JCQlxdWVyeURlc2MtPnRvdGFsdGltZSA9IEluc3RyQWxsb2Mo MSwgSU5TVFJVTUVOVF9BTEwsIGZhbHNlKTsKKwkJCXF1ZXJ5RGVzYy0+dG90YWx0aW1lID0gSW5z dHJBbGxvYyhJTlNUUlVNRU5UX0FMTCk7CiAJCQlNZW1vcnlDb250ZXh0U3dpdGNoVG8ob2xkY3h0 KTsKIAkJfQogCX0KQEAgLTEwODQsMTIgKzEwODQsNiBAQCBwZ3NzX0V4ZWN1dG9yRW5kKFF1ZXJ5 RGVzYyAqcXVlcnlEZXNjKQogCWlmIChxdWVyeUlkICE9IElOVDY0Q09OU1QoMCkgJiYgcXVlcnlE ZXNjLT50b3RhbHRpbWUgJiYKIAkJcGdzc19lbmFibGVkKG5lc3RpbmdfbGV2ZWwpKQogCXsKLQkJ LyoKLQkJICogTWFrZSBzdXJlIHN0YXRzIGFjY3VtdWxhdGlvbiBpcyBkb25lLiAgKE5vdGU6IGl0 J3Mgb2theSBpZiBzZXZlcmFsCi0JCSAqIGxldmVscyBvZiBob29rIGFsbCBkbyB0aGlzLikKLQkJ ICovCi0JCUluc3RyRW5kTG9vcChxdWVyeURlc2MtPnRvdGFsdGltZSk7Ci0KIAkJcGdzc19zdG9y ZShxdWVyeURlc2MtPnNvdXJjZVRleHQsCiAJCQkJICAgcXVlcnlJZCwKIAkJCQkgICBxdWVyeURl c2MtPnBsYW5uZWRzdG10LT5zdG10X2xvY2F0aW9uLApkaWZmIC0tZ2l0IGEvY29udHJpYi9wb3N0 Z3Jlc19mZHcvcG9zdGdyZXNfZmR3LmMgYi9jb250cmliL3Bvc3RncmVzX2Zkdy9wb3N0Z3Jlc19m ZHcuYwppbmRleCA0MWU0N2NjNzk1Yi4uY2M4ZWMyNGMzMGUgMTAwNjQ0Ci0tLSBhL2NvbnRyaWIv cG9zdGdyZXNfZmR3L3Bvc3RncmVzX2Zkdy5jCisrKyBiL2NvbnRyaWIvcG9zdGdyZXNfZmR3L3Bv c3RncmVzX2Zkdy5jCkBAIC0yNzc5LDcgKzI3NzksNyBAQCBwb3N0Z3Jlc0l0ZXJhdGVEaXJlY3RN b2RpZnkoRm9yZWlnblNjYW5TdGF0ZSAqbm9kZSkKIAlpZiAoIXJlc3VsdFJlbEluZm8tPnJpX3By b2plY3RSZXR1cm5pbmcpCiAJewogCQlUdXBsZVRhYmxlU2xvdCAqc2xvdCA9IG5vZGUtPnNzLnNz X1NjYW5UdXBsZVNsb3Q7Ci0JCUluc3RydW1lbnRhdGlvbiAqaW5zdHIgPSBub2RlLT5zcy5wcy5p bnN0cnVtZW50OworCQlOb2RlSW5zdHJ1bWVudGF0aW9uICppbnN0ciA9IG5vZGUtPnNzLnBzLmlu c3RydW1lbnQ7CiAKIAkJQXNzZXJ0KCFkbXN0YXRlLT5oYXNfcmV0dXJuaW5nKTsKIApkaWZmIC0t Z2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvZXhwbGFpbi5jIGIvc3JjL2JhY2tlbmQvY29tbWFu ZHMvZXhwbGFpbi5jCmluZGV4IGViNmVmMjNjMmQ2Li5lNzNkYzEyOTEzMiAxMDA2NDQKLS0tIGEv c3JjL2JhY2tlbmQvY29tbWFuZHMvZXhwbGFpbi5jCisrKyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRz L2V4cGxhaW4uYwpAQCAtMTgzNyw3ICsxODM3LDcgQEAgRXhwbGFpbk5vZGUoUGxhblN0YXRlICpw bGFuc3RhdGUsIExpc3QgKmFuY2VzdG9ycywKIAl7CiAJCWRvdWJsZQkJbmxvb3BzID0gcGxhbnN0 YXRlLT5pbnN0cnVtZW50LT5ubG9vcHM7CiAJCWRvdWJsZQkJc3RhcnR1cF9tcyA9IElOU1RSX1RJ TUVfR0VUX01JTExJU0VDKHBsYW5zdGF0ZS0+aW5zdHJ1bWVudC0+c3RhcnR1cCkgLyBubG9vcHM7 Ci0JCWRvdWJsZQkJdG90YWxfbXMgPSBJTlNUUl9USU1FX0dFVF9NSUxMSVNFQyhwbGFuc3RhdGUt Pmluc3RydW1lbnQtPnRvdGFsKSAvIG5sb29wczsKKwkJZG91YmxlCQl0b3RhbF9tcyA9IElOU1RS X1RJTUVfR0VUX01JTExJU0VDKHBsYW5zdGF0ZS0+aW5zdHJ1bWVudC0+aW5zdHIudG90YWwpIC8g bmxvb3BzOwogCQlkb3VibGUJCXJvd3MgPSBwbGFuc3RhdGUtPmluc3RydW1lbnQtPm50dXBsZXMg LyBubG9vcHM7CiAKIAkJaWYgKGVzLT5mb3JtYXQgPT0gRVhQTEFJTl9GT1JNQVRfVEVYVCkKQEAg LTE4OTAsMTEgKzE4OTAsMTEgQEAgRXhwbGFpbk5vZGUoUGxhblN0YXRlICpwbGFuc3RhdGUsIExp c3QgKmFuY2VzdG9ycywKIAkvKiBwcmVwYXJlIHBlci13b3JrZXIgZ2VuZXJhbCBleGVjdXRpb24g ZGV0YWlscyAqLwogCWlmIChlcy0+d29ya2Vyc19zdGF0ZSAmJiBlcy0+dmVyYm9zZSkKIAl7Ci0J CVdvcmtlckluc3RydW1lbnRhdGlvbiAqdyA9IHBsYW5zdGF0ZS0+d29ya2VyX2luc3RydW1lbnQ7 CisJCVdvcmtlck5vZGVJbnN0cnVtZW50YXRpb24gKncgPSBwbGFuc3RhdGUtPndvcmtlcl9pbnN0 cnVtZW50OwogCiAJCWZvciAoaW50IG4gPSAwOyBuIDwgdy0+bnVtX3dvcmtlcnM7IG4rKykKIAkJ ewotCQkJSW5zdHJ1bWVudGF0aW9uICppbnN0cnVtZW50ID0gJnctPmluc3RydW1lbnRbbl07CisJ CQlOb2RlSW5zdHJ1bWVudGF0aW9uICppbnN0cnVtZW50ID0gJnctPmluc3RydW1lbnRbbl07CiAJ CQlkb3VibGUJCW5sb29wcyA9IGluc3RydW1lbnQtPm5sb29wczsKIAkJCWRvdWJsZQkJc3RhcnR1 cF9tczsKIAkJCWRvdWJsZQkJdG90YWxfbXM7CkBAIC0xOTAzLDcgKzE5MDMsNyBAQCBFeHBsYWlu Tm9kZShQbGFuU3RhdGUgKnBsYW5zdGF0ZSwgTGlzdCAqYW5jZXN0b3JzLAogCQkJaWYgKG5sb29w cyA8PSAwKQogCQkJCWNvbnRpbnVlOwogCQkJc3RhcnR1cF9tcyA9IElOU1RSX1RJTUVfR0VUX01J TExJU0VDKGluc3RydW1lbnQtPnN0YXJ0dXApIC8gbmxvb3BzOwotCQkJdG90YWxfbXMgPSBJTlNU Ul9USU1FX0dFVF9NSUxMSVNFQyhpbnN0cnVtZW50LT50b3RhbCkgLyBubG9vcHM7CisJCQl0b3Rh bF9tcyA9IElOU1RSX1RJTUVfR0VUX01JTExJU0VDKGluc3RydW1lbnQtPmluc3RyLnRvdGFsKSAv IG5sb29wczsKIAkJCXJvd3MgPSBpbnN0cnVtZW50LT5udHVwbGVzIC8gbmxvb3BzOwogCiAJCQlF eHBsYWluT3BlbldvcmtlcihuLCBlcyk7CkBAIC0yMjkwLDE4ICsyMjkwLDE4IEBAIEV4cGxhaW5O b2RlKFBsYW5TdGF0ZSAqcGxhbnN0YXRlLCBMaXN0ICphbmNlc3RvcnMsCiAKIAkvKiBTaG93IGJ1 ZmZlci9XQUwgdXNhZ2UgKi8KIAlpZiAoZXMtPmJ1ZmZlcnMgJiYgcGxhbnN0YXRlLT5pbnN0cnVt ZW50KQotCQlzaG93X2J1ZmZlcl91c2FnZShlcywgJnBsYW5zdGF0ZS0+aW5zdHJ1bWVudC0+YnVm dXNhZ2UpOworCQlzaG93X2J1ZmZlcl91c2FnZShlcywgJnBsYW5zdGF0ZS0+aW5zdHJ1bWVudC0+ aW5zdHIuYnVmdXNhZ2UpOwogCWlmIChlcy0+d2FsICYmIHBsYW5zdGF0ZS0+aW5zdHJ1bWVudCkK LQkJc2hvd193YWxfdXNhZ2UoZXMsICZwbGFuc3RhdGUtPmluc3RydW1lbnQtPndhbHVzYWdlKTsK KwkJc2hvd193YWxfdXNhZ2UoZXMsICZwbGFuc3RhdGUtPmluc3RydW1lbnQtPmluc3RyLndhbHVz YWdlKTsKIAogCS8qIFByZXBhcmUgcGVyLXdvcmtlciBidWZmZXIvV0FMIHVzYWdlICovCiAJaWYg KGVzLT53b3JrZXJzX3N0YXRlICYmIChlcy0+YnVmZmVycyB8fCBlcy0+d2FsKSAmJiBlcy0+dmVy Ym9zZSkKIAl7Ci0JCVdvcmtlckluc3RydW1lbnRhdGlvbiAqdyA9IHBsYW5zdGF0ZS0+d29ya2Vy X2luc3RydW1lbnQ7CisJCVdvcmtlck5vZGVJbnN0cnVtZW50YXRpb24gKncgPSBwbGFuc3RhdGUt Pndvcmtlcl9pbnN0cnVtZW50OwogCiAJCWZvciAoaW50IG4gPSAwOyBuIDwgdy0+bnVtX3dvcmtl cnM7IG4rKykKIAkJewotCQkJSW5zdHJ1bWVudGF0aW9uICppbnN0cnVtZW50ID0gJnctPmluc3Ry dW1lbnRbbl07CisJCQlOb2RlSW5zdHJ1bWVudGF0aW9uICppbnN0cnVtZW50ID0gJnctPmluc3Ry dW1lbnRbbl07CiAJCQlkb3VibGUJCW5sb29wcyA9IGluc3RydW1lbnQtPm5sb29wczsKIAogCQkJ aWYgKG5sb29wcyA8PSAwKQpAQCAtMjMwOSw5ICsyMzA5LDkgQEAgRXhwbGFpbk5vZGUoUGxhblN0 YXRlICpwbGFuc3RhdGUsIExpc3QgKmFuY2VzdG9ycywKIAogCQkJRXhwbGFpbk9wZW5Xb3JrZXIo biwgZXMpOwogCQkJaWYgKGVzLT5idWZmZXJzKQotCQkJCXNob3dfYnVmZmVyX3VzYWdlKGVzLCAm aW5zdHJ1bWVudC0+YnVmdXNhZ2UpOworCQkJCXNob3dfYnVmZmVyX3VzYWdlKGVzLCAmaW5zdHJ1 bWVudC0+aW5zdHIuYnVmdXNhZ2UpOwogCQkJaWYgKGVzLT53YWwpCi0JCQkJc2hvd193YWxfdXNh Z2UoZXMsICZpbnN0cnVtZW50LT53YWx1c2FnZSk7CisJCQkJc2hvd193YWxfdXNhZ2UoZXMsICZp bnN0cnVtZW50LT5pbnN0ci53YWx1c2FnZSk7CiAJCQlFeHBsYWluQ2xvc2VXb3JrZXIobiwgZXMp OwogCQl9CiAJfQpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY01haW4uYyBi L3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNNYWluLmMKaW5kZXggMDIzN2Q4YzNiMWQuLmIwZjYz NmJmOGI2IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjTWFpbi5jCisrKyBi L3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNNYWluLmMKQEAgLTMzMyw3ICszMzMsNyBAQCBzdGFu ZGFyZF9FeGVjdXRvclJ1bihRdWVyeURlc2MgKnF1ZXJ5RGVzYywKIAogCS8qIEFsbG93IGluc3Ry dW1lbnRhdGlvbiBvZiBFeGVjdXRvciBvdmVyYWxsIHJ1bnRpbWUgKi8KIAlpZiAocXVlcnlEZXNj LT50b3RhbHRpbWUpCi0JCUluc3RyU3RhcnROb2RlKHF1ZXJ5RGVzYy0+dG90YWx0aW1lKTsKKwkJ SW5zdHJTdGFydChxdWVyeURlc2MtPnRvdGFsdGltZSk7CiAKIAkvKgogCSAqIGV4dHJhY3QgaW5m b3JtYXRpb24gZnJvbSB0aGUgcXVlcnkgZGVzY3JpcHRvciBhbmQgdGhlIHF1ZXJ5IGZlYXR1cmUu CkBAIC0zODUsNyArMzg1LDcgQEAgc3RhbmRhcmRfRXhlY3V0b3JSdW4oUXVlcnlEZXNjICpxdWVy eURlc2MsCiAJCWRlc3QtPnJTaHV0ZG93bihkZXN0KTsKIAogCWlmIChxdWVyeURlc2MtPnRvdGFs dGltZSkKLQkJSW5zdHJTdG9wTm9kZShxdWVyeURlc2MtPnRvdGFsdGltZSwgZXN0YXRlLT5lc19w cm9jZXNzZWQpOworCQlJbnN0clN0b3AocXVlcnlEZXNjLT50b3RhbHRpbWUpOwogCiAJTWVtb3J5 Q29udGV4dFN3aXRjaFRvKG9sZGNvbnRleHQpOwogfQpAQCAtNDM1LDcgKzQzNSw3IEBAIHN0YW5k YXJkX0V4ZWN1dG9yRmluaXNoKFF1ZXJ5RGVzYyAqcXVlcnlEZXNjKQogCiAJLyogQWxsb3cgaW5z dHJ1bWVudGF0aW9uIG9mIEV4ZWN1dG9yIG92ZXJhbGwgcnVudGltZSAqLwogCWlmIChxdWVyeURl c2MtPnRvdGFsdGltZSkKLQkJSW5zdHJTdGFydE5vZGUocXVlcnlEZXNjLT50b3RhbHRpbWUpOwor CQlJbnN0clN0YXJ0KHF1ZXJ5RGVzYy0+dG90YWx0aW1lKTsKIAogCS8qIFJ1biBNb2RpZnlUYWJs ZSBub2RlcyB0byBjb21wbGV0aW9uICovCiAJRXhlY1Bvc3Rwcm9jZXNzUGxhbihlc3RhdGUpOwpA QCAtNDQ1LDcgKzQ0NSw3IEBAIHN0YW5kYXJkX0V4ZWN1dG9yRmluaXNoKFF1ZXJ5RGVzYyAqcXVl cnlEZXNjKQogCQlBZnRlclRyaWdnZXJFbmRRdWVyeShlc3RhdGUpOwogCiAJaWYgKHF1ZXJ5RGVz Yy0+dG90YWx0aW1lKQotCQlJbnN0clN0b3BOb2RlKHF1ZXJ5RGVzYy0+dG90YWx0aW1lLCAwKTsK KwkJSW5zdHJTdG9wKHF1ZXJ5RGVzYy0+dG90YWx0aW1lKTsKIAogCU1lbW9yeUNvbnRleHRTd2l0 Y2hUbyhvbGRjb250ZXh0KTsKIApkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhl Y1BhcmFsbGVsLmMgYi9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjUGFyYWxsZWwuYwppbmRleCA3 NTUxOTFiNTFlZi4uNzhmNjBjMTUzMGMgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9y L2V4ZWNQYXJhbGxlbC5jCisrKyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNQYXJhbGxlbC5j CkBAIC04Nyw3ICs4Nyw3IEBAIHR5cGVkZWYgc3RydWN0IEZpeGVkUGFyYWxsZWxFeGVjdXRvclN0 YXRlCiAgKiBpbnN0cnVtZW50X29wdGlvbnM6IFNhbWUgbWVhbmluZyBoZXJlIGFzIGluIGluc3Ry dW1lbnQuYy4KICAqCiAgKiBpbnN0cnVtZW50X29mZnNldDogT2Zmc2V0LCByZWxhdGl2ZSB0byB0 aGUgc3RhcnQgb2YgdGhpcyBzdHJ1Y3R1cmUsCi0gKiBvZiB0aGUgZmlyc3QgSW5zdHJ1bWVudGF0 aW9uIG9iamVjdC4gIFRoaXMgd2lsbCBkZXBlbmQgb24gdGhlIGxlbmd0aCBvZgorICogb2YgdGhl IGZpcnN0IE5vZGVJbnN0cnVtZW50YXRpb24gb2JqZWN0LiAgVGhpcyB3aWxsIGRlcGVuZCBvbiB0 aGUgbGVuZ3RoIG9mCiAgKiB0aGUgcGxhbl9ub2RlX2lkIGFycmF5LgogICoKICAqIG51bV93b3Jr ZXJzOiBOdW1iZXIgb2Ygd29ya2Vycy4KQEAgLTEwNCwxMSArMTA0LDE1IEBAIHN0cnVjdCBTaGFy ZWRFeGVjdXRvckluc3RydW1lbnRhdGlvbgogCWludAkJCW51bV93b3JrZXJzOwogCWludAkJCW51 bV9wbGFuX25vZGVzOwogCWludAkJCXBsYW5fbm9kZV9pZFtGTEVYSUJMRV9BUlJBWV9NRU1CRVJd OwotCS8qIGFycmF5IG9mIG51bV9wbGFuX25vZGVzICogbnVtX3dvcmtlcnMgSW5zdHJ1bWVudGF0 aW9uIG9iamVjdHMgZm9sbG93cyAqLworCisJLyoKKwkgKiBhcnJheSBvZiBudW1fcGxhbl9ub2Rl cyAqIG51bV93b3JrZXJzIE5vZGVJbnN0cnVtZW50YXRpb24gb2JqZWN0cworCSAqIGZvbGxvd3MK KwkgKi8KIH07CiAjZGVmaW5lIEdldEluc3RydW1lbnRhdGlvbkFycmF5KHNlaSkgXAogCShTdGF0 aWNBc3NlcnRWYXJpYWJsZUlzT2ZUeXBlTWFjcm8oc2VpLCBTaGFyZWRFeGVjdXRvckluc3RydW1l bnRhdGlvbiAqKSwgXAotCSAoSW5zdHJ1bWVudGF0aW9uICopICgoKGNoYXIgKikgc2VpKSArIHNl aS0+aW5zdHJ1bWVudF9vZmZzZXQpKQorCSAoTm9kZUluc3RydW1lbnRhdGlvbiAqKSAoKChjaGFy ICopIHNlaSkgKyBzZWktPmluc3RydW1lbnRfb2Zmc2V0KSkKIAogLyogQ29udGV4dCBvYmplY3Qg Zm9yIEV4ZWNQYXJhbGxlbEVzdGltYXRlLiAqLwogdHlwZWRlZiBzdHJ1Y3QgRXhlY1BhcmFsbGVs RXN0aW1hdGVDb250ZXh0CkBAIC03MzEsNyArNzM1LDcgQEAgRXhlY0luaXRQYXJhbGxlbFBsYW4o UGxhblN0YXRlICpwbGFuc3RhdGUsIEVTdGF0ZSAqZXN0YXRlLAogCQlpbnN0cnVtZW50YXRpb25f bGVuID0gTUFYQUxJR04oaW5zdHJ1bWVudGF0aW9uX2xlbik7CiAJCWluc3RydW1lbnRfb2Zmc2V0 ID0gaW5zdHJ1bWVudGF0aW9uX2xlbjsKIAkJaW5zdHJ1bWVudGF0aW9uX2xlbiArPQotCQkJbXVs X3NpemUoc2l6ZW9mKEluc3RydW1lbnRhdGlvbiksCisJCQltdWxfc2l6ZShzaXplb2YoTm9kZUlu c3RydW1lbnRhdGlvbiksCiAJCQkJCSBtdWxfc2l6ZShlLm5ub2RlcywgbndvcmtlcnMpKTsKIAkJ c2htX3RvY19lc3RpbWF0ZV9jaHVuaygmcGN4dC0+ZXN0aW1hdG9yLCBpbnN0cnVtZW50YXRpb25f bGVuKTsKIAkJc2htX3RvY19lc3RpbWF0ZV9rZXlzKCZwY3h0LT5lc3RpbWF0b3IsIDEpOwpAQCAt ODE3LDcgKzgyMSw3IEBAIEV4ZWNJbml0UGFyYWxsZWxQbGFuKFBsYW5TdGF0ZSAqcGxhbnN0YXRl LCBFU3RhdGUgKmVzdGF0ZSwKIAkgKi8KIAlpZiAoZXN0YXRlLT5lc19pbnN0cnVtZW50KQogCXsK LQkJSW5zdHJ1bWVudGF0aW9uICppbnN0cnVtZW50OworCQlOb2RlSW5zdHJ1bWVudGF0aW9uICpp bnN0cnVtZW50OwogCQlpbnQJCQlpOwogCiAJCWluc3RydW1lbnRhdGlvbiA9IHNobV90b2NfYWxs b2NhdGUocGN4dC0+dG9jLCBpbnN0cnVtZW50YXRpb25fbGVuKTsKQEAgLTgyNyw3ICs4MzEsNyBA QCBFeGVjSW5pdFBhcmFsbGVsUGxhbihQbGFuU3RhdGUgKnBsYW5zdGF0ZSwgRVN0YXRlICplc3Rh dGUsCiAJCWluc3RydW1lbnRhdGlvbi0+bnVtX3BsYW5fbm9kZXMgPSBlLm5ub2RlczsKIAkJaW5z dHJ1bWVudCA9IEdldEluc3RydW1lbnRhdGlvbkFycmF5KGluc3RydW1lbnRhdGlvbik7CiAJCWZv ciAoaSA9IDA7IGkgPCBud29ya2VycyAqIGUubm5vZGVzOyArK2kpCi0JCQlJbnN0ckluaXQoJmlu c3RydW1lbnRbaV0sIGVzdGF0ZS0+ZXNfaW5zdHJ1bWVudCk7CisJCQlJbnN0ckluaXROb2RlKCZp bnN0cnVtZW50W2ldLCBlc3RhdGUtPmVzX2luc3RydW1lbnQpOwogCQlzaG1fdG9jX2luc2VydChw Y3h0LT50b2MsIFBBUkFMTEVMX0tFWV9JTlNUUlVNRU5UQVRJT04sCiAJCQkJCSAgIGluc3RydW1l bnRhdGlvbik7CiAJCXBlaS0+aW5zdHJ1bWVudGF0aW9uID0gaW5zdHJ1bWVudGF0aW9uOwpAQCAt MTA1OSw3ICsxMDYzLDcgQEAgc3RhdGljIGJvb2wKIEV4ZWNQYXJhbGxlbFJldHJpZXZlSW5zdHJ1 bWVudGF0aW9uKFBsYW5TdGF0ZSAqcGxhbnN0YXRlLAogCQkJCQkJCQkJU2hhcmVkRXhlY3V0b3JJ bnN0cnVtZW50YXRpb24gKmluc3RydW1lbnRhdGlvbikKIHsKLQlJbnN0cnVtZW50YXRpb24gKmlu c3RydW1lbnQ7CisJTm9kZUluc3RydW1lbnRhdGlvbiAqaW5zdHJ1bWVudDsKIAlpbnQJCQlpOwog CWludAkJCW47CiAJaW50CQkJaWJ5dGVzOwpAQCAtMTA4Nyw5ICsxMDkxLDkgQEAgRXhlY1BhcmFs bGVsUmV0cmlldmVJbnN0cnVtZW50YXRpb24oUGxhblN0YXRlICpwbGFuc3RhdGUsCiAJICogU3dp dGNoIGludG8gcGVyLXF1ZXJ5IG1lbW9yeSBjb250ZXh0LgogCSAqLwogCW9sZGNvbnRleHQgPSBN ZW1vcnlDb250ZXh0U3dpdGNoVG8ocGxhbnN0YXRlLT5zdGF0ZS0+ZXNfcXVlcnlfY3h0KTsKLQlp Ynl0ZXMgPSBtdWxfc2l6ZShpbnN0cnVtZW50YXRpb24tPm51bV93b3JrZXJzLCBzaXplb2YoSW5z dHJ1bWVudGF0aW9uKSk7CisJaWJ5dGVzID0gbXVsX3NpemUoaW5zdHJ1bWVudGF0aW9uLT5udW1f d29ya2Vycywgc2l6ZW9mKE5vZGVJbnN0cnVtZW50YXRpb24pKTsKIAlwbGFuc3RhdGUtPndvcmtl cl9pbnN0cnVtZW50ID0KLQkJcGFsbG9jKGlieXRlcyArIG9mZnNldG9mKFdvcmtlckluc3RydW1l bnRhdGlvbiwgaW5zdHJ1bWVudCkpOworCQlwYWxsb2MoaWJ5dGVzICsgb2Zmc2V0b2YoV29ya2Vy Tm9kZUluc3RydW1lbnRhdGlvbiwgaW5zdHJ1bWVudCkpOwogCU1lbW9yeUNvbnRleHRTd2l0Y2hU byhvbGRjb250ZXh0KTsKIAogCXBsYW5zdGF0ZS0+d29ya2VyX2luc3RydW1lbnQtPm51bV93b3Jr ZXJzID0gaW5zdHJ1bWVudGF0aW9uLT5udW1fd29ya2VyczsKQEAgLTEzMTksNyArMTMyMyw3IEBA IEV4ZWNQYXJhbGxlbFJlcG9ydEluc3RydW1lbnRhdGlvbihQbGFuU3RhdGUgKnBsYW5zdGF0ZSwK IHsKIAlpbnQJCQlpOwogCWludAkJCXBsYW5fbm9kZV9pZCA9IHBsYW5zdGF0ZS0+cGxhbi0+cGxh bl9ub2RlX2lkOwotCUluc3RydW1lbnRhdGlvbiAqaW5zdHJ1bWVudDsKKwlOb2RlSW5zdHJ1bWVu dGF0aW9uICppbnN0cnVtZW50OwogCiAJSW5zdHJFbmRMb29wKHBsYW5zdGF0ZS0+aW5zdHJ1bWVu dCk7CiAKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNQcm9jbm9kZS5jIGIv c3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY1Byb2Nub2RlLmMKaW5kZXggZDM1OTc2OTI1YWUuLjEz MmZlMzdlZjYwIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjUHJvY25vZGUu YworKysgYi9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjUHJvY25vZGUuYwpAQCAtNDE0LDggKzQx NCw4IEBAIEV4ZWNJbml0Tm9kZShQbGFuICpub2RlLCBFU3RhdGUgKmVzdGF0ZSwgaW50IGVmbGFn cykKIAogCS8qIFNldCB1cCBpbnN0cnVtZW50YXRpb24gZm9yIHRoaXMgbm9kZSBpZiByZXF1ZXN0 ZWQgKi8KIAlpZiAoZXN0YXRlLT5lc19pbnN0cnVtZW50KQotCQlyZXN1bHQtPmluc3RydW1lbnQg PSBJbnN0ckFsbG9jKDEsIGVzdGF0ZS0+ZXNfaW5zdHJ1bWVudCwKLQkJCQkJCQkJCQlyZXN1bHQt PmFzeW5jX2NhcGFibGUpOworCQlyZXN1bHQtPmluc3RydW1lbnQgPSBJbnN0ckFsbG9jTm9kZShl c3RhdGUtPmVzX2luc3RydW1lbnQsCisJCQkJCQkJCQkJCXJlc3VsdC0+YXN5bmNfY2FwYWJsZSk7 CiAKIAlyZXR1cm4gcmVzdWx0OwogfQpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvZXhlY3V0b3Iv aW5zdHJ1bWVudC5jIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3IvaW5zdHJ1bWVudC5jCmluZGV4IDkz NTRhZDdiZTEyLi5lM2Q4OTBhN2Y5OCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvZXhlY3V0b3Iv aW5zdHJ1bWVudC5jCisrKyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2luc3RydW1lbnQuYwpAQCAt MjYsNTEgKzI2LDMxIEBAIHN0YXRpYyB2b2lkIEJ1ZmZlclVzYWdlQWRkKEJ1ZmZlclVzYWdlICpk c3QsIGNvbnN0IEJ1ZmZlclVzYWdlICphZGQpOwogc3RhdGljIHZvaWQgV2FsVXNhZ2VBZGQoV2Fs VXNhZ2UgKmRzdCwgV2FsVXNhZ2UgKmFkZCk7CiAKIAotLyogQWxsb2NhdGUgbmV3IGluc3RydW1l bnRhdGlvbiBzdHJ1Y3R1cmUocykgKi8KKy8qIEdlbmVyYWwgcHVycG9zZSBpbnN0cnVtZW50YXRp b24gaGFuZGxpbmcgKi8KIEluc3RydW1lbnRhdGlvbiAqCi1JbnN0ckFsbG9jKGludCBuLCBpbnQg aW5zdHJ1bWVudF9vcHRpb25zLCBib29sIGFzeW5jX21vZGUpCitJbnN0ckFsbG9jKGludCBpbnN0 cnVtZW50X29wdGlvbnMpCiB7Ci0JSW5zdHJ1bWVudGF0aW9uICppbnN0cjsKLQotCS8qIGluaXRp YWxpemUgYWxsIGZpZWxkcyB0byB6ZXJvZXMsIHRoZW4gbW9kaWZ5IGFzIG5lZWRlZCAqLwotCWlu c3RyID0gcGFsbG9jMChuICogc2l6ZW9mKEluc3RydW1lbnRhdGlvbikpOwotCWlmIChpbnN0cnVt ZW50X29wdGlvbnMgJiAoSU5TVFJVTUVOVF9CVUZGRVJTIHwgSU5TVFJVTUVOVF9USU1FUiB8IElO U1RSVU1FTlRfV0FMKSkKLQl7Ci0JCWJvb2wJCW5lZWRfYnVmZmVycyA9IChpbnN0cnVtZW50X29w dGlvbnMgJiBJTlNUUlVNRU5UX0JVRkZFUlMpICE9IDA7Ci0JCWJvb2wJCW5lZWRfd2FsID0gKGlu c3RydW1lbnRfb3B0aW9ucyAmIElOU1RSVU1FTlRfV0FMKSAhPSAwOwotCQlib29sCQluZWVkX3Rp bWVyID0gKGluc3RydW1lbnRfb3B0aW9ucyAmIElOU1RSVU1FTlRfVElNRVIpICE9IDA7Ci0JCWlu dAkJCWk7Ci0KLQkJZm9yIChpID0gMDsgaSA8IG47IGkrKykKLQkJewotCQkJaW5zdHJbaV0ubmVl ZF9idWZ1c2FnZSA9IG5lZWRfYnVmZmVyczsKLQkJCWluc3RyW2ldLm5lZWRfd2FsdXNhZ2UgPSBu ZWVkX3dhbDsKLQkJCWluc3RyW2ldLm5lZWRfdGltZXIgPSBuZWVkX3RpbWVyOwotCQkJaW5zdHJb aV0uYXN5bmNfbW9kZSA9IGFzeW5jX21vZGU7Ci0JCX0KLQl9CisJSW5zdHJ1bWVudGF0aW9uICpp bnN0ciA9IHBhbGxvYzAoc2l6ZW9mKEluc3RydW1lbnRhdGlvbikpOwogCisJSW5zdHJJbml0T3B0 aW9ucyhpbnN0ciwgaW5zdHJ1bWVudF9vcHRpb25zKTsKIAlyZXR1cm4gaW5zdHI7CiB9CiAKLS8q IEluaXRpYWxpemUgYSBwcmUtYWxsb2NhdGVkIGluc3RydW1lbnRhdGlvbiBzdHJ1Y3R1cmUuICov CiB2b2lkCi1JbnN0ckluaXQoSW5zdHJ1bWVudGF0aW9uICppbnN0ciwgaW50IGluc3RydW1lbnRf b3B0aW9ucykKK0luc3RySW5pdE9wdGlvbnMoSW5zdHJ1bWVudGF0aW9uICppbnN0ciwgaW50IGlu c3RydW1lbnRfb3B0aW9ucykKIHsKLQltZW1zZXQoaW5zdHIsIDAsIHNpemVvZihJbnN0cnVtZW50 YXRpb24pKTsKIAlpbnN0ci0+bmVlZF9idWZ1c2FnZSA9IChpbnN0cnVtZW50X29wdGlvbnMgJiBJ TlNUUlVNRU5UX0JVRkZFUlMpICE9IDA7CiAJaW5zdHItPm5lZWRfd2FsdXNhZ2UgPSAoaW5zdHJ1 bWVudF9vcHRpb25zICYgSU5TVFJVTUVOVF9XQUwpICE9IDA7CiAJaW5zdHItPm5lZWRfdGltZXIg PSAoaW5zdHJ1bWVudF9vcHRpb25zICYgSU5TVFJVTUVOVF9USU1FUikgIT0gMDsKIH0KIAotLyog RW50cnkgdG8gYSBwbGFuIG5vZGUgKi8KIHZvaWQKLUluc3RyU3RhcnROb2RlKEluc3RydW1lbnRh dGlvbiAqaW5zdHIpCitJbnN0clN0YXJ0KEluc3RydW1lbnRhdGlvbiAqaW5zdHIpCiB7CiAJaWYg KGluc3RyLT5uZWVkX3RpbWVyKQogCXsKIAkJaWYgKCFJTlNUUl9USU1FX0lTX1pFUk8oaW5zdHIt PnN0YXJ0dGltZSkpCi0JCQllbG9nKEVSUk9SLCAiSW5zdHJTdGFydE5vZGUgY2FsbGVkIHR3aWNl IGluIGEgcm93Iik7CisJCQllbG9nKEVSUk9SLCAiSW5zdHJTdGFydCBjYWxsZWQgdHdpY2UgaW4g YSByb3ciKTsKIAkJZWxzZQogCQkJSU5TVFJfVElNRV9TRVRfQ1VSUkVOVChpbnN0ci0+c3RhcnR0 aW1lKTsKIAl9CkBAIC04MywyNCArNjMsMTkgQEAgSW5zdHJTdGFydE5vZGUoSW5zdHJ1bWVudGF0 aW9uICppbnN0cikKIAkJaW5zdHItPndhbHVzYWdlX3N0YXJ0ID0gcGdXYWxVc2FnZTsKIH0KIAot LyogRXhpdCBmcm9tIGEgcGxhbiBub2RlICovCiB2b2lkCi1JbnN0clN0b3BOb2RlKEluc3RydW1l bnRhdGlvbiAqaW5zdHIsIGRvdWJsZSBuVHVwbGVzKQorSW5zdHJTdG9wKEluc3RydW1lbnRhdGlv biAqaW5zdHIpCiB7Ci0JZG91YmxlCQlzYXZlX3R1cGxlY291bnQgPSBpbnN0ci0+dHVwbGVjb3Vu dDsKIAlpbnN0cl90aW1lCWVuZHRpbWU7CiAKLQkvKiBjb3VudCB0aGUgcmV0dXJuZWQgdHVwbGVz ICovCi0JaW5zdHItPnR1cGxlY291bnQgKz0gblR1cGxlczsKLQogCS8qIGxldCdzIHVwZGF0ZSB0 aGUgdGltZSBvbmx5IGlmIHRoZSB0aW1lciB3YXMgcmVxdWVzdGVkICovCiAJaWYgKGluc3RyLT5u ZWVkX3RpbWVyKQogCXsKIAkJaWYgKElOU1RSX1RJTUVfSVNfWkVSTyhpbnN0ci0+c3RhcnR0aW1l KSkKLQkJCWVsb2coRVJST1IsICJJbnN0clN0b3BOb2RlIGNhbGxlZCB3aXRob3V0IHN0YXJ0Iik7 CisJCQllbG9nKEVSUk9SLCAiSW5zdHJTdG9wIGNhbGxlZCB3aXRob3V0IHN0YXJ0Iik7CiAKIAkJ SU5TVFJfVElNRV9TRVRfQ1VSUkVOVChlbmR0aW1lKTsKLQkJSU5TVFJfVElNRV9BQ0NVTV9ESUZG KGluc3RyLT5jb3VudGVyLCBlbmR0aW1lLCBpbnN0ci0+c3RhcnR0aW1lKTsKKwkJSU5TVFJfVElN RV9BQ0NVTV9ESUZGKGluc3RyLT50b3RhbCwgZW5kdGltZSwgaW5zdHItPnN0YXJ0dGltZSk7CiAK IAkJSU5TVFJfVElNRV9TRVRfWkVSTyhpbnN0ci0+c3RhcnR0aW1lKTsKIAl9CkBAIC0xMTMsNiAr ODgsNzQgQEAgSW5zdHJTdG9wTm9kZShJbnN0cnVtZW50YXRpb24gKmluc3RyLCBkb3VibGUgblR1 cGxlcykKIAlpZiAoaW5zdHItPm5lZWRfd2FsdXNhZ2UpCiAJCVdhbFVzYWdlQWNjdW1EaWZmKCZp bnN0ci0+d2FsdXNhZ2UsCiAJCQkJCQkgICZwZ1dhbFVzYWdlLCAmaW5zdHItPndhbHVzYWdlX3N0 YXJ0KTsKK30KKworLyogTm9kZSBpbnN0cnVtZW50YXRpb24gaGFuZGxpbmcgKi8KKworLyogQWxs b2NhdGUgbmV3IG5vZGUgaW5zdHJ1bWVudGF0aW9uIHN0cnVjdHVyZSAqLworTm9kZUluc3RydW1l bnRhdGlvbiAqCitJbnN0ckFsbG9jTm9kZShpbnQgaW5zdHJ1bWVudF9vcHRpb25zLCBib29sIGFz eW5jX21vZGUpCit7CisJTm9kZUluc3RydW1lbnRhdGlvbiAqaW5zdHIgPSBwYWxsb2Moc2l6ZW9m KE5vZGVJbnN0cnVtZW50YXRpb24pKTsKKworCUluc3RySW5pdE5vZGUoaW5zdHIsIGluc3RydW1l bnRfb3B0aW9ucyk7CisJaW5zdHItPmFzeW5jX21vZGUgPSBhc3luY19tb2RlOworCisJcmV0dXJu IGluc3RyOworfQorCisvKiBJbml0aWFsaXplIGEgcHJlLWFsbG9jYXRlZCBpbnN0cnVtZW50YXRp b24gc3RydWN0dXJlLiAqLwordm9pZAorSW5zdHJJbml0Tm9kZShOb2RlSW5zdHJ1bWVudGF0aW9u ICppbnN0ciwgaW50IGluc3RydW1lbnRfb3B0aW9ucykKK3sKKwltZW1zZXQoaW5zdHIsIDAsIHNp emVvZihOb2RlSW5zdHJ1bWVudGF0aW9uKSk7CisJSW5zdHJJbml0T3B0aW9ucygmaW5zdHItPmlu c3RyLCBpbnN0cnVtZW50X29wdGlvbnMpOworfQorCisvKiBFbnRyeSB0byBhIHBsYW4gbm9kZSAq Lwordm9pZAorSW5zdHJTdGFydE5vZGUoTm9kZUluc3RydW1lbnRhdGlvbiAqaW5zdHIpCit7CisJ SW5zdHJTdGFydCgmaW5zdHItPmluc3RyKTsKK30KKworLyogRXhpdCBmcm9tIGEgcGxhbiBub2Rl ICovCit2b2lkCitJbnN0clN0b3BOb2RlKE5vZGVJbnN0cnVtZW50YXRpb24gKmluc3RyLCBkb3Vi bGUgblR1cGxlcykKK3sKKwlkb3VibGUJCXNhdmVfdHVwbGVjb3VudCA9IGluc3RyLT50dXBsZWNv dW50OworCWluc3RyX3RpbWUJZW5kdGltZTsKKworCS8qIGNvdW50IHRoZSByZXR1cm5lZCB0dXBs ZXMgKi8KKwlpbnN0ci0+dHVwbGVjb3VudCArPSBuVHVwbGVzOworCisJLyoKKwkgKiBVcGRhdGUg dGhlIHRpbWUgb25seSBpZiB0aGUgdGltZXIgd2FzIHJlcXVlc3RlZC4KKwkgKgorCSAqIE5vdGUg dGhpcyBpcyBkaWZmZXJlbnQgZnJvbSBJbnN0clN0b3AgYmVjYXVzZSB0b3RhbCBpcyBvbmx5IHVw ZGF0ZWQgaW4KKwkgKiBJbnN0ckVuZExvb3AuIFdlIG5lZWQgdGhlIHNlcGFyYXRlIGNvdW50ZXIg dmFyaWFibGUgYmVjYXVzZSB3ZSBuZWVkIHRvCisJICogY2FsY3VsYXRlIHN0YXJ0LXVwIHRpbWUg Zm9yIHRoZSBmaXJzdCB0dXBsZSBpbiBlYWNoIGN5Y2xlLCBhbmQgdGhlbgorCSAqIGFjY3VtdWxh dGUgaXQgdG9nZXRoZXIuCisJICovCisJaWYgKGluc3RyLT5pbnN0ci5uZWVkX3RpbWVyKQorCXsK KwkJaWYgKElOU1RSX1RJTUVfSVNfWkVSTyhpbnN0ci0+aW5zdHIuc3RhcnR0aW1lKSkKKwkJCWVs b2coRVJST1IsICJJbnN0clN0b3BOb2RlIGNhbGxlZCB3aXRob3V0IHN0YXJ0Iik7CisKKwkJSU5T VFJfVElNRV9TRVRfQ1VSUkVOVChlbmR0aW1lKTsKKwkJSU5TVFJfVElNRV9BQ0NVTV9ESUZGKGlu c3RyLT5jb3VudGVyLCBlbmR0aW1lLCBpbnN0ci0+aW5zdHIuc3RhcnR0aW1lKTsKKworCQlJTlNU Ul9USU1FX1NFVF9aRVJPKGluc3RyLT5pbnN0ci5zdGFydHRpbWUpOworCX0KKworCS8qIEFkZCBk ZWx0YSBvZiBidWZmZXIgdXNhZ2Ugc2luY2UgZW50cnkgdG8gbm9kZSdzIHRvdGFscyAqLworCWlm IChpbnN0ci0+aW5zdHIubmVlZF9idWZ1c2FnZSkKKwkJQnVmZmVyVXNhZ2VBY2N1bURpZmYoJmlu c3RyLT5pbnN0ci5idWZ1c2FnZSwKKwkJCQkJCQkgJnBnQnVmZmVyVXNhZ2UsICZpbnN0ci0+aW5z dHIuYnVmdXNhZ2Vfc3RhcnQpOworCisJaWYgKGluc3RyLT5pbnN0ci5uZWVkX3dhbHVzYWdlKQor CQlXYWxVc2FnZUFjY3VtRGlmZigmaW5zdHItPmluc3RyLndhbHVzYWdlLAorCQkJCQkJICAmcGdX YWxVc2FnZSwgJmluc3RyLT5pbnN0ci53YWx1c2FnZV9zdGFydCk7CiAKIAkvKiBJcyB0aGlzIHRo ZSBmaXJzdCB0dXBsZSBvZiB0aGlzIGN5Y2xlPyAqLwogCWlmICghaW5zdHItPnJ1bm5pbmcpCkBA IC0xMzMsNyArMTc2LDcgQEAgSW5zdHJTdG9wTm9kZShJbnN0cnVtZW50YXRpb24gKmluc3RyLCBk b3VibGUgblR1cGxlcykKIAogLyogVXBkYXRlIHR1cGxlIGNvdW50ICovCiB2b2lkCi1JbnN0clVw ZGF0ZVR1cGxlQ291bnQoSW5zdHJ1bWVudGF0aW9uICppbnN0ciwgZG91YmxlIG5UdXBsZXMpCitJ bnN0clVwZGF0ZVR1cGxlQ291bnQoTm9kZUluc3RydW1lbnRhdGlvbiAqaW5zdHIsIGRvdWJsZSBu VHVwbGVzKQogewogCS8qIGNvdW50IHRoZSByZXR1cm5lZCB0dXBsZXMgKi8KIAlpbnN0ci0+dHVw bGVjb3VudCArPSBuVHVwbGVzOwpAQCAtMTQxLDQ3ICsxODQsNDAgQEAgSW5zdHJVcGRhdGVUdXBs ZUNvdW50KEluc3RydW1lbnRhdGlvbiAqaW5zdHIsIGRvdWJsZSBuVHVwbGVzKQogCiAvKiBGaW5p c2ggYSBydW4gY3ljbGUgZm9yIGEgcGxhbiBub2RlICovCiB2b2lkCi1JbnN0ckVuZExvb3AoSW5z dHJ1bWVudGF0aW9uICppbnN0cikKK0luc3RyRW5kTG9vcChOb2RlSW5zdHJ1bWVudGF0aW9uICpp bnN0cikKIHsKIAkvKiBTa2lwIGlmIG5vdGhpbmcgaGFzIGhhcHBlbmVkLCBvciBhbHJlYWR5IHNo dXQgZG93biAqLwogCWlmICghaW5zdHItPnJ1bm5pbmcpCiAJCXJldHVybjsKIAotCWlmICghSU5T VFJfVElNRV9JU19aRVJPKGluc3RyLT5zdGFydHRpbWUpKQorCWlmICghSU5TVFJfVElNRV9JU19a RVJPKGluc3RyLT5pbnN0ci5zdGFydHRpbWUpKQogCQllbG9nKEVSUk9SLCAiSW5zdHJFbmRMb29w IGNhbGxlZCBvbiBydW5uaW5nIG5vZGUiKTsKIAogCS8qIEFjY3VtdWxhdGUgcGVyLWN5Y2xlIHN0 YXRpc3RpY3MgaW50byB0b3RhbHMgKi8KIAlJTlNUUl9USU1FX0FERChpbnN0ci0+c3RhcnR1cCwg aW5zdHItPmZpcnN0dHVwbGUpOwotCUlOU1RSX1RJTUVfQUREKGluc3RyLT50b3RhbCwgaW5zdHIt PmNvdW50ZXIpOworCUlOU1RSX1RJTUVfQUREKGluc3RyLT5pbnN0ci50b3RhbCwgaW5zdHItPmNv dW50ZXIpOwogCWluc3RyLT5udHVwbGVzICs9IGluc3RyLT50dXBsZWNvdW50OwogCWluc3RyLT5u bG9vcHMgKz0gMTsKIAogCS8qIFJlc2V0IGZvciBuZXh0IGN5Y2xlIChpZiBhbnkpICovCiAJaW5z dHItPnJ1bm5pbmcgPSBmYWxzZTsKLQlJTlNUUl9USU1FX1NFVF9aRVJPKGluc3RyLT5zdGFydHRp bWUpOworCUlOU1RSX1RJTUVfU0VUX1pFUk8oaW5zdHItPmluc3RyLnN0YXJ0dGltZSk7CiAJSU5T VFJfVElNRV9TRVRfWkVSTyhpbnN0ci0+Y291bnRlcik7CiAJSU5TVFJfVElNRV9TRVRfWkVSTyhp bnN0ci0+Zmlyc3R0dXBsZSk7CiAJaW5zdHItPnR1cGxlY291bnQgPSAwOwogfQogCi0vKiBhZ2dy ZWdhdGUgaW5zdHJ1bWVudGF0aW9uIGluZm9ybWF0aW9uICovCisvKgorICogQWdncmVnYXRlIGlu c3RydW1lbnRhdGlvbiBmcm9tIHBhcmFsbGVsIHdvcmtlcnMuIE11c3QgYmUgY2FsbGVkIGFmdGVy CisgKiBJbnN0ckVuZExvb3AuCisgKi8KIHZvaWQKLUluc3RyQWdnTm9kZShJbnN0cnVtZW50YXRp b24gKmRzdCwgSW5zdHJ1bWVudGF0aW9uICphZGQpCitJbnN0ckFnZ05vZGUoTm9kZUluc3RydW1l bnRhdGlvbiAqZHN0LCBOb2RlSW5zdHJ1bWVudGF0aW9uICphZGQpCiB7Ci0JaWYgKCFkc3QtPnJ1 bm5pbmcgJiYgYWRkLT5ydW5uaW5nKQotCXsKLQkJZHN0LT5ydW5uaW5nID0gdHJ1ZTsKLQkJZHN0 LT5maXJzdHR1cGxlID0gYWRkLT5maXJzdHR1cGxlOwotCX0KLQllbHNlIGlmIChkc3QtPnJ1bm5p bmcgJiYgYWRkLT5ydW5uaW5nICYmCi0JCQkgSU5TVFJfVElNRV9HVChkc3QtPmZpcnN0dHVwbGUs IGFkZC0+Zmlyc3R0dXBsZSkpCi0JCWRzdC0+Zmlyc3R0dXBsZSA9IGFkZC0+Zmlyc3R0dXBsZTsK LQotCUlOU1RSX1RJTUVfQUREKGRzdC0+Y291bnRlciwgYWRkLT5jb3VudGVyKTsKKwlBc3NlcnQo IWFkZC0+cnVubmluZyk7CiAKLQlkc3QtPnR1cGxlY291bnQgKz0gYWRkLT50dXBsZWNvdW50Owog CUlOU1RSX1RJTUVfQUREKGRzdC0+c3RhcnR1cCwgYWRkLT5zdGFydHVwKTsKLQlJTlNUUl9USU1F X0FERChkc3QtPnRvdGFsLCBhZGQtPnRvdGFsKTsKKwlJTlNUUl9USU1FX0FERChkc3QtPmluc3Ry LnRvdGFsLCBhZGQtPmluc3RyLnRvdGFsKTsKIAlkc3QtPm50dXBsZXMgKz0gYWRkLT5udHVwbGVz OwogCWRzdC0+bnR1cGxlczIgKz0gYWRkLT5udHVwbGVzMjsKIAlkc3QtPm5sb29wcyArPSBhZGQt Pm5sb29wczsKQEAgLTE4OSwxMSArMjI1LDExIEBAIEluc3RyQWdnTm9kZShJbnN0cnVtZW50YXRp b24gKmRzdCwgSW5zdHJ1bWVudGF0aW9uICphZGQpCiAJZHN0LT5uZmlsdGVyZWQyICs9IGFkZC0+ bmZpbHRlcmVkMjsKIAogCS8qIEFkZCBkZWx0YSBvZiBidWZmZXIgdXNhZ2Ugc2luY2UgZW50cnkg dG8gbm9kZSdzIHRvdGFscyAqLwotCWlmIChkc3QtPm5lZWRfYnVmdXNhZ2UpCi0JCUJ1ZmZlclVz YWdlQWRkKCZkc3QtPmJ1ZnVzYWdlLCAmYWRkLT5idWZ1c2FnZSk7CisJaWYgKGRzdC0+aW5zdHIu bmVlZF9idWZ1c2FnZSkKKwkJQnVmZmVyVXNhZ2VBZGQoJmRzdC0+aW5zdHIuYnVmdXNhZ2UsICZh ZGQtPmluc3RyLmJ1ZnVzYWdlKTsKIAotCWlmIChkc3QtPm5lZWRfd2FsdXNhZ2UpCi0JCVdhbFVz YWdlQWRkKCZkc3QtPndhbHVzYWdlLCAmYWRkLT53YWx1c2FnZSk7CisJaWYgKGRzdC0+aW5zdHIu bmVlZF93YWx1c2FnZSkKKwkJV2FsVXNhZ2VBZGQoJmRzdC0+aW5zdHIud2FsdXNhZ2UsICZhZGQt Pmluc3RyLndhbHVzYWdlKTsKIH0KIAogLyogVHJpZ2dlciBpbnN0cnVtZW50YXRpb24gaGFuZGxp bmcgKi8KQEAgLTIwNCw3ICsyNDAsNyBAQCBJbnN0ckFsbG9jVHJpZ2dlcihpbnQgbiwgaW50IGlu c3RydW1lbnRfb3B0aW9ucykKIAlpbnQJCQlpOwogCiAJZm9yIChpID0gMDsgaSA8IG47IGkrKykK LQkJSW5zdHJJbml0KCZ0Z2luc3RyW2ldLmluc3RyLCBpbnN0cnVtZW50X29wdGlvbnMpOworCQlJ bnN0ckluaXRPcHRpb25zKCZ0Z2luc3RyW2ldLmluc3RyLCBpbnN0cnVtZW50X29wdGlvbnMpOwog CiAJcmV0dXJuIHRnaW5zdHI7CiB9CkBAIC0yMTIsMTMgKzI0OCwxMyBAQCBJbnN0ckFsbG9jVHJp Z2dlcihpbnQgbiwgaW50IGluc3RydW1lbnRfb3B0aW9ucykKIHZvaWQKIEluc3RyU3RhcnRUcmln Z2VyKFRyaWdnZXJJbnN0cnVtZW50YXRpb24gKnRnaW5zdHIpCiB7Ci0JSW5zdHJTdGFydE5vZGUo JnRnaW5zdHItPmluc3RyKTsKKwlJbnN0clN0YXJ0KCZ0Z2luc3RyLT5pbnN0cik7CiB9CiAKIHZv aWQKIEluc3RyU3RvcFRyaWdnZXIoVHJpZ2dlckluc3RydW1lbnRhdGlvbiAqdGdpbnN0ciwgaW50 IGZpcmluZ3MpCiB7Ci0JSW5zdHJTdG9wTm9kZSgmdGdpbnN0ci0+aW5zdHIsIDApOworCUluc3Ry U3RvcCgmdGdpbnN0ci0+aW5zdHIpOwogCXRnaW5zdHItPmZpcmluZ3MgKz0gZmlyaW5nczsKIH0K IApkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvZXhlY3V0b3IvaW5zdHJ1bWVudC5oIGIvc3JjL2lu Y2x1ZGUvZXhlY3V0b3IvaW5zdHJ1bWVudC5oCmluZGV4IGE5YzIyMzMyMjdmLi5iMTFkNjQ2MzNi NSAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvZXhlY3V0b3IvaW5zdHJ1bWVudC5oCisrKyBiL3Ny Yy9pbmNsdWRlL2V4ZWN1dG9yL2luc3RydW1lbnQuaApAQCAtNjcsMzggKzY3LDU1IEBAIHR5cGVk ZWYgZW51bSBJbnN0cnVtZW50T3B0aW9uCiAJSU5TVFJVTUVOVF9BTEwgPSBQR19JTlQzMl9NQVgK IH0gSW5zdHJ1bWVudE9wdGlvbjsKIAorLyoKKyAqIEdlbmVyYWwgcHVycG9zZSBpbnN0cnVtZW50 YXRpb24gdGhhdCBjYW4gY2FwdHVyZSB0aW1lIGFuZCBXQUwvYnVmZmVyIHVzYWdlCisgKgorICog SW5pdGlhbGl6ZWQgdGhyb3VnaCBJbnN0ckFsbG9jLCBmb2xsb3dlZCBieSBvbmUgb3IgbW9yZSBj YWxscyB0byBhIHBhaXIgb2YKKyAqIEluc3RyU3RhcnQvSW5zdHJTdG9wIChhY3Rpdml0eSBpcyBt ZWFzdXJlZCBpbmJldHdlZW4pLgorICovCiB0eXBlZGVmIHN0cnVjdCBJbnN0cnVtZW50YXRpb24K IHsKLQkvKiBQYXJhbWV0ZXJzIHNldCBhdCBub2RlIGNyZWF0aW9uOiAqLworCS8qIFBhcmFtZXRl cnMgc2V0IGF0IGNyZWF0aW9uOiAqLwogCWJvb2wJCW5lZWRfdGltZXI7CQkvKiB0cnVlIGlmIHdl IG5lZWQgdGltZXIgZGF0YSAqLwogCWJvb2wJCW5lZWRfYnVmdXNhZ2U7CS8qIHRydWUgaWYgd2Ug bmVlZCBidWZmZXIgdXNhZ2UgZGF0YSAqLwogCWJvb2wJCW5lZWRfd2FsdXNhZ2U7CS8qIHRydWUg aWYgd2UgbmVlZCBXQUwgdXNhZ2UgZGF0YSAqLworCS8qIEludGVybmFsIHN0YXRlIGtlZXBpbmc6 ICovCisJaW5zdHJfdGltZQlzdGFydHRpbWU7CQkvKiBzdGFydCB0aW1lIG9mIGxhc3QgSW5zdHJT dGFydCAqLworCUJ1ZmZlclVzYWdlIGJ1ZnVzYWdlX3N0YXJ0OyAvKiBidWZmZXIgdXNhZ2UgYXQg c3RhcnQgKi8KKwlXYWxVc2FnZQl3YWx1c2FnZV9zdGFydDsgLyogV0FMIHVzYWdlIGF0IHN0YXJ0 ICovCisJLyogQWNjdW11bGF0ZWQgc3RhdGlzdGljczogKi8KKwlpbnN0cl90aW1lCXRvdGFsOwkJ CS8qIHRvdGFsIHJ1bnRpbWUgKi8KKwlCdWZmZXJVc2FnZSBidWZ1c2FnZTsJCS8qIHRvdGFsIGJ1 ZmZlciB1c2FnZSAqLworCVdhbFVzYWdlCXdhbHVzYWdlOwkJLyogdG90YWwgV0FMIHVzYWdlICov Cit9IEluc3RydW1lbnRhdGlvbjsKKworLyoKKyAqIFNwZWNpYWxpemVkIGluc3RydW1lbnRhdGlv biBmb3IgcGVyLW5vZGUgZXhlY3V0aW9uIHN0YXRpc3RpY3MKKyAqLwordHlwZWRlZiBzdHJ1Y3Qg Tm9kZUluc3RydW1lbnRhdGlvbgoreworCUluc3RydW1lbnRhdGlvbiBpbnN0cjsKKwkvKiBQYXJh bWV0ZXJzIHNldCBhdCBub2RlIGNyZWF0aW9uOiAqLwogCWJvb2wJCWFzeW5jX21vZGU7CQkvKiB0 cnVlIGlmIG5vZGUgaXMgaW4gYXN5bmMgbW9kZSAqLwogCS8qIEluZm8gYWJvdXQgY3VycmVudCBw bGFuIGN5Y2xlOiAqLwogCWJvb2wJCXJ1bm5pbmc7CQkvKiB0cnVlIGlmIHdlJ3ZlIGNvbXBsZXRl ZCBmaXJzdCB0dXBsZSAqLwotCWluc3RyX3RpbWUJc3RhcnR0aW1lOwkJLyogc3RhcnQgdGltZSBv ZiBjdXJyZW50IGl0ZXJhdGlvbiBvZiBub2RlICovCiAJaW5zdHJfdGltZQljb3VudGVyOwkJLyog YWNjdW11bGF0ZWQgcnVudGltZSBmb3IgdGhpcyBub2RlICovCiAJaW5zdHJfdGltZQlmaXJzdHR1 cGxlOwkJLyogdGltZSBmb3IgZmlyc3QgdHVwbGUgb2YgdGhpcyBjeWNsZSAqLwogCWRvdWJsZQkJ dHVwbGVjb3VudDsJCS8qICMgb2YgdHVwbGVzIGVtaXR0ZWQgc28gZmFyIHRoaXMgY3ljbGUgKi8K LQlCdWZmZXJVc2FnZSBidWZ1c2FnZV9zdGFydDsgLyogYnVmZmVyIHVzYWdlIGF0IHN0YXJ0ICov Ci0JV2FsVXNhZ2UJd2FsdXNhZ2Vfc3RhcnQ7IC8qIFdBTCB1c2FnZSBhdCBzdGFydCAqLwogCS8q IEFjY3VtdWxhdGVkIHN0YXRpc3RpY3MgYWNyb3NzIGFsbCBjb21wbGV0ZWQgY3ljbGVzOiAqLwog CWluc3RyX3RpbWUJc3RhcnR1cDsJCS8qIHRvdGFsIHN0YXJ0dXAgdGltZSAqLwotCWluc3RyX3Rp bWUJdG90YWw7CQkJLyogdG90YWwgdGltZSAqLwogCWRvdWJsZQkJbnR1cGxlczsJCS8qIHRvdGFs IHR1cGxlcyBwcm9kdWNlZCAqLwogCWRvdWJsZQkJbnR1cGxlczI7CQkvKiBzZWNvbmRhcnkgbm9k ZS1zcGVjaWZpYyB0dXBsZSBjb3VudGVyICovCiAJZG91YmxlCQlubG9vcHM7CQkJLyogIyBvZiBy dW4gY3ljbGVzIGZvciB0aGlzIG5vZGUgKi8KIAlkb3VibGUJCW5maWx0ZXJlZDE7CQkvKiAjIG9m IHR1cGxlcyByZW1vdmVkIGJ5IHNjYW5xdWFsIG9yIGpvaW5xdWFsICovCiAJZG91YmxlCQluZmls dGVyZWQyOwkJLyogIyBvZiB0dXBsZXMgcmVtb3ZlZCBieSAib3RoZXIiIHF1YWxzICovCi0JQnVm ZmVyVXNhZ2UgYnVmdXNhZ2U7CQkvKiB0b3RhbCBidWZmZXIgdXNhZ2UgKi8KLQlXYWxVc2FnZQl3 YWx1c2FnZTsJCS8qIHRvdGFsIFdBTCB1c2FnZSAqLwotfSBJbnN0cnVtZW50YXRpb247Cit9IE5v ZGVJbnN0cnVtZW50YXRpb247CiAKLXR5cGVkZWYgc3RydWN0IFdvcmtlckluc3RydW1lbnRhdGlv bgordHlwZWRlZiBzdHJ1Y3QgV29ya2VyTm9kZUluc3RydW1lbnRhdGlvbgogewogCWludAkJCW51 bV93b3JrZXJzOwkvKiAjIG9mIHN0cnVjdHVyZXMgdGhhdCBmb2xsb3cgKi8KLQlJbnN0cnVtZW50 YXRpb24gaW5zdHJ1bWVudFtGTEVYSUJMRV9BUlJBWV9NRU1CRVJdOwotfSBXb3JrZXJJbnN0cnVt ZW50YXRpb247CisJTm9kZUluc3RydW1lbnRhdGlvbiBpbnN0cnVtZW50W0ZMRVhJQkxFX0FSUkFZ X01FTUJFUl07Cit9IFdvcmtlck5vZGVJbnN0cnVtZW50YXRpb247CiAKIHR5cGVkZWYgc3RydWN0 IFRyaWdnZXJJbnN0cnVtZW50YXRpb24KIHsKQEAgLTExMCwxNCArMTI3LDE5IEBAIHR5cGVkZWYg c3RydWN0IFRyaWdnZXJJbnN0cnVtZW50YXRpb24KIGV4dGVybiBQR0RMTElNUE9SVCBCdWZmZXJV c2FnZSBwZ0J1ZmZlclVzYWdlOwogZXh0ZXJuIFBHRExMSU1QT1JUIFdhbFVzYWdlIHBnV2FsVXNh Z2U7CiAKLWV4dGVybiBJbnN0cnVtZW50YXRpb24gKkluc3RyQWxsb2MoaW50IG4sIGludCBpbnN0 cnVtZW50X29wdGlvbnMsCi0JCQkJCQkJCSAgIGJvb2wgYXN5bmNfbW9kZSk7Ci1leHRlcm4gdm9p ZCBJbnN0ckluaXQoSW5zdHJ1bWVudGF0aW9uICppbnN0ciwgaW50IGluc3RydW1lbnRfb3B0aW9u cyk7Ci1leHRlcm4gdm9pZCBJbnN0clN0YXJ0Tm9kZShJbnN0cnVtZW50YXRpb24gKmluc3RyKTsK LWV4dGVybiB2b2lkIEluc3RyU3RvcE5vZGUoSW5zdHJ1bWVudGF0aW9uICppbnN0ciwgZG91Ymxl IG5UdXBsZXMpOwotZXh0ZXJuIHZvaWQgSW5zdHJVcGRhdGVUdXBsZUNvdW50KEluc3RydW1lbnRh dGlvbiAqaW5zdHIsIGRvdWJsZSBuVHVwbGVzKTsKLWV4dGVybiB2b2lkIEluc3RyRW5kTG9vcChJ bnN0cnVtZW50YXRpb24gKmluc3RyKTsKLWV4dGVybiB2b2lkIEluc3RyQWdnTm9kZShJbnN0cnVt ZW50YXRpb24gKmRzdCwgSW5zdHJ1bWVudGF0aW9uICphZGQpOworZXh0ZXJuIEluc3RydW1lbnRh dGlvbiAqSW5zdHJBbGxvYyhpbnQgaW5zdHJ1bWVudF9vcHRpb25zKTsKK2V4dGVybiB2b2lkIElu c3RySW5pdE9wdGlvbnMoSW5zdHJ1bWVudGF0aW9uICppbnN0ciwgaW50IGluc3RydW1lbnRfb3B0 aW9ucyk7CitleHRlcm4gdm9pZCBJbnN0clN0YXJ0KEluc3RydW1lbnRhdGlvbiAqaW5zdHIpOwor ZXh0ZXJuIHZvaWQgSW5zdHJTdG9wKEluc3RydW1lbnRhdGlvbiAqaW5zdHIpOworCitleHRlcm4g Tm9kZUluc3RydW1lbnRhdGlvbiAqSW5zdHJBbGxvY05vZGUoaW50IGluc3RydW1lbnRfb3B0aW9u cywKKwkJCQkJCQkJCQkgICBib29sIGFzeW5jX21vZGUpOworZXh0ZXJuIHZvaWQgSW5zdHJJbml0 Tm9kZShOb2RlSW5zdHJ1bWVudGF0aW9uICppbnN0ciwgaW50IGluc3RydW1lbnRfb3B0aW9ucyk7 CitleHRlcm4gdm9pZCBJbnN0clN0YXJ0Tm9kZShOb2RlSW5zdHJ1bWVudGF0aW9uICppbnN0cik7 CitleHRlcm4gdm9pZCBJbnN0clN0b3BOb2RlKE5vZGVJbnN0cnVtZW50YXRpb24gKmluc3RyLCBk b3VibGUgblR1cGxlcyk7CitleHRlcm4gdm9pZCBJbnN0clVwZGF0ZVR1cGxlQ291bnQoTm9kZUlu c3RydW1lbnRhdGlvbiAqaW5zdHIsIGRvdWJsZSBuVHVwbGVzKTsKK2V4dGVybiB2b2lkIEluc3Ry RW5kTG9vcChOb2RlSW5zdHJ1bWVudGF0aW9uICppbnN0cik7CitleHRlcm4gdm9pZCBJbnN0ckFn Z05vZGUoTm9kZUluc3RydW1lbnRhdGlvbiAqZHN0LCBOb2RlSW5zdHJ1bWVudGF0aW9uICphZGQp OwogCiBleHRlcm4gVHJpZ2dlckluc3RydW1lbnRhdGlvbiAqSW5zdHJBbGxvY1RyaWdnZXIoaW50 IG4sIGludCBpbnN0cnVtZW50X29wdGlvbnMpOwogZXh0ZXJuIHZvaWQgSW5zdHJTdGFydFRyaWdn ZXIoVHJpZ2dlckluc3RydW1lbnRhdGlvbiAqdGdpbnN0cik7CmRpZmYgLS1naXQgYS9zcmMvaW5j bHVkZS9ub2Rlcy9leGVjbm9kZXMuaCBiL3NyYy9pbmNsdWRlL25vZGVzL2V4ZWNub2Rlcy5oCmlu ZGV4IDkwODg5OGFhN2M5Li4zZWNhZTc1NTJmYyAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvbm9k ZXMvZXhlY25vZGVzLmgKKysrIGIvc3JjL2luY2x1ZGUvbm9kZXMvZXhlY25vZGVzLmgKQEAgLTYw LDYgKzYwLDcgQEAgdHlwZWRlZiBzdHJ1Y3QgU2NhbktleURhdGEgU2NhbktleURhdGE7CiB0eXBl ZGVmIHN0cnVjdCBTbmFwc2hvdERhdGEgKlNuYXBzaG90OwogdHlwZWRlZiBzdHJ1Y3QgU29ydFN1 cHBvcnREYXRhICpTb3J0U3VwcG9ydDsKIHR5cGVkZWYgc3RydWN0IFRJREJpdG1hcCBUSURCaXRt YXA7Cit0eXBlZGVmIHN0cnVjdCBOb2RlSW5zdHJ1bWVudGF0aW9uIE5vZGVJbnN0cnVtZW50YXRp b247CiB0eXBlZGVmIHN0cnVjdCBUcmlnZ2VySW5zdHJ1bWVudGF0aW9uIFRyaWdnZXJJbnN0cnVt ZW50YXRpb247CiB0eXBlZGVmIHN0cnVjdCBUdXBsZUNvbnZlcnNpb25NYXAgVHVwbGVDb252ZXJz aW9uTWFwOwogdHlwZWRlZiBzdHJ1Y3QgVHVwbGVEZXNjRGF0YSAqVHVwbGVEZXNjOwpAQCAtNjgs NyArNjksNyBAQCB0eXBlZGVmIHN0cnVjdCBUdXBsZXN0b3Jlc3RhdGUgVHVwbGVzdG9yZXN0YXRl OwogdHlwZWRlZiBzdHJ1Y3QgVHVwbGVUYWJsZVNsb3QgVHVwbGVUYWJsZVNsb3Q7CiB0eXBlZGVm IHN0cnVjdCBUdXBsZVRhYmxlU2xvdE9wcyBUdXBsZVRhYmxlU2xvdE9wczsKIHR5cGVkZWYgc3Ry dWN0IFdhbFVzYWdlIFdhbFVzYWdlOwotdHlwZWRlZiBzdHJ1Y3QgV29ya2VySW5zdHJ1bWVudGF0 aW9uIFdvcmtlckluc3RydW1lbnRhdGlvbjsKK3R5cGVkZWYgc3RydWN0IFdvcmtlck5vZGVJbnN0 cnVtZW50YXRpb24gV29ya2VyTm9kZUluc3RydW1lbnRhdGlvbjsKIAogCiAvKiAtLS0tLS0tLS0t LS0tLS0tCkBAIC0xMjA3LDggKzEyMDgsMTAgQEAgdHlwZWRlZiBzdHJ1Y3QgUGxhblN0YXRlCiAJ RXhlY1Byb2NOb2RlTXRkIEV4ZWNQcm9jTm9kZVJlYWw7CS8qIGFjdHVhbCBmdW5jdGlvbiwgaWYg YWJvdmUgaXMgYQogCQkJCQkJCQkJCSAqIHdyYXBwZXIgKi8KIAotCUluc3RydW1lbnRhdGlvbiAq aW5zdHJ1bWVudDsJLyogT3B0aW9uYWwgcnVudGltZSBzdGF0cyBmb3IgdGhpcyBub2RlICovCi0J V29ya2VySW5zdHJ1bWVudGF0aW9uICp3b3JrZXJfaW5zdHJ1bWVudDsJLyogcGVyLXdvcmtlciBp bnN0cnVtZW50YXRpb24gKi8KKwlOb2RlSW5zdHJ1bWVudGF0aW9uICppbnN0cnVtZW50OwkvKiBP cHRpb25hbCBydW50aW1lIHN0YXRzIGZvciB0aGlzCisJCQkJCQkJCQkJICogbm9kZSAqLworCVdv cmtlck5vZGVJbnN0cnVtZW50YXRpb24gKndvcmtlcl9pbnN0cnVtZW50OwkvKiBwZXItd29ya2Vy CisJCQkJCQkJCQkJCQkJICogaW5zdHJ1bWVudGF0aW9uICovCiAKIAkvKiBQZXItd29ya2VyIEpJ VCBpbnN0cnVtZW50YXRpb24gKi8KIAlzdHJ1Y3QgU2hhcmVkSml0SW5zdHJ1bWVudGF0aW9uICp3 b3JrZXJfaml0X2luc3RydW1lbnQ7CmRpZmYgLS1naXQgYS9zcmMvdG9vbHMvcGdpbmRlbnQvdHlw ZWRlZnMubGlzdCBiL3NyYy90b29scy9wZ2luZGVudC90eXBlZGVmcy5saXN0CmluZGV4IDdkZGY5 NzBmYjk3Li40NDlhY2NhOGRjMSAxMDA2NDQKLS0tIGEvc3JjL3Rvb2xzL3BnaW5kZW50L3R5cGVk ZWZzLmxpc3QKKysrIGIvc3JjL3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZzLmxpc3QKQEAgLTE4MjIs NiArMTgyMiw3IEBAIE5leHRTYW1wbGVCbG9ja19mdW5jdGlvbgogTmV4dFNhbXBsZVR1cGxlX2Z1 bmN0aW9uCiBOZXh0VmFsdWVFeHByCiBOb2RlCitOb2RlSW5zdHJ1bWVudGF0aW9uCiBOb2RlVGFn CiBOb25FbXB0eVJhbmdlCiBOb25lQ29tcHJlc3NvclN0YXRlCkBAIC0zNDM2LDkgKzM0MzcsOSBA QCBXb3JrVGFibGVTY2FuCiBXb3JrVGFibGVTY2FuU3RhdGUKIFdvcmtlckluZm8KIFdvcmtlcklu Zm9EYXRhCi1Xb3JrZXJJbnN0cnVtZW50YXRpb24KIFdvcmtlckpvYkR1bXBQdHJUeXBlCiBXb3Jr ZXJKb2JSZXN0b3JlUHRyVHlwZQorV29ya2VyTm9kZUluc3RydW1lbnRhdGlvbgogV29ya2luZ19T dGF0ZQogV3JpdGVCdWZQdHJUeXBlCiBXcml0ZUJ5dGVQdHJUeXBlCi0tIAoyLjQ3LjEKCg== --0000000000006d0cb0064eb5be7d Content-Type: application/octet-stream; name="v13-0003-instrumentation-Use-Instrumentation-instead-of-m.patch" Content-Disposition: attachment; filename="v13-0003-instrumentation-Use-Instrumentation-instead-of-m.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mnlqag5s2 RnJvbSAxYjg0ZjEyMTUyNjlmOTFmN2VlZjAyY2E2MjM3ZmI4MzU1ZmJhM2RhIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBMdWthcyBGaXR0bCA8bHVrYXNAZml0dGwuY29tPgpEYXRlOiBT dW4sIDUgQXByIDIwMjYgMDU6MDg6MjMgLTA3MDAKU3ViamVjdDogW1BBVENIIHYxMyAwMy8xMl0g aW5zdHJ1bWVudGF0aW9uOiBVc2UgSW5zdHJ1bWVudGF0aW9uIGluc3RlYWQgb2YKIG1hbnVhbCBi dWZmZXIgdHJhY2tpbmcKClRoaXMgcmVwbGFjZXMgZGlmZmVyZW50IHJlcGVhdGVkIGNvZGUgYmxv Y2tzIHRoYXQgcmVhZCBwZ0J1ZmZlclVzYWdlIC8KcGdXYWxVc2FnZSwgYW5kIG1heSBoYXZlIGFs c28gYmVlbiBydW5uaW5nIGEgdGltZXIgdG8gbWVhc3VyZSBhY3Rpdml0eSwKd2l0aCB0aGUgbmV3 IEluc3RydW1lbnRhdGlvbiBzdHJ1Y3QgYW5kIGFzc29jaWF0ZWQgaGVscGVycy4KCkF1dGhvcjog THVrYXMgRml0dGwgPGx1a2FzQGZpdHRsLmNvbT4KUmV2aWV3ZWQtYnk6CkRpc2N1c3Npb246Ci0t LQogLi4uL3BnX3N0YXRfc3RhdGVtZW50cy9wZ19zdGF0X3N0YXRlbWVudHMuYyAgIHwgNjcgKysr KystLS0tLS0tLS0tLS0tLQogc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvdmFjdXVtbGF6eS5jICAg ICAgICAgIHwgMTUgKystLS0KIHNyYy9iYWNrZW5kL2NvbW1hbmRzL2FuYWx5emUuYyAgICAgICAg ICAgICAgICB8IDMxICsrKysrLS0tLQogc3JjL2JhY2tlbmQvY29tbWFuZHMvZXhwbGFpbi5jICAg ICAgICAgICAgICAgIHwgNDQgKysrKysrLS0tLS0tCiBzcmMvYmFja2VuZC9jb21tYW5kcy9leHBs YWluX2RyLmMgICAgICAgICAgICAgfCA1NiArKysrKysrLS0tLS0tLS0tCiBzcmMvYmFja2VuZC9j b21tYW5kcy9wcmVwYXJlLmMgICAgICAgICAgICAgICAgfCAyOCArKystLS0tLQogc3JjL2luY2x1 ZGUvY29tbWFuZHMvZXhwbGFpbl9kci5oICAgICAgICAgICAgIHwgIDUgKy0KIDcgZmlsZXMgY2hh bmdlZCwgOTQgaW5zZXJ0aW9ucygrKSwgMTUyIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2Nv bnRyaWIvcGdfc3RhdF9zdGF0ZW1lbnRzL3BnX3N0YXRfc3RhdGVtZW50cy5jIGIvY29udHJpYi9w Z19zdGF0X3N0YXRlbWVudHMvcGdfc3RhdF9zdGF0ZW1lbnRzLmMKaW5kZXggZmJmMzJmMGU3MmMu LjYzOTc1NzA2Yjg3IDEwMDY0NAotLS0gYS9jb250cmliL3BnX3N0YXRfc3RhdGVtZW50cy9wZ19z dGF0X3N0YXRlbWVudHMuYworKysgYi9jb250cmliL3BnX3N0YXRfc3RhdGVtZW50cy9wZ19zdGF0 X3N0YXRlbWVudHMuYwpAQCAtOTExLDIyICs5MTEsMTEgQEAgcGdzc19wbGFubmVyKFF1ZXJ5ICpw YXJzZSwKIAkJJiYgcGdzc190cmFja19wbGFubmluZyAmJiBxdWVyeV9zdHJpbmcKIAkJJiYgcGFy c2UtPnF1ZXJ5SWQgIT0gSU5UNjRDT05TVCgwKSkKIAl7Ci0JCWluc3RyX3RpbWUJc3RhcnQ7Ci0J CWluc3RyX3RpbWUJZHVyYXRpb247Ci0JCUJ1ZmZlclVzYWdlIGJ1ZnVzYWdlX3N0YXJ0LAotCQkJ CQlidWZ1c2FnZTsKLQkJV2FsVXNhZ2UJd2FsdXNhZ2Vfc3RhcnQsCi0JCQkJCXdhbHVzYWdlOwor CQlJbnN0cnVtZW50YXRpb24gaW5zdHIgPSB7MH07CiAKLQkJLyogV2UgbmVlZCB0byB0cmFjayBi dWZmZXIgdXNhZ2UgYXMgdGhlIHBsYW5uZXIgY2FuIGFjY2VzcyB0aGVtLiAqLwotCQlidWZ1c2Fn ZV9zdGFydCA9IHBnQnVmZmVyVXNhZ2U7Ci0KLQkJLyoKLQkJICogU2ltaWxhcmx5IHRoZSBwbGFu bmVyIGNvdWxkIHdyaXRlIHNvbWUgV0FMIHJlY29yZHMgaW4gc29tZSBjYXNlcwotCQkgKiAoZS5n LiBzZXR0aW5nIGEgaGludCBiaXQgd2l0aCB0aG9zZSBiZWluZyBXQUwtbG9nZ2VkKQotCQkgKi8K LQkJd2FsdXNhZ2Vfc3RhcnQgPSBwZ1dhbFVzYWdlOwotCQlJTlNUUl9USU1FX1NFVF9DVVJSRU5U KHN0YXJ0KTsKKwkJLyogVHJhY2sgdGltZSBhbmQgYnVmZmVyL1dBTCB1c2FnZSBhcyB0aGUgcGxh bm5lciBjYW4gYWNjZXNzIHRoZW0uICovCisJCUluc3RySW5pdE9wdGlvbnMoJmluc3RyLCBJTlNU UlVNRU5UX0FMTCk7CisJCUluc3RyU3RhcnQoJmluc3RyKTsKIAogCQluZXN0aW5nX2xldmVsKys7 CiAJCVBHX1RSWSgpOwpAQCAtOTQwLDMwICs5MjksMjAgQEAgcGdzc19wbGFubmVyKFF1ZXJ5ICpw YXJzZSwKIAkJfQogCQlQR19GSU5BTExZKCk7CiAJCXsKKwkJCUluc3RyU3RvcCgmaW5zdHIpOwog CQkJbmVzdGluZ19sZXZlbC0tOwogCQl9CiAJCVBHX0VORF9UUlkoKTsKIAotCQlJTlNUUl9USU1F X1NFVF9DVVJSRU5UKGR1cmF0aW9uKTsKLQkJSU5TVFJfVElNRV9TVUJUUkFDVChkdXJhdGlvbiwg c3RhcnQpOwotCi0JCS8qIGNhbGMgZGlmZmVyZW5jZXMgb2YgYnVmZmVyIGNvdW50ZXJzLiAqLwot CQltZW1zZXQoJmJ1ZnVzYWdlLCAwLCBzaXplb2YoQnVmZmVyVXNhZ2UpKTsKLQkJQnVmZmVyVXNh Z2VBY2N1bURpZmYoJmJ1ZnVzYWdlLCAmcGdCdWZmZXJVc2FnZSwgJmJ1ZnVzYWdlX3N0YXJ0KTsK LQotCQkvKiBjYWxjIGRpZmZlcmVuY2VzIG9mIFdBTCBjb3VudGVycy4gKi8KLQkJbWVtc2V0KCZ3 YWx1c2FnZSwgMCwgc2l6ZW9mKFdhbFVzYWdlKSk7Ci0JCVdhbFVzYWdlQWNjdW1EaWZmKCZ3YWx1 c2FnZSwgJnBnV2FsVXNhZ2UsICZ3YWx1c2FnZV9zdGFydCk7Ci0KIAkJcGdzc19zdG9yZShxdWVy eV9zdHJpbmcsCiAJCQkJICAgcGFyc2UtPnF1ZXJ5SWQsCiAJCQkJICAgcGFyc2UtPnN0bXRfbG9j YXRpb24sCiAJCQkJICAgcGFyc2UtPnN0bXRfbGVuLAogCQkJCSAgIFBHU1NfUExBTiwKLQkJCQkg ICBJTlNUUl9USU1FX0dFVF9NSUxMSVNFQyhkdXJhdGlvbiksCisJCQkJICAgSU5TVFJfVElNRV9H RVRfTUlMTElTRUMoaW5zdHIudG90YWwpLAogCQkJCSAgIDAsCi0JCQkJICAgJmJ1ZnVzYWdlLAot CQkJCSAgICZ3YWx1c2FnZSwKKwkJCQkgICAmaW5zdHIuYnVmdXNhZ2UsCisJCQkJICAgJmluc3Ry LndhbHVzYWdlLAogCQkJCSAgIE5VTEwsCiAJCQkJICAgTlVMTCwKIAkJCQkgICAwLApAQCAtMTE1 NiwxNyArMTEzNSwxMSBAQCBwZ3NzX1Byb2Nlc3NVdGlsaXR5KFBsYW5uZWRTdG10ICpwc3RtdCwg Y29uc3QgY2hhciAqcXVlcnlTdHJpbmcsCiAJCSFJc0EocGFyc2V0cmVlLCBFeGVjdXRlU3RtdCkg JiYKIAkJIUlzQShwYXJzZXRyZWUsIFByZXBhcmVTdG10KSkKIAl7Ci0JCWluc3RyX3RpbWUJc3Rh cnQ7Ci0JCWluc3RyX3RpbWUJZHVyYXRpb247CiAJCXVpbnQ2NAkJcm93czsKLQkJQnVmZmVyVXNh Z2UgYnVmdXNhZ2Vfc3RhcnQsCi0JCQkJCWJ1ZnVzYWdlOwotCQlXYWxVc2FnZQl3YWx1c2FnZV9z dGFydCwKLQkJCQkJd2FsdXNhZ2U7CisJCUluc3RydW1lbnRhdGlvbiBpbnN0ciA9IHswfTsKIAot CQlidWZ1c2FnZV9zdGFydCA9IHBnQnVmZmVyVXNhZ2U7Ci0JCXdhbHVzYWdlX3N0YXJ0ID0gcGdX YWxVc2FnZTsKLQkJSU5TVFJfVElNRV9TRVRfQ1VSUkVOVChzdGFydCk7CisJCUluc3RySW5pdE9w dGlvbnMoJmluc3RyLCBJTlNUUlVNRU5UX0FMTCk7CisJCUluc3RyU3RhcnQoJmluc3RyKTsKIAog CQluZXN0aW5nX2xldmVsKys7CiAJCVBHX1RSWSgpOwpAQCAtMTE4Miw2ICsxMTU1LDcgQEAgcGdz c19Qcm9jZXNzVXRpbGl0eShQbGFubmVkU3RtdCAqcHN0bXQsIGNvbnN0IGNoYXIgKnF1ZXJ5U3Ry aW5nLAogCQl9CiAJCVBHX0ZJTkFMTFkoKTsKIAkJeworCQkJSW5zdHJTdG9wKCZpbnN0cik7CiAJ CQluZXN0aW5nX2xldmVsLS07CiAJCX0KIAkJUEdfRU5EX1RSWSgpOwpAQCAtMTE5Niw5ICsxMTcw LDYgQEAgcGdzc19Qcm9jZXNzVXRpbGl0eShQbGFubmVkU3RtdCAqcHN0bXQsIGNvbnN0IGNoYXIg KnF1ZXJ5U3RyaW5nLAogCQkgKiBmb3JtZXIgdmFsdWUsIHdoaWNoJ2Qgb3RoZXJ3aXNlIGJlIGEg Z29vZCBpZGVhLgogCQkgKi8KIAotCQlJTlNUUl9USU1FX1NFVF9DVVJSRU5UKGR1cmF0aW9uKTsK LQkJSU5TVFJfVElNRV9TVUJUUkFDVChkdXJhdGlvbiwgc3RhcnQpOwotCiAJCS8qCiAJCSAqIFRy YWNrIHRoZSB0b3RhbCBudW1iZXIgb2Ygcm93cyByZXRyaWV2ZWQgb3IgYWZmZWN0ZWQgYnkgdGhl IHV0aWxpdHkKIAkJICogc3RhdGVtZW50cyBvZiBDT1BZLCBGRVRDSCwgQ1JFQVRFIFRBQkxFIEFT LCBDUkVBVEUgTUFURVJJQUxJWkVECkBAIC0xMjEwLDIzICsxMTgxLDE1IEBAIHBnc3NfUHJvY2Vz c1V0aWxpdHkoUGxhbm5lZFN0bXQgKnBzdG10LCBjb25zdCBjaGFyICpxdWVyeVN0cmluZywKIAkJ CQkJICAgcWMtPmNvbW1hbmRUYWcgPT0gQ01EVEFHX1JFRlJFU0hfTUFURVJJQUxJWkVEX1ZJRVcp KSA/CiAJCQlxYy0+bnByb2Nlc3NlZCA6IDA7CiAKLQkJLyogY2FsYyBkaWZmZXJlbmNlcyBvZiBi dWZmZXIgY291bnRlcnMuICovCi0JCW1lbXNldCgmYnVmdXNhZ2UsIDAsIHNpemVvZihCdWZmZXJV c2FnZSkpOwotCQlCdWZmZXJVc2FnZUFjY3VtRGlmZigmYnVmdXNhZ2UsICZwZ0J1ZmZlclVzYWdl LCAmYnVmdXNhZ2Vfc3RhcnQpOwotCi0JCS8qIGNhbGMgZGlmZmVyZW5jZXMgb2YgV0FMIGNvdW50 ZXJzLiAqLwotCQltZW1zZXQoJndhbHVzYWdlLCAwLCBzaXplb2YoV2FsVXNhZ2UpKTsKLQkJV2Fs VXNhZ2VBY2N1bURpZmYoJndhbHVzYWdlLCAmcGdXYWxVc2FnZSwgJndhbHVzYWdlX3N0YXJ0KTsK LQogCQlwZ3NzX3N0b3JlKHF1ZXJ5U3RyaW5nLAogCQkJCSAgIHNhdmVkX3F1ZXJ5SWQsCiAJCQkJ ICAgc2F2ZWRfc3RtdF9sb2NhdGlvbiwKIAkJCQkgICBzYXZlZF9zdG10X2xlbiwKIAkJCQkgICBQ R1NTX0VYRUMsCi0JCQkJICAgSU5TVFJfVElNRV9HRVRfTUlMTElTRUMoZHVyYXRpb24pLAorCQkJ CSAgIElOU1RSX1RJTUVfR0VUX01JTExJU0VDKGluc3RyLnRvdGFsKSwKIAkJCQkgICByb3dzLAot CQkJCSAgICZidWZ1c2FnZSwKLQkJCQkgICAmd2FsdXNhZ2UsCisJCQkJICAgJmluc3RyLmJ1ZnVz YWdlLAorCQkJCSAgICZpbnN0ci53YWx1c2FnZSwKIAkJCQkgICBOVUxMLAogCQkJCSAgIE5VTEws CiAJCQkJICAgMCwKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1bWxh enkuYyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYwppbmRleCA4OGM3MWNk ODViNi4uMzBmNTg5YzkyMDcgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3Zh Y3V1bWxhenkuYworKysgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMKQEAg LTYzNyw4ICs2MzcsNyBAQCBoZWFwX3ZhY3V1bV9yZWwoUmVsYXRpb24gcmVsLCBjb25zdCBWYWN1 dW1QYXJhbXMgKnBhcmFtcywKIAlUaW1lc3RhbXBUeiBzdGFydHRpbWUgPSAwOwogCVBnU3RhdF9D b3VudGVyIHN0YXJ0cmVhZHRpbWUgPSAwLAogCQkJCXN0YXJ0d3JpdGV0aW1lID0gMDsKLQlXYWxV c2FnZQlzdGFydHdhbHVzYWdlID0gcGdXYWxVc2FnZTsKLQlCdWZmZXJVc2FnZSBzdGFydGJ1ZmZl cnVzYWdlID0gcGdCdWZmZXJVc2FnZTsKKwlJbnN0cnVtZW50YXRpb24gKmluc3RyID0gTlVMTDsK IAlFcnJvckNvbnRleHRDYWxsYmFjayBlcnJjYWxsYmFjazsKIAljaGFyCSAgKippbmRuYW1lcyA9 IE5VTEw7CiAJU2l6ZQkJZGVhZF9pdGVtc19tYXhfYnl0ZXMgPSAwOwpAQCAtNjU0LDYgKzY1Myw4 IEBAIGhlYXBfdmFjdXVtX3JlbChSZWxhdGlvbiByZWwsIGNvbnN0IFZhY3V1bVBhcmFtcyAqcGFy YW1zLAogCQkJc3RhcnRyZWFkdGltZSA9IHBnU3RhdEJsb2NrUmVhZFRpbWU7CiAJCQlzdGFydHdy aXRldGltZSA9IHBnU3RhdEJsb2NrV3JpdGVUaW1lOwogCQl9CisJCWluc3RyID0gSW5zdHJBbGxv YyhJTlNUUlVNRU5UX0JVRkZFUlMgfCBJTlNUUlVNRU5UX1dBTCk7CisJCUluc3RyU3RhcnQoaW5z dHIpOwogCX0KIAogCS8qIFVzZWQgZm9yIGluc3RydW1lbnRhdGlvbiBhbmQgc3RhdHMgcmVwb3J0 ICovCkBAIC05ODQsMTQgKzk4NSwxNCBAQCBoZWFwX3ZhY3V1bV9yZWwoUmVsYXRpb24gcmVsLCBj b25zdCBWYWN1dW1QYXJhbXMgKnBhcmFtcywKIAl7CiAJCVRpbWVzdGFtcFR6IGVuZHRpbWUgPSBH ZXRDdXJyZW50VGltZXN0YW1wKCk7CiAKKwkJSW5zdHJTdG9wKGluc3RyKTsKKwogCQlpZiAodmVy Ym9zZSB8fCBwYXJhbXMtPmxvZ192YWN1dW1fbWluX2R1cmF0aW9uID09IDAgfHwKIAkJCVRpbWVz dGFtcERpZmZlcmVuY2VFeGNlZWRzKHN0YXJ0dGltZSwgZW5kdGltZSwKIAkJCQkJCQkJCSAgIHBh cmFtcy0+bG9nX3ZhY3V1bV9taW5fZHVyYXRpb24pKQogCQl7CiAJCQlsb25nCQlzZWNzX2R1cjsK IAkJCWludAkJCXVzZWNzX2R1cjsKLQkJCVdhbFVzYWdlCXdhbHVzYWdlOwotCQkJQnVmZmVyVXNh Z2UgYnVmZmVydXNhZ2U7CiAJCQlTdHJpbmdJbmZvRGF0YSBidWY7CiAJCQljaGFyCSAgICptc2dm bXQ7CiAJCQlpbnQzMgkJZGlmZjsKQEAgLTEwMDAsMTIgKzEwMDEsMTAgQEAgaGVhcF92YWN1dW1f cmVsKFJlbGF0aW9uIHJlbCwgY29uc3QgVmFjdXVtUGFyYW1zICpwYXJhbXMsCiAJCQlpbnQ2NAkJ dG90YWxfYmxrc19oaXQ7CiAJCQlpbnQ2NAkJdG90YWxfYmxrc19yZWFkOwogCQkJaW50NjQJCXRv dGFsX2Jsa3NfZGlydGllZDsKKwkJCUJ1ZmZlclVzYWdlIGJ1ZmZlcnVzYWdlID0gaW5zdHItPmJ1 ZnVzYWdlOworCQkJV2FsVXNhZ2UJd2FsdXNhZ2UgPSBpbnN0ci0+d2FsdXNhZ2U7CiAKIAkJCVRp bWVzdGFtcERpZmZlcmVuY2Uoc3RhcnR0aW1lLCBlbmR0aW1lLCAmc2Vjc19kdXIsICZ1c2Vjc19k dXIpOwotCQkJbWVtc2V0KCZ3YWx1c2FnZSwgMCwgc2l6ZW9mKFdhbFVzYWdlKSk7Ci0JCQlXYWxV c2FnZUFjY3VtRGlmZigmd2FsdXNhZ2UsICZwZ1dhbFVzYWdlLCAmc3RhcnR3YWx1c2FnZSk7Ci0J CQltZW1zZXQoJmJ1ZmZlcnVzYWdlLCAwLCBzaXplb2YoQnVmZmVyVXNhZ2UpKTsKLQkJCUJ1ZmZl clVzYWdlQWNjdW1EaWZmKCZidWZmZXJ1c2FnZSwgJnBnQnVmZmVyVXNhZ2UsICZzdGFydGJ1ZmZl cnVzYWdlKTsKIAogCQkJdG90YWxfYmxrc19oaXQgPSBidWZmZXJ1c2FnZS5zaGFyZWRfYmxrc19o aXQgKwogCQkJCWJ1ZmZlcnVzYWdlLmxvY2FsX2Jsa3NfaGl0OwpkaWZmIC0tZ2l0IGEvc3JjL2Jh Y2tlbmQvY29tbWFuZHMvYW5hbHl6ZS5jIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvYW5hbHl6ZS5j CmluZGV4IDQ5YTVjZGY1NzljLi44NDcyZmMwYzI4MCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQv Y29tbWFuZHMvYW5hbHl6ZS5jCisrKyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL2FuYWx5emUuYwpA QCAtMzA5LDkgKzMwOSw3IEBAIGRvX2FuYWx5emVfcmVsKFJlbGF0aW9uIG9uZXJlbCwgY29uc3Qg VmFjdXVtUGFyYW1zICpwYXJhbXMsCiAJT2lkCQkJc2F2ZV91c2VyaWQ7CiAJaW50CQkJc2F2ZV9z ZWNfY29udGV4dDsKIAlpbnQJCQlzYXZlX25lc3RsZXZlbDsKLQlXYWxVc2FnZQlzdGFydHdhbHVz YWdlID0gcGdXYWxVc2FnZTsKLQlCdWZmZXJVc2FnZSBzdGFydGJ1ZmZlcnVzYWdlID0gcGdCdWZm ZXJVc2FnZTsKLQlCdWZmZXJVc2FnZSBidWZmZXJ1c2FnZTsKKwlJbnN0cnVtZW50YXRpb24gKmlu c3RyID0gTlVMTDsKIAlQZ1N0YXRfQ291bnRlciBzdGFydHJlYWR0aW1lID0gMDsKIAlQZ1N0YXRf Q291bnRlciBzdGFydHdyaXRldGltZSA9IDA7CiAKQEAgLTM2Miw2ICszNjAsOSBAQCBkb19hbmFs eXplX3JlbChSZWxhdGlvbiBvbmVyZWwsIGNvbnN0IFZhY3V1bVBhcmFtcyAqcGFyYW1zLAogCQl9 CiAKIAkJcGdfcnVzYWdlX2luaXQoJnJ1MCk7CisKKwkJaW5zdHIgPSBJbnN0ckFsbG9jKElOU1RS VU1FTlRfQlVGRkVSUyB8IElOU1RSVU1FTlRfV0FMKTsKKwkJSW5zdHJTdGFydChpbnN0cik7CiAJ fQogCiAJLyogVXNlZCBmb3IgaW5zdHJ1bWVudGF0aW9uIGFuZCBzdGF0cyByZXBvcnQgKi8KQEAg LTc0MiwxMiArNzQzLDEzIEBAIGRvX2FuYWx5emVfcmVsKFJlbGF0aW9uIG9uZXJlbCwgY29uc3Qg VmFjdXVtUGFyYW1zICpwYXJhbXMsCiAJewogCQlUaW1lc3RhbXBUeiBlbmR0aW1lID0gR2V0Q3Vy cmVudFRpbWVzdGFtcCgpOwogCisJCUluc3RyU3RvcChpbnN0cik7CisKIAkJaWYgKHZlcmJvc2Ug fHwgcGFyYW1zLT5sb2dfYW5hbHl6ZV9taW5fZHVyYXRpb24gPT0gMCB8fAogCQkJVGltZXN0YW1w RGlmZmVyZW5jZUV4Y2VlZHMoc3RhcnR0aW1lLCBlbmR0aW1lLAogCQkJCQkJCQkJICAgcGFyYW1z LT5sb2dfYW5hbHl6ZV9taW5fZHVyYXRpb24pKQogCQl7CiAJCQlsb25nCQlkZWxheV9pbl9tczsK LQkJCVdhbFVzYWdlCXdhbHVzYWdlOwogCQkJZG91YmxlCQlyZWFkX3JhdGUgPSAwOwogCQkJZG91 YmxlCQl3cml0ZV9yYXRlID0gMDsKIAkJCWNoYXIJICAgKm1zZ2ZtdDsKQEAgLTc1NSwxOCArNzU3 LDE1IEBAIGRvX2FuYWx5emVfcmVsKFJlbGF0aW9uIG9uZXJlbCwgY29uc3QgVmFjdXVtUGFyYW1z ICpwYXJhbXMsCiAJCQlpbnQ2NAkJdG90YWxfYmxrc19oaXQ7CiAJCQlpbnQ2NAkJdG90YWxfYmxr c19yZWFkOwogCQkJaW50NjQJCXRvdGFsX2Jsa3NfZGlydGllZDsKLQotCQkJbWVtc2V0KCZidWZm ZXJ1c2FnZSwgMCwgc2l6ZW9mKEJ1ZmZlclVzYWdlKSk7Ci0JCQlCdWZmZXJVc2FnZUFjY3VtRGlm ZigmYnVmZmVydXNhZ2UsICZwZ0J1ZmZlclVzYWdlLCAmc3RhcnRidWZmZXJ1c2FnZSk7Ci0JCQlt ZW1zZXQoJndhbHVzYWdlLCAwLCBzaXplb2YoV2FsVXNhZ2UpKTsKLQkJCVdhbFVzYWdlQWNjdW1E aWZmKCZ3YWx1c2FnZSwgJnBnV2FsVXNhZ2UsICZzdGFydHdhbHVzYWdlKTsKLQotCQkJdG90YWxf Ymxrc19oaXQgPSBidWZmZXJ1c2FnZS5zaGFyZWRfYmxrc19oaXQgKwotCQkJCWJ1ZmZlcnVzYWdl LmxvY2FsX2Jsa3NfaGl0OwotCQkJdG90YWxfYmxrc19yZWFkID0gYnVmZmVydXNhZ2Uuc2hhcmVk X2Jsa3NfcmVhZCArCi0JCQkJYnVmZmVydXNhZ2UubG9jYWxfYmxrc19yZWFkOwotCQkJdG90YWxf Ymxrc19kaXJ0aWVkID0gYnVmZmVydXNhZ2Uuc2hhcmVkX2Jsa3NfZGlydGllZCArCi0JCQkJYnVm ZmVydXNhZ2UubG9jYWxfYmxrc19kaXJ0aWVkOworCQkJQnVmZmVyVXNhZ2UgYnVmdXNhZ2UgPSBp bnN0ci0+YnVmdXNhZ2U7CisJCQlXYWxVc2FnZQl3YWx1c2FnZSA9IGluc3RyLT53YWx1c2FnZTsK KworCQkJdG90YWxfYmxrc19oaXQgPSBidWZ1c2FnZS5zaGFyZWRfYmxrc19oaXQgKworCQkJCWJ1 ZnVzYWdlLmxvY2FsX2Jsa3NfaGl0OworCQkJdG90YWxfYmxrc19yZWFkID0gYnVmdXNhZ2Uuc2hh cmVkX2Jsa3NfcmVhZCArCisJCQkJYnVmdXNhZ2UubG9jYWxfYmxrc19yZWFkOworCQkJdG90YWxf Ymxrc19kaXJ0aWVkID0gYnVmdXNhZ2Uuc2hhcmVkX2Jsa3NfZGlydGllZCArCisJCQkJYnVmdXNh Z2UubG9jYWxfYmxrc19kaXJ0aWVkOwogCiAJCQkvKgogCQkJICogV2UgZG8gbm90IGV4cGVjdCBh biBhbmFseXplIHRvIHRha2UgPiAyNSBkYXlzIGFuZCBpdCBzaW1wbGlmaWVzCmRpZmYgLS1naXQg YS9zcmMvYmFja2VuZC9jb21tYW5kcy9leHBsYWluLmMgYi9zcmMvYmFja2VuZC9jb21tYW5kcy9l eHBsYWluLmMKaW5kZXggZTczZGMxMjkxMzIuLmU3NTUwYThhYzQ2IDEwMDY0NAotLS0gYS9zcmMv YmFja2VuZC9jb21tYW5kcy9leHBsYWluLmMKKysrIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvZXhw bGFpbi5jCkBAIC0zMjQsMTMgKzMyNCwxNiBAQCBzdGFuZGFyZF9FeHBsYWluT25lUXVlcnkoUXVl cnkgKnF1ZXJ5LCBpbnQgY3Vyc29yT3B0aW9ucywKIAkJCQkJCSBRdWVyeUVudmlyb25tZW50ICpx dWVyeUVudikKIHsKIAlQbGFubmVkU3RtdCAqcGxhbjsKLQlpbnN0cl90aW1lCXBsYW5zdGFydCwK LQkJCQlwbGFuZHVyYXRpb247Ci0JQnVmZmVyVXNhZ2UgYnVmdXNhZ2Vfc3RhcnQsCi0JCQkJYnVm dXNhZ2U7CisJSW5zdHJ1bWVudGF0aW9uIHBsYW5faW5zdHIgPSB7MH07CiAJTWVtb3J5Q29udGV4 dENvdW50ZXJzIG1lbV9jb3VudGVyczsKIAlNZW1vcnlDb250ZXh0IHBsYW5uZXJfY3R4ID0gTlVM TDsKIAlNZW1vcnlDb250ZXh0IHNhdmVkX2N0eCA9IE5VTEw7CisJaW50CQkJaW5zdHJ1bWVudF9v cHRpb25zID0gSU5TVFJVTUVOVF9USU1FUjsKKworCWlmIChlcy0+YnVmZmVycykKKwkJaW5zdHJ1 bWVudF9vcHRpb25zIHw9IElOU1RSVU1FTlRfQlVGRkVSUzsKKworCUluc3RySW5pdE9wdGlvbnMo JnBsYW5faW5zdHIsIGluc3RydW1lbnRfb3B0aW9ucyk7CiAKIAlpZiAoZXMtPm1lbW9yeSkKIAl7 CkBAIC0zNDgsMTUgKzM1MSwxMiBAQCBzdGFuZGFyZF9FeHBsYWluT25lUXVlcnkoUXVlcnkgKnF1 ZXJ5LCBpbnQgY3Vyc29yT3B0aW9ucywKIAkJc2F2ZWRfY3R4ID0gTWVtb3J5Q29udGV4dFN3aXRj aFRvKHBsYW5uZXJfY3R4KTsKIAl9CiAKLQlpZiAoZXMtPmJ1ZmZlcnMpCi0JCWJ1ZnVzYWdlX3N0 YXJ0ID0gcGdCdWZmZXJVc2FnZTsKLQlJTlNUUl9USU1FX1NFVF9DVVJSRU5UKHBsYW5zdGFydCk7 CisJSW5zdHJTdGFydCgmcGxhbl9pbnN0cik7CiAKIAkvKiBwbGFuIHRoZSBxdWVyeSAqLwogCXBs YW4gPSBwZ19wbGFuX3F1ZXJ5KHF1ZXJ5LCBxdWVyeVN0cmluZywgY3Vyc29yT3B0aW9ucywgcGFy YW1zLCBlcyk7CiAKLQlJTlNUUl9USU1FX1NFVF9DVVJSRU5UKHBsYW5kdXJhdGlvbik7Ci0JSU5T VFJfVElNRV9TVUJUUkFDVChwbGFuZHVyYXRpb24sIHBsYW5zdGFydCk7CisJSW5zdHJTdG9wKCZw bGFuX2luc3RyKTsKIAogCWlmIChlcy0+bWVtb3J5KQogCXsKQEAgLTM2NCwxNiArMzY0LDkgQEAg c3RhbmRhcmRfRXhwbGFpbk9uZVF1ZXJ5KFF1ZXJ5ICpxdWVyeSwgaW50IGN1cnNvck9wdGlvbnMs CiAJCU1lbW9yeUNvbnRleHRNZW1Db25zdW1lZChwbGFubmVyX2N0eCwgJm1lbV9jb3VudGVycyk7 CiAJfQogCi0JLyogY2FsYyBkaWZmZXJlbmNlcyBvZiBidWZmZXIgY291bnRlcnMuICovCi0JaWYg KGVzLT5idWZmZXJzKQotCXsKLQkJbWVtc2V0KCZidWZ1c2FnZSwgMCwgc2l6ZW9mKEJ1ZmZlclVz YWdlKSk7Ci0JCUJ1ZmZlclVzYWdlQWNjdW1EaWZmKCZidWZ1c2FnZSwgJnBnQnVmZmVyVXNhZ2Us ICZidWZ1c2FnZV9zdGFydCk7Ci0JfQotCiAJLyogcnVuIGl0IChpZiBuZWVkZWQpIGFuZCBwcm9k dWNlIG91dHB1dCAqLwogCUV4cGxhaW5PbmVQbGFuKHBsYW4sIGludG8sIGVzLCBxdWVyeVN0cmlu ZywgcGFyYW1zLCBxdWVyeUVudiwKLQkJCQkgICAmcGxhbmR1cmF0aW9uLCAoZXMtPmJ1ZmZlcnMg PyAmYnVmdXNhZ2UgOiBOVUxMKSwKKwkJCQkgICAmcGxhbl9pbnN0ci50b3RhbCwgKGVzLT5idWZm ZXJzID8gJnBsYW5faW5zdHIuYnVmdXNhZ2UgOiBOVUxMKSwKIAkJCQkgICBlcy0+bWVtb3J5ID8g Jm1lbV9jb3VudGVycyA6IE5VTEwpOwogfQogCkBAIC01OTAsNyArNTgzLDEyIEBAIEV4cGxhaW5P bmVQbGFuKFBsYW5uZWRTdG10ICpwbGFubmVkc3RtdCwgSW50b0NsYXVzZSAqaW50bywgRXhwbGFp blN0YXRlICplcywKIAogCS8qIGdyYWIgc2VyaWFsaXphdGlvbiBtZXRyaWNzIGJlZm9yZSB3ZSBk ZXN0cm95IHRoZSBEZXN0UmVjZWl2ZXIgKi8KIAlpZiAoZXMtPnNlcmlhbGl6ZSAhPSBFWFBMQUlO X1NFUklBTElaRV9OT05FKQotCQlzZXJpYWxpemVNZXRyaWNzID0gR2V0U2VyaWFsaXphdGlvbk1l dHJpY3MoZGVzdCk7CisJeworCQlTZXJpYWxpemVNZXRyaWNzICptZXRyaWNzID0gR2V0U2VyaWFs aXphdGlvbk1ldHJpY3MoZGVzdCk7CisKKwkJaWYgKG1ldHJpY3MpCisJCQltZW1jcHkoJnNlcmlh bGl6ZU1ldHJpY3MsIG1ldHJpY3MsIHNpemVvZihTZXJpYWxpemVNZXRyaWNzKSk7CisJfQogCiAJ LyogY2FsbCB0aGUgRGVzdFJlY2VpdmVyJ3MgZGVzdHJveSBtZXRob2QgZXZlbiBkdXJpbmcgZXhw bGFpbiAqLwogCWRlc3QtPnJEZXN0cm95KGRlc3QpOwpAQCAtMTAxOSw3ICsxMDE3LDcgQEAgRXhw bGFpblByaW50U2VyaWFsaXplKEV4cGxhaW5TdGF0ZSAqZXMsIFNlcmlhbGl6ZU1ldHJpY3MgKm1l dHJpY3MpCiAJCUV4cGxhaW5JbmRlbnRUZXh0KGVzKTsKIAkJaWYgKGVzLT50aW1pbmcpCiAJCQlh cHBlbmRTdHJpbmdJbmZvKGVzLT5zdHIsICJTZXJpYWxpemF0aW9uOiB0aW1lPSUuM2YgbXMgIG91 dHB1dD0iIFVJTlQ2NF9GT1JNQVQgImtCICBmb3JtYXQ9JXNcbiIsCi0JCQkJCQkJIDEwMDAuMCAq IElOU1RSX1RJTUVfR0VUX0RPVUJMRShtZXRyaWNzLT50aW1lU3BlbnQpLAorCQkJCQkJCSAxMDAw LjAgKiBJTlNUUl9USU1FX0dFVF9ET1VCTEUobWV0cmljcy0+aW5zdHIudG90YWwpLAogCQkJCQkJ CSBCWVRFU19UT19LSUxPQllURVMobWV0cmljcy0+Ynl0ZXNTZW50KSwKIAkJCQkJCQkgZm9ybWF0 KTsKIAkJZWxzZQpAQCAtMTAyNywxMCArMTAyNSwxMCBAQCBFeHBsYWluUHJpbnRTZXJpYWxpemUo RXhwbGFpblN0YXRlICplcywgU2VyaWFsaXplTWV0cmljcyAqbWV0cmljcykKIAkJCQkJCQkgQllU RVNfVE9fS0lMT0JZVEVTKG1ldHJpY3MtPmJ5dGVzU2VudCksCiAJCQkJCQkJIGZvcm1hdCk7CiAK LQkJaWYgKGVzLT5idWZmZXJzICYmIHBlZWtfYnVmZmVyX3VzYWdlKGVzLCAmbWV0cmljcy0+YnVm ZmVyVXNhZ2UpKQorCQlpZiAoZXMtPmJ1ZmZlcnMgJiYgcGVla19idWZmZXJfdXNhZ2UoZXMsICZt ZXRyaWNzLT5pbnN0ci5idWZ1c2FnZSkpCiAJCXsKIAkJCWVzLT5pbmRlbnQrKzsKLQkJCXNob3df YnVmZmVyX3VzYWdlKGVzLCAmbWV0cmljcy0+YnVmZmVyVXNhZ2UpOworCQkJc2hvd19idWZmZXJf dXNhZ2UoZXMsICZtZXRyaWNzLT5pbnN0ci5idWZ1c2FnZSk7CiAJCQllcy0+aW5kZW50LS07CiAJ CX0KIAl9CkBAIC0xMDM4LDEzICsxMDM2LDEzIEBAIEV4cGxhaW5QcmludFNlcmlhbGl6ZShFeHBs YWluU3RhdGUgKmVzLCBTZXJpYWxpemVNZXRyaWNzICptZXRyaWNzKQogCXsKIAkJaWYgKGVzLT50 aW1pbmcpCiAJCQlFeHBsYWluUHJvcGVydHlGbG9hdCgiVGltZSIsICJtcyIsCi0JCQkJCQkJCSAx MDAwLjAgKiBJTlNUUl9USU1FX0dFVF9ET1VCTEUobWV0cmljcy0+dGltZVNwZW50KSwKKwkJCQkJ CQkJIDEwMDAuMCAqIElOU1RSX1RJTUVfR0VUX0RPVUJMRShtZXRyaWNzLT5pbnN0ci50b3RhbCks CiAJCQkJCQkJCSAzLCBlcyk7CiAJCUV4cGxhaW5Qcm9wZXJ0eVVJbnRlZ2VyKCJPdXRwdXQgVm9s dW1lIiwgImtCIiwKIAkJCQkJCQkJQllURVNfVE9fS0lMT0JZVEVTKG1ldHJpY3MtPmJ5dGVzU2Vu dCksIGVzKTsKIAkJRXhwbGFpblByb3BlcnR5VGV4dCgiRm9ybWF0IiwgZm9ybWF0LCBlcyk7CiAJ CWlmIChlcy0+YnVmZmVycykKLQkJCXNob3dfYnVmZmVyX3VzYWdlKGVzLCAmbWV0cmljcy0+YnVm ZmVyVXNhZ2UpOworCQkJc2hvd19idWZmZXJfdXNhZ2UoZXMsICZtZXRyaWNzLT5pbnN0ci5idWZ1 c2FnZSk7CiAJfQogCiAJRXhwbGFpbkNsb3NlR3JvdXAoIlNlcmlhbGl6YXRpb24iLCAiU2VyaWFs aXphdGlvbiIsIHRydWUsIGVzKTsKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL2V4 cGxhaW5fZHIuYyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL2V4cGxhaW5fZHIuYwppbmRleCAzYzk2 MDYxY2YzMi4uMzRmZTRmOGY2ZGQgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL2V4 cGxhaW5fZHIuYworKysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy9leHBsYWluX2RyLmMKQEAgLTEx MCwxNSArMTEwLDExIEBAIHNlcmlhbGl6ZUFuYWx5emVSZWNlaXZlKFR1cGxlVGFibGVTbG90ICpz bG90LCBEZXN0UmVjZWl2ZXIgKnNlbGYpCiAJTWVtb3J5Q29udGV4dCBvbGRjb250ZXh0OwogCVN0 cmluZ0luZm8JYnVmID0gJm15U3RhdGUtPmJ1ZjsKIAlpbnQJCQluYXR0cyA9IHR5cGVpbmZvLT5u YXR0czsKLQlpbnN0cl90aW1lCXN0YXJ0LAotCQkJCWVuZDsKLQlCdWZmZXJVc2FnZSBpbnN0cl9z dGFydDsKKwlJbnN0cnVtZW50YXRpb24gKmluc3RyID0gJm15U3RhdGUtPm1ldHJpY3MuaW5zdHI7 CiAKIAkvKiBvbmx5IG1lYXN1cmUgdGltZSwgYnVmZmVycyBpZiByZXF1ZXN0ZWQgKi8KLQlpZiAo bXlTdGF0ZS0+ZXMtPnRpbWluZykKLQkJSU5TVFJfVElNRV9TRVRfQ1VSUkVOVChzdGFydCk7Ci0J aWYgKG15U3RhdGUtPmVzLT5idWZmZXJzKQotCQlpbnN0cl9zdGFydCA9IHBnQnVmZmVyVXNhZ2U7 CisJaWYgKGluc3RyLT5uZWVkX3RpbWVyIHx8IGluc3RyLT5uZWVkX2J1ZnVzYWdlKQorCQlJbnN0 clN0YXJ0KGluc3RyKTsKIAogCS8qIFNldCBvciB1cGRhdGUgbXkgZGVyaXZlZCBhdHRyaWJ1dGUg aW5mbywgaWYgbmVlZGVkICovCiAJaWYgKG15U3RhdGUtPmF0dHJpbmZvICE9IHR5cGVpbmZvIHx8 IG15U3RhdGUtPm5hdHRycyAhPSBuYXR0cykKQEAgLTE4NiwxOCArMTgyLDkgQEAgc2VyaWFsaXpl QW5hbHl6ZVJlY2VpdmUoVHVwbGVUYWJsZVNsb3QgKnNsb3QsIERlc3RSZWNlaXZlciAqc2VsZikK IAlNZW1vcnlDb250ZXh0U3dpdGNoVG8ob2xkY29udGV4dCk7CiAJTWVtb3J5Q29udGV4dFJlc2V0 KG15U3RhdGUtPnRtcGNvbnRleHQpOwogCi0JLyogVXBkYXRlIHRpbWluZyBkYXRhICovCi0JaWYg KG15U3RhdGUtPmVzLT50aW1pbmcpCi0JewotCQlJTlNUUl9USU1FX1NFVF9DVVJSRU5UKGVuZCk7 Ci0JCUlOU1RSX1RJTUVfQUNDVU1fRElGRihteVN0YXRlLT5tZXRyaWNzLnRpbWVTcGVudCwgZW5k LCBzdGFydCk7Ci0JfQotCi0JLyogVXBkYXRlIGJ1ZmZlciBtZXRyaWNzICovCi0JaWYgKG15U3Rh dGUtPmVzLT5idWZmZXJzKQotCQlCdWZmZXJVc2FnZUFjY3VtRGlmZigmbXlTdGF0ZS0+bWV0cmlj cy5idWZmZXJVc2FnZSwKLQkJCQkJCQkgJnBnQnVmZmVyVXNhZ2UsCi0JCQkJCQkJICZpbnN0cl9z dGFydCk7CisJLyogU3RvcCBwZXItdHVwbGUgbWVhc3VyZW1lbnQgKi8KKwlpZiAoaW5zdHItPm5l ZWRfdGltZXIgfHwgaW5zdHItPm5lZWRfYnVmdXNhZ2UpCisJCUluc3RyU3RvcChpbnN0cik7CiAK IAlyZXR1cm4gdHJ1ZTsKIH0KQEAgLTIzMyw5ICsyMjAsMTcgQEAgc2VyaWFsaXplQW5hbHl6ZVN0 YXJ0dXAoRGVzdFJlY2VpdmVyICpzZWxmLCBpbnQgb3BlcmF0aW9uLCBUdXBsZURlc2MgdHlwZWlu Zm8pCiAJLyogVGhlIG91dHB1dCBidWZmZXIgaXMgcmUtdXNlZCBhY3Jvc3Mgcm93cywgYXMgaW4g cHJpbnR0dXAuYyAqLwogCWluaXRTdHJpbmdJbmZvKCZyZWNlaXZlci0+YnVmKTsKIAotCS8qIElu aXRpYWxpemUgcmVzdWx0cyBjb3VudGVycyAqLworCS8qIEluaXRpYWxpemUgbWV0cmljcyBhbmQg cGVyLXR1cGxlIGluc3RydW1lbnRhdGlvbiAqLwogCW1lbXNldCgmcmVjZWl2ZXItPm1ldHJpY3Ms IDAsIHNpemVvZihTZXJpYWxpemVNZXRyaWNzKSk7Ci0JSU5TVFJfVElNRV9TRVRfWkVSTyhyZWNl aXZlci0+bWV0cmljcy50aW1lU3BlbnQpOworCXsKKwkJaW50CQkJaW5zdHJ1bWVudF9vcHRpb25z ID0gMDsKKworCQlpZiAocmVjZWl2ZXItPmVzLT50aW1pbmcpCisJCQlpbnN0cnVtZW50X29wdGlv bnMgfD0gSU5TVFJVTUVOVF9USU1FUjsKKwkJaWYgKHJlY2VpdmVyLT5lcy0+YnVmZmVycykKKwkJ CWluc3RydW1lbnRfb3B0aW9ucyB8PSBJTlNUUlVNRU5UX0JVRkZFUlM7CisJCUluc3RySW5pdE9w dGlvbnMoJnJlY2VpdmVyLT5tZXRyaWNzLmluc3RyLCBpbnN0cnVtZW50X29wdGlvbnMpOworCX0K IH0KIAogLyoKQEAgLTI5MCwyMiArMjg1LDE3IEBAIENyZWF0ZUV4cGxhaW5TZXJpYWxpemVEZXN0 UmVjZWl2ZXIoRXhwbGFpblN0YXRlICplcykKIH0KIAogLyoKLSAqIEdldFNlcmlhbGl6YXRpb25N ZXRyaWNzIC0gY29sbGVjdCBtZXRyaWNzCisgKiBHZXRTZXJpYWxpemF0aW9uTWV0cmljcyAtIGdl dCBzZXJpYWxpemF0aW9uIG1ldHJpY3MKICAqCi0gKiBXZSBoYXZlIHRvIGJlIGNhcmVmdWwgaGVy ZSBzaW5jZSB0aGUgcmVjZWl2ZXIgY291bGQgYmUgYW4gSW50b1JlbAotICogcmVjZWl2ZXIgaWYg dGhlIHN1YmplY3Qgc3RhdGVtZW50IGlzIENSRUFURSBUQUJMRSBBUy4gIEluIHRoYXQKLSAqIGNh c2UsIHJldHVybiBhbGwtemVyb2VzIHN0YXRzLgorICogUmV0dXJucyBhIHBvaW50ZXIgdG8gdGhl IFNlcmlhbGl6ZU1ldHJpY3MgaW5zaWRlIHRoZSBkZXN0IHJlY2VpdmVyLAorICogb3IgTlVMTCBp ZiB0aGUgcmVjZWl2ZXIgaXMgbm90IGEgU2VyaWFsaXplRGVzdFJlY2VpdmVyIChlLmcuIGFuIElu dG9SZWwKKyAqIHJlY2VpdmVyIGZvciBDUkVBVEUgVEFCTEUgQVMpLgogICovCi1TZXJpYWxpemVN ZXRyaWNzCitTZXJpYWxpemVNZXRyaWNzICoKIEdldFNlcmlhbGl6YXRpb25NZXRyaWNzKERlc3RS ZWNlaXZlciAqZGVzdCkKIHsKLQlTZXJpYWxpemVNZXRyaWNzIGVtcHR5OwotCiAJaWYgKGRlc3Qt Pm15ZGVzdCA9PSBEZXN0RXhwbGFpblNlcmlhbGl6ZSkKLQkJcmV0dXJuICgoU2VyaWFsaXplRGVz dFJlY2VpdmVyICopIGRlc3QpLT5tZXRyaWNzOwotCi0JbWVtc2V0KCZlbXB0eSwgMCwgc2l6ZW9m KFNlcmlhbGl6ZU1ldHJpY3MpKTsKLQlJTlNUUl9USU1FX1NFVF9aRVJPKGVtcHR5LnRpbWVTcGVu dCk7CisJCXJldHVybiAmKChTZXJpYWxpemVEZXN0UmVjZWl2ZXIgKikgZGVzdCktPm1ldHJpY3M7 CiAKLQlyZXR1cm4gZW1wdHk7CisJcmV0dXJuIE5VTEw7CiB9CmRpZmYgLS1naXQgYS9zcmMvYmFj a2VuZC9jb21tYW5kcy9wcmVwYXJlLmMgYi9zcmMvYmFja2VuZC9jb21tYW5kcy9wcmVwYXJlLmMK aW5kZXggODc2YWFkMjEwMGEuLmJmOWYyZWI2MTQ5IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9j b21tYW5kcy9wcmVwYXJlLmMKKysrIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvcHJlcGFyZS5jCkBA IC0yMiw2ICsyMiw3IEBACiAjaW5jbHVkZSAiY2F0YWxvZy9wZ190eXBlLmgiCiAjaW5jbHVkZSAi Y29tbWFuZHMvY3JlYXRlYXMuaCIKICNpbmNsdWRlICJjb21tYW5kcy9leHBsYWluLmgiCisjaW5j bHVkZSAiZXhlY3V0b3IvaW5zdHJ1bWVudC5oIgogI2luY2x1ZGUgImNvbW1hbmRzL2V4cGxhaW5f Zm9ybWF0LmgiCiAjaW5jbHVkZSAiY29tbWFuZHMvZXhwbGFpbl9zdGF0ZS5oIgogI2luY2x1ZGUg ImNvbW1hbmRzL3ByZXBhcmUuaCIKQEAgLTU4MCwxNCArNTgxLDE3IEBAIEV4cGxhaW5FeGVjdXRl UXVlcnkoRXhlY3V0ZVN0bXQgKmV4ZWNzdG10LCBJbnRvQ2xhdXNlICppbnRvLCBFeHBsYWluU3Rh dGUgKmVzLAogCUxpc3RDZWxsICAgKnA7CiAJUGFyYW1MaXN0SW5mbyBwYXJhbUxJID0gTlVMTDsK IAlFU3RhdGUJICAgKmVzdGF0ZSA9IE5VTEw7Ci0JaW5zdHJfdGltZQlwbGFuc3RhcnQ7Ci0JaW5z dHJfdGltZQlwbGFuZHVyYXRpb247Ci0JQnVmZmVyVXNhZ2UgYnVmdXNhZ2Vfc3RhcnQsCi0JCQkJ YnVmdXNhZ2U7CisJSW5zdHJ1bWVudGF0aW9uIHBsYW5faW5zdHIgPSB7MH07CisJaW50CQkJaW5z dHJ1bWVudF9vcHRpb25zID0gSU5TVFJVTUVOVF9USU1FUjsKIAlNZW1vcnlDb250ZXh0Q291bnRl cnMgbWVtX2NvdW50ZXJzOwogCU1lbW9yeUNvbnRleHQgcGxhbm5lcl9jdHggPSBOVUxMOwogCU1l bW9yeUNvbnRleHQgc2F2ZWRfY3R4ID0gTlVMTDsKIAorCWlmIChlcy0+YnVmZmVycykKKwkJaW5z dHJ1bWVudF9vcHRpb25zIHw9IElOU1RSVU1FTlRfQlVGRkVSUzsKKworCUluc3RySW5pdE9wdGlv bnMoJnBsYW5faW5zdHIsIGluc3RydW1lbnRfb3B0aW9ucyk7CisKIAlpZiAoZXMtPm1lbW9yeSkK IAl7CiAJCS8qIFNlZSBFeHBsYWluT25lUXVlcnkgYWJvdXQgdGhpcyAqLwpAQCAtNTk4LDkgKzYw Miw3IEBAIEV4cGxhaW5FeGVjdXRlUXVlcnkoRXhlY3V0ZVN0bXQgKmV4ZWNzdG10LCBJbnRvQ2xh dXNlICppbnRvLCBFeHBsYWluU3RhdGUgKmVzLAogCQlzYXZlZF9jdHggPSBNZW1vcnlDb250ZXh0 U3dpdGNoVG8ocGxhbm5lcl9jdHgpOwogCX0KIAotCWlmIChlcy0+YnVmZmVycykKLQkJYnVmdXNh Z2Vfc3RhcnQgPSBwZ0J1ZmZlclVzYWdlOwotCUlOU1RSX1RJTUVfU0VUX0NVUlJFTlQocGxhbnN0 YXJ0KTsKKwlJbnN0clN0YXJ0KCZwbGFuX2luc3RyKTsKIAogCS8qIExvb2sgaXQgdXAgaW4gdGhl IGhhc2ggdGFibGUgKi8KIAllbnRyeSA9IEZldGNoUHJlcGFyZWRTdGF0ZW1lbnQoZXhlY3N0bXQt Pm5hbWUsIHRydWUpOwpAQCAtNjM1LDggKzYzNyw3IEBAIEV4cGxhaW5FeGVjdXRlUXVlcnkoRXhl Y3V0ZVN0bXQgKmV4ZWNzdG10LCBJbnRvQ2xhdXNlICppbnRvLCBFeHBsYWluU3RhdGUgKmVzLAog CWNwbGFuID0gR2V0Q2FjaGVkUGxhbihlbnRyeS0+cGxhbnNvdXJjZSwgcGFyYW1MSSwKIAkJCQkJ CSAgQ3VycmVudFJlc291cmNlT3duZXIsIHBzdGF0ZS0+cF9xdWVyeUVudik7CiAKLQlJTlNUUl9U SU1FX1NFVF9DVVJSRU5UKHBsYW5kdXJhdGlvbik7Ci0JSU5TVFJfVElNRV9TVUJUUkFDVChwbGFu ZHVyYXRpb24sIHBsYW5zdGFydCk7CisJSW5zdHJTdG9wKCZwbGFuX2luc3RyKTsKIAogCWlmIChl cy0+bWVtb3J5KQogCXsKQEAgLTY0NCwxMyArNjQ1LDYgQEAgRXhwbGFpbkV4ZWN1dGVRdWVyeShF eGVjdXRlU3RtdCAqZXhlY3N0bXQsIEludG9DbGF1c2UgKmludG8sIEV4cGxhaW5TdGF0ZSAqZXMs CiAJCU1lbW9yeUNvbnRleHRNZW1Db25zdW1lZChwbGFubmVyX2N0eCwgJm1lbV9jb3VudGVycyk7 CiAJfQogCi0JLyogY2FsYyBkaWZmZXJlbmNlcyBvZiBidWZmZXIgY291bnRlcnMuICovCi0JaWYg KGVzLT5idWZmZXJzKQotCXsKLQkJbWVtc2V0KCZidWZ1c2FnZSwgMCwgc2l6ZW9mKEJ1ZmZlclVz YWdlKSk7Ci0JCUJ1ZmZlclVzYWdlQWNjdW1EaWZmKCZidWZ1c2FnZSwgJnBnQnVmZmVyVXNhZ2Us ICZidWZ1c2FnZV9zdGFydCk7Ci0JfQotCiAJcGxhbl9saXN0ID0gY3BsYW4tPnN0bXRfbGlzdDsK IAogCS8qIEV4cGxhaW4gZWFjaCBxdWVyeSAqLwpAQCAtNjYwLDcgKzY1NCw3IEBAIEV4cGxhaW5F eGVjdXRlUXVlcnkoRXhlY3V0ZVN0bXQgKmV4ZWNzdG10LCBJbnRvQ2xhdXNlICppbnRvLCBFeHBs YWluU3RhdGUgKmVzLAogCiAJCWlmIChwc3RtdC0+Y29tbWFuZFR5cGUgIT0gQ01EX1VUSUxJVFkp CiAJCQlFeHBsYWluT25lUGxhbihwc3RtdCwgaW50bywgZXMsIHF1ZXJ5X3N0cmluZywgcGFyYW1M SSwgcHN0YXRlLT5wX3F1ZXJ5RW52LAotCQkJCQkJICAgJnBsYW5kdXJhdGlvbiwgKGVzLT5idWZm ZXJzID8gJmJ1ZnVzYWdlIDogTlVMTCksCisJCQkJCQkgICAmcGxhbl9pbnN0ci50b3RhbCwgKGVz LT5idWZmZXJzID8gJnBsYW5faW5zdHIuYnVmdXNhZ2UgOiBOVUxMKSwKIAkJCQkJCSAgIGVzLT5t ZW1vcnkgPyAmbWVtX2NvdW50ZXJzIDogTlVMTCk7CiAJCWVsc2UKIAkJCUV4cGxhaW5PbmVVdGls aXR5KHBzdG10LT51dGlsaXR5U3RtdCwgaW50bywgZXMsIHBzdGF0ZSwgcGFyYW1MSSk7CmRpZmYg LS1naXQgYS9zcmMvaW5jbHVkZS9jb21tYW5kcy9leHBsYWluX2RyLmggYi9zcmMvaW5jbHVkZS9j b21tYW5kcy9leHBsYWluX2RyLmgKaW5kZXggZjk4ZWFhZTE4NjQuLmFiNWM1MzAyM2UxIDEwMDY0 NAotLS0gYS9zcmMvaW5jbHVkZS9jb21tYW5kcy9leHBsYWluX2RyLmgKKysrIGIvc3JjL2luY2x1 ZGUvY29tbWFuZHMvZXhwbGFpbl9kci5oCkBAIC0yMywxMSArMjMsMTAgQEAgdHlwZWRlZiBzdHJ1 Y3QgRXhwbGFpblN0YXRlIEV4cGxhaW5TdGF0ZTsKIHR5cGVkZWYgc3RydWN0IFNlcmlhbGl6ZU1l dHJpY3MKIHsKIAl1aW50NjQJCWJ5dGVzU2VudDsJCS8qICMgb2YgYnl0ZXMgc2VyaWFsaXplZCAq LwotCWluc3RyX3RpbWUJdGltZVNwZW50OwkJLyogdGltZSBzcGVudCBzZXJpYWxpemluZyAqLwot CUJ1ZmZlclVzYWdlIGJ1ZmZlclVzYWdlOwkvKiBidWZmZXJzIGFjY2Vzc2VkIGR1cmluZyBzZXJp YWxpemF0aW9uICovCisJSW5zdHJ1bWVudGF0aW9uIGluc3RyOwkJLyogdGltZSBhbmQgYnVmZmVy IHVzYWdlICovCiB9IFNlcmlhbGl6ZU1ldHJpY3M7CiAKIGV4dGVybiBEZXN0UmVjZWl2ZXIgKkNy ZWF0ZUV4cGxhaW5TZXJpYWxpemVEZXN0UmVjZWl2ZXIoRXhwbGFpblN0YXRlICplcyk7Ci1leHRl cm4gU2VyaWFsaXplTWV0cmljcyBHZXRTZXJpYWxpemF0aW9uTWV0cmljcyhEZXN0UmVjZWl2ZXIg KmRlc3QpOworZXh0ZXJuIFNlcmlhbGl6ZU1ldHJpY3MgKkdldFNlcmlhbGl6YXRpb25NZXRyaWNz KERlc3RSZWNlaXZlciAqZGVzdCk7CiAKICNlbmRpZgotLSAKMi40Ny4xCgo= --0000000000006d0cb0064eb5be7d Content-Type: application/octet-stream; name="v13-0005-Parallel-Bitmap-Heap-Scan-Fix-EXPLAIN-reporting-.patch" Content-Disposition: attachment; filename="v13-0005-Parallel-Bitmap-Heap-Scan-Fix-EXPLAIN-reporting-.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mnlqag6f4 RnJvbSAxMWM5MzY0YmIzM2Q2YzZjN2E4ZGU5ZTI2YmMyNDdlNzYxY2I1ODA4IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBMdWthcyBGaXR0bCA8bHVrYXNAZml0dGwuY29tPgpEYXRlOiBT dW4sIDUgQXByIDIwMjYgMDM6Mzk6NDYgLTA3MDAKU3ViamVjdDogW1BBVENIIHYxMyAwNS8xMl0g UGFyYWxsZWwgQml0bWFwIEhlYXAgU2NhbjogRml4IEVYUExBSU4gcmVwb3J0aW5nIG9mCiAiSGVh cCBCbG9ja3MiCgpGaXggdGhlIG1pc3NpbmcgYWNjdW11bGF0aW9uIG9mICJIZWFwIEJsb2NrcyIg ZnJvbSBwYXJhbGxlbCBxdWVyeSB3b3JrZXJzCnRvIHRoZSBsZWFkZXIsIGNhdXNpbmcgRVhQTEFJ TiAoQU5BTFlaRSkgdG8gb25seSBzaG93IHRoZSBsZWFkZXIgc3RhdGlzdGljcywKc2lnbmlmaWNh bnRseSB1bmRlcmNvdW50aW5nIHRoZSB0cnVlIHZhbHVlLgoKQWRkaXRpb25hbGx5LCBhZGQgYSBy ZWdyZXNzaW9uIHRlc3QgY292ZXJpbmcgRVhQTEFJTiAoQU5BTFlaRSkgb2YgYQpQYXJhbGxlbCBC aXRtYXAgSGVhcCBTY2FuLCB3aGljaCBwcmV2aW91c2x5IHdhcyBub3QgdGVzdGVkIGF0IGFsbC4K CkF1dGhvcjogTHVrYXMgRml0dGwgPGx1a2FzQGZpdHRsLmNvbT4KUmV2aWV3ZWQtYnk6CkRpc2N1 c3Npb24KLS0tCiBzcmMvYmFja2VuZC9jb21tYW5kcy9leHBsYWluLmMgICAgICAgIHwgMzMgKysr KysrKysrKysrKysrKysrKysrLS0tLS0tCiBzcmMvdGVzdC9yZWdyZXNzL2V4cGVjdGVkL2V4cGxh aW4ub3V0IHwgMzMgKysrKysrKysrKysrKysrKysrKysrKysrKysrCiBzcmMvdGVzdC9yZWdyZXNz L3NxbC9leHBsYWluLnNxbCAgICAgIHwgMzEgKysrKysrKysrKysrKysrKysrKysrKysrKwogMyBm aWxlcyBjaGFuZ2VkLCA5MCBpbnNlcnRpb25zKCspLCA3IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdp dCBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL2V4cGxhaW4uYyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRz L2V4cGxhaW4uYwppbmRleCBlNzU1MGE4YWM0Ni4uNzliZDRkOWQ2OWUgMTAwNjQ0Ci0tLSBhL3Ny Yy9iYWNrZW5kL2NvbW1hbmRzL2V4cGxhaW4uYworKysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy9l eHBsYWluLmMKQEAgLTM5MTksMjYgKzM5MTksNDUgQEAgc2hvd19pbmRleHNlYXJjaGVzX2luZm8o UGxhblN0YXRlICpwbGFuc3RhdGUsIEV4cGxhaW5TdGF0ZSAqZXMpCiBzdGF0aWMgdm9pZAogc2hv d190aWRiaXRtYXBfaW5mbyhCaXRtYXBIZWFwU2NhblN0YXRlICpwbGFuc3RhdGUsIEV4cGxhaW5T dGF0ZSAqZXMpCiB7CisJdWludDY0CQlleGFjdF9wYWdlczsKKwl1aW50NjQJCWxvc3N5X3BhZ2Vz OworCiAJaWYgKCFlcy0+YW5hbHl6ZSkKIAkJcmV0dXJuOwogCisJLyogU3RhcnQgd2l0aCBsZWFk ZXIncyBzdGF0cyAqLworCWV4YWN0X3BhZ2VzID0gcGxhbnN0YXRlLT5zdGF0cy5leGFjdF9wYWdl czsKKwlsb3NzeV9wYWdlcyA9IHBsYW5zdGF0ZS0+c3RhdHMubG9zc3lfcGFnZXM7CisKKwkvKiBB Y2N1bXVsYXRlIHdvcmtlciBzdGF0cyBpbnRvIG5vZGUtbGV2ZWwgdG90YWxzICovCisJaWYgKHBs YW5zdGF0ZS0+c2luc3RydW1lbnQgIT0gTlVMTCkKKwl7CisJCWZvciAoaW50IG4gPSAwOyBuIDwg cGxhbnN0YXRlLT5zaW5zdHJ1bWVudC0+bnVtX3dvcmtlcnM7IG4rKykKKwkJeworCQkJQml0bWFw SGVhcFNjYW5JbnN0cnVtZW50YXRpb24gKnNpID0gJnBsYW5zdGF0ZS0+c2luc3RydW1lbnQtPnNp bnN0cnVtZW50W25dOworCisJCQlleGFjdF9wYWdlcyArPSBzaS0+ZXhhY3RfcGFnZXM7CisJCQls b3NzeV9wYWdlcyArPSBzaS0+bG9zc3lfcGFnZXM7CisJCX0KKwl9CisKIAlpZiAoZXMtPmZvcm1h dCAhPSBFWFBMQUlOX0ZPUk1BVF9URVhUKQogCXsKIAkJRXhwbGFpblByb3BlcnR5VUludGVnZXIo IkV4YWN0IEhlYXAgQmxvY2tzIiwgTlVMTCwKLQkJCQkJCQkJcGxhbnN0YXRlLT5zdGF0cy5leGFj dF9wYWdlcywgZXMpOworCQkJCQkJCQlleGFjdF9wYWdlcywgZXMpOwogCQlFeHBsYWluUHJvcGVy dHlVSW50ZWdlcigiTG9zc3kgSGVhcCBCbG9ja3MiLCBOVUxMLAotCQkJCQkJCQlwbGFuc3RhdGUt PnN0YXRzLmxvc3N5X3BhZ2VzLCBlcyk7CisJCQkJCQkJCWxvc3N5X3BhZ2VzLCBlcyk7CiAJfQog CWVsc2UKIAl7Ci0JCWlmIChwbGFuc3RhdGUtPnN0YXRzLmV4YWN0X3BhZ2VzID4gMCB8fCBwbGFu c3RhdGUtPnN0YXRzLmxvc3N5X3BhZ2VzID4gMCkKKwkJaWYgKGV4YWN0X3BhZ2VzID4gMCB8fCBs b3NzeV9wYWdlcyA+IDApCiAJCXsKIAkJCUV4cGxhaW5JbmRlbnRUZXh0KGVzKTsKIAkJCWFwcGVu ZFN0cmluZ0luZm9TdHJpbmcoZXMtPnN0ciwgIkhlYXAgQmxvY2tzOiIpOwotCQkJaWYgKHBsYW5z dGF0ZS0+c3RhdHMuZXhhY3RfcGFnZXMgPiAwKQotCQkJCWFwcGVuZFN0cmluZ0luZm8oZXMtPnN0 ciwgIiBleGFjdD0iIFVJTlQ2NF9GT1JNQVQsIHBsYW5zdGF0ZS0+c3RhdHMuZXhhY3RfcGFnZXMp OwotCQkJaWYgKHBsYW5zdGF0ZS0+c3RhdHMubG9zc3lfcGFnZXMgPiAwKQotCQkJCWFwcGVuZFN0 cmluZ0luZm8oZXMtPnN0ciwgIiBsb3NzeT0iIFVJTlQ2NF9GT1JNQVQsIHBsYW5zdGF0ZS0+c3Rh dHMubG9zc3lfcGFnZXMpOworCQkJaWYgKGV4YWN0X3BhZ2VzID4gMCkKKwkJCQlhcHBlbmRTdHJp bmdJbmZvKGVzLT5zdHIsICIgZXhhY3Q9IiBVSU5UNjRfRk9STUFULCBleGFjdF9wYWdlcyk7CisJ CQlpZiAobG9zc3lfcGFnZXMgPiAwKQorCQkJCWFwcGVuZFN0cmluZ0luZm8oZXMtPnN0ciwgIiBs b3NzeT0iIFVJTlQ2NF9GT1JNQVQsIGxvc3N5X3BhZ2VzKTsKIAkJCWFwcGVuZFN0cmluZ0luZm9D aGFyKGVzLT5zdHIsICdcbicpOwogCQl9CiAJfQpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvcmVncmVz cy9leHBlY3RlZC9leHBsYWluLm91dCBiL3NyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQvZXhwbGFp bi5vdXQKaW5kZXggN2MxZjI2YjE4MmMuLjU4YzVhNTEyZDc0IDEwMDY0NAotLS0gYS9zcmMvdGVz dC9yZWdyZXNzL2V4cGVjdGVkL2V4cGxhaW4ub3V0CisrKyBiL3NyYy90ZXN0L3JlZ3Jlc3MvZXhw ZWN0ZWQvZXhwbGFpbi5vdXQKQEAgLTgyMiwzICs4MjIsMzYgQEAgc2VsZWN0IGV4cGxhaW5fZmls dGVyKCdleHBsYWluIChhbmFseXplLGJ1ZmZlcnMgb2ZmLGNvc3RzIG9mZikgc2VsZWN0IHN1bShu KSBvdmUKICg5IHJvd3MpCiAKIHJlc2V0IHdvcmtfbWVtOworLS0gVGVzdCBwYXJhbGxlbCBiaXRt YXAgaGVhcCBzY2FuIHJlcG9ydHMgcGVyLXdvcmtlciBoZWFwIGJsb2NrIHN0YXRzLgorQ1JFQVRF IEZVTkNUSU9OIGNoZWNrX3BhcmFsbGVsX2JpdG1hcF9oZWFwX3NjYW4oKSBSRVRVUk5TIGJvb2xl YW4gQVMgJCQKK0RFQ0xBUkUKKyAgICBwbGFuX2pzb24ganNvbjsKKyAgICBub2RlIGpzb247CitC RUdJTgorICAgIFNFVCBMT0NBTCBlbmFibGVfc2Vxc2NhbiA9IG9mZjsKKyAgICBTRVQgTE9DQUwg ZW5hYmxlX2luZGV4c2NhbiA9IG9mZjsKKyAgICBTRVQgTE9DQUwgcGFyYWxsZWxfc2V0dXBfY29z dCA9IDA7CisgICAgU0VUIExPQ0FMIHBhcmFsbGVsX3R1cGxlX2Nvc3QgPSAwOworICAgIFNFVCBM T0NBTCBtaW5fcGFyYWxsZWxfdGFibGVfc2Nhbl9zaXplID0gMDsKKyAgICBTRVQgTE9DQUwgbWlu X3BhcmFsbGVsX2luZGV4X3NjYW5fc2l6ZSA9IDA7CisgICAgU0VUIExPQ0FMIG1heF9wYXJhbGxl bF93b3JrZXJzX3Blcl9nYXRoZXIgPSAyOworICAgIFNFVCBMT0NBTCBwYXJhbGxlbF9sZWFkZXJf cGFydGljaXBhdGlvbiA9IG9mZjsKKworICAgIEVYRUNVVEUgJ0VYUExBSU4gKEFOQUxZWkUsIEJV RkZFUlMsIENPU1RTIE9GRiwgRk9STUFUIEpTT04pCisgICAgICAgIFNFTEVDVCBjb3VudCgqKSBG Uk9NIHRlbmsxIFdIRVJFIGh1bmRyZWQgPiAxJyBJTlRPIHBsYW5fanNvbjsKKworICAgIG5vZGUg Oj0gcGxhbl9qc29uLT4wLT4nUGxhbic7CisgICAgV0hJTEUgbm9kZS0+J1BsYW5zJyBJUyBOT1Qg TlVMTCBBTkQgbm9kZS0+PidOb2RlIFR5cGUnICE9ICdCaXRtYXAgSGVhcCBTY2FuJyBMT09QCisg ICAgICAgIG5vZGUgOj0gbm9kZS0+J1BsYW5zJy0+MDsKKyAgICBFTkQgTE9PUDsKKworICAgIFJF VFVSTiBDT0FMRVNDRSgobm9kZS0+PidFeGFjdCBIZWFwIEJsb2NrcycpOjppbnQsIDApID4gMDsK K0VORDsKKyQkIExBTkdVQUdFIHBscGdzcWw7CitTRUxFQ1QgY2hlY2tfcGFyYWxsZWxfYml0bWFw X2hlYXBfc2NhbigpIEFTIHBhcmFsbGVsX2JpdG1hcF9pbnN0cnVtZW50YXRpb247CisgcGFyYWxs ZWxfYml0bWFwX2luc3RydW1lbnRhdGlvbiAKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLQorIHQKKygxIHJvdykKKworRFJPUCBGVU5DVElPTiBjaGVja19wYXJhbGxlbF9iaXRtYXBf aGVhcF9zY2FuOwpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvcmVncmVzcy9zcWwvZXhwbGFpbi5zcWwg Yi9zcmMvdGVzdC9yZWdyZXNzL3NxbC9leHBsYWluLnNxbAppbmRleCBlYmRhYjQyNjA0Yi4uYmFj OTc1MjIwNTMgMTAwNjQ0Ci0tLSBhL3NyYy90ZXN0L3JlZ3Jlc3Mvc3FsL2V4cGxhaW4uc3FsCisr KyBiL3NyYy90ZXN0L3JlZ3Jlc3Mvc3FsL2V4cGxhaW4uc3FsCkBAIC0xODgsMyArMTg4LDM0IEBA IHNlbGVjdCBleHBsYWluX2ZpbHRlcignZXhwbGFpbiAoYW5hbHl6ZSxidWZmZXJzIG9mZixjb3N0 cyBvZmYpIHNlbGVjdCBzdW0obikgb3ZlCiAtLSBUZXN0IHR1cGxlc3RvcmUgc3RvcmFnZSB1c2Fn ZSBpbiBXaW5kb3cgYWdncmVnYXRlIChtZW1vcnkgYW5kIGRpc2sgY2FzZSwgZmluYWwgcmVzdWx0 IGlzIGRpc2spCiBzZWxlY3QgZXhwbGFpbl9maWx0ZXIoJ2V4cGxhaW4gKGFuYWx5emUsYnVmZmVy cyBvZmYsY29zdHMgb2ZmKSBzZWxlY3Qgc3VtKG4pIG92ZXIocGFydGl0aW9uIGJ5IG0pIGZyb20g KFNFTEVDVCBuIDwgMyBhcyBtLCBuIGZyb20gZ2VuZXJhdGVfc2VyaWVzKDEsMjUwMCkgYShuKSkn KTsKIHJlc2V0IHdvcmtfbWVtOworCistLSBUZXN0IHBhcmFsbGVsIGJpdG1hcCBoZWFwIHNjYW4g cmVwb3J0cyBwZXItd29ya2VyIGhlYXAgYmxvY2sgc3RhdHMuCitDUkVBVEUgRlVOQ1RJT04gY2hl Y2tfcGFyYWxsZWxfYml0bWFwX2hlYXBfc2NhbigpIFJFVFVSTlMgYm9vbGVhbiBBUyAkJAorREVD TEFSRQorICAgIHBsYW5fanNvbiBqc29uOworICAgIG5vZGUganNvbjsKK0JFR0lOCisgICAgU0VU IExPQ0FMIGVuYWJsZV9zZXFzY2FuID0gb2ZmOworICAgIFNFVCBMT0NBTCBlbmFibGVfaW5kZXhz Y2FuID0gb2ZmOworICAgIFNFVCBMT0NBTCBwYXJhbGxlbF9zZXR1cF9jb3N0ID0gMDsKKyAgICBT RVQgTE9DQUwgcGFyYWxsZWxfdHVwbGVfY29zdCA9IDA7CisgICAgU0VUIExPQ0FMIG1pbl9wYXJh bGxlbF90YWJsZV9zY2FuX3NpemUgPSAwOworICAgIFNFVCBMT0NBTCBtaW5fcGFyYWxsZWxfaW5k ZXhfc2Nhbl9zaXplID0gMDsKKyAgICBTRVQgTE9DQUwgbWF4X3BhcmFsbGVsX3dvcmtlcnNfcGVy X2dhdGhlciA9IDI7CisgICAgU0VUIExPQ0FMIHBhcmFsbGVsX2xlYWRlcl9wYXJ0aWNpcGF0aW9u ID0gb2ZmOworCisgICAgRVhFQ1VURSAnRVhQTEFJTiAoQU5BTFlaRSwgQlVGRkVSUywgQ09TVFMg T0ZGLCBGT1JNQVQgSlNPTikKKyAgICAgICAgU0VMRUNUIGNvdW50KCopIEZST00gdGVuazEgV0hF UkUgaHVuZHJlZCA+IDEnIElOVE8gcGxhbl9qc29uOworCisgICAgbm9kZSA6PSBwbGFuX2pzb24t PjAtPidQbGFuJzsKKyAgICBXSElMRSBub2RlLT4nUGxhbnMnIElTIE5PVCBOVUxMIEFORCBub2Rl LT4+J05vZGUgVHlwZScgIT0gJ0JpdG1hcCBIZWFwIFNjYW4nIExPT1AKKyAgICAgICAgbm9kZSA6 PSBub2RlLT4nUGxhbnMnLT4wOworICAgIEVORCBMT09QOworCisgICAgUkVUVVJOIENPQUxFU0NF KChub2RlLT4+J0V4YWN0IEhlYXAgQmxvY2tzJyk6OmludCwgMCkgPiAwOworRU5EOworJCQgTEFO R1VBR0UgcGxwZ3NxbDsKKworU0VMRUNUIGNoZWNrX3BhcmFsbGVsX2JpdG1hcF9oZWFwX3NjYW4o KSBBUyBwYXJhbGxlbF9iaXRtYXBfaW5zdHJ1bWVudGF0aW9uOworCitEUk9QIEZVTkNUSU9OIGNo ZWNrX3BhcmFsbGVsX2JpdG1hcF9oZWFwX3NjYW47Ci0tIAoyLjQ3LjEKCg== --0000000000006d0cb0064eb5be7d Content-Type: application/octet-stream; name="v13-0001-instrumentation-Separate-trigger-logic-from-othe.patch" Content-Disposition: attachment; filename="v13-0001-instrumentation-Separate-trigger-logic-from-othe.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mnlqag4x0 RnJvbSA5MTM0YjgyNzVjNDRkZmRhYmVlZThkMDg2NDlkYTFhNGI1Yzc1ZGFhIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBMdWthcyBGaXR0bCA8bHVrYXNAZml0dGwuY29tPgpEYXRlOiBT YXQsIDEgTWFyIDIwMjUgMTk6MzE6MzAgLTA4MDAKU3ViamVjdDogW1BBVENIIHYxMyAwMS8xMl0g aW5zdHJ1bWVudGF0aW9uOiBTZXBhcmF0ZSB0cmlnZ2VyIGxvZ2ljIGZyb20gb3RoZXIKIHVzZXMK CkludHJvZHVjZSBUcmlnZ2VySW5zdHJ1bWVudGF0aW9uIHRvIGNhcHR1cmUgdHJpZ2dlciB0aW1p bmcgYW5kIGZpcmluZ3MKKHByZXZpb3VzbHkgY291bnRlZCBpbiAibnR1cGxlcyIpLCB0byBhaWQg YSBmdXR1cmUgcmVmYWN0b3JpbmcgdGhhdApzcGxpdHMgb3V0IGFsbCBJbnN0cnVtZW50YXRpb24g ZmllbGRzIGJleW9uZCB0aW1pbmcgYW5kIFdBTC9idWZmZXJzIGludG8KbW9yZSBzcGVjaWZpYyBz dHJ1Y3RzLgoKQXV0aG9yOiBMdWthcyBGaXR0bCA8bHVrYXNAZml0dGwuY29tPgpSZXZpZXdlZC1i eToKRGlzY3Vzc2lvbjoKLS0tCiBzcmMvYmFja2VuZC9jb21tYW5kcy9leHBsYWluLmMgICAgfCAx OSArKysrKysrKy0tLS0tLS0tLS0tCiBzcmMvYmFja2VuZC9jb21tYW5kcy90cmlnZ2VyLmMgICAg fCAyMiArKysrKysrKysrKy0tLS0tLS0tLS0tCiBzcmMvYmFja2VuZC9leGVjdXRvci9leGVjTWFp bi5jICAgfCAgMiArLQogc3JjL2JhY2tlbmQvZXhlY3V0b3IvaW5zdHJ1bWVudC5jIHwgMjYgKysr KysrKysrKysrKysrKysrKysrKysrKysKIHNyYy9pbmNsdWRlL2V4ZWN1dG9yL2luc3RydW1lbnQu aCB8IDEyICsrKysrKysrKysrKwogc3JjL2luY2x1ZGUvbm9kZXMvZXhlY25vZGVzLmggICAgIHwg IDMgKystCiBzcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdCAgfCAgMSArCiA3IGZpbGVz IGNoYW5nZWQsIDYxIGluc2VydGlvbnMoKyksIDI0IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBh L3NyYy9iYWNrZW5kL2NvbW1hbmRzL2V4cGxhaW4uYyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL2V4 cGxhaW4uYwppbmRleCBlNGI3MDE2NmIwZS4uZWI2ZWYyM2MyZDYgMTAwNjQ0Ci0tLSBhL3NyYy9i YWNrZW5kL2NvbW1hbmRzL2V4cGxhaW4uYworKysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy9leHBs YWluLmMKQEAgLTExMDEsMTggKzExMDEsMTUgQEAgcmVwb3J0X3RyaWdnZXJzKFJlc3VsdFJlbElu Zm8gKnJJbmZvLCBib29sIHNob3dfcmVsbmFtZSwgRXhwbGFpblN0YXRlICplcykKIAlmb3IgKG50 ID0gMDsgbnQgPCBySW5mby0+cmlfVHJpZ0Rlc2MtPm51bXRyaWdnZXJzOyBudCsrKQogCXsKIAkJ VHJpZ2dlciAgICAqdHJpZyA9IHJJbmZvLT5yaV9UcmlnRGVzYy0+dHJpZ2dlcnMgKyBudDsKLQkJ SW5zdHJ1bWVudGF0aW9uICppbnN0ciA9IHJJbmZvLT5yaV9UcmlnSW5zdHJ1bWVudCArIG50Owor CQlUcmlnZ2VySW5zdHJ1bWVudGF0aW9uICp0Z2luc3RyID0gckluZm8tPnJpX1RyaWdJbnN0cnVt ZW50ICsgbnQ7CiAJCWNoYXIJICAgKnJlbG5hbWU7CiAJCWNoYXIJICAgKmNvbm5hbWUgPSBOVUxM OwogCi0JCS8qIE11c3QgY2xlYW4gdXAgaW5zdHJ1bWVudGF0aW9uIHN0YXRlICovCi0JCUluc3Ry RW5kTG9vcChpbnN0cik7Ci0KIAkJLyoKIAkJICogV2UgaWdub3JlIHRyaWdnZXJzIHRoYXQgd2Vy ZSBuZXZlciBpbnZva2VkOyB0aGV5IGxpa2VseSBhcmVuJ3QKIAkJICogcmVsZXZhbnQgdG8gdGhl IGN1cnJlbnQgcXVlcnkgdHlwZS4KIAkJICovCi0JCWlmIChpbnN0ci0+bnR1cGxlcyA9PSAwKQor CQlpZiAodGdpbnN0ci0+ZmlyaW5ncyA9PSAwKQogCQkJY29udGludWU7CiAKIAkJRXhwbGFpbk9w ZW5Hcm91cCgiVHJpZ2dlciIsIE5VTEwsIHRydWUsIGVzKTsKQEAgLTExMzcsMTEgKzExMzQsMTEg QEAgcmVwb3J0X3RyaWdnZXJzKFJlc3VsdFJlbEluZm8gKnJJbmZvLCBib29sIHNob3dfcmVsbmFt ZSwgRXhwbGFpblN0YXRlICplcykKIAkJCWlmIChzaG93X3JlbG5hbWUpCiAJCQkJYXBwZW5kU3Ry aW5nSW5mbyhlcy0+c3RyLCAiIG9uICVzIiwgcmVsbmFtZSk7CiAJCQlpZiAoZXMtPnRpbWluZykK LQkJCQlhcHBlbmRTdHJpbmdJbmZvKGVzLT5zdHIsICI6IHRpbWU9JS4zZiBjYWxscz0lLjBmXG4i LAotCQkJCQkJCQkgSU5TVFJfVElNRV9HRVRfTUlMTElTRUMoaW5zdHItPnRvdGFsKSwKLQkJCQkJ CQkJIGluc3RyLT5udHVwbGVzKTsKKwkJCQlhcHBlbmRTdHJpbmdJbmZvKGVzLT5zdHIsICI6IHRp bWU9JS4zZiBjYWxscz0lZFxuIiwKKwkJCQkJCQkJIElOU1RSX1RJTUVfR0VUX01JTExJU0VDKHRn aW5zdHItPmluc3RyLnRvdGFsKSwKKwkJCQkJCQkJIHRnaW5zdHItPmZpcmluZ3MpOwogCQkJZWxz ZQotCQkJCWFwcGVuZFN0cmluZ0luZm8oZXMtPnN0ciwgIjogY2FsbHM9JS4wZlxuIiwgaW5zdHIt Pm50dXBsZXMpOworCQkJCWFwcGVuZFN0cmluZ0luZm8oZXMtPnN0ciwgIjogY2FsbHM9JWRcbiIs IHRnaW5zdHItPmZpcmluZ3MpOwogCQl9CiAJCWVsc2UKIAkJewpAQCAtMTE1MSw5ICsxMTQ4LDkg QEAgcmVwb3J0X3RyaWdnZXJzKFJlc3VsdFJlbEluZm8gKnJJbmZvLCBib29sIHNob3dfcmVsbmFt ZSwgRXhwbGFpblN0YXRlICplcykKIAkJCUV4cGxhaW5Qcm9wZXJ0eVRleHQoIlJlbGF0aW9uIiwg cmVsbmFtZSwgZXMpOwogCQkJaWYgKGVzLT50aW1pbmcpCiAJCQkJRXhwbGFpblByb3BlcnR5Rmxv YXQoIlRpbWUiLCAibXMiLAotCQkJCQkJCQkJIElOU1RSX1RJTUVfR0VUX01JTExJU0VDKGluc3Ry LT50b3RhbCksIDMsCisJCQkJCQkJCQkgSU5TVFJfVElNRV9HRVRfTUlMTElTRUModGdpbnN0ci0+ aW5zdHIudG90YWwpLCAzLAogCQkJCQkJCQkJIGVzKTsKLQkJCUV4cGxhaW5Qcm9wZXJ0eUZsb2F0 KCJDYWxscyIsIE5VTEwsIGluc3RyLT5udHVwbGVzLCAwLCBlcyk7CisJCQlFeHBsYWluUHJvcGVy dHlJbnRlZ2VyKCJDYWxscyIsIE5VTEwsIHRnaW5zdHItPmZpcmluZ3MsIGVzKTsKIAkJfQogCiAJ CWlmIChjb25uYW1lKQpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdHJpZ2dlci5j IGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvdHJpZ2dlci5jCmluZGV4IDkwZTk0ZmI4YTVhLi40ZDRl OTZhNTMwMiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdHJpZ2dlci5jCisrKyBi L3NyYy9iYWNrZW5kL2NvbW1hbmRzL3RyaWdnZXIuYwpAQCAtOTIsNyArOTIsNyBAQCBzdGF0aWMg Ym9vbCBUcmlnZ2VyRW5hYmxlZChFU3RhdGUgKmVzdGF0ZSwgUmVzdWx0UmVsSW5mbyAqcmVsaW5m bywKIHN0YXRpYyBIZWFwVHVwbGUgRXhlY0NhbGxUcmlnZ2VyRnVuYyhUcmlnZ2VyRGF0YSAqdHJp Z2RhdGEsCiAJCQkJCQkJCQkgaW50IHRnaW5keCwKIAkJCQkJCQkJCSBGbWdySW5mbyAqZmluZm8s Ci0JCQkJCQkJCQkgSW5zdHJ1bWVudGF0aW9uICppbnN0ciwKKwkJCQkJCQkJCSBUcmlnZ2VySW5z dHJ1bWVudGF0aW9uICppbnN0ciwKIAkJCQkJCQkJCSBNZW1vcnlDb250ZXh0IHBlcl90dXBsZV9j b250ZXh0KTsKIHN0YXRpYyB2b2lkIEFmdGVyVHJpZ2dlclNhdmVFdmVudChFU3RhdGUgKmVzdGF0 ZSwgUmVzdWx0UmVsSW5mbyAqcmVsaW5mbywKIAkJCQkJCQkJICBSZXN1bHRSZWxJbmZvICpzcmNf cGFydGluZm8sCkBAIC0yMzExLDcgKzIzMTEsNyBAQCBzdGF0aWMgSGVhcFR1cGxlCiBFeGVjQ2Fs bFRyaWdnZXJGdW5jKFRyaWdnZXJEYXRhICp0cmlnZGF0YSwKIAkJCQkJaW50IHRnaW5keCwKIAkJ CQkJRm1nckluZm8gKmZpbmZvLAotCQkJCQlJbnN0cnVtZW50YXRpb24gKmluc3RyLAorCQkJCQlU cmlnZ2VySW5zdHJ1bWVudGF0aW9uICppbnN0ciwKIAkJCQkJTWVtb3J5Q29udGV4dCBwZXJfdHVw bGVfY29udGV4dCkKIHsKIAlMT0NBTF9GQ0lORk8oZmNpbmZvLCAwKTsKQEAgLTIzNDYsNyArMjM0 Niw3IEBAIEV4ZWNDYWxsVHJpZ2dlckZ1bmMoVHJpZ2dlckRhdGEgKnRyaWdkYXRhLAogCSAqIElm IGRvaW5nIEVYUExBSU4gQU5BTFlaRSwgc3RhcnQgY2hhcmdpbmcgdGltZSB0byB0aGlzIHRyaWdn ZXIuCiAJICovCiAJaWYgKGluc3RyKQotCQlJbnN0clN0YXJ0Tm9kZShpbnN0ciArIHRnaW5keCk7 CisJCUluc3RyU3RhcnRUcmlnZ2VyKGluc3RyICsgdGdpbmR4KTsKIAogCS8qCiAJICogRG8gdGhl IGZ1bmN0aW9uIGV2YWx1YXRpb24gaW4gdGhlIHBlci10dXBsZSBtZW1vcnkgY29udGV4dCwgc28g dGhhdApAQCAtMjM5MSwxMCArMjM5MSwxMCBAQCBFeGVjQ2FsbFRyaWdnZXJGdW5jKFRyaWdnZXJE YXRhICp0cmlnZGF0YSwKIAogCS8qCiAJICogSWYgZG9pbmcgRVhQTEFJTiBBTkFMWVpFLCBzdG9w IGNoYXJnaW5nIHRpbWUgdG8gdGhpcyB0cmlnZ2VyLCBhbmQgY291bnQKLQkgKiBvbmUgInR1cGxl IHJldHVybmVkIiAocmVhbGx5IHRoZSBudW1iZXIgb2YgZmlyaW5ncykuCisJICogdGhlIGZpcmlu ZyBvZiB0aGUgdHJpZ2dlci4KIAkgKi8KIAlpZiAoaW5zdHIpCi0JCUluc3RyU3RvcE5vZGUoaW5z dHIgKyB0Z2luZHgsIDEpOworCQlJbnN0clN0b3BUcmlnZ2VyKGluc3RyICsgdGdpbmR4LCAxKTsK IAogCXJldHVybiAoSGVhcFR1cGxlKSBEYXR1bUdldFBvaW50ZXIocmVzdWx0KTsKIH0KQEAgLTM5 NDcsNyArMzk0Nyw3IEBAIHN0YXRpYyB2b2lkIEFmdGVyVHJpZ2dlckV4ZWN1dGUoRVN0YXRlICpl c3RhdGUsCiAJCQkJCQkJCVJlc3VsdFJlbEluZm8gKmRzdF9yZWxJbmZvLAogCQkJCQkJCQlUcmln Z2VyRGVzYyAqdHJpZ2Rlc2MsCiAJCQkJCQkJCUZtZ3JJbmZvICpmaW5mbywKLQkJCQkJCQkJSW5z dHJ1bWVudGF0aW9uICppbnN0ciwKKwkJCQkJCQkJVHJpZ2dlckluc3RydW1lbnRhdGlvbiAqaW5z dHIsCiAJCQkJCQkJCU1lbW9yeUNvbnRleHQgcGVyX3R1cGxlX2NvbnRleHQsCiAJCQkJCQkJCVR1 cGxlVGFibGVTbG90ICp0cmlnX3R1cGxlX3Nsb3QxLAogCQkJCQkJCQlUdXBsZVRhYmxlU2xvdCAq dHJpZ190dXBsZV9zbG90Mik7CkBAIC00MzQyLDcgKzQzNDIsNyBAQCBBZnRlclRyaWdnZXJFeGVj dXRlKEVTdGF0ZSAqZXN0YXRlLAogCQkJCQlSZXN1bHRSZWxJbmZvICpzcmNfcmVsSW5mbywKIAkJ CQkJUmVzdWx0UmVsSW5mbyAqZHN0X3JlbEluZm8sCiAJCQkJCVRyaWdnZXJEZXNjICp0cmlnZGVz YywKLQkJCQkJRm1nckluZm8gKmZpbmZvLCBJbnN0cnVtZW50YXRpb24gKmluc3RyLAorCQkJCQlG bWdySW5mbyAqZmluZm8sIFRyaWdnZXJJbnN0cnVtZW50YXRpb24gKmluc3RyLAogCQkJCQlNZW1v cnlDb250ZXh0IHBlcl90dXBsZV9jb250ZXh0LAogCQkJCQlUdXBsZVRhYmxlU2xvdCAqdHJpZ190 dXBsZV9zbG90MSwKIAkJCQkJVHVwbGVUYWJsZVNsb3QgKnRyaWdfdHVwbGVfc2xvdDIpCkBAIC00 MzgzLDcgKzQzODMsNyBAQCBBZnRlclRyaWdnZXJFeGVjdXRlKEVTdGF0ZSAqZXN0YXRlLAogCSAq IHRvIGluY2x1ZGUgdGltZSBzcGVudCByZS1mZXRjaGluZyB0dXBsZXMgaW4gdGhlIHRyaWdnZXIg Y29zdC4KIAkgKi8KIAlpZiAoaW5zdHIpCi0JCUluc3RyU3RhcnROb2RlKGluc3RyICsgdGdpbmR4 KTsKKwkJSW5zdHJTdGFydFRyaWdnZXIoaW5zdHIgKyB0Z2luZHgpOwogCiAJLyoKIAkgKiBGZXRj aCB0aGUgcmVxdWlyZWQgdHVwbGUocykuCkBAIC00NjAwLDEwICs0NjAwLDEwIEBAIEFmdGVyVHJp Z2dlckV4ZWN1dGUoRVN0YXRlICplc3RhdGUsCiAKIAkvKgogCSAqIElmIGRvaW5nIEVYUExBSU4g QU5BTFlaRSwgc3RvcCBjaGFyZ2luZyB0aW1lIHRvIHRoaXMgdHJpZ2dlciwgYW5kIGNvdW50Ci0J ICogb25lICJ0dXBsZSByZXR1cm5lZCIgKHJlYWxseSB0aGUgbnVtYmVyIG9mIGZpcmluZ3MpLgor CSAqIHRoZSBmaXJpbmcgb2YgdGhlIHRyaWdnZXIuCiAJICovCiAJaWYgKGluc3RyKQotCQlJbnN0 clN0b3BOb2RlKGluc3RyICsgdGdpbmR4LCAxKTsKKwkJSW5zdHJTdG9wVHJpZ2dlcihpbnN0ciAr IHRnaW5keCwgMSk7CiB9CiAKIApAQCAtNDcxOSw3ICs0NzE5LDcgQEAgYWZ0ZXJUcmlnZ2VySW52 b2tlRXZlbnRzKEFmdGVyVHJpZ2dlckV2ZW50TGlzdCAqZXZlbnRzLAogCVJlbGF0aW9uCXJlbCA9 IE5VTEw7CiAJVHJpZ2dlckRlc2MgKnRyaWdkZXNjID0gTlVMTDsKIAlGbWdySW5mbyAgICpmaW5m byA9IE5VTEw7Ci0JSW5zdHJ1bWVudGF0aW9uICppbnN0ciA9IE5VTEw7CisJVHJpZ2dlckluc3Ry dW1lbnRhdGlvbiAqaW5zdHIgPSBOVUxMOwogCVR1cGxlVGFibGVTbG90ICpzbG90MSA9IE5VTEws CiAJCQkgICAqc2xvdDIgPSBOVUxMOwogCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9leGVjdXRv ci9leGVjTWFpbi5jIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY01haW4uYwppbmRleCA0NWUw MGM2YWY4NS4uMDIzN2Q4YzNiMWQgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4 ZWNNYWluLmMKKysrIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY01haW4uYwpAQCAtMTI4NSw3 ICsxMjg1LDcgQEAgSW5pdFJlc3VsdFJlbEluZm8oUmVzdWx0UmVsSW5mbyAqcmVzdWx0UmVsSW5m bywKIAkJcmVzdWx0UmVsSW5mby0+cmlfVHJpZ1doZW5FeHBycyA9IChFeHByU3RhdGUgKiopCiAJ CQlwYWxsb2MwX2FycmF5KEV4cHJTdGF0ZSAqLCBuKTsKIAkJaWYgKGluc3RydW1lbnRfb3B0aW9u cykKLQkJCXJlc3VsdFJlbEluZm8tPnJpX1RyaWdJbnN0cnVtZW50ID0gSW5zdHJBbGxvYyhuLCBp bnN0cnVtZW50X29wdGlvbnMsIGZhbHNlKTsKKwkJCXJlc3VsdFJlbEluZm8tPnJpX1RyaWdJbnN0 cnVtZW50ID0gSW5zdHJBbGxvY1RyaWdnZXIobiwgaW5zdHJ1bWVudF9vcHRpb25zKTsKIAl9CiAJ ZWxzZQogCXsKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2luc3RydW1lbnQuYyBi L3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2luc3RydW1lbnQuYwppbmRleCBhNDA2MTBiYzI1Mi4uOTM1 NGFkN2JlMTIgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2luc3RydW1lbnQuYwor KysgYi9zcmMvYmFja2VuZC9leGVjdXRvci9pbnN0cnVtZW50LmMKQEAgLTE5Niw2ICsxOTYsMzIg QEAgSW5zdHJBZ2dOb2RlKEluc3RydW1lbnRhdGlvbiAqZHN0LCBJbnN0cnVtZW50YXRpb24gKmFk ZCkKIAkJV2FsVXNhZ2VBZGQoJmRzdC0+d2FsdXNhZ2UsICZhZGQtPndhbHVzYWdlKTsKIH0KIAor LyogVHJpZ2dlciBpbnN0cnVtZW50YXRpb24gaGFuZGxpbmcgKi8KK1RyaWdnZXJJbnN0cnVtZW50 YXRpb24gKgorSW5zdHJBbGxvY1RyaWdnZXIoaW50IG4sIGludCBpbnN0cnVtZW50X29wdGlvbnMp Cit7CisJVHJpZ2dlckluc3RydW1lbnRhdGlvbiAqdGdpbnN0ciA9IHBhbGxvYzAobiAqIHNpemVv ZihUcmlnZ2VySW5zdHJ1bWVudGF0aW9uKSk7CisJaW50CQkJaTsKKworCWZvciAoaSA9IDA7IGkg PCBuOyBpKyspCisJCUluc3RySW5pdCgmdGdpbnN0cltpXS5pbnN0ciwgaW5zdHJ1bWVudF9vcHRp b25zKTsKKworCXJldHVybiB0Z2luc3RyOworfQorCit2b2lkCitJbnN0clN0YXJ0VHJpZ2dlcihU cmlnZ2VySW5zdHJ1bWVudGF0aW9uICp0Z2luc3RyKQoreworCUluc3RyU3RhcnROb2RlKCZ0Z2lu c3RyLT5pbnN0cik7Cit9CisKK3ZvaWQKK0luc3RyU3RvcFRyaWdnZXIoVHJpZ2dlckluc3RydW1l bnRhdGlvbiAqdGdpbnN0ciwgaW50IGZpcmluZ3MpCit7CisJSW5zdHJTdG9wTm9kZSgmdGdpbnN0 ci0+aW5zdHIsIDApOworCXRnaW5zdHItPmZpcmluZ3MgKz0gZmlyaW5nczsKK30KKwogLyogbm90 ZSBjdXJyZW50IHZhbHVlcyBkdXJpbmcgcGFyYWxsZWwgZXhlY3V0b3Igc3RhcnR1cCAqLwogdm9p ZAogSW5zdHJTdGFydFBhcmFsbGVsUXVlcnkodm9pZCkKZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRl L2V4ZWN1dG9yL2luc3RydW1lbnQuaCBiL3NyYy9pbmNsdWRlL2V4ZWN1dG9yL2luc3RydW1lbnQu aAppbmRleCA5NzU5ZjNlYTVkOC4uYTljMjIzMzIyN2YgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRl L2V4ZWN1dG9yL2luc3RydW1lbnQuaAorKysgYi9zcmMvaW5jbHVkZS9leGVjdXRvci9pbnN0cnVt ZW50LmgKQEAgLTEwMCw2ICsxMDAsMTMgQEAgdHlwZWRlZiBzdHJ1Y3QgV29ya2VySW5zdHJ1bWVu dGF0aW9uCiAJSW5zdHJ1bWVudGF0aW9uIGluc3RydW1lbnRbRkxFWElCTEVfQVJSQVlfTUVNQkVS XTsKIH0gV29ya2VySW5zdHJ1bWVudGF0aW9uOwogCit0eXBlZGVmIHN0cnVjdCBUcmlnZ2VySW5z dHJ1bWVudGF0aW9uCit7CisJSW5zdHJ1bWVudGF0aW9uIGluc3RyOworCWludAkJCWZpcmluZ3M7 CQkvKiBudW1iZXIgb2YgdGltZXMgdGhlIGluc3RydW1lbnRlZCB0cmlnZ2VyCisJCQkJCQkJCSAq IHdhcyBmaXJlZCAqLworfSBUcmlnZ2VySW5zdHJ1bWVudGF0aW9uOworCiBleHRlcm4gUEdETExJ TVBPUlQgQnVmZmVyVXNhZ2UgcGdCdWZmZXJVc2FnZTsKIGV4dGVybiBQR0RMTElNUE9SVCBXYWxV c2FnZSBwZ1dhbFVzYWdlOwogCkBAIC0xMTEsNiArMTE4LDExIEBAIGV4dGVybiB2b2lkIEluc3Ry U3RvcE5vZGUoSW5zdHJ1bWVudGF0aW9uICppbnN0ciwgZG91YmxlIG5UdXBsZXMpOwogZXh0ZXJu IHZvaWQgSW5zdHJVcGRhdGVUdXBsZUNvdW50KEluc3RydW1lbnRhdGlvbiAqaW5zdHIsIGRvdWJs ZSBuVHVwbGVzKTsKIGV4dGVybiB2b2lkIEluc3RyRW5kTG9vcChJbnN0cnVtZW50YXRpb24gKmlu c3RyKTsKIGV4dGVybiB2b2lkIEluc3RyQWdnTm9kZShJbnN0cnVtZW50YXRpb24gKmRzdCwgSW5z dHJ1bWVudGF0aW9uICphZGQpOworCitleHRlcm4gVHJpZ2dlckluc3RydW1lbnRhdGlvbiAqSW5z dHJBbGxvY1RyaWdnZXIoaW50IG4sIGludCBpbnN0cnVtZW50X29wdGlvbnMpOworZXh0ZXJuIHZv aWQgSW5zdHJTdGFydFRyaWdnZXIoVHJpZ2dlckluc3RydW1lbnRhdGlvbiAqdGdpbnN0cik7Citl eHRlcm4gdm9pZCBJbnN0clN0b3BUcmlnZ2VyKFRyaWdnZXJJbnN0cnVtZW50YXRpb24gKnRnaW5z dHIsIGludCBmaXJpbmdzKTsKKwogZXh0ZXJuIHZvaWQgSW5zdHJTdGFydFBhcmFsbGVsUXVlcnko dm9pZCk7CiBleHRlcm4gdm9pZCBJbnN0ckVuZFBhcmFsbGVsUXVlcnkoQnVmZmVyVXNhZ2UgKmJ1 ZnVzYWdlLCBXYWxVc2FnZSAqd2FsdXNhZ2UpOwogZXh0ZXJuIHZvaWQgSW5zdHJBY2N1bVBhcmFs bGVsUXVlcnkoQnVmZmVyVXNhZ2UgKmJ1ZnVzYWdlLCBXYWxVc2FnZSAqd2FsdXNhZ2UpOwpkaWZm IC0tZ2l0IGEvc3JjL2luY2x1ZGUvbm9kZXMvZXhlY25vZGVzLmggYi9zcmMvaW5jbHVkZS9ub2Rl cy9leGVjbm9kZXMuaAppbmRleCAwOTBjZmNjZjY1Zi4uOTA4ODk4YWE3YzkgMTAwNjQ0Ci0tLSBh L3NyYy9pbmNsdWRlL25vZGVzL2V4ZWNub2Rlcy5oCisrKyBiL3NyYy9pbmNsdWRlL25vZGVzL2V4 ZWNub2Rlcy5oCkBAIC02MCw2ICs2MCw3IEBAIHR5cGVkZWYgc3RydWN0IFNjYW5LZXlEYXRhIFNj YW5LZXlEYXRhOwogdHlwZWRlZiBzdHJ1Y3QgU25hcHNob3REYXRhICpTbmFwc2hvdDsKIHR5cGVk ZWYgc3RydWN0IFNvcnRTdXBwb3J0RGF0YSAqU29ydFN1cHBvcnQ7CiB0eXBlZGVmIHN0cnVjdCBU SURCaXRtYXAgVElEQml0bWFwOwordHlwZWRlZiBzdHJ1Y3QgVHJpZ2dlckluc3RydW1lbnRhdGlv biBUcmlnZ2VySW5zdHJ1bWVudGF0aW9uOwogdHlwZWRlZiBzdHJ1Y3QgVHVwbGVDb252ZXJzaW9u TWFwIFR1cGxlQ29udmVyc2lvbk1hcDsKIHR5cGVkZWYgc3RydWN0IFR1cGxlRGVzY0RhdGEgKlR1 cGxlRGVzYzsKIHR5cGVkZWYgc3RydWN0IFR1cGxlc29ydHN0YXRlIFR1cGxlc29ydHN0YXRlOwpA QCAtNTUyLDcgKzU1Myw3IEBAIHR5cGVkZWYgc3RydWN0IFJlc3VsdFJlbEluZm8KIAlFeHByU3Rh dGUgKipyaV9UcmlnV2hlbkV4cHJzOwogCiAJLyogb3B0aW9uYWwgcnVudGltZSBtZWFzdXJlbWVu dHMgZm9yIHRyaWdnZXJzICovCi0JSW5zdHJ1bWVudGF0aW9uICpyaV9UcmlnSW5zdHJ1bWVudDsK KwlUcmlnZ2VySW5zdHJ1bWVudGF0aW9uICpyaV9UcmlnSW5zdHJ1bWVudDsKIAogCS8qIE9uLWRl bWFuZCBjcmVhdGVkIHNsb3RzIGZvciB0cmlnZ2VycyAvIHJldHVybmluZyBwcm9jZXNzaW5nICov CiAJVHVwbGVUYWJsZVNsb3QgKnJpX1JldHVybmluZ1Nsb3Q7CS8qIGZvciB0cmlnZ2VyIG91dHB1 dCB0dXBsZXMgKi8KZGlmZiAtLWdpdCBhL3NyYy90b29scy9wZ2luZGVudC90eXBlZGVmcy5saXN0 IGIvc3JjL3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZzLmxpc3QKaW5kZXggYzcyZjZjNTk1NzMuLjdk ZGY5NzBmYjk3IDEwMDY0NAotLS0gYS9zcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdAor KysgYi9zcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdApAQCAtMzIxMyw2ICszMjEzLDcg QEAgVHJpZ2dlckRlc2MKIFRyaWdnZXJFdmVudAogVHJpZ2dlckZsYWdzCiBUcmlnZ2VySW5mbwor VHJpZ2dlckluc3RydW1lbnRhdGlvbgogVHJpZ2dlclRyYW5zaXRpb24KIFRydW5jYXRlU3RtdAog VHNtUm91dGluZQotLSAKMi40Ny4xCgo= --0000000000006d0cb0064eb5be7d Content-Type: application/octet-stream; name="v13-0004-instrumentation-Replace-direct-changes-of-pgBuff.patch" Content-Disposition: attachment; filename="v13-0004-instrumentation-Replace-direct-changes-of-pgBuff.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mnlqag633 RnJvbSA1ZmMyZDI1MTk2MzRiNmExMzY1OGYzZWM4MWMyMDUxOTBkZmNmZmYxIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBMdWthcyBGaXR0bCA8bHVrYXNAZml0dGwuY29tPgpEYXRlOiBU aHUsIDI2IE1hciAyMDI2IDIzOjMxOjA0IC0wNzAwClN1YmplY3Q6IFtQQVRDSCB2MTMgMDQvMTJd IGluc3RydW1lbnRhdGlvbjogUmVwbGFjZSBkaXJlY3QgY2hhbmdlcyBvZgogcGdCdWZmZXJVc2Fn ZS9wZ1dhbFVzYWdlIHdpdGggSU5TVFJfKiBtYWNyb3MKClRoaXMgZW5jYXBzdWxhdGVzIHRoZSBv d25lcnNoaXAgb2YgdGhlc2UgZ2xvYmFscyBiZXR0ZXIsIGFuZCB3aWxsIGFsbG93CmEgc3Vic2Vx dWVudCByZWZhY3RvcmluZy4KCkF1dGhvcjogTHVrYXMgRml0dGwgPGx1a2FzQGZpdHRsLmNvbT4K UmV2aWV3ZWQtYnk6IEFuZHJlcyBGcmV1bmQgPGFuZHJlc0BhbmFyYXplbC5kZT4KUmV2aWV3ZWQt Ynk6IFpzb2x0IFBhcnJhZ2kgPHpzb2x0LnBhcnJhZ2lAcGVyY29uYS5jb20+CkRpc2N1c3Npb246 IGh0dHBzOi8vd3d3LnBvc3RncmVzcWwub3JnL21lc3NhZ2UtaWQvZmxhdC9DQVA1M1BrelozVW90 blJycm5YV0F2JTNERjRhdlJxOU1ROHpVJTJCYnhvTjl0cG92RXU2ZkdRJTQwbWFpbC5nbWFpbC5j b20jZmM3MTQwZThhZjIxZTA3YTkwYTA5ZDdlNzZiMzAwYzQKLS0tCiBzcmMvYmFja2VuZC9hY2Nl c3MvdHJhbnNhbS94bG9nLmMgICAgICB8IDEwICsrKysrLS0tLS0KIHNyYy9iYWNrZW5kL3N0b3Jh Z2UvYnVmZmVyL2J1Zm1nci5jICAgIHwgMjAgKysrKysrKysrKy0tLS0tLS0tLS0KIHNyYy9iYWNr ZW5kL3N0b3JhZ2UvYnVmZmVyL2xvY2FsYnVmLmMgIHwgIDYgKysrLS0tCiBzcmMvYmFja2VuZC9z dG9yYWdlL2ZpbGUvYnVmZmlsZS5jICAgICB8ICA4ICsrKystLS0tCiBzcmMvYmFja2VuZC91dGls cy9hY3Rpdml0eS9wZ3N0YXRfaW8uYyB8ICA4ICsrKystLS0tCiBzcmMvaW5jbHVkZS9leGVjdXRv ci9pbnN0cnVtZW50LmggICAgICB8IDE5ICsrKysrKysrKysrKysrKysrKysKIDYgZmlsZXMgY2hh bmdlZCwgNDUgaW5zZXJ0aW9ucygrKSwgMjYgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvc3Jj L2JhY2tlbmQvYWNjZXNzL3RyYW5zYW0veGxvZy5jIGIvc3JjL2JhY2tlbmQvYWNjZXNzL3RyYW5z YW0veGxvZy5jCmluZGV4IDllODk5OWJiYjYxLi43MWM5YTI2NTY2MiAxMDA2NDQKLS0tIGEvc3Jj L2JhY2tlbmQvYWNjZXNzL3RyYW5zYW0veGxvZy5jCisrKyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy90 cmFuc2FtL3hsb2cuYwpAQCAtMTEwMywxMCArMTEwMywxMCBAQCBYTG9nSW5zZXJ0UmVjb3JkKFhM b2dSZWNEYXRhICpyZGF0YSwKIAkvKiBSZXBvcnQgV0FMIHRyYWZmaWMgdG8gdGhlIGluc3RydW1l bnRhdGlvbi4gKi8KIAlpZiAoaW5zZXJ0ZWQpCiAJewotCQlwZ1dhbFVzYWdlLndhbF9ieXRlcyAr PSByZWNoZHItPnhsX3RvdF9sZW47Ci0JCXBnV2FsVXNhZ2Uud2FsX3JlY29yZHMrKzsKLQkJcGdX YWxVc2FnZS53YWxfZnBpICs9IG51bV9mcGk7Ci0JCXBnV2FsVXNhZ2Uud2FsX2ZwaV9ieXRlcyAr PSBmcGlfYnl0ZXM7CisJCUlOU1RSX1dBTFVTQUdFX0FERCh3YWxfYnl0ZXMsIHJlY2hkci0+eGxf dG90X2xlbik7CisJCUlOU1RSX1dBTFVTQUdFX0lOQ1Iod2FsX3JlY29yZHMpOworCQlJTlNUUl9X QUxVU0FHRV9BREQod2FsX2ZwaSwgbnVtX2ZwaSk7CisJCUlOU1RSX1dBTFVTQUdFX0FERCh3YWxf ZnBpX2J5dGVzLCBmcGlfYnl0ZXMpOwogCiAJCS8qIFJlcXVpcmVkIGZvciB0aGUgZmx1c2ggb2Yg cGVuZGluZyBzdGF0cyBXQUwgZGF0YSAqLwogCQlwZ3N0YXRfcmVwb3J0X2ZpeGVkID0gdHJ1ZTsK QEAgLTIwODUsNyArMjA4NSw3IEBAIEFkdmFuY2VYTEluc2VydEJ1ZmZlcihYTG9nUmVjUHRyIHVw dG8sIFRpbWVMaW5lSUQgdGxpLCBib29sIG9wcG9ydHVuaXN0aWMpCiAJCQkJCVdyaXRlUnFzdC5G bHVzaCA9IEludmFsaWRYTG9nUmVjUHRyOwogCQkJCQlYTG9nV3JpdGUoV3JpdGVScXN0LCB0bGks IGZhbHNlKTsKIAkJCQkJTFdMb2NrUmVsZWFzZShXQUxXcml0ZUxvY2spOwotCQkJCQlwZ1dhbFVz YWdlLndhbF9idWZmZXJzX2Z1bGwrKzsKKwkJCQkJSU5TVFJfV0FMVVNBR0VfSU5DUih3YWxfYnVm ZmVyc19mdWxsKTsKIAkJCQkJVFJBQ0VfUE9TVEdSRVNRTF9XQUxfQlVGRkVSX1dSSVRFX0RJUlRZ X0RPTkUoKTsKIAogCQkJCQkvKgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvc3RvcmFnZS9idWZm ZXIvYnVmbWdyLmMgYi9zcmMvYmFja2VuZC9zdG9yYWdlL2J1ZmZlci9idWZtZ3IuYwppbmRleCAz Y2MwYjBiZGQ5Mi4uM2UxYzM5MTYwZGIgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3N0b3JhZ2Uv YnVmZmVyL2J1Zm1nci5jCisrKyBiL3NyYy9iYWNrZW5kL3N0b3JhZ2UvYnVmZmVyL2J1Zm1nci5j CkBAIC04NDAsNyArODQwLDcgQEAgUmVhZFJlY2VudEJ1ZmZlcihSZWxGaWxlTG9jYXRvciBybG9j YXRvciwgRm9ya051bWJlciBmb3JrTnVtLCBCbG9ja051bWJlciBibG9ja04KIAkJewogCQkJUGlu TG9jYWxCdWZmZXIoYnVmSGRyLCB0cnVlKTsKIAotCQkJcGdCdWZmZXJVc2FnZS5sb2NhbF9ibGtz X2hpdCsrOworCQkJSU5TVFJfQlVGVVNBR0VfSU5DUihsb2NhbF9ibGtzX2hpdCk7CiAKIAkJCXJl dHVybiB0cnVlOwogCQl9CkBAIC04NjEsNyArODYxLDcgQEAgUmVhZFJlY2VudEJ1ZmZlcihSZWxG aWxlTG9jYXRvciBybG9jYXRvciwgRm9ya051bWJlciBmb3JrTnVtLCBCbG9ja051bWJlciBibG9j a04KIAkJewogCQkJaWYgKEJ1ZmZlclRhZ3NFcXVhbCgmdGFnLCAmYnVmSGRyLT50YWcpKQogCQkJ ewotCQkJCXBnQnVmZmVyVXNhZ2Uuc2hhcmVkX2Jsa3NfaGl0Kys7CisJCQkJSU5TVFJfQlVGVVNB R0VfSU5DUihzaGFyZWRfYmxrc19oaXQpOwogCQkJCXJldHVybiB0cnVlOwogCQkJfQogCQkJVW5w aW5CdWZmZXIoYnVmSGRyKTsKQEAgLTE2ODQsOSArMTY4NCw5IEBAIFRyYWNrQnVmZmVySGl0KElP T2JqZWN0IGlvX29iamVjdCwgSU9Db250ZXh0IGlvX2NvbnRleHQsCiAJCQkJCQkJCQkgIHRydWUp OwogCiAJaWYgKHBlcnNpc3RlbmNlID09IFJFTFBFUlNJU1RFTkNFX1RFTVApCi0JCXBnQnVmZmVy VXNhZ2UubG9jYWxfYmxrc19oaXQgKz0gMTsKKwkJSU5TVFJfQlVGVVNBR0VfSU5DUihsb2NhbF9i bGtzX2hpdCk7CiAJZWxzZQotCQlwZ0J1ZmZlclVzYWdlLnNoYXJlZF9ibGtzX2hpdCArPSAxOwor CQlJTlNUUl9CVUZVU0FHRV9JTkNSKHNoYXJlZF9ibGtzX2hpdCk7CiAKIAlwZ3N0YXRfY291bnRf aW9fb3AoaW9fb2JqZWN0LCBpb19jb250ZXh0LCBJT09QX0hJVCwgMSwgMCk7CiAKQEAgLTIxNDgs OSArMjE0OCw5IEBAIEFzeW5jUmVhZEJ1ZmZlcnMoUmVhZEJ1ZmZlcnNPcGVyYXRpb24gKm9wZXJh dGlvbiwgaW50ICpuYmxvY2tzX3Byb2dyZXNzKQogCQkJCQkJCWlvX3N0YXJ0LCAxLCBpb19idWZm ZXJzX2xlbiAqIEJMQ0tTWik7CiAKIAlpZiAocGVyc2lzdGVuY2UgPT0gUkVMUEVSU0lTVEVOQ0Vf VEVNUCkKLQkJcGdCdWZmZXJVc2FnZS5sb2NhbF9ibGtzX3JlYWQgKz0gaW9fYnVmZmVyc19sZW47 CisJCUlOU1RSX0JVRlVTQUdFX0FERChsb2NhbF9ibGtzX3JlYWQsIGlvX2J1ZmZlcnNfbGVuKTsK IAllbHNlCi0JCXBnQnVmZmVyVXNhZ2Uuc2hhcmVkX2Jsa3NfcmVhZCArPSBpb19idWZmZXJzX2xl bjsKKwkJSU5TVFJfQlVGVVNBR0VfQUREKHNoYXJlZF9ibGtzX3JlYWQsIGlvX2J1ZmZlcnNfbGVu KTsKIAogCS8qCiAJICogVHJhY2sgdmFjdXVtIGNvc3Qgd2hlbiBpc3N1aW5nIElPLCBub3QgYWZ0 ZXIgd2FpdGluZyBmb3IgaXQuIE90aGVyd2lzZQpAQCAtMzA0Myw3ICszMDQzLDcgQEAgRXh0ZW5k QnVmZmVyZWRSZWxTaGFyZWQoQnVmZmVyTWFuYWdlclJlbGF0aW9uIGJtciwKIAkJVGVybWluYXRl QnVmZmVySU8oYnVmX2hkciwgZmFsc2UsIEJNX1ZBTElELCB0cnVlLCBmYWxzZSk7CiAJfQogCi0J cGdCdWZmZXJVc2FnZS5zaGFyZWRfYmxrc193cml0dGVuICs9IGV4dGVuZF9ieTsKKwlJTlNUUl9C VUZVU0FHRV9BREQoc2hhcmVkX2Jsa3Nfd3JpdHRlbiwgZXh0ZW5kX2J5KTsKIAogCSpleHRlbmRl ZF9ieSA9IGV4dGVuZF9ieTsKIApAQCAtMzE4OSw3ICszMTg5LDcgQEAgTWFya0J1ZmZlckRpcnR5 KEJ1ZmZlciBidWZmZXIpCiAJICovCiAJaWYgKCEob2xkX2J1Zl9zdGF0ZSAmIEJNX0RJUlRZKSkK IAl7Ci0JCXBnQnVmZmVyVXNhZ2Uuc2hhcmVkX2Jsa3NfZGlydGllZCsrOworCQlJTlNUUl9CVUZV U0FHRV9JTkNSKHNoYXJlZF9ibGtzX2RpcnRpZWQpOwogCQlpZiAoVmFjdXVtQ29zdEFjdGl2ZSkK IAkJCVZhY3V1bUNvc3RCYWxhbmNlICs9IFZhY3V1bUNvc3RQYWdlRGlydHk7CiAJfQpAQCAtNDYw MSw3ICs0NjAxLDcgQEAgRmx1c2hCdWZmZXIoQnVmZmVyRGVzYyAqYnVmLCBTTWdyUmVsYXRpb24g cmVsbiwgSU9PYmplY3QgaW9fb2JqZWN0LAogCXBnc3RhdF9jb3VudF9pb19vcF90aW1lKElPT0JK RUNUX1JFTEFUSU9OLCBpb19jb250ZXh0LAogCQkJCQkJCUlPT1BfV1JJVEUsIGlvX3N0YXJ0LCAx LCBCTENLU1opOwogCi0JcGdCdWZmZXJVc2FnZS5zaGFyZWRfYmxrc193cml0dGVuKys7CisJSU5T VFJfQlVGVVNBR0VfSU5DUihzaGFyZWRfYmxrc193cml0dGVuKTsKIAogCS8qCiAJICogTWFyayB0 aGUgYnVmZmVyIGFzIGNsZWFuIGFuZCBlbmQgdGhlIEJNX0lPX0lOX1BST0dSRVNTIHN0YXRlLgpA QCAtNTc5Niw3ICs1Nzk2LDcgQEAgTWFya1NoYXJlZEJ1ZmZlckRpcnR5SGludChCdWZmZXIgYnVm ZmVyLCBCdWZmZXJEZXNjICpidWZIZHIsIHVpbnQ2NCBsb2Nrc3RhdGUsCiAJCQlVbmxvY2tCdWZI ZHIoYnVmSGRyKTsKIAkJfQogCi0JCXBnQnVmZmVyVXNhZ2Uuc2hhcmVkX2Jsa3NfZGlydGllZCsr OworCQlJTlNUUl9CVUZVU0FHRV9JTkNSKHNoYXJlZF9ibGtzX2RpcnRpZWQpOwogCQlpZiAoVmFj dXVtQ29zdEFjdGl2ZSkKIAkJCVZhY3V1bUNvc3RCYWxhbmNlICs9IFZhY3V1bUNvc3RQYWdlRGly dHk7CiAJfQpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvc3RvcmFnZS9idWZmZXIvbG9jYWxidWYu YyBiL3NyYy9iYWNrZW5kL3N0b3JhZ2UvYnVmZmVyL2xvY2FsYnVmLmMKaW5kZXggMzk2ZGE4NGIy NWMuLjg1MWI5OTA1NmQ1IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9zdG9yYWdlL2J1ZmZlci9s b2NhbGJ1Zi5jCisrKyBiL3NyYy9iYWNrZW5kL3N0b3JhZ2UvYnVmZmVyL2xvY2FsYnVmLmMKQEAg LTIxOCw3ICsyMTgsNyBAQCBGbHVzaExvY2FsQnVmZmVyKEJ1ZmZlckRlc2MgKmJ1ZkhkciwgU01n clJlbGF0aW9uIHJlbG4pCiAJLyogTWFyayBub3QtZGlydHkgKi8KIAlUZXJtaW5hdGVMb2NhbEJ1 ZmZlcklPKGJ1ZkhkciwgdHJ1ZSwgMCwgZmFsc2UpOwogCi0JcGdCdWZmZXJVc2FnZS5sb2NhbF9i bGtzX3dyaXR0ZW4rKzsKKwlJTlNUUl9CVUZVU0FHRV9JTkNSKGxvY2FsX2Jsa3Nfd3JpdHRlbik7 CiB9CiAKIHN0YXRpYyBCdWZmZXIKQEAgLTQ3OSw3ICs0NzksNyBAQCBFeHRlbmRCdWZmZXJlZFJl bExvY2FsKEJ1ZmZlck1hbmFnZXJSZWxhdGlvbiBibXIsCiAKIAkqZXh0ZW5kZWRfYnkgPSBleHRl bmRfYnk7CiAKLQlwZ0J1ZmZlclVzYWdlLmxvY2FsX2Jsa3Nfd3JpdHRlbiArPSBleHRlbmRfYnk7 CisJSU5TVFJfQlVGVVNBR0VfQUREKGxvY2FsX2Jsa3Nfd3JpdHRlbiwgZXh0ZW5kX2J5KTsKIAog CXJldHVybiBmaXJzdF9ibG9jazsKIH0KQEAgLTUxMCw3ICs1MTAsNyBAQCBNYXJrTG9jYWxCdWZm ZXJEaXJ0eShCdWZmZXIgYnVmZmVyKQogCWJ1Zl9zdGF0ZSA9IHBnX2F0b21pY19yZWFkX3U2NCgm YnVmSGRyLT5zdGF0ZSk7CiAKIAlpZiAoIShidWZfc3RhdGUgJiBCTV9ESVJUWSkpCi0JCXBnQnVm ZmVyVXNhZ2UubG9jYWxfYmxrc19kaXJ0aWVkKys7CisJCUlOU1RSX0JVRlVTQUdFX0lOQ1IobG9j YWxfYmxrc19kaXJ0aWVkKTsKIAogCWJ1Zl9zdGF0ZSB8PSBCTV9ESVJUWTsKIApkaWZmIC0tZ2l0 IGEvc3JjL2JhY2tlbmQvc3RvcmFnZS9maWxlL2J1ZmZpbGUuYyBiL3NyYy9iYWNrZW5kL3N0b3Jh Z2UvZmlsZS9idWZmaWxlLmMKaW5kZXggYzRhZmU0ZDM2OGEuLjhiNTAxZGZjYWRkIDEwMDY0NAot LS0gYS9zcmMvYmFja2VuZC9zdG9yYWdlL2ZpbGUvYnVmZmlsZS5jCisrKyBiL3NyYy9iYWNrZW5k L3N0b3JhZ2UvZmlsZS9idWZmaWxlLmMKQEAgLTQ3NSwxMyArNDc1LDEzIEBAIEJ1ZkZpbGVMb2Fk QnVmZmVyKEJ1ZkZpbGUgKmZpbGUpCiAJaWYgKHRyYWNrX2lvX3RpbWluZykKIAl7CiAJCUlOU1RS X1RJTUVfU0VUX0NVUlJFTlQoaW9fdGltZSk7Ci0JCUlOU1RSX1RJTUVfQUNDVU1fRElGRihwZ0J1 ZmZlclVzYWdlLnRlbXBfYmxrX3JlYWRfdGltZSwgaW9fdGltZSwgaW9fc3RhcnQpOworCQlJTlNU Ul9CVUZVU0FHRV9USU1FX0FDQ1VNX0RJRkYodGVtcF9ibGtfcmVhZF90aW1lLCBpb190aW1lLCBp b19zdGFydCk7CiAJfQogCiAJLyogd2UgY2hvb3NlIG5vdCB0byBhZHZhbmNlIGN1ck9mZnNldCBo ZXJlICovCiAKIAlpZiAoZmlsZS0+bmJ5dGVzID4gMCkKLQkJcGdCdWZmZXJVc2FnZS50ZW1wX2Js a3NfcmVhZCsrOworCQlJTlNUUl9CVUZVU0FHRV9JTkNSKHRlbXBfYmxrc19yZWFkKTsKIH0KIAog LyoKQEAgLTU0OSwxMyArNTQ5LDEzIEBAIEJ1ZkZpbGVEdW1wQnVmZmVyKEJ1ZkZpbGUgKmZpbGUp CiAJCWlmICh0cmFja19pb190aW1pbmcpCiAJCXsKIAkJCUlOU1RSX1RJTUVfU0VUX0NVUlJFTlQo aW9fdGltZSk7Ci0JCQlJTlNUUl9USU1FX0FDQ1VNX0RJRkYocGdCdWZmZXJVc2FnZS50ZW1wX2Js a193cml0ZV90aW1lLCBpb190aW1lLCBpb19zdGFydCk7CisJCQlJTlNUUl9CVUZVU0FHRV9USU1F X0FDQ1VNX0RJRkYodGVtcF9ibGtfd3JpdGVfdGltZSwgaW9fdGltZSwgaW9fc3RhcnQpOwogCQl9 CiAKIAkJZmlsZS0+Y3VyT2Zmc2V0ICs9IGJ5dGVzdG93cml0ZTsKIAkJd3BvcyArPSBieXRlc3Rv d3JpdGU7CiAKLQkJcGdCdWZmZXJVc2FnZS50ZW1wX2Jsa3Nfd3JpdHRlbisrOworCQlJTlNUUl9C VUZVU0FHRV9JTkNSKHRlbXBfYmxrc193cml0dGVuKTsKIAl9CiAJZmlsZS0+ZGlydHkgPSBmYWxz ZTsKIApkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvdXRpbHMvYWN0aXZpdHkvcGdzdGF0X2lvLmMg Yi9zcmMvYmFja2VuZC91dGlscy9hY3Rpdml0eS9wZ3N0YXRfaW8uYwppbmRleCAyYmUyNmU5MjI4 My4uZTM4MjlkN2ZlN2MgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3V0aWxzL2FjdGl2aXR5L3Bn c3RhdF9pby5jCisrKyBiL3NyYy9iYWNrZW5kL3V0aWxzL2FjdGl2aXR5L3Bnc3RhdF9pby5jCkBA IC0xMzUsMTcgKzEzNSwxNyBAQCBwZ3N0YXRfY291bnRfaW9fb3BfdGltZShJT09iamVjdCBpb19v YmplY3QsIElPQ29udGV4dCBpb19jb250ZXh0LCBJT09wIGlvX29wLAogCQkJewogCQkJCXBnc3Rh dF9jb3VudF9idWZmZXJfd3JpdGVfdGltZShJTlNUUl9USU1FX0dFVF9NSUNST1NFQyhpb190aW1l KSk7CiAJCQkJaWYgKGlvX29iamVjdCA9PSBJT09CSkVDVF9SRUxBVElPTikKLQkJCQkJSU5TVFJf VElNRV9BREQocGdCdWZmZXJVc2FnZS5zaGFyZWRfYmxrX3dyaXRlX3RpbWUsIGlvX3RpbWUpOwor CQkJCQlJTlNUUl9CVUZVU0FHRV9USU1FX0FERChzaGFyZWRfYmxrX3dyaXRlX3RpbWUsIGlvX3Rp bWUpOwogCQkJCWVsc2UgaWYgKGlvX29iamVjdCA9PSBJT09CSkVDVF9URU1QX1JFTEFUSU9OKQot CQkJCQlJTlNUUl9USU1FX0FERChwZ0J1ZmZlclVzYWdlLmxvY2FsX2Jsa193cml0ZV90aW1lLCBp b190aW1lKTsKKwkJCQkJSU5TVFJfQlVGVVNBR0VfVElNRV9BREQobG9jYWxfYmxrX3dyaXRlX3Rp bWUsIGlvX3RpbWUpOwogCQkJfQogCQkJZWxzZSBpZiAoaW9fb3AgPT0gSU9PUF9SRUFEKQogCQkJ ewogCQkJCXBnc3RhdF9jb3VudF9idWZmZXJfcmVhZF90aW1lKElOU1RSX1RJTUVfR0VUX01JQ1JP U0VDKGlvX3RpbWUpKTsKIAkJCQlpZiAoaW9fb2JqZWN0ID09IElPT0JKRUNUX1JFTEFUSU9OKQot CQkJCQlJTlNUUl9USU1FX0FERChwZ0J1ZmZlclVzYWdlLnNoYXJlZF9ibGtfcmVhZF90aW1lLCBp b190aW1lKTsKKwkJCQkJSU5TVFJfQlVGVVNBR0VfVElNRV9BREQoc2hhcmVkX2Jsa19yZWFkX3Rp bWUsIGlvX3RpbWUpOwogCQkJCWVsc2UgaWYgKGlvX29iamVjdCA9PSBJT09CSkVDVF9URU1QX1JF TEFUSU9OKQotCQkJCQlJTlNUUl9USU1FX0FERChwZ0J1ZmZlclVzYWdlLmxvY2FsX2Jsa19yZWFk X3RpbWUsIGlvX3RpbWUpOworCQkJCQlJTlNUUl9CVUZVU0FHRV9USU1FX0FERChsb2NhbF9ibGtf cmVhZF90aW1lLCBpb190aW1lKTsKIAkJCX0KIAkJfQogCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVk ZS9leGVjdXRvci9pbnN0cnVtZW50LmggYi9zcmMvaW5jbHVkZS9leGVjdXRvci9pbnN0cnVtZW50 LmgKaW5kZXggYjExZDY0NjMzYjUuLmQ0NzY5ZjNkYTdiIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVk ZS9leGVjdXRvci9pbnN0cnVtZW50LmgKKysrIGIvc3JjL2luY2x1ZGUvZXhlY3V0b3IvaW5zdHJ1 bWVudC5oCkBAIC0xNTMsNCArMTUzLDIzIEBAIGV4dGVybiB2b2lkIEJ1ZmZlclVzYWdlQWNjdW1E aWZmKEJ1ZmZlclVzYWdlICpkc3QsCiBleHRlcm4gdm9pZCBXYWxVc2FnZUFjY3VtRGlmZihXYWxV c2FnZSAqZHN0LCBjb25zdCBXYWxVc2FnZSAqYWRkLAogCQkJCQkJCSAgY29uc3QgV2FsVXNhZ2Ug KnN1Yik7CiAKKyNkZWZpbmUgSU5TVFJfQlVGVVNBR0VfSU5DUihmbGQpIGRvIHsgXAorCQlwZ0J1 ZmZlclVzYWdlLmZsZCsrOyBcCisJfSB3aGlsZSgwKQorI2RlZmluZSBJTlNUUl9CVUZVU0FHRV9B REQoZmxkLHZhbCkgZG8geyBcCisJCXBnQnVmZmVyVXNhZ2UuZmxkICs9ICh2YWwpOyBcCisJfSB3 aGlsZSgwKQorI2RlZmluZSBJTlNUUl9CVUZVU0FHRV9USU1FX0FERChmbGQsdmFsKSBkbyB7IFwK KwlJTlNUUl9USU1FX0FERChwZ0J1ZmZlclVzYWdlLmZsZCwgdmFsKTsgXAorCX0gd2hpbGUgKDAp CisjZGVmaW5lIElOU1RSX0JVRlVTQUdFX1RJTUVfQUNDVU1fRElGRihmbGQsZW5kdmFsLHN0YXJ0 dmFsKSBkbyB7IFwKKwlJTlNUUl9USU1FX0FDQ1VNX0RJRkYocGdCdWZmZXJVc2FnZS5mbGQsIGVu ZHZhbCwgc3RhcnR2YWwpOyBcCisJfSB3aGlsZSAoMCkKKyNkZWZpbmUgSU5TVFJfV0FMVVNBR0Vf SU5DUihmbGQpIGRvIHsgXAorCQlwZ1dhbFVzYWdlLmZsZCsrOyBcCisJfSB3aGlsZSgwKQorI2Rl ZmluZSBJTlNUUl9XQUxVU0FHRV9BREQoZmxkLHZhbCkgZG8geyBcCisJCXBnV2FsVXNhZ2UuZmxk ICs9ICh2YWwpOyBcCisJfSB3aGlsZSgwKQorCiAjZW5kaWYJCQkJCQkJLyogSU5TVFJVTUVOVF9I ICovCi0tIAoyLjQ3LjEKCg== --0000000000006d0cb0064eb5be7d Content-Type: application/octet-stream; name="v13-0007-instrumentation-Add-additional-regression-tests-.patch" Content-Disposition: attachment; filename="v13-0007-instrumentation-Add-additional-regression-tests-.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mnlqag6z6 RnJvbSA3M2QzZDQzZmUzMDU4NzFmNjIzMzIwOThlNDE0ZjlkYjg0ZmMxMzNjIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBMdWthcyBGaXR0bCA8bHVrYXNAZml0dGwuY29tPgpEYXRlOiBT dW4sIDUgQXByIDIwMjYgMDM6NDg6MzIgLTA3MDAKU3ViamVjdDogW1BBVENIIHYxMyAwNy8xMl0g aW5zdHJ1bWVudGF0aW9uOiBBZGQgYWRkaXRpb25hbCByZWdyZXNzaW9uIHRlc3RzCiBjb3Zlcmlu ZyBidWZmZXIgdXNhZ2UKClRoaXMgYWRkcyByZWdyZXNzaW9uIHRlc3RzIHRoYXQgY292ZXIgc29t ZSBvZiB0aGUgZXhwZWN0ZWQgYmVoYXZpb3VyCmFyb3VuZCB0aGUgYnVmZmVyIHN0YXRpc3RpY3Mg cmVwb3J0ZWQgaW4gRVhQTEFJTiBBTkFMWVpFLCBzcGVjaWZpY2FsbHkKaG93IHRoZXkgYmVoYXZl IGluIHBhcmFsbGVsIHF1ZXJ5LCBuZXN0ZWQgZnVuY3Rpb24gY2FsbHMgYW5kIGFib3J0CnNpdHVh dGlvbnMuCgpUZXN0aW5nIHRoaXMgaXMgY2hhbGxlbmdpbmcgYmVjYXVzZSB0aGVyZSBjYW4gYmUg ZGlmZmVyZW50IHNvdXJjZXMgb2YKYnVmZmVyIGFjdGl2aXR5LCBzbyB3ZSByZWx5IG9uIHRlbXBv cmFyeSB0YWJsZXMgd2hlcmUgd2UgY2FuIHRvIHByb3ZlCnRoYXQgYWN0aXZpdHkgd2FzIGNhcHR1 cmVkIGFuZCBub3QgbG9zdC4gVGhpcyBzdXBwb3J0cyBhIGZ1dHVyZSBjb21taXQKdGhhdCB3aWxs IHJld29yayBzb21lIG9mIHRoZSBpbnN0cnVtZW50YXRpb24gbG9naWMgdGhhdCBjb3VsZCBjYXVz ZQphcmVhcyBjb3ZlcmVkIGJ5IHRoZXNlIHRlc3RzIHRvIGZhaWwuCgpBdXRob3I6IEx1a2FzIEZp dHRsIDxsdWthc0BmaXR0bC5jb20+ClJldmlld2VkLWJ5OgpEaXNjdXNzaW9uOgotLS0KIC4uLi9w Z19zdGF0X3N0YXRlbWVudHMvZXhwZWN0ZWQvdXRpbGl0eS5vdXQgICB8ICA3MCArKysrKysKIGNv bnRyaWIvcGdfc3RhdF9zdGF0ZW1lbnRzL2V4cGVjdGVkL3dhbC5vdXQgICB8ICA0OCArKysrCiBj b250cmliL3BnX3N0YXRfc3RhdGVtZW50cy9zcWwvdXRpbGl0eS5zcWwgICAgfCAgNTYgKysrKysK IGNvbnRyaWIvcGdfc3RhdF9zdGF0ZW1lbnRzL3NxbC93YWwuc3FsICAgICAgICB8ICAzMyArKysK IHNyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQvZXhwbGFpbi5vdXQgICAgICAgICB8IDIyOCArKysr KysrKysrKysrKysrKysKIHNyYy90ZXN0L3JlZ3Jlc3Mvc3FsL2V4cGxhaW4uc3FsICAgICAgICAg ICAgICB8IDIyNiArKysrKysrKysrKysrKysrKwogNiBmaWxlcyBjaGFuZ2VkLCA2NjEgaW5zZXJ0 aW9ucygrKQoKZGlmZiAtLWdpdCBhL2NvbnRyaWIvcGdfc3RhdF9zdGF0ZW1lbnRzL2V4cGVjdGVk L3V0aWxpdHkub3V0IGIvY29udHJpYi9wZ19zdGF0X3N0YXRlbWVudHMvZXhwZWN0ZWQvdXRpbGl0 eS5vdXQKaW5kZXggZTRkNjU2NGVhNWIuLmNiYTQ4N2Y2YmU1IDEwMDY0NAotLS0gYS9jb250cmli L3BnX3N0YXRfc3RhdGVtZW50cy9leHBlY3RlZC91dGlsaXR5Lm91dAorKysgYi9jb250cmliL3Bn X3N0YXRfc3RhdGVtZW50cy9leHBlY3RlZC91dGlsaXR5Lm91dApAQCAtMjg5LDYgKzI4OSw3NiBA QCBTRUxFQ1QgY2FsbHMsIHJvd3MsIHF1ZXJ5IEZST00gcGdfc3RhdF9zdGF0ZW1lbnRzIE9SREVS IEJZIHF1ZXJ5IENPTExBVEUgIkMiOwogICAgICAxIHwgICAgMSB8IFNFTEVDVCBwZ19zdGF0X3N0 YXRlbWVudHNfcmVzZXQoKSBJUyBOT1QgTlVMTCBBUyB0CiAoMyByb3dzKQogCistLSBCdWZmZXIg c3RhdHMgc2hvdWxkIGZsb3cgdGhyb3VnaCBFWFBMQUlOIEFOQUxZWkUKK0NSRUFURSBURU1QIFRB QkxFIGZsb3dfdGhyb3VnaF90ZXN0IChhIGludCwgYiBjaGFyKDIwMCkpOworSU5TRVJUIElOVE8g Zmxvd190aHJvdWdoX3Rlc3QgU0VMRUNUIGksIHJlcGVhdCgneCcsIDIwMCkgRlJPTSBnZW5lcmF0 ZV9zZXJpZXMoMSwgNTAwMCkgQVMgaTsKK0NSRUFURSBGVU5DVElPTiBydW5fZXhwbGFpbl9idWZm ZXJzX3Rlc3QoKSBSRVRVUk5TIHZvaWQgQVMgJCQKK0RFQ0xBUkUKK0JFR0lOCisgICAgRVhFQ1VU RSAnRVhQTEFJTiAoQU5BTFlaRSwgQlVGRkVSUykgU0VMRUNUICogRlJPTSBmbG93X3Rocm91Z2hf dGVzdCc7CitFTkQ7CiskJCBMQU5HVUFHRSBwbHBnc3FsOworU0VMRUNUIHBnX3N0YXRfc3RhdGVt ZW50c19yZXNldCgpIElTIE5PVCBOVUxMIEFTIHQ7CisgdCAKKy0tLQorIHQKKygxIHJvdykKKwor U0VMRUNUIHJ1bl9leHBsYWluX2J1ZmZlcnNfdGVzdCgpOworIHJ1bl9leHBsYWluX2J1ZmZlcnNf dGVzdCAKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgCisoMSByb3cpCisKKy0tIEVYUExB SU4gZW50cmllcyBzaG91bGQgaGF2ZSBub24temVybyBidWZmZXIgc3RhdHMKK1NFTEVDVCBxdWVy eSwgbG9jYWxfYmxrc19oaXQgKyBsb2NhbF9ibGtzX3JlYWQgPiAwIGFzIGhhc19idWZmZXJfc3Rh dHMKK0ZST00gcGdfc3RhdF9zdGF0ZW1lbnRzCitXSEVSRSBxdWVyeSBMSUtFICdTRUxFQ1QgcnVu X2V4cGxhaW5fYnVmZmVyc190ZXN0JScKK09SREVSIEJZIHF1ZXJ5IENPTExBVEUgIkMiOworICAg ICAgICAgICAgICAgcXVlcnkgICAgICAgICAgICAgICB8IGhhc19idWZmZXJfc3RhdHMgCistLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0tLS0KKyBTRUxF Q1QgcnVuX2V4cGxhaW5fYnVmZmVyc190ZXN0KCkgfCB0CisoMSByb3cpCisKK0RST1AgRlVOQ1RJ T04gcnVuX2V4cGxhaW5fYnVmZmVyc190ZXN0OworRFJPUCBUQUJMRSBmbG93X3Rocm91Z2hfdGVz dDsKKy0tIFZhbGlkYXRlIGJ1ZmZlci9XQUwgY291bnRpbmcgZHVyaW5nIGFib3J0CitTRVQgcGdf c3RhdF9zdGF0ZW1lbnRzLnRyYWNrID0gJ2FsbCc7CitDUkVBVEUgVEVNUCBUQUJMRSBwZ3NzX2Nh bGxfdGFiIChhIGludCwgYiBjaGFyKDIwKSk7CitDUkVBVEUgVEVNUCBUQUJMRSBwZ3NzX2NhbGxf dGFiMiAoYSBpbnQsIGIgY2hhcigyMCkpOworSU5TRVJUIElOVE8gcGdzc19jYWxsX3RhYiBWQUxV RVMgKDAsICd6enonKTsKK0NSRUFURSBQUk9DRURVUkUgcGdzc19jYWxsX3JvbGxiYWNrX3Byb2Mo KSBBUyAkJAorREVDTEFSRQorICAgIHYgaW50OworQkVHSU4KKyAgICBFWFBMQUlOIEFOQUxZWkUg V0lUSCBpbnMgQVMgKElOU0VSVCBJTlRPIHBnc3NfY2FsbF90YWIyIFNFTEVDVCAqIEZST00gcGdz c19jYWxsX3RhYiBSRVRVUk5JTkcgYSkKKyAgICBTRUxFQ1QgYSAvIDAgSU5UTyB2IEZST00gaW5z OworRVhDRVBUSU9OIFdIRU4gZGl2aXNpb25fYnlfemVybyBUSEVOCitFTkQ7CiskJCBMQU5HVUFH RSBwbHBnc3FsOworU0VMRUNUIHBnX3N0YXRfc3RhdGVtZW50c19yZXNldCgpIElTIE5PVCBOVUxM IEFTIHQ7CisgdCAKKy0tLQorIHQKKygxIHJvdykKKworQ0FMTCBwZ3NzX2NhbGxfcm9sbGJhY2tf cHJvYygpOworU0VMRUNUIHF1ZXJ5LCBjYWxscywKK2xvY2FsX2Jsa3NfaGl0ICsgbG9jYWxfYmxr c19yZWFkID4gMCBhcyBsb2NhbF9oaXRyZWFkLAord2FsX2J5dGVzID4gMCBhcyB3YWxfYnl0ZXNf Z2VuZXJhdGVkLAord2FsX3JlY29yZHMgPiAwIGFzIHdhbF9yZWNvcmRzX2dlbmVyYXRlZAorRlJP TSBwZ19zdGF0X3N0YXRlbWVudHMKK1dIRVJFIHF1ZXJ5IExJS0UgJyVwZ3NzX2NhbGxfcm9sbGJh Y2tfcHJvYyUnCitPUkRFUiBCWSBxdWVyeSBDT0xMQVRFICJDIjsKKyAgICAgICAgICAgICBxdWVy eSAgICAgICAgICAgICAgfCBjYWxscyB8IGxvY2FsX2hpdHJlYWQgfCB3YWxfYnl0ZXNfZ2VuZXJh dGVkIHwgd2FsX3JlY29yZHNfZ2VuZXJhdGVkIAorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0rLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tLS0tKy0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tCisgQ0FMTCBwZ3NzX2NhbGxfcm9sbGJhY2tfcHJvYygpIHwgICAg IDEgfCB0ICAgICAgICAgICAgIHwgdCAgICAgICAgICAgICAgICAgICB8IHQKKygxIHJvdykKKwor RFJPUCBUQUJMRSBwZ3NzX2NhbGxfdGFiMjsKK0RST1AgVEFCTEUgcGdzc19jYWxsX3RhYjsKK0RS T1AgUFJPQ0VEVVJFIHBnc3NfY2FsbF9yb2xsYmFja19wcm9jOworU0VUIHBnX3N0YXRfc3RhdGVt ZW50cy50cmFjayA9ICd0b3AnOwogLS0gQ0FMTAogQ1JFQVRFIE9SIFJFUExBQ0UgUFJPQ0VEVVJF IHN1bV9vbmUoaSBpbnQpIEFTICQkCiBERUNMQVJFCmRpZmYgLS1naXQgYS9jb250cmliL3BnX3N0 YXRfc3RhdGVtZW50cy9leHBlY3RlZC93YWwub3V0IGIvY29udHJpYi9wZ19zdGF0X3N0YXRlbWVu dHMvZXhwZWN0ZWQvd2FsLm91dAppbmRleCA5NzdlMzgyZDg0OC4uNjExMjEzZGFlZjYgMTAwNjQ0 Ci0tLSBhL2NvbnRyaWIvcGdfc3RhdF9zdGF0ZW1lbnRzL2V4cGVjdGVkL3dhbC5vdXQKKysrIGIv Y29udHJpYi9wZ19zdGF0X3N0YXRlbWVudHMvZXhwZWN0ZWQvd2FsLm91dApAQCAtMjgsMyArMjgs NTEgQEAgU0VMRUNUIHBnX3N0YXRfc3RhdGVtZW50c19yZXNldCgpIElTIE5PVCBOVUxMIEFTIHQ7 CiAgdAogKDEgcm93KQogCistLQorLS0gVmFsaWRhdGUgYnVmZmVyL1dBTCBjb3VudGluZyB3aXRo IGNhdWdodCBleGNlcHRpb24gaW4gUEwvcGdTUUwKKy0tCitDUkVBVEUgVEVNUCBUQUJMRSBwZ3Nz X2Vycm9yX3RhYiAoYSBpbnQsIGIgY2hhcigyMCkpOworSU5TRVJUIElOVE8gcGdzc19lcnJvcl90 YWIgVkFMVUVTICgwLCAnenp6Jyk7CitDUkVBVEUgRlVOQ1RJT04gcGdzc19lcnJvcl9mdW5jKCkg UkVUVVJOUyB2b2lkIEFTICQkCitERUNMQVJFCisgICAgdiBpbnQ7CitCRUdJTgorICAgIFdJVEgg aW5zIEFTIChJTlNFUlQgSU5UTyBwZ3NzX2Vycm9yX3RhYiBWQUxVRVMgKDEsICdhYWEnKSBSRVRV Uk5JTkcgYSkKKyAgICBTRUxFQ1QgYSAvIDAgSU5UTyB2IEZST00gaW5zOworRVhDRVBUSU9OIFdI RU4gZGl2aXNpb25fYnlfemVybyBUSEVOCisgICAgTlVMTDsKK0VORDsKKyQkIExBTkdVQUdFIHBs cGdzcWw7CitTRUxFQ1QgcGdfc3RhdF9zdGF0ZW1lbnRzX3Jlc2V0KCkgSVMgTk9UIE5VTEwgQVMg dDsKKyB0IAorLS0tCisgdAorKDEgcm93KQorCitTRUxFQ1QgcGdzc19lcnJvcl9mdW5jKCk7Cisg cGdzc19lcnJvcl9mdW5jIAorLS0tLS0tLS0tLS0tLS0tLS0KKyAKKygxIHJvdykKKworLS0gQnVm ZmVyL1dBTCB1c2FnZSBmcm9tIHRoZSB3Q1RFIElOU0VSVCBzaG91bGQgc3Vydml2ZSB0aGUgZXhj ZXB0aW9uCitTRUxFQ1QgcXVlcnksIGNhbGxzLAorbG9jYWxfYmxrc19oaXQgKyBsb2NhbF9ibGtz X3JlYWQgPiAwIGFzIGxvY2FsX2hpdHJlYWQsCit3YWxfYnl0ZXMgPiAwIGFzIHdhbF9ieXRlc19n ZW5lcmF0ZWQsCit3YWxfcmVjb3JkcyA+IDAgYXMgd2FsX3JlY29yZHNfZ2VuZXJhdGVkCitGUk9N IHBnX3N0YXRfc3RhdGVtZW50cworV0hFUkUgcXVlcnkgTElLRSAnJXBnc3NfZXJyb3JfZnVuYyUn CitPUkRFUiBCWSBxdWVyeSBDT0xMQVRFICJDIjsKKyAgICAgICAgICBxdWVyeSAgICAgICAgICAg fCBjYWxscyB8IGxvY2FsX2hpdHJlYWQgfCB3YWxfYnl0ZXNfZ2VuZXJhdGVkIHwgd2FsX3JlY29y ZHNfZ2VuZXJhdGVkIAorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rLS0tLS0tLSstLS0tLS0t LS0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tLS0tKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisg U0VMRUNUIHBnc3NfZXJyb3JfZnVuYygpIHwgICAgIDEgfCB0ICAgICAgICAgICAgIHwgdCAgICAg ICAgICAgICAgICAgICB8IHQKKygxIHJvdykKKworRFJPUCBUQUJMRSBwZ3NzX2Vycm9yX3RhYjsK K0RST1AgRlVOQ1RJT04gcGdzc19lcnJvcl9mdW5jOworU0VMRUNUIHBnX3N0YXRfc3RhdGVtZW50 c19yZXNldCgpIElTIE5PVCBOVUxMIEFTIHQ7CisgdCAKKy0tLQorIHQKKygxIHJvdykKKwpkaWZm IC0tZ2l0IGEvY29udHJpYi9wZ19zdGF0X3N0YXRlbWVudHMvc3FsL3V0aWxpdHkuc3FsIGIvY29u dHJpYi9wZ19zdGF0X3N0YXRlbWVudHMvc3FsL3V0aWxpdHkuc3FsCmluZGV4IGRkOTcyMDNjMjEw Li43NTQwZTQ5YzczYyAxMDA2NDQKLS0tIGEvY29udHJpYi9wZ19zdGF0X3N0YXRlbWVudHMvc3Fs L3V0aWxpdHkuc3FsCisrKyBiL2NvbnRyaWIvcGdfc3RhdF9zdGF0ZW1lbnRzL3NxbC91dGlsaXR5 LnNxbApAQCAtMTUyLDYgKzE1Miw2MiBAQCBFWFBMQUlOIChjb3N0cyBvZmYpIFNFTEVDVCBhIEZS T00gZ2VuZXJhdGVfc2VyaWVzKDEsMTApIEFTIHRhYihhKSBXSEVSRSBhID0gNzsKIAogU0VMRUNU IGNhbGxzLCByb3dzLCBxdWVyeSBGUk9NIHBnX3N0YXRfc3RhdGVtZW50cyBPUkRFUiBCWSBxdWVy eSBDT0xMQVRFICJDIjsKIAorLS0gQnVmZmVyIHN0YXRzIHNob3VsZCBmbG93IHRocm91Z2ggRVhQ TEFJTiBBTkFMWVpFCitDUkVBVEUgVEVNUCBUQUJMRSBmbG93X3Rocm91Z2hfdGVzdCAoYSBpbnQs IGIgY2hhcigyMDApKTsKK0lOU0VSVCBJTlRPIGZsb3dfdGhyb3VnaF90ZXN0IFNFTEVDVCBpLCBy ZXBlYXQoJ3gnLCAyMDApIEZST00gZ2VuZXJhdGVfc2VyaWVzKDEsIDUwMDApIEFTIGk7CisKK0NS RUFURSBGVU5DVElPTiBydW5fZXhwbGFpbl9idWZmZXJzX3Rlc3QoKSBSRVRVUk5TIHZvaWQgQVMg JCQKK0RFQ0xBUkUKK0JFR0lOCisgICAgRVhFQ1VURSAnRVhQTEFJTiAoQU5BTFlaRSwgQlVGRkVS UykgU0VMRUNUICogRlJPTSBmbG93X3Rocm91Z2hfdGVzdCc7CitFTkQ7CiskJCBMQU5HVUFHRSBw bHBnc3FsOworCitTRUxFQ1QgcGdfc3RhdF9zdGF0ZW1lbnRzX3Jlc2V0KCkgSVMgTk9UIE5VTEwg QVMgdDsKKworU0VMRUNUIHJ1bl9leHBsYWluX2J1ZmZlcnNfdGVzdCgpOworCistLSBFWFBMQUlO IGVudHJpZXMgc2hvdWxkIGhhdmUgbm9uLXplcm8gYnVmZmVyIHN0YXRzCitTRUxFQ1QgcXVlcnks IGxvY2FsX2Jsa3NfaGl0ICsgbG9jYWxfYmxrc19yZWFkID4gMCBhcyBoYXNfYnVmZmVyX3N0YXRz CitGUk9NIHBnX3N0YXRfc3RhdGVtZW50cworV0hFUkUgcXVlcnkgTElLRSAnU0VMRUNUIHJ1bl9l eHBsYWluX2J1ZmZlcnNfdGVzdCUnCitPUkRFUiBCWSBxdWVyeSBDT0xMQVRFICJDIjsKKworRFJP UCBGVU5DVElPTiBydW5fZXhwbGFpbl9idWZmZXJzX3Rlc3Q7CitEUk9QIFRBQkxFIGZsb3dfdGhy b3VnaF90ZXN0OworCistLSBWYWxpZGF0ZSBidWZmZXIvV0FMIGNvdW50aW5nIGR1cmluZyBhYm9y dAorU0VUIHBnX3N0YXRfc3RhdGVtZW50cy50cmFjayA9ICdhbGwnOworQ1JFQVRFIFRFTVAgVEFC TEUgcGdzc19jYWxsX3RhYiAoYSBpbnQsIGIgY2hhcigyMCkpOworQ1JFQVRFIFRFTVAgVEFCTEUg cGdzc19jYWxsX3RhYjIgKGEgaW50LCBiIGNoYXIoMjApKTsKK0lOU0VSVCBJTlRPIHBnc3NfY2Fs bF90YWIgVkFMVUVTICgwLCAnenp6Jyk7CisKK0NSRUFURSBQUk9DRURVUkUgcGdzc19jYWxsX3Jv bGxiYWNrX3Byb2MoKSBBUyAkJAorREVDTEFSRQorICAgIHYgaW50OworQkVHSU4KKyAgICBFWFBM QUlOIEFOQUxZWkUgV0lUSCBpbnMgQVMgKElOU0VSVCBJTlRPIHBnc3NfY2FsbF90YWIyIFNFTEVD VCAqIEZST00gcGdzc19jYWxsX3RhYiBSRVRVUk5JTkcgYSkKKyAgICBTRUxFQ1QgYSAvIDAgSU5U TyB2IEZST00gaW5zOworRVhDRVBUSU9OIFdIRU4gZGl2aXNpb25fYnlfemVybyBUSEVOCitFTkQ7 CiskJCBMQU5HVUFHRSBwbHBnc3FsOworCitTRUxFQ1QgcGdfc3RhdF9zdGF0ZW1lbnRzX3Jlc2V0 KCkgSVMgTk9UIE5VTEwgQVMgdDsKK0NBTEwgcGdzc19jYWxsX3JvbGxiYWNrX3Byb2MoKTsKKwor U0VMRUNUIHF1ZXJ5LCBjYWxscywKK2xvY2FsX2Jsa3NfaGl0ICsgbG9jYWxfYmxrc19yZWFkID4g MCBhcyBsb2NhbF9oaXRyZWFkLAord2FsX2J5dGVzID4gMCBhcyB3YWxfYnl0ZXNfZ2VuZXJhdGVk LAord2FsX3JlY29yZHMgPiAwIGFzIHdhbF9yZWNvcmRzX2dlbmVyYXRlZAorRlJPTSBwZ19zdGF0 X3N0YXRlbWVudHMKK1dIRVJFIHF1ZXJ5IExJS0UgJyVwZ3NzX2NhbGxfcm9sbGJhY2tfcHJvYyUn CitPUkRFUiBCWSBxdWVyeSBDT0xMQVRFICJDIjsKKworRFJPUCBUQUJMRSBwZ3NzX2NhbGxfdGFi MjsKK0RST1AgVEFCTEUgcGdzc19jYWxsX3RhYjsKK0RST1AgUFJPQ0VEVVJFIHBnc3NfY2FsbF9y b2xsYmFja19wcm9jOworU0VUIHBnX3N0YXRfc3RhdGVtZW50cy50cmFjayA9ICd0b3AnOworCiAt LSBDQUxMCiBDUkVBVEUgT1IgUkVQTEFDRSBQUk9DRURVUkUgc3VtX29uZShpIGludCkgQVMgJCQK IERFQ0xBUkUKZGlmZiAtLWdpdCBhL2NvbnRyaWIvcGdfc3RhdF9zdGF0ZW1lbnRzL3NxbC93YWwu c3FsIGIvY29udHJpYi9wZ19zdGF0X3N0YXRlbWVudHMvc3FsL3dhbC5zcWwKaW5kZXggMWRjMTU1 MmE4MWUuLjQ2N2UzMjFiMjA2IDEwMDY0NAotLS0gYS9jb250cmliL3BnX3N0YXRfc3RhdGVtZW50 cy9zcWwvd2FsLnNxbAorKysgYi9jb250cmliL3BnX3N0YXRfc3RhdGVtZW50cy9zcWwvd2FsLnNx bApAQCAtMTgsMyArMTgsMzYgQEAgd2FsX3JlY29yZHMgPiAwIGFzIHdhbF9yZWNvcmRzX2dlbmVy YXRlZCwKIHdhbF9yZWNvcmRzID49IHJvd3MgYXMgd2FsX3JlY29yZHNfZ2Vfcm93cwogRlJPTSBw Z19zdGF0X3N0YXRlbWVudHMgT1JERVIgQlkgcXVlcnkgQ09MTEFURSAiQyI7CiBTRUxFQ1QgcGdf c3RhdF9zdGF0ZW1lbnRzX3Jlc2V0KCkgSVMgTk9UIE5VTEwgQVMgdDsKKworLS0KKy0tIFZhbGlk YXRlIGJ1ZmZlci9XQUwgY291bnRpbmcgd2l0aCBjYXVnaHQgZXhjZXB0aW9uIGluIFBML3BnU1FM CistLQorQ1JFQVRFIFRFTVAgVEFCTEUgcGdzc19lcnJvcl90YWIgKGEgaW50LCBiIGNoYXIoMjAp KTsKK0lOU0VSVCBJTlRPIHBnc3NfZXJyb3JfdGFiIFZBTFVFUyAoMCwgJ3p6eicpOworCitDUkVB VEUgRlVOQ1RJT04gcGdzc19lcnJvcl9mdW5jKCkgUkVUVVJOUyB2b2lkIEFTICQkCitERUNMQVJF CisgICAgdiBpbnQ7CitCRUdJTgorICAgIFdJVEggaW5zIEFTIChJTlNFUlQgSU5UTyBwZ3NzX2Vy cm9yX3RhYiBWQUxVRVMgKDEsICdhYWEnKSBSRVRVUk5JTkcgYSkKKyAgICBTRUxFQ1QgYSAvIDAg SU5UTyB2IEZST00gaW5zOworRVhDRVBUSU9OIFdIRU4gZGl2aXNpb25fYnlfemVybyBUSEVOCisg ICAgTlVMTDsKK0VORDsKKyQkIExBTkdVQUdFIHBscGdzcWw7CisKK1NFTEVDVCBwZ19zdGF0X3N0 YXRlbWVudHNfcmVzZXQoKSBJUyBOT1QgTlVMTCBBUyB0OworU0VMRUNUIHBnc3NfZXJyb3JfZnVu YygpOworCistLSBCdWZmZXIvV0FMIHVzYWdlIGZyb20gdGhlIHdDVEUgSU5TRVJUIHNob3VsZCBz dXJ2aXZlIHRoZSBleGNlcHRpb24KK1NFTEVDVCBxdWVyeSwgY2FsbHMsCitsb2NhbF9ibGtzX2hp dCArIGxvY2FsX2Jsa3NfcmVhZCA+IDAgYXMgbG9jYWxfaGl0cmVhZCwKK3dhbF9ieXRlcyA+IDAg YXMgd2FsX2J5dGVzX2dlbmVyYXRlZCwKK3dhbF9yZWNvcmRzID4gMCBhcyB3YWxfcmVjb3Jkc19n ZW5lcmF0ZWQKK0ZST00gcGdfc3RhdF9zdGF0ZW1lbnRzCitXSEVSRSBxdWVyeSBMSUtFICclcGdz c19lcnJvcl9mdW5jJScKK09SREVSIEJZIHF1ZXJ5IENPTExBVEUgIkMiOworCitEUk9QIFRBQkxF IHBnc3NfZXJyb3JfdGFiOworRFJPUCBGVU5DVElPTiBwZ3NzX2Vycm9yX2Z1bmM7CitTRUxFQ1Qg cGdfc3RhdF9zdGF0ZW1lbnRzX3Jlc2V0KCkgSVMgTk9UIE5VTEwgQVMgdDsKZGlmZiAtLWdpdCBh L3NyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQvZXhwbGFpbi5vdXQgYi9zcmMvdGVzdC9yZWdyZXNz L2V4cGVjdGVkL2V4cGxhaW4ub3V0CmluZGV4IGIzMDdlODEwY2E1Li5mNjMwYWNkNWY1NCAxMDA2 NDQKLS0tIGEvc3JjL3Rlc3QvcmVncmVzcy9leHBlY3RlZC9leHBsYWluLm91dAorKysgYi9zcmMv dGVzdC9yZWdyZXNzL2V4cGVjdGVkL2V4cGxhaW4ub3V0CkBAIC04ODksMyArODg5LDIzMSBAQCBT RUxFQ1QgY2hlY2tfcGFyYWxsZWxfaW5kZXhvbmx5X3NjYW4oKSBBUyBwYXJhbGxlbF9pbmRleG9u bHlfaW5zdHJ1bWVudGF0aW9uOwogKDEgcm93KQogCiBEUk9QIEZVTkNUSU9OIGNoZWNrX3BhcmFs bGVsX2luZGV4b25seV9zY2FuOworLS0gVGVzdCBwYXJhbGxlbCBxdWVyeSByZXBvcnRzIHNpbWls YXIgYnVmZmVyIHN0YXRzIHRvIGEgc2VyaWFsIHJ1bgorQ1JFQVRFIEZVTkNUSU9OIGNoZWNrX3Bh cmFsbGVsX2V4cGxhaW5fYnVmZmVycygpIFJFVFVSTlMgVEFCTEUocmF0aW8gbnVtZXJpYykgQVMg JCQKK0RFQ0xBUkUKKyAgICBwbGFuX2pzb24ganNvbjsKKyAgICBzZXJpYWxfYnVmZmVycyBpbnQ7 CisgICAgcGFyYWxsZWxfYnVmZmVycyBpbnQ7CisgICAgbm9kZSBqc29uOworQkVHSU4KKyAgICAt LSBTZXJpYWwgLS0KKyAgICBTRVQgTE9DQUwgbWF4X3BhcmFsbGVsX3dvcmtlcnNfcGVyX2dhdGhl ciA9IDA7CisgICAgRVhFQ1VURSAnRVhQTEFJTiAoQU5BTFlaRSwgQlVGRkVSUywgQ09TVFMgT0ZG LCBGT1JNQVQgSlNPTikKKyAgICAgICAgU0VMRUNUIGNvdW50KCopIEZST00gdGVuazEnIElOVE8g cGxhbl9qc29uOworICAgIG5vZGUgOj0gcGxhbl9qc29uLT4wLT4nUGxhbic7CisgICAgc2VyaWFs X2J1ZmZlcnMgOj0KKyAgICAgICAgQ09BTEVTQ0UoKG5vZGUtPj4nU2hhcmVkIEhpdCBCbG9ja3Mn KTo6aW50LCAwKSArCisgICAgICAgIENPQUxFU0NFKChub2RlLT4+J1NoYXJlZCBSZWFkIEJsb2Nr cycpOjppbnQsIDApOworCisgICAgLS0gUGFyYWxsZWwgLS0KKyAgICBTRVQgTE9DQUwgcGFyYWxs ZWxfc2V0dXBfY29zdCA9IDA7CisgICAgU0VUIExPQ0FMIHBhcmFsbGVsX3R1cGxlX2Nvc3QgPSAw OworICAgIFNFVCBMT0NBTCBtaW5fcGFyYWxsZWxfdGFibGVfc2Nhbl9zaXplID0gMDsKKyAgICBT RVQgTE9DQUwgbWF4X3BhcmFsbGVsX3dvcmtlcnNfcGVyX2dhdGhlciA9IDI7CisgICAgU0VUIExP Q0FMIHBhcmFsbGVsX2xlYWRlcl9wYXJ0aWNpcGF0aW9uID0gb2ZmOworICAgIEVYRUNVVEUgJ0VY UExBSU4gKEFOQUxZWkUsIEJVRkZFUlMsIENPU1RTIE9GRiwgRk9STUFUIEpTT04pCisgICAgICAg IFNFTEVDVCBjb3VudCgqKSBGUk9NIHRlbmsxJyBJTlRPIHBsYW5fanNvbjsKKyAgICBub2RlIDo9 IHBsYW5fanNvbi0+MC0+J1BsYW4nOworICAgIHBhcmFsbGVsX2J1ZmZlcnMgOj0KKyAgICAgICAg Q09BTEVTQ0UoKG5vZGUtPj4nU2hhcmVkIEhpdCBCbG9ja3MnKTo6aW50LCAwKSArCisgICAgICAg IENPQUxFU0NFKChub2RlLT4+J1NoYXJlZCBSZWFkIEJsb2NrcycpOjppbnQsIDApOworCisgICAg UkVUVVJOIFFVRVJZIFNFTEVDVCByb3VuZChwYXJhbGxlbF9idWZmZXJzOjpudW1lcmljIC8gR1JF QVRFU1Qoc2VyaWFsX2J1ZmZlcnMsIDEpKTsKK0VORDsKKyQkIExBTkdVQUdFIHBscGdzcWw7CitT RUxFQ1QgKiBGUk9NIGNoZWNrX3BhcmFsbGVsX2V4cGxhaW5fYnVmZmVycygpOworIHJhdGlvIAor LS0tLS0tLQorICAgICAxCisoMSByb3cpCisKK0RST1AgRlVOQ1RJT04gY2hlY2tfcGFyYWxsZWxf ZXhwbGFpbl9idWZmZXJzOworLS0gRVhQTEFJTiAoQU5BTFlaRSwgQlVGRkVSUykgc2hvdWxkIHJl cG9ydCBidWZmZXIgdXNhZ2UgZnJvbSBQTC9wZ1NRTAorLS0gRVhDRVBUSU9OIGJsb2NrcywgZXZl biBhZnRlciBzdWJ0cmFuc2FjdGlvbiByb2xsYmFjay4KK0NSRUFURSBURU1QIFRBQkxFIGV4cGxh aW5fZXhjX3RhYiAoYSBpbnQsIGIgY2hhcigyMCkpOworSU5TRVJUIElOVE8gZXhwbGFpbl9leGNf dGFiIFZBTFVFUyAoMCwgJ3p6eicpOworQ1JFQVRFIEZVTkNUSU9OIGV4cGxhaW5fZXhjX2Z1bmMo KSBSRVRVUk5TIHZvaWQgQVMgJCQKK0RFQ0xBUkUKKyAgICB2IGludDsKK0JFR0lOCisgICAgV0lU SCBpbnMgQVMgKElOU0VSVCBJTlRPIGV4cGxhaW5fZXhjX3RhYiBWQUxVRVMgKDEsICdhYWEnKSBS RVRVUk5JTkcgYSkKKyAgICBTRUxFQ1QgYSAvIDAgSU5UTyB2IEZST00gaW5zOworRVhDRVBUSU9O IFdIRU4gZGl2aXNpb25fYnlfemVybyBUSEVOCisgICAgTlVMTDsKK0VORDsKKyQkIExBTkdVQUdF IHBscGdzcWw7CitDUkVBVEUgRlVOQ1RJT04gY2hlY2tfZXhwbGFpbl9leGNlcHRpb25fYnVmZmVy cygpIFJFVFVSTlMgYm9vbGVhbiBBUyAkJAorREVDTEFSRQorICAgIHBsYW5fanNvbiBqc29uOwor ICAgIG5vZGUganNvbjsKKyAgICB0b3RhbF9idWZmZXJzIGludDsKK0JFR0lOCisgICAgRVhFQ1VU RSAnRVhQTEFJTiAoQU5BTFlaRSwgQlVGRkVSUywgQ09TVFMgT0ZGLCBGT1JNQVQgSlNPTikKKyAg ICAgICAgU0VMRUNUIGV4cGxhaW5fZXhjX2Z1bmMoKScgSU5UTyBwbGFuX2pzb247CisgICAgbm9k ZSA6PSBwbGFuX2pzb24tPjAtPidQbGFuJzsKKyAgICB0b3RhbF9idWZmZXJzIDo9CisgICAgICAg IENPQUxFU0NFKChub2RlLT4+J0xvY2FsIEhpdCBCbG9ja3MnKTo6aW50LCAwKSArCisgICAgICAg IENPQUxFU0NFKChub2RlLT4+J0xvY2FsIFJlYWQgQmxvY2tzJyk6OmludCwgMCk7CisgICAgUkVU VVJOIHRvdGFsX2J1ZmZlcnMgPiAwOworRU5EOworJCQgTEFOR1VBR0UgcGxwZ3NxbDsKK1NFTEVD VCBjaGVja19leHBsYWluX2V4Y2VwdGlvbl9idWZmZXJzKCkgQVMgZXhjZXB0aW9uX2J1ZmZlcnNf dmlzaWJsZTsKKyBleGNlcHRpb25fYnVmZmVyc192aXNpYmxlIAorLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tCisgdAorKDEgcm93KQorCistLSBBbHNvIHRlc3Qgd2l0aCBuZXN0ZWQgRVhQTEFJ TiBBTkFMWVpFICh0d28gbGV2ZWxzIG9mIGluc3RydW1lbnRhdGlvbikKK0NSRUFURSBGVU5DVElP TiBjaGVja19leHBsYWluX2V4Y2VwdGlvbl9idWZmZXJzX25lc3RlZCgpIFJFVFVSTlMgYm9vbGVh biBBUyAkJAorREVDTEFSRQorICAgIHBsYW5fanNvbiBqc29uOworICAgIG5vZGUganNvbjsKKyAg ICB0b3RhbF9idWZmZXJzIGludDsKK0JFR0lOCisgICAgRVhFQ1VURSAnRVhQTEFJTiAoQU5BTFla RSwgQlVGRkVSUywgQ09TVFMgT0ZGLCBGT1JNQVQgSlNPTikKKyAgICAgICAgU0VMRUNUIGNoZWNr X2V4cGxhaW5fZXhjZXB0aW9uX2J1ZmZlcnMoKScgSU5UTyBwbGFuX2pzb247CisgICAgbm9kZSA6 PSBwbGFuX2pzb24tPjAtPidQbGFuJzsKKyAgICB0b3RhbF9idWZmZXJzIDo9CisgICAgICAgIENP QUxFU0NFKChub2RlLT4+J0xvY2FsIEhpdCBCbG9ja3MnKTo6aW50LCAwKSArCisgICAgICAgIENP QUxFU0NFKChub2RlLT4+J0xvY2FsIFJlYWQgQmxvY2tzJyk6OmludCwgMCk7CisgICAgUkVUVVJO IHRvdGFsX2J1ZmZlcnMgPiAwOworRU5EOworJCQgTEFOR1VBR0UgcGxwZ3NxbDsKK1NFTEVDVCBj aGVja19leHBsYWluX2V4Y2VwdGlvbl9idWZmZXJzX25lc3RlZCgpIEFTIGV4Y2VwdGlvbl9idWZm ZXJzX25lc3RlZF92aXNpYmxlOworIGV4Y2VwdGlvbl9idWZmZXJzX25lc3RlZF92aXNpYmxlIAor LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorIHQKKygxIHJvdykKKworRFJPUCBG VU5DVElPTiBjaGVja19leHBsYWluX2V4Y2VwdGlvbl9idWZmZXJzX25lc3RlZDsKK0RST1AgRlVO Q1RJT04gY2hlY2tfZXhwbGFpbl9leGNlcHRpb25fYnVmZmVyczsKK0RST1AgRlVOQ1RJT04gZXhw bGFpbl9leGNfZnVuYzsKK0RST1AgVEFCTEUgZXhwbGFpbl9leGNfdGFiOworLS0gQ3Vyc29yIGlu c3RydW1lbnRhdGlvbiB0ZXN0LgorLS0gVmVyaWZ5IHRoYXQgYnVmZmVyIHVzYWdlIGlzIGNvcnJl Y3RseSB0cmFja2VkIHRocm91Z2ggY3Vyc29yIGV4ZWN1dGlvbiBwYXRocy4KKy0tIE5vbi1zY3Jv bGxhYmxlIGN1cnNvcnMgZXhlcmNpc2UgRXhlY1NodXRkb3duTm9kZSBhZnRlciBlYWNoIEV4ZWN1 dG9yUnVuCistLSAoRVhFQ19GTEFHX0JBQ0tXQVJEIGlzIG5vdCBzZXQpLCB3aGlsZSBzY3JvbGxh YmxlIGN1cnNvcnMgb25seSBzaHV0IGRvd24KKy0tIG5vZGVzIGluIEV4ZWN1dG9yRmluaXNoLiBJ biBib3RoIGNhc2VzLCBidWZmZXIgdXNhZ2UgZnJvbSB0aGUgaW5uZXIgY3Vyc29yCistLSBzY2Fu IHNob3VsZCBiZSBjb3JyZWN0bHkgcmVwb3J0ZWQuCitDUkVBVEUgVEVNUCBUQUJMRSBjdXJzb3Jf YnVmX3Rlc3QgQVMgU0VMRUNUICogRlJPTSB0ZW5rMTsKK0NSRUFURSBGVU5DVElPTiBjdXJzb3Jf bm9zY3JvbGxfc2NhbigpIFJFVFVSTlMgYmlnaW50IEFTICQkCitERUNMQVJFCisgICAgY3VyIE5P IFNDUk9MTCBDVVJTT1IgRk9SIFNFTEVDVCAqIEZST00gY3Vyc29yX2J1Zl90ZXN0OworICAgIHJl YyBSRUNPUkQ7CisgICAgY250IGJpZ2ludCA6PSAwOworQkVHSU4KKyAgICBPUEVOIGN1cjsKKyAg ICBMT09QCisgICAgICAgIEZFVENIIE5FWFQgRlJPTSBjdXIgSU5UTyByZWM7CisgICAgICAgIEVY SVQgV0hFTiBOT1QgRk9VTkQ7CisgICAgICAgIGNudCA6PSBjbnQgKyAxOworICAgIEVORCBMT09Q OworICAgIENMT1NFIGN1cjsKKyAgICBSRVRVUk4gY250OworRU5EOworJCQgTEFOR1VBR0UgcGxw Z3NxbDsKK0NSRUFURSBGVU5DVElPTiBjdXJzb3Jfc2Nyb2xsX3NjYW4oKSBSRVRVUk5TIGJpZ2lu dCBBUyAkJAorREVDTEFSRQorICAgIGN1ciBTQ1JPTEwgQ1VSU09SIEZPUiBTRUxFQ1QgKiBGUk9N IGN1cnNvcl9idWZfdGVzdDsKKyAgICByZWMgUkVDT1JEOworICAgIGNudCBiaWdpbnQgOj0gMDsK K0JFR0lOCisgICAgT1BFTiBjdXI7CisgICAgTE9PUAorICAgICAgICBGRVRDSCBORVhUIEZST00g Y3VyIElOVE8gcmVjOworICAgICAgICBFWElUIFdIRU4gTk9UIEZPVU5EOworICAgICAgICBjbnQg Oj0gY250ICsgMTsKKyAgICBFTkQgTE9PUDsKKyAgICBDTE9TRSBjdXI7CisgICAgUkVUVVJOIGNu dDsKK0VORDsKKyQkIExBTkdVQUdFIHBscGdzcWw7CitDUkVBVEUgRlVOQ1RJT04gY2hlY2tfY3Vy c29yX2V4cGxhaW5fYnVmZmVycygpIFJFVFVSTlMgVEFCTEUobm9zY3JvbGxfb2sgYm9vbGVhbiwg c2Nyb2xsX29rIGJvb2xlYW4pIEFTICQkCitERUNMQVJFCisgICAgcGxhbl9qc29uIGpzb247Cisg ICAgbm9kZSBqc29uOworICAgIGRpcmVjdF9idWYgaW50OworICAgIG5vc2Nyb2xsX2J1ZiBpbnQ7 CisgICAgc2Nyb2xsX2J1ZiBpbnQ7CitCRUdJTgorICAgIC0tIERpcmVjdCBzY2FuOiBnZXQgbGVh ZiBTZXEgU2NhbiBub2RlIGJ1ZmZlcnMgYXMgYmFzZWxpbmUKKyAgICBFWEVDVVRFICdFWFBMQUlO IChBTkFMWVpFLCBCVUZGRVJTLCBDT1NUUyBPRkYsIEZPUk1BVCBKU09OKQorICAgICAgICBTRUxF Q1QgKiBGUk9NIGN1cnNvcl9idWZfdGVzdCcgSU5UTyBwbGFuX2pzb247CisgICAgbm9kZSA6PSBw bGFuX2pzb24tPjAtPidQbGFuJzsKKyAgICBXSElMRSBub2RlLT4nUGxhbnMnIElTIE5PVCBOVUxM IExPT1AKKyAgICAgICAgbm9kZSA6PSBub2RlLT4nUGxhbnMnLT4wOworICAgIEVORCBMT09QOwor ICAgIGRpcmVjdF9idWYgOj0KKyAgICAgICAgQ09BTEVTQ0UoKG5vZGUtPj4nTG9jYWwgSGl0IEJs b2NrcycpOjppbnQsIDApICsKKyAgICAgICAgQ09BTEVTQ0UoKG5vZGUtPj4nTG9jYWwgUmVhZCBC bG9ja3MnKTo6aW50LCAwKTsKKworICAgIC0tIE5vbi1zY3JvbGxhYmxlIGN1cnNvciBwYXRoOiBF eGVjU2h1dGRvd25Ob2RlIHJ1bnMgYWZ0ZXIgZWFjaCBFeGVjdXRvclJ1bgorICAgIEVYRUNVVEUg J0VYUExBSU4gKEFOQUxZWkUsIEJVRkZFUlMsIENPU1RTIE9GRiwgRk9STUFUIEpTT04pCisgICAg ICAgIFNFTEVDVCBjdXJzb3Jfbm9zY3JvbGxfc2NhbigpJyBJTlRPIHBsYW5fanNvbjsKKyAgICBu b2RlIDo9IHBsYW5fanNvbi0+MC0+J1BsYW4nOworICAgIG5vc2Nyb2xsX2J1ZiA6PQorICAgICAg ICBDT0FMRVNDRSgobm9kZS0+PidMb2NhbCBIaXQgQmxvY2tzJyk6OmludCwgMCkgKworICAgICAg ICBDT0FMRVNDRSgobm9kZS0+PidMb2NhbCBSZWFkIEJsb2NrcycpOjppbnQsIDApOworCisgICAg LS0gU2Nyb2xsYWJsZSBjdXJzb3IgcGF0aDogRXhlY1NodXRkb3duTm9kZSBpcyBza2lwcGVkCisg ICAgRVhFQ1VURSAnRVhQTEFJTiAoQU5BTFlaRSwgQlVGRkVSUywgQ09TVFMgT0ZGLCBGT1JNQVQg SlNPTikKKyAgICAgICAgU0VMRUNUIGN1cnNvcl9zY3JvbGxfc2NhbigpJyBJTlRPIHBsYW5fanNv bjsKKyAgICBub2RlIDo9IHBsYW5fanNvbi0+MC0+J1BsYW4nOworICAgIHNjcm9sbF9idWYgOj0K KyAgICAgICAgQ09BTEVTQ0UoKG5vZGUtPj4nTG9jYWwgSGl0IEJsb2NrcycpOjppbnQsIDApICsK KyAgICAgICAgQ09BTEVTQ0UoKG5vZGUtPj4nTG9jYWwgUmVhZCBCbG9ja3MnKTo6aW50LCAwKTsK KworICAgIC0tIEJvdGggY3Vyc29yIHBhdGhzIHNob3VsZCByZXBvcnQgYnVmZmVyIGNvdW50cyBh Ym91dCBhcyBoaWdoIGFzCisgICAgLS0gdGhlIGRpcmVjdCBzY2FuIChzYW1lIGRhdGEgcGx1cyBt aW5vciBjYXRhbG9nIG92ZXJoZWFkKSwgYW5kIG5vdAorICAgIC0tIGRvdWJsZS1jb3VudGVkICg8 IDJ4IHRoZSBkaXJlY3Qgc2NhbikKKyAgICBSRVRVUk4gUVVFUlkgU0VMRUNUCisgICAgICAgIChu b3Njcm9sbF9idWYgPj0gZGlyZWN0X2J1ZiAqIDAuNSBBTkQgbm9zY3JvbGxfYnVmIDwgZGlyZWN0 X2J1ZiAqIDIpLAorICAgICAgICAoc2Nyb2xsX2J1ZiA+PSBkaXJlY3RfYnVmICogMC41IEFORCBz Y3JvbGxfYnVmIDwgZGlyZWN0X2J1ZiAqIDIpOworRU5EOworJCQgTEFOR1VBR0UgcGxwZ3NxbDsK K1NFTEVDVCAqIEZST00gY2hlY2tfY3Vyc29yX2V4cGxhaW5fYnVmZmVycygpOworIG5vc2Nyb2xs X29rIHwgc2Nyb2xsX29rIAorLS0tLS0tLS0tLS0tLSstLS0tLS0tLS0tLQorIHQgICAgICAgICAg IHwgdAorKDEgcm93KQorCitEUk9QIEZVTkNUSU9OIGNoZWNrX2N1cnNvcl9leHBsYWluX2J1ZmZl cnM7CitEUk9QIEZVTkNUSU9OIGN1cnNvcl9ub3Njcm9sbF9zY2FuOworRFJPUCBGVU5DVElPTiBj dXJzb3Jfc2Nyb2xsX3NjYW47CitEUk9QIFRBQkxFIGN1cnNvcl9idWZfdGVzdDsKKy0tIFRlc3Qg dHJpZ2dlciBpbnN0cnVtZW50YXRpb24uCitDUkVBVEUgVEVNUCBUQUJMRSB0cmlnX3Rlc3RfdGFi IChhIGludCk7CitDUkVBVEUgVEVNUCBUQUJMRSB0cmlnX3dvcmtfdGFiIChhIGludCk7CitJTlNF UlQgSU5UTyB0cmlnX3dvcmtfdGFiIFZBTFVFUyAoMSk7CitDUkVBVEUgRlVOQ1RJT04gdHJpZ190 ZXN0X2Z1bmMoKSBSRVRVUk5TIHRyaWdnZXIgQVMgJCQKK0JFR0lOCisgICAgUEVSRk9STSAqIEZS T00gdHJpZ193b3JrX3RhYjsKKyAgICBSRVRVUk4gTkVXOworRU5EOworJCQgTEFOR1VBR0UgcGxw Z3NxbDsKK0NSRUFURSBUUklHR0VSIHRyaWdfdGVzdF90cmlnCisgICAgQkVGT1JFIElOU0VSVCBP TiB0cmlnX3Rlc3RfdGFiCisgICAgRk9SIEVBQ0ggUk9XIEVYRUNVVEUgRlVOQ1RJT04gdHJpZ190 ZXN0X2Z1bmMoKTsKK0NSRUFURSBGVU5DVElPTiBjaGVja190cmlnZ2VyX2V4cGxhaW5fYnVmZmVy cygpIFJFVFVSTlMgYm9vbGVhbiBBUyAkJAorREVDTEFSRQorICAgIHBsYW5fanNvbiBqc29uOwor ICAgIHRyaWcganNvbjsKK0JFR0lOCisgICAgRVhFQ1VURSAnRVhQTEFJTiAoQU5BTFlaRSwgQlVG RkVSUywgQ09TVFMgT0ZGLCBGT1JNQVQgSlNPTikKKyAgICAgICAgSU5TRVJUIElOVE8gdHJpZ190 ZXN0X3RhYiBWQUxVRVMgKDEpJyBJTlRPIHBsYW5fanNvbjsKKyAgICB0cmlnIDo9IHBsYW5fanNv bi0+MC0+J1RyaWdnZXJzJy0+MDsKKyAgICBSRVRVUk4gQ09BTEVTQ0UoKHRyaWctPj4nQ2FsbHMn KTo6aW50LCAwKSA+IDA7CitFTkQ7CiskJCBMQU5HVUFHRSBwbHBnc3FsOworU0VMRUNUIGNoZWNr X3RyaWdnZXJfZXhwbGFpbl9idWZmZXJzKCkgQVMgdHJpZ2dlcl9idWZmZXJzX3Zpc2libGU7Cisg dHJpZ2dlcl9idWZmZXJzX3Zpc2libGUgCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgdAor KDEgcm93KQorCitEUk9QIEZVTkNUSU9OIGNoZWNrX3RyaWdnZXJfZXhwbGFpbl9idWZmZXJzOwor RFJPUCBUUklHR0VSIHRyaWdfdGVzdF90cmlnIE9OIHRyaWdfdGVzdF90YWI7CitEUk9QIEZVTkNU SU9OIHRyaWdfdGVzdF9mdW5jOworRFJPUCBUQUJMRSB0cmlnX3Rlc3RfdGFiOworRFJPUCBUQUJM RSB0cmlnX3dvcmtfdGFiOwpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvcmVncmVzcy9zcWwvZXhwbGFp bi5zcWwgYi9zcmMvdGVzdC9yZWdyZXNzL3NxbC9leHBsYWluLnNxbAppbmRleCAzYTEzZmE2Y2E2 OS4uNzRmNjA1NzM5ZjEgMTAwNjQ0Ci0tLSBhL3NyYy90ZXN0L3JlZ3Jlc3Mvc3FsL2V4cGxhaW4u c3FsCisrKyBiL3NyYy90ZXN0L3JlZ3Jlc3Mvc3FsL2V4cGxhaW4uc3FsCkBAIC0yNTEsMyArMjUx LDIyOSBAQCAkJCBMQU5HVUFHRSBwbHBnc3FsOwogU0VMRUNUIGNoZWNrX3BhcmFsbGVsX2luZGV4 b25seV9zY2FuKCkgQVMgcGFyYWxsZWxfaW5kZXhvbmx5X2luc3RydW1lbnRhdGlvbjsKIAogRFJP UCBGVU5DVElPTiBjaGVja19wYXJhbGxlbF9pbmRleG9ubHlfc2NhbjsKKworLS0gVGVzdCBwYXJh bGxlbCBxdWVyeSByZXBvcnRzIHNpbWlsYXIgYnVmZmVyIHN0YXRzIHRvIGEgc2VyaWFsIHJ1bgor Q1JFQVRFIEZVTkNUSU9OIGNoZWNrX3BhcmFsbGVsX2V4cGxhaW5fYnVmZmVycygpIFJFVFVSTlMg VEFCTEUocmF0aW8gbnVtZXJpYykgQVMgJCQKK0RFQ0xBUkUKKyAgICBwbGFuX2pzb24ganNvbjsK KyAgICBzZXJpYWxfYnVmZmVycyBpbnQ7CisgICAgcGFyYWxsZWxfYnVmZmVycyBpbnQ7CisgICAg bm9kZSBqc29uOworQkVHSU4KKyAgICAtLSBTZXJpYWwgLS0KKyAgICBTRVQgTE9DQUwgbWF4X3Bh cmFsbGVsX3dvcmtlcnNfcGVyX2dhdGhlciA9IDA7CisgICAgRVhFQ1VURSAnRVhQTEFJTiAoQU5B TFlaRSwgQlVGRkVSUywgQ09TVFMgT0ZGLCBGT1JNQVQgSlNPTikKKyAgICAgICAgU0VMRUNUIGNv dW50KCopIEZST00gdGVuazEnIElOVE8gcGxhbl9qc29uOworICAgIG5vZGUgOj0gcGxhbl9qc29u LT4wLT4nUGxhbic7CisgICAgc2VyaWFsX2J1ZmZlcnMgOj0KKyAgICAgICAgQ09BTEVTQ0UoKG5v ZGUtPj4nU2hhcmVkIEhpdCBCbG9ja3MnKTo6aW50LCAwKSArCisgICAgICAgIENPQUxFU0NFKChu b2RlLT4+J1NoYXJlZCBSZWFkIEJsb2NrcycpOjppbnQsIDApOworCisgICAgLS0gUGFyYWxsZWwg LS0KKyAgICBTRVQgTE9DQUwgcGFyYWxsZWxfc2V0dXBfY29zdCA9IDA7CisgICAgU0VUIExPQ0FM IHBhcmFsbGVsX3R1cGxlX2Nvc3QgPSAwOworICAgIFNFVCBMT0NBTCBtaW5fcGFyYWxsZWxfdGFi bGVfc2Nhbl9zaXplID0gMDsKKyAgICBTRVQgTE9DQUwgbWF4X3BhcmFsbGVsX3dvcmtlcnNfcGVy X2dhdGhlciA9IDI7CisgICAgU0VUIExPQ0FMIHBhcmFsbGVsX2xlYWRlcl9wYXJ0aWNpcGF0aW9u ID0gb2ZmOworICAgIEVYRUNVVEUgJ0VYUExBSU4gKEFOQUxZWkUsIEJVRkZFUlMsIENPU1RTIE9G RiwgRk9STUFUIEpTT04pCisgICAgICAgIFNFTEVDVCBjb3VudCgqKSBGUk9NIHRlbmsxJyBJTlRP IHBsYW5fanNvbjsKKyAgICBub2RlIDo9IHBsYW5fanNvbi0+MC0+J1BsYW4nOworICAgIHBhcmFs bGVsX2J1ZmZlcnMgOj0KKyAgICAgICAgQ09BTEVTQ0UoKG5vZGUtPj4nU2hhcmVkIEhpdCBCbG9j a3MnKTo6aW50LCAwKSArCisgICAgICAgIENPQUxFU0NFKChub2RlLT4+J1NoYXJlZCBSZWFkIEJs b2NrcycpOjppbnQsIDApOworCisgICAgUkVUVVJOIFFVRVJZIFNFTEVDVCByb3VuZChwYXJhbGxl bF9idWZmZXJzOjpudW1lcmljIC8gR1JFQVRFU1Qoc2VyaWFsX2J1ZmZlcnMsIDEpKTsKK0VORDsK KyQkIExBTkdVQUdFIHBscGdzcWw7CisKK1NFTEVDVCAqIEZST00gY2hlY2tfcGFyYWxsZWxfZXhw bGFpbl9idWZmZXJzKCk7CisKK0RST1AgRlVOQ1RJT04gY2hlY2tfcGFyYWxsZWxfZXhwbGFpbl9i dWZmZXJzOworCistLSBFWFBMQUlOIChBTkFMWVpFLCBCVUZGRVJTKSBzaG91bGQgcmVwb3J0IGJ1 ZmZlciB1c2FnZSBmcm9tIFBML3BnU1FMCistLSBFWENFUFRJT04gYmxvY2tzLCBldmVuIGFmdGVy IHN1YnRyYW5zYWN0aW9uIHJvbGxiYWNrLgorQ1JFQVRFIFRFTVAgVEFCTEUgZXhwbGFpbl9leGNf dGFiIChhIGludCwgYiBjaGFyKDIwKSk7CitJTlNFUlQgSU5UTyBleHBsYWluX2V4Y190YWIgVkFM VUVTICgwLCAnenp6Jyk7CisKK0NSRUFURSBGVU5DVElPTiBleHBsYWluX2V4Y19mdW5jKCkgUkVU VVJOUyB2b2lkIEFTICQkCitERUNMQVJFCisgICAgdiBpbnQ7CitCRUdJTgorICAgIFdJVEggaW5z IEFTIChJTlNFUlQgSU5UTyBleHBsYWluX2V4Y190YWIgVkFMVUVTICgxLCAnYWFhJykgUkVUVVJO SU5HIGEpCisgICAgU0VMRUNUIGEgLyAwIElOVE8gdiBGUk9NIGluczsKK0VYQ0VQVElPTiBXSEVO IGRpdmlzaW9uX2J5X3plcm8gVEhFTgorICAgIE5VTEw7CitFTkQ7CiskJCBMQU5HVUFHRSBwbHBn c3FsOworCitDUkVBVEUgRlVOQ1RJT04gY2hlY2tfZXhwbGFpbl9leGNlcHRpb25fYnVmZmVycygp IFJFVFVSTlMgYm9vbGVhbiBBUyAkJAorREVDTEFSRQorICAgIHBsYW5fanNvbiBqc29uOworICAg IG5vZGUganNvbjsKKyAgICB0b3RhbF9idWZmZXJzIGludDsKK0JFR0lOCisgICAgRVhFQ1VURSAn RVhQTEFJTiAoQU5BTFlaRSwgQlVGRkVSUywgQ09TVFMgT0ZGLCBGT1JNQVQgSlNPTikKKyAgICAg ICAgU0VMRUNUIGV4cGxhaW5fZXhjX2Z1bmMoKScgSU5UTyBwbGFuX2pzb247CisgICAgbm9kZSA6 PSBwbGFuX2pzb24tPjAtPidQbGFuJzsKKyAgICB0b3RhbF9idWZmZXJzIDo9CisgICAgICAgIENP QUxFU0NFKChub2RlLT4+J0xvY2FsIEhpdCBCbG9ja3MnKTo6aW50LCAwKSArCisgICAgICAgIENP QUxFU0NFKChub2RlLT4+J0xvY2FsIFJlYWQgQmxvY2tzJyk6OmludCwgMCk7CisgICAgUkVUVVJO IHRvdGFsX2J1ZmZlcnMgPiAwOworRU5EOworJCQgTEFOR1VBR0UgcGxwZ3NxbDsKKworU0VMRUNU IGNoZWNrX2V4cGxhaW5fZXhjZXB0aW9uX2J1ZmZlcnMoKSBBUyBleGNlcHRpb25fYnVmZmVyc192 aXNpYmxlOworCistLSBBbHNvIHRlc3Qgd2l0aCBuZXN0ZWQgRVhQTEFJTiBBTkFMWVpFICh0d28g bGV2ZWxzIG9mIGluc3RydW1lbnRhdGlvbikKK0NSRUFURSBGVU5DVElPTiBjaGVja19leHBsYWlu X2V4Y2VwdGlvbl9idWZmZXJzX25lc3RlZCgpIFJFVFVSTlMgYm9vbGVhbiBBUyAkJAorREVDTEFS RQorICAgIHBsYW5fanNvbiBqc29uOworICAgIG5vZGUganNvbjsKKyAgICB0b3RhbF9idWZmZXJz IGludDsKK0JFR0lOCisgICAgRVhFQ1VURSAnRVhQTEFJTiAoQU5BTFlaRSwgQlVGRkVSUywgQ09T VFMgT0ZGLCBGT1JNQVQgSlNPTikKKyAgICAgICAgU0VMRUNUIGNoZWNrX2V4cGxhaW5fZXhjZXB0 aW9uX2J1ZmZlcnMoKScgSU5UTyBwbGFuX2pzb247CisgICAgbm9kZSA6PSBwbGFuX2pzb24tPjAt PidQbGFuJzsKKyAgICB0b3RhbF9idWZmZXJzIDo9CisgICAgICAgIENPQUxFU0NFKChub2RlLT4+ J0xvY2FsIEhpdCBCbG9ja3MnKTo6aW50LCAwKSArCisgICAgICAgIENPQUxFU0NFKChub2RlLT4+ J0xvY2FsIFJlYWQgQmxvY2tzJyk6OmludCwgMCk7CisgICAgUkVUVVJOIHRvdGFsX2J1ZmZlcnMg PiAwOworRU5EOworJCQgTEFOR1VBR0UgcGxwZ3NxbDsKKworU0VMRUNUIGNoZWNrX2V4cGxhaW5f ZXhjZXB0aW9uX2J1ZmZlcnNfbmVzdGVkKCkgQVMgZXhjZXB0aW9uX2J1ZmZlcnNfbmVzdGVkX3Zp c2libGU7CisKK0RST1AgRlVOQ1RJT04gY2hlY2tfZXhwbGFpbl9leGNlcHRpb25fYnVmZmVyc19u ZXN0ZWQ7CitEUk9QIEZVTkNUSU9OIGNoZWNrX2V4cGxhaW5fZXhjZXB0aW9uX2J1ZmZlcnM7CitE Uk9QIEZVTkNUSU9OIGV4cGxhaW5fZXhjX2Z1bmM7CitEUk9QIFRBQkxFIGV4cGxhaW5fZXhjX3Rh YjsKKworLS0gQ3Vyc29yIGluc3RydW1lbnRhdGlvbiB0ZXN0LgorLS0gVmVyaWZ5IHRoYXQgYnVm ZmVyIHVzYWdlIGlzIGNvcnJlY3RseSB0cmFja2VkIHRocm91Z2ggY3Vyc29yIGV4ZWN1dGlvbiBw YXRocy4KKy0tIE5vbi1zY3JvbGxhYmxlIGN1cnNvcnMgZXhlcmNpc2UgRXhlY1NodXRkb3duTm9k ZSBhZnRlciBlYWNoIEV4ZWN1dG9yUnVuCistLSAoRVhFQ19GTEFHX0JBQ0tXQVJEIGlzIG5vdCBz ZXQpLCB3aGlsZSBzY3JvbGxhYmxlIGN1cnNvcnMgb25seSBzaHV0IGRvd24KKy0tIG5vZGVzIGlu IEV4ZWN1dG9yRmluaXNoLiBJbiBib3RoIGNhc2VzLCBidWZmZXIgdXNhZ2UgZnJvbSB0aGUgaW5u ZXIgY3Vyc29yCistLSBzY2FuIHNob3VsZCBiZSBjb3JyZWN0bHkgcmVwb3J0ZWQuCisKK0NSRUFU RSBURU1QIFRBQkxFIGN1cnNvcl9idWZfdGVzdCBBUyBTRUxFQ1QgKiBGUk9NIHRlbmsxOworCitD UkVBVEUgRlVOQ1RJT04gY3Vyc29yX25vc2Nyb2xsX3NjYW4oKSBSRVRVUk5TIGJpZ2ludCBBUyAk JAorREVDTEFSRQorICAgIGN1ciBOTyBTQ1JPTEwgQ1VSU09SIEZPUiBTRUxFQ1QgKiBGUk9NIGN1 cnNvcl9idWZfdGVzdDsKKyAgICByZWMgUkVDT1JEOworICAgIGNudCBiaWdpbnQgOj0gMDsKK0JF R0lOCisgICAgT1BFTiBjdXI7CisgICAgTE9PUAorICAgICAgICBGRVRDSCBORVhUIEZST00gY3Vy IElOVE8gcmVjOworICAgICAgICBFWElUIFdIRU4gTk9UIEZPVU5EOworICAgICAgICBjbnQgOj0g Y250ICsgMTsKKyAgICBFTkQgTE9PUDsKKyAgICBDTE9TRSBjdXI7CisgICAgUkVUVVJOIGNudDsK K0VORDsKKyQkIExBTkdVQUdFIHBscGdzcWw7CisKK0NSRUFURSBGVU5DVElPTiBjdXJzb3Jfc2Ny b2xsX3NjYW4oKSBSRVRVUk5TIGJpZ2ludCBBUyAkJAorREVDTEFSRQorICAgIGN1ciBTQ1JPTEwg Q1VSU09SIEZPUiBTRUxFQ1QgKiBGUk9NIGN1cnNvcl9idWZfdGVzdDsKKyAgICByZWMgUkVDT1JE OworICAgIGNudCBiaWdpbnQgOj0gMDsKK0JFR0lOCisgICAgT1BFTiBjdXI7CisgICAgTE9PUAor ICAgICAgICBGRVRDSCBORVhUIEZST00gY3VyIElOVE8gcmVjOworICAgICAgICBFWElUIFdIRU4g Tk9UIEZPVU5EOworICAgICAgICBjbnQgOj0gY250ICsgMTsKKyAgICBFTkQgTE9PUDsKKyAgICBD TE9TRSBjdXI7CisgICAgUkVUVVJOIGNudDsKK0VORDsKKyQkIExBTkdVQUdFIHBscGdzcWw7CisK K0NSRUFURSBGVU5DVElPTiBjaGVja19jdXJzb3JfZXhwbGFpbl9idWZmZXJzKCkgUkVUVVJOUyBU QUJMRShub3Njcm9sbF9vayBib29sZWFuLCBzY3JvbGxfb2sgYm9vbGVhbikgQVMgJCQKK0RFQ0xB UkUKKyAgICBwbGFuX2pzb24ganNvbjsKKyAgICBub2RlIGpzb247CisgICAgZGlyZWN0X2J1ZiBp bnQ7CisgICAgbm9zY3JvbGxfYnVmIGludDsKKyAgICBzY3JvbGxfYnVmIGludDsKK0JFR0lOCisg ICAgLS0gRGlyZWN0IHNjYW46IGdldCBsZWFmIFNlcSBTY2FuIG5vZGUgYnVmZmVycyBhcyBiYXNl bGluZQorICAgIEVYRUNVVEUgJ0VYUExBSU4gKEFOQUxZWkUsIEJVRkZFUlMsIENPU1RTIE9GRiwg Rk9STUFUIEpTT04pCisgICAgICAgIFNFTEVDVCAqIEZST00gY3Vyc29yX2J1Zl90ZXN0JyBJTlRP IHBsYW5fanNvbjsKKyAgICBub2RlIDo9IHBsYW5fanNvbi0+MC0+J1BsYW4nOworICAgIFdISUxF IG5vZGUtPidQbGFucycgSVMgTk9UIE5VTEwgTE9PUAorICAgICAgICBub2RlIDo9IG5vZGUtPidQ bGFucyctPjA7CisgICAgRU5EIExPT1A7CisgICAgZGlyZWN0X2J1ZiA6PQorICAgICAgICBDT0FM RVNDRSgobm9kZS0+PidMb2NhbCBIaXQgQmxvY2tzJyk6OmludCwgMCkgKworICAgICAgICBDT0FM RVNDRSgobm9kZS0+PidMb2NhbCBSZWFkIEJsb2NrcycpOjppbnQsIDApOworCisgICAgLS0gTm9u LXNjcm9sbGFibGUgY3Vyc29yIHBhdGg6IEV4ZWNTaHV0ZG93bk5vZGUgcnVucyBhZnRlciBlYWNo IEV4ZWN1dG9yUnVuCisgICAgRVhFQ1VURSAnRVhQTEFJTiAoQU5BTFlaRSwgQlVGRkVSUywgQ09T VFMgT0ZGLCBGT1JNQVQgSlNPTikKKyAgICAgICAgU0VMRUNUIGN1cnNvcl9ub3Njcm9sbF9zY2Fu KCknIElOVE8gcGxhbl9qc29uOworICAgIG5vZGUgOj0gcGxhbl9qc29uLT4wLT4nUGxhbic7Cisg ICAgbm9zY3JvbGxfYnVmIDo9CisgICAgICAgIENPQUxFU0NFKChub2RlLT4+J0xvY2FsIEhpdCBC bG9ja3MnKTo6aW50LCAwKSArCisgICAgICAgIENPQUxFU0NFKChub2RlLT4+J0xvY2FsIFJlYWQg QmxvY2tzJyk6OmludCwgMCk7CisKKyAgICAtLSBTY3JvbGxhYmxlIGN1cnNvciBwYXRoOiBFeGVj U2h1dGRvd25Ob2RlIGlzIHNraXBwZWQKKyAgICBFWEVDVVRFICdFWFBMQUlOIChBTkFMWVpFLCBC VUZGRVJTLCBDT1NUUyBPRkYsIEZPUk1BVCBKU09OKQorICAgICAgICBTRUxFQ1QgY3Vyc29yX3Nj cm9sbF9zY2FuKCknIElOVE8gcGxhbl9qc29uOworICAgIG5vZGUgOj0gcGxhbl9qc29uLT4wLT4n UGxhbic7CisgICAgc2Nyb2xsX2J1ZiA6PQorICAgICAgICBDT0FMRVNDRSgobm9kZS0+PidMb2Nh bCBIaXQgQmxvY2tzJyk6OmludCwgMCkgKworICAgICAgICBDT0FMRVNDRSgobm9kZS0+PidMb2Nh bCBSZWFkIEJsb2NrcycpOjppbnQsIDApOworCisgICAgLS0gQm90aCBjdXJzb3IgcGF0aHMgc2hv dWxkIHJlcG9ydCBidWZmZXIgY291bnRzIGFib3V0IGFzIGhpZ2ggYXMKKyAgICAtLSB0aGUgZGly ZWN0IHNjYW4gKHNhbWUgZGF0YSBwbHVzIG1pbm9yIGNhdGFsb2cgb3ZlcmhlYWQpLCBhbmQgbm90 CisgICAgLS0gZG91YmxlLWNvdW50ZWQgKDwgMnggdGhlIGRpcmVjdCBzY2FuKQorICAgIFJFVFVS TiBRVUVSWSBTRUxFQ1QKKyAgICAgICAgKG5vc2Nyb2xsX2J1ZiA+PSBkaXJlY3RfYnVmICogMC41 IEFORCBub3Njcm9sbF9idWYgPCBkaXJlY3RfYnVmICogMiksCisgICAgICAgIChzY3JvbGxfYnVm ID49IGRpcmVjdF9idWYgKiAwLjUgQU5EIHNjcm9sbF9idWYgPCBkaXJlY3RfYnVmICogMik7CitF TkQ7CiskJCBMQU5HVUFHRSBwbHBnc3FsOworCitTRUxFQ1QgKiBGUk9NIGNoZWNrX2N1cnNvcl9l eHBsYWluX2J1ZmZlcnMoKTsKKworRFJPUCBGVU5DVElPTiBjaGVja19jdXJzb3JfZXhwbGFpbl9i dWZmZXJzOworRFJPUCBGVU5DVElPTiBjdXJzb3Jfbm9zY3JvbGxfc2NhbjsKK0RST1AgRlVOQ1RJ T04gY3Vyc29yX3Njcm9sbF9zY2FuOworRFJPUCBUQUJMRSBjdXJzb3JfYnVmX3Rlc3Q7CisKKy0t IFRlc3QgdHJpZ2dlciBpbnN0cnVtZW50YXRpb24uCitDUkVBVEUgVEVNUCBUQUJMRSB0cmlnX3Rl c3RfdGFiIChhIGludCk7CitDUkVBVEUgVEVNUCBUQUJMRSB0cmlnX3dvcmtfdGFiIChhIGludCk7 CitJTlNFUlQgSU5UTyB0cmlnX3dvcmtfdGFiIFZBTFVFUyAoMSk7CisKK0NSRUFURSBGVU5DVElP TiB0cmlnX3Rlc3RfZnVuYygpIFJFVFVSTlMgdHJpZ2dlciBBUyAkJAorQkVHSU4KKyAgICBQRVJG T1JNICogRlJPTSB0cmlnX3dvcmtfdGFiOworICAgIFJFVFVSTiBORVc7CitFTkQ7CiskJCBMQU5H VUFHRSBwbHBnc3FsOworCitDUkVBVEUgVFJJR0dFUiB0cmlnX3Rlc3RfdHJpZworICAgIEJFRk9S RSBJTlNFUlQgT04gdHJpZ190ZXN0X3RhYgorICAgIEZPUiBFQUNIIFJPVyBFWEVDVVRFIEZVTkNU SU9OIHRyaWdfdGVzdF9mdW5jKCk7CisKK0NSRUFURSBGVU5DVElPTiBjaGVja190cmlnZ2VyX2V4 cGxhaW5fYnVmZmVycygpIFJFVFVSTlMgYm9vbGVhbiBBUyAkJAorREVDTEFSRQorICAgIHBsYW5f anNvbiBqc29uOworICAgIHRyaWcganNvbjsKK0JFR0lOCisgICAgRVhFQ1VURSAnRVhQTEFJTiAo QU5BTFlaRSwgQlVGRkVSUywgQ09TVFMgT0ZGLCBGT1JNQVQgSlNPTikKKyAgICAgICAgSU5TRVJU IElOVE8gdHJpZ190ZXN0X3RhYiBWQUxVRVMgKDEpJyBJTlRPIHBsYW5fanNvbjsKKyAgICB0cmln IDo9IHBsYW5fanNvbi0+MC0+J1RyaWdnZXJzJy0+MDsKKyAgICBSRVRVUk4gQ09BTEVTQ0UoKHRy aWctPj4nQ2FsbHMnKTo6aW50LCAwKSA+IDA7CitFTkQ7CiskJCBMQU5HVUFHRSBwbHBnc3FsOwor CitTRUxFQ1QgY2hlY2tfdHJpZ2dlcl9leHBsYWluX2J1ZmZlcnMoKSBBUyB0cmlnZ2VyX2J1ZmZl cnNfdmlzaWJsZTsKKworRFJPUCBGVU5DVElPTiBjaGVja190cmlnZ2VyX2V4cGxhaW5fYnVmZmVy czsKK0RST1AgVFJJR0dFUiB0cmlnX3Rlc3RfdHJpZyBPTiB0cmlnX3Rlc3RfdGFiOworRFJPUCBG VU5DVElPTiB0cmlnX3Rlc3RfZnVuYzsKK0RST1AgVEFCTEUgdHJpZ190ZXN0X3RhYjsKK0RST1Ag VEFCTEUgdHJpZ193b3JrX3RhYjsKLS0gCjIuNDcuMQoK --0000000000006d0cb0064eb5be7d Content-Type: application/octet-stream; name="v13-0006-Add-regression-test-coverage-for-EXPLAIN-of-Para.patch" Content-Disposition: attachment; filename="v13-0006-Add-regression-test-coverage-for-EXPLAIN-of-Para.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mnlqag6q5 RnJvbSBlYjNiZTgxZGYxM2IzYjdkZWQ4NGRiMDAxOWJiNjgxMDVjZTMxNjNhIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBMdWthcyBGaXR0bCA8bHVrYXNAZml0dGwuY29tPgpEYXRlOiBT dW4sIDUgQXByIDIwMjYgMDM6NDg6MjIgLTA3MDAKU3ViamVjdDogW1BBVENIIHYxMyAwNi8xMl0g QWRkIHJlZ3Jlc3Npb24gdGVzdCBjb3ZlcmFnZSBmb3IgRVhQTEFJTiBvZgogUGFyYWxsZWwgSW5k ZXggT25seSBTY2FucwoKVGhlIGZ1bmN0aW9ucyBkZWFsaW5nIHdpdGggY29weWluZyBiYWNrIHBh cmFsbGVsIHdvcmtlciBpbnN0cnVtZW50YXRpb24Kc3VjaCBhcyBFeGVjSW5kZXhPbmx5U2NhblJl dHJpZXZlSW5zdHJ1bWVudGF0aW9uIHdlcmUgbm90IGV4ZXJjaXNlZAphdCBhbGwgaW4gdGhlIHJl Z3Jlc3Npb24gdGVzdHMsIGxlYWRpbmcgdG8gYSBnYXAgaW4gY292ZXJhZ2UuIEFkZCBhCnF1ZXJ5 IHRoYXQgdmVyaWZpZXMgd2UgY29ycmVjdGx5IGNvcHkgYmFjayAiSW5kZXggU2VhcmNoZXMiIGZv cgpFWFBMQUlOIEFOQUxZWkUgb2YgYSBQYXJhbGxlbCBJbmRleCBPbmx5IFNjYW4uCgpSZXBvcnRl ZC1ieTogQW5kcmVzIEZyZXVuZCA8YW5kcmVzQGFuYXJhemVsLmRlPgpBdXRob3I6IEx1a2FzIEZp dHRsIDxsdWthc0BmaXR0bC5jb20+CkRpc2N1c3Npb246Ci0tLQogc3JjL3Rlc3QvcmVncmVzcy9l eHBlY3RlZC9leHBsYWluLm91dCB8IDM0ICsrKysrKysrKysrKysrKysrKysrKysrKysrKwogc3Jj L3Rlc3QvcmVncmVzcy9zcWwvZXhwbGFpbi5zcWwgICAgICB8IDMyICsrKysrKysrKysrKysrKysr KysrKysrKysKIDIgZmlsZXMgY2hhbmdlZCwgNjYgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBh L3NyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQvZXhwbGFpbi5vdXQgYi9zcmMvdGVzdC9yZWdyZXNz L2V4cGVjdGVkL2V4cGxhaW4ub3V0CmluZGV4IDU4YzVhNTEyZDc0Li5iMzA3ZTgxMGNhNSAxMDA2 NDQKLS0tIGEvc3JjL3Rlc3QvcmVncmVzcy9leHBlY3RlZC9leHBsYWluLm91dAorKysgYi9zcmMv dGVzdC9yZWdyZXNzL2V4cGVjdGVkL2V4cGxhaW4ub3V0CkBAIC04NTUsMyArODU1LDM3IEBAIFNF TEVDVCBjaGVja19wYXJhbGxlbF9iaXRtYXBfaGVhcF9zY2FuKCkgQVMgcGFyYWxsZWxfYml0bWFw X2luc3RydW1lbnRhdGlvbjsKICgxIHJvdykKIAogRFJPUCBGVU5DVElPTiBjaGVja19wYXJhbGxl bF9iaXRtYXBfaGVhcF9zY2FuOworLS0gVGVzdCBwYXJhbGxlbCBpbmRleC1vbmx5IHNjYW4gcmVw b3J0cyBwZXItd29ya2VyIGluZGV4IHNlYXJjaCBzdGF0cy4KK0NSRUFURSBGVU5DVElPTiBjaGVj a19wYXJhbGxlbF9pbmRleG9ubHlfc2NhbigpIFJFVFVSTlMgYm9vbGVhbiBBUyAkJAorREVDTEFS RQorICAgIHBsYW5fanNvbiBqc29uOworICAgIG5vZGUganNvbjsKK0JFR0lOCisgICAgU0VUIExP Q0FMIGVuYWJsZV9zZXFzY2FuID0gb2ZmOworICAgIFNFVCBMT0NBTCBlbmFibGVfYml0bWFwc2Nh biA9IG9mZjsKKyAgICBTRVQgTE9DQUwgcGFyYWxsZWxfc2V0dXBfY29zdCA9IDA7CisgICAgU0VU IExPQ0FMIHBhcmFsbGVsX3R1cGxlX2Nvc3QgPSAwOworICAgIFNFVCBMT0NBTCBtaW5fcGFyYWxs ZWxfaW5kZXhfc2Nhbl9zaXplID0gMDsKKyAgICBTRVQgTE9DQUwgbWluX3BhcmFsbGVsX3RhYmxl X3NjYW5fc2l6ZSA9IDA7CisgICAgU0VUIExPQ0FMIG1heF9wYXJhbGxlbF93b3JrZXJzX3Blcl9n YXRoZXIgPSAyOworICAgIFNFVCBMT0NBTCBwYXJhbGxlbF9sZWFkZXJfcGFydGljaXBhdGlvbiA9 IG9mZjsKKworICAgIEVYRUNVVEUgJ0VYUExBSU4gKEFOQUxZWkUsIEJVRkZFUlMsIENPU1RTIE9G RiwgRk9STUFUIEpTT04pCisgICAgICAgIFNFTEVDVCBjb3VudCgqKSBGUk9NIHRlbmsxIFdIRVJF IHRob3VzYW5kID4gOTUnIElOVE8gcGxhbl9qc29uOworCisgICAgLS0gRHJpbGwgZG93biB0byB0 aGUgSW5kZXggT25seSBTY2FuIG5vZGUKKyAgICBub2RlIDo9IHBsYW5fanNvbi0+MC0+J1BsYW4n OworICAgIFdISUxFIG5vZGUtPidQbGFucycgSVMgTk9UIE5VTEwgQU5EIG5vZGUtPj4nTm9kZSBU eXBlJyAhPSAnSW5kZXggT25seSBTY2FuJyBMT09QCisgICAgICAgIG5vZGUgOj0gbm9kZS0+J1Bs YW5zJy0+MDsKKyAgICBFTkQgTE9PUDsKKworICAgIFJFVFVSTiBDT0FMRVNDRSgobm9kZS0+PidJ bmRleCBTZWFyY2hlcycpOjppbnQsIDApID4gMDsKK0VORDsKKyQkIExBTkdVQUdFIHBscGdzcWw7 CitTRUxFQ1QgY2hlY2tfcGFyYWxsZWxfaW5kZXhvbmx5X3NjYW4oKSBBUyBwYXJhbGxlbF9pbmRl eG9ubHlfaW5zdHJ1bWVudGF0aW9uOworIHBhcmFsbGVsX2luZGV4b25seV9pbnN0cnVtZW50YXRp b24gCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyB0CisoMSByb3cpCisK K0RST1AgRlVOQ1RJT04gY2hlY2tfcGFyYWxsZWxfaW5kZXhvbmx5X3NjYW47CmRpZmYgLS1naXQg YS9zcmMvdGVzdC9yZWdyZXNzL3NxbC9leHBsYWluLnNxbCBiL3NyYy90ZXN0L3JlZ3Jlc3Mvc3Fs L2V4cGxhaW4uc3FsCmluZGV4IGJhYzk3NTIyMDUzLi4zYTEzZmE2Y2E2OSAxMDA2NDQKLS0tIGEv c3JjL3Rlc3QvcmVncmVzcy9zcWwvZXhwbGFpbi5zcWwKKysrIGIvc3JjL3Rlc3QvcmVncmVzcy9z cWwvZXhwbGFpbi5zcWwKQEAgLTIxOSwzICsyMTksMzUgQEAgJCQgTEFOR1VBR0UgcGxwZ3NxbDsK IFNFTEVDVCBjaGVja19wYXJhbGxlbF9iaXRtYXBfaGVhcF9zY2FuKCkgQVMgcGFyYWxsZWxfYml0 bWFwX2luc3RydW1lbnRhdGlvbjsKIAogRFJPUCBGVU5DVElPTiBjaGVja19wYXJhbGxlbF9iaXRt YXBfaGVhcF9zY2FuOworCistLSBUZXN0IHBhcmFsbGVsIGluZGV4LW9ubHkgc2NhbiByZXBvcnRz IHBlci13b3JrZXIgaW5kZXggc2VhcmNoIHN0YXRzLgorQ1JFQVRFIEZVTkNUSU9OIGNoZWNrX3Bh cmFsbGVsX2luZGV4b25seV9zY2FuKCkgUkVUVVJOUyBib29sZWFuIEFTICQkCitERUNMQVJFCisg ICAgcGxhbl9qc29uIGpzb247CisgICAgbm9kZSBqc29uOworQkVHSU4KKyAgICBTRVQgTE9DQUwg ZW5hYmxlX3NlcXNjYW4gPSBvZmY7CisgICAgU0VUIExPQ0FMIGVuYWJsZV9iaXRtYXBzY2FuID0g b2ZmOworICAgIFNFVCBMT0NBTCBwYXJhbGxlbF9zZXR1cF9jb3N0ID0gMDsKKyAgICBTRVQgTE9D QUwgcGFyYWxsZWxfdHVwbGVfY29zdCA9IDA7CisgICAgU0VUIExPQ0FMIG1pbl9wYXJhbGxlbF9p bmRleF9zY2FuX3NpemUgPSAwOworICAgIFNFVCBMT0NBTCBtaW5fcGFyYWxsZWxfdGFibGVfc2Nh bl9zaXplID0gMDsKKyAgICBTRVQgTE9DQUwgbWF4X3BhcmFsbGVsX3dvcmtlcnNfcGVyX2dhdGhl ciA9IDI7CisgICAgU0VUIExPQ0FMIHBhcmFsbGVsX2xlYWRlcl9wYXJ0aWNpcGF0aW9uID0gb2Zm OworCisgICAgRVhFQ1VURSAnRVhQTEFJTiAoQU5BTFlaRSwgQlVGRkVSUywgQ09TVFMgT0ZGLCBG T1JNQVQgSlNPTikKKyAgICAgICAgU0VMRUNUIGNvdW50KCopIEZST00gdGVuazEgV0hFUkUgdGhv dXNhbmQgPiA5NScgSU5UTyBwbGFuX2pzb247CisKKyAgICAtLSBEcmlsbCBkb3duIHRvIHRoZSBJ bmRleCBPbmx5IFNjYW4gbm9kZQorICAgIG5vZGUgOj0gcGxhbl9qc29uLT4wLT4nUGxhbic7Cisg ICAgV0hJTEUgbm9kZS0+J1BsYW5zJyBJUyBOT1QgTlVMTCBBTkQgbm9kZS0+PidOb2RlIFR5cGUn ICE9ICdJbmRleCBPbmx5IFNjYW4nIExPT1AKKyAgICAgICAgbm9kZSA6PSBub2RlLT4nUGxhbnMn LT4wOworICAgIEVORCBMT09QOworCisgICAgUkVUVVJOIENPQUxFU0NFKChub2RlLT4+J0luZGV4 IFNlYXJjaGVzJyk6OmludCwgMCkgPiAwOworRU5EOworJCQgTEFOR1VBR0UgcGxwZ3NxbDsKKwor U0VMRUNUIGNoZWNrX3BhcmFsbGVsX2luZGV4b25seV9zY2FuKCkgQVMgcGFyYWxsZWxfaW5kZXhv bmx5X2luc3RydW1lbnRhdGlvbjsKKworRFJPUCBGVU5DVElPTiBjaGVja19wYXJhbGxlbF9pbmRl eG9ubHlfc2NhbjsKLS0gCjIuNDcuMQoK --0000000000006d0cb0064eb5be7d Content-Type: application/octet-stream; name="v13-0009-instrumentation-Use-Instrumentation-struct-for-p.patch" Content-Disposition: attachment; filename="v13-0009-instrumentation-Use-Instrumentation-struct-for-p.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mnlqag7k8 RnJvbSA5MzY1YmJkMDZlNDJmYzQ1MmQ0MDBiODcwZTIzMzRjY2MzMmFkZThlIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBMdWthcyBGaXR0bCA8bHVrYXNAZml0dGwuY29tPgpEYXRlOiBT dW4sIDE1IE1hciAyMDI2IDIxOjQ0OjU4IC0wNzAwClN1YmplY3Q6IFtQQVRDSCB2MTMgMDkvMTJd IGluc3RydW1lbnRhdGlvbjogVXNlIEluc3RydW1lbnRhdGlvbiBzdHJ1Y3QgZm9yCiBwYXJhbGxl bCB3b3JrZXJzCgpUaGlzIHNpbXBsaWZpZXMgdGhlIERTTSBhbGxvY2F0aW9ucyBhIGJpdCBzaW5j ZSB3ZSBkb24ndCBuZWVkIHRvCnNlcGFyYXRlbHkgYWxsb2NhdGUgV0FMIGFuZCBidWZmZXIgdXNh Z2UsIGFuZCBhbGxvd3MgdGhlIGVhc2llciBmdXR1cmUKYWRkaXRpb24gb2YgYSB0aGlyZCBzdGFj ay1iYXNlZCBzdHJ1Y3QgYmVpbmcgZGlzY3Vzc2VkLgoKQXV0aG9yOiBMdWthcyBGaXR0bCA8bHVr YXNAZml0dGwuY29tPgpSZXZpZXdlZC1ieToKRGlzY3Vzc2lvbjoKLS0tCiBzcmMvYmFja2VuZC9h Y2Nlc3MvYnJpbi9icmluLmMgICAgICAgIHwgNDMgKysrKysrLS0tLS0tLS0tLS0KIHNyYy9iYWNr ZW5kL2FjY2Vzcy9naW4vZ2luaW5zZXJ0LmMgICAgfCA0MyArKysrKystLS0tLS0tLS0tLQogc3Jj L2JhY2tlbmQvYWNjZXNzL25idHJlZS9uYnRzb3J0LmMgICB8IDQzICsrKysrKy0tLS0tLS0tLS0t CiBzcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jIHwgNTIgKysrKysrKystLS0t LS0tLS0tLS0tCiBzcmMvYmFja2VuZC9leGVjdXRvci9leGVjUGFyYWxsZWwuYyAgIHwgNjYgKysr KysrKysrKysrLS0tLS0tLS0tLS0tLS0tCiBzcmMvYmFja2VuZC9leGVjdXRvci9pbnN0cnVtZW50 LmMgICAgIHwgMTQgKysrLS0tCiBzcmMvaW5jbHVkZS9leGVjdXRvci9leGVjUGFyYWxsZWwuaCAg IHwgIDUgKy0KIHNyYy9pbmNsdWRlL2V4ZWN1dG9yL2luc3RydW1lbnQuaCAgICAgfCAgNCArLQog OCBmaWxlcyBjaGFuZ2VkLCA5OSBpbnNlcnRpb25zKCspLCAxNzEgZGVsZXRpb25zKC0pCgpkaWZm IC0tZ2l0IGEvc3JjL2JhY2tlbmQvYWNjZXNzL2JyaW4vYnJpbi5jIGIvc3JjL2JhY2tlbmQvYWNj ZXNzL2JyaW4vYnJpbi5jCmluZGV4IDNhNTE3NmM3NmM3Li45ZTU0NWI0ZWYwZSAxMDA2NDQKLS0t IGEvc3JjL2JhY2tlbmQvYWNjZXNzL2JyaW4vYnJpbi5jCisrKyBiL3NyYy9iYWNrZW5kL2FjY2Vz cy9icmluL2JyaW4uYwpAQCAtNTEsOCArNTEsNyBAQAogI2RlZmluZSBQQVJBTExFTF9LRVlfQlJJ Tl9TSEFSRUQJCVVJTlQ2NENPTlNUKDB4QjAwMDAwMDAwMDAwMDAwMSkKICNkZWZpbmUgUEFSQUxM RUxfS0VZX1RVUExFU09SVAkJCVVJTlQ2NENPTlNUKDB4QjAwMDAwMDAwMDAwMDAwMikKICNkZWZp bmUgUEFSQUxMRUxfS0VZX1FVRVJZX1RFWFQJCQlVSU5UNjRDT05TVCgweEIwMDAwMDAwMDAwMDAw MDMpCi0jZGVmaW5lIFBBUkFMTEVMX0tFWV9XQUxfVVNBR0UJCQlVSU5UNjRDT05TVCgweEIwMDAw MDAwMDAwMDAwMDQpCi0jZGVmaW5lIFBBUkFMTEVMX0tFWV9CVUZGRVJfVVNBR0UJCVVJTlQ2NENP TlNUKDB4QjAwMDAwMDAwMDAwMDAwNSkKKyNkZWZpbmUgUEFSQUxMRUxfS0VZX0lOU1RSVU1FTlRB VElPTglVSU5UNjRDT05TVCgweEIwMDAwMDAwMDAwMDAwMDQpCiAKIC8qCiAgKiBTdGF0dXMgZm9y IGluZGV4IGJ1aWxkcyBwZXJmb3JtZWQgaW4gcGFyYWxsZWwuICBUaGlzIGlzIGFsbG9jYXRlZCBp biBhCkBAIC0xNDgsOCArMTQ3LDcgQEAgdHlwZWRlZiBzdHJ1Y3QgQnJpbkxlYWRlcgogCUJyaW5T aGFyZWQgKmJyaW5zaGFyZWQ7CiAJU2hhcmVkc29ydCAqc2hhcmVkc29ydDsKIAlTbmFwc2hvdAlz bmFwc2hvdDsKLQlXYWxVc2FnZSAgICp3YWx1c2FnZTsKLQlCdWZmZXJVc2FnZSAqYnVmZmVydXNh Z2U7CisJSW5zdHJ1bWVudGF0aW9uICppbnN0cjsKIH0gQnJpbkxlYWRlcjsKIAogLyoKQEAgLTIz ODcsOCArMjM4NSw3IEBAIF9icmluX2JlZ2luX3BhcmFsbGVsKEJyaW5CdWlsZFN0YXRlICpidWls ZHN0YXRlLCBSZWxhdGlvbiBoZWFwLCBSZWxhdGlvbiBpbmRleCwKIAlCcmluU2hhcmVkICpicmlu c2hhcmVkOwogCVNoYXJlZHNvcnQgKnNoYXJlZHNvcnQ7CiAJQnJpbkxlYWRlciAqYnJpbmxlYWRl ciA9IHBhbGxvYzBfb2JqZWN0KEJyaW5MZWFkZXIpOwotCVdhbFVzYWdlICAgKndhbHVzYWdlOwot CUJ1ZmZlclVzYWdlICpidWZmZXJ1c2FnZTsKKwlJbnN0cnVtZW50YXRpb24gKmluc3RyOwogCWJv b2wJCWxlYWRlcnBhcnRpY2lwYXRlcyA9IHRydWU7CiAJaW50CQkJcXVlcnlsZW47CiAKQEAgLTI0 MzAsMTggKzI0MjcsMTQgQEAgX2JyaW5fYmVnaW5fcGFyYWxsZWwoQnJpbkJ1aWxkU3RhdGUgKmJ1 aWxkc3RhdGUsIFJlbGF0aW9uIGhlYXAsIFJlbGF0aW9uIGluZGV4LAogCXNobV90b2NfZXN0aW1h dGVfa2V5cygmcGN4dC0+ZXN0aW1hdG9yLCAyKTsKIAogCS8qCi0JICogRXN0aW1hdGUgc3BhY2Ug Zm9yIFdhbFVzYWdlIGFuZCBCdWZmZXJVc2FnZSAtLSBQQVJBTExFTF9LRVlfV0FMX1VTQUdFCi0J ICogYW5kIFBBUkFMTEVMX0tFWV9CVUZGRVJfVVNBR0UuCisJICogRXN0aW1hdGUgc3BhY2UgZm9y IEluc3RydW1lbnRhdGlvbiAtLSBQQVJBTExFTF9LRVlfSU5TVFJVTUVOVEFUSU9OLgogCSAqCiAJ ICogSWYgdGhlcmUgYXJlIG5vIGV4dGVuc2lvbnMgbG9hZGVkIHRoYXQgY2FyZSwgd2UgY291bGQg c2tpcCB0aGlzLiAgV2UKIAkgKiBoYXZlIG5vIHdheSBvZiBrbm93aW5nIHdoZXRoZXIgYW55b25l J3MgbG9va2luZyBhdCBpbnN0cnVtZW50YXRpb24sIHNvCiAJICogZG8gaXQgdW5jb25kaXRpb25h bGx5LgogCSAqLwogCXNobV90b2NfZXN0aW1hdGVfY2h1bmsoJnBjeHQtPmVzdGltYXRvciwKLQkJ CQkJCSAgIG11bF9zaXplKHNpemVvZihXYWxVc2FnZSksIHBjeHQtPm53b3JrZXJzKSk7Ci0Jc2ht X3RvY19lc3RpbWF0ZV9rZXlzKCZwY3h0LT5lc3RpbWF0b3IsIDEpOwotCXNobV90b2NfZXN0aW1h dGVfY2h1bmsoJnBjeHQtPmVzdGltYXRvciwKLQkJCQkJCSAgIG11bF9zaXplKHNpemVvZihCdWZm ZXJVc2FnZSksIHBjeHQtPm53b3JrZXJzKSk7CisJCQkJCQkgICBtdWxfc2l6ZShzaXplb2YoSW5z dHJ1bWVudGF0aW9uKSwgcGN4dC0+bndvcmtlcnMpKTsKIAlzaG1fdG9jX2VzdGltYXRlX2tleXMo JnBjeHQtPmVzdGltYXRvciwgMSk7CiAKIAkvKiBGaW5hbGx5LCBlc3RpbWF0ZSBQQVJBTExFTF9L RVlfUVVFUllfVEVYVCBzcGFjZSAqLwpAQCAtMjUxNCwxNSArMjUwNywxMiBAQCBfYnJpbl9iZWdp bl9wYXJhbGxlbChCcmluQnVpbGRTdGF0ZSAqYnVpbGRzdGF0ZSwgUmVsYXRpb24gaGVhcCwgUmVs YXRpb24gaW5kZXgsCiAJfQogCiAJLyoKLQkgKiBBbGxvY2F0ZSBzcGFjZSBmb3IgZWFjaCB3b3Jr ZXIncyBXYWxVc2FnZSBhbmQgQnVmZmVyVXNhZ2U7IG5vIG5lZWQgdG8KKwkgKiBBbGxvY2F0ZSBz cGFjZSBmb3IgZWFjaCB3b3JrZXIncyBJbnN0cnVtZW50YXRpb247IG5vIG5lZWQgdG8KIAkgKiBp bml0aWFsaXplLgogCSAqLwotCXdhbHVzYWdlID0gc2htX3RvY19hbGxvY2F0ZShwY3h0LT50b2Ms Ci0JCQkJCQkJCW11bF9zaXplKHNpemVvZihXYWxVc2FnZSksIHBjeHQtPm53b3JrZXJzKSk7Ci0J c2htX3RvY19pbnNlcnQocGN4dC0+dG9jLCBQQVJBTExFTF9LRVlfV0FMX1VTQUdFLCB3YWx1c2Fn ZSk7Ci0JYnVmZmVydXNhZ2UgPSBzaG1fdG9jX2FsbG9jYXRlKHBjeHQtPnRvYywKLQkJCQkJCQkJ ICAgbXVsX3NpemUoc2l6ZW9mKEJ1ZmZlclVzYWdlKSwgcGN4dC0+bndvcmtlcnMpKTsKLQlzaG1f dG9jX2luc2VydChwY3h0LT50b2MsIFBBUkFMTEVMX0tFWV9CVUZGRVJfVVNBR0UsIGJ1ZmZlcnVz YWdlKTsKKwlpbnN0ciA9IHNobV90b2NfYWxsb2NhdGUocGN4dC0+dG9jLAorCQkJCQkJCSBtdWxf c2l6ZShzaXplb2YoSW5zdHJ1bWVudGF0aW9uKSwgcGN4dC0+bndvcmtlcnMpKTsKKwlzaG1fdG9j X2luc2VydChwY3h0LT50b2MsIFBBUkFMTEVMX0tFWV9JTlNUUlVNRU5UQVRJT04sIGluc3RyKTsK IAogCS8qIExhdW5jaCB3b3JrZXJzLCBzYXZpbmcgc3RhdHVzIGZvciBsZWFkZXIvY2FsbGVyICov CiAJTGF1bmNoUGFyYWxsZWxXb3JrZXJzKHBjeHQpOwpAQCAtMjUzMyw4ICsyNTIzLDcgQEAgX2Jy aW5fYmVnaW5fcGFyYWxsZWwoQnJpbkJ1aWxkU3RhdGUgKmJ1aWxkc3RhdGUsIFJlbGF0aW9uIGhl YXAsIFJlbGF0aW9uIGluZGV4LAogCWJyaW5sZWFkZXItPmJyaW5zaGFyZWQgPSBicmluc2hhcmVk OwogCWJyaW5sZWFkZXItPnNoYXJlZHNvcnQgPSBzaGFyZWRzb3J0OwogCWJyaW5sZWFkZXItPnNu YXBzaG90ID0gc25hcHNob3Q7Ci0JYnJpbmxlYWRlci0+d2FsdXNhZ2UgPSB3YWx1c2FnZTsKLQli cmlubGVhZGVyLT5idWZmZXJ1c2FnZSA9IGJ1ZmZlcnVzYWdlOworCWJyaW5sZWFkZXItPmluc3Ry ID0gaW5zdHI7CiAKIAkvKiBJZiBubyB3b3JrZXJzIHdlcmUgc3VjY2Vzc2Z1bGx5IGxhdW5jaGVk LCBiYWNrIG91dCAoZG8gc2VyaWFsIGJ1aWxkKSAqLwogCWlmIChwY3h0LT5ud29ya2Vyc19sYXVu Y2hlZCA9PSAwKQpAQCAtMjU3Myw3ICsyNTYyLDcgQEAgX2JyaW5fZW5kX3BhcmFsbGVsKEJyaW5M ZWFkZXIgKmJyaW5sZWFkZXIsIEJyaW5CdWlsZFN0YXRlICpzdGF0ZSkKIAkgKiBvciB3ZSBtaWdo dCBnZXQgaW5jb21wbGV0ZSBkYXRhLikKIAkgKi8KIAlmb3IgKGkgPSAwOyBpIDwgYnJpbmxlYWRl ci0+cGN4dC0+bndvcmtlcnNfbGF1bmNoZWQ7IGkrKykKLQkJSW5zdHJBY2N1bVBhcmFsbGVsUXVl cnkoJmJyaW5sZWFkZXItPmJ1ZmZlcnVzYWdlW2ldLCAmYnJpbmxlYWRlci0+d2FsdXNhZ2VbaV0p OworCQlJbnN0ckFjY3VtUGFyYWxsZWxRdWVyeSgmYnJpbmxlYWRlci0+aW5zdHJbaV0pOwogCiAJ LyogRnJlZSBsYXN0IHJlZmVyZW5jZSB0byBNVkNDIHNuYXBzaG90LCBpZiBvbmUgd2FzIHVzZWQg Ki8KIAlpZiAoSXNNVkNDU25hcHNob3QoYnJpbmxlYWRlci0+c25hcHNob3QpKQpAQCAtMjg4OCw4 ICsyODc3LDcgQEAgX2JyaW5fcGFyYWxsZWxfYnVpbGRfbWFpbihkc21fc2VnbWVudCAqc2VnLCBz aG1fdG9jICp0b2MpCiAJTE9DS01PREUJaGVhcExvY2ttb2RlOwogCUxPQ0tNT0RFCWluZGV4TG9j a21vZGU7CiAJUXVlcnlJbnN0cnVtZW50YXRpb24gKmluc3RyOwotCVdhbFVzYWdlICAgKndhbHVz YWdlOwotCUJ1ZmZlclVzYWdlICpidWZmZXJ1c2FnZTsKKwlJbnN0cnVtZW50YXRpb24gKndvcmtl cl9pbnN0cjsKIAlpbnQJCQlzb3J0bWVtOwogCiAJLyoKQEAgLTI5NTAsMTEgKzI5MzgsOCBAQCBf YnJpbl9wYXJhbGxlbF9idWlsZF9tYWluKGRzbV9zZWdtZW50ICpzZWcsIHNobV90b2MgKnRvYykK IAkJCQkJCQkJICBoZWFwUmVsLCBpbmRleFJlbCwgc29ydG1lbSwgZmFsc2UpOwogCiAJLyogUmVw b3J0IFdBTC9idWZmZXIgdXNhZ2UgZHVyaW5nIHBhcmFsbGVsIGV4ZWN1dGlvbiAqLwotCWJ1ZmZl cnVzYWdlID0gc2htX3RvY19sb29rdXAodG9jLCBQQVJBTExFTF9LRVlfQlVGRkVSX1VTQUdFLCBm YWxzZSk7Ci0Jd2FsdXNhZ2UgPSBzaG1fdG9jX2xvb2t1cCh0b2MsIFBBUkFMTEVMX0tFWV9XQUxf VVNBR0UsIGZhbHNlKTsKLQlJbnN0ckVuZFBhcmFsbGVsUXVlcnkoaW5zdHIsCi0JCQkJCQkgICZi dWZmZXJ1c2FnZVtQYXJhbGxlbFdvcmtlck51bWJlcl0sCi0JCQkJCQkgICZ3YWx1c2FnZVtQYXJh bGxlbFdvcmtlck51bWJlcl0pOworCXdvcmtlcl9pbnN0ciA9IHNobV90b2NfbG9va3VwKHRvYywg UEFSQUxMRUxfS0VZX0lOU1RSVU1FTlRBVElPTiwgZmFsc2UpOworCUluc3RyRW5kUGFyYWxsZWxR dWVyeShpbnN0ciwgJndvcmtlcl9pbnN0cltQYXJhbGxlbFdvcmtlck51bWJlcl0pOwogCiAJaW5k ZXhfY2xvc2UoaW5kZXhSZWwsIGluZGV4TG9ja21vZGUpOwogCXRhYmxlX2Nsb3NlKGhlYXBSZWws IGhlYXBMb2NrbW9kZSk7CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9hY2Nlc3MvZ2luL2dpbmlu c2VydC5jIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2dpbi9naW5pbnNlcnQuYwppbmRleCAwZDgwZjcy YTBiMC4uZjNkZTYyY2U3ZjMgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9naW4vZ2lu aW5zZXJ0LmMKKysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2dpbi9naW5pbnNlcnQuYwpAQCAtNDUs OCArNDUsNyBAQAogI2RlZmluZSBQQVJBTExFTF9LRVlfR0lOX1NIQVJFRAkJCVVJTlQ2NENPTlNU KDB4QjAwMDAwMDAwMDAwMDAwMSkKICNkZWZpbmUgUEFSQUxMRUxfS0VZX1RVUExFU09SVAkJCVVJ TlQ2NENPTlNUKDB4QjAwMDAwMDAwMDAwMDAwMikKICNkZWZpbmUgUEFSQUxMRUxfS0VZX1FVRVJZ X1RFWFQJCQlVSU5UNjRDT05TVCgweEIwMDAwMDAwMDAwMDAwMDMpCi0jZGVmaW5lIFBBUkFMTEVM X0tFWV9XQUxfVVNBR0UJCQlVSU5UNjRDT05TVCgweEIwMDAwMDAwMDAwMDAwMDQpCi0jZGVmaW5l IFBBUkFMTEVMX0tFWV9CVUZGRVJfVVNBR0UJCVVJTlQ2NENPTlNUKDB4QjAwMDAwMDAwMDAwMDAw NSkKKyNkZWZpbmUgUEFSQUxMRUxfS0VZX0lOU1RSVU1FTlRBVElPTglVSU5UNjRDT05TVCgweEIw MDAwMDAwMDAwMDAwMDQpCiAKIC8qCiAgKiBTdGF0dXMgZm9yIGluZGV4IGJ1aWxkcyBwZXJmb3Jt ZWQgaW4gcGFyYWxsZWwuICBUaGlzIGlzIGFsbG9jYXRlZCBpbiBhCkBAIC0xMzgsOCArMTM3LDcg QEAgdHlwZWRlZiBzdHJ1Y3QgR2luTGVhZGVyCiAJR2luQnVpbGRTaGFyZWQgKmdpbnNoYXJlZDsK IAlTaGFyZWRzb3J0ICpzaGFyZWRzb3J0OwogCVNuYXBzaG90CXNuYXBzaG90OwotCVdhbFVzYWdl ICAgKndhbHVzYWdlOwotCUJ1ZmZlclVzYWdlICpidWZmZXJ1c2FnZTsKKwlJbnN0cnVtZW50YXRp b24gKmluc3RyOwogfSBHaW5MZWFkZXI7CiAKIHR5cGVkZWYgc3RydWN0CkBAIC05NDUsOCArOTQz LDcgQEAgX2dpbl9iZWdpbl9wYXJhbGxlbChHaW5CdWlsZFN0YXRlICpidWlsZHN0YXRlLCBSZWxh dGlvbiBoZWFwLCBSZWxhdGlvbiBpbmRleCwKIAlHaW5CdWlsZFNoYXJlZCAqZ2luc2hhcmVkOwog CVNoYXJlZHNvcnQgKnNoYXJlZHNvcnQ7CiAJR2luTGVhZGVyICAqZ2lubGVhZGVyID0gcGFsbG9j MF9vYmplY3QoR2luTGVhZGVyKTsKLQlXYWxVc2FnZSAgICp3YWx1c2FnZTsKLQlCdWZmZXJVc2Fn ZSAqYnVmZmVydXNhZ2U7CisJSW5zdHJ1bWVudGF0aW9uICppbnN0cjsKIAlib29sCQlsZWFkZXJw YXJ0aWNpcGF0ZXMgPSB0cnVlOwogCWludAkJCXF1ZXJ5bGVuOwogCkBAIC05ODcsMTggKzk4NCwx NCBAQCBfZ2luX2JlZ2luX3BhcmFsbGVsKEdpbkJ1aWxkU3RhdGUgKmJ1aWxkc3RhdGUsIFJlbGF0 aW9uIGhlYXAsIFJlbGF0aW9uIGluZGV4LAogCXNobV90b2NfZXN0aW1hdGVfa2V5cygmcGN4dC0+ ZXN0aW1hdG9yLCAyKTsKIAogCS8qCi0JICogRXN0aW1hdGUgc3BhY2UgZm9yIFdhbFVzYWdlIGFu ZCBCdWZmZXJVc2FnZSAtLSBQQVJBTExFTF9LRVlfV0FMX1VTQUdFCi0JICogYW5kIFBBUkFMTEVM X0tFWV9CVUZGRVJfVVNBR0UuCisJICogRXN0aW1hdGUgc3BhY2UgZm9yIEluc3RydW1lbnRhdGlv biAtLSBQQVJBTExFTF9LRVlfSU5TVFJVTUVOVEFUSU9OLgogCSAqCiAJICogSWYgdGhlcmUgYXJl IG5vIGV4dGVuc2lvbnMgbG9hZGVkIHRoYXQgY2FyZSwgd2UgY291bGQgc2tpcCB0aGlzLiAgV2UK IAkgKiBoYXZlIG5vIHdheSBvZiBrbm93aW5nIHdoZXRoZXIgYW55b25lJ3MgbG9va2luZyBhdCBp bnN0cnVtZW50YXRpb24sIHNvCiAJICogZG8gaXQgdW5jb25kaXRpb25hbGx5LgogCSAqLwogCXNo bV90b2NfZXN0aW1hdGVfY2h1bmsoJnBjeHQtPmVzdGltYXRvciwKLQkJCQkJCSAgIG11bF9zaXpl KHNpemVvZihXYWxVc2FnZSksIHBjeHQtPm53b3JrZXJzKSk7Ci0Jc2htX3RvY19lc3RpbWF0ZV9r ZXlzKCZwY3h0LT5lc3RpbWF0b3IsIDEpOwotCXNobV90b2NfZXN0aW1hdGVfY2h1bmsoJnBjeHQt PmVzdGltYXRvciwKLQkJCQkJCSAgIG11bF9zaXplKHNpemVvZihCdWZmZXJVc2FnZSksIHBjeHQt Pm53b3JrZXJzKSk7CisJCQkJCQkgICBtdWxfc2l6ZShzaXplb2YoSW5zdHJ1bWVudGF0aW9uKSwg cGN4dC0+bndvcmtlcnMpKTsKIAlzaG1fdG9jX2VzdGltYXRlX2tleXMoJnBjeHQtPmVzdGltYXRv ciwgMSk7CiAKIAkvKiBGaW5hbGx5LCBlc3RpbWF0ZSBQQVJBTExFTF9LRVlfUVVFUllfVEVYVCBz cGFjZSAqLwpAQCAtMTA2NiwxNSArMTA1OSwxMiBAQCBfZ2luX2JlZ2luX3BhcmFsbGVsKEdpbkJ1 aWxkU3RhdGUgKmJ1aWxkc3RhdGUsIFJlbGF0aW9uIGhlYXAsIFJlbGF0aW9uIGluZGV4LAogCX0K IAogCS8qCi0JICogQWxsb2NhdGUgc3BhY2UgZm9yIGVhY2ggd29ya2VyJ3MgV2FsVXNhZ2UgYW5k IEJ1ZmZlclVzYWdlOyBubyBuZWVkIHRvCisJICogQWxsb2NhdGUgc3BhY2UgZm9yIGVhY2ggd29y a2VyJ3MgSW5zdHJ1bWVudGF0aW9uOyBubyBuZWVkIHRvCiAJICogaW5pdGlhbGl6ZS4KIAkgKi8K LQl3YWx1c2FnZSA9IHNobV90b2NfYWxsb2NhdGUocGN4dC0+dG9jLAotCQkJCQkJCQltdWxfc2l6 ZShzaXplb2YoV2FsVXNhZ2UpLCBwY3h0LT5ud29ya2VycykpOwotCXNobV90b2NfaW5zZXJ0KHBj eHQtPnRvYywgUEFSQUxMRUxfS0VZX1dBTF9VU0FHRSwgd2FsdXNhZ2UpOwotCWJ1ZmZlcnVzYWdl ID0gc2htX3RvY19hbGxvY2F0ZShwY3h0LT50b2MsCi0JCQkJCQkJCSAgIG11bF9zaXplKHNpemVv ZihCdWZmZXJVc2FnZSksIHBjeHQtPm53b3JrZXJzKSk7Ci0Jc2htX3RvY19pbnNlcnQocGN4dC0+ dG9jLCBQQVJBTExFTF9LRVlfQlVGRkVSX1VTQUdFLCBidWZmZXJ1c2FnZSk7CisJaW5zdHIgPSBz aG1fdG9jX2FsbG9jYXRlKHBjeHQtPnRvYywKKwkJCQkJCQkgbXVsX3NpemUoc2l6ZW9mKEluc3Ry dW1lbnRhdGlvbiksIHBjeHQtPm53b3JrZXJzKSk7CisJc2htX3RvY19pbnNlcnQocGN4dC0+dG9j LCBQQVJBTExFTF9LRVlfSU5TVFJVTUVOVEFUSU9OLCBpbnN0cik7CiAKIAkvKiBMYXVuY2ggd29y a2Vycywgc2F2aW5nIHN0YXR1cyBmb3IgbGVhZGVyL2NhbGxlciAqLwogCUxhdW5jaFBhcmFsbGVs V29ya2VycyhwY3h0KTsKQEAgLTEwODUsOCArMTA3NSw3IEBAIF9naW5fYmVnaW5fcGFyYWxsZWwo R2luQnVpbGRTdGF0ZSAqYnVpbGRzdGF0ZSwgUmVsYXRpb24gaGVhcCwgUmVsYXRpb24gaW5kZXgs CiAJZ2lubGVhZGVyLT5naW5zaGFyZWQgPSBnaW5zaGFyZWQ7CiAJZ2lubGVhZGVyLT5zaGFyZWRz b3J0ID0gc2hhcmVkc29ydDsKIAlnaW5sZWFkZXItPnNuYXBzaG90ID0gc25hcHNob3Q7Ci0JZ2lu bGVhZGVyLT53YWx1c2FnZSA9IHdhbHVzYWdlOwotCWdpbmxlYWRlci0+YnVmZmVydXNhZ2UgPSBi dWZmZXJ1c2FnZTsKKwlnaW5sZWFkZXItPmluc3RyID0gaW5zdHI7CiAKIAkvKiBJZiBubyB3b3Jr ZXJzIHdlcmUgc3VjY2Vzc2Z1bGx5IGxhdW5jaGVkLCBiYWNrIG91dCAoZG8gc2VyaWFsIGJ1aWxk KSAqLwogCWlmIChwY3h0LT5ud29ya2Vyc19sYXVuY2hlZCA9PSAwKQpAQCAtMTEyNSw3ICsxMTE0 LDcgQEAgX2dpbl9lbmRfcGFyYWxsZWwoR2luTGVhZGVyICpnaW5sZWFkZXIsIEdpbkJ1aWxkU3Rh dGUgKnN0YXRlKQogCSAqIG9yIHdlIG1pZ2h0IGdldCBpbmNvbXBsZXRlIGRhdGEuKQogCSAqLwog CWZvciAoaSA9IDA7IGkgPCBnaW5sZWFkZXItPnBjeHQtPm53b3JrZXJzX2xhdW5jaGVkOyBpKysp Ci0JCUluc3RyQWNjdW1QYXJhbGxlbFF1ZXJ5KCZnaW5sZWFkZXItPmJ1ZmZlcnVzYWdlW2ldLCAm Z2lubGVhZGVyLT53YWx1c2FnZVtpXSk7CisJCUluc3RyQWNjdW1QYXJhbGxlbFF1ZXJ5KCZnaW5s ZWFkZXItPmluc3RyW2ldKTsKIAogCS8qIEZyZWUgbGFzdCByZWZlcmVuY2UgdG8gTVZDQyBzbmFw c2hvdCwgaWYgb25lIHdhcyB1c2VkICovCiAJaWYgKElzTVZDQ1NuYXBzaG90KGdpbmxlYWRlci0+ c25hcHNob3QpKQpAQCAtMjExOSw4ICsyMTA4LDcgQEAgX2dpbl9wYXJhbGxlbF9idWlsZF9tYWlu KGRzbV9zZWdtZW50ICpzZWcsIHNobV90b2MgKnRvYykKIAlMT0NLTU9ERQloZWFwTG9ja21vZGU7 CiAJTE9DS01PREUJaW5kZXhMb2NrbW9kZTsKIAlRdWVyeUluc3RydW1lbnRhdGlvbiAqaW5zdHI7 Ci0JV2FsVXNhZ2UgICAqd2FsdXNhZ2U7Ci0JQnVmZmVyVXNhZ2UgKmJ1ZmZlcnVzYWdlOworCUlu c3RydW1lbnRhdGlvbiAqd29ya2VyX2luc3RyOwogCWludAkJCXNvcnRtZW07CiAKIAkvKgpAQCAt MjIwMCwxMSArMjE4OCw4IEBAIF9naW5fcGFyYWxsZWxfYnVpbGRfbWFpbihkc21fc2VnbWVudCAq c2VnLCBzaG1fdG9jICp0b2MpCiAJCQkJCQkJCSBoZWFwUmVsLCBpbmRleFJlbCwgc29ydG1lbSwg ZmFsc2UpOwogCiAJLyogUmVwb3J0IFdBTC9idWZmZXIgdXNhZ2UgZHVyaW5nIHBhcmFsbGVsIGV4 ZWN1dGlvbiAqLwotCWJ1ZmZlcnVzYWdlID0gc2htX3RvY19sb29rdXAodG9jLCBQQVJBTExFTF9L RVlfQlVGRkVSX1VTQUdFLCBmYWxzZSk7Ci0Jd2FsdXNhZ2UgPSBzaG1fdG9jX2xvb2t1cCh0b2Ms IFBBUkFMTEVMX0tFWV9XQUxfVVNBR0UsIGZhbHNlKTsKLQlJbnN0ckVuZFBhcmFsbGVsUXVlcnko aW5zdHIsCi0JCQkJCQkgICZidWZmZXJ1c2FnZVtQYXJhbGxlbFdvcmtlck51bWJlcl0sCi0JCQkJ CQkgICZ3YWx1c2FnZVtQYXJhbGxlbFdvcmtlck51bWJlcl0pOworCXdvcmtlcl9pbnN0ciA9IHNo bV90b2NfbG9va3VwKHRvYywgUEFSQUxMRUxfS0VZX0lOU1RSVU1FTlRBVElPTiwgZmFsc2UpOwor CUluc3RyRW5kUGFyYWxsZWxRdWVyeShpbnN0ciwgJndvcmtlcl9pbnN0cltQYXJhbGxlbFdvcmtl ck51bWJlcl0pOwogCiAJaW5kZXhfY2xvc2UoaW5kZXhSZWwsIGluZGV4TG9ja21vZGUpOwogCXRh YmxlX2Nsb3NlKGhlYXBSZWwsIGhlYXBMb2NrbW9kZSk7CmRpZmYgLS1naXQgYS9zcmMvYmFja2Vu ZC9hY2Nlc3MvbmJ0cmVlL25idHNvcnQuYyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9uYnRyZWUvbmJ0 c29ydC5jCmluZGV4IDJkN2I3Y2VmOTEyLi5jYjIzOGY4NjJhNyAxMDA2NDQKLS0tIGEvc3JjL2Jh Y2tlbmQvYWNjZXNzL25idHJlZS9uYnRzb3J0LmMKKysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL25i dHJlZS9uYnRzb3J0LmMKQEAgLTY2LDggKzY2LDcgQEAKICNkZWZpbmUgUEFSQUxMRUxfS0VZX1RV UExFU09SVAkJCVVJTlQ2NENPTlNUKDB4QTAwMDAwMDAwMDAwMDAwMikKICNkZWZpbmUgUEFSQUxM RUxfS0VZX1RVUExFU09SVF9TUE9PTDIJVUlOVDY0Q09OU1QoMHhBMDAwMDAwMDAwMDAwMDAzKQog I2RlZmluZSBQQVJBTExFTF9LRVlfUVVFUllfVEVYVAkJCVVJTlQ2NENPTlNUKDB4QTAwMDAwMDAw MDAwMDAwNCkKLSNkZWZpbmUgUEFSQUxMRUxfS0VZX1dBTF9VU0FHRQkJCVVJTlQ2NENPTlNUKDB4 QTAwMDAwMDAwMDAwMDAwNSkKLSNkZWZpbmUgUEFSQUxMRUxfS0VZX0JVRkZFUl9VU0FHRQkJVUlO VDY0Q09OU1QoMHhBMDAwMDAwMDAwMDAwMDA2KQorI2RlZmluZSBQQVJBTExFTF9LRVlfSU5TVFJV TUVOVEFUSU9OCVVJTlQ2NENPTlNUKDB4QTAwMDAwMDAwMDAwMDAwNSkKIAogLyoKICAqIERJU0FC TEVfTEVBREVSX1BBUlRJQ0lQQVRJT04gZGlzYWJsZXMgdGhlIGxlYWRlcidzIHBhcnRpY2lwYXRp b24gaW4KQEAgLTE5NSw4ICsxOTQsNyBAQCB0eXBlZGVmIHN0cnVjdCBCVExlYWRlcgogCVNoYXJl ZHNvcnQgKnNoYXJlZHNvcnQ7CiAJU2hhcmVkc29ydCAqc2hhcmVkc29ydDI7CiAJU25hcHNob3QJ c25hcHNob3Q7Ci0JV2FsVXNhZ2UgICAqd2FsdXNhZ2U7Ci0JQnVmZmVyVXNhZ2UgKmJ1ZmZlcnVz YWdlOworCUluc3RydW1lbnRhdGlvbiAqaW5zdHI7CiB9IEJUTGVhZGVyOwogCiAvKgpAQCAtMTQw OCw4ICsxNDA2LDcgQEAgX2J0X2JlZ2luX3BhcmFsbGVsKEJUQnVpbGRTdGF0ZSAqYnVpbGRzdGF0 ZSwgYm9vbCBpc2NvbmN1cnJlbnQsIGludCByZXF1ZXN0KQogCVNoYXJlZHNvcnQgKnNoYXJlZHNv cnQyOwogCUJUU3Bvb2wgICAgKmJ0c3Bvb2wgPSBidWlsZHN0YXRlLT5zcG9vbDsKIAlCVExlYWRl ciAgICpidGxlYWRlciA9IHBhbGxvYzBfb2JqZWN0KEJUTGVhZGVyKTsKLQlXYWxVc2FnZSAgICp3 YWx1c2FnZTsKLQlCdWZmZXJVc2FnZSAqYnVmZmVydXNhZ2U7CisJSW5zdHJ1bWVudGF0aW9uICpp bnN0cjsKIAlib29sCQlsZWFkZXJwYXJ0aWNpcGF0ZXMgPSB0cnVlOwogCWludAkJCXF1ZXJ5bGVu OwogCkBAIC0xNDYyLDE4ICsxNDU5LDE0IEBAIF9idF9iZWdpbl9wYXJhbGxlbChCVEJ1aWxkU3Rh dGUgKmJ1aWxkc3RhdGUsIGJvb2wgaXNjb25jdXJyZW50LCBpbnQgcmVxdWVzdCkKIAl9CiAKIAkv KgotCSAqIEVzdGltYXRlIHNwYWNlIGZvciBXYWxVc2FnZSBhbmQgQnVmZmVyVXNhZ2UgLS0gUEFS QUxMRUxfS0VZX1dBTF9VU0FHRQotCSAqIGFuZCBQQVJBTExFTF9LRVlfQlVGRkVSX1VTQUdFLgor CSAqIEVzdGltYXRlIHNwYWNlIGZvciBJbnN0cnVtZW50YXRpb24gLS0gUEFSQUxMRUxfS0VZX0lO U1RSVU1FTlRBVElPTi4KIAkgKgogCSAqIElmIHRoZXJlIGFyZSBubyBleHRlbnNpb25zIGxvYWRl ZCB0aGF0IGNhcmUsIHdlIGNvdWxkIHNraXAgdGhpcy4gIFdlCiAJICogaGF2ZSBubyB3YXkgb2Yg a25vd2luZyB3aGV0aGVyIGFueW9uZSdzIGxvb2tpbmcgYXQgaW5zdHJ1bWVudGF0aW9uLCBzbwog CSAqIGRvIGl0IHVuY29uZGl0aW9uYWxseS4KIAkgKi8KIAlzaG1fdG9jX2VzdGltYXRlX2NodW5r KCZwY3h0LT5lc3RpbWF0b3IsCi0JCQkJCQkgICBtdWxfc2l6ZShzaXplb2YoV2FsVXNhZ2UpLCBw Y3h0LT5ud29ya2VycykpOwotCXNobV90b2NfZXN0aW1hdGVfa2V5cygmcGN4dC0+ZXN0aW1hdG9y LCAxKTsKLQlzaG1fdG9jX2VzdGltYXRlX2NodW5rKCZwY3h0LT5lc3RpbWF0b3IsCi0JCQkJCQkg ICBtdWxfc2l6ZShzaXplb2YoQnVmZmVyVXNhZ2UpLCBwY3h0LT5ud29ya2VycykpOworCQkJCQkJ ICAgbXVsX3NpemUoc2l6ZW9mKEluc3RydW1lbnRhdGlvbiksIHBjeHQtPm53b3JrZXJzKSk7CiAJ c2htX3RvY19lc3RpbWF0ZV9rZXlzKCZwY3h0LT5lc3RpbWF0b3IsIDEpOwogCiAJLyogRmluYWxs eSwgZXN0aW1hdGUgUEFSQUxMRUxfS0VZX1FVRVJZX1RFWFQgc3BhY2UgKi8KQEAgLTE1NjAsMTUg KzE1NTMsMTIgQEAgX2J0X2JlZ2luX3BhcmFsbGVsKEJUQnVpbGRTdGF0ZSAqYnVpbGRzdGF0ZSwg Ym9vbCBpc2NvbmN1cnJlbnQsIGludCByZXF1ZXN0KQogCX0KIAogCS8qCi0JICogQWxsb2NhdGUg c3BhY2UgZm9yIGVhY2ggd29ya2VyJ3MgV2FsVXNhZ2UgYW5kIEJ1ZmZlclVzYWdlOyBubyBuZWVk IHRvCisJICogQWxsb2NhdGUgc3BhY2UgZm9yIGVhY2ggd29ya2VyJ3MgSW5zdHJ1bWVudGF0aW9u OyBubyBuZWVkIHRvCiAJICogaW5pdGlhbGl6ZS4KIAkgKi8KLQl3YWx1c2FnZSA9IHNobV90b2Nf YWxsb2NhdGUocGN4dC0+dG9jLAotCQkJCQkJCQltdWxfc2l6ZShzaXplb2YoV2FsVXNhZ2UpLCBw Y3h0LT5ud29ya2VycykpOwotCXNobV90b2NfaW5zZXJ0KHBjeHQtPnRvYywgUEFSQUxMRUxfS0VZ X1dBTF9VU0FHRSwgd2FsdXNhZ2UpOwotCWJ1ZmZlcnVzYWdlID0gc2htX3RvY19hbGxvY2F0ZShw Y3h0LT50b2MsCi0JCQkJCQkJCSAgIG11bF9zaXplKHNpemVvZihCdWZmZXJVc2FnZSksIHBjeHQt Pm53b3JrZXJzKSk7Ci0Jc2htX3RvY19pbnNlcnQocGN4dC0+dG9jLCBQQVJBTExFTF9LRVlfQlVG RkVSX1VTQUdFLCBidWZmZXJ1c2FnZSk7CisJaW5zdHIgPSBzaG1fdG9jX2FsbG9jYXRlKHBjeHQt PnRvYywKKwkJCQkJCQkgbXVsX3NpemUoc2l6ZW9mKEluc3RydW1lbnRhdGlvbiksIHBjeHQtPm53 b3JrZXJzKSk7CisJc2htX3RvY19pbnNlcnQocGN4dC0+dG9jLCBQQVJBTExFTF9LRVlfSU5TVFJV TUVOVEFUSU9OLCBpbnN0cik7CiAKIAkvKiBMYXVuY2ggd29ya2Vycywgc2F2aW5nIHN0YXR1cyBm b3IgbGVhZGVyL2NhbGxlciAqLwogCUxhdW5jaFBhcmFsbGVsV29ya2VycyhwY3h0KTsKQEAgLTE1 ODAsOCArMTU3MCw3IEBAIF9idF9iZWdpbl9wYXJhbGxlbChCVEJ1aWxkU3RhdGUgKmJ1aWxkc3Rh dGUsIGJvb2wgaXNjb25jdXJyZW50LCBpbnQgcmVxdWVzdCkKIAlidGxlYWRlci0+c2hhcmVkc29y dCA9IHNoYXJlZHNvcnQ7CiAJYnRsZWFkZXItPnNoYXJlZHNvcnQyID0gc2hhcmVkc29ydDI7CiAJ YnRsZWFkZXItPnNuYXBzaG90ID0gc25hcHNob3Q7Ci0JYnRsZWFkZXItPndhbHVzYWdlID0gd2Fs dXNhZ2U7Ci0JYnRsZWFkZXItPmJ1ZmZlcnVzYWdlID0gYnVmZmVydXNhZ2U7CisJYnRsZWFkZXIt Pmluc3RyID0gaW5zdHI7CiAKIAkvKiBJZiBubyB3b3JrZXJzIHdlcmUgc3VjY2Vzc2Z1bGx5IGxh dW5jaGVkLCBiYWNrIG91dCAoZG8gc2VyaWFsIGJ1aWxkKSAqLwogCWlmIChwY3h0LT5ud29ya2Vy c19sYXVuY2hlZCA9PSAwKQpAQCAtMTYyMCw3ICsxNjA5LDcgQEAgX2J0X2VuZF9wYXJhbGxlbChC VExlYWRlciAqYnRsZWFkZXIpCiAJICogb3Igd2UgbWlnaHQgZ2V0IGluY29tcGxldGUgZGF0YS4p CiAJICovCiAJZm9yIChpID0gMDsgaSA8IGJ0bGVhZGVyLT5wY3h0LT5ud29ya2Vyc19sYXVuY2hl ZDsgaSsrKQotCQlJbnN0ckFjY3VtUGFyYWxsZWxRdWVyeSgmYnRsZWFkZXItPmJ1ZmZlcnVzYWdl W2ldLCAmYnRsZWFkZXItPndhbHVzYWdlW2ldKTsKKwkJSW5zdHJBY2N1bVBhcmFsbGVsUXVlcnko JmJ0bGVhZGVyLT5pbnN0cltpXSk7CiAKIAkvKiBGcmVlIGxhc3QgcmVmZXJlbmNlIHRvIE1WQ0Mg c25hcHNob3QsIGlmIG9uZSB3YXMgdXNlZCAqLwogCWlmIChJc01WQ0NTbmFwc2hvdChidGxlYWRl ci0+c25hcHNob3QpKQpAQCAtMTc1NCw4ICsxNzQzLDcgQEAgX2J0X3BhcmFsbGVsX2J1aWxkX21h aW4oZHNtX3NlZ21lbnQgKnNlZywgc2htX3RvYyAqdG9jKQogCUxPQ0tNT0RFCWhlYXBMb2NrbW9k ZTsKIAlMT0NLTU9ERQlpbmRleExvY2ttb2RlOwogCVF1ZXJ5SW5zdHJ1bWVudGF0aW9uICppbnN0 cjsKLQlXYWxVc2FnZSAgICp3YWx1c2FnZTsKLQlCdWZmZXJVc2FnZSAqYnVmZmVydXNhZ2U7CisJ SW5zdHJ1bWVudGF0aW9uICp3b3JrZXJfaW5zdHI7CiAJaW50CQkJc29ydG1lbTsKIAogI2lmZGVm IEJUUkVFX0JVSUxEX1NUQVRTCkBAIC0xODM3LDExICsxODI1LDggQEAgX2J0X3BhcmFsbGVsX2J1 aWxkX21haW4oZHNtX3NlZ21lbnQgKnNlZywgc2htX3RvYyAqdG9jKQogCQkJCQkJCSAgIHNoYXJl ZHNvcnQyLCBzb3J0bWVtLCBmYWxzZSk7CiAKIAkvKiBSZXBvcnQgV0FML2J1ZmZlciB1c2FnZSBk dXJpbmcgcGFyYWxsZWwgZXhlY3V0aW9uICovCi0JYnVmZmVydXNhZ2UgPSBzaG1fdG9jX2xvb2t1 cCh0b2MsIFBBUkFMTEVMX0tFWV9CVUZGRVJfVVNBR0UsIGZhbHNlKTsKLQl3YWx1c2FnZSA9IHNo bV90b2NfbG9va3VwKHRvYywgUEFSQUxMRUxfS0VZX1dBTF9VU0FHRSwgZmFsc2UpOwotCUluc3Ry RW5kUGFyYWxsZWxRdWVyeShpbnN0ciwKLQkJCQkJCSAgJmJ1ZmZlcnVzYWdlW1BhcmFsbGVsV29y a2VyTnVtYmVyXSwKLQkJCQkJCSAgJndhbHVzYWdlW1BhcmFsbGVsV29ya2VyTnVtYmVyXSk7CisJ d29ya2VyX2luc3RyID0gc2htX3RvY19sb29rdXAodG9jLCBQQVJBTExFTF9LRVlfSU5TVFJVTUVO VEFUSU9OLCBmYWxzZSk7CisJSW5zdHJFbmRQYXJhbGxlbFF1ZXJ5KGluc3RyLCAmd29ya2VyX2lu c3RyW1BhcmFsbGVsV29ya2VyTnVtYmVyXSk7CiAKICNpZmRlZiBCVFJFRV9CVUlMRF9TVEFUUwog CWlmIChsb2dfYnRyZWVfYnVpbGRfc3RhdHMpCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9jb21t YW5kcy92YWN1dW1wYXJhbGxlbC5jIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxs ZWwuYwppbmRleCBjMzMwYzg5MWMwMy4uYjVmZWQ1NGZiODUgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNr ZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMKKysrIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMv dmFjdXVtcGFyYWxsZWwuYwpAQCAtNDcsOSArNDcsOCBAQAogICovCiAjZGVmaW5lIFBBUkFMTEVM X1ZBQ1VVTV9LRVlfU0hBUkVECQkJMQogI2RlZmluZSBQQVJBTExFTF9WQUNVVU1fS0VZX1FVRVJZ X1RFWFQJCTIKLSNkZWZpbmUgUEFSQUxMRUxfVkFDVVVNX0tFWV9CVUZGRVJfVVNBR0UJMwotI2Rl ZmluZSBQQVJBTExFTF9WQUNVVU1fS0VZX1dBTF9VU0FHRQkJNAotI2RlZmluZSBQQVJBTExFTF9W QUNVVU1fS0VZX0lOREVYX1NUQVRTCQk1CisjZGVmaW5lIFBBUkFMTEVMX1ZBQ1VVTV9LRVlfSU5T VFJVTUVOVEFUSU9OCTMKKyNkZWZpbmUgUEFSQUxMRUxfVkFDVVVNX0tFWV9JTkRFWF9TVEFUUwkJ NAogCiAvKgogICogU2hhcmVkIGluZm9ybWF0aW9uIGFtb25nIHBhcmFsbGVsIHdvcmtlcnMuICBT byB0aGlzIGlzIGFsbG9jYXRlZCBpbiB0aGUgRFNNCkBAIC0xODgsMTEgKzE4Nyw4IEBAIHN0cnVj dCBQYXJhbGxlbFZhY3V1bVN0YXRlCiAJLyogU2hhcmVkIGRlYWQgaXRlbXMgc3BhY2UgYW1vbmcg cGFyYWxsZWwgdmFjdXVtIHdvcmtlcnMgKi8KIAlUaWRTdG9yZSAgICpkZWFkX2l0ZW1zOwogCi0J LyogUG9pbnRzIHRvIGJ1ZmZlciB1c2FnZSBhcmVhIGluIERTTSAqLwotCUJ1ZmZlclVzYWdlICpi dWZmZXJfdXNhZ2U7Ci0KLQkvKiBQb2ludHMgdG8gV0FMIHVzYWdlIGFyZWEgaW4gRFNNICovCi0J V2FsVXNhZ2UgICAqd2FsX3VzYWdlOworCS8qIFBvaW50cyB0byBpbnN0cnVtZW50YXRpb24gYXJl YSBpbiBEU00gKi8KKwlJbnN0cnVtZW50YXRpb24gKmluc3RyOwogCiAJLyoKIAkgKiBGYWxzZSBp ZiB0aGUgaW5kZXggaXMgdG90YWxseSB1bnN1aXRhYmxlIHRhcmdldCBmb3IgYWxsIHBhcmFsbGVs CkBAIC0yNTAsOCArMjQ2LDcgQEAgcGFyYWxsZWxfdmFjdXVtX2luaXQoUmVsYXRpb24gcmVsLCBS ZWxhdGlvbiAqaW5kcmVscywgaW50IG5pbmRleGVzLAogCVBWU2hhcmVkICAgKnNoYXJlZDsKIAlU aWRTdG9yZSAgICpkZWFkX2l0ZW1zOwogCVBWSW5kU3RhdHMgKmluZHN0YXRzOwotCUJ1ZmZlclVz YWdlICpidWZmZXJfdXNhZ2U7Ci0JV2FsVXNhZ2UgICAqd2FsX3VzYWdlOworCUluc3RydW1lbnRh dGlvbiAqaW5zdHI7CiAJYm9vbAkgICAqd2lsbF9wYXJhbGxlbF92YWN1dW07CiAJU2l6ZQkJZXN0 X2luZHN0YXRzX2xlbjsKIAlTaXplCQllc3Rfc2hhcmVkX2xlbjsKQEAgLTMwNCwxOCArMjk5LDE1 IEBAIHBhcmFsbGVsX3ZhY3V1bV9pbml0KFJlbGF0aW9uIHJlbCwgUmVsYXRpb24gKmluZHJlbHMs IGludCBuaW5kZXhlcywKIAlzaG1fdG9jX2VzdGltYXRlX2tleXMoJnBjeHQtPmVzdGltYXRvciwg MSk7CiAKIAkvKgotCSAqIEVzdGltYXRlIHNwYWNlIGZvciBCdWZmZXJVc2FnZSBhbmQgV2FsVXNh Z2UgLS0KLQkgKiBQQVJBTExFTF9WQUNVVU1fS0VZX0JVRkZFUl9VU0FHRSBhbmQgUEFSQUxMRUxf VkFDVVVNX0tFWV9XQUxfVVNBR0UuCisJICogRXN0aW1hdGUgc3BhY2UgZm9yIEluc3RydW1lbnRh dGlvbiAtLQorCSAqIFBBUkFMTEVMX1ZBQ1VVTV9LRVlfSU5TVFJVTUVOVEFUSU9OLgogCSAqCiAJ ICogSWYgdGhlcmUgYXJlIG5vIGV4dGVuc2lvbnMgbG9hZGVkIHRoYXQgY2FyZSwgd2UgY291bGQg c2tpcCB0aGlzLiAgV2UKIAkgKiBoYXZlIG5vIHdheSBvZiBrbm93aW5nIHdoZXRoZXIgYW55b25l J3MgbG9va2luZyBhdCBpbnN0cnVtZW50YXRpb24sIHNvCiAJICogZG8gaXQgdW5jb25kaXRpb25h bGx5LgogCSAqLwogCXNobV90b2NfZXN0aW1hdGVfY2h1bmsoJnBjeHQtPmVzdGltYXRvciwKLQkJ CQkJCSAgIG11bF9zaXplKHNpemVvZihCdWZmZXJVc2FnZSksIHBjeHQtPm53b3JrZXJzKSk7Ci0J c2htX3RvY19lc3RpbWF0ZV9rZXlzKCZwY3h0LT5lc3RpbWF0b3IsIDEpOwotCXNobV90b2NfZXN0 aW1hdGVfY2h1bmsoJnBjeHQtPmVzdGltYXRvciwKLQkJCQkJCSAgIG11bF9zaXplKHNpemVvZihX YWxVc2FnZSksIHBjeHQtPm53b3JrZXJzKSk7CisJCQkJCQkgICBtdWxfc2l6ZShzaXplb2YoSW5z dHJ1bWVudGF0aW9uKSwgcGN4dC0+bndvcmtlcnMpKTsKIAlzaG1fdG9jX2VzdGltYXRlX2tleXMo JnBjeHQtPmVzdGltYXRvciwgMSk7CiAKIAkvKiBGaW5hbGx5LCBlc3RpbWF0ZSBQQVJBTExFTF9W QUNVVU1fS0VZX1FVRVJZX1RFWFQgc3BhY2UgKi8KQEAgLTM5NiwxNyArMzg4LDEzIEBAIHBhcmFs bGVsX3ZhY3V1bV9pbml0KFJlbGF0aW9uIHJlbCwgUmVsYXRpb24gKmluZHJlbHMsIGludCBuaW5k ZXhlcywKIAlwdnMtPnNoYXJlZCA9IHNoYXJlZDsKIAogCS8qCi0JICogQWxsb2NhdGUgc3BhY2Ug Zm9yIGVhY2ggd29ya2VyJ3MgQnVmZmVyVXNhZ2UgYW5kIFdhbFVzYWdlOyBubyBuZWVkIHRvCi0J ICogaW5pdGlhbGl6ZQorCSAqIEFsbG9jYXRlIHNwYWNlIGZvciBlYWNoIHdvcmtlcidzIEluc3Ry dW1lbnRhdGlvbjsgbm8gbmVlZCB0bworCSAqIGluaXRpYWxpemUuCiAJICovCi0JYnVmZmVyX3Vz YWdlID0gc2htX3RvY19hbGxvY2F0ZShwY3h0LT50b2MsCi0JCQkJCQkJCQltdWxfc2l6ZShzaXpl b2YoQnVmZmVyVXNhZ2UpLCBwY3h0LT5ud29ya2VycykpOwotCXNobV90b2NfaW5zZXJ0KHBjeHQt PnRvYywgUEFSQUxMRUxfVkFDVVVNX0tFWV9CVUZGRVJfVVNBR0UsIGJ1ZmZlcl91c2FnZSk7Ci0J cHZzLT5idWZmZXJfdXNhZ2UgPSBidWZmZXJfdXNhZ2U7Ci0Jd2FsX3VzYWdlID0gc2htX3RvY19h bGxvY2F0ZShwY3h0LT50b2MsCi0JCQkJCQkJCSBtdWxfc2l6ZShzaXplb2YoV2FsVXNhZ2UpLCBw Y3h0LT5ud29ya2VycykpOwotCXNobV90b2NfaW5zZXJ0KHBjeHQtPnRvYywgUEFSQUxMRUxfVkFD VVVNX0tFWV9XQUxfVVNBR0UsIHdhbF91c2FnZSk7Ci0JcHZzLT53YWxfdXNhZ2UgPSB3YWxfdXNh Z2U7CisJaW5zdHIgPSBzaG1fdG9jX2FsbG9jYXRlKHBjeHQtPnRvYywKKwkJCQkJCQkgbXVsX3Np emUoc2l6ZW9mKEluc3RydW1lbnRhdGlvbiksIHBjeHQtPm53b3JrZXJzKSk7CisJc2htX3RvY19p bnNlcnQocGN4dC0+dG9jLCBQQVJBTExFTF9WQUNVVU1fS0VZX0lOU1RSVU1FTlRBVElPTiwgaW5z dHIpOworCXB2cy0+aW5zdHIgPSBpbnN0cjsKIAogCS8qIFN0b3JlIHF1ZXJ5IHN0cmluZyBmb3Ig d29ya2VycyAqLwogCWlmIChkZWJ1Z19xdWVyeV9zdHJpbmcpCkBAIC03NDksNyArNzM3LDcgQEAg cGFyYWxsZWxfdmFjdXVtX3Byb2Nlc3NfYWxsX2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAq cHZzLCBpbnQgbnVtX2luZGV4X3NjYW4KIAkJV2FpdEZvclBhcmFsbGVsV29ya2Vyc1RvRmluaXNo KHB2cy0+cGN4dCk7CiAKIAkJZm9yIChpbnQgaSA9IDA7IGkgPCBwdnMtPnBjeHQtPm53b3JrZXJz X2xhdW5jaGVkOyBpKyspCi0JCQlJbnN0ckFjY3VtUGFyYWxsZWxRdWVyeSgmcHZzLT5idWZmZXJf dXNhZ2VbaV0sICZwdnMtPndhbF91c2FnZVtpXSk7CisJCQlJbnN0ckFjY3VtUGFyYWxsZWxRdWVy eSgmcHZzLT5pbnN0cltpXSk7CiAJfQogCiAJLyoKQEAgLTEwMDcsOCArOTk1LDcgQEAgcGFyYWxs ZWxfdmFjdXVtX21haW4oZHNtX3NlZ21lbnQgKnNlZywgc2htX3RvYyAqdG9jKQogCVBWU2hhcmVk ICAgKnNoYXJlZDsKIAlUaWRTdG9yZSAgICpkZWFkX2l0ZW1zOwogCVF1ZXJ5SW5zdHJ1bWVudGF0 aW9uICppbnN0cjsKLQlCdWZmZXJVc2FnZSAqYnVmZmVyX3VzYWdlOwotCVdhbFVzYWdlICAgKndh bF91c2FnZTsKKwlJbnN0cnVtZW50YXRpb24gKndvcmtlcl9pbnN0cjsKIAlpbnQJCQluaW5kZXhl czsKIAljaGFyCSAgICpzaGFyZWRxdWVyeTsKIAlFcnJvckNvbnRleHRDYWxsYmFjayBlcnJjYWxs YmFjazsKQEAgLTExMDIsMTEgKzEwODksOCBAQCBwYXJhbGxlbF92YWN1dW1fbWFpbihkc21fc2Vn bWVudCAqc2VnLCBzaG1fdG9jICp0b2MpCiAJcGFyYWxsZWxfdmFjdXVtX3Byb2Nlc3Nfc2FmZV9p bmRleGVzKCZwdnMpOwogCiAJLyogUmVwb3J0IGJ1ZmZlci9XQUwgdXNhZ2UgZHVyaW5nIHBhcmFs bGVsIGV4ZWN1dGlvbiAqLwotCWJ1ZmZlcl91c2FnZSA9IHNobV90b2NfbG9va3VwKHRvYywgUEFS QUxMRUxfVkFDVVVNX0tFWV9CVUZGRVJfVVNBR0UsIGZhbHNlKTsKLQl3YWxfdXNhZ2UgPSBzaG1f dG9jX2xvb2t1cCh0b2MsIFBBUkFMTEVMX1ZBQ1VVTV9LRVlfV0FMX1VTQUdFLCBmYWxzZSk7Ci0J SW5zdHJFbmRQYXJhbGxlbFF1ZXJ5KGluc3RyLAotCQkJCQkJICAmYnVmZmVyX3VzYWdlW1BhcmFs bGVsV29ya2VyTnVtYmVyXSwKLQkJCQkJCSAgJndhbF91c2FnZVtQYXJhbGxlbFdvcmtlck51bWJl cl0pOworCXdvcmtlcl9pbnN0ciA9IHNobV90b2NfbG9va3VwKHRvYywgUEFSQUxMRUxfVkFDVVVN X0tFWV9JTlNUUlVNRU5UQVRJT04sIGZhbHNlKTsKKwlJbnN0ckVuZFBhcmFsbGVsUXVlcnkoaW5z dHIsICZ3b3JrZXJfaW5zdHJbUGFyYWxsZWxXb3JrZXJOdW1iZXJdKTsKIAogCS8qIFJlcG9ydCBh bnkgcmVtYWluaW5nIGNvc3QtYmFzZWQgdmFjdXVtIGRlbGF5IHRpbWUgKi8KIAlpZiAodHJhY2tf Y29zdF9kZWxheV90aW1pbmcpCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9leGVjdXRvci9leGVj UGFyYWxsZWwuYyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNQYXJhbGxlbC5jCmluZGV4IGMw MWU3ODBmOTE4Li4yZTU3MTM2ZWRmZCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvZXhlY3V0b3Iv ZXhlY1BhcmFsbGVsLmMKKysrIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY1BhcmFsbGVsLmMK QEAgLTYwLDEzICs2MCwxMiBAQAogI2RlZmluZSBQQVJBTExFTF9LRVlfRVhFQ1VUT1JfRklYRUQJ CVVJTlQ2NENPTlNUKDB4RTAwMDAwMDAwMDAwMDAwMSkKICNkZWZpbmUgUEFSQUxMRUxfS0VZX1BM QU5ORURTVE1UCQlVSU5UNjRDT05TVCgweEUwMDAwMDAwMDAwMDAwMDIpCiAjZGVmaW5lIFBBUkFM TEVMX0tFWV9QQVJBTUxJU1RJTkZPCQlVSU5UNjRDT05TVCgweEUwMDAwMDAwMDAwMDAwMDMpCi0j ZGVmaW5lIFBBUkFMTEVMX0tFWV9CVUZGRVJfVVNBR0UJCVVJTlQ2NENPTlNUKDB4RTAwMDAwMDAw MDAwMDAwNCkKKyNkZWZpbmUgUEFSQUxMRUxfS0VZX0lOU1RSVU1FTlRBVElPTglVSU5UNjRDT05T VCgweEUwMDAwMDAwMDAwMDAwMDQpCiAjZGVmaW5lIFBBUkFMTEVMX0tFWV9UVVBMRV9RVUVVRQkJ VUlOVDY0Q09OU1QoMHhFMDAwMDAwMDAwMDAwMDA1KQotI2RlZmluZSBQQVJBTExFTF9LRVlfSU5T VFJVTUVOVEFUSU9OCVVJTlQ2NENPTlNUKDB4RTAwMDAwMDAwMDAwMDAwNikKKyNkZWZpbmUgUEFS QUxMRUxfS0VZX05PREVfSU5TVFJVTUVOVEFUSU9OIFVJTlQ2NENPTlNUKDB4RTAwMDAwMDAwMDAw MDAwNikKICNkZWZpbmUgUEFSQUxMRUxfS0VZX0RTQQkJCQlVSU5UNjRDT05TVCgweEUwMDAwMDAw MDAwMDAwMDcpCiAjZGVmaW5lIFBBUkFMTEVMX0tFWV9RVUVSWV9URVhUCQlVSU5UNjRDT05TVCgw eEUwMDAwMDAwMDAwMDAwMDgpCiAjZGVmaW5lIFBBUkFMTEVMX0tFWV9KSVRfSU5TVFJVTUVOVEFU SU9OIFVJTlQ2NENPTlNUKDB4RTAwMDAwMDAwMDAwMDAwOSkKLSNkZWZpbmUgUEFSQUxMRUxfS0VZ X1dBTF9VU0FHRQkJCVVJTlQ2NENPTlNUKDB4RTAwMDAwMDAwMDAwMDAwQSkKIAogI2RlZmluZSBQ QVJBTExFTF9UVVBMRV9RVUVVRV9TSVpFCQk2NTUzNgogCkBAIC02MzEsOCArNjMwLDYgQEAgRXhl Y0luaXRQYXJhbGxlbFBsYW4oUGxhblN0YXRlICpwbGFuc3RhdGUsIEVTdGF0ZSAqZXN0YXRlLAog CWNoYXIJICAgKnBzdG10X2RhdGE7CiAJY2hhcgkgICAqcHN0bXRfc3BhY2U7CiAJY2hhcgkgICAq cGFyYW1saXN0aW5mb19zcGFjZTsKLQlCdWZmZXJVc2FnZSAqYnVmdXNhZ2Vfc3BhY2U7Ci0JV2Fs VXNhZ2UgICAqd2FsdXNhZ2Vfc3BhY2U7CiAJU2hhcmVkRXhlY3V0b3JJbnN0cnVtZW50YXRpb24g Kmluc3RydW1lbnRhdGlvbiA9IE5VTEw7CiAJU2hhcmVkSml0SW5zdHJ1bWVudGF0aW9uICpqaXRf aW5zdHJ1bWVudGF0aW9uID0gTlVMTDsKIAlpbnQJCQlwc3RtdF9sZW47CkBAIC02OTYsMjEgKzY5 MywxNCBAQCBFeGVjSW5pdFBhcmFsbGVsUGxhbihQbGFuU3RhdGUgKnBsYW5zdGF0ZSwgRVN0YXRl ICplc3RhdGUsCiAJc2htX3RvY19lc3RpbWF0ZV9rZXlzKCZwY3h0LT5lc3RpbWF0b3IsIDEpOwog CiAJLyoKLQkgKiBFc3RpbWF0ZSBzcGFjZSBmb3IgQnVmZmVyVXNhZ2UuCisJICogRXN0aW1hdGUg c3BhY2UgZm9yIEluc3RydW1lbnRhdGlvbi4KIAkgKgogCSAqIElmIEVYUExBSU4gaXMgbm90IGlu IHVzZSBhbmQgdGhlcmUgYXJlIG5vIGV4dGVuc2lvbnMgbG9hZGVkIHRoYXQgY2FyZSwKIAkgKiB3 ZSBjb3VsZCBza2lwIHRoaXMuICBCdXQgd2UgaGF2ZSBubyB3YXkgb2Yga25vd2luZyB3aGV0aGVy IGFueW9uZSdzCiAJICogbG9va2luZyBhdCBpbnN0cnVtZW50YXRpb24sIHNvIGRvIGl0IHVuY29u ZGl0aW9uYWxseS4KIAkgKi8KIAlzaG1fdG9jX2VzdGltYXRlX2NodW5rKCZwY3h0LT5lc3RpbWF0 b3IsCi0JCQkJCQkgICBtdWxfc2l6ZShzaXplb2YoQnVmZmVyVXNhZ2UpLCBwY3h0LT5ud29ya2Vy cykpOwotCXNobV90b2NfZXN0aW1hdGVfa2V5cygmcGN4dC0+ZXN0aW1hdG9yLCAxKTsKLQotCS8q Ci0JICogU2FtZSB0aGluZyBmb3IgV2FsVXNhZ2UuCi0JICovCi0Jc2htX3RvY19lc3RpbWF0ZV9j aHVuaygmcGN4dC0+ZXN0aW1hdG9yLAotCQkJCQkJICAgbXVsX3NpemUoc2l6ZW9mKFdhbFVzYWdl KSwgcGN4dC0+bndvcmtlcnMpKTsKKwkJCQkJCSAgIG11bF9zaXplKHNpemVvZihJbnN0cnVtZW50 YXRpb24pLCBwY3h0LT5ud29ya2VycykpOwogCXNobV90b2NfZXN0aW1hdGVfa2V5cygmcGN4dC0+ ZXN0aW1hdG9yLCAxKTsKIAogCS8qIEVzdGltYXRlIHNwYWNlIGZvciB0dXBsZSBxdWV1ZXMuICov CkBAIC03OTYsMTcgKzc4NiwxOCBAQCBFeGVjSW5pdFBhcmFsbGVsUGxhbihQbGFuU3RhdGUgKnBs YW5zdGF0ZSwgRVN0YXRlICplc3RhdGUsCiAJc2htX3RvY19pbnNlcnQocGN4dC0+dG9jLCBQQVJB TExFTF9LRVlfUEFSQU1MSVNUSU5GTywgcGFyYW1saXN0aW5mb19zcGFjZSk7CiAJU2VyaWFsaXpl UGFyYW1MaXN0KGVzdGF0ZS0+ZXNfcGFyYW1fbGlzdF9pbmZvLCAmcGFyYW1saXN0aW5mb19zcGFj ZSk7CiAKLQkvKiBBbGxvY2F0ZSBzcGFjZSBmb3IgZWFjaCB3b3JrZXIncyBCdWZmZXJVc2FnZTsg bm8gbmVlZCB0byBpbml0aWFsaXplLiAqLwotCWJ1ZnVzYWdlX3NwYWNlID0gc2htX3RvY19hbGxv Y2F0ZShwY3h0LT50b2MsCi0JCQkJCQkJCQkgIG11bF9zaXplKHNpemVvZihCdWZmZXJVc2FnZSks IHBjeHQtPm53b3JrZXJzKSk7Ci0Jc2htX3RvY19pbnNlcnQocGN4dC0+dG9jLCBQQVJBTExFTF9L RVlfQlVGRkVSX1VTQUdFLCBidWZ1c2FnZV9zcGFjZSk7Ci0JcGVpLT5idWZmZXJfdXNhZ2UgPSBi dWZ1c2FnZV9zcGFjZTsKKwkvKgorCSAqIEFsbG9jYXRlIHNwYWNlIGZvciBlYWNoIHdvcmtlcidz IEluc3RydW1lbnRhdGlvbjsgbm8gbmVlZCB0bworCSAqIGluaXRpYWxpemUuCisJICovCisJewor CQlJbnN0cnVtZW50YXRpb24gKmluc3RyOwogCi0JLyogU2FtZSBmb3IgV2FsVXNhZ2UuICovCi0J d2FsdXNhZ2Vfc3BhY2UgPSBzaG1fdG9jX2FsbG9jYXRlKHBjeHQtPnRvYywKLQkJCQkJCQkJCSAg bXVsX3NpemUoc2l6ZW9mKFdhbFVzYWdlKSwgcGN4dC0+bndvcmtlcnMpKTsKLQlzaG1fdG9jX2lu c2VydChwY3h0LT50b2MsIFBBUkFMTEVMX0tFWV9XQUxfVVNBR0UsIHdhbHVzYWdlX3NwYWNlKTsK LQlwZWktPndhbF91c2FnZSA9IHdhbHVzYWdlX3NwYWNlOworCQlpbnN0ciA9IHNobV90b2NfYWxs b2NhdGUocGN4dC0+dG9jLAorCQkJCQkJCQkgbXVsX3NpemUoc2l6ZW9mKEluc3RydW1lbnRhdGlv biksIHBjeHQtPm53b3JrZXJzKSk7CisJCXNobV90b2NfaW5zZXJ0KHBjeHQtPnRvYywgUEFSQUxM RUxfS0VZX0lOU1RSVU1FTlRBVElPTiwgaW5zdHIpOworCQlwZWktPmluc3RydW1lbnRhdGlvbiA9 IGluc3RyOworCX0KIAogCS8qIFNldCB1cCB0aGUgdHVwbGUgcXVldWVzIHRoYXQgdGhlIHdvcmtl cnMgd2lsbCB3cml0ZSBpbnRvLiAqLwogCXBlaS0+dHF1ZXVlID0gRXhlY1BhcmFsbGVsU2V0dXBU dXBsZVF1ZXVlcyhwY3h0LCBmYWxzZSk7CkBAIC04MzIsOSArODIzLDkgQEAgRXhlY0luaXRQYXJh bGxlbFBsYW4oUGxhblN0YXRlICpwbGFuc3RhdGUsIEVTdGF0ZSAqZXN0YXRlLAogCQlpbnN0cnVt ZW50ID0gR2V0SW5zdHJ1bWVudGF0aW9uQXJyYXkoaW5zdHJ1bWVudGF0aW9uKTsKIAkJZm9yIChp ID0gMDsgaSA8IG53b3JrZXJzICogZS5ubm9kZXM7ICsraSkKIAkJCUluc3RySW5pdE5vZGUoJmlu c3RydW1lbnRbaV0sIGVzdGF0ZS0+ZXNfaW5zdHJ1bWVudC0+aW5zdHJ1bWVudF9vcHRpb25zKTsK LQkJc2htX3RvY19pbnNlcnQocGN4dC0+dG9jLCBQQVJBTExFTF9LRVlfSU5TVFJVTUVOVEFUSU9O LAorCQlzaG1fdG9jX2luc2VydChwY3h0LT50b2MsIFBBUkFMTEVMX0tFWV9OT0RFX0lOU1RSVU1F TlRBVElPTiwKIAkJCQkJICAgaW5zdHJ1bWVudGF0aW9uKTsKLQkJcGVpLT5pbnN0cnVtZW50YXRp b24gPSBpbnN0cnVtZW50YXRpb247CisJCXBlaS0+bm9kZV9pbnN0cnVtZW50YXRpb24gPSBpbnN0 cnVtZW50YXRpb247CiAKIAkJaWYgKGVzdGF0ZS0+ZXNfaml0X2ZsYWdzICE9IFBHSklUX05PTkUp CiAJCXsKQEAgLTEyMzYsNyArMTIyNyw3IEBAIEV4ZWNQYXJhbGxlbEZpbmlzaChQYXJhbGxlbEV4 ZWN1dG9ySW5mbyAqcGVpKQogCSAqIGZpbmlzaCwgb3Igd2UgbWlnaHQgZ2V0IGluY29tcGxldGUg ZGF0YS4pCiAJICovCiAJZm9yIChpID0gMDsgaSA8IG53b3JrZXJzOyBpKyspCi0JCUluc3RyQWNj dW1QYXJhbGxlbFF1ZXJ5KCZwZWktPmJ1ZmZlcl91c2FnZVtpXSwgJnBlaS0+d2FsX3VzYWdlW2ld KTsKKwkJSW5zdHJBY2N1bVBhcmFsbGVsUXVlcnkoJnBlaS0+aW5zdHJ1bWVudGF0aW9uW2ldKTsK IAogCXBlaS0+ZmluaXNoZWQgPSB0cnVlOwogfQpAQCAtMTI1MCwxMSArMTI0MSwxMSBAQCBFeGVj UGFyYWxsZWxGaW5pc2goUGFyYWxsZWxFeGVjdXRvckluZm8gKnBlaSkKIHZvaWQKIEV4ZWNQYXJh bGxlbENsZWFudXAoUGFyYWxsZWxFeGVjdXRvckluZm8gKnBlaSkKIHsKLQkvKiBBY2N1bXVsYXRl IGluc3RydW1lbnRhdGlvbiwgaWYgYW55LiAqLwotCWlmIChwZWktPmluc3RydW1lbnRhdGlvbikK KwkvKiBBY2N1bXVsYXRlIG5vZGUgaW5zdHJ1bWVudGF0aW9uLCBpZiBhbnkuICovCisJaWYgKHBl aS0+bm9kZV9pbnN0cnVtZW50YXRpb24pCiAJewogCQlFeGVjUGFyYWxsZWxSZXRyaWV2ZUluc3Ry dW1lbnRhdGlvbihwZWktPnBsYW5zdGF0ZSwKLQkJCQkJCQkJCQkJcGVpLT5pbnN0cnVtZW50YXRp b24pOworCQkJCQkJCQkJCQlwZWktPm5vZGVfaW5zdHJ1bWVudGF0aW9uKTsKIAogCQlFeGVjRmlu YWxpemVXb3JrZXJJbnN0cnVtZW50YXRpb24ocGVpLT5wbGFuc3RhdGUpOwogCX0KQEAgLTE0ODEs OCArMTQ3Miw2IEBAIFBhcmFsbGVsUXVlcnlNYWluKGRzbV9zZWdtZW50ICpzZWcsIHNobV90b2Mg KnRvYykKIHsKIAlGaXhlZFBhcmFsbGVsRXhlY3V0b3JTdGF0ZSAqZnBlczsKIAlRdWVyeUluc3Ry dW1lbnRhdGlvbiAqaW5zdHI7Ci0JQnVmZmVyVXNhZ2UgKmJ1ZmZlcl91c2FnZTsKLQlXYWxVc2Fn ZSAgICp3YWxfdXNhZ2U7CiAJRGVzdFJlY2VpdmVyICpyZWNlaXZlcjsKIAlRdWVyeURlc2MgICpx dWVyeURlc2M7CiAJU2hhcmVkRXhlY3V0b3JJbnN0cnVtZW50YXRpb24gKmluc3RydW1lbnRhdGlv bjsKQEAgLTE0OTcsNyArMTQ4Niw3IEBAIFBhcmFsbGVsUXVlcnlNYWluKGRzbV9zZWdtZW50ICpz ZWcsIHNobV90b2MgKnRvYykKIAogCS8qIFNldCB1cCBEZXN0UmVjZWl2ZXIsIFNoYXJlZEV4ZWN1 dG9ySW5zdHJ1bWVudGF0aW9uLCBhbmQgUXVlcnlEZXNjLiAqLwogCXJlY2VpdmVyID0gRXhlY1Bh cmFsbGVsR2V0UmVjZWl2ZXIoc2VnLCB0b2MpOwotCWluc3RydW1lbnRhdGlvbiA9IHNobV90b2Nf bG9va3VwKHRvYywgUEFSQUxMRUxfS0VZX0lOU1RSVU1FTlRBVElPTiwgdHJ1ZSk7CisJaW5zdHJ1 bWVudGF0aW9uID0gc2htX3RvY19sb29rdXAodG9jLCBQQVJBTExFTF9LRVlfTk9ERV9JTlNUUlVN RU5UQVRJT04sIHRydWUpOwogCWlmIChpbnN0cnVtZW50YXRpb24gIT0gTlVMTCkKIAkJaW5zdHJ1 bWVudF9vcHRpb25zID0gaW5zdHJ1bWVudGF0aW9uLT5pbnN0cnVtZW50X29wdGlvbnM7CiAJaml0 X2luc3RydW1lbnRhdGlvbiA9IHNobV90b2NfbG9va3VwKHRvYywgUEFSQUxMRUxfS0VZX0pJVF9J TlNUUlVNRU5UQVRJT04sCkBAIC0xNTU1LDExICsxNTQ0LDEyIEBAIFBhcmFsbGVsUXVlcnlNYWlu KGRzbV9zZWdtZW50ICpzZWcsIHNobV90b2MgKnRvYykKIAlFeGVjdXRvckZpbmlzaChxdWVyeURl c2MpOwogCiAJLyogUmVwb3J0IGJ1ZmZlci9XQUwgdXNhZ2UgZHVyaW5nIHBhcmFsbGVsIGV4ZWN1 dGlvbi4gKi8KLQlidWZmZXJfdXNhZ2UgPSBzaG1fdG9jX2xvb2t1cCh0b2MsIFBBUkFMTEVMX0tF WV9CVUZGRVJfVVNBR0UsIGZhbHNlKTsKLQl3YWxfdXNhZ2UgPSBzaG1fdG9jX2xvb2t1cCh0b2Ms IFBBUkFMTEVMX0tFWV9XQUxfVVNBR0UsIGZhbHNlKTsKLQlJbnN0ckVuZFBhcmFsbGVsUXVlcnko aW5zdHIsCi0JCQkJCQkgICZidWZmZXJfdXNhZ2VbUGFyYWxsZWxXb3JrZXJOdW1iZXJdLAotCQkJ CQkJICAmd2FsX3VzYWdlW1BhcmFsbGVsV29ya2VyTnVtYmVyXSk7CisJeworCQlJbnN0cnVtZW50 YXRpb24gKndvcmtlcl9pbnN0cjsKKworCQl3b3JrZXJfaW5zdHIgPSBzaG1fdG9jX2xvb2t1cCh0 b2MsIFBBUkFMTEVMX0tFWV9JTlNUUlVNRU5UQVRJT04sIGZhbHNlKTsKKwkJSW5zdHJFbmRQYXJh bGxlbFF1ZXJ5KGluc3RyLCAmd29ya2VyX2luc3RyW1BhcmFsbGVsV29ya2VyTnVtYmVyXSk7CisJ fQogCiAJLyogUmVwb3J0IGluc3RydW1lbnRhdGlvbiBkYXRhIGlmIGFueSBpbnN0cnVtZW50YXRp b24gb3B0aW9ucyBhcmUgc2V0LiAqLwogCWlmIChpbnN0cnVtZW50YXRpb24gIT0gTlVMTCkKZGlm ZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2luc3RydW1lbnQuYyBiL3NyYy9iYWNrZW5k L2V4ZWN1dG9yL2luc3RydW1lbnQuYwppbmRleCBmOTIwMmI1NThkNi4uYWY2NGFhMTQ1ZWIgMTAw NjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2luc3RydW1lbnQuYworKysgYi9zcmMvYmFj a2VuZC9leGVjdXRvci9pbnN0cnVtZW50LmMKQEAgLTMzOSwxMSArMzM5LDEyIEBAIEluc3RyU3Rh cnRQYXJhbGxlbFF1ZXJ5KHZvaWQpCiAKIC8qIHJlcG9ydCB1c2FnZSBhZnRlciBwYXJhbGxlbCBl eGVjdXRvciBzaHV0ZG93biAqLwogdm9pZAotSW5zdHJFbmRQYXJhbGxlbFF1ZXJ5KFF1ZXJ5SW5z dHJ1bWVudGF0aW9uICpxaW5zdHIsIEJ1ZmZlclVzYWdlICpidWZ1c2FnZSwgV2FsVXNhZ2UgKndh bHVzYWdlKQorSW5zdHJFbmRQYXJhbGxlbFF1ZXJ5KFF1ZXJ5SW5zdHJ1bWVudGF0aW9uICpxaW5z dHIsIEluc3RydW1lbnRhdGlvbiAqZHN0KQogewogCUluc3RyUXVlcnlTdG9wRmluYWxpemUocWlu c3RyKTsKLQltZW1jcHkoYnVmdXNhZ2UsICZxaW5zdHItPmluc3RyLmJ1ZnVzYWdlLCBzaXplb2Yo QnVmZmVyVXNhZ2UpKTsKLQltZW1jcHkod2FsdXNhZ2UsICZxaW5zdHItPmluc3RyLndhbHVzYWdl LCBzaXplb2YoV2FsVXNhZ2UpKTsKKwlkc3QtPm5lZWRfc3RhY2sgPSBxaW5zdHItPmluc3RyLm5l ZWRfc3RhY2s7CisJbWVtY3B5KCZkc3QtPmJ1ZnVzYWdlLCAmcWluc3RyLT5pbnN0ci5idWZ1c2Fn ZSwgc2l6ZW9mKEJ1ZmZlclVzYWdlKSk7CisJbWVtY3B5KCZkc3QtPndhbHVzYWdlLCAmcWluc3Ry LT5pbnN0ci53YWx1c2FnZSwgc2l6ZW9mKFdhbFVzYWdlKSk7CiB9CiAKIC8qCkBAIC0zNTksMTIg KzM2MCwxMSBAQCBJbnN0ckVuZFBhcmFsbGVsUXVlcnkoUXVlcnlJbnN0cnVtZW50YXRpb24gKnFp bnN0ciwgQnVmZmVyVXNhZ2UgKmJ1ZnVzYWdlLCBXYWxVcwogICogYWN0aXZpdHkgaXMgYWNjdW11 bGF0ZWQuCiAgKi8KIHZvaWQKLUluc3RyQWNjdW1QYXJhbGxlbFF1ZXJ5KEJ1ZmZlclVzYWdlICpi dWZ1c2FnZSwgV2FsVXNhZ2UgKndhbHVzYWdlKQorSW5zdHJBY2N1bVBhcmFsbGVsUXVlcnkoSW5z dHJ1bWVudGF0aW9uICppbnN0cikKIHsKLQlCdWZmZXJVc2FnZUFkZCgmaW5zdHJfc3RhY2suY3Vy cmVudC0+YnVmdXNhZ2UsIGJ1ZnVzYWdlKTsKLQlXYWxVc2FnZUFkZCgmaW5zdHJfc3RhY2suY3Vy cmVudC0+d2FsdXNhZ2UsIHdhbHVzYWdlKTsKKwlJbnN0ckFjY3VtU3RhY2soaW5zdHJfc3RhY2su Y3VycmVudCwgaW5zdHIpOwogCi0JV2FsVXNhZ2VBZGQoJnBnV2FsVXNhZ2UsIHdhbHVzYWdlKTsK KwlXYWxVc2FnZUFkZCgmcGdXYWxVc2FnZSwgJmluc3RyLT53YWx1c2FnZSk7CiB9CiAKIC8qIE5v ZGUgaW5zdHJ1bWVudGF0aW9uIGhhbmRsaW5nICovCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9l eGVjdXRvci9leGVjUGFyYWxsZWwuaCBiL3NyYy9pbmNsdWRlL2V4ZWN1dG9yL2V4ZWNQYXJhbGxl bC5oCmluZGV4IDVhMjAzNDgxMWQ1Li42YzhiNjAyZDA3ZiAxMDA2NDQKLS0tIGEvc3JjL2luY2x1 ZGUvZXhlY3V0b3IvZXhlY1BhcmFsbGVsLmgKKysrIGIvc3JjL2luY2x1ZGUvZXhlY3V0b3IvZXhl Y1BhcmFsbGVsLmgKQEAgLTI1LDkgKzI1LDggQEAgdHlwZWRlZiBzdHJ1Y3QgUGFyYWxsZWxFeGVj dXRvckluZm8KIHsKIAlQbGFuU3RhdGUgICpwbGFuc3RhdGU7CQkvKiBwbGFuIHN1YnRyZWUgd2Un cmUgcnVubmluZyBpbiBwYXJhbGxlbCAqLwogCVBhcmFsbGVsQ29udGV4dCAqcGN4dDsJCS8qIHBh cmFsbGVsIGNvbnRleHQgd2UncmUgdXNpbmcgKi8KLQlCdWZmZXJVc2FnZSAqYnVmZmVyX3VzYWdl OwkvKiBwb2ludHMgdG8gYnVmdXNhZ2UgYXJlYSBpbiBEU00gKi8KLQlXYWxVc2FnZSAgICp3YWxf dXNhZ2U7CQkvKiB3YWx1c2FnZSBhcmVhIGluIERTTSAqLwotCVNoYXJlZEV4ZWN1dG9ySW5zdHJ1 bWVudGF0aW9uICppbnN0cnVtZW50YXRpb247IC8qIG9wdGlvbmFsICovCisJSW5zdHJ1bWVudGF0 aW9uICppbnN0cnVtZW50YXRpb247CS8qIGluc3RydW1lbnRhdGlvbiBhcmVhIGluIERTTSAqLwor CVNoYXJlZEV4ZWN1dG9ySW5zdHJ1bWVudGF0aW9uICpub2RlX2luc3RydW1lbnRhdGlvbjsJLyog b3B0aW9uYWwgKi8KIAlzdHJ1Y3QgU2hhcmVkSml0SW5zdHJ1bWVudGF0aW9uICpqaXRfaW5zdHJ1 bWVudGF0aW9uOwkvKiBvcHRpb25hbCAqLwogCWRzYV9hcmVhICAgKmFyZWE7CQkJLyogcG9pbnRz IHRvIERTQSBhcmVhIGluIERTTSAqLwogCWRzYV9wb2ludGVyIHBhcmFtX2V4ZWM7CQkvKiBzZXJp YWxpemVkIFBBUkFNX0VYRUMgcGFyYW1ldGVycyAqLwpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUv ZXhlY3V0b3IvaW5zdHJ1bWVudC5oIGIvc3JjL2luY2x1ZGUvZXhlY3V0b3IvaW5zdHJ1bWVudC5o CmluZGV4IGQyZjAxOTFhZjI3Li5iNjI2MTk0MTJhMCAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUv ZXhlY3V0b3IvaW5zdHJ1bWVudC5oCisrKyBiL3NyYy9pbmNsdWRlL2V4ZWN1dG9yL2luc3RydW1l bnQuaApAQCAtMjg2LDggKzI4Niw4IEBAIGV4dGVybiB2b2lkIEluc3RyUXVlcnlTdG9wRmluYWxp emUoUXVlcnlJbnN0cnVtZW50YXRpb24gKmluc3RyKTsKIGV4dGVybiB2b2lkIEluc3RyUXVlcnlS ZW1lbWJlckNoaWxkKFF1ZXJ5SW5zdHJ1bWVudGF0aW9uICpwYXJlbnQsIEluc3RydW1lbnRhdGlv biAqaW5zdHIpOwogCiBwZ19ub2Rpc2NhcmQgZXh0ZXJuIFF1ZXJ5SW5zdHJ1bWVudGF0aW9uICpJ bnN0clN0YXJ0UGFyYWxsZWxRdWVyeSh2b2lkKTsKLWV4dGVybiB2b2lkIEluc3RyRW5kUGFyYWxs ZWxRdWVyeShRdWVyeUluc3RydW1lbnRhdGlvbiAqcWluc3RyLCBCdWZmZXJVc2FnZSAqYnVmdXNh Z2UsIFdhbFVzYWdlICp3YWx1c2FnZSk7Ci1leHRlcm4gdm9pZCBJbnN0ckFjY3VtUGFyYWxsZWxR dWVyeShCdWZmZXJVc2FnZSAqYnVmdXNhZ2UsIFdhbFVzYWdlICp3YWx1c2FnZSk7CitleHRlcm4g dm9pZCBJbnN0ckVuZFBhcmFsbGVsUXVlcnkoUXVlcnlJbnN0cnVtZW50YXRpb24gKnFpbnN0ciwg SW5zdHJ1bWVudGF0aW9uICpkc3QpOworZXh0ZXJuIHZvaWQgSW5zdHJBY2N1bVBhcmFsbGVsUXVl cnkoSW5zdHJ1bWVudGF0aW9uICppbnN0cik7CiAKIGV4dGVybiBOb2RlSW5zdHJ1bWVudGF0aW9u ICpJbnN0ckFsbG9jTm9kZShRdWVyeUluc3RydW1lbnRhdGlvbiAqcWluc3RyLCBib29sIGFzeW5j X21vZGUpOwogZXh0ZXJuIHZvaWQgSW5zdHJJbml0Tm9kZShOb2RlSW5zdHJ1bWVudGF0aW9uICpp bnN0ciwgaW50IGluc3RydW1lbnRfb3B0aW9ucyk7Ci0tIAoyLjQ3LjEKCg== --0000000000006d0cb0064eb5be7d Content-Type: application/octet-stream; name="v13-0008-Optimize-measuring-WAL-buffer-usage-through-stac.patch" Content-Disposition: attachment; filename="v13-0008-Optimize-measuring-WAL-buffer-usage-through-stac.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mnlqag7b7 RnJvbSA5Mzg2YmM3NGE1NjBkZDk3OWIxZDJiNDQ4NGNkYzE0MjBhYjg2YjM5IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBMdWthcyBGaXR0bCA8bHVrYXNAZml0dGwuY29tPgpEYXRlOiBU dWUsIDkgU2VwIDIwMjUgMDI6MTY6NTkgLTA3MDAKU3ViamVjdDogW1BBVENIIHYxMyAwOC8xMl0g T3B0aW1pemUgbWVhc3VyaW5nIFdBTC9idWZmZXIgdXNhZ2UgdGhyb3VnaAogc3RhY2stYmFzZWQg aW5zdHJ1bWVudGF0aW9uCgpQcmV2aW91c2x5LCBpbiBvcmRlciB0byBkZXRlcm1pbmUgdGhlIGJ1 ZmZlci9XQUwgdXNhZ2Ugb2YgYSBnaXZlbiBjb2RlCnNlY3Rpb24sIHdlIHV0aWxpemVkIGNvbnRp bnVvdXNseSBpbmNyZW1lbnRpbmcgZ2xvYmFsIGNvdW50ZXJzIHRoYXQgZ2V0CnVwZGF0ZWQgd2hl biB0aGUgYWN0dWFsIGFjdGl2aXR5IChlLmcuIHNoYXJlZCBibG9jayByZWFkKSBvY2N1cnJlZCwg YW5kCnRoZW4gY2FsY3VsYXRlZCBhIGRpZmYgd2hlbiB0aGUgY29kZSBzZWN0aW9uIGVuZGVkLiBU aGlzIHJlc3VsdGVkIGluIGEKYm90dGxlbmVjayBmb3IgZXhlY3V0b3Igbm9kZSBpbnN0cnVtZW50 YXRpb24gc3BlY2lmaWNhbGx5LCB3aXRoIHRoZQpmdW5jdGlvbiBCdWZmZXJVc2FnZUFjY3VtRGlm ZiBzaG93aW5nIHVwIGluIHByb2ZpbGVzIGFuZCBpbiBzb21lIGNhc2VzCmFkZGluZyB1cCB0byAx MCUgb3ZlcmhlYWQgdG8gYW4gRVhQTEFJTiAoQU5BTFlaRSwgQlVGRkVSUykgcnVuLgoKSW5zdGVh ZCwgaW50cm9kdWNlIGEgc3RhY2stYmFzZWQgbWVjaGFuaXNtLCB3aGVyZSB0aGUgYWN0dWFsIGFj dGl2aXR5CndyaXRlcyBpbnRvIHRoZSBjdXJyZW50IHN0YWNrIGVudHJ5LiBJbiB0aGUgY2FzZSBv ZiBleGVjdXRvciBub2RlcywgdGhpcwptZWFucyB0aGF0IGVhY2ggbm9kZSBnZXRzIGl0cyBvd24g c3RhY2sgZW50cnkgdGhhdCBpcyBwdXNoZWQgYXQKSW5zdHJTdGFydE5vZGUsIGFuZCBwb3BwZWQg YXQgSW5zdHJFbmROb2RlLiBTdGFjayBlbnRyaWVzIGFyZSB6ZXJvCmluaXRpYWxpemVkIChhdm9p ZGluZyB0aGUgZGlmZiBtZWNoYW5pc20pIGFuZCBnZXQgYWRkZWQgdG8gdGhlaXIgcGFyZW50CmVu dHJ5IHdoZW4gdGhleSBhcmUgZmluYWxpemVkLCBpLmUuIG5vIG1vcmUgbW9kaWZpY2F0aW9ucyBj YW4gb2NjdXIuCgpUbyBjb3JyZWN0bHkgaGFuZGxlIGFib3J0IHNpdHVhdGlvbnMsIGFueSB1c2Ug b2YgaW5zdHJ1bWVudGF0aW9uIHN0YWNrcwptdXN0IGludm9sdmUgZWl0aGVyIGEgdG9wLWxldmVs IFF1ZXJ5SW5zdHJ1bWVudGF0aW9uIHN0cnVjdCwgYW5kIGl0cwphc3NvY2lhdGVkIEluc3RyUXVl cnlTdGFydC9JbnN0clF1ZXJ5U3RvcCBoZWxwZXJzICh3aGljaCB1c2UgcmVzb3VyY2UKb3duZXJz IHRvIGhhbmRsZSBhYm9ydHMpLCBvciB0aGUgSW5zdHJ1bWVudGF0aW9uIHN0cnVjdCBpdHNlbGYg d2l0aApkZWRpY2F0ZWQgUEdfVFJZL1BHX0ZJTkFMTFkgY2FsbHMgdGhhdCBlbnN1cmUgdGhlIHN0 YWNrIGlzIGluIGEKY29uc2lzdGVudCBzdGF0ZSBhZnRlciBhbiBhYm9ydC4KCkluIHRlc3RzLCB0 aGUgc3RhY2stYmFzZWQgaW5zdHJ1bWVudGF0aW9uIG1lY2hhbmlzbSByZWR1Y2VzIHRoZSBvdmVy aGVhZApvZiBFWFBMQUlOIChBTkFMWVpFLCBCVUZGRVJTIE9OLCBUSU1JTkcgT0ZGKSBmb3IgYSBs YXJnZSBDT1VOVCgqKSBxdWVyeQpmcm9tIGFib3V0IDUwJSB0byAyMiUgb24gdG9wIG9mIHRoZSBh Y3R1YWwgcnVudGltZS4KClRoaXMgYWxzbyBkcm9wcyB0aGUgZ2xvYmFsIHBnQnVmZmVyVXNhZ2Us IGFueSBjYWxsZXJzIGludGVyZXN0ZWQgaW4KbWVhc3VyaW5nIGJ1ZmZlciBhY3Rpdml0eSBzaG91 bGQgaW5zdGVhZCB1dGlsaXplIEluc3RyU3RhcnQvSW5zdHJTdG9wLgoKVGhlIHJlbGF0ZWQgZ2xv YmFsIHBnV2FsVXNhZ2UgaXMga2VwdCBmb3Igbm93IGR1ZSB0byBpdHMgdXNlIGluIHBnc3RhdAp0 byB0cmFjayBhZ2dyZWdhdGUgV0FMIGFjdGl2aXR5IGFuZCBoZWFwX3BhZ2VfcHJ1bmVfYW5kX2Zy ZWV6ZSBmb3IKbWVhc3VyaW5nIEZQSXMuCgpBdXRob3I6IEx1a2FzIEZpdHRsIDxsdWthc0BmaXR0 bC5jb20+ClJldmlld2VkLWJ5OiBac29sdCBQYXJyYWdpIDx6c29sdC5wYXJyYWdpQHBlcmNvbmEu Y29tPgpSZXZpZXdlZC1ieTogSGVpa2tpIExpbm5ha2FuZ2FzIDxobGlubmFrYUBpa2kuZmk+CkRp c2N1c3Npb246IGh0dHBzOi8vd3d3LnBvc3RncmVzcWwub3JnL21lc3NhZ2UtaWQvZmxhdC9DQVA1 M1BreHJtcEVDelZGcGVlRUVIREdlNnU2MjVzJTJCWWttVnY1LWd3M0xfTkRTZmJpQSU0MG1haWwu Z21haWwuY29tI2NiNTgzYTA4ZThlMDk2YWExZjA5M2JiMTc4OTA2MTczCi0tLQogY29udHJpYi9h dXRvX2V4cGxhaW4vYXV0b19leHBsYWluLmMgICAgICAgICAgIHwgIDE2ICstCiAuLi4vcGdfc3Rh dF9zdGF0ZW1lbnRzL3BnX3N0YXRfc3RhdGVtZW50cy5jICAgfCAgMjQgKy0KIHNyYy9iYWNrZW5k L2FjY2Vzcy9icmluL2JyaW4uYyAgICAgICAgICAgICAgICB8ICAxMCArLQogc3JjL2JhY2tlbmQv YWNjZXNzL2dpbi9naW5pbnNlcnQuYyAgICAgICAgICAgIHwgIDEwICstCiBzcmMvYmFja2VuZC9h Y2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMgICAgICAgICAgfCAgMTIgKy0KIHNyYy9iYWNrZW5kL2Fj Y2Vzcy9uYnRyZWUvbmJ0c29ydC5jICAgICAgICAgICB8ICAxMCArLQogc3JjL2JhY2tlbmQvY29t bWFuZHMvYW5hbHl6ZS5jICAgICAgICAgICAgICAgIHwgIDEyICstCiBzcmMvYmFja2VuZC9jb21t YW5kcy9leHBsYWluLmMgICAgICAgICAgICAgICAgfCAgMTAgKy0KIHNyYy9iYWNrZW5kL2NvbW1h bmRzL2V4cGxhaW5fZHIuYyAgICAgICAgICAgICB8ICAgNiArLQogc3JjL2JhY2tlbmQvY29tbWFu ZHMvcHJlcGFyZS5jICAgICAgICAgICAgICAgIHwgIDEwICstCiBzcmMvYmFja2VuZC9jb21tYW5k cy90YWJsZWNtZHMuYyAgICAgICAgICAgICAgfCAgIDIgKy0KIHNyYy9iYWNrZW5kL2NvbW1hbmRz L3RyaWdnZXIuYyAgICAgICAgICAgICAgICB8ICAxNyArLQogc3JjL2JhY2tlbmQvY29tbWFuZHMv dmFjdXVtcGFyYWxsZWwuYyAgICAgICAgIHwgIDEwICstCiBzcmMvYmFja2VuZC9leGVjdXRvci9S RUFETUUuaW5zdHJ1bWVudCAgICAgICAgfCAyMzcgKysrKysrKysrCiBzcmMvYmFja2VuZC9leGVj dXRvci9leGVjTWFpbi5jICAgICAgICAgICAgICAgfCAgODQgKysrLQogc3JjL2JhY2tlbmQvZXhl Y3V0b3IvZXhlY1BhcmFsbGVsLmMgICAgICAgICAgIHwgIDM2ICstCiBzcmMvYmFja2VuZC9leGVj dXRvci9leGVjUGFydGl0aW9uLmMgICAgICAgICAgfCAgIDIgKy0KIHNyYy9iYWNrZW5kL2V4ZWN1 dG9yL2V4ZWNQcm9jbm9kZS5jICAgICAgICAgICB8IDEwMyArKystCiBzcmMvYmFja2VuZC9leGVj dXRvci9leGVjVXRpbHMuYyAgICAgICAgICAgICAgfCAgMTEgKy0KIHNyYy9iYWNrZW5kL2V4ZWN1 dG9yL2luc3RydW1lbnQuYyAgICAgICAgICAgICB8IDQ2OCArKysrKysrKysrKysrKy0tLS0KIHNy Yy9iYWNrZW5kL3JlcGxpY2F0aW9uL2xvZ2ljYWwvd29ya2VyLmMgICAgICB8ICAgMiArLQogc3Jj L2JhY2tlbmQvc3RvcmFnZS9idWZmZXIvYnVmbWdyLmMgICAgICAgICAgIHwgICA2ICstCiBzcmMv YmFja2VuZC91dGlscy9hY3Rpdml0eS9wZ3N0YXRfaW8uYyAgICAgICAgfCAgIDYgKy0KIHNyYy9p bmNsdWRlL2V4ZWN1dG9yL2V4ZWNkZXNjLmggICAgICAgICAgICAgICB8ICAgNCArLQogc3JjL2lu Y2x1ZGUvZXhlY3V0b3IvZXhlY3V0b3IuaCAgICAgICAgICAgICAgIHwgICA1ICstCiBzcmMvaW5j bHVkZS9leGVjdXRvci9pbnN0cnVtZW50LmggICAgICAgICAgICAgfCAyMDEgKysrKysrKy0KIHNy Yy9pbmNsdWRlL25vZGVzL2V4ZWNub2Rlcy5oICAgICAgICAgICAgICAgICB8ICAgMyArLQogc3Jj L2luY2x1ZGUvdXRpbHMvcmVzb3duZXIuaCAgICAgICAgICAgICAgICAgIHwgICAxICsKIHNyYy90 b29scy9wZ2luZGVudC90eXBlZGVmcy5saXN0ICAgICAgICAgICAgICB8ICAgMiArCiAyOSBmaWxl cyBjaGFuZ2VkLCAxMDg0IGluc2VydGlvbnMoKyksIDIzNiBkZWxldGlvbnMoLSkKIGNyZWF0ZSBt b2RlIDEwMDY0NCBzcmMvYmFja2VuZC9leGVjdXRvci9SRUFETUUuaW5zdHJ1bWVudAoKZGlmZiAt LWdpdCBhL2NvbnRyaWIvYXV0b19leHBsYWluL2F1dG9fZXhwbGFpbi5jIGIvY29udHJpYi9hdXRv X2V4cGxhaW4vYXV0b19leHBsYWluLmMKaW5kZXggMzliZjI1NDNiNzAuLjRiZTgxNDg5ZmY0IDEw MDY0NAotLS0gYS9jb250cmliL2F1dG9fZXhwbGFpbi9hdXRvX2V4cGxhaW4uYworKysgYi9jb250 cmliL2F1dG9fZXhwbGFpbi9hdXRvX2V4cGxhaW4uYwpAQCAtMzA1LDE5ICszMDUsOSBAQCBleHBs YWluX0V4ZWN1dG9yU3RhcnQoUXVlcnlEZXNjICpxdWVyeURlc2MsIGludCBlZmxhZ3MpCiAKIAlp ZiAoYXV0b19leHBsYWluX2VuYWJsZWQoKSkKIAl7Ci0JCS8qCi0JCSAqIFNldCB1cCB0byB0cmFj ayB0b3RhbCBlbGFwc2VkIHRpbWUgaW4gRXhlY3V0b3JSdW4uICBNYWtlIHN1cmUgdGhlCi0JCSAq IHNwYWNlIGlzIGFsbG9jYXRlZCBpbiB0aGUgcGVyLXF1ZXJ5IGNvbnRleHQgc28gaXQgd2lsbCBn byBhd2F5IGF0Ci0JCSAqIEV4ZWN1dG9yRW5kLgotCQkgKi8KKwkJLyogU2V0IHVwIHRvIHRyYWNr IHRvdGFsIGVsYXBzZWQgdGltZSBpbiBFeGVjdXRvclJ1bi4gKi8KIAkJaWYgKHF1ZXJ5RGVzYy0+ dG90YWx0aW1lID09IE5VTEwpCi0JCXsKLQkJCU1lbW9yeUNvbnRleHQgb2xkY3h0OwotCi0JCQlv bGRjeHQgPSBNZW1vcnlDb250ZXh0U3dpdGNoVG8ocXVlcnlEZXNjLT5lc3RhdGUtPmVzX3F1ZXJ5 X2N4dCk7Ci0JCQlxdWVyeURlc2MtPnRvdGFsdGltZSA9IEluc3RyQWxsb2MoSU5TVFJVTUVOVF9B TEwpOwotCQkJTWVtb3J5Q29udGV4dFN3aXRjaFRvKG9sZGN4dCk7Ci0JCX0KKwkJCXF1ZXJ5RGVz Yy0+dG90YWx0aW1lID0gSW5zdHJRdWVyeUFsbG9jKElOU1RSVU1FTlRfQUxMKTsKIAl9CiB9CiAK QEAgLTM4Miw3ICszNzIsNyBAQCBleHBsYWluX0V4ZWN1dG9yRW5kKFF1ZXJ5RGVzYyAqcXVlcnlE ZXNjKQogCQlvbGRjeHQgPSBNZW1vcnlDb250ZXh0U3dpdGNoVG8ocXVlcnlEZXNjLT5lc3RhdGUt PmVzX3F1ZXJ5X2N4dCk7CiAKIAkJLyogTG9nIHBsYW4gaWYgZHVyYXRpb24gaXMgZXhjZWVkZWQu ICovCi0JCW1zZWMgPSBJTlNUUl9USU1FX0dFVF9NSUxMSVNFQyhxdWVyeURlc2MtPnRvdGFsdGlt ZS0+dG90YWwpOworCQltc2VjID0gSU5TVFJfVElNRV9HRVRfTUlMTElTRUMocXVlcnlEZXNjLT50 b3RhbHRpbWUtPmluc3RyLnRvdGFsKTsKIAkJaWYgKG1zZWMgPj0gYXV0b19leHBsYWluX2xvZ19t aW5fZHVyYXRpb24pCiAJCXsKIAkJCUV4cGxhaW5TdGF0ZSAqZXMgPSBOZXdFeHBsYWluU3RhdGUo KTsKZGlmZiAtLWdpdCBhL2NvbnRyaWIvcGdfc3RhdF9zdGF0ZW1lbnRzL3BnX3N0YXRfc3RhdGVt ZW50cy5jIGIvY29udHJpYi9wZ19zdGF0X3N0YXRlbWVudHMvcGdfc3RhdF9zdGF0ZW1lbnRzLmMK aW5kZXggNjM5NzU3MDZiODcuLjc4ZjE1MThjOTQwIDEwMDY0NAotLS0gYS9jb250cmliL3BnX3N0 YXRfc3RhdGVtZW50cy9wZ19zdGF0X3N0YXRlbWVudHMuYworKysgYi9jb250cmliL3BnX3N0YXRf c3RhdGVtZW50cy9wZ19zdGF0X3N0YXRlbWVudHMuYwpAQCAtOTI5LDcgKzkyOSw3IEBAIHBnc3Nf cGxhbm5lcihRdWVyeSAqcGFyc2UsCiAJCX0KIAkJUEdfRklOQUxMWSgpOwogCQl7Ci0JCQlJbnN0 clN0b3AoJmluc3RyKTsKKwkJCUluc3RyU3RvcEZpbmFsaXplKCZpbnN0cik7CiAJCQluZXN0aW5n X2xldmVsLS07CiAJCX0KIAkJUEdfRU5EX1RSWSgpOwpAQCAtOTk0LDE5ICs5OTQsOSBAQCBwZ3Nz X0V4ZWN1dG9yU3RhcnQoUXVlcnlEZXNjICpxdWVyeURlc2MsIGludCBlZmxhZ3MpCiAJICovCiAJ aWYgKHBnc3NfZW5hYmxlZChuZXN0aW5nX2xldmVsKSAmJiBxdWVyeURlc2MtPnBsYW5uZWRzdG10 LT5xdWVyeUlkICE9IElOVDY0Q09OU1QoMCkpCiAJewotCQkvKgotCQkgKiBTZXQgdXAgdG8gdHJh Y2sgdG90YWwgZWxhcHNlZCB0aW1lIGluIEV4ZWN1dG9yUnVuLiAgTWFrZSBzdXJlIHRoZQotCQkg KiBzcGFjZSBpcyBhbGxvY2F0ZWQgaW4gdGhlIHBlci1xdWVyeSBjb250ZXh0IHNvIGl0IHdpbGwg Z28gYXdheSBhdAotCQkgKiBFeGVjdXRvckVuZC4KLQkJICovCisJCS8qIFNldCB1cCB0byB0cmFj ayB0b3RhbCBlbGFwc2VkIHRpbWUgaW4gRXhlY3V0b3JSdW4uICovCiAJCWlmIChxdWVyeURlc2Mt PnRvdGFsdGltZSA9PSBOVUxMKQotCQl7Ci0JCQlNZW1vcnlDb250ZXh0IG9sZGN4dDsKLQotCQkJ b2xkY3h0ID0gTWVtb3J5Q29udGV4dFN3aXRjaFRvKHF1ZXJ5RGVzYy0+ZXN0YXRlLT5lc19xdWVy eV9jeHQpOwotCQkJcXVlcnlEZXNjLT50b3RhbHRpbWUgPSBJbnN0ckFsbG9jKElOU1RSVU1FTlRf QUxMKTsKLQkJCU1lbW9yeUNvbnRleHRTd2l0Y2hUbyhvbGRjeHQpOwotCQl9CisJCQlxdWVyeURl c2MtPnRvdGFsdGltZSA9IEluc3RyUXVlcnlBbGxvYyhJTlNUUlVNRU5UX0FMTCk7CiAJfQogfQog CkBAIC0xMDY4LDEwICsxMDU4LDEwIEBAIHBnc3NfRXhlY3V0b3JFbmQoUXVlcnlEZXNjICpxdWVy eURlc2MpCiAJCQkJICAgcXVlcnlEZXNjLT5wbGFubmVkc3RtdC0+c3RtdF9sb2NhdGlvbiwKIAkJ CQkgICBxdWVyeURlc2MtPnBsYW5uZWRzdG10LT5zdG10X2xlbiwKIAkJCQkgICBQR1NTX0VYRUMs Ci0JCQkJICAgSU5TVFJfVElNRV9HRVRfTUlMTElTRUMocXVlcnlEZXNjLT50b3RhbHRpbWUtPnRv dGFsKSwKKwkJCQkgICBJTlNUUl9USU1FX0dFVF9NSUxMSVNFQyhxdWVyeURlc2MtPnRvdGFsdGlt ZS0+aW5zdHIudG90YWwpLAogCQkJCSAgIHF1ZXJ5RGVzYy0+ZXN0YXRlLT5lc190b3RhbF9wcm9j ZXNzZWQsCi0JCQkJICAgJnF1ZXJ5RGVzYy0+dG90YWx0aW1lLT5idWZ1c2FnZSwKLQkJCQkgICAm cXVlcnlEZXNjLT50b3RhbHRpbWUtPndhbHVzYWdlLAorCQkJCSAgICZxdWVyeURlc2MtPnRvdGFs dGltZS0+aW5zdHIuYnVmdXNhZ2UsCisJCQkJICAgJnF1ZXJ5RGVzYy0+dG90YWx0aW1lLT5pbnN0 ci53YWx1c2FnZSwKIAkJCQkgICBxdWVyeURlc2MtPmVzdGF0ZS0+ZXNfaml0ID8gJnF1ZXJ5RGVz Yy0+ZXN0YXRlLT5lc19qaXQtPmluc3RyIDogTlVMTCwKIAkJCQkgICBOVUxMLAogCQkJCSAgIHF1 ZXJ5RGVzYy0+ZXN0YXRlLT5lc19wYXJhbGxlbF93b3JrZXJzX3RvX2xhdW5jaCwKQEAgLTExNTUs NyArMTE0NSw3IEBAIHBnc3NfUHJvY2Vzc1V0aWxpdHkoUGxhbm5lZFN0bXQgKnBzdG10LCBjb25z dCBjaGFyICpxdWVyeVN0cmluZywKIAkJfQogCQlQR19GSU5BTExZKCk7CiAJCXsKLQkJCUluc3Ry U3RvcCgmaW5zdHIpOworCQkJSW5zdHJTdG9wRmluYWxpemUoJmluc3RyKTsKIAkJCW5lc3Rpbmdf bGV2ZWwtLTsKIAkJfQogCQlQR19FTkRfVFJZKCk7CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9h Y2Nlc3MvYnJpbi9icmluLmMgYi9zcmMvYmFja2VuZC9hY2Nlc3MvYnJpbi9icmluLmMKaW5kZXgg YmRiMzA3NTJlMDkuLjNhNTE3NmM3NmM3IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nlc3Mv YnJpbi9icmluLmMKKysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2JyaW4vYnJpbi5jCkBAIC0yNDM0 LDggKzI0MzQsOCBAQCBfYnJpbl9iZWdpbl9wYXJhbGxlbChCcmluQnVpbGRTdGF0ZSAqYnVpbGRz dGF0ZSwgUmVsYXRpb24gaGVhcCwgUmVsYXRpb24gaW5kZXgsCiAJICogYW5kIFBBUkFMTEVMX0tF WV9CVUZGRVJfVVNBR0UuCiAJICoKIAkgKiBJZiB0aGVyZSBhcmUgbm8gZXh0ZW5zaW9ucyBsb2Fk ZWQgdGhhdCBjYXJlLCB3ZSBjb3VsZCBza2lwIHRoaXMuICBXZQotCSAqIGhhdmUgbm8gd2F5IG9m IGtub3dpbmcgd2hldGhlciBhbnlvbmUncyBsb29raW5nIGF0IHBnV2FsVXNhZ2Ugb3IKLQkgKiBw Z0J1ZmZlclVzYWdlLCBzbyBkbyBpdCB1bmNvbmRpdGlvbmFsbHkuCisJICogaGF2ZSBubyB3YXkg b2Yga25vd2luZyB3aGV0aGVyIGFueW9uZSdzIGxvb2tpbmcgYXQgaW5zdHJ1bWVudGF0aW9uLCBz bworCSAqIGRvIGl0IHVuY29uZGl0aW9uYWxseS4KIAkgKi8KIAlzaG1fdG9jX2VzdGltYXRlX2No dW5rKCZwY3h0LT5lc3RpbWF0b3IsCiAJCQkJCQkgICBtdWxfc2l6ZShzaXplb2YoV2FsVXNhZ2Up LCBwY3h0LT5ud29ya2VycykpOwpAQCAtMjg4Nyw2ICsyODg3LDcgQEAgX2JyaW5fcGFyYWxsZWxf YnVpbGRfbWFpbihkc21fc2VnbWVudCAqc2VnLCBzaG1fdG9jICp0b2MpCiAJUmVsYXRpb24JaW5k ZXhSZWw7CiAJTE9DS01PREUJaGVhcExvY2ttb2RlOwogCUxPQ0tNT0RFCWluZGV4TG9ja21vZGU7 CisJUXVlcnlJbnN0cnVtZW50YXRpb24gKmluc3RyOwogCVdhbFVzYWdlICAgKndhbHVzYWdlOwog CUJ1ZmZlclVzYWdlICpidWZmZXJ1c2FnZTsKIAlpbnQJCQlzb3J0bWVtOwpAQCAtMjkzNiw3ICsy OTM3LDcgQEAgX2JyaW5fcGFyYWxsZWxfYnVpbGRfbWFpbihkc21fc2VnbWVudCAqc2VnLCBzaG1f dG9jICp0b2MpCiAJdHVwbGVzb3J0X2F0dGFjaF9zaGFyZWQoc2hhcmVkc29ydCwgc2VnKTsKIAog CS8qIFByZXBhcmUgdG8gdHJhY2sgYnVmZmVyIHVzYWdlIGR1cmluZyBwYXJhbGxlbCBleGVjdXRp b24gKi8KLQlJbnN0clN0YXJ0UGFyYWxsZWxRdWVyeSgpOworCWluc3RyID0gSW5zdHJTdGFydFBh cmFsbGVsUXVlcnkoKTsKIAogCS8qCiAJICogTWlnaHQgYXMgd2VsbCB1c2UgcmVsaWFibGUgZmln dXJlIHdoZW4gZG9saW5nIG91dCBtYWludGVuYW5jZV93b3JrX21lbQpAQCAtMjk1MSw3ICsyOTUy LDggQEAgX2JyaW5fcGFyYWxsZWxfYnVpbGRfbWFpbihkc21fc2VnbWVudCAqc2VnLCBzaG1fdG9j ICp0b2MpCiAJLyogUmVwb3J0IFdBTC9idWZmZXIgdXNhZ2UgZHVyaW5nIHBhcmFsbGVsIGV4ZWN1 dGlvbiAqLwogCWJ1ZmZlcnVzYWdlID0gc2htX3RvY19sb29rdXAodG9jLCBQQVJBTExFTF9LRVlf QlVGRkVSX1VTQUdFLCBmYWxzZSk7CiAJd2FsdXNhZ2UgPSBzaG1fdG9jX2xvb2t1cCh0b2MsIFBB UkFMTEVMX0tFWV9XQUxfVVNBR0UsIGZhbHNlKTsKLQlJbnN0ckVuZFBhcmFsbGVsUXVlcnkoJmJ1 ZmZlcnVzYWdlW1BhcmFsbGVsV29ya2VyTnVtYmVyXSwKKwlJbnN0ckVuZFBhcmFsbGVsUXVlcnko aW5zdHIsCisJCQkJCQkgICZidWZmZXJ1c2FnZVtQYXJhbGxlbFdvcmtlck51bWJlcl0sCiAJCQkJ CQkgICZ3YWx1c2FnZVtQYXJhbGxlbFdvcmtlck51bWJlcl0pOwogCiAJaW5kZXhfY2xvc2UoaW5k ZXhSZWwsIGluZGV4TG9ja21vZGUpOwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvYWNjZXNzL2dp bi9naW5pbnNlcnQuYyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9naW4vZ2luaW5zZXJ0LmMKaW5kZXgg OWQ4M2E0OTU3NzUuLjBkODBmNzJhMGIwIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nlc3Mv Z2luL2dpbmluc2VydC5jCisrKyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9naW4vZ2luaW5zZXJ0LmMK QEAgLTk5MSw4ICs5OTEsOCBAQCBfZ2luX2JlZ2luX3BhcmFsbGVsKEdpbkJ1aWxkU3RhdGUgKmJ1 aWxkc3RhdGUsIFJlbGF0aW9uIGhlYXAsIFJlbGF0aW9uIGluZGV4LAogCSAqIGFuZCBQQVJBTExF TF9LRVlfQlVGRkVSX1VTQUdFLgogCSAqCiAJICogSWYgdGhlcmUgYXJlIG5vIGV4dGVuc2lvbnMg bG9hZGVkIHRoYXQgY2FyZSwgd2UgY291bGQgc2tpcCB0aGlzLiAgV2UKLQkgKiBoYXZlIG5vIHdh eSBvZiBrbm93aW5nIHdoZXRoZXIgYW55b25lJ3MgbG9va2luZyBhdCBwZ1dhbFVzYWdlIG9yCi0J ICogcGdCdWZmZXJVc2FnZSwgc28gZG8gaXQgdW5jb25kaXRpb25hbGx5LgorCSAqIGhhdmUgbm8g d2F5IG9mIGtub3dpbmcgd2hldGhlciBhbnlvbmUncyBsb29raW5nIGF0IGluc3RydW1lbnRhdGlv biwgc28KKwkgKiBkbyBpdCB1bmNvbmRpdGlvbmFsbHkuCiAJICovCiAJc2htX3RvY19lc3RpbWF0 ZV9jaHVuaygmcGN4dC0+ZXN0aW1hdG9yLAogCQkJCQkJICAgbXVsX3NpemUoc2l6ZW9mKFdhbFVz YWdlKSwgcGN4dC0+bndvcmtlcnMpKTsKQEAgLTIxMTgsNiArMjExOCw3IEBAIF9naW5fcGFyYWxs ZWxfYnVpbGRfbWFpbihkc21fc2VnbWVudCAqc2VnLCBzaG1fdG9jICp0b2MpCiAJUmVsYXRpb24J aW5kZXhSZWw7CiAJTE9DS01PREUJaGVhcExvY2ttb2RlOwogCUxPQ0tNT0RFCWluZGV4TG9ja21v ZGU7CisJUXVlcnlJbnN0cnVtZW50YXRpb24gKmluc3RyOwogCVdhbFVzYWdlICAgKndhbHVzYWdl OwogCUJ1ZmZlclVzYWdlICpidWZmZXJ1c2FnZTsKIAlpbnQJCQlzb3J0bWVtOwpAQCAtMjE4Niw3 ICsyMTg3LDcgQEAgX2dpbl9wYXJhbGxlbF9idWlsZF9tYWluKGRzbV9zZWdtZW50ICpzZWcsIHNo bV90b2MgKnRvYykKIAl0dXBsZXNvcnRfYXR0YWNoX3NoYXJlZChzaGFyZWRzb3J0LCBzZWcpOwog CiAJLyogUHJlcGFyZSB0byB0cmFjayBidWZmZXIgdXNhZ2UgZHVyaW5nIHBhcmFsbGVsIGV4ZWN1 dGlvbiAqLwotCUluc3RyU3RhcnRQYXJhbGxlbFF1ZXJ5KCk7CisJaW5zdHIgPSBJbnN0clN0YXJ0 UGFyYWxsZWxRdWVyeSgpOwogCiAJLyoKIAkgKiBNaWdodCBhcyB3ZWxsIHVzZSByZWxpYWJsZSBm aWd1cmUgd2hlbiBkb2xpbmcgb3V0IG1haW50ZW5hbmNlX3dvcmtfbWVtCkBAIC0yMjAxLDcgKzIy MDIsOCBAQCBfZ2luX3BhcmFsbGVsX2J1aWxkX21haW4oZHNtX3NlZ21lbnQgKnNlZywgc2htX3Rv YyAqdG9jKQogCS8qIFJlcG9ydCBXQUwvYnVmZmVyIHVzYWdlIGR1cmluZyBwYXJhbGxlbCBleGVj dXRpb24gKi8KIAlidWZmZXJ1c2FnZSA9IHNobV90b2NfbG9va3VwKHRvYywgUEFSQUxMRUxfS0VZ X0JVRkZFUl9VU0FHRSwgZmFsc2UpOwogCXdhbHVzYWdlID0gc2htX3RvY19sb29rdXAodG9jLCBQ QVJBTExFTF9LRVlfV0FMX1VTQUdFLCBmYWxzZSk7Ci0JSW5zdHJFbmRQYXJhbGxlbFF1ZXJ5KCZi dWZmZXJ1c2FnZVtQYXJhbGxlbFdvcmtlck51bWJlcl0sCisJSW5zdHJFbmRQYXJhbGxlbFF1ZXJ5 KGluc3RyLAorCQkJCQkJICAmYnVmZmVydXNhZ2VbUGFyYWxsZWxXb3JrZXJOdW1iZXJdLAogCQkJ CQkJICAmd2FsdXNhZ2VbUGFyYWxsZWxXb3JrZXJOdW1iZXJdKTsKIAogCWluZGV4X2Nsb3NlKGlu ZGV4UmVsLCBpbmRleExvY2ttb2RlKTsKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9o ZWFwL3ZhY3V1bWxhenkuYyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYwpp bmRleCAzMGY1ODljOTIwNy4uMjkxZDlkNjdiYzIgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2Fj Y2Vzcy9oZWFwL3ZhY3V1bWxhenkuYworKysgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1 dW1sYXp5LmMKQEAgLTYzNyw3ICs2MzcsNyBAQCBoZWFwX3ZhY3V1bV9yZWwoUmVsYXRpb24gcmVs LCBjb25zdCBWYWN1dW1QYXJhbXMgKnBhcmFtcywKIAlUaW1lc3RhbXBUeiBzdGFydHRpbWUgPSAw OwogCVBnU3RhdF9Db3VudGVyIHN0YXJ0cmVhZHRpbWUgPSAwLAogCQkJCXN0YXJ0d3JpdGV0aW1l ID0gMDsKLQlJbnN0cnVtZW50YXRpb24gKmluc3RyID0gTlVMTDsKKwlRdWVyeUluc3RydW1lbnRh dGlvbiAqaW5zdHIgPSBOVUxMOwogCUVycm9yQ29udGV4dENhbGxiYWNrIGVycmNhbGxiYWNrOwog CWNoYXIJICAqKmluZG5hbWVzID0gTlVMTDsKIAlTaXplCQlkZWFkX2l0ZW1zX21heF9ieXRlcyA9 IDA7CkBAIC02NTMsOCArNjUzLDggQEAgaGVhcF92YWN1dW1fcmVsKFJlbGF0aW9uIHJlbCwgY29u c3QgVmFjdXVtUGFyYW1zICpwYXJhbXMsCiAJCQlzdGFydHJlYWR0aW1lID0gcGdTdGF0QmxvY2tS ZWFkVGltZTsKIAkJCXN0YXJ0d3JpdGV0aW1lID0gcGdTdGF0QmxvY2tXcml0ZVRpbWU7CiAJCX0K LQkJaW5zdHIgPSBJbnN0ckFsbG9jKElOU1RSVU1FTlRfQlVGRkVSUyB8IElOU1RSVU1FTlRfV0FM KTsKLQkJSW5zdHJTdGFydChpbnN0cik7CisJCWluc3RyID0gSW5zdHJRdWVyeUFsbG9jKElOU1RS VU1FTlRfQlVGRkVSUyB8IElOU1RSVU1FTlRfV0FMKTsKKwkJSW5zdHJRdWVyeVN0YXJ0KGluc3Ry KTsKIAl9CiAKIAkvKiBVc2VkIGZvciBpbnN0cnVtZW50YXRpb24gYW5kIHN0YXRzIHJlcG9ydCAq LwpAQCAtOTg1LDcgKzk4NSw3IEBAIGhlYXBfdmFjdXVtX3JlbChSZWxhdGlvbiByZWwsIGNvbnN0 IFZhY3V1bVBhcmFtcyAqcGFyYW1zLAogCXsKIAkJVGltZXN0YW1wVHogZW5kdGltZSA9IEdldEN1 cnJlbnRUaW1lc3RhbXAoKTsKIAotCQlJbnN0clN0b3AoaW5zdHIpOworCQlJbnN0clF1ZXJ5U3Rv cEZpbmFsaXplKGluc3RyKTsKIAogCQlpZiAodmVyYm9zZSB8fCBwYXJhbXMtPmxvZ192YWN1dW1f bWluX2R1cmF0aW9uID09IDAgfHwKIAkJCVRpbWVzdGFtcERpZmZlcmVuY2VFeGNlZWRzKHN0YXJ0 dGltZSwgZW5kdGltZSwKQEAgLTEwMDEsOCArMTAwMSw4IEBAIGhlYXBfdmFjdXVtX3JlbChSZWxh dGlvbiByZWwsIGNvbnN0IFZhY3V1bVBhcmFtcyAqcGFyYW1zLAogCQkJaW50NjQJCXRvdGFsX2Js a3NfaGl0OwogCQkJaW50NjQJCXRvdGFsX2Jsa3NfcmVhZDsKIAkJCWludDY0CQl0b3RhbF9ibGtz X2RpcnRpZWQ7Ci0JCQlCdWZmZXJVc2FnZSBidWZmZXJ1c2FnZSA9IGluc3RyLT5idWZ1c2FnZTsK LQkJCVdhbFVzYWdlCXdhbHVzYWdlID0gaW5zdHItPndhbHVzYWdlOworCQkJQnVmZmVyVXNhZ2Ug YnVmZmVydXNhZ2UgPSBpbnN0ci0+aW5zdHIuYnVmdXNhZ2U7CisJCQlXYWxVc2FnZQl3YWx1c2Fn ZSA9IGluc3RyLT5pbnN0ci53YWx1c2FnZTsKIAogCQkJVGltZXN0YW1wRGlmZmVyZW5jZShzdGFy dHRpbWUsIGVuZHRpbWUsICZzZWNzX2R1ciwgJnVzZWNzX2R1cik7CiAKZGlmZiAtLWdpdCBhL3Ny Yy9iYWNrZW5kL2FjY2Vzcy9uYnRyZWUvbmJ0c29ydC5jIGIvc3JjL2JhY2tlbmQvYWNjZXNzL25i dHJlZS9uYnRzb3J0LmMKaW5kZXggNzU2ZGZhM2RjZjQuLjJkN2I3Y2VmOTEyIDEwMDY0NAotLS0g YS9zcmMvYmFja2VuZC9hY2Nlc3MvbmJ0cmVlL25idHNvcnQuYworKysgYi9zcmMvYmFja2VuZC9h Y2Nlc3MvbmJ0cmVlL25idHNvcnQuYwpAQCAtMTQ2Niw4ICsxNDY2LDggQEAgX2J0X2JlZ2luX3Bh cmFsbGVsKEJUQnVpbGRTdGF0ZSAqYnVpbGRzdGF0ZSwgYm9vbCBpc2NvbmN1cnJlbnQsIGludCBy ZXF1ZXN0KQogCSAqIGFuZCBQQVJBTExFTF9LRVlfQlVGRkVSX1VTQUdFLgogCSAqCiAJICogSWYg dGhlcmUgYXJlIG5vIGV4dGVuc2lvbnMgbG9hZGVkIHRoYXQgY2FyZSwgd2UgY291bGQgc2tpcCB0 aGlzLiAgV2UKLQkgKiBoYXZlIG5vIHdheSBvZiBrbm93aW5nIHdoZXRoZXIgYW55b25lJ3MgbG9v a2luZyBhdCBwZ1dhbFVzYWdlIG9yCi0JICogcGdCdWZmZXJVc2FnZSwgc28gZG8gaXQgdW5jb25k aXRpb25hbGx5LgorCSAqIGhhdmUgbm8gd2F5IG9mIGtub3dpbmcgd2hldGhlciBhbnlvbmUncyBs b29raW5nIGF0IGluc3RydW1lbnRhdGlvbiwgc28KKwkgKiBkbyBpdCB1bmNvbmRpdGlvbmFsbHku CiAJICovCiAJc2htX3RvY19lc3RpbWF0ZV9jaHVuaygmcGN4dC0+ZXN0aW1hdG9yLAogCQkJCQkJ ICAgbXVsX3NpemUoc2l6ZW9mKFdhbFVzYWdlKSwgcGN4dC0+bndvcmtlcnMpKTsKQEAgLTE3NTMs NiArMTc1Myw3IEBAIF9idF9wYXJhbGxlbF9idWlsZF9tYWluKGRzbV9zZWdtZW50ICpzZWcsIHNo bV90b2MgKnRvYykKIAlSZWxhdGlvbglpbmRleFJlbDsKIAlMT0NLTU9ERQloZWFwTG9ja21vZGU7 CiAJTE9DS01PREUJaW5kZXhMb2NrbW9kZTsKKwlRdWVyeUluc3RydW1lbnRhdGlvbiAqaW5zdHI7 CiAJV2FsVXNhZ2UgICAqd2FsdXNhZ2U7CiAJQnVmZmVyVXNhZ2UgKmJ1ZmZlcnVzYWdlOwogCWlu dAkJCXNvcnRtZW07CkBAIC0xODI4LDcgKzE4MjksNyBAQCBfYnRfcGFyYWxsZWxfYnVpbGRfbWFp bihkc21fc2VnbWVudCAqc2VnLCBzaG1fdG9jICp0b2MpCiAJfQogCiAJLyogUHJlcGFyZSB0byB0 cmFjayBidWZmZXIgdXNhZ2UgZHVyaW5nIHBhcmFsbGVsIGV4ZWN1dGlvbiAqLwotCUluc3RyU3Rh cnRQYXJhbGxlbFF1ZXJ5KCk7CisJaW5zdHIgPSBJbnN0clN0YXJ0UGFyYWxsZWxRdWVyeSgpOwog CiAJLyogUGVyZm9ybSBzb3J0aW5nIG9mIHNwb29sLCBhbmQgcG9zc2libHkgYSBzcG9vbDIgKi8K IAlzb3J0bWVtID0gbWFpbnRlbmFuY2Vfd29ya19tZW0gLyBidHNoYXJlZC0+c2NhbnR1cGxlc29y dHN0YXRlczsKQEAgLTE4MzgsNyArMTgzOSw4IEBAIF9idF9wYXJhbGxlbF9idWlsZF9tYWluKGRz bV9zZWdtZW50ICpzZWcsIHNobV90b2MgKnRvYykKIAkvKiBSZXBvcnQgV0FML2J1ZmZlciB1c2Fn ZSBkdXJpbmcgcGFyYWxsZWwgZXhlY3V0aW9uICovCiAJYnVmZmVydXNhZ2UgPSBzaG1fdG9jX2xv b2t1cCh0b2MsIFBBUkFMTEVMX0tFWV9CVUZGRVJfVVNBR0UsIGZhbHNlKTsKIAl3YWx1c2FnZSA9 IHNobV90b2NfbG9va3VwKHRvYywgUEFSQUxMRUxfS0VZX1dBTF9VU0FHRSwgZmFsc2UpOwotCUlu c3RyRW5kUGFyYWxsZWxRdWVyeSgmYnVmZmVydXNhZ2VbUGFyYWxsZWxXb3JrZXJOdW1iZXJdLAor CUluc3RyRW5kUGFyYWxsZWxRdWVyeShpbnN0ciwKKwkJCQkJCSAgJmJ1ZmZlcnVzYWdlW1BhcmFs bGVsV29ya2VyTnVtYmVyXSwKIAkJCQkJCSAgJndhbHVzYWdlW1BhcmFsbGVsV29ya2VyTnVtYmVy XSk7CiAKICNpZmRlZiBCVFJFRV9CVUlMRF9TVEFUUwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQv Y29tbWFuZHMvYW5hbHl6ZS5jIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvYW5hbHl6ZS5jCmluZGV4 IDg0NzJmYzBjMjgwLi4xMGY4YTJkYzgxYyAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFu ZHMvYW5hbHl6ZS5jCisrKyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL2FuYWx5emUuYwpAQCAtMzA5 LDcgKzMwOSw3IEBAIGRvX2FuYWx5emVfcmVsKFJlbGF0aW9uIG9uZXJlbCwgY29uc3QgVmFjdXVt UGFyYW1zICpwYXJhbXMsCiAJT2lkCQkJc2F2ZV91c2VyaWQ7CiAJaW50CQkJc2F2ZV9zZWNfY29u dGV4dDsKIAlpbnQJCQlzYXZlX25lc3RsZXZlbDsKLQlJbnN0cnVtZW50YXRpb24gKmluc3RyID0g TlVMTDsKKwlRdWVyeUluc3RydW1lbnRhdGlvbiAqaW5zdHIgPSBOVUxMOwogCVBnU3RhdF9Db3Vu dGVyIHN0YXJ0cmVhZHRpbWUgPSAwOwogCVBnU3RhdF9Db3VudGVyIHN0YXJ0d3JpdGV0aW1lID0g MDsKIApAQCAtMzYxLDggKzM2MSw4IEBAIGRvX2FuYWx5emVfcmVsKFJlbGF0aW9uIG9uZXJlbCwg Y29uc3QgVmFjdXVtUGFyYW1zICpwYXJhbXMsCiAKIAkJcGdfcnVzYWdlX2luaXQoJnJ1MCk7CiAK LQkJaW5zdHIgPSBJbnN0ckFsbG9jKElOU1RSVU1FTlRfQlVGRkVSUyB8IElOU1RSVU1FTlRfV0FM KTsKLQkJSW5zdHJTdGFydChpbnN0cik7CisJCWluc3RyID0gSW5zdHJRdWVyeUFsbG9jKElOU1RS VU1FTlRfQlVGRkVSUyB8IElOU1RSVU1FTlRfV0FMKTsKKwkJSW5zdHJRdWVyeVN0YXJ0KGluc3Ry KTsKIAl9CiAKIAkvKiBVc2VkIGZvciBpbnN0cnVtZW50YXRpb24gYW5kIHN0YXRzIHJlcG9ydCAq LwpAQCAtNzQzLDcgKzc0Myw3IEBAIGRvX2FuYWx5emVfcmVsKFJlbGF0aW9uIG9uZXJlbCwgY29u c3QgVmFjdXVtUGFyYW1zICpwYXJhbXMsCiAJewogCQlUaW1lc3RhbXBUeiBlbmR0aW1lID0gR2V0 Q3VycmVudFRpbWVzdGFtcCgpOwogCi0JCUluc3RyU3RvcChpbnN0cik7CisJCUluc3RyUXVlcnlT dG9wRmluYWxpemUoaW5zdHIpOwogCiAJCWlmICh2ZXJib3NlIHx8IHBhcmFtcy0+bG9nX2FuYWx5 emVfbWluX2R1cmF0aW9uID09IDAgfHwKIAkJCVRpbWVzdGFtcERpZmZlcmVuY2VFeGNlZWRzKHN0 YXJ0dGltZSwgZW5kdGltZSwKQEAgLTc1Nyw4ICs3NTcsOCBAQCBkb19hbmFseXplX3JlbChSZWxh dGlvbiBvbmVyZWwsIGNvbnN0IFZhY3V1bVBhcmFtcyAqcGFyYW1zLAogCQkJaW50NjQJCXRvdGFs X2Jsa3NfaGl0OwogCQkJaW50NjQJCXRvdGFsX2Jsa3NfcmVhZDsKIAkJCWludDY0CQl0b3RhbF9i bGtzX2RpcnRpZWQ7Ci0JCQlCdWZmZXJVc2FnZSBidWZ1c2FnZSA9IGluc3RyLT5idWZ1c2FnZTsK LQkJCVdhbFVzYWdlCXdhbHVzYWdlID0gaW5zdHItPndhbHVzYWdlOworCQkJQnVmZmVyVXNhZ2Ug YnVmdXNhZ2UgPSBpbnN0ci0+aW5zdHIuYnVmdXNhZ2U7CisJCQlXYWxVc2FnZQl3YWx1c2FnZSA9 IGluc3RyLT5pbnN0ci53YWx1c2FnZTsKIAogCQkJdG90YWxfYmxrc19oaXQgPSBidWZ1c2FnZS5z aGFyZWRfYmxrc19oaXQgKwogCQkJCWJ1ZnVzYWdlLmxvY2FsX2Jsa3NfaGl0OwpkaWZmIC0tZ2l0 IGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvZXhwbGFpbi5jIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMv ZXhwbGFpbi5jCmluZGV4IDc5YmQ0ZDlkNjllLi45ZmMzOWNhYmRmOCAxMDA2NDQKLS0tIGEvc3Jj L2JhY2tlbmQvY29tbWFuZHMvZXhwbGFpbi5jCisrKyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL2V4 cGxhaW4uYwpAQCAtMzI0LDcgKzMyNCw3IEBAIHN0YW5kYXJkX0V4cGxhaW5PbmVRdWVyeShRdWVy eSAqcXVlcnksIGludCBjdXJzb3JPcHRpb25zLAogCQkJCQkJIFF1ZXJ5RW52aXJvbm1lbnQgKnF1 ZXJ5RW52KQogewogCVBsYW5uZWRTdG10ICpwbGFuOwotCUluc3RydW1lbnRhdGlvbiBwbGFuX2lu c3RyID0gezB9OworCVF1ZXJ5SW5zdHJ1bWVudGF0aW9uICpwbGFuX2luc3RyID0gTlVMTDsKIAlN ZW1vcnlDb250ZXh0Q291bnRlcnMgbWVtX2NvdW50ZXJzOwogCU1lbW9yeUNvbnRleHQgcGxhbm5l cl9jdHggPSBOVUxMOwogCU1lbW9yeUNvbnRleHQgc2F2ZWRfY3R4ID0gTlVMTDsKQEAgLTMzMyw3 ICszMzMsNyBAQCBzdGFuZGFyZF9FeHBsYWluT25lUXVlcnkoUXVlcnkgKnF1ZXJ5LCBpbnQgY3Vy c29yT3B0aW9ucywKIAlpZiAoZXMtPmJ1ZmZlcnMpCiAJCWluc3RydW1lbnRfb3B0aW9ucyB8PSBJ TlNUUlVNRU5UX0JVRkZFUlM7CiAKLQlJbnN0ckluaXRPcHRpb25zKCZwbGFuX2luc3RyLCBpbnN0 cnVtZW50X29wdGlvbnMpOworCXBsYW5faW5zdHIgPSBJbnN0clF1ZXJ5QWxsb2MoaW5zdHJ1bWVu dF9vcHRpb25zKTsKIAogCWlmIChlcy0+bWVtb3J5KQogCXsKQEAgLTM1MSwxMiArMzUxLDEyIEBA IHN0YW5kYXJkX0V4cGxhaW5PbmVRdWVyeShRdWVyeSAqcXVlcnksIGludCBjdXJzb3JPcHRpb25z LAogCQlzYXZlZF9jdHggPSBNZW1vcnlDb250ZXh0U3dpdGNoVG8ocGxhbm5lcl9jdHgpOwogCX0K IAotCUluc3RyU3RhcnQoJnBsYW5faW5zdHIpOworCUluc3RyUXVlcnlTdGFydChwbGFuX2luc3Ry KTsKIAogCS8qIHBsYW4gdGhlIHF1ZXJ5ICovCiAJcGxhbiA9IHBnX3BsYW5fcXVlcnkocXVlcnks IHF1ZXJ5U3RyaW5nLCBjdXJzb3JPcHRpb25zLCBwYXJhbXMsIGVzKTsKIAotCUluc3RyU3RvcCgm cGxhbl9pbnN0cik7CisJSW5zdHJRdWVyeVN0b3BGaW5hbGl6ZShwbGFuX2luc3RyKTsKIAogCWlm IChlcy0+bWVtb3J5KQogCXsKQEAgLTM2Niw3ICszNjYsNyBAQCBzdGFuZGFyZF9FeHBsYWluT25l UXVlcnkoUXVlcnkgKnF1ZXJ5LCBpbnQgY3Vyc29yT3B0aW9ucywKIAogCS8qIHJ1biBpdCAoaWYg bmVlZGVkKSBhbmQgcHJvZHVjZSBvdXRwdXQgKi8KIAlFeHBsYWluT25lUGxhbihwbGFuLCBpbnRv LCBlcywgcXVlcnlTdHJpbmcsIHBhcmFtcywgcXVlcnlFbnYsCi0JCQkJICAgJnBsYW5faW5zdHIu dG90YWwsIChlcy0+YnVmZmVycyA/ICZwbGFuX2luc3RyLmJ1ZnVzYWdlIDogTlVMTCksCisJCQkJ ICAgJnBsYW5faW5zdHItPmluc3RyLnRvdGFsLCAoZXMtPmJ1ZmZlcnMgPyAmcGxhbl9pbnN0ci0+ aW5zdHIuYnVmdXNhZ2UgOiBOVUxMKSwKIAkJCQkgICBlcy0+bWVtb3J5ID8gJm1lbV9jb3VudGVy cyA6IE5VTEwpOwogfQogCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9jb21tYW5kcy9leHBsYWlu X2RyLmMgYi9zcmMvYmFja2VuZC9jb21tYW5kcy9leHBsYWluX2RyLmMKaW5kZXggMzRmZTRmOGY2 ZGQuLjljMWIzMGZiNzViIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9jb21tYW5kcy9leHBsYWlu X2RyLmMKKysrIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvZXhwbGFpbl9kci5jCkBAIC0xMTMsNyAr MTEzLDcgQEAgc2VyaWFsaXplQW5hbHl6ZVJlY2VpdmUoVHVwbGVUYWJsZVNsb3QgKnNsb3QsIERl c3RSZWNlaXZlciAqc2VsZikKIAlJbnN0cnVtZW50YXRpb24gKmluc3RyID0gJm15U3RhdGUtPm1l dHJpY3MuaW5zdHI7CiAKIAkvKiBvbmx5IG1lYXN1cmUgdGltZSwgYnVmZmVycyBpZiByZXF1ZXN0 ZWQgKi8KLQlpZiAoaW5zdHItPm5lZWRfdGltZXIgfHwgaW5zdHItPm5lZWRfYnVmdXNhZ2UpCisJ aWYgKGluc3RyLT5uZWVkX3RpbWVyIHx8IGluc3RyLT5uZWVkX3N0YWNrKQogCQlJbnN0clN0YXJ0 KGluc3RyKTsKIAogCS8qIFNldCBvciB1cGRhdGUgbXkgZGVyaXZlZCBhdHRyaWJ1dGUgaW5mbywg aWYgbmVlZGVkICovCkBAIC0xODMsNyArMTgzLDcgQEAgc2VyaWFsaXplQW5hbHl6ZVJlY2VpdmUo VHVwbGVUYWJsZVNsb3QgKnNsb3QsIERlc3RSZWNlaXZlciAqc2VsZikKIAlNZW1vcnlDb250ZXh0 UmVzZXQobXlTdGF0ZS0+dG1wY29udGV4dCk7CiAKIAkvKiBTdG9wIHBlci10dXBsZSBtZWFzdXJl bWVudCAqLwotCWlmIChpbnN0ci0+bmVlZF90aW1lciB8fCBpbnN0ci0+bmVlZF9idWZ1c2FnZSkK KwlpZiAoaW5zdHItPm5lZWRfdGltZXIgfHwgaW5zdHItPm5lZWRfc3RhY2spCiAJCUluc3RyU3Rv cChpbnN0cik7CiAKIAlyZXR1cm4gdHJ1ZTsKQEAgLTI0MSw2ICsyNDEsOCBAQCBzZXJpYWxpemVB bmFseXplU2h1dGRvd24oRGVzdFJlY2VpdmVyICpzZWxmKQogewogCVNlcmlhbGl6ZURlc3RSZWNl aXZlciAqcmVjZWl2ZXIgPSAoU2VyaWFsaXplRGVzdFJlY2VpdmVyICopIHNlbGY7CiAKKwlJbnN0 ckZpbmFsaXplQ2hpbGQoJnJlY2VpdmVyLT5tZXRyaWNzLmluc3RyLCBpbnN0cl9zdGFjay5jdXJy ZW50KTsKKwogCWlmIChyZWNlaXZlci0+ZmluZm9zKQogCQlwZnJlZShyZWNlaXZlci0+ZmluZm9z KTsKIAlyZWNlaXZlci0+ZmluZm9zID0gTlVMTDsKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2Nv bW1hbmRzL3ByZXBhcmUuYyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ByZXBhcmUuYwppbmRleCBi ZjlmMmViNjE0OS4uZWU4MTEzNTc1ODggMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2NvbW1hbmRz L3ByZXBhcmUuYworKysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy9wcmVwYXJlLmMKQEAgLTU4MSw3 ICs1ODEsNyBAQCBFeHBsYWluRXhlY3V0ZVF1ZXJ5KEV4ZWN1dGVTdG10ICpleGVjc3RtdCwgSW50 b0NsYXVzZSAqaW50bywgRXhwbGFpblN0YXRlICplcywKIAlMaXN0Q2VsbCAgICpwOwogCVBhcmFt TGlzdEluZm8gcGFyYW1MSSA9IE5VTEw7CiAJRVN0YXRlCSAgICplc3RhdGUgPSBOVUxMOwotCUlu c3RydW1lbnRhdGlvbiBwbGFuX2luc3RyID0gezB9OworCVF1ZXJ5SW5zdHJ1bWVudGF0aW9uICpw bGFuX2luc3RyID0gTlVMTDsKIAlpbnQJCQlpbnN0cnVtZW50X29wdGlvbnMgPSBJTlNUUlVNRU5U X1RJTUVSOwogCU1lbW9yeUNvbnRleHRDb3VudGVycyBtZW1fY291bnRlcnM7CiAJTWVtb3J5Q29u dGV4dCBwbGFubmVyX2N0eCA9IE5VTEw7CkBAIC01OTAsNyArNTkwLDcgQEAgRXhwbGFpbkV4ZWN1 dGVRdWVyeShFeGVjdXRlU3RtdCAqZXhlY3N0bXQsIEludG9DbGF1c2UgKmludG8sIEV4cGxhaW5T dGF0ZSAqZXMsCiAJaWYgKGVzLT5idWZmZXJzKQogCQlpbnN0cnVtZW50X29wdGlvbnMgfD0gSU5T VFJVTUVOVF9CVUZGRVJTOwogCi0JSW5zdHJJbml0T3B0aW9ucygmcGxhbl9pbnN0ciwgaW5zdHJ1 bWVudF9vcHRpb25zKTsKKwlwbGFuX2luc3RyID0gSW5zdHJRdWVyeUFsbG9jKGluc3RydW1lbnRf b3B0aW9ucyk7CiAKIAlpZiAoZXMtPm1lbW9yeSkKIAl7CkBAIC02MDIsNyArNjAyLDcgQEAgRXhw bGFpbkV4ZWN1dGVRdWVyeShFeGVjdXRlU3RtdCAqZXhlY3N0bXQsIEludG9DbGF1c2UgKmludG8s IEV4cGxhaW5TdGF0ZSAqZXMsCiAJCXNhdmVkX2N0eCA9IE1lbW9yeUNvbnRleHRTd2l0Y2hUbyhw bGFubmVyX2N0eCk7CiAJfQogCi0JSW5zdHJTdGFydCgmcGxhbl9pbnN0cik7CisJSW5zdHJRdWVy eVN0YXJ0KHBsYW5faW5zdHIpOwogCiAJLyogTG9vayBpdCB1cCBpbiB0aGUgaGFzaCB0YWJsZSAq LwogCWVudHJ5ID0gRmV0Y2hQcmVwYXJlZFN0YXRlbWVudChleGVjc3RtdC0+bmFtZSwgdHJ1ZSk7 CkBAIC02MzcsNyArNjM3LDcgQEAgRXhwbGFpbkV4ZWN1dGVRdWVyeShFeGVjdXRlU3RtdCAqZXhl Y3N0bXQsIEludG9DbGF1c2UgKmludG8sIEV4cGxhaW5TdGF0ZSAqZXMsCiAJY3BsYW4gPSBHZXRD YWNoZWRQbGFuKGVudHJ5LT5wbGFuc291cmNlLCBwYXJhbUxJLAogCQkJCQkJICBDdXJyZW50UmVz b3VyY2VPd25lciwgcHN0YXRlLT5wX3F1ZXJ5RW52KTsKIAotCUluc3RyU3RvcCgmcGxhbl9pbnN0 cik7CisJSW5zdHJRdWVyeVN0b3BGaW5hbGl6ZShwbGFuX2luc3RyKTsKIAogCWlmIChlcy0+bWVt b3J5KQogCXsKQEAgLTY1NCw3ICs2NTQsNyBAQCBFeHBsYWluRXhlY3V0ZVF1ZXJ5KEV4ZWN1dGVT dG10ICpleGVjc3RtdCwgSW50b0NsYXVzZSAqaW50bywgRXhwbGFpblN0YXRlICplcywKIAogCQlp ZiAocHN0bXQtPmNvbW1hbmRUeXBlICE9IENNRF9VVElMSVRZKQogCQkJRXhwbGFpbk9uZVBsYW4o cHN0bXQsIGludG8sIGVzLCBxdWVyeV9zdHJpbmcsIHBhcmFtTEksIHBzdGF0ZS0+cF9xdWVyeUVu diwKLQkJCQkJCSAgICZwbGFuX2luc3RyLnRvdGFsLCAoZXMtPmJ1ZmZlcnMgPyAmcGxhbl9pbnN0 ci5idWZ1c2FnZSA6IE5VTEwpLAorCQkJCQkJICAgJnBsYW5faW5zdHItPmluc3RyLnRvdGFsLCAo ZXMtPmJ1ZmZlcnMgPyAmcGxhbl9pbnN0ci0+aW5zdHIuYnVmdXNhZ2UgOiBOVUxMKSwKIAkJCQkJ CSAgIGVzLT5tZW1vcnkgPyAmbWVtX2NvdW50ZXJzIDogTlVMTCk7CiAJCWVsc2UKIAkJCUV4cGxh aW5PbmVVdGlsaXR5KHBzdG10LT51dGlsaXR5U3RtdCwgaW50bywgZXMsIHBzdGF0ZSwgcGFyYW1M SSk7CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9jb21tYW5kcy90YWJsZWNtZHMuYyBiL3NyYy9i YWNrZW5kL2NvbW1hbmRzL3RhYmxlY21kcy5jCmluZGV4IDBjZTJlODFmOWMyLi5mNzJjMWFjNTIx YSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdGFibGVjbWRzLmMKKysrIGIvc3Jj L2JhY2tlbmQvY29tbWFuZHMvdGFibGVjbWRzLmMKQEAgLTIxMzksNyArMjEzOSw3IEBAIEV4ZWN1 dGVUcnVuY2F0ZUd1dHMoTGlzdCAqZXhwbGljaXRfcmVscywKIAkJCQkJCSAgcmVsLAogCQkJCQkJ ICAwLAkvKiBkdW1teSByYW5nZXRhYmxlIGluZGV4ICovCiAJCQkJCQkgIE5VTEwsCi0JCQkJCQkg IDApOworCQkJCQkJICBOVUxMKTsKIAkJZXN0YXRlLT5lc19vcGVuZWRfcmVzdWx0X3JlbGF0aW9u cyA9CiAJCQlsYXBwZW5kKGVzdGF0ZS0+ZXNfb3BlbmVkX3Jlc3VsdF9yZWxhdGlvbnMsIHJlc3Vs dFJlbEluZm8pOwogCQlyZXN1bHRSZWxJbmZvKys7CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9j b21tYW5kcy90cmlnZ2VyLmMgYi9zcmMvYmFja2VuZC9jb21tYW5kcy90cmlnZ2VyLmMKaW5kZXgg NGQ0ZTk2YTUzMDIuLmI4Yjg4NDAzNDViIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9jb21tYW5k cy90cmlnZ2VyLmMKKysrIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvdHJpZ2dlci5jCkBAIC05Myw2 ICs5Myw3IEBAIHN0YXRpYyBIZWFwVHVwbGUgRXhlY0NhbGxUcmlnZ2VyRnVuYyhUcmlnZ2VyRGF0 YSAqdHJpZ2RhdGEsCiAJCQkJCQkJCQkgaW50IHRnaW5keCwKIAkJCQkJCQkJCSBGbWdySW5mbyAq ZmluZm8sCiAJCQkJCQkJCQkgVHJpZ2dlckluc3RydW1lbnRhdGlvbiAqaW5zdHIsCisJCQkJCQkJ CQkgUXVlcnlJbnN0cnVtZW50YXRpb24gKnFpbnN0ciwKIAkJCQkJCQkJCSBNZW1vcnlDb250ZXh0 IHBlcl90dXBsZV9jb250ZXh0KTsKIHN0YXRpYyB2b2lkIEFmdGVyVHJpZ2dlclNhdmVFdmVudChF U3RhdGUgKmVzdGF0ZSwgUmVzdWx0UmVsSW5mbyAqcmVsaW5mbywKIAkJCQkJCQkJICBSZXN1bHRS ZWxJbmZvICpzcmNfcGFydGluZm8sCkBAIC0yMzEyLDYgKzIzMTMsNyBAQCBFeGVjQ2FsbFRyaWdn ZXJGdW5jKFRyaWdnZXJEYXRhICp0cmlnZGF0YSwKIAkJCQkJaW50IHRnaW5keCwKIAkJCQkJRm1n ckluZm8gKmZpbmZvLAogCQkJCQlUcmlnZ2VySW5zdHJ1bWVudGF0aW9uICppbnN0ciwKKwkJCQkJ UXVlcnlJbnN0cnVtZW50YXRpb24gKnFpbnN0ciwKIAkJCQkJTWVtb3J5Q29udGV4dCBwZXJfdHVw bGVfY29udGV4dCkKIHsKIAlMT0NBTF9GQ0lORk8oZmNpbmZvLCAwKTsKQEAgLTIzNDYsNyArMjM0 OCw3IEBAIEV4ZWNDYWxsVHJpZ2dlckZ1bmMoVHJpZ2dlckRhdGEgKnRyaWdkYXRhLAogCSAqIElm IGRvaW5nIEVYUExBSU4gQU5BTFlaRSwgc3RhcnQgY2hhcmdpbmcgdGltZSB0byB0aGlzIHRyaWdn ZXIuCiAJICovCiAJaWYgKGluc3RyKQotCQlJbnN0clN0YXJ0VHJpZ2dlcihpbnN0ciArIHRnaW5k eCk7CisJCUluc3RyU3RhcnRUcmlnZ2VyKHFpbnN0ciwgaW5zdHIgKyB0Z2luZHgpOwogCiAJLyoK IAkgKiBEbyB0aGUgZnVuY3Rpb24gZXZhbHVhdGlvbiBpbiB0aGUgcGVyLXR1cGxlIG1lbW9yeSBj b250ZXh0LCBzbyB0aGF0CkBAIC0yNDQxLDYgKzI0NDMsNyBAQCBFeGVjQlNJbnNlcnRUcmlnZ2Vy cyhFU3RhdGUgKmVzdGF0ZSwgUmVzdWx0UmVsSW5mbyAqcmVsaW5mbykKIAkJCQkJCQkJCSAgIGks CiAJCQkJCQkJCQkgICByZWxpbmZvLT5yaV9UcmlnRnVuY3Rpb25zLAogCQkJCQkJCQkJICAgcmVs aW5mby0+cmlfVHJpZ0luc3RydW1lbnQsCisJCQkJCQkJCQkgICBlc3RhdGUtPmVzX2luc3RydW1l bnQsCiAJCQkJCQkJCQkgICBHZXRQZXJUdXBsZU1lbW9yeUNvbnRleHQoZXN0YXRlKSk7CiAKIAkJ aWYgKG5ld3R1cGxlKQpAQCAtMjUwMiw2ICsyNTA1LDcgQEAgRXhlY0JSSW5zZXJ0VHJpZ2dlcnMo RVN0YXRlICplc3RhdGUsIFJlc3VsdFJlbEluZm8gKnJlbGluZm8sCiAJCQkJCQkJCQkgICBpLAog CQkJCQkJCQkJICAgcmVsaW5mby0+cmlfVHJpZ0Z1bmN0aW9ucywKIAkJCQkJCQkJCSAgIHJlbGlu Zm8tPnJpX1RyaWdJbnN0cnVtZW50LAorCQkJCQkJCQkJICAgZXN0YXRlLT5lc19pbnN0cnVtZW50 LAogCQkJCQkJCQkJICAgR2V0UGVyVHVwbGVNZW1vcnlDb250ZXh0KGVzdGF0ZSkpOwogCQlpZiAo bmV3dHVwbGUgPT0gTlVMTCkKIAkJewpAQCAtMjYwNiw2ICsyNjEwLDcgQEAgRXhlY0lSSW5zZXJ0 VHJpZ2dlcnMoRVN0YXRlICplc3RhdGUsIFJlc3VsdFJlbEluZm8gKnJlbGluZm8sCiAJCQkJCQkJ CQkgICBpLAogCQkJCQkJCQkJICAgcmVsaW5mby0+cmlfVHJpZ0Z1bmN0aW9ucywKIAkJCQkJCQkJ CSAgIHJlbGluZm8tPnJpX1RyaWdJbnN0cnVtZW50LAorCQkJCQkJCQkJICAgZXN0YXRlLT5lc19p bnN0cnVtZW50LAogCQkJCQkJCQkJICAgR2V0UGVyVHVwbGVNZW1vcnlDb250ZXh0KGVzdGF0ZSkp OwogCQlpZiAobmV3dHVwbGUgPT0gTlVMTCkKIAkJewpAQCAtMjY3MCw2ICsyNjc1LDcgQEAgRXhl Y0JTRGVsZXRlVHJpZ2dlcnMoRVN0YXRlICplc3RhdGUsIFJlc3VsdFJlbEluZm8gKnJlbGluZm8p CiAJCQkJCQkJCQkgICBpLAogCQkJCQkJCQkJICAgcmVsaW5mby0+cmlfVHJpZ0Z1bmN0aW9ucywK IAkJCQkJCQkJCSAgIHJlbGluZm8tPnJpX1RyaWdJbnN0cnVtZW50LAorCQkJCQkJCQkJICAgZXN0 YXRlLT5lc19pbnN0cnVtZW50LAogCQkJCQkJCQkJICAgR2V0UGVyVHVwbGVNZW1vcnlDb250ZXh0 KGVzdGF0ZSkpOwogCiAJCWlmIChuZXd0dXBsZSkKQEAgLTI3ODAsNiArMjc4Niw3IEBAIEV4ZWNC UkRlbGV0ZVRyaWdnZXJzKEVTdGF0ZSAqZXN0YXRlLCBFUFFTdGF0ZSAqZXBxc3RhdGUsCiAJCQkJ CQkJCQkgICBpLAogCQkJCQkJCQkJICAgcmVsaW5mby0+cmlfVHJpZ0Z1bmN0aW9ucywKIAkJCQkJ CQkJCSAgIHJlbGluZm8tPnJpX1RyaWdJbnN0cnVtZW50LAorCQkJCQkJCQkJICAgZXN0YXRlLT5l c19pbnN0cnVtZW50LAogCQkJCQkJCQkJICAgR2V0UGVyVHVwbGVNZW1vcnlDb250ZXh0KGVzdGF0 ZSkpOwogCQlpZiAobmV3dHVwbGUgPT0gTlVMTCkKIAkJewpAQCAtMjg4NCw2ICsyODkxLDcgQEAg RXhlY0lSRGVsZXRlVHJpZ2dlcnMoRVN0YXRlICplc3RhdGUsIFJlc3VsdFJlbEluZm8gKnJlbGlu Zm8sCiAJCQkJCQkJCQkgICBpLAogCQkJCQkJCQkJICAgcmVsaW5mby0+cmlfVHJpZ0Z1bmN0aW9u cywKIAkJCQkJCQkJCSAgIHJlbGluZm8tPnJpX1RyaWdJbnN0cnVtZW50LAorCQkJCQkJCQkJICAg ZXN0YXRlLT5lc19pbnN0cnVtZW50LAogCQkJCQkJCQkJICAgR2V0UGVyVHVwbGVNZW1vcnlDb250 ZXh0KGVzdGF0ZSkpOwogCQlpZiAocmV0dHVwbGUgPT0gTlVMTCkKIAkJCXJldHVybiBmYWxzZTsJ CS8qIERlbGV0ZSB3YXMgc3VwcHJlc3NlZCAqLwpAQCAtMjk0Miw2ICsyOTUwLDcgQEAgRXhlY0JT VXBkYXRlVHJpZ2dlcnMoRVN0YXRlICplc3RhdGUsIFJlc3VsdFJlbEluZm8gKnJlbGluZm8pCiAJ CQkJCQkJCQkgICBpLAogCQkJCQkJCQkJICAgcmVsaW5mby0+cmlfVHJpZ0Z1bmN0aW9ucywKIAkJ CQkJCQkJCSAgIHJlbGluZm8tPnJpX1RyaWdJbnN0cnVtZW50LAorCQkJCQkJCQkJICAgZXN0YXRl LT5lc19pbnN0cnVtZW50LAogCQkJCQkJCQkJICAgR2V0UGVyVHVwbGVNZW1vcnlDb250ZXh0KGVz dGF0ZSkpOwogCiAJCWlmIChuZXd0dXBsZSkKQEAgLTMwOTQsNiArMzEwMyw3IEBAIEV4ZWNCUlVw ZGF0ZVRyaWdnZXJzKEVTdGF0ZSAqZXN0YXRlLCBFUFFTdGF0ZSAqZXBxc3RhdGUsCiAJCQkJCQkJ CQkgICBpLAogCQkJCQkJCQkJICAgcmVsaW5mby0+cmlfVHJpZ0Z1bmN0aW9ucywKIAkJCQkJCQkJ CSAgIHJlbGluZm8tPnJpX1RyaWdJbnN0cnVtZW50LAorCQkJCQkJCQkJICAgZXN0YXRlLT5lc19p bnN0cnVtZW50LAogCQkJCQkJCQkJICAgR2V0UGVyVHVwbGVNZW1vcnlDb250ZXh0KGVzdGF0ZSkp OwogCiAJCWlmIChuZXd0dXBsZSA9PSBOVUxMKQpAQCAtMzI1OCw2ICszMjY4LDcgQEAgRXhlY0lS VXBkYXRlVHJpZ2dlcnMoRVN0YXRlICplc3RhdGUsIFJlc3VsdFJlbEluZm8gKnJlbGluZm8sCiAJ CQkJCQkJCQkgICBpLAogCQkJCQkJCQkJICAgcmVsaW5mby0+cmlfVHJpZ0Z1bmN0aW9ucywKIAkJ CQkJCQkJCSAgIHJlbGluZm8tPnJpX1RyaWdJbnN0cnVtZW50LAorCQkJCQkJCQkJICAgZXN0YXRl LT5lc19pbnN0cnVtZW50LAogCQkJCQkJCQkJICAgR2V0UGVyVHVwbGVNZW1vcnlDb250ZXh0KGVz dGF0ZSkpOwogCQlpZiAobmV3dHVwbGUgPT0gTlVMTCkKIAkJewpAQCAtMzMxNiw2ICszMzI3LDcg QEAgRXhlY0JTVHJ1bmNhdGVUcmlnZ2VycyhFU3RhdGUgKmVzdGF0ZSwgUmVzdWx0UmVsSW5mbyAq cmVsaW5mbykKIAkJCQkJCQkJCSAgIGksCiAJCQkJCQkJCQkgICByZWxpbmZvLT5yaV9UcmlnRnVu Y3Rpb25zLAogCQkJCQkJCQkJICAgcmVsaW5mby0+cmlfVHJpZ0luc3RydW1lbnQsCisJCQkJCQkJ CQkgICBlc3RhdGUtPmVzX2luc3RydW1lbnQsCiAJCQkJCQkJCQkgICBHZXRQZXJUdXBsZU1lbW9y eUNvbnRleHQoZXN0YXRlKSk7CiAKIAkJaWYgKG5ld3R1cGxlKQpAQCAtNDM4Myw3ICs0Mzk1LDcg QEAgQWZ0ZXJUcmlnZ2VyRXhlY3V0ZShFU3RhdGUgKmVzdGF0ZSwKIAkgKiB0byBpbmNsdWRlIHRp bWUgc3BlbnQgcmUtZmV0Y2hpbmcgdHVwbGVzIGluIHRoZSB0cmlnZ2VyIGNvc3QuCiAJICovCiAJ aWYgKGluc3RyKQotCQlJbnN0clN0YXJ0VHJpZ2dlcihpbnN0ciArIHRnaW5keCk7CisJCUluc3Ry U3RhcnRUcmlnZ2VyKGVzdGF0ZS0+ZXNfaW5zdHJ1bWVudCwgaW5zdHIgKyB0Z2luZHgpOwogCiAJ LyoKIAkgKiBGZXRjaCB0aGUgcmVxdWlyZWQgdHVwbGUocykuCkBAIC00NTcxLDYgKzQ1ODMsNyBA QCBBZnRlclRyaWdnZXJFeGVjdXRlKEVTdGF0ZSAqZXN0YXRlLAogCQkJCQkJCQkgICB0Z2luZHgs CiAJCQkJCQkJCSAgIGZpbmZvLAogCQkJCQkJCQkgICBOVUxMLAorCQkJCQkJCQkgICBOVUxMLAog CQkJCQkJCQkgICBwZXJfdHVwbGVfY29udGV4dCk7CiAJaWYgKHJldHR1cGxlICE9IE5VTEwgJiYK IAkJcmV0dHVwbGUgIT0gTG9jVHJpZ2dlckRhdGEudGdfdHJpZ3R1cGxlICYmCmRpZmYgLS1naXQg YS9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jIGIvc3JjL2JhY2tlbmQvY29t bWFuZHMvdmFjdXVtcGFyYWxsZWwuYwppbmRleCA3NzgzNGI5NmEyMS4uYzMzMGM4OTFjMDMgMTAw NjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMKKysrIGIvc3Jj L2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxsZWwuYwpAQCAtMzA4LDggKzMwOCw4IEBAIHBh cmFsbGVsX3ZhY3V1bV9pbml0KFJlbGF0aW9uIHJlbCwgUmVsYXRpb24gKmluZHJlbHMsIGludCBu aW5kZXhlcywKIAkgKiBQQVJBTExFTF9WQUNVVU1fS0VZX0JVRkZFUl9VU0FHRSBhbmQgUEFSQUxM RUxfVkFDVVVNX0tFWV9XQUxfVVNBR0UuCiAJICoKIAkgKiBJZiB0aGVyZSBhcmUgbm8gZXh0ZW5z aW9ucyBsb2FkZWQgdGhhdCBjYXJlLCB3ZSBjb3VsZCBza2lwIHRoaXMuICBXZQotCSAqIGhhdmUg bm8gd2F5IG9mIGtub3dpbmcgd2hldGhlciBhbnlvbmUncyBsb29raW5nIGF0IHBnQnVmZmVyVXNh Z2Ugb3IKLQkgKiBwZ1dhbFVzYWdlLCBzbyBkbyBpdCB1bmNvbmRpdGlvbmFsbHkuCisJICogaGF2 ZSBubyB3YXkgb2Yga25vd2luZyB3aGV0aGVyIGFueW9uZSdzIGxvb2tpbmcgYXQgaW5zdHJ1bWVu dGF0aW9uLCBzbworCSAqIGRvIGl0IHVuY29uZGl0aW9uYWxseS4KIAkgKi8KIAlzaG1fdG9jX2Vz dGltYXRlX2NodW5rKCZwY3h0LT5lc3RpbWF0b3IsCiAJCQkJCQkgICBtdWxfc2l6ZShzaXplb2Yo QnVmZmVyVXNhZ2UpLCBwY3h0LT5ud29ya2VycykpOwpAQCAtMTAwNiw2ICsxMDA2LDcgQEAgcGFy YWxsZWxfdmFjdXVtX21haW4oZHNtX3NlZ21lbnQgKnNlZywgc2htX3RvYyAqdG9jKQogCVBWSW5k U3RhdHMgKmluZHN0YXRzOwogCVBWU2hhcmVkICAgKnNoYXJlZDsKIAlUaWRTdG9yZSAgICpkZWFk X2l0ZW1zOworCVF1ZXJ5SW5zdHJ1bWVudGF0aW9uICppbnN0cjsKIAlCdWZmZXJVc2FnZSAqYnVm ZmVyX3VzYWdlOwogCVdhbFVzYWdlICAgKndhbF91c2FnZTsKIAlpbnQJCQluaW5kZXhlczsKQEAg LTEwOTUsNyArMTA5Niw3IEBAIHBhcmFsbGVsX3ZhY3V1bV9tYWluKGRzbV9zZWdtZW50ICpzZWcs IHNobV90b2MgKnRvYykKIAllcnJvcl9jb250ZXh0X3N0YWNrID0gJmVycmNhbGxiYWNrOwogCiAJ LyogUHJlcGFyZSB0byB0cmFjayBidWZmZXIgdXNhZ2UgZHVyaW5nIHBhcmFsbGVsIGV4ZWN1dGlv biAqLwotCUluc3RyU3RhcnRQYXJhbGxlbFF1ZXJ5KCk7CisJaW5zdHIgPSBJbnN0clN0YXJ0UGFy YWxsZWxRdWVyeSgpOwogCiAJLyogUHJvY2VzcyBpbmRleGVzIHRvIHBlcmZvcm0gdmFjdXVtL2Ns ZWFudXAgKi8KIAlwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19zYWZlX2luZGV4ZXMoJnB2cyk7CkBA IC0xMTAzLDcgKzExMDQsOCBAQCBwYXJhbGxlbF92YWN1dW1fbWFpbihkc21fc2VnbWVudCAqc2Vn LCBzaG1fdG9jICp0b2MpCiAJLyogUmVwb3J0IGJ1ZmZlci9XQUwgdXNhZ2UgZHVyaW5nIHBhcmFs bGVsIGV4ZWN1dGlvbiAqLwogCWJ1ZmZlcl91c2FnZSA9IHNobV90b2NfbG9va3VwKHRvYywgUEFS QUxMRUxfVkFDVVVNX0tFWV9CVUZGRVJfVVNBR0UsIGZhbHNlKTsKIAl3YWxfdXNhZ2UgPSBzaG1f dG9jX2xvb2t1cCh0b2MsIFBBUkFMTEVMX1ZBQ1VVTV9LRVlfV0FMX1VTQUdFLCBmYWxzZSk7Ci0J SW5zdHJFbmRQYXJhbGxlbFF1ZXJ5KCZidWZmZXJfdXNhZ2VbUGFyYWxsZWxXb3JrZXJOdW1iZXJd LAorCUluc3RyRW5kUGFyYWxsZWxRdWVyeShpbnN0ciwKKwkJCQkJCSAgJmJ1ZmZlcl91c2FnZVtQ YXJhbGxlbFdvcmtlck51bWJlcl0sCiAJCQkJCQkgICZ3YWxfdXNhZ2VbUGFyYWxsZWxXb3JrZXJO dW1iZXJdKTsKIAogCS8qIFJlcG9ydCBhbnkgcmVtYWluaW5nIGNvc3QtYmFzZWQgdmFjdXVtIGRl bGF5IHRpbWUgKi8KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL1JFQURNRS5pbnN0 cnVtZW50IGIvc3JjL2JhY2tlbmQvZXhlY3V0b3IvUkVBRE1FLmluc3RydW1lbnQKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLjdkZjgzN2RiYzc3Ci0tLSAvZGV2L251bGwK KysrIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3IvUkVBRE1FLmluc3RydW1lbnQKQEAgLTAsMCArMSwy MzcgQEAKK3NyYy9iYWNrZW5kL2V4ZWN1dG9yL1JFQURNRS5pbnN0cnVtZW50CisKK0luc3RydW1l bnRhdGlvbgorPT09PT09PT09PT09PT09CisKK1RoZSBpbnN0cnVtZW50YXRpb24gc3Vic3lzdGVt IG1lYXN1cmVzIHRpbWUsIGJ1ZmZlciB1c2FnZSBhbmQgV0FMIGFjdGl2aXR5CitkdXJpbmcgcXVl cnkgZXhlY3V0aW9uIGFuZCBvdGhlciBzaW1pbGFyIGFjdGl2aXRpZXMuICBJdCBpcyB1c2VkIGJ5 CitFWFBMQUlOIEFOQUxZWkUsIHBnX3N0YXRfc3RhdGVtZW50cywgYW5kIG90aGVyIGNvbnN1bWVy cyB0aGF0IG5lZWQKK2FjdGl2aXR5IGFuZC9vciB0aW1pbmcgbWV0cmljcyBvdmVyIGEgc2VjdGlv biBvZiBjb2RlLgorCitUaGUgZGVzaWduIGhhcyB0d28gY2VudHJhbCBnb2FsczoKKworKiBNYWtl IGl0IGNoZWFwIHRvIG1lYXN1cmUgYWN0aXZpdHkgaW4gYSBzZWN0aW9uIG9mIGNvZGUsIGV2ZW4g d2hlbgorICB0aGF0IHNlY3Rpb24gaXMgY2FsbGVkIG1hbnkgdGltZXMgYW5kIHRoZSBhZ2dyZWdh dGUgaXMgd2hhdCBpcyB1c2VkCisgIChhcyBpcyB0aGUgY2FzZSB3aXRoIHBlci1ub2RlIGluc3Ry dW1lbnRhdGlvbiBpbiB0aGUgZXhlY3V0b3IpCisKKyogRW5zdXJlIG5lc3RlZCBpbnN0cnVtZW50 YXRpb24gYWNjdXJhdGVseSBtZWFzdXJlcyBhY3Rpdml0eS90aW1pbmcsCisgIGV2ZW4gd2hlbiBl eGVjdXRpb24gaXMgYWJvcnRlZCBkdWUgdG8gZXJyb3JzIGJlaW5nIHRocm93bi4KKworVGhlIGtl eSBkYXRhIHN0cnVjdHVyZXMgYXJlIGRlZmluZWQgaW4gc3JjL2luY2x1ZGUvZXhlY3V0b3IvaW5z dHJ1bWVudC5oCithbmQgdGhlIGltcGxlbWVudGF0aW9uIGxpdmVzIGluIHNyYy9iYWNrZW5kL2V4 ZWN1dG9yL2luc3RydW1lbnQuYy4KKworCitJbnN0cnVtZW50YXRpb24gT3B0aW9ucworLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0KKworQ2FsbGVycyBzcGVjaWZ5IHdoYXQgdG8gbWVhc3VyZSB3aXRo IGEgYml0bWFzayBvZiBJbnN0cnVtZW50T3B0aW9uIGZsYWdzOgorCisgIElOU1RSVU1FTlRfUk9X UyAgICAgLS0gcm93IGNvdW50cyBvbmx5ICh1c2VkIHdpdGggTm9kZUluc3RydW1lbnRhdGlvbikK KyAgSU5TVFJVTUVOVF9USU1FUiAgICAtLSB3YWxsLWNsb2NrIHRpbWluZyBhbmQgcm93IGNvdW50 cworICBJTlNUUlVNRU5UX0JVRkZFUlMgIC0tIGJ1ZmZlciBoaXQvcmVhZC9kaXJ0aWVkL3dyaXR0 ZW4gY291bnRzIGFuZCBJL08gdGltZQorICBJTlNUUlVNRU5UX1dBTCAgICAgIC0tIFdBTCByZWNv cmRzLCBGUEksIGJ5dGVzCisKK0lOU1RSVU1FTlRfQlVGRkVSUyBhbmQgSU5TVFJVTUVOVF9XQUwg dXRpbGl6ZSB0aGUgaW5zdHJ1bWVudGF0aW9uIHN0YWNrCisoZGVzY3JpYmVkIGJlbG93KSBmb3Ig ZWZmaWNpZW50IGhhbmRsaW5nIG9mIGNvdW50ZXIgdmFsdWVzLgorCisKK1N0cnVjdCBIaWVyYXJj aHkKKy0tLS0tLS0tLS0tLS0tLS0KKworVGhlcmUgYXJlIHRoZSBmb2xsb3dpbmcgaW5zdHJ1bWVu dGF0aW9uIHN0cnVjdHMsIGVhY2ggc3BlY2lhbGl6ZWQgZm9yIGEKK2RpZmZlcmVudCBzY29wZToK KworSW5zdHJ1bWVudGF0aW9uICAgICAgICBCYXNlIHN0cnVjdC4gIEhvbGRzIHRpbWluZyBhbmQg YnVmZmVyL1dBTCBjb3VudGVycy4KKworUXVlcnlJbnN0cnVtZW50YXRpb24gICBFeHRlbmRzIElu c3RydW1lbnRhdGlvbiBmb3IgcXVlcnktbGV2ZWwgdHJhY2tpbmcuICBXaGVuCisgICAgICAgICAg ICAgICAgICAgICAgIHN0YWNrLWJhc2VkIHRyYWNraW5nIGlzIGVuYWJsZWQsIGl0IG93bnMgYSBk ZWRpY2F0ZWQKKyAgICAgICAgICAgICAgICAgICAgICAgTWVtb3J5Q29udGV4dCBhbmQgdXNlcyB0 aGUgUmVzb3VyY2VPd25lciBtZWNoYW5pc20gZm9yCisgICAgICAgICAgICAgICAgICAgICAgIGFi b3J0IGNsZWFudXAuCisKK05vZGVJbnN0cnVtZW50YXRpb24gICAgRXh0ZW5kcyBJbnN0cnVtZW50 YXRpb24gZm9yIHBlci1wbGFuLW5vZGUgc3RhdGlzdGljcworICAgICAgICAgICAgICAgICAgICAg ICAoc3RhcnR1cCB0aW1lLCB0dXBsZSBjb3VudHMsIGxvb3AgY291bnRzLCBldGMpLgorCitUcmln Z2VySW5zdHJ1bWVudGF0aW9uIEV4dGVuZHMgSW5zdHJ1bWVudGF0aW9uIHdpdGggYSBmaXJpbmcg Y291bnQuCisKKworU3RhY2stYmFzZWQgaW5zdHJ1bWVudGF0aW9uCis9PT09PT09PT09PT09PT09 PT09PT09PT09PT0KKworRm9yIHRyYWNraW5nIFdBTCBvciBidWZmZXIgdXNhZ2UgY291bnRlcnMs IHRoZSBzcGVjaWFsaXplZCBzdGFjay1iYXNlZAoraW5zdHJ1bWVudGF0aW9uIGlzIHVzZWQuCisK K0Egc2ltcGxlIGFwcHJvYWNoIHRvIG1lYXN1cmluZyBidWZmZXIvV0FMIGFjdGl2aXR5IGluIGEg Y29kZSBzZWN0aW9uIGNvdWxkIGJlCit0byBoYXZlIGEgc2V0IG9mIGdsb2JhbCBjb3VudGVycywg c25hcHNob3QgYWxsIHRoZSBjb3VudGVycyBhdCB0aGUgc3RhcnQsIGFuZAorZGlmZiB0aGVtIGF0 IHRoZSBlbmQuIEJ1dCwgdGhpcyBpcyBleHBlbnNpdmUgaW4gcHJhY3RpY2U6IEJ1ZmZlclVzYWdl IGFsb25lCitoYXMgbWFueSBmaWVsZHMsIGFuZCB0aGUgZGlmZiBtdXN0IGJlIGNvbXB1dGVkIGZv ciBldmVyeSBJbnN0clN0YXJ0Tm9kZSAvCitJbnN0clN0b3BOb2RlIGN5Y2xlLgorCitBbiBhbHRl cm5hdGl2ZSBpcyB0byB3cml0ZSBjb3VudGVyIHVwZGF0ZXMgZGlyZWN0bHkgaW50byB0aGUgc3Ry dWN0IHRoYXQKK3Nob3VsZCByZWNlaXZlIHRoZW0sIGF2b2lkaW5nIHRoZSBkaWZmLiAgQnV0IHRo YXQgaGFzIHR3byBjb21wbGV4aXRpZXM6IExvdy1sZXZlbAorY29kZSBzdWNoIGFzIHRoZSBidWZm ZXIgbWFuYWdlciwgaGFzIG5vIGRpcmVjdCBwb2ludGVycyB0byBoaWdoZXIgbGV2ZWwKK3N0cnVj dHMsIHN1Y2ggYXMgcGxhbiBub2RlcyB0cmFja2luZyBidWZmZXIgdXNhZ2UuIEFuZCBpbnN0cnVt ZW50YXRpb24gaXMgb2Z0ZW4KK25lc3RlZDogV2UgbWlnaHQgYm90aCBiZSBpbnRlcmVzdGVkIGlu IHRoZSBhZ2dyZWdhdGUgYnVmZmVyIHVzYWdlIG9mIGEgcXVlcnksIGFuZAordGhlIGluZGl2aWR1 YWwgcGVyLW5vZGUgZGV0YWlscy4gU3RhY2stYmFzZWQgaW5zdHJ1bWVudGF0aW9uIHNvbHZlcyBm b3IgdGhhdDoKKworQXQgYWxsIHRpbWVzLCB0aGVyZSBpcyBhIHN0YWNrIHRoYXQgdHJhY2tzIHdo aWNoIEluc3RydW1lbnRhdGlvbiBpcyBjdXJyZW50bHkKK2FjdGl2ZS4gIFRoZSBzdGFjayBpcyBy ZXByZXNlbnRlZCBieSBpbnN0cl9zdGFjaywgYSBwZXItYmFja2VuZCBnbG9iYWwKK3RoYXQgaG9s ZHMgYSBkeW5hbWljIGFycmF5IG9mIEluc3RydW1lbnRhdGlvbiBwb2ludGVycy4gIFRoZSBmaWVs ZAoraW5zdHJfc3RhY2suY3VycmVudCBhbHdheXMgcG9pbnRzIHRvIHRoZSBjdXJyZW50IHN0YWNr IGVudHJ5IHRoYXQgc2hvdWxkCitiZSB1cGRhdGVkIHdoZW4gYWN0aXZpdHkgb2NjdXJzLiAgV2hl biB0aGUgc3RhY2sgYXJyYXkgaXMgZW1wdHksIHRoZQorY3VycmVudCBzdGFjayBwb2ludHMgdG8g aW5zdHJfdG9wLgorCitGb3IgZXhhbXBsZSwgaWYgYSBiYWNrZW5kIGhhcyB0d28gcG9ydGFscyBv cGVuLCB0aGUgb3ZlcmFsbCBuZXN0aW5nIG9mCitJbnN0cnVtZW50YXRpb24gYW5kIHRoZWlyIHJl c3BlY3RpdmUgSW5zdHJTdGFydC9JbnN0clN0b3AgY2FsbHMgY3JlYXRlcyBhCit0cmVlLWxpa2Ug c3RydWN0dXJlIGxpa2UgdGhpczoKKworICAgIFNlc3Npb24gKGluc3RyX3RvcCkKKyAgICAgfAor ICAgICArLS0gUXVlcnkgQSAoUXVlcnlJbnN0cnVtZW50YXRpb24pCisgICAgIHwgICAgfAorICAg ICB8ICAgICstLSBOZXN0TG9vcCAoTm9kZUluc3RydW1lbnRhdGlvbikKKyAgICAgfCAgICAgICAg IHwKKyAgICAgfCAgICAgICAgICstLSBTZXEgU2NhbiBBIChOb2RlSW5zdHJ1bWVudGF0aW9uKQor ICAgICB8ICAgICAgICAgKy0tIFNlcSBTY2FuIEIgKE5vZGVJbnN0cnVtZW50YXRpb24pCisgICAg IHwKKyAgICAgKy0tIFF1ZXJ5IEIgKFF1ZXJ5SW5zdHJ1bWVudGF0aW9uKQorICAgICAgICAgIHwK KyAgICAgICAgICArLS0gU2VxIFNjYW4gQyAoTm9kZUluc3RydW1lbnRhdGlvbikKKworV2hpbGUg ZXhlY3V0aW5nIFNlcSBTY2FuIEIsIHRoZSBzdGFjayBsb29rcyBsaWtlOgorCisgICAgaW5zdHJf dG9wICAgICAgICAgICAgICAoaW1wbGljaXQgYm90dG9tLCBub3QgaW4gdGhlIGVudHJpZXMgYXJy YXkpCisgICAgMDogUXVlcnkgQQorICAgIDE6IE5lc3RMb29wCisgICAgMjogU2VxIFNjYW4gQiAg ICAgICAgICA8LS0gaW5zdHJfc3RhY2suY3VycmVudAorCitXaGVuIG5vIHF1ZXJ5IGlzIHJ1bm5p bmcsIHRoZSBzdGFjayBpcyBlbXB0eSAoc3RhY2tfc2l6ZSA9PSAwKSBhbmQKK2luc3RyX3N0YWNr LmN1cnJlbnQgcG9pbnRzIHRvIGluc3RyX3RvcC4KKworQW55IGJ1ZmZlciBvciBXQUwgY291bnRl ciB1cGRhdGUgKHZpYSB0aGUgSU5TVFJfQlVGVVNBR0VfKiBhbmQKK0lOU1RSX1dBTFVTQUdFXyog bWFjcm9zIGluIHRoZSBidWZmZXIgbWFuYWdlciwgV0FMIGluc2VydGlvbiBjb2RlLCBldGMuKQor d3JpdGVzIGRpcmVjdGx5IGludG8gaW5zdHJfc3RhY2suY3VycmVudC4gIEVhY2ggaW5zdHJ1bWVu dGF0aW9uIG5vZGUgc3RhcnRzCit6ZXJvZWQsIHNvIHRoZSB2YWx1ZXMgaXQgYWNjdW11bGF0ZXMg d2hpbGUgb24gdG9wIG9mIHRoZSBzdGFjayByZXByZXNlbnQKK2V4YWN0bHkgdGhlIGFjdGl2aXR5 IHRoYXQgb2NjdXJyZWQgZHVyaW5nIHRoYXQgdGltZS4KKworRXZlcnkgSW5zdHJ1bWVudGF0aW9u IG5vZGUgKGV4Y2VwdCBmb3IgaW5zdHJfdG9wKSBoYXMgYSB0YXJnZXQsIG9yIHBhcmVudCwgaXQK K3dpbGwgYmUgYWNjdW11bGF0ZWQgaW50bywgd2hpY2ggaXMgdHlwaWNhbGx5IHRoZSBJbnN0cnVt ZW50YXRpb24gdGhhdCB3YXMgdGhlCitjdXJyZW50IHN0YWNrIGVudHJ5IHdoZW4gaXQgd2FzIGNy ZWF0ZWQuCisKK0ZvciBleGFtcGxlLCB3aGVuIFNlcSBTY2FuIEEgZ2V0cyBmaW5hbGl6ZWQgaW4g cmVndWxhciBleGVjdXRpb24gdmlhIEV4ZWN1dG9yRmluaXNoLAoraXRzIGluc3RydW1lbnRhdGlv biBkYXRhIGdldHMgYWRkZWQgdG8gdGhlIGltbWVkaWF0ZSBwYXJlbnQgaW4KK3RoZSBleGVjdXRp b24gdHJlZSwgdGhlIE5lc3RMb29wLCB3aGljaCB3aWxsIHRoZW4gZ2V0IGFkZGVkIHRvIFF1ZXJ5 IEEncworUXVlcnlJbnN0cnVtZW50YXRpb24sIHdoaWNoIHRoZW4gYWNjdW11bGF0ZXMgdG8gdGhl IHBhcmVudC4KKworV2hpbGUgd2UgY2FuIHR5cGljYWxseSB0aGluayBvZiB0aGlzIGFzIGEgdHJl ZSwgdGhlIE5vZGVJbnN0cnVtZW50YXRpb24KK3VuZGVybmVhdGggYSBwYXJ0aWN1bGFyIFF1ZXJ5 SW5zdHJ1bWVudGF0aW9uIGNvdWxkIGJlaGF2ZSBkaWZmZXJlbnRseSAtLQorZm9yIGV4YW1wbGUs IGl0IGNvdWxkIHByb3BhZ2F0ZSBkaXJlY3RseSB0byB0aGUgUXVlcnlJbnN0cnVtZW50YXRpb24s IGluCitvcmRlciB0byBub3Qgc2hvdyBjdW11bGF0aXZlIG51bWJlcnMgaW4gRVhQTEFJTiBBTkFM WVpFLgorCitOb3RlIHRoZXNlIHJlbGF0aW9uc2hpcHMgYXJlIHBhcnRpYWxseSBpbXBsaWNpdCwg ZXNwZWNpYWxseSB3aGVuIGl0IGNvbWVzCit0byBOb2RlSW5zdHJ1bWVudGF0aW9uLiBFYWNoIFF1 ZXJ5SW5zdHJ1bWVudGF0aW9uIG1haW50YWlucyBhIGxpc3Qgb2YgaXRzCit1bmZpbmFsaXplZCBj aGlsZCBub2Rlcy4gIFRoZSBwYXJlbnQgb2YgYSBRdWVyeUluc3RydW1lbnRhdGlvbiBpdHNlbGYg aXMKK2RldGVybWluZWQgYnkgdGhlIHN0YWNrIChzZWUgYmVsb3cpOiB3aGVuIGEgcXVlcnkgaXMg ZmluYWxpemVkIG9yIGNsZWFuZWQKK3VwIG9uIGFib3J0LCBpdHMgY291bnRlcnMgYXJlIGFjY3Vt dWxhdGVkIHRvIHdoYXRldmVyIGVudHJ5IGlzIHRoZW4gY3VycmVudAorb24gdGhlIHN0YWNrLCB3 aGljaCBpcyB0eXBpY2FsbHkgaW5zdHJfdG9wLgorCisKK0ZpbmFsaXphdGlvbiBhbmQgQWJvcnQg U2FmZXR5Cis9PT09PT09PT09PT09PT09PT09PT09PT09PT09PQorCitGaW5hbGl6YXRpb24gaXMg dGhlIHByb2Nlc3Mgb2Ygcm9sbGluZyB1cCBhIG5vZGUncyBidWZmZXIvV0FMIGNvdW50ZXJzIHRv CitpdHMgcGFyZW50LiAgSW4gbm9ybWFsIGV4ZWN1dGlvbiwgbm9kZXMgYXJlIHB1c2hlZCBvbnRv IHRoZSBzdGFjayB3aGVuIHRoZXkKK3N0YXJ0IGFuZCBwb3BwZWQgd2hlbiB0aGV5IHN0b3A7IGF0 IGZpbmFsaXphdGlvbiB0aW1lIHRoZWlyIGFjY3VtdWxhdGVkCitjb3VudGVycyBhcmUgYWRkZWQg dG8gdGhlIHBhcmVudC4KKworRHVlIHRvIHRoZSB1c2Ugb2YgbG9uZ2ptcCBmb3IgZXJyb3IgaGFu ZGxpbmcsIGZ1bmN0aW9ucyBjYW4gZXhpdCBhYnJ1cHRseQord2l0aG91dCBleGVjdXRpbmcgdGhl aXIgbm9ybWFsIGNsZWFudXAgY29kZS4gIE9uIGFib3J0LCB0d28gdGhpbmdzIG5lZWQKK3RvIGhh cHBlbjoKKworMS4gVGhlIHN0YWNrIGlzIHJlc2V0IHRvIHRoZSBsZXZlbCBzYXZlZCBhdCB0aGUg c3RhcnQgb2YgdGhlIGFib3J0aW5nCisgICAoc3ViLSl0cmFuc2FjdGlvbiBsZXZlbC4gIFRoaXMg ZW5zdXJlcyB0aGF0IHdlIGRvbid0IGxhdGVyIHRyeSB0byB1cGRhdGUKKyAgIGNvdW50ZXJzIG9u IGEgZnJlZWQgc3RhY2sgZW50cnkuICBXZSBhbHNvIG5lZWQgdG8gZW5zdXJlIHRoYXQgdGhlIHN0 YWNrCisgICBlbnRyeSB0aGF0IHdhcyBjdXJyZW50IGJlZm9yZSBhIHBhcnRpY3VsYXIgSW5zdHJ1 bWVudGF0aW9uIHN0YXJ0ZWQsIGlzCisgICBjdXJyZW50IGFnYWluIGFmdGVyIGl0IHN0b3BzLgor CisyLiBGaW5hbGl6ZSBhbGwgYWZmZWN0ZWQgSW5zdHJ1bWVudGF0aW9uIG5vZGVzLCByb2xsaW5n IHVwIHRoZWlyIGNvdW50ZXJzCisgICB0byB0aGUgaW5uZXJtb3N0IHN1cnZpdmluZyBJbnN0cnVt ZW50YXRpb24sIHNvIHRoYXQgZGF0YSBpcyBub3QgbG9zdC4KKworRm9yIGV4YW1wbGUsIGlmIFNl cSBTY2FuIEIgYWJvcnRzIHdoaWxlIHRoZSBzdGFjayBpczoKKworICAgIGluc3RyX3RvcCAgICAg ICAgICAgICAgKGltcGxpY2l0IGJvdHRvbSkKKyAgICAwOiBRdWVyeSBBCisgICAgMTogTmVzdExv b3AKKyAgICAyOiBTZXEgU2NhbiBCCisKK1RoZSBhYm9ydCBoYW5kbGVyIGZvciBRdWVyeSBBIGFj Y3VtdWxhdGVzIGFsbCB1bmZpbmFsaXplZCBjaGlsZHJlbiAoU2VxCitTY2FuIEEsIFNlcSBTY2Fu IEIsIE5lc3RMb29wKSBkaXJlY3RseSBpbnRvIFF1ZXJ5IEEncyBjb3VudGVycywgdGhlbgordW53 aW5kcyB0aGUgaW5zdHJ1bWVudGF0aW9uIHN0YWNrIGFuZCBhY2N1bXVsYXRlcyBRdWVyeSBBJ3Mg Y291bnRlcnMgdG8KK2luc3RyX3RvcC4KKworTm90ZSB0aGF0IG9uIGFib3J0IHRoZSBjaGlsZHJl biBkbyBub3QgYWNjdW11bGF0ZSB0aHJvdWdoIGVhY2ggb3RoZXIgKFNlcQorU2NhbiBCIC0+IE5l c3RMb29wIC0+IFF1ZXJ5IEEpOyB0aGV5IGFsbCBhY2N1bXVsYXRlIGRpcmVjdGx5IHRvIHRoZWly CitwYXJlbnQgUXVlcnlJbnN0cnVtZW50YXRpb24uICBUaGlzIG1lYW5zIHRoZSBvcmRlciBpbiB3 aGljaCBjaGlsZHJlbiBhcmUKK3JlbGVhc2VkIGRvZXMgbm90IG1hdHRlciAtLSB0aGlzIGlzIGlt cG9ydGFudCBiZWNhdXNlIFJlc291cmNlT3duZXIgY2xlYW51cAorZG9lcyBub3QgZ3VhcmFudGVl IGEgcGFydGljdWxhciByZWxlYXNlIG9yZGVyLiAgVGhlIHBlci1ub2RlIGJyZWFrZG93biBpcyBs b3N0LAorYnV0IHRoZSBpbnN0cnVtZW50YXRpb24gYWN0aXZlIHdoZW4gdGhlIHF1ZXJ5IHdhcyBz dGFydGVkIChpbnN0cl90b3AgaW4gdGhlCithYm92ZSBleGFtcGxlKSBzdXJ2aXZlcyB0aGUgYWJv cnQsIGFuZCBpdHMgY291bnRlcnMgaW5jbHVkZSB0aGUgYWN0aXZpdHkuCisKK0lmIG11bHRpcGxl IFF1ZXJ5SW5zdHJ1bWVudGF0aW9ucyBhcmUgYWN0aXZlIG9uIHRoZSBzdGFjayAoZS5nLiBuZXN0 ZWQKK3BvcnRhbHMpLCB0aGUgYWJvcnQgaGFuZGxlciBvZiBlYWNoIHVzZXMgSW5zdHJTdG9wRmlu YWxpemUoKSB0byBhY2N1bXVsYXRlCit0aGUgc3RhdGlzdGljcyB0byB0aGUgcGFyZW50IGVudHJ5 IG9mIGVpdGhlciB0aGUgZW50cnkgYmVpbmcgcmVsZWFzZWQsIG9yIGEKK3ByZXZpb3VzbHkgcmVs ZWFzZWQgZW50cnkgaWYgaXQgd2FzIGhpZ2hlciB1cCBpbiB0aGUgc3RhY2ssIHNvIHRoZXkgY29t cG9zZQorY29ycmVjdGx5IHJlZ2FyZGxlc3Mgb2YgcmVsZWFzZSBvcmRlci4KKworVGhlcmUgYXJl IHR3byBtZWNoYW5pc21zIGZvciBhY2hpZXZpbmcgYWJvcnQgc2FmZXR5OgorCisqIFJlc291cmNl IE93bmVyIChRdWVyeUluc3RydW1lbnRhdGlvbik6IHJlZ2lzdGVycyB3aXRoIHRoZSBjdXJyZW50 CisgIFJlc291cmNlT3duZXIgYXQgc3RhcnQuICBPbiB0cmFuc2FjdGlvbiBhYm9ydCwgdGhlIHJl c291cmNlIG93bmVyIHN5c3RlbQorICBjYWxscyB0aGUgcmVsZWFzZSBjYWxsYmFjaywgd2hpY2gg d2Fsa3MgdW5maW5hbGl6ZWQgY2hpbGQgZW50cmllcywKKyAgYWNjdW11bGF0ZXMgdGhlaXIgZGF0 YSwgdW53aW5kcyB0aGUgc3RhY2ssIGFuZCBkZXN0cm95cyB0aGUgZGVkaWNhdGVkCisgIG1lbW9y eSBjb250ZXh0IChmcmVlaW5nIHRoZSBRdWVyeUluc3RydW1lbnRhdGlvbiBhbmQgYWxsIGNoaWxk CisgIGFsbG9jYXRpb25zIGFzIGEgdW5pdCkuICBUaGlzIGlzIHRoZSByZWNvbW1lbmRlZCBhcHBy b2FjaCB3aGVuIHRoZQorICBpbnN0cnVtZW50ZWQgY29kZSBhbHJlYWR5IGhhcyBhbiBhcHByb3By aWF0ZSByZXNvdXJjZSBvd25lciAoZS5nLiBpdAorICBydW5zIGluc2lkZSBhIHBvcnRhbCkuICBU aGUgcXVlcnkgZXhlY3V0b3IgdXNlcyB0aGlzIHBhdGguCisKKyogUEdfRklOQUxMWSAoYmFzZSBJ bnN0cnVtZW50YXRpb24pOiB3aGVuIG5vIHN1aXRhYmxlIHJlc291cmNlIG93bmVyCisgIGV4aXN0 cywgb3Igd2hlbiB0aGUgY2FsbGVyIHdhbnRzIHRvIGluc3BlY3QgdGhlIGluc3RydW1lbnRhdGlv biBkYXRhCisgIGV2ZW4gYWZ0ZXIgYW4gZXJyb3IsIHRoZSBiYXNlIEluc3RydW1lbnRhdGlvbiBj YW4gYmUgdXNlZCB3aXRoIGEKKyAgUEdfVFJZL1BHX0ZJTkFMTFkgYmxvY2sgdGhhdCBjYWxscyBJ bnN0clN0b3BGaW5hbGl6ZSgpLgorCitCb3RoIG1lY2hhbmlzbXMgYWRkIG92ZXJoZWFkLCBzbyBu ZWl0aGVyIGlzIHN1aXRhYmxlIGZvciBoaWdoLWZyZXF1ZW5jeQoraW5zdHJ1bWVudGF0aW9uIGxp a2UgcGVyLW5vZGUgbWVhc3VyZW1lbnRzIGluIHRoZSBleGVjdXRvci4gIEluc3RlYWQsCitwbGFu IG5vZGUgYW5kIHRyaWdnZXIgY2hpbGRyZW4gcmVseSBvbiB0aGVpciBwYXJlbnQgUXVlcnlJbnN0 cnVtZW50YXRpb24KK2ZvciBhYm9ydCBzYWZldHk6IHRoZXkgYXJlIGFsbG9jYXRlZCBpbiB0aGUg cGFyZW50J3MgbWVtb3J5IGNvbnRleHQgYW5kCityZWdpc3RlcmVkIGluIGl0cyB1bmZpbmFsaXpl ZC1lbnRyaWVzIGxpc3QsIHNvIHRoZSBwYXJlbnQncyBhYm9ydCBoYW5kbGVyCityZWNvdmVycyB0 aGVpciBkYXRhIGF1dG9tYXRpY2FsbHkuICBJbiBub3JtYWwgZXhlY3V0aW9uLCBjaGlsZHJlbiBh cmUKK2ZpbmFsaXplZCBleHBsaWNpdGx5IGJ5IHRoZSBjYWxsZXIuCisKK1BhcmFsbGVsIFF1ZXJ5 CistLS0tLS0tLS0tLS0tLQorCitQYXJhbGxlbCB3b3JrZXJzIGdldCB0aGVpciBvd24gUXVlcnlJ bnN0cnVtZW50YXRpb24gc28gdGhleSBjYW4gbWVhc3VyZQorYnVmZmVyIGFuZCBXQUwgYWN0aXZp dHkgaW5kZXBlbmRlbnRseSwgdGhlbiBjb3B5IHRoZSB0b3RhbHMgaW50byBkeW5hbWljCitzaGFy ZWQgbWVtb3J5IGF0IHdvcmtlciBzaHV0ZG93bi4gIFRoZSBsZWFkZXIgYWNjdW11bGF0ZXMgdGhl c2UgaW50byBpdHMKK293biBzdGFjay4KKworV2hlbiBwZXItbm9kZSBpbnN0cnVtZW50YXRpb24g aXMgYWN0aXZlLCBwYXJhbGxlbCB3b3JrZXJzIHNraXAgcGVyLW5vZGUKK2ZpbmFsaXphdGlvbiBh dCBzaHV0ZG93biB0byBhdm9pZCBkb3VibGUtY291bnRpbmc7IHRoZSBwZXItbm9kZSBkYXRhIGlz CithZ2dyZWdhdGVkIHNlcGFyYXRlbHkgdGhyb3VnaCBJbnN0ckFnZ05vZGUoKS4KKworCitNZW1v cnkgSGFuZGxpbmcKKz09PT09PT09PT09PT09PQorCitJbnN0cnVtZW50YXRpb24gb2JqZWN0cyB0 aGF0IHVzZSB0aGUgc3RhY2sgbXVzdCBzdXJ2aXZlIHVudGlsIGZpbmFsaXphdGlvbgorcnVucywg aW5jbHVkaW5nIHRoZSBhYm9ydCBjYXNlLiAgVG8gZW5zdXJlIHRoaXMsIFF1ZXJ5SW5zdHJ1bWVu dGF0aW9uCitjcmVhdGVzIGEgZGVkaWNhdGVkICJJbnN0cnVtZW50YXRpb24iIE1lbW9yeUNvbnRl eHQgKGluc3RyX2N4dCkgYXMgYSBjaGlsZAorb2YgVG9wTWVtb3J5Q29udGV4dC4gIEFsbCBjaGls ZCBpbnN0cnVtZW50YXRpb24gKG5vZGVzLCB0cmlnZ2Vycykgc2hvdWxkIGJlCithbGxvY2F0ZWQg aW4gdGhpcyBjb250ZXh0LgorCitPbiBzdWNjZXNzZnVsIGNvbXBsZXRpb24sIGluc3RyX2N4dCBp cyByZXBhcmVudGVkIHRvIEN1cnJlbnRNZW1vcnlDb250ZXh0CitzbyBpdHMgbGlmZXRpbWUgaXMg dGllZCB0byB0aGUgY2FsbGVyJ3MgY29udGV4dC4gIE9uIGFib3J0LCB0aGUKK1Jlc291cmNlT3du ZXIgY2xlYW51cCBmcmVlcyBpdCBhZnRlciBhY2N1bXVsYXRpbmcgdGhlIGluc3RydW1lbnRhdGlv biBkYXRhCit0byB0aGUgY3VycmVudCBzdGFjayBlbnRyeSBhZnRlciByZXNldHRpbmcgdGhlIHN0 YWNrLgorCitXaGVuIHRoZSBzdGFjayBpcyBub3QgbmVlZGVkICh0aW1lci9yb3dzIG9ubHkpLCBJ bnN0cnVtZW50YXRpb24gYWxsb2NhdGlvbnMKK2hhcHBlbiBpbiBDdXJyZW50TWVtb3J5Q29udGV4 dCBpbnN0ZWFkIG9mIFRvcE1lbW9yeUNvbnRleHQuCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9l eGVjdXRvci9leGVjTWFpbi5jIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY01haW4uYwppbmRl eCBiMGY2MzZiZjhiNi4uZDBjZDM0ZDI4NmMgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1 dG9yL2V4ZWNNYWluLmMKKysrIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY01haW4uYwpAQCAt NzgsNiArNzgsNyBAQCBFeGVjdXRvckNoZWNrUGVybXNfaG9va190eXBlIEV4ZWN1dG9yQ2hlY2tQ ZXJtc19ob29rID0gTlVMTDsKIC8qIGRlY2xzIGZvciBsb2NhbCByb3V0aW5lcyBvbmx5IHVzZWQg d2l0aGluIHRoaXMgbW9kdWxlICovCiBzdGF0aWMgdm9pZCBJbml0UGxhbihRdWVyeURlc2MgKnF1 ZXJ5RGVzYywgaW50IGVmbGFncyk7CiBzdGF0aWMgdm9pZCBDaGVja1ZhbGlkUm93TWFya1JlbChS ZWxhdGlvbiByZWwsIFJvd01hcmtUeXBlIG1hcmtUeXBlKTsKK3N0YXRpYyB2b2lkIEV4ZWNGaW5h bGl6ZVRyaWdnZXJJbnN0cnVtZW50YXRpb24oRVN0YXRlICplc3RhdGUpOwogc3RhdGljIHZvaWQg RXhlY1Bvc3Rwcm9jZXNzUGxhbihFU3RhdGUgKmVzdGF0ZSk7CiBzdGF0aWMgdm9pZCBFeGVjRW5k UGxhbihQbGFuU3RhdGUgKnBsYW5zdGF0ZSwgRVN0YXRlICplc3RhdGUpOwogc3RhdGljIHZvaWQg RXhlY3V0ZVBsYW4oUXVlcnlEZXNjICpxdWVyeURlc2MsCkBAIC0yNDcsOSArMjQ4LDE2IEBAIHN0 YW5kYXJkX0V4ZWN1dG9yU3RhcnQoUXVlcnlEZXNjICpxdWVyeURlc2MsIGludCBlZmxhZ3MpCiAJ ZXN0YXRlLT5lc19zbmFwc2hvdCA9IFJlZ2lzdGVyU25hcHNob3QocXVlcnlEZXNjLT5zbmFwc2hv dCk7CiAJZXN0YXRlLT5lc19jcm9zc2NoZWNrX3NuYXBzaG90ID0gUmVnaXN0ZXJTbmFwc2hvdChx dWVyeURlc2MtPmNyb3NzY2hlY2tfc25hcHNob3QpOwogCWVzdGF0ZS0+ZXNfdG9wX2VmbGFncyA9 IGVmbGFnczsKLQllc3RhdGUtPmVzX2luc3RydW1lbnQgPSBxdWVyeURlc2MtPmluc3RydW1lbnRf b3B0aW9uczsKIAllc3RhdGUtPmVzX2ppdF9mbGFncyA9IHF1ZXJ5RGVzYy0+cGxhbm5lZHN0bXQt PmppdEZsYWdzOwogCisJLyoKKwkgKiBTZXQgdXAgcGVyLW5vZGUgaW5zdHJ1bWVudGF0aW9uIGlm IG5lZWRlZC4gV2UgZG8gdGhpcyBiZWZvcmUgSW5pdFBsYW4KKwkgKiBzbyB0aGF0IG5vZGUgYW5k IHRyaWdnZXIgaW5zdHJ1bWVudGF0aW9uIGNhbiBiZSBhbGxvY2F0ZWQgd2l0aGluIHRoZQorCSAq IHF1ZXJ5J3MgZGVkaWNhdGVkIGluc3RydW1lbnRhdGlvbiBtZW1vcnkgY29udGV4dC4KKwkgKi8K KwlpZiAoIWVzdGF0ZS0+ZXNfaW5zdHJ1bWVudCAmJiBxdWVyeURlc2MtPmluc3RydW1lbnRfb3B0 aW9ucykKKwkJZXN0YXRlLT5lc19pbnN0cnVtZW50ID0gSW5zdHJRdWVyeUFsbG9jKHF1ZXJ5RGVz Yy0+aW5zdHJ1bWVudF9vcHRpb25zKTsKKwogCS8qCiAJICogU2V0IHVwIGFuIEFGVEVSLXRyaWdn ZXIgc3RhdGVtZW50IGNvbnRleHQsIHVubGVzcyB0b2xkIG5vdCB0bywgb3IKIAkgKiB1bmxlc3Mg aXQncyBFWFBMQUlOLW9ubHkgbW9kZSAod2hlbiBFeGVjdXRvckZpbmlzaCB3b24ndCBiZSBjYWxs ZWQpLgpAQCAtMzMxLDkgKzMzOSwxMSBAQCBzdGFuZGFyZF9FeGVjdXRvclJ1bihRdWVyeURlc2Mg KnF1ZXJ5RGVzYywKIAkgKi8KIAlvbGRjb250ZXh0ID0gTWVtb3J5Q29udGV4dFN3aXRjaFRvKGVz dGF0ZS0+ZXNfcXVlcnlfY3h0KTsKIAotCS8qIEFsbG93IGluc3RydW1lbnRhdGlvbiBvZiBFeGVj dXRvciBvdmVyYWxsIHJ1bnRpbWUgKi8KKwkvKiBTdGFydCB1cCBpbnN0cnVtZW50YXRpb24gZm9y IHRoaXMgZXhlY3V0aW9uIHJ1biAqLwogCWlmIChxdWVyeURlc2MtPnRvdGFsdGltZSkKLQkJSW5z dHJTdGFydChxdWVyeURlc2MtPnRvdGFsdGltZSk7CisJCUluc3RyUXVlcnlTdGFydChxdWVyeURl c2MtPnRvdGFsdGltZSk7CisJaWYgKGVzdGF0ZS0+ZXNfaW5zdHJ1bWVudCkKKwkJSW5zdHJRdWVy eVN0YXJ0KGVzdGF0ZS0+ZXNfaW5zdHJ1bWVudCk7CiAKIAkvKgogCSAqIGV4dHJhY3QgaW5mb3Jt YXRpb24gZnJvbSB0aGUgcXVlcnkgZGVzY3JpcHRvciBhbmQgdGhlIHF1ZXJ5IGZlYXR1cmUuCkBA IC0zODQsOCArMzk0LDEwIEBAIHN0YW5kYXJkX0V4ZWN1dG9yUnVuKFF1ZXJ5RGVzYyAqcXVlcnlE ZXNjLAogCWlmIChzZW5kVHVwbGVzKQogCQlkZXN0LT5yU2h1dGRvd24oZGVzdCk7CiAKKwlpZiAo ZXN0YXRlLT5lc19pbnN0cnVtZW50KQorCQlJbnN0clF1ZXJ5U3RvcChlc3RhdGUtPmVzX2luc3Ry dW1lbnQpOwogCWlmIChxdWVyeURlc2MtPnRvdGFsdGltZSkKLQkJSW5zdHJTdG9wKHF1ZXJ5RGVz Yy0+dG90YWx0aW1lKTsKKwkJSW5zdHJRdWVyeVN0b3AocXVlcnlEZXNjLT50b3RhbHRpbWUpOwog CiAJTWVtb3J5Q29udGV4dFN3aXRjaFRvKG9sZGNvbnRleHQpOwogfQpAQCAtNDM1LDcgKzQ0Nyw5 IEBAIHN0YW5kYXJkX0V4ZWN1dG9yRmluaXNoKFF1ZXJ5RGVzYyAqcXVlcnlEZXNjKQogCiAJLyog QWxsb3cgaW5zdHJ1bWVudGF0aW9uIG9mIEV4ZWN1dG9yIG92ZXJhbGwgcnVudGltZSAqLwogCWlm IChxdWVyeURlc2MtPnRvdGFsdGltZSkKLQkJSW5zdHJTdGFydChxdWVyeURlc2MtPnRvdGFsdGlt ZSk7CisJCUluc3RyUXVlcnlTdGFydChxdWVyeURlc2MtPnRvdGFsdGltZSk7CisJaWYgKGVzdGF0 ZS0+ZXNfaW5zdHJ1bWVudCkKKwkJSW5zdHJRdWVyeVN0YXJ0KGVzdGF0ZS0+ZXNfaW5zdHJ1bWVu dCk7CiAKIAkvKiBSdW4gTW9kaWZ5VGFibGUgbm9kZXMgdG8gY29tcGxldGlvbiAqLwogCUV4ZWNQ b3N0cHJvY2Vzc1BsYW4oZXN0YXRlKTsKQEAgLTQ0NCw4ICs0NTgsMzIgQEAgc3RhbmRhcmRfRXhl Y3V0b3JGaW5pc2goUXVlcnlEZXNjICpxdWVyeURlc2MpCiAJaWYgKCEoZXN0YXRlLT5lc190b3Bf ZWZsYWdzICYgRVhFQ19GTEFHX1NLSVBfVFJJR0dFUlMpKQogCQlBZnRlclRyaWdnZXJFbmRRdWVy eShlc3RhdGUpOwogCisJaWYgKGVzdGF0ZS0+ZXNfaW5zdHJ1bWVudCkKKwl7CisJCS8qCisJCSAq IEFjY3VtdWxhdGUgcGVyLW5vZGUgYW5kIHRyaWdnZXIgc3RhdGlzdGljcyB0byB0aGVpciByZXNw ZWN0aXZlCisJCSAqIHBhcmVudCBpbnN0cnVtZW50YXRpb24gc3RhY2tzLgorCQkgKgorCQkgKiBX ZSBza2lwIHRoaXMgaW4gcGFyYWxsZWwgd29ya2VycyBiZWNhdXNlIHRoZWlyIHBlci1ub2RlIHN0 YXRzIGFyZQorCQkgKiByZXBvcnRlZCBpbmRpdmlkdWFsbHkgdmlhIEV4ZWNQYXJhbGxlbFJlcG9y dEluc3RydW1lbnRhdGlvbiwgYW5kCisJCSAqIHRoZSBsZWFkZXIncyBvd24gRXhlY0ZpbmFsaXpl Tm9kZUluc3RydW1lbnRhdGlvbiBoYW5kbGVzCisJCSAqIHByb3BhZ2F0aW9uLiAgSWYgd2UgYWNj dW11bGF0ZWQgaGVyZSwgdGhlIGxlYWRlciB3b3VsZAorCQkgKiBkb3VibGUtY291bnQ6IHdvcmtl ciBwYXJlbnQgbm9kZXMgd291bGQgYWxyZWFkeSBpbmNsdWRlIHRoZWlyCisJCSAqIGNoaWxkcmVu J3Mgc3RhdHMsIGFuZCB0aGVuIHRoZSBsZWFkZXIncyBhY2N1bXVsYXRpb24gd291bGQgYWRkIHRo ZQorCQkgKiBjaGlsZHJlbiBhZ2Fpbi4KKwkJICovCisJCWlmICghSXNQYXJhbGxlbFdvcmtlcigp KQorCQl7CisJCQlFeGVjRmluYWxpemVOb2RlSW5zdHJ1bWVudGF0aW9uKHF1ZXJ5RGVzYy0+cGxh bnN0YXRlKTsKKworCQkJRXhlY0ZpbmFsaXplVHJpZ2dlckluc3RydW1lbnRhdGlvbihlc3RhdGUp OworCQl9CisKKwkJSW5zdHJRdWVyeVN0b3BGaW5hbGl6ZShlc3RhdGUtPmVzX2luc3RydW1lbnQp OworCX0KKwogCWlmIChxdWVyeURlc2MtPnRvdGFsdGltZSkKLQkJSW5zdHJTdG9wKHF1ZXJ5RGVz Yy0+dG90YWx0aW1lKTsKKwkJSW5zdHJRdWVyeVN0b3BGaW5hbGl6ZShxdWVyeURlc2MtPnRvdGFs dGltZSk7CiAKIAlNZW1vcnlDb250ZXh0U3dpdGNoVG8ob2xkY29udGV4dCk7CiAKQEAgLTEyNjMs NyArMTMwMSw3IEBAIEluaXRSZXN1bHRSZWxJbmZvKFJlc3VsdFJlbEluZm8gKnJlc3VsdFJlbElu Zm8sCiAJCQkJICBSZWxhdGlvbiByZXN1bHRSZWxhdGlvbkRlc2MsCiAJCQkJICBJbmRleCByZXN1 bHRSZWxhdGlvbkluZGV4LAogCQkJCSAgUmVzdWx0UmVsSW5mbyAqcGFydGl0aW9uX3Jvb3RfcnJp LAotCQkJCSAgaW50IGluc3RydW1lbnRfb3B0aW9ucykKKwkJCQkgIFF1ZXJ5SW5zdHJ1bWVudGF0 aW9uICpxaW5zdHIpCiB7CiAJTWVtU2V0KHJlc3VsdFJlbEluZm8sIDAsIHNpemVvZihSZXN1bHRS ZWxJbmZvKSk7CiAJcmVzdWx0UmVsSW5mby0+dHlwZSA9IFRfUmVzdWx0UmVsSW5mbzsKQEAgLTEy ODQsOCArMTMyMiw4IEBAIEluaXRSZXN1bHRSZWxJbmZvKFJlc3VsdFJlbEluZm8gKnJlc3VsdFJl bEluZm8sCiAJCQlwYWxsb2MwX2FycmF5KEZtZ3JJbmZvLCBuKTsKIAkJcmVzdWx0UmVsSW5mby0+ cmlfVHJpZ1doZW5FeHBycyA9IChFeHByU3RhdGUgKiopCiAJCQlwYWxsb2MwX2FycmF5KEV4cHJT dGF0ZSAqLCBuKTsKLQkJaWYgKGluc3RydW1lbnRfb3B0aW9ucykKLQkJCXJlc3VsdFJlbEluZm8t PnJpX1RyaWdJbnN0cnVtZW50ID0gSW5zdHJBbGxvY1RyaWdnZXIobiwgaW5zdHJ1bWVudF9vcHRp b25zKTsKKwkJaWYgKHFpbnN0cikKKwkJCXJlc3VsdFJlbEluZm8tPnJpX1RyaWdJbnN0cnVtZW50 ID0gSW5zdHJBbGxvY1RyaWdnZXIocWluc3RyLCBuKTsKIAl9CiAJZWxzZQogCXsKQEAgLTEzNTgs NiArMTM5NiwxMCBAQCBJbml0UmVzdWx0UmVsSW5mbyhSZXN1bHRSZWxJbmZvICpyZXN1bHRSZWxJ bmZvLAogICogYWxzbyBwcm92aWRlcyBhIHdheSBmb3IgRVhQTEFJTiBBTkFMWVpFIHRvIHJlcG9y dCB0aGUgcnVudGltZXMgb2Ygc3VjaAogICogdHJpZ2dlcnMuKSAgU28gd2UgbWFrZSBhZGRpdGlv bmFsIFJlc3VsdFJlbEluZm8ncyBhcyBuZWVkZWQsIGFuZCBzYXZlIHRoZW0KICAqIGluIGVzX3Ry aWdfdGFyZ2V0X3JlbGF0aW9ucy4KKyAqCisgKiBOb3RlOiBpZiBuZXcgcmVsYXRpb24gbGlzdHMg YXJlIHNlYXJjaGVkIGhlcmUsIHRoZXkgbXVzdCBhbHNvIGJlIGFkZGVkIHRvCisgKiBFeGVjRmlu YWxpemVUcmlnZ2VySW5zdHJ1bWVudGF0aW9uIHNvIHRoYXQgdHJpZ2dlciBpbnN0cnVtZW50YXRp b24gZGF0YQorICogaXMgcHJvcGVybHkgYWNjdW11bGF0ZWQuCiAgKi8KIFJlc3VsdFJlbEluZm8g KgogRXhlY0dldFRyaWdnZXJSZXN1bHRSZWwoRVN0YXRlICplc3RhdGUsIE9pZCByZWxpZCwKQEAg LTE1MDAsNiArMTU0MiwzMCBAQCBFeGVjR2V0QW5jZXN0b3JSZXN1bHRSZWxzKEVTdGF0ZSAqZXN0 YXRlLCBSZXN1bHRSZWxJbmZvICpyZXN1bHRSZWxJbmZvKQogCXJldHVybiByZXN1bHRSZWxJbmZv LT5yaV9hbmNlc3RvclJlc3VsdFJlbHM7CiB9CiAKK3N0YXRpYyB2b2lkCitFeGVjRmluYWxpemVU cmlnZ2VySW5zdHJ1bWVudGF0aW9uKEVTdGF0ZSAqZXN0YXRlKQoreworCUxpc3QJICAgKnJlbHMg PSBOSUw7CisKKwlyZWxzID0gbGlzdF9jb25jYXQocmVscywgZXN0YXRlLT5lc190dXBsZV9yb3V0 aW5nX3Jlc3VsdF9yZWxhdGlvbnMpOworCXJlbHMgPSBsaXN0X2NvbmNhdChyZWxzLCBlc3RhdGUt PmVzX29wZW5lZF9yZXN1bHRfcmVsYXRpb25zKTsKKwlyZWxzID0gbGlzdF9jb25jYXQocmVscywg ZXN0YXRlLT5lc190cmlnX3RhcmdldF9yZWxhdGlvbnMpOworCisJZm9yZWFjaF9ub2RlKFJlc3Vs dFJlbEluZm8sIHJJbmZvLCByZWxzKQorCXsKKwkJVHJpZ2dlckluc3RydW1lbnRhdGlvbiAqdGkg PSBySW5mby0+cmlfVHJpZ0luc3RydW1lbnQ7CisKKwkJaWYgKHRpID09IE5VTEwgfHwgckluZm8t PnJpX1RyaWdEZXNjID09IE5VTEwpCisJCQljb250aW51ZTsKKworCQlmb3IgKGludCBudCA9IDA7 IG50IDwgckluZm8tPnJpX1RyaWdEZXNjLT5udW10cmlnZ2VyczsgbnQrKykKKwkJeworCQkJaWYg KHRpW250XS5pbnN0ci5uZWVkX3N0YWNrKQorCQkJCUluc3RyQWNjdW1TdGFjaygmZXN0YXRlLT5l c19pbnN0cnVtZW50LT5pbnN0ciwgJnRpW250XS5pbnN0cik7CisJCX0KKwl9Cit9CisKIC8qIC0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0KICAqCQlFeGVjUG9zdHByb2Nlc3NQbGFuCiAgKgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tl bmQvZXhlY3V0b3IvZXhlY1BhcmFsbGVsLmMgYi9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjUGFy YWxsZWwuYwppbmRleCA3OGY2MGMxNTMwYy4uYzAxZTc4MGY5MTggMTAwNjQ0Ci0tLSBhL3NyYy9i YWNrZW5kL2V4ZWN1dG9yL2V4ZWNQYXJhbGxlbC5jCisrKyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9y L2V4ZWNQYXJhbGxlbC5jCkBAIC03MDAsNyArNzAwLDcgQEAgRXhlY0luaXRQYXJhbGxlbFBsYW4o UGxhblN0YXRlICpwbGFuc3RhdGUsIEVTdGF0ZSAqZXN0YXRlLAogCSAqCiAJICogSWYgRVhQTEFJ TiBpcyBub3QgaW4gdXNlIGFuZCB0aGVyZSBhcmUgbm8gZXh0ZW5zaW9ucyBsb2FkZWQgdGhhdCBj YXJlLAogCSAqIHdlIGNvdWxkIHNraXAgdGhpcy4gIEJ1dCB3ZSBoYXZlIG5vIHdheSBvZiBrbm93 aW5nIHdoZXRoZXIgYW55b25lJ3MKLQkgKiBsb29raW5nIGF0IHBnQnVmZmVyVXNhZ2UsIHNvIGRv IGl0IHVuY29uZGl0aW9uYWxseS4KKwkgKiBsb29raW5nIGF0IGluc3RydW1lbnRhdGlvbiwgc28g ZG8gaXQgdW5jb25kaXRpb25hbGx5LgogCSAqLwogCXNobV90b2NfZXN0aW1hdGVfY2h1bmsoJnBj eHQtPmVzdGltYXRvciwKIAkJCQkJCSAgIG11bF9zaXplKHNpemVvZihCdWZmZXJVc2FnZSksIHBj eHQtPm53b3JrZXJzKSk7CkBAIC04MjUsMTMgKzgyNSwxMyBAQCBFeGVjSW5pdFBhcmFsbGVsUGxh bihQbGFuU3RhdGUgKnBsYW5zdGF0ZSwgRVN0YXRlICplc3RhdGUsCiAJCWludAkJCWk7CiAKIAkJ aW5zdHJ1bWVudGF0aW9uID0gc2htX3RvY19hbGxvY2F0ZShwY3h0LT50b2MsIGluc3RydW1lbnRh dGlvbl9sZW4pOwotCQlpbnN0cnVtZW50YXRpb24tPmluc3RydW1lbnRfb3B0aW9ucyA9IGVzdGF0 ZS0+ZXNfaW5zdHJ1bWVudDsKKwkJaW5zdHJ1bWVudGF0aW9uLT5pbnN0cnVtZW50X29wdGlvbnMg PSBlc3RhdGUtPmVzX2luc3RydW1lbnQtPmluc3RydW1lbnRfb3B0aW9uczsKIAkJaW5zdHJ1bWVu dGF0aW9uLT5pbnN0cnVtZW50X29mZnNldCA9IGluc3RydW1lbnRfb2Zmc2V0OwogCQlpbnN0cnVt ZW50YXRpb24tPm51bV93b3JrZXJzID0gbndvcmtlcnM7CiAJCWluc3RydW1lbnRhdGlvbi0+bnVt X3BsYW5fbm9kZXMgPSBlLm5ub2RlczsKIAkJaW5zdHJ1bWVudCA9IEdldEluc3RydW1lbnRhdGlv bkFycmF5KGluc3RydW1lbnRhdGlvbik7CiAJCWZvciAoaSA9IDA7IGkgPCBud29ya2VycyAqIGUu bm5vZGVzOyArK2kpCi0JCQlJbnN0ckluaXROb2RlKCZpbnN0cnVtZW50W2ldLCBlc3RhdGUtPmVz X2luc3RydW1lbnQpOworCQkJSW5zdHJJbml0Tm9kZSgmaW5zdHJ1bWVudFtpXSwgZXN0YXRlLT5l c19pbnN0cnVtZW50LT5pbnN0cnVtZW50X29wdGlvbnMpOwogCQlzaG1fdG9jX2luc2VydChwY3h0 LT50b2MsIFBBUkFMTEVMX0tFWV9JTlNUUlVNRU5UQVRJT04sCiAJCQkJCSAgIGluc3RydW1lbnRh dGlvbik7CiAJCXBlaS0+aW5zdHJ1bWVudGF0aW9uID0gaW5zdHJ1bWVudGF0aW9uOwpAQCAtMTA4 MSwxNCArMTA4MSwyOCBAQCBFeGVjUGFyYWxsZWxSZXRyaWV2ZUluc3RydW1lbnRhdGlvbihQbGFu U3RhdGUgKnBsYW5zdGF0ZSwKIAlpbnN0cnVtZW50ID0gR2V0SW5zdHJ1bWVudGF0aW9uQXJyYXko aW5zdHJ1bWVudGF0aW9uKTsKIAlpbnN0cnVtZW50ICs9IGkgKiBpbnN0cnVtZW50YXRpb24tPm51 bV93b3JrZXJzOwogCWZvciAobiA9IDA7IG4gPCBpbnN0cnVtZW50YXRpb24tPm51bV93b3JrZXJz OyArK24pCisJewogCQlJbnN0ckFnZ05vZGUocGxhbnN0YXRlLT5pbnN0cnVtZW50LCAmaW5zdHJ1 bWVudFtuXSk7CiAKKwkJLyoKKwkJICogQWxzbyBhZGQgd29ya2VyIFdBTCB1c2FnZSB0byB0aGUg Z2xvYmFsIHBnV2FsVXNhZ2UgY291bnRlci4KKwkJICoKKwkJICogV2hlbiBwZXItbm9kZSBpbnN0 cnVtZW50YXRpb24gaXMgYWN0aXZlLCBwYXJhbGxlbCB3b3JrZXJzIHNraXAKKwkJICogRXhlY0Zp bmFsaXplTm9kZUluc3RydW1lbnRhdGlvbiAodG8gYXZvaWQgZG91YmxlLWNvdW50aW5nIGluCisJ CSAqIEVYUExBSU4pLCBzbyBwZXItbm9kZSBXQUwgYWN0aXZpdHkgaXMgbm90IHJvbGxlZCB1cCBp bnRvIHRoZQorCQkgKiBxdWVyeS1sZXZlbCBzdGF0cyB0aGF0IEluc3RyQWNjdW1QYXJhbGxlbFF1 ZXJ5IHJlY2VpdmVzLiBXaXRob3V0CisJCSAqIHRoaXMsIHBnV2FsVXNhZ2Ugd291bGQgdW5kZXIt cmVwb3J0IFdBTCBnZW5lcmF0ZWQgYnkgcGFyYWxsZWwKKwkJICogd29ya2VycyB3aGVuIGluc3Ry dW1lbnRhdGlvbiBpcyBhY3RpdmUuCisJCSAqLworCQlXYWxVc2FnZUFkZCgmcGdXYWxVc2FnZSwg Jmluc3RydW1lbnRbbl0uaW5zdHIud2FsdXNhZ2UpOworCX0KKwogCS8qCiAJICogQWxzbyBzdG9y ZSB0aGUgcGVyLXdvcmtlciBkZXRhaWwuCiAJICoKLQkgKiBXb3JrZXIgaW5zdHJ1bWVudGF0aW9u IHNob3VsZCBiZSBhbGxvY2F0ZWQgaW4gdGhlIHNhbWUgY29udGV4dCBhcyB0aGUKLQkgKiByZWd1 bGFyIGluc3RydW1lbnRhdGlvbiBpbmZvcm1hdGlvbiwgd2hpY2ggaXMgdGhlIHBlci1xdWVyeSBj b250ZXh0LgotCSAqIFN3aXRjaCBpbnRvIHBlci1xdWVyeSBtZW1vcnkgY29udGV4dC4KKwkgKiBF bnN1cmUgd29ya2VyIGluc3RydW1lbnRhdGlvbiBpcyBhbGxvY2F0ZWQgaW4gdGhlIHBlci1xdWVy eSBjb250ZXh0LiBXZQorCSAqIGRvbid0IG5lZWQgdG8gcGxhY2UgdGhpcyBpbiB0aGUgaW5zdHJ1 bWVudGF0aW9uIGNvbnRleHQgc2luY2Ugbm8gbW9yZQorCSAqIHN0YWNrLWJhc2VkIGluc3RydW1l bnRhdGlvbiB3b3JrIGlzIGJlaW5nIGRvbmUuCiAJICovCiAJb2xkY29udGV4dCA9IE1lbW9yeUNv bnRleHRTd2l0Y2hUbyhwbGFuc3RhdGUtPnN0YXRlLT5lc19xdWVyeV9jeHQpOwogCWlieXRlcyA9 IG11bF9zaXplKGluc3RydW1lbnRhdGlvbi0+bnVtX3dvcmtlcnMsIHNpemVvZihOb2RlSW5zdHJ1 bWVudGF0aW9uKSk7CkBAIC0xMjM4LDkgKzEyNTIsMTMgQEAgRXhlY1BhcmFsbGVsQ2xlYW51cChQ YXJhbGxlbEV4ZWN1dG9ySW5mbyAqcGVpKQogewogCS8qIEFjY3VtdWxhdGUgaW5zdHJ1bWVudGF0 aW9uLCBpZiBhbnkuICovCiAJaWYgKHBlaS0+aW5zdHJ1bWVudGF0aW9uKQorCXsKIAkJRXhlY1Bh cmFsbGVsUmV0cmlldmVJbnN0cnVtZW50YXRpb24ocGVpLT5wbGFuc3RhdGUsCiAJCQkJCQkJCQkJ CXBlaS0+aW5zdHJ1bWVudGF0aW9uKTsKIAorCQlFeGVjRmluYWxpemVXb3JrZXJJbnN0cnVtZW50 YXRpb24ocGVpLT5wbGFuc3RhdGUpOworCX0KKwogCS8qIEFjY3VtdWxhdGUgSklUIGluc3RydW1l bnRhdGlvbiwgaWYgYW55LiAqLwogCWlmIChwZWktPmppdF9pbnN0cnVtZW50YXRpb24pCiAJCUV4 ZWNQYXJhbGxlbFJldHJpZXZlSml0SW5zdHJ1bWVudGF0aW9uKHBlaS0+cGxhbnN0YXRlLApAQCAt MTQ2Miw2ICsxNDgwLDcgQEAgdm9pZAogUGFyYWxsZWxRdWVyeU1haW4oZHNtX3NlZ21lbnQgKnNl Zywgc2htX3RvYyAqdG9jKQogewogCUZpeGVkUGFyYWxsZWxFeGVjdXRvclN0YXRlICpmcGVzOwor CVF1ZXJ5SW5zdHJ1bWVudGF0aW9uICppbnN0cjsKIAlCdWZmZXJVc2FnZSAqYnVmZmVyX3VzYWdl OwogCVdhbFVzYWdlICAgKndhbF91c2FnZTsKIAlEZXN0UmVjZWl2ZXIgKnJlY2VpdmVyOwpAQCAt MTUyMiw3ICsxNTQxLDcgQEAgUGFyYWxsZWxRdWVyeU1haW4oZHNtX3NlZ21lbnQgKnNlZywgc2ht X3RvYyAqdG9jKQogCSAqIGxlYWRlciwgd2hpY2ggYWxzbyBkb2Vzbid0IGNvdW50IGJ1ZmZlciBh Y2Nlc3NlcyBhbmQgV0FMIGFjdGl2aXR5IHRoYXQKIAkgKiBvY2N1ciBkdXJpbmcgZXhlY3V0b3Ig c3RhcnR1cC4KIAkgKi8KLQlJbnN0clN0YXJ0UGFyYWxsZWxRdWVyeSgpOworCWluc3RyID0gSW5z dHJTdGFydFBhcmFsbGVsUXVlcnkoKTsKIAogCS8qCiAJICogUnVuIHRoZSBwbGFuLiAgSWYgd2Ug c3BlY2lmaWVkIGEgdHVwbGUgYm91bmQsIGJlIGNhcmVmdWwgbm90IHRvIGRlbWFuZApAQCAtMTUz OCw3ICsxNTU3LDggQEAgUGFyYWxsZWxRdWVyeU1haW4oZHNtX3NlZ21lbnQgKnNlZywgc2htX3Rv YyAqdG9jKQogCS8qIFJlcG9ydCBidWZmZXIvV0FMIHVzYWdlIGR1cmluZyBwYXJhbGxlbCBleGVj dXRpb24uICovCiAJYnVmZmVyX3VzYWdlID0gc2htX3RvY19sb29rdXAodG9jLCBQQVJBTExFTF9L RVlfQlVGRkVSX1VTQUdFLCBmYWxzZSk7CiAJd2FsX3VzYWdlID0gc2htX3RvY19sb29rdXAodG9j LCBQQVJBTExFTF9LRVlfV0FMX1VTQUdFLCBmYWxzZSk7Ci0JSW5zdHJFbmRQYXJhbGxlbFF1ZXJ5 KCZidWZmZXJfdXNhZ2VbUGFyYWxsZWxXb3JrZXJOdW1iZXJdLAorCUluc3RyRW5kUGFyYWxsZWxR dWVyeShpbnN0ciwKKwkJCQkJCSAgJmJ1ZmZlcl91c2FnZVtQYXJhbGxlbFdvcmtlck51bWJlcl0s CiAJCQkJCQkgICZ3YWxfdXNhZ2VbUGFyYWxsZWxXb3JrZXJOdW1iZXJdKTsKIAogCS8qIFJlcG9y dCBpbnN0cnVtZW50YXRpb24gZGF0YSBpZiBhbnkgaW5zdHJ1bWVudGF0aW9uIG9wdGlvbnMgYXJl IHNldC4gKi8KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNQYXJ0aXRpb24u YyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNQYXJ0aXRpb24uYwppbmRleCBkOTZkNGY5OTQ3 Yi4uNmYyOTA5YTFiYzMgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNQYXJ0 aXRpb24uYworKysgYi9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjUGFydGl0aW9uLmMKQEAgLTEz ODEsNyArMTM4MSw3IEBAIEV4ZWNJbml0UGFydGl0aW9uRGlzcGF0Y2hJbmZvKEVTdGF0ZSAqZXN0 YXRlLAogCXsKIAkJUmVzdWx0UmVsSW5mbyAqcnJpID0gbWFrZU5vZGUoUmVzdWx0UmVsSW5mbyk7 CiAKLQkJSW5pdFJlc3VsdFJlbEluZm8ocnJpLCByZWwsIDAsIHJvb3RSZXN1bHRSZWxJbmZvLCAw KTsKKwkJSW5pdFJlc3VsdFJlbEluZm8ocnJpLCByZWwsIDAsIHJvb3RSZXN1bHRSZWxJbmZvLCBO VUxMKTsKIAkJcHJvdXRlLT5ub25sZWFmX3BhcnRpdGlvbnNbZGlzcGF0Y2hpZHhdID0gcnJpOwog CX0KIAllbHNlCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjUHJvY25vZGUu YyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNQcm9jbm9kZS5jCmluZGV4IDEzMmZlMzdlZjYw Li4zYjNlYzk4NTBlOCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY1Byb2Nu b2RlLmMKKysrIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY1Byb2Nub2RlLmMKQEAgLTEyMyw2 ICsxMjMsOCBAQAogc3RhdGljIFR1cGxlVGFibGVTbG90ICpFeGVjUHJvY05vZGVGaXJzdChQbGFu U3RhdGUgKm5vZGUpOwogc3RhdGljIFR1cGxlVGFibGVTbG90ICpFeGVjUHJvY05vZGVJbnN0cihQ bGFuU3RhdGUgKm5vZGUpOwogc3RhdGljIGJvb2wgRXhlY1NodXRkb3duTm9kZV93YWxrZXIoUGxh blN0YXRlICpub2RlLCB2b2lkICpjb250ZXh0KTsKK3N0YXRpYyBib29sIEV4ZWNGaW5hbGl6ZU5v ZGVJbnN0cnVtZW50YXRpb25fd2Fsa2VyKFBsYW5TdGF0ZSAqbm9kZSwgdm9pZCAqY29udGV4dCk7 CitzdGF0aWMgYm9vbCBFeGVjRmluYWxpemVXb3JrZXJJbnN0cnVtZW50YXRpb25fd2Fsa2VyKFBs YW5TdGF0ZSAqbm9kZSwgdm9pZCAqY29udGV4dCk7CiAKIAogLyogLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCkBA IC03ODgsMTAgKzc5MCwxMCBAQCBFeGVjU2h1dGRvd25Ob2RlX3dhbGtlcihQbGFuU3RhdGUgKm5v ZGUsIHZvaWQgKmNvbnRleHQpCiAJICogYXQgbGVhc3Qgb25jZSBhbHJlYWR5LiAgV2UgZG9uJ3Qg ZXhwZWN0IG11Y2ggQ1BVIGNvbnN1bXB0aW9uIGR1cmluZwogCSAqIG5vZGUgc2h1dGRvd24sIGJ1 dCBpbiB0aGUgY2FzZSBvZiBHYXRoZXIgb3IgR2F0aGVyIE1lcmdlLCB3ZSBtYXkgc2h1dAogCSAq IGRvd24gd29ya2VycyBhdCB0aGlzIHN0YWdlLiAgSWYgc28sIHRoZWlyIGJ1ZmZlciB1c2FnZSB3 aWxsIGdldAotCSAqIHByb3BhZ2F0ZWQgaW50byBwZ0J1ZmZlclVzYWdlIGF0IHRoaXMgcG9pbnQs IGFuZCB3ZSB3YW50IHRvIG1ha2Ugc3VyZQotCSAqIHRoYXQgaXQgZ2V0cyBhc3NvY2lhdGVkIHdp dGggdGhlIEdhdGhlciBub2RlLiAgV2Ugc2tpcCB0aGlzIGlmIHRoZSBub2RlCi0JICogaGFzIG5l dmVyIGJlZW4gZXhlY3V0ZWQsIHNvIGFzIHRvIGF2b2lkIGluY29ycmVjdGx5IG1ha2luZyBpdCBh cHBlYXIKLQkgKiB0aGF0IGl0IGhhcy4KKwkgKiBwcm9wYWdhdGVkIGludG8gdGhlIGN1cnJlbnQg aW5zdHJ1bWVudGF0aW9uIHN0YWNrIGVudHJ5IGF0IHRoaXMgcG9pbnQsCisJICogYW5kIHdlIHdh bnQgdG8gbWFrZSBzdXJlIHRoYXQgaXQgZ2V0cyBhc3NvY2lhdGVkIHdpdGggdGhlIEdhdGhlciBu b2RlLgorCSAqIFdlIHNraXAgdGhpcyBpZiB0aGUgbm9kZSBoYXMgbmV2ZXIgYmVlbiBleGVjdXRl ZCwgc28gYXMgdG8gYXZvaWQKKwkgKiBpbmNvcnJlY3RseSBtYWtpbmcgaXQgYXBwZWFyIHRoYXQg aXQgaGFzLgogCSAqLwogCWlmIChub2RlLT5pbnN0cnVtZW50ICYmIG5vZGUtPmluc3RydW1lbnQt PnJ1bm5pbmcpCiAJCUluc3RyU3RhcnROb2RlKG5vZGUtPmluc3RydW1lbnQpOwpAQCAtODI5LDYg KzgzMSw5OSBAQCBFeGVjU2h1dGRvd25Ob2RlX3dhbGtlcihQbGFuU3RhdGUgKm5vZGUsIHZvaWQg KmNvbnRleHQpCiAJcmV0dXJuIGZhbHNlOwogfQogCisvKgorICogRXhlY0ZpbmFsaXplTm9kZUlu c3RydW1lbnRhdGlvbgorICoKKyAqIEFjY3VtdWxhdGUgaW5zdHJ1bWVudGF0aW9uIHN0YXRzIGZy b20gYWxsIGV4ZWN1dGlvbiBub2RlcyB0byB0aGVpciByZXNwZWN0aXZlCisgKiBwYXJlbnRzIChv ciB0aGUgb3JpZ2luYWwgcGFyZW50IGluc3RydW1lbnRhdGlvbikuCisgKgorICogVGhpcyBtdXN0 IHJ1biBhZnRlciB0aGUgY2xlYW51cCBkb25lIGJ5IEV4ZWNTaHV0ZG93bk5vZGUsIGFuZCBub3Qg cmVseSBvbiBhbnkKKyAqIHJlc291cmNlcyBjbGVhbmVkIHVwIGJ5IGl0LiBXZSBhbHNvIGV4cGVj dCBzaHV0ZG93biBhY3Rpb25zIHRvIGhhdmUgb2NjdXJyZWQsCisgKiBlLmcuIHBhcmFsbGVsIHdv cmtlciBpbnN0cnVtZW50YXRpb24gdG8gaGF2ZSBiZWVuIGFkZGVkIHRvIHRoZSBsZWFkZXIuCisg Ki8KK3ZvaWQKK0V4ZWNGaW5hbGl6ZU5vZGVJbnN0cnVtZW50YXRpb24oUGxhblN0YXRlICpub2Rl KQoreworCSh2b2lkKSBFeGVjRmluYWxpemVOb2RlSW5zdHJ1bWVudGF0aW9uX3dhbGtlcihub2Rl LCBpbnN0cl9zdGFjay5jdXJyZW50KTsKK30KKworc3RhdGljIGJvb2wKK0V4ZWNGaW5hbGl6ZU5v ZGVJbnN0cnVtZW50YXRpb25fd2Fsa2VyKFBsYW5TdGF0ZSAqbm9kZSwgdm9pZCAqY29udGV4dCkK K3sKKwlJbnN0cnVtZW50YXRpb24gKnBhcmVudCA9IChJbnN0cnVtZW50YXRpb24gKikgY29udGV4 dDsKKworCUFzc2VydChwYXJlbnQgIT0gTlVMTCk7CisKKwlpZiAobm9kZSA9PSBOVUxMKQorCQly ZXR1cm4gZmFsc2U7CisKKwlBc3NlcnQobm9kZS0+aW5zdHJ1bWVudCAhPSBOVUxMKTsKKworCS8q CisJICogUmVjdXJzZSBpbnRvIGNoaWxkcmVuIGZpcnN0IChib3R0b20tdXAgYWNjdW11bGF0aW9u KSwgYW5kIGFjY3VtbXVsYXRlCisJICogdG8gdGhpcyBub2RlcyBpbnN0cnVtZW50YXRpb24gYXMg dGhlIHBhcmVudCBjb250ZXh0LgorCSAqLworCXBsYW5zdGF0ZV90cmVlX3dhbGtlcihub2RlLCBF eGVjRmluYWxpemVOb2RlSW5zdHJ1bWVudGF0aW9uX3dhbGtlciwKKwkJCQkJCSAgJm5vZGUtPmlu c3RydW1lbnQtPmluc3RyKTsKKworCUluc3RyRmluYWxpemVDaGlsZCgmbm9kZS0+aW5zdHJ1bWVu dC0+aW5zdHIsIHBhcmVudCk7CisKKwlyZXR1cm4gZmFsc2U7Cit9CisKKy8qCisgKiBFeGVjRmlu YWxpemVXb3JrZXJJbnN0cnVtZW50YXRpb24KKyAqCisgKiBBY2N1bXVsYXRlIHBlci13b3JrZXIg aW5zdHJ1bWVudGF0aW9uIHN0YXRzIGZyb20gY2hpbGQgbm9kZXMgaW50byB0aGVpcgorICogcGFy ZW50cywgbWlycm9yaW5nIHdoYXQgRXhlY0ZpbmFsaXplTm9kZUluc3RydW1lbnRhdGlvbiBkb2Vz IGZvciB0aGUKKyAqIGxlYWRlcidzIG93biBzdGF0cy4gIFdpdGhvdXQgdGhpcywgcGVyLXdvcmtl ciBidWZmZXIvV0FMIHN0YXRzIHNob3duIGJ5CisgKiBFWFBMQUlOIChBTkFMWVpFLCBWRVJCT1NF KSB3b3VsZCBvbmx5IHJlZmxlY3QgZWFjaCBub2RlJ3Mgb3duIGRpcmVjdAorICogYWN0aXZpdHks IG5vdCBpbmNsdWRpbmcgY2hpbGRyZW4uCisgKgorICogVGhpcyBtdXN0IHJ1biBhZnRlciBFeGVj UGFyYWxsZWxSZXRyaWV2ZUluc3RydW1lbnRhdGlvbiBoYXMgcG9wdWxhdGVkCisgKiB3b3JrZXJf aW5zdHJ1bWVudCBmb3IgYWxsIG5vZGVzIGluIHRoZSBwYXJhbGxlbCBzdWJ0cmVlLgorICovCit2 b2lkCitFeGVjRmluYWxpemVXb3JrZXJJbnN0cnVtZW50YXRpb24oUGxhblN0YXRlICpub2RlKQor eworCSh2b2lkKSBFeGVjRmluYWxpemVXb3JrZXJJbnN0cnVtZW50YXRpb25fd2Fsa2VyKG5vZGUs IE5VTEwpOworfQorCitzdGF0aWMgYm9vbAorRXhlY0ZpbmFsaXplV29ya2VySW5zdHJ1bWVudGF0 aW9uX3dhbGtlcihQbGFuU3RhdGUgKm5vZGUsIHZvaWQgKmNvbnRleHQpCit7CisJUGxhblN0YXRl ICAqcGFyZW50ID0gKFBsYW5TdGF0ZSAqKSBjb250ZXh0OworCWludAkJCW51bV93b3JrZXJzOwor CisJaWYgKG5vZGUgPT0gTlVMTCkKKwkJcmV0dXJuIGZhbHNlOworCisJLyoKKwkgKiBSZWN1cnNl IGludG8gY2hpbGRyZW4gZmlyc3QgKGJvdHRvbS11cCBhY2N1bXVsYXRpb24pLCBwYXNzaW5nIHRo aXMgbm9kZQorCSAqIGFzIHBhcmVudCBjb250ZXh0IGlmIGl0IGhhcyB3b3JrZXJfaW5zdHJ1bWVu dCwgb3RoZXJ3aXNlIHBhc3MgdGhyb3VnaAorCSAqIHRoZSBwcmV2aW91cyBwYXJlbnQuCisJICov CisJcGxhbnN0YXRlX3RyZWVfd2Fsa2VyKG5vZGUsIEV4ZWNGaW5hbGl6ZVdvcmtlckluc3RydW1l bnRhdGlvbl93YWxrZXIsCisJCQkJCQkgIG5vZGUtPndvcmtlcl9pbnN0cnVtZW50ID8gKHZvaWQg Kikgbm9kZSA6IGNvbnRleHQpOworCisJaWYgKCFub2RlLT53b3JrZXJfaW5zdHJ1bWVudCkKKwkJ cmV0dXJuIGZhbHNlOworCisJbnVtX3dvcmtlcnMgPSBub2RlLT53b3JrZXJfaW5zdHJ1bWVudC0+ bnVtX3dvcmtlcnM7CisKKwkvKiBBY2N1bXVsYXRlIHRoaXMgbm9kZSdzIHBlci13b3JrZXIgc3Rh dHMgdG8gcGFyZW50J3MgcGVyLXdvcmtlciBzdGF0cyAqLworCWlmIChwYXJlbnQgJiYgcGFyZW50 LT53b3JrZXJfaW5zdHJ1bWVudCkKKwl7CisJCWludAkJCXBhcmVudF93b3JrZXJzID0gcGFyZW50 LT53b3JrZXJfaW5zdHJ1bWVudC0+bnVtX3dvcmtlcnM7CisKKwkJZm9yIChpbnQgbiA9IDA7IG4g PCBNaW4obnVtX3dvcmtlcnMsIHBhcmVudF93b3JrZXJzKTsgbisrKQorCQkJSW5zdHJBY2N1bVN0 YWNrKCZwYXJlbnQtPndvcmtlcl9pbnN0cnVtZW50LT5pbnN0cnVtZW50W25dLmluc3RyLAorCQkJ CQkJCSZub2RlLT53b3JrZXJfaW5zdHJ1bWVudC0+aW5zdHJ1bWVudFtuXS5pbnN0cik7CisJfQor CisJcmV0dXJuIGZhbHNlOworfQorCiAvKgogICogRXhlY1NldFR1cGxlQm91bmQKICAqCmRpZmYg LS1naXQgYS9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjVXRpbHMuYyBiL3NyYy9iYWNrZW5kL2V4 ZWN1dG9yL2V4ZWNVdGlscy5jCmluZGV4IDFlYjZiOWYxZjQwLi43MDA3NjRkYWY0NSAxMDA2NDQK LS0tIGEvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY1V0aWxzLmMKKysrIGIvc3JjL2JhY2tlbmQv ZXhlY3V0b3IvZXhlY1V0aWxzLmMKQEAgLTE1MCw3ICsxNTAsNyBAQCBDcmVhdGVFeGVjdXRvclN0 YXRlKHZvaWQpCiAJZXN0YXRlLT5lc190b3RhbF9wcm9jZXNzZWQgPSAwOwogCiAJZXN0YXRlLT5l c190b3BfZWZsYWdzID0gMDsKLQllc3RhdGUtPmVzX2luc3RydW1lbnQgPSAwOworCWVzdGF0ZS0+ ZXNfaW5zdHJ1bWVudCA9IE5VTEw7CiAJZXN0YXRlLT5lc19maW5pc2hlZCA9IGZhbHNlOwogCiAJ ZXN0YXRlLT5lc19leHByY29udGV4dHMgPSBOSUw7CkBAIC0yMjcsNiArMjI3LDE1IEBAIEZyZWVF eGVjdXRvclN0YXRlKEVTdGF0ZSAqZXN0YXRlKQogCQllc3RhdGUtPmVzX3BhcnRpdGlvbl9kaXJl Y3RvcnkgPSBOVUxMOwogCX0KIAorCS8qCisJICogTWFrZSBzdXJlIHRoZSBpbnN0cnVtZW50YXRp b24gY29udGV4dCBnZXRzIGZyZWVkLiBUaGlzIHVzdWFsbHkgZ2V0cworCSAqIHJlLXBhcmVudGVk IHVuZGVyIHRoZSBwZXItcXVlcnkgY29udGV4dCBpbiBJbnN0clF1ZXJ5U3RvcEZpbmFsaXplLCBi dXQKKwkgKiB0aGF0IHdvbid0IGhhcHBlbiBkdXJpbmcgRVhQTEFJTiAoQlVGRkVSUykgc2luY2Ug RXhlY3V0b3JGaW5pc2ggbmV2ZXIKKwkgKiBnZXRzIGNhbGxlZCwgc28gd2Ugd291bGQgb3RoZXJ3 aXNlIGxlYWsgaXQgaW4gVG9wTWVtb3J5Q29udGV4dC4KKwkgKi8KKwlpZiAoZXN0YXRlLT5lc19p bnN0cnVtZW50ICYmIGVzdGF0ZS0+ZXNfaW5zdHJ1bWVudC0+aW5zdHIubmVlZF9zdGFjaykKKwkJ TWVtb3J5Q29udGV4dERlbGV0ZShlc3RhdGUtPmVzX2luc3RydW1lbnQtPmluc3RyX2N4dCk7CisK IAkvKgogCSAqIEZyZWUgdGhlIHBlci1xdWVyeSBtZW1vcnkgY29udGV4dCwgdGhlcmVieSByZWxl YXNpbmcgYWxsIHdvcmtpbmcKIAkgKiBtZW1vcnksIGluY2x1ZGluZyB0aGUgRVN0YXRlIG5vZGUg aXRzZWxmLgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvZXhlY3V0b3IvaW5zdHJ1bWVudC5jIGIv c3JjL2JhY2tlbmQvZXhlY3V0b3IvaW5zdHJ1bWVudC5jCmluZGV4IGUzZDg5MGE3Zjk4Li5mOTIw MmI1NThkNiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvZXhlY3V0b3IvaW5zdHJ1bWVudC5jCisr KyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2luc3RydW1lbnQuYwpAQCAtMTYsMzEgKzE2LDUzIEBA CiAjaW5jbHVkZSA8dW5pc3RkLmg+CiAKICNpbmNsdWRlICJleGVjdXRvci9pbnN0cnVtZW50Lmgi CisjaW5jbHVkZSAidXRpbHMvbWVtdXRpbHMuaCIKKyNpbmNsdWRlICJ1dGlscy9yZXNvd25lci5o IgogCi1CdWZmZXJVc2FnZSBwZ0J1ZmZlclVzYWdlOwotc3RhdGljIEJ1ZmZlclVzYWdlIHNhdmVf cGdCdWZmZXJVc2FnZTsKIFdhbFVzYWdlCXBnV2FsVXNhZ2U7Ci1zdGF0aWMgV2FsVXNhZ2Ugc2F2 ZV9wZ1dhbFVzYWdlOworSW5zdHJ1bWVudGF0aW9uIGluc3RyX3RvcDsKK0luc3RyU3RhY2tTdGF0 ZSBpbnN0cl9zdGFjayA9IHsKKwkuc3RhY2tfc3BhY2UgPSAwLAorCS5zdGFja19zaXplID0gMCwK KwkuZW50cmllcyA9IE5VTEwsCisJLmN1cnJlbnQgPSAmaW5zdHJfdG9wLAorfTsKIAotc3RhdGlj IHZvaWQgQnVmZmVyVXNhZ2VBZGQoQnVmZmVyVXNhZ2UgKmRzdCwgY29uc3QgQnVmZmVyVXNhZ2Ug KmFkZCk7Ci1zdGF0aWMgdm9pZCBXYWxVc2FnZUFkZChXYWxVc2FnZSAqZHN0LCBXYWxVc2FnZSAq YWRkKTsKK3ZvaWQKK0luc3RyU3RhY2tHcm93KHZvaWQpCit7CisJaW50CQkJc3BhY2UgPSBpbnN0 cl9zdGFjay5zdGFja19zcGFjZTsKIAorCUFzc2VydChpbnN0cl9zdGFjay5zdGFja19zaXplID49 IGluc3RyX3N0YWNrLnN0YWNrX3NwYWNlKTsKKworCWlmIChpbnN0cl9zdGFjay5lbnRyaWVzID09 IE5VTEwpCisJeworCQlzcGFjZSA9IDEwOwkJCQkvKiBBbGxvY2F0ZSBzdWZmaWNpZW50IGluaXRp YWwgc3BhY2UgZm9yCisJCQkJCQkJCSAqIHR5cGljYWwgYWN0aXZpdHkgKi8KKwkJaW5zdHJfc3Rh Y2suZW50cmllcyA9IE1lbW9yeUNvbnRleHRBbGxvYyhUb3BNZW1vcnlDb250ZXh0LAorCQkJCQkJ CQkJCQkJIHNpemVvZihJbnN0cnVtZW50YXRpb24gKikgKiBzcGFjZSk7CisJfQorCWVsc2UKKwl7 CisJCXNwYWNlICo9IDI7CisJCWluc3RyX3N0YWNrLmVudHJpZXMgPSByZXBhbGxvY19hcnJheShp bnN0cl9zdGFjay5lbnRyaWVzLCBJbnN0cnVtZW50YXRpb24gKiwgc3BhY2UpOworCX0KKworCS8q IFVwZGF0ZSBzdGFjayBzcGFjZSBhZnRlciBhbGxvY2F0aW9uIHN1Y2NlZWRlZCB0byBwcm90ZWN0 IGFnYWluc3QgT09NcyAqLworCWluc3RyX3N0YWNrLnN0YWNrX3NwYWNlID0gc3BhY2U7Cit9CiAK IC8qIEdlbmVyYWwgcHVycG9zZSBpbnN0cnVtZW50YXRpb24gaGFuZGxpbmcgKi8KLUluc3RydW1l bnRhdGlvbiAqCi1JbnN0ckFsbG9jKGludCBpbnN0cnVtZW50X29wdGlvbnMpCitzdGF0aWMgaW5s aW5lIGJvb2wKK0luc3RyTmVlZFN0YWNrKGludCBpbnN0cnVtZW50X29wdGlvbnMpCiB7Ci0JSW5z dHJ1bWVudGF0aW9uICppbnN0ciA9IHBhbGxvYzAoc2l6ZW9mKEluc3RydW1lbnRhdGlvbikpOwot Ci0JSW5zdHJJbml0T3B0aW9ucyhpbnN0ciwgaW5zdHJ1bWVudF9vcHRpb25zKTsKLQlyZXR1cm4g aW5zdHI7CisJcmV0dXJuIChpbnN0cnVtZW50X29wdGlvbnMgJiAoSU5TVFJVTUVOVF9CVUZGRVJT IHwgSU5TVFJVTUVOVF9XQUwpKSAhPSAwOwogfQogCiB2b2lkCiBJbnN0ckluaXRPcHRpb25zKElu c3RydW1lbnRhdGlvbiAqaW5zdHIsIGludCBpbnN0cnVtZW50X29wdGlvbnMpCiB7Ci0JaW5zdHIt Pm5lZWRfYnVmdXNhZ2UgPSAoaW5zdHJ1bWVudF9vcHRpb25zICYgSU5TVFJVTUVOVF9CVUZGRVJT KSAhPSAwOwotCWluc3RyLT5uZWVkX3dhbHVzYWdlID0gKGluc3RydW1lbnRfb3B0aW9ucyAmIElO U1RSVU1FTlRfV0FMKSAhPSAwOworCWluc3RyLT5uZWVkX3N0YWNrID0gSW5zdHJOZWVkU3RhY2so aW5zdHJ1bWVudF9vcHRpb25zKTsKIAlpbnN0ci0+bmVlZF90aW1lciA9IChpbnN0cnVtZW50X29w dGlvbnMgJiBJTlNUUlVNRU5UX1RJTUVSKSAhPSAwOwogfQogCkBAIC01NSw1MiArNzcsMzA5IEBA IEluc3RyU3RhcnQoSW5zdHJ1bWVudGF0aW9uICppbnN0cikKIAkJCUlOU1RSX1RJTUVfU0VUX0NV UlJFTlQoaW5zdHItPnN0YXJ0dGltZSk7CiAJfQogCi0JLyogc2F2ZSBidWZmZXIgdXNhZ2UgdG90 YWxzIGF0IG5vZGUgZW50cnksIGlmIG5lZWRlZCAqLwotCWlmIChpbnN0ci0+bmVlZF9idWZ1c2Fn ZSkKLQkJaW5zdHItPmJ1ZnVzYWdlX3N0YXJ0ID0gcGdCdWZmZXJVc2FnZTsKKwlpZiAoaW5zdHIt Pm5lZWRfc3RhY2spCisJCUluc3RyUHVzaFN0YWNrKGluc3RyKTsKK30KKworc3RhdGljIHZvaWQK K0luc3RyU3RvcFRpbWVyKEluc3RydW1lbnRhdGlvbiAqaW5zdHIpCit7CisJaW5zdHJfdGltZQll bmR0aW1lOwogCi0JaWYgKGluc3RyLT5uZWVkX3dhbHVzYWdlKQotCQlpbnN0ci0+d2FsdXNhZ2Vf c3RhcnQgPSBwZ1dhbFVzYWdlOworCS8qIGxldCdzIHVwZGF0ZSB0aGUgdGltZSBvbmx5IGlmIHRo ZSB0aW1lciB3YXMgcmVxdWVzdGVkICovCisJaWYgKElOU1RSX1RJTUVfSVNfWkVSTyhpbnN0ci0+ c3RhcnR0aW1lKSkKKwkJZWxvZyhFUlJPUiwgIkluc3RyU3RvcCBjYWxsZWQgd2l0aG91dCBzdGFy dCIpOworCisJSU5TVFJfVElNRV9TRVRfQ1VSUkVOVChlbmR0aW1lKTsKKwlJTlNUUl9USU1FX0FD Q1VNX0RJRkYoaW5zdHItPnRvdGFsLCBlbmR0aW1lLCBpbnN0ci0+c3RhcnR0aW1lKTsKKworCUlO U1RSX1RJTUVfU0VUX1pFUk8oaW5zdHItPnN0YXJ0dGltZSk7CiB9CiAKIHZvaWQKIEluc3RyU3Rv cChJbnN0cnVtZW50YXRpb24gKmluc3RyKQogewotCWluc3RyX3RpbWUJZW5kdGltZTsKKwlpZiAo aW5zdHItPm5lZWRfdGltZXIpCisJCUluc3RyU3RvcFRpbWVyKGluc3RyKTsKKworCWlmIChpbnN0 ci0+bmVlZF9zdGFjaykKKwkJSW5zdHJQb3BTdGFjayhpbnN0cik7Cit9CisKKy8qCisgKiBTdG9w cyBpbnN0cnVtZW50YXRpb24sIGZpbmFsaXplcyB0aGUgc3RhY2sgZW50cnkgYW5kIGFjY3VtdWxh dGVzIHRvIGl0cyBwYXJlbnQuCisgKgorICogTm90ZSB0aGF0IHRoaXMgaW50ZW50aW9uYWxseSBh bGxvd3MgcGFzc2luZyBhIHN0YWNrIHRoYXQgaXMgbm90IHRoZSBjdXJyZW50CisgKiB0b3AsIGFz IGNhbiBoYXBwZW4gd2l0aCBQR19GSU5BTExZLCBvciByZXNvdXJjZSBvd25lcnMsIHdoaWNoIGRv bid0IGhhdmUgYQorICogZ3VhcmFudGVlZCBjbGVhbnVwIG9yZGVyLgorICoKKyAqIFdlIGFyZSBj YXJlZnVsIGhlcmUgdG8gYWNoaWV2ZSB0d28gZ29hbHM6CisgKgorICogMSkgUmVzZXQgdGhlIHN0 YWNrIHRvIHRoZSBwYXJlbnQgb2Ygd2hpY2hldmVyIG9mIHRoZSByZWxlYXNlZCBzdGFjayBlbnRy aWVzCisgKiAgICBoYXMgdGhlIGxvd2VzdCBpbmRleAorICogMikgQWNjdW11bGF0ZSBhbGwgaW5z dHJ1bWVudGF0aW9uIHRvIHRoZSBjdXJyZW50bHkgYWN0aXZlIGluc3RydW1lbnRhdGlvbiwKKyAq ICAgIHNvIHRoYXQgY2FsbGVycyBnZXQgYSBjb21wbGV0ZSBwaWN0dXJlIG9mIGFjdGl2aXR5LCBl dmVuIGFmdGVyIGFuIGFib3J0CisgKi8KK3ZvaWQKK0luc3RyU3RvcEZpbmFsaXplKEluc3RydW1l bnRhdGlvbiAqaW5zdHIpCit7CisJaWYgKGluc3RyLT5vbl9zdGFjaykKKwl7CisJCWludAkJCWlk eCA9IC0xOworCisJCWZvciAoaW50IGkgPSBpbnN0cl9zdGFjay5zdGFja19zaXplIC0gMTsgaSA+ PSAwOyBpLS0pCisJCXsKKwkJCWlmIChpbnN0cl9zdGFjay5lbnRyaWVzW2ldID09IGluc3RyKQor CQkJeworCQkJCWlkeCA9IGk7CisJCQkJYnJlYWs7CisJCQl9CisJCX0KKworCQlpZiAoaWR4IDwg MCkKKwkJCWVsb2coRVJST1IsICJpbnN0cnVtZW50YXRpb24gZW50cnkgbm90IGZvdW5kIG9uIHN0 YWNrIik7CisKKwkJLyogQ2xlYXIgb25fc3RhY2sgZm9yIGFueSBpbnRlcm1lZGlhdGUgZW50cmll cyB3ZSdyZSBza2lwcGluZyBvdmVyICovCisJCWZvciAoaW50IGkgPSBpbnN0cl9zdGFjay5zdGFj a19zaXplIC0gMTsgaSA+IGlkeDsgaS0tKQorCQkJaW5zdHJfc3RhY2suZW50cmllc1tpXS0+b25f c3RhY2sgPSBmYWxzZTsKKworCQl3aGlsZSAoaW5zdHJfc3RhY2suc3RhY2tfc2l6ZSA+IGlkeCAr IDEpCisJCQlpbnN0cl9zdGFjay5zdGFja19zaXplLS07CisKKwkJSW5zdHJQb3BTdGFjayhpbnN0 cik7CisJfQogCi0JLyogbGV0J3MgdXBkYXRlIHRoZSB0aW1lIG9ubHkgaWYgdGhlIHRpbWVyIHdh cyByZXF1ZXN0ZWQgKi8KIAlpZiAoaW5zdHItPm5lZWRfdGltZXIpCisJCUluc3RyU3RvcFRpbWVy KGluc3RyKTsKKworCUluc3RyQWNjdW1TdGFjayhpbnN0cl9zdGFjay5jdXJyZW50LCBpbnN0cik7 Cit9CisKKy8qCisgKiBGaW5hbGl6ZSBjaGlsZCBpbnN0cnVtZW50YXRpb24gYnkgYWNjdW11bGF0 aW5nIGJ1ZmZlci9XQUwgdXNhZ2UgdG8gdGhlCisgKiBwcm92aWRlZCBpbnN0cnVtZW50YXRpb24s IHdoaWNoIG1heSBiZSB0aGUgY3VycmVudCBlbnRyeSwgb3Igb25lIHRoZSBjYWxsZXIKKyAqIHRy ZWF0cyBhcyBhIHBhcmVudCBhbmQgd2lsbCBhZGQgdG8gdGhlIHRvdGFscyBsYXRlci4KKyAqCisg KiBBbHNvIGRlbGV0ZXMgdGhlIHVuZmluYWxpemVkIGVudHJ5IHRvIGF2b2lkIGRvdWJsZSBjb3Vu dGluZyBpbiBhbiBhYm9ydAorICogc2l0dWF0aW9uLCBlLmcuIGR1cmluZyBleGVjdXRvciBmaW5p c2guCisgKi8KK3ZvaWQKK0luc3RyRmluYWxpemVDaGlsZChJbnN0cnVtZW50YXRpb24gKmluc3Ry LCBJbnN0cnVtZW50YXRpb24gKnBhcmVudCkKK3sKKwlpZiAoaW5zdHItPm5lZWRfc3RhY2spCiAJ ewotCQlpZiAoSU5TVFJfVElNRV9JU19aRVJPKGluc3RyLT5zdGFydHRpbWUpKQotCQkJZWxvZyhF UlJPUiwgIkluc3RyU3RvcCBjYWxsZWQgd2l0aG91dCBzdGFydCIpOworCQlpZiAoIWRsaXN0X25v ZGVfaXNfZGV0YWNoZWQoJmluc3RyLT51bmZpbmFsaXplZF9lbnRyeSkpCisJCQlkbGlzdF9kZWxl dGVfdGhvcm91Z2hseSgmaW5zdHItPnVuZmluYWxpemVkX2VudHJ5KTsKIAotCQlJTlNUUl9USU1F X1NFVF9DVVJSRU5UKGVuZHRpbWUpOwotCQlJTlNUUl9USU1FX0FDQ1VNX0RJRkYoaW5zdHItPnRv dGFsLCBlbmR0aW1lLCBpbnN0ci0+c3RhcnR0aW1lKTsKKwkJSW5zdHJBY2N1bVN0YWNrKHBhcmVu dCwgaW5zdHIpOworCX0KK30KKworCisvKiBRdWVyeSBpbnN0cnVtZW50YXRpb24gaGFuZGxpbmcg Ki8KKworLyoKKyAqIFVzZSBSZXNvdXJjZU93bmVyIG1lY2hhbmlzbSB0byBjb3JyZWN0bHkgcmVz ZXQgaW5zdHJfc3RhY2sgb24gYWJvcnQuCisgKi8KK3N0YXRpYyB2b2lkIFJlc093bmVyUmVsZWFz ZUluc3RydW1lbnRhdGlvbihEYXR1bSByZXMpOworc3RhdGljIGNvbnN0IFJlc291cmNlT3duZXJE ZXNjIGluc3RydW1lbnRhdGlvbl9yZXNvd25lcl9kZXNjID0KK3sKKwkubmFtZSA9ICJpbnN0cnVt ZW50YXRpb24iLAorCS5yZWxlYXNlX3BoYXNlID0gUkVTT1VSQ0VfUkVMRUFTRV9BRlRFUl9MT0NL UywKKwkucmVsZWFzZV9wcmlvcml0eSA9IFJFTEVBU0VfUFJJT19JTlNUUlVNRU5UQVRJT04sCisJ LlJlbGVhc2VSZXNvdXJjZSA9IFJlc093bmVyUmVsZWFzZUluc3RydW1lbnRhdGlvbiwKKwkuRGVi dWdQcmludCA9IE5VTEwsCQkJLyogZGVmYXVsdCBtZXNzYWdlIGlzIGZpbmUgKi8KK307CisKK3N0 YXRpYyBpbmxpbmUgdm9pZAorUmVzb3VyY2VPd25lclJlbWVtYmVySW5zdHJ1bWVudGF0aW9uKFJl c291cmNlT3duZXIgb3duZXIsIFF1ZXJ5SW5zdHJ1bWVudGF0aW9uICpxaW5zdHIpCit7CisJUmVz b3VyY2VPd25lclJlbWVtYmVyKG93bmVyLCBQb2ludGVyR2V0RGF0dW0ocWluc3RyKSwgJmluc3Ry dW1lbnRhdGlvbl9yZXNvd25lcl9kZXNjKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkCitSZXNv dXJjZU93bmVyRm9yZ2V0SW5zdHJ1bWVudGF0aW9uKFJlc291cmNlT3duZXIgb3duZXIsIFF1ZXJ5 SW5zdHJ1bWVudGF0aW9uICpxaW5zdHIpCit7CisJUmVzb3VyY2VPd25lckZvcmdldChvd25lciwg UG9pbnRlckdldERhdHVtKHFpbnN0ciksICZpbnN0cnVtZW50YXRpb25fcmVzb3duZXJfZGVzYyk7 Cit9CisKK3N0YXRpYyB2b2lkCitSZXNPd25lclJlbGVhc2VJbnN0cnVtZW50YXRpb24oRGF0dW0g cmVzKQoreworCVF1ZXJ5SW5zdHJ1bWVudGF0aW9uICpxaW5zdHIgPSAoUXVlcnlJbnN0cnVtZW50 YXRpb24gKikgRGF0dW1HZXRQb2ludGVyKHJlcyk7CisJTWVtb3J5Q29udGV4dCBpbnN0cl9jeHQg PSBxaW5zdHItPmluc3RyX2N4dDsKKwlkbGlzdF9tdXRhYmxlX2l0ZXIgaXRlcjsKKworCS8qIEFj Y3VtdWxhdGUgZGF0YSBmcm9tIGFsbCB1bmZpbmFsaXplZCBjaGlsZCBlbnRyaWVzIChub2Rlcywg dHJpZ2dlcnMpICovCisJZGxpc3RfZm9yZWFjaF9tb2RpZnkoaXRlciwgJnFpbnN0ci0+dW5maW5h bGl6ZWRfZW50cmllcykKKwl7CisJCUluc3RydW1lbnRhdGlvbiAqY2hpbGQgPSBkbGlzdF9jb250 YWluZXIoSW5zdHJ1bWVudGF0aW9uLCB1bmZpbmFsaXplZF9lbnRyeSwgaXRlci5jdXIpOwogCi0J CUlOU1RSX1RJTUVfU0VUX1pFUk8oaW5zdHItPnN0YXJ0dGltZSk7CisJCUluc3RyQWNjdW1TdGFj aygmcWluc3RyLT5pbnN0ciwgY2hpbGQpOwogCX0KIAotCS8qIEFkZCBkZWx0YSBvZiBidWZmZXIg dXNhZ2Ugc2luY2UgZW50cnkgdG8gbm9kZSdzIHRvdGFscyAqLwotCWlmIChpbnN0ci0+bmVlZF9i dWZ1c2FnZSkKLQkJQnVmZmVyVXNhZ2VBY2N1bURpZmYoJmluc3RyLT5idWZ1c2FnZSwKLQkJCQkJ CQkgJnBnQnVmZmVyVXNhZ2UsICZpbnN0ci0+YnVmdXNhZ2Vfc3RhcnQpOworCS8qIEVuc3VyZSB0 aGUgc3RhY2sgaXMgcmVzZXQgYXMgZXhwZWN0ZWQsIGFuZCB3ZSBhY2N1bXVsYXRlIHRvIHRoZSBw YXJlbnQgKi8KKwlJbnN0clN0b3BGaW5hbGl6ZSgmcWluc3RyLT5pbnN0cik7CiAKLQlpZiAoaW5z dHItPm5lZWRfd2FsdXNhZ2UpCi0JCVdhbFVzYWdlQWNjdW1EaWZmKCZpbnN0ci0+d2FsdXNhZ2Us Ci0JCQkJCQkgICZwZ1dhbFVzYWdlLCAmaW5zdHItPndhbHVzYWdlX3N0YXJ0KTsKKwkvKgorCSAq IERlc3Ryb3kgdGhlIGRlZGljYXRlZCBpbnN0cnVtZW50YXRpb24gY29udGV4dCwgd2hpY2ggZnJl ZXMgdGhlCisJICogUXVlcnlJbnN0cnVtZW50YXRpb24gYW5kIGFsbCBjaGlsZCBhbGxvY2F0aW9u cy4KKwkgKi8KKwlNZW1vcnlDb250ZXh0RGVsZXRlKGluc3RyX2N4dCk7Cit9CisKK1F1ZXJ5SW5z dHJ1bWVudGF0aW9uICoKK0luc3RyUXVlcnlBbGxvYyhpbnQgaW5zdHJ1bWVudF9vcHRpb25zKQor eworCVF1ZXJ5SW5zdHJ1bWVudGF0aW9uICppbnN0cjsKKwlNZW1vcnlDb250ZXh0IGluc3RyX2N4 dDsKKworCS8qCisJICogV2hlbiB0aGUgaW5zdHJ1bWVudGF0aW9uIHN0YWNrIGlzIHVzZWQsIGNy ZWF0ZSBhIGRlZGljYXRlZCBtZW1vcnkKKwkgKiBjb250ZXh0IGZvciB0aGlzIHF1ZXJ5J3MgaW5z dHJ1bWVudGF0aW9uIGFsbG9jYXRpb25zLiBUaGlzIGNvbnRleHQgaXMgYQorCSAqIGNoaWxkIG9m IFRvcE1lbW9yeUNvbnRleHQgc28gaXQgc3Vydml2ZXMgdHJhbnNhY3Rpb24gYWJvcnQg4oCUCisJ ICogUmVzb3VyY2VPd25lciByZWxlYXNlIG5lZWRzIHRvIGFjY2VzcyBpdC4KKwkgKgorCSAqIEZv ciBzaW1wbGVyIGNhc2VzICh0aW1lci9yb3dzIG9ubHkpLCB1c2UgdGhlIGN1cnJlbnQgbWVtb3J5 IGNvbnRleHQuCisJICoKKwkgKiBBbGwgY2hpbGQgaW5zdHJ1bWVudGF0aW9uIGFsbG9jYXRpb25z IChub2RlcywgdHJpZ2dlcnMsIGV0YykgbXVzdCBiZQorCSAqIGFsbG9jYXRlZCB3aXRoaW4gdGhp cyBjb250ZXh0IHRvIGVuc3VyZSBjb3JyZWN0IGNsZWFuIHVwIG9uIGFib3J0LgorCSAqLworCWlm IChJbnN0ck5lZWRTdGFjayhpbnN0cnVtZW50X29wdGlvbnMpKQorCQlpbnN0cl9jeHQgPSBBbGxv Y1NldENvbnRleHRDcmVhdGUoVG9wTWVtb3J5Q29udGV4dCwKKwkJCQkJCQkJCQkgICJJbnN0cnVt ZW50YXRpb24iLAorCQkJCQkJCQkJCSAgQUxMT0NTRVRfU01BTExfU0laRVMpOworCWVsc2UKKwkJ aW5zdHJfY3h0ID0gQ3VycmVudE1lbW9yeUNvbnRleHQ7CisKKwlpbnN0ciA9IE1lbW9yeUNvbnRl eHRBbGxvY1plcm8oaW5zdHJfY3h0LCBzaXplb2YoUXVlcnlJbnN0cnVtZW50YXRpb24pKTsKKwlp bnN0ci0+aW5zdHJ1bWVudF9vcHRpb25zID0gaW5zdHJ1bWVudF9vcHRpb25zOworCWluc3RyLT5p bnN0cl9jeHQgPSBpbnN0cl9jeHQ7CisKKwlJbnN0ckluaXRPcHRpb25zKCZpbnN0ci0+aW5zdHIs IGluc3RydW1lbnRfb3B0aW9ucyk7CisJZGxpc3RfaW5pdCgmaW5zdHItPnVuZmluYWxpemVkX2Vu dHJpZXMpOworCisJcmV0dXJuIGluc3RyOworfQorCit2b2lkCitJbnN0clF1ZXJ5U3RhcnQoUXVl cnlJbnN0cnVtZW50YXRpb24gKnFpbnN0cikKK3sKKwlJbnN0clN0YXJ0KCZxaW5zdHItPmluc3Ry KTsKKworCWlmIChxaW5zdHItPmluc3RyLm5lZWRfc3RhY2spCisJeworCQlBc3NlcnQoQ3VycmVu dFJlc291cmNlT3duZXIgIT0gTlVMTCk7CisJCXFpbnN0ci0+b3duZXIgPSBDdXJyZW50UmVzb3Vy Y2VPd25lcjsKKworCQlSZXNvdXJjZU93bmVyRW5sYXJnZShxaW5zdHItPm93bmVyKTsKKwkJUmVz b3VyY2VPd25lclJlbWVtYmVySW5zdHJ1bWVudGF0aW9uKHFpbnN0ci0+b3duZXIsIHFpbnN0cik7 CisJfQorfQorCit2b2lkCitJbnN0clF1ZXJ5U3RvcChRdWVyeUluc3RydW1lbnRhdGlvbiAqcWlu c3RyKQoreworCUluc3RyU3RvcCgmcWluc3RyLT5pbnN0cik7CisKKwlpZiAocWluc3RyLT5pbnN0 ci5uZWVkX3N0YWNrKQorCXsKKwkJQXNzZXJ0KHFpbnN0ci0+b3duZXIgIT0gTlVMTCk7CisJCVJl c291cmNlT3duZXJGb3JnZXRJbnN0cnVtZW50YXRpb24ocWluc3RyLT5vd25lciwgcWluc3RyKTsK KwkJcWluc3RyLT5vd25lciA9IE5VTEw7CisJfQorfQorCit2b2lkCitJbnN0clF1ZXJ5U3RvcEZp bmFsaXplKFF1ZXJ5SW5zdHJ1bWVudGF0aW9uICpxaW5zdHIpCit7CisJSW5zdHJTdG9wRmluYWxp emUoJnFpbnN0ci0+aW5zdHIpOworCisJaWYgKCFxaW5zdHItPmluc3RyLm5lZWRfc3RhY2spCisJ eworCQlBc3NlcnQocWluc3RyLT5vd25lciA9PSBOVUxMKTsKKwkJcmV0dXJuOworCX0KKworCUFz c2VydChxaW5zdHItPm93bmVyICE9IE5VTEwpOworCVJlc291cmNlT3duZXJGb3JnZXRJbnN0cnVt ZW50YXRpb24ocWluc3RyLT5vd25lciwgcWluc3RyKTsKKwlxaW5zdHItPm93bmVyID0gTlVMTDsK KworCS8qCisJICogUmVwYXJlbnQgdGhlIGRlZGljYXRlZCBpbnN0cnVtZW50YXRpb24gY29udGV4 dCB1bmRlciB0aGUgY3VycmVudCBtZW1vcnkKKwkgKiBjb250ZXh0LCBzbyB0aGF0IGl0cyBsaWZl dGltZSBpcyBub3cgdGllZCB0byB0aGUgY2FsbGVyJ3MgY29udGV4dAorCSAqIHJhdGhlciB0aGFu IFRvcE1lbW9yeUNvbnRleHQuCisJICovCisJTWVtb3J5Q29udGV4dFNldFBhcmVudChxaW5zdHIt Pmluc3RyX2N4dCwgQ3VycmVudE1lbW9yeUNvbnRleHQpOworfQorCisvKgorICogUmVnaXN0ZXIg YSBjaGlsZCBJbnN0cnVtZW50YXRpb24gZW50cnkgZm9yIGFib3J0IHByb2Nlc3NpbmcuCisgKgor ICogT24gYWJvcnQsIFJlc093bmVyUmVsZWFzZUluc3RydW1lbnRhdGlvbiB3aWxsIHdhbGsgdGhl IHBhcmVudCdzIGxpc3QgdG8KKyAqIHJlY292ZXIgYnVmZmVyL1dBTCBkYXRhIGZyb20gZW50cmll cyB0aGF0IHdlcmUgbmV2ZXIgZmluYWxpemVkLCBpbiBvcmRlciBmb3IKKyAqIGFnZ3JlZ2F0ZSB0 b3RhbHMgdG8gYmUgYWNjdXJhdGUgZGVzcGl0ZSB0aGUgcXVlcnkgZXJyb3Jpbmcgb3V0LgorICov Cit2b2lkCitJbnN0clF1ZXJ5UmVtZW1iZXJDaGlsZChRdWVyeUluc3RydW1lbnRhdGlvbiAqcGFy ZW50LCBJbnN0cnVtZW50YXRpb24gKmNoaWxkKQoreworCWlmIChjaGlsZC0+bmVlZF9zdGFjaykK KwkJZGxpc3RfcHVzaF9oZWFkKCZwYXJlbnQtPnVuZmluYWxpemVkX2VudHJpZXMsICZjaGlsZC0+ dW5maW5hbGl6ZWRfZW50cnkpOworfQorCisvKiBzdGFydCBpbnN0cnVtZW50YXRpb24gZHVyaW5n IHBhcmFsbGVsIGV4ZWN1dG9yIHN0YXJ0dXAgKi8KK1F1ZXJ5SW5zdHJ1bWVudGF0aW9uICoKK0lu c3RyU3RhcnRQYXJhbGxlbFF1ZXJ5KHZvaWQpCit7CisJUXVlcnlJbnN0cnVtZW50YXRpb24gKnFp bnN0ciA9IEluc3RyUXVlcnlBbGxvYyhJTlNUUlVNRU5UX0JVRkZFUlMgfCBJTlNUUlVNRU5UX1dB TCk7CisKKwlJbnN0clF1ZXJ5U3RhcnQocWluc3RyKTsKKwlyZXR1cm4gcWluc3RyOworfQorCisv KiByZXBvcnQgdXNhZ2UgYWZ0ZXIgcGFyYWxsZWwgZXhlY3V0b3Igc2h1dGRvd24gKi8KK3ZvaWQK K0luc3RyRW5kUGFyYWxsZWxRdWVyeShRdWVyeUluc3RydW1lbnRhdGlvbiAqcWluc3RyLCBCdWZm ZXJVc2FnZSAqYnVmdXNhZ2UsIFdhbFVzYWdlICp3YWx1c2FnZSkKK3sKKwlJbnN0clF1ZXJ5U3Rv cEZpbmFsaXplKHFpbnN0cik7CisJbWVtY3B5KGJ1ZnVzYWdlLCAmcWluc3RyLT5pbnN0ci5idWZ1 c2FnZSwgc2l6ZW9mKEJ1ZmZlclVzYWdlKSk7CisJbWVtY3B5KHdhbHVzYWdlLCAmcWluc3RyLT5p bnN0ci53YWx1c2FnZSwgc2l6ZW9mKFdhbFVzYWdlKSk7Cit9CisKKy8qCisgKiBBY2N1bXVsYXRl IHdvcmsgZG9uZSBieSBwYXJhbGxlbCB3b3JrZXJzIGluIHRoZSBsZWFkZXIncyBzdGF0cy4KKyAq CisgKiBOb3RlIHRoYXQgd2hhdCBnZXRzIGFkZGVkIGhlcmUgZWZmZWN0aXZlbHkgZGVwZW5kcyBv biB3aGV0aGVyIHBlci1ub2RlCisgKiBpbnN0cnVtZW50YXRpb24gaXMgYWN0aXZlLiBJZiBpdCdz IGFjdGl2ZSB0aGUgcGFyYWxsZWwgd29ya2VyIGludGVudGlvbmFsbHkKKyAqIHNraXBzIEV4ZWNG aW5hbGl6ZU5vZGVJbnN0cnVtZW50YXRpb24gb24gZXhlY3V0b3Igc2h1dGRvd24sIGJlY2F1c2Ug aXQgd291bGQKKyAqIGNhdXNlIGRvdWJsZSBjb3VudGluZy4gSW5zdGVhZCwgdGhpcyBvbmx5IGFj Y3VtdWxhdGVzIGFueSBleHRyYSBhY3Rpdml0eQorICogb3V0c2lkZSBvZiBub2Rlcy4KKyAqCisg KiBPdGhlcndpc2UgdGhpcyBpcyByZXNwb25zaWJsZSBmb3IgbWFraW5nIHN1cmUgdGhhdCB0aGUg Y29tcGxldGUgcXVlcnkKKyAqIGFjdGl2aXR5IGlzIGFjY3VtdWxhdGVkLgorICovCit2b2lkCitJ bnN0ckFjY3VtUGFyYWxsZWxRdWVyeShCdWZmZXJVc2FnZSAqYnVmdXNhZ2UsIFdhbFVzYWdlICp3 YWx1c2FnZSkKK3sKKwlCdWZmZXJVc2FnZUFkZCgmaW5zdHJfc3RhY2suY3VycmVudC0+YnVmdXNh Z2UsIGJ1ZnVzYWdlKTsKKwlXYWxVc2FnZUFkZCgmaW5zdHJfc3RhY2suY3VycmVudC0+d2FsdXNh Z2UsIHdhbHVzYWdlKTsKKworCVdhbFVzYWdlQWRkKCZwZ1dhbFVzYWdlLCB3YWx1c2FnZSk7CiB9 CiAKIC8qIE5vZGUgaW5zdHJ1bWVudGF0aW9uIGhhbmRsaW5nICovCiAKIC8qIEFsbG9jYXRlIG5l dyBub2RlIGluc3RydW1lbnRhdGlvbiBzdHJ1Y3R1cmUgKi8KIE5vZGVJbnN0cnVtZW50YXRpb24g KgotSW5zdHJBbGxvY05vZGUoaW50IGluc3RydW1lbnRfb3B0aW9ucywgYm9vbCBhc3luY19tb2Rl KQorSW5zdHJBbGxvY05vZGUoUXVlcnlJbnN0cnVtZW50YXRpb24gKnFpbnN0ciwgYm9vbCBhc3lu Y19tb2RlKQogewotCU5vZGVJbnN0cnVtZW50YXRpb24gKmluc3RyID0gcGFsbG9jKHNpemVvZihO b2RlSW5zdHJ1bWVudGF0aW9uKSk7CisJTm9kZUluc3RydW1lbnRhdGlvbiAqaW5zdHIgPSBNZW1v cnlDb250ZXh0QWxsb2MocWluc3RyLT5pbnN0cl9jeHQsIHNpemVvZihOb2RlSW5zdHJ1bWVudGF0 aW9uKSk7CiAKLQlJbnN0ckluaXROb2RlKGluc3RyLCBpbnN0cnVtZW50X29wdGlvbnMpOworCUlu c3RySW5pdE5vZGUoaW5zdHIsIHFpbnN0ci0+aW5zdHJ1bWVudF9vcHRpb25zKTsKIAlpbnN0ci0+ YXN5bmNfbW9kZSA9IGFzeW5jX21vZGU7CiAKKwlJbnN0clF1ZXJ5UmVtZW1iZXJDaGlsZChxaW5z dHIsICZpbnN0ci0+aW5zdHIpOworCiAJcmV0dXJuIGluc3RyOwogfQogCkBAIC0xMTksNiArMzk4 LDcgQEAgSW5zdHJTdGFydE5vZGUoTm9kZUluc3RydW1lbnRhdGlvbiAqaW5zdHIpCiAJSW5zdHJT dGFydCgmaW5zdHItPmluc3RyKTsKIH0KIAorCiAvKiBFeGl0IGZyb20gYSBwbGFuIG5vZGUgKi8K IHZvaWQKIEluc3RyU3RvcE5vZGUoTm9kZUluc3RydW1lbnRhdGlvbiAqaW5zdHIsIGRvdWJsZSBu VHVwbGVzKQpAQCAtMTQ4LDE0ICs0MjgsMTIgQEAgSW5zdHJTdG9wTm9kZShOb2RlSW5zdHJ1bWVu dGF0aW9uICppbnN0ciwgZG91YmxlIG5UdXBsZXMpCiAJCUlOU1RSX1RJTUVfU0VUX1pFUk8oaW5z dHItPmluc3RyLnN0YXJ0dGltZSk7CiAJfQogCi0JLyogQWRkIGRlbHRhIG9mIGJ1ZmZlciB1c2Fn ZSBzaW5jZSBlbnRyeSB0byBub2RlJ3MgdG90YWxzICovCi0JaWYgKGluc3RyLT5pbnN0ci5uZWVk X2J1ZnVzYWdlKQotCQlCdWZmZXJVc2FnZUFjY3VtRGlmZigmaW5zdHItPmluc3RyLmJ1ZnVzYWdl LAotCQkJCQkJCSAmcGdCdWZmZXJVc2FnZSwgJmluc3RyLT5pbnN0ci5idWZ1c2FnZV9zdGFydCk7 Ci0KLQlpZiAoaW5zdHItPmluc3RyLm5lZWRfd2FsdXNhZ2UpCi0JCVdhbFVzYWdlQWNjdW1EaWZm KCZpbnN0ci0+aW5zdHIud2FsdXNhZ2UsCi0JCQkJCQkgICZwZ1dhbFVzYWdlLCAmaW5zdHItPmlu c3RyLndhbHVzYWdlX3N0YXJ0KTsKKwkvKgorCSAqIE9ubHkgcG9wIHRoZSBzdGFjaywgYWNjdW11 bGF0aW9uIHJ1bnMgaW4KKwkgKiBFeGVjRmluYWxpemVOb2RlSW5zdHJ1bWVudGF0aW9uCisJICov CisJaWYgKGluc3RyLT5pbnN0ci5uZWVkX3N0YWNrKQorCQlJbnN0clBvcFN0YWNrKCZpbnN0ci0+ aW5zdHIpOwogCiAJLyogSXMgdGhpcyB0aGUgZmlyc3QgdHVwbGUgb2YgdGhpcyBjeWNsZT8gKi8K IAlpZiAoIWluc3RyLT5ydW5uaW5nKQpAQCAtMTkwLDggKzQ2OCw4IEBAIEluc3RyRW5kTG9vcChO b2RlSW5zdHJ1bWVudGF0aW9uICppbnN0cikKIAlpZiAoIWluc3RyLT5ydW5uaW5nKQogCQlyZXR1 cm47CiAKLQlpZiAoIUlOU1RSX1RJTUVfSVNfWkVSTyhpbnN0ci0+aW5zdHIuc3RhcnR0aW1lKSkK LQkJZWxvZyhFUlJPUiwgIkluc3RyRW5kTG9vcCBjYWxsZWQgb24gcnVubmluZyBub2RlIik7CisJ LyogRW5zdXJlIEluc3RyTm9kZVN0b3Agd2FzIGNhbGxlZCAqLworCUFzc2VydChJTlNUUl9USU1F X0lTX1pFUk8oaW5zdHItPmluc3RyLnN0YXJ0dGltZSkpOwogCiAJLyogQWNjdW11bGF0ZSBwZXIt Y3ljbGUgc3RhdGlzdGljcyBpbnRvIHRvdGFscyAqLwogCUlOU1RSX1RJTUVfQUREKGluc3RyLT5z dGFydHVwLCBpbnN0ci0+Zmlyc3R0dXBsZSk7CkBAIC0yMjUsNjcgKzUwMyw3MyBAQCBJbnN0ckFn Z05vZGUoTm9kZUluc3RydW1lbnRhdGlvbiAqZHN0LCBOb2RlSW5zdHJ1bWVudGF0aW9uICphZGQp CiAJZHN0LT5uZmlsdGVyZWQyICs9IGFkZC0+bmZpbHRlcmVkMjsKIAogCS8qIEFkZCBkZWx0YSBv ZiBidWZmZXIgdXNhZ2Ugc2luY2UgZW50cnkgdG8gbm9kZSdzIHRvdGFscyAqLwotCWlmIChkc3Qt Pmluc3RyLm5lZWRfYnVmdXNhZ2UpCi0JCUJ1ZmZlclVzYWdlQWRkKCZkc3QtPmluc3RyLmJ1ZnVz YWdlLCAmYWRkLT5pbnN0ci5idWZ1c2FnZSk7Ci0KLQlpZiAoZHN0LT5pbnN0ci5uZWVkX3dhbHVz YWdlKQotCQlXYWxVc2FnZUFkZCgmZHN0LT5pbnN0ci53YWx1c2FnZSwgJmFkZC0+aW5zdHIud2Fs dXNhZ2UpOworCWlmIChkc3QtPmluc3RyLm5lZWRfc3RhY2spCisJCUluc3RyQWNjdW1TdGFjaygm ZHN0LT5pbnN0ciwgJmFkZC0+aW5zdHIpOwogfQogCiAvKiBUcmlnZ2VyIGluc3RydW1lbnRhdGlv biBoYW5kbGluZyAqLwogVHJpZ2dlckluc3RydW1lbnRhdGlvbiAqCi1JbnN0ckFsbG9jVHJpZ2dl cihpbnQgbiwgaW50IGluc3RydW1lbnRfb3B0aW9ucykKK0luc3RyQWxsb2NUcmlnZ2VyKFF1ZXJ5 SW5zdHJ1bWVudGF0aW9uICpxaW5zdHIsIGludCBuKQogewotCVRyaWdnZXJJbnN0cnVtZW50YXRp b24gKnRnaW5zdHIgPSBwYWxsb2MwKG4gKiBzaXplb2YoVHJpZ2dlckluc3RydW1lbnRhdGlvbikp OworCVRyaWdnZXJJbnN0cnVtZW50YXRpb24gKnRnaW5zdHI7CiAJaW50CQkJaTsKIAorCS8qCisJ ICogQWxsb2NhdGUgaW4gdGhlIHF1ZXJ5J3MgZGVkaWNhdGVkIGluc3RydW1lbnRhdGlvbiBjb250 ZXh0IHNvIGFsbAorCSAqIGluc3RydW1lbnRhdGlvbiBkYXRhIGlzIGdyb3VwZWQgdG9nZXRoZXIg YW5kIGNsZWFuZWQgdXAgYXMgYSB1bml0LgorCSAqLworCUFzc2VydChxaW5zdHIgIT0gTlVMTCAm JiBxaW5zdHItPmluc3RyX2N4dCAhPSBOVUxMKTsKKwl0Z2luc3RyID0gTWVtb3J5Q29udGV4dEFs bG9jWmVybyhxaW5zdHItPmluc3RyX2N4dCwKKwkJCQkJCQkJCSBuICogc2l6ZW9mKFRyaWdnZXJJ bnN0cnVtZW50YXRpb24pKTsKKwogCWZvciAoaSA9IDA7IGkgPCBuOyBpKyspCi0JCUluc3RySW5p dE9wdGlvbnMoJnRnaW5zdHJbaV0uaW5zdHIsIGluc3RydW1lbnRfb3B0aW9ucyk7CisJCUluc3Ry SW5pdE9wdGlvbnMoJnRnaW5zdHJbaV0uaW5zdHIsIHFpbnN0ci0+aW5zdHJ1bWVudF9vcHRpb25z KTsKIAogCXJldHVybiB0Z2luc3RyOwogfQogCiB2b2lkCi1JbnN0clN0YXJ0VHJpZ2dlcihUcmln Z2VySW5zdHJ1bWVudGF0aW9uICp0Z2luc3RyKQorSW5zdHJTdGFydFRyaWdnZXIoUXVlcnlJbnN0 cnVtZW50YXRpb24gKnFpbnN0ciwgVHJpZ2dlckluc3RydW1lbnRhdGlvbiAqdGdpbnN0cikKIHsK IAlJbnN0clN0YXJ0KCZ0Z2luc3RyLT5pbnN0cik7CisKKwkvKgorCSAqIE9uIGZpcnN0IGNhbGws IHJlZ2lzdGVyIHdpdGggdGhlIHBhcmVudCBRdWVyeUluc3RydW1lbnRhdGlvbiBmb3IgYWJvcnQK KwkgKiByZWNvdmVyeS4KKwkgKi8KKwlpZiAocWluc3RyICYmIHRnaW5zdHItPmluc3RyLm5lZWRf c3RhY2sgJiYKKwkJZGxpc3Rfbm9kZV9pc19kZXRhY2hlZCgmdGdpbnN0ci0+aW5zdHIudW5maW5h bGl6ZWRfZW50cnkpKQorCQlkbGlzdF9wdXNoX2hlYWQoJnFpbnN0ci0+dW5maW5hbGl6ZWRfZW50 cmllcywKKwkJCQkJCSZ0Z2luc3RyLT5pbnN0ci51bmZpbmFsaXplZF9lbnRyeSk7CiB9CiAKIHZv aWQKIEluc3RyU3RvcFRyaWdnZXIoVHJpZ2dlckluc3RydW1lbnRhdGlvbiAqdGdpbnN0ciwgaW50 IGZpcmluZ3MpCiB7CisJLyoKKwkgKiBUaGlzIHRyaWdnZXIgbWF5IGJlIGNhbGxlZCBhZ2Fpbiwg c28gd2UgZG9uJ3QgZmluYWxpemUgaW5zdHJ1bWVudGF0aW9uCisJICogaGVyZS4gQWNjdW11bGF0 aW9uIHRvIHRoZSBwYXJlbnQgaGFwcGVucyBhdCBFeGVjdXRvckZpbmlzaCB0aHJvdWdoCisJICog RXhlY0ZpbmFsaXplVHJpZ2dlckluc3RydW1lbnRhdGlvbi4KKwkgKi8KIAlJbnN0clN0b3AoJnRn aW5zdHItPmluc3RyKTsKIAl0Z2luc3RyLT5maXJpbmdzICs9IGZpcmluZ3M7CiB9CiAKLS8qIG5v dGUgY3VycmVudCB2YWx1ZXMgZHVyaW5nIHBhcmFsbGVsIGV4ZWN1dG9yIHN0YXJ0dXAgKi8KIHZv aWQKLUluc3RyU3RhcnRQYXJhbGxlbFF1ZXJ5KHZvaWQpCitJbnN0ckFjY3VtU3RhY2soSW5zdHJ1 bWVudGF0aW9uICpkc3QsIEluc3RydW1lbnRhdGlvbiAqYWRkKQogewotCXNhdmVfcGdCdWZmZXJV c2FnZSA9IHBnQnVmZmVyVXNhZ2U7Ci0Jc2F2ZV9wZ1dhbFVzYWdlID0gcGdXYWxVc2FnZTsKLX0K KwlBc3NlcnQoZHN0ICE9IE5VTEwpOworCUFzc2VydChhZGQgIT0gTlVMTCk7CiAKLS8qIHJlcG9y dCB1c2FnZSBhZnRlciBwYXJhbGxlbCBleGVjdXRvciBzaHV0ZG93biAqLwotdm9pZAotSW5zdHJF bmRQYXJhbGxlbFF1ZXJ5KEJ1ZmZlclVzYWdlICpidWZ1c2FnZSwgV2FsVXNhZ2UgKndhbHVzYWdl KQotewotCW1lbXNldChidWZ1c2FnZSwgMCwgc2l6ZW9mKEJ1ZmZlclVzYWdlKSk7Ci0JQnVmZmVy VXNhZ2VBY2N1bURpZmYoYnVmdXNhZ2UsICZwZ0J1ZmZlclVzYWdlLCAmc2F2ZV9wZ0J1ZmZlclVz YWdlKTsKLQltZW1zZXQod2FsdXNhZ2UsIDAsIHNpemVvZihXYWxVc2FnZSkpOwotCVdhbFVzYWdl QWNjdW1EaWZmKHdhbHVzYWdlLCAmcGdXYWxVc2FnZSwgJnNhdmVfcGdXYWxVc2FnZSk7Ci19CisJ aWYgKCFhZGQtPm5lZWRfc3RhY2spCisJCXJldHVybjsKIAotLyogYWNjdW11bGF0ZSB3b3JrIGRv bmUgYnkgd29ya2VycyBpbiBsZWFkZXIncyBzdGF0cyAqLwotdm9pZAotSW5zdHJBY2N1bVBhcmFs bGVsUXVlcnkoQnVmZmVyVXNhZ2UgKmJ1ZnVzYWdlLCBXYWxVc2FnZSAqd2FsdXNhZ2UpCi17Ci0J QnVmZmVyVXNhZ2VBZGQoJnBnQnVmZmVyVXNhZ2UsIGJ1ZnVzYWdlKTsKLQlXYWxVc2FnZUFkZCgm cGdXYWxVc2FnZSwgd2FsdXNhZ2UpOworCUJ1ZmZlclVzYWdlQWRkKCZkc3QtPmJ1ZnVzYWdlLCAm YWRkLT5idWZ1c2FnZSk7CisJV2FsVXNhZ2VBZGQoJmRzdC0+d2FsdXNhZ2UsICZhZGQtPndhbHVz YWdlKTsKIH0KIAogLyogZHN0ICs9IGFkZCAqLwotc3RhdGljIHZvaWQKK3ZvaWQKIEJ1ZmZlclVz YWdlQWRkKEJ1ZmZlclVzYWdlICpkc3QsIGNvbnN0IEJ1ZmZlclVzYWdlICphZGQpCiB7CiAJZHN0 LT5zaGFyZWRfYmxrc19oaXQgKz0gYWRkLT5zaGFyZWRfYmxrc19oaXQ7CkBAIC0zMDYsMzkgKzU5 MCw5IEBAIEJ1ZmZlclVzYWdlQWRkKEJ1ZmZlclVzYWdlICpkc3QsIGNvbnN0IEJ1ZmZlclVzYWdl ICphZGQpCiAJSU5TVFJfVElNRV9BREQoZHN0LT50ZW1wX2Jsa193cml0ZV90aW1lLCBhZGQtPnRl bXBfYmxrX3dyaXRlX3RpbWUpOwogfQogCi0vKiBkc3QgKz0gYWRkIC0gc3ViICovCisvKiBkc3Qg Kz0gYWRkICovCiB2b2lkCi1CdWZmZXJVc2FnZUFjY3VtRGlmZihCdWZmZXJVc2FnZSAqZHN0LAot CQkJCQkgY29uc3QgQnVmZmVyVXNhZ2UgKmFkZCwKLQkJCQkJIGNvbnN0IEJ1ZmZlclVzYWdlICpz dWIpCi17Ci0JZHN0LT5zaGFyZWRfYmxrc19oaXQgKz0gYWRkLT5zaGFyZWRfYmxrc19oaXQgLSBz dWItPnNoYXJlZF9ibGtzX2hpdDsKLQlkc3QtPnNoYXJlZF9ibGtzX3JlYWQgKz0gYWRkLT5zaGFy ZWRfYmxrc19yZWFkIC0gc3ViLT5zaGFyZWRfYmxrc19yZWFkOwotCWRzdC0+c2hhcmVkX2Jsa3Nf ZGlydGllZCArPSBhZGQtPnNoYXJlZF9ibGtzX2RpcnRpZWQgLSBzdWItPnNoYXJlZF9ibGtzX2Rp cnRpZWQ7Ci0JZHN0LT5zaGFyZWRfYmxrc193cml0dGVuICs9IGFkZC0+c2hhcmVkX2Jsa3Nfd3Jp dHRlbiAtIHN1Yi0+c2hhcmVkX2Jsa3Nfd3JpdHRlbjsKLQlkc3QtPmxvY2FsX2Jsa3NfaGl0ICs9 IGFkZC0+bG9jYWxfYmxrc19oaXQgLSBzdWItPmxvY2FsX2Jsa3NfaGl0OwotCWRzdC0+bG9jYWxf Ymxrc19yZWFkICs9IGFkZC0+bG9jYWxfYmxrc19yZWFkIC0gc3ViLT5sb2NhbF9ibGtzX3JlYWQ7 Ci0JZHN0LT5sb2NhbF9ibGtzX2RpcnRpZWQgKz0gYWRkLT5sb2NhbF9ibGtzX2RpcnRpZWQgLSBz dWItPmxvY2FsX2Jsa3NfZGlydGllZDsKLQlkc3QtPmxvY2FsX2Jsa3Nfd3JpdHRlbiArPSBhZGQt PmxvY2FsX2Jsa3Nfd3JpdHRlbiAtIHN1Yi0+bG9jYWxfYmxrc193cml0dGVuOwotCWRzdC0+dGVt cF9ibGtzX3JlYWQgKz0gYWRkLT50ZW1wX2Jsa3NfcmVhZCAtIHN1Yi0+dGVtcF9ibGtzX3JlYWQ7 Ci0JZHN0LT50ZW1wX2Jsa3Nfd3JpdHRlbiArPSBhZGQtPnRlbXBfYmxrc193cml0dGVuIC0gc3Vi LT50ZW1wX2Jsa3Nfd3JpdHRlbjsKLQlJTlNUUl9USU1FX0FDQ1VNX0RJRkYoZHN0LT5zaGFyZWRf YmxrX3JlYWRfdGltZSwKLQkJCQkJCSAgYWRkLT5zaGFyZWRfYmxrX3JlYWRfdGltZSwgc3ViLT5z aGFyZWRfYmxrX3JlYWRfdGltZSk7Ci0JSU5TVFJfVElNRV9BQ0NVTV9ESUZGKGRzdC0+c2hhcmVk X2Jsa193cml0ZV90aW1lLAotCQkJCQkJICBhZGQtPnNoYXJlZF9ibGtfd3JpdGVfdGltZSwgc3Vi LT5zaGFyZWRfYmxrX3dyaXRlX3RpbWUpOwotCUlOU1RSX1RJTUVfQUNDVU1fRElGRihkc3QtPmxv Y2FsX2Jsa19yZWFkX3RpbWUsCi0JCQkJCQkgIGFkZC0+bG9jYWxfYmxrX3JlYWRfdGltZSwgc3Vi LT5sb2NhbF9ibGtfcmVhZF90aW1lKTsKLQlJTlNUUl9USU1FX0FDQ1VNX0RJRkYoZHN0LT5sb2Nh bF9ibGtfd3JpdGVfdGltZSwKLQkJCQkJCSAgYWRkLT5sb2NhbF9ibGtfd3JpdGVfdGltZSwgc3Vi LT5sb2NhbF9ibGtfd3JpdGVfdGltZSk7Ci0JSU5TVFJfVElNRV9BQ0NVTV9ESUZGKGRzdC0+dGVt cF9ibGtfcmVhZF90aW1lLAotCQkJCQkJICBhZGQtPnRlbXBfYmxrX3JlYWRfdGltZSwgc3ViLT50 ZW1wX2Jsa19yZWFkX3RpbWUpOwotCUlOU1RSX1RJTUVfQUNDVU1fRElGRihkc3QtPnRlbXBfYmxr X3dyaXRlX3RpbWUsCi0JCQkJCQkgIGFkZC0+dGVtcF9ibGtfd3JpdGVfdGltZSwgc3ViLT50ZW1w X2Jsa193cml0ZV90aW1lKTsKLX0KLQotLyogaGVscGVyIGZ1bmN0aW9ucyBmb3IgV0FMIHVzYWdl IGFjY3VtdWxhdGlvbiAqLwotc3RhdGljIHZvaWQKLVdhbFVzYWdlQWRkKFdhbFVzYWdlICpkc3Qs IFdhbFVzYWdlICphZGQpCitXYWxVc2FnZUFkZChXYWxVc2FnZSAqZHN0LCBjb25zdCBXYWxVc2Fn ZSAqYWRkKQogewogCWRzdC0+d2FsX2J5dGVzICs9IGFkZC0+d2FsX2J5dGVzOwogCWRzdC0+d2Fs X3JlY29yZHMgKz0gYWRkLT53YWxfcmVjb3JkczsKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3Jl cGxpY2F0aW9uL2xvZ2ljYWwvd29ya2VyLmMgYi9zcmMvYmFja2VuZC9yZXBsaWNhdGlvbi9sb2dp Y2FsL3dvcmtlci5jCmluZGV4IGIzODE3MGYwZmJlLi4zY2EwYTdhNjM1ZCAxMDA2NDQKLS0tIGEv c3JjL2JhY2tlbmQvcmVwbGljYXRpb24vbG9naWNhbC93b3JrZXIuYworKysgYi9zcmMvYmFja2Vu ZC9yZXBsaWNhdGlvbi9sb2dpY2FsL3dvcmtlci5jCkBAIC05MDQsNyArOTA0LDcgQEAgY3JlYXRl X2VkYXRhX2Zvcl9yZWxhdGlvbihMb2dpY2FsUmVwUmVsTWFwRW50cnkgKnJlbCkKIAkgKiBVc2Ug UmVsYXRpb24gb3BlbmVkIGJ5IGxvZ2ljYWxyZXBfcmVsX29wZW4oKSBpbnN0ZWFkIG9mIG9wZW5p bmcgaXQKIAkgKiBhZ2Fpbi4KIAkgKi8KLQlJbml0UmVzdWx0UmVsSW5mbyhyZXN1bHRSZWxJbmZv LCByZWwtPmxvY2FscmVsLCAxLCBOVUxMLCAwKTsKKwlJbml0UmVzdWx0UmVsSW5mbyhyZXN1bHRS ZWxJbmZvLCByZWwtPmxvY2FscmVsLCAxLCBOVUxMLCBOVUxMKTsKIAogCS8qCiAJICogV2UgcHV0 IHRoZSBSZXN1bHRSZWxJbmZvIGluIHRoZSBlc19vcGVuZWRfcmVzdWx0X3JlbGF0aW9ucyBsaXN0 LCBldmVuCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9zdG9yYWdlL2J1ZmZlci9idWZtZ3IuYyBi L3NyYy9iYWNrZW5kL3N0b3JhZ2UvYnVmZmVyL2J1Zm1nci5jCmluZGV4IDNlMWMzOTE2MGRiLi5j ZjRmNDI0NmNhMiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvc3RvcmFnZS9idWZmZXIvYnVmbWdy LmMKKysrIGIvc3JjL2JhY2tlbmQvc3RvcmFnZS9idWZmZXIvYnVmbWdyLmMKQEAgLTEyNjYsOSAr MTI2Niw5IEBAIFBpbkJ1ZmZlckZvckJsb2NrKFJlbGF0aW9uIHJlbCwKIAlpZiAocmVsKQogCXsK IAkJLyoKLQkJICogV2hpbGUgcGdCdWZmZXJVc2FnZSdzICJyZWFkIiBjb3VudGVyIGlzbid0IGJ1 bXBlZCB1bmxlc3Mgd2UgcmVhY2gKLQkJICogV2FpdFJlYWRCdWZmZXJzKCkgKHNvLCBub3QgZm9y IGhpdHMsIGFuZCBub3QgZm9yIGJ1ZmZlcnMgdGhhdCBhcmUKLQkJICogemVyb2VkIGluc3RlYWQp LCB0aGUgcGVyLXJlbGF0aW9uIHN0YXRzIGFsd2F5cyBjb3VudCB0aGVtLgorCQkgKiBXaGlsZSB0 aGUgY3VycmVudCBidWZmZXIgdXNhZ2UgInJlYWQiIGNvdW50ZXIgaXNuJ3QgYnVtcGVkIHVubGVz cworCQkgKiB3ZSByZWFjaCBXYWl0UmVhZEJ1ZmZlcnMoKSAoc28sIG5vdCBmb3IgaGl0cywgYW5k IG5vdCBmb3IgYnVmZmVycworCQkgKiB0aGF0IGFyZSB6ZXJvZWQgaW5zdGVhZCksIHRoZSBwZXIt cmVsYXRpb24gc3RhdHMgYWx3YXlzIGNvdW50IHRoZW0uCiAJCSAqLwogCQlwZ3N0YXRfY291bnRf YnVmZmVyX3JlYWQocmVsKTsKIAl9CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC91dGlscy9hY3Rp dml0eS9wZ3N0YXRfaW8uYyBiL3NyYy9iYWNrZW5kL3V0aWxzL2FjdGl2aXR5L3Bnc3RhdF9pby5j CmluZGV4IGUzODI5ZDdmZTdjLi5lN2ZjN2YwNzFkOCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQv dXRpbHMvYWN0aXZpdHkvcGdzdGF0X2lvLmMKKysrIGIvc3JjL2JhY2tlbmQvdXRpbHMvYWN0aXZp dHkvcGdzdGF0X2lvLmMKQEAgLTExNCw5ICsxMTQsOSBAQCBwZ3N0YXRfcHJlcGFyZV9pb190aW1l KGJvb2wgdHJhY2tfaW9fZ3VjKQogICogcGdfc3RhdF9kYXRhYmFzZSBvbmx5IGNvdW50cyBibG9j ayByZWFkIGFuZCB3cml0ZSB0aW1lcywgdGhlc2UgYXJlIGRvbmUgZm9yCiAgKiBJT09QX1JFQUQs IElPT1BfV1JJVEUgYW5kIElPT1BfRVhURU5ELgogICoKLSAqIHBnQnVmZmVyVXNhZ2UgaXMgdXNl ZCBmb3IgRVhQTEFJTi4gIHBnQnVmZmVyVXNhZ2UgaGFzIHdyaXRlIGFuZCByZWFkIHN0YXRzCi0g KiBmb3Igc2hhcmVkLCBsb2NhbCBhbmQgdGVtcG9yYXJ5IGJsb2Nrcy4gIHBnX3N0YXRfaW8gZG9l cyBub3QgdHJhY2sgdGhlCi0gKiBhY3Rpdml0eSBvZiB0ZW1wb3JhcnkgYmxvY2tzLCBzbyB0aGVz ZSBhcmUgaWdub3JlZCBoZXJlLgorICogRXhlY3V0b3IgaW5zdHJ1bWVudGF0aW9uIGlzIHVzZWQg Zm9yIEVYUExBSU4uIEJ1ZmZlciB1c2FnZSB0cmFja2VkIHRoZXJlIGhhcworICogd3JpdGUgYW5k IHJlYWQgc3RhdHMgZm9yIHNoYXJlZCwgbG9jYWwgYW5kIHRlbXBvcmFyeSBibG9ja3MuIHBnX3N0 YXRfaW8KKyAqIGRvZXMgbm90IHRyYWNrIHRoZSBhY3Rpdml0eSBvZiB0ZW1wb3JhcnkgYmxvY2tz LCBzbyB0aGVzZSBhcmUgaWdub3JlZCBoZXJlLgogICovCiB2b2lkCiBwZ3N0YXRfY291bnRfaW9f b3BfdGltZShJT09iamVjdCBpb19vYmplY3QsIElPQ29udGV4dCBpb19jb250ZXh0LCBJT09wIGlv X29wLApkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvZXhlY3V0b3IvZXhlY2Rlc2MuaCBiL3NyYy9p bmNsdWRlL2V4ZWN1dG9yL2V4ZWNkZXNjLmgKaW5kZXggZDNhNTcyNDI4NDQuLjM0MDAyOWEyMDM0 IDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9leGVjdXRvci9leGVjZGVzYy5oCisrKyBiL3NyYy9p bmNsdWRlL2V4ZWN1dG9yL2V4ZWNkZXNjLmgKQEAgLTUxLDggKzUxLDggQEAgdHlwZWRlZiBzdHJ1 Y3QgUXVlcnlEZXNjCiAJLyogVGhpcyBmaWVsZCBpcyBzZXQgYnkgRXhlY3V0ZVBsYW4gKi8KIAli b29sCQlhbHJlYWR5X2V4ZWN1dGVkOwkvKiB0cnVlIGlmIHByZXZpb3VzbHkgZXhlY3V0ZWQgKi8K IAotCS8qIFRoaXMgaXMgYWx3YXlzIHNldCBOVUxMIGJ5IHRoZSBjb3JlIHN5c3RlbSwgYnV0IHBs dWdpbnMgY2FuIGNoYW5nZSBpdCAqLwotCXN0cnVjdCBJbnN0cnVtZW50YXRpb24gKnRvdGFsdGlt ZTsJLyogdG90YWwgdGltZSBzcGVudCBpbiBFeGVjdXRvclJ1biAqLworCS8qIFRoaXMgZmllbGQg aXMgc2V0IGJ5IEV4ZWN1dG9yUnVuLCBvciBwbHVnaW5zICovCisJc3RydWN0IFF1ZXJ5SW5zdHJ1 bWVudGF0aW9uICp0b3RhbHRpbWU7IC8qIHRvdGFsIHRpbWUgc3BlbnQgaW4gRXhlY3V0b3JSdW4g Ki8KIH0gUXVlcnlEZXNjOwogCiAvKiBpbiBwcXVlcnkuYyAqLwpkaWZmIC0tZ2l0IGEvc3JjL2lu Y2x1ZGUvZXhlY3V0b3IvZXhlY3V0b3IuaCBiL3NyYy9pbmNsdWRlL2V4ZWN1dG9yL2V4ZWN1dG9y LmgKaW5kZXggNDkxYzQ4ODY1MDYuLjAzZjBlODY0MTc2IDEwMDY0NAotLS0gYS9zcmMvaW5jbHVk ZS9leGVjdXRvci9leGVjdXRvci5oCisrKyBiL3NyYy9pbmNsdWRlL2V4ZWN1dG9yL2V4ZWN1dG9y LmgKQEAgLTIzMyw2ICsyMzMsNyBAQCBFeGVjR2V0SnVua0F0dHJpYnV0ZShUdXBsZVRhYmxlU2xv dCAqc2xvdCwgQXR0ck51bWJlciBhdHRubywgYm9vbCAqaXNOdWxsKQogLyoKICAqIHByb3RvdHlw ZXMgZnJvbSBmdW5jdGlvbnMgaW4gZXhlY01haW4uYwogICovCit0eXBlZGVmIHN0cnVjdCBRdWVy eUluc3RydW1lbnRhdGlvbiBRdWVyeUluc3RydW1lbnRhdGlvbjsKIGV4dGVybiB2b2lkIEV4ZWN1 dG9yU3RhcnQoUXVlcnlEZXNjICpxdWVyeURlc2MsIGludCBlZmxhZ3MpOwogZXh0ZXJuIHZvaWQg c3RhbmRhcmRfRXhlY3V0b3JTdGFydChRdWVyeURlc2MgKnF1ZXJ5RGVzYywgaW50IGVmbGFncyk7 CiBleHRlcm4gdm9pZCBFeGVjdXRvclJ1bihRdWVyeURlc2MgKnF1ZXJ5RGVzYywKQEAgLTI1NCw3 ICsyNTUsNyBAQCBleHRlcm4gdm9pZCBJbml0UmVzdWx0UmVsSW5mbyhSZXN1bHRSZWxJbmZvICpy ZXN1bHRSZWxJbmZvLAogCQkJCQkJCSAgUmVsYXRpb24gcmVzdWx0UmVsYXRpb25EZXNjLAogCQkJ CQkJCSAgSW5kZXggcmVzdWx0UmVsYXRpb25JbmRleCwKIAkJCQkJCQkgIFJlc3VsdFJlbEluZm8g KnBhcnRpdGlvbl9yb290X3JyaSwKLQkJCQkJCQkgIGludCBpbnN0cnVtZW50X29wdGlvbnMpOwor CQkJCQkJCSAgUXVlcnlJbnN0cnVtZW50YXRpb24gKnFpbnN0cik7CiBleHRlcm4gUmVzdWx0UmVs SW5mbyAqRXhlY0dldFRyaWdnZXJSZXN1bHRSZWwoRVN0YXRlICplc3RhdGUsIE9pZCByZWxpZCwK IAkJCQkJCQkJCQkJICBSZXN1bHRSZWxJbmZvICpyb290UmVsSW5mbyk7CiBleHRlcm4gTGlzdCAq RXhlY0dldEFuY2VzdG9yUmVzdWx0UmVscyhFU3RhdGUgKmVzdGF0ZSwgUmVzdWx0UmVsSW5mbyAq cmVzdWx0UmVsSW5mbyk7CkBAIC0zMDEsNiArMzAyLDggQEAgZXh0ZXJuIHZvaWQgRXhlY1NldEV4 ZWNQcm9jTm9kZShQbGFuU3RhdGUgKm5vZGUsIEV4ZWNQcm9jTm9kZU10ZCBmdW5jdGlvbik7CiBl eHRlcm4gTm9kZSAqTXVsdGlFeGVjUHJvY05vZGUoUGxhblN0YXRlICpub2RlKTsKIGV4dGVybiB2 b2lkIEV4ZWNFbmROb2RlKFBsYW5TdGF0ZSAqbm9kZSk7CiBleHRlcm4gdm9pZCBFeGVjU2h1dGRv d25Ob2RlKFBsYW5TdGF0ZSAqbm9kZSk7CitleHRlcm4gdm9pZCBFeGVjRmluYWxpemVOb2RlSW5z dHJ1bWVudGF0aW9uKFBsYW5TdGF0ZSAqbm9kZSk7CitleHRlcm4gdm9pZCBFeGVjRmluYWxpemVX b3JrZXJJbnN0cnVtZW50YXRpb24oUGxhblN0YXRlICpub2RlKTsKIGV4dGVybiB2b2lkIEV4ZWNT ZXRUdXBsZUJvdW5kKGludDY0IHR1cGxlc19uZWVkZWQsIFBsYW5TdGF0ZSAqY2hpbGRfbm9kZSk7 CiAKIApkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvZXhlY3V0b3IvaW5zdHJ1bWVudC5oIGIvc3Jj L2luY2x1ZGUvZXhlY3V0b3IvaW5zdHJ1bWVudC5oCmluZGV4IGQ0NzY5ZjNkYTdiLi5kMmYwMTkx YWYyNyAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvZXhlY3V0b3IvaW5zdHJ1bWVudC5oCisrKyBi L3NyYy9pbmNsdWRlL2V4ZWN1dG9yL2luc3RydW1lbnQuaApAQCAtMTMsNiArMTMsNyBAQAogI2lm bmRlZiBJTlNUUlVNRU5UX0gKICNkZWZpbmUgSU5TVFJVTUVOVF9ICiAKKyNpbmNsdWRlICJsaWIv aWxpc3QuaCIKICNpbmNsdWRlICJwb3J0YWJpbGl0eS9pbnN0cl90aW1lLmgiCiAKIApAQCAtNjgs MjkgKzY5LDkyIEBAIHR5cGVkZWYgZW51bSBJbnN0cnVtZW50T3B0aW9uCiB9IEluc3RydW1lbnRP cHRpb247CiAKIC8qCi0gKiBHZW5lcmFsIHB1cnBvc2UgaW5zdHJ1bWVudGF0aW9uIHRoYXQgY2Fu IGNhcHR1cmUgdGltZSBhbmQgV0FML2J1ZmZlciB1c2FnZQorICogSW5zdHJ1bWVudGF0aW9uIGJh c2UgY2xhc3MgZm9yIGNhcHR1cmluZyB0aW1lIGFuZCBXQUwvYnVmZmVyIHVzYWdlCiAgKgotICog SW5pdGlhbGl6ZWQgdGhyb3VnaCBJbnN0ckFsbG9jLCBmb2xsb3dlZCBieSBvbmUgb3IgbW9yZSBj YWxscyB0byBhIHBhaXIgb2YKLSAqIEluc3RyU3RhcnQvSW5zdHJTdG9wIChhY3Rpdml0eSBpcyBt ZWFzdXJlZCBpbmJldHdlZW4pLgorICogSWYgdXNlZCBkaXJlY3RseToKKyAqIC0gQWxsb2NhdGUg b24gdGhlIHN0YWNrIGFuZCB6ZXJvIGluaXRpYWxpemUgdGhlIHN0cnVjdAorICogLSBDYWxsIElu c3RySW5pdE9wdGlvbnMgdG8gc2V0IGluc3RydW1lbnRhdGlvbiBvcHRpb25zCisgKiAtIENhbGwg SW5zdHJTdGFydCBiZWZvcmUgdGhlIGFjdGl2aXR5IHlvdSB3YW50IHRvIG1lYXN1cmUKKyAqIC0g Q2FsbCBJbnN0clN0b3AgLyBJbnN0clN0b3BGaW5hbGl6ZSBhZnRlciB0aGUgYWN0aXZpdHkgdG8g Y2FwdHVyZSB0b3RhbHMKKyAqCisgKiBJbnN0clN0YXJ0L0luc3RyU3RvcCBtYXkgYmUgY2FsbGVk IG11bHRpcGxlIHRpbWVzLiBUaGUgbGFzdCBzdG9wIGNhbGwgbXVzdAorICogYmUgdG8gSW5zdHJT dG9wRmluYWxpemUgdG8gZW5zdXJlIHBhcmVudCBzdGFjayBlbnRyaWVzIGdldCB0aGUgYWNjdW11 bGF0ZWQKKyAqIHRvdGFscy4gSWYgdGhlcmUgaXMgcmlzayBvZiB0cmFuc2FjdGlvbiBhYm9ydHMg eW91IG11c3QgY2FsbAorICogSW5zdHJTdG9wRmluYWxpemUgaW4gYSBQR19UUlkvUEdfRklOQUxM WSBibG9jayB0byBhdm9pZCBjb3JydXB0aW5nIHRoZQorICogaW5zdHJ1bWVudGF0aW9uIHN0YWNr LgorICoKKyAqIEluIGEgcXVlcnkgY29udGV4dCB1c2UgUXVlcnlJbnN0cnVtZW50YXRpb24gaW5z dGVhZCwgd2hpY2ggaGFuZGxlcyBhYm9ydHMKKyAqIHVzaW5nIHRoZSByZXNvdXJjZSBvd25lciBs b2dpYy4KICAqLwogdHlwZWRlZiBzdHJ1Y3QgSW5zdHJ1bWVudGF0aW9uCiB7CiAJLyogUGFyYW1l dGVycyBzZXQgYXQgY3JlYXRpb246ICovCiAJYm9vbAkJbmVlZF90aW1lcjsJCS8qIHRydWUgaWYg d2UgbmVlZCB0aW1lciBkYXRhICovCi0JYm9vbAkJbmVlZF9idWZ1c2FnZTsJLyogdHJ1ZSBpZiB3 ZSBuZWVkIGJ1ZmZlciB1c2FnZSBkYXRhICovCi0JYm9vbAkJbmVlZF93YWx1c2FnZTsJLyogdHJ1 ZSBpZiB3ZSBuZWVkIFdBTCB1c2FnZSBkYXRhICovCisJYm9vbAkJbmVlZF9zdGFjazsJCS8qIHRy dWUgaWYgd2UgbmVlZCBXQUwvYnVmZmVyIHVzYWdlIGRhdGEgKi8KIAkvKiBJbnRlcm5hbCBzdGF0 ZSBrZWVwaW5nOiAqLworCWJvb2wJCW9uX3N0YWNrOwkJLyogdHJ1ZSBpZiBjdXJyZW50bHkgb24g aW5zdHJfc3RhY2sgKi8KIAlpbnN0cl90aW1lCXN0YXJ0dGltZTsJCS8qIHN0YXJ0IHRpbWUgb2Yg bGFzdCBJbnN0clN0YXJ0ICovCi0JQnVmZmVyVXNhZ2UgYnVmdXNhZ2Vfc3RhcnQ7IC8qIGJ1ZmZl ciB1c2FnZSBhdCBzdGFydCAqLwotCVdhbFVzYWdlCXdhbHVzYWdlX3N0YXJ0OyAvKiBXQUwgdXNh Z2UgYXQgc3RhcnQgKi8KIAkvKiBBY2N1bXVsYXRlZCBzdGF0aXN0aWNzOiAqLwogCWluc3RyX3Rp bWUJdG90YWw7CQkJLyogdG90YWwgcnVudGltZSAqLwogCUJ1ZmZlclVzYWdlIGJ1ZnVzYWdlOwkJ LyogdG90YWwgYnVmZmVyIHVzYWdlICovCiAJV2FsVXNhZ2UJd2FsdXNhZ2U7CQkvKiB0b3RhbCBX QUwgdXNhZ2UgKi8KKwkvKiBBYm9ydCBoYW5kbGluZzogbGluayBpbiBwYXJlbnQgUXVlcnlJbnN0 cnVtZW50YXRpb24ncyB1bmZpbmFsaXplZCBsaXN0ICovCisJZGxpc3Rfbm9kZQl1bmZpbmFsaXpl ZF9lbnRyeTsKIH0gSW5zdHJ1bWVudGF0aW9uOwogCisvKgorICogUXVlcnktcmVsYXRlZCBpbnN0 cnVtZW50YXRpb24gdHJhY2tpbmcuCisgKgorICogVXNhZ2U6CisgKiAtIEFsbG9jYXRlIG9uIHRo ZSBoZWFwIHVzaW5nIEluc3RyUXVlcnlBbGxvYyAocmVxdWlyZWQgZm9yIGFib3J0IGhhbmRsaW5n KQorICogLSBDYWxsIEluc3RyUXVlcnlTdGFydCBiZWZvcmUgdGhlIGFjdGl2aXR5IHlvdSB3YW50 IHRvIG1lYXN1cmUKKyAqIC0gQ2FsbCBJbnN0clF1ZXJ5U3RvcCAvIEluc3RyUXVlcnlTdG9wRmlu YWxpemUgYWZ0ZXJ3YXJkcyB0byBjYXB0dXJlIHRvdGFscworICoKKyAqIEluc3RyUXVlcnlTdGFy dC9JbnN0clF1ZXJ5U3RvcCBtYXkgYmUgY2FsbGVkIG11bHRpcGxlIHRpbWVzLiBUaGUgbGFzdCBz dG9wCisgKiBjYWxsIG11c3QgYmUgdG8gSW5zdHJRdWVyeVN0b3BGaW5hbGl6ZSB0byBlbnN1cmUg cGFyZW50IHN0YWNrIGVudHJpZXMgZ2V0CisgKiB0aGUgYWNjdW11bGF0ZWQgdG90YWxzLgorICoK KyAqIFVzZXMgcmVzb3VyY2Ugb3duZXIgbWVjaGFuaXNtIGZvciBoYW5kbGluZyBhYm9ydHMsIGFz IHN1Y2gsIHRoZSBjYWxsZXIKKyAqICptdXN0KiBub3QgZXhpdCBvdXQgb2YgdGhlIHRvcCBsZXZl bCB0cmFuc2FjdGlvbiBhZnRlciBoYXZpbmcgY2FsbGVkCisgKiBJbnN0clF1ZXJ5U3RhcnQsIHdp dGhvdXQgZmlyc3QgY2FsbGluZyBJbnN0clF1ZXJ5U3RvcCBvcgorICogSW5zdHJRdWVyeVN0b3BG aW5hbGl6ZS4gSW4gdGhlIGNhc2Ugb2YgYSB0cmFuc2FjdGlvbiBhYm9ydCwgbG9naWMgZXF1aXZh bGVudAorICogdG8gSW5zdHJRdWVyeVN0b3BGaW5hbGl6ZSB3aWxsIGJlIGNhbGxlZCBhdXRvbWF0 aWNhbGx5LgorICovCitzdHJ1Y3QgUmVzb3VyY2VPd25lckRhdGE7Cit0eXBlZGVmIHN0cnVjdCBR dWVyeUluc3RydW1lbnRhdGlvbgoreworCUluc3RydW1lbnRhdGlvbiBpbnN0cjsKKworCS8qIE9y aWdpbmFsIGluc3RydW1lbnRfb3B0aW9ucyBmbGFncyB1c2VkIHRvIGNyZWF0ZSB0aGlzIGluc3Ry dW1lbnRhdGlvbiAqLworCWludAkJCWluc3RydW1lbnRfb3B0aW9uczsKKworCS8qIFJlc291cmNl IG93bmVyIHVzZWQgZm9yIGNsZWFudXAgZm9yIGFib3J0cyBiZXR3ZWVuIEluc3RyU3RhcnQvSW5z dHJTdG9wICovCisJc3RydWN0IFJlc291cmNlT3duZXJEYXRhICpvd25lcjsKKworCS8qCisJICog RGVkaWNhdGVkIG1lbW9yeSBjb250ZXh0IGZvciBhbGwgaW5zdHJ1bWVudGF0aW9uIGFsbG9jYXRp b25zIGJlbG9uZ2luZworCSAqIHRvIHRoaXMgcXVlcnkgKG5vZGUgaW5zdHJ1bWVudGF0aW9uLCB0 cmlnZ2VyIGluc3RydW1lbnRhdGlvbiwgZXRjLikuCisJICogSW5pdGlhbGx5IGEgY2hpbGQgb2Yg VG9wTWVtb3J5Q29udGV4dCBzbyBpdCBzdXJ2aXZlcyB0cmFuc2FjdGlvbiBhYm9ydAorCSAqIGZv ciBSZXNvdXJjZU93bmVyIGNsZWFudXAsIHdoaWNoIGlzIHRoZW4gcmVhc3NpZ25lZCB0byB0aGUg Y3VycmVudAorCSAqIG1lbW9yeSBjb250ZXh0IG9uIEluc3RyUXVlcnlTdG9wRmluYWxpemUuCisJ ICovCisJTWVtb3J5Q29udGV4dCBpbnN0cl9jeHQ7CisKKwkvKgorCSAqIENoaWxkIGVudHJpZXMg dGhhdCBuZWVkIHRvIGJlIGNsZWFuZWQgdXAgb24gYWJvcnQsIHNpbmNlIHRoZXkgYXJlIG5vdAor CSAqIHJlZ2lzdGVyZWQgYXMgYSByZXNvdXJjZSBvd25lciB0aGVtc2VsdmVzLiBDb250YWlucyBi b3RoIG5vZGUgYW5kCisJICogdHJpZ2dlciBpbnN0cnVtZW50YXRpb24gZW50cmllcyBsaW5rZWQg dmlhIGluc3RyLnVuZmluYWxpemVkX2VudHJ5LgorCSAqLworCWRsaXN0X2hlYWQJdW5maW5hbGl6 ZWRfZW50cmllczsKK30gUXVlcnlJbnN0cnVtZW50YXRpb247CisKIC8qCiAgKiBTcGVjaWFsaXpl ZCBpbnN0cnVtZW50YXRpb24gZm9yIHBlci1ub2RlIGV4ZWN1dGlvbiBzdGF0aXN0aWNzCisgKgor ICogUmVsaWVzIG9uIGFuIG91dGVyIFF1ZXJ5SW5zdHJ1bWVudGF0aW9uIGhhdmluZyBiZWVuIHNl dCB1cCB0byBoYW5kbGUgdGhlCisgKiBzdGFjayB1c2VkIGZvciBXQUwvYnVmZmVyIHVzYWdlIHN0 YXRpc3RpY3MsIGFuZCByZWxpZXMgb24gaXQgZm9yIG1hbmFnaW5nCisgKiBhYm9ydHMuIFNvbGVs eSBpbnRlbmRlZCBmb3IgdGhlIGV4ZWN1dG9yIGFuZCBhbnlvbmUgcmVwb3J0aW5nIGFib3V0IGl0 cworICogYWN0aXZpdGllcyAoZS5nLiBFWFBMQUlOIEFOQUxZWkUpLgogICovCiB0eXBlZGVmIHN0 cnVjdCBOb2RlSW5zdHJ1bWVudGF0aW9uCiB7CkBAIC0xMTEsNiArMTc1LDEwIEBAIHR5cGVkZWYg c3RydWN0IE5vZGVJbnN0cnVtZW50YXRpb24KIAlkb3VibGUJCW5maWx0ZXJlZDI7CQkvKiAjIG9m IHR1cGxlcyByZW1vdmVkIGJ5ICJvdGhlciIgcXVhbHMgKi8KIH0gTm9kZUluc3RydW1lbnRhdGlv bjsKIAorLyoKKyAqIENhcmUgbXVzdCBiZSB0YWtlbiB3aXRoIGFueSBwb2ludGVycyBjb250YWlu ZWQgd2l0aGluIHRoaXMgc3RydWN0LCBhcyB0aGlzCisgKiBnZXRzIGNvcGllZCBhY3Jvc3MgcHJv Y2Vzc2VzIGR1cmluZyBwYXJhbGxlbCBxdWVyeSBleGVjdXRpb24uCisgKi8KIHR5cGVkZWYgc3Ry dWN0IFdvcmtlck5vZGVJbnN0cnVtZW50YXRpb24KIHsKIAlpbnQJCQludW1fd29ya2VyczsJLyog IyBvZiBzdHJ1Y3R1cmVzIHRoYXQgZm9sbG93ICovCkBAIC0xMjQsMTYgKzE5MiwxMDQgQEAgdHlw ZWRlZiBzdHJ1Y3QgVHJpZ2dlckluc3RydW1lbnRhdGlvbgogCQkJCQkJCQkgKiB3YXMgZmlyZWQg Ki8KIH0gVHJpZ2dlckluc3RydW1lbnRhdGlvbjsKIAotZXh0ZXJuIFBHRExMSU1QT1JUIEJ1ZmZl clVzYWdlIHBnQnVmZmVyVXNhZ2U7CisvKgorICogRHluYW1pYyBhcnJheS1iYXNlZCBzdGFjayBm b3IgdHJhY2tpbmcgY3VycmVudCBXQUwvYnVmZmVyIHVzYWdlIGNvbnRleHQuCisgKgorICogV2hl biB0aGUgc3RhY2sgaXMgZW1wdHksICdjdXJyZW50JyBwb2ludHMgdG8gaW5zdHJfdG9wIHdoaWNo IGFjY3VtdWxhdGVzCisgKiBzZXNzaW9uLWxldmVsIHRvdGFscy4KKyAqLwordHlwZWRlZiBzdHJ1 Y3QgSW5zdHJTdGFja1N0YXRlCit7CisJaW50CQkJc3RhY2tfc3BhY2U7CS8qIGFsbG9jYXRlZCBj YXBhY2l0eSBvZiBlbnRyaWVzIGFycmF5ICovCisJaW50CQkJc3RhY2tfc2l6ZTsJCS8qIGN1cnJl bnQgbnVtYmVyIG9mIGVudHJpZXMgKi8KKworCUluc3RydW1lbnRhdGlvbiAqKmVudHJpZXM7CS8q IGR5bmFtaWMgYXJyYXkgb2YgcG9pbnRlcnMgKi8KKwlJbnN0cnVtZW50YXRpb24gKmN1cnJlbnQ7 CS8qIHRvcCBvZiBzdGFjaywgb3IgJmluc3RyX3RvcCB3aGVuIGVtcHR5ICovCit9IEluc3RyU3Rh Y2tTdGF0ZTsKKwogZXh0ZXJuIFBHRExMSU1QT1JUIFdhbFVzYWdlIHBnV2FsVXNhZ2U7CiAKLWV4 dGVybiBJbnN0cnVtZW50YXRpb24gKkluc3RyQWxsb2MoaW50IGluc3RydW1lbnRfb3B0aW9ucyk7 CisvKgorICogVGhlIHRvcCBpbnN0cnVtZW50YXRpb24gcmVwcmVzZW50cyBhIHJ1bm5pbmcgdG90 YWwgb2YgdGhlIGN1cnJlbnQgYmFja2VuZAorICogV0FML2J1ZmZlciB1c2FnZSBpbmZvcm1hdGlv bi4gVGhpcyB3aWxsIG5vdCBiZSB1cGRhdGVkIGltbWVkaWF0ZWx5LCBidXQKKyAqIHJhdGhlciB3 aGVuIHRoZSBjdXJyZW50IHN0YWNrIGVudHJ5IGdldHMgYWNjdW11bGF0ZWQgd2hpY2ggdHlwaWNh bGx5IGhhcHBlbnMKKyAqIGF0IHF1ZXJ5IGVuZC4KKyAqCisgKiBDYXJlIG11c3QgYmUgdGFrZW4g d2hlbiB1dGlsaXppbmcgdGhpcyBpbiB0aGUgcGFyYWxsZWwgd29ya2VyIGNvbnRleHQ6CisgKiBQ YXJhbGxlbCB3b3JrZXJzIHdpbGwgcmVwb3J0IGJhY2sgdGhlaXIgaW5zdHJ1bWVudGF0aW9uIHRv IHRoZSBjYWxsZXIsCisgKiBhbmQgdGhpcyBnZXRzIGFkZGVkIHRvIHRoZSBjYWxsZXIncyBzdGFj ay4gSWYgdGhpcyB3ZXJlIHRvIGJlIHVzZWQgaW4gdGhlCisgKiBzaGFyZWQgbWVtb3J5IHN0YXRz IGluZnJhc3RydWN0dXJlIGl0IHdvdWxkIG5lZWQgdG8gYmUgc2tpcHBlZCBvbiBwYXJhbGxlbAor ICogd29ya2VycyB0byBhdm9pZCBkb3VibGUgY291bnRpbmcuCisgKi8KK2V4dGVybiBQR0RMTElN UE9SVCBJbnN0cnVtZW50YXRpb24gaW5zdHJfdG9wOworCisvKgorICogVGhlIGluc3RydW1lbnRh dGlvbiBzdGFjayBzdGF0ZS4gVGhlICdjdXJyZW50JyBmaWVsZCBwb2ludHMgdG8gdGhlCisgKiBj dXJyZW50bHkgYWN0aXZlIHN0YWNrIGVudHJ5IHRoYXQgaXMgZ2V0dGluZyB1cGRhdGVkIGFzIGFj dGl2aXR5IGhhcHBlbnMsCisgKiBhbmQgd2lsbCBiZSBhY2N1bXVsYXRlZCB0byBwYXJlbnQgc3Rh Y2tzIHdoZW4gaXQgZ2V0cyBmaW5hbGl6ZWQgYnkKKyAqIEluc3RyU3RvcCAoZm9yIG5vbi1leGVj dXRvciB1c2UgY2FzZXMpLCBFeGVjRmluYWxpemVOb2RlSW5zdHJ1bWVudGF0aW9uCisgKiAoZXhl Y3V0b3IgZmluaXNoKSBvciBSZXNPd25lclJlbGVhc2VJbnN0cnVtZW50YXRpb24gb24gYWJvcnQu CisgKi8KK2V4dGVybiBQR0RMTElNUE9SVCBJbnN0clN0YWNrU3RhdGUgaW5zdHJfc3RhY2s7CisK K2V4dGVybiB2b2lkIEluc3RyU3RhY2tHcm93KHZvaWQpOworCisvKgorICogUHVzaGVzIHRoZSBz dGFjayBzbyB0aGF0IGFsbCBXQUwvYnVmZmVyIHVzYWdlIHVwZGF0ZXMgZ28gdG8gdGhlIHBhc3Nl ZCBpbgorICogaW5zdHJ1bWVudGF0aW9uIGVudHJ5LgorICoKKyAqIFNlZSBub3RlIG9uIEluc3Ry UG9wU3RhY2sgcmVnYXJkaW5nIHNhZmUgdXNlIG9mIHRoZXNlIGZ1bmN0aW9ucy4KKyAqLworc3Rh dGljIGlubGluZSB2b2lkCitJbnN0clB1c2hTdGFjayhJbnN0cnVtZW50YXRpb24gKmluc3RyKQor eworCWlmICh1bmxpa2VseShpbnN0cl9zdGFjay5zdGFja19zaXplID09IGluc3RyX3N0YWNrLnN0 YWNrX3NwYWNlKSkKKwkJSW5zdHJTdGFja0dyb3coKTsKKworCWluc3RyX3N0YWNrLmVudHJpZXNb aW5zdHJfc3RhY2suc3RhY2tfc2l6ZSsrXSA9IGluc3RyOworCWluc3RyX3N0YWNrLmN1cnJlbnQg PSBpbnN0cjsKKwlpbnN0ci0+b25fc3RhY2sgPSB0cnVlOworfQorCisvKgorICogUG9wcyB0aGUg c3RhY2sgZW50cnkgYmFjayB0byB0aGUgcHJldmlvdXMgb25lIHRoYXQgd2FzIGVmZmVjdGl2ZSBh dAorICogSW5zdHJQdXNoU3RhY2suCisgKgorICogQ2FsbGVycyBtdXN0IGVuc3VyZSB0aGF0IG5v IGludGVybWVkaWF0ZSBzdGFjayBlbnRyaWVzIGFyZSBza2lwcGVkLCB0bworICogaGFuZGxlIGFi b3J0cyBjb3JyZWN0bHkuIElmIHlvdSdyZSB0aGlua2luZyBvZiBjYWxsaW5nIHRoaXMgaW4gYSBQ R19GSU5BTExZCisgKiBibG9jaywgY29uc2lkZXIgaW5zdGVhZCB1c2luZyBJbnN0clN0YXJ0ICsg SW5zdHJTdG9wRmluYWxpemUgd2hpY2ggY2FuIHNraXAKKyAqIGludGVybWVkaWF0ZSBzdGFjayBl bnRyaWVzLgorICovCitzdGF0aWMgaW5saW5lIHZvaWQKK0luc3RyUG9wU3RhY2soSW5zdHJ1bWVu dGF0aW9uICppbnN0cikKK3sKKwlBc3NlcnQoaW5zdHJfc3RhY2suc3RhY2tfc2l6ZSA+IDApOwor CUFzc2VydChpbnN0cl9zdGFjay5lbnRyaWVzW2luc3RyX3N0YWNrLnN0YWNrX3NpemUgLSAxXSA9 PSBpbnN0cik7CisJaW5zdHJfc3RhY2suc3RhY2tfc2l6ZS0tOworCWluc3RyX3N0YWNrLmN1cnJl bnQgPSBpbnN0cl9zdGFjay5zdGFja19zaXplID4gMAorCQk/IGluc3RyX3N0YWNrLmVudHJpZXNb aW5zdHJfc3RhY2suc3RhY2tfc2l6ZSAtIDFdCisJCTogJmluc3RyX3RvcDsKKwlpbnN0ci0+b25f c3RhY2sgPSBmYWxzZTsKK30KKwogZXh0ZXJuIHZvaWQgSW5zdHJJbml0T3B0aW9ucyhJbnN0cnVt ZW50YXRpb24gKmluc3RyLCBpbnQgaW5zdHJ1bWVudF9vcHRpb25zKTsKIGV4dGVybiB2b2lkIElu c3RyU3RhcnQoSW5zdHJ1bWVudGF0aW9uICppbnN0cik7CiBleHRlcm4gdm9pZCBJbnN0clN0b3Ao SW5zdHJ1bWVudGF0aW9uICppbnN0cik7CitleHRlcm4gdm9pZCBJbnN0clN0b3BGaW5hbGl6ZShJ bnN0cnVtZW50YXRpb24gKmluc3RyKTsKK2V4dGVybiB2b2lkIEluc3RyRmluYWxpemVDaGlsZChJ bnN0cnVtZW50YXRpb24gKmluc3RyLCBJbnN0cnVtZW50YXRpb24gKnBhcmVudCk7CitleHRlcm4g dm9pZCBJbnN0ckFjY3VtU3RhY2soSW5zdHJ1bWVudGF0aW9uICpkc3QsIEluc3RydW1lbnRhdGlv biAqYWRkKTsKIAotZXh0ZXJuIE5vZGVJbnN0cnVtZW50YXRpb24gKkluc3RyQWxsb2NOb2RlKGlu dCBpbnN0cnVtZW50X29wdGlvbnMsCi0JCQkJCQkJCQkJICAgYm9vbCBhc3luY19tb2RlKTsKK2V4 dGVybiBRdWVyeUluc3RydW1lbnRhdGlvbiAqSW5zdHJRdWVyeUFsbG9jKGludCBpbnN0cnVtZW50 X29wdGlvbnMpOworZXh0ZXJuIHZvaWQgSW5zdHJRdWVyeVN0YXJ0KFF1ZXJ5SW5zdHJ1bWVudGF0 aW9uICppbnN0cik7CitleHRlcm4gdm9pZCBJbnN0clF1ZXJ5U3RvcChRdWVyeUluc3RydW1lbnRh dGlvbiAqaW5zdHIpOworZXh0ZXJuIHZvaWQgSW5zdHJRdWVyeVN0b3BGaW5hbGl6ZShRdWVyeUlu c3RydW1lbnRhdGlvbiAqaW5zdHIpOworZXh0ZXJuIHZvaWQgSW5zdHJRdWVyeVJlbWVtYmVyQ2hp bGQoUXVlcnlJbnN0cnVtZW50YXRpb24gKnBhcmVudCwgSW5zdHJ1bWVudGF0aW9uICppbnN0cik7 CisKK3BnX25vZGlzY2FyZCBleHRlcm4gUXVlcnlJbnN0cnVtZW50YXRpb24gKkluc3RyU3RhcnRQ YXJhbGxlbFF1ZXJ5KHZvaWQpOworZXh0ZXJuIHZvaWQgSW5zdHJFbmRQYXJhbGxlbFF1ZXJ5KFF1 ZXJ5SW5zdHJ1bWVudGF0aW9uICpxaW5zdHIsIEJ1ZmZlclVzYWdlICpidWZ1c2FnZSwgV2FsVXNh Z2UgKndhbHVzYWdlKTsKK2V4dGVybiB2b2lkIEluc3RyQWNjdW1QYXJhbGxlbFF1ZXJ5KEJ1ZmZl clVzYWdlICpidWZ1c2FnZSwgV2FsVXNhZ2UgKndhbHVzYWdlKTsKKworZXh0ZXJuIE5vZGVJbnN0 cnVtZW50YXRpb24gKkluc3RyQWxsb2NOb2RlKFF1ZXJ5SW5zdHJ1bWVudGF0aW9uICpxaW5zdHIs IGJvb2wgYXN5bmNfbW9kZSk7CiBleHRlcm4gdm9pZCBJbnN0ckluaXROb2RlKE5vZGVJbnN0cnVt ZW50YXRpb24gKmluc3RyLCBpbnQgaW5zdHJ1bWVudF9vcHRpb25zKTsKIGV4dGVybiB2b2lkIElu c3RyU3RhcnROb2RlKE5vZGVJbnN0cnVtZW50YXRpb24gKmluc3RyKTsKIGV4dGVybiB2b2lkIElu c3RyU3RvcE5vZGUoTm9kZUluc3RydW1lbnRhdGlvbiAqaW5zdHIsIGRvdWJsZSBuVHVwbGVzKTsK QEAgLTE0MSwzNSArMjk3LDM2IEBAIGV4dGVybiB2b2lkIEluc3RyVXBkYXRlVHVwbGVDb3VudChO b2RlSW5zdHJ1bWVudGF0aW9uICppbnN0ciwgZG91YmxlIG5UdXBsZXMpOwogZXh0ZXJuIHZvaWQg SW5zdHJFbmRMb29wKE5vZGVJbnN0cnVtZW50YXRpb24gKmluc3RyKTsKIGV4dGVybiB2b2lkIElu c3RyQWdnTm9kZShOb2RlSW5zdHJ1bWVudGF0aW9uICpkc3QsIE5vZGVJbnN0cnVtZW50YXRpb24g KmFkZCk7CiAKLWV4dGVybiBUcmlnZ2VySW5zdHJ1bWVudGF0aW9uICpJbnN0ckFsbG9jVHJpZ2dl cihpbnQgbiwgaW50IGluc3RydW1lbnRfb3B0aW9ucyk7Ci1leHRlcm4gdm9pZCBJbnN0clN0YXJ0 VHJpZ2dlcihUcmlnZ2VySW5zdHJ1bWVudGF0aW9uICp0Z2luc3RyKTsKK2V4dGVybiBUcmlnZ2Vy SW5zdHJ1bWVudGF0aW9uICpJbnN0ckFsbG9jVHJpZ2dlcihRdWVyeUluc3RydW1lbnRhdGlvbiAq cWluc3RyLCBpbnQgbik7CitleHRlcm4gdm9pZCBJbnN0clN0YXJ0VHJpZ2dlcihRdWVyeUluc3Ry dW1lbnRhdGlvbiAqcWluc3RyLAorCQkJCQkJCSAgVHJpZ2dlckluc3RydW1lbnRhdGlvbiAqdGdp bnN0cik7CiBleHRlcm4gdm9pZCBJbnN0clN0b3BUcmlnZ2VyKFRyaWdnZXJJbnN0cnVtZW50YXRp b24gKnRnaW5zdHIsIGludCBmaXJpbmdzKTsKIAotZXh0ZXJuIHZvaWQgSW5zdHJTdGFydFBhcmFs bGVsUXVlcnkodm9pZCk7Ci1leHRlcm4gdm9pZCBJbnN0ckVuZFBhcmFsbGVsUXVlcnkoQnVmZmVy VXNhZ2UgKmJ1ZnVzYWdlLCBXYWxVc2FnZSAqd2FsdXNhZ2UpOwotZXh0ZXJuIHZvaWQgSW5zdHJB Y2N1bVBhcmFsbGVsUXVlcnkoQnVmZmVyVXNhZ2UgKmJ1ZnVzYWdlLCBXYWxVc2FnZSAqd2FsdXNh Z2UpOwotZXh0ZXJuIHZvaWQgQnVmZmVyVXNhZ2VBY2N1bURpZmYoQnVmZmVyVXNhZ2UgKmRzdCwK LQkJCQkJCQkJIGNvbnN0IEJ1ZmZlclVzYWdlICphZGQsIGNvbnN0IEJ1ZmZlclVzYWdlICpzdWIp OworZXh0ZXJuIHZvaWQgQnVmZmVyVXNhZ2VBZGQoQnVmZmVyVXNhZ2UgKmRzdCwgY29uc3QgQnVm ZmVyVXNhZ2UgKmFkZCk7CitleHRlcm4gdm9pZCBXYWxVc2FnZUFkZChXYWxVc2FnZSAqZHN0LCBj b25zdCBXYWxVc2FnZSAqYWRkKTsKIGV4dGVybiB2b2lkIFdhbFVzYWdlQWNjdW1EaWZmKFdhbFVz YWdlICpkc3QsIGNvbnN0IFdhbFVzYWdlICphZGQsCiAJCQkJCQkJICBjb25zdCBXYWxVc2FnZSAq c3ViKTsKIAogI2RlZmluZSBJTlNUUl9CVUZVU0FHRV9JTkNSKGZsZCkgZG8geyBcCi0JCXBnQnVm ZmVyVXNhZ2UuZmxkKys7IFwKKwkJaW5zdHJfc3RhY2suY3VycmVudC0+YnVmdXNhZ2UuZmxkKys7 IFwKIAl9IHdoaWxlKDApCiAjZGVmaW5lIElOU1RSX0JVRlVTQUdFX0FERChmbGQsdmFsKSBkbyB7 IFwKLQkJcGdCdWZmZXJVc2FnZS5mbGQgKz0gKHZhbCk7IFwKKwkJaW5zdHJfc3RhY2suY3VycmVu dC0+YnVmdXNhZ2UuZmxkICs9ICh2YWwpOyBcCiAJfSB3aGlsZSgwKQogI2RlZmluZSBJTlNUUl9C VUZVU0FHRV9USU1FX0FERChmbGQsdmFsKSBkbyB7IFwKLQlJTlNUUl9USU1FX0FERChwZ0J1ZmZl clVzYWdlLmZsZCwgdmFsKTsgXAorCUlOU1RSX1RJTUVfQUREKGluc3RyX3N0YWNrLmN1cnJlbnQt PmJ1ZnVzYWdlLmZsZCwgdmFsKTsgXAogCX0gd2hpbGUgKDApCiAjZGVmaW5lIElOU1RSX0JVRlVT QUdFX1RJTUVfQUNDVU1fRElGRihmbGQsZW5kdmFsLHN0YXJ0dmFsKSBkbyB7IFwKLQlJTlNUUl9U SU1FX0FDQ1VNX0RJRkYocGdCdWZmZXJVc2FnZS5mbGQsIGVuZHZhbCwgc3RhcnR2YWwpOyBcCisJ SU5TVFJfVElNRV9BQ0NVTV9ESUZGKGluc3RyX3N0YWNrLmN1cnJlbnQtPmJ1ZnVzYWdlLmZsZCwg ZW5kdmFsLCBzdGFydHZhbCk7IFwKIAl9IHdoaWxlICgwKQorCiAjZGVmaW5lIElOU1RSX1dBTFVT QUdFX0lOQ1IoZmxkKSBkbyB7IFwKIAkJcGdXYWxVc2FnZS5mbGQrKzsgXAorCQlpbnN0cl9zdGFj ay5jdXJyZW50LT53YWx1c2FnZS5mbGQrKzsgXAogCX0gd2hpbGUoMCkKICNkZWZpbmUgSU5TVFJf V0FMVVNBR0VfQUREKGZsZCx2YWwpIGRvIHsgXAogCQlwZ1dhbFVzYWdlLmZsZCArPSAodmFsKTsg XAorCQlpbnN0cl9zdGFjay5jdXJyZW50LT53YWx1c2FnZS5mbGQgKz0gKHZhbCk7IFwKIAl9IHdo aWxlKDApCiAKICNlbmRpZgkJCQkJCQkvKiBJTlNUUlVNRU5UX0ggKi8KZGlmZiAtLWdpdCBhL3Ny Yy9pbmNsdWRlL25vZGVzL2V4ZWNub2Rlcy5oIGIvc3JjL2luY2x1ZGUvbm9kZXMvZXhlY25vZGVz LmgKaW5kZXggM2VjYWU3NTUyZmMuLmIyODI4OGFhMWU4IDEwMDY0NAotLS0gYS9zcmMvaW5jbHVk ZS9ub2Rlcy9leGVjbm9kZXMuaAorKysgYi9zcmMvaW5jbHVkZS9ub2Rlcy9leGVjbm9kZXMuaApA QCAtNTQsNiArNTQsNyBAQCB0eXBlZGVmIHN0cnVjdCBJbnN0cnVtZW50YXRpb24gSW5zdHJ1bWVu dGF0aW9uOwogdHlwZWRlZiBzdHJ1Y3QgcGFpcmluZ2hlYXAgcGFpcmluZ2hlYXA7CiB0eXBlZGVm IHN0cnVjdCBQbGFuU3RhdGUgUGxhblN0YXRlOwogdHlwZWRlZiBzdHJ1Y3QgUXVlcnlFbnZpcm9u bWVudCBRdWVyeUVudmlyb25tZW50OwordHlwZWRlZiBzdHJ1Y3QgUXVlcnlJbnN0cnVtZW50YXRp b24gUXVlcnlJbnN0cnVtZW50YXRpb247CiB0eXBlZGVmIHN0cnVjdCBSZWxhdGlvbkRhdGEgKlJl bGF0aW9uOwogdHlwZWRlZiBSZWxhdGlvbiAqUmVsYXRpb25QdHI7CiB0eXBlZGVmIHN0cnVjdCBT Y2FuS2V5RGF0YSBTY2FuS2V5RGF0YTsKQEAgLTc1Myw3ICs3NTQsNyBAQCB0eXBlZGVmIHN0cnVj dCBFU3RhdGUKIAkJCQkJCQkJCSAqIEV4ZWN1dG9yUnVuKCkgY2FsbHMuICovCiAKIAlpbnQJCQll c190b3BfZWZsYWdzOwkvKiBlZmxhZ3MgcGFzc2VkIHRvIEV4ZWN1dG9yU3RhcnQgKi8KLQlpbnQJ CQllc19pbnN0cnVtZW50OwkvKiBPUiBvZiBJbnN0cnVtZW50T3B0aW9uIGZsYWdzICovCisJUXVl cnlJbnN0cnVtZW50YXRpb24gKmVzX2luc3RydW1lbnQ7CS8qIHF1ZXJ5LWxldmVsIGluc3RydW1l bnRhdGlvbiAqLwogCWJvb2wJCWVzX2ZpbmlzaGVkOwkvKiB0cnVlIHdoZW4gRXhlY3V0b3JGaW5p c2ggaXMgZG9uZSAqLwogCiAJTGlzdAkgICAqZXNfZXhwcmNvbnRleHRzOwkvKiBMaXN0IG9mIEV4 cHJDb250ZXh0cyB3aXRoaW4gRVN0YXRlICovCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS91dGls cy9yZXNvd25lci5oIGIvc3JjL2luY2x1ZGUvdXRpbHMvcmVzb3duZXIuaAppbmRleCBlYjYwMzNi NGZkYi4uNTQ2M2JjOTIxZjAgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL3V0aWxzL3Jlc293bmVy LmgKKysrIGIvc3JjL2luY2x1ZGUvdXRpbHMvcmVzb3duZXIuaApAQCAtNzUsNiArNzUsNyBAQCB0 eXBlZGVmIHVpbnQzMiBSZXNvdXJjZVJlbGVhc2VQcmlvcml0eTsKICNkZWZpbmUgUkVMRUFTRV9Q UklPX1NOQVBTSE9UX1JFRlMJCQk1MDAKICNkZWZpbmUgUkVMRUFTRV9QUklPX0ZJTEVTCQkJCQk2 MDAKICNkZWZpbmUgUkVMRUFTRV9QUklPX1dBSVRFVkVOVFNFVFMJCQk3MDAKKyNkZWZpbmUgUkVM RUFTRV9QUklPX0lOU1RSVU1FTlRBVElPTgkJODAwCiAKIC8qIDAgaXMgY29uc2lkZXJlZCBpbnZh bGlkICovCiAjZGVmaW5lIFJFTEVBU0VfUFJJT19GSVJTVAkJCQkJMQpkaWZmIC0tZ2l0IGEvc3Jj L3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZzLmxpc3QgYi9zcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRl ZnMubGlzdAppbmRleCA0NDlhY2NhOGRjMS4uNzM5MzkyNmUzNGQgMTAwNjQ0Ci0tLSBhL3NyYy90 b29scy9wZ2luZGVudC90eXBlZGVmcy5saXN0CisrKyBiL3NyYy90b29scy9wZ2luZGVudC90eXBl ZGVmcy5saXN0CkBAIC0xMzU1LDYgKzEzNTUsNyBAQCBJbmplY3Rpb25Qb2ludFNoYXJlZFN0YXRl CiBJbmplY3Rpb25Qb2ludHNDdGwKIElubGluZUNvZGVCbG9jawogSW5zZXJ0U3RtdAorSW5zdHJT dGFja1N0YXRlCiBJbnN0cnVtZW50YXRpb24KIEludDEyOEFnZ1N0YXRlCiBJbnQ4VHJhbnNUeXBl RGF0YQpAQCAtMjQ3Nyw2ICsyNDc4LDcgQEAgUXVlcnlDb21wbGV0aW9uCiBRdWVyeURlc2MKIFF1 ZXJ5RW52aXJvbm1lbnQKIFF1ZXJ5SW5mbworUXVlcnlJbnN0cnVtZW50YXRpb24KIFF1ZXJ5SXRl bQogUXVlcnlJdGVtVHlwZQogUXVlcnlNb2RlCi0tIAoyLjQ3LjEKCg== --0000000000006d0cb0064eb5be7d Content-Type: application/octet-stream; name="v13-0010-instrumentation-Optimize-ExecProcNodeInstr-instr.patch" Content-Disposition: attachment; filename="v13-0010-instrumentation-Optimize-ExecProcNodeInstr-instr.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mnlqag7u9 RnJvbSBkNTFlZDVhNWViZmU4MzExNmE0YTc0MGJhM2I5ZDNmNDk2ODdmMjI2IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBMdWthcyBGaXR0bCA8bHVrYXNAZml0dGwuY29tPgpEYXRlOiBT YXQsIDcgTWFyIDIwMjYgMTc6NTI6MjQgLTA4MDAKU3ViamVjdDogW1BBVENIIHYxMyAxMC8xMl0g aW5zdHJ1bWVudGF0aW9uOiBPcHRpbWl6ZSBFeGVjUHJvY05vZGVJbnN0cgogaW5zdHJ1Y3Rpb25z IGJ5IGlubGluaW5nCgpGb3IgbW9zdCBxdWVyaWVzLCB0aGUgYnVsayBvZiB0aGUgb3ZlcmhlYWQg b2YgRVhQTEFJTiBBTkFMWVpFIGhhcHBlbnMgaW4KRXhlY1Byb2NOb2RlSW5zdHIgd2hlbiBzdGFy dGluZy9zdG9wcGluZyBpbnN0cnVtZW50YXRpb24gZm9yIHRoYXQgbm9kZS4KClByZXZpb3VzbHkg ZWFjaCBFeGVjUHJvY05vZGVJbnN0ciB3b3VsZCBjaGVjayB3aGljaCBpbnN0cnVtZW50YXRpb24K b3B0aW9ucyBhcmUgYWN0aXZlIGluIHRoZSBJbnN0clN0YXJ0Tm9kZS9JbnN0clN0b3BOb2RlIGNh bGxzLCBhbmQgZG8gdGhlCmNvcnJlc3BvbmRpbmcgd29yayAodGltZXJzLCBpbnN0cnVtZW50YXRp b24gc3RhY2ssIGV0Yy4pLiBUaGVzZQpjb25kaXRpb25hbHMgYmVpbmcgY2hlY2tlZCBmb3IgZWFj aCB0dXBsZSBiZWluZyBlbWl0dGVkIGFkZCB1cCwgYW5kIGNhdXNlCm5vbi1vcHRpbWFsIHNldCBv ZiBpbnN0cnVjdGlvbnMgdG8gYmUgZ2VuZXJhdGVkIGJ5IHRoZSBjb21waWxlci4KCkJlY2F1c2Ug d2UgYWxyZWFkeSBoYXZlIGFuIGV4aXN0aW5nIG1lY2hhbmlzbSB0byBzcGVjaWZ5IGEgZnVuY3Rp b24KcG9pbnRlciB3aGVuIGluc3RydW1lbnRhdGlvbiBpcyBlbmFibGVkLCB3ZSBjYW4gaW5zdGVh ZCBjcmVhdGUgc3BlY2lhbGl6ZWQKZnVuY3Rpb25zIHRoYXQgYXJlIHRhaWxvcmVkIHRvIHRoZSBp bnN0cnVtZW50YXRpb24gb3B0aW9ucyBlbmFibGVkLCBhbmQKYXZvaWQgY29uZGl0aW9uYWxzIG9u IHN1YnNlcXVlbnQgRXhlY1Byb2NOb2RlSW5zdHIgY2FsbHMuIFRoaXMgcmVzdWx0cyBpbgp0aGUg b3ZlcmhlYWQgZm9yIEVYUExBSU4gKEFOQUxZWkUsIFRJTUlORyBPRkYsIEJVRkZFUlMgT0ZGKSBm b3IgYSBzdHJlc3MKdGVzdCB3aXRoIGEgbGFyZ2UgQ09VTlQoKikgdGhhdCBkb2VzIG1hbnkgRXhl Y1Byb2NOb2RlIGNhbGxzIGZyb20gfiAyMCUgb24KdG9wIG9mIGFjdHVhbCBydW50aW1lIHRvIH4g MyUuIFdoZW4gdXNpbmcgQlVGRkVSUyBPTiB0aGUgc2FtZSBxdWVyeSBnb2VzCmZyb20gfiAyMCUg dG8gfiAxMCUgb24gdG9wIG9mIGFjdHVhbCBydW50aW1lLgoKQXV0aG9yOiBMdWthcyBGaXR0bCA8 bHVrYXNAZml0dGwuY29tPgpSZXZpZXdlZC1ieTogWnNvbHQgUGFycmFnaSA8enNvbHQucGFycmFn aUBwZXJjb25hLmNvbT4KRGlzY3Vzc2lvbjogaHR0cHM6Ly93d3cucG9zdGdyZXNxbC5vcmcvbWVz c2FnZS1pZC9mbGF0L0NBUDUzUGt4RlA3aTctd3k5OFptRUoxMWVkWXEtUnJQdkpvYTRrekdoQkJq RVJBNE55dyU0MG1haWwuZ21haWwuY29tI2U4ZGZkMDE4YTA3ZDdmOGQ0MTU2NWEwNzlkNDBjNTY0 Ci0tLQogc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY1Byb2Nub2RlLmMgfCAgMjIgKy0tCiBzcmMv YmFja2VuZC9leGVjdXRvci9pbnN0cnVtZW50LmMgICB8IDE5OSArKysrKysrKysrKysrKysrKysr Ky0tLS0tLS0tCiBzcmMvaW5jbHVkZS9leGVjdXRvci9pbnN0cnVtZW50LmggICB8ICAgNSArCiAz IGZpbGVzIGNoYW5nZWQsIDE0OSBpbnNlcnRpb25zKCspLCA3NyBkZWxldGlvbnMoLSkKCmRpZmYg LS1naXQgYS9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjUHJvY25vZGUuYyBiL3NyYy9iYWNrZW5k L2V4ZWN1dG9yL2V4ZWNQcm9jbm9kZS5jCmluZGV4IDNiM2VjOTg1MGU4Li42ZThjYmFlY2NmNyAx MDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY1Byb2Nub2RlLmMKKysrIGIvc3Jj L2JhY2tlbmQvZXhlY3V0b3IvZXhlY1Byb2Nub2RlLmMKQEAgLTEyMSw3ICsxMjEsNiBAQAogI2lu Y2x1ZGUgIm5vZGVzL25vZGVGdW5jcy5oIgogCiBzdGF0aWMgVHVwbGVUYWJsZVNsb3QgKkV4ZWNQ cm9jTm9kZUZpcnN0KFBsYW5TdGF0ZSAqbm9kZSk7Ci1zdGF0aWMgVHVwbGVUYWJsZVNsb3QgKkV4 ZWNQcm9jTm9kZUluc3RyKFBsYW5TdGF0ZSAqbm9kZSk7CiBzdGF0aWMgYm9vbCBFeGVjU2h1dGRv d25Ob2RlX3dhbGtlcihQbGFuU3RhdGUgKm5vZGUsIHZvaWQgKmNvbnRleHQpOwogc3RhdGljIGJv b2wgRXhlY0ZpbmFsaXplTm9kZUluc3RydW1lbnRhdGlvbl93YWxrZXIoUGxhblN0YXRlICpub2Rl LCB2b2lkICpjb250ZXh0KTsKIHN0YXRpYyBib29sIEV4ZWNGaW5hbGl6ZVdvcmtlckluc3RydW1l bnRhdGlvbl93YWxrZXIoUGxhblN0YXRlICpub2RlLCB2b2lkICpjb250ZXh0KTsKQEAgLTQ2NSw3 ICs0NjQsNyBAQCBFeGVjUHJvY05vZGVGaXJzdChQbGFuU3RhdGUgKm5vZGUpCiAJICogaGF2ZSBF eGVjUHJvY05vZGUoKSBkaXJlY3RseSBjYWxsIHRoZSByZWxldmFudCBmdW5jdGlvbiBmcm9tIG5v dyBvbi4KIAkgKi8KIAlpZiAobm9kZS0+aW5zdHJ1bWVudCkKLQkJbm9kZS0+RXhlY1Byb2NOb2Rl ID0gRXhlY1Byb2NOb2RlSW5zdHI7CisJCW5vZGUtPkV4ZWNQcm9jTm9kZSA9IEluc3RyTm9kZVNl dHVwRXhlY1Byb2NOb2RlKG5vZGUtPmluc3RydW1lbnQpOwogCWVsc2UKIAkJbm9kZS0+RXhlY1By b2NOb2RlID0gbm9kZS0+RXhlY1Byb2NOb2RlUmVhbDsKIApAQCAtNDczLDI1ICs0NzIsNiBAQCBF eGVjUHJvY05vZGVGaXJzdChQbGFuU3RhdGUgKm5vZGUpCiB9CiAKIAotLyoKLSAqIEV4ZWNQcm9j Tm9kZSB3cmFwcGVyIHRoYXQgcGVyZm9ybXMgaW5zdHJ1bWVudGF0aW9uIGNhbGxzLiAgQnkga2Vl cGluZwotICogdGhpcyBhIHNlcGFyYXRlIGZ1bmN0aW9uLCB3ZSBhdm9pZCBvdmVyaGVhZCBpbiB0 aGUgbm9ybWFsIGNhc2Ugd2hlcmUKLSAqIG5vIGluc3RydW1lbnRhdGlvbiBpcyB3YW50ZWQuCi0g Ki8KLXN0YXRpYyBUdXBsZVRhYmxlU2xvdCAqCi1FeGVjUHJvY05vZGVJbnN0cihQbGFuU3RhdGUg Km5vZGUpCi17Ci0JVHVwbGVUYWJsZVNsb3QgKnJlc3VsdDsKLQotCUluc3RyU3RhcnROb2RlKG5v ZGUtPmluc3RydW1lbnQpOwotCi0JcmVzdWx0ID0gbm9kZS0+RXhlY1Byb2NOb2RlUmVhbChub2Rl KTsKLQotCUluc3RyU3RvcE5vZGUobm9kZS0+aW5zdHJ1bWVudCwgVHVwSXNOdWxsKHJlc3VsdCkg PyAwLjAgOiAxLjApOwotCi0JcmV0dXJuIHJlc3VsdDsKLX0KLQogCiAvKiAtLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgKgkJ TXVsdGlFeGVjUHJvY05vZGUKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2luc3Ry dW1lbnQuYyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2luc3RydW1lbnQuYwppbmRleCBhZjY0YWEx NDVlYi4uMzE4M2YwMGQ2OTMgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2luc3Ry dW1lbnQuYworKysgYi9zcmMvYmFja2VuZC9leGVjdXRvci9pbnN0cnVtZW50LmMKQEAgLTY2LDI5 ICs2NiwyMCBAQCBJbnN0ckluaXRPcHRpb25zKEluc3RydW1lbnRhdGlvbiAqaW5zdHIsIGludCBp bnN0cnVtZW50X29wdGlvbnMpCiAJaW5zdHItPm5lZWRfdGltZXIgPSAoaW5zdHJ1bWVudF9vcHRp b25zICYgSU5TVFJVTUVOVF9USU1FUikgIT0gMDsKIH0KIAotdm9pZAotSW5zdHJTdGFydChJbnN0 cnVtZW50YXRpb24gKmluc3RyKQorc3RhdGljIGlubGluZSB2b2lkCitJbnN0clN0YXJ0VGltZXIo SW5zdHJ1bWVudGF0aW9uICppbnN0cikKIHsKLQlpZiAoaW5zdHItPm5lZWRfdGltZXIpCi0Jewot CQlpZiAoIUlOU1RSX1RJTUVfSVNfWkVSTyhpbnN0ci0+c3RhcnR0aW1lKSkKLQkJCWVsb2coRVJS T1IsICJJbnN0clN0YXJ0IGNhbGxlZCB0d2ljZSBpbiBhIHJvdyIpOwotCQllbHNlCi0JCQlJTlNU Ul9USU1FX1NFVF9DVVJSRU5UKGluc3RyLT5zdGFydHRpbWUpOwotCX0KKwlBc3NlcnQoSU5TVFJf VElNRV9JU19aRVJPKGluc3RyLT5zdGFydHRpbWUpKTsKIAotCWlmIChpbnN0ci0+bmVlZF9zdGFj aykKLQkJSW5zdHJQdXNoU3RhY2soaW5zdHIpOworCUlOU1RSX1RJTUVfU0VUX0NVUlJFTlQoaW5z dHItPnN0YXJ0dGltZSk7CiB9CiAKLXN0YXRpYyB2b2lkCitzdGF0aWMgaW5saW5lIHZvaWQKIElu c3RyU3RvcFRpbWVyKEluc3RydW1lbnRhdGlvbiAqaW5zdHIpCiB7CiAJaW5zdHJfdGltZQllbmR0 aW1lOwogCi0JLyogbGV0J3MgdXBkYXRlIHRoZSB0aW1lIG9ubHkgaWYgdGhlIHRpbWVyIHdhcyBy ZXF1ZXN0ZWQgKi8KLQlpZiAoSU5TVFJfVElNRV9JU19aRVJPKGluc3RyLT5zdGFydHRpbWUpKQot CQllbG9nKEVSUk9SLCAiSW5zdHJTdG9wIGNhbGxlZCB3aXRob3V0IHN0YXJ0Iik7CisJQXNzZXJ0 KCFJTlNUUl9USU1FX0lTX1pFUk8oaW5zdHItPnN0YXJ0dGltZSkpOwogCiAJSU5TVFJfVElNRV9T RVRfQ1VSUkVOVChlbmR0aW1lKTsKIAlJTlNUUl9USU1FX0FDQ1VNX0RJRkYoaW5zdHItPnRvdGFs LCBlbmR0aW1lLCBpbnN0ci0+c3RhcnR0aW1lKTsKQEAgLTk2LDYgKzg3LDE2IEBAIEluc3RyU3Rv cFRpbWVyKEluc3RydW1lbnRhdGlvbiAqaW5zdHIpCiAJSU5TVFJfVElNRV9TRVRfWkVSTyhpbnN0 ci0+c3RhcnR0aW1lKTsKIH0KIAordm9pZAorSW5zdHJTdGFydChJbnN0cnVtZW50YXRpb24gKmlu c3RyKQoreworCWlmIChpbnN0ci0+bmVlZF90aW1lcikKKwkJSW5zdHJTdGFydFRpbWVyKGluc3Ry KTsKKworCWlmIChpbnN0ci0+bmVlZF9zdGFjaykKKwkJSW5zdHJQdXNoU3RhY2soaW5zdHIpOwor fQorCiB2b2lkCiBJbnN0clN0b3AoSW5zdHJ1bWVudGF0aW9uICppbnN0cikKIHsKQEAgLTM5MSw2 NSArMzkyLDU3IEBAIEluc3RySW5pdE5vZGUoTm9kZUluc3RydW1lbnRhdGlvbiAqaW5zdHIsIGlu dCBpbnN0cnVtZW50X29wdGlvbnMpCiAJSW5zdHJJbml0T3B0aW9ucygmaW5zdHItPmluc3RyLCBp bnN0cnVtZW50X29wdGlvbnMpOwogfQogCi0vKiBFbnRyeSB0byBhIHBsYW4gbm9kZSAqLworLyog RW50cnkgdG8gYSBwbGFuIG5vZGUuIElmIHlvdSBtb2RpZnkgdGhpcywgY2hlY2sgSW5zdHJOb2Rl U2V0dXBFeGVjUHJvY05vZGUuICovCiB2b2lkCiBJbnN0clN0YXJ0Tm9kZShOb2RlSW5zdHJ1bWVu dGF0aW9uICppbnN0cikKIHsKIAlJbnN0clN0YXJ0KCZpbnN0ci0+aW5zdHIpOwogfQogCi0KLS8q IEV4aXQgZnJvbSBhIHBsYW4gbm9kZSAqLwotdm9pZAotSW5zdHJTdG9wTm9kZShOb2RlSW5zdHJ1 bWVudGF0aW9uICppbnN0ciwgZG91YmxlIG5UdXBsZXMpCisvKgorICogVXBkYXRlcyB0aGUgbm9k ZSBpbnN0cnVtZW50YXRpb24gdGltZSBjb3VudGVyLgorICoKKyAqIE5vdGUgdGhpcyBpcyBkaWZm ZXJlbnQgZnJvbSBJbnN0clN0b3AgYmVjYXVzZSB0b3RhbCBpcyBvbmx5IHVwZGF0ZWQgaW4KKyAq IEluc3RyRW5kTG9vcC4gV2UgbmVlZCB0aGUgc2VwYXJhdGUgY291bnRlciB2YXJpYWJsZSBiZWNh dXNlIHdlIG5lZWQgdG8KKyAqIGNhbGN1bGF0ZSBzdGFydC11cCB0aW1lIGZvciB0aGUgZmlyc3Qg dHVwbGUgaW4gZWFjaCBjeWNsZSwgYW5kIHRoZW4KKyAqIGFjY3VtdWxhdGUgaXQgdG9nZXRoZXIu CisgKi8KK3N0YXRpYyBpbmxpbmUgdm9pZAorSW5zdHJTdG9wTm9kZVRpbWVyKE5vZGVJbnN0cnVt ZW50YXRpb24gKmluc3RyKQogewotCWRvdWJsZQkJc2F2ZV90dXBsZWNvdW50ID0gaW5zdHItPnR1 cGxlY291bnQ7CiAJaW5zdHJfdGltZQllbmR0aW1lOwogCi0JLyogY291bnQgdGhlIHJldHVybmVk IHR1cGxlcyAqLwotCWluc3RyLT50dXBsZWNvdW50ICs9IG5UdXBsZXM7CisJQXNzZXJ0KCFJTlNU Ul9USU1FX0lTX1pFUk8oaW5zdHItPmluc3RyLnN0YXJ0dGltZSkpOworCisJSU5TVFJfVElNRV9T RVRfQ1VSUkVOVChlbmR0aW1lKTsKKwlJTlNUUl9USU1FX0FDQ1VNX0RJRkYoaW5zdHItPmNvdW50 ZXIsIGVuZHRpbWUsIGluc3RyLT5pbnN0ci5zdGFydHRpbWUpOworCUlOU1RSX1RJTUVfU0VUX1pF Uk8oaW5zdHItPmluc3RyLnN0YXJ0dGltZSk7CiAKIAkvKgotCSAqIFVwZGF0ZSB0aGUgdGltZSBv bmx5IGlmIHRoZSB0aW1lciB3YXMgcmVxdWVzdGVkLgorCSAqIElzIHRoaXMgdGhlIGZpcnN0IHR1 cGxlIG9mIHRoaXMgY3ljbGU/CiAJICoKLQkgKiBOb3RlIHRoaXMgaXMgZGlmZmVyZW50IGZyb20g SW5zdHJTdG9wIGJlY2F1c2UgdG90YWwgaXMgb25seSB1cGRhdGVkIGluCi0JICogSW5zdHJFbmRM b29wLiBXZSBuZWVkIHRoZSBzZXBhcmF0ZSBjb3VudGVyIHZhcmlhYmxlIGJlY2F1c2Ugd2UgbmVl ZCB0bwotCSAqIGNhbGN1bGF0ZSBzdGFydC11cCB0aW1lIGZvciB0aGUgZmlyc3QgdHVwbGUgaW4g ZWFjaCBjeWNsZSwgYW5kIHRoZW4KLQkgKiBhY2N1bXVsYXRlIGl0IHRvZ2V0aGVyLgorCSAqIElu IGFzeW5jIG1vZGUsIGlmIHRoZSBwbGFuIG5vZGUgaGFkbid0IGVtaXR0ZWQgYW55IHR1cGxlcyBi ZWZvcmUsIHRoaXMKKwkgKiBtaWdodCBiZSB0aGUgZmlyc3QgdHVwbGUKIAkgKi8KLQlpZiAoaW5z dHItPmluc3RyLm5lZWRfdGltZXIpCi0JewotCQlpZiAoSU5TVFJfVElNRV9JU19aRVJPKGluc3Ry LT5pbnN0ci5zdGFydHRpbWUpKQotCQkJZWxvZyhFUlJPUiwgIkluc3RyU3RvcE5vZGUgY2FsbGVk IHdpdGhvdXQgc3RhcnQiKTsKLQotCQlJTlNUUl9USU1FX1NFVF9DVVJSRU5UKGVuZHRpbWUpOwot CQlJTlNUUl9USU1FX0FDQ1VNX0RJRkYoaW5zdHItPmNvdW50ZXIsIGVuZHRpbWUsIGluc3RyLT5p bnN0ci5zdGFydHRpbWUpOworCWlmICghaW5zdHItPnJ1bm5pbmcgfHwgKGluc3RyLT5hc3luY19t b2RlICYmIGluc3RyLT50dXBsZWNvdW50IDwgMS4wKSkKKwkJaW5zdHItPmZpcnN0dHVwbGUgPSBp bnN0ci0+Y291bnRlcjsKK30KIAotCQlJTlNUUl9USU1FX1NFVF9aRVJPKGluc3RyLT5pbnN0ci5z dGFydHRpbWUpOwotCX0KKy8qIEV4aXQgZnJvbSBhIHBsYW4gbm9kZS4gSWYgeW91IG1vZGlmeSB0 aGlzLCBjaGVjayBJbnN0ck5vZGVTZXR1cEV4ZWNQcm9jTm9kZS4gKi8KK3ZvaWQKK0luc3RyU3Rv cE5vZGUoTm9kZUluc3RydW1lbnRhdGlvbiAqaW5zdHIsIGRvdWJsZSBuVHVwbGVzKQoreworCWlm IChpbnN0ci0+aW5zdHIubmVlZF90aW1lcikKKwkJSW5zdHJTdG9wTm9kZVRpbWVyKGluc3RyKTsK IAotCS8qCi0JICogT25seSBwb3AgdGhlIHN0YWNrLCBhY2N1bXVsYXRpb24gcnVucyBpbgotCSAq IEV4ZWNGaW5hbGl6ZU5vZGVJbnN0cnVtZW50YXRpb24KLQkgKi8KKwkvKiBPbmx5IHBvcCB0aGUg c3RhY2ssIGFjY3VtdWxhdGlvbiBydW5zIGluIEluc3RyRmluYWxpemVOb2RlICovCiAJaWYgKGlu c3RyLT5pbnN0ci5uZWVkX3N0YWNrKQogCQlJbnN0clBvcFN0YWNrKCZpbnN0ci0+aW5zdHIpOwog Ci0JLyogSXMgdGhpcyB0aGUgZmlyc3QgdHVwbGUgb2YgdGhpcyBjeWNsZT8gKi8KLQlpZiAoIWlu c3RyLT5ydW5uaW5nKQotCXsKLQkJaW5zdHItPnJ1bm5pbmcgPSB0cnVlOwotCQlpbnN0ci0+Zmly c3R0dXBsZSA9IGluc3RyLT5jb3VudGVyOwotCX0KLQllbHNlCi0JewotCQkvKgotCQkgKiBJbiBh c3luYyBtb2RlLCBpZiB0aGUgcGxhbiBub2RlIGhhZG4ndCBlbWl0dGVkIGFueSB0dXBsZXMgYmVm b3JlLAotCQkgKiB0aGlzIG1pZ2h0IGJlIHRoZSBmaXJzdCB0dXBsZQotCQkgKi8KLQkJaWYgKGlu c3RyLT5hc3luY19tb2RlICYmIHNhdmVfdHVwbGVjb3VudCA8IDEuMCkKLQkJCWluc3RyLT5maXJz dHR1cGxlID0gaW5zdHItPmNvdW50ZXI7Ci0JfQorCWluc3RyLT5ydW5uaW5nID0gdHJ1ZTsKKwor CS8qIGNvdW50IHRoZSByZXR1cm5lZCB0dXBsZXMgKi8KKwlpbnN0ci0+dHVwbGVjb3VudCArPSBu VHVwbGVzOwogfQogCiAvKiBVcGRhdGUgdHVwbGUgY291bnQgKi8KQEAgLTUwNyw2ICs1MDAsMTAw IEBAIEluc3RyQWdnTm9kZShOb2RlSW5zdHJ1bWVudGF0aW9uICpkc3QsIE5vZGVJbnN0cnVtZW50 YXRpb24gKmFkZCkKIAkJSW5zdHJBY2N1bVN0YWNrKCZkc3QtPmluc3RyLCAmYWRkLT5pbnN0cik7 CiB9CiAKKy8qCisgKiBTcGVjaWFsaXplZCBoYW5kbGluZyBvZiBpbnN0cnVtZW50ZWQgRXhlY1By b2NOb2RlCisgKgorICogVGhlc2UgZnVuY3Rpb25zIGFyZSBlcXVpdmFsZW50IHRvIHJ1bm5pbmcg RXhlY1Byb2NOb2RlUmVhbCB3cmFwcGVkIGluCisgKiBJbnN0clN0YXJ0Tm9kZSBhbmQgSW5zdHJT dG9wTm9kZSwgYnV0IGF2b2lkIHRoZSBjb25kaXRpb25hbHMgaW4gdGhlIGhvdCBwYXRoCisgKiBi eSBjaGVja2luZyB0aGUgaW5zdHJ1bWVudGF0aW9uIG9wdGlvbnMgd2hlbiB0aGUgRXhlY1Byb2NO b2RlIHBvaW50ZXIgZ2V0cworICogZmlyc3Qgc2V0LCBhbmQgdGhlbiB1c2luZyBhIHNwZWNpYWwt cHVycG9zZSBmdW5jdGlvbiBmb3IgZWFjaC4gVGhpcyByZXN1bHRzCisgKiBpbiBhIG1vcmUgb3B0 aW1pemVkIHNldCBvZiBjb21waWxlZCBpbnN0cnVjdGlvbnMuCisgKi8KKworI2luY2x1ZGUgImV4 ZWN1dG9yL3R1cHRhYmxlLmgiCisjaW5jbHVkZSAibm9kZXMvZXhlY25vZGVzLmgiCisKKy8qIFNp bXBsaWZpZWQgcG9wOiByZXN0b3JlIHNhdmVkIHN0YXRlIGluc3RlYWQgb2YgcmUtZGVyaXZpbmcg ZnJvbSBhcnJheSAqLworc3RhdGljIGlubGluZSB2b2lkCitJbnN0clBvcFN0YWNrVG8oSW5zdHJ1 bWVudGF0aW9uICpwcmV2KQoreworCUFzc2VydChpbnN0cl9zdGFjay5zdGFja19zaXplID4gMCk7 CisJQXNzZXJ0KGluc3RyX3N0YWNrLnN0YWNrX3NpemUgPiAxID8gaW5zdHJfc3RhY2suZW50cmll c1tpbnN0cl9zdGFjay5zdGFja19zaXplIC0gMl0gPT0gcHJldiA6ICZpbnN0cl90b3AgPT0gcHJl dik7CisJaW5zdHJfc3RhY2suZW50cmllc1tpbnN0cl9zdGFjay5zdGFja19zaXplIC0gMV0tPm9u X3N0YWNrID0gZmFsc2U7CisJaW5zdHJfc3RhY2suc3RhY2tfc2l6ZS0tOworCWluc3RyX3N0YWNr LmN1cnJlbnQgPSBwcmV2OworfQorCitzdGF0aWMgcGdfYXR0cmlidXRlX2Fsd2F5c19pbmxpbmUg VHVwbGVUYWJsZVNsb3QgKgorRXhlY1Byb2NOb2RlSW5zdHIoUGxhblN0YXRlICpub2RlLCBib29s IG5lZWRfdGltZXIsIGJvb2wgbmVlZF9zdGFjaykKK3sKKwlOb2RlSW5zdHJ1bWVudGF0aW9uICpp bnN0ciA9IG5vZGUtPmluc3RydW1lbnQ7CisJSW5zdHJ1bWVudGF0aW9uICpwcmV2ID0gaW5zdHJf c3RhY2suY3VycmVudDsKKwlUdXBsZVRhYmxlU2xvdCAqcmVzdWx0OworCisJaWYgKG5lZWRfc3Rh Y2spCisJCUluc3RyUHVzaFN0YWNrKCZpbnN0ci0+aW5zdHIpOworCWlmIChuZWVkX3RpbWVyKQor CQlJbnN0clN0YXJ0VGltZXIoJmluc3RyLT5pbnN0cik7CisKKwlyZXN1bHQgPSBub2RlLT5FeGVj UHJvY05vZGVSZWFsKG5vZGUpOworCisJaWYgKG5lZWRfdGltZXIpCisJCUluc3RyU3RvcE5vZGVU aW1lcihpbnN0cik7CisJaWYgKG5lZWRfc3RhY2spCisJCUluc3RyUG9wU3RhY2tUbyhwcmV2KTsK KworCWluc3RyLT5ydW5uaW5nID0gdHJ1ZTsKKwlpZiAoIVR1cElzTnVsbChyZXN1bHQpKQorCQlp bnN0ci0+dHVwbGVjb3VudCArPSAxLjA7CisKKwlyZXR1cm4gcmVzdWx0OworfQorCitzdGF0aWMg VHVwbGVUYWJsZVNsb3QgKgorRXhlY1Byb2NOb2RlSW5zdHJGdWxsKFBsYW5TdGF0ZSAqbm9kZSkK K3sKKwlyZXR1cm4gRXhlY1Byb2NOb2RlSW5zdHIobm9kZSwgdHJ1ZSwgdHJ1ZSk7Cit9CisKK3N0 YXRpYyBUdXBsZVRhYmxlU2xvdCAqCitFeGVjUHJvY05vZGVJbnN0clJvd3NTdGFja09ubHkoUGxh blN0YXRlICpub2RlKQoreworCXJldHVybiBFeGVjUHJvY05vZGVJbnN0cihub2RlLCBmYWxzZSwg dHJ1ZSk7Cit9CisKK3N0YXRpYyBUdXBsZVRhYmxlU2xvdCAqCitFeGVjUHJvY05vZGVJbnN0clJv d3NUaW1lck9ubHkoUGxhblN0YXRlICpub2RlKQoreworCXJldHVybiBFeGVjUHJvY05vZGVJbnN0 cihub2RlLCB0cnVlLCBmYWxzZSk7Cit9CisKK3N0YXRpYyBUdXBsZVRhYmxlU2xvdCAqCitFeGVj UHJvY05vZGVJbnN0clJvd3NPbmx5KFBsYW5TdGF0ZSAqbm9kZSkKK3sKKwlyZXR1cm4gRXhlY1By b2NOb2RlSW5zdHIobm9kZSwgZmFsc2UsIGZhbHNlKTsKK30KKworLyoKKyAqIFJldHVybnMgYW4g RXhlY1Byb2NOb2RlIHdyYXBwZXIgdGhhdCBwZXJmb3JtcyBpbnN0cnVtZW50YXRpb24gY2FsbHMs CisgKiB0YWlsb3JlZCB0byB0aGUgaW5zdHJ1bWVudGF0aW9uIG9wdGlvbnMgZW5hYmxlZCBmb3Ig dGhlIG5vZGUuCisgKi8KK0V4ZWNQcm9jTm9kZU10ZAorSW5zdHJOb2RlU2V0dXBFeGVjUHJvY05v ZGUoTm9kZUluc3RydW1lbnRhdGlvbiAqaW5zdHIpCit7CisJYm9vbAkJbmVlZF90aW1lciA9IGlu c3RyLT5pbnN0ci5uZWVkX3RpbWVyOworCWJvb2wJCW5lZWRfc3RhY2sgPSBpbnN0ci0+aW5zdHIu bmVlZF9zdGFjazsKKworCWlmIChuZWVkX3RpbWVyICYmIG5lZWRfc3RhY2spCisJCXJldHVybiBF eGVjUHJvY05vZGVJbnN0ckZ1bGw7CisJZWxzZSBpZiAobmVlZF9zdGFjaykKKwkJcmV0dXJuIEV4 ZWNQcm9jTm9kZUluc3RyUm93c1N0YWNrT25seTsKKwllbHNlIGlmIChuZWVkX3RpbWVyKQorCQly ZXR1cm4gRXhlY1Byb2NOb2RlSW5zdHJSb3dzVGltZXJPbmx5OworCWVsc2UKKwkJcmV0dXJuIEV4 ZWNQcm9jTm9kZUluc3RyUm93c09ubHk7Cit9CisKIC8qIFRyaWdnZXIgaW5zdHJ1bWVudGF0aW9u IGhhbmRsaW5nICovCiBUcmlnZ2VySW5zdHJ1bWVudGF0aW9uICoKIEluc3RyQWxsb2NUcmlnZ2Vy KFF1ZXJ5SW5zdHJ1bWVudGF0aW9uICpxaW5zdHIsIGludCBuKQpkaWZmIC0tZ2l0IGEvc3JjL2lu Y2x1ZGUvZXhlY3V0b3IvaW5zdHJ1bWVudC5oIGIvc3JjL2luY2x1ZGUvZXhlY3V0b3IvaW5zdHJ1 bWVudC5oCmluZGV4IGI2MjYxOTQxMmEwLi5iYWU4YTliMGU2MiAxMDA2NDQKLS0tIGEvc3JjL2lu Y2x1ZGUvZXhlY3V0b3IvaW5zdHJ1bWVudC5oCisrKyBiL3NyYy9pbmNsdWRlL2V4ZWN1dG9yL2lu c3RydW1lbnQuaApAQCAtMjk3LDYgKzI5NywxMSBAQCBleHRlcm4gdm9pZCBJbnN0clVwZGF0ZVR1 cGxlQ291bnQoTm9kZUluc3RydW1lbnRhdGlvbiAqaW5zdHIsIGRvdWJsZSBuVHVwbGVzKTsKIGV4 dGVybiB2b2lkIEluc3RyRW5kTG9vcChOb2RlSW5zdHJ1bWVudGF0aW9uICppbnN0cik7CiBleHRl cm4gdm9pZCBJbnN0ckFnZ05vZGUoTm9kZUluc3RydW1lbnRhdGlvbiAqZHN0LCBOb2RlSW5zdHJ1 bWVudGF0aW9uICphZGQpOwogCit0eXBlZGVmIHN0cnVjdCBUdXBsZVRhYmxlU2xvdCBUdXBsZVRh YmxlU2xvdDsKK3R5cGVkZWYgc3RydWN0IFBsYW5TdGF0ZSBQbGFuU3RhdGU7Cit0eXBlZGVmIFR1 cGxlVGFibGVTbG90ICooKkV4ZWNQcm9jTm9kZU10ZCkgKFBsYW5TdGF0ZSAqcHN0YXRlKTsKK2V4 dGVybiBFeGVjUHJvY05vZGVNdGQgSW5zdHJOb2RlU2V0dXBFeGVjUHJvY05vZGUoTm9kZUluc3Ry dW1lbnRhdGlvbiAqaW5zdHIpOworCiBleHRlcm4gVHJpZ2dlckluc3RydW1lbnRhdGlvbiAqSW5z dHJBbGxvY1RyaWdnZXIoUXVlcnlJbnN0cnVtZW50YXRpb24gKnFpbnN0ciwgaW50IG4pOwogZXh0 ZXJuIHZvaWQgSW5zdHJTdGFydFRyaWdnZXIoUXVlcnlJbnN0cnVtZW50YXRpb24gKnFpbnN0ciwK IAkJCQkJCQkgIFRyaWdnZXJJbnN0cnVtZW50YXRpb24gKnRnaW5zdHIpOwotLSAKMi40Ny4xCgo= --0000000000006d0cb0064eb5be7d Content-Type: application/octet-stream; name="v13-0011-Index-scans-Show-table-buffer-accesses-separatel.patch" Content-Disposition: attachment; filename="v13-0011-Index-scans-Show-table-buffer-accesses-separatel.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mnlqag8610 RnJvbSBiNTdjNDExODk4NGJkNDZiODQ4NjA3NjgwYWZmZjExYjc5NjBmMWJkIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBMdWthcyBGaXR0bCA8bHVrYXNAZml0dGwuY29tPgpEYXRlOiBT YXQsIDcgTWFyIDIwMjYgMTE6NDY6MTkgLTA4MDAKU3ViamVjdDogW1BBVENIIHYxMyAxMS8xMl0g SW5kZXggc2NhbnM6IFNob3cgdGFibGUgYnVmZmVyIGFjY2Vzc2VzIHNlcGFyYXRlbHkKIGluIEVY UExBSU4gQU5BTFlaRQoKVGhpcyBzZXRzIHVwIGEgc2VwYXJhdGUgaW5zdHJ1bWVudGF0aW9uIHN0 YWNrIHRoYXQgaXMgdXNlZCB3aGlsc3QgYW4KSW5kZXggU2NhbiBvciBJbmRleCBPbmx5IFNjYW4g ZG9lcyBzY2FubmluZyBvbiB0aGUgdGFibGUsIGZvciBleGFtcGxlIGR1ZQp0byBhZGRpdGlvbmFs IGRhdGEgYmVpbmcgbmVlZGVkLgoKRVhQTEFJTiBBTkFMWVpFIHdpbGwgbm93IHNob3cgIlRhYmxl IEJ1ZmZlcnMiIHRoYXQgcmVwcmVzZW50IHN1Y2ggYWN0aXZpdHkuClRoZSBhY3Rpdml0eSBpcyBh bHNvIGluY2x1ZGVkIGluIHJlZ3VsYXIgIkJ1ZmZlcnMiIHRvZ2V0aGVyIHdpdGggaW5kZXgKYWN0 aXZpdHkgYW5kIHRoYXQgb2YgYW55IGNoaWxkIG5vZGVzLgoKQXV0aG9yOiBMdWthcyBGaXR0bCA8 bHVrYXNAZml0dGwuY29tPgpTdWdnZXN0ZWQtYnk6IEFuZHJlcyBGcmV1bmQgPGFuZHJlc0BhbmFy YXplbC5kZT4KUmV2aWV3ZWQtYnk6IFpzb2x0IFBhcnJhZ2kgPHpzb2x0LnBhcnJhZ2lAcGVyY29u YS5jb20+ClJldmlld2VkLWJ5OiBUb21hcyBWb25kcmEgPHRvbWFzQHZvbmRyYS5tZT4KRGlzY3Vz c2lvbjogaHR0cHM6Ly93d3cucG9zdGdyZXNxbC5vcmcvbWVzc2FnZS1pZC9mbGF0L0NBUDUzUGt4 cm1wRUN6VkZwZWVFRUhER2U2dTYyNXMlMkJZa21WdjUtZ3czTF9ORFNmYmlBJTQwbWFpbC5nbWFp bC5jb20jY2I1ODNhMDhlOGUwOTZhYTFmMDkzYmIxNzg5MDYxNzMKLS0tCiBkb2Mvc3JjL3NnbWwv cGVyZm9ybS5zZ21sICAgICAgICAgICAgICAgICAgfCAgMTMgKystCiBkb2Mvc3JjL3NnbWwvcmVm L2V4cGxhaW4uc2dtbCAgICAgICAgICAgICAgfCAgIDEgKwogc3JjL2JhY2tlbmQvY29tbWFuZHMv ZXhwbGFpbi5jICAgICAgICAgICAgIHwgIDQ3ICsrKysrKy0tCiBzcmMvYmFja2VuZC9leGVjdXRv ci9leGVjUHJvY25vZGUuYyAgICAgICAgfCAgNDYgKysrKysrKysKIHNyYy9iYWNrZW5kL2V4ZWN1 dG9yL25vZGVCaXRtYXBJbmRleHNjYW4uYyB8ICAgMiArLQogc3JjL2JhY2tlbmQvZXhlY3V0b3Iv bm9kZUluZGV4b25seXNjYW4uYyAgIHwgIDQxICsrKysrKy0KIHNyYy9iYWNrZW5kL2V4ZWN1dG9y L25vZGVJbmRleHNjYW4uYyAgICAgICB8IDEyNyArKysrKysrKysrKysrKysrKy0tLS0KIHNyYy9p bmNsdWRlL2V4ZWN1dG9yL2luc3RydW1lbnRfbm9kZS5oICAgICB8ICAgNSArCiA4IGZpbGVzIGNo YW5nZWQsIDI0NCBpbnNlcnRpb25zKCspLCAzOCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9k b2Mvc3JjL3NnbWwvcGVyZm9ybS5zZ21sIGIvZG9jL3NyYy9zZ21sL3BlcmZvcm0uc2dtbAppbmRl eCA2MDRlODU3OGE4ZC4uZDI4ZjRmMjI1MzUgMTAwNjQ0Ci0tLSBhL2RvYy9zcmMvc2dtbC9wZXJm b3JtLnNnbWwKKysrIGIvZG9jL3NyYy9zZ21sL3BlcmZvcm0uc2dtbApAQCAtNzM0LDYgKzczNCw3 IEBAIFdIRVJFIHQxLnVuaXF1ZTEgJmx0OyAxMCBBTkQgdDEudW5pcXVlMiA9IHQyLnVuaXF1ZTI7 CiAgICAtJmd0OyAgSW5kZXggU2NhbiB1c2luZyB0ZW5rMl91bmlxdWUyIG9uIHRlbmsyIHQyICAo Y29zdD0wLjI5Li43LjkwIHJvd3M9MSB3aWR0aD0yNDQpIChhY3R1YWwgdGltZT0wLjAwMy4uMC4w MDMgcm93cz0xLjAwIGxvb3BzPTEwKQogICAgICAgICAgSW5kZXggQ29uZDogKHVuaXF1ZTIgPSB0 MS51bmlxdWUyKQogICAgICAgICAgSW5kZXggU2VhcmNoZXM6IDEwCisgICAgICAgICBUYWJsZSBC dWZmZXJzOiBzaGFyZWQgaGl0PTEwCiAgICAgICAgICBCdWZmZXJzOiBzaGFyZWQgaGl0PTI0IHJl YWQ9NgogIFBsYW5uaW5nOgogICAgQnVmZmVyczogc2hhcmVkIGhpdD0xNSBkaXJ0aWVkPTkKQEAg LTEwMDUsNyArMTAwNiw4IEBAIEVYUExBSU4gQU5BTFlaRSBTRUxFQ1QgKiBGUk9NIHBvbHlnb25f dGJsIFdIRVJFIGYxIEAmZ3Q7IHBvbHlnb24gJygwLjUsMi4wKSc7CiAgICBJbmRleCBDb25kOiAo ZjEgQCZndDsgJygoMC41LDIpKSc6OnBvbHlnb24pCiAgICBSb3dzIFJlbW92ZWQgYnkgSW5kZXgg UmVjaGVjazogMQogICAgSW5kZXggU2VhcmNoZXM6IDEKLSAgIEJ1ZmZlcnM6IHNoYXJlZCBoaXQ9 MQorICAgVGFibGUgQnVmZmVyczogc2hhcmVkIGhpdD0xCisgICBCdWZmZXJzOiBzaGFyZWQgaGl0 PTIKICBQbGFubmluZyBUaW1lOiAwLjAzOSBtcwogIEV4ZWN1dGlvbiBUaW1lOiAwLjA5OCBtcwog PC9zY3JlZW4+CkBAIC0xMDE0LDcgKzEwMTYsOSBAQCBFWFBMQUlOIEFOQUxZWkUgU0VMRUNUICog RlJPTSBwb2x5Z29uX3RibCBXSEVSRSBmMSBAJmd0OyBwb2x5Z29uICcoMC41LDIuMCknOwogICAg IHRoZW4gcmVqZWN0ZWQgYnkgYSByZWNoZWNrIG9mIHRoZSBpbmRleCBjb25kaXRpb24uICBUaGlz IGhhcHBlbnMgYmVjYXVzZSBhCiAgICAgR2lTVCBpbmRleCBpcyA8cXVvdGU+bG9zc3k8L3F1b3Rl PiBmb3IgcG9seWdvbiBjb250YWlubWVudCB0ZXN0czogaXQgYWN0dWFsbHkKICAgICByZXR1cm5z IHRoZSByb3dzIHdpdGggcG9seWdvbnMgdGhhdCBvdmVybGFwIHRoZSB0YXJnZXQsIGFuZCB0aGVu IHdlIGhhdmUKLSAgICB0byBkbyB0aGUgZXhhY3QgY29udGFpbm1lbnQgdGVzdCBvbiB0aG9zZSBy b3dzLgorICAgIHRvIGRvIHRoZSBleGFjdCBjb250YWlubWVudCB0ZXN0IG9uIHRob3NlIHJvd3Mu IFRoZSA8bGl0ZXJhbD5UYWJsZSBCdWZmZXJzPC9saXRlcmFsPgorICAgIGNvdW50cyBpbmRpY2F0 ZSBob3cgbWFueSBvcGVyYXRpb25zIHdlcmUgcGVyZm9ybWVkIG9uIHRoZSB0YWJsZSBpbnN0ZWFk IG9mCisgICAgdGhlIGluZGV4LiBUaGlzIG51bWJlciBpcyBpbmNsdWRlZCBpbiB0aGUgPGxpdGVy YWw+QnVmZmVyczwvbGl0ZXJhbD4gY291bnRzLgogICAgPC9wYXJhPgogCiAgICA8cGFyYT4KQEAg LTEyMDMsMTMgKzEyMDcsMTQgQEAgRVhQTEFJTiBBTkFMWVpFIFNFTEVDVCAqIEZST00gdGVuazEg V0hFUkUgdW5pcXVlMSAmbHQ7IDEwMCBBTkQgdW5pcXVlMiAmZ3Q7IDkwMDAKICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBRVUVSWSBQTEFO CiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tJnp3c3A7LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgTGltaXQgIChjb3N0PTAuMjkuLjE0LjMzIHJvd3M9MiB3 aWR0aD0yNDQpIChhY3R1YWwgdGltZT0wLjA1MS4uMC4wNzEgcm93cz0yLjAwIGxvb3BzPTEpCi0g ICBCdWZmZXJzOiBzaGFyZWQgaGl0PTE2CisgICBCdWZmZXJzOiBzaGFyZWQgaGl0PTE0CiAgICAt Jmd0OyAgSW5kZXggU2NhbiB1c2luZyB0ZW5rMV91bmlxdWUyIG9uIHRlbmsxICAoY29zdD0wLjI5 Li43MC41MCByb3dzPTEwIHdpZHRoPTI0NCkgKGFjdHVhbCB0aW1lPTAuMDUxLi4wLjA3MCByb3dz PTIuMDAgbG9vcHM9MSkKICAgICAgICAgIEluZGV4IENvbmQ6ICh1bmlxdWUyICZndDsgOTAwMCkK ICAgICAgICAgIEZpbHRlcjogKHVuaXF1ZTEgJmx0OyAxMDApCiAgICAgICAgICBSb3dzIFJlbW92 ZWQgYnkgRmlsdGVyOiAyODcKICAgICAgICAgIEluZGV4IFNlYXJjaGVzOiAxCi0gICAgICAgICBC dWZmZXJzOiBzaGFyZWQgaGl0PTE2CisgICAgICAgICBUYWJsZSBCdWZmZXJzOiBzaGFyZWQgaGl0 PTExCisgICAgICAgICBCdWZmZXJzOiBzaGFyZWQgaGl0PTE0CiAgUGxhbm5pbmcgVGltZTogMC4w NzcgbXMKICBFeGVjdXRpb24gVGltZTogMC4wODYgbXMKIDwvc2NyZWVuPgpkaWZmIC0tZ2l0IGEv ZG9jL3NyYy9zZ21sL3JlZi9leHBsYWluLnNnbWwgYi9kb2Mvc3JjL3NnbWwvcmVmL2V4cGxhaW4u c2dtbAppbmRleCA1YjhiNTIxODAyZS4uNzEwNzA3MzZhY2IgMTAwNjQ0Ci0tLSBhL2RvYy9zcmMv c2dtbC9yZWYvZXhwbGFpbi5zZ21sCisrKyBiL2RvYy9zcmMvc2dtbC9yZWYvZXhwbGFpbi5zZ21s CkBAIC01MDksNiArNTA5LDcgQEAgRVhQTEFJTiBBTkFMWVpFIEVYRUNVVEUgcXVlcnkoMTAwLCAy MDApOwogICAgLSZndDsgIEluZGV4IFNjYW4gdXNpbmcgdGVzdF9wa2V5IG9uIHRlc3QgIChjb3N0 PTAuMjkuLjEwLjI3IHJvd3M9OTkgd2lkdGg9OCkgKGFjdHVhbCB0aW1lPTAuMDA5Li4wLjAyNSBy b3dzPTk5LjAwIGxvb3BzPTEpCiAgICAgICAgICBJbmRleCBDb25kOiAoKGlkICZndDsgMTAwKSBB TkQgKGlkICZsdDsgMjAwKSkKICAgICAgICAgIEluZGV4IFNlYXJjaGVzOiAxCisgICAgICAgICBU YWJsZSBCdWZmZXJzOiBzaGFyZWQgaGl0PTEKICAgICAgICAgIEJ1ZmZlcnM6IHNoYXJlZCBoaXQ9 NAogIFBsYW5uaW5nIFRpbWU6IDAuMjQ0IG1zCiAgRXhlY3V0aW9uIFRpbWU6IDAuMDczIG1zCmRp ZmYgLS1naXQgYS9zcmMvYmFja2VuZC9jb21tYW5kcy9leHBsYWluLmMgYi9zcmMvYmFja2VuZC9j b21tYW5kcy9leHBsYWluLmMKaW5kZXggOWZjMzljYWJkZjguLjQyZmMwMGNiZDM0IDEwMDY0NAot LS0gYS9zcmMvYmFja2VuZC9jb21tYW5kcy9leHBsYWluLmMKKysrIGIvc3JjL2JhY2tlbmQvY29t bWFuZHMvZXhwbGFpbi5jCkBAIC0xNDQsNyArMTQ0LDcgQEAgc3RhdGljIHZvaWQgc2hvd19pbnN0 cnVtZW50YXRpb25fY291bnQoY29uc3QgY2hhciAqcWxhYmVsLCBpbnQgd2hpY2gsCiBzdGF0aWMg dm9pZCBzaG93X2ZvcmVpZ25zY2FuX2luZm8oRm9yZWlnblNjYW5TdGF0ZSAqZnNzdGF0ZSwgRXhw bGFpblN0YXRlICplcyk7CiBzdGF0aWMgY29uc3QgY2hhciAqZXhwbGFpbl9nZXRfaW5kZXhfbmFt ZShPaWQgaW5kZXhJZCk7CiBzdGF0aWMgYm9vbCBwZWVrX2J1ZmZlcl91c2FnZShFeHBsYWluU3Rh dGUgKmVzLCBjb25zdCBCdWZmZXJVc2FnZSAqdXNhZ2UpOwotc3RhdGljIHZvaWQgc2hvd19idWZm ZXJfdXNhZ2UoRXhwbGFpblN0YXRlICplcywgY29uc3QgQnVmZmVyVXNhZ2UgKnVzYWdlKTsKK3N0 YXRpYyB2b2lkIHNob3dfYnVmZmVyX3VzYWdlKEV4cGxhaW5TdGF0ZSAqZXMsIGNvbnN0IEJ1ZmZl clVzYWdlICp1c2FnZSwgY29uc3QgY2hhciAqdGl0bGUpOwogc3RhdGljIHZvaWQgc2hvd193YWxf dXNhZ2UoRXhwbGFpblN0YXRlICplcywgY29uc3QgV2FsVXNhZ2UgKnVzYWdlKTsKIHN0YXRpYyB2 b2lkIHNob3dfbWVtb3J5X2NvdW50ZXJzKEV4cGxhaW5TdGF0ZSAqZXMsCiAJCQkJCQkJCSBjb25z dCBNZW1vcnlDb250ZXh0Q291bnRlcnMgKm1lbV9jb3VudGVycyk7CkBAIC02MTEsNyArNjExLDcg QEAgRXhwbGFpbk9uZVBsYW4oUGxhbm5lZFN0bXQgKnBsYW5uZWRzdG10LCBJbnRvQ2xhdXNlICpp bnRvLCBFeHBsYWluU3RhdGUgKmVzLAogCQl9CiAKIAkJaWYgKGJ1ZnVzYWdlKQotCQkJc2hvd19i dWZmZXJfdXNhZ2UoZXMsIGJ1ZnVzYWdlKTsKKwkJCXNob3dfYnVmZmVyX3VzYWdlKGVzLCBidWZ1 c2FnZSwgTlVMTCk7CiAKIAkJaWYgKG1lbV9jb3VudGVycykKIAkJCXNob3dfbWVtb3J5X2NvdW50 ZXJzKGVzLCBtZW1fY291bnRlcnMpOwpAQCAtMTAyOCw3ICsxMDI4LDcgQEAgRXhwbGFpblByaW50 U2VyaWFsaXplKEV4cGxhaW5TdGF0ZSAqZXMsIFNlcmlhbGl6ZU1ldHJpY3MgKm1ldHJpY3MpCiAJ CWlmIChlcy0+YnVmZmVycyAmJiBwZWVrX2J1ZmZlcl91c2FnZShlcywgJm1ldHJpY3MtPmluc3Ry LmJ1ZnVzYWdlKSkKIAkJewogCQkJZXMtPmluZGVudCsrOwotCQkJc2hvd19idWZmZXJfdXNhZ2Uo ZXMsICZtZXRyaWNzLT5pbnN0ci5idWZ1c2FnZSk7CisJCQlzaG93X2J1ZmZlcl91c2FnZShlcywg Jm1ldHJpY3MtPmluc3RyLmJ1ZnVzYWdlLCBOVUxMKTsKIAkJCWVzLT5pbmRlbnQtLTsKIAkJfQog CX0KQEAgLTEwNDIsNyArMTA0Miw3IEBAIEV4cGxhaW5QcmludFNlcmlhbGl6ZShFeHBsYWluU3Rh dGUgKmVzLCBTZXJpYWxpemVNZXRyaWNzICptZXRyaWNzKQogCQkJCQkJCQlCWVRFU19UT19LSUxP QllURVMobWV0cmljcy0+Ynl0ZXNTZW50KSwgZXMpOwogCQlFeHBsYWluUHJvcGVydHlUZXh0KCJG b3JtYXQiLCBmb3JtYXQsIGVzKTsKIAkJaWYgKGVzLT5idWZmZXJzKQotCQkJc2hvd19idWZmZXJf dXNhZ2UoZXMsICZtZXRyaWNzLT5pbnN0ci5idWZ1c2FnZSk7CisJCQlzaG93X2J1ZmZlcl91c2Fn ZShlcywgJm1ldHJpY3MtPmluc3RyLmJ1ZnVzYWdlLCBOVUxMKTsKIAl9CiAKIAlFeHBsYWluQ2xv c2VHcm91cCgiU2VyaWFsaXphdGlvbiIsICJTZXJpYWxpemF0aW9uIiwgdHJ1ZSwgZXMpOwpAQCAt MTk3MCw2ICsxOTcwLDkgQEAgRXhwbGFpbk5vZGUoUGxhblN0YXRlICpwbGFuc3RhdGUsIExpc3Qg KmFuY2VzdG9ycywKIAkJCQlzaG93X2luc3RydW1lbnRhdGlvbl9jb3VudCgiUm93cyBSZW1vdmVk IGJ5IEZpbHRlciIsIDEsCiAJCQkJCQkJCQkJICAgcGxhbnN0YXRlLCBlcyk7CiAJCQlzaG93X2lu ZGV4c2VhcmNoZXNfaW5mbyhwbGFuc3RhdGUsIGVzKTsKKworCQkJaWYgKGVzLT5idWZmZXJzICYm IHBsYW5zdGF0ZS0+aW5zdHJ1bWVudCkKKwkJCQlzaG93X2J1ZmZlcl91c2FnZShlcywgJigoSW5k ZXhTY2FuU3RhdGUgKikgcGxhbnN0YXRlKS0+aXNzX0luc3RydW1lbnQtPnRhYmxlX2luc3RyLmJ1 ZnVzYWdlLCAiVGFibGUiKTsKIAkJCWJyZWFrOwogCQljYXNlIFRfSW5kZXhPbmx5U2NhbjoKIAkJ CXNob3dfc2Nhbl9xdWFsKCgoSW5kZXhPbmx5U2NhbiAqKSBwbGFuKS0+aW5kZXhxdWFsLApAQCAt MTk4Nyw2ICsxOTkwLDkgQEAgRXhwbGFpbk5vZGUoUGxhblN0YXRlICpwbGFuc3RhdGUsIExpc3Qg KmFuY2VzdG9ycywKIAkJCQlFeHBsYWluUHJvcGVydHlGbG9hdCgiSGVhcCBGZXRjaGVzIiwgTlVM TCwKIAkJCQkJCQkJCSBwbGFuc3RhdGUtPmluc3RydW1lbnQtPm50dXBsZXMyLCAwLCBlcyk7CiAJ CQlzaG93X2luZGV4c2VhcmNoZXNfaW5mbyhwbGFuc3RhdGUsIGVzKTsKKworCQkJaWYgKGVzLT5i dWZmZXJzICYmIHBsYW5zdGF0ZS0+aW5zdHJ1bWVudCkKKwkJCQlzaG93X2J1ZmZlcl91c2FnZShl cywgJigoSW5kZXhPbmx5U2NhblN0YXRlICopIHBsYW5zdGF0ZSktPmlvc3NfSW5zdHJ1bWVudC0+ dGFibGVfaW5zdHIuYnVmdXNhZ2UsICJUYWJsZSIpOwogCQkJYnJlYWs7CiAJCWNhc2UgVF9CaXRt YXBJbmRleFNjYW46CiAJCQlzaG93X3NjYW5fcXVhbCgoKEJpdG1hcEluZGV4U2NhbiAqKSBwbGFu KS0+aW5kZXhxdWFsb3JpZywKQEAgLTIyODgsNyArMjI5NCw3IEBAIEV4cGxhaW5Ob2RlKFBsYW5T dGF0ZSAqcGxhbnN0YXRlLCBMaXN0ICphbmNlc3RvcnMsCiAKIAkvKiBTaG93IGJ1ZmZlci9XQUwg dXNhZ2UgKi8KIAlpZiAoZXMtPmJ1ZmZlcnMgJiYgcGxhbnN0YXRlLT5pbnN0cnVtZW50KQotCQlz aG93X2J1ZmZlcl91c2FnZShlcywgJnBsYW5zdGF0ZS0+aW5zdHJ1bWVudC0+aW5zdHIuYnVmdXNh Z2UpOworCQlzaG93X2J1ZmZlcl91c2FnZShlcywgJnBsYW5zdGF0ZS0+aW5zdHJ1bWVudC0+aW5z dHIuYnVmdXNhZ2UsIE5VTEwpOwogCWlmIChlcy0+d2FsICYmIHBsYW5zdGF0ZS0+aW5zdHJ1bWVu dCkKIAkJc2hvd193YWxfdXNhZ2UoZXMsICZwbGFuc3RhdGUtPmluc3RydW1lbnQtPmluc3RyLndh bHVzYWdlKTsKIApAQCAtMjMwNyw3ICsyMzEzLDcgQEAgRXhwbGFpbk5vZGUoUGxhblN0YXRlICpw bGFuc3RhdGUsIExpc3QgKmFuY2VzdG9ycywKIAogCQkJRXhwbGFpbk9wZW5Xb3JrZXIobiwgZXMp OwogCQkJaWYgKGVzLT5idWZmZXJzKQotCQkJCXNob3dfYnVmZmVyX3VzYWdlKGVzLCAmaW5zdHJ1 bWVudC0+aW5zdHIuYnVmdXNhZ2UpOworCQkJCXNob3dfYnVmZmVyX3VzYWdlKGVzLCAmaW5zdHJ1 bWVudC0+aW5zdHIuYnVmdXNhZ2UsIE5VTEwpOwogCQkJaWYgKGVzLT53YWwpCiAJCQkJc2hvd193 YWxfdXNhZ2UoZXMsICZpbnN0cnVtZW50LT5pbnN0ci53YWx1c2FnZSk7CiAJCQlFeHBsYWluQ2xv c2VXb3JrZXIobiwgZXMpOwpAQCAtNDEyNiw3ICs0MTMyLDcgQEAgcGVla19idWZmZXJfdXNhZ2Uo RXhwbGFpblN0YXRlICplcywgY29uc3QgQnVmZmVyVXNhZ2UgKnVzYWdlKQogICogU2hvdyBidWZm ZXIgdXNhZ2UgZGV0YWlscy4gIFRoaXMgYmV0dGVyIGJlIHN5bmMgd2l0aCBwZWVrX2J1ZmZlcl91 c2FnZS4KICAqLwogc3RhdGljIHZvaWQKLXNob3dfYnVmZmVyX3VzYWdlKEV4cGxhaW5TdGF0ZSAq ZXMsIGNvbnN0IEJ1ZmZlclVzYWdlICp1c2FnZSkKK3Nob3dfYnVmZmVyX3VzYWdlKEV4cGxhaW5T dGF0ZSAqZXMsIGNvbnN0IEJ1ZmZlclVzYWdlICp1c2FnZSwgY29uc3QgY2hhciAqdGl0bGUpCiB7 CiAJaWYgKGVzLT5mb3JtYXQgPT0gRVhQTEFJTl9GT1JNQVRfVEVYVCkKIAl7CkBAIC00MTUxLDYg KzQxNTcsOCBAQCBzaG93X2J1ZmZlcl91c2FnZShFeHBsYWluU3RhdGUgKmVzLCBjb25zdCBCdWZm ZXJVc2FnZSAqdXNhZ2UpCiAJCWlmIChoYXNfc2hhcmVkIHx8IGhhc19sb2NhbCB8fCBoYXNfdGVt cCkKIAkJewogCQkJRXhwbGFpbkluZGVudFRleHQoZXMpOworCQkJaWYgKHRpdGxlKQorCQkJCWFw cGVuZFN0cmluZ0luZm8oZXMtPnN0ciwgIiVzICIsIHRpdGxlKTsKIAkJCWFwcGVuZFN0cmluZ0lu Zm9TdHJpbmcoZXMtPnN0ciwgIkJ1ZmZlcnM6Iik7CiAKIAkJCWlmIChoYXNfc2hhcmVkKQpAQCAt NDIwNiw2ICs0MjE0LDggQEAgc2hvd19idWZmZXJfdXNhZ2UoRXhwbGFpblN0YXRlICplcywgY29u c3QgQnVmZmVyVXNhZ2UgKnVzYWdlKQogCQlpZiAoaGFzX3NoYXJlZF90aW1pbmcgfHwgaGFzX2xv Y2FsX3RpbWluZyB8fCBoYXNfdGVtcF90aW1pbmcpCiAJCXsKIAkJCUV4cGxhaW5JbmRlbnRUZXh0 KGVzKTsKKwkJCWlmICh0aXRsZSkKKwkJCQlhcHBlbmRTdHJpbmdJbmZvKGVzLT5zdHIsICIlcyAi LCB0aXRsZSk7CiAJCQlhcHBlbmRTdHJpbmdJbmZvU3RyaW5nKGVzLT5zdHIsICJJL08gVGltaW5n czoiKTsKIAogCQkJaWYgKGhhc19zaGFyZWRfdGltaW5nKQpAQCAtNDI0Nyw2ICs0MjU3LDE0IEBA IHNob3dfYnVmZmVyX3VzYWdlKEV4cGxhaW5TdGF0ZSAqZXMsIGNvbnN0IEJ1ZmZlclVzYWdlICp1 c2FnZSkKIAl9CiAJZWxzZQogCXsKKwkJY2hhcgkgICAqYnVmZmVyc190aXRsZSA9IE5VTEw7CisK KwkJaWYgKHRpdGxlKQorCQl7CisJCQlidWZmZXJzX3RpdGxlID0gcHNwcmludGYoIiVzIEJ1ZmZl cnMiLCB0aXRsZSk7CisJCQlFeHBsYWluT3Blbkdyb3VwKGJ1ZmZlcnNfdGl0bGUsIGJ1ZmZlcnNf dGl0bGUsIHRydWUsIGVzKTsKKwkJfQorCiAJCUV4cGxhaW5Qcm9wZXJ0eUludGVnZXIoIlNoYXJl ZCBIaXQgQmxvY2tzIiwgTlVMTCwKIAkJCQkJCQkgICB1c2FnZS0+c2hhcmVkX2Jsa3NfaGl0LCBl cyk7CiAJCUV4cGxhaW5Qcm9wZXJ0eUludGVnZXIoIlNoYXJlZCBSZWFkIEJsb2NrcyIsIE5VTEws CkBAIC00MjY3LDggKzQyODUsMjAgQEAgc2hvd19idWZmZXJfdXNhZ2UoRXhwbGFpblN0YXRlICpl cywgY29uc3QgQnVmZmVyVXNhZ2UgKnVzYWdlKQogCQkJCQkJCSAgIHVzYWdlLT50ZW1wX2Jsa3Nf cmVhZCwgZXMpOwogCQlFeHBsYWluUHJvcGVydHlJbnRlZ2VyKCJUZW1wIFdyaXR0ZW4gQmxvY2tz IiwgTlVMTCwKIAkJCQkJCQkgICB1c2FnZS0+dGVtcF9ibGtzX3dyaXR0ZW4sIGVzKTsKKworCQlp ZiAoYnVmZmVyc190aXRsZSkKKwkJCUV4cGxhaW5DbG9zZUdyb3VwKGJ1ZmZlcnNfdGl0bGUsIGJ1 ZmZlcnNfdGl0bGUsIHRydWUsIGVzKTsKKwogCQlpZiAodHJhY2tfaW9fdGltaW5nKQogCQl7CisJ CQljaGFyCSAgICp0aW1pbmdzX3RpdGxlID0gTlVMTDsKKworCQkJaWYgKHRpdGxlKQorCQkJewor CQkJCXRpbWluZ3NfdGl0bGUgPSBwc3ByaW50ZigiJXMgSS9PIFRpbWluZ3MiLCB0aXRsZSk7CisJ CQkJRXhwbGFpbk9wZW5Hcm91cCh0aW1pbmdzX3RpdGxlLCB0aW1pbmdzX3RpdGxlLCB0cnVlLCBl cyk7CisJCQl9CisKIAkJCUV4cGxhaW5Qcm9wZXJ0eUZsb2F0KCJTaGFyZWQgSS9PIFJlYWQgVGlt ZSIsICJtcyIsCiAJCQkJCQkJCSBJTlNUUl9USU1FX0dFVF9NSUxMSVNFQyh1c2FnZS0+c2hhcmVk X2Jsa19yZWFkX3RpbWUpLAogCQkJCQkJCQkgMywgZXMpOwpAQCAtNDI4Nyw2ICs0MzE3LDkgQEAg c2hvd19idWZmZXJfdXNhZ2UoRXhwbGFpblN0YXRlICplcywgY29uc3QgQnVmZmVyVXNhZ2UgKnVz YWdlKQogCQkJRXhwbGFpblByb3BlcnR5RmxvYXQoIlRlbXAgSS9PIFdyaXRlIFRpbWUiLCAibXMi LAogCQkJCQkJCQkgSU5TVFJfVElNRV9HRVRfTUlMTElTRUModXNhZ2UtPnRlbXBfYmxrX3dyaXRl X3RpbWUpLAogCQkJCQkJCQkgMywgZXMpOworCisJCQlpZiAodGltaW5nc190aXRsZSkKKwkJCQlF eHBsYWluQ2xvc2VHcm91cCh0aW1pbmdzX3RpdGxlLCB0aW1pbmdzX3RpdGxlLCB0cnVlLCBlcyk7 CiAJCX0KIAl9CiB9CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjUHJvY25v ZGUuYyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNQcm9jbm9kZS5jCmluZGV4IDZlOGNiYWVj Y2Y3Li5hNTlkZTBlZjIyYiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY1By b2Nub2RlLmMKKysrIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY1Byb2Nub2RlLmMKQEAgLTg0 Niw2ICs4NDYsMjAgQEAgRXhlY0ZpbmFsaXplTm9kZUluc3RydW1lbnRhdGlvbl93YWxrZXIoUGxh blN0YXRlICpub2RlLCB2b2lkICpjb250ZXh0KQogCXBsYW5zdGF0ZV90cmVlX3dhbGtlcihub2Rl LCBFeGVjRmluYWxpemVOb2RlSW5zdHJ1bWVudGF0aW9uX3dhbGtlciwKIAkJCQkJCSAgJm5vZGUt Pmluc3RydW1lbnQtPmluc3RyKTsKIAorCS8qIEluZGV4U2Nhbi9JbmRleE9ubHlTY2FuIGhhdmUg YSBzZXBhcmF0ZSBlbnRyeSB0byB0cmFjayB0YWJsZSBhY2Nlc3MgKi8KKwlpZiAoSXNBKG5vZGUs IEluZGV4U2NhblN0YXRlKSkKKwl7CisJCUluZGV4U2NhblN0YXRlICppc3MgPSBjYXN0Tm9kZShJ bmRleFNjYW5TdGF0ZSwgbm9kZSk7CisKKwkJSW5zdHJGaW5hbGl6ZUNoaWxkKCZpc3MtPmlzc19J bnN0cnVtZW50LT50YWJsZV9pbnN0ciwgJm5vZGUtPmluc3RydW1lbnQtPmluc3RyKTsKKwl9CisJ ZWxzZSBpZiAoSXNBKG5vZGUsIEluZGV4T25seVNjYW5TdGF0ZSkpCisJeworCQlJbmRleE9ubHlT Y2FuU3RhdGUgKmlvc3MgPSBjYXN0Tm9kZShJbmRleE9ubHlTY2FuU3RhdGUsIG5vZGUpOworCisJ CUluc3RyRmluYWxpemVDaGlsZCgmaW9zcy0+aW9zc19JbnN0cnVtZW50LT50YWJsZV9pbnN0ciwg Jm5vZGUtPmluc3RydW1lbnQtPmluc3RyKTsKKwl9CisKIAlJbnN0ckZpbmFsaXplQ2hpbGQoJm5v ZGUtPmluc3RydW1lbnQtPmluc3RyLCBwYXJlbnQpOwogCiAJcmV0dXJuIGZhbHNlOwpAQCAtODkx LDYgKzkwNSwzOCBAQCBFeGVjRmluYWxpemVXb3JrZXJJbnN0cnVtZW50YXRpb25fd2Fsa2VyKFBs YW5TdGF0ZSAqbm9kZSwgdm9pZCAqY29udGV4dCkKIAogCW51bV93b3JrZXJzID0gbm9kZS0+d29y a2VyX2luc3RydW1lbnQtPm51bV93b3JrZXJzOwogCisJLyoKKwkgKiBGb2xkIHBlci13b3JrZXIg SW5kZXhTY2FuL0luZGV4T25seVNjYW4gdGFibGUgYnVmZmVyIHN0YXRzIGludG8gdGhlCisJICog cGVyLXdvcmtlciBub2RlIHN0YXRzLCBtYXRjaGluZyB3aGF0IEV4ZWNGaW5hbGl6ZU5vZGVJbnN0 cnVtZW50YXRpb24KKwkgKiBkb2VzIGZvciB0aGUgbGVhZGVyLgorCSAqLworCWlmIChJc0Eobm9k ZSwgSW5kZXhTY2FuU3RhdGUpKQorCXsKKwkJSW5kZXhTY2FuU3RhdGUgKmlzcyA9IGNhc3ROb2Rl KEluZGV4U2NhblN0YXRlLCBub2RlKTsKKworCQlpZiAoaXNzLT5pc3NfU2hhcmVkSW5mbykKKwkJ eworCQkJaW50CQkJbndvcmtlcnMgPSBNaW4obnVtX3dvcmtlcnMsIGlzcy0+aXNzX1NoYXJlZElu Zm8tPm51bV93b3JrZXJzKTsKKworCQkJZm9yIChpbnQgbiA9IDA7IG4gPCBud29ya2Vyczsgbisr KQorCQkJCUluc3RyQWNjdW1TdGFjaygmbm9kZS0+d29ya2VyX2luc3RydW1lbnQtPmluc3RydW1l bnRbbl0uaW5zdHIsCisJCQkJCQkJCSZpc3MtPmlzc19TaGFyZWRJbmZvLT53aW5zdHJ1bWVudFtu XS50YWJsZV9pbnN0cik7CisJCX0KKwl9CisJZWxzZSBpZiAoSXNBKG5vZGUsIEluZGV4T25seVNj YW5TdGF0ZSkpCisJeworCQlJbmRleE9ubHlTY2FuU3RhdGUgKmlvc3MgPSBjYXN0Tm9kZShJbmRl eE9ubHlTY2FuU3RhdGUsIG5vZGUpOworCisJCWlmIChpb3NzLT5pb3NzX1NoYXJlZEluZm8pCisJ CXsKKwkJCWludAkJCW53b3JrZXJzID0gTWluKG51bV93b3JrZXJzLCBpb3NzLT5pb3NzX1NoYXJl ZEluZm8tPm51bV93b3JrZXJzKTsKKworCQkJZm9yIChpbnQgbiA9IDA7IG4gPCBud29ya2Vyczsg bisrKQorCQkJCUluc3RyQWNjdW1TdGFjaygmbm9kZS0+d29ya2VyX2luc3RydW1lbnQtPmluc3Ry dW1lbnRbbl0uaW5zdHIsCisJCQkJCQkJCSZpb3NzLT5pb3NzX1NoYXJlZEluZm8tPndpbnN0cnVt ZW50W25dLnRhYmxlX2luc3RyKTsKKwkJfQorCX0KKwogCS8qIEFjY3VtdWxhdGUgdGhpcyBub2Rl J3MgcGVyLXdvcmtlciBzdGF0cyB0byBwYXJlbnQncyBwZXItd29ya2VyIHN0YXRzICovCiAJaWYg KHBhcmVudCAmJiBwYXJlbnQtPndvcmtlcl9pbnN0cnVtZW50KQogCXsKZGlmZiAtLWdpdCBhL3Ny Yy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVCaXRtYXBJbmRleHNjYW4uYyBiL3NyYy9iYWNrZW5kL2V4 ZWN1dG9yL25vZGVCaXRtYXBJbmRleHNjYW4uYwppbmRleCA3MGM1NWVlNmQ2MS4uNjNlMjRhMGJj ZDQgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVCaXRtYXBJbmRleHNjYW4u YworKysgYi9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlQml0bWFwSW5kZXhzY2FuLmMKQEAgLTI3 Niw3ICsyNzYsNyBAQCBFeGVjSW5pdEJpdG1hcEluZGV4U2NhbihCaXRtYXBJbmRleFNjYW4gKm5v ZGUsIEVTdGF0ZSAqZXN0YXRlLCBpbnQgZWZsYWdzKQogCiAJLyogU2V0IHVwIGluc3RydW1lbnRh dGlvbiBvZiBiaXRtYXAgaW5kZXggc2NhbnMgaWYgcmVxdWVzdGVkICovCiAJaWYgKGVzdGF0ZS0+ ZXNfaW5zdHJ1bWVudCkKLQkJaW5kZXhzdGF0ZS0+Ymlzc19JbnN0cnVtZW50ID0gcGFsbG9jMF9v YmplY3QoSW5kZXhTY2FuSW5zdHJ1bWVudGF0aW9uKTsKKwkJaW5kZXhzdGF0ZS0+Ymlzc19JbnN0 cnVtZW50ID0gTWVtb3J5Q29udGV4dEFsbG9jWmVybyhlc3RhdGUtPmVzX2luc3RydW1lbnQtPmlu c3RyX2N4dCwgc2l6ZW9mKEluZGV4U2Nhbkluc3RydW1lbnRhdGlvbikpOwogCiAJLyogT3BlbiB0 aGUgaW5kZXggcmVsYXRpb24uICovCiAJbG9ja21vZGUgPSBleGVjX3J0X2ZldGNoKG5vZGUtPnNj YW4uc2NhbnJlbGlkLCBlc3RhdGUpLT5yZWxsb2NrbW9kZTsKZGlmZiAtLWdpdCBhL3NyYy9iYWNr ZW5kL2V4ZWN1dG9yL25vZGVJbmRleG9ubHlzY2FuLmMgYi9zcmMvYmFja2VuZC9leGVjdXRvci9u b2RlSW5kZXhvbmx5c2Nhbi5jCmluZGV4IGRlNjE1NGZkNTQxLi45ZTY0Y2UyYmQyZCAxMDA2NDQK LS0tIGEvc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZUluZGV4b25seXNjYW4uYworKysgYi9zcmMv YmFja2VuZC9leGVjdXRvci9ub2RlSW5kZXhvbmx5c2Nhbi5jCkBAIC02Nyw2ICs2Nyw3IEBAIElu ZGV4T25seU5leHQoSW5kZXhPbmx5U2NhblN0YXRlICpub2RlKQogCUluZGV4U2NhbkRlc2Mgc2Nh bmRlc2M7CiAJVHVwbGVUYWJsZVNsb3QgKnNsb3Q7CiAJSXRlbVBvaW50ZXIgdGlkOworCUluc3Ry dW1lbnRhdGlvbiAqdGFibGVfaW5zdHIgPSBOVUxMOwogCiAJLyoKIAkgKiBleHRyYWN0IG5lY2Vz c2FyeSBpbmZvcm1hdGlvbiBmcm9tIGluZGV4IHNjYW4gbm9kZQpAQCAtODMsNiArODQsOSBAQCBJ bmRleE9ubHlOZXh0KEluZGV4T25seVNjYW5TdGF0ZSAqbm9kZSkKIAllY29udGV4dCA9IG5vZGUt PnNzLnBzLnBzX0V4cHJDb250ZXh0OwogCXNsb3QgPSBub2RlLT5zcy5zc19TY2FuVHVwbGVTbG90 OwogCisJaWYgKG5vZGUtPmlvc3NfSW5zdHJ1bWVudCAmJiBub2RlLT5pb3NzX0luc3RydW1lbnQt PnRhYmxlX2luc3RyLm5lZWRfc3RhY2spCisJCXRhYmxlX2luc3RyID0gJm5vZGUtPmlvc3NfSW5z dHJ1bWVudC0+dGFibGVfaW5zdHI7CisKIAlpZiAoc2NhbmRlc2MgPT0gTlVMTCkKIAl7CiAJCS8q CkBAIC0xNjUsMTEgKzE2OSwyMiBAQCBJbmRleE9ubHlOZXh0KEluZGV4T25seVNjYW5TdGF0ZSAq bm9kZSkKIAkJCQkJCQlJdGVtUG9pbnRlckdldEJsb2NrTnVtYmVyKHRpZCksCiAJCQkJCQkJJm5v ZGUtPmlvc3NfVk1CdWZmZXIpKQogCQl7CisJCQlib29sCQlmb3VuZDsKKwogCQkJLyoKIAkJCSAq IFJhdHMsIHdlIGhhdmUgdG8gdmlzaXQgdGhlIGhlYXAgdG8gY2hlY2sgdmlzaWJpbGl0eS4KIAkJ CSAqLwogCQkJSW5zdHJDb3VudFR1cGxlczIobm9kZSwgMSk7Ci0JCQlpZiAoIWluZGV4X2ZldGNo X2hlYXAoc2NhbmRlc2MsIG5vZGUtPmlvc3NfVGFibGVTbG90KSkKKworCQkJaWYgKHRhYmxlX2lu c3RyKQorCQkJCUluc3RyUHVzaFN0YWNrKHRhYmxlX2luc3RyKTsKKworCQkJZm91bmQgPSBpbmRl eF9mZXRjaF9oZWFwKHNjYW5kZXNjLCBub2RlLT5pb3NzX1RhYmxlU2xvdCk7CisKKwkJCWlmICh0 YWJsZV9pbnN0cikKKwkJCQlJbnN0clBvcFN0YWNrKHRhYmxlX2luc3RyKTsKKworCQkJaWYgKCFm b3VuZCkKIAkJCQljb250aW51ZTsJCS8qIG5vIHZpc2libGUgdHVwbGUsIHRyeSBuZXh0IGluZGV4 IGVudHJ5ICovCiAKIAkJCUV4ZWNDbGVhclR1cGxlKG5vZGUtPmlvc3NfVGFibGVTbG90KTsKQEAg LTQzNiw2ICs0NTEsNyBAQCBFeGVjRW5kSW5kZXhPbmx5U2NhbihJbmRleE9ubHlTY2FuU3RhdGUg Km5vZGUpCiAJCSAqIHdoaWNoIHdpbGwgaGF2ZSBhIG5ldyBJbmRleE9ubHlTY2FuU3RhdGUgYW5k IHplcm9lZCBzdGF0cy4KIAkJICovCiAJCXdpbnN0cnVtZW50LT5uc2VhcmNoZXMgKz0gbm9kZS0+ aW9zc19JbnN0cnVtZW50LT5uc2VhcmNoZXM7CisJCUluc3RyQWNjdW1TdGFjaygmd2luc3RydW1l bnQtPnRhYmxlX2luc3RyLCAmbm9kZS0+aW9zc19JbnN0cnVtZW50LT50YWJsZV9pbnN0cik7CiAJ fQogCiAJLyoKQEAgLTYxMCw3ICs2MjYsMjEgQEAgRXhlY0luaXRJbmRleE9ubHlTY2FuKEluZGV4 T25seVNjYW4gKm5vZGUsIEVTdGF0ZSAqZXN0YXRlLCBpbnQgZWZsYWdzKQogCiAJLyogU2V0IHVw IGluc3RydW1lbnRhdGlvbiBvZiBpbmRleC1vbmx5IHNjYW5zIGlmIHJlcXVlc3RlZCAqLwogCWlm IChlc3RhdGUtPmVzX2luc3RydW1lbnQpCi0JCWluZGV4c3RhdGUtPmlvc3NfSW5zdHJ1bWVudCA9 IHBhbGxvYzBfb2JqZWN0KEluZGV4U2Nhbkluc3RydW1lbnRhdGlvbik7CisJeworCQlpbmRleHN0 YXRlLT5pb3NzX0luc3RydW1lbnQgPSBNZW1vcnlDb250ZXh0QWxsb2NaZXJvKGVzdGF0ZS0+ZXNf aW5zdHJ1bWVudC0+aW5zdHJfY3h0LCBzaXplb2YoSW5kZXhTY2FuSW5zdHJ1bWVudGF0aW9uKSk7 CisKKwkJLyoKKwkJICogVHJhY2sgdGFibGUgYW5kIGluZGV4IGFjY2VzcyBzZXBhcmF0ZWx5LiBX ZSBpbnRlbnRpb25hbGx5IGRvbid0CisJCSAqIGNvbGxlY3QgdGltaW5nIChldmVuIGlmIGVuYWJs ZWQpLCBzaW5jZSB3ZSBkb24ndCBuZWVkIGl0LCBhbmQKKwkJICogSW5kZXhPbmx5TmV4dCBjYWxs cyBJbnN0clB1c2hTdGFjayAvIEluc3RyUG9wU3RhY2sgKGluc3RlYWQgb2YgdGhlCisJCSAqIGZ1 bGwgSW5zdHJOb2RlKikgdG8gcmVkdWNlIG92ZXJoZWFkLgorCQkgKi8KKwkJaWYgKChlc3RhdGUt PmVzX2luc3RydW1lbnQtPmluc3RydW1lbnRfb3B0aW9ucyAmIElOU1RSVU1FTlRfQlVGRkVSUykg IT0gMCkKKwkJeworCQkJSW5zdHJJbml0T3B0aW9ucygmaW5kZXhzdGF0ZS0+aW9zc19JbnN0cnVt ZW50LT50YWJsZV9pbnN0ciwgSU5TVFJVTUVOVF9CVUZGRVJTKTsKKwkJCUluc3RyUXVlcnlSZW1l bWJlckNoaWxkKGVzdGF0ZS0+ZXNfaW5zdHJ1bWVudCwgJmluZGV4c3RhdGUtPmlvc3NfSW5zdHJ1 bWVudC0+dGFibGVfaW5zdHIpOworCQl9CisJfQogCiAJLyogT3BlbiB0aGUgaW5kZXggcmVsYXRp b24uICovCiAJbG9ja21vZGUgPSBleGVjX3J0X2ZldGNoKG5vZGUtPnNjYW4uc2NhbnJlbGlkLCBl c3RhdGUpLT5yZWxsb2NrbW9kZTsKQEAgLTg5OSw0ICs5MjksMTEgQEAgRXhlY0luZGV4T25seVNj YW5SZXRyaWV2ZUluc3RydW1lbnRhdGlvbihJbmRleE9ubHlTY2FuU3RhdGUgKm5vZGUpCiAJCVNo YXJlZEluZm8tPm51bV93b3JrZXJzICogc2l6ZW9mKEluZGV4U2Nhbkluc3RydW1lbnRhdGlvbik7 CiAJbm9kZS0+aW9zc19TaGFyZWRJbmZvID0gcGFsbG9jKHNpemUpOwogCW1lbWNweShub2RlLT5p b3NzX1NoYXJlZEluZm8sIFNoYXJlZEluZm8sIHNpemUpOworCisJLyogQWdncmVnYXRlIHdvcmtl cnMnIHRhYmxlIGJ1ZmZlci9XQUwgdXNhZ2UgaW50byBsZWFkZXIncyBlbnRyeSAqLworCWZvciAo aW50IGkgPSAwOyBpIDwgbm9kZS0+aW9zc19TaGFyZWRJbmZvLT5udW1fd29ya2VyczsgaSsrKQor CXsKKwkJSW5zdHJBY2N1bVN0YWNrKCZub2RlLT5pb3NzX0luc3RydW1lbnQtPnRhYmxlX2luc3Ry LAorCQkJCQkJJm5vZGUtPmlvc3NfU2hhcmVkSW5mby0+d2luc3RydW1lbnRbaV0udGFibGVfaW5z dHIpOworCX0KIH0KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVJbmRleHNj YW4uYyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVJbmRleHNjYW4uYwppbmRleCAxNjIwZDE0 NjA3MS4uMDJlZjlkMTI0YTMgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVJ bmRleHNjYW4uYworKysgYi9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlSW5kZXhzY2FuLmMKQEAg LTg1LDcgKzg1LDEwIEBAIEluZGV4TmV4dChJbmRleFNjYW5TdGF0ZSAqbm9kZSkKIAlFeHByQ29u dGV4dCAqZWNvbnRleHQ7CiAJU2NhbkRpcmVjdGlvbiBkaXJlY3Rpb247CiAJSW5kZXhTY2FuRGVz YyBzY2FuZGVzYzsKKwlJdGVtUG9pbnRlciB0aWQ7CiAJVHVwbGVUYWJsZVNsb3QgKnNsb3Q7CisJ Ym9vbAkJZm91bmQ7CisJSW5zdHJ1bWVudGF0aW9uICp0YWJsZV9pbnN0ciA9IE5VTEw7CiAKIAkv KgogCSAqIGV4dHJhY3QgbmVjZXNzYXJ5IGluZm9ybWF0aW9uIGZyb20gaW5kZXggc2NhbiBub2Rl CkBAIC0xMDIsNiArMTA1LDkgQEAgSW5kZXhOZXh0KEluZGV4U2NhblN0YXRlICpub2RlKQogCWVj b250ZXh0ID0gbm9kZS0+c3MucHMucHNfRXhwckNvbnRleHQ7CiAJc2xvdCA9IG5vZGUtPnNzLnNz X1NjYW5UdXBsZVNsb3Q7CiAKKwlpZiAobm9kZS0+aXNzX0luc3RydW1lbnQgJiYgbm9kZS0+aXNz X0luc3RydW1lbnQtPnRhYmxlX2luc3RyLm5lZWRfc3RhY2spCisJCXRhYmxlX2luc3RyID0gJm5v ZGUtPmlzc19JbnN0cnVtZW50LT50YWJsZV9pbnN0cjsKKwogCWlmIChzY2FuZGVzYyA9PSBOVUxM KQogCXsKIAkJLyoKQEAgLTEzMiw4ICsxMzgsMjQgQEAgSW5kZXhOZXh0KEluZGV4U2NhblN0YXRl ICpub2RlKQogCS8qCiAJICogb2ssIG5vdyB0aGF0IHdlIGhhdmUgd2hhdCB3ZSBuZWVkLCBmZXRj aCB0aGUgbmV4dCB0dXBsZS4KIAkgKi8KLQl3aGlsZSAoaW5kZXhfZ2V0bmV4dF9zbG90KHNjYW5k ZXNjLCBkaXJlY3Rpb24sIHNsb3QpKQorCXdoaWxlICgodGlkID0gaW5kZXhfZ2V0bmV4dF90aWQo c2NhbmRlc2MsIGRpcmVjdGlvbikpICE9IE5VTEwpCiAJeworCQlpZiAodGFibGVfaW5zdHIpCisJ CQlJbnN0clB1c2hTdGFjayh0YWJsZV9pbnN0cik7CisKKwkJZm9yICg7OykKKwkJeworCQkJZm91 bmQgPSBpbmRleF9mZXRjaF9oZWFwKHNjYW5kZXNjLCBzbG90KTsKKwkJCWlmIChmb3VuZCB8fCAh c2NhbmRlc2MtPnhzX2hlYXBfY29udGludWUpCisJCQkJYnJlYWs7CisJCX0KKworCQlpZiAodGFi bGVfaW5zdHIpCisJCQlJbnN0clBvcFN0YWNrKHRhYmxlX2luc3RyKTsKKworCQlpZiAodW5saWtl bHkoIWZvdW5kKSkKKwkJCWNvbnRpbnVlOworCiAJCUNIRUNLX0ZPUl9JTlRFUlJVUFRTKCk7CiAK IAkJLyoKQEAgLTE4MSw2ICsyMDMsNyBAQCBJbmRleE5leHRXaXRoUmVvcmRlcihJbmRleFNjYW5T dGF0ZSAqbm9kZSkKIAlEYXR1bQkgICAqbGFzdGZldGNoZWRfdmFsczsKIAlib29sCSAgICpsYXN0 ZmV0Y2hlZF9udWxsczsKIAlpbnQJCQljbXA7CisJSW5zdHJ1bWVudGF0aW9uICp0YWJsZV9pbnN0 ciA9IE5VTEw7CiAKIAllc3RhdGUgPSBub2RlLT5zcy5wcy5zdGF0ZTsKIApAQCAtMjAwLDYgKzIy Myw5IEBAIEluZGV4TmV4dFdpdGhSZW9yZGVyKEluZGV4U2NhblN0YXRlICpub2RlKQogCWVjb250 ZXh0ID0gbm9kZS0+c3MucHMucHNfRXhwckNvbnRleHQ7CiAJc2xvdCA9IG5vZGUtPnNzLnNzX1Nj YW5UdXBsZVNsb3Q7CiAKKwlpZiAobm9kZS0+aXNzX0luc3RydW1lbnQgJiYgbm9kZS0+aXNzX0lu c3RydW1lbnQtPnRhYmxlX2luc3RyLm5lZWRfc3RhY2spCisJCXRhYmxlX2luc3RyID0gJm5vZGUt Pmlzc19JbnN0cnVtZW50LT50YWJsZV9pbnN0cjsKKwogCWlmIChzY2FuZGVzYyA9PSBOVUxMKQog CXsKIAkJLyoKQEAgLTI2MywzNiArMjg5LDY3IEBAIEluZGV4TmV4dFdpdGhSZW9yZGVyKEluZGV4 U2NhblN0YXRlICpub2RlKQogCQl9CiAKIAkJLyoKLQkJICogRmV0Y2ggbmV4dCB0dXBsZSBmcm9t IHRoZSBpbmRleC4KKwkJICogRmV0Y2ggbmV4dCB2YWxpZCB0dXBsZSBmcm9tIHRoZSBpbmRleC4K IAkJICovCi1uZXh0X2luZGV4dHVwbGU6Ci0JCWlmICghaW5kZXhfZ2V0bmV4dF9zbG90KHNjYW5k ZXNjLCBGb3J3YXJkU2NhbkRpcmVjdGlvbiwgc2xvdCkpCisJCWZvciAoOzspCiAJCXsKKwkJCUl0 ZW1Qb2ludGVyIHRpZDsKKwkJCWJvb2wJCWZvdW5kOworCisJCQkvKiBUaW1lIHRvIGZldGNoIHRo ZSBuZXh0IFRJRCBmcm9tIHRoZSBpbmRleCAqLworCQkJdGlkID0gaW5kZXhfZ2V0bmV4dF90aWQo c2NhbmRlc2MsIEZvcndhcmRTY2FuRGlyZWN0aW9uKTsKKworCQkJLyogSWYgd2UncmUgb3V0IG9m IGluZGV4IGVudHJpZXMsIHdlJ3JlIGRvbmUgKi8KKwkJCWlmICh0aWQgPT0gTlVMTCkKKwkJCXsK KwkJCQkvKgorCQkJCSAqIE5vIG1vcmUgdHVwbGVzIGZyb20gdGhlIGluZGV4LiAgQnV0IHdlIHN0 aWxsIG5lZWQgdG8gZHJhaW4KKwkJCQkgKiBhbnkgcmVtYWluaW5nIHR1cGxlcyBmcm9tIHRoZSBx dWV1ZSBiZWZvcmUgd2UncmUgZG9uZS4KKwkJCQkgKi8KKwkJCQlub2RlLT5pc3NfUmVhY2hlZEVu ZCA9IHRydWU7CisJCQkJYnJlYWs7CisJCQl9CisKKwkJCUFzc2VydChJdGVtUG9pbnRlckVxdWFs cyh0aWQsICZzY2FuZGVzYy0+eHNfaGVhcHRpZCkpOworCisJCQlpZiAodGFibGVfaW5zdHIpCisJ CQkJSW5zdHJQdXNoU3RhY2sodGFibGVfaW5zdHIpOworCisJCQlmb3IgKDs7KQorCQkJeworCQkJ CWZvdW5kID0gaW5kZXhfZmV0Y2hfaGVhcChzY2FuZGVzYywgc2xvdCk7CisJCQkJaWYgKGZvdW5k IHx8ICFzY2FuZGVzYy0+eHNfaGVhcF9jb250aW51ZSkKKwkJCQkJYnJlYWs7CisJCQl9CisKKwkJ CWlmICh0YWJsZV9pbnN0cikKKwkJCQlJbnN0clBvcFN0YWNrKHRhYmxlX2luc3RyKTsKKwogCQkJ LyoKLQkJCSAqIE5vIG1vcmUgdHVwbGVzIGZyb20gdGhlIGluZGV4LiAgQnV0IHdlIHN0aWxsIG5l ZWQgdG8gZHJhaW4gYW55Ci0JCQkgKiByZW1haW5pbmcgdHVwbGVzIGZyb20gdGhlIHF1ZXVlIGJl Zm9yZSB3ZSdyZSBkb25lLgorCQkJICogSWYgdGhlIGluZGV4IHdhcyBsb3NzeSwgd2UgaGF2ZSB0 byByZWNoZWNrIHRoZSBpbmRleCBxdWFscyBhbmQKKwkJCSAqIE9SREVSIEJZIGV4cHJlc3Npb25z IHVzaW5nIHRoZSBmZXRjaGVkIHR1cGxlLgogCQkJICovCi0JCQlub2RlLT5pc3NfUmVhY2hlZEVu ZCA9IHRydWU7Ci0JCQljb250aW51ZTsKLQkJfQotCi0JCS8qCi0JCSAqIElmIHRoZSBpbmRleCB3 YXMgbG9zc3ksIHdlIGhhdmUgdG8gcmVjaGVjayB0aGUgaW5kZXggcXVhbHMgYW5kCi0JCSAqIE9S REVSIEJZIGV4cHJlc3Npb25zIHVzaW5nIHRoZSBmZXRjaGVkIHR1cGxlLgotCQkgKi8KLQkJaWYg KHNjYW5kZXNjLT54c19yZWNoZWNrKQotCQl7Ci0JCQllY29udGV4dC0+ZWN4dF9zY2FudHVwbGUg PSBzbG90OwotCQkJaWYgKCFFeGVjUXVhbEFuZFJlc2V0KG5vZGUtPmluZGV4cXVhbG9yaWcsIGVj b250ZXh0KSkKKwkJCWlmIChmb3VuZCAmJiBzY2FuZGVzYy0+eHNfcmVjaGVjaykKIAkJCXsKLQkJ CQkvKiBGYWlscyByZWNoZWNrLCBzbyBkcm9wIGl0IGFuZCBsb29wIGJhY2sgZm9yIGFub3RoZXIg Ki8KLQkJCQlJbnN0ckNvdW50RmlsdGVyZWQyKG5vZGUsIDEpOwotCQkJCS8qIGFsbG93IHRoaXMg bG9vcCB0byBiZSBjYW5jZWxsYWJsZSAqLwotCQkJCUNIRUNLX0ZPUl9JTlRFUlJVUFRTKCk7Ci0J CQkJZ290byBuZXh0X2luZGV4dHVwbGU7CisJCQkJZWNvbnRleHQtPmVjeHRfc2NhbnR1cGxlID0g c2xvdDsKKwkJCQlpZiAoIUV4ZWNRdWFsQW5kUmVzZXQobm9kZS0+aW5kZXhxdWFsb3JpZywgZWNv bnRleHQpKQorCQkJCXsKKwkJCQkJLyogRmFpbHMgcmVjaGVjaywgc28gZHJvcCBpdCBhbmQgbG9v cCBiYWNrIGZvciBhbm90aGVyICovCisJCQkJCUluc3RyQ291bnRGaWx0ZXJlZDIobm9kZSwgMSk7 CisJCQkJCS8qIGFsbG93IHRoaXMgbG9vcCB0byBiZSBjYW5jZWxsYWJsZSAqLworCQkJCQlDSEVD S19GT1JfSU5URVJSVVBUUygpOworCQkJCQljb250aW51ZTsKKwkJCQl9CiAJCQl9CisKKwkJCWlm IChmb3VuZCkKKwkJCQlicmVhazsKIAkJfQogCisJCS8qIE5vIG1vcmUgaW5kZXggZW50cmllcywg cmUtcnVuIHRvIGNsZWFyIHRoZSByZW9yZGVyIHF1ZXVlICovCisJCWlmIChub2RlLT5pc3NfUmVh Y2hlZEVuZCkKKwkJCWNvbnRpbnVlOworCiAJCWlmIChzY2FuZGVzYy0+eHNfcmVjaGVja29yZGVy YnkpCiAJCXsKIAkJCWVjb250ZXh0LT5lY3h0X3NjYW50dXBsZSA9IHNsb3Q7CkBAIC04MTgsNiAr ODc1LDcgQEAgRXhlY0VuZEluZGV4U2NhbihJbmRleFNjYW5TdGF0ZSAqbm9kZSkKIAkJICogd2hp Y2ggd2lsbCBoYXZlIGEgbmV3IEluZGV4T25seVNjYW5TdGF0ZSBhbmQgemVyb2VkIHN0YXRzLgog CQkgKi8KIAkJd2luc3RydW1lbnQtPm5zZWFyY2hlcyArPSBub2RlLT5pc3NfSW5zdHJ1bWVudC0+ bnNlYXJjaGVzOworCQlJbnN0ckFjY3VtU3RhY2soJndpbnN0cnVtZW50LT50YWJsZV9pbnN0ciwg Jm5vZGUtPmlzc19JbnN0cnVtZW50LT50YWJsZV9pbnN0cik7CiAJfQogCiAJLyoKQEAgLTk4MCw3 ICsxMDM4LDIxIEBAIEV4ZWNJbml0SW5kZXhTY2FuKEluZGV4U2NhbiAqbm9kZSwgRVN0YXRlICpl c3RhdGUsIGludCBlZmxhZ3MpCiAKIAkvKiBTZXQgdXAgaW5zdHJ1bWVudGF0aW9uIG9mIGluZGV4 IHNjYW5zIGlmIHJlcXVlc3RlZCAqLwogCWlmIChlc3RhdGUtPmVzX2luc3RydW1lbnQpCi0JCWlu ZGV4c3RhdGUtPmlzc19JbnN0cnVtZW50ID0gcGFsbG9jMF9vYmplY3QoSW5kZXhTY2FuSW5zdHJ1 bWVudGF0aW9uKTsKKwl7CisJCWluZGV4c3RhdGUtPmlzc19JbnN0cnVtZW50ID0gTWVtb3J5Q29u dGV4dEFsbG9jWmVybyhlc3RhdGUtPmVzX2luc3RydW1lbnQtPmluc3RyX2N4dCwgc2l6ZW9mKElu ZGV4U2Nhbkluc3RydW1lbnRhdGlvbikpOworCisJCS8qCisJCSAqIFRyYWNrIHRhYmxlIGFuZCBp bmRleCBhY2Nlc3Mgc2VwYXJhdGVseS4gV2UgaW50ZW50aW9uYWxseSBkb24ndAorCQkgKiBjb2xs ZWN0IHRpbWluZyAoZXZlbiBpZiBlbmFibGVkKSwgc2luY2Ugd2UgZG9uJ3QgbmVlZCBpdCwgYW5k CisJCSAqIEluZGV4TmV4dCAvIEluZGV4TmV4dFdpdGhSZW9yZGVyIGNhbGwgSW5zdHJQdXNoU3Rh Y2sgLworCQkgKiBJbnN0clBvcFN0YWNrIChpbnN0ZWFkIG9mIHRoZSBmdWxsIEluc3RyTm9kZSop IHRvIHJlZHVjZSBvdmVyaGVhZC4KKwkJICovCisJCWlmICgoZXN0YXRlLT5lc19pbnN0cnVtZW50 LT5pbnN0cnVtZW50X29wdGlvbnMgJiBJTlNUUlVNRU5UX0JVRkZFUlMpICE9IDApCisJCXsKKwkJ CUluc3RySW5pdE9wdGlvbnMoJmluZGV4c3RhdGUtPmlzc19JbnN0cnVtZW50LT50YWJsZV9pbnN0 ciwgSU5TVFJVTUVOVF9CVUZGRVJTKTsKKwkJCUluc3RyUXVlcnlSZW1lbWJlckNoaWxkKGVzdGF0 ZS0+ZXNfaW5zdHJ1bWVudCwgJmluZGV4c3RhdGUtPmlzc19JbnN0cnVtZW50LT50YWJsZV9pbnN0 cik7CisJCX0KKwl9CiAKIAkvKiBPcGVuIHRoZSBpbmRleCByZWxhdGlvbi4gKi8KIAlsb2NrbW9k ZSA9IGV4ZWNfcnRfZmV0Y2gobm9kZS0+c2Nhbi5zY2FucmVsaWQsIGVzdGF0ZSktPnJlbGxvY2tt b2RlOwpAQCAtMTgzNCw0ICsxOTA2LDExIEBAIEV4ZWNJbmRleFNjYW5SZXRyaWV2ZUluc3RydW1l bnRhdGlvbihJbmRleFNjYW5TdGF0ZSAqbm9kZSkKIAkJU2hhcmVkSW5mby0+bnVtX3dvcmtlcnMg KiBzaXplb2YoSW5kZXhTY2FuSW5zdHJ1bWVudGF0aW9uKTsKIAlub2RlLT5pc3NfU2hhcmVkSW5m byA9IHBhbGxvYyhzaXplKTsKIAltZW1jcHkobm9kZS0+aXNzX1NoYXJlZEluZm8sIFNoYXJlZElu Zm8sIHNpemUpOworCisJLyogQWdncmVnYXRlIHdvcmtlcnMnIHRhYmxlIGJ1ZmZlci9XQUwgdXNh Z2UgaW50byBsZWFkZXIncyBlbnRyeSAqLworCWZvciAoaW50IGkgPSAwOyBpIDwgbm9kZS0+aXNz X1NoYXJlZEluZm8tPm51bV93b3JrZXJzOyBpKyspCisJeworCQlJbnN0ckFjY3VtU3RhY2soJm5v ZGUtPmlzc19JbnN0cnVtZW50LT50YWJsZV9pbnN0ciwKKwkJCQkJCSZub2RlLT5pc3NfU2hhcmVk SW5mby0+d2luc3RydW1lbnRbaV0udGFibGVfaW5zdHIpOworCX0KIH0KZGlmZiAtLWdpdCBhL3Ny Yy9pbmNsdWRlL2V4ZWN1dG9yL2luc3RydW1lbnRfbm9kZS5oIGIvc3JjL2luY2x1ZGUvZXhlY3V0 b3IvaW5zdHJ1bWVudF9ub2RlLmgKaW5kZXggMmEwZmYzNzdhNzMuLmUyMzE1Y2VmMzg0IDEwMDY0 NAotLS0gYS9zcmMvaW5jbHVkZS9leGVjdXRvci9pbnN0cnVtZW50X25vZGUuaAorKysgYi9zcmMv aW5jbHVkZS9leGVjdXRvci9pbnN0cnVtZW50X25vZGUuaApAQCAtMTgsNiArMTgsOCBAQAogI2lm bmRlZiBJTlNUUlVNRU5UX05PREVfSAogI2RlZmluZSBJTlNUUlVNRU5UX05PREVfSAogCisjaW5j bHVkZSAiZXhlY3V0b3IvaW5zdHJ1bWVudC5oIgorCiAKIC8qIC0tLS0tLS0tLS0tLS0tLS0tLS0t LQogICoJSW5zdHJ1bWVudGF0aW9uIGluZm9ybWF0aW9uIGZvciBhZ2dyZWdhdGUgZnVuY3Rpb24g ZXhlY3V0aW9uCkBAIC00OCw2ICs1MCw5IEBAIHR5cGVkZWYgc3RydWN0IEluZGV4U2Nhbkluc3Ry dW1lbnRhdGlvbgogewogCS8qIEluZGV4IHNlYXJjaCBjb3VudCAoaW5jcmVtZW50ZWQgd2l0aCBw Z3N0YXRfY291bnRfaW5kZXhfc2NhbiBjYWxsKSAqLwogCXVpbnQ2NAkJbnNlYXJjaGVzOworCisJ LyogSW5zdHJ1bWVudGF0aW9uIHV0aWxpemVkIGZvciB0cmFja2luZyBidWZmZXIgdXNhZ2UgZHVy aW5nIHRhYmxlIGFjY2VzcyAqLworCUluc3RydW1lbnRhdGlvbiB0YWJsZV9pbnN0cjsKIH0gSW5k ZXhTY2FuSW5zdHJ1bWVudGF0aW9uOwogCiAvKgotLSAKMi40Ny4xCgo= --0000000000006d0cb0064eb5be7d Content-Type: application/octet-stream; name="v13-0012-Add-test_session_buffer_usage-test-module.patch" Content-Disposition: attachment; filename="v13-0012-Add-test_session_buffer_usage-test-module.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mnlqag8g11 RnJvbSBmZjcxZWE2NTM1OWFmNGNjMWM2YjhkZjRkOTAxN2RhNWZlODdlNGI3IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBMdWthcyBGaXR0bCA8bHVrYXNAZml0dGwuY29tPgpEYXRlOiBT YXQsIDcgTWFyIDIwMjYgMTE6NDY6NDEgLTA4MDAKU3ViamVjdDogW1BBVENIIHYxMyAxMi8xMl0g QWRkIHRlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UgdGVzdCBtb2R1bGUKClRoaXMgaXMgaW50ZW5k ZWQgZm9yIHRlc3RpbmcgaW5zdHJ1bWVudGF0aW9uIHJlbGF0ZWQgbG9naWMgYXMgaXQgcGVydGFp bnMKdG8gdGhlIHRvcCBsZXZlbCBzdGFjayB0aGF0IGlzIG1haW50YWluZWQgYXMgYSBydW5uaW5n IHRvdGFsLiBUaGVyZSBpcwpjdXJyZW50bHkgbm8gaW4tY29yZSB1c2VyIHRoYXQgdXRpbGl6ZXMg dGhlIHRvcC1sZXZlbCB2YWx1ZXMgaW4gdGhpcwptYW5uZXIsIGFuZCBlc3BlY2lhbGx5IGR1cmlu ZyBhYm9ydCBzaXR1YXRpb25zIHRoaXMgaGVscHMgZW5zdXJlIHdlIGRvbid0Cmxvc2UgYWN0aXZp dHkgZHVlIHRvIGluY29ycmVjdCBoYW5kbGluZyBvZiB1bmZpbmFsaXplZCBub2RlIHN0YWNrcy4K LS0tCiBzcmMvdGVzdC9tb2R1bGVzL01ha2VmaWxlICAgICAgICAgICAgICAgICAgICAgfCAgIDEg Kwogc3JjL3Rlc3QvbW9kdWxlcy9tZXNvbi5idWlsZCAgICAgICAgICAgICAgICAgIHwgICAxICsK IC4uLi90ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlL01ha2VmaWxlICAgICAgICB8ICAyMyArKwog Li4uL2V4cGVjdGVkL3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2Uub3V0ICAgIHwgMzQyICsrKysr KysrKysrKysrKysrKwogLi4uL3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UvbWVzb24uYnVpbGQg ICAgIHwgIDMzICsrCiAuLi4vc3FsL3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2Uuc3FsICAgICAg ICAgfCAyNDUgKysrKysrKysrKysrKwogLi4uL3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UtLTEu MC5zcWwgICAgICAgIHwgIDMxICsrCiAuLi4vdGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZS5jICAg ICAgICAgICAgICAgfCAgOTUgKysrKysKIC4uLi90ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlLmNv bnRyb2wgICAgICAgICB8ICAgNSArCiA5IGZpbGVzIGNoYW5nZWQsIDc3NiBpbnNlcnRpb25zKCsp CiBjcmVhdGUgbW9kZSAxMDA2NDQgc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X3Nlc3Npb25fYnVmZmVy X3VzYWdlL01ha2VmaWxlCiBjcmVhdGUgbW9kZSAxMDA2NDQgc3JjL3Rlc3QvbW9kdWxlcy90ZXN0 X3Nlc3Npb25fYnVmZmVyX3VzYWdlL2V4cGVjdGVkL3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2Uu b3V0CiBjcmVhdGUgbW9kZSAxMDA2NDQgc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X3Nlc3Npb25fYnVm ZmVyX3VzYWdlL21lc29uLmJ1aWxkCiBjcmVhdGUgbW9kZSAxMDA2NDQgc3JjL3Rlc3QvbW9kdWxl cy90ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlL3NxbC90ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdl LnNxbAogY3JlYXRlIG1vZGUgMTAwNjQ0IHNyYy90ZXN0L21vZHVsZXMvdGVzdF9zZXNzaW9uX2J1 ZmZlcl91c2FnZS90ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlLS0xLjAuc3FsCiBjcmVhdGUgbW9k ZSAxMDA2NDQgc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlL3Rlc3Rf c2Vzc2lvbl9idWZmZXJfdXNhZ2UuYwogY3JlYXRlIG1vZGUgMTAwNjQ0IHNyYy90ZXN0L21vZHVs ZXMvdGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZS90ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlLmNv bnRyb2wKCmRpZmYgLS1naXQgYS9zcmMvdGVzdC9tb2R1bGVzL01ha2VmaWxlIGIvc3JjL3Rlc3Qv bW9kdWxlcy9NYWtlZmlsZQppbmRleCA4NjRiNDA3YWJjZi4uYzVhY2UxNjJmZTIgMTAwNjQ0Ci0t LSBhL3NyYy90ZXN0L21vZHVsZXMvTWFrZWZpbGUKKysrIGIvc3JjL3Rlc3QvbW9kdWxlcy9NYWtl ZmlsZQpAQCAtNDgsNiArNDgsNyBAQCBTVUJESVJTID0gXAogCQkgIHRlc3RfcmVzb3duZXIgXAog CQkgIHRlc3RfcmxzX2hvb2tzIFwKIAkJICB0ZXN0X3Nhc2xwcmVwIFwKKwkJICB0ZXN0X3Nlc3Np b25fYnVmZmVyX3VzYWdlIFwKIAkJICB0ZXN0X3NobV9tcSBcCiAJCSAgdGVzdF9zbHJ1IFwKIAkJ ICB0ZXN0X3RpZHN0b3JlIFwKZGlmZiAtLWdpdCBhL3NyYy90ZXN0L21vZHVsZXMvbWVzb24uYnVp bGQgYi9zcmMvdGVzdC9tb2R1bGVzL21lc29uLmJ1aWxkCmluZGV4IGU1YWNhY2Q1MDgzLi44MDJj YzkzZDcxYSAxMDA2NDQKLS0tIGEvc3JjL3Rlc3QvbW9kdWxlcy9tZXNvbi5idWlsZAorKysgYi9z cmMvdGVzdC9tb2R1bGVzL21lc29uLmJ1aWxkCkBAIC00OSw2ICs0OSw3IEBAIHN1YmRpcigndGVz dF9yZWdleCcpCiBzdWJkaXIoJ3Rlc3RfcmVzb3duZXInKQogc3ViZGlyKCd0ZXN0X3Jsc19ob29r cycpCiBzdWJkaXIoJ3Rlc3Rfc2FzbHByZXAnKQorc3ViZGlyKCd0ZXN0X3Nlc3Npb25fYnVmZmVy X3VzYWdlJykKIHN1YmRpcigndGVzdF9zaG1fbXEnKQogc3ViZGlyKCd0ZXN0X3NscnUnKQogc3Vi ZGlyKCd0ZXN0X3RpZHN0b3JlJykKZGlmZiAtLWdpdCBhL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9z ZXNzaW9uX2J1ZmZlcl91c2FnZS9NYWtlZmlsZSBiL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9zZXNz aW9uX2J1ZmZlcl91c2FnZS9NYWtlZmlsZQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMC4uMTI1MmIyMjJjYjkKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvdGVzdC9tb2R1bGVz L3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UvTWFrZWZpbGUKQEAgLTAsMCArMSwyMyBAQAorIyBz cmMvdGVzdC9tb2R1bGVzL3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UvTWFrZWZpbGUKKworTU9E VUxFX2JpZyA9IHRlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UKK09CSlMgPSBcCisJJChXSU4zMlJF UykgXAorCXRlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UubworCitFWFRFTlNJT04gPSB0ZXN0X3Nl c3Npb25fYnVmZmVyX3VzYWdlCitEQVRBID0gdGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZS0tMS4w LnNxbAorUEdGSUxFREVTQyA9ICJ0ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlIC0gc2hvdyBidWZm ZXIgdXNhZ2Ugc3RhdGlzdGljcyBmb3IgdGhlIGN1cnJlbnQgc2Vzc2lvbiIKKworUkVHUkVTUyA9 IHRlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UKKworaWZkZWYgVVNFX1BHWFMKK1BHX0NPTkZJRyA9 IHBnX2NvbmZpZworUEdYUyA6PSAkKHNoZWxsICQoUEdfQ09ORklHKSAtLXBneHMpCitpbmNsdWRl ICQoUEdYUykKK2Vsc2UKK3N1YmRpciA9IHNyYy90ZXN0L21vZHVsZXMvdGVzdF9zZXNzaW9uX2J1 ZmZlcl91c2FnZQordG9wX2J1aWxkZGlyID0gLi4vLi4vLi4vLi4KK2luY2x1ZGUgJCh0b3BfYnVp bGRkaXIpL3NyYy9NYWtlZmlsZS5nbG9iYWwKK2luY2x1ZGUgJCh0b3Bfc3JjZGlyKS9jb250cmli L2NvbnRyaWItZ2xvYmFsLm1rCitlbmRpZgpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvbW9kdWxlcy90 ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlL2V4cGVjdGVkL3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNh Z2Uub3V0IGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlL2V4cGVj dGVkL3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2Uub3V0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwLi41ZjdkMzQ5ODcxYQotLS0gL2Rldi9udWxsCisrKyBiL3NyYy90ZXN0 L21vZHVsZXMvdGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZS9leHBlY3RlZC90ZXN0X3Nlc3Npb25f YnVmZmVyX3VzYWdlLm91dApAQCAtMCwwICsxLDM0MiBAQAorTE9BRCAndGVzdF9zZXNzaW9uX2J1 ZmZlcl91c2FnZSc7CitDUkVBVEUgRVhURU5TSU9OIHRlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2U7 CistLSBWZXJpZnkgYWxsIGNvbHVtbnMgYXJlIG5vbi1uZWdhdGl2ZQorU0VMRUNUIGNvdW50KCop ID0gMSBBUyBvayBGUk9NIHRlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UoKQorV0hFUkUgc2hhcmVk X2Jsa3NfaGl0ID49IDAgQU5EIHNoYXJlZF9ibGtzX3JlYWQgPj0gMAorICBBTkQgc2hhcmVkX2Js a3NfZGlydGllZCA+PSAwIEFORCBzaGFyZWRfYmxrc193cml0dGVuID49IDAKKyAgQU5EIGxvY2Fs X2Jsa3NfaGl0ID49IDAgQU5EIGxvY2FsX2Jsa3NfcmVhZCA+PSAwCisgIEFORCBsb2NhbF9ibGtz X2RpcnRpZWQgPj0gMCBBTkQgbG9jYWxfYmxrc193cml0dGVuID49IDAKKyAgQU5EIHRlbXBfYmxr c19yZWFkID49IDAgQU5EIHRlbXBfYmxrc193cml0dGVuID49IDAKKyAgQU5EIHNoYXJlZF9ibGtf cmVhZF90aW1lID49IDAgQU5EIHNoYXJlZF9ibGtfd3JpdGVfdGltZSA+PSAwCisgIEFORCBsb2Nh bF9ibGtfcmVhZF90aW1lID49IDAgQU5EIGxvY2FsX2Jsa193cml0ZV90aW1lID49IDAKKyAgQU5E IHRlbXBfYmxrX3JlYWRfdGltZSA+PSAwIEFORCB0ZW1wX2Jsa193cml0ZV90aW1lID49IDA7Cisg b2sgCistLS0tCisgdAorKDEgcm93KQorCistLSBWZXJpZnkgY291bnRlcnMgaW5jcmVhc2UgYWZ0 ZXIgYnVmZmVyIGFjdGl2aXR5CitTRUxFQ1QgdGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZV9yZXNl dCgpOworIHRlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2VfcmVzZXQgCistLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0KKyAKKygxIHJvdykKKworQ1JFQVRFIFRFTVAgVEFCTEUgdGVzdF9i dWZfYWN0aXZpdHkgKGlkIGludCwgZGF0YSB0ZXh0KTsKK0lOU0VSVCBJTlRPIHRlc3RfYnVmX2Fj dGl2aXR5IFNFTEVDVCBpLCByZXBlYXQoJ3gnLCAxMDApIEZST00gZ2VuZXJhdGVfc2VyaWVzKDEs IDEwMDApIEFTIGk7CitTRUxFQ1QgY291bnQoKikgRlJPTSB0ZXN0X2J1Zl9hY3Rpdml0eTsKKyBj b3VudCAKKy0tLS0tLS0KKyAgMTAwMAorKDEgcm93KQorCitTRUxFQ1QgbG9jYWxfYmxrc19oaXQg KyBsb2NhbF9ibGtzX3JlYWQgPiAwIEFTIGJsb2Nrc19pbmNyZWFzZWQKK0ZST00gdGVzdF9zZXNz aW9uX2J1ZmZlcl91c2FnZSgpOworIGJsb2Nrc19pbmNyZWFzZWQgCistLS0tLS0tLS0tLS0tLS0t LS0KKyB0CisoMSByb3cpCisKK0RST1AgVEFCTEUgdGVzdF9idWZfYWN0aXZpdHk7CistLSBQYXJh bGxlbCBxdWVyeSB0ZXN0CitDUkVBVEUgVEFCTEUgcGFyX2RjX3RhYiAoYSBpbnQsIGIgY2hhcigy MDApKTsKK0lOU0VSVCBJTlRPIHBhcl9kY190YWIgU0VMRUNUIGksIHJlcGVhdCgneCcsIDIwMCkg RlJPTSBnZW5lcmF0ZV9zZXJpZXMoMSwgNTAwMCkgQVMgaTsKK1NFTEVDVCBjb3VudCgqKSBGUk9N IHBhcl9kY190YWI7CisgY291bnQgCistLS0tLS0tCisgIDUwMDAKKygxIHJvdykKKworLS0gTWVh c3VyZSBzZXJpYWwgc2NhbiBkZWx0YSAobGVhZGVyIGRvZXMgYWxsIHRoZSB3b3JrKQorU0VUIG1h eF9wYXJhbGxlbF93b3JrZXJzX3Blcl9nYXRoZXIgPSAwOworU0VMRUNUIHRlc3Rfc2Vzc2lvbl9i dWZmZXJfdXNhZ2VfcmVzZXQoKTsKKyB0ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlX3Jlc2V0IAor LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgCisoMSByb3cpCisKK1NFTEVDVCBj b3VudCgqKSBGUk9NIHBhcl9kY190YWI7CisgY291bnQgCistLS0tLS0tCisgIDUwMDAKKygxIHJv dykKKworQ1JFQVRFIFRFTVAgVEFCTEUgZGNfc2VyaWFsX3Jlc3VsdCBBUworU0VMRUNUIHNoYXJl ZF9ibGtzX2hpdCBBUyBzZXJpYWxfZGVsdGEgRlJPTSB0ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdl KCk7CistLSBNZWFzdXJlIHBhcmFsbGVsIHNjYW4gZGVsdGEgd2l0aCBsZWFkZXIgTk9UIHBhcnRp Y2lwYXRpbmcgaW4gc2Nhbm5pbmcuCistLSBXb3JrZXJzIGRvIGFsbCB0YWJsZSBzY2FubmluZzsg bGVhZGVyIG9ubHkgcnVucyB0aGUgR2F0aGVyIG5vZGUuCitTRVQgcGFyYWxsZWxfc2V0dXBfY29z dCA9IDA7CitTRVQgcGFyYWxsZWxfdHVwbGVfY29zdCA9IDA7CitTRVQgbWluX3BhcmFsbGVsX3Rh YmxlX3NjYW5fc2l6ZSA9IDA7CitTRVQgbWF4X3BhcmFsbGVsX3dvcmtlcnNfcGVyX2dhdGhlciA9 IDI7CitTRVQgcGFyYWxsZWxfbGVhZGVyX3BhcnRpY2lwYXRpb24gPSBvZmY7CitTRUxFQ1QgdGVz dF9zZXNzaW9uX2J1ZmZlcl91c2FnZV9yZXNldCgpOworIHRlc3Rfc2Vzc2lvbl9idWZmZXJfdXNh Z2VfcmVzZXQgCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAKKygxIHJvdykK KworU0VMRUNUIGNvdW50KCopIEZST00gcGFyX2RjX3RhYjsKKyBjb3VudCAKKy0tLS0tLS0KKyAg NTAwMAorKDEgcm93KQorCistLSBDb25maXJtIHdlIGdvdCBhIHNpbWlsYXIgaGl0IGNvdW50ZXIg dGhyb3VnaCBwYXJhbGxlbCB3b3JrZXIgYWNjdW11bGF0aW9uCitTRUxFQ1Qgc2hhcmVkX2Jsa3Nf aGl0ID4gcy5zZXJpYWxfZGVsdGEgLyAyIEFORCBzaGFyZWRfYmxrc19oaXQgPCBzLnNlcmlhbF9k ZWx0YSAqIDIKKyAgICAgICBBUyBsZWFkZXJfYnVmZmVyc19tYXRjaAorRlJPTSB0ZXN0X3Nlc3Np b25fYnVmZmVyX3VzYWdlKCksIGRjX3NlcmlhbF9yZXN1bHQgczsKKyBsZWFkZXJfYnVmZmVyc19t YXRjaCAKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyB0CisoMSByb3cpCisKK1JFU0VUIHBhcmFs bGVsX3NldHVwX2Nvc3Q7CitSRVNFVCBwYXJhbGxlbF90dXBsZV9jb3N0OworUkVTRVQgbWluX3Bh cmFsbGVsX3RhYmxlX3NjYW5fc2l6ZTsKK1JFU0VUIG1heF9wYXJhbGxlbF93b3JrZXJzX3Blcl9n YXRoZXI7CitSRVNFVCBwYXJhbGxlbF9sZWFkZXJfcGFydGljaXBhdGlvbjsKK0RST1AgVEFCTEUg cGFyX2RjX3RhYiwgZGNfc2VyaWFsX3Jlc3VsdDsKKy0tCistLSBBYm9ydC9leGNlcHRpb24gdGVz dHM6IHZlcmlmeSBidWZmZXIgdXNhZ2Ugc3Vydml2ZXMgdmFyaW91cyBlcnJvciBwYXRocy4KKy0t CistLSBSb2xsZWQtYmFjayBkaXZpZGUtYnktemVybyB1bmRlciBFWFBMQUlOIEFOQUxZWkUKK0NS RUFURSBURU1QIFRBQkxFIGV4Y190YWIgKGEgaW50LCBiIGNoYXIoMjApKTsKK1NFTEVDVCB0ZXN0 X3Nlc3Npb25fYnVmZmVyX3VzYWdlX3Jlc2V0KCk7CisgdGVzdF9zZXNzaW9uX2J1ZmZlcl91c2Fn ZV9yZXNldCAKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorIAorKDEgcm93KQor CitFWFBMQUlOIChBTkFMWVpFLCBCVUZGRVJTLCBDT1NUUyBPRkYpCisgICAgICAgIFdJVEggaW5z IEFTIChJTlNFUlQgSU5UTyBleGNfdGFiIFZBTFVFUyAoMSwgJ2FhYScpIFJFVFVSTklORyBhKQor ICAgICAgICBTRUxFQ1QgYSAvIDAgRlJPTSBpbnM7CitFUlJPUjogIGRpdmlzaW9uIGJ5IHplcm8K K1NFTEVDVCBsb2NhbF9ibGtzX2RpcnRpZWQgPiAwIEFTIGV4Y2VwdGlvbl9idWZmZXJzX3Zpc2li bGUKK0ZST00gdGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZSgpOworIGV4Y2VwdGlvbl9idWZmZXJz X3Zpc2libGUgCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyB0CisoMSByb3cpCisKK0RS T1AgVEFCTEUgZXhjX3RhYjsKKy0tIFVuaXF1ZSBjb25zdHJhaW50IHZpb2xhdGlvbiBpbiByZWd1 bGFyIHF1ZXJ5CitDUkVBVEUgVEVNUCBUQUJMRSB1bmlxdWVfdGFiIChhIGludCBVTklRVUUsIGIg Y2hhcigyMCkpOworSU5TRVJUIElOVE8gdW5pcXVlX3RhYiBWQUxVRVMgKDEsICdmaXJzdCcpOwor U0VMRUNUIHRlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2VfcmVzZXQoKTsKKyB0ZXN0X3Nlc3Npb25f YnVmZmVyX3VzYWdlX3Jlc2V0IAorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisg CisoMSByb3cpCisKK0lOU0VSVCBJTlRPIHVuaXF1ZV90YWIgVkFMVUVTICgxLCAnZHVwbGljYXRl Jyk7CitFUlJPUjogIGR1cGxpY2F0ZSBrZXkgdmFsdWUgdmlvbGF0ZXMgdW5pcXVlIGNvbnN0cmFp bnQgInVuaXF1ZV90YWJfYV9rZXkiCitERVRBSUw6ICBLZXkgKGEpPSgxKSBhbHJlYWR5IGV4aXN0 cy4KK1NFTEVDVCBsb2NhbF9ibGtzX2hpdCA+IDAgQVMgdW5pcXVlX3Zpb2xhdGlvbl9idWZmZXJz X3Zpc2libGUKK0ZST00gdGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZSgpOworIHVuaXF1ZV92aW9s YXRpb25fYnVmZmVyc192aXNpYmxlIAorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LQorIHQKKygxIHJvdykKKworRFJPUCBUQUJMRSB1bmlxdWVfdGFiOworLS0gQ2F1Z2h0IGV4Y2Vw dGlvbiBpbiBQTC9wZ1NRTCBzdWJ0cmFuc2FjdGlvbiAoQkVHSU4uLi5FWENFUFRJT04pCitDUkVB VEUgVEVNUCBUQUJMRSBzdWJ4YWN0X3RhYiAoYSBpbnQsIGIgY2hhcigyMCkpOworQ1JFQVRFIEZV TkNUSU9OIHN1YnhhY3RfZXhjX2Z1bmMoKSBSRVRVUk5TIHRleHQgQVMgJCQKK0JFR0lOCisgICAg QkVHSU4KKyAgICAgICAgRVhFQ1VURSAnRVhQTEFJTiAoQU5BTFlaRSwgQlVGRkVSUywgQ09TVFMg T0ZGKQorICAgICAgICAgICAgV0lUSCBpbnMgQVMgKElOU0VSVCBJTlRPIHN1YnhhY3RfdGFiIFZB TFVFUyAoMSwgJydhYWEnJykgUkVUVVJOSU5HIGEpCisgICAgICAgICAgICBTRUxFQ1QgYSAvIDAg RlJPTSBpbnMnOworICAgIEVYQ0VQVElPTiBXSEVOIGRpdmlzaW9uX2J5X3plcm8gVEhFTgorICAg ICAgICBSRVRVUk4gJ2NhdWdodCc7CisgICAgRU5EOworICAgIFJFVFVSTiAnbm90IHJlYWNoZWQn OworRU5EOworJCQgTEFOR1VBR0UgcGxwZ3NxbDsKK1NFTEVDVCB0ZXN0X3Nlc3Npb25fYnVmZmVy X3VzYWdlX3Jlc2V0KCk7CisgdGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZV9yZXNldCAKKy0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorIAorKDEgcm93KQorCitTRUxFQ1Qgc3VieGFj dF9leGNfZnVuYygpOworIHN1YnhhY3RfZXhjX2Z1bmMgCistLS0tLS0tLS0tLS0tLS0tLS0KKyBj YXVnaHQKKygxIHJvdykKKworU0VMRUNUIGxvY2FsX2Jsa3NfZGlydGllZCA+IDAgQVMgc3VieGFj dF9idWZmZXJzX3Zpc2libGUKK0ZST00gdGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZSgpOworIHN1 YnhhY3RfYnVmZmVyc192aXNpYmxlIAorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorIHQKKygx IHJvdykKKworRFJPUCBGVU5DVElPTiBzdWJ4YWN0X2V4Y19mdW5jOworRFJPUCBUQUJMRSBzdWJ4 YWN0X3RhYjsKKy0tIEN1cnNvciAoRk9SIGxvb3ApIGluIGFib3J0ZWQgc3VidHJhbnNhY3Rpb247 IHZlcmlmeSBwb3N0LWV4Y2VwdGlvbiB0cmFja2luZworQ1JFQVRFIFRFTVAgVEFCTEUgY3Vyc29y X3RhYiAoYSBpbnQsIGIgY2hhcigyMDApKTsKK0lOU0VSVCBJTlRPIGN1cnNvcl90YWIgU0VMRUNU IGksIHJlcGVhdCgneCcsIDIwMCkgRlJPTSBnZW5lcmF0ZV9zZXJpZXMoMSwgNTAwKSBBUyBpOwor Q1JFQVRFIEZVTkNUSU9OIGN1cnNvcl9leGNfZnVuYygpIFJFVFVSTlMgdGV4dCBBUyAkJAorREVD TEFSRQorICAgIHJlYyByZWNvcmQ7CisgICAgY250IGludCA6PSAwOworQkVHSU4KKyAgICBCRUdJ TgorICAgICAgICBGT1IgcmVjIElOIFNFTEVDVCAqIEZST00gY3Vyc29yX3RhYiBMT09QCisgICAg ICAgICAgICBjbnQgOj0gY250ICsgMTsKKyAgICAgICAgICAgIElGIGNudCA9IDI1MCBUSEVOCisg ICAgICAgICAgICAgICAgUEVSRk9STSAxIC8gMDsKKyAgICAgICAgICAgIEVORCBJRjsKKyAgICAg ICAgRU5EIExPT1A7CisgICAgRVhDRVBUSU9OIFdIRU4gZGl2aXNpb25fYnlfemVybyBUSEVOCisg ICAgICAgIFJFVFVSTiAnY2F1Z2h0IGFmdGVyICcgfHwgY250IHx8ICcgcm93cyc7CisgICAgRU5E OworICAgIFJFVFVSTiAnbm90IHJlYWNoZWQnOworRU5EOworJCQgTEFOR1VBR0UgcGxwZ3NxbDsK K1NFTEVDVCB0ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlX3Jlc2V0KCk7CisgdGVzdF9zZXNzaW9u X2J1ZmZlcl91c2FnZV9yZXNldCAKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQor IAorKDEgcm93KQorCitTRUxFQ1QgY3Vyc29yX2V4Y19mdW5jKCk7CisgICAgY3Vyc29yX2V4Y19m dW5jICAgIAorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyBjYXVnaHQgYWZ0ZXIgMjUwIHJvd3MK KygxIHJvdykKKworU0VMRUNUIGxvY2FsX2Jsa3NfaGl0ICsgbG9jYWxfYmxrc19yZWFkID4gMAor ICAgICAgIEFTIGN1cnNvcl9zdWJ4YWN0X2J1ZmZlcnNfdmlzaWJsZQorRlJPTSB0ZXN0X3Nlc3Np b25fYnVmZmVyX3VzYWdlKCk7CisgY3Vyc29yX3N1YnhhY3RfYnVmZmVyc192aXNpYmxlIAorLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyB0CisoMSByb3cpCisKK0RST1AgRlVOQ1RJ T04gY3Vyc29yX2V4Y19mdW5jOworRFJPUCBUQUJMRSBjdXJzb3JfdGFiOworLS0gVHJpZ2dlciBh Ym9ydCB1bmRlciBFWFBMQUlOIEFOQUxZWkU6IHZlcmlmeSB0aGF0IGJ1ZmZlciBhY3Rpdml0eSBm cm9tIGEKKy0tIHRyaWdnZXIgdGhhdCB0aHJvd3MgYW4gZXJyb3IgaXMgc3RpbGwgcHJvcGVybHkg cHJvcGFnYXRlZC4KK0NSRUFURSBURU1QIFRBQkxFIHRyaWdfZXJyX3RhYiAoYSBpbnQpOworQ1JF QVRFIFRFTVAgVEFCTEUgdHJpZ193b3JrX3RhYiAoYSBpbnQsIGIgY2hhcigyMDApKTsKK0lOU0VS VCBJTlRPIHRyaWdfd29ya190YWIgU0VMRUNUIGksIHJlcGVhdCgneCcsIDIwMCkgRlJPTSBnZW5l cmF0ZV9zZXJpZXMoMSwgNTAwKSBBUyBpOworLS0gV2FybSBsb2NhbCBidWZmZXJzIHNvIHRyaWdf d29ya190YWIgcmVhZHMgYmVjb21lIGhpdHMKK1NFTEVDVCBjb3VudCgqKSBGUk9NIHRyaWdfd29y a190YWI7CisgY291bnQgCistLS0tLS0tCisgICA1MDAKKygxIHJvdykKKworQ1JFQVRFIEZVTkNU SU9OIHRyaWdfZXJyX2Z1bmMoKSBSRVRVUk5TIHRyaWdnZXIgQVMgJCQKK0JFR0lOCisgICAgUEVS Rk9STSBjb3VudCgqKSBGUk9NIHRyaWdfd29ya190YWI7CisgICAgUkFJU0UgRVhDRVBUSU9OICd0 cmlnZ2VyIGVycm9yJzsKKyAgICBSRVRVUk4gTkVXOworRU5EOworJCQgTEFOR1VBR0UgcGxwZ3Nx bDsKK0NSRUFURSBUUklHR0VSIHRyaWdfZXJyIEJFRk9SRSBJTlNFUlQgT04gdHJpZ19lcnJfdGFi CisgICAgRk9SIEVBQ0ggUk9XIEVYRUNVVEUgRlVOQ1RJT04gdHJpZ19lcnJfZnVuYygpOworLS0g TWVhc3VyZSBob3cgbWFueSBsb2NhbCBidWZmZXIgaGl0cyBhIHNjYW4gb2YgdHJpZ193b3JrX3Rh YiBwcm9kdWNlcworU0VMRUNUIHRlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2VfcmVzZXQoKTsKKyB0 ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlX3Jlc2V0IAorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tCisgCisoMSByb3cpCisKK1NFTEVDVCBjb3VudCgqKSBGUk9NIHRyaWdfd29ya190 YWI7CisgY291bnQgCistLS0tLS0tCisgICA1MDAKKygxIHJvdykKKworQ1JFQVRFIFRFTVAgVEFC TEUgdHJpZ19zZXJpYWxfcmVzdWx0IEFTCitTRUxFQ1QgbG9jYWxfYmxrc19oaXQgQVMgc2VyaWFs X2hpdHMgRlJPTSB0ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlKCk7CistLSBOb3cgdHJpZ2dlciB0 aGUgc2FtZSBzY2FuIHZpYSBhIHRyaWdnZXIgdGhhdCBlcnJvcnMKK1NFTEVDVCB0ZXN0X3Nlc3Np b25fYnVmZmVyX3VzYWdlX3Jlc2V0KCk7CisgdGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZV9yZXNl dCAKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorIAorKDEgcm93KQorCitFWFBM QUlOIChBTkFMWVpFLCBCVUZGRVJTLCBDT1NUUyBPRkYpCisgICAgSU5TRVJUIElOVE8gdHJpZ19l cnJfdGFiIFZBTFVFUyAoMSk7CitFUlJPUjogIHRyaWdnZXIgZXJyb3IKK0NPTlRFWFQ6ICBQTC9w Z1NRTCBmdW5jdGlvbiB0cmlnX2Vycl9mdW5jKCkgbGluZSA0IGF0IFJBSVNFCistLSBUaGUgdHJp Z2dlciBzY2FubmVkIHRyaWdfd29ya190YWIgYnV0IGVycm9yZWQgYmVmb3JlIEluc3RyU3RvcFRy aWdnZXIgcmFuLgorLS0gSW5zdHJTdG9wRmluYWxpemUgaW4gdGhlIFBHX0NBVENIIGVuc3VyZXMg YnVmZmVyIGRhdGEgaXMgc3RpbGwgcHJvcGFnYXRlZC4KK1NFTEVDVCBsb2NhbF9ibGtzX2hpdCA+ PSBzLnNlcmlhbF9oaXRzIC8gMgorICAgICAgIEFTIHRyaWdnZXJfYWJvcnRfYnVmZmVyc19wcm9w YWdhdGVkCitGUk9NIHRlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UoKSwgdHJpZ19zZXJpYWxfcmVz dWx0IHM7CisgdHJpZ2dlcl9hYm9ydF9idWZmZXJzX3Byb3BhZ2F0ZWQgCistLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgdAorKDEgcm93KQorCitEUk9QIFRBQkxFIHRyaWdfZXJy X3RhYiwgdHJpZ193b3JrX3RhYiwgdHJpZ19zZXJpYWxfcmVzdWx0OworRFJPUCBGVU5DVElPTiB0 cmlnX2Vycl9mdW5jOworLS0gUGFyYWxsZWwgd29ya2VyIGFib3J0OiB3b3JrZXIgYnVmZmVyIGFj dGl2aXR5IGlzIGN1cnJlbnRseSBOT1QgcHJvcGFnYXRlZCBvbiBhYm9ydC4KKy0tCistLSBXaGVu IGEgcGFyYWxsZWwgd29ya2VyIGFib3J0cywgSW5zdHJFbmRQYXJhbGxlbFF1ZXJ5IGFuZAorLS0g RXhlY1BhcmFsbGVsUmVwb3J0SW5zdHJ1bWVudGF0aW9uIG5ldmVyIHJ1biwgc28gdGhlIHdvcmtl cidzIGJ1ZmZlcgorLS0gYWN0aXZpdHkgaXMgbmV2ZXIgd3JpdHRlbiB0byBzaGFyZWQgbWVtb3J5 LCBkZXNwaXRlIHRoZSBpbmZvcm1hdGlvbiBoYXZpbmcgYmVlbgorLS0gY2FwdHVyZWQgYnkgdGhl IHJlcyBvd25lciByZWxlYXNlIGluc3RydW1lbnRhdGlvbiBoYW5kbGluZy4KK0NSRUFURSBUQUJM RSBwYXJfYWJvcnRfdGFiIChhIGludCwgYiBjaGFyKDIwMCkpOworSU5TRVJUIElOVE8gcGFyX2Fi b3J0X3RhYiBTRUxFQ1QgaSwgcmVwZWF0KCd4JywgMjAwKSBGUk9NIGdlbmVyYXRlX3Nlcmllcygx LCA1MDAwKSBBUyBpOworLS0gV2FybSBzaGFyZWQgYnVmZmVycyBzbyBhbGwgcmVhZHMgYmVjb21l IGhpdHMKK1NFTEVDVCBjb3VudCgqKSBGUk9NIHBhcl9hYm9ydF90YWI7CisgY291bnQgCistLS0t LS0tCisgIDUwMDAKKygxIHJvdykKKworLS0gTWVhc3VyZSBzZXJpYWwgc2NhbiBkZWx0YSBhcyBh IHJlZmVyZW5jZSAobGVhZGVyIHJlYWRzIGFsbCBibG9ja3MpCitTRVQgbWF4X3BhcmFsbGVsX3dv cmtlcnNfcGVyX2dhdGhlciA9IDA7CitTRUxFQ1QgdGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZV9y ZXNldCgpOworIHRlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2VfcmVzZXQgCistLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAKKygxIHJvdykKKworU0VMRUNUIGI6OmludDIgRlJPTSBw YXJfYWJvcnRfdGFiIFdIRVJFIGEgPiAxMDAwOworRVJST1I6ICBpbnZhbGlkIGlucHV0IHN5bnRh eCBmb3IgdHlwZSBzbWFsbGludDogInh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4 eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4 eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4 eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4IgorQ1JF QVRFIFRBQkxFIHBhcl9hYm9ydF9zZXJpYWxfcmVzdWx0IEFTCitTRUxFQ1Qgc2hhcmVkX2Jsa3Nf aGl0IEFTIHNlcmlhbF9kZWx0YSBGUk9NIHRlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UoKTsKKy0t IE5vdyBmb3JjZSBwYXJhbGxlbCB3aXRoIGxlYWRlciBOT1QgcGFydGljaXBhdGluZyBpbiBzY2Fu bmluZworU0VUIHBhcmFsbGVsX3NldHVwX2Nvc3QgPSAwOworU0VUIHBhcmFsbGVsX3R1cGxlX2Nv c3QgPSAwOworU0VUIG1pbl9wYXJhbGxlbF90YWJsZV9zY2FuX3NpemUgPSAwOworU0VUIG1heF9w YXJhbGxlbF93b3JrZXJzX3Blcl9nYXRoZXIgPSAyOworU0VUIHBhcmFsbGVsX2xlYWRlcl9wYXJ0 aWNpcGF0aW9uID0gb2ZmOworU0VUIGRlYnVnX3BhcmFsbGVsX3F1ZXJ5ID0gb247IC0tIEVuc3Vy ZSB3ZSBnZXQgQ09OVEVYVCBsaW5lIGNvbnNpc3RlbnRseQorU0VMRUNUIHRlc3Rfc2Vzc2lvbl9i dWZmZXJfdXNhZ2VfcmVzZXQoKTsKKyB0ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlX3Jlc2V0IAor LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgCisoMSByb3cpCisKK1NFTEVDVCBi OjppbnQyIEZST00gcGFyX2Fib3J0X3RhYiBXSEVSRSBhID4gMTAwMDsKK0VSUk9SOiAgaW52YWxp ZCBpbnB1dCBzeW50YXggZm9yIHR5cGUgc21hbGxpbnQ6ICJ4eHh4eHh4eHh4eHh4eHh4eHh4eHh4 eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4 eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4 eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4eHh4 eHh4eHh4eCIKK0NPTlRFWFQ6ICBwYXJhbGxlbCB3b3JrZXIKK1JFU0VUIGRlYnVnX3BhcmFsbGVs X3F1ZXJ5OworLS0gV29ya2VycyBzY2FubmVkIHRoZSB0YWJsZSBidXQgYWJvcnRlZCBiZWZvcmUg cmVwb3J0aW5nIHN0YXRzIGJhY2suCistLSBUaGUgbGVhZGVyJ3MgZGVsdGEgc2hvdWxkIGJlIG11 Y2ggbGVzcyB0aGFuIGEgc2VyaWFsIHNjYW4sIGRvY3VtZW50aW5nCistLSB0aGF0IHdvcmtlciBi dWZmZXIgYWN0aXZpdHkgaXMgbG9zdCBvbiBhYm9ydC4KK1NFTEVDVCBzaGFyZWRfYmxrc19oaXQg PCBzLnNlcmlhbF9kZWx0YSAvIDIKKyAgICAgICBBUyB3b3JrZXJfYWJvcnRfYnVmZmVyc19ub3Rf cHJvcGFnYXRlZAorRlJPTSB0ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlKCksIHBhcl9hYm9ydF9z ZXJpYWxfcmVzdWx0IHM7Cisgd29ya2VyX2Fib3J0X2J1ZmZlcnNfbm90X3Byb3BhZ2F0ZWQgCist LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgdAorKDEgcm93KQorCitSRVNF VCBwYXJhbGxlbF9zZXR1cF9jb3N0OworUkVTRVQgcGFyYWxsZWxfdHVwbGVfY29zdDsKK1JFU0VU IG1pbl9wYXJhbGxlbF90YWJsZV9zY2FuX3NpemU7CitSRVNFVCBtYXhfcGFyYWxsZWxfd29ya2Vy c19wZXJfZ2F0aGVyOworUkVTRVQgcGFyYWxsZWxfbGVhZGVyX3BhcnRpY2lwYXRpb247CitEUk9Q IFRBQkxFIHBhcl9hYm9ydF90YWIsIHBhcl9hYm9ydF9zZXJpYWxfcmVzdWx0OworLS0gQ2xlYW51 cAorRFJPUCBFWFRFTlNJT04gdGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZTsKZGlmZiAtLWdpdCBh L3NyYy90ZXN0L21vZHVsZXMvdGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZS9tZXNvbi5idWlsZCBi L3NyYy90ZXN0L21vZHVsZXMvdGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZS9tZXNvbi5idWlsZApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMC4uYjk2ZjY3ZGM3ZmUKLS0tIC9k ZXYvbnVsbAorKysgYi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2Uv bWVzb24uYnVpbGQKQEAgLTAsMCArMSwzMyBAQAorIyBDb3B5cmlnaHQgKGMpIDIwMjYsIFBvc3Rn cmVTUUwgR2xvYmFsIERldmVsb3BtZW50IEdyb3VwCisKK3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNh Z2Vfc291cmNlcyA9IGZpbGVzKAorICAndGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZS5jJywKKykK KworaWYgaG9zdF9zeXN0ZW0gPT0gJ3dpbmRvd3MnCisgIHRlc3Rfc2Vzc2lvbl9idWZmZXJfdXNh Z2Vfc291cmNlcyArPSByY19saWJfZ2VuLnByb2Nlc3Mod2luMzJ2ZXJfcmMsIGV4dHJhX2FyZ3M6 IFsKKyAgICAnLS1OQU1FJywgJ3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UnLAorICAgICctLUZJ TEVERVNDJywgJ3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UgLSBzaG93IGJ1ZmZlciB1c2FnZSBz dGF0aXN0aWNzIGZvciB0aGUgY3VycmVudCBzZXNzaW9uJyxdKQorZW5kaWYKKwordGVzdF9zZXNz aW9uX2J1ZmZlcl91c2FnZSA9IHNoYXJlZF9tb2R1bGUoJ3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNh Z2UnLAorICB0ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlX3NvdXJjZXMsCisgIGt3YXJnczogcGdf dGVzdF9tb2RfYXJncywKKykKK3Rlc3RfaW5zdGFsbF9saWJzICs9IHRlc3Rfc2Vzc2lvbl9idWZm ZXJfdXNhZ2UKKwordGVzdF9pbnN0YWxsX2RhdGEgKz0gZmlsZXMoCisgICd0ZXN0X3Nlc3Npb25f YnVmZmVyX3VzYWdlLmNvbnRyb2wnLAorICAndGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZS0tMS4w LnNxbCcsCispCisKK3Rlc3RzICs9IHsKKyAgJ25hbWUnOiAndGVzdF9zZXNzaW9uX2J1ZmZlcl91 c2FnZScsCisgICdzZCc6IG1lc29uLmN1cnJlbnRfc291cmNlX2RpcigpLAorICAnYmQnOiBtZXNv bi5jdXJyZW50X2J1aWxkX2RpcigpLAorICAncmVncmVzcyc6IHsKKyAgICAnc3FsJzogWworICAg ICAgJ3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UnLAorICAgIF0sCisgIH0sCit9CmRpZmYgLS1n aXQgYS9zcmMvdGVzdC9tb2R1bGVzL3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2Uvc3FsL3Rlc3Rf c2Vzc2lvbl9idWZmZXJfdXNhZ2Uuc3FsIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X3Nlc3Npb25f YnVmZmVyX3VzYWdlL3NxbC90ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlLnNxbApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMC4uZGFmMjE1OWM0YTYKLS0tIC9kZXYvbnVsbAor KysgYi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2Uvc3FsL3Rlc3Rf c2Vzc2lvbl9idWZmZXJfdXNhZ2Uuc3FsCkBAIC0wLDAgKzEsMjQ1IEBACitMT0FEICd0ZXN0X3Nl c3Npb25fYnVmZmVyX3VzYWdlJzsKK0NSRUFURSBFWFRFTlNJT04gdGVzdF9zZXNzaW9uX2J1ZmZl cl91c2FnZTsKKworLS0gVmVyaWZ5IGFsbCBjb2x1bW5zIGFyZSBub24tbmVnYXRpdmUKK1NFTEVD VCBjb3VudCgqKSA9IDEgQVMgb2sgRlJPTSB0ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlKCkKK1dI RVJFIHNoYXJlZF9ibGtzX2hpdCA+PSAwIEFORCBzaGFyZWRfYmxrc19yZWFkID49IDAKKyAgQU5E IHNoYXJlZF9ibGtzX2RpcnRpZWQgPj0gMCBBTkQgc2hhcmVkX2Jsa3Nfd3JpdHRlbiA+PSAwCisg IEFORCBsb2NhbF9ibGtzX2hpdCA+PSAwIEFORCBsb2NhbF9ibGtzX3JlYWQgPj0gMAorICBBTkQg bG9jYWxfYmxrc19kaXJ0aWVkID49IDAgQU5EIGxvY2FsX2Jsa3Nfd3JpdHRlbiA+PSAwCisgIEFO RCB0ZW1wX2Jsa3NfcmVhZCA+PSAwIEFORCB0ZW1wX2Jsa3Nfd3JpdHRlbiA+PSAwCisgIEFORCBz aGFyZWRfYmxrX3JlYWRfdGltZSA+PSAwIEFORCBzaGFyZWRfYmxrX3dyaXRlX3RpbWUgPj0gMAor ICBBTkQgbG9jYWxfYmxrX3JlYWRfdGltZSA+PSAwIEFORCBsb2NhbF9ibGtfd3JpdGVfdGltZSA+ PSAwCisgIEFORCB0ZW1wX2Jsa19yZWFkX3RpbWUgPj0gMCBBTkQgdGVtcF9ibGtfd3JpdGVfdGlt ZSA+PSAwOworCistLSBWZXJpZnkgY291bnRlcnMgaW5jcmVhc2UgYWZ0ZXIgYnVmZmVyIGFjdGl2 aXR5CitTRUxFQ1QgdGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZV9yZXNldCgpOworCitDUkVBVEUg VEVNUCBUQUJMRSB0ZXN0X2J1Zl9hY3Rpdml0eSAoaWQgaW50LCBkYXRhIHRleHQpOworSU5TRVJU IElOVE8gdGVzdF9idWZfYWN0aXZpdHkgU0VMRUNUIGksIHJlcGVhdCgneCcsIDEwMCkgRlJPTSBn ZW5lcmF0ZV9zZXJpZXMoMSwgMTAwMCkgQVMgaTsKK1NFTEVDVCBjb3VudCgqKSBGUk9NIHRlc3Rf YnVmX2FjdGl2aXR5OworCitTRUxFQ1QgbG9jYWxfYmxrc19oaXQgKyBsb2NhbF9ibGtzX3JlYWQg PiAwIEFTIGJsb2Nrc19pbmNyZWFzZWQKK0ZST00gdGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZSgp OworCitEUk9QIFRBQkxFIHRlc3RfYnVmX2FjdGl2aXR5OworCistLSBQYXJhbGxlbCBxdWVyeSB0 ZXN0CitDUkVBVEUgVEFCTEUgcGFyX2RjX3RhYiAoYSBpbnQsIGIgY2hhcigyMDApKTsKK0lOU0VS VCBJTlRPIHBhcl9kY190YWIgU0VMRUNUIGksIHJlcGVhdCgneCcsIDIwMCkgRlJPTSBnZW5lcmF0 ZV9zZXJpZXMoMSwgNTAwMCkgQVMgaTsKKworU0VMRUNUIGNvdW50KCopIEZST00gcGFyX2RjX3Rh YjsKKworLS0gTWVhc3VyZSBzZXJpYWwgc2NhbiBkZWx0YSAobGVhZGVyIGRvZXMgYWxsIHRoZSB3 b3JrKQorU0VUIG1heF9wYXJhbGxlbF93b3JrZXJzX3Blcl9nYXRoZXIgPSAwOworCitTRUxFQ1Qg dGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZV9yZXNldCgpOworU0VMRUNUIGNvdW50KCopIEZST00g cGFyX2RjX3RhYjsKKworQ1JFQVRFIFRFTVAgVEFCTEUgZGNfc2VyaWFsX3Jlc3VsdCBBUworU0VM RUNUIHNoYXJlZF9ibGtzX2hpdCBBUyBzZXJpYWxfZGVsdGEgRlJPTSB0ZXN0X3Nlc3Npb25fYnVm ZmVyX3VzYWdlKCk7CisKKy0tIE1lYXN1cmUgcGFyYWxsZWwgc2NhbiBkZWx0YSB3aXRoIGxlYWRl ciBOT1QgcGFydGljaXBhdGluZyBpbiBzY2FubmluZy4KKy0tIFdvcmtlcnMgZG8gYWxsIHRhYmxl IHNjYW5uaW5nOyBsZWFkZXIgb25seSBydW5zIHRoZSBHYXRoZXIgbm9kZS4KK1NFVCBwYXJhbGxl bF9zZXR1cF9jb3N0ID0gMDsKK1NFVCBwYXJhbGxlbF90dXBsZV9jb3N0ID0gMDsKK1NFVCBtaW5f cGFyYWxsZWxfdGFibGVfc2Nhbl9zaXplID0gMDsKK1NFVCBtYXhfcGFyYWxsZWxfd29ya2Vyc19w ZXJfZ2F0aGVyID0gMjsKK1NFVCBwYXJhbGxlbF9sZWFkZXJfcGFydGljaXBhdGlvbiA9IG9mZjsK KworU0VMRUNUIHRlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2VfcmVzZXQoKTsKK1NFTEVDVCBjb3Vu dCgqKSBGUk9NIHBhcl9kY190YWI7CisKKy0tIENvbmZpcm0gd2UgZ290IGEgc2ltaWxhciBoaXQg Y291bnRlciB0aHJvdWdoIHBhcmFsbGVsIHdvcmtlciBhY2N1bXVsYXRpb24KK1NFTEVDVCBzaGFy ZWRfYmxrc19oaXQgPiBzLnNlcmlhbF9kZWx0YSAvIDIgQU5EIHNoYXJlZF9ibGtzX2hpdCA8IHMu c2VyaWFsX2RlbHRhICogMgorICAgICAgIEFTIGxlYWRlcl9idWZmZXJzX21hdGNoCitGUk9NIHRl c3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UoKSwgZGNfc2VyaWFsX3Jlc3VsdCBzOworCitSRVNFVCBw YXJhbGxlbF9zZXR1cF9jb3N0OworUkVTRVQgcGFyYWxsZWxfdHVwbGVfY29zdDsKK1JFU0VUIG1p bl9wYXJhbGxlbF90YWJsZV9zY2FuX3NpemU7CitSRVNFVCBtYXhfcGFyYWxsZWxfd29ya2Vyc19w ZXJfZ2F0aGVyOworUkVTRVQgcGFyYWxsZWxfbGVhZGVyX3BhcnRpY2lwYXRpb247CisKK0RST1Ag VEFCTEUgcGFyX2RjX3RhYiwgZGNfc2VyaWFsX3Jlc3VsdDsKKworLS0KKy0tIEFib3J0L2V4Y2Vw dGlvbiB0ZXN0czogdmVyaWZ5IGJ1ZmZlciB1c2FnZSBzdXJ2aXZlcyB2YXJpb3VzIGVycm9yIHBh dGhzLgorLS0KKworLS0gUm9sbGVkLWJhY2sgZGl2aWRlLWJ5LXplcm8gdW5kZXIgRVhQTEFJTiBB TkFMWVpFCitDUkVBVEUgVEVNUCBUQUJMRSBleGNfdGFiIChhIGludCwgYiBjaGFyKDIwKSk7CisK K1NFTEVDVCB0ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlX3Jlc2V0KCk7CisKK0VYUExBSU4gKEFO QUxZWkUsIEJVRkZFUlMsIENPU1RTIE9GRikKKyAgICAgICAgV0lUSCBpbnMgQVMgKElOU0VSVCBJ TlRPIGV4Y190YWIgVkFMVUVTICgxLCAnYWFhJykgUkVUVVJOSU5HIGEpCisgICAgICAgIFNFTEVD VCBhIC8gMCBGUk9NIGluczsKKworU0VMRUNUIGxvY2FsX2Jsa3NfZGlydGllZCA+IDAgQVMgZXhj ZXB0aW9uX2J1ZmZlcnNfdmlzaWJsZQorRlJPTSB0ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlKCk7 CisKK0RST1AgVEFCTEUgZXhjX3RhYjsKKworLS0gVW5pcXVlIGNvbnN0cmFpbnQgdmlvbGF0aW9u IGluIHJlZ3VsYXIgcXVlcnkKK0NSRUFURSBURU1QIFRBQkxFIHVuaXF1ZV90YWIgKGEgaW50IFVO SVFVRSwgYiBjaGFyKDIwKSk7CitJTlNFUlQgSU5UTyB1bmlxdWVfdGFiIFZBTFVFUyAoMSwgJ2Zp cnN0Jyk7CisKK1NFTEVDVCB0ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlX3Jlc2V0KCk7CitJTlNF UlQgSU5UTyB1bmlxdWVfdGFiIFZBTFVFUyAoMSwgJ2R1cGxpY2F0ZScpOworCitTRUxFQ1QgbG9j YWxfYmxrc19oaXQgPiAwIEFTIHVuaXF1ZV92aW9sYXRpb25fYnVmZmVyc192aXNpYmxlCitGUk9N IHRlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UoKTsKKworRFJPUCBUQUJMRSB1bmlxdWVfdGFiOwor CistLSBDYXVnaHQgZXhjZXB0aW9uIGluIFBML3BnU1FMIHN1YnRyYW5zYWN0aW9uIChCRUdJTi4u LkVYQ0VQVElPTikKK0NSRUFURSBURU1QIFRBQkxFIHN1YnhhY3RfdGFiIChhIGludCwgYiBjaGFy KDIwKSk7CisKK0NSRUFURSBGVU5DVElPTiBzdWJ4YWN0X2V4Y19mdW5jKCkgUkVUVVJOUyB0ZXh0 IEFTICQkCitCRUdJTgorICAgIEJFR0lOCisgICAgICAgIEVYRUNVVEUgJ0VYUExBSU4gKEFOQUxZ WkUsIEJVRkZFUlMsIENPU1RTIE9GRikKKyAgICAgICAgICAgIFdJVEggaW5zIEFTIChJTlNFUlQg SU5UTyBzdWJ4YWN0X3RhYiBWQUxVRVMgKDEsICcnYWFhJycpIFJFVFVSTklORyBhKQorICAgICAg ICAgICAgU0VMRUNUIGEgLyAwIEZST00gaW5zJzsKKyAgICBFWENFUFRJT04gV0hFTiBkaXZpc2lv bl9ieV96ZXJvIFRIRU4KKyAgICAgICAgUkVUVVJOICdjYXVnaHQnOworICAgIEVORDsKKyAgICBS RVRVUk4gJ25vdCByZWFjaGVkJzsKK0VORDsKKyQkIExBTkdVQUdFIHBscGdzcWw7CisKK1NFTEVD VCB0ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlX3Jlc2V0KCk7CitTRUxFQ1Qgc3VieGFjdF9leGNf ZnVuYygpOworCitTRUxFQ1QgbG9jYWxfYmxrc19kaXJ0aWVkID4gMCBBUyBzdWJ4YWN0X2J1ZmZl cnNfdmlzaWJsZQorRlJPTSB0ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlKCk7CisKK0RST1AgRlVO Q1RJT04gc3VieGFjdF9leGNfZnVuYzsKK0RST1AgVEFCTEUgc3VieGFjdF90YWI7CisKKy0tIEN1 cnNvciAoRk9SIGxvb3ApIGluIGFib3J0ZWQgc3VidHJhbnNhY3Rpb247IHZlcmlmeSBwb3N0LWV4 Y2VwdGlvbiB0cmFja2luZworQ1JFQVRFIFRFTVAgVEFCTEUgY3Vyc29yX3RhYiAoYSBpbnQsIGIg Y2hhcigyMDApKTsKK0lOU0VSVCBJTlRPIGN1cnNvcl90YWIgU0VMRUNUIGksIHJlcGVhdCgneCcs IDIwMCkgRlJPTSBnZW5lcmF0ZV9zZXJpZXMoMSwgNTAwKSBBUyBpOworCitDUkVBVEUgRlVOQ1RJ T04gY3Vyc29yX2V4Y19mdW5jKCkgUkVUVVJOUyB0ZXh0IEFTICQkCitERUNMQVJFCisgICAgcmVj IHJlY29yZDsKKyAgICBjbnQgaW50IDo9IDA7CitCRUdJTgorICAgIEJFR0lOCisgICAgICAgIEZP UiByZWMgSU4gU0VMRUNUICogRlJPTSBjdXJzb3JfdGFiIExPT1AKKyAgICAgICAgICAgIGNudCA6 PSBjbnQgKyAxOworICAgICAgICAgICAgSUYgY250ID0gMjUwIFRIRU4KKyAgICAgICAgICAgICAg ICBQRVJGT1JNIDEgLyAwOworICAgICAgICAgICAgRU5EIElGOworICAgICAgICBFTkQgTE9PUDsK KyAgICBFWENFUFRJT04gV0hFTiBkaXZpc2lvbl9ieV96ZXJvIFRIRU4KKyAgICAgICAgUkVUVVJO ICdjYXVnaHQgYWZ0ZXIgJyB8fCBjbnQgfHwgJyByb3dzJzsKKyAgICBFTkQ7CisgICAgUkVUVVJO ICdub3QgcmVhY2hlZCc7CitFTkQ7CiskJCBMQU5HVUFHRSBwbHBnc3FsOworCitTRUxFQ1QgdGVz dF9zZXNzaW9uX2J1ZmZlcl91c2FnZV9yZXNldCgpOworU0VMRUNUIGN1cnNvcl9leGNfZnVuYygp OworCitTRUxFQ1QgbG9jYWxfYmxrc19oaXQgKyBsb2NhbF9ibGtzX3JlYWQgPiAwCisgICAgICAg QVMgY3Vyc29yX3N1YnhhY3RfYnVmZmVyc192aXNpYmxlCitGUk9NIHRlc3Rfc2Vzc2lvbl9idWZm ZXJfdXNhZ2UoKTsKKworRFJPUCBGVU5DVElPTiBjdXJzb3JfZXhjX2Z1bmM7CitEUk9QIFRBQkxF IGN1cnNvcl90YWI7CisKKy0tIFRyaWdnZXIgYWJvcnQgdW5kZXIgRVhQTEFJTiBBTkFMWVpFOiB2 ZXJpZnkgdGhhdCBidWZmZXIgYWN0aXZpdHkgZnJvbSBhCistLSB0cmlnZ2VyIHRoYXQgdGhyb3dz IGFuIGVycm9yIGlzIHN0aWxsIHByb3Blcmx5IHByb3BhZ2F0ZWQuCitDUkVBVEUgVEVNUCBUQUJM RSB0cmlnX2Vycl90YWIgKGEgaW50KTsKK0NSRUFURSBURU1QIFRBQkxFIHRyaWdfd29ya190YWIg KGEgaW50LCBiIGNoYXIoMjAwKSk7CitJTlNFUlQgSU5UTyB0cmlnX3dvcmtfdGFiIFNFTEVDVCBp LCByZXBlYXQoJ3gnLCAyMDApIEZST00gZ2VuZXJhdGVfc2VyaWVzKDEsIDUwMCkgQVMgaTsKKwor LS0gV2FybSBsb2NhbCBidWZmZXJzIHNvIHRyaWdfd29ya190YWIgcmVhZHMgYmVjb21lIGhpdHMK K1NFTEVDVCBjb3VudCgqKSBGUk9NIHRyaWdfd29ya190YWI7CisKK0NSRUFURSBGVU5DVElPTiB0 cmlnX2Vycl9mdW5jKCkgUkVUVVJOUyB0cmlnZ2VyIEFTICQkCitCRUdJTgorICAgIFBFUkZPUk0g Y291bnQoKikgRlJPTSB0cmlnX3dvcmtfdGFiOworICAgIFJBSVNFIEVYQ0VQVElPTiAndHJpZ2dl ciBlcnJvcic7CisgICAgUkVUVVJOIE5FVzsKK0VORDsKKyQkIExBTkdVQUdFIHBscGdzcWw7CisK K0NSRUFURSBUUklHR0VSIHRyaWdfZXJyIEJFRk9SRSBJTlNFUlQgT04gdHJpZ19lcnJfdGFiCisg ICAgRk9SIEVBQ0ggUk9XIEVYRUNVVEUgRlVOQ1RJT04gdHJpZ19lcnJfZnVuYygpOworCistLSBN ZWFzdXJlIGhvdyBtYW55IGxvY2FsIGJ1ZmZlciBoaXRzIGEgc2NhbiBvZiB0cmlnX3dvcmtfdGFi IHByb2R1Y2VzCitTRUxFQ1QgdGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZV9yZXNldCgpOworU0VM RUNUIGNvdW50KCopIEZST00gdHJpZ193b3JrX3RhYjsKKworQ1JFQVRFIFRFTVAgVEFCTEUgdHJp Z19zZXJpYWxfcmVzdWx0IEFTCitTRUxFQ1QgbG9jYWxfYmxrc19oaXQgQVMgc2VyaWFsX2hpdHMg RlJPTSB0ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlKCk7CisKKy0tIE5vdyB0cmlnZ2VyIHRoZSBz YW1lIHNjYW4gdmlhIGEgdHJpZ2dlciB0aGF0IGVycm9ycworU0VMRUNUIHRlc3Rfc2Vzc2lvbl9i dWZmZXJfdXNhZ2VfcmVzZXQoKTsKK0VYUExBSU4gKEFOQUxZWkUsIEJVRkZFUlMsIENPU1RTIE9G RikKKyAgICBJTlNFUlQgSU5UTyB0cmlnX2Vycl90YWIgVkFMVUVTICgxKTsKKworLS0gVGhlIHRy aWdnZXIgc2Nhbm5lZCB0cmlnX3dvcmtfdGFiIGJ1dCBlcnJvcmVkIGJlZm9yZSBJbnN0clN0b3BU cmlnZ2VyIHJhbi4KKy0tIEluc3RyU3RvcEZpbmFsaXplIGluIHRoZSBQR19DQVRDSCBlbnN1cmVz IGJ1ZmZlciBkYXRhIGlzIHN0aWxsIHByb3BhZ2F0ZWQuCitTRUxFQ1QgbG9jYWxfYmxrc19oaXQg Pj0gcy5zZXJpYWxfaGl0cyAvIDIKKyAgICAgICBBUyB0cmlnZ2VyX2Fib3J0X2J1ZmZlcnNfcHJv cGFnYXRlZAorRlJPTSB0ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlKCksIHRyaWdfc2VyaWFsX3Jl c3VsdCBzOworCitEUk9QIFRBQkxFIHRyaWdfZXJyX3RhYiwgdHJpZ193b3JrX3RhYiwgdHJpZ19z ZXJpYWxfcmVzdWx0OworRFJPUCBGVU5DVElPTiB0cmlnX2Vycl9mdW5jOworCistLSBQYXJhbGxl bCB3b3JrZXIgYWJvcnQ6IHdvcmtlciBidWZmZXIgYWN0aXZpdHkgaXMgY3VycmVudGx5IE5PVCBw cm9wYWdhdGVkIG9uIGFib3J0LgorLS0KKy0tIFdoZW4gYSBwYXJhbGxlbCB3b3JrZXIgYWJvcnRz LCBJbnN0ckVuZFBhcmFsbGVsUXVlcnkgYW5kCistLSBFeGVjUGFyYWxsZWxSZXBvcnRJbnN0cnVt ZW50YXRpb24gbmV2ZXIgcnVuLCBzbyB0aGUgd29ya2VyJ3MgYnVmZmVyCistLSBhY3Rpdml0eSBp cyBuZXZlciB3cml0dGVuIHRvIHNoYXJlZCBtZW1vcnksIGRlc3BpdGUgdGhlIGluZm9ybWF0aW9u IGhhdmluZyBiZWVuCistLSBjYXB0dXJlZCBieSB0aGUgcmVzIG93bmVyIHJlbGVhc2UgaW5zdHJ1 bWVudGF0aW9uIGhhbmRsaW5nLgorQ1JFQVRFIFRBQkxFIHBhcl9hYm9ydF90YWIgKGEgaW50LCBi IGNoYXIoMjAwKSk7CitJTlNFUlQgSU5UTyBwYXJfYWJvcnRfdGFiIFNFTEVDVCBpLCByZXBlYXQo J3gnLCAyMDApIEZST00gZ2VuZXJhdGVfc2VyaWVzKDEsIDUwMDApIEFTIGk7CisKKy0tIFdhcm0g c2hhcmVkIGJ1ZmZlcnMgc28gYWxsIHJlYWRzIGJlY29tZSBoaXRzCitTRUxFQ1QgY291bnQoKikg RlJPTSBwYXJfYWJvcnRfdGFiOworCistLSBNZWFzdXJlIHNlcmlhbCBzY2FuIGRlbHRhIGFzIGEg cmVmZXJlbmNlIChsZWFkZXIgcmVhZHMgYWxsIGJsb2NrcykKK1NFVCBtYXhfcGFyYWxsZWxfd29y a2Vyc19wZXJfZ2F0aGVyID0gMDsKKworU0VMRUNUIHRlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2Vf cmVzZXQoKTsKK1NFTEVDVCBiOjppbnQyIEZST00gcGFyX2Fib3J0X3RhYiBXSEVSRSBhID4gMTAw MDsKKworQ1JFQVRFIFRBQkxFIHBhcl9hYm9ydF9zZXJpYWxfcmVzdWx0IEFTCitTRUxFQ1Qgc2hh cmVkX2Jsa3NfaGl0IEFTIHNlcmlhbF9kZWx0YSBGUk9NIHRlc3Rfc2Vzc2lvbl9idWZmZXJfdXNh Z2UoKTsKKworLS0gTm93IGZvcmNlIHBhcmFsbGVsIHdpdGggbGVhZGVyIE5PVCBwYXJ0aWNpcGF0 aW5nIGluIHNjYW5uaW5nCitTRVQgcGFyYWxsZWxfc2V0dXBfY29zdCA9IDA7CitTRVQgcGFyYWxs ZWxfdHVwbGVfY29zdCA9IDA7CitTRVQgbWluX3BhcmFsbGVsX3RhYmxlX3NjYW5fc2l6ZSA9IDA7 CitTRVQgbWF4X3BhcmFsbGVsX3dvcmtlcnNfcGVyX2dhdGhlciA9IDI7CitTRVQgcGFyYWxsZWxf bGVhZGVyX3BhcnRpY2lwYXRpb24gPSBvZmY7CitTRVQgZGVidWdfcGFyYWxsZWxfcXVlcnkgPSBv bjsgLS0gRW5zdXJlIHdlIGdldCBDT05URVhUIGxpbmUgY29uc2lzdGVudGx5CisKK1NFTEVDVCB0 ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlX3Jlc2V0KCk7CitTRUxFQ1QgYjo6aW50MiBGUk9NIHBh cl9hYm9ydF90YWIgV0hFUkUgYSA+IDEwMDA7CisKK1JFU0VUIGRlYnVnX3BhcmFsbGVsX3F1ZXJ5 OworCistLSBXb3JrZXJzIHNjYW5uZWQgdGhlIHRhYmxlIGJ1dCBhYm9ydGVkIGJlZm9yZSByZXBv cnRpbmcgc3RhdHMgYmFjay4KKy0tIFRoZSBsZWFkZXIncyBkZWx0YSBzaG91bGQgYmUgbXVjaCBs ZXNzIHRoYW4gYSBzZXJpYWwgc2NhbiwgZG9jdW1lbnRpbmcKKy0tIHRoYXQgd29ya2VyIGJ1ZmZl ciBhY3Rpdml0eSBpcyBsb3N0IG9uIGFib3J0LgorU0VMRUNUIHNoYXJlZF9ibGtzX2hpdCA8IHMu c2VyaWFsX2RlbHRhIC8gMgorICAgICAgIEFTIHdvcmtlcl9hYm9ydF9idWZmZXJzX25vdF9wcm9w YWdhdGVkCitGUk9NIHRlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UoKSwgcGFyX2Fib3J0X3Nlcmlh bF9yZXN1bHQgczsKKworUkVTRVQgcGFyYWxsZWxfc2V0dXBfY29zdDsKK1JFU0VUIHBhcmFsbGVs X3R1cGxlX2Nvc3Q7CitSRVNFVCBtaW5fcGFyYWxsZWxfdGFibGVfc2Nhbl9zaXplOworUkVTRVQg bWF4X3BhcmFsbGVsX3dvcmtlcnNfcGVyX2dhdGhlcjsKK1JFU0VUIHBhcmFsbGVsX2xlYWRlcl9w YXJ0aWNpcGF0aW9uOworCitEUk9QIFRBQkxFIHBhcl9hYm9ydF90YWIsIHBhcl9hYm9ydF9zZXJp YWxfcmVzdWx0OworCistLSBDbGVhbnVwCitEUk9QIEVYVEVOU0lPTiB0ZXN0X3Nlc3Npb25fYnVm ZmVyX3VzYWdlOwpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X3Nlc3Npb25fYnVm ZmVyX3VzYWdlL3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UtLTEuMC5zcWwgYi9zcmMvdGVzdC9t b2R1bGVzL3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UvdGVzdF9zZXNzaW9uX2J1ZmZlcl91c2Fn ZS0tMS4wLnNxbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMC4uZTk4MzNi ZTQ3MGEKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3Rfc2Vzc2lvbl9i dWZmZXJfdXNhZ2UvdGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZS0tMS4wLnNxbApAQCAtMCwwICsx LDMxIEBACisvKiBzcmMvdGVzdC9tb2R1bGVzL3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UvdGVz dF9zZXNzaW9uX2J1ZmZlcl91c2FnZS0tMS4wLnNxbCAqLworCistLSBjb21wbGFpbiBpZiBzY3Jp cHQgaXMgc291cmNlZCBpbiBwc3FsLCByYXRoZXIgdGhhbiB2aWEgQ1JFQVRFIEVYVEVOU0lPTgor XGVjaG8gVXNlICJDUkVBVEUgRVhURU5TSU9OIHRlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UiIHRv IGxvYWQgdGhpcyBmaWxlLiBccXVpdAorCitDUkVBVEUgRlVOQ1RJT04gdGVzdF9zZXNzaW9uX2J1 ZmZlcl91c2FnZSgKKyAgICBPVVQgc2hhcmVkX2Jsa3NfaGl0IGJpZ2ludCwKKyAgICBPVVQgc2hh cmVkX2Jsa3NfcmVhZCBiaWdpbnQsCisgICAgT1VUIHNoYXJlZF9ibGtzX2RpcnRpZWQgYmlnaW50 LAorICAgIE9VVCBzaGFyZWRfYmxrc193cml0dGVuIGJpZ2ludCwKKyAgICBPVVQgbG9jYWxfYmxr c19oaXQgYmlnaW50LAorICAgIE9VVCBsb2NhbF9ibGtzX3JlYWQgYmlnaW50LAorICAgIE9VVCBs b2NhbF9ibGtzX2RpcnRpZWQgYmlnaW50LAorICAgIE9VVCBsb2NhbF9ibGtzX3dyaXR0ZW4gYmln aW50LAorICAgIE9VVCB0ZW1wX2Jsa3NfcmVhZCBiaWdpbnQsCisgICAgT1VUIHRlbXBfYmxrc193 cml0dGVuIGJpZ2ludCwKKyAgICBPVVQgc2hhcmVkX2Jsa19yZWFkX3RpbWUgZG91YmxlIHByZWNp c2lvbiwKKyAgICBPVVQgc2hhcmVkX2Jsa193cml0ZV90aW1lIGRvdWJsZSBwcmVjaXNpb24sCisg ICAgT1VUIGxvY2FsX2Jsa19yZWFkX3RpbWUgZG91YmxlIHByZWNpc2lvbiwKKyAgICBPVVQgbG9j YWxfYmxrX3dyaXRlX3RpbWUgZG91YmxlIHByZWNpc2lvbiwKKyAgICBPVVQgdGVtcF9ibGtfcmVh ZF90aW1lIGRvdWJsZSBwcmVjaXNpb24sCisgICAgT1VUIHRlbXBfYmxrX3dyaXRlX3RpbWUgZG91 YmxlIHByZWNpc2lvbgorKQorUkVUVVJOUyByZWNvcmQKK0FTICdNT0RVTEVfUEFUSE5BTUUnLCAn dGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZScKK0xBTkdVQUdFIEMgUEFSQUxMRUwgUkVTVFJJQ1RF RDsKKworQ1JFQVRFIEZVTkNUSU9OIHRlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2VfcmVzZXQoKQor UkVUVVJOUyB2b2lkCitBUyAnTU9EVUxFX1BBVEhOQU1FJywgJ3Rlc3Rfc2Vzc2lvbl9idWZmZXJf dXNhZ2VfcmVzZXQnCitMQU5HVUFHRSBDIFBBUkFMTEVMIFJFU1RSSUNURUQ7CmRpZmYgLS1naXQg YS9zcmMvdGVzdC9tb2R1bGVzL3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UvdGVzdF9zZXNzaW9u X2J1ZmZlcl91c2FnZS5jIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X3Nlc3Npb25fYnVmZmVyX3Vz YWdlL3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMC4uNTBlYjFhMmZmZTYKLS0tIC9kZXYvbnVsbAorKysgYi9zcmMvdGVzdC9t b2R1bGVzL3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UvdGVzdF9zZXNzaW9uX2J1ZmZlcl91c2Fn ZS5jCkBAIC0wLDAgKzEsOTUgQEAKKy8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICoKKyAqIHRlc3Rfc2Vz c2lvbl9idWZmZXJfdXNhZ2UuYworICoJICBzaG93IGJ1ZmZlciB1c2FnZSBzdGF0aXN0aWNzIGZv ciB0aGUgY3VycmVudCBzZXNzaW9uCisgKgorICogQ29weXJpZ2h0IChjKSAyMDI2LCBQb3N0Z3Jl U1FMIEdsb2JhbCBEZXZlbG9wbWVudCBHcm91cAorICoKKyAqCSAgc3JjL3Rlc3QvbW9kdWxlcy90 ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlL3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UuYworICot LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tCisgKi8KKyNpbmNsdWRlICJwb3N0Z3Jlcy5oIgorCisjaW5jbHVkZSAi YWNjZXNzL2h0dXBfZGV0YWlscy5oIgorI2luY2x1ZGUgImV4ZWN1dG9yL2luc3RydW1lbnQuaCIK KyNpbmNsdWRlICJmdW5jYXBpLmgiCisjaW5jbHVkZSAibWlzY2FkbWluLmgiCisjaW5jbHVkZSAi dXRpbHMvbWVtdXRpbHMuaCIKKworUEdfTU9EVUxFX01BR0lDX0VYVCgKKwkJCQkJLm5hbWUgPSAi dGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZSIsCisJCQkJCS52ZXJzaW9uID0gUEdfVkVSU0lPTgor KTsKKworI2RlZmluZSBOVU1fQlVGRkVSX1VTQUdFX0NPTFVNTlMgMTYKKworUEdfRlVOQ1RJT05f SU5GT19WMSh0ZXN0X3Nlc3Npb25fYnVmZmVyX3VzYWdlKTsKK1BHX0ZVTkNUSU9OX0lORk9fVjEo dGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZV9yZXNldCk7CisKKyNkZWZpbmUgSEFWRV9JTlNUUl9T VEFDSyAxCQkvKiBDaGFuZ2UgdG8gMCB3aGVuIHRlc3RpbmcgYmVmb3JlIHN0YWNrCisJCQkJCQkJ CSAqIGNoYW5nZSAqLworCisvKgorICogU1FMIGZ1bmN0aW9uOiB0ZXN0X3Nlc3Npb25fYnVmZmVy X3VzYWdlKCkKKyAqCisgKiBSZXR1cm5zIGEgc2luZ2xlIHJvdyB3aXRoIGFsbCBCdWZmZXJVc2Fn ZSBjb3VudGVycyBhY2N1bXVsYXRlZCBzaW5jZSB0aGUKKyAqIHN0YXJ0IG9mIHRoZSBzZXNzaW9u LiBFeGNsdWRlcyBhbnkgdXNhZ2Ugbm90IHlldCBhZGRlZCB0byB0aGUgdG9wIG9mIHRoZQorICog c3RhY2sgKGUuZy4gaWYgdGhpcyBnZXRzIGNhbGxlZCBpbnNpZGUgYSBzdGF0ZW1lbnQgdGhhdCBh bHNvIGhhZCBidWZmZXIKKyAqIGFjdGl2aXR5KS4KKyAqLworRGF0dW0KK3Rlc3Rfc2Vzc2lvbl9i dWZmZXJfdXNhZ2UoUEdfRlVOQ1RJT05fQVJHUykKK3sKKwlUdXBsZURlc2MJdHVwZGVzYzsKKwlE YXR1bQkJdmFsdWVzW05VTV9CVUZGRVJfVVNBR0VfQ09MVU1OU107CisJYm9vbAkJbnVsbHNbTlVN X0JVRkZFUl9VU0FHRV9DT0xVTU5TXTsKKwlCdWZmZXJVc2FnZSAqdXNhZ2U7CisKKwlpZiAoZ2V0 X2NhbGxfcmVzdWx0X3R5cGUoZmNpbmZvLCBOVUxMLCAmdHVwZGVzYykgIT0gVFlQRUZVTkNfQ09N UE9TSVRFKQorCQllbG9nKEVSUk9SLCAicmV0dXJuIHR5cGUgbXVzdCBiZSBhIHJvdyB0eXBlIik7 CisKKwltZW1zZXQobnVsbHMsIDAsIHNpemVvZihudWxscykpOworCisjaWYgSEFWRV9JTlNUUl9T VEFDSworCXVzYWdlID0gJmluc3RyX3RvcC5idWZ1c2FnZTsKKyNlbHNlCisJdXNhZ2UgPSAmcGdC dWZmZXJVc2FnZTsKKyNlbmRpZgorCisJdmFsdWVzWzBdID0gSW50NjRHZXREYXR1bSh1c2FnZS0+ c2hhcmVkX2Jsa3NfaGl0KTsKKwl2YWx1ZXNbMV0gPSBJbnQ2NEdldERhdHVtKHVzYWdlLT5zaGFy ZWRfYmxrc19yZWFkKTsKKwl2YWx1ZXNbMl0gPSBJbnQ2NEdldERhdHVtKHVzYWdlLT5zaGFyZWRf Ymxrc19kaXJ0aWVkKTsKKwl2YWx1ZXNbM10gPSBJbnQ2NEdldERhdHVtKHVzYWdlLT5zaGFyZWRf Ymxrc193cml0dGVuKTsKKwl2YWx1ZXNbNF0gPSBJbnQ2NEdldERhdHVtKHVzYWdlLT5sb2NhbF9i bGtzX2hpdCk7CisJdmFsdWVzWzVdID0gSW50NjRHZXREYXR1bSh1c2FnZS0+bG9jYWxfYmxrc19y ZWFkKTsKKwl2YWx1ZXNbNl0gPSBJbnQ2NEdldERhdHVtKHVzYWdlLT5sb2NhbF9ibGtzX2RpcnRp ZWQpOworCXZhbHVlc1s3XSA9IEludDY0R2V0RGF0dW0odXNhZ2UtPmxvY2FsX2Jsa3Nfd3JpdHRl bik7CisJdmFsdWVzWzhdID0gSW50NjRHZXREYXR1bSh1c2FnZS0+dGVtcF9ibGtzX3JlYWQpOwor CXZhbHVlc1s5XSA9IEludDY0R2V0RGF0dW0odXNhZ2UtPnRlbXBfYmxrc193cml0dGVuKTsKKwl2 YWx1ZXNbMTBdID0gRmxvYXQ4R2V0RGF0dW0oSU5TVFJfVElNRV9HRVRfTUlMTElTRUModXNhZ2Ut PnNoYXJlZF9ibGtfcmVhZF90aW1lKSk7CisJdmFsdWVzWzExXSA9IEZsb2F0OEdldERhdHVtKElO U1RSX1RJTUVfR0VUX01JTExJU0VDKHVzYWdlLT5zaGFyZWRfYmxrX3dyaXRlX3RpbWUpKTsKKwl2 YWx1ZXNbMTJdID0gRmxvYXQ4R2V0RGF0dW0oSU5TVFJfVElNRV9HRVRfTUlMTElTRUModXNhZ2Ut PmxvY2FsX2Jsa19yZWFkX3RpbWUpKTsKKwl2YWx1ZXNbMTNdID0gRmxvYXQ4R2V0RGF0dW0oSU5T VFJfVElNRV9HRVRfTUlMTElTRUModXNhZ2UtPmxvY2FsX2Jsa193cml0ZV90aW1lKSk7CisJdmFs dWVzWzE0XSA9IEZsb2F0OEdldERhdHVtKElOU1RSX1RJTUVfR0VUX01JTExJU0VDKHVzYWdlLT50 ZW1wX2Jsa19yZWFkX3RpbWUpKTsKKwl2YWx1ZXNbMTVdID0gRmxvYXQ4R2V0RGF0dW0oSU5TVFJf VElNRV9HRVRfTUlMTElTRUModXNhZ2UtPnRlbXBfYmxrX3dyaXRlX3RpbWUpKTsKKworCVBHX1JF VFVSTl9EQVRVTShIZWFwVHVwbGVHZXREYXR1bShoZWFwX2Zvcm1fdHVwbGUodHVwZGVzYywgdmFs dWVzLCBudWxscykpKTsKK30KKworLyoKKyAqIFNRTCBmdW5jdGlvbjogdGVzdF9zZXNzaW9uX2J1 ZmZlcl91c2FnZV9yZXNldCgpCisgKgorICogUmVzZXRzIGFsbCBCdWZmZXJVc2FnZSBjb3VudGVy cyBvbiB0aGUgdG9wIGluc3RydW1lbnRhdGlvbiBzdGFjayB0byB6ZXJvLgorICogVXNlZnVsIGlu IHRlc3RzIHRvIGF2b2lkIHRoZSBiYXNlbGluZS9kZWx0YSBwYXR0ZXJuLgorICovCitEYXR1bQor dGVzdF9zZXNzaW9uX2J1ZmZlcl91c2FnZV9yZXNldChQR19GVU5DVElPTl9BUkdTKQoreworI2lm IEhBVkVfSU5TVFJfU1RBQ0sKKwltZW1zZXQoJmluc3RyX3RvcC5idWZ1c2FnZSwgMCwgc2l6ZW9m KEJ1ZmZlclVzYWdlKSk7CisjZWxzZQorCW1lbXNldCgmcGdCdWZmZXJVc2FnZSwgMCwgc2l6ZW9m KEJ1ZmZlclVzYWdlKSk7CisjZW5kaWYKKworCVBHX1JFVFVSTl9WT0lEKCk7Cit9CmRpZmYgLS1n aXQgYS9zcmMvdGVzdC9tb2R1bGVzL3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UvdGVzdF9zZXNz aW9uX2J1ZmZlcl91c2FnZS5jb250cm9sIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X3Nlc3Npb25f YnVmZmVyX3VzYWdlL3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UuY29udHJvbApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMC4uNDFjZmIxNWE3NjUKLS0tIC9kZXYvbnVsbAor KysgYi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UvdGVzdF9zZXNz aW9uX2J1ZmZlcl91c2FnZS5jb250cm9sCkBAIC0wLDAgKzEsNSBAQAorIyB0ZXN0X3Nlc3Npb25f YnVmZmVyX3VzYWdlIGV4dGVuc2lvbgorY29tbWVudCA9ICdzaG93IGJ1ZmZlciB1c2FnZSBzdGF0 aXN0aWNzIGZvciB0aGUgY3VycmVudCBzZXNzaW9uJworZGVmYXVsdF92ZXJzaW9uID0gJzEuMCcK K21vZHVsZV9wYXRobmFtZSA9ICckbGliZGlyL3Rlc3Rfc2Vzc2lvbl9idWZmZXJfdXNhZ2UnCity ZWxvY2F0YWJsZSA9IHRydWUKLS0gCjIuNDcuMQoK --0000000000006d0cb0064eb5be7d--