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 26E58FA3728 for ; Tue, 15 Oct 2019 18:17:31 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id D5DA52245A for ; Tue, 15 Oct 2019 18:17:30 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=ziepe.ca header.i=@ziepe.ca header.b="k4hbQSPr" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1731873AbfJOSQl (ORCPT ); Tue, 15 Oct 2019 14:16:41 -0400 Received: from mail-pg1-f194.google.com ([209.85.215.194]:32927 "EHLO mail-pg1-f194.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726597AbfJOSQl (ORCPT ); Tue, 15 Oct 2019 14:16:41 -0400 Received: by mail-pg1-f194.google.com with SMTP id i76so12636418pgc.0 for ; Tue, 15 Oct 2019 11:16:40 -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=WFWRO10+feWff7r6fgmeh5w6Y3QPVjROWE9lwVqn/i8=; b=k4hbQSPrqznVf/5ZnM7x5J4seFc1YAeDg8waTuZOs9CkrIPaaSVB71IIQKnkb+I9M8 YzXu6IJuH9tkROTv3YGUt/CV/lzAQb4zUFOtx9dDDURZ2bIwyQp42dPF1LsgD9TkSD1H AZ5IMtwNJEOiu8aqymqw4AbNIvD0H0rRHH02mAQr8zBrSGpkhLZ58JRXwulRwBlPijkO YoYURzkUOhAkBJbWVEkGhYtc32DOD+5VuPxKPwJkAnQoxaBzrB+c3XSFE833ZgvBIlqZ fqWltqEnK7aPbVd3yTfCyTrSzLOv2IYndGxHZOparqhbPIKvqGdJWDc3TIY7UUgU9MDm GiHw== 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=WFWRO10+feWff7r6fgmeh5w6Y3QPVjROWE9lwVqn/i8=; b=LTz1laUY9BMVICY2geAV/68+W5Z0HUs145YuDZvvWX0UcbzHzony2CYuykXVYG81KN EBDV0z51oGujbjjEsgyJKR5meRV7iHmHl97Gr+kOtlgyqeZkWPx7CuZqwfrUIt2UCEIh Xg6nLfScPyi9STIcpfZmhvbbE7tHpByJcNZ8jk9Vidhu+MIgFacbi23LYXB2fFo1+iXt AA7lIQBDPZq9XGoXgHJwbiWUyw9A403Cy2+TvFu8dzvDRS48ekKZqJyWWGZox+jU0erR 9K7bHjk69kYL1rKEJvZYzZxZ3WquC0lvKl1UiRY6eBS2OoHQxOLrYwgluCXLJuHWHbCI Hs1g== X-Gm-Message-State: APjAAAWZxHTJ7CoHDguHks5uPsTet2+6UlfWGRvBDiMEdCybP1qVucQp NTb/0Ak29Lyg2JADV4cLuENu0w== X-Google-Smtp-Source: APXvYqwcBUTmMtfzkt7tzvsqtJbdQLE7/86WTaqOjVFBlbeV0uObGeL49nnNgpBmIxrl56Z9I63Gfw== X-Received: by 2002:aa7:9f9b:: with SMTP id z27mr39853337pfr.65.1571163399727; Tue, 15 Oct 2019 11:16:39 -0700 (PDT) Received: from ziepe.ca ([24.114.26.129]) by smtp.gmail.com with ESMTPSA id y6sm25518660pfp.82.2019.10.15.11.16.38 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Tue, 15 Oct 2019 11:16:39 -0700 (PDT) Received: from jgg by jggl.ziepe.ca with local (Exim 4.90_1) (envelope-from ) id 1iKRJT-0002Cu-RH; Tue, 15 Oct 2019 15:12:51 -0300 From: Jason Gunthorpe To: Jerome Glisse , Ralph Campbell , John Hubbard , Felix.Kuehling@amd.com Cc: linux-rdma@vger.kernel.org, linux-mm@kvack.org, Andrea Arcangeli , dri-devel@lists.freedesktop.org, amd-gfx@lists.freedesktop.org, Ben Skeggs , Jason Gunthorpe Subject: [PATCH hmm 15/15] mm/hmm: remove hmm_mirror and related Date: Tue, 15 Oct 2019 15:12:42 -0300 Message-Id: <20191015181242.8343-16-jgg@ziepe.ca> X-Mailer: git-send-email 2.23.0 In-Reply-To: <20191015181242.8343-1-jgg@ziepe.ca> References: <20191015181242.8343-1-jgg@ziepe.ca> MIME-Version: 1.0 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 The only two users of this are now converted to use mmu_range_notifier, delete all the code and update hmm.rst. Signed-off-by: Jason Gunthorpe --- Documentation/vm/hmm.rst | 105 ++++----------- include/linux/hmm.h | 183 +------------------------ mm/Kconfig | 1 - mm/hmm.c | 284 +-------------------------------------- 4 files changed, 33 insertions(+), 540 deletions(-) diff --git a/Documentation/vm/hmm.rst b/Documentation/vm/hmm.rst index 0a5960beccf76d..a247643035c4e2 100644 --- a/Documentation/vm/hmm.rst +++ b/Documentation/vm/hmm.rst @@ -147,49 +147,16 @@ Address space mirroring implementation and API Address space mirroring's main objective is to allow duplication of a range of CPU page table into a device page table; HMM helps keep both synchronized. A device driver that wants to mirror a process address space must start with the -registration of an hmm_mirror struct:: - - int hmm_mirror_register(struct hmm_mirror *mirror, - struct mm_struct *mm); - -The mirror struct has a set of callbacks that are used -to propagate CPU page tables:: - - struct hmm_mirror_ops { - /* release() - release hmm_mirror - * - * @mirror: pointer to struct hmm_mirror - * - * This is called when the mm_struct is being released. The callback - * must ensure that all access to any pages obtained from this mirror - * is halted before the callback returns. All future access should - * fault. - */ - void (*release)(struct hmm_mirror *mirror); - - /* sync_cpu_device_pagetables() - synchronize page tables - * - * @mirror: pointer to struct hmm_mirror - * @update: update information (see struct mmu_notifier_range) - * Return: -EAGAIN if update.blockable false and callback need to - * block, 0 otherwise. - * - * This callback ultimately originates from mmu_notifiers when the CPU - * page table is updated. The device driver must update its page table - * in response to this callback. The update argument tells what action - * to perform. - * - * The device driver must not return from this callback until the device - * page tables are completely updated (TLBs flushed, etc); this is a - * synchronous call. - */ - int (*sync_cpu_device_pagetables)(struct hmm_mirror *mirror, - const struct hmm_update *update); - }; - -The device driver must perform the update action to the range (mark range -read only, or fully unmap, etc.). The device must complete the update before -the driver callback returns. +registration of a mmu_range_notifier:: + + mrn->ops = &driver_ops; + int mmu_range_notifier_insert(struct mmu_range_notifier *mrn, + unsigned long start, unsigned long length, + struct mm_struct *mm); + +During the driver_ops->invalidate() callback the device driver must perform +the update action to the range (mark range read only, or fully unmap, +etc.). The device must complete the update before the driver callback returns. When the device driver wants to populate a range of virtual addresses, it can use:: @@ -216,70 +183,46 @@ The usage pattern is:: struct hmm_range range; ... + range.notifier = &mrn; range.start = ...; range.end = ...; range.pfns = ...; range.flags = ...; range.values = ...; range.pfn_shift = ...; - hmm_range_register(&range, mirror); - /* - * Just wait for range to be valid, safe to ignore return value as we - * will use the return value of hmm_range_fault() below under the - * mmap_sem to ascertain the validity of the range. - */ - hmm_range_wait_until_valid(&range, TIMEOUT_IN_MSEC); + if (!mmget_not_zero(mrn->notifier.mm)) + return -EFAULT; again: + range.notifier_seq = mmu_range_read_begin(&mrn); down_read(&mm->mmap_sem); ret = hmm_range_fault(&range, HMM_RANGE_SNAPSHOT); if (ret) { up_read(&mm->mmap_sem); - if (ret == -EBUSY) { - /* - * No need to check hmm_range_wait_until_valid() return value - * on retry we will get proper error with hmm_range_fault() - */ - hmm_range_wait_until_valid(&range, TIMEOUT_IN_MSEC); - goto again; - } - hmm_range_unregister(&range); + if (ret == -EBUSY) + goto again; return ret; } + up_read(&mm->mmap_sem); + take_lock(driver->update); - if (!hmm_range_valid(&range)) { + if (mmu_range_read_retry(&mrn, range.notifier_seq) { release_lock(driver->update); - up_read(&mm->mmap_sem); goto again; } - // Use pfns array content to update device page table + /* Use pfns array content to update device page table, + * under the update lock */ - hmm_range_unregister(&range); release_lock(driver->update); - up_read(&mm->mmap_sem); return 0; } The driver->update lock is the same lock that the driver takes inside its -sync_cpu_device_pagetables() callback. That lock must be held before calling -hmm_range_valid() to avoid any race with a concurrent CPU page table update. - -HMM implements all this on top of the mmu_notifier API because we wanted a -simpler API and also to be able to perform optimizations latter on like doing -concurrent device updates in multi-devices scenario. - -HMM also serves as an impedance mismatch between how CPU page table updates -are done (by CPU write to the page table and TLB flushes) and how devices -update their own page table. Device updates are a multi-step process. First, -appropriate commands are written to a buffer, then this buffer is scheduled for -execution on the device. It is only once the device has executed commands in -the buffer that the update is done. Creating and scheduling the update command -buffer can happen concurrently for multiple devices. Waiting for each device to -report commands as executed is serialized (there is no point in doing this -concurrently). - +invalidate() callback. That lock must be held before calling +mmu_range_read_retry() to avoid any race with a concurrent CPU page table +update. Leverage default_flags and pfn_flags_mask ========================================= diff --git a/include/linux/hmm.h b/include/linux/hmm.h index 2666eb08a40615..b4af5173523232 100644 --- a/include/linux/hmm.h +++ b/include/linux/hmm.h @@ -68,29 +68,6 @@ #include #include - -/* - * struct hmm - HMM per mm struct - * - * @mm: mm struct this HMM struct is bound to - * @lock: lock protecting ranges list - * @ranges: list of range being snapshotted - * @mirrors: list of mirrors for this mm - * @mmu_notifier: mmu notifier to track updates to CPU page table - * @mirrors_sem: read/write semaphore protecting the mirrors list - * @wq: wait queue for user waiting on a range invalidation - * @notifiers: count of active mmu notifiers - */ -struct hmm { - struct mmu_notifier mmu_notifier; - spinlock_t ranges_lock; - struct list_head ranges; - struct list_head mirrors; - struct rw_semaphore mirrors_sem; - wait_queue_head_t wq; - long notifiers; -}; - /* * hmm_pfn_flag_e - HMM flag enums * @@ -143,9 +120,8 @@ enum hmm_pfn_value_e { /* * struct hmm_range - track invalidation lock on virtual address range * - * @notifier: an optional mmu_range_notifier - * @notifier_seq: when notifier is used this is the result of - * mmu_range_read_begin() + * @notifier: a mmu_range_notifier that includes the start/end + * @notifier_seq: result of mmu_range_read_begin() * @hmm: the core HMM structure this range is active against * @vma: the vm area struct for the range * @list: all range lock are on a list @@ -162,8 +138,6 @@ enum hmm_pfn_value_e { struct hmm_range { struct mmu_range_notifier *notifier; unsigned long notifier_seq; - struct hmm *hmm; - struct list_head list; unsigned long start; unsigned long end; uint64_t *pfns; @@ -172,32 +146,8 @@ struct hmm_range { uint64_t default_flags; uint64_t pfn_flags_mask; uint8_t pfn_shift; - bool valid; }; -/* - * hmm_range_wait_until_valid() - wait for range to be valid - * @range: range affected by invalidation to wait on - * @timeout: time out for wait in ms (ie abort wait after that period of time) - * Return: true if the range is valid, false otherwise. - */ -static inline bool hmm_range_wait_until_valid(struct hmm_range *range, - unsigned long timeout) -{ - return wait_event_timeout(range->hmm->wq, range->valid, - msecs_to_jiffies(timeout)) != 0; -} - -/* - * hmm_range_valid() - test if a range is valid or not - * @range: range - * Return: true if the range is valid, false otherwise. - */ -static inline bool hmm_range_valid(struct hmm_range *range) -{ - return range->valid; -} - /* * hmm_device_entry_to_page() - return struct page pointed to by a device entry * @range: range use to decode device entry value @@ -267,111 +217,6 @@ static inline uint64_t hmm_device_entry_from_pfn(const struct hmm_range *range, range->flags[HMM_PFN_VALID]; } -/* - * Mirroring: how to synchronize device page table with CPU page table. - * - * A device driver that is participating in HMM mirroring must always - * synchronize with CPU page table updates. For this, device drivers can either - * directly use mmu_notifier APIs or they can use the hmm_mirror API. Device - * drivers can decide to register one mirror per device per process, or just - * one mirror per process for a group of devices. The pattern is: - * - * int device_bind_address_space(..., struct mm_struct *mm, ...) - * { - * struct device_address_space *das; - * - * // Device driver specific initialization, and allocation of das - * // which contains an hmm_mirror struct as one of its fields. - * ... - * - * ret = hmm_mirror_register(&das->mirror, mm, &device_mirror_ops); - * if (ret) { - * // Cleanup on error - * return ret; - * } - * - * // Other device driver specific initialization - * ... - * } - * - * Once an hmm_mirror is registered for an address space, the device driver - * will get callbacks through sync_cpu_device_pagetables() operation (see - * hmm_mirror_ops struct). - * - * Device driver must not free the struct containing the hmm_mirror struct - * before calling hmm_mirror_unregister(). The expected usage is to do that when - * the device driver is unbinding from an address space. - * - * - * void device_unbind_address_space(struct device_address_space *das) - * { - * // Device driver specific cleanup - * ... - * - * hmm_mirror_unregister(&das->mirror); - * - * // Other device driver specific cleanup, and now das can be freed - * ... - * } - */ - -struct hmm_mirror; - -/* - * struct hmm_mirror_ops - HMM mirror device operations callback - * - * @update: callback to update range on a device - */ -struct hmm_mirror_ops { - /* release() - release hmm_mirror - * - * @mirror: pointer to struct hmm_mirror - * - * This is called when the mm_struct is being released. The callback - * must ensure that all access to any pages obtained from this mirror - * is halted before the callback returns. All future access should - * fault. - */ - void (*release)(struct hmm_mirror *mirror); - - /* sync_cpu_device_pagetables() - synchronize page tables - * - * @mirror: pointer to struct hmm_mirror - * @update: update information (see struct mmu_notifier_range) - * Return: -EAGAIN if mmu_notifier_range_blockable(update) is false - * and callback needs to block, 0 otherwise. - * - * This callback ultimately originates from mmu_notifiers when the CPU - * page table is updated. The device driver must update its page table - * in response to this callback. The update argument tells what action - * to perform. - * - * The device driver must not return from this callback until the device - * page tables are completely updated (TLBs flushed, etc); this is a - * synchronous call. - */ - int (*sync_cpu_device_pagetables)( - struct hmm_mirror *mirror, - const struct mmu_notifier_range *update); -}; - -/* - * struct hmm_mirror - mirror struct for a device driver - * - * @hmm: pointer to struct hmm (which is unique per mm_struct) - * @ops: device driver callback for HMM mirror operations - * @list: for list of mirrors of a given mm - * - * Each address space (mm_struct) being mirrored by a device must register one - * instance of an hmm_mirror struct with HMM. HMM will track the list of all - * mirrors for each mm_struct. - */ -struct hmm_mirror { - struct hmm *hmm; - const struct hmm_mirror_ops *ops; - struct list_head list; -}; - /* * Retry fault if non-blocking, drop mmap_sem and return -EAGAIN in that case. */ @@ -381,15 +226,9 @@ struct hmm_mirror { #define HMM_FAULT_SNAPSHOT (1 << 1) #ifdef CONFIG_HMM_MIRROR -int hmm_mirror_register(struct hmm_mirror *mirror, struct mm_struct *mm); -void hmm_mirror_unregister(struct hmm_mirror *mirror); - /* * Please see Documentation/vm/hmm.rst for how to use the range API. */ -int hmm_range_register(struct hmm_range *range, struct hmm_mirror *mirror); -void hmm_range_unregister(struct hmm_range *range); - long hmm_range_fault(struct hmm_range *range, unsigned int flags); long hmm_range_dma_map(struct hmm_range *range, @@ -401,24 +240,6 @@ long hmm_range_dma_unmap(struct hmm_range *range, dma_addr_t *daddrs, bool dirty); #else -int hmm_mirror_register(struct hmm_mirror *mirror, struct mm_struct *mm) -{ - return -EOPNOTSUPP; -} - -void hmm_mirror_unregister(struct hmm_mirror *mirror) -{ -} - -int hmm_range_register(struct hmm_range *range, struct hmm_mirror *mirror) -{ - return -EOPNOTSUPP; -} - -void hmm_range_unregister(struct hmm_range *range) -{ -} - static inline long hmm_range_fault(struct hmm_range *range, unsigned int flags) { return -EOPNOTSUPP; diff --git a/mm/Kconfig b/mm/Kconfig index d0b5046d9aeffd..e38ff1d5968dbf 100644 --- a/mm/Kconfig +++ b/mm/Kconfig @@ -675,7 +675,6 @@ config DEV_PAGEMAP_OPS config HMM_MIRROR bool depends on MMU - depends on MMU_NOTIFIER config DEVICE_PRIVATE bool "Unaddressable device memory (GPU memory, ...)" diff --git a/mm/hmm.c b/mm/hmm.c index 22ac3595771feb..75d15a820e182e 100644 --- a/mm/hmm.c +++ b/mm/hmm.c @@ -26,193 +26,6 @@ #include #include -static struct mmu_notifier *hmm_alloc_notifier(struct mm_struct *mm) -{ - struct hmm *hmm; - - hmm = kzalloc(sizeof(*hmm), GFP_KERNEL); - if (!hmm) - return ERR_PTR(-ENOMEM); - - init_waitqueue_head(&hmm->wq); - INIT_LIST_HEAD(&hmm->mirrors); - init_rwsem(&hmm->mirrors_sem); - INIT_LIST_HEAD(&hmm->ranges); - spin_lock_init(&hmm->ranges_lock); - hmm->notifiers = 0; - return &hmm->mmu_notifier; -} - -static void hmm_free_notifier(struct mmu_notifier *mn) -{ - struct hmm *hmm = container_of(mn, struct hmm, mmu_notifier); - - WARN_ON(!list_empty(&hmm->ranges)); - WARN_ON(!list_empty(&hmm->mirrors)); - kfree(hmm); -} - -static void hmm_release(struct mmu_notifier *mn, struct mm_struct *mm) -{ - struct hmm *hmm = container_of(mn, struct hmm, mmu_notifier); - struct hmm_mirror *mirror; - - /* - * Since hmm_range_register() holds the mmget() lock hmm_release() is - * prevented as long as a range exists. - */ - WARN_ON(!list_empty_careful(&hmm->ranges)); - - down_read(&hmm->mirrors_sem); - list_for_each_entry(mirror, &hmm->mirrors, list) { - /* - * Note: The driver is not allowed to trigger - * hmm_mirror_unregister() from this thread. - */ - if (mirror->ops->release) - mirror->ops->release(mirror); - } - up_read(&hmm->mirrors_sem); -} - -static void notifiers_decrement(struct hmm *hmm) -{ - unsigned long flags; - - spin_lock_irqsave(&hmm->ranges_lock, flags); - hmm->notifiers--; - if (!hmm->notifiers) { - struct hmm_range *range; - - list_for_each_entry(range, &hmm->ranges, list) { - if (range->valid) - continue; - range->valid = true; - } - wake_up_all(&hmm->wq); - } - spin_unlock_irqrestore(&hmm->ranges_lock, flags); -} - -static int hmm_invalidate_range_start(struct mmu_notifier *mn, - const struct mmu_notifier_range *nrange) -{ - struct hmm *hmm = container_of(mn, struct hmm, mmu_notifier); - struct hmm_mirror *mirror; - struct hmm_range *range; - unsigned long flags; - int ret = 0; - - spin_lock_irqsave(&hmm->ranges_lock, flags); - hmm->notifiers++; - list_for_each_entry(range, &hmm->ranges, list) { - if (nrange->end < range->start || nrange->start >= range->end) - continue; - - range->valid = false; - } - spin_unlock_irqrestore(&hmm->ranges_lock, flags); - - if (mmu_notifier_range_blockable(nrange)) - down_read(&hmm->mirrors_sem); - else if (!down_read_trylock(&hmm->mirrors_sem)) { - ret = -EAGAIN; - goto out; - } - - list_for_each_entry(mirror, &hmm->mirrors, list) { - int rc; - - rc = mirror->ops->sync_cpu_device_pagetables(mirror, nrange); - if (rc) { - if (WARN_ON(mmu_notifier_range_blockable(nrange) || - rc != -EAGAIN)) - continue; - ret = -EAGAIN; - break; - } - } - up_read(&hmm->mirrors_sem); - -out: - if (ret) - notifiers_decrement(hmm); - return ret; -} - -static void hmm_invalidate_range_end(struct mmu_notifier *mn, - const struct mmu_notifier_range *nrange) -{ - struct hmm *hmm = container_of(mn, struct hmm, mmu_notifier); - - notifiers_decrement(hmm); -} - -static const struct mmu_notifier_ops hmm_mmu_notifier_ops = { - .release = hmm_release, - .invalidate_range_start = hmm_invalidate_range_start, - .invalidate_range_end = hmm_invalidate_range_end, - .alloc_notifier = hmm_alloc_notifier, - .free_notifier = hmm_free_notifier, -}; - -/* - * hmm_mirror_register() - register a mirror against an mm - * - * @mirror: new mirror struct to register - * @mm: mm to register against - * Return: 0 on success, -ENOMEM if no memory, -EINVAL if invalid arguments - * - * To start mirroring a process address space, the device driver must register - * an HMM mirror struct. - * - * The caller cannot unregister the hmm_mirror while any ranges are - * registered. - * - * Callers using this function must put a call to mmu_notifier_synchronize() - * in their module exit functions. - */ -int hmm_mirror_register(struct hmm_mirror *mirror, struct mm_struct *mm) -{ - struct mmu_notifier *mn; - - lockdep_assert_held_write(&mm->mmap_sem); - - /* Sanity check */ - if (!mm || !mirror || !mirror->ops) - return -EINVAL; - - mn = mmu_notifier_get_locked(&hmm_mmu_notifier_ops, mm); - if (IS_ERR(mn)) - return PTR_ERR(mn); - mirror->hmm = container_of(mn, struct hmm, mmu_notifier); - - down_write(&mirror->hmm->mirrors_sem); - list_add(&mirror->list, &mirror->hmm->mirrors); - up_write(&mirror->hmm->mirrors_sem); - - return 0; -} -EXPORT_SYMBOL(hmm_mirror_register); - -/* - * hmm_mirror_unregister() - unregister a mirror - * - * @mirror: mirror struct to unregister - * - * Stop mirroring a process address space, and cleanup. - */ -void hmm_mirror_unregister(struct hmm_mirror *mirror) -{ - struct hmm *hmm = mirror->hmm; - - down_write(&hmm->mirrors_sem); - list_del(&mirror->list); - up_write(&hmm->mirrors_sem); - mmu_notifier_put(&hmm->mmu_notifier); -} -EXPORT_SYMBOL(hmm_mirror_unregister); - struct hmm_vma_walk { struct hmm_range *range; struct dev_pagemap *pgmap; @@ -779,87 +592,6 @@ static void hmm_pfns_clear(struct hmm_range *range, *pfns = range->values[HMM_PFN_NONE]; } -/* - * hmm_range_register() - start tracking change to CPU page table over a range - * @range: range - * @mm: the mm struct for the range of virtual address - * - * Return: 0 on success, -EFAULT if the address space is no longer valid - * - * Track updates to the CPU page table see include/linux/hmm.h - */ -int hmm_range_register(struct hmm_range *range, struct hmm_mirror *mirror) -{ - struct hmm *hmm = mirror->hmm; - unsigned long flags; - - range->valid = false; - range->hmm = NULL; - - if ((range->start & (PAGE_SIZE - 1)) || (range->end & (PAGE_SIZE - 1))) - return -EINVAL; - if (range->start >= range->end) - return -EINVAL; - - /* Prevent hmm_release() from running while the range is valid */ - if (!mmget_not_zero(hmm->mmu_notifier.mm)) - return -EFAULT; - - /* Initialize range to track CPU page table updates. */ - spin_lock_irqsave(&hmm->ranges_lock, flags); - - range->hmm = hmm; - list_add(&range->list, &hmm->ranges); - - /* - * If there are any concurrent notifiers we have to wait for them for - * the range to be valid (see hmm_range_wait_until_valid()). - */ - if (!hmm->notifiers) - range->valid = true; - spin_unlock_irqrestore(&hmm->ranges_lock, flags); - - return 0; -} -EXPORT_SYMBOL(hmm_range_register); - -/* - * hmm_range_unregister() - stop tracking change to CPU page table over a range - * @range: range - * - * Range struct is used to track updates to the CPU page table after a call to - * hmm_range_register(). See include/linux/hmm.h for how to use it. - */ -void hmm_range_unregister(struct hmm_range *range) -{ - struct hmm *hmm = range->hmm; - unsigned long flags; - - spin_lock_irqsave(&hmm->ranges_lock, flags); - list_del_init(&range->list); - spin_unlock_irqrestore(&hmm->ranges_lock, flags); - - /* Drop reference taken by hmm_range_register() */ - mmput(hmm->mmu_notifier.mm); - - /* - * The range is now invalid and the ref on the hmm is dropped, so - * poison the pointer. Leave other fields in place, for the caller's - * use. - */ - range->valid = false; - memset(&range->hmm, POISON_INUSE, sizeof(range->hmm)); -} -EXPORT_SYMBOL(hmm_range_unregister); - -static bool needs_retry(struct hmm_range *range) -{ - if (range->notifier) - return mmu_range_check_retry(range->notifier, - range->notifier_seq); - return !range->valid; -} - static const struct mm_walk_ops hmm_walk_ops = { .pud_entry = hmm_vma_walk_pud, .pmd_entry = hmm_vma_walk_pmd, @@ -900,20 +632,15 @@ long hmm_range_fault(struct hmm_range *range, unsigned int flags) const unsigned long device_vma = VM_IO | VM_PFNMAP | VM_MIXEDMAP; unsigned long start = range->start, end; struct hmm_vma_walk hmm_vma_walk; - struct mm_struct *mm; + struct mm_struct *mm = range->notifier->mm; struct vm_area_struct *vma; int ret; - if (range->notifier) - mm = range->notifier->mm; - else - mm = range->hmm->mmu_notifier.mm; - lockdep_assert_held(&mm->mmap_sem); do { /* If range is no longer valid force retry. */ - if (needs_retry(range)) + if (mmu_range_check_retry(range->notifier, range->notifier_seq)) return -EBUSY; vma = find_vma(mm, start); @@ -946,7 +673,9 @@ long hmm_range_fault(struct hmm_range *range, unsigned int flags) start = hmm_vma_walk.last; /* Keep trying while the range is valid. */ - } while (ret == -EBUSY && !needs_retry(range)); + } while (ret == -EBUSY && + !mmu_range_check_retry(range->notifier, + range->notifier_seq)); if (ret) { unsigned long i; @@ -1004,7 +733,8 @@ long hmm_range_dma_map(struct hmm_range *range, struct device *device, continue; /* Check if range is being invalidated */ - if (needs_retry(range)) { + if (mmu_range_check_retry(range->notifier, + range->notifier_seq)) { ret = -EBUSY; goto unmap; } -- 2.23.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jason Gunthorpe Subject: [PATCH hmm 15/15] mm/hmm: remove hmm_mirror and related Date: Tue, 15 Oct 2019 15:12:42 -0300 Message-ID: <20191015181242.8343-16-jgg@ziepe.ca> References: <20191015181242.8343-1-jgg@ziepe.ca> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20191015181242.8343-1-jgg-uk2M96/98Pc@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: amd-gfx-bounces-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Sender: "amd-gfx" To: Jerome Glisse , Ralph Campbell , John Hubbard , Felix.Kuehling-5C7GfCeVMHo@public.gmane.org Cc: Andrea Arcangeli , linux-rdma-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, amd-gfx-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, linux-mm-Bw31MaZKKs3YtjvyW6yDsg@public.gmane.org, Jason Gunthorpe , dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, Ben Skeggs List-Id: dri-devel@lists.freedesktop.org RnJvbTogSmFzb24gR3VudGhvcnBlIDxqZ2dAbWVsbGFub3guY29tPgoKVGhlIG9ubHkgdHdvIHVz ZXJzIG9mIHRoaXMgYXJlIG5vdyBjb252ZXJ0ZWQgdG8gdXNlIG1tdV9yYW5nZV9ub3RpZmllciwK ZGVsZXRlIGFsbCB0aGUgY29kZSBhbmQgdXBkYXRlIGhtbS5yc3QuCgpTaWduZWQtb2ZmLWJ5OiBK YXNvbiBHdW50aG9ycGUgPGpnZ0BtZWxsYW5veC5jb20+Ci0tLQogRG9jdW1lbnRhdGlvbi92bS9o bW0ucnN0IHwgMTA1ICsrKystLS0tLS0tLS0tLQogaW5jbHVkZS9saW51eC9obW0uaCAgICAgIHwg MTgzICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIG1tL0tjb25maWcgICAgICAgICAgICAgICB8 ICAgMSAtCiBtbS9obW0uYyAgICAgICAgICAgICAgICAgfCAyODQgKy0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tCiA0IGZpbGVzIGNoYW5nZWQsIDMzIGluc2VydGlvbnMoKyks IDU0MCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3ZtL2htbS5yc3Qg Yi9Eb2N1bWVudGF0aW9uL3ZtL2htbS5yc3QKaW5kZXggMGE1OTYwYmVjY2Y3NmQuLmEyNDc2NDMw MzVjNGUyIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3ZtL2htbS5yc3QKKysrIGIvRG9jdW1l bnRhdGlvbi92bS9obW0ucnN0CkBAIC0xNDcsNDkgKzE0NywxNiBAQCBBZGRyZXNzIHNwYWNlIG1p cnJvcmluZyBpbXBsZW1lbnRhdGlvbiBhbmQgQVBJCiBBZGRyZXNzIHNwYWNlIG1pcnJvcmluZydz IG1haW4gb2JqZWN0aXZlIGlzIHRvIGFsbG93IGR1cGxpY2F0aW9uIG9mIGEgcmFuZ2Ugb2YKIENQ VSBwYWdlIHRhYmxlIGludG8gYSBkZXZpY2UgcGFnZSB0YWJsZTsgSE1NIGhlbHBzIGtlZXAgYm90 aCBzeW5jaHJvbml6ZWQuIEEKIGRldmljZSBkcml2ZXIgdGhhdCB3YW50cyB0byBtaXJyb3IgYSBw cm9jZXNzIGFkZHJlc3Mgc3BhY2UgbXVzdCBzdGFydCB3aXRoIHRoZQotcmVnaXN0cmF0aW9uIG9m IGFuIGhtbV9taXJyb3Igc3RydWN0OjoKLQotIGludCBobW1fbWlycm9yX3JlZ2lzdGVyKHN0cnVj dCBobW1fbWlycm9yICptaXJyb3IsCi0gICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0IG1t X3N0cnVjdCAqbW0pOwotCi1UaGUgbWlycm9yIHN0cnVjdCBoYXMgYSBzZXQgb2YgY2FsbGJhY2tz IHRoYXQgYXJlIHVzZWQKLXRvIHByb3BhZ2F0ZSBDUFUgcGFnZSB0YWJsZXM6OgotCi0gc3RydWN0 IGhtbV9taXJyb3Jfb3BzIHsKLSAgICAgLyogcmVsZWFzZSgpIC0gcmVsZWFzZSBobW1fbWlycm9y Ci0gICAgICAqCi0gICAgICAqIEBtaXJyb3I6IHBvaW50ZXIgdG8gc3RydWN0IGhtbV9taXJyb3IK LSAgICAgICoKLSAgICAgICogVGhpcyBpcyBjYWxsZWQgd2hlbiB0aGUgbW1fc3RydWN0IGlzIGJl aW5nIHJlbGVhc2VkLiAgVGhlIGNhbGxiYWNrCi0gICAgICAqIG11c3QgZW5zdXJlIHRoYXQgYWxs IGFjY2VzcyB0byBhbnkgcGFnZXMgb2J0YWluZWQgZnJvbSB0aGlzIG1pcnJvcgotICAgICAgKiBp cyBoYWx0ZWQgYmVmb3JlIHRoZSBjYWxsYmFjayByZXR1cm5zLiBBbGwgZnV0dXJlIGFjY2VzcyBz aG91bGQKLSAgICAgICogZmF1bHQuCi0gICAgICAqLwotICAgICB2b2lkICgqcmVsZWFzZSkoc3Ry dWN0IGhtbV9taXJyb3IgKm1pcnJvcik7Ci0KLSAgICAgLyogc3luY19jcHVfZGV2aWNlX3BhZ2V0 YWJsZXMoKSAtIHN5bmNocm9uaXplIHBhZ2UgdGFibGVzCi0gICAgICAqCi0gICAgICAqIEBtaXJy b3I6IHBvaW50ZXIgdG8gc3RydWN0IGhtbV9taXJyb3IKLSAgICAgICogQHVwZGF0ZTogdXBkYXRl IGluZm9ybWF0aW9uIChzZWUgc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSkKLSAgICAgICogUmV0 dXJuOiAtRUFHQUlOIGlmIHVwZGF0ZS5ibG9ja2FibGUgZmFsc2UgYW5kIGNhbGxiYWNrIG5lZWQg dG8KLSAgICAgICogICAgICAgICBibG9jaywgMCBvdGhlcndpc2UuCi0gICAgICAqCi0gICAgICAq IFRoaXMgY2FsbGJhY2sgdWx0aW1hdGVseSBvcmlnaW5hdGVzIGZyb20gbW11X25vdGlmaWVycyB3 aGVuIHRoZSBDUFUKLSAgICAgICogcGFnZSB0YWJsZSBpcyB1cGRhdGVkLiBUaGUgZGV2aWNlIGRy aXZlciBtdXN0IHVwZGF0ZSBpdHMgcGFnZSB0YWJsZQotICAgICAgKiBpbiByZXNwb25zZSB0byB0 aGlzIGNhbGxiYWNrLiBUaGUgdXBkYXRlIGFyZ3VtZW50IHRlbGxzIHdoYXQgYWN0aW9uCi0gICAg ICAqIHRvIHBlcmZvcm0uCi0gICAgICAqCi0gICAgICAqIFRoZSBkZXZpY2UgZHJpdmVyIG11c3Qg bm90IHJldHVybiBmcm9tIHRoaXMgY2FsbGJhY2sgdW50aWwgdGhlIGRldmljZQotICAgICAgKiBw YWdlIHRhYmxlcyBhcmUgY29tcGxldGVseSB1cGRhdGVkIChUTEJzIGZsdXNoZWQsIGV0Yyk7IHRo aXMgaXMgYQotICAgICAgKiBzeW5jaHJvbm91cyBjYWxsLgotICAgICAgKi8KLSAgICAgaW50ICgq c3luY19jcHVfZGV2aWNlX3BhZ2V0YWJsZXMpKHN0cnVjdCBobW1fbWlycm9yICptaXJyb3IsCi0g ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBzdHJ1Y3QgaG1tX3Vw ZGF0ZSAqdXBkYXRlKTsKLSB9OwotCi1UaGUgZGV2aWNlIGRyaXZlciBtdXN0IHBlcmZvcm0gdGhl IHVwZGF0ZSBhY3Rpb24gdG8gdGhlIHJhbmdlIChtYXJrIHJhbmdlCi1yZWFkIG9ubHksIG9yIGZ1 bGx5IHVubWFwLCBldGMuKS4gVGhlIGRldmljZSBtdXN0IGNvbXBsZXRlIHRoZSB1cGRhdGUgYmVm b3JlCi10aGUgZHJpdmVyIGNhbGxiYWNrIHJldHVybnMuCityZWdpc3RyYXRpb24gb2YgYSBtbXVf cmFuZ2Vfbm90aWZpZXI6OgorCisgbXJuLT5vcHMgPSAmZHJpdmVyX29wczsKKyBpbnQgbW11X3Jh bmdlX25vdGlmaWVyX2luc2VydChzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyICptcm4sCisJCQkg ICAgICB1bnNpZ25lZCBsb25nIHN0YXJ0LCB1bnNpZ25lZCBsb25nIGxlbmd0aCwKKwkJCSAgICAg IHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKTsKKworRHVyaW5nIHRoZSBkcml2ZXJfb3BzLT5pbnZhbGlk YXRlKCkgY2FsbGJhY2sgdGhlIGRldmljZSBkcml2ZXIgbXVzdCBwZXJmb3JtCit0aGUgdXBkYXRl IGFjdGlvbiB0byB0aGUgcmFuZ2UgKG1hcmsgcmFuZ2UgcmVhZCBvbmx5LCBvciBmdWxseSB1bm1h cCwKK2V0Yy4pLiBUaGUgZGV2aWNlIG11c3QgY29tcGxldGUgdGhlIHVwZGF0ZSBiZWZvcmUgdGhl IGRyaXZlciBjYWxsYmFjayByZXR1cm5zLgogCiBXaGVuIHRoZSBkZXZpY2UgZHJpdmVyIHdhbnRz IHRvIHBvcHVsYXRlIGEgcmFuZ2Ugb2YgdmlydHVhbCBhZGRyZXNzZXMsIGl0IGNhbgogdXNlOjoK QEAgLTIxNiw3MCArMTgzLDQ2IEBAIFRoZSB1c2FnZSBwYXR0ZXJuIGlzOjoKICAgICAgIHN0cnVj dCBobW1fcmFuZ2UgcmFuZ2U7CiAgICAgICAuLi4KIAorICAgICAgcmFuZ2Uubm90aWZpZXIgPSAm bXJuOwogICAgICAgcmFuZ2Uuc3RhcnQgPSAuLi47CiAgICAgICByYW5nZS5lbmQgPSAuLi47CiAg ICAgICByYW5nZS5wZm5zID0gLi4uOwogICAgICAgcmFuZ2UuZmxhZ3MgPSAuLi47CiAgICAgICBy YW5nZS52YWx1ZXMgPSAuLi47CiAgICAgICByYW5nZS5wZm5fc2hpZnQgPSAuLi47Ci0gICAgICBo bW1fcmFuZ2VfcmVnaXN0ZXIoJnJhbmdlLCBtaXJyb3IpOwogCi0gICAgICAvKgotICAgICAgICog SnVzdCB3YWl0IGZvciByYW5nZSB0byBiZSB2YWxpZCwgc2FmZSB0byBpZ25vcmUgcmV0dXJuIHZh bHVlIGFzIHdlCi0gICAgICAgKiB3aWxsIHVzZSB0aGUgcmV0dXJuIHZhbHVlIG9mIGhtbV9yYW5n ZV9mYXVsdCgpIGJlbG93IHVuZGVyIHRoZQotICAgICAgICogbW1hcF9zZW0gdG8gYXNjZXJ0YWlu IHRoZSB2YWxpZGl0eSBvZiB0aGUgcmFuZ2UuCi0gICAgICAgKi8KLSAgICAgIGhtbV9yYW5nZV93 YWl0X3VudGlsX3ZhbGlkKCZyYW5nZSwgVElNRU9VVF9JTl9NU0VDKTsKKyAgICAgIGlmICghbW1n ZXRfbm90X3plcm8obXJuLT5ub3RpZmllci5tbSkpCisgICAgICAgICAgcmV0dXJuIC1FRkFVTFQ7 CiAKICBhZ2FpbjoKKyAgICAgIHJhbmdlLm5vdGlmaWVyX3NlcSA9IG1tdV9yYW5nZV9yZWFkX2Jl Z2luKCZtcm4pOwogICAgICAgZG93bl9yZWFkKCZtbS0+bW1hcF9zZW0pOwogICAgICAgcmV0ID0g aG1tX3JhbmdlX2ZhdWx0KCZyYW5nZSwgSE1NX1JBTkdFX1NOQVBTSE9UKTsKICAgICAgIGlmIChy ZXQpIHsKICAgICAgICAgICB1cF9yZWFkKCZtbS0+bW1hcF9zZW0pOwotICAgICAgICAgIGlmIChy ZXQgPT0gLUVCVVNZKSB7Ci0gICAgICAgICAgICAvKgotICAgICAgICAgICAgICogTm8gbmVlZCB0 byBjaGVjayBobW1fcmFuZ2Vfd2FpdF91bnRpbF92YWxpZCgpIHJldHVybiB2YWx1ZQotICAgICAg ICAgICAgICogb24gcmV0cnkgd2Ugd2lsbCBnZXQgcHJvcGVyIGVycm9yIHdpdGggaG1tX3Jhbmdl X2ZhdWx0KCkKLSAgICAgICAgICAgICAqLwotICAgICAgICAgICAgaG1tX3JhbmdlX3dhaXRfdW50 aWxfdmFsaWQoJnJhbmdlLCBUSU1FT1VUX0lOX01TRUMpOwotICAgICAgICAgICAgZ290byBhZ2Fp bjsKLSAgICAgICAgICB9Ci0gICAgICAgICAgaG1tX3JhbmdlX3VucmVnaXN0ZXIoJnJhbmdlKTsK KyAgICAgICAgICBpZiAocmV0ID09IC1FQlVTWSkKKyAgICAgICAgICAgICAgICAgZ290byBhZ2Fp bjsKICAgICAgICAgICByZXR1cm4gcmV0OwogICAgICAgfQorICAgICAgdXBfcmVhZCgmbW0tPm1t YXBfc2VtKTsKKwogICAgICAgdGFrZV9sb2NrKGRyaXZlci0+dXBkYXRlKTsKLSAgICAgIGlmICgh aG1tX3JhbmdlX3ZhbGlkKCZyYW5nZSkpIHsKKyAgICAgIGlmIChtbXVfcmFuZ2VfcmVhZF9yZXRy eSgmbXJuLCByYW5nZS5ub3RpZmllcl9zZXEpIHsKICAgICAgICAgICByZWxlYXNlX2xvY2soZHJp dmVyLT51cGRhdGUpOwotICAgICAgICAgIHVwX3JlYWQoJm1tLT5tbWFwX3NlbSk7CiAgICAgICAg ICAgZ290byBhZ2FpbjsKICAgICAgIH0KIAotICAgICAgLy8gVXNlIHBmbnMgYXJyYXkgY29udGVu dCB0byB1cGRhdGUgZGV2aWNlIHBhZ2UgdGFibGUKKyAgICAgIC8qIFVzZSBwZm5zIGFycmF5IGNv bnRlbnQgdG8gdXBkYXRlIGRldmljZSBwYWdlIHRhYmxlLAorICAgICAgICogdW5kZXIgdGhlIHVw ZGF0ZSBsb2NrICovCiAKLSAgICAgIGhtbV9yYW5nZV91bnJlZ2lzdGVyKCZyYW5nZSk7CiAgICAg ICByZWxlYXNlX2xvY2soZHJpdmVyLT51cGRhdGUpOwotICAgICAgdXBfcmVhZCgmbW0tPm1tYXBf c2VtKTsKICAgICAgIHJldHVybiAwOwogIH0KIAogVGhlIGRyaXZlci0+dXBkYXRlIGxvY2sgaXMg dGhlIHNhbWUgbG9jayB0aGF0IHRoZSBkcml2ZXIgdGFrZXMgaW5zaWRlIGl0cwotc3luY19jcHVf ZGV2aWNlX3BhZ2V0YWJsZXMoKSBjYWxsYmFjay4gVGhhdCBsb2NrIG11c3QgYmUgaGVsZCBiZWZv cmUgY2FsbGluZwotaG1tX3JhbmdlX3ZhbGlkKCkgdG8gYXZvaWQgYW55IHJhY2Ugd2l0aCBhIGNv bmN1cnJlbnQgQ1BVIHBhZ2UgdGFibGUgdXBkYXRlLgotCi1ITU0gaW1wbGVtZW50cyBhbGwgdGhp cyBvbiB0b3Agb2YgdGhlIG1tdV9ub3RpZmllciBBUEkgYmVjYXVzZSB3ZSB3YW50ZWQgYQotc2lt cGxlciBBUEkgYW5kIGFsc28gdG8gYmUgYWJsZSB0byBwZXJmb3JtIG9wdGltaXphdGlvbnMgbGF0 dGVyIG9uIGxpa2UgZG9pbmcKLWNvbmN1cnJlbnQgZGV2aWNlIHVwZGF0ZXMgaW4gbXVsdGktZGV2 aWNlcyBzY2VuYXJpby4KLQotSE1NIGFsc28gc2VydmVzIGFzIGFuIGltcGVkYW5jZSBtaXNtYXRj aCBiZXR3ZWVuIGhvdyBDUFUgcGFnZSB0YWJsZSB1cGRhdGVzCi1hcmUgZG9uZSAoYnkgQ1BVIHdy aXRlIHRvIHRoZSBwYWdlIHRhYmxlIGFuZCBUTEIgZmx1c2hlcykgYW5kIGhvdyBkZXZpY2VzCi11 cGRhdGUgdGhlaXIgb3duIHBhZ2UgdGFibGUuIERldmljZSB1cGRhdGVzIGFyZSBhIG11bHRpLXN0 ZXAgcHJvY2Vzcy4gRmlyc3QsCi1hcHByb3ByaWF0ZSBjb21tYW5kcyBhcmUgd3JpdHRlbiB0byBh IGJ1ZmZlciwgdGhlbiB0aGlzIGJ1ZmZlciBpcyBzY2hlZHVsZWQgZm9yCi1leGVjdXRpb24gb24g dGhlIGRldmljZS4gSXQgaXMgb25seSBvbmNlIHRoZSBkZXZpY2UgaGFzIGV4ZWN1dGVkIGNvbW1h bmRzIGluCi10aGUgYnVmZmVyIHRoYXQgdGhlIHVwZGF0ZSBpcyBkb25lLiBDcmVhdGluZyBhbmQg c2NoZWR1bGluZyB0aGUgdXBkYXRlIGNvbW1hbmQKLWJ1ZmZlciBjYW4gaGFwcGVuIGNvbmN1cnJl bnRseSBmb3IgbXVsdGlwbGUgZGV2aWNlcy4gV2FpdGluZyBmb3IgZWFjaCBkZXZpY2UgdG8KLXJl cG9ydCBjb21tYW5kcyBhcyBleGVjdXRlZCBpcyBzZXJpYWxpemVkICh0aGVyZSBpcyBubyBwb2lu dCBpbiBkb2luZyB0aGlzCi1jb25jdXJyZW50bHkpLgotCitpbnZhbGlkYXRlKCkgY2FsbGJhY2su IFRoYXQgbG9jayBtdXN0IGJlIGhlbGQgYmVmb3JlIGNhbGxpbmcKK21tdV9yYW5nZV9yZWFkX3Jl dHJ5KCkgdG8gYXZvaWQgYW55IHJhY2Ugd2l0aCBhIGNvbmN1cnJlbnQgQ1BVIHBhZ2UgdGFibGUK K3VwZGF0ZS4KIAogTGV2ZXJhZ2UgZGVmYXVsdF9mbGFncyBhbmQgcGZuX2ZsYWdzX21hc2sKID09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CmRpZmYgLS1naXQgYS9pbmNs dWRlL2xpbnV4L2htbS5oIGIvaW5jbHVkZS9saW51eC9obW0uaAppbmRleCAyNjY2ZWIwOGE0MDYx NS4uYjRhZjUxNzM1MjMyMzIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvaG1tLmgKKysrIGIv aW5jbHVkZS9saW51eC9obW0uaApAQCAtNjgsMjkgKzY4LDYgQEAKICNpbmNsdWRlIDxsaW51eC9j b21wbGV0aW9uLmg+CiAjaW5jbHVkZSA8bGludXgvbW11X25vdGlmaWVyLmg+CiAKLQotLyoKLSAq IHN0cnVjdCBobW0gLSBITU0gcGVyIG1tIHN0cnVjdAotICoKLSAqIEBtbTogbW0gc3RydWN0IHRo aXMgSE1NIHN0cnVjdCBpcyBib3VuZCB0bwotICogQGxvY2s6IGxvY2sgcHJvdGVjdGluZyByYW5n ZXMgbGlzdAotICogQHJhbmdlczogbGlzdCBvZiByYW5nZSBiZWluZyBzbmFwc2hvdHRlZAotICog QG1pcnJvcnM6IGxpc3Qgb2YgbWlycm9ycyBmb3IgdGhpcyBtbQotICogQG1tdV9ub3RpZmllcjog bW11IG5vdGlmaWVyIHRvIHRyYWNrIHVwZGF0ZXMgdG8gQ1BVIHBhZ2UgdGFibGUKLSAqIEBtaXJy b3JzX3NlbTogcmVhZC93cml0ZSBzZW1hcGhvcmUgcHJvdGVjdGluZyB0aGUgbWlycm9ycyBsaXN0 Ci0gKiBAd3E6IHdhaXQgcXVldWUgZm9yIHVzZXIgd2FpdGluZyBvbiBhIHJhbmdlIGludmFsaWRh dGlvbgotICogQG5vdGlmaWVyczogY291bnQgb2YgYWN0aXZlIG1tdSBub3RpZmllcnMKLSAqLwot c3RydWN0IGhtbSB7Ci0Jc3RydWN0IG1tdV9ub3RpZmllcgltbXVfbm90aWZpZXI7Ci0Jc3Bpbmxv Y2tfdAkJcmFuZ2VzX2xvY2s7Ci0Jc3RydWN0IGxpc3RfaGVhZAlyYW5nZXM7Ci0Jc3RydWN0IGxp c3RfaGVhZAltaXJyb3JzOwotCXN0cnVjdCByd19zZW1hcGhvcmUJbWlycm9yc19zZW07Ci0Jd2Fp dF9xdWV1ZV9oZWFkX3QJd3E7Ci0JbG9uZwkJCW5vdGlmaWVyczsKLX07Ci0KIC8qCiAgKiBobW1f cGZuX2ZsYWdfZSAtIEhNTSBmbGFnIGVudW1zCiAgKgpAQCAtMTQzLDkgKzEyMCw4IEBAIGVudW0g aG1tX3Bmbl92YWx1ZV9lIHsKIC8qCiAgKiBzdHJ1Y3QgaG1tX3JhbmdlIC0gdHJhY2sgaW52YWxp ZGF0aW9uIGxvY2sgb24gdmlydHVhbCBhZGRyZXNzIHJhbmdlCiAgKgotICogQG5vdGlmaWVyOiBh biBvcHRpb25hbCBtbXVfcmFuZ2Vfbm90aWZpZXIKLSAqIEBub3RpZmllcl9zZXE6IHdoZW4gbm90 aWZpZXIgaXMgdXNlZCB0aGlzIGlzIHRoZSByZXN1bHQgb2YKLSAqICAgICAgICAgICAgICAgIG1t dV9yYW5nZV9yZWFkX2JlZ2luKCkKKyAqIEBub3RpZmllcjogYSBtbXVfcmFuZ2Vfbm90aWZpZXIg dGhhdCBpbmNsdWRlcyB0aGUgc3RhcnQvZW5kCisgKiBAbm90aWZpZXJfc2VxOiByZXN1bHQgb2Yg bW11X3JhbmdlX3JlYWRfYmVnaW4oKQogICogQGhtbTogdGhlIGNvcmUgSE1NIHN0cnVjdHVyZSB0 aGlzIHJhbmdlIGlzIGFjdGl2ZSBhZ2FpbnN0CiAgKiBAdm1hOiB0aGUgdm0gYXJlYSBzdHJ1Y3Qg Zm9yIHRoZSByYW5nZQogICogQGxpc3Q6IGFsbCByYW5nZSBsb2NrIGFyZSBvbiBhIGxpc3QKQEAg LTE2Miw4ICsxMzgsNiBAQCBlbnVtIGhtbV9wZm5fdmFsdWVfZSB7CiBzdHJ1Y3QgaG1tX3Jhbmdl IHsKIAlzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyICpub3RpZmllcjsKIAl1bnNpZ25lZCBsb25n CQlub3RpZmllcl9zZXE7Ci0Jc3RydWN0IGhtbQkJKmhtbTsKLQlzdHJ1Y3QgbGlzdF9oZWFkCWxp c3Q7CiAJdW5zaWduZWQgbG9uZwkJc3RhcnQ7CiAJdW5zaWduZWQgbG9uZwkJZW5kOwogCXVpbnQ2 NF90CQkqcGZuczsKQEAgLTE3MiwzMiArMTQ2LDggQEAgc3RydWN0IGhtbV9yYW5nZSB7CiAJdWlu dDY0X3QJCWRlZmF1bHRfZmxhZ3M7CiAJdWludDY0X3QJCXBmbl9mbGFnc19tYXNrOwogCXVpbnQ4 X3QJCQlwZm5fc2hpZnQ7Ci0JYm9vbAkJCXZhbGlkOwogfTsKIAotLyoKLSAqIGhtbV9yYW5nZV93 YWl0X3VudGlsX3ZhbGlkKCkgLSB3YWl0IGZvciByYW5nZSB0byBiZSB2YWxpZAotICogQHJhbmdl OiByYW5nZSBhZmZlY3RlZCBieSBpbnZhbGlkYXRpb24gdG8gd2FpdCBvbgotICogQHRpbWVvdXQ6 IHRpbWUgb3V0IGZvciB3YWl0IGluIG1zIChpZSBhYm9ydCB3YWl0IGFmdGVyIHRoYXQgcGVyaW9k IG9mIHRpbWUpCi0gKiBSZXR1cm46IHRydWUgaWYgdGhlIHJhbmdlIGlzIHZhbGlkLCBmYWxzZSBv dGhlcndpc2UuCi0gKi8KLXN0YXRpYyBpbmxpbmUgYm9vbCBobW1fcmFuZ2Vfd2FpdF91bnRpbF92 YWxpZChzdHJ1Y3QgaG1tX3JhbmdlICpyYW5nZSwKLQkJCQkJICAgICAgdW5zaWduZWQgbG9uZyB0 aW1lb3V0KQotewotCXJldHVybiB3YWl0X2V2ZW50X3RpbWVvdXQocmFuZ2UtPmhtbS0+d3EsIHJh bmdlLT52YWxpZCwKLQkJCQkgIG1zZWNzX3RvX2ppZmZpZXModGltZW91dCkpICE9IDA7Ci19Ci0K LS8qCi0gKiBobW1fcmFuZ2VfdmFsaWQoKSAtIHRlc3QgaWYgYSByYW5nZSBpcyB2YWxpZCBvciBu b3QKLSAqIEByYW5nZTogcmFuZ2UKLSAqIFJldHVybjogdHJ1ZSBpZiB0aGUgcmFuZ2UgaXMgdmFs aWQsIGZhbHNlIG90aGVyd2lzZS4KLSAqLwotc3RhdGljIGlubGluZSBib29sIGhtbV9yYW5nZV92 YWxpZChzdHJ1Y3QgaG1tX3JhbmdlICpyYW5nZSkKLXsKLQlyZXR1cm4gcmFuZ2UtPnZhbGlkOwot fQotCiAvKgogICogaG1tX2RldmljZV9lbnRyeV90b19wYWdlKCkgLSByZXR1cm4gc3RydWN0IHBh Z2UgcG9pbnRlZCB0byBieSBhIGRldmljZSBlbnRyeQogICogQHJhbmdlOiByYW5nZSB1c2UgdG8g ZGVjb2RlIGRldmljZSBlbnRyeSB2YWx1ZQpAQCAtMjY3LDExMSArMjE3LDYgQEAgc3RhdGljIGlu bGluZSB1aW50NjRfdCBobW1fZGV2aWNlX2VudHJ5X2Zyb21fcGZuKGNvbnN0IHN0cnVjdCBobW1f cmFuZ2UgKnJhbmdlLAogCQlyYW5nZS0+ZmxhZ3NbSE1NX1BGTl9WQUxJRF07CiB9CiAKLS8qCi0g KiBNaXJyb3Jpbmc6IGhvdyB0byBzeW5jaHJvbml6ZSBkZXZpY2UgcGFnZSB0YWJsZSB3aXRoIENQ VSBwYWdlIHRhYmxlLgotICoKLSAqIEEgZGV2aWNlIGRyaXZlciB0aGF0IGlzIHBhcnRpY2lwYXRp bmcgaW4gSE1NIG1pcnJvcmluZyBtdXN0IGFsd2F5cwotICogc3luY2hyb25pemUgd2l0aCBDUFUg cGFnZSB0YWJsZSB1cGRhdGVzLiBGb3IgdGhpcywgZGV2aWNlIGRyaXZlcnMgY2FuIGVpdGhlcgot ICogZGlyZWN0bHkgdXNlIG1tdV9ub3RpZmllciBBUElzIG9yIHRoZXkgY2FuIHVzZSB0aGUgaG1t X21pcnJvciBBUEkuIERldmljZQotICogZHJpdmVycyBjYW4gZGVjaWRlIHRvIHJlZ2lzdGVyIG9u ZSBtaXJyb3IgcGVyIGRldmljZSBwZXIgcHJvY2Vzcywgb3IganVzdAotICogb25lIG1pcnJvciBw ZXIgcHJvY2VzcyBmb3IgYSBncm91cCBvZiBkZXZpY2VzLiBUaGUgcGF0dGVybiBpczoKLSAqCi0g KiAgICAgIGludCBkZXZpY2VfYmluZF9hZGRyZXNzX3NwYWNlKC4uLiwgc3RydWN0IG1tX3N0cnVj dCAqbW0sIC4uLikKLSAqICAgICAgewotICogICAgICAgICAgc3RydWN0IGRldmljZV9hZGRyZXNz X3NwYWNlICpkYXM7Ci0gKgotICogICAgICAgICAgLy8gRGV2aWNlIGRyaXZlciBzcGVjaWZpYyBp bml0aWFsaXphdGlvbiwgYW5kIGFsbG9jYXRpb24gb2YgZGFzCi0gKiAgICAgICAgICAvLyB3aGlj aCBjb250YWlucyBhbiBobW1fbWlycm9yIHN0cnVjdCBhcyBvbmUgb2YgaXRzIGZpZWxkcy4KLSAq ICAgICAgICAgIC4uLgotICoKLSAqICAgICAgICAgIHJldCA9IGhtbV9taXJyb3JfcmVnaXN0ZXIo JmRhcy0+bWlycm9yLCBtbSwgJmRldmljZV9taXJyb3Jfb3BzKTsKLSAqICAgICAgICAgIGlmIChy ZXQpIHsKLSAqICAgICAgICAgICAgICAvLyBDbGVhbnVwIG9uIGVycm9yCi0gKiAgICAgICAgICAg ICAgcmV0dXJuIHJldDsKLSAqICAgICAgICAgIH0KLSAqCi0gKiAgICAgICAgICAvLyBPdGhlciBk ZXZpY2UgZHJpdmVyIHNwZWNpZmljIGluaXRpYWxpemF0aW9uCi0gKiAgICAgICAgICAuLi4KLSAq ICAgICAgfQotICoKLSAqIE9uY2UgYW4gaG1tX21pcnJvciBpcyByZWdpc3RlcmVkIGZvciBhbiBh ZGRyZXNzIHNwYWNlLCB0aGUgZGV2aWNlIGRyaXZlcgotICogd2lsbCBnZXQgY2FsbGJhY2tzIHRo cm91Z2ggc3luY19jcHVfZGV2aWNlX3BhZ2V0YWJsZXMoKSBvcGVyYXRpb24gKHNlZQotICogaG1t X21pcnJvcl9vcHMgc3RydWN0KS4KLSAqCi0gKiBEZXZpY2UgZHJpdmVyIG11c3Qgbm90IGZyZWUg dGhlIHN0cnVjdCBjb250YWluaW5nIHRoZSBobW1fbWlycm9yIHN0cnVjdAotICogYmVmb3JlIGNh bGxpbmcgaG1tX21pcnJvcl91bnJlZ2lzdGVyKCkuIFRoZSBleHBlY3RlZCB1c2FnZSBpcyB0byBk byB0aGF0IHdoZW4KLSAqIHRoZSBkZXZpY2UgZHJpdmVyIGlzIHVuYmluZGluZyBmcm9tIGFuIGFk ZHJlc3Mgc3BhY2UuCi0gKgotICoKLSAqICAgICAgdm9pZCBkZXZpY2VfdW5iaW5kX2FkZHJlc3Nf c3BhY2Uoc3RydWN0IGRldmljZV9hZGRyZXNzX3NwYWNlICpkYXMpCi0gKiAgICAgIHsKLSAqICAg ICAgICAgIC8vIERldmljZSBkcml2ZXIgc3BlY2lmaWMgY2xlYW51cAotICogICAgICAgICAgLi4u Ci0gKgotICogICAgICAgICAgaG1tX21pcnJvcl91bnJlZ2lzdGVyKCZkYXMtPm1pcnJvcik7Ci0g KgotICogICAgICAgICAgLy8gT3RoZXIgZGV2aWNlIGRyaXZlciBzcGVjaWZpYyBjbGVhbnVwLCBh bmQgbm93IGRhcyBjYW4gYmUgZnJlZWQKLSAqICAgICAgICAgIC4uLgotICogICAgICB9Ci0gKi8K LQotc3RydWN0IGhtbV9taXJyb3I7Ci0KLS8qCi0gKiBzdHJ1Y3QgaG1tX21pcnJvcl9vcHMgLSBI TU0gbWlycm9yIGRldmljZSBvcGVyYXRpb25zIGNhbGxiYWNrCi0gKgotICogQHVwZGF0ZTogY2Fs bGJhY2sgdG8gdXBkYXRlIHJhbmdlIG9uIGEgZGV2aWNlCi0gKi8KLXN0cnVjdCBobW1fbWlycm9y X29wcyB7Ci0JLyogcmVsZWFzZSgpIC0gcmVsZWFzZSBobW1fbWlycm9yCi0JICoKLQkgKiBAbWly cm9yOiBwb2ludGVyIHRvIHN0cnVjdCBobW1fbWlycm9yCi0JICoKLQkgKiBUaGlzIGlzIGNhbGxl ZCB3aGVuIHRoZSBtbV9zdHJ1Y3QgaXMgYmVpbmcgcmVsZWFzZWQuICBUaGUgY2FsbGJhY2sKLQkg KiBtdXN0IGVuc3VyZSB0aGF0IGFsbCBhY2Nlc3MgdG8gYW55IHBhZ2VzIG9idGFpbmVkIGZyb20g dGhpcyBtaXJyb3IKLQkgKiBpcyBoYWx0ZWQgYmVmb3JlIHRoZSBjYWxsYmFjayByZXR1cm5zLiBB bGwgZnV0dXJlIGFjY2VzcyBzaG91bGQKLQkgKiBmYXVsdC4KLQkgKi8KLQl2b2lkICgqcmVsZWFz ZSkoc3RydWN0IGhtbV9taXJyb3IgKm1pcnJvcik7Ci0KLQkvKiBzeW5jX2NwdV9kZXZpY2VfcGFn ZXRhYmxlcygpIC0gc3luY2hyb25pemUgcGFnZSB0YWJsZXMKLQkgKgotCSAqIEBtaXJyb3I6IHBv aW50ZXIgdG8gc3RydWN0IGhtbV9taXJyb3IKLQkgKiBAdXBkYXRlOiB1cGRhdGUgaW5mb3JtYXRp b24gKHNlZSBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlKQotCSAqIFJldHVybjogLUVBR0FJTiBp ZiBtbXVfbm90aWZpZXJfcmFuZ2VfYmxvY2thYmxlKHVwZGF0ZSkgaXMgZmFsc2UKLQkgKiBhbmQg Y2FsbGJhY2sgbmVlZHMgdG8gYmxvY2ssIDAgb3RoZXJ3aXNlLgotCSAqCi0JICogVGhpcyBjYWxs YmFjayB1bHRpbWF0ZWx5IG9yaWdpbmF0ZXMgZnJvbSBtbXVfbm90aWZpZXJzIHdoZW4gdGhlIENQ VQotCSAqIHBhZ2UgdGFibGUgaXMgdXBkYXRlZC4gVGhlIGRldmljZSBkcml2ZXIgbXVzdCB1cGRh dGUgaXRzIHBhZ2UgdGFibGUKLQkgKiBpbiByZXNwb25zZSB0byB0aGlzIGNhbGxiYWNrLiBUaGUg dXBkYXRlIGFyZ3VtZW50IHRlbGxzIHdoYXQgYWN0aW9uCi0JICogdG8gcGVyZm9ybS4KLQkgKgot CSAqIFRoZSBkZXZpY2UgZHJpdmVyIG11c3Qgbm90IHJldHVybiBmcm9tIHRoaXMgY2FsbGJhY2sg dW50aWwgdGhlIGRldmljZQotCSAqIHBhZ2UgdGFibGVzIGFyZSBjb21wbGV0ZWx5IHVwZGF0ZWQg KFRMQnMgZmx1c2hlZCwgZXRjKTsgdGhpcyBpcyBhCi0JICogc3luY2hyb25vdXMgY2FsbC4KLQkg Ki8KLQlpbnQgKCpzeW5jX2NwdV9kZXZpY2VfcGFnZXRhYmxlcykoCi0JCXN0cnVjdCBobW1fbWly cm9yICptaXJyb3IsCi0JCWNvbnN0IHN0cnVjdCBtbXVfbm90aWZpZXJfcmFuZ2UgKnVwZGF0ZSk7 Ci19OwotCi0vKgotICogc3RydWN0IGhtbV9taXJyb3IgLSBtaXJyb3Igc3RydWN0IGZvciBhIGRl dmljZSBkcml2ZXIKLSAqCi0gKiBAaG1tOiBwb2ludGVyIHRvIHN0cnVjdCBobW0gKHdoaWNoIGlz IHVuaXF1ZSBwZXIgbW1fc3RydWN0KQotICogQG9wczogZGV2aWNlIGRyaXZlciBjYWxsYmFjayBm b3IgSE1NIG1pcnJvciBvcGVyYXRpb25zCi0gKiBAbGlzdDogZm9yIGxpc3Qgb2YgbWlycm9ycyBv ZiBhIGdpdmVuIG1tCi0gKgotICogRWFjaCBhZGRyZXNzIHNwYWNlIChtbV9zdHJ1Y3QpIGJlaW5n IG1pcnJvcmVkIGJ5IGEgZGV2aWNlIG11c3QgcmVnaXN0ZXIgb25lCi0gKiBpbnN0YW5jZSBvZiBh biBobW1fbWlycm9yIHN0cnVjdCB3aXRoIEhNTS4gSE1NIHdpbGwgdHJhY2sgdGhlIGxpc3Qgb2Yg YWxsCi0gKiBtaXJyb3JzIGZvciBlYWNoIG1tX3N0cnVjdC4KLSAqLwotc3RydWN0IGhtbV9taXJy b3IgewotCXN0cnVjdCBobW0JCQkqaG1tOwotCWNvbnN0IHN0cnVjdCBobW1fbWlycm9yX29wcwkq b3BzOwotCXN0cnVjdCBsaXN0X2hlYWQJCWxpc3Q7Ci19OwotCiAvKgogICogUmV0cnkgZmF1bHQg aWYgbm9uLWJsb2NraW5nLCBkcm9wIG1tYXBfc2VtIGFuZCByZXR1cm4gLUVBR0FJTiBpbiB0aGF0 IGNhc2UuCiAgKi8KQEAgLTM4MSwxNSArMjI2LDkgQEAgc3RydWN0IGhtbV9taXJyb3IgewogI2Rl ZmluZSBITU1fRkFVTFRfU05BUFNIT1QJCSgxIDw8IDEpCiAKICNpZmRlZiBDT05GSUdfSE1NX01J UlJPUgotaW50IGhtbV9taXJyb3JfcmVnaXN0ZXIoc3RydWN0IGhtbV9taXJyb3IgKm1pcnJvciwg c3RydWN0IG1tX3N0cnVjdCAqbW0pOwotdm9pZCBobW1fbWlycm9yX3VucmVnaXN0ZXIoc3RydWN0 IGhtbV9taXJyb3IgKm1pcnJvcik7Ci0KIC8qCiAgKiBQbGVhc2Ugc2VlIERvY3VtZW50YXRpb24v dm0vaG1tLnJzdCBmb3IgaG93IHRvIHVzZSB0aGUgcmFuZ2UgQVBJLgogICovCi1pbnQgaG1tX3Jh bmdlX3JlZ2lzdGVyKHN0cnVjdCBobW1fcmFuZ2UgKnJhbmdlLCBzdHJ1Y3QgaG1tX21pcnJvciAq bWlycm9yKTsKLXZvaWQgaG1tX3JhbmdlX3VucmVnaXN0ZXIoc3RydWN0IGhtbV9yYW5nZSAqcmFu Z2UpOwotCiBsb25nIGhtbV9yYW5nZV9mYXVsdChzdHJ1Y3QgaG1tX3JhbmdlICpyYW5nZSwgdW5z aWduZWQgaW50IGZsYWdzKTsKIAogbG9uZyBobW1fcmFuZ2VfZG1hX21hcChzdHJ1Y3QgaG1tX3Jh bmdlICpyYW5nZSwKQEAgLTQwMSwyNCArMjQwLDYgQEAgbG9uZyBobW1fcmFuZ2VfZG1hX3VubWFw KHN0cnVjdCBobW1fcmFuZ2UgKnJhbmdlLAogCQkJIGRtYV9hZGRyX3QgKmRhZGRycywKIAkJCSBi b29sIGRpcnR5KTsKICNlbHNlCi1pbnQgaG1tX21pcnJvcl9yZWdpc3RlcihzdHJ1Y3QgaG1tX21p cnJvciAqbWlycm9yLCBzdHJ1Y3QgbW1fc3RydWN0ICptbSkKLXsKLQlyZXR1cm4gLUVPUE5PVFNV UFA7Ci19Ci0KLXZvaWQgaG1tX21pcnJvcl91bnJlZ2lzdGVyKHN0cnVjdCBobW1fbWlycm9yICpt aXJyb3IpCi17Ci19Ci0KLWludCBobW1fcmFuZ2VfcmVnaXN0ZXIoc3RydWN0IGhtbV9yYW5nZSAq cmFuZ2UsIHN0cnVjdCBobW1fbWlycm9yICptaXJyb3IpCi17Ci0JcmV0dXJuIC1FT1BOT1RTVVBQ OwotfQotCi12b2lkIGhtbV9yYW5nZV91bnJlZ2lzdGVyKHN0cnVjdCBobW1fcmFuZ2UgKnJhbmdl KQotewotfQotCiBzdGF0aWMgaW5saW5lIGxvbmcgaG1tX3JhbmdlX2ZhdWx0KHN0cnVjdCBobW1f cmFuZ2UgKnJhbmdlLCB1bnNpZ25lZCBpbnQgZmxhZ3MpCiB7CiAJcmV0dXJuIC1FT1BOT1RTVVBQ OwpkaWZmIC0tZ2l0IGEvbW0vS2NvbmZpZyBiL21tL0tjb25maWcKaW5kZXggZDBiNTA0NmQ5YWVm ZmQuLmUzOGZmMWQ1OTY4ZGJmIDEwMDY0NAotLS0gYS9tbS9LY29uZmlnCisrKyBiL21tL0tjb25m aWcKQEAgLTY3NSw3ICs2NzUsNiBAQCBjb25maWcgREVWX1BBR0VNQVBfT1BTCiBjb25maWcgSE1N X01JUlJPUgogCWJvb2wKIAlkZXBlbmRzIG9uIE1NVQotCWRlcGVuZHMgb24gTU1VX05PVElGSUVS CiAKIGNvbmZpZyBERVZJQ0VfUFJJVkFURQogCWJvb2wgIlVuYWRkcmVzc2FibGUgZGV2aWNlIG1l bW9yeSAoR1BVIG1lbW9yeSwgLi4uKSIKZGlmZiAtLWdpdCBhL21tL2htbS5jIGIvbW0vaG1tLmMK aW5kZXggMjJhYzM1OTU3NzFmZWIuLjc1ZDE1YTgyMGUxODJlIDEwMDY0NAotLS0gYS9tbS9obW0u YworKysgYi9tbS9obW0uYwpAQCAtMjYsMTkzICsyNiw2IEBACiAjaW5jbHVkZSA8bGludXgvbW11 X25vdGlmaWVyLmg+CiAjaW5jbHVkZSA8bGludXgvbWVtb3J5X2hvdHBsdWcuaD4KIAotc3RhdGlj IHN0cnVjdCBtbXVfbm90aWZpZXIgKmhtbV9hbGxvY19ub3RpZmllcihzdHJ1Y3QgbW1fc3RydWN0 ICptbSkKLXsKLQlzdHJ1Y3QgaG1tICpobW07Ci0KLQlobW0gPSBremFsbG9jKHNpemVvZigqaG1t KSwgR0ZQX0tFUk5FTCk7Ci0JaWYgKCFobW0pCi0JCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOwot Ci0JaW5pdF93YWl0cXVldWVfaGVhZCgmaG1tLT53cSk7Ci0JSU5JVF9MSVNUX0hFQUQoJmhtbS0+ bWlycm9ycyk7Ci0JaW5pdF9yd3NlbSgmaG1tLT5taXJyb3JzX3NlbSk7Ci0JSU5JVF9MSVNUX0hF QUQoJmhtbS0+cmFuZ2VzKTsKLQlzcGluX2xvY2tfaW5pdCgmaG1tLT5yYW5nZXNfbG9jayk7Ci0J aG1tLT5ub3RpZmllcnMgPSAwOwotCXJldHVybiAmaG1tLT5tbXVfbm90aWZpZXI7Ci19Ci0KLXN0 YXRpYyB2b2lkIGhtbV9mcmVlX25vdGlmaWVyKHN0cnVjdCBtbXVfbm90aWZpZXIgKm1uKQotewot CXN0cnVjdCBobW0gKmhtbSA9IGNvbnRhaW5lcl9vZihtbiwgc3RydWN0IGhtbSwgbW11X25vdGlm aWVyKTsKLQotCVdBUk5fT04oIWxpc3RfZW1wdHkoJmhtbS0+cmFuZ2VzKSk7Ci0JV0FSTl9PTigh bGlzdF9lbXB0eSgmaG1tLT5taXJyb3JzKSk7Ci0Ja2ZyZWUoaG1tKTsKLX0KLQotc3RhdGljIHZv aWQgaG1tX3JlbGVhc2Uoc3RydWN0IG1tdV9ub3RpZmllciAqbW4sIHN0cnVjdCBtbV9zdHJ1Y3Qg Km1tKQotewotCXN0cnVjdCBobW0gKmhtbSA9IGNvbnRhaW5lcl9vZihtbiwgc3RydWN0IGhtbSwg bW11X25vdGlmaWVyKTsKLQlzdHJ1Y3QgaG1tX21pcnJvciAqbWlycm9yOwotCi0JLyoKLQkgKiBT aW5jZSBobW1fcmFuZ2VfcmVnaXN0ZXIoKSBob2xkcyB0aGUgbW1nZXQoKSBsb2NrIGhtbV9yZWxl YXNlKCkgaXMKLQkgKiBwcmV2ZW50ZWQgYXMgbG9uZyBhcyBhIHJhbmdlIGV4aXN0cy4KLQkgKi8K LQlXQVJOX09OKCFsaXN0X2VtcHR5X2NhcmVmdWwoJmhtbS0+cmFuZ2VzKSk7Ci0KLQlkb3duX3Jl YWQoJmhtbS0+bWlycm9yc19zZW0pOwotCWxpc3RfZm9yX2VhY2hfZW50cnkobWlycm9yLCAmaG1t LT5taXJyb3JzLCBsaXN0KSB7Ci0JCS8qCi0JCSAqIE5vdGU6IFRoZSBkcml2ZXIgaXMgbm90IGFs bG93ZWQgdG8gdHJpZ2dlcgotCQkgKiBobW1fbWlycm9yX3VucmVnaXN0ZXIoKSBmcm9tIHRoaXMg dGhyZWFkLgotCQkgKi8KLQkJaWYgKG1pcnJvci0+b3BzLT5yZWxlYXNlKQotCQkJbWlycm9yLT5v cHMtPnJlbGVhc2UobWlycm9yKTsKLQl9Ci0JdXBfcmVhZCgmaG1tLT5taXJyb3JzX3NlbSk7Ci19 Ci0KLXN0YXRpYyB2b2lkIG5vdGlmaWVyc19kZWNyZW1lbnQoc3RydWN0IGhtbSAqaG1tKQotewot CXVuc2lnbmVkIGxvbmcgZmxhZ3M7Ci0KLQlzcGluX2xvY2tfaXJxc2F2ZSgmaG1tLT5yYW5nZXNf bG9jaywgZmxhZ3MpOwotCWhtbS0+bm90aWZpZXJzLS07Ci0JaWYgKCFobW0tPm5vdGlmaWVycykg ewotCQlzdHJ1Y3QgaG1tX3JhbmdlICpyYW5nZTsKLQotCQlsaXN0X2Zvcl9lYWNoX2VudHJ5KHJh bmdlLCAmaG1tLT5yYW5nZXMsIGxpc3QpIHsKLQkJCWlmIChyYW5nZS0+dmFsaWQpCi0JCQkJY29u dGludWU7Ci0JCQlyYW5nZS0+dmFsaWQgPSB0cnVlOwotCQl9Ci0JCXdha2VfdXBfYWxsKCZobW0t PndxKTsKLQl9Ci0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmaG1tLT5yYW5nZXNfbG9jaywgZmxh Z3MpOwotfQotCi1zdGF0aWMgaW50IGhtbV9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KHN0cnVjdCBt bXVfbm90aWZpZXIgKm1uLAotCQkJY29uc3Qgc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAqbnJh bmdlKQotewotCXN0cnVjdCBobW0gKmhtbSA9IGNvbnRhaW5lcl9vZihtbiwgc3RydWN0IGhtbSwg bW11X25vdGlmaWVyKTsKLQlzdHJ1Y3QgaG1tX21pcnJvciAqbWlycm9yOwotCXN0cnVjdCBobW1f cmFuZ2UgKnJhbmdlOwotCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Ci0JaW50IHJldCA9IDA7Ci0KLQlz cGluX2xvY2tfaXJxc2F2ZSgmaG1tLT5yYW5nZXNfbG9jaywgZmxhZ3MpOwotCWhtbS0+bm90aWZp ZXJzKys7Ci0JbGlzdF9mb3JfZWFjaF9lbnRyeShyYW5nZSwgJmhtbS0+cmFuZ2VzLCBsaXN0KSB7 Ci0JCWlmIChucmFuZ2UtPmVuZCA8IHJhbmdlLT5zdGFydCB8fCBucmFuZ2UtPnN0YXJ0ID49IHJh bmdlLT5lbmQpCi0JCQljb250aW51ZTsKLQotCQlyYW5nZS0+dmFsaWQgPSBmYWxzZTsKLQl9Ci0J c3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmaG1tLT5yYW5nZXNfbG9jaywgZmxhZ3MpOwotCi0JaWYg KG1tdV9ub3RpZmllcl9yYW5nZV9ibG9ja2FibGUobnJhbmdlKSkKLQkJZG93bl9yZWFkKCZobW0t Pm1pcnJvcnNfc2VtKTsKLQllbHNlIGlmICghZG93bl9yZWFkX3RyeWxvY2soJmhtbS0+bWlycm9y c19zZW0pKSB7Ci0JCXJldCA9IC1FQUdBSU47Ci0JCWdvdG8gb3V0OwotCX0KLQotCWxpc3RfZm9y X2VhY2hfZW50cnkobWlycm9yLCAmaG1tLT5taXJyb3JzLCBsaXN0KSB7Ci0JCWludCByYzsKLQot CQlyYyA9IG1pcnJvci0+b3BzLT5zeW5jX2NwdV9kZXZpY2VfcGFnZXRhYmxlcyhtaXJyb3IsIG5y YW5nZSk7Ci0JCWlmIChyYykgewotCQkJaWYgKFdBUk5fT04obW11X25vdGlmaWVyX3JhbmdlX2Js b2NrYWJsZShucmFuZ2UpIHx8Ci0JCQkgICAgcmMgIT0gLUVBR0FJTikpCi0JCQkJY29udGludWU7 Ci0JCQlyZXQgPSAtRUFHQUlOOwotCQkJYnJlYWs7Ci0JCX0KLQl9Ci0JdXBfcmVhZCgmaG1tLT5t aXJyb3JzX3NlbSk7Ci0KLW91dDoKLQlpZiAocmV0KQotCQlub3RpZmllcnNfZGVjcmVtZW50KGht bSk7Ci0JcmV0dXJuIHJldDsKLX0KLQotc3RhdGljIHZvaWQgaG1tX2ludmFsaWRhdGVfcmFuZ2Vf ZW5kKHN0cnVjdCBtbXVfbm90aWZpZXIgKm1uLAotCQkJY29uc3Qgc3RydWN0IG1tdV9ub3RpZmll cl9yYW5nZSAqbnJhbmdlKQotewotCXN0cnVjdCBobW0gKmhtbSA9IGNvbnRhaW5lcl9vZihtbiwg c3RydWN0IGhtbSwgbW11X25vdGlmaWVyKTsKLQotCW5vdGlmaWVyc19kZWNyZW1lbnQoaG1tKTsK LX0KLQotc3RhdGljIGNvbnN0IHN0cnVjdCBtbXVfbm90aWZpZXJfb3BzIGhtbV9tbXVfbm90aWZp ZXJfb3BzID0gewotCS5yZWxlYXNlCQk9IGhtbV9yZWxlYXNlLAotCS5pbnZhbGlkYXRlX3Jhbmdl X3N0YXJ0CT0gaG1tX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnQsCi0JLmludmFsaWRhdGVfcmFuZ2Vf ZW5kCT0gaG1tX2ludmFsaWRhdGVfcmFuZ2VfZW5kLAotCS5hbGxvY19ub3RpZmllcgkJPSBobW1f YWxsb2Nfbm90aWZpZXIsCi0JLmZyZWVfbm90aWZpZXIJCT0gaG1tX2ZyZWVfbm90aWZpZXIsCi19 OwotCi0vKgotICogaG1tX21pcnJvcl9yZWdpc3RlcigpIC0gcmVnaXN0ZXIgYSBtaXJyb3IgYWdh aW5zdCBhbiBtbQotICoKLSAqIEBtaXJyb3I6IG5ldyBtaXJyb3Igc3RydWN0IHRvIHJlZ2lzdGVy Ci0gKiBAbW06IG1tIHRvIHJlZ2lzdGVyIGFnYWluc3QKLSAqIFJldHVybjogMCBvbiBzdWNjZXNz LCAtRU5PTUVNIGlmIG5vIG1lbW9yeSwgLUVJTlZBTCBpZiBpbnZhbGlkIGFyZ3VtZW50cwotICoK LSAqIFRvIHN0YXJ0IG1pcnJvcmluZyBhIHByb2Nlc3MgYWRkcmVzcyBzcGFjZSwgdGhlIGRldmlj ZSBkcml2ZXIgbXVzdCByZWdpc3RlcgotICogYW4gSE1NIG1pcnJvciBzdHJ1Y3QuCi0gKgotICog VGhlIGNhbGxlciBjYW5ub3QgdW5yZWdpc3RlciB0aGUgaG1tX21pcnJvciB3aGlsZSBhbnkgcmFu Z2VzIGFyZQotICogcmVnaXN0ZXJlZC4KLSAqCi0gKiBDYWxsZXJzIHVzaW5nIHRoaXMgZnVuY3Rp b24gbXVzdCBwdXQgYSBjYWxsIHRvIG1tdV9ub3RpZmllcl9zeW5jaHJvbml6ZSgpCi0gKiBpbiB0 aGVpciBtb2R1bGUgZXhpdCBmdW5jdGlvbnMuCi0gKi8KLWludCBobW1fbWlycm9yX3JlZ2lzdGVy KHN0cnVjdCBobW1fbWlycm9yICptaXJyb3IsIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQotewotCXN0 cnVjdCBtbXVfbm90aWZpZXIgKm1uOwotCi0JbG9ja2RlcF9hc3NlcnRfaGVsZF93cml0ZSgmbW0t Pm1tYXBfc2VtKTsKLQotCS8qIFNhbml0eSBjaGVjayAqLwotCWlmICghbW0gfHwgIW1pcnJvciB8 fCAhbWlycm9yLT5vcHMpCi0JCXJldHVybiAtRUlOVkFMOwotCi0JbW4gPSBtbXVfbm90aWZpZXJf Z2V0X2xvY2tlZCgmaG1tX21tdV9ub3RpZmllcl9vcHMsIG1tKTsKLQlpZiAoSVNfRVJSKG1uKSkK LQkJcmV0dXJuIFBUUl9FUlIobW4pOwotCW1pcnJvci0+aG1tID0gY29udGFpbmVyX29mKG1uLCBz dHJ1Y3QgaG1tLCBtbXVfbm90aWZpZXIpOwotCi0JZG93bl93cml0ZSgmbWlycm9yLT5obW0tPm1p cnJvcnNfc2VtKTsKLQlsaXN0X2FkZCgmbWlycm9yLT5saXN0LCAmbWlycm9yLT5obW0tPm1pcnJv cnMpOwotCXVwX3dyaXRlKCZtaXJyb3ItPmhtbS0+bWlycm9yc19zZW0pOwotCi0JcmV0dXJuIDA7 Ci19Ci1FWFBPUlRfU1lNQk9MKGhtbV9taXJyb3JfcmVnaXN0ZXIpOwotCi0vKgotICogaG1tX21p cnJvcl91bnJlZ2lzdGVyKCkgLSB1bnJlZ2lzdGVyIGEgbWlycm9yCi0gKgotICogQG1pcnJvcjog bWlycm9yIHN0cnVjdCB0byB1bnJlZ2lzdGVyCi0gKgotICogU3RvcCBtaXJyb3JpbmcgYSBwcm9j ZXNzIGFkZHJlc3Mgc3BhY2UsIGFuZCBjbGVhbnVwLgotICovCi12b2lkIGhtbV9taXJyb3JfdW5y ZWdpc3RlcihzdHJ1Y3QgaG1tX21pcnJvciAqbWlycm9yKQotewotCXN0cnVjdCBobW0gKmhtbSA9 IG1pcnJvci0+aG1tOwotCi0JZG93bl93cml0ZSgmaG1tLT5taXJyb3JzX3NlbSk7Ci0JbGlzdF9k ZWwoJm1pcnJvci0+bGlzdCk7Ci0JdXBfd3JpdGUoJmhtbS0+bWlycm9yc19zZW0pOwotCW1tdV9u b3RpZmllcl9wdXQoJmhtbS0+bW11X25vdGlmaWVyKTsKLX0KLUVYUE9SVF9TWU1CT0woaG1tX21p cnJvcl91bnJlZ2lzdGVyKTsKLQogc3RydWN0IGhtbV92bWFfd2FsayB7CiAJc3RydWN0IGhtbV9y YW5nZQkqcmFuZ2U7CiAJc3RydWN0IGRldl9wYWdlbWFwCSpwZ21hcDsKQEAgLTc3OSw4NyArNTky LDYgQEAgc3RhdGljIHZvaWQgaG1tX3BmbnNfY2xlYXIoc3RydWN0IGhtbV9yYW5nZSAqcmFuZ2Us CiAJCSpwZm5zID0gcmFuZ2UtPnZhbHVlc1tITU1fUEZOX05PTkVdOwogfQogCi0vKgotICogaG1t X3JhbmdlX3JlZ2lzdGVyKCkgLSBzdGFydCB0cmFja2luZyBjaGFuZ2UgdG8gQ1BVIHBhZ2UgdGFi bGUgb3ZlciBhIHJhbmdlCi0gKiBAcmFuZ2U6IHJhbmdlCi0gKiBAbW06IHRoZSBtbSBzdHJ1Y3Qg Zm9yIHRoZSByYW5nZSBvZiB2aXJ0dWFsIGFkZHJlc3MKLSAqCi0gKiBSZXR1cm46IDAgb24gc3Vj Y2VzcywgLUVGQVVMVCBpZiB0aGUgYWRkcmVzcyBzcGFjZSBpcyBubyBsb25nZXIgdmFsaWQKLSAq Ci0gKiBUcmFjayB1cGRhdGVzIHRvIHRoZSBDUFUgcGFnZSB0YWJsZSBzZWUgaW5jbHVkZS9saW51 eC9obW0uaAotICovCi1pbnQgaG1tX3JhbmdlX3JlZ2lzdGVyKHN0cnVjdCBobW1fcmFuZ2UgKnJh bmdlLCBzdHJ1Y3QgaG1tX21pcnJvciAqbWlycm9yKQotewotCXN0cnVjdCBobW0gKmhtbSA9IG1p cnJvci0+aG1tOwotCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Ci0KLQlyYW5nZS0+dmFsaWQgPSBmYWxz ZTsKLQlyYW5nZS0+aG1tID0gTlVMTDsKLQotCWlmICgocmFuZ2UtPnN0YXJ0ICYgKFBBR0VfU0la RSAtIDEpKSB8fCAocmFuZ2UtPmVuZCAmIChQQUdFX1NJWkUgLSAxKSkpCi0JCXJldHVybiAtRUlO VkFMOwotCWlmIChyYW5nZS0+c3RhcnQgPj0gcmFuZ2UtPmVuZCkKLQkJcmV0dXJuIC1FSU5WQUw7 Ci0KLQkvKiBQcmV2ZW50IGhtbV9yZWxlYXNlKCkgZnJvbSBydW5uaW5nIHdoaWxlIHRoZSByYW5n ZSBpcyB2YWxpZCAqLwotCWlmICghbW1nZXRfbm90X3plcm8oaG1tLT5tbXVfbm90aWZpZXIubW0p KQotCQlyZXR1cm4gLUVGQVVMVDsKLQotCS8qIEluaXRpYWxpemUgcmFuZ2UgdG8gdHJhY2sgQ1BV IHBhZ2UgdGFibGUgdXBkYXRlcy4gKi8KLQlzcGluX2xvY2tfaXJxc2F2ZSgmaG1tLT5yYW5nZXNf bG9jaywgZmxhZ3MpOwotCi0JcmFuZ2UtPmhtbSA9IGhtbTsKLQlsaXN0X2FkZCgmcmFuZ2UtPmxp c3QsICZobW0tPnJhbmdlcyk7Ci0KLQkvKgotCSAqIElmIHRoZXJlIGFyZSBhbnkgY29uY3VycmVu dCBub3RpZmllcnMgd2UgaGF2ZSB0byB3YWl0IGZvciB0aGVtIGZvcgotCSAqIHRoZSByYW5nZSB0 byBiZSB2YWxpZCAoc2VlIGhtbV9yYW5nZV93YWl0X3VudGlsX3ZhbGlkKCkpLgotCSAqLwotCWlm ICghaG1tLT5ub3RpZmllcnMpCi0JCXJhbmdlLT52YWxpZCA9IHRydWU7Ci0Jc3Bpbl91bmxvY2tf aXJxcmVzdG9yZSgmaG1tLT5yYW5nZXNfbG9jaywgZmxhZ3MpOwotCi0JcmV0dXJuIDA7Ci19Ci1F WFBPUlRfU1lNQk9MKGhtbV9yYW5nZV9yZWdpc3Rlcik7Ci0KLS8qCi0gKiBobW1fcmFuZ2VfdW5y ZWdpc3RlcigpIC0gc3RvcCB0cmFja2luZyBjaGFuZ2UgdG8gQ1BVIHBhZ2UgdGFibGUgb3ZlciBh IHJhbmdlCi0gKiBAcmFuZ2U6IHJhbmdlCi0gKgotICogUmFuZ2Ugc3RydWN0IGlzIHVzZWQgdG8g dHJhY2sgdXBkYXRlcyB0byB0aGUgQ1BVIHBhZ2UgdGFibGUgYWZ0ZXIgYSBjYWxsIHRvCi0gKiBo bW1fcmFuZ2VfcmVnaXN0ZXIoKS4gU2VlIGluY2x1ZGUvbGludXgvaG1tLmggZm9yIGhvdyB0byB1 c2UgaXQuCi0gKi8KLXZvaWQgaG1tX3JhbmdlX3VucmVnaXN0ZXIoc3RydWN0IGhtbV9yYW5nZSAq cmFuZ2UpCi17Ci0Jc3RydWN0IGhtbSAqaG1tID0gcmFuZ2UtPmhtbTsKLQl1bnNpZ25lZCBsb25n IGZsYWdzOwotCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJmhtbS0+cmFuZ2VzX2xvY2ssIGZsYWdzKTsK LQlsaXN0X2RlbF9pbml0KCZyYW5nZS0+bGlzdCk7Ci0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgm aG1tLT5yYW5nZXNfbG9jaywgZmxhZ3MpOwotCi0JLyogRHJvcCByZWZlcmVuY2UgdGFrZW4gYnkg aG1tX3JhbmdlX3JlZ2lzdGVyKCkgKi8KLQltbXB1dChobW0tPm1tdV9ub3RpZmllci5tbSk7Ci0K LQkvKgotCSAqIFRoZSByYW5nZSBpcyBub3cgaW52YWxpZCBhbmQgdGhlIHJlZiBvbiB0aGUgaG1t IGlzIGRyb3BwZWQsIHNvCi0JICogcG9pc29uIHRoZSBwb2ludGVyLiAgTGVhdmUgb3RoZXIgZmll bGRzIGluIHBsYWNlLCBmb3IgdGhlIGNhbGxlcidzCi0JICogdXNlLgotCSAqLwotCXJhbmdlLT52 YWxpZCA9IGZhbHNlOwotCW1lbXNldCgmcmFuZ2UtPmhtbSwgUE9JU09OX0lOVVNFLCBzaXplb2Yo cmFuZ2UtPmhtbSkpOwotfQotRVhQT1JUX1NZTUJPTChobW1fcmFuZ2VfdW5yZWdpc3Rlcik7Ci0K LXN0YXRpYyBib29sIG5lZWRzX3JldHJ5KHN0cnVjdCBobW1fcmFuZ2UgKnJhbmdlKQotewotCWlm IChyYW5nZS0+bm90aWZpZXIpCi0JCXJldHVybiBtbXVfcmFuZ2VfY2hlY2tfcmV0cnkocmFuZ2Ut Pm5vdGlmaWVyLAotCQkJCQkgICAgIHJhbmdlLT5ub3RpZmllcl9zZXEpOwotCXJldHVybiAhcmFu Z2UtPnZhbGlkOwotfQotCiBzdGF0aWMgY29uc3Qgc3RydWN0IG1tX3dhbGtfb3BzIGhtbV93YWxr X29wcyA9IHsKIAkucHVkX2VudHJ5CT0gaG1tX3ZtYV93YWxrX3B1ZCwKIAkucG1kX2VudHJ5CT0g aG1tX3ZtYV93YWxrX3BtZCwKQEAgLTkwMCwyMCArNjMyLDE1IEBAIGxvbmcgaG1tX3JhbmdlX2Zh dWx0KHN0cnVjdCBobW1fcmFuZ2UgKnJhbmdlLCB1bnNpZ25lZCBpbnQgZmxhZ3MpCiAJY29uc3Qg dW5zaWduZWQgbG9uZyBkZXZpY2Vfdm1hID0gVk1fSU8gfCBWTV9QRk5NQVAgfCBWTV9NSVhFRE1B UDsKIAl1bnNpZ25lZCBsb25nIHN0YXJ0ID0gcmFuZ2UtPnN0YXJ0LCBlbmQ7CiAJc3RydWN0IGht bV92bWFfd2FsayBobW1fdm1hX3dhbGs7Ci0Jc3RydWN0IG1tX3N0cnVjdCAqbW07CisJc3RydWN0 IG1tX3N0cnVjdCAqbW0gPSByYW5nZS0+bm90aWZpZXItPm1tOwogCXN0cnVjdCB2bV9hcmVhX3N0 cnVjdCAqdm1hOwogCWludCByZXQ7CiAKLQlpZiAocmFuZ2UtPm5vdGlmaWVyKQotCQltbSA9IHJh bmdlLT5ub3RpZmllci0+bW07Ci0JZWxzZQotCQltbSA9IHJhbmdlLT5obW0tPm1tdV9ub3RpZmll ci5tbTsKLQogCWxvY2tkZXBfYXNzZXJ0X2hlbGQoJm1tLT5tbWFwX3NlbSk7CiAKIAlkbyB7CiAJ CS8qIElmIHJhbmdlIGlzIG5vIGxvbmdlciB2YWxpZCBmb3JjZSByZXRyeS4gKi8KLQkJaWYgKG5l ZWRzX3JldHJ5KHJhbmdlKSkKKwkJaWYgKG1tdV9yYW5nZV9jaGVja19yZXRyeShyYW5nZS0+bm90 aWZpZXIsIHJhbmdlLT5ub3RpZmllcl9zZXEpKQogCQkJcmV0dXJuIC1FQlVTWTsKIAogCQl2bWEg PSBmaW5kX3ZtYShtbSwgc3RhcnQpOwpAQCAtOTQ2LDcgKzY3Myw5IEBAIGxvbmcgaG1tX3Jhbmdl X2ZhdWx0KHN0cnVjdCBobW1fcmFuZ2UgKnJhbmdlLCB1bnNpZ25lZCBpbnQgZmxhZ3MpCiAJCQlz dGFydCA9IGhtbV92bWFfd2Fsay5sYXN0OwogCiAJCQkvKiBLZWVwIHRyeWluZyB3aGlsZSB0aGUg cmFuZ2UgaXMgdmFsaWQuICovCi0JCX0gd2hpbGUgKHJldCA9PSAtRUJVU1kgJiYgIW5lZWRzX3Jl dHJ5KHJhbmdlKSk7CisJCX0gd2hpbGUgKHJldCA9PSAtRUJVU1kgJiYKKwkJCSAhbW11X3Jhbmdl X2NoZWNrX3JldHJ5KHJhbmdlLT5ub3RpZmllciwKKwkJCQkJCXJhbmdlLT5ub3RpZmllcl9zZXEp KTsKIAogCQlpZiAocmV0KSB7CiAJCQl1bnNpZ25lZCBsb25nIGk7CkBAIC0xMDA0LDcgKzczMyw4 IEBAIGxvbmcgaG1tX3JhbmdlX2RtYV9tYXAoc3RydWN0IGhtbV9yYW5nZSAqcmFuZ2UsIHN0cnVj dCBkZXZpY2UgKmRldmljZSwKIAkJCWNvbnRpbnVlOwogCiAJCS8qIENoZWNrIGlmIHJhbmdlIGlz IGJlaW5nIGludmFsaWRhdGVkICovCi0JCWlmIChuZWVkc19yZXRyeShyYW5nZSkpIHsKKwkJaWYg KG1tdV9yYW5nZV9jaGVja19yZXRyeShyYW5nZS0+bm90aWZpZXIsCisJCQkJCSAgcmFuZ2UtPm5v dGlmaWVyX3NlcSkpIHsKIAkJCXJldCA9IC1FQlVTWTsKIAkJCWdvdG8gdW5tYXA7CiAJCX0KLS0g CjIuMjMuMAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K YW1kLWdmeCBtYWlsaW5nIGxpc3QKYW1kLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6 Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9hbWQtZ2Z4