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,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 43F9FCA9EC0 for ; Mon, 28 Oct 2019 20:21:13 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id F032D21835 for ; Mon, 28 Oct 2019 20:21:12 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=ziepe.ca header.i=@ziepe.ca header.b="l4b6BiRz" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729206AbfJ1UVM (ORCPT ); Mon, 28 Oct 2019 16:21:12 -0400 Received: from mail-qt1-f194.google.com ([209.85.160.194]:44855 "EHLO mail-qt1-f194.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727581AbfJ1UVM (ORCPT ); Mon, 28 Oct 2019 16:21:12 -0400 Received: by mail-qt1-f194.google.com with SMTP id z22so16541400qtq.11 for ; Mon, 28 Oct 2019 13:21:11 -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=f54wq5BOB+L91cuUIb1GfXpGUvNo7lL3IgdsSk0oLWI=; b=l4b6BiRzQbpC7T2GUxlPwjsdxPoQOk1FEPvAXONkG/JTKYB9azNhf74H1C4wi7aQSp 8A9jFV987xM6BpaBeNouD/l/GAxvjknDJS/NO03bddceTqett3RlzyU2OehGxRCGAxRx VRLi47+XEZkpQBZ079F1MnS9P763EC47IrVHlcaPUxwm9kP9JrnJ3RFygb28rTnhXydF 5FzebAKk3jhDaSXSdwhUukrFq7F5R19QvmFj8uU5j3Di5Kj9qaNRbbV/6rmYeeL0Df9a HzbpJ23C0BmdJ2aw1hETLPxUaEfvdYquQMl+Ku4SHxEshKk7ymPS56K6cQKlUnwCjURY RJ4g== 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=f54wq5BOB+L91cuUIb1GfXpGUvNo7lL3IgdsSk0oLWI=; b=b+S5Za7ANX+sgEie5/KbThQAH7Hsm1W/huxZ2ZpP3irs81ZNbEQgSDAWcN4+5Ymu1l h8xZOysxLJzfg5OD8TGK1VsbieH/MH4RDjUu5ZrAs0Wvy+Wq+PUth2/RoAJJET//6IBO zcWx/32rakl2DRXbHTfnIX/6jAKsjL+pBffxioub4lPMHncVScF8ZFx+OW2mqconCgOQ 1bl/dWo1RVRB3IOvlbrsVtO2mOrprtcypjP1KSJQT1Fb+7VS4DKamuo7FBjH+G0WNX0e 8TrEpjAyOHeKDe3ULf69efidrxJjfcMq3yPrshm4L1YsW9nMfMEy7wkSdKYw783asedn wBKQ== X-Gm-Message-State: APjAAAVOtiqN7ao2T4tOz4ARP3Ght1lw/9rAw8YQc1Tyw+WEHEfZRYDs LBX5qDwDslxRbaD+X8LMUMEUxA== X-Google-Smtp-Source: APXvYqwq2Y0Q6HWDIbs7vkuLUQo9mosZUKJbVQ8JILYrIGj2H8AgBVH06Qhu2TcTbLBJgxthQ23WKA== X-Received: by 2002:a05:6214:14ac:: with SMTP id bo12mr17885970qvb.67.1572294070501; Mon, 28 Oct 2019 13:21:10 -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 w131sm6550657qka.85.2019.10.28.13.21.09 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Mon, 28 Oct 2019 13:21:09 -0700 (PDT) Received: from jgg by mlx.ziepe.ca with local (Exim 4.90_1) (envelope-from ) id 1iPBLf-0001hF-L8; 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 13/15] drm/amdgpu: Use mmu_range_insert instead of hmm_mirror Date: Mon, 28 Oct 2019 17:10:30 -0300 Message-Id: <20191028201032.6352-14-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 Remove the interval tree in the driver and rely on the tree maintained by the mmu_notifier for delivering mmu_notifier invalidation callbacks. For some reason amdgpu has a very complicated arrangement where it tries to prevent duplicate entries in the interval_tree, this is not necessary, each amdgpu_bo can be its own stand alone entry. interval_tree already allows duplicates and overlaps in the tree. Also, there is no need to remove entries upon a release callback, the mmu_range API safely allows objects to remain registered beyond the lifetime of the mm. The driver only has to stop touching the pages during release. Cc: Alex Deucher Cc: Christian König Cc: David (ChunMing) Zhou Cc: amd-gfx@lists.freedesktop.org Signed-off-by: Jason Gunthorpe --- drivers/gpu/drm/amd/amdgpu/amdgpu.h | 2 + .../gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c | 5 +- drivers/gpu/drm/amd/amdgpu/amdgpu_device.c | 1 + drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c | 341 ++++-------------- drivers/gpu/drm/amd/amdgpu/amdgpu_mn.h | 4 - drivers/gpu/drm/amd/amdgpu/amdgpu_object.h | 13 +- 6 files changed, 84 insertions(+), 282 deletions(-) diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu.h b/drivers/gpu/drm/amd/amdgpu/amdgpu.h index bd37df5dd6d048..60591a5d420021 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu.h +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu.h @@ -1006,6 +1006,8 @@ struct amdgpu_device { struct mutex lock_reset; struct amdgpu_doorbell_index doorbell_index; + struct mutex notifier_lock; + int asic_reset_res; struct work_struct xgmi_reset_work; diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c index 6d021ecc8d598f..47700302a08b7f 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c @@ -481,8 +481,7 @@ static void remove_kgd_mem_from_kfd_bo_list(struct kgd_mem *mem, * * Returns 0 for success, negative errno for errors. */ -static int init_user_pages(struct kgd_mem *mem, struct mm_struct *mm, - uint64_t user_addr) +static int init_user_pages(struct kgd_mem *mem, uint64_t user_addr) { struct amdkfd_process_info *process_info = mem->process_info; struct amdgpu_bo *bo = mem->bo; @@ -1195,7 +1194,7 @@ int amdgpu_amdkfd_gpuvm_alloc_memory_of_gpu( add_kgd_mem_to_kfd_bo_list(*mem, avm->process_info, user_addr); if (user_addr) { - ret = init_user_pages(*mem, current->mm, user_addr); + ret = init_user_pages(*mem, user_addr); if (ret) goto allocate_init_user_pages_failed; } diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c index 5a1939dbd4e3e6..38f97998aaddb2 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c @@ -2633,6 +2633,7 @@ int amdgpu_device_init(struct amdgpu_device *adev, mutex_init(&adev->virt.vf_errors.lock); hash_init(adev->mn_hash); mutex_init(&adev->lock_reset); + mutex_init(&adev->notifier_lock); mutex_init(&adev->virt.dpm_mutex); mutex_init(&adev->psp.mutex); diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c index 31d4deb5d29484..4ffd7b90f4d907 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c @@ -50,66 +50,6 @@ #include "amdgpu.h" #include "amdgpu_amdkfd.h" -/** - * struct amdgpu_mn_node - * - * @it: interval node defining start-last of the affected address range - * @bos: list of all BOs in the affected address range - * - * Manages all BOs which are affected of a certain range of address space. - */ -struct amdgpu_mn_node { - struct interval_tree_node it; - struct list_head bos; -}; - -/** - * amdgpu_mn_destroy - destroy the HMM mirror - * - * @work: previously sheduled work item - * - * Lazy destroys the notifier from a work item - */ -static void amdgpu_mn_destroy(struct work_struct *work) -{ - struct amdgpu_mn *amn = container_of(work, struct amdgpu_mn, work); - struct amdgpu_device *adev = amn->adev; - struct amdgpu_mn_node *node, *next_node; - struct amdgpu_bo *bo, *next_bo; - - mutex_lock(&adev->mn_lock); - down_write(&amn->lock); - hash_del(&amn->node); - rbtree_postorder_for_each_entry_safe(node, next_node, - &amn->objects.rb_root, it.rb) { - list_for_each_entry_safe(bo, next_bo, &node->bos, mn_list) { - bo->mn = NULL; - list_del_init(&bo->mn_list); - } - kfree(node); - } - up_write(&amn->lock); - mutex_unlock(&adev->mn_lock); - - hmm_mirror_unregister(&amn->mirror); - kfree(amn); -} - -/** - * amdgpu_hmm_mirror_release - callback to notify about mm destruction - * - * @mirror: the HMM mirror (mm) this callback is about - * - * Shedule a work item to lazy destroy HMM mirror. - */ -static void amdgpu_hmm_mirror_release(struct hmm_mirror *mirror) -{ - struct amdgpu_mn *amn = container_of(mirror, struct amdgpu_mn, mirror); - - INIT_WORK(&amn->work, amdgpu_mn_destroy); - schedule_work(&amn->work); -} - /** * amdgpu_mn_lock - take the write side lock for this notifier * @@ -133,157 +73,86 @@ void amdgpu_mn_unlock(struct amdgpu_mn *mn) } /** - * amdgpu_mn_read_lock - take the read side lock for this notifier - * - * @amn: our notifier - */ -static int amdgpu_mn_read_lock(struct amdgpu_mn *amn, bool blockable) -{ - if (blockable) - down_read(&amn->lock); - else if (!down_read_trylock(&amn->lock)) - return -EAGAIN; - - return 0; -} - -/** - * amdgpu_mn_read_unlock - drop the read side lock for this notifier - * - * @amn: our notifier - */ -static void amdgpu_mn_read_unlock(struct amdgpu_mn *amn) -{ - up_read(&amn->lock); -} - -/** - * amdgpu_mn_invalidate_node - unmap all BOs of a node + * amdgpu_mn_invalidate_gfx - callback to notify about mm change * - * @node: the node with the BOs to unmap - * @start: start of address range affected - * @end: end of address range affected + * @mrn: the range (mm) is about to update + * @range: details on the invalidation * * Block for operations on BOs to finish and mark pages as accessed and * potentially dirty. */ -static void amdgpu_mn_invalidate_node(struct amdgpu_mn_node *node, - unsigned long start, - unsigned long end) +static bool amdgpu_mn_invalidate_gfx(struct mmu_range_notifier *mrn, + const struct mmu_notifier_range *range) { - struct amdgpu_bo *bo; + struct amdgpu_bo *bo = container_of(mrn, struct amdgpu_bo, notifier); + struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev); long r; - list_for_each_entry(bo, &node->bos, mn_list) { - - if (!amdgpu_ttm_tt_affect_userptr(bo->tbo.ttm, start, end)) - continue; - - r = dma_resv_wait_timeout_rcu(bo->tbo.base.resv, - true, false, MAX_SCHEDULE_TIMEOUT); - if (r <= 0) - DRM_ERROR("(%ld) failed to wait for user bo\n", r); - } + /* FIXME: Is this necessary? */ + if (!amdgpu_ttm_tt_affect_userptr(bo->tbo.ttm, range->start, + range->end)) + return true; + + if (!mmu_notifier_range_blockable(range)) + return false; + + mutex_lock(&adev->notifier_lock); + r = dma_resv_wait_timeout_rcu(bo->tbo.base.resv, true, false, + MAX_SCHEDULE_TIMEOUT); + mutex_unlock(&adev->notifier_lock); + if (r <= 0) + DRM_ERROR("(%ld) failed to wait for user bo\n", r); + return true; } +static const struct mmu_range_notifier_ops amdgpu_mn_gfx_ops = { + .invalidate = amdgpu_mn_invalidate_gfx, +}; + /** - * amdgpu_mn_sync_pagetables_gfx - callback to notify about mm change + * amdgpu_mn_invalidate_hsa - callback to notify about mm change * - * @mirror: the hmm_mirror (mm) is about to update - * @update: the update start, end address + * @mrn: the range (mm) is about to update + * @range: details on the invalidation * - * Block for operations on BOs to finish and mark pages as accessed and - * potentially dirty. + * We temporarily evict the BO attached to this range. This necessitates + * evicting all user-mode queues of the process. */ -static int -amdgpu_mn_sync_pagetables_gfx(struct hmm_mirror *mirror, - const struct mmu_notifier_range *update) +static bool amdgpu_mn_invalidate_hsa(struct mmu_range_notifier *mrn, + const struct mmu_notifier_range *range) { - struct amdgpu_mn *amn = container_of(mirror, struct amdgpu_mn, mirror); - unsigned long start = update->start; - unsigned long end = update->end; - bool blockable = mmu_notifier_range_blockable(update); - struct interval_tree_node *it; - - /* notification is exclusive, but interval is inclusive */ - end -= 1; - - /* TODO we should be able to split locking for interval tree and - * amdgpu_mn_invalidate_node - */ - if (amdgpu_mn_read_lock(amn, blockable)) - return -EAGAIN; - - it = interval_tree_iter_first(&amn->objects, start, end); - while (it) { - struct amdgpu_mn_node *node; - - if (!blockable) { - amdgpu_mn_read_unlock(amn); - return -EAGAIN; - } + struct amdgpu_bo *bo = container_of(mrn, struct amdgpu_bo, notifier); + struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev); - node = container_of(it, struct amdgpu_mn_node, it); - it = interval_tree_iter_next(it, start, end); + /* FIXME: Is this necessary? */ + if (!amdgpu_ttm_tt_affect_userptr(bo->tbo.ttm, range->start, + range->end)) + return true; - amdgpu_mn_invalidate_node(node, start, end); - } + if (!mmu_notifier_range_blockable(range)) + return false; - amdgpu_mn_read_unlock(amn); + mutex_lock(&adev->notifier_lock); + amdgpu_amdkfd_evict_userptr(bo->kfd_bo, bo->notifier.mm); + mutex_unlock(&adev->notifier_lock); - return 0; + return true; } -/** - * amdgpu_mn_sync_pagetables_hsa - callback to notify about mm change - * - * @mirror: the hmm_mirror (mm) is about to update - * @update: the update start, end address - * - * We temporarily evict all BOs between start and end. This - * necessitates evicting all user-mode queues of the process. The BOs - * are restorted in amdgpu_mn_invalidate_range_end_hsa. - */ -static int -amdgpu_mn_sync_pagetables_hsa(struct hmm_mirror *mirror, - const struct mmu_notifier_range *update) +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); - unsigned long start = update->start; - unsigned long end = update->end; - bool blockable = mmu_notifier_range_blockable(update); - struct interval_tree_node *it; - /* notification is exclusive, but interval is inclusive */ - end -= 1; - - if (amdgpu_mn_read_lock(amn, blockable)) - return -EAGAIN; - - it = interval_tree_iter_first(&amn->objects, start, end); - while (it) { - struct amdgpu_mn_node *node; - struct amdgpu_bo *bo; - - if (!blockable) { - amdgpu_mn_read_unlock(amn); - return -EAGAIN; - } - - node = container_of(it, struct amdgpu_mn_node, it); - it = interval_tree_iter_next(it, start, end); - - list_for_each_entry(bo, &node->bos, mn_list) { - struct kgd_mem *mem = bo->kfd_bo; - - if (amdgpu_ttm_tt_affect_userptr(bo->tbo.ttm, - start, end)) - amdgpu_amdkfd_evict_userptr(mem, amn->mm); - } - } - - amdgpu_mn_read_unlock(amn); + if (!mmu_notifier_range_blockable(update)) + return false; + down_read(&amn->lock); + up_read(&amn->lock); return 0; } @@ -295,12 +164,10 @@ amdgpu_mn_sync_pagetables_hsa(struct hmm_mirror *mirror, static struct hmm_mirror_ops amdgpu_hmm_mirror_ops[] = { [AMDGPU_MN_TYPE_GFX] = { - .sync_cpu_device_pagetables = amdgpu_mn_sync_pagetables_gfx, - .release = amdgpu_hmm_mirror_release + .sync_cpu_device_pagetables = amdgpu_mn_sync_pagetables, }, [AMDGPU_MN_TYPE_HSA] = { - .sync_cpu_device_pagetables = amdgpu_mn_sync_pagetables_hsa, - .release = amdgpu_hmm_mirror_release + .sync_cpu_device_pagetables = amdgpu_mn_sync_pagetables, }, }; @@ -327,7 +194,8 @@ struct amdgpu_mn *amdgpu_mn_get(struct amdgpu_device *adev, } hash_for_each_possible(adev->mn_hash, amn, node, key) - if (AMDGPU_MN_KEY(amn->mm, amn->type) == key) + if (AMDGPU_MN_KEY(amn->mirror.hmm->mmu_notifier.mm, + amn->type) == key) goto release_locks; amn = kzalloc(sizeof(*amn), GFP_KERNEL); @@ -337,10 +205,8 @@ struct amdgpu_mn *amdgpu_mn_get(struct amdgpu_device *adev, } amn->adev = adev; - amn->mm = mm; init_rwsem(&amn->lock); amn->type = type; - amn->objects = RB_ROOT_CACHED; amn->mirror.ops = &amdgpu_hmm_mirror_ops[type]; r = hmm_mirror_register(&amn->mirror, mm); @@ -369,100 +235,33 @@ struct amdgpu_mn *amdgpu_mn_get(struct amdgpu_device *adev, * @bo: amdgpu buffer object * @addr: userptr addr we should monitor * - * Registers an HMM mirror for the given BO at the specified address. + * Registers a mmu_notifier for the given BO at the specified address. * Returns 0 on success, -ERRNO if anything goes wrong. */ int amdgpu_mn_register(struct amdgpu_bo *bo, unsigned long addr) { - unsigned long end = addr + amdgpu_bo_size(bo) - 1; - struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev); - enum amdgpu_mn_type type = - bo->kfd_bo ? AMDGPU_MN_TYPE_HSA : AMDGPU_MN_TYPE_GFX; - struct amdgpu_mn *amn; - struct amdgpu_mn_node *node = NULL, *new_node; - struct list_head bos; - struct interval_tree_node *it; - - amn = amdgpu_mn_get(adev, type); - if (IS_ERR(amn)) - return PTR_ERR(amn); - - new_node = kmalloc(sizeof(*new_node), GFP_KERNEL); - if (!new_node) - return -ENOMEM; - - INIT_LIST_HEAD(&bos); - - down_write(&amn->lock); - - while ((it = interval_tree_iter_first(&amn->objects, addr, end))) { - kfree(node); - node = container_of(it, struct amdgpu_mn_node, it); - interval_tree_remove(&node->it, &amn->objects); - addr = min(it->start, addr); - end = max(it->last, end); - list_splice(&node->bos, &bos); - } - - if (!node) - node = new_node; + if (bo->kfd_bo) + bo->notifier.ops = &amdgpu_mn_hsa_ops; else - kfree(new_node); - - bo->mn = amn; - - node->it.start = addr; - node->it.last = end; - INIT_LIST_HEAD(&node->bos); - list_splice(&bos, &node->bos); - list_add(&bo->mn_list, &node->bos); + bo->notifier.ops = &amdgpu_mn_gfx_ops; - interval_tree_insert(&node->it, &amn->objects); - - up_write(&amn->lock); - - return 0; + return mmu_range_notifier_insert(&bo->notifier, addr, + amdgpu_bo_size(bo), current->mm); } /** - * amdgpu_mn_unregister - unregister a BO for HMM mirror updates + * amdgpu_mn_unregister - unregister a BO for notifier updates * * @bo: amdgpu buffer object * - * Remove any registration of HMM mirror updates from the buffer object. + * Remove any registration of mmu notifier updates from the buffer object. */ void amdgpu_mn_unregister(struct amdgpu_bo *bo) { - struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev); - struct amdgpu_mn *amn; - struct list_head *head; - - mutex_lock(&adev->mn_lock); - - amn = bo->mn; - if (amn == NULL) { - mutex_unlock(&adev->mn_lock); + if (!bo->notifier.mm) return; - } - - down_write(&amn->lock); - - /* save the next list entry for later */ - head = bo->mn_list.next; - - bo->mn = NULL; - list_del_init(&bo->mn_list); - - if (list_empty(head)) { - struct amdgpu_mn_node *node; - - node = container_of(head, struct amdgpu_mn_node, bos); - interval_tree_remove(&node->it, &amn->objects); - kfree(node); - } - - up_write(&amn->lock); - mutex_unlock(&adev->mn_lock); + mmu_range_notifier_remove(&bo->notifier); + bo->notifier.mm = NULL; } /* flags used by HMM internal, not related to CPU/GPU PTE flags */ diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.h index b8ed68943625c2..d73ab2947b22b2 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.h +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.h @@ -39,12 +39,10 @@ enum amdgpu_mn_type { * struct amdgpu_mn * * @adev: amdgpu device pointer - * @mm: process address space * @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 - * @objects: interval tree containing amdgpu_mn_nodes * @mirror: HMM mirror function support * * Data for each amdgpu device and process address space. @@ -52,7 +50,6 @@ enum amdgpu_mn_type { struct amdgpu_mn { /* constant after initialisation */ struct amdgpu_device *adev; - struct mm_struct *mm; enum amdgpu_mn_type type; /* only used on destruction */ @@ -63,7 +60,6 @@ struct amdgpu_mn { /* objects protected by lock */ struct rw_semaphore lock; - struct rb_root_cached objects; #ifdef CONFIG_HMM_MIRROR /* HMM mirror */ diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_object.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_object.h index 658f4c9779b704..4b44ab850f94c2 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_object.h +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_object.h @@ -30,6 +30,9 @@ #include #include "amdgpu.h" +#ifdef CONFIG_MMU_NOTIFIER +#include +#endif #define AMDGPU_BO_INVALID_OFFSET LONG_MAX #define AMDGPU_BO_MAX_PLACEMENTS 3 @@ -100,10 +103,12 @@ struct amdgpu_bo { struct ttm_bo_kmap_obj dma_buf_vmap; struct amdgpu_mn *mn; - union { - struct list_head mn_list; - struct list_head shadow_list; - }; + +#ifdef CONFIG_MMU_NOTIFIER + struct mmu_range_notifier notifier; +#endif + + struct list_head shadow_list; struct kgd_mem *kfd_bo; }; -- 2.23.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jason Gunthorpe Subject: [PATCH v2 13/15] drm/amdgpu: Use mmu_range_insert instead of hmm_mirror Date: Mon, 28 Oct 2019 17:10:30 -0300 Message-ID: <20191028201032.6352-14-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 RnJvbTogSmFzb24gR3VudGhvcnBlIDxqZ2dAbWVsbGFub3guY29tPgoKUmVtb3ZlIHRoZSBpbnRl cnZhbCB0cmVlIGluIHRoZSBkcml2ZXIgYW5kIHJlbHkgb24gdGhlIHRyZWUgbWFpbnRhaW5lZCBi eQp0aGUgbW11X25vdGlmaWVyIGZvciBkZWxpdmVyaW5nIG1tdV9ub3RpZmllciBpbnZhbGlkYXRp b24gY2FsbGJhY2tzLgoKRm9yIHNvbWUgcmVhc29uIGFtZGdwdSBoYXMgYSB2ZXJ5IGNvbXBsaWNh dGVkIGFycmFuZ2VtZW50IHdoZXJlIGl0IHRyaWVzCnRvIHByZXZlbnQgZHVwbGljYXRlIGVudHJp ZXMgaW4gdGhlIGludGVydmFsX3RyZWUsIHRoaXMgaXMgbm90IG5lY2Vzc2FyeSwKZWFjaCBhbWRn cHVfYm8gY2FuIGJlIGl0cyBvd24gc3RhbmQgYWxvbmUgZW50cnkuIGludGVydmFsX3RyZWUgYWxy ZWFkeQphbGxvd3MgZHVwbGljYXRlcyBhbmQgb3ZlcmxhcHMgaW4gdGhlIHRyZWUuCgpBbHNvLCB0 aGVyZSBpcyBubyBuZWVkIHRvIHJlbW92ZSBlbnRyaWVzIHVwb24gYSByZWxlYXNlIGNhbGxiYWNr LCB0aGUKbW11X3JhbmdlIEFQSSBzYWZlbHkgYWxsb3dzIG9iamVjdHMgdG8gcmVtYWluIHJlZ2lz dGVyZWQgYmV5b25kIHRoZQpsaWZldGltZSBvZiB0aGUgbW0uIFRoZSBkcml2ZXIgb25seSBoYXMg dG8gc3RvcCB0b3VjaGluZyB0aGUgcGFnZXMgZHVyaW5nCnJlbGVhc2UuCgpDYzogQWxleCBEZXVj aGVyIDxhbGV4YW5kZXIuZGV1Y2hlckBhbWQuY29tPgpDYzogQ2hyaXN0aWFuIEvDtm5pZyA8Y2hy aXN0aWFuLmtvZW5pZ0BhbWQuY29tPgpDYzogRGF2aWQgKENodW5NaW5nKSBaaG91IDxEYXZpZDEu WmhvdUBhbWQuY29tPgpDYzogYW1kLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKU2lnbmVkLW9m Zi1ieTogSmFzb24gR3VudGhvcnBlIDxqZ2dAbWVsbGFub3guY29tPgotLS0KIGRyaXZlcnMvZ3B1 L2RybS9hbWQvYW1kZ3B1L2FtZGdwdS5oICAgICAgICAgICB8ICAgMiArCiAuLi4vZ3B1L2RybS9h bWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYyAgfCAgIDUgKy0KIGRyaXZlcnMvZ3B1L2Ry bS9hbWQvYW1kZ3B1L2FtZGdwdV9kZXZpY2UuYyAgICB8ICAgMSArCiBkcml2ZXJzL2dwdS9kcm0v YW1kL2FtZGdwdS9hbWRncHVfbW4uYyAgICAgICAgfCAzNDEgKysrKy0tLS0tLS0tLS0tLS0tCiBk cml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uaCAgICAgICAgfCAgIDQgLQogZHJp dmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X29iamVjdC5oICAgIHwgIDEzICstCiA2IGZp bGVzIGNoYW5nZWQsIDg0IGluc2VydGlvbnMoKyksIDI4MiBkZWxldGlvbnMoLSkKCmRpZmYgLS1n aXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHUuaCBiL2RyaXZlcnMvZ3B1L2Ry bS9hbWQvYW1kZ3B1L2FtZGdwdS5oCmluZGV4IGJkMzdkZjVkZDZkMDQ4Li42MDU5MWE1ZDQyMDAy MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1LmgKKysrIGIv ZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1LmgKQEAgLTEwMDYsNiArMTAwNiw4IEBA IHN0cnVjdCBhbWRncHVfZGV2aWNlIHsKIAlzdHJ1Y3QgbXV0ZXggIGxvY2tfcmVzZXQ7CiAJc3Ry dWN0IGFtZGdwdV9kb29yYmVsbF9pbmRleCBkb29yYmVsbF9pbmRleDsKIAorCXN0cnVjdCBtdXRl eAkJCW5vdGlmaWVyX2xvY2s7CisKIAlpbnQgYXNpY19yZXNldF9yZXM7CiAJc3RydWN0IHdvcmtf c3RydWN0CQl4Z21pX3Jlc2V0X3dvcms7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9h bWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1k Z3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYwppbmRleCA2ZDAyMWVjYzhkNTk4Zi4uNDc3MDAzMDJh MDhiN2YgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9hbWRr ZmRfZ3B1dm0uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfYW1ka2Zk X2dwdXZtLmMKQEAgLTQ4MSw4ICs0ODEsNyBAQCBzdGF0aWMgdm9pZCByZW1vdmVfa2dkX21lbV9m cm9tX2tmZF9ib19saXN0KHN0cnVjdCBrZ2RfbWVtICptZW0sCiAgKgogICogUmV0dXJucyAwIGZv ciBzdWNjZXNzLCBuZWdhdGl2ZSBlcnJubyBmb3IgZXJyb3JzLgogICovCi1zdGF0aWMgaW50IGlu aXRfdXNlcl9wYWdlcyhzdHJ1Y3Qga2dkX21lbSAqbWVtLCBzdHJ1Y3QgbW1fc3RydWN0ICptbSwK LQkJCSAgIHVpbnQ2NF90IHVzZXJfYWRkcikKK3N0YXRpYyBpbnQgaW5pdF91c2VyX3BhZ2VzKHN0 cnVjdCBrZ2RfbWVtICptZW0sIHVpbnQ2NF90IHVzZXJfYWRkcikKIHsKIAlzdHJ1Y3QgYW1ka2Zk X3Byb2Nlc3NfaW5mbyAqcHJvY2Vzc19pbmZvID0gbWVtLT5wcm9jZXNzX2luZm87CiAJc3RydWN0 IGFtZGdwdV9ibyAqYm8gPSBtZW0tPmJvOwpAQCAtMTE5NSw3ICsxMTk0LDcgQEAgaW50IGFtZGdw dV9hbWRrZmRfZ3B1dm1fYWxsb2NfbWVtb3J5X29mX2dwdSgKIAlhZGRfa2dkX21lbV90b19rZmRf Ym9fbGlzdCgqbWVtLCBhdm0tPnByb2Nlc3NfaW5mbywgdXNlcl9hZGRyKTsKIAogCWlmICh1c2Vy X2FkZHIpIHsKLQkJcmV0ID0gaW5pdF91c2VyX3BhZ2VzKCptZW0sIGN1cnJlbnQtPm1tLCB1c2Vy X2FkZHIpOworCQlyZXQgPSBpbml0X3VzZXJfcGFnZXMoKm1lbSwgdXNlcl9hZGRyKTsKIAkJaWYg KHJldCkKIAkJCWdvdG8gYWxsb2NhdGVfaW5pdF91c2VyX3BhZ2VzX2ZhaWxlZDsKIAl9CmRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfZGV2aWNlLmMgYi9kcml2 ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfZGV2aWNlLmMKaW5kZXggNWExOTM5ZGJkNGUz ZTYuLjM4Zjk3OTk4YWFkZGIyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdw dS9hbWRncHVfZGV2aWNlLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1 X2RldmljZS5jCkBAIC0yNjMzLDYgKzI2MzMsNyBAQCBpbnQgYW1kZ3B1X2RldmljZV9pbml0KHN0 cnVjdCBhbWRncHVfZGV2aWNlICphZGV2LAogCW11dGV4X2luaXQoJmFkZXYtPnZpcnQudmZfZXJy b3JzLmxvY2spOwogCWhhc2hfaW5pdChhZGV2LT5tbl9oYXNoKTsKIAltdXRleF9pbml0KCZhZGV2 LT5sb2NrX3Jlc2V0KTsKKwltdXRleF9pbml0KCZhZGV2LT5ub3RpZmllcl9sb2NrKTsKIAltdXRl eF9pbml0KCZhZGV2LT52aXJ0LmRwbV9tdXRleCk7CiAJbXV0ZXhfaW5pdCgmYWRldi0+cHNwLm11 dGV4KTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21u LmMgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uYwppbmRleCAzMWQ0ZGVi NWQyOTQ4NC4uNGZmZDdiOTBmNGQ5MDcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQv YW1kZ3B1L2FtZGdwdV9tbi5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdw dV9tbi5jCkBAIC01MCw2NiArNTAsNiBAQAogI2luY2x1ZGUgImFtZGdwdS5oIgogI2luY2x1ZGUg ImFtZGdwdV9hbWRrZmQuaCIKIAotLyoqCi0gKiBzdHJ1Y3QgYW1kZ3B1X21uX25vZGUKLSAqCi0g KiBAaXQ6IGludGVydmFsIG5vZGUgZGVmaW5pbmcgc3RhcnQtbGFzdCBvZiB0aGUgYWZmZWN0ZWQg YWRkcmVzcyByYW5nZQotICogQGJvczogbGlzdCBvZiBhbGwgQk9zIGluIHRoZSBhZmZlY3RlZCBh ZGRyZXNzIHJhbmdlCi0gKgotICogTWFuYWdlcyBhbGwgQk9zIHdoaWNoIGFyZSBhZmZlY3RlZCBv ZiBhIGNlcnRhaW4gcmFuZ2Ugb2YgYWRkcmVzcyBzcGFjZS4KLSAqLwotc3RydWN0IGFtZGdwdV9t bl9ub2RlIHsKLQlzdHJ1Y3QgaW50ZXJ2YWxfdHJlZV9ub2RlCWl0OwotCXN0cnVjdCBsaXN0X2hl YWQJCWJvczsKLX07Ci0KLS8qKgotICogYW1kZ3B1X21uX2Rlc3Ryb3kgLSBkZXN0cm95IHRoZSBI TU0gbWlycm9yCi0gKgotICogQHdvcms6IHByZXZpb3VzbHkgc2hlZHVsZWQgd29yayBpdGVtCi0g KgotICogTGF6eSBkZXN0cm95cyB0aGUgbm90aWZpZXIgZnJvbSBhIHdvcmsgaXRlbQotICovCi1z dGF0aWMgdm9pZCBhbWRncHVfbW5fZGVzdHJveShzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCi17 Ci0Jc3RydWN0IGFtZGdwdV9tbiAqYW1uID0gY29udGFpbmVyX29mKHdvcmssIHN0cnVjdCBhbWRn cHVfbW4sIHdvcmspOwotCXN0cnVjdCBhbWRncHVfZGV2aWNlICphZGV2ID0gYW1uLT5hZGV2Owot CXN0cnVjdCBhbWRncHVfbW5fbm9kZSAqbm9kZSwgKm5leHRfbm9kZTsKLQlzdHJ1Y3QgYW1kZ3B1 X2JvICpibywgKm5leHRfYm87Ci0KLQltdXRleF9sb2NrKCZhZGV2LT5tbl9sb2NrKTsKLQlkb3du X3dyaXRlKCZhbW4tPmxvY2spOwotCWhhc2hfZGVsKCZhbW4tPm5vZGUpOwotCXJidHJlZV9wb3N0 b3JkZXJfZm9yX2VhY2hfZW50cnlfc2FmZShub2RlLCBuZXh0X25vZGUsCi0JCQkJCSAgICAgJmFt bi0+b2JqZWN0cy5yYl9yb290LCBpdC5yYikgewotCQlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUo Ym8sIG5leHRfYm8sICZub2RlLT5ib3MsIG1uX2xpc3QpIHsKLQkJCWJvLT5tbiA9IE5VTEw7Ci0J CQlsaXN0X2RlbF9pbml0KCZiby0+bW5fbGlzdCk7Ci0JCX0KLQkJa2ZyZWUobm9kZSk7Ci0JfQot CXVwX3dyaXRlKCZhbW4tPmxvY2spOwotCW11dGV4X3VubG9jaygmYWRldi0+bW5fbG9jayk7Ci0K LQlobW1fbWlycm9yX3VucmVnaXN0ZXIoJmFtbi0+bWlycm9yKTsKLQlrZnJlZShhbW4pOwotfQot Ci0vKioKLSAqIGFtZGdwdV9obW1fbWlycm9yX3JlbGVhc2UgLSBjYWxsYmFjayB0byBub3RpZnkg YWJvdXQgbW0gZGVzdHJ1Y3Rpb24KLSAqCi0gKiBAbWlycm9yOiB0aGUgSE1NIG1pcnJvciAobW0p IHRoaXMgY2FsbGJhY2sgaXMgYWJvdXQKLSAqCi0gKiBTaGVkdWxlIGEgd29yayBpdGVtIHRvIGxh enkgZGVzdHJveSBITU0gbWlycm9yLgotICovCi1zdGF0aWMgdm9pZCBhbWRncHVfaG1tX21pcnJv cl9yZWxlYXNlKHN0cnVjdCBobW1fbWlycm9yICptaXJyb3IpCi17Ci0Jc3RydWN0IGFtZGdwdV9t biAqYW1uID0gY29udGFpbmVyX29mKG1pcnJvciwgc3RydWN0IGFtZGdwdV9tbiwgbWlycm9yKTsK LQotCUlOSVRfV09SSygmYW1uLT53b3JrLCBhbWRncHVfbW5fZGVzdHJveSk7Ci0Jc2NoZWR1bGVf d29yaygmYW1uLT53b3JrKTsKLX0KLQogLyoqCiAgKiBhbWRncHVfbW5fbG9jayAtIHRha2UgdGhl IHdyaXRlIHNpZGUgbG9jayBmb3IgdGhpcyBub3RpZmllcgogICoKQEAgLTEzMywxNTcgKzczLDg2 IEBAIHZvaWQgYW1kZ3B1X21uX3VubG9jayhzdHJ1Y3QgYW1kZ3B1X21uICptbikKIH0KIAogLyoq Ci0gKiBhbWRncHVfbW5fcmVhZF9sb2NrIC0gdGFrZSB0aGUgcmVhZCBzaWRlIGxvY2sgZm9yIHRo aXMgbm90aWZpZXIKLSAqCi0gKiBAYW1uOiBvdXIgbm90aWZpZXIKLSAqLwotc3RhdGljIGludCBh bWRncHVfbW5fcmVhZF9sb2NrKHN0cnVjdCBhbWRncHVfbW4gKmFtbiwgYm9vbCBibG9ja2FibGUp Ci17Ci0JaWYgKGJsb2NrYWJsZSkKLQkJZG93bl9yZWFkKCZhbW4tPmxvY2spOwotCWVsc2UgaWYg KCFkb3duX3JlYWRfdHJ5bG9jaygmYW1uLT5sb2NrKSkKLQkJcmV0dXJuIC1FQUdBSU47Ci0KLQly ZXR1cm4gMDsKLX0KLQotLyoqCi0gKiBhbWRncHVfbW5fcmVhZF91bmxvY2sgLSBkcm9wIHRoZSBy ZWFkIHNpZGUgbG9jayBmb3IgdGhpcyBub3RpZmllcgotICoKLSAqIEBhbW46IG91ciBub3RpZmll cgotICovCi1zdGF0aWMgdm9pZCBhbWRncHVfbW5fcmVhZF91bmxvY2soc3RydWN0IGFtZGdwdV9t biAqYW1uKQotewotCXVwX3JlYWQoJmFtbi0+bG9jayk7Ci19Ci0KLS8qKgotICogYW1kZ3B1X21u X2ludmFsaWRhdGVfbm9kZSAtIHVubWFwIGFsbCBCT3Mgb2YgYSBub2RlCisgKiBhbWRncHVfbW5f aW52YWxpZGF0ZV9nZnggLSBjYWxsYmFjayB0byBub3RpZnkgYWJvdXQgbW0gY2hhbmdlCiAgKgot ICogQG5vZGU6IHRoZSBub2RlIHdpdGggdGhlIEJPcyB0byB1bm1hcAotICogQHN0YXJ0OiBzdGFy dCBvZiBhZGRyZXNzIHJhbmdlIGFmZmVjdGVkCi0gKiBAZW5kOiBlbmQgb2YgYWRkcmVzcyByYW5n ZSBhZmZlY3RlZAorICogQG1ybjogdGhlIHJhbmdlIChtbSkgaXMgYWJvdXQgdG8gdXBkYXRlCisg KiBAcmFuZ2U6IGRldGFpbHMgb24gdGhlIGludmFsaWRhdGlvbgogICoKICAqIEJsb2NrIGZvciBv cGVyYXRpb25zIG9uIEJPcyB0byBmaW5pc2ggYW5kIG1hcmsgcGFnZXMgYXMgYWNjZXNzZWQgYW5k CiAgKiBwb3RlbnRpYWxseSBkaXJ0eS4KICAqLwotc3RhdGljIHZvaWQgYW1kZ3B1X21uX2ludmFs aWRhdGVfbm9kZShzdHJ1Y3QgYW1kZ3B1X21uX25vZGUgKm5vZGUsCi0JCQkJICAgICAgdW5zaWdu ZWQgbG9uZyBzdGFydCwKLQkJCQkgICAgICB1bnNpZ25lZCBsb25nIGVuZCkKK3N0YXRpYyBib29s IGFtZGdwdV9tbl9pbnZhbGlkYXRlX2dmeChzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyICptcm4s CisJCQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICpyYW5nZSkKIHsKLQlz dHJ1Y3QgYW1kZ3B1X2JvICpibzsKKwlzdHJ1Y3QgYW1kZ3B1X2JvICpibyA9IGNvbnRhaW5lcl9v Zihtcm4sIHN0cnVjdCBhbWRncHVfYm8sIG5vdGlmaWVyKTsKKwlzdHJ1Y3QgYW1kZ3B1X2Rldmlj ZSAqYWRldiA9IGFtZGdwdV90dG1fYWRldihiby0+dGJvLmJkZXYpOwogCWxvbmcgcjsKIAotCWxp c3RfZm9yX2VhY2hfZW50cnkoYm8sICZub2RlLT5ib3MsIG1uX2xpc3QpIHsKLQotCQlpZiAoIWFt ZGdwdV90dG1fdHRfYWZmZWN0X3VzZXJwdHIoYm8tPnRiby50dG0sIHN0YXJ0LCBlbmQpKQotCQkJ Y29udGludWU7Ci0KLQkJciA9IGRtYV9yZXN2X3dhaXRfdGltZW91dF9yY3UoYm8tPnRiby5iYXNl LnJlc3YsCi0JCQl0cnVlLCBmYWxzZSwgTUFYX1NDSEVEVUxFX1RJTUVPVVQpOwotCQlpZiAociA8 PSAwKQotCQkJRFJNX0VSUk9SKCIoJWxkKSBmYWlsZWQgdG8gd2FpdCBmb3IgdXNlciBib1xuIiwg cik7Ci0JfQorCS8qIEZJWE1FOiBJcyB0aGlzIG5lY2Vzc2FyeT8gKi8KKwlpZiAoIWFtZGdwdV90 dG1fdHRfYWZmZWN0X3VzZXJwdHIoYm8tPnRiby50dG0sIHJhbmdlLT5zdGFydCwKKwkJCQkJICBy YW5nZS0+ZW5kKSkKKwkJcmV0dXJuIHRydWU7CisKKwlpZiAoIW1tdV9ub3RpZmllcl9yYW5nZV9i bG9ja2FibGUocmFuZ2UpKQorCQlyZXR1cm4gZmFsc2U7CisKKwltdXRleF9sb2NrKCZhZGV2LT5u b3RpZmllcl9sb2NrKTsKKwlyID0gZG1hX3Jlc3Zfd2FpdF90aW1lb3V0X3JjdShiby0+dGJvLmJh c2UucmVzdiwgdHJ1ZSwgZmFsc2UsCisJCQkJICAgICAgTUFYX1NDSEVEVUxFX1RJTUVPVVQpOwor CW11dGV4X3VubG9jaygmYWRldi0+bm90aWZpZXJfbG9jayk7CisJaWYgKHIgPD0gMCkKKwkJRFJN X0VSUk9SKCIoJWxkKSBmYWlsZWQgdG8gd2FpdCBmb3IgdXNlciBib1xuIiwgcik7CisJcmV0dXJu IHRydWU7CiB9CiAKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyX29wcyBh bWRncHVfbW5fZ2Z4X29wcyA9IHsKKwkuaW52YWxpZGF0ZSA9IGFtZGdwdV9tbl9pbnZhbGlkYXRl X2dmeCwKK307CisKIC8qKgotICogYW1kZ3B1X21uX3N5bmNfcGFnZXRhYmxlc19nZnggLSBjYWxs YmFjayB0byBub3RpZnkgYWJvdXQgbW0gY2hhbmdlCisgKiBhbWRncHVfbW5faW52YWxpZGF0ZV9o c2EgLSBjYWxsYmFjayB0byBub3RpZnkgYWJvdXQgbW0gY2hhbmdlCiAgKgotICogQG1pcnJvcjog dGhlIGhtbV9taXJyb3IgKG1tKSBpcyBhYm91dCB0byB1cGRhdGUKLSAqIEB1cGRhdGU6IHRoZSB1 cGRhdGUgc3RhcnQsIGVuZCBhZGRyZXNzCisgKiBAbXJuOiB0aGUgcmFuZ2UgKG1tKSBpcyBhYm91 dCB0byB1cGRhdGUKKyAqIEByYW5nZTogZGV0YWlscyBvbiB0aGUgaW52YWxpZGF0aW9uCiAgKgot ICogQmxvY2sgZm9yIG9wZXJhdGlvbnMgb24gQk9zIHRvIGZpbmlzaCBhbmQgbWFyayBwYWdlcyBh cyBhY2Nlc3NlZCBhbmQKLSAqIHBvdGVudGlhbGx5IGRpcnR5LgorICogV2UgdGVtcG9yYXJpbHkg ZXZpY3QgdGhlIEJPIGF0dGFjaGVkIHRvIHRoaXMgcmFuZ2UuIFRoaXMgbmVjZXNzaXRhdGVzCisg KiBldmljdGluZyBhbGwgdXNlci1tb2RlIHF1ZXVlcyBvZiB0aGUgcHJvY2Vzcy4KICAqLwotc3Rh dGljIGludAotYW1kZ3B1X21uX3N5bmNfcGFnZXRhYmxlc19nZngoc3RydWN0IGhtbV9taXJyb3Ig Km1pcnJvciwKLQkJCSAgICAgIGNvbnN0IHN0cnVjdCBtbXVfbm90aWZpZXJfcmFuZ2UgKnVwZGF0 ZSkKK3N0YXRpYyBib29sIGFtZGdwdV9tbl9pbnZhbGlkYXRlX2hzYShzdHJ1Y3QgbW11X3Jhbmdl X25vdGlmaWVyICptcm4sCisJCQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3Jhbmdl ICpyYW5nZSkKIHsKLQlzdHJ1Y3QgYW1kZ3B1X21uICphbW4gPSBjb250YWluZXJfb2YobWlycm9y LCBzdHJ1Y3QgYW1kZ3B1X21uLCBtaXJyb3IpOwotCXVuc2lnbmVkIGxvbmcgc3RhcnQgPSB1cGRh dGUtPnN0YXJ0OwotCXVuc2lnbmVkIGxvbmcgZW5kID0gdXBkYXRlLT5lbmQ7Ci0JYm9vbCBibG9j a2FibGUgPSBtbXVfbm90aWZpZXJfcmFuZ2VfYmxvY2thYmxlKHVwZGF0ZSk7Ci0Jc3RydWN0IGlu dGVydmFsX3RyZWVfbm9kZSAqaXQ7Ci0KLQkvKiBub3RpZmljYXRpb24gaXMgZXhjbHVzaXZlLCBi dXQgaW50ZXJ2YWwgaXMgaW5jbHVzaXZlICovCi0JZW5kIC09IDE7Ci0KLQkvKiBUT0RPIHdlIHNo b3VsZCBiZSBhYmxlIHRvIHNwbGl0IGxvY2tpbmcgZm9yIGludGVydmFsIHRyZWUgYW5kCi0JICog YW1kZ3B1X21uX2ludmFsaWRhdGVfbm9kZQotCSAqLwotCWlmIChhbWRncHVfbW5fcmVhZF9sb2Nr KGFtbiwgYmxvY2thYmxlKSkKLQkJcmV0dXJuIC1FQUdBSU47Ci0KLQlpdCA9IGludGVydmFsX3Ry ZWVfaXRlcl9maXJzdCgmYW1uLT5vYmplY3RzLCBzdGFydCwgZW5kKTsKLQl3aGlsZSAoaXQpIHsK LQkJc3RydWN0IGFtZGdwdV9tbl9ub2RlICpub2RlOwotCi0JCWlmICghYmxvY2thYmxlKSB7Ci0J CQlhbWRncHVfbW5fcmVhZF91bmxvY2soYW1uKTsKLQkJCXJldHVybiAtRUFHQUlOOwotCQl9CisJ c3RydWN0IGFtZGdwdV9ibyAqYm8gPSBjb250YWluZXJfb2YobXJuLCBzdHJ1Y3QgYW1kZ3B1X2Jv LCBub3RpZmllcik7CisJc3RydWN0IGFtZGdwdV9kZXZpY2UgKmFkZXYgPSBhbWRncHVfdHRtX2Fk ZXYoYm8tPnRiby5iZGV2KTsKIAotCQlub2RlID0gY29udGFpbmVyX29mKGl0LCBzdHJ1Y3QgYW1k Z3B1X21uX25vZGUsIGl0KTsKLQkJaXQgPSBpbnRlcnZhbF90cmVlX2l0ZXJfbmV4dChpdCwgc3Rh cnQsIGVuZCk7CisJLyogRklYTUU6IElzIHRoaXMgbmVjZXNzYXJ5PyAqLworCWlmICghYW1kZ3B1 X3R0bV90dF9hZmZlY3RfdXNlcnB0cihiby0+dGJvLnR0bSwgcmFuZ2UtPnN0YXJ0LAorCQkJCQkg IHJhbmdlLT5lbmQpKQorCQlyZXR1cm4gdHJ1ZTsKIAotCQlhbWRncHVfbW5faW52YWxpZGF0ZV9u b2RlKG5vZGUsIHN0YXJ0LCBlbmQpOwotCX0KKwlpZiAoIW1tdV9ub3RpZmllcl9yYW5nZV9ibG9j a2FibGUocmFuZ2UpKQorCQlyZXR1cm4gZmFsc2U7CiAKLQlhbWRncHVfbW5fcmVhZF91bmxvY2so YW1uKTsKKwltdXRleF9sb2NrKCZhZGV2LT5ub3RpZmllcl9sb2NrKTsKKwlhbWRncHVfYW1ka2Zk X2V2aWN0X3VzZXJwdHIoYm8tPmtmZF9ibywgYm8tPm5vdGlmaWVyLm1tKTsKKwltdXRleF91bmxv Y2soJmFkZXYtPm5vdGlmaWVyX2xvY2spOwogCi0JcmV0dXJuIDA7CisJcmV0dXJuIHRydWU7CiB9 CiAKLS8qKgotICogYW1kZ3B1X21uX3N5bmNfcGFnZXRhYmxlc19oc2EgLSBjYWxsYmFjayB0byBu b3RpZnkgYWJvdXQgbW0gY2hhbmdlCi0gKgotICogQG1pcnJvcjogdGhlIGhtbV9taXJyb3IgKG1t KSBpcyBhYm91dCB0byB1cGRhdGUKLSAqIEB1cGRhdGU6IHRoZSB1cGRhdGUgc3RhcnQsIGVuZCBh ZGRyZXNzCi0gKgotICogV2UgdGVtcG9yYXJpbHkgZXZpY3QgYWxsIEJPcyBiZXR3ZWVuIHN0YXJ0 IGFuZCBlbmQuIFRoaXMKLSAqIG5lY2Vzc2l0YXRlcyBldmljdGluZyBhbGwgdXNlci1tb2RlIHF1 ZXVlcyBvZiB0aGUgcHJvY2Vzcy4gVGhlIEJPcwotICogYXJlIHJlc3RvcnRlZCBpbiBhbWRncHVf bW5faW52YWxpZGF0ZV9yYW5nZV9lbmRfaHNhLgotICovCi1zdGF0aWMgaW50Ci1hbWRncHVfbW5f c3luY19wYWdldGFibGVzX2hzYShzdHJ1Y3QgaG1tX21pcnJvciAqbWlycm9yLAotCQkJICAgICAg Y29uc3Qgc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAqdXBkYXRlKQorc3RhdGljIGNvbnN0IHN0 cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXJfb3BzIGFtZGdwdV9tbl9oc2Ffb3BzID0geworCS5pbnZh bGlkYXRlID0gYW1kZ3B1X21uX2ludmFsaWRhdGVfaHNhLAorfTsKKworc3RhdGljIGludCBhbWRn cHVfbW5fc3luY19wYWdldGFibGVzKHN0cnVjdCBobW1fbWlycm9yICptaXJyb3IsCisJCQkJICAg ICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICp1cGRhdGUpCiB7CiAJc3RydWN0IGFt ZGdwdV9tbiAqYW1uID0gY29udGFpbmVyX29mKG1pcnJvciwgc3RydWN0IGFtZGdwdV9tbiwgbWly cm9yKTsKLQl1bnNpZ25lZCBsb25nIHN0YXJ0ID0gdXBkYXRlLT5zdGFydDsKLQl1bnNpZ25lZCBs b25nIGVuZCA9IHVwZGF0ZS0+ZW5kOwotCWJvb2wgYmxvY2thYmxlID0gbW11X25vdGlmaWVyX3Jh bmdlX2Jsb2NrYWJsZSh1cGRhdGUpOwotCXN0cnVjdCBpbnRlcnZhbF90cmVlX25vZGUgKml0Owog Ci0JLyogbm90aWZpY2F0aW9uIGlzIGV4Y2x1c2l2ZSwgYnV0IGludGVydmFsIGlzIGluY2x1c2l2 ZSAqLwotCWVuZCAtPSAxOwotCi0JaWYgKGFtZGdwdV9tbl9yZWFkX2xvY2soYW1uLCBibG9ja2Fi bGUpKQotCQlyZXR1cm4gLUVBR0FJTjsKLQotCWl0ID0gaW50ZXJ2YWxfdHJlZV9pdGVyX2ZpcnN0 KCZhbW4tPm9iamVjdHMsIHN0YXJ0LCBlbmQpOwotCXdoaWxlIChpdCkgewotCQlzdHJ1Y3QgYW1k Z3B1X21uX25vZGUgKm5vZGU7Ci0JCXN0cnVjdCBhbWRncHVfYm8gKmJvOwotCi0JCWlmICghYmxv Y2thYmxlKSB7Ci0JCQlhbWRncHVfbW5fcmVhZF91bmxvY2soYW1uKTsKLQkJCXJldHVybiAtRUFH QUlOOwotCQl9Ci0KLQkJbm9kZSA9IGNvbnRhaW5lcl9vZihpdCwgc3RydWN0IGFtZGdwdV9tbl9u b2RlLCBpdCk7Ci0JCWl0ID0gaW50ZXJ2YWxfdHJlZV9pdGVyX25leHQoaXQsIHN0YXJ0LCBlbmQp OwotCi0JCWxpc3RfZm9yX2VhY2hfZW50cnkoYm8sICZub2RlLT5ib3MsIG1uX2xpc3QpIHsKLQkJ CXN0cnVjdCBrZ2RfbWVtICptZW0gPSBiby0+a2ZkX2JvOwotCi0JCQlpZiAoYW1kZ3B1X3R0bV90 dF9hZmZlY3RfdXNlcnB0cihiby0+dGJvLnR0bSwKLQkJCQkJCQkgc3RhcnQsIGVuZCkpCi0JCQkJ YW1kZ3B1X2FtZGtmZF9ldmljdF91c2VycHRyKG1lbSwgYW1uLT5tbSk7Ci0JCX0KLQl9Ci0KLQlh bWRncHVfbW5fcmVhZF91bmxvY2soYW1uKTsKKwlpZiAoIW1tdV9ub3RpZmllcl9yYW5nZV9ibG9j a2FibGUodXBkYXRlKSkKKwkJcmV0dXJuIGZhbHNlOwogCisJZG93bl9yZWFkKCZhbW4tPmxvY2sp OworCXVwX3JlYWQoJmFtbi0+bG9jayk7CiAJcmV0dXJuIDA7CiB9CiAKQEAgLTI5NSwxMiArMTY0 LDEwIEBAIGFtZGdwdV9tbl9zeW5jX3BhZ2V0YWJsZXNfaHNhKHN0cnVjdCBobW1fbWlycm9yICpt aXJyb3IsCiAKIHN0YXRpYyBzdHJ1Y3QgaG1tX21pcnJvcl9vcHMgYW1kZ3B1X2htbV9taXJyb3Jf b3BzW10gPSB7CiAJW0FNREdQVV9NTl9UWVBFX0dGWF0gPSB7Ci0JCS5zeW5jX2NwdV9kZXZpY2Vf cGFnZXRhYmxlcyA9IGFtZGdwdV9tbl9zeW5jX3BhZ2V0YWJsZXNfZ2Z4LAotCQkucmVsZWFzZSA9 IGFtZGdwdV9obW1fbWlycm9yX3JlbGVhc2UKKwkJLnN5bmNfY3B1X2RldmljZV9wYWdldGFibGVz ID0gYW1kZ3B1X21uX3N5bmNfcGFnZXRhYmxlcywKIAl9LAogCVtBTURHUFVfTU5fVFlQRV9IU0Fd ID0gewotCQkuc3luY19jcHVfZGV2aWNlX3BhZ2V0YWJsZXMgPSBhbWRncHVfbW5fc3luY19wYWdl dGFibGVzX2hzYSwKLQkJLnJlbGVhc2UgPSBhbWRncHVfaG1tX21pcnJvcl9yZWxlYXNlCisJCS5z eW5jX2NwdV9kZXZpY2VfcGFnZXRhYmxlcyA9IGFtZGdwdV9tbl9zeW5jX3BhZ2V0YWJsZXMsCiAJ fSwKIH07CiAKQEAgLTMyNyw3ICsxOTQsOCBAQCBzdHJ1Y3QgYW1kZ3B1X21uICphbWRncHVfbW5f Z2V0KHN0cnVjdCBhbWRncHVfZGV2aWNlICphZGV2LAogCX0KIAogCWhhc2hfZm9yX2VhY2hfcG9z c2libGUoYWRldi0+bW5faGFzaCwgYW1uLCBub2RlLCBrZXkpCi0JCWlmIChBTURHUFVfTU5fS0VZ KGFtbi0+bW0sIGFtbi0+dHlwZSkgPT0ga2V5KQorCQlpZiAoQU1ER1BVX01OX0tFWShhbW4tPm1p cnJvci5obW0tPm1tdV9ub3RpZmllci5tbSwKKwkJCQkgIGFtbi0+dHlwZSkgPT0ga2V5KQogCQkJ Z290byByZWxlYXNlX2xvY2tzOwogCiAJYW1uID0ga3phbGxvYyhzaXplb2YoKmFtbiksIEdGUF9L RVJORUwpOwpAQCAtMzM3LDEwICsyMDUsOCBAQCBzdHJ1Y3QgYW1kZ3B1X21uICphbWRncHVfbW5f Z2V0KHN0cnVjdCBhbWRncHVfZGV2aWNlICphZGV2LAogCX0KIAogCWFtbi0+YWRldiA9IGFkZXY7 Ci0JYW1uLT5tbSA9IG1tOwogCWluaXRfcndzZW0oJmFtbi0+bG9jayk7CiAJYW1uLT50eXBlID0g dHlwZTsKLQlhbW4tPm9iamVjdHMgPSBSQl9ST09UX0NBQ0hFRDsKIAogCWFtbi0+bWlycm9yLm9w cyA9ICZhbWRncHVfaG1tX21pcnJvcl9vcHNbdHlwZV07CiAJciA9IGhtbV9taXJyb3JfcmVnaXN0 ZXIoJmFtbi0+bWlycm9yLCBtbSk7CkBAIC0zNjksMTAwICsyMzUsMzMgQEAgc3RydWN0IGFtZGdw dV9tbiAqYW1kZ3B1X21uX2dldChzdHJ1Y3QgYW1kZ3B1X2RldmljZSAqYWRldiwKICAqIEBibzog YW1kZ3B1IGJ1ZmZlciBvYmplY3QKICAqIEBhZGRyOiB1c2VycHRyIGFkZHIgd2Ugc2hvdWxkIG1v bml0b3IKICAqCi0gKiBSZWdpc3RlcnMgYW4gSE1NIG1pcnJvciBmb3IgdGhlIGdpdmVuIEJPIGF0 IHRoZSBzcGVjaWZpZWQgYWRkcmVzcy4KKyAqIFJlZ2lzdGVycyBhIG1tdV9ub3RpZmllciBmb3Ig dGhlIGdpdmVuIEJPIGF0IHRoZSBzcGVjaWZpZWQgYWRkcmVzcy4KICAqIFJldHVybnMgMCBvbiBz dWNjZXNzLCAtRVJSTk8gaWYgYW55dGhpbmcgZ29lcyB3cm9uZy4KICAqLwogaW50IGFtZGdwdV9t bl9yZWdpc3RlcihzdHJ1Y3QgYW1kZ3B1X2JvICpibywgdW5zaWduZWQgbG9uZyBhZGRyKQogewot CXVuc2lnbmVkIGxvbmcgZW5kID0gYWRkciArIGFtZGdwdV9ib19zaXplKGJvKSAtIDE7Ci0Jc3Ry dWN0IGFtZGdwdV9kZXZpY2UgKmFkZXYgPSBhbWRncHVfdHRtX2FkZXYoYm8tPnRiby5iZGV2KTsK LQllbnVtIGFtZGdwdV9tbl90eXBlIHR5cGUgPQotCQliby0+a2ZkX2JvID8gQU1ER1BVX01OX1RZ UEVfSFNBIDogQU1ER1BVX01OX1RZUEVfR0ZYOwotCXN0cnVjdCBhbWRncHVfbW4gKmFtbjsKLQlz dHJ1Y3QgYW1kZ3B1X21uX25vZGUgKm5vZGUgPSBOVUxMLCAqbmV3X25vZGU7Ci0Jc3RydWN0IGxp c3RfaGVhZCBib3M7Ci0Jc3RydWN0IGludGVydmFsX3RyZWVfbm9kZSAqaXQ7Ci0KLQlhbW4gPSBh bWRncHVfbW5fZ2V0KGFkZXYsIHR5cGUpOwotCWlmIChJU19FUlIoYW1uKSkKLQkJcmV0dXJuIFBU Ul9FUlIoYW1uKTsKLQotCW5ld19ub2RlID0ga21hbGxvYyhzaXplb2YoKm5ld19ub2RlKSwgR0ZQ X0tFUk5FTCk7Ci0JaWYgKCFuZXdfbm9kZSkKLQkJcmV0dXJuIC1FTk9NRU07Ci0KLQlJTklUX0xJ U1RfSEVBRCgmYm9zKTsKLQotCWRvd25fd3JpdGUoJmFtbi0+bG9jayk7Ci0KLQl3aGlsZSAoKGl0 ID0gaW50ZXJ2YWxfdHJlZV9pdGVyX2ZpcnN0KCZhbW4tPm9iamVjdHMsIGFkZHIsIGVuZCkpKSB7 Ci0JCWtmcmVlKG5vZGUpOwotCQlub2RlID0gY29udGFpbmVyX29mKGl0LCBzdHJ1Y3QgYW1kZ3B1 X21uX25vZGUsIGl0KTsKLQkJaW50ZXJ2YWxfdHJlZV9yZW1vdmUoJm5vZGUtPml0LCAmYW1uLT5v YmplY3RzKTsKLQkJYWRkciA9IG1pbihpdC0+c3RhcnQsIGFkZHIpOwotCQllbmQgPSBtYXgoaXQt Pmxhc3QsIGVuZCk7Ci0JCWxpc3Rfc3BsaWNlKCZub2RlLT5ib3MsICZib3MpOwotCX0KLQotCWlm ICghbm9kZSkKLQkJbm9kZSA9IG5ld19ub2RlOworCWlmIChiby0+a2ZkX2JvKQorCQliby0+bm90 aWZpZXIub3BzID0gJmFtZGdwdV9tbl9oc2Ffb3BzOwogCWVsc2UKLQkJa2ZyZWUobmV3X25vZGUp OwotCi0JYm8tPm1uID0gYW1uOwotCi0Jbm9kZS0+aXQuc3RhcnQgPSBhZGRyOwotCW5vZGUtPml0 Lmxhc3QgPSBlbmQ7Ci0JSU5JVF9MSVNUX0hFQUQoJm5vZGUtPmJvcyk7Ci0JbGlzdF9zcGxpY2Uo JmJvcywgJm5vZGUtPmJvcyk7Ci0JbGlzdF9hZGQoJmJvLT5tbl9saXN0LCAmbm9kZS0+Ym9zKTsK KwkJYm8tPm5vdGlmaWVyLm9wcyA9ICZhbWRncHVfbW5fZ2Z4X29wczsKIAotCWludGVydmFsX3Ry ZWVfaW5zZXJ0KCZub2RlLT5pdCwgJmFtbi0+b2JqZWN0cyk7Ci0KLQl1cF93cml0ZSgmYW1uLT5s b2NrKTsKLQotCXJldHVybiAwOworCXJldHVybiBtbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0KCZi by0+bm90aWZpZXIsIGFkZHIsCisJCQkJCSBhbWRncHVfYm9fc2l6ZShibyksIGN1cnJlbnQtPm1t KTsKIH0KIAogLyoqCi0gKiBhbWRncHVfbW5fdW5yZWdpc3RlciAtIHVucmVnaXN0ZXIgYSBCTyBm b3IgSE1NIG1pcnJvciB1cGRhdGVzCisgKiBhbWRncHVfbW5fdW5yZWdpc3RlciAtIHVucmVnaXN0 ZXIgYSBCTyBmb3Igbm90aWZpZXIgdXBkYXRlcwogICoKICAqIEBibzogYW1kZ3B1IGJ1ZmZlciBv YmplY3QKICAqCi0gKiBSZW1vdmUgYW55IHJlZ2lzdHJhdGlvbiBvZiBITU0gbWlycm9yIHVwZGF0 ZXMgZnJvbSB0aGUgYnVmZmVyIG9iamVjdC4KKyAqIFJlbW92ZSBhbnkgcmVnaXN0cmF0aW9uIG9m IG1tdSBub3RpZmllciB1cGRhdGVzIGZyb20gdGhlIGJ1ZmZlciBvYmplY3QuCiAgKi8KIHZvaWQg YW1kZ3B1X21uX3VucmVnaXN0ZXIoc3RydWN0IGFtZGdwdV9ibyAqYm8pCiB7Ci0Jc3RydWN0IGFt ZGdwdV9kZXZpY2UgKmFkZXYgPSBhbWRncHVfdHRtX2FkZXYoYm8tPnRiby5iZGV2KTsKLQlzdHJ1 Y3QgYW1kZ3B1X21uICphbW47Ci0Jc3RydWN0IGxpc3RfaGVhZCAqaGVhZDsKLQotCW11dGV4X2xv Y2soJmFkZXYtPm1uX2xvY2spOwotCi0JYW1uID0gYm8tPm1uOwotCWlmIChhbW4gPT0gTlVMTCkg ewotCQltdXRleF91bmxvY2soJmFkZXYtPm1uX2xvY2spOworCWlmICghYm8tPm5vdGlmaWVyLm1t KQogCQlyZXR1cm47Ci0JfQotCi0JZG93bl93cml0ZSgmYW1uLT5sb2NrKTsKLQotCS8qIHNhdmUg dGhlIG5leHQgbGlzdCBlbnRyeSBmb3IgbGF0ZXIgKi8KLQloZWFkID0gYm8tPm1uX2xpc3QubmV4 dDsKLQotCWJvLT5tbiA9IE5VTEw7Ci0JbGlzdF9kZWxfaW5pdCgmYm8tPm1uX2xpc3QpOwotCi0J aWYgKGxpc3RfZW1wdHkoaGVhZCkpIHsKLQkJc3RydWN0IGFtZGdwdV9tbl9ub2RlICpub2RlOwot Ci0JCW5vZGUgPSBjb250YWluZXJfb2YoaGVhZCwgc3RydWN0IGFtZGdwdV9tbl9ub2RlLCBib3Mp OwotCQlpbnRlcnZhbF90cmVlX3JlbW92ZSgmbm9kZS0+aXQsICZhbW4tPm9iamVjdHMpOwotCQlr ZnJlZShub2RlKTsKLQl9Ci0KLQl1cF93cml0ZSgmYW1uLT5sb2NrKTsKLQltdXRleF91bmxvY2so JmFkZXYtPm1uX2xvY2spOworCW1tdV9yYW5nZV9ub3RpZmllcl9yZW1vdmUoJmJvLT5ub3RpZmll cik7CisJYm8tPm5vdGlmaWVyLm1tID0gTlVMTDsKIH0KIAogLyogZmxhZ3MgdXNlZCBieSBITU0g aW50ZXJuYWwsIG5vdCByZWxhdGVkIHRvIENQVS9HUFUgUFRFIGZsYWdzICovCmRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uaCBiL2RyaXZlcnMvZ3B1L2Ry bS9hbWQvYW1kZ3B1L2FtZGdwdV9tbi5oCmluZGV4IGI4ZWQ2ODk0MzYyNWMyLi5kNzNhYjI5NDdi MjJiMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmgK KysrIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmgKQEAgLTM5LDEyICsz OSwxMCBAQCBlbnVtIGFtZGdwdV9tbl90eXBlIHsKICAqIHN0cnVjdCBhbWRncHVfbW4KICAqCiAg KiBAYWRldjogYW1kZ3B1IGRldmljZSBwb2ludGVyCi0gKiBAbW06IHByb2Nlc3MgYWRkcmVzcyBz cGFjZQogICogQHR5cGU6IHR5cGUgb2YgTU1VIG5vdGlmaWVyCiAgKiBAd29yazogZGVzdHJ1Y3Rp b24gd29yayBpdGVtCiAgKiBAbm9kZTogaGFzaCB0YWJsZSBub2RlIHRvIGZpbmQgc3RydWN0dXJl IGJ5IGFkZXYgYW5kIG1uCiAgKiBAbG9jazogcncgc2VtYXBob3JlIHByb3RlY3RpbmcgdGhlIG5v dGlmaWVyIG5vZGVzCi0gKiBAb2JqZWN0czogaW50ZXJ2YWwgdHJlZSBjb250YWluaW5nIGFtZGdw dV9tbl9ub2RlcwogICogQG1pcnJvcjogSE1NIG1pcnJvciBmdW5jdGlvbiBzdXBwb3J0CiAgKgog ICogRGF0YSBmb3IgZWFjaCBhbWRncHUgZGV2aWNlIGFuZCBwcm9jZXNzIGFkZHJlc3Mgc3BhY2Uu CkBAIC01Miw3ICs1MCw2IEBAIGVudW0gYW1kZ3B1X21uX3R5cGUgewogc3RydWN0IGFtZGdwdV9t biB7CiAJLyogY29uc3RhbnQgYWZ0ZXIgaW5pdGlhbGlzYXRpb24gKi8KIAlzdHJ1Y3QgYW1kZ3B1 X2RldmljZQkqYWRldjsKLQlzdHJ1Y3QgbW1fc3RydWN0CSptbTsKIAllbnVtIGFtZGdwdV9tbl90 eXBlCXR5cGU7CiAKIAkvKiBvbmx5IHVzZWQgb24gZGVzdHJ1Y3Rpb24gKi8KQEAgLTYzLDcgKzYw LDYgQEAgc3RydWN0IGFtZGdwdV9tbiB7CiAKIAkvKiBvYmplY3RzIHByb3RlY3RlZCBieSBsb2Nr ICovCiAJc3RydWN0IHJ3X3NlbWFwaG9yZQlsb2NrOwotCXN0cnVjdCByYl9yb290X2NhY2hlZAlv YmplY3RzOwogCiAjaWZkZWYgQ09ORklHX0hNTV9NSVJST1IKIAkvKiBITU0gbWlycm9yICovCmRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfb2JqZWN0LmggYi9k cml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfb2JqZWN0LmgKaW5kZXggNjU4ZjRjOTc3 OWI3MDQuLjRiNDRhYjg1MGY5NGMyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2Ft ZGdwdS9hbWRncHVfb2JqZWN0LmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1k Z3B1X29iamVjdC5oCkBAIC0zMCw2ICszMCw5IEBACiAKICNpbmNsdWRlIDxkcm0vYW1kZ3B1X2Ry bS5oPgogI2luY2x1ZGUgImFtZGdwdS5oIgorI2lmZGVmIENPTkZJR19NTVVfTk9USUZJRVIKKyNp bmNsdWRlIDxsaW51eC9tbXVfbm90aWZpZXIuaD4KKyNlbmRpZgogCiAjZGVmaW5lIEFNREdQVV9C T19JTlZBTElEX09GRlNFVAlMT05HX01BWAogI2RlZmluZSBBTURHUFVfQk9fTUFYX1BMQUNFTUVO VFMJMwpAQCAtMTAwLDEwICsxMDMsMTIgQEAgc3RydWN0IGFtZGdwdV9ibyB7CiAJc3RydWN0IHR0 bV9ib19rbWFwX29iagkJZG1hX2J1Zl92bWFwOwogCXN0cnVjdCBhbWRncHVfbW4JCSptbjsKIAot CXVuaW9uIHsKLQkJc3RydWN0IGxpc3RfaGVhZAltbl9saXN0OwotCQlzdHJ1Y3QgbGlzdF9oZWFk CXNoYWRvd19saXN0OwotCX07CisKKyNpZmRlZiBDT05GSUdfTU1VX05PVElGSUVSCisJc3RydWN0 IG1tdV9yYW5nZV9ub3RpZmllcglub3RpZmllcjsKKyNlbmRpZgorCisJc3RydWN0IGxpc3RfaGVh ZAkJc2hhZG93X2xpc3Q7CiAKIAlzdHJ1Y3Qga2dkX21lbSAgICAgICAgICAgICAgICAgICprZmRf Ym87CiB9OwotLSAKMi4yMy4wCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KWGVuLWRldmVsIG1haWxpbmcgbGlzdApYZW4tZGV2ZWxAbGlzdHMueGVucHJv amVjdC5vcmcKaHR0cHM6Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL3hl bi1kZXZlbA== 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 9145ACA9EC1 for ; Mon, 28 Oct 2019 21:08:14 +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 6EEB2217D6 for ; Mon, 28 Oct 2019 21:08:14 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 6EEB2217D6 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 5C3BC6EA67; Mon, 28 Oct 2019 21:08:00 +0000 (UTC) Received: from mail-qt1-x842.google.com (mail-qt1-x842.google.com [IPv6:2607:f8b0:4864:20::842]) by gabe.freedesktop.org (Postfix) with ESMTPS id 918F76EA01 for ; Mon, 28 Oct 2019 20:21:11 +0000 (UTC) Received: by mail-qt1-x842.google.com with SMTP id x14so6275113qtq.3 for ; Mon, 28 Oct 2019 13:21:11 -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=f54wq5BOB+L91cuUIb1GfXpGUvNo7lL3IgdsSk0oLWI=; b=BlO666d19FXCbFSD2l0AF86Mdk7LAPnIVl1yi1ONdsV/hjXWb7rVGB7ImG76IEcmrp Xz5m80pWFQtEjNspab6dPxgXcEKDSblpmo//uRN7ZXoricqjhwaPaEJdyJpEaGVbnPTl N9/OHcA8vJ0aKdzhK3vcAvcBMyYhPEwXJJVT4lK82ONLuvJY6H4Ei4zXqSM3J5WNdUzR S/SNMIZ+cNH34qyJ6wZ9FvUUc1lfaQkeWIxATBV9Ich/mh3BzNGkv/f68Zhii/gTUjDr wUt2cUiCMtmP1X5rFUy7Hd5gfHzbL1SCbxJIle1lhbGjrwvTxXfRQCYkYTm0oZNlN/U2 gVbg== X-Gm-Message-State: APjAAAWtBtdH9lSut6HaETD9K8FRQZipB60JmZNaOhAvfXxjgQ6XJIt0 st2VySAhzWiEjlQC9gSmabFlQw== X-Google-Smtp-Source: APXvYqwq2Y0Q6HWDIbs7vkuLUQo9mosZUKJbVQ8JILYrIGj2H8AgBVH06Qhu2TcTbLBJgxthQ23WKA== X-Received: by 2002:a05:6214:14ac:: with SMTP id bo12mr17885970qvb.67.1572294070501; Mon, 28 Oct 2019 13:21:10 -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 w131sm6550657qka.85.2019.10.28.13.21.09 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Mon, 28 Oct 2019 13:21:09 -0700 (PDT) Received: from jgg by mlx.ziepe.ca with local (Exim 4.90_1) (envelope-from ) id 1iPBLf-0001hF-L8; 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 13/15] drm/amdgpu: Use mmu_range_insert instead of hmm_mirror Date: Mon, 28 Oct 2019 17:10:30 -0300 Message-Id: <20191028201032.6352-14-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=f54wq5BOB+L91cuUIb1GfXpGUvNo7lL3IgdsSk0oLWI=; b=l4b6BiRzQbpC7T2GUxlPwjsdxPoQOk1FEPvAXONkG/JTKYB9azNhf74H1C4wi7aQSp 8A9jFV987xM6BpaBeNouD/l/GAxvjknDJS/NO03bddceTqett3RlzyU2OehGxRCGAxRx VRLi47+XEZkpQBZ079F1MnS9P763EC47IrVHlcaPUxwm9kP9JrnJ3RFygb28rTnhXydF 5FzebAKk3jhDaSXSdwhUukrFq7F5R19QvmFj8uU5j3Di5Kj9qaNRbbV/6rmYeeL0Df9a HzbpJ23C0BmdJ2aw1hETLPxUaEfvdYquQMl+Ku4SHxEshKk7ymPS56K6cQKlUnwCjURY RJ4g== 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: <20191028201030.xQuKkTXJtDVlq1HtXo2eKZK_RO_A-4jedPzSyA8O5Uo@z> RnJvbTogSmFzb24gR3VudGhvcnBlIDxqZ2dAbWVsbGFub3guY29tPgoKUmVtb3ZlIHRoZSBpbnRl cnZhbCB0cmVlIGluIHRoZSBkcml2ZXIgYW5kIHJlbHkgb24gdGhlIHRyZWUgbWFpbnRhaW5lZCBi eQp0aGUgbW11X25vdGlmaWVyIGZvciBkZWxpdmVyaW5nIG1tdV9ub3RpZmllciBpbnZhbGlkYXRp b24gY2FsbGJhY2tzLgoKRm9yIHNvbWUgcmVhc29uIGFtZGdwdSBoYXMgYSB2ZXJ5IGNvbXBsaWNh dGVkIGFycmFuZ2VtZW50IHdoZXJlIGl0IHRyaWVzCnRvIHByZXZlbnQgZHVwbGljYXRlIGVudHJp ZXMgaW4gdGhlIGludGVydmFsX3RyZWUsIHRoaXMgaXMgbm90IG5lY2Vzc2FyeSwKZWFjaCBhbWRn cHVfYm8gY2FuIGJlIGl0cyBvd24gc3RhbmQgYWxvbmUgZW50cnkuIGludGVydmFsX3RyZWUgYWxy ZWFkeQphbGxvd3MgZHVwbGljYXRlcyBhbmQgb3ZlcmxhcHMgaW4gdGhlIHRyZWUuCgpBbHNvLCB0 aGVyZSBpcyBubyBuZWVkIHRvIHJlbW92ZSBlbnRyaWVzIHVwb24gYSByZWxlYXNlIGNhbGxiYWNr LCB0aGUKbW11X3JhbmdlIEFQSSBzYWZlbHkgYWxsb3dzIG9iamVjdHMgdG8gcmVtYWluIHJlZ2lz dGVyZWQgYmV5b25kIHRoZQpsaWZldGltZSBvZiB0aGUgbW0uIFRoZSBkcml2ZXIgb25seSBoYXMg dG8gc3RvcCB0b3VjaGluZyB0aGUgcGFnZXMgZHVyaW5nCnJlbGVhc2UuCgpDYzogQWxleCBEZXVj aGVyIDxhbGV4YW5kZXIuZGV1Y2hlckBhbWQuY29tPgpDYzogQ2hyaXN0aWFuIEvDtm5pZyA8Y2hy aXN0aWFuLmtvZW5pZ0BhbWQuY29tPgpDYzogRGF2aWQgKENodW5NaW5nKSBaaG91IDxEYXZpZDEu WmhvdUBhbWQuY29tPgpDYzogYW1kLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKU2lnbmVkLW9m Zi1ieTogSmFzb24gR3VudGhvcnBlIDxqZ2dAbWVsbGFub3guY29tPgotLS0KIGRyaXZlcnMvZ3B1 L2RybS9hbWQvYW1kZ3B1L2FtZGdwdS5oICAgICAgICAgICB8ICAgMiArCiAuLi4vZ3B1L2RybS9h bWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYyAgfCAgIDUgKy0KIGRyaXZlcnMvZ3B1L2Ry bS9hbWQvYW1kZ3B1L2FtZGdwdV9kZXZpY2UuYyAgICB8ICAgMSArCiBkcml2ZXJzL2dwdS9kcm0v YW1kL2FtZGdwdS9hbWRncHVfbW4uYyAgICAgICAgfCAzNDEgKysrKy0tLS0tLS0tLS0tLS0tCiBk cml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uaCAgICAgICAgfCAgIDQgLQogZHJp dmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X29iamVjdC5oICAgIHwgIDEzICstCiA2IGZp bGVzIGNoYW5nZWQsIDg0IGluc2VydGlvbnMoKyksIDI4MiBkZWxldGlvbnMoLSkKCmRpZmYgLS1n aXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHUuaCBiL2RyaXZlcnMvZ3B1L2Ry bS9hbWQvYW1kZ3B1L2FtZGdwdS5oCmluZGV4IGJkMzdkZjVkZDZkMDQ4Li42MDU5MWE1ZDQyMDAy MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1LmgKKysrIGIv ZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1LmgKQEAgLTEwMDYsNiArMTAwNiw4IEBA IHN0cnVjdCBhbWRncHVfZGV2aWNlIHsKIAlzdHJ1Y3QgbXV0ZXggIGxvY2tfcmVzZXQ7CiAJc3Ry dWN0IGFtZGdwdV9kb29yYmVsbF9pbmRleCBkb29yYmVsbF9pbmRleDsKIAorCXN0cnVjdCBtdXRl eAkJCW5vdGlmaWVyX2xvY2s7CisKIAlpbnQgYXNpY19yZXNldF9yZXM7CiAJc3RydWN0IHdvcmtf c3RydWN0CQl4Z21pX3Jlc2V0X3dvcms7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9h bWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1k Z3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYwppbmRleCA2ZDAyMWVjYzhkNTk4Zi4uNDc3MDAzMDJh MDhiN2YgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9hbWRr ZmRfZ3B1dm0uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfYW1ka2Zk X2dwdXZtLmMKQEAgLTQ4MSw4ICs0ODEsNyBAQCBzdGF0aWMgdm9pZCByZW1vdmVfa2dkX21lbV9m cm9tX2tmZF9ib19saXN0KHN0cnVjdCBrZ2RfbWVtICptZW0sCiAgKgogICogUmV0dXJucyAwIGZv ciBzdWNjZXNzLCBuZWdhdGl2ZSBlcnJubyBmb3IgZXJyb3JzLgogICovCi1zdGF0aWMgaW50IGlu aXRfdXNlcl9wYWdlcyhzdHJ1Y3Qga2dkX21lbSAqbWVtLCBzdHJ1Y3QgbW1fc3RydWN0ICptbSwK LQkJCSAgIHVpbnQ2NF90IHVzZXJfYWRkcikKK3N0YXRpYyBpbnQgaW5pdF91c2VyX3BhZ2VzKHN0 cnVjdCBrZ2RfbWVtICptZW0sIHVpbnQ2NF90IHVzZXJfYWRkcikKIHsKIAlzdHJ1Y3QgYW1ka2Zk X3Byb2Nlc3NfaW5mbyAqcHJvY2Vzc19pbmZvID0gbWVtLT5wcm9jZXNzX2luZm87CiAJc3RydWN0 IGFtZGdwdV9ibyAqYm8gPSBtZW0tPmJvOwpAQCAtMTE5NSw3ICsxMTk0LDcgQEAgaW50IGFtZGdw dV9hbWRrZmRfZ3B1dm1fYWxsb2NfbWVtb3J5X29mX2dwdSgKIAlhZGRfa2dkX21lbV90b19rZmRf Ym9fbGlzdCgqbWVtLCBhdm0tPnByb2Nlc3NfaW5mbywgdXNlcl9hZGRyKTsKIAogCWlmICh1c2Vy X2FkZHIpIHsKLQkJcmV0ID0gaW5pdF91c2VyX3BhZ2VzKCptZW0sIGN1cnJlbnQtPm1tLCB1c2Vy X2FkZHIpOworCQlyZXQgPSBpbml0X3VzZXJfcGFnZXMoKm1lbSwgdXNlcl9hZGRyKTsKIAkJaWYg KHJldCkKIAkJCWdvdG8gYWxsb2NhdGVfaW5pdF91c2VyX3BhZ2VzX2ZhaWxlZDsKIAl9CmRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfZGV2aWNlLmMgYi9kcml2 ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfZGV2aWNlLmMKaW5kZXggNWExOTM5ZGJkNGUz ZTYuLjM4Zjk3OTk4YWFkZGIyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdw dS9hbWRncHVfZGV2aWNlLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1 X2RldmljZS5jCkBAIC0yNjMzLDYgKzI2MzMsNyBAQCBpbnQgYW1kZ3B1X2RldmljZV9pbml0KHN0 cnVjdCBhbWRncHVfZGV2aWNlICphZGV2LAogCW11dGV4X2luaXQoJmFkZXYtPnZpcnQudmZfZXJy b3JzLmxvY2spOwogCWhhc2hfaW5pdChhZGV2LT5tbl9oYXNoKTsKIAltdXRleF9pbml0KCZhZGV2 LT5sb2NrX3Jlc2V0KTsKKwltdXRleF9pbml0KCZhZGV2LT5ub3RpZmllcl9sb2NrKTsKIAltdXRl eF9pbml0KCZhZGV2LT52aXJ0LmRwbV9tdXRleCk7CiAJbXV0ZXhfaW5pdCgmYWRldi0+cHNwLm11 dGV4KTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21u LmMgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uYwppbmRleCAzMWQ0ZGVi NWQyOTQ4NC4uNGZmZDdiOTBmNGQ5MDcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQv YW1kZ3B1L2FtZGdwdV9tbi5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdw dV9tbi5jCkBAIC01MCw2NiArNTAsNiBAQAogI2luY2x1ZGUgImFtZGdwdS5oIgogI2luY2x1ZGUg ImFtZGdwdV9hbWRrZmQuaCIKIAotLyoqCi0gKiBzdHJ1Y3QgYW1kZ3B1X21uX25vZGUKLSAqCi0g KiBAaXQ6IGludGVydmFsIG5vZGUgZGVmaW5pbmcgc3RhcnQtbGFzdCBvZiB0aGUgYWZmZWN0ZWQg YWRkcmVzcyByYW5nZQotICogQGJvczogbGlzdCBvZiBhbGwgQk9zIGluIHRoZSBhZmZlY3RlZCBh ZGRyZXNzIHJhbmdlCi0gKgotICogTWFuYWdlcyBhbGwgQk9zIHdoaWNoIGFyZSBhZmZlY3RlZCBv ZiBhIGNlcnRhaW4gcmFuZ2Ugb2YgYWRkcmVzcyBzcGFjZS4KLSAqLwotc3RydWN0IGFtZGdwdV9t bl9ub2RlIHsKLQlzdHJ1Y3QgaW50ZXJ2YWxfdHJlZV9ub2RlCWl0OwotCXN0cnVjdCBsaXN0X2hl YWQJCWJvczsKLX07Ci0KLS8qKgotICogYW1kZ3B1X21uX2Rlc3Ryb3kgLSBkZXN0cm95IHRoZSBI TU0gbWlycm9yCi0gKgotICogQHdvcms6IHByZXZpb3VzbHkgc2hlZHVsZWQgd29yayBpdGVtCi0g KgotICogTGF6eSBkZXN0cm95cyB0aGUgbm90aWZpZXIgZnJvbSBhIHdvcmsgaXRlbQotICovCi1z dGF0aWMgdm9pZCBhbWRncHVfbW5fZGVzdHJveShzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCi17 Ci0Jc3RydWN0IGFtZGdwdV9tbiAqYW1uID0gY29udGFpbmVyX29mKHdvcmssIHN0cnVjdCBhbWRn cHVfbW4sIHdvcmspOwotCXN0cnVjdCBhbWRncHVfZGV2aWNlICphZGV2ID0gYW1uLT5hZGV2Owot CXN0cnVjdCBhbWRncHVfbW5fbm9kZSAqbm9kZSwgKm5leHRfbm9kZTsKLQlzdHJ1Y3QgYW1kZ3B1 X2JvICpibywgKm5leHRfYm87Ci0KLQltdXRleF9sb2NrKCZhZGV2LT5tbl9sb2NrKTsKLQlkb3du X3dyaXRlKCZhbW4tPmxvY2spOwotCWhhc2hfZGVsKCZhbW4tPm5vZGUpOwotCXJidHJlZV9wb3N0 b3JkZXJfZm9yX2VhY2hfZW50cnlfc2FmZShub2RlLCBuZXh0X25vZGUsCi0JCQkJCSAgICAgJmFt bi0+b2JqZWN0cy5yYl9yb290LCBpdC5yYikgewotCQlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUo Ym8sIG5leHRfYm8sICZub2RlLT5ib3MsIG1uX2xpc3QpIHsKLQkJCWJvLT5tbiA9IE5VTEw7Ci0J CQlsaXN0X2RlbF9pbml0KCZiby0+bW5fbGlzdCk7Ci0JCX0KLQkJa2ZyZWUobm9kZSk7Ci0JfQot CXVwX3dyaXRlKCZhbW4tPmxvY2spOwotCW11dGV4X3VubG9jaygmYWRldi0+bW5fbG9jayk7Ci0K LQlobW1fbWlycm9yX3VucmVnaXN0ZXIoJmFtbi0+bWlycm9yKTsKLQlrZnJlZShhbW4pOwotfQot Ci0vKioKLSAqIGFtZGdwdV9obW1fbWlycm9yX3JlbGVhc2UgLSBjYWxsYmFjayB0byBub3RpZnkg YWJvdXQgbW0gZGVzdHJ1Y3Rpb24KLSAqCi0gKiBAbWlycm9yOiB0aGUgSE1NIG1pcnJvciAobW0p IHRoaXMgY2FsbGJhY2sgaXMgYWJvdXQKLSAqCi0gKiBTaGVkdWxlIGEgd29yayBpdGVtIHRvIGxh enkgZGVzdHJveSBITU0gbWlycm9yLgotICovCi1zdGF0aWMgdm9pZCBhbWRncHVfaG1tX21pcnJv cl9yZWxlYXNlKHN0cnVjdCBobW1fbWlycm9yICptaXJyb3IpCi17Ci0Jc3RydWN0IGFtZGdwdV9t biAqYW1uID0gY29udGFpbmVyX29mKG1pcnJvciwgc3RydWN0IGFtZGdwdV9tbiwgbWlycm9yKTsK LQotCUlOSVRfV09SSygmYW1uLT53b3JrLCBhbWRncHVfbW5fZGVzdHJveSk7Ci0Jc2NoZWR1bGVf d29yaygmYW1uLT53b3JrKTsKLX0KLQogLyoqCiAgKiBhbWRncHVfbW5fbG9jayAtIHRha2UgdGhl IHdyaXRlIHNpZGUgbG9jayBmb3IgdGhpcyBub3RpZmllcgogICoKQEAgLTEzMywxNTcgKzczLDg2 IEBAIHZvaWQgYW1kZ3B1X21uX3VubG9jayhzdHJ1Y3QgYW1kZ3B1X21uICptbikKIH0KIAogLyoq Ci0gKiBhbWRncHVfbW5fcmVhZF9sb2NrIC0gdGFrZSB0aGUgcmVhZCBzaWRlIGxvY2sgZm9yIHRo aXMgbm90aWZpZXIKLSAqCi0gKiBAYW1uOiBvdXIgbm90aWZpZXIKLSAqLwotc3RhdGljIGludCBh bWRncHVfbW5fcmVhZF9sb2NrKHN0cnVjdCBhbWRncHVfbW4gKmFtbiwgYm9vbCBibG9ja2FibGUp Ci17Ci0JaWYgKGJsb2NrYWJsZSkKLQkJZG93bl9yZWFkKCZhbW4tPmxvY2spOwotCWVsc2UgaWYg KCFkb3duX3JlYWRfdHJ5bG9jaygmYW1uLT5sb2NrKSkKLQkJcmV0dXJuIC1FQUdBSU47Ci0KLQly ZXR1cm4gMDsKLX0KLQotLyoqCi0gKiBhbWRncHVfbW5fcmVhZF91bmxvY2sgLSBkcm9wIHRoZSBy ZWFkIHNpZGUgbG9jayBmb3IgdGhpcyBub3RpZmllcgotICoKLSAqIEBhbW46IG91ciBub3RpZmll cgotICovCi1zdGF0aWMgdm9pZCBhbWRncHVfbW5fcmVhZF91bmxvY2soc3RydWN0IGFtZGdwdV9t biAqYW1uKQotewotCXVwX3JlYWQoJmFtbi0+bG9jayk7Ci19Ci0KLS8qKgotICogYW1kZ3B1X21u X2ludmFsaWRhdGVfbm9kZSAtIHVubWFwIGFsbCBCT3Mgb2YgYSBub2RlCisgKiBhbWRncHVfbW5f aW52YWxpZGF0ZV9nZnggLSBjYWxsYmFjayB0byBub3RpZnkgYWJvdXQgbW0gY2hhbmdlCiAgKgot ICogQG5vZGU6IHRoZSBub2RlIHdpdGggdGhlIEJPcyB0byB1bm1hcAotICogQHN0YXJ0OiBzdGFy dCBvZiBhZGRyZXNzIHJhbmdlIGFmZmVjdGVkCi0gKiBAZW5kOiBlbmQgb2YgYWRkcmVzcyByYW5n ZSBhZmZlY3RlZAorICogQG1ybjogdGhlIHJhbmdlIChtbSkgaXMgYWJvdXQgdG8gdXBkYXRlCisg KiBAcmFuZ2U6IGRldGFpbHMgb24gdGhlIGludmFsaWRhdGlvbgogICoKICAqIEJsb2NrIGZvciBv cGVyYXRpb25zIG9uIEJPcyB0byBmaW5pc2ggYW5kIG1hcmsgcGFnZXMgYXMgYWNjZXNzZWQgYW5k CiAgKiBwb3RlbnRpYWxseSBkaXJ0eS4KICAqLwotc3RhdGljIHZvaWQgYW1kZ3B1X21uX2ludmFs aWRhdGVfbm9kZShzdHJ1Y3QgYW1kZ3B1X21uX25vZGUgKm5vZGUsCi0JCQkJICAgICAgdW5zaWdu ZWQgbG9uZyBzdGFydCwKLQkJCQkgICAgICB1bnNpZ25lZCBsb25nIGVuZCkKK3N0YXRpYyBib29s IGFtZGdwdV9tbl9pbnZhbGlkYXRlX2dmeChzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyICptcm4s CisJCQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICpyYW5nZSkKIHsKLQlz dHJ1Y3QgYW1kZ3B1X2JvICpibzsKKwlzdHJ1Y3QgYW1kZ3B1X2JvICpibyA9IGNvbnRhaW5lcl9v Zihtcm4sIHN0cnVjdCBhbWRncHVfYm8sIG5vdGlmaWVyKTsKKwlzdHJ1Y3QgYW1kZ3B1X2Rldmlj ZSAqYWRldiA9IGFtZGdwdV90dG1fYWRldihiby0+dGJvLmJkZXYpOwogCWxvbmcgcjsKIAotCWxp c3RfZm9yX2VhY2hfZW50cnkoYm8sICZub2RlLT5ib3MsIG1uX2xpc3QpIHsKLQotCQlpZiAoIWFt ZGdwdV90dG1fdHRfYWZmZWN0X3VzZXJwdHIoYm8tPnRiby50dG0sIHN0YXJ0LCBlbmQpKQotCQkJ Y29udGludWU7Ci0KLQkJciA9IGRtYV9yZXN2X3dhaXRfdGltZW91dF9yY3UoYm8tPnRiby5iYXNl LnJlc3YsCi0JCQl0cnVlLCBmYWxzZSwgTUFYX1NDSEVEVUxFX1RJTUVPVVQpOwotCQlpZiAociA8 PSAwKQotCQkJRFJNX0VSUk9SKCIoJWxkKSBmYWlsZWQgdG8gd2FpdCBmb3IgdXNlciBib1xuIiwg cik7Ci0JfQorCS8qIEZJWE1FOiBJcyB0aGlzIG5lY2Vzc2FyeT8gKi8KKwlpZiAoIWFtZGdwdV90 dG1fdHRfYWZmZWN0X3VzZXJwdHIoYm8tPnRiby50dG0sIHJhbmdlLT5zdGFydCwKKwkJCQkJICBy YW5nZS0+ZW5kKSkKKwkJcmV0dXJuIHRydWU7CisKKwlpZiAoIW1tdV9ub3RpZmllcl9yYW5nZV9i bG9ja2FibGUocmFuZ2UpKQorCQlyZXR1cm4gZmFsc2U7CisKKwltdXRleF9sb2NrKCZhZGV2LT5u b3RpZmllcl9sb2NrKTsKKwlyID0gZG1hX3Jlc3Zfd2FpdF90aW1lb3V0X3JjdShiby0+dGJvLmJh c2UucmVzdiwgdHJ1ZSwgZmFsc2UsCisJCQkJICAgICAgTUFYX1NDSEVEVUxFX1RJTUVPVVQpOwor CW11dGV4X3VubG9jaygmYWRldi0+bm90aWZpZXJfbG9jayk7CisJaWYgKHIgPD0gMCkKKwkJRFJN X0VSUk9SKCIoJWxkKSBmYWlsZWQgdG8gd2FpdCBmb3IgdXNlciBib1xuIiwgcik7CisJcmV0dXJu IHRydWU7CiB9CiAKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyX29wcyBh bWRncHVfbW5fZ2Z4X29wcyA9IHsKKwkuaW52YWxpZGF0ZSA9IGFtZGdwdV9tbl9pbnZhbGlkYXRl X2dmeCwKK307CisKIC8qKgotICogYW1kZ3B1X21uX3N5bmNfcGFnZXRhYmxlc19nZnggLSBjYWxs YmFjayB0byBub3RpZnkgYWJvdXQgbW0gY2hhbmdlCisgKiBhbWRncHVfbW5faW52YWxpZGF0ZV9o c2EgLSBjYWxsYmFjayB0byBub3RpZnkgYWJvdXQgbW0gY2hhbmdlCiAgKgotICogQG1pcnJvcjog dGhlIGhtbV9taXJyb3IgKG1tKSBpcyBhYm91dCB0byB1cGRhdGUKLSAqIEB1cGRhdGU6IHRoZSB1 cGRhdGUgc3RhcnQsIGVuZCBhZGRyZXNzCisgKiBAbXJuOiB0aGUgcmFuZ2UgKG1tKSBpcyBhYm91 dCB0byB1cGRhdGUKKyAqIEByYW5nZTogZGV0YWlscyBvbiB0aGUgaW52YWxpZGF0aW9uCiAgKgot ICogQmxvY2sgZm9yIG9wZXJhdGlvbnMgb24gQk9zIHRvIGZpbmlzaCBhbmQgbWFyayBwYWdlcyBh cyBhY2Nlc3NlZCBhbmQKLSAqIHBvdGVudGlhbGx5IGRpcnR5LgorICogV2UgdGVtcG9yYXJpbHkg ZXZpY3QgdGhlIEJPIGF0dGFjaGVkIHRvIHRoaXMgcmFuZ2UuIFRoaXMgbmVjZXNzaXRhdGVzCisg KiBldmljdGluZyBhbGwgdXNlci1tb2RlIHF1ZXVlcyBvZiB0aGUgcHJvY2Vzcy4KICAqLwotc3Rh dGljIGludAotYW1kZ3B1X21uX3N5bmNfcGFnZXRhYmxlc19nZngoc3RydWN0IGhtbV9taXJyb3Ig Km1pcnJvciwKLQkJCSAgICAgIGNvbnN0IHN0cnVjdCBtbXVfbm90aWZpZXJfcmFuZ2UgKnVwZGF0 ZSkKK3N0YXRpYyBib29sIGFtZGdwdV9tbl9pbnZhbGlkYXRlX2hzYShzdHJ1Y3QgbW11X3Jhbmdl X25vdGlmaWVyICptcm4sCisJCQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3Jhbmdl ICpyYW5nZSkKIHsKLQlzdHJ1Y3QgYW1kZ3B1X21uICphbW4gPSBjb250YWluZXJfb2YobWlycm9y LCBzdHJ1Y3QgYW1kZ3B1X21uLCBtaXJyb3IpOwotCXVuc2lnbmVkIGxvbmcgc3RhcnQgPSB1cGRh dGUtPnN0YXJ0OwotCXVuc2lnbmVkIGxvbmcgZW5kID0gdXBkYXRlLT5lbmQ7Ci0JYm9vbCBibG9j a2FibGUgPSBtbXVfbm90aWZpZXJfcmFuZ2VfYmxvY2thYmxlKHVwZGF0ZSk7Ci0Jc3RydWN0IGlu dGVydmFsX3RyZWVfbm9kZSAqaXQ7Ci0KLQkvKiBub3RpZmljYXRpb24gaXMgZXhjbHVzaXZlLCBi dXQgaW50ZXJ2YWwgaXMgaW5jbHVzaXZlICovCi0JZW5kIC09IDE7Ci0KLQkvKiBUT0RPIHdlIHNo b3VsZCBiZSBhYmxlIHRvIHNwbGl0IGxvY2tpbmcgZm9yIGludGVydmFsIHRyZWUgYW5kCi0JICog YW1kZ3B1X21uX2ludmFsaWRhdGVfbm9kZQotCSAqLwotCWlmIChhbWRncHVfbW5fcmVhZF9sb2Nr KGFtbiwgYmxvY2thYmxlKSkKLQkJcmV0dXJuIC1FQUdBSU47Ci0KLQlpdCA9IGludGVydmFsX3Ry ZWVfaXRlcl9maXJzdCgmYW1uLT5vYmplY3RzLCBzdGFydCwgZW5kKTsKLQl3aGlsZSAoaXQpIHsK LQkJc3RydWN0IGFtZGdwdV9tbl9ub2RlICpub2RlOwotCi0JCWlmICghYmxvY2thYmxlKSB7Ci0J CQlhbWRncHVfbW5fcmVhZF91bmxvY2soYW1uKTsKLQkJCXJldHVybiAtRUFHQUlOOwotCQl9CisJ c3RydWN0IGFtZGdwdV9ibyAqYm8gPSBjb250YWluZXJfb2YobXJuLCBzdHJ1Y3QgYW1kZ3B1X2Jv LCBub3RpZmllcik7CisJc3RydWN0IGFtZGdwdV9kZXZpY2UgKmFkZXYgPSBhbWRncHVfdHRtX2Fk ZXYoYm8tPnRiby5iZGV2KTsKIAotCQlub2RlID0gY29udGFpbmVyX29mKGl0LCBzdHJ1Y3QgYW1k Z3B1X21uX25vZGUsIGl0KTsKLQkJaXQgPSBpbnRlcnZhbF90cmVlX2l0ZXJfbmV4dChpdCwgc3Rh cnQsIGVuZCk7CisJLyogRklYTUU6IElzIHRoaXMgbmVjZXNzYXJ5PyAqLworCWlmICghYW1kZ3B1 X3R0bV90dF9hZmZlY3RfdXNlcnB0cihiby0+dGJvLnR0bSwgcmFuZ2UtPnN0YXJ0LAorCQkJCQkg IHJhbmdlLT5lbmQpKQorCQlyZXR1cm4gdHJ1ZTsKIAotCQlhbWRncHVfbW5faW52YWxpZGF0ZV9u b2RlKG5vZGUsIHN0YXJ0LCBlbmQpOwotCX0KKwlpZiAoIW1tdV9ub3RpZmllcl9yYW5nZV9ibG9j a2FibGUocmFuZ2UpKQorCQlyZXR1cm4gZmFsc2U7CiAKLQlhbWRncHVfbW5fcmVhZF91bmxvY2so YW1uKTsKKwltdXRleF9sb2NrKCZhZGV2LT5ub3RpZmllcl9sb2NrKTsKKwlhbWRncHVfYW1ka2Zk X2V2aWN0X3VzZXJwdHIoYm8tPmtmZF9ibywgYm8tPm5vdGlmaWVyLm1tKTsKKwltdXRleF91bmxv Y2soJmFkZXYtPm5vdGlmaWVyX2xvY2spOwogCi0JcmV0dXJuIDA7CisJcmV0dXJuIHRydWU7CiB9 CiAKLS8qKgotICogYW1kZ3B1X21uX3N5bmNfcGFnZXRhYmxlc19oc2EgLSBjYWxsYmFjayB0byBu b3RpZnkgYWJvdXQgbW0gY2hhbmdlCi0gKgotICogQG1pcnJvcjogdGhlIGhtbV9taXJyb3IgKG1t KSBpcyBhYm91dCB0byB1cGRhdGUKLSAqIEB1cGRhdGU6IHRoZSB1cGRhdGUgc3RhcnQsIGVuZCBh ZGRyZXNzCi0gKgotICogV2UgdGVtcG9yYXJpbHkgZXZpY3QgYWxsIEJPcyBiZXR3ZWVuIHN0YXJ0 IGFuZCBlbmQuIFRoaXMKLSAqIG5lY2Vzc2l0YXRlcyBldmljdGluZyBhbGwgdXNlci1tb2RlIHF1 ZXVlcyBvZiB0aGUgcHJvY2Vzcy4gVGhlIEJPcwotICogYXJlIHJlc3RvcnRlZCBpbiBhbWRncHVf bW5faW52YWxpZGF0ZV9yYW5nZV9lbmRfaHNhLgotICovCi1zdGF0aWMgaW50Ci1hbWRncHVfbW5f c3luY19wYWdldGFibGVzX2hzYShzdHJ1Y3QgaG1tX21pcnJvciAqbWlycm9yLAotCQkJICAgICAg Y29uc3Qgc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAqdXBkYXRlKQorc3RhdGljIGNvbnN0IHN0 cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXJfb3BzIGFtZGdwdV9tbl9oc2Ffb3BzID0geworCS5pbnZh bGlkYXRlID0gYW1kZ3B1X21uX2ludmFsaWRhdGVfaHNhLAorfTsKKworc3RhdGljIGludCBhbWRn cHVfbW5fc3luY19wYWdldGFibGVzKHN0cnVjdCBobW1fbWlycm9yICptaXJyb3IsCisJCQkJICAg ICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICp1cGRhdGUpCiB7CiAJc3RydWN0IGFt ZGdwdV9tbiAqYW1uID0gY29udGFpbmVyX29mKG1pcnJvciwgc3RydWN0IGFtZGdwdV9tbiwgbWly cm9yKTsKLQl1bnNpZ25lZCBsb25nIHN0YXJ0ID0gdXBkYXRlLT5zdGFydDsKLQl1bnNpZ25lZCBs b25nIGVuZCA9IHVwZGF0ZS0+ZW5kOwotCWJvb2wgYmxvY2thYmxlID0gbW11X25vdGlmaWVyX3Jh bmdlX2Jsb2NrYWJsZSh1cGRhdGUpOwotCXN0cnVjdCBpbnRlcnZhbF90cmVlX25vZGUgKml0Owog Ci0JLyogbm90aWZpY2F0aW9uIGlzIGV4Y2x1c2l2ZSwgYnV0IGludGVydmFsIGlzIGluY2x1c2l2 ZSAqLwotCWVuZCAtPSAxOwotCi0JaWYgKGFtZGdwdV9tbl9yZWFkX2xvY2soYW1uLCBibG9ja2Fi bGUpKQotCQlyZXR1cm4gLUVBR0FJTjsKLQotCWl0ID0gaW50ZXJ2YWxfdHJlZV9pdGVyX2ZpcnN0 KCZhbW4tPm9iamVjdHMsIHN0YXJ0LCBlbmQpOwotCXdoaWxlIChpdCkgewotCQlzdHJ1Y3QgYW1k Z3B1X21uX25vZGUgKm5vZGU7Ci0JCXN0cnVjdCBhbWRncHVfYm8gKmJvOwotCi0JCWlmICghYmxv Y2thYmxlKSB7Ci0JCQlhbWRncHVfbW5fcmVhZF91bmxvY2soYW1uKTsKLQkJCXJldHVybiAtRUFH QUlOOwotCQl9Ci0KLQkJbm9kZSA9IGNvbnRhaW5lcl9vZihpdCwgc3RydWN0IGFtZGdwdV9tbl9u b2RlLCBpdCk7Ci0JCWl0ID0gaW50ZXJ2YWxfdHJlZV9pdGVyX25leHQoaXQsIHN0YXJ0LCBlbmQp OwotCi0JCWxpc3RfZm9yX2VhY2hfZW50cnkoYm8sICZub2RlLT5ib3MsIG1uX2xpc3QpIHsKLQkJ CXN0cnVjdCBrZ2RfbWVtICptZW0gPSBiby0+a2ZkX2JvOwotCi0JCQlpZiAoYW1kZ3B1X3R0bV90 dF9hZmZlY3RfdXNlcnB0cihiby0+dGJvLnR0bSwKLQkJCQkJCQkgc3RhcnQsIGVuZCkpCi0JCQkJ YW1kZ3B1X2FtZGtmZF9ldmljdF91c2VycHRyKG1lbSwgYW1uLT5tbSk7Ci0JCX0KLQl9Ci0KLQlh bWRncHVfbW5fcmVhZF91bmxvY2soYW1uKTsKKwlpZiAoIW1tdV9ub3RpZmllcl9yYW5nZV9ibG9j a2FibGUodXBkYXRlKSkKKwkJcmV0dXJuIGZhbHNlOwogCisJZG93bl9yZWFkKCZhbW4tPmxvY2sp OworCXVwX3JlYWQoJmFtbi0+bG9jayk7CiAJcmV0dXJuIDA7CiB9CiAKQEAgLTI5NSwxMiArMTY0 LDEwIEBAIGFtZGdwdV9tbl9zeW5jX3BhZ2V0YWJsZXNfaHNhKHN0cnVjdCBobW1fbWlycm9yICpt aXJyb3IsCiAKIHN0YXRpYyBzdHJ1Y3QgaG1tX21pcnJvcl9vcHMgYW1kZ3B1X2htbV9taXJyb3Jf b3BzW10gPSB7CiAJW0FNREdQVV9NTl9UWVBFX0dGWF0gPSB7Ci0JCS5zeW5jX2NwdV9kZXZpY2Vf cGFnZXRhYmxlcyA9IGFtZGdwdV9tbl9zeW5jX3BhZ2V0YWJsZXNfZ2Z4LAotCQkucmVsZWFzZSA9 IGFtZGdwdV9obW1fbWlycm9yX3JlbGVhc2UKKwkJLnN5bmNfY3B1X2RldmljZV9wYWdldGFibGVz ID0gYW1kZ3B1X21uX3N5bmNfcGFnZXRhYmxlcywKIAl9LAogCVtBTURHUFVfTU5fVFlQRV9IU0Fd ID0gewotCQkuc3luY19jcHVfZGV2aWNlX3BhZ2V0YWJsZXMgPSBhbWRncHVfbW5fc3luY19wYWdl dGFibGVzX2hzYSwKLQkJLnJlbGVhc2UgPSBhbWRncHVfaG1tX21pcnJvcl9yZWxlYXNlCisJCS5z eW5jX2NwdV9kZXZpY2VfcGFnZXRhYmxlcyA9IGFtZGdwdV9tbl9zeW5jX3BhZ2V0YWJsZXMsCiAJ fSwKIH07CiAKQEAgLTMyNyw3ICsxOTQsOCBAQCBzdHJ1Y3QgYW1kZ3B1X21uICphbWRncHVfbW5f Z2V0KHN0cnVjdCBhbWRncHVfZGV2aWNlICphZGV2LAogCX0KIAogCWhhc2hfZm9yX2VhY2hfcG9z c2libGUoYWRldi0+bW5faGFzaCwgYW1uLCBub2RlLCBrZXkpCi0JCWlmIChBTURHUFVfTU5fS0VZ KGFtbi0+bW0sIGFtbi0+dHlwZSkgPT0ga2V5KQorCQlpZiAoQU1ER1BVX01OX0tFWShhbW4tPm1p cnJvci5obW0tPm1tdV9ub3RpZmllci5tbSwKKwkJCQkgIGFtbi0+dHlwZSkgPT0ga2V5KQogCQkJ Z290byByZWxlYXNlX2xvY2tzOwogCiAJYW1uID0ga3phbGxvYyhzaXplb2YoKmFtbiksIEdGUF9L RVJORUwpOwpAQCAtMzM3LDEwICsyMDUsOCBAQCBzdHJ1Y3QgYW1kZ3B1X21uICphbWRncHVfbW5f Z2V0KHN0cnVjdCBhbWRncHVfZGV2aWNlICphZGV2LAogCX0KIAogCWFtbi0+YWRldiA9IGFkZXY7 Ci0JYW1uLT5tbSA9IG1tOwogCWluaXRfcndzZW0oJmFtbi0+bG9jayk7CiAJYW1uLT50eXBlID0g dHlwZTsKLQlhbW4tPm9iamVjdHMgPSBSQl9ST09UX0NBQ0hFRDsKIAogCWFtbi0+bWlycm9yLm9w cyA9ICZhbWRncHVfaG1tX21pcnJvcl9vcHNbdHlwZV07CiAJciA9IGhtbV9taXJyb3JfcmVnaXN0 ZXIoJmFtbi0+bWlycm9yLCBtbSk7CkBAIC0zNjksMTAwICsyMzUsMzMgQEAgc3RydWN0IGFtZGdw dV9tbiAqYW1kZ3B1X21uX2dldChzdHJ1Y3QgYW1kZ3B1X2RldmljZSAqYWRldiwKICAqIEBibzog YW1kZ3B1IGJ1ZmZlciBvYmplY3QKICAqIEBhZGRyOiB1c2VycHRyIGFkZHIgd2Ugc2hvdWxkIG1v bml0b3IKICAqCi0gKiBSZWdpc3RlcnMgYW4gSE1NIG1pcnJvciBmb3IgdGhlIGdpdmVuIEJPIGF0 IHRoZSBzcGVjaWZpZWQgYWRkcmVzcy4KKyAqIFJlZ2lzdGVycyBhIG1tdV9ub3RpZmllciBmb3Ig dGhlIGdpdmVuIEJPIGF0IHRoZSBzcGVjaWZpZWQgYWRkcmVzcy4KICAqIFJldHVybnMgMCBvbiBz dWNjZXNzLCAtRVJSTk8gaWYgYW55dGhpbmcgZ29lcyB3cm9uZy4KICAqLwogaW50IGFtZGdwdV9t bl9yZWdpc3RlcihzdHJ1Y3QgYW1kZ3B1X2JvICpibywgdW5zaWduZWQgbG9uZyBhZGRyKQogewot CXVuc2lnbmVkIGxvbmcgZW5kID0gYWRkciArIGFtZGdwdV9ib19zaXplKGJvKSAtIDE7Ci0Jc3Ry dWN0IGFtZGdwdV9kZXZpY2UgKmFkZXYgPSBhbWRncHVfdHRtX2FkZXYoYm8tPnRiby5iZGV2KTsK LQllbnVtIGFtZGdwdV9tbl90eXBlIHR5cGUgPQotCQliby0+a2ZkX2JvID8gQU1ER1BVX01OX1RZ UEVfSFNBIDogQU1ER1BVX01OX1RZUEVfR0ZYOwotCXN0cnVjdCBhbWRncHVfbW4gKmFtbjsKLQlz dHJ1Y3QgYW1kZ3B1X21uX25vZGUgKm5vZGUgPSBOVUxMLCAqbmV3X25vZGU7Ci0Jc3RydWN0IGxp c3RfaGVhZCBib3M7Ci0Jc3RydWN0IGludGVydmFsX3RyZWVfbm9kZSAqaXQ7Ci0KLQlhbW4gPSBh bWRncHVfbW5fZ2V0KGFkZXYsIHR5cGUpOwotCWlmIChJU19FUlIoYW1uKSkKLQkJcmV0dXJuIFBU Ul9FUlIoYW1uKTsKLQotCW5ld19ub2RlID0ga21hbGxvYyhzaXplb2YoKm5ld19ub2RlKSwgR0ZQ X0tFUk5FTCk7Ci0JaWYgKCFuZXdfbm9kZSkKLQkJcmV0dXJuIC1FTk9NRU07Ci0KLQlJTklUX0xJ U1RfSEVBRCgmYm9zKTsKLQotCWRvd25fd3JpdGUoJmFtbi0+bG9jayk7Ci0KLQl3aGlsZSAoKGl0 ID0gaW50ZXJ2YWxfdHJlZV9pdGVyX2ZpcnN0KCZhbW4tPm9iamVjdHMsIGFkZHIsIGVuZCkpKSB7 Ci0JCWtmcmVlKG5vZGUpOwotCQlub2RlID0gY29udGFpbmVyX29mKGl0LCBzdHJ1Y3QgYW1kZ3B1 X21uX25vZGUsIGl0KTsKLQkJaW50ZXJ2YWxfdHJlZV9yZW1vdmUoJm5vZGUtPml0LCAmYW1uLT5v YmplY3RzKTsKLQkJYWRkciA9IG1pbihpdC0+c3RhcnQsIGFkZHIpOwotCQllbmQgPSBtYXgoaXQt Pmxhc3QsIGVuZCk7Ci0JCWxpc3Rfc3BsaWNlKCZub2RlLT5ib3MsICZib3MpOwotCX0KLQotCWlm ICghbm9kZSkKLQkJbm9kZSA9IG5ld19ub2RlOworCWlmIChiby0+a2ZkX2JvKQorCQliby0+bm90 aWZpZXIub3BzID0gJmFtZGdwdV9tbl9oc2Ffb3BzOwogCWVsc2UKLQkJa2ZyZWUobmV3X25vZGUp OwotCi0JYm8tPm1uID0gYW1uOwotCi0Jbm9kZS0+aXQuc3RhcnQgPSBhZGRyOwotCW5vZGUtPml0 Lmxhc3QgPSBlbmQ7Ci0JSU5JVF9MSVNUX0hFQUQoJm5vZGUtPmJvcyk7Ci0JbGlzdF9zcGxpY2Uo JmJvcywgJm5vZGUtPmJvcyk7Ci0JbGlzdF9hZGQoJmJvLT5tbl9saXN0LCAmbm9kZS0+Ym9zKTsK KwkJYm8tPm5vdGlmaWVyLm9wcyA9ICZhbWRncHVfbW5fZ2Z4X29wczsKIAotCWludGVydmFsX3Ry ZWVfaW5zZXJ0KCZub2RlLT5pdCwgJmFtbi0+b2JqZWN0cyk7Ci0KLQl1cF93cml0ZSgmYW1uLT5s b2NrKTsKLQotCXJldHVybiAwOworCXJldHVybiBtbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0KCZi by0+bm90aWZpZXIsIGFkZHIsCisJCQkJCSBhbWRncHVfYm9fc2l6ZShibyksIGN1cnJlbnQtPm1t KTsKIH0KIAogLyoqCi0gKiBhbWRncHVfbW5fdW5yZWdpc3RlciAtIHVucmVnaXN0ZXIgYSBCTyBm b3IgSE1NIG1pcnJvciB1cGRhdGVzCisgKiBhbWRncHVfbW5fdW5yZWdpc3RlciAtIHVucmVnaXN0 ZXIgYSBCTyBmb3Igbm90aWZpZXIgdXBkYXRlcwogICoKICAqIEBibzogYW1kZ3B1IGJ1ZmZlciBv YmplY3QKICAqCi0gKiBSZW1vdmUgYW55IHJlZ2lzdHJhdGlvbiBvZiBITU0gbWlycm9yIHVwZGF0 ZXMgZnJvbSB0aGUgYnVmZmVyIG9iamVjdC4KKyAqIFJlbW92ZSBhbnkgcmVnaXN0cmF0aW9uIG9m IG1tdSBub3RpZmllciB1cGRhdGVzIGZyb20gdGhlIGJ1ZmZlciBvYmplY3QuCiAgKi8KIHZvaWQg YW1kZ3B1X21uX3VucmVnaXN0ZXIoc3RydWN0IGFtZGdwdV9ibyAqYm8pCiB7Ci0Jc3RydWN0IGFt ZGdwdV9kZXZpY2UgKmFkZXYgPSBhbWRncHVfdHRtX2FkZXYoYm8tPnRiby5iZGV2KTsKLQlzdHJ1 Y3QgYW1kZ3B1X21uICphbW47Ci0Jc3RydWN0IGxpc3RfaGVhZCAqaGVhZDsKLQotCW11dGV4X2xv Y2soJmFkZXYtPm1uX2xvY2spOwotCi0JYW1uID0gYm8tPm1uOwotCWlmIChhbW4gPT0gTlVMTCkg ewotCQltdXRleF91bmxvY2soJmFkZXYtPm1uX2xvY2spOworCWlmICghYm8tPm5vdGlmaWVyLm1t KQogCQlyZXR1cm47Ci0JfQotCi0JZG93bl93cml0ZSgmYW1uLT5sb2NrKTsKLQotCS8qIHNhdmUg dGhlIG5leHQgbGlzdCBlbnRyeSBmb3IgbGF0ZXIgKi8KLQloZWFkID0gYm8tPm1uX2xpc3QubmV4 dDsKLQotCWJvLT5tbiA9IE5VTEw7Ci0JbGlzdF9kZWxfaW5pdCgmYm8tPm1uX2xpc3QpOwotCi0J aWYgKGxpc3RfZW1wdHkoaGVhZCkpIHsKLQkJc3RydWN0IGFtZGdwdV9tbl9ub2RlICpub2RlOwot Ci0JCW5vZGUgPSBjb250YWluZXJfb2YoaGVhZCwgc3RydWN0IGFtZGdwdV9tbl9ub2RlLCBib3Mp OwotCQlpbnRlcnZhbF90cmVlX3JlbW92ZSgmbm9kZS0+aXQsICZhbW4tPm9iamVjdHMpOwotCQlr ZnJlZShub2RlKTsKLQl9Ci0KLQl1cF93cml0ZSgmYW1uLT5sb2NrKTsKLQltdXRleF91bmxvY2so JmFkZXYtPm1uX2xvY2spOworCW1tdV9yYW5nZV9ub3RpZmllcl9yZW1vdmUoJmJvLT5ub3RpZmll cik7CisJYm8tPm5vdGlmaWVyLm1tID0gTlVMTDsKIH0KIAogLyogZmxhZ3MgdXNlZCBieSBITU0g aW50ZXJuYWwsIG5vdCByZWxhdGVkIHRvIENQVS9HUFUgUFRFIGZsYWdzICovCmRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uaCBiL2RyaXZlcnMvZ3B1L2Ry bS9hbWQvYW1kZ3B1L2FtZGdwdV9tbi5oCmluZGV4IGI4ZWQ2ODk0MzYyNWMyLi5kNzNhYjI5NDdi MjJiMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmgK KysrIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmgKQEAgLTM5LDEyICsz OSwxMCBAQCBlbnVtIGFtZGdwdV9tbl90eXBlIHsKICAqIHN0cnVjdCBhbWRncHVfbW4KICAqCiAg KiBAYWRldjogYW1kZ3B1IGRldmljZSBwb2ludGVyCi0gKiBAbW06IHByb2Nlc3MgYWRkcmVzcyBz cGFjZQogICogQHR5cGU6IHR5cGUgb2YgTU1VIG5vdGlmaWVyCiAgKiBAd29yazogZGVzdHJ1Y3Rp b24gd29yayBpdGVtCiAgKiBAbm9kZTogaGFzaCB0YWJsZSBub2RlIHRvIGZpbmQgc3RydWN0dXJl IGJ5IGFkZXYgYW5kIG1uCiAgKiBAbG9jazogcncgc2VtYXBob3JlIHByb3RlY3RpbmcgdGhlIG5v dGlmaWVyIG5vZGVzCi0gKiBAb2JqZWN0czogaW50ZXJ2YWwgdHJlZSBjb250YWluaW5nIGFtZGdw dV9tbl9ub2RlcwogICogQG1pcnJvcjogSE1NIG1pcnJvciBmdW5jdGlvbiBzdXBwb3J0CiAgKgog ICogRGF0YSBmb3IgZWFjaCBhbWRncHUgZGV2aWNlIGFuZCBwcm9jZXNzIGFkZHJlc3Mgc3BhY2Uu CkBAIC01Miw3ICs1MCw2IEBAIGVudW0gYW1kZ3B1X21uX3R5cGUgewogc3RydWN0IGFtZGdwdV9t biB7CiAJLyogY29uc3RhbnQgYWZ0ZXIgaW5pdGlhbGlzYXRpb24gKi8KIAlzdHJ1Y3QgYW1kZ3B1 X2RldmljZQkqYWRldjsKLQlzdHJ1Y3QgbW1fc3RydWN0CSptbTsKIAllbnVtIGFtZGdwdV9tbl90 eXBlCXR5cGU7CiAKIAkvKiBvbmx5IHVzZWQgb24gZGVzdHJ1Y3Rpb24gKi8KQEAgLTYzLDcgKzYw LDYgQEAgc3RydWN0IGFtZGdwdV9tbiB7CiAKIAkvKiBvYmplY3RzIHByb3RlY3RlZCBieSBsb2Nr ICovCiAJc3RydWN0IHJ3X3NlbWFwaG9yZQlsb2NrOwotCXN0cnVjdCByYl9yb290X2NhY2hlZAlv YmplY3RzOwogCiAjaWZkZWYgQ09ORklHX0hNTV9NSVJST1IKIAkvKiBITU0gbWlycm9yICovCmRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfb2JqZWN0LmggYi9k cml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfb2JqZWN0LmgKaW5kZXggNjU4ZjRjOTc3 OWI3MDQuLjRiNDRhYjg1MGY5NGMyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2Ft ZGdwdS9hbWRncHVfb2JqZWN0LmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1k Z3B1X29iamVjdC5oCkBAIC0zMCw2ICszMCw5IEBACiAKICNpbmNsdWRlIDxkcm0vYW1kZ3B1X2Ry bS5oPgogI2luY2x1ZGUgImFtZGdwdS5oIgorI2lmZGVmIENPTkZJR19NTVVfTk9USUZJRVIKKyNp bmNsdWRlIDxsaW51eC9tbXVfbm90aWZpZXIuaD4KKyNlbmRpZgogCiAjZGVmaW5lIEFNREdQVV9C T19JTlZBTElEX09GRlNFVAlMT05HX01BWAogI2RlZmluZSBBTURHUFVfQk9fTUFYX1BMQUNFTUVO VFMJMwpAQCAtMTAwLDEwICsxMDMsMTIgQEAgc3RydWN0IGFtZGdwdV9ibyB7CiAJc3RydWN0IHR0 bV9ib19rbWFwX29iagkJZG1hX2J1Zl92bWFwOwogCXN0cnVjdCBhbWRncHVfbW4JCSptbjsKIAot CXVuaW9uIHsKLQkJc3RydWN0IGxpc3RfaGVhZAltbl9saXN0OwotCQlzdHJ1Y3QgbGlzdF9oZWFk CXNoYWRvd19saXN0OwotCX07CisKKyNpZmRlZiBDT05GSUdfTU1VX05PVElGSUVSCisJc3RydWN0 IG1tdV9yYW5nZV9ub3RpZmllcglub3RpZmllcjsKKyNlbmRpZgorCisJc3RydWN0IGxpc3RfaGVh ZAkJc2hhZG93X2xpc3Q7CiAKIAlzdHJ1Y3Qga2dkX21lbSAgICAgICAgICAgICAgICAgICprZmRf Ym87CiB9OwotLSAKMi4yMy4wCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVz a3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9k cmktZGV2ZWw= 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 4E6AECA9EC0 for ; Mon, 28 Oct 2019 20:21:36 +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 1587821721 for ; Mon, 28 Oct 2019 20:21:36 +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="l4b6BiRz" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 1587821721 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 1iPBVq-0003sK-5m; Mon, 28 Oct 2019 20:21:14 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1iPBVo-0003sF-GC for xen-devel@lists.xenproject.org; Mon, 28 Oct 2019 20:21:12 +0000 X-Inumbo-ID: 7b56c324-f9c0-11e9-beca-bc764e2007e4 Received: from mail-qt1-x843.google.com (unknown [2607:f8b0:4864:20::843]) by us1-rack-iad1.inumbo.com (Halon) with ESMTPS id 7b56c324-f9c0-11e9-beca-bc764e2007e4; Mon, 28 Oct 2019 20:21:11 +0000 (UTC) Received: by mail-qt1-x843.google.com with SMTP id o49so16561854qta.7 for ; Mon, 28 Oct 2019 13:21:11 -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=f54wq5BOB+L91cuUIb1GfXpGUvNo7lL3IgdsSk0oLWI=; b=l4b6BiRzQbpC7T2GUxlPwjsdxPoQOk1FEPvAXONkG/JTKYB9azNhf74H1C4wi7aQSp 8A9jFV987xM6BpaBeNouD/l/GAxvjknDJS/NO03bddceTqett3RlzyU2OehGxRCGAxRx VRLi47+XEZkpQBZ079F1MnS9P763EC47IrVHlcaPUxwm9kP9JrnJ3RFygb28rTnhXydF 5FzebAKk3jhDaSXSdwhUukrFq7F5R19QvmFj8uU5j3Di5Kj9qaNRbbV/6rmYeeL0Df9a HzbpJ23C0BmdJ2aw1hETLPxUaEfvdYquQMl+Ku4SHxEshKk7ymPS56K6cQKlUnwCjURY RJ4g== 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=f54wq5BOB+L91cuUIb1GfXpGUvNo7lL3IgdsSk0oLWI=; b=a8/kuL6VlmuT3myFx4zsY974fkADQBD6NzRH0oqgWQ8Ul2qKCe7wGulkykBkNJzZ0y IgRMlvlK8B0oeAxylkkhpNL8a/iZ4oEFTjAinif58MB1gSPFwf8R3o5LFhKXUk6URdB6 K0Yj2rUzj8juIS1EOMntyajtkmSCFRSB/wSTWUvLVQRIQijyLJ7FdCbIzmNUrCuaMMrM BwSWoBLrVmzrXYA5VC151dHYktJIAaH7rqmrjzOxC1cQzIXtUQ7Uo0DXyDUcCnSvEWYE nvYysFS1cr6G0Ep0pyqvqNF/1E9d3t337p0tcdwvtJqXdKNPxXGHxH8g+PASls89KFZL wkug== X-Gm-Message-State: APjAAAWatEbSlkyRflkf2vR50KsQa+EQE0J5ejomdfNz8m3fB+m0yGMo Z3FuWjiZd3llN7vVjigUgSHDtA== X-Google-Smtp-Source: APXvYqwq2Y0Q6HWDIbs7vkuLUQo9mosZUKJbVQ8JILYrIGj2H8AgBVH06Qhu2TcTbLBJgxthQ23WKA== X-Received: by 2002:a05:6214:14ac:: with SMTP id bo12mr17885970qvb.67.1572294070501; Mon, 28 Oct 2019 13:21:10 -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 w131sm6550657qka.85.2019.10.28.13.21.09 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Mon, 28 Oct 2019 13:21:09 -0700 (PDT) Received: from jgg by mlx.ziepe.ca with local (Exim 4.90_1) (envelope-from ) id 1iPBLf-0001hF-L8; 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:30 -0300 Message-Id: <20191028201032.6352-14-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 13/15] drm/amdgpu: Use mmu_range_insert 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" RnJvbTogSmFzb24gR3VudGhvcnBlIDxqZ2dAbWVsbGFub3guY29tPgoKUmVtb3ZlIHRoZSBpbnRl cnZhbCB0cmVlIGluIHRoZSBkcml2ZXIgYW5kIHJlbHkgb24gdGhlIHRyZWUgbWFpbnRhaW5lZCBi eQp0aGUgbW11X25vdGlmaWVyIGZvciBkZWxpdmVyaW5nIG1tdV9ub3RpZmllciBpbnZhbGlkYXRp b24gY2FsbGJhY2tzLgoKRm9yIHNvbWUgcmVhc29uIGFtZGdwdSBoYXMgYSB2ZXJ5IGNvbXBsaWNh dGVkIGFycmFuZ2VtZW50IHdoZXJlIGl0IHRyaWVzCnRvIHByZXZlbnQgZHVwbGljYXRlIGVudHJp ZXMgaW4gdGhlIGludGVydmFsX3RyZWUsIHRoaXMgaXMgbm90IG5lY2Vzc2FyeSwKZWFjaCBhbWRn cHVfYm8gY2FuIGJlIGl0cyBvd24gc3RhbmQgYWxvbmUgZW50cnkuIGludGVydmFsX3RyZWUgYWxy ZWFkeQphbGxvd3MgZHVwbGljYXRlcyBhbmQgb3ZlcmxhcHMgaW4gdGhlIHRyZWUuCgpBbHNvLCB0 aGVyZSBpcyBubyBuZWVkIHRvIHJlbW92ZSBlbnRyaWVzIHVwb24gYSByZWxlYXNlIGNhbGxiYWNr LCB0aGUKbW11X3JhbmdlIEFQSSBzYWZlbHkgYWxsb3dzIG9iamVjdHMgdG8gcmVtYWluIHJlZ2lz dGVyZWQgYmV5b25kIHRoZQpsaWZldGltZSBvZiB0aGUgbW0uIFRoZSBkcml2ZXIgb25seSBoYXMg dG8gc3RvcCB0b3VjaGluZyB0aGUgcGFnZXMgZHVyaW5nCnJlbGVhc2UuCgpDYzogQWxleCBEZXVj aGVyIDxhbGV4YW5kZXIuZGV1Y2hlckBhbWQuY29tPgpDYzogQ2hyaXN0aWFuIEvDtm5pZyA8Y2hy aXN0aWFuLmtvZW5pZ0BhbWQuY29tPgpDYzogRGF2aWQgKENodW5NaW5nKSBaaG91IDxEYXZpZDEu WmhvdUBhbWQuY29tPgpDYzogYW1kLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKU2lnbmVkLW9m Zi1ieTogSmFzb24gR3VudGhvcnBlIDxqZ2dAbWVsbGFub3guY29tPgotLS0KIGRyaXZlcnMvZ3B1 L2RybS9hbWQvYW1kZ3B1L2FtZGdwdS5oICAgICAgICAgICB8ICAgMiArCiAuLi4vZ3B1L2RybS9h bWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYyAgfCAgIDUgKy0KIGRyaXZlcnMvZ3B1L2Ry bS9hbWQvYW1kZ3B1L2FtZGdwdV9kZXZpY2UuYyAgICB8ICAgMSArCiBkcml2ZXJzL2dwdS9kcm0v YW1kL2FtZGdwdS9hbWRncHVfbW4uYyAgICAgICAgfCAzNDEgKysrKy0tLS0tLS0tLS0tLS0tCiBk cml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uaCAgICAgICAgfCAgIDQgLQogZHJp dmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X29iamVjdC5oICAgIHwgIDEzICstCiA2IGZp bGVzIGNoYW5nZWQsIDg0IGluc2VydGlvbnMoKyksIDI4MiBkZWxldGlvbnMoLSkKCmRpZmYgLS1n aXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHUuaCBiL2RyaXZlcnMvZ3B1L2Ry bS9hbWQvYW1kZ3B1L2FtZGdwdS5oCmluZGV4IGJkMzdkZjVkZDZkMDQ4Li42MDU5MWE1ZDQyMDAy MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1LmgKKysrIGIv ZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1LmgKQEAgLTEwMDYsNiArMTAwNiw4IEBA IHN0cnVjdCBhbWRncHVfZGV2aWNlIHsKIAlzdHJ1Y3QgbXV0ZXggIGxvY2tfcmVzZXQ7CiAJc3Ry dWN0IGFtZGdwdV9kb29yYmVsbF9pbmRleCBkb29yYmVsbF9pbmRleDsKIAorCXN0cnVjdCBtdXRl eAkJCW5vdGlmaWVyX2xvY2s7CisKIAlpbnQgYXNpY19yZXNldF9yZXM7CiAJc3RydWN0IHdvcmtf c3RydWN0CQl4Z21pX3Jlc2V0X3dvcms7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9h bWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1k Z3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYwppbmRleCA2ZDAyMWVjYzhkNTk4Zi4uNDc3MDAzMDJh MDhiN2YgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9hbWRr ZmRfZ3B1dm0uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfYW1ka2Zk X2dwdXZtLmMKQEAgLTQ4MSw4ICs0ODEsNyBAQCBzdGF0aWMgdm9pZCByZW1vdmVfa2dkX21lbV9m cm9tX2tmZF9ib19saXN0KHN0cnVjdCBrZ2RfbWVtICptZW0sCiAgKgogICogUmV0dXJucyAwIGZv ciBzdWNjZXNzLCBuZWdhdGl2ZSBlcnJubyBmb3IgZXJyb3JzLgogICovCi1zdGF0aWMgaW50IGlu aXRfdXNlcl9wYWdlcyhzdHJ1Y3Qga2dkX21lbSAqbWVtLCBzdHJ1Y3QgbW1fc3RydWN0ICptbSwK LQkJCSAgIHVpbnQ2NF90IHVzZXJfYWRkcikKK3N0YXRpYyBpbnQgaW5pdF91c2VyX3BhZ2VzKHN0 cnVjdCBrZ2RfbWVtICptZW0sIHVpbnQ2NF90IHVzZXJfYWRkcikKIHsKIAlzdHJ1Y3QgYW1ka2Zk X3Byb2Nlc3NfaW5mbyAqcHJvY2Vzc19pbmZvID0gbWVtLT5wcm9jZXNzX2luZm87CiAJc3RydWN0 IGFtZGdwdV9ibyAqYm8gPSBtZW0tPmJvOwpAQCAtMTE5NSw3ICsxMTk0LDcgQEAgaW50IGFtZGdw dV9hbWRrZmRfZ3B1dm1fYWxsb2NfbWVtb3J5X29mX2dwdSgKIAlhZGRfa2dkX21lbV90b19rZmRf Ym9fbGlzdCgqbWVtLCBhdm0tPnByb2Nlc3NfaW5mbywgdXNlcl9hZGRyKTsKIAogCWlmICh1c2Vy X2FkZHIpIHsKLQkJcmV0ID0gaW5pdF91c2VyX3BhZ2VzKCptZW0sIGN1cnJlbnQtPm1tLCB1c2Vy X2FkZHIpOworCQlyZXQgPSBpbml0X3VzZXJfcGFnZXMoKm1lbSwgdXNlcl9hZGRyKTsKIAkJaWYg KHJldCkKIAkJCWdvdG8gYWxsb2NhdGVfaW5pdF91c2VyX3BhZ2VzX2ZhaWxlZDsKIAl9CmRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfZGV2aWNlLmMgYi9kcml2 ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfZGV2aWNlLmMKaW5kZXggNWExOTM5ZGJkNGUz ZTYuLjM4Zjk3OTk4YWFkZGIyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdw dS9hbWRncHVfZGV2aWNlLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1 X2RldmljZS5jCkBAIC0yNjMzLDYgKzI2MzMsNyBAQCBpbnQgYW1kZ3B1X2RldmljZV9pbml0KHN0 cnVjdCBhbWRncHVfZGV2aWNlICphZGV2LAogCW11dGV4X2luaXQoJmFkZXYtPnZpcnQudmZfZXJy b3JzLmxvY2spOwogCWhhc2hfaW5pdChhZGV2LT5tbl9oYXNoKTsKIAltdXRleF9pbml0KCZhZGV2 LT5sb2NrX3Jlc2V0KTsKKwltdXRleF9pbml0KCZhZGV2LT5ub3RpZmllcl9sb2NrKTsKIAltdXRl eF9pbml0KCZhZGV2LT52aXJ0LmRwbV9tdXRleCk7CiAJbXV0ZXhfaW5pdCgmYWRldi0+cHNwLm11 dGV4KTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21u LmMgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uYwppbmRleCAzMWQ0ZGVi NWQyOTQ4NC4uNGZmZDdiOTBmNGQ5MDcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQv YW1kZ3B1L2FtZGdwdV9tbi5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdw dV9tbi5jCkBAIC01MCw2NiArNTAsNiBAQAogI2luY2x1ZGUgImFtZGdwdS5oIgogI2luY2x1ZGUg ImFtZGdwdV9hbWRrZmQuaCIKIAotLyoqCi0gKiBzdHJ1Y3QgYW1kZ3B1X21uX25vZGUKLSAqCi0g KiBAaXQ6IGludGVydmFsIG5vZGUgZGVmaW5pbmcgc3RhcnQtbGFzdCBvZiB0aGUgYWZmZWN0ZWQg YWRkcmVzcyByYW5nZQotICogQGJvczogbGlzdCBvZiBhbGwgQk9zIGluIHRoZSBhZmZlY3RlZCBh ZGRyZXNzIHJhbmdlCi0gKgotICogTWFuYWdlcyBhbGwgQk9zIHdoaWNoIGFyZSBhZmZlY3RlZCBv ZiBhIGNlcnRhaW4gcmFuZ2Ugb2YgYWRkcmVzcyBzcGFjZS4KLSAqLwotc3RydWN0IGFtZGdwdV9t bl9ub2RlIHsKLQlzdHJ1Y3QgaW50ZXJ2YWxfdHJlZV9ub2RlCWl0OwotCXN0cnVjdCBsaXN0X2hl YWQJCWJvczsKLX07Ci0KLS8qKgotICogYW1kZ3B1X21uX2Rlc3Ryb3kgLSBkZXN0cm95IHRoZSBI TU0gbWlycm9yCi0gKgotICogQHdvcms6IHByZXZpb3VzbHkgc2hlZHVsZWQgd29yayBpdGVtCi0g KgotICogTGF6eSBkZXN0cm95cyB0aGUgbm90aWZpZXIgZnJvbSBhIHdvcmsgaXRlbQotICovCi1z dGF0aWMgdm9pZCBhbWRncHVfbW5fZGVzdHJveShzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCi17 Ci0Jc3RydWN0IGFtZGdwdV9tbiAqYW1uID0gY29udGFpbmVyX29mKHdvcmssIHN0cnVjdCBhbWRn cHVfbW4sIHdvcmspOwotCXN0cnVjdCBhbWRncHVfZGV2aWNlICphZGV2ID0gYW1uLT5hZGV2Owot CXN0cnVjdCBhbWRncHVfbW5fbm9kZSAqbm9kZSwgKm5leHRfbm9kZTsKLQlzdHJ1Y3QgYW1kZ3B1 X2JvICpibywgKm5leHRfYm87Ci0KLQltdXRleF9sb2NrKCZhZGV2LT5tbl9sb2NrKTsKLQlkb3du X3dyaXRlKCZhbW4tPmxvY2spOwotCWhhc2hfZGVsKCZhbW4tPm5vZGUpOwotCXJidHJlZV9wb3N0 b3JkZXJfZm9yX2VhY2hfZW50cnlfc2FmZShub2RlLCBuZXh0X25vZGUsCi0JCQkJCSAgICAgJmFt bi0+b2JqZWN0cy5yYl9yb290LCBpdC5yYikgewotCQlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUo Ym8sIG5leHRfYm8sICZub2RlLT5ib3MsIG1uX2xpc3QpIHsKLQkJCWJvLT5tbiA9IE5VTEw7Ci0J CQlsaXN0X2RlbF9pbml0KCZiby0+bW5fbGlzdCk7Ci0JCX0KLQkJa2ZyZWUobm9kZSk7Ci0JfQot CXVwX3dyaXRlKCZhbW4tPmxvY2spOwotCW11dGV4X3VubG9jaygmYWRldi0+bW5fbG9jayk7Ci0K LQlobW1fbWlycm9yX3VucmVnaXN0ZXIoJmFtbi0+bWlycm9yKTsKLQlrZnJlZShhbW4pOwotfQot Ci0vKioKLSAqIGFtZGdwdV9obW1fbWlycm9yX3JlbGVhc2UgLSBjYWxsYmFjayB0byBub3RpZnkg YWJvdXQgbW0gZGVzdHJ1Y3Rpb24KLSAqCi0gKiBAbWlycm9yOiB0aGUgSE1NIG1pcnJvciAobW0p IHRoaXMgY2FsbGJhY2sgaXMgYWJvdXQKLSAqCi0gKiBTaGVkdWxlIGEgd29yayBpdGVtIHRvIGxh enkgZGVzdHJveSBITU0gbWlycm9yLgotICovCi1zdGF0aWMgdm9pZCBhbWRncHVfaG1tX21pcnJv cl9yZWxlYXNlKHN0cnVjdCBobW1fbWlycm9yICptaXJyb3IpCi17Ci0Jc3RydWN0IGFtZGdwdV9t biAqYW1uID0gY29udGFpbmVyX29mKG1pcnJvciwgc3RydWN0IGFtZGdwdV9tbiwgbWlycm9yKTsK LQotCUlOSVRfV09SSygmYW1uLT53b3JrLCBhbWRncHVfbW5fZGVzdHJveSk7Ci0Jc2NoZWR1bGVf d29yaygmYW1uLT53b3JrKTsKLX0KLQogLyoqCiAgKiBhbWRncHVfbW5fbG9jayAtIHRha2UgdGhl IHdyaXRlIHNpZGUgbG9jayBmb3IgdGhpcyBub3RpZmllcgogICoKQEAgLTEzMywxNTcgKzczLDg2 IEBAIHZvaWQgYW1kZ3B1X21uX3VubG9jayhzdHJ1Y3QgYW1kZ3B1X21uICptbikKIH0KIAogLyoq Ci0gKiBhbWRncHVfbW5fcmVhZF9sb2NrIC0gdGFrZSB0aGUgcmVhZCBzaWRlIGxvY2sgZm9yIHRo aXMgbm90aWZpZXIKLSAqCi0gKiBAYW1uOiBvdXIgbm90aWZpZXIKLSAqLwotc3RhdGljIGludCBh bWRncHVfbW5fcmVhZF9sb2NrKHN0cnVjdCBhbWRncHVfbW4gKmFtbiwgYm9vbCBibG9ja2FibGUp Ci17Ci0JaWYgKGJsb2NrYWJsZSkKLQkJZG93bl9yZWFkKCZhbW4tPmxvY2spOwotCWVsc2UgaWYg KCFkb3duX3JlYWRfdHJ5bG9jaygmYW1uLT5sb2NrKSkKLQkJcmV0dXJuIC1FQUdBSU47Ci0KLQly ZXR1cm4gMDsKLX0KLQotLyoqCi0gKiBhbWRncHVfbW5fcmVhZF91bmxvY2sgLSBkcm9wIHRoZSBy ZWFkIHNpZGUgbG9jayBmb3IgdGhpcyBub3RpZmllcgotICoKLSAqIEBhbW46IG91ciBub3RpZmll cgotICovCi1zdGF0aWMgdm9pZCBhbWRncHVfbW5fcmVhZF91bmxvY2soc3RydWN0IGFtZGdwdV9t biAqYW1uKQotewotCXVwX3JlYWQoJmFtbi0+bG9jayk7Ci19Ci0KLS8qKgotICogYW1kZ3B1X21u X2ludmFsaWRhdGVfbm9kZSAtIHVubWFwIGFsbCBCT3Mgb2YgYSBub2RlCisgKiBhbWRncHVfbW5f aW52YWxpZGF0ZV9nZnggLSBjYWxsYmFjayB0byBub3RpZnkgYWJvdXQgbW0gY2hhbmdlCiAgKgot ICogQG5vZGU6IHRoZSBub2RlIHdpdGggdGhlIEJPcyB0byB1bm1hcAotICogQHN0YXJ0OiBzdGFy dCBvZiBhZGRyZXNzIHJhbmdlIGFmZmVjdGVkCi0gKiBAZW5kOiBlbmQgb2YgYWRkcmVzcyByYW5n ZSBhZmZlY3RlZAorICogQG1ybjogdGhlIHJhbmdlIChtbSkgaXMgYWJvdXQgdG8gdXBkYXRlCisg KiBAcmFuZ2U6IGRldGFpbHMgb24gdGhlIGludmFsaWRhdGlvbgogICoKICAqIEJsb2NrIGZvciBv cGVyYXRpb25zIG9uIEJPcyB0byBmaW5pc2ggYW5kIG1hcmsgcGFnZXMgYXMgYWNjZXNzZWQgYW5k CiAgKiBwb3RlbnRpYWxseSBkaXJ0eS4KICAqLwotc3RhdGljIHZvaWQgYW1kZ3B1X21uX2ludmFs aWRhdGVfbm9kZShzdHJ1Y3QgYW1kZ3B1X21uX25vZGUgKm5vZGUsCi0JCQkJICAgICAgdW5zaWdu ZWQgbG9uZyBzdGFydCwKLQkJCQkgICAgICB1bnNpZ25lZCBsb25nIGVuZCkKK3N0YXRpYyBib29s IGFtZGdwdV9tbl9pbnZhbGlkYXRlX2dmeChzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyICptcm4s CisJCQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICpyYW5nZSkKIHsKLQlz dHJ1Y3QgYW1kZ3B1X2JvICpibzsKKwlzdHJ1Y3QgYW1kZ3B1X2JvICpibyA9IGNvbnRhaW5lcl9v Zihtcm4sIHN0cnVjdCBhbWRncHVfYm8sIG5vdGlmaWVyKTsKKwlzdHJ1Y3QgYW1kZ3B1X2Rldmlj ZSAqYWRldiA9IGFtZGdwdV90dG1fYWRldihiby0+dGJvLmJkZXYpOwogCWxvbmcgcjsKIAotCWxp c3RfZm9yX2VhY2hfZW50cnkoYm8sICZub2RlLT5ib3MsIG1uX2xpc3QpIHsKLQotCQlpZiAoIWFt ZGdwdV90dG1fdHRfYWZmZWN0X3VzZXJwdHIoYm8tPnRiby50dG0sIHN0YXJ0LCBlbmQpKQotCQkJ Y29udGludWU7Ci0KLQkJciA9IGRtYV9yZXN2X3dhaXRfdGltZW91dF9yY3UoYm8tPnRiby5iYXNl LnJlc3YsCi0JCQl0cnVlLCBmYWxzZSwgTUFYX1NDSEVEVUxFX1RJTUVPVVQpOwotCQlpZiAociA8 PSAwKQotCQkJRFJNX0VSUk9SKCIoJWxkKSBmYWlsZWQgdG8gd2FpdCBmb3IgdXNlciBib1xuIiwg cik7Ci0JfQorCS8qIEZJWE1FOiBJcyB0aGlzIG5lY2Vzc2FyeT8gKi8KKwlpZiAoIWFtZGdwdV90 dG1fdHRfYWZmZWN0X3VzZXJwdHIoYm8tPnRiby50dG0sIHJhbmdlLT5zdGFydCwKKwkJCQkJICBy YW5nZS0+ZW5kKSkKKwkJcmV0dXJuIHRydWU7CisKKwlpZiAoIW1tdV9ub3RpZmllcl9yYW5nZV9i bG9ja2FibGUocmFuZ2UpKQorCQlyZXR1cm4gZmFsc2U7CisKKwltdXRleF9sb2NrKCZhZGV2LT5u b3RpZmllcl9sb2NrKTsKKwlyID0gZG1hX3Jlc3Zfd2FpdF90aW1lb3V0X3JjdShiby0+dGJvLmJh c2UucmVzdiwgdHJ1ZSwgZmFsc2UsCisJCQkJICAgICAgTUFYX1NDSEVEVUxFX1RJTUVPVVQpOwor CW11dGV4X3VubG9jaygmYWRldi0+bm90aWZpZXJfbG9jayk7CisJaWYgKHIgPD0gMCkKKwkJRFJN X0VSUk9SKCIoJWxkKSBmYWlsZWQgdG8gd2FpdCBmb3IgdXNlciBib1xuIiwgcik7CisJcmV0dXJu IHRydWU7CiB9CiAKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyX29wcyBh bWRncHVfbW5fZ2Z4X29wcyA9IHsKKwkuaW52YWxpZGF0ZSA9IGFtZGdwdV9tbl9pbnZhbGlkYXRl X2dmeCwKK307CisKIC8qKgotICogYW1kZ3B1X21uX3N5bmNfcGFnZXRhYmxlc19nZnggLSBjYWxs YmFjayB0byBub3RpZnkgYWJvdXQgbW0gY2hhbmdlCisgKiBhbWRncHVfbW5faW52YWxpZGF0ZV9o c2EgLSBjYWxsYmFjayB0byBub3RpZnkgYWJvdXQgbW0gY2hhbmdlCiAgKgotICogQG1pcnJvcjog dGhlIGhtbV9taXJyb3IgKG1tKSBpcyBhYm91dCB0byB1cGRhdGUKLSAqIEB1cGRhdGU6IHRoZSB1 cGRhdGUgc3RhcnQsIGVuZCBhZGRyZXNzCisgKiBAbXJuOiB0aGUgcmFuZ2UgKG1tKSBpcyBhYm91 dCB0byB1cGRhdGUKKyAqIEByYW5nZTogZGV0YWlscyBvbiB0aGUgaW52YWxpZGF0aW9uCiAgKgot ICogQmxvY2sgZm9yIG9wZXJhdGlvbnMgb24gQk9zIHRvIGZpbmlzaCBhbmQgbWFyayBwYWdlcyBh cyBhY2Nlc3NlZCBhbmQKLSAqIHBvdGVudGlhbGx5IGRpcnR5LgorICogV2UgdGVtcG9yYXJpbHkg ZXZpY3QgdGhlIEJPIGF0dGFjaGVkIHRvIHRoaXMgcmFuZ2UuIFRoaXMgbmVjZXNzaXRhdGVzCisg KiBldmljdGluZyBhbGwgdXNlci1tb2RlIHF1ZXVlcyBvZiB0aGUgcHJvY2Vzcy4KICAqLwotc3Rh dGljIGludAotYW1kZ3B1X21uX3N5bmNfcGFnZXRhYmxlc19nZngoc3RydWN0IGhtbV9taXJyb3Ig Km1pcnJvciwKLQkJCSAgICAgIGNvbnN0IHN0cnVjdCBtbXVfbm90aWZpZXJfcmFuZ2UgKnVwZGF0 ZSkKK3N0YXRpYyBib29sIGFtZGdwdV9tbl9pbnZhbGlkYXRlX2hzYShzdHJ1Y3QgbW11X3Jhbmdl X25vdGlmaWVyICptcm4sCisJCQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3Jhbmdl ICpyYW5nZSkKIHsKLQlzdHJ1Y3QgYW1kZ3B1X21uICphbW4gPSBjb250YWluZXJfb2YobWlycm9y LCBzdHJ1Y3QgYW1kZ3B1X21uLCBtaXJyb3IpOwotCXVuc2lnbmVkIGxvbmcgc3RhcnQgPSB1cGRh dGUtPnN0YXJ0OwotCXVuc2lnbmVkIGxvbmcgZW5kID0gdXBkYXRlLT5lbmQ7Ci0JYm9vbCBibG9j a2FibGUgPSBtbXVfbm90aWZpZXJfcmFuZ2VfYmxvY2thYmxlKHVwZGF0ZSk7Ci0Jc3RydWN0IGlu dGVydmFsX3RyZWVfbm9kZSAqaXQ7Ci0KLQkvKiBub3RpZmljYXRpb24gaXMgZXhjbHVzaXZlLCBi dXQgaW50ZXJ2YWwgaXMgaW5jbHVzaXZlICovCi0JZW5kIC09IDE7Ci0KLQkvKiBUT0RPIHdlIHNo b3VsZCBiZSBhYmxlIHRvIHNwbGl0IGxvY2tpbmcgZm9yIGludGVydmFsIHRyZWUgYW5kCi0JICog YW1kZ3B1X21uX2ludmFsaWRhdGVfbm9kZQotCSAqLwotCWlmIChhbWRncHVfbW5fcmVhZF9sb2Nr KGFtbiwgYmxvY2thYmxlKSkKLQkJcmV0dXJuIC1FQUdBSU47Ci0KLQlpdCA9IGludGVydmFsX3Ry ZWVfaXRlcl9maXJzdCgmYW1uLT5vYmplY3RzLCBzdGFydCwgZW5kKTsKLQl3aGlsZSAoaXQpIHsK LQkJc3RydWN0IGFtZGdwdV9tbl9ub2RlICpub2RlOwotCi0JCWlmICghYmxvY2thYmxlKSB7Ci0J CQlhbWRncHVfbW5fcmVhZF91bmxvY2soYW1uKTsKLQkJCXJldHVybiAtRUFHQUlOOwotCQl9CisJ c3RydWN0IGFtZGdwdV9ibyAqYm8gPSBjb250YWluZXJfb2YobXJuLCBzdHJ1Y3QgYW1kZ3B1X2Jv LCBub3RpZmllcik7CisJc3RydWN0IGFtZGdwdV9kZXZpY2UgKmFkZXYgPSBhbWRncHVfdHRtX2Fk ZXYoYm8tPnRiby5iZGV2KTsKIAotCQlub2RlID0gY29udGFpbmVyX29mKGl0LCBzdHJ1Y3QgYW1k Z3B1X21uX25vZGUsIGl0KTsKLQkJaXQgPSBpbnRlcnZhbF90cmVlX2l0ZXJfbmV4dChpdCwgc3Rh cnQsIGVuZCk7CisJLyogRklYTUU6IElzIHRoaXMgbmVjZXNzYXJ5PyAqLworCWlmICghYW1kZ3B1 X3R0bV90dF9hZmZlY3RfdXNlcnB0cihiby0+dGJvLnR0bSwgcmFuZ2UtPnN0YXJ0LAorCQkJCQkg IHJhbmdlLT5lbmQpKQorCQlyZXR1cm4gdHJ1ZTsKIAotCQlhbWRncHVfbW5faW52YWxpZGF0ZV9u b2RlKG5vZGUsIHN0YXJ0LCBlbmQpOwotCX0KKwlpZiAoIW1tdV9ub3RpZmllcl9yYW5nZV9ibG9j a2FibGUocmFuZ2UpKQorCQlyZXR1cm4gZmFsc2U7CiAKLQlhbWRncHVfbW5fcmVhZF91bmxvY2so YW1uKTsKKwltdXRleF9sb2NrKCZhZGV2LT5ub3RpZmllcl9sb2NrKTsKKwlhbWRncHVfYW1ka2Zk X2V2aWN0X3VzZXJwdHIoYm8tPmtmZF9ibywgYm8tPm5vdGlmaWVyLm1tKTsKKwltdXRleF91bmxv Y2soJmFkZXYtPm5vdGlmaWVyX2xvY2spOwogCi0JcmV0dXJuIDA7CisJcmV0dXJuIHRydWU7CiB9 CiAKLS8qKgotICogYW1kZ3B1X21uX3N5bmNfcGFnZXRhYmxlc19oc2EgLSBjYWxsYmFjayB0byBu b3RpZnkgYWJvdXQgbW0gY2hhbmdlCi0gKgotICogQG1pcnJvcjogdGhlIGhtbV9taXJyb3IgKG1t KSBpcyBhYm91dCB0byB1cGRhdGUKLSAqIEB1cGRhdGU6IHRoZSB1cGRhdGUgc3RhcnQsIGVuZCBh ZGRyZXNzCi0gKgotICogV2UgdGVtcG9yYXJpbHkgZXZpY3QgYWxsIEJPcyBiZXR3ZWVuIHN0YXJ0 IGFuZCBlbmQuIFRoaXMKLSAqIG5lY2Vzc2l0YXRlcyBldmljdGluZyBhbGwgdXNlci1tb2RlIHF1 ZXVlcyBvZiB0aGUgcHJvY2Vzcy4gVGhlIEJPcwotICogYXJlIHJlc3RvcnRlZCBpbiBhbWRncHVf bW5faW52YWxpZGF0ZV9yYW5nZV9lbmRfaHNhLgotICovCi1zdGF0aWMgaW50Ci1hbWRncHVfbW5f c3luY19wYWdldGFibGVzX2hzYShzdHJ1Y3QgaG1tX21pcnJvciAqbWlycm9yLAotCQkJICAgICAg Y29uc3Qgc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAqdXBkYXRlKQorc3RhdGljIGNvbnN0IHN0 cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXJfb3BzIGFtZGdwdV9tbl9oc2Ffb3BzID0geworCS5pbnZh bGlkYXRlID0gYW1kZ3B1X21uX2ludmFsaWRhdGVfaHNhLAorfTsKKworc3RhdGljIGludCBhbWRn cHVfbW5fc3luY19wYWdldGFibGVzKHN0cnVjdCBobW1fbWlycm9yICptaXJyb3IsCisJCQkJICAg ICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICp1cGRhdGUpCiB7CiAJc3RydWN0IGFt ZGdwdV9tbiAqYW1uID0gY29udGFpbmVyX29mKG1pcnJvciwgc3RydWN0IGFtZGdwdV9tbiwgbWly cm9yKTsKLQl1bnNpZ25lZCBsb25nIHN0YXJ0ID0gdXBkYXRlLT5zdGFydDsKLQl1bnNpZ25lZCBs b25nIGVuZCA9IHVwZGF0ZS0+ZW5kOwotCWJvb2wgYmxvY2thYmxlID0gbW11X25vdGlmaWVyX3Jh bmdlX2Jsb2NrYWJsZSh1cGRhdGUpOwotCXN0cnVjdCBpbnRlcnZhbF90cmVlX25vZGUgKml0Owog Ci0JLyogbm90aWZpY2F0aW9uIGlzIGV4Y2x1c2l2ZSwgYnV0IGludGVydmFsIGlzIGluY2x1c2l2 ZSAqLwotCWVuZCAtPSAxOwotCi0JaWYgKGFtZGdwdV9tbl9yZWFkX2xvY2soYW1uLCBibG9ja2Fi bGUpKQotCQlyZXR1cm4gLUVBR0FJTjsKLQotCWl0ID0gaW50ZXJ2YWxfdHJlZV9pdGVyX2ZpcnN0 KCZhbW4tPm9iamVjdHMsIHN0YXJ0LCBlbmQpOwotCXdoaWxlIChpdCkgewotCQlzdHJ1Y3QgYW1k Z3B1X21uX25vZGUgKm5vZGU7Ci0JCXN0cnVjdCBhbWRncHVfYm8gKmJvOwotCi0JCWlmICghYmxv Y2thYmxlKSB7Ci0JCQlhbWRncHVfbW5fcmVhZF91bmxvY2soYW1uKTsKLQkJCXJldHVybiAtRUFH QUlOOwotCQl9Ci0KLQkJbm9kZSA9IGNvbnRhaW5lcl9vZihpdCwgc3RydWN0IGFtZGdwdV9tbl9u b2RlLCBpdCk7Ci0JCWl0ID0gaW50ZXJ2YWxfdHJlZV9pdGVyX25leHQoaXQsIHN0YXJ0LCBlbmQp OwotCi0JCWxpc3RfZm9yX2VhY2hfZW50cnkoYm8sICZub2RlLT5ib3MsIG1uX2xpc3QpIHsKLQkJ CXN0cnVjdCBrZ2RfbWVtICptZW0gPSBiby0+a2ZkX2JvOwotCi0JCQlpZiAoYW1kZ3B1X3R0bV90 dF9hZmZlY3RfdXNlcnB0cihiby0+dGJvLnR0bSwKLQkJCQkJCQkgc3RhcnQsIGVuZCkpCi0JCQkJ YW1kZ3B1X2FtZGtmZF9ldmljdF91c2VycHRyKG1lbSwgYW1uLT5tbSk7Ci0JCX0KLQl9Ci0KLQlh bWRncHVfbW5fcmVhZF91bmxvY2soYW1uKTsKKwlpZiAoIW1tdV9ub3RpZmllcl9yYW5nZV9ibG9j a2FibGUodXBkYXRlKSkKKwkJcmV0dXJuIGZhbHNlOwogCisJZG93bl9yZWFkKCZhbW4tPmxvY2sp OworCXVwX3JlYWQoJmFtbi0+bG9jayk7CiAJcmV0dXJuIDA7CiB9CiAKQEAgLTI5NSwxMiArMTY0 LDEwIEBAIGFtZGdwdV9tbl9zeW5jX3BhZ2V0YWJsZXNfaHNhKHN0cnVjdCBobW1fbWlycm9yICpt aXJyb3IsCiAKIHN0YXRpYyBzdHJ1Y3QgaG1tX21pcnJvcl9vcHMgYW1kZ3B1X2htbV9taXJyb3Jf b3BzW10gPSB7CiAJW0FNREdQVV9NTl9UWVBFX0dGWF0gPSB7Ci0JCS5zeW5jX2NwdV9kZXZpY2Vf cGFnZXRhYmxlcyA9IGFtZGdwdV9tbl9zeW5jX3BhZ2V0YWJsZXNfZ2Z4LAotCQkucmVsZWFzZSA9 IGFtZGdwdV9obW1fbWlycm9yX3JlbGVhc2UKKwkJLnN5bmNfY3B1X2RldmljZV9wYWdldGFibGVz ID0gYW1kZ3B1X21uX3N5bmNfcGFnZXRhYmxlcywKIAl9LAogCVtBTURHUFVfTU5fVFlQRV9IU0Fd ID0gewotCQkuc3luY19jcHVfZGV2aWNlX3BhZ2V0YWJsZXMgPSBhbWRncHVfbW5fc3luY19wYWdl dGFibGVzX2hzYSwKLQkJLnJlbGVhc2UgPSBhbWRncHVfaG1tX21pcnJvcl9yZWxlYXNlCisJCS5z eW5jX2NwdV9kZXZpY2VfcGFnZXRhYmxlcyA9IGFtZGdwdV9tbl9zeW5jX3BhZ2V0YWJsZXMsCiAJ fSwKIH07CiAKQEAgLTMyNyw3ICsxOTQsOCBAQCBzdHJ1Y3QgYW1kZ3B1X21uICphbWRncHVfbW5f Z2V0KHN0cnVjdCBhbWRncHVfZGV2aWNlICphZGV2LAogCX0KIAogCWhhc2hfZm9yX2VhY2hfcG9z c2libGUoYWRldi0+bW5faGFzaCwgYW1uLCBub2RlLCBrZXkpCi0JCWlmIChBTURHUFVfTU5fS0VZ KGFtbi0+bW0sIGFtbi0+dHlwZSkgPT0ga2V5KQorCQlpZiAoQU1ER1BVX01OX0tFWShhbW4tPm1p cnJvci5obW0tPm1tdV9ub3RpZmllci5tbSwKKwkJCQkgIGFtbi0+dHlwZSkgPT0ga2V5KQogCQkJ Z290byByZWxlYXNlX2xvY2tzOwogCiAJYW1uID0ga3phbGxvYyhzaXplb2YoKmFtbiksIEdGUF9L RVJORUwpOwpAQCAtMzM3LDEwICsyMDUsOCBAQCBzdHJ1Y3QgYW1kZ3B1X21uICphbWRncHVfbW5f Z2V0KHN0cnVjdCBhbWRncHVfZGV2aWNlICphZGV2LAogCX0KIAogCWFtbi0+YWRldiA9IGFkZXY7 Ci0JYW1uLT5tbSA9IG1tOwogCWluaXRfcndzZW0oJmFtbi0+bG9jayk7CiAJYW1uLT50eXBlID0g dHlwZTsKLQlhbW4tPm9iamVjdHMgPSBSQl9ST09UX0NBQ0hFRDsKIAogCWFtbi0+bWlycm9yLm9w cyA9ICZhbWRncHVfaG1tX21pcnJvcl9vcHNbdHlwZV07CiAJciA9IGhtbV9taXJyb3JfcmVnaXN0 ZXIoJmFtbi0+bWlycm9yLCBtbSk7CkBAIC0zNjksMTAwICsyMzUsMzMgQEAgc3RydWN0IGFtZGdw dV9tbiAqYW1kZ3B1X21uX2dldChzdHJ1Y3QgYW1kZ3B1X2RldmljZSAqYWRldiwKICAqIEBibzog YW1kZ3B1IGJ1ZmZlciBvYmplY3QKICAqIEBhZGRyOiB1c2VycHRyIGFkZHIgd2Ugc2hvdWxkIG1v bml0b3IKICAqCi0gKiBSZWdpc3RlcnMgYW4gSE1NIG1pcnJvciBmb3IgdGhlIGdpdmVuIEJPIGF0 IHRoZSBzcGVjaWZpZWQgYWRkcmVzcy4KKyAqIFJlZ2lzdGVycyBhIG1tdV9ub3RpZmllciBmb3Ig dGhlIGdpdmVuIEJPIGF0IHRoZSBzcGVjaWZpZWQgYWRkcmVzcy4KICAqIFJldHVybnMgMCBvbiBz dWNjZXNzLCAtRVJSTk8gaWYgYW55dGhpbmcgZ29lcyB3cm9uZy4KICAqLwogaW50IGFtZGdwdV9t bl9yZWdpc3RlcihzdHJ1Y3QgYW1kZ3B1X2JvICpibywgdW5zaWduZWQgbG9uZyBhZGRyKQogewot CXVuc2lnbmVkIGxvbmcgZW5kID0gYWRkciArIGFtZGdwdV9ib19zaXplKGJvKSAtIDE7Ci0Jc3Ry dWN0IGFtZGdwdV9kZXZpY2UgKmFkZXYgPSBhbWRncHVfdHRtX2FkZXYoYm8tPnRiby5iZGV2KTsK LQllbnVtIGFtZGdwdV9tbl90eXBlIHR5cGUgPQotCQliby0+a2ZkX2JvID8gQU1ER1BVX01OX1RZ UEVfSFNBIDogQU1ER1BVX01OX1RZUEVfR0ZYOwotCXN0cnVjdCBhbWRncHVfbW4gKmFtbjsKLQlz dHJ1Y3QgYW1kZ3B1X21uX25vZGUgKm5vZGUgPSBOVUxMLCAqbmV3X25vZGU7Ci0Jc3RydWN0IGxp c3RfaGVhZCBib3M7Ci0Jc3RydWN0IGludGVydmFsX3RyZWVfbm9kZSAqaXQ7Ci0KLQlhbW4gPSBh bWRncHVfbW5fZ2V0KGFkZXYsIHR5cGUpOwotCWlmIChJU19FUlIoYW1uKSkKLQkJcmV0dXJuIFBU Ul9FUlIoYW1uKTsKLQotCW5ld19ub2RlID0ga21hbGxvYyhzaXplb2YoKm5ld19ub2RlKSwgR0ZQ X0tFUk5FTCk7Ci0JaWYgKCFuZXdfbm9kZSkKLQkJcmV0dXJuIC1FTk9NRU07Ci0KLQlJTklUX0xJ U1RfSEVBRCgmYm9zKTsKLQotCWRvd25fd3JpdGUoJmFtbi0+bG9jayk7Ci0KLQl3aGlsZSAoKGl0 ID0gaW50ZXJ2YWxfdHJlZV9pdGVyX2ZpcnN0KCZhbW4tPm9iamVjdHMsIGFkZHIsIGVuZCkpKSB7 Ci0JCWtmcmVlKG5vZGUpOwotCQlub2RlID0gY29udGFpbmVyX29mKGl0LCBzdHJ1Y3QgYW1kZ3B1 X21uX25vZGUsIGl0KTsKLQkJaW50ZXJ2YWxfdHJlZV9yZW1vdmUoJm5vZGUtPml0LCAmYW1uLT5v YmplY3RzKTsKLQkJYWRkciA9IG1pbihpdC0+c3RhcnQsIGFkZHIpOwotCQllbmQgPSBtYXgoaXQt Pmxhc3QsIGVuZCk7Ci0JCWxpc3Rfc3BsaWNlKCZub2RlLT5ib3MsICZib3MpOwotCX0KLQotCWlm ICghbm9kZSkKLQkJbm9kZSA9IG5ld19ub2RlOworCWlmIChiby0+a2ZkX2JvKQorCQliby0+bm90 aWZpZXIub3BzID0gJmFtZGdwdV9tbl9oc2Ffb3BzOwogCWVsc2UKLQkJa2ZyZWUobmV3X25vZGUp OwotCi0JYm8tPm1uID0gYW1uOwotCi0Jbm9kZS0+aXQuc3RhcnQgPSBhZGRyOwotCW5vZGUtPml0 Lmxhc3QgPSBlbmQ7Ci0JSU5JVF9MSVNUX0hFQUQoJm5vZGUtPmJvcyk7Ci0JbGlzdF9zcGxpY2Uo JmJvcywgJm5vZGUtPmJvcyk7Ci0JbGlzdF9hZGQoJmJvLT5tbl9saXN0LCAmbm9kZS0+Ym9zKTsK KwkJYm8tPm5vdGlmaWVyLm9wcyA9ICZhbWRncHVfbW5fZ2Z4X29wczsKIAotCWludGVydmFsX3Ry ZWVfaW5zZXJ0KCZub2RlLT5pdCwgJmFtbi0+b2JqZWN0cyk7Ci0KLQl1cF93cml0ZSgmYW1uLT5s b2NrKTsKLQotCXJldHVybiAwOworCXJldHVybiBtbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0KCZi by0+bm90aWZpZXIsIGFkZHIsCisJCQkJCSBhbWRncHVfYm9fc2l6ZShibyksIGN1cnJlbnQtPm1t KTsKIH0KIAogLyoqCi0gKiBhbWRncHVfbW5fdW5yZWdpc3RlciAtIHVucmVnaXN0ZXIgYSBCTyBm b3IgSE1NIG1pcnJvciB1cGRhdGVzCisgKiBhbWRncHVfbW5fdW5yZWdpc3RlciAtIHVucmVnaXN0 ZXIgYSBCTyBmb3Igbm90aWZpZXIgdXBkYXRlcwogICoKICAqIEBibzogYW1kZ3B1IGJ1ZmZlciBv YmplY3QKICAqCi0gKiBSZW1vdmUgYW55IHJlZ2lzdHJhdGlvbiBvZiBITU0gbWlycm9yIHVwZGF0 ZXMgZnJvbSB0aGUgYnVmZmVyIG9iamVjdC4KKyAqIFJlbW92ZSBhbnkgcmVnaXN0cmF0aW9uIG9m IG1tdSBub3RpZmllciB1cGRhdGVzIGZyb20gdGhlIGJ1ZmZlciBvYmplY3QuCiAgKi8KIHZvaWQg YW1kZ3B1X21uX3VucmVnaXN0ZXIoc3RydWN0IGFtZGdwdV9ibyAqYm8pCiB7Ci0Jc3RydWN0IGFt ZGdwdV9kZXZpY2UgKmFkZXYgPSBhbWRncHVfdHRtX2FkZXYoYm8tPnRiby5iZGV2KTsKLQlzdHJ1 Y3QgYW1kZ3B1X21uICphbW47Ci0Jc3RydWN0IGxpc3RfaGVhZCAqaGVhZDsKLQotCW11dGV4X2xv Y2soJmFkZXYtPm1uX2xvY2spOwotCi0JYW1uID0gYm8tPm1uOwotCWlmIChhbW4gPT0gTlVMTCkg ewotCQltdXRleF91bmxvY2soJmFkZXYtPm1uX2xvY2spOworCWlmICghYm8tPm5vdGlmaWVyLm1t KQogCQlyZXR1cm47Ci0JfQotCi0JZG93bl93cml0ZSgmYW1uLT5sb2NrKTsKLQotCS8qIHNhdmUg dGhlIG5leHQgbGlzdCBlbnRyeSBmb3IgbGF0ZXIgKi8KLQloZWFkID0gYm8tPm1uX2xpc3QubmV4 dDsKLQotCWJvLT5tbiA9IE5VTEw7Ci0JbGlzdF9kZWxfaW5pdCgmYm8tPm1uX2xpc3QpOwotCi0J aWYgKGxpc3RfZW1wdHkoaGVhZCkpIHsKLQkJc3RydWN0IGFtZGdwdV9tbl9ub2RlICpub2RlOwot Ci0JCW5vZGUgPSBjb250YWluZXJfb2YoaGVhZCwgc3RydWN0IGFtZGdwdV9tbl9ub2RlLCBib3Mp OwotCQlpbnRlcnZhbF90cmVlX3JlbW92ZSgmbm9kZS0+aXQsICZhbW4tPm9iamVjdHMpOwotCQlr ZnJlZShub2RlKTsKLQl9Ci0KLQl1cF93cml0ZSgmYW1uLT5sb2NrKTsKLQltdXRleF91bmxvY2so JmFkZXYtPm1uX2xvY2spOworCW1tdV9yYW5nZV9ub3RpZmllcl9yZW1vdmUoJmJvLT5ub3RpZmll cik7CisJYm8tPm5vdGlmaWVyLm1tID0gTlVMTDsKIH0KIAogLyogZmxhZ3MgdXNlZCBieSBITU0g aW50ZXJuYWwsIG5vdCByZWxhdGVkIHRvIENQVS9HUFUgUFRFIGZsYWdzICovCmRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uaCBiL2RyaXZlcnMvZ3B1L2Ry bS9hbWQvYW1kZ3B1L2FtZGdwdV9tbi5oCmluZGV4IGI4ZWQ2ODk0MzYyNWMyLi5kNzNhYjI5NDdi MjJiMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmgK KysrIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmgKQEAgLTM5LDEyICsz OSwxMCBAQCBlbnVtIGFtZGdwdV9tbl90eXBlIHsKICAqIHN0cnVjdCBhbWRncHVfbW4KICAqCiAg KiBAYWRldjogYW1kZ3B1IGRldmljZSBwb2ludGVyCi0gKiBAbW06IHByb2Nlc3MgYWRkcmVzcyBz cGFjZQogICogQHR5cGU6IHR5cGUgb2YgTU1VIG5vdGlmaWVyCiAgKiBAd29yazogZGVzdHJ1Y3Rp b24gd29yayBpdGVtCiAgKiBAbm9kZTogaGFzaCB0YWJsZSBub2RlIHRvIGZpbmQgc3RydWN0dXJl IGJ5IGFkZXYgYW5kIG1uCiAgKiBAbG9jazogcncgc2VtYXBob3JlIHByb3RlY3RpbmcgdGhlIG5v dGlmaWVyIG5vZGVzCi0gKiBAb2JqZWN0czogaW50ZXJ2YWwgdHJlZSBjb250YWluaW5nIGFtZGdw dV9tbl9ub2RlcwogICogQG1pcnJvcjogSE1NIG1pcnJvciBmdW5jdGlvbiBzdXBwb3J0CiAgKgog ICogRGF0YSBmb3IgZWFjaCBhbWRncHUgZGV2aWNlIGFuZCBwcm9jZXNzIGFkZHJlc3Mgc3BhY2Uu CkBAIC01Miw3ICs1MCw2IEBAIGVudW0gYW1kZ3B1X21uX3R5cGUgewogc3RydWN0IGFtZGdwdV9t biB7CiAJLyogY29uc3RhbnQgYWZ0ZXIgaW5pdGlhbGlzYXRpb24gKi8KIAlzdHJ1Y3QgYW1kZ3B1 X2RldmljZQkqYWRldjsKLQlzdHJ1Y3QgbW1fc3RydWN0CSptbTsKIAllbnVtIGFtZGdwdV9tbl90 eXBlCXR5cGU7CiAKIAkvKiBvbmx5IHVzZWQgb24gZGVzdHJ1Y3Rpb24gKi8KQEAgLTYzLDcgKzYw LDYgQEAgc3RydWN0IGFtZGdwdV9tbiB7CiAKIAkvKiBvYmplY3RzIHByb3RlY3RlZCBieSBsb2Nr ICovCiAJc3RydWN0IHJ3X3NlbWFwaG9yZQlsb2NrOwotCXN0cnVjdCByYl9yb290X2NhY2hlZAlv YmplY3RzOwogCiAjaWZkZWYgQ09ORklHX0hNTV9NSVJST1IKIAkvKiBITU0gbWlycm9yICovCmRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfb2JqZWN0LmggYi9k cml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfb2JqZWN0LmgKaW5kZXggNjU4ZjRjOTc3 OWI3MDQuLjRiNDRhYjg1MGY5NGMyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2Ft ZGdwdS9hbWRncHVfb2JqZWN0LmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1k Z3B1X29iamVjdC5oCkBAIC0zMCw2ICszMCw5IEBACiAKICNpbmNsdWRlIDxkcm0vYW1kZ3B1X2Ry bS5oPgogI2luY2x1ZGUgImFtZGdwdS5oIgorI2lmZGVmIENPTkZJR19NTVVfTk9USUZJRVIKKyNp bmNsdWRlIDxsaW51eC9tbXVfbm90aWZpZXIuaD4KKyNlbmRpZgogCiAjZGVmaW5lIEFNREdQVV9C T19JTlZBTElEX09GRlNFVAlMT05HX01BWAogI2RlZmluZSBBTURHUFVfQk9fTUFYX1BMQUNFTUVO VFMJMwpAQCAtMTAwLDEwICsxMDMsMTIgQEAgc3RydWN0IGFtZGdwdV9ibyB7CiAJc3RydWN0IHR0 bV9ib19rbWFwX29iagkJZG1hX2J1Zl92bWFwOwogCXN0cnVjdCBhbWRncHVfbW4JCSptbjsKIAot CXVuaW9uIHsKLQkJc3RydWN0IGxpc3RfaGVhZAltbl9saXN0OwotCQlzdHJ1Y3QgbGlzdF9oZWFk CXNoYWRvd19saXN0OwotCX07CisKKyNpZmRlZiBDT05GSUdfTU1VX05PVElGSUVSCisJc3RydWN0 IG1tdV9yYW5nZV9ub3RpZmllcglub3RpZmllcjsKKyNlbmRpZgorCisJc3RydWN0IGxpc3RfaGVh ZAkJc2hhZG93X2xpc3Q7CiAKIAlzdHJ1Y3Qga2dkX21lbSAgICAgICAgICAgICAgICAgICprZmRf Ym87CiB9OwotLSAKMi4yMy4wCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KWGVuLWRldmVsIG1haWxpbmcgbGlzdApYZW4tZGV2ZWxAbGlzdHMueGVucHJv amVjdC5vcmcKaHR0cHM6Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL3hl bi1kZXZlbA== 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 EB56DCA9EC0 for ; Mon, 28 Oct 2019 20:23:52 +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 CE4CF21721 for ; Mon, 28 Oct 2019 20:23:52 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org CE4CF21721 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 7E60F6EA01; Mon, 28 Oct 2019 20:23:52 +0000 (UTC) Received: from mail-qt1-x842.google.com (mail-qt1-x842.google.com [IPv6:2607:f8b0:4864:20::842]) by gabe.freedesktop.org (Postfix) with ESMTPS id 995B16EA05 for ; Mon, 28 Oct 2019 20:21:11 +0000 (UTC) Received: by mail-qt1-x842.google.com with SMTP id t26so6530997qtr.5 for ; Mon, 28 Oct 2019 13:21:11 -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=f54wq5BOB+L91cuUIb1GfXpGUvNo7lL3IgdsSk0oLWI=; b=YPueNTVUJdST8vhVBWCvul180XpOSiKAksD6VX2kQRbn3YU/Ul4o32GvmiHJHPaAYe Lxu7GIoWLIDcSIwYgHcilpbM1593tp8PPii6phiUT8+B+xv+/5+fcIoYADpOvxlkLTQZ xB84SpQ4k2VM1OvXG5HVKL05nRpyuG/wHQQcpZjNh3TWaenwiesmIWIQ6c0gTiM6OHPQ 3x9Gn60QGvC0Lb63RwFDzH/b0dcAyH/8EiiVUkauvkLBh4OsBcGMvWk1kNT2z+u75ZwW aIICKmp+af1vQmx4/mRVELGbpMBwg/OqbZrx2SEIWF8WZfCuGOj6Ypy2bXUBUegVG+Wh yhfQ== X-Gm-Message-State: APjAAAW4YsQ+VmxWfAYYM1Oy2lzBf3O+8E8XzKP6CTtPu2L9OKz9Zefg QmAWBYtFzT2VMX8FJ7fHBjwUyw== X-Google-Smtp-Source: APXvYqwq2Y0Q6HWDIbs7vkuLUQo9mosZUKJbVQ8JILYrIGj2H8AgBVH06Qhu2TcTbLBJgxthQ23WKA== X-Received: by 2002:a05:6214:14ac:: with SMTP id bo12mr17885970qvb.67.1572294070501; Mon, 28 Oct 2019 13:21:10 -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 w131sm6550657qka.85.2019.10.28.13.21.09 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Mon, 28 Oct 2019 13:21:09 -0700 (PDT) Received: from jgg by mlx.ziepe.ca with local (Exim 4.90_1) (envelope-from ) id 1iPBLf-0001hF-L8; 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 13/15] drm/amdgpu: Use mmu_range_insert instead of hmm_mirror Date: Mon, 28 Oct 2019 17:10:30 -0300 Message-Id: <20191028201032.6352-14-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:23:51 +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=f54wq5BOB+L91cuUIb1GfXpGUvNo7lL3IgdsSk0oLWI=; b=l4b6BiRzQbpC7T2GUxlPwjsdxPoQOk1FEPvAXONkG/JTKYB9azNhf74H1C4wi7aQSp 8A9jFV987xM6BpaBeNouD/l/GAxvjknDJS/NO03bddceTqett3RlzyU2OehGxRCGAxRx VRLi47+XEZkpQBZ079F1MnS9P763EC47IrVHlcaPUxwm9kP9JrnJ3RFygb28rTnhXydF 5FzebAKk3jhDaSXSdwhUukrFq7F5R19QvmFj8uU5j3Di5Kj9qaNRbbV/6rmYeeL0Df9a HzbpJ23C0BmdJ2aw1hETLPxUaEfvdYquQMl+Ku4SHxEshKk7ymPS56K6cQKlUnwCjURY RJ4g== 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: <20191028201030._1qbJ0ybf1zxf8QW8eiqOtYRQyKcMHdSO8HCxUr1tNw@z> RnJvbTogSmFzb24gR3VudGhvcnBlIDxqZ2dAbWVsbGFub3guY29tPgoKUmVtb3ZlIHRoZSBpbnRl cnZhbCB0cmVlIGluIHRoZSBkcml2ZXIgYW5kIHJlbHkgb24gdGhlIHRyZWUgbWFpbnRhaW5lZCBi eQp0aGUgbW11X25vdGlmaWVyIGZvciBkZWxpdmVyaW5nIG1tdV9ub3RpZmllciBpbnZhbGlkYXRp b24gY2FsbGJhY2tzLgoKRm9yIHNvbWUgcmVhc29uIGFtZGdwdSBoYXMgYSB2ZXJ5IGNvbXBsaWNh dGVkIGFycmFuZ2VtZW50IHdoZXJlIGl0IHRyaWVzCnRvIHByZXZlbnQgZHVwbGljYXRlIGVudHJp ZXMgaW4gdGhlIGludGVydmFsX3RyZWUsIHRoaXMgaXMgbm90IG5lY2Vzc2FyeSwKZWFjaCBhbWRn cHVfYm8gY2FuIGJlIGl0cyBvd24gc3RhbmQgYWxvbmUgZW50cnkuIGludGVydmFsX3RyZWUgYWxy ZWFkeQphbGxvd3MgZHVwbGljYXRlcyBhbmQgb3ZlcmxhcHMgaW4gdGhlIHRyZWUuCgpBbHNvLCB0 aGVyZSBpcyBubyBuZWVkIHRvIHJlbW92ZSBlbnRyaWVzIHVwb24gYSByZWxlYXNlIGNhbGxiYWNr LCB0aGUKbW11X3JhbmdlIEFQSSBzYWZlbHkgYWxsb3dzIG9iamVjdHMgdG8gcmVtYWluIHJlZ2lz dGVyZWQgYmV5b25kIHRoZQpsaWZldGltZSBvZiB0aGUgbW0uIFRoZSBkcml2ZXIgb25seSBoYXMg dG8gc3RvcCB0b3VjaGluZyB0aGUgcGFnZXMgZHVyaW5nCnJlbGVhc2UuCgpDYzogQWxleCBEZXVj aGVyIDxhbGV4YW5kZXIuZGV1Y2hlckBhbWQuY29tPgpDYzogQ2hyaXN0aWFuIEvDtm5pZyA8Y2hy aXN0aWFuLmtvZW5pZ0BhbWQuY29tPgpDYzogRGF2aWQgKENodW5NaW5nKSBaaG91IDxEYXZpZDEu WmhvdUBhbWQuY29tPgpDYzogYW1kLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKU2lnbmVkLW9m Zi1ieTogSmFzb24gR3VudGhvcnBlIDxqZ2dAbWVsbGFub3guY29tPgotLS0KIGRyaXZlcnMvZ3B1 L2RybS9hbWQvYW1kZ3B1L2FtZGdwdS5oICAgICAgICAgICB8ICAgMiArCiAuLi4vZ3B1L2RybS9h bWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYyAgfCAgIDUgKy0KIGRyaXZlcnMvZ3B1L2Ry bS9hbWQvYW1kZ3B1L2FtZGdwdV9kZXZpY2UuYyAgICB8ICAgMSArCiBkcml2ZXJzL2dwdS9kcm0v YW1kL2FtZGdwdS9hbWRncHVfbW4uYyAgICAgICAgfCAzNDEgKysrKy0tLS0tLS0tLS0tLS0tCiBk cml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uaCAgICAgICAgfCAgIDQgLQogZHJp dmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X29iamVjdC5oICAgIHwgIDEzICstCiA2IGZp bGVzIGNoYW5nZWQsIDg0IGluc2VydGlvbnMoKyksIDI4MiBkZWxldGlvbnMoLSkKCmRpZmYgLS1n aXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHUuaCBiL2RyaXZlcnMvZ3B1L2Ry bS9hbWQvYW1kZ3B1L2FtZGdwdS5oCmluZGV4IGJkMzdkZjVkZDZkMDQ4Li42MDU5MWE1ZDQyMDAy MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1LmgKKysrIGIv ZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1LmgKQEAgLTEwMDYsNiArMTAwNiw4IEBA IHN0cnVjdCBhbWRncHVfZGV2aWNlIHsKIAlzdHJ1Y3QgbXV0ZXggIGxvY2tfcmVzZXQ7CiAJc3Ry dWN0IGFtZGdwdV9kb29yYmVsbF9pbmRleCBkb29yYmVsbF9pbmRleDsKIAorCXN0cnVjdCBtdXRl eAkJCW5vdGlmaWVyX2xvY2s7CisKIAlpbnQgYXNpY19yZXNldF9yZXM7CiAJc3RydWN0IHdvcmtf c3RydWN0CQl4Z21pX3Jlc2V0X3dvcms7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9h bWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1k Z3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYwppbmRleCA2ZDAyMWVjYzhkNTk4Zi4uNDc3MDAzMDJh MDhiN2YgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9hbWRr ZmRfZ3B1dm0uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfYW1ka2Zk X2dwdXZtLmMKQEAgLTQ4MSw4ICs0ODEsNyBAQCBzdGF0aWMgdm9pZCByZW1vdmVfa2dkX21lbV9m cm9tX2tmZF9ib19saXN0KHN0cnVjdCBrZ2RfbWVtICptZW0sCiAgKgogICogUmV0dXJucyAwIGZv ciBzdWNjZXNzLCBuZWdhdGl2ZSBlcnJubyBmb3IgZXJyb3JzLgogICovCi1zdGF0aWMgaW50IGlu aXRfdXNlcl9wYWdlcyhzdHJ1Y3Qga2dkX21lbSAqbWVtLCBzdHJ1Y3QgbW1fc3RydWN0ICptbSwK LQkJCSAgIHVpbnQ2NF90IHVzZXJfYWRkcikKK3N0YXRpYyBpbnQgaW5pdF91c2VyX3BhZ2VzKHN0 cnVjdCBrZ2RfbWVtICptZW0sIHVpbnQ2NF90IHVzZXJfYWRkcikKIHsKIAlzdHJ1Y3QgYW1ka2Zk X3Byb2Nlc3NfaW5mbyAqcHJvY2Vzc19pbmZvID0gbWVtLT5wcm9jZXNzX2luZm87CiAJc3RydWN0 IGFtZGdwdV9ibyAqYm8gPSBtZW0tPmJvOwpAQCAtMTE5NSw3ICsxMTk0LDcgQEAgaW50IGFtZGdw dV9hbWRrZmRfZ3B1dm1fYWxsb2NfbWVtb3J5X29mX2dwdSgKIAlhZGRfa2dkX21lbV90b19rZmRf Ym9fbGlzdCgqbWVtLCBhdm0tPnByb2Nlc3NfaW5mbywgdXNlcl9hZGRyKTsKIAogCWlmICh1c2Vy X2FkZHIpIHsKLQkJcmV0ID0gaW5pdF91c2VyX3BhZ2VzKCptZW0sIGN1cnJlbnQtPm1tLCB1c2Vy X2FkZHIpOworCQlyZXQgPSBpbml0X3VzZXJfcGFnZXMoKm1lbSwgdXNlcl9hZGRyKTsKIAkJaWYg KHJldCkKIAkJCWdvdG8gYWxsb2NhdGVfaW5pdF91c2VyX3BhZ2VzX2ZhaWxlZDsKIAl9CmRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfZGV2aWNlLmMgYi9kcml2 ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfZGV2aWNlLmMKaW5kZXggNWExOTM5ZGJkNGUz ZTYuLjM4Zjk3OTk4YWFkZGIyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdw dS9hbWRncHVfZGV2aWNlLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1 X2RldmljZS5jCkBAIC0yNjMzLDYgKzI2MzMsNyBAQCBpbnQgYW1kZ3B1X2RldmljZV9pbml0KHN0 cnVjdCBhbWRncHVfZGV2aWNlICphZGV2LAogCW11dGV4X2luaXQoJmFkZXYtPnZpcnQudmZfZXJy b3JzLmxvY2spOwogCWhhc2hfaW5pdChhZGV2LT5tbl9oYXNoKTsKIAltdXRleF9pbml0KCZhZGV2 LT5sb2NrX3Jlc2V0KTsKKwltdXRleF9pbml0KCZhZGV2LT5ub3RpZmllcl9sb2NrKTsKIAltdXRl eF9pbml0KCZhZGV2LT52aXJ0LmRwbV9tdXRleCk7CiAJbXV0ZXhfaW5pdCgmYWRldi0+cHNwLm11 dGV4KTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21u LmMgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uYwppbmRleCAzMWQ0ZGVi NWQyOTQ4NC4uNGZmZDdiOTBmNGQ5MDcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQv YW1kZ3B1L2FtZGdwdV9tbi5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdw dV9tbi5jCkBAIC01MCw2NiArNTAsNiBAQAogI2luY2x1ZGUgImFtZGdwdS5oIgogI2luY2x1ZGUg ImFtZGdwdV9hbWRrZmQuaCIKIAotLyoqCi0gKiBzdHJ1Y3QgYW1kZ3B1X21uX25vZGUKLSAqCi0g KiBAaXQ6IGludGVydmFsIG5vZGUgZGVmaW5pbmcgc3RhcnQtbGFzdCBvZiB0aGUgYWZmZWN0ZWQg YWRkcmVzcyByYW5nZQotICogQGJvczogbGlzdCBvZiBhbGwgQk9zIGluIHRoZSBhZmZlY3RlZCBh ZGRyZXNzIHJhbmdlCi0gKgotICogTWFuYWdlcyBhbGwgQk9zIHdoaWNoIGFyZSBhZmZlY3RlZCBv ZiBhIGNlcnRhaW4gcmFuZ2Ugb2YgYWRkcmVzcyBzcGFjZS4KLSAqLwotc3RydWN0IGFtZGdwdV9t bl9ub2RlIHsKLQlzdHJ1Y3QgaW50ZXJ2YWxfdHJlZV9ub2RlCWl0OwotCXN0cnVjdCBsaXN0X2hl YWQJCWJvczsKLX07Ci0KLS8qKgotICogYW1kZ3B1X21uX2Rlc3Ryb3kgLSBkZXN0cm95IHRoZSBI TU0gbWlycm9yCi0gKgotICogQHdvcms6IHByZXZpb3VzbHkgc2hlZHVsZWQgd29yayBpdGVtCi0g KgotICogTGF6eSBkZXN0cm95cyB0aGUgbm90aWZpZXIgZnJvbSBhIHdvcmsgaXRlbQotICovCi1z dGF0aWMgdm9pZCBhbWRncHVfbW5fZGVzdHJveShzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCi17 Ci0Jc3RydWN0IGFtZGdwdV9tbiAqYW1uID0gY29udGFpbmVyX29mKHdvcmssIHN0cnVjdCBhbWRn cHVfbW4sIHdvcmspOwotCXN0cnVjdCBhbWRncHVfZGV2aWNlICphZGV2ID0gYW1uLT5hZGV2Owot CXN0cnVjdCBhbWRncHVfbW5fbm9kZSAqbm9kZSwgKm5leHRfbm9kZTsKLQlzdHJ1Y3QgYW1kZ3B1 X2JvICpibywgKm5leHRfYm87Ci0KLQltdXRleF9sb2NrKCZhZGV2LT5tbl9sb2NrKTsKLQlkb3du X3dyaXRlKCZhbW4tPmxvY2spOwotCWhhc2hfZGVsKCZhbW4tPm5vZGUpOwotCXJidHJlZV9wb3N0 b3JkZXJfZm9yX2VhY2hfZW50cnlfc2FmZShub2RlLCBuZXh0X25vZGUsCi0JCQkJCSAgICAgJmFt bi0+b2JqZWN0cy5yYl9yb290LCBpdC5yYikgewotCQlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUo Ym8sIG5leHRfYm8sICZub2RlLT5ib3MsIG1uX2xpc3QpIHsKLQkJCWJvLT5tbiA9IE5VTEw7Ci0J CQlsaXN0X2RlbF9pbml0KCZiby0+bW5fbGlzdCk7Ci0JCX0KLQkJa2ZyZWUobm9kZSk7Ci0JfQot CXVwX3dyaXRlKCZhbW4tPmxvY2spOwotCW11dGV4X3VubG9jaygmYWRldi0+bW5fbG9jayk7Ci0K LQlobW1fbWlycm9yX3VucmVnaXN0ZXIoJmFtbi0+bWlycm9yKTsKLQlrZnJlZShhbW4pOwotfQot Ci0vKioKLSAqIGFtZGdwdV9obW1fbWlycm9yX3JlbGVhc2UgLSBjYWxsYmFjayB0byBub3RpZnkg YWJvdXQgbW0gZGVzdHJ1Y3Rpb24KLSAqCi0gKiBAbWlycm9yOiB0aGUgSE1NIG1pcnJvciAobW0p IHRoaXMgY2FsbGJhY2sgaXMgYWJvdXQKLSAqCi0gKiBTaGVkdWxlIGEgd29yayBpdGVtIHRvIGxh enkgZGVzdHJveSBITU0gbWlycm9yLgotICovCi1zdGF0aWMgdm9pZCBhbWRncHVfaG1tX21pcnJv cl9yZWxlYXNlKHN0cnVjdCBobW1fbWlycm9yICptaXJyb3IpCi17Ci0Jc3RydWN0IGFtZGdwdV9t biAqYW1uID0gY29udGFpbmVyX29mKG1pcnJvciwgc3RydWN0IGFtZGdwdV9tbiwgbWlycm9yKTsK LQotCUlOSVRfV09SSygmYW1uLT53b3JrLCBhbWRncHVfbW5fZGVzdHJveSk7Ci0Jc2NoZWR1bGVf d29yaygmYW1uLT53b3JrKTsKLX0KLQogLyoqCiAgKiBhbWRncHVfbW5fbG9jayAtIHRha2UgdGhl IHdyaXRlIHNpZGUgbG9jayBmb3IgdGhpcyBub3RpZmllcgogICoKQEAgLTEzMywxNTcgKzczLDg2 IEBAIHZvaWQgYW1kZ3B1X21uX3VubG9jayhzdHJ1Y3QgYW1kZ3B1X21uICptbikKIH0KIAogLyoq Ci0gKiBhbWRncHVfbW5fcmVhZF9sb2NrIC0gdGFrZSB0aGUgcmVhZCBzaWRlIGxvY2sgZm9yIHRo aXMgbm90aWZpZXIKLSAqCi0gKiBAYW1uOiBvdXIgbm90aWZpZXIKLSAqLwotc3RhdGljIGludCBh bWRncHVfbW5fcmVhZF9sb2NrKHN0cnVjdCBhbWRncHVfbW4gKmFtbiwgYm9vbCBibG9ja2FibGUp Ci17Ci0JaWYgKGJsb2NrYWJsZSkKLQkJZG93bl9yZWFkKCZhbW4tPmxvY2spOwotCWVsc2UgaWYg KCFkb3duX3JlYWRfdHJ5bG9jaygmYW1uLT5sb2NrKSkKLQkJcmV0dXJuIC1FQUdBSU47Ci0KLQly ZXR1cm4gMDsKLX0KLQotLyoqCi0gKiBhbWRncHVfbW5fcmVhZF91bmxvY2sgLSBkcm9wIHRoZSBy ZWFkIHNpZGUgbG9jayBmb3IgdGhpcyBub3RpZmllcgotICoKLSAqIEBhbW46IG91ciBub3RpZmll cgotICovCi1zdGF0aWMgdm9pZCBhbWRncHVfbW5fcmVhZF91bmxvY2soc3RydWN0IGFtZGdwdV9t biAqYW1uKQotewotCXVwX3JlYWQoJmFtbi0+bG9jayk7Ci19Ci0KLS8qKgotICogYW1kZ3B1X21u X2ludmFsaWRhdGVfbm9kZSAtIHVubWFwIGFsbCBCT3Mgb2YgYSBub2RlCisgKiBhbWRncHVfbW5f aW52YWxpZGF0ZV9nZnggLSBjYWxsYmFjayB0byBub3RpZnkgYWJvdXQgbW0gY2hhbmdlCiAgKgot ICogQG5vZGU6IHRoZSBub2RlIHdpdGggdGhlIEJPcyB0byB1bm1hcAotICogQHN0YXJ0OiBzdGFy dCBvZiBhZGRyZXNzIHJhbmdlIGFmZmVjdGVkCi0gKiBAZW5kOiBlbmQgb2YgYWRkcmVzcyByYW5n ZSBhZmZlY3RlZAorICogQG1ybjogdGhlIHJhbmdlIChtbSkgaXMgYWJvdXQgdG8gdXBkYXRlCisg KiBAcmFuZ2U6IGRldGFpbHMgb24gdGhlIGludmFsaWRhdGlvbgogICoKICAqIEJsb2NrIGZvciBv cGVyYXRpb25zIG9uIEJPcyB0byBmaW5pc2ggYW5kIG1hcmsgcGFnZXMgYXMgYWNjZXNzZWQgYW5k CiAgKiBwb3RlbnRpYWxseSBkaXJ0eS4KICAqLwotc3RhdGljIHZvaWQgYW1kZ3B1X21uX2ludmFs aWRhdGVfbm9kZShzdHJ1Y3QgYW1kZ3B1X21uX25vZGUgKm5vZGUsCi0JCQkJICAgICAgdW5zaWdu ZWQgbG9uZyBzdGFydCwKLQkJCQkgICAgICB1bnNpZ25lZCBsb25nIGVuZCkKK3N0YXRpYyBib29s IGFtZGdwdV9tbl9pbnZhbGlkYXRlX2dmeChzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyICptcm4s CisJCQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICpyYW5nZSkKIHsKLQlz dHJ1Y3QgYW1kZ3B1X2JvICpibzsKKwlzdHJ1Y3QgYW1kZ3B1X2JvICpibyA9IGNvbnRhaW5lcl9v Zihtcm4sIHN0cnVjdCBhbWRncHVfYm8sIG5vdGlmaWVyKTsKKwlzdHJ1Y3QgYW1kZ3B1X2Rldmlj ZSAqYWRldiA9IGFtZGdwdV90dG1fYWRldihiby0+dGJvLmJkZXYpOwogCWxvbmcgcjsKIAotCWxp c3RfZm9yX2VhY2hfZW50cnkoYm8sICZub2RlLT5ib3MsIG1uX2xpc3QpIHsKLQotCQlpZiAoIWFt ZGdwdV90dG1fdHRfYWZmZWN0X3VzZXJwdHIoYm8tPnRiby50dG0sIHN0YXJ0LCBlbmQpKQotCQkJ Y29udGludWU7Ci0KLQkJciA9IGRtYV9yZXN2X3dhaXRfdGltZW91dF9yY3UoYm8tPnRiby5iYXNl LnJlc3YsCi0JCQl0cnVlLCBmYWxzZSwgTUFYX1NDSEVEVUxFX1RJTUVPVVQpOwotCQlpZiAociA8 PSAwKQotCQkJRFJNX0VSUk9SKCIoJWxkKSBmYWlsZWQgdG8gd2FpdCBmb3IgdXNlciBib1xuIiwg cik7Ci0JfQorCS8qIEZJWE1FOiBJcyB0aGlzIG5lY2Vzc2FyeT8gKi8KKwlpZiAoIWFtZGdwdV90 dG1fdHRfYWZmZWN0X3VzZXJwdHIoYm8tPnRiby50dG0sIHJhbmdlLT5zdGFydCwKKwkJCQkJICBy YW5nZS0+ZW5kKSkKKwkJcmV0dXJuIHRydWU7CisKKwlpZiAoIW1tdV9ub3RpZmllcl9yYW5nZV9i bG9ja2FibGUocmFuZ2UpKQorCQlyZXR1cm4gZmFsc2U7CisKKwltdXRleF9sb2NrKCZhZGV2LT5u b3RpZmllcl9sb2NrKTsKKwlyID0gZG1hX3Jlc3Zfd2FpdF90aW1lb3V0X3JjdShiby0+dGJvLmJh c2UucmVzdiwgdHJ1ZSwgZmFsc2UsCisJCQkJICAgICAgTUFYX1NDSEVEVUxFX1RJTUVPVVQpOwor CW11dGV4X3VubG9jaygmYWRldi0+bm90aWZpZXJfbG9jayk7CisJaWYgKHIgPD0gMCkKKwkJRFJN X0VSUk9SKCIoJWxkKSBmYWlsZWQgdG8gd2FpdCBmb3IgdXNlciBib1xuIiwgcik7CisJcmV0dXJu IHRydWU7CiB9CiAKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyX29wcyBh bWRncHVfbW5fZ2Z4X29wcyA9IHsKKwkuaW52YWxpZGF0ZSA9IGFtZGdwdV9tbl9pbnZhbGlkYXRl X2dmeCwKK307CisKIC8qKgotICogYW1kZ3B1X21uX3N5bmNfcGFnZXRhYmxlc19nZnggLSBjYWxs YmFjayB0byBub3RpZnkgYWJvdXQgbW0gY2hhbmdlCisgKiBhbWRncHVfbW5faW52YWxpZGF0ZV9o c2EgLSBjYWxsYmFjayB0byBub3RpZnkgYWJvdXQgbW0gY2hhbmdlCiAgKgotICogQG1pcnJvcjog dGhlIGhtbV9taXJyb3IgKG1tKSBpcyBhYm91dCB0byB1cGRhdGUKLSAqIEB1cGRhdGU6IHRoZSB1 cGRhdGUgc3RhcnQsIGVuZCBhZGRyZXNzCisgKiBAbXJuOiB0aGUgcmFuZ2UgKG1tKSBpcyBhYm91 dCB0byB1cGRhdGUKKyAqIEByYW5nZTogZGV0YWlscyBvbiB0aGUgaW52YWxpZGF0aW9uCiAgKgot ICogQmxvY2sgZm9yIG9wZXJhdGlvbnMgb24gQk9zIHRvIGZpbmlzaCBhbmQgbWFyayBwYWdlcyBh cyBhY2Nlc3NlZCBhbmQKLSAqIHBvdGVudGlhbGx5IGRpcnR5LgorICogV2UgdGVtcG9yYXJpbHkg ZXZpY3QgdGhlIEJPIGF0dGFjaGVkIHRvIHRoaXMgcmFuZ2UuIFRoaXMgbmVjZXNzaXRhdGVzCisg KiBldmljdGluZyBhbGwgdXNlci1tb2RlIHF1ZXVlcyBvZiB0aGUgcHJvY2Vzcy4KICAqLwotc3Rh dGljIGludAotYW1kZ3B1X21uX3N5bmNfcGFnZXRhYmxlc19nZngoc3RydWN0IGhtbV9taXJyb3Ig Km1pcnJvciwKLQkJCSAgICAgIGNvbnN0IHN0cnVjdCBtbXVfbm90aWZpZXJfcmFuZ2UgKnVwZGF0 ZSkKK3N0YXRpYyBib29sIGFtZGdwdV9tbl9pbnZhbGlkYXRlX2hzYShzdHJ1Y3QgbW11X3Jhbmdl X25vdGlmaWVyICptcm4sCisJCQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3Jhbmdl ICpyYW5nZSkKIHsKLQlzdHJ1Y3QgYW1kZ3B1X21uICphbW4gPSBjb250YWluZXJfb2YobWlycm9y LCBzdHJ1Y3QgYW1kZ3B1X21uLCBtaXJyb3IpOwotCXVuc2lnbmVkIGxvbmcgc3RhcnQgPSB1cGRh dGUtPnN0YXJ0OwotCXVuc2lnbmVkIGxvbmcgZW5kID0gdXBkYXRlLT5lbmQ7Ci0JYm9vbCBibG9j a2FibGUgPSBtbXVfbm90aWZpZXJfcmFuZ2VfYmxvY2thYmxlKHVwZGF0ZSk7Ci0Jc3RydWN0IGlu dGVydmFsX3RyZWVfbm9kZSAqaXQ7Ci0KLQkvKiBub3RpZmljYXRpb24gaXMgZXhjbHVzaXZlLCBi dXQgaW50ZXJ2YWwgaXMgaW5jbHVzaXZlICovCi0JZW5kIC09IDE7Ci0KLQkvKiBUT0RPIHdlIHNo b3VsZCBiZSBhYmxlIHRvIHNwbGl0IGxvY2tpbmcgZm9yIGludGVydmFsIHRyZWUgYW5kCi0JICog YW1kZ3B1X21uX2ludmFsaWRhdGVfbm9kZQotCSAqLwotCWlmIChhbWRncHVfbW5fcmVhZF9sb2Nr KGFtbiwgYmxvY2thYmxlKSkKLQkJcmV0dXJuIC1FQUdBSU47Ci0KLQlpdCA9IGludGVydmFsX3Ry ZWVfaXRlcl9maXJzdCgmYW1uLT5vYmplY3RzLCBzdGFydCwgZW5kKTsKLQl3aGlsZSAoaXQpIHsK LQkJc3RydWN0IGFtZGdwdV9tbl9ub2RlICpub2RlOwotCi0JCWlmICghYmxvY2thYmxlKSB7Ci0J CQlhbWRncHVfbW5fcmVhZF91bmxvY2soYW1uKTsKLQkJCXJldHVybiAtRUFHQUlOOwotCQl9CisJ c3RydWN0IGFtZGdwdV9ibyAqYm8gPSBjb250YWluZXJfb2YobXJuLCBzdHJ1Y3QgYW1kZ3B1X2Jv LCBub3RpZmllcik7CisJc3RydWN0IGFtZGdwdV9kZXZpY2UgKmFkZXYgPSBhbWRncHVfdHRtX2Fk ZXYoYm8tPnRiby5iZGV2KTsKIAotCQlub2RlID0gY29udGFpbmVyX29mKGl0LCBzdHJ1Y3QgYW1k Z3B1X21uX25vZGUsIGl0KTsKLQkJaXQgPSBpbnRlcnZhbF90cmVlX2l0ZXJfbmV4dChpdCwgc3Rh cnQsIGVuZCk7CisJLyogRklYTUU6IElzIHRoaXMgbmVjZXNzYXJ5PyAqLworCWlmICghYW1kZ3B1 X3R0bV90dF9hZmZlY3RfdXNlcnB0cihiby0+dGJvLnR0bSwgcmFuZ2UtPnN0YXJ0LAorCQkJCQkg IHJhbmdlLT5lbmQpKQorCQlyZXR1cm4gdHJ1ZTsKIAotCQlhbWRncHVfbW5faW52YWxpZGF0ZV9u b2RlKG5vZGUsIHN0YXJ0LCBlbmQpOwotCX0KKwlpZiAoIW1tdV9ub3RpZmllcl9yYW5nZV9ibG9j a2FibGUocmFuZ2UpKQorCQlyZXR1cm4gZmFsc2U7CiAKLQlhbWRncHVfbW5fcmVhZF91bmxvY2so YW1uKTsKKwltdXRleF9sb2NrKCZhZGV2LT5ub3RpZmllcl9sb2NrKTsKKwlhbWRncHVfYW1ka2Zk X2V2aWN0X3VzZXJwdHIoYm8tPmtmZF9ibywgYm8tPm5vdGlmaWVyLm1tKTsKKwltdXRleF91bmxv Y2soJmFkZXYtPm5vdGlmaWVyX2xvY2spOwogCi0JcmV0dXJuIDA7CisJcmV0dXJuIHRydWU7CiB9 CiAKLS8qKgotICogYW1kZ3B1X21uX3N5bmNfcGFnZXRhYmxlc19oc2EgLSBjYWxsYmFjayB0byBu b3RpZnkgYWJvdXQgbW0gY2hhbmdlCi0gKgotICogQG1pcnJvcjogdGhlIGhtbV9taXJyb3IgKG1t KSBpcyBhYm91dCB0byB1cGRhdGUKLSAqIEB1cGRhdGU6IHRoZSB1cGRhdGUgc3RhcnQsIGVuZCBh ZGRyZXNzCi0gKgotICogV2UgdGVtcG9yYXJpbHkgZXZpY3QgYWxsIEJPcyBiZXR3ZWVuIHN0YXJ0 IGFuZCBlbmQuIFRoaXMKLSAqIG5lY2Vzc2l0YXRlcyBldmljdGluZyBhbGwgdXNlci1tb2RlIHF1 ZXVlcyBvZiB0aGUgcHJvY2Vzcy4gVGhlIEJPcwotICogYXJlIHJlc3RvcnRlZCBpbiBhbWRncHVf bW5faW52YWxpZGF0ZV9yYW5nZV9lbmRfaHNhLgotICovCi1zdGF0aWMgaW50Ci1hbWRncHVfbW5f c3luY19wYWdldGFibGVzX2hzYShzdHJ1Y3QgaG1tX21pcnJvciAqbWlycm9yLAotCQkJICAgICAg Y29uc3Qgc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAqdXBkYXRlKQorc3RhdGljIGNvbnN0IHN0 cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXJfb3BzIGFtZGdwdV9tbl9oc2Ffb3BzID0geworCS5pbnZh bGlkYXRlID0gYW1kZ3B1X21uX2ludmFsaWRhdGVfaHNhLAorfTsKKworc3RhdGljIGludCBhbWRn cHVfbW5fc3luY19wYWdldGFibGVzKHN0cnVjdCBobW1fbWlycm9yICptaXJyb3IsCisJCQkJICAg ICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICp1cGRhdGUpCiB7CiAJc3RydWN0IGFt ZGdwdV9tbiAqYW1uID0gY29udGFpbmVyX29mKG1pcnJvciwgc3RydWN0IGFtZGdwdV9tbiwgbWly cm9yKTsKLQl1bnNpZ25lZCBsb25nIHN0YXJ0ID0gdXBkYXRlLT5zdGFydDsKLQl1bnNpZ25lZCBs b25nIGVuZCA9IHVwZGF0ZS0+ZW5kOwotCWJvb2wgYmxvY2thYmxlID0gbW11X25vdGlmaWVyX3Jh bmdlX2Jsb2NrYWJsZSh1cGRhdGUpOwotCXN0cnVjdCBpbnRlcnZhbF90cmVlX25vZGUgKml0Owog Ci0JLyogbm90aWZpY2F0aW9uIGlzIGV4Y2x1c2l2ZSwgYnV0IGludGVydmFsIGlzIGluY2x1c2l2 ZSAqLwotCWVuZCAtPSAxOwotCi0JaWYgKGFtZGdwdV9tbl9yZWFkX2xvY2soYW1uLCBibG9ja2Fi bGUpKQotCQlyZXR1cm4gLUVBR0FJTjsKLQotCWl0ID0gaW50ZXJ2YWxfdHJlZV9pdGVyX2ZpcnN0 KCZhbW4tPm9iamVjdHMsIHN0YXJ0LCBlbmQpOwotCXdoaWxlIChpdCkgewotCQlzdHJ1Y3QgYW1k Z3B1X21uX25vZGUgKm5vZGU7Ci0JCXN0cnVjdCBhbWRncHVfYm8gKmJvOwotCi0JCWlmICghYmxv Y2thYmxlKSB7Ci0JCQlhbWRncHVfbW5fcmVhZF91bmxvY2soYW1uKTsKLQkJCXJldHVybiAtRUFH QUlOOwotCQl9Ci0KLQkJbm9kZSA9IGNvbnRhaW5lcl9vZihpdCwgc3RydWN0IGFtZGdwdV9tbl9u b2RlLCBpdCk7Ci0JCWl0ID0gaW50ZXJ2YWxfdHJlZV9pdGVyX25leHQoaXQsIHN0YXJ0LCBlbmQp OwotCi0JCWxpc3RfZm9yX2VhY2hfZW50cnkoYm8sICZub2RlLT5ib3MsIG1uX2xpc3QpIHsKLQkJ CXN0cnVjdCBrZ2RfbWVtICptZW0gPSBiby0+a2ZkX2JvOwotCi0JCQlpZiAoYW1kZ3B1X3R0bV90 dF9hZmZlY3RfdXNlcnB0cihiby0+dGJvLnR0bSwKLQkJCQkJCQkgc3RhcnQsIGVuZCkpCi0JCQkJ YW1kZ3B1X2FtZGtmZF9ldmljdF91c2VycHRyKG1lbSwgYW1uLT5tbSk7Ci0JCX0KLQl9Ci0KLQlh bWRncHVfbW5fcmVhZF91bmxvY2soYW1uKTsKKwlpZiAoIW1tdV9ub3RpZmllcl9yYW5nZV9ibG9j a2FibGUodXBkYXRlKSkKKwkJcmV0dXJuIGZhbHNlOwogCisJZG93bl9yZWFkKCZhbW4tPmxvY2sp OworCXVwX3JlYWQoJmFtbi0+bG9jayk7CiAJcmV0dXJuIDA7CiB9CiAKQEAgLTI5NSwxMiArMTY0 LDEwIEBAIGFtZGdwdV9tbl9zeW5jX3BhZ2V0YWJsZXNfaHNhKHN0cnVjdCBobW1fbWlycm9yICpt aXJyb3IsCiAKIHN0YXRpYyBzdHJ1Y3QgaG1tX21pcnJvcl9vcHMgYW1kZ3B1X2htbV9taXJyb3Jf b3BzW10gPSB7CiAJW0FNREdQVV9NTl9UWVBFX0dGWF0gPSB7Ci0JCS5zeW5jX2NwdV9kZXZpY2Vf cGFnZXRhYmxlcyA9IGFtZGdwdV9tbl9zeW5jX3BhZ2V0YWJsZXNfZ2Z4LAotCQkucmVsZWFzZSA9 IGFtZGdwdV9obW1fbWlycm9yX3JlbGVhc2UKKwkJLnN5bmNfY3B1X2RldmljZV9wYWdldGFibGVz ID0gYW1kZ3B1X21uX3N5bmNfcGFnZXRhYmxlcywKIAl9LAogCVtBTURHUFVfTU5fVFlQRV9IU0Fd ID0gewotCQkuc3luY19jcHVfZGV2aWNlX3BhZ2V0YWJsZXMgPSBhbWRncHVfbW5fc3luY19wYWdl dGFibGVzX2hzYSwKLQkJLnJlbGVhc2UgPSBhbWRncHVfaG1tX21pcnJvcl9yZWxlYXNlCisJCS5z eW5jX2NwdV9kZXZpY2VfcGFnZXRhYmxlcyA9IGFtZGdwdV9tbl9zeW5jX3BhZ2V0YWJsZXMsCiAJ fSwKIH07CiAKQEAgLTMyNyw3ICsxOTQsOCBAQCBzdHJ1Y3QgYW1kZ3B1X21uICphbWRncHVfbW5f Z2V0KHN0cnVjdCBhbWRncHVfZGV2aWNlICphZGV2LAogCX0KIAogCWhhc2hfZm9yX2VhY2hfcG9z c2libGUoYWRldi0+bW5faGFzaCwgYW1uLCBub2RlLCBrZXkpCi0JCWlmIChBTURHUFVfTU5fS0VZ KGFtbi0+bW0sIGFtbi0+dHlwZSkgPT0ga2V5KQorCQlpZiAoQU1ER1BVX01OX0tFWShhbW4tPm1p cnJvci5obW0tPm1tdV9ub3RpZmllci5tbSwKKwkJCQkgIGFtbi0+dHlwZSkgPT0ga2V5KQogCQkJ Z290byByZWxlYXNlX2xvY2tzOwogCiAJYW1uID0ga3phbGxvYyhzaXplb2YoKmFtbiksIEdGUF9L RVJORUwpOwpAQCAtMzM3LDEwICsyMDUsOCBAQCBzdHJ1Y3QgYW1kZ3B1X21uICphbWRncHVfbW5f Z2V0KHN0cnVjdCBhbWRncHVfZGV2aWNlICphZGV2LAogCX0KIAogCWFtbi0+YWRldiA9IGFkZXY7 Ci0JYW1uLT5tbSA9IG1tOwogCWluaXRfcndzZW0oJmFtbi0+bG9jayk7CiAJYW1uLT50eXBlID0g dHlwZTsKLQlhbW4tPm9iamVjdHMgPSBSQl9ST09UX0NBQ0hFRDsKIAogCWFtbi0+bWlycm9yLm9w cyA9ICZhbWRncHVfaG1tX21pcnJvcl9vcHNbdHlwZV07CiAJciA9IGhtbV9taXJyb3JfcmVnaXN0 ZXIoJmFtbi0+bWlycm9yLCBtbSk7CkBAIC0zNjksMTAwICsyMzUsMzMgQEAgc3RydWN0IGFtZGdw dV9tbiAqYW1kZ3B1X21uX2dldChzdHJ1Y3QgYW1kZ3B1X2RldmljZSAqYWRldiwKICAqIEBibzog YW1kZ3B1IGJ1ZmZlciBvYmplY3QKICAqIEBhZGRyOiB1c2VycHRyIGFkZHIgd2Ugc2hvdWxkIG1v bml0b3IKICAqCi0gKiBSZWdpc3RlcnMgYW4gSE1NIG1pcnJvciBmb3IgdGhlIGdpdmVuIEJPIGF0 IHRoZSBzcGVjaWZpZWQgYWRkcmVzcy4KKyAqIFJlZ2lzdGVycyBhIG1tdV9ub3RpZmllciBmb3Ig dGhlIGdpdmVuIEJPIGF0IHRoZSBzcGVjaWZpZWQgYWRkcmVzcy4KICAqIFJldHVybnMgMCBvbiBz dWNjZXNzLCAtRVJSTk8gaWYgYW55dGhpbmcgZ29lcyB3cm9uZy4KICAqLwogaW50IGFtZGdwdV9t bl9yZWdpc3RlcihzdHJ1Y3QgYW1kZ3B1X2JvICpibywgdW5zaWduZWQgbG9uZyBhZGRyKQogewot CXVuc2lnbmVkIGxvbmcgZW5kID0gYWRkciArIGFtZGdwdV9ib19zaXplKGJvKSAtIDE7Ci0Jc3Ry dWN0IGFtZGdwdV9kZXZpY2UgKmFkZXYgPSBhbWRncHVfdHRtX2FkZXYoYm8tPnRiby5iZGV2KTsK LQllbnVtIGFtZGdwdV9tbl90eXBlIHR5cGUgPQotCQliby0+a2ZkX2JvID8gQU1ER1BVX01OX1RZ UEVfSFNBIDogQU1ER1BVX01OX1RZUEVfR0ZYOwotCXN0cnVjdCBhbWRncHVfbW4gKmFtbjsKLQlz dHJ1Y3QgYW1kZ3B1X21uX25vZGUgKm5vZGUgPSBOVUxMLCAqbmV3X25vZGU7Ci0Jc3RydWN0IGxp c3RfaGVhZCBib3M7Ci0Jc3RydWN0IGludGVydmFsX3RyZWVfbm9kZSAqaXQ7Ci0KLQlhbW4gPSBh bWRncHVfbW5fZ2V0KGFkZXYsIHR5cGUpOwotCWlmIChJU19FUlIoYW1uKSkKLQkJcmV0dXJuIFBU Ul9FUlIoYW1uKTsKLQotCW5ld19ub2RlID0ga21hbGxvYyhzaXplb2YoKm5ld19ub2RlKSwgR0ZQ X0tFUk5FTCk7Ci0JaWYgKCFuZXdfbm9kZSkKLQkJcmV0dXJuIC1FTk9NRU07Ci0KLQlJTklUX0xJ U1RfSEVBRCgmYm9zKTsKLQotCWRvd25fd3JpdGUoJmFtbi0+bG9jayk7Ci0KLQl3aGlsZSAoKGl0 ID0gaW50ZXJ2YWxfdHJlZV9pdGVyX2ZpcnN0KCZhbW4tPm9iamVjdHMsIGFkZHIsIGVuZCkpKSB7 Ci0JCWtmcmVlKG5vZGUpOwotCQlub2RlID0gY29udGFpbmVyX29mKGl0LCBzdHJ1Y3QgYW1kZ3B1 X21uX25vZGUsIGl0KTsKLQkJaW50ZXJ2YWxfdHJlZV9yZW1vdmUoJm5vZGUtPml0LCAmYW1uLT5v YmplY3RzKTsKLQkJYWRkciA9IG1pbihpdC0+c3RhcnQsIGFkZHIpOwotCQllbmQgPSBtYXgoaXQt Pmxhc3QsIGVuZCk7Ci0JCWxpc3Rfc3BsaWNlKCZub2RlLT5ib3MsICZib3MpOwotCX0KLQotCWlm ICghbm9kZSkKLQkJbm9kZSA9IG5ld19ub2RlOworCWlmIChiby0+a2ZkX2JvKQorCQliby0+bm90 aWZpZXIub3BzID0gJmFtZGdwdV9tbl9oc2Ffb3BzOwogCWVsc2UKLQkJa2ZyZWUobmV3X25vZGUp OwotCi0JYm8tPm1uID0gYW1uOwotCi0Jbm9kZS0+aXQuc3RhcnQgPSBhZGRyOwotCW5vZGUtPml0 Lmxhc3QgPSBlbmQ7Ci0JSU5JVF9MSVNUX0hFQUQoJm5vZGUtPmJvcyk7Ci0JbGlzdF9zcGxpY2Uo JmJvcywgJm5vZGUtPmJvcyk7Ci0JbGlzdF9hZGQoJmJvLT5tbl9saXN0LCAmbm9kZS0+Ym9zKTsK KwkJYm8tPm5vdGlmaWVyLm9wcyA9ICZhbWRncHVfbW5fZ2Z4X29wczsKIAotCWludGVydmFsX3Ry ZWVfaW5zZXJ0KCZub2RlLT5pdCwgJmFtbi0+b2JqZWN0cyk7Ci0KLQl1cF93cml0ZSgmYW1uLT5s b2NrKTsKLQotCXJldHVybiAwOworCXJldHVybiBtbXVfcmFuZ2Vfbm90aWZpZXJfaW5zZXJ0KCZi by0+bm90aWZpZXIsIGFkZHIsCisJCQkJCSBhbWRncHVfYm9fc2l6ZShibyksIGN1cnJlbnQtPm1t KTsKIH0KIAogLyoqCi0gKiBhbWRncHVfbW5fdW5yZWdpc3RlciAtIHVucmVnaXN0ZXIgYSBCTyBm b3IgSE1NIG1pcnJvciB1cGRhdGVzCisgKiBhbWRncHVfbW5fdW5yZWdpc3RlciAtIHVucmVnaXN0 ZXIgYSBCTyBmb3Igbm90aWZpZXIgdXBkYXRlcwogICoKICAqIEBibzogYW1kZ3B1IGJ1ZmZlciBv YmplY3QKICAqCi0gKiBSZW1vdmUgYW55IHJlZ2lzdHJhdGlvbiBvZiBITU0gbWlycm9yIHVwZGF0 ZXMgZnJvbSB0aGUgYnVmZmVyIG9iamVjdC4KKyAqIFJlbW92ZSBhbnkgcmVnaXN0cmF0aW9uIG9m IG1tdSBub3RpZmllciB1cGRhdGVzIGZyb20gdGhlIGJ1ZmZlciBvYmplY3QuCiAgKi8KIHZvaWQg YW1kZ3B1X21uX3VucmVnaXN0ZXIoc3RydWN0IGFtZGdwdV9ibyAqYm8pCiB7Ci0Jc3RydWN0IGFt ZGdwdV9kZXZpY2UgKmFkZXYgPSBhbWRncHVfdHRtX2FkZXYoYm8tPnRiby5iZGV2KTsKLQlzdHJ1 Y3QgYW1kZ3B1X21uICphbW47Ci0Jc3RydWN0IGxpc3RfaGVhZCAqaGVhZDsKLQotCW11dGV4X2xv Y2soJmFkZXYtPm1uX2xvY2spOwotCi0JYW1uID0gYm8tPm1uOwotCWlmIChhbW4gPT0gTlVMTCkg ewotCQltdXRleF91bmxvY2soJmFkZXYtPm1uX2xvY2spOworCWlmICghYm8tPm5vdGlmaWVyLm1t KQogCQlyZXR1cm47Ci0JfQotCi0JZG93bl93cml0ZSgmYW1uLT5sb2NrKTsKLQotCS8qIHNhdmUg dGhlIG5leHQgbGlzdCBlbnRyeSBmb3IgbGF0ZXIgKi8KLQloZWFkID0gYm8tPm1uX2xpc3QubmV4 dDsKLQotCWJvLT5tbiA9IE5VTEw7Ci0JbGlzdF9kZWxfaW5pdCgmYm8tPm1uX2xpc3QpOwotCi0J aWYgKGxpc3RfZW1wdHkoaGVhZCkpIHsKLQkJc3RydWN0IGFtZGdwdV9tbl9ub2RlICpub2RlOwot Ci0JCW5vZGUgPSBjb250YWluZXJfb2YoaGVhZCwgc3RydWN0IGFtZGdwdV9tbl9ub2RlLCBib3Mp OwotCQlpbnRlcnZhbF90cmVlX3JlbW92ZSgmbm9kZS0+aXQsICZhbW4tPm9iamVjdHMpOwotCQlr ZnJlZShub2RlKTsKLQl9Ci0KLQl1cF93cml0ZSgmYW1uLT5sb2NrKTsKLQltdXRleF91bmxvY2so JmFkZXYtPm1uX2xvY2spOworCW1tdV9yYW5nZV9ub3RpZmllcl9yZW1vdmUoJmJvLT5ub3RpZmll cik7CisJYm8tPm5vdGlmaWVyLm1tID0gTlVMTDsKIH0KIAogLyogZmxhZ3MgdXNlZCBieSBITU0g aW50ZXJuYWwsIG5vdCByZWxhdGVkIHRvIENQVS9HUFUgUFRFIGZsYWdzICovCmRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uaCBiL2RyaXZlcnMvZ3B1L2Ry bS9hbWQvYW1kZ3B1L2FtZGdwdV9tbi5oCmluZGV4IGI4ZWQ2ODk0MzYyNWMyLi5kNzNhYjI5NDdi MjJiMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmgK KysrIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmgKQEAgLTM5LDEyICsz OSwxMCBAQCBlbnVtIGFtZGdwdV9tbl90eXBlIHsKICAqIHN0cnVjdCBhbWRncHVfbW4KICAqCiAg KiBAYWRldjogYW1kZ3B1IGRldmljZSBwb2ludGVyCi0gKiBAbW06IHByb2Nlc3MgYWRkcmVzcyBz cGFjZQogICogQHR5cGU6IHR5cGUgb2YgTU1VIG5vdGlmaWVyCiAgKiBAd29yazogZGVzdHJ1Y3Rp b24gd29yayBpdGVtCiAgKiBAbm9kZTogaGFzaCB0YWJsZSBub2RlIHRvIGZpbmQgc3RydWN0dXJl IGJ5IGFkZXYgYW5kIG1uCiAgKiBAbG9jazogcncgc2VtYXBob3JlIHByb3RlY3RpbmcgdGhlIG5v dGlmaWVyIG5vZGVzCi0gKiBAb2JqZWN0czogaW50ZXJ2YWwgdHJlZSBjb250YWluaW5nIGFtZGdw dV9tbl9ub2RlcwogICogQG1pcnJvcjogSE1NIG1pcnJvciBmdW5jdGlvbiBzdXBwb3J0CiAgKgog ICogRGF0YSBmb3IgZWFjaCBhbWRncHUgZGV2aWNlIGFuZCBwcm9jZXNzIGFkZHJlc3Mgc3BhY2Uu CkBAIC01Miw3ICs1MCw2IEBAIGVudW0gYW1kZ3B1X21uX3R5cGUgewogc3RydWN0IGFtZGdwdV9t biB7CiAJLyogY29uc3RhbnQgYWZ0ZXIgaW5pdGlhbGlzYXRpb24gKi8KIAlzdHJ1Y3QgYW1kZ3B1 X2RldmljZQkqYWRldjsKLQlzdHJ1Y3QgbW1fc3RydWN0CSptbTsKIAllbnVtIGFtZGdwdV9tbl90 eXBlCXR5cGU7CiAKIAkvKiBvbmx5IHVzZWQgb24gZGVzdHJ1Y3Rpb24gKi8KQEAgLTYzLDcgKzYw LDYgQEAgc3RydWN0IGFtZGdwdV9tbiB7CiAKIAkvKiBvYmplY3RzIHByb3RlY3RlZCBieSBsb2Nr ICovCiAJc3RydWN0IHJ3X3NlbWFwaG9yZQlsb2NrOwotCXN0cnVjdCByYl9yb290X2NhY2hlZAlv YmplY3RzOwogCiAjaWZkZWYgQ09ORklHX0hNTV9NSVJST1IKIAkvKiBITU0gbWlycm9yICovCmRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfb2JqZWN0LmggYi9k cml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfb2JqZWN0LmgKaW5kZXggNjU4ZjRjOTc3 OWI3MDQuLjRiNDRhYjg1MGY5NGMyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2Ft ZGdwdS9hbWRncHVfb2JqZWN0LmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1k Z3B1X29iamVjdC5oCkBAIC0zMCw2ICszMCw5IEBACiAKICNpbmNsdWRlIDxkcm0vYW1kZ3B1X2Ry bS5oPgogI2luY2x1ZGUgImFtZGdwdS5oIgorI2lmZGVmIENPTkZJR19NTVVfTk9USUZJRVIKKyNp bmNsdWRlIDxsaW51eC9tbXVfbm90aWZpZXIuaD4KKyNlbmRpZgogCiAjZGVmaW5lIEFNREdQVV9C T19JTlZBTElEX09GRlNFVAlMT05HX01BWAogI2RlZmluZSBBTURHUFVfQk9fTUFYX1BMQUNFTUVO VFMJMwpAQCAtMTAwLDEwICsxMDMsMTIgQEAgc3RydWN0IGFtZGdwdV9ibyB7CiAJc3RydWN0IHR0 bV9ib19rbWFwX29iagkJZG1hX2J1Zl92bWFwOwogCXN0cnVjdCBhbWRncHVfbW4JCSptbjsKIAot CXVuaW9uIHsKLQkJc3RydWN0IGxpc3RfaGVhZAltbl9saXN0OwotCQlzdHJ1Y3QgbGlzdF9oZWFk CXNoYWRvd19saXN0OwotCX07CisKKyNpZmRlZiBDT05GSUdfTU1VX05PVElGSUVSCisJc3RydWN0 IG1tdV9yYW5nZV9ub3RpZmllcglub3RpZmllcjsKKyNlbmRpZgorCisJc3RydWN0IGxpc3RfaGVh ZAkJc2hhZG93X2xpc3Q7CiAKIAlzdHJ1Y3Qga2dkX21lbSAgICAgICAgICAgICAgICAgICprZmRf Ym87CiB9OwotLSAKMi4yMy4wCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fXwphbWQtZ2Z4IG1haWxpbmcgbGlzdAphbWQtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9w Lm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2FtZC1n Zng=