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 1w3PlX-001C4Z-11 for pgsql-hackers@arkaria.postgresql.org; Fri, 20 Mar 2026 02:39:11 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1w3PlV-003xIi-2b for pgsql-hackers@arkaria.postgresql.org; Fri, 20 Mar 2026 02:39:10 +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 1w3PlV-003xIa-0o for pgsql-hackers@lists.postgresql.org; Fri, 20 Mar 2026 02:39:09 +0000 Received: from mail-ed1-x532.google.com ([2a00:1450:4864:20::532]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.98.2) (envelope-from ) id 1w3PlO-000000006ki-3jNI for pgsql-hackers@lists.postgresql.org; Fri, 20 Mar 2026 02:39:09 +0000 Received: by mail-ed1-x532.google.com with SMTP id 4fb4d7f45d1cf-6644a3029b3so2116457a12.0 for ; Thu, 19 Mar 2026 19:39:02 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1773974340; cv=none; d=google.com; s=arc-20240605; b=dDZ111vpO+GWfUrwHpbVnbXFpMfy0odet2Pvahba8zR1M36z5OX8vwvIiO5hbhDgNa qijJXzJUW8vtacD9kzLGnAMhmjM9MPV8a6mMuVwtJVvTWYy2LO+tmEa4ZZgUWYQU1iHi XeIaKjsjSQjzjlnUM8RW8tsLbb4Tsluo74mftS5++bPlTBXo0IfHy9BFsyShR4UsTSgj 930ZJdHJ7CfiWFtqvXjifoE1BIvr09Y6j+Bat2hgHThRc7wM2st15OG7fowpUxrJnAWi 6gWdKLjIAhhBTWqyoIJhomzW/5G91cLmuAvNRSbT5HcmzwrlDAfrk1nokKw9KARG4mXw Cg8A== 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=RkOMpGc3gaqw8lEiwMp6mCTFMim5zb+0+7wvHnK4DUs=; fh=ycdthhiy2DJcRu6+TB9/56CaAL6mzAETS+AIAelUvrM=; b=Iw7Vqe6XmkA1ZktxhCVOXljR/lYjGN0Z7+MisZQBWEDpX7o1RD381vTWOgHn3YYeZQ GaJ3SmX1zYCuazz470Wd8hY8v5dynCej+0VjVOCJ7vgE05t0DztGN17pR2QA0uj0SIcP qXfNNQushSlMbHjOOodToJ6Wg2569YZKpbsJistCpGYA2Ole5rEsfl7OmviL1tWS6C5Z 9/7+VIL3PooSOiTN5xp6lJGYkjqE4YDIP5jwCcWNQEcDYrMgseSoIWdyjVAEwS6tcAYy /ZpNemEYMXeF8SIgQ/BR10S8pYLk59KRgmnXzKGpFi8qNQYXhDjeQKCE7V3zzz9a/fsZ 2EiQ==; darn=lists.postgresql.org ARC-Authentication-Results: i=1; mx.google.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1773974340; x=1774579140; 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=RkOMpGc3gaqw8lEiwMp6mCTFMim5zb+0+7wvHnK4DUs=; b=EN/YrIOgk7OodQDHBF7VssQBbbn5CQm+/lMmeMsXcLEfIuhylm6JZs2HgIDzh1Himb Ptg5xjyXNJQNF53Gr3TcKcmi+fO5tqYEn9g8PTdjy3EPwYORbfiUfLFvGTv0IDBK/A6S AVmJw3+Y502ieyFqyo1K2SxKQPkWmFywRiuTwoG4ibEF5ma122o1noXZaSjT6dlCVn4z 7y6G++Kbt0cSXJwkZx2tt16x9s4bYMbCAzATgnyyg4xYiH6+ik+KVcqasHazWl6QlnD8 Cnt6JPWLjS6xJIkAsNs5CeezweSoNlYYTdUfdf153xXnOoFHn/9N8Fow4eypfhkD3oGW DAmw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1773974340; x=1774579140; 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=RkOMpGc3gaqw8lEiwMp6mCTFMim5zb+0+7wvHnK4DUs=; b=Rx5Rp4AoTodYKOou9YVazMMTBzuVwu8feJ8BGPrWkqmlusY+dR/qFNKP6se7oPGbio pyMn65HWujFWfMIdfZ7hYXffUCvtcuDe0C0dRxuZYuPwBW2u6ar0rI37wXmI4fZgD1cu rMBh70lwDwNSdq8sxgN/Ip2jPZOlNJux1Sil/ZBv1rYr9OJ3+Wu0FPrM6dKiZ+7fCE0F 7PLs1Jp9sJkbypxlXbGyj8mv0Zb24T4dvUQjmXqxZ4meOH6b5l3kYtOiZ2xQ0UBMctU1 eXg9uqG5mDPek0YFtFhmLbYOUXX/ydRS8DpAWW5wE4TJbyAVpLHgqYgkSVJ2WYvKV3H3 kh+Q== X-Forwarded-Encrypted: i=1; AJvYcCV35rjP3A4S4o8FGeU5TIKQWSryaSJ7Kc/FAVJw9c6PG5p41yrVL3U8MLoSDV6nY3xQsSA+Sz/btXHTSur2@lists.postgresql.org X-Gm-Message-State: AOJu0YxdLT8yds5icaSJF2RIHyABZ6u/tsk09ThBucjxus+PcJmKl7NU FpRJkiCVKqlnGcmVuVcwB8hkGp8vddr2hp/IsDleJ3x2JB96ZE+3+lkKAOeZc3qXGy7DjAY0aAI Ozy1elYnz7x7049KaGUYU4ZYGkaajBCY= X-Gm-Gg: ATEYQzzf1TcOOZEzzxlkUzmBk2uTbO+rV+7lLabJrdEZjqj9fueWpt9j2Fs7yvTp04d HEPHFnH6ELtlvaOoHzZ+aSUNa/hW3vnZpvIPC+FPqtAKd8vxm385iAxjriCA28ec9EUxhqpBUB3 WexyzVqRwzT4r2XapyGcD74ibgxHQsVNrXqGcPejdmYi3co7jMS9QzKjuIKTW6ka85H40CrgI2B 7TEhyowWFJMfhxl8ddBpyBDrhgqA/tjUkcDIj/tyHnRsJodtXYVZED/Urm9eo4AeugYve8UbL7c QvAwzyEzN87KkKoPObyw5RFtTvaZzQo53rBpQeVCjGJS8mXEwdoxhkaDF2xXU4AUyhVB8T9KxQS jJcbhDKAj X-Received: by 2002:a05:6402:270e:b0:663:d74e:9253 with SMTP id 4fb4d7f45d1cf-668c9b21203mr1059309a12.30.1773974340019; Thu, 19 Mar 2026 19:39:00 -0700 (PDT) MIME-Version: 1.0 References: <81DAFACF-7D55-4A84-ACB0-0425D1669DB4@gmail.com> In-Reply-To: From: Melanie Plageman Date: Thu, 19 Mar 2026 22:38:47 -0400 X-Gm-Features: AaiRm53agXwkhps6iE0TtyahOkZoppHD3V0i1NKxOF2eRgvOm8xdg-Lgw0tCs-4 Message-ID: Subject: Re: eliminate xl_heap_visible to reduce WAL (and eventually set VM on-access) To: Andres Freund Cc: Kirill Reshke , Chao Li , Andrey Borodin , Xuneng Zhou , Robert Haas , PostgreSQL Hackers , Heikki Linnakangas Content-Type: multipart/mixed; boundary="00000000000060fd69064d6b968a" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --00000000000060fd69064d6b968a Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Thanks for the detailed review! Unless otherwise specified, attached v41 includes all of your straightforward review points. On Wed, Mar 18, 2026 at 1:14=E2=80=AFPM Andres Freund = wrote: > > > + params.relation =3D relation; > > + params.buffer =3D buffer; > > + params.vmbuffer =3D *vmbuffer; > > + params.reason =3D PRUNE_ON_ACCESS; > > + params.vistest =3D vistest; > > + params.cutoffs =3D NULL; > > > > > * We don't pass the HEAP_PAGE_PRUNE_MARK_UNUSED_= NOW option > > @@ -284,14 +312,7 @@ heap_page_prune_opt(Relation relation, Buffer buff= er, Buffer *vmbuffer) > > * cannot safely determine that during on-access = pruning with the > > * current implementation. > > */ > > - PruneFreezeParams params =3D { > > - .relation =3D relation, > > - .buffer =3D buffer, > > - .reason =3D PRUNE_ON_ACCESS, > > - .options =3D 0, > > - .vistest =3D vistest, > > - .cutoffs =3D NULL, > > - }; > > + params.options =3D 0; > > > > heap_page_prune_and_freeze(¶ms, &presult, &du= mmy_off_loc, > > = NULL, NULL); > > Why does this change the way the PruneFreezeParams variable is defined? = I > don't really mind, it's just a bit confusing. I couldn't use the designated initializer after visibilitymap_pin() and I thought it was worse to have the designated initializer nitialize vmbuffer to InvalidBuffer and then have to set vmbuffer to the real vmbuffer after visibilitymap_pin(). > > + * Helper to fix visibility-related corruption on a heap page and its > > + * corresponding VM page. An all-visible page cannot have dead items n= or can > > + * it have tuples that are not visible to all running transactions. It= clears > > + * the VM corruption as well as resetting the vmbits used during pruni= ng. > > So this is now only called when we already know there's corruption? I th= ink > that could be clearer in the comments. > > Seems a bit odd that the function then figures out what it should do from= the > page & VM contents, given that the caller already needs to have known tha= t > something is wrong? Yea, it was all a bit off. I agree. I've tried something new and made a VMCorruptionType enum for the caller to pass in which tells this function what to do (clear PD_ALL_VISIBLE and/or clear VM) and what warning to emit. > > +static void > > +heap_fix_vm_corruption(PruneState *prstate, OffsetNumber offnum) > > +{ > > + { > > + ereport(WARNING, > > + (errcode(ERRCODE_DATA_CORRUPTED), > > + errmsg("tuple not visible to all= transactions found on page marked all-visible"), > > + errcontext("relation \"%s\", pag= e %u, tuple %u", > > + relname, = prstate->block, offnum))); > > + } > > Wait, why are we now WARNING about the PageIsAllVisible() && > prstate->lpdead_items =3D=3D 0 case? Seems to run flatly counter to the c= omment > above about GetOldestNonRemovableTransactionId() going backward? Only if the page has tuples with HTSV_Result HEAPTUPLE_RECENTLY_DEAD/DELETE_IN_PROGRESS/INSERT_IN_PROGRESS. Even if GetOldestNonRemovableTransactionId() goes backwards that should only make it so that xids we previously thought were visible now show as not visible to all. But those have to be HEAPTUPLE_LIVE tuples. We should never thought it was all-visible if there were in-progress deletes/inserts. So, I think it is okay. Now (in v41), the caller would need to pass VM_CORRUPT_TUPLE_VISIBILITY and intend to emit the warning. > > + else if (prstate->vmbits & VISIBILITYMAP_VALID_BITS) > > + { > > + /* > > + * As of PostgreSQL 9.2, the visibility map bit should ne= ver be set if > > + * the page-level bit is clear. However, for vacuum, it's= possible > > + * that the bit got cleared after heap_vac_scan_next_bloc= k() was > > + * called, so we must recheck now that we have the buffer= lock before > > + * concluding that the VM is corrupt. > > + */ > > + ereport(WARNING, > > + (errcode(ERRCODE_DATA_CORRUPTED), > > + errmsg("page is not marked all-visible b= ut visibility map bit is set"), > > + errcontext("relation \"%s\", page %u", > > + relname, prstate-= >block))); > > + } > > + > > + visibilitymap_clear(prstate->relation, prstate->block, prstate->v= mbuffer, > > + VISIBILITYMAP_VALID_BITS)= ; > > + prstate->vmbits =3D 0; > > So we can end up clearing the VM without emitting any warning? This was me trying to avoid duplicating code in the branches. In v41, I error out if the caller doesn't specify a valid corruption type, so anything that clears the VM will have emitted a warning. > > +static void > > +heap_page_bypass_prune_freeze(PruneState *prstate, PruneFreezeResult *= presult) > > +{ > > + OffsetNumber maxoff =3D PageGetMaxOffsetNumber(prstate->page); > > + Page page =3D prstate->page; > > + > > + Assert(prstate->vmbits & VISIBILITYMAP_ALL_FROZEN || > > + (prstate->vmbits & VISIBILITYMAP_ALL_VISIBLE && > > + !prstate->attempt_freeze)); > > + > > + /* We'll fill in presult for the caller */ > > + memset(presult, 0, sizeof(PruneFreezeResult)); > > + > > + presult->vmbits =3D prstate->vmbits; > > + > > + /* Clear any stale prune hint */ > > + if (TransactionIdIsValid(PageGetPruneXid(page))) > > + { > > + PageClearPrunable(page); > > + MarkBufferDirtyHint(prstate->buffer, true); > > + } > > + > > + if (PageIsEmpty(page)) > > + return; > > + > > + presult->hastup =3D true; > > Is that actually a given? Couldn't the page consist solely out of unused > items? That'd make PageIsEmpty() return false, but should still allow > truncation. Good point. I've changed it to set hastup when counting live tuples. But should I set hastup it if I see an LP_REDIRECT pointer? I know I should always see a LP_NORMAL pointer if I see an LP_REDIRECT pointer, but I just wondered if I should explicitly set hastup when I see LP_REDIRECT since heap_prune_record_redirect() sets hastup =3D true. > > diff --git a/src/backend/access/heap/pruneheap.c b/src/backend/access/h= eap/pruneheap.c > > > + /* > > + * After processing all the live tuples on the page, if the newes= t xmin > > + * amongst them may be considered running by any snapshot, the pa= ge cannot > > + * be all-visible. > > + */ > > + if (prstate.set_all_visible && > > + TransactionIdIsNormal(prstate.visibility_cutoff_xid) && > > + GlobalVisTestXidMaybeRunning(prstate.vistest, > > + = prstate.visibility_cutoff_xid)) > > + prstate.set_all_visible =3D prstate.set_all_frozen =3D fa= lse; > > + > > So the docs for prstate.visibility_cutoff_xid say: > > * visibility_cutoff_xid is the newest xmin of live tuples on the= page. > * The caller can use it as the conflict horizon, when setting th= e VM > * bits. It is only valid if we froze some tuples, and set_all_f= rozen is > * true. > > But here we look at it without checking that we froze some tuples. I gue= ss > the comment is outdated? That comment was never correct -- or I have chopped it into unrecognizable bits over the last two years. > Could the "going backward" thing possibly trigger a spurious assert in > > Assert(heap_page_is_all_visible(vacrel->rel, buf, > vacrel->vistest, &debug_all_froze= n, > &debug_cutoff, &vacrel->offnum)); I don't think anything (today) updates GlobalVisState between GlobalVisTestXidMaybeRunning() and the heap_page_is_all_visible() assert. I had removed the visibility_cutoff_xid part of the assertion on the intuition that comparing an exact horizon would no longer work when using GlobalVisState. I can't remember if I actually saw failing tests, but I don't see them anymore (so I've put it back). The heap_page_is_all_visible() assertion moves into heap_page_prune_and_freeze() in a later patch in this set, and while it is also in a place where I don't think GlobalVisState can have moved between making the page changes and calling heap_page_is_all_visible(), I suspect it won't be a totally reliable assertion now that it uses a moving target for comparison. What do you think? > > From a1d768a8cea8ac13e250188ec96c01d98acda94a Mon Sep 17 00:00:00 2001 > > From: Melanie Plageman > > Date: Sat, 28 Feb 2026 16:06:51 -0500 > > Subject: [PATCH v40 04/12] Keep newest live XID up-to-date even if page= not > > all-visible > > I guess I'd have expected 03 and 04 to be swapped... But whatever. It couldn't be because I used GlobalVisState to always keep it up-to-date (even for on-access pruning). > > @@ -1076,6 +1116,30 @@ heap_page_prune_and_freeze(PruneFreezeParams *pa= rams, > > prstate.set_all_visible =3D prstate.set_all_frozen =3D fa= lse; > > > > Assert(!prstate.set_all_frozen || prstate.set_all_visible); > > + Assert(!prstate.set_all_visible || (prstate.lpdead_items =3D=3D 0= )); > > Why didn't we have this assert earlier? It was in lazy_scan_prune() as: Assert(!presult.set_all_visible || !(*has_lpdead_items)); > > + do_set_vm =3D heap_page_will_set_vm(&prstate, params->reason); > > Most of the other heap_page_prune_and_freeze() helpers are named > heap_prune_xyz(), why not follow that here? > > I guess this holds for a few other helpers added in earlier commits > too. E.g. heap_page_bypass_prune_freeze() should probably be > heap_prune_bypass_prune_freeze() or such. Most of the helpers prefixed with "heap_prune" now directly do something related to pruning like recording line pointers and traversing hot chains. heap_page_will_set_vm() and heap_page_will_freeze() have nothing to do with pruning, so I think it makes sense they are named differently. And I don't think we are in any danger of folks using functions not prefixed with heap_prune for other purposes, given that most of them take a PruneState as an argument. I'll do a big rename if you feel strongly about it, though. > > @@ -1097,14 +1161,17 @@ heap_page_prune_and_freeze(PruneFreezeParams *p= arams, > > > > /* > > * If that's all we had to do to the page, this is a non-= WAL-logged > > - * hint. If we are going to freeze or prune the page, we= will mark > > - * the buffer dirty below. > > + * hint. If we are going to freeze or prune the page or = set > > + * PD_ALL_VISIBLE, we will mark the buffer dirty below. > > + * > > + * Setting PD_ALL_VISIBLE is fully WAL-logged because it = is forbidden > > + * for the VM to be set and PD_ALL_VISIBLE to be clear. > > */ > > - if (!do_freeze && !do_prune) > > + if (!do_freeze && !do_prune && !do_set_vm) > > MarkBufferDirtyHint(prstate.buffer, true); > > } > > This block is gated by if (do_hint_prune) which is computed as: > > /* > * Even if we don't prune anything, if we found a new value for t= he > * pd_prune_xid field or the page was marked full, we will update= the hint > * bit. > */ > do_hint_prune =3D PageGetPruneXid(prstate.page) !=3D prstate.new_= prune_xid || > PageIsFull(prstate.page); > > It's not really related to this change, but I'm just confused a bit by th= e > "|| PageIsFull(prstate.page)". What is that about? Why do we want to mark= the > buffer DirtyHint if the page is full? It very well might already have bee= n > marked as such, no? Because if the page is marked full, we clear that hint, and, if that's the only change we make to the page, we need to do MarkBufferDirtyHint(). > > +#ifdef USE_ASSERT_CHECKING > > + if (prstate.set_all_visible) > > + { > > + TransactionId debug_cutoff; > > + bool debug_all_frozen; > > + > > + Assert(prstate.lpdead_items =3D=3D 0); > > + > > + Assert(heap_page_is_all_visible(prstate.relation, prstate= .buffer, > > + = prstate.vistest, > > + = &debug_all_frozen, > > + = &debug_cutoff, off_loc)); > > + > > + /* > > + * It's possible the page is composed entirely of frozen = tuples but is > > + * not set all-frozen in the VM and did not pass > > + * HEAP_PAGE_PRUNE_FREEZE. In this case, it's possible > > + * heap_page_is_all_visible() finds the page completely f= rozen, even > > + * though prstate.set_all_frozen is false. > > + */ > > + Assert(!prstate.set_all_frozen || debug_all_frozen); > > Seems like we could verify that debug_cutoff isn't newer than conflict_xi= d? Well, not conflict_xid, but newest_xid, yes. > Hm. I guess aborting after we did incorrect pruning/freezing/VMing is be= tter > than not, but it'd be even better if we did it before corrupting things. = But I > guess it'd be not trivial to add something like the debug_cutoff assertio= n I > suggest above, when freezing of tuples is only executed after > heap_page_is_all_visible() (for dead tuples heap_page_would_be_all_visibl= e() > already has provisions). > > It's probably more a theoretical concern than a real worry. Yea, I think the work it would take to make heap_page_would_be_all_visible() work for frozen tuples wouldn't be worth it just to get it to assert out before executing the page changes. > > + presult->new_all_visible_pages =3D 0; > > + presult->new_all_frozen_pages =3D 0; > > + presult->new_all_visible_frozen_pages =3D 0; > > Isn't it odd to talk about pages here? Given that heap_page_prune_and_fre= eze() > only ever operates on exactly one page. Is that just so you can do > > > + vacrel->new_all_visible_pages +=3D presult.new_all_visible_pages; I made this change because you didn't like it when I passed old_vmbits and new_vmbits back out to lazy_scan_prune() to derive these counters. FWIW I think it's better not to have lazy_scan_prune() compare new and old vmbits to increment counters, because lazy_scan_prune() shouldn't have to know about the VM anymore once it is not setting it. > > + if (do_set_vm) > > + { > > + if ((prstate.old_vmbits & VISIBILITYMAP_ALL_VISIBLE) =3D= =3D 0) > > + { > > + presult->new_all_visible_pages =3D 1; > > + if (prstate.set_all_frozen) > > + presult->new_all_visible_frozen_pages =3D= 1; > > + } > > + else if ((prstate.old_vmbits & VISIBILITYMAP_ALL_FROZEN) = =3D=3D 0 && > > + prstate.set_all_frozen) > > + presult->new_all_frozen_pages =3D 1; > > + } > > + > > if (prstate.attempt_freeze) > > { > > if (presult->nfrozen > 0) > > Feels like this is kinda redoing what heap_page_will_set_vm already did. The logic is different than what is in heap_page_will_set_vm() because there we don't care about what old_vmbits is. We are simply concerned with whether we should set new_vmbits to something. So we need to have logic somewhere that is figuring out if the vmbits were set before and whether we newly set them. That can either go in heap_page_prune_and_freeze() and we can use that to set the counters in the LVRelState or it can go in lazy_scan_prune(). I think it makes more sense in heap_page_prune_and_freeze() so that lazy_scan_prune() doesn't have to know about the VM's new/old state, which it otherwise no longer deals with. > > @@ -1923,13 +1926,33 @@ lazy_scan_new_or_empty(LVRelState *vacrel, Buff= er buf, BlockNumber blkno, > > PageSetAllVisible(page); > > PageClearPrunable(page); > > - visibilitymap_set(vacrel->rel, blkno, buf, > > - InvalidXLogRecP= tr, > > - vmbuffer, Inval= idTransactionId, > > - VISIBILITYMAP_A= LL_VISIBLE | > > - VISIBILITYMAP_A= LL_FROZEN); > > + visibilitymap_set_vmbits(blkno, > > + = vmbuffer, > > + = VISIBILITYMAP_ALL_VISIBLE | > > + = VISIBILITYMAP_ALL_FROZEN, > > + = vacrel->rel->rd_locator); > > + > > + /* > > + * Emit WAL for setting PD_ALL_VISIBLE on the hea= p page and > > + * setting the VM. > > + */ > > + if (RelationNeedsWAL(vacrel->rel)) > > + log_heap_prune_and_freeze(vacrel->rel, bu= f, > > + = vmbuffer, > > + = VISIBILITYMAP_ALL_VISIBLE | > > + = VISIBILITYMAP_ALL_FROZEN, > > + = InvalidTransactionId, /* conflict xid */ > > + = false, /* cleanup lock */ > > + = PRUNE_VACUUM_SCAN, /* reason */ > > + = NULL, 0, > > + = NULL, 0, > > + = NULL, 0, > > + = NULL, 0); > > + > > END_CRIT_SECTION(); > > It's a tad odd that we do: > > /* > * It's possible that another backend has extende= d the heap, > * initialized the page, and then failed to WAL-l= og the page due > * to an ERROR. Since heap extension is not WAL-= logged, recovery > * might try to replay our record setting the pag= e all-visible and > * find that the page isn't initialized, which wi= ll cause a PANIC. > * To prevent that, check whether the page has be= en previously > * WAL-logged, and if not, do that now. > */ > if (RelationNeedsWAL(vacrel->rel) && > !XLogRecPtrIsValid(PageGetLSN(page))) > log_newpage_buffer(buf, true); > > if we then immediately afterwards emit a WAL record that could just as we= ll > have included in FPI of the heap page. I originally added a flag to log_heap_prune_and_freeze() that could force an FPI but Robert disliked it, saying he found it more confusing. He said: > 0004. It is not clear to me why you need to get > log_heap_prune_and_freeze to do the work here. Why can't > log_newpage_buffer get the job done already? I can put it back that way, I don't have strong feelings either way. Though I imagine if I add another argument to log_heap_prune_and_freeze(), you'll bring up creating a struct for its arguments again... > > diff --git a/src/backend/access/common/bufmask.c b/src/backend/access/c= ommon/bufmask.c > > index 8a67bfa1aff..d9042e1f91d 100644 > > --- a/src/backend/access/common/bufmask.c > > +++ b/src/backend/access/common/bufmask.c > > @@ -56,8 +56,8 @@ mask_page_hint_bits(Page page) > > > > /* > > * During replay, if the page LSN has advanced past our XLOG reco= rd's LSN, > > - * we don't mark the page all-visible. See heap_xlog_visible() fo= r > > - * details. > > + * we don't mark the page all-visible. See heap_xlog_prune_freeze= () for > > + * more details. > > */ > > PageClearAllVisible(page); > > } > > Not introduced by your change, but isn't it rather terrifying that the > wal_consistency_checking infrastructure doesn't verify whether the page i= s > marked all-visible? Wasn't aware of this. Seems bonkers to me. Agreed. I wonder what it would take to start. > I don't even know what specifically in heap_xlog_visible() that comment i= s > referring to? Just that we only do PageSetAllVisible() if BLK_NEEDS_REDO?= But > uh, what does that have to do with anything? Yea, this comment doesn't make sense. I think we should remove it. But regarding why we mask PD_ALL_VISIBLE in wal consistency checking, I wonder if this is the scenario: Record 1 sets the VM and PD_ALL_VISIBLE Record 2 inserts a tuple and clears PD_ALL_VISIBLE the heap page is flushed to disk, but the VM page is not crash replay R1; skip setting PD_ALL_VISIBLE because the page has R2's LSN; set the bits on the VM page Even though we'll clear the VM when we replay R2, if we cross-check the page and VM after replaying only R1, the VM will be set and PD_ALL_VISIBLE will be clear. I think this is okay because no one should see them at this time. But it might not work with wal consistency checking. > > @@ -477,12 +477,12 @@ ResolveRecoveryConflictWithSnapshot(TransactionId= snapshotConflictHorizon, > > * If we get passed InvalidTransactionId then we do nothing (no c= onflict). > > * > > * This can happen when replaying already-applied WAL records aft= er a > > - * standby crash or restart, or when replaying an XLOG_HEAP2_VISI= BLE > > - * record that marks as frozen a page which was already all-visib= le. It's > > - * also quite common with records generated during index deletion > > - * (original execution of the deletion can reason that a recovery= conflict > > - * which is sufficient for the deletion operation must take place= before > > - * replay of the deletion record itself). > > + * standby crash or restart > > Again not about your patch: I don't understand how already applied WAL ca= n > lead to InvalidTransactionId being passed here. The record doesn't change= just > because we had already applied the WAL? Yea, I think the comment is just wrong. I realized the comment still needed to reference my code, so I've updated it. > > From 04b03c1ec3abcee75e464fef994b482df41b35f4 Mon Sep 17 00:00:00 2001 > > From: Melanie Plageman > > Date: Wed, 3 Dec 2025 15:07:24 -0500 > > Subject: [PATCH v40 08/12] Track which relations are modified by a quer= y > > > > Save the relids of modified relations in a bitmap in the executor state= . > > A later commit will pass this information down to scan nodes to control > > whether or not on-access pruning is allowed to set the visibility map. > > Setting the visibility map during a scan is counterproductive if the > > query is going to modify the page immediately after. > > > > Relations are considered modified if they are the target of INSERT, > > UPDATE, DELETE, or MERGE, or if they have any row mark (including SELEC= T > > FOR UPDATE/SHARE). All row mark types are included, even those which > > don't actually modify tuples, because this bitmap is only used as a hin= t > > to avoid unnecessary work. > > You're probably going to hate me for the question, but is there a reason = to > not compute es_modified_relids at plan time? Yea, it probably does make more sense there. The only thing is that by doing it in planner, it could include relids of leaf partitions that get run-time pruned. But we won't scan those, so it is no issue for this feature. I'm just wondering if it dilutes the meaning of "modified relids", though. In v41, I've implemented it in planner (which also made me realize parallel workers previously didn't have es_modified_relids, oops). > > @@ -992,6 +996,10 @@ InitPlan(QueryDesc *queryDesc, int eflags) > > */ > > planstate =3D ExecInitNode(plan, estate, eflags); > > > > +#ifdef USE_ASSERT_CHECKING > > + CrossCheckModifiedRelids(estate); > > +#endif > > Not sure that buys you much, given it pretty much is just a restatement o= f the > code building estate->es_modified_relids. Yea, now that I've done it in planner, I cross-check in the executor. > What about checking against PlannedStmt->{resultRelations, permInfos} or I don't think it makes sense to use permInfos because according to expand_single_inheritance_child() there is no permission checking for child RTEs, so I think permInfos won't include everything we need. > asserting membership at the places that actually lock/modify? Are you thinking I should also add some in ExecInsert, ExecDelete, ExecUpdate, and ExecLockRows? Think this might be redundant with the executor cross-check I have now after InitPlan(). (I've done it anyway so we can discuss). > > diff --git a/src/include/access/genam.h b/src/include/access/genam.h > > index 1a27bf060b3..db102803eb5 100644 > > --- a/src/include/access/genam.h > > +++ b/src/include/access/genam.h > > @@ -158,7 +158,7 @@ extern IndexScanDesc index_beginscan(Relation heapR= elation, > > = Relation indexRelation, > > = Snapshot snapshot, > > = IndexScanInstrumentation *instrument, > > - = int nkeys, int norderbys); > > + = int nkeys, int norderbys, uint32 flags); > > I'd probably put flags in a position where it's not as easily confused wi= th > nkeys or norderbys. Do you mean like move it before nkeys and norderbys or move it earlier? I did the latter but not sure if it's weird to have flags before snapshot (especially since the other table am routines pass it last). I think it looks kind of weird when all of the other ones have flags as the last argument. > > @@ -1059,10 +1062,11 @@ table_scan_getnextslot(TableScanDesc sscan, Sca= nDirection direction, TupleTableS > > static inline TableScanDesc > > table_beginscan_tidrange(Relation rel, Snapshot snapshot, > > ItemPointer mintid, > > - ItemPointer maxtid) > > + ItemPointer maxtid, uint= 32 flags) > > { > > TableScanDesc sscan; > > - uint32 flags =3D SO_TYPE_TIDRANGESCAN | SO_ALLOW_PAGEMOD= E; > > + > > + flags |=3D SO_TYPE_TIDRANGESCAN | SO_ALLOW_PAGEMODE; > > > > sscan =3D table_beginscan_common(rel, snapshot, 0, NULL, NULL, fl= ags); > > Hm. Would it perhaps be a good idea to have an assert as to which flags a= re > specified by the "user"? If e.g. another SO_TYPE_* were specified it migh= t > result in some odd behaviour. > > Perhaps this would be best done by adding an argument to > table_beginscan_common() specifying the "internal" flags (i.e. the ones t= hat > specified inside table_beginscan_*) and user specified flags? Then > table_beginscan_common could check the set of user specified flags being = sane. Yes, good idea. Done in attached v41. It's unclear to me which flags should be considered internal though. I think it makes sense that the SO_TYPE* flags are considered internal because you can only specify one. But all of the other current ScanOptions are specified inside table_beginscan_* so do you mean that we should consider all of those internal flags? > > + * Some optimizations can only be performed if the query does not= modify > > + * the underlying relation. Track that here. > > + */ > > + bool modifies_base_rel; > > } IndexFetchHeapData; > > Wonder if this should be in the generic IndexFetchTableData? I added flags to the IndexFetchTableData in much the same way as the regular table scan descriptor has them. > > diff --git a/src/test/recovery/t/035_standby_logical_decoding.pl b/src/= test/recovery/t/035_standby_logical_decoding.pl > > index d264a698ff6..a5536ba4ff6 100644 > > --- a/src/test/recovery/t/035_standby_logical_decoding.pl > > +++ b/src/test/recovery/t/035_standby_logical_decoding.pl > > @@ -296,6 +296,7 @@ wal_level =3D 'logical' > > max_replication_slots =3D 4 > > max_wal_senders =3D 4 > > autovacuum =3D off > > +hot_standby_feedback =3D on > > }); > > $node_primary->dump_info; > > $node_primary->start; > > @@ -748,7 +749,7 @@ check_pg_recvlogical_stderr($handle, > > $logstart =3D -s $node_standby->logfile; > > > > reactive_slots_change_hfs_and_wait_for_xmins('shared_row_removal_', > > - 'no_conflict_', 0, 1); > > + 'no_conflict_', 1, 0); > > > > # This should not trigger a conflict > > wait_until_vacuum_can_remove( > > -- > > 2.43.0 > > Why does this patch need to change anything here? Is the test buggy > independently? Nope. I guess that was a mistake during development. No change needed. > > @@ -1863,16 +1864,14 @@ heap_prune_record_unchanged_lp_normal(PruneStat= e *prstate, OffsetNumber offnum) > > prstate->set_all_visible =3D false; > > prstate->set_all_frozen =3D false; > > > > - /* The page should not be marked all-visible */ > > - if (PageIsAllVisible(page)) > > - heap_fix_vm_corruption(prstate, offnum); > > - > > Huh? heap_prune_record_prunable() already does the corruption check, so I don't need to do it separately for INSERT_IN_PROGRESS tuples once we call heap_prune_record_prunable() for them. - Melanie --00000000000060fd69064d6b968a Content-Type: text/x-patch; charset="US-ASCII"; name="v41-0001-Fix-visibility-map-corruption-in-more-cases.patch" Content-Disposition: attachment; filename="v41-0001-Fix-visibility-map-corruption-in-more-cases.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmyafw870 RnJvbSBjODdkZDAzZWMzMDllMTIyNDdjOGNjZGMzYWRmMjg5YTFlNDUxMjU1IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBXZWQsIDI1IEZlYiAyMDI2IDE2OjIzOjA5IC0wNTAwClN1YmplY3Q6IFtQ QVRDSCB2NDEgMDEvMTJdIEZpeCB2aXNpYmlsaXR5IG1hcCBjb3JydXB0aW9uIGluIG1vcmUgY2Fz ZXMKCk1vdmUgVk0gY29ycnVwdGlvbiBkZXRlY3Rpb24gYW5kIHJlcGFpciBpbnRvIHBydW5pbmcu IFRoaXMgYWxsb3dzIFZNCnJlcGFpciBkdXJpbmcgb24tYWNjZXNzIHBydW5pbmcsIG5vdCBvbmx5 IGR1cmluZyB2YWN1dW0uCgpBbHNvLCBleHBhbmQgY29ycnVwdGlvbiBkZXRlY3Rpb24gdG8gY292 ZXIgcGFnZXMgbWFya2VkIGFsbC12aXNpYmxlIHRoYXQKY29udGFpbiBkZWFkIHR1cGxlcyBhbmQg dHVwbGVzIGluc2VydGVkIG9yIHVwZGF0ZWQgYnkgaW4tcHJvZ3Jlc3MKdHJhbnNhY3Rpb25zLCBy YXRoZXIgdGhhbiBvbmx5IGFsbC12aXNpYmxlIHBhZ2VzIHdpdGggTFBfREVBRCBpdGVtcy4KClBp bm5pbmcgdGhlIGNvcnJlY3QgVk0gcGFnZSBiZWZvcmUgb24tYWNjZXNzIHBydW5pbmcgaXMgY2hl YXAgd2hlbgpjb21wYXJlZCB0byB0aGUgY29zdCBvZiBhY3R1YWxseSBwcnVuaW5nLiBUaGUgdm1i dWZmZXIgaXMgc2F2ZWQgaW4gdGhlCnNjYW4gZGVzY3JpcHRvciwgc28gYSBxdWVyeSBzaG91bGQg b25seSBuZWVkIHRvIHBpbiBlYWNoIFZNIHBhZ2Ugb25jZQphbmQgYSBzaW5nbGUgVk0gcGFnZSBj b3ZlcnMgYSBsYXJnZSBudW1iZXIgb2YgaGVhcCBwYWdlcy4KCkF1dGhvcjogTWVsYW5pZSBQbGFn ZW1hbiA8bWVsYW5pZXBsYWdlbWFuQGdtYWlsLmNvbT4KUmV2aWV3ZWQtYnk6IEFuZHJlcyBGcmV1 bmQgPGFuZHJlc0BhbmFyYXplbC5kZT4KUmV2aWV3ZWQtYnk6IENoYW8gTGkgPGxpLmV2YW4uY2hh b0BnbWFpbC5jb20+ClJldmlld2VkLWJ5OiBLaXJpbGwgUmVzaGtlIDxyZXNoa2VraXJpbGxAZ21h aWwuY29tPgpEaXNjdXNzaW9uOiBodHRwczovL3Bvc3Rnci5lcy9tL2JxYzRraDVtaWRmbjQ0Z25q aXFlejNianF2NHpvZ3lkZ3V2ZG40NDZyaXc0NWpjZjN5JTQwNGV6NjZpbDdlYnZrCi0tLQogc3Jj L2JhY2tlbmQvYWNjZXNzL2hlYXAvcHJ1bmVoZWFwLmMgIHwgMjE1ICsrKysrKysrKysrKysrKysr KysrKysrKystLQogc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvdmFjdXVtbGF6eS5jIHwgIDg5ICst LS0tLS0tLS0tCiBzcmMvaW5jbHVkZS9hY2Nlc3MvaGVhcGFtLmggICAgICAgICAgfCAgMTIgKysK IHNyYy90b29scy9wZ2luZGVudC90eXBlZGVmcy5saXN0ICAgICB8ICAgMSArCiA0IGZpbGVzIGNo YW5nZWQsIDIxNSBpbnNlcnRpb25zKCspLCAxMDIgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEv c3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvcHJ1bmVoZWFwLmMgYi9zcmMvYmFja2VuZC9hY2Nlc3Mv aGVhcC9wcnVuZWhlYXAuYwppbmRleCA4ZDlmMDY5NDIwNi4uZTQ1MmQyNWNhZTYgMTAwNjQ0Ci0t LSBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3BydW5laGVhcC5jCisrKyBiL3NyYy9iYWNrZW5k L2FjY2Vzcy9oZWFwL3BydW5laGVhcC5jCkBAIC0xOSw3ICsxOSw3IEBACiAjaW5jbHVkZSAiYWNj ZXNzL2h0dXBfZGV0YWlscy5oIgogI2luY2x1ZGUgImFjY2Vzcy9tdWx0aXhhY3QuaCIKICNpbmNs dWRlICJhY2Nlc3MvdHJhbnNhbS5oIgotI2luY2x1ZGUgImFjY2Vzcy92aXNpYmlsaXR5bWFwZGVm cy5oIgorI2luY2x1ZGUgImFjY2Vzcy92aXNpYmlsaXR5bWFwLmgiCiAjaW5jbHVkZSAiYWNjZXNz L3hsb2cuaCIKICNpbmNsdWRlICJhY2Nlc3MveGxvZ2luc2VydC5oIgogI2luY2x1ZGUgImNvbW1h bmRzL3ZhY3V1bS5oIgpAQCAtMTE0LDYgKzExNCwyMSBAQCB0eXBlZGVmIHN0cnVjdAogCSAqLwog CUhlYXBQYWdlRnJlZXplIHBhZ2Vmcno7CiAKKwkvKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKwkgKiBXb3JraW5nIHN0YXRlIGZvciB2aXNp YmlsaXR5IG1hcCBwcm9jZXNzaW5nCisJICotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisJICovCisKKwkvKgorCSAqIENhbGxlciBtdXN0IHBy b3ZpZGUgYSBwaW5uZWQgdm1idWZmZXIgY29ycmVzcG9uZGluZyB0byB0aGUgaGVhcCBibG9jawor CSAqIHBhc3NlZCB0byBoZWFwX3BhZ2VfcHJ1bmVfYW5kX2ZyZWV6ZSgpLiBXZSB3aWxsIGZpeCBh bnkgY29ycnVwdGlvbgorCSAqIGZvdW5kIGluIHRoZSBWTS4KKwkgKi8KKwlCdWZmZXIJCXZtYnVm ZmVyOworCisJLyogQml0cyBpbiB0aGUgdm1idWZmZXIgZm9yIHRoaXMgaGVhcCBwYWdlICovCisJ dWludDgJCW9sZF92bWJpdHM7CisKIAkvKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIAkgKiBJbmZvcm1hdGlvbiBhYm91dCB3aGF0IHdhcyBk b25lCiAJICoKQEAgLTE2MiwxMiArMTc3LDMwIEBAIHR5cGVkZWYgc3RydWN0CiAJVHJhbnNhY3Rp b25JZCB2aXNpYmlsaXR5X2N1dG9mZl94aWQ7CiB9IFBydW5lU3RhdGU7CiAKKworLyoKKyAqIFR5 cGUgb2YgdmlzaWJpbGl0eSBtYXAgY29ycnVwdGlvbiBkZXRlY3RlZCBvbiBhIGhlYXAgcGFnZS4g IFBhc3NlZCB0bworICogaGVhcF9wYWdlX2ZpeF92bV9jb3JydXB0aW9uKCkgc28gdGhlIGNhbGxl ciBjYW4gc3BlY2lmeSB3aGF0IGl0IGZvdW5kIHJhdGhlcgorICogdGhhbiBoYXZpbmcgdGhlIGZ1 bmN0aW9uIHJlLWRlcml2ZSB0aGUgY29ycnVwdGlvbiBmcm9tIHBhZ2Ugc3RhdGUuCisgKi8KK3R5 cGVkZWYgZW51bSBWTUNvcnJ1cHRpb25UeXBlCit7CisJLyogVk0gYml0cyBhcmUgc2V0IGJ1dCB0 aGUgcGFnZS1sZXZlbCBQRF9BTExfVklTSUJMRSBmbGFnIGlzIG5vdCAqLworCVZNX0NPUlJVUFRf TUlTU0lOR19QQUdFX0hJTlQsCisJLyogTFBfREVBRCBsaW5lIHBvaW50ZXJzIGZvdW5kIG9uIGEg cGFnZSBtYXJrZWQgYWxsLXZpc2libGUgKi8KKwlWTV9DT1JSVVBUX0xQREVBRCwKKwkvKiBUdXBs ZSBub3QgdmlzaWJsZSB0byBhbGwgdHJhbnNhY3Rpb25zIG9uIGEgcGFnZSBtYXJrZWQgYWxsLXZp c2libGUgKi8KKwlWTV9DT1JSVVBUX1RVUExFX1ZJU0lCSUxJVFksCit9IFZNQ29ycnVwdGlvblR5 cGU7CisKIC8qIExvY2FsIGZ1bmN0aW9ucyAqLwogc3RhdGljIHZvaWQgcHJ1bmVfZnJlZXplX3Nl dHVwKFBydW5lRnJlZXplUGFyYW1zICpwYXJhbXMsCiAJCQkJCQkJICAgVHJhbnNhY3Rpb25JZCAq bmV3X3JlbGZyb3plbl94aWQsCiAJCQkJCQkJICAgTXVsdGlYYWN0SWQgKm5ld19yZWxtaW5fbXhp ZCwKIAkJCQkJCQkgICBQcnVuZUZyZWV6ZVJlc3VsdCAqcHJlc3VsdCwKIAkJCQkJCQkgICBQcnVu ZVN0YXRlICpwcnN0YXRlKTsKK3N0YXRpYyB2b2lkIGhlYXBfcGFnZV9maXhfdm1fY29ycnVwdGlv bihQcnVuZVN0YXRlICpwcnN0YXRlLCBPZmZzZXROdW1iZXIgb2ZmbnVtLAorCQkJCQkJCQkJCVZN Q29ycnVwdGlvblR5cGUgY3R5cGUpOwogc3RhdGljIHZvaWQgcHJ1bmVfZnJlZXplX3BsYW4oUHJ1 bmVTdGF0ZSAqcHJzdGF0ZSwKIAkJCQkJCQkgIE9mZnNldE51bWJlciAqb2ZmX2xvYyk7CiBzdGF0 aWMgSFRTVl9SZXN1bHQgaGVhcF9wcnVuZV9zYXRpc2ZpZXNfdmFjdXVtKFBydW5lU3RhdGUgKnBy c3RhdGUsCkBAIC0xNzUsNyArMjA4LDggQEAgc3RhdGljIEhUU1ZfUmVzdWx0IGhlYXBfcHJ1bmVf c2F0aXNmaWVzX3ZhY3V1bShQcnVuZVN0YXRlICpwcnN0YXRlLAogc3RhdGljIGlubGluZSBIVFNW X1Jlc3VsdCBodHN2X2dldF92YWxpZF9zdGF0dXMoaW50IHN0YXR1cyk7CiBzdGF0aWMgdm9pZCBo ZWFwX3BydW5lX2NoYWluKE9mZnNldE51bWJlciBtYXhvZmYsCiAJCQkJCQkJIE9mZnNldE51bWJl ciByb290b2ZmbnVtLCBQcnVuZVN0YXRlICpwcnN0YXRlKTsKLXN0YXRpYyB2b2lkIGhlYXBfcHJ1 bmVfcmVjb3JkX3BydW5hYmxlKFBydW5lU3RhdGUgKnByc3RhdGUsIFRyYW5zYWN0aW9uSWQgeGlk KTsKK3N0YXRpYyB2b2lkIGhlYXBfcHJ1bmVfcmVjb3JkX3BydW5hYmxlKFBydW5lU3RhdGUgKnBy c3RhdGUsIFRyYW5zYWN0aW9uSWQgeGlkLAorCQkJCQkJCQkJICAgT2Zmc2V0TnVtYmVyIG9mZm51 bSk7CiBzdGF0aWMgdm9pZCBoZWFwX3BydW5lX3JlY29yZF9yZWRpcmVjdChQcnVuZVN0YXRlICpw cnN0YXRlLAogCQkJCQkJCQkJICAgT2Zmc2V0TnVtYmVyIG9mZm51bSwgT2Zmc2V0TnVtYmVyIHJk b2ZmbnVtLAogCQkJCQkJCQkJICAgYm9vbCB3YXNfbm9ybWFsKTsKQEAgLTIwOSw4ICsyNDMsOSBA QCBzdGF0aWMgYm9vbCBoZWFwX3BhZ2Vfd2lsbF9mcmVlemUoYm9vbCBkaWRfdHVwbGVfaGludF9m cGksIGJvb2wgZG9fcHJ1bmUsIGJvb2wgZAogICogQ2FsbGVyIG11c3QgaGF2ZSBwaW4gb24gdGhl IGJ1ZmZlciwgYW5kIG11c3QgKm5vdCogaGF2ZSBhIGxvY2sgb24gaXQuCiAgKgogICogVGhpcyBm dW5jdGlvbiBtYXkgcGluICp2bWJ1ZmZlci4gSXQncyBwYXNzZWQgYnkgcmVmZXJlbmNlIHNvIHRo ZSBjYWxsZXIgY2FuCi0gKiByZXVzZSB0aGUgcGluIGFjcm9zcyBjYWxscywgYXZvaWRpbmcgcmVw ZWF0ZWQgcGluL3VucGluIGN5Y2xlcy4gQ2FsbGVyIGlzCi0gKiByZXNwb25zaWJsZSBmb3IgdW5w aW5uaW5nIGl0LgorICogcmV1c2UgdGhlIHBpbiBhY3Jvc3MgY2FsbHMsIGF2b2lkaW5nIHJlcGVh dGVkIHBpbi91bnBpbiBjeWNsZXMuIElmIHdlIGZpbmQKKyAqIFZNIGNvcnJ1cHRpb24gZHVyaW5n IHBydW5pbmcsIHdlIHdpbGwgZml4IGl0LiBDYWxsZXIgaXMgcmVzcG9uc2libGUgZm9yCisgKiB1 bnBpbm5pbmcgKnZtYnVmZmVyLgogICovCiB2b2lkCiBoZWFwX3BhZ2VfcHJ1bmVfb3B0KFJlbGF0 aW9uIHJlbGF0aW9uLCBCdWZmZXIgYnVmZmVyLCBCdWZmZXIgKnZtYnVmZmVyKQpAQCAtMjc3LDYg KzMxMiwxNiBAQCBoZWFwX3BhZ2VfcHJ1bmVfb3B0KFJlbGF0aW9uIHJlbGF0aW9uLCBCdWZmZXIg YnVmZmVyLCBCdWZmZXIgKnZtYnVmZmVyKQogCQl7CiAJCQlPZmZzZXROdW1iZXIgZHVtbXlfb2Zm X2xvYzsKIAkJCVBydW5lRnJlZXplUmVzdWx0IHByZXN1bHQ7CisJCQlQcnVuZUZyZWV6ZVBhcmFt cyBwYXJhbXM7CisKKwkJCXZpc2liaWxpdHltYXBfcGluKHJlbGF0aW9uLCBCdWZmZXJHZXRCbG9j a051bWJlcihidWZmZXIpLCB2bWJ1ZmZlcik7CisKKwkJCXBhcmFtcy5yZWxhdGlvbiA9IHJlbGF0 aW9uOworCQkJcGFyYW1zLmJ1ZmZlciA9IGJ1ZmZlcjsKKwkJCXBhcmFtcy52bWJ1ZmZlciA9ICp2 bWJ1ZmZlcjsKKwkJCXBhcmFtcy5yZWFzb24gPSBQUlVORV9PTl9BQ0NFU1M7CisJCQlwYXJhbXMu dmlzdGVzdCA9IHZpc3Rlc3Q7CisJCQlwYXJhbXMuY3V0b2ZmcyA9IE5VTEw7CiAKIAkJCS8qCiAJ CQkgKiBXZSBkb24ndCBwYXNzIHRoZSBIRUFQX1BBR0VfUFJVTkVfTUFSS19VTlVTRURfTk9XIG9w dGlvbgpAQCAtMjg0LDE0ICszMjksNyBAQCBoZWFwX3BhZ2VfcHJ1bmVfb3B0KFJlbGF0aW9uIHJl bGF0aW9uLCBCdWZmZXIgYnVmZmVyLCBCdWZmZXIgKnZtYnVmZmVyKQogCQkJICogY2Fubm90IHNh ZmVseSBkZXRlcm1pbmUgdGhhdCBkdXJpbmcgb24tYWNjZXNzIHBydW5pbmcgd2l0aCB0aGUKIAkJ CSAqIGN1cnJlbnQgaW1wbGVtZW50YXRpb24uCiAJCQkgKi8KLQkJCVBydW5lRnJlZXplUGFyYW1z IHBhcmFtcyA9IHsKLQkJCQkucmVsYXRpb24gPSByZWxhdGlvbiwKLQkJCQkuYnVmZmVyID0gYnVm ZmVyLAotCQkJCS5yZWFzb24gPSBQUlVORV9PTl9BQ0NFU1MsCi0JCQkJLm9wdGlvbnMgPSAwLAot CQkJCS52aXN0ZXN0ID0gdmlzdGVzdCwKLQkJCQkuY3V0b2ZmcyA9IE5VTEwsCi0JCQl9OworCQkJ cGFyYW1zLm9wdGlvbnMgPSAwOwogCiAJCQloZWFwX3BhZ2VfcHJ1bmVfYW5kX2ZyZWV6ZSgmcGFy YW1zLCAmcHJlc3VsdCwgJmR1bW15X29mZl9sb2MsCiAJCQkJCQkJCQkgICBOVUxMLCBOVUxMKTsK QEAgLTM1NCw2ICszOTIsMTIgQEAgcHJ1bmVfZnJlZXplX3NldHVwKFBydW5lRnJlZXplUGFyYW1z ICpwYXJhbXMsCiAJcHJzdGF0ZS0+YnVmZmVyID0gcGFyYW1zLT5idWZmZXI7CiAJcHJzdGF0ZS0+ cGFnZSA9IEJ1ZmZlckdldFBhZ2UocGFyYW1zLT5idWZmZXIpOwogCisJQXNzZXJ0KEJ1ZmZlcklz VmFsaWQocGFyYW1zLT52bWJ1ZmZlcikpOworCXByc3RhdGUtPnZtYnVmZmVyID0gcGFyYW1zLT52 bWJ1ZmZlcjsKKwlwcnN0YXRlLT5vbGRfdm1iaXRzID0gdmlzaWJpbGl0eW1hcF9nZXRfc3RhdHVz KHByc3RhdGUtPnJlbGF0aW9uLAorCQkJCQkJCQkJCQkJICAgcHJzdGF0ZS0+YmxvY2ssCisJCQkJ CQkJCQkJCQkgICAmcHJzdGF0ZS0+dm1idWZmZXIpOworCiAJLyoKIAkgKiBPdXIgc3RyYXRlZ3kg aXMgdG8gc2NhbiB0aGUgcGFnZSBhbmQgbWFrZSBsaXN0cyBvZiBpdGVtcyB0byBjaGFuZ2UsCiAJ ICogdGhlbiBhcHBseSB0aGUgY2hhbmdlcyB3aXRoaW4gYSBjcml0aWNhbCBzZWN0aW9uLiAgVGhp cyBrZWVwcyBhcyBtdWNoCkBAIC03NzAsNiArODE0LDEwNCBAQCBoZWFwX3BhZ2Vfd2lsbF9mcmVl emUoYm9vbCBkaWRfdHVwbGVfaGludF9mcGksCiAJcmV0dXJuIGRvX2ZyZWV6ZTsKIH0KIAorLyoK KyAqIEVtaXQgYSB3YXJuaW5nIGFib3V0IGFuZCBmaXggdmlzaWJpbGl0eSBtYXAgY29ycnVwdGlv biBvbiB0aGUgZ2l2ZW4gcGFnZS4KKyAqCisgKiBUaGUgY2FsbGVyIHNwZWNpZmllcyB0aGUgdHlw ZSBvZiBjb3JydXB0aW9uIGl0IGhhcyBhbHJlYWR5IGRldGVjdGVkIHZpYQorICogY29ycnVwdGlv bl90eXBlLCBzbyB0aGF0IHdlIGNhbiBlbWl0IHRoZSBhcHByb3ByaWF0ZSB3YXJuaW5nLiBBbGwg Y2FzZXMKKyAqIHJlc3VsdCBpbiB0aGUgVk0gYml0cyBiZWluZyBjbGVhcmVkOyBwYWdlLWxldmVs IGNvcnJ1cHRpb24gdHlwZXMgYWxzbyBjbGVhcgorICogUERfQUxMX1ZJU0lCTEUuCisgKgorICog TXVzdCBiZSBjYWxsZWQgd2hpbGUgaG9sZGluZyBhbiBleGNsdXNpdmUgbG9jayBvbiB0aGUgaGVh cCBidWZmZXIuIERlYWQKKyAqIGl0ZW1zIG11c3QgaGF2ZSBiZWVuIGRpc2NvdmVyZWQgdW5kZXIg dGhhdCBzYW1lIGxvY2suIEFsdGhvdWdoIHdlIGRvIG5vdAorICogaG9sZCBhIGxvY2sgb24gdGhl IFZNIGJ1ZmZlciwgaXQgaXMgcGlubmVkLCBhbmQgdGhlIGhlYXAgYnVmZmVyIGlzCisgKiBleGNs dXNpdmVseSBsb2NrZWQsIGVuc3VyaW5nIHRoYXQgbm8gb3RoZXIgYmFja2VuZCBjYW4gdXBkYXRl IHRoZSBWTSBiaXRzCisgKiBjb3JyZXNwb25kaW5nIHRvIHRoaXMgaGVhcCBwYWdlLgorICoKKyAq IFRoaXMgZnVuY3Rpb24gbWFrZXMgY2hhbmdlcyB0byB0aGUgVk0gYW5kLCBwb3RlbnRpYWxseSwg dGhlIGhlYXAgcGFnZSwgYnV0CisgKiBpdCBkb2VzIG5vdCBuZWVkIHRvIGJlIGRvbmUgaW4gYSBj cml0aWNhbCBzZWN0aW9uLgorICovCitzdGF0aWMgdm9pZAoraGVhcF9wYWdlX2ZpeF92bV9jb3Jy dXB0aW9uKFBydW5lU3RhdGUgKnByc3RhdGUsIE9mZnNldE51bWJlciBvZmZudW0sCisJCQkJCQkJ Vk1Db3JydXB0aW9uVHlwZSBjb3JydXB0aW9uX3R5cGUpCit7CisJY29uc3QgY2hhciAqcmVsbmFt ZSA9IFJlbGF0aW9uR2V0UmVsYXRpb25OYW1lKHByc3RhdGUtPnJlbGF0aW9uKTsKKworCUFzc2Vy dChCdWZmZXJJc0xvY2tlZEJ5TWVJbk1vZGUocHJzdGF0ZS0+YnVmZmVyLCBCVUZGRVJfTE9DS19F WENMVVNJVkUpKTsKKworCXN3aXRjaCAoY29ycnVwdGlvbl90eXBlKQorCXsKKwkJY2FzZSBWTV9D T1JSVVBUX0xQREVBRDoKKwkJCWVyZXBvcnQoV0FSTklORywKKwkJCQkJKGVycmNvZGUoRVJSQ09E RV9EQVRBX0NPUlJVUFRFRCksCisJCQkJCSBlcnJtc2coImRlYWQgbGluZSBwb2ludGVyIGZvdW5k IG9uIHBhZ2UgbWFya2VkIGFsbC12aXNpYmxlIiksCisJCQkJCSBlcnJjb250ZXh0KCJyZWxhdGlv biBcIiVzXCIsIHBhZ2UgJXUsIHR1cGxlICV1IiwKKwkJCQkJCQkJcmVsbmFtZSwgcHJzdGF0ZS0+ YmxvY2ssIG9mZm51bSkpKTsKKwkJCWJyZWFrOworCisJCWNhc2UgVk1fQ09SUlVQVF9UVVBMRV9W SVNJQklMSVRZOgorCisJCQkvKgorCQkJICogQSBIRUFQVFVQTEVfTElWRSB0dXBsZSBvbiBhbiBh bGwtdmlzaWJsZSBwYWdlIGNhbiBhcHBlYXIgdG8gbm90CisJCQkgKiBiZSB2aXNpYmxlIHRvIGV2 ZXJ5b25lIHdoZW4KKwkJCSAqIEdldE9sZGVzdE5vblJlbW92YWJsZVRyYW5zYWN0aW9uSWQoKSBy ZXR1cm5zIGEgY29uc2VydmF0aXZlCisJCQkgKiB2YWx1ZSB0aGF0J3Mgb2xkZXIgdGhhbiB0aGUg cmVhbCBzYWZlIHhtaW4uIFRoYXQgaXMgbm90CisJCQkgKiBjb3JydXB0aW9uIC0tIHRoZSBQRF9B TExfVklTSUJMRSBmbGFnIGlzIHN0aWxsIGNvcnJlY3QuCisJCQkgKgorCQkJICogSG93ZXZlciwg ZGVhZCB0dXBsZSB2ZXJzaW9ucywgaW4tcHJvZ3Jlc3MgaW5zZXJ0cywgYW5kCisJCQkgKiBpbi1w cm9ncmVzcyBkZWxldGVzIHNob3VsZCBuZXZlciBhcHBlYXIgb24gYSBwYWdlIG1hcmtlZAorCQkJ ICogYWxsLXZpc2libGUuIFRoYXQgaW5kaWNhdGVzIHJlYWwgY29ycnVwdGlvbi4gUERfQUxMX1ZJ U0lCTEUKKwkJCSAqIHNob3VsZCBoYXZlIGJlZW4gY2xlYXJlZCBieSB0aGUgRE1MIG9wZXJhdGlv biB0aGF0IGRlbGV0ZWQgb3IKKwkJCSAqIGluc2VydGVkIHRoZSB0dXBsZS4KKwkJCSAqLworCQkJ ZXJlcG9ydChXQVJOSU5HLAorCQkJCQkoZXJyY29kZShFUlJDT0RFX0RBVEFfQ09SUlVQVEVEKSwK KwkJCQkJIGVycm1zZygidHVwbGUgbm90IHZpc2libGUgdG8gYWxsIHRyYW5zYWN0aW9ucyBmb3Vu ZCBvbiBwYWdlIG1hcmtlZCBhbGwtdmlzaWJsZSIpLAorCQkJCQkgZXJyY29udGV4dCgicmVsYXRp b24gXCIlc1wiLCBwYWdlICV1LCB0dXBsZSAldSIsCisJCQkJCQkJCXJlbG5hbWUsIHByc3RhdGUt PmJsb2NrLCBvZmZudW0pKSk7CisJCQlicmVhazsKKworCQljYXNlIFZNX0NPUlJVUFRfTUlTU0lO R19QQUdFX0hJTlQ6CisKKwkJCS8qCisJCQkgKiBBcyBvZiBQb3N0Z3JlU1FMIDkuMiwgdGhlIHZp c2liaWxpdHkgbWFwIGJpdCBzaG91bGQgbmV2ZXIgYmUKKwkJCSAqIHNldCBpZiB0aGUgcGFnZS1s ZXZlbCBiaXQgaXMgY2xlYXIuIEhvd2V2ZXIsIGZvciB2YWN1dW0sIGl0J3MKKwkJCSAqIHBvc3Np YmxlIHRoYXQgdGhlIGJpdCBnb3QgY2xlYXJlZCBhZnRlcgorCQkJICogaGVhcF92YWNfc2Nhbl9u ZXh0X2Jsb2NrKCkgd2FzIGNhbGxlZCwgc28gd2UgbXVzdCByZWNoZWNrIG5vdworCQkJICogdGhh dCB3ZSBoYXZlIHRoZSBidWZmZXIgbG9jayBiZWZvcmUgY29uY2x1ZGluZyB0aGF0IHRoZSBWTSBp cworCQkJICogY29ycnVwdC4KKwkJCSAqLworCQkJQXNzZXJ0KCFQYWdlSXNBbGxWaXNpYmxlKHBy c3RhdGUtPnBhZ2UpKTsKKwkJCUFzc2VydChwcnN0YXRlLT5vbGRfdm1iaXRzICYgVklTSUJJTElU WU1BUF9WQUxJRF9CSVRTKTsKKwkJCWVyZXBvcnQoV0FSTklORywKKwkJCQkJKGVycmNvZGUoRVJS Q09ERV9EQVRBX0NPUlJVUFRFRCksCisJCQkJCSBlcnJtc2coInBhZ2UgaXMgbm90IG1hcmtlZCBh bGwtdmlzaWJsZSBidXQgdmlzaWJpbGl0eSBtYXAgYml0IGlzIHNldCIpLAorCQkJCQkgZXJyY29u dGV4dCgicmVsYXRpb24gXCIlc1wiLCBwYWdlICV1IiwKKwkJCQkJCQkJcmVsbmFtZSwgcHJzdGF0 ZS0+YmxvY2spKSk7CisJCQlicmVhazsKKworCQlkZWZhdWx0OgorCQkJZWxvZyhFUlJPUiwgInVu cmVjb2duaXplZCBWTSBjb3JydXB0aW9uIHR5cGU6ICVkIiwKKwkJCQkgKGludCkgY29ycnVwdGlv bl90eXBlKTsKKwkJCWJyZWFrOworCX0KKworCS8qCisJICogQ2xlYXIgUERfQUxMX1ZJU0lCTEUg b24gdGhlIGhlYXAgcGFnZSBpZiBpdCBpcyBzZXQuCisJICogVk1fQ09SUlVQVF9NSVNTSU5HX1BB R0VfSElOVCBpcyBhbHJlYWR5IGNsZWFyIGJ5IGRlZmluaXRpb24sIHNvIGF2b2lkCisJICogbWFy a2luZyB0aGUgYnVmZmVyIGRpcnR5LgorCSAqLworCWlmIChjb3JydXB0aW9uX3R5cGUgIT0gVk1f Q09SUlVQVF9NSVNTSU5HX1BBR0VfSElOVCkKKwl7CisJCUFzc2VydChQYWdlSXNBbGxWaXNpYmxl KHByc3RhdGUtPnBhZ2UpKTsKKwkJUGFnZUNsZWFyQWxsVmlzaWJsZShwcnN0YXRlLT5wYWdlKTsK KwkJTWFya0J1ZmZlckRpcnR5SGludChwcnN0YXRlLT5idWZmZXIsIHRydWUpOworCX0KKworCXZp c2liaWxpdHltYXBfY2xlYXIocHJzdGF0ZS0+cmVsYXRpb24sIHByc3RhdGUtPmJsb2NrLCBwcnN0 YXRlLT52bWJ1ZmZlciwKKwkJCQkJCVZJU0lCSUxJVFlNQVBfVkFMSURfQklUUyk7CisJcHJzdGF0 ZS0+b2xkX3ZtYml0cyA9IDA7Cit9CiAKIC8qCiAgKiBQcnVuZSBhbmQgcmVwYWlyIGZyYWdtZW50 YXRpb24gYW5kIHBvdGVudGlhbGx5IGZyZWV6ZSB0dXBsZXMgb24gdGhlCkBAIC04MzAsNiArOTcy LDE2IEBAIGhlYXBfcGFnZV9wcnVuZV9hbmRfZnJlZXplKFBydW5lRnJlZXplUGFyYW1zICpwYXJh bXMsCiAJCQkJCSAgIG5ld19yZWxmcm96ZW5feGlkLCBuZXdfcmVsbWluX214aWQsCiAJCQkJCSAg IHByZXN1bHQsICZwcnN0YXRlKTsKIAorCS8qCisJICogSWYgdGhlIFZNIGlzIHNldCBidXQgUERf QUxMX1ZJU0lCTEUgaXMgY2xlYXIsIGZpeCB0aGF0IGNvcnJ1cHRpb24KKwkgKiBiZWZvcmUgcHJ1 bmluZyBhbmQgZnJlZXppbmcgc28gdGhhdCB0aGUgcGFnZSBhbmQgVk0gc3RhcnQgb3V0IGluIGEK KwkgKiBjb25zaXN0ZW50IHN0YXRlLgorCSAqLworCWlmICgocHJzdGF0ZS5vbGRfdm1iaXRzICYg VklTSUJJTElUWU1BUF9WQUxJRF9CSVRTKSAmJgorCQkhUGFnZUlzQWxsVmlzaWJsZShwcnN0YXRl LnBhZ2UpKQorCQloZWFwX3BhZ2VfZml4X3ZtX2NvcnJ1cHRpb24oJnByc3RhdGUsIEludmFsaWRP ZmZzZXROdW1iZXIsCisJCQkJCQkJCQlWTV9DT1JSVVBUX01JU1NJTkdfUEFHRV9ISU5UKTsKKwog CS8qCiAJICogRXhhbWluZSBhbGwgbGluZSBwb2ludGVycyBhbmQgdHVwbGUgdmlzaWJpbGl0eSBp bmZvcm1hdGlvbiB0byBkZXRlcm1pbmUKIAkgKiB3aGljaCBsaW5lIHBvaW50ZXJzIHNob3VsZCBj aGFuZ2Ugc3RhdGUgYW5kIHdoaWNoIHR1cGxlcyBtYXkgYmUgZnJvemVuLgpAQCAtOTczLDYgKzEx MjUsNyBAQCBoZWFwX3BhZ2VfcHJ1bmVfYW5kX2ZyZWV6ZShQcnVuZUZyZWV6ZVBhcmFtcyAqcGFy YW1zLAogCXByZXN1bHQtPnNldF9hbGxfdmlzaWJsZSA9IHByc3RhdGUuc2V0X2FsbF92aXNpYmxl OwogCXByZXN1bHQtPnNldF9hbGxfZnJvemVuID0gcHJzdGF0ZS5zZXRfYWxsX2Zyb3plbjsKIAlw cmVzdWx0LT5oYXN0dXAgPSBwcnN0YXRlLmhhc3R1cDsKKwlwcmVzdWx0LT5vbGRfdm1iaXRzID0g cHJzdGF0ZS5vbGRfdm1iaXRzOwogCiAJLyoKIAkgKiBGb3IgY2FsbGVycyBwbGFubmluZyB0byB1 cGRhdGUgdGhlIHZpc2liaWxpdHkgbWFwLCB0aGUgY29uZmxpY3QgaG9yaXpvbgpAQCAtMTI5NSw3 ICsxNDQ4LDggQEAgcHJvY2Vzc19jaGFpbjoKIAogLyogUmVjb3JkIGxvd2VzdCBzb29uLXBydW5h YmxlIFhJRCAqLwogc3RhdGljIHZvaWQKLWhlYXBfcHJ1bmVfcmVjb3JkX3BydW5hYmxlKFBydW5l U3RhdGUgKnByc3RhdGUsIFRyYW5zYWN0aW9uSWQgeGlkKQoraGVhcF9wcnVuZV9yZWNvcmRfcHJ1 bmFibGUoUHJ1bmVTdGF0ZSAqcHJzdGF0ZSwgVHJhbnNhY3Rpb25JZCB4aWQsCisJCQkJCQkgICBP ZmZzZXROdW1iZXIgb2ZmbnVtKQogewogCS8qCiAJICogVGhpcyBzaG91bGQgZXhhY3RseSBtYXRj aCB0aGUgUGFnZVNldFBydW5hYmxlIG1hY3JvLiAgV2UgY2FuJ3Qgc3RvcmUKQEAgLTEzMDUsNiAr MTQ1OSwxNCBAQCBoZWFwX3BydW5lX3JlY29yZF9wcnVuYWJsZShQcnVuZVN0YXRlICpwcnN0YXRl LCBUcmFuc2FjdGlvbklkIHhpZCkKIAlpZiAoIVRyYW5zYWN0aW9uSWRJc1ZhbGlkKHByc3RhdGUt Pm5ld19wcnVuZV94aWQpIHx8CiAJCVRyYW5zYWN0aW9uSWRQcmVjZWRlcyh4aWQsIHByc3RhdGUt Pm5ld19wcnVuZV94aWQpKQogCQlwcnN0YXRlLT5uZXdfcHJ1bmVfeGlkID0geGlkOworCisJLyoK KwkgKiBJdCdzIGluY29ycmVjdCBmb3IgYSBwYWdlIHRvIGJlIG1hcmtlZCBhbGwtdmlzaWJsZSBp ZiBpdCBjb250YWlucworCSAqIHBydW5hYmxlIGl0ZW1zLgorCSAqLworCWlmIChQYWdlSXNBbGxW aXNpYmxlKHByc3RhdGUtPnBhZ2UpKQorCQloZWFwX3BhZ2VfZml4X3ZtX2NvcnJ1cHRpb24ocHJz dGF0ZSwgb2ZmbnVtLAorCQkJCQkJCQkJVk1fQ09SUlVQVF9UVVBMRV9WSVNJQklMSVRZKTsKIH0K IAogLyogUmVjb3JkIGxpbmUgcG9pbnRlciB0byBiZSByZWRpcmVjdGVkICovCkBAIC0xMzg4LDYg KzE1NTAsMTUgQEAgaGVhcF9wcnVuZV9yZWNvcmRfZGVhZF9vcl91bnVzZWQoUHJ1bmVTdGF0ZSAq cHJzdGF0ZSwgT2Zmc2V0TnVtYmVyIG9mZm51bSwKIAkJaGVhcF9wcnVuZV9yZWNvcmRfdW51c2Vk KHByc3RhdGUsIG9mZm51bSwgd2FzX25vcm1hbCk7CiAJZWxzZQogCQloZWFwX3BydW5lX3JlY29y ZF9kZWFkKHByc3RhdGUsIG9mZm51bSwgd2FzX25vcm1hbCk7CisKKwkvKgorCSAqIEl0J3MgaW5j b3JyZWN0IGZvciB0aGUgcGFnZSB0byBiZSBzZXQgYWxsLXZpc2libGUgaWYgaXQgY29udGFpbnMg ZGVhZAorCSAqIGl0ZW1zLiBGaXggdGhhdCBvbiB0aGUgaGVhcCBwYWdlIGFuZCBjaGVjayB0aGUg Vk0gZm9yIGNvcnJ1cHRpb24gYXMKKwkgKiB3ZWxsLiBEbyB0aGF0IGhlcmUgcmF0aGVyIHRoYW4g aW4gaGVhcF9wcnVuZV9yZWNvcmRfZGVhZCgpIHNvIHdlIGFsc28KKwkgKiBjb3ZlciB0dXBsZXMg dGhhdCBhcmUgZGlyZWN0bHkgbWFya2VkIExQX1VOVVNFRCB2aWEgbWFya191bnVzZWRfbm93Lgor CSAqLworCWlmIChQYWdlSXNBbGxWaXNpYmxlKHByc3RhdGUtPnBhZ2UpKQorCQloZWFwX3BhZ2Vf Zml4X3ZtX2NvcnJ1cHRpb24ocHJzdGF0ZSwgb2ZmbnVtLCBWTV9DT1JSVVBUX0xQREVBRCk7CiB9 CiAKIC8qIFJlY29yZCBsaW5lIHBvaW50ZXIgdG8gYmUgbWFya2VkIHVudXNlZCAqLwpAQCAtMTUy Nyw3ICsxNjk4LDggQEAgaGVhcF9wcnVuZV9yZWNvcmRfdW5jaGFuZ2VkX2xwX25vcm1hbChQcnVu ZVN0YXRlICpwcnN0YXRlLCBPZmZzZXROdW1iZXIgb2ZmbnVtKQogCQkJICogdGhhdCB0aGUgcGFn ZSBpcyByZWNvbnNpZGVyZWQgZm9yIHBydW5pbmcgaW4gZnV0dXJlLgogCQkJICovCiAJCQloZWFw X3BydW5lX3JlY29yZF9wcnVuYWJsZShwcnN0YXRlLAotCQkJCQkJCQkJICAgSGVhcFR1cGxlSGVh ZGVyR2V0VXBkYXRlWGlkKGh0dXApKTsKKwkJCQkJCQkJCSAgIEhlYXBUdXBsZUhlYWRlckdldFVw ZGF0ZVhpZChodHVwKSwKKwkJCQkJCQkJCSAgIG9mZm51bSk7CiAJCQlicmVhazsKIAogCQljYXNl IEhFQVBUVVBMRV9JTlNFUlRfSU5fUFJPR1JFU1M6CkBAIC0xNTQyLDYgKzE3MTQsMTEgQEAgaGVh cF9wcnVuZV9yZWNvcmRfdW5jaGFuZ2VkX2xwX25vcm1hbChQcnVuZVN0YXRlICpwcnN0YXRlLCBP ZmZzZXROdW1iZXIgb2ZmbnVtKQogCQkJcHJzdGF0ZS0+c2V0X2FsbF92aXNpYmxlID0gZmFsc2U7 CiAJCQlwcnN0YXRlLT5zZXRfYWxsX2Zyb3plbiA9IGZhbHNlOwogCisJCQkvKiBUaGUgcGFnZSBz aG91bGQgbm90IGJlIG1hcmtlZCBhbGwtdmlzaWJsZSAqLworCQkJaWYgKFBhZ2VJc0FsbFZpc2li bGUocGFnZSkpCisJCQkJaGVhcF9wYWdlX2ZpeF92bV9jb3JydXB0aW9uKHByc3RhdGUsIG9mZm51 bSwKKwkJCQkJCQkJCQkJVk1fQ09SUlVQVF9UVVBMRV9WSVNJQklMSVRZKTsKKwogCQkJLyoKIAkJ CSAqIElmIHdlIHdhbnRlZCB0byBvcHRpbWl6ZSBmb3IgYWJvcnRzLCB3ZSBtaWdodCBjb25zaWRl ciBtYXJraW5nCiAJCQkgKiB0aGUgcGFnZSBwcnVuYWJsZSB3aGVuIHdlIHNlZSBJTlNFUlRfSU5f UFJPR1JFU1MuICBCdXQgd2UKQEAgLTE1NjYsNyArMTc0Myw4IEBAIGhlYXBfcHJ1bmVfcmVjb3Jk X3VuY2hhbmdlZF9scF9ub3JtYWwoUHJ1bmVTdGF0ZSAqcHJzdGF0ZSwgT2Zmc2V0TnVtYmVyIG9m Zm51bSkKIAkJCSAqIHRoZSBwYWdlIGlzIHJlY29uc2lkZXJlZCBmb3IgcHJ1bmluZyBpbiBmdXR1 cmUuCiAJCQkgKi8KIAkJCWhlYXBfcHJ1bmVfcmVjb3JkX3BydW5hYmxlKHByc3RhdGUsCi0JCQkJ CQkJCQkgICBIZWFwVHVwbGVIZWFkZXJHZXRVcGRhdGVYaWQoaHR1cCkpOworCQkJCQkJCQkJICAg SGVhcFR1cGxlSGVhZGVyR2V0VXBkYXRlWGlkKGh0dXApLAorCQkJCQkJCQkJICAgb2ZmbnVtKTsK IAkJCWJyZWFrOwogCiAJCWRlZmF1bHQ6CkBAIC0xNjMyLDYgKzE4MTAsMTMgQEAgaGVhcF9wcnVu ZV9yZWNvcmRfdW5jaGFuZ2VkX2xwX2RlYWQoUHJ1bmVTdGF0ZSAqcHJzdGF0ZSwgT2Zmc2V0TnVt YmVyIG9mZm51bSkKIAogCS8qIFJlY29yZCB0aGUgZGVhZCBvZmZzZXQgZm9yIHZhY3V1bSAqLwog CXByc3RhdGUtPmRlYWRvZmZzZXRzW3Byc3RhdGUtPmxwZGVhZF9pdGVtcysrXSA9IG9mZm51bTsK KworCS8qCisJICogSXQncyBpbmNvcnJlY3QgZm9yIGEgcGFnZSB0byBiZSBtYXJrZWQgYWxsLXZp c2libGUgaWYgaXQgY29udGFpbnMgZGVhZAorCSAqIGl0ZW1zLgorCSAqLworCWlmIChQYWdlSXNB bGxWaXNpYmxlKHByc3RhdGUtPnBhZ2UpKQorCQloZWFwX3BhZ2VfZml4X3ZtX2NvcnJ1cHRpb24o cHJzdGF0ZSwgb2ZmbnVtLCBWTV9DT1JSVVBUX0xQREVBRCk7CiB9CiAKIC8qCmRpZmYgLS1naXQg YS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMgYi9zcmMvYmFja2VuZC9hY2Nl c3MvaGVhcC92YWN1dW1sYXp5LmMKaW5kZXggYzU3NDMyNjcwZTcuLjU2NzIyNTU2NDE3IDEwMDY0 NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMKKysrIGIvc3JjL2Jh Y2tlbmQvYWNjZXNzL2hlYXAvdmFjdXVtbGF6eS5jCkBAIC00MzIsMTEgKzQzMiw2IEBAIHN0YXRp YyB2b2lkIGZpbmRfbmV4dF91bnNraXBwYWJsZV9ibG9jayhMVlJlbFN0YXRlICp2YWNyZWwsIGJv b2wgKnNraXBzYWxsdmlzKTsKIHN0YXRpYyBib29sIGxhenlfc2Nhbl9uZXdfb3JfZW1wdHkoTFZS ZWxTdGF0ZSAqdmFjcmVsLCBCdWZmZXIgYnVmLAogCQkJCQkJCQkgICBCbG9ja051bWJlciBibGtu bywgUGFnZSBwYWdlLAogCQkJCQkJCQkgICBib29sIHNoYXJlbG9jaywgQnVmZmVyIHZtYnVmZmVy KTsKLXN0YXRpYyB2b2lkIGlkZW50aWZ5X2FuZF9maXhfdm1fY29ycnVwdGlvbihSZWxhdGlvbiBy ZWwsIEJ1ZmZlciBoZWFwX2J1ZmZlciwKLQkJCQkJCQkJCQkgICBCbG9ja051bWJlciBoZWFwX2Js aywgUGFnZSBoZWFwX3BhZ2UsCi0JCQkJCQkJCQkJICAgaW50IG5scGRlYWRfaXRlbXMsCi0JCQkJ CQkJCQkJICAgQnVmZmVyIHZtYnVmZmVyLAotCQkJCQkJCQkJCSAgIHVpbnQ4ICp2bWJpdHMpOwog c3RhdGljIGludAlsYXp5X3NjYW5fcHJ1bmUoTFZSZWxTdGF0ZSAqdmFjcmVsLCBCdWZmZXIgYnVm LAogCQkJCQkJCUJsb2NrTnVtYmVyIGJsa25vLCBQYWdlIHBhZ2UsCiAJCQkJCQkJQnVmZmVyIHZt YnVmZmVyLApAQCAtMTk4OSw4MSArMTk4NCw2IEBAIGNtcE9mZnNldE51bWJlcnMoY29uc3Qgdm9p ZCAqYSwgY29uc3Qgdm9pZCAqYikKIAlyZXR1cm4gcGdfY21wX3UxNigqKGNvbnN0IE9mZnNldE51 bWJlciAqKSBhLCAqKGNvbnN0IE9mZnNldE51bWJlciAqKSBiKTsKIH0KIAotLyoKLSAqIEhlbHBl ciB0byBjb3JyZWN0IGFueSBjb3JydXB0aW9uIGRldGVjdGVkIG9uIGEgaGVhcCBwYWdlIGFuZCBp dHMKLSAqIGNvcnJlc3BvbmRpbmcgdmlzaWJpbGl0eSBtYXAgcGFnZSBhZnRlciBwcnVuaW5nIGJ1 dCBiZWZvcmUgc2V0dGluZyB0aGUKLSAqIHZpc2liaWxpdHkgbWFwLiBJdCBleGFtaW5lcyB0aGUg aGVhcCBwYWdlLCB0aGUgYXNzb2NpYXRlZCBWTSBwYWdlLCBhbmQgdGhlCi0gKiBudW1iZXIgb2Yg ZGVhZCBpdGVtcyBwcmV2aW91c2x5IGlkZW50aWZpZWQuCi0gKgotICogVGhpcyBmdW5jdGlvbiBt dXN0IGJlIGNhbGxlZCB3aGlsZSBob2xkaW5nIGFuIGV4Y2x1c2l2ZSBsb2NrIG9uIHRoZSBoZWFw Ci0gKiBidWZmZXIsIGFuZCB0aGUgZGVhZCBpdGVtcyBtdXN0IGhhdmUgYmVlbiBkaXNjb3ZlcmVk IHVuZGVyIHRoYXQgc2FtZSBsb2NrLgotCi0gKiBUaGUgcHJvdmlkZWQgdm1iaXRzIG11c3QgcmVm bGVjdCB0aGUgY3VycmVudCBzdGF0ZSBvZiB0aGUgVk0gYmxvY2sKLSAqIHJlZmVyZW5jZWQgYnkg dm1idWZmZXIuIEFsdGhvdWdoIHdlIGRvIG5vdCBob2xkIGEgbG9jayBvbiB0aGUgVk0gYnVmZmVy LCBpdAotICogaXMgcGlubmVkLCBhbmQgdGhlIGhlYXAgYnVmZmVyIGlzIGV4Y2x1c2l2ZWx5IGxv Y2tlZCwgZW5zdXJpbmcgdGhhdCBubwotICogb3RoZXIgYmFja2VuZCBjYW4gdXBkYXRlIHRoZSBW TSBiaXRzIGNvcnJlc3BvbmRpbmcgdG8gdGhpcyBoZWFwIHBhZ2UuCi0gKgotICogSWYgaXQgY2xl YXJzIGNvcnJ1cHRpb24sIGl0IHdpbGwgemVybyBvdXQgdm1iaXRzLgotICovCi1zdGF0aWMgdm9p ZAotaWRlbnRpZnlfYW5kX2ZpeF92bV9jb3JydXB0aW9uKFJlbGF0aW9uIHJlbCwgQnVmZmVyIGhl YXBfYnVmZmVyLAotCQkJCQkJCSAgIEJsb2NrTnVtYmVyIGhlYXBfYmxrLCBQYWdlIGhlYXBfcGFn ZSwKLQkJCQkJCQkgICBpbnQgbmxwZGVhZF9pdGVtcywKLQkJCQkJCQkgICBCdWZmZXIgdm1idWZm ZXIsCi0JCQkJCQkJICAgdWludDggKnZtYml0cykKLXsKLQlBc3NlcnQodmlzaWJpbGl0eW1hcF9n ZXRfc3RhdHVzKHJlbCwgaGVhcF9ibGssICZ2bWJ1ZmZlcikgPT0gKnZtYml0cyk7Ci0KLQlBc3Nl cnQoQnVmZmVySXNMb2NrZWRCeU1lSW5Nb2RlKGhlYXBfYnVmZmVyLCBCVUZGRVJfTE9DS19FWENM VVNJVkUpKTsKLQotCS8qCi0JICogQXMgb2YgUG9zdGdyZVNRTCA5LjIsIHRoZSB2aXNpYmlsaXR5 IG1hcCBiaXQgc2hvdWxkIG5ldmVyIGJlIHNldCBpZiB0aGUKLQkgKiBwYWdlLWxldmVsIGJpdCBp cyBjbGVhci4gIEhvd2V2ZXIsIGl0J3MgcG9zc2libGUgdGhhdCB0aGUgYml0IGdvdAotCSAqIGNs ZWFyZWQgYWZ0ZXIgaGVhcF92YWNfc2Nhbl9uZXh0X2Jsb2NrKCkgd2FzIGNhbGxlZCwgc28gd2Ug bXVzdCByZWNoZWNrCi0JICogd2l0aCBidWZmZXIgbG9jayBiZWZvcmUgY29uY2x1ZGluZyB0aGF0 IHRoZSBWTSBpcyBjb3JydXB0LgotCSAqLwotCWlmICghUGFnZUlzQWxsVmlzaWJsZShoZWFwX3Bh Z2UpICYmCi0JCSgoKnZtYml0cyAmIFZJU0lCSUxJVFlNQVBfVkFMSURfQklUUykgIT0gMCkpCi0J ewotCQllcmVwb3J0KFdBUk5JTkcsCi0JCQkJKGVycmNvZGUoRVJSQ09ERV9EQVRBX0NPUlJVUFRF RCksCi0JCQkJIGVycm1zZygicGFnZSBpcyBub3QgbWFya2VkIGFsbC12aXNpYmxlIGJ1dCB2aXNp YmlsaXR5IG1hcCBiaXQgaXMgc2V0IGluIHJlbGF0aW9uIFwiJXNcIiBwYWdlICV1IiwKLQkJCQkJ CVJlbGF0aW9uR2V0UmVsYXRpb25OYW1lKHJlbCksIGhlYXBfYmxrKSkpOwotCi0JCXZpc2liaWxp dHltYXBfY2xlYXIocmVsLCBoZWFwX2Jsaywgdm1idWZmZXIsCi0JCQkJCQkJVklTSUJJTElUWU1B UF9WQUxJRF9CSVRTKTsKLQkJKnZtYml0cyA9IDA7Ci0JfQotCi0JLyoKLQkgKiBJdCdzIHBvc3Np YmxlIGZvciB0aGUgdmFsdWUgcmV0dXJuZWQgYnkKLQkgKiBHZXRPbGRlc3ROb25SZW1vdmFibGVU cmFuc2FjdGlvbklkKCkgdG8gbW92ZSBiYWNrd2FyZHMsIHNvIGl0J3Mgbm90Ci0JICogd3Jvbmcg Zm9yIHVzIHRvIHNlZSB0dXBsZXMgdGhhdCBhcHBlYXIgdG8gbm90IGJlIHZpc2libGUgdG8gZXZl cnlvbmUKLQkgKiB5ZXQsIHdoaWxlIFBEX0FMTF9WSVNJQkxFIGlzIGFscmVhZHkgc2V0LiBUaGUg cmVhbCBzYWZlIHhtaW4gdmFsdWUKLQkgKiBuZXZlciBtb3ZlcyBiYWNrd2FyZHMsIGJ1dCBHZXRP bGRlc3ROb25SZW1vdmFibGVUcmFuc2FjdGlvbklkKCkgaXMKLQkgKiBjb25zZXJ2YXRpdmUgYW5k IHNvbWV0aW1lcyByZXR1cm5zIGEgdmFsdWUgdGhhdCdzIHVubmVjZXNzYXJpbHkgc21hbGwsCi0J ICogc28gaWYgd2Ugc2VlIHRoYXQgY29udHJhZGljdGlvbiBpdCBqdXN0IG1lYW5zIHRoYXQgdGhl IHR1cGxlcyB0aGF0IHdlCi0JICogdGhpbmsgYXJlIG5vdCB2aXNpYmxlIHRvIGV2ZXJ5b25lIHll dCBhY3R1YWxseSBhcmUsIGFuZCB0aGUKLQkgKiBQRF9BTExfVklTSUJMRSBmbGFnIGlzIGNvcnJl Y3QuCi0JICoKLQkgKiBUaGVyZSBzaG91bGQgbmV2ZXIgYmUgTFBfREVBRCBpdGVtcyBvbiBhIHBh Z2Ugd2l0aCBQRF9BTExfVklTSUJMRSBzZXQsCi0JICogaG93ZXZlci4KLQkgKi8KLQllbHNlIGlm IChQYWdlSXNBbGxWaXNpYmxlKGhlYXBfcGFnZSkgJiYgbmxwZGVhZF9pdGVtcyA+IDApCi0Jewot CQllcmVwb3J0KFdBUk5JTkcsCi0JCQkJKGVycmNvZGUoRVJSQ09ERV9EQVRBX0NPUlJVUFRFRCks Ci0JCQkJIGVycm1zZygicGFnZSBjb250YWluaW5nIExQX0RFQUQgaXRlbXMgaXMgbWFya2VkIGFz IGFsbC12aXNpYmxlIGluIHJlbGF0aW9uIFwiJXNcIiBwYWdlICV1IiwKLQkJCQkJCVJlbGF0aW9u R2V0UmVsYXRpb25OYW1lKHJlbCksIGhlYXBfYmxrKSkpOwotCi0JCVBhZ2VDbGVhckFsbFZpc2li bGUoaGVhcF9wYWdlKTsKLQkJTWFya0J1ZmZlckRpcnR5KGhlYXBfYnVmZmVyKTsKLQkJdmlzaWJp bGl0eW1hcF9jbGVhcihyZWwsIGhlYXBfYmxrLCB2bWJ1ZmZlciwKLQkJCQkJCQlWSVNJQklMSVRZ TUFQX1ZBTElEX0JJVFMpOwotCQkqdm1iaXRzID0gMDsKLQl9Ci19Ci0KIC8qCiAgKglsYXp5X3Nj YW5fcHJ1bmUoKSAtLSBsYXp5X3NjYW5faGVhcCgpIHBydW5pbmcgYW5kIGZyZWV6aW5nLgogICoK QEAgLTIwOTUsNiArMjAxNSw3IEBAIGxhenlfc2Nhbl9wcnVuZShMVlJlbFN0YXRlICp2YWNyZWws CiAJUHJ1bmVGcmVlemVQYXJhbXMgcGFyYW1zID0gewogCQkucmVsYXRpb24gPSByZWwsCiAJCS5i dWZmZXIgPSBidWYsCisJCS52bWJ1ZmZlciA9IHZtYnVmZmVyLAogCQkucmVhc29uID0gUFJVTkVf VkFDVVVNX1NDQU4sCiAJCS5vcHRpb25zID0gSEVBUF9QQUdFX1BSVU5FX0ZSRUVaRSwKIAkJLnZp c3Rlc3QgPSB2YWNyZWwtPnZpc3Rlc3QsCkBAIC0yMjA0LDE4ICsyMTI1LDEyIEBAIGxhenlfc2Nh bl9wcnVuZShMVlJlbFN0YXRlICp2YWNyZWwsCiAJQXNzZXJ0KCFwcmVzdWx0LnNldF9hbGxfdmlz aWJsZSB8fCAhKCpoYXNfbHBkZWFkX2l0ZW1zKSk7CiAJQXNzZXJ0KCFwcmVzdWx0LnNldF9hbGxf ZnJvemVuIHx8IHByZXN1bHQuc2V0X2FsbF92aXNpYmxlKTsKIAotCW9sZF92bWJpdHMgPSB2aXNp YmlsaXR5bWFwX2dldF9zdGF0dXModmFjcmVsLT5yZWwsIGJsa25vLCAmdm1idWZmZXIpOwotCi0J aWRlbnRpZnlfYW5kX2ZpeF92bV9jb3JydXB0aW9uKHZhY3JlbC0+cmVsLCBidWYsIGJsa25vLCBw YWdlLAotCQkJCQkJCQkgICBwcmVzdWx0LmxwZGVhZF9pdGVtcywgdm1idWZmZXIsCi0JCQkJCQkJ CSAgICZvbGRfdm1iaXRzKTsKLQogCWlmICghcHJlc3VsdC5zZXRfYWxsX3Zpc2libGUpCiAJCXJl dHVybiBwcmVzdWx0Lm5kZWxldGVkOwogCiAJLyogU2V0IHRoZSB2aXNpYmlsaXR5IG1hcCBhbmQg cGFnZSB2aXNpYmlsaXR5IGhpbnQgKi8KKwlvbGRfdm1iaXRzID0gcHJlc3VsdC5vbGRfdm1iaXRz OwogCW5ld192bWJpdHMgPSBWSVNJQklMSVRZTUFQX0FMTF9WSVNJQkxFOwotCiAJaWYgKHByZXN1 bHQuc2V0X2FsbF9mcm96ZW4pCiAJCW5ld192bWJpdHMgfD0gVklTSUJJTElUWU1BUF9BTExfRlJP WkVOOwogCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9hY2Nlc3MvaGVhcGFtLmggYi9zcmMvaW5j bHVkZS9hY2Nlc3MvaGVhcGFtLmgKaW5kZXggMmZkYzUwYjg2NWIuLjAwMTM0MDEyMTM3IDEwMDY0 NAotLS0gYS9zcmMvaW5jbHVkZS9hY2Nlc3MvaGVhcGFtLmgKKysrIGIvc3JjL2luY2x1ZGUvYWNj ZXNzL2hlYXBhbS5oCkBAIC0yNjIsNiArMjYyLDEyIEBAIHR5cGVkZWYgc3RydWN0IFBydW5lRnJl ZXplUGFyYW1zCiAJUmVsYXRpb24JcmVsYXRpb247CQkvKiByZWxhdGlvbiBjb250YWluaW5nIGJ1 ZmZlciB0byBiZSBwcnVuZWQgKi8KIAlCdWZmZXIJCWJ1ZmZlcjsJCQkvKiBidWZmZXIgdG8gYmUg cHJ1bmVkICovCiAKKwkvKgorCSAqIENhbGxlcnMgc2hvdWxkIHByb3ZpZGUgYSBwaW5uZWQgdm1i dWZmZXIgY29ycmVzcG9uZGluZyB0byB0aGUgaGVhcAorCSAqIGJsb2NrIGluIGJ1ZmZlci4gV2Ug d2lsbCBjaGVjayBmb3IgYW5kIHJlcGFpciBhbnkgY29ycnVwdGlvbiBpbiB0aGUgVk0uCisJICov CisJQnVmZmVyCQl2bWJ1ZmZlcjsKKwogCS8qCiAJICogVGhlIHJlYXNvbiBwcnVuaW5nIHdhcyBw ZXJmb3JtZWQuICBJdCBpcyB1c2VkIHRvIHNldCB0aGUgV0FMIHJlY29yZAogCSAqIG9wY29kZSB3 aGljaCBpcyB1c2VkIGZvciBkZWJ1Z2dpbmcgYW5kIGFuYWx5c2lzIHB1cnBvc2VzLgpAQCAtMzI0 LDYgKzMzMCwxMiBAQCB0eXBlZGVmIHN0cnVjdCBQcnVuZUZyZWV6ZVJlc3VsdAogCWJvb2wJCXNl dF9hbGxfZnJvemVuOwogCVRyYW5zYWN0aW9uSWQgdm1fY29uZmxpY3RfaG9yaXpvbjsKIAorCS8q CisJICogVGhlIHZhbHVlIG9mIHRoZSB2bWJ1ZmZlcidzIHZtYml0cyBhdCB0aGUgYmVnaW5uaW5n IG9mIHBydW5pbmcuIEl0IGlzCisJICogY2xlYXJlZCBpZiBWTSBjb3JydXB0aW9uIGlzIGZvdW5k IGFuZCBjb3JyZWN0ZWQuCisJICovCisJdWludDgJCW9sZF92bWJpdHM7CisKIAkvKgogCSAqIFdo ZXRoZXIgb3Igbm90IHRoZSBwYWdlIG1ha2VzIHJlbCB0cnVuY2F0aW9uIHVuc2FmZS4gIFRoaXMg aXMgc2V0IHRvCiAJICogJ3RydWUnLCBldmVuIGlmIHRoZSBwYWdlIGNvbnRhaW5zIExQX0RFQUQg aXRlbXMuICBWQUNVVU0gd2lsbCByZW1vdmUKZGlmZiAtLWdpdCBhL3NyYy90b29scy9wZ2luZGVu dC90eXBlZGVmcy5saXN0IGIvc3JjL3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZzLmxpc3QKaW5kZXgg YTRhMmVkMDc4MTYuLjQ4MDYxNGQ0ODNiIDEwMDY0NAotLS0gYS9zcmMvdG9vbHMvcGdpbmRlbnQv dHlwZWRlZnMubGlzdAorKysgYi9zcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdApAQCAt MzI3Myw2ICszMjczLDcgQEAgVXNlckF1dGgKIFVzZXJDb250ZXh0CiBVc2VyTWFwcGluZwogVXNl ck9wdHMKK1ZNQ29ycnVwdGlvblR5cGUKIFZhY0F0dHJTdGF0cwogVmFjQXR0clN0YXRzUAogVmFj RGVhZEl0ZW1zSW5mbwotLSAKMi40My4wCgo= --00000000000060fd69064d6b968a Content-Type: text/x-patch; charset="US-ASCII"; name="v41-0002-Add-pruning-fast-path-for-all-visible-and-all-fr.patch" Content-Disposition: attachment; filename="v41-0002-Add-pruning-fast-path-for-all-visible-and-all-fr.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmyag1ju1 RnJvbSAwYzlmOTFlZWMwMTI3YmM5MTRjN2ZiZTc5MjU2YzZlNWI2ODljZGU4IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBXZWQsIDI1IEZlYiAyMDI2IDE2OjQ4OjE5IC0wNTAwClN1YmplY3Q6IFtQ QVRDSCB2NDEgMDIvMTJdIEFkZCBwcnVuaW5nIGZhc3QgcGF0aCBmb3IgYWxsLXZpc2libGUgYW5k CiBhbGwtZnJvemVuIHBhZ2VzCgpCZWNhdXNlIG9mIHRoZSBTS0lQX1BBR0VTX1RIUkVTSE9MRCBv cHRpbWl6YXRpb24gb3IgYSBzdGFsZSBwcnVuZSBYSUQsCmhlYXBfcGFnZV9wcnVuZV9hbmRfZnJl ZXplKCkgY2FuIGJlIGludm9rZWQgZm9yIHBhZ2VzIHdpdGggbm8gcHJ1bmluZyBvcgpmcmVlemlu ZyB3b3JrLiBUbyBhdm9pZCB0aGlzLCBpZiBhIHBhZ2UgaXMgYWxyZWFkeSBhbGwtZnJvemVuIG9y IGl0IGlzCmFsbC12aXNpYmxlIGFuZCBubyBmcmVlemluZyB3aWxsIGJlIGF0dGVtcHRlZCwgd2Ug ZXhpdCBlYXJseS4gV2UgY2FuJ3QKZXhpdCBlYXJseSBpZiB2YWN1dW0gcGFzc2VkIERJU0FCTEVf UEFHRV9TS0lQUElORywgdGhvdWdoLgoKQXV0aG9yOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmll cGxhZ2VtYW5AZ21haWwuY29tPgpSZXZpZXdlZC1ieTogQW5kcmVzIEZyZXVuZCA8YW5kcmVzQGFu YXJhemVsLmRlPgpSZXZpZXdlZC1ieTogQ2hhbyBMaSA8bGkuZXZhbi5jaGFvQGdtYWlsLmNvbT4K UmV2aWV3ZWQtYnk6IEtpcmlsbCBSZXNoa2UgPHJlc2hrZWtpcmlsbEBnbWFpbC5jb20+CkRpc2N1 c3Npb246IGh0dHBzOi8vcG9zdGdyLmVzL20vYnFjNGtoNW1pZGZuNDRnbmppcWV6M2JqcXY0em9n eWRndXZkbjQ0NnJpdzQ1amNmM3klNDA0ZXo2NmlsN2VidmsKLS0tCiBzcmMvYmFja2VuZC9hY2Nl c3MvaGVhcC9wcnVuZWhlYXAuYyAgfCA5NyArKysrKysrKysrKysrKysrKysrKysrKysrKystCiBz cmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMgfCAxMCArKysKIHNyYy9pbmNsdWRl L2FjY2Vzcy9oZWFwYW0uaCAgICAgICAgICB8ICAxICsKIDMgZmlsZXMgY2hhbmdlZCwgMTA3IGlu c2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9hY2Nl c3MvaGVhcC9wcnVuZWhlYXAuYyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3BydW5laGVhcC5j CmluZGV4IGU0NTJkMjVjYWU2Li4xOWE3MmFjNmIyNyAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQv YWNjZXNzL2hlYXAvcHJ1bmVoZWFwLmMKKysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvcHJ1 bmVoZWFwLmMKQEAgLTEyOSw2ICsxMjksMTIgQEAgdHlwZWRlZiBzdHJ1Y3QKIAkvKiBCaXRzIGlu IHRoZSB2bWJ1ZmZlciBmb3IgdGhpcyBoZWFwIHBhZ2UgKi8KIAl1aW50OAkJb2xkX3ZtYml0czsK IAorCS8qCisJICogVHJ1ZSBpZiB0aGUgcGFnZSBjYW4gYnlwYXNzIGZ1bGwgcGFnZSBpbnNwZWN0 aW9uIGR1cmluZyBwcnVuaW5nIGFuZAorCSAqIGZyZWV6aW5nIGJhc2VkIG9uIGl0cyB2aXNpYmls aXR5IG1hcCBzdGF0dXMgYW5kIHRoZSBjYWxsZXIncyBvcHRpb25zLgorCSAqLworCWJvb2wJCWZh c3RfcGF0aDsKKwogCS8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLQogCSAqIEluZm9ybWF0aW9uIGFib3V0IHdoYXQgd2FzIGRvbmUKIAkgKgpA QCAtMjAxLDYgKzIwNyw3IEBAIHN0YXRpYyB2b2lkIHBydW5lX2ZyZWV6ZV9zZXR1cChQcnVuZUZy ZWV6ZVBhcmFtcyAqcGFyYW1zLAogCQkJCQkJCSAgIFBydW5lU3RhdGUgKnByc3RhdGUpOwogc3Rh dGljIHZvaWQgaGVhcF9wYWdlX2ZpeF92bV9jb3JydXB0aW9uKFBydW5lU3RhdGUgKnByc3RhdGUs IE9mZnNldE51bWJlciBvZmZudW0sCiAJCQkJCQkJCQkJVk1Db3JydXB0aW9uVHlwZSBjdHlwZSk7 CitzdGF0aWMgdm9pZCBwcnVuZV9mcmVlemVfYnlwYXNzKFBydW5lU3RhdGUgKnByc3RhdGUsIFBy dW5lRnJlZXplUmVzdWx0ICpwcmVzdWx0KTsKIHN0YXRpYyB2b2lkIHBydW5lX2ZyZWV6ZV9wbGFu KFBydW5lU3RhdGUgKnByc3RhdGUsCiAJCQkJCQkJICBPZmZzZXROdW1iZXIgKm9mZl9sb2MpOwog c3RhdGljIEhUU1ZfUmVzdWx0IGhlYXBfcHJ1bmVfc2F0aXNmaWVzX3ZhY3V1bShQcnVuZVN0YXRl ICpwcnN0YXRlLApAQCAtMzI5LDcgKzMzNiw3IEBAIGhlYXBfcGFnZV9wcnVuZV9vcHQoUmVsYXRp b24gcmVsYXRpb24sIEJ1ZmZlciBidWZmZXIsIEJ1ZmZlciAqdm1idWZmZXIpCiAJCQkgKiBjYW5u b3Qgc2FmZWx5IGRldGVybWluZSB0aGF0IGR1cmluZyBvbi1hY2Nlc3MgcHJ1bmluZyB3aXRoIHRo ZQogCQkJICogY3VycmVudCBpbXBsZW1lbnRhdGlvbi4KIAkJCSAqLwotCQkJcGFyYW1zLm9wdGlv bnMgPSAwOworCQkJcGFyYW1zLm9wdGlvbnMgPSBIRUFQX1BBR0VfUFJVTkVfQUxMT1dfRkFTVF9Q QVRIOwogCiAJCQloZWFwX3BhZ2VfcHJ1bmVfYW5kX2ZyZWV6ZSgmcGFyYW1zLCAmcHJlc3VsdCwg JmR1bW15X29mZl9sb2MsCiAJCQkJCQkJCQkgICBOVUxMLCBOVUxMKTsKQEAgLTM5OCw2ICs0MDUs MTYgQEAgcHJ1bmVfZnJlZXplX3NldHVwKFBydW5lRnJlZXplUGFyYW1zICpwYXJhbXMsCiAJCQkJ CQkJCQkJCQkgICBwcnN0YXRlLT5ibG9jaywKIAkJCQkJCQkJCQkJCSAgICZwcnN0YXRlLT52bWJ1 ZmZlcik7CiAKKwkvKgorCSAqIElmIHRoZSBwYWdlIGlzIGFscmVhZHkgYWxsLWZyb3plbiwgb3Ig YWxyZWFkeSBhbGwtdmlzaWJsZSB3aGVuIGZyZWV6aW5nCisJICogaXMgbm90IGJlaW5nIGF0dGVt cHRlZCwgd2UgY2FuIHNraXAgcHJ1bmluZyBhbmQgZnJlZXppbmcgZW50aXJlbHkuCisJICogQ2Fs bGVycyBtdXN0IG9wdCBpbiBieSBzZXR0aW5nIEhFQVBfUEFHRV9QUlVORV9BTExPV19GQVNUX1BB VEguCisJICovCisJcHJzdGF0ZS0+ZmFzdF9wYXRoID0gKChwcnN0YXRlLT5vbGRfdm1iaXRzICYg VklTSUJJTElUWU1BUF9BTExfRlJPWkVOKSB8fAorCQkJCQkJICAoKHByc3RhdGUtPm9sZF92bWJp dHMgJiBWSVNJQklMSVRZTUFQX0FMTF9WSVNJQkxFKSAmJgorCQkJCQkJICAgIXByc3RhdGUtPmF0 dGVtcHRfZnJlZXplKSkgJiYKKwkJKHBhcmFtcy0+b3B0aW9ucyAmIEhFQVBfUEFHRV9QUlVORV9B TExPV19GQVNUX1BBVEgpOworCiAJLyoKIAkgKiBPdXIgc3RyYXRlZ3kgaXMgdG8gc2NhbiB0aGUg cGFnZSBhbmQgbWFrZSBsaXN0cyBvZiBpdGVtcyB0byBjaGFuZ2UsCiAJICogdGhlbiBhcHBseSB0 aGUgY2hhbmdlcyB3aXRoaW4gYSBjcml0aWNhbCBzZWN0aW9uLiAgVGhpcyBrZWVwcyBhcyBtdWNo CkBAIC05MTMsNiArOTMwLDczIEBAIGhlYXBfcGFnZV9maXhfdm1fY29ycnVwdGlvbihQcnVuZVN0 YXRlICpwcnN0YXRlLCBPZmZzZXROdW1iZXIgb2ZmbnVtLAogCXByc3RhdGUtPm9sZF92bWJpdHMg PSAwOwogfQogCisvKgorICogSWYgdGhlIHBhZ2UgaXMgYWxyZWFkeSBhbGwtZnJvemVuLCBvciBh bHJlYWR5IGFsbC12aXNpYmxlIGFuZCBmcmVlemluZworICogaXMgbm90IGJlaW5nIGF0dGVtcHRl ZCwgdGhlcmUgaXMgbm8gcmVtYWluaW5nIHdvcmsgYW5kIHdlIGNhbiBieXBhc3MgdGhlCisgKiBl eHBlbnNpdmUgb3ZlcmhlYWQgb2YgaGVhcF9wYWdlX3BydW5lX2FuZF9mcmVlemUoKS4KKyAqCisg KiBUaGlzIGNhbiBoYXBwZW4gd2hlbiB0aGUgcGFnZSBoYXMgYSBzdGFsZSBwcnVuZSBoaW50LCBv ciBpZiBWQUNVVU0gaXMKKyAqIHNjYW5uaW5nIGFuIGFscmVhZHkgYWxsLWZyb3plbiBwYWdlIGR1 ZSB0byBTS0lQX1BBR0VTX1RIUkVTSE9MRC4KKyAqCisgKiBUaGUgY2FsbGVyIG11c3QgYWxyZWFk eSBoYXZlIGV4YW1pbmVkIHRoZSB2aXNpYmlsaXR5IG1hcCBhbmQgc2F2ZWQgdGhlCisgKiBzdGF0 dXMgZm9yIHRoZSBwYWdlJ3MgVk0gYml0cyBpbiBwcnN0YXRlLT5vbGRfdm1iaXRzLiBDYWxsZXIg bXVzdCBob2xkIGEKKyAqIGNvbnRlbnQgbG9jayBvbiB0aGUgaGVhcCBwYWdlIHNpbmNlIGl0IHdp bGwgZXhhbWluZSBsaW5lIHBvaW50ZXJzLgorICoKKyAqIEJlZm9yZSBjYWxsaW5nIHBydW5lX2Zy ZWV6ZV9ieXBhc3MoKSwgdGhlIGNhbGxlciBzaG91bGQgZmlyc3QKKyAqIGNoZWNrIGZvciBhbmQg Zml4IGFueSBkaXNjcmVwYW5jeSBiZXR3ZWVuIHRoZSBwYWdlLWxldmVsIHZpc2liaWxpdHkgaGlu dAorICogYW5kIHRoZSB2aXNpYmlsaXR5IG1hcC4gT3RoZXJ3aXNlLCB0aGUgZmFzdCBwYXRoIHdp bGwgYWx3YXlzIHByZXZlbnQgdXMKKyAqIGZyb20gZ2V0dGluZyB0aGVtIGluIHN5bmMuIE5vdGUg dGhhdCBpZiB0aGVyZSBhcmUgdHVwbGVzIG9uIHRoZSBwYWdlIHRoYXQKKyAqIGFyZSBub3Qgdmlz aWJsZSB0byBhbGwgYnV0IHRoZSBWTSBpcyBpbmNvcnJlY3RseSBtYXJrZWQKKyAqIGFsbC12aXNp YmxlL2FsbC1mcm96ZW4sIHdlIHdpbGwgbm90IGdldCB0aGUgY2hhbmNlIHRvIGZpeCB0aGF0IGNv cnJ1cHRpb24KKyAqIHdoZW4gdXNpbmcgdGhlIGZhc3QgcGF0aC4KKyAqLworc3RhdGljIHZvaWQK K3BydW5lX2ZyZWV6ZV9ieXBhc3MoUHJ1bmVTdGF0ZSAqcHJzdGF0ZSwgUHJ1bmVGcmVlemVSZXN1 bHQgKnByZXN1bHQpCit7CisJT2Zmc2V0TnVtYmVyIG1heG9mZiA9IFBhZ2VHZXRNYXhPZmZzZXRO dW1iZXIocHJzdGF0ZS0+cGFnZSk7CisJUGFnZQkJcGFnZSA9IHByc3RhdGUtPnBhZ2U7CisKKwlB c3NlcnQocHJzdGF0ZS0+b2xkX3ZtYml0cyAmIFZJU0lCSUxJVFlNQVBfQUxMX0ZST1pFTiB8fAor CQkgICAocHJzdGF0ZS0+b2xkX3ZtYml0cyAmIFZJU0lCSUxJVFlNQVBfQUxMX1ZJU0lCTEUgJiYK KwkJCSFwcnN0YXRlLT5hdHRlbXB0X2ZyZWV6ZSkpOworCisJLyogV2UnbGwgZmlsbCBpbiBwcmVz dWx0IGZvciB0aGUgY2FsbGVyICovCisJbWVtc2V0KHByZXN1bHQsIDAsIHNpemVvZihQcnVuZUZy ZWV6ZVJlc3VsdCkpOworCisJcHJlc3VsdC0+b2xkX3ZtYml0cyA9IHByc3RhdGUtPm9sZF92bWJp dHM7CisKKwkvKiBDbGVhciBhbnkgc3RhbGUgcHJ1bmUgaGludCAqLworCWlmIChUcmFuc2FjdGlv bklkSXNWYWxpZChQYWdlR2V0UHJ1bmVYaWQocGFnZSkpKQorCXsKKwkJUGFnZUNsZWFyUHJ1bmFi bGUocGFnZSk7CisJCU1hcmtCdWZmZXJEaXJ0eUhpbnQocHJzdGF0ZS0+YnVmZmVyLCB0cnVlKTsK Kwl9CisKKwlpZiAoUGFnZUlzRW1wdHkocGFnZSkpCisJCXJldHVybjsKKworCS8qCisJICogU2lu Y2UgdGhlIHBhZ2UgaXMgYWxsLXZpc2libGUsIGEgY291bnQgb2YgdGhlIG5vcm1hbCBJdGVtSWRz IG9uIHRoZQorCSAqIHBhZ2Ugc2hvdWxkIGJlIHN1ZmZpY2llbnQgZm9yIHZhY3V1bSdzIGxpdmUg dHVwbGUgY291bnQuCisJICovCisJZm9yIChPZmZzZXROdW1iZXIgb2ZmID0gRmlyc3RPZmZzZXRO dW1iZXI7CisJCSBvZmYgPD0gbWF4b2ZmOworCQkgb2ZmID0gT2Zmc2V0TnVtYmVyTmV4dChvZmYp KQorCXsKKwkJaWYgKEl0ZW1JZElzTm9ybWFsKFBhZ2VHZXRJdGVtSWQocGFnZSwgb2ZmKSkpCisJ CXsKKwkJCS8qCisJCQkgKiBOb3cgdGhhdCB3ZSd2ZSBmb3VuZCBhbiBhY3R1YWwgdHVwbGUsIHNl dCBoYXN0dXAuIElmIHRoZSBwYWdlCisJCQkgKiBpcyBlbnRpcmVseSBMUF9VTlVTRUQsIHdlIHdh bnQgdmFjdXVtIHRvIHN0aWxsIHRydW5jYXRlIGl0LgorCQkJICovCisJCQlwcmVzdWx0LT5oYXN0 dXAgPSB0cnVlOworCQkJcHJzdGF0ZS0+bGl2ZV90dXBsZXMrKzsKKwkJfQorCX0KKworCXByZXN1 bHQtPmxpdmVfdHVwbGVzID0gcHJzdGF0ZS0+bGl2ZV90dXBsZXM7Cit9CisKIC8qCiAgKiBQcnVu ZSBhbmQgcmVwYWlyIGZyYWdtZW50YXRpb24gYW5kIHBvdGVudGlhbGx5IGZyZWV6ZSB0dXBsZXMg b24gdGhlCiAgKiBzcGVjaWZpZWQgcGFnZS4KQEAgLTk4Miw2ICsxMDY2LDE3IEBAIGhlYXBfcGFn ZV9wcnVuZV9hbmRfZnJlZXplKFBydW5lRnJlZXplUGFyYW1zICpwYXJhbXMsCiAJCWhlYXBfcGFn ZV9maXhfdm1fY29ycnVwdGlvbigmcHJzdGF0ZSwgSW52YWxpZE9mZnNldE51bWJlciwKIAkJCQkJ CQkJCVZNX0NPUlJVUFRfTUlTU0lOR19QQUdFX0hJTlQpOwogCisJLyoKKwkgKiBJZiB0aGUgdmlz aWJpbGl0eSBtYXAgc3RhdHVzIGFsbG93cyBpdCwgYnlwYXNzIHBydW5pbmcgYW5kIGZyZWV6aW5n CisJICogZW50aXJlbHkuIFRoaXMgbXVzdCBiZSBkb25lIGFmdGVyIGZpeGluZyBhbnkgZGlzY3Jl cGFuY3kgYmV0d2VlbiB0aGUKKwkgKiBwYWdlLWxldmVsIHZpc2liaWxpdHkgaGludCBhbmQgdGhl IFZNLgorCSAqLworCWlmIChwcnN0YXRlLmZhc3RfcGF0aCkKKwl7CisJCXBydW5lX2ZyZWV6ZV9i eXBhc3MoJnByc3RhdGUsIHByZXN1bHQpOworCQlyZXR1cm47CisJfQorCiAJLyoKIAkgKiBFeGFt aW5lIGFsbCBsaW5lIHBvaW50ZXJzIGFuZCB0dXBsZSB2aXNpYmlsaXR5IGluZm9ybWF0aW9uIHRv IGRldGVybWluZQogCSAqIHdoaWNoIGxpbmUgcG9pbnRlcnMgc2hvdWxkIGNoYW5nZSBzdGF0ZSBh bmQgd2hpY2ggdHVwbGVzIG1heSBiZSBmcm96ZW4uCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9h Y2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1s YXp5LmMKaW5kZXggNTY3MjI1NTY0MTcuLjFhNDQ2MDUwZDg1IDEwMDY0NAotLS0gYS9zcmMvYmFj a2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMKKysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hl YXAvdmFjdXVtbGF6eS5jCkBAIC0yMDQ0LDYgKzIwNDQsMTYgQEAgbGF6eV9zY2FuX3BydW5lKExW UmVsU3RhdGUgKnZhY3JlbCwKIAlpZiAodmFjcmVsLT5uaW5kZXhlcyA9PSAwKQogCQlwYXJhbXMu b3B0aW9ucyB8PSBIRUFQX1BBR0VfUFJVTkVfTUFSS19VTlVTRURfTk9XOwogCisJLyoKKwkgKiBB bGxvdyBza2lwcGluZyBmdWxsIGluc3BlY3Rpb24gb2YgcGFnZXMgdGhhdCB0aGUgVk0gaW5kaWNh dGVzIGFyZQorCSAqIGFscmVhZHkgYWxsLWZyb3plbiAod2hpY2ggbWF5IGJlIHNjYW5uZWQgZHVl IHRvIFNLSVBfUEFHRVNfVEhSRVNIT0xEKS4KKwkgKiBIb3dldmVyLCBpZiBESVNBQkxFX1BBR0Vf U0tJUFBJTkcgd2FzIHNwZWNpZmllZCwgd2UgY2FuJ3QgdHJ1c3QgdGhlIFZNLAorCSAqIHNvIHdl IG11c3QgZXhhbWluZSB0aGUgcGFnZSB0byBtYWtlIHN1cmUgaXQgaXMgdHJ1bHkgYWxsLWZyb3pl biBhbmQgZml4CisJICogaXQgb3RoZXJ3aXNlLgorCSAqLworCWlmICh2YWNyZWwtPnNraXB3aXRo dm0pCisJCXBhcmFtcy5vcHRpb25zIHw9IEhFQVBfUEFHRV9QUlVORV9BTExPV19GQVNUX1BBVEg7 CisKIAloZWFwX3BhZ2VfcHJ1bmVfYW5kX2ZyZWV6ZSgmcGFyYW1zLAogCQkJCQkJCSAgICZwcmVz dWx0LAogCQkJCQkJCSAgICZ2YWNyZWwtPm9mZm51bSwKZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRl L2FjY2Vzcy9oZWFwYW0uaCBiL3NyYy9pbmNsdWRlL2FjY2Vzcy9oZWFwYW0uaAppbmRleCAwMDEz NDAxMjEzNy4uMzA1ZWNjMzFhOWUgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL2FjY2Vzcy9oZWFw YW0uaAorKysgYi9zcmMvaW5jbHVkZS9hY2Nlc3MvaGVhcGFtLmgKQEAgLTQyLDYgKzQyLDcgQEAK IC8qICJvcHRpb25zIiBmbGFnIGJpdHMgZm9yIGhlYXBfcGFnZV9wcnVuZV9hbmRfZnJlZXplICov CiAjZGVmaW5lIEhFQVBfUEFHRV9QUlVORV9NQVJLX1VOVVNFRF9OT1cJCSgxIDw8IDApCiAjZGVm aW5lIEhFQVBfUEFHRV9QUlVORV9GUkVFWkUJCQkJKDEgPDwgMSkKKyNkZWZpbmUgSEVBUF9QQUdF X1BSVU5FX0FMTE9XX0ZBU1RfUEFUSAkJKDEgPDwgMikKIAogdHlwZWRlZiBzdHJ1Y3QgQnVsa0lu c2VydFN0YXRlRGF0YSAqQnVsa0luc2VydFN0YXRlOwogdHlwZWRlZiBzdHJ1Y3QgR2xvYmFsVmlz U3RhdGUgR2xvYmFsVmlzU3RhdGU7Ci0tIAoyLjQzLjAKCg== --00000000000060fd69064d6b968a Content-Type: text/x-patch; charset="UTF-8"; name="v41-0003-Use-GlobalVisState-in-vacuum-to-determine-page-l.patch" Content-Disposition: attachment; filename="v41-0003-Use-GlobalVisState-in-vacuum-to-determine-page-l.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmyag5zx2 RnJvbSA5MzNjY2ZjMWZhNGY2NTJjOWE5ZjBiZTdjYWM1YWJlYmY0ZGRmN2MxIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBXZWQsIDE3IERlYyAyMDI1IDE2OjUxOjA1IC0wNTAwClN1YmplY3Q6IFtQ QVRDSCB2NDEgMDMvMTJdIFVzZSBHbG9iYWxWaXNTdGF0ZSBpbiB2YWN1dW0gdG8gZGV0ZXJtaW5l IHBhZ2UKIGxldmVsIHZpc2liaWxpdHkKCkR1cmluZyB2YWN1dW0ncyBmaXJzdCBhbmQgdGhpcmQg cGhhc2VzLCB3ZSBleGFtaW5lIHR1cGxlcycgdmlzaWJpbGl0eQp0byBkZXRlcm1pbmUgaWYgd2Ug Y2FuIHNldCB0aGUgcGFnZSBhbGwtdmlzaWJsZSBpbiB0aGUgdmlzaWJpbGl0eSBtYXAuCgpQcmV2 aW91c2x5LCB0aGlzIGNoZWNrIGNvbXBhcmVkIHR1cGxlIHhtaW5zIGFnYWluc3QgYSBzaW5nbGUg WElEIGNob3NlbiBhdAp0aGUgc3RhcnQgb2YgdmFjdXVtIChPbGRlc3RYbWluKS4gV2Ugbm93IHVz ZSBHbG9iYWxWaXNTdGF0ZSwgd2hpY2ggYWxzbwplbmFibGVzIGZ1dHVyZSB3b3JrIHRvIHNldCB0 aGUgVk0gZHVyaW5nIG9uLWFjY2VzcyBwcnVuaW5nLCBzaW5jZSBvcmRpbmFyeQpxdWVyaWVzIGhh dmUgYWNjZXNzIHRvIEdsb2JhbFZpc1N0YXRlIGJ1dCBub3QgT2xkZXN0WG1pbi4KClRoaXMgYWxz byBiZW5lZml0cyB2YWN1dW06IGluIHNvbWUgY2FzZXMsIEdsb2JhbFZpc1N0YXRlIG1heSBhZHZh bmNlCmR1cmluZyBhIHZhY3V1bSwgYWxsb3dpbmcgbW9yZSBwYWdlcyB0byBiZWNvbWUgY29uc2lk ZXJlZCBhbGwtdmlzaWJsZS4KQW5kLCBpbiB0aGUgZnV0dXJlLCB3ZSBjb3VsZCBlYXNpbHkgYWRk IGEgaGV1cmlzdGljIHRvIHVwZGF0ZQpHbG9iYWxWaXNTdGF0ZSBtb3JlIGZyZXF1ZW50bHkgZHVy aW5nIHZhY3V1bXMgb2YgbGFyZ2UgdGFibGVzLgoKT2xkZXN0WG1pbiBpcyBzdGlsbCB1c2VkIGZv ciBmcmVlemluZyBhbmQgYXMgYSBiYWNrc3RvcCB0byBlbnN1cmUgd2UKZG9uJ3QgZnJlZXplIGEg ZGVhZCB0dXBsZSB0aGF0IHdhc24ndCB5ZXQgcHJ1bmFibGUgYWNjb3JkaW5nIHRvCkdsb2JhbFZp c1N0YXRlIGluIHRoZSByYXJlIG9jY3VycmVuY2VzIHdoZXJlIEdsb2JhbFZpc1N0YXRlIG1vdmVz CmJhY2t3YXJkcy4KCkJlY2F1c2UgY29tcGFyaW5nIGEgdHJhbnNhY3Rpb24gSUQgYWdhaW5zdCBH bG9iYWxWaXNTdGF0ZSBpcyBtb3JlCmV4cGVuc2l2ZSB0aGFuIGNvbXBhcmluZyBhZ2FpbnN0IGEg c2luZ2xlIFhJRCwgd2UgZGVmZXIgdGhpcyBjaGVjayB1bnRpbAphZnRlciBzY2FubmluZyBhbGwg dHVwbGVzIG9uIHRoZSBwYWdlLiBUaGVyZWZvcmUsIHdlIHBlcmZvcm0gdGhlCkdsb2JhbFZpc1N0 YXRlIGNoZWNrIG9ubHkgb25jZSBwZXIgcGFnZS4gVGhpcyBpcyBzYWZlIGJlY2F1c2UKdmlzaWJp bGl0eV9jdXRvZmZfeGlkIHJlY29yZHMgdGhlIG5ld2VzdCBsaXZlIHhtaW4gb24gdGhlIHBhZ2U7 CmlmIGl0IGlzIGdsb2JhbGx5IHZpc2libGUsIHRoZW4gdGhlIGVudGlyZSBwYWdlIGlzIGFsbC12 aXNpYmxlLgoKVXNpbmcgR2xvYmFsVmlzU3RhdGUgbWVhbnMgb24tYWNjZXNzIHBydW5pbmcgY2Fu IGFsc28gbWFpbnRhaW4KdmlzaWJpbGl0eV9jdXRvZmZfeGlkLiBUaGlzIGFwcHJvYWNoIHdpbGwg cmVzdWx0IGluIGV4YW1pbmluZyBtb3JlIHR1cGxlCnhtaW5zIHRoYW4gYmVmb3JlOyBob3dldmVy LCB0aGUgYWRkaXRpb25hbCBjb3N0IHNob3VsZCBub3QgYmUKc2lnbmlmaWNhbnQuIEFuZCBkb2lu ZyBzbyB3aWxsIGVuYWJsZSB1cyB0byBzZXQgdGhlIHZpc2liaWxpdHkgbWFwIG9uCmFjY2VzcyBp biB0aGUgZnV0dXJlLgoKQXV0aG9yOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5A Z21haWwuY29tPgpSZXZpZXdlZC1ieTogQW5kcmVzIEZyZXVuZCA8YW5kcmVzQGFuYXJhemVsLmRl PgpSZXZpZXdlZC1ieTogQ2hhbyBMaSA8bGkuZXZhbi5jaGFvQGdtYWlsLmNvbT4KUmV2aWV3ZWQt Ynk6IEtpcmlsbCBSZXNoa2UgPHJlc2hrZWtpcmlsbEBnbWFpbC5jb20+CkRpc2N1c3Npb246IGh0 dHBzOi8vcG9zdGdyLmVzL20vZmxhdC9icWM0a2g1bWlkZm40NGduamlxZXozYmpxdjR6b2d5ZGd1 dmRuNDQ2cml3NDVqY2YzeSU0MDRlejY2aWw3ZWJ2ayNjNzU1ZWYxNTE1MDdhYmE1ODQ3MWZmYWNh NjA3ZTQ5MwotLS0KIHNyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL2hlYXBhbV92aXNpYmlsaXR5LmMg fCAyMiArKysrKysrKysrCiBzcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9wcnVuZWhlYXAuYyAgICAg ICAgIHwgNDggKysrKysrKysrKy0tLS0tLS0tLS0tCiBzcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92 YWN1dW1sYXp5LmMgICAgICAgIHwgNDggKysrKysrKysrKysrKy0tLS0tLS0tCiBzcmMvaW5jbHVk ZS9hY2Nlc3MvaGVhcGFtLmggICAgICAgICAgICAgICAgIHwgIDIgKwogNCBmaWxlcyBjaGFuZ2Vk LCA3OSBpbnNlcnRpb25zKCspLCA0MSBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zcmMvYmFj a2VuZC9hY2Nlc3MvaGVhcC9oZWFwYW1fdmlzaWJpbGl0eS5jIGIvc3JjL2JhY2tlbmQvYWNjZXNz L2hlYXAvaGVhcGFtX3Zpc2liaWxpdHkuYwppbmRleCBmYzY0ZjQzNDNjZS4uZDcwZmFiM2E3NjMg MTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL2hlYXBhbV92aXNpYmlsaXR5LmMK KysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvaGVhcGFtX3Zpc2liaWxpdHkuYwpAQCAtMTEz MSw2ICsxMTMxLDI4IEBAIEhlYXBUdXBsZVNhdGlzZmllc1ZhY3V1bShIZWFwVHVwbGUgaHR1cCwg VHJhbnNhY3Rpb25JZCBPbGRlc3RYbWluLAogCXJldHVybiByZXM7CiB9CiAKKy8qCisgKiBXcmFw cGVyIGFyb3VuZCBHbG9iYWxWaXNUZXN0SXNSZW1vdmFibGVYaWQoKSBmb3IgdXNlIHdoZW4gZXhh bWluaW5nIGxpdmUKKyAqIHR1cGxlcy4gUmV0dXJucyB0cnVlIGlmIHRoZSBnaXZlbiBYSUQgbWF5 IGJlIGNvbnNpZGVyZWQgcnVubmluZyBieSBhdCBsZWFzdAorICogb25lIHNuYXBzaG90LgorICoK KyAqIFRoaXMgZnVuY3Rpb24gYWxvbmUgaXMgaW5zdWZmaWNpZW50IHRvIGRldGVybWluZSB0dXBs ZSB2aXNpYmlsaXR5OyBjYWxsZXJzCisgKiBtdXN0IGFsc28gY29uc2lkZXIgdGhlIFhJRCdzIGNv bW1pdCBzdGF0dXMuIEl0cyBwdXJwb3NlIGlzIHB1cmVseSBzZW1hbnRpYzoKKyAqIHdoZW4gYXBw bGllZCB0byBsaXZlIHR1cGxlcywgR2xvYmFsVmlzVGVzdElzUmVtb3ZhYmxlWGlkKCkgaXMgY2hl Y2tpbmcKKyAqIHdoZXRoZXIgdGhlIGluc2VydGluZyB0cmFuc2FjdGlvbiBpcyBzdGlsbCBjb25z aWRlcmVkIHJ1bm5pbmcsIG5vdCB3aGV0aGVyCisgKiB0aGUgdHVwbGUgaXMgcmVtb3ZhYmxlLiBM aXZlIHR1cGxlcyBhcmUsIGJ5IGRlZmluaXRpb24sIG5vdCByZW1vdmFibGUsIGJ1dAorICogdGhl IHNuYXBzaG90IGNyaXRlcmlhIGZvciDigJx0cmFuc2FjdGlvbiBzdGlsbCBydW5uaW5n4oCdIGFy ZSBpZGVudGljYWwgdG8KKyAqIHRob3NlIHVzZWQgZm9yIHJlbW92YWwgWElEcy4KKyAqCisgKiBT ZWUgdGhlIGNvbW1lbnQgYWJvdmUgR2xvYmFsVmlzVGVzdElzUmVtb3ZhYmxlW0Z1bGxdWGlkKCkg Zm9yIGRldGFpbHMgb24gdGhlCisgKiByZXF1aXJlZCBwcmVjb25kaXRpb25zIGZvciBjYWxsaW5n IHRoaXMgZnVuY3Rpb24uCisgKi8KK2Jvb2wKK0dsb2JhbFZpc1Rlc3RYaWRNYXliZVJ1bm5pbmco R2xvYmFsVmlzU3RhdGUgKnN0YXRlLCBUcmFuc2FjdGlvbklkIHhpZCkKK3sKKwlyZXR1cm4gIUds b2JhbFZpc1Rlc3RJc1JlbW92YWJsZVhpZChzdGF0ZSwgeGlkKTsKK30KKwogLyoKICAqIFdvcmsg aG9yc2UgZm9yIEhlYXBUdXBsZVNhdGlzZmllc1ZhY3V1bSBhbmQgc2ltaWxhciByb3V0aW5lcy4K ICAqCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9wcnVuZWhlYXAuYyBiL3Ny Yy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3BydW5laGVhcC5jCmluZGV4IDE5YTcyYWM2YjI3Li5mNDM3 NTc5MDc2ZSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvcHJ1bmVoZWFwLmMK KysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvcHJ1bmVoZWFwLmMKQEAgLTE2NiwxMCArMTY2 LDEzIEBAIHR5cGVkZWYgc3RydWN0CiAJICogYWxsLWZyb3plbiBiaXRzIGluIHRoZSB2aXNpYmls aXR5IG1hcCBjYW4gYmUgc2V0IGZvciB0aGlzIHBhZ2UgYWZ0ZXIKIAkgKiBwcnVuaW5nLgogCSAq Ci0JICogdmlzaWJpbGl0eV9jdXRvZmZfeGlkIGlzIHRoZSBuZXdlc3QgeG1pbiBvZiBsaXZlIHR1 cGxlcyBvbiB0aGUgcGFnZS4KLQkgKiBUaGUgY2FsbGVyIGNhbiB1c2UgaXQgYXMgdGhlIGNvbmZs aWN0IGhvcml6b24sIHdoZW4gc2V0dGluZyB0aGUgVk0KLQkgKiBiaXRzLiAgSXQgaXMgb25seSB2 YWxpZCBpZiB3ZSBmcm96ZSBzb21lIHR1cGxlcywgYW5kIHNldF9hbGxfZnJvemVuIGlzCi0JICog dHJ1ZS4KKwkgKiB2aXNpYmlsaXR5X2N1dG9mZl94aWQgaXMgdGhlIG5ld2VzdCB4bWluIG9mIGxp dmUgdHVwbGVzIG9uIHRoZSBwYWdlLiBJdAorCSAqIGlzIHVzZWQgYWZ0ZXIgcHJvY2Vzc2luZyBh bGwgdHVwbGVzIHRvIGRldGVybWluZSBpZiB0aGUgcGFnZSBjYW4gYmUKKwkgKiBjb25zaWRlcmVk IGFsbC12aXNpYmxlIChpZiB0aGUgbmV3ZXN0IHhtaW4gaXMgc3RpbGwgY29uc2lkZXJlZCBydW5u aW5nCisJICogYnkgc29tZSBzbmFwc2hvdCwgaXQgY2Fubm90IGJlKS4gSXQgaXMgYWxzbyB1c2Vk IGJ5IHRoZSBjYWxsZXIgYXMgdGhlCisJICogY29uZmxpY3QgaG9yaXpvbiB3aGVuIHNldHRpbmcg dGhlIFZNIGJpdHMsIHVubGVzcyB3ZSBmcm96ZSBhbGwgdHVwbGVzCisJICogb24gdGhlIHBhZ2Ug KGluIHdoaWNoIGNhc2UgdGhlIGNvbmZsaWN0IHhpZCB3YXMgYWxyZWFkeSBpbmNsdWRlZCBpbiB0 aGUKKwkgKiBXQUwgcmVjb3JkKS4KIAkgKgogCSAqIE5PVEU6IHNldF9hbGxfdmlzaWJsZSBhbmQg c2V0X2FsbF9mcm96ZW4gaW5pdGlhbGx5IGRvbid0IGluY2x1ZGUKIAkgKiBMUF9ERUFEIGl0ZW1z LiBUaGF0J3MgY29udmVuaWVudCBmb3IgaGVhcF9wYWdlX3BydW5lX2FuZF9mcmVlemUoKSB0bwpA QCAtMTA4NSw2ICsxMDg4LDE3IEBAIGhlYXBfcGFnZV9wcnVuZV9hbmRfZnJlZXplKFBydW5lRnJl ZXplUGFyYW1zICpwYXJhbXMsCiAJICovCiAJcHJ1bmVfZnJlZXplX3BsYW4oJnByc3RhdGUsIG9m Zl9sb2MpOwogCisJLyoKKwkgKiBBZnRlciBwcm9jZXNzaW5nIGFsbCB0aGUgbGl2ZSB0dXBsZXMg b24gdGhlIHBhZ2UsIGlmIHRoZSBuZXdlc3QgeG1pbgorCSAqIGFtb25nc3QgdGhlbSBtYXkgYmUg Y29uc2lkZXJlZCBydW5uaW5nIGJ5IGFueSBzbmFwc2hvdCwgdGhlIHBhZ2UgY2Fubm90CisJICog YmUgYWxsLXZpc2libGUuCisJICovCisJaWYgKHByc3RhdGUuc2V0X2FsbF92aXNpYmxlICYmCisJ CVRyYW5zYWN0aW9uSWRJc05vcm1hbChwcnN0YXRlLnZpc2liaWxpdHlfY3V0b2ZmX3hpZCkgJiYK KwkJR2xvYmFsVmlzVGVzdFhpZE1heWJlUnVubmluZyhwcnN0YXRlLnZpc3Rlc3QsCisJCQkJCQkJ CQkgcHJzdGF0ZS52aXNpYmlsaXR5X2N1dG9mZl94aWQpKQorCQlwcnN0YXRlLnNldF9hbGxfdmlz aWJsZSA9IHByc3RhdGUuc2V0X2FsbF9mcm96ZW4gPSBmYWxzZTsKKwogCS8qCiAJICogSWYgY2hl Y2tzdW1zIGFyZSBlbmFibGVkLCBjYWxsaW5nIGhlYXBfcHJ1bmVfc2F0aXNmaWVzX3ZhY3V1bSgp IHdoaWxlCiAJICogY2hlY2tpbmcgdHVwbGUgdmlzaWJpbGl0eSBpbmZvcm1hdGlvbiBpbiBwcnVu ZV9mcmVlemVfcGxhbigpIG1heSBoYXZlCkBAIC0xNzUzLDI5ICsxNzY3LDE1IEBAIGhlYXBfcHJ1 bmVfcmVjb3JkX3VuY2hhbmdlZF9scF9ub3JtYWwoUHJ1bmVTdGF0ZSAqcHJzdGF0ZSwgT2Zmc2V0 TnVtYmVyIG9mZm51bSkKIAkJCQl9CiAKIAkJCQkvKgotCQkJCSAqIFRoZSBpbnNlcnRlciBkZWZp bml0ZWx5IGNvbW1pdHRlZC4gIEJ1dCBpcyBpdCBvbGQgZW5vdWdoCi0JCQkJICogdGhhdCBldmVy eW9uZSBzZWVzIGl0IGFzIGNvbW1pdHRlZD8gIEEgRnJvemVuVHJhbnNhY3Rpb25JZAotCQkJCSAq IGlzIHNlZW4gYXMgY29tbWl0dGVkIHRvIGV2ZXJ5b25lLiAgT3RoZXJ3aXNlLCB3ZSBjaGVjayBp ZgotCQkJCSAqIHRoZXJlIGlzIGEgc25hcHNob3QgdGhhdCBjb25zaWRlcnMgdGhpcyB4aWQgdG8g c3RpbGwgYmUKLQkJCQkgKiBydW5uaW5nLCBhbmQgaWYgc28sIHdlIGRvbid0IGNvbnNpZGVyIHRo ZSBwYWdlIGFsbC12aXNpYmxlLgorCQkJCSAqIFRoZSBpbnNlcnRlciBkZWZpbml0ZWx5IGNvbW1p dHRlZC4gQnV0IHdlIGRvbid0IGtub3cgaWYgaXQKKwkJCQkgKiBpcyBvbGQgZW5vdWdoIHRoYXQg ZXZlcnlvbmUgc2VlcyBpdCBhcyBjb21taXR0ZWQuIExhdGVyLAorCQkJCSAqIGFmdGVyIHByb2Nl c3NpbmcgYWxsIHRoZSB0dXBsZXMgb24gdGhlIHBhZ2UsIHdlJ2xsIGNoZWNrIGlmCisJCQkJICog dGhlcmUgaXMgYW55IHNuYXBzaG90IHRoYXQgc3RpbGwgY29uc2lkZXJzIHRoZSBuZXdlc3QgeGlk CisJCQkJICogb24gdGhlIHBhZ2UgdG8gYmUgcnVubmluZy4gSWYgc28sIHdlIGRvbid0IGNvbnNp ZGVyIHRoZQorCQkJCSAqIHBhZ2UgYWxsLXZpc2libGUuCiAJCQkJICovCiAJCQkJeG1pbiA9IEhl YXBUdXBsZUhlYWRlckdldFhtaW4oaHR1cCk7CiAKLQkJCQkvKgotCQkJCSAqIEZvciBub3cgYWx3 YXlzIHVzZSBwcnN0YXRlLT5jdXRvZmZzIGZvciB0aGlzIHRlc3QsIGJlY2F1c2UKLQkJCQkgKiB3 ZSBvbmx5IHVwZGF0ZSAnc2V0X2FsbF92aXNpYmxlJyBhbmQgJ3NldF9hbGxfZnJvemVuJyB3aGVu Ci0JCQkJICogZnJlZXppbmcgaXMgcmVxdWVzdGVkLiBXZSBjb3VsZCB1c2UKLQkJCQkgKiBHbG9i YWxWaXNUZXN0SXNSZW1vdmFibGVYaWQgaW5zdGVhZCwgaWYgYSBub24tZnJlZXppbmcKLQkJCQkg KiBjYWxsZXIgd2FudGVkIHRvIHNldCB0aGUgVk0gYml0LgotCQkJCSAqLwotCQkJCUFzc2VydChw cnN0YXRlLT5jdXRvZmZzKTsKLQkJCQlpZiAoIVRyYW5zYWN0aW9uSWRQcmVjZWRlcyh4bWluLCBw cnN0YXRlLT5jdXRvZmZzLT5PbGRlc3RYbWluKSkKLQkJCQl7Ci0JCQkJCXByc3RhdGUtPnNldF9h bGxfdmlzaWJsZSA9IGZhbHNlOwotCQkJCQlwcnN0YXRlLT5zZXRfYWxsX2Zyb3plbiA9IGZhbHNl OwotCQkJCQlicmVhazsKLQkJCQl9Ci0KIAkJCQkvKiBUcmFjayBuZXdlc3QgeG1pbiBvbiBwYWdl LiAqLwogCQkJCWlmIChUcmFuc2FjdGlvbklkRm9sbG93cyh4bWluLCBwcnN0YXRlLT52aXNpYmls aXR5X2N1dG9mZl94aWQpICYmCiAJCQkJCVRyYW5zYWN0aW9uSWRJc05vcm1hbCh4bWluKSkKZGlm ZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYyBiL3NyYy9iYWNr ZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYwppbmRleCAxYTQ0NjA1MGQ4NS4uMmE5NGJhM2Ez ODcgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYworKysg Yi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMKQEAgLTQ2OCwxMyArNDY4LDEz IEBAIHN0YXRpYyB2b2lkIGRlYWRfaXRlbXNfY2xlYW51cChMVlJlbFN0YXRlICp2YWNyZWwpOwog CiAjaWZkZWYgVVNFX0FTU0VSVF9DSEVDS0lORwogc3RhdGljIGJvb2wgaGVhcF9wYWdlX2lzX2Fs bF92aXNpYmxlKFJlbGF0aW9uIHJlbCwgQnVmZmVyIGJ1ZiwKLQkJCQkJCQkJCSBUcmFuc2FjdGlv bklkIE9sZGVzdFhtaW4sCisJCQkJCQkJCQkgR2xvYmFsVmlzU3RhdGUgKnZpc3Rlc3QsCiAJCQkJ CQkJCQkgYm9vbCAqYWxsX2Zyb3plbiwKIAkJCQkJCQkJCSBUcmFuc2FjdGlvbklkICp2aXNpYmls aXR5X2N1dG9mZl94aWQsCiAJCQkJCQkJCQkgT2Zmc2V0TnVtYmVyICpsb2dnaW5nX29mZm51bSk7 CiAjZW5kaWYKIHN0YXRpYyBib29sIGhlYXBfcGFnZV93b3VsZF9iZV9hbGxfdmlzaWJsZShSZWxh dGlvbiByZWwsIEJ1ZmZlciBidWYsCi0JCQkJCQkJCQkJICAgVHJhbnNhY3Rpb25JZCBPbGRlc3RY bWluLAorCQkJCQkJCQkJCSAgIEdsb2JhbFZpc1N0YXRlICp2aXN0ZXN0LAogCQkJCQkJCQkJCSAg IE9mZnNldE51bWJlciAqZGVhZG9mZnNldHMsCiAJCQkJCQkJCQkJICAgaW50IG5kZWFkb2Zmc2V0 cywKIAkJCQkJCQkJCQkgICBib29sICphbGxfZnJvemVuLApAQCAtMjA4OSw3ICsyMDg5LDcgQEAg bGF6eV9zY2FuX3BydW5lKExWUmVsU3RhdGUgKnZhY3JlbCwKIAkJQXNzZXJ0KHByZXN1bHQubHBk ZWFkX2l0ZW1zID09IDApOwogCiAJCUFzc2VydChoZWFwX3BhZ2VfaXNfYWxsX3Zpc2libGUodmFj cmVsLT5yZWwsIGJ1ZiwKLQkJCQkJCQkJCQl2YWNyZWwtPmN1dG9mZnMuT2xkZXN0WG1pbiwgJmRl YnVnX2FsbF9mcm96ZW4sCisJCQkJCQkJCQkJdmFjcmVsLT52aXN0ZXN0LCAmZGVidWdfYWxsX2Zy b3plbiwKIAkJCQkJCQkJCQkmZGVidWdfY3V0b2ZmLCAmdmFjcmVsLT5vZmZudW0pKTsKIAogCQlB c3NlcnQocHJlc3VsdC5zZXRfYWxsX2Zyb3plbiA9PSBkZWJ1Z19hbGxfZnJvemVuKTsKQEAgLTI4 NTIsNyArMjg1Miw3IEBAIGxhenlfdmFjdXVtX2hlYXBfcGFnZShMVlJlbFN0YXRlICp2YWNyZWws IEJsb2NrTnVtYmVyIGJsa25vLCBCdWZmZXIgYnVmZmVyLAogCSAqIGRvbmUgb3V0c2lkZSB0aGUg Y3JpdGljYWwgc2VjdGlvbi4KIAkgKi8KIAlpZiAoaGVhcF9wYWdlX3dvdWxkX2JlX2FsbF92aXNp YmxlKHZhY3JlbC0+cmVsLCBidWZmZXIsCi0JCQkJCQkJCQkgICB2YWNyZWwtPmN1dG9mZnMuT2xk ZXN0WG1pbiwKKwkJCQkJCQkJCSAgIHZhY3JlbC0+dmlzdGVzdCwKIAkJCQkJCQkJCSAgIGRlYWRv ZmZzZXRzLCBudW1fb2Zmc2V0cywKIAkJCQkJCQkJCSAgICZhbGxfZnJvemVuLCAmdmlzaWJpbGl0 eV9jdXRvZmZfeGlkLAogCQkJCQkJCQkJICAgJnZhY3JlbC0+b2ZmbnVtKSkKQEAgLTM2MTQsMTQg KzM2MTQsMTQgQEAgZGVhZF9pdGVtc19jbGVhbnVwKExWUmVsU3RhdGUgKnZhY3JlbCkKICAqLwog c3RhdGljIGJvb2wKIGhlYXBfcGFnZV9pc19hbGxfdmlzaWJsZShSZWxhdGlvbiByZWwsIEJ1ZmZl ciBidWYsCi0JCQkJCQkgVHJhbnNhY3Rpb25JZCBPbGRlc3RYbWluLAorCQkJCQkJIEdsb2JhbFZp c1N0YXRlICp2aXN0ZXN0LAogCQkJCQkJIGJvb2wgKmFsbF9mcm96ZW4sCiAJCQkJCQkgVHJhbnNh Y3Rpb25JZCAqdmlzaWJpbGl0eV9jdXRvZmZfeGlkLAogCQkJCQkJIE9mZnNldE51bWJlciAqbG9n Z2luZ19vZmZudW0pCiB7CiAKIAlyZXR1cm4gaGVhcF9wYWdlX3dvdWxkX2JlX2FsbF92aXNpYmxl KHJlbCwgYnVmLAotCQkJCQkJCQkJCSAgT2xkZXN0WG1pbiwKKwkJCQkJCQkJCQkgIHZpc3Rlc3Qs CiAJCQkJCQkJCQkJICBOVUxMLCAwLAogCQkJCQkJCQkJCSAgYWxsX2Zyb3plbiwKIAkJCQkJCQkJ CQkgIHZpc2liaWxpdHlfY3V0b2ZmX3hpZCwKQEAgLTM2NDIsNyArMzY0Miw3IEBAIGhlYXBfcGFn ZV9pc19hbGxfdmlzaWJsZShSZWxhdGlvbiByZWwsIEJ1ZmZlciBidWYsCiAgKiBSZXR1cm5zIHRy dWUgaWYgdGhlIHBhZ2UgaXMgYWxsLXZpc2libGUgb3RoZXIgdGhhbiB0aGUgcHJvdmlkZWQKICAq IGRlYWRvZmZzZXRzIGFuZCBmYWxzZSBvdGhlcndpc2UuCiAgKgotICogT2xkZXN0WG1pbiBpcyB1 c2VkIHRvIGRldGVybWluZSB2aXNpYmlsaXR5LgorICogdmlzdGVzdCBpcyB1c2VkIHRvIGRldGVy bWluZSB2aXNpYmlsaXR5LgogICoKICAqIE91dHB1dCBwYXJhbWV0ZXJzOgogICoKQEAgLTM2NjEs NyArMzY2MSw3IEBAIGhlYXBfcGFnZV9pc19hbGxfdmlzaWJsZShSZWxhdGlvbiByZWwsIEJ1ZmZl ciBidWYsCiAgKi8KIHN0YXRpYyBib29sCiBoZWFwX3BhZ2Vfd291bGRfYmVfYWxsX3Zpc2libGUo UmVsYXRpb24gcmVsLCBCdWZmZXIgYnVmLAotCQkJCQkJCSAgIFRyYW5zYWN0aW9uSWQgT2xkZXN0 WG1pbiwKKwkJCQkJCQkgICBHbG9iYWxWaXNTdGF0ZSAqdmlzdGVzdCwKIAkJCQkJCQkgICBPZmZz ZXROdW1iZXIgKmRlYWRvZmZzZXRzLAogCQkJCQkJCSAgIGludCBuZGVhZG9mZnNldHMsCiAJCQkJ CQkJICAgYm9vbCAqYWxsX2Zyb3plbiwKQEAgLTM3NDIsNyArMzc0Miw3IEBAIGhlYXBfcGFnZV93 b3VsZF9iZV9hbGxfdmlzaWJsZShSZWxhdGlvbiByZWwsIEJ1ZmZlciBidWYsCiAJCQkJewogCQkJ CQlUcmFuc2FjdGlvbklkIHhtaW47CiAKLQkJCQkJLyogQ2hlY2sgY29tbWVudHMgaW4gbGF6eV9z Y2FuX3BydW5lLiAqLworCQkJCQkvKiBDaGVjayBoZWFwX3BydW5lX3JlY29yZF91bmNoYW5nZWRf bHBfbm9ybWFsIGNvbW1lbnRzICovCiAJCQkJCWlmICghSGVhcFR1cGxlSGVhZGVyWG1pbkNvbW1p dHRlZCh0dXBsZS50X2RhdGEpKQogCQkJCQl7CiAJCQkJCQlhbGxfdmlzaWJsZSA9IGZhbHNlOwpA QCAtMzc1MSwxNiArMzc1MSwxNyBAQCBoZWFwX3BhZ2Vfd291bGRfYmVfYWxsX3Zpc2libGUoUmVs YXRpb24gcmVsLCBCdWZmZXIgYnVmLAogCQkJCQl9CiAKIAkJCQkJLyoKLQkJCQkJICogVGhlIGlu c2VydGVyIGRlZmluaXRlbHkgY29tbWl0dGVkLiBCdXQgaXMgaXQgb2xkIGVub3VnaAotCQkJCQkg KiB0aGF0IGV2ZXJ5b25lIHNlZXMgaXQgYXMgY29tbWl0dGVkPworCQkJCQkgKiBUaGUgaW5zZXJ0 ZXIgZGVmaW5pdGVseSBjb21taXR0ZWQuIEJ1dCB3ZSBkb24ndCBrbm93IGlmCisJCQkJCSAqIGl0 IGlzIG9sZCBlbm91Z2ggdGhhdCBldmVyeW9uZSBzZWVzIGl0IGFzIGNvbW1pdHRlZC4KKwkJCQkJ ICogRG9uJ3QgY2hlY2sgdGhhdCBub3cuCisJCQkJCSAqCisJCQkJCSAqIElmIHdlIHNjYW4gYWxs IHR1cGxlcyB3aXRob3V0IGZpbmRpbmcgb25lIHRoYXQgcHJldmVudHMKKwkJCQkJICogdGhlIHBh Z2UgZnJvbSBiZWluZyBhbGwtdmlzaWJsZSwgd2UgdGhlbiBjaGVjayB3aGV0aGVyCisJCQkJCSAq IGFueSBzbmFwc2hvdCBzdGlsbCBjb25zaWRlcnMgdGhlIG5ld2VzdCBYSUQgb24gdGhlIHBhZ2UK KwkJCQkJICogdG8gYmUgcnVubmluZy4gSW4gdGhhdCBjYXNlLCB0aGUgcGFnZSBpcyBub3QgY29u c2lkZXJlZAorCQkJCQkgKiBhbGwtdmlzaWJsZS4KIAkJCQkJICovCiAJCQkJCXhtaW4gPSBIZWFw VHVwbGVIZWFkZXJHZXRYbWluKHR1cGxlLnRfZGF0YSk7Ci0JCQkJCWlmICghVHJhbnNhY3Rpb25J ZFByZWNlZGVzKHhtaW4sIE9sZGVzdFhtaW4pKQotCQkJCQl7Ci0JCQkJCQlhbGxfdmlzaWJsZSA9 IGZhbHNlOwotCQkJCQkJKmFsbF9mcm96ZW4gPSBmYWxzZTsKLQkJCQkJCWJyZWFrOwotCQkJCQl9 CiAKIAkJCQkJLyogVHJhY2sgbmV3ZXN0IHhtaW4gb24gcGFnZS4gKi8KIAkJCQkJaWYgKFRyYW5z YWN0aW9uSWRGb2xsb3dzKHhtaW4sICp2aXNpYmlsaXR5X2N1dG9mZl94aWQpICYmCkBAIC0zNzg5 LDYgKzM3OTAsMTkgQEAgaGVhcF9wYWdlX3dvdWxkX2JlX2FsbF92aXNpYmxlKFJlbGF0aW9uIHJl bCwgQnVmZmVyIGJ1ZiwKIAkJfQogCX0JCQkJCQkJLyogc2NhbiBhbG9uZyBwYWdlICovCiAKKwkv KgorCSAqIEFmdGVyIHByb2Nlc3NpbmcgYWxsIHRoZSBsaXZlIHR1cGxlcyBvbiB0aGUgcGFnZSwg aWYgdGhlIG5ld2VzdCB4bWluCisJICogYW1vbmcgdGhlbSBtYXkgc3RpbGwgYmUgY29uc2lkZXJl ZCBydW5uaW5nIGJ5IGFueSBzbmFwc2hvdCwgdGhlIHBhZ2UKKwkgKiBjYW5ub3QgYmUgYWxsLXZp c2libGUuCisJICovCisJaWYgKGFsbF92aXNpYmxlICYmCisJCVRyYW5zYWN0aW9uSWRJc05vcm1h bCgqdmlzaWJpbGl0eV9jdXRvZmZfeGlkKSAmJgorCQlHbG9iYWxWaXNUZXN0WGlkTWF5YmVSdW5u aW5nKHZpc3Rlc3QsICp2aXNpYmlsaXR5X2N1dG9mZl94aWQpKQorCXsKKwkJYWxsX3Zpc2libGUg PSBmYWxzZTsKKwkJKmFsbF9mcm96ZW4gPSBmYWxzZTsKKwl9CisKIAkvKiBDbGVhciB0aGUgb2Zm c2V0IGluZm9ybWF0aW9uIG9uY2Ugd2UgaGF2ZSBwcm9jZXNzZWQgdGhlIGdpdmVuIHBhZ2UuICov CiAJKmxvZ2dpbmdfb2ZmbnVtID0gSW52YWxpZE9mZnNldE51bWJlcjsKIApkaWZmIC0tZ2l0IGEv c3JjL2luY2x1ZGUvYWNjZXNzL2hlYXBhbS5oIGIvc3JjL2luY2x1ZGUvYWNjZXNzL2hlYXBhbS5o CmluZGV4IDMwNWVjYzMxYTllLi5mOWRiZDcwYzFjNCAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUv YWNjZXNzL2hlYXBhbS5oCisrKyBiL3NyYy9pbmNsdWRlL2FjY2Vzcy9oZWFwYW0uaApAQCAtNDgw LDYgKzQ4MCw4IEBAIGV4dGVybiBUTV9SZXN1bHQgSGVhcFR1cGxlU2F0aXNmaWVzVXBkYXRlKEhl YXBUdXBsZSBodHVwLCBDb21tYW5kSWQgY3VyY2lkLAogCQkJCQkJCQkJCSAgQnVmZmVyIGJ1ZmZl cik7CiBleHRlcm4gSFRTVl9SZXN1bHQgSGVhcFR1cGxlU2F0aXNmaWVzVmFjdXVtKEhlYXBUdXBs ZSBodHVwLCBUcmFuc2FjdGlvbklkIE9sZGVzdFhtaW4sCiAJCQkJCQkJCQkJCUJ1ZmZlciBidWZm ZXIpOworCitleHRlcm4gYm9vbCBHbG9iYWxWaXNUZXN0WGlkTWF5YmVSdW5uaW5nKEdsb2JhbFZp c1N0YXRlICpzdGF0ZSwgVHJhbnNhY3Rpb25JZCB4aWQpOwogZXh0ZXJuIEhUU1ZfUmVzdWx0IEhl YXBUdXBsZVNhdGlzZmllc1ZhY3V1bUhvcml6b24oSGVhcFR1cGxlIGh0dXAsIEJ1ZmZlciBidWZm ZXIsCiAJCQkJCQkJCQkJCQkgICBUcmFuc2FjdGlvbklkICpkZWFkX2FmdGVyKTsKIGV4dGVybiB2 b2lkIEhlYXBUdXBsZVNldEhpbnRCaXRzKEhlYXBUdXBsZUhlYWRlciB0dXBsZSwgQnVmZmVyIGJ1 ZmZlciwKLS0gCjIuNDMuMAoK --00000000000060fd69064d6b968a Content-Type: text/x-patch; charset="US-ASCII"; name="v41-0004-Keep-newest-live-XID-up-to-date-even-if-page-not.patch" Content-Disposition: attachment; filename="v41-0004-Keep-newest-live-XID-up-to-date-even-if-page-not.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmyaga1q3 RnJvbSBkZTA3NjQ1YjA4NGMyZTAxMDUwYWM1ZmE4YTZjODAyNDA4NDI2NzNlIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBTYXQsIDI4IEZlYiAyMDI2IDE2OjA2OjUxIC0wNTAwClN1YmplY3Q6IFtQ QVRDSCB2NDEgMDQvMTJdIEtlZXAgbmV3ZXN0IGxpdmUgWElEIHVwLXRvLWRhdGUgZXZlbiBpZiBw YWdlIG5vdAogYWxsLXZpc2libGUKCkR1cmluZyBwcnVuaW5nLCB3ZSBrZWVwIHRyYWNrIG9mIHRo ZSBuZXdlc3QgeG1pbiBvZiBsaXZlIHR1cGxlcyBvbiB0aGUKcGFnZSB2aXNpYmxlIHRvIGFsbCBy dW5uaW5nIGFuZCBmdXR1cmUgdHJhbnNhY3Rpb25zIHNvIHRoYXQgd2UgY2FuIHVzZQppdCBsYXRl ciBhcyB0aGUgc25hcHNob3QgY29uZmxpY3QgaG9yaXpvbiB3aGVuIHNldHRpbmcgdGhlIFZNIGlm IHRoZQpwYWdlIHR1cm5zIG91dCB0byBiZSBhbGwtdmlzaWJsZS4KClByZXZpb3VzbHksIHdlIHN0 b3BwZWQgdXBkYXRpbmcgdGhpcyB2YWx1ZSBvbmNlIHdlIGRldGVybWluZWQgdGhlIHBhZ2UKd2Fz IG5vdCBhbGwtdmlzaWJsZS4gSG93ZXZlciwgbWFpbnRhaW5pbmcgaXQgZXZlbiB3aGVuIHRoZSBw YWdlIGlzIG5vdAphbGwtdmlzaWJsZSBpcyBpbmV4cGVuc2l2ZSBhbmQgbWFrZXMgdGhlIHNuYXBz aG90IGNvbmZsaWN0IGhvcml6b24KY2FsY3VsYXRpb24gY2xlYXJlci4gVGhpcyBndWFyYW50ZWVz IGl0IHdvbid0IGNvbnRhaW4gYSBzdGFsZSB2YWx1ZS4KClNpbmNlIHdlJ2xsIGtlZXAgaXQgdXAg dG8gZGF0ZSBhbGwgdGhlIHRpbWUgbm93IGFueXdheSwgdGhlcmUncyBubwpyZWFzb24gbm90IHRv IG1haW50YWluIGFsbF92aXNpYmxlIGZvciBvbi1hY2Nlc3MgcHJ1bmluZy4gVGhpcyB3aWxsCmFs bG93IHVzIHRvIHNldCB0aGUgVk0gb24tYWNjZXNzIGluIHRoZSBmdXR1cmUuCgpBdXRob3I6IE1l bGFuaWUgUGxhZ2VtYW4gPG1lbGFuaWVwbGFnZW1hbkBnbWFpbC5jb20+ClJldmlld2VkLWJ5OiBB bmRyZXMgRnJldW5kIDxhbmRyZXNAYW5hcmF6ZWwuZGU+ClJldmlld2VkLWJ5OiBDaGFvIExpIDxs aS5ldmFuLmNoYW9AZ21haWwuY29tPgpEaXNjdXNzaW9uOiBodHRwczovL3Bvc3Rnci5lcy9tL2Jx YzRraDVtaWRmbjQ0Z25qaXFlejNianF2NHpvZ3lkZ3V2ZG40NDZyaXc0NWpjZjN5JTQwNGV6NjZp bDdlYnZrCi0tLQogc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvcHJ1bmVoZWFwLmMgIHwgMTM3ICsr KysrKysrKysrLS0tLS0tLS0tLS0tLS0tLQogc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvdmFjdXVt bGF6eS5jIHwgIDMwICsrKy0tLQogMiBmaWxlcyBjaGFuZ2VkLCA3MiBpbnNlcnRpb25zKCspLCA5 NSBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9wcnVu ZWhlYXAuYyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3BydW5laGVhcC5jCmluZGV4IGY0Mzc1 NzkwNzZlLi45NDUxZTk0MTdmNyAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAv cHJ1bmVoZWFwLmMKKysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvcHJ1bmVoZWFwLmMKQEAg LTEyOSw2ICsxMjksOSBAQCB0eXBlZGVmIHN0cnVjdAogCS8qIEJpdHMgaW4gdGhlIHZtYnVmZmVy IGZvciB0aGlzIGhlYXAgcGFnZSAqLwogCXVpbnQ4CQlvbGRfdm1iaXRzOwogCisJLyogVGhlIG5l d2VzdCB4bWluIG9mIGxpdmUgdHVwbGVzIG9uIHRoZSBwYWdlICovCisJVHJhbnNhY3Rpb25JZCBu ZXdlc3RfbGl2ZV94aWQ7CisKIAkvKgogCSAqIFRydWUgaWYgdGhlIHBhZ2UgY2FuIGJ5cGFzcyBm dWxsIHBhZ2UgaW5zcGVjdGlvbiBkdXJpbmcgcHJ1bmluZyBhbmQKIAkgKiBmcmVlemluZyBiYXNl ZCBvbiBpdHMgdmlzaWJpbGl0eSBtYXAgc3RhdHVzIGFuZCB0aGUgY2FsbGVyJ3Mgb3B0aW9ucy4K QEAgLTE2NiwxNCArMTY5LDYgQEAgdHlwZWRlZiBzdHJ1Y3QKIAkgKiBhbGwtZnJvemVuIGJpdHMg aW4gdGhlIHZpc2liaWxpdHkgbWFwIGNhbiBiZSBzZXQgZm9yIHRoaXMgcGFnZSBhZnRlcgogCSAq IHBydW5pbmcuCiAJICoKLQkgKiB2aXNpYmlsaXR5X2N1dG9mZl94aWQgaXMgdGhlIG5ld2VzdCB4 bWluIG9mIGxpdmUgdHVwbGVzIG9uIHRoZSBwYWdlLiBJdAotCSAqIGlzIHVzZWQgYWZ0ZXIgcHJv Y2Vzc2luZyBhbGwgdHVwbGVzIHRvIGRldGVybWluZSBpZiB0aGUgcGFnZSBjYW4gYmUKLQkgKiBj b25zaWRlcmVkIGFsbC12aXNpYmxlIChpZiB0aGUgbmV3ZXN0IHhtaW4gaXMgc3RpbGwgY29uc2lk ZXJlZCBydW5uaW5nCi0JICogYnkgc29tZSBzbmFwc2hvdCwgaXQgY2Fubm90IGJlKS4gSXQgaXMg YWxzbyB1c2VkIGJ5IHRoZSBjYWxsZXIgYXMgdGhlCi0JICogY29uZmxpY3QgaG9yaXpvbiB3aGVu IHNldHRpbmcgdGhlIFZNIGJpdHMsIHVubGVzcyB3ZSBmcm96ZSBhbGwgdHVwbGVzCi0JICogb24g dGhlIHBhZ2UgKGluIHdoaWNoIGNhc2UgdGhlIGNvbmZsaWN0IHhpZCB3YXMgYWxyZWFkeSBpbmNs dWRlZCBpbiB0aGUKLQkgKiBXQUwgcmVjb3JkKS4KLQkgKgogCSAqIE5PVEU6IHNldF9hbGxfdmlz aWJsZSBhbmQgc2V0X2FsbF9mcm96ZW4gaW5pdGlhbGx5IGRvbid0IGluY2x1ZGUKIAkgKiBMUF9E RUFEIGl0ZW1zLiBUaGF0J3MgY29udmVuaWVudCBmb3IgaGVhcF9wYWdlX3BydW5lX2FuZF9mcmVl emUoKSB0bwogCSAqIHVzZSB0aGVtIHRvIGRlY2lkZSB3aGV0aGVyIHRvIGZyZWV6ZSB0aGUgcGFn ZSBvciBub3QuICBUaGUKQEAgLTE4Myw3ICsxNzgsNiBAQCB0eXBlZGVmIHN0cnVjdAogCSAqLwog CWJvb2wJCXNldF9hbGxfdmlzaWJsZTsKIAlib29sCQlzZXRfYWxsX2Zyb3plbjsKLQlUcmFuc2Fj dGlvbklkIHZpc2liaWxpdHlfY3V0b2ZmX3hpZDsKIH0gUHJ1bmVTdGF0ZTsKIAogCkBAIC00NzEs NTMgKzQ2NSw0MiBAQCBwcnVuZV9mcmVlemVfc2V0dXAoUHJ1bmVGcmVlemVQYXJhbXMgKnBhcmFt cywKIAlwcnN0YXRlLT5kZWFkb2Zmc2V0cyA9IHByZXN1bHQtPmRlYWRvZmZzZXRzOwogCiAJLyoK LQkgKiBWYWN1dW0gbWF5IHVwZGF0ZSB0aGUgVk0gYWZ0ZXIgd2UncmUgZG9uZS4gIFdlIGNhbiBr ZWVwIHRyYWNrIG9mCi0JICogd2hldGhlciB0aGUgcGFnZSB3aWxsIGJlIGFsbC12aXNpYmxlIGFu ZCBhbGwtZnJvemVuIGFmdGVyIHBydW5pbmcgYW5kCi0JICogZnJlZXppbmcgdG8gaGVscCB0aGUg Y2FsbGVyIHRvIGRvIHRoYXQuCi0JICoKLQkgKiBDdXJyZW50bHksIG9ubHkgVkFDVVVNIHNldHMg dGhlIFZNIGJpdHMuICBUbyBzYXZlIHRoZSBlZmZvcnQsIG9ubHkgZG8KLQkgKiB0aGUgYm9va2tl ZXBpbmcgaWYgdGhlIGNhbGxlciBuZWVkcyBpdC4gIEN1cnJlbnRseSwgdGhhdCdzIHRpZWQgdG8K LQkgKiBIRUFQX1BBR0VfUFJVTkVfRlJFRVpFLCBidXQgaXQgY291bGQgYmUgYSBzZXBhcmF0ZSBm bGFnIGlmIHlvdSB3YW50ZWQKLQkgKiB0byB1cGRhdGUgdGhlIFZNIGJpdHMgd2l0aG91dCBhbHNv IGZyZWV6aW5nIG9yIGZyZWV6ZSB3aXRob3V0IGFsc28KLQkgKiBzZXR0aW5nIHRoZSBWTSBiaXRz LgorCSAqIFdlIHRyYWNrIHdoZXRoZXIgdGhlIHBhZ2Ugd2lsbCBiZSBhbGwtdmlzaWJsZS9hbGwt ZnJvemVuIGF0IHRoZSBlbmQgb2YKKwkgKiBwcnVuaW5nIGFuZCBmcmVlemluZy4gV2hpbGUgZXhh bWluaW5nIHR1cGxlIHZpc2liaWxpdHksIHdlJ2xsIHNldAorCSAqIHNldF9hbGxfdmlzaWJsZSB0 byBmYWxzZSBpZiB0aGVyZSBhcmUgdHVwbGVzIG9uIHRoZSBwYWdlIG5vdCB2aXNpYmxlIHRvCisJ ICogYWxsIHJ1bm5pbmcgYW5kIGZ1dHVyZSB0cmFuc2FjdGlvbnMuIHNldF9hbGxfdmlzaWJsZSBp cyBhbHdheXMKKwkgKiBtYWludGFpbmVkIGJ1dCBvbmx5IFZBQ1VVTSB3aWxsIHNldCB0aGUgVk0g aWYgdGhlIHBhZ2UgZW5kcyB1cCBiZWluZworCSAqIGFsbC12aXNpYmxlLgogCSAqCi0JICogSW4g YWRkaXRpb24gdG8gdGVsbGluZyB0aGUgY2FsbGVyIHdoZXRoZXIgaXQgY2FuIHNldCB0aGUgVk0g Yml0LCB3ZQotCSAqIGFsc28gdXNlICdzZXRfYWxsX3Zpc2libGUnIGFuZCAnc2V0X2FsbF9mcm96 ZW4nIGZvciBvdXIgb3duCi0JICogZGVjaXNpb24tbWFraW5nLiBJZiB0aGUgd2hvbGUgcGFnZSB3 b3VsZCBiZWNvbWUgZnJvemVuLCB3ZSBjb25zaWRlcgotCSAqIG9wcG9ydHVuaXN0aWNhbGx5IGZy ZWV6aW5nIHR1cGxlcy4gIFdlIHdpbGwgbm90IGJlIGFibGUgdG8gZnJlZXplIHRoZQotCSAqIHdo b2xlIHBhZ2UgaWYgdGhlcmUgYXJlIHR1cGxlcyBwcmVzZW50IHRoYXQgYXJlIG5vdCB2aXNpYmxl IHRvIGV2ZXJ5b25lCi0JICogb3IgaWYgdGhlcmUgYXJlIGRlYWQgdHVwbGVzIHdoaWNoIGFyZSBu b3QgeWV0IHJlbW92YWJsZS4gIEhvd2V2ZXIsIGRlYWQKLQkgKiB0dXBsZXMgd2hpY2ggd2lsbCBi ZSByZW1vdmVkIGJ5IHRoZSBlbmQgb2YgdmFjdXVtaW5nIHNob3VsZCBub3QKLQkgKiBwcmVjbHVk ZSB1cyBmcm9tIG9wcG9ydHVuaXN0aWNhbGx5IGZyZWV6aW5nLiAgQmVjYXVzZSBvZiB0aGF0LCB3 ZSBkbwotCSAqIG5vdCBpbW1lZGlhdGVseSBjbGVhciBzZXRfYWxsX3Zpc2libGUgYW5kIHNldF9h bGxfZnJvemVuIHdoZW4gd2Ugc2VlCi0JICogTFBfREVBRCBpdGVtcy4gIFdlIGZpeCB0aGF0IGFm dGVyIHNjYW5uaW5nIHRoZSBsaW5lIHBvaW50ZXJzLiBXZSBtdXN0Ci0JICogY29ycmVjdCBzZXRf YWxsX3Zpc2libGUgYW5kIHNldF9hbGxfZnJvemVuIGJlZm9yZSB3ZSByZXR1cm4gdGhlbSB0byB0 aGUKLQkgKiBjYWxsZXIsIHNvIHRoYXQgdGhlIGNhbGxlciBkb2Vzbid0IHNldCB0aGUgVk0gYml0 cyBpbmNvcnJlY3RseS4KKwkgKiBXZSBhbHNvIGtlZXAgdHJhY2sgb2YgdGhlIG5ld2VzdCBsaXZl IFhJRCwgd2hpY2ggaXMgdXNlZCB0byBjYWxjdWxhdGUKKwkgKiB0aGUgc25hcHNob3QgY29uZmxp Y3QgaG9yaXpvbiBmb3IgYSBXQUwgcmVjb3JkIHNldHRpbmcgdGhlIFZNLgogCSAqLwotCWlmIChw cnN0YXRlLT5hdHRlbXB0X2ZyZWV6ZSkKLQl7Ci0JCXByc3RhdGUtPnNldF9hbGxfdmlzaWJsZSA9 IHRydWU7Ci0JCXByc3RhdGUtPnNldF9hbGxfZnJvemVuID0gdHJ1ZTsKLQl9Ci0JZWxzZQotCXsK LQkJLyoKLQkJICogSW5pdGlhbGl6aW5nIHRvIGZhbHNlIGFsbG93cyBza2lwcGluZyB0aGUgd29y ayB0byB1cGRhdGUgdGhlbSBpbgotCQkgKiBoZWFwX3BydW5lX3JlY29yZF91bmNoYW5nZWRfbHBf bm9ybWFsKCkuCi0JCSAqLwotCQlwcnN0YXRlLT5zZXRfYWxsX3Zpc2libGUgPSBmYWxzZTsKLQkJ cHJzdGF0ZS0+c2V0X2FsbF9mcm96ZW4gPSBmYWxzZTsKLQl9CisJcHJzdGF0ZS0+c2V0X2FsbF92 aXNpYmxlID0gdHJ1ZTsKKwlwcnN0YXRlLT5uZXdlc3RfbGl2ZV94aWQgPSBJbnZhbGlkVHJhbnNh Y3Rpb25JZDsKIAogCS8qCi0JICogVGhlIHZpc2liaWxpdHkgY3V0b2ZmIHhpZCBpcyB0aGUgbmV3 ZXN0IHhtaW4gb2YgbGl2ZSB0dXBsZXMgb24gdGhlCi0JICogcGFnZS4gIEluIHRoZSBjb21tb24g Y2FzZSwgdGhpcyB3aWxsIGJlIHNldCBhcyB0aGUgY29uZmxpY3QgaG9yaXpvbiB0aGUKLQkgKiBj YWxsZXIgY2FuIHVzZSBmb3IgdXBkYXRpbmcgdGhlIFZNLiAgSWYsIGF0IHRoZSBlbmQgb2YgZnJl ZXppbmcgYW5kCi0JICogcHJ1bmluZywgdGhlIHBhZ2UgaXMgYWxsLWZyb3plbiwgdGhlcmUgaXMg bm8gcG9zc2liaWxpdHkgdGhhdCBhbnkKLQkgKiBydW5uaW5nIHRyYW5zYWN0aW9uIG9uIHRoZSBz dGFuZGJ5IGRvZXMgbm90IHNlZSB0dXBsZXMgb24gdGhlIHBhZ2UgYXMKLQkgKiBhbGwtdmlzaWJs ZSwgc28gdGhlIGNvbmZsaWN0IGhvcml6b24gcmVtYWlucyBJbnZhbGlkVHJhbnNhY3Rpb25JZC4K KwkgKiBDdXJyZW50bHksIG9ubHkgVkFDVVVNIHBlcmZvcm1zIGZyZWV6aW5nLCBidXQgb3RoZXIg Y2FsbGVycyBtYXkgaW4gdGhlCisJICogZnV0dXJlLiBXZSBtdXN0IGluaXRpYWxpemUgc2V0X2Fs bF9mcm96ZW4gYmFzZWQgb24gd2hldGhlciBvciBub3QgdGhlCisJICogY2FsbGVyIHBhc3NlZCBI RUFQX1BBR0VfUFJVTkVfRlJFRVpFLCBiZWNhdXNlIGlmIHRoZXkgZGlkIG5vdCwgd2Ugd29uJ3QK KwkgKiBjYWxsIGhlYXBfcHJlcGFyZV9mcmVlemVfdHVwbGUoKSBmb3IgZWFjaCB0dXBsZSwgYW5k IHNldF9hbGxfZnJvemVuCisJICogd2lsbCBuZXZlciBiZSBjbGVhcmVkIGZvciB0dXBsZXMgdGhh dCBuZWVkIGZyZWV6aW5nLgorCSAqCisJICogV2hlbiBmcmVlemluZyBpcyBub3QgcmVxdWlyZWQg KG5vIFhJRHMvTVhJRHMgb2xkZXIgdGhhbiB0aGUgZnJlZXplCisJICogY3V0b2ZmKSwgd2UgbWF5 IHN0aWxsIGNob29zZSB0byAib3Bwb3J0dW5pc3RpY2FsbHkiIGZyZWV6ZSBpZiBkb2luZyBzbwor CSAqIHdvdWxkIG1ha2UgdGhlIHBhZ2UgYWxsLWZyb3plbi4KKwkgKgorCSAqIFdlIHdpbGwgbm90 IGJlIGFibGUgdG8gZnJlZXplIHRoZSB3aG9sZSBwYWdlIGF0IHRoZSBlbmQgb2YgdmFjdXVtIGlm CisJICogdGhlcmUgYXJlIHR1cGxlcyBwcmVzZW50IHRoYXQgYXJlIG5vdCB2aXNpYmxlIHRvIGV2 ZXJ5b25lIG9yIGlmIHRoZXJlCisJICogYXJlIGRlYWQgdHVwbGVzIHdoaWNoIHdpbGwgbm90IGJl IHJlbW92YWJsZS4gSG93ZXZlciwgZGVhZCB0dXBsZXMgdGhhdAorCSAqIHdpbGwgYmUgcmVtb3Zl ZCBieSB0aGUgZW5kIG9mIHZhY3V1bSBzaG91bGQgbm90IHByZXZlbnQgdGhpcworCSAqIG9wcG9y dHVuaXN0aWMgZnJlZXppbmcuCisJICoKKwkgKiBUaGVyZWZvcmUsIHdlIGRvIG5vdCBjbGVhciBz ZXRfYWxsX3Zpc2libGUgYW5kIHNldF9hbGxfZnJvemVuIHdoZW4gd2UKKwkgKiBlbmNvdW50ZXIg TFBfREVBRCBpdGVtcy4gSW5zdGVhZCwgd2UgY29ycmVjdCB0aGVtIGFmdGVyIGRlY2lkaW5nCisJ ICogd2hldGhlciB0byBmcmVlemUsIGJ1dCBiZWZvcmUgdXBkYXRpbmcgdGhlIFZNLCB0byBhdm9p ZCBzZXR0aW5nIHRoZSBWTQorCSAqIGJpdHMgaW5jb3JyZWN0bHkuCiAJICovCi0JcHJzdGF0ZS0+ dmlzaWJpbGl0eV9jdXRvZmZfeGlkID0gSW52YWxpZFRyYW5zYWN0aW9uSWQ7CisJcHJzdGF0ZS0+ c2V0X2FsbF9mcm96ZW4gPSBwcnN0YXRlLT5hdHRlbXB0X2ZyZWV6ZTsKIH0KIAogLyoKQEAgLTc0 Nyw3ICs3MzAsNiBAQCBoZWFwX3BhZ2Vfd2lsbF9mcmVlemUoYm9vbCBkaWRfdHVwbGVfaGludF9m cGksCiAJaWYgKCFwcnN0YXRlLT5hdHRlbXB0X2ZyZWV6ZSkKIAl7CiAJCUFzc2VydCghcHJzdGF0 ZS0+c2V0X2FsbF9mcm96ZW4gJiYgcHJzdGF0ZS0+bmZyb3plbiA9PSAwKTsKLQkJQXNzZXJ0KHBy c3RhdGUtPmxwZGVhZF9pdGVtcyA9PSAwIHx8ICFwcnN0YXRlLT5zZXRfYWxsX3Zpc2libGUpOwog CQlyZXR1cm4gZmFsc2U7CiAJfQogCkBAIC0xMDIxLDkgKzEwMDMsOCBAQCBwcnVuZV9mcmVlemVf YnlwYXNzKFBydW5lU3RhdGUgKnByc3RhdGUsIFBydW5lRnJlZXplUmVzdWx0ICpwcmVzdWx0KQog ICogSEVBUF9QQUdFX1BSVU5FX0ZSRUVaRSBvcHRpb24gaXMgcGFzc2VkLCB3ZSBhbHNvIHNldAog ICogcHJlc3VsdC0+c2V0X2FsbF92aXNpYmxlIGFuZCBwcmVzdWx0LT5zZXRfYWxsX2Zyb3plbiBh ZnRlciBkZXRlcm1pbmluZwogICogd2hldGhlciBvciBub3QgdG8gb3Bwb3J0dW5pc3RpY2FsbHkg ZnJlZXplLCB0byBpbmRpY2F0ZSBpZiB0aGUgVk0gYml0cyBjYW4KLSAqIGJlIHNldC4gIFRoZXkg YXJlIGFsd2F5cyBzZXQgdG8gZmFsc2Ugd2hlbiB0aGUgSEVBUF9QQUdFX1BSVU5FX0ZSRUVaRQot ICogb3B0aW9uIGlzIG5vdCBwYXNzZWQsIGJlY2F1c2UgYXQgdGhlIG1vbWVudCBvbmx5IGNhbGxl cnMgdGhhdCBhbHNvIGZyZWV6ZQotICogbmVlZCB0aGF0IGluZm9ybWF0aW9uLgorICogYmUgc2V0 LiAnYWxsLWZyb3plbicgaXMgYWx3YXlzIHNldCB0byBmYWxzZSB3aGVuIHRoZSBIRUFQX1BBR0Vf UFJVTkVfRlJFRVpFCisgKiBvcHRpb24gaXMgbm90IHBhc3NlZC4KICAqCiAgKiBwcmVzdWx0IGNv bnRhaW5zIG91dHB1dCBwYXJhbWV0ZXJzIG5lZWRlZCBieSBjYWxsZXJzLCBzdWNoIGFzIHRoZSBu dW1iZXIgb2YKICAqIHR1cGxlcyByZW1vdmVkIGFuZCB0aGUgb2Zmc2V0cyBvZiBkZWFkIGl0ZW1z IG9uIHRoZSBwYWdlIGFmdGVyIHBydW5pbmcuCkBAIC0xMDk0LDkgKzEwNzUsOSBAQCBoZWFwX3Bh Z2VfcHJ1bmVfYW5kX2ZyZWV6ZShQcnVuZUZyZWV6ZVBhcmFtcyAqcGFyYW1zLAogCSAqIGJlIGFs bC12aXNpYmxlLgogCSAqLwogCWlmIChwcnN0YXRlLnNldF9hbGxfdmlzaWJsZSAmJgotCQlUcmFu c2FjdGlvbklkSXNOb3JtYWwocHJzdGF0ZS52aXNpYmlsaXR5X2N1dG9mZl94aWQpICYmCisJCVRy YW5zYWN0aW9uSWRJc05vcm1hbChwcnN0YXRlLm5ld2VzdF9saXZlX3hpZCkgJiYKIAkJR2xvYmFs VmlzVGVzdFhpZE1heWJlUnVubmluZyhwcnN0YXRlLnZpc3Rlc3QsCi0JCQkJCQkJCQkgcHJzdGF0 ZS52aXNpYmlsaXR5X2N1dG9mZl94aWQpKQorCQkJCQkJCQkJIHByc3RhdGUubmV3ZXN0X2xpdmVf eGlkKSkKIAkJcHJzdGF0ZS5zZXRfYWxsX3Zpc2libGUgPSBwcnN0YXRlLnNldF9hbGxfZnJvemVu ID0gZmFsc2U7CiAKIAkvKgpAQCAtMTI0Nyw3ICsxMjI4LDcgQEAgaGVhcF9wYWdlX3BydW5lX2Fu ZF9mcmVlemUoUHJ1bmVGcmVlemVQYXJhbXMgKnBhcmFtcywKIAlpZiAocHJlc3VsdC0+c2V0X2Fs bF9mcm96ZW4pCiAJCXByZXN1bHQtPnZtX2NvbmZsaWN0X2hvcml6b24gPSBJbnZhbGlkVHJhbnNh Y3Rpb25JZDsKIAllbHNlCi0JCXByZXN1bHQtPnZtX2NvbmZsaWN0X2hvcml6b24gPSBwcnN0YXRl LnZpc2liaWxpdHlfY3V0b2ZmX3hpZDsKKwkJcHJlc3VsdC0+dm1fY29uZmxpY3RfaG9yaXpvbiA9 IHByc3RhdGUubmV3ZXN0X2xpdmVfeGlkOwogCiAJcHJlc3VsdC0+bHBkZWFkX2l0ZW1zID0gcHJz dGF0ZS5scGRlYWRfaXRlbXM7CiAJLyogdGhlIHByZXN1bHQtPmRlYWRvZmZzZXRzIGFycmF5IHdh cyBhbHJlYWR5IGZpbGxlZCBpbiAqLwpAQCAtMTcwOCw2ICsxNjg5LDcgQEAgc3RhdGljIHZvaWQK IGhlYXBfcHJ1bmVfcmVjb3JkX3VuY2hhbmdlZF9scF9ub3JtYWwoUHJ1bmVTdGF0ZSAqcHJzdGF0 ZSwgT2Zmc2V0TnVtYmVyIG9mZm51bSkKIHsKIAlIZWFwVHVwbGVIZWFkZXIgaHR1cDsKKwlUcmFu c2FjdGlvbklkIHhtaW47CiAJUGFnZQkJcGFnZSA9IHByc3RhdGUtPnBhZ2U7CiAKIAlBc3NlcnQo IXByc3RhdGUtPnByb2Nlc3NlZFtvZmZudW1dKTsKQEAgLTE3NTUsMzIgKzE3MzcsMjcgQEAgaGVh cF9wcnVuZV9yZWNvcmRfdW5jaGFuZ2VkX2xwX25vcm1hbChQcnVuZVN0YXRlICpwcnN0YXRlLCBP ZmZzZXROdW1iZXIgb2ZmbnVtKQogCQkJICogU2VlIFNldEhpbnRCaXRzIGZvciBtb3JlIGluZm8u ICBDaGVjayB0aGF0IHRoZSB0dXBsZSBpcyBoaW50ZWQKIAkJCSAqIHhtaW4tY29tbWl0dGVkIGJl Y2F1c2Ugb2YgdGhhdC4KIAkJCSAqLwotCQkJaWYgKHByc3RhdGUtPnNldF9hbGxfdmlzaWJsZSkK KwkJCWlmICghSGVhcFR1cGxlSGVhZGVyWG1pbkNvbW1pdHRlZChodHVwKSkKIAkJCXsKLQkJCQlU cmFuc2FjdGlvbklkIHhtaW47CisJCQkJcHJzdGF0ZS0+c2V0X2FsbF92aXNpYmxlID0gZmFsc2U7 CisJCQkJcHJzdGF0ZS0+c2V0X2FsbF9mcm96ZW4gPSBmYWxzZTsKKwkJCQlicmVhazsKKwkJCX0K IAotCQkJCWlmICghSGVhcFR1cGxlSGVhZGVyWG1pbkNvbW1pdHRlZChodHVwKSkKLQkJCQl7Ci0J CQkJCXByc3RhdGUtPnNldF9hbGxfdmlzaWJsZSA9IGZhbHNlOwotCQkJCQlwcnN0YXRlLT5zZXRf YWxsX2Zyb3plbiA9IGZhbHNlOwotCQkJCQlicmVhazsKLQkJCQl9CisJCQkvKgorCQkJICogVGhl IGluc2VydGVyIGRlZmluaXRlbHkgY29tbWl0dGVkLiBCdXQgd2UgZG9uJ3Qga25vdyBpZiBpdCBp cworCQkJICogb2xkIGVub3VnaCB0aGF0IGV2ZXJ5b25lIHNlZXMgaXQgYXMgY29tbWl0dGVkLiBM YXRlciwgYWZ0ZXIKKwkJCSAqIHByb2Nlc3NpbmcgYWxsIHRoZSB0dXBsZXMgb24gdGhlIHBhZ2Us IHdlJ2xsIGNoZWNrIGlmIHRoZXJlIGlzCisJCQkgKiBhbnkgc25hcHNob3QgdGhhdCBzdGlsbCBj b25zaWRlcnMgdGhlIG5ld2VzdCB4aWQgb24gdGhlIHBhZ2UgdG8KKwkJCSAqIGJlIHJ1bm5pbmcu IElmIHNvLCB3ZSBkb24ndCBjb25zaWRlciB0aGUgcGFnZSBhbGwtdmlzaWJsZS4KKwkJCSAqLwor CQkJeG1pbiA9IEhlYXBUdXBsZUhlYWRlckdldFhtaW4oaHR1cCk7CiAKLQkJCQkvKgotCQkJCSAq IFRoZSBpbnNlcnRlciBkZWZpbml0ZWx5IGNvbW1pdHRlZC4gQnV0IHdlIGRvbid0IGtub3cgaWYg aXQKLQkJCQkgKiBpcyBvbGQgZW5vdWdoIHRoYXQgZXZlcnlvbmUgc2VlcyBpdCBhcyBjb21taXR0 ZWQuIExhdGVyLAotCQkJCSAqIGFmdGVyIHByb2Nlc3NpbmcgYWxsIHRoZSB0dXBsZXMgb24gdGhl IHBhZ2UsIHdlJ2xsIGNoZWNrIGlmCi0JCQkJICogdGhlcmUgaXMgYW55IHNuYXBzaG90IHRoYXQg c3RpbGwgY29uc2lkZXJzIHRoZSBuZXdlc3QgeGlkCi0JCQkJICogb24gdGhlIHBhZ2UgdG8gYmUg cnVubmluZy4gSWYgc28sIHdlIGRvbid0IGNvbnNpZGVyIHRoZQotCQkJCSAqIHBhZ2UgYWxsLXZp c2libGUuCi0JCQkJICovCi0JCQkJeG1pbiA9IEhlYXBUdXBsZUhlYWRlckdldFhtaW4oaHR1cCk7 CisJCQkvKiBUcmFjayBuZXdlc3QgeG1pbiBvbiBwYWdlLiAqLworCQkJaWYgKFRyYW5zYWN0aW9u SWRGb2xsb3dzKHhtaW4sIHByc3RhdGUtPm5ld2VzdF9saXZlX3hpZCkgJiYKKwkJCQlUcmFuc2Fj dGlvbklkSXNOb3JtYWwoeG1pbikpCisJCQkJcHJzdGF0ZS0+bmV3ZXN0X2xpdmVfeGlkID0geG1p bjsKIAotCQkJCS8qIFRyYWNrIG5ld2VzdCB4bWluIG9uIHBhZ2UuICovCi0JCQkJaWYgKFRyYW5z YWN0aW9uSWRGb2xsb3dzKHhtaW4sIHByc3RhdGUtPnZpc2liaWxpdHlfY3V0b2ZmX3hpZCkgJiYK LQkJCQkJVHJhbnNhY3Rpb25JZElzTm9ybWFsKHhtaW4pKQotCQkJCQlwcnN0YXRlLT52aXNpYmls aXR5X2N1dG9mZl94aWQgPSB4bWluOwotCQkJfQogCQkJYnJlYWs7CiAKIAkJY2FzZSBIRUFQVFVQ TEVfUkVDRU5UTFlfREVBRDoKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3Zh Y3V1bWxhenkuYyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYwppbmRleCAy YTk0YmEzYTM4Ny4uODU5OWRkN2ZjZmEgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9o ZWFwL3ZhY3V1bWxhenkuYworKysgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5 LmMKQEAgLTQ3MCw3ICs0NzAsNyBAQCBzdGF0aWMgdm9pZCBkZWFkX2l0ZW1zX2NsZWFudXAoTFZS ZWxTdGF0ZSAqdmFjcmVsKTsKIHN0YXRpYyBib29sIGhlYXBfcGFnZV9pc19hbGxfdmlzaWJsZShS ZWxhdGlvbiByZWwsIEJ1ZmZlciBidWYsCiAJCQkJCQkJCQkgR2xvYmFsVmlzU3RhdGUgKnZpc3Rl c3QsCiAJCQkJCQkJCQkgYm9vbCAqYWxsX2Zyb3plbiwKLQkJCQkJCQkJCSBUcmFuc2FjdGlvbklk ICp2aXNpYmlsaXR5X2N1dG9mZl94aWQsCisJCQkJCQkJCQkgVHJhbnNhY3Rpb25JZCAqbmV3ZXN0 X2xpdmVfeGlkLAogCQkJCQkJCQkJIE9mZnNldE51bWJlciAqbG9nZ2luZ19vZmZudW0pOwogI2Vu ZGlmCiBzdGF0aWMgYm9vbCBoZWFwX3BhZ2Vfd291bGRfYmVfYWxsX3Zpc2libGUoUmVsYXRpb24g cmVsLCBCdWZmZXIgYnVmLApAQCAtNDc4LDcgKzQ3OCw3IEBAIHN0YXRpYyBib29sIGhlYXBfcGFn ZV93b3VsZF9iZV9hbGxfdmlzaWJsZShSZWxhdGlvbiByZWwsIEJ1ZmZlciBidWYsCiAJCQkJCQkJ CQkJICAgT2Zmc2V0TnVtYmVyICpkZWFkb2Zmc2V0cywKIAkJCQkJCQkJCQkgICBpbnQgbmRlYWRv ZmZzZXRzLAogCQkJCQkJCQkJCSAgIGJvb2wgKmFsbF9mcm96ZW4sCi0JCQkJCQkJCQkJICAgVHJh bnNhY3Rpb25JZCAqdmlzaWJpbGl0eV9jdXRvZmZfeGlkLAorCQkJCQkJCQkJCSAgIFRyYW5zYWN0 aW9uSWQgKm5ld2VzdF9saXZlX3hpZCwKIAkJCQkJCQkJCQkgICBPZmZzZXROdW1iZXIgKmxvZ2dp bmdfb2ZmbnVtKTsKIHN0YXRpYyB2b2lkIHVwZGF0ZV9yZWxzdGF0c19hbGxfaW5kZXhlcyhMVlJl bFN0YXRlICp2YWNyZWwpOwogc3RhdGljIHZvaWQgdmFjdXVtX2Vycm9yX2NhbGxiYWNrKHZvaWQg KmFyZyk7CkBAIC0yODI4LDcgKzI4MjgsNyBAQCBsYXp5X3ZhY3V1bV9oZWFwX3BhZ2UoTFZSZWxT dGF0ZSAqdmFjcmVsLCBCbG9ja051bWJlciBibGtubywgQnVmZmVyIGJ1ZmZlciwKIAlQYWdlCQlw YWdlID0gQnVmZmVyR2V0UGFnZShidWZmZXIpOwogCU9mZnNldE51bWJlciB1bnVzZWRbTWF4SGVh cFR1cGxlc1BlclBhZ2VdOwogCWludAkJCW51bnVzZWQgPSAwOwotCVRyYW5zYWN0aW9uSWQgdmlz aWJpbGl0eV9jdXRvZmZfeGlkOworCVRyYW5zYWN0aW9uSWQgbmV3ZXN0X2xpdmVfeGlkOwogCVRy YW5zYWN0aW9uSWQgY29uZmxpY3RfeGlkID0gSW52YWxpZFRyYW5zYWN0aW9uSWQ7CiAJYm9vbAkJ YWxsX2Zyb3plbjsKIAlMVlNhdmVkRXJySW5mbyBzYXZlZF9lcnJfaW5mbzsKQEAgLTI4NTQsMTQg KzI4NTQsMTQgQEAgbGF6eV92YWN1dW1faGVhcF9wYWdlKExWUmVsU3RhdGUgKnZhY3JlbCwgQmxv Y2tOdW1iZXIgYmxrbm8sIEJ1ZmZlciBidWZmZXIsCiAJaWYgKGhlYXBfcGFnZV93b3VsZF9iZV9h bGxfdmlzaWJsZSh2YWNyZWwtPnJlbCwgYnVmZmVyLAogCQkJCQkJCQkJICAgdmFjcmVsLT52aXN0 ZXN0LAogCQkJCQkJCQkJICAgZGVhZG9mZnNldHMsIG51bV9vZmZzZXRzLAotCQkJCQkJCQkJICAg JmFsbF9mcm96ZW4sICZ2aXNpYmlsaXR5X2N1dG9mZl94aWQsCisJCQkJCQkJCQkgICAmYWxsX2Zy b3plbiwgJm5ld2VzdF9saXZlX3hpZCwKIAkJCQkJCQkJCSAgICZ2YWNyZWwtPm9mZm51bSkpCiAJ ewogCQl2bWZsYWdzIHw9IFZJU0lCSUxJVFlNQVBfQUxMX1ZJU0lCTEU7CiAJCWlmIChhbGxfZnJv emVuKQogCQl7CiAJCQl2bWZsYWdzIHw9IFZJU0lCSUxJVFlNQVBfQUxMX0ZST1pFTjsKLQkJCUFz c2VydCghVHJhbnNhY3Rpb25JZElzVmFsaWQodmlzaWJpbGl0eV9jdXRvZmZfeGlkKSk7CisJCQlB c3NlcnQoIVRyYW5zYWN0aW9uSWRJc1ZhbGlkKG5ld2VzdF9saXZlX3hpZCkpOwogCQl9CiAKIAkJ LyoKQEAgLTI5MDIsNyArMjkwMiw3IEBAIGxhenlfdmFjdXVtX2hlYXBfcGFnZShMVlJlbFN0YXRl ICp2YWNyZWwsIEJsb2NrTnVtYmVyIGJsa25vLCBCdWZmZXIgYnVmZmVyLAogCQl2aXNpYmlsaXR5 bWFwX3NldF92bWJpdHMoYmxrbm8sCiAJCQkJCQkJCSB2bWJ1ZmZlciwgdm1mbGFncywKIAkJCQkJ CQkJIHZhY3JlbC0+cmVsLT5yZF9sb2NhdG9yKTsKLQkJY29uZmxpY3RfeGlkID0gdmlzaWJpbGl0 eV9jdXRvZmZfeGlkOworCQljb25mbGljdF94aWQgPSBuZXdlc3RfbGl2ZV94aWQ7CiAJfQogCiAJ LyoKQEAgLTM2MTYsNyArMzYxNiw3IEBAIHN0YXRpYyBib29sCiBoZWFwX3BhZ2VfaXNfYWxsX3Zp c2libGUoUmVsYXRpb24gcmVsLCBCdWZmZXIgYnVmLAogCQkJCQkJIEdsb2JhbFZpc1N0YXRlICp2 aXN0ZXN0LAogCQkJCQkJIGJvb2wgKmFsbF9mcm96ZW4sCi0JCQkJCQkgVHJhbnNhY3Rpb25JZCAq dmlzaWJpbGl0eV9jdXRvZmZfeGlkLAorCQkJCQkJIFRyYW5zYWN0aW9uSWQgKm5ld2VzdF9saXZl X3hpZCwKIAkJCQkJCSBPZmZzZXROdW1iZXIgKmxvZ2dpbmdfb2ZmbnVtKQogewogCkBAIC0zNjI0 LDcgKzM2MjQsNyBAQCBoZWFwX3BhZ2VfaXNfYWxsX3Zpc2libGUoUmVsYXRpb24gcmVsLCBCdWZm ZXIgYnVmLAogCQkJCQkJCQkJCSAgdmlzdGVzdCwKIAkJCQkJCQkJCQkgIE5VTEwsIDAsCiAJCQkJ CQkJCQkJICBhbGxfZnJvemVuLAotCQkJCQkJCQkJCSAgdmlzaWJpbGl0eV9jdXRvZmZfeGlkLAor CQkJCQkJCQkJCSAgbmV3ZXN0X2xpdmVfeGlkLAogCQkJCQkJCQkJCSAgbG9nZ2luZ19vZmZudW0p OwogfQogI2VuZGlmCkBAIC0zNjQ3LDcgKzM2NDcsNyBAQCBoZWFwX3BhZ2VfaXNfYWxsX3Zpc2li bGUoUmVsYXRpb24gcmVsLCBCdWZmZXIgYnVmLAogICogT3V0cHV0IHBhcmFtZXRlcnM6CiAgKgog ICogIC0gKmFsbF9mcm96ZW46IHRydWUgaWYgZXZlcnkgdHVwbGUgb24gdGhlIHBhZ2UgaXMgZnJv emVuCi0gKiAgLSAqdmlzaWJpbGl0eV9jdXRvZmZfeGlkOiBuZXdlc3QgeG1pbjsgdmFsaWQgb25s eSBpZiBwYWdlIGlzIGFsbC12aXNpYmxlCisgKiAgLSAqbmV3ZXN0X2xpdmVfeGlkOiBuZXdlc3Qg eG1pbiBvZiBsaXZlIHR1cGxlcyBvbiB0aGUgcGFnZQogICogIC0gKmxvZ2dpbmdfb2ZmbnVtOiBP ZmZzZXROdW1iZXIgb2YgY3VycmVudCB0dXBsZSBiZWluZyBwcm9jZXNzZWQ7CiAgKiAgICAgdXNl ZCBieSB2YWN1dW0ncyBlcnJvciBjYWxsYmFjayBzeXN0ZW0uCiAgKgpAQCAtMzY2NSw3ICszNjY1 LDcgQEAgaGVhcF9wYWdlX3dvdWxkX2JlX2FsbF92aXNpYmxlKFJlbGF0aW9uIHJlbCwgQnVmZmVy IGJ1ZiwKIAkJCQkJCQkgICBPZmZzZXROdW1iZXIgKmRlYWRvZmZzZXRzLAogCQkJCQkJCSAgIGlu dCBuZGVhZG9mZnNldHMsCiAJCQkJCQkJICAgYm9vbCAqYWxsX2Zyb3plbiwKLQkJCQkJCQkgICBU cmFuc2FjdGlvbklkICp2aXNpYmlsaXR5X2N1dG9mZl94aWQsCisJCQkJCQkJICAgVHJhbnNhY3Rp b25JZCAqbmV3ZXN0X2xpdmVfeGlkLAogCQkJCQkJCSAgIE9mZnNldE51bWJlciAqbG9nZ2luZ19v ZmZudW0pCiB7CiAJUGFnZQkJcGFnZSA9IEJ1ZmZlckdldFBhZ2UoYnVmKTsKQEAgLTM2NzUsNyAr MzY3NSw3IEBAIGhlYXBfcGFnZV93b3VsZF9iZV9hbGxfdmlzaWJsZShSZWxhdGlvbiByZWwsIEJ1 ZmZlciBidWYsCiAJYm9vbAkJYWxsX3Zpc2libGUgPSB0cnVlOwogCWludAkJCW1hdGNoZWRfZGVh ZF9jb3VudCA9IDA7CiAKLQkqdmlzaWJpbGl0eV9jdXRvZmZfeGlkID0gSW52YWxpZFRyYW5zYWN0 aW9uSWQ7CisJKm5ld2VzdF9saXZlX3hpZCA9IEludmFsaWRUcmFuc2FjdGlvbklkOwogCSphbGxf ZnJvemVuID0gdHJ1ZTsKIAogCUFzc2VydChuZGVhZG9mZnNldHMgPT0gMCB8fCBkZWFkb2Zmc2V0 cyk7CkBAIC0zNzY0LDkgKzM3NjQsOSBAQCBoZWFwX3BhZ2Vfd291bGRfYmVfYWxsX3Zpc2libGUo UmVsYXRpb24gcmVsLCBCdWZmZXIgYnVmLAogCQkJCQl4bWluID0gSGVhcFR1cGxlSGVhZGVyR2V0 WG1pbih0dXBsZS50X2RhdGEpOwogCiAJCQkJCS8qIFRyYWNrIG5ld2VzdCB4bWluIG9uIHBhZ2Uu ICovCi0JCQkJCWlmIChUcmFuc2FjdGlvbklkRm9sbG93cyh4bWluLCAqdmlzaWJpbGl0eV9jdXRv ZmZfeGlkKSAmJgorCQkJCQlpZiAoVHJhbnNhY3Rpb25JZEZvbGxvd3MoeG1pbiwgKm5ld2VzdF9s aXZlX3hpZCkgJiYKIAkJCQkJCVRyYW5zYWN0aW9uSWRJc05vcm1hbCh4bWluKSkKLQkJCQkJCSp2 aXNpYmlsaXR5X2N1dG9mZl94aWQgPSB4bWluOworCQkJCQkJKm5ld2VzdF9saXZlX3hpZCA9IHht aW47CiAKIAkJCQkJLyogQ2hlY2sgd2hldGhlciB0aGlzIHR1cGxlIGlzIGFscmVhZHkgZnJvemVu IG9yIG5vdCAqLwogCQkJCQlpZiAoYWxsX3Zpc2libGUgJiYgKmFsbF9mcm96ZW4gJiYKQEAgLTM3 OTYsOCArMzc5Niw4IEBAIGhlYXBfcGFnZV93b3VsZF9iZV9hbGxfdmlzaWJsZShSZWxhdGlvbiBy ZWwsIEJ1ZmZlciBidWYsCiAJICogY2Fubm90IGJlIGFsbC12aXNpYmxlLgogCSAqLwogCWlmIChh bGxfdmlzaWJsZSAmJgotCQlUcmFuc2FjdGlvbklkSXNOb3JtYWwoKnZpc2liaWxpdHlfY3V0b2Zm X3hpZCkgJiYKLQkJR2xvYmFsVmlzVGVzdFhpZE1heWJlUnVubmluZyh2aXN0ZXN0LCAqdmlzaWJp bGl0eV9jdXRvZmZfeGlkKSkKKwkJVHJhbnNhY3Rpb25JZElzTm9ybWFsKCpuZXdlc3RfbGl2ZV94 aWQpICYmCisJCUdsb2JhbFZpc1Rlc3RYaWRNYXliZVJ1bm5pbmcodmlzdGVzdCwgKm5ld2VzdF9s aXZlX3hpZCkpCiAJewogCQlhbGxfdmlzaWJsZSA9IGZhbHNlOwogCQkqYWxsX2Zyb3plbiA9IGZh bHNlOwotLSAKMi40My4wCgo= --00000000000060fd69064d6b968a Content-Type: text/x-patch; charset="US-ASCII"; name="v41-0005-WAL-log-VM-setting-during-vacuum-phase-I-in-XLOG.patch" Content-Disposition: attachment; filename="v41-0005-WAL-log-VM-setting-during-vacuum-phase-I-in-XLOG.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmyagd5h4 RnJvbSBiNjk3NTk5MWIzOTFiOTc5YmJmZmFjOWNjMGJkODg5NmJhMTgxYmE4IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBUdWUsIDIgRGVjIDIwMjUgMTU6MDc6NDIgLTA1MDAKU3ViamVjdDogW1BB VENIIHY0MSAwNS8xMl0gV0FMIGxvZyBWTSBzZXR0aW5nIGR1cmluZyB2YWN1dW0gcGhhc2UgSSBp bgogWExPR19IRUFQMl9QUlVORV9WQUNVVU1fU0NBTgoKVmFjdXVtIG5vIGxvbmdlciBlbWl0cyBh IHNlcGFyYXRlIFdBTCByZWNvcmQgZm9yIGVhY2ggcGFnZSBzZXQKYWxsLXZpc2libGUgb3IgYWxs LWZyb3plbiBkdXJpbmcgcGhhc2UgSS4gSW5zdGVhZCwgdmlzaWJpbGl0eSBtYXAKdXBkYXRlcyBh cmUgbm93IGluY2x1ZGVkIGluIHRoZSBYTE9HX0hFQVAyX1BSVU5FX1ZBQ1VVTV9TQ0FOIHJlY29y ZCB0aGF0CmlzIGFscmVhZHkgZW1pdHRlZCBmb3IgcHJ1bmluZyBhbmQgZnJlZXppbmcuCgpQcmV2 aW91c2x5LCBoZWFwX3BhZ2VfcHJ1bmVfYW5kX2ZyZWV6ZSgpIGRldGVybWluZWQgd2hldGhlciBh IHBhZ2Ugd2FzCmFsbC12aXNpYmxlLCBidXQgdGhlIGNvcnJlc3BvbmRpbmcgVk0gYml0cyB3ZXJl IG9ubHkgc2V0IGxhdGVyIGluCmxhenlfc2Nhbl9wcnVuZSgpLiBOb3cgdGhlIFZNIGlzIHVwZGF0 ZWQgaW1tZWRpYXRlbHkgaW4KaGVhcF9wYWdlX3BydW5lX2FuZF9mcmVlemUoKSwgYXQgdGhlIHNh bWUgdGltZSBhcyB0aGUgaGVhcAptb2RpZmljYXRpb25zLgoKRm9yIG5vdywgdGhpcyBjaGFuZ2Ug YXBwbGllcyBvbmx5IHRvIHZhY3V1bSBwaGFzZSBJLCBub3QgdG8gcHJ1bmluZwpwZXJmb3JtZWQg ZHVyaW5nIG5vcm1hbCBwYWdlIGFjY2Vzcy4KCkF1dGhvcjogTWVsYW5pZSBQbGFnZW1hbiA8bWVs YW5pZXBsYWdlbWFuQGdtYWlsLmNvbT4KUmV2aWV3ZWQtYnk6IEFuZHJlcyBGcmV1bmQgPGFuZHJl c0BhbmFyYXplbC5kZT4KUmV2aWV3ZWQtYnk6IFJvYmVydCBIYWFzIDxyb2JlcnRtaGFhc0BnbWFp bC5jb20+ClJldmlld2VkLWJ5OiBLaXJpbGwgUmVzaGtlIDxyZXNoa2VraXJpbGxAZ21haWwuY29t PgpSZXZpZXdlZC1ieTogQ2hhbyBMaSA8bGkuZXZhbi5jaGFvQGdtYWlsLmNvbT4KRGlzY3Vzc2lv bjogaHR0cHM6Ly9wb3N0Z3IuZXMvbS9mbGF0L0NBQUtSdV9aTXc2TnBkX3FtMktNJTJCRndRM2NN T014MURoM1ZNaHA4LVY3U09MeGRLOS1nJTQwbWFpbC5nbWFpbC5jb20KLS0tCiBzcmMvYmFja2Vu ZC9hY2Nlc3MvaGVhcC9wcnVuZWhlYXAuYyAgfCAyNDQgKysrKysrKysrKysrKysrKysrKy0tLS0t LS0tCiBzcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMgfCAxMTMgKystLS0tLS0t LS0tLQogc3JjL2luY2x1ZGUvYWNjZXNzL2hlYXBhbS5oICAgICAgICAgIHwgIDM3ICsrLS0KIDMg ZmlsZXMgY2hhbmdlZCwgMjA0IGluc2VydGlvbnMoKyksIDE5MCBkZWxldGlvbnMoLSkKCmRpZmYg LS1naXQgYS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9wcnVuZWhlYXAuYyBiL3NyYy9iYWNrZW5k L2FjY2Vzcy9oZWFwL3BydW5laGVhcC5jCmluZGV4IDk0NTFlOTQxN2Y3Li5kZDhhYzE3M2NhMSAx MDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvcHJ1bmVoZWFwLmMKKysrIGIvc3Jj L2JhY2tlbmQvYWNjZXNzL2hlYXAvcHJ1bmVoZWFwLmMKQEAgLTcyLDYgKzcyLDIxIEBAIHR5cGVk ZWYgc3RydWN0CiAJT2Zmc2V0TnVtYmVyIG5vd3VudXNlZFtNYXhIZWFwVHVwbGVzUGVyUGFnZV07 CiAJSGVhcFR1cGxlRnJlZXplIGZyb3plbltNYXhIZWFwVHVwbGVzUGVyUGFnZV07CiAKKwkvKgor CSAqIHNldF9hbGxfdmlzaWJsZSBhbmQgc2V0X2FsbF9mcm96ZW4gaW5kaWNhdGUgaWYgdGhlIGFs bC12aXNpYmxlIGFuZAorCSAqIGFsbC1mcm96ZW4gYml0cyBpbiB0aGUgdmlzaWJpbGl0eSBtYXAg Y2FuIGJlIHNldCBmb3IgdGhpcyBwYWdlIGFmdGVyCisJICogcHJ1bmluZy4KKwkgKgorCSAqIE5P VEU6IHNldF9hbGxfdmlzaWJsZSBhbmQgc2V0X2FsbF9mcm96ZW4gaW5pdGlhbGx5IGRvbid0IGlu Y2x1ZGUKKwkgKiBMUF9ERUFEIGl0ZW1zLiBUaGF0J3MgY29udmVuaWVudCBmb3IgaGVhcF9wYWdl X3BydW5lX2FuZF9mcmVlemUoKSB0bworCSAqIHVzZSB0aGVtIHRvIGRlY2lkZSB3aGV0aGVyIHRv IG9wcG9ydHVuaXN0aWNhbGx5IGZyZWV6ZSB0aGUgcGFnZSBvciBub3QuCisJICogVGhlIHNldF9h bGxfdmlzaWJsZSBhbmQgc2V0X2FsbF9mcm96ZW4gdmFsdWVzIHVsdGltYXRlbHkgdXNlZCB0byBz ZXQKKwkgKiB0aGUgVk0gYXJlIGFkanVzdGVkIHRvIGluY2x1ZGUgTFBfREVBRCBpdGVtcyBhZnRl ciB3ZSBkZXRlcm1pbmUgd2hldGhlcgorCSAqIG9yIG5vdCB0byBvcHBvcnR1bmlzdGljYWxseSBm cmVlemUuCisJICovCisJYm9vbAkJc2V0X2FsbF92aXNpYmxlOworCWJvb2wJCXNldF9hbGxfZnJv emVuOworCiAJLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tCiAJICogV29ya2luZyBzdGF0ZSBmb3IgSE9UIGNoYWluIHByb2Nlc3NpbmcKIAkg Ki0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0K QEAgLTEyMiwxMiArMTM3LDE2IEBAIHR5cGVkZWYgc3RydWN0CiAJLyoKIAkgKiBDYWxsZXIgbXVz dCBwcm92aWRlIGEgcGlubmVkIHZtYnVmZmVyIGNvcnJlc3BvbmRpbmcgdG8gdGhlIGhlYXAgYmxv Y2sKIAkgKiBwYXNzZWQgdG8gaGVhcF9wYWdlX3BydW5lX2FuZF9mcmVlemUoKS4gV2Ugd2lsbCBm aXggYW55IGNvcnJ1cHRpb24KLQkgKiBmb3VuZCBpbiB0aGUgVk0uCisJICogZm91bmQgaW4gdGhl IFZNIGFuZCBzZXQgdGhlIFZNIGlmIHRoZSBwYWdlIGlzIGFsbC12aXNpYmxlL2FsbC1mcm96ZW4u CiAJICovCiAJQnVmZmVyCQl2bWJ1ZmZlcjsKIAotCS8qIEJpdHMgaW4gdGhlIHZtYnVmZmVyIGZv ciB0aGlzIGhlYXAgcGFnZSAqLworCS8qCisJICogVGhlIHN0YXRlIG9mIHRoZSBWTSBiaXRzIGF0 IHRoZSBiZWdpbm5pbmcgb2YgcHJ1bmluZyBhbmQgdGhlIHN0YXRlIHRoZXkKKwkgKiB3aWxsIGJl IGluIGF0IHRoZSBlbmQuCisJICovCiAJdWludDgJCW9sZF92bWJpdHM7CisJdWludDgJCW5ld192 bWJpdHM7CiAKIAkvKiBUaGUgbmV3ZXN0IHhtaW4gb2YgbGl2ZSB0dXBsZXMgb24gdGhlIHBhZ2Ug Ki8KIAlUcmFuc2FjdGlvbklkIG5ld2VzdF9saXZlX3hpZDsKQEAgLTE2MywyMSArMTgyLDYgQEAg dHlwZWRlZiBzdHJ1Y3QKIAkgKi8KIAlpbnQJCQlscGRlYWRfaXRlbXM7CS8qIG51bWJlciBvZiBp dGVtcyBpbiB0aGUgYXJyYXkgKi8KIAlPZmZzZXROdW1iZXIgKmRlYWRvZmZzZXRzOwkvKiBwb2lu dHMgZGlyZWN0bHkgdG8gcHJlc3VsdC0+ZGVhZG9mZnNldHMgKi8KLQotCS8qCi0JICogc2V0X2Fs bF92aXNpYmxlIGFuZCBzZXRfYWxsX2Zyb3plbiBpbmRpY2F0ZSBpZiB0aGUgYWxsLXZpc2libGUg YW5kCi0JICogYWxsLWZyb3plbiBiaXRzIGluIHRoZSB2aXNpYmlsaXR5IG1hcCBjYW4gYmUgc2V0 IGZvciB0aGlzIHBhZ2UgYWZ0ZXIKLQkgKiBwcnVuaW5nLgotCSAqCi0JICogTk9URTogc2V0X2Fs bF92aXNpYmxlIGFuZCBzZXRfYWxsX2Zyb3plbiBpbml0aWFsbHkgZG9uJ3QgaW5jbHVkZQotCSAq IExQX0RFQUQgaXRlbXMuIFRoYXQncyBjb252ZW5pZW50IGZvciBoZWFwX3BhZ2VfcHJ1bmVfYW5k X2ZyZWV6ZSgpIHRvCi0JICogdXNlIHRoZW0gdG8gZGVjaWRlIHdoZXRoZXIgdG8gZnJlZXplIHRo ZSBwYWdlIG9yIG5vdC4gIFRoZQotCSAqIHNldF9hbGxfdmlzaWJsZSBhbmQgc2V0X2FsbF9mcm96 ZW4gdmFsdWVzIHJldHVybmVkIHRvIHRoZSBjYWxsZXIgYXJlCi0JICogYWRqdXN0ZWQgdG8gaW5j bHVkZSBMUF9ERUFEIGl0ZW1zIGFmdGVyIHdlIGRldGVybWluZSB3aGV0aGVyIHRvCi0JICogb3Bw b3J0dW5pc3RpY2FsbHkgZnJlZXplLgotCSAqLwotCWJvb2wJCXNldF9hbGxfdmlzaWJsZTsKLQli b29sCQlzZXRfYWxsX2Zyb3plbjsKIH0gUHJ1bmVTdGF0ZTsKIAogCkBAIC0yMzIsNiArMjM2LDcg QEAgc3RhdGljIHZvaWQgcGFnZV92ZXJpZnlfcmVkaXJlY3RzKFBhZ2UgcGFnZSk7CiAKIHN0YXRp YyBib29sIGhlYXBfcGFnZV93aWxsX2ZyZWV6ZShib29sIGRpZF90dXBsZV9oaW50X2ZwaSwgYm9v bCBkb19wcnVuZSwgYm9vbCBkb19oaW50X3BydW5lLAogCQkJCQkJCQkgIFBydW5lU3RhdGUgKnBy c3RhdGUpOworc3RhdGljIGJvb2wgaGVhcF9wYWdlX3dpbGxfc2V0X3ZtKFBydW5lU3RhdGUgKnBy c3RhdGUsIFBydW5lUmVhc29uIHJlYXNvbik7CiAKIAogLyoKQEAgLTM5OCw2ICs0MDMsNyBAQCBw cnVuZV9mcmVlemVfc2V0dXAoUHJ1bmVGcmVlemVQYXJhbXMgKnBhcmFtcywKIAogCUFzc2VydChC dWZmZXJJc1ZhbGlkKHBhcmFtcy0+dm1idWZmZXIpKTsKIAlwcnN0YXRlLT52bWJ1ZmZlciA9IHBh cmFtcy0+dm1idWZmZXI7CisJcHJzdGF0ZS0+bmV3X3ZtYml0cyA9IDA7CiAJcHJzdGF0ZS0+b2xk X3ZtYml0cyA9IHZpc2liaWxpdHltYXBfZ2V0X3N0YXR1cyhwcnN0YXRlLT5yZWxhdGlvbiwKIAkJ CQkJCQkJCQkJCSAgIHByc3RhdGUtPmJsb2NrLAogCQkJCQkJCQkJCQkJICAgJnByc3RhdGUtPnZt YnVmZmVyKTsKQEAgLTkxNSw2ICs5MjEsNDIgQEAgaGVhcF9wYWdlX2ZpeF92bV9jb3JydXB0aW9u KFBydW5lU3RhdGUgKnByc3RhdGUsIE9mZnNldE51bWJlciBvZmZudW0sCiAJcHJzdGF0ZS0+b2xk X3ZtYml0cyA9IDA7CiB9CiAKKy8qCisgKiBEZWNpZGUgd2hldGhlciB0byBzZXQgdGhlIHZpc2li aWxpdHkgbWFwIGJpdHMgKGFsbC12aXNpYmxlIGFuZCBhbGwtZnJvemVuKQorICogZm9yIGhlYXBf YmxrIHVzaW5nIGluZm9ybWF0aW9uIGZyb20gdGhlIFBydW5lU3RhdGUgYW5kIFZNLgorICoKKyAq IFRoaXMgZnVuY3Rpb24gZG9lcyBub3QgYWN0dWFsbHkgc2V0IHRoZSBWTSBiaXRzIG9yIHBhZ2Ut bGV2ZWwgdmlzaWJpbGl0eQorICogaGludCwgUERfQUxMX1ZJU0lCTEUuCisgKgorICogUmV0dXJu cyB0cnVlIGlmIG9uZSBvciBib3RoIFZNIGJpdHMgc2hvdWxkIGJlIHNldCBhbmQgZmFsc2Ugb3Ro ZXJ3aXNlLgorICovCitzdGF0aWMgYm9vbAoraGVhcF9wYWdlX3dpbGxfc2V0X3ZtKFBydW5lU3Rh dGUgKnByc3RhdGUsIFBydW5lUmVhc29uIHJlYXNvbikKK3sKKwkvKgorCSAqIFRob3VnaCBvbi1h Y2Nlc3MgcHJ1bmluZyBtYWludGFpbnMgcHJzdGF0ZS0+c2V0X2FsbF92aXNpYmxlLCB3ZSBkb24n dAorCSAqIHNldCB0aGUgVk0gZm9yIG5vdy4KKwkgKi8KKwlpZiAocmVhc29uID09IFBSVU5FX09O X0FDQ0VTUykKKwkJcmV0dXJuIGZhbHNlOworCisJaWYgKCFwcnN0YXRlLT5zZXRfYWxsX3Zpc2li bGUpCisJCXJldHVybiBmYWxzZTsKKworCXByc3RhdGUtPm5ld192bWJpdHMgPSBWSVNJQklMSVRZ TUFQX0FMTF9WSVNJQkxFOworCisJaWYgKHByc3RhdGUtPnNldF9hbGxfZnJvemVuKQorCQlwcnN0 YXRlLT5uZXdfdm1iaXRzIHw9IFZJU0lCSUxJVFlNQVBfQUxMX0ZST1pFTjsKKworCWlmIChwcnN0 YXRlLT5uZXdfdm1iaXRzID09IHByc3RhdGUtPm9sZF92bWJpdHMpCisJeworCQlwcnN0YXRlLT5u ZXdfdm1iaXRzID0gMDsKKwkJcmV0dXJuIGZhbHNlOworCX0KKworCXJldHVybiB0cnVlOworfQor CiAvKgogICogSWYgdGhlIHBhZ2UgaXMgYWxyZWFkeSBhbGwtZnJvemVuLCBvciBhbHJlYWR5IGFs bC12aXNpYmxlIGFuZCBmcmVlemluZwogICogaXMgbm90IGJlaW5nIGF0dGVtcHRlZCwgdGhlcmUg aXMgbm8gcmVtYWluaW5nIHdvcmsgYW5kIHdlIGNhbiBieXBhc3MgdGhlCkBAIC05NDgsOCArOTkw LDYgQEAgcHJ1bmVfZnJlZXplX2J5cGFzcyhQcnVuZVN0YXRlICpwcnN0YXRlLCBQcnVuZUZyZWV6 ZVJlc3VsdCAqcHJlc3VsdCkKIAkvKiBXZSdsbCBmaWxsIGluIHByZXN1bHQgZm9yIHRoZSBjYWxs ZXIgKi8KIAltZW1zZXQocHJlc3VsdCwgMCwgc2l6ZW9mKFBydW5lRnJlZXplUmVzdWx0KSk7CiAK LQlwcmVzdWx0LT5vbGRfdm1iaXRzID0gcHJzdGF0ZS0+b2xkX3ZtYml0czsKLQogCS8qIENsZWFy IGFueSBzdGFsZSBwcnVuZSBoaW50ICovCiAJaWYgKFRyYW5zYWN0aW9uSWRJc1ZhbGlkKFBhZ2VH ZXRQcnVuZVhpZChwYWdlKSkpCiAJewpAQCAtOTg0LDcgKzEwMjQsOCBAQCBwcnVuZV9mcmVlemVf YnlwYXNzKFBydW5lU3RhdGUgKnByc3RhdGUsIFBydW5lRnJlZXplUmVzdWx0ICpwcmVzdWx0KQog CiAvKgogICogUHJ1bmUgYW5kIHJlcGFpciBmcmFnbWVudGF0aW9uIGFuZCBwb3RlbnRpYWxseSBm cmVlemUgdHVwbGVzIG9uIHRoZQotICogc3BlY2lmaWVkIHBhZ2UuCisgKiBzcGVjaWZpZWQgcGFn ZS4gSWYgdGhlIHBhZ2UncyB2aXNpYmlsaXR5IHN0YXR1cyBoYXMgY2hhbmdlZCwgdXBkYXRlIGl0 IGluCisgKiB0aGUgVk0uCiAgKgogICogQ2FsbGVyIG11c3QgaGF2ZSBwaW4gYW5kIGJ1ZmZlciBj bGVhbnVwIGxvY2sgb24gdGhlIHBhZ2UuICBOb3RlIHRoYXQgd2UKICAqIGRvbid0IHVwZGF0ZSB0 aGUgRlNNIGluZm9ybWF0aW9uIGZvciBwYWdlIG9uIGNhbGxlcidzIGJlaGFsZi4gIENhbGxlciBt aWdodApAQCAtOTk5LDEyICsxMDQwLDEwIEBAIHBydW5lX2ZyZWV6ZV9ieXBhc3MoUHJ1bmVTdGF0 ZSAqcHJzdGF0ZSwgUHJ1bmVGcmVlemVSZXN1bHQgKnByZXN1bHQpCiAgKiB0dXBsZXMgaWYgaXQn cyByZXF1aXJlZCBpbiBvcmRlciB0byBhZHZhbmNlIHJlbGZyb3plbnhpZCAvIHJlbG1pbm14aWQs IG9yCiAgKiBpZiBpdCdzIGNvbnNpZGVyZWQgYWR2YW50YWdlb3VzIGZvciBvdmVyYWxsIHN5c3Rl bSBwZXJmb3JtYW5jZSB0byBkbyBzbwogICogbm93LiAgVGhlICdwYXJhbXMuY3V0b2ZmcycsICdw cmVzdWx0JywgJ25ld19yZWxmcm96ZW5feGlkJyBhbmQKLSAqICduZXdfcmVsbWluX214aWQnIGFy Z3VtZW50cyBhcmUgcmVxdWlyZWQgd2hlbiBmcmVlemluZy4gIFdoZW4KLSAqIEhFQVBfUEFHRV9Q UlVORV9GUkVFWkUgb3B0aW9uIGlzIHBhc3NlZCwgd2UgYWxzbyBzZXQKLSAqIHByZXN1bHQtPnNl dF9hbGxfdmlzaWJsZSBhbmQgcHJlc3VsdC0+c2V0X2FsbF9mcm96ZW4gYWZ0ZXIgZGV0ZXJtaW5p bmcKLSAqIHdoZXRoZXIgb3Igbm90IHRvIG9wcG9ydHVuaXN0aWNhbGx5IGZyZWV6ZSwgdG8gaW5k aWNhdGUgaWYgdGhlIFZNIGJpdHMgY2FuCi0gKiBiZSBzZXQuICdhbGwtZnJvemVuJyBpcyBhbHdh eXMgc2V0IHRvIGZhbHNlIHdoZW4gdGhlIEhFQVBfUEFHRV9QUlVORV9GUkVFWkUKLSAqIG9wdGlv biBpcyBub3QgcGFzc2VkLgorICogJ25ld19yZWxtaW5fbXhpZCcgYXJndW1lbnRzIGFyZSByZXF1 aXJlZCB3aGVuIGZyZWV6aW5nLgorICoKKyAqIEEgdm1idWZmZXIgY29ycmVzcG9uZGluZyB0byB0 aGUgaGVhcCBwYWdlIGlzIGFsc28gcGFzc2VkIGFuZCBpZiB0aGUgcGFnZSBpcworICogZm91bmQg dG8gYmUgYWxsLXZpc2libGUvYWxsLWZyb3plbiwgd2Ugd2lsbCBzZXQgaXQgaW4gdGhlIFZNLgog ICoKICAqIHByZXN1bHQgY29udGFpbnMgb3V0cHV0IHBhcmFtZXRlcnMgbmVlZGVkIGJ5IGNhbGxl cnMsIHN1Y2ggYXMgdGhlIG51bWJlciBvZgogICogdHVwbGVzIHJlbW92ZWQgYW5kIHRoZSBvZmZz ZXRzIG9mIGRlYWQgaXRlbXMgb24gdGhlIHBhZ2UgYWZ0ZXIgcHJ1bmluZy4KQEAgLTEwMzIsOCAr MTA3MSwxMCBAQCBoZWFwX3BhZ2VfcHJ1bmVfYW5kX2ZyZWV6ZShQcnVuZUZyZWV6ZVBhcmFtcyAq cGFyYW1zLAogCWJvb2wJCWRvX2ZyZWV6ZTsKIAlib29sCQlkb19wcnVuZTsKIAlib29sCQlkb19o aW50X3BydW5lOworCWJvb2wJCWRvX3NldF92bTsKIAlib29sCQlkaWRfdHVwbGVfaGludF9mcGk7 CiAJaW50NjQJCWZwaV9iZWZvcmUgPSBwZ1dhbFVzYWdlLndhbF9mcGk7CisJVHJhbnNhY3Rpb25J ZCBjb25mbGljdF94aWQ7CiAKIAkvKiBJbml0aWFsaXplIHByc3RhdGUgKi8KIAlwcnVuZV9mcmVl emVfc2V0dXAocGFyYW1zLApAQCAtMTEyNSw2ICsxMTY2LDMxIEBAIGhlYXBfcGFnZV9wcnVuZV9h bmRfZnJlZXplKFBydW5lRnJlZXplUGFyYW1zICpwYXJhbXMsCiAJCXByc3RhdGUuc2V0X2FsbF92 aXNpYmxlID0gcHJzdGF0ZS5zZXRfYWxsX2Zyb3plbiA9IGZhbHNlOwogCiAJQXNzZXJ0KCFwcnN0 YXRlLnNldF9hbGxfZnJvemVuIHx8IHByc3RhdGUuc2V0X2FsbF92aXNpYmxlKTsKKwlBc3NlcnQo IXByc3RhdGUuc2V0X2FsbF92aXNpYmxlIHx8IChwcnN0YXRlLmxwZGVhZF9pdGVtcyA9PSAwKSk7 CisKKwlkb19zZXRfdm0gPSBoZWFwX3BhZ2Vfd2lsbF9zZXRfdm0oJnByc3RhdGUsIHBhcmFtcy0+ cmVhc29uKTsKKworCS8qCisJICogbmV3X3ZtYml0cyBzaG91bGQgYmUgMCByZWdhcmRsZXNzIG9m IHdoZXRoZXIgb3Igbm90IHRoZSBwYWdlIGlzCisJICogYWxsLXZpc2libGUgaWYgd2UgZG8gbm90 IGludGVuZCB0byBzZXQgdGhlIFZNLgorCSAqLworCUFzc2VydChkb19zZXRfdm0gfHwgcHJzdGF0 ZS5uZXdfdm1iaXRzID09IDApOworCisJLyoKKwkgKiBUaGUgc25hcHNob3QgY29uZmxpY3QgaG9y aXpvbiBmb3IgdGhlIHdob2xlIHJlY29yZCBpcyB0aGUgbW9zdAorCSAqIGNvbnNlcnZhdGl2ZSAo bmV3ZXN0KSBob3Jpem9uIHJlcXVpcmVkIGJ5IGFueSBjaGFuZ2UgaW4gdGhlIHJlY29yZC4KKwkg Ki8KKwljb25mbGljdF94aWQgPSBJbnZhbGlkVHJhbnNhY3Rpb25JZDsKKwlpZiAoZG9fc2V0X3Zt KQorCQljb25mbGljdF94aWQgPSBwcnN0YXRlLm5ld2VzdF9saXZlX3hpZDsKKwlpZiAoZG9fZnJl ZXplICYmIFRyYW5zYWN0aW9uSWRGb2xsb3dzKHByc3RhdGUucGFnZWZyei5GcmVlemVQYWdlQ29u ZmxpY3RYaWQsIGNvbmZsaWN0X3hpZCkpCisJCWNvbmZsaWN0X3hpZCA9IHByc3RhdGUucGFnZWZy ei5GcmVlemVQYWdlQ29uZmxpY3RYaWQ7CisJaWYgKGRvX3BydW5lICYmIFRyYW5zYWN0aW9uSWRG b2xsb3dzKHByc3RhdGUubGF0ZXN0X3hpZF9yZW1vdmVkLCBjb25mbGljdF94aWQpKQorCQljb25m bGljdF94aWQgPSBwcnN0YXRlLmxhdGVzdF94aWRfcmVtb3ZlZDsKKworCS8qIExvY2sgdm1idWZm ZXIgYmVmb3JlIGVudGVyaW5nIGEgY3JpdGljYWwgc2VjdGlvbiAqLworCWlmIChkb19zZXRfdm0p CisJCUxvY2tCdWZmZXIocHJzdGF0ZS52bWJ1ZmZlciwgQlVGRkVSX0xPQ0tfRVhDTFVTSVZFKTsK IAogCS8qIEFueSBlcnJvciB3aGlsZSBhcHBseWluZyB0aGUgY2hhbmdlcyBpcyBjcml0aWNhbCAq LwogCVNUQVJUX0NSSVRfU0VDVElPTigpOwpAQCAtMTE0NiwxNCArMTIxMiwxNyBAQCBoZWFwX3Bh Z2VfcHJ1bmVfYW5kX2ZyZWV6ZShQcnVuZUZyZWV6ZVBhcmFtcyAqcGFyYW1zLAogCiAJCS8qCiAJ CSAqIElmIHRoYXQncyBhbGwgd2UgaGFkIHRvIGRvIHRvIHRoZSBwYWdlLCB0aGlzIGlzIGEgbm9u LVdBTC1sb2dnZWQKLQkJICogaGludC4gIElmIHdlIGFyZSBnb2luZyB0byBmcmVlemUgb3IgcHJ1 bmUgdGhlIHBhZ2UsIHdlIHdpbGwgbWFyawotCQkgKiB0aGUgYnVmZmVyIGRpcnR5IGJlbG93Lgor CQkgKiBoaW50LiAgSWYgd2UgYXJlIGdvaW5nIHRvIGZyZWV6ZSBvciBwcnVuZSB0aGUgcGFnZSBv ciBzZXQKKwkJICogUERfQUxMX1ZJU0lCTEUsIHdlIHdpbGwgbWFyayB0aGUgYnVmZmVyIGRpcnR5 IGJlbG93LgorCQkgKgorCQkgKiBTZXR0aW5nIFBEX0FMTF9WSVNJQkxFIGlzIGZ1bGx5IFdBTC1s b2dnZWQgYmVjYXVzZSBpdCBpcyBmb3JiaWRkZW4KKwkJICogZm9yIHRoZSBWTSB0byBiZSBzZXQg YW5kIFBEX0FMTF9WSVNJQkxFIHRvIGJlIGNsZWFyLgogCQkgKi8KLQkJaWYgKCFkb19mcmVlemUg JiYgIWRvX3BydW5lKQorCQlpZiAoIWRvX2ZyZWV6ZSAmJiAhZG9fcHJ1bmUgJiYgIWRvX3NldF92 bSkKIAkJCU1hcmtCdWZmZXJEaXJ0eUhpbnQocHJzdGF0ZS5idWZmZXIsIHRydWUpOwogCX0KIAot CWlmIChkb19wcnVuZSB8fCBkb19mcmVlemUpCisJaWYgKGRvX3BydW5lIHx8IGRvX2ZyZWV6ZSB8 fCBkb19zZXRfdm0pCiAJewogCQkvKiBBcHBseSB0aGUgcGxhbm5lZCBpdGVtIGNoYW5nZXMgYW5k IHJlcGFpciBwYWdlIGZyYWdtZW50YXRpb24uICovCiAJCWlmIChkb19wcnVuZSkKQEAgLTExNjcs NiArMTIzNiwyNyBAQCBoZWFwX3BhZ2VfcHJ1bmVfYW5kX2ZyZWV6ZShQcnVuZUZyZWV6ZVBhcmFt cyAqcGFyYW1zLAogCQlpZiAoZG9fZnJlZXplKQogCQkJaGVhcF9mcmVlemVfcHJlcGFyZWRfdHVw bGVzKHByc3RhdGUuYnVmZmVyLCBwcnN0YXRlLmZyb3plbiwgcHJzdGF0ZS5uZnJvemVuKTsKIAor CQkvKiBTZXQgdGhlIHZpc2liaWxpdHkgbWFwIGFuZCBwYWdlIHZpc2liaWxpdHkgaGludCAqLwor CQlpZiAoZG9fc2V0X3ZtKQorCQl7CisJCQkvKgorCQkJICogV2hpbGUgaXQgaXMgdmFsaWQgZm9y IFBEX0FMTF9WSVNJQkxFIHRvIGJlIHNldCB3aGVuIHRoZQorCQkJICogY29ycmVzcG9uZGluZyBW TSBiaXQgaXMgY2xlYXIsIHdlIHN0cm9uZ2x5IHByZWZlciB0byBrZWVwIHRoZW0KKwkJCSAqIGlu IHN5bmMuCisJCQkgKgorCQkJICogVGhlIGhlYXAgYnVmZmVyIG11c3QgYmUgbWFya2VkIGRpcnR5 IGJlZm9yZSBhZGRpbmcgaXQgdG8gdGhlCisJCQkgKiBXQUwgY2hhaW4gd2hlbiBzZXR0aW5nIHRo ZSBWTS4gV2UgZG9uJ3Qgd29ycnkgYWJvdXQKKwkJCSAqIHVubmVjZXNzYXJpbHkgZGlydHlpbmcg dGhlIGhlYXAgYnVmZmVyIGlmIFBEX0FMTF9WSVNJQkxFIGlzCisJCQkgKiBhbHJlYWR5IHNldCwg dGhvdWdoLiBJdCBpcyBleHRyZW1lbHkgcmFyZSB0byBoYXZlIGEgY2xlYW4gaGVhcAorCQkJICog YnVmZmVyIHdpdGggUERfQUxMX1ZJU0lCTEUgYWxyZWFkeSBzZXQgYW5kIHRoZSBWTSBiaXRzIGNs ZWFyLAorCQkJICogc28gdGhlcmUgaXMgbm8gcG9pbnQgaW4gb3B0aW1pemluZyBpdC4KKwkJCSAq LworCQkJUGFnZVNldEFsbFZpc2libGUocHJzdGF0ZS5wYWdlKTsKKwkJCVBhZ2VDbGVhclBydW5h YmxlKHByc3RhdGUucGFnZSk7CisJCQl2aXNpYmlsaXR5bWFwX3NldF92bWJpdHMocHJzdGF0ZS5i bG9jaywgcHJzdGF0ZS52bWJ1ZmZlciwgcHJzdGF0ZS5uZXdfdm1iaXRzLAorCQkJCQkJCQkJIHBy c3RhdGUucmVsYXRpb24tPnJkX2xvY2F0b3IpOworCQl9CisKIAkJTWFya0J1ZmZlckRpcnR5KHBy c3RhdGUuYnVmZmVyKTsKIAogCQkvKgpAQCAtMTE3NCwyOSArMTI2NCwxMiBAQCBoZWFwX3BhZ2Vf cHJ1bmVfYW5kX2ZyZWV6ZShQcnVuZUZyZWV6ZVBhcmFtcyAqcGFyYW1zLAogCQkgKi8KIAkJaWYg KFJlbGF0aW9uTmVlZHNXQUwocHJzdGF0ZS5yZWxhdGlvbikpCiAJCXsKLQkJCS8qCi0JCQkgKiBU aGUgc25hcHNob3RDb25mbGljdEhvcml6b24gZm9yIHRoZSB3aG9sZSByZWNvcmQgc2hvdWxkIGJl IHRoZQotCQkJICogbW9zdCBjb25zZXJ2YXRpdmUgb2YgYWxsIHRoZSBob3Jpem9ucyBjYWxjdWxh dGVkIGZvciBhbnkgb2YgdGhlCi0JCQkgKiBwb3NzaWJsZSBtb2RpZmljYXRpb25zLiBJZiB0aGlz IHJlY29yZCB3aWxsIHBydW5lIHR1cGxlcywgYW55Ci0JCQkgKiBxdWVyaWVzIG9uIHRoZSBzdGFu ZGJ5IG9sZGVyIHRoYW4gdGhlIG5ld2VzdCB4aWQgb2YgdGhlIG1vc3QKLQkJCSAqIHJlY2VudGx5 IHJlbW92ZWQgdHVwbGUgdGhpcyByZWNvcmQgd2lsbCBwcnVuZSB3aWxsIGNvbmZsaWN0LiBJZgot CQkJICogdGhpcyByZWNvcmQgd2lsbCBmcmVlemUgdHVwbGVzLCBhbnkgcXVlcmllcyBvbiB0aGUg c3RhbmRieSB3aXRoCi0JCQkgKiB4aWRzIG9sZGVyIHRoYW4gdGhlIG5ld2VzdCB0dXBsZSB0aGlz IHJlY29yZCB3aWxsIGZyZWV6ZSB3aWxsCi0JCQkgKiBjb25mbGljdC4KLQkJCSAqLwotCQkJVHJh bnNhY3Rpb25JZCBjb25mbGljdF94aWQ7Ci0KLQkJCWlmIChUcmFuc2FjdGlvbklkRm9sbG93cyhw cnN0YXRlLnBhZ2VmcnouRnJlZXplUGFnZUNvbmZsaWN0WGlkLAotCQkJCQkJCQkJIHByc3RhdGUu bGF0ZXN0X3hpZF9yZW1vdmVkKSkKLQkJCQljb25mbGljdF94aWQgPSBwcnN0YXRlLnBhZ2Vmcnou RnJlZXplUGFnZUNvbmZsaWN0WGlkOwotCQkJZWxzZQotCQkJCWNvbmZsaWN0X3hpZCA9IHByc3Rh dGUubGF0ZXN0X3hpZF9yZW1vdmVkOwotCiAJCQlsb2dfaGVhcF9wcnVuZV9hbmRfZnJlZXplKHBy c3RhdGUucmVsYXRpb24sIHByc3RhdGUuYnVmZmVyLAotCQkJCQkJCQkJICBJbnZhbGlkQnVmZmVy LAkvKiB2bWJ1ZmZlciAqLwotCQkJCQkJCQkJICAwLAkvKiB2bWZsYWdzICovCisJCQkJCQkJCQkg IGRvX3NldF92bSA/IHByc3RhdGUudm1idWZmZXIgOiBJbnZhbGlkQnVmZmVyLAorCQkJCQkJCQkJ ICBkb19zZXRfdm0gPyBwcnN0YXRlLm5ld192bWJpdHMgOiAwLAogCQkJCQkJCQkJICBjb25mbGlj dF94aWQsCi0JCQkJCQkJCQkgIHRydWUsIHBhcmFtcy0+cmVhc29uLAorCQkJCQkJCQkJICB0cnVl LCAvKiBjbGVhbnVwIGxvY2sgKi8KKwkJCQkJCQkJCSAgcGFyYW1zLT5yZWFzb24sCiAJCQkJCQkJ CQkgIHByc3RhdGUuZnJvemVuLCBwcnN0YXRlLm5mcm96ZW4sCiAJCQkJCQkJCQkgIHByc3RhdGUu cmVkaXJlY3RlZCwgcHJzdGF0ZS5ucmVkaXJlY3RlZCwKIAkJCQkJCQkJCSAgcHJzdGF0ZS5ub3dk ZWFkLCBwcnN0YXRlLm5kZWFkLApAQCAtMTIwNiwzMyArMTI3OSw3MCBAQCBoZWFwX3BhZ2VfcHJ1 bmVfYW5kX2ZyZWV6ZShQcnVuZUZyZWV6ZVBhcmFtcyAqcGFyYW1zLAogCiAJRU5EX0NSSVRfU0VD VElPTigpOwogCisJaWYgKGRvX3NldF92bSkKKwkJTG9ja0J1ZmZlcihwcnN0YXRlLnZtYnVmZmVy LCBCVUZGRVJfTE9DS19VTkxPQ0spOworCisJLyoKKwkgKiBEdXJpbmcgaXRzIHNlY29uZCBwYXNz IG92ZXIgdGhlIGhlYXAsIFZBQ1VVTSBjYWxscworCSAqIGhlYXBfcGFnZV93b3VsZF9iZV9hbGxf dmlzaWJsZSgpIHRvIGRldGVybWluZSB3aGV0aGVyIGEgcGFnZSBpcworCSAqIGFsbC12aXNpYmxl IGFuZCBhbGwtZnJvemVuLiBUaGUgbG9naWMgaGVyZSBpcyBzaW1pbGFyLiBBZnRlciBjb21wbGV0 aW5nCisJICogcHJ1bmluZyBhbmQgZnJlZXppbmcsIHVzZSBhbiBhc3NlcnRpb24gdG8gdmVyaWZ5 IHRoYXQgb3VyIHJlc3VsdHMKKwkgKiByZW1haW4gY29uc2lzdGVudCB3aXRoIGhlYXBfcGFnZV93 b3VsZF9iZV9hbGxfdmlzaWJsZSgpLgorCSAqLworI2lmZGVmIFVTRV9BU1NFUlRfQ0hFQ0tJTkcK KwlpZiAocHJzdGF0ZS5zZXRfYWxsX3Zpc2libGUpCisJeworCQlUcmFuc2FjdGlvbklkIGRlYnVn X2N1dG9mZjsKKwkJYm9vbAkJZGVidWdfYWxsX2Zyb3plbjsKKworCQlBc3NlcnQocHJzdGF0ZS5s cGRlYWRfaXRlbXMgPT0gMCk7CisKKwkJQXNzZXJ0KGhlYXBfcGFnZV9pc19hbGxfdmlzaWJsZShw cnN0YXRlLnJlbGF0aW9uLCBwcnN0YXRlLmJ1ZmZlciwKKwkJCQkJCQkJCQlwcnN0YXRlLnZpc3Rl c3QsCisJCQkJCQkJCQkJJmRlYnVnX2FsbF9mcm96ZW4sCisJCQkJCQkJCQkJJmRlYnVnX2N1dG9m Ziwgb2ZmX2xvYykpOworCisJCUFzc2VydCghVHJhbnNhY3Rpb25JZElzVmFsaWQoZGVidWdfY3V0 b2ZmKSB8fAorCQkJICAgZGVidWdfY3V0b2ZmID09IHByc3RhdGUubmV3ZXN0X2xpdmVfeGlkKTsK KworCQkvKgorCQkgKiBJdCdzIHBvc3NpYmxlIHRoZSBwYWdlIGlzIGNvbXBvc2VkIGVudGlyZWx5 IG9mIGZyb3plbiB0dXBsZXMgYnV0IGlzCisJCSAqIG5vdCBzZXQgYWxsLWZyb3plbiBpbiB0aGUg Vk0gYW5kIGRpZCBub3QgcGFzcworCQkgKiBIRUFQX1BBR0VfUFJVTkVfRlJFRVpFLiBJbiB0aGlz IGNhc2UsIGl0J3MgcG9zc2libGUKKwkJICogaGVhcF9wYWdlX2lzX2FsbF92aXNpYmxlKCkgZmlu ZHMgdGhlIHBhZ2UgY29tcGxldGVseSBmcm96ZW4sIGV2ZW4KKwkJICogdGhvdWdoIHByc3RhdGUu c2V0X2FsbF9mcm96ZW4gaXMgZmFsc2UuCisJCSAqLworCQlBc3NlcnQoIXByc3RhdGUuc2V0X2Fs bF9mcm96ZW4gfHwgZGVidWdfYWxsX2Zyb3plbik7CisJfQorI2VuZGlmCisKIAkvKiBDb3B5IGlu Zm9ybWF0aW9uIGJhY2sgZm9yIGNhbGxlciAqLwogCXByZXN1bHQtPm5kZWxldGVkID0gcHJzdGF0 ZS5uZGVsZXRlZDsKIAlwcmVzdWx0LT5ubmV3bHBkZWFkID0gcHJzdGF0ZS5uZGVhZDsKIAlwcmVz dWx0LT5uZnJvemVuID0gcHJzdGF0ZS5uZnJvemVuOwogCXByZXN1bHQtPmxpdmVfdHVwbGVzID0g cHJzdGF0ZS5saXZlX3R1cGxlczsKIAlwcmVzdWx0LT5yZWNlbnRseV9kZWFkX3R1cGxlcyA9IHBy c3RhdGUucmVjZW50bHlfZGVhZF90dXBsZXM7Ci0JcHJlc3VsdC0+c2V0X2FsbF92aXNpYmxlID0g cHJzdGF0ZS5zZXRfYWxsX3Zpc2libGU7Ci0JcHJlc3VsdC0+c2V0X2FsbF9mcm96ZW4gPSBwcnN0 YXRlLnNldF9hbGxfZnJvemVuOwogCXByZXN1bHQtPmhhc3R1cCA9IHByc3RhdGUuaGFzdHVwOwot CXByZXN1bHQtPm9sZF92bWJpdHMgPSBwcnN0YXRlLm9sZF92bWJpdHM7Ci0KLQkvKgotCSAqIEZv ciBjYWxsZXJzIHBsYW5uaW5nIHRvIHVwZGF0ZSB0aGUgdmlzaWJpbGl0eSBtYXAsIHRoZSBjb25m bGljdCBob3Jpem9uCi0JICogZm9yIHRoYXQgcmVjb3JkIG11c3QgYmUgdGhlIG5ld2VzdCB4bWlu IG9uIHRoZSBwYWdlLiAgSG93ZXZlciwgaWYgdGhlCi0JICogcGFnZSBpcyBjb21wbGV0ZWx5IGZy b3plbiwgdGhlcmUgY2FuIGJlIG5vIGNvbmZsaWN0IGFuZCB0aGUKLQkgKiB2bV9jb25mbGljdF9o b3Jpem9uIHNob3VsZCByZW1haW4gSW52YWxpZFRyYW5zYWN0aW9uSWQuICBUaGlzIGluY2x1ZGVz Ci0JICogdGhlIGNhc2UgdGhhdCB3ZSBqdXN0IGZyb3plIGFsbCB0aGUgdHVwbGVzOyB0aGUgcHJ1 bmUtZnJlZXplIHJlY29yZAotCSAqIGluY2x1ZGVkIHRoZSBjb25mbGljdCBYSUQgYWxyZWFkeSBz byB0aGUgY2FsbGVyIGRvZXNuJ3QgbmVlZCBpdC4KLQkgKi8KLQlpZiAocHJlc3VsdC0+c2V0X2Fs bF9mcm96ZW4pCi0JCXByZXN1bHQtPnZtX2NvbmZsaWN0X2hvcml6b24gPSBJbnZhbGlkVHJhbnNh Y3Rpb25JZDsKLQllbHNlCi0JCXByZXN1bHQtPnZtX2NvbmZsaWN0X2hvcml6b24gPSBwcnN0YXRl Lm5ld2VzdF9saXZlX3hpZDsKIAogCXByZXN1bHQtPmxwZGVhZF9pdGVtcyA9IHByc3RhdGUubHBk ZWFkX2l0ZW1zOwogCS8qIHRoZSBwcmVzdWx0LT5kZWFkb2Zmc2V0cyBhcnJheSB3YXMgYWxyZWFk eSBmaWxsZWQgaW4gKi8KIAorCXByZXN1bHQtPm5ld2x5X2FsbF92aXNpYmxlID0gZmFsc2U7CisJ cHJlc3VsdC0+bmV3bHlfYWxsX2Zyb3plbiA9IGZhbHNlOworCXByZXN1bHQtPm5ld2x5X2FsbF92 aXNpYmxlX2Zyb3plbiA9IGZhbHNlOworCWlmIChkb19zZXRfdm0pCisJeworCQlpZiAoKHByc3Rh dGUub2xkX3ZtYml0cyAmIFZJU0lCSUxJVFlNQVBfQUxMX1ZJU0lCTEUpID09IDApCisJCXsKKwkJ CXByZXN1bHQtPm5ld2x5X2FsbF92aXNpYmxlID0gdHJ1ZTsKKwkJCWlmIChwcnN0YXRlLnNldF9h bGxfZnJvemVuKQorCQkJCXByZXN1bHQtPm5ld2x5X2FsbF92aXNpYmxlX2Zyb3plbiA9IHRydWU7 CisJCX0KKwkJZWxzZSBpZiAoKHByc3RhdGUub2xkX3ZtYml0cyAmIFZJU0lCSUxJVFlNQVBfQUxM X0ZST1pFTikgPT0gMCAmJgorCQkJCSBwcnN0YXRlLnNldF9hbGxfZnJvemVuKQorCQkJcHJlc3Vs dC0+bmV3bHlfYWxsX2Zyb3plbiA9IHRydWU7CisJfQorCiAJaWYgKHByc3RhdGUuYXR0ZW1wdF9m cmVlemUpCiAJewogCQlpZiAocHJlc3VsdC0+bmZyb3plbiA+IDApCmRpZmYgLS1naXQgYS9zcmMv YmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVh cC92YWN1dW1sYXp5LmMKaW5kZXggODU5OWRkN2ZjZmEuLmQxNDRlMGY2NDJiIDEwMDY0NAotLS0g YS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMKKysrIGIvc3JjL2JhY2tlbmQv YWNjZXNzL2hlYXAvdmFjdXVtbGF6eS5jCkBAIC00NjYsMTMgKzQ2Niw2IEBAIHN0YXRpYyB2b2lk IGRlYWRfaXRlbXNfYWRkKExWUmVsU3RhdGUgKnZhY3JlbCwgQmxvY2tOdW1iZXIgYmxrbm8sIE9m ZnNldE51bWJlciAqCiBzdGF0aWMgdm9pZCBkZWFkX2l0ZW1zX3Jlc2V0KExWUmVsU3RhdGUgKnZh Y3JlbCk7CiBzdGF0aWMgdm9pZCBkZWFkX2l0ZW1zX2NsZWFudXAoTFZSZWxTdGF0ZSAqdmFjcmVs KTsKIAotI2lmZGVmIFVTRV9BU1NFUlRfQ0hFQ0tJTkcKLXN0YXRpYyBib29sIGhlYXBfcGFnZV9p c19hbGxfdmlzaWJsZShSZWxhdGlvbiByZWwsIEJ1ZmZlciBidWYsCi0JCQkJCQkJCQkgR2xvYmFs VmlzU3RhdGUgKnZpc3Rlc3QsCi0JCQkJCQkJCQkgYm9vbCAqYWxsX2Zyb3plbiwKLQkJCQkJCQkJ CSBUcmFuc2FjdGlvbklkICpuZXdlc3RfbGl2ZV94aWQsCi0JCQkJCQkJCQkgT2Zmc2V0TnVtYmVy ICpsb2dnaW5nX29mZm51bSk7Ci0jZW5kaWYKIHN0YXRpYyBib29sIGhlYXBfcGFnZV93b3VsZF9i ZV9hbGxfdmlzaWJsZShSZWxhdGlvbiByZWwsIEJ1ZmZlciBidWYsCiAJCQkJCQkJCQkJICAgR2xv YmFsVmlzU3RhdGUgKnZpc3Rlc3QsCiAJCQkJCQkJCQkJICAgT2Zmc2V0TnVtYmVyICpkZWFkb2Zm c2V0cywKQEAgLTIwMjEsOCArMjAxNCw2IEBAIGxhenlfc2Nhbl9wcnVuZShMVlJlbFN0YXRlICp2 YWNyZWwsCiAJCS52aXN0ZXN0ID0gdmFjcmVsLT52aXN0ZXN0LAogCQkuY3V0b2ZmcyA9ICZ2YWNy ZWwtPmN1dG9mZnMsCiAJfTsKLQl1aW50OAkJb2xkX3ZtYml0cyA9IDA7Ci0JdWludDgJCW5ld192 bWJpdHMgPSAwOwogCiAJQXNzZXJ0KEJ1ZmZlckdldEJsb2NrTnVtYmVyKGJ1ZikgPT0gYmxrbm8p OwogCkBAIC0yMDczLDMyICsyMDY0LDYgQEAgbGF6eV9zY2FuX3BydW5lKExWUmVsU3RhdGUgKnZh Y3JlbCwKIAkJdmFjcmVsLT5uZXdfZnJvemVuX3R1cGxlX3BhZ2VzKys7CiAJfQogCi0JLyoKLQkg KiBWQUNVVU0gd2lsbCBjYWxsIGhlYXBfcGFnZV9pc19hbGxfdmlzaWJsZSgpIGR1cmluZyB0aGUg c2Vjb25kIHBhc3Mgb3ZlcgotCSAqIHRoZSBoZWFwIHRvIGRldGVybWluZSBhbGxfdmlzaWJsZSBh bmQgYWxsX2Zyb3plbiBmb3IgdGhlIHBhZ2UgLS0gdGhpcwotCSAqIGlzIGEgc3BlY2lhbGl6ZWQg dmVyc2lvbiBvZiB0aGUgbG9naWMgZnJvbSB0aGlzIGZ1bmN0aW9uLiAgTm93IHRoYXQKLQkgKiB3 ZSd2ZSBmaW5pc2hlZCBwcnVuaW5nIGFuZCBmcmVlemluZywgbWFrZSBzdXJlIHRoYXQgd2UncmUg aW4gdG90YWwKLQkgKiBhZ3JlZW1lbnQgd2l0aCBoZWFwX3BhZ2VfaXNfYWxsX3Zpc2libGUoKSB1 c2luZyBhbiBhc3NlcnRpb24uCi0JICovCi0jaWZkZWYgVVNFX0FTU0VSVF9DSEVDS0lORwotCWlm IChwcmVzdWx0LnNldF9hbGxfdmlzaWJsZSkKLQl7Ci0JCVRyYW5zYWN0aW9uSWQgZGVidWdfY3V0 b2ZmOwotCQlib29sCQlkZWJ1Z19hbGxfZnJvemVuOwotCi0JCUFzc2VydChwcmVzdWx0LmxwZGVh ZF9pdGVtcyA9PSAwKTsKLQotCQlBc3NlcnQoaGVhcF9wYWdlX2lzX2FsbF92aXNpYmxlKHZhY3Jl bC0+cmVsLCBidWYsCi0JCQkJCQkJCQkJdmFjcmVsLT52aXN0ZXN0LCAmZGVidWdfYWxsX2Zyb3pl biwKLQkJCQkJCQkJCQkmZGVidWdfY3V0b2ZmLCAmdmFjcmVsLT5vZmZudW0pKTsKLQotCQlBc3Nl cnQocHJlc3VsdC5zZXRfYWxsX2Zyb3plbiA9PSBkZWJ1Z19hbGxfZnJvemVuKTsKLQotCQlBc3Nl cnQoIVRyYW5zYWN0aW9uSWRJc1ZhbGlkKGRlYnVnX2N1dG9mZikgfHwKLQkJCSAgIGRlYnVnX2N1 dG9mZiA9PSBwcmVzdWx0LnZtX2NvbmZsaWN0X2hvcml6b24pOwotCX0KLSNlbmRpZgotCiAJLyoK IAkgKiBOb3cgc2F2ZSBkZXRhaWxzIG9mIHRoZSBMUF9ERUFEIGl0ZW1zIGZyb20gdGhlIHBhZ2Ug aW4gdmFjcmVsCiAJICovCkBAIC0yMTE5LDYgKzIwODQsMTcgQEAgbGF6eV9zY2FuX3BydW5lKExW UmVsU3RhdGUgKnZhY3JlbCwKIAl9CiAKIAkvKiBGaW5hbGx5LCBhZGQgcGFnZS1sb2NhbCBjb3Vu dHMgdG8gd2hvbGUtVkFDVVVNIGNvdW50cyAqLworCWlmIChwcmVzdWx0Lm5ld2x5X2FsbF92aXNp YmxlKQorCQl2YWNyZWwtPm5ld19hbGxfdmlzaWJsZV9wYWdlcysrOworCWlmIChwcmVzdWx0Lm5l d2x5X2FsbF92aXNpYmxlX2Zyb3plbikKKwkJdmFjcmVsLT5uZXdfYWxsX3Zpc2libGVfYWxsX2Zy b3plbl9wYWdlcysrOworCWlmIChwcmVzdWx0Lm5ld2x5X2FsbF9mcm96ZW4pCisJCXZhY3JlbC0+ bmV3X2FsbF9mcm96ZW5fcGFnZXMrKzsKKworCS8qIENhcHR1cmUgaWYgdGhlIHBhZ2Ugd2FzIG5l d2x5IHNldCBmcm96ZW4gKi8KKwkqdm1fcGFnZV9mcm96ZW4gPSBwcmVzdWx0Lm5ld2x5X2FsbF92 aXNpYmxlX2Zyb3plbiB8fAorCQlwcmVzdWx0Lm5ld2x5X2FsbF9mcm96ZW47CisKIAl2YWNyZWwt PnR1cGxlc19kZWxldGVkICs9IHByZXN1bHQubmRlbGV0ZWQ7CiAJdmFjcmVsLT50dXBsZXNfZnJv emVuICs9IHByZXN1bHQubmZyb3plbjsKIAl2YWNyZWwtPmxwZGVhZF9pdGVtcyArPSBwcmVzdWx0 LmxwZGVhZF9pdGVtczsKQEAgLTIxMzIsNzEgKzIxMDgsNiBAQCBsYXp5X3NjYW5fcHJ1bmUoTFZS ZWxTdGF0ZSAqdmFjcmVsLAogCS8qIERpZCB3ZSBmaW5kIExQX0RFQUQgaXRlbXM/ICovCiAJKmhh c19scGRlYWRfaXRlbXMgPSAocHJlc3VsdC5scGRlYWRfaXRlbXMgPiAwKTsKIAotCUFzc2VydCgh cHJlc3VsdC5zZXRfYWxsX3Zpc2libGUgfHwgISgqaGFzX2xwZGVhZF9pdGVtcykpOwotCUFzc2Vy dCghcHJlc3VsdC5zZXRfYWxsX2Zyb3plbiB8fCBwcmVzdWx0LnNldF9hbGxfdmlzaWJsZSk7Ci0K LQlpZiAoIXByZXN1bHQuc2V0X2FsbF92aXNpYmxlKQotCQlyZXR1cm4gcHJlc3VsdC5uZGVsZXRl ZDsKLQotCS8qIFNldCB0aGUgdmlzaWJpbGl0eSBtYXAgYW5kIHBhZ2UgdmlzaWJpbGl0eSBoaW50 ICovCi0Jb2xkX3ZtYml0cyA9IHByZXN1bHQub2xkX3ZtYml0czsKLQluZXdfdm1iaXRzID0gVklT SUJJTElUWU1BUF9BTExfVklTSUJMRTsKLQlpZiAocHJlc3VsdC5zZXRfYWxsX2Zyb3plbikKLQkJ bmV3X3ZtYml0cyB8PSBWSVNJQklMSVRZTUFQX0FMTF9GUk9aRU47Ci0KLQkvKiBOb3RoaW5nIHRv IGRvICovCi0JaWYgKG9sZF92bWJpdHMgPT0gbmV3X3ZtYml0cykKLQkJcmV0dXJuIHByZXN1bHQu bmRlbGV0ZWQ7Ci0KLQkvKgotCSAqIEl0IHNob3VsZCBuZXZlciBiZSB0aGUgY2FzZSB0aGF0IHRo ZSB2aXNpYmlsaXR5IG1hcCBwYWdlIGlzIHNldCB3aGlsZQotCSAqIHRoZSBwYWdlLWxldmVsIGJp dCBpcyBjbGVhciAoYW5kIGlmIHNvLCB3ZSBjbGVhcmVkIGl0IGFib3ZlKSwgYnV0IHRoZQotCSAq IHJldmVyc2UgaXMgYWxsb3dlZCAoaWYgY2hlY2tzdW1zIGFyZSBub3QgZW5hYmxlZCkuIFJlZ2Fy ZGxlc3MsIHNldCBib3RoCi0JICogYml0cyBzbyB0aGF0IHdlIGdldCBiYWNrIGluIHN5bmMuCi0J ICoKLQkgKiBUaGUgaGVhcCBidWZmZXIgbXVzdCBiZSBtYXJrZWQgZGlydHkgYmVmb3JlIGFkZGlu ZyBpdCB0byB0aGUgV0FMIGNoYWluCi0JICogd2hlbiBzZXR0aW5nIHRoZSBWTS4gV2UgZG9uJ3Qg d29ycnkgYWJvdXQgdW5uZWNlc3NhcmlseSBkaXJ0eWluZyB0aGUKLQkgKiBoZWFwIGJ1ZmZlciBp ZiBQRF9BTExfVklTSUJMRSBpcyBhbHJlYWR5IHNldCwgdGhvdWdoLiBJdCBpcyBleHRyZW1lbHkK LQkgKiByYXJlIHRvIGhhdmUgYSBjbGVhbiBoZWFwIGJ1ZmZlciB3aXRoIFBEX0FMTF9WSVNJQkxF IGFscmVhZHkgc2V0IGFuZAotCSAqIHRoZSBWTSBiaXRzIGNsZWFyLCBzbyB0aGVyZSBpcyBubyBw b2ludCBpbiBvcHRpbWl6aW5nIGl0LgotCSAqLwotCVBhZ2VTZXRBbGxWaXNpYmxlKHBhZ2UpOwot CVBhZ2VDbGVhclBydW5hYmxlKHBhZ2UpOwotCU1hcmtCdWZmZXJEaXJ0eShidWYpOwotCi0JLyoK LQkgKiBJZiB0aGUgcGFnZSBpcyBiZWluZyBzZXQgYWxsLWZyb3plbiwgd2UgcGFzcyBJbnZhbGlk VHJhbnNhY3Rpb25JZCBhcwotCSAqIHRoZSBjdXRvZmZfeGlkLCBzaW5jZSBhIHNuYXBzaG90IGNv bmZsaWN0IGhvcml6b24gc3VmZmljaWVudCB0byBtYWtlCi0JICogZXZlcnl0aGluZyBzYWZlIGZv ciBSRURPIHdhcyBsb2dnZWQgd2hlbiB0aGUgcGFnZSdzIHR1cGxlcyB3ZXJlIGZyb3plbi4KLQkg Ki8KLQlBc3NlcnQoIXByZXN1bHQuc2V0X2FsbF9mcm96ZW4gfHwKLQkJICAgIVRyYW5zYWN0aW9u SWRJc1ZhbGlkKHByZXN1bHQudm1fY29uZmxpY3RfaG9yaXpvbikpOwotCi0JdmlzaWJpbGl0eW1h cF9zZXQodmFjcmVsLT5yZWwsIGJsa25vLCBidWYsCi0JCQkJCSAgSW52YWxpZFhMb2dSZWNQdHIs Ci0JCQkJCSAgdm1idWZmZXIsIHByZXN1bHQudm1fY29uZmxpY3RfaG9yaXpvbiwKLQkJCQkJICBu ZXdfdm1iaXRzKTsKLQotCS8qCi0JICogSWYgdGhlIHBhZ2Ugd2Fzbid0IGFscmVhZHkgc2V0IGFs bC12aXNpYmxlIGFuZC9vciBhbGwtZnJvemVuIGluIHRoZSBWTSwKLQkgKiBjb3VudCBpdCBhcyBu ZXdseSBzZXQgZm9yIGxvZ2dpbmcuCi0JICovCi0JaWYgKChvbGRfdm1iaXRzICYgVklTSUJJTElU WU1BUF9BTExfVklTSUJMRSkgPT0gMCkKLQl7Ci0JCXZhY3JlbC0+bmV3X2FsbF92aXNpYmxlX3Bh Z2VzKys7Ci0JCWlmIChwcmVzdWx0LnNldF9hbGxfZnJvemVuKQotCQl7Ci0JCQl2YWNyZWwtPm5l d19hbGxfdmlzaWJsZV9hbGxfZnJvemVuX3BhZ2VzKys7Ci0JCQkqdm1fcGFnZV9mcm96ZW4gPSB0 cnVlOwotCQl9Ci0JfQotCWVsc2UgaWYgKChvbGRfdm1iaXRzICYgVklTSUJJTElUWU1BUF9BTExf RlJPWkVOKSA9PSAwICYmCi0JCQkgcHJlc3VsdC5zZXRfYWxsX2Zyb3plbikKLQl7Ci0JCXZhY3Jl bC0+bmV3X2FsbF9mcm96ZW5fcGFnZXMrKzsKLQkJKnZtX3BhZ2VfZnJvemVuID0gdHJ1ZTsKLQl9 Ci0KIAlyZXR1cm4gcHJlc3VsdC5uZGVsZXRlZDsKIH0KIApAQCAtMzYxMiw3ICszNTIzLDcgQEAg ZGVhZF9pdGVtc19jbGVhbnVwKExWUmVsU3RhdGUgKnZhY3JlbCkKICAqIHRoYXQgZXhwZWN0IG5v IExQX0RFQUQgb24gdGhlIHBhZ2UuIEN1cnJlbnRseSBhc3NlcnQtb25seSwgYnV0IHRoZXJlIGlz IG5vCiAgKiByZWFzb24gbm90IHRvIHVzZSBpdCBvdXRzaWRlIG9mIGFzc2VydHMuCiAgKi8KLXN0 YXRpYyBib29sCitib29sCiBoZWFwX3BhZ2VfaXNfYWxsX3Zpc2libGUoUmVsYXRpb24gcmVsLCBC dWZmZXIgYnVmLAogCQkJCQkJIEdsb2JhbFZpc1N0YXRlICp2aXN0ZXN0LAogCQkJCQkJIGJvb2wg KmFsbF9mcm96ZW4sCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9hY2Nlc3MvaGVhcGFtLmggYi9z cmMvaW5jbHVkZS9hY2Nlc3MvaGVhcGFtLmgKaW5kZXggZjlkYmQ3MGMxYzQuLmI5NTc3YzI0ODQ0 IDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9hY2Nlc3MvaGVhcGFtLmgKKysrIGIvc3JjL2luY2x1 ZGUvYWNjZXNzL2hlYXBhbS5oCkBAIC0yNjUsNyArMjY1LDggQEAgdHlwZWRlZiBzdHJ1Y3QgUHJ1 bmVGcmVlemVQYXJhbXMKIAogCS8qCiAJICogQ2FsbGVycyBzaG91bGQgcHJvdmlkZSBhIHBpbm5l ZCB2bWJ1ZmZlciBjb3JyZXNwb25kaW5nIHRvIHRoZSBoZWFwCi0JICogYmxvY2sgaW4gYnVmZmVy LiBXZSB3aWxsIGNoZWNrIGZvciBhbmQgcmVwYWlyIGFueSBjb3JydXB0aW9uIGluIHRoZSBWTS4K KwkgKiBibG9jayBpbiBidWZmZXIuIFdlIHdpbGwgY2hlY2sgZm9yIGFuZCByZXBhaXIgYW55IGNv cnJ1cHRpb24gaW4gdGhlIFZNCisJICogYW5kIHNldCB0aGUgVk0gYWZ0ZXIgcHJ1bmluZyBpZiB0 aGUgcGFnZSBpcyBhbGwtdmlzaWJsZS9hbGwtZnJvemVuLgogCSAqLwogCUJ1ZmZlcgkJdm1idWZm ZXI7CiAKQEAgLTI4MSw4ICsyODIsNyBAQCB0eXBlZGVmIHN0cnVjdCBQcnVuZUZyZWV6ZVBhcmFt cwogCSAqIEhFQVBfUEFHRV9QUlVORV9NQVJLX1VOVVNFRF9OT1cgaW5kaWNhdGVzIHRoYXQgZGVh ZCBpdGVtcyBjYW4gYmUgc2V0CiAJICogTFBfVU5VU0VEIGR1cmluZyBwcnVuaW5nLgogCSAqCi0J ICogSEVBUF9QQUdFX1BSVU5FX0ZSRUVaRSBpbmRpY2F0ZXMgdGhhdCB3ZSB3aWxsIGFsc28gZnJl ZXplIHR1cGxlcywgYW5kCi0JICogd2lsbCByZXR1cm4gJ2FsbF92aXNpYmxlJywgJ2FsbF9mcm96 ZW4nIGZsYWdzIHRvIHRoZSBjYWxsZXIuCisJICogSEVBUF9QQUdFX1BSVU5FX0ZSRUVaRSBpbmRp Y2F0ZXMgdGhhdCB3ZSB3aWxsIGFsc28gZnJlZXplIHR1cGxlcy4KIAkgKi8KIAlpbnQJCQlvcHRp b25zOwogCkBAIC0zMTYsMjYgKzMxNiwxMiBAQCB0eXBlZGVmIHN0cnVjdCBQcnVuZUZyZWV6ZVJl c3VsdAogCWludAkJCXJlY2VudGx5X2RlYWRfdHVwbGVzOwogCiAJLyoKLQkgKiBzZXRfYWxsX3Zp c2libGUgYW5kIHNldF9hbGxfZnJvemVuIGluZGljYXRlIGlmIHRoZSBhbGwtdmlzaWJsZSBhbmQK LQkgKiBhbGwtZnJvemVuIGJpdHMgaW4gdGhlIHZpc2liaWxpdHkgbWFwIHNob3VsZCBiZSBzZXQg Zm9yIHRoaXMgcGFnZSBhZnRlcgotCSAqIHBydW5pbmcuCi0JICoKLQkgKiB2bV9jb25mbGljdF9o b3Jpem9uIGlzIHRoZSBuZXdlc3QgeG1pbiBvZiBsaXZlIHR1cGxlcyBvbiB0aGUgcGFnZS4gIFRo ZQotCSAqIGNhbGxlciBjYW4gdXNlIGl0IGFzIHRoZSBjb25mbGljdCBob3Jpem9uIHdoZW4gc2V0 dGluZyB0aGUgVk0gYml0cy4gIEl0Ci0JICogaXMgb25seSB2YWxpZCBpZiB3ZSBmcm96ZSBzb21l IHR1cGxlcyAobmZyb3plbiA+IDApLCBhbmQgc2V0X2FsbF9mcm96ZW4KLQkgKiBpcyB0cnVlLgot CSAqCi0JICogVGhlc2UgYXJlIG9ubHkgc2V0IGlmIHRoZSBIRUFQX1BBR0VfUFJVTkVfRlJFRVpF IG9wdGlvbiBpcyBzZXQuCi0JICovCi0JYm9vbAkJc2V0X2FsbF92aXNpYmxlOwotCWJvb2wJCXNl dF9hbGxfZnJvemVuOwotCVRyYW5zYWN0aW9uSWQgdm1fY29uZmxpY3RfaG9yaXpvbjsKLQotCS8q Ci0JICogVGhlIHZhbHVlIG9mIHRoZSB2bWJ1ZmZlcidzIHZtYml0cyBhdCB0aGUgYmVnaW5uaW5n IG9mIHBydW5pbmcuIEl0IGlzCi0JICogY2xlYXJlZCBpZiBWTSBjb3JydXB0aW9uIGlzIGZvdW5k IGFuZCBjb3JyZWN0ZWQuCisJICogV2hldGhlciBvciBub3QgdGhlIHBhZ2Ugd2FzIG5ld2x5IHNl dCBhbGwtdmlzaWJsZSBhbmQgYWxsLWZyb3plbiBkdXJpbmcKKwkgKiBwaGFzZSBJIG9mIHZhY3V1 bWluZy4KIAkgKi8KLQl1aW50OAkJb2xkX3ZtYml0czsKKwlib29sCQluZXdseV9hbGxfdmlzaWJs ZTsKKwlib29sCQluZXdseV9hbGxfdmlzaWJsZV9mcm96ZW47CisJYm9vbAkJbmV3bHlfYWxsX2Zy b3plbjsKIAogCS8qCiAJICogV2hldGhlciBvciBub3QgdGhlIHBhZ2UgbWFrZXMgcmVsIHRydW5j YXRpb24gdW5zYWZlLiAgVGhpcyBpcyBzZXQgdG8KQEAgLTQ3Miw2ICs0NTgsMTMgQEAgZXh0ZXJu IHZvaWQgbG9nX2hlYXBfcHJ1bmVfYW5kX2ZyZWV6ZShSZWxhdGlvbiByZWxhdGlvbiwgQnVmZmVy IGJ1ZmZlciwKIC8qIGluIGhlYXAvdmFjdXVtbGF6eS5jICovCiBleHRlcm4gdm9pZCBoZWFwX3Zh Y3V1bV9yZWwoUmVsYXRpb24gcmVsLAogCQkJCQkJCWNvbnN0IFZhY3V1bVBhcmFtcyBwYXJhbXMs IEJ1ZmZlckFjY2Vzc1N0cmF0ZWd5IGJzdHJhdGVneSk7CisjaWZkZWYgVVNFX0FTU0VSVF9DSEVD S0lORworZXh0ZXJuIGJvb2wgaGVhcF9wYWdlX2lzX2FsbF92aXNpYmxlKFJlbGF0aW9uIHJlbCwg QnVmZmVyIGJ1ZiwKKwkJCQkJCQkJCSBHbG9iYWxWaXNTdGF0ZSAqdmlzdGVzdCwKKwkJCQkJCQkJ CSBib29sICphbGxfZnJvemVuLAorCQkJCQkJCQkJIFRyYW5zYWN0aW9uSWQgKnZpc2liaWxpdHlf Y3V0b2ZmX3hpZCwKKwkJCQkJCQkJCSBPZmZzZXROdW1iZXIgKmxvZ2dpbmdfb2ZmbnVtKTsKKyNl bmRpZgogCiAvKiBpbiBoZWFwL2hlYXBhbV92aXNpYmlsaXR5LmMgKi8KIGV4dGVybiBib29sIEhl YXBUdXBsZVNhdGlzZmllc1Zpc2liaWxpdHkoSGVhcFR1cGxlIGh0dXAsIFNuYXBzaG90IHNuYXBz aG90LAotLSAKMi40My4wCgo= --00000000000060fd69064d6b968a Content-Type: text/x-patch; charset="US-ASCII"; name="v41-0006-WAL-log-VM-setting-for-empty-pages-in-XLOG_HEAP2.patch" Content-Disposition: attachment; filename="v41-0006-WAL-log-VM-setting-for-empty-pages-in-XLOG_HEAP2.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmyagg1e5 RnJvbSA1NjE2Mzc2MzNjMTQxN2FmN2RlYTA1MDliYmJmNTVkY2EzYzJmZWFkIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBTYXQsIDI3IFNlcCAyMDI1IDExOjU1OjIxIC0wNDAwClN1YmplY3Q6IFtQ QVRDSCB2NDEgMDYvMTJdIFdBTCBsb2cgVk0gc2V0dGluZyBmb3IgZW1wdHkgcGFnZXMgaW4KIFhM T0dfSEVBUDJfUFJVTkVfVkFDVVVNX1NDQU4KCkFzIHBhcnQgb2YgcmVtb3ZpbmcgWExPR19IRUFQ Ml9WSVNJQkxFIHJlY29yZHMsIHBoYXNlIEkgb2YgVkFDVVVNIG5vdwptYXJrcyBlbXB0eSBwYWdl cyBhbGwtdmlzaWJsZSBpbiBhIFhMT0dfSEVBUDJfUFJVTkVfVkFDVVVNX1NDQU4gcmVjb3JkLgoK VGhpcyBoYXMgbm8gaW5kZXBlbmRlbnQgYmVuZWZpdCwgYnV0IGVtcHR5IHBhZ2VzIHdlcmUgdGhl IGxhc3QgdXNlciBvZgpYTE9HX0hFQVAyX1ZJU0lCTEUsIHNvIGlmIHdlIG1ha2UgdGhpcyBjaGFu Z2Ugd2UgY2FuIHJlbW92ZSBhbGwgb2YgdGhlClhMT0hfSEVBUDJfVklTSUJMRSBjb2RlLgoKQXV0 aG9yOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21haWwuY29tPgpSZXZpZXdl ZC1ieTogUm9iZXJ0IEhhYXMgPHJvYmVydG1oYWFzQGdtYWlsLmNvbT4KUmV2aWV3ZWQtYnk6IEFu ZHJlcyBGcmV1bmQgPGFuZHJlc0BhbmFyYXplbC5kZT4KUmV2aWV3ZWQtYnk6IENoYW8gTGkgPGxp LmV2YW4uY2hhb0BnbWFpbC5jb20+Ci0tLQogc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvdmFjdXVt bGF6eS5jIHwgMzUgKysrKysrKysrKysrKysrKysrKysrKystLS0tLQogMSBmaWxlIGNoYW5nZWQs IDI5IGluc2VydGlvbnMoKyksIDYgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tl bmQvYWNjZXNzL2hlYXAvdmFjdXVtbGF6eS5jIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvdmFj dXVtbGF6eS5jCmluZGV4IGQxNDRlMGY2NDJiLi5kZTkzYmZmNGE4ZSAxMDA2NDQKLS0tIGEvc3Jj L2JhY2tlbmQvYWNjZXNzL2hlYXAvdmFjdXVtbGF6eS5jCisrKyBiL3NyYy9iYWNrZW5kL2FjY2Vz cy9oZWFwL3ZhY3V1bWxhenkuYwpAQCAtMTkyOCw5ICsxOTI4LDEyIEBAIGxhenlfc2Nhbl9uZXdf b3JfZW1wdHkoTFZSZWxTdGF0ZSAqdmFjcmVsLCBCdWZmZXIgYnVmLCBCbG9ja051bWJlciBibGtu bywKIAkJICovCiAJCWlmICghUGFnZUlzQWxsVmlzaWJsZShwYWdlKSkKIAkJeworCQkJLyogTG9j ayB2bWJ1ZmZlciBiZWZvcmUgZW50ZXJpbmcgY3JpdGljYWwgc2VjdGlvbiAqLworCQkJTG9ja0J1 ZmZlcih2bWJ1ZmZlciwgQlVGRkVSX0xPQ0tfRVhDTFVTSVZFKTsKKwogCQkJU1RBUlRfQ1JJVF9T RUNUSU9OKCk7CiAKLQkJCS8qIG1hcmsgYnVmZmVyIGRpcnR5IGJlZm9yZSB3cml0aW5nIGEgV0FM IHJlY29yZCAqLworCQkJLyogTWFyayBidWZmZXIgZGlydHkgYmVmb3JlIHdyaXRpbmcgYW55IFdB TCByZWNvcmRzICovCiAJCQlNYXJrQnVmZmVyRGlydHkoYnVmKTsKIAogCQkJLyoKQEAgLTE5NDgs MTMgKzE5NTEsMzMgQEAgbGF6eV9zY2FuX25ld19vcl9lbXB0eShMVlJlbFN0YXRlICp2YWNyZWws IEJ1ZmZlciBidWYsIEJsb2NrTnVtYmVyIGJsa25vLAogCiAJCQlQYWdlU2V0QWxsVmlzaWJsZShw YWdlKTsKIAkJCVBhZ2VDbGVhclBydW5hYmxlKHBhZ2UpOwotCQkJdmlzaWJpbGl0eW1hcF9zZXQo dmFjcmVsLT5yZWwsIGJsa25vLCBidWYsCi0JCQkJCQkJICBJbnZhbGlkWExvZ1JlY1B0ciwKLQkJ CQkJCQkgIHZtYnVmZmVyLCBJbnZhbGlkVHJhbnNhY3Rpb25JZCwKLQkJCQkJCQkgIFZJU0lCSUxJ VFlNQVBfQUxMX1ZJU0lCTEUgfAotCQkJCQkJCSAgVklTSUJJTElUWU1BUF9BTExfRlJPWkVOKTsK KwkJCXZpc2liaWxpdHltYXBfc2V0X3ZtYml0cyhibGtubywKKwkJCQkJCQkJCSB2bWJ1ZmZlciwK KwkJCQkJCQkJCSBWSVNJQklMSVRZTUFQX0FMTF9WSVNJQkxFIHwKKwkJCQkJCQkJCSBWSVNJQklM SVRZTUFQX0FMTF9GUk9aRU4sCisJCQkJCQkJCQkgdmFjcmVsLT5yZWwtPnJkX2xvY2F0b3IpOwor CisJCQkvKgorCQkJICogRW1pdCBXQUwgZm9yIHNldHRpbmcgUERfQUxMX1ZJU0lCTEUgb24gdGhl IGhlYXAgcGFnZSBhbmQKKwkJCSAqIHNldHRpbmcgdGhlIFZNLgorCQkJICovCisJCQlpZiAoUmVs YXRpb25OZWVkc1dBTCh2YWNyZWwtPnJlbCkpCisJCQkJbG9nX2hlYXBfcHJ1bmVfYW5kX2ZyZWV6 ZSh2YWNyZWwtPnJlbCwgYnVmLAorCQkJCQkJCQkJCSAgdm1idWZmZXIsCisJCQkJCQkJCQkJICBW SVNJQklMSVRZTUFQX0FMTF9WSVNJQkxFIHwKKwkJCQkJCQkJCQkgIFZJU0lCSUxJVFlNQVBfQUxM X0ZST1pFTiwKKwkJCQkJCQkJCQkgIEludmFsaWRUcmFuc2FjdGlvbklkLCAvKiBjb25mbGljdCB4 aWQgKi8KKwkJCQkJCQkJCQkgIGZhbHNlLAkvKiBjbGVhbnVwIGxvY2sgKi8KKwkJCQkJCQkJCQkg IFBSVU5FX1ZBQ1VVTV9TQ0FOLAkvKiByZWFzb24gKi8KKwkJCQkJCQkJCQkgIE5VTEwsIDAsCisJ CQkJCQkJCQkJICBOVUxMLCAwLAorCQkJCQkJCQkJCSAgTlVMTCwgMCwKKwkJCQkJCQkJCQkgIE5V TEwsIDApOworCiAJCQlFTkRfQ1JJVF9TRUNUSU9OKCk7CiAKKwkJCUxvY2tCdWZmZXIodm1idWZm ZXIsIEJVRkZFUl9MT0NLX1VOTE9DSyk7CisKIAkJCS8qIENvdW50IHRoZSBuZXdseSBhbGwtZnJv emVuIHBhZ2VzIGZvciBsb2dnaW5nICovCiAJCQl2YWNyZWwtPm5ld19hbGxfdmlzaWJsZV9wYWdl cysrOwogCQkJdmFjcmVsLT5uZXdfYWxsX3Zpc2libGVfYWxsX2Zyb3plbl9wYWdlcysrOwotLSAK Mi40My4wCgo= --00000000000060fd69064d6b968a Content-Type: text/x-patch; charset="US-ASCII"; name="v41-0007-Remove-XLOG_HEAP2_VISIBLE-entirely.patch" Content-Disposition: attachment; filename="v41-0007-Remove-XLOG_HEAP2_VISIBLE-entirely.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmyaging6 RnJvbSA4YzYzYWRlNjk0Y2U4ZWQ1YmNiMmQ2N2MxNTIwM2YwYmQ0MWQ2YjNmIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBTYXQsIDI3IFNlcCAyMDI1IDExOjU1OjM2IC0wNDAwClN1YmplY3Q6IFtQ QVRDSCB2NDEgMDcvMTJdIFJlbW92ZSBYTE9HX0hFQVAyX1ZJU0lCTEUgZW50aXJlbHkKClRoZXJl IGFyZSBubyByZW1haW5pbmcgdXNlcnMgdGhhdCBlbWl0IFhMT0dfSEVBUDJfVklTSUJMRSByZWNv cmRzLCBzbyBpdApjYW4gYmUgcmVtb3ZlZC4gVGhpcyBpbmNsdWRlcyBkZWxldGluZyB0aGUgeGxf aGVhcF92aXNpYmxlIHN0cnVjdCBhbmQKYWxsIGZ1bmN0aW9ucyByZXNwb25zaWJsZSBmb3IgZW1p dHRpbmcgb3IgcmVwbGF5aW5nIFhMT0dfSEVBUDJfVklTSUJMRQpyZWNvcmRzLgoKQXV0aG9yOiBN ZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21haWwuY29tPgpSZXZpZXdlZC1ieTog QW5kcmV5IEJvcm9kaW4gPHg0bW1tQHlhbmRleC10ZWFtLnJ1PgpSZXZpZXdlZC1ieTogQW5kcmVz IEZyZXVuZCA8YW5kcmVzQGFuYXJhemVsLmRlPgpSZXZpZXdlZC1ieTogQ2hhbyBMaSA8bGkuZXZh bi5jaGFvQGdtYWlsLmNvbT4KLS0tCiBzcmMvYmFja2VuZC9hY2Nlc3MvY29tbW9uL2J1Zm1hc2su YyAgICAgIHwgICA1ICstCiBzcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9oZWFwYW0uYyAgICAgICAg IHwgIDU0ICstLS0tLS0tCiBzcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9oZWFwYW1feGxvZy5jICAg IHwgMTU2ICsrLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiBzcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9w cnVuZWhlYXAuYyAgICAgIHwgICA0ICstCiBzcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1s YXp5LmMgICAgIHwgIDE2ICstLQogc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvdmlzaWJpbGl0eW1h cC5jICB8IDE1MCArKysrKy0tLS0tLS0tLS0tLS0tLS0tCiBzcmMvYmFja2VuZC9hY2Nlc3Mvcm1n cmRlc2MvaGVhcGRlc2MuYyAgIHwgIDEwIC0tCiBzcmMvYmFja2VuZC9yZXBsaWNhdGlvbi9sb2dp Y2FsL2RlY29kZS5jIHwgICAxIC0KIHNyYy9iYWNrZW5kL3N0b3JhZ2UvaXBjL3N0YW5kYnkuYyAg ICAgICAgfCAgIDkgKy0KIHNyYy9pbmNsdWRlL2FjY2Vzcy9oZWFwYW1feGxvZy5oICAgICAgICAg fCAgMjEgKy0tCiBzcmMvaW5jbHVkZS9hY2Nlc3MvdmlzaWJpbGl0eW1hcC5oICAgICAgIHwgIDEz ICstCiBzcmMvaW5jbHVkZS9hY2Nlc3MvdmlzaWJpbGl0eW1hcGRlZnMuaCAgIHwgICA5IC0tCiBz cmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdCAgICAgICAgIHwgICAxIC0KIDEzIGZpbGVz IGNoYW5nZWQsIDYzIGluc2VydGlvbnMoKyksIDM4NiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQg YS9zcmMvYmFja2VuZC9hY2Nlc3MvY29tbW9uL2J1Zm1hc2suYyBiL3NyYy9iYWNrZW5kL2FjY2Vz cy9jb21tb24vYnVmbWFzay5jCmluZGV4IDhhNjdiZmExYWZmLi5kNjRjNDAzZjJmMCAxMDA2NDQK LS0tIGEvc3JjL2JhY2tlbmQvYWNjZXNzL2NvbW1vbi9idWZtYXNrLmMKKysrIGIvc3JjL2JhY2tl bmQvYWNjZXNzL2NvbW1vbi9idWZtYXNrLmMKQEAgLTU1LDkgKzU1LDggQEAgbWFza19wYWdlX2hp bnRfYml0cyhQYWdlIHBhZ2UpCiAJUGFnZUNsZWFySGFzRnJlZUxpbmVQb2ludGVycyhwYWdlKTsK IAogCS8qCi0JICogRHVyaW5nIHJlcGxheSwgaWYgdGhlIHBhZ2UgTFNOIGhhcyBhZHZhbmNlZCBw YXN0IG91ciBYTE9HIHJlY29yZCdzIExTTiwKLQkgKiB3ZSBkb24ndCBtYXJrIHRoZSBwYWdlIGFs bC12aXNpYmxlLiBTZWUgaGVhcF94bG9nX3Zpc2libGUoKSBmb3IKLQkgKiBkZXRhaWxzLgorCSAq IFhYWDogV2Ugc2hvdWxkIGNvbnNpZGVyIG5vdCBtYXNraW5nIFBEX0FMTF9WSVNJQkxFIGR1cmlu ZyBXQUwKKwkgKiBjb25zaXN0ZW5jeSBjaGVja2luZy4KIAkgKi8KIAlQYWdlQ2xlYXJBbGxWaXNp YmxlKHBhZ2UpOwogfQpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvaGVhcGFt LmMgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9oZWFwYW0uYwppbmRleCBlNWJkMDYyZGU3Ny4u MDQ0ZjM4NWU0NzcgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL2hlYXBhbS5j CisrKyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL2hlYXBhbS5jCkBAIC0yNTg5LDExICsyNTg5 LDExIEBAIGhlYXBfbXVsdGlfaW5zZXJ0KFJlbGF0aW9uIHJlbGF0aW9uLCBUdXBsZVRhYmxlU2xv dCAqKnNsb3RzLCBpbnQgbnR1cGxlcywKIAkJewogCQkJUGFnZVNldEFsbFZpc2libGUocGFnZSk7 CiAJCQlQYWdlQ2xlYXJQcnVuYWJsZShwYWdlKTsKLQkJCXZpc2liaWxpdHltYXBfc2V0X3ZtYml0 cyhCdWZmZXJHZXRCbG9ja051bWJlcihidWZmZXIpLAotCQkJCQkJCQkJIHZtYnVmZmVyLAotCQkJ CQkJCQkJIFZJU0lCSUxJVFlNQVBfQUxMX1ZJU0lCTEUgfAotCQkJCQkJCQkJIFZJU0lCSUxJVFlN QVBfQUxMX0ZST1pFTiwKLQkJCQkJCQkJCSByZWxhdGlvbi0+cmRfbG9jYXRvcik7CisJCQl2aXNp YmlsaXR5bWFwX3NldChCdWZmZXJHZXRCbG9ja051bWJlcihidWZmZXIpLAorCQkJCQkJCSAgdm1i dWZmZXIsCisJCQkJCQkJICBWSVNJQklMSVRZTUFQX0FMTF9WSVNJQkxFIHwKKwkJCQkJCQkgIFZJ U0lCSUxJVFlNQVBfQUxMX0ZST1pFTiwKKwkJCQkJCQkgIHJlbGF0aW9uLT5yZF9sb2NhdG9yKTsK IAkJfQogCiAJCS8qCkBAIC04ODg2LDUwICs4ODg2LDYgQEAgYm90dG9tdXBfc29ydF9hbmRfc2hy aW5rKFRNX0luZGV4RGVsZXRlT3AgKmRlbHN0YXRlKQogCXJldHVybiBuYmxvY2tzZmF2b3JhYmxl OwogfQogCi0vKgotICogUGVyZm9ybSBYTG9nSW5zZXJ0IGZvciBhIGhlYXAtdmlzaWJsZSBvcGVy YXRpb24uICAnYmxvY2snIGlzIHRoZSBibG9jawotICogYmVpbmcgbWFya2VkIGFsbC12aXNpYmxl LCBhbmQgdm1fYnVmZmVyIGlzIHRoZSBidWZmZXIgY29udGFpbmluZyB0aGUKLSAqIGNvcnJlc3Bv bmRpbmcgdmlzaWJpbGl0eSBtYXAgYmxvY2suICBCb3RoIHNob3VsZCBoYXZlIGFscmVhZHkgYmVl biBtb2RpZmllZAotICogYW5kIGRpcnRpZWQuCi0gKgotICogc25hcHNob3RDb25mbGljdEhvcml6 b24gY29tZXMgZnJvbSB0aGUgbGFyZ2VzdCB4bWluIG9uIHRoZSBwYWdlIGJlaW5nCi0gKiBtYXJr ZWQgYWxsLXZpc2libGUuICBSRURPIHJvdXRpbmUgdXNlcyBpdCB0byBnZW5lcmF0ZSByZWNvdmVy eSBjb25mbGljdHMuCi0gKgotICogSWYgY2hlY2tzdW1zIG9yIHdhbF9sb2dfaGludHMgYXJlIGVu YWJsZWQsIHdlIG1heSBhbHNvIGdlbmVyYXRlIGEgZnVsbC1wYWdlCi0gKiBpbWFnZSBvZiBoZWFw X2J1ZmZlci4gT3RoZXJ3aXNlLCB3ZSBvcHRpbWl6ZSBhd2F5IHRoZSBGUEkgKGJ5IHNwZWNpZnlp bmcKLSAqIFJFR0JVRl9OT19JTUFHRSBmb3IgdGhlIGhlYXAgYnVmZmVyKSwgaW4gd2hpY2ggY2Fz ZSB0aGUgY2FsbGVyIHNob3VsZCAqbm90KgotICogdXBkYXRlIHRoZSBoZWFwIHBhZ2UncyBMU04u Ci0gKi8KLVhMb2dSZWNQdHIKLWxvZ19oZWFwX3Zpc2libGUoUmVsYXRpb24gcmVsLCBCdWZmZXIg aGVhcF9idWZmZXIsIEJ1ZmZlciB2bV9idWZmZXIsCi0JCQkJIFRyYW5zYWN0aW9uSWQgc25hcHNo b3RDb25mbGljdEhvcml6b24sIHVpbnQ4IHZtZmxhZ3MpCi17Ci0JeGxfaGVhcF92aXNpYmxlIHhs cmVjOwotCVhMb2dSZWNQdHIJcmVjcHRyOwotCXVpbnQ4CQlmbGFnczsKLQotCUFzc2VydChCdWZm ZXJJc1ZhbGlkKGhlYXBfYnVmZmVyKSk7Ci0JQXNzZXJ0KEJ1ZmZlcklzVmFsaWQodm1fYnVmZmVy KSk7Ci0KLQl4bHJlYy5zbmFwc2hvdENvbmZsaWN0SG9yaXpvbiA9IHNuYXBzaG90Q29uZmxpY3RI b3Jpem9uOwotCXhscmVjLmZsYWdzID0gdm1mbGFnczsKLQlpZiAoUmVsYXRpb25Jc0FjY2Vzc2li bGVJbkxvZ2ljYWxEZWNvZGluZyhyZWwpKQotCQl4bHJlYy5mbGFncyB8PSBWSVNJQklMSVRZTUFQ X1hMT0dfQ0FUQUxPR19SRUw7Ci0JWExvZ0JlZ2luSW5zZXJ0KCk7Ci0JWExvZ1JlZ2lzdGVyRGF0 YSgmeGxyZWMsIFNpemVPZkhlYXBWaXNpYmxlKTsKLQotCVhMb2dSZWdpc3RlckJ1ZmZlcigwLCB2 bV9idWZmZXIsIDApOwotCi0JZmxhZ3MgPSBSRUdCVUZfU1RBTkRBUkQ7Ci0JaWYgKCFYTG9nSGlu dEJpdElzTmVlZGVkKCkpCi0JCWZsYWdzIHw9IFJFR0JVRl9OT19JTUFHRTsKLQlYTG9nUmVnaXN0 ZXJCdWZmZXIoMSwgaGVhcF9idWZmZXIsIGZsYWdzKTsKLQotCXJlY3B0ciA9IFhMb2dJbnNlcnQo Uk1fSEVBUDJfSUQsIFhMT0dfSEVBUDJfVklTSUJMRSk7Ci0KLQlyZXR1cm4gcmVjcHRyOwotfQot CiAvKgogICogUGVyZm9ybSBYTG9nSW5zZXJ0IGZvciBhIGhlYXAtdXBkYXRlIG9wZXJhdGlvbi4g IENhbGxlciBtdXN0IGFscmVhZHkKICAqIGhhdmUgbW9kaWZpZWQgdGhlIGJ1ZmZlcihzKSBhbmQg bWFya2VkIHRoZW0gZGlydHkuCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9o ZWFwYW1feGxvZy5jIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvaGVhcGFtX3hsb2cuYwppbmRl eCAxZGE3NzRjMTUzNi4uMTMwMmJiMTNlMTggMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2FjY2Vz cy9oZWFwL2hlYXBhbV94bG9nLmMKKysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvaGVhcGFt X3hsb2cuYwpAQCAtMjM5LDcgKzIzOSw3IEBAIGhlYXBfeGxvZ19wcnVuZV9mcmVlemUoWExvZ1Jl YWRlclN0YXRlICpyZWNvcmQpCiAJCWlmIChQYWdlSXNOZXcodm1wYWdlKSkKIAkJCVBhZ2VJbml0 KHZtcGFnZSwgQkxDS1NaLCAwKTsKIAotCQl2aXNpYmlsaXR5bWFwX3NldF92bWJpdHMoYmxrbm8s IHZtYnVmZmVyLCB2bWZsYWdzLCBybG9jYXRvcik7CisJCXZpc2liaWxpdHltYXBfc2V0KGJsa25v LCB2bWJ1ZmZlciwgdm1mbGFncywgcmxvY2F0b3IpOwogCiAJCUFzc2VydChCdWZmZXJJc0RpcnR5 KHZtYnVmZmVyKSk7CiAJCVBhZ2VTZXRMU04odm1wYWdlLCBsc24pOwpAQCAtMjUyLDE0MyArMjUy LDYgQEAgaGVhcF94bG9nX3BydW5lX2ZyZWV6ZShYTG9nUmVhZGVyU3RhdGUgKnJlY29yZCkKIAkJ WExvZ1JlY29yZFBhZ2VXaXRoRnJlZVNwYWNlKHJsb2NhdG9yLCBibGtubywgZnJlZXNwYWNlKTsK IH0KIAotLyoKLSAqIFJlcGxheSBYTE9HX0hFQVAyX1ZJU0lCTEUgcmVjb3Jkcy4KLSAqCi0gKiBU aGUgY3JpdGljYWwgaW50ZWdyaXR5IHJlcXVpcmVtZW50IGhlcmUgaXMgdGhhdCB3ZSBtdXN0IG5l dmVyIGVuZCB1cCB3aXRoCi0gKiBhIHNpdHVhdGlvbiB3aGVyZSB0aGUgdmlzaWJpbGl0eSBtYXAg Yml0IGlzIHNldCwgYW5kIHRoZSBwYWdlLWxldmVsCi0gKiBQRF9BTExfVklTSUJMRSBiaXQgaXMg Y2xlYXIuICBJZiB0aGF0IHdlcmUgdG8gb2NjdXIsIHRoZW4gYSBzdWJzZXF1ZW50Ci0gKiBwYWdl IG1vZGlmaWNhdGlvbiB3b3VsZCBmYWlsIHRvIGNsZWFyIHRoZSB2aXNpYmlsaXR5IG1hcCBiaXQu Ci0gKi8KLXN0YXRpYyB2b2lkCi1oZWFwX3hsb2dfdmlzaWJsZShYTG9nUmVhZGVyU3RhdGUgKnJl Y29yZCkKLXsKLQlYTG9nUmVjUHRyCWxzbiA9IHJlY29yZC0+RW5kUmVjUHRyOwotCXhsX2hlYXBf dmlzaWJsZSAqeGxyZWMgPSAoeGxfaGVhcF92aXNpYmxlICopIFhMb2dSZWNHZXREYXRhKHJlY29y ZCk7Ci0JQnVmZmVyCQl2bWJ1ZmZlciA9IEludmFsaWRCdWZmZXI7Ci0JQnVmZmVyCQlidWZmZXI7 Ci0JUGFnZQkJcGFnZTsKLQlSZWxGaWxlTG9jYXRvciBybG9jYXRvcjsKLQlCbG9ja051bWJlciBi bGtubzsKLQlYTG9nUmVkb0FjdGlvbiBhY3Rpb247Ci0KLQlBc3NlcnQoKHhscmVjLT5mbGFncyAm IFZJU0lCSUxJVFlNQVBfWExPR19WQUxJRF9CSVRTKSA9PSB4bHJlYy0+ZmxhZ3MpOwotCi0JWExv Z1JlY0dldEJsb2NrVGFnKHJlY29yZCwgMSwgJnJsb2NhdG9yLCBOVUxMLCAmYmxrbm8pOwotCi0J LyoKLQkgKiBJZiB0aGVyZSBhcmUgYW55IEhvdCBTdGFuZGJ5IHRyYW5zYWN0aW9ucyBydW5uaW5n IHRoYXQgaGF2ZSBhbiB4bWluCi0JICogaG9yaXpvbiBvbGQgZW5vdWdoIHRoYXQgdGhpcyBwYWdl IGlzbid0IGFsbC12aXNpYmxlIGZvciB0aGVtLCB0aGV5Ci0JICogbWlnaHQgaW5jb3JyZWN0bHkg ZGVjaWRlIHRoYXQgYW4gaW5kZXgtb25seSBzY2FuIGNhbiBza2lwIGEgaGVhcCBmZXRjaC4KLQkg KgotCSAqIE5COiBJdCBtaWdodCBiZSBiZXR0ZXIgdG8gdGhyb3cgc29tZSBraW5kIG9mICJzb2Z0 IiBjb25mbGljdCBoZXJlIHRoYXQKLQkgKiBmb3JjZXMgYW55IGluZGV4LW9ubHkgc2NhbiB0aGF0 IGlzIGluIGZsaWdodCB0byBwZXJmb3JtIGhlYXAgZmV0Y2hlcywKLQkgKiByYXRoZXIgdGhhbiBr aWxsaW5nIHRoZSB0cmFuc2FjdGlvbiBvdXRyaWdodC4KLQkgKi8KLQlpZiAoSW5Ib3RTdGFuZGJ5 KQotCQlSZXNvbHZlUmVjb3ZlcnlDb25mbGljdFdpdGhTbmFwc2hvdCh4bHJlYy0+c25hcHNob3RD b25mbGljdEhvcml6b24sCi0JCQkJCQkJCQkJCXhscmVjLT5mbGFncyAmIFZJU0lCSUxJVFlNQVBf WExPR19DQVRBTE9HX1JFTCwKLQkJCQkJCQkJCQkJcmxvY2F0b3IpOwotCi0JLyoKLQkgKiBSZWFk IHRoZSBoZWFwIHBhZ2UsIGlmIGl0IHN0aWxsIGV4aXN0cy4gSWYgdGhlIGhlYXAgZmlsZSBoYXMg ZHJvcHBlZCBvcgotCSAqIHRydW5jYXRlZCBsYXRlciBpbiByZWNvdmVyeSwgd2UgZG9uJ3QgbmVl ZCB0byB1cGRhdGUgdGhlIHBhZ2UsIGJ1dCB3ZSdkCi0JICogYmV0dGVyIHN0aWxsIHVwZGF0ZSB0 aGUgdmlzaWJpbGl0eSBtYXAuCi0JICovCi0JYWN0aW9uID0gWExvZ1JlYWRCdWZmZXJGb3JSZWRv KHJlY29yZCwgMSwgJmJ1ZmZlcik7Ci0JaWYgKGFjdGlvbiA9PSBCTEtfTkVFRFNfUkVETykKLQl7 Ci0JCS8qCi0JCSAqIFdlIGRvbid0IGJ1bXAgdGhlIExTTiBvZiB0aGUgaGVhcCBwYWdlIHdoZW4g c2V0dGluZyB0aGUgdmlzaWJpbGl0eQotCQkgKiBtYXAgYml0ICh1bmxlc3MgY2hlY2tzdW1zIG9y IHdhbF9oaW50X2JpdHMgaXMgZW5hYmxlZCwgaW4gd2hpY2gKLQkJICogY2FzZSB3ZSBtdXN0KS4g VGhpcyBleHBvc2VzIHVzIHRvIHRvcm4gcGFnZSBoYXphcmRzLCBidXQgc2luY2UKLQkJICogd2Un cmUgbm90IGluc3BlY3RpbmcgdGhlIGV4aXN0aW5nIHBhZ2UgY29udGVudHMgaW4gYW55IHdheSwg d2UKLQkJICogZG9uJ3QgY2FyZS4KLQkJICovCi0JCXBhZ2UgPSBCdWZmZXJHZXRQYWdlKGJ1ZmZl cik7Ci0KLQkJUGFnZVNldEFsbFZpc2libGUocGFnZSk7Ci0JCVBhZ2VDbGVhclBydW5hYmxlKHBh Z2UpOwotCi0JCWlmIChYTG9nSGludEJpdElzTmVlZGVkKCkpCi0JCQlQYWdlU2V0TFNOKHBhZ2Us IGxzbik7Ci0KLQkJTWFya0J1ZmZlckRpcnR5KGJ1ZmZlcik7Ci0JfQotCWVsc2UgaWYgKGFjdGlv biA9PSBCTEtfUkVTVE9SRUQpCi0JewotCQkvKgotCQkgKiBJZiBoZWFwIGJsb2NrIHdhcyBiYWNr ZWQgdXAsIHdlIGFscmVhZHkgcmVzdG9yZWQgaXQgYW5kIHRoZXJlJ3MKLQkJICogbm90aGluZyBt b3JlIHRvIGRvLiAoVGhpcyBjYW4gb25seSBoYXBwZW4gd2l0aCBjaGVja3N1bXMgb3IKLQkJICog d2FsX2xvZ19oaW50cyBlbmFibGVkLikKLQkJICovCi0JfQotCi0JaWYgKEJ1ZmZlcklzVmFsaWQo YnVmZmVyKSkKLQl7Ci0JCVNpemUJCXNwYWNlID0gUGFnZUdldEZyZWVTcGFjZShCdWZmZXJHZXRQ YWdlKGJ1ZmZlcikpOwotCi0JCVVubG9ja1JlbGVhc2VCdWZmZXIoYnVmZmVyKTsKLQotCQkvKgot CQkgKiBTaW5jZSBGU00gaXMgbm90IFdBTC1sb2dnZWQgYW5kIG9ubHkgdXBkYXRlZCBoZXVyaXN0 aWNhbGx5LCBpdAotCQkgKiBlYXNpbHkgYmVjb21lcyBzdGFsZSBpbiBzdGFuZGJ5cy4gIElmIHRo ZSBzdGFuZGJ5IGlzIGxhdGVyIHByb21vdGVkCi0JCSAqIGFuZCBydW5zIFZBQ1VVTSwgaXQgd2ls bCBza2lwIHVwZGF0aW5nIGluZGl2aWR1YWwgZnJlZSBzcGFjZQotCQkgKiBmaWd1cmVzIGZvciBw YWdlcyB0aGF0IGJlY2FtZSBhbGwtdmlzaWJsZSAob3IgYWxsLWZyb3plbiwgZGVwZW5kaW5nCi0J CSAqIG9uIHRoZSB2YWN1dW0gbW9kZSwpIHdoaWNoIGlzIHRyb3VibGVzb21lIHdoZW4gRnJlZVNw YWNlTWFwVmFjdXVtCi0JCSAqIHByb3BhZ2F0ZXMgdG9vIG9wdGltaXN0aWMgZnJlZSBzcGFjZSB2 YWx1ZXMgdG8gdXBwZXIgRlNNIGxheWVyczsKLQkJICogbGF0ZXIgaW5zZXJ0ZXJzIHRyeSB0byB1 c2Ugc3VjaCBwYWdlcyBvbmx5IHRvIGZpbmQgb3V0IHRoYXQgdGhleQotCQkgKiBhcmUgdW51c2Fi bGUuICBUaGlzIGNhbiBjYXVzZSBsb25nIHN0YWxscyB3aGVuIHRoZXJlIGFyZSBtYW55IHN1Y2gK LQkJICogcGFnZXMuCi0JCSAqCi0JCSAqIEZvcmVzdGFsbCB0aG9zZSBwcm9ibGVtcyBieSB1cGRh dGluZyBGU00ncyBpZGVhIGFib3V0IGEgcGFnZSB0aGF0Ci0JCSAqIGlzIGJlY29taW5nIGFsbC12 aXNpYmxlIG9yIGFsbC1mcm96ZW4uCi0JCSAqCi0JCSAqIERvIHRoaXMgcmVnYXJkbGVzcyBvZiBh IGZ1bGwtcGFnZSBpbWFnZSBiZWluZyBhcHBsaWVkLCBzaW5jZSB0aGUKLQkJICogRlNNIGRhdGEg aXMgbm90IGluIHRoZSBwYWdlIGFueXdheS4KLQkJICovCi0JCWlmICh4bHJlYy0+ZmxhZ3MgJiBW SVNJQklMSVRZTUFQX1ZBTElEX0JJVFMpCi0JCQlYTG9nUmVjb3JkUGFnZVdpdGhGcmVlU3BhY2Uo cmxvY2F0b3IsIGJsa25vLCBzcGFjZSk7Ci0JfQotCi0JLyoKLQkgKiBFdmVuIGlmIHdlIHNraXBw ZWQgdGhlIGhlYXAgcGFnZSB1cGRhdGUgZHVlIHRvIHRoZSBMU04gaW50ZXJsb2NrLCBpdCdzCi0J ICogc3RpbGwgc2FmZSB0byB1cGRhdGUgdGhlIHZpc2liaWxpdHkgbWFwLiAgQW55IFdBTCByZWNv cmQgdGhhdCBjbGVhcnMKLQkgKiB0aGUgdmlzaWJpbGl0eSBtYXAgYml0IGRvZXMgc28gYmVmb3Jl IGNoZWNraW5nIHRoZSBwYWdlIExTTiwgc28gYW55Ci0JICogYml0cyB0aGF0IG5lZWQgdG8gYmUg Y2xlYXJlZCB3aWxsIHN0aWxsIGJlIGNsZWFyZWQuCi0JICovCi0JaWYgKFhMb2dSZWFkQnVmZmVy Rm9yUmVkb0V4dGVuZGVkKHJlY29yZCwgMCwgUkJNX1pFUk9fT05fRVJST1IsIGZhbHNlLAotCQkJ CQkJCQkJICAmdm1idWZmZXIpID09IEJMS19ORUVEU19SRURPKQotCXsKLQkJUGFnZQkJdm1wYWdl ID0gQnVmZmVyR2V0UGFnZSh2bWJ1ZmZlcik7Ci0JCVJlbGF0aW9uCXJlbG47Ci0JCXVpbnQ4CQl2 bWJpdHM7Ci0KLQkJLyogaW5pdGlhbGl6ZSB0aGUgcGFnZSBpZiBpdCB3YXMgcmVhZCBhcyB6ZXJv cyAqLwotCQlpZiAoUGFnZUlzTmV3KHZtcGFnZSkpCi0JCQlQYWdlSW5pdCh2bXBhZ2UsIEJMQ0tT WiwgMCk7Ci0KLQkJLyogcmVtb3ZlIFZJU0lCSUxJVFlNQVBfWExPR18qICovCi0JCXZtYml0cyA9 IHhscmVjLT5mbGFncyAmIFZJU0lCSUxJVFlNQVBfVkFMSURfQklUUzsKLQotCQkvKgotCQkgKiBY TG9nUmVhZEJ1ZmZlckZvclJlZG9FeHRlbmRlZCBsb2NrZWQgdGhlIGJ1ZmZlci4gQnV0Ci0JCSAq IHZpc2liaWxpdHltYXBfc2V0IHdpbGwgaGFuZGxlIGxvY2tpbmcgaXRzZWxmLgotCQkgKi8KLQkJ TG9ja0J1ZmZlcih2bWJ1ZmZlciwgQlVGRkVSX0xPQ0tfVU5MT0NLKTsKLQotCQlyZWxuID0gQ3Jl YXRlRmFrZVJlbGNhY2hlRW50cnkocmxvY2F0b3IpOwotCi0JCXZpc2liaWxpdHltYXBfc2V0KHJl bG4sIGJsa25vLCBJbnZhbGlkQnVmZmVyLCBsc24sIHZtYnVmZmVyLAotCQkJCQkJICB4bHJlYy0+ c25hcHNob3RDb25mbGljdEhvcml6b24sIHZtYml0cyk7Ci0KLQkJUmVsZWFzZUJ1ZmZlcih2bWJ1 ZmZlcik7Ci0JCUZyZWVGYWtlUmVsY2FjaGVFbnRyeShyZWxuKTsKLQl9Ci0JZWxzZSBpZiAoQnVm ZmVySXNWYWxpZCh2bWJ1ZmZlcikpCi0JCVVubG9ja1JlbGVhc2VCdWZmZXIodm1idWZmZXIpOwot fQotCiAvKgogICogR2l2ZW4gYW4gImluZm9iaXRzIiBmaWVsZCBmcm9tIGFuIFhMb2cgcmVjb3Jk LCBzZXQgdGhlIGNvcnJlY3QgYml0cyBpbiB0aGUKICAqIGdpdmVuIGluZm9tYXNrIGFuZCBpbmZv bWFzazIgZm9yIHRoZSB0dXBsZSB0b3VjaGVkIGJ5IHRoZSByZWNvcmQuCkBAIC03NjksOCArNjMy LDggQEAgaGVhcF94bG9nX211bHRpX2luc2VydChYTG9nUmVhZGVyU3RhdGUgKnJlY29yZCkKIAkg KgogCSAqIER1cmluZyByZWNvdmVyeSwgaG93ZXZlciwgbm8gY29uY3VycmVudCB3cml0ZXJzIGV4 aXN0LiBUaGVyZWZvcmUsCiAJICogdXBkYXRpbmcgdGhlIFZNIHdpdGhvdXQgaG9sZGluZyB0aGUg aGVhcCBwYWdlIGxvY2sgaXMgc2FmZSBlbm91Z2guIFRoaXMKLQkgKiBzYW1lIGFwcHJvYWNoIGlz IHRha2VuIHdoZW4gcmVwbGF5aW5nIHhsX2hlYXBfdmlzaWJsZSByZWNvcmRzIChzZWUKLQkgKiBo ZWFwX3hsb2dfdmlzaWJsZSgpKS4KKwkgKiBzYW1lIGFwcHJvYWNoIGlzIHRha2VuIHdoZW4gcmVw bGF5aW5nIFhMT0dfSEVBUDJfUFJVTkUqIHJlY29yZHMgKHNlZQorCSAqIGhlYXBfeGxvZ19wcnVu ZV9mcmVlemUoKSkuCiAJICovCiAJaWYgKCh4bHJlYy0+ZmxhZ3MgJiBYTEhfSU5TRVJUX0FMTF9G Uk9aRU5fU0VUKSAmJgogCQlYTG9nUmVhZEJ1ZmZlckZvclJlZG9FeHRlbmRlZChyZWNvcmQsIDEs IFJCTV9aRVJPX09OX0VSUk9SLCBmYWxzZSwKQEAgLTc4MiwxMSArNjQ1LDExIEBAIGhlYXBfeGxv Z19tdWx0aV9pbnNlcnQoWExvZ1JlYWRlclN0YXRlICpyZWNvcmQpCiAJCWlmIChQYWdlSXNOZXco dm1wYWdlKSkKIAkJCVBhZ2VJbml0KHZtcGFnZSwgQkxDS1NaLCAwKTsKIAotCQl2aXNpYmlsaXR5 bWFwX3NldF92bWJpdHMoYmxrbm8sCi0JCQkJCQkJCSB2bWJ1ZmZlciwKLQkJCQkJCQkJIFZJU0lC SUxJVFlNQVBfQUxMX1ZJU0lCTEUgfAotCQkJCQkJCQkgVklTSUJJTElUWU1BUF9BTExfRlJPWkVO LAotCQkJCQkJCQkgcmxvY2F0b3IpOworCQl2aXNpYmlsaXR5bWFwX3NldChibGtubywKKwkJCQkJ CSAgdm1idWZmZXIsCisJCQkJCQkgIFZJU0lCSUxJVFlNQVBfQUxMX1ZJU0lCTEUgfAorCQkJCQkJ ICBWSVNJQklMSVRZTUFQX0FMTF9GUk9aRU4sCisJCQkJCQkgIHJsb2NhdG9yKTsKIAogCQlBc3Nl cnQoQnVmZmVySXNEaXJ0eSh2bWJ1ZmZlcikpOwogCQlQYWdlU2V0TFNOKHZtcGFnZSwgbHNuKTsK QEAgLTEzNjksOSArMTIzMiw2IEBAIGhlYXAyX3JlZG8oWExvZ1JlYWRlclN0YXRlICpyZWNvcmQp CiAJCWNhc2UgWExPR19IRUFQMl9QUlVORV9WQUNVVU1fQ0xFQU5VUDoKIAkJCWhlYXBfeGxvZ19w cnVuZV9mcmVlemUocmVjb3JkKTsKIAkJCWJyZWFrOwotCQljYXNlIFhMT0dfSEVBUDJfVklTSUJM RToKLQkJCWhlYXBfeGxvZ192aXNpYmxlKHJlY29yZCk7Ci0JCQlicmVhazsKIAkJY2FzZSBYTE9H X0hFQVAyX01VTFRJX0lOU0VSVDoKIAkJCWhlYXBfeGxvZ19tdWx0aV9pbnNlcnQocmVjb3JkKTsK IAkJCWJyZWFrOwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvcHJ1bmVoZWFw LmMgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9wcnVuZWhlYXAuYwppbmRleCBkZDhhYzE3M2Nh MS4uZmFjNzE5NGRjYmEgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3BydW5l aGVhcC5jCisrKyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3BydW5laGVhcC5jCkBAIC0xMjUz LDggKzEyNTMsOCBAQCBoZWFwX3BhZ2VfcHJ1bmVfYW5kX2ZyZWV6ZShQcnVuZUZyZWV6ZVBhcmFt cyAqcGFyYW1zLAogCQkJICovCiAJCQlQYWdlU2V0QWxsVmlzaWJsZShwcnN0YXRlLnBhZ2UpOwog CQkJUGFnZUNsZWFyUHJ1bmFibGUocHJzdGF0ZS5wYWdlKTsKLQkJCXZpc2liaWxpdHltYXBfc2V0 X3ZtYml0cyhwcnN0YXRlLmJsb2NrLCBwcnN0YXRlLnZtYnVmZmVyLCBwcnN0YXRlLm5ld192bWJp dHMsCi0JCQkJCQkJCQkgcHJzdGF0ZS5yZWxhdGlvbi0+cmRfbG9jYXRvcik7CisJCQl2aXNpYmls aXR5bWFwX3NldChwcnN0YXRlLmJsb2NrLCBwcnN0YXRlLnZtYnVmZmVyLCBwcnN0YXRlLm5ld192 bWJpdHMsCisJCQkJCQkJICBwcnN0YXRlLnJlbGF0aW9uLT5yZF9sb2NhdG9yKTsKIAkJfQogCiAJ CU1hcmtCdWZmZXJEaXJ0eShwcnN0YXRlLmJ1ZmZlcik7CmRpZmYgLS1naXQgYS9zcmMvYmFja2Vu ZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1 dW1sYXp5LmMKaW5kZXggZGU5M2JmZjRhOGUuLjQ2MWZkZjRlZDgzIDEwMDY0NAotLS0gYS9zcmMv YmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMKKysrIGIvc3JjL2JhY2tlbmQvYWNjZXNz L2hlYXAvdmFjdXVtbGF6eS5jCkBAIC0xOTUxLDExICsxOTUxLDExIEBAIGxhenlfc2Nhbl9uZXdf b3JfZW1wdHkoTFZSZWxTdGF0ZSAqdmFjcmVsLCBCdWZmZXIgYnVmLCBCbG9ja051bWJlciBibGtu bywKIAogCQkJUGFnZVNldEFsbFZpc2libGUocGFnZSk7CiAJCQlQYWdlQ2xlYXJQcnVuYWJsZShw YWdlKTsKLQkJCXZpc2liaWxpdHltYXBfc2V0X3ZtYml0cyhibGtubywKLQkJCQkJCQkJCSB2bWJ1 ZmZlciwKLQkJCQkJCQkJCSBWSVNJQklMSVRZTUFQX0FMTF9WSVNJQkxFIHwKLQkJCQkJCQkJCSBW SVNJQklMSVRZTUFQX0FMTF9GUk9aRU4sCi0JCQkJCQkJCQkgdmFjcmVsLT5yZWwtPnJkX2xvY2F0 b3IpOworCQkJdmlzaWJpbGl0eW1hcF9zZXQoYmxrbm8sCisJCQkJCQkJICB2bWJ1ZmZlciwKKwkJ CQkJCQkgIFZJU0lCSUxJVFlNQVBfQUxMX1ZJU0lCTEUgfAorCQkJCQkJCSAgVklTSUJJTElUWU1B UF9BTExfRlJPWkVOLAorCQkJCQkJCSAgdmFjcmVsLT5yZWwtPnJkX2xvY2F0b3IpOwogCiAJCQkv KgogCQkJICogRW1pdCBXQUwgZm9yIHNldHRpbmcgUERfQUxMX1ZJU0lCTEUgb24gdGhlIGhlYXAg cGFnZSBhbmQKQEAgLTI4MzMsOSArMjgzMyw5IEBAIGxhenlfdmFjdXVtX2hlYXBfcGFnZShMVlJl bFN0YXRlICp2YWNyZWwsIEJsb2NrTnVtYmVyIGJsa25vLCBCdWZmZXIgYnVmZmVyLAogCQkgKi8K IAkJUGFnZVNldEFsbFZpc2libGUocGFnZSk7CiAJCVBhZ2VDbGVhclBydW5hYmxlKHBhZ2UpOwot CQl2aXNpYmlsaXR5bWFwX3NldF92bWJpdHMoYmxrbm8sCi0JCQkJCQkJCSB2bWJ1ZmZlciwgdm1m bGFncywKLQkJCQkJCQkJIHZhY3JlbC0+cmVsLT5yZF9sb2NhdG9yKTsKKwkJdmlzaWJpbGl0eW1h cF9zZXQoYmxrbm8sCisJCQkJCQkgIHZtYnVmZmVyLCB2bWZsYWdzLAorCQkJCQkJICB2YWNyZWwt PnJlbC0+cmRfbG9jYXRvcik7CiAJCWNvbmZsaWN0X3hpZCA9IG5ld2VzdF9saXZlX3hpZDsKIAl9 CiAKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3Zpc2liaWxpdHltYXAuYyBi L3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3Zpc2liaWxpdHltYXAuYwppbmRleCBlMjFiOTYyODFh Ni4uMjFlODljMzhmMGEgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3Zpc2li aWxpdHltYXAuYworKysgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92aXNpYmlsaXR5bWFwLmMK QEAgLTE0LDggKzE0LDcgQEAKICAqCQl2aXNpYmlsaXR5bWFwX2NsZWFyICAtIGNsZWFyIGJpdHMg Zm9yIG9uZSBwYWdlIGluIHRoZSB2aXNpYmlsaXR5IG1hcAogICoJCXZpc2liaWxpdHltYXBfcGlu CSAtIHBpbiBhIG1hcCBwYWdlIGZvciBzZXR0aW5nIGEgYml0CiAgKgkJdmlzaWJpbGl0eW1hcF9w aW5fb2sgLSBjaGVjayB3aGV0aGVyIGNvcnJlY3QgbWFwIHBhZ2UgaXMgYWxyZWFkeSBwaW5uZWQK LSAqCQl2aXNpYmlsaXR5bWFwX3NldAkgLSBzZXQgYml0KHMpIGluIGEgcHJldmlvdXNseSBwaW5u ZWQgcGFnZSBhbmQgbG9nCi0gKgkJdmlzaWJpbGl0eW1hcF9zZXRfdm1iaXRzIC0gc2V0IGJpdChz KSBpbiBhIHBpbm5lZCBwYWdlCisgKgkJdmlzaWJpbGl0eW1hcF9zZXQJIC0gc2V0IGJpdChzKSBp biBhIHByZXZpb3VzbHkgcGlubmVkIHBhZ2UKICAqCQl2aXNpYmlsaXR5bWFwX2dldF9zdGF0dXMg LSBnZXQgc3RhdHVzIG9mIGJpdHMKICAqCQl2aXNpYmlsaXR5bWFwX2NvdW50ICAtIGNvdW50IG51 bWJlciBvZiBiaXRzIHNldCBpbiB2aXNpYmlsaXR5IG1hcAogICoJCXZpc2liaWxpdHltYXBfcHJl cGFyZV90cnVuY2F0ZSAtCkBAIC0zNSwyMSArMzQsMzEgQEAKICAqIGlzIHNldCwgd2Uga25vdyB0 aGUgY29uZGl0aW9uIGlzIHRydWUsIGJ1dCBpZiBhIGJpdCBpcyBub3Qgc2V0LCBpdCBtaWdodCBv cgogICogbWlnaHQgbm90IGJlIHRydWUuCiAgKgotICogQ2xlYXJpbmcgdmlzaWJpbGl0eSBtYXAg Yml0cyBpcyBub3Qgc2VwYXJhdGVseSBXQUwtbG9nZ2VkLiAgVGhlIGNhbGxlcnMKLSAqIG11c3Qg bWFrZSBzdXJlIHRoYXQgd2hlbmV2ZXIgYSBiaXQgaXMgY2xlYXJlZCwgdGhlIGJpdCBpcyBjbGVh cmVkIG9uIFdBTAotICogcmVwbGF5IG9mIHRoZSB1cGRhdGluZyBvcGVyYXRpb24gYXMgd2VsbC4K LSAqCi0gKiBXaGVuIHdlICpzZXQqIGEgdmlzaWJpbGl0eSBtYXAgZHVyaW5nIFZBQ1VVTSwgd2Ug bXVzdCB3cml0ZSBXQUwuICBUaGlzIG1heQotICogc2VlbSBjb3VudGVyaW50dWl0aXZlLCBzaW5j ZSB0aGUgYml0IGlzIGJhc2ljYWxseSBhIGhpbnQ6IGlmIGl0IGlzIGNsZWFyLAotICogaXQgbWF5 IHN0aWxsIGJlIHRoZSBjYXNlIHRoYXQgZXZlcnkgdHVwbGUgb24gdGhlIHBhZ2UgaXMgdmlzaWJs ZSB0byBhbGwKLSAqIHRyYW5zYWN0aW9uczsgd2UganVzdCBkb24ndCBrbm93IHRoYXQgZm9yIGNl cnRhaW4uICBUaGUgZGlmZmljdWx0eSBpcyB0aGF0Ci0gKiB0aGVyZSBhcmUgdHdvIGJpdHMgd2hp Y2ggYXJlIHR5cGljYWxseSBzZXQgdG9nZXRoZXI6IHRoZSBQRF9BTExfVklTSUJMRSBiaXQKLSAq IG9uIHRoZSBwYWdlIGl0c2VsZiwgYW5kIHRoZSB2aXNpYmlsaXR5IG1hcCBiaXQuICBJZiBhIGNy YXNoIG9jY3VycyBhZnRlciB0aGUKLSAqIHZpc2liaWxpdHkgbWFwIHBhZ2UgbWFrZXMgaXQgdG8g ZGlzayBhbmQgYmVmb3JlIHRoZSB1cGRhdGVkIGhlYXAgcGFnZSBtYWtlcwotICogaXQgdG8gZGlz aywgcmVkbyBtdXN0IHNldCB0aGUgYml0IG9uIHRoZSBoZWFwIHBhZ2UuICBPdGhlcndpc2UsIHRo ZSBuZXh0Ci0gKiBpbnNlcnQsIHVwZGF0ZSwgb3IgZGVsZXRlIG9uIHRoZSBoZWFwIHBhZ2Ugd2ls bCBmYWlsIHRvIHJlYWxpemUgdGhhdCB0aGUKLSAqIHZpc2liaWxpdHkgbWFwIGJpdCBtdXN0IGJl IGNsZWFyZWQsIHBvc3NpYmx5IGNhdXNpbmcgaW5kZXgtb25seSBzY2FucyB0bwotICogcmV0dXJu IHdyb25nIGFuc3dlcnMuCisgKiBDaGFuZ2VzIHRvIHRoZSB2aXNpYmlsaXR5IG1hcCBiaXRzIGFy ZSBub3Qgc2VwYXJhdGVseSBXQUwtbG9nZ2VkLiBDYWxsZXJzCisgKiBtdXN0IG1ha2Ugc3VyZSB0 aGF0IHdoZW5ldmVyIGEgdmlzaWJpbGl0eSBtYXAgYml0IGlzIGNsZWFyZWQsIHRoZSBiaXQgaXMK KyAqIGNsZWFyZWQgb24gV0FMIHJlcGxheSBvZiB0aGUgdXBkYXRpbmcgb3BlcmF0aW9uLiBBbmQg d2hlbmV2ZXIgYSB2aXNpYmlsaXR5CisgKiBtYXAgYml0IGlzIHNldCwgdGhlIGJpdCBpcyBzZXQg b24gV0FMIHJlcGxheSBvZiB0aGUgb3BlcmF0aW9uIHRoYXQgcmVuZGVyZWQKKyAqIHRoZSBwYWdl IGFsbC12aXNpYmxlL2FsbC1mcm96ZW4uCisgKgorICogVGhlIHZpc2liaWxpdHkgbWFwIGJpdHMg b3BlcmF0ZSBhcyBhIGhpbnQgaW4gb25lIGRpcmVjdGlvbjogaWYgdGhleSBhcmUKKyAqIGNsZWFy LCBpdCBtYXkgc3RpbGwgYmUgdGhlIGNhc2UgdGhhdCBldmVyeSB0dXBsZSBvbiB0aGUgcGFnZSBp cyB2aXNpYmxlIHRvCisgKiBhbGwgdHJhbnNhY3Rpb25zICh3ZSBqdXN0IGRvbid0IGtub3cgdGhh dCBmb3IgY2VydGFpbikuIEhvd2V2ZXIsIGlmIHRoZXkKKyAqIGFyZSBzZXQsIHdlIG1heSBza2lw IHZhY3V1bWluZyBwYWdlcyBhbmQgaW5jb3JyZWN0bHkgYWR2YW5jZSByZWxmcm96ZW54aWQKKyAq IG9yIHNraXAgcmVhZGluZyBoZWFwIHBhZ2VzIGZvciBhbiBpbmRleC1vbmx5IHNjYW4gYW5kIHJl dHVybiB3cm9uZyByZXN1bHRzLgorICoKKyAqIEFkZGl0aW9uYWxseSwgaXQgaXMgY3JpdGljYWwg dGhhdCB0aGUgaGVhcC1wYWdlIGxldmVsIFBEX0FMTF9WSVNJQkxFIGJpdCBiZQorICogY29ycmVj dGx5IHNldCBhbmQgY2xlYXJlZCBhbG9uZyB3aXRoIHRoZSBWTSBiaXRzLgorICoKKyAqIFdoZW4g Y2xlYXJpbmcgdGhlIFZNLCBpZiBhIGNyYXNoIG9jY3VycyBhZnRlciB0aGUgaGVhcCBwYWdlIG1h a2VzIGl0IHRvCisgKiBkaXNrIGJ1dCBiZWZvcmUgdGhlIFZNIHBhZ2UgbWFrZXMgaXQgdG8gZGlz aywgcmVwbGF5IG11c3QgY2xlYXIgdGhlIFZNIG9yCisgKiB0aGUgbmV4dCBpbmRleC1vbmx5IHNj YW4gY2FuIHJldHVybiB3cm9uZyByZXN1bHRzIG9yIHZhY3V1bSBtYXkgaW5jb3JyZWN0bHkKKyAq IGFkdmFuY2UgcmVsZnJvemVueGlkLgorICoKKyAqIFdoZW4gc2V0dGluZyB0aGUgVk0sIGlmIGEg Y3Jhc2ggb2NjdXJzIGFmdGVyIHRoZSB2aXNpYmlsaXR5IG1hcCBwYWdlIG1ha2VzCisgKiBpdCB0 byBkaXNrIGFuZCBiZWZvcmUgdGhlIHVwZGF0ZWQgaGVhcCBwYWdlIG1ha2VzIGl0IHRvIGRpc2ss IHJlZG8gbXVzdCBzZXQKKyAqIHRoZSBiaXQgb24gdGhlIGhlYXAgcGFnZS4gT3RoZXJ3aXNlLCB0 aGUgbmV4dCBpbnNlcnQsIHVwZGF0ZSwgb3IgZGVsZXRlIG9uCisgKiB0aGUgaGVhcCBwYWdlIHdp bGwgZmFpbCB0byByZWFsaXplIHRoYXQgdGhlIHZpc2liaWxpdHkgbWFwIGJpdCBtdXN0IGJlCisg KiBjbGVhcmVkLCBwb3NzaWJseSBjYXVzaW5nIGluZGV4LW9ubHkgc2NhbnMgdG8gcmV0dXJuIHdy b25nIGFuc3dlcnMuCiAgKgogICogVkFDVVVNIHdpbGwgbm9ybWFsbHkgc2tpcCBwYWdlcyBmb3Ig d2hpY2ggdGhlIHZpc2liaWxpdHkgbWFwIGJpdCBpcyBzZXQ7CiAgKiBzdWNoIHBhZ2VzIGNhbid0 IGNvbnRhaW4gYW55IGRlYWQgdHVwbGVzIGFuZCB0aGVyZWZvcmUgZG9uJ3QgbmVlZCB2YWN1dW1p bmcuCkBAIC0yMjIsMTEyICsyMzEsMTEgQEAgdmlzaWJpbGl0eW1hcF9waW5fb2soQmxvY2tOdW1i ZXIgaGVhcEJsaywgQnVmZmVyIHZtYnVmKQogCXJldHVybiBCdWZmZXJJc1ZhbGlkKHZtYnVmKSAm JiBCdWZmZXJHZXRCbG9ja051bWJlcih2bWJ1ZikgPT0gbWFwQmxvY2s7CiB9CiAKLS8qCi0gKgl2 aXNpYmlsaXR5bWFwX3NldCAtIHNldCBiaXQocykgb24gYSBwcmV2aW91c2x5IHBpbm5lZCBwYWdl Ci0gKgotICogcmVjcHRyIGlzIHRoZSBMU04gb2YgdGhlIFhMT0cgcmVjb3JkIHdlJ3JlIHJlcGxh eWluZywgaWYgd2UncmUgaW4gcmVjb3ZlcnksCi0gKiBvciBJbnZhbGlkWExvZ1JlY1B0ciBpbiBu b3JtYWwgcnVubmluZy4gIFRoZSBWTSBwYWdlIExTTiBpcyBhZHZhbmNlZCB0byB0aGUKLSAqIG9u ZSBwcm92aWRlZDsgaW4gbm9ybWFsIHJ1bm5pbmcsIHdlIGdlbmVyYXRlIGEgbmV3IFhMT0cgcmVj b3JkIGFuZCBzZXQgdGhlCi0gKiBwYWdlIExTTiB0byB0aGF0IHZhbHVlICh0aG91Z2ggdGhlIGhl YXAgcGFnZSdzIExTTiBtYXkgKm5vdCogYmUgdXBkYXRlZDsKLSAqIHNlZSBiZWxvdykuICBjdXRv ZmZfeGlkIGlzIHRoZSBsYXJnZXN0IHhtaW4gb24gdGhlIHBhZ2UgYmVpbmcgbWFya2VkCi0gKiBh bGwtdmlzaWJsZTsgaXQgaXMgbmVlZGVkIGZvciBIb3QgU3RhbmRieSwgYW5kIGNhbiBiZSBJbnZh bGlkVHJhbnNhY3Rpb25JZAotICogaWYgdGhlIHBhZ2UgY29udGFpbnMgbm8gdHVwbGVzLiAgSXQg Y2FuIGFsc28gYmUgc2V0IHRvIEludmFsaWRUcmFuc2FjdGlvbklkCi0gKiB3aGVuIGEgcGFnZSB0 aGF0IGlzIGFscmVhZHkgYWxsLXZpc2libGUgaXMgYmVpbmcgbWFya2VkIGFsbC1mcm96ZW4uCi0g KgotICogQ2FsbGVyIGlzIGV4cGVjdGVkIHRvIHNldCB0aGUgaGVhcCBwYWdlJ3MgUERfQUxMX1ZJ U0lCTEUgYml0IGJlZm9yZSBjYWxsaW5nCi0gKiB0aGlzIGZ1bmN0aW9uLiBFeGNlcHQgaW4gcmVj b3ZlcnksIGNhbGxlciBzaG91bGQgYWxzbyBwYXNzIHRoZSBoZWFwCi0gKiBidWZmZXIuIFdoZW4g Y2hlY2tzdW1zIGFyZSBlbmFibGVkIGFuZCB3ZSdyZSBub3QgaW4gcmVjb3ZlcnksIHdlIG11c3Qg YWRkCi0gKiB0aGUgaGVhcCBidWZmZXIgdG8gdGhlIFdBTCBjaGFpbiB0byBwcm90ZWN0IGl0IGZy b20gYmVpbmcgdG9ybi4KLSAqCi0gKiBZb3UgbXVzdCBwYXNzIGEgYnVmZmVyIGNvbnRhaW5pbmcg dGhlIGNvcnJlY3QgbWFwIHBhZ2UgdG8gdGhpcyBmdW5jdGlvbi4KLSAqIENhbGwgdmlzaWJpbGl0 eW1hcF9waW4gZmlyc3QgdG8gcGluIHRoZSByaWdodCBvbmUuIFRoaXMgZnVuY3Rpb24gZG9lc24n dCBkbwotICogYW55IEkvTy4KLSAqLwotdm9pZAotdmlzaWJpbGl0eW1hcF9zZXQoUmVsYXRpb24g cmVsLCBCbG9ja051bWJlciBoZWFwQmxrLCBCdWZmZXIgaGVhcEJ1ZiwKLQkJCQkgIFhMb2dSZWNQ dHIgcmVjcHRyLCBCdWZmZXIgdm1CdWYsIFRyYW5zYWN0aW9uSWQgY3V0b2ZmX3hpZCwKLQkJCQkg IHVpbnQ4IGZsYWdzKQotewotCUJsb2NrTnVtYmVyIG1hcEJsb2NrID0gSEVBUEJMS19UT19NQVBC TE9DSyhoZWFwQmxrKTsKLQl1aW50MzIJCW1hcEJ5dGUgPSBIRUFQQkxLX1RPX01BUEJZVEUoaGVh cEJsayk7Ci0JdWludDgJCW1hcE9mZnNldCA9IEhFQVBCTEtfVE9fT0ZGU0VUKGhlYXBCbGspOwot CVBhZ2UJCXBhZ2U7Ci0JdWludDgJICAgKm1hcDsKLQl1aW50OAkJc3RhdHVzOwotCi0jaWZkZWYg VFJBQ0VfVklTSUJJTElUWU1BUAotCWVsb2coREVCVUcxLCAidm1fc2V0IGZsYWdzIDB4JTAyWCBm b3IgJXMgJWQiLAotCQkgZmxhZ3MsIFJlbGF0aW9uR2V0UmVsYXRpb25OYW1lKHJlbCksIGhlYXBC bGspOwotI2VuZGlmCi0KLQlBc3NlcnQoSW5SZWNvdmVyeSB8fCAhWExvZ1JlY1B0cklzVmFsaWQo cmVjcHRyKSk7Ci0JQXNzZXJ0KEluUmVjb3ZlcnkgfHwgUGFnZUlzQWxsVmlzaWJsZShCdWZmZXJH ZXRQYWdlKGhlYXBCdWYpKSk7Ci0JQXNzZXJ0KChmbGFncyAmIFZJU0lCSUxJVFlNQVBfVkFMSURf QklUUykgPT0gZmxhZ3MpOwotCi0JLyogTXVzdCBuZXZlciBzZXQgYWxsX2Zyb3plbiBiaXQgd2l0 aG91dCBhbHNvIHNldHRpbmcgYWxsX3Zpc2libGUgYml0ICovCi0JQXNzZXJ0KGZsYWdzICE9IFZJ U0lCSUxJVFlNQVBfQUxMX0ZST1pFTik7Ci0KLQkvKiBDaGVjayB0aGF0IHdlIGhhdmUgdGhlIHJp Z2h0IGhlYXAgcGFnZSBwaW5uZWQsIGlmIHByZXNlbnQgKi8KLQlpZiAoQnVmZmVySXNWYWxpZCho ZWFwQnVmKSAmJiBCdWZmZXJHZXRCbG9ja051bWJlcihoZWFwQnVmKSAhPSBoZWFwQmxrKQotCQll bG9nKEVSUk9SLCAid3JvbmcgaGVhcCBidWZmZXIgcGFzc2VkIHRvIHZpc2liaWxpdHltYXBfc2V0 Iik7Ci0KLQlBc3NlcnQoIUJ1ZmZlcklzVmFsaWQoaGVhcEJ1ZikgfHwKLQkJICAgQnVmZmVySXNM b2NrZWRCeU1lSW5Nb2RlKGhlYXBCdWYsIEJVRkZFUl9MT0NLX0VYQ0xVU0lWRSkpOwotCi0JLyog Q2hlY2sgdGhhdCB3ZSBoYXZlIHRoZSByaWdodCBWTSBwYWdlIHBpbm5lZCAqLwotCWlmICghQnVm ZmVySXNWYWxpZCh2bUJ1ZikgfHwgQnVmZmVyR2V0QmxvY2tOdW1iZXIodm1CdWYpICE9IG1hcEJs b2NrKQotCQllbG9nKEVSUk9SLCAid3JvbmcgVk0gYnVmZmVyIHBhc3NlZCB0byB2aXNpYmlsaXR5 bWFwX3NldCIpOwotCi0JcGFnZSA9IEJ1ZmZlckdldFBhZ2Uodm1CdWYpOwotCW1hcCA9ICh1aW50 OCAqKSBQYWdlR2V0Q29udGVudHMocGFnZSk7Ci0JTG9ja0J1ZmZlcih2bUJ1ZiwgQlVGRkVSX0xP Q0tfRVhDTFVTSVZFKTsKLQotCXN0YXR1cyA9IChtYXBbbWFwQnl0ZV0gPj4gbWFwT2Zmc2V0KSAm IFZJU0lCSUxJVFlNQVBfVkFMSURfQklUUzsKLQlpZiAoZmxhZ3MgIT0gc3RhdHVzKQotCXsKLQkJ U1RBUlRfQ1JJVF9TRUNUSU9OKCk7Ci0KLQkJbWFwW21hcEJ5dGVdIHw9IChmbGFncyA8PCBtYXBP ZmZzZXQpOwotCQlNYXJrQnVmZmVyRGlydHkodm1CdWYpOwotCi0JCWlmIChSZWxhdGlvbk5lZWRz V0FMKHJlbCkpCi0JCXsKLQkJCWlmICghWExvZ1JlY1B0cklzVmFsaWQocmVjcHRyKSkKLQkJCXsK LQkJCQlBc3NlcnQoIUluUmVjb3ZlcnkpOwotCQkJCXJlY3B0ciA9IGxvZ19oZWFwX3Zpc2libGUo cmVsLCBoZWFwQnVmLCB2bUJ1ZiwgY3V0b2ZmX3hpZCwgZmxhZ3MpOwotCi0JCQkJLyoKLQkJCQkg KiBJZiBkYXRhIGNoZWNrc3VtcyBhcmUgZW5hYmxlZCAob3Igd2FsX2xvZ19oaW50cz1vbiksIHdl Ci0JCQkJICogbmVlZCB0byBwcm90ZWN0IHRoZSBoZWFwIHBhZ2UgZnJvbSBiZWluZyB0b3JuLgot CQkJCSAqCi0JCQkJICogSWYgbm90LCB0aGVuIHdlIG11c3QgKm5vdCogdXBkYXRlIHRoZSBoZWFw IHBhZ2UncyBMU04uIEluCi0JCQkJICogdGhpcyBjYXNlLCB0aGUgRlBJIGZvciB0aGUgaGVhcCBw YWdlIHdhcyBvbWl0dGVkIGZyb20gdGhlCi0JCQkJICogV0FMIHJlY29yZCBpbnNlcnRlZCBhYm92 ZSwgc28gaXQgd291bGQgYmUgaW5jb3JyZWN0IHRvCi0JCQkJICogdXBkYXRlIHRoZSBoZWFwIHBh Z2UncyBMU04uCi0JCQkJICovCi0JCQkJaWYgKFhMb2dIaW50Qml0SXNOZWVkZWQoKSkKLQkJCQl7 Ci0JCQkJCVBhZ2UJCWhlYXBQYWdlID0gQnVmZmVyR2V0UGFnZShoZWFwQnVmKTsKLQotCQkJCQlQ YWdlU2V0TFNOKGhlYXBQYWdlLCByZWNwdHIpOwotCQkJCX0KLQkJCX0KLQkJCVBhZ2VTZXRMU04o cGFnZSwgcmVjcHRyKTsKLQkJfQotCi0JCUVORF9DUklUX1NFQ1RJT04oKTsKLQl9Ci0KLQlMb2Nr QnVmZmVyKHZtQnVmLCBCVUZGRVJfTE9DS19VTkxPQ0spOwotfQotCiAvKgogICogU2V0IFZNICh2 aXNpYmlsaXR5IG1hcCkgZmxhZ3MgaW4gdGhlIFZNIGJsb2NrIGluIHZtQnVmLgogICoKICAqIFRo aXMgZnVuY3Rpb24gaXMgaW50ZW5kZWQgZm9yIGNhbGxlcnMgdGhhdCBsb2cgVk0gY2hhbmdlcyB0 b2dldGhlcgogICogd2l0aCB0aGUgaGVhcCBwYWdlIG1vZGlmaWNhdGlvbnMgdGhhdCByZW5kZXJl ZCB0aGUgcGFnZSBhbGwtdmlzaWJsZS4KLSAqIENhbGxlcnMgdGhhdCBsb2cgVk0gY2hhbmdlcyBz ZXBhcmF0ZWx5IHNob3VsZCB1c2UgdmlzaWJpbGl0eW1hcF9zZXQoKS4KICAqCiAgKiB2bUJ1ZiBt dXN0IGJlIHBpbm5lZCBhbmQgZXhjbHVzaXZlbHkgbG9ja2VkLCBhbmQgaXQgbXVzdCBjb3ZlciB0 aGUgVk0gYml0cwogICogY29ycmVzcG9uZGluZyB0byBoZWFwQmxrLgpAQCAtMzQzLDkgKzI1MSw5 IEBAIHZpc2liaWxpdHltYXBfc2V0KFJlbGF0aW9uIHJlbCwgQmxvY2tOdW1iZXIgaGVhcEJsaywg QnVmZmVyIGhlYXBCdWYsCiAgKiBybG9jYXRvciBpcyB1c2VkIG9ubHkgZm9yIGRlYnVnZ2luZyBt ZXNzYWdlcy4KICAqLwogdm9pZAotdmlzaWJpbGl0eW1hcF9zZXRfdm1iaXRzKEJsb2NrTnVtYmVy IGhlYXBCbGssCi0JCQkJCQkgQnVmZmVyIHZtQnVmLCB1aW50OCBmbGFncywKLQkJCQkJCSBjb25z dCBSZWxGaWxlTG9jYXRvciBybG9jYXRvcikKK3Zpc2liaWxpdHltYXBfc2V0KEJsb2NrTnVtYmVy IGhlYXBCbGssCisJCQkJICBCdWZmZXIgdm1CdWYsIHVpbnQ4IGZsYWdzLAorCQkJCSAgY29uc3Qg UmVsRmlsZUxvY2F0b3IgcmxvY2F0b3IpCiB7CiAJQmxvY2tOdW1iZXIgbWFwQmxvY2sgPSBIRUFQ QkxLX1RPX01BUEJMT0NLKGhlYXBCbGspOwogCXVpbnQzMgkJbWFwQnl0ZSA9IEhFQVBCTEtfVE9f TUFQQllURShoZWFwQmxrKTsKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9ybWdyZGVz Yy9oZWFwZGVzYy5jIGIvc3JjL2JhY2tlbmQvYWNjZXNzL3JtZ3JkZXNjL2hlYXBkZXNjLmMKaW5k ZXggMDJhZTkxNjUzYzEuLjc1YWU2ZjlkMzc1IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nl c3Mvcm1ncmRlc2MvaGVhcGRlc2MuYworKysgYi9zcmMvYmFja2VuZC9hY2Nlc3Mvcm1ncmRlc2Mv aGVhcGRlc2MuYwpAQCAtMzQ5LDEzICszNDksNiBAQCBoZWFwMl9kZXNjKFN0cmluZ0luZm8gYnVm LCBYTG9nUmVhZGVyU3RhdGUgKnJlY29yZCkKIAkJCX0KIAkJfQogCX0KLQllbHNlIGlmIChpbmZv ID09IFhMT0dfSEVBUDJfVklTSUJMRSkKLQl7Ci0JCXhsX2hlYXBfdmlzaWJsZSAqeGxyZWMgPSAo eGxfaGVhcF92aXNpYmxlICopIHJlYzsKLQotCQlhcHBlbmRTdHJpbmdJbmZvKGJ1ZiwgInNuYXBz aG90Q29uZmxpY3RIb3Jpem9uOiAldSwgZmxhZ3M6IDB4JTAyWCIsCi0JCQkJCQkgeGxyZWMtPnNu YXBzaG90Q29uZmxpY3RIb3Jpem9uLCB4bHJlYy0+ZmxhZ3MpOwotCX0KIAllbHNlIGlmIChpbmZv ID09IFhMT0dfSEVBUDJfTVVMVElfSU5TRVJUKQogCXsKIAkJeGxfaGVhcF9tdWx0aV9pbnNlcnQg KnhscmVjID0gKHhsX2hlYXBfbXVsdGlfaW5zZXJ0ICopIHJlYzsKQEAgLTQ2MSw5ICs0NTQsNiBA QCBoZWFwMl9pZGVudGlmeSh1aW50OCBpbmZvKQogCQljYXNlIFhMT0dfSEVBUDJfUFJVTkVfVkFD VVVNX0NMRUFOVVA6CiAJCQlpZCA9ICJQUlVORV9WQUNVVU1fQ0xFQU5VUCI7CiAJCQlicmVhazsK LQkJY2FzZSBYTE9HX0hFQVAyX1ZJU0lCTEU6Ci0JCQlpZCA9ICJWSVNJQkxFIjsKLQkJCWJyZWFr OwogCQljYXNlIFhMT0dfSEVBUDJfTVVMVElfSU5TRVJUOgogCQkJaWQgPSAiTVVMVElfSU5TRVJU IjsKIAkJCWJyZWFrOwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvcmVwbGljYXRpb24vbG9naWNh bC9kZWNvZGUuYyBiL3NyYy9iYWNrZW5kL3JlcGxpY2F0aW9uL2xvZ2ljYWwvZGVjb2RlLmMKaW5k ZXggMjFmMDM4NjRhNjYuLjNjMDI3YmNiMmY3IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9yZXBs aWNhdGlvbi9sb2dpY2FsL2RlY29kZS5jCisrKyBiL3NyYy9iYWNrZW5kL3JlcGxpY2F0aW9uL2xv Z2ljYWwvZGVjb2RlLmMKQEAgLTQ0OCw3ICs0NDgsNiBAQCBoZWFwMl9kZWNvZGUoTG9naWNhbERl Y29kaW5nQ29udGV4dCAqY3R4LCBYTG9nUmVjb3JkQnVmZmVyICpidWYpCiAJCWNhc2UgWExPR19I RUFQMl9QUlVORV9PTl9BQ0NFU1M6CiAJCWNhc2UgWExPR19IRUFQMl9QUlVORV9WQUNVVU1fU0NB TjoKIAkJY2FzZSBYTE9HX0hFQVAyX1BSVU5FX1ZBQ1VVTV9DTEVBTlVQOgotCQljYXNlIFhMT0df SEVBUDJfVklTSUJMRToKIAkJY2FzZSBYTE9HX0hFQVAyX0xPQ0tfVVBEQVRFRDoKIAkJCWJyZWFr OwogCQlkZWZhdWx0OgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvc3RvcmFnZS9pcGMvc3RhbmRi eS5jIGIvc3JjL2JhY2tlbmQvc3RvcmFnZS9pcGMvc3RhbmRieS5jCmluZGV4IGYzYWQ5MGM3Yzdh Li5kZTkwOTJmZGY1YiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvc3RvcmFnZS9pcGMvc3RhbmRi eS5jCisrKyBiL3NyYy9iYWNrZW5kL3N0b3JhZ2UvaXBjL3N0YW5kYnkuYwpAQCAtNDc2LDEwICs0 NzYsMTEgQEAgUmVzb2x2ZVJlY292ZXJ5Q29uZmxpY3RXaXRoU25hcHNob3QoVHJhbnNhY3Rpb25J ZCBzbmFwc2hvdENvbmZsaWN0SG9yaXpvbiwKIAkvKgogCSAqIElmIHdlIGdldCBwYXNzZWQgSW52 YWxpZFRyYW5zYWN0aW9uSWQgdGhlbiB3ZSBkbyBub3RoaW5nIChubyBjb25mbGljdCkuCiAJICoK LQkgKiBUaGlzIGNhbiBoYXBwZW4gd2hlbiByZXBsYXlpbmcgYWxyZWFkeS1hcHBsaWVkIFdBTCBy ZWNvcmRzIGFmdGVyIGEKLQkgKiBzdGFuZGJ5IGNyYXNoIG9yIHJlc3RhcnQsIG9yIHdoZW4gcmVw bGF5aW5nIGFuIFhMT0dfSEVBUDJfVklTSUJMRQotCSAqIHJlY29yZCB0aGF0IG1hcmtzIGFzIGZy b3plbiBhIHBhZ2Ugd2hpY2ggd2FzIGFscmVhZHkgYWxsLXZpc2libGUuICBJdCdzCi0JICogYWxz byBxdWl0ZSBjb21tb24gd2l0aCByZWNvcmRzIGdlbmVyYXRlZCBkdXJpbmcgaW5kZXggZGVsZXRp b24KKwkgKiBUaGlzIGNhbiBoYXBwZW4gd2hlbmV2ZXIgdGhlIGNoYW5nZXMgaW4gdGhlIFdBTCBy ZWNvcmQgZG8gbm90IGFmZmVjdAorCSAqIHZpc2liaWxpdHkgb24gYSBzdGFuZGJ5LiBGb3IgZXhh bXBsZTogYSByZWNvcmQgdGhhdCBvbmx5IGZyZWV6ZXMgYW4KKwkgKiB4bWF4IGZyb20gYSBsb2Nr ZXIuCisJICoKKwkgKiBJdCdzIGFsc28gcXVpdGUgY29tbW9uIHdpdGggcmVjb3JkcyBnZW5lcmF0 ZWQgZHVyaW5nIGluZGV4IGRlbGV0aW9uCiAJICogKG9yaWdpbmFsIGV4ZWN1dGlvbiBvZiB0aGUg ZGVsZXRpb24gY2FuIHJlYXNvbiB0aGF0IGEgcmVjb3ZlcnkgY29uZmxpY3QKIAkgKiB3aGljaCBp cyBzdWZmaWNpZW50IGZvciB0aGUgZGVsZXRpb24gb3BlcmF0aW9uIG11c3QgdGFrZSBwbGFjZSBi ZWZvcmUKIAkgKiByZXBsYXkgb2YgdGhlIGRlbGV0aW9uIHJlY29yZCBpdHNlbGYpLgpkaWZmIC0t Z2l0IGEvc3JjL2luY2x1ZGUvYWNjZXNzL2hlYXBhbV94bG9nLmggYi9zcmMvaW5jbHVkZS9hY2Nl c3MvaGVhcGFtX3hsb2cuaAppbmRleCBjZTM1NjZiYTk0OS4uNTE2ODA2ZmNjYTIgMTAwNjQ0Ci0t LSBhL3NyYy9pbmNsdWRlL2FjY2Vzcy9oZWFwYW1feGxvZy5oCisrKyBiL3NyYy9pbmNsdWRlL2Fj Y2Vzcy9oZWFwYW1feGxvZy5oCkBAIC02MCw3ICs2MCw3IEBACiAjZGVmaW5lIFhMT0dfSEVBUDJf UFJVTkVfT05fQUNDRVNTCQkweDEwCiAjZGVmaW5lIFhMT0dfSEVBUDJfUFJVTkVfVkFDVVVNX1ND QU4JMHgyMAogI2RlZmluZSBYTE9HX0hFQVAyX1BSVU5FX1ZBQ1VVTV9DTEVBTlVQCTB4MzAKLSNk ZWZpbmUgWExPR19IRUFQMl9WSVNJQkxFCQkweDQwCisvKiAweDQwIHdhcyBYTE9HX0hFQVAyX1ZJ U0lCTEUgKi8KICNkZWZpbmUgWExPR19IRUFQMl9NVUxUSV9JTlNFUlQgMHg1MAogI2RlZmluZSBY TE9HX0hFQVAyX0xPQ0tfVVBEQVRFRCAweDYwCiAjZGVmaW5lIFhMT0dfSEVBUDJfTkVXX0NJRAkJ MHg3MApAQCAtNDQzLDIwICs0NDMsNiBAQCB0eXBlZGVmIHN0cnVjdCB4bF9oZWFwX2lucGxhY2UK IAogI2RlZmluZSBNaW5TaXplT2ZIZWFwSW5wbGFjZQkob2Zmc2V0b2YoeGxfaGVhcF9pbnBsYWNl LCBubXNncykgKyBzaXplb2YoaW50KSkKIAotLyoKLSAqIFRoaXMgaXMgd2hhdCB3ZSBuZWVkIHRv IGtub3cgYWJvdXQgc2V0dGluZyBhIHZpc2liaWxpdHkgbWFwIGJpdAotICoKLSAqIEJhY2t1cCBi bGsgMDogdmlzaWJpbGl0eSBtYXAgYnVmZmVyCi0gKiBCYWNrdXAgYmxrIDE6IGhlYXAgYnVmZmVy Ci0gKi8KLXR5cGVkZWYgc3RydWN0IHhsX2hlYXBfdmlzaWJsZQotewotCVRyYW5zYWN0aW9uSWQg c25hcHNob3RDb25mbGljdEhvcml6b247Ci0JdWludDgJCWZsYWdzOwotfSB4bF9oZWFwX3Zpc2li bGU7Ci0KLSNkZWZpbmUgU2l6ZU9mSGVhcFZpc2libGUgKG9mZnNldG9mKHhsX2hlYXBfdmlzaWJs ZSwgZmxhZ3MpICsgc2l6ZW9mKHVpbnQ4KSkKLQogdHlwZWRlZiBzdHJ1Y3QgeGxfaGVhcF9uZXdf Y2lkCiB7CiAJLyoKQEAgLTUwMCwxMSArNDg2LDYgQEAgZXh0ZXJuIHZvaWQgaGVhcDJfZGVzYyhT dHJpbmdJbmZvIGJ1ZiwgWExvZ1JlYWRlclN0YXRlICpyZWNvcmQpOwogZXh0ZXJuIGNvbnN0IGNo YXIgKmhlYXAyX2lkZW50aWZ5KHVpbnQ4IGluZm8pOwogZXh0ZXJuIHZvaWQgaGVhcF94bG9nX2xv Z2ljYWxfcmV3cml0ZShYTG9nUmVhZGVyU3RhdGUgKnIpOwogCi1leHRlcm4gWExvZ1JlY1B0ciBs b2dfaGVhcF92aXNpYmxlKFJlbGF0aW9uIHJlbCwgQnVmZmVyIGhlYXBfYnVmZmVyLAotCQkJCQkJ CQkgICBCdWZmZXIgdm1fYnVmZmVyLAotCQkJCQkJCQkgICBUcmFuc2FjdGlvbklkIHNuYXBzaG90 Q29uZmxpY3RIb3Jpem9uLAotCQkJCQkJCQkgICB1aW50OCB2bWZsYWdzKTsKLQogLyogaW4gaGVh cGRlc2MuYywgc28gaXQgY2FuIGJlIHNoYXJlZCBiZXR3ZWVuIGZyb250ZW5kL2JhY2tlbmQgY29k ZSAqLwogZXh0ZXJuIHZvaWQgaGVhcF94bG9nX2Rlc2VyaWFsaXplX3BydW5lX2FuZF9mcmVlemUo Y2hhciAqY3Vyc29yLCB1aW50MTYgZmxhZ3MsCiAJCQkJCQkJCQkJCQkgICBpbnQgKm5wbGFucywg eGxocF9mcmVlemVfcGxhbiAqKnBsYW5zLApkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvYWNjZXNz L3Zpc2liaWxpdHltYXAuaCBiL3NyYy9pbmNsdWRlL2FjY2Vzcy92aXNpYmlsaXR5bWFwLmgKaW5k ZXggNTJjZGU1NmJlODYuLmU0ZTBjZmE5ODllIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9hY2Nl c3MvdmlzaWJpbGl0eW1hcC5oCisrKyBiL3NyYy9pbmNsdWRlL2FjY2Vzcy92aXNpYmlsaXR5bWFw LmgKQEAgLTE1LDcgKzE1LDYgQEAKICNkZWZpbmUgVklTSUJJTElUWU1BUF9ICiAKICNpbmNsdWRl ICJhY2Nlc3MvdmlzaWJpbGl0eW1hcGRlZnMuaCIKLSNpbmNsdWRlICJhY2Nlc3MveGxvZ2RlZnMu aCIKICNpbmNsdWRlICJzdG9yYWdlL2Jsb2NrLmgiCiAjaW5jbHVkZSAic3RvcmFnZS9idWYuaCIK ICNpbmNsdWRlICJzdG9yYWdlL3JlbGZpbGVsb2NhdG9yLmgiCkBAIC0zMiwxNSArMzEsOSBAQCBl eHRlcm4gYm9vbCB2aXNpYmlsaXR5bWFwX2NsZWFyKFJlbGF0aW9uIHJlbCwgQmxvY2tOdW1iZXIg aGVhcEJsaywKIGV4dGVybiB2b2lkIHZpc2liaWxpdHltYXBfcGluKFJlbGF0aW9uIHJlbCwgQmxv Y2tOdW1iZXIgaGVhcEJsaywKIAkJCQkJCQkgIEJ1ZmZlciAqdm1idWYpOwogZXh0ZXJuIGJvb2wg dmlzaWJpbGl0eW1hcF9waW5fb2soQmxvY2tOdW1iZXIgaGVhcEJsaywgQnVmZmVyIHZtYnVmKTsK LWV4dGVybiB2b2lkIHZpc2liaWxpdHltYXBfc2V0KFJlbGF0aW9uIHJlbCwKLQkJCQkJCQkgIEJs b2NrTnVtYmVyIGhlYXBCbGssIEJ1ZmZlciBoZWFwQnVmLAotCQkJCQkJCSAgWExvZ1JlY1B0ciBy ZWNwdHIsCi0JCQkJCQkJICBCdWZmZXIgdm1CdWYsCi0JCQkJCQkJICBUcmFuc2FjdGlvbklkIGN1 dG9mZl94aWQsCi0JCQkJCQkJICB1aW50OCBmbGFncyk7Ci1leHRlcm4gdm9pZCB2aXNpYmlsaXR5 bWFwX3NldF92bWJpdHMoQmxvY2tOdW1iZXIgaGVhcEJsaywKLQkJCQkJCQkJCSBCdWZmZXIgdm1C dWYsIHVpbnQ4IGZsYWdzLAotCQkJCQkJCQkJIGNvbnN0IFJlbEZpbGVMb2NhdG9yIHJsb2NhdG9y KTsKK2V4dGVybiB2b2lkIHZpc2liaWxpdHltYXBfc2V0KEJsb2NrTnVtYmVyIGhlYXBCbGssCisJ CQkJCQkJICBCdWZmZXIgdm1CdWYsIHVpbnQ4IGZsYWdzLAorCQkJCQkJCSAgY29uc3QgUmVsRmls ZUxvY2F0b3IgcmxvY2F0b3IpOwogZXh0ZXJuIHVpbnQ4IHZpc2liaWxpdHltYXBfZ2V0X3N0YXR1 cyhSZWxhdGlvbiByZWwsIEJsb2NrTnVtYmVyIGhlYXBCbGssIEJ1ZmZlciAqdm1idWYpOwogZXh0 ZXJuIHZvaWQgdmlzaWJpbGl0eW1hcF9jb3VudChSZWxhdGlvbiByZWwsIEJsb2NrTnVtYmVyICph bGxfdmlzaWJsZSwgQmxvY2tOdW1iZXIgKmFsbF9mcm96ZW4pOwogZXh0ZXJuIEJsb2NrTnVtYmVy IHZpc2liaWxpdHltYXBfcHJlcGFyZV90cnVuY2F0ZShSZWxhdGlvbiByZWwsCmRpZmYgLS1naXQg YS9zcmMvaW5jbHVkZS9hY2Nlc3MvdmlzaWJpbGl0eW1hcGRlZnMuaCBiL3NyYy9pbmNsdWRlL2Fj Y2Vzcy92aXNpYmlsaXR5bWFwZGVmcy5oCmluZGV4IDg5MTUzYjNjZDlhLi5lNTc5NGM4NTU5ZSAx MDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvYWNjZXNzL3Zpc2liaWxpdHltYXBkZWZzLmgKKysrIGIv c3JjL2luY2x1ZGUvYWNjZXNzL3Zpc2liaWxpdHltYXBkZWZzLmgKQEAgLTIxLDE0ICsyMSw1IEBA CiAjZGVmaW5lIFZJU0lCSUxJVFlNQVBfQUxMX0ZST1pFTgkweDAyCiAjZGVmaW5lIFZJU0lCSUxJ VFlNQVBfVkFMSURfQklUUwkweDAzCS8qIE9SIG9mIGFsbCB2YWxpZCB2aXNpYmlsaXR5bWFwCiAJ CQkJCQkJCQkJCSAqIGZsYWdzIGJpdHMgKi8KLS8qCi0gKiBUbyBkZXRlY3QgcmVjb3ZlcnkgY29u ZmxpY3RzIGR1cmluZyBsb2dpY2FsIGRlY29kaW5nIG9uIGEgc3RhbmRieSwgd2UgbmVlZAotICog dG8ga25vdyBpZiBhIHRhYmxlIGlzIGEgdXNlciBjYXRhbG9nIHRhYmxlLiBGb3IgdGhhdCB3ZSBh ZGQgYW4gYWRkaXRpb25hbAotICogYml0IGludG8geGxfaGVhcF92aXNpYmxlLmZsYWdzLCBpbiBh ZGRpdGlvbiB0byB0aGUgYWJvdmUuCi0gKgotICogTkI6IFZJU0lCSUxJVFlNQVBfWExPR18qIG1h eSBub3QgYmUgcGFzc2VkIHRvIHZpc2liaWxpdHltYXBfc2V0KCkuCi0gKi8KLSNkZWZpbmUgVklT SUJJTElUWU1BUF9YTE9HX0NBVEFMT0dfUkVMCTB4MDQKLSNkZWZpbmUgVklTSUJJTElUWU1BUF9Y TE9HX1ZBTElEX0JJVFMJKFZJU0lCSUxJVFlNQVBfVkFMSURfQklUUyB8IFZJU0lCSUxJVFlNQVBf WExPR19DQVRBTE9HX1JFTCkKIAogI2VuZGlmCQkJCQkJCS8qIFZJU0lCSUxJVFlNQVBERUZTX0gg Ki8KZGlmZiAtLWdpdCBhL3NyYy90b29scy9wZ2luZGVudC90eXBlZGVmcy5saXN0IGIvc3JjL3Rv b2xzL3BnaW5kZW50L3R5cGVkZWZzLmxpc3QKaW5kZXggNDgwNjE0ZDQ4M2IuLmYxMmYyZGVlYzQz IDEwMDY0NAotLS0gYS9zcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdAorKysgYi9zcmMv dG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdApAQCAtNDQxNiw3ICs0NDE2LDYgQEAgeGxfaGVh cF9wcnVuZQogeGxfaGVhcF9yZXdyaXRlX21hcHBpbmcKIHhsX2hlYXBfdHJ1bmNhdGUKIHhsX2hl YXBfdXBkYXRlCi14bF9oZWFwX3Zpc2libGUKIHhsX2ludmFsaWRfcGFnZQogeGxfaW52YWxpZF9w YWdlX2tleQogeGxfaW52YWxpZGF0aW9ucwotLSAKMi40My4wCgo= --00000000000060fd69064d6b968a Content-Type: text/x-patch; charset="US-ASCII"; name="v41-0008-Track-which-relations-are-modified-by-a-query.patch" Content-Disposition: attachment; filename="v41-0008-Track-which-relations-are-modified-by-a-query.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmyagmdn7 RnJvbSBmNWRlMzNjMTczY2E1MjE2ZWEwNDI0NzVlYzhlZTJkOGYwZGRkM2E5IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBXZWQsIDMgRGVjIDIwMjUgMTU6MDc6MjQgLTA1MDAKU3ViamVjdDogW1BB VENIIHY0MSAwOC8xMl0gVHJhY2sgd2hpY2ggcmVsYXRpb25zIGFyZSBtb2RpZmllZCBieSBhIHF1 ZXJ5CgpTYXZlIHRoZSByZWxpZHMgb2YgbW9kaWZpZWQgcmVsYXRpb25zIGluIGEgYml0bWFwIGlu IHRoZSBQbGFubmVkU3RtdC4KQSBsYXRlciBjb21taXQgd2lsbCBwYXNzIHRoaXMgaW5mb3JtYXRp b24gZG93biB0byBzY2FuIG5vZGVzIHRvIGNvbnRyb2wKd2hldGhlciBvciBub3Qgb24tYWNjZXNz IHBydW5pbmcgaXMgYWxsb3dlZCB0byBzZXQgdGhlIHZpc2liaWxpdHkgbWFwLgpTZXR0aW5nIHRo ZSB2aXNpYmlsaXR5IG1hcCBkdXJpbmcgYSBzY2FuIGlzIGNvdW50ZXJwcm9kdWN0aXZlIGlmIHRo ZQpxdWVyeSBpcyBnb2luZyB0byBtb2RpZnkgdGhlIHBhZ2UgaW1tZWRpYXRlbHkgYWZ0ZXIuCgpS ZWxhdGlvbnMgYXJlIGNvbnNpZGVyZWQgbW9kaWZpZWQgaWYgdGhleSBhcmUgdGhlIHRhcmdldCBv ZiBJTlNFUlQsClVQREFURSwgREVMRVRFLCBvciBNRVJHRSwgb3IgaWYgdGhleSBoYXZlIGFueSBy b3cgbWFyayAoaW5jbHVkaW5nIFNFTEVDVApGT1IgVVBEQVRFL1NIQVJFKS4gQWxsIHJvdyBtYXJr IHR5cGVzIGFyZSBpbmNsdWRlZCwgZXZlbiB0aG9zZSB3aGljaApkb24ndCBhY3R1YWxseSBtb2Rp ZnkgdHVwbGVzLCBiZWNhdXNlIHRoaXMgYml0bWFwIGlzIG9ubHkgdXNlZCBhcyBhIGhpbnQKdG8g YXZvaWQgdW5uZWNlc3Nhcnkgd29yay4KCkF1dGhvcjogTWVsYW5pZSBQbGFnZW1hbiA8bWVsYW5p ZXBsYWdlbWFuQGdtYWlsLmNvbT4KUmV2aWV3ZWQtYnk6IEFuZHJlcyBGcmV1bmQgPGFuZHJlc0Bh bmFyYXplbC5kZT4KUmV2aWV3ZWQtYnk6IENoYW8gTGkgPGxpLmV2YW4uY2hhb0BnbWFpbC5jb20+ CkRpc2N1c3Npb246IGh0dHBzOi8vcG9zdGdyLmVzL20vRjVDREQxQjUtNjI4Qy00NEExLTlGODUt Mzk1OEM2MjZGNkE5JTQwZ21haWwuY29tCi0tLQogc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY01h aW4uYyAgICAgICAgfCA0NyArKysrKysrKysrKysrKysrKysrKysrKysrKwogc3JjL2JhY2tlbmQv ZXhlY3V0b3IvZXhlY1BhcmFsbGVsLmMgICAgfCAgMSArCiBzcmMvYmFja2VuZC9leGVjdXRvci9u b2RlTG9ja1Jvd3MuYyAgICB8ICA0ICsrKwogc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZU1vZGlm eVRhYmxlLmMgfCAxOCArKysrKysrKysrCiBzcmMvYmFja2VuZC9vcHRpbWl6ZXIvcGxhbi9wbGFu bmVyLmMgICB8IDIxICsrKysrKysrKysrLQogc3JjL2luY2x1ZGUvbm9kZXMvcGxhbm5vZGVzLmgg ICAgICAgICAgfCAxMCArKysrKysKIDYgZmlsZXMgY2hhbmdlZCwgMTAwIGluc2VydGlvbnMoKyks IDEgZGVsZXRpb24oLSkKCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjTWFp bi5jIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY01haW4uYwppbmRleCA1OGI4NDk1NWMyYi4u M2YxMzRmOWEzNGQgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNNYWluLmMK KysrIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY01haW4uYwpAQCAtOTAsNiArOTAsOSBAQCBz dGF0aWMgYm9vbCBFeGVjQ2hlY2tQZXJtaXNzaW9uc01vZGlmaWVkKE9pZCByZWxPaWQsIE9pZCB1 c2VyaWQsCiAJCQkJCQkJCQkJIEJpdG1hcHNldCAqbW9kaWZpZWRDb2xzLAogCQkJCQkJCQkJCSBB Y2xNb2RlIHJlcXVpcmVkUGVybXMpOwogc3RhdGljIHZvaWQgRXhlY0NoZWNrWGFjdFJlYWRPbmx5 KFBsYW5uZWRTdG10ICpwbGFubmVkc3RtdCk7CisjaWZkZWYgVVNFX0FTU0VSVF9DSEVDS0lORwor c3RhdGljIHZvaWQgRXhlY0NoZWNrTW9kaWZpZWRSZWxJZHMoRVN0YXRlICplc3RhdGUpOworI2Vu ZGlmCiBzdGF0aWMgdm9pZCBFdmFsUGxhblF1YWxTdGFydChFUFFTdGF0ZSAqZXBxc3RhdGUsIFBs YW4gKnBsYW5UcmVlKTsKIHN0YXRpYyB2b2lkIFJlcG9ydE5vdE51bGxWaW9sYXRpb25FcnJvcihS ZXN1bHRSZWxJbmZvICpyZXN1bHRSZWxJbmZvLAogCQkJCQkJCQkJCVR1cGxlVGFibGVTbG90ICpz bG90LApAQCAtODI3LDYgKzgzMCw0NiBAQCBFeGVjQ2hlY2tYYWN0UmVhZE9ubHkoUGxhbm5lZFN0 bXQgKnBsYW5uZWRzdG10KQogfQogCiAKKy8qCisgKiBFeGVjQ2hlY2tNb2RpZmllZFJlbElkcwor ICoJCVZlcmlmeSB0aGF0IGV2ZXJ5IHJlbGF0aW9uIHRoZSBleGVjdXRvciBhY3R1YWxseSBvcGVu ZWQgZm9yIG1vZGlmaWNhdGlvbgorICoJCW9yIHJvdyBsb2NraW5nIGlzIHByZXNlbnQgaW4gdGhl IHBsYW5uZXIncyBtb2RpZmllZFJlbGlkcy4KKyAqCisgKiBUaGUgcGxhbm5lcidzIHNldCBtYXkg YmUgYSBzdXBlcnNldCBvZiB3aGF0IHRoZSBleGVjdXRvciB0b3VjaGVzLCBiZWNhdXNlIGl0Cisg KiBpbmNsdWRlcyBwYXJ0aXRpb25zIHRoYXQgd2VyZSBwcnVuZWQgYXQgcnVudGltZSBhbmQgcGFy ZW50IHJvdyBtYXJrcyB0aGF0IHRoZQorICogZXhlY3V0b3Igc2tpcHMuCisgKi8KKyNpZmRlZiBV U0VfQVNTRVJUX0NIRUNLSU5HCitzdGF0aWMgdm9pZAorRXhlY0NoZWNrTW9kaWZpZWRSZWxJZHMo RVN0YXRlICplc3RhdGUpCit7CisJUGxhbm5lZFN0bXQgKnBsYW5uZWRzdG10ID0gZXN0YXRlLT5l c19wbGFubmVkc3RtdDsKKwlCaXRtYXBzZXQgICpleGVjdXRvcl9yZWxpZHMgPSBOVUxMOworCUxp c3RDZWxsICAgKmxjOworCisJZm9yZWFjaChsYywgZXN0YXRlLT5lc19vcGVuZWRfcmVzdWx0X3Jl bGF0aW9ucykKKwl7CisJCVJlc3VsdFJlbEluZm8gKnJyaSA9IChSZXN1bHRSZWxJbmZvICopIGxm aXJzdChsYyk7CisKKwkJaWYgKHJyaS0+cmlfUmFuZ2VUYWJsZUluZGV4ICE9IDApCisJCQlleGVj dXRvcl9yZWxpZHMgPSBibXNfYWRkX21lbWJlcihleGVjdXRvcl9yZWxpZHMsCisJCQkJCQkJCQkJ CSBycmktPnJpX1JhbmdlVGFibGVJbmRleCk7CisJfQorCWlmIChlc3RhdGUtPmVzX3Jvd21hcmtz KQorCXsKKwkJZm9yIChpbnQgaSA9IDA7IGkgPCBlc3RhdGUtPmVzX3JhbmdlX3RhYmxlX3NpemU7 IGkrKykKKwkJeworCQkJaWYgKGVzdGF0ZS0+ZXNfcm93bWFya3NbaV0gIT0gTlVMTCkKKwkJCQll eGVjdXRvcl9yZWxpZHMgPSBibXNfYWRkX21lbWJlcihleGVjdXRvcl9yZWxpZHMsCisJCQkJCQkJ CQkJCQkgZXN0YXRlLT5lc19yb3dtYXJrc1tpXS0+cnRpKTsKKwkJfQorCX0KKwlBc3NlcnQoYm1z X2lzX3N1YnNldChleGVjdXRvcl9yZWxpZHMsIHBsYW5uZWRzdG10LT5tb2RpZmllZFJlbGlkcykp OworCWJtc19mcmVlKGV4ZWN1dG9yX3JlbGlkcyk7Cit9CisjZW5kaWYKKworCiAvKiAtLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t CiAgKgkJSW5pdFBsYW4KICAqCkBAIC05OTIsNiArMTAzNSwxMCBAQCBJbml0UGxhbihRdWVyeURl c2MgKnF1ZXJ5RGVzYywgaW50IGVmbGFncykKIAkgKi8KIAlwbGFuc3RhdGUgPSBFeGVjSW5pdE5v ZGUocGxhbiwgZXN0YXRlLCBlZmxhZ3MpOwogCisjaWZkZWYgVVNFX0FTU0VSVF9DSEVDS0lORwor CUV4ZWNDaGVja01vZGlmaWVkUmVsSWRzKGVzdGF0ZSk7CisjZW5kaWYKKwogCS8qCiAJICogR2V0 IHRoZSB0dXBsZSBkZXNjcmlwdG9yIGRlc2NyaWJpbmcgdGhlIHR5cGUgb2YgdHVwbGVzIHRvIHJl dHVybi4KIAkgKi8KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNQYXJhbGxl bC5jIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY1BhcmFsbGVsLmMKaW5kZXggYWM4NGFmMjk0 YzkuLjRmMzk3NjdkMDMzIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjUGFy YWxsZWwuYworKysgYi9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjUGFyYWxsZWwuYwpAQCAtMTg4 LDYgKzE4OCw3IEBAIEV4ZWNTZXJpYWxpemVQbGFuKFBsYW4gKnBsYW4sIEVTdGF0ZSAqZXN0YXRl KQogCXBzdG10LT5wYXJ0UHJ1bmVJbmZvcyA9IGVzdGF0ZS0+ZXNfcGFydF9wcnVuZV9pbmZvczsK IAlwc3RtdC0+cnRhYmxlID0gZXN0YXRlLT5lc19yYW5nZV90YWJsZTsKIAlwc3RtdC0+dW5wcnVu YWJsZVJlbGlkcyA9IGVzdGF0ZS0+ZXNfdW5wcnVuZWRfcmVsaWRzOworCXBzdG10LT5tb2RpZmll ZFJlbGlkcyA9IGVzdGF0ZS0+ZXNfcGxhbm5lZHN0bXQtPm1vZGlmaWVkUmVsaWRzOwogCXBzdG10 LT5wZXJtSW5mb3MgPSBlc3RhdGUtPmVzX3J0ZXBlcm1pbmZvczsKIAlwc3RtdC0+cmVzdWx0UmVs YXRpb25zID0gTklMOwogCXBzdG10LT5hcHBlbmRSZWxhdGlvbnMgPSBOSUw7CmRpZmYgLS1naXQg YS9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlTG9ja1Jvd3MuYyBiL3NyYy9iYWNrZW5kL2V4ZWN1 dG9yL25vZGVMb2NrUm93cy5jCmluZGV4IDhkODY1NDcwNzgwLi5kNjdmMjRmY2E4YyAxMDA2NDQK LS0tIGEvc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZUxvY2tSb3dzLmMKKysrIGIvc3JjL2JhY2tl bmQvZXhlY3V0b3Ivbm9kZUxvY2tSb3dzLmMKQEAgLTExMyw2ICsxMTMsMTAgQEAgbG5leHQ6CiAJ CX0KIAkJZXJtLT5lcm1BY3RpdmUgPSB0cnVlOwogCisJCS8qIHZlcmlmeSB0aGlzIHJlbGF0aW9u IGlzIGluIHRoZSBwbGFubmVyJ3MgbW9kaWZpZWRSZWxpZHMgKi8KKwkJQXNzZXJ0KGJtc19pc19t ZW1iZXIoZXJtLT5ydGksCisJCQkJCQkJIGVzdGF0ZS0+ZXNfcGxhbm5lZHN0bXQtPm1vZGlmaWVk UmVsaWRzKSk7CisKIAkJLyogZmV0Y2ggdGhlIHR1cGxlJ3MgY3RpZCAqLwogCQlkYXR1bSA9IEV4 ZWNHZXRKdW5rQXR0cmlidXRlKHNsb3QsCiAJCQkJCQkJCQkgYWVybS0+Y3RpZEF0dE5vLApkaWZm IC0tZ2l0IGEvc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZU1vZGlmeVRhYmxlLmMgYi9zcmMvYmFj a2VuZC9leGVjdXRvci9ub2RlTW9kaWZ5VGFibGUuYwppbmRleCA0Y2Q1ZTI2MmUwZi4uNmI0ZWU0 ZjkzNzggMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVNb2RpZnlUYWJsZS5j CisrKyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVNb2RpZnlUYWJsZS5jCkBAIC04OTYsNiAr ODk2LDE2IEBAIEV4ZWNJbnNlcnQoTW9kaWZ5VGFibGVDb250ZXh0ICpjb250ZXh0LAogCiAJcmVz dWx0UmVsYXRpb25EZXNjID0gcmVzdWx0UmVsSW5mby0+cmlfUmVsYXRpb25EZXNjOwogCisJLyoK KwkgKiBWZXJpZnkgdGhpcyByZWxhdGlvbiBpcyBpbiB0aGUgcGxhbm5lcidzIHNldCBvZiBtb2Rp ZmllZCByZWxhdGlvbnMuCisJICogUGFydGl0aW9ucyBvcGVuZWQgYnkgdHVwbGUgcm91dGluZyBo YXZlIHJpX1JhbmdlVGFibGVJbmRleCA9PSAwIGJlY2F1c2UKKwkgKiB0aGV5IGhhdmUgbm8gcmFu Z2UgdGFibGUgZW50cnksIHNvIHdlIGNhbiBvbmx5IGNoZWNrIHJlbGF0aW9ucyB0aGF0IGFyZQor CSAqIGluIHRoZSByYW5nZSB0YWJsZS4KKwkgKi8KKwlBc3NlcnQocmVzdWx0UmVsSW5mby0+cmlf UmFuZ2VUYWJsZUluZGV4ID09IDAgfHwKKwkJICAgYm1zX2lzX21lbWJlcihyZXN1bHRSZWxJbmZv LT5yaV9SYW5nZVRhYmxlSW5kZXgsCisJCQkJCQkgZXN0YXRlLT5lc19wbGFubmVkc3RtdC0+bW9k aWZpZWRSZWxpZHMpKTsKKwogCS8qCiAJICogT3BlbiB0aGUgdGFibGUncyBpbmRleGVzLCBpZiB3 ZSBoYXZlIG5vdCBkb25lIHNvIGFscmVhZHksIHNvIHRoYXQgd2UKIAkgKiBjYW4gYWRkIG5ldyBp bmRleCBlbnRyaWVzIGZvciB0aGUgaW5zZXJ0ZWQgdHVwbGUuCkBAIC0xNTIzLDYgKzE1MzMsMTAg QEAgRXhlY0RlbGV0ZUFjdChNb2RpZnlUYWJsZUNvbnRleHQgKmNvbnRleHQsIFJlc3VsdFJlbElu Zm8gKnJlc3VsdFJlbEluZm8sCiB7CiAJRVN0YXRlCSAgICplc3RhdGUgPSBjb250ZXh0LT5lc3Rh dGU7CiAKKwlBc3NlcnQocmVzdWx0UmVsSW5mby0+cmlfUmFuZ2VUYWJsZUluZGV4ID09IDAgfHwK KwkJICAgYm1zX2lzX21lbWJlcihyZXN1bHRSZWxJbmZvLT5yaV9SYW5nZVRhYmxlSW5kZXgsCisJ CQkJCQkgZXN0YXRlLT5lc19wbGFubmVkc3RtdC0+bW9kaWZpZWRSZWxpZHMpKTsKKwogCXJldHVy biB0YWJsZV90dXBsZV9kZWxldGUocmVzdWx0UmVsSW5mby0+cmlfUmVsYXRpb25EZXNjLCB0dXBs ZWlkLAogCQkJCQkJCSAgZXN0YXRlLT5lc19vdXRwdXRfY2lkLAogCQkJCQkJCSAgZXN0YXRlLT5l c19zbmFwc2hvdCwKQEAgLTIyMDUsNiArMjIxOSwxMCBAQCBFeGVjVXBkYXRlQWN0KE1vZGlmeVRh YmxlQ29udGV4dCAqY29udGV4dCwgUmVzdWx0UmVsSW5mbyAqcmVzdWx0UmVsSW5mbywKIAlib29s CQlwYXJ0aXRpb25fY29uc3RyYWludF9mYWlsZWQ7CiAJVE1fUmVzdWx0CXJlc3VsdDsKIAorCUFz c2VydChyZXN1bHRSZWxJbmZvLT5yaV9SYW5nZVRhYmxlSW5kZXggPT0gMCB8fAorCQkgICBibXNf aXNfbWVtYmVyKHJlc3VsdFJlbEluZm8tPnJpX1JhbmdlVGFibGVJbmRleCwKKwkJCQkJCSBlc3Rh dGUtPmVzX3BsYW5uZWRzdG10LT5tb2RpZmllZFJlbGlkcykpOworCiAJdXBkYXRlQ3h0LT5jcm9z c1BhcnRVcGRhdGUgPSBmYWxzZTsKIAogCS8qCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9vcHRp bWl6ZXIvcGxhbi9wbGFubmVyLmMgYi9zcmMvYmFja2VuZC9vcHRpbWl6ZXIvcGxhbi9wbGFubmVy LmMKaW5kZXggNDI2MDRhMGY3NWMuLjg0N2FmOTc5ZTMxIDEwMDY0NAotLS0gYS9zcmMvYmFja2Vu ZC9vcHRpbWl6ZXIvcGxhbi9wbGFubmVyLmMKKysrIGIvc3JjL2JhY2tlbmQvb3B0aW1pemVyL3Bs YW4vcGxhbm5lci5jCkBAIC0zNDAsOCArMzQwLDEwIEBAIHN0YW5kYXJkX3BsYW5uZXIoUXVlcnkg KnBhcnNlLCBjb25zdCBjaGFyICpxdWVyeV9zdHJpbmcsIGludCBjdXJzb3JPcHRpb25zLAogCVJl bE9wdEluZm8gKmZpbmFsX3JlbDsKIAlQYXRoCSAgICpiZXN0X3BhdGg7CiAJUGxhbgkgICAqdG9w X3BsYW47CisJQml0bWFwc2V0ICAqbW9kaWZpZWRSZWxpZHMgPSBOVUxMOwogCUxpc3RDZWxsICAg KmxwLAotCQkJICAgKmxyOworCQkJICAgKmxyLAorCQkJICAgKmxjOwogCiAJLyoKIAkgKiBTZXQg dXAgZ2xvYmFsIHN0YXRlIGZvciB0aGlzIHBsYW5uZXIgaW52b2NhdGlvbi4gIFRoaXMgZGF0YSBp cyBuZWVkZWQKQEAgLTY2MSw2ICs2NjMsMjMgQEAgc3RhbmRhcmRfcGxhbm5lcihRdWVyeSAqcGFy c2UsIGNvbnN0IGNoYXIgKnF1ZXJ5X3N0cmluZywgaW50IGN1cnNvck9wdGlvbnMsCiAJcmVzdWx0 LT5zdWJwbGFucyA9IGdsb2ItPnN1YnBsYW5zOwogCXJlc3VsdC0+cmV3aW5kUGxhbklEcyA9IGds b2ItPnJld2luZFBsYW5JRHM7CiAJcmVzdWx0LT5yb3dNYXJrcyA9IGdsb2ItPmZpbmFscm93bWFy a3M7CisKKwkvKgorCSAqIENvbXB1dGUgbW9kaWZpZWRSZWxpZHMgZnJvbSByZXN1bHQgcmVsYXRp b25zIGFuZCByb3cgbWFya3MuICBUaGlzIGlzIGEKKwkgKiBzdXBlcnNldCBvZiB3aGF0IHRoZSBl eGVjdXRvciB3aWxsIGFjdHVhbGx5IG1vZGlmeS9sb2NrIGF0IHJ1bnRpbWUsCisJICogYmVjYXVz ZSBydW50aW1lIHBhcnRpdGlvbiBwcnVuaW5nIG1heSBlbGltaW5hdGUgc29tZSByZXN1bHQgcmVs YXRpb25zLAorCSAqIGFuZCBwYXJlbnQgcm93IG1hcmtzIGFyZSBpbmNsdWRlZCBoZXJlIGJ1dCBz a2lwcGVkIGJ5IHRoZSBleGVjdXRvci4KKwkgKi8KKwlmb3JlYWNoKGxjLCBnbG9iLT5yZXN1bHRS ZWxhdGlvbnMpCisJCW1vZGlmaWVkUmVsaWRzID0gYm1zX2FkZF9tZW1iZXIobW9kaWZpZWRSZWxp ZHMsIGxmaXJzdF9pbnQobGMpKTsKKwlmb3JlYWNoKGxjLCBnbG9iLT5maW5hbHJvd21hcmtzKQor CXsKKwkJUGxhblJvd01hcmsgKnJjID0gKFBsYW5Sb3dNYXJrICopIGxmaXJzdChsYyk7CisKKwkJ bW9kaWZpZWRSZWxpZHMgPSBibXNfYWRkX21lbWJlcihtb2RpZmllZFJlbGlkcywgcmMtPnJ0aSk7 CisJfQorCXJlc3VsdC0+bW9kaWZpZWRSZWxpZHMgPSBtb2RpZmllZFJlbGlkczsKKwogCXJlc3Vs dC0+cmVsYXRpb25PaWRzID0gZ2xvYi0+cmVsYXRpb25PaWRzOwogCXJlc3VsdC0+aW52YWxJdGVt cyA9IGdsb2ItPmludmFsSXRlbXM7CiAJcmVzdWx0LT5wYXJhbUV4ZWNUeXBlcyA9IGdsb2ItPnBh cmFtRXhlY1R5cGVzOwpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUvbm9kZXMvcGxhbm5vZGVzLmgg Yi9zcmMvaW5jbHVkZS9ub2Rlcy9wbGFubm9kZXMuaAppbmRleCBiNjE4NTgyNWZjYi4uODQxYzc3 MDdjNTkgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL25vZGVzL3BsYW5ub2Rlcy5oCisrKyBiL3Ny Yy9pbmNsdWRlL25vZGVzL3BsYW5ub2Rlcy5oCkBAIC0xMTIsNiArMTEyLDE2IEBAIHR5cGVkZWYg c3RydWN0IFBsYW5uZWRTdG10CiAJICovCiAJQml0bWFwc2V0ICAqdW5wcnVuYWJsZVJlbGlkczsK IAorCS8qCisJICogUlQgaW5kZXhlcyBvZiByZWxhdGlvbnMgbW9kaWZpZWQgYnkgdGhlIHF1ZXJ5 IHRocm91Z2gKKwkgKiBVUERBVEUvREVMRVRFL0lOU0VSVC9NRVJHRSBvciB0YXJnZXRlZCBieSBT RUxFQ1QgRk9SIFVQREFURS9TSEFSRS4KKwkgKgorCSAqIENvbXB1dGVkIGJ5IHRoZSBwbGFubmVy LCB0aGlzIGlzIGEgc3VwZXJzZXQgb2Ygd2hhdCB0aGUgZXhlY3V0b3Igd2lsbAorCSAqIGFjdHVh bGx5IHRvdWNoIGF0IHJ1bnRpbWUsIGJlY2F1c2UgaXQgaW5jbHVkZXMgcGFydGl0aW9ucyB0aGF0 IG1heSBiZQorCSAqIHBydW5lZCBhbmQgcGFyZW50IHJvdyBtYXJrcyB0aGF0IHRoZSBleGVjdXRv ciBza2lwcy4KKwkgKi8KKwlCaXRtYXBzZXQgICptb2RpZmllZFJlbGlkczsKKwogCS8qCiAJICog bGlzdCBvZiBSVEVQZXJtaXNzaW9uSW5mbyBub2RlcyBmb3IgcnRhYmxlIGVudHJpZXMgbmVlZGlu ZyBvbmUKIAkgKi8KLS0gCjIuNDMuMAoK --00000000000060fd69064d6b968a Content-Type: text/x-patch; charset="US-ASCII"; name="v41-0009-Thread-flags-through-begin-scan-APIs.patch" Content-Disposition: attachment; filename="v41-0009-Thread-flags-through-begin-scan-APIs.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmyagq888 RnJvbSBhMmFjYThkY2Q4ZTk0NDA1OGRlZDczNzE4NDM0M2E2OTYwZjdjZWU2IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBUaHUsIDE5IE1hciAyMDI2IDE3OjA1OjU1IC0wNDAwClN1YmplY3Q6IFtQ QVRDSCB2NDEgMDkvMTJdIFRocmVhZCBmbGFncyB0aHJvdWdoIGJlZ2luLXNjYW4gQVBJcwoKQWRk IGEgdXNlci1zZXR0YWJsZSBmbGFncyBwYXJhbWV0ZXIgdG8gdGhlIHRhYmxlX2JlZ2luc2Nhbl8q IHdyYXBwZXJzLAppbmRleF9iZWdpbnNjYW4oKSwgdGFibGVfaW5kZXhfZmV0Y2hfYmVnaW4oKSwg YW5kIHRoZSB0YWJsZQpBTSBjYWxsYmFjayBpbmRleF9mZXRjaF9iZWdpbigpLiBUaGlzIGFsbG93 cyB1c2VycyB0byBwYXNzIGFkZGl0aW9uYWwKY29udGV4dCB0byBiZSB1c2VkIHdoZW4gYnVpbGRp bmcgdGhlIHNjYW4gZGVzY3JpcHRvcnMuCgpGb3IgaW5kZXggc2NhbnMsIGEgbmV3IHVpbnQzMiBm bGFncyBmaWVsZCBpcyBhZGRlZCB0bwpJbmRleEZldGNoVGFibGVEYXRhLCBhbmQgdGhlIGhlYXAg QU0gc3RvcmVzIHRoZSBjYWxsZXItcHJvdmlkZWQgZmxhZ3MKdGhlcmUgaW4gaGVhcGFtX2luZGV4 X2ZldGNoX2JlZ2luKCkuCgpUaGlzIGludHJvZHVjZXMgYW4gZXh0ZW5zaW9uIHBvaW50IGZvciBm b2xsb3ctdXAgd29yayB0byBwYXNzCnBlci1zY2FuIGluZm9ybWF0aW9uIChzdWNoIGFzIHdoZXRo ZXIgdGhlIHJlbGF0aW9uIGlzIHJlYWQtb25seSBmb3IgdGhlCmN1cnJlbnQgcXVlcnkpIGZyb20g dGhlIGV4ZWN1dG9yIHRvIHRoZSBBTSBsYXllci4KCkF1dGhvcjogTWVsYW5pZSBQbGFnZW1hbiA8 bWVsYW5pZXBsYWdlbWFuQGdtYWlsLmNvbT4KUmV2aWV3ZWQtYnk6IEFuZHJlcyBGcmV1bmQgPGFu ZHJlc0BhbmFyYXplbC5kZT4KUmV2aWV3ZWQtYnk6IENoYW8gTGkgPGxpLmV2YW4uY2hhb0BnbWFp bC5jb20+CkRpc2N1c3Npb246IGh0dHBzOi8vcG9zdGdyLmVzL20vRjVDREQxQjUtNjI4Qy00NEEx LTlGODUtMzk1OEM2MjZGNkE5JTQwZ21haWwuY29tCi0tLQogY29udHJpYi9wZ3Jvd2xvY2tzL3Bn cm93bG9ja3MuYyAgICAgICAgICAgfCAgMiArLQogc3JjL2JhY2tlbmQvYWNjZXNzL2JyaW4vYnJp bi5jICAgICAgICAgICAgfCAgMyArLQogc3JjL2JhY2tlbmQvYWNjZXNzL2dpbi9naW5pbnNlcnQu YyAgICAgICAgfCAgMyArLQogc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvaGVhcGFtX2hhbmRsZXIu YyAgfCAgOSArKy0KIHNyYy9iYWNrZW5kL2FjY2Vzcy9pbmRleC9nZW5hbS5jICAgICAgICAgIHwg IDIgKwogc3JjL2JhY2tlbmQvYWNjZXNzL2luZGV4L2luZGV4YW0uYyAgICAgICAgfCAgNyArKy0K IHNyYy9iYWNrZW5kL2FjY2Vzcy9uYnRyZWUvbmJ0c29ydC5jICAgICAgIHwgIDIgKy0KIHNyYy9i YWNrZW5kL2FjY2Vzcy90YWJsZS90YWJsZWFtLmMgICAgICAgIHwgMjEgKysrLS0tLQogc3JjL2Jh Y2tlbmQvY29tbWFuZHMvY29uc3RyYWludC5jICAgICAgICAgfCAgMiArLQogc3JjL2JhY2tlbmQv Y29tbWFuZHMvY29weXRvLmMgICAgICAgICAgICAgfCAgMiArLQogc3JjL2JhY2tlbmQvY29tbWFu ZHMvdGFibGVjbWRzLmMgICAgICAgICAgfCAgOCArLS0KIHNyYy9iYWNrZW5kL2NvbW1hbmRzL3R5 cGVjbWRzLmMgICAgICAgICAgIHwgIDQgKy0KIHNyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNJbmRl eGluZy5jICAgICAgIHwgIDMgKy0KIHNyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNSZXBsaWNhdGlv bi5jICAgIHwgMTIgKystLQogc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZUJpdG1hcEhlYXBzY2Fu LmMgfCAgMiArLQogc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZUluZGV4b25seXNjYW4uYyAgfCAg NSArLQogc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZUluZGV4c2Nhbi5jICAgICAgfCAgNiArLQog c3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZVNhbXBsZXNjYW4uYyAgICAgfCAgMiArLQogc3JjL2Jh Y2tlbmQvZXhlY3V0b3Ivbm9kZVNlcXNjYW4uYyAgICAgICAgfCAgNiArLQogc3JjL2JhY2tlbmQv ZXhlY3V0b3Ivbm9kZVRpZHJhbmdlc2Nhbi5jICAgfCAgNiArLQogc3JjL2JhY2tlbmQvcGFydGl0 aW9uaW5nL3BhcnRib3VuZHMuYyAgICAgfCAgMiArLQogc3JjL2JhY2tlbmQvdXRpbHMvYWR0L3Nl bGZ1bmNzLmMgICAgICAgICAgfCAgMSArCiBzcmMvaW5jbHVkZS9hY2Nlc3MvZ2VuYW0uaCAgICAg ICAgICAgICAgICB8ICA0ICstCiBzcmMvaW5jbHVkZS9hY2Nlc3MvaGVhcGFtLmggICAgICAgICAg ICAgICB8ICA1ICstCiBzcmMvaW5jbHVkZS9hY2Nlc3MvcmVsc2Nhbi5oICAgICAgICAgICAgICB8 ICAxICsKIHNyYy9pbmNsdWRlL2FjY2Vzcy90YWJsZWFtLmggICAgICAgICAgICAgIHwgNzIgKysr KysrKysrKysrKysrLS0tLS0tLS0KIDI2IGZpbGVzIGNoYW5nZWQsIDExNyBpbnNlcnRpb25zKCsp LCA3NSBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9jb250cmliL3Bncm93bG9ja3MvcGdyb3ds b2Nrcy5jIGIvY29udHJpYi9wZ3Jvd2xvY2tzL3Bncm93bG9ja3MuYwppbmRleCBmZjM2OTJjODdj NC4uMDU1NmU5ZjdiODggMTAwNjQ0Ci0tLSBhL2NvbnRyaWIvcGdyb3dsb2Nrcy9wZ3Jvd2xvY2tz LmMKKysrIGIvY29udHJpYi9wZ3Jvd2xvY2tzL3Bncm93bG9ja3MuYwpAQCAtMTE1LDcgKzExNSw3 IEBAIHBncm93bG9ja3MoUEdfRlVOQ1RJT05fQVJHUykKIAkJCQkJICAgUmVsYXRpb25HZXRSZWxh dGlvbk5hbWUocmVsKSk7CiAKIAkvKiBTY2FuIHRoZSByZWxhdGlvbiAqLwotCXNjYW4gPSB0YWJs ZV9iZWdpbnNjYW4ocmVsLCBHZXRBY3RpdmVTbmFwc2hvdCgpLCAwLCBOVUxMKTsKKwlzY2FuID0g dGFibGVfYmVnaW5zY2FuKHJlbCwgR2V0QWN0aXZlU25hcHNob3QoKSwgMCwgTlVMTCwgMCk7CiAJ aHNjYW4gPSAoSGVhcFNjYW5EZXNjKSBzY2FuOwogCiAJYXR0aW5tZXRhID0gVHVwbGVEZXNjR2V0 QXR0SW5NZXRhZGF0YShyc2luZm8tPnNldERlc2MpOwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQv YWNjZXNzL2JyaW4vYnJpbi5jIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2JyaW4vYnJpbi5jCmluZGV4 IDJhMGY4YzhlM2I4Li5iMjVlODE0YTk5NiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvYWNjZXNz L2JyaW4vYnJpbi5jCisrKyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9icmluL2JyaW4uYwpAQCAtMjg0 NCw3ICsyODQ0LDggQEAgX2JyaW5fcGFyYWxsZWxfc2Nhbl9hbmRfYnVpbGQoQnJpbkJ1aWxkU3Rh dGUgKnN0YXRlLAogCWluZGV4SW5mby0+aWlfQ29uY3VycmVudCA9IGJyaW5zaGFyZWQtPmlzY29u Y3VycmVudDsKIAogCXNjYW4gPSB0YWJsZV9iZWdpbnNjYW5fcGFyYWxsZWwoaGVhcCwKLQkJCQkJ CQkJCVBhcmFsbGVsVGFibGVTY2FuRnJvbUJyaW5TaGFyZWQoYnJpbnNoYXJlZCkpOworCQkJCQkJ CQkJUGFyYWxsZWxUYWJsZVNjYW5Gcm9tQnJpblNoYXJlZChicmluc2hhcmVkKSwKKwkJCQkJCQkJ CTApOwogCiAJcmVsdHVwbGVzID0gdGFibGVfaW5kZXhfYnVpbGRfc2NhbihoZWFwLCBpbmRleCwg aW5kZXhJbmZvLCB0cnVlLCB0cnVlLAogCQkJCQkJCQkJICAgYnJpbmJ1aWxkQ2FsbGJhY2tQYXJh bGxlbCwgc3RhdGUsIHNjYW4pOwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvYWNjZXNzL2dpbi9n aW5pbnNlcnQuYyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9naW4vZ2luaW5zZXJ0LmMKaW5kZXggZTU0 NzgyZDlkZDguLjU1NWIxNjc3MWU5IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nlc3MvZ2lu L2dpbmluc2VydC5jCisrKyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9naW4vZ2luaW5zZXJ0LmMKQEAg LTIwNjgsNyArMjA2OCw4IEBAIF9naW5fcGFyYWxsZWxfc2Nhbl9hbmRfYnVpbGQoR2luQnVpbGRT dGF0ZSAqc3RhdGUsCiAJaW5kZXhJbmZvLT5paV9Db25jdXJyZW50ID0gZ2luc2hhcmVkLT5pc2Nv bmN1cnJlbnQ7CiAKIAlzY2FuID0gdGFibGVfYmVnaW5zY2FuX3BhcmFsbGVsKGhlYXAsCi0JCQkJ CQkJCQlQYXJhbGxlbFRhYmxlU2NhbkZyb21HaW5CdWlsZFNoYXJlZChnaW5zaGFyZWQpKTsKKwkJ CQkJCQkJCVBhcmFsbGVsVGFibGVTY2FuRnJvbUdpbkJ1aWxkU2hhcmVkKGdpbnNoYXJlZCksCisJ CQkJCQkJCQkwKTsKIAogCXJlbHR1cGxlcyA9IHRhYmxlX2luZGV4X2J1aWxkX3NjYW4oaGVhcCwg aW5kZXgsIGluZGV4SW5mbywgdHJ1ZSwgcHJvZ3Jlc3MsCiAJCQkJCQkJCQkgICBnaW5CdWlsZENh bGxiYWNrUGFyYWxsZWwsIHN0YXRlLCBzY2FuKTsKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2Fj Y2Vzcy9oZWFwL2hlYXBhbV9oYW5kbGVyLmMgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9oZWFw YW1faGFuZGxlci5jCmluZGV4IDI1M2E3MzViNmMxLi42NjcyNmIyMmRlNiAxMDA2NDQKLS0tIGEv c3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvaGVhcGFtX2hhbmRsZXIuYworKysgYi9zcmMvYmFja2Vu ZC9hY2Nlc3MvaGVhcC9oZWFwYW1faGFuZGxlci5jCkBAIC04MCwxMSArODAsMTIgQEAgaGVhcGFt X3Nsb3RfY2FsbGJhY2tzKFJlbGF0aW9uIHJlbGF0aW9uKQogICovCiAKIHN0YXRpYyBJbmRleEZl dGNoVGFibGVEYXRhICoKLWhlYXBhbV9pbmRleF9mZXRjaF9iZWdpbihSZWxhdGlvbiByZWwpCito ZWFwYW1faW5kZXhfZmV0Y2hfYmVnaW4oUmVsYXRpb24gcmVsLCB1aW50MzIgZmxhZ3MpCiB7CiAJ SW5kZXhGZXRjaEhlYXBEYXRhICpoc2NhbiA9IHBhbGxvYzBfb2JqZWN0KEluZGV4RmV0Y2hIZWFw RGF0YSk7CiAKIAloc2Nhbi0+eHNfYmFzZS5yZWwgPSByZWw7CisJaHNjYW4tPnhzX2Jhc2UuZmxh Z3MgPSBmbGFnczsKIAloc2Nhbi0+eHNfY2J1ZiA9IEludmFsaWRCdWZmZXI7CiAJaHNjYW4tPnhz X3ZtYnVmZmVyID0gSW52YWxpZEJ1ZmZlcjsKIApAQCAtNzYyLDcgKzc2Myw5IEBAIGhlYXBhbV9y ZWxhdGlvbl9jb3B5X2Zvcl9jbHVzdGVyKFJlbGF0aW9uIE9sZEhlYXAsIFJlbGF0aW9uIE5ld0hl YXAsCiAKIAkJdGFibGVTY2FuID0gTlVMTDsKIAkJaGVhcFNjYW4gPSBOVUxMOwotCQlpbmRleFNj YW4gPSBpbmRleF9iZWdpbnNjYW4oT2xkSGVhcCwgT2xkSW5kZXgsIFNuYXBzaG90QW55LCBOVUxM LCAwLCAwKTsKKwkJaW5kZXhTY2FuID0gaW5kZXhfYmVnaW5zY2FuKE9sZEhlYXAsIE9sZEluZGV4 LAorCQkJCQkJCQkJMCwJLyogZmxhZ3MgKi8KKwkJCQkJCQkJCVNuYXBzaG90QW55LCBOVUxMLCAw LCAwKTsKIAkJaW5kZXhfcmVzY2FuKGluZGV4U2NhbiwgTlVMTCwgMCwgTlVMTCwgMCk7CiAJfQog CWVsc2UKQEAgLTc3MSw3ICs3NzQsNyBAQCBoZWFwYW1fcmVsYXRpb25fY29weV9mb3JfY2x1c3Rl cihSZWxhdGlvbiBPbGRIZWFwLCBSZWxhdGlvbiBOZXdIZWFwLAogCQlwZ3N0YXRfcHJvZ3Jlc3Nf dXBkYXRlX3BhcmFtKFBST0dSRVNTX1JFUEFDS19QSEFTRSwKIAkJCQkJCQkJCSBQUk9HUkVTU19S RVBBQ0tfUEhBU0VfU0VRX1NDQU5fSEVBUCk7CiAKLQkJdGFibGVTY2FuID0gdGFibGVfYmVnaW5z Y2FuKE9sZEhlYXAsIFNuYXBzaG90QW55LCAwLCAoU2NhbktleSkgTlVMTCk7CisJCXRhYmxlU2Nh biA9IHRhYmxlX2JlZ2luc2NhbihPbGRIZWFwLCBTbmFwc2hvdEFueSwgMCwgKFNjYW5LZXkpIE5V TEwsIDApOwogCQloZWFwU2NhbiA9IChIZWFwU2NhbkRlc2MpIHRhYmxlU2NhbjsKIAkJaW5kZXhT Y2FuID0gTlVMTDsKIApkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvYWNjZXNzL2luZGV4L2dlbmFt LmMgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaW5kZXgvZ2VuYW0uYwppbmRleCA1ZTg5Yjg2YTYyYy4u YjA5OWQ5NTZlNDEgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9pbmRleC9nZW5hbS5j CisrKyBiL3NyYy9iYWNrZW5kL2FjY2Vzcy9pbmRleC9nZW5hbS5jCkBAIC00NTUsNiArNDU1LDcg QEAgc3lzdGFibGVfYmVnaW5zY2FuKFJlbGF0aW9uIGhlYXBSZWxhdGlvbiwKIAkJfQogCiAJCXN5 c3NjYW4tPmlzY2FuID0gaW5kZXhfYmVnaW5zY2FuKGhlYXBSZWxhdGlvbiwgaXJlbCwKKwkJCQkJ CQkJCQkgMCwgLyogZmxhZ3MgKi8KIAkJCQkJCQkJCQkgc25hcHNob3QsIE5VTEwsIG5rZXlzLCAw KTsKIAkJaW5kZXhfcmVzY2FuKHN5c3NjYW4tPmlzY2FuLCBpZHhrZXksIG5rZXlzLCBOVUxMLCAw KTsKIAkJc3lzc2Nhbi0+c2NhbiA9IE5VTEw7CkBAIC03MTYsNiArNzE3LDcgQEAgc3lzdGFibGVf YmVnaW5zY2FuX29yZGVyZWQoUmVsYXRpb24gaGVhcFJlbGF0aW9uLAogCQlic3lzc2NhbiA9IHRy dWU7CiAKIAlzeXNzY2FuLT5pc2NhbiA9IGluZGV4X2JlZ2luc2NhbihoZWFwUmVsYXRpb24sIGlu ZGV4UmVsYXRpb24sCisJCQkJCQkJCQkgMCwgLyogZmxhZ3MgKi8KIAkJCQkJCQkJCSBzbmFwc2hv dCwgTlVMTCwgbmtleXMsIDApOwogCWluZGV4X3Jlc2NhbihzeXNzY2FuLT5pc2NhbiwgaWR4a2V5 LCBua2V5cywgTlVMTCwgMCk7CiAJc3lzc2Nhbi0+c2NhbiA9IE5VTEw7CmRpZmYgLS1naXQgYS9z cmMvYmFja2VuZC9hY2Nlc3MvaW5kZXgvaW5kZXhhbS5jIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2lu ZGV4L2luZGV4YW0uYwppbmRleCA1ZWI3ZTk5YWQzZS4uNjNkNWRhYWRjYTYgMTAwNjQ0Ci0tLSBh L3NyYy9iYWNrZW5kL2FjY2Vzcy9pbmRleC9pbmRleGFtLmMKKysrIGIvc3JjL2JhY2tlbmQvYWNj ZXNzL2luZGV4L2luZGV4YW0uYwpAQCAtMjU1LDYgKzI1NSw3IEBAIGluZGV4X2luc2VydF9jbGVh bnVwKFJlbGF0aW9uIGluZGV4UmVsYXRpb24sCiBJbmRleFNjYW5EZXNjCiBpbmRleF9iZWdpbnNj YW4oUmVsYXRpb24gaGVhcFJlbGF0aW9uLAogCQkJCVJlbGF0aW9uIGluZGV4UmVsYXRpb24sCisJ CQkJdWludDMyIGZsYWdzLAogCQkJCVNuYXBzaG90IHNuYXBzaG90LAogCQkJCUluZGV4U2Nhbklu c3RydW1lbnRhdGlvbiAqaW5zdHJ1bWVudCwKIAkJCQlpbnQgbmtleXMsIGludCBub3JkZXJieXMp CkBAIC0yODQsNyArMjg1LDcgQEAgaW5kZXhfYmVnaW5zY2FuKFJlbGF0aW9uIGhlYXBSZWxhdGlv biwKIAlzY2FuLT5pbnN0cnVtZW50ID0gaW5zdHJ1bWVudDsKIAogCS8qIHByZXBhcmUgdG8gZmV0 Y2ggaW5kZXggbWF0Y2hlcyBmcm9tIHRhYmxlICovCi0Jc2Nhbi0+eHNfaGVhcGZldGNoID0gdGFi bGVfaW5kZXhfZmV0Y2hfYmVnaW4oaGVhcFJlbGF0aW9uKTsKKwlzY2FuLT54c19oZWFwZmV0Y2gg PSB0YWJsZV9pbmRleF9mZXRjaF9iZWdpbihoZWFwUmVsYXRpb24sIGZsYWdzKTsKIAogCXJldHVy biBzY2FuOwogfQpAQCAtNTkzLDcgKzU5NCw3IEBAIEluZGV4U2NhbkRlc2MKIGluZGV4X2JlZ2lu c2Nhbl9wYXJhbGxlbChSZWxhdGlvbiBoZWFwcmVsLCBSZWxhdGlvbiBpbmRleHJlbCwKIAkJCQkJ CSBJbmRleFNjYW5JbnN0cnVtZW50YXRpb24gKmluc3RydW1lbnQsCiAJCQkJCQkgaW50IG5rZXlz LCBpbnQgbm9yZGVyYnlzLAotCQkJCQkJIFBhcmFsbGVsSW5kZXhTY2FuRGVzYyBwc2NhbikKKwkJ CQkJCSBQYXJhbGxlbEluZGV4U2NhbkRlc2MgcHNjYW4sIHVpbnQzMiBmbGFncykKIHsKIAlTbmFw c2hvdAlzbmFwc2hvdDsKIAlJbmRleFNjYW5EZXNjIHNjYW47CkBAIC02MTUsNyArNjE2LDcgQEAg aW5kZXhfYmVnaW5zY2FuX3BhcmFsbGVsKFJlbGF0aW9uIGhlYXByZWwsIFJlbGF0aW9uIGluZGV4 cmVsLAogCXNjYW4tPmluc3RydW1lbnQgPSBpbnN0cnVtZW50OwogCiAJLyogcHJlcGFyZSB0byBm ZXRjaCBpbmRleCBtYXRjaGVzIGZyb20gdGFibGUgKi8KLQlzY2FuLT54c19oZWFwZmV0Y2ggPSB0 YWJsZV9pbmRleF9mZXRjaF9iZWdpbihoZWFwcmVsKTsKKwlzY2FuLT54c19oZWFwZmV0Y2ggPSB0 YWJsZV9pbmRleF9mZXRjaF9iZWdpbihoZWFwcmVsLCBmbGFncyk7CiAKIAlyZXR1cm4gc2NhbjsK IH0KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9uYnRyZWUvbmJ0c29ydC5jIGIvc3Jj L2JhY2tlbmQvYWNjZXNzL25idHJlZS9uYnRzb3J0LmMKaW5kZXggNDdhOWJkYTMwYzkuLjAxNmE1 ZTU0NmRkIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nlc3MvbmJ0cmVlL25idHNvcnQuYwor KysgYi9zcmMvYmFja2VuZC9hY2Nlc3MvbmJ0cmVlL25idHNvcnQuYwpAQCAtMTkyOCw3ICsxOTI4 LDcgQEAgX2J0X3BhcmFsbGVsX3NjYW5fYW5kX3NvcnQoQlRTcG9vbCAqYnRzcG9vbCwgQlRTcG9v bCAqYnRzcG9vbDIsCiAJaW5kZXhJbmZvID0gQnVpbGRJbmRleEluZm8oYnRzcG9vbC0+aW5kZXgp OwogCWluZGV4SW5mby0+aWlfQ29uY3VycmVudCA9IGJ0c2hhcmVkLT5pc2NvbmN1cnJlbnQ7CiAJ c2NhbiA9IHRhYmxlX2JlZ2luc2Nhbl9wYXJhbGxlbChidHNwb29sLT5oZWFwLAotCQkJCQkJCQkJ UGFyYWxsZWxUYWJsZVNjYW5Gcm9tQlRTaGFyZWQoYnRzaGFyZWQpKTsKKwkJCQkJCQkJCVBhcmFs bGVsVGFibGVTY2FuRnJvbUJUU2hhcmVkKGJ0c2hhcmVkKSwgMCk7CiAJcmVsdHVwbGVzID0gdGFi bGVfaW5kZXhfYnVpbGRfc2NhbihidHNwb29sLT5oZWFwLCBidHNwb29sLT5pbmRleCwgaW5kZXhJ bmZvLAogCQkJCQkJCQkJICAgdHJ1ZSwgcHJvZ3Jlc3MsIF9idF9idWlsZF9jYWxsYmFjaywKIAkJ CQkJCQkJCSAgICZidWlsZHN0YXRlLCBzY2FuKTsKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2Fj Y2Vzcy90YWJsZS90YWJsZWFtLmMgYi9zcmMvYmFja2VuZC9hY2Nlc3MvdGFibGUvdGFibGVhbS5j CmluZGV4IGRmZGExYWY0MTJlLi43YTEyZTgwOGIwNyAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQv YWNjZXNzL3RhYmxlL3RhYmxlYW0uYworKysgYi9zcmMvYmFja2VuZC9hY2Nlc3MvdGFibGUvdGFi bGVhbS5jCkBAIC0xMTgsNyArMTE4LDcgQEAgdGFibGVfYmVnaW5zY2FuX2NhdGFsb2coUmVsYXRp b24gcmVsYXRpb24sIGludCBua2V5cywgU2NhbktleURhdGEgKmtleSkKIAlTbmFwc2hvdAlzbmFw c2hvdCA9IFJlZ2lzdGVyU25hcHNob3QoR2V0Q2F0YWxvZ1NuYXBzaG90KHJlbGlkKSk7CiAKIAly ZXR1cm4gdGFibGVfYmVnaW5zY2FuX2NvbW1vbihyZWxhdGlvbiwgc25hcHNob3QsIG5rZXlzLCBr ZXksCi0JCQkJCQkJCSAgTlVMTCwgZmxhZ3MpOworCQkJCQkJCQkgIE5VTEwsIGZsYWdzLCAwKTsK IH0KIAogCkBAIC0xNjMsMTAgKzE2MywxMCBAQCB0YWJsZV9wYXJhbGxlbHNjYW5faW5pdGlhbGl6 ZShSZWxhdGlvbiByZWwsIFBhcmFsbGVsVGFibGVTY2FuRGVzYyBwc2NhbiwKIH0KIAogVGFibGVT Y2FuRGVzYwotdGFibGVfYmVnaW5zY2FuX3BhcmFsbGVsKFJlbGF0aW9uIHJlbGF0aW9uLCBQYXJh bGxlbFRhYmxlU2NhbkRlc2MgcHNjYW4pCit0YWJsZV9iZWdpbnNjYW5fcGFyYWxsZWwoUmVsYXRp b24gcmVsYXRpb24sIFBhcmFsbGVsVGFibGVTY2FuRGVzYyBwc2NhbiwgdWludDMyIGZsYWdzKQog ewogCVNuYXBzaG90CXNuYXBzaG90OwotCXVpbnQzMgkJZmxhZ3MgPSBTT19UWVBFX1NFUVNDQU4g fAorCXVpbnQzMgkJaW50ZXJuYWxfZmxhZ3MgPSBTT19UWVBFX1NFUVNDQU4gfAogCQlTT19BTExP V19TVFJBVCB8IFNPX0FMTE9XX1NZTkMgfCBTT19BTExPV19QQUdFTU9ERTsKIAogCUFzc2VydChS ZWxGaWxlTG9jYXRvckVxdWFscyhyZWxhdGlvbi0+cmRfbG9jYXRvciwgcHNjYW4tPnBoc19sb2Nh dG9yKSk7CkBAIC0xNzYsNyArMTc2LDcgQEAgdGFibGVfYmVnaW5zY2FuX3BhcmFsbGVsKFJlbGF0 aW9uIHJlbGF0aW9uLCBQYXJhbGxlbFRhYmxlU2NhbkRlc2MgcHNjYW4pCiAJCS8qIFNuYXBzaG90 IHdhcyBzZXJpYWxpemVkIC0tIHJlc3RvcmUgaXQgKi8KIAkJc25hcHNob3QgPSBSZXN0b3JlU25h cHNob3QoKGNoYXIgKikgcHNjYW4gKyBwc2Nhbi0+cGhzX3NuYXBzaG90X29mZik7CiAJCVJlZ2lz dGVyU25hcHNob3Qoc25hcHNob3QpOwotCQlmbGFncyB8PSBTT19URU1QX1NOQVBTSE9UOworCQlp bnRlcm5hbF9mbGFncyB8PSBTT19URU1QX1NOQVBTSE9UOwogCX0KIAllbHNlCiAJewpAQCAtMTg1 LDE2ICsxODUsMTcgQEAgdGFibGVfYmVnaW5zY2FuX3BhcmFsbGVsKFJlbGF0aW9uIHJlbGF0aW9u LCBQYXJhbGxlbFRhYmxlU2NhbkRlc2MgcHNjYW4pCiAJfQogCiAJcmV0dXJuIHRhYmxlX2JlZ2lu c2Nhbl9jb21tb24ocmVsYXRpb24sIHNuYXBzaG90LCAwLCBOVUxMLAotCQkJCQkJCQkgIHBzY2Fu LCBmbGFncyk7CisJCQkJCQkJCSAgcHNjYW4sIGludGVybmFsX2ZsYWdzLCBmbGFncyk7CiB9CiAK IFRhYmxlU2NhbkRlc2MKIHRhYmxlX2JlZ2luc2Nhbl9wYXJhbGxlbF90aWRyYW5nZShSZWxhdGlv biByZWxhdGlvbiwKLQkJCQkJCQkJICBQYXJhbGxlbFRhYmxlU2NhbkRlc2MgcHNjYW4pCisJCQkJ CQkJCSAgUGFyYWxsZWxUYWJsZVNjYW5EZXNjIHBzY2FuLAorCQkJCQkJCQkgIHVpbnQzMiBmbGFn cykKIHsKIAlTbmFwc2hvdAlzbmFwc2hvdDsKLQl1aW50MzIJCWZsYWdzID0gU09fVFlQRV9USURS QU5HRVNDQU4gfCBTT19BTExPV19QQUdFTU9ERTsKIAlUYWJsZVNjYW5EZXNjIHNzY2FuOworCXVp bnQzMgkJaW50ZXJuYWxfZmxhZ3MgPSBTT19UWVBFX1RJRFJBTkdFU0NBTiB8IFNPX0FMTE9XX1BB R0VNT0RFOwogCiAJQXNzZXJ0KFJlbEZpbGVMb2NhdG9yRXF1YWxzKHJlbGF0aW9uLT5yZF9sb2Nh dG9yLCBwc2Nhbi0+cGhzX2xvY2F0b3IpKTsKIApAQCAtMjA2LDcgKzIwNyw3IEBAIHRhYmxlX2Jl Z2luc2Nhbl9wYXJhbGxlbF90aWRyYW5nZShSZWxhdGlvbiByZWxhdGlvbiwKIAkJLyogU25hcHNo b3Qgd2FzIHNlcmlhbGl6ZWQgLS0gcmVzdG9yZSBpdCAqLwogCQlzbmFwc2hvdCA9IFJlc3RvcmVT bmFwc2hvdCgoY2hhciAqKSBwc2NhbiArIHBzY2FuLT5waHNfc25hcHNob3Rfb2ZmKTsKIAkJUmVn aXN0ZXJTbmFwc2hvdChzbmFwc2hvdCk7Ci0JCWZsYWdzIHw9IFNPX1RFTVBfU05BUFNIT1Q7CisJ CWludGVybmFsX2ZsYWdzIHw9IFNPX1RFTVBfU05BUFNIT1Q7CiAJfQogCWVsc2UKIAl7CkBAIC0y MTUsNyArMjE2LDcgQEAgdGFibGVfYmVnaW5zY2FuX3BhcmFsbGVsX3RpZHJhbmdlKFJlbGF0aW9u IHJlbGF0aW9uLAogCX0KIAogCXNzY2FuID0gdGFibGVfYmVnaW5zY2FuX2NvbW1vbihyZWxhdGlv biwgc25hcHNob3QsIDAsIE5VTEwsCi0JCQkJCQkJCSAgIHBzY2FuLCBmbGFncyk7CisJCQkJCQkJ CSAgIHBzY2FuLCBpbnRlcm5hbF9mbGFncywgZmxhZ3MpOwogCXJldHVybiBzc2NhbjsKIH0KIApA QCAtMjQ4LDcgKzI0OSw3IEBAIHRhYmxlX2luZGV4X2ZldGNoX3R1cGxlX2NoZWNrKFJlbGF0aW9u IHJlbCwKIAlib29sCQlmb3VuZDsKIAogCXNsb3QgPSB0YWJsZV9zbG90X2NyZWF0ZShyZWwsIE5V TEwpOwotCXNjYW4gPSB0YWJsZV9pbmRleF9mZXRjaF9iZWdpbihyZWwpOworCXNjYW4gPSB0YWJs ZV9pbmRleF9mZXRjaF9iZWdpbihyZWwsIDApOwogCWZvdW5kID0gdGFibGVfaW5kZXhfZmV0Y2hf dHVwbGUoc2NhbiwgdGlkLCBzbmFwc2hvdCwgc2xvdCwgJmNhbGxfYWdhaW4sCiAJCQkJCQkJCQlh bGxfZGVhZCk7CiAJdGFibGVfaW5kZXhfZmV0Y2hfZW5kKHNjYW4pOwpkaWZmIC0tZ2l0IGEvc3Jj L2JhY2tlbmQvY29tbWFuZHMvY29uc3RyYWludC5jIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvY29u c3RyYWludC5jCmluZGV4IGNjMTFjNDdiNmYyLi4zN2NmYmQ2MzkzOCAxMDA2NDQKLS0tIGEvc3Jj L2JhY2tlbmQvY29tbWFuZHMvY29uc3RyYWludC5jCisrKyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRz L2NvbnN0cmFpbnQuYwpAQCAtMTA2LDcgKzEwNiw3IEBAIHVuaXF1ZV9rZXlfcmVjaGVjayhQR19G VU5DVElPTl9BUkdTKQogCSAqLwogCXRtcHRpZCA9IGNoZWNrdGlkOwogCXsKLQkJSW5kZXhGZXRj aFRhYmxlRGF0YSAqc2NhbiA9IHRhYmxlX2luZGV4X2ZldGNoX2JlZ2luKHRyaWdkYXRhLT50Z19y ZWxhdGlvbik7CisJCUluZGV4RmV0Y2hUYWJsZURhdGEgKnNjYW4gPSB0YWJsZV9pbmRleF9mZXRj aF9iZWdpbih0cmlnZGF0YS0+dGdfcmVsYXRpb24sIDApOwogCQlib29sCQljYWxsX2FnYWluID0g ZmFsc2U7CiAKIAkJaWYgKCF0YWJsZV9pbmRleF9mZXRjaF90dXBsZShzY2FuLCAmdG1wdGlkLCBT bmFwc2hvdFNlbGYsIHNsb3QsCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9jb21tYW5kcy9jb3B5 dG8uYyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL2NvcHl0by5jCmluZGV4IDQ5OWNlOWFkM2RiLi5m Yjc5MWM3OTkwYiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvY29weXRvLmMKKysr IGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvY29weXRvLmMKQEAgLTExNjAsNyArMTE2MCw3IEBAIENv cHlSZWxhdGlvblRvKENvcHlUb1N0YXRlIGNzdGF0ZSwgUmVsYXRpb24gcmVsLCBSZWxhdGlvbiBy b290X3JlbCwgdWludDY0ICpwcm9jCiAJQXR0ck1hcCAgICAqbWFwID0gTlVMTDsKIAlUdXBsZVRh YmxlU2xvdCAqcm9vdF9zbG90ID0gTlVMTDsKIAotCXNjYW5kZXNjID0gdGFibGVfYmVnaW5zY2Fu KHJlbCwgR2V0QWN0aXZlU25hcHNob3QoKSwgMCwgTlVMTCk7CisJc2NhbmRlc2MgPSB0YWJsZV9i ZWdpbnNjYW4ocmVsLCBHZXRBY3RpdmVTbmFwc2hvdCgpLCAwLCBOVUxMLCAwKTsKIAlzbG90ID0g dGFibGVfc2xvdF9jcmVhdGUocmVsLCBOVUxMKTsKIAogCS8qCmRpZmYgLS1naXQgYS9zcmMvYmFj a2VuZC9jb21tYW5kcy90YWJsZWNtZHMuYyBiL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3RhYmxlY21k cy5jCmluZGV4IDY3ZTQyZTVkZjI5Li5jYzJlYzkzOTNhOCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tl bmQvY29tbWFuZHMvdGFibGVjbWRzLmMKKysrIGIvc3JjL2JhY2tlbmQvY29tbWFuZHMvdGFibGVj bWRzLmMKQEAgLTY0MTEsNyArNjQxMSw3IEBAIEFUUmV3cml0ZVRhYmxlKEFsdGVyZWRUYWJsZUlu Zm8gKnRhYiwgT2lkIE9JRE5ld0hlYXApCiAJCSAqIGNoZWNraW5nIGFsbCB0aGUgY29uc3RyYWlu dHMuCiAJCSAqLwogCQlzbmFwc2hvdCA9IFJlZ2lzdGVyU25hcHNob3QoR2V0TGF0ZXN0U25hcHNo b3QoKSk7Ci0JCXNjYW4gPSB0YWJsZV9iZWdpbnNjYW4ob2xkcmVsLCBzbmFwc2hvdCwgMCwgTlVM TCk7CisJCXNjYW4gPSB0YWJsZV9iZWdpbnNjYW4ob2xkcmVsLCBzbmFwc2hvdCwgMCwgTlVMTCwg MCk7CiAKIAkJLyoKIAkJICogU3dpdGNoIHRvIHBlci10dXBsZSBtZW1vcnkgY29udGV4dCBhbmQg cmVzZXQgaXQgZm9yIGVhY2ggdHVwbGUKQEAgLTEzOTgwLDcgKzEzOTgwLDcgQEAgdmFsaWRhdGVG b3JlaWduS2V5Q29uc3RyYWludChjaGFyICpjb25uYW1lLAogCSAqLwogCXNuYXBzaG90ID0gUmVn aXN0ZXJTbmFwc2hvdChHZXRMYXRlc3RTbmFwc2hvdCgpKTsKIAlzbG90ID0gdGFibGVfc2xvdF9j cmVhdGUocmVsLCBOVUxMKTsKLQlzY2FuID0gdGFibGVfYmVnaW5zY2FuKHJlbCwgc25hcHNob3Qs IDAsIE5VTEwpOworCXNjYW4gPSB0YWJsZV9iZWdpbnNjYW4ocmVsLCBzbmFwc2hvdCwgMCwgTlVM TCwgMCk7CiAKIAlwZXJUdXBDeHQgPSBBbGxvY1NldENvbnRleHRDcmVhdGUoQ3VycmVudE1lbW9y eUNvbnRleHQsCiAJCQkJCQkJCQkgICJ2YWxpZGF0ZUZvcmVpZ25LZXlDb25zdHJhaW50IiwKQEAg LTIyODgxLDcgKzIyODgxLDcgQEAgTWVyZ2VQYXJ0aXRpb25zTW92ZVJvd3MoTGlzdCAqKndxdWV1 ZSwgTGlzdCAqbWVyZ2luZ1BhcnRpdGlvbnMsIFJlbGF0aW9uIG5ld1BhcnQKIAogCQkvKiBTY2Fu IHRocm91Z2ggdGhlIHJvd3MuICovCiAJCXNuYXBzaG90ID0gUmVnaXN0ZXJTbmFwc2hvdChHZXRM YXRlc3RTbmFwc2hvdCgpKTsKLQkJc2NhbiA9IHRhYmxlX2JlZ2luc2NhbihtZXJnaW5nUGFydGl0 aW9uLCBzbmFwc2hvdCwgMCwgTlVMTCk7CisJCXNjYW4gPSB0YWJsZV9iZWdpbnNjYW4obWVyZ2lu Z1BhcnRpdGlvbiwgc25hcHNob3QsIDAsIE5VTEwsIDApOwogCiAJCS8qCiAJCSAqIFN3aXRjaCB0 byBwZXItdHVwbGUgbWVtb3J5IGNvbnRleHQgYW5kIHJlc2V0IGl0IGZvciBlYWNoIHR1cGxlCkBA IC0yMzM0NSw3ICsyMzM0NSw3IEBAIFNwbGl0UGFydGl0aW9uTW92ZVJvd3MoTGlzdCAqKndxdWV1 ZSwgUmVsYXRpb24gcmVsLCBSZWxhdGlvbiBzcGxpdFJlbCwKIAogCS8qIFNjYW4gdGhyb3VnaCB0 aGUgcm93cy4gKi8KIAlzbmFwc2hvdCA9IFJlZ2lzdGVyU25hcHNob3QoR2V0TGF0ZXN0U25hcHNo b3QoKSk7Ci0Jc2NhbiA9IHRhYmxlX2JlZ2luc2NhbihzcGxpdFJlbCwgc25hcHNob3QsIDAsIE5V TEwpOworCXNjYW4gPSB0YWJsZV9iZWdpbnNjYW4oc3BsaXRSZWwsIHNuYXBzaG90LCAwLCBOVUxM LCAwKTsKIAogCS8qCiAJICogU3dpdGNoIHRvIHBlci10dXBsZSBtZW1vcnkgY29udGV4dCBhbmQg cmVzZXQgaXQgZm9yIGVhY2ggdHVwbGUKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2NvbW1hbmRz L3R5cGVjbWRzLmMgYi9zcmMvYmFja2VuZC9jb21tYW5kcy90eXBlY21kcy5jCmluZGV4IDNkYWI2 YmI1YTc5Li41MzE2Y2VhN2NlYyAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdHlw ZWNtZHMuYworKysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy90eXBlY21kcy5jCkBAIC0zMTg1LDcg KzMxODUsNyBAQCB2YWxpZGF0ZURvbWFpbk5vdE51bGxDb25zdHJhaW50KE9pZCBkb21haW5vaWQp CiAKIAkJLyogU2NhbiBhbGwgdHVwbGVzIGluIHRoaXMgcmVsYXRpb24gKi8KIAkJc25hcHNob3Qg PSBSZWdpc3RlclNuYXBzaG90KEdldExhdGVzdFNuYXBzaG90KCkpOwotCQlzY2FuID0gdGFibGVf YmVnaW5zY2FuKHRlc3RyZWwsIHNuYXBzaG90LCAwLCBOVUxMKTsKKwkJc2NhbiA9IHRhYmxlX2Jl Z2luc2Nhbih0ZXN0cmVsLCBzbmFwc2hvdCwgMCwgTlVMTCwgMCk7CiAJCXNsb3QgPSB0YWJsZV9z bG90X2NyZWF0ZSh0ZXN0cmVsLCBOVUxMKTsKIAkJd2hpbGUgKHRhYmxlX3NjYW5fZ2V0bmV4dHNs b3Qoc2NhbiwgRm9yd2FyZFNjYW5EaXJlY3Rpb24sIHNsb3QpKQogCQl7CkBAIC0zMjY2LDcgKzMy NjYsNyBAQCB2YWxpZGF0ZURvbWFpbkNoZWNrQ29uc3RyYWludChPaWQgZG9tYWlub2lkLCBjb25z dCBjaGFyICpjY2JpbiwgTE9DS01PREUgbG9ja21vZAogCiAJCS8qIFNjYW4gYWxsIHR1cGxlcyBp biB0aGlzIHJlbGF0aW9uICovCiAJCXNuYXBzaG90ID0gUmVnaXN0ZXJTbmFwc2hvdChHZXRMYXRl c3RTbmFwc2hvdCgpKTsKLQkJc2NhbiA9IHRhYmxlX2JlZ2luc2Nhbih0ZXN0cmVsLCBzbmFwc2hv dCwgMCwgTlVMTCk7CisJCXNjYW4gPSB0YWJsZV9iZWdpbnNjYW4odGVzdHJlbCwgc25hcHNob3Qs IDAsIE5VTEwsIDApOwogCQlzbG90ID0gdGFibGVfc2xvdF9jcmVhdGUodGVzdHJlbCwgTlVMTCk7 CiAJCXdoaWxlICh0YWJsZV9zY2FuX2dldG5leHRzbG90KHNjYW4sIEZvcndhcmRTY2FuRGlyZWN0 aW9uLCBzbG90KSkKIAkJewpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY0lu ZGV4aW5nLmMgYi9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjSW5kZXhpbmcuYwppbmRleCA5ZDA3 MWU0OTVjNi4uYzQ2YmVlZGViNzEgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4 ZWNJbmRleGluZy5jCisrKyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNJbmRleGluZy5jCkBA IC04MTUsNyArODE1LDggQEAgY2hlY2tfZXhjbHVzaW9uX29yX3VuaXF1ZV9jb25zdHJhaW50KFJl bGF0aW9uIGhlYXAsIFJlbGF0aW9uIGluZGV4LAogcmV0cnk6CiAJY29uZmxpY3QgPSBmYWxzZTsK IAlmb3VuZF9zZWxmID0gZmFsc2U7Ci0JaW5kZXhfc2NhbiA9IGluZGV4X2JlZ2luc2NhbihoZWFw LCBpbmRleCwgJkRpcnR5U25hcHNob3QsIE5VTEwsIGluZG5rZXlhdHRzLCAwKTsKKwlpbmRleF9z Y2FuID0gaW5kZXhfYmVnaW5zY2FuKGhlYXAsIGluZGV4LCAwLAkvKiBmbGFncyAqLworCQkJCQkJ CQkgJkRpcnR5U25hcHNob3QsIE5VTEwsIGluZG5rZXlhdHRzLCAwKTsKIAlpbmRleF9yZXNjYW4o aW5kZXhfc2Nhbiwgc2NhbmtleXMsIGluZG5rZXlhdHRzLCBOVUxMLCAwKTsKIAogCXdoaWxlIChp bmRleF9nZXRuZXh0X3Nsb3QoaW5kZXhfc2NhbiwgRm9yd2FyZFNjYW5EaXJlY3Rpb24sIGV4aXN0 aW5nX3Nsb3QpKQpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvZXhlY3V0b3IvZXhlY1JlcGxpY2F0 aW9uLmMgYi9zcmMvYmFja2VuZC9leGVjdXRvci9leGVjUmVwbGljYXRpb24uYwppbmRleCAyNDk3 ZWU3ZWRjNS4uMjM1MDk3NzE1NTcgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4 ZWNSZXBsaWNhdGlvbi5jCisrKyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL2V4ZWNSZXBsaWNhdGlv bi5jCkBAIC0yMDUsNyArMjA1LDkgQEAgUmVsYXRpb25GaW5kUmVwbFR1cGxlQnlJbmRleChSZWxh dGlvbiByZWwsIE9pZCBpZHhvaWQsCiAJc2tleV9hdHRvZmYgPSBidWlsZF9yZXBsaW5kZXhfc2Nh bl9rZXkoc2tleSwgcmVsLCBpZHhyZWwsIHNlYXJjaHNsb3QpOwogCiAJLyogU3RhcnQgYW4gaW5k ZXggc2Nhbi4gKi8KLQlzY2FuID0gaW5kZXhfYmVnaW5zY2FuKHJlbCwgaWR4cmVsLCAmc25hcCwg TlVMTCwgc2tleV9hdHRvZmYsIDApOworCXNjYW4gPSBpbmRleF9iZWdpbnNjYW4ocmVsLCBpZHhy ZWwsCisJCQkJCQkgICAwLAkvKiBmbGFncyAqLworCQkJCQkJICAgJnNuYXAsIE5VTEwsIHNrZXlf YXR0b2ZmLCAwKTsKIAogcmV0cnk6CiAJZm91bmQgPSBmYWxzZTsKQEAgLTM4Myw3ICszODUsNyBA QCBSZWxhdGlvbkZpbmRSZXBsVHVwbGVTZXEoUmVsYXRpb24gcmVsLCBMb2NrVHVwbGVNb2RlIGxv Y2ttb2RlLAogCiAJLyogU3RhcnQgYSBoZWFwIHNjYW4uICovCiAJSW5pdERpcnR5U25hcHNob3Qo c25hcCk7Ci0Jc2NhbiA9IHRhYmxlX2JlZ2luc2NhbihyZWwsICZzbmFwLCAwLCBOVUxMKTsKKwlz Y2FuID0gdGFibGVfYmVnaW5zY2FuKHJlbCwgJnNuYXAsIDAsIE5VTEwsIDApOwogCXNjYW5zbG90 ID0gdGFibGVfc2xvdF9jcmVhdGUocmVsLCBOVUxMKTsKIAogcmV0cnk6CkBAIC02MDIsNyArNjA0 LDcgQEAgUmVsYXRpb25GaW5kRGVsZXRlZFR1cGxlSW5mb1NlcShSZWxhdGlvbiByZWwsIFR1cGxl VGFibGVTbG90ICpzZWFyY2hzbG90LAogCSAqIG5vdCB5ZXQgY29tbWl0dGVkIG9yIHRob3NlIGp1 c3QgY29tbWl0dGVkIHByaW9yIHRvIHRoZSBzY2FuIGFyZQogCSAqIGV4Y2x1ZGVkIGluIHVwZGF0 ZV9tb3N0X3JlY2VudF9kZWxldGlvbl9pbmZvKCkuCiAJICovCi0Jc2NhbiA9IHRhYmxlX2JlZ2lu c2NhbihyZWwsIFNuYXBzaG90QW55LCAwLCBOVUxMKTsKKwlzY2FuID0gdGFibGVfYmVnaW5zY2Fu KHJlbCwgU25hcHNob3RBbnksIDAsIE5VTEwsIDApOwogCXNjYW5zbG90ID0gdGFibGVfc2xvdF9j cmVhdGUocmVsLCBOVUxMKTsKIAogCXRhYmxlX3Jlc2NhbihzY2FuLCBOVUxMKTsKQEAgLTY2Niw3 ICs2NjgsOSBAQCBSZWxhdGlvbkZpbmREZWxldGVkVHVwbGVJbmZvQnlJbmRleChSZWxhdGlvbiBy ZWwsIE9pZCBpZHhvaWQsCiAJICogbm90IHlldCBjb21taXR0ZWQgb3IgdGhvc2UganVzdCBjb21t aXR0ZWQgcHJpb3IgdG8gdGhlIHNjYW4gYXJlCiAJICogZXhjbHVkZWQgaW4gdXBkYXRlX21vc3Rf cmVjZW50X2RlbGV0aW9uX2luZm8oKS4KIAkgKi8KLQlzY2FuID0gaW5kZXhfYmVnaW5zY2FuKHJl bCwgaWR4cmVsLCBTbmFwc2hvdEFueSwgTlVMTCwgc2tleV9hdHRvZmYsIDApOworCXNjYW4gPSBp bmRleF9iZWdpbnNjYW4ocmVsLCBpZHhyZWwsCisJCQkJCQkgICAwLAkvKiBmbGFncyAqLworCQkJ CQkJICAgU25hcHNob3RBbnksIE5VTEwsIHNrZXlfYXR0b2ZmLCAwKTsKIAogCWluZGV4X3Jlc2Nh bihzY2FuLCBza2V5LCBza2V5X2F0dG9mZiwgTlVMTCwgMCk7CiAKZGlmZiAtLWdpdCBhL3NyYy9i YWNrZW5kL2V4ZWN1dG9yL25vZGVCaXRtYXBIZWFwc2Nhbi5jIGIvc3JjL2JhY2tlbmQvZXhlY3V0 b3Ivbm9kZUJpdG1hcEhlYXBzY2FuLmMKaW5kZXggN2NmOGQyM2M3NDIuLjMyNGUyYmVkMjJjIDEw MDY0NAotLS0gYS9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlQml0bWFwSGVhcHNjYW4uYworKysg Yi9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlQml0bWFwSGVhcHNjYW4uYwpAQCAtMTQ4LDcgKzE0 OCw3IEBAIEJpdG1hcFRhYmxlU2NhblNldHVwKEJpdG1hcEhlYXBTY2FuU3RhdGUgKm5vZGUpCiAJ CQl0YWJsZV9iZWdpbnNjYW5fYm0obm9kZS0+c3Muc3NfY3VycmVudFJlbGF0aW9uLAogCQkJCQkJ CSAgIG5vZGUtPnNzLnBzLnN0YXRlLT5lc19zbmFwc2hvdCwKIAkJCQkJCQkgICAwLAotCQkJCQkJ CSAgIE5VTEwpOworCQkJCQkJCSAgIE5VTEwsIDApOwogCX0KIAogCW5vZGUtPnNzLnNzX2N1cnJl bnRTY2FuRGVzYy0+c3QucnNfdGJtaXRlcmF0b3IgPSB0Ym1pdGVyYXRvcjsKZGlmZiAtLWdpdCBh L3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVJbmRleG9ubHlzY2FuLmMgYi9zcmMvYmFja2VuZC9l eGVjdXRvci9ub2RlSW5kZXhvbmx5c2Nhbi5jCmluZGV4IGM4ZGIzNTdlNjlmLi5kZWNmZDc5Mjgw OSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZUluZGV4b25seXNjYW4uYwor KysgYi9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlSW5kZXhvbmx5c2Nhbi5jCkBAIC05Miw2ICs5 Miw3IEBAIEluZGV4T25seU5leHQoSW5kZXhPbmx5U2NhblN0YXRlICpub2RlKQogCQkgKi8KIAkJ c2NhbmRlc2MgPSBpbmRleF9iZWdpbnNjYW4obm9kZS0+c3Muc3NfY3VycmVudFJlbGF0aW9uLAog CQkJCQkJCQkgICBub2RlLT5pb3NzX1JlbGF0aW9uRGVzYywKKwkJCQkJCQkJICAgMCwJLyogZmxh Z3MgKi8KIAkJCQkJCQkJICAgZXN0YXRlLT5lc19zbmFwc2hvdCwKIAkJCQkJCQkJICAgJm5vZGUt Pmlvc3NfSW5zdHJ1bWVudCwKIAkJCQkJCQkJICAgbm9kZS0+aW9zc19OdW1TY2FuS2V5cywKQEAg LTc5MCw3ICs3OTEsNyBAQCBFeGVjSW5kZXhPbmx5U2NhbkluaXRpYWxpemVEU00oSW5kZXhPbmx5 U2NhblN0YXRlICpub2RlLAogCQkJCQkJCQkgJm5vZGUtPmlvc3NfSW5zdHJ1bWVudCwKIAkJCQkJ CQkJIG5vZGUtPmlvc3NfTnVtU2NhbktleXMsCiAJCQkJCQkJCSBub2RlLT5pb3NzX051bU9yZGVy QnlLZXlzLAotCQkJCQkJCQkgcGlzY2FuKTsKKwkJCQkJCQkJIHBpc2NhbiwgMCk7CiAJbm9kZS0+ aW9zc19TY2FuRGVzYy0+eHNfd2FudF9pdHVwID0gdHJ1ZTsKIAlub2RlLT5pb3NzX1ZNQnVmZmVy ID0gSW52YWxpZEJ1ZmZlcjsKIApAQCAtODU2LDcgKzg1Nyw3IEBAIEV4ZWNJbmRleE9ubHlTY2Fu SW5pdGlhbGl6ZVdvcmtlcihJbmRleE9ubHlTY2FuU3RhdGUgKm5vZGUsCiAJCQkJCQkJCSAmbm9k ZS0+aW9zc19JbnN0cnVtZW50LAogCQkJCQkJCQkgbm9kZS0+aW9zc19OdW1TY2FuS2V5cywKIAkJ CQkJCQkJIG5vZGUtPmlvc3NfTnVtT3JkZXJCeUtleXMsCi0JCQkJCQkJCSBwaXNjYW4pOworCQkJ CQkJCQkgcGlzY2FuLCAwKTsKIAlub2RlLT5pb3NzX1NjYW5EZXNjLT54c193YW50X2l0dXAgPSB0 cnVlOwogCiAJLyoKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVJbmRleHNj YW4uYyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVJbmRleHNjYW4uYwppbmRleCBiZDgzZTQ3 MTJiMy4uYTM3ZmE5YWJlY2UgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVJ bmRleHNjYW4uYworKysgYi9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlSW5kZXhzY2FuLmMKQEAg LTExMCw2ICsxMTAsNyBAQCBJbmRleE5leHQoSW5kZXhTY2FuU3RhdGUgKm5vZGUpCiAJCSAqLwog CQlzY2FuZGVzYyA9IGluZGV4X2JlZ2luc2Nhbihub2RlLT5zcy5zc19jdXJyZW50UmVsYXRpb24s CiAJCQkJCQkJCSAgIG5vZGUtPmlzc19SZWxhdGlvbkRlc2MsCisJCQkJCQkJCSAgIDAsCS8qIGZs YWdzICovCiAJCQkJCQkJCSAgIGVzdGF0ZS0+ZXNfc25hcHNob3QsCiAJCQkJCQkJCSAgICZub2Rl LT5pc3NfSW5zdHJ1bWVudCwKIAkJCQkJCQkJICAgbm9kZS0+aXNzX051bVNjYW5LZXlzLApAQCAt MjA2LDYgKzIwNyw3IEBAIEluZGV4TmV4dFdpdGhSZW9yZGVyKEluZGV4U2NhblN0YXRlICpub2Rl KQogCQkgKi8KIAkJc2NhbmRlc2MgPSBpbmRleF9iZWdpbnNjYW4obm9kZS0+c3Muc3NfY3VycmVu dFJlbGF0aW9uLAogCQkJCQkJCQkgICBub2RlLT5pc3NfUmVsYXRpb25EZXNjLAorCQkJCQkJCQkg ICAwLAkvKiBmbGFncyAqLwogCQkJCQkJCQkgICBlc3RhdGUtPmVzX3NuYXBzaG90LAogCQkJCQkJ CQkgICAmbm9kZS0+aXNzX0luc3RydW1lbnQsCiAJCQkJCQkJCSAgIG5vZGUtPmlzc19OdW1TY2Fu S2V5cywKQEAgLTE3MjYsNyArMTcyOCw3IEBAIEV4ZWNJbmRleFNjYW5Jbml0aWFsaXplRFNNKElu ZGV4U2NhblN0YXRlICpub2RlLAogCQkJCQkJCQkgJm5vZGUtPmlzc19JbnN0cnVtZW50LAogCQkJ CQkJCQkgbm9kZS0+aXNzX051bVNjYW5LZXlzLAogCQkJCQkJCQkgbm9kZS0+aXNzX051bU9yZGVy QnlLZXlzLAotCQkJCQkJCQkgcGlzY2FuKTsKKwkJCQkJCQkJIHBpc2NhbiwgMCk7CiAKIAkvKgog CSAqIElmIG5vIHJ1bi10aW1lIGtleXMgdG8gY2FsY3VsYXRlIG9yIHRoZXkgYXJlIHJlYWR5LCBn byBhaGVhZCBhbmQgcGFzcwpAQCAtMTc5MCw3ICsxNzkyLDcgQEAgRXhlY0luZGV4U2NhbkluaXRp YWxpemVXb3JrZXIoSW5kZXhTY2FuU3RhdGUgKm5vZGUsCiAJCQkJCQkJCSAmbm9kZS0+aXNzX0lu c3RydW1lbnQsCiAJCQkJCQkJCSBub2RlLT5pc3NfTnVtU2NhbktleXMsCiAJCQkJCQkJCSBub2Rl LT5pc3NfTnVtT3JkZXJCeUtleXMsCi0JCQkJCQkJCSBwaXNjYW4pOworCQkJCQkJCQkgcGlzY2Fu LCAwKTsKIAogCS8qCiAJICogSWYgbm8gcnVuLXRpbWUga2V5cyB0byBjYWxjdWxhdGUgb3IgdGhl eSBhcmUgcmVhZHksIGdvIGFoZWFkIGFuZCBwYXNzCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9l eGVjdXRvci9ub2RlU2FtcGxlc2Nhbi5jIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZVNhbXBs ZXNjYW4uYwppbmRleCA2YjBkNjVmNzUyZi4uY2M2YjIzYWJlZTAgMTAwNjQ0Ci0tLSBhL3NyYy9i YWNrZW5kL2V4ZWN1dG9yL25vZGVTYW1wbGVzY2FuLmMKKysrIGIvc3JjL2JhY2tlbmQvZXhlY3V0 b3Ivbm9kZVNhbXBsZXNjYW4uYwpAQCAtMjk4LDcgKzI5OCw3IEBAIHRhYmxlc2FtcGxlX2luaXQo U2FtcGxlU2NhblN0YXRlICpzY2Fuc3RhdGUpCiAJCQkJCQkJCQkgMCwgTlVMTCwKIAkJCQkJCQkJ CSBzY2Fuc3RhdGUtPnVzZV9idWxrcmVhZCwKIAkJCQkJCQkJCSBhbGxvd19zeW5jLAotCQkJCQkJ CQkJIHNjYW5zdGF0ZS0+dXNlX3BhZ2Vtb2RlKTsKKwkJCQkJCQkJCSBzY2Fuc3RhdGUtPnVzZV9w YWdlbW9kZSwgMCk7CiAJfQogCWVsc2UKIAl7CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9leGVj dXRvci9ub2RlU2Vxc2Nhbi5jIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZVNlcXNjYW4uYwpp bmRleCA4ZjIxOWY2MGE5My4uYzJkOWI3MjkzZGUgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4 ZWN1dG9yL25vZGVTZXFzY2FuLmMKKysrIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZVNlcXNj YW4uYwpAQCAtNzEsNyArNzEsNyBAQCBTZXFOZXh0KFNlcVNjYW5TdGF0ZSAqbm9kZSkKIAkJICov CiAJCXNjYW5kZXNjID0gdGFibGVfYmVnaW5zY2FuKG5vZGUtPnNzLnNzX2N1cnJlbnRSZWxhdGlv biwKIAkJCQkJCQkJICAgZXN0YXRlLT5lc19zbmFwc2hvdCwKLQkJCQkJCQkJICAgMCwgTlVMTCk7 CisJCQkJCQkJCSAgIDAsIE5VTEwsIDApOwogCQlub2RlLT5zcy5zc19jdXJyZW50U2NhbkRlc2Mg PSBzY2FuZGVzYzsKIAl9CiAKQEAgLTM3NSw3ICszNzUsNyBAQCBFeGVjU2VxU2NhbkluaXRpYWxp emVEU00oU2VxU2NhblN0YXRlICpub2RlLAogCQkJCQkJCQkgIGVzdGF0ZS0+ZXNfc25hcHNob3Qp OwogCXNobV90b2NfaW5zZXJ0KHBjeHQtPnRvYywgbm9kZS0+c3MucHMucGxhbi0+cGxhbl9ub2Rl X2lkLCBwc2Nhbik7CiAJbm9kZS0+c3Muc3NfY3VycmVudFNjYW5EZXNjID0KLQkJdGFibGVfYmVn aW5zY2FuX3BhcmFsbGVsKG5vZGUtPnNzLnNzX2N1cnJlbnRSZWxhdGlvbiwgcHNjYW4pOworCQl0 YWJsZV9iZWdpbnNjYW5fcGFyYWxsZWwobm9kZS0+c3Muc3NfY3VycmVudFJlbGF0aW9uLCBwc2Nh biwgMCk7CiB9CiAKIC8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KQEAgLTQwOCw1ICs0MDgsNSBAQCBFeGVjU2VxU2Nhbklu aXRpYWxpemVXb3JrZXIoU2VxU2NhblN0YXRlICpub2RlLAogCiAJcHNjYW4gPSBzaG1fdG9jX2xv b2t1cChwd2N4dC0+dG9jLCBub2RlLT5zcy5wcy5wbGFuLT5wbGFuX25vZGVfaWQsIGZhbHNlKTsK IAlub2RlLT5zcy5zc19jdXJyZW50U2NhbkRlc2MgPQotCQl0YWJsZV9iZWdpbnNjYW5fcGFyYWxs ZWwobm9kZS0+c3Muc3NfY3VycmVudFJlbGF0aW9uLCBwc2Nhbik7CisJCXRhYmxlX2JlZ2luc2Nh bl9wYXJhbGxlbChub2RlLT5zcy5zc19jdXJyZW50UmVsYXRpb24sIHBzY2FuLCAwKTsKIH0KZGlm ZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVUaWRyYW5nZXNjYW4uYyBiL3NyYy9i YWNrZW5kL2V4ZWN1dG9yL25vZGVUaWRyYW5nZXNjYW4uYwppbmRleCA2MTc3MTNiZGUwNC4uOTk0 ZjcwOTg5YmMgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVUaWRyYW5nZXNj YW4uYworKysgYi9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlVGlkcmFuZ2VzY2FuLmMKQEAgLTI0 NSw3ICsyNDUsNyBAQCBUaWRSYW5nZU5leHQoVGlkUmFuZ2VTY2FuU3RhdGUgKm5vZGUpCiAJCQlz Y2FuZGVzYyA9IHRhYmxlX2JlZ2luc2Nhbl90aWRyYW5nZShub2RlLT5zcy5zc19jdXJyZW50UmVs YXRpb24sCiAJCQkJCQkJCQkJCQllc3RhdGUtPmVzX3NuYXBzaG90LAogCQkJCQkJCQkJCQkJJm5v ZGUtPnRyc3NfbWludGlkLAotCQkJCQkJCQkJCQkJJm5vZGUtPnRyc3NfbWF4dGlkKTsKKwkJCQkJ CQkJCQkJCSZub2RlLT50cnNzX21heHRpZCwgMCk7CiAJCQlub2RlLT5zcy5zc19jdXJyZW50U2Nh bkRlc2MgPSBzY2FuZGVzYzsKIAkJfQogCQllbHNlCkBAIC00NjAsNyArNDYwLDcgQEAgRXhlY1Rp ZFJhbmdlU2NhbkluaXRpYWxpemVEU00oVGlkUmFuZ2VTY2FuU3RhdGUgKm5vZGUsIFBhcmFsbGVs Q29udGV4dCAqcGN4dCkKIAlzaG1fdG9jX2luc2VydChwY3h0LT50b2MsIG5vZGUtPnNzLnBzLnBs YW4tPnBsYW5fbm9kZV9pZCwgcHNjYW4pOwogCW5vZGUtPnNzLnNzX2N1cnJlbnRTY2FuRGVzYyA9 CiAJCXRhYmxlX2JlZ2luc2Nhbl9wYXJhbGxlbF90aWRyYW5nZShub2RlLT5zcy5zc19jdXJyZW50 UmVsYXRpb24sCi0JCQkJCQkJCQkJICBwc2Nhbik7CisJCQkJCQkJCQkJICBwc2NhbiwgMCk7CiB9 CiAKIC8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0KQEAgLTQ5NCw1ICs0OTQsNSBAQCBFeGVjVGlkUmFuZ2VTY2FuSW5pdGlh bGl6ZVdvcmtlcihUaWRSYW5nZVNjYW5TdGF0ZSAqbm9kZSwKIAlwc2NhbiA9IHNobV90b2NfbG9v a3VwKHB3Y3h0LT50b2MsIG5vZGUtPnNzLnBzLnBsYW4tPnBsYW5fbm9kZV9pZCwgZmFsc2UpOwog CW5vZGUtPnNzLnNzX2N1cnJlbnRTY2FuRGVzYyA9CiAJCXRhYmxlX2JlZ2luc2Nhbl9wYXJhbGxl bF90aWRyYW5nZShub2RlLT5zcy5zc19jdXJyZW50UmVsYXRpb24sCi0JCQkJCQkJCQkJICBwc2Nh bik7CisJCQkJCQkJCQkJICBwc2NhbiwgMCk7CiB9CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9w YXJ0aXRpb25pbmcvcGFydGJvdW5kcy5jIGIvc3JjL2JhY2tlbmQvcGFydGl0aW9uaW5nL3BhcnRi b3VuZHMuYwppbmRleCAwY2EzMTJhYzI3ZC4uYjdjNGU2ZDEwNzEgMTAwNjQ0Ci0tLSBhL3NyYy9i YWNrZW5kL3BhcnRpdGlvbmluZy9wYXJ0Ym91bmRzLmMKKysrIGIvc3JjL2JhY2tlbmQvcGFydGl0 aW9uaW5nL3BhcnRib3VuZHMuYwpAQCAtMzM2Miw3ICszMzYyLDcgQEAgY2hlY2tfZGVmYXVsdF9w YXJ0aXRpb25fY29udGVudHMoUmVsYXRpb24gcGFyZW50LCBSZWxhdGlvbiBkZWZhdWx0X3JlbCwK IAkJZWNvbnRleHQgPSBHZXRQZXJUdXBsZUV4cHJDb250ZXh0KGVzdGF0ZSk7CiAJCXNuYXBzaG90 ID0gUmVnaXN0ZXJTbmFwc2hvdChHZXRMYXRlc3RTbmFwc2hvdCgpKTsKIAkJdHVwc2xvdCA9IHRh YmxlX3Nsb3RfY3JlYXRlKHBhcnRfcmVsLCAmZXN0YXRlLT5lc190dXBsZVRhYmxlKTsKLQkJc2Nh biA9IHRhYmxlX2JlZ2luc2NhbihwYXJ0X3JlbCwgc25hcHNob3QsIDAsIE5VTEwpOworCQlzY2Fu ID0gdGFibGVfYmVnaW5zY2FuKHBhcnRfcmVsLCBzbmFwc2hvdCwgMCwgTlVMTCwgMCk7CiAKIAkJ LyoKIAkJICogU3dpdGNoIHRvIHBlci10dXBsZSBtZW1vcnkgY29udGV4dCBhbmQgcmVzZXQgaXQg Zm9yIGVhY2ggdHVwbGUKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3V0aWxzL2FkdC9zZWxmdW5j cy5jIGIvc3JjL2JhY2tlbmQvdXRpbHMvYWR0L3NlbGZ1bmNzLmMKaW5kZXggODZiNTVjOWJiOGIu LjFkNjRkMjg2ODgxIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC91dGlscy9hZHQvc2VsZnVuY3Mu YworKysgYi9zcmMvYmFja2VuZC91dGlscy9hZHQvc2VsZnVuY3MuYwpAQCAtNzE3Nyw2ICs3MTc3 LDcgQEAgZ2V0X2FjdHVhbF92YXJpYWJsZV9lbmRwb2ludChSZWxhdGlvbiBoZWFwUmVsLAogCQkJ CQkJCSAgR2xvYmFsVmlzVGVzdEZvcihoZWFwUmVsKSk7CiAKIAlpbmRleF9zY2FuID0gaW5kZXhf YmVnaW5zY2FuKGhlYXBSZWwsIGluZGV4UmVsLAorCQkJCQkJCQkgMCwgLyogZmxhZ3MgKi8KIAkJ CQkJCQkJICZTbmFwc2hvdE5vblZhY3V1bWFibGUsIE5VTEwsCiAJCQkJCQkJCSAxLCAwKTsKIAkv KiBTZXQgaXQgdXAgZm9yIGluZGV4LW9ubHkgc2NhbiAqLwpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1 ZGUvYWNjZXNzL2dlbmFtLmggYi9zcmMvaW5jbHVkZS9hY2Nlc3MvZ2VuYW0uaAppbmRleCAxYTI3 YmYwNjBiMy4uYjk4YzIwYTBlZGMgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL2FjY2Vzcy9nZW5h bS5oCisrKyBiL3NyYy9pbmNsdWRlL2FjY2Vzcy9nZW5hbS5oCkBAIC0xNTYsNiArMTU2LDcgQEAg ZXh0ZXJuIHZvaWQgaW5kZXhfaW5zZXJ0X2NsZWFudXAoUmVsYXRpb24gaW5kZXhSZWxhdGlvbiwK IAogZXh0ZXJuIEluZGV4U2NhbkRlc2MgaW5kZXhfYmVnaW5zY2FuKFJlbGF0aW9uIGhlYXBSZWxh dGlvbiwKIAkJCQkJCQkJCSBSZWxhdGlvbiBpbmRleFJlbGF0aW9uLAorCQkJCQkJCQkJIHVpbnQz MiBmbGFncywKIAkJCQkJCQkJCSBTbmFwc2hvdCBzbmFwc2hvdCwKIAkJCQkJCQkJCSBJbmRleFNj YW5JbnN0cnVtZW50YXRpb24gKmluc3RydW1lbnQsCiAJCQkJCQkJCQkgaW50IG5rZXlzLCBpbnQg bm9yZGVyYnlzKTsKQEAgLTE4NCw3ICsxODUsOCBAQCBleHRlcm4gSW5kZXhTY2FuRGVzYyBpbmRl eF9iZWdpbnNjYW5fcGFyYWxsZWwoUmVsYXRpb24gaGVhcHJlbCwKIAkJCQkJCQkJCQkJICBSZWxh dGlvbiBpbmRleHJlbCwKIAkJCQkJCQkJCQkJICBJbmRleFNjYW5JbnN0cnVtZW50YXRpb24gKmlu c3RydW1lbnQsCiAJCQkJCQkJCQkJCSAgaW50IG5rZXlzLCBpbnQgbm9yZGVyYnlzLAotCQkJCQkJ CQkJCQkgIFBhcmFsbGVsSW5kZXhTY2FuRGVzYyBwc2Nhbik7CisJCQkJCQkJCQkJCSAgUGFyYWxs ZWxJbmRleFNjYW5EZXNjIHBzY2FuLAorCQkJCQkJCQkJCQkgIHVpbnQzMiBmbGFncyk7CiBleHRl cm4gSXRlbVBvaW50ZXIgaW5kZXhfZ2V0bmV4dF90aWQoSW5kZXhTY2FuRGVzYyBzY2FuLAogCQkJ CQkJCQkJIFNjYW5EaXJlY3Rpb24gZGlyZWN0aW9uKTsKIGV4dGVybiBib29sIGluZGV4X2ZldGNo X2hlYXAoSW5kZXhTY2FuRGVzYyBzY2FuLCBUdXBsZVRhYmxlU2xvdCAqc2xvdCk7CmRpZmYgLS1n aXQgYS9zcmMvaW5jbHVkZS9hY2Nlc3MvaGVhcGFtLmggYi9zcmMvaW5jbHVkZS9hY2Nlc3MvaGVh cGFtLmgKaW5kZXggYjk1NzdjMjQ4NDQuLmUzMmYyOGQ3YWNiIDEwMDY0NAotLS0gYS9zcmMvaW5j bHVkZS9hY2Nlc3MvaGVhcGFtLmgKKysrIGIvc3JjL2luY2x1ZGUvYWNjZXNzL2hlYXBhbS5oCkBA IC05NSwxMCArOTUsNyBAQCB0eXBlZGVmIHN0cnVjdCBIZWFwU2NhbkRlc2NEYXRhCiAJICovCiAJ UGFyYWxsZWxCbG9ja1RhYmxlU2NhbldvcmtlckRhdGEgKnJzX3BhcmFsbGVsd29ya2VyZGF0YTsK IAotCS8qCi0JICogRm9yIHNlcXVlbnRpYWwgc2NhbnMgYW5kIGJpdG1hcCBoZWFwIHNjYW5zLiBU aGUgY3VycmVudCBoZWFwIGJsb2NrJ3MKLQkgKiBjb3JyZXNwb25kaW5nIHBhZ2UgaW4gdGhlIHZp c2liaWxpdHkgbWFwLgotCSAqLworCS8qIEN1cnJlbnQgaGVhcCBibG9jaydzIGNvcnJlc3BvbmRp bmcgcGFnZSBpbiB0aGUgdmlzaWJpbGl0eSBtYXAgKi8KIAlCdWZmZXIJCXJzX3ZtYnVmZmVyOwog CiAJLyogdGhlc2UgZmllbGRzIG9ubHkgdXNlZCBpbiBwYWdlLWF0LWEtdGltZSBtb2RlIGFuZCBm b3IgYml0bWFwIHNjYW5zICovCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9hY2Nlc3MvcmVsc2Nh bi5oIGIvc3JjL2luY2x1ZGUvYWNjZXNzL3JlbHNjYW4uaAppbmRleCBjZTM0MGMwNzZmOC4uODBl YTBiNDM3ZDEgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL2FjY2Vzcy9yZWxzY2FuLmgKKysrIGIv c3JjL2luY2x1ZGUvYWNjZXNzL3JlbHNjYW4uaApAQCAtMTIyLDYgKzEyMiw3IEBAIHR5cGVkZWYg c3RydWN0IFBhcmFsbGVsQmxvY2tUYWJsZVNjYW5Xb3JrZXJEYXRhICpQYXJhbGxlbEJsb2NrVGFi bGVTY2FuV29ya2VyOwogdHlwZWRlZiBzdHJ1Y3QgSW5kZXhGZXRjaFRhYmxlRGF0YQogewogCVJl bGF0aW9uCXJlbDsKKwl1aW50MzIJCWZsYWdzOwogfSBJbmRleEZldGNoVGFibGVEYXRhOwogCiBz dHJ1Y3QgSW5kZXhTY2FuSW5zdHJ1bWVudGF0aW9uOwpkaWZmIC0tZ2l0IGEvc3JjL2luY2x1ZGUv YWNjZXNzL3RhYmxlYW0uaCBiL3NyYy9pbmNsdWRlL2FjY2Vzcy90YWJsZWFtLmgKaW5kZXggMDYw ODQ3NTIyNDUuLjgzNTdkMDVkODNiIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9hY2Nlc3MvdGFi bGVhbS5oCisrKyBiL3NyYy9pbmNsdWRlL2FjY2Vzcy90YWJsZWFtLmgKQEAgLTY1LDYgKzY1LDE2 IEBAIHR5cGVkZWYgZW51bSBTY2FuT3B0aW9ucwogCVNPX1RFTVBfU05BUFNIT1QgPSAxIDw8IDks CiB9CQkJU2Nhbk9wdGlvbnM7CiAKKy8qCisgKiBNYXNrIG9mIGZsYWdzIHRoYXQgYXJlIHNldCBp bnRlcm5hbGx5IGJ5IHRoZSB0YWJsZV9iZWdpbnNjYW5fKiBmdW5jdGlvbnMKKyAqIGFuZCBtdXN0 IG5vdCBiZSBwYXNzZWQgYnkgY2FsbGVycy4KKyAqLworI2RlZmluZSBTT19JTlRFUk5BTF9GTEFH UyBcCisJKFNPX1RZUEVfU0VRU0NBTiB8IFNPX1RZUEVfQklUTUFQU0NBTiB8IFNPX1RZUEVfU0FN UExFU0NBTiB8IFwKKwkgU09fVFlQRV9USURTQ0FOIHwgU09fVFlQRV9USURSQU5HRVNDQU4gfCBT T19UWVBFX0FOQUxZWkUgfCBcCisJIFNPX0FMTE9XX1NUUkFUIHwgU09fQUxMT1dfU1lOQyB8IFNP X0FMTE9XX1BBR0VNT0RFIHwgXAorCSBTT19URU1QX1NOQVBTSE9UKQorCiAvKgogICogUmVzdWx0 IGNvZGVzIGZvciB0YWJsZV97dXBkYXRlLGRlbGV0ZSxsb2NrX3R1cGxlfSwgYW5kIGZvciB2aXNp YmlsaXR5CiAgKiByb3V0aW5lcyBpbnNpZGUgdGFibGUgQU1zLgpAQCAtNDIwLDcgKzQzMCw3IEBA IHR5cGVkZWYgc3RydWN0IFRhYmxlQW1Sb3V0aW5lCiAJICoKIAkgKiBUdXBsZXMgZm9yIGFuIGlu ZGV4IHNjYW4gY2FuIHRoZW4gYmUgZmV0Y2hlZCB2aWEgaW5kZXhfZmV0Y2hfdHVwbGUuCiAJICov Ci0Jc3RydWN0IEluZGV4RmV0Y2hUYWJsZURhdGEgKigqaW5kZXhfZmV0Y2hfYmVnaW4pIChSZWxh dGlvbiByZWwpOworCXN0cnVjdCBJbmRleEZldGNoVGFibGVEYXRhICooKmluZGV4X2ZldGNoX2Jl Z2luKSAoUmVsYXRpb24gcmVsLCB1aW50MzIgZmxhZ3MpOwogCiAJLyoKIAkgKiBSZXNldCBpbmRl eCBmZXRjaC4gVHlwaWNhbGx5IHRoaXMgd2lsbCByZWxlYXNlIGNyb3NzIGluZGV4IGZldGNoCkBA IC04NzEsMTIgKzg4MSwxOCBAQCBleHRlcm4gVHVwbGVUYWJsZVNsb3QgKnRhYmxlX3Nsb3RfY3Jl YXRlKFJlbGF0aW9uIHJlbGF0aW9uLCBMaXN0ICoqcmVnbGlzdCk7CiAgKiBBIHdyYXBwZXIgYXJv dW5kIHRoZSBUYWJsZSBBY2Nlc3MgTWV0aG9kIHNjYW5fYmVnaW4gY2FsbGJhY2ssIHRvIGNlbnRy YWxpemUKICAqIGVycm9yIGNoZWNraW5nLiBBbGwgY2FsbHMgdG8gLT5zY2FuX2JlZ2luKCkgc2hv dWxkIGdvIHRocm91Z2ggdGhpcwogICogZnVuY3Rpb24uCisgKgorICogVGhlIGNhbGxlci1wcm92 aWRlZCB1c2VyX2ZsYWdzIGFyZSB2YWxpZGF0ZWQgYWdhaW5zdCBTT19JTlRFUk5BTF9GTEFHUyB0 bworICogY2F0Y2ggY2FsbGVycyB0aGF0IGFjY2lkZW50YWxseSBwYXNzIHNjYW4tdHlwZSBvciBv dGhlciBpbnRlcm5hbCBmbGFncy4KICAqLwogc3RhdGljIFRhYmxlU2NhbkRlc2MKIHRhYmxlX2Jl Z2luc2Nhbl9jb21tb24oUmVsYXRpb24gcmVsLCBTbmFwc2hvdCBzbmFwc2hvdCwgaW50IG5rZXlz LAogCQkJCQkgICBTY2FuS2V5RGF0YSAqa2V5LCBQYXJhbGxlbFRhYmxlU2NhbkRlc2MgcHNjYW4s Ci0JCQkJCSAgIHVpbnQzMiBmbGFncykKKwkJCQkJICAgdWludDMyIGZsYWdzLCB1aW50MzIgdXNl cl9mbGFncykKIHsKKwlBc3NlcnQoKHVzZXJfZmxhZ3MgJiBTT19JTlRFUk5BTF9GTEFHUykgPT0g MCk7CisJZmxhZ3MgfD0gdXNlcl9mbGFnczsKKwogCS8qCiAJICogV2UgZG9uJ3QgYWxsb3cgc2Nh bnMgdG8gYmUgc3RhcnRlZCB3aGlsZSBDaGVja1hpZEFsaXZlIGlzIHNldCwgZXhjZXB0CiAJICog dmlhIHN5c3RhYmxlX2JlZ2luc2NhbigpIGV0IGFsLiAgU2VlIGRldGFpbGVkIGNvbW1lbnRzIGlu IHhhY3QuYyB3aGVyZQpAQCAtODk0LDEyICs5MTAsMTMgQEAgdGFibGVfYmVnaW5zY2FuX2NvbW1v bihSZWxhdGlvbiByZWwsIFNuYXBzaG90IHNuYXBzaG90LCBpbnQgbmtleXMsCiAgKi8KIHN0YXRp YyBpbmxpbmUgVGFibGVTY2FuRGVzYwogdGFibGVfYmVnaW5zY2FuKFJlbGF0aW9uIHJlbCwgU25h cHNob3Qgc25hcHNob3QsCi0JCQkJaW50IG5rZXlzLCBTY2FuS2V5RGF0YSAqa2V5KQorCQkJCWlu dCBua2V5cywgU2NhbktleURhdGEgKmtleSwgdWludDMyIGZsYWdzKQogewotCXVpbnQzMgkJZmxh Z3MgPSBTT19UWVBFX1NFUVNDQU4gfAorCXVpbnQzMgkJaW50ZXJuYWxfZmxhZ3MgPSBTT19UWVBF X1NFUVNDQU4gfAogCQlTT19BTExPV19TVFJBVCB8IFNPX0FMTE9XX1NZTkMgfCBTT19BTExPV19Q QUdFTU9ERTsKIAotCXJldHVybiB0YWJsZV9iZWdpbnNjYW5fY29tbW9uKHJlbCwgc25hcHNob3Qs IG5rZXlzLCBrZXksIE5VTEwsIGZsYWdzKTsKKwlyZXR1cm4gdGFibGVfYmVnaW5zY2FuX2NvbW1v bihyZWwsIHNuYXBzaG90LCBua2V5cywga2V5LCBOVUxMLAorCQkJCQkJCQkgIGludGVybmFsX2Zs YWdzLCBmbGFncyk7CiB9CiAKIC8qCkBAIC05MjgsNyArOTQ1LDcgQEAgdGFibGVfYmVnaW5zY2Fu X3N0cmF0KFJlbGF0aW9uIHJlbCwgU25hcHNob3Qgc25hcHNob3QsCiAJaWYgKGFsbG93X3N5bmMp CiAJCWZsYWdzIHw9IFNPX0FMTE9XX1NZTkM7CiAKLQlyZXR1cm4gdGFibGVfYmVnaW5zY2FuX2Nv bW1vbihyZWwsIHNuYXBzaG90LCBua2V5cywga2V5LCBOVUxMLCBmbGFncyk7CisJcmV0dXJuIHRh YmxlX2JlZ2luc2Nhbl9jb21tb24ocmVsLCBzbmFwc2hvdCwgbmtleXMsIGtleSwgTlVMTCwgZmxh Z3MsIDApOwogfQogCiAvKgpAQCAtOTM5LDExICs5NTYsMTIgQEAgdGFibGVfYmVnaW5zY2FuX3N0 cmF0KFJlbGF0aW9uIHJlbCwgU25hcHNob3Qgc25hcHNob3QsCiAgKi8KIHN0YXRpYyBpbmxpbmUg VGFibGVTY2FuRGVzYwogdGFibGVfYmVnaW5zY2FuX2JtKFJlbGF0aW9uIHJlbCwgU25hcHNob3Qg c25hcHNob3QsCi0JCQkJICAgaW50IG5rZXlzLCBTY2FuS2V5RGF0YSAqa2V5KQorCQkJCSAgIGlu dCBua2V5cywgU2NhbktleURhdGEgKmtleSwgdWludDMyIGZsYWdzKQogewotCXVpbnQzMgkJZmxh Z3MgPSBTT19UWVBFX0JJVE1BUFNDQU4gfCBTT19BTExPV19QQUdFTU9ERTsKKwl1aW50MzIJCWlu dGVybmFsX2ZsYWdzID0gU09fVFlQRV9CSVRNQVBTQ0FOIHwgU09fQUxMT1dfUEFHRU1PREU7CiAK LQlyZXR1cm4gdGFibGVfYmVnaW5zY2FuX2NvbW1vbihyZWwsIHNuYXBzaG90LCBua2V5cywga2V5 LCBOVUxMLCBmbGFncyk7CisJcmV0dXJuIHRhYmxlX2JlZ2luc2Nhbl9jb21tb24ocmVsLCBzbmFw c2hvdCwgbmtleXMsIGtleSwgTlVMTCwKKwkJCQkJCQkJICBpbnRlcm5hbF9mbGFncywgZmxhZ3Mp OwogfQogCiAvKgpAQCAtOTU3LDE4ICs5NzUsMTkgQEAgc3RhdGljIGlubGluZSBUYWJsZVNjYW5E ZXNjCiB0YWJsZV9iZWdpbnNjYW5fc2FtcGxpbmcoUmVsYXRpb24gcmVsLCBTbmFwc2hvdCBzbmFw c2hvdCwKIAkJCQkJCSBpbnQgbmtleXMsIFNjYW5LZXlEYXRhICprZXksCiAJCQkJCQkgYm9vbCBh bGxvd19zdHJhdCwgYm9vbCBhbGxvd19zeW5jLAotCQkJCQkJIGJvb2wgYWxsb3dfcGFnZW1vZGUp CisJCQkJCQkgYm9vbCBhbGxvd19wYWdlbW9kZSwgdWludDMyIGZsYWdzKQogewotCXVpbnQzMgkJ ZmxhZ3MgPSBTT19UWVBFX1NBTVBMRVNDQU47CisJdWludDMyCQlpbnRlcm5hbF9mbGFncyA9IFNP X1RZUEVfU0FNUExFU0NBTjsKIAogCWlmIChhbGxvd19zdHJhdCkKLQkJZmxhZ3MgfD0gU09fQUxM T1dfU1RSQVQ7CisJCWludGVybmFsX2ZsYWdzIHw9IFNPX0FMTE9XX1NUUkFUOwogCWlmIChhbGxv d19zeW5jKQotCQlmbGFncyB8PSBTT19BTExPV19TWU5DOworCQlpbnRlcm5hbF9mbGFncyB8PSBT T19BTExPV19TWU5DOwogCWlmIChhbGxvd19wYWdlbW9kZSkKLQkJZmxhZ3MgfD0gU09fQUxMT1df UEFHRU1PREU7CisJCWludGVybmFsX2ZsYWdzIHw9IFNPX0FMTE9XX1BBR0VNT0RFOwogCi0JcmV0 dXJuIHRhYmxlX2JlZ2luc2Nhbl9jb21tb24ocmVsLCBzbmFwc2hvdCwgbmtleXMsIGtleSwgTlVM TCwgZmxhZ3MpOworCXJldHVybiB0YWJsZV9iZWdpbnNjYW5fY29tbW9uKHJlbCwgc25hcHNob3Qs IG5rZXlzLCBrZXksIE5VTEwsCisJCQkJCQkJCSAgaW50ZXJuYWxfZmxhZ3MsIGZsYWdzKTsKIH0K IAogLyoKQEAgLTk4MSw3ICsxMDAwLDcgQEAgdGFibGVfYmVnaW5zY2FuX3RpZChSZWxhdGlvbiBy ZWwsIFNuYXBzaG90IHNuYXBzaG90KQogewogCXVpbnQzMgkJZmxhZ3MgPSBTT19UWVBFX1RJRFND QU47CiAKLQlyZXR1cm4gdGFibGVfYmVnaW5zY2FuX2NvbW1vbihyZWwsIHNuYXBzaG90LCAwLCBO VUxMLCBOVUxMLCBmbGFncyk7CisJcmV0dXJuIHRhYmxlX2JlZ2luc2Nhbl9jb21tb24ocmVsLCBz bmFwc2hvdCwgMCwgTlVMTCwgTlVMTCwgZmxhZ3MsIDApOwogfQogCiAvKgpAQCAtOTk0LDcgKzEw MTMsNyBAQCB0YWJsZV9iZWdpbnNjYW5fYW5hbHl6ZShSZWxhdGlvbiByZWwpCiB7CiAJdWludDMy CQlmbGFncyA9IFNPX1RZUEVfQU5BTFlaRTsKIAotCXJldHVybiB0YWJsZV9iZWdpbnNjYW5fY29t bW9uKHJlbCwgTlVMTCwgMCwgTlVMTCwgTlVMTCwgZmxhZ3MpOworCXJldHVybiB0YWJsZV9iZWdp bnNjYW5fY29tbW9uKHJlbCwgTlVMTCwgMCwgTlVMTCwgTlVMTCwgZmxhZ3MsIDApOwogfQogCiAv KgpAQCAtMTA1OSwxMiArMTA3OCwxMyBAQCB0YWJsZV9zY2FuX2dldG5leHRzbG90KFRhYmxlU2Nh bkRlc2Mgc3NjYW4sIFNjYW5EaXJlY3Rpb24gZGlyZWN0aW9uLCBUdXBsZVRhYmxlUwogc3RhdGlj IGlubGluZSBUYWJsZVNjYW5EZXNjCiB0YWJsZV9iZWdpbnNjYW5fdGlkcmFuZ2UoUmVsYXRpb24g cmVsLCBTbmFwc2hvdCBzbmFwc2hvdCwKIAkJCQkJCSBJdGVtUG9pbnRlciBtaW50aWQsCi0JCQkJ CQkgSXRlbVBvaW50ZXIgbWF4dGlkKQorCQkJCQkJIEl0ZW1Qb2ludGVyIG1heHRpZCwgdWludDMy IGZsYWdzKQogewogCVRhYmxlU2NhbkRlc2Mgc3NjYW47Ci0JdWludDMyCQlmbGFncyA9IFNPX1RZ UEVfVElEUkFOR0VTQ0FOIHwgU09fQUxMT1dfUEFHRU1PREU7CisJdWludDMyCQlpbnRlcm5hbF9m bGFncyA9IFNPX1RZUEVfVElEUkFOR0VTQ0FOIHwgU09fQUxMT1dfUEFHRU1PREU7CiAKLQlzc2Nh biA9IHRhYmxlX2JlZ2luc2Nhbl9jb21tb24ocmVsLCBzbmFwc2hvdCwgMCwgTlVMTCwgTlVMTCwg ZmxhZ3MpOworCXNzY2FuID0gdGFibGVfYmVnaW5zY2FuX2NvbW1vbihyZWwsIHNuYXBzaG90LCAw LCBOVUxMLCBOVUxMLAorCQkJCQkJCQkgICBpbnRlcm5hbF9mbGFncywgZmxhZ3MpOwogCiAJLyog U2V0IHRoZSByYW5nZSBvZiBUSURzIHRvIHNjYW4gKi8KIAlzc2Nhbi0+cnNfcmQtPnJkX3RhYmxl YW0tPnNjYW5fc2V0X3RpZHJhbmdlKHNzY2FuLCBtaW50aWQsIG1heHRpZCk7CkBAIC0xMTM5LDcg KzExNTksOCBAQCBleHRlcm4gdm9pZCB0YWJsZV9wYXJhbGxlbHNjYW5faW5pdGlhbGl6ZShSZWxh dGlvbiByZWwsCiAgKiBDYWxsZXIgbXVzdCBob2xkIGEgc3VpdGFibGUgbG9jayBvbiB0aGUgcmVs YXRpb24uCiAgKi8KIGV4dGVybiBUYWJsZVNjYW5EZXNjIHRhYmxlX2JlZ2luc2Nhbl9wYXJhbGxl bChSZWxhdGlvbiByZWxhdGlvbiwKLQkJCQkJCQkJCQkJICBQYXJhbGxlbFRhYmxlU2NhbkRlc2Mg cHNjYW4pOworCQkJCQkJCQkJCQkgIFBhcmFsbGVsVGFibGVTY2FuRGVzYyBwc2NhbiwKKwkJCQkJ CQkJCQkJICB1aW50MzIgZmxhZ3MpOwogCiAvKgogICogQmVnaW4gYSBwYXJhbGxlbCB0aWQgcmFu Z2Ugc2Nhbi4gYHBzY2FuYCBuZWVkcyB0byBoYXZlIGJlZW4gaW5pdGlhbGl6ZWQKQEAgLTExNDks NyArMTE3MCw4IEBAIGV4dGVybiBUYWJsZVNjYW5EZXNjIHRhYmxlX2JlZ2luc2Nhbl9wYXJhbGxl bChSZWxhdGlvbiByZWxhdGlvbiwKICAqIENhbGxlciBtdXN0IGhvbGQgYSBzdWl0YWJsZSBsb2Nr IG9uIHRoZSByZWxhdGlvbi4KICAqLwogZXh0ZXJuIFRhYmxlU2NhbkRlc2MgdGFibGVfYmVnaW5z Y2FuX3BhcmFsbGVsX3RpZHJhbmdlKFJlbGF0aW9uIHJlbGF0aW9uLAotCQkJCQkJCQkJCQkJCSAg IFBhcmFsbGVsVGFibGVTY2FuRGVzYyBwc2Nhbik7CisJCQkJCQkJCQkJCQkJICAgUGFyYWxsZWxU YWJsZVNjYW5EZXNjIHBzY2FuLAorCQkJCQkJCQkJCQkJCSAgIHVpbnQzMiBmbGFncyk7CiAKIC8q CiAgKiBSZXN0YXJ0IGEgcGFyYWxsZWwgc2Nhbi4gIENhbGwgdGhpcyBpbiB0aGUgbGVhZGVyIHBy b2Nlc3MuICBDYWxsZXIgaXMKQEAgLTExNzUsOCArMTE5NywxMCBAQCB0YWJsZV9wYXJhbGxlbHNj YW5fcmVpbml0aWFsaXplKFJlbGF0aW9uIHJlbCwgUGFyYWxsZWxUYWJsZVNjYW5EZXNjIHBzY2Fu KQogICogVHVwbGVzIGZvciBhbiBpbmRleCBzY2FuIGNhbiB0aGVuIGJlIGZldGNoZWQgdmlhIHRh YmxlX2luZGV4X2ZldGNoX3R1cGxlKCkuCiAgKi8KIHN0YXRpYyBpbmxpbmUgSW5kZXhGZXRjaFRh YmxlRGF0YSAqCi10YWJsZV9pbmRleF9mZXRjaF9iZWdpbihSZWxhdGlvbiByZWwpCit0YWJsZV9p bmRleF9mZXRjaF9iZWdpbihSZWxhdGlvbiByZWwsIHVpbnQzMiBmbGFncykKIHsKKwlBc3NlcnQo KGZsYWdzICYgU09fSU5URVJOQUxfRkxBR1MpID09IDApOworCiAJLyoKIAkgKiBXZSBkb24ndCBh bGxvdyBzY2FucyB0byBiZSBzdGFydGVkIHdoaWxlIENoZWNrWGlkQWxpdmUgaXMgc2V0LCBleGNl cHQKIAkgKiB2aWEgc3lzdGFibGVfYmVnaW5zY2FuKCkgZXQgYWwuICBTZWUgZGV0YWlsZWQgY29t bWVudHMgaW4geGFjdC5jIHdoZXJlCkBAIC0xMTg1LDcgKzEyMDksNyBAQCB0YWJsZV9pbmRleF9m ZXRjaF9iZWdpbihSZWxhdGlvbiByZWwpCiAJaWYgKHVubGlrZWx5KFRyYW5zYWN0aW9uSWRJc1Zh bGlkKENoZWNrWGlkQWxpdmUpICYmICFic3lzc2NhbikpCiAJCWVsb2coRVJST1IsICJzY2FuIHN0 YXJ0ZWQgZHVyaW5nIGxvZ2ljYWwgZGVjb2RpbmciKTsKIAotCXJldHVybiByZWwtPnJkX3RhYmxl YW0tPmluZGV4X2ZldGNoX2JlZ2luKHJlbCk7CisJcmV0dXJuIHJlbC0+cmRfdGFibGVhbS0+aW5k ZXhfZmV0Y2hfYmVnaW4ocmVsLCBmbGFncyk7CiB9CiAKIC8qCi0tIAoyLjQzLjAKCg== --00000000000060fd69064d6b968a Content-Type: text/x-patch; charset="US-ASCII"; name="v41-0010-Pass-down-information-on-table-modification-to-s.patch" Content-Disposition: attachment; filename="v41-0010-Pass-down-information-on-table-modification-to-s.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmyagswl9 RnJvbSA1MTJjMmExOTY1MWFlY2FiM2ExNTcxMjk5MjU4NmRjZTI4OGI4M2ZkIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBNb24sIDIgTWFyIDIwMjYgMTY6MzE6MzMgLTA1MDAKU3ViamVjdDogW1BB VENIIHY0MSAxMC8xMl0gUGFzcyBkb3duIGluZm9ybWF0aW9uIG9uIHRhYmxlIG1vZGlmaWNhdGlv biB0byBzY2FuCiBub2RlCgpQYXNzIGRvd24gaW5mb3JtYXRpb24gdG8gc2VxdWVudGlhbCBzY2Fu LCBpbmRleCBbb25seV0gc2NhbiwgYml0bWFwCnRhYmxlIHNjYW4sIHNhbXBsZSBzY2FuLCBhbmQg VElEIHJhbmdlIHNjYW4gbm9kZXMgb24gd2hldGhlciBvciBub3QgdGhlCnF1ZXJ5IG1vZGlmaWVz IHRoZSByZWxhdGlvbiBiZWluZyBzY2FubmVkLiBBIGxhdGVyIGNvbW1pdCB3aWxsIHVzZSB0aGlz CmluZm9ybWF0aW9uIHRvIHVwZGF0ZSB0aGUgVk0gZHVyaW5nIG9uLWFjY2VzcyBwcnVuaW5nIG9u bHkgaWYgdGhlCnJlbGF0aW9uIGlzIG5vdCBtb2RpZmllZCBieSB0aGUgcXVlcnkuCgpBdXRob3I6 IE1lbGFuaWUgUGxhZ2VtYW4gPG1lbGFuaWVwbGFnZW1hbkBnbWFpbC5jb20+ClJldmlld2VkLWJ5 OiBBbmRyZXMgRnJldW5kIDxhbmRyZXNAYW5hcmF6ZWwuZGU+ClJldmlld2VkLWJ5OiBBbmRyZXkg Qm9yb2RpbiA8eDRtbW1AeWFuZGV4LXRlYW0ucnU+ClJldmlld2VkLWJ5OiBDaGFvIExpIDxsaS5l dmFuLmNoYW9AZ21haWwuY29tPgpEaXNjdXNzaW9uOiBodHRwczovL3Bvc3Rnci5lcy9tLzQzNzlG REEzLTk0NDYtNEUyQy05QzE1LTMyRUZFOEQ0RjMxQiU0MHlhbmRleC10ZWFtLnJ1Ci0tLQogc3Jj L2JhY2tlbmQvZXhlY3V0b3Ivbm9kZUJpdG1hcEhlYXBzY2FuLmMgfCAgNiArKysrKy0KIHNyYy9i YWNrZW5kL2V4ZWN1dG9yL25vZGVJbmRleG9ubHlzY2FuLmMgIHwgMTUgKysrKysrKysrKysrLS0t CiBzcmMvYmFja2VuZC9leGVjdXRvci9ub2RlSW5kZXhzY2FuLmMgICAgICB8IDE4ICsrKysrKysr KysrKysrLS0tLQogc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZVNhbXBsZXNjYW4uYyAgICAgfCAg NSArKysrLQogc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZVNlcXNjYW4uYyAgICAgICAgfCAxOCAr KysrKysrKysrKysrKystLS0KIHNyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVUaWRyYW5nZXNjYW4u YyAgIHwgMTUgKysrKysrKysrKysrLS0tCiBzcmMvaW5jbHVkZS9hY2Nlc3MvdGFibGVhbS5oICAg ICAgICAgICAgICB8ICAzICsrKwogc3JjL2luY2x1ZGUvZXhlY3V0b3IvZXhlY3V0b3IuaCAgICAg ICAgICAgfCAxMCArKysrKysrKysrCiA4IGZpbGVzIGNoYW5nZWQsIDc1IGluc2VydGlvbnMoKyks IDE1IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVC aXRtYXBIZWFwc2Nhbi5jIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9kZUJpdG1hcEhlYXBzY2Fu LmMKaW5kZXggMzI0ZTJiZWQyMmMuLmFlYzkyYzg2OGFjIDEwMDY0NAotLS0gYS9zcmMvYmFja2Vu ZC9leGVjdXRvci9ub2RlQml0bWFwSGVhcHNjYW4uYworKysgYi9zcmMvYmFja2VuZC9leGVjdXRv ci9ub2RlQml0bWFwSGVhcHNjYW4uYwpAQCAtMTQ0LDExICsxNDQsMTUgQEAgQml0bWFwVGFibGVT Y2FuU2V0dXAoQml0bWFwSGVhcFNjYW5TdGF0ZSAqbm9kZSkKIAkgKi8KIAlpZiAoIW5vZGUtPnNz LnNzX2N1cnJlbnRTY2FuRGVzYykKIAl7CisJCXVpbnQzMgkJZmxhZ3MgPSBTY2FuUmVsSXNSZWFk T25seSgmbm9kZS0+c3MpID8KKwkJCVNPX0hJTlRfUkVMX1JFQURfT05MWSA6IDA7CisKIAkJbm9k ZS0+c3Muc3NfY3VycmVudFNjYW5EZXNjID0KIAkJCXRhYmxlX2JlZ2luc2Nhbl9ibShub2RlLT5z cy5zc19jdXJyZW50UmVsYXRpb24sCiAJCQkJCQkJICAgbm9kZS0+c3MucHMuc3RhdGUtPmVzX3Nu YXBzaG90LAogCQkJCQkJCSAgIDAsCi0JCQkJCQkJICAgTlVMTCwgMCk7CisJCQkJCQkJICAgTlVM TCwKKwkJCQkJCQkgICBmbGFncyk7CiAJfQogCiAJbm9kZS0+c3Muc3NfY3VycmVudFNjYW5EZXNj LT5zdC5yc190Ym1pdGVyYXRvciA9IHRibWl0ZXJhdG9yOwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tl bmQvZXhlY3V0b3Ivbm9kZUluZGV4b25seXNjYW4uYyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25v ZGVJbmRleG9ubHlzY2FuLmMKaW5kZXggZGVjZmQ3OTI4MDkuLmI5Nzc3MTljMjk1IDEwMDY0NAot LS0gYS9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlSW5kZXhvbmx5c2Nhbi5jCisrKyBiL3NyYy9i YWNrZW5kL2V4ZWN1dG9yL25vZGVJbmRleG9ubHlzY2FuLmMKQEAgLTg1LDYgKzg1LDkgQEAgSW5k ZXhPbmx5TmV4dChJbmRleE9ubHlTY2FuU3RhdGUgKm5vZGUpCiAKIAlpZiAoc2NhbmRlc2MgPT0g TlVMTCkKIAl7CisJCXVpbnQzMgkJZmxhZ3MgPSBTY2FuUmVsSXNSZWFkT25seSgmbm9kZS0+c3Mp ID8KKwkJCVNPX0hJTlRfUkVMX1JFQURfT05MWSA6IDA7CisKIAkJLyoKIAkJICogV2UgcmVhY2gg aGVyZSBpZiB0aGUgaW5kZXggb25seSBzY2FuIGlzIG5vdCBwYXJhbGxlbCwgb3IgaWYgd2UncmUK IAkJICogc2VyaWFsbHkgZXhlY3V0aW5nIGFuIGluZGV4IG9ubHkgc2NhbiB0aGF0IHdhcyBwbGFu bmVkIHRvIGJlCkBAIC05Miw3ICs5NSw3IEBAIEluZGV4T25seU5leHQoSW5kZXhPbmx5U2NhblN0 YXRlICpub2RlKQogCQkgKi8KIAkJc2NhbmRlc2MgPSBpbmRleF9iZWdpbnNjYW4obm9kZS0+c3Mu c3NfY3VycmVudFJlbGF0aW9uLAogCQkJCQkJCQkgICBub2RlLT5pb3NzX1JlbGF0aW9uRGVzYywK LQkJCQkJCQkJICAgMCwJLyogZmxhZ3MgKi8KKwkJCQkJCQkJICAgZmxhZ3MsCiAJCQkJCQkJCSAg IGVzdGF0ZS0+ZXNfc25hcHNob3QsCiAJCQkJCQkJCSAgICZub2RlLT5pb3NzX0luc3RydW1lbnQs CiAJCQkJCQkJCSAgIG5vZGUtPmlvc3NfTnVtU2NhbktleXMsCkBAIC03OTEsNyArNzk0LDEwIEBA IEV4ZWNJbmRleE9ubHlTY2FuSW5pdGlhbGl6ZURTTShJbmRleE9ubHlTY2FuU3RhdGUgKm5vZGUs CiAJCQkJCQkJCSAmbm9kZS0+aW9zc19JbnN0cnVtZW50LAogCQkJCQkJCQkgbm9kZS0+aW9zc19O dW1TY2FuS2V5cywKIAkJCQkJCQkJIG5vZGUtPmlvc3NfTnVtT3JkZXJCeUtleXMsCi0JCQkJCQkJ CSBwaXNjYW4sIDApOworCQkJCQkJCQkgcGlzY2FuLAorCQkJCQkJCQkgU2NhblJlbElzUmVhZE9u bHkoJm5vZGUtPnNzKSA/CisJCQkJCQkJCSBTT19ISU5UX1JFTF9SRUFEX09OTFkgOiAwKTsKKwog CW5vZGUtPmlvc3NfU2NhbkRlc2MtPnhzX3dhbnRfaXR1cCA9IHRydWU7CiAJbm9kZS0+aW9zc19W TUJ1ZmZlciA9IEludmFsaWRCdWZmZXI7CiAKQEAgLTg1Nyw3ICs4NjMsMTAgQEAgRXhlY0luZGV4 T25seVNjYW5Jbml0aWFsaXplV29ya2VyKEluZGV4T25seVNjYW5TdGF0ZSAqbm9kZSwKIAkJCQkJ CQkJICZub2RlLT5pb3NzX0luc3RydW1lbnQsCiAJCQkJCQkJCSBub2RlLT5pb3NzX051bVNjYW5L ZXlzLAogCQkJCQkJCQkgbm9kZS0+aW9zc19OdW1PcmRlckJ5S2V5cywKLQkJCQkJCQkJIHBpc2Nh biwgMCk7CisJCQkJCQkJCSBwaXNjYW4sCisJCQkJCQkJCSBTY2FuUmVsSXNSZWFkT25seSgmbm9k ZS0+c3MpID8KKwkJCQkJCQkJIFNPX0hJTlRfUkVMX1JFQURfT05MWSA6IDApOworCiAJbm9kZS0+ aW9zc19TY2FuRGVzYy0+eHNfd2FudF9pdHVwID0gdHJ1ZTsKIAogCS8qCmRpZmYgLS1naXQgYS9z cmMvYmFja2VuZC9leGVjdXRvci9ub2RlSW5kZXhzY2FuLmMgYi9zcmMvYmFja2VuZC9leGVjdXRv ci9ub2RlSW5kZXhzY2FuLmMKaW5kZXggYTM3ZmE5YWJlY2UuLmFkNDYwYzExNjc5IDEwMDY0NAot LS0gYS9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlSW5kZXhzY2FuLmMKKysrIGIvc3JjL2JhY2tl bmQvZXhlY3V0b3Ivbm9kZUluZGV4c2Nhbi5jCkBAIC0xMDQsMTMgKzEwNCwxNiBAQCBJbmRleE5l eHQoSW5kZXhTY2FuU3RhdGUgKm5vZGUpCiAKIAlpZiAoc2NhbmRlc2MgPT0gTlVMTCkKIAl7CisJ CXVpbnQzMgkJZmxhZ3MgPSBTY2FuUmVsSXNSZWFkT25seSgmbm9kZS0+c3MpID8KKwkJCVNPX0hJ TlRfUkVMX1JFQURfT05MWSA6IDA7CisKIAkJLyoKIAkJICogV2UgcmVhY2ggaGVyZSBpZiB0aGUg aW5kZXggc2NhbiBpcyBub3QgcGFyYWxsZWwsIG9yIGlmIHdlJ3JlCiAJCSAqIHNlcmlhbGx5IGV4 ZWN1dGluZyBhbiBpbmRleCBzY2FuIHRoYXQgd2FzIHBsYW5uZWQgdG8gYmUgcGFyYWxsZWwuCiAJ CSAqLwogCQlzY2FuZGVzYyA9IGluZGV4X2JlZ2luc2Nhbihub2RlLT5zcy5zc19jdXJyZW50UmVs YXRpb24sCiAJCQkJCQkJCSAgIG5vZGUtPmlzc19SZWxhdGlvbkRlc2MsCi0JCQkJCQkJCSAgIDAs CS8qIGZsYWdzICovCisJCQkJCQkJCSAgIGZsYWdzLAogCQkJCQkJCQkgICBlc3RhdGUtPmVzX3Nu YXBzaG90LAogCQkJCQkJCQkgICAmbm9kZS0+aXNzX0luc3RydW1lbnQsCiAJCQkJCQkJCSAgIG5v ZGUtPmlzc19OdW1TY2FuS2V5cywKQEAgLTIwMSwxMyArMjA0LDE2IEBAIEluZGV4TmV4dFdpdGhS ZW9yZGVyKEluZGV4U2NhblN0YXRlICpub2RlKQogCiAJaWYgKHNjYW5kZXNjID09IE5VTEwpCiAJ eworCQl1aW50MzIJCWZsYWdzID0gU2NhblJlbElzUmVhZE9ubHkoJm5vZGUtPnNzKSA/CisJCQlT T19ISU5UX1JFTF9SRUFEX09OTFkgOiAwOworCiAJCS8qCiAJCSAqIFdlIHJlYWNoIGhlcmUgaWYg dGhlIGluZGV4IHNjYW4gaXMgbm90IHBhcmFsbGVsLCBvciBpZiB3ZSdyZQogCQkgKiBzZXJpYWxs eSBleGVjdXRpbmcgYW4gaW5kZXggc2NhbiB0aGF0IHdhcyBwbGFubmVkIHRvIGJlIHBhcmFsbGVs LgogCQkgKi8KIAkJc2NhbmRlc2MgPSBpbmRleF9iZWdpbnNjYW4obm9kZS0+c3Muc3NfY3VycmVu dFJlbGF0aW9uLAogCQkJCQkJCQkgICBub2RlLT5pc3NfUmVsYXRpb25EZXNjLAotCQkJCQkJCQkg ICAwLAkvKiBmbGFncyAqLworCQkJCQkJCQkgICBmbGFncywKIAkJCQkJCQkJICAgZXN0YXRlLT5l c19zbmFwc2hvdCwKIAkJCQkJCQkJICAgJm5vZGUtPmlzc19JbnN0cnVtZW50LAogCQkJCQkJCQkg ICBub2RlLT5pc3NfTnVtU2NhbktleXMsCkBAIC0xNzI4LDcgKzE3MzQsOSBAQCBFeGVjSW5kZXhT Y2FuSW5pdGlhbGl6ZURTTShJbmRleFNjYW5TdGF0ZSAqbm9kZSwKIAkJCQkJCQkJICZub2RlLT5p c3NfSW5zdHJ1bWVudCwKIAkJCQkJCQkJIG5vZGUtPmlzc19OdW1TY2FuS2V5cywKIAkJCQkJCQkJ IG5vZGUtPmlzc19OdW1PcmRlckJ5S2V5cywKLQkJCQkJCQkJIHBpc2NhbiwgMCk7CisJCQkJCQkJ CSBwaXNjYW4sCisJCQkJCQkJCSBTY2FuUmVsSXNSZWFkT25seSgmbm9kZS0+c3MpID8KKwkJCQkJ CQkJIFNPX0hJTlRfUkVMX1JFQURfT05MWSA6IDApOwogCiAJLyoKIAkgKiBJZiBubyBydW4tdGlt ZSBrZXlzIHRvIGNhbGN1bGF0ZSBvciB0aGV5IGFyZSByZWFkeSwgZ28gYWhlYWQgYW5kIHBhc3MK QEAgLTE3OTIsNyArMTgwMCw5IEBAIEV4ZWNJbmRleFNjYW5Jbml0aWFsaXplV29ya2VyKEluZGV4 U2NhblN0YXRlICpub2RlLAogCQkJCQkJCQkgJm5vZGUtPmlzc19JbnN0cnVtZW50LAogCQkJCQkJ CQkgbm9kZS0+aXNzX051bVNjYW5LZXlzLAogCQkJCQkJCQkgbm9kZS0+aXNzX051bU9yZGVyQnlL ZXlzLAotCQkJCQkJCQkgcGlzY2FuLCAwKTsKKwkJCQkJCQkJIHBpc2NhbiwKKwkJCQkJCQkJIFNj YW5SZWxJc1JlYWRPbmx5KCZub2RlLT5zcykgPworCQkJCQkJCQkgU09fSElOVF9SRUxfUkVBRF9P TkxZIDogMCk7CiAKIAkvKgogCSAqIElmIG5vIHJ1bi10aW1lIGtleXMgdG8gY2FsY3VsYXRlIG9y IHRoZXkgYXJlIHJlYWR5LCBnbyBhaGVhZCBhbmQgcGFzcwpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tl bmQvZXhlY3V0b3Ivbm9kZVNhbXBsZXNjYW4uYyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVT YW1wbGVzY2FuLmMKaW5kZXggY2M2YjIzYWJlZTAuLjcxYzcwZTVlNWM3IDEwMDY0NAotLS0gYS9z cmMvYmFja2VuZC9leGVjdXRvci9ub2RlU2FtcGxlc2Nhbi5jCisrKyBiL3NyYy9iYWNrZW5kL2V4 ZWN1dG9yL25vZGVTYW1wbGVzY2FuLmMKQEAgLTI5MiwxMyArMjkyLDE2IEBAIHRhYmxlc2FtcGxl X2luaXQoU2FtcGxlU2NhblN0YXRlICpzY2Fuc3RhdGUpCiAJLyogTm93IHdlIGNhbiBjcmVhdGUg b3IgcmVzZXQgdGhlIEhlYXBTY2FuRGVzYyAqLwogCWlmIChzY2Fuc3RhdGUtPnNzLnNzX2N1cnJl bnRTY2FuRGVzYyA9PSBOVUxMKQogCXsKKwkJdWludDMyCQlmbGFncyA9IFNjYW5SZWxJc1JlYWRP bmx5KCZzY2Fuc3RhdGUtPnNzKSA/CisJCQlTT19ISU5UX1JFTF9SRUFEX09OTFkgOiAwOworCiAJ CXNjYW5zdGF0ZS0+c3Muc3NfY3VycmVudFNjYW5EZXNjID0KIAkJCXRhYmxlX2JlZ2luc2Nhbl9z YW1wbGluZyhzY2Fuc3RhdGUtPnNzLnNzX2N1cnJlbnRSZWxhdGlvbiwKIAkJCQkJCQkJCSBzY2Fu c3RhdGUtPnNzLnBzLnN0YXRlLT5lc19zbmFwc2hvdCwKIAkJCQkJCQkJCSAwLCBOVUxMLAogCQkJ CQkJCQkJIHNjYW5zdGF0ZS0+dXNlX2J1bGtyZWFkLAogCQkJCQkJCQkJIGFsbG93X3N5bmMsCi0J CQkJCQkJCQkgc2NhbnN0YXRlLT51c2VfcGFnZW1vZGUsIDApOworCQkJCQkJCQkJIHNjYW5zdGF0 ZS0+dXNlX3BhZ2Vtb2RlLCBmbGFncyk7CiAJfQogCWVsc2UKIAl7CmRpZmYgLS1naXQgYS9zcmMv YmFja2VuZC9leGVjdXRvci9ub2RlU2Vxc2Nhbi5jIGIvc3JjL2JhY2tlbmQvZXhlY3V0b3Ivbm9k ZVNlcXNjYW4uYwppbmRleCBjMmQ5YjcyOTNkZS4uNzk0NzBlNmI5YjUgMTAwNjQ0Ci0tLSBhL3Ny Yy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVTZXFzY2FuLmMKKysrIGIvc3JjL2JhY2tlbmQvZXhlY3V0 b3Ivbm9kZVNlcXNjYW4uYwpAQCAtNjUsMTMgKzY1LDE3IEBAIFNlcU5leHQoU2VxU2NhblN0YXRl ICpub2RlKQogCiAJaWYgKHNjYW5kZXNjID09IE5VTEwpCiAJeworCQl1aW50MzIJCWZsYWdzID0g U2NhblJlbElzUmVhZE9ubHkoJm5vZGUtPnNzKSA/CisJCQlTT19ISU5UX1JFTF9SRUFEX09OTFkg OiAwOworCiAJCS8qCiAJCSAqIFdlIHJlYWNoIGhlcmUgaWYgdGhlIHNjYW4gaXMgbm90IHBhcmFs bGVsLCBvciBpZiB3ZSdyZSBzZXJpYWxseQogCQkgKiBleGVjdXRpbmcgYSBzY2FuIHRoYXQgd2Fz IHBsYW5uZWQgdG8gYmUgcGFyYWxsZWwuCiAJCSAqLwogCQlzY2FuZGVzYyA9IHRhYmxlX2JlZ2lu c2Nhbihub2RlLT5zcy5zc19jdXJyZW50UmVsYXRpb24sCiAJCQkJCQkJCSAgIGVzdGF0ZS0+ZXNf c25hcHNob3QsCi0JCQkJCQkJCSAgIDAsIE5VTEwsIDApOworCQkJCQkJCQkgICAwLCBOVUxMLCBm bGFncyk7CisKIAkJbm9kZS0+c3Muc3NfY3VycmVudFNjYW5EZXNjID0gc2NhbmRlc2M7CiAJfQog CkBAIC0zNjgsMTQgKzM3MiwxOCBAQCBFeGVjU2VxU2NhbkluaXRpYWxpemVEU00oU2VxU2NhblN0 YXRlICpub2RlLAogewogCUVTdGF0ZQkgICAqZXN0YXRlID0gbm9kZS0+c3MucHMuc3RhdGU7CiAJ UGFyYWxsZWxUYWJsZVNjYW5EZXNjIHBzY2FuOworCXVpbnQzMgkJZmxhZ3MgPSBTY2FuUmVsSXNS ZWFkT25seSgmbm9kZS0+c3MpID8KKwkJU09fSElOVF9SRUxfUkVBRF9PTkxZIDogMDsKIAogCXBz Y2FuID0gc2htX3RvY19hbGxvY2F0ZShwY3h0LT50b2MsIG5vZGUtPnBzY2FuX2xlbik7CiAJdGFi bGVfcGFyYWxsZWxzY2FuX2luaXRpYWxpemUobm9kZS0+c3Muc3NfY3VycmVudFJlbGF0aW9uLAog CQkJCQkJCQkgIHBzY2FuLAogCQkJCQkJCQkgIGVzdGF0ZS0+ZXNfc25hcHNob3QpOwogCXNobV90 b2NfaW5zZXJ0KHBjeHQtPnRvYywgbm9kZS0+c3MucHMucGxhbi0+cGxhbl9ub2RlX2lkLCBwc2Nh bik7CisKIAlub2RlLT5zcy5zc19jdXJyZW50U2NhbkRlc2MgPQotCQl0YWJsZV9iZWdpbnNjYW5f cGFyYWxsZWwobm9kZS0+c3Muc3NfY3VycmVudFJlbGF0aW9uLCBwc2NhbiwgMCk7CisJCXRhYmxl X2JlZ2luc2Nhbl9wYXJhbGxlbChub2RlLT5zcy5zc19jdXJyZW50UmVsYXRpb24sIHBzY2FuLAor CQkJCQkJCQkgZmxhZ3MpOwogfQogCiAvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCkBAIC00MDUsOCArNDEzLDEyIEBAIEV4 ZWNTZXFTY2FuSW5pdGlhbGl6ZVdvcmtlcihTZXFTY2FuU3RhdGUgKm5vZGUsCiAJCQkJCQkJUGFy YWxsZWxXb3JrZXJDb250ZXh0ICpwd2N4dCkKIHsKIAlQYXJhbGxlbFRhYmxlU2NhbkRlc2MgcHNj YW47CisJdWludDMyCQlmbGFncyA9IFNjYW5SZWxJc1JlYWRPbmx5KCZub2RlLT5zcykgPworCQlT T19ISU5UX1JFTF9SRUFEX09OTFkgOiAwOwogCiAJcHNjYW4gPSBzaG1fdG9jX2xvb2t1cChwd2N4 dC0+dG9jLCBub2RlLT5zcy5wcy5wbGFuLT5wbGFuX25vZGVfaWQsIGZhbHNlKTsKIAlub2RlLT5z cy5zc19jdXJyZW50U2NhbkRlc2MgPQotCQl0YWJsZV9iZWdpbnNjYW5fcGFyYWxsZWwobm9kZS0+ c3Muc3NfY3VycmVudFJlbGF0aW9uLCBwc2NhbiwgMCk7CisJCXRhYmxlX2JlZ2luc2Nhbl9wYXJh bGxlbChub2RlLT5zcy5zc19jdXJyZW50UmVsYXRpb24sCisJCQkJCQkJCSBwc2NhbiwKKwkJCQkJ CQkJIGZsYWdzKTsKIH0KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVUaWRy YW5nZXNjYW4uYyBiL3NyYy9iYWNrZW5kL2V4ZWN1dG9yL25vZGVUaWRyYW5nZXNjYW4uYwppbmRl eCA5OTRmNzA5ODliYy4uNDI1N2FmZDk2ZWQgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2V4ZWN1 dG9yL25vZGVUaWRyYW5nZXNjYW4uYworKysgYi9zcmMvYmFja2VuZC9leGVjdXRvci9ub2RlVGlk cmFuZ2VzY2FuLmMKQEAgLTI0MiwxMCArMjQyLDEzIEBAIFRpZFJhbmdlTmV4dChUaWRSYW5nZVNj YW5TdGF0ZSAqbm9kZSkKIAogCQlpZiAoc2NhbmRlc2MgPT0gTlVMTCkKIAkJeworCQkJdWludDMy CQlmbGFncyA9IFNjYW5SZWxJc1JlYWRPbmx5KCZub2RlLT5zcykgPworCQkJCVNPX0hJTlRfUkVM X1JFQURfT05MWSA6IDA7CisKIAkJCXNjYW5kZXNjID0gdGFibGVfYmVnaW5zY2FuX3RpZHJhbmdl KG5vZGUtPnNzLnNzX2N1cnJlbnRSZWxhdGlvbiwKIAkJCQkJCQkJCQkJCWVzdGF0ZS0+ZXNfc25h cHNob3QsCiAJCQkJCQkJCQkJCQkmbm9kZS0+dHJzc19taW50aWQsCi0JCQkJCQkJCQkJCQkmbm9k ZS0+dHJzc19tYXh0aWQsIDApOworCQkJCQkJCQkJCQkJJm5vZGUtPnRyc3NfbWF4dGlkLCBmbGFn cyk7CiAJCQlub2RlLT5zcy5zc19jdXJyZW50U2NhbkRlc2MgPSBzY2FuZGVzYzsKIAkJfQogCQll bHNlCkBAIC00NTIsMTUgKzQ1NSwxOCBAQCBFeGVjVGlkUmFuZ2VTY2FuSW5pdGlhbGl6ZURTTShU aWRSYW5nZVNjYW5TdGF0ZSAqbm9kZSwgUGFyYWxsZWxDb250ZXh0ICpwY3h0KQogewogCUVTdGF0 ZQkgICAqZXN0YXRlID0gbm9kZS0+c3MucHMuc3RhdGU7CiAJUGFyYWxsZWxUYWJsZVNjYW5EZXNj IHBzY2FuOworCXVpbnQzMgkJZmxhZ3MgPSBTY2FuUmVsSXNSZWFkT25seSgmbm9kZS0+c3MpID8K KwkJU09fSElOVF9SRUxfUkVBRF9PTkxZIDogMDsKIAogCXBzY2FuID0gc2htX3RvY19hbGxvY2F0 ZShwY3h0LT50b2MsIG5vZGUtPnRyc3NfcHNjYW5sZW4pOwogCXRhYmxlX3BhcmFsbGVsc2Nhbl9p bml0aWFsaXplKG5vZGUtPnNzLnNzX2N1cnJlbnRSZWxhdGlvbiwKIAkJCQkJCQkJICBwc2NhbiwK IAkJCQkJCQkJICBlc3RhdGUtPmVzX3NuYXBzaG90KTsKIAlzaG1fdG9jX2luc2VydChwY3h0LT50 b2MsIG5vZGUtPnNzLnBzLnBsYW4tPnBsYW5fbm9kZV9pZCwgcHNjYW4pOworCiAJbm9kZS0+c3Mu c3NfY3VycmVudFNjYW5EZXNjID0KIAkJdGFibGVfYmVnaW5zY2FuX3BhcmFsbGVsX3RpZHJhbmdl KG5vZGUtPnNzLnNzX2N1cnJlbnRSZWxhdGlvbiwKLQkJCQkJCQkJCQkgIHBzY2FuLCAwKTsKKwkJ CQkJCQkJCQkgIHBzY2FuLCBmbGFncyk7CiB9CiAKIC8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KQEAgLTQ5MCw5ICs0OTYs MTIgQEAgRXhlY1RpZFJhbmdlU2NhbkluaXRpYWxpemVXb3JrZXIoVGlkUmFuZ2VTY2FuU3RhdGUg Km5vZGUsCiAJCQkJCQkJCSBQYXJhbGxlbFdvcmtlckNvbnRleHQgKnB3Y3h0KQogewogCVBhcmFs bGVsVGFibGVTY2FuRGVzYyBwc2NhbjsKKwl1aW50MzIJCWZsYWdzID0gU2NhblJlbElzUmVhZE9u bHkoJm5vZGUtPnNzKSA/CisJCVNPX0hJTlRfUkVMX1JFQURfT05MWSA6IDA7CiAKIAlwc2NhbiA9 IHNobV90b2NfbG9va3VwKHB3Y3h0LT50b2MsIG5vZGUtPnNzLnBzLnBsYW4tPnBsYW5fbm9kZV9p ZCwgZmFsc2UpOworCiAJbm9kZS0+c3Muc3NfY3VycmVudFNjYW5EZXNjID0KIAkJdGFibGVfYmVn aW5zY2FuX3BhcmFsbGVsX3RpZHJhbmdlKG5vZGUtPnNzLnNzX2N1cnJlbnRSZWxhdGlvbiwKLQkJ CQkJCQkJCQkgIHBzY2FuLCAwKTsKKwkJCQkJCQkJCQkgIHBzY2FuLCBmbGFncyk7CiB9CmRpZmYg LS1naXQgYS9zcmMvaW5jbHVkZS9hY2Nlc3MvdGFibGVhbS5oIGIvc3JjL2luY2x1ZGUvYWNjZXNz L3RhYmxlYW0uaAppbmRleCA4MzU3ZDA1ZDgzYi4uNDg3ZTM4MjkyZmEgMTAwNjQ0Ci0tLSBhL3Ny Yy9pbmNsdWRlL2FjY2Vzcy90YWJsZWFtLmgKKysrIGIvc3JjL2luY2x1ZGUvYWNjZXNzL3RhYmxl YW0uaApAQCAtNjMsNiArNjMsOSBAQCB0eXBlZGVmIGVudW0gU2Nhbk9wdGlvbnMKIAogCS8qIHVu cmVnaXN0ZXIgc25hcHNob3QgYXQgc2NhbiBlbmQ/ICovCiAJU09fVEVNUF9TTkFQU0hPVCA9IDEg PDwgOSwKKworCS8qIHNldCBpZiB0aGUgcXVlcnkgZG9lc24ndCBtb2RpZnkgdGhlIHJlbGF0aW9u ICovCisJU09fSElOVF9SRUxfUkVBRF9PTkxZID0gMSA8PCAxMCwKIH0JCQlTY2FuT3B0aW9uczsK IAogLyoKZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL2V4ZWN1dG9yL2V4ZWN1dG9yLmggYi9zcmMv aW5jbHVkZS9leGVjdXRvci9leGVjdXRvci5oCmluZGV4IDA3ZjRiMWY3NDkwLi4zMWM0MTkyYjY3 ZSAxMDA2NDQKLS0tIGEvc3JjL2luY2x1ZGUvZXhlY3V0b3IvZXhlY3V0b3IuaAorKysgYi9zcmMv aW5jbHVkZS9leGVjdXRvci9leGVjdXRvci5oCkBAIC02OTAsNiArNjkwLDE2IEBAIGV4dGVybiB2 b2lkIEV4ZWNDcmVhdGVTY2FuU2xvdEZyb21PdXRlclBsYW4oRVN0YXRlICplc3RhdGUsCiAKIGV4 dGVybiBib29sIEV4ZWNSZWxhdGlvbklzVGFyZ2V0UmVsYXRpb24oRVN0YXRlICplc3RhdGUsIElu ZGV4IHNjYW5yZWxpZCk7CiAKKy8qCisgKiBSZXR1cm4gdHJ1ZSBpZiB0aGUgc2NhbiBub2RlJ3Mg cmVsYXRpb24gaXMgbm90IG1vZGlmaWVkIGJ5IHRoZSBxdWVyeS4KKyAqLworc3RhdGljIGlubGlu ZSBib29sCitTY2FuUmVsSXNSZWFkT25seShTY2FuU3RhdGUgKnNzKQoreworCXJldHVybiAhYm1z X2lzX21lbWJlcigoKFNjYW4gKikgc3MtPnBzLnBsYW4pLT5zY2FucmVsaWQsCisJCQkJCQkgIHNz LT5wcy5zdGF0ZS0+ZXNfcGxhbm5lZHN0bXQtPm1vZGlmaWVkUmVsaWRzKTsKK30KKwogZXh0ZXJu IFJlbGF0aW9uIEV4ZWNPcGVuU2NhblJlbGF0aW9uKEVTdGF0ZSAqZXN0YXRlLCBJbmRleCBzY2Fu cmVsaWQsIGludCBlZmxhZ3MpOwogCiBleHRlcm4gdm9pZCBFeGVjSW5pdFJhbmdlVGFibGUoRVN0 YXRlICplc3RhdGUsIExpc3QgKnJhbmdlVGFibGUsIExpc3QgKnBlcm1JbmZvcywKLS0gCjIuNDMu MAoK --00000000000060fd69064d6b968a Content-Type: text/x-patch; charset="US-ASCII"; name="v41-0011-Allow-on-access-pruning-to-set-pages-all-visible.patch" Content-Disposition: attachment; filename="v41-0011-Allow-on-access-pruning-to-set-pages-all-visible.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmyagvxz10 RnJvbSBmMDJhN2U4ODBhZjkxYzRmYjE0ZWRjNzUwNzZkNDQ4ZjAwNDYyMjcwIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBGcmksIDI3IEZlYiAyMDI2IDE2OjMzOjQwIC0wNTAwClN1YmplY3Q6IFtQ QVRDSCB2NDEgMTEvMTJdIEFsbG93IG9uLWFjY2VzcyBwcnVuaW5nIHRvIHNldCBwYWdlcyBhbGwt dmlzaWJsZQoKTWFueSBxdWVyaWVzIGRvIG5vdCBtb2RpZnkgdGhlIHVuZGVybHlpbmcgcmVsYXRp b24uIEZvciBzdWNoIHF1ZXJpZXMsIGlmCm9uLWFjY2VzcyBwcnVuaW5nIG9jY3VycyBkdXJpbmcg dGhlIHNjYW4sIHdlIGNhbiBjaGVjayB3aGV0aGVyIHRoZSBwYWdlCmhhcyBiZWNvbWUgYWxsLXZp c2libGUgYW5kIHVwZGF0ZSB0aGUgdmlzaWJpbGl0eSBtYXAgYWNjb3JkaW5nbHkuClByZXZpb3Vz bHksIG9ubHkgdmFjdXVtIGFuZCBDT1BZIEZSRUVaRSBtYXJrZWQgcGFnZXMgYXMgYWxsLXZpc2li bGUgb3IKYWxsLWZyb3plbi4KClRoaXMgY29tbWl0IGltcGxlbWVudHMgb24tYWNjZXNzIFZNIHNl dHRpbmcgZm9yIHNlcXVlbnRpYWwgc2NhbnMgYXMgd2VsbAphcyBmb3IgdGhlIHVuZGVybHlpbmcg aGVhcCByZWxhdGlvbiBpbiBpbmRleCBzY2FucyBhbmQgYml0bWFwIGhlYXAKc2NhbnMuCgpTZXR0 aW5nIHRoZSB2aXNpYmlsaXR5IG1hcCBvbi1hY2Nlc3MgY2FuIGF2b2lkIHdyaXRlIGFtcGxpZmlj YXRpb24KY2F1c2VkIGJ5IHZhY3V1bSBsYXRlciBuZWVkaW5nIHRvIHNldCB0aGUgcGFnZSBhbGwt dmlzaWJsZSwgdHJpZ2dlciBhCndyaXRlIGFuZCBwb3RlbnRpYWxseSBGUEkuIEl0IGFsc28gYWxs b3dzIG1vcmUgZnJlcXVlbnQgaW5kZXgtb25seQpzY2Fucywgc2luY2UgdGhleSByZXF1cmllIHBh Z2VzIHRvIGJlIG1hcmtlZCBhbGwtdmlzaWJsZSBpbiB0aGUgVk0uCgpBdXRob3I6IE1lbGFuaWUg UGxhZ2VtYW4gPG1lbGFuaWVwbGFnZW1hbkBnbWFpbC5jb20+ClJldmlld2VkLWJ5OiBBbmRyZXMg RnJldW5kIDxhbmRyZXNAYW5hcmF6ZWwuZGU+ClJldmlld2VkLWJ5OiBLaXJpbGwgUmVzaGtlIDxy ZXNoa2VraXJpbGxAZ21haWwuY29tPgpSZXZpZXdlZC1ieTogQ2hhbyBMaSA8bGkuZXZhbi5jaGFv QGdtYWlsLmNvbT4KRGlzY3Vzc2lvbjogaHR0cHM6Ly9wb3N0Z3IuZXMvbS9mbGF0L0NBQUtSdV9a TXc2TnBkX3FtMktNJTJCRndRM2NNT014MURoM1ZNaHA4LVY3U09MeGRLOS1nJTQwbWFpbC5nbWFp bC5jb20KLS0tCiBzcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9oZWFwYW0uYyAgICAgICAgIHwgIDMg Ky0KIHNyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL2hlYXBhbV9oYW5kbGVyLmMgfCAgNiArKy0tCiBz cmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9wcnVuZWhlYXAuYyAgICAgIHwgNDYgKysrKysrKysrKysr KysrKystLS0tLS0tCiBzcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMgICAgIHwg IDIgKy0KIHNyYy9pbmNsdWRlL2FjY2Vzcy9oZWFwYW0uaCAgICAgICAgICAgICAgfCAxNiArKysr KysrLS0KIDUgZmlsZXMgY2hhbmdlZCwgNTQgaW5zZXJ0aW9ucygrKSwgMTkgZGVsZXRpb25zKC0p CgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvaGVhcGFtLmMgYi9zcmMvYmFj a2VuZC9hY2Nlc3MvaGVhcC9oZWFwYW0uYwppbmRleCAwNDRmMzg1ZTQ3Ny4uZGJkZjY1MjFjNDIg MTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL2hlYXBhbS5jCisrKyBiL3NyYy9i YWNrZW5kL2FjY2Vzcy9oZWFwL2hlYXBhbS5jCkBAIC02MzMsNyArNjMzLDggQEAgaGVhcF9wcmVw YXJlX3BhZ2VzY2FuKFRhYmxlU2NhbkRlc2Mgc3NjYW4pCiAJLyoKIAkgKiBQcnVuZSBhbmQgcmVw YWlyIGZyYWdtZW50YXRpb24gZm9yIHRoZSB3aG9sZSBwYWdlLCBpZiBwb3NzaWJsZS4KIAkgKi8K LQloZWFwX3BhZ2VfcHJ1bmVfb3B0KHNjYW4tPnJzX2Jhc2UucnNfcmQsIGJ1ZmZlciwgJnNjYW4t PnJzX3ZtYnVmZmVyKTsKKwloZWFwX3BhZ2VfcHJ1bmVfb3B0KHNjYW4tPnJzX2Jhc2UucnNfcmQs IGJ1ZmZlciwgJnNjYW4tPnJzX3ZtYnVmZmVyLAorCQkJCQkJKHNzY2FuLT5yc19mbGFncyAmIFNP X0hJTlRfUkVMX1JFQURfT05MWSkpOwogCiAJLyoKIAkgKiBXZSBtdXN0IGhvbGQgc2hhcmUgbG9j ayBvbiB0aGUgYnVmZmVyIGNvbnRlbnQgd2hpbGUgZXhhbWluaW5nIHR1cGxlCmRpZmYgLS1naXQg YS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9oZWFwYW1faGFuZGxlci5jIGIvc3JjL2JhY2tlbmQv YWNjZXNzL2hlYXAvaGVhcGFtX2hhbmRsZXIuYwppbmRleCA2NjcyNmIyMmRlNi4uNjUxZWZhMDEy N2EgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL2hlYXBhbV9oYW5kbGVyLmMK KysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvaGVhcGFtX2hhbmRsZXIuYwpAQCAtMTQ4LDcg KzE0OCw4IEBAIGhlYXBhbV9pbmRleF9mZXRjaF90dXBsZShzdHJ1Y3QgSW5kZXhGZXRjaFRhYmxl RGF0YSAqc2NhbiwKIAkJICovCiAJCWlmIChwcmV2X2J1ZiAhPSBoc2Nhbi0+eHNfY2J1ZikKIAkJ CWhlYXBfcGFnZV9wcnVuZV9vcHQoaHNjYW4tPnhzX2Jhc2UucmVsLCBoc2Nhbi0+eHNfY2J1ZiwK LQkJCQkJCQkJJmhzY2FuLT54c192bWJ1ZmZlcik7CisJCQkJCQkJCSZoc2Nhbi0+eHNfdm1idWZm ZXIsCisJCQkJCQkJCShoc2Nhbi0+eHNfYmFzZS5mbGFncyAmIFNPX0hJTlRfUkVMX1JFQURfT05M WSkpOwogCX0KIAogCS8qIE9idGFpbiBzaGFyZS1sb2NrIG9uIHRoZSBidWZmZXIgc28gd2UgY2Fu IGV4YW1pbmUgdmlzaWJpbGl0eSAqLwpAQCAtMjU0NSw3ICsyNTQ2LDggQEAgQml0bWFwSGVhcFNj YW5OZXh0QmxvY2soVGFibGVTY2FuRGVzYyBzY2FuLAogCS8qCiAJICogUHJ1bmUgYW5kIHJlcGFp ciBmcmFnbWVudGF0aW9uIGZvciB0aGUgd2hvbGUgcGFnZSwgaWYgcG9zc2libGUuCiAJICovCi0J aGVhcF9wYWdlX3BydW5lX29wdChzY2FuLT5yc19yZCwgYnVmZmVyLCAmaHNjYW4tPnJzX3ZtYnVm ZmVyKTsKKwloZWFwX3BhZ2VfcHJ1bmVfb3B0KHNjYW4tPnJzX3JkLCBidWZmZXIsICZoc2Nhbi0+ cnNfdm1idWZmZXIsCisJCQkJCQlzY2FuLT5yc19mbGFncyAmIFNPX0hJTlRfUkVMX1JFQURfT05M WSk7CiAKIAkvKgogCSAqIFdlIG11c3QgaG9sZCBzaGFyZSBsb2NrIG9uIHRoZSBidWZmZXIgY29u dGVudCB3aGlsZSBleGFtaW5pbmcgdHVwbGUKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vz cy9oZWFwL3BydW5laGVhcC5jIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvcHJ1bmVoZWFwLmMK aW5kZXggZmFjNzE5NGRjYmEuLmRlYjdiOTQ4YzFlIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9h Y2Nlc3MvaGVhcC9wcnVuZWhlYXAuYworKysgYi9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9wcnVu ZWhlYXAuYwpAQCAtNDQsNiArNDQsOCBAQCB0eXBlZGVmIHN0cnVjdAogCWJvb2wJCW1hcmtfdW51 c2VkX25vdzsKIAkvKiB3aGV0aGVyIHRvIGF0dGVtcHQgZnJlZXppbmcgdHVwbGVzICovCiAJYm9v bAkJYXR0ZW1wdF9mcmVlemU7CisJLyogd2hldGhlciB0byBhdHRlbXB0IHNldHRpbmcgdGhlIFZN ICovCisJYm9vbAkJYXR0ZW1wdF9zZXRfdm07CiAJc3RydWN0IFZhY3V1bUN1dG9mZnMgKmN1dG9m ZnM7CiAJUmVsYXRpb24JcmVsYXRpb247CiAKQEAgLTIzNiw3ICsyMzgsOCBAQCBzdGF0aWMgdm9p ZCBwYWdlX3ZlcmlmeV9yZWRpcmVjdHMoUGFnZSBwYWdlKTsKIAogc3RhdGljIGJvb2wgaGVhcF9w YWdlX3dpbGxfZnJlZXplKGJvb2wgZGlkX3R1cGxlX2hpbnRfZnBpLCBib29sIGRvX3BydW5lLCBi b29sIGRvX2hpbnRfcHJ1bmUsCiAJCQkJCQkJCSAgUHJ1bmVTdGF0ZSAqcHJzdGF0ZSk7Ci1zdGF0 aWMgYm9vbCBoZWFwX3BhZ2Vfd2lsbF9zZXRfdm0oUHJ1bmVTdGF0ZSAqcHJzdGF0ZSwgUHJ1bmVS ZWFzb24gcmVhc29uKTsKK3N0YXRpYyBib29sIGhlYXBfcGFnZV93aWxsX3NldF92bShQcnVuZVN0 YXRlICpwcnN0YXRlLCBQcnVuZVJlYXNvbiByZWFzb24sCisJCQkJCQkJCSAgYm9vbCBkb19wcnVu ZSwgYm9vbCBkb19mcmVlemUpOwogCiAKIC8qCkBAIC0yNTcsNyArMjYwLDggQEAgc3RhdGljIGJv b2wgaGVhcF9wYWdlX3dpbGxfc2V0X3ZtKFBydW5lU3RhdGUgKnByc3RhdGUsIFBydW5lUmVhc29u IHJlYXNvbik7CiAgKiB1bnBpbm5pbmcgKnZtYnVmZmVyLgogICovCiB2b2lkCi1oZWFwX3BhZ2Vf cHJ1bmVfb3B0KFJlbGF0aW9uIHJlbGF0aW9uLCBCdWZmZXIgYnVmZmVyLCBCdWZmZXIgKnZtYnVm ZmVyKQoraGVhcF9wYWdlX3BydW5lX29wdChSZWxhdGlvbiByZWxhdGlvbiwgQnVmZmVyIGJ1ZmZl ciwgQnVmZmVyICp2bWJ1ZmZlciwKKwkJCQkJYm9vbCByZWxfcmVhZF9vbmx5KQogewogCVBhZ2UJ CXBhZ2UgPSBCdWZmZXJHZXRQYWdlKGJ1ZmZlcik7CiAJVHJhbnNhY3Rpb25JZCBwcnVuZV94aWQ7 CkBAIC0zMzksNiArMzQzLDggQEAgaGVhcF9wYWdlX3BydW5lX29wdChSZWxhdGlvbiByZWxhdGlv biwgQnVmZmVyIGJ1ZmZlciwgQnVmZmVyICp2bWJ1ZmZlcikKIAkJCSAqIGN1cnJlbnQgaW1wbGVt ZW50YXRpb24uCiAJCQkgKi8KIAkJCXBhcmFtcy5vcHRpb25zID0gSEVBUF9QQUdFX1BSVU5FX0FM TE9XX0ZBU1RfUEFUSDsKKwkJCWlmIChyZWxfcmVhZF9vbmx5KQorCQkJCXBhcmFtcy5vcHRpb25z IHw9IEhFQVBfUEFHRV9QUlVORV9TRVRfVk07CiAKIAkJCWhlYXBfcGFnZV9wcnVuZV9hbmRfZnJl ZXplKCZwYXJhbXMsICZwcmVzdWx0LCAmZHVtbXlfb2ZmX2xvYywKIAkJCQkJCQkJCSAgIE5VTEws IE5VTEwpOwpAQCAtMzk1LDYgKzQwMSw3IEBAIHBydW5lX2ZyZWV6ZV9zZXR1cChQcnVuZUZyZWV6 ZVBhcmFtcyAqcGFyYW1zLAogCS8qIGN1dG9mZnMgbXVzdCBiZSBwcm92aWRlZCBpZiB3ZSB3aWxs IGF0dGVtcHQgZnJlZXppbmcgKi8KIAlBc3NlcnQoIShwYXJhbXMtPm9wdGlvbnMgJiBIRUFQX1BB R0VfUFJVTkVfRlJFRVpFKSB8fCBwYXJhbXMtPmN1dG9mZnMpOwogCXByc3RhdGUtPmF0dGVtcHRf ZnJlZXplID0gKHBhcmFtcy0+b3B0aW9ucyAmIEhFQVBfUEFHRV9QUlVORV9GUkVFWkUpICE9IDA7 CisJcHJzdGF0ZS0+YXR0ZW1wdF9zZXRfdm0gPSAocGFyYW1zLT5vcHRpb25zICYgSEVBUF9QQUdF X1BSVU5FX1NFVF9WTSkgIT0gMDsKIAlwcnN0YXRlLT5jdXRvZmZzID0gcGFyYW1zLT5jdXRvZmZz OwogCXByc3RhdGUtPnJlbGF0aW9uID0gcGFyYW1zLT5yZWxhdGlvbjsKIAlwcnN0YXRlLT5ibG9j ayA9IEJ1ZmZlckdldEJsb2NrTnVtYmVyKHBhcmFtcy0+YnVmZmVyKTsKQEAgLTQ3NCw5ICs0ODEs OCBAQCBwcnVuZV9mcmVlemVfc2V0dXAoUHJ1bmVGcmVlemVQYXJhbXMgKnBhcmFtcywKIAkgKiBX ZSB0cmFjayB3aGV0aGVyIHRoZSBwYWdlIHdpbGwgYmUgYWxsLXZpc2libGUvYWxsLWZyb3plbiBh dCB0aGUgZW5kIG9mCiAJICogcHJ1bmluZyBhbmQgZnJlZXppbmcuIFdoaWxlIGV4YW1pbmluZyB0 dXBsZSB2aXNpYmlsaXR5LCB3ZSdsbCBzZXQKIAkgKiBzZXRfYWxsX3Zpc2libGUgdG8gZmFsc2Ug aWYgdGhlcmUgYXJlIHR1cGxlcyBvbiB0aGUgcGFnZSBub3QgdmlzaWJsZSB0bwotCSAqIGFsbCBy dW5uaW5nIGFuZCBmdXR1cmUgdHJhbnNhY3Rpb25zLiBzZXRfYWxsX3Zpc2libGUgaXMgYWx3YXlz Ci0JICogbWFpbnRhaW5lZCBidXQgb25seSBWQUNVVU0gd2lsbCBzZXQgdGhlIFZNIGlmIHRoZSBw YWdlIGVuZHMgdXAgYmVpbmcKLQkgKiBhbGwtdmlzaWJsZS4KKwkgKiBhbGwgcnVubmluZyBhbmQg ZnV0dXJlIHRyYW5zYWN0aW9ucy4gSWYgZW5hYmxlZCBmb3IgdGhpcyBzY2FuLCB3ZSB3aWxsCisJ ICogc2V0IHRoZSBWTSBpZiB0aGUgcGFnZSBlbmRzIHVwIGJlaW5nIGFsbC12aXNpYmxlLgogCSAq CiAJICogV2UgYWxzbyBrZWVwIHRyYWNrIG9mIHRoZSBuZXdlc3QgbGl2ZSBYSUQsIHdoaWNoIGlz IHVzZWQgdG8gY2FsY3VsYXRlCiAJICogdGhlIHNuYXBzaG90IGNvbmZsaWN0IGhvcml6b24gZm9y IGEgV0FMIHJlY29yZCBzZXR0aW5nIHRoZSBWTS4KQEAgLTkyOCwyMSArOTM0LDM3IEBAIGhlYXBf cGFnZV9maXhfdm1fY29ycnVwdGlvbihQcnVuZVN0YXRlICpwcnN0YXRlLCBPZmZzZXROdW1iZXIg b2ZmbnVtLAogICogVGhpcyBmdW5jdGlvbiBkb2VzIG5vdCBhY3R1YWxseSBzZXQgdGhlIFZNIGJp dHMgb3IgcGFnZS1sZXZlbCB2aXNpYmlsaXR5CiAgKiBoaW50LCBQRF9BTExfVklTSUJMRS4KICAq CisgKiBUaGlzIHNob3VsZCBiZSBjYWxsZWQgb25seSBhZnRlciBkb19mcmVlemUgaGFzIGJlZW4g ZGVjaWRlZCAoYW5kIGRvX3BydW5lCisgKiBoYXMgYmVlbiBzZXQpLCBhcyB0aGVzZSBmYWN0b3Ig aW50byBvdXIgaGV1cmlzdGljLWJhc2VkIGRlY2lzaW9uLgorICoKICAqIFJldHVybnMgdHJ1ZSBp ZiBvbmUgb3IgYm90aCBWTSBiaXRzIHNob3VsZCBiZSBzZXQgYW5kIGZhbHNlIG90aGVyd2lzZS4K ICAqLwogc3RhdGljIGJvb2wKLWhlYXBfcGFnZV93aWxsX3NldF92bShQcnVuZVN0YXRlICpwcnN0 YXRlLCBQcnVuZVJlYXNvbiByZWFzb24pCitoZWFwX3BhZ2Vfd2lsbF9zZXRfdm0oUHJ1bmVTdGF0 ZSAqcHJzdGF0ZSwgUHJ1bmVSZWFzb24gcmVhc29uLAorCQkJCQkgIGJvb2wgZG9fcHJ1bmUsIGJv b2wgZG9fZnJlZXplKQogewotCS8qCi0JICogVGhvdWdoIG9uLWFjY2VzcyBwcnVuaW5nIG1haW50 YWlucyBwcnN0YXRlLT5zZXRfYWxsX3Zpc2libGUsIHdlIGRvbid0Ci0JICogc2V0IHRoZSBWTSBm b3Igbm93LgotCSAqLwotCWlmIChyZWFzb24gPT0gUFJVTkVfT05fQUNDRVNTKQorCWlmICghcHJz dGF0ZS0+YXR0ZW1wdF9zZXRfdm0pCiAJCXJldHVybiBmYWxzZTsKIAogCWlmICghcHJzdGF0ZS0+ c2V0X2FsbF92aXNpYmxlKQogCQlyZXR1cm4gZmFsc2U7CiAKKwkvKgorCSAqIElmIHRoaXMgaXMg YW4gb24tYWNjZXNzIGNhbGwgYW5kIHdlJ3JlIG5vdCBhY3R1YWxseSBwcnVuaW5nLCBhdm9pZAor CSAqIHNldHRpbmcgdGhlIHZpc2liaWxpdHkgbWFwIGlmIGl0IHdvdWxkIG5ld2x5IGRpcnR5IHRo ZSBoZWFwIHBhZ2Ugb3IsIGlmCisJICogdGhlIHBhZ2UgaXMgYWxyZWFkeSBkaXJ0eSwgaWYgZG9p bmcgc28gd291bGQgcmVxdWlyZSBpbmNsdWRpbmcgYQorCSAqIGZ1bGwtcGFnZSBpbWFnZSAoRlBJ KSBvZiB0aGUgaGVhcCBwYWdlIGluIHRoZSBXQUwuIFRoaXMgc2l0dWF0aW9uCisJICogc2hvdWxk IGJlIHJhcmUsIGFzIG9uLWFjY2VzcyBwcnVuaW5nIGlzIG9ubHkgYXR0ZW1wdGVkIHdoZW4KKwkg KiBwZF9wcnVuZV94aWQgaXMgdmFsaWQuCisJICovCisJaWYgKHJlYXNvbiA9PSBQUlVORV9PTl9B Q0NFU1MgJiYgIWRvX3BydW5lICYmICFkb19mcmVlemUgJiYKKwkJKCFCdWZmZXJJc0RpcnR5KHBy c3RhdGUtPmJ1ZmZlcikgfHwgWExvZ0NoZWNrQnVmZmVyTmVlZHNCYWNrdXAocHJzdGF0ZS0+YnVm ZmVyKSkpCisJeworCQlwcnN0YXRlLT5zZXRfYWxsX3Zpc2libGUgPSBmYWxzZTsKKwkJcHJzdGF0 ZS0+c2V0X2FsbF9mcm96ZW4gPSBmYWxzZTsKKwkJcmV0dXJuIGZhbHNlOworCX0KKwogCXByc3Rh dGUtPm5ld192bWJpdHMgPSBWSVNJQklMSVRZTUFQX0FMTF9WSVNJQkxFOwogCiAJaWYgKHByc3Rh dGUtPnNldF9hbGxfZnJvemVuKQpAQCAtMTE2OCw3ICsxMTkwLDcgQEAgaGVhcF9wYWdlX3BydW5l X2FuZF9mcmVlemUoUHJ1bmVGcmVlemVQYXJhbXMgKnBhcmFtcywKIAlBc3NlcnQoIXByc3RhdGUu c2V0X2FsbF9mcm96ZW4gfHwgcHJzdGF0ZS5zZXRfYWxsX3Zpc2libGUpOwogCUFzc2VydCghcHJz dGF0ZS5zZXRfYWxsX3Zpc2libGUgfHwgKHByc3RhdGUubHBkZWFkX2l0ZW1zID09IDApKTsKIAot CWRvX3NldF92bSA9IGhlYXBfcGFnZV93aWxsX3NldF92bSgmcHJzdGF0ZSwgcGFyYW1zLT5yZWFz b24pOworCWRvX3NldF92bSA9IGhlYXBfcGFnZV93aWxsX3NldF92bSgmcHJzdGF0ZSwgcGFyYW1z LT5yZWFzb24sIGRvX3BydW5lLCBkb19mcmVlemUpOwogCiAJLyoKIAkgKiBuZXdfdm1iaXRzIHNo b3VsZCBiZSAwIHJlZ2FyZGxlc3Mgb2Ygd2hldGhlciBvciBub3QgdGhlIHBhZ2UgaXMKZGlmZiAt LWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYyBiL3NyYy9iYWNrZW5k L2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYwppbmRleCA0NjFmZGY0ZWQ4My4uMzdkYmE0Y2IzZWMg MTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYworKysgYi9z cmMvYmFja2VuZC9hY2Nlc3MvaGVhcC92YWN1dW1sYXp5LmMKQEAgLTIwMzMsNyArMjAzMyw3IEBA IGxhenlfc2Nhbl9wcnVuZShMVlJlbFN0YXRlICp2YWNyZWwsCiAJCS5idWZmZXIgPSBidWYsCiAJ CS52bWJ1ZmZlciA9IHZtYnVmZmVyLAogCQkucmVhc29uID0gUFJVTkVfVkFDVVVNX1NDQU4sCi0J CS5vcHRpb25zID0gSEVBUF9QQUdFX1BSVU5FX0ZSRUVaRSwKKwkJLm9wdGlvbnMgPSBIRUFQX1BB R0VfUFJVTkVfRlJFRVpFIHwgSEVBUF9QQUdFX1BSVU5FX1NFVF9WTSwKIAkJLnZpc3Rlc3QgPSB2 YWNyZWwtPnZpc3Rlc3QsCiAJCS5jdXRvZmZzID0gJnZhY3JlbC0+Y3V0b2ZmcywKIAl9OwpkaWZm IC0tZ2l0IGEvc3JjL2luY2x1ZGUvYWNjZXNzL2hlYXBhbS5oIGIvc3JjL2luY2x1ZGUvYWNjZXNz L2hlYXBhbS5oCmluZGV4IGUzMmYyOGQ3YWNiLi43OGM4NTUzNmQzOSAxMDA2NDQKLS0tIGEvc3Jj L2luY2x1ZGUvYWNjZXNzL2hlYXBhbS5oCisrKyBiL3NyYy9pbmNsdWRlL2FjY2Vzcy9oZWFwYW0u aApAQCAtNDMsNiArNDMsNyBAQAogI2RlZmluZSBIRUFQX1BBR0VfUFJVTkVfTUFSS19VTlVTRURf Tk9XCQkoMSA8PCAwKQogI2RlZmluZSBIRUFQX1BBR0VfUFJVTkVfRlJFRVpFCQkJCSgxIDw8IDEp CiAjZGVmaW5lIEhFQVBfUEFHRV9QUlVORV9BTExPV19GQVNUX1BBVEgJCSgxIDw8IDIpCisjZGVm aW5lIEhFQVBfUEFHRV9QUlVORV9TRVRfVk0JCQkJKDEgPDwgMykKIAogdHlwZWRlZiBzdHJ1Y3Qg QnVsa0luc2VydFN0YXRlRGF0YSAqQnVsa0luc2VydFN0YXRlOwogdHlwZWRlZiBzdHJ1Y3QgR2xv YmFsVmlzU3RhdGUgR2xvYmFsVmlzU3RhdGU7CkBAIC05NSw3ICs5NiwxMiBAQCB0eXBlZGVmIHN0 cnVjdCBIZWFwU2NhbkRlc2NEYXRhCiAJICovCiAJUGFyYWxsZWxCbG9ja1RhYmxlU2Nhbldvcmtl ckRhdGEgKnJzX3BhcmFsbGVsd29ya2VyZGF0YTsKIAotCS8qIEN1cnJlbnQgaGVhcCBibG9jaydz IGNvcnJlc3BvbmRpbmcgcGFnZSBpbiB0aGUgdmlzaWJpbGl0eSBtYXAgKi8KKwkvKgorCSAqIEZv ciBzZXF1ZW50aWFsIHNjYW5zLCBiaXRtYXAgaGVhcCBzY2FucywgVElEIHJhbmdlIHNjYW5zLCBh bmQgc2FtcGxlCisJICogc2NhbnMuIFRoZSBjdXJyZW50IGhlYXAgYmxvY2sncyBjb3JyZXNwb25k aW5nIHBhZ2UgaW4gdGhlIHZpc2liaWxpdHkKKwkgKiBtYXAuIElmIHRoZSByZWxhdGlvbiBpcyBu b3QgbW9kaWZpZWQgYnkgdGhlIHF1ZXJ5LCBvbi1hY2Nlc3MgcHJ1bmluZworCSAqIG1heSBzZXQg dGhlIFZNLgorCSAqLwogCUJ1ZmZlcgkJcnNfdm1idWZmZXI7CiAKIAkvKiB0aGVzZSBmaWVsZHMg b25seSB1c2VkIGluIHBhZ2UtYXQtYS10aW1lIG1vZGUgYW5kIGZvciBiaXRtYXAgc2NhbnMgKi8K QEAgLTEyNiw3ICsxMzIsMTEgQEAgdHlwZWRlZiBzdHJ1Y3QgSW5kZXhGZXRjaEhlYXBEYXRhCiAJ ICovCiAJQnVmZmVyCQl4c19jYnVmOwogCi0JLyogQ3VycmVudCBoZWFwIGJsb2NrJ3MgY29ycmVz cG9uZGluZyBwYWdlIGluIHRoZSB2aXNpYmlsaXR5IG1hcCAqLworCS8qCisJICogQ3VycmVudCBo ZWFwIGJsb2NrJ3MgY29ycmVzcG9uZGluZyBwYWdlIGluIHRoZSB2aXNpYmlsaXR5IG1hcC4gRm9y CisJICogaW5kZXggc2NhbnMgdGhhdCBkbyBub3QgbW9kaWZ5IHRoZSB1bmRlcmx5aW5nIGhlYXAg dGFibGUsIG9uLWFjY2VzcworCSAqIHBydW5pbmcgbWF5IHNldCB0aGUgVk0gb24tYWNjZXNzLgor CSAqLwogCUJ1ZmZlcgkJeHNfdm1idWZmZXI7CiB9IEluZGV4RmV0Y2hIZWFwRGF0YTsKIApAQCAt NDMxLDcgKzQ0MSw3IEBAIGV4dGVybiBUcmFuc2FjdGlvbklkIGhlYXBfaW5kZXhfZGVsZXRlX3R1 cGxlcyhSZWxhdGlvbiByZWwsCiAKIC8qIGluIGhlYXAvcHJ1bmVoZWFwLmMgKi8KIGV4dGVybiB2 b2lkIGhlYXBfcGFnZV9wcnVuZV9vcHQoUmVsYXRpb24gcmVsYXRpb24sIEJ1ZmZlciBidWZmZXIs Ci0JCQkJCQkJCUJ1ZmZlciAqdm1idWZmZXIpOworCQkJCQkJCQlCdWZmZXIgKnZtYnVmZmVyLCBi b29sIHJlbF9yZWFkX29ubHkpOwogZXh0ZXJuIHZvaWQgaGVhcF9wYWdlX3BydW5lX2FuZF9mcmVl emUoUHJ1bmVGcmVlemVQYXJhbXMgKnBhcmFtcywKIAkJCQkJCQkJCSAgIFBydW5lRnJlZXplUmVz dWx0ICpwcmVzdWx0LAogCQkJCQkJCQkJICAgT2Zmc2V0TnVtYmVyICpvZmZfbG9jLAotLSAKMi40 My4wCgo= --00000000000060fd69064d6b968a Content-Type: text/x-patch; charset="UTF-8"; name="v41-0012-Set-pd_prune_xid-on-insert.patch" Content-Disposition: attachment; filename="v41-0012-Set-pd_prune_xid-on-insert.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmyah1ig11 RnJvbSA5OWM1YjE3YzQ1ZTQxMzY4MDkxOWYyNjIzZmM1MjhiYjM1ODczZGM5IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBUdWUsIDI5IEp1bCAyMDI1IDE2OjEyOjU2IC0wNDAwClN1YmplY3Q6IFtQ QVRDSCB2NDEgMTIvMTJdIFNldCBwZF9wcnVuZV94aWQgb24gaW5zZXJ0Ck1JTUUtVmVyc2lvbjog MS4wCkNvbnRlbnQtVHlwZTogdGV4dC9wbGFpbjsgY2hhcnNldD1VVEYtOApDb250ZW50LVRyYW5z ZmVyLUVuY29kaW5nOiA4Yml0CgpOb3cgdGhhdCB2aXNpYmlsaXR5IG1hcCAoVk0pIHVwZGF0ZXMg Y2FuIG9jY3VyIGR1cmluZyByZWFkLW9ubHkgcXVlcmllcywKaXQgbWFrZXMgc2Vuc2UgdG8gYWxz byBzZXQgdGhlIHBhZ2XigJlzIHBkX3BydW5lX3hpZCBoaW50IGR1cmluZyBpbnNlcnRzCmFuZCBv biB0aGUgbmV3IHBhZ2UgZHVyaW5nIHVwZGF0ZXMuCgpUaGlzIGVuYWJsZXMgaGVhcF9wYWdlX3By dW5lX2FuZF9mcmVlemUoKSB0byBzZXQgdGhlIFZNIGFsbC12aXNpYmxlCmFmdGVyIGEgcGFnZSBp cyBmaWxsZWQgd2l0aCBuZXdseSBpbnNlcnRlZCB0dXBsZXMgdGhlIGZpcnN0IHRpbWUgaXQgaXMK cmVhZC4gVGhpcyBtZWFucyB0aGUgcGFnZSB3aWxsIGdldCBzZXQgYWxsLXZpc2libGUgd2hlbiBp dCBpcyBzdGlsbCBpbgpzaGFyZWQgYnVmZmVycyBhbmQgYXZvaWQgcG90ZW50aWFsIEkvTyBhbXBs aWZpY2F0aW9uIHdoZW4gdmFjdXVtIGxhdGVyCmhhcyB0byBzY2FuIHRoZSBwYWdlIGFuZCBzZXQg aXQgYWxsLXZpc2libGUuIEl0IGFsc28gZW5hYmxlcyBpbmRleC1vbmx5CnNjYW5zIG9mIG5ld2x5 IGluc2VydGVkIGRhdGEgbXVjaCBzb29uZXIuCgpUaGlzIGNoYW5nZSBhbHNvIGFkZHJlc3NlcyBh IGxvbmctc3RhbmRpbmcgbm90ZSBpbiBoZWFwX2luc2VydCgpIGFuZApoZWFwX211bHRpX2luc2Vy dCgpLCB3aGljaCBvYnNlcnZlZCB0aGF0IHNldHRpbmcgcGRfcHJ1bmVfeGlkIHdvdWxkCmhlbHAg Y2xlYW4gdXAgYWJvcnRlZCBpbnNlcnRpb25zIHNvb25lci4gV2l0aG91dCBpdCwgc3VjaCB0dXBs ZXMgbWlnaHQKbGluZ2VyIHVudGlsIFZBQ1VVTSwgd2hlcmVhcyBub3cgdGhleSBjYW4gYmUgcHJ1 bmVkIGVhcmxpZXIuCgpBdXRob3I6IE1lbGFuaWUgUGxhZ2VtYW4gPG1lbGFuaWVwbGFnZW1hbkBn bWFpbC5jb20+ClJldmlld2VkLWJ5OiBBbmRyZXMgRnJldW5kIDxhbmRyZXNAYW5hcmF6ZWwuZGU+ ClJldmlld2VkLWJ5OiBDaGFvIExpIDxsaS5ldmFuLmNoYW9AZ21haWwuY29tPgpEaXNjdXNzaW9u OiBodHRwczovL3Bvc3Rnci5lcy9tL2ZsYXQvQ0FBS1J1X1pNdzZOcGRfcW0yS00lMkJGd1EzY01P TXgxRGgzVk1ocDgtVjdTT0x4ZEs5LWclNDBtYWlsLmdtYWlsLmNvbQotLS0KIHNyYy9iYWNrZW5k L2FjY2Vzcy9oZWFwL2hlYXBhbS5jICAgICAgfCA0MCArKysrKysrKysrKysrKysrKy0tLS0tLS0t LS0KIHNyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL2hlYXBhbV94bG9nLmMgfCAxOSArKysrKysrKysr KystCiBzcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9wcnVuZWhlYXAuYyAgIHwgMTggKysrKysrLS0t LS0tCiAzIGZpbGVzIGNoYW5nZWQsIDUyIGluc2VydGlvbnMoKyksIDI1IGRlbGV0aW9ucygtKQoK ZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL2hlYXBhbS5jIGIvc3JjL2JhY2tl bmQvYWNjZXNzL2hlYXAvaGVhcGFtLmMKaW5kZXggZGJkZjY1MjFjNDIuLmJhMTFiYmMwM2E1IDEw MDY0NAotLS0gYS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9oZWFwYW0uYworKysgYi9zcmMvYmFj a2VuZC9hY2Nlc3MvaGVhcC9oZWFwYW0uYwpAQCAtMjE1Niw2ICsyMTU2LDcgQEAgaGVhcF9pbnNl cnQoUmVsYXRpb24gcmVsYXRpb24sIEhlYXBUdXBsZSB0dXAsIENvbW1hbmRJZCBjaWQsCiAJVHJh bnNhY3Rpb25JZCB4aWQgPSBHZXRDdXJyZW50VHJhbnNhY3Rpb25JZCgpOwogCUhlYXBUdXBsZQlo ZWFwdHVwOwogCUJ1ZmZlcgkJYnVmZmVyOworCVBhZ2UJCXBhZ2U7CiAJQnVmZmVyCQl2bWJ1ZmZl ciA9IEludmFsaWRCdWZmZXI7CiAJYm9vbAkJYWxsX3Zpc2libGVfY2xlYXJlZCA9IGZhbHNlOwog CkBAIC0yMTgyLDYgKzIxODMsOCBAQCBoZWFwX2luc2VydChSZWxhdGlvbiByZWxhdGlvbiwgSGVh cFR1cGxlIHR1cCwgQ29tbWFuZElkIGNpZCwKIAkJCQkJCQkJCSAgICZ2bWJ1ZmZlciwgTlVMTCwK IAkJCQkJCQkJCSAgIDApOwogCisJcGFnZSA9IEJ1ZmZlckdldFBhZ2UoYnVmZmVyKTsKKwogCS8q CiAJICogV2UncmUgYWJvdXQgdG8gZG8gdGhlIGFjdHVhbCBpbnNlcnQgLS0gYnV0IGNoZWNrIGZv ciBjb25mbGljdCBmaXJzdCwgdG8KIAkgKiBhdm9pZCBwb3NzaWJseSBoYXZpbmcgdG8gcm9sbCBi YWNrIHdvcmsgd2UndmUganVzdCBkb25lLgpAQCAtMjIwNSwyNSArMjIwOCwzMCBAQCBoZWFwX2lu c2VydChSZWxhdGlvbiByZWxhdGlvbiwgSGVhcFR1cGxlIHR1cCwgQ29tbWFuZElkIGNpZCwKIAlS ZWxhdGlvblB1dEhlYXBUdXBsZShyZWxhdGlvbiwgYnVmZmVyLCBoZWFwdHVwLAogCQkJCQkJIChv cHRpb25zICYgSEVBUF9JTlNFUlRfU1BFQ1VMQVRJVkUpICE9IDApOwogCi0JaWYgKFBhZ2VJc0Fs bFZpc2libGUoQnVmZmVyR2V0UGFnZShidWZmZXIpKSkKKwlpZiAoUGFnZUlzQWxsVmlzaWJsZShw YWdlKSkKIAl7CiAJCWFsbF92aXNpYmxlX2NsZWFyZWQgPSB0cnVlOwotCQlQYWdlQ2xlYXJBbGxW aXNpYmxlKEJ1ZmZlckdldFBhZ2UoYnVmZmVyKSk7CisJCVBhZ2VDbGVhckFsbFZpc2libGUocGFn ZSk7CiAJCXZpc2liaWxpdHltYXBfY2xlYXIocmVsYXRpb24sCiAJCQkJCQkJSXRlbVBvaW50ZXJH ZXRCbG9ja051bWJlcigmKGhlYXB0dXAtPnRfc2VsZikpLAogCQkJCQkJCXZtYnVmZmVyLCBWSVNJ QklMSVRZTUFQX1ZBTElEX0JJVFMpOwogCX0KIAogCS8qCi0JICogWFhYIFNob3VsZCB3ZSBzZXQg UGFnZVNldFBydW5hYmxlIG9uIHRoaXMgcGFnZSA/CisJICogU2V0IHBkX3BydW5lX3hpZCB0byB0 cmlnZ2VyIGhlYXBfcGFnZV9wcnVuZV9hbmRfZnJlZXplKCkgb25jZSB0aGUgcGFnZQorCSAqIGlz IGZ1bGwgc28gdGhhdCB3ZSBjYW4gc2V0IHRoZSBwYWdlIGFsbC12aXNpYmxlIGluIHRoZSBWTSBv biB0aGUgbmV4dAorCSAqIHBhZ2UgYWNjZXNzLgogCSAqCi0JICogVGhlIGluc2VydGluZyB0cmFu c2FjdGlvbiBtYXkgZXZlbnR1YWxseSBhYm9ydCB0aHVzIG1ha2luZyB0aGlzIHR1cGxlCi0JICog REVBRCBhbmQgaGVuY2UgYXZhaWxhYmxlIGZvciBwcnVuaW5nLiBUaG91Z2ggd2UgZG9uJ3Qgd2Fu dCB0byBvcHRpbWl6ZQotCSAqIGZvciBhYm9ydHMsIGlmIG5vIG90aGVyIHR1cGxlIGluIHRoaXMg cGFnZSBpcyBVUERBVEVkL0RFTEVURWQsIHRoZQotCSAqIGFib3J0ZWQgdHVwbGUgd2lsbCBuZXZl ciBiZSBwcnVuZWQgdW50aWwgbmV4dCB2YWN1dW0gaXMgdHJpZ2dlcmVkLgorCSAqIFNldHRpbmcg cGRfcHJ1bmVfeGlkIGlzIGFsc28gaGFuZHkgaWYgdGhlIGluc2VydGluZyB0cmFuc2FjdGlvbgor CSAqIGV2ZW50dWFsbHkgYWJvcnRzIG1ha2luZyB0aGlzIHR1cGxlIERFQUQgYW5kIGhlbmNlIGF2 YWlsYWJsZSBmb3IKKwkgKiBwcnVuaW5nLiBJZiBubyBvdGhlciB0dXBsZSBpbiB0aGlzIHBhZ2Ug aXMgVVBEQVRFZC9ERUxFVEVkLCB0aGUgYWJvcnRlZAorCSAqIHR1cGxlIHdvdWxkIG5ldmVyIG90 aGVyd2lzZSBiZSBwcnVuZWQgdW50aWwgbmV4dCB2YWN1dW0gaXMgdHJpZ2dlcmVkLgogCSAqCi0J ICogSWYgeW91IGRvIGFkZCBQYWdlU2V0UHJ1bmFibGUgaGVyZSwgYWRkIGl0IGluIGhlYXBfeGxv Z19pbnNlcnQgdG9vLgorCSAqIERvbid0IHNldCBpdCBpZiB3ZSBhcmUgaW4gYm9vdHN0cmFwIG1v ZGUgb3Igd2UgYXJlIGluc2VydGluZyBhIGZyb3plbgorCSAqIHR1cGxlLCBhcyB0aGVyZSBpcyBu byBmdXJ0aGVyIHBydW5pbmcvZnJlZXppbmcgbmVlZGVkIGluIHRob3NlIGNhc2VzLgogCSAqLwor CWlmIChUcmFuc2FjdGlvbklkSXNOb3JtYWwoeGlkKSAmJiAhKG9wdGlvbnMgJiBIRUFQX0lOU0VS VF9GUk9aRU4pKQorCQlQYWdlU2V0UHJ1bmFibGUocGFnZSwgeGlkKTsKIAogCU1hcmtCdWZmZXJE aXJ0eShidWZmZXIpOwogCkBAIC0yMjMzLDcgKzIyNDEsNiBAQCBoZWFwX2luc2VydChSZWxhdGlv biByZWxhdGlvbiwgSGVhcFR1cGxlIHR1cCwgQ29tbWFuZElkIGNpZCwKIAkJeGxfaGVhcF9pbnNl cnQgeGxyZWM7CiAJCXhsX2hlYXBfaGVhZGVyIHhsaGRyOwogCQlYTG9nUmVjUHRyCXJlY3B0cjsK LQkJUGFnZQkJcGFnZSA9IEJ1ZmZlckdldFBhZ2UoYnVmZmVyKTsKIAkJdWludDgJCWluZm8gPSBY TE9HX0hFQVBfSU5TRVJUOwogCQlpbnQJCQlidWZmbGFncyA9IDA7CiAKQEAgLTI1OTgsOCArMjYw NSwxMyBAQCBoZWFwX211bHRpX2luc2VydChSZWxhdGlvbiByZWxhdGlvbiwgVHVwbGVUYWJsZVNs b3QgKipzbG90cywgaW50IG50dXBsZXMsCiAJCX0KIAogCQkvKgotCQkgKiBYWFggU2hvdWxkIHdl IHNldCBQYWdlU2V0UHJ1bmFibGUgb24gdGhpcyBwYWdlID8gU2VlIGhlYXBfaW5zZXJ0KCkKKwkJ ICogU2V0IHBkX3BydW5lX3hpZC4gU2VlIGhlYXBfaW5zZXJ0KCkgZm9yIG1vcmUgb24gd2h5IHdl IGRvIHRoaXMgd2hlbgorCQkgKiBpbnNlcnRpbmcgdHVwbGVzLiBUaGlzIG9ubHkgbWFrZXMgc2Vu c2UgaWYgd2UgYXJlbid0IGFscmVhZHkKKwkJICogc2V0dGluZyB0aGUgcGFnZSBmcm96ZW4gaW4g dGhlIFZNLiBXZSBhbHNvIGRvbid0IHNldCBpdCBpbgorCQkgKiBib290c3RyYXAgbW9kZS4KIAkJ ICovCisJCWlmICghYWxsX2Zyb3plbl9zZXQgJiYgVHJhbnNhY3Rpb25JZElzTm9ybWFsKHhpZCkp CisJCQlQYWdlU2V0UHJ1bmFibGUocGFnZSwgeGlkKTsKIAogCQlNYXJrQnVmZmVyRGlydHkoYnVm ZmVyKTsKIApAQCAtNDE0MSwxMiArNDE1MywxMiBAQCBsMjoKIAkgKiB0aGUgc3Vic2VxdWVudCBw YWdlIHBydW5pbmcgd2lsbCBiZSBhIG5vLW9wIGFuZCB0aGUgaGludCB3aWxsIGJlCiAJICogY2xl YXJlZC4KIAkgKgotCSAqIFhYWCBTaG91bGQgd2Ugc2V0IGhpbnQgb24gbmV3YnVmIGFzIHdlbGw/ ICBJZiB0aGUgdHJhbnNhY3Rpb24gYWJvcnRzLAotCSAqIHRoZXJlIHdvdWxkIGJlIGEgcHJ1bmFi bGUgdHVwbGUgaW4gdGhlIG5ld2J1ZjsgYnV0IGZvciBub3cgd2UgY2hvb3NlCi0JICogbm90IHRv IG9wdGltaXplIGZvciBhYm9ydHMuICBOb3RlIHRoYXQgaGVhcF94bG9nX3VwZGF0ZSBtdXN0IGJl IGtlcHQgaW4KLQkgKiBzeW5jIGlmIHRoaXMgZGVjaXNpb24gY2hhbmdlcy4KKwkgKiBXZSBzZXQg dGhlIG5ldyBwYWdlIHBydW5hYmxlIGFzIHdlbGwuIFNlZSBoZWFwX2luc2VydCgpIGZvciBtb3Jl IG9uIHdoeQorCSAqIHdlIGRvIHRoaXMgd2hlbiBpbnNlcnRpbmcgdHVwbGVzLgogCSAqLwogCVBh Z2VTZXRQcnVuYWJsZShwYWdlLCB4aWQpOworCWlmIChuZXdidWYgIT0gYnVmZmVyKQorCQlQYWdl U2V0UHJ1bmFibGUobmV3cGFnZSwgeGlkKTsKIAogCWlmICh1c2VfaG90X3VwZGF0ZSkKIAl7CmRp ZmYgLS1naXQgYS9zcmMvYmFja2VuZC9hY2Nlc3MvaGVhcC9oZWFwYW1feGxvZy5jIGIvc3JjL2Jh Y2tlbmQvYWNjZXNzL2hlYXAvaGVhcGFtX3hsb2cuYwppbmRleCAxMzAyYmIxM2UxOC4uZjNmNDE5 ZDNkYzEgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL2FjY2Vzcy9oZWFwL2hlYXBhbV94bG9nLmMK KysrIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvaGVhcGFtX3hsb2cuYwpAQCAtNDUwLDYgKzQ1 MCwxNCBAQCBoZWFwX3hsb2dfaW5zZXJ0KFhMb2dSZWFkZXJTdGF0ZSAqcmVjb3JkKQogCiAJCWZy ZWVzcGFjZSA9IFBhZ2VHZXRIZWFwRnJlZVNwYWNlKHBhZ2UpOyAvKiBuZWVkZWQgdG8gdXBkYXRl IEZTTSBiZWxvdyAqLwogCisJCS8qCisJCSAqIFNldCB0aGUgcGFnZSBwcnVuYWJsZSB0byB0cmln Z2VyIG9uLWFjY2VzcyBwcnVuaW5nIGxhdGVyLCB3aGljaCBtYXkKKwkJICogc2V0IHRoZSBwYWdl IGFsbC12aXNpYmxlIGluIHRoZSBWTS4gU2VlIGNvbW1lbnRzIGluIGhlYXBfaW5zZXJ0KCkuCisJ CSAqLworCQlpZiAoVHJhbnNhY3Rpb25JZElzTm9ybWFsKFhMb2dSZWNHZXRYaWQocmVjb3JkKSkg JiYKKwkJCSFIZWFwVHVwbGVIZWFkZXJYbWluRnJvemVuKGh0dXApKQorCQkJUGFnZVNldFBydW5h YmxlKHBhZ2UsIFhMb2dSZWNHZXRYaWQocmVjb3JkKSk7CisKIAkJUGFnZVNldExTTihwYWdlLCBs c24pOwogCiAJCWlmICh4bHJlYy0+ZmxhZ3MgJiBYTEhfSU5TRVJUX0FMTF9WSVNJQkxFX0NMRUFS RUQpCkBAIC01OTksMTIgKzYwNywxOSBAQCBoZWFwX3hsb2dfbXVsdGlfaW5zZXJ0KFhMb2dSZWFk ZXJTdGF0ZSAqcmVjb3JkKQogCQlpZiAoeGxyZWMtPmZsYWdzICYgWExIX0lOU0VSVF9BTExfVklT SUJMRV9DTEVBUkVEKQogCQkJUGFnZUNsZWFyQWxsVmlzaWJsZShwYWdlKTsKIAotCQkvKiBYTEhf SU5TRVJUX0FMTF9GUk9aRU5fU0VUIGltcGxpZXMgdGhhdCBhbGwgdHVwbGVzIGFyZSB2aXNpYmxl ICovCisJCS8qCisJCSAqIFhMSF9JTlNFUlRfQUxMX0ZST1pFTl9TRVQgaW1wbGllcyB0aGF0IGFs bCB0dXBsZXMgYXJlIHZpc2libGUuIElmCisJCSAqIHdlIGFyZSBub3Qgc2V0dGluZyB0aGUgcGFn ZSBmcm96ZW4sIHRoZW4gc2V0IHRoZSBwYWdlJ3MgcHJ1bmFibGUKKwkJICogaGludCBzbyB0aGF0 IHdlIHRyaWdnZXIgb24tYWNjZXNzIHBydW5pbmcgbGF0ZXIgd2hpY2ggbWF5IHNldCB0aGUKKwkJ ICogcGFnZSBhbGwtdmlzaWJsZSBpbiB0aGUgVk0uCisJCSAqLwogCQlpZiAoeGxyZWMtPmZsYWdz ICYgWExIX0lOU0VSVF9BTExfRlJPWkVOX1NFVCkKIAkJewogCQkJUGFnZVNldEFsbFZpc2libGUo cGFnZSk7CiAJCQlQYWdlQ2xlYXJQcnVuYWJsZShwYWdlKTsKIAkJfQorCQllbHNlCisJCQlQYWdl U2V0UHJ1bmFibGUocGFnZSwgWExvZ1JlY0dldFhpZChyZWNvcmQpKTsKIAogCQlNYXJrQnVmZmVy RGlydHkoYnVmZmVyKTsKIAl9CkBAIC05MjEsNiArOTM2LDggQEAgaGVhcF94bG9nX3VwZGF0ZShY TG9nUmVhZGVyU3RhdGUgKnJlY29yZCwgYm9vbCBob3RfdXBkYXRlKQogCQlmcmVlc3BhY2UgPSBQ YWdlR2V0SGVhcEZyZWVTcGFjZShucGFnZSk7CiAKIAkJUGFnZVNldExTTihucGFnZSwgbHNuKTsK KwkJLyogU2VlIGhlYXBfaW5zZXJ0KCkgZm9yIHdoeSB3ZSBzZXQgcGRfcHJ1bmVfeGlkIG9uIGlu c2VydCAqLworCQlQYWdlU2V0UHJ1bmFibGUobnBhZ2UsIFhMb2dSZWNHZXRYaWQocmVjb3JkKSk7 CiAJCU1hcmtCdWZmZXJEaXJ0eShuYnVmZmVyKTsKIAl9CiAKZGlmZiAtLWdpdCBhL3NyYy9iYWNr ZW5kL2FjY2Vzcy9oZWFwL3BydW5laGVhcC5jIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvcHJ1 bmVoZWFwLmMKaW5kZXggZGViN2I5NDhjMWUuLjlmOGM4M2FhN2QzIDEwMDY0NAotLS0gYS9zcmMv YmFja2VuZC9hY2Nlc3MvaGVhcC9wcnVuZWhlYXAuYworKysgYi9zcmMvYmFja2VuZC9hY2Nlc3Mv aGVhcC9wcnVuZWhlYXAuYwpAQCAtMjc5LDcgKzI3OSw4IEBAIGhlYXBfcGFnZV9wcnVuZV9vcHQo UmVsYXRpb24gcmVsYXRpb24sIEJ1ZmZlciBidWZmZXIsIEJ1ZmZlciAqdm1idWZmZXIsCiAJLyoK IAkgKiBGaXJzdCBjaGVjayB3aGV0aGVyIHRoZXJlJ3MgYW55IGNoYW5jZSB0aGVyZSdzIHNvbWV0 aGluZyB0byBwcnVuZSwKIAkgKiBkZXRlcm1pbmluZyB0aGUgYXBwcm9wcmlhdGUgaG9yaXpvbiBp cyBhIHdhc3RlIGlmIHRoZXJlJ3Mgbm8gcHJ1bmVfeGlkCi0JICogKGkuZS4gbm8gdXBkYXRlcy9k ZWxldGVzIGxlZnQgcG90ZW50aWFsbHkgZGVhZCB0dXBsZXMgYXJvdW5kKS4KKwkgKiAoaS5lLiBu byB1cGRhdGVzL2RlbGV0ZXMgbGVmdCBwb3RlbnRpYWxseSBkZWFkIHR1cGxlcyBhcm91bmQgYW5k IG5vCisJICogaW5zZXJ0cyBpbnNlcnRlZCBuZXcgdHVwbGVzIHRoYXQgbWF5IGJlIHZpc2libGUg dG8gYWxsKS4KIAkgKi8KIAlwcnVuZV94aWQgPSBQYWdlR2V0UHJ1bmVYaWQocGFnZSk7CiAJaWYg KCFUcmFuc2FjdGlvbklkSXNWYWxpZChwcnVuZV94aWQpKQpAQCAtMTkxOCwxNyArMTkxOSwxNCBA QCBoZWFwX3BydW5lX3JlY29yZF91bmNoYW5nZWRfbHBfbm9ybWFsKFBydW5lU3RhdGUgKnByc3Rh dGUsIE9mZnNldE51bWJlciBvZmZudW0pCiAJCQlwcnN0YXRlLT5zZXRfYWxsX3Zpc2libGUgPSBm YWxzZTsKIAkJCXByc3RhdGUtPnNldF9hbGxfZnJvemVuID0gZmFsc2U7CiAKLQkJCS8qIFRoZSBw YWdlIHNob3VsZCBub3QgYmUgbWFya2VkIGFsbC12aXNpYmxlICovCi0JCQlpZiAoUGFnZUlzQWxs VmlzaWJsZShwYWdlKSkKLQkJCQloZWFwX3BhZ2VfZml4X3ZtX2NvcnJ1cHRpb24ocHJzdGF0ZSwg b2ZmbnVtLAotCQkJCQkJCQkJCQlWTV9DT1JSVVBUX1RVUExFX1ZJU0lCSUxJVFkpOwotCiAJCQkv KgotCQkJICogSWYgd2Ugd2FudGVkIHRvIG9wdGltaXplIGZvciBhYm9ydHMsIHdlIG1pZ2h0IGNv bnNpZGVyIG1hcmtpbmcKLQkJCSAqIHRoZSBwYWdlIHBydW5hYmxlIHdoZW4gd2Ugc2VlIElOU0VS VF9JTl9QUk9HUkVTUy4gIEJ1dCB3ZQotCQkJICogZG9uJ3QuICBTZWUgcmVsYXRlZCBkZWNpc2lv bnMgYWJvdXQgd2hlbiB0byBtYXJrIHRoZSBwYWdlCi0JCQkgKiBwcnVuYWJsZSBpbiBoZWFwYW0u Yy4KKwkJCSAqIFRob3VnaCB0aGVyZSBpcyBub3RoaW5nICJwcnVuYWJsZSIgb24gdGhlIHBhZ2Us IHdlIG1haW50YWluCisJCQkgKiBwZF9wcnVuZV94aWQgZm9yIGluc2VydHMgc28gdGhhdCB3ZSBo YXZlIHRoZSBvcHBvcnR1bml0eSB0bworCQkJICogbWFyayB0aGVtIGFsbC12aXNpYmxlIGR1cmlu ZyB0aGUgbmV4dCByb3VuZCBvZiBwcnVuaW5nLgogCQkJICovCisJCQloZWFwX3BydW5lX3JlY29y ZF9wcnVuYWJsZShwcnN0YXRlLAorCQkJCQkJCQkJICAgSGVhcFR1cGxlSGVhZGVyR2V0WG1pbiho dHVwKSwKKwkJCQkJCQkJCSAgIG9mZm51bSk7CiAJCQlicmVhazsKIAogCQljYXNlIEhFQVBUVVBM RV9ERUxFVEVfSU5fUFJPR1JFU1M6Ci0tIAoyLjQzLjAKCg== --00000000000060fd69064d6b968a--