From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 47275C47E49 for ; Mon, 28 Oct 2019 20:10:47 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 0E8A121721 for ; Mon, 28 Oct 2019 20:10:47 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=ziepe.ca header.i=@ziepe.ca header.b="S58t6Ohp" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727503AbfJ1UKq (ORCPT ); Mon, 28 Oct 2019 16:10:46 -0400 Received: from mail-qk1-f193.google.com ([209.85.222.193]:40292 "EHLO mail-qk1-f193.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726483AbfJ1UKq (ORCPT ); Mon, 28 Oct 2019 16:10:46 -0400 Received: by mail-qk1-f193.google.com with SMTP id y81so9744492qkb.7 for ; Mon, 28 Oct 2019 13:10:44 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ziepe.ca; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=H6qkKhlE377yexDDU3hhVTFW0t+EXROxR6aal9KdQe4=; b=S58t6OhprBE5qw20UbAe+Vwse+w2lO/Up0h0lfqdRge/4nS1rXcCCsxlIno+C6MBwn eJxkhgL2L64qgxBPmUhWD6RFK5kf5e0ZelEdKRYLUIxrkTpbhVFOlRF9uwIgGHYVhyZn p43djgWgjcRWx88FI7pDFwEqr3ezye3qfqni5fPI5bTAKCKpVObL1YPw8nHvp+t0PDWo 8uNkbZbvEJJD1KQQGq6PO27jpJTe9bYV5khfvnCnHC1ClOhSnanJvpp5MF0tRIO9Gzbt bgIWXRYWbjzPF2+LqBI2sTQC4L5/nUfSvol6+joXWujgAwYghBBxAzRmxevNYuzjif4u swxA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=H6qkKhlE377yexDDU3hhVTFW0t+EXROxR6aal9KdQe4=; b=gSxI0+G/rOaY8OR1YZbpI6ENwBkL9Bt3+hw5iqruEG19EI8bHKz9WQW9GPndoeAPvV 76rFFqFWbIErVsgy9qObySDCV7G7VNBOUtjXr3yoqv0OdOZfKLah459Bwwwbigz0Sk4F 9XiV9kPppEIarbRl6Y42V7vQRuo7m8fy/ykVEZBG/SLWvxlIiV80/7PEuUWwK3WPKwSW 2sZ1O6BntGzkl6nD15uWyFFMHcn9SNl1pcuSumMG7qWNbg28BKXhNRNVaNwEVPeMOxzo 498WekRymswPccDaBJd4S6qr0Oy6pTq8ZuP64jmPKb56MJ8nF3h1UbOR7TKewe7DtbKF VtlQ== X-Gm-Message-State: APjAAAVHCRWjTvL68t2XuB+B9FO6F9GuAdKU8ZAC8sJV1VPWO4FiBIAr x/0zwgJ/BPacsNIDwEnZ0YbODw== X-Google-Smtp-Source: APXvYqwcJctJ4wjkPX/iRBrM71GSQB516ozrtr/cgoYC3wlErfDwUG/hWnwhh/5dQ5u5+5Pie/tT7A== X-Received: by 2002:a37:7c42:: with SMTP id x63mr13834494qkc.134.1572293444160; Mon, 28 Oct 2019 13:10:44 -0700 (PDT) Received: from ziepe.ca (hlfxns017vw-142-162-113-180.dhcp-dynamic.fibreop.ns.bellaliant.net. [142.162.113.180]) by smtp.gmail.com with ESMTPSA id t65sm6325908qkh.23.2019.10.28.13.10.43 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Mon, 28 Oct 2019 13:10:44 -0700 (PDT) Received: from jgg by mlx.ziepe.ca with local (Exim 4.90_1) (envelope-from ) id 1iPBLf-0001gA-4C; Mon, 28 Oct 2019 17:10:43 -0300 From: Jason Gunthorpe To: linux-mm@kvack.org, Jerome Glisse , Ralph Campbell , John Hubbard , Felix.Kuehling@amd.com Cc: linux-rdma@vger.kernel.org, dri-devel@lists.freedesktop.org, amd-gfx@lists.freedesktop.org, Alex Deucher , Ben Skeggs , Boris Ostrovsky , =?UTF-8?q?Christian=20K=C3=B6nig?= , David Zhou , Dennis Dalessandro , Juergen Gross , Mike Marciniszyn , Oleksandr Andrushchenko , Petr Cvek , Stefano Stabellini , nouveau@lists.freedesktop.org, xen-devel@lists.xenproject.org, Christoph Hellwig , Jason Gunthorpe , Andrea Arcangeli , Michal Hocko Subject: [PATCH v2 02/15] mm/mmu_notifier: add an interval tree notifier Date: Mon, 28 Oct 2019 17:10:19 -0300 Message-Id: <20191028201032.6352-3-jgg@ziepe.ca> X-Mailer: git-send-email 2.23.0 In-Reply-To: <20191028201032.6352-1-jgg@ziepe.ca> References: <20191028201032.6352-1-jgg@ziepe.ca> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-rdma-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-rdma@vger.kernel.org From: Jason Gunthorpe Of the 13 users of mmu_notifiers, 8 of them use only invalidate_range_start/end() and immediately intersect the mmu_notifier_range with some kind of internal list of VAs. 4 use an interval tree (i915_gem, radeon_mn, umem_odp, hfi1). 4 use a linked list of some kind (scif_dma, vhost, gntdev, hmm) And the remaining 5 either don't use invalidate_range_start() or do some special thing with it. It turns out that building a correct scheme with an interval tree is pretty complicated, particularly if the use case is synchronizing against another thread doing get_user_pages(). Many of these implementations have various subtle and difficult to fix races. This approach puts the interval tree as common code at the top of the mmu notifier call tree and implements a shareable locking scheme. It includes: - An interval tree tracking VA ranges, with per-range callbacks - A read/write locking scheme for the interval tree that avoids sleeping in the notifier path (for OOM killer) - A sequence counter based collision-retry locking scheme to tell device page fault that a VA range is being concurrently invalidated. This is based on various ideas: - hmm accumulates invalidated VA ranges and releases them when all invalidates are done, via active_invalidate_ranges count. This approach avoids having to intersect the interval tree twice (as umem_odp does) at the potential cost of a longer device page fault. - kvm/umem_odp use a sequence counter to drive the collision retry, via invalidate_seq - a deferred work todo list on unlock scheme like RTNL, via deferred_list. This makes adding/removing interval tree members more deterministic - seqlock, except this version makes the seqlock idea multi-holder on the write side by protecting it with active_invalidate_ranges and a spinlock To minimize MM overhead when only the interval tree is being used, the entire SRCU and hlist overheads are dropped using some simple branches. Similarly the interval tree overhead is dropped when in hlist mode. The overhead from the mandatory spinlock is broadly the same as most of existing users which already had a lock (or two) of some sort on the invalidation path. Cc: Andrea Arcangeli Cc: Michal Hocko Acked-by: Christian König Signed-off-by: Jason Gunthorpe --- include/linux/mmu_notifier.h | 98 +++++++ mm/Kconfig | 1 + mm/mmu_notifier.c | 533 +++++++++++++++++++++++++++++++++-- 3 files changed, 607 insertions(+), 25 deletions(-) diff --git a/include/linux/mmu_notifier.h b/include/linux/mmu_notifier.h index 12bd603d318ce7..51b92ba013ddce 100644 --- a/include/linux/mmu_notifier.h +++ b/include/linux/mmu_notifier.h @@ -6,10 +6,12 @@ #include #include #include +#include struct mmu_notifier_mm; struct mmu_notifier; struct mmu_notifier_range; +struct mmu_range_notifier; /** * enum mmu_notifier_event - reason for the mmu notifier callback @@ -32,6 +34,9 @@ struct mmu_notifier_range; * access flags). User should soft dirty the page in the end callback to make * sure that anyone relying on soft dirtyness catch pages that might be written * through non CPU mappings. + * + * @MMU_NOTIFY_RELEASE: used during mmu_range_notifier invalidate to signal that + * the mm refcount is zero and the range is no longer accessible. */ enum mmu_notifier_event { MMU_NOTIFY_UNMAP = 0, @@ -39,6 +44,7 @@ enum mmu_notifier_event { MMU_NOTIFY_PROTECTION_VMA, MMU_NOTIFY_PROTECTION_PAGE, MMU_NOTIFY_SOFT_DIRTY, + MMU_NOTIFY_RELEASE, }; #define MMU_NOTIFIER_RANGE_BLOCKABLE (1 << 0) @@ -222,6 +228,26 @@ struct mmu_notifier { unsigned int users; }; +/** + * struct mmu_range_notifier_ops + * @invalidate: Upon return the caller must stop using any SPTEs within this + * range, this function can sleep. Return false if blocking was + * required but range is non-blocking + */ +struct mmu_range_notifier_ops { + bool (*invalidate)(struct mmu_range_notifier *mrn, + const struct mmu_notifier_range *range, + unsigned long cur_seq); +}; + +struct mmu_range_notifier { + struct interval_tree_node interval_tree; + const struct mmu_range_notifier_ops *ops; + struct hlist_node deferred_item; + unsigned long invalidate_seq; + struct mm_struct *mm; +}; + #ifdef CONFIG_MMU_NOTIFIER #ifdef CONFIG_LOCKDEP @@ -263,6 +289,78 @@ extern int __mmu_notifier_register(struct mmu_notifier *mn, struct mm_struct *mm); extern void mmu_notifier_unregister(struct mmu_notifier *mn, struct mm_struct *mm); + +unsigned long mmu_range_read_begin(struct mmu_range_notifier *mrn); +int mmu_range_notifier_insert(struct mmu_range_notifier *mrn, + unsigned long start, unsigned long length, + struct mm_struct *mm); +int mmu_range_notifier_insert_locked(struct mmu_range_notifier *mrn, + unsigned long start, unsigned long length, + struct mm_struct *mm); +void mmu_range_notifier_remove(struct mmu_range_notifier *mrn); + +/** + * mmu_range_set_seq - Save the invalidation sequence + * @mrn - The mrn passed to invalidate + * @cur_seq - The cur_seq passed to invalidate + * + * This must be called unconditionally from the invalidate callback of a + * struct mmu_range_notifier_ops under the same lock that is used to call + * mmu_range_read_retry(). It updates the sequence number for later use by + * mmu_range_read_retry(). + * + * If the user does not call mmu_range_read_begin() or mmu_range_read_retry() + * then this call is not required. + */ +static inline void mmu_range_set_seq(struct mmu_range_notifier *mrn, + unsigned long cur_seq) +{ + WRITE_ONCE(mrn->invalidate_seq, cur_seq); +} + +/** + * mmu_range_read_retry - End a read side critical section against a VA range + * mrn: The range under lock + * seq: The return of the paired mmu_range_read_begin() + * + * This MUST be called under a user provided lock that is also held + * unconditionally by op->invalidate() when it calls mmu_range_set_seq(). + * + * Each call should be paired with a single mmu_range_read_begin() and + * should be used to conclude the read side. + * + * Returns true if an invalidation collided with this critical section, and + * the caller should retry. + */ +static inline bool mmu_range_read_retry(struct mmu_range_notifier *mrn, + unsigned long seq) +{ + return mrn->invalidate_seq != seq; +} + +/** + * mmu_range_check_retry - Test if a collision has occurred + * mrn: The range under lock + * seq: The return of the matching mmu_range_read_begin() + * + * This can be used in the critical section between mmu_range_read_begin() and + * mmu_range_read_retry(). A return of true indicates an invalidation has + * collided with this lock and a future mmu_range_read_retry() will return + * true. + * + * False is not reliable and only suggests a collision has not happened. It + * can be called many times and does not have to hold the user provided lock. + * + * This call can be used as part of loops and other expensive operations to + * expedite a retry. + */ +static inline bool mmu_range_check_retry(struct mmu_range_notifier *mrn, + unsigned long seq) +{ + /* Pairs with the WRITE_ONCE in mmu_range_set_seq() */ + return READ_ONCE(mrn->invalidate_seq) != seq; +} + extern void __mmu_notifier_mm_destroy(struct mm_struct *mm); extern void __mmu_notifier_release(struct mm_struct *mm); extern int __mmu_notifier_clear_flush_young(struct mm_struct *mm, diff --git a/mm/Kconfig b/mm/Kconfig index a5dae9a7eb510a..d0b5046d9aeffd 100644 --- a/mm/Kconfig +++ b/mm/Kconfig @@ -284,6 +284,7 @@ config VIRT_TO_BUS config MMU_NOTIFIER bool select SRCU + select INTERVAL_TREE config KSM bool "Enable KSM for page merging" diff --git a/mm/mmu_notifier.c b/mm/mmu_notifier.c index 367670cfd02b7b..d02d3c8c223eb7 100644 --- a/mm/mmu_notifier.c +++ b/mm/mmu_notifier.c @@ -12,6 +12,7 @@ #include #include #include +#include #include #include #include @@ -36,10 +37,243 @@ struct lockdep_map __mmu_notifier_invalidate_range_start_map = { struct mmu_notifier_mm { /* all mmu notifiers registered in this mm are queued in this list */ struct hlist_head list; + bool has_interval; /* to serialize the list modifications and hlist_unhashed */ spinlock_t lock; + unsigned long invalidate_seq; + unsigned long active_invalidate_ranges; + struct rb_root_cached itree; + wait_queue_head_t wq; + struct hlist_head deferred_list; }; +/* + * This is a collision-retry read-side/write-side 'lock', a lot like a + * seqcount, however this allows multiple write-sides to hold it at + * once. Conceptually the write side is protecting the values of the PTEs in + * this mm, such that PTES cannot be read into SPTEs while any writer exists. + * + * Note that the core mm creates nested invalidate_range_start()/end() regions + * within the same thread, and runs invalidate_range_start()/end() in parallel + * on multiple CPUs. This is designed to not reduce concurrency or block + * progress on the mm side. + * + * As a secondary function, holding the full write side also serves to prevent + * writers for the itree, this is an optimization to avoid extra locking + * during invalidate_range_start/end notifiers. + * + * The write side has two states, fully excluded: + * - mm->active_invalidate_ranges != 0 + * - mnn->invalidate_seq & 1 == True + * - some range on the mm_struct is being invalidated + * - the itree is not allowed to change + * + * And partially excluded: + * - mm->active_invalidate_ranges != 0 + * - some range on the mm_struct is being invalidated + * - the itree is allowed to change + * + * The later state avoids some expensive work on inv_end in the common case of + * no mrn monitoring the VA. + */ +static bool mn_itree_is_invalidating(struct mmu_notifier_mm *mmn_mm) +{ + lockdep_assert_held(&mmn_mm->lock); + return mmn_mm->invalidate_seq & 1; +} + +static struct mmu_range_notifier * +mn_itree_inv_start_range(struct mmu_notifier_mm *mmn_mm, + const struct mmu_notifier_range *range, + unsigned long *seq) +{ + struct interval_tree_node *node; + struct mmu_range_notifier *res = NULL; + + spin_lock(&mmn_mm->lock); + mmn_mm->active_invalidate_ranges++; + node = interval_tree_iter_first(&mmn_mm->itree, range->start, + range->end - 1); + if (node) { + mmn_mm->invalidate_seq |= 1; + res = container_of(node, struct mmu_range_notifier, + interval_tree); + } + + *seq = mmn_mm->invalidate_seq; + spin_unlock(&mmn_mm->lock); + return res; +} + +static struct mmu_range_notifier * +mn_itree_inv_next(struct mmu_range_notifier *mrn, + const struct mmu_notifier_range *range) +{ + struct interval_tree_node *node; + + node = interval_tree_iter_next(&mrn->interval_tree, range->start, + range->end - 1); + if (!node) + return NULL; + return container_of(node, struct mmu_range_notifier, interval_tree); +} + +static void mn_itree_inv_end(struct mmu_notifier_mm *mmn_mm) +{ + struct mmu_range_notifier *mrn; + struct hlist_node *next; + bool need_wake = false; + + spin_lock(&mmn_mm->lock); + if (--mmn_mm->active_invalidate_ranges || + !mn_itree_is_invalidating(mmn_mm)) { + spin_unlock(&mmn_mm->lock); + return; + } + + mmn_mm->invalidate_seq++; + need_wake = true; + + /* + * The inv_end incorporates a deferred mechanism like + * rtnl_lock(). Adds and removes are queued until the final inv_end + * happens then they are progressed. This arrangement for tree updates + * is used to avoid using a blocking lock during + * invalidate_range_start. + */ + hlist_for_each_entry_safe(mrn, next, &mmn_mm->deferred_list, + deferred_item) { + if (RB_EMPTY_NODE(&mrn->interval_tree.rb)) + interval_tree_insert(&mrn->interval_tree, + &mmn_mm->itree); + else + interval_tree_remove(&mrn->interval_tree, + &mmn_mm->itree); + hlist_del(&mrn->deferred_item); + } + spin_unlock(&mmn_mm->lock); + + /* + * TODO: Since we already have a spinlock above, this would be faster + * as wake_up_q + */ + if (need_wake) + wake_up_all(&mmn_mm->wq); +} + +/** + * mmu_range_read_begin - Begin a read side critical section against a VA range + * mrn: The range to lock + * + * mmu_range_read_begin()/mmu_range_read_retry() implement a collision-retry + * locking scheme similar to seqcount for the VA range under mrn. If the mm + * invokes invalidation during the critical section then + * mmu_range_read_retry() will return true. + * + * This is useful to obtain shadow PTEs where teardown or setup of the SPTEs + * require a blocking context. The critical region formed by this lock can + * sleep, and the required 'user_lock' can also be a sleeping lock. + * + * The caller is required to provide a 'user_lock' to serialize both teardown + * and setup. + * + * The return value should be passed to mmu_range_read_retry(). + */ +unsigned long mmu_range_read_begin(struct mmu_range_notifier *mrn) +{ + struct mmu_notifier_mm *mmn_mm = mrn->mm->mmu_notifier_mm; + unsigned long seq; + bool is_invalidating; + + /* + * If the mrn has a different seq value under the user_lock than we + * started with then it has collided. + * + * If the mrn currently has the same seq value as the mmn_mm seq, then + * it is currently between invalidate_start/end and is colliding. + * + * The locking looks broadly like this: + * mn_tree_invalidate_start(): mmu_range_read_begin(): + * spin_lock + * seq = READ_ONCE(mrn->invalidate_seq); + * seq == mmn_mm->invalidate_seq + * spin_unlock + * spin_lock + * seq = ++mmn_mm->invalidate_seq + * spin_unlock + * op->invalidate_range(): + * user_lock + * mmu_range_set_seq() + * mrn->invalidate_seq = seq + * user_unlock + * + * [Required: mmu_range_read_retry() == true] + * + * mn_itree_inv_end(): + * spin_lock + * seq = ++mmn_mm->invalidate_seq + * spin_unlock + * + * user_lock + * mmu_range_read_retry(): + * mrn->invalidate_seq != seq + * user_unlock + * + * Barriers are not needed here as any races here are closed by an + * eventual mmu_range_read_retry(), which provides a barrier via the + * user_lock. + */ + spin_lock(&mmn_mm->lock); + /* Pairs with the WRITE_ONCE in mmu_range_set_seq() */ + seq = READ_ONCE(mrn->invalidate_seq); + is_invalidating = seq == mmn_mm->invalidate_seq; + spin_unlock(&mmn_mm->lock); + + /* + * mrn->invalidate_seq is always set to an odd value. This ensures + * that if seq does wrap we will always clear the below sleep in some + * reasonable time as mmn_mm->invalidate_seq is even in the idle + * state. + */ + lock_map_acquire(&__mmu_notifier_invalidate_range_start_map); + lock_map_release(&__mmu_notifier_invalidate_range_start_map); + if (is_invalidating) + wait_event(mmn_mm->wq, + READ_ONCE(mmn_mm->invalidate_seq) != seq); + + /* + * Notice that mmu_range_read_retry() can already be true at this + * point, avoiding loops here allows the user of this lock to provide + * a global time bound. + */ + + return seq; +} +EXPORT_SYMBOL_GPL(mmu_range_read_begin); + +static void mn_itree_release(struct mmu_notifier_mm *mmn_mm, + struct mm_struct *mm) +{ + struct mmu_notifier_range range = { + .flags = MMU_NOTIFIER_RANGE_BLOCKABLE, + .event = MMU_NOTIFY_RELEASE, + .mm = mm, + .start = 0, + .end = ULONG_MAX, + }; + struct mmu_range_notifier *mrn; + unsigned long cur_seq; + bool ret; + + for (mrn = mn_itree_inv_start_range(mmn_mm, &range, &cur_seq); mrn; + mrn = mn_itree_inv_next(mrn, &range)) { + ret = mrn->ops->invalidate(mrn, &range, cur_seq); + WARN_ON(!ret); + } + + mn_itree_inv_end(mmn_mm); +} + /* * This function can't run concurrently against mmu_notifier_register * because mm->mm_users > 0 during mmu_notifier_register and exit_mmap @@ -52,17 +286,24 @@ struct mmu_notifier_mm { * can't go away from under us as exit_mmap holds an mm_count pin * itself. */ -void __mmu_notifier_release(struct mm_struct *mm) +static void mn_hlist_release(struct mmu_notifier_mm *mmn_mm, + struct mm_struct *mm) { struct mmu_notifier *mn; int id; + if (mmn_mm->has_interval) + mn_itree_release(mmn_mm, mm); + + if (hlist_empty(&mmn_mm->list)) + return; + /* * SRCU here will block mmu_notifier_unregister until * ->release returns. */ id = srcu_read_lock(&srcu); - hlist_for_each_entry_rcu(mn, &mm->mmu_notifier_mm->list, hlist) + hlist_for_each_entry_rcu(mn, &mmn_mm->list, hlist) /* * If ->release runs before mmu_notifier_unregister it must be * handled, as it's the only way for the driver to flush all @@ -72,9 +313,9 @@ void __mmu_notifier_release(struct mm_struct *mm) if (mn->ops->release) mn->ops->release(mn, mm); - spin_lock(&mm->mmu_notifier_mm->lock); - while (unlikely(!hlist_empty(&mm->mmu_notifier_mm->list))) { - mn = hlist_entry(mm->mmu_notifier_mm->list.first, + spin_lock(&mmn_mm->lock); + while (unlikely(!hlist_empty(&mmn_mm->list))) { + mn = hlist_entry(mmn_mm->list.first, struct mmu_notifier, hlist); /* @@ -85,7 +326,7 @@ void __mmu_notifier_release(struct mm_struct *mm) */ hlist_del_init_rcu(&mn->hlist); } - spin_unlock(&mm->mmu_notifier_mm->lock); + spin_unlock(&mmn_mm->lock); srcu_read_unlock(&srcu, id); /* @@ -100,6 +341,17 @@ void __mmu_notifier_release(struct mm_struct *mm) synchronize_srcu(&srcu); } +void __mmu_notifier_release(struct mm_struct *mm) +{ + struct mmu_notifier_mm *mmn_mm = mm->mmu_notifier_mm; + + if (mmn_mm->has_interval) + mn_itree_release(mmn_mm, mm); + + if (!hlist_empty(&mmn_mm->list)) + mn_hlist_release(mmn_mm, mm); +} + /* * If no young bitflag is supported by the hardware, ->clear_flush_young can * unmap the address and return 1 or 0 depending if the mapping previously @@ -172,14 +424,43 @@ void __mmu_notifier_change_pte(struct mm_struct *mm, unsigned long address, srcu_read_unlock(&srcu, id); } -int __mmu_notifier_invalidate_range_start(struct mmu_notifier_range *range) +static int mn_itree_invalidate(struct mmu_notifier_mm *mmn_mm, + const struct mmu_notifier_range *range) +{ + struct mmu_range_notifier *mrn; + unsigned long cur_seq; + + for (mrn = mn_itree_inv_start_range(mmn_mm, range, &cur_seq); mrn; + mrn = mn_itree_inv_next(mrn, range)) { + bool ret; + + ret = mrn->ops->invalidate(mrn, range, cur_seq); + if (!ret) { + if (WARN_ON(mmu_notifier_range_blockable(range))) + continue; + goto out_would_block; + } + } + return 0; + +out_would_block: + /* + * On -EAGAIN the non-blocking caller is not allowed to call + * invalidate_range_end() + */ + mn_itree_inv_end(mmn_mm); + return -EAGAIN; +} + +static int mn_hlist_invalidate_range_start(struct mmu_notifier_mm *mmn_mm, + struct mmu_notifier_range *range) { struct mmu_notifier *mn; int ret = 0; int id; id = srcu_read_lock(&srcu); - hlist_for_each_entry_rcu(mn, &range->mm->mmu_notifier_mm->list, hlist) { + hlist_for_each_entry_rcu(mn, &mmn_mm->list, hlist) { if (mn->ops->invalidate_range_start) { int _ret; @@ -203,15 +484,30 @@ int __mmu_notifier_invalidate_range_start(struct mmu_notifier_range *range) return ret; } -void __mmu_notifier_invalidate_range_end(struct mmu_notifier_range *range, - bool only_end) +int __mmu_notifier_invalidate_range_start(struct mmu_notifier_range *range) +{ + struct mmu_notifier_mm *mmn_mm = range->mm->mmu_notifier_mm; + int ret = 0; + + if (mmn_mm->has_interval) { + ret = mn_itree_invalidate(mmn_mm, range); + if (ret) + return ret; + } + if (!hlist_empty(&mmn_mm->list)) + return mn_hlist_invalidate_range_start(mmn_mm, range); + return 0; +} + +static void mn_hlist_invalidate_end(struct mmu_notifier_mm *mmn_mm, + struct mmu_notifier_range *range, + bool only_end) { struct mmu_notifier *mn; int id; - lock_map_acquire(&__mmu_notifier_invalidate_range_start_map); id = srcu_read_lock(&srcu); - hlist_for_each_entry_rcu(mn, &range->mm->mmu_notifier_mm->list, hlist) { + hlist_for_each_entry_rcu(mn, &mmn_mm->list, hlist) { /* * Call invalidate_range here too to avoid the need for the * subsystem of having to register an invalidate_range_end @@ -238,6 +534,19 @@ void __mmu_notifier_invalidate_range_end(struct mmu_notifier_range *range, } } srcu_read_unlock(&srcu, id); +} + +void __mmu_notifier_invalidate_range_end(struct mmu_notifier_range *range, + bool only_end) +{ + struct mmu_notifier_mm *mmn_mm = range->mm->mmu_notifier_mm; + + lock_map_acquire(&__mmu_notifier_invalidate_range_start_map); + if (mmn_mm->has_interval) + mn_itree_inv_end(mmn_mm); + + if (!hlist_empty(&mmn_mm->list)) + mn_hlist_invalidate_end(mmn_mm, range, only_end); lock_map_release(&__mmu_notifier_invalidate_range_start_map); } @@ -256,8 +565,9 @@ void __mmu_notifier_invalidate_range(struct mm_struct *mm, } /* - * Same as mmu_notifier_register but here the caller must hold the - * mmap_sem in write mode. + * Same as mmu_notifier_register but here the caller must hold the mmap_sem in + * write mode. A NULL mn signals the notifier is being registered for itree + * mode. */ int __mmu_notifier_register(struct mmu_notifier *mn, struct mm_struct *mm) { @@ -274,9 +584,6 @@ int __mmu_notifier_register(struct mmu_notifier *mn, struct mm_struct *mm) fs_reclaim_release(GFP_KERNEL); } - mn->mm = mm; - mn->users = 1; - if (!mm->mmu_notifier_mm) { /* * kmalloc cannot be called under mm_take_all_locks(), but we @@ -284,21 +591,22 @@ int __mmu_notifier_register(struct mmu_notifier *mn, struct mm_struct *mm) * the write side of the mmap_sem. */ mmu_notifier_mm = - kmalloc(sizeof(struct mmu_notifier_mm), GFP_KERNEL); + kzalloc(sizeof(struct mmu_notifier_mm), GFP_KERNEL); if (!mmu_notifier_mm) return -ENOMEM; INIT_HLIST_HEAD(&mmu_notifier_mm->list); spin_lock_init(&mmu_notifier_mm->lock); + mmu_notifier_mm->invalidate_seq = 2; + mmu_notifier_mm->itree = RB_ROOT_CACHED; + init_waitqueue_head(&mmu_notifier_mm->wq); + INIT_HLIST_HEAD(&mmu_notifier_mm->deferred_list); } ret = mm_take_all_locks(mm); if (unlikely(ret)) goto out_clean; - /* Pairs with the mmdrop in mmu_notifier_unregister_* */ - mmgrab(mm); - /* * Serialize the update against mmu_notifier_unregister. A * side note: mmu_notifier_release can't run concurrently with @@ -306,13 +614,28 @@ int __mmu_notifier_register(struct mmu_notifier *mn, struct mm_struct *mm) * current->mm or explicitly with get_task_mm() or similar). * We can't race against any other mmu notifier method either * thanks to mm_take_all_locks(). + * + * release semantics on the initialization of the mmu_notifier_mm's + * contents are provided for unlocked readers. acquire can only be + * used while holding the mmgrab or mmget, and is safe because once + * created the mmu_notififer_mm is not freed until the mm is + * destroyed. As above, users holding the mmap_sem or one of the + * mm_take_all_locks() do not need to use acquire semantics. */ if (mmu_notifier_mm) - mm->mmu_notifier_mm = mmu_notifier_mm; + smp_store_release(&mm->mmu_notifier_mm, mmu_notifier_mm); - spin_lock(&mm->mmu_notifier_mm->lock); - hlist_add_head_rcu(&mn->hlist, &mm->mmu_notifier_mm->list); - spin_unlock(&mm->mmu_notifier_mm->lock); + if (mn) { + /* Pairs with the mmdrop in mmu_notifier_unregister_* */ + mmgrab(mm); + mn->mm = mm; + mn->users = 1; + + spin_lock(&mm->mmu_notifier_mm->lock); + hlist_add_head_rcu(&mn->hlist, &mm->mmu_notifier_mm->list); + spin_unlock(&mm->mmu_notifier_mm->lock); + } else + mm->mmu_notifier_mm->has_interval = true; mm_drop_all_locks(mm); BUG_ON(atomic_read(&mm->mm_users) <= 0); @@ -529,6 +852,166 @@ void mmu_notifier_put(struct mmu_notifier *mn) } EXPORT_SYMBOL_GPL(mmu_notifier_put); +static int __mmu_range_notifier_insert(struct mmu_range_notifier *mrn, + unsigned long start, + unsigned long length, + struct mmu_notifier_mm *mmn_mm, + struct mm_struct *mm) +{ + mrn->mm = mm; + RB_CLEAR_NODE(&mrn->interval_tree.rb); + mrn->interval_tree.start = start; + /* + * Note that the representation of the intervals in the interval tree + * considers the ending point as contained in the interval. + */ + if (length == 0 || + check_add_overflow(start, length - 1, &mrn->interval_tree.last)) + return -EOVERFLOW; + + /* pairs with mmdrop in mmu_range_notifier_remove() */ + mmgrab(mm); + + /* + * If some invalidate_range_start/end region is going on in parallel + * we don't know what VA ranges are affected, so we must assume this + * new range is included. + * + * If the itree is invalidating then we are not allowed to change + * it. Retrying until invalidation is done is tricky due to the + * possibility for live lock, instead defer the add to the unlock so + * this algorithm is deterministic. + * + * In all cases the value for the mrn->mr_invalidate_seq should be + * odd, see mmu_range_read_begin() + */ + spin_lock(&mmn_mm->lock); + if (mmn_mm->active_invalidate_ranges) { + if (mn_itree_is_invalidating(mmn_mm)) + hlist_add_head(&mrn->deferred_item, + &mmn_mm->deferred_list); + else { + mmn_mm->invalidate_seq |= 1; + interval_tree_insert(&mrn->interval_tree, + &mmn_mm->itree); + } + mrn->invalidate_seq = mmn_mm->invalidate_seq; + } else { + WARN_ON(mn_itree_is_invalidating(mmn_mm)); + mrn->invalidate_seq = mmn_mm->invalidate_seq - 1; + interval_tree_insert(&mrn->interval_tree, &mmn_mm->itree); + } + spin_unlock(&mmn_mm->lock); + return 0; +} + +/** + * mmu_range_notifier_insert - Insert a range notifier + * @mrn: Range notifier to register + * @start: Starting virtual address to monitor + * @length: Length of the range to monitor + * @mm : mm_struct to attach to + * + * This function subscribes the range notifier for notifications from the mm. + * Upon return the ops related to mmu_range_notifier will be called whenever + * an event that intersects with the given range occurs. + * + * Upon return the range_notifier may not be present in the interval tree yet. + * The caller must use the normal range notifier locking flow via + * mmu_range_read_begin() to establish SPTEs for this range. + */ +int mmu_range_notifier_insert(struct mmu_range_notifier *mrn, + unsigned long start, unsigned long length, + struct mm_struct *mm) +{ + struct mmu_notifier_mm *mmn_mm; + int ret; + + might_lock(&mm->mmap_sem); + + mmn_mm = smp_load_acquire(&mm->mmu_notifier_mm); + if (!mmn_mm || !mmn_mm->has_interval) { + ret = mmu_notifier_register(NULL, mm); + if (ret) + return ret; + mmn_mm = mm->mmu_notifier_mm; + } + return __mmu_range_notifier_insert(mrn, start, length, mmn_mm, mm); +} +EXPORT_SYMBOL_GPL(mmu_range_notifier_insert); + +int mmu_range_notifier_insert_locked(struct mmu_range_notifier *mrn, + unsigned long start, unsigned long length, + struct mm_struct *mm) +{ + struct mmu_notifier_mm *mmn_mm; + int ret; + + lockdep_assert_held_write(&mm->mmap_sem); + + mmn_mm = mm->mmu_notifier_mm; + if (!mmn_mm || !mmn_mm->has_interval) { + ret = __mmu_notifier_register(NULL, mm); + if (ret) + return ret; + mmn_mm = mm->mmu_notifier_mm; + } + return __mmu_range_notifier_insert(mrn, start, length, mmn_mm, mm); +} +EXPORT_SYMBOL_GPL(mmu_range_notifier_insert_locked); + +/** + * mmu_range_notifier_remove - Remove a range notifier + * @mrn: Range notifier to unregister + * + * This function must be paired with mmu_range_notifier_insert(). It cannot be + * called from any ops callback. + * + * Once this returns ops callbacks are no longer running on other CPUs and + * will not be called in future. + */ +void mmu_range_notifier_remove(struct mmu_range_notifier *mrn) +{ + struct mm_struct *mm = mrn->mm; + struct mmu_notifier_mm *mmn_mm = mm->mmu_notifier_mm; + unsigned long seq = 0; + + might_sleep(); + + spin_lock(&mmn_mm->lock); + if (mn_itree_is_invalidating(mmn_mm)) { + /* + * remove is being called after insert put this on the + * deferred list, but before the deferred list was processed. + */ + if (RB_EMPTY_NODE(&mrn->interval_tree.rb)) { + hlist_del(&mrn->deferred_item); + } else { + hlist_add_head(&mrn->deferred_item, + &mmn_mm->deferred_list); + seq = mmn_mm->invalidate_seq; + } + } else { + WARN_ON(RB_EMPTY_NODE(&mrn->interval_tree.rb)); + interval_tree_remove(&mrn->interval_tree, &mmn_mm->itree); + } + spin_unlock(&mmn_mm->lock); + + /* + * The possible sleep on progress in the invalidation requires the + * caller not hold any locks held by invalidation callbacks. + */ + lock_map_acquire(&__mmu_notifier_invalidate_range_start_map); + lock_map_release(&__mmu_notifier_invalidate_range_start_map); + if (seq) + wait_event(mmn_mm->wq, + READ_ONCE(mmn_mm->invalidate_seq) != seq); + + /* pairs with mmgrab in mmu_range_notifier_insert() */ + mmdrop(mm); +} +EXPORT_SYMBOL_GPL(mmu_range_notifier_remove); + /** * mmu_notifier_synchronize - Ensure all mmu_notifiers are freed * -- 2.23.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jason Gunthorpe Subject: [PATCH v2 02/15] mm/mmu_notifier: add an interval tree notifier Date: Mon, 28 Oct 2019 17:10:19 -0300 Message-ID: <20191028201032.6352-3-jgg@ziepe.ca> References: <20191028201032.6352-1-jgg@ziepe.ca> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20191028201032.6352-1-jgg@ziepe.ca> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" To: linux-mm@kvack.org, Jerome Glisse , Ralph Campbell , John Hubbard , Felix.Kuehling@amd.com Cc: Juergen Gross , David Zhou , Mike Marciniszyn , Stefano Stabellini , Andrea Arcangeli , Oleksandr Andrushchenko , linux-rdma@vger.kernel.org, nouveau@lists.freedesktop.org, Dennis Dalessandro , amd-gfx@lists.freedesktop.org, Michal Hocko , Christoph Hellwig , Jason Gunthorpe , dri-devel@lists.freedesktop.org, Alex Deucher , xen-devel@lists.xenproject.org, Boris Ostrovsky , Petr Cvek , =?UTF-8?q?Christian=20K=C3=B6nig?= , Ben Skeggs List-Id: nouveau.vger.kernel.org RnJvbTogSmFzb24gR3VudGhvcnBlIDxqZ2dAbWVsbGFub3guY29tPgoKT2YgdGhlIDEzIHVzZXJz IG9mIG1tdV9ub3RpZmllcnMsIDggb2YgdGhlbSB1c2Ugb25seQppbnZhbGlkYXRlX3JhbmdlX3N0 YXJ0L2VuZCgpIGFuZCBpbW1lZGlhdGVseSBpbnRlcnNlY3QgdGhlCm1tdV9ub3RpZmllcl9yYW5n ZSB3aXRoIHNvbWUga2luZCBvZiBpbnRlcm5hbCBsaXN0IG9mIFZBcy4gIDQgdXNlIGFuCmludGVy dmFsIHRyZWUgKGk5MTVfZ2VtLCByYWRlb25fbW4sIHVtZW1fb2RwLCBoZmkxKS4gNCB1c2UgYSBs aW5rZWQgbGlzdApvZiBzb21lIGtpbmQgKHNjaWZfZG1hLCB2aG9zdCwgZ250ZGV2LCBobW0pCgpB bmQgdGhlIHJlbWFpbmluZyA1IGVpdGhlciBkb24ndCB1c2UgaW52YWxpZGF0ZV9yYW5nZV9zdGFy dCgpIG9yIGRvIHNvbWUKc3BlY2lhbCB0aGluZyB3aXRoIGl0LgoKSXQgdHVybnMgb3V0IHRoYXQg YnVpbGRpbmcgYSBjb3JyZWN0IHNjaGVtZSB3aXRoIGFuIGludGVydmFsIHRyZWUgaXMKcHJldHR5 IGNvbXBsaWNhdGVkLCBwYXJ0aWN1bGFybHkgaWYgdGhlIHVzZSBjYXNlIGlzIHN5bmNocm9uaXpp bmcgYWdhaW5zdAphbm90aGVyIHRocmVhZCBkb2luZyBnZXRfdXNlcl9wYWdlcygpLiAgTWFueSBv ZiB0aGVzZSBpbXBsZW1lbnRhdGlvbnMgaGF2ZQp2YXJpb3VzIHN1YnRsZSBhbmQgZGlmZmljdWx0 IHRvIGZpeCByYWNlcy4KClRoaXMgYXBwcm9hY2ggcHV0cyB0aGUgaW50ZXJ2YWwgdHJlZSBhcyBj b21tb24gY29kZSBhdCB0aGUgdG9wIG9mIHRoZSBtbXUKbm90aWZpZXIgY2FsbCB0cmVlIGFuZCBp bXBsZW1lbnRzIGEgc2hhcmVhYmxlIGxvY2tpbmcgc2NoZW1lLgoKSXQgaW5jbHVkZXM6CiAtIEFu IGludGVydmFsIHRyZWUgdHJhY2tpbmcgVkEgcmFuZ2VzLCB3aXRoIHBlci1yYW5nZSBjYWxsYmFj a3MKIC0gQSByZWFkL3dyaXRlIGxvY2tpbmcgc2NoZW1lIGZvciB0aGUgaW50ZXJ2YWwgdHJlZSB0 aGF0IGF2b2lkcwogICBzbGVlcGluZyBpbiB0aGUgbm90aWZpZXIgcGF0aCAoZm9yIE9PTSBraWxs ZXIpCiAtIEEgc2VxdWVuY2UgY291bnRlciBiYXNlZCBjb2xsaXNpb24tcmV0cnkgbG9ja2luZyBz Y2hlbWUgdG8gdGVsbAogICBkZXZpY2UgcGFnZSBmYXVsdCB0aGF0IGEgVkEgcmFuZ2UgaXMgYmVp bmcgY29uY3VycmVudGx5IGludmFsaWRhdGVkLgoKVGhpcyBpcyBiYXNlZCBvbiB2YXJpb3VzIGlk ZWFzOgotIGhtbSBhY2N1bXVsYXRlcyBpbnZhbGlkYXRlZCBWQSByYW5nZXMgYW5kIHJlbGVhc2Vz IHRoZW0gd2hlbiBhbGwKICBpbnZhbGlkYXRlcyBhcmUgZG9uZSwgdmlhIGFjdGl2ZV9pbnZhbGlk YXRlX3JhbmdlcyBjb3VudC4KICBUaGlzIGFwcHJvYWNoIGF2b2lkcyBoYXZpbmcgdG8gaW50ZXJz ZWN0IHRoZSBpbnRlcnZhbCB0cmVlIHR3aWNlIChhcwogIHVtZW1fb2RwIGRvZXMpIGF0IHRoZSBw b3RlbnRpYWwgY29zdCBvZiBhIGxvbmdlciBkZXZpY2UgcGFnZSBmYXVsdC4KCi0ga3ZtL3VtZW1f b2RwIHVzZSBhIHNlcXVlbmNlIGNvdW50ZXIgdG8gZHJpdmUgdGhlIGNvbGxpc2lvbiByZXRyeSwK ICB2aWEgaW52YWxpZGF0ZV9zZXEKCi0gYSBkZWZlcnJlZCB3b3JrIHRvZG8gbGlzdCBvbiB1bmxv Y2sgc2NoZW1lIGxpa2UgUlROTCwgdmlhIGRlZmVycmVkX2xpc3QuCiAgVGhpcyBtYWtlcyBhZGRp bmcvcmVtb3ZpbmcgaW50ZXJ2YWwgdHJlZSBtZW1iZXJzIG1vcmUgZGV0ZXJtaW5pc3RpYwoKLSBz ZXFsb2NrLCBleGNlcHQgdGhpcyB2ZXJzaW9uIG1ha2VzIHRoZSBzZXFsb2NrIGlkZWEgbXVsdGkt aG9sZGVyIG9uIHRoZQogIHdyaXRlIHNpZGUgYnkgcHJvdGVjdGluZyBpdCB3aXRoIGFjdGl2ZV9p bnZhbGlkYXRlX3JhbmdlcyBhbmQgYSBzcGlubG9jawoKVG8gbWluaW1pemUgTU0gb3ZlcmhlYWQg d2hlbiBvbmx5IHRoZSBpbnRlcnZhbCB0cmVlIGlzIGJlaW5nIHVzZWQsIHRoZQplbnRpcmUgU1JD VSBhbmQgaGxpc3Qgb3ZlcmhlYWRzIGFyZSBkcm9wcGVkIHVzaW5nIHNvbWUgc2ltcGxlCmJyYW5j aGVzLiBTaW1pbGFybHkgdGhlIGludGVydmFsIHRyZWUgb3ZlcmhlYWQgaXMgZHJvcHBlZCB3aGVu IGluIGhsaXN0Cm1vZGUuCgpUaGUgb3ZlcmhlYWQgZnJvbSB0aGUgbWFuZGF0b3J5IHNwaW5sb2Nr IGlzIGJyb2FkbHkgdGhlIHNhbWUgYXMgbW9zdCBvZgpleGlzdGluZyB1c2VycyB3aGljaCBhbHJl YWR5IGhhZCBhIGxvY2sgKG9yIHR3bykgb2Ygc29tZSBzb3J0IG9uIHRoZQppbnZhbGlkYXRpb24g cGF0aC4KCkNjOiBBbmRyZWEgQXJjYW5nZWxpIDxhYXJjYW5nZUByZWRoYXQuY29tPgpDYzogTWlj aGFsIEhvY2tvIDxtaG9ja29Aa2VybmVsLm9yZz4KQWNrZWQtYnk6IENocmlzdGlhbiBLw7ZuaWcg PGNocmlzdGlhbi5rb2VuaWdAYW1kLmNvbT4KU2lnbmVkLW9mZi1ieTogSmFzb24gR3VudGhvcnBl IDxqZ2dAbWVsbGFub3guY29tPgotLS0KIGluY2x1ZGUvbGludXgvbW11X25vdGlmaWVyLmggfCAg OTggKysrKysrKwogbW0vS2NvbmZpZyAgICAgICAgICAgICAgICAgICB8ICAgMSArCiBtbS9tbXVf bm90aWZpZXIuYyAgICAgICAgICAgIHwgNTMzICsrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKy0tCiAzIGZpbGVzIGNoYW5nZWQsIDYwNyBpbnNlcnRpb25zKCspLCAyNSBkZWxldGlvbnMo LSkKCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21tdV9ub3RpZmllci5oIGIvaW5jbHVkZS9s aW51eC9tbXVfbm90aWZpZXIuaAppbmRleCAxMmJkNjAzZDMxOGNlNy4uNTFiOTJiYTAxM2RkY2Ug MTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbW11X25vdGlmaWVyLmgKKysrIGIvaW5jbHVkZS9s aW51eC9tbXVfbm90aWZpZXIuaApAQCAtNiwxMCArNiwxMiBAQAogI2luY2x1ZGUgPGxpbnV4L3Nw aW5sb2NrLmg+CiAjaW5jbHVkZSA8bGludXgvbW1fdHlwZXMuaD4KICNpbmNsdWRlIDxsaW51eC9z cmN1Lmg+CisjaW5jbHVkZSA8bGludXgvaW50ZXJ2YWxfdHJlZS5oPgogCiBzdHJ1Y3QgbW11X25v dGlmaWVyX21tOwogc3RydWN0IG1tdV9ub3RpZmllcjsKIHN0cnVjdCBtbXVfbm90aWZpZXJfcmFu Z2U7CitzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyOwogCiAvKioKICAqIGVudW0gbW11X25vdGlm aWVyX2V2ZW50IC0gcmVhc29uIGZvciB0aGUgbW11IG5vdGlmaWVyIGNhbGxiYWNrCkBAIC0zMiw2 ICszNCw5IEBAIHN0cnVjdCBtbXVfbm90aWZpZXJfcmFuZ2U7CiAgKiBhY2Nlc3MgZmxhZ3MpLiBV c2VyIHNob3VsZCBzb2Z0IGRpcnR5IHRoZSBwYWdlIGluIHRoZSBlbmQgY2FsbGJhY2sgdG8gbWFr ZQogICogc3VyZSB0aGF0IGFueW9uZSByZWx5aW5nIG9uIHNvZnQgZGlydHluZXNzIGNhdGNoIHBh Z2VzIHRoYXQgbWlnaHQgYmUgd3JpdHRlbgogICogdGhyb3VnaCBub24gQ1BVIG1hcHBpbmdzLgor ICoKKyAqIEBNTVVfTk9USUZZX1JFTEVBU0U6IHVzZWQgZHVyaW5nIG1tdV9yYW5nZV9ub3RpZmll ciBpbnZhbGlkYXRlIHRvIHNpZ25hbCB0aGF0CisgKiB0aGUgbW0gcmVmY291bnQgaXMgemVybyBh bmQgdGhlIHJhbmdlIGlzIG5vIGxvbmdlciBhY2Nlc3NpYmxlLgogICovCiBlbnVtIG1tdV9ub3Rp Zmllcl9ldmVudCB7CiAJTU1VX05PVElGWV9VTk1BUCA9IDAsCkBAIC0zOSw2ICs0NCw3IEBAIGVu dW0gbW11X25vdGlmaWVyX2V2ZW50IHsKIAlNTVVfTk9USUZZX1BST1RFQ1RJT05fVk1BLAogCU1N VV9OT1RJRllfUFJPVEVDVElPTl9QQUdFLAogCU1NVV9OT1RJRllfU09GVF9ESVJUWSwKKwlNTVVf Tk9USUZZX1JFTEVBU0UsCiB9OwogCiAjZGVmaW5lIE1NVV9OT1RJRklFUl9SQU5HRV9CTE9DS0FC TEUgKDEgPDwgMCkKQEAgLTIyMiw2ICsyMjgsMjYgQEAgc3RydWN0IG1tdV9ub3RpZmllciB7CiAJ dW5zaWduZWQgaW50IHVzZXJzOwogfTsKIAorLyoqCisgKiBzdHJ1Y3QgbW11X3JhbmdlX25vdGlm aWVyX29wcworICogQGludmFsaWRhdGU6IFVwb24gcmV0dXJuIHRoZSBjYWxsZXIgbXVzdCBzdG9w IHVzaW5nIGFueSBTUFRFcyB3aXRoaW4gdGhpcworICogICAgICAgICAgICAgIHJhbmdlLCB0aGlz IGZ1bmN0aW9uIGNhbiBzbGVlcC4gUmV0dXJuIGZhbHNlIGlmIGJsb2NraW5nIHdhcworICogICAg ICAgICAgICAgIHJlcXVpcmVkIGJ1dCByYW5nZSBpcyBub24tYmxvY2tpbmcKKyAqLworc3RydWN0 IG1tdV9yYW5nZV9ub3RpZmllcl9vcHMgeworCWJvb2wgKCppbnZhbGlkYXRlKShzdHJ1Y3QgbW11 X3JhbmdlX25vdGlmaWVyICptcm4sCisJCQkgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3Jh bmdlICpyYW5nZSwKKwkJCSAgIHVuc2lnbmVkIGxvbmcgY3VyX3NlcSk7Cit9OworCitzdHJ1Y3Qg bW11X3JhbmdlX25vdGlmaWVyIHsKKwlzdHJ1Y3QgaW50ZXJ2YWxfdHJlZV9ub2RlIGludGVydmFs X3RyZWU7CisJY29uc3Qgc3RydWN0IG1tdV9yYW5nZV9ub3RpZmllcl9vcHMgKm9wczsKKwlzdHJ1 Y3QgaGxpc3Rfbm9kZSBkZWZlcnJlZF9pdGVtOworCXVuc2lnbmVkIGxvbmcgaW52YWxpZGF0ZV9z ZXE7CisJc3RydWN0IG1tX3N0cnVjdCAqbW07Cit9OworCiAjaWZkZWYgQ09ORklHX01NVV9OT1RJ RklFUgogCiAjaWZkZWYgQ09ORklHX0xPQ0tERVAKQEAgLTI2Myw2ICsyODksNzggQEAgZXh0ZXJu IGludCBfX21tdV9ub3RpZmllcl9yZWdpc3RlcihzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwKIAkJ CQkgICBzdHJ1Y3QgbW1fc3RydWN0ICptbSk7CiBleHRlcm4gdm9pZCBtbXVfbm90aWZpZXJfdW5y ZWdpc3RlcihzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwKIAkJCQkgICAgc3RydWN0IG1tX3N0cnVj dCAqbW0pOworCit1bnNpZ25lZCBsb25nIG1tdV9yYW5nZV9yZWFkX2JlZ2luKHN0cnVjdCBtbXVf cmFuZ2Vfbm90aWZpZXIgKm1ybik7CitpbnQgbW11X3JhbmdlX25vdGlmaWVyX2luc2VydChzdHJ1 Y3QgbW11X3JhbmdlX25vdGlmaWVyICptcm4sCisJCQkgICAgICB1bnNpZ25lZCBsb25nIHN0YXJ0 LCB1bnNpZ25lZCBsb25nIGxlbmd0aCwKKwkJCSAgICAgIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKTsK K2ludCBtbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0X2xvY2tlZChzdHJ1Y3QgbW11X3JhbmdlX25v dGlmaWVyICptcm4sCisJCQkJICAgICB1bnNpZ25lZCBsb25nIHN0YXJ0LCB1bnNpZ25lZCBsb25n IGxlbmd0aCwKKwkJCQkgICAgIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKTsKK3ZvaWQgbW11X3Jhbmdl X25vdGlmaWVyX3JlbW92ZShzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyICptcm4pOworCisvKioK KyAqIG1tdV9yYW5nZV9zZXRfc2VxIC0gU2F2ZSB0aGUgaW52YWxpZGF0aW9uIHNlcXVlbmNlCisg KiBAbXJuIC0gVGhlIG1ybiBwYXNzZWQgdG8gaW52YWxpZGF0ZQorICogQGN1cl9zZXEgLSBUaGUg Y3VyX3NlcSBwYXNzZWQgdG8gaW52YWxpZGF0ZQorICoKKyAqIFRoaXMgbXVzdCBiZSBjYWxsZWQg dW5jb25kaXRpb25hbGx5IGZyb20gdGhlIGludmFsaWRhdGUgY2FsbGJhY2sgb2YgYQorICogc3Ry dWN0IG1tdV9yYW5nZV9ub3RpZmllcl9vcHMgdW5kZXIgdGhlIHNhbWUgbG9jayB0aGF0IGlzIHVz ZWQgdG8gY2FsbAorICogbW11X3JhbmdlX3JlYWRfcmV0cnkoKS4gSXQgdXBkYXRlcyB0aGUgc2Vx dWVuY2UgbnVtYmVyIGZvciBsYXRlciB1c2UgYnkKKyAqIG1tdV9yYW5nZV9yZWFkX3JldHJ5KCku CisgKgorICogSWYgdGhlIHVzZXIgZG9lcyBub3QgY2FsbCBtbXVfcmFuZ2VfcmVhZF9iZWdpbigp IG9yIG1tdV9yYW5nZV9yZWFkX3JldHJ5KCkKKyAqIHRoZW4gdGhpcyBjYWxsIGlzIG5vdCByZXF1 aXJlZC4KKyAqLworc3RhdGljIGlubGluZSB2b2lkIG1tdV9yYW5nZV9zZXRfc2VxKHN0cnVjdCBt bXVfcmFuZ2Vfbm90aWZpZXIgKm1ybiwKKwkJCQkgICAgIHVuc2lnbmVkIGxvbmcgY3VyX3NlcSkK K3sKKwlXUklURV9PTkNFKG1ybi0+aW52YWxpZGF0ZV9zZXEsIGN1cl9zZXEpOworfQorCisvKioK KyAqIG1tdV9yYW5nZV9yZWFkX3JldHJ5IC0gRW5kIGEgcmVhZCBzaWRlIGNyaXRpY2FsIHNlY3Rp b24gYWdhaW5zdCBhIFZBIHJhbmdlCisgKiBtcm46IFRoZSByYW5nZSB1bmRlciBsb2NrCisgKiBz ZXE6IFRoZSByZXR1cm4gb2YgdGhlIHBhaXJlZCBtbXVfcmFuZ2VfcmVhZF9iZWdpbigpCisgKgor ICogVGhpcyBNVVNUIGJlIGNhbGxlZCB1bmRlciBhIHVzZXIgcHJvdmlkZWQgbG9jayB0aGF0IGlz IGFsc28gaGVsZAorICogdW5jb25kaXRpb25hbGx5IGJ5IG9wLT5pbnZhbGlkYXRlKCkgd2hlbiBp dCBjYWxscyBtbXVfcmFuZ2Vfc2V0X3NlcSgpLgorICoKKyAqIEVhY2ggY2FsbCBzaG91bGQgYmUg cGFpcmVkIHdpdGggYSBzaW5nbGUgbW11X3JhbmdlX3JlYWRfYmVnaW4oKSBhbmQKKyAqIHNob3Vs ZCBiZSB1c2VkIHRvIGNvbmNsdWRlIHRoZSByZWFkIHNpZGUuCisgKgorICogUmV0dXJucyB0cnVl IGlmIGFuIGludmFsaWRhdGlvbiBjb2xsaWRlZCB3aXRoIHRoaXMgY3JpdGljYWwgc2VjdGlvbiwg YW5kCisgKiB0aGUgY2FsbGVyIHNob3VsZCByZXRyeS4KKyAqLworc3RhdGljIGlubGluZSBib29s IG1tdV9yYW5nZV9yZWFkX3JldHJ5KHN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXIgKm1ybiwKKwkJ CQkJdW5zaWduZWQgbG9uZyBzZXEpCit7CisJcmV0dXJuIG1ybi0+aW52YWxpZGF0ZV9zZXEgIT0g c2VxOworfQorCisvKioKKyAqIG1tdV9yYW5nZV9jaGVja19yZXRyeSAtIFRlc3QgaWYgYSBjb2xs aXNpb24gaGFzIG9jY3VycmVkCisgKiBtcm46IFRoZSByYW5nZSB1bmRlciBsb2NrCisgKiBzZXE6 IFRoZSByZXR1cm4gb2YgdGhlIG1hdGNoaW5nIG1tdV9yYW5nZV9yZWFkX2JlZ2luKCkKKyAqCisg KiBUaGlzIGNhbiBiZSB1c2VkIGluIHRoZSBjcml0aWNhbCBzZWN0aW9uIGJldHdlZW4gbW11X3Jh bmdlX3JlYWRfYmVnaW4oKSBhbmQKKyAqIG1tdV9yYW5nZV9yZWFkX3JldHJ5KCkuICBBIHJldHVy biBvZiB0cnVlIGluZGljYXRlcyBhbiBpbnZhbGlkYXRpb24gaGFzCisgKiBjb2xsaWRlZCB3aXRo IHRoaXMgbG9jayBhbmQgYSBmdXR1cmUgbW11X3JhbmdlX3JlYWRfcmV0cnkoKSB3aWxsIHJldHVy bgorICogdHJ1ZS4KKyAqCisgKiBGYWxzZSBpcyBub3QgcmVsaWFibGUgYW5kIG9ubHkgc3VnZ2Vz dHMgYSBjb2xsaXNpb24gaGFzIG5vdCBoYXBwZW5lZC4gSXQKKyAqIGNhbiBiZSBjYWxsZWQgbWFu eSB0aW1lcyBhbmQgZG9lcyBub3QgaGF2ZSB0byBob2xkIHRoZSB1c2VyIHByb3ZpZGVkIGxvY2su CisgKgorICogVGhpcyBjYWxsIGNhbiBiZSB1c2VkIGFzIHBhcnQgb2YgbG9vcHMgYW5kIG90aGVy IGV4cGVuc2l2ZSBvcGVyYXRpb25zIHRvCisgKiBleHBlZGl0ZSBhIHJldHJ5LgorICovCitzdGF0 aWMgaW5saW5lIGJvb2wgbW11X3JhbmdlX2NoZWNrX3JldHJ5KHN0cnVjdCBtbXVfcmFuZ2Vfbm90 aWZpZXIgKm1ybiwKKwkJCQkJIHVuc2lnbmVkIGxvbmcgc2VxKQoreworCS8qIFBhaXJzIHdpdGgg dGhlIFdSSVRFX09OQ0UgaW4gbW11X3JhbmdlX3NldF9zZXEoKSAqLworCXJldHVybiBSRUFEX09O Q0UobXJuLT5pbnZhbGlkYXRlX3NlcSkgIT0gc2VxOworfQorCiBleHRlcm4gdm9pZCBfX21tdV9u b3RpZmllcl9tbV9kZXN0cm95KHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKTsKIGV4dGVybiB2b2lkIF9f bW11X25vdGlmaWVyX3JlbGVhc2Uoc3RydWN0IG1tX3N0cnVjdCAqbW0pOwogZXh0ZXJuIGludCBf X21tdV9ub3RpZmllcl9jbGVhcl9mbHVzaF95b3VuZyhzdHJ1Y3QgbW1fc3RydWN0ICptbSwKZGlm ZiAtLWdpdCBhL21tL0tjb25maWcgYi9tbS9LY29uZmlnCmluZGV4IGE1ZGFlOWE3ZWI1MTBhLi5k MGI1MDQ2ZDlhZWZmZCAxMDA2NDQKLS0tIGEvbW0vS2NvbmZpZworKysgYi9tbS9LY29uZmlnCkBA IC0yODQsNiArMjg0LDcgQEAgY29uZmlnIFZJUlRfVE9fQlVTCiBjb25maWcgTU1VX05PVElGSUVS CiAJYm9vbAogCXNlbGVjdCBTUkNVCisJc2VsZWN0IElOVEVSVkFMX1RSRUUKIAogY29uZmlnIEtT TQogCWJvb2wgIkVuYWJsZSBLU00gZm9yIHBhZ2UgbWVyZ2luZyIKZGlmZiAtLWdpdCBhL21tL21t dV9ub3RpZmllci5jIGIvbW0vbW11X25vdGlmaWVyLmMKaW5kZXggMzY3NjcwY2ZkMDJiN2IuLmQw MmQzYzhjMjIzZWI3IDEwMDY0NAotLS0gYS9tbS9tbXVfbm90aWZpZXIuYworKysgYi9tbS9tbXVf bm90aWZpZXIuYwpAQCAtMTIsNiArMTIsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2V4cG9ydC5oPgog I2luY2x1ZGUgPGxpbnV4L21tLmg+CiAjaW5jbHVkZSA8bGludXgvZXJyLmg+CisjaW5jbHVkZSA8 bGludXgvaW50ZXJ2YWxfdHJlZS5oPgogI2luY2x1ZGUgPGxpbnV4L3NyY3UuaD4KICNpbmNsdWRl IDxsaW51eC9yY3VwZGF0ZS5oPgogI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CkBAIC0zNiwxMCAr MzcsMjQzIEBAIHN0cnVjdCBsb2NrZGVwX21hcCBfX21tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3Jh bmdlX3N0YXJ0X21hcCA9IHsKIHN0cnVjdCBtbXVfbm90aWZpZXJfbW0gewogCS8qIGFsbCBtbXUg bm90aWZpZXJzIHJlZ2lzdGVyZWQgaW4gdGhpcyBtbSBhcmUgcXVldWVkIGluIHRoaXMgbGlzdCAq LwogCXN0cnVjdCBobGlzdF9oZWFkIGxpc3Q7CisJYm9vbCBoYXNfaW50ZXJ2YWw7CiAJLyogdG8g c2VyaWFsaXplIHRoZSBsaXN0IG1vZGlmaWNhdGlvbnMgYW5kIGhsaXN0X3VuaGFzaGVkICovCiAJ c3BpbmxvY2tfdCBsb2NrOworCXVuc2lnbmVkIGxvbmcgaW52YWxpZGF0ZV9zZXE7CisJdW5zaWdu ZWQgbG9uZyBhY3RpdmVfaW52YWxpZGF0ZV9yYW5nZXM7CisJc3RydWN0IHJiX3Jvb3RfY2FjaGVk IGl0cmVlOworCXdhaXRfcXVldWVfaGVhZF90IHdxOworCXN0cnVjdCBobGlzdF9oZWFkIGRlZmVy cmVkX2xpc3Q7CiB9OwogCisvKgorICogVGhpcyBpcyBhIGNvbGxpc2lvbi1yZXRyeSByZWFkLXNp ZGUvd3JpdGUtc2lkZSAnbG9jaycsIGEgbG90IGxpa2UgYQorICogc2VxY291bnQsIGhvd2V2ZXIg dGhpcyBhbGxvd3MgbXVsdGlwbGUgd3JpdGUtc2lkZXMgdG8gaG9sZCBpdCBhdAorICogb25jZS4g Q29uY2VwdHVhbGx5IHRoZSB3cml0ZSBzaWRlIGlzIHByb3RlY3RpbmcgdGhlIHZhbHVlcyBvZiB0 aGUgUFRFcyBpbgorICogdGhpcyBtbSwgc3VjaCB0aGF0IFBURVMgY2Fubm90IGJlIHJlYWQgaW50 byBTUFRFcyB3aGlsZSBhbnkgd3JpdGVyIGV4aXN0cy4KKyAqCisgKiBOb3RlIHRoYXQgdGhlIGNv cmUgbW0gY3JlYXRlcyBuZXN0ZWQgaW52YWxpZGF0ZV9yYW5nZV9zdGFydCgpL2VuZCgpIHJlZ2lv bnMKKyAqIHdpdGhpbiB0aGUgc2FtZSB0aHJlYWQsIGFuZCBydW5zIGludmFsaWRhdGVfcmFuZ2Vf c3RhcnQoKS9lbmQoKSBpbiBwYXJhbGxlbAorICogb24gbXVsdGlwbGUgQ1BVcy4gVGhpcyBpcyBk ZXNpZ25lZCB0byBub3QgcmVkdWNlIGNvbmN1cnJlbmN5IG9yIGJsb2NrCisgKiBwcm9ncmVzcyBv biB0aGUgbW0gc2lkZS4KKyAqCisgKiBBcyBhIHNlY29uZGFyeSBmdW5jdGlvbiwgaG9sZGluZyB0 aGUgZnVsbCB3cml0ZSBzaWRlIGFsc28gc2VydmVzIHRvIHByZXZlbnQKKyAqIHdyaXRlcnMgZm9y IHRoZSBpdHJlZSwgdGhpcyBpcyBhbiBvcHRpbWl6YXRpb24gdG8gYXZvaWQgZXh0cmEgbG9ja2lu ZworICogZHVyaW5nIGludmFsaWRhdGVfcmFuZ2Vfc3RhcnQvZW5kIG5vdGlmaWVycy4KKyAqCisg KiBUaGUgd3JpdGUgc2lkZSBoYXMgdHdvIHN0YXRlcywgZnVsbHkgZXhjbHVkZWQ6CisgKiAgLSBt bS0+YWN0aXZlX2ludmFsaWRhdGVfcmFuZ2VzICE9IDAKKyAqICAtIG1ubi0+aW52YWxpZGF0ZV9z ZXEgJiAxID09IFRydWUKKyAqICAtIHNvbWUgcmFuZ2Ugb24gdGhlIG1tX3N0cnVjdCBpcyBiZWlu ZyBpbnZhbGlkYXRlZAorICogIC0gdGhlIGl0cmVlIGlzIG5vdCBhbGxvd2VkIHRvIGNoYW5nZQor ICoKKyAqIEFuZCBwYXJ0aWFsbHkgZXhjbHVkZWQ6CisgKiAgLSBtbS0+YWN0aXZlX2ludmFsaWRh dGVfcmFuZ2VzICE9IDAKKyAqICAtIHNvbWUgcmFuZ2Ugb24gdGhlIG1tX3N0cnVjdCBpcyBiZWlu ZyBpbnZhbGlkYXRlZAorICogIC0gdGhlIGl0cmVlIGlzIGFsbG93ZWQgdG8gY2hhbmdlCisgKgor ICogVGhlIGxhdGVyIHN0YXRlIGF2b2lkcyBzb21lIGV4cGVuc2l2ZSB3b3JrIG9uIGludl9lbmQg aW4gdGhlIGNvbW1vbiBjYXNlIG9mCisgKiBubyBtcm4gbW9uaXRvcmluZyB0aGUgVkEuCisgKi8K K3N0YXRpYyBib29sIG1uX2l0cmVlX2lzX2ludmFsaWRhdGluZyhzdHJ1Y3QgbW11X25vdGlmaWVy X21tICptbW5fbW0pCit7CisJbG9ja2RlcF9hc3NlcnRfaGVsZCgmbW1uX21tLT5sb2NrKTsKKwly ZXR1cm4gbW1uX21tLT5pbnZhbGlkYXRlX3NlcSAmIDE7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgbW11 X3JhbmdlX25vdGlmaWVyICoKK21uX2l0cmVlX2ludl9zdGFydF9yYW5nZShzdHJ1Y3QgbW11X25v dGlmaWVyX21tICptbW5fbW0sCisJCQkgY29uc3Qgc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAq cmFuZ2UsCisJCQkgdW5zaWduZWQgbG9uZyAqc2VxKQoreworCXN0cnVjdCBpbnRlcnZhbF90cmVl X25vZGUgKm5vZGU7CisJc3RydWN0IG1tdV9yYW5nZV9ub3RpZmllciAqcmVzID0gTlVMTDsKKwor CXNwaW5fbG9jaygmbW1uX21tLT5sb2NrKTsKKwltbW5fbW0tPmFjdGl2ZV9pbnZhbGlkYXRlX3Jh bmdlcysrOworCW5vZGUgPSBpbnRlcnZhbF90cmVlX2l0ZXJfZmlyc3QoJm1tbl9tbS0+aXRyZWUs IHJhbmdlLT5zdGFydCwKKwkJCQkJcmFuZ2UtPmVuZCAtIDEpOworCWlmIChub2RlKSB7CisJCW1t bl9tbS0+aW52YWxpZGF0ZV9zZXEgfD0gMTsKKwkJcmVzID0gY29udGFpbmVyX29mKG5vZGUsIHN0 cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXIsCisJCQkJICAgaW50ZXJ2YWxfdHJlZSk7CisJfQorCisJ KnNlcSA9IG1tbl9tbS0+aW52YWxpZGF0ZV9zZXE7CisJc3Bpbl91bmxvY2soJm1tbl9tbS0+bG9j ayk7CisJcmV0dXJuIHJlczsKK30KKworc3RhdGljIHN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXIg KgorbW5faXRyZWVfaW52X25leHQoc3RydWN0IG1tdV9yYW5nZV9ub3RpZmllciAqbXJuLAorCQkg IGNvbnN0IHN0cnVjdCBtbXVfbm90aWZpZXJfcmFuZ2UgKnJhbmdlKQoreworCXN0cnVjdCBpbnRl cnZhbF90cmVlX25vZGUgKm5vZGU7CisKKwlub2RlID0gaW50ZXJ2YWxfdHJlZV9pdGVyX25leHQo Jm1ybi0+aW50ZXJ2YWxfdHJlZSwgcmFuZ2UtPnN0YXJ0LAorCQkJCSAgICAgICByYW5nZS0+ZW5k IC0gMSk7CisJaWYgKCFub2RlKQorCQlyZXR1cm4gTlVMTDsKKwlyZXR1cm4gY29udGFpbmVyX29m KG5vZGUsIHN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXIsIGludGVydmFsX3RyZWUpOworfQorCitz dGF0aWMgdm9pZCBtbl9pdHJlZV9pbnZfZW5kKHN0cnVjdCBtbXVfbm90aWZpZXJfbW0gKm1tbl9t bSkKK3sKKwlzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyICptcm47CisJc3RydWN0IGhsaXN0X25v ZGUgKm5leHQ7CisJYm9vbCBuZWVkX3dha2UgPSBmYWxzZTsKKworCXNwaW5fbG9jaygmbW1uX21t LT5sb2NrKTsKKwlpZiAoLS1tbW5fbW0tPmFjdGl2ZV9pbnZhbGlkYXRlX3JhbmdlcyB8fAorCSAg ICAhbW5faXRyZWVfaXNfaW52YWxpZGF0aW5nKG1tbl9tbSkpIHsKKwkJc3Bpbl91bmxvY2soJm1t bl9tbS0+bG9jayk7CisJCXJldHVybjsKKwl9CisKKwltbW5fbW0tPmludmFsaWRhdGVfc2VxKys7 CisJbmVlZF93YWtlID0gdHJ1ZTsKKworCS8qCisJICogVGhlIGludl9lbmQgaW5jb3Jwb3JhdGVz IGEgZGVmZXJyZWQgbWVjaGFuaXNtIGxpa2UKKwkgKiBydG5sX2xvY2soKS4gQWRkcyBhbmQgcmVt b3ZlcyBhcmUgcXVldWVkIHVudGlsIHRoZSBmaW5hbCBpbnZfZW5kCisJICogaGFwcGVucyB0aGVu IHRoZXkgYXJlIHByb2dyZXNzZWQuIFRoaXMgYXJyYW5nZW1lbnQgZm9yIHRyZWUgdXBkYXRlcwor CSAqIGlzIHVzZWQgdG8gYXZvaWQgdXNpbmcgYSBibG9ja2luZyBsb2NrIGR1cmluZworCSAqIGlu dmFsaWRhdGVfcmFuZ2Vfc3RhcnQuCisJICovCisJaGxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZSht cm4sIG5leHQsICZtbW5fbW0tPmRlZmVycmVkX2xpc3QsCisJCQkJICBkZWZlcnJlZF9pdGVtKSB7 CisJCWlmIChSQl9FTVBUWV9OT0RFKCZtcm4tPmludGVydmFsX3RyZWUucmIpKQorCQkJaW50ZXJ2 YWxfdHJlZV9pbnNlcnQoJm1ybi0+aW50ZXJ2YWxfdHJlZSwKKwkJCQkJICAgICAmbW1uX21tLT5p dHJlZSk7CisJCWVsc2UKKwkJCWludGVydmFsX3RyZWVfcmVtb3ZlKCZtcm4tPmludGVydmFsX3Ry ZWUsCisJCQkJCSAgICAgJm1tbl9tbS0+aXRyZWUpOworCQlobGlzdF9kZWwoJm1ybi0+ZGVmZXJy ZWRfaXRlbSk7CisJfQorCXNwaW5fdW5sb2NrKCZtbW5fbW0tPmxvY2spOworCisJLyoKKwkgKiBU T0RPOiBTaW5jZSB3ZSBhbHJlYWR5IGhhdmUgYSBzcGlubG9jayBhYm92ZSwgdGhpcyB3b3VsZCBi ZSBmYXN0ZXIKKwkgKiBhcyB3YWtlX3VwX3EKKwkgKi8KKwlpZiAobmVlZF93YWtlKQorCQl3YWtl X3VwX2FsbCgmbW1uX21tLT53cSk7Cit9CisKKy8qKgorICogbW11X3JhbmdlX3JlYWRfYmVnaW4g LSBCZWdpbiBhIHJlYWQgc2lkZSBjcml0aWNhbCBzZWN0aW9uIGFnYWluc3QgYSBWQSByYW5nZQor ICogbXJuOiBUaGUgcmFuZ2UgdG8gbG9jaworICoKKyAqIG1tdV9yYW5nZV9yZWFkX2JlZ2luKCkv bW11X3JhbmdlX3JlYWRfcmV0cnkoKSBpbXBsZW1lbnQgYSBjb2xsaXNpb24tcmV0cnkKKyAqIGxv Y2tpbmcgc2NoZW1lIHNpbWlsYXIgdG8gc2VxY291bnQgZm9yIHRoZSBWQSByYW5nZSB1bmRlciBt cm4uIElmIHRoZSBtbQorICogaW52b2tlcyBpbnZhbGlkYXRpb24gZHVyaW5nIHRoZSBjcml0aWNh bCBzZWN0aW9uIHRoZW4KKyAqIG1tdV9yYW5nZV9yZWFkX3JldHJ5KCkgd2lsbCByZXR1cm4gdHJ1 ZS4KKyAqCisgKiBUaGlzIGlzIHVzZWZ1bCB0byBvYnRhaW4gc2hhZG93IFBURXMgd2hlcmUgdGVh cmRvd24gb3Igc2V0dXAgb2YgdGhlIFNQVEVzCisgKiByZXF1aXJlIGEgYmxvY2tpbmcgY29udGV4 dC4gIFRoZSBjcml0aWNhbCByZWdpb24gZm9ybWVkIGJ5IHRoaXMgbG9jayBjYW4KKyAqIHNsZWVw LCBhbmQgdGhlIHJlcXVpcmVkICd1c2VyX2xvY2snIGNhbiBhbHNvIGJlIGEgc2xlZXBpbmcgbG9j ay4KKyAqCisgKiBUaGUgY2FsbGVyIGlzIHJlcXVpcmVkIHRvIHByb3ZpZGUgYSAndXNlcl9sb2Nr JyB0byBzZXJpYWxpemUgYm90aCB0ZWFyZG93bgorICogYW5kIHNldHVwLgorICoKKyAqIFRoZSBy ZXR1cm4gdmFsdWUgc2hvdWxkIGJlIHBhc3NlZCB0byBtbXVfcmFuZ2VfcmVhZF9yZXRyeSgpLgor ICovCit1bnNpZ25lZCBsb25nIG1tdV9yYW5nZV9yZWFkX2JlZ2luKHN0cnVjdCBtbXVfcmFuZ2Vf bm90aWZpZXIgKm1ybikKK3sKKwlzdHJ1Y3QgbW11X25vdGlmaWVyX21tICptbW5fbW0gPSBtcm4t Pm1tLT5tbXVfbm90aWZpZXJfbW07CisJdW5zaWduZWQgbG9uZyBzZXE7CisJYm9vbCBpc19pbnZh bGlkYXRpbmc7CisKKwkvKgorCSAqIElmIHRoZSBtcm4gaGFzIGEgZGlmZmVyZW50IHNlcSB2YWx1 ZSB1bmRlciB0aGUgdXNlcl9sb2NrIHRoYW4gd2UKKwkgKiBzdGFydGVkIHdpdGggdGhlbiBpdCBo YXMgY29sbGlkZWQuCisJICoKKwkgKiBJZiB0aGUgbXJuIGN1cnJlbnRseSBoYXMgdGhlIHNhbWUg c2VxIHZhbHVlIGFzIHRoZSBtbW5fbW0gc2VxLCB0aGVuCisJICogaXQgaXMgY3VycmVudGx5IGJl dHdlZW4gaW52YWxpZGF0ZV9zdGFydC9lbmQgYW5kIGlzIGNvbGxpZGluZy4KKwkgKgorCSAqIFRo ZSBsb2NraW5nIGxvb2tzIGJyb2FkbHkgbGlrZSB0aGlzOgorCSAqICAgbW5fdHJlZV9pbnZhbGlk YXRlX3N0YXJ0KCk6ICAgICAgICAgIG1tdV9yYW5nZV9yZWFkX2JlZ2luKCk6CisJICogICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNwaW5fbG9jaworCSAqICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc2VxID0gUkVBRF9PTkNFKG1ybi0+aW52 YWxpZGF0ZV9zZXEpOworCSAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgc2VxID09IG1tbl9tbS0+aW52YWxpZGF0ZV9zZXEKKwkgKiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgc3Bpbl91bmxvY2sKKwkgKiAgICBzcGluX2xvY2sKKwkgKiAg ICAgc2VxID0gKyttbW5fbW0tPmludmFsaWRhdGVfc2VxCisJICogICAgc3Bpbl91bmxvY2sKKwkg KiAgICAgb3AtPmludmFsaWRhdGVfcmFuZ2UoKToKKwkgKiAgICAgICB1c2VyX2xvY2sKKwkgKiAg ICAgICAgbW11X3JhbmdlX3NldF9zZXEoKQorCSAqICAgICAgICAgbXJuLT5pbnZhbGlkYXRlX3Nl cSA9IHNlcQorCSAqICAgICAgIHVzZXJfdW5sb2NrCisJICoKKwkgKiAgICAgICAgICAgICAgICAg ICAgICAgICAgW1JlcXVpcmVkOiBtbXVfcmFuZ2VfcmVhZF9yZXRyeSgpID09IHRydWVdCisJICoK KwkgKiAgIG1uX2l0cmVlX2ludl9lbmQoKToKKwkgKiAgICBzcGluX2xvY2sKKwkgKiAgICAgc2Vx ID0gKyttbW5fbW0tPmludmFsaWRhdGVfc2VxCisJICogICAgc3Bpbl91bmxvY2sKKwkgKgorCSAq ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVzZXJfbG9jaworCSAqICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtbXVfcmFuZ2VfcmVhZF9yZXRy eSgpOgorCSAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbXJuLT5p bnZhbGlkYXRlX3NlcSAhPSBzZXEKKwkgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB1c2VyX3VubG9jaworCSAqCisJICogQmFycmllcnMgYXJlIG5vdCBuZWVkZWQgaGVy ZSBhcyBhbnkgcmFjZXMgaGVyZSBhcmUgY2xvc2VkIGJ5IGFuCisJICogZXZlbnR1YWwgbW11X3Jh bmdlX3JlYWRfcmV0cnkoKSwgd2hpY2ggcHJvdmlkZXMgYSBiYXJyaWVyIHZpYSB0aGUKKwkgKiB1 c2VyX2xvY2suCisJICovCisJc3Bpbl9sb2NrKCZtbW5fbW0tPmxvY2spOworCS8qIFBhaXJzIHdp dGggdGhlIFdSSVRFX09OQ0UgaW4gbW11X3JhbmdlX3NldF9zZXEoKSAqLworCXNlcSA9IFJFQURf T05DRShtcm4tPmludmFsaWRhdGVfc2VxKTsKKwlpc19pbnZhbGlkYXRpbmcgPSBzZXEgPT0gbW1u X21tLT5pbnZhbGlkYXRlX3NlcTsKKwlzcGluX3VubG9jaygmbW1uX21tLT5sb2NrKTsKKworCS8q CisJICogbXJuLT5pbnZhbGlkYXRlX3NlcSBpcyBhbHdheXMgc2V0IHRvIGFuIG9kZCB2YWx1ZS4g VGhpcyBlbnN1cmVzCisJICogdGhhdCBpZiBzZXEgZG9lcyB3cmFwIHdlIHdpbGwgYWx3YXlzIGNs ZWFyIHRoZSBiZWxvdyBzbGVlcCBpbiBzb21lCisJICogcmVhc29uYWJsZSB0aW1lIGFzIG1tbl9t bS0+aW52YWxpZGF0ZV9zZXEgaXMgZXZlbiBpbiB0aGUgaWRsZQorCSAqIHN0YXRlLgorCSAqLwor CWxvY2tfbWFwX2FjcXVpcmUoJl9fbW11X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnRf bWFwKTsKKwlsb2NrX21hcF9yZWxlYXNlKCZfX21tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3Jhbmdl X3N0YXJ0X21hcCk7CisJaWYgKGlzX2ludmFsaWRhdGluZykKKwkJd2FpdF9ldmVudChtbW5fbW0t PndxLAorCQkJICAgUkVBRF9PTkNFKG1tbl9tbS0+aW52YWxpZGF0ZV9zZXEpICE9IHNlcSk7CisK KwkvKgorCSAqIE5vdGljZSB0aGF0IG1tdV9yYW5nZV9yZWFkX3JldHJ5KCkgY2FuIGFscmVhZHkg YmUgdHJ1ZSBhdCB0aGlzCisJICogcG9pbnQsIGF2b2lkaW5nIGxvb3BzIGhlcmUgYWxsb3dzIHRo ZSB1c2VyIG9mIHRoaXMgbG9jayB0byBwcm92aWRlCisJICogYSBnbG9iYWwgdGltZSBib3VuZC4K KwkgKi8KKworCXJldHVybiBzZXE7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChtbXVfcmFuZ2VfcmVh ZF9iZWdpbik7CisKK3N0YXRpYyB2b2lkIG1uX2l0cmVlX3JlbGVhc2Uoc3RydWN0IG1tdV9ub3Rp Zmllcl9tbSAqbW1uX21tLAorCQkJICAgICBzdHJ1Y3QgbW1fc3RydWN0ICptbSkKK3sKKwlzdHJ1 Y3QgbW11X25vdGlmaWVyX3JhbmdlIHJhbmdlID0geworCQkuZmxhZ3MgPSBNTVVfTk9USUZJRVJf UkFOR0VfQkxPQ0tBQkxFLAorCQkuZXZlbnQgPSBNTVVfTk9USUZZX1JFTEVBU0UsCisJCS5tbSA9 IG1tLAorCQkuc3RhcnQgPSAwLAorCQkuZW5kID0gVUxPTkdfTUFYLAorCX07CisJc3RydWN0IG1t dV9yYW5nZV9ub3RpZmllciAqbXJuOworCXVuc2lnbmVkIGxvbmcgY3VyX3NlcTsKKwlib29sIHJl dDsKKworCWZvciAobXJuID0gbW5faXRyZWVfaW52X3N0YXJ0X3JhbmdlKG1tbl9tbSwgJnJhbmdl LCAmY3VyX3NlcSk7IG1ybjsKKwkgICAgIG1ybiA9IG1uX2l0cmVlX2ludl9uZXh0KG1ybiwgJnJh bmdlKSkgeworCQlyZXQgPSBtcm4tPm9wcy0+aW52YWxpZGF0ZShtcm4sICZyYW5nZSwgY3VyX3Nl cSk7CisJCVdBUk5fT04oIXJldCk7CisJfQorCisJbW5faXRyZWVfaW52X2VuZChtbW5fbW0pOwor fQorCiAvKgogICogVGhpcyBmdW5jdGlvbiBjYW4ndCBydW4gY29uY3VycmVudGx5IGFnYWluc3Qg bW11X25vdGlmaWVyX3JlZ2lzdGVyCiAgKiBiZWNhdXNlIG1tLT5tbV91c2VycyA+IDAgZHVyaW5n IG1tdV9ub3RpZmllcl9yZWdpc3RlciBhbmQgZXhpdF9tbWFwCkBAIC01MiwxNyArMjg2LDI0IEBA IHN0cnVjdCBtbXVfbm90aWZpZXJfbW0gewogICogY2FuJ3QgZ28gYXdheSBmcm9tIHVuZGVyIHVz IGFzIGV4aXRfbW1hcCBob2xkcyBhbiBtbV9jb3VudCBwaW4KICAqIGl0c2VsZi4KICAqLwotdm9p ZCBfX21tdV9ub3RpZmllcl9yZWxlYXNlKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQorc3RhdGljIHZv aWQgbW5faGxpc3RfcmVsZWFzZShzdHJ1Y3QgbW11X25vdGlmaWVyX21tICptbW5fbW0sCisJCQkg ICAgIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQogewogCXN0cnVjdCBtbXVfbm90aWZpZXIgKm1uOwog CWludCBpZDsKIAorCWlmIChtbW5fbW0tPmhhc19pbnRlcnZhbCkKKwkJbW5faXRyZWVfcmVsZWFz ZShtbW5fbW0sIG1tKTsKKworCWlmIChobGlzdF9lbXB0eSgmbW1uX21tLT5saXN0KSkKKwkJcmV0 dXJuOworCiAJLyoKIAkgKiBTUkNVIGhlcmUgd2lsbCBibG9jayBtbXVfbm90aWZpZXJfdW5yZWdp c3RlciB1bnRpbAogCSAqIC0+cmVsZWFzZSByZXR1cm5zLgogCSAqLwogCWlkID0gc3JjdV9yZWFk X2xvY2soJnNyY3UpOwotCWhsaXN0X2Zvcl9lYWNoX2VudHJ5X3JjdShtbiwgJm1tLT5tbXVfbm90 aWZpZXJfbW0tPmxpc3QsIGhsaXN0KQorCWhsaXN0X2Zvcl9lYWNoX2VudHJ5X3JjdShtbiwgJm1t bl9tbS0+bGlzdCwgaGxpc3QpCiAJCS8qCiAJCSAqIElmIC0+cmVsZWFzZSBydW5zIGJlZm9yZSBt bXVfbm90aWZpZXJfdW5yZWdpc3RlciBpdCBtdXN0IGJlCiAJCSAqIGhhbmRsZWQsIGFzIGl0J3Mg dGhlIG9ubHkgd2F5IGZvciB0aGUgZHJpdmVyIHRvIGZsdXNoIGFsbApAQCAtNzIsOSArMzEzLDkg QEAgdm9pZCBfX21tdV9ub3RpZmllcl9yZWxlYXNlKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQogCQlp ZiAobW4tPm9wcy0+cmVsZWFzZSkKIAkJCW1uLT5vcHMtPnJlbGVhc2UobW4sIG1tKTsKIAotCXNw aW5fbG9jaygmbW0tPm1tdV9ub3RpZmllcl9tbS0+bG9jayk7Ci0Jd2hpbGUgKHVubGlrZWx5KCFo bGlzdF9lbXB0eSgmbW0tPm1tdV9ub3RpZmllcl9tbS0+bGlzdCkpKSB7Ci0JCW1uID0gaGxpc3Rf ZW50cnkobW0tPm1tdV9ub3RpZmllcl9tbS0+bGlzdC5maXJzdCwKKwlzcGluX2xvY2soJm1tbl9t bS0+bG9jayk7CisJd2hpbGUgKHVubGlrZWx5KCFobGlzdF9lbXB0eSgmbW1uX21tLT5saXN0KSkp IHsKKwkJbW4gPSBobGlzdF9lbnRyeShtbW5fbW0tPmxpc3QuZmlyc3QsCiAJCQkJIHN0cnVjdCBt bXVfbm90aWZpZXIsCiAJCQkJIGhsaXN0KTsKIAkJLyoKQEAgLTg1LDcgKzMyNiw3IEBAIHZvaWQg X19tbXVfbm90aWZpZXJfcmVsZWFzZShzdHJ1Y3QgbW1fc3RydWN0ICptbSkKIAkJICovCiAJCWhs aXN0X2RlbF9pbml0X3JjdSgmbW4tPmhsaXN0KTsKIAl9Ci0Jc3Bpbl91bmxvY2soJm1tLT5tbXVf bm90aWZpZXJfbW0tPmxvY2spOworCXNwaW5fdW5sb2NrKCZtbW5fbW0tPmxvY2spOwogCXNyY3Vf cmVhZF91bmxvY2soJnNyY3UsIGlkKTsKIAogCS8qCkBAIC0xMDAsNiArMzQxLDE3IEBAIHZvaWQg X19tbXVfbm90aWZpZXJfcmVsZWFzZShzdHJ1Y3QgbW1fc3RydWN0ICptbSkKIAlzeW5jaHJvbml6 ZV9zcmN1KCZzcmN1KTsKIH0KIAordm9pZCBfX21tdV9ub3RpZmllcl9yZWxlYXNlKHN0cnVjdCBt bV9zdHJ1Y3QgKm1tKQoreworCXN0cnVjdCBtbXVfbm90aWZpZXJfbW0gKm1tbl9tbSA9IG1tLT5t bXVfbm90aWZpZXJfbW07CisKKwlpZiAobW1uX21tLT5oYXNfaW50ZXJ2YWwpCisJCW1uX2l0cmVl X3JlbGVhc2UobW1uX21tLCBtbSk7CisKKwlpZiAoIWhsaXN0X2VtcHR5KCZtbW5fbW0tPmxpc3Qp KQorCQltbl9obGlzdF9yZWxlYXNlKG1tbl9tbSwgbW0pOworfQorCiAvKgogICogSWYgbm8geW91 bmcgYml0ZmxhZyBpcyBzdXBwb3J0ZWQgYnkgdGhlIGhhcmR3YXJlLCAtPmNsZWFyX2ZsdXNoX3lv dW5nIGNhbgogICogdW5tYXAgdGhlIGFkZHJlc3MgYW5kIHJldHVybiAxIG9yIDAgZGVwZW5kaW5n IGlmIHRoZSBtYXBwaW5nIHByZXZpb3VzbHkKQEAgLTE3MiwxNCArNDI0LDQzIEBAIHZvaWQgX19t bXVfbm90aWZpZXJfY2hhbmdlX3B0ZShzdHJ1Y3QgbW1fc3RydWN0ICptbSwgdW5zaWduZWQgbG9u ZyBhZGRyZXNzLAogCXNyY3VfcmVhZF91bmxvY2soJnNyY3UsIGlkKTsKIH0KIAotaW50IF9fbW11 X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnQoc3RydWN0IG1tdV9ub3RpZmllcl9yYW5n ZSAqcmFuZ2UpCitzdGF0aWMgaW50IG1uX2l0cmVlX2ludmFsaWRhdGUoc3RydWN0IG1tdV9ub3Rp Zmllcl9tbSAqbW1uX21tLAorCQkJCSAgICAgY29uc3Qgc3RydWN0IG1tdV9ub3RpZmllcl9yYW5n ZSAqcmFuZ2UpCit7CisJc3RydWN0IG1tdV9yYW5nZV9ub3RpZmllciAqbXJuOworCXVuc2lnbmVk IGxvbmcgY3VyX3NlcTsKKworCWZvciAobXJuID0gbW5faXRyZWVfaW52X3N0YXJ0X3JhbmdlKG1t bl9tbSwgcmFuZ2UsICZjdXJfc2VxKTsgbXJuOworCSAgICAgbXJuID0gbW5faXRyZWVfaW52X25l eHQobXJuLCByYW5nZSkpIHsKKwkJYm9vbCByZXQ7CisKKwkJcmV0ID0gbXJuLT5vcHMtPmludmFs aWRhdGUobXJuLCByYW5nZSwgY3VyX3NlcSk7CisJCWlmICghcmV0KSB7CisJCQlpZiAoV0FSTl9P TihtbXVfbm90aWZpZXJfcmFuZ2VfYmxvY2thYmxlKHJhbmdlKSkpCisJCQkJY29udGludWU7CisJ CQlnb3RvIG91dF93b3VsZF9ibG9jazsKKwkJfQorCX0KKwlyZXR1cm4gMDsKKworb3V0X3dvdWxk X2Jsb2NrOgorCS8qCisJICogT24gLUVBR0FJTiB0aGUgbm9uLWJsb2NraW5nIGNhbGxlciBpcyBu b3QgYWxsb3dlZCB0byBjYWxsCisJICogaW52YWxpZGF0ZV9yYW5nZV9lbmQoKQorCSAqLworCW1u X2l0cmVlX2ludl9lbmQobW1uX21tKTsKKwlyZXR1cm4gLUVBR0FJTjsKK30KKworc3RhdGljIGlu dCBtbl9obGlzdF9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KHN0cnVjdCBtbXVfbm90aWZpZXJfbW0g Km1tbl9tbSwKKwkJCQkJICAgc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAqcmFuZ2UpCiB7CiAJ c3RydWN0IG1tdV9ub3RpZmllciAqbW47CiAJaW50IHJldCA9IDA7CiAJaW50IGlkOwogCiAJaWQg PSBzcmN1X3JlYWRfbG9jaygmc3JjdSk7Ci0JaGxpc3RfZm9yX2VhY2hfZW50cnlfcmN1KG1uLCAm cmFuZ2UtPm1tLT5tbXVfbm90aWZpZXJfbW0tPmxpc3QsIGhsaXN0KSB7CisJaGxpc3RfZm9yX2Vh Y2hfZW50cnlfcmN1KG1uLCAmbW1uX21tLT5saXN0LCBobGlzdCkgewogCQlpZiAobW4tPm9wcy0+ aW52YWxpZGF0ZV9yYW5nZV9zdGFydCkgewogCQkJaW50IF9yZXQ7CiAKQEAgLTIwMywxNSArNDg0 LDMwIEBAIGludCBfX21tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KHN0cnVjdCBt bXVfbm90aWZpZXJfcmFuZ2UgKnJhbmdlKQogCXJldHVybiByZXQ7CiB9CiAKLXZvaWQgX19tbXVf bm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZV9lbmQoc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAq cmFuZ2UsCi0JCQkJCSBib29sIG9ubHlfZW5kKQoraW50IF9fbW11X25vdGlmaWVyX2ludmFsaWRh dGVfcmFuZ2Vfc3RhcnQoc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAqcmFuZ2UpCit7CisJc3Ry dWN0IG1tdV9ub3RpZmllcl9tbSAqbW1uX21tID0gcmFuZ2UtPm1tLT5tbXVfbm90aWZpZXJfbW07 CisJaW50IHJldCA9IDA7CisKKwlpZiAobW1uX21tLT5oYXNfaW50ZXJ2YWwpIHsKKwkJcmV0ID0g bW5faXRyZWVfaW52YWxpZGF0ZShtbW5fbW0sIHJhbmdlKTsKKwkJaWYgKHJldCkKKwkJCXJldHVy biByZXQ7CisJfQorCWlmICghaGxpc3RfZW1wdHkoJm1tbl9tbS0+bGlzdCkpCisJCXJldHVybiBt bl9obGlzdF9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KG1tbl9tbSwgcmFuZ2UpOworCXJldHVybiAw OworfQorCitzdGF0aWMgdm9pZCBtbl9obGlzdF9pbnZhbGlkYXRlX2VuZChzdHJ1Y3QgbW11X25v dGlmaWVyX21tICptbW5fbW0sCisJCQkJICAgIHN0cnVjdCBtbXVfbm90aWZpZXJfcmFuZ2UgKnJh bmdlLAorCQkJCSAgICBib29sIG9ubHlfZW5kKQogewogCXN0cnVjdCBtbXVfbm90aWZpZXIgKm1u OwogCWludCBpZDsKIAotCWxvY2tfbWFwX2FjcXVpcmUoJl9fbW11X25vdGlmaWVyX2ludmFsaWRh dGVfcmFuZ2Vfc3RhcnRfbWFwKTsKIAlpZCA9IHNyY3VfcmVhZF9sb2NrKCZzcmN1KTsKLQlobGlz dF9mb3JfZWFjaF9lbnRyeV9yY3UobW4sICZyYW5nZS0+bW0tPm1tdV9ub3RpZmllcl9tbS0+bGlz dCwgaGxpc3QpIHsKKwlobGlzdF9mb3JfZWFjaF9lbnRyeV9yY3UobW4sICZtbW5fbW0tPmxpc3Qs IGhsaXN0KSB7CiAJCS8qCiAJCSAqIENhbGwgaW52YWxpZGF0ZV9yYW5nZSBoZXJlIHRvbyB0byBh dm9pZCB0aGUgbmVlZCBmb3IgdGhlCiAJCSAqIHN1YnN5c3RlbSBvZiBoYXZpbmcgdG8gcmVnaXN0 ZXIgYW4gaW52YWxpZGF0ZV9yYW5nZV9lbmQKQEAgLTIzOCw2ICs1MzQsMTkgQEAgdm9pZCBfX21t dV9ub3RpZmllcl9pbnZhbGlkYXRlX3JhbmdlX2VuZChzdHJ1Y3QgbW11X25vdGlmaWVyX3Jhbmdl ICpyYW5nZSwKIAkJfQogCX0KIAlzcmN1X3JlYWRfdW5sb2NrKCZzcmN1LCBpZCk7Cit9CisKK3Zv aWQgX19tbXVfbm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZV9lbmQoc3RydWN0IG1tdV9ub3RpZmll cl9yYW5nZSAqcmFuZ2UsCisJCQkJCSBib29sIG9ubHlfZW5kKQoreworCXN0cnVjdCBtbXVfbm90 aWZpZXJfbW0gKm1tbl9tbSA9IHJhbmdlLT5tbS0+bW11X25vdGlmaWVyX21tOworCisJbG9ja19t YXBfYWNxdWlyZSgmX19tbXVfbm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZV9zdGFydF9tYXApOwor CWlmIChtbW5fbW0tPmhhc19pbnRlcnZhbCkKKwkJbW5faXRyZWVfaW52X2VuZChtbW5fbW0pOwor CisJaWYgKCFobGlzdF9lbXB0eSgmbW1uX21tLT5saXN0KSkKKwkJbW5faGxpc3RfaW52YWxpZGF0 ZV9lbmQobW1uX21tLCByYW5nZSwgb25seV9lbmQpOwogCWxvY2tfbWFwX3JlbGVhc2UoJl9fbW11 X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnRfbWFwKTsKIH0KIApAQCAtMjU2LDggKzU2 NSw5IEBAIHZvaWQgX19tbXVfbm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZShzdHJ1Y3QgbW1fc3Ry dWN0ICptbSwKIH0KIAogLyoKLSAqIFNhbWUgYXMgbW11X25vdGlmaWVyX3JlZ2lzdGVyIGJ1dCBo ZXJlIHRoZSBjYWxsZXIgbXVzdCBob2xkIHRoZQotICogbW1hcF9zZW0gaW4gd3JpdGUgbW9kZS4K KyAqIFNhbWUgYXMgbW11X25vdGlmaWVyX3JlZ2lzdGVyIGJ1dCBoZXJlIHRoZSBjYWxsZXIgbXVz dCBob2xkIHRoZSBtbWFwX3NlbSBpbgorICogd3JpdGUgbW9kZS4gQSBOVUxMIG1uIHNpZ25hbHMg dGhlIG5vdGlmaWVyIGlzIGJlaW5nIHJlZ2lzdGVyZWQgZm9yIGl0cmVlCisgKiBtb2RlLgogICov CiBpbnQgX19tbXVfbm90aWZpZXJfcmVnaXN0ZXIoc3RydWN0IG1tdV9ub3RpZmllciAqbW4sIHN0 cnVjdCBtbV9zdHJ1Y3QgKm1tKQogewpAQCAtMjc0LDkgKzU4NCw2IEBAIGludCBfX21tdV9ub3Rp Zmllcl9yZWdpc3RlcihzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwgc3RydWN0IG1tX3N0cnVjdCAq bW0pCiAJCWZzX3JlY2xhaW1fcmVsZWFzZShHRlBfS0VSTkVMKTsKIAl9CiAKLQltbi0+bW0gPSBt bTsKLQltbi0+dXNlcnMgPSAxOwotCiAJaWYgKCFtbS0+bW11X25vdGlmaWVyX21tKSB7CiAJCS8q CiAJCSAqIGttYWxsb2MgY2Fubm90IGJlIGNhbGxlZCB1bmRlciBtbV90YWtlX2FsbF9sb2Nrcygp LCBidXQgd2UKQEAgLTI4NCwyMSArNTkxLDIyIEBAIGludCBfX21tdV9ub3RpZmllcl9yZWdpc3Rl cihzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwgc3RydWN0IG1tX3N0cnVjdCAqbW0pCiAJCSAqIHRo ZSB3cml0ZSBzaWRlIG9mIHRoZSBtbWFwX3NlbS4KIAkJICovCiAJCW1tdV9ub3RpZmllcl9tbSA9 Ci0JCQlrbWFsbG9jKHNpemVvZihzdHJ1Y3QgbW11X25vdGlmaWVyX21tKSwgR0ZQX0tFUk5FTCk7 CisJCQlremFsbG9jKHNpemVvZihzdHJ1Y3QgbW11X25vdGlmaWVyX21tKSwgR0ZQX0tFUk5FTCk7 CiAJCWlmICghbW11X25vdGlmaWVyX21tKQogCQkJcmV0dXJuIC1FTk9NRU07CiAKIAkJSU5JVF9I TElTVF9IRUFEKCZtbXVfbm90aWZpZXJfbW0tPmxpc3QpOwogCQlzcGluX2xvY2tfaW5pdCgmbW11 X25vdGlmaWVyX21tLT5sb2NrKTsKKwkJbW11X25vdGlmaWVyX21tLT5pbnZhbGlkYXRlX3NlcSA9 IDI7CisJCW1tdV9ub3RpZmllcl9tbS0+aXRyZWUgPSBSQl9ST09UX0NBQ0hFRDsKKwkJaW5pdF93 YWl0cXVldWVfaGVhZCgmbW11X25vdGlmaWVyX21tLT53cSk7CisJCUlOSVRfSExJU1RfSEVBRCgm bW11X25vdGlmaWVyX21tLT5kZWZlcnJlZF9saXN0KTsKIAl9CiAKIAlyZXQgPSBtbV90YWtlX2Fs bF9sb2NrcyhtbSk7CiAJaWYgKHVubGlrZWx5KHJldCkpCiAJCWdvdG8gb3V0X2NsZWFuOwogCi0J LyogUGFpcnMgd2l0aCB0aGUgbW1kcm9wIGluIG1tdV9ub3RpZmllcl91bnJlZ2lzdGVyXyogKi8K LQltbWdyYWIobW0pOwotCiAJLyoKIAkgKiBTZXJpYWxpemUgdGhlIHVwZGF0ZSBhZ2FpbnN0IG1t dV9ub3RpZmllcl91bnJlZ2lzdGVyLiBBCiAJICogc2lkZSBub3RlOiBtbXVfbm90aWZpZXJfcmVs ZWFzZSBjYW4ndCBydW4gY29uY3VycmVudGx5IHdpdGgKQEAgLTMwNiwxMyArNjE0LDI4IEBAIGlu dCBfX21tdV9ub3RpZmllcl9yZWdpc3RlcihzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwgc3RydWN0 IG1tX3N0cnVjdCAqbW0pCiAJICogY3VycmVudC0+bW0gb3IgZXhwbGljaXRseSB3aXRoIGdldF90 YXNrX21tKCkgb3Igc2ltaWxhcikuCiAJICogV2UgY2FuJ3QgcmFjZSBhZ2FpbnN0IGFueSBvdGhl ciBtbXUgbm90aWZpZXIgbWV0aG9kIGVpdGhlcgogCSAqIHRoYW5rcyB0byBtbV90YWtlX2FsbF9s b2NrcygpLgorCSAqCisJICogcmVsZWFzZSBzZW1hbnRpY3Mgb24gdGhlIGluaXRpYWxpemF0aW9u IG9mIHRoZSBtbXVfbm90aWZpZXJfbW0ncworICAgICAgICAgKiBjb250ZW50cyBhcmUgcHJvdmlk ZWQgZm9yIHVubG9ja2VkIHJlYWRlcnMuICBhY3F1aXJlIGNhbiBvbmx5IGJlCisgICAgICAgICAq IHVzZWQgd2hpbGUgaG9sZGluZyB0aGUgbW1ncmFiIG9yIG1tZ2V0LCBhbmQgaXMgc2FmZSBiZWNh dXNlIG9uY2UKKyAgICAgICAgICogY3JlYXRlZCB0aGUgbW11X25vdGlmaWZlcl9tbSBpcyBub3Qg ZnJlZWQgdW50aWwgdGhlIG1tIGlzCisgICAgICAgICAqIGRlc3Ryb3llZC4gIEFzIGFib3ZlLCB1 c2VycyBob2xkaW5nIHRoZSBtbWFwX3NlbSBvciBvbmUgb2YgdGhlCisgICAgICAgICAqIG1tX3Rh a2VfYWxsX2xvY2tzKCkgZG8gbm90IG5lZWQgdG8gdXNlIGFjcXVpcmUgc2VtYW50aWNzLgogCSAq LwogCWlmIChtbXVfbm90aWZpZXJfbW0pCi0JCW1tLT5tbXVfbm90aWZpZXJfbW0gPSBtbXVfbm90 aWZpZXJfbW07CisJCXNtcF9zdG9yZV9yZWxlYXNlKCZtbS0+bW11X25vdGlmaWVyX21tLCBtbXVf bm90aWZpZXJfbW0pOwogCi0Jc3Bpbl9sb2NrKCZtbS0+bW11X25vdGlmaWVyX21tLT5sb2NrKTsK LQlobGlzdF9hZGRfaGVhZF9yY3UoJm1uLT5obGlzdCwgJm1tLT5tbXVfbm90aWZpZXJfbW0tPmxp c3QpOwotCXNwaW5fdW5sb2NrKCZtbS0+bW11X25vdGlmaWVyX21tLT5sb2NrKTsKKwlpZiAobW4p IHsKKwkJLyogUGFpcnMgd2l0aCB0aGUgbW1kcm9wIGluIG1tdV9ub3RpZmllcl91bnJlZ2lzdGVy XyogKi8KKwkJbW1ncmFiKG1tKTsKKwkJbW4tPm1tID0gbW07CisJCW1uLT51c2VycyA9IDE7CisK KwkJc3Bpbl9sb2NrKCZtbS0+bW11X25vdGlmaWVyX21tLT5sb2NrKTsKKwkJaGxpc3RfYWRkX2hl YWRfcmN1KCZtbi0+aGxpc3QsICZtbS0+bW11X25vdGlmaWVyX21tLT5saXN0KTsKKwkJc3Bpbl91 bmxvY2soJm1tLT5tbXVfbm90aWZpZXJfbW0tPmxvY2spOworCX0gZWxzZQorCQltbS0+bW11X25v dGlmaWVyX21tLT5oYXNfaW50ZXJ2YWwgPSB0cnVlOwogCiAJbW1fZHJvcF9hbGxfbG9ja3MobW0p OwogCUJVR19PTihhdG9taWNfcmVhZCgmbW0tPm1tX3VzZXJzKSA8PSAwKTsKQEAgLTUyOSw2ICs4 NTIsMTY2IEBAIHZvaWQgbW11X25vdGlmaWVyX3B1dChzdHJ1Y3QgbW11X25vdGlmaWVyICptbikK IH0KIEVYUE9SVF9TWU1CT0xfR1BMKG1tdV9ub3RpZmllcl9wdXQpOwogCitzdGF0aWMgaW50IF9f bW11X3JhbmdlX25vdGlmaWVyX2luc2VydChzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyICptcm4s CisJCQkJICAgICAgIHVuc2lnbmVkIGxvbmcgc3RhcnQsCisJCQkJICAgICAgIHVuc2lnbmVkIGxv bmcgbGVuZ3RoLAorCQkJCSAgICAgICBzdHJ1Y3QgbW11X25vdGlmaWVyX21tICptbW5fbW0sCisJ CQkJICAgICAgIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQoreworCW1ybi0+bW0gPSBtbTsKKwlSQl9D TEVBUl9OT0RFKCZtcm4tPmludGVydmFsX3RyZWUucmIpOworCW1ybi0+aW50ZXJ2YWxfdHJlZS5z dGFydCA9IHN0YXJ0OworCS8qCisJICogTm90ZSB0aGF0IHRoZSByZXByZXNlbnRhdGlvbiBvZiB0 aGUgaW50ZXJ2YWxzIGluIHRoZSBpbnRlcnZhbCB0cmVlCisJICogY29uc2lkZXJzIHRoZSBlbmRp bmcgcG9pbnQgYXMgY29udGFpbmVkIGluIHRoZSBpbnRlcnZhbC4KKwkgKi8KKwlpZiAobGVuZ3Ro ID09IDAgfHwKKwkgICAgY2hlY2tfYWRkX292ZXJmbG93KHN0YXJ0LCBsZW5ndGggLSAxLCAmbXJu LT5pbnRlcnZhbF90cmVlLmxhc3QpKQorCQlyZXR1cm4gLUVPVkVSRkxPVzsKKworCS8qIHBhaXJz IHdpdGggbW1kcm9wIGluIG1tdV9yYW5nZV9ub3RpZmllcl9yZW1vdmUoKSAqLworCW1tZ3JhYiht bSk7CisKKwkvKgorCSAqIElmIHNvbWUgaW52YWxpZGF0ZV9yYW5nZV9zdGFydC9lbmQgcmVnaW9u IGlzIGdvaW5nIG9uIGluIHBhcmFsbGVsCisJICogd2UgZG9uJ3Qga25vdyB3aGF0IFZBIHJhbmdl cyBhcmUgYWZmZWN0ZWQsIHNvIHdlIG11c3QgYXNzdW1lIHRoaXMKKwkgKiBuZXcgcmFuZ2UgaXMg aW5jbHVkZWQuCisJICoKKwkgKiBJZiB0aGUgaXRyZWUgaXMgaW52YWxpZGF0aW5nIHRoZW4gd2Ug YXJlIG5vdCBhbGxvd2VkIHRvIGNoYW5nZQorCSAqIGl0LiBSZXRyeWluZyB1bnRpbCBpbnZhbGlk YXRpb24gaXMgZG9uZSBpcyB0cmlja3kgZHVlIHRvIHRoZQorCSAqIHBvc3NpYmlsaXR5IGZvciBs aXZlIGxvY2ssIGluc3RlYWQgZGVmZXIgdGhlIGFkZCB0byB0aGUgdW5sb2NrIHNvCisJICogdGhp cyBhbGdvcml0aG0gaXMgZGV0ZXJtaW5pc3RpYy4KKwkgKgorCSAqIEluIGFsbCBjYXNlcyB0aGUg dmFsdWUgZm9yIHRoZSBtcm4tPm1yX2ludmFsaWRhdGVfc2VxIHNob3VsZCBiZQorCSAqIG9kZCwg c2VlIG1tdV9yYW5nZV9yZWFkX2JlZ2luKCkKKwkgKi8KKwlzcGluX2xvY2soJm1tbl9tbS0+bG9j ayk7CisJaWYgKG1tbl9tbS0+YWN0aXZlX2ludmFsaWRhdGVfcmFuZ2VzKSB7CisJCWlmIChtbl9p dHJlZV9pc19pbnZhbGlkYXRpbmcobW1uX21tKSkKKwkJCWhsaXN0X2FkZF9oZWFkKCZtcm4tPmRl ZmVycmVkX2l0ZW0sCisJCQkJICAgICAgICZtbW5fbW0tPmRlZmVycmVkX2xpc3QpOworCQllbHNl IHsKKwkJCW1tbl9tbS0+aW52YWxpZGF0ZV9zZXEgfD0gMTsKKwkJCWludGVydmFsX3RyZWVfaW5z ZXJ0KCZtcm4tPmludGVydmFsX3RyZWUsCisJCQkJCSAgICAgJm1tbl9tbS0+aXRyZWUpOworCQl9 CisJCW1ybi0+aW52YWxpZGF0ZV9zZXEgPSBtbW5fbW0tPmludmFsaWRhdGVfc2VxOworCX0gZWxz ZSB7CisJCVdBUk5fT04obW5faXRyZWVfaXNfaW52YWxpZGF0aW5nKG1tbl9tbSkpOworCQltcm4t PmludmFsaWRhdGVfc2VxID0gbW1uX21tLT5pbnZhbGlkYXRlX3NlcSAtIDE7CisJCWludGVydmFs X3RyZWVfaW5zZXJ0KCZtcm4tPmludGVydmFsX3RyZWUsICZtbW5fbW0tPml0cmVlKTsKKwl9CisJ c3Bpbl91bmxvY2soJm1tbl9tbS0+bG9jayk7CisJcmV0dXJuIDA7Cit9CisKKy8qKgorICogbW11 X3JhbmdlX25vdGlmaWVyX2luc2VydCAtIEluc2VydCBhIHJhbmdlIG5vdGlmaWVyCisgKiBAbXJu OiBSYW5nZSBub3RpZmllciB0byByZWdpc3RlcgorICogQHN0YXJ0OiBTdGFydGluZyB2aXJ0dWFs IGFkZHJlc3MgdG8gbW9uaXRvcgorICogQGxlbmd0aDogTGVuZ3RoIG9mIHRoZSByYW5nZSB0byBt b25pdG9yCisgKiBAbW0gOiBtbV9zdHJ1Y3QgdG8gYXR0YWNoIHRvCisgKgorICogVGhpcyBmdW5j dGlvbiBzdWJzY3JpYmVzIHRoZSByYW5nZSBub3RpZmllciBmb3Igbm90aWZpY2F0aW9ucyBmcm9t IHRoZSBtbS4KKyAqIFVwb24gcmV0dXJuIHRoZSBvcHMgcmVsYXRlZCB0byBtbXVfcmFuZ2Vfbm90 aWZpZXIgd2lsbCBiZSBjYWxsZWQgd2hlbmV2ZXIKKyAqIGFuIGV2ZW50IHRoYXQgaW50ZXJzZWN0 cyB3aXRoIHRoZSBnaXZlbiByYW5nZSBvY2N1cnMuCisgKgorICogVXBvbiByZXR1cm4gdGhlIHJh bmdlX25vdGlmaWVyIG1heSBub3QgYmUgcHJlc2VudCBpbiB0aGUgaW50ZXJ2YWwgdHJlZSB5ZXQu CisgKiBUaGUgY2FsbGVyIG11c3QgdXNlIHRoZSBub3JtYWwgcmFuZ2Ugbm90aWZpZXIgbG9ja2lu ZyBmbG93IHZpYQorICogbW11X3JhbmdlX3JlYWRfYmVnaW4oKSB0byBlc3RhYmxpc2ggU1BURXMg Zm9yIHRoaXMgcmFuZ2UuCisgKi8KK2ludCBtbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0KHN0cnVj dCBtbXVfcmFuZ2Vfbm90aWZpZXIgKm1ybiwKKwkJCSAgICAgIHVuc2lnbmVkIGxvbmcgc3RhcnQs IHVuc2lnbmVkIGxvbmcgbGVuZ3RoLAorCQkJICAgICAgc3RydWN0IG1tX3N0cnVjdCAqbW0pCit7 CisJc3RydWN0IG1tdV9ub3RpZmllcl9tbSAqbW1uX21tOworCWludCByZXQ7CisKKwltaWdodF9s b2NrKCZtbS0+bW1hcF9zZW0pOworCisJbW1uX21tID0gc21wX2xvYWRfYWNxdWlyZSgmbW0tPm1t dV9ub3RpZmllcl9tbSk7CisJaWYgKCFtbW5fbW0gfHwgIW1tbl9tbS0+aGFzX2ludGVydmFsKSB7 CisJCXJldCA9IG1tdV9ub3RpZmllcl9yZWdpc3RlcihOVUxMLCBtbSk7CisJCWlmIChyZXQpCisJ CQlyZXR1cm4gcmV0OworCQltbW5fbW0gPSBtbS0+bW11X25vdGlmaWVyX21tOworCX0KKwlyZXR1 cm4gX19tbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0KG1ybiwgc3RhcnQsIGxlbmd0aCwgbW1uX21t LCBtbSk7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChtbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0KTsK KworaW50IG1tdV9yYW5nZV9ub3RpZmllcl9pbnNlcnRfbG9ja2VkKHN0cnVjdCBtbXVfcmFuZ2Vf bm90aWZpZXIgKm1ybiwKKwkJCQkgICAgIHVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxv bmcgbGVuZ3RoLAorCQkJCSAgICAgc3RydWN0IG1tX3N0cnVjdCAqbW0pCit7CisJc3RydWN0IG1t dV9ub3RpZmllcl9tbSAqbW1uX21tOworCWludCByZXQ7CisKKwlsb2NrZGVwX2Fzc2VydF9oZWxk X3dyaXRlKCZtbS0+bW1hcF9zZW0pOworCisJbW1uX21tID0gbW0tPm1tdV9ub3RpZmllcl9tbTsK KwlpZiAoIW1tbl9tbSB8fCAhbW1uX21tLT5oYXNfaW50ZXJ2YWwpIHsKKwkJcmV0ID0gX19tbXVf bm90aWZpZXJfcmVnaXN0ZXIoTlVMTCwgbW0pOworCQlpZiAocmV0KQorCQkJcmV0dXJuIHJldDsK KwkJbW1uX21tID0gbW0tPm1tdV9ub3RpZmllcl9tbTsKKwl9CisJcmV0dXJuIF9fbW11X3Jhbmdl X25vdGlmaWVyX2luc2VydChtcm4sIHN0YXJ0LCBsZW5ndGgsIG1tbl9tbSwgbW0pOworfQorRVhQ T1JUX1NZTUJPTF9HUEwobW11X3JhbmdlX25vdGlmaWVyX2luc2VydF9sb2NrZWQpOworCisvKioK KyAqIG1tdV9yYW5nZV9ub3RpZmllcl9yZW1vdmUgLSBSZW1vdmUgYSByYW5nZSBub3RpZmllcgor ICogQG1ybjogUmFuZ2Ugbm90aWZpZXIgdG8gdW5yZWdpc3RlcgorICoKKyAqIFRoaXMgZnVuY3Rp b24gbXVzdCBiZSBwYWlyZWQgd2l0aCBtbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0KCkuIEl0IGNh bm5vdCBiZQorICogY2FsbGVkIGZyb20gYW55IG9wcyBjYWxsYmFjay4KKyAqCisgKiBPbmNlIHRo aXMgcmV0dXJucyBvcHMgY2FsbGJhY2tzIGFyZSBubyBsb25nZXIgcnVubmluZyBvbiBvdGhlciBD UFVzIGFuZAorICogd2lsbCBub3QgYmUgY2FsbGVkIGluIGZ1dHVyZS4KKyAqLwordm9pZCBtbXVf cmFuZ2Vfbm90aWZpZXJfcmVtb3ZlKHN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXIgKm1ybikKK3sK KwlzdHJ1Y3QgbW1fc3RydWN0ICptbSA9IG1ybi0+bW07CisJc3RydWN0IG1tdV9ub3RpZmllcl9t bSAqbW1uX21tID0gbW0tPm1tdV9ub3RpZmllcl9tbTsKKwl1bnNpZ25lZCBsb25nIHNlcSA9IDA7 CisKKwltaWdodF9zbGVlcCgpOworCisJc3Bpbl9sb2NrKCZtbW5fbW0tPmxvY2spOworCWlmICht bl9pdHJlZV9pc19pbnZhbGlkYXRpbmcobW1uX21tKSkgeworCQkvKgorCQkgKiByZW1vdmUgaXMg YmVpbmcgY2FsbGVkIGFmdGVyIGluc2VydCBwdXQgdGhpcyBvbiB0aGUKKwkJICogZGVmZXJyZWQg bGlzdCwgYnV0IGJlZm9yZSB0aGUgZGVmZXJyZWQgbGlzdCB3YXMgcHJvY2Vzc2VkLgorCQkgKi8K KwkJaWYgKFJCX0VNUFRZX05PREUoJm1ybi0+aW50ZXJ2YWxfdHJlZS5yYikpIHsKKwkJCWhsaXN0 X2RlbCgmbXJuLT5kZWZlcnJlZF9pdGVtKTsKKwkJfSBlbHNlIHsKKwkJCWhsaXN0X2FkZF9oZWFk KCZtcm4tPmRlZmVycmVkX2l0ZW0sCisJCQkJICAgICAgICZtbW5fbW0tPmRlZmVycmVkX2xpc3Qp OworCQkJc2VxID0gbW1uX21tLT5pbnZhbGlkYXRlX3NlcTsKKwkJfQorCX0gZWxzZSB7CisJCVdB Uk5fT04oUkJfRU1QVFlfTk9ERSgmbXJuLT5pbnRlcnZhbF90cmVlLnJiKSk7CisJCWludGVydmFs X3RyZWVfcmVtb3ZlKCZtcm4tPmludGVydmFsX3RyZWUsICZtbW5fbW0tPml0cmVlKTsKKwl9CisJ c3Bpbl91bmxvY2soJm1tbl9tbS0+bG9jayk7CisKKwkvKgorCSAqIFRoZSBwb3NzaWJsZSBzbGVl cCBvbiBwcm9ncmVzcyBpbiB0aGUgaW52YWxpZGF0aW9uIHJlcXVpcmVzIHRoZQorCSAqIGNhbGxl ciBub3QgaG9sZCBhbnkgbG9ja3MgaGVsZCBieSBpbnZhbGlkYXRpb24gY2FsbGJhY2tzLgorCSAq LworCWxvY2tfbWFwX2FjcXVpcmUoJl9fbW11X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3Rh cnRfbWFwKTsKKwlsb2NrX21hcF9yZWxlYXNlKCZfX21tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3Jh bmdlX3N0YXJ0X21hcCk7CisJaWYgKHNlcSkKKwkJd2FpdF9ldmVudChtbW5fbW0tPndxLAorCQkJ ICAgUkVBRF9PTkNFKG1tbl9tbS0+aW52YWxpZGF0ZV9zZXEpICE9IHNlcSk7CisKKwkvKiBwYWly cyB3aXRoIG1tZ3JhYiBpbiBtbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0KCkgKi8KKwltbWRyb3Ao bW0pOworfQorRVhQT1JUX1NZTUJPTF9HUEwobW11X3JhbmdlX25vdGlmaWVyX3JlbW92ZSk7CisK IC8qKgogICogbW11X25vdGlmaWVyX3N5bmNocm9uaXplIC0gRW5zdXJlIGFsbCBtbXVfbm90aWZp ZXJzIGFyZSBmcmVlZAogICoKLS0gCjIuMjMuMAoKCl9fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fClhlbi1kZXZlbCBtYWlsaW5nIGxpc3QKWGVuLWRldmVsQGxp c3RzLnhlbnByb2plY3Qub3JnCmh0dHBzOi8vbGlzdHMueGVucHJvamVjdC5vcmcvbWFpbG1hbi9s aXN0aW5mby94ZW4tZGV2ZWw= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id C713FCA9EC2 for ; Mon, 28 Oct 2019 21:08:01 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id A0ED7218AC for ; Mon, 28 Oct 2019 21:08:01 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org A0ED7218AC Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=ziepe.ca Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 5CFAF6EA40; Mon, 28 Oct 2019 21:07:59 +0000 (UTC) Received: from mail-qk1-x743.google.com (mail-qk1-x743.google.com [IPv6:2607:f8b0:4864:20::743]) by gabe.freedesktop.org (Postfix) with ESMTPS id 5F64589DFB for ; Mon, 28 Oct 2019 20:10:45 +0000 (UTC) Received: by mail-qk1-x743.google.com with SMTP id 71so9800503qkl.0 for ; Mon, 28 Oct 2019 13:10:45 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=H6qkKhlE377yexDDU3hhVTFW0t+EXROxR6aal9KdQe4=; b=fLTffNjWxEQzRQNBOAwpvDxPCQOgR4gtiJz9S+NBQpUDQ7zQjfBrVkaOfNk1eMwNKb g+NUdrIcr8fzXrnmRsKjoCYwp8wkulsgHE/RFk1VZT4bSXk9w5IqHPU4mEjhmnCrTkvY 9D7U7x/ujQiQFiMfJiyaH1Gr9f2pADCijYS+Bd12o5PdaBNtYq9k8wpiNnNruooJz0yY rkMDEN+lPZ5B0YULAE1cggJXKrjoJgZlEpYwGRXsW0OFtT/KPzOrLXgr4AFntHo6tw0W rAMPpaD380RExY+82N7t6GnmhWv8bpivPvjEMB1cnTtP3m8I0+37jssrNTu92+5nh09W IL7A== X-Gm-Message-State: APjAAAUPI8tW06mHt5K/jNAeOVROGYF284Dxmq7oNuHmJ/0KyIBfGIZH 7a2crT4Aiw/4FBaZF4kGM9Smhw== X-Google-Smtp-Source: APXvYqwcJctJ4wjkPX/iRBrM71GSQB516ozrtr/cgoYC3wlErfDwUG/hWnwhh/5dQ5u5+5Pie/tT7A== X-Received: by 2002:a37:7c42:: with SMTP id x63mr13834494qkc.134.1572293444160; Mon, 28 Oct 2019 13:10:44 -0700 (PDT) Received: from ziepe.ca (hlfxns017vw-142-162-113-180.dhcp-dynamic.fibreop.ns.bellaliant.net. [142.162.113.180]) by smtp.gmail.com with ESMTPSA id t65sm6325908qkh.23.2019.10.28.13.10.43 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Mon, 28 Oct 2019 13:10:44 -0700 (PDT) Received: from jgg by mlx.ziepe.ca with local (Exim 4.90_1) (envelope-from ) id 1iPBLf-0001gA-4C; Mon, 28 Oct 2019 17:10:43 -0300 From: Jason Gunthorpe To: linux-mm@kvack.org, Jerome Glisse , Ralph Campbell , John Hubbard , Felix.Kuehling@amd.com Subject: [PATCH v2 02/15] mm/mmu_notifier: add an interval tree notifier Date: Mon, 28 Oct 2019 17:10:19 -0300 Message-Id: <20191028201032.6352-3-jgg@ziepe.ca> X-Mailer: git-send-email 2.23.0 In-Reply-To: <20191028201032.6352-1-jgg@ziepe.ca> References: <20191028201032.6352-1-jgg@ziepe.ca> MIME-Version: 1.0 X-Mailman-Approved-At: Mon, 28 Oct 2019 21:07:58 +0000 X-Mailman-Original-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ziepe.ca; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=H6qkKhlE377yexDDU3hhVTFW0t+EXROxR6aal9KdQe4=; b=S58t6OhprBE5qw20UbAe+Vwse+w2lO/Up0h0lfqdRge/4nS1rXcCCsxlIno+C6MBwn eJxkhgL2L64qgxBPmUhWD6RFK5kf5e0ZelEdKRYLUIxrkTpbhVFOlRF9uwIgGHYVhyZn p43djgWgjcRWx88FI7pDFwEqr3ezye3qfqni5fPI5bTAKCKpVObL1YPw8nHvp+t0PDWo 8uNkbZbvEJJD1KQQGq6PO27jpJTe9bYV5khfvnCnHC1ClOhSnanJvpp5MF0tRIO9Gzbt bgIWXRYWbjzPF2+LqBI2sTQC4L5/nUfSvol6+joXWujgAwYghBBxAzRmxevNYuzjif4u swxA== X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Juergen Gross , Mike Marciniszyn , Stefano Stabellini , Andrea Arcangeli , Oleksandr Andrushchenko , linux-rdma@vger.kernel.org, nouveau@lists.freedesktop.org, Dennis Dalessandro , amd-gfx@lists.freedesktop.org, Michal Hocko , Christoph Hellwig , Jason Gunthorpe , dri-devel@lists.freedesktop.org, Alex Deucher , xen-devel@lists.xenproject.org, Boris Ostrovsky , Petr Cvek , =?UTF-8?q?Christian=20K=C3=B6nig?= , Ben Skeggs Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Message-ID: <20191028201019.crjNuwr-DMCCtFYUcwN2d8pml90sQCeaLvWmIA7Sr7g@z> RnJvbTogSmFzb24gR3VudGhvcnBlIDxqZ2dAbWVsbGFub3guY29tPgoKT2YgdGhlIDEzIHVzZXJz IG9mIG1tdV9ub3RpZmllcnMsIDggb2YgdGhlbSB1c2Ugb25seQppbnZhbGlkYXRlX3JhbmdlX3N0 YXJ0L2VuZCgpIGFuZCBpbW1lZGlhdGVseSBpbnRlcnNlY3QgdGhlCm1tdV9ub3RpZmllcl9yYW5n ZSB3aXRoIHNvbWUga2luZCBvZiBpbnRlcm5hbCBsaXN0IG9mIFZBcy4gIDQgdXNlIGFuCmludGVy dmFsIHRyZWUgKGk5MTVfZ2VtLCByYWRlb25fbW4sIHVtZW1fb2RwLCBoZmkxKS4gNCB1c2UgYSBs aW5rZWQgbGlzdApvZiBzb21lIGtpbmQgKHNjaWZfZG1hLCB2aG9zdCwgZ250ZGV2LCBobW0pCgpB bmQgdGhlIHJlbWFpbmluZyA1IGVpdGhlciBkb24ndCB1c2UgaW52YWxpZGF0ZV9yYW5nZV9zdGFy dCgpIG9yIGRvIHNvbWUKc3BlY2lhbCB0aGluZyB3aXRoIGl0LgoKSXQgdHVybnMgb3V0IHRoYXQg YnVpbGRpbmcgYSBjb3JyZWN0IHNjaGVtZSB3aXRoIGFuIGludGVydmFsIHRyZWUgaXMKcHJldHR5 IGNvbXBsaWNhdGVkLCBwYXJ0aWN1bGFybHkgaWYgdGhlIHVzZSBjYXNlIGlzIHN5bmNocm9uaXpp bmcgYWdhaW5zdAphbm90aGVyIHRocmVhZCBkb2luZyBnZXRfdXNlcl9wYWdlcygpLiAgTWFueSBv ZiB0aGVzZSBpbXBsZW1lbnRhdGlvbnMgaGF2ZQp2YXJpb3VzIHN1YnRsZSBhbmQgZGlmZmljdWx0 IHRvIGZpeCByYWNlcy4KClRoaXMgYXBwcm9hY2ggcHV0cyB0aGUgaW50ZXJ2YWwgdHJlZSBhcyBj b21tb24gY29kZSBhdCB0aGUgdG9wIG9mIHRoZSBtbXUKbm90aWZpZXIgY2FsbCB0cmVlIGFuZCBp bXBsZW1lbnRzIGEgc2hhcmVhYmxlIGxvY2tpbmcgc2NoZW1lLgoKSXQgaW5jbHVkZXM6CiAtIEFu IGludGVydmFsIHRyZWUgdHJhY2tpbmcgVkEgcmFuZ2VzLCB3aXRoIHBlci1yYW5nZSBjYWxsYmFj a3MKIC0gQSByZWFkL3dyaXRlIGxvY2tpbmcgc2NoZW1lIGZvciB0aGUgaW50ZXJ2YWwgdHJlZSB0 aGF0IGF2b2lkcwogICBzbGVlcGluZyBpbiB0aGUgbm90aWZpZXIgcGF0aCAoZm9yIE9PTSBraWxs ZXIpCiAtIEEgc2VxdWVuY2UgY291bnRlciBiYXNlZCBjb2xsaXNpb24tcmV0cnkgbG9ja2luZyBz Y2hlbWUgdG8gdGVsbAogICBkZXZpY2UgcGFnZSBmYXVsdCB0aGF0IGEgVkEgcmFuZ2UgaXMgYmVp bmcgY29uY3VycmVudGx5IGludmFsaWRhdGVkLgoKVGhpcyBpcyBiYXNlZCBvbiB2YXJpb3VzIGlk ZWFzOgotIGhtbSBhY2N1bXVsYXRlcyBpbnZhbGlkYXRlZCBWQSByYW5nZXMgYW5kIHJlbGVhc2Vz IHRoZW0gd2hlbiBhbGwKICBpbnZhbGlkYXRlcyBhcmUgZG9uZSwgdmlhIGFjdGl2ZV9pbnZhbGlk YXRlX3JhbmdlcyBjb3VudC4KICBUaGlzIGFwcHJvYWNoIGF2b2lkcyBoYXZpbmcgdG8gaW50ZXJz ZWN0IHRoZSBpbnRlcnZhbCB0cmVlIHR3aWNlIChhcwogIHVtZW1fb2RwIGRvZXMpIGF0IHRoZSBw b3RlbnRpYWwgY29zdCBvZiBhIGxvbmdlciBkZXZpY2UgcGFnZSBmYXVsdC4KCi0ga3ZtL3VtZW1f b2RwIHVzZSBhIHNlcXVlbmNlIGNvdW50ZXIgdG8gZHJpdmUgdGhlIGNvbGxpc2lvbiByZXRyeSwK ICB2aWEgaW52YWxpZGF0ZV9zZXEKCi0gYSBkZWZlcnJlZCB3b3JrIHRvZG8gbGlzdCBvbiB1bmxv Y2sgc2NoZW1lIGxpa2UgUlROTCwgdmlhIGRlZmVycmVkX2xpc3QuCiAgVGhpcyBtYWtlcyBhZGRp bmcvcmVtb3ZpbmcgaW50ZXJ2YWwgdHJlZSBtZW1iZXJzIG1vcmUgZGV0ZXJtaW5pc3RpYwoKLSBz ZXFsb2NrLCBleGNlcHQgdGhpcyB2ZXJzaW9uIG1ha2VzIHRoZSBzZXFsb2NrIGlkZWEgbXVsdGkt aG9sZGVyIG9uIHRoZQogIHdyaXRlIHNpZGUgYnkgcHJvdGVjdGluZyBpdCB3aXRoIGFjdGl2ZV9p bnZhbGlkYXRlX3JhbmdlcyBhbmQgYSBzcGlubG9jawoKVG8gbWluaW1pemUgTU0gb3ZlcmhlYWQg d2hlbiBvbmx5IHRoZSBpbnRlcnZhbCB0cmVlIGlzIGJlaW5nIHVzZWQsIHRoZQplbnRpcmUgU1JD VSBhbmQgaGxpc3Qgb3ZlcmhlYWRzIGFyZSBkcm9wcGVkIHVzaW5nIHNvbWUgc2ltcGxlCmJyYW5j aGVzLiBTaW1pbGFybHkgdGhlIGludGVydmFsIHRyZWUgb3ZlcmhlYWQgaXMgZHJvcHBlZCB3aGVu IGluIGhsaXN0Cm1vZGUuCgpUaGUgb3ZlcmhlYWQgZnJvbSB0aGUgbWFuZGF0b3J5IHNwaW5sb2Nr IGlzIGJyb2FkbHkgdGhlIHNhbWUgYXMgbW9zdCBvZgpleGlzdGluZyB1c2VycyB3aGljaCBhbHJl YWR5IGhhZCBhIGxvY2sgKG9yIHR3bykgb2Ygc29tZSBzb3J0IG9uIHRoZQppbnZhbGlkYXRpb24g cGF0aC4KCkNjOiBBbmRyZWEgQXJjYW5nZWxpIDxhYXJjYW5nZUByZWRoYXQuY29tPgpDYzogTWlj aGFsIEhvY2tvIDxtaG9ja29Aa2VybmVsLm9yZz4KQWNrZWQtYnk6IENocmlzdGlhbiBLw7ZuaWcg PGNocmlzdGlhbi5rb2VuaWdAYW1kLmNvbT4KU2lnbmVkLW9mZi1ieTogSmFzb24gR3VudGhvcnBl IDxqZ2dAbWVsbGFub3guY29tPgotLS0KIGluY2x1ZGUvbGludXgvbW11X25vdGlmaWVyLmggfCAg OTggKysrKysrKwogbW0vS2NvbmZpZyAgICAgICAgICAgICAgICAgICB8ICAgMSArCiBtbS9tbXVf bm90aWZpZXIuYyAgICAgICAgICAgIHwgNTMzICsrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKy0tCiAzIGZpbGVzIGNoYW5nZWQsIDYwNyBpbnNlcnRpb25zKCspLCAyNSBkZWxldGlvbnMo LSkKCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21tdV9ub3RpZmllci5oIGIvaW5jbHVkZS9s aW51eC9tbXVfbm90aWZpZXIuaAppbmRleCAxMmJkNjAzZDMxOGNlNy4uNTFiOTJiYTAxM2RkY2Ug MTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbW11X25vdGlmaWVyLmgKKysrIGIvaW5jbHVkZS9s aW51eC9tbXVfbm90aWZpZXIuaApAQCAtNiwxMCArNiwxMiBAQAogI2luY2x1ZGUgPGxpbnV4L3Nw aW5sb2NrLmg+CiAjaW5jbHVkZSA8bGludXgvbW1fdHlwZXMuaD4KICNpbmNsdWRlIDxsaW51eC9z cmN1Lmg+CisjaW5jbHVkZSA8bGludXgvaW50ZXJ2YWxfdHJlZS5oPgogCiBzdHJ1Y3QgbW11X25v dGlmaWVyX21tOwogc3RydWN0IG1tdV9ub3RpZmllcjsKIHN0cnVjdCBtbXVfbm90aWZpZXJfcmFu Z2U7CitzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyOwogCiAvKioKICAqIGVudW0gbW11X25vdGlm aWVyX2V2ZW50IC0gcmVhc29uIGZvciB0aGUgbW11IG5vdGlmaWVyIGNhbGxiYWNrCkBAIC0zMiw2 ICszNCw5IEBAIHN0cnVjdCBtbXVfbm90aWZpZXJfcmFuZ2U7CiAgKiBhY2Nlc3MgZmxhZ3MpLiBV c2VyIHNob3VsZCBzb2Z0IGRpcnR5IHRoZSBwYWdlIGluIHRoZSBlbmQgY2FsbGJhY2sgdG8gbWFr ZQogICogc3VyZSB0aGF0IGFueW9uZSByZWx5aW5nIG9uIHNvZnQgZGlydHluZXNzIGNhdGNoIHBh Z2VzIHRoYXQgbWlnaHQgYmUgd3JpdHRlbgogICogdGhyb3VnaCBub24gQ1BVIG1hcHBpbmdzLgor ICoKKyAqIEBNTVVfTk9USUZZX1JFTEVBU0U6IHVzZWQgZHVyaW5nIG1tdV9yYW5nZV9ub3RpZmll ciBpbnZhbGlkYXRlIHRvIHNpZ25hbCB0aGF0CisgKiB0aGUgbW0gcmVmY291bnQgaXMgemVybyBh bmQgdGhlIHJhbmdlIGlzIG5vIGxvbmdlciBhY2Nlc3NpYmxlLgogICovCiBlbnVtIG1tdV9ub3Rp Zmllcl9ldmVudCB7CiAJTU1VX05PVElGWV9VTk1BUCA9IDAsCkBAIC0zOSw2ICs0NCw3IEBAIGVu dW0gbW11X25vdGlmaWVyX2V2ZW50IHsKIAlNTVVfTk9USUZZX1BST1RFQ1RJT05fVk1BLAogCU1N VV9OT1RJRllfUFJPVEVDVElPTl9QQUdFLAogCU1NVV9OT1RJRllfU09GVF9ESVJUWSwKKwlNTVVf Tk9USUZZX1JFTEVBU0UsCiB9OwogCiAjZGVmaW5lIE1NVV9OT1RJRklFUl9SQU5HRV9CTE9DS0FC TEUgKDEgPDwgMCkKQEAgLTIyMiw2ICsyMjgsMjYgQEAgc3RydWN0IG1tdV9ub3RpZmllciB7CiAJ dW5zaWduZWQgaW50IHVzZXJzOwogfTsKIAorLyoqCisgKiBzdHJ1Y3QgbW11X3JhbmdlX25vdGlm aWVyX29wcworICogQGludmFsaWRhdGU6IFVwb24gcmV0dXJuIHRoZSBjYWxsZXIgbXVzdCBzdG9w IHVzaW5nIGFueSBTUFRFcyB3aXRoaW4gdGhpcworICogICAgICAgICAgICAgIHJhbmdlLCB0aGlz IGZ1bmN0aW9uIGNhbiBzbGVlcC4gUmV0dXJuIGZhbHNlIGlmIGJsb2NraW5nIHdhcworICogICAg ICAgICAgICAgIHJlcXVpcmVkIGJ1dCByYW5nZSBpcyBub24tYmxvY2tpbmcKKyAqLworc3RydWN0 IG1tdV9yYW5nZV9ub3RpZmllcl9vcHMgeworCWJvb2wgKCppbnZhbGlkYXRlKShzdHJ1Y3QgbW11 X3JhbmdlX25vdGlmaWVyICptcm4sCisJCQkgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3Jh bmdlICpyYW5nZSwKKwkJCSAgIHVuc2lnbmVkIGxvbmcgY3VyX3NlcSk7Cit9OworCitzdHJ1Y3Qg bW11X3JhbmdlX25vdGlmaWVyIHsKKwlzdHJ1Y3QgaW50ZXJ2YWxfdHJlZV9ub2RlIGludGVydmFs X3RyZWU7CisJY29uc3Qgc3RydWN0IG1tdV9yYW5nZV9ub3RpZmllcl9vcHMgKm9wczsKKwlzdHJ1 Y3QgaGxpc3Rfbm9kZSBkZWZlcnJlZF9pdGVtOworCXVuc2lnbmVkIGxvbmcgaW52YWxpZGF0ZV9z ZXE7CisJc3RydWN0IG1tX3N0cnVjdCAqbW07Cit9OworCiAjaWZkZWYgQ09ORklHX01NVV9OT1RJ RklFUgogCiAjaWZkZWYgQ09ORklHX0xPQ0tERVAKQEAgLTI2Myw2ICsyODksNzggQEAgZXh0ZXJu IGludCBfX21tdV9ub3RpZmllcl9yZWdpc3RlcihzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwKIAkJ CQkgICBzdHJ1Y3QgbW1fc3RydWN0ICptbSk7CiBleHRlcm4gdm9pZCBtbXVfbm90aWZpZXJfdW5y ZWdpc3RlcihzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwKIAkJCQkgICAgc3RydWN0IG1tX3N0cnVj dCAqbW0pOworCit1bnNpZ25lZCBsb25nIG1tdV9yYW5nZV9yZWFkX2JlZ2luKHN0cnVjdCBtbXVf cmFuZ2Vfbm90aWZpZXIgKm1ybik7CitpbnQgbW11X3JhbmdlX25vdGlmaWVyX2luc2VydChzdHJ1 Y3QgbW11X3JhbmdlX25vdGlmaWVyICptcm4sCisJCQkgICAgICB1bnNpZ25lZCBsb25nIHN0YXJ0 LCB1bnNpZ25lZCBsb25nIGxlbmd0aCwKKwkJCSAgICAgIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKTsK K2ludCBtbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0X2xvY2tlZChzdHJ1Y3QgbW11X3JhbmdlX25v dGlmaWVyICptcm4sCisJCQkJICAgICB1bnNpZ25lZCBsb25nIHN0YXJ0LCB1bnNpZ25lZCBsb25n IGxlbmd0aCwKKwkJCQkgICAgIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKTsKK3ZvaWQgbW11X3Jhbmdl X25vdGlmaWVyX3JlbW92ZShzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyICptcm4pOworCisvKioK KyAqIG1tdV9yYW5nZV9zZXRfc2VxIC0gU2F2ZSB0aGUgaW52YWxpZGF0aW9uIHNlcXVlbmNlCisg KiBAbXJuIC0gVGhlIG1ybiBwYXNzZWQgdG8gaW52YWxpZGF0ZQorICogQGN1cl9zZXEgLSBUaGUg Y3VyX3NlcSBwYXNzZWQgdG8gaW52YWxpZGF0ZQorICoKKyAqIFRoaXMgbXVzdCBiZSBjYWxsZWQg dW5jb25kaXRpb25hbGx5IGZyb20gdGhlIGludmFsaWRhdGUgY2FsbGJhY2sgb2YgYQorICogc3Ry dWN0IG1tdV9yYW5nZV9ub3RpZmllcl9vcHMgdW5kZXIgdGhlIHNhbWUgbG9jayB0aGF0IGlzIHVz ZWQgdG8gY2FsbAorICogbW11X3JhbmdlX3JlYWRfcmV0cnkoKS4gSXQgdXBkYXRlcyB0aGUgc2Vx dWVuY2UgbnVtYmVyIGZvciBsYXRlciB1c2UgYnkKKyAqIG1tdV9yYW5nZV9yZWFkX3JldHJ5KCku CisgKgorICogSWYgdGhlIHVzZXIgZG9lcyBub3QgY2FsbCBtbXVfcmFuZ2VfcmVhZF9iZWdpbigp IG9yIG1tdV9yYW5nZV9yZWFkX3JldHJ5KCkKKyAqIHRoZW4gdGhpcyBjYWxsIGlzIG5vdCByZXF1 aXJlZC4KKyAqLworc3RhdGljIGlubGluZSB2b2lkIG1tdV9yYW5nZV9zZXRfc2VxKHN0cnVjdCBt bXVfcmFuZ2Vfbm90aWZpZXIgKm1ybiwKKwkJCQkgICAgIHVuc2lnbmVkIGxvbmcgY3VyX3NlcSkK K3sKKwlXUklURV9PTkNFKG1ybi0+aW52YWxpZGF0ZV9zZXEsIGN1cl9zZXEpOworfQorCisvKioK KyAqIG1tdV9yYW5nZV9yZWFkX3JldHJ5IC0gRW5kIGEgcmVhZCBzaWRlIGNyaXRpY2FsIHNlY3Rp b24gYWdhaW5zdCBhIFZBIHJhbmdlCisgKiBtcm46IFRoZSByYW5nZSB1bmRlciBsb2NrCisgKiBz ZXE6IFRoZSByZXR1cm4gb2YgdGhlIHBhaXJlZCBtbXVfcmFuZ2VfcmVhZF9iZWdpbigpCisgKgor ICogVGhpcyBNVVNUIGJlIGNhbGxlZCB1bmRlciBhIHVzZXIgcHJvdmlkZWQgbG9jayB0aGF0IGlz IGFsc28gaGVsZAorICogdW5jb25kaXRpb25hbGx5IGJ5IG9wLT5pbnZhbGlkYXRlKCkgd2hlbiBp dCBjYWxscyBtbXVfcmFuZ2Vfc2V0X3NlcSgpLgorICoKKyAqIEVhY2ggY2FsbCBzaG91bGQgYmUg cGFpcmVkIHdpdGggYSBzaW5nbGUgbW11X3JhbmdlX3JlYWRfYmVnaW4oKSBhbmQKKyAqIHNob3Vs ZCBiZSB1c2VkIHRvIGNvbmNsdWRlIHRoZSByZWFkIHNpZGUuCisgKgorICogUmV0dXJucyB0cnVl IGlmIGFuIGludmFsaWRhdGlvbiBjb2xsaWRlZCB3aXRoIHRoaXMgY3JpdGljYWwgc2VjdGlvbiwg YW5kCisgKiB0aGUgY2FsbGVyIHNob3VsZCByZXRyeS4KKyAqLworc3RhdGljIGlubGluZSBib29s IG1tdV9yYW5nZV9yZWFkX3JldHJ5KHN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXIgKm1ybiwKKwkJ CQkJdW5zaWduZWQgbG9uZyBzZXEpCit7CisJcmV0dXJuIG1ybi0+aW52YWxpZGF0ZV9zZXEgIT0g c2VxOworfQorCisvKioKKyAqIG1tdV9yYW5nZV9jaGVja19yZXRyeSAtIFRlc3QgaWYgYSBjb2xs aXNpb24gaGFzIG9jY3VycmVkCisgKiBtcm46IFRoZSByYW5nZSB1bmRlciBsb2NrCisgKiBzZXE6 IFRoZSByZXR1cm4gb2YgdGhlIG1hdGNoaW5nIG1tdV9yYW5nZV9yZWFkX2JlZ2luKCkKKyAqCisg KiBUaGlzIGNhbiBiZSB1c2VkIGluIHRoZSBjcml0aWNhbCBzZWN0aW9uIGJldHdlZW4gbW11X3Jh bmdlX3JlYWRfYmVnaW4oKSBhbmQKKyAqIG1tdV9yYW5nZV9yZWFkX3JldHJ5KCkuICBBIHJldHVy biBvZiB0cnVlIGluZGljYXRlcyBhbiBpbnZhbGlkYXRpb24gaGFzCisgKiBjb2xsaWRlZCB3aXRo IHRoaXMgbG9jayBhbmQgYSBmdXR1cmUgbW11X3JhbmdlX3JlYWRfcmV0cnkoKSB3aWxsIHJldHVy bgorICogdHJ1ZS4KKyAqCisgKiBGYWxzZSBpcyBub3QgcmVsaWFibGUgYW5kIG9ubHkgc3VnZ2Vz dHMgYSBjb2xsaXNpb24gaGFzIG5vdCBoYXBwZW5lZC4gSXQKKyAqIGNhbiBiZSBjYWxsZWQgbWFu eSB0aW1lcyBhbmQgZG9lcyBub3QgaGF2ZSB0byBob2xkIHRoZSB1c2VyIHByb3ZpZGVkIGxvY2su CisgKgorICogVGhpcyBjYWxsIGNhbiBiZSB1c2VkIGFzIHBhcnQgb2YgbG9vcHMgYW5kIG90aGVy IGV4cGVuc2l2ZSBvcGVyYXRpb25zIHRvCisgKiBleHBlZGl0ZSBhIHJldHJ5LgorICovCitzdGF0 aWMgaW5saW5lIGJvb2wgbW11X3JhbmdlX2NoZWNrX3JldHJ5KHN0cnVjdCBtbXVfcmFuZ2Vfbm90 aWZpZXIgKm1ybiwKKwkJCQkJIHVuc2lnbmVkIGxvbmcgc2VxKQoreworCS8qIFBhaXJzIHdpdGgg dGhlIFdSSVRFX09OQ0UgaW4gbW11X3JhbmdlX3NldF9zZXEoKSAqLworCXJldHVybiBSRUFEX09O Q0UobXJuLT5pbnZhbGlkYXRlX3NlcSkgIT0gc2VxOworfQorCiBleHRlcm4gdm9pZCBfX21tdV9u b3RpZmllcl9tbV9kZXN0cm95KHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKTsKIGV4dGVybiB2b2lkIF9f bW11X25vdGlmaWVyX3JlbGVhc2Uoc3RydWN0IG1tX3N0cnVjdCAqbW0pOwogZXh0ZXJuIGludCBf X21tdV9ub3RpZmllcl9jbGVhcl9mbHVzaF95b3VuZyhzdHJ1Y3QgbW1fc3RydWN0ICptbSwKZGlm ZiAtLWdpdCBhL21tL0tjb25maWcgYi9tbS9LY29uZmlnCmluZGV4IGE1ZGFlOWE3ZWI1MTBhLi5k MGI1MDQ2ZDlhZWZmZCAxMDA2NDQKLS0tIGEvbW0vS2NvbmZpZworKysgYi9tbS9LY29uZmlnCkBA IC0yODQsNiArMjg0LDcgQEAgY29uZmlnIFZJUlRfVE9fQlVTCiBjb25maWcgTU1VX05PVElGSUVS CiAJYm9vbAogCXNlbGVjdCBTUkNVCisJc2VsZWN0IElOVEVSVkFMX1RSRUUKIAogY29uZmlnIEtT TQogCWJvb2wgIkVuYWJsZSBLU00gZm9yIHBhZ2UgbWVyZ2luZyIKZGlmZiAtLWdpdCBhL21tL21t dV9ub3RpZmllci5jIGIvbW0vbW11X25vdGlmaWVyLmMKaW5kZXggMzY3NjcwY2ZkMDJiN2IuLmQw MmQzYzhjMjIzZWI3IDEwMDY0NAotLS0gYS9tbS9tbXVfbm90aWZpZXIuYworKysgYi9tbS9tbXVf bm90aWZpZXIuYwpAQCAtMTIsNiArMTIsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2V4cG9ydC5oPgog I2luY2x1ZGUgPGxpbnV4L21tLmg+CiAjaW5jbHVkZSA8bGludXgvZXJyLmg+CisjaW5jbHVkZSA8 bGludXgvaW50ZXJ2YWxfdHJlZS5oPgogI2luY2x1ZGUgPGxpbnV4L3NyY3UuaD4KICNpbmNsdWRl IDxsaW51eC9yY3VwZGF0ZS5oPgogI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CkBAIC0zNiwxMCAr MzcsMjQzIEBAIHN0cnVjdCBsb2NrZGVwX21hcCBfX21tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3Jh bmdlX3N0YXJ0X21hcCA9IHsKIHN0cnVjdCBtbXVfbm90aWZpZXJfbW0gewogCS8qIGFsbCBtbXUg bm90aWZpZXJzIHJlZ2lzdGVyZWQgaW4gdGhpcyBtbSBhcmUgcXVldWVkIGluIHRoaXMgbGlzdCAq LwogCXN0cnVjdCBobGlzdF9oZWFkIGxpc3Q7CisJYm9vbCBoYXNfaW50ZXJ2YWw7CiAJLyogdG8g c2VyaWFsaXplIHRoZSBsaXN0IG1vZGlmaWNhdGlvbnMgYW5kIGhsaXN0X3VuaGFzaGVkICovCiAJ c3BpbmxvY2tfdCBsb2NrOworCXVuc2lnbmVkIGxvbmcgaW52YWxpZGF0ZV9zZXE7CisJdW5zaWdu ZWQgbG9uZyBhY3RpdmVfaW52YWxpZGF0ZV9yYW5nZXM7CisJc3RydWN0IHJiX3Jvb3RfY2FjaGVk IGl0cmVlOworCXdhaXRfcXVldWVfaGVhZF90IHdxOworCXN0cnVjdCBobGlzdF9oZWFkIGRlZmVy cmVkX2xpc3Q7CiB9OwogCisvKgorICogVGhpcyBpcyBhIGNvbGxpc2lvbi1yZXRyeSByZWFkLXNp ZGUvd3JpdGUtc2lkZSAnbG9jaycsIGEgbG90IGxpa2UgYQorICogc2VxY291bnQsIGhvd2V2ZXIg dGhpcyBhbGxvd3MgbXVsdGlwbGUgd3JpdGUtc2lkZXMgdG8gaG9sZCBpdCBhdAorICogb25jZS4g Q29uY2VwdHVhbGx5IHRoZSB3cml0ZSBzaWRlIGlzIHByb3RlY3RpbmcgdGhlIHZhbHVlcyBvZiB0 aGUgUFRFcyBpbgorICogdGhpcyBtbSwgc3VjaCB0aGF0IFBURVMgY2Fubm90IGJlIHJlYWQgaW50 byBTUFRFcyB3aGlsZSBhbnkgd3JpdGVyIGV4aXN0cy4KKyAqCisgKiBOb3RlIHRoYXQgdGhlIGNv cmUgbW0gY3JlYXRlcyBuZXN0ZWQgaW52YWxpZGF0ZV9yYW5nZV9zdGFydCgpL2VuZCgpIHJlZ2lv bnMKKyAqIHdpdGhpbiB0aGUgc2FtZSB0aHJlYWQsIGFuZCBydW5zIGludmFsaWRhdGVfcmFuZ2Vf c3RhcnQoKS9lbmQoKSBpbiBwYXJhbGxlbAorICogb24gbXVsdGlwbGUgQ1BVcy4gVGhpcyBpcyBk ZXNpZ25lZCB0byBub3QgcmVkdWNlIGNvbmN1cnJlbmN5IG9yIGJsb2NrCisgKiBwcm9ncmVzcyBv biB0aGUgbW0gc2lkZS4KKyAqCisgKiBBcyBhIHNlY29uZGFyeSBmdW5jdGlvbiwgaG9sZGluZyB0 aGUgZnVsbCB3cml0ZSBzaWRlIGFsc28gc2VydmVzIHRvIHByZXZlbnQKKyAqIHdyaXRlcnMgZm9y IHRoZSBpdHJlZSwgdGhpcyBpcyBhbiBvcHRpbWl6YXRpb24gdG8gYXZvaWQgZXh0cmEgbG9ja2lu ZworICogZHVyaW5nIGludmFsaWRhdGVfcmFuZ2Vfc3RhcnQvZW5kIG5vdGlmaWVycy4KKyAqCisg KiBUaGUgd3JpdGUgc2lkZSBoYXMgdHdvIHN0YXRlcywgZnVsbHkgZXhjbHVkZWQ6CisgKiAgLSBt bS0+YWN0aXZlX2ludmFsaWRhdGVfcmFuZ2VzICE9IDAKKyAqICAtIG1ubi0+aW52YWxpZGF0ZV9z ZXEgJiAxID09IFRydWUKKyAqICAtIHNvbWUgcmFuZ2Ugb24gdGhlIG1tX3N0cnVjdCBpcyBiZWlu ZyBpbnZhbGlkYXRlZAorICogIC0gdGhlIGl0cmVlIGlzIG5vdCBhbGxvd2VkIHRvIGNoYW5nZQor ICoKKyAqIEFuZCBwYXJ0aWFsbHkgZXhjbHVkZWQ6CisgKiAgLSBtbS0+YWN0aXZlX2ludmFsaWRh dGVfcmFuZ2VzICE9IDAKKyAqICAtIHNvbWUgcmFuZ2Ugb24gdGhlIG1tX3N0cnVjdCBpcyBiZWlu ZyBpbnZhbGlkYXRlZAorICogIC0gdGhlIGl0cmVlIGlzIGFsbG93ZWQgdG8gY2hhbmdlCisgKgor ICogVGhlIGxhdGVyIHN0YXRlIGF2b2lkcyBzb21lIGV4cGVuc2l2ZSB3b3JrIG9uIGludl9lbmQg aW4gdGhlIGNvbW1vbiBjYXNlIG9mCisgKiBubyBtcm4gbW9uaXRvcmluZyB0aGUgVkEuCisgKi8K K3N0YXRpYyBib29sIG1uX2l0cmVlX2lzX2ludmFsaWRhdGluZyhzdHJ1Y3QgbW11X25vdGlmaWVy X21tICptbW5fbW0pCit7CisJbG9ja2RlcF9hc3NlcnRfaGVsZCgmbW1uX21tLT5sb2NrKTsKKwly ZXR1cm4gbW1uX21tLT5pbnZhbGlkYXRlX3NlcSAmIDE7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgbW11 X3JhbmdlX25vdGlmaWVyICoKK21uX2l0cmVlX2ludl9zdGFydF9yYW5nZShzdHJ1Y3QgbW11X25v dGlmaWVyX21tICptbW5fbW0sCisJCQkgY29uc3Qgc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAq cmFuZ2UsCisJCQkgdW5zaWduZWQgbG9uZyAqc2VxKQoreworCXN0cnVjdCBpbnRlcnZhbF90cmVl X25vZGUgKm5vZGU7CisJc3RydWN0IG1tdV9yYW5nZV9ub3RpZmllciAqcmVzID0gTlVMTDsKKwor CXNwaW5fbG9jaygmbW1uX21tLT5sb2NrKTsKKwltbW5fbW0tPmFjdGl2ZV9pbnZhbGlkYXRlX3Jh bmdlcysrOworCW5vZGUgPSBpbnRlcnZhbF90cmVlX2l0ZXJfZmlyc3QoJm1tbl9tbS0+aXRyZWUs IHJhbmdlLT5zdGFydCwKKwkJCQkJcmFuZ2UtPmVuZCAtIDEpOworCWlmIChub2RlKSB7CisJCW1t bl9tbS0+aW52YWxpZGF0ZV9zZXEgfD0gMTsKKwkJcmVzID0gY29udGFpbmVyX29mKG5vZGUsIHN0 cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXIsCisJCQkJICAgaW50ZXJ2YWxfdHJlZSk7CisJfQorCisJ KnNlcSA9IG1tbl9tbS0+aW52YWxpZGF0ZV9zZXE7CisJc3Bpbl91bmxvY2soJm1tbl9tbS0+bG9j ayk7CisJcmV0dXJuIHJlczsKK30KKworc3RhdGljIHN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXIg KgorbW5faXRyZWVfaW52X25leHQoc3RydWN0IG1tdV9yYW5nZV9ub3RpZmllciAqbXJuLAorCQkg IGNvbnN0IHN0cnVjdCBtbXVfbm90aWZpZXJfcmFuZ2UgKnJhbmdlKQoreworCXN0cnVjdCBpbnRl cnZhbF90cmVlX25vZGUgKm5vZGU7CisKKwlub2RlID0gaW50ZXJ2YWxfdHJlZV9pdGVyX25leHQo Jm1ybi0+aW50ZXJ2YWxfdHJlZSwgcmFuZ2UtPnN0YXJ0LAorCQkJCSAgICAgICByYW5nZS0+ZW5k IC0gMSk7CisJaWYgKCFub2RlKQorCQlyZXR1cm4gTlVMTDsKKwlyZXR1cm4gY29udGFpbmVyX29m KG5vZGUsIHN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXIsIGludGVydmFsX3RyZWUpOworfQorCitz dGF0aWMgdm9pZCBtbl9pdHJlZV9pbnZfZW5kKHN0cnVjdCBtbXVfbm90aWZpZXJfbW0gKm1tbl9t bSkKK3sKKwlzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyICptcm47CisJc3RydWN0IGhsaXN0X25v ZGUgKm5leHQ7CisJYm9vbCBuZWVkX3dha2UgPSBmYWxzZTsKKworCXNwaW5fbG9jaygmbW1uX21t LT5sb2NrKTsKKwlpZiAoLS1tbW5fbW0tPmFjdGl2ZV9pbnZhbGlkYXRlX3JhbmdlcyB8fAorCSAg ICAhbW5faXRyZWVfaXNfaW52YWxpZGF0aW5nKG1tbl9tbSkpIHsKKwkJc3Bpbl91bmxvY2soJm1t bl9tbS0+bG9jayk7CisJCXJldHVybjsKKwl9CisKKwltbW5fbW0tPmludmFsaWRhdGVfc2VxKys7 CisJbmVlZF93YWtlID0gdHJ1ZTsKKworCS8qCisJICogVGhlIGludl9lbmQgaW5jb3Jwb3JhdGVz IGEgZGVmZXJyZWQgbWVjaGFuaXNtIGxpa2UKKwkgKiBydG5sX2xvY2soKS4gQWRkcyBhbmQgcmVt b3ZlcyBhcmUgcXVldWVkIHVudGlsIHRoZSBmaW5hbCBpbnZfZW5kCisJICogaGFwcGVucyB0aGVu IHRoZXkgYXJlIHByb2dyZXNzZWQuIFRoaXMgYXJyYW5nZW1lbnQgZm9yIHRyZWUgdXBkYXRlcwor CSAqIGlzIHVzZWQgdG8gYXZvaWQgdXNpbmcgYSBibG9ja2luZyBsb2NrIGR1cmluZworCSAqIGlu dmFsaWRhdGVfcmFuZ2Vfc3RhcnQuCisJICovCisJaGxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZSht cm4sIG5leHQsICZtbW5fbW0tPmRlZmVycmVkX2xpc3QsCisJCQkJICBkZWZlcnJlZF9pdGVtKSB7 CisJCWlmIChSQl9FTVBUWV9OT0RFKCZtcm4tPmludGVydmFsX3RyZWUucmIpKQorCQkJaW50ZXJ2 YWxfdHJlZV9pbnNlcnQoJm1ybi0+aW50ZXJ2YWxfdHJlZSwKKwkJCQkJICAgICAmbW1uX21tLT5p dHJlZSk7CisJCWVsc2UKKwkJCWludGVydmFsX3RyZWVfcmVtb3ZlKCZtcm4tPmludGVydmFsX3Ry ZWUsCisJCQkJCSAgICAgJm1tbl9tbS0+aXRyZWUpOworCQlobGlzdF9kZWwoJm1ybi0+ZGVmZXJy ZWRfaXRlbSk7CisJfQorCXNwaW5fdW5sb2NrKCZtbW5fbW0tPmxvY2spOworCisJLyoKKwkgKiBU T0RPOiBTaW5jZSB3ZSBhbHJlYWR5IGhhdmUgYSBzcGlubG9jayBhYm92ZSwgdGhpcyB3b3VsZCBi ZSBmYXN0ZXIKKwkgKiBhcyB3YWtlX3VwX3EKKwkgKi8KKwlpZiAobmVlZF93YWtlKQorCQl3YWtl X3VwX2FsbCgmbW1uX21tLT53cSk7Cit9CisKKy8qKgorICogbW11X3JhbmdlX3JlYWRfYmVnaW4g LSBCZWdpbiBhIHJlYWQgc2lkZSBjcml0aWNhbCBzZWN0aW9uIGFnYWluc3QgYSBWQSByYW5nZQor ICogbXJuOiBUaGUgcmFuZ2UgdG8gbG9jaworICoKKyAqIG1tdV9yYW5nZV9yZWFkX2JlZ2luKCkv bW11X3JhbmdlX3JlYWRfcmV0cnkoKSBpbXBsZW1lbnQgYSBjb2xsaXNpb24tcmV0cnkKKyAqIGxv Y2tpbmcgc2NoZW1lIHNpbWlsYXIgdG8gc2VxY291bnQgZm9yIHRoZSBWQSByYW5nZSB1bmRlciBt cm4uIElmIHRoZSBtbQorICogaW52b2tlcyBpbnZhbGlkYXRpb24gZHVyaW5nIHRoZSBjcml0aWNh bCBzZWN0aW9uIHRoZW4KKyAqIG1tdV9yYW5nZV9yZWFkX3JldHJ5KCkgd2lsbCByZXR1cm4gdHJ1 ZS4KKyAqCisgKiBUaGlzIGlzIHVzZWZ1bCB0byBvYnRhaW4gc2hhZG93IFBURXMgd2hlcmUgdGVh cmRvd24gb3Igc2V0dXAgb2YgdGhlIFNQVEVzCisgKiByZXF1aXJlIGEgYmxvY2tpbmcgY29udGV4 dC4gIFRoZSBjcml0aWNhbCByZWdpb24gZm9ybWVkIGJ5IHRoaXMgbG9jayBjYW4KKyAqIHNsZWVw LCBhbmQgdGhlIHJlcXVpcmVkICd1c2VyX2xvY2snIGNhbiBhbHNvIGJlIGEgc2xlZXBpbmcgbG9j ay4KKyAqCisgKiBUaGUgY2FsbGVyIGlzIHJlcXVpcmVkIHRvIHByb3ZpZGUgYSAndXNlcl9sb2Nr JyB0byBzZXJpYWxpemUgYm90aCB0ZWFyZG93bgorICogYW5kIHNldHVwLgorICoKKyAqIFRoZSBy ZXR1cm4gdmFsdWUgc2hvdWxkIGJlIHBhc3NlZCB0byBtbXVfcmFuZ2VfcmVhZF9yZXRyeSgpLgor ICovCit1bnNpZ25lZCBsb25nIG1tdV9yYW5nZV9yZWFkX2JlZ2luKHN0cnVjdCBtbXVfcmFuZ2Vf bm90aWZpZXIgKm1ybikKK3sKKwlzdHJ1Y3QgbW11X25vdGlmaWVyX21tICptbW5fbW0gPSBtcm4t Pm1tLT5tbXVfbm90aWZpZXJfbW07CisJdW5zaWduZWQgbG9uZyBzZXE7CisJYm9vbCBpc19pbnZh bGlkYXRpbmc7CisKKwkvKgorCSAqIElmIHRoZSBtcm4gaGFzIGEgZGlmZmVyZW50IHNlcSB2YWx1 ZSB1bmRlciB0aGUgdXNlcl9sb2NrIHRoYW4gd2UKKwkgKiBzdGFydGVkIHdpdGggdGhlbiBpdCBo YXMgY29sbGlkZWQuCisJICoKKwkgKiBJZiB0aGUgbXJuIGN1cnJlbnRseSBoYXMgdGhlIHNhbWUg c2VxIHZhbHVlIGFzIHRoZSBtbW5fbW0gc2VxLCB0aGVuCisJICogaXQgaXMgY3VycmVudGx5IGJl dHdlZW4gaW52YWxpZGF0ZV9zdGFydC9lbmQgYW5kIGlzIGNvbGxpZGluZy4KKwkgKgorCSAqIFRo ZSBsb2NraW5nIGxvb2tzIGJyb2FkbHkgbGlrZSB0aGlzOgorCSAqICAgbW5fdHJlZV9pbnZhbGlk YXRlX3N0YXJ0KCk6ICAgICAgICAgIG1tdV9yYW5nZV9yZWFkX2JlZ2luKCk6CisJICogICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNwaW5fbG9jaworCSAqICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc2VxID0gUkVBRF9PTkNFKG1ybi0+aW52 YWxpZGF0ZV9zZXEpOworCSAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgc2VxID09IG1tbl9tbS0+aW52YWxpZGF0ZV9zZXEKKwkgKiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgc3Bpbl91bmxvY2sKKwkgKiAgICBzcGluX2xvY2sKKwkgKiAg ICAgc2VxID0gKyttbW5fbW0tPmludmFsaWRhdGVfc2VxCisJICogICAgc3Bpbl91bmxvY2sKKwkg KiAgICAgb3AtPmludmFsaWRhdGVfcmFuZ2UoKToKKwkgKiAgICAgICB1c2VyX2xvY2sKKwkgKiAg ICAgICAgbW11X3JhbmdlX3NldF9zZXEoKQorCSAqICAgICAgICAgbXJuLT5pbnZhbGlkYXRlX3Nl cSA9IHNlcQorCSAqICAgICAgIHVzZXJfdW5sb2NrCisJICoKKwkgKiAgICAgICAgICAgICAgICAg ICAgICAgICAgW1JlcXVpcmVkOiBtbXVfcmFuZ2VfcmVhZF9yZXRyeSgpID09IHRydWVdCisJICoK KwkgKiAgIG1uX2l0cmVlX2ludl9lbmQoKToKKwkgKiAgICBzcGluX2xvY2sKKwkgKiAgICAgc2Vx ID0gKyttbW5fbW0tPmludmFsaWRhdGVfc2VxCisJICogICAgc3Bpbl91bmxvY2sKKwkgKgorCSAq ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVzZXJfbG9jaworCSAqICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtbXVfcmFuZ2VfcmVhZF9yZXRy eSgpOgorCSAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbXJuLT5p bnZhbGlkYXRlX3NlcSAhPSBzZXEKKwkgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB1c2VyX3VubG9jaworCSAqCisJICogQmFycmllcnMgYXJlIG5vdCBuZWVkZWQgaGVy ZSBhcyBhbnkgcmFjZXMgaGVyZSBhcmUgY2xvc2VkIGJ5IGFuCisJICogZXZlbnR1YWwgbW11X3Jh bmdlX3JlYWRfcmV0cnkoKSwgd2hpY2ggcHJvdmlkZXMgYSBiYXJyaWVyIHZpYSB0aGUKKwkgKiB1 c2VyX2xvY2suCisJICovCisJc3Bpbl9sb2NrKCZtbW5fbW0tPmxvY2spOworCS8qIFBhaXJzIHdp dGggdGhlIFdSSVRFX09OQ0UgaW4gbW11X3JhbmdlX3NldF9zZXEoKSAqLworCXNlcSA9IFJFQURf T05DRShtcm4tPmludmFsaWRhdGVfc2VxKTsKKwlpc19pbnZhbGlkYXRpbmcgPSBzZXEgPT0gbW1u X21tLT5pbnZhbGlkYXRlX3NlcTsKKwlzcGluX3VubG9jaygmbW1uX21tLT5sb2NrKTsKKworCS8q CisJICogbXJuLT5pbnZhbGlkYXRlX3NlcSBpcyBhbHdheXMgc2V0IHRvIGFuIG9kZCB2YWx1ZS4g VGhpcyBlbnN1cmVzCisJICogdGhhdCBpZiBzZXEgZG9lcyB3cmFwIHdlIHdpbGwgYWx3YXlzIGNs ZWFyIHRoZSBiZWxvdyBzbGVlcCBpbiBzb21lCisJICogcmVhc29uYWJsZSB0aW1lIGFzIG1tbl9t bS0+aW52YWxpZGF0ZV9zZXEgaXMgZXZlbiBpbiB0aGUgaWRsZQorCSAqIHN0YXRlLgorCSAqLwor CWxvY2tfbWFwX2FjcXVpcmUoJl9fbW11X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnRf bWFwKTsKKwlsb2NrX21hcF9yZWxlYXNlKCZfX21tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3Jhbmdl X3N0YXJ0X21hcCk7CisJaWYgKGlzX2ludmFsaWRhdGluZykKKwkJd2FpdF9ldmVudChtbW5fbW0t PndxLAorCQkJICAgUkVBRF9PTkNFKG1tbl9tbS0+aW52YWxpZGF0ZV9zZXEpICE9IHNlcSk7CisK KwkvKgorCSAqIE5vdGljZSB0aGF0IG1tdV9yYW5nZV9yZWFkX3JldHJ5KCkgY2FuIGFscmVhZHkg YmUgdHJ1ZSBhdCB0aGlzCisJICogcG9pbnQsIGF2b2lkaW5nIGxvb3BzIGhlcmUgYWxsb3dzIHRo ZSB1c2VyIG9mIHRoaXMgbG9jayB0byBwcm92aWRlCisJICogYSBnbG9iYWwgdGltZSBib3VuZC4K KwkgKi8KKworCXJldHVybiBzZXE7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChtbXVfcmFuZ2VfcmVh ZF9iZWdpbik7CisKK3N0YXRpYyB2b2lkIG1uX2l0cmVlX3JlbGVhc2Uoc3RydWN0IG1tdV9ub3Rp Zmllcl9tbSAqbW1uX21tLAorCQkJICAgICBzdHJ1Y3QgbW1fc3RydWN0ICptbSkKK3sKKwlzdHJ1 Y3QgbW11X25vdGlmaWVyX3JhbmdlIHJhbmdlID0geworCQkuZmxhZ3MgPSBNTVVfTk9USUZJRVJf UkFOR0VfQkxPQ0tBQkxFLAorCQkuZXZlbnQgPSBNTVVfTk9USUZZX1JFTEVBU0UsCisJCS5tbSA9 IG1tLAorCQkuc3RhcnQgPSAwLAorCQkuZW5kID0gVUxPTkdfTUFYLAorCX07CisJc3RydWN0IG1t dV9yYW5nZV9ub3RpZmllciAqbXJuOworCXVuc2lnbmVkIGxvbmcgY3VyX3NlcTsKKwlib29sIHJl dDsKKworCWZvciAobXJuID0gbW5faXRyZWVfaW52X3N0YXJ0X3JhbmdlKG1tbl9tbSwgJnJhbmdl LCAmY3VyX3NlcSk7IG1ybjsKKwkgICAgIG1ybiA9IG1uX2l0cmVlX2ludl9uZXh0KG1ybiwgJnJh bmdlKSkgeworCQlyZXQgPSBtcm4tPm9wcy0+aW52YWxpZGF0ZShtcm4sICZyYW5nZSwgY3VyX3Nl cSk7CisJCVdBUk5fT04oIXJldCk7CisJfQorCisJbW5faXRyZWVfaW52X2VuZChtbW5fbW0pOwor fQorCiAvKgogICogVGhpcyBmdW5jdGlvbiBjYW4ndCBydW4gY29uY3VycmVudGx5IGFnYWluc3Qg bW11X25vdGlmaWVyX3JlZ2lzdGVyCiAgKiBiZWNhdXNlIG1tLT5tbV91c2VycyA+IDAgZHVyaW5n IG1tdV9ub3RpZmllcl9yZWdpc3RlciBhbmQgZXhpdF9tbWFwCkBAIC01MiwxNyArMjg2LDI0IEBA IHN0cnVjdCBtbXVfbm90aWZpZXJfbW0gewogICogY2FuJ3QgZ28gYXdheSBmcm9tIHVuZGVyIHVz IGFzIGV4aXRfbW1hcCBob2xkcyBhbiBtbV9jb3VudCBwaW4KICAqIGl0c2VsZi4KICAqLwotdm9p ZCBfX21tdV9ub3RpZmllcl9yZWxlYXNlKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQorc3RhdGljIHZv aWQgbW5faGxpc3RfcmVsZWFzZShzdHJ1Y3QgbW11X25vdGlmaWVyX21tICptbW5fbW0sCisJCQkg ICAgIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQogewogCXN0cnVjdCBtbXVfbm90aWZpZXIgKm1uOwog CWludCBpZDsKIAorCWlmIChtbW5fbW0tPmhhc19pbnRlcnZhbCkKKwkJbW5faXRyZWVfcmVsZWFz ZShtbW5fbW0sIG1tKTsKKworCWlmIChobGlzdF9lbXB0eSgmbW1uX21tLT5saXN0KSkKKwkJcmV0 dXJuOworCiAJLyoKIAkgKiBTUkNVIGhlcmUgd2lsbCBibG9jayBtbXVfbm90aWZpZXJfdW5yZWdp c3RlciB1bnRpbAogCSAqIC0+cmVsZWFzZSByZXR1cm5zLgogCSAqLwogCWlkID0gc3JjdV9yZWFk X2xvY2soJnNyY3UpOwotCWhsaXN0X2Zvcl9lYWNoX2VudHJ5X3JjdShtbiwgJm1tLT5tbXVfbm90 aWZpZXJfbW0tPmxpc3QsIGhsaXN0KQorCWhsaXN0X2Zvcl9lYWNoX2VudHJ5X3JjdShtbiwgJm1t bl9tbS0+bGlzdCwgaGxpc3QpCiAJCS8qCiAJCSAqIElmIC0+cmVsZWFzZSBydW5zIGJlZm9yZSBt bXVfbm90aWZpZXJfdW5yZWdpc3RlciBpdCBtdXN0IGJlCiAJCSAqIGhhbmRsZWQsIGFzIGl0J3Mg dGhlIG9ubHkgd2F5IGZvciB0aGUgZHJpdmVyIHRvIGZsdXNoIGFsbApAQCAtNzIsOSArMzEzLDkg QEAgdm9pZCBfX21tdV9ub3RpZmllcl9yZWxlYXNlKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQogCQlp ZiAobW4tPm9wcy0+cmVsZWFzZSkKIAkJCW1uLT5vcHMtPnJlbGVhc2UobW4sIG1tKTsKIAotCXNw aW5fbG9jaygmbW0tPm1tdV9ub3RpZmllcl9tbS0+bG9jayk7Ci0Jd2hpbGUgKHVubGlrZWx5KCFo bGlzdF9lbXB0eSgmbW0tPm1tdV9ub3RpZmllcl9tbS0+bGlzdCkpKSB7Ci0JCW1uID0gaGxpc3Rf ZW50cnkobW0tPm1tdV9ub3RpZmllcl9tbS0+bGlzdC5maXJzdCwKKwlzcGluX2xvY2soJm1tbl9t bS0+bG9jayk7CisJd2hpbGUgKHVubGlrZWx5KCFobGlzdF9lbXB0eSgmbW1uX21tLT5saXN0KSkp IHsKKwkJbW4gPSBobGlzdF9lbnRyeShtbW5fbW0tPmxpc3QuZmlyc3QsCiAJCQkJIHN0cnVjdCBt bXVfbm90aWZpZXIsCiAJCQkJIGhsaXN0KTsKIAkJLyoKQEAgLTg1LDcgKzMyNiw3IEBAIHZvaWQg X19tbXVfbm90aWZpZXJfcmVsZWFzZShzdHJ1Y3QgbW1fc3RydWN0ICptbSkKIAkJICovCiAJCWhs aXN0X2RlbF9pbml0X3JjdSgmbW4tPmhsaXN0KTsKIAl9Ci0Jc3Bpbl91bmxvY2soJm1tLT5tbXVf bm90aWZpZXJfbW0tPmxvY2spOworCXNwaW5fdW5sb2NrKCZtbW5fbW0tPmxvY2spOwogCXNyY3Vf cmVhZF91bmxvY2soJnNyY3UsIGlkKTsKIAogCS8qCkBAIC0xMDAsNiArMzQxLDE3IEBAIHZvaWQg X19tbXVfbm90aWZpZXJfcmVsZWFzZShzdHJ1Y3QgbW1fc3RydWN0ICptbSkKIAlzeW5jaHJvbml6 ZV9zcmN1KCZzcmN1KTsKIH0KIAordm9pZCBfX21tdV9ub3RpZmllcl9yZWxlYXNlKHN0cnVjdCBt bV9zdHJ1Y3QgKm1tKQoreworCXN0cnVjdCBtbXVfbm90aWZpZXJfbW0gKm1tbl9tbSA9IG1tLT5t bXVfbm90aWZpZXJfbW07CisKKwlpZiAobW1uX21tLT5oYXNfaW50ZXJ2YWwpCisJCW1uX2l0cmVl X3JlbGVhc2UobW1uX21tLCBtbSk7CisKKwlpZiAoIWhsaXN0X2VtcHR5KCZtbW5fbW0tPmxpc3Qp KQorCQltbl9obGlzdF9yZWxlYXNlKG1tbl9tbSwgbW0pOworfQorCiAvKgogICogSWYgbm8geW91 bmcgYml0ZmxhZyBpcyBzdXBwb3J0ZWQgYnkgdGhlIGhhcmR3YXJlLCAtPmNsZWFyX2ZsdXNoX3lv dW5nIGNhbgogICogdW5tYXAgdGhlIGFkZHJlc3MgYW5kIHJldHVybiAxIG9yIDAgZGVwZW5kaW5n IGlmIHRoZSBtYXBwaW5nIHByZXZpb3VzbHkKQEAgLTE3MiwxNCArNDI0LDQzIEBAIHZvaWQgX19t bXVfbm90aWZpZXJfY2hhbmdlX3B0ZShzdHJ1Y3QgbW1fc3RydWN0ICptbSwgdW5zaWduZWQgbG9u ZyBhZGRyZXNzLAogCXNyY3VfcmVhZF91bmxvY2soJnNyY3UsIGlkKTsKIH0KIAotaW50IF9fbW11 X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnQoc3RydWN0IG1tdV9ub3RpZmllcl9yYW5n ZSAqcmFuZ2UpCitzdGF0aWMgaW50IG1uX2l0cmVlX2ludmFsaWRhdGUoc3RydWN0IG1tdV9ub3Rp Zmllcl9tbSAqbW1uX21tLAorCQkJCSAgICAgY29uc3Qgc3RydWN0IG1tdV9ub3RpZmllcl9yYW5n ZSAqcmFuZ2UpCit7CisJc3RydWN0IG1tdV9yYW5nZV9ub3RpZmllciAqbXJuOworCXVuc2lnbmVk IGxvbmcgY3VyX3NlcTsKKworCWZvciAobXJuID0gbW5faXRyZWVfaW52X3N0YXJ0X3JhbmdlKG1t bl9tbSwgcmFuZ2UsICZjdXJfc2VxKTsgbXJuOworCSAgICAgbXJuID0gbW5faXRyZWVfaW52X25l eHQobXJuLCByYW5nZSkpIHsKKwkJYm9vbCByZXQ7CisKKwkJcmV0ID0gbXJuLT5vcHMtPmludmFs aWRhdGUobXJuLCByYW5nZSwgY3VyX3NlcSk7CisJCWlmICghcmV0KSB7CisJCQlpZiAoV0FSTl9P TihtbXVfbm90aWZpZXJfcmFuZ2VfYmxvY2thYmxlKHJhbmdlKSkpCisJCQkJY29udGludWU7CisJ CQlnb3RvIG91dF93b3VsZF9ibG9jazsKKwkJfQorCX0KKwlyZXR1cm4gMDsKKworb3V0X3dvdWxk X2Jsb2NrOgorCS8qCisJICogT24gLUVBR0FJTiB0aGUgbm9uLWJsb2NraW5nIGNhbGxlciBpcyBu b3QgYWxsb3dlZCB0byBjYWxsCisJICogaW52YWxpZGF0ZV9yYW5nZV9lbmQoKQorCSAqLworCW1u X2l0cmVlX2ludl9lbmQobW1uX21tKTsKKwlyZXR1cm4gLUVBR0FJTjsKK30KKworc3RhdGljIGlu dCBtbl9obGlzdF9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KHN0cnVjdCBtbXVfbm90aWZpZXJfbW0g Km1tbl9tbSwKKwkJCQkJICAgc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAqcmFuZ2UpCiB7CiAJ c3RydWN0IG1tdV9ub3RpZmllciAqbW47CiAJaW50IHJldCA9IDA7CiAJaW50IGlkOwogCiAJaWQg PSBzcmN1X3JlYWRfbG9jaygmc3JjdSk7Ci0JaGxpc3RfZm9yX2VhY2hfZW50cnlfcmN1KG1uLCAm cmFuZ2UtPm1tLT5tbXVfbm90aWZpZXJfbW0tPmxpc3QsIGhsaXN0KSB7CisJaGxpc3RfZm9yX2Vh Y2hfZW50cnlfcmN1KG1uLCAmbW1uX21tLT5saXN0LCBobGlzdCkgewogCQlpZiAobW4tPm9wcy0+ aW52YWxpZGF0ZV9yYW5nZV9zdGFydCkgewogCQkJaW50IF9yZXQ7CiAKQEAgLTIwMywxNSArNDg0 LDMwIEBAIGludCBfX21tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KHN0cnVjdCBt bXVfbm90aWZpZXJfcmFuZ2UgKnJhbmdlKQogCXJldHVybiByZXQ7CiB9CiAKLXZvaWQgX19tbXVf bm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZV9lbmQoc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAq cmFuZ2UsCi0JCQkJCSBib29sIG9ubHlfZW5kKQoraW50IF9fbW11X25vdGlmaWVyX2ludmFsaWRh dGVfcmFuZ2Vfc3RhcnQoc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAqcmFuZ2UpCit7CisJc3Ry dWN0IG1tdV9ub3RpZmllcl9tbSAqbW1uX21tID0gcmFuZ2UtPm1tLT5tbXVfbm90aWZpZXJfbW07 CisJaW50IHJldCA9IDA7CisKKwlpZiAobW1uX21tLT5oYXNfaW50ZXJ2YWwpIHsKKwkJcmV0ID0g bW5faXRyZWVfaW52YWxpZGF0ZShtbW5fbW0sIHJhbmdlKTsKKwkJaWYgKHJldCkKKwkJCXJldHVy biByZXQ7CisJfQorCWlmICghaGxpc3RfZW1wdHkoJm1tbl9tbS0+bGlzdCkpCisJCXJldHVybiBt bl9obGlzdF9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KG1tbl9tbSwgcmFuZ2UpOworCXJldHVybiAw OworfQorCitzdGF0aWMgdm9pZCBtbl9obGlzdF9pbnZhbGlkYXRlX2VuZChzdHJ1Y3QgbW11X25v dGlmaWVyX21tICptbW5fbW0sCisJCQkJICAgIHN0cnVjdCBtbXVfbm90aWZpZXJfcmFuZ2UgKnJh bmdlLAorCQkJCSAgICBib29sIG9ubHlfZW5kKQogewogCXN0cnVjdCBtbXVfbm90aWZpZXIgKm1u OwogCWludCBpZDsKIAotCWxvY2tfbWFwX2FjcXVpcmUoJl9fbW11X25vdGlmaWVyX2ludmFsaWRh dGVfcmFuZ2Vfc3RhcnRfbWFwKTsKIAlpZCA9IHNyY3VfcmVhZF9sb2NrKCZzcmN1KTsKLQlobGlz dF9mb3JfZWFjaF9lbnRyeV9yY3UobW4sICZyYW5nZS0+bW0tPm1tdV9ub3RpZmllcl9tbS0+bGlz dCwgaGxpc3QpIHsKKwlobGlzdF9mb3JfZWFjaF9lbnRyeV9yY3UobW4sICZtbW5fbW0tPmxpc3Qs IGhsaXN0KSB7CiAJCS8qCiAJCSAqIENhbGwgaW52YWxpZGF0ZV9yYW5nZSBoZXJlIHRvbyB0byBh dm9pZCB0aGUgbmVlZCBmb3IgdGhlCiAJCSAqIHN1YnN5c3RlbSBvZiBoYXZpbmcgdG8gcmVnaXN0 ZXIgYW4gaW52YWxpZGF0ZV9yYW5nZV9lbmQKQEAgLTIzOCw2ICs1MzQsMTkgQEAgdm9pZCBfX21t dV9ub3RpZmllcl9pbnZhbGlkYXRlX3JhbmdlX2VuZChzdHJ1Y3QgbW11X25vdGlmaWVyX3Jhbmdl ICpyYW5nZSwKIAkJfQogCX0KIAlzcmN1X3JlYWRfdW5sb2NrKCZzcmN1LCBpZCk7Cit9CisKK3Zv aWQgX19tbXVfbm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZV9lbmQoc3RydWN0IG1tdV9ub3RpZmll cl9yYW5nZSAqcmFuZ2UsCisJCQkJCSBib29sIG9ubHlfZW5kKQoreworCXN0cnVjdCBtbXVfbm90 aWZpZXJfbW0gKm1tbl9tbSA9IHJhbmdlLT5tbS0+bW11X25vdGlmaWVyX21tOworCisJbG9ja19t YXBfYWNxdWlyZSgmX19tbXVfbm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZV9zdGFydF9tYXApOwor CWlmIChtbW5fbW0tPmhhc19pbnRlcnZhbCkKKwkJbW5faXRyZWVfaW52X2VuZChtbW5fbW0pOwor CisJaWYgKCFobGlzdF9lbXB0eSgmbW1uX21tLT5saXN0KSkKKwkJbW5faGxpc3RfaW52YWxpZGF0 ZV9lbmQobW1uX21tLCByYW5nZSwgb25seV9lbmQpOwogCWxvY2tfbWFwX3JlbGVhc2UoJl9fbW11 X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnRfbWFwKTsKIH0KIApAQCAtMjU2LDggKzU2 NSw5IEBAIHZvaWQgX19tbXVfbm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZShzdHJ1Y3QgbW1fc3Ry dWN0ICptbSwKIH0KIAogLyoKLSAqIFNhbWUgYXMgbW11X25vdGlmaWVyX3JlZ2lzdGVyIGJ1dCBo ZXJlIHRoZSBjYWxsZXIgbXVzdCBob2xkIHRoZQotICogbW1hcF9zZW0gaW4gd3JpdGUgbW9kZS4K KyAqIFNhbWUgYXMgbW11X25vdGlmaWVyX3JlZ2lzdGVyIGJ1dCBoZXJlIHRoZSBjYWxsZXIgbXVz dCBob2xkIHRoZSBtbWFwX3NlbSBpbgorICogd3JpdGUgbW9kZS4gQSBOVUxMIG1uIHNpZ25hbHMg dGhlIG5vdGlmaWVyIGlzIGJlaW5nIHJlZ2lzdGVyZWQgZm9yIGl0cmVlCisgKiBtb2RlLgogICov CiBpbnQgX19tbXVfbm90aWZpZXJfcmVnaXN0ZXIoc3RydWN0IG1tdV9ub3RpZmllciAqbW4sIHN0 cnVjdCBtbV9zdHJ1Y3QgKm1tKQogewpAQCAtMjc0LDkgKzU4NCw2IEBAIGludCBfX21tdV9ub3Rp Zmllcl9yZWdpc3RlcihzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwgc3RydWN0IG1tX3N0cnVjdCAq bW0pCiAJCWZzX3JlY2xhaW1fcmVsZWFzZShHRlBfS0VSTkVMKTsKIAl9CiAKLQltbi0+bW0gPSBt bTsKLQltbi0+dXNlcnMgPSAxOwotCiAJaWYgKCFtbS0+bW11X25vdGlmaWVyX21tKSB7CiAJCS8q CiAJCSAqIGttYWxsb2MgY2Fubm90IGJlIGNhbGxlZCB1bmRlciBtbV90YWtlX2FsbF9sb2Nrcygp LCBidXQgd2UKQEAgLTI4NCwyMSArNTkxLDIyIEBAIGludCBfX21tdV9ub3RpZmllcl9yZWdpc3Rl cihzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwgc3RydWN0IG1tX3N0cnVjdCAqbW0pCiAJCSAqIHRo ZSB3cml0ZSBzaWRlIG9mIHRoZSBtbWFwX3NlbS4KIAkJICovCiAJCW1tdV9ub3RpZmllcl9tbSA9 Ci0JCQlrbWFsbG9jKHNpemVvZihzdHJ1Y3QgbW11X25vdGlmaWVyX21tKSwgR0ZQX0tFUk5FTCk7 CisJCQlremFsbG9jKHNpemVvZihzdHJ1Y3QgbW11X25vdGlmaWVyX21tKSwgR0ZQX0tFUk5FTCk7 CiAJCWlmICghbW11X25vdGlmaWVyX21tKQogCQkJcmV0dXJuIC1FTk9NRU07CiAKIAkJSU5JVF9I TElTVF9IRUFEKCZtbXVfbm90aWZpZXJfbW0tPmxpc3QpOwogCQlzcGluX2xvY2tfaW5pdCgmbW11 X25vdGlmaWVyX21tLT5sb2NrKTsKKwkJbW11X25vdGlmaWVyX21tLT5pbnZhbGlkYXRlX3NlcSA9 IDI7CisJCW1tdV9ub3RpZmllcl9tbS0+aXRyZWUgPSBSQl9ST09UX0NBQ0hFRDsKKwkJaW5pdF93 YWl0cXVldWVfaGVhZCgmbW11X25vdGlmaWVyX21tLT53cSk7CisJCUlOSVRfSExJU1RfSEVBRCgm bW11X25vdGlmaWVyX21tLT5kZWZlcnJlZF9saXN0KTsKIAl9CiAKIAlyZXQgPSBtbV90YWtlX2Fs bF9sb2NrcyhtbSk7CiAJaWYgKHVubGlrZWx5KHJldCkpCiAJCWdvdG8gb3V0X2NsZWFuOwogCi0J LyogUGFpcnMgd2l0aCB0aGUgbW1kcm9wIGluIG1tdV9ub3RpZmllcl91bnJlZ2lzdGVyXyogKi8K LQltbWdyYWIobW0pOwotCiAJLyoKIAkgKiBTZXJpYWxpemUgdGhlIHVwZGF0ZSBhZ2FpbnN0IG1t dV9ub3RpZmllcl91bnJlZ2lzdGVyLiBBCiAJICogc2lkZSBub3RlOiBtbXVfbm90aWZpZXJfcmVs ZWFzZSBjYW4ndCBydW4gY29uY3VycmVudGx5IHdpdGgKQEAgLTMwNiwxMyArNjE0LDI4IEBAIGlu dCBfX21tdV9ub3RpZmllcl9yZWdpc3RlcihzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwgc3RydWN0 IG1tX3N0cnVjdCAqbW0pCiAJICogY3VycmVudC0+bW0gb3IgZXhwbGljaXRseSB3aXRoIGdldF90 YXNrX21tKCkgb3Igc2ltaWxhcikuCiAJICogV2UgY2FuJ3QgcmFjZSBhZ2FpbnN0IGFueSBvdGhl ciBtbXUgbm90aWZpZXIgbWV0aG9kIGVpdGhlcgogCSAqIHRoYW5rcyB0byBtbV90YWtlX2FsbF9s b2NrcygpLgorCSAqCisJICogcmVsZWFzZSBzZW1hbnRpY3Mgb24gdGhlIGluaXRpYWxpemF0aW9u IG9mIHRoZSBtbXVfbm90aWZpZXJfbW0ncworICAgICAgICAgKiBjb250ZW50cyBhcmUgcHJvdmlk ZWQgZm9yIHVubG9ja2VkIHJlYWRlcnMuICBhY3F1aXJlIGNhbiBvbmx5IGJlCisgICAgICAgICAq IHVzZWQgd2hpbGUgaG9sZGluZyB0aGUgbW1ncmFiIG9yIG1tZ2V0LCBhbmQgaXMgc2FmZSBiZWNh dXNlIG9uY2UKKyAgICAgICAgICogY3JlYXRlZCB0aGUgbW11X25vdGlmaWZlcl9tbSBpcyBub3Qg ZnJlZWQgdW50aWwgdGhlIG1tIGlzCisgICAgICAgICAqIGRlc3Ryb3llZC4gIEFzIGFib3ZlLCB1 c2VycyBob2xkaW5nIHRoZSBtbWFwX3NlbSBvciBvbmUgb2YgdGhlCisgICAgICAgICAqIG1tX3Rh a2VfYWxsX2xvY2tzKCkgZG8gbm90IG5lZWQgdG8gdXNlIGFjcXVpcmUgc2VtYW50aWNzLgogCSAq LwogCWlmIChtbXVfbm90aWZpZXJfbW0pCi0JCW1tLT5tbXVfbm90aWZpZXJfbW0gPSBtbXVfbm90 aWZpZXJfbW07CisJCXNtcF9zdG9yZV9yZWxlYXNlKCZtbS0+bW11X25vdGlmaWVyX21tLCBtbXVf bm90aWZpZXJfbW0pOwogCi0Jc3Bpbl9sb2NrKCZtbS0+bW11X25vdGlmaWVyX21tLT5sb2NrKTsK LQlobGlzdF9hZGRfaGVhZF9yY3UoJm1uLT5obGlzdCwgJm1tLT5tbXVfbm90aWZpZXJfbW0tPmxp c3QpOwotCXNwaW5fdW5sb2NrKCZtbS0+bW11X25vdGlmaWVyX21tLT5sb2NrKTsKKwlpZiAobW4p IHsKKwkJLyogUGFpcnMgd2l0aCB0aGUgbW1kcm9wIGluIG1tdV9ub3RpZmllcl91bnJlZ2lzdGVy XyogKi8KKwkJbW1ncmFiKG1tKTsKKwkJbW4tPm1tID0gbW07CisJCW1uLT51c2VycyA9IDE7CisK KwkJc3Bpbl9sb2NrKCZtbS0+bW11X25vdGlmaWVyX21tLT5sb2NrKTsKKwkJaGxpc3RfYWRkX2hl YWRfcmN1KCZtbi0+aGxpc3QsICZtbS0+bW11X25vdGlmaWVyX21tLT5saXN0KTsKKwkJc3Bpbl91 bmxvY2soJm1tLT5tbXVfbm90aWZpZXJfbW0tPmxvY2spOworCX0gZWxzZQorCQltbS0+bW11X25v dGlmaWVyX21tLT5oYXNfaW50ZXJ2YWwgPSB0cnVlOwogCiAJbW1fZHJvcF9hbGxfbG9ja3MobW0p OwogCUJVR19PTihhdG9taWNfcmVhZCgmbW0tPm1tX3VzZXJzKSA8PSAwKTsKQEAgLTUyOSw2ICs4 NTIsMTY2IEBAIHZvaWQgbW11X25vdGlmaWVyX3B1dChzdHJ1Y3QgbW11X25vdGlmaWVyICptbikK IH0KIEVYUE9SVF9TWU1CT0xfR1BMKG1tdV9ub3RpZmllcl9wdXQpOwogCitzdGF0aWMgaW50IF9f bW11X3JhbmdlX25vdGlmaWVyX2luc2VydChzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyICptcm4s CisJCQkJICAgICAgIHVuc2lnbmVkIGxvbmcgc3RhcnQsCisJCQkJICAgICAgIHVuc2lnbmVkIGxv bmcgbGVuZ3RoLAorCQkJCSAgICAgICBzdHJ1Y3QgbW11X25vdGlmaWVyX21tICptbW5fbW0sCisJ CQkJICAgICAgIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQoreworCW1ybi0+bW0gPSBtbTsKKwlSQl9D TEVBUl9OT0RFKCZtcm4tPmludGVydmFsX3RyZWUucmIpOworCW1ybi0+aW50ZXJ2YWxfdHJlZS5z dGFydCA9IHN0YXJ0OworCS8qCisJICogTm90ZSB0aGF0IHRoZSByZXByZXNlbnRhdGlvbiBvZiB0 aGUgaW50ZXJ2YWxzIGluIHRoZSBpbnRlcnZhbCB0cmVlCisJICogY29uc2lkZXJzIHRoZSBlbmRp bmcgcG9pbnQgYXMgY29udGFpbmVkIGluIHRoZSBpbnRlcnZhbC4KKwkgKi8KKwlpZiAobGVuZ3Ro ID09IDAgfHwKKwkgICAgY2hlY2tfYWRkX292ZXJmbG93KHN0YXJ0LCBsZW5ndGggLSAxLCAmbXJu LT5pbnRlcnZhbF90cmVlLmxhc3QpKQorCQlyZXR1cm4gLUVPVkVSRkxPVzsKKworCS8qIHBhaXJz IHdpdGggbW1kcm9wIGluIG1tdV9yYW5nZV9ub3RpZmllcl9yZW1vdmUoKSAqLworCW1tZ3JhYiht bSk7CisKKwkvKgorCSAqIElmIHNvbWUgaW52YWxpZGF0ZV9yYW5nZV9zdGFydC9lbmQgcmVnaW9u IGlzIGdvaW5nIG9uIGluIHBhcmFsbGVsCisJICogd2UgZG9uJ3Qga25vdyB3aGF0IFZBIHJhbmdl cyBhcmUgYWZmZWN0ZWQsIHNvIHdlIG11c3QgYXNzdW1lIHRoaXMKKwkgKiBuZXcgcmFuZ2UgaXMg aW5jbHVkZWQuCisJICoKKwkgKiBJZiB0aGUgaXRyZWUgaXMgaW52YWxpZGF0aW5nIHRoZW4gd2Ug YXJlIG5vdCBhbGxvd2VkIHRvIGNoYW5nZQorCSAqIGl0LiBSZXRyeWluZyB1bnRpbCBpbnZhbGlk YXRpb24gaXMgZG9uZSBpcyB0cmlja3kgZHVlIHRvIHRoZQorCSAqIHBvc3NpYmlsaXR5IGZvciBs aXZlIGxvY2ssIGluc3RlYWQgZGVmZXIgdGhlIGFkZCB0byB0aGUgdW5sb2NrIHNvCisJICogdGhp cyBhbGdvcml0aG0gaXMgZGV0ZXJtaW5pc3RpYy4KKwkgKgorCSAqIEluIGFsbCBjYXNlcyB0aGUg dmFsdWUgZm9yIHRoZSBtcm4tPm1yX2ludmFsaWRhdGVfc2VxIHNob3VsZCBiZQorCSAqIG9kZCwg c2VlIG1tdV9yYW5nZV9yZWFkX2JlZ2luKCkKKwkgKi8KKwlzcGluX2xvY2soJm1tbl9tbS0+bG9j ayk7CisJaWYgKG1tbl9tbS0+YWN0aXZlX2ludmFsaWRhdGVfcmFuZ2VzKSB7CisJCWlmIChtbl9p dHJlZV9pc19pbnZhbGlkYXRpbmcobW1uX21tKSkKKwkJCWhsaXN0X2FkZF9oZWFkKCZtcm4tPmRl ZmVycmVkX2l0ZW0sCisJCQkJICAgICAgICZtbW5fbW0tPmRlZmVycmVkX2xpc3QpOworCQllbHNl IHsKKwkJCW1tbl9tbS0+aW52YWxpZGF0ZV9zZXEgfD0gMTsKKwkJCWludGVydmFsX3RyZWVfaW5z ZXJ0KCZtcm4tPmludGVydmFsX3RyZWUsCisJCQkJCSAgICAgJm1tbl9tbS0+aXRyZWUpOworCQl9 CisJCW1ybi0+aW52YWxpZGF0ZV9zZXEgPSBtbW5fbW0tPmludmFsaWRhdGVfc2VxOworCX0gZWxz ZSB7CisJCVdBUk5fT04obW5faXRyZWVfaXNfaW52YWxpZGF0aW5nKG1tbl9tbSkpOworCQltcm4t PmludmFsaWRhdGVfc2VxID0gbW1uX21tLT5pbnZhbGlkYXRlX3NlcSAtIDE7CisJCWludGVydmFs X3RyZWVfaW5zZXJ0KCZtcm4tPmludGVydmFsX3RyZWUsICZtbW5fbW0tPml0cmVlKTsKKwl9CisJ c3Bpbl91bmxvY2soJm1tbl9tbS0+bG9jayk7CisJcmV0dXJuIDA7Cit9CisKKy8qKgorICogbW11 X3JhbmdlX25vdGlmaWVyX2luc2VydCAtIEluc2VydCBhIHJhbmdlIG5vdGlmaWVyCisgKiBAbXJu OiBSYW5nZSBub3RpZmllciB0byByZWdpc3RlcgorICogQHN0YXJ0OiBTdGFydGluZyB2aXJ0dWFs IGFkZHJlc3MgdG8gbW9uaXRvcgorICogQGxlbmd0aDogTGVuZ3RoIG9mIHRoZSByYW5nZSB0byBt b25pdG9yCisgKiBAbW0gOiBtbV9zdHJ1Y3QgdG8gYXR0YWNoIHRvCisgKgorICogVGhpcyBmdW5j dGlvbiBzdWJzY3JpYmVzIHRoZSByYW5nZSBub3RpZmllciBmb3Igbm90aWZpY2F0aW9ucyBmcm9t IHRoZSBtbS4KKyAqIFVwb24gcmV0dXJuIHRoZSBvcHMgcmVsYXRlZCB0byBtbXVfcmFuZ2Vfbm90 aWZpZXIgd2lsbCBiZSBjYWxsZWQgd2hlbmV2ZXIKKyAqIGFuIGV2ZW50IHRoYXQgaW50ZXJzZWN0 cyB3aXRoIHRoZSBnaXZlbiByYW5nZSBvY2N1cnMuCisgKgorICogVXBvbiByZXR1cm4gdGhlIHJh bmdlX25vdGlmaWVyIG1heSBub3QgYmUgcHJlc2VudCBpbiB0aGUgaW50ZXJ2YWwgdHJlZSB5ZXQu CisgKiBUaGUgY2FsbGVyIG11c3QgdXNlIHRoZSBub3JtYWwgcmFuZ2Ugbm90aWZpZXIgbG9ja2lu ZyBmbG93IHZpYQorICogbW11X3JhbmdlX3JlYWRfYmVnaW4oKSB0byBlc3RhYmxpc2ggU1BURXMg Zm9yIHRoaXMgcmFuZ2UuCisgKi8KK2ludCBtbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0KHN0cnVj dCBtbXVfcmFuZ2Vfbm90aWZpZXIgKm1ybiwKKwkJCSAgICAgIHVuc2lnbmVkIGxvbmcgc3RhcnQs IHVuc2lnbmVkIGxvbmcgbGVuZ3RoLAorCQkJICAgICAgc3RydWN0IG1tX3N0cnVjdCAqbW0pCit7 CisJc3RydWN0IG1tdV9ub3RpZmllcl9tbSAqbW1uX21tOworCWludCByZXQ7CisKKwltaWdodF9s b2NrKCZtbS0+bW1hcF9zZW0pOworCisJbW1uX21tID0gc21wX2xvYWRfYWNxdWlyZSgmbW0tPm1t dV9ub3RpZmllcl9tbSk7CisJaWYgKCFtbW5fbW0gfHwgIW1tbl9tbS0+aGFzX2ludGVydmFsKSB7 CisJCXJldCA9IG1tdV9ub3RpZmllcl9yZWdpc3RlcihOVUxMLCBtbSk7CisJCWlmIChyZXQpCisJ CQlyZXR1cm4gcmV0OworCQltbW5fbW0gPSBtbS0+bW11X25vdGlmaWVyX21tOworCX0KKwlyZXR1 cm4gX19tbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0KG1ybiwgc3RhcnQsIGxlbmd0aCwgbW1uX21t LCBtbSk7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChtbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0KTsK KworaW50IG1tdV9yYW5nZV9ub3RpZmllcl9pbnNlcnRfbG9ja2VkKHN0cnVjdCBtbXVfcmFuZ2Vf bm90aWZpZXIgKm1ybiwKKwkJCQkgICAgIHVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxv bmcgbGVuZ3RoLAorCQkJCSAgICAgc3RydWN0IG1tX3N0cnVjdCAqbW0pCit7CisJc3RydWN0IG1t dV9ub3RpZmllcl9tbSAqbW1uX21tOworCWludCByZXQ7CisKKwlsb2NrZGVwX2Fzc2VydF9oZWxk X3dyaXRlKCZtbS0+bW1hcF9zZW0pOworCisJbW1uX21tID0gbW0tPm1tdV9ub3RpZmllcl9tbTsK KwlpZiAoIW1tbl9tbSB8fCAhbW1uX21tLT5oYXNfaW50ZXJ2YWwpIHsKKwkJcmV0ID0gX19tbXVf bm90aWZpZXJfcmVnaXN0ZXIoTlVMTCwgbW0pOworCQlpZiAocmV0KQorCQkJcmV0dXJuIHJldDsK KwkJbW1uX21tID0gbW0tPm1tdV9ub3RpZmllcl9tbTsKKwl9CisJcmV0dXJuIF9fbW11X3Jhbmdl X25vdGlmaWVyX2luc2VydChtcm4sIHN0YXJ0LCBsZW5ndGgsIG1tbl9tbSwgbW0pOworfQorRVhQ T1JUX1NZTUJPTF9HUEwobW11X3JhbmdlX25vdGlmaWVyX2luc2VydF9sb2NrZWQpOworCisvKioK KyAqIG1tdV9yYW5nZV9ub3RpZmllcl9yZW1vdmUgLSBSZW1vdmUgYSByYW5nZSBub3RpZmllcgor ICogQG1ybjogUmFuZ2Ugbm90aWZpZXIgdG8gdW5yZWdpc3RlcgorICoKKyAqIFRoaXMgZnVuY3Rp b24gbXVzdCBiZSBwYWlyZWQgd2l0aCBtbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0KCkuIEl0IGNh bm5vdCBiZQorICogY2FsbGVkIGZyb20gYW55IG9wcyBjYWxsYmFjay4KKyAqCisgKiBPbmNlIHRo aXMgcmV0dXJucyBvcHMgY2FsbGJhY2tzIGFyZSBubyBsb25nZXIgcnVubmluZyBvbiBvdGhlciBD UFVzIGFuZAorICogd2lsbCBub3QgYmUgY2FsbGVkIGluIGZ1dHVyZS4KKyAqLwordm9pZCBtbXVf cmFuZ2Vfbm90aWZpZXJfcmVtb3ZlKHN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXIgKm1ybikKK3sK KwlzdHJ1Y3QgbW1fc3RydWN0ICptbSA9IG1ybi0+bW07CisJc3RydWN0IG1tdV9ub3RpZmllcl9t bSAqbW1uX21tID0gbW0tPm1tdV9ub3RpZmllcl9tbTsKKwl1bnNpZ25lZCBsb25nIHNlcSA9IDA7 CisKKwltaWdodF9zbGVlcCgpOworCisJc3Bpbl9sb2NrKCZtbW5fbW0tPmxvY2spOworCWlmICht bl9pdHJlZV9pc19pbnZhbGlkYXRpbmcobW1uX21tKSkgeworCQkvKgorCQkgKiByZW1vdmUgaXMg YmVpbmcgY2FsbGVkIGFmdGVyIGluc2VydCBwdXQgdGhpcyBvbiB0aGUKKwkJICogZGVmZXJyZWQg bGlzdCwgYnV0IGJlZm9yZSB0aGUgZGVmZXJyZWQgbGlzdCB3YXMgcHJvY2Vzc2VkLgorCQkgKi8K KwkJaWYgKFJCX0VNUFRZX05PREUoJm1ybi0+aW50ZXJ2YWxfdHJlZS5yYikpIHsKKwkJCWhsaXN0 X2RlbCgmbXJuLT5kZWZlcnJlZF9pdGVtKTsKKwkJfSBlbHNlIHsKKwkJCWhsaXN0X2FkZF9oZWFk KCZtcm4tPmRlZmVycmVkX2l0ZW0sCisJCQkJICAgICAgICZtbW5fbW0tPmRlZmVycmVkX2xpc3Qp OworCQkJc2VxID0gbW1uX21tLT5pbnZhbGlkYXRlX3NlcTsKKwkJfQorCX0gZWxzZSB7CisJCVdB Uk5fT04oUkJfRU1QVFlfTk9ERSgmbXJuLT5pbnRlcnZhbF90cmVlLnJiKSk7CisJCWludGVydmFs X3RyZWVfcmVtb3ZlKCZtcm4tPmludGVydmFsX3RyZWUsICZtbW5fbW0tPml0cmVlKTsKKwl9CisJ c3Bpbl91bmxvY2soJm1tbl9tbS0+bG9jayk7CisKKwkvKgorCSAqIFRoZSBwb3NzaWJsZSBzbGVl cCBvbiBwcm9ncmVzcyBpbiB0aGUgaW52YWxpZGF0aW9uIHJlcXVpcmVzIHRoZQorCSAqIGNhbGxl ciBub3QgaG9sZCBhbnkgbG9ja3MgaGVsZCBieSBpbnZhbGlkYXRpb24gY2FsbGJhY2tzLgorCSAq LworCWxvY2tfbWFwX2FjcXVpcmUoJl9fbW11X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3Rh cnRfbWFwKTsKKwlsb2NrX21hcF9yZWxlYXNlKCZfX21tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3Jh bmdlX3N0YXJ0X21hcCk7CisJaWYgKHNlcSkKKwkJd2FpdF9ldmVudChtbW5fbW0tPndxLAorCQkJ ICAgUkVBRF9PTkNFKG1tbl9tbS0+aW52YWxpZGF0ZV9zZXEpICE9IHNlcSk7CisKKwkvKiBwYWly cyB3aXRoIG1tZ3JhYiBpbiBtbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0KCkgKi8KKwltbWRyb3Ao bW0pOworfQorRVhQT1JUX1NZTUJPTF9HUEwobW11X3JhbmdlX25vdGlmaWVyX3JlbW92ZSk7CisK IC8qKgogICogbW11X25vdGlmaWVyX3N5bmNocm9uaXplIC0gRW5zdXJlIGFsbCBtbXVfbm90aWZp ZXJzIGFyZSBmcmVlZAogICoKLS0gCjIuMjMuMAoKX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlz dHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4v bGlzdGluZm8vZHJpLWRldmVs From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.5 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id A1C80CA9EC2 for ; Mon, 28 Oct 2019 20:11:21 +0000 (UTC) Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 5F5E4208C0 for ; Mon, 28 Oct 2019 20:11:21 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=ziepe.ca header.i=@ziepe.ca header.b="S58t6Ohp" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 5F5E4208C0 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=ziepe.ca Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=xen-devel-bounces@lists.xenproject.org Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1iPBM2-0001Xd-Dc; Mon, 28 Oct 2019 20:11:06 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1iPBM1-0001XN-OJ for xen-devel@lists.xenproject.org; Mon, 28 Oct 2019 20:11:05 +0000 X-Inumbo-ID: 060a2f76-f9bf-11e9-8aca-bc764e2007e4 Received: from mail-qk1-x742.google.com (unknown [2607:f8b0:4864:20::742]) by us1-rack-iad1.inumbo.com (Halon) with ESMTPS id 060a2f76-f9bf-11e9-8aca-bc764e2007e4; Mon, 28 Oct 2019 20:10:44 +0000 (UTC) Received: by mail-qk1-x742.google.com with SMTP id e2so1216230qkn.5 for ; Mon, 28 Oct 2019 13:10:44 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ziepe.ca; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=H6qkKhlE377yexDDU3hhVTFW0t+EXROxR6aal9KdQe4=; b=S58t6OhprBE5qw20UbAe+Vwse+w2lO/Up0h0lfqdRge/4nS1rXcCCsxlIno+C6MBwn eJxkhgL2L64qgxBPmUhWD6RFK5kf5e0ZelEdKRYLUIxrkTpbhVFOlRF9uwIgGHYVhyZn p43djgWgjcRWx88FI7pDFwEqr3ezye3qfqni5fPI5bTAKCKpVObL1YPw8nHvp+t0PDWo 8uNkbZbvEJJD1KQQGq6PO27jpJTe9bYV5khfvnCnHC1ClOhSnanJvpp5MF0tRIO9Gzbt bgIWXRYWbjzPF2+LqBI2sTQC4L5/nUfSvol6+joXWujgAwYghBBxAzRmxevNYuzjif4u swxA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=H6qkKhlE377yexDDU3hhVTFW0t+EXROxR6aal9KdQe4=; b=k0VidgnSrsdkZxMTC/ZZ6pAO7JCnjny0rhxdDRHyoGTup1DDA48dro9QCqos2GZtOe 9vA3xWTdxRourx+aumuiLuUIJK3ykdpG7mgM1mHeNFhtPe1vjTO/SxcGGAEAQ9y77kmr tk2ipoKJJn6uOPoIP1oRD0OdPPHv4Rhac/ORbSogm2wSpqM1yAapYKSFSo6GR1QtPhte qHZ1WRvAHtTRCb/t4WY4NdVFzix7J07675J/Z6p+VzkVhmGBFnUvehHlbx5ax+ysXhix 8hxQ0m+jf3OOpGNqp3zYOuGMiKuO7EH/w8il9vdzJMT3KhIl/ZGR2rfRuQbwghmAm+ey M0Yw== X-Gm-Message-State: APjAAAXBuOWI/D22ruXrHx2QMd3J5mkCE3sg6ZZZo4jvlUocD+kjsMwj HSE9MglFifFnB78HCJ7qY3y5vg== X-Google-Smtp-Source: APXvYqwcJctJ4wjkPX/iRBrM71GSQB516ozrtr/cgoYC3wlErfDwUG/hWnwhh/5dQ5u5+5Pie/tT7A== X-Received: by 2002:a37:7c42:: with SMTP id x63mr13834494qkc.134.1572293444160; Mon, 28 Oct 2019 13:10:44 -0700 (PDT) Received: from ziepe.ca (hlfxns017vw-142-162-113-180.dhcp-dynamic.fibreop.ns.bellaliant.net. [142.162.113.180]) by smtp.gmail.com with ESMTPSA id t65sm6325908qkh.23.2019.10.28.13.10.43 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Mon, 28 Oct 2019 13:10:44 -0700 (PDT) Received: from jgg by mlx.ziepe.ca with local (Exim 4.90_1) (envelope-from ) id 1iPBLf-0001gA-4C; Mon, 28 Oct 2019 17:10:43 -0300 From: Jason Gunthorpe To: linux-mm@kvack.org, Jerome Glisse , Ralph Campbell , John Hubbard , Felix.Kuehling@amd.com Date: Mon, 28 Oct 2019 17:10:19 -0300 Message-Id: <20191028201032.6352-3-jgg@ziepe.ca> X-Mailer: git-send-email 2.23.0 In-Reply-To: <20191028201032.6352-1-jgg@ziepe.ca> References: <20191028201032.6352-1-jgg@ziepe.ca> MIME-Version: 1.0 Subject: [Xen-devel] [PATCH v2 02/15] mm/mmu_notifier: add an interval tree notifier X-BeenThere: xen-devel@lists.xenproject.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Cc: Juergen Gross , David Zhou , Mike Marciniszyn , Stefano Stabellini , Andrea Arcangeli , Oleksandr Andrushchenko , linux-rdma@vger.kernel.org, nouveau@lists.freedesktop.org, Dennis Dalessandro , amd-gfx@lists.freedesktop.org, Michal Hocko , Christoph Hellwig , Jason Gunthorpe , dri-devel@lists.freedesktop.org, Alex Deucher , xen-devel@lists.xenproject.org, Boris Ostrovsky , Petr Cvek , =?UTF-8?q?Christian=20K=C3=B6nig?= , Ben Skeggs Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" RnJvbTogSmFzb24gR3VudGhvcnBlIDxqZ2dAbWVsbGFub3guY29tPgoKT2YgdGhlIDEzIHVzZXJz IG9mIG1tdV9ub3RpZmllcnMsIDggb2YgdGhlbSB1c2Ugb25seQppbnZhbGlkYXRlX3JhbmdlX3N0 YXJ0L2VuZCgpIGFuZCBpbW1lZGlhdGVseSBpbnRlcnNlY3QgdGhlCm1tdV9ub3RpZmllcl9yYW5n ZSB3aXRoIHNvbWUga2luZCBvZiBpbnRlcm5hbCBsaXN0IG9mIFZBcy4gIDQgdXNlIGFuCmludGVy dmFsIHRyZWUgKGk5MTVfZ2VtLCByYWRlb25fbW4sIHVtZW1fb2RwLCBoZmkxKS4gNCB1c2UgYSBs aW5rZWQgbGlzdApvZiBzb21lIGtpbmQgKHNjaWZfZG1hLCB2aG9zdCwgZ250ZGV2LCBobW0pCgpB bmQgdGhlIHJlbWFpbmluZyA1IGVpdGhlciBkb24ndCB1c2UgaW52YWxpZGF0ZV9yYW5nZV9zdGFy dCgpIG9yIGRvIHNvbWUKc3BlY2lhbCB0aGluZyB3aXRoIGl0LgoKSXQgdHVybnMgb3V0IHRoYXQg YnVpbGRpbmcgYSBjb3JyZWN0IHNjaGVtZSB3aXRoIGFuIGludGVydmFsIHRyZWUgaXMKcHJldHR5 IGNvbXBsaWNhdGVkLCBwYXJ0aWN1bGFybHkgaWYgdGhlIHVzZSBjYXNlIGlzIHN5bmNocm9uaXpp bmcgYWdhaW5zdAphbm90aGVyIHRocmVhZCBkb2luZyBnZXRfdXNlcl9wYWdlcygpLiAgTWFueSBv ZiB0aGVzZSBpbXBsZW1lbnRhdGlvbnMgaGF2ZQp2YXJpb3VzIHN1YnRsZSBhbmQgZGlmZmljdWx0 IHRvIGZpeCByYWNlcy4KClRoaXMgYXBwcm9hY2ggcHV0cyB0aGUgaW50ZXJ2YWwgdHJlZSBhcyBj b21tb24gY29kZSBhdCB0aGUgdG9wIG9mIHRoZSBtbXUKbm90aWZpZXIgY2FsbCB0cmVlIGFuZCBp bXBsZW1lbnRzIGEgc2hhcmVhYmxlIGxvY2tpbmcgc2NoZW1lLgoKSXQgaW5jbHVkZXM6CiAtIEFu IGludGVydmFsIHRyZWUgdHJhY2tpbmcgVkEgcmFuZ2VzLCB3aXRoIHBlci1yYW5nZSBjYWxsYmFj a3MKIC0gQSByZWFkL3dyaXRlIGxvY2tpbmcgc2NoZW1lIGZvciB0aGUgaW50ZXJ2YWwgdHJlZSB0 aGF0IGF2b2lkcwogICBzbGVlcGluZyBpbiB0aGUgbm90aWZpZXIgcGF0aCAoZm9yIE9PTSBraWxs ZXIpCiAtIEEgc2VxdWVuY2UgY291bnRlciBiYXNlZCBjb2xsaXNpb24tcmV0cnkgbG9ja2luZyBz Y2hlbWUgdG8gdGVsbAogICBkZXZpY2UgcGFnZSBmYXVsdCB0aGF0IGEgVkEgcmFuZ2UgaXMgYmVp bmcgY29uY3VycmVudGx5IGludmFsaWRhdGVkLgoKVGhpcyBpcyBiYXNlZCBvbiB2YXJpb3VzIGlk ZWFzOgotIGhtbSBhY2N1bXVsYXRlcyBpbnZhbGlkYXRlZCBWQSByYW5nZXMgYW5kIHJlbGVhc2Vz IHRoZW0gd2hlbiBhbGwKICBpbnZhbGlkYXRlcyBhcmUgZG9uZSwgdmlhIGFjdGl2ZV9pbnZhbGlk YXRlX3JhbmdlcyBjb3VudC4KICBUaGlzIGFwcHJvYWNoIGF2b2lkcyBoYXZpbmcgdG8gaW50ZXJz ZWN0IHRoZSBpbnRlcnZhbCB0cmVlIHR3aWNlIChhcwogIHVtZW1fb2RwIGRvZXMpIGF0IHRoZSBw b3RlbnRpYWwgY29zdCBvZiBhIGxvbmdlciBkZXZpY2UgcGFnZSBmYXVsdC4KCi0ga3ZtL3VtZW1f b2RwIHVzZSBhIHNlcXVlbmNlIGNvdW50ZXIgdG8gZHJpdmUgdGhlIGNvbGxpc2lvbiByZXRyeSwK ICB2aWEgaW52YWxpZGF0ZV9zZXEKCi0gYSBkZWZlcnJlZCB3b3JrIHRvZG8gbGlzdCBvbiB1bmxv Y2sgc2NoZW1lIGxpa2UgUlROTCwgdmlhIGRlZmVycmVkX2xpc3QuCiAgVGhpcyBtYWtlcyBhZGRp bmcvcmVtb3ZpbmcgaW50ZXJ2YWwgdHJlZSBtZW1iZXJzIG1vcmUgZGV0ZXJtaW5pc3RpYwoKLSBz ZXFsb2NrLCBleGNlcHQgdGhpcyB2ZXJzaW9uIG1ha2VzIHRoZSBzZXFsb2NrIGlkZWEgbXVsdGkt aG9sZGVyIG9uIHRoZQogIHdyaXRlIHNpZGUgYnkgcHJvdGVjdGluZyBpdCB3aXRoIGFjdGl2ZV9p bnZhbGlkYXRlX3JhbmdlcyBhbmQgYSBzcGlubG9jawoKVG8gbWluaW1pemUgTU0gb3ZlcmhlYWQg d2hlbiBvbmx5IHRoZSBpbnRlcnZhbCB0cmVlIGlzIGJlaW5nIHVzZWQsIHRoZQplbnRpcmUgU1JD VSBhbmQgaGxpc3Qgb3ZlcmhlYWRzIGFyZSBkcm9wcGVkIHVzaW5nIHNvbWUgc2ltcGxlCmJyYW5j aGVzLiBTaW1pbGFybHkgdGhlIGludGVydmFsIHRyZWUgb3ZlcmhlYWQgaXMgZHJvcHBlZCB3aGVu IGluIGhsaXN0Cm1vZGUuCgpUaGUgb3ZlcmhlYWQgZnJvbSB0aGUgbWFuZGF0b3J5IHNwaW5sb2Nr IGlzIGJyb2FkbHkgdGhlIHNhbWUgYXMgbW9zdCBvZgpleGlzdGluZyB1c2VycyB3aGljaCBhbHJl YWR5IGhhZCBhIGxvY2sgKG9yIHR3bykgb2Ygc29tZSBzb3J0IG9uIHRoZQppbnZhbGlkYXRpb24g cGF0aC4KCkNjOiBBbmRyZWEgQXJjYW5nZWxpIDxhYXJjYW5nZUByZWRoYXQuY29tPgpDYzogTWlj aGFsIEhvY2tvIDxtaG9ja29Aa2VybmVsLm9yZz4KQWNrZWQtYnk6IENocmlzdGlhbiBLw7ZuaWcg PGNocmlzdGlhbi5rb2VuaWdAYW1kLmNvbT4KU2lnbmVkLW9mZi1ieTogSmFzb24gR3VudGhvcnBl IDxqZ2dAbWVsbGFub3guY29tPgotLS0KIGluY2x1ZGUvbGludXgvbW11X25vdGlmaWVyLmggfCAg OTggKysrKysrKwogbW0vS2NvbmZpZyAgICAgICAgICAgICAgICAgICB8ICAgMSArCiBtbS9tbXVf bm90aWZpZXIuYyAgICAgICAgICAgIHwgNTMzICsrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKy0tCiAzIGZpbGVzIGNoYW5nZWQsIDYwNyBpbnNlcnRpb25zKCspLCAyNSBkZWxldGlvbnMo LSkKCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21tdV9ub3RpZmllci5oIGIvaW5jbHVkZS9s aW51eC9tbXVfbm90aWZpZXIuaAppbmRleCAxMmJkNjAzZDMxOGNlNy4uNTFiOTJiYTAxM2RkY2Ug MTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbW11X25vdGlmaWVyLmgKKysrIGIvaW5jbHVkZS9s aW51eC9tbXVfbm90aWZpZXIuaApAQCAtNiwxMCArNiwxMiBAQAogI2luY2x1ZGUgPGxpbnV4L3Nw aW5sb2NrLmg+CiAjaW5jbHVkZSA8bGludXgvbW1fdHlwZXMuaD4KICNpbmNsdWRlIDxsaW51eC9z cmN1Lmg+CisjaW5jbHVkZSA8bGludXgvaW50ZXJ2YWxfdHJlZS5oPgogCiBzdHJ1Y3QgbW11X25v dGlmaWVyX21tOwogc3RydWN0IG1tdV9ub3RpZmllcjsKIHN0cnVjdCBtbXVfbm90aWZpZXJfcmFu Z2U7CitzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyOwogCiAvKioKICAqIGVudW0gbW11X25vdGlm aWVyX2V2ZW50IC0gcmVhc29uIGZvciB0aGUgbW11IG5vdGlmaWVyIGNhbGxiYWNrCkBAIC0zMiw2 ICszNCw5IEBAIHN0cnVjdCBtbXVfbm90aWZpZXJfcmFuZ2U7CiAgKiBhY2Nlc3MgZmxhZ3MpLiBV c2VyIHNob3VsZCBzb2Z0IGRpcnR5IHRoZSBwYWdlIGluIHRoZSBlbmQgY2FsbGJhY2sgdG8gbWFr ZQogICogc3VyZSB0aGF0IGFueW9uZSByZWx5aW5nIG9uIHNvZnQgZGlydHluZXNzIGNhdGNoIHBh Z2VzIHRoYXQgbWlnaHQgYmUgd3JpdHRlbgogICogdGhyb3VnaCBub24gQ1BVIG1hcHBpbmdzLgor ICoKKyAqIEBNTVVfTk9USUZZX1JFTEVBU0U6IHVzZWQgZHVyaW5nIG1tdV9yYW5nZV9ub3RpZmll ciBpbnZhbGlkYXRlIHRvIHNpZ25hbCB0aGF0CisgKiB0aGUgbW0gcmVmY291bnQgaXMgemVybyBh bmQgdGhlIHJhbmdlIGlzIG5vIGxvbmdlciBhY2Nlc3NpYmxlLgogICovCiBlbnVtIG1tdV9ub3Rp Zmllcl9ldmVudCB7CiAJTU1VX05PVElGWV9VTk1BUCA9IDAsCkBAIC0zOSw2ICs0NCw3IEBAIGVu dW0gbW11X25vdGlmaWVyX2V2ZW50IHsKIAlNTVVfTk9USUZZX1BST1RFQ1RJT05fVk1BLAogCU1N VV9OT1RJRllfUFJPVEVDVElPTl9QQUdFLAogCU1NVV9OT1RJRllfU09GVF9ESVJUWSwKKwlNTVVf Tk9USUZZX1JFTEVBU0UsCiB9OwogCiAjZGVmaW5lIE1NVV9OT1RJRklFUl9SQU5HRV9CTE9DS0FC TEUgKDEgPDwgMCkKQEAgLTIyMiw2ICsyMjgsMjYgQEAgc3RydWN0IG1tdV9ub3RpZmllciB7CiAJ dW5zaWduZWQgaW50IHVzZXJzOwogfTsKIAorLyoqCisgKiBzdHJ1Y3QgbW11X3JhbmdlX25vdGlm aWVyX29wcworICogQGludmFsaWRhdGU6IFVwb24gcmV0dXJuIHRoZSBjYWxsZXIgbXVzdCBzdG9w IHVzaW5nIGFueSBTUFRFcyB3aXRoaW4gdGhpcworICogICAgICAgICAgICAgIHJhbmdlLCB0aGlz IGZ1bmN0aW9uIGNhbiBzbGVlcC4gUmV0dXJuIGZhbHNlIGlmIGJsb2NraW5nIHdhcworICogICAg ICAgICAgICAgIHJlcXVpcmVkIGJ1dCByYW5nZSBpcyBub24tYmxvY2tpbmcKKyAqLworc3RydWN0 IG1tdV9yYW5nZV9ub3RpZmllcl9vcHMgeworCWJvb2wgKCppbnZhbGlkYXRlKShzdHJ1Y3QgbW11 X3JhbmdlX25vdGlmaWVyICptcm4sCisJCQkgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3Jh bmdlICpyYW5nZSwKKwkJCSAgIHVuc2lnbmVkIGxvbmcgY3VyX3NlcSk7Cit9OworCitzdHJ1Y3Qg bW11X3JhbmdlX25vdGlmaWVyIHsKKwlzdHJ1Y3QgaW50ZXJ2YWxfdHJlZV9ub2RlIGludGVydmFs X3RyZWU7CisJY29uc3Qgc3RydWN0IG1tdV9yYW5nZV9ub3RpZmllcl9vcHMgKm9wczsKKwlzdHJ1 Y3QgaGxpc3Rfbm9kZSBkZWZlcnJlZF9pdGVtOworCXVuc2lnbmVkIGxvbmcgaW52YWxpZGF0ZV9z ZXE7CisJc3RydWN0IG1tX3N0cnVjdCAqbW07Cit9OworCiAjaWZkZWYgQ09ORklHX01NVV9OT1RJ RklFUgogCiAjaWZkZWYgQ09ORklHX0xPQ0tERVAKQEAgLTI2Myw2ICsyODksNzggQEAgZXh0ZXJu IGludCBfX21tdV9ub3RpZmllcl9yZWdpc3RlcihzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwKIAkJ CQkgICBzdHJ1Y3QgbW1fc3RydWN0ICptbSk7CiBleHRlcm4gdm9pZCBtbXVfbm90aWZpZXJfdW5y ZWdpc3RlcihzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwKIAkJCQkgICAgc3RydWN0IG1tX3N0cnVj dCAqbW0pOworCit1bnNpZ25lZCBsb25nIG1tdV9yYW5nZV9yZWFkX2JlZ2luKHN0cnVjdCBtbXVf cmFuZ2Vfbm90aWZpZXIgKm1ybik7CitpbnQgbW11X3JhbmdlX25vdGlmaWVyX2luc2VydChzdHJ1 Y3QgbW11X3JhbmdlX25vdGlmaWVyICptcm4sCisJCQkgICAgICB1bnNpZ25lZCBsb25nIHN0YXJ0 LCB1bnNpZ25lZCBsb25nIGxlbmd0aCwKKwkJCSAgICAgIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKTsK K2ludCBtbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0X2xvY2tlZChzdHJ1Y3QgbW11X3JhbmdlX25v dGlmaWVyICptcm4sCisJCQkJICAgICB1bnNpZ25lZCBsb25nIHN0YXJ0LCB1bnNpZ25lZCBsb25n IGxlbmd0aCwKKwkJCQkgICAgIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKTsKK3ZvaWQgbW11X3Jhbmdl X25vdGlmaWVyX3JlbW92ZShzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyICptcm4pOworCisvKioK KyAqIG1tdV9yYW5nZV9zZXRfc2VxIC0gU2F2ZSB0aGUgaW52YWxpZGF0aW9uIHNlcXVlbmNlCisg KiBAbXJuIC0gVGhlIG1ybiBwYXNzZWQgdG8gaW52YWxpZGF0ZQorICogQGN1cl9zZXEgLSBUaGUg Y3VyX3NlcSBwYXNzZWQgdG8gaW52YWxpZGF0ZQorICoKKyAqIFRoaXMgbXVzdCBiZSBjYWxsZWQg dW5jb25kaXRpb25hbGx5IGZyb20gdGhlIGludmFsaWRhdGUgY2FsbGJhY2sgb2YgYQorICogc3Ry dWN0IG1tdV9yYW5nZV9ub3RpZmllcl9vcHMgdW5kZXIgdGhlIHNhbWUgbG9jayB0aGF0IGlzIHVz ZWQgdG8gY2FsbAorICogbW11X3JhbmdlX3JlYWRfcmV0cnkoKS4gSXQgdXBkYXRlcyB0aGUgc2Vx dWVuY2UgbnVtYmVyIGZvciBsYXRlciB1c2UgYnkKKyAqIG1tdV9yYW5nZV9yZWFkX3JldHJ5KCku CisgKgorICogSWYgdGhlIHVzZXIgZG9lcyBub3QgY2FsbCBtbXVfcmFuZ2VfcmVhZF9iZWdpbigp IG9yIG1tdV9yYW5nZV9yZWFkX3JldHJ5KCkKKyAqIHRoZW4gdGhpcyBjYWxsIGlzIG5vdCByZXF1 aXJlZC4KKyAqLworc3RhdGljIGlubGluZSB2b2lkIG1tdV9yYW5nZV9zZXRfc2VxKHN0cnVjdCBt bXVfcmFuZ2Vfbm90aWZpZXIgKm1ybiwKKwkJCQkgICAgIHVuc2lnbmVkIGxvbmcgY3VyX3NlcSkK K3sKKwlXUklURV9PTkNFKG1ybi0+aW52YWxpZGF0ZV9zZXEsIGN1cl9zZXEpOworfQorCisvKioK KyAqIG1tdV9yYW5nZV9yZWFkX3JldHJ5IC0gRW5kIGEgcmVhZCBzaWRlIGNyaXRpY2FsIHNlY3Rp b24gYWdhaW5zdCBhIFZBIHJhbmdlCisgKiBtcm46IFRoZSByYW5nZSB1bmRlciBsb2NrCisgKiBz ZXE6IFRoZSByZXR1cm4gb2YgdGhlIHBhaXJlZCBtbXVfcmFuZ2VfcmVhZF9iZWdpbigpCisgKgor ICogVGhpcyBNVVNUIGJlIGNhbGxlZCB1bmRlciBhIHVzZXIgcHJvdmlkZWQgbG9jayB0aGF0IGlz IGFsc28gaGVsZAorICogdW5jb25kaXRpb25hbGx5IGJ5IG9wLT5pbnZhbGlkYXRlKCkgd2hlbiBp dCBjYWxscyBtbXVfcmFuZ2Vfc2V0X3NlcSgpLgorICoKKyAqIEVhY2ggY2FsbCBzaG91bGQgYmUg cGFpcmVkIHdpdGggYSBzaW5nbGUgbW11X3JhbmdlX3JlYWRfYmVnaW4oKSBhbmQKKyAqIHNob3Vs ZCBiZSB1c2VkIHRvIGNvbmNsdWRlIHRoZSByZWFkIHNpZGUuCisgKgorICogUmV0dXJucyB0cnVl IGlmIGFuIGludmFsaWRhdGlvbiBjb2xsaWRlZCB3aXRoIHRoaXMgY3JpdGljYWwgc2VjdGlvbiwg YW5kCisgKiB0aGUgY2FsbGVyIHNob3VsZCByZXRyeS4KKyAqLworc3RhdGljIGlubGluZSBib29s IG1tdV9yYW5nZV9yZWFkX3JldHJ5KHN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXIgKm1ybiwKKwkJ CQkJdW5zaWduZWQgbG9uZyBzZXEpCit7CisJcmV0dXJuIG1ybi0+aW52YWxpZGF0ZV9zZXEgIT0g c2VxOworfQorCisvKioKKyAqIG1tdV9yYW5nZV9jaGVja19yZXRyeSAtIFRlc3QgaWYgYSBjb2xs aXNpb24gaGFzIG9jY3VycmVkCisgKiBtcm46IFRoZSByYW5nZSB1bmRlciBsb2NrCisgKiBzZXE6 IFRoZSByZXR1cm4gb2YgdGhlIG1hdGNoaW5nIG1tdV9yYW5nZV9yZWFkX2JlZ2luKCkKKyAqCisg KiBUaGlzIGNhbiBiZSB1c2VkIGluIHRoZSBjcml0aWNhbCBzZWN0aW9uIGJldHdlZW4gbW11X3Jh bmdlX3JlYWRfYmVnaW4oKSBhbmQKKyAqIG1tdV9yYW5nZV9yZWFkX3JldHJ5KCkuICBBIHJldHVy biBvZiB0cnVlIGluZGljYXRlcyBhbiBpbnZhbGlkYXRpb24gaGFzCisgKiBjb2xsaWRlZCB3aXRo IHRoaXMgbG9jayBhbmQgYSBmdXR1cmUgbW11X3JhbmdlX3JlYWRfcmV0cnkoKSB3aWxsIHJldHVy bgorICogdHJ1ZS4KKyAqCisgKiBGYWxzZSBpcyBub3QgcmVsaWFibGUgYW5kIG9ubHkgc3VnZ2Vz dHMgYSBjb2xsaXNpb24gaGFzIG5vdCBoYXBwZW5lZC4gSXQKKyAqIGNhbiBiZSBjYWxsZWQgbWFu eSB0aW1lcyBhbmQgZG9lcyBub3QgaGF2ZSB0byBob2xkIHRoZSB1c2VyIHByb3ZpZGVkIGxvY2su CisgKgorICogVGhpcyBjYWxsIGNhbiBiZSB1c2VkIGFzIHBhcnQgb2YgbG9vcHMgYW5kIG90aGVy IGV4cGVuc2l2ZSBvcGVyYXRpb25zIHRvCisgKiBleHBlZGl0ZSBhIHJldHJ5LgorICovCitzdGF0 aWMgaW5saW5lIGJvb2wgbW11X3JhbmdlX2NoZWNrX3JldHJ5KHN0cnVjdCBtbXVfcmFuZ2Vfbm90 aWZpZXIgKm1ybiwKKwkJCQkJIHVuc2lnbmVkIGxvbmcgc2VxKQoreworCS8qIFBhaXJzIHdpdGgg dGhlIFdSSVRFX09OQ0UgaW4gbW11X3JhbmdlX3NldF9zZXEoKSAqLworCXJldHVybiBSRUFEX09O Q0UobXJuLT5pbnZhbGlkYXRlX3NlcSkgIT0gc2VxOworfQorCiBleHRlcm4gdm9pZCBfX21tdV9u b3RpZmllcl9tbV9kZXN0cm95KHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKTsKIGV4dGVybiB2b2lkIF9f bW11X25vdGlmaWVyX3JlbGVhc2Uoc3RydWN0IG1tX3N0cnVjdCAqbW0pOwogZXh0ZXJuIGludCBf X21tdV9ub3RpZmllcl9jbGVhcl9mbHVzaF95b3VuZyhzdHJ1Y3QgbW1fc3RydWN0ICptbSwKZGlm ZiAtLWdpdCBhL21tL0tjb25maWcgYi9tbS9LY29uZmlnCmluZGV4IGE1ZGFlOWE3ZWI1MTBhLi5k MGI1MDQ2ZDlhZWZmZCAxMDA2NDQKLS0tIGEvbW0vS2NvbmZpZworKysgYi9tbS9LY29uZmlnCkBA IC0yODQsNiArMjg0LDcgQEAgY29uZmlnIFZJUlRfVE9fQlVTCiBjb25maWcgTU1VX05PVElGSUVS CiAJYm9vbAogCXNlbGVjdCBTUkNVCisJc2VsZWN0IElOVEVSVkFMX1RSRUUKIAogY29uZmlnIEtT TQogCWJvb2wgIkVuYWJsZSBLU00gZm9yIHBhZ2UgbWVyZ2luZyIKZGlmZiAtLWdpdCBhL21tL21t dV9ub3RpZmllci5jIGIvbW0vbW11X25vdGlmaWVyLmMKaW5kZXggMzY3NjcwY2ZkMDJiN2IuLmQw MmQzYzhjMjIzZWI3IDEwMDY0NAotLS0gYS9tbS9tbXVfbm90aWZpZXIuYworKysgYi9tbS9tbXVf bm90aWZpZXIuYwpAQCAtMTIsNiArMTIsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2V4cG9ydC5oPgog I2luY2x1ZGUgPGxpbnV4L21tLmg+CiAjaW5jbHVkZSA8bGludXgvZXJyLmg+CisjaW5jbHVkZSA8 bGludXgvaW50ZXJ2YWxfdHJlZS5oPgogI2luY2x1ZGUgPGxpbnV4L3NyY3UuaD4KICNpbmNsdWRl IDxsaW51eC9yY3VwZGF0ZS5oPgogI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CkBAIC0zNiwxMCAr MzcsMjQzIEBAIHN0cnVjdCBsb2NrZGVwX21hcCBfX21tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3Jh bmdlX3N0YXJ0X21hcCA9IHsKIHN0cnVjdCBtbXVfbm90aWZpZXJfbW0gewogCS8qIGFsbCBtbXUg bm90aWZpZXJzIHJlZ2lzdGVyZWQgaW4gdGhpcyBtbSBhcmUgcXVldWVkIGluIHRoaXMgbGlzdCAq LwogCXN0cnVjdCBobGlzdF9oZWFkIGxpc3Q7CisJYm9vbCBoYXNfaW50ZXJ2YWw7CiAJLyogdG8g c2VyaWFsaXplIHRoZSBsaXN0IG1vZGlmaWNhdGlvbnMgYW5kIGhsaXN0X3VuaGFzaGVkICovCiAJ c3BpbmxvY2tfdCBsb2NrOworCXVuc2lnbmVkIGxvbmcgaW52YWxpZGF0ZV9zZXE7CisJdW5zaWdu ZWQgbG9uZyBhY3RpdmVfaW52YWxpZGF0ZV9yYW5nZXM7CisJc3RydWN0IHJiX3Jvb3RfY2FjaGVk IGl0cmVlOworCXdhaXRfcXVldWVfaGVhZF90IHdxOworCXN0cnVjdCBobGlzdF9oZWFkIGRlZmVy cmVkX2xpc3Q7CiB9OwogCisvKgorICogVGhpcyBpcyBhIGNvbGxpc2lvbi1yZXRyeSByZWFkLXNp ZGUvd3JpdGUtc2lkZSAnbG9jaycsIGEgbG90IGxpa2UgYQorICogc2VxY291bnQsIGhvd2V2ZXIg dGhpcyBhbGxvd3MgbXVsdGlwbGUgd3JpdGUtc2lkZXMgdG8gaG9sZCBpdCBhdAorICogb25jZS4g Q29uY2VwdHVhbGx5IHRoZSB3cml0ZSBzaWRlIGlzIHByb3RlY3RpbmcgdGhlIHZhbHVlcyBvZiB0 aGUgUFRFcyBpbgorICogdGhpcyBtbSwgc3VjaCB0aGF0IFBURVMgY2Fubm90IGJlIHJlYWQgaW50 byBTUFRFcyB3aGlsZSBhbnkgd3JpdGVyIGV4aXN0cy4KKyAqCisgKiBOb3RlIHRoYXQgdGhlIGNv cmUgbW0gY3JlYXRlcyBuZXN0ZWQgaW52YWxpZGF0ZV9yYW5nZV9zdGFydCgpL2VuZCgpIHJlZ2lv bnMKKyAqIHdpdGhpbiB0aGUgc2FtZSB0aHJlYWQsIGFuZCBydW5zIGludmFsaWRhdGVfcmFuZ2Vf c3RhcnQoKS9lbmQoKSBpbiBwYXJhbGxlbAorICogb24gbXVsdGlwbGUgQ1BVcy4gVGhpcyBpcyBk ZXNpZ25lZCB0byBub3QgcmVkdWNlIGNvbmN1cnJlbmN5IG9yIGJsb2NrCisgKiBwcm9ncmVzcyBv biB0aGUgbW0gc2lkZS4KKyAqCisgKiBBcyBhIHNlY29uZGFyeSBmdW5jdGlvbiwgaG9sZGluZyB0 aGUgZnVsbCB3cml0ZSBzaWRlIGFsc28gc2VydmVzIHRvIHByZXZlbnQKKyAqIHdyaXRlcnMgZm9y IHRoZSBpdHJlZSwgdGhpcyBpcyBhbiBvcHRpbWl6YXRpb24gdG8gYXZvaWQgZXh0cmEgbG9ja2lu ZworICogZHVyaW5nIGludmFsaWRhdGVfcmFuZ2Vfc3RhcnQvZW5kIG5vdGlmaWVycy4KKyAqCisg KiBUaGUgd3JpdGUgc2lkZSBoYXMgdHdvIHN0YXRlcywgZnVsbHkgZXhjbHVkZWQ6CisgKiAgLSBt bS0+YWN0aXZlX2ludmFsaWRhdGVfcmFuZ2VzICE9IDAKKyAqICAtIG1ubi0+aW52YWxpZGF0ZV9z ZXEgJiAxID09IFRydWUKKyAqICAtIHNvbWUgcmFuZ2Ugb24gdGhlIG1tX3N0cnVjdCBpcyBiZWlu ZyBpbnZhbGlkYXRlZAorICogIC0gdGhlIGl0cmVlIGlzIG5vdCBhbGxvd2VkIHRvIGNoYW5nZQor ICoKKyAqIEFuZCBwYXJ0aWFsbHkgZXhjbHVkZWQ6CisgKiAgLSBtbS0+YWN0aXZlX2ludmFsaWRh dGVfcmFuZ2VzICE9IDAKKyAqICAtIHNvbWUgcmFuZ2Ugb24gdGhlIG1tX3N0cnVjdCBpcyBiZWlu ZyBpbnZhbGlkYXRlZAorICogIC0gdGhlIGl0cmVlIGlzIGFsbG93ZWQgdG8gY2hhbmdlCisgKgor ICogVGhlIGxhdGVyIHN0YXRlIGF2b2lkcyBzb21lIGV4cGVuc2l2ZSB3b3JrIG9uIGludl9lbmQg aW4gdGhlIGNvbW1vbiBjYXNlIG9mCisgKiBubyBtcm4gbW9uaXRvcmluZyB0aGUgVkEuCisgKi8K K3N0YXRpYyBib29sIG1uX2l0cmVlX2lzX2ludmFsaWRhdGluZyhzdHJ1Y3QgbW11X25vdGlmaWVy X21tICptbW5fbW0pCit7CisJbG9ja2RlcF9hc3NlcnRfaGVsZCgmbW1uX21tLT5sb2NrKTsKKwly ZXR1cm4gbW1uX21tLT5pbnZhbGlkYXRlX3NlcSAmIDE7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgbW11 X3JhbmdlX25vdGlmaWVyICoKK21uX2l0cmVlX2ludl9zdGFydF9yYW5nZShzdHJ1Y3QgbW11X25v dGlmaWVyX21tICptbW5fbW0sCisJCQkgY29uc3Qgc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAq cmFuZ2UsCisJCQkgdW5zaWduZWQgbG9uZyAqc2VxKQoreworCXN0cnVjdCBpbnRlcnZhbF90cmVl X25vZGUgKm5vZGU7CisJc3RydWN0IG1tdV9yYW5nZV9ub3RpZmllciAqcmVzID0gTlVMTDsKKwor CXNwaW5fbG9jaygmbW1uX21tLT5sb2NrKTsKKwltbW5fbW0tPmFjdGl2ZV9pbnZhbGlkYXRlX3Jh bmdlcysrOworCW5vZGUgPSBpbnRlcnZhbF90cmVlX2l0ZXJfZmlyc3QoJm1tbl9tbS0+aXRyZWUs IHJhbmdlLT5zdGFydCwKKwkJCQkJcmFuZ2UtPmVuZCAtIDEpOworCWlmIChub2RlKSB7CisJCW1t bl9tbS0+aW52YWxpZGF0ZV9zZXEgfD0gMTsKKwkJcmVzID0gY29udGFpbmVyX29mKG5vZGUsIHN0 cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXIsCisJCQkJICAgaW50ZXJ2YWxfdHJlZSk7CisJfQorCisJ KnNlcSA9IG1tbl9tbS0+aW52YWxpZGF0ZV9zZXE7CisJc3Bpbl91bmxvY2soJm1tbl9tbS0+bG9j ayk7CisJcmV0dXJuIHJlczsKK30KKworc3RhdGljIHN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXIg KgorbW5faXRyZWVfaW52X25leHQoc3RydWN0IG1tdV9yYW5nZV9ub3RpZmllciAqbXJuLAorCQkg IGNvbnN0IHN0cnVjdCBtbXVfbm90aWZpZXJfcmFuZ2UgKnJhbmdlKQoreworCXN0cnVjdCBpbnRl cnZhbF90cmVlX25vZGUgKm5vZGU7CisKKwlub2RlID0gaW50ZXJ2YWxfdHJlZV9pdGVyX25leHQo Jm1ybi0+aW50ZXJ2YWxfdHJlZSwgcmFuZ2UtPnN0YXJ0LAorCQkJCSAgICAgICByYW5nZS0+ZW5k IC0gMSk7CisJaWYgKCFub2RlKQorCQlyZXR1cm4gTlVMTDsKKwlyZXR1cm4gY29udGFpbmVyX29m KG5vZGUsIHN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXIsIGludGVydmFsX3RyZWUpOworfQorCitz dGF0aWMgdm9pZCBtbl9pdHJlZV9pbnZfZW5kKHN0cnVjdCBtbXVfbm90aWZpZXJfbW0gKm1tbl9t bSkKK3sKKwlzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyICptcm47CisJc3RydWN0IGhsaXN0X25v ZGUgKm5leHQ7CisJYm9vbCBuZWVkX3dha2UgPSBmYWxzZTsKKworCXNwaW5fbG9jaygmbW1uX21t LT5sb2NrKTsKKwlpZiAoLS1tbW5fbW0tPmFjdGl2ZV9pbnZhbGlkYXRlX3JhbmdlcyB8fAorCSAg ICAhbW5faXRyZWVfaXNfaW52YWxpZGF0aW5nKG1tbl9tbSkpIHsKKwkJc3Bpbl91bmxvY2soJm1t bl9tbS0+bG9jayk7CisJCXJldHVybjsKKwl9CisKKwltbW5fbW0tPmludmFsaWRhdGVfc2VxKys7 CisJbmVlZF93YWtlID0gdHJ1ZTsKKworCS8qCisJICogVGhlIGludl9lbmQgaW5jb3Jwb3JhdGVz IGEgZGVmZXJyZWQgbWVjaGFuaXNtIGxpa2UKKwkgKiBydG5sX2xvY2soKS4gQWRkcyBhbmQgcmVt b3ZlcyBhcmUgcXVldWVkIHVudGlsIHRoZSBmaW5hbCBpbnZfZW5kCisJICogaGFwcGVucyB0aGVu IHRoZXkgYXJlIHByb2dyZXNzZWQuIFRoaXMgYXJyYW5nZW1lbnQgZm9yIHRyZWUgdXBkYXRlcwor CSAqIGlzIHVzZWQgdG8gYXZvaWQgdXNpbmcgYSBibG9ja2luZyBsb2NrIGR1cmluZworCSAqIGlu dmFsaWRhdGVfcmFuZ2Vfc3RhcnQuCisJICovCisJaGxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZSht cm4sIG5leHQsICZtbW5fbW0tPmRlZmVycmVkX2xpc3QsCisJCQkJICBkZWZlcnJlZF9pdGVtKSB7 CisJCWlmIChSQl9FTVBUWV9OT0RFKCZtcm4tPmludGVydmFsX3RyZWUucmIpKQorCQkJaW50ZXJ2 YWxfdHJlZV9pbnNlcnQoJm1ybi0+aW50ZXJ2YWxfdHJlZSwKKwkJCQkJICAgICAmbW1uX21tLT5p dHJlZSk7CisJCWVsc2UKKwkJCWludGVydmFsX3RyZWVfcmVtb3ZlKCZtcm4tPmludGVydmFsX3Ry ZWUsCisJCQkJCSAgICAgJm1tbl9tbS0+aXRyZWUpOworCQlobGlzdF9kZWwoJm1ybi0+ZGVmZXJy ZWRfaXRlbSk7CisJfQorCXNwaW5fdW5sb2NrKCZtbW5fbW0tPmxvY2spOworCisJLyoKKwkgKiBU T0RPOiBTaW5jZSB3ZSBhbHJlYWR5IGhhdmUgYSBzcGlubG9jayBhYm92ZSwgdGhpcyB3b3VsZCBi ZSBmYXN0ZXIKKwkgKiBhcyB3YWtlX3VwX3EKKwkgKi8KKwlpZiAobmVlZF93YWtlKQorCQl3YWtl X3VwX2FsbCgmbW1uX21tLT53cSk7Cit9CisKKy8qKgorICogbW11X3JhbmdlX3JlYWRfYmVnaW4g LSBCZWdpbiBhIHJlYWQgc2lkZSBjcml0aWNhbCBzZWN0aW9uIGFnYWluc3QgYSBWQSByYW5nZQor ICogbXJuOiBUaGUgcmFuZ2UgdG8gbG9jaworICoKKyAqIG1tdV9yYW5nZV9yZWFkX2JlZ2luKCkv bW11X3JhbmdlX3JlYWRfcmV0cnkoKSBpbXBsZW1lbnQgYSBjb2xsaXNpb24tcmV0cnkKKyAqIGxv Y2tpbmcgc2NoZW1lIHNpbWlsYXIgdG8gc2VxY291bnQgZm9yIHRoZSBWQSByYW5nZSB1bmRlciBt cm4uIElmIHRoZSBtbQorICogaW52b2tlcyBpbnZhbGlkYXRpb24gZHVyaW5nIHRoZSBjcml0aWNh bCBzZWN0aW9uIHRoZW4KKyAqIG1tdV9yYW5nZV9yZWFkX3JldHJ5KCkgd2lsbCByZXR1cm4gdHJ1 ZS4KKyAqCisgKiBUaGlzIGlzIHVzZWZ1bCB0byBvYnRhaW4gc2hhZG93IFBURXMgd2hlcmUgdGVh cmRvd24gb3Igc2V0dXAgb2YgdGhlIFNQVEVzCisgKiByZXF1aXJlIGEgYmxvY2tpbmcgY29udGV4 dC4gIFRoZSBjcml0aWNhbCByZWdpb24gZm9ybWVkIGJ5IHRoaXMgbG9jayBjYW4KKyAqIHNsZWVw LCBhbmQgdGhlIHJlcXVpcmVkICd1c2VyX2xvY2snIGNhbiBhbHNvIGJlIGEgc2xlZXBpbmcgbG9j ay4KKyAqCisgKiBUaGUgY2FsbGVyIGlzIHJlcXVpcmVkIHRvIHByb3ZpZGUgYSAndXNlcl9sb2Nr JyB0byBzZXJpYWxpemUgYm90aCB0ZWFyZG93bgorICogYW5kIHNldHVwLgorICoKKyAqIFRoZSBy ZXR1cm4gdmFsdWUgc2hvdWxkIGJlIHBhc3NlZCB0byBtbXVfcmFuZ2VfcmVhZF9yZXRyeSgpLgor ICovCit1bnNpZ25lZCBsb25nIG1tdV9yYW5nZV9yZWFkX2JlZ2luKHN0cnVjdCBtbXVfcmFuZ2Vf bm90aWZpZXIgKm1ybikKK3sKKwlzdHJ1Y3QgbW11X25vdGlmaWVyX21tICptbW5fbW0gPSBtcm4t Pm1tLT5tbXVfbm90aWZpZXJfbW07CisJdW5zaWduZWQgbG9uZyBzZXE7CisJYm9vbCBpc19pbnZh bGlkYXRpbmc7CisKKwkvKgorCSAqIElmIHRoZSBtcm4gaGFzIGEgZGlmZmVyZW50IHNlcSB2YWx1 ZSB1bmRlciB0aGUgdXNlcl9sb2NrIHRoYW4gd2UKKwkgKiBzdGFydGVkIHdpdGggdGhlbiBpdCBo YXMgY29sbGlkZWQuCisJICoKKwkgKiBJZiB0aGUgbXJuIGN1cnJlbnRseSBoYXMgdGhlIHNhbWUg c2VxIHZhbHVlIGFzIHRoZSBtbW5fbW0gc2VxLCB0aGVuCisJICogaXQgaXMgY3VycmVudGx5IGJl dHdlZW4gaW52YWxpZGF0ZV9zdGFydC9lbmQgYW5kIGlzIGNvbGxpZGluZy4KKwkgKgorCSAqIFRo ZSBsb2NraW5nIGxvb2tzIGJyb2FkbHkgbGlrZSB0aGlzOgorCSAqICAgbW5fdHJlZV9pbnZhbGlk YXRlX3N0YXJ0KCk6ICAgICAgICAgIG1tdV9yYW5nZV9yZWFkX2JlZ2luKCk6CisJICogICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNwaW5fbG9jaworCSAqICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc2VxID0gUkVBRF9PTkNFKG1ybi0+aW52 YWxpZGF0ZV9zZXEpOworCSAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgc2VxID09IG1tbl9tbS0+aW52YWxpZGF0ZV9zZXEKKwkgKiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgc3Bpbl91bmxvY2sKKwkgKiAgICBzcGluX2xvY2sKKwkgKiAg ICAgc2VxID0gKyttbW5fbW0tPmludmFsaWRhdGVfc2VxCisJICogICAgc3Bpbl91bmxvY2sKKwkg KiAgICAgb3AtPmludmFsaWRhdGVfcmFuZ2UoKToKKwkgKiAgICAgICB1c2VyX2xvY2sKKwkgKiAg ICAgICAgbW11X3JhbmdlX3NldF9zZXEoKQorCSAqICAgICAgICAgbXJuLT5pbnZhbGlkYXRlX3Nl cSA9IHNlcQorCSAqICAgICAgIHVzZXJfdW5sb2NrCisJICoKKwkgKiAgICAgICAgICAgICAgICAg ICAgICAgICAgW1JlcXVpcmVkOiBtbXVfcmFuZ2VfcmVhZF9yZXRyeSgpID09IHRydWVdCisJICoK KwkgKiAgIG1uX2l0cmVlX2ludl9lbmQoKToKKwkgKiAgICBzcGluX2xvY2sKKwkgKiAgICAgc2Vx ID0gKyttbW5fbW0tPmludmFsaWRhdGVfc2VxCisJICogICAgc3Bpbl91bmxvY2sKKwkgKgorCSAq ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVzZXJfbG9jaworCSAqICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtbXVfcmFuZ2VfcmVhZF9yZXRy eSgpOgorCSAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbXJuLT5p bnZhbGlkYXRlX3NlcSAhPSBzZXEKKwkgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB1c2VyX3VubG9jaworCSAqCisJICogQmFycmllcnMgYXJlIG5vdCBuZWVkZWQgaGVy ZSBhcyBhbnkgcmFjZXMgaGVyZSBhcmUgY2xvc2VkIGJ5IGFuCisJICogZXZlbnR1YWwgbW11X3Jh bmdlX3JlYWRfcmV0cnkoKSwgd2hpY2ggcHJvdmlkZXMgYSBiYXJyaWVyIHZpYSB0aGUKKwkgKiB1 c2VyX2xvY2suCisJICovCisJc3Bpbl9sb2NrKCZtbW5fbW0tPmxvY2spOworCS8qIFBhaXJzIHdp dGggdGhlIFdSSVRFX09OQ0UgaW4gbW11X3JhbmdlX3NldF9zZXEoKSAqLworCXNlcSA9IFJFQURf T05DRShtcm4tPmludmFsaWRhdGVfc2VxKTsKKwlpc19pbnZhbGlkYXRpbmcgPSBzZXEgPT0gbW1u X21tLT5pbnZhbGlkYXRlX3NlcTsKKwlzcGluX3VubG9jaygmbW1uX21tLT5sb2NrKTsKKworCS8q CisJICogbXJuLT5pbnZhbGlkYXRlX3NlcSBpcyBhbHdheXMgc2V0IHRvIGFuIG9kZCB2YWx1ZS4g VGhpcyBlbnN1cmVzCisJICogdGhhdCBpZiBzZXEgZG9lcyB3cmFwIHdlIHdpbGwgYWx3YXlzIGNs ZWFyIHRoZSBiZWxvdyBzbGVlcCBpbiBzb21lCisJICogcmVhc29uYWJsZSB0aW1lIGFzIG1tbl9t bS0+aW52YWxpZGF0ZV9zZXEgaXMgZXZlbiBpbiB0aGUgaWRsZQorCSAqIHN0YXRlLgorCSAqLwor CWxvY2tfbWFwX2FjcXVpcmUoJl9fbW11X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnRf bWFwKTsKKwlsb2NrX21hcF9yZWxlYXNlKCZfX21tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3Jhbmdl X3N0YXJ0X21hcCk7CisJaWYgKGlzX2ludmFsaWRhdGluZykKKwkJd2FpdF9ldmVudChtbW5fbW0t PndxLAorCQkJICAgUkVBRF9PTkNFKG1tbl9tbS0+aW52YWxpZGF0ZV9zZXEpICE9IHNlcSk7CisK KwkvKgorCSAqIE5vdGljZSB0aGF0IG1tdV9yYW5nZV9yZWFkX3JldHJ5KCkgY2FuIGFscmVhZHkg YmUgdHJ1ZSBhdCB0aGlzCisJICogcG9pbnQsIGF2b2lkaW5nIGxvb3BzIGhlcmUgYWxsb3dzIHRo ZSB1c2VyIG9mIHRoaXMgbG9jayB0byBwcm92aWRlCisJICogYSBnbG9iYWwgdGltZSBib3VuZC4K KwkgKi8KKworCXJldHVybiBzZXE7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChtbXVfcmFuZ2VfcmVh ZF9iZWdpbik7CisKK3N0YXRpYyB2b2lkIG1uX2l0cmVlX3JlbGVhc2Uoc3RydWN0IG1tdV9ub3Rp Zmllcl9tbSAqbW1uX21tLAorCQkJICAgICBzdHJ1Y3QgbW1fc3RydWN0ICptbSkKK3sKKwlzdHJ1 Y3QgbW11X25vdGlmaWVyX3JhbmdlIHJhbmdlID0geworCQkuZmxhZ3MgPSBNTVVfTk9USUZJRVJf UkFOR0VfQkxPQ0tBQkxFLAorCQkuZXZlbnQgPSBNTVVfTk9USUZZX1JFTEVBU0UsCisJCS5tbSA9 IG1tLAorCQkuc3RhcnQgPSAwLAorCQkuZW5kID0gVUxPTkdfTUFYLAorCX07CisJc3RydWN0IG1t dV9yYW5nZV9ub3RpZmllciAqbXJuOworCXVuc2lnbmVkIGxvbmcgY3VyX3NlcTsKKwlib29sIHJl dDsKKworCWZvciAobXJuID0gbW5faXRyZWVfaW52X3N0YXJ0X3JhbmdlKG1tbl9tbSwgJnJhbmdl LCAmY3VyX3NlcSk7IG1ybjsKKwkgICAgIG1ybiA9IG1uX2l0cmVlX2ludl9uZXh0KG1ybiwgJnJh bmdlKSkgeworCQlyZXQgPSBtcm4tPm9wcy0+aW52YWxpZGF0ZShtcm4sICZyYW5nZSwgY3VyX3Nl cSk7CisJCVdBUk5fT04oIXJldCk7CisJfQorCisJbW5faXRyZWVfaW52X2VuZChtbW5fbW0pOwor fQorCiAvKgogICogVGhpcyBmdW5jdGlvbiBjYW4ndCBydW4gY29uY3VycmVudGx5IGFnYWluc3Qg bW11X25vdGlmaWVyX3JlZ2lzdGVyCiAgKiBiZWNhdXNlIG1tLT5tbV91c2VycyA+IDAgZHVyaW5n IG1tdV9ub3RpZmllcl9yZWdpc3RlciBhbmQgZXhpdF9tbWFwCkBAIC01MiwxNyArMjg2LDI0IEBA IHN0cnVjdCBtbXVfbm90aWZpZXJfbW0gewogICogY2FuJ3QgZ28gYXdheSBmcm9tIHVuZGVyIHVz IGFzIGV4aXRfbW1hcCBob2xkcyBhbiBtbV9jb3VudCBwaW4KICAqIGl0c2VsZi4KICAqLwotdm9p ZCBfX21tdV9ub3RpZmllcl9yZWxlYXNlKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQorc3RhdGljIHZv aWQgbW5faGxpc3RfcmVsZWFzZShzdHJ1Y3QgbW11X25vdGlmaWVyX21tICptbW5fbW0sCisJCQkg ICAgIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQogewogCXN0cnVjdCBtbXVfbm90aWZpZXIgKm1uOwog CWludCBpZDsKIAorCWlmIChtbW5fbW0tPmhhc19pbnRlcnZhbCkKKwkJbW5faXRyZWVfcmVsZWFz ZShtbW5fbW0sIG1tKTsKKworCWlmIChobGlzdF9lbXB0eSgmbW1uX21tLT5saXN0KSkKKwkJcmV0 dXJuOworCiAJLyoKIAkgKiBTUkNVIGhlcmUgd2lsbCBibG9jayBtbXVfbm90aWZpZXJfdW5yZWdp c3RlciB1bnRpbAogCSAqIC0+cmVsZWFzZSByZXR1cm5zLgogCSAqLwogCWlkID0gc3JjdV9yZWFk X2xvY2soJnNyY3UpOwotCWhsaXN0X2Zvcl9lYWNoX2VudHJ5X3JjdShtbiwgJm1tLT5tbXVfbm90 aWZpZXJfbW0tPmxpc3QsIGhsaXN0KQorCWhsaXN0X2Zvcl9lYWNoX2VudHJ5X3JjdShtbiwgJm1t bl9tbS0+bGlzdCwgaGxpc3QpCiAJCS8qCiAJCSAqIElmIC0+cmVsZWFzZSBydW5zIGJlZm9yZSBt bXVfbm90aWZpZXJfdW5yZWdpc3RlciBpdCBtdXN0IGJlCiAJCSAqIGhhbmRsZWQsIGFzIGl0J3Mg dGhlIG9ubHkgd2F5IGZvciB0aGUgZHJpdmVyIHRvIGZsdXNoIGFsbApAQCAtNzIsOSArMzEzLDkg QEAgdm9pZCBfX21tdV9ub3RpZmllcl9yZWxlYXNlKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQogCQlp ZiAobW4tPm9wcy0+cmVsZWFzZSkKIAkJCW1uLT5vcHMtPnJlbGVhc2UobW4sIG1tKTsKIAotCXNw aW5fbG9jaygmbW0tPm1tdV9ub3RpZmllcl9tbS0+bG9jayk7Ci0Jd2hpbGUgKHVubGlrZWx5KCFo bGlzdF9lbXB0eSgmbW0tPm1tdV9ub3RpZmllcl9tbS0+bGlzdCkpKSB7Ci0JCW1uID0gaGxpc3Rf ZW50cnkobW0tPm1tdV9ub3RpZmllcl9tbS0+bGlzdC5maXJzdCwKKwlzcGluX2xvY2soJm1tbl9t bS0+bG9jayk7CisJd2hpbGUgKHVubGlrZWx5KCFobGlzdF9lbXB0eSgmbW1uX21tLT5saXN0KSkp IHsKKwkJbW4gPSBobGlzdF9lbnRyeShtbW5fbW0tPmxpc3QuZmlyc3QsCiAJCQkJIHN0cnVjdCBt bXVfbm90aWZpZXIsCiAJCQkJIGhsaXN0KTsKIAkJLyoKQEAgLTg1LDcgKzMyNiw3IEBAIHZvaWQg X19tbXVfbm90aWZpZXJfcmVsZWFzZShzdHJ1Y3QgbW1fc3RydWN0ICptbSkKIAkJICovCiAJCWhs aXN0X2RlbF9pbml0X3JjdSgmbW4tPmhsaXN0KTsKIAl9Ci0Jc3Bpbl91bmxvY2soJm1tLT5tbXVf bm90aWZpZXJfbW0tPmxvY2spOworCXNwaW5fdW5sb2NrKCZtbW5fbW0tPmxvY2spOwogCXNyY3Vf cmVhZF91bmxvY2soJnNyY3UsIGlkKTsKIAogCS8qCkBAIC0xMDAsNiArMzQxLDE3IEBAIHZvaWQg X19tbXVfbm90aWZpZXJfcmVsZWFzZShzdHJ1Y3QgbW1fc3RydWN0ICptbSkKIAlzeW5jaHJvbml6 ZV9zcmN1KCZzcmN1KTsKIH0KIAordm9pZCBfX21tdV9ub3RpZmllcl9yZWxlYXNlKHN0cnVjdCBt bV9zdHJ1Y3QgKm1tKQoreworCXN0cnVjdCBtbXVfbm90aWZpZXJfbW0gKm1tbl9tbSA9IG1tLT5t bXVfbm90aWZpZXJfbW07CisKKwlpZiAobW1uX21tLT5oYXNfaW50ZXJ2YWwpCisJCW1uX2l0cmVl X3JlbGVhc2UobW1uX21tLCBtbSk7CisKKwlpZiAoIWhsaXN0X2VtcHR5KCZtbW5fbW0tPmxpc3Qp KQorCQltbl9obGlzdF9yZWxlYXNlKG1tbl9tbSwgbW0pOworfQorCiAvKgogICogSWYgbm8geW91 bmcgYml0ZmxhZyBpcyBzdXBwb3J0ZWQgYnkgdGhlIGhhcmR3YXJlLCAtPmNsZWFyX2ZsdXNoX3lv dW5nIGNhbgogICogdW5tYXAgdGhlIGFkZHJlc3MgYW5kIHJldHVybiAxIG9yIDAgZGVwZW5kaW5n IGlmIHRoZSBtYXBwaW5nIHByZXZpb3VzbHkKQEAgLTE3MiwxNCArNDI0LDQzIEBAIHZvaWQgX19t bXVfbm90aWZpZXJfY2hhbmdlX3B0ZShzdHJ1Y3QgbW1fc3RydWN0ICptbSwgdW5zaWduZWQgbG9u ZyBhZGRyZXNzLAogCXNyY3VfcmVhZF91bmxvY2soJnNyY3UsIGlkKTsKIH0KIAotaW50IF9fbW11 X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnQoc3RydWN0IG1tdV9ub3RpZmllcl9yYW5n ZSAqcmFuZ2UpCitzdGF0aWMgaW50IG1uX2l0cmVlX2ludmFsaWRhdGUoc3RydWN0IG1tdV9ub3Rp Zmllcl9tbSAqbW1uX21tLAorCQkJCSAgICAgY29uc3Qgc3RydWN0IG1tdV9ub3RpZmllcl9yYW5n ZSAqcmFuZ2UpCit7CisJc3RydWN0IG1tdV9yYW5nZV9ub3RpZmllciAqbXJuOworCXVuc2lnbmVk IGxvbmcgY3VyX3NlcTsKKworCWZvciAobXJuID0gbW5faXRyZWVfaW52X3N0YXJ0X3JhbmdlKG1t bl9tbSwgcmFuZ2UsICZjdXJfc2VxKTsgbXJuOworCSAgICAgbXJuID0gbW5faXRyZWVfaW52X25l eHQobXJuLCByYW5nZSkpIHsKKwkJYm9vbCByZXQ7CisKKwkJcmV0ID0gbXJuLT5vcHMtPmludmFs aWRhdGUobXJuLCByYW5nZSwgY3VyX3NlcSk7CisJCWlmICghcmV0KSB7CisJCQlpZiAoV0FSTl9P TihtbXVfbm90aWZpZXJfcmFuZ2VfYmxvY2thYmxlKHJhbmdlKSkpCisJCQkJY29udGludWU7CisJ CQlnb3RvIG91dF93b3VsZF9ibG9jazsKKwkJfQorCX0KKwlyZXR1cm4gMDsKKworb3V0X3dvdWxk X2Jsb2NrOgorCS8qCisJICogT24gLUVBR0FJTiB0aGUgbm9uLWJsb2NraW5nIGNhbGxlciBpcyBu b3QgYWxsb3dlZCB0byBjYWxsCisJICogaW52YWxpZGF0ZV9yYW5nZV9lbmQoKQorCSAqLworCW1u X2l0cmVlX2ludl9lbmQobW1uX21tKTsKKwlyZXR1cm4gLUVBR0FJTjsKK30KKworc3RhdGljIGlu dCBtbl9obGlzdF9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KHN0cnVjdCBtbXVfbm90aWZpZXJfbW0g Km1tbl9tbSwKKwkJCQkJICAgc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAqcmFuZ2UpCiB7CiAJ c3RydWN0IG1tdV9ub3RpZmllciAqbW47CiAJaW50IHJldCA9IDA7CiAJaW50IGlkOwogCiAJaWQg PSBzcmN1X3JlYWRfbG9jaygmc3JjdSk7Ci0JaGxpc3RfZm9yX2VhY2hfZW50cnlfcmN1KG1uLCAm cmFuZ2UtPm1tLT5tbXVfbm90aWZpZXJfbW0tPmxpc3QsIGhsaXN0KSB7CisJaGxpc3RfZm9yX2Vh Y2hfZW50cnlfcmN1KG1uLCAmbW1uX21tLT5saXN0LCBobGlzdCkgewogCQlpZiAobW4tPm9wcy0+ aW52YWxpZGF0ZV9yYW5nZV9zdGFydCkgewogCQkJaW50IF9yZXQ7CiAKQEAgLTIwMywxNSArNDg0 LDMwIEBAIGludCBfX21tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KHN0cnVjdCBt bXVfbm90aWZpZXJfcmFuZ2UgKnJhbmdlKQogCXJldHVybiByZXQ7CiB9CiAKLXZvaWQgX19tbXVf bm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZV9lbmQoc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAq cmFuZ2UsCi0JCQkJCSBib29sIG9ubHlfZW5kKQoraW50IF9fbW11X25vdGlmaWVyX2ludmFsaWRh dGVfcmFuZ2Vfc3RhcnQoc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAqcmFuZ2UpCit7CisJc3Ry dWN0IG1tdV9ub3RpZmllcl9tbSAqbW1uX21tID0gcmFuZ2UtPm1tLT5tbXVfbm90aWZpZXJfbW07 CisJaW50IHJldCA9IDA7CisKKwlpZiAobW1uX21tLT5oYXNfaW50ZXJ2YWwpIHsKKwkJcmV0ID0g bW5faXRyZWVfaW52YWxpZGF0ZShtbW5fbW0sIHJhbmdlKTsKKwkJaWYgKHJldCkKKwkJCXJldHVy biByZXQ7CisJfQorCWlmICghaGxpc3RfZW1wdHkoJm1tbl9tbS0+bGlzdCkpCisJCXJldHVybiBt bl9obGlzdF9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KG1tbl9tbSwgcmFuZ2UpOworCXJldHVybiAw OworfQorCitzdGF0aWMgdm9pZCBtbl9obGlzdF9pbnZhbGlkYXRlX2VuZChzdHJ1Y3QgbW11X25v dGlmaWVyX21tICptbW5fbW0sCisJCQkJICAgIHN0cnVjdCBtbXVfbm90aWZpZXJfcmFuZ2UgKnJh bmdlLAorCQkJCSAgICBib29sIG9ubHlfZW5kKQogewogCXN0cnVjdCBtbXVfbm90aWZpZXIgKm1u OwogCWludCBpZDsKIAotCWxvY2tfbWFwX2FjcXVpcmUoJl9fbW11X25vdGlmaWVyX2ludmFsaWRh dGVfcmFuZ2Vfc3RhcnRfbWFwKTsKIAlpZCA9IHNyY3VfcmVhZF9sb2NrKCZzcmN1KTsKLQlobGlz dF9mb3JfZWFjaF9lbnRyeV9yY3UobW4sICZyYW5nZS0+bW0tPm1tdV9ub3RpZmllcl9tbS0+bGlz dCwgaGxpc3QpIHsKKwlobGlzdF9mb3JfZWFjaF9lbnRyeV9yY3UobW4sICZtbW5fbW0tPmxpc3Qs IGhsaXN0KSB7CiAJCS8qCiAJCSAqIENhbGwgaW52YWxpZGF0ZV9yYW5nZSBoZXJlIHRvbyB0byBh dm9pZCB0aGUgbmVlZCBmb3IgdGhlCiAJCSAqIHN1YnN5c3RlbSBvZiBoYXZpbmcgdG8gcmVnaXN0 ZXIgYW4gaW52YWxpZGF0ZV9yYW5nZV9lbmQKQEAgLTIzOCw2ICs1MzQsMTkgQEAgdm9pZCBfX21t dV9ub3RpZmllcl9pbnZhbGlkYXRlX3JhbmdlX2VuZChzdHJ1Y3QgbW11X25vdGlmaWVyX3Jhbmdl ICpyYW5nZSwKIAkJfQogCX0KIAlzcmN1X3JlYWRfdW5sb2NrKCZzcmN1LCBpZCk7Cit9CisKK3Zv aWQgX19tbXVfbm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZV9lbmQoc3RydWN0IG1tdV9ub3RpZmll cl9yYW5nZSAqcmFuZ2UsCisJCQkJCSBib29sIG9ubHlfZW5kKQoreworCXN0cnVjdCBtbXVfbm90 aWZpZXJfbW0gKm1tbl9tbSA9IHJhbmdlLT5tbS0+bW11X25vdGlmaWVyX21tOworCisJbG9ja19t YXBfYWNxdWlyZSgmX19tbXVfbm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZV9zdGFydF9tYXApOwor CWlmIChtbW5fbW0tPmhhc19pbnRlcnZhbCkKKwkJbW5faXRyZWVfaW52X2VuZChtbW5fbW0pOwor CisJaWYgKCFobGlzdF9lbXB0eSgmbW1uX21tLT5saXN0KSkKKwkJbW5faGxpc3RfaW52YWxpZGF0 ZV9lbmQobW1uX21tLCByYW5nZSwgb25seV9lbmQpOwogCWxvY2tfbWFwX3JlbGVhc2UoJl9fbW11 X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnRfbWFwKTsKIH0KIApAQCAtMjU2LDggKzU2 NSw5IEBAIHZvaWQgX19tbXVfbm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZShzdHJ1Y3QgbW1fc3Ry dWN0ICptbSwKIH0KIAogLyoKLSAqIFNhbWUgYXMgbW11X25vdGlmaWVyX3JlZ2lzdGVyIGJ1dCBo ZXJlIHRoZSBjYWxsZXIgbXVzdCBob2xkIHRoZQotICogbW1hcF9zZW0gaW4gd3JpdGUgbW9kZS4K KyAqIFNhbWUgYXMgbW11X25vdGlmaWVyX3JlZ2lzdGVyIGJ1dCBoZXJlIHRoZSBjYWxsZXIgbXVz dCBob2xkIHRoZSBtbWFwX3NlbSBpbgorICogd3JpdGUgbW9kZS4gQSBOVUxMIG1uIHNpZ25hbHMg dGhlIG5vdGlmaWVyIGlzIGJlaW5nIHJlZ2lzdGVyZWQgZm9yIGl0cmVlCisgKiBtb2RlLgogICov CiBpbnQgX19tbXVfbm90aWZpZXJfcmVnaXN0ZXIoc3RydWN0IG1tdV9ub3RpZmllciAqbW4sIHN0 cnVjdCBtbV9zdHJ1Y3QgKm1tKQogewpAQCAtMjc0LDkgKzU4NCw2IEBAIGludCBfX21tdV9ub3Rp Zmllcl9yZWdpc3RlcihzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwgc3RydWN0IG1tX3N0cnVjdCAq bW0pCiAJCWZzX3JlY2xhaW1fcmVsZWFzZShHRlBfS0VSTkVMKTsKIAl9CiAKLQltbi0+bW0gPSBt bTsKLQltbi0+dXNlcnMgPSAxOwotCiAJaWYgKCFtbS0+bW11X25vdGlmaWVyX21tKSB7CiAJCS8q CiAJCSAqIGttYWxsb2MgY2Fubm90IGJlIGNhbGxlZCB1bmRlciBtbV90YWtlX2FsbF9sb2Nrcygp LCBidXQgd2UKQEAgLTI4NCwyMSArNTkxLDIyIEBAIGludCBfX21tdV9ub3RpZmllcl9yZWdpc3Rl cihzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwgc3RydWN0IG1tX3N0cnVjdCAqbW0pCiAJCSAqIHRo ZSB3cml0ZSBzaWRlIG9mIHRoZSBtbWFwX3NlbS4KIAkJICovCiAJCW1tdV9ub3RpZmllcl9tbSA9 Ci0JCQlrbWFsbG9jKHNpemVvZihzdHJ1Y3QgbW11X25vdGlmaWVyX21tKSwgR0ZQX0tFUk5FTCk7 CisJCQlremFsbG9jKHNpemVvZihzdHJ1Y3QgbW11X25vdGlmaWVyX21tKSwgR0ZQX0tFUk5FTCk7 CiAJCWlmICghbW11X25vdGlmaWVyX21tKQogCQkJcmV0dXJuIC1FTk9NRU07CiAKIAkJSU5JVF9I TElTVF9IRUFEKCZtbXVfbm90aWZpZXJfbW0tPmxpc3QpOwogCQlzcGluX2xvY2tfaW5pdCgmbW11 X25vdGlmaWVyX21tLT5sb2NrKTsKKwkJbW11X25vdGlmaWVyX21tLT5pbnZhbGlkYXRlX3NlcSA9 IDI7CisJCW1tdV9ub3RpZmllcl9tbS0+aXRyZWUgPSBSQl9ST09UX0NBQ0hFRDsKKwkJaW5pdF93 YWl0cXVldWVfaGVhZCgmbW11X25vdGlmaWVyX21tLT53cSk7CisJCUlOSVRfSExJU1RfSEVBRCgm bW11X25vdGlmaWVyX21tLT5kZWZlcnJlZF9saXN0KTsKIAl9CiAKIAlyZXQgPSBtbV90YWtlX2Fs bF9sb2NrcyhtbSk7CiAJaWYgKHVubGlrZWx5KHJldCkpCiAJCWdvdG8gb3V0X2NsZWFuOwogCi0J LyogUGFpcnMgd2l0aCB0aGUgbW1kcm9wIGluIG1tdV9ub3RpZmllcl91bnJlZ2lzdGVyXyogKi8K LQltbWdyYWIobW0pOwotCiAJLyoKIAkgKiBTZXJpYWxpemUgdGhlIHVwZGF0ZSBhZ2FpbnN0IG1t dV9ub3RpZmllcl91bnJlZ2lzdGVyLiBBCiAJICogc2lkZSBub3RlOiBtbXVfbm90aWZpZXJfcmVs ZWFzZSBjYW4ndCBydW4gY29uY3VycmVudGx5IHdpdGgKQEAgLTMwNiwxMyArNjE0LDI4IEBAIGlu dCBfX21tdV9ub3RpZmllcl9yZWdpc3RlcihzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwgc3RydWN0 IG1tX3N0cnVjdCAqbW0pCiAJICogY3VycmVudC0+bW0gb3IgZXhwbGljaXRseSB3aXRoIGdldF90 YXNrX21tKCkgb3Igc2ltaWxhcikuCiAJICogV2UgY2FuJ3QgcmFjZSBhZ2FpbnN0IGFueSBvdGhl ciBtbXUgbm90aWZpZXIgbWV0aG9kIGVpdGhlcgogCSAqIHRoYW5rcyB0byBtbV90YWtlX2FsbF9s b2NrcygpLgorCSAqCisJICogcmVsZWFzZSBzZW1hbnRpY3Mgb24gdGhlIGluaXRpYWxpemF0aW9u IG9mIHRoZSBtbXVfbm90aWZpZXJfbW0ncworICAgICAgICAgKiBjb250ZW50cyBhcmUgcHJvdmlk ZWQgZm9yIHVubG9ja2VkIHJlYWRlcnMuICBhY3F1aXJlIGNhbiBvbmx5IGJlCisgICAgICAgICAq IHVzZWQgd2hpbGUgaG9sZGluZyB0aGUgbW1ncmFiIG9yIG1tZ2V0LCBhbmQgaXMgc2FmZSBiZWNh dXNlIG9uY2UKKyAgICAgICAgICogY3JlYXRlZCB0aGUgbW11X25vdGlmaWZlcl9tbSBpcyBub3Qg ZnJlZWQgdW50aWwgdGhlIG1tIGlzCisgICAgICAgICAqIGRlc3Ryb3llZC4gIEFzIGFib3ZlLCB1 c2VycyBob2xkaW5nIHRoZSBtbWFwX3NlbSBvciBvbmUgb2YgdGhlCisgICAgICAgICAqIG1tX3Rh a2VfYWxsX2xvY2tzKCkgZG8gbm90IG5lZWQgdG8gdXNlIGFjcXVpcmUgc2VtYW50aWNzLgogCSAq LwogCWlmIChtbXVfbm90aWZpZXJfbW0pCi0JCW1tLT5tbXVfbm90aWZpZXJfbW0gPSBtbXVfbm90 aWZpZXJfbW07CisJCXNtcF9zdG9yZV9yZWxlYXNlKCZtbS0+bW11X25vdGlmaWVyX21tLCBtbXVf bm90aWZpZXJfbW0pOwogCi0Jc3Bpbl9sb2NrKCZtbS0+bW11X25vdGlmaWVyX21tLT5sb2NrKTsK LQlobGlzdF9hZGRfaGVhZF9yY3UoJm1uLT5obGlzdCwgJm1tLT5tbXVfbm90aWZpZXJfbW0tPmxp c3QpOwotCXNwaW5fdW5sb2NrKCZtbS0+bW11X25vdGlmaWVyX21tLT5sb2NrKTsKKwlpZiAobW4p IHsKKwkJLyogUGFpcnMgd2l0aCB0aGUgbW1kcm9wIGluIG1tdV9ub3RpZmllcl91bnJlZ2lzdGVy XyogKi8KKwkJbW1ncmFiKG1tKTsKKwkJbW4tPm1tID0gbW07CisJCW1uLT51c2VycyA9IDE7CisK KwkJc3Bpbl9sb2NrKCZtbS0+bW11X25vdGlmaWVyX21tLT5sb2NrKTsKKwkJaGxpc3RfYWRkX2hl YWRfcmN1KCZtbi0+aGxpc3QsICZtbS0+bW11X25vdGlmaWVyX21tLT5saXN0KTsKKwkJc3Bpbl91 bmxvY2soJm1tLT5tbXVfbm90aWZpZXJfbW0tPmxvY2spOworCX0gZWxzZQorCQltbS0+bW11X25v dGlmaWVyX21tLT5oYXNfaW50ZXJ2YWwgPSB0cnVlOwogCiAJbW1fZHJvcF9hbGxfbG9ja3MobW0p OwogCUJVR19PTihhdG9taWNfcmVhZCgmbW0tPm1tX3VzZXJzKSA8PSAwKTsKQEAgLTUyOSw2ICs4 NTIsMTY2IEBAIHZvaWQgbW11X25vdGlmaWVyX3B1dChzdHJ1Y3QgbW11X25vdGlmaWVyICptbikK IH0KIEVYUE9SVF9TWU1CT0xfR1BMKG1tdV9ub3RpZmllcl9wdXQpOwogCitzdGF0aWMgaW50IF9f bW11X3JhbmdlX25vdGlmaWVyX2luc2VydChzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyICptcm4s CisJCQkJICAgICAgIHVuc2lnbmVkIGxvbmcgc3RhcnQsCisJCQkJICAgICAgIHVuc2lnbmVkIGxv bmcgbGVuZ3RoLAorCQkJCSAgICAgICBzdHJ1Y3QgbW11X25vdGlmaWVyX21tICptbW5fbW0sCisJ CQkJICAgICAgIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQoreworCW1ybi0+bW0gPSBtbTsKKwlSQl9D TEVBUl9OT0RFKCZtcm4tPmludGVydmFsX3RyZWUucmIpOworCW1ybi0+aW50ZXJ2YWxfdHJlZS5z dGFydCA9IHN0YXJ0OworCS8qCisJICogTm90ZSB0aGF0IHRoZSByZXByZXNlbnRhdGlvbiBvZiB0 aGUgaW50ZXJ2YWxzIGluIHRoZSBpbnRlcnZhbCB0cmVlCisJICogY29uc2lkZXJzIHRoZSBlbmRp bmcgcG9pbnQgYXMgY29udGFpbmVkIGluIHRoZSBpbnRlcnZhbC4KKwkgKi8KKwlpZiAobGVuZ3Ro ID09IDAgfHwKKwkgICAgY2hlY2tfYWRkX292ZXJmbG93KHN0YXJ0LCBsZW5ndGggLSAxLCAmbXJu LT5pbnRlcnZhbF90cmVlLmxhc3QpKQorCQlyZXR1cm4gLUVPVkVSRkxPVzsKKworCS8qIHBhaXJz IHdpdGggbW1kcm9wIGluIG1tdV9yYW5nZV9ub3RpZmllcl9yZW1vdmUoKSAqLworCW1tZ3JhYiht bSk7CisKKwkvKgorCSAqIElmIHNvbWUgaW52YWxpZGF0ZV9yYW5nZV9zdGFydC9lbmQgcmVnaW9u IGlzIGdvaW5nIG9uIGluIHBhcmFsbGVsCisJICogd2UgZG9uJ3Qga25vdyB3aGF0IFZBIHJhbmdl cyBhcmUgYWZmZWN0ZWQsIHNvIHdlIG11c3QgYXNzdW1lIHRoaXMKKwkgKiBuZXcgcmFuZ2UgaXMg aW5jbHVkZWQuCisJICoKKwkgKiBJZiB0aGUgaXRyZWUgaXMgaW52YWxpZGF0aW5nIHRoZW4gd2Ug YXJlIG5vdCBhbGxvd2VkIHRvIGNoYW5nZQorCSAqIGl0LiBSZXRyeWluZyB1bnRpbCBpbnZhbGlk YXRpb24gaXMgZG9uZSBpcyB0cmlja3kgZHVlIHRvIHRoZQorCSAqIHBvc3NpYmlsaXR5IGZvciBs aXZlIGxvY2ssIGluc3RlYWQgZGVmZXIgdGhlIGFkZCB0byB0aGUgdW5sb2NrIHNvCisJICogdGhp cyBhbGdvcml0aG0gaXMgZGV0ZXJtaW5pc3RpYy4KKwkgKgorCSAqIEluIGFsbCBjYXNlcyB0aGUg dmFsdWUgZm9yIHRoZSBtcm4tPm1yX2ludmFsaWRhdGVfc2VxIHNob3VsZCBiZQorCSAqIG9kZCwg c2VlIG1tdV9yYW5nZV9yZWFkX2JlZ2luKCkKKwkgKi8KKwlzcGluX2xvY2soJm1tbl9tbS0+bG9j ayk7CisJaWYgKG1tbl9tbS0+YWN0aXZlX2ludmFsaWRhdGVfcmFuZ2VzKSB7CisJCWlmIChtbl9p dHJlZV9pc19pbnZhbGlkYXRpbmcobW1uX21tKSkKKwkJCWhsaXN0X2FkZF9oZWFkKCZtcm4tPmRl ZmVycmVkX2l0ZW0sCisJCQkJICAgICAgICZtbW5fbW0tPmRlZmVycmVkX2xpc3QpOworCQllbHNl IHsKKwkJCW1tbl9tbS0+aW52YWxpZGF0ZV9zZXEgfD0gMTsKKwkJCWludGVydmFsX3RyZWVfaW5z ZXJ0KCZtcm4tPmludGVydmFsX3RyZWUsCisJCQkJCSAgICAgJm1tbl9tbS0+aXRyZWUpOworCQl9 CisJCW1ybi0+aW52YWxpZGF0ZV9zZXEgPSBtbW5fbW0tPmludmFsaWRhdGVfc2VxOworCX0gZWxz ZSB7CisJCVdBUk5fT04obW5faXRyZWVfaXNfaW52YWxpZGF0aW5nKG1tbl9tbSkpOworCQltcm4t PmludmFsaWRhdGVfc2VxID0gbW1uX21tLT5pbnZhbGlkYXRlX3NlcSAtIDE7CisJCWludGVydmFs X3RyZWVfaW5zZXJ0KCZtcm4tPmludGVydmFsX3RyZWUsICZtbW5fbW0tPml0cmVlKTsKKwl9CisJ c3Bpbl91bmxvY2soJm1tbl9tbS0+bG9jayk7CisJcmV0dXJuIDA7Cit9CisKKy8qKgorICogbW11 X3JhbmdlX25vdGlmaWVyX2luc2VydCAtIEluc2VydCBhIHJhbmdlIG5vdGlmaWVyCisgKiBAbXJu OiBSYW5nZSBub3RpZmllciB0byByZWdpc3RlcgorICogQHN0YXJ0OiBTdGFydGluZyB2aXJ0dWFs IGFkZHJlc3MgdG8gbW9uaXRvcgorICogQGxlbmd0aDogTGVuZ3RoIG9mIHRoZSByYW5nZSB0byBt b25pdG9yCisgKiBAbW0gOiBtbV9zdHJ1Y3QgdG8gYXR0YWNoIHRvCisgKgorICogVGhpcyBmdW5j dGlvbiBzdWJzY3JpYmVzIHRoZSByYW5nZSBub3RpZmllciBmb3Igbm90aWZpY2F0aW9ucyBmcm9t IHRoZSBtbS4KKyAqIFVwb24gcmV0dXJuIHRoZSBvcHMgcmVsYXRlZCB0byBtbXVfcmFuZ2Vfbm90 aWZpZXIgd2lsbCBiZSBjYWxsZWQgd2hlbmV2ZXIKKyAqIGFuIGV2ZW50IHRoYXQgaW50ZXJzZWN0 cyB3aXRoIHRoZSBnaXZlbiByYW5nZSBvY2N1cnMuCisgKgorICogVXBvbiByZXR1cm4gdGhlIHJh bmdlX25vdGlmaWVyIG1heSBub3QgYmUgcHJlc2VudCBpbiB0aGUgaW50ZXJ2YWwgdHJlZSB5ZXQu CisgKiBUaGUgY2FsbGVyIG11c3QgdXNlIHRoZSBub3JtYWwgcmFuZ2Ugbm90aWZpZXIgbG9ja2lu ZyBmbG93IHZpYQorICogbW11X3JhbmdlX3JlYWRfYmVnaW4oKSB0byBlc3RhYmxpc2ggU1BURXMg Zm9yIHRoaXMgcmFuZ2UuCisgKi8KK2ludCBtbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0KHN0cnVj dCBtbXVfcmFuZ2Vfbm90aWZpZXIgKm1ybiwKKwkJCSAgICAgIHVuc2lnbmVkIGxvbmcgc3RhcnQs IHVuc2lnbmVkIGxvbmcgbGVuZ3RoLAorCQkJICAgICAgc3RydWN0IG1tX3N0cnVjdCAqbW0pCit7 CisJc3RydWN0IG1tdV9ub3RpZmllcl9tbSAqbW1uX21tOworCWludCByZXQ7CisKKwltaWdodF9s b2NrKCZtbS0+bW1hcF9zZW0pOworCisJbW1uX21tID0gc21wX2xvYWRfYWNxdWlyZSgmbW0tPm1t dV9ub3RpZmllcl9tbSk7CisJaWYgKCFtbW5fbW0gfHwgIW1tbl9tbS0+aGFzX2ludGVydmFsKSB7 CisJCXJldCA9IG1tdV9ub3RpZmllcl9yZWdpc3RlcihOVUxMLCBtbSk7CisJCWlmIChyZXQpCisJ CQlyZXR1cm4gcmV0OworCQltbW5fbW0gPSBtbS0+bW11X25vdGlmaWVyX21tOworCX0KKwlyZXR1 cm4gX19tbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0KG1ybiwgc3RhcnQsIGxlbmd0aCwgbW1uX21t LCBtbSk7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChtbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0KTsK KworaW50IG1tdV9yYW5nZV9ub3RpZmllcl9pbnNlcnRfbG9ja2VkKHN0cnVjdCBtbXVfcmFuZ2Vf bm90aWZpZXIgKm1ybiwKKwkJCQkgICAgIHVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxv bmcgbGVuZ3RoLAorCQkJCSAgICAgc3RydWN0IG1tX3N0cnVjdCAqbW0pCit7CisJc3RydWN0IG1t dV9ub3RpZmllcl9tbSAqbW1uX21tOworCWludCByZXQ7CisKKwlsb2NrZGVwX2Fzc2VydF9oZWxk X3dyaXRlKCZtbS0+bW1hcF9zZW0pOworCisJbW1uX21tID0gbW0tPm1tdV9ub3RpZmllcl9tbTsK KwlpZiAoIW1tbl9tbSB8fCAhbW1uX21tLT5oYXNfaW50ZXJ2YWwpIHsKKwkJcmV0ID0gX19tbXVf bm90aWZpZXJfcmVnaXN0ZXIoTlVMTCwgbW0pOworCQlpZiAocmV0KQorCQkJcmV0dXJuIHJldDsK KwkJbW1uX21tID0gbW0tPm1tdV9ub3RpZmllcl9tbTsKKwl9CisJcmV0dXJuIF9fbW11X3Jhbmdl X25vdGlmaWVyX2luc2VydChtcm4sIHN0YXJ0LCBsZW5ndGgsIG1tbl9tbSwgbW0pOworfQorRVhQ T1JUX1NZTUJPTF9HUEwobW11X3JhbmdlX25vdGlmaWVyX2luc2VydF9sb2NrZWQpOworCisvKioK KyAqIG1tdV9yYW5nZV9ub3RpZmllcl9yZW1vdmUgLSBSZW1vdmUgYSByYW5nZSBub3RpZmllcgor ICogQG1ybjogUmFuZ2Ugbm90aWZpZXIgdG8gdW5yZWdpc3RlcgorICoKKyAqIFRoaXMgZnVuY3Rp b24gbXVzdCBiZSBwYWlyZWQgd2l0aCBtbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0KCkuIEl0IGNh bm5vdCBiZQorICogY2FsbGVkIGZyb20gYW55IG9wcyBjYWxsYmFjay4KKyAqCisgKiBPbmNlIHRo aXMgcmV0dXJucyBvcHMgY2FsbGJhY2tzIGFyZSBubyBsb25nZXIgcnVubmluZyBvbiBvdGhlciBD UFVzIGFuZAorICogd2lsbCBub3QgYmUgY2FsbGVkIGluIGZ1dHVyZS4KKyAqLwordm9pZCBtbXVf cmFuZ2Vfbm90aWZpZXJfcmVtb3ZlKHN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXIgKm1ybikKK3sK KwlzdHJ1Y3QgbW1fc3RydWN0ICptbSA9IG1ybi0+bW07CisJc3RydWN0IG1tdV9ub3RpZmllcl9t bSAqbW1uX21tID0gbW0tPm1tdV9ub3RpZmllcl9tbTsKKwl1bnNpZ25lZCBsb25nIHNlcSA9IDA7 CisKKwltaWdodF9zbGVlcCgpOworCisJc3Bpbl9sb2NrKCZtbW5fbW0tPmxvY2spOworCWlmICht bl9pdHJlZV9pc19pbnZhbGlkYXRpbmcobW1uX21tKSkgeworCQkvKgorCQkgKiByZW1vdmUgaXMg YmVpbmcgY2FsbGVkIGFmdGVyIGluc2VydCBwdXQgdGhpcyBvbiB0aGUKKwkJICogZGVmZXJyZWQg bGlzdCwgYnV0IGJlZm9yZSB0aGUgZGVmZXJyZWQgbGlzdCB3YXMgcHJvY2Vzc2VkLgorCQkgKi8K KwkJaWYgKFJCX0VNUFRZX05PREUoJm1ybi0+aW50ZXJ2YWxfdHJlZS5yYikpIHsKKwkJCWhsaXN0 X2RlbCgmbXJuLT5kZWZlcnJlZF9pdGVtKTsKKwkJfSBlbHNlIHsKKwkJCWhsaXN0X2FkZF9oZWFk KCZtcm4tPmRlZmVycmVkX2l0ZW0sCisJCQkJICAgICAgICZtbW5fbW0tPmRlZmVycmVkX2xpc3Qp OworCQkJc2VxID0gbW1uX21tLT5pbnZhbGlkYXRlX3NlcTsKKwkJfQorCX0gZWxzZSB7CisJCVdB Uk5fT04oUkJfRU1QVFlfTk9ERSgmbXJuLT5pbnRlcnZhbF90cmVlLnJiKSk7CisJCWludGVydmFs X3RyZWVfcmVtb3ZlKCZtcm4tPmludGVydmFsX3RyZWUsICZtbW5fbW0tPml0cmVlKTsKKwl9CisJ c3Bpbl91bmxvY2soJm1tbl9tbS0+bG9jayk7CisKKwkvKgorCSAqIFRoZSBwb3NzaWJsZSBzbGVl cCBvbiBwcm9ncmVzcyBpbiB0aGUgaW52YWxpZGF0aW9uIHJlcXVpcmVzIHRoZQorCSAqIGNhbGxl ciBub3QgaG9sZCBhbnkgbG9ja3MgaGVsZCBieSBpbnZhbGlkYXRpb24gY2FsbGJhY2tzLgorCSAq LworCWxvY2tfbWFwX2FjcXVpcmUoJl9fbW11X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3Rh cnRfbWFwKTsKKwlsb2NrX21hcF9yZWxlYXNlKCZfX21tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3Jh bmdlX3N0YXJ0X21hcCk7CisJaWYgKHNlcSkKKwkJd2FpdF9ldmVudChtbW5fbW0tPndxLAorCQkJ ICAgUkVBRF9PTkNFKG1tbl9tbS0+aW52YWxpZGF0ZV9zZXEpICE9IHNlcSk7CisKKwkvKiBwYWly cyB3aXRoIG1tZ3JhYiBpbiBtbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0KCkgKi8KKwltbWRyb3Ao bW0pOworfQorRVhQT1JUX1NZTUJPTF9HUEwobW11X3JhbmdlX25vdGlmaWVyX3JlbW92ZSk7CisK IC8qKgogICogbW11X25vdGlmaWVyX3N5bmNocm9uaXplIC0gRW5zdXJlIGFsbCBtbXVfbm90aWZp ZXJzIGFyZSBmcmVlZAogICoKLS0gCjIuMjMuMAoKCl9fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fClhlbi1kZXZlbCBtYWlsaW5nIGxpc3QKWGVuLWRldmVsQGxp c3RzLnhlbnByb2plY3Qub3JnCmh0dHBzOi8vbGlzdHMueGVucHJvamVjdC5vcmcvbWFpbG1hbi9s aXN0aW5mby94ZW4tZGV2ZWw= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id E1E25CA9EC0 for ; Mon, 28 Oct 2019 20:17:19 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id C51F521721 for ; Mon, 28 Oct 2019 20:17:19 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org C51F521721 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=ziepe.ca Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=amd-gfx-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 420B26E9F9; Mon, 28 Oct 2019 20:17:17 +0000 (UTC) Received: from mail-qk1-x744.google.com (mail-qk1-x744.google.com [IPv6:2607:f8b0:4864:20::744]) by gabe.freedesktop.org (Postfix) with ESMTPS id 5384289DE6 for ; Mon, 28 Oct 2019 20:10:45 +0000 (UTC) Received: by mail-qk1-x744.google.com with SMTP id e2so1216226qkn.5 for ; Mon, 28 Oct 2019 13:10:45 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=H6qkKhlE377yexDDU3hhVTFW0t+EXROxR6aal9KdQe4=; b=BU3RAKuXTTxMjAjvFq/rNNfos0HjNIwuHJUChjudsom6ScjWWoXEr1V3Ovh3aFoKvl rHS/cMSYY3QjJ+NkqfWgA1upJMkFfSF6/BiQUlY85PEY+96Z7fvyxNN5Bn8kg9Zk2VQB bo6aYGw7Jr6xhvVeW/TCBGSb0qY93Csgj53vU3LgNf1bBAlZUsDus2L0ZfDasorEx1vq Iuy9WByDajqMtV8ZmEoF1V4AzJ0LfCpYHjOGhR6GYT8F1gwW9mpcmdHX7i3kxtFSj7ET FWwrkirbLMvYQiu738b0ul1sDcOy5X4qmPC92jd6+ZzkSY1hhlgiuQJnX+PAIcLxsGO/ r+gg== X-Gm-Message-State: APjAAAX+XuT3xUuyGkYxMdSfvxLYd4ZGKAETx2knSSC+YHHpUeg0NiGq //2Z4ItDiSZ5UOtLUc4KnupguQ== X-Google-Smtp-Source: APXvYqwcJctJ4wjkPX/iRBrM71GSQB516ozrtr/cgoYC3wlErfDwUG/hWnwhh/5dQ5u5+5Pie/tT7A== X-Received: by 2002:a37:7c42:: with SMTP id x63mr13834494qkc.134.1572293444160; Mon, 28 Oct 2019 13:10:44 -0700 (PDT) Received: from ziepe.ca (hlfxns017vw-142-162-113-180.dhcp-dynamic.fibreop.ns.bellaliant.net. [142.162.113.180]) by smtp.gmail.com with ESMTPSA id t65sm6325908qkh.23.2019.10.28.13.10.43 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Mon, 28 Oct 2019 13:10:44 -0700 (PDT) Received: from jgg by mlx.ziepe.ca with local (Exim 4.90_1) (envelope-from ) id 1iPBLf-0001gA-4C; Mon, 28 Oct 2019 17:10:43 -0300 From: Jason Gunthorpe To: linux-mm@kvack.org, Jerome Glisse , Ralph Campbell , John Hubbard , Felix.Kuehling@amd.com Subject: [PATCH v2 02/15] mm/mmu_notifier: add an interval tree notifier Date: Mon, 28 Oct 2019 17:10:19 -0300 Message-Id: <20191028201032.6352-3-jgg@ziepe.ca> X-Mailer: git-send-email 2.23.0 In-Reply-To: <20191028201032.6352-1-jgg@ziepe.ca> References: <20191028201032.6352-1-jgg@ziepe.ca> MIME-Version: 1.0 X-Mailman-Approved-At: Mon, 28 Oct 2019 20:17:16 +0000 X-Mailman-Original-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ziepe.ca; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=H6qkKhlE377yexDDU3hhVTFW0t+EXROxR6aal9KdQe4=; b=S58t6OhprBE5qw20UbAe+Vwse+w2lO/Up0h0lfqdRge/4nS1rXcCCsxlIno+C6MBwn eJxkhgL2L64qgxBPmUhWD6RFK5kf5e0ZelEdKRYLUIxrkTpbhVFOlRF9uwIgGHYVhyZn p43djgWgjcRWx88FI7pDFwEqr3ezye3qfqni5fPI5bTAKCKpVObL1YPw8nHvp+t0PDWo 8uNkbZbvEJJD1KQQGq6PO27jpJTe9bYV5khfvnCnHC1ClOhSnanJvpp5MF0tRIO9Gzbt bgIWXRYWbjzPF2+LqBI2sTQC4L5/nUfSvol6+joXWujgAwYghBBxAzRmxevNYuzjif4u swxA== X-BeenThere: amd-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Discussion list for AMD gfx List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Juergen Gross , David Zhou , Mike Marciniszyn , Stefano Stabellini , Andrea Arcangeli , Oleksandr Andrushchenko , linux-rdma@vger.kernel.org, nouveau@lists.freedesktop.org, Dennis Dalessandro , amd-gfx@lists.freedesktop.org, Michal Hocko , Christoph Hellwig , Jason Gunthorpe , dri-devel@lists.freedesktop.org, Alex Deucher , xen-devel@lists.xenproject.org, Boris Ostrovsky , Petr Cvek , =?UTF-8?q?Christian=20K=C3=B6nig?= , Ben Skeggs Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: amd-gfx-bounces@lists.freedesktop.org Sender: "amd-gfx" Message-ID: <20191028201019.DNO-U76hOyvj7D1yhcI7wAcWHHSQ1I7fgO5LshZeC5Y@z> RnJvbTogSmFzb24gR3VudGhvcnBlIDxqZ2dAbWVsbGFub3guY29tPgoKT2YgdGhlIDEzIHVzZXJz IG9mIG1tdV9ub3RpZmllcnMsIDggb2YgdGhlbSB1c2Ugb25seQppbnZhbGlkYXRlX3JhbmdlX3N0 YXJ0L2VuZCgpIGFuZCBpbW1lZGlhdGVseSBpbnRlcnNlY3QgdGhlCm1tdV9ub3RpZmllcl9yYW5n ZSB3aXRoIHNvbWUga2luZCBvZiBpbnRlcm5hbCBsaXN0IG9mIFZBcy4gIDQgdXNlIGFuCmludGVy dmFsIHRyZWUgKGk5MTVfZ2VtLCByYWRlb25fbW4sIHVtZW1fb2RwLCBoZmkxKS4gNCB1c2UgYSBs aW5rZWQgbGlzdApvZiBzb21lIGtpbmQgKHNjaWZfZG1hLCB2aG9zdCwgZ250ZGV2LCBobW0pCgpB bmQgdGhlIHJlbWFpbmluZyA1IGVpdGhlciBkb24ndCB1c2UgaW52YWxpZGF0ZV9yYW5nZV9zdGFy dCgpIG9yIGRvIHNvbWUKc3BlY2lhbCB0aGluZyB3aXRoIGl0LgoKSXQgdHVybnMgb3V0IHRoYXQg YnVpbGRpbmcgYSBjb3JyZWN0IHNjaGVtZSB3aXRoIGFuIGludGVydmFsIHRyZWUgaXMKcHJldHR5 IGNvbXBsaWNhdGVkLCBwYXJ0aWN1bGFybHkgaWYgdGhlIHVzZSBjYXNlIGlzIHN5bmNocm9uaXpp bmcgYWdhaW5zdAphbm90aGVyIHRocmVhZCBkb2luZyBnZXRfdXNlcl9wYWdlcygpLiAgTWFueSBv ZiB0aGVzZSBpbXBsZW1lbnRhdGlvbnMgaGF2ZQp2YXJpb3VzIHN1YnRsZSBhbmQgZGlmZmljdWx0 IHRvIGZpeCByYWNlcy4KClRoaXMgYXBwcm9hY2ggcHV0cyB0aGUgaW50ZXJ2YWwgdHJlZSBhcyBj b21tb24gY29kZSBhdCB0aGUgdG9wIG9mIHRoZSBtbXUKbm90aWZpZXIgY2FsbCB0cmVlIGFuZCBp bXBsZW1lbnRzIGEgc2hhcmVhYmxlIGxvY2tpbmcgc2NoZW1lLgoKSXQgaW5jbHVkZXM6CiAtIEFu IGludGVydmFsIHRyZWUgdHJhY2tpbmcgVkEgcmFuZ2VzLCB3aXRoIHBlci1yYW5nZSBjYWxsYmFj a3MKIC0gQSByZWFkL3dyaXRlIGxvY2tpbmcgc2NoZW1lIGZvciB0aGUgaW50ZXJ2YWwgdHJlZSB0 aGF0IGF2b2lkcwogICBzbGVlcGluZyBpbiB0aGUgbm90aWZpZXIgcGF0aCAoZm9yIE9PTSBraWxs ZXIpCiAtIEEgc2VxdWVuY2UgY291bnRlciBiYXNlZCBjb2xsaXNpb24tcmV0cnkgbG9ja2luZyBz Y2hlbWUgdG8gdGVsbAogICBkZXZpY2UgcGFnZSBmYXVsdCB0aGF0IGEgVkEgcmFuZ2UgaXMgYmVp bmcgY29uY3VycmVudGx5IGludmFsaWRhdGVkLgoKVGhpcyBpcyBiYXNlZCBvbiB2YXJpb3VzIGlk ZWFzOgotIGhtbSBhY2N1bXVsYXRlcyBpbnZhbGlkYXRlZCBWQSByYW5nZXMgYW5kIHJlbGVhc2Vz IHRoZW0gd2hlbiBhbGwKICBpbnZhbGlkYXRlcyBhcmUgZG9uZSwgdmlhIGFjdGl2ZV9pbnZhbGlk YXRlX3JhbmdlcyBjb3VudC4KICBUaGlzIGFwcHJvYWNoIGF2b2lkcyBoYXZpbmcgdG8gaW50ZXJz ZWN0IHRoZSBpbnRlcnZhbCB0cmVlIHR3aWNlIChhcwogIHVtZW1fb2RwIGRvZXMpIGF0IHRoZSBw b3RlbnRpYWwgY29zdCBvZiBhIGxvbmdlciBkZXZpY2UgcGFnZSBmYXVsdC4KCi0ga3ZtL3VtZW1f b2RwIHVzZSBhIHNlcXVlbmNlIGNvdW50ZXIgdG8gZHJpdmUgdGhlIGNvbGxpc2lvbiByZXRyeSwK ICB2aWEgaW52YWxpZGF0ZV9zZXEKCi0gYSBkZWZlcnJlZCB3b3JrIHRvZG8gbGlzdCBvbiB1bmxv Y2sgc2NoZW1lIGxpa2UgUlROTCwgdmlhIGRlZmVycmVkX2xpc3QuCiAgVGhpcyBtYWtlcyBhZGRp bmcvcmVtb3ZpbmcgaW50ZXJ2YWwgdHJlZSBtZW1iZXJzIG1vcmUgZGV0ZXJtaW5pc3RpYwoKLSBz ZXFsb2NrLCBleGNlcHQgdGhpcyB2ZXJzaW9uIG1ha2VzIHRoZSBzZXFsb2NrIGlkZWEgbXVsdGkt aG9sZGVyIG9uIHRoZQogIHdyaXRlIHNpZGUgYnkgcHJvdGVjdGluZyBpdCB3aXRoIGFjdGl2ZV9p bnZhbGlkYXRlX3JhbmdlcyBhbmQgYSBzcGlubG9jawoKVG8gbWluaW1pemUgTU0gb3ZlcmhlYWQg d2hlbiBvbmx5IHRoZSBpbnRlcnZhbCB0cmVlIGlzIGJlaW5nIHVzZWQsIHRoZQplbnRpcmUgU1JD VSBhbmQgaGxpc3Qgb3ZlcmhlYWRzIGFyZSBkcm9wcGVkIHVzaW5nIHNvbWUgc2ltcGxlCmJyYW5j aGVzLiBTaW1pbGFybHkgdGhlIGludGVydmFsIHRyZWUgb3ZlcmhlYWQgaXMgZHJvcHBlZCB3aGVu IGluIGhsaXN0Cm1vZGUuCgpUaGUgb3ZlcmhlYWQgZnJvbSB0aGUgbWFuZGF0b3J5IHNwaW5sb2Nr IGlzIGJyb2FkbHkgdGhlIHNhbWUgYXMgbW9zdCBvZgpleGlzdGluZyB1c2VycyB3aGljaCBhbHJl YWR5IGhhZCBhIGxvY2sgKG9yIHR3bykgb2Ygc29tZSBzb3J0IG9uIHRoZQppbnZhbGlkYXRpb24g cGF0aC4KCkNjOiBBbmRyZWEgQXJjYW5nZWxpIDxhYXJjYW5nZUByZWRoYXQuY29tPgpDYzogTWlj aGFsIEhvY2tvIDxtaG9ja29Aa2VybmVsLm9yZz4KQWNrZWQtYnk6IENocmlzdGlhbiBLw7ZuaWcg PGNocmlzdGlhbi5rb2VuaWdAYW1kLmNvbT4KU2lnbmVkLW9mZi1ieTogSmFzb24gR3VudGhvcnBl IDxqZ2dAbWVsbGFub3guY29tPgotLS0KIGluY2x1ZGUvbGludXgvbW11X25vdGlmaWVyLmggfCAg OTggKysrKysrKwogbW0vS2NvbmZpZyAgICAgICAgICAgICAgICAgICB8ICAgMSArCiBtbS9tbXVf bm90aWZpZXIuYyAgICAgICAgICAgIHwgNTMzICsrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKy0tCiAzIGZpbGVzIGNoYW5nZWQsIDYwNyBpbnNlcnRpb25zKCspLCAyNSBkZWxldGlvbnMo LSkKCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21tdV9ub3RpZmllci5oIGIvaW5jbHVkZS9s aW51eC9tbXVfbm90aWZpZXIuaAppbmRleCAxMmJkNjAzZDMxOGNlNy4uNTFiOTJiYTAxM2RkY2Ug MTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbW11X25vdGlmaWVyLmgKKysrIGIvaW5jbHVkZS9s aW51eC9tbXVfbm90aWZpZXIuaApAQCAtNiwxMCArNiwxMiBAQAogI2luY2x1ZGUgPGxpbnV4L3Nw aW5sb2NrLmg+CiAjaW5jbHVkZSA8bGludXgvbW1fdHlwZXMuaD4KICNpbmNsdWRlIDxsaW51eC9z cmN1Lmg+CisjaW5jbHVkZSA8bGludXgvaW50ZXJ2YWxfdHJlZS5oPgogCiBzdHJ1Y3QgbW11X25v dGlmaWVyX21tOwogc3RydWN0IG1tdV9ub3RpZmllcjsKIHN0cnVjdCBtbXVfbm90aWZpZXJfcmFu Z2U7CitzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyOwogCiAvKioKICAqIGVudW0gbW11X25vdGlm aWVyX2V2ZW50IC0gcmVhc29uIGZvciB0aGUgbW11IG5vdGlmaWVyIGNhbGxiYWNrCkBAIC0zMiw2 ICszNCw5IEBAIHN0cnVjdCBtbXVfbm90aWZpZXJfcmFuZ2U7CiAgKiBhY2Nlc3MgZmxhZ3MpLiBV c2VyIHNob3VsZCBzb2Z0IGRpcnR5IHRoZSBwYWdlIGluIHRoZSBlbmQgY2FsbGJhY2sgdG8gbWFr ZQogICogc3VyZSB0aGF0IGFueW9uZSByZWx5aW5nIG9uIHNvZnQgZGlydHluZXNzIGNhdGNoIHBh Z2VzIHRoYXQgbWlnaHQgYmUgd3JpdHRlbgogICogdGhyb3VnaCBub24gQ1BVIG1hcHBpbmdzLgor ICoKKyAqIEBNTVVfTk9USUZZX1JFTEVBU0U6IHVzZWQgZHVyaW5nIG1tdV9yYW5nZV9ub3RpZmll ciBpbnZhbGlkYXRlIHRvIHNpZ25hbCB0aGF0CisgKiB0aGUgbW0gcmVmY291bnQgaXMgemVybyBh bmQgdGhlIHJhbmdlIGlzIG5vIGxvbmdlciBhY2Nlc3NpYmxlLgogICovCiBlbnVtIG1tdV9ub3Rp Zmllcl9ldmVudCB7CiAJTU1VX05PVElGWV9VTk1BUCA9IDAsCkBAIC0zOSw2ICs0NCw3IEBAIGVu dW0gbW11X25vdGlmaWVyX2V2ZW50IHsKIAlNTVVfTk9USUZZX1BST1RFQ1RJT05fVk1BLAogCU1N VV9OT1RJRllfUFJPVEVDVElPTl9QQUdFLAogCU1NVV9OT1RJRllfU09GVF9ESVJUWSwKKwlNTVVf Tk9USUZZX1JFTEVBU0UsCiB9OwogCiAjZGVmaW5lIE1NVV9OT1RJRklFUl9SQU5HRV9CTE9DS0FC TEUgKDEgPDwgMCkKQEAgLTIyMiw2ICsyMjgsMjYgQEAgc3RydWN0IG1tdV9ub3RpZmllciB7CiAJ dW5zaWduZWQgaW50IHVzZXJzOwogfTsKIAorLyoqCisgKiBzdHJ1Y3QgbW11X3JhbmdlX25vdGlm aWVyX29wcworICogQGludmFsaWRhdGU6IFVwb24gcmV0dXJuIHRoZSBjYWxsZXIgbXVzdCBzdG9w IHVzaW5nIGFueSBTUFRFcyB3aXRoaW4gdGhpcworICogICAgICAgICAgICAgIHJhbmdlLCB0aGlz IGZ1bmN0aW9uIGNhbiBzbGVlcC4gUmV0dXJuIGZhbHNlIGlmIGJsb2NraW5nIHdhcworICogICAg ICAgICAgICAgIHJlcXVpcmVkIGJ1dCByYW5nZSBpcyBub24tYmxvY2tpbmcKKyAqLworc3RydWN0 IG1tdV9yYW5nZV9ub3RpZmllcl9vcHMgeworCWJvb2wgKCppbnZhbGlkYXRlKShzdHJ1Y3QgbW11 X3JhbmdlX25vdGlmaWVyICptcm4sCisJCQkgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3Jh bmdlICpyYW5nZSwKKwkJCSAgIHVuc2lnbmVkIGxvbmcgY3VyX3NlcSk7Cit9OworCitzdHJ1Y3Qg bW11X3JhbmdlX25vdGlmaWVyIHsKKwlzdHJ1Y3QgaW50ZXJ2YWxfdHJlZV9ub2RlIGludGVydmFs X3RyZWU7CisJY29uc3Qgc3RydWN0IG1tdV9yYW5nZV9ub3RpZmllcl9vcHMgKm9wczsKKwlzdHJ1 Y3QgaGxpc3Rfbm9kZSBkZWZlcnJlZF9pdGVtOworCXVuc2lnbmVkIGxvbmcgaW52YWxpZGF0ZV9z ZXE7CisJc3RydWN0IG1tX3N0cnVjdCAqbW07Cit9OworCiAjaWZkZWYgQ09ORklHX01NVV9OT1RJ RklFUgogCiAjaWZkZWYgQ09ORklHX0xPQ0tERVAKQEAgLTI2Myw2ICsyODksNzggQEAgZXh0ZXJu IGludCBfX21tdV9ub3RpZmllcl9yZWdpc3RlcihzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwKIAkJ CQkgICBzdHJ1Y3QgbW1fc3RydWN0ICptbSk7CiBleHRlcm4gdm9pZCBtbXVfbm90aWZpZXJfdW5y ZWdpc3RlcihzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwKIAkJCQkgICAgc3RydWN0IG1tX3N0cnVj dCAqbW0pOworCit1bnNpZ25lZCBsb25nIG1tdV9yYW5nZV9yZWFkX2JlZ2luKHN0cnVjdCBtbXVf cmFuZ2Vfbm90aWZpZXIgKm1ybik7CitpbnQgbW11X3JhbmdlX25vdGlmaWVyX2luc2VydChzdHJ1 Y3QgbW11X3JhbmdlX25vdGlmaWVyICptcm4sCisJCQkgICAgICB1bnNpZ25lZCBsb25nIHN0YXJ0 LCB1bnNpZ25lZCBsb25nIGxlbmd0aCwKKwkJCSAgICAgIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKTsK K2ludCBtbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0X2xvY2tlZChzdHJ1Y3QgbW11X3JhbmdlX25v dGlmaWVyICptcm4sCisJCQkJICAgICB1bnNpZ25lZCBsb25nIHN0YXJ0LCB1bnNpZ25lZCBsb25n IGxlbmd0aCwKKwkJCQkgICAgIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKTsKK3ZvaWQgbW11X3Jhbmdl X25vdGlmaWVyX3JlbW92ZShzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyICptcm4pOworCisvKioK KyAqIG1tdV9yYW5nZV9zZXRfc2VxIC0gU2F2ZSB0aGUgaW52YWxpZGF0aW9uIHNlcXVlbmNlCisg KiBAbXJuIC0gVGhlIG1ybiBwYXNzZWQgdG8gaW52YWxpZGF0ZQorICogQGN1cl9zZXEgLSBUaGUg Y3VyX3NlcSBwYXNzZWQgdG8gaW52YWxpZGF0ZQorICoKKyAqIFRoaXMgbXVzdCBiZSBjYWxsZWQg dW5jb25kaXRpb25hbGx5IGZyb20gdGhlIGludmFsaWRhdGUgY2FsbGJhY2sgb2YgYQorICogc3Ry dWN0IG1tdV9yYW5nZV9ub3RpZmllcl9vcHMgdW5kZXIgdGhlIHNhbWUgbG9jayB0aGF0IGlzIHVz ZWQgdG8gY2FsbAorICogbW11X3JhbmdlX3JlYWRfcmV0cnkoKS4gSXQgdXBkYXRlcyB0aGUgc2Vx dWVuY2UgbnVtYmVyIGZvciBsYXRlciB1c2UgYnkKKyAqIG1tdV9yYW5nZV9yZWFkX3JldHJ5KCku CisgKgorICogSWYgdGhlIHVzZXIgZG9lcyBub3QgY2FsbCBtbXVfcmFuZ2VfcmVhZF9iZWdpbigp IG9yIG1tdV9yYW5nZV9yZWFkX3JldHJ5KCkKKyAqIHRoZW4gdGhpcyBjYWxsIGlzIG5vdCByZXF1 aXJlZC4KKyAqLworc3RhdGljIGlubGluZSB2b2lkIG1tdV9yYW5nZV9zZXRfc2VxKHN0cnVjdCBt bXVfcmFuZ2Vfbm90aWZpZXIgKm1ybiwKKwkJCQkgICAgIHVuc2lnbmVkIGxvbmcgY3VyX3NlcSkK K3sKKwlXUklURV9PTkNFKG1ybi0+aW52YWxpZGF0ZV9zZXEsIGN1cl9zZXEpOworfQorCisvKioK KyAqIG1tdV9yYW5nZV9yZWFkX3JldHJ5IC0gRW5kIGEgcmVhZCBzaWRlIGNyaXRpY2FsIHNlY3Rp b24gYWdhaW5zdCBhIFZBIHJhbmdlCisgKiBtcm46IFRoZSByYW5nZSB1bmRlciBsb2NrCisgKiBz ZXE6IFRoZSByZXR1cm4gb2YgdGhlIHBhaXJlZCBtbXVfcmFuZ2VfcmVhZF9iZWdpbigpCisgKgor ICogVGhpcyBNVVNUIGJlIGNhbGxlZCB1bmRlciBhIHVzZXIgcHJvdmlkZWQgbG9jayB0aGF0IGlz IGFsc28gaGVsZAorICogdW5jb25kaXRpb25hbGx5IGJ5IG9wLT5pbnZhbGlkYXRlKCkgd2hlbiBp dCBjYWxscyBtbXVfcmFuZ2Vfc2V0X3NlcSgpLgorICoKKyAqIEVhY2ggY2FsbCBzaG91bGQgYmUg cGFpcmVkIHdpdGggYSBzaW5nbGUgbW11X3JhbmdlX3JlYWRfYmVnaW4oKSBhbmQKKyAqIHNob3Vs ZCBiZSB1c2VkIHRvIGNvbmNsdWRlIHRoZSByZWFkIHNpZGUuCisgKgorICogUmV0dXJucyB0cnVl IGlmIGFuIGludmFsaWRhdGlvbiBjb2xsaWRlZCB3aXRoIHRoaXMgY3JpdGljYWwgc2VjdGlvbiwg YW5kCisgKiB0aGUgY2FsbGVyIHNob3VsZCByZXRyeS4KKyAqLworc3RhdGljIGlubGluZSBib29s IG1tdV9yYW5nZV9yZWFkX3JldHJ5KHN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXIgKm1ybiwKKwkJ CQkJdW5zaWduZWQgbG9uZyBzZXEpCit7CisJcmV0dXJuIG1ybi0+aW52YWxpZGF0ZV9zZXEgIT0g c2VxOworfQorCisvKioKKyAqIG1tdV9yYW5nZV9jaGVja19yZXRyeSAtIFRlc3QgaWYgYSBjb2xs aXNpb24gaGFzIG9jY3VycmVkCisgKiBtcm46IFRoZSByYW5nZSB1bmRlciBsb2NrCisgKiBzZXE6 IFRoZSByZXR1cm4gb2YgdGhlIG1hdGNoaW5nIG1tdV9yYW5nZV9yZWFkX2JlZ2luKCkKKyAqCisg KiBUaGlzIGNhbiBiZSB1c2VkIGluIHRoZSBjcml0aWNhbCBzZWN0aW9uIGJldHdlZW4gbW11X3Jh bmdlX3JlYWRfYmVnaW4oKSBhbmQKKyAqIG1tdV9yYW5nZV9yZWFkX3JldHJ5KCkuICBBIHJldHVy biBvZiB0cnVlIGluZGljYXRlcyBhbiBpbnZhbGlkYXRpb24gaGFzCisgKiBjb2xsaWRlZCB3aXRo IHRoaXMgbG9jayBhbmQgYSBmdXR1cmUgbW11X3JhbmdlX3JlYWRfcmV0cnkoKSB3aWxsIHJldHVy bgorICogdHJ1ZS4KKyAqCisgKiBGYWxzZSBpcyBub3QgcmVsaWFibGUgYW5kIG9ubHkgc3VnZ2Vz dHMgYSBjb2xsaXNpb24gaGFzIG5vdCBoYXBwZW5lZC4gSXQKKyAqIGNhbiBiZSBjYWxsZWQgbWFu eSB0aW1lcyBhbmQgZG9lcyBub3QgaGF2ZSB0byBob2xkIHRoZSB1c2VyIHByb3ZpZGVkIGxvY2su CisgKgorICogVGhpcyBjYWxsIGNhbiBiZSB1c2VkIGFzIHBhcnQgb2YgbG9vcHMgYW5kIG90aGVy IGV4cGVuc2l2ZSBvcGVyYXRpb25zIHRvCisgKiBleHBlZGl0ZSBhIHJldHJ5LgorICovCitzdGF0 aWMgaW5saW5lIGJvb2wgbW11X3JhbmdlX2NoZWNrX3JldHJ5KHN0cnVjdCBtbXVfcmFuZ2Vfbm90 aWZpZXIgKm1ybiwKKwkJCQkJIHVuc2lnbmVkIGxvbmcgc2VxKQoreworCS8qIFBhaXJzIHdpdGgg dGhlIFdSSVRFX09OQ0UgaW4gbW11X3JhbmdlX3NldF9zZXEoKSAqLworCXJldHVybiBSRUFEX09O Q0UobXJuLT5pbnZhbGlkYXRlX3NlcSkgIT0gc2VxOworfQorCiBleHRlcm4gdm9pZCBfX21tdV9u b3RpZmllcl9tbV9kZXN0cm95KHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKTsKIGV4dGVybiB2b2lkIF9f bW11X25vdGlmaWVyX3JlbGVhc2Uoc3RydWN0IG1tX3N0cnVjdCAqbW0pOwogZXh0ZXJuIGludCBf X21tdV9ub3RpZmllcl9jbGVhcl9mbHVzaF95b3VuZyhzdHJ1Y3QgbW1fc3RydWN0ICptbSwKZGlm ZiAtLWdpdCBhL21tL0tjb25maWcgYi9tbS9LY29uZmlnCmluZGV4IGE1ZGFlOWE3ZWI1MTBhLi5k MGI1MDQ2ZDlhZWZmZCAxMDA2NDQKLS0tIGEvbW0vS2NvbmZpZworKysgYi9tbS9LY29uZmlnCkBA IC0yODQsNiArMjg0LDcgQEAgY29uZmlnIFZJUlRfVE9fQlVTCiBjb25maWcgTU1VX05PVElGSUVS CiAJYm9vbAogCXNlbGVjdCBTUkNVCisJc2VsZWN0IElOVEVSVkFMX1RSRUUKIAogY29uZmlnIEtT TQogCWJvb2wgIkVuYWJsZSBLU00gZm9yIHBhZ2UgbWVyZ2luZyIKZGlmZiAtLWdpdCBhL21tL21t dV9ub3RpZmllci5jIGIvbW0vbW11X25vdGlmaWVyLmMKaW5kZXggMzY3NjcwY2ZkMDJiN2IuLmQw MmQzYzhjMjIzZWI3IDEwMDY0NAotLS0gYS9tbS9tbXVfbm90aWZpZXIuYworKysgYi9tbS9tbXVf bm90aWZpZXIuYwpAQCAtMTIsNiArMTIsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2V4cG9ydC5oPgog I2luY2x1ZGUgPGxpbnV4L21tLmg+CiAjaW5jbHVkZSA8bGludXgvZXJyLmg+CisjaW5jbHVkZSA8 bGludXgvaW50ZXJ2YWxfdHJlZS5oPgogI2luY2x1ZGUgPGxpbnV4L3NyY3UuaD4KICNpbmNsdWRl IDxsaW51eC9yY3VwZGF0ZS5oPgogI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CkBAIC0zNiwxMCAr MzcsMjQzIEBAIHN0cnVjdCBsb2NrZGVwX21hcCBfX21tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3Jh bmdlX3N0YXJ0X21hcCA9IHsKIHN0cnVjdCBtbXVfbm90aWZpZXJfbW0gewogCS8qIGFsbCBtbXUg bm90aWZpZXJzIHJlZ2lzdGVyZWQgaW4gdGhpcyBtbSBhcmUgcXVldWVkIGluIHRoaXMgbGlzdCAq LwogCXN0cnVjdCBobGlzdF9oZWFkIGxpc3Q7CisJYm9vbCBoYXNfaW50ZXJ2YWw7CiAJLyogdG8g c2VyaWFsaXplIHRoZSBsaXN0IG1vZGlmaWNhdGlvbnMgYW5kIGhsaXN0X3VuaGFzaGVkICovCiAJ c3BpbmxvY2tfdCBsb2NrOworCXVuc2lnbmVkIGxvbmcgaW52YWxpZGF0ZV9zZXE7CisJdW5zaWdu ZWQgbG9uZyBhY3RpdmVfaW52YWxpZGF0ZV9yYW5nZXM7CisJc3RydWN0IHJiX3Jvb3RfY2FjaGVk IGl0cmVlOworCXdhaXRfcXVldWVfaGVhZF90IHdxOworCXN0cnVjdCBobGlzdF9oZWFkIGRlZmVy cmVkX2xpc3Q7CiB9OwogCisvKgorICogVGhpcyBpcyBhIGNvbGxpc2lvbi1yZXRyeSByZWFkLXNp ZGUvd3JpdGUtc2lkZSAnbG9jaycsIGEgbG90IGxpa2UgYQorICogc2VxY291bnQsIGhvd2V2ZXIg dGhpcyBhbGxvd3MgbXVsdGlwbGUgd3JpdGUtc2lkZXMgdG8gaG9sZCBpdCBhdAorICogb25jZS4g Q29uY2VwdHVhbGx5IHRoZSB3cml0ZSBzaWRlIGlzIHByb3RlY3RpbmcgdGhlIHZhbHVlcyBvZiB0 aGUgUFRFcyBpbgorICogdGhpcyBtbSwgc3VjaCB0aGF0IFBURVMgY2Fubm90IGJlIHJlYWQgaW50 byBTUFRFcyB3aGlsZSBhbnkgd3JpdGVyIGV4aXN0cy4KKyAqCisgKiBOb3RlIHRoYXQgdGhlIGNv cmUgbW0gY3JlYXRlcyBuZXN0ZWQgaW52YWxpZGF0ZV9yYW5nZV9zdGFydCgpL2VuZCgpIHJlZ2lv bnMKKyAqIHdpdGhpbiB0aGUgc2FtZSB0aHJlYWQsIGFuZCBydW5zIGludmFsaWRhdGVfcmFuZ2Vf c3RhcnQoKS9lbmQoKSBpbiBwYXJhbGxlbAorICogb24gbXVsdGlwbGUgQ1BVcy4gVGhpcyBpcyBk ZXNpZ25lZCB0byBub3QgcmVkdWNlIGNvbmN1cnJlbmN5IG9yIGJsb2NrCisgKiBwcm9ncmVzcyBv biB0aGUgbW0gc2lkZS4KKyAqCisgKiBBcyBhIHNlY29uZGFyeSBmdW5jdGlvbiwgaG9sZGluZyB0 aGUgZnVsbCB3cml0ZSBzaWRlIGFsc28gc2VydmVzIHRvIHByZXZlbnQKKyAqIHdyaXRlcnMgZm9y IHRoZSBpdHJlZSwgdGhpcyBpcyBhbiBvcHRpbWl6YXRpb24gdG8gYXZvaWQgZXh0cmEgbG9ja2lu ZworICogZHVyaW5nIGludmFsaWRhdGVfcmFuZ2Vfc3RhcnQvZW5kIG5vdGlmaWVycy4KKyAqCisg KiBUaGUgd3JpdGUgc2lkZSBoYXMgdHdvIHN0YXRlcywgZnVsbHkgZXhjbHVkZWQ6CisgKiAgLSBt bS0+YWN0aXZlX2ludmFsaWRhdGVfcmFuZ2VzICE9IDAKKyAqICAtIG1ubi0+aW52YWxpZGF0ZV9z ZXEgJiAxID09IFRydWUKKyAqICAtIHNvbWUgcmFuZ2Ugb24gdGhlIG1tX3N0cnVjdCBpcyBiZWlu ZyBpbnZhbGlkYXRlZAorICogIC0gdGhlIGl0cmVlIGlzIG5vdCBhbGxvd2VkIHRvIGNoYW5nZQor ICoKKyAqIEFuZCBwYXJ0aWFsbHkgZXhjbHVkZWQ6CisgKiAgLSBtbS0+YWN0aXZlX2ludmFsaWRh dGVfcmFuZ2VzICE9IDAKKyAqICAtIHNvbWUgcmFuZ2Ugb24gdGhlIG1tX3N0cnVjdCBpcyBiZWlu ZyBpbnZhbGlkYXRlZAorICogIC0gdGhlIGl0cmVlIGlzIGFsbG93ZWQgdG8gY2hhbmdlCisgKgor ICogVGhlIGxhdGVyIHN0YXRlIGF2b2lkcyBzb21lIGV4cGVuc2l2ZSB3b3JrIG9uIGludl9lbmQg aW4gdGhlIGNvbW1vbiBjYXNlIG9mCisgKiBubyBtcm4gbW9uaXRvcmluZyB0aGUgVkEuCisgKi8K K3N0YXRpYyBib29sIG1uX2l0cmVlX2lzX2ludmFsaWRhdGluZyhzdHJ1Y3QgbW11X25vdGlmaWVy X21tICptbW5fbW0pCit7CisJbG9ja2RlcF9hc3NlcnRfaGVsZCgmbW1uX21tLT5sb2NrKTsKKwly ZXR1cm4gbW1uX21tLT5pbnZhbGlkYXRlX3NlcSAmIDE7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgbW11 X3JhbmdlX25vdGlmaWVyICoKK21uX2l0cmVlX2ludl9zdGFydF9yYW5nZShzdHJ1Y3QgbW11X25v dGlmaWVyX21tICptbW5fbW0sCisJCQkgY29uc3Qgc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAq cmFuZ2UsCisJCQkgdW5zaWduZWQgbG9uZyAqc2VxKQoreworCXN0cnVjdCBpbnRlcnZhbF90cmVl X25vZGUgKm5vZGU7CisJc3RydWN0IG1tdV9yYW5nZV9ub3RpZmllciAqcmVzID0gTlVMTDsKKwor CXNwaW5fbG9jaygmbW1uX21tLT5sb2NrKTsKKwltbW5fbW0tPmFjdGl2ZV9pbnZhbGlkYXRlX3Jh bmdlcysrOworCW5vZGUgPSBpbnRlcnZhbF90cmVlX2l0ZXJfZmlyc3QoJm1tbl9tbS0+aXRyZWUs IHJhbmdlLT5zdGFydCwKKwkJCQkJcmFuZ2UtPmVuZCAtIDEpOworCWlmIChub2RlKSB7CisJCW1t bl9tbS0+aW52YWxpZGF0ZV9zZXEgfD0gMTsKKwkJcmVzID0gY29udGFpbmVyX29mKG5vZGUsIHN0 cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXIsCisJCQkJICAgaW50ZXJ2YWxfdHJlZSk7CisJfQorCisJ KnNlcSA9IG1tbl9tbS0+aW52YWxpZGF0ZV9zZXE7CisJc3Bpbl91bmxvY2soJm1tbl9tbS0+bG9j ayk7CisJcmV0dXJuIHJlczsKK30KKworc3RhdGljIHN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXIg KgorbW5faXRyZWVfaW52X25leHQoc3RydWN0IG1tdV9yYW5nZV9ub3RpZmllciAqbXJuLAorCQkg IGNvbnN0IHN0cnVjdCBtbXVfbm90aWZpZXJfcmFuZ2UgKnJhbmdlKQoreworCXN0cnVjdCBpbnRl cnZhbF90cmVlX25vZGUgKm5vZGU7CisKKwlub2RlID0gaW50ZXJ2YWxfdHJlZV9pdGVyX25leHQo Jm1ybi0+aW50ZXJ2YWxfdHJlZSwgcmFuZ2UtPnN0YXJ0LAorCQkJCSAgICAgICByYW5nZS0+ZW5k IC0gMSk7CisJaWYgKCFub2RlKQorCQlyZXR1cm4gTlVMTDsKKwlyZXR1cm4gY29udGFpbmVyX29m KG5vZGUsIHN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXIsIGludGVydmFsX3RyZWUpOworfQorCitz dGF0aWMgdm9pZCBtbl9pdHJlZV9pbnZfZW5kKHN0cnVjdCBtbXVfbm90aWZpZXJfbW0gKm1tbl9t bSkKK3sKKwlzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyICptcm47CisJc3RydWN0IGhsaXN0X25v ZGUgKm5leHQ7CisJYm9vbCBuZWVkX3dha2UgPSBmYWxzZTsKKworCXNwaW5fbG9jaygmbW1uX21t LT5sb2NrKTsKKwlpZiAoLS1tbW5fbW0tPmFjdGl2ZV9pbnZhbGlkYXRlX3JhbmdlcyB8fAorCSAg ICAhbW5faXRyZWVfaXNfaW52YWxpZGF0aW5nKG1tbl9tbSkpIHsKKwkJc3Bpbl91bmxvY2soJm1t bl9tbS0+bG9jayk7CisJCXJldHVybjsKKwl9CisKKwltbW5fbW0tPmludmFsaWRhdGVfc2VxKys7 CisJbmVlZF93YWtlID0gdHJ1ZTsKKworCS8qCisJICogVGhlIGludl9lbmQgaW5jb3Jwb3JhdGVz IGEgZGVmZXJyZWQgbWVjaGFuaXNtIGxpa2UKKwkgKiBydG5sX2xvY2soKS4gQWRkcyBhbmQgcmVt b3ZlcyBhcmUgcXVldWVkIHVudGlsIHRoZSBmaW5hbCBpbnZfZW5kCisJICogaGFwcGVucyB0aGVu IHRoZXkgYXJlIHByb2dyZXNzZWQuIFRoaXMgYXJyYW5nZW1lbnQgZm9yIHRyZWUgdXBkYXRlcwor CSAqIGlzIHVzZWQgdG8gYXZvaWQgdXNpbmcgYSBibG9ja2luZyBsb2NrIGR1cmluZworCSAqIGlu dmFsaWRhdGVfcmFuZ2Vfc3RhcnQuCisJICovCisJaGxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZSht cm4sIG5leHQsICZtbW5fbW0tPmRlZmVycmVkX2xpc3QsCisJCQkJICBkZWZlcnJlZF9pdGVtKSB7 CisJCWlmIChSQl9FTVBUWV9OT0RFKCZtcm4tPmludGVydmFsX3RyZWUucmIpKQorCQkJaW50ZXJ2 YWxfdHJlZV9pbnNlcnQoJm1ybi0+aW50ZXJ2YWxfdHJlZSwKKwkJCQkJICAgICAmbW1uX21tLT5p dHJlZSk7CisJCWVsc2UKKwkJCWludGVydmFsX3RyZWVfcmVtb3ZlKCZtcm4tPmludGVydmFsX3Ry ZWUsCisJCQkJCSAgICAgJm1tbl9tbS0+aXRyZWUpOworCQlobGlzdF9kZWwoJm1ybi0+ZGVmZXJy ZWRfaXRlbSk7CisJfQorCXNwaW5fdW5sb2NrKCZtbW5fbW0tPmxvY2spOworCisJLyoKKwkgKiBU T0RPOiBTaW5jZSB3ZSBhbHJlYWR5IGhhdmUgYSBzcGlubG9jayBhYm92ZSwgdGhpcyB3b3VsZCBi ZSBmYXN0ZXIKKwkgKiBhcyB3YWtlX3VwX3EKKwkgKi8KKwlpZiAobmVlZF93YWtlKQorCQl3YWtl X3VwX2FsbCgmbW1uX21tLT53cSk7Cit9CisKKy8qKgorICogbW11X3JhbmdlX3JlYWRfYmVnaW4g LSBCZWdpbiBhIHJlYWQgc2lkZSBjcml0aWNhbCBzZWN0aW9uIGFnYWluc3QgYSBWQSByYW5nZQor ICogbXJuOiBUaGUgcmFuZ2UgdG8gbG9jaworICoKKyAqIG1tdV9yYW5nZV9yZWFkX2JlZ2luKCkv bW11X3JhbmdlX3JlYWRfcmV0cnkoKSBpbXBsZW1lbnQgYSBjb2xsaXNpb24tcmV0cnkKKyAqIGxv Y2tpbmcgc2NoZW1lIHNpbWlsYXIgdG8gc2VxY291bnQgZm9yIHRoZSBWQSByYW5nZSB1bmRlciBt cm4uIElmIHRoZSBtbQorICogaW52b2tlcyBpbnZhbGlkYXRpb24gZHVyaW5nIHRoZSBjcml0aWNh bCBzZWN0aW9uIHRoZW4KKyAqIG1tdV9yYW5nZV9yZWFkX3JldHJ5KCkgd2lsbCByZXR1cm4gdHJ1 ZS4KKyAqCisgKiBUaGlzIGlzIHVzZWZ1bCB0byBvYnRhaW4gc2hhZG93IFBURXMgd2hlcmUgdGVh cmRvd24gb3Igc2V0dXAgb2YgdGhlIFNQVEVzCisgKiByZXF1aXJlIGEgYmxvY2tpbmcgY29udGV4 dC4gIFRoZSBjcml0aWNhbCByZWdpb24gZm9ybWVkIGJ5IHRoaXMgbG9jayBjYW4KKyAqIHNsZWVw LCBhbmQgdGhlIHJlcXVpcmVkICd1c2VyX2xvY2snIGNhbiBhbHNvIGJlIGEgc2xlZXBpbmcgbG9j ay4KKyAqCisgKiBUaGUgY2FsbGVyIGlzIHJlcXVpcmVkIHRvIHByb3ZpZGUgYSAndXNlcl9sb2Nr JyB0byBzZXJpYWxpemUgYm90aCB0ZWFyZG93bgorICogYW5kIHNldHVwLgorICoKKyAqIFRoZSBy ZXR1cm4gdmFsdWUgc2hvdWxkIGJlIHBhc3NlZCB0byBtbXVfcmFuZ2VfcmVhZF9yZXRyeSgpLgor ICovCit1bnNpZ25lZCBsb25nIG1tdV9yYW5nZV9yZWFkX2JlZ2luKHN0cnVjdCBtbXVfcmFuZ2Vf bm90aWZpZXIgKm1ybikKK3sKKwlzdHJ1Y3QgbW11X25vdGlmaWVyX21tICptbW5fbW0gPSBtcm4t Pm1tLT5tbXVfbm90aWZpZXJfbW07CisJdW5zaWduZWQgbG9uZyBzZXE7CisJYm9vbCBpc19pbnZh bGlkYXRpbmc7CisKKwkvKgorCSAqIElmIHRoZSBtcm4gaGFzIGEgZGlmZmVyZW50IHNlcSB2YWx1 ZSB1bmRlciB0aGUgdXNlcl9sb2NrIHRoYW4gd2UKKwkgKiBzdGFydGVkIHdpdGggdGhlbiBpdCBo YXMgY29sbGlkZWQuCisJICoKKwkgKiBJZiB0aGUgbXJuIGN1cnJlbnRseSBoYXMgdGhlIHNhbWUg c2VxIHZhbHVlIGFzIHRoZSBtbW5fbW0gc2VxLCB0aGVuCisJICogaXQgaXMgY3VycmVudGx5IGJl dHdlZW4gaW52YWxpZGF0ZV9zdGFydC9lbmQgYW5kIGlzIGNvbGxpZGluZy4KKwkgKgorCSAqIFRo ZSBsb2NraW5nIGxvb2tzIGJyb2FkbHkgbGlrZSB0aGlzOgorCSAqICAgbW5fdHJlZV9pbnZhbGlk YXRlX3N0YXJ0KCk6ICAgICAgICAgIG1tdV9yYW5nZV9yZWFkX2JlZ2luKCk6CisJICogICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNwaW5fbG9jaworCSAqICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc2VxID0gUkVBRF9PTkNFKG1ybi0+aW52 YWxpZGF0ZV9zZXEpOworCSAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgc2VxID09IG1tbl9tbS0+aW52YWxpZGF0ZV9zZXEKKwkgKiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgc3Bpbl91bmxvY2sKKwkgKiAgICBzcGluX2xvY2sKKwkgKiAg ICAgc2VxID0gKyttbW5fbW0tPmludmFsaWRhdGVfc2VxCisJICogICAgc3Bpbl91bmxvY2sKKwkg KiAgICAgb3AtPmludmFsaWRhdGVfcmFuZ2UoKToKKwkgKiAgICAgICB1c2VyX2xvY2sKKwkgKiAg ICAgICAgbW11X3JhbmdlX3NldF9zZXEoKQorCSAqICAgICAgICAgbXJuLT5pbnZhbGlkYXRlX3Nl cSA9IHNlcQorCSAqICAgICAgIHVzZXJfdW5sb2NrCisJICoKKwkgKiAgICAgICAgICAgICAgICAg ICAgICAgICAgW1JlcXVpcmVkOiBtbXVfcmFuZ2VfcmVhZF9yZXRyeSgpID09IHRydWVdCisJICoK KwkgKiAgIG1uX2l0cmVlX2ludl9lbmQoKToKKwkgKiAgICBzcGluX2xvY2sKKwkgKiAgICAgc2Vx ID0gKyttbW5fbW0tPmludmFsaWRhdGVfc2VxCisJICogICAgc3Bpbl91bmxvY2sKKwkgKgorCSAq ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVzZXJfbG9jaworCSAqICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtbXVfcmFuZ2VfcmVhZF9yZXRy eSgpOgorCSAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbXJuLT5p bnZhbGlkYXRlX3NlcSAhPSBzZXEKKwkgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB1c2VyX3VubG9jaworCSAqCisJICogQmFycmllcnMgYXJlIG5vdCBuZWVkZWQgaGVy ZSBhcyBhbnkgcmFjZXMgaGVyZSBhcmUgY2xvc2VkIGJ5IGFuCisJICogZXZlbnR1YWwgbW11X3Jh bmdlX3JlYWRfcmV0cnkoKSwgd2hpY2ggcHJvdmlkZXMgYSBiYXJyaWVyIHZpYSB0aGUKKwkgKiB1 c2VyX2xvY2suCisJICovCisJc3Bpbl9sb2NrKCZtbW5fbW0tPmxvY2spOworCS8qIFBhaXJzIHdp dGggdGhlIFdSSVRFX09OQ0UgaW4gbW11X3JhbmdlX3NldF9zZXEoKSAqLworCXNlcSA9IFJFQURf T05DRShtcm4tPmludmFsaWRhdGVfc2VxKTsKKwlpc19pbnZhbGlkYXRpbmcgPSBzZXEgPT0gbW1u X21tLT5pbnZhbGlkYXRlX3NlcTsKKwlzcGluX3VubG9jaygmbW1uX21tLT5sb2NrKTsKKworCS8q CisJICogbXJuLT5pbnZhbGlkYXRlX3NlcSBpcyBhbHdheXMgc2V0IHRvIGFuIG9kZCB2YWx1ZS4g VGhpcyBlbnN1cmVzCisJICogdGhhdCBpZiBzZXEgZG9lcyB3cmFwIHdlIHdpbGwgYWx3YXlzIGNs ZWFyIHRoZSBiZWxvdyBzbGVlcCBpbiBzb21lCisJICogcmVhc29uYWJsZSB0aW1lIGFzIG1tbl9t bS0+aW52YWxpZGF0ZV9zZXEgaXMgZXZlbiBpbiB0aGUgaWRsZQorCSAqIHN0YXRlLgorCSAqLwor CWxvY2tfbWFwX2FjcXVpcmUoJl9fbW11X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnRf bWFwKTsKKwlsb2NrX21hcF9yZWxlYXNlKCZfX21tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3Jhbmdl X3N0YXJ0X21hcCk7CisJaWYgKGlzX2ludmFsaWRhdGluZykKKwkJd2FpdF9ldmVudChtbW5fbW0t PndxLAorCQkJICAgUkVBRF9PTkNFKG1tbl9tbS0+aW52YWxpZGF0ZV9zZXEpICE9IHNlcSk7CisK KwkvKgorCSAqIE5vdGljZSB0aGF0IG1tdV9yYW5nZV9yZWFkX3JldHJ5KCkgY2FuIGFscmVhZHkg YmUgdHJ1ZSBhdCB0aGlzCisJICogcG9pbnQsIGF2b2lkaW5nIGxvb3BzIGhlcmUgYWxsb3dzIHRo ZSB1c2VyIG9mIHRoaXMgbG9jayB0byBwcm92aWRlCisJICogYSBnbG9iYWwgdGltZSBib3VuZC4K KwkgKi8KKworCXJldHVybiBzZXE7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChtbXVfcmFuZ2VfcmVh ZF9iZWdpbik7CisKK3N0YXRpYyB2b2lkIG1uX2l0cmVlX3JlbGVhc2Uoc3RydWN0IG1tdV9ub3Rp Zmllcl9tbSAqbW1uX21tLAorCQkJICAgICBzdHJ1Y3QgbW1fc3RydWN0ICptbSkKK3sKKwlzdHJ1 Y3QgbW11X25vdGlmaWVyX3JhbmdlIHJhbmdlID0geworCQkuZmxhZ3MgPSBNTVVfTk9USUZJRVJf UkFOR0VfQkxPQ0tBQkxFLAorCQkuZXZlbnQgPSBNTVVfTk9USUZZX1JFTEVBU0UsCisJCS5tbSA9 IG1tLAorCQkuc3RhcnQgPSAwLAorCQkuZW5kID0gVUxPTkdfTUFYLAorCX07CisJc3RydWN0IG1t dV9yYW5nZV9ub3RpZmllciAqbXJuOworCXVuc2lnbmVkIGxvbmcgY3VyX3NlcTsKKwlib29sIHJl dDsKKworCWZvciAobXJuID0gbW5faXRyZWVfaW52X3N0YXJ0X3JhbmdlKG1tbl9tbSwgJnJhbmdl LCAmY3VyX3NlcSk7IG1ybjsKKwkgICAgIG1ybiA9IG1uX2l0cmVlX2ludl9uZXh0KG1ybiwgJnJh bmdlKSkgeworCQlyZXQgPSBtcm4tPm9wcy0+aW52YWxpZGF0ZShtcm4sICZyYW5nZSwgY3VyX3Nl cSk7CisJCVdBUk5fT04oIXJldCk7CisJfQorCisJbW5faXRyZWVfaW52X2VuZChtbW5fbW0pOwor fQorCiAvKgogICogVGhpcyBmdW5jdGlvbiBjYW4ndCBydW4gY29uY3VycmVudGx5IGFnYWluc3Qg bW11X25vdGlmaWVyX3JlZ2lzdGVyCiAgKiBiZWNhdXNlIG1tLT5tbV91c2VycyA+IDAgZHVyaW5n IG1tdV9ub3RpZmllcl9yZWdpc3RlciBhbmQgZXhpdF9tbWFwCkBAIC01MiwxNyArMjg2LDI0IEBA IHN0cnVjdCBtbXVfbm90aWZpZXJfbW0gewogICogY2FuJ3QgZ28gYXdheSBmcm9tIHVuZGVyIHVz IGFzIGV4aXRfbW1hcCBob2xkcyBhbiBtbV9jb3VudCBwaW4KICAqIGl0c2VsZi4KICAqLwotdm9p ZCBfX21tdV9ub3RpZmllcl9yZWxlYXNlKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQorc3RhdGljIHZv aWQgbW5faGxpc3RfcmVsZWFzZShzdHJ1Y3QgbW11X25vdGlmaWVyX21tICptbW5fbW0sCisJCQkg ICAgIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQogewogCXN0cnVjdCBtbXVfbm90aWZpZXIgKm1uOwog CWludCBpZDsKIAorCWlmIChtbW5fbW0tPmhhc19pbnRlcnZhbCkKKwkJbW5faXRyZWVfcmVsZWFz ZShtbW5fbW0sIG1tKTsKKworCWlmIChobGlzdF9lbXB0eSgmbW1uX21tLT5saXN0KSkKKwkJcmV0 dXJuOworCiAJLyoKIAkgKiBTUkNVIGhlcmUgd2lsbCBibG9jayBtbXVfbm90aWZpZXJfdW5yZWdp c3RlciB1bnRpbAogCSAqIC0+cmVsZWFzZSByZXR1cm5zLgogCSAqLwogCWlkID0gc3JjdV9yZWFk X2xvY2soJnNyY3UpOwotCWhsaXN0X2Zvcl9lYWNoX2VudHJ5X3JjdShtbiwgJm1tLT5tbXVfbm90 aWZpZXJfbW0tPmxpc3QsIGhsaXN0KQorCWhsaXN0X2Zvcl9lYWNoX2VudHJ5X3JjdShtbiwgJm1t bl9tbS0+bGlzdCwgaGxpc3QpCiAJCS8qCiAJCSAqIElmIC0+cmVsZWFzZSBydW5zIGJlZm9yZSBt bXVfbm90aWZpZXJfdW5yZWdpc3RlciBpdCBtdXN0IGJlCiAJCSAqIGhhbmRsZWQsIGFzIGl0J3Mg dGhlIG9ubHkgd2F5IGZvciB0aGUgZHJpdmVyIHRvIGZsdXNoIGFsbApAQCAtNzIsOSArMzEzLDkg QEAgdm9pZCBfX21tdV9ub3RpZmllcl9yZWxlYXNlKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQogCQlp ZiAobW4tPm9wcy0+cmVsZWFzZSkKIAkJCW1uLT5vcHMtPnJlbGVhc2UobW4sIG1tKTsKIAotCXNw aW5fbG9jaygmbW0tPm1tdV9ub3RpZmllcl9tbS0+bG9jayk7Ci0Jd2hpbGUgKHVubGlrZWx5KCFo bGlzdF9lbXB0eSgmbW0tPm1tdV9ub3RpZmllcl9tbS0+bGlzdCkpKSB7Ci0JCW1uID0gaGxpc3Rf ZW50cnkobW0tPm1tdV9ub3RpZmllcl9tbS0+bGlzdC5maXJzdCwKKwlzcGluX2xvY2soJm1tbl9t bS0+bG9jayk7CisJd2hpbGUgKHVubGlrZWx5KCFobGlzdF9lbXB0eSgmbW1uX21tLT5saXN0KSkp IHsKKwkJbW4gPSBobGlzdF9lbnRyeShtbW5fbW0tPmxpc3QuZmlyc3QsCiAJCQkJIHN0cnVjdCBt bXVfbm90aWZpZXIsCiAJCQkJIGhsaXN0KTsKIAkJLyoKQEAgLTg1LDcgKzMyNiw3IEBAIHZvaWQg X19tbXVfbm90aWZpZXJfcmVsZWFzZShzdHJ1Y3QgbW1fc3RydWN0ICptbSkKIAkJICovCiAJCWhs aXN0X2RlbF9pbml0X3JjdSgmbW4tPmhsaXN0KTsKIAl9Ci0Jc3Bpbl91bmxvY2soJm1tLT5tbXVf bm90aWZpZXJfbW0tPmxvY2spOworCXNwaW5fdW5sb2NrKCZtbW5fbW0tPmxvY2spOwogCXNyY3Vf cmVhZF91bmxvY2soJnNyY3UsIGlkKTsKIAogCS8qCkBAIC0xMDAsNiArMzQxLDE3IEBAIHZvaWQg X19tbXVfbm90aWZpZXJfcmVsZWFzZShzdHJ1Y3QgbW1fc3RydWN0ICptbSkKIAlzeW5jaHJvbml6 ZV9zcmN1KCZzcmN1KTsKIH0KIAordm9pZCBfX21tdV9ub3RpZmllcl9yZWxlYXNlKHN0cnVjdCBt bV9zdHJ1Y3QgKm1tKQoreworCXN0cnVjdCBtbXVfbm90aWZpZXJfbW0gKm1tbl9tbSA9IG1tLT5t bXVfbm90aWZpZXJfbW07CisKKwlpZiAobW1uX21tLT5oYXNfaW50ZXJ2YWwpCisJCW1uX2l0cmVl X3JlbGVhc2UobW1uX21tLCBtbSk7CisKKwlpZiAoIWhsaXN0X2VtcHR5KCZtbW5fbW0tPmxpc3Qp KQorCQltbl9obGlzdF9yZWxlYXNlKG1tbl9tbSwgbW0pOworfQorCiAvKgogICogSWYgbm8geW91 bmcgYml0ZmxhZyBpcyBzdXBwb3J0ZWQgYnkgdGhlIGhhcmR3YXJlLCAtPmNsZWFyX2ZsdXNoX3lv dW5nIGNhbgogICogdW5tYXAgdGhlIGFkZHJlc3MgYW5kIHJldHVybiAxIG9yIDAgZGVwZW5kaW5n IGlmIHRoZSBtYXBwaW5nIHByZXZpb3VzbHkKQEAgLTE3MiwxNCArNDI0LDQzIEBAIHZvaWQgX19t bXVfbm90aWZpZXJfY2hhbmdlX3B0ZShzdHJ1Y3QgbW1fc3RydWN0ICptbSwgdW5zaWduZWQgbG9u ZyBhZGRyZXNzLAogCXNyY3VfcmVhZF91bmxvY2soJnNyY3UsIGlkKTsKIH0KIAotaW50IF9fbW11 X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnQoc3RydWN0IG1tdV9ub3RpZmllcl9yYW5n ZSAqcmFuZ2UpCitzdGF0aWMgaW50IG1uX2l0cmVlX2ludmFsaWRhdGUoc3RydWN0IG1tdV9ub3Rp Zmllcl9tbSAqbW1uX21tLAorCQkJCSAgICAgY29uc3Qgc3RydWN0IG1tdV9ub3RpZmllcl9yYW5n ZSAqcmFuZ2UpCit7CisJc3RydWN0IG1tdV9yYW5nZV9ub3RpZmllciAqbXJuOworCXVuc2lnbmVk IGxvbmcgY3VyX3NlcTsKKworCWZvciAobXJuID0gbW5faXRyZWVfaW52X3N0YXJ0X3JhbmdlKG1t bl9tbSwgcmFuZ2UsICZjdXJfc2VxKTsgbXJuOworCSAgICAgbXJuID0gbW5faXRyZWVfaW52X25l eHQobXJuLCByYW5nZSkpIHsKKwkJYm9vbCByZXQ7CisKKwkJcmV0ID0gbXJuLT5vcHMtPmludmFs aWRhdGUobXJuLCByYW5nZSwgY3VyX3NlcSk7CisJCWlmICghcmV0KSB7CisJCQlpZiAoV0FSTl9P TihtbXVfbm90aWZpZXJfcmFuZ2VfYmxvY2thYmxlKHJhbmdlKSkpCisJCQkJY29udGludWU7CisJ CQlnb3RvIG91dF93b3VsZF9ibG9jazsKKwkJfQorCX0KKwlyZXR1cm4gMDsKKworb3V0X3dvdWxk X2Jsb2NrOgorCS8qCisJICogT24gLUVBR0FJTiB0aGUgbm9uLWJsb2NraW5nIGNhbGxlciBpcyBu b3QgYWxsb3dlZCB0byBjYWxsCisJICogaW52YWxpZGF0ZV9yYW5nZV9lbmQoKQorCSAqLworCW1u X2l0cmVlX2ludl9lbmQobW1uX21tKTsKKwlyZXR1cm4gLUVBR0FJTjsKK30KKworc3RhdGljIGlu dCBtbl9obGlzdF9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KHN0cnVjdCBtbXVfbm90aWZpZXJfbW0g Km1tbl9tbSwKKwkJCQkJICAgc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAqcmFuZ2UpCiB7CiAJ c3RydWN0IG1tdV9ub3RpZmllciAqbW47CiAJaW50IHJldCA9IDA7CiAJaW50IGlkOwogCiAJaWQg PSBzcmN1X3JlYWRfbG9jaygmc3JjdSk7Ci0JaGxpc3RfZm9yX2VhY2hfZW50cnlfcmN1KG1uLCAm cmFuZ2UtPm1tLT5tbXVfbm90aWZpZXJfbW0tPmxpc3QsIGhsaXN0KSB7CisJaGxpc3RfZm9yX2Vh Y2hfZW50cnlfcmN1KG1uLCAmbW1uX21tLT5saXN0LCBobGlzdCkgewogCQlpZiAobW4tPm9wcy0+ aW52YWxpZGF0ZV9yYW5nZV9zdGFydCkgewogCQkJaW50IF9yZXQ7CiAKQEAgLTIwMywxNSArNDg0 LDMwIEBAIGludCBfX21tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KHN0cnVjdCBt bXVfbm90aWZpZXJfcmFuZ2UgKnJhbmdlKQogCXJldHVybiByZXQ7CiB9CiAKLXZvaWQgX19tbXVf bm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZV9lbmQoc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAq cmFuZ2UsCi0JCQkJCSBib29sIG9ubHlfZW5kKQoraW50IF9fbW11X25vdGlmaWVyX2ludmFsaWRh dGVfcmFuZ2Vfc3RhcnQoc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAqcmFuZ2UpCit7CisJc3Ry dWN0IG1tdV9ub3RpZmllcl9tbSAqbW1uX21tID0gcmFuZ2UtPm1tLT5tbXVfbm90aWZpZXJfbW07 CisJaW50IHJldCA9IDA7CisKKwlpZiAobW1uX21tLT5oYXNfaW50ZXJ2YWwpIHsKKwkJcmV0ID0g bW5faXRyZWVfaW52YWxpZGF0ZShtbW5fbW0sIHJhbmdlKTsKKwkJaWYgKHJldCkKKwkJCXJldHVy biByZXQ7CisJfQorCWlmICghaGxpc3RfZW1wdHkoJm1tbl9tbS0+bGlzdCkpCisJCXJldHVybiBt bl9obGlzdF9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KG1tbl9tbSwgcmFuZ2UpOworCXJldHVybiAw OworfQorCitzdGF0aWMgdm9pZCBtbl9obGlzdF9pbnZhbGlkYXRlX2VuZChzdHJ1Y3QgbW11X25v dGlmaWVyX21tICptbW5fbW0sCisJCQkJICAgIHN0cnVjdCBtbXVfbm90aWZpZXJfcmFuZ2UgKnJh bmdlLAorCQkJCSAgICBib29sIG9ubHlfZW5kKQogewogCXN0cnVjdCBtbXVfbm90aWZpZXIgKm1u OwogCWludCBpZDsKIAotCWxvY2tfbWFwX2FjcXVpcmUoJl9fbW11X25vdGlmaWVyX2ludmFsaWRh dGVfcmFuZ2Vfc3RhcnRfbWFwKTsKIAlpZCA9IHNyY3VfcmVhZF9sb2NrKCZzcmN1KTsKLQlobGlz dF9mb3JfZWFjaF9lbnRyeV9yY3UobW4sICZyYW5nZS0+bW0tPm1tdV9ub3RpZmllcl9tbS0+bGlz dCwgaGxpc3QpIHsKKwlobGlzdF9mb3JfZWFjaF9lbnRyeV9yY3UobW4sICZtbW5fbW0tPmxpc3Qs IGhsaXN0KSB7CiAJCS8qCiAJCSAqIENhbGwgaW52YWxpZGF0ZV9yYW5nZSBoZXJlIHRvbyB0byBh dm9pZCB0aGUgbmVlZCBmb3IgdGhlCiAJCSAqIHN1YnN5c3RlbSBvZiBoYXZpbmcgdG8gcmVnaXN0 ZXIgYW4gaW52YWxpZGF0ZV9yYW5nZV9lbmQKQEAgLTIzOCw2ICs1MzQsMTkgQEAgdm9pZCBfX21t dV9ub3RpZmllcl9pbnZhbGlkYXRlX3JhbmdlX2VuZChzdHJ1Y3QgbW11X25vdGlmaWVyX3Jhbmdl ICpyYW5nZSwKIAkJfQogCX0KIAlzcmN1X3JlYWRfdW5sb2NrKCZzcmN1LCBpZCk7Cit9CisKK3Zv aWQgX19tbXVfbm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZV9lbmQoc3RydWN0IG1tdV9ub3RpZmll cl9yYW5nZSAqcmFuZ2UsCisJCQkJCSBib29sIG9ubHlfZW5kKQoreworCXN0cnVjdCBtbXVfbm90 aWZpZXJfbW0gKm1tbl9tbSA9IHJhbmdlLT5tbS0+bW11X25vdGlmaWVyX21tOworCisJbG9ja19t YXBfYWNxdWlyZSgmX19tbXVfbm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZV9zdGFydF9tYXApOwor CWlmIChtbW5fbW0tPmhhc19pbnRlcnZhbCkKKwkJbW5faXRyZWVfaW52X2VuZChtbW5fbW0pOwor CisJaWYgKCFobGlzdF9lbXB0eSgmbW1uX21tLT5saXN0KSkKKwkJbW5faGxpc3RfaW52YWxpZGF0 ZV9lbmQobW1uX21tLCByYW5nZSwgb25seV9lbmQpOwogCWxvY2tfbWFwX3JlbGVhc2UoJl9fbW11 X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnRfbWFwKTsKIH0KIApAQCAtMjU2LDggKzU2 NSw5IEBAIHZvaWQgX19tbXVfbm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZShzdHJ1Y3QgbW1fc3Ry dWN0ICptbSwKIH0KIAogLyoKLSAqIFNhbWUgYXMgbW11X25vdGlmaWVyX3JlZ2lzdGVyIGJ1dCBo ZXJlIHRoZSBjYWxsZXIgbXVzdCBob2xkIHRoZQotICogbW1hcF9zZW0gaW4gd3JpdGUgbW9kZS4K KyAqIFNhbWUgYXMgbW11X25vdGlmaWVyX3JlZ2lzdGVyIGJ1dCBoZXJlIHRoZSBjYWxsZXIgbXVz dCBob2xkIHRoZSBtbWFwX3NlbSBpbgorICogd3JpdGUgbW9kZS4gQSBOVUxMIG1uIHNpZ25hbHMg dGhlIG5vdGlmaWVyIGlzIGJlaW5nIHJlZ2lzdGVyZWQgZm9yIGl0cmVlCisgKiBtb2RlLgogICov CiBpbnQgX19tbXVfbm90aWZpZXJfcmVnaXN0ZXIoc3RydWN0IG1tdV9ub3RpZmllciAqbW4sIHN0 cnVjdCBtbV9zdHJ1Y3QgKm1tKQogewpAQCAtMjc0LDkgKzU4NCw2IEBAIGludCBfX21tdV9ub3Rp Zmllcl9yZWdpc3RlcihzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwgc3RydWN0IG1tX3N0cnVjdCAq bW0pCiAJCWZzX3JlY2xhaW1fcmVsZWFzZShHRlBfS0VSTkVMKTsKIAl9CiAKLQltbi0+bW0gPSBt bTsKLQltbi0+dXNlcnMgPSAxOwotCiAJaWYgKCFtbS0+bW11X25vdGlmaWVyX21tKSB7CiAJCS8q CiAJCSAqIGttYWxsb2MgY2Fubm90IGJlIGNhbGxlZCB1bmRlciBtbV90YWtlX2FsbF9sb2Nrcygp LCBidXQgd2UKQEAgLTI4NCwyMSArNTkxLDIyIEBAIGludCBfX21tdV9ub3RpZmllcl9yZWdpc3Rl cihzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwgc3RydWN0IG1tX3N0cnVjdCAqbW0pCiAJCSAqIHRo ZSB3cml0ZSBzaWRlIG9mIHRoZSBtbWFwX3NlbS4KIAkJICovCiAJCW1tdV9ub3RpZmllcl9tbSA9 Ci0JCQlrbWFsbG9jKHNpemVvZihzdHJ1Y3QgbW11X25vdGlmaWVyX21tKSwgR0ZQX0tFUk5FTCk7 CisJCQlremFsbG9jKHNpemVvZihzdHJ1Y3QgbW11X25vdGlmaWVyX21tKSwgR0ZQX0tFUk5FTCk7 CiAJCWlmICghbW11X25vdGlmaWVyX21tKQogCQkJcmV0dXJuIC1FTk9NRU07CiAKIAkJSU5JVF9I TElTVF9IRUFEKCZtbXVfbm90aWZpZXJfbW0tPmxpc3QpOwogCQlzcGluX2xvY2tfaW5pdCgmbW11 X25vdGlmaWVyX21tLT5sb2NrKTsKKwkJbW11X25vdGlmaWVyX21tLT5pbnZhbGlkYXRlX3NlcSA9 IDI7CisJCW1tdV9ub3RpZmllcl9tbS0+aXRyZWUgPSBSQl9ST09UX0NBQ0hFRDsKKwkJaW5pdF93 YWl0cXVldWVfaGVhZCgmbW11X25vdGlmaWVyX21tLT53cSk7CisJCUlOSVRfSExJU1RfSEVBRCgm bW11X25vdGlmaWVyX21tLT5kZWZlcnJlZF9saXN0KTsKIAl9CiAKIAlyZXQgPSBtbV90YWtlX2Fs bF9sb2NrcyhtbSk7CiAJaWYgKHVubGlrZWx5KHJldCkpCiAJCWdvdG8gb3V0X2NsZWFuOwogCi0J LyogUGFpcnMgd2l0aCB0aGUgbW1kcm9wIGluIG1tdV9ub3RpZmllcl91bnJlZ2lzdGVyXyogKi8K LQltbWdyYWIobW0pOwotCiAJLyoKIAkgKiBTZXJpYWxpemUgdGhlIHVwZGF0ZSBhZ2FpbnN0IG1t dV9ub3RpZmllcl91bnJlZ2lzdGVyLiBBCiAJICogc2lkZSBub3RlOiBtbXVfbm90aWZpZXJfcmVs ZWFzZSBjYW4ndCBydW4gY29uY3VycmVudGx5IHdpdGgKQEAgLTMwNiwxMyArNjE0LDI4IEBAIGlu dCBfX21tdV9ub3RpZmllcl9yZWdpc3RlcihzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwgc3RydWN0 IG1tX3N0cnVjdCAqbW0pCiAJICogY3VycmVudC0+bW0gb3IgZXhwbGljaXRseSB3aXRoIGdldF90 YXNrX21tKCkgb3Igc2ltaWxhcikuCiAJICogV2UgY2FuJ3QgcmFjZSBhZ2FpbnN0IGFueSBvdGhl ciBtbXUgbm90aWZpZXIgbWV0aG9kIGVpdGhlcgogCSAqIHRoYW5rcyB0byBtbV90YWtlX2FsbF9s b2NrcygpLgorCSAqCisJICogcmVsZWFzZSBzZW1hbnRpY3Mgb24gdGhlIGluaXRpYWxpemF0aW9u IG9mIHRoZSBtbXVfbm90aWZpZXJfbW0ncworICAgICAgICAgKiBjb250ZW50cyBhcmUgcHJvdmlk ZWQgZm9yIHVubG9ja2VkIHJlYWRlcnMuICBhY3F1aXJlIGNhbiBvbmx5IGJlCisgICAgICAgICAq IHVzZWQgd2hpbGUgaG9sZGluZyB0aGUgbW1ncmFiIG9yIG1tZ2V0LCBhbmQgaXMgc2FmZSBiZWNh dXNlIG9uY2UKKyAgICAgICAgICogY3JlYXRlZCB0aGUgbW11X25vdGlmaWZlcl9tbSBpcyBub3Qg ZnJlZWQgdW50aWwgdGhlIG1tIGlzCisgICAgICAgICAqIGRlc3Ryb3llZC4gIEFzIGFib3ZlLCB1 c2VycyBob2xkaW5nIHRoZSBtbWFwX3NlbSBvciBvbmUgb2YgdGhlCisgICAgICAgICAqIG1tX3Rh a2VfYWxsX2xvY2tzKCkgZG8gbm90IG5lZWQgdG8gdXNlIGFjcXVpcmUgc2VtYW50aWNzLgogCSAq LwogCWlmIChtbXVfbm90aWZpZXJfbW0pCi0JCW1tLT5tbXVfbm90aWZpZXJfbW0gPSBtbXVfbm90 aWZpZXJfbW07CisJCXNtcF9zdG9yZV9yZWxlYXNlKCZtbS0+bW11X25vdGlmaWVyX21tLCBtbXVf bm90aWZpZXJfbW0pOwogCi0Jc3Bpbl9sb2NrKCZtbS0+bW11X25vdGlmaWVyX21tLT5sb2NrKTsK LQlobGlzdF9hZGRfaGVhZF9yY3UoJm1uLT5obGlzdCwgJm1tLT5tbXVfbm90aWZpZXJfbW0tPmxp c3QpOwotCXNwaW5fdW5sb2NrKCZtbS0+bW11X25vdGlmaWVyX21tLT5sb2NrKTsKKwlpZiAobW4p IHsKKwkJLyogUGFpcnMgd2l0aCB0aGUgbW1kcm9wIGluIG1tdV9ub3RpZmllcl91bnJlZ2lzdGVy XyogKi8KKwkJbW1ncmFiKG1tKTsKKwkJbW4tPm1tID0gbW07CisJCW1uLT51c2VycyA9IDE7CisK KwkJc3Bpbl9sb2NrKCZtbS0+bW11X25vdGlmaWVyX21tLT5sb2NrKTsKKwkJaGxpc3RfYWRkX2hl YWRfcmN1KCZtbi0+aGxpc3QsICZtbS0+bW11X25vdGlmaWVyX21tLT5saXN0KTsKKwkJc3Bpbl91 bmxvY2soJm1tLT5tbXVfbm90aWZpZXJfbW0tPmxvY2spOworCX0gZWxzZQorCQltbS0+bW11X25v dGlmaWVyX21tLT5oYXNfaW50ZXJ2YWwgPSB0cnVlOwogCiAJbW1fZHJvcF9hbGxfbG9ja3MobW0p OwogCUJVR19PTihhdG9taWNfcmVhZCgmbW0tPm1tX3VzZXJzKSA8PSAwKTsKQEAgLTUyOSw2ICs4 NTIsMTY2IEBAIHZvaWQgbW11X25vdGlmaWVyX3B1dChzdHJ1Y3QgbW11X25vdGlmaWVyICptbikK IH0KIEVYUE9SVF9TWU1CT0xfR1BMKG1tdV9ub3RpZmllcl9wdXQpOwogCitzdGF0aWMgaW50IF9f bW11X3JhbmdlX25vdGlmaWVyX2luc2VydChzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyICptcm4s CisJCQkJICAgICAgIHVuc2lnbmVkIGxvbmcgc3RhcnQsCisJCQkJICAgICAgIHVuc2lnbmVkIGxv bmcgbGVuZ3RoLAorCQkJCSAgICAgICBzdHJ1Y3QgbW11X25vdGlmaWVyX21tICptbW5fbW0sCisJ CQkJICAgICAgIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQoreworCW1ybi0+bW0gPSBtbTsKKwlSQl9D TEVBUl9OT0RFKCZtcm4tPmludGVydmFsX3RyZWUucmIpOworCW1ybi0+aW50ZXJ2YWxfdHJlZS5z dGFydCA9IHN0YXJ0OworCS8qCisJICogTm90ZSB0aGF0IHRoZSByZXByZXNlbnRhdGlvbiBvZiB0 aGUgaW50ZXJ2YWxzIGluIHRoZSBpbnRlcnZhbCB0cmVlCisJICogY29uc2lkZXJzIHRoZSBlbmRp bmcgcG9pbnQgYXMgY29udGFpbmVkIGluIHRoZSBpbnRlcnZhbC4KKwkgKi8KKwlpZiAobGVuZ3Ro ID09IDAgfHwKKwkgICAgY2hlY2tfYWRkX292ZXJmbG93KHN0YXJ0LCBsZW5ndGggLSAxLCAmbXJu LT5pbnRlcnZhbF90cmVlLmxhc3QpKQorCQlyZXR1cm4gLUVPVkVSRkxPVzsKKworCS8qIHBhaXJz IHdpdGggbW1kcm9wIGluIG1tdV9yYW5nZV9ub3RpZmllcl9yZW1vdmUoKSAqLworCW1tZ3JhYiht bSk7CisKKwkvKgorCSAqIElmIHNvbWUgaW52YWxpZGF0ZV9yYW5nZV9zdGFydC9lbmQgcmVnaW9u IGlzIGdvaW5nIG9uIGluIHBhcmFsbGVsCisJICogd2UgZG9uJ3Qga25vdyB3aGF0IFZBIHJhbmdl cyBhcmUgYWZmZWN0ZWQsIHNvIHdlIG11c3QgYXNzdW1lIHRoaXMKKwkgKiBuZXcgcmFuZ2UgaXMg aW5jbHVkZWQuCisJICoKKwkgKiBJZiB0aGUgaXRyZWUgaXMgaW52YWxpZGF0aW5nIHRoZW4gd2Ug YXJlIG5vdCBhbGxvd2VkIHRvIGNoYW5nZQorCSAqIGl0LiBSZXRyeWluZyB1bnRpbCBpbnZhbGlk YXRpb24gaXMgZG9uZSBpcyB0cmlja3kgZHVlIHRvIHRoZQorCSAqIHBvc3NpYmlsaXR5IGZvciBs aXZlIGxvY2ssIGluc3RlYWQgZGVmZXIgdGhlIGFkZCB0byB0aGUgdW5sb2NrIHNvCisJICogdGhp cyBhbGdvcml0aG0gaXMgZGV0ZXJtaW5pc3RpYy4KKwkgKgorCSAqIEluIGFsbCBjYXNlcyB0aGUg dmFsdWUgZm9yIHRoZSBtcm4tPm1yX2ludmFsaWRhdGVfc2VxIHNob3VsZCBiZQorCSAqIG9kZCwg c2VlIG1tdV9yYW5nZV9yZWFkX2JlZ2luKCkKKwkgKi8KKwlzcGluX2xvY2soJm1tbl9tbS0+bG9j ayk7CisJaWYgKG1tbl9tbS0+YWN0aXZlX2ludmFsaWRhdGVfcmFuZ2VzKSB7CisJCWlmIChtbl9p dHJlZV9pc19pbnZhbGlkYXRpbmcobW1uX21tKSkKKwkJCWhsaXN0X2FkZF9oZWFkKCZtcm4tPmRl ZmVycmVkX2l0ZW0sCisJCQkJICAgICAgICZtbW5fbW0tPmRlZmVycmVkX2xpc3QpOworCQllbHNl IHsKKwkJCW1tbl9tbS0+aW52YWxpZGF0ZV9zZXEgfD0gMTsKKwkJCWludGVydmFsX3RyZWVfaW5z ZXJ0KCZtcm4tPmludGVydmFsX3RyZWUsCisJCQkJCSAgICAgJm1tbl9tbS0+aXRyZWUpOworCQl9 CisJCW1ybi0+aW52YWxpZGF0ZV9zZXEgPSBtbW5fbW0tPmludmFsaWRhdGVfc2VxOworCX0gZWxz ZSB7CisJCVdBUk5fT04obW5faXRyZWVfaXNfaW52YWxpZGF0aW5nKG1tbl9tbSkpOworCQltcm4t PmludmFsaWRhdGVfc2VxID0gbW1uX21tLT5pbnZhbGlkYXRlX3NlcSAtIDE7CisJCWludGVydmFs X3RyZWVfaW5zZXJ0KCZtcm4tPmludGVydmFsX3RyZWUsICZtbW5fbW0tPml0cmVlKTsKKwl9CisJ c3Bpbl91bmxvY2soJm1tbl9tbS0+bG9jayk7CisJcmV0dXJuIDA7Cit9CisKKy8qKgorICogbW11 X3JhbmdlX25vdGlmaWVyX2luc2VydCAtIEluc2VydCBhIHJhbmdlIG5vdGlmaWVyCisgKiBAbXJu OiBSYW5nZSBub3RpZmllciB0byByZWdpc3RlcgorICogQHN0YXJ0OiBTdGFydGluZyB2aXJ0dWFs IGFkZHJlc3MgdG8gbW9uaXRvcgorICogQGxlbmd0aDogTGVuZ3RoIG9mIHRoZSByYW5nZSB0byBt b25pdG9yCisgKiBAbW0gOiBtbV9zdHJ1Y3QgdG8gYXR0YWNoIHRvCisgKgorICogVGhpcyBmdW5j dGlvbiBzdWJzY3JpYmVzIHRoZSByYW5nZSBub3RpZmllciBmb3Igbm90aWZpY2F0aW9ucyBmcm9t IHRoZSBtbS4KKyAqIFVwb24gcmV0dXJuIHRoZSBvcHMgcmVsYXRlZCB0byBtbXVfcmFuZ2Vfbm90 aWZpZXIgd2lsbCBiZSBjYWxsZWQgd2hlbmV2ZXIKKyAqIGFuIGV2ZW50IHRoYXQgaW50ZXJzZWN0 cyB3aXRoIHRoZSBnaXZlbiByYW5nZSBvY2N1cnMuCisgKgorICogVXBvbiByZXR1cm4gdGhlIHJh bmdlX25vdGlmaWVyIG1heSBub3QgYmUgcHJlc2VudCBpbiB0aGUgaW50ZXJ2YWwgdHJlZSB5ZXQu CisgKiBUaGUgY2FsbGVyIG11c3QgdXNlIHRoZSBub3JtYWwgcmFuZ2Ugbm90aWZpZXIgbG9ja2lu ZyBmbG93IHZpYQorICogbW11X3JhbmdlX3JlYWRfYmVnaW4oKSB0byBlc3RhYmxpc2ggU1BURXMg Zm9yIHRoaXMgcmFuZ2UuCisgKi8KK2ludCBtbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0KHN0cnVj dCBtbXVfcmFuZ2Vfbm90aWZpZXIgKm1ybiwKKwkJCSAgICAgIHVuc2lnbmVkIGxvbmcgc3RhcnQs IHVuc2lnbmVkIGxvbmcgbGVuZ3RoLAorCQkJICAgICAgc3RydWN0IG1tX3N0cnVjdCAqbW0pCit7 CisJc3RydWN0IG1tdV9ub3RpZmllcl9tbSAqbW1uX21tOworCWludCByZXQ7CisKKwltaWdodF9s b2NrKCZtbS0+bW1hcF9zZW0pOworCisJbW1uX21tID0gc21wX2xvYWRfYWNxdWlyZSgmbW0tPm1t dV9ub3RpZmllcl9tbSk7CisJaWYgKCFtbW5fbW0gfHwgIW1tbl9tbS0+aGFzX2ludGVydmFsKSB7 CisJCXJldCA9IG1tdV9ub3RpZmllcl9yZWdpc3RlcihOVUxMLCBtbSk7CisJCWlmIChyZXQpCisJ CQlyZXR1cm4gcmV0OworCQltbW5fbW0gPSBtbS0+bW11X25vdGlmaWVyX21tOworCX0KKwlyZXR1 cm4gX19tbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0KG1ybiwgc3RhcnQsIGxlbmd0aCwgbW1uX21t LCBtbSk7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChtbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0KTsK KworaW50IG1tdV9yYW5nZV9ub3RpZmllcl9pbnNlcnRfbG9ja2VkKHN0cnVjdCBtbXVfcmFuZ2Vf bm90aWZpZXIgKm1ybiwKKwkJCQkgICAgIHVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxv bmcgbGVuZ3RoLAorCQkJCSAgICAgc3RydWN0IG1tX3N0cnVjdCAqbW0pCit7CisJc3RydWN0IG1t dV9ub3RpZmllcl9tbSAqbW1uX21tOworCWludCByZXQ7CisKKwlsb2NrZGVwX2Fzc2VydF9oZWxk X3dyaXRlKCZtbS0+bW1hcF9zZW0pOworCisJbW1uX21tID0gbW0tPm1tdV9ub3RpZmllcl9tbTsK KwlpZiAoIW1tbl9tbSB8fCAhbW1uX21tLT5oYXNfaW50ZXJ2YWwpIHsKKwkJcmV0ID0gX19tbXVf bm90aWZpZXJfcmVnaXN0ZXIoTlVMTCwgbW0pOworCQlpZiAocmV0KQorCQkJcmV0dXJuIHJldDsK KwkJbW1uX21tID0gbW0tPm1tdV9ub3RpZmllcl9tbTsKKwl9CisJcmV0dXJuIF9fbW11X3Jhbmdl X25vdGlmaWVyX2luc2VydChtcm4sIHN0YXJ0LCBsZW5ndGgsIG1tbl9tbSwgbW0pOworfQorRVhQ T1JUX1NZTUJPTF9HUEwobW11X3JhbmdlX25vdGlmaWVyX2luc2VydF9sb2NrZWQpOworCisvKioK KyAqIG1tdV9yYW5nZV9ub3RpZmllcl9yZW1vdmUgLSBSZW1vdmUgYSByYW5nZSBub3RpZmllcgor ICogQG1ybjogUmFuZ2Ugbm90aWZpZXIgdG8gdW5yZWdpc3RlcgorICoKKyAqIFRoaXMgZnVuY3Rp b24gbXVzdCBiZSBwYWlyZWQgd2l0aCBtbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0KCkuIEl0IGNh bm5vdCBiZQorICogY2FsbGVkIGZyb20gYW55IG9wcyBjYWxsYmFjay4KKyAqCisgKiBPbmNlIHRo aXMgcmV0dXJucyBvcHMgY2FsbGJhY2tzIGFyZSBubyBsb25nZXIgcnVubmluZyBvbiBvdGhlciBD UFVzIGFuZAorICogd2lsbCBub3QgYmUgY2FsbGVkIGluIGZ1dHVyZS4KKyAqLwordm9pZCBtbXVf cmFuZ2Vfbm90aWZpZXJfcmVtb3ZlKHN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXIgKm1ybikKK3sK KwlzdHJ1Y3QgbW1fc3RydWN0ICptbSA9IG1ybi0+bW07CisJc3RydWN0IG1tdV9ub3RpZmllcl9t bSAqbW1uX21tID0gbW0tPm1tdV9ub3RpZmllcl9tbTsKKwl1bnNpZ25lZCBsb25nIHNlcSA9IDA7 CisKKwltaWdodF9zbGVlcCgpOworCisJc3Bpbl9sb2NrKCZtbW5fbW0tPmxvY2spOworCWlmICht bl9pdHJlZV9pc19pbnZhbGlkYXRpbmcobW1uX21tKSkgeworCQkvKgorCQkgKiByZW1vdmUgaXMg YmVpbmcgY2FsbGVkIGFmdGVyIGluc2VydCBwdXQgdGhpcyBvbiB0aGUKKwkJICogZGVmZXJyZWQg bGlzdCwgYnV0IGJlZm9yZSB0aGUgZGVmZXJyZWQgbGlzdCB3YXMgcHJvY2Vzc2VkLgorCQkgKi8K KwkJaWYgKFJCX0VNUFRZX05PREUoJm1ybi0+aW50ZXJ2YWxfdHJlZS5yYikpIHsKKwkJCWhsaXN0 X2RlbCgmbXJuLT5kZWZlcnJlZF9pdGVtKTsKKwkJfSBlbHNlIHsKKwkJCWhsaXN0X2FkZF9oZWFk KCZtcm4tPmRlZmVycmVkX2l0ZW0sCisJCQkJICAgICAgICZtbW5fbW0tPmRlZmVycmVkX2xpc3Qp OworCQkJc2VxID0gbW1uX21tLT5pbnZhbGlkYXRlX3NlcTsKKwkJfQorCX0gZWxzZSB7CisJCVdB Uk5fT04oUkJfRU1QVFlfTk9ERSgmbXJuLT5pbnRlcnZhbF90cmVlLnJiKSk7CisJCWludGVydmFs X3RyZWVfcmVtb3ZlKCZtcm4tPmludGVydmFsX3RyZWUsICZtbW5fbW0tPml0cmVlKTsKKwl9CisJ c3Bpbl91bmxvY2soJm1tbl9tbS0+bG9jayk7CisKKwkvKgorCSAqIFRoZSBwb3NzaWJsZSBzbGVl cCBvbiBwcm9ncmVzcyBpbiB0aGUgaW52YWxpZGF0aW9uIHJlcXVpcmVzIHRoZQorCSAqIGNhbGxl ciBub3QgaG9sZCBhbnkgbG9ja3MgaGVsZCBieSBpbnZhbGlkYXRpb24gY2FsbGJhY2tzLgorCSAq LworCWxvY2tfbWFwX2FjcXVpcmUoJl9fbW11X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3Rh cnRfbWFwKTsKKwlsb2NrX21hcF9yZWxlYXNlKCZfX21tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3Jh bmdlX3N0YXJ0X21hcCk7CisJaWYgKHNlcSkKKwkJd2FpdF9ldmVudChtbW5fbW0tPndxLAorCQkJ ICAgUkVBRF9PTkNFKG1tbl9tbS0+aW52YWxpZGF0ZV9zZXEpICE9IHNlcSk7CisKKwkvKiBwYWly cyB3aXRoIG1tZ3JhYiBpbiBtbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0KCkgKi8KKwltbWRyb3Ao bW0pOworfQorRVhQT1JUX1NZTUJPTF9HUEwobW11X3JhbmdlX25vdGlmaWVyX3JlbW92ZSk7CisK IC8qKgogICogbW11X25vdGlmaWVyX3N5bmNocm9uaXplIC0gRW5zdXJlIGFsbCBtbXVfbm90aWZp ZXJzIGFyZSBmcmVlZAogICoKLS0gCjIuMjMuMAoKX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX18KYW1kLWdmeCBtYWlsaW5nIGxpc3QKYW1kLWdmeEBsaXN0cy5m cmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0 aW5mby9hbWQtZ2Z4