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 A9002CA9EC6 for ; Mon, 28 Oct 2019 20:10:52 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 6FE03208C0 for ; Mon, 28 Oct 2019 20:10:52 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=ziepe.ca header.i=@ziepe.ca header.b="ZMZ20vhD" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1730484AbfJ1UKv (ORCPT ); Mon, 28 Oct 2019 16:10:51 -0400 Received: from mail-qk1-f195.google.com ([209.85.222.195]:43522 "EHLO mail-qk1-f195.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726483AbfJ1UKv (ORCPT ); Mon, 28 Oct 2019 16:10:51 -0400 Received: by mail-qk1-f195.google.com with SMTP id a194so9752530qkg.10 for ; Mon, 28 Oct 2019 13:10:50 -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=kWAFXaairmju5dUouyI0fIFpVoVh+rRI3GJkG/c3jbo=; b=ZMZ20vhDqRatgd/VeNs+gakMuIFZXaMsb6XQWoUK9HXLD+PHirdDumPc851+WT2Hyf C1Iv1wiPN6IlkT/5OzHp2qTA3MHXJcFx6P54sX18cmGOfENyUr/3lvF7WB/e9idjitHy lGg8W7hcfUwYhCtTo+P5QwNkSGSXWLHrmB7UiWpkznO/5PpvIjO4rkGK5oPJe284j39Z 0SrDdsATeTt0aysE+Vjhm+ODlfdb0SYunqwjoByjas1/pFQCfKFMrcffBKQilclNwoJN Kw57TFwiQGNXYLPWr/vN3hajssQSFf3odyyUW2L2YFJ1wLFryfEwL6Mj/wjl8DvBS7u6 6HmA== 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=kWAFXaairmju5dUouyI0fIFpVoVh+rRI3GJkG/c3jbo=; b=G6nx7APOqWKjR2/ihX3KEZ495kAqHggmLvlzaCKcAV9uYxvF/CJ5+/9AeZJ12IaY6C vOLk+OxagXcnViYJW/6AwkcIXsqr0DqhIzwwLu/towRjjHv/pEsOQ1j/4bClrhjzX3nG vBJg8ThEzGOpP9hJoQs3oKxmWGI1lvxQvkx3bvNSka02sbMQefrzqX/RdDdVTtunM5yi eyWsgqijyfMwLF4RCZmjKGih0TMOu8cNY9VtqxWtU5z3ssJ/a8rx6uyA5qjTRY64hJLp xeNfm8QAkDnn10WEvyUciKC40XQsk8S5dzGFar75xX3FhRpAluixfsLnrQ6w9AwgNupn LmsQ== X-Gm-Message-State: APjAAAVEhxXe/M2JOpC+IX2UEoPWDClol7u6iyua/ad0Z/oXF3T/nLuJ g3lRkKUKZTEJUSF1IeGqRBRMBw== X-Google-Smtp-Source: APXvYqyexUtgyT46O4Xj8Sx5B6Zyp9sP915KnVYaCPjwqJLiYtfebmqJR+ZAbE7J5Hww5Pxy2DBZEA== X-Received: by 2002:a05:620a:13f0:: with SMTP id h16mr17732993qkl.310.1572293449993; Mon, 28 Oct 2019 13:10:49 -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 o1sm7821379qtb.82.2019.10.28.13.10.44 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Mon, 28 Oct 2019 13:10:48 -0700 (PDT) Received: from jgg by mlx.ziepe.ca with local (Exim 4.90_1) (envelope-from ) id 1iPBLf-0001hL-Mi; 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 Subject: [PATCH v2 14/15] drm/amdgpu: Use mmu_range_notifier instead of hmm_mirror Date: Mon, 28 Oct 2019 17:10:31 -0300 Message-Id: <20191028201032.6352-15-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 Convert the collision-retry lock around hmm_range_fault to use the one now provided by the mmu_range notifier. Although this driver does not seem to use the collision retry lock that hmm provides correctly, it can still be converted over to use the mmu_range_notifier api instead of hmm_mirror without too much trouble. This also deletes another place where a driver is associating additional data (struct amdgpu_mn) with a mmu_struct. Cc: Alex Deucher Cc: Christian König Cc: David (ChunMing) Zhou Cc: amd-gfx@lists.freedesktop.org Signed-off-by: Jason Gunthorpe --- .../gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c | 4 + drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c | 14 +- drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c | 148 ++---------------- drivers/gpu/drm/amd/amdgpu/amdgpu_mn.h | 49 ------ drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c | 76 ++++----- 5 files changed, 66 insertions(+), 225 deletions(-) diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c index 47700302a08b7f..1bcedb9b477dce 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c @@ -1738,6 +1738,10 @@ static int update_invalid_user_pages(struct amdkfd_process_info *process_info, return ret; } + /* + * FIXME: Cannot ignore the return code, must hold + * notifier_lock + */ amdgpu_ttm_tt_get_user_pages_done(bo->tbo.ttm); /* Mark the BO as valid unless it was invalidated diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c index 2e53feed40e230..76771f5f0b60ab 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c @@ -607,8 +607,6 @@ static int amdgpu_cs_parser_bos(struct amdgpu_cs_parser *p, e->tv.num_shared = 2; amdgpu_bo_list_get_list(p->bo_list, &p->validated); - if (p->bo_list->first_userptr != p->bo_list->num_entries) - p->mn = amdgpu_mn_get(p->adev, AMDGPU_MN_TYPE_GFX); INIT_LIST_HEAD(&duplicates); amdgpu_vm_get_pd_bo(&fpriv->vm, &p->validated, &p->vm_pd); @@ -1291,11 +1289,11 @@ static int amdgpu_cs_submit(struct amdgpu_cs_parser *p, if (r) goto error_unlock; - /* No memory allocation is allowed while holding the mn lock. - * p->mn is hold until amdgpu_cs_submit is finished and fence is added - * to BOs. + /* No memory allocation is allowed while holding the notifier lock. + * The lock is held until amdgpu_cs_submit is finished and fence is + * added to BOs. */ - amdgpu_mn_lock(p->mn); + mutex_lock(&p->adev->notifier_lock); /* If userptr are invalidated after amdgpu_cs_parser_bos(), return * -EAGAIN, drmIoctl in libdrm will restart the amdgpu_cs_ioctl. @@ -1338,13 +1336,13 @@ static int amdgpu_cs_submit(struct amdgpu_cs_parser *p, amdgpu_vm_move_to_lru_tail(p->adev, &fpriv->vm); ttm_eu_fence_buffer_objects(&p->ticket, &p->validated, p->fence); - amdgpu_mn_unlock(p->mn); + mutex_unlock(&p->adev->notifier_lock); return 0; error_abort: drm_sched_job_cleanup(&job->base); - amdgpu_mn_unlock(p->mn); + mutex_unlock(&p->adev->notifier_lock); error_unlock: amdgpu_job_free(job); diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c index 4ffd7b90f4d907..cb718a064eb491 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c @@ -50,28 +50,6 @@ #include "amdgpu.h" #include "amdgpu_amdkfd.h" -/** - * amdgpu_mn_lock - take the write side lock for this notifier - * - * @mn: our notifier - */ -void amdgpu_mn_lock(struct amdgpu_mn *mn) -{ - if (mn) - down_write(&mn->lock); -} - -/** - * amdgpu_mn_unlock - drop the write side lock for this notifier - * - * @mn: our notifier - */ -void amdgpu_mn_unlock(struct amdgpu_mn *mn) -{ - if (mn) - up_write(&mn->lock); -} - /** * amdgpu_mn_invalidate_gfx - callback to notify about mm change * @@ -82,12 +60,19 @@ void amdgpu_mn_unlock(struct amdgpu_mn *mn) * potentially dirty. */ static bool amdgpu_mn_invalidate_gfx(struct mmu_range_notifier *mrn, - const struct mmu_notifier_range *range) + const struct mmu_notifier_range *range, + unsigned long cur_seq) { struct amdgpu_bo *bo = container_of(mrn, struct amdgpu_bo, notifier); struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev); long r; + /* + * FIXME: Must hold some lock shared with + * amdgpu_ttm_tt_get_user_pages_done() + */ + mmu_range_set_seq(mrn, cur_seq); + /* FIXME: Is this necessary? */ if (!amdgpu_ttm_tt_affect_userptr(bo->tbo.ttm, range->start, range->end)) @@ -119,11 +104,18 @@ static const struct mmu_range_notifier_ops amdgpu_mn_gfx_ops = { * evicting all user-mode queues of the process. */ static bool amdgpu_mn_invalidate_hsa(struct mmu_range_notifier *mrn, - const struct mmu_notifier_range *range) + const struct mmu_notifier_range *range, + unsigned long cur_seq) { struct amdgpu_bo *bo = container_of(mrn, struct amdgpu_bo, notifier); struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev); + /* + * FIXME: Must hold some lock shared with + * amdgpu_ttm_tt_get_user_pages_done() + */ + mmu_range_set_seq(mrn, cur_seq); + /* FIXME: Is this necessary? */ if (!amdgpu_ttm_tt_affect_userptr(bo->tbo.ttm, range->start, range->end)) @@ -143,92 +135,6 @@ static const struct mmu_range_notifier_ops amdgpu_mn_hsa_ops = { .invalidate = amdgpu_mn_invalidate_hsa, }; -static int amdgpu_mn_sync_pagetables(struct hmm_mirror *mirror, - const struct mmu_notifier_range *update) -{ - struct amdgpu_mn *amn = container_of(mirror, struct amdgpu_mn, mirror); - - if (!mmu_notifier_range_blockable(update)) - return false; - - down_read(&amn->lock); - up_read(&amn->lock); - return 0; -} - -/* Low bits of any reasonable mm pointer will be unused due to struct - * alignment. Use these bits to make a unique key from the mm pointer - * and notifier type. - */ -#define AMDGPU_MN_KEY(mm, type) ((unsigned long)(mm) + (type)) - -static struct hmm_mirror_ops amdgpu_hmm_mirror_ops[] = { - [AMDGPU_MN_TYPE_GFX] = { - .sync_cpu_device_pagetables = amdgpu_mn_sync_pagetables, - }, - [AMDGPU_MN_TYPE_HSA] = { - .sync_cpu_device_pagetables = amdgpu_mn_sync_pagetables, - }, -}; - -/** - * amdgpu_mn_get - create HMM mirror context - * - * @adev: amdgpu device pointer - * @type: type of MMU notifier context - * - * Creates a HMM mirror context for current->mm. - */ -struct amdgpu_mn *amdgpu_mn_get(struct amdgpu_device *adev, - enum amdgpu_mn_type type) -{ - struct mm_struct *mm = current->mm; - struct amdgpu_mn *amn; - unsigned long key = AMDGPU_MN_KEY(mm, type); - int r; - - mutex_lock(&adev->mn_lock); - if (down_write_killable(&mm->mmap_sem)) { - mutex_unlock(&adev->mn_lock); - return ERR_PTR(-EINTR); - } - - hash_for_each_possible(adev->mn_hash, amn, node, key) - if (AMDGPU_MN_KEY(amn->mirror.hmm->mmu_notifier.mm, - amn->type) == key) - goto release_locks; - - amn = kzalloc(sizeof(*amn), GFP_KERNEL); - if (!amn) { - amn = ERR_PTR(-ENOMEM); - goto release_locks; - } - - amn->adev = adev; - init_rwsem(&amn->lock); - amn->type = type; - - amn->mirror.ops = &amdgpu_hmm_mirror_ops[type]; - r = hmm_mirror_register(&amn->mirror, mm); - if (r) - goto free_amn; - - hash_add(adev->mn_hash, &amn->node, AMDGPU_MN_KEY(mm, type)); - -release_locks: - up_write(&mm->mmap_sem); - mutex_unlock(&adev->mn_lock); - - return amn; - -free_amn: - up_write(&mm->mmap_sem); - mutex_unlock(&adev->mn_lock); - kfree(amn); - - return ERR_PTR(r); -} - /** * amdgpu_mn_register - register a BO for notifier updates * @@ -263,25 +169,3 @@ void amdgpu_mn_unregister(struct amdgpu_bo *bo) mmu_range_notifier_remove(&bo->notifier); bo->notifier.mm = NULL; } - -/* flags used by HMM internal, not related to CPU/GPU PTE flags */ -static const uint64_t hmm_range_flags[HMM_PFN_FLAG_MAX] = { - (1 << 0), /* HMM_PFN_VALID */ - (1 << 1), /* HMM_PFN_WRITE */ - 0 /* HMM_PFN_DEVICE_PRIVATE */ -}; - -static const uint64_t hmm_range_values[HMM_PFN_VALUE_MAX] = { - 0xfffffffffffffffeUL, /* HMM_PFN_ERROR */ - 0, /* HMM_PFN_NONE */ - 0xfffffffffffffffcUL /* HMM_PFN_SPECIAL */ -}; - -void amdgpu_hmm_init_range(struct hmm_range *range) -{ - if (range) { - range->flags = hmm_range_flags; - range->values = hmm_range_values; - range->pfn_shift = PAGE_SHIFT; - } -} diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.h index d73ab2947b22b2..a292238f75ebae 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.h +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.h @@ -30,59 +30,10 @@ #include #include -enum amdgpu_mn_type { - AMDGPU_MN_TYPE_GFX, - AMDGPU_MN_TYPE_HSA, -}; - -/** - * struct amdgpu_mn - * - * @adev: amdgpu device pointer - * @type: type of MMU notifier - * @work: destruction work item - * @node: hash table node to find structure by adev and mn - * @lock: rw semaphore protecting the notifier nodes - * @mirror: HMM mirror function support - * - * Data for each amdgpu device and process address space. - */ -struct amdgpu_mn { - /* constant after initialisation */ - struct amdgpu_device *adev; - enum amdgpu_mn_type type; - - /* only used on destruction */ - struct work_struct work; - - /* protected by adev->mn_lock */ - struct hlist_node node; - - /* objects protected by lock */ - struct rw_semaphore lock; - -#ifdef CONFIG_HMM_MIRROR - /* HMM mirror */ - struct hmm_mirror mirror; -#endif -}; - #if defined(CONFIG_HMM_MIRROR) -void amdgpu_mn_lock(struct amdgpu_mn *mn); -void amdgpu_mn_unlock(struct amdgpu_mn *mn); -struct amdgpu_mn *amdgpu_mn_get(struct amdgpu_device *adev, - enum amdgpu_mn_type type); int amdgpu_mn_register(struct amdgpu_bo *bo, unsigned long addr); void amdgpu_mn_unregister(struct amdgpu_bo *bo); -void amdgpu_hmm_init_range(struct hmm_range *range); #else -static inline void amdgpu_mn_lock(struct amdgpu_mn *mn) {} -static inline void amdgpu_mn_unlock(struct amdgpu_mn *mn) {} -static inline struct amdgpu_mn *amdgpu_mn_get(struct amdgpu_device *adev, - enum amdgpu_mn_type type) -{ - return NULL; -} static inline int amdgpu_mn_register(struct amdgpu_bo *bo, unsigned long addr) { DRM_WARN_ONCE("HMM_MIRROR kernel config option is not enabled, " diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c index c0e41f1f0c2365..65d9824b54f2a9 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c @@ -773,6 +773,20 @@ struct amdgpu_ttm_tt { #endif }; +#ifdef CONFIG_DRM_AMDGPU_USERPTR +/* flags used by HMM internal, not related to CPU/GPU PTE flags */ +static const uint64_t hmm_range_flags[HMM_PFN_FLAG_MAX] = { + (1 << 0), /* HMM_PFN_VALID */ + (1 << 1), /* HMM_PFN_WRITE */ + 0 /* HMM_PFN_DEVICE_PRIVATE */ +}; + +static const uint64_t hmm_range_values[HMM_PFN_VALUE_MAX] = { + 0xfffffffffffffffeUL, /* HMM_PFN_ERROR */ + 0, /* HMM_PFN_NONE */ + 0xfffffffffffffffcUL /* HMM_PFN_SPECIAL */ +}; + /** * amdgpu_ttm_tt_get_user_pages - get device accessible pages that back user * memory and start HMM tracking CPU page table update @@ -780,29 +794,27 @@ struct amdgpu_ttm_tt { * Calling function must call amdgpu_ttm_tt_userptr_range_done() once and only * once afterwards to stop HMM tracking */ -#if IS_ENABLED(CONFIG_DRM_AMDGPU_USERPTR) - -#define MAX_RETRY_HMM_RANGE_FAULT 16 - int amdgpu_ttm_tt_get_user_pages(struct amdgpu_bo *bo, struct page **pages) { - struct hmm_mirror *mirror = bo->mn ? &bo->mn->mirror : NULL; struct ttm_tt *ttm = bo->tbo.ttm; struct amdgpu_ttm_tt *gtt = (void *)ttm; struct mm_struct *mm; + struct hmm_range *range; unsigned long start = gtt->userptr; struct vm_area_struct *vma; - struct hmm_range *range; unsigned long i; - uint64_t *pfns; int r = 0; - if (unlikely(!mirror)) { - DRM_DEBUG_DRIVER("Failed to get hmm_mirror\n"); + mm = bo->notifier.mm; + if (unlikely(!mm)) { + DRM_DEBUG_DRIVER("BO is not registered?\n"); return -EFAULT; } - mm = mirror->hmm->mmu_notifier.mm; + /* Another get_user_pages is running at the same time?? */ + if (WARN_ON(gtt->range)) + return -EFAULT; + if (!mmget_not_zero(mm)) /* Happens during process shutdown */ return -ESRCH; @@ -811,30 +823,24 @@ int amdgpu_ttm_tt_get_user_pages(struct amdgpu_bo *bo, struct page **pages) r = -ENOMEM; goto out; } + range->notifier = &bo->notifier; + range->flags = hmm_range_flags; + range->values = hmm_range_values; + range->pfn_shift = PAGE_SHIFT; + range->start = bo->notifier.interval_tree.start; + range->end = bo->notifier.interval_tree.last + 1; + range->default_flags = hmm_range_flags[HMM_PFN_VALID]; + if (!amdgpu_ttm_tt_is_readonly(ttm)) + range->default_flags |= range->flags[HMM_PFN_WRITE]; - pfns = kvmalloc_array(ttm->num_pages, sizeof(*pfns), GFP_KERNEL); - if (unlikely(!pfns)) { + range->pfns = kvmalloc_array(ttm->num_pages, sizeof(*range->pfns), + GFP_KERNEL); + if (unlikely(!range->pfns)) { r = -ENOMEM; goto out_free_ranges; } - amdgpu_hmm_init_range(range); - range->default_flags = range->flags[HMM_PFN_VALID]; - range->default_flags |= amdgpu_ttm_tt_is_readonly(ttm) ? - 0 : range->flags[HMM_PFN_WRITE]; - range->pfn_flags_mask = 0; - range->pfns = pfns; - range->start = start; - range->end = start + ttm->num_pages * PAGE_SIZE; - - 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, HMM_RANGE_DEFAULT_TIMEOUT); + range->notifier_seq = mmu_range_read_begin(&bo->notifier); down_read(&mm->mmap_sem); vma = find_vma(mm, start); @@ -855,10 +861,10 @@ int amdgpu_ttm_tt_get_user_pages(struct amdgpu_bo *bo, struct page **pages) goto out_free_pfns; for (i = 0; i < ttm->num_pages; i++) { - pages[i] = hmm_device_entry_to_page(range, pfns[i]); + pages[i] = hmm_device_entry_to_page(range, range->pfns[i]); if (unlikely(!pages[i])) { pr_err("Page fault failed for pfn[%lu] = 0x%llx\n", - i, pfns[i]); + i, range->pfns[i]); r = -ENOMEM; goto out_free_pfns; @@ -873,8 +879,7 @@ int amdgpu_ttm_tt_get_user_pages(struct amdgpu_bo *bo, struct page **pages) out_unlock: up_read(&mm->mmap_sem); out_free_pfns: - hmm_range_unregister(range); - kvfree(pfns); + kvfree(range->pfns); out_free_ranges: kfree(range); out: @@ -903,9 +908,8 @@ bool amdgpu_ttm_tt_get_user_pages_done(struct ttm_tt *ttm) "No user pages to check\n"); if (gtt->range) { - r = hmm_range_valid(gtt->range); - hmm_range_unregister(gtt->range); - + r = mmu_range_read_retry(gtt->range->notifier, + gtt->range->notifier_seq); kvfree(gtt->range->pfns); kfree(gtt->range); gtt->range = NULL; -- 2.23.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jason Gunthorpe Subject: [PATCH v2 14/15] drm/amdgpu: Use mmu_range_notifier instead of hmm_mirror Date: Mon, 28 Oct 2019 17:10:31 -0300 Message-ID: <20191028201032.6352-15-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 , Oleksandr Andrushchenko , linux-rdma@vger.kernel.org, nouveau@lists.freedesktop.org, Dennis Dalessandro , amd-gfx@lists.freedesktop.org, 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 RnJvbTogSmFzb24gR3VudGhvcnBlIDxqZ2dAbWVsbGFub3guY29tPgoKQ29udmVydCB0aGUgY29s bGlzaW9uLXJldHJ5IGxvY2sgYXJvdW5kIGhtbV9yYW5nZV9mYXVsdCB0byB1c2UgdGhlIG9uZSBu b3cKcHJvdmlkZWQgYnkgdGhlIG1tdV9yYW5nZSBub3RpZmllci4KCkFsdGhvdWdoIHRoaXMgZHJp dmVyIGRvZXMgbm90IHNlZW0gdG8gdXNlIHRoZSBjb2xsaXNpb24gcmV0cnkgbG9jayB0aGF0Cmht bSBwcm92aWRlcyBjb3JyZWN0bHksIGl0IGNhbiBzdGlsbCBiZSBjb252ZXJ0ZWQgb3ZlciB0byB1 c2UgdGhlCm1tdV9yYW5nZV9ub3RpZmllciBhcGkgaW5zdGVhZCBvZiBobW1fbWlycm9yIHdpdGhv dXQgdG9vIG11Y2ggdHJvdWJsZS4KClRoaXMgYWxzbyBkZWxldGVzIGFub3RoZXIgcGxhY2Ugd2hl cmUgYSBkcml2ZXIgaXMgYXNzb2NpYXRpbmcgYWRkaXRpb25hbApkYXRhIChzdHJ1Y3QgYW1kZ3B1 X21uKSB3aXRoIGEgbW11X3N0cnVjdC4KCkNjOiBBbGV4IERldWNoZXIgPGFsZXhhbmRlci5kZXVj aGVyQGFtZC5jb20+CkNjOiBDaHJpc3RpYW4gS8O2bmlnIDxjaHJpc3RpYW4ua29lbmlnQGFtZC5j b20+CkNjOiBEYXZpZCAoQ2h1bk1pbmcpIFpob3UgPERhdmlkMS5aaG91QGFtZC5jb20+CkNjOiBh bWQtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpTaWduZWQtb2ZmLWJ5OiBKYXNvbiBHdW50aG9y cGUgPGpnZ0BtZWxsYW5veC5jb20+Ci0tLQogLi4uL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVf YW1ka2ZkX2dwdXZtLmMgIHwgICA0ICsKIGRyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdw dV9jcy5jICAgICAgICB8ICAxNCArLQogZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1 X21uLmMgICAgICAgIHwgMTQ4ICsrLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy9ncHUvZHJtL2Ft ZC9hbWRncHUvYW1kZ3B1X21uLmggICAgICAgIHwgIDQ5IC0tLS0tLQogZHJpdmVycy9ncHUvZHJt L2FtZC9hbWRncHUvYW1kZ3B1X3R0bS5jICAgICAgIHwgIDc2ICsrKystLS0tLQogNSBmaWxlcyBj aGFuZ2VkLCA2NiBpbnNlcnRpb25zKCspLCAyMjUgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2FtZGtmZF9ncHV2bS5jIGIvZHJpdmVy cy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2FtZGtmZF9ncHV2bS5jCmluZGV4IDQ3NzAwMzAy YTA4YjdmLi4xYmNlZGI5YjQ3N2RjZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FtZC9h bWRncHUvYW1kZ3B1X2FtZGtmZF9ncHV2bS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1k Z3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYwpAQCAtMTczOCw2ICsxNzM4LDEwIEBAIHN0YXRpYyBp bnQgdXBkYXRlX2ludmFsaWRfdXNlcl9wYWdlcyhzdHJ1Y3QgYW1ka2ZkX3Byb2Nlc3NfaW5mbyAq cHJvY2Vzc19pbmZvLAogCQkJcmV0dXJuIHJldDsKIAkJfQogCisJCS8qCisJCSAqIEZJWE1FOiBD YW5ub3QgaWdub3JlIHRoZSByZXR1cm4gY29kZSwgbXVzdCBob2xkCisJCSAqIG5vdGlmaWVyX2xv Y2sKKwkJICovCiAJCWFtZGdwdV90dG1fdHRfZ2V0X3VzZXJfcGFnZXNfZG9uZShiby0+dGJvLnR0 bSk7CiAKIAkJLyogTWFyayB0aGUgQk8gYXMgdmFsaWQgdW5sZXNzIGl0IHdhcyBpbnZhbGlkYXRl ZApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2NzLmMgYi9k cml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfY3MuYwppbmRleCAyZTUzZmVlZDQwZTIz MC4uNzY3NzFmNWYwYjYwYWIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1 L2FtZGdwdV9jcy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9jcy5j CkBAIC02MDcsOCArNjA3LDYgQEAgc3RhdGljIGludCBhbWRncHVfY3NfcGFyc2VyX2JvcyhzdHJ1 Y3QgYW1kZ3B1X2NzX3BhcnNlciAqcCwKIAkJZS0+dHYubnVtX3NoYXJlZCA9IDI7CiAKIAlhbWRn cHVfYm9fbGlzdF9nZXRfbGlzdChwLT5ib19saXN0LCAmcC0+dmFsaWRhdGVkKTsKLQlpZiAocC0+ Ym9fbGlzdC0+Zmlyc3RfdXNlcnB0ciAhPSBwLT5ib19saXN0LT5udW1fZW50cmllcykKLQkJcC0+ bW4gPSBhbWRncHVfbW5fZ2V0KHAtPmFkZXYsIEFNREdQVV9NTl9UWVBFX0dGWCk7CiAKIAlJTklU X0xJU1RfSEVBRCgmZHVwbGljYXRlcyk7CiAJYW1kZ3B1X3ZtX2dldF9wZF9ibygmZnByaXYtPnZt LCAmcC0+dmFsaWRhdGVkLCAmcC0+dm1fcGQpOwpAQCAtMTI5MSwxMSArMTI4OSwxMSBAQCBzdGF0 aWMgaW50IGFtZGdwdV9jc19zdWJtaXQoc3RydWN0IGFtZGdwdV9jc19wYXJzZXIgKnAsCiAJaWYg KHIpCiAJCWdvdG8gZXJyb3JfdW5sb2NrOwogCi0JLyogTm8gbWVtb3J5IGFsbG9jYXRpb24gaXMg YWxsb3dlZCB3aGlsZSBob2xkaW5nIHRoZSBtbiBsb2NrLgotCSAqIHAtPm1uIGlzIGhvbGQgdW50 aWwgYW1kZ3B1X2NzX3N1Ym1pdCBpcyBmaW5pc2hlZCBhbmQgZmVuY2UgaXMgYWRkZWQKLQkgKiB0 byBCT3MuCisJLyogTm8gbWVtb3J5IGFsbG9jYXRpb24gaXMgYWxsb3dlZCB3aGlsZSBob2xkaW5n IHRoZSBub3RpZmllciBsb2NrLgorCSAqIFRoZSBsb2NrIGlzIGhlbGQgdW50aWwgYW1kZ3B1X2Nz X3N1Ym1pdCBpcyBmaW5pc2hlZCBhbmQgZmVuY2UgaXMKKwkgKiBhZGRlZCB0byBCT3MuCiAJICov Ci0JYW1kZ3B1X21uX2xvY2socC0+bW4pOworCW11dGV4X2xvY2soJnAtPmFkZXYtPm5vdGlmaWVy X2xvY2spOwogCiAJLyogSWYgdXNlcnB0ciBhcmUgaW52YWxpZGF0ZWQgYWZ0ZXIgYW1kZ3B1X2Nz X3BhcnNlcl9ib3MoKSwgcmV0dXJuCiAJICogLUVBR0FJTiwgZHJtSW9jdGwgaW4gbGliZHJtIHdp bGwgcmVzdGFydCB0aGUgYW1kZ3B1X2NzX2lvY3RsLgpAQCAtMTMzOCwxMyArMTMzNiwxMyBAQCBz dGF0aWMgaW50IGFtZGdwdV9jc19zdWJtaXQoc3RydWN0IGFtZGdwdV9jc19wYXJzZXIgKnAsCiAJ YW1kZ3B1X3ZtX21vdmVfdG9fbHJ1X3RhaWwocC0+YWRldiwgJmZwcml2LT52bSk7CiAKIAl0dG1f ZXVfZmVuY2VfYnVmZmVyX29iamVjdHMoJnAtPnRpY2tldCwgJnAtPnZhbGlkYXRlZCwgcC0+ZmVu Y2UpOwotCWFtZGdwdV9tbl91bmxvY2socC0+bW4pOworCW11dGV4X3VubG9jaygmcC0+YWRldi0+ bm90aWZpZXJfbG9jayk7CiAKIAlyZXR1cm4gMDsKIAogZXJyb3JfYWJvcnQ6CiAJZHJtX3NjaGVk X2pvYl9jbGVhbnVwKCZqb2ItPmJhc2UpOwotCWFtZGdwdV9tbl91bmxvY2socC0+bW4pOworCW11 dGV4X3VubG9jaygmcC0+YWRldi0+bm90aWZpZXJfbG9jayk7CiAKIGVycm9yX3VubG9jazoKIAlh bWRncHVfam9iX2ZyZWUoam9iKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1k Z3B1L2FtZGdwdV9tbi5jIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmMK aW5kZXggNGZmZDdiOTBmNGQ5MDcuLmNiNzE4YTA2NGViNDkxIDEwMDY0NAotLS0gYS9kcml2ZXJz L2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1k L2FtZGdwdS9hbWRncHVfbW4uYwpAQCAtNTAsMjggKzUwLDYgQEAKICNpbmNsdWRlICJhbWRncHUu aCIKICNpbmNsdWRlICJhbWRncHVfYW1ka2ZkLmgiCiAKLS8qKgotICogYW1kZ3B1X21uX2xvY2sg LSB0YWtlIHRoZSB3cml0ZSBzaWRlIGxvY2sgZm9yIHRoaXMgbm90aWZpZXIKLSAqCi0gKiBAbW46 IG91ciBub3RpZmllcgotICovCi12b2lkIGFtZGdwdV9tbl9sb2NrKHN0cnVjdCBhbWRncHVfbW4g Km1uKQotewotCWlmIChtbikKLQkJZG93bl93cml0ZSgmbW4tPmxvY2spOwotfQotCi0vKioKLSAq IGFtZGdwdV9tbl91bmxvY2sgLSBkcm9wIHRoZSB3cml0ZSBzaWRlIGxvY2sgZm9yIHRoaXMgbm90 aWZpZXIKLSAqCi0gKiBAbW46IG91ciBub3RpZmllcgotICovCi12b2lkIGFtZGdwdV9tbl91bmxv Y2soc3RydWN0IGFtZGdwdV9tbiAqbW4pCi17Ci0JaWYgKG1uKQotCQl1cF93cml0ZSgmbW4tPmxv Y2spOwotfQotCiAvKioKICAqIGFtZGdwdV9tbl9pbnZhbGlkYXRlX2dmeCAtIGNhbGxiYWNrIHRv IG5vdGlmeSBhYm91dCBtbSBjaGFuZ2UKICAqCkBAIC04MiwxMiArNjAsMTkgQEAgdm9pZCBhbWRn cHVfbW5fdW5sb2NrKHN0cnVjdCBhbWRncHVfbW4gKm1uKQogICogcG90ZW50aWFsbHkgZGlydHku CiAgKi8KIHN0YXRpYyBib29sIGFtZGdwdV9tbl9pbnZhbGlkYXRlX2dmeChzdHJ1Y3QgbW11X3Jh bmdlX25vdGlmaWVyICptcm4sCi0JCQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3Jh bmdlICpyYW5nZSkKKwkJCQkgICAgIGNvbnN0IHN0cnVjdCBtbXVfbm90aWZpZXJfcmFuZ2UgKnJh bmdlLAorCQkJCSAgICAgdW5zaWduZWQgbG9uZyBjdXJfc2VxKQogewogCXN0cnVjdCBhbWRncHVf Ym8gKmJvID0gY29udGFpbmVyX29mKG1ybiwgc3RydWN0IGFtZGdwdV9ibywgbm90aWZpZXIpOwog CXN0cnVjdCBhbWRncHVfZGV2aWNlICphZGV2ID0gYW1kZ3B1X3R0bV9hZGV2KGJvLT50Ym8uYmRl dik7CiAJbG9uZyByOwogCisJLyoKKwkgKiBGSVhNRTogTXVzdCBob2xkIHNvbWUgbG9jayBzaGFy ZWQgd2l0aAorCSAqIGFtZGdwdV90dG1fdHRfZ2V0X3VzZXJfcGFnZXNfZG9uZSgpCisJICovCisJ bW11X3JhbmdlX3NldF9zZXEobXJuLCBjdXJfc2VxKTsKKwogCS8qIEZJWE1FOiBJcyB0aGlzIG5l Y2Vzc2FyeT8gKi8KIAlpZiAoIWFtZGdwdV90dG1fdHRfYWZmZWN0X3VzZXJwdHIoYm8tPnRiby50 dG0sIHJhbmdlLT5zdGFydCwKIAkJCQkJICByYW5nZS0+ZW5kKSkKQEAgLTExOSwxMSArMTA0LDE4 IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyX29wcyBhbWRncHVfbW5f Z2Z4X29wcyA9IHsKICAqIGV2aWN0aW5nIGFsbCB1c2VyLW1vZGUgcXVldWVzIG9mIHRoZSBwcm9j ZXNzLgogICovCiBzdGF0aWMgYm9vbCBhbWRncHVfbW5faW52YWxpZGF0ZV9oc2Eoc3RydWN0IG1t dV9yYW5nZV9ub3RpZmllciAqbXJuLAotCQkJCSAgICAgY29uc3Qgc3RydWN0IG1tdV9ub3RpZmll cl9yYW5nZSAqcmFuZ2UpCisJCQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3Jhbmdl ICpyYW5nZSwKKwkJCQkgICAgIHVuc2lnbmVkIGxvbmcgY3VyX3NlcSkKIHsKIAlzdHJ1Y3QgYW1k Z3B1X2JvICpibyA9IGNvbnRhaW5lcl9vZihtcm4sIHN0cnVjdCBhbWRncHVfYm8sIG5vdGlmaWVy KTsKIAlzdHJ1Y3QgYW1kZ3B1X2RldmljZSAqYWRldiA9IGFtZGdwdV90dG1fYWRldihiby0+dGJv LmJkZXYpOwogCisJLyoKKwkgKiBGSVhNRTogTXVzdCBob2xkIHNvbWUgbG9jayBzaGFyZWQgd2l0 aAorCSAqIGFtZGdwdV90dG1fdHRfZ2V0X3VzZXJfcGFnZXNfZG9uZSgpCisJICovCisJbW11X3Jh bmdlX3NldF9zZXEobXJuLCBjdXJfc2VxKTsKKwogCS8qIEZJWE1FOiBJcyB0aGlzIG5lY2Vzc2Fy eT8gKi8KIAlpZiAoIWFtZGdwdV90dG1fdHRfYWZmZWN0X3VzZXJwdHIoYm8tPnRiby50dG0sIHJh bmdlLT5zdGFydCwKIAkJCQkJICByYW5nZS0+ZW5kKSkKQEAgLTE0Myw5MiArMTM1LDYgQEAgc3Rh dGljIGNvbnN0IHN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXJfb3BzIGFtZGdwdV9tbl9oc2Ffb3Bz ID0gewogCS5pbnZhbGlkYXRlID0gYW1kZ3B1X21uX2ludmFsaWRhdGVfaHNhLAogfTsKIAotc3Rh dGljIGludCBhbWRncHVfbW5fc3luY19wYWdldGFibGVzKHN0cnVjdCBobW1fbWlycm9yICptaXJy b3IsCi0JCQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICp1cGRhdGUpCi17 Ci0Jc3RydWN0IGFtZGdwdV9tbiAqYW1uID0gY29udGFpbmVyX29mKG1pcnJvciwgc3RydWN0IGFt ZGdwdV9tbiwgbWlycm9yKTsKLQotCWlmICghbW11X25vdGlmaWVyX3JhbmdlX2Jsb2NrYWJsZSh1 cGRhdGUpKQotCQlyZXR1cm4gZmFsc2U7Ci0KLQlkb3duX3JlYWQoJmFtbi0+bG9jayk7Ci0JdXBf cmVhZCgmYW1uLT5sb2NrKTsKLQlyZXR1cm4gMDsKLX0KLQotLyogTG93IGJpdHMgb2YgYW55IHJl YXNvbmFibGUgbW0gcG9pbnRlciB3aWxsIGJlIHVudXNlZCBkdWUgdG8gc3RydWN0Ci0gKiBhbGln bm1lbnQuIFVzZSB0aGVzZSBiaXRzIHRvIG1ha2UgYSB1bmlxdWUga2V5IGZyb20gdGhlIG1tIHBv aW50ZXIKLSAqIGFuZCBub3RpZmllciB0eXBlLgotICovCi0jZGVmaW5lIEFNREdQVV9NTl9LRVko bW0sIHR5cGUpICgodW5zaWduZWQgbG9uZykobW0pICsgKHR5cGUpKQotCi1zdGF0aWMgc3RydWN0 IGhtbV9taXJyb3Jfb3BzIGFtZGdwdV9obW1fbWlycm9yX29wc1tdID0gewotCVtBTURHUFVfTU5f VFlQRV9HRlhdID0gewotCQkuc3luY19jcHVfZGV2aWNlX3BhZ2V0YWJsZXMgPSBhbWRncHVfbW5f c3luY19wYWdldGFibGVzLAotCX0sCi0JW0FNREdQVV9NTl9UWVBFX0hTQV0gPSB7Ci0JCS5zeW5j X2NwdV9kZXZpY2VfcGFnZXRhYmxlcyA9IGFtZGdwdV9tbl9zeW5jX3BhZ2V0YWJsZXMsCi0JfSwK LX07Ci0KLS8qKgotICogYW1kZ3B1X21uX2dldCAtIGNyZWF0ZSBITU0gbWlycm9yIGNvbnRleHQK LSAqCi0gKiBAYWRldjogYW1kZ3B1IGRldmljZSBwb2ludGVyCi0gKiBAdHlwZTogdHlwZSBvZiBN TVUgbm90aWZpZXIgY29udGV4dAotICoKLSAqIENyZWF0ZXMgYSBITU0gbWlycm9yIGNvbnRleHQg Zm9yIGN1cnJlbnQtPm1tLgotICovCi1zdHJ1Y3QgYW1kZ3B1X21uICphbWRncHVfbW5fZ2V0KHN0 cnVjdCBhbWRncHVfZGV2aWNlICphZGV2LAotCQkJCWVudW0gYW1kZ3B1X21uX3R5cGUgdHlwZSkK LXsKLQlzdHJ1Y3QgbW1fc3RydWN0ICptbSA9IGN1cnJlbnQtPm1tOwotCXN0cnVjdCBhbWRncHVf bW4gKmFtbjsKLQl1bnNpZ25lZCBsb25nIGtleSA9IEFNREdQVV9NTl9LRVkobW0sIHR5cGUpOwot CWludCByOwotCi0JbXV0ZXhfbG9jaygmYWRldi0+bW5fbG9jayk7Ci0JaWYgKGRvd25fd3JpdGVf a2lsbGFibGUoJm1tLT5tbWFwX3NlbSkpIHsKLQkJbXV0ZXhfdW5sb2NrKCZhZGV2LT5tbl9sb2Nr KTsKLQkJcmV0dXJuIEVSUl9QVFIoLUVJTlRSKTsKLQl9Ci0KLQloYXNoX2Zvcl9lYWNoX3Bvc3Np YmxlKGFkZXYtPm1uX2hhc2gsIGFtbiwgbm9kZSwga2V5KQotCQlpZiAoQU1ER1BVX01OX0tFWShh bW4tPm1pcnJvci5obW0tPm1tdV9ub3RpZmllci5tbSwKLQkJCQkgIGFtbi0+dHlwZSkgPT0ga2V5 KQotCQkJZ290byByZWxlYXNlX2xvY2tzOwotCi0JYW1uID0ga3phbGxvYyhzaXplb2YoKmFtbiks IEdGUF9LRVJORUwpOwotCWlmICghYW1uKSB7Ci0JCWFtbiA9IEVSUl9QVFIoLUVOT01FTSk7Ci0J CWdvdG8gcmVsZWFzZV9sb2NrczsKLQl9Ci0KLQlhbW4tPmFkZXYgPSBhZGV2OwotCWluaXRfcndz ZW0oJmFtbi0+bG9jayk7Ci0JYW1uLT50eXBlID0gdHlwZTsKLQotCWFtbi0+bWlycm9yLm9wcyA9 ICZhbWRncHVfaG1tX21pcnJvcl9vcHNbdHlwZV07Ci0JciA9IGhtbV9taXJyb3JfcmVnaXN0ZXIo JmFtbi0+bWlycm9yLCBtbSk7Ci0JaWYgKHIpCi0JCWdvdG8gZnJlZV9hbW47Ci0KLQloYXNoX2Fk ZChhZGV2LT5tbl9oYXNoLCAmYW1uLT5ub2RlLCBBTURHUFVfTU5fS0VZKG1tLCB0eXBlKSk7Ci0K LXJlbGVhc2VfbG9ja3M6Ci0JdXBfd3JpdGUoJm1tLT5tbWFwX3NlbSk7Ci0JbXV0ZXhfdW5sb2Nr KCZhZGV2LT5tbl9sb2NrKTsKLQotCXJldHVybiBhbW47Ci0KLWZyZWVfYW1uOgotCXVwX3dyaXRl KCZtbS0+bW1hcF9zZW0pOwotCW11dGV4X3VubG9jaygmYWRldi0+bW5fbG9jayk7Ci0Ja2ZyZWUo YW1uKTsKLQotCXJldHVybiBFUlJfUFRSKHIpOwotfQotCiAvKioKICAqIGFtZGdwdV9tbl9yZWdp c3RlciAtIHJlZ2lzdGVyIGEgQk8gZm9yIG5vdGlmaWVyIHVwZGF0ZXMKICAqCkBAIC0yNjMsMjUg KzE2OSwzIEBAIHZvaWQgYW1kZ3B1X21uX3VucmVnaXN0ZXIoc3RydWN0IGFtZGdwdV9ibyAqYm8p CiAJbW11X3JhbmdlX25vdGlmaWVyX3JlbW92ZSgmYm8tPm5vdGlmaWVyKTsKIAliby0+bm90aWZp ZXIubW0gPSBOVUxMOwogfQotCi0vKiBmbGFncyB1c2VkIGJ5IEhNTSBpbnRlcm5hbCwgbm90IHJl bGF0ZWQgdG8gQ1BVL0dQVSBQVEUgZmxhZ3MgKi8KLXN0YXRpYyBjb25zdCB1aW50NjRfdCBobW1f cmFuZ2VfZmxhZ3NbSE1NX1BGTl9GTEFHX01BWF0gPSB7Ci0JCSgxIDw8IDApLCAvKiBITU1fUEZO X1ZBTElEICovCi0JCSgxIDw8IDEpLCAvKiBITU1fUEZOX1dSSVRFICovCi0JCTAgLyogSE1NX1BG Tl9ERVZJQ0VfUFJJVkFURSAqLwotfTsKLQotc3RhdGljIGNvbnN0IHVpbnQ2NF90IGhtbV9yYW5n ZV92YWx1ZXNbSE1NX1BGTl9WQUxVRV9NQVhdID0gewotCQkweGZmZmZmZmZmZmZmZmZmZmVVTCwg LyogSE1NX1BGTl9FUlJPUiAqLwotCQkwLCAvKiBITU1fUEZOX05PTkUgKi8KLQkJMHhmZmZmZmZm ZmZmZmZmZmZjVUwgLyogSE1NX1BGTl9TUEVDSUFMICovCi19OwotCi12b2lkIGFtZGdwdV9obW1f aW5pdF9yYW5nZShzdHJ1Y3QgaG1tX3JhbmdlICpyYW5nZSkKLXsKLQlpZiAocmFuZ2UpIHsKLQkJ cmFuZ2UtPmZsYWdzID0gaG1tX3JhbmdlX2ZsYWdzOwotCQlyYW5nZS0+dmFsdWVzID0gaG1tX3Jh bmdlX3ZhbHVlczsKLQkJcmFuZ2UtPnBmbl9zaGlmdCA9IFBBR0VfU0hJRlQ7Ci0JfQotfQpkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmggYi9kcml2ZXJz L2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uaAppbmRleCBkNzNhYjI5NDdiMjJiMi4uYTI5 MjIzOGY3NWViYWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdw dV9tbi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9tbi5oCkBAIC0z MCw1OSArMzAsMTAgQEAKICNpbmNsdWRlIDxsaW51eC93b3JrcXVldWUuaD4KICNpbmNsdWRlIDxs aW51eC9pbnRlcnZhbF90cmVlLmg+CiAKLWVudW0gYW1kZ3B1X21uX3R5cGUgewotCUFNREdQVV9N Tl9UWVBFX0dGWCwKLQlBTURHUFVfTU5fVFlQRV9IU0EsCi19OwotCi0vKioKLSAqIHN0cnVjdCBh bWRncHVfbW4KLSAqCi0gKiBAYWRldjogYW1kZ3B1IGRldmljZSBwb2ludGVyCi0gKiBAdHlwZTog dHlwZSBvZiBNTVUgbm90aWZpZXIKLSAqIEB3b3JrOiBkZXN0cnVjdGlvbiB3b3JrIGl0ZW0KLSAq IEBub2RlOiBoYXNoIHRhYmxlIG5vZGUgdG8gZmluZCBzdHJ1Y3R1cmUgYnkgYWRldiBhbmQgbW4K LSAqIEBsb2NrOiBydyBzZW1hcGhvcmUgcHJvdGVjdGluZyB0aGUgbm90aWZpZXIgbm9kZXMKLSAq IEBtaXJyb3I6IEhNTSBtaXJyb3IgZnVuY3Rpb24gc3VwcG9ydAotICoKLSAqIERhdGEgZm9yIGVh Y2ggYW1kZ3B1IGRldmljZSBhbmQgcHJvY2VzcyBhZGRyZXNzIHNwYWNlLgotICovCi1zdHJ1Y3Qg YW1kZ3B1X21uIHsKLQkvKiBjb25zdGFudCBhZnRlciBpbml0aWFsaXNhdGlvbiAqLwotCXN0cnVj dCBhbWRncHVfZGV2aWNlCSphZGV2OwotCWVudW0gYW1kZ3B1X21uX3R5cGUJdHlwZTsKLQotCS8q IG9ubHkgdXNlZCBvbiBkZXN0cnVjdGlvbiAqLwotCXN0cnVjdCB3b3JrX3N0cnVjdAl3b3JrOwot Ci0JLyogcHJvdGVjdGVkIGJ5IGFkZXYtPm1uX2xvY2sgKi8KLQlzdHJ1Y3QgaGxpc3Rfbm9kZQlu b2RlOwotCi0JLyogb2JqZWN0cyBwcm90ZWN0ZWQgYnkgbG9jayAqLwotCXN0cnVjdCByd19zZW1h cGhvcmUJbG9jazsKLQotI2lmZGVmIENPTkZJR19ITU1fTUlSUk9SCi0JLyogSE1NIG1pcnJvciAq LwotCXN0cnVjdCBobW1fbWlycm9yCW1pcnJvcjsKLSNlbmRpZgotfTsKLQogI2lmIGRlZmluZWQo Q09ORklHX0hNTV9NSVJST1IpCi12b2lkIGFtZGdwdV9tbl9sb2NrKHN0cnVjdCBhbWRncHVfbW4g Km1uKTsKLXZvaWQgYW1kZ3B1X21uX3VubG9jayhzdHJ1Y3QgYW1kZ3B1X21uICptbik7Ci1zdHJ1 Y3QgYW1kZ3B1X21uICphbWRncHVfbW5fZ2V0KHN0cnVjdCBhbWRncHVfZGV2aWNlICphZGV2LAot CQkJCWVudW0gYW1kZ3B1X21uX3R5cGUgdHlwZSk7CiBpbnQgYW1kZ3B1X21uX3JlZ2lzdGVyKHN0 cnVjdCBhbWRncHVfYm8gKmJvLCB1bnNpZ25lZCBsb25nIGFkZHIpOwogdm9pZCBhbWRncHVfbW5f dW5yZWdpc3RlcihzdHJ1Y3QgYW1kZ3B1X2JvICpibyk7Ci12b2lkIGFtZGdwdV9obW1faW5pdF9y YW5nZShzdHJ1Y3QgaG1tX3JhbmdlICpyYW5nZSk7CiAjZWxzZQotc3RhdGljIGlubGluZSB2b2lk IGFtZGdwdV9tbl9sb2NrKHN0cnVjdCBhbWRncHVfbW4gKm1uKSB7fQotc3RhdGljIGlubGluZSB2 b2lkIGFtZGdwdV9tbl91bmxvY2soc3RydWN0IGFtZGdwdV9tbiAqbW4pIHt9Ci1zdGF0aWMgaW5s aW5lIHN0cnVjdCBhbWRncHVfbW4gKmFtZGdwdV9tbl9nZXQoc3RydWN0IGFtZGdwdV9kZXZpY2Ug KmFkZXYsCi0JCQkJCSAgICAgIGVudW0gYW1kZ3B1X21uX3R5cGUgdHlwZSkKLXsKLQlyZXR1cm4g TlVMTDsKLX0KIHN0YXRpYyBpbmxpbmUgaW50IGFtZGdwdV9tbl9yZWdpc3RlcihzdHJ1Y3QgYW1k Z3B1X2JvICpibywgdW5zaWduZWQgbG9uZyBhZGRyKQogewogCURSTV9XQVJOX09OQ0UoIkhNTV9N SVJST1Iga2VybmVsIGNvbmZpZyBvcHRpb24gaXMgbm90IGVuYWJsZWQsICIKZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV90dG0uYyBiL2RyaXZlcnMvZ3B1L2Ry bS9hbWQvYW1kZ3B1L2FtZGdwdV90dG0uYwppbmRleCBjMGU0MWYxZjBjMjM2NS4uNjVkOTgyNGI1 NGYyYTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV90dG0u YworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfdHRtLmMKQEAgLTc3Myw2 ICs3NzMsMjAgQEAgc3RydWN0IGFtZGdwdV90dG1fdHQgewogI2VuZGlmCiB9OwogCisjaWZkZWYg Q09ORklHX0RSTV9BTURHUFVfVVNFUlBUUgorLyogZmxhZ3MgdXNlZCBieSBITU0gaW50ZXJuYWws IG5vdCByZWxhdGVkIHRvIENQVS9HUFUgUFRFIGZsYWdzICovCitzdGF0aWMgY29uc3QgdWludDY0 X3QgaG1tX3JhbmdlX2ZsYWdzW0hNTV9QRk5fRkxBR19NQVhdID0geworCSgxIDw8IDApLCAvKiBI TU1fUEZOX1ZBTElEICovCisJKDEgPDwgMSksIC8qIEhNTV9QRk5fV1JJVEUgKi8KKwkwIC8qIEhN TV9QRk5fREVWSUNFX1BSSVZBVEUgKi8KK307CisKK3N0YXRpYyBjb25zdCB1aW50NjRfdCBobW1f cmFuZ2VfdmFsdWVzW0hNTV9QRk5fVkFMVUVfTUFYXSA9IHsKKwkweGZmZmZmZmZmZmZmZmZmZmVV TCwgLyogSE1NX1BGTl9FUlJPUiAqLworCTAsIC8qIEhNTV9QRk5fTk9ORSAqLworCTB4ZmZmZmZm ZmZmZmZmZmZmY1VMIC8qIEhNTV9QRk5fU1BFQ0lBTCAqLworfTsKKwogLyoqCiAgKiBhbWRncHVf dHRtX3R0X2dldF91c2VyX3BhZ2VzIC0gZ2V0IGRldmljZSBhY2Nlc3NpYmxlIHBhZ2VzIHRoYXQg YmFjayB1c2VyCiAgKiBtZW1vcnkgYW5kIHN0YXJ0IEhNTSB0cmFja2luZyBDUFUgcGFnZSB0YWJs ZSB1cGRhdGUKQEAgLTc4MCwyOSArNzk0LDI3IEBAIHN0cnVjdCBhbWRncHVfdHRtX3R0IHsKICAq IENhbGxpbmcgZnVuY3Rpb24gbXVzdCBjYWxsIGFtZGdwdV90dG1fdHRfdXNlcnB0cl9yYW5nZV9k b25lKCkgb25jZSBhbmQgb25seQogICogb25jZSBhZnRlcndhcmRzIHRvIHN0b3AgSE1NIHRyYWNr aW5nCiAgKi8KLSNpZiBJU19FTkFCTEVEKENPTkZJR19EUk1fQU1ER1BVX1VTRVJQVFIpCi0KLSNk ZWZpbmUgTUFYX1JFVFJZX0hNTV9SQU5HRV9GQVVMVAkxNgotCiBpbnQgYW1kZ3B1X3R0bV90dF9n ZXRfdXNlcl9wYWdlcyhzdHJ1Y3QgYW1kZ3B1X2JvICpibywgc3RydWN0IHBhZ2UgKipwYWdlcykK IHsKLQlzdHJ1Y3QgaG1tX21pcnJvciAqbWlycm9yID0gYm8tPm1uID8gJmJvLT5tbi0+bWlycm9y IDogTlVMTDsKIAlzdHJ1Y3QgdHRtX3R0ICp0dG0gPSBiby0+dGJvLnR0bTsKIAlzdHJ1Y3QgYW1k Z3B1X3R0bV90dCAqZ3R0ID0gKHZvaWQgKil0dG07CiAJc3RydWN0IG1tX3N0cnVjdCAqbW07CisJ c3RydWN0IGhtbV9yYW5nZSAqcmFuZ2U7CiAJdW5zaWduZWQgbG9uZyBzdGFydCA9IGd0dC0+dXNl cnB0cjsKIAlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYTsKLQlzdHJ1Y3QgaG1tX3JhbmdlICpy YW5nZTsKIAl1bnNpZ25lZCBsb25nIGk7Ci0JdWludDY0X3QgKnBmbnM7CiAJaW50IHIgPSAwOwog Ci0JaWYgKHVubGlrZWx5KCFtaXJyb3IpKSB7Ci0JCURSTV9ERUJVR19EUklWRVIoIkZhaWxlZCB0 byBnZXQgaG1tX21pcnJvclxuIik7CisJbW0gPSBiby0+bm90aWZpZXIubW07CisJaWYgKHVubGlr ZWx5KCFtbSkpIHsKKwkJRFJNX0RFQlVHX0RSSVZFUigiQk8gaXMgbm90IHJlZ2lzdGVyZWQ/XG4i KTsKIAkJcmV0dXJuIC1FRkFVTFQ7CiAJfQogCi0JbW0gPSBtaXJyb3ItPmhtbS0+bW11X25vdGlm aWVyLm1tOworCS8qIEFub3RoZXIgZ2V0X3VzZXJfcGFnZXMgaXMgcnVubmluZyBhdCB0aGUgc2Ft ZSB0aW1lPz8gKi8KKwlpZiAoV0FSTl9PTihndHQtPnJhbmdlKSkKKwkJcmV0dXJuIC1FRkFVTFQ7 CisKIAlpZiAoIW1tZ2V0X25vdF96ZXJvKG1tKSkgLyogSGFwcGVucyBkdXJpbmcgcHJvY2VzcyBz aHV0ZG93biAqLwogCQlyZXR1cm4gLUVTUkNIOwogCkBAIC04MTEsMzAgKzgyMywyNCBAQCBpbnQg YW1kZ3B1X3R0bV90dF9nZXRfdXNlcl9wYWdlcyhzdHJ1Y3QgYW1kZ3B1X2JvICpibywgc3RydWN0 IHBhZ2UgKipwYWdlcykKIAkJciA9IC1FTk9NRU07CiAJCWdvdG8gb3V0OwogCX0KKwlyYW5nZS0+ bm90aWZpZXIgPSAmYm8tPm5vdGlmaWVyOworCXJhbmdlLT5mbGFncyA9IGhtbV9yYW5nZV9mbGFn czsKKwlyYW5nZS0+dmFsdWVzID0gaG1tX3JhbmdlX3ZhbHVlczsKKwlyYW5nZS0+cGZuX3NoaWZ0 ID0gUEFHRV9TSElGVDsKKwlyYW5nZS0+c3RhcnQgPSBiby0+bm90aWZpZXIuaW50ZXJ2YWxfdHJl ZS5zdGFydDsKKwlyYW5nZS0+ZW5kID0gYm8tPm5vdGlmaWVyLmludGVydmFsX3RyZWUubGFzdCAr IDE7CisJcmFuZ2UtPmRlZmF1bHRfZmxhZ3MgPSBobW1fcmFuZ2VfZmxhZ3NbSE1NX1BGTl9WQUxJ RF07CisJaWYgKCFhbWRncHVfdHRtX3R0X2lzX3JlYWRvbmx5KHR0bSkpCisJCXJhbmdlLT5kZWZh dWx0X2ZsYWdzIHw9IHJhbmdlLT5mbGFnc1tITU1fUEZOX1dSSVRFXTsKIAotCXBmbnMgPSBrdm1h bGxvY19hcnJheSh0dG0tPm51bV9wYWdlcywgc2l6ZW9mKCpwZm5zKSwgR0ZQX0tFUk5FTCk7Ci0J aWYgKHVubGlrZWx5KCFwZm5zKSkgeworCXJhbmdlLT5wZm5zID0ga3ZtYWxsb2NfYXJyYXkodHRt LT5udW1fcGFnZXMsIHNpemVvZigqcmFuZ2UtPnBmbnMpLAorCQkJCSAgICAgR0ZQX0tFUk5FTCk7 CisJaWYgKHVubGlrZWx5KCFyYW5nZS0+cGZucykpIHsKIAkJciA9IC1FTk9NRU07CiAJCWdvdG8g b3V0X2ZyZWVfcmFuZ2VzOwogCX0KIAotCWFtZGdwdV9obW1faW5pdF9yYW5nZShyYW5nZSk7Ci0J cmFuZ2UtPmRlZmF1bHRfZmxhZ3MgPSByYW5nZS0+ZmxhZ3NbSE1NX1BGTl9WQUxJRF07Ci0JcmFu Z2UtPmRlZmF1bHRfZmxhZ3MgfD0gYW1kZ3B1X3R0bV90dF9pc19yZWFkb25seSh0dG0pID8KLQkJ CQkwIDogcmFuZ2UtPmZsYWdzW0hNTV9QRk5fV1JJVEVdOwotCXJhbmdlLT5wZm5fZmxhZ3NfbWFz ayA9IDA7Ci0JcmFuZ2UtPnBmbnMgPSBwZm5zOwotCXJhbmdlLT5zdGFydCA9IHN0YXJ0OwotCXJh bmdlLT5lbmQgPSBzdGFydCArIHR0bS0+bnVtX3BhZ2VzICogUEFHRV9TSVpFOwotCi0JaG1tX3Jh bmdlX3JlZ2lzdGVyKHJhbmdlLCBtaXJyb3IpOwotCi0JLyoKLQkgKiBKdXN0IHdhaXQgZm9yIHJh bmdlIHRvIGJlIHZhbGlkLCBzYWZlIHRvIGlnbm9yZSByZXR1cm4gdmFsdWUgYXMgd2UKLQkgKiB3 aWxsIHVzZSB0aGUgcmV0dXJuIHZhbHVlIG9mIGhtbV9yYW5nZV9mYXVsdCgpIGJlbG93IHVuZGVy IHRoZQotCSAqIG1tYXBfc2VtIHRvIGFzY2VydGFpbiB0aGUgdmFsaWRpdHkgb2YgdGhlIHJhbmdl LgotCSAqLwotCWhtbV9yYW5nZV93YWl0X3VudGlsX3ZhbGlkKHJhbmdlLCBITU1fUkFOR0VfREVG QVVMVF9USU1FT1VUKTsKKwlyYW5nZS0+bm90aWZpZXJfc2VxID0gbW11X3JhbmdlX3JlYWRfYmVn aW4oJmJvLT5ub3RpZmllcik7CiAKIAlkb3duX3JlYWQoJm1tLT5tbWFwX3NlbSk7CiAJdm1hID0g ZmluZF92bWEobW0sIHN0YXJ0KTsKQEAgLTg1NSwxMCArODYxLDEwIEBAIGludCBhbWRncHVfdHRt X3R0X2dldF91c2VyX3BhZ2VzKHN0cnVjdCBhbWRncHVfYm8gKmJvLCBzdHJ1Y3QgcGFnZSAqKnBh Z2VzKQogCQlnb3RvIG91dF9mcmVlX3BmbnM7CiAKIAlmb3IgKGkgPSAwOyBpIDwgdHRtLT5udW1f cGFnZXM7IGkrKykgewotCQlwYWdlc1tpXSA9IGhtbV9kZXZpY2VfZW50cnlfdG9fcGFnZShyYW5n ZSwgcGZuc1tpXSk7CisJCXBhZ2VzW2ldID0gaG1tX2RldmljZV9lbnRyeV90b19wYWdlKHJhbmdl LCByYW5nZS0+cGZuc1tpXSk7CiAJCWlmICh1bmxpa2VseSghcGFnZXNbaV0pKSB7CiAJCQlwcl9l cnIoIlBhZ2UgZmF1bHQgZmFpbGVkIGZvciBwZm5bJWx1XSA9IDB4JWxseFxuIiwKLQkJCSAgICAg ICBpLCBwZm5zW2ldKTsKKwkJCSAgICAgICBpLCByYW5nZS0+cGZuc1tpXSk7CiAJCQlyID0gLUVO T01FTTsKIAogCQkJZ290byBvdXRfZnJlZV9wZm5zOwpAQCAtODczLDggKzg3OSw3IEBAIGludCBh bWRncHVfdHRtX3R0X2dldF91c2VyX3BhZ2VzKHN0cnVjdCBhbWRncHVfYm8gKmJvLCBzdHJ1Y3Qg cGFnZSAqKnBhZ2VzKQogb3V0X3VubG9jazoKIAl1cF9yZWFkKCZtbS0+bW1hcF9zZW0pOwogb3V0 X2ZyZWVfcGZuczoKLQlobW1fcmFuZ2VfdW5yZWdpc3RlcihyYW5nZSk7Ci0Ja3ZmcmVlKHBmbnMp OworCWt2ZnJlZShyYW5nZS0+cGZucyk7CiBvdXRfZnJlZV9yYW5nZXM6CiAJa2ZyZWUocmFuZ2Up Owogb3V0OgpAQCAtOTAzLDkgKzkwOCw4IEBAIGJvb2wgYW1kZ3B1X3R0bV90dF9nZXRfdXNlcl9w YWdlc19kb25lKHN0cnVjdCB0dG1fdHQgKnR0bSkKIAkJIk5vIHVzZXIgcGFnZXMgdG8gY2hlY2tc biIpOwogCiAJaWYgKGd0dC0+cmFuZ2UpIHsKLQkJciA9IGhtbV9yYW5nZV92YWxpZChndHQtPnJh bmdlKTsKLQkJaG1tX3JhbmdlX3VucmVnaXN0ZXIoZ3R0LT5yYW5nZSk7Ci0KKwkJciA9IG1tdV9y YW5nZV9yZWFkX3JldHJ5KGd0dC0+cmFuZ2UtPm5vdGlmaWVyLAorCQkJCQkgZ3R0LT5yYW5nZS0+ bm90aWZpZXJfc2VxKTsKIAkJa3ZmcmVlKGd0dC0+cmFuZ2UtPnBmbnMpOwogCQlrZnJlZShndHQt PnJhbmdlKTsKIAkJZ3R0LT5yYW5nZSA9IE5VTEw7Ci0tIAoyLjIzLjAKCgpfX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpYZW4tZGV2ZWwgbWFpbGluZyBsaXN0 Clhlbi1kZXZlbEBsaXN0cy54ZW5wcm9qZWN0Lm9yZwpodHRwczovL2xpc3RzLnhlbnByb2plY3Qu b3JnL21haWxtYW4vbGlzdGluZm8veGVuLWRldmVs 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 CD85FCA9EC0 for ; Mon, 28 Oct 2019 21:08:20 +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 AAD1F217D6 for ; Mon, 28 Oct 2019 21:08:20 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org AAD1F217D6 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 D975F6EA6C; Mon, 28 Oct 2019 21:08:00 +0000 (UTC) Received: from mail-qk1-x742.google.com (mail-qk1-x742.google.com [IPv6:2607:f8b0:4864:20::742]) by gabe.freedesktop.org (Postfix) with ESMTPS id F21A989D5F for ; Mon, 28 Oct 2019 20:10:50 +0000 (UTC) Received: by mail-qk1-x742.google.com with SMTP id u184so9779431qkd.4 for ; Mon, 28 Oct 2019 13:10:50 -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=kWAFXaairmju5dUouyI0fIFpVoVh+rRI3GJkG/c3jbo=; b=pQb4J1Vd+nAYkH2gYdu+QC/IzzygjhpPL0GGHDzSJnkN4gFi7F1n/eyEiLVQxhfAgH n7cp39xTGuBDJoG22zTGzqIG83Rp/hmwDHSwDul8OCrFpz7BtSSnVHbBiYe7tuwkkXzg tGXjpWlfeXV/8GqwDxGzusMxEBKJW1ZCmdWwmfffsgmlCIv8fArQ6N1ZDCYAIJuId3lw MShB0kbllEA934C8TyLcWrvhEH0KVQEl9b+oU27aNWtPYPA0yMgQdkg7SKvTbvQ82qcl 1dhgNv5olPQZHsV6UnXc4PPPRCCKVva/22LS3pDKgYMvnG4+Kr2p6H+wqeHOEw4ywV5E C51Q== X-Gm-Message-State: APjAAAWQfH2GHc+PFhEMAOW8zbQvzjUnouiXlh4NLgjLpCb8XBBiNwGg UA7kk0c2KZxslwyN2+M0/6rhEg== X-Google-Smtp-Source: APXvYqyexUtgyT46O4Xj8Sx5B6Zyp9sP915KnVYaCPjwqJLiYtfebmqJR+ZAbE7J5Hww5Pxy2DBZEA== X-Received: by 2002:a05:620a:13f0:: with SMTP id h16mr17732993qkl.310.1572293449993; Mon, 28 Oct 2019 13:10:49 -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 o1sm7821379qtb.82.2019.10.28.13.10.44 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Mon, 28 Oct 2019 13:10:48 -0700 (PDT) Received: from jgg by mlx.ziepe.ca with local (Exim 4.90_1) (envelope-from ) id 1iPBLf-0001hL-Mi; 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 14/15] drm/amdgpu: Use mmu_range_notifier instead of hmm_mirror Date: Mon, 28 Oct 2019 17:10:31 -0300 Message-Id: <20191028201032.6352-15-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=kWAFXaairmju5dUouyI0fIFpVoVh+rRI3GJkG/c3jbo=; b=ZMZ20vhDqRatgd/VeNs+gakMuIFZXaMsb6XQWoUK9HXLD+PHirdDumPc851+WT2Hyf C1Iv1wiPN6IlkT/5OzHp2qTA3MHXJcFx6P54sX18cmGOfENyUr/3lvF7WB/e9idjitHy lGg8W7hcfUwYhCtTo+P5QwNkSGSXWLHrmB7UiWpkznO/5PpvIjO4rkGK5oPJe284j39Z 0SrDdsATeTt0aysE+Vjhm+ODlfdb0SYunqwjoByjas1/pFQCfKFMrcffBKQilclNwoJN Kw57TFwiQGNXYLPWr/vN3hajssQSFf3odyyUW2L2YFJ1wLFryfEwL6Mj/wjl8DvBS7u6 6HmA== 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 , Oleksandr Andrushchenko , linux-rdma@vger.kernel.org, nouveau@lists.freedesktop.org, Dennis Dalessandro , amd-gfx@lists.freedesktop.org, 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: <20191028201031.1f2z7f6jaN5dnR8EAIZJ_ZSgjTWTb_uL1NICfUkEDJQ@z> RnJvbTogSmFzb24gR3VudGhvcnBlIDxqZ2dAbWVsbGFub3guY29tPgoKQ29udmVydCB0aGUgY29s bGlzaW9uLXJldHJ5IGxvY2sgYXJvdW5kIGhtbV9yYW5nZV9mYXVsdCB0byB1c2UgdGhlIG9uZSBu b3cKcHJvdmlkZWQgYnkgdGhlIG1tdV9yYW5nZSBub3RpZmllci4KCkFsdGhvdWdoIHRoaXMgZHJp dmVyIGRvZXMgbm90IHNlZW0gdG8gdXNlIHRoZSBjb2xsaXNpb24gcmV0cnkgbG9jayB0aGF0Cmht bSBwcm92aWRlcyBjb3JyZWN0bHksIGl0IGNhbiBzdGlsbCBiZSBjb252ZXJ0ZWQgb3ZlciB0byB1 c2UgdGhlCm1tdV9yYW5nZV9ub3RpZmllciBhcGkgaW5zdGVhZCBvZiBobW1fbWlycm9yIHdpdGhv dXQgdG9vIG11Y2ggdHJvdWJsZS4KClRoaXMgYWxzbyBkZWxldGVzIGFub3RoZXIgcGxhY2Ugd2hl cmUgYSBkcml2ZXIgaXMgYXNzb2NpYXRpbmcgYWRkaXRpb25hbApkYXRhIChzdHJ1Y3QgYW1kZ3B1 X21uKSB3aXRoIGEgbW11X3N0cnVjdC4KCkNjOiBBbGV4IERldWNoZXIgPGFsZXhhbmRlci5kZXVj aGVyQGFtZC5jb20+CkNjOiBDaHJpc3RpYW4gS8O2bmlnIDxjaHJpc3RpYW4ua29lbmlnQGFtZC5j b20+CkNjOiBEYXZpZCAoQ2h1bk1pbmcpIFpob3UgPERhdmlkMS5aaG91QGFtZC5jb20+CkNjOiBh bWQtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpTaWduZWQtb2ZmLWJ5OiBKYXNvbiBHdW50aG9y cGUgPGpnZ0BtZWxsYW5veC5jb20+Ci0tLQogLi4uL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVf YW1ka2ZkX2dwdXZtLmMgIHwgICA0ICsKIGRyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdw dV9jcy5jICAgICAgICB8ICAxNCArLQogZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1 X21uLmMgICAgICAgIHwgMTQ4ICsrLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy9ncHUvZHJtL2Ft ZC9hbWRncHUvYW1kZ3B1X21uLmggICAgICAgIHwgIDQ5IC0tLS0tLQogZHJpdmVycy9ncHUvZHJt L2FtZC9hbWRncHUvYW1kZ3B1X3R0bS5jICAgICAgIHwgIDc2ICsrKystLS0tLQogNSBmaWxlcyBj aGFuZ2VkLCA2NiBpbnNlcnRpb25zKCspLCAyMjUgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2FtZGtmZF9ncHV2bS5jIGIvZHJpdmVy cy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2FtZGtmZF9ncHV2bS5jCmluZGV4IDQ3NzAwMzAy YTA4YjdmLi4xYmNlZGI5YjQ3N2RjZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FtZC9h bWRncHUvYW1kZ3B1X2FtZGtmZF9ncHV2bS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1k Z3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYwpAQCAtMTczOCw2ICsxNzM4LDEwIEBAIHN0YXRpYyBp bnQgdXBkYXRlX2ludmFsaWRfdXNlcl9wYWdlcyhzdHJ1Y3QgYW1ka2ZkX3Byb2Nlc3NfaW5mbyAq cHJvY2Vzc19pbmZvLAogCQkJcmV0dXJuIHJldDsKIAkJfQogCisJCS8qCisJCSAqIEZJWE1FOiBD YW5ub3QgaWdub3JlIHRoZSByZXR1cm4gY29kZSwgbXVzdCBob2xkCisJCSAqIG5vdGlmaWVyX2xv Y2sKKwkJICovCiAJCWFtZGdwdV90dG1fdHRfZ2V0X3VzZXJfcGFnZXNfZG9uZShiby0+dGJvLnR0 bSk7CiAKIAkJLyogTWFyayB0aGUgQk8gYXMgdmFsaWQgdW5sZXNzIGl0IHdhcyBpbnZhbGlkYXRl ZApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2NzLmMgYi9k cml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfY3MuYwppbmRleCAyZTUzZmVlZDQwZTIz MC4uNzY3NzFmNWYwYjYwYWIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1 L2FtZGdwdV9jcy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9jcy5j CkBAIC02MDcsOCArNjA3LDYgQEAgc3RhdGljIGludCBhbWRncHVfY3NfcGFyc2VyX2JvcyhzdHJ1 Y3QgYW1kZ3B1X2NzX3BhcnNlciAqcCwKIAkJZS0+dHYubnVtX3NoYXJlZCA9IDI7CiAKIAlhbWRn cHVfYm9fbGlzdF9nZXRfbGlzdChwLT5ib19saXN0LCAmcC0+dmFsaWRhdGVkKTsKLQlpZiAocC0+ Ym9fbGlzdC0+Zmlyc3RfdXNlcnB0ciAhPSBwLT5ib19saXN0LT5udW1fZW50cmllcykKLQkJcC0+ bW4gPSBhbWRncHVfbW5fZ2V0KHAtPmFkZXYsIEFNREdQVV9NTl9UWVBFX0dGWCk7CiAKIAlJTklU X0xJU1RfSEVBRCgmZHVwbGljYXRlcyk7CiAJYW1kZ3B1X3ZtX2dldF9wZF9ibygmZnByaXYtPnZt LCAmcC0+dmFsaWRhdGVkLCAmcC0+dm1fcGQpOwpAQCAtMTI5MSwxMSArMTI4OSwxMSBAQCBzdGF0 aWMgaW50IGFtZGdwdV9jc19zdWJtaXQoc3RydWN0IGFtZGdwdV9jc19wYXJzZXIgKnAsCiAJaWYg KHIpCiAJCWdvdG8gZXJyb3JfdW5sb2NrOwogCi0JLyogTm8gbWVtb3J5IGFsbG9jYXRpb24gaXMg YWxsb3dlZCB3aGlsZSBob2xkaW5nIHRoZSBtbiBsb2NrLgotCSAqIHAtPm1uIGlzIGhvbGQgdW50 aWwgYW1kZ3B1X2NzX3N1Ym1pdCBpcyBmaW5pc2hlZCBhbmQgZmVuY2UgaXMgYWRkZWQKLQkgKiB0 byBCT3MuCisJLyogTm8gbWVtb3J5IGFsbG9jYXRpb24gaXMgYWxsb3dlZCB3aGlsZSBob2xkaW5n IHRoZSBub3RpZmllciBsb2NrLgorCSAqIFRoZSBsb2NrIGlzIGhlbGQgdW50aWwgYW1kZ3B1X2Nz X3N1Ym1pdCBpcyBmaW5pc2hlZCBhbmQgZmVuY2UgaXMKKwkgKiBhZGRlZCB0byBCT3MuCiAJICov Ci0JYW1kZ3B1X21uX2xvY2socC0+bW4pOworCW11dGV4X2xvY2soJnAtPmFkZXYtPm5vdGlmaWVy X2xvY2spOwogCiAJLyogSWYgdXNlcnB0ciBhcmUgaW52YWxpZGF0ZWQgYWZ0ZXIgYW1kZ3B1X2Nz X3BhcnNlcl9ib3MoKSwgcmV0dXJuCiAJICogLUVBR0FJTiwgZHJtSW9jdGwgaW4gbGliZHJtIHdp bGwgcmVzdGFydCB0aGUgYW1kZ3B1X2NzX2lvY3RsLgpAQCAtMTMzOCwxMyArMTMzNiwxMyBAQCBz dGF0aWMgaW50IGFtZGdwdV9jc19zdWJtaXQoc3RydWN0IGFtZGdwdV9jc19wYXJzZXIgKnAsCiAJ YW1kZ3B1X3ZtX21vdmVfdG9fbHJ1X3RhaWwocC0+YWRldiwgJmZwcml2LT52bSk7CiAKIAl0dG1f ZXVfZmVuY2VfYnVmZmVyX29iamVjdHMoJnAtPnRpY2tldCwgJnAtPnZhbGlkYXRlZCwgcC0+ZmVu Y2UpOwotCWFtZGdwdV9tbl91bmxvY2socC0+bW4pOworCW11dGV4X3VubG9jaygmcC0+YWRldi0+ bm90aWZpZXJfbG9jayk7CiAKIAlyZXR1cm4gMDsKIAogZXJyb3JfYWJvcnQ6CiAJZHJtX3NjaGVk X2pvYl9jbGVhbnVwKCZqb2ItPmJhc2UpOwotCWFtZGdwdV9tbl91bmxvY2socC0+bW4pOworCW11 dGV4X3VubG9jaygmcC0+YWRldi0+bm90aWZpZXJfbG9jayk7CiAKIGVycm9yX3VubG9jazoKIAlh bWRncHVfam9iX2ZyZWUoam9iKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1k Z3B1L2FtZGdwdV9tbi5jIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmMK aW5kZXggNGZmZDdiOTBmNGQ5MDcuLmNiNzE4YTA2NGViNDkxIDEwMDY0NAotLS0gYS9kcml2ZXJz L2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1k L2FtZGdwdS9hbWRncHVfbW4uYwpAQCAtNTAsMjggKzUwLDYgQEAKICNpbmNsdWRlICJhbWRncHUu aCIKICNpbmNsdWRlICJhbWRncHVfYW1ka2ZkLmgiCiAKLS8qKgotICogYW1kZ3B1X21uX2xvY2sg LSB0YWtlIHRoZSB3cml0ZSBzaWRlIGxvY2sgZm9yIHRoaXMgbm90aWZpZXIKLSAqCi0gKiBAbW46 IG91ciBub3RpZmllcgotICovCi12b2lkIGFtZGdwdV9tbl9sb2NrKHN0cnVjdCBhbWRncHVfbW4g Km1uKQotewotCWlmIChtbikKLQkJZG93bl93cml0ZSgmbW4tPmxvY2spOwotfQotCi0vKioKLSAq IGFtZGdwdV9tbl91bmxvY2sgLSBkcm9wIHRoZSB3cml0ZSBzaWRlIGxvY2sgZm9yIHRoaXMgbm90 aWZpZXIKLSAqCi0gKiBAbW46IG91ciBub3RpZmllcgotICovCi12b2lkIGFtZGdwdV9tbl91bmxv Y2soc3RydWN0IGFtZGdwdV9tbiAqbW4pCi17Ci0JaWYgKG1uKQotCQl1cF93cml0ZSgmbW4tPmxv Y2spOwotfQotCiAvKioKICAqIGFtZGdwdV9tbl9pbnZhbGlkYXRlX2dmeCAtIGNhbGxiYWNrIHRv IG5vdGlmeSBhYm91dCBtbSBjaGFuZ2UKICAqCkBAIC04MiwxMiArNjAsMTkgQEAgdm9pZCBhbWRn cHVfbW5fdW5sb2NrKHN0cnVjdCBhbWRncHVfbW4gKm1uKQogICogcG90ZW50aWFsbHkgZGlydHku CiAgKi8KIHN0YXRpYyBib29sIGFtZGdwdV9tbl9pbnZhbGlkYXRlX2dmeChzdHJ1Y3QgbW11X3Jh bmdlX25vdGlmaWVyICptcm4sCi0JCQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3Jh bmdlICpyYW5nZSkKKwkJCQkgICAgIGNvbnN0IHN0cnVjdCBtbXVfbm90aWZpZXJfcmFuZ2UgKnJh bmdlLAorCQkJCSAgICAgdW5zaWduZWQgbG9uZyBjdXJfc2VxKQogewogCXN0cnVjdCBhbWRncHVf Ym8gKmJvID0gY29udGFpbmVyX29mKG1ybiwgc3RydWN0IGFtZGdwdV9ibywgbm90aWZpZXIpOwog CXN0cnVjdCBhbWRncHVfZGV2aWNlICphZGV2ID0gYW1kZ3B1X3R0bV9hZGV2KGJvLT50Ym8uYmRl dik7CiAJbG9uZyByOwogCisJLyoKKwkgKiBGSVhNRTogTXVzdCBob2xkIHNvbWUgbG9jayBzaGFy ZWQgd2l0aAorCSAqIGFtZGdwdV90dG1fdHRfZ2V0X3VzZXJfcGFnZXNfZG9uZSgpCisJICovCisJ bW11X3JhbmdlX3NldF9zZXEobXJuLCBjdXJfc2VxKTsKKwogCS8qIEZJWE1FOiBJcyB0aGlzIG5l Y2Vzc2FyeT8gKi8KIAlpZiAoIWFtZGdwdV90dG1fdHRfYWZmZWN0X3VzZXJwdHIoYm8tPnRiby50 dG0sIHJhbmdlLT5zdGFydCwKIAkJCQkJICByYW5nZS0+ZW5kKSkKQEAgLTExOSwxMSArMTA0LDE4 IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyX29wcyBhbWRncHVfbW5f Z2Z4X29wcyA9IHsKICAqIGV2aWN0aW5nIGFsbCB1c2VyLW1vZGUgcXVldWVzIG9mIHRoZSBwcm9j ZXNzLgogICovCiBzdGF0aWMgYm9vbCBhbWRncHVfbW5faW52YWxpZGF0ZV9oc2Eoc3RydWN0IG1t dV9yYW5nZV9ub3RpZmllciAqbXJuLAotCQkJCSAgICAgY29uc3Qgc3RydWN0IG1tdV9ub3RpZmll cl9yYW5nZSAqcmFuZ2UpCisJCQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3Jhbmdl ICpyYW5nZSwKKwkJCQkgICAgIHVuc2lnbmVkIGxvbmcgY3VyX3NlcSkKIHsKIAlzdHJ1Y3QgYW1k Z3B1X2JvICpibyA9IGNvbnRhaW5lcl9vZihtcm4sIHN0cnVjdCBhbWRncHVfYm8sIG5vdGlmaWVy KTsKIAlzdHJ1Y3QgYW1kZ3B1X2RldmljZSAqYWRldiA9IGFtZGdwdV90dG1fYWRldihiby0+dGJv LmJkZXYpOwogCisJLyoKKwkgKiBGSVhNRTogTXVzdCBob2xkIHNvbWUgbG9jayBzaGFyZWQgd2l0 aAorCSAqIGFtZGdwdV90dG1fdHRfZ2V0X3VzZXJfcGFnZXNfZG9uZSgpCisJICovCisJbW11X3Jh bmdlX3NldF9zZXEobXJuLCBjdXJfc2VxKTsKKwogCS8qIEZJWE1FOiBJcyB0aGlzIG5lY2Vzc2Fy eT8gKi8KIAlpZiAoIWFtZGdwdV90dG1fdHRfYWZmZWN0X3VzZXJwdHIoYm8tPnRiby50dG0sIHJh bmdlLT5zdGFydCwKIAkJCQkJICByYW5nZS0+ZW5kKSkKQEAgLTE0Myw5MiArMTM1LDYgQEAgc3Rh dGljIGNvbnN0IHN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXJfb3BzIGFtZGdwdV9tbl9oc2Ffb3Bz ID0gewogCS5pbnZhbGlkYXRlID0gYW1kZ3B1X21uX2ludmFsaWRhdGVfaHNhLAogfTsKIAotc3Rh dGljIGludCBhbWRncHVfbW5fc3luY19wYWdldGFibGVzKHN0cnVjdCBobW1fbWlycm9yICptaXJy b3IsCi0JCQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICp1cGRhdGUpCi17 Ci0Jc3RydWN0IGFtZGdwdV9tbiAqYW1uID0gY29udGFpbmVyX29mKG1pcnJvciwgc3RydWN0IGFt ZGdwdV9tbiwgbWlycm9yKTsKLQotCWlmICghbW11X25vdGlmaWVyX3JhbmdlX2Jsb2NrYWJsZSh1 cGRhdGUpKQotCQlyZXR1cm4gZmFsc2U7Ci0KLQlkb3duX3JlYWQoJmFtbi0+bG9jayk7Ci0JdXBf cmVhZCgmYW1uLT5sb2NrKTsKLQlyZXR1cm4gMDsKLX0KLQotLyogTG93IGJpdHMgb2YgYW55IHJl YXNvbmFibGUgbW0gcG9pbnRlciB3aWxsIGJlIHVudXNlZCBkdWUgdG8gc3RydWN0Ci0gKiBhbGln bm1lbnQuIFVzZSB0aGVzZSBiaXRzIHRvIG1ha2UgYSB1bmlxdWUga2V5IGZyb20gdGhlIG1tIHBv aW50ZXIKLSAqIGFuZCBub3RpZmllciB0eXBlLgotICovCi0jZGVmaW5lIEFNREdQVV9NTl9LRVko bW0sIHR5cGUpICgodW5zaWduZWQgbG9uZykobW0pICsgKHR5cGUpKQotCi1zdGF0aWMgc3RydWN0 IGhtbV9taXJyb3Jfb3BzIGFtZGdwdV9obW1fbWlycm9yX29wc1tdID0gewotCVtBTURHUFVfTU5f VFlQRV9HRlhdID0gewotCQkuc3luY19jcHVfZGV2aWNlX3BhZ2V0YWJsZXMgPSBhbWRncHVfbW5f c3luY19wYWdldGFibGVzLAotCX0sCi0JW0FNREdQVV9NTl9UWVBFX0hTQV0gPSB7Ci0JCS5zeW5j X2NwdV9kZXZpY2VfcGFnZXRhYmxlcyA9IGFtZGdwdV9tbl9zeW5jX3BhZ2V0YWJsZXMsCi0JfSwK LX07Ci0KLS8qKgotICogYW1kZ3B1X21uX2dldCAtIGNyZWF0ZSBITU0gbWlycm9yIGNvbnRleHQK LSAqCi0gKiBAYWRldjogYW1kZ3B1IGRldmljZSBwb2ludGVyCi0gKiBAdHlwZTogdHlwZSBvZiBN TVUgbm90aWZpZXIgY29udGV4dAotICoKLSAqIENyZWF0ZXMgYSBITU0gbWlycm9yIGNvbnRleHQg Zm9yIGN1cnJlbnQtPm1tLgotICovCi1zdHJ1Y3QgYW1kZ3B1X21uICphbWRncHVfbW5fZ2V0KHN0 cnVjdCBhbWRncHVfZGV2aWNlICphZGV2LAotCQkJCWVudW0gYW1kZ3B1X21uX3R5cGUgdHlwZSkK LXsKLQlzdHJ1Y3QgbW1fc3RydWN0ICptbSA9IGN1cnJlbnQtPm1tOwotCXN0cnVjdCBhbWRncHVf bW4gKmFtbjsKLQl1bnNpZ25lZCBsb25nIGtleSA9IEFNREdQVV9NTl9LRVkobW0sIHR5cGUpOwot CWludCByOwotCi0JbXV0ZXhfbG9jaygmYWRldi0+bW5fbG9jayk7Ci0JaWYgKGRvd25fd3JpdGVf a2lsbGFibGUoJm1tLT5tbWFwX3NlbSkpIHsKLQkJbXV0ZXhfdW5sb2NrKCZhZGV2LT5tbl9sb2Nr KTsKLQkJcmV0dXJuIEVSUl9QVFIoLUVJTlRSKTsKLQl9Ci0KLQloYXNoX2Zvcl9lYWNoX3Bvc3Np YmxlKGFkZXYtPm1uX2hhc2gsIGFtbiwgbm9kZSwga2V5KQotCQlpZiAoQU1ER1BVX01OX0tFWShh bW4tPm1pcnJvci5obW0tPm1tdV9ub3RpZmllci5tbSwKLQkJCQkgIGFtbi0+dHlwZSkgPT0ga2V5 KQotCQkJZ290byByZWxlYXNlX2xvY2tzOwotCi0JYW1uID0ga3phbGxvYyhzaXplb2YoKmFtbiks IEdGUF9LRVJORUwpOwotCWlmICghYW1uKSB7Ci0JCWFtbiA9IEVSUl9QVFIoLUVOT01FTSk7Ci0J CWdvdG8gcmVsZWFzZV9sb2NrczsKLQl9Ci0KLQlhbW4tPmFkZXYgPSBhZGV2OwotCWluaXRfcndz ZW0oJmFtbi0+bG9jayk7Ci0JYW1uLT50eXBlID0gdHlwZTsKLQotCWFtbi0+bWlycm9yLm9wcyA9 ICZhbWRncHVfaG1tX21pcnJvcl9vcHNbdHlwZV07Ci0JciA9IGhtbV9taXJyb3JfcmVnaXN0ZXIo JmFtbi0+bWlycm9yLCBtbSk7Ci0JaWYgKHIpCi0JCWdvdG8gZnJlZV9hbW47Ci0KLQloYXNoX2Fk ZChhZGV2LT5tbl9oYXNoLCAmYW1uLT5ub2RlLCBBTURHUFVfTU5fS0VZKG1tLCB0eXBlKSk7Ci0K LXJlbGVhc2VfbG9ja3M6Ci0JdXBfd3JpdGUoJm1tLT5tbWFwX3NlbSk7Ci0JbXV0ZXhfdW5sb2Nr KCZhZGV2LT5tbl9sb2NrKTsKLQotCXJldHVybiBhbW47Ci0KLWZyZWVfYW1uOgotCXVwX3dyaXRl KCZtbS0+bW1hcF9zZW0pOwotCW11dGV4X3VubG9jaygmYWRldi0+bW5fbG9jayk7Ci0Ja2ZyZWUo YW1uKTsKLQotCXJldHVybiBFUlJfUFRSKHIpOwotfQotCiAvKioKICAqIGFtZGdwdV9tbl9yZWdp c3RlciAtIHJlZ2lzdGVyIGEgQk8gZm9yIG5vdGlmaWVyIHVwZGF0ZXMKICAqCkBAIC0yNjMsMjUg KzE2OSwzIEBAIHZvaWQgYW1kZ3B1X21uX3VucmVnaXN0ZXIoc3RydWN0IGFtZGdwdV9ibyAqYm8p CiAJbW11X3JhbmdlX25vdGlmaWVyX3JlbW92ZSgmYm8tPm5vdGlmaWVyKTsKIAliby0+bm90aWZp ZXIubW0gPSBOVUxMOwogfQotCi0vKiBmbGFncyB1c2VkIGJ5IEhNTSBpbnRlcm5hbCwgbm90IHJl bGF0ZWQgdG8gQ1BVL0dQVSBQVEUgZmxhZ3MgKi8KLXN0YXRpYyBjb25zdCB1aW50NjRfdCBobW1f cmFuZ2VfZmxhZ3NbSE1NX1BGTl9GTEFHX01BWF0gPSB7Ci0JCSgxIDw8IDApLCAvKiBITU1fUEZO X1ZBTElEICovCi0JCSgxIDw8IDEpLCAvKiBITU1fUEZOX1dSSVRFICovCi0JCTAgLyogSE1NX1BG Tl9ERVZJQ0VfUFJJVkFURSAqLwotfTsKLQotc3RhdGljIGNvbnN0IHVpbnQ2NF90IGhtbV9yYW5n ZV92YWx1ZXNbSE1NX1BGTl9WQUxVRV9NQVhdID0gewotCQkweGZmZmZmZmZmZmZmZmZmZmVVTCwg LyogSE1NX1BGTl9FUlJPUiAqLwotCQkwLCAvKiBITU1fUEZOX05PTkUgKi8KLQkJMHhmZmZmZmZm ZmZmZmZmZmZjVUwgLyogSE1NX1BGTl9TUEVDSUFMICovCi19OwotCi12b2lkIGFtZGdwdV9obW1f aW5pdF9yYW5nZShzdHJ1Y3QgaG1tX3JhbmdlICpyYW5nZSkKLXsKLQlpZiAocmFuZ2UpIHsKLQkJ cmFuZ2UtPmZsYWdzID0gaG1tX3JhbmdlX2ZsYWdzOwotCQlyYW5nZS0+dmFsdWVzID0gaG1tX3Jh bmdlX3ZhbHVlczsKLQkJcmFuZ2UtPnBmbl9zaGlmdCA9IFBBR0VfU0hJRlQ7Ci0JfQotfQpkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmggYi9kcml2ZXJz L2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uaAppbmRleCBkNzNhYjI5NDdiMjJiMi4uYTI5 MjIzOGY3NWViYWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdw dV9tbi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9tbi5oCkBAIC0z MCw1OSArMzAsMTAgQEAKICNpbmNsdWRlIDxsaW51eC93b3JrcXVldWUuaD4KICNpbmNsdWRlIDxs aW51eC9pbnRlcnZhbF90cmVlLmg+CiAKLWVudW0gYW1kZ3B1X21uX3R5cGUgewotCUFNREdQVV9N Tl9UWVBFX0dGWCwKLQlBTURHUFVfTU5fVFlQRV9IU0EsCi19OwotCi0vKioKLSAqIHN0cnVjdCBh bWRncHVfbW4KLSAqCi0gKiBAYWRldjogYW1kZ3B1IGRldmljZSBwb2ludGVyCi0gKiBAdHlwZTog dHlwZSBvZiBNTVUgbm90aWZpZXIKLSAqIEB3b3JrOiBkZXN0cnVjdGlvbiB3b3JrIGl0ZW0KLSAq IEBub2RlOiBoYXNoIHRhYmxlIG5vZGUgdG8gZmluZCBzdHJ1Y3R1cmUgYnkgYWRldiBhbmQgbW4K LSAqIEBsb2NrOiBydyBzZW1hcGhvcmUgcHJvdGVjdGluZyB0aGUgbm90aWZpZXIgbm9kZXMKLSAq IEBtaXJyb3I6IEhNTSBtaXJyb3IgZnVuY3Rpb24gc3VwcG9ydAotICoKLSAqIERhdGEgZm9yIGVh Y2ggYW1kZ3B1IGRldmljZSBhbmQgcHJvY2VzcyBhZGRyZXNzIHNwYWNlLgotICovCi1zdHJ1Y3Qg YW1kZ3B1X21uIHsKLQkvKiBjb25zdGFudCBhZnRlciBpbml0aWFsaXNhdGlvbiAqLwotCXN0cnVj dCBhbWRncHVfZGV2aWNlCSphZGV2OwotCWVudW0gYW1kZ3B1X21uX3R5cGUJdHlwZTsKLQotCS8q IG9ubHkgdXNlZCBvbiBkZXN0cnVjdGlvbiAqLwotCXN0cnVjdCB3b3JrX3N0cnVjdAl3b3JrOwot Ci0JLyogcHJvdGVjdGVkIGJ5IGFkZXYtPm1uX2xvY2sgKi8KLQlzdHJ1Y3QgaGxpc3Rfbm9kZQlu b2RlOwotCi0JLyogb2JqZWN0cyBwcm90ZWN0ZWQgYnkgbG9jayAqLwotCXN0cnVjdCByd19zZW1h cGhvcmUJbG9jazsKLQotI2lmZGVmIENPTkZJR19ITU1fTUlSUk9SCi0JLyogSE1NIG1pcnJvciAq LwotCXN0cnVjdCBobW1fbWlycm9yCW1pcnJvcjsKLSNlbmRpZgotfTsKLQogI2lmIGRlZmluZWQo Q09ORklHX0hNTV9NSVJST1IpCi12b2lkIGFtZGdwdV9tbl9sb2NrKHN0cnVjdCBhbWRncHVfbW4g Km1uKTsKLXZvaWQgYW1kZ3B1X21uX3VubG9jayhzdHJ1Y3QgYW1kZ3B1X21uICptbik7Ci1zdHJ1 Y3QgYW1kZ3B1X21uICphbWRncHVfbW5fZ2V0KHN0cnVjdCBhbWRncHVfZGV2aWNlICphZGV2LAot CQkJCWVudW0gYW1kZ3B1X21uX3R5cGUgdHlwZSk7CiBpbnQgYW1kZ3B1X21uX3JlZ2lzdGVyKHN0 cnVjdCBhbWRncHVfYm8gKmJvLCB1bnNpZ25lZCBsb25nIGFkZHIpOwogdm9pZCBhbWRncHVfbW5f dW5yZWdpc3RlcihzdHJ1Y3QgYW1kZ3B1X2JvICpibyk7Ci12b2lkIGFtZGdwdV9obW1faW5pdF9y YW5nZShzdHJ1Y3QgaG1tX3JhbmdlICpyYW5nZSk7CiAjZWxzZQotc3RhdGljIGlubGluZSB2b2lk IGFtZGdwdV9tbl9sb2NrKHN0cnVjdCBhbWRncHVfbW4gKm1uKSB7fQotc3RhdGljIGlubGluZSB2 b2lkIGFtZGdwdV9tbl91bmxvY2soc3RydWN0IGFtZGdwdV9tbiAqbW4pIHt9Ci1zdGF0aWMgaW5s aW5lIHN0cnVjdCBhbWRncHVfbW4gKmFtZGdwdV9tbl9nZXQoc3RydWN0IGFtZGdwdV9kZXZpY2Ug KmFkZXYsCi0JCQkJCSAgICAgIGVudW0gYW1kZ3B1X21uX3R5cGUgdHlwZSkKLXsKLQlyZXR1cm4g TlVMTDsKLX0KIHN0YXRpYyBpbmxpbmUgaW50IGFtZGdwdV9tbl9yZWdpc3RlcihzdHJ1Y3QgYW1k Z3B1X2JvICpibywgdW5zaWduZWQgbG9uZyBhZGRyKQogewogCURSTV9XQVJOX09OQ0UoIkhNTV9N SVJST1Iga2VybmVsIGNvbmZpZyBvcHRpb24gaXMgbm90IGVuYWJsZWQsICIKZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV90dG0uYyBiL2RyaXZlcnMvZ3B1L2Ry bS9hbWQvYW1kZ3B1L2FtZGdwdV90dG0uYwppbmRleCBjMGU0MWYxZjBjMjM2NS4uNjVkOTgyNGI1 NGYyYTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV90dG0u YworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfdHRtLmMKQEAgLTc3Myw2 ICs3NzMsMjAgQEAgc3RydWN0IGFtZGdwdV90dG1fdHQgewogI2VuZGlmCiB9OwogCisjaWZkZWYg Q09ORklHX0RSTV9BTURHUFVfVVNFUlBUUgorLyogZmxhZ3MgdXNlZCBieSBITU0gaW50ZXJuYWws IG5vdCByZWxhdGVkIHRvIENQVS9HUFUgUFRFIGZsYWdzICovCitzdGF0aWMgY29uc3QgdWludDY0 X3QgaG1tX3JhbmdlX2ZsYWdzW0hNTV9QRk5fRkxBR19NQVhdID0geworCSgxIDw8IDApLCAvKiBI TU1fUEZOX1ZBTElEICovCisJKDEgPDwgMSksIC8qIEhNTV9QRk5fV1JJVEUgKi8KKwkwIC8qIEhN TV9QRk5fREVWSUNFX1BSSVZBVEUgKi8KK307CisKK3N0YXRpYyBjb25zdCB1aW50NjRfdCBobW1f cmFuZ2VfdmFsdWVzW0hNTV9QRk5fVkFMVUVfTUFYXSA9IHsKKwkweGZmZmZmZmZmZmZmZmZmZmVV TCwgLyogSE1NX1BGTl9FUlJPUiAqLworCTAsIC8qIEhNTV9QRk5fTk9ORSAqLworCTB4ZmZmZmZm ZmZmZmZmZmZmY1VMIC8qIEhNTV9QRk5fU1BFQ0lBTCAqLworfTsKKwogLyoqCiAgKiBhbWRncHVf dHRtX3R0X2dldF91c2VyX3BhZ2VzIC0gZ2V0IGRldmljZSBhY2Nlc3NpYmxlIHBhZ2VzIHRoYXQg YmFjayB1c2VyCiAgKiBtZW1vcnkgYW5kIHN0YXJ0IEhNTSB0cmFja2luZyBDUFUgcGFnZSB0YWJs ZSB1cGRhdGUKQEAgLTc4MCwyOSArNzk0LDI3IEBAIHN0cnVjdCBhbWRncHVfdHRtX3R0IHsKICAq IENhbGxpbmcgZnVuY3Rpb24gbXVzdCBjYWxsIGFtZGdwdV90dG1fdHRfdXNlcnB0cl9yYW5nZV9k b25lKCkgb25jZSBhbmQgb25seQogICogb25jZSBhZnRlcndhcmRzIHRvIHN0b3AgSE1NIHRyYWNr aW5nCiAgKi8KLSNpZiBJU19FTkFCTEVEKENPTkZJR19EUk1fQU1ER1BVX1VTRVJQVFIpCi0KLSNk ZWZpbmUgTUFYX1JFVFJZX0hNTV9SQU5HRV9GQVVMVAkxNgotCiBpbnQgYW1kZ3B1X3R0bV90dF9n ZXRfdXNlcl9wYWdlcyhzdHJ1Y3QgYW1kZ3B1X2JvICpibywgc3RydWN0IHBhZ2UgKipwYWdlcykK IHsKLQlzdHJ1Y3QgaG1tX21pcnJvciAqbWlycm9yID0gYm8tPm1uID8gJmJvLT5tbi0+bWlycm9y IDogTlVMTDsKIAlzdHJ1Y3QgdHRtX3R0ICp0dG0gPSBiby0+dGJvLnR0bTsKIAlzdHJ1Y3QgYW1k Z3B1X3R0bV90dCAqZ3R0ID0gKHZvaWQgKil0dG07CiAJc3RydWN0IG1tX3N0cnVjdCAqbW07CisJ c3RydWN0IGhtbV9yYW5nZSAqcmFuZ2U7CiAJdW5zaWduZWQgbG9uZyBzdGFydCA9IGd0dC0+dXNl cnB0cjsKIAlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYTsKLQlzdHJ1Y3QgaG1tX3JhbmdlICpy YW5nZTsKIAl1bnNpZ25lZCBsb25nIGk7Ci0JdWludDY0X3QgKnBmbnM7CiAJaW50IHIgPSAwOwog Ci0JaWYgKHVubGlrZWx5KCFtaXJyb3IpKSB7Ci0JCURSTV9ERUJVR19EUklWRVIoIkZhaWxlZCB0 byBnZXQgaG1tX21pcnJvclxuIik7CisJbW0gPSBiby0+bm90aWZpZXIubW07CisJaWYgKHVubGlr ZWx5KCFtbSkpIHsKKwkJRFJNX0RFQlVHX0RSSVZFUigiQk8gaXMgbm90IHJlZ2lzdGVyZWQ/XG4i KTsKIAkJcmV0dXJuIC1FRkFVTFQ7CiAJfQogCi0JbW0gPSBtaXJyb3ItPmhtbS0+bW11X25vdGlm aWVyLm1tOworCS8qIEFub3RoZXIgZ2V0X3VzZXJfcGFnZXMgaXMgcnVubmluZyBhdCB0aGUgc2Ft ZSB0aW1lPz8gKi8KKwlpZiAoV0FSTl9PTihndHQtPnJhbmdlKSkKKwkJcmV0dXJuIC1FRkFVTFQ7 CisKIAlpZiAoIW1tZ2V0X25vdF96ZXJvKG1tKSkgLyogSGFwcGVucyBkdXJpbmcgcHJvY2VzcyBz aHV0ZG93biAqLwogCQlyZXR1cm4gLUVTUkNIOwogCkBAIC04MTEsMzAgKzgyMywyNCBAQCBpbnQg YW1kZ3B1X3R0bV90dF9nZXRfdXNlcl9wYWdlcyhzdHJ1Y3QgYW1kZ3B1X2JvICpibywgc3RydWN0 IHBhZ2UgKipwYWdlcykKIAkJciA9IC1FTk9NRU07CiAJCWdvdG8gb3V0OwogCX0KKwlyYW5nZS0+ bm90aWZpZXIgPSAmYm8tPm5vdGlmaWVyOworCXJhbmdlLT5mbGFncyA9IGhtbV9yYW5nZV9mbGFn czsKKwlyYW5nZS0+dmFsdWVzID0gaG1tX3JhbmdlX3ZhbHVlczsKKwlyYW5nZS0+cGZuX3NoaWZ0 ID0gUEFHRV9TSElGVDsKKwlyYW5nZS0+c3RhcnQgPSBiby0+bm90aWZpZXIuaW50ZXJ2YWxfdHJl ZS5zdGFydDsKKwlyYW5nZS0+ZW5kID0gYm8tPm5vdGlmaWVyLmludGVydmFsX3RyZWUubGFzdCAr IDE7CisJcmFuZ2UtPmRlZmF1bHRfZmxhZ3MgPSBobW1fcmFuZ2VfZmxhZ3NbSE1NX1BGTl9WQUxJ RF07CisJaWYgKCFhbWRncHVfdHRtX3R0X2lzX3JlYWRvbmx5KHR0bSkpCisJCXJhbmdlLT5kZWZh dWx0X2ZsYWdzIHw9IHJhbmdlLT5mbGFnc1tITU1fUEZOX1dSSVRFXTsKIAotCXBmbnMgPSBrdm1h bGxvY19hcnJheSh0dG0tPm51bV9wYWdlcywgc2l6ZW9mKCpwZm5zKSwgR0ZQX0tFUk5FTCk7Ci0J aWYgKHVubGlrZWx5KCFwZm5zKSkgeworCXJhbmdlLT5wZm5zID0ga3ZtYWxsb2NfYXJyYXkodHRt LT5udW1fcGFnZXMsIHNpemVvZigqcmFuZ2UtPnBmbnMpLAorCQkJCSAgICAgR0ZQX0tFUk5FTCk7 CisJaWYgKHVubGlrZWx5KCFyYW5nZS0+cGZucykpIHsKIAkJciA9IC1FTk9NRU07CiAJCWdvdG8g b3V0X2ZyZWVfcmFuZ2VzOwogCX0KIAotCWFtZGdwdV9obW1faW5pdF9yYW5nZShyYW5nZSk7Ci0J cmFuZ2UtPmRlZmF1bHRfZmxhZ3MgPSByYW5nZS0+ZmxhZ3NbSE1NX1BGTl9WQUxJRF07Ci0JcmFu Z2UtPmRlZmF1bHRfZmxhZ3MgfD0gYW1kZ3B1X3R0bV90dF9pc19yZWFkb25seSh0dG0pID8KLQkJ CQkwIDogcmFuZ2UtPmZsYWdzW0hNTV9QRk5fV1JJVEVdOwotCXJhbmdlLT5wZm5fZmxhZ3NfbWFz ayA9IDA7Ci0JcmFuZ2UtPnBmbnMgPSBwZm5zOwotCXJhbmdlLT5zdGFydCA9IHN0YXJ0OwotCXJh bmdlLT5lbmQgPSBzdGFydCArIHR0bS0+bnVtX3BhZ2VzICogUEFHRV9TSVpFOwotCi0JaG1tX3Jh bmdlX3JlZ2lzdGVyKHJhbmdlLCBtaXJyb3IpOwotCi0JLyoKLQkgKiBKdXN0IHdhaXQgZm9yIHJh bmdlIHRvIGJlIHZhbGlkLCBzYWZlIHRvIGlnbm9yZSByZXR1cm4gdmFsdWUgYXMgd2UKLQkgKiB3 aWxsIHVzZSB0aGUgcmV0dXJuIHZhbHVlIG9mIGhtbV9yYW5nZV9mYXVsdCgpIGJlbG93IHVuZGVy IHRoZQotCSAqIG1tYXBfc2VtIHRvIGFzY2VydGFpbiB0aGUgdmFsaWRpdHkgb2YgdGhlIHJhbmdl LgotCSAqLwotCWhtbV9yYW5nZV93YWl0X3VudGlsX3ZhbGlkKHJhbmdlLCBITU1fUkFOR0VfREVG QVVMVF9USU1FT1VUKTsKKwlyYW5nZS0+bm90aWZpZXJfc2VxID0gbW11X3JhbmdlX3JlYWRfYmVn aW4oJmJvLT5ub3RpZmllcik7CiAKIAlkb3duX3JlYWQoJm1tLT5tbWFwX3NlbSk7CiAJdm1hID0g ZmluZF92bWEobW0sIHN0YXJ0KTsKQEAgLTg1NSwxMCArODYxLDEwIEBAIGludCBhbWRncHVfdHRt X3R0X2dldF91c2VyX3BhZ2VzKHN0cnVjdCBhbWRncHVfYm8gKmJvLCBzdHJ1Y3QgcGFnZSAqKnBh Z2VzKQogCQlnb3RvIG91dF9mcmVlX3BmbnM7CiAKIAlmb3IgKGkgPSAwOyBpIDwgdHRtLT5udW1f cGFnZXM7IGkrKykgewotCQlwYWdlc1tpXSA9IGhtbV9kZXZpY2VfZW50cnlfdG9fcGFnZShyYW5n ZSwgcGZuc1tpXSk7CisJCXBhZ2VzW2ldID0gaG1tX2RldmljZV9lbnRyeV90b19wYWdlKHJhbmdl LCByYW5nZS0+cGZuc1tpXSk7CiAJCWlmICh1bmxpa2VseSghcGFnZXNbaV0pKSB7CiAJCQlwcl9l cnIoIlBhZ2UgZmF1bHQgZmFpbGVkIGZvciBwZm5bJWx1XSA9IDB4JWxseFxuIiwKLQkJCSAgICAg ICBpLCBwZm5zW2ldKTsKKwkJCSAgICAgICBpLCByYW5nZS0+cGZuc1tpXSk7CiAJCQlyID0gLUVO T01FTTsKIAogCQkJZ290byBvdXRfZnJlZV9wZm5zOwpAQCAtODczLDggKzg3OSw3IEBAIGludCBh bWRncHVfdHRtX3R0X2dldF91c2VyX3BhZ2VzKHN0cnVjdCBhbWRncHVfYm8gKmJvLCBzdHJ1Y3Qg cGFnZSAqKnBhZ2VzKQogb3V0X3VubG9jazoKIAl1cF9yZWFkKCZtbS0+bW1hcF9zZW0pOwogb3V0 X2ZyZWVfcGZuczoKLQlobW1fcmFuZ2VfdW5yZWdpc3RlcihyYW5nZSk7Ci0Ja3ZmcmVlKHBmbnMp OworCWt2ZnJlZShyYW5nZS0+cGZucyk7CiBvdXRfZnJlZV9yYW5nZXM6CiAJa2ZyZWUocmFuZ2Up Owogb3V0OgpAQCAtOTAzLDkgKzkwOCw4IEBAIGJvb2wgYW1kZ3B1X3R0bV90dF9nZXRfdXNlcl9w YWdlc19kb25lKHN0cnVjdCB0dG1fdHQgKnR0bSkKIAkJIk5vIHVzZXIgcGFnZXMgdG8gY2hlY2tc biIpOwogCiAJaWYgKGd0dC0+cmFuZ2UpIHsKLQkJciA9IGhtbV9yYW5nZV92YWxpZChndHQtPnJh bmdlKTsKLQkJaG1tX3JhbmdlX3VucmVnaXN0ZXIoZ3R0LT5yYW5nZSk7Ci0KKwkJciA9IG1tdV9y YW5nZV9yZWFkX3JldHJ5KGd0dC0+cmFuZ2UtPm5vdGlmaWVyLAorCQkJCQkgZ3R0LT5yYW5nZS0+ bm90aWZpZXJfc2VxKTsKIAkJa3ZmcmVlKGd0dC0+cmFuZ2UtPnBmbnMpOwogCQlrZnJlZShndHQt PnJhbmdlKTsKIAkJZ3R0LT5yYW5nZSA9IE5VTEw7Ci0tIAoyLjIzLjAKCl9fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QK ZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9w Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbA== 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 60FAACA9EC0 for ; Mon, 28 Oct 2019 20:12:02 +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 27D8A208C0 for ; Mon, 28 Oct 2019 20:12:02 +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="ZMZ20vhD" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 27D8A208C0 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 1iPBMc-0001tS-7L; Mon, 28 Oct 2019 20:11:42 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1iPBMa-0001sc-Oo for xen-devel@lists.xenproject.org; Mon, 28 Oct 2019 20:11:40 +0000 X-Inumbo-ID: 0971d524-f9bf-11e9-bbab-bc764e2007e4 Received: from mail-qk1-x743.google.com (unknown [2607:f8b0:4864:20::743]) by us1-rack-iad1.inumbo.com (Halon) with ESMTPS id 0971d524-f9bf-11e9-bbab-bc764e2007e4; Mon, 28 Oct 2019 20:10:50 +0000 (UTC) Received: by mail-qk1-x743.google.com with SMTP id g21so9746886qkm.11 for ; Mon, 28 Oct 2019 13:10:50 -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=kWAFXaairmju5dUouyI0fIFpVoVh+rRI3GJkG/c3jbo=; b=ZMZ20vhDqRatgd/VeNs+gakMuIFZXaMsb6XQWoUK9HXLD+PHirdDumPc851+WT2Hyf C1Iv1wiPN6IlkT/5OzHp2qTA3MHXJcFx6P54sX18cmGOfENyUr/3lvF7WB/e9idjitHy lGg8W7hcfUwYhCtTo+P5QwNkSGSXWLHrmB7UiWpkznO/5PpvIjO4rkGK5oPJe284j39Z 0SrDdsATeTt0aysE+Vjhm+ODlfdb0SYunqwjoByjas1/pFQCfKFMrcffBKQilclNwoJN Kw57TFwiQGNXYLPWr/vN3hajssQSFf3odyyUW2L2YFJ1wLFryfEwL6Mj/wjl8DvBS7u6 6HmA== 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=kWAFXaairmju5dUouyI0fIFpVoVh+rRI3GJkG/c3jbo=; b=B2HNisO76pcvbS4AVTda9X1EdWeCeRJ0ImTDhY8AEHVtLzH4daNNjgOiGOa7L90Mt0 63/RTPOWciN0PKul9BxEfccQD2XMMtnnbYqutEe1IZKAHjEy3gZNuiTMx1eM//IsM6Hv QqFoIurRekDjbeeKz4Joa9CWCjyWNtx9Jw7eIgLu2v7DK6mnnJoAPaEPHvbL66/q4QhD ab6/e6ticKtDcRSUNLOfuAqw3GcJb5ikLgOts3UGnw3AHJpDCTFBdSKtzZAuyvF1P/Rc 1XH1hlxhKTJBbpxqD7p543mjFmxhTj0tUyee5z9yQch+eW02lOqO9qLN3Qufdhdlxr+u /cow== X-Gm-Message-State: APjAAAWeZwjJGWVlc7HwnXqaEu58KnQ3bb1LjuSaqvhnvze7J6ZjWjDv PE/X7NH7JI94++iqhTv54gw6eA== X-Google-Smtp-Source: APXvYqyexUtgyT46O4Xj8Sx5B6Zyp9sP915KnVYaCPjwqJLiYtfebmqJR+ZAbE7J5Hww5Pxy2DBZEA== X-Received: by 2002:a05:620a:13f0:: with SMTP id h16mr17732993qkl.310.1572293449993; Mon, 28 Oct 2019 13:10:49 -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 o1sm7821379qtb.82.2019.10.28.13.10.44 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Mon, 28 Oct 2019 13:10:48 -0700 (PDT) Received: from jgg by mlx.ziepe.ca with local (Exim 4.90_1) (envelope-from ) id 1iPBLf-0001hL-Mi; 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:31 -0300 Message-Id: <20191028201032.6352-15-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 14/15] drm/amdgpu: Use mmu_range_notifier instead of hmm_mirror 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 , Oleksandr Andrushchenko , linux-rdma@vger.kernel.org, nouveau@lists.freedesktop.org, Dennis Dalessandro , amd-gfx@lists.freedesktop.org, 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" RnJvbTogSmFzb24gR3VudGhvcnBlIDxqZ2dAbWVsbGFub3guY29tPgoKQ29udmVydCB0aGUgY29s bGlzaW9uLXJldHJ5IGxvY2sgYXJvdW5kIGhtbV9yYW5nZV9mYXVsdCB0byB1c2UgdGhlIG9uZSBu b3cKcHJvdmlkZWQgYnkgdGhlIG1tdV9yYW5nZSBub3RpZmllci4KCkFsdGhvdWdoIHRoaXMgZHJp dmVyIGRvZXMgbm90IHNlZW0gdG8gdXNlIHRoZSBjb2xsaXNpb24gcmV0cnkgbG9jayB0aGF0Cmht bSBwcm92aWRlcyBjb3JyZWN0bHksIGl0IGNhbiBzdGlsbCBiZSBjb252ZXJ0ZWQgb3ZlciB0byB1 c2UgdGhlCm1tdV9yYW5nZV9ub3RpZmllciBhcGkgaW5zdGVhZCBvZiBobW1fbWlycm9yIHdpdGhv dXQgdG9vIG11Y2ggdHJvdWJsZS4KClRoaXMgYWxzbyBkZWxldGVzIGFub3RoZXIgcGxhY2Ugd2hl cmUgYSBkcml2ZXIgaXMgYXNzb2NpYXRpbmcgYWRkaXRpb25hbApkYXRhIChzdHJ1Y3QgYW1kZ3B1 X21uKSB3aXRoIGEgbW11X3N0cnVjdC4KCkNjOiBBbGV4IERldWNoZXIgPGFsZXhhbmRlci5kZXVj aGVyQGFtZC5jb20+CkNjOiBDaHJpc3RpYW4gS8O2bmlnIDxjaHJpc3RpYW4ua29lbmlnQGFtZC5j b20+CkNjOiBEYXZpZCAoQ2h1bk1pbmcpIFpob3UgPERhdmlkMS5aaG91QGFtZC5jb20+CkNjOiBh bWQtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpTaWduZWQtb2ZmLWJ5OiBKYXNvbiBHdW50aG9y cGUgPGpnZ0BtZWxsYW5veC5jb20+Ci0tLQogLi4uL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVf YW1ka2ZkX2dwdXZtLmMgIHwgICA0ICsKIGRyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdw dV9jcy5jICAgICAgICB8ICAxNCArLQogZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1 X21uLmMgICAgICAgIHwgMTQ4ICsrLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy9ncHUvZHJtL2Ft ZC9hbWRncHUvYW1kZ3B1X21uLmggICAgICAgIHwgIDQ5IC0tLS0tLQogZHJpdmVycy9ncHUvZHJt L2FtZC9hbWRncHUvYW1kZ3B1X3R0bS5jICAgICAgIHwgIDc2ICsrKystLS0tLQogNSBmaWxlcyBj aGFuZ2VkLCA2NiBpbnNlcnRpb25zKCspLCAyMjUgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2FtZGtmZF9ncHV2bS5jIGIvZHJpdmVy cy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2FtZGtmZF9ncHV2bS5jCmluZGV4IDQ3NzAwMzAy YTA4YjdmLi4xYmNlZGI5YjQ3N2RjZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FtZC9h bWRncHUvYW1kZ3B1X2FtZGtmZF9ncHV2bS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1k Z3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYwpAQCAtMTczOCw2ICsxNzM4LDEwIEBAIHN0YXRpYyBp bnQgdXBkYXRlX2ludmFsaWRfdXNlcl9wYWdlcyhzdHJ1Y3QgYW1ka2ZkX3Byb2Nlc3NfaW5mbyAq cHJvY2Vzc19pbmZvLAogCQkJcmV0dXJuIHJldDsKIAkJfQogCisJCS8qCisJCSAqIEZJWE1FOiBD YW5ub3QgaWdub3JlIHRoZSByZXR1cm4gY29kZSwgbXVzdCBob2xkCisJCSAqIG5vdGlmaWVyX2xv Y2sKKwkJICovCiAJCWFtZGdwdV90dG1fdHRfZ2V0X3VzZXJfcGFnZXNfZG9uZShiby0+dGJvLnR0 bSk7CiAKIAkJLyogTWFyayB0aGUgQk8gYXMgdmFsaWQgdW5sZXNzIGl0IHdhcyBpbnZhbGlkYXRl ZApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2NzLmMgYi9k cml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfY3MuYwppbmRleCAyZTUzZmVlZDQwZTIz MC4uNzY3NzFmNWYwYjYwYWIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1 L2FtZGdwdV9jcy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9jcy5j CkBAIC02MDcsOCArNjA3LDYgQEAgc3RhdGljIGludCBhbWRncHVfY3NfcGFyc2VyX2JvcyhzdHJ1 Y3QgYW1kZ3B1X2NzX3BhcnNlciAqcCwKIAkJZS0+dHYubnVtX3NoYXJlZCA9IDI7CiAKIAlhbWRn cHVfYm9fbGlzdF9nZXRfbGlzdChwLT5ib19saXN0LCAmcC0+dmFsaWRhdGVkKTsKLQlpZiAocC0+ Ym9fbGlzdC0+Zmlyc3RfdXNlcnB0ciAhPSBwLT5ib19saXN0LT5udW1fZW50cmllcykKLQkJcC0+ bW4gPSBhbWRncHVfbW5fZ2V0KHAtPmFkZXYsIEFNREdQVV9NTl9UWVBFX0dGWCk7CiAKIAlJTklU X0xJU1RfSEVBRCgmZHVwbGljYXRlcyk7CiAJYW1kZ3B1X3ZtX2dldF9wZF9ibygmZnByaXYtPnZt LCAmcC0+dmFsaWRhdGVkLCAmcC0+dm1fcGQpOwpAQCAtMTI5MSwxMSArMTI4OSwxMSBAQCBzdGF0 aWMgaW50IGFtZGdwdV9jc19zdWJtaXQoc3RydWN0IGFtZGdwdV9jc19wYXJzZXIgKnAsCiAJaWYg KHIpCiAJCWdvdG8gZXJyb3JfdW5sb2NrOwogCi0JLyogTm8gbWVtb3J5IGFsbG9jYXRpb24gaXMg YWxsb3dlZCB3aGlsZSBob2xkaW5nIHRoZSBtbiBsb2NrLgotCSAqIHAtPm1uIGlzIGhvbGQgdW50 aWwgYW1kZ3B1X2NzX3N1Ym1pdCBpcyBmaW5pc2hlZCBhbmQgZmVuY2UgaXMgYWRkZWQKLQkgKiB0 byBCT3MuCisJLyogTm8gbWVtb3J5IGFsbG9jYXRpb24gaXMgYWxsb3dlZCB3aGlsZSBob2xkaW5n IHRoZSBub3RpZmllciBsb2NrLgorCSAqIFRoZSBsb2NrIGlzIGhlbGQgdW50aWwgYW1kZ3B1X2Nz X3N1Ym1pdCBpcyBmaW5pc2hlZCBhbmQgZmVuY2UgaXMKKwkgKiBhZGRlZCB0byBCT3MuCiAJICov Ci0JYW1kZ3B1X21uX2xvY2socC0+bW4pOworCW11dGV4X2xvY2soJnAtPmFkZXYtPm5vdGlmaWVy X2xvY2spOwogCiAJLyogSWYgdXNlcnB0ciBhcmUgaW52YWxpZGF0ZWQgYWZ0ZXIgYW1kZ3B1X2Nz X3BhcnNlcl9ib3MoKSwgcmV0dXJuCiAJICogLUVBR0FJTiwgZHJtSW9jdGwgaW4gbGliZHJtIHdp bGwgcmVzdGFydCB0aGUgYW1kZ3B1X2NzX2lvY3RsLgpAQCAtMTMzOCwxMyArMTMzNiwxMyBAQCBz dGF0aWMgaW50IGFtZGdwdV9jc19zdWJtaXQoc3RydWN0IGFtZGdwdV9jc19wYXJzZXIgKnAsCiAJ YW1kZ3B1X3ZtX21vdmVfdG9fbHJ1X3RhaWwocC0+YWRldiwgJmZwcml2LT52bSk7CiAKIAl0dG1f ZXVfZmVuY2VfYnVmZmVyX29iamVjdHMoJnAtPnRpY2tldCwgJnAtPnZhbGlkYXRlZCwgcC0+ZmVu Y2UpOwotCWFtZGdwdV9tbl91bmxvY2socC0+bW4pOworCW11dGV4X3VubG9jaygmcC0+YWRldi0+ bm90aWZpZXJfbG9jayk7CiAKIAlyZXR1cm4gMDsKIAogZXJyb3JfYWJvcnQ6CiAJZHJtX3NjaGVk X2pvYl9jbGVhbnVwKCZqb2ItPmJhc2UpOwotCWFtZGdwdV9tbl91bmxvY2socC0+bW4pOworCW11 dGV4X3VubG9jaygmcC0+YWRldi0+bm90aWZpZXJfbG9jayk7CiAKIGVycm9yX3VubG9jazoKIAlh bWRncHVfam9iX2ZyZWUoam9iKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1k Z3B1L2FtZGdwdV9tbi5jIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmMK aW5kZXggNGZmZDdiOTBmNGQ5MDcuLmNiNzE4YTA2NGViNDkxIDEwMDY0NAotLS0gYS9kcml2ZXJz L2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1k L2FtZGdwdS9hbWRncHVfbW4uYwpAQCAtNTAsMjggKzUwLDYgQEAKICNpbmNsdWRlICJhbWRncHUu aCIKICNpbmNsdWRlICJhbWRncHVfYW1ka2ZkLmgiCiAKLS8qKgotICogYW1kZ3B1X21uX2xvY2sg LSB0YWtlIHRoZSB3cml0ZSBzaWRlIGxvY2sgZm9yIHRoaXMgbm90aWZpZXIKLSAqCi0gKiBAbW46 IG91ciBub3RpZmllcgotICovCi12b2lkIGFtZGdwdV9tbl9sb2NrKHN0cnVjdCBhbWRncHVfbW4g Km1uKQotewotCWlmIChtbikKLQkJZG93bl93cml0ZSgmbW4tPmxvY2spOwotfQotCi0vKioKLSAq IGFtZGdwdV9tbl91bmxvY2sgLSBkcm9wIHRoZSB3cml0ZSBzaWRlIGxvY2sgZm9yIHRoaXMgbm90 aWZpZXIKLSAqCi0gKiBAbW46IG91ciBub3RpZmllcgotICovCi12b2lkIGFtZGdwdV9tbl91bmxv Y2soc3RydWN0IGFtZGdwdV9tbiAqbW4pCi17Ci0JaWYgKG1uKQotCQl1cF93cml0ZSgmbW4tPmxv Y2spOwotfQotCiAvKioKICAqIGFtZGdwdV9tbl9pbnZhbGlkYXRlX2dmeCAtIGNhbGxiYWNrIHRv IG5vdGlmeSBhYm91dCBtbSBjaGFuZ2UKICAqCkBAIC04MiwxMiArNjAsMTkgQEAgdm9pZCBhbWRn cHVfbW5fdW5sb2NrKHN0cnVjdCBhbWRncHVfbW4gKm1uKQogICogcG90ZW50aWFsbHkgZGlydHku CiAgKi8KIHN0YXRpYyBib29sIGFtZGdwdV9tbl9pbnZhbGlkYXRlX2dmeChzdHJ1Y3QgbW11X3Jh bmdlX25vdGlmaWVyICptcm4sCi0JCQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3Jh bmdlICpyYW5nZSkKKwkJCQkgICAgIGNvbnN0IHN0cnVjdCBtbXVfbm90aWZpZXJfcmFuZ2UgKnJh bmdlLAorCQkJCSAgICAgdW5zaWduZWQgbG9uZyBjdXJfc2VxKQogewogCXN0cnVjdCBhbWRncHVf Ym8gKmJvID0gY29udGFpbmVyX29mKG1ybiwgc3RydWN0IGFtZGdwdV9ibywgbm90aWZpZXIpOwog CXN0cnVjdCBhbWRncHVfZGV2aWNlICphZGV2ID0gYW1kZ3B1X3R0bV9hZGV2KGJvLT50Ym8uYmRl dik7CiAJbG9uZyByOwogCisJLyoKKwkgKiBGSVhNRTogTXVzdCBob2xkIHNvbWUgbG9jayBzaGFy ZWQgd2l0aAorCSAqIGFtZGdwdV90dG1fdHRfZ2V0X3VzZXJfcGFnZXNfZG9uZSgpCisJICovCisJ bW11X3JhbmdlX3NldF9zZXEobXJuLCBjdXJfc2VxKTsKKwogCS8qIEZJWE1FOiBJcyB0aGlzIG5l Y2Vzc2FyeT8gKi8KIAlpZiAoIWFtZGdwdV90dG1fdHRfYWZmZWN0X3VzZXJwdHIoYm8tPnRiby50 dG0sIHJhbmdlLT5zdGFydCwKIAkJCQkJICByYW5nZS0+ZW5kKSkKQEAgLTExOSwxMSArMTA0LDE4 IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyX29wcyBhbWRncHVfbW5f Z2Z4X29wcyA9IHsKICAqIGV2aWN0aW5nIGFsbCB1c2VyLW1vZGUgcXVldWVzIG9mIHRoZSBwcm9j ZXNzLgogICovCiBzdGF0aWMgYm9vbCBhbWRncHVfbW5faW52YWxpZGF0ZV9oc2Eoc3RydWN0IG1t dV9yYW5nZV9ub3RpZmllciAqbXJuLAotCQkJCSAgICAgY29uc3Qgc3RydWN0IG1tdV9ub3RpZmll cl9yYW5nZSAqcmFuZ2UpCisJCQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3Jhbmdl ICpyYW5nZSwKKwkJCQkgICAgIHVuc2lnbmVkIGxvbmcgY3VyX3NlcSkKIHsKIAlzdHJ1Y3QgYW1k Z3B1X2JvICpibyA9IGNvbnRhaW5lcl9vZihtcm4sIHN0cnVjdCBhbWRncHVfYm8sIG5vdGlmaWVy KTsKIAlzdHJ1Y3QgYW1kZ3B1X2RldmljZSAqYWRldiA9IGFtZGdwdV90dG1fYWRldihiby0+dGJv LmJkZXYpOwogCisJLyoKKwkgKiBGSVhNRTogTXVzdCBob2xkIHNvbWUgbG9jayBzaGFyZWQgd2l0 aAorCSAqIGFtZGdwdV90dG1fdHRfZ2V0X3VzZXJfcGFnZXNfZG9uZSgpCisJICovCisJbW11X3Jh bmdlX3NldF9zZXEobXJuLCBjdXJfc2VxKTsKKwogCS8qIEZJWE1FOiBJcyB0aGlzIG5lY2Vzc2Fy eT8gKi8KIAlpZiAoIWFtZGdwdV90dG1fdHRfYWZmZWN0X3VzZXJwdHIoYm8tPnRiby50dG0sIHJh bmdlLT5zdGFydCwKIAkJCQkJICByYW5nZS0+ZW5kKSkKQEAgLTE0Myw5MiArMTM1LDYgQEAgc3Rh dGljIGNvbnN0IHN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXJfb3BzIGFtZGdwdV9tbl9oc2Ffb3Bz ID0gewogCS5pbnZhbGlkYXRlID0gYW1kZ3B1X21uX2ludmFsaWRhdGVfaHNhLAogfTsKIAotc3Rh dGljIGludCBhbWRncHVfbW5fc3luY19wYWdldGFibGVzKHN0cnVjdCBobW1fbWlycm9yICptaXJy b3IsCi0JCQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICp1cGRhdGUpCi17 Ci0Jc3RydWN0IGFtZGdwdV9tbiAqYW1uID0gY29udGFpbmVyX29mKG1pcnJvciwgc3RydWN0IGFt ZGdwdV9tbiwgbWlycm9yKTsKLQotCWlmICghbW11X25vdGlmaWVyX3JhbmdlX2Jsb2NrYWJsZSh1 cGRhdGUpKQotCQlyZXR1cm4gZmFsc2U7Ci0KLQlkb3duX3JlYWQoJmFtbi0+bG9jayk7Ci0JdXBf cmVhZCgmYW1uLT5sb2NrKTsKLQlyZXR1cm4gMDsKLX0KLQotLyogTG93IGJpdHMgb2YgYW55IHJl YXNvbmFibGUgbW0gcG9pbnRlciB3aWxsIGJlIHVudXNlZCBkdWUgdG8gc3RydWN0Ci0gKiBhbGln bm1lbnQuIFVzZSB0aGVzZSBiaXRzIHRvIG1ha2UgYSB1bmlxdWUga2V5IGZyb20gdGhlIG1tIHBv aW50ZXIKLSAqIGFuZCBub3RpZmllciB0eXBlLgotICovCi0jZGVmaW5lIEFNREdQVV9NTl9LRVko bW0sIHR5cGUpICgodW5zaWduZWQgbG9uZykobW0pICsgKHR5cGUpKQotCi1zdGF0aWMgc3RydWN0 IGhtbV9taXJyb3Jfb3BzIGFtZGdwdV9obW1fbWlycm9yX29wc1tdID0gewotCVtBTURHUFVfTU5f VFlQRV9HRlhdID0gewotCQkuc3luY19jcHVfZGV2aWNlX3BhZ2V0YWJsZXMgPSBhbWRncHVfbW5f c3luY19wYWdldGFibGVzLAotCX0sCi0JW0FNREdQVV9NTl9UWVBFX0hTQV0gPSB7Ci0JCS5zeW5j X2NwdV9kZXZpY2VfcGFnZXRhYmxlcyA9IGFtZGdwdV9tbl9zeW5jX3BhZ2V0YWJsZXMsCi0JfSwK LX07Ci0KLS8qKgotICogYW1kZ3B1X21uX2dldCAtIGNyZWF0ZSBITU0gbWlycm9yIGNvbnRleHQK LSAqCi0gKiBAYWRldjogYW1kZ3B1IGRldmljZSBwb2ludGVyCi0gKiBAdHlwZTogdHlwZSBvZiBN TVUgbm90aWZpZXIgY29udGV4dAotICoKLSAqIENyZWF0ZXMgYSBITU0gbWlycm9yIGNvbnRleHQg Zm9yIGN1cnJlbnQtPm1tLgotICovCi1zdHJ1Y3QgYW1kZ3B1X21uICphbWRncHVfbW5fZ2V0KHN0 cnVjdCBhbWRncHVfZGV2aWNlICphZGV2LAotCQkJCWVudW0gYW1kZ3B1X21uX3R5cGUgdHlwZSkK LXsKLQlzdHJ1Y3QgbW1fc3RydWN0ICptbSA9IGN1cnJlbnQtPm1tOwotCXN0cnVjdCBhbWRncHVf bW4gKmFtbjsKLQl1bnNpZ25lZCBsb25nIGtleSA9IEFNREdQVV9NTl9LRVkobW0sIHR5cGUpOwot CWludCByOwotCi0JbXV0ZXhfbG9jaygmYWRldi0+bW5fbG9jayk7Ci0JaWYgKGRvd25fd3JpdGVf a2lsbGFibGUoJm1tLT5tbWFwX3NlbSkpIHsKLQkJbXV0ZXhfdW5sb2NrKCZhZGV2LT5tbl9sb2Nr KTsKLQkJcmV0dXJuIEVSUl9QVFIoLUVJTlRSKTsKLQl9Ci0KLQloYXNoX2Zvcl9lYWNoX3Bvc3Np YmxlKGFkZXYtPm1uX2hhc2gsIGFtbiwgbm9kZSwga2V5KQotCQlpZiAoQU1ER1BVX01OX0tFWShh bW4tPm1pcnJvci5obW0tPm1tdV9ub3RpZmllci5tbSwKLQkJCQkgIGFtbi0+dHlwZSkgPT0ga2V5 KQotCQkJZ290byByZWxlYXNlX2xvY2tzOwotCi0JYW1uID0ga3phbGxvYyhzaXplb2YoKmFtbiks IEdGUF9LRVJORUwpOwotCWlmICghYW1uKSB7Ci0JCWFtbiA9IEVSUl9QVFIoLUVOT01FTSk7Ci0J CWdvdG8gcmVsZWFzZV9sb2NrczsKLQl9Ci0KLQlhbW4tPmFkZXYgPSBhZGV2OwotCWluaXRfcndz ZW0oJmFtbi0+bG9jayk7Ci0JYW1uLT50eXBlID0gdHlwZTsKLQotCWFtbi0+bWlycm9yLm9wcyA9 ICZhbWRncHVfaG1tX21pcnJvcl9vcHNbdHlwZV07Ci0JciA9IGhtbV9taXJyb3JfcmVnaXN0ZXIo JmFtbi0+bWlycm9yLCBtbSk7Ci0JaWYgKHIpCi0JCWdvdG8gZnJlZV9hbW47Ci0KLQloYXNoX2Fk ZChhZGV2LT5tbl9oYXNoLCAmYW1uLT5ub2RlLCBBTURHUFVfTU5fS0VZKG1tLCB0eXBlKSk7Ci0K LXJlbGVhc2VfbG9ja3M6Ci0JdXBfd3JpdGUoJm1tLT5tbWFwX3NlbSk7Ci0JbXV0ZXhfdW5sb2Nr KCZhZGV2LT5tbl9sb2NrKTsKLQotCXJldHVybiBhbW47Ci0KLWZyZWVfYW1uOgotCXVwX3dyaXRl KCZtbS0+bW1hcF9zZW0pOwotCW11dGV4X3VubG9jaygmYWRldi0+bW5fbG9jayk7Ci0Ja2ZyZWUo YW1uKTsKLQotCXJldHVybiBFUlJfUFRSKHIpOwotfQotCiAvKioKICAqIGFtZGdwdV9tbl9yZWdp c3RlciAtIHJlZ2lzdGVyIGEgQk8gZm9yIG5vdGlmaWVyIHVwZGF0ZXMKICAqCkBAIC0yNjMsMjUg KzE2OSwzIEBAIHZvaWQgYW1kZ3B1X21uX3VucmVnaXN0ZXIoc3RydWN0IGFtZGdwdV9ibyAqYm8p CiAJbW11X3JhbmdlX25vdGlmaWVyX3JlbW92ZSgmYm8tPm5vdGlmaWVyKTsKIAliby0+bm90aWZp ZXIubW0gPSBOVUxMOwogfQotCi0vKiBmbGFncyB1c2VkIGJ5IEhNTSBpbnRlcm5hbCwgbm90IHJl bGF0ZWQgdG8gQ1BVL0dQVSBQVEUgZmxhZ3MgKi8KLXN0YXRpYyBjb25zdCB1aW50NjRfdCBobW1f cmFuZ2VfZmxhZ3NbSE1NX1BGTl9GTEFHX01BWF0gPSB7Ci0JCSgxIDw8IDApLCAvKiBITU1fUEZO X1ZBTElEICovCi0JCSgxIDw8IDEpLCAvKiBITU1fUEZOX1dSSVRFICovCi0JCTAgLyogSE1NX1BG Tl9ERVZJQ0VfUFJJVkFURSAqLwotfTsKLQotc3RhdGljIGNvbnN0IHVpbnQ2NF90IGhtbV9yYW5n ZV92YWx1ZXNbSE1NX1BGTl9WQUxVRV9NQVhdID0gewotCQkweGZmZmZmZmZmZmZmZmZmZmVVTCwg LyogSE1NX1BGTl9FUlJPUiAqLwotCQkwLCAvKiBITU1fUEZOX05PTkUgKi8KLQkJMHhmZmZmZmZm ZmZmZmZmZmZjVUwgLyogSE1NX1BGTl9TUEVDSUFMICovCi19OwotCi12b2lkIGFtZGdwdV9obW1f aW5pdF9yYW5nZShzdHJ1Y3QgaG1tX3JhbmdlICpyYW5nZSkKLXsKLQlpZiAocmFuZ2UpIHsKLQkJ cmFuZ2UtPmZsYWdzID0gaG1tX3JhbmdlX2ZsYWdzOwotCQlyYW5nZS0+dmFsdWVzID0gaG1tX3Jh bmdlX3ZhbHVlczsKLQkJcmFuZ2UtPnBmbl9zaGlmdCA9IFBBR0VfU0hJRlQ7Ci0JfQotfQpkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmggYi9kcml2ZXJz L2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uaAppbmRleCBkNzNhYjI5NDdiMjJiMi4uYTI5 MjIzOGY3NWViYWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdw dV9tbi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9tbi5oCkBAIC0z MCw1OSArMzAsMTAgQEAKICNpbmNsdWRlIDxsaW51eC93b3JrcXVldWUuaD4KICNpbmNsdWRlIDxs aW51eC9pbnRlcnZhbF90cmVlLmg+CiAKLWVudW0gYW1kZ3B1X21uX3R5cGUgewotCUFNREdQVV9N Tl9UWVBFX0dGWCwKLQlBTURHUFVfTU5fVFlQRV9IU0EsCi19OwotCi0vKioKLSAqIHN0cnVjdCBh bWRncHVfbW4KLSAqCi0gKiBAYWRldjogYW1kZ3B1IGRldmljZSBwb2ludGVyCi0gKiBAdHlwZTog dHlwZSBvZiBNTVUgbm90aWZpZXIKLSAqIEB3b3JrOiBkZXN0cnVjdGlvbiB3b3JrIGl0ZW0KLSAq IEBub2RlOiBoYXNoIHRhYmxlIG5vZGUgdG8gZmluZCBzdHJ1Y3R1cmUgYnkgYWRldiBhbmQgbW4K LSAqIEBsb2NrOiBydyBzZW1hcGhvcmUgcHJvdGVjdGluZyB0aGUgbm90aWZpZXIgbm9kZXMKLSAq IEBtaXJyb3I6IEhNTSBtaXJyb3IgZnVuY3Rpb24gc3VwcG9ydAotICoKLSAqIERhdGEgZm9yIGVh Y2ggYW1kZ3B1IGRldmljZSBhbmQgcHJvY2VzcyBhZGRyZXNzIHNwYWNlLgotICovCi1zdHJ1Y3Qg YW1kZ3B1X21uIHsKLQkvKiBjb25zdGFudCBhZnRlciBpbml0aWFsaXNhdGlvbiAqLwotCXN0cnVj dCBhbWRncHVfZGV2aWNlCSphZGV2OwotCWVudW0gYW1kZ3B1X21uX3R5cGUJdHlwZTsKLQotCS8q IG9ubHkgdXNlZCBvbiBkZXN0cnVjdGlvbiAqLwotCXN0cnVjdCB3b3JrX3N0cnVjdAl3b3JrOwot Ci0JLyogcHJvdGVjdGVkIGJ5IGFkZXYtPm1uX2xvY2sgKi8KLQlzdHJ1Y3QgaGxpc3Rfbm9kZQlu b2RlOwotCi0JLyogb2JqZWN0cyBwcm90ZWN0ZWQgYnkgbG9jayAqLwotCXN0cnVjdCByd19zZW1h cGhvcmUJbG9jazsKLQotI2lmZGVmIENPTkZJR19ITU1fTUlSUk9SCi0JLyogSE1NIG1pcnJvciAq LwotCXN0cnVjdCBobW1fbWlycm9yCW1pcnJvcjsKLSNlbmRpZgotfTsKLQogI2lmIGRlZmluZWQo Q09ORklHX0hNTV9NSVJST1IpCi12b2lkIGFtZGdwdV9tbl9sb2NrKHN0cnVjdCBhbWRncHVfbW4g Km1uKTsKLXZvaWQgYW1kZ3B1X21uX3VubG9jayhzdHJ1Y3QgYW1kZ3B1X21uICptbik7Ci1zdHJ1 Y3QgYW1kZ3B1X21uICphbWRncHVfbW5fZ2V0KHN0cnVjdCBhbWRncHVfZGV2aWNlICphZGV2LAot CQkJCWVudW0gYW1kZ3B1X21uX3R5cGUgdHlwZSk7CiBpbnQgYW1kZ3B1X21uX3JlZ2lzdGVyKHN0 cnVjdCBhbWRncHVfYm8gKmJvLCB1bnNpZ25lZCBsb25nIGFkZHIpOwogdm9pZCBhbWRncHVfbW5f dW5yZWdpc3RlcihzdHJ1Y3QgYW1kZ3B1X2JvICpibyk7Ci12b2lkIGFtZGdwdV9obW1faW5pdF9y YW5nZShzdHJ1Y3QgaG1tX3JhbmdlICpyYW5nZSk7CiAjZWxzZQotc3RhdGljIGlubGluZSB2b2lk IGFtZGdwdV9tbl9sb2NrKHN0cnVjdCBhbWRncHVfbW4gKm1uKSB7fQotc3RhdGljIGlubGluZSB2 b2lkIGFtZGdwdV9tbl91bmxvY2soc3RydWN0IGFtZGdwdV9tbiAqbW4pIHt9Ci1zdGF0aWMgaW5s aW5lIHN0cnVjdCBhbWRncHVfbW4gKmFtZGdwdV9tbl9nZXQoc3RydWN0IGFtZGdwdV9kZXZpY2Ug KmFkZXYsCi0JCQkJCSAgICAgIGVudW0gYW1kZ3B1X21uX3R5cGUgdHlwZSkKLXsKLQlyZXR1cm4g TlVMTDsKLX0KIHN0YXRpYyBpbmxpbmUgaW50IGFtZGdwdV9tbl9yZWdpc3RlcihzdHJ1Y3QgYW1k Z3B1X2JvICpibywgdW5zaWduZWQgbG9uZyBhZGRyKQogewogCURSTV9XQVJOX09OQ0UoIkhNTV9N SVJST1Iga2VybmVsIGNvbmZpZyBvcHRpb24gaXMgbm90IGVuYWJsZWQsICIKZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV90dG0uYyBiL2RyaXZlcnMvZ3B1L2Ry bS9hbWQvYW1kZ3B1L2FtZGdwdV90dG0uYwppbmRleCBjMGU0MWYxZjBjMjM2NS4uNjVkOTgyNGI1 NGYyYTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV90dG0u YworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfdHRtLmMKQEAgLTc3Myw2 ICs3NzMsMjAgQEAgc3RydWN0IGFtZGdwdV90dG1fdHQgewogI2VuZGlmCiB9OwogCisjaWZkZWYg Q09ORklHX0RSTV9BTURHUFVfVVNFUlBUUgorLyogZmxhZ3MgdXNlZCBieSBITU0gaW50ZXJuYWws IG5vdCByZWxhdGVkIHRvIENQVS9HUFUgUFRFIGZsYWdzICovCitzdGF0aWMgY29uc3QgdWludDY0 X3QgaG1tX3JhbmdlX2ZsYWdzW0hNTV9QRk5fRkxBR19NQVhdID0geworCSgxIDw8IDApLCAvKiBI TU1fUEZOX1ZBTElEICovCisJKDEgPDwgMSksIC8qIEhNTV9QRk5fV1JJVEUgKi8KKwkwIC8qIEhN TV9QRk5fREVWSUNFX1BSSVZBVEUgKi8KK307CisKK3N0YXRpYyBjb25zdCB1aW50NjRfdCBobW1f cmFuZ2VfdmFsdWVzW0hNTV9QRk5fVkFMVUVfTUFYXSA9IHsKKwkweGZmZmZmZmZmZmZmZmZmZmVV TCwgLyogSE1NX1BGTl9FUlJPUiAqLworCTAsIC8qIEhNTV9QRk5fTk9ORSAqLworCTB4ZmZmZmZm ZmZmZmZmZmZmY1VMIC8qIEhNTV9QRk5fU1BFQ0lBTCAqLworfTsKKwogLyoqCiAgKiBhbWRncHVf dHRtX3R0X2dldF91c2VyX3BhZ2VzIC0gZ2V0IGRldmljZSBhY2Nlc3NpYmxlIHBhZ2VzIHRoYXQg YmFjayB1c2VyCiAgKiBtZW1vcnkgYW5kIHN0YXJ0IEhNTSB0cmFja2luZyBDUFUgcGFnZSB0YWJs ZSB1cGRhdGUKQEAgLTc4MCwyOSArNzk0LDI3IEBAIHN0cnVjdCBhbWRncHVfdHRtX3R0IHsKICAq IENhbGxpbmcgZnVuY3Rpb24gbXVzdCBjYWxsIGFtZGdwdV90dG1fdHRfdXNlcnB0cl9yYW5nZV9k b25lKCkgb25jZSBhbmQgb25seQogICogb25jZSBhZnRlcndhcmRzIHRvIHN0b3AgSE1NIHRyYWNr aW5nCiAgKi8KLSNpZiBJU19FTkFCTEVEKENPTkZJR19EUk1fQU1ER1BVX1VTRVJQVFIpCi0KLSNk ZWZpbmUgTUFYX1JFVFJZX0hNTV9SQU5HRV9GQVVMVAkxNgotCiBpbnQgYW1kZ3B1X3R0bV90dF9n ZXRfdXNlcl9wYWdlcyhzdHJ1Y3QgYW1kZ3B1X2JvICpibywgc3RydWN0IHBhZ2UgKipwYWdlcykK IHsKLQlzdHJ1Y3QgaG1tX21pcnJvciAqbWlycm9yID0gYm8tPm1uID8gJmJvLT5tbi0+bWlycm9y IDogTlVMTDsKIAlzdHJ1Y3QgdHRtX3R0ICp0dG0gPSBiby0+dGJvLnR0bTsKIAlzdHJ1Y3QgYW1k Z3B1X3R0bV90dCAqZ3R0ID0gKHZvaWQgKil0dG07CiAJc3RydWN0IG1tX3N0cnVjdCAqbW07CisJ c3RydWN0IGhtbV9yYW5nZSAqcmFuZ2U7CiAJdW5zaWduZWQgbG9uZyBzdGFydCA9IGd0dC0+dXNl cnB0cjsKIAlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYTsKLQlzdHJ1Y3QgaG1tX3JhbmdlICpy YW5nZTsKIAl1bnNpZ25lZCBsb25nIGk7Ci0JdWludDY0X3QgKnBmbnM7CiAJaW50IHIgPSAwOwog Ci0JaWYgKHVubGlrZWx5KCFtaXJyb3IpKSB7Ci0JCURSTV9ERUJVR19EUklWRVIoIkZhaWxlZCB0 byBnZXQgaG1tX21pcnJvclxuIik7CisJbW0gPSBiby0+bm90aWZpZXIubW07CisJaWYgKHVubGlr ZWx5KCFtbSkpIHsKKwkJRFJNX0RFQlVHX0RSSVZFUigiQk8gaXMgbm90IHJlZ2lzdGVyZWQ/XG4i KTsKIAkJcmV0dXJuIC1FRkFVTFQ7CiAJfQogCi0JbW0gPSBtaXJyb3ItPmhtbS0+bW11X25vdGlm aWVyLm1tOworCS8qIEFub3RoZXIgZ2V0X3VzZXJfcGFnZXMgaXMgcnVubmluZyBhdCB0aGUgc2Ft ZSB0aW1lPz8gKi8KKwlpZiAoV0FSTl9PTihndHQtPnJhbmdlKSkKKwkJcmV0dXJuIC1FRkFVTFQ7 CisKIAlpZiAoIW1tZ2V0X25vdF96ZXJvKG1tKSkgLyogSGFwcGVucyBkdXJpbmcgcHJvY2VzcyBz aHV0ZG93biAqLwogCQlyZXR1cm4gLUVTUkNIOwogCkBAIC04MTEsMzAgKzgyMywyNCBAQCBpbnQg YW1kZ3B1X3R0bV90dF9nZXRfdXNlcl9wYWdlcyhzdHJ1Y3QgYW1kZ3B1X2JvICpibywgc3RydWN0 IHBhZ2UgKipwYWdlcykKIAkJciA9IC1FTk9NRU07CiAJCWdvdG8gb3V0OwogCX0KKwlyYW5nZS0+ bm90aWZpZXIgPSAmYm8tPm5vdGlmaWVyOworCXJhbmdlLT5mbGFncyA9IGhtbV9yYW5nZV9mbGFn czsKKwlyYW5nZS0+dmFsdWVzID0gaG1tX3JhbmdlX3ZhbHVlczsKKwlyYW5nZS0+cGZuX3NoaWZ0 ID0gUEFHRV9TSElGVDsKKwlyYW5nZS0+c3RhcnQgPSBiby0+bm90aWZpZXIuaW50ZXJ2YWxfdHJl ZS5zdGFydDsKKwlyYW5nZS0+ZW5kID0gYm8tPm5vdGlmaWVyLmludGVydmFsX3RyZWUubGFzdCAr IDE7CisJcmFuZ2UtPmRlZmF1bHRfZmxhZ3MgPSBobW1fcmFuZ2VfZmxhZ3NbSE1NX1BGTl9WQUxJ RF07CisJaWYgKCFhbWRncHVfdHRtX3R0X2lzX3JlYWRvbmx5KHR0bSkpCisJCXJhbmdlLT5kZWZh dWx0X2ZsYWdzIHw9IHJhbmdlLT5mbGFnc1tITU1fUEZOX1dSSVRFXTsKIAotCXBmbnMgPSBrdm1h bGxvY19hcnJheSh0dG0tPm51bV9wYWdlcywgc2l6ZW9mKCpwZm5zKSwgR0ZQX0tFUk5FTCk7Ci0J aWYgKHVubGlrZWx5KCFwZm5zKSkgeworCXJhbmdlLT5wZm5zID0ga3ZtYWxsb2NfYXJyYXkodHRt LT5udW1fcGFnZXMsIHNpemVvZigqcmFuZ2UtPnBmbnMpLAorCQkJCSAgICAgR0ZQX0tFUk5FTCk7 CisJaWYgKHVubGlrZWx5KCFyYW5nZS0+cGZucykpIHsKIAkJciA9IC1FTk9NRU07CiAJCWdvdG8g b3V0X2ZyZWVfcmFuZ2VzOwogCX0KIAotCWFtZGdwdV9obW1faW5pdF9yYW5nZShyYW5nZSk7Ci0J cmFuZ2UtPmRlZmF1bHRfZmxhZ3MgPSByYW5nZS0+ZmxhZ3NbSE1NX1BGTl9WQUxJRF07Ci0JcmFu Z2UtPmRlZmF1bHRfZmxhZ3MgfD0gYW1kZ3B1X3R0bV90dF9pc19yZWFkb25seSh0dG0pID8KLQkJ CQkwIDogcmFuZ2UtPmZsYWdzW0hNTV9QRk5fV1JJVEVdOwotCXJhbmdlLT5wZm5fZmxhZ3NfbWFz ayA9IDA7Ci0JcmFuZ2UtPnBmbnMgPSBwZm5zOwotCXJhbmdlLT5zdGFydCA9IHN0YXJ0OwotCXJh bmdlLT5lbmQgPSBzdGFydCArIHR0bS0+bnVtX3BhZ2VzICogUEFHRV9TSVpFOwotCi0JaG1tX3Jh bmdlX3JlZ2lzdGVyKHJhbmdlLCBtaXJyb3IpOwotCi0JLyoKLQkgKiBKdXN0IHdhaXQgZm9yIHJh bmdlIHRvIGJlIHZhbGlkLCBzYWZlIHRvIGlnbm9yZSByZXR1cm4gdmFsdWUgYXMgd2UKLQkgKiB3 aWxsIHVzZSB0aGUgcmV0dXJuIHZhbHVlIG9mIGhtbV9yYW5nZV9mYXVsdCgpIGJlbG93IHVuZGVy IHRoZQotCSAqIG1tYXBfc2VtIHRvIGFzY2VydGFpbiB0aGUgdmFsaWRpdHkgb2YgdGhlIHJhbmdl LgotCSAqLwotCWhtbV9yYW5nZV93YWl0X3VudGlsX3ZhbGlkKHJhbmdlLCBITU1fUkFOR0VfREVG QVVMVF9USU1FT1VUKTsKKwlyYW5nZS0+bm90aWZpZXJfc2VxID0gbW11X3JhbmdlX3JlYWRfYmVn aW4oJmJvLT5ub3RpZmllcik7CiAKIAlkb3duX3JlYWQoJm1tLT5tbWFwX3NlbSk7CiAJdm1hID0g ZmluZF92bWEobW0sIHN0YXJ0KTsKQEAgLTg1NSwxMCArODYxLDEwIEBAIGludCBhbWRncHVfdHRt X3R0X2dldF91c2VyX3BhZ2VzKHN0cnVjdCBhbWRncHVfYm8gKmJvLCBzdHJ1Y3QgcGFnZSAqKnBh Z2VzKQogCQlnb3RvIG91dF9mcmVlX3BmbnM7CiAKIAlmb3IgKGkgPSAwOyBpIDwgdHRtLT5udW1f cGFnZXM7IGkrKykgewotCQlwYWdlc1tpXSA9IGhtbV9kZXZpY2VfZW50cnlfdG9fcGFnZShyYW5n ZSwgcGZuc1tpXSk7CisJCXBhZ2VzW2ldID0gaG1tX2RldmljZV9lbnRyeV90b19wYWdlKHJhbmdl LCByYW5nZS0+cGZuc1tpXSk7CiAJCWlmICh1bmxpa2VseSghcGFnZXNbaV0pKSB7CiAJCQlwcl9l cnIoIlBhZ2UgZmF1bHQgZmFpbGVkIGZvciBwZm5bJWx1XSA9IDB4JWxseFxuIiwKLQkJCSAgICAg ICBpLCBwZm5zW2ldKTsKKwkJCSAgICAgICBpLCByYW5nZS0+cGZuc1tpXSk7CiAJCQlyID0gLUVO T01FTTsKIAogCQkJZ290byBvdXRfZnJlZV9wZm5zOwpAQCAtODczLDggKzg3OSw3IEBAIGludCBh bWRncHVfdHRtX3R0X2dldF91c2VyX3BhZ2VzKHN0cnVjdCBhbWRncHVfYm8gKmJvLCBzdHJ1Y3Qg cGFnZSAqKnBhZ2VzKQogb3V0X3VubG9jazoKIAl1cF9yZWFkKCZtbS0+bW1hcF9zZW0pOwogb3V0 X2ZyZWVfcGZuczoKLQlobW1fcmFuZ2VfdW5yZWdpc3RlcihyYW5nZSk7Ci0Ja3ZmcmVlKHBmbnMp OworCWt2ZnJlZShyYW5nZS0+cGZucyk7CiBvdXRfZnJlZV9yYW5nZXM6CiAJa2ZyZWUocmFuZ2Up Owogb3V0OgpAQCAtOTAzLDkgKzkwOCw4IEBAIGJvb2wgYW1kZ3B1X3R0bV90dF9nZXRfdXNlcl9w YWdlc19kb25lKHN0cnVjdCB0dG1fdHQgKnR0bSkKIAkJIk5vIHVzZXIgcGFnZXMgdG8gY2hlY2tc biIpOwogCiAJaWYgKGd0dC0+cmFuZ2UpIHsKLQkJciA9IGhtbV9yYW5nZV92YWxpZChndHQtPnJh bmdlKTsKLQkJaG1tX3JhbmdlX3VucmVnaXN0ZXIoZ3R0LT5yYW5nZSk7Ci0KKwkJciA9IG1tdV9y YW5nZV9yZWFkX3JldHJ5KGd0dC0+cmFuZ2UtPm5vdGlmaWVyLAorCQkJCQkgZ3R0LT5yYW5nZS0+ bm90aWZpZXJfc2VxKTsKIAkJa3ZmcmVlKGd0dC0+cmFuZ2UtPnBmbnMpOwogCQlrZnJlZShndHQt PnJhbmdlKTsKIAkJZ3R0LT5yYW5nZSA9IE5VTEw7Ci0tIAoyLjIzLjAKCgpfX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpYZW4tZGV2ZWwgbWFpbGluZyBsaXN0 Clhlbi1kZXZlbEBsaXN0cy54ZW5wcm9qZWN0Lm9yZwpodHRwczovL2xpc3RzLnhlbnByb2plY3Qu b3JnL21haWxtYW4vbGlzdGluZm8veGVuLWRldmVs 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 97159CA9EC1 for ; Mon, 28 Oct 2019 20:17:25 +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 7A51021721 for ; Mon, 28 Oct 2019 20:17:25 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 7A51021721 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 7DD766EA0C; Mon, 28 Oct 2019 20:17:18 +0000 (UTC) Received: from mail-qk1-x742.google.com (mail-qk1-x742.google.com [IPv6:2607:f8b0:4864:20::742]) by gabe.freedesktop.org (Postfix) with ESMTPS id F3BDE89D84 for ; Mon, 28 Oct 2019 20:10:50 +0000 (UTC) Received: by mail-qk1-x742.google.com with SMTP id c25so3545799qkk.1 for ; Mon, 28 Oct 2019 13:10:50 -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=kWAFXaairmju5dUouyI0fIFpVoVh+rRI3GJkG/c3jbo=; b=ooXXXFVMm+lO2vgDIkM+gENv0KlHEcN6oYZC1uBXeX4S7iXMEgp1v00ed8hxL8PZCd ct5vtuPhXfdKEfPckR6eYZh+E5zxjgoaUrdTrSR6p4cLyI1h9ckwItHwkMwJtVvWFdHd SrKw3FTevs0Lr5oK8mEwj1yVpN5hpN5cs0pt79BPKandL3emNk4epn4/fNRGyaYYduyS jE/bRP7Y9jQBRbjRlRS24HPU/F7wf1fudTXJZDRA45/zedjrCq01XTsXW458Ok08ekZa 2iBPixvywnOcT7gNJHjQS12tO8ouB/byuxlhsdN4usY05zNOoiPRh+QuRs9e5pu+TYdw mTIA== X-Gm-Message-State: APjAAAWGT7MSHPxnNO9W+uC3NUXBLIsuzGLHZQ6U4KTep+8pNjyfodwe W5b16VQrci+FQL8x4fJ9SHiYdQ== X-Google-Smtp-Source: APXvYqyexUtgyT46O4Xj8Sx5B6Zyp9sP915KnVYaCPjwqJLiYtfebmqJR+ZAbE7J5Hww5Pxy2DBZEA== X-Received: by 2002:a05:620a:13f0:: with SMTP id h16mr17732993qkl.310.1572293449993; Mon, 28 Oct 2019 13:10:49 -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 o1sm7821379qtb.82.2019.10.28.13.10.44 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Mon, 28 Oct 2019 13:10:48 -0700 (PDT) Received: from jgg by mlx.ziepe.ca with local (Exim 4.90_1) (envelope-from ) id 1iPBLf-0001hL-Mi; 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 14/15] drm/amdgpu: Use mmu_range_notifier instead of hmm_mirror Date: Mon, 28 Oct 2019 17:10:31 -0300 Message-Id: <20191028201032.6352-15-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=kWAFXaairmju5dUouyI0fIFpVoVh+rRI3GJkG/c3jbo=; b=ZMZ20vhDqRatgd/VeNs+gakMuIFZXaMsb6XQWoUK9HXLD+PHirdDumPc851+WT2Hyf C1Iv1wiPN6IlkT/5OzHp2qTA3MHXJcFx6P54sX18cmGOfENyUr/3lvF7WB/e9idjitHy lGg8W7hcfUwYhCtTo+P5QwNkSGSXWLHrmB7UiWpkznO/5PpvIjO4rkGK5oPJe284j39Z 0SrDdsATeTt0aysE+Vjhm+ODlfdb0SYunqwjoByjas1/pFQCfKFMrcffBKQilclNwoJN Kw57TFwiQGNXYLPWr/vN3hajssQSFf3odyyUW2L2YFJ1wLFryfEwL6Mj/wjl8DvBS7u6 6HmA== 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 , Oleksandr Andrushchenko , linux-rdma@vger.kernel.org, nouveau@lists.freedesktop.org, Dennis Dalessandro , amd-gfx@lists.freedesktop.org, 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: <20191028201031.-3ElE-TsT_GdE5P6-REGNh1Ugphc1t29K9gSN9-WIH8@z> RnJvbTogSmFzb24gR3VudGhvcnBlIDxqZ2dAbWVsbGFub3guY29tPgoKQ29udmVydCB0aGUgY29s bGlzaW9uLXJldHJ5IGxvY2sgYXJvdW5kIGhtbV9yYW5nZV9mYXVsdCB0byB1c2UgdGhlIG9uZSBu b3cKcHJvdmlkZWQgYnkgdGhlIG1tdV9yYW5nZSBub3RpZmllci4KCkFsdGhvdWdoIHRoaXMgZHJp dmVyIGRvZXMgbm90IHNlZW0gdG8gdXNlIHRoZSBjb2xsaXNpb24gcmV0cnkgbG9jayB0aGF0Cmht bSBwcm92aWRlcyBjb3JyZWN0bHksIGl0IGNhbiBzdGlsbCBiZSBjb252ZXJ0ZWQgb3ZlciB0byB1 c2UgdGhlCm1tdV9yYW5nZV9ub3RpZmllciBhcGkgaW5zdGVhZCBvZiBobW1fbWlycm9yIHdpdGhv dXQgdG9vIG11Y2ggdHJvdWJsZS4KClRoaXMgYWxzbyBkZWxldGVzIGFub3RoZXIgcGxhY2Ugd2hl cmUgYSBkcml2ZXIgaXMgYXNzb2NpYXRpbmcgYWRkaXRpb25hbApkYXRhIChzdHJ1Y3QgYW1kZ3B1 X21uKSB3aXRoIGEgbW11X3N0cnVjdC4KCkNjOiBBbGV4IERldWNoZXIgPGFsZXhhbmRlci5kZXVj aGVyQGFtZC5jb20+CkNjOiBDaHJpc3RpYW4gS8O2bmlnIDxjaHJpc3RpYW4ua29lbmlnQGFtZC5j b20+CkNjOiBEYXZpZCAoQ2h1bk1pbmcpIFpob3UgPERhdmlkMS5aaG91QGFtZC5jb20+CkNjOiBh bWQtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpTaWduZWQtb2ZmLWJ5OiBKYXNvbiBHdW50aG9y cGUgPGpnZ0BtZWxsYW5veC5jb20+Ci0tLQogLi4uL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVf YW1ka2ZkX2dwdXZtLmMgIHwgICA0ICsKIGRyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdw dV9jcy5jICAgICAgICB8ICAxNCArLQogZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1 X21uLmMgICAgICAgIHwgMTQ4ICsrLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy9ncHUvZHJtL2Ft ZC9hbWRncHUvYW1kZ3B1X21uLmggICAgICAgIHwgIDQ5IC0tLS0tLQogZHJpdmVycy9ncHUvZHJt L2FtZC9hbWRncHUvYW1kZ3B1X3R0bS5jICAgICAgIHwgIDc2ICsrKystLS0tLQogNSBmaWxlcyBj aGFuZ2VkLCA2NiBpbnNlcnRpb25zKCspLCAyMjUgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2FtZGtmZF9ncHV2bS5jIGIvZHJpdmVy cy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2FtZGtmZF9ncHV2bS5jCmluZGV4IDQ3NzAwMzAy YTA4YjdmLi4xYmNlZGI5YjQ3N2RjZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FtZC9h bWRncHUvYW1kZ3B1X2FtZGtmZF9ncHV2bS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1k Z3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYwpAQCAtMTczOCw2ICsxNzM4LDEwIEBAIHN0YXRpYyBp bnQgdXBkYXRlX2ludmFsaWRfdXNlcl9wYWdlcyhzdHJ1Y3QgYW1ka2ZkX3Byb2Nlc3NfaW5mbyAq cHJvY2Vzc19pbmZvLAogCQkJcmV0dXJuIHJldDsKIAkJfQogCisJCS8qCisJCSAqIEZJWE1FOiBD YW5ub3QgaWdub3JlIHRoZSByZXR1cm4gY29kZSwgbXVzdCBob2xkCisJCSAqIG5vdGlmaWVyX2xv Y2sKKwkJICovCiAJCWFtZGdwdV90dG1fdHRfZ2V0X3VzZXJfcGFnZXNfZG9uZShiby0+dGJvLnR0 bSk7CiAKIAkJLyogTWFyayB0aGUgQk8gYXMgdmFsaWQgdW5sZXNzIGl0IHdhcyBpbnZhbGlkYXRl ZApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2NzLmMgYi9k cml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfY3MuYwppbmRleCAyZTUzZmVlZDQwZTIz MC4uNzY3NzFmNWYwYjYwYWIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1 L2FtZGdwdV9jcy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9jcy5j CkBAIC02MDcsOCArNjA3LDYgQEAgc3RhdGljIGludCBhbWRncHVfY3NfcGFyc2VyX2JvcyhzdHJ1 Y3QgYW1kZ3B1X2NzX3BhcnNlciAqcCwKIAkJZS0+dHYubnVtX3NoYXJlZCA9IDI7CiAKIAlhbWRn cHVfYm9fbGlzdF9nZXRfbGlzdChwLT5ib19saXN0LCAmcC0+dmFsaWRhdGVkKTsKLQlpZiAocC0+ Ym9fbGlzdC0+Zmlyc3RfdXNlcnB0ciAhPSBwLT5ib19saXN0LT5udW1fZW50cmllcykKLQkJcC0+ bW4gPSBhbWRncHVfbW5fZ2V0KHAtPmFkZXYsIEFNREdQVV9NTl9UWVBFX0dGWCk7CiAKIAlJTklU X0xJU1RfSEVBRCgmZHVwbGljYXRlcyk7CiAJYW1kZ3B1X3ZtX2dldF9wZF9ibygmZnByaXYtPnZt LCAmcC0+dmFsaWRhdGVkLCAmcC0+dm1fcGQpOwpAQCAtMTI5MSwxMSArMTI4OSwxMSBAQCBzdGF0 aWMgaW50IGFtZGdwdV9jc19zdWJtaXQoc3RydWN0IGFtZGdwdV9jc19wYXJzZXIgKnAsCiAJaWYg KHIpCiAJCWdvdG8gZXJyb3JfdW5sb2NrOwogCi0JLyogTm8gbWVtb3J5IGFsbG9jYXRpb24gaXMg YWxsb3dlZCB3aGlsZSBob2xkaW5nIHRoZSBtbiBsb2NrLgotCSAqIHAtPm1uIGlzIGhvbGQgdW50 aWwgYW1kZ3B1X2NzX3N1Ym1pdCBpcyBmaW5pc2hlZCBhbmQgZmVuY2UgaXMgYWRkZWQKLQkgKiB0 byBCT3MuCisJLyogTm8gbWVtb3J5IGFsbG9jYXRpb24gaXMgYWxsb3dlZCB3aGlsZSBob2xkaW5n IHRoZSBub3RpZmllciBsb2NrLgorCSAqIFRoZSBsb2NrIGlzIGhlbGQgdW50aWwgYW1kZ3B1X2Nz X3N1Ym1pdCBpcyBmaW5pc2hlZCBhbmQgZmVuY2UgaXMKKwkgKiBhZGRlZCB0byBCT3MuCiAJICov Ci0JYW1kZ3B1X21uX2xvY2socC0+bW4pOworCW11dGV4X2xvY2soJnAtPmFkZXYtPm5vdGlmaWVy X2xvY2spOwogCiAJLyogSWYgdXNlcnB0ciBhcmUgaW52YWxpZGF0ZWQgYWZ0ZXIgYW1kZ3B1X2Nz X3BhcnNlcl9ib3MoKSwgcmV0dXJuCiAJICogLUVBR0FJTiwgZHJtSW9jdGwgaW4gbGliZHJtIHdp bGwgcmVzdGFydCB0aGUgYW1kZ3B1X2NzX2lvY3RsLgpAQCAtMTMzOCwxMyArMTMzNiwxMyBAQCBz dGF0aWMgaW50IGFtZGdwdV9jc19zdWJtaXQoc3RydWN0IGFtZGdwdV9jc19wYXJzZXIgKnAsCiAJ YW1kZ3B1X3ZtX21vdmVfdG9fbHJ1X3RhaWwocC0+YWRldiwgJmZwcml2LT52bSk7CiAKIAl0dG1f ZXVfZmVuY2VfYnVmZmVyX29iamVjdHMoJnAtPnRpY2tldCwgJnAtPnZhbGlkYXRlZCwgcC0+ZmVu Y2UpOwotCWFtZGdwdV9tbl91bmxvY2socC0+bW4pOworCW11dGV4X3VubG9jaygmcC0+YWRldi0+ bm90aWZpZXJfbG9jayk7CiAKIAlyZXR1cm4gMDsKIAogZXJyb3JfYWJvcnQ6CiAJZHJtX3NjaGVk X2pvYl9jbGVhbnVwKCZqb2ItPmJhc2UpOwotCWFtZGdwdV9tbl91bmxvY2socC0+bW4pOworCW11 dGV4X3VubG9jaygmcC0+YWRldi0+bm90aWZpZXJfbG9jayk7CiAKIGVycm9yX3VubG9jazoKIAlh bWRncHVfam9iX2ZyZWUoam9iKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1k Z3B1L2FtZGdwdV9tbi5jIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmMK aW5kZXggNGZmZDdiOTBmNGQ5MDcuLmNiNzE4YTA2NGViNDkxIDEwMDY0NAotLS0gYS9kcml2ZXJz L2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1k L2FtZGdwdS9hbWRncHVfbW4uYwpAQCAtNTAsMjggKzUwLDYgQEAKICNpbmNsdWRlICJhbWRncHUu aCIKICNpbmNsdWRlICJhbWRncHVfYW1ka2ZkLmgiCiAKLS8qKgotICogYW1kZ3B1X21uX2xvY2sg LSB0YWtlIHRoZSB3cml0ZSBzaWRlIGxvY2sgZm9yIHRoaXMgbm90aWZpZXIKLSAqCi0gKiBAbW46 IG91ciBub3RpZmllcgotICovCi12b2lkIGFtZGdwdV9tbl9sb2NrKHN0cnVjdCBhbWRncHVfbW4g Km1uKQotewotCWlmIChtbikKLQkJZG93bl93cml0ZSgmbW4tPmxvY2spOwotfQotCi0vKioKLSAq IGFtZGdwdV9tbl91bmxvY2sgLSBkcm9wIHRoZSB3cml0ZSBzaWRlIGxvY2sgZm9yIHRoaXMgbm90 aWZpZXIKLSAqCi0gKiBAbW46IG91ciBub3RpZmllcgotICovCi12b2lkIGFtZGdwdV9tbl91bmxv Y2soc3RydWN0IGFtZGdwdV9tbiAqbW4pCi17Ci0JaWYgKG1uKQotCQl1cF93cml0ZSgmbW4tPmxv Y2spOwotfQotCiAvKioKICAqIGFtZGdwdV9tbl9pbnZhbGlkYXRlX2dmeCAtIGNhbGxiYWNrIHRv IG5vdGlmeSBhYm91dCBtbSBjaGFuZ2UKICAqCkBAIC04MiwxMiArNjAsMTkgQEAgdm9pZCBhbWRn cHVfbW5fdW5sb2NrKHN0cnVjdCBhbWRncHVfbW4gKm1uKQogICogcG90ZW50aWFsbHkgZGlydHku CiAgKi8KIHN0YXRpYyBib29sIGFtZGdwdV9tbl9pbnZhbGlkYXRlX2dmeChzdHJ1Y3QgbW11X3Jh bmdlX25vdGlmaWVyICptcm4sCi0JCQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3Jh bmdlICpyYW5nZSkKKwkJCQkgICAgIGNvbnN0IHN0cnVjdCBtbXVfbm90aWZpZXJfcmFuZ2UgKnJh bmdlLAorCQkJCSAgICAgdW5zaWduZWQgbG9uZyBjdXJfc2VxKQogewogCXN0cnVjdCBhbWRncHVf Ym8gKmJvID0gY29udGFpbmVyX29mKG1ybiwgc3RydWN0IGFtZGdwdV9ibywgbm90aWZpZXIpOwog CXN0cnVjdCBhbWRncHVfZGV2aWNlICphZGV2ID0gYW1kZ3B1X3R0bV9hZGV2KGJvLT50Ym8uYmRl dik7CiAJbG9uZyByOwogCisJLyoKKwkgKiBGSVhNRTogTXVzdCBob2xkIHNvbWUgbG9jayBzaGFy ZWQgd2l0aAorCSAqIGFtZGdwdV90dG1fdHRfZ2V0X3VzZXJfcGFnZXNfZG9uZSgpCisJICovCisJ bW11X3JhbmdlX3NldF9zZXEobXJuLCBjdXJfc2VxKTsKKwogCS8qIEZJWE1FOiBJcyB0aGlzIG5l Y2Vzc2FyeT8gKi8KIAlpZiAoIWFtZGdwdV90dG1fdHRfYWZmZWN0X3VzZXJwdHIoYm8tPnRiby50 dG0sIHJhbmdlLT5zdGFydCwKIAkJCQkJICByYW5nZS0+ZW5kKSkKQEAgLTExOSwxMSArMTA0LDE4 IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyX29wcyBhbWRncHVfbW5f Z2Z4X29wcyA9IHsKICAqIGV2aWN0aW5nIGFsbCB1c2VyLW1vZGUgcXVldWVzIG9mIHRoZSBwcm9j ZXNzLgogICovCiBzdGF0aWMgYm9vbCBhbWRncHVfbW5faW52YWxpZGF0ZV9oc2Eoc3RydWN0IG1t dV9yYW5nZV9ub3RpZmllciAqbXJuLAotCQkJCSAgICAgY29uc3Qgc3RydWN0IG1tdV9ub3RpZmll cl9yYW5nZSAqcmFuZ2UpCisJCQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3Jhbmdl ICpyYW5nZSwKKwkJCQkgICAgIHVuc2lnbmVkIGxvbmcgY3VyX3NlcSkKIHsKIAlzdHJ1Y3QgYW1k Z3B1X2JvICpibyA9IGNvbnRhaW5lcl9vZihtcm4sIHN0cnVjdCBhbWRncHVfYm8sIG5vdGlmaWVy KTsKIAlzdHJ1Y3QgYW1kZ3B1X2RldmljZSAqYWRldiA9IGFtZGdwdV90dG1fYWRldihiby0+dGJv LmJkZXYpOwogCisJLyoKKwkgKiBGSVhNRTogTXVzdCBob2xkIHNvbWUgbG9jayBzaGFyZWQgd2l0 aAorCSAqIGFtZGdwdV90dG1fdHRfZ2V0X3VzZXJfcGFnZXNfZG9uZSgpCisJICovCisJbW11X3Jh bmdlX3NldF9zZXEobXJuLCBjdXJfc2VxKTsKKwogCS8qIEZJWE1FOiBJcyB0aGlzIG5lY2Vzc2Fy eT8gKi8KIAlpZiAoIWFtZGdwdV90dG1fdHRfYWZmZWN0X3VzZXJwdHIoYm8tPnRiby50dG0sIHJh bmdlLT5zdGFydCwKIAkJCQkJICByYW5nZS0+ZW5kKSkKQEAgLTE0Myw5MiArMTM1LDYgQEAgc3Rh dGljIGNvbnN0IHN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXJfb3BzIGFtZGdwdV9tbl9oc2Ffb3Bz ID0gewogCS5pbnZhbGlkYXRlID0gYW1kZ3B1X21uX2ludmFsaWRhdGVfaHNhLAogfTsKIAotc3Rh dGljIGludCBhbWRncHVfbW5fc3luY19wYWdldGFibGVzKHN0cnVjdCBobW1fbWlycm9yICptaXJy b3IsCi0JCQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICp1cGRhdGUpCi17 Ci0Jc3RydWN0IGFtZGdwdV9tbiAqYW1uID0gY29udGFpbmVyX29mKG1pcnJvciwgc3RydWN0IGFt ZGdwdV9tbiwgbWlycm9yKTsKLQotCWlmICghbW11X25vdGlmaWVyX3JhbmdlX2Jsb2NrYWJsZSh1 cGRhdGUpKQotCQlyZXR1cm4gZmFsc2U7Ci0KLQlkb3duX3JlYWQoJmFtbi0+bG9jayk7Ci0JdXBf cmVhZCgmYW1uLT5sb2NrKTsKLQlyZXR1cm4gMDsKLX0KLQotLyogTG93IGJpdHMgb2YgYW55IHJl YXNvbmFibGUgbW0gcG9pbnRlciB3aWxsIGJlIHVudXNlZCBkdWUgdG8gc3RydWN0Ci0gKiBhbGln bm1lbnQuIFVzZSB0aGVzZSBiaXRzIHRvIG1ha2UgYSB1bmlxdWUga2V5IGZyb20gdGhlIG1tIHBv aW50ZXIKLSAqIGFuZCBub3RpZmllciB0eXBlLgotICovCi0jZGVmaW5lIEFNREdQVV9NTl9LRVko bW0sIHR5cGUpICgodW5zaWduZWQgbG9uZykobW0pICsgKHR5cGUpKQotCi1zdGF0aWMgc3RydWN0 IGhtbV9taXJyb3Jfb3BzIGFtZGdwdV9obW1fbWlycm9yX29wc1tdID0gewotCVtBTURHUFVfTU5f VFlQRV9HRlhdID0gewotCQkuc3luY19jcHVfZGV2aWNlX3BhZ2V0YWJsZXMgPSBhbWRncHVfbW5f c3luY19wYWdldGFibGVzLAotCX0sCi0JW0FNREdQVV9NTl9UWVBFX0hTQV0gPSB7Ci0JCS5zeW5j X2NwdV9kZXZpY2VfcGFnZXRhYmxlcyA9IGFtZGdwdV9tbl9zeW5jX3BhZ2V0YWJsZXMsCi0JfSwK LX07Ci0KLS8qKgotICogYW1kZ3B1X21uX2dldCAtIGNyZWF0ZSBITU0gbWlycm9yIGNvbnRleHQK LSAqCi0gKiBAYWRldjogYW1kZ3B1IGRldmljZSBwb2ludGVyCi0gKiBAdHlwZTogdHlwZSBvZiBN TVUgbm90aWZpZXIgY29udGV4dAotICoKLSAqIENyZWF0ZXMgYSBITU0gbWlycm9yIGNvbnRleHQg Zm9yIGN1cnJlbnQtPm1tLgotICovCi1zdHJ1Y3QgYW1kZ3B1X21uICphbWRncHVfbW5fZ2V0KHN0 cnVjdCBhbWRncHVfZGV2aWNlICphZGV2LAotCQkJCWVudW0gYW1kZ3B1X21uX3R5cGUgdHlwZSkK LXsKLQlzdHJ1Y3QgbW1fc3RydWN0ICptbSA9IGN1cnJlbnQtPm1tOwotCXN0cnVjdCBhbWRncHVf bW4gKmFtbjsKLQl1bnNpZ25lZCBsb25nIGtleSA9IEFNREdQVV9NTl9LRVkobW0sIHR5cGUpOwot CWludCByOwotCi0JbXV0ZXhfbG9jaygmYWRldi0+bW5fbG9jayk7Ci0JaWYgKGRvd25fd3JpdGVf a2lsbGFibGUoJm1tLT5tbWFwX3NlbSkpIHsKLQkJbXV0ZXhfdW5sb2NrKCZhZGV2LT5tbl9sb2Nr KTsKLQkJcmV0dXJuIEVSUl9QVFIoLUVJTlRSKTsKLQl9Ci0KLQloYXNoX2Zvcl9lYWNoX3Bvc3Np YmxlKGFkZXYtPm1uX2hhc2gsIGFtbiwgbm9kZSwga2V5KQotCQlpZiAoQU1ER1BVX01OX0tFWShh bW4tPm1pcnJvci5obW0tPm1tdV9ub3RpZmllci5tbSwKLQkJCQkgIGFtbi0+dHlwZSkgPT0ga2V5 KQotCQkJZ290byByZWxlYXNlX2xvY2tzOwotCi0JYW1uID0ga3phbGxvYyhzaXplb2YoKmFtbiks IEdGUF9LRVJORUwpOwotCWlmICghYW1uKSB7Ci0JCWFtbiA9IEVSUl9QVFIoLUVOT01FTSk7Ci0J CWdvdG8gcmVsZWFzZV9sb2NrczsKLQl9Ci0KLQlhbW4tPmFkZXYgPSBhZGV2OwotCWluaXRfcndz ZW0oJmFtbi0+bG9jayk7Ci0JYW1uLT50eXBlID0gdHlwZTsKLQotCWFtbi0+bWlycm9yLm9wcyA9 ICZhbWRncHVfaG1tX21pcnJvcl9vcHNbdHlwZV07Ci0JciA9IGhtbV9taXJyb3JfcmVnaXN0ZXIo JmFtbi0+bWlycm9yLCBtbSk7Ci0JaWYgKHIpCi0JCWdvdG8gZnJlZV9hbW47Ci0KLQloYXNoX2Fk ZChhZGV2LT5tbl9oYXNoLCAmYW1uLT5ub2RlLCBBTURHUFVfTU5fS0VZKG1tLCB0eXBlKSk7Ci0K LXJlbGVhc2VfbG9ja3M6Ci0JdXBfd3JpdGUoJm1tLT5tbWFwX3NlbSk7Ci0JbXV0ZXhfdW5sb2Nr KCZhZGV2LT5tbl9sb2NrKTsKLQotCXJldHVybiBhbW47Ci0KLWZyZWVfYW1uOgotCXVwX3dyaXRl KCZtbS0+bW1hcF9zZW0pOwotCW11dGV4X3VubG9jaygmYWRldi0+bW5fbG9jayk7Ci0Ja2ZyZWUo YW1uKTsKLQotCXJldHVybiBFUlJfUFRSKHIpOwotfQotCiAvKioKICAqIGFtZGdwdV9tbl9yZWdp c3RlciAtIHJlZ2lzdGVyIGEgQk8gZm9yIG5vdGlmaWVyIHVwZGF0ZXMKICAqCkBAIC0yNjMsMjUg KzE2OSwzIEBAIHZvaWQgYW1kZ3B1X21uX3VucmVnaXN0ZXIoc3RydWN0IGFtZGdwdV9ibyAqYm8p CiAJbW11X3JhbmdlX25vdGlmaWVyX3JlbW92ZSgmYm8tPm5vdGlmaWVyKTsKIAliby0+bm90aWZp ZXIubW0gPSBOVUxMOwogfQotCi0vKiBmbGFncyB1c2VkIGJ5IEhNTSBpbnRlcm5hbCwgbm90IHJl bGF0ZWQgdG8gQ1BVL0dQVSBQVEUgZmxhZ3MgKi8KLXN0YXRpYyBjb25zdCB1aW50NjRfdCBobW1f cmFuZ2VfZmxhZ3NbSE1NX1BGTl9GTEFHX01BWF0gPSB7Ci0JCSgxIDw8IDApLCAvKiBITU1fUEZO X1ZBTElEICovCi0JCSgxIDw8IDEpLCAvKiBITU1fUEZOX1dSSVRFICovCi0JCTAgLyogSE1NX1BG Tl9ERVZJQ0VfUFJJVkFURSAqLwotfTsKLQotc3RhdGljIGNvbnN0IHVpbnQ2NF90IGhtbV9yYW5n ZV92YWx1ZXNbSE1NX1BGTl9WQUxVRV9NQVhdID0gewotCQkweGZmZmZmZmZmZmZmZmZmZmVVTCwg LyogSE1NX1BGTl9FUlJPUiAqLwotCQkwLCAvKiBITU1fUEZOX05PTkUgKi8KLQkJMHhmZmZmZmZm ZmZmZmZmZmZjVUwgLyogSE1NX1BGTl9TUEVDSUFMICovCi19OwotCi12b2lkIGFtZGdwdV9obW1f aW5pdF9yYW5nZShzdHJ1Y3QgaG1tX3JhbmdlICpyYW5nZSkKLXsKLQlpZiAocmFuZ2UpIHsKLQkJ cmFuZ2UtPmZsYWdzID0gaG1tX3JhbmdlX2ZsYWdzOwotCQlyYW5nZS0+dmFsdWVzID0gaG1tX3Jh bmdlX3ZhbHVlczsKLQkJcmFuZ2UtPnBmbl9zaGlmdCA9IFBBR0VfU0hJRlQ7Ci0JfQotfQpkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmggYi9kcml2ZXJz L2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uaAppbmRleCBkNzNhYjI5NDdiMjJiMi4uYTI5 MjIzOGY3NWViYWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdw dV9tbi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9tbi5oCkBAIC0z MCw1OSArMzAsMTAgQEAKICNpbmNsdWRlIDxsaW51eC93b3JrcXVldWUuaD4KICNpbmNsdWRlIDxs aW51eC9pbnRlcnZhbF90cmVlLmg+CiAKLWVudW0gYW1kZ3B1X21uX3R5cGUgewotCUFNREdQVV9N Tl9UWVBFX0dGWCwKLQlBTURHUFVfTU5fVFlQRV9IU0EsCi19OwotCi0vKioKLSAqIHN0cnVjdCBh bWRncHVfbW4KLSAqCi0gKiBAYWRldjogYW1kZ3B1IGRldmljZSBwb2ludGVyCi0gKiBAdHlwZTog dHlwZSBvZiBNTVUgbm90aWZpZXIKLSAqIEB3b3JrOiBkZXN0cnVjdGlvbiB3b3JrIGl0ZW0KLSAq IEBub2RlOiBoYXNoIHRhYmxlIG5vZGUgdG8gZmluZCBzdHJ1Y3R1cmUgYnkgYWRldiBhbmQgbW4K LSAqIEBsb2NrOiBydyBzZW1hcGhvcmUgcHJvdGVjdGluZyB0aGUgbm90aWZpZXIgbm9kZXMKLSAq IEBtaXJyb3I6IEhNTSBtaXJyb3IgZnVuY3Rpb24gc3VwcG9ydAotICoKLSAqIERhdGEgZm9yIGVh Y2ggYW1kZ3B1IGRldmljZSBhbmQgcHJvY2VzcyBhZGRyZXNzIHNwYWNlLgotICovCi1zdHJ1Y3Qg YW1kZ3B1X21uIHsKLQkvKiBjb25zdGFudCBhZnRlciBpbml0aWFsaXNhdGlvbiAqLwotCXN0cnVj dCBhbWRncHVfZGV2aWNlCSphZGV2OwotCWVudW0gYW1kZ3B1X21uX3R5cGUJdHlwZTsKLQotCS8q IG9ubHkgdXNlZCBvbiBkZXN0cnVjdGlvbiAqLwotCXN0cnVjdCB3b3JrX3N0cnVjdAl3b3JrOwot Ci0JLyogcHJvdGVjdGVkIGJ5IGFkZXYtPm1uX2xvY2sgKi8KLQlzdHJ1Y3QgaGxpc3Rfbm9kZQlu b2RlOwotCi0JLyogb2JqZWN0cyBwcm90ZWN0ZWQgYnkgbG9jayAqLwotCXN0cnVjdCByd19zZW1h cGhvcmUJbG9jazsKLQotI2lmZGVmIENPTkZJR19ITU1fTUlSUk9SCi0JLyogSE1NIG1pcnJvciAq LwotCXN0cnVjdCBobW1fbWlycm9yCW1pcnJvcjsKLSNlbmRpZgotfTsKLQogI2lmIGRlZmluZWQo Q09ORklHX0hNTV9NSVJST1IpCi12b2lkIGFtZGdwdV9tbl9sb2NrKHN0cnVjdCBhbWRncHVfbW4g Km1uKTsKLXZvaWQgYW1kZ3B1X21uX3VubG9jayhzdHJ1Y3QgYW1kZ3B1X21uICptbik7Ci1zdHJ1 Y3QgYW1kZ3B1X21uICphbWRncHVfbW5fZ2V0KHN0cnVjdCBhbWRncHVfZGV2aWNlICphZGV2LAot CQkJCWVudW0gYW1kZ3B1X21uX3R5cGUgdHlwZSk7CiBpbnQgYW1kZ3B1X21uX3JlZ2lzdGVyKHN0 cnVjdCBhbWRncHVfYm8gKmJvLCB1bnNpZ25lZCBsb25nIGFkZHIpOwogdm9pZCBhbWRncHVfbW5f dW5yZWdpc3RlcihzdHJ1Y3QgYW1kZ3B1X2JvICpibyk7Ci12b2lkIGFtZGdwdV9obW1faW5pdF9y YW5nZShzdHJ1Y3QgaG1tX3JhbmdlICpyYW5nZSk7CiAjZWxzZQotc3RhdGljIGlubGluZSB2b2lk IGFtZGdwdV9tbl9sb2NrKHN0cnVjdCBhbWRncHVfbW4gKm1uKSB7fQotc3RhdGljIGlubGluZSB2 b2lkIGFtZGdwdV9tbl91bmxvY2soc3RydWN0IGFtZGdwdV9tbiAqbW4pIHt9Ci1zdGF0aWMgaW5s aW5lIHN0cnVjdCBhbWRncHVfbW4gKmFtZGdwdV9tbl9nZXQoc3RydWN0IGFtZGdwdV9kZXZpY2Ug KmFkZXYsCi0JCQkJCSAgICAgIGVudW0gYW1kZ3B1X21uX3R5cGUgdHlwZSkKLXsKLQlyZXR1cm4g TlVMTDsKLX0KIHN0YXRpYyBpbmxpbmUgaW50IGFtZGdwdV9tbl9yZWdpc3RlcihzdHJ1Y3QgYW1k Z3B1X2JvICpibywgdW5zaWduZWQgbG9uZyBhZGRyKQogewogCURSTV9XQVJOX09OQ0UoIkhNTV9N SVJST1Iga2VybmVsIGNvbmZpZyBvcHRpb24gaXMgbm90IGVuYWJsZWQsICIKZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV90dG0uYyBiL2RyaXZlcnMvZ3B1L2Ry bS9hbWQvYW1kZ3B1L2FtZGdwdV90dG0uYwppbmRleCBjMGU0MWYxZjBjMjM2NS4uNjVkOTgyNGI1 NGYyYTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV90dG0u YworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfdHRtLmMKQEAgLTc3Myw2 ICs3NzMsMjAgQEAgc3RydWN0IGFtZGdwdV90dG1fdHQgewogI2VuZGlmCiB9OwogCisjaWZkZWYg Q09ORklHX0RSTV9BTURHUFVfVVNFUlBUUgorLyogZmxhZ3MgdXNlZCBieSBITU0gaW50ZXJuYWws IG5vdCByZWxhdGVkIHRvIENQVS9HUFUgUFRFIGZsYWdzICovCitzdGF0aWMgY29uc3QgdWludDY0 X3QgaG1tX3JhbmdlX2ZsYWdzW0hNTV9QRk5fRkxBR19NQVhdID0geworCSgxIDw8IDApLCAvKiBI TU1fUEZOX1ZBTElEICovCisJKDEgPDwgMSksIC8qIEhNTV9QRk5fV1JJVEUgKi8KKwkwIC8qIEhN TV9QRk5fREVWSUNFX1BSSVZBVEUgKi8KK307CisKK3N0YXRpYyBjb25zdCB1aW50NjRfdCBobW1f cmFuZ2VfdmFsdWVzW0hNTV9QRk5fVkFMVUVfTUFYXSA9IHsKKwkweGZmZmZmZmZmZmZmZmZmZmVV TCwgLyogSE1NX1BGTl9FUlJPUiAqLworCTAsIC8qIEhNTV9QRk5fTk9ORSAqLworCTB4ZmZmZmZm ZmZmZmZmZmZmY1VMIC8qIEhNTV9QRk5fU1BFQ0lBTCAqLworfTsKKwogLyoqCiAgKiBhbWRncHVf dHRtX3R0X2dldF91c2VyX3BhZ2VzIC0gZ2V0IGRldmljZSBhY2Nlc3NpYmxlIHBhZ2VzIHRoYXQg YmFjayB1c2VyCiAgKiBtZW1vcnkgYW5kIHN0YXJ0IEhNTSB0cmFja2luZyBDUFUgcGFnZSB0YWJs ZSB1cGRhdGUKQEAgLTc4MCwyOSArNzk0LDI3IEBAIHN0cnVjdCBhbWRncHVfdHRtX3R0IHsKICAq IENhbGxpbmcgZnVuY3Rpb24gbXVzdCBjYWxsIGFtZGdwdV90dG1fdHRfdXNlcnB0cl9yYW5nZV9k b25lKCkgb25jZSBhbmQgb25seQogICogb25jZSBhZnRlcndhcmRzIHRvIHN0b3AgSE1NIHRyYWNr aW5nCiAgKi8KLSNpZiBJU19FTkFCTEVEKENPTkZJR19EUk1fQU1ER1BVX1VTRVJQVFIpCi0KLSNk ZWZpbmUgTUFYX1JFVFJZX0hNTV9SQU5HRV9GQVVMVAkxNgotCiBpbnQgYW1kZ3B1X3R0bV90dF9n ZXRfdXNlcl9wYWdlcyhzdHJ1Y3QgYW1kZ3B1X2JvICpibywgc3RydWN0IHBhZ2UgKipwYWdlcykK IHsKLQlzdHJ1Y3QgaG1tX21pcnJvciAqbWlycm9yID0gYm8tPm1uID8gJmJvLT5tbi0+bWlycm9y IDogTlVMTDsKIAlzdHJ1Y3QgdHRtX3R0ICp0dG0gPSBiby0+dGJvLnR0bTsKIAlzdHJ1Y3QgYW1k Z3B1X3R0bV90dCAqZ3R0ID0gKHZvaWQgKil0dG07CiAJc3RydWN0IG1tX3N0cnVjdCAqbW07CisJ c3RydWN0IGhtbV9yYW5nZSAqcmFuZ2U7CiAJdW5zaWduZWQgbG9uZyBzdGFydCA9IGd0dC0+dXNl cnB0cjsKIAlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYTsKLQlzdHJ1Y3QgaG1tX3JhbmdlICpy YW5nZTsKIAl1bnNpZ25lZCBsb25nIGk7Ci0JdWludDY0X3QgKnBmbnM7CiAJaW50IHIgPSAwOwog Ci0JaWYgKHVubGlrZWx5KCFtaXJyb3IpKSB7Ci0JCURSTV9ERUJVR19EUklWRVIoIkZhaWxlZCB0 byBnZXQgaG1tX21pcnJvclxuIik7CisJbW0gPSBiby0+bm90aWZpZXIubW07CisJaWYgKHVubGlr ZWx5KCFtbSkpIHsKKwkJRFJNX0RFQlVHX0RSSVZFUigiQk8gaXMgbm90IHJlZ2lzdGVyZWQ/XG4i KTsKIAkJcmV0dXJuIC1FRkFVTFQ7CiAJfQogCi0JbW0gPSBtaXJyb3ItPmhtbS0+bW11X25vdGlm aWVyLm1tOworCS8qIEFub3RoZXIgZ2V0X3VzZXJfcGFnZXMgaXMgcnVubmluZyBhdCB0aGUgc2Ft ZSB0aW1lPz8gKi8KKwlpZiAoV0FSTl9PTihndHQtPnJhbmdlKSkKKwkJcmV0dXJuIC1FRkFVTFQ7 CisKIAlpZiAoIW1tZ2V0X25vdF96ZXJvKG1tKSkgLyogSGFwcGVucyBkdXJpbmcgcHJvY2VzcyBz aHV0ZG93biAqLwogCQlyZXR1cm4gLUVTUkNIOwogCkBAIC04MTEsMzAgKzgyMywyNCBAQCBpbnQg YW1kZ3B1X3R0bV90dF9nZXRfdXNlcl9wYWdlcyhzdHJ1Y3QgYW1kZ3B1X2JvICpibywgc3RydWN0 IHBhZ2UgKipwYWdlcykKIAkJciA9IC1FTk9NRU07CiAJCWdvdG8gb3V0OwogCX0KKwlyYW5nZS0+ bm90aWZpZXIgPSAmYm8tPm5vdGlmaWVyOworCXJhbmdlLT5mbGFncyA9IGhtbV9yYW5nZV9mbGFn czsKKwlyYW5nZS0+dmFsdWVzID0gaG1tX3JhbmdlX3ZhbHVlczsKKwlyYW5nZS0+cGZuX3NoaWZ0 ID0gUEFHRV9TSElGVDsKKwlyYW5nZS0+c3RhcnQgPSBiby0+bm90aWZpZXIuaW50ZXJ2YWxfdHJl ZS5zdGFydDsKKwlyYW5nZS0+ZW5kID0gYm8tPm5vdGlmaWVyLmludGVydmFsX3RyZWUubGFzdCAr IDE7CisJcmFuZ2UtPmRlZmF1bHRfZmxhZ3MgPSBobW1fcmFuZ2VfZmxhZ3NbSE1NX1BGTl9WQUxJ RF07CisJaWYgKCFhbWRncHVfdHRtX3R0X2lzX3JlYWRvbmx5KHR0bSkpCisJCXJhbmdlLT5kZWZh dWx0X2ZsYWdzIHw9IHJhbmdlLT5mbGFnc1tITU1fUEZOX1dSSVRFXTsKIAotCXBmbnMgPSBrdm1h bGxvY19hcnJheSh0dG0tPm51bV9wYWdlcywgc2l6ZW9mKCpwZm5zKSwgR0ZQX0tFUk5FTCk7Ci0J aWYgKHVubGlrZWx5KCFwZm5zKSkgeworCXJhbmdlLT5wZm5zID0ga3ZtYWxsb2NfYXJyYXkodHRt LT5udW1fcGFnZXMsIHNpemVvZigqcmFuZ2UtPnBmbnMpLAorCQkJCSAgICAgR0ZQX0tFUk5FTCk7 CisJaWYgKHVubGlrZWx5KCFyYW5nZS0+cGZucykpIHsKIAkJciA9IC1FTk9NRU07CiAJCWdvdG8g b3V0X2ZyZWVfcmFuZ2VzOwogCX0KIAotCWFtZGdwdV9obW1faW5pdF9yYW5nZShyYW5nZSk7Ci0J cmFuZ2UtPmRlZmF1bHRfZmxhZ3MgPSByYW5nZS0+ZmxhZ3NbSE1NX1BGTl9WQUxJRF07Ci0JcmFu Z2UtPmRlZmF1bHRfZmxhZ3MgfD0gYW1kZ3B1X3R0bV90dF9pc19yZWFkb25seSh0dG0pID8KLQkJ CQkwIDogcmFuZ2UtPmZsYWdzW0hNTV9QRk5fV1JJVEVdOwotCXJhbmdlLT5wZm5fZmxhZ3NfbWFz ayA9IDA7Ci0JcmFuZ2UtPnBmbnMgPSBwZm5zOwotCXJhbmdlLT5zdGFydCA9IHN0YXJ0OwotCXJh bmdlLT5lbmQgPSBzdGFydCArIHR0bS0+bnVtX3BhZ2VzICogUEFHRV9TSVpFOwotCi0JaG1tX3Jh bmdlX3JlZ2lzdGVyKHJhbmdlLCBtaXJyb3IpOwotCi0JLyoKLQkgKiBKdXN0IHdhaXQgZm9yIHJh bmdlIHRvIGJlIHZhbGlkLCBzYWZlIHRvIGlnbm9yZSByZXR1cm4gdmFsdWUgYXMgd2UKLQkgKiB3 aWxsIHVzZSB0aGUgcmV0dXJuIHZhbHVlIG9mIGhtbV9yYW5nZV9mYXVsdCgpIGJlbG93IHVuZGVy IHRoZQotCSAqIG1tYXBfc2VtIHRvIGFzY2VydGFpbiB0aGUgdmFsaWRpdHkgb2YgdGhlIHJhbmdl LgotCSAqLwotCWhtbV9yYW5nZV93YWl0X3VudGlsX3ZhbGlkKHJhbmdlLCBITU1fUkFOR0VfREVG QVVMVF9USU1FT1VUKTsKKwlyYW5nZS0+bm90aWZpZXJfc2VxID0gbW11X3JhbmdlX3JlYWRfYmVn aW4oJmJvLT5ub3RpZmllcik7CiAKIAlkb3duX3JlYWQoJm1tLT5tbWFwX3NlbSk7CiAJdm1hID0g ZmluZF92bWEobW0sIHN0YXJ0KTsKQEAgLTg1NSwxMCArODYxLDEwIEBAIGludCBhbWRncHVfdHRt X3R0X2dldF91c2VyX3BhZ2VzKHN0cnVjdCBhbWRncHVfYm8gKmJvLCBzdHJ1Y3QgcGFnZSAqKnBh Z2VzKQogCQlnb3RvIG91dF9mcmVlX3BmbnM7CiAKIAlmb3IgKGkgPSAwOyBpIDwgdHRtLT5udW1f cGFnZXM7IGkrKykgewotCQlwYWdlc1tpXSA9IGhtbV9kZXZpY2VfZW50cnlfdG9fcGFnZShyYW5n ZSwgcGZuc1tpXSk7CisJCXBhZ2VzW2ldID0gaG1tX2RldmljZV9lbnRyeV90b19wYWdlKHJhbmdl LCByYW5nZS0+cGZuc1tpXSk7CiAJCWlmICh1bmxpa2VseSghcGFnZXNbaV0pKSB7CiAJCQlwcl9l cnIoIlBhZ2UgZmF1bHQgZmFpbGVkIGZvciBwZm5bJWx1XSA9IDB4JWxseFxuIiwKLQkJCSAgICAg ICBpLCBwZm5zW2ldKTsKKwkJCSAgICAgICBpLCByYW5nZS0+cGZuc1tpXSk7CiAJCQlyID0gLUVO T01FTTsKIAogCQkJZ290byBvdXRfZnJlZV9wZm5zOwpAQCAtODczLDggKzg3OSw3IEBAIGludCBh bWRncHVfdHRtX3R0X2dldF91c2VyX3BhZ2VzKHN0cnVjdCBhbWRncHVfYm8gKmJvLCBzdHJ1Y3Qg cGFnZSAqKnBhZ2VzKQogb3V0X3VubG9jazoKIAl1cF9yZWFkKCZtbS0+bW1hcF9zZW0pOwogb3V0 X2ZyZWVfcGZuczoKLQlobW1fcmFuZ2VfdW5yZWdpc3RlcihyYW5nZSk7Ci0Ja3ZmcmVlKHBmbnMp OworCWt2ZnJlZShyYW5nZS0+cGZucyk7CiBvdXRfZnJlZV9yYW5nZXM6CiAJa2ZyZWUocmFuZ2Up Owogb3V0OgpAQCAtOTAzLDkgKzkwOCw4IEBAIGJvb2wgYW1kZ3B1X3R0bV90dF9nZXRfdXNlcl9w YWdlc19kb25lKHN0cnVjdCB0dG1fdHQgKnR0bSkKIAkJIk5vIHVzZXIgcGFnZXMgdG8gY2hlY2tc biIpOwogCiAJaWYgKGd0dC0+cmFuZ2UpIHsKLQkJciA9IGhtbV9yYW5nZV92YWxpZChndHQtPnJh bmdlKTsKLQkJaG1tX3JhbmdlX3VucmVnaXN0ZXIoZ3R0LT5yYW5nZSk7Ci0KKwkJciA9IG1tdV9y YW5nZV9yZWFkX3JldHJ5KGd0dC0+cmFuZ2UtPm5vdGlmaWVyLAorCQkJCQkgZ3R0LT5yYW5nZS0+ bm90aWZpZXJfc2VxKTsKIAkJa3ZmcmVlKGd0dC0+cmFuZ2UtPnBmbnMpOwogCQlrZnJlZShndHQt PnJhbmdlKTsKIAkJZ3R0LT5yYW5nZSA9IE5VTEw7Ci0tIAoyLjIzLjAKCl9fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmFtZC1nZnggbWFpbGluZyBsaXN0CmFt ZC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3Jn L21haWxtYW4vbGlzdGluZm8vYW1kLWdmeA==