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=-6.8 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED 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 5A0E6CA9ECF for ; Fri, 1 Nov 2019 18:39:43 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 0FD3F21734 for ; Fri, 1 Nov 2019 18:39:43 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=Mellanox.com header.i=@Mellanox.com header.b="SVt+wZWf" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726498AbfKASjm (ORCPT ); Fri, 1 Nov 2019 14:39:42 -0400 Received: from mail-eopbgr30058.outbound.protection.outlook.com ([40.107.3.58]:60995 "EHLO EUR03-AM5-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1726671AbfKASjm (ORCPT ); Fri, 1 Nov 2019 14:39:42 -0400 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=ID1czwKAJLJjyQE30wEVEYNJTUEtpI7Qkl24FrPbmXzaju2x222SlxL+11q/UDBdUsYq/Z2/UvM7LVb9kuBkmxRiPd+cG27JIs/5anPSLrc7aT3QaOrgcKpwM8i5z2Mu+VXBiwW83tEQNE5hJXvc+XrdZie0X3djGlK9VtdfANz/f9HA6j0tymIPobevmbRt5At9dvqKzmAlICQVL+C5KxnYAZUX1XsZDwxeeap+ii3cUXxe6a6LXB6Y9Z2CLEUZrgZfETf0RDCkTFrDGtTCi21B8u9CnCEWoplFgFw+ldPZqhwRHcWF5oC5uiLKC4BAedJEJltsMdcJCdpwIM9Ntw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=oXuOHTtipoYkfU5LykKoTmwF4/VlgjtrC3fuHXm5AjI=; b=Ua7vkWayi5JBuLpIWZDwMR6AU8/DU7mhA0xCZewXDuUeeom3QLuwm1csS/Ijbju+vpjF5akTq0bN0oEELJ/Kenn1bIACSln3frAm66Gi8wdxfLhRqTQ+N8LJ2dpvGazDJQ9x9GjhAtvjf0jWi9ZpO9RhsiChXpx2x0XeytZp+nweQxxTcQXG22ZsGL5xqq1RfQ6lSkx9Yu/VeSvwR2JR/7hDMR5ENG++Gq98I60v1tkMK9wUXyvj65jfuM/79MVATfvMzpRzm1WpRXaXg6xWxf5XH6Ldn86uJDqZtAtFu3WnXOsCN8l+OGWxqAgNf56bqEnegkHrJwtC6tD56Ps3+g== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=mellanox.com; dmarc=pass action=none header.from=mellanox.com; dkim=pass header.d=mellanox.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=Mellanox.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=oXuOHTtipoYkfU5LykKoTmwF4/VlgjtrC3fuHXm5AjI=; b=SVt+wZWfddkHw40mdehiJvucDKT2KvzDlrQP55Ml/4rWjve2GuEe2xqxPo73B2fRqrFrHqK5bx8O/xIaihWeqPjCshAWTaYAbnXeNPUgKNFCym3gLpiowXTwCoZckm0xfZGrKXjiAUW/JE5DWbv0znRymHJP/wjis3b6AfDHIX8= Received: from VI1PR05MB4141.eurprd05.prod.outlook.com (52.133.14.15) by VI1PR05MB4416.eurprd05.prod.outlook.com (52.134.123.146) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.2387.22; Fri, 1 Nov 2019 18:34:40 +0000 Received: from VI1PR05MB4141.eurprd05.prod.outlook.com ([fe80::b179:e8bf:22d4:bf8d]) by VI1PR05MB4141.eurprd05.prod.outlook.com ([fe80::b179:e8bf:22d4:bf8d%5]) with mapi id 15.20.2387.028; Fri, 1 Nov 2019 18:34:40 +0000 From: Jason Gunthorpe To: "Yang, Philip" CC: "linux-mm@kvack.org" , Jerome Glisse , Ralph Campbell , John Hubbard , "Kuehling, Felix" , Juergen Gross , "Zhou, David(ChunMing)" , Mike Marciniszyn , Stefano Stabellini , Oleksandr Andrushchenko , "linux-rdma@vger.kernel.org" , "nouveau@lists.freedesktop.org" , Dennis Dalessandro , "amd-gfx@lists.freedesktop.org" , Christoph Hellwig , "dri-devel@lists.freedesktop.org" , "Deucher, Alexander" , "xen-devel@lists.xenproject.org" , Boris Ostrovsky , Petr Cvek , "Koenig, Christian" , Ben Skeggs Subject: [PATCH v2a 14/15] drm/amdgpu: Use mmu_range_notifier instead of hmm_mirror Thread-Topic: [PATCH v2a 14/15] drm/amdgpu: Use mmu_range_notifier instead of hmm_mirror Thread-Index: AQHVkOMFaRcJHQRrK0S6ryutY4Fnpg== Date: Fri, 1 Nov 2019 18:34:40 +0000 Message-ID: <20191101183435.GR22766@mellanox.com> References: <20191028201032.6352-1-jgg@ziepe.ca> <20191028201032.6352-15-jgg@ziepe.ca> <20191029192544.GU22766@mellanox.com> <30b2f569-bf7a-5166-c98d-4a4a13d1351f@amd.com> In-Reply-To: <30b2f569-bf7a-5166-c98d-4a4a13d1351f@amd.com> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-clientproxiedby: BN4PR12CA0013.namprd12.prod.outlook.com (2603:10b6:403:2::23) To VI1PR05MB4141.eurprd05.prod.outlook.com (2603:10a6:803:44::15) authentication-results: spf=none (sender IP is ) smtp.mailfrom=jgg@mellanox.com; x-ms-exchange-messagesentrepresentingtype: 1 x-originating-ip: [142.162.113.180] x-ms-publictraffictype: Email x-ms-office365-filtering-ht: Tenant x-ms-office365-filtering-correlation-id: 7fd1dc84-23d9-4c30-3490-08d75efa27d3 x-ms-traffictypediagnostic: VI1PR05MB4416: x-microsoft-antispam-prvs: x-ms-oob-tlc-oobclassifiers: OLM:6430; x-forefront-prvs: 020877E0CB x-forefront-antispam-report: SFV:NSPM;SFS:(10009020)(4636009)(366004)(136003)(396003)(376002)(39860400002)(346002)(199004)(189003)(36756003)(81156014)(86362001)(102836004)(54906003)(476003)(11346002)(446003)(14454004)(6916009)(6512007)(486006)(2616005)(99286004)(14444005)(6436002)(66066001)(256004)(6486002)(6116002)(2906002)(8676002)(25786009)(71200400001)(3846002)(4326008)(478600001)(71190400001)(33656002)(30864003)(5660300002)(66946007)(81166006)(8936002)(7736002)(52116002)(66556008)(66476007)(386003)(6506007)(1076003)(316002)(66446008)(186003)(305945005)(26005)(7416002)(76176011)(64756008);DIR:OUT;SFP:1101;SCL:1;SRVR:VI1PR05MB4416;H:VI1PR05MB4141.eurprd05.prod.outlook.com;FPR:;SPF:None;LANG:en;PTR:InfoNoRecords;A:1;MX:1; received-spf: None (protection.outlook.com: mellanox.com does not designate permitted sender hosts) x-ms-exchange-senderadcheck: 1 x-microsoft-antispam: BCL:0; x-microsoft-antispam-message-info: fWNQ+BZa7hfC/4uLDbkIzf190FXkgTVGRQKdPvrvbvJpoBtJPgrsM7NGgZQ1QolaRtrYNrap2uwCvyZBwc+s1RJrMJs0W4wt38pjuaPPJHfnwuNoqyOnrYlMsQwNybX+mi4Q5WE4Pg0wiaVGQDLKd/jzIznyDxANtLOIJkay4xVDUZuqQJg0ZJ5lwxg9w7eTS8jfnmflWgEN1kT2Vh17iuWWQZ3VwGzrMwd3SehhT5moiR+3hN8s058c3TYlgBggqYdEGdDYMmVxzwWbZ1hRnOtvnkbCjHalAFCEwBe2F4KYWoOr44uRyLV32bUbwHLWYknPvscKcWD2/FgOmTHQPiVPsk9o16OhK4JhXmP+uYkdvjkbZgWiPYIElS4dXYek7ygn7Xc0XKeD/JE/rH5lLTVBDLeo3+S2wC+qVP+/j2+4kf1uzHXjbfJLmDORfGdY x-ms-exchange-transport-forked: True Content-Type: text/plain; charset="us-ascii" Content-ID: Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 X-OriginatorOrg: Mellanox.com X-MS-Exchange-CrossTenant-Network-Message-Id: 7fd1dc84-23d9-4c30-3490-08d75efa27d3 X-MS-Exchange-CrossTenant-originalarrivaltime: 01 Nov 2019 18:34:40.7437 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: a652971c-7d2e-4d9b-a6a4-d149256f461b X-MS-Exchange-CrossTenant-mailboxtype: HOSTED X-MS-Exchange-CrossTenant-userprincipalname: 6w7Cky8H25cOW4Dxqgj7Dr4BIQtw+qoZ/7TjiXWzab8P8ekkpF8unK6sBjda6ZrGlvHzuK1g8e6b2fcbAMO5Iw== X-MS-Exchange-Transport-CrossTenantHeadersStamped: VI1PR05MB4416 Sender: linux-rdma-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-rdma@vger.kernel.org Convert the collision-retry lock around hmm_range_fault to use the one now provided by the mmu_range notifier. Although this driver does not seem to use the collision retry lock that hmm provides correctly, it can still be converted over to use the mmu_range_notifier api instead of hmm_mirror without too much trouble. This also deletes another place where a driver is associating additional data (struct amdgpu_mn) with a mmu_struct. Signed-off-by: Philip Yang Reviewed-by: Philip Yang Tested-by: Philip Yang Signed-off-by: Jason Gunthorpe --- .../gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c | 4 + drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c | 14 +- drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c | 150 ++---------------- drivers/gpu/drm/amd/amdgpu/amdgpu_mn.h | 49 ------ drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c | 116 +++++++++----- 5 files changed, 96 insertions(+), 237 deletions(-) Philip, here is what it loos like after combining the two patches, thanks diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c b/drivers/gpu= /drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c index 47700302a08b7f..1bcedb9b477dce 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c @@ -1738,6 +1738,10 @@ static int update_invalid_user_pages(struct amdkfd_p= rocess_info *process_info, return ret; } =20 + /* + * FIXME: Cannot ignore the return code, must hold + * notifier_lock + */ amdgpu_ttm_tt_get_user_pages_done(bo->tbo.ttm); =20 /* Mark the BO as valid unless it was invalidated diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c b/drivers/gpu/drm/amd/a= mdgpu/amdgpu_cs.c index 82823d9a8ba887..22c989bca7514c 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c @@ -603,8 +603,6 @@ static int amdgpu_cs_parser_bos(struct amdgpu_cs_parser= *p, e->tv.num_shared =3D 2; =20 amdgpu_bo_list_get_list(p->bo_list, &p->validated); - if (p->bo_list->first_userptr !=3D p->bo_list->num_entries) - p->mn =3D amdgpu_mn_get(p->adev, AMDGPU_MN_TYPE_GFX); =20 INIT_LIST_HEAD(&duplicates); amdgpu_vm_get_pd_bo(&fpriv->vm, &p->validated, &p->vm_pd); @@ -1287,11 +1285,11 @@ static int amdgpu_cs_submit(struct amdgpu_cs_parser= *p, if (r) goto error_unlock; =20 - /* No memory allocation is allowed while holding the mn lock. - * p->mn is hold until amdgpu_cs_submit is finished and fence is added - * to BOs. + /* No memory allocation is allowed while holding the notifier lock. + * The lock is held until amdgpu_cs_submit is finished and fence is + * added to BOs. */ - amdgpu_mn_lock(p->mn); + mutex_lock(&p->adev->notifier_lock); =20 /* If userptr are invalidated after amdgpu_cs_parser_bos(), return * -EAGAIN, drmIoctl in libdrm will restart the amdgpu_cs_ioctl. @@ -1334,13 +1332,13 @@ static int amdgpu_cs_submit(struct amdgpu_cs_parser= *p, amdgpu_vm_move_to_lru_tail(p->adev, &fpriv->vm); =20 ttm_eu_fence_buffer_objects(&p->ticket, &p->validated, p->fence); - amdgpu_mn_unlock(p->mn); + mutex_unlock(&p->adev->notifier_lock); =20 return 0; =20 error_abort: drm_sched_job_cleanup(&job->base); - amdgpu_mn_unlock(p->mn); + mutex_unlock(&p->adev->notifier_lock); =20 error_unlock: amdgpu_job_free(job); diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c b/drivers/gpu/drm/amd/a= mdgpu/amdgpu_mn.c index ac74320b71e4e7..f7be34907e54f5 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c @@ -50,28 +50,6 @@ #include "amdgpu.h" #include "amdgpu_amdkfd.h" =20 -/** - * amdgpu_mn_lock - take the write side lock for this notifier - * - * @mn: our notifier - */ -void amdgpu_mn_lock(struct amdgpu_mn *mn) -{ - if (mn) - down_write(&mn->lock); -} - -/** - * amdgpu_mn_unlock - drop the write side lock for this notifier - * - * @mn: our notifier - */ -void amdgpu_mn_unlock(struct amdgpu_mn *mn) -{ - if (mn) - up_write(&mn->lock); -} - /** * amdgpu_mn_invalidate_gfx - callback to notify about mm change * @@ -82,16 +60,20 @@ void amdgpu_mn_unlock(struct amdgpu_mn *mn) * potentially dirty. */ static bool amdgpu_mn_invalidate_gfx(struct mmu_range_notifier *mrn, - const struct mmu_notifier_range *range) + const struct mmu_notifier_range *range, + unsigned long cur_seq) { struct amdgpu_bo *bo =3D container_of(mrn, struct amdgpu_bo, notifier); struct amdgpu_device *adev =3D amdgpu_ttm_adev(bo->tbo.bdev); long r; =20 - if (!mmu_notifier_range_blockable(range)) + if (mmu_notifier_range_blockable(range)) + mutex_lock(&adev->notifier_lock); + else if (!mutex_trylock(&adev->notifier_lock)) return false; =20 - mutex_lock(&adev->notifier_lock); + mmu_range_set_seq(mrn, cur_seq); + r =3D dma_resv_wait_timeout_rcu(bo->tbo.base.resv, true, false, MAX_SCHEDULE_TIMEOUT); mutex_unlock(&adev->notifier_lock); @@ -114,15 +96,19 @@ static const struct mmu_range_notifier_ops amdgpu_mn_g= fx_ops =3D { * evicting all user-mode queues of the process. */ static bool amdgpu_mn_invalidate_hsa(struct mmu_range_notifier *mrn, - const struct mmu_notifier_range *range) + const struct mmu_notifier_range *range, + unsigned long cur_seq) { struct amdgpu_bo *bo =3D container_of(mrn, struct amdgpu_bo, notifier); struct amdgpu_device *adev =3D amdgpu_ttm_adev(bo->tbo.bdev); =20 - if (!mmu_notifier_range_blockable(range)) + if (mmu_notifier_range_blockable(range)) + mutex_lock(&adev->notifier_lock); + else if (!mutex_trylock(&adev->notifier_lock)) return false; =20 - mutex_lock(&adev->notifier_lock); + mmu_range_set_seq(mrn, cur_seq); + amdgpu_amdkfd_evict_userptr(bo->kfd_bo, bo->notifier.mm); mutex_unlock(&adev->notifier_lock); =20 @@ -133,92 +119,6 @@ static const struct mmu_range_notifier_ops amdgpu_mn_h= sa_ops =3D { .invalidate =3D amdgpu_mn_invalidate_hsa, }; =20 -static int amdgpu_mn_sync_pagetables(struct hmm_mirror *mirror, - const struct mmu_notifier_range *update) -{ - struct amdgpu_mn *amn =3D container_of(mirror, struct amdgpu_mn, mirror); - - if (!mmu_notifier_range_blockable(update)) - return -EAGAIN; - - down_read(&amn->lock); - up_read(&amn->lock); - return 0; -} - -/* Low bits of any reasonable mm pointer will be unused due to struct - * alignment. Use these bits to make a unique key from the mm pointer - * and notifier type. - */ -#define AMDGPU_MN_KEY(mm, type) ((unsigned long)(mm) + (type)) - -static struct hmm_mirror_ops amdgpu_hmm_mirror_ops[] =3D { - [AMDGPU_MN_TYPE_GFX] =3D { - .sync_cpu_device_pagetables =3D amdgpu_mn_sync_pagetables, - }, - [AMDGPU_MN_TYPE_HSA] =3D { - .sync_cpu_device_pagetables =3D amdgpu_mn_sync_pagetables, - }, -}; - -/** - * amdgpu_mn_get - create HMM mirror context - * - * @adev: amdgpu device pointer - * @type: type of MMU notifier context - * - * Creates a HMM mirror context for current->mm. - */ -struct amdgpu_mn *amdgpu_mn_get(struct amdgpu_device *adev, - enum amdgpu_mn_type type) -{ - struct mm_struct *mm =3D current->mm; - struct amdgpu_mn *amn; - unsigned long key =3D AMDGPU_MN_KEY(mm, type); - int r; - - mutex_lock(&adev->mn_lock); - if (down_write_killable(&mm->mmap_sem)) { - mutex_unlock(&adev->mn_lock); - return ERR_PTR(-EINTR); - } - - hash_for_each_possible(adev->mn_hash, amn, node, key) - if (AMDGPU_MN_KEY(amn->mirror.hmm->mmu_notifier.mm, - amn->type) =3D=3D key) - goto release_locks; - - amn =3D kzalloc(sizeof(*amn), GFP_KERNEL); - if (!amn) { - amn =3D ERR_PTR(-ENOMEM); - goto release_locks; - } - - amn->adev =3D adev; - init_rwsem(&amn->lock); - amn->type =3D type; - - amn->mirror.ops =3D &amdgpu_hmm_mirror_ops[type]; - r =3D hmm_mirror_register(&amn->mirror, mm); - if (r) - goto free_amn; - - hash_add(adev->mn_hash, &amn->node, AMDGPU_MN_KEY(mm, type)); - -release_locks: - up_write(&mm->mmap_sem); - mutex_unlock(&adev->mn_lock); - - return amn; - -free_amn: - up_write(&mm->mmap_sem); - mutex_unlock(&adev->mn_lock); - kfree(amn); - - return ERR_PTR(r); -} - /** * amdgpu_mn_register - register a BO for notifier updates * @@ -253,25 +153,3 @@ void amdgpu_mn_unregister(struct amdgpu_bo *bo) mmu_range_notifier_remove(&bo->notifier); bo->notifier.mm =3D NULL; } - -/* flags used by HMM internal, not related to CPU/GPU PTE flags */ -static const uint64_t hmm_range_flags[HMM_PFN_FLAG_MAX] =3D { - (1 << 0), /* HMM_PFN_VALID */ - (1 << 1), /* HMM_PFN_WRITE */ - 0 /* HMM_PFN_DEVICE_PRIVATE */ -}; - -static const uint64_t hmm_range_values[HMM_PFN_VALUE_MAX] =3D { - 0xfffffffffffffffeUL, /* HMM_PFN_ERROR */ - 0, /* HMM_PFN_NONE */ - 0xfffffffffffffffcUL /* HMM_PFN_SPECIAL */ -}; - -void amdgpu_hmm_init_range(struct hmm_range *range) -{ - if (range) { - range->flags =3D hmm_range_flags; - range->values =3D hmm_range_values; - range->pfn_shift =3D PAGE_SHIFT; - } -} diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.h b/drivers/gpu/drm/amd/a= mdgpu/amdgpu_mn.h index d73ab2947b22b2..a292238f75ebae 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.h +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.h @@ -30,59 +30,10 @@ #include #include =20 -enum amdgpu_mn_type { - AMDGPU_MN_TYPE_GFX, - AMDGPU_MN_TYPE_HSA, -}; - -/** - * struct amdgpu_mn - * - * @adev: amdgpu device pointer - * @type: type of MMU notifier - * @work: destruction work item - * @node: hash table node to find structure by adev and mn - * @lock: rw semaphore protecting the notifier nodes - * @mirror: HMM mirror function support - * - * Data for each amdgpu device and process address space. - */ -struct amdgpu_mn { - /* constant after initialisation */ - struct amdgpu_device *adev; - enum amdgpu_mn_type type; - - /* only used on destruction */ - struct work_struct work; - - /* protected by adev->mn_lock */ - struct hlist_node node; - - /* objects protected by lock */ - struct rw_semaphore lock; - -#ifdef CONFIG_HMM_MIRROR - /* HMM mirror */ - struct hmm_mirror mirror; -#endif -}; - #if defined(CONFIG_HMM_MIRROR) -void amdgpu_mn_lock(struct amdgpu_mn *mn); -void amdgpu_mn_unlock(struct amdgpu_mn *mn); -struct amdgpu_mn *amdgpu_mn_get(struct amdgpu_device *adev, - enum amdgpu_mn_type type); int amdgpu_mn_register(struct amdgpu_bo *bo, unsigned long addr); void amdgpu_mn_unregister(struct amdgpu_bo *bo); -void amdgpu_hmm_init_range(struct hmm_range *range); #else -static inline void amdgpu_mn_lock(struct amdgpu_mn *mn) {} -static inline void amdgpu_mn_unlock(struct amdgpu_mn *mn) {} -static inline struct amdgpu_mn *amdgpu_mn_get(struct amdgpu_device *adev, - enum amdgpu_mn_type type) -{ - return NULL; -} static inline int amdgpu_mn_register(struct amdgpu_bo *bo, unsigned long a= ddr) { DRM_WARN_ONCE("HMM_MIRROR kernel config option is not enabled, " diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c b/drivers/gpu/drm/amd/= amdgpu/amdgpu_ttm.c index c0e41f1f0c2365..5f4d8ab76f1da0 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c @@ -773,6 +773,20 @@ struct amdgpu_ttm_tt { #endif }; =20 +#ifdef CONFIG_DRM_AMDGPU_USERPTR +/* flags used by HMM internal, not related to CPU/GPU PTE flags */ +static const uint64_t hmm_range_flags[HMM_PFN_FLAG_MAX] =3D { + (1 << 0), /* HMM_PFN_VALID */ + (1 << 1), /* HMM_PFN_WRITE */ + 0 /* HMM_PFN_DEVICE_PRIVATE */ +}; + +static const uint64_t hmm_range_values[HMM_PFN_VALUE_MAX] =3D { + 0xfffffffffffffffeUL, /* HMM_PFN_ERROR */ + 0, /* HMM_PFN_NONE */ + 0xfffffffffffffffcUL /* HMM_PFN_SPECIAL */ +}; + /** * amdgpu_ttm_tt_get_user_pages - get device accessible pages that back us= er * memory and start HMM tracking CPU page table update @@ -780,29 +794,28 @@ struct amdgpu_ttm_tt { * Calling function must call amdgpu_ttm_tt_userptr_range_done() once and = only * once afterwards to stop HMM tracking */ -#if IS_ENABLED(CONFIG_DRM_AMDGPU_USERPTR) - -#define MAX_RETRY_HMM_RANGE_FAULT 16 - int amdgpu_ttm_tt_get_user_pages(struct amdgpu_bo *bo, struct page **pages= ) { - struct hmm_mirror *mirror =3D bo->mn ? &bo->mn->mirror : NULL; struct ttm_tt *ttm =3D bo->tbo.ttm; struct amdgpu_ttm_tt *gtt =3D (void *)ttm; - struct mm_struct *mm; unsigned long start =3D gtt->userptr; struct vm_area_struct *vma; struct hmm_range *range; + unsigned long timeout; + struct mm_struct *mm; unsigned long i; - uint64_t *pfns; int r =3D 0; =20 - if (unlikely(!mirror)) { - DRM_DEBUG_DRIVER("Failed to get hmm_mirror\n"); + mm =3D bo->notifier.mm; + if (unlikely(!mm)) { + DRM_DEBUG_DRIVER("BO is not registered?\n"); return -EFAULT; } =20 - mm =3D mirror->hmm->mmu_notifier.mm; + /* Another get_user_pages is running at the same time?? */ + if (WARN_ON(gtt->range)) + return -EFAULT; + if (!mmget_not_zero(mm)) /* Happens during process shutdown */ return -ESRCH; =20 @@ -811,31 +824,23 @@ int amdgpu_ttm_tt_get_user_pages(struct amdgpu_bo *bo= , struct page **pages) r =3D -ENOMEM; goto out; } + range->notifier =3D &bo->notifier; + range->flags =3D hmm_range_flags; + range->values =3D hmm_range_values; + range->pfn_shift =3D PAGE_SHIFT; + range->start =3D bo->notifier.interval_tree.start; + range->end =3D bo->notifier.interval_tree.last + 1; + range->default_flags =3D hmm_range_flags[HMM_PFN_VALID]; + if (!amdgpu_ttm_tt_is_readonly(ttm)) + range->default_flags |=3D range->flags[HMM_PFN_WRITE]; =20 - pfns =3D kvmalloc_array(ttm->num_pages, sizeof(*pfns), GFP_KERNEL); - if (unlikely(!pfns)) { + range->pfns =3D kvmalloc_array(ttm->num_pages, sizeof(*range->pfns), + GFP_KERNEL); + if (unlikely(!range->pfns)) { r =3D -ENOMEM; goto out_free_ranges; } =20 - amdgpu_hmm_init_range(range); - range->default_flags =3D range->flags[HMM_PFN_VALID]; - range->default_flags |=3D amdgpu_ttm_tt_is_readonly(ttm) ? - 0 : range->flags[HMM_PFN_WRITE]; - range->pfn_flags_mask =3D 0; - range->pfns =3D pfns; - range->start =3D start; - range->end =3D start + ttm->num_pages * PAGE_SIZE; - - hmm_range_register(range, mirror); - - /* - * Just wait for range to be valid, safe to ignore return value as we - * will use the return value of hmm_range_fault() below under the - * mmap_sem to ascertain the validity of the range. - */ - hmm_range_wait_until_valid(range, HMM_RANGE_DEFAULT_TIMEOUT); - down_read(&mm->mmap_sem); vma =3D find_vma(mm, start); if (unlikely(!vma || start < vma->vm_start)) { @@ -847,18 +852,31 @@ int amdgpu_ttm_tt_get_user_pages(struct amdgpu_bo *bo= , struct page **pages) r =3D -EPERM; goto out_unlock; } + up_read(&mm->mmap_sem); + timeout =3D jiffies + msecs_to_jiffies(HMM_RANGE_DEFAULT_TIMEOUT); =20 +retry: + range->notifier_seq =3D mmu_range_read_begin(&bo->notifier); + + down_read(&mm->mmap_sem); r =3D hmm_range_fault(range, 0); up_read(&mm->mmap_sem); - - if (unlikely(r < 0)) + if (unlikely(r <=3D 0)) { + /* + * FIXME: This timeout should encompass the retry from + * mmu_range_read_retry() as well. + */ + if ((r =3D=3D 0 || r =3D=3D -EBUSY) && !time_after(jiffies, timeout)) + goto retry; goto out_free_pfns; + } =20 for (i =3D 0; i < ttm->num_pages; i++) { - pages[i] =3D hmm_device_entry_to_page(range, pfns[i]); + /* FIXME: The pages cannot be touched outside the notifier_lock */ + pages[i] =3D hmm_device_entry_to_page(range, range->pfns[i]); if (unlikely(!pages[i])) { pr_err("Page fault failed for pfn[%lu] =3D 0x%llx\n", - i, pfns[i]); + i, range->pfns[i]); r =3D -ENOMEM; =20 goto out_free_pfns; @@ -873,8 +891,7 @@ int amdgpu_ttm_tt_get_user_pages(struct amdgpu_bo *bo, = struct page **pages) out_unlock: up_read(&mm->mmap_sem); out_free_pfns: - hmm_range_unregister(range); - kvfree(pfns); + kvfree(range->pfns); out_free_ranges: kfree(range); out: @@ -903,15 +920,18 @@ bool amdgpu_ttm_tt_get_user_pages_done(struct ttm_tt = *ttm) "No user pages to check\n"); =20 if (gtt->range) { - r =3D hmm_range_valid(gtt->range); - hmm_range_unregister(gtt->range); - + /* + * FIXME: Must always hold notifier_lock for this, and must + * not ignore the return code. + */ + r =3D mmu_range_read_retry(gtt->range->notifier, + gtt->range->notifier_seq); kvfree(gtt->range->pfns); kfree(gtt->range); gtt->range =3D NULL; } =20 - return r; + return !r; } #endif =20 @@ -992,10 +1012,18 @@ static void amdgpu_ttm_tt_unpin_userptr(struct ttm_t= t *ttm) sg_free_table(ttm->sg); =20 #if IS_ENABLED(CONFIG_DRM_AMDGPU_USERPTR) - if (gtt->range && - ttm->pages[0] =3D=3D hmm_device_entry_to_page(gtt->range, - gtt->range->pfns[0])) - WARN_ONCE(1, "Missing get_user_page_done\n"); + if (gtt->range) { + unsigned long i; + + for (i =3D 0; i < ttm->num_pages; i++) { + if (ttm->pages[i] !=3D + hmm_device_entry_to_page(gtt->range, + gtt->range->pfns[i])) + break; + } + + WARN((i =3D=3D ttm->num_pages), "Missing get_user_page_done\n"); + } #endif } =20 --=20 2.23.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jason Gunthorpe Subject: [PATCH v2a 14/15] drm/amdgpu: Use mmu_range_notifier instead of hmm_mirror Date: Fri, 1 Nov 2019 18:34:40 +0000 Message-ID: <20191101183435.GR22766@mellanox.com> References: <20191028201032.6352-1-jgg@ziepe.ca> <20191028201032.6352-15-jgg@ziepe.ca> <20191029192544.GU22766@mellanox.com> <30b2f569-bf7a-5166-c98d-4a4a13d1351f@amd.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <30b2f569-bf7a-5166-c98d-4a4a13d1351f@amd.com> Content-Language: en-US Content-ID: List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" To: "Yang, Philip" Cc: "nouveau@lists.freedesktop.org" , "dri-devel@lists.freedesktop.org" , "linux-mm@kvack.org" , "Zhou, David(ChunMing)" , Stefano Stabellini , Oleksandr Andrushchenko , "linux-rdma@vger.kernel.org" , "amd-gfx@lists.freedesktop.org" , Christoph Hellwig , Ben Skeggs , "xen-devel@lists.xenproject.org" , Ralph Campbell , John Hubbard , Jerome Glisse , Dennis Dalessandro , Boris Ostrovsky , Petr Cvek , Juergen Gross , Mike List-Id: nouveau.vger.kernel.org Q29udmVydCB0aGUgY29sbGlzaW9uLXJldHJ5IGxvY2sgYXJvdW5kIGhtbV9yYW5nZV9mYXVsdCB0 byB1c2UgdGhlIG9uZSBub3cKcHJvdmlkZWQgYnkgdGhlIG1tdV9yYW5nZSBub3RpZmllci4KCkFs dGhvdWdoIHRoaXMgZHJpdmVyIGRvZXMgbm90IHNlZW0gdG8gdXNlIHRoZSBjb2xsaXNpb24gcmV0 cnkgbG9jayB0aGF0CmhtbSBwcm92aWRlcyBjb3JyZWN0bHksIGl0IGNhbiBzdGlsbCBiZSBjb252 ZXJ0ZWQgb3ZlciB0byB1c2UgdGhlCm1tdV9yYW5nZV9ub3RpZmllciBhcGkgaW5zdGVhZCBvZiBo bW1fbWlycm9yIHdpdGhvdXQgdG9vIG11Y2ggdHJvdWJsZS4KClRoaXMgYWxzbyBkZWxldGVzIGFu b3RoZXIgcGxhY2Ugd2hlcmUgYSBkcml2ZXIgaXMgYXNzb2NpYXRpbmcgYWRkaXRpb25hbApkYXRh IChzdHJ1Y3QgYW1kZ3B1X21uKSB3aXRoIGEgbW11X3N0cnVjdC4KClNpZ25lZC1vZmYtYnk6IFBo aWxpcCBZYW5nIDxQaGlsaXAuWWFuZ0BhbWQuY29tPgpSZXZpZXdlZC1ieTogUGhpbGlwIFlhbmcg PFBoaWxpcC5ZYW5nQGFtZC5jb20+ClRlc3RlZC1ieTogUGhpbGlwIFlhbmcgPFBoaWxpcC5ZYW5n QGFtZC5jb20+ClNpZ25lZC1vZmYtYnk6IEphc29uIEd1bnRob3JwZSA8amdnQG1lbGxhbm94LmNv bT4KLS0tCiAuLi4vZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYyAgfCAg IDQgKwogZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2NzLmMgICAgICAgIHwgIDE0 ICstCiBkcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uYyAgICAgICAgfCAxNTAg KystLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4u aCAgICAgICAgfCAgNDkgLS0tLS0tCiBkcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVf dHRtLmMgICAgICAgfCAxMTYgKysrKysrKysrLS0tLS0KIDUgZmlsZXMgY2hhbmdlZCwgOTYgaW5z ZXJ0aW9ucygrKSwgMjM3IGRlbGV0aW9ucygtKQoKUGhpbGlwLCBoZXJlIGlzIHdoYXQgaXQgbG9v cyBsaWtlIGFmdGVyIGNvbWJpbmluZyB0aGUgdHdvIHBhdGNoZXMsIHRoYW5rcwoKZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYyBiL2Ry aXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYwppbmRleCA0Nzcw MDMwMmEwOGI3Zi4uMWJjZWRiOWI0NzdkY2UgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9h bWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1k L2FtZGdwdS9hbWRncHVfYW1ka2ZkX2dwdXZtLmMKQEAgLTE3MzgsNiArMTczOCwxMCBAQCBzdGF0 aWMgaW50IHVwZGF0ZV9pbnZhbGlkX3VzZXJfcGFnZXMoc3RydWN0IGFtZGtmZF9wcm9jZXNzX2lu Zm8gKnByb2Nlc3NfaW5mbywKIAkJCXJldHVybiByZXQ7CiAJCX0KIAorCQkvKgorCQkgKiBGSVhN RTogQ2Fubm90IGlnbm9yZSB0aGUgcmV0dXJuIGNvZGUsIG11c3QgaG9sZAorCQkgKiBub3RpZmll cl9sb2NrCisJCSAqLwogCQlhbWRncHVfdHRtX3R0X2dldF91c2VyX3BhZ2VzX2RvbmUoYm8tPnRi by50dG0pOwogCiAJCS8qIE1hcmsgdGhlIEJPIGFzIHZhbGlkIHVubGVzcyBpdCB3YXMgaW52YWxp ZGF0ZWQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9jcy5j IGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2NzLmMKaW5kZXggODI4MjNkOWE4 YmE4ODcuLjIyYzk4OWJjYTc1MTRjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2Ft ZGdwdS9hbWRncHVfY3MuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVf Y3MuYwpAQCAtNjAzLDggKzYwMyw2IEBAIHN0YXRpYyBpbnQgYW1kZ3B1X2NzX3BhcnNlcl9ib3Mo c3RydWN0IGFtZGdwdV9jc19wYXJzZXIgKnAsCiAJCWUtPnR2Lm51bV9zaGFyZWQgPSAyOwogCiAJ YW1kZ3B1X2JvX2xpc3RfZ2V0X2xpc3QocC0+Ym9fbGlzdCwgJnAtPnZhbGlkYXRlZCk7Ci0JaWYg KHAtPmJvX2xpc3QtPmZpcnN0X3VzZXJwdHIgIT0gcC0+Ym9fbGlzdC0+bnVtX2VudHJpZXMpCi0J CXAtPm1uID0gYW1kZ3B1X21uX2dldChwLT5hZGV2LCBBTURHUFVfTU5fVFlQRV9HRlgpOwogCiAJ SU5JVF9MSVNUX0hFQUQoJmR1cGxpY2F0ZXMpOwogCWFtZGdwdV92bV9nZXRfcGRfYm8oJmZwcml2 LT52bSwgJnAtPnZhbGlkYXRlZCwgJnAtPnZtX3BkKTsKQEAgLTEyODcsMTEgKzEyODUsMTEgQEAg c3RhdGljIGludCBhbWRncHVfY3Nfc3VibWl0KHN0cnVjdCBhbWRncHVfY3NfcGFyc2VyICpwLAog CWlmIChyKQogCQlnb3RvIGVycm9yX3VubG9jazsKIAotCS8qIE5vIG1lbW9yeSBhbGxvY2F0aW9u IGlzIGFsbG93ZWQgd2hpbGUgaG9sZGluZyB0aGUgbW4gbG9jay4KLQkgKiBwLT5tbiBpcyBob2xk IHVudGlsIGFtZGdwdV9jc19zdWJtaXQgaXMgZmluaXNoZWQgYW5kIGZlbmNlIGlzIGFkZGVkCi0J ICogdG8gQk9zLgorCS8qIE5vIG1lbW9yeSBhbGxvY2F0aW9uIGlzIGFsbG93ZWQgd2hpbGUgaG9s ZGluZyB0aGUgbm90aWZpZXIgbG9jay4KKwkgKiBUaGUgbG9jayBpcyBoZWxkIHVudGlsIGFtZGdw dV9jc19zdWJtaXQgaXMgZmluaXNoZWQgYW5kIGZlbmNlIGlzCisJICogYWRkZWQgdG8gQk9zLgog CSAqLwotCWFtZGdwdV9tbl9sb2NrKHAtPm1uKTsKKwltdXRleF9sb2NrKCZwLT5hZGV2LT5ub3Rp Zmllcl9sb2NrKTsKIAogCS8qIElmIHVzZXJwdHIgYXJlIGludmFsaWRhdGVkIGFmdGVyIGFtZGdw dV9jc19wYXJzZXJfYm9zKCksIHJldHVybgogCSAqIC1FQUdBSU4sIGRybUlvY3RsIGluIGxpYmRy bSB3aWxsIHJlc3RhcnQgdGhlIGFtZGdwdV9jc19pb2N0bC4KQEAgLTEzMzQsMTMgKzEzMzIsMTMg QEAgc3RhdGljIGludCBhbWRncHVfY3Nfc3VibWl0KHN0cnVjdCBhbWRncHVfY3NfcGFyc2VyICpw LAogCWFtZGdwdV92bV9tb3ZlX3RvX2xydV90YWlsKHAtPmFkZXYsICZmcHJpdi0+dm0pOwogCiAJ dHRtX2V1X2ZlbmNlX2J1ZmZlcl9vYmplY3RzKCZwLT50aWNrZXQsICZwLT52YWxpZGF0ZWQsIHAt PmZlbmNlKTsKLQlhbWRncHVfbW5fdW5sb2NrKHAtPm1uKTsKKwltdXRleF91bmxvY2soJnAtPmFk ZXYtPm5vdGlmaWVyX2xvY2spOwogCiAJcmV0dXJuIDA7CiAKIGVycm9yX2Fib3J0OgogCWRybV9z Y2hlZF9qb2JfY2xlYW51cCgmam9iLT5iYXNlKTsKLQlhbWRncHVfbW5fdW5sb2NrKHAtPm1uKTsK KwltdXRleF91bmxvY2soJnAtPmFkZXYtPm5vdGlmaWVyX2xvY2spOwogCiBlcnJvcl91bmxvY2s6 CiAJYW1kZ3B1X2pvYl9mcmVlKGpvYik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1k L2FtZGdwdS9hbWRncHVfbW4uYyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9t bi5jCmluZGV4IGFjNzQzMjBiNzFlNGU3Li5mN2JlMzQ5MDdlNTRmNSAxMDA2NDQKLS0tIGEvZHJp dmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmMKKysrIGIvZHJpdmVycy9ncHUvZHJt L2FtZC9hbWRncHUvYW1kZ3B1X21uLmMKQEAgLTUwLDI4ICs1MCw2IEBACiAjaW5jbHVkZSAiYW1k Z3B1LmgiCiAjaW5jbHVkZSAiYW1kZ3B1X2FtZGtmZC5oIgogCi0vKioKLSAqIGFtZGdwdV9tbl9s b2NrIC0gdGFrZSB0aGUgd3JpdGUgc2lkZSBsb2NrIGZvciB0aGlzIG5vdGlmaWVyCi0gKgotICog QG1uOiBvdXIgbm90aWZpZXIKLSAqLwotdm9pZCBhbWRncHVfbW5fbG9jayhzdHJ1Y3QgYW1kZ3B1 X21uICptbikKLXsKLQlpZiAobW4pCi0JCWRvd25fd3JpdGUoJm1uLT5sb2NrKTsKLX0KLQotLyoq Ci0gKiBhbWRncHVfbW5fdW5sb2NrIC0gZHJvcCB0aGUgd3JpdGUgc2lkZSBsb2NrIGZvciB0aGlz IG5vdGlmaWVyCi0gKgotICogQG1uOiBvdXIgbm90aWZpZXIKLSAqLwotdm9pZCBhbWRncHVfbW5f dW5sb2NrKHN0cnVjdCBhbWRncHVfbW4gKm1uKQotewotCWlmIChtbikKLQkJdXBfd3JpdGUoJm1u LT5sb2NrKTsKLX0KLQogLyoqCiAgKiBhbWRncHVfbW5faW52YWxpZGF0ZV9nZnggLSBjYWxsYmFj ayB0byBub3RpZnkgYWJvdXQgbW0gY2hhbmdlCiAgKgpAQCAtODIsMTYgKzYwLDIwIEBAIHZvaWQg YW1kZ3B1X21uX3VubG9jayhzdHJ1Y3QgYW1kZ3B1X21uICptbikKICAqIHBvdGVudGlhbGx5IGRp cnR5LgogICovCiBzdGF0aWMgYm9vbCBhbWRncHVfbW5faW52YWxpZGF0ZV9nZngoc3RydWN0IG1t dV9yYW5nZV9ub3RpZmllciAqbXJuLAotCQkJCSAgICAgY29uc3Qgc3RydWN0IG1tdV9ub3RpZmll cl9yYW5nZSAqcmFuZ2UpCisJCQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3Jhbmdl ICpyYW5nZSwKKwkJCQkgICAgIHVuc2lnbmVkIGxvbmcgY3VyX3NlcSkKIHsKIAlzdHJ1Y3QgYW1k Z3B1X2JvICpibyA9IGNvbnRhaW5lcl9vZihtcm4sIHN0cnVjdCBhbWRncHVfYm8sIG5vdGlmaWVy KTsKIAlzdHJ1Y3QgYW1kZ3B1X2RldmljZSAqYWRldiA9IGFtZGdwdV90dG1fYWRldihiby0+dGJv LmJkZXYpOwogCWxvbmcgcjsKIAotCWlmICghbW11X25vdGlmaWVyX3JhbmdlX2Jsb2NrYWJsZShy YW5nZSkpCisJaWYgKG1tdV9ub3RpZmllcl9yYW5nZV9ibG9ja2FibGUocmFuZ2UpKQorCQltdXRl eF9sb2NrKCZhZGV2LT5ub3RpZmllcl9sb2NrKTsKKwllbHNlIGlmICghbXV0ZXhfdHJ5bG9jaygm YWRldi0+bm90aWZpZXJfbG9jaykpCiAJCXJldHVybiBmYWxzZTsKIAotCW11dGV4X2xvY2soJmFk ZXYtPm5vdGlmaWVyX2xvY2spOworCW1tdV9yYW5nZV9zZXRfc2VxKG1ybiwgY3VyX3NlcSk7CisK IAlyID0gZG1hX3Jlc3Zfd2FpdF90aW1lb3V0X3JjdShiby0+dGJvLmJhc2UucmVzdiwgdHJ1ZSwg ZmFsc2UsCiAJCQkJICAgICAgTUFYX1NDSEVEVUxFX1RJTUVPVVQpOwogCW11dGV4X3VubG9jaygm YWRldi0+bm90aWZpZXJfbG9jayk7CkBAIC0xMTQsMTUgKzk2LDE5IEBAIHN0YXRpYyBjb25zdCBz dHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyX29wcyBhbWRncHVfbW5fZ2Z4X29wcyA9IHsKICAqIGV2 aWN0aW5nIGFsbCB1c2VyLW1vZGUgcXVldWVzIG9mIHRoZSBwcm9jZXNzLgogICovCiBzdGF0aWMg Ym9vbCBhbWRncHVfbW5faW52YWxpZGF0ZV9oc2Eoc3RydWN0IG1tdV9yYW5nZV9ub3RpZmllciAq bXJuLAotCQkJCSAgICAgY29uc3Qgc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAqcmFuZ2UpCisJ CQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICpyYW5nZSwKKwkJCQkgICAg IHVuc2lnbmVkIGxvbmcgY3VyX3NlcSkKIHsKIAlzdHJ1Y3QgYW1kZ3B1X2JvICpibyA9IGNvbnRh aW5lcl9vZihtcm4sIHN0cnVjdCBhbWRncHVfYm8sIG5vdGlmaWVyKTsKIAlzdHJ1Y3QgYW1kZ3B1 X2RldmljZSAqYWRldiA9IGFtZGdwdV90dG1fYWRldihiby0+dGJvLmJkZXYpOwogCi0JaWYgKCFt bXVfbm90aWZpZXJfcmFuZ2VfYmxvY2thYmxlKHJhbmdlKSkKKwlpZiAobW11X25vdGlmaWVyX3Jh bmdlX2Jsb2NrYWJsZShyYW5nZSkpCisJCW11dGV4X2xvY2soJmFkZXYtPm5vdGlmaWVyX2xvY2sp OworCWVsc2UgaWYgKCFtdXRleF90cnlsb2NrKCZhZGV2LT5ub3RpZmllcl9sb2NrKSkKIAkJcmV0 dXJuIGZhbHNlOwogCi0JbXV0ZXhfbG9jaygmYWRldi0+bm90aWZpZXJfbG9jayk7CisJbW11X3Jh bmdlX3NldF9zZXEobXJuLCBjdXJfc2VxKTsKKwogCWFtZGdwdV9hbWRrZmRfZXZpY3RfdXNlcnB0 cihiby0+a2ZkX2JvLCBiby0+bm90aWZpZXIubW0pOwogCW11dGV4X3VubG9jaygmYWRldi0+bm90 aWZpZXJfbG9jayk7CiAKQEAgLTEzMyw5MiArMTE5LDYgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBt bXVfcmFuZ2Vfbm90aWZpZXJfb3BzIGFtZGdwdV9tbl9oc2Ffb3BzID0gewogCS5pbnZhbGlkYXRl ID0gYW1kZ3B1X21uX2ludmFsaWRhdGVfaHNhLAogfTsKIAotc3RhdGljIGludCBhbWRncHVfbW5f c3luY19wYWdldGFibGVzKHN0cnVjdCBobW1fbWlycm9yICptaXJyb3IsCi0JCQkJICAgICBjb25z dCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICp1cGRhdGUpCi17Ci0Jc3RydWN0IGFtZGdwdV9t biAqYW1uID0gY29udGFpbmVyX29mKG1pcnJvciwgc3RydWN0IGFtZGdwdV9tbiwgbWlycm9yKTsK LQotCWlmICghbW11X25vdGlmaWVyX3JhbmdlX2Jsb2NrYWJsZSh1cGRhdGUpKQotCQlyZXR1cm4g LUVBR0FJTjsKLQotCWRvd25fcmVhZCgmYW1uLT5sb2NrKTsKLQl1cF9yZWFkKCZhbW4tPmxvY2sp OwotCXJldHVybiAwOwotfQotCi0vKiBMb3cgYml0cyBvZiBhbnkgcmVhc29uYWJsZSBtbSBwb2lu dGVyIHdpbGwgYmUgdW51c2VkIGR1ZSB0byBzdHJ1Y3QKLSAqIGFsaWdubWVudC4gVXNlIHRoZXNl IGJpdHMgdG8gbWFrZSBhIHVuaXF1ZSBrZXkgZnJvbSB0aGUgbW0gcG9pbnRlcgotICogYW5kIG5v dGlmaWVyIHR5cGUuCi0gKi8KLSNkZWZpbmUgQU1ER1BVX01OX0tFWShtbSwgdHlwZSkgKCh1bnNp Z25lZCBsb25nKShtbSkgKyAodHlwZSkpCi0KLXN0YXRpYyBzdHJ1Y3QgaG1tX21pcnJvcl9vcHMg YW1kZ3B1X2htbV9taXJyb3Jfb3BzW10gPSB7Ci0JW0FNREdQVV9NTl9UWVBFX0dGWF0gPSB7Ci0J CS5zeW5jX2NwdV9kZXZpY2VfcGFnZXRhYmxlcyA9IGFtZGdwdV9tbl9zeW5jX3BhZ2V0YWJsZXMs Ci0JfSwKLQlbQU1ER1BVX01OX1RZUEVfSFNBXSA9IHsKLQkJLnN5bmNfY3B1X2RldmljZV9wYWdl dGFibGVzID0gYW1kZ3B1X21uX3N5bmNfcGFnZXRhYmxlcywKLQl9LAotfTsKLQotLyoqCi0gKiBh bWRncHVfbW5fZ2V0IC0gY3JlYXRlIEhNTSBtaXJyb3IgY29udGV4dAotICoKLSAqIEBhZGV2OiBh bWRncHUgZGV2aWNlIHBvaW50ZXIKLSAqIEB0eXBlOiB0eXBlIG9mIE1NVSBub3RpZmllciBjb250 ZXh0Ci0gKgotICogQ3JlYXRlcyBhIEhNTSBtaXJyb3IgY29udGV4dCBmb3IgY3VycmVudC0+bW0u Ci0gKi8KLXN0cnVjdCBhbWRncHVfbW4gKmFtZGdwdV9tbl9nZXQoc3RydWN0IGFtZGdwdV9kZXZp Y2UgKmFkZXYsCi0JCQkJZW51bSBhbWRncHVfbW5fdHlwZSB0eXBlKQotewotCXN0cnVjdCBtbV9z dHJ1Y3QgKm1tID0gY3VycmVudC0+bW07Ci0Jc3RydWN0IGFtZGdwdV9tbiAqYW1uOwotCXVuc2ln bmVkIGxvbmcga2V5ID0gQU1ER1BVX01OX0tFWShtbSwgdHlwZSk7Ci0JaW50IHI7Ci0KLQltdXRl eF9sb2NrKCZhZGV2LT5tbl9sb2NrKTsKLQlpZiAoZG93bl93cml0ZV9raWxsYWJsZSgmbW0tPm1t YXBfc2VtKSkgewotCQltdXRleF91bmxvY2soJmFkZXYtPm1uX2xvY2spOwotCQlyZXR1cm4gRVJS X1BUUigtRUlOVFIpOwotCX0KLQotCWhhc2hfZm9yX2VhY2hfcG9zc2libGUoYWRldi0+bW5faGFz aCwgYW1uLCBub2RlLCBrZXkpCi0JCWlmIChBTURHUFVfTU5fS0VZKGFtbi0+bWlycm9yLmhtbS0+ bW11X25vdGlmaWVyLm1tLAotCQkJCSAgYW1uLT50eXBlKSA9PSBrZXkpCi0JCQlnb3RvIHJlbGVh c2VfbG9ja3M7Ci0KLQlhbW4gPSBremFsbG9jKHNpemVvZigqYW1uKSwgR0ZQX0tFUk5FTCk7Ci0J aWYgKCFhbW4pIHsKLQkJYW1uID0gRVJSX1BUUigtRU5PTUVNKTsKLQkJZ290byByZWxlYXNlX2xv Y2tzOwotCX0KLQotCWFtbi0+YWRldiA9IGFkZXY7Ci0JaW5pdF9yd3NlbSgmYW1uLT5sb2NrKTsK LQlhbW4tPnR5cGUgPSB0eXBlOwotCi0JYW1uLT5taXJyb3Iub3BzID0gJmFtZGdwdV9obW1fbWly cm9yX29wc1t0eXBlXTsKLQlyID0gaG1tX21pcnJvcl9yZWdpc3RlcigmYW1uLT5taXJyb3IsIG1t KTsKLQlpZiAocikKLQkJZ290byBmcmVlX2FtbjsKLQotCWhhc2hfYWRkKGFkZXYtPm1uX2hhc2gs ICZhbW4tPm5vZGUsIEFNREdQVV9NTl9LRVkobW0sIHR5cGUpKTsKLQotcmVsZWFzZV9sb2NrczoK LQl1cF93cml0ZSgmbW0tPm1tYXBfc2VtKTsKLQltdXRleF91bmxvY2soJmFkZXYtPm1uX2xvY2sp OwotCi0JcmV0dXJuIGFtbjsKLQotZnJlZV9hbW46Ci0JdXBfd3JpdGUoJm1tLT5tbWFwX3NlbSk7 Ci0JbXV0ZXhfdW5sb2NrKCZhZGV2LT5tbl9sb2NrKTsKLQlrZnJlZShhbW4pOwotCi0JcmV0dXJu IEVSUl9QVFIocik7Ci19Ci0KIC8qKgogICogYW1kZ3B1X21uX3JlZ2lzdGVyIC0gcmVnaXN0ZXIg YSBCTyBmb3Igbm90aWZpZXIgdXBkYXRlcwogICoKQEAgLTI1MywyNSArMTUzLDMgQEAgdm9pZCBh bWRncHVfbW5fdW5yZWdpc3RlcihzdHJ1Y3QgYW1kZ3B1X2JvICpibykKIAltbXVfcmFuZ2Vfbm90 aWZpZXJfcmVtb3ZlKCZiby0+bm90aWZpZXIpOwogCWJvLT5ub3RpZmllci5tbSA9IE5VTEw7CiB9 Ci0KLS8qIGZsYWdzIHVzZWQgYnkgSE1NIGludGVybmFsLCBub3QgcmVsYXRlZCB0byBDUFUvR1BV IFBURSBmbGFncyAqLwotc3RhdGljIGNvbnN0IHVpbnQ2NF90IGhtbV9yYW5nZV9mbGFnc1tITU1f UEZOX0ZMQUdfTUFYXSA9IHsKLQkJKDEgPDwgMCksIC8qIEhNTV9QRk5fVkFMSUQgKi8KLQkJKDEg PDwgMSksIC8qIEhNTV9QRk5fV1JJVEUgKi8KLQkJMCAvKiBITU1fUEZOX0RFVklDRV9QUklWQVRF ICovCi19OwotCi1zdGF0aWMgY29uc3QgdWludDY0X3QgaG1tX3JhbmdlX3ZhbHVlc1tITU1fUEZO X1ZBTFVFX01BWF0gPSB7Ci0JCTB4ZmZmZmZmZmZmZmZmZmZmZVVMLCAvKiBITU1fUEZOX0VSUk9S ICovCi0JCTAsIC8qIEhNTV9QRk5fTk9ORSAqLwotCQkweGZmZmZmZmZmZmZmZmZmZmNVTCAvKiBI TU1fUEZOX1NQRUNJQUwgKi8KLX07Ci0KLXZvaWQgYW1kZ3B1X2htbV9pbml0X3JhbmdlKHN0cnVj dCBobW1fcmFuZ2UgKnJhbmdlKQotewotCWlmIChyYW5nZSkgewotCQlyYW5nZS0+ZmxhZ3MgPSBo bW1fcmFuZ2VfZmxhZ3M7Ci0JCXJhbmdlLT52YWx1ZXMgPSBobW1fcmFuZ2VfdmFsdWVzOwotCQly YW5nZS0+cGZuX3NoaWZ0ID0gUEFHRV9TSElGVDsKLQl9Ci19CmRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uaCBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1k Z3B1L2FtZGdwdV9tbi5oCmluZGV4IGQ3M2FiMjk0N2IyMmIyLi5hMjkyMjM4Zjc1ZWJhZSAxMDA2 NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmgKKysrIGIvZHJp dmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmgKQEAgLTMwLDU5ICszMCwxMCBAQAog I2luY2x1ZGUgPGxpbnV4L3dvcmtxdWV1ZS5oPgogI2luY2x1ZGUgPGxpbnV4L2ludGVydmFsX3Ry ZWUuaD4KIAotZW51bSBhbWRncHVfbW5fdHlwZSB7Ci0JQU1ER1BVX01OX1RZUEVfR0ZYLAotCUFN REdQVV9NTl9UWVBFX0hTQSwKLX07Ci0KLS8qKgotICogc3RydWN0IGFtZGdwdV9tbgotICoKLSAq IEBhZGV2OiBhbWRncHUgZGV2aWNlIHBvaW50ZXIKLSAqIEB0eXBlOiB0eXBlIG9mIE1NVSBub3Rp ZmllcgotICogQHdvcms6IGRlc3RydWN0aW9uIHdvcmsgaXRlbQotICogQG5vZGU6IGhhc2ggdGFi bGUgbm9kZSB0byBmaW5kIHN0cnVjdHVyZSBieSBhZGV2IGFuZCBtbgotICogQGxvY2s6IHJ3IHNl bWFwaG9yZSBwcm90ZWN0aW5nIHRoZSBub3RpZmllciBub2RlcwotICogQG1pcnJvcjogSE1NIG1p cnJvciBmdW5jdGlvbiBzdXBwb3J0Ci0gKgotICogRGF0YSBmb3IgZWFjaCBhbWRncHUgZGV2aWNl IGFuZCBwcm9jZXNzIGFkZHJlc3Mgc3BhY2UuCi0gKi8KLXN0cnVjdCBhbWRncHVfbW4gewotCS8q IGNvbnN0YW50IGFmdGVyIGluaXRpYWxpc2F0aW9uICovCi0Jc3RydWN0IGFtZGdwdV9kZXZpY2UJ KmFkZXY7Ci0JZW51bSBhbWRncHVfbW5fdHlwZQl0eXBlOwotCi0JLyogb25seSB1c2VkIG9uIGRl c3RydWN0aW9uICovCi0Jc3RydWN0IHdvcmtfc3RydWN0CXdvcms7Ci0KLQkvKiBwcm90ZWN0ZWQg YnkgYWRldi0+bW5fbG9jayAqLwotCXN0cnVjdCBobGlzdF9ub2RlCW5vZGU7Ci0KLQkvKiBvYmpl Y3RzIHByb3RlY3RlZCBieSBsb2NrICovCi0Jc3RydWN0IHJ3X3NlbWFwaG9yZQlsb2NrOwotCi0j aWZkZWYgQ09ORklHX0hNTV9NSVJST1IKLQkvKiBITU0gbWlycm9yICovCi0Jc3RydWN0IGhtbV9t aXJyb3IJbWlycm9yOwotI2VuZGlmCi19OwotCiAjaWYgZGVmaW5lZChDT05GSUdfSE1NX01JUlJP UikKLXZvaWQgYW1kZ3B1X21uX2xvY2soc3RydWN0IGFtZGdwdV9tbiAqbW4pOwotdm9pZCBhbWRn cHVfbW5fdW5sb2NrKHN0cnVjdCBhbWRncHVfbW4gKm1uKTsKLXN0cnVjdCBhbWRncHVfbW4gKmFt ZGdwdV9tbl9nZXQoc3RydWN0IGFtZGdwdV9kZXZpY2UgKmFkZXYsCi0JCQkJZW51bSBhbWRncHVf bW5fdHlwZSB0eXBlKTsKIGludCBhbWRncHVfbW5fcmVnaXN0ZXIoc3RydWN0IGFtZGdwdV9ibyAq Ym8sIHVuc2lnbmVkIGxvbmcgYWRkcik7CiB2b2lkIGFtZGdwdV9tbl91bnJlZ2lzdGVyKHN0cnVj dCBhbWRncHVfYm8gKmJvKTsKLXZvaWQgYW1kZ3B1X2htbV9pbml0X3JhbmdlKHN0cnVjdCBobW1f cmFuZ2UgKnJhbmdlKTsKICNlbHNlCi1zdGF0aWMgaW5saW5lIHZvaWQgYW1kZ3B1X21uX2xvY2so c3RydWN0IGFtZGdwdV9tbiAqbW4pIHt9Ci1zdGF0aWMgaW5saW5lIHZvaWQgYW1kZ3B1X21uX3Vu bG9jayhzdHJ1Y3QgYW1kZ3B1X21uICptbikge30KLXN0YXRpYyBpbmxpbmUgc3RydWN0IGFtZGdw dV9tbiAqYW1kZ3B1X21uX2dldChzdHJ1Y3QgYW1kZ3B1X2RldmljZSAqYWRldiwKLQkJCQkJICAg ICAgZW51bSBhbWRncHVfbW5fdHlwZSB0eXBlKQotewotCXJldHVybiBOVUxMOwotfQogc3RhdGlj IGlubGluZSBpbnQgYW1kZ3B1X21uX3JlZ2lzdGVyKHN0cnVjdCBhbWRncHVfYm8gKmJvLCB1bnNp Z25lZCBsb25nIGFkZHIpCiB7CiAJRFJNX1dBUk5fT05DRSgiSE1NX01JUlJPUiBrZXJuZWwgY29u ZmlnIG9wdGlvbiBpcyBub3QgZW5hYmxlZCwgIgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L2FtZC9hbWRncHUvYW1kZ3B1X3R0bS5jIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1k Z3B1X3R0bS5jCmluZGV4IGMwZTQxZjFmMGMyMzY1Li41ZjRkOGFiNzZmMWRhMCAxMDA2NDQKLS0t IGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X3R0bS5jCisrKyBiL2RyaXZlcnMv Z3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV90dG0uYwpAQCAtNzczLDYgKzc3MywyMCBAQCBzdHJ1 Y3QgYW1kZ3B1X3R0bV90dCB7CiAjZW5kaWYKIH07CiAKKyNpZmRlZiBDT05GSUdfRFJNX0FNREdQ VV9VU0VSUFRSCisvKiBmbGFncyB1c2VkIGJ5IEhNTSBpbnRlcm5hbCwgbm90IHJlbGF0ZWQgdG8g Q1BVL0dQVSBQVEUgZmxhZ3MgKi8KK3N0YXRpYyBjb25zdCB1aW50NjRfdCBobW1fcmFuZ2VfZmxh Z3NbSE1NX1BGTl9GTEFHX01BWF0gPSB7CisJKDEgPDwgMCksIC8qIEhNTV9QRk5fVkFMSUQgKi8K KwkoMSA8PCAxKSwgLyogSE1NX1BGTl9XUklURSAqLworCTAgLyogSE1NX1BGTl9ERVZJQ0VfUFJJ VkFURSAqLworfTsKKworc3RhdGljIGNvbnN0IHVpbnQ2NF90IGhtbV9yYW5nZV92YWx1ZXNbSE1N X1BGTl9WQUxVRV9NQVhdID0geworCTB4ZmZmZmZmZmZmZmZmZmZmZVVMLCAvKiBITU1fUEZOX0VS Uk9SICovCisJMCwgLyogSE1NX1BGTl9OT05FICovCisJMHhmZmZmZmZmZmZmZmZmZmZjVUwgLyog SE1NX1BGTl9TUEVDSUFMICovCit9OworCiAvKioKICAqIGFtZGdwdV90dG1fdHRfZ2V0X3VzZXJf cGFnZXMgLSBnZXQgZGV2aWNlIGFjY2Vzc2libGUgcGFnZXMgdGhhdCBiYWNrIHVzZXIKICAqIG1l bW9yeSBhbmQgc3RhcnQgSE1NIHRyYWNraW5nIENQVSBwYWdlIHRhYmxlIHVwZGF0ZQpAQCAtNzgw LDI5ICs3OTQsMjggQEAgc3RydWN0IGFtZGdwdV90dG1fdHQgewogICogQ2FsbGluZyBmdW5jdGlv biBtdXN0IGNhbGwgYW1kZ3B1X3R0bV90dF91c2VycHRyX3JhbmdlX2RvbmUoKSBvbmNlIGFuZCBv bmx5CiAgKiBvbmNlIGFmdGVyd2FyZHMgdG8gc3RvcCBITU0gdHJhY2tpbmcKICAqLwotI2lmIElT X0VOQUJMRUQoQ09ORklHX0RSTV9BTURHUFVfVVNFUlBUUikKLQotI2RlZmluZSBNQVhfUkVUUllf SE1NX1JBTkdFX0ZBVUxUCTE2Ci0KIGludCBhbWRncHVfdHRtX3R0X2dldF91c2VyX3BhZ2VzKHN0 cnVjdCBhbWRncHVfYm8gKmJvLCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKQogewotCXN0cnVjdCBobW1f bWlycm9yICptaXJyb3IgPSBiby0+bW4gPyAmYm8tPm1uLT5taXJyb3IgOiBOVUxMOwogCXN0cnVj dCB0dG1fdHQgKnR0bSA9IGJvLT50Ym8udHRtOwogCXN0cnVjdCBhbWRncHVfdHRtX3R0ICpndHQg PSAodm9pZCAqKXR0bTsKLQlzdHJ1Y3QgbW1fc3RydWN0ICptbTsKIAl1bnNpZ25lZCBsb25nIHN0 YXJ0ID0gZ3R0LT51c2VycHRyOwogCXN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hOwogCXN0cnVj dCBobW1fcmFuZ2UgKnJhbmdlOworCXVuc2lnbmVkIGxvbmcgdGltZW91dDsKKwlzdHJ1Y3QgbW1f c3RydWN0ICptbTsKIAl1bnNpZ25lZCBsb25nIGk7Ci0JdWludDY0X3QgKnBmbnM7CiAJaW50IHIg PSAwOwogCi0JaWYgKHVubGlrZWx5KCFtaXJyb3IpKSB7Ci0JCURSTV9ERUJVR19EUklWRVIoIkZh aWxlZCB0byBnZXQgaG1tX21pcnJvclxuIik7CisJbW0gPSBiby0+bm90aWZpZXIubW07CisJaWYg KHVubGlrZWx5KCFtbSkpIHsKKwkJRFJNX0RFQlVHX0RSSVZFUigiQk8gaXMgbm90IHJlZ2lzdGVy ZWQ/XG4iKTsKIAkJcmV0dXJuIC1FRkFVTFQ7CiAJfQogCi0JbW0gPSBtaXJyb3ItPmhtbS0+bW11 X25vdGlmaWVyLm1tOworCS8qIEFub3RoZXIgZ2V0X3VzZXJfcGFnZXMgaXMgcnVubmluZyBhdCB0 aGUgc2FtZSB0aW1lPz8gKi8KKwlpZiAoV0FSTl9PTihndHQtPnJhbmdlKSkKKwkJcmV0dXJuIC1F RkFVTFQ7CisKIAlpZiAoIW1tZ2V0X25vdF96ZXJvKG1tKSkgLyogSGFwcGVucyBkdXJpbmcgcHJv Y2VzcyBzaHV0ZG93biAqLwogCQlyZXR1cm4gLUVTUkNIOwogCkBAIC04MTEsMzEgKzgyNCwyMyBA QCBpbnQgYW1kZ3B1X3R0bV90dF9nZXRfdXNlcl9wYWdlcyhzdHJ1Y3QgYW1kZ3B1X2JvICpibywg c3RydWN0IHBhZ2UgKipwYWdlcykKIAkJciA9IC1FTk9NRU07CiAJCWdvdG8gb3V0OwogCX0KKwly YW5nZS0+bm90aWZpZXIgPSAmYm8tPm5vdGlmaWVyOworCXJhbmdlLT5mbGFncyA9IGhtbV9yYW5n ZV9mbGFnczsKKwlyYW5nZS0+dmFsdWVzID0gaG1tX3JhbmdlX3ZhbHVlczsKKwlyYW5nZS0+cGZu X3NoaWZ0ID0gUEFHRV9TSElGVDsKKwlyYW5nZS0+c3RhcnQgPSBiby0+bm90aWZpZXIuaW50ZXJ2 YWxfdHJlZS5zdGFydDsKKwlyYW5nZS0+ZW5kID0gYm8tPm5vdGlmaWVyLmludGVydmFsX3RyZWUu bGFzdCArIDE7CisJcmFuZ2UtPmRlZmF1bHRfZmxhZ3MgPSBobW1fcmFuZ2VfZmxhZ3NbSE1NX1BG Tl9WQUxJRF07CisJaWYgKCFhbWRncHVfdHRtX3R0X2lzX3JlYWRvbmx5KHR0bSkpCisJCXJhbmdl LT5kZWZhdWx0X2ZsYWdzIHw9IHJhbmdlLT5mbGFnc1tITU1fUEZOX1dSSVRFXTsKIAotCXBmbnMg PSBrdm1hbGxvY19hcnJheSh0dG0tPm51bV9wYWdlcywgc2l6ZW9mKCpwZm5zKSwgR0ZQX0tFUk5F TCk7Ci0JaWYgKHVubGlrZWx5KCFwZm5zKSkgeworCXJhbmdlLT5wZm5zID0ga3ZtYWxsb2NfYXJy YXkodHRtLT5udW1fcGFnZXMsIHNpemVvZigqcmFuZ2UtPnBmbnMpLAorCQkJCSAgICAgR0ZQX0tF Uk5FTCk7CisJaWYgKHVubGlrZWx5KCFyYW5nZS0+cGZucykpIHsKIAkJciA9IC1FTk9NRU07CiAJ CWdvdG8gb3V0X2ZyZWVfcmFuZ2VzOwogCX0KIAotCWFtZGdwdV9obW1faW5pdF9yYW5nZShyYW5n ZSk7Ci0JcmFuZ2UtPmRlZmF1bHRfZmxhZ3MgPSByYW5nZS0+ZmxhZ3NbSE1NX1BGTl9WQUxJRF07 Ci0JcmFuZ2UtPmRlZmF1bHRfZmxhZ3MgfD0gYW1kZ3B1X3R0bV90dF9pc19yZWFkb25seSh0dG0p ID8KLQkJCQkwIDogcmFuZ2UtPmZsYWdzW0hNTV9QRk5fV1JJVEVdOwotCXJhbmdlLT5wZm5fZmxh Z3NfbWFzayA9IDA7Ci0JcmFuZ2UtPnBmbnMgPSBwZm5zOwotCXJhbmdlLT5zdGFydCA9IHN0YXJ0 OwotCXJhbmdlLT5lbmQgPSBzdGFydCArIHR0bS0+bnVtX3BhZ2VzICogUEFHRV9TSVpFOwotCi0J aG1tX3JhbmdlX3JlZ2lzdGVyKHJhbmdlLCBtaXJyb3IpOwotCi0JLyoKLQkgKiBKdXN0IHdhaXQg Zm9yIHJhbmdlIHRvIGJlIHZhbGlkLCBzYWZlIHRvIGlnbm9yZSByZXR1cm4gdmFsdWUgYXMgd2UK LQkgKiB3aWxsIHVzZSB0aGUgcmV0dXJuIHZhbHVlIG9mIGhtbV9yYW5nZV9mYXVsdCgpIGJlbG93 IHVuZGVyIHRoZQotCSAqIG1tYXBfc2VtIHRvIGFzY2VydGFpbiB0aGUgdmFsaWRpdHkgb2YgdGhl IHJhbmdlLgotCSAqLwotCWhtbV9yYW5nZV93YWl0X3VudGlsX3ZhbGlkKHJhbmdlLCBITU1fUkFO R0VfREVGQVVMVF9USU1FT1VUKTsKLQogCWRvd25fcmVhZCgmbW0tPm1tYXBfc2VtKTsKIAl2bWEg PSBmaW5kX3ZtYShtbSwgc3RhcnQpOwogCWlmICh1bmxpa2VseSghdm1hIHx8IHN0YXJ0IDwgdm1h LT52bV9zdGFydCkpIHsKQEAgLTg0NywxOCArODUyLDMxIEBAIGludCBhbWRncHVfdHRtX3R0X2dl dF91c2VyX3BhZ2VzKHN0cnVjdCBhbWRncHVfYm8gKmJvLCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKQog CQlyID0gLUVQRVJNOwogCQlnb3RvIG91dF91bmxvY2s7CiAJfQorCXVwX3JlYWQoJm1tLT5tbWFw X3NlbSk7CisJdGltZW91dCA9IGppZmZpZXMgKyBtc2Vjc190b19qaWZmaWVzKEhNTV9SQU5HRV9E RUZBVUxUX1RJTUVPVVQpOwogCityZXRyeToKKwlyYW5nZS0+bm90aWZpZXJfc2VxID0gbW11X3Jh bmdlX3JlYWRfYmVnaW4oJmJvLT5ub3RpZmllcik7CisKKwlkb3duX3JlYWQoJm1tLT5tbWFwX3Nl bSk7CiAJciA9IGhtbV9yYW5nZV9mYXVsdChyYW5nZSwgMCk7CiAJdXBfcmVhZCgmbW0tPm1tYXBf c2VtKTsKLQotCWlmICh1bmxpa2VseShyIDwgMCkpCisJaWYgKHVubGlrZWx5KHIgPD0gMCkpIHsK KwkJLyoKKwkJICogRklYTUU6IFRoaXMgdGltZW91dCBzaG91bGQgZW5jb21wYXNzIHRoZSByZXRy eSBmcm9tCisJCSAqIG1tdV9yYW5nZV9yZWFkX3JldHJ5KCkgYXMgd2VsbC4KKwkJICovCisJCWlm ICgociA9PSAwIHx8IHIgPT0gLUVCVVNZKSAmJiAhdGltZV9hZnRlcihqaWZmaWVzLCB0aW1lb3V0 KSkKKwkJCWdvdG8gcmV0cnk7CiAJCWdvdG8gb3V0X2ZyZWVfcGZuczsKKwl9CiAKIAlmb3IgKGkg PSAwOyBpIDwgdHRtLT5udW1fcGFnZXM7IGkrKykgewotCQlwYWdlc1tpXSA9IGhtbV9kZXZpY2Vf ZW50cnlfdG9fcGFnZShyYW5nZSwgcGZuc1tpXSk7CisJCS8qIEZJWE1FOiBUaGUgcGFnZXMgY2Fu bm90IGJlIHRvdWNoZWQgb3V0c2lkZSB0aGUgbm90aWZpZXJfbG9jayAqLworCQlwYWdlc1tpXSA9 IGhtbV9kZXZpY2VfZW50cnlfdG9fcGFnZShyYW5nZSwgcmFuZ2UtPnBmbnNbaV0pOwogCQlpZiAo dW5saWtlbHkoIXBhZ2VzW2ldKSkgewogCQkJcHJfZXJyKCJQYWdlIGZhdWx0IGZhaWxlZCBmb3Ig cGZuWyVsdV0gPSAweCVsbHhcbiIsCi0JCQkgICAgICAgaSwgcGZuc1tpXSk7CisJCQkgICAgICAg aSwgcmFuZ2UtPnBmbnNbaV0pOwogCQkJciA9IC1FTk9NRU07CiAKIAkJCWdvdG8gb3V0X2ZyZWVf cGZuczsKQEAgLTg3Myw4ICs4OTEsNyBAQCBpbnQgYW1kZ3B1X3R0bV90dF9nZXRfdXNlcl9wYWdl cyhzdHJ1Y3QgYW1kZ3B1X2JvICpibywgc3RydWN0IHBhZ2UgKipwYWdlcykKIG91dF91bmxvY2s6 CiAJdXBfcmVhZCgmbW0tPm1tYXBfc2VtKTsKIG91dF9mcmVlX3BmbnM6Ci0JaG1tX3JhbmdlX3Vu cmVnaXN0ZXIocmFuZ2UpOwotCWt2ZnJlZShwZm5zKTsKKwlrdmZyZWUocmFuZ2UtPnBmbnMpOwog b3V0X2ZyZWVfcmFuZ2VzOgogCWtmcmVlKHJhbmdlKTsKIG91dDoKQEAgLTkwMywxNSArOTIwLDE4 IEBAIGJvb2wgYW1kZ3B1X3R0bV90dF9nZXRfdXNlcl9wYWdlc19kb25lKHN0cnVjdCB0dG1fdHQg KnR0bSkKIAkJIk5vIHVzZXIgcGFnZXMgdG8gY2hlY2tcbiIpOwogCiAJaWYgKGd0dC0+cmFuZ2Up IHsKLQkJciA9IGhtbV9yYW5nZV92YWxpZChndHQtPnJhbmdlKTsKLQkJaG1tX3JhbmdlX3VucmVn aXN0ZXIoZ3R0LT5yYW5nZSk7Ci0KKwkJLyoKKwkJICogRklYTUU6IE11c3QgYWx3YXlzIGhvbGQg bm90aWZpZXJfbG9jayBmb3IgdGhpcywgYW5kIG11c3QKKwkJICogbm90IGlnbm9yZSB0aGUgcmV0 dXJuIGNvZGUuCisJCSAqLworCQlyID0gbW11X3JhbmdlX3JlYWRfcmV0cnkoZ3R0LT5yYW5nZS0+ bm90aWZpZXIsCisJCQkJCSBndHQtPnJhbmdlLT5ub3RpZmllcl9zZXEpOwogCQlrdmZyZWUoZ3R0 LT5yYW5nZS0+cGZucyk7CiAJCWtmcmVlKGd0dC0+cmFuZ2UpOwogCQlndHQtPnJhbmdlID0gTlVM TDsKIAl9CiAKLQlyZXR1cm4gcjsKKwlyZXR1cm4gIXI7CiB9CiAjZW5kaWYKIApAQCAtOTkyLDEw ICsxMDEyLDE4IEBAIHN0YXRpYyB2b2lkIGFtZGdwdV90dG1fdHRfdW5waW5fdXNlcnB0cihzdHJ1 Y3QgdHRtX3R0ICp0dG0pCiAJc2dfZnJlZV90YWJsZSh0dG0tPnNnKTsKIAogI2lmIElTX0VOQUJM RUQoQ09ORklHX0RSTV9BTURHUFVfVVNFUlBUUikKLQlpZiAoZ3R0LT5yYW5nZSAmJgotCSAgICB0 dG0tPnBhZ2VzWzBdID09IGhtbV9kZXZpY2VfZW50cnlfdG9fcGFnZShndHQtPnJhbmdlLAotCQkJ CQkJICAgICAgZ3R0LT5yYW5nZS0+cGZuc1swXSkpCi0JCVdBUk5fT05DRSgxLCAiTWlzc2luZyBn ZXRfdXNlcl9wYWdlX2RvbmVcbiIpOworCWlmIChndHQtPnJhbmdlKSB7CisJCXVuc2lnbmVkIGxv bmcgaTsKKworCQlmb3IgKGkgPSAwOyBpIDwgdHRtLT5udW1fcGFnZXM7IGkrKykgeworCQkJaWYg KHR0bS0+cGFnZXNbaV0gIT0KKwkJCQlobW1fZGV2aWNlX2VudHJ5X3RvX3BhZ2UoZ3R0LT5yYW5n ZSwKKwkJCQkJICAgICAgZ3R0LT5yYW5nZS0+cGZuc1tpXSkpCisJCQkJYnJlYWs7CisJCX0KKwor CQlXQVJOKChpID09IHR0bS0+bnVtX3BhZ2VzKSwgIk1pc3NpbmcgZ2V0X3VzZXJfcGFnZV9kb25l XG4iKTsKKwl9CiAjZW5kaWYKIH0KIAotLSAKMi4yMy4wCgoKX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX18KWGVuLWRldmVsIG1haWxpbmcgbGlzdApYZW4tZGV2 ZWxAbGlzdHMueGVucHJvamVjdC5vcmcKaHR0cHM6Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9tYWls bWFuL2xpc3RpbmZvL3hlbi1kZXZlbA== 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=-6.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS 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 3A181CA9ED0 for ; Fri, 1 Nov 2019 22:49:49 +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 19819217D9 for ; Fri, 1 Nov 2019 22:49:49 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 19819217D9 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=mellanox.com 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 7A3E46F88D; Fri, 1 Nov 2019 22:49:40 +0000 (UTC) Received: from EUR03-AM5-obe.outbound.protection.outlook.com (mail-eopbgr30077.outbound.protection.outlook.com [40.107.3.77]) by gabe.freedesktop.org (Postfix) with ESMTPS id 15C0B6F852; Fri, 1 Nov 2019 18:34:45 +0000 (UTC) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=ID1czwKAJLJjyQE30wEVEYNJTUEtpI7Qkl24FrPbmXzaju2x222SlxL+11q/UDBdUsYq/Z2/UvM7LVb9kuBkmxRiPd+cG27JIs/5anPSLrc7aT3QaOrgcKpwM8i5z2Mu+VXBiwW83tEQNE5hJXvc+XrdZie0X3djGlK9VtdfANz/f9HA6j0tymIPobevmbRt5At9dvqKzmAlICQVL+C5KxnYAZUX1XsZDwxeeap+ii3cUXxe6a6LXB6Y9Z2CLEUZrgZfETf0RDCkTFrDGtTCi21B8u9CnCEWoplFgFw+ldPZqhwRHcWF5oC5uiLKC4BAedJEJltsMdcJCdpwIM9Ntw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=oXuOHTtipoYkfU5LykKoTmwF4/VlgjtrC3fuHXm5AjI=; b=Ua7vkWayi5JBuLpIWZDwMR6AU8/DU7mhA0xCZewXDuUeeom3QLuwm1csS/Ijbju+vpjF5akTq0bN0oEELJ/Kenn1bIACSln3frAm66Gi8wdxfLhRqTQ+N8LJ2dpvGazDJQ9x9GjhAtvjf0jWi9ZpO9RhsiChXpx2x0XeytZp+nweQxxTcQXG22ZsGL5xqq1RfQ6lSkx9Yu/VeSvwR2JR/7hDMR5ENG++Gq98I60v1tkMK9wUXyvj65jfuM/79MVATfvMzpRzm1WpRXaXg6xWxf5XH6Ldn86uJDqZtAtFu3WnXOsCN8l+OGWxqAgNf56bqEnegkHrJwtC6tD56Ps3+g== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=mellanox.com; dmarc=pass action=none header.from=mellanox.com; dkim=pass header.d=mellanox.com; arc=none Received: from VI1PR05MB4141.eurprd05.prod.outlook.com (52.133.14.15) by VI1PR05MB4416.eurprd05.prod.outlook.com (52.134.123.146) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.2387.22; Fri, 1 Nov 2019 18:34:40 +0000 Received: from VI1PR05MB4141.eurprd05.prod.outlook.com ([fe80::b179:e8bf:22d4:bf8d]) by VI1PR05MB4141.eurprd05.prod.outlook.com ([fe80::b179:e8bf:22d4:bf8d%5]) with mapi id 15.20.2387.028; Fri, 1 Nov 2019 18:34:40 +0000 From: Jason Gunthorpe To: "Yang, Philip" Subject: [PATCH v2a 14/15] drm/amdgpu: Use mmu_range_notifier instead of hmm_mirror Thread-Topic: [PATCH v2a 14/15] drm/amdgpu: Use mmu_range_notifier instead of hmm_mirror Thread-Index: AQHVkOMFaRcJHQRrK0S6ryutY4Fnpg== Date: Fri, 1 Nov 2019 18:34:40 +0000 Message-ID: <20191101183435.GR22766@mellanox.com> References: <20191028201032.6352-1-jgg@ziepe.ca> <20191028201032.6352-15-jgg@ziepe.ca> <20191029192544.GU22766@mellanox.com> <30b2f569-bf7a-5166-c98d-4a4a13d1351f@amd.com> In-Reply-To: <30b2f569-bf7a-5166-c98d-4a4a13d1351f@amd.com> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-clientproxiedby: BN4PR12CA0013.namprd12.prod.outlook.com (2603:10b6:403:2::23) To VI1PR05MB4141.eurprd05.prod.outlook.com (2603:10a6:803:44::15) x-ms-exchange-messagesentrepresentingtype: 1 x-originating-ip: [142.162.113.180] x-ms-publictraffictype: Email x-ms-office365-filtering-ht: Tenant x-ms-office365-filtering-correlation-id: 7fd1dc84-23d9-4c30-3490-08d75efa27d3 x-ms-traffictypediagnostic: VI1PR05MB4416: x-microsoft-antispam-prvs: x-ms-oob-tlc-oobclassifiers: OLM:6430; x-forefront-prvs: 020877E0CB x-forefront-antispam-report: SFV:NSPM; SFS:(10009020)(4636009)(366004)(136003)(396003)(376002)(39860400002)(346002)(199004)(189003)(36756003)(81156014)(86362001)(102836004)(54906003)(476003)(11346002)(446003)(14454004)(6916009)(6512007)(486006)(2616005)(99286004)(14444005)(6436002)(66066001)(256004)(6486002)(6116002)(2906002)(8676002)(25786009)(71200400001)(3846002)(4326008)(478600001)(71190400001)(33656002)(30864003)(5660300002)(66946007)(81166006)(8936002)(7736002)(52116002)(66556008)(66476007)(386003)(6506007)(1076003)(316002)(66446008)(186003)(305945005)(26005)(7416002)(76176011)(64756008); DIR:OUT; SFP:1101; SCL:1; SRVR:VI1PR05MB4416; H:VI1PR05MB4141.eurprd05.prod.outlook.com; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; A:1; MX:1; received-spf: None (protection.outlook.com: mellanox.com does not designate permitted sender hosts) x-ms-exchange-senderadcheck: 1 x-microsoft-antispam: BCL:0; x-microsoft-antispam-message-info: fWNQ+BZa7hfC/4uLDbkIzf190FXkgTVGRQKdPvrvbvJpoBtJPgrsM7NGgZQ1QolaRtrYNrap2uwCvyZBwc+s1RJrMJs0W4wt38pjuaPPJHfnwuNoqyOnrYlMsQwNybX+mi4Q5WE4Pg0wiaVGQDLKd/jzIznyDxANtLOIJkay4xVDUZuqQJg0ZJ5lwxg9w7eTS8jfnmflWgEN1kT2Vh17iuWWQZ3VwGzrMwd3SehhT5moiR+3hN8s058c3TYlgBggqYdEGdDYMmVxzwWbZ1hRnOtvnkbCjHalAFCEwBe2F4KYWoOr44uRyLV32bUbwHLWYknPvscKcWD2/FgOmTHQPiVPsk9o16OhK4JhXmP+uYkdvjkbZgWiPYIElS4dXYek7ygn7Xc0XKeD/JE/rH5lLTVBDLeo3+S2wC+qVP+/j2+4kf1uzHXjbfJLmDORfGdY x-ms-exchange-transport-forked: True Content-ID: MIME-Version: 1.0 X-OriginatorOrg: Mellanox.com X-MS-Exchange-CrossTenant-Network-Message-Id: 7fd1dc84-23d9-4c30-3490-08d75efa27d3 X-MS-Exchange-CrossTenant-originalarrivaltime: 01 Nov 2019 18:34:40.7437 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: a652971c-7d2e-4d9b-a6a4-d149256f461b X-MS-Exchange-CrossTenant-mailboxtype: HOSTED X-MS-Exchange-CrossTenant-userprincipalname: 6w7Cky8H25cOW4Dxqgj7Dr4BIQtw+qoZ/7TjiXWzab8P8ekkpF8unK6sBjda6ZrGlvHzuK1g8e6b2fcbAMO5Iw== X-MS-Exchange-Transport-CrossTenantHeadersStamped: VI1PR05MB4416 X-Mailman-Approved-At: Fri, 01 Nov 2019 22:49:38 +0000 X-Mailman-Original-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=Mellanox.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=oXuOHTtipoYkfU5LykKoTmwF4/VlgjtrC3fuHXm5AjI=; b=SVt+wZWfddkHw40mdehiJvucDKT2KvzDlrQP55Ml/4rWjve2GuEe2xqxPo73B2fRqrFrHqK5bx8O/xIaihWeqPjCshAWTaYAbnXeNPUgKNFCym3gLpiowXTwCoZckm0xfZGrKXjiAUW/JE5DWbv0znRymHJP/wjis3b6AfDHIX8= X-Mailman-Original-Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=jgg@mellanox.com; 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: "nouveau@lists.freedesktop.org" , "dri-devel@lists.freedesktop.org" , "linux-mm@kvack.org" , Stefano Stabellini , Oleksandr Andrushchenko , "linux-rdma@vger.kernel.org" , "amd-gfx@lists.freedesktop.org" , Christoph Hellwig , Ben Skeggs , "xen-devel@lists.xenproject.org" , Ralph Campbell , John Hubbard , Jerome Glisse , Dennis Dalessandro , Boris Ostrovsky , Petr Cvek , Juergen Gross , Mike Marciniszyn , "Kuehling, Felix" , "Deucher, Alexander" , "Koenig, Christian" Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Message-ID: <20191101183440.iHYK4_Op9me4z5jodQqK4NEre09U1JCKhZfkw5Sdy_Q@z> Q29udmVydCB0aGUgY29sbGlzaW9uLXJldHJ5IGxvY2sgYXJvdW5kIGhtbV9yYW5nZV9mYXVsdCB0 byB1c2UgdGhlIG9uZSBub3cKcHJvdmlkZWQgYnkgdGhlIG1tdV9yYW5nZSBub3RpZmllci4KCkFs dGhvdWdoIHRoaXMgZHJpdmVyIGRvZXMgbm90IHNlZW0gdG8gdXNlIHRoZSBjb2xsaXNpb24gcmV0 cnkgbG9jayB0aGF0CmhtbSBwcm92aWRlcyBjb3JyZWN0bHksIGl0IGNhbiBzdGlsbCBiZSBjb252 ZXJ0ZWQgb3ZlciB0byB1c2UgdGhlCm1tdV9yYW5nZV9ub3RpZmllciBhcGkgaW5zdGVhZCBvZiBo bW1fbWlycm9yIHdpdGhvdXQgdG9vIG11Y2ggdHJvdWJsZS4KClRoaXMgYWxzbyBkZWxldGVzIGFu b3RoZXIgcGxhY2Ugd2hlcmUgYSBkcml2ZXIgaXMgYXNzb2NpYXRpbmcgYWRkaXRpb25hbApkYXRh IChzdHJ1Y3QgYW1kZ3B1X21uKSB3aXRoIGEgbW11X3N0cnVjdC4KClNpZ25lZC1vZmYtYnk6IFBo aWxpcCBZYW5nIDxQaGlsaXAuWWFuZ0BhbWQuY29tPgpSZXZpZXdlZC1ieTogUGhpbGlwIFlhbmcg PFBoaWxpcC5ZYW5nQGFtZC5jb20+ClRlc3RlZC1ieTogUGhpbGlwIFlhbmcgPFBoaWxpcC5ZYW5n QGFtZC5jb20+ClNpZ25lZC1vZmYtYnk6IEphc29uIEd1bnRob3JwZSA8amdnQG1lbGxhbm94LmNv bT4KLS0tCiAuLi4vZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYyAgfCAg IDQgKwogZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2NzLmMgICAgICAgIHwgIDE0 ICstCiBkcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uYyAgICAgICAgfCAxNTAg KystLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4u aCAgICAgICAgfCAgNDkgLS0tLS0tCiBkcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVf dHRtLmMgICAgICAgfCAxMTYgKysrKysrKysrLS0tLS0KIDUgZmlsZXMgY2hhbmdlZCwgOTYgaW5z ZXJ0aW9ucygrKSwgMjM3IGRlbGV0aW9ucygtKQoKUGhpbGlwLCBoZXJlIGlzIHdoYXQgaXQgbG9v cyBsaWtlIGFmdGVyIGNvbWJpbmluZyB0aGUgdHdvIHBhdGNoZXMsIHRoYW5rcwoKZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYyBiL2Ry aXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYwppbmRleCA0Nzcw MDMwMmEwOGI3Zi4uMWJjZWRiOWI0NzdkY2UgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9h bWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1k L2FtZGdwdS9hbWRncHVfYW1ka2ZkX2dwdXZtLmMKQEAgLTE3MzgsNiArMTczOCwxMCBAQCBzdGF0 aWMgaW50IHVwZGF0ZV9pbnZhbGlkX3VzZXJfcGFnZXMoc3RydWN0IGFtZGtmZF9wcm9jZXNzX2lu Zm8gKnByb2Nlc3NfaW5mbywKIAkJCXJldHVybiByZXQ7CiAJCX0KIAorCQkvKgorCQkgKiBGSVhN RTogQ2Fubm90IGlnbm9yZSB0aGUgcmV0dXJuIGNvZGUsIG11c3QgaG9sZAorCQkgKiBub3RpZmll cl9sb2NrCisJCSAqLwogCQlhbWRncHVfdHRtX3R0X2dldF91c2VyX3BhZ2VzX2RvbmUoYm8tPnRi by50dG0pOwogCiAJCS8qIE1hcmsgdGhlIEJPIGFzIHZhbGlkIHVubGVzcyBpdCB3YXMgaW52YWxp ZGF0ZWQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9jcy5j IGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2NzLmMKaW5kZXggODI4MjNkOWE4 YmE4ODcuLjIyYzk4OWJjYTc1MTRjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2Ft ZGdwdS9hbWRncHVfY3MuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVf Y3MuYwpAQCAtNjAzLDggKzYwMyw2IEBAIHN0YXRpYyBpbnQgYW1kZ3B1X2NzX3BhcnNlcl9ib3Mo c3RydWN0IGFtZGdwdV9jc19wYXJzZXIgKnAsCiAJCWUtPnR2Lm51bV9zaGFyZWQgPSAyOwogCiAJ YW1kZ3B1X2JvX2xpc3RfZ2V0X2xpc3QocC0+Ym9fbGlzdCwgJnAtPnZhbGlkYXRlZCk7Ci0JaWYg KHAtPmJvX2xpc3QtPmZpcnN0X3VzZXJwdHIgIT0gcC0+Ym9fbGlzdC0+bnVtX2VudHJpZXMpCi0J CXAtPm1uID0gYW1kZ3B1X21uX2dldChwLT5hZGV2LCBBTURHUFVfTU5fVFlQRV9HRlgpOwogCiAJ SU5JVF9MSVNUX0hFQUQoJmR1cGxpY2F0ZXMpOwogCWFtZGdwdV92bV9nZXRfcGRfYm8oJmZwcml2 LT52bSwgJnAtPnZhbGlkYXRlZCwgJnAtPnZtX3BkKTsKQEAgLTEyODcsMTEgKzEyODUsMTEgQEAg c3RhdGljIGludCBhbWRncHVfY3Nfc3VibWl0KHN0cnVjdCBhbWRncHVfY3NfcGFyc2VyICpwLAog CWlmIChyKQogCQlnb3RvIGVycm9yX3VubG9jazsKIAotCS8qIE5vIG1lbW9yeSBhbGxvY2F0aW9u IGlzIGFsbG93ZWQgd2hpbGUgaG9sZGluZyB0aGUgbW4gbG9jay4KLQkgKiBwLT5tbiBpcyBob2xk IHVudGlsIGFtZGdwdV9jc19zdWJtaXQgaXMgZmluaXNoZWQgYW5kIGZlbmNlIGlzIGFkZGVkCi0J ICogdG8gQk9zLgorCS8qIE5vIG1lbW9yeSBhbGxvY2F0aW9uIGlzIGFsbG93ZWQgd2hpbGUgaG9s ZGluZyB0aGUgbm90aWZpZXIgbG9jay4KKwkgKiBUaGUgbG9jayBpcyBoZWxkIHVudGlsIGFtZGdw dV9jc19zdWJtaXQgaXMgZmluaXNoZWQgYW5kIGZlbmNlIGlzCisJICogYWRkZWQgdG8gQk9zLgog CSAqLwotCWFtZGdwdV9tbl9sb2NrKHAtPm1uKTsKKwltdXRleF9sb2NrKCZwLT5hZGV2LT5ub3Rp Zmllcl9sb2NrKTsKIAogCS8qIElmIHVzZXJwdHIgYXJlIGludmFsaWRhdGVkIGFmdGVyIGFtZGdw dV9jc19wYXJzZXJfYm9zKCksIHJldHVybgogCSAqIC1FQUdBSU4sIGRybUlvY3RsIGluIGxpYmRy bSB3aWxsIHJlc3RhcnQgdGhlIGFtZGdwdV9jc19pb2N0bC4KQEAgLTEzMzQsMTMgKzEzMzIsMTMg QEAgc3RhdGljIGludCBhbWRncHVfY3Nfc3VibWl0KHN0cnVjdCBhbWRncHVfY3NfcGFyc2VyICpw LAogCWFtZGdwdV92bV9tb3ZlX3RvX2xydV90YWlsKHAtPmFkZXYsICZmcHJpdi0+dm0pOwogCiAJ dHRtX2V1X2ZlbmNlX2J1ZmZlcl9vYmplY3RzKCZwLT50aWNrZXQsICZwLT52YWxpZGF0ZWQsIHAt PmZlbmNlKTsKLQlhbWRncHVfbW5fdW5sb2NrKHAtPm1uKTsKKwltdXRleF91bmxvY2soJnAtPmFk ZXYtPm5vdGlmaWVyX2xvY2spOwogCiAJcmV0dXJuIDA7CiAKIGVycm9yX2Fib3J0OgogCWRybV9z Y2hlZF9qb2JfY2xlYW51cCgmam9iLT5iYXNlKTsKLQlhbWRncHVfbW5fdW5sb2NrKHAtPm1uKTsK KwltdXRleF91bmxvY2soJnAtPmFkZXYtPm5vdGlmaWVyX2xvY2spOwogCiBlcnJvcl91bmxvY2s6 CiAJYW1kZ3B1X2pvYl9mcmVlKGpvYik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1k L2FtZGdwdS9hbWRncHVfbW4uYyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9t bi5jCmluZGV4IGFjNzQzMjBiNzFlNGU3Li5mN2JlMzQ5MDdlNTRmNSAxMDA2NDQKLS0tIGEvZHJp dmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmMKKysrIGIvZHJpdmVycy9ncHUvZHJt L2FtZC9hbWRncHUvYW1kZ3B1X21uLmMKQEAgLTUwLDI4ICs1MCw2IEBACiAjaW5jbHVkZSAiYW1k Z3B1LmgiCiAjaW5jbHVkZSAiYW1kZ3B1X2FtZGtmZC5oIgogCi0vKioKLSAqIGFtZGdwdV9tbl9s b2NrIC0gdGFrZSB0aGUgd3JpdGUgc2lkZSBsb2NrIGZvciB0aGlzIG5vdGlmaWVyCi0gKgotICog QG1uOiBvdXIgbm90aWZpZXIKLSAqLwotdm9pZCBhbWRncHVfbW5fbG9jayhzdHJ1Y3QgYW1kZ3B1 X21uICptbikKLXsKLQlpZiAobW4pCi0JCWRvd25fd3JpdGUoJm1uLT5sb2NrKTsKLX0KLQotLyoq Ci0gKiBhbWRncHVfbW5fdW5sb2NrIC0gZHJvcCB0aGUgd3JpdGUgc2lkZSBsb2NrIGZvciB0aGlz IG5vdGlmaWVyCi0gKgotICogQG1uOiBvdXIgbm90aWZpZXIKLSAqLwotdm9pZCBhbWRncHVfbW5f dW5sb2NrKHN0cnVjdCBhbWRncHVfbW4gKm1uKQotewotCWlmIChtbikKLQkJdXBfd3JpdGUoJm1u LT5sb2NrKTsKLX0KLQogLyoqCiAgKiBhbWRncHVfbW5faW52YWxpZGF0ZV9nZnggLSBjYWxsYmFj ayB0byBub3RpZnkgYWJvdXQgbW0gY2hhbmdlCiAgKgpAQCAtODIsMTYgKzYwLDIwIEBAIHZvaWQg YW1kZ3B1X21uX3VubG9jayhzdHJ1Y3QgYW1kZ3B1X21uICptbikKICAqIHBvdGVudGlhbGx5IGRp cnR5LgogICovCiBzdGF0aWMgYm9vbCBhbWRncHVfbW5faW52YWxpZGF0ZV9nZngoc3RydWN0IG1t dV9yYW5nZV9ub3RpZmllciAqbXJuLAotCQkJCSAgICAgY29uc3Qgc3RydWN0IG1tdV9ub3RpZmll cl9yYW5nZSAqcmFuZ2UpCisJCQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3Jhbmdl ICpyYW5nZSwKKwkJCQkgICAgIHVuc2lnbmVkIGxvbmcgY3VyX3NlcSkKIHsKIAlzdHJ1Y3QgYW1k Z3B1X2JvICpibyA9IGNvbnRhaW5lcl9vZihtcm4sIHN0cnVjdCBhbWRncHVfYm8sIG5vdGlmaWVy KTsKIAlzdHJ1Y3QgYW1kZ3B1X2RldmljZSAqYWRldiA9IGFtZGdwdV90dG1fYWRldihiby0+dGJv LmJkZXYpOwogCWxvbmcgcjsKIAotCWlmICghbW11X25vdGlmaWVyX3JhbmdlX2Jsb2NrYWJsZShy YW5nZSkpCisJaWYgKG1tdV9ub3RpZmllcl9yYW5nZV9ibG9ja2FibGUocmFuZ2UpKQorCQltdXRl eF9sb2NrKCZhZGV2LT5ub3RpZmllcl9sb2NrKTsKKwllbHNlIGlmICghbXV0ZXhfdHJ5bG9jaygm YWRldi0+bm90aWZpZXJfbG9jaykpCiAJCXJldHVybiBmYWxzZTsKIAotCW11dGV4X2xvY2soJmFk ZXYtPm5vdGlmaWVyX2xvY2spOworCW1tdV9yYW5nZV9zZXRfc2VxKG1ybiwgY3VyX3NlcSk7CisK IAlyID0gZG1hX3Jlc3Zfd2FpdF90aW1lb3V0X3JjdShiby0+dGJvLmJhc2UucmVzdiwgdHJ1ZSwg ZmFsc2UsCiAJCQkJICAgICAgTUFYX1NDSEVEVUxFX1RJTUVPVVQpOwogCW11dGV4X3VubG9jaygm YWRldi0+bm90aWZpZXJfbG9jayk7CkBAIC0xMTQsMTUgKzk2LDE5IEBAIHN0YXRpYyBjb25zdCBz dHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyX29wcyBhbWRncHVfbW5fZ2Z4X29wcyA9IHsKICAqIGV2 aWN0aW5nIGFsbCB1c2VyLW1vZGUgcXVldWVzIG9mIHRoZSBwcm9jZXNzLgogICovCiBzdGF0aWMg Ym9vbCBhbWRncHVfbW5faW52YWxpZGF0ZV9oc2Eoc3RydWN0IG1tdV9yYW5nZV9ub3RpZmllciAq bXJuLAotCQkJCSAgICAgY29uc3Qgc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAqcmFuZ2UpCisJ CQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICpyYW5nZSwKKwkJCQkgICAg IHVuc2lnbmVkIGxvbmcgY3VyX3NlcSkKIHsKIAlzdHJ1Y3QgYW1kZ3B1X2JvICpibyA9IGNvbnRh aW5lcl9vZihtcm4sIHN0cnVjdCBhbWRncHVfYm8sIG5vdGlmaWVyKTsKIAlzdHJ1Y3QgYW1kZ3B1 X2RldmljZSAqYWRldiA9IGFtZGdwdV90dG1fYWRldihiby0+dGJvLmJkZXYpOwogCi0JaWYgKCFt bXVfbm90aWZpZXJfcmFuZ2VfYmxvY2thYmxlKHJhbmdlKSkKKwlpZiAobW11X25vdGlmaWVyX3Jh bmdlX2Jsb2NrYWJsZShyYW5nZSkpCisJCW11dGV4X2xvY2soJmFkZXYtPm5vdGlmaWVyX2xvY2sp OworCWVsc2UgaWYgKCFtdXRleF90cnlsb2NrKCZhZGV2LT5ub3RpZmllcl9sb2NrKSkKIAkJcmV0 dXJuIGZhbHNlOwogCi0JbXV0ZXhfbG9jaygmYWRldi0+bm90aWZpZXJfbG9jayk7CisJbW11X3Jh bmdlX3NldF9zZXEobXJuLCBjdXJfc2VxKTsKKwogCWFtZGdwdV9hbWRrZmRfZXZpY3RfdXNlcnB0 cihiby0+a2ZkX2JvLCBiby0+bm90aWZpZXIubW0pOwogCW11dGV4X3VubG9jaygmYWRldi0+bm90 aWZpZXJfbG9jayk7CiAKQEAgLTEzMyw5MiArMTE5LDYgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBt bXVfcmFuZ2Vfbm90aWZpZXJfb3BzIGFtZGdwdV9tbl9oc2Ffb3BzID0gewogCS5pbnZhbGlkYXRl ID0gYW1kZ3B1X21uX2ludmFsaWRhdGVfaHNhLAogfTsKIAotc3RhdGljIGludCBhbWRncHVfbW5f c3luY19wYWdldGFibGVzKHN0cnVjdCBobW1fbWlycm9yICptaXJyb3IsCi0JCQkJICAgICBjb25z dCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICp1cGRhdGUpCi17Ci0Jc3RydWN0IGFtZGdwdV9t biAqYW1uID0gY29udGFpbmVyX29mKG1pcnJvciwgc3RydWN0IGFtZGdwdV9tbiwgbWlycm9yKTsK LQotCWlmICghbW11X25vdGlmaWVyX3JhbmdlX2Jsb2NrYWJsZSh1cGRhdGUpKQotCQlyZXR1cm4g LUVBR0FJTjsKLQotCWRvd25fcmVhZCgmYW1uLT5sb2NrKTsKLQl1cF9yZWFkKCZhbW4tPmxvY2sp OwotCXJldHVybiAwOwotfQotCi0vKiBMb3cgYml0cyBvZiBhbnkgcmVhc29uYWJsZSBtbSBwb2lu dGVyIHdpbGwgYmUgdW51c2VkIGR1ZSB0byBzdHJ1Y3QKLSAqIGFsaWdubWVudC4gVXNlIHRoZXNl IGJpdHMgdG8gbWFrZSBhIHVuaXF1ZSBrZXkgZnJvbSB0aGUgbW0gcG9pbnRlcgotICogYW5kIG5v dGlmaWVyIHR5cGUuCi0gKi8KLSNkZWZpbmUgQU1ER1BVX01OX0tFWShtbSwgdHlwZSkgKCh1bnNp Z25lZCBsb25nKShtbSkgKyAodHlwZSkpCi0KLXN0YXRpYyBzdHJ1Y3QgaG1tX21pcnJvcl9vcHMg YW1kZ3B1X2htbV9taXJyb3Jfb3BzW10gPSB7Ci0JW0FNREdQVV9NTl9UWVBFX0dGWF0gPSB7Ci0J CS5zeW5jX2NwdV9kZXZpY2VfcGFnZXRhYmxlcyA9IGFtZGdwdV9tbl9zeW5jX3BhZ2V0YWJsZXMs Ci0JfSwKLQlbQU1ER1BVX01OX1RZUEVfSFNBXSA9IHsKLQkJLnN5bmNfY3B1X2RldmljZV9wYWdl dGFibGVzID0gYW1kZ3B1X21uX3N5bmNfcGFnZXRhYmxlcywKLQl9LAotfTsKLQotLyoqCi0gKiBh bWRncHVfbW5fZ2V0IC0gY3JlYXRlIEhNTSBtaXJyb3IgY29udGV4dAotICoKLSAqIEBhZGV2OiBh bWRncHUgZGV2aWNlIHBvaW50ZXIKLSAqIEB0eXBlOiB0eXBlIG9mIE1NVSBub3RpZmllciBjb250 ZXh0Ci0gKgotICogQ3JlYXRlcyBhIEhNTSBtaXJyb3IgY29udGV4dCBmb3IgY3VycmVudC0+bW0u Ci0gKi8KLXN0cnVjdCBhbWRncHVfbW4gKmFtZGdwdV9tbl9nZXQoc3RydWN0IGFtZGdwdV9kZXZp Y2UgKmFkZXYsCi0JCQkJZW51bSBhbWRncHVfbW5fdHlwZSB0eXBlKQotewotCXN0cnVjdCBtbV9z dHJ1Y3QgKm1tID0gY3VycmVudC0+bW07Ci0Jc3RydWN0IGFtZGdwdV9tbiAqYW1uOwotCXVuc2ln bmVkIGxvbmcga2V5ID0gQU1ER1BVX01OX0tFWShtbSwgdHlwZSk7Ci0JaW50IHI7Ci0KLQltdXRl eF9sb2NrKCZhZGV2LT5tbl9sb2NrKTsKLQlpZiAoZG93bl93cml0ZV9raWxsYWJsZSgmbW0tPm1t YXBfc2VtKSkgewotCQltdXRleF91bmxvY2soJmFkZXYtPm1uX2xvY2spOwotCQlyZXR1cm4gRVJS X1BUUigtRUlOVFIpOwotCX0KLQotCWhhc2hfZm9yX2VhY2hfcG9zc2libGUoYWRldi0+bW5faGFz aCwgYW1uLCBub2RlLCBrZXkpCi0JCWlmIChBTURHUFVfTU5fS0VZKGFtbi0+bWlycm9yLmhtbS0+ bW11X25vdGlmaWVyLm1tLAotCQkJCSAgYW1uLT50eXBlKSA9PSBrZXkpCi0JCQlnb3RvIHJlbGVh c2VfbG9ja3M7Ci0KLQlhbW4gPSBremFsbG9jKHNpemVvZigqYW1uKSwgR0ZQX0tFUk5FTCk7Ci0J aWYgKCFhbW4pIHsKLQkJYW1uID0gRVJSX1BUUigtRU5PTUVNKTsKLQkJZ290byByZWxlYXNlX2xv Y2tzOwotCX0KLQotCWFtbi0+YWRldiA9IGFkZXY7Ci0JaW5pdF9yd3NlbSgmYW1uLT5sb2NrKTsK LQlhbW4tPnR5cGUgPSB0eXBlOwotCi0JYW1uLT5taXJyb3Iub3BzID0gJmFtZGdwdV9obW1fbWly cm9yX29wc1t0eXBlXTsKLQlyID0gaG1tX21pcnJvcl9yZWdpc3RlcigmYW1uLT5taXJyb3IsIG1t KTsKLQlpZiAocikKLQkJZ290byBmcmVlX2FtbjsKLQotCWhhc2hfYWRkKGFkZXYtPm1uX2hhc2gs ICZhbW4tPm5vZGUsIEFNREdQVV9NTl9LRVkobW0sIHR5cGUpKTsKLQotcmVsZWFzZV9sb2NrczoK LQl1cF93cml0ZSgmbW0tPm1tYXBfc2VtKTsKLQltdXRleF91bmxvY2soJmFkZXYtPm1uX2xvY2sp OwotCi0JcmV0dXJuIGFtbjsKLQotZnJlZV9hbW46Ci0JdXBfd3JpdGUoJm1tLT5tbWFwX3NlbSk7 Ci0JbXV0ZXhfdW5sb2NrKCZhZGV2LT5tbl9sb2NrKTsKLQlrZnJlZShhbW4pOwotCi0JcmV0dXJu IEVSUl9QVFIocik7Ci19Ci0KIC8qKgogICogYW1kZ3B1X21uX3JlZ2lzdGVyIC0gcmVnaXN0ZXIg YSBCTyBmb3Igbm90aWZpZXIgdXBkYXRlcwogICoKQEAgLTI1MywyNSArMTUzLDMgQEAgdm9pZCBh bWRncHVfbW5fdW5yZWdpc3RlcihzdHJ1Y3QgYW1kZ3B1X2JvICpibykKIAltbXVfcmFuZ2Vfbm90 aWZpZXJfcmVtb3ZlKCZiby0+bm90aWZpZXIpOwogCWJvLT5ub3RpZmllci5tbSA9IE5VTEw7CiB9 Ci0KLS8qIGZsYWdzIHVzZWQgYnkgSE1NIGludGVybmFsLCBub3QgcmVsYXRlZCB0byBDUFUvR1BV IFBURSBmbGFncyAqLwotc3RhdGljIGNvbnN0IHVpbnQ2NF90IGhtbV9yYW5nZV9mbGFnc1tITU1f UEZOX0ZMQUdfTUFYXSA9IHsKLQkJKDEgPDwgMCksIC8qIEhNTV9QRk5fVkFMSUQgKi8KLQkJKDEg PDwgMSksIC8qIEhNTV9QRk5fV1JJVEUgKi8KLQkJMCAvKiBITU1fUEZOX0RFVklDRV9QUklWQVRF ICovCi19OwotCi1zdGF0aWMgY29uc3QgdWludDY0X3QgaG1tX3JhbmdlX3ZhbHVlc1tITU1fUEZO X1ZBTFVFX01BWF0gPSB7Ci0JCTB4ZmZmZmZmZmZmZmZmZmZmZVVMLCAvKiBITU1fUEZOX0VSUk9S ICovCi0JCTAsIC8qIEhNTV9QRk5fTk9ORSAqLwotCQkweGZmZmZmZmZmZmZmZmZmZmNVTCAvKiBI TU1fUEZOX1NQRUNJQUwgKi8KLX07Ci0KLXZvaWQgYW1kZ3B1X2htbV9pbml0X3JhbmdlKHN0cnVj dCBobW1fcmFuZ2UgKnJhbmdlKQotewotCWlmIChyYW5nZSkgewotCQlyYW5nZS0+ZmxhZ3MgPSBo bW1fcmFuZ2VfZmxhZ3M7Ci0JCXJhbmdlLT52YWx1ZXMgPSBobW1fcmFuZ2VfdmFsdWVzOwotCQly YW5nZS0+cGZuX3NoaWZ0ID0gUEFHRV9TSElGVDsKLQl9Ci19CmRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uaCBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1k Z3B1L2FtZGdwdV9tbi5oCmluZGV4IGQ3M2FiMjk0N2IyMmIyLi5hMjkyMjM4Zjc1ZWJhZSAxMDA2 NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmgKKysrIGIvZHJp dmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmgKQEAgLTMwLDU5ICszMCwxMCBAQAog I2luY2x1ZGUgPGxpbnV4L3dvcmtxdWV1ZS5oPgogI2luY2x1ZGUgPGxpbnV4L2ludGVydmFsX3Ry ZWUuaD4KIAotZW51bSBhbWRncHVfbW5fdHlwZSB7Ci0JQU1ER1BVX01OX1RZUEVfR0ZYLAotCUFN REdQVV9NTl9UWVBFX0hTQSwKLX07Ci0KLS8qKgotICogc3RydWN0IGFtZGdwdV9tbgotICoKLSAq IEBhZGV2OiBhbWRncHUgZGV2aWNlIHBvaW50ZXIKLSAqIEB0eXBlOiB0eXBlIG9mIE1NVSBub3Rp ZmllcgotICogQHdvcms6IGRlc3RydWN0aW9uIHdvcmsgaXRlbQotICogQG5vZGU6IGhhc2ggdGFi bGUgbm9kZSB0byBmaW5kIHN0cnVjdHVyZSBieSBhZGV2IGFuZCBtbgotICogQGxvY2s6IHJ3IHNl bWFwaG9yZSBwcm90ZWN0aW5nIHRoZSBub3RpZmllciBub2RlcwotICogQG1pcnJvcjogSE1NIG1p cnJvciBmdW5jdGlvbiBzdXBwb3J0Ci0gKgotICogRGF0YSBmb3IgZWFjaCBhbWRncHUgZGV2aWNl IGFuZCBwcm9jZXNzIGFkZHJlc3Mgc3BhY2UuCi0gKi8KLXN0cnVjdCBhbWRncHVfbW4gewotCS8q IGNvbnN0YW50IGFmdGVyIGluaXRpYWxpc2F0aW9uICovCi0Jc3RydWN0IGFtZGdwdV9kZXZpY2UJ KmFkZXY7Ci0JZW51bSBhbWRncHVfbW5fdHlwZQl0eXBlOwotCi0JLyogb25seSB1c2VkIG9uIGRl c3RydWN0aW9uICovCi0Jc3RydWN0IHdvcmtfc3RydWN0CXdvcms7Ci0KLQkvKiBwcm90ZWN0ZWQg YnkgYWRldi0+bW5fbG9jayAqLwotCXN0cnVjdCBobGlzdF9ub2RlCW5vZGU7Ci0KLQkvKiBvYmpl Y3RzIHByb3RlY3RlZCBieSBsb2NrICovCi0Jc3RydWN0IHJ3X3NlbWFwaG9yZQlsb2NrOwotCi0j aWZkZWYgQ09ORklHX0hNTV9NSVJST1IKLQkvKiBITU0gbWlycm9yICovCi0Jc3RydWN0IGhtbV9t aXJyb3IJbWlycm9yOwotI2VuZGlmCi19OwotCiAjaWYgZGVmaW5lZChDT05GSUdfSE1NX01JUlJP UikKLXZvaWQgYW1kZ3B1X21uX2xvY2soc3RydWN0IGFtZGdwdV9tbiAqbW4pOwotdm9pZCBhbWRn cHVfbW5fdW5sb2NrKHN0cnVjdCBhbWRncHVfbW4gKm1uKTsKLXN0cnVjdCBhbWRncHVfbW4gKmFt ZGdwdV9tbl9nZXQoc3RydWN0IGFtZGdwdV9kZXZpY2UgKmFkZXYsCi0JCQkJZW51bSBhbWRncHVf bW5fdHlwZSB0eXBlKTsKIGludCBhbWRncHVfbW5fcmVnaXN0ZXIoc3RydWN0IGFtZGdwdV9ibyAq Ym8sIHVuc2lnbmVkIGxvbmcgYWRkcik7CiB2b2lkIGFtZGdwdV9tbl91bnJlZ2lzdGVyKHN0cnVj dCBhbWRncHVfYm8gKmJvKTsKLXZvaWQgYW1kZ3B1X2htbV9pbml0X3JhbmdlKHN0cnVjdCBobW1f cmFuZ2UgKnJhbmdlKTsKICNlbHNlCi1zdGF0aWMgaW5saW5lIHZvaWQgYW1kZ3B1X21uX2xvY2so c3RydWN0IGFtZGdwdV9tbiAqbW4pIHt9Ci1zdGF0aWMgaW5saW5lIHZvaWQgYW1kZ3B1X21uX3Vu bG9jayhzdHJ1Y3QgYW1kZ3B1X21uICptbikge30KLXN0YXRpYyBpbmxpbmUgc3RydWN0IGFtZGdw dV9tbiAqYW1kZ3B1X21uX2dldChzdHJ1Y3QgYW1kZ3B1X2RldmljZSAqYWRldiwKLQkJCQkJICAg ICAgZW51bSBhbWRncHVfbW5fdHlwZSB0eXBlKQotewotCXJldHVybiBOVUxMOwotfQogc3RhdGlj IGlubGluZSBpbnQgYW1kZ3B1X21uX3JlZ2lzdGVyKHN0cnVjdCBhbWRncHVfYm8gKmJvLCB1bnNp Z25lZCBsb25nIGFkZHIpCiB7CiAJRFJNX1dBUk5fT05DRSgiSE1NX01JUlJPUiBrZXJuZWwgY29u ZmlnIG9wdGlvbiBpcyBub3QgZW5hYmxlZCwgIgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L2FtZC9hbWRncHUvYW1kZ3B1X3R0bS5jIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1k Z3B1X3R0bS5jCmluZGV4IGMwZTQxZjFmMGMyMzY1Li41ZjRkOGFiNzZmMWRhMCAxMDA2NDQKLS0t IGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X3R0bS5jCisrKyBiL2RyaXZlcnMv Z3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV90dG0uYwpAQCAtNzczLDYgKzc3MywyMCBAQCBzdHJ1 Y3QgYW1kZ3B1X3R0bV90dCB7CiAjZW5kaWYKIH07CiAKKyNpZmRlZiBDT05GSUdfRFJNX0FNREdQ VV9VU0VSUFRSCisvKiBmbGFncyB1c2VkIGJ5IEhNTSBpbnRlcm5hbCwgbm90IHJlbGF0ZWQgdG8g Q1BVL0dQVSBQVEUgZmxhZ3MgKi8KK3N0YXRpYyBjb25zdCB1aW50NjRfdCBobW1fcmFuZ2VfZmxh Z3NbSE1NX1BGTl9GTEFHX01BWF0gPSB7CisJKDEgPDwgMCksIC8qIEhNTV9QRk5fVkFMSUQgKi8K KwkoMSA8PCAxKSwgLyogSE1NX1BGTl9XUklURSAqLworCTAgLyogSE1NX1BGTl9ERVZJQ0VfUFJJ VkFURSAqLworfTsKKworc3RhdGljIGNvbnN0IHVpbnQ2NF90IGhtbV9yYW5nZV92YWx1ZXNbSE1N X1BGTl9WQUxVRV9NQVhdID0geworCTB4ZmZmZmZmZmZmZmZmZmZmZVVMLCAvKiBITU1fUEZOX0VS Uk9SICovCisJMCwgLyogSE1NX1BGTl9OT05FICovCisJMHhmZmZmZmZmZmZmZmZmZmZjVUwgLyog SE1NX1BGTl9TUEVDSUFMICovCit9OworCiAvKioKICAqIGFtZGdwdV90dG1fdHRfZ2V0X3VzZXJf cGFnZXMgLSBnZXQgZGV2aWNlIGFjY2Vzc2libGUgcGFnZXMgdGhhdCBiYWNrIHVzZXIKICAqIG1l bW9yeSBhbmQgc3RhcnQgSE1NIHRyYWNraW5nIENQVSBwYWdlIHRhYmxlIHVwZGF0ZQpAQCAtNzgw LDI5ICs3OTQsMjggQEAgc3RydWN0IGFtZGdwdV90dG1fdHQgewogICogQ2FsbGluZyBmdW5jdGlv biBtdXN0IGNhbGwgYW1kZ3B1X3R0bV90dF91c2VycHRyX3JhbmdlX2RvbmUoKSBvbmNlIGFuZCBv bmx5CiAgKiBvbmNlIGFmdGVyd2FyZHMgdG8gc3RvcCBITU0gdHJhY2tpbmcKICAqLwotI2lmIElT X0VOQUJMRUQoQ09ORklHX0RSTV9BTURHUFVfVVNFUlBUUikKLQotI2RlZmluZSBNQVhfUkVUUllf SE1NX1JBTkdFX0ZBVUxUCTE2Ci0KIGludCBhbWRncHVfdHRtX3R0X2dldF91c2VyX3BhZ2VzKHN0 cnVjdCBhbWRncHVfYm8gKmJvLCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKQogewotCXN0cnVjdCBobW1f bWlycm9yICptaXJyb3IgPSBiby0+bW4gPyAmYm8tPm1uLT5taXJyb3IgOiBOVUxMOwogCXN0cnVj dCB0dG1fdHQgKnR0bSA9IGJvLT50Ym8udHRtOwogCXN0cnVjdCBhbWRncHVfdHRtX3R0ICpndHQg PSAodm9pZCAqKXR0bTsKLQlzdHJ1Y3QgbW1fc3RydWN0ICptbTsKIAl1bnNpZ25lZCBsb25nIHN0 YXJ0ID0gZ3R0LT51c2VycHRyOwogCXN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hOwogCXN0cnVj dCBobW1fcmFuZ2UgKnJhbmdlOworCXVuc2lnbmVkIGxvbmcgdGltZW91dDsKKwlzdHJ1Y3QgbW1f c3RydWN0ICptbTsKIAl1bnNpZ25lZCBsb25nIGk7Ci0JdWludDY0X3QgKnBmbnM7CiAJaW50IHIg PSAwOwogCi0JaWYgKHVubGlrZWx5KCFtaXJyb3IpKSB7Ci0JCURSTV9ERUJVR19EUklWRVIoIkZh aWxlZCB0byBnZXQgaG1tX21pcnJvclxuIik7CisJbW0gPSBiby0+bm90aWZpZXIubW07CisJaWYg KHVubGlrZWx5KCFtbSkpIHsKKwkJRFJNX0RFQlVHX0RSSVZFUigiQk8gaXMgbm90IHJlZ2lzdGVy ZWQ/XG4iKTsKIAkJcmV0dXJuIC1FRkFVTFQ7CiAJfQogCi0JbW0gPSBtaXJyb3ItPmhtbS0+bW11 X25vdGlmaWVyLm1tOworCS8qIEFub3RoZXIgZ2V0X3VzZXJfcGFnZXMgaXMgcnVubmluZyBhdCB0 aGUgc2FtZSB0aW1lPz8gKi8KKwlpZiAoV0FSTl9PTihndHQtPnJhbmdlKSkKKwkJcmV0dXJuIC1F RkFVTFQ7CisKIAlpZiAoIW1tZ2V0X25vdF96ZXJvKG1tKSkgLyogSGFwcGVucyBkdXJpbmcgcHJv Y2VzcyBzaHV0ZG93biAqLwogCQlyZXR1cm4gLUVTUkNIOwogCkBAIC04MTEsMzEgKzgyNCwyMyBA QCBpbnQgYW1kZ3B1X3R0bV90dF9nZXRfdXNlcl9wYWdlcyhzdHJ1Y3QgYW1kZ3B1X2JvICpibywg c3RydWN0IHBhZ2UgKipwYWdlcykKIAkJciA9IC1FTk9NRU07CiAJCWdvdG8gb3V0OwogCX0KKwly YW5nZS0+bm90aWZpZXIgPSAmYm8tPm5vdGlmaWVyOworCXJhbmdlLT5mbGFncyA9IGhtbV9yYW5n ZV9mbGFnczsKKwlyYW5nZS0+dmFsdWVzID0gaG1tX3JhbmdlX3ZhbHVlczsKKwlyYW5nZS0+cGZu X3NoaWZ0ID0gUEFHRV9TSElGVDsKKwlyYW5nZS0+c3RhcnQgPSBiby0+bm90aWZpZXIuaW50ZXJ2 YWxfdHJlZS5zdGFydDsKKwlyYW5nZS0+ZW5kID0gYm8tPm5vdGlmaWVyLmludGVydmFsX3RyZWUu bGFzdCArIDE7CisJcmFuZ2UtPmRlZmF1bHRfZmxhZ3MgPSBobW1fcmFuZ2VfZmxhZ3NbSE1NX1BG Tl9WQUxJRF07CisJaWYgKCFhbWRncHVfdHRtX3R0X2lzX3JlYWRvbmx5KHR0bSkpCisJCXJhbmdl LT5kZWZhdWx0X2ZsYWdzIHw9IHJhbmdlLT5mbGFnc1tITU1fUEZOX1dSSVRFXTsKIAotCXBmbnMg PSBrdm1hbGxvY19hcnJheSh0dG0tPm51bV9wYWdlcywgc2l6ZW9mKCpwZm5zKSwgR0ZQX0tFUk5F TCk7Ci0JaWYgKHVubGlrZWx5KCFwZm5zKSkgeworCXJhbmdlLT5wZm5zID0ga3ZtYWxsb2NfYXJy YXkodHRtLT5udW1fcGFnZXMsIHNpemVvZigqcmFuZ2UtPnBmbnMpLAorCQkJCSAgICAgR0ZQX0tF Uk5FTCk7CisJaWYgKHVubGlrZWx5KCFyYW5nZS0+cGZucykpIHsKIAkJciA9IC1FTk9NRU07CiAJ CWdvdG8gb3V0X2ZyZWVfcmFuZ2VzOwogCX0KIAotCWFtZGdwdV9obW1faW5pdF9yYW5nZShyYW5n ZSk7Ci0JcmFuZ2UtPmRlZmF1bHRfZmxhZ3MgPSByYW5nZS0+ZmxhZ3NbSE1NX1BGTl9WQUxJRF07 Ci0JcmFuZ2UtPmRlZmF1bHRfZmxhZ3MgfD0gYW1kZ3B1X3R0bV90dF9pc19yZWFkb25seSh0dG0p ID8KLQkJCQkwIDogcmFuZ2UtPmZsYWdzW0hNTV9QRk5fV1JJVEVdOwotCXJhbmdlLT5wZm5fZmxh Z3NfbWFzayA9IDA7Ci0JcmFuZ2UtPnBmbnMgPSBwZm5zOwotCXJhbmdlLT5zdGFydCA9IHN0YXJ0 OwotCXJhbmdlLT5lbmQgPSBzdGFydCArIHR0bS0+bnVtX3BhZ2VzICogUEFHRV9TSVpFOwotCi0J aG1tX3JhbmdlX3JlZ2lzdGVyKHJhbmdlLCBtaXJyb3IpOwotCi0JLyoKLQkgKiBKdXN0IHdhaXQg Zm9yIHJhbmdlIHRvIGJlIHZhbGlkLCBzYWZlIHRvIGlnbm9yZSByZXR1cm4gdmFsdWUgYXMgd2UK LQkgKiB3aWxsIHVzZSB0aGUgcmV0dXJuIHZhbHVlIG9mIGhtbV9yYW5nZV9mYXVsdCgpIGJlbG93 IHVuZGVyIHRoZQotCSAqIG1tYXBfc2VtIHRvIGFzY2VydGFpbiB0aGUgdmFsaWRpdHkgb2YgdGhl IHJhbmdlLgotCSAqLwotCWhtbV9yYW5nZV93YWl0X3VudGlsX3ZhbGlkKHJhbmdlLCBITU1fUkFO R0VfREVGQVVMVF9USU1FT1VUKTsKLQogCWRvd25fcmVhZCgmbW0tPm1tYXBfc2VtKTsKIAl2bWEg PSBmaW5kX3ZtYShtbSwgc3RhcnQpOwogCWlmICh1bmxpa2VseSghdm1hIHx8IHN0YXJ0IDwgdm1h LT52bV9zdGFydCkpIHsKQEAgLTg0NywxOCArODUyLDMxIEBAIGludCBhbWRncHVfdHRtX3R0X2dl dF91c2VyX3BhZ2VzKHN0cnVjdCBhbWRncHVfYm8gKmJvLCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKQog CQlyID0gLUVQRVJNOwogCQlnb3RvIG91dF91bmxvY2s7CiAJfQorCXVwX3JlYWQoJm1tLT5tbWFw X3NlbSk7CisJdGltZW91dCA9IGppZmZpZXMgKyBtc2Vjc190b19qaWZmaWVzKEhNTV9SQU5HRV9E RUZBVUxUX1RJTUVPVVQpOwogCityZXRyeToKKwlyYW5nZS0+bm90aWZpZXJfc2VxID0gbW11X3Jh bmdlX3JlYWRfYmVnaW4oJmJvLT5ub3RpZmllcik7CisKKwlkb3duX3JlYWQoJm1tLT5tbWFwX3Nl bSk7CiAJciA9IGhtbV9yYW5nZV9mYXVsdChyYW5nZSwgMCk7CiAJdXBfcmVhZCgmbW0tPm1tYXBf c2VtKTsKLQotCWlmICh1bmxpa2VseShyIDwgMCkpCisJaWYgKHVubGlrZWx5KHIgPD0gMCkpIHsK KwkJLyoKKwkJICogRklYTUU6IFRoaXMgdGltZW91dCBzaG91bGQgZW5jb21wYXNzIHRoZSByZXRy eSBmcm9tCisJCSAqIG1tdV9yYW5nZV9yZWFkX3JldHJ5KCkgYXMgd2VsbC4KKwkJICovCisJCWlm ICgociA9PSAwIHx8IHIgPT0gLUVCVVNZKSAmJiAhdGltZV9hZnRlcihqaWZmaWVzLCB0aW1lb3V0 KSkKKwkJCWdvdG8gcmV0cnk7CiAJCWdvdG8gb3V0X2ZyZWVfcGZuczsKKwl9CiAKIAlmb3IgKGkg PSAwOyBpIDwgdHRtLT5udW1fcGFnZXM7IGkrKykgewotCQlwYWdlc1tpXSA9IGhtbV9kZXZpY2Vf ZW50cnlfdG9fcGFnZShyYW5nZSwgcGZuc1tpXSk7CisJCS8qIEZJWE1FOiBUaGUgcGFnZXMgY2Fu bm90IGJlIHRvdWNoZWQgb3V0c2lkZSB0aGUgbm90aWZpZXJfbG9jayAqLworCQlwYWdlc1tpXSA9 IGhtbV9kZXZpY2VfZW50cnlfdG9fcGFnZShyYW5nZSwgcmFuZ2UtPnBmbnNbaV0pOwogCQlpZiAo dW5saWtlbHkoIXBhZ2VzW2ldKSkgewogCQkJcHJfZXJyKCJQYWdlIGZhdWx0IGZhaWxlZCBmb3Ig cGZuWyVsdV0gPSAweCVsbHhcbiIsCi0JCQkgICAgICAgaSwgcGZuc1tpXSk7CisJCQkgICAgICAg aSwgcmFuZ2UtPnBmbnNbaV0pOwogCQkJciA9IC1FTk9NRU07CiAKIAkJCWdvdG8gb3V0X2ZyZWVf cGZuczsKQEAgLTg3Myw4ICs4OTEsNyBAQCBpbnQgYW1kZ3B1X3R0bV90dF9nZXRfdXNlcl9wYWdl cyhzdHJ1Y3QgYW1kZ3B1X2JvICpibywgc3RydWN0IHBhZ2UgKipwYWdlcykKIG91dF91bmxvY2s6 CiAJdXBfcmVhZCgmbW0tPm1tYXBfc2VtKTsKIG91dF9mcmVlX3BmbnM6Ci0JaG1tX3JhbmdlX3Vu cmVnaXN0ZXIocmFuZ2UpOwotCWt2ZnJlZShwZm5zKTsKKwlrdmZyZWUocmFuZ2UtPnBmbnMpOwog b3V0X2ZyZWVfcmFuZ2VzOgogCWtmcmVlKHJhbmdlKTsKIG91dDoKQEAgLTkwMywxNSArOTIwLDE4 IEBAIGJvb2wgYW1kZ3B1X3R0bV90dF9nZXRfdXNlcl9wYWdlc19kb25lKHN0cnVjdCB0dG1fdHQg KnR0bSkKIAkJIk5vIHVzZXIgcGFnZXMgdG8gY2hlY2tcbiIpOwogCiAJaWYgKGd0dC0+cmFuZ2Up IHsKLQkJciA9IGhtbV9yYW5nZV92YWxpZChndHQtPnJhbmdlKTsKLQkJaG1tX3JhbmdlX3VucmVn aXN0ZXIoZ3R0LT5yYW5nZSk7Ci0KKwkJLyoKKwkJICogRklYTUU6IE11c3QgYWx3YXlzIGhvbGQg bm90aWZpZXJfbG9jayBmb3IgdGhpcywgYW5kIG11c3QKKwkJICogbm90IGlnbm9yZSB0aGUgcmV0 dXJuIGNvZGUuCisJCSAqLworCQlyID0gbW11X3JhbmdlX3JlYWRfcmV0cnkoZ3R0LT5yYW5nZS0+ bm90aWZpZXIsCisJCQkJCSBndHQtPnJhbmdlLT5ub3RpZmllcl9zZXEpOwogCQlrdmZyZWUoZ3R0 LT5yYW5nZS0+cGZucyk7CiAJCWtmcmVlKGd0dC0+cmFuZ2UpOwogCQlndHQtPnJhbmdlID0gTlVM TDsKIAl9CiAKLQlyZXR1cm4gcjsKKwlyZXR1cm4gIXI7CiB9CiAjZW5kaWYKIApAQCAtOTkyLDEw ICsxMDEyLDE4IEBAIHN0YXRpYyB2b2lkIGFtZGdwdV90dG1fdHRfdW5waW5fdXNlcnB0cihzdHJ1 Y3QgdHRtX3R0ICp0dG0pCiAJc2dfZnJlZV90YWJsZSh0dG0tPnNnKTsKIAogI2lmIElTX0VOQUJM RUQoQ09ORklHX0RSTV9BTURHUFVfVVNFUlBUUikKLQlpZiAoZ3R0LT5yYW5nZSAmJgotCSAgICB0 dG0tPnBhZ2VzWzBdID09IGhtbV9kZXZpY2VfZW50cnlfdG9fcGFnZShndHQtPnJhbmdlLAotCQkJ CQkJICAgICAgZ3R0LT5yYW5nZS0+cGZuc1swXSkpCi0JCVdBUk5fT05DRSgxLCAiTWlzc2luZyBn ZXRfdXNlcl9wYWdlX2RvbmVcbiIpOworCWlmIChndHQtPnJhbmdlKSB7CisJCXVuc2lnbmVkIGxv bmcgaTsKKworCQlmb3IgKGkgPSAwOyBpIDwgdHRtLT5udW1fcGFnZXM7IGkrKykgeworCQkJaWYg KHR0bS0+cGFnZXNbaV0gIT0KKwkJCQlobW1fZGV2aWNlX2VudHJ5X3RvX3BhZ2UoZ3R0LT5yYW5n ZSwKKwkJCQkJICAgICAgZ3R0LT5yYW5nZS0+cGZuc1tpXSkpCisJCQkJYnJlYWs7CisJCX0KKwor CQlXQVJOKChpID09IHR0bS0+bnVtX3BhZ2VzKSwgIk1pc3NpbmcgZ2V0X3VzZXJfcGFnZV9kb25l XG4iKTsKKwl9CiAjZW5kaWYKIH0KIAotLSAKMi4yMy4wCgpfX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZl bEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFp bG1hbi9saXN0aW5mby9kcmktZGV2ZWw= 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=-6.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 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 F23D0CA9ECF for ; Fri, 1 Nov 2019 18:35:09 +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 B3D3321734 for ; Fri, 1 Nov 2019 18:35:09 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=Mellanox.com header.i=@Mellanox.com header.b="SVt+wZWf" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org B3D3321734 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=mellanox.com 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 1iQbl2-0007oB-HU; Fri, 01 Nov 2019 18:34:48 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1iQbl0-0007o4-Hl for xen-devel@lists.xenproject.org; Fri, 01 Nov 2019 18:34:46 +0000 X-Inumbo-ID: 45e4d456-fcd6-11e9-a703-bc764e2007e4 Received: from EUR03-AM5-obe.outbound.protection.outlook.com (unknown [40.107.3.55]) by us1-rack-iad1.inumbo.com (Halon) with ESMTPS id 45e4d456-fcd6-11e9-a703-bc764e2007e4; Fri, 01 Nov 2019 18:34:44 +0000 (UTC) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=ID1czwKAJLJjyQE30wEVEYNJTUEtpI7Qkl24FrPbmXzaju2x222SlxL+11q/UDBdUsYq/Z2/UvM7LVb9kuBkmxRiPd+cG27JIs/5anPSLrc7aT3QaOrgcKpwM8i5z2Mu+VXBiwW83tEQNE5hJXvc+XrdZie0X3djGlK9VtdfANz/f9HA6j0tymIPobevmbRt5At9dvqKzmAlICQVL+C5KxnYAZUX1XsZDwxeeap+ii3cUXxe6a6LXB6Y9Z2CLEUZrgZfETf0RDCkTFrDGtTCi21B8u9CnCEWoplFgFw+ldPZqhwRHcWF5oC5uiLKC4BAedJEJltsMdcJCdpwIM9Ntw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=oXuOHTtipoYkfU5LykKoTmwF4/VlgjtrC3fuHXm5AjI=; b=Ua7vkWayi5JBuLpIWZDwMR6AU8/DU7mhA0xCZewXDuUeeom3QLuwm1csS/Ijbju+vpjF5akTq0bN0oEELJ/Kenn1bIACSln3frAm66Gi8wdxfLhRqTQ+N8LJ2dpvGazDJQ9x9GjhAtvjf0jWi9ZpO9RhsiChXpx2x0XeytZp+nweQxxTcQXG22ZsGL5xqq1RfQ6lSkx9Yu/VeSvwR2JR/7hDMR5ENG++Gq98I60v1tkMK9wUXyvj65jfuM/79MVATfvMzpRzm1WpRXaXg6xWxf5XH6Ldn86uJDqZtAtFu3WnXOsCN8l+OGWxqAgNf56bqEnegkHrJwtC6tD56Ps3+g== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=mellanox.com; dmarc=pass action=none header.from=mellanox.com; dkim=pass header.d=mellanox.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=Mellanox.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=oXuOHTtipoYkfU5LykKoTmwF4/VlgjtrC3fuHXm5AjI=; b=SVt+wZWfddkHw40mdehiJvucDKT2KvzDlrQP55Ml/4rWjve2GuEe2xqxPo73B2fRqrFrHqK5bx8O/xIaihWeqPjCshAWTaYAbnXeNPUgKNFCym3gLpiowXTwCoZckm0xfZGrKXjiAUW/JE5DWbv0znRymHJP/wjis3b6AfDHIX8= Received: from VI1PR05MB4141.eurprd05.prod.outlook.com (52.133.14.15) by VI1PR05MB4416.eurprd05.prod.outlook.com (52.134.123.146) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.2387.22; Fri, 1 Nov 2019 18:34:40 +0000 Received: from VI1PR05MB4141.eurprd05.prod.outlook.com ([fe80::b179:e8bf:22d4:bf8d]) by VI1PR05MB4141.eurprd05.prod.outlook.com ([fe80::b179:e8bf:22d4:bf8d%5]) with mapi id 15.20.2387.028; Fri, 1 Nov 2019 18:34:40 +0000 From: Jason Gunthorpe To: "Yang, Philip" Thread-Topic: [PATCH v2a 14/15] drm/amdgpu: Use mmu_range_notifier instead of hmm_mirror Thread-Index: AQHVkOMFaRcJHQRrK0S6ryutY4Fnpg== Date: Fri, 1 Nov 2019 18:34:40 +0000 Message-ID: <20191101183435.GR22766@mellanox.com> References: <20191028201032.6352-1-jgg@ziepe.ca> <20191028201032.6352-15-jgg@ziepe.ca> <20191029192544.GU22766@mellanox.com> <30b2f569-bf7a-5166-c98d-4a4a13d1351f@amd.com> In-Reply-To: <30b2f569-bf7a-5166-c98d-4a4a13d1351f@amd.com> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-clientproxiedby: BN4PR12CA0013.namprd12.prod.outlook.com (2603:10b6:403:2::23) To VI1PR05MB4141.eurprd05.prod.outlook.com (2603:10a6:803:44::15) authentication-results: spf=none (sender IP is ) smtp.mailfrom=jgg@mellanox.com; x-ms-exchange-messagesentrepresentingtype: 1 x-originating-ip: [142.162.113.180] x-ms-publictraffictype: Email x-ms-office365-filtering-ht: Tenant x-ms-office365-filtering-correlation-id: 7fd1dc84-23d9-4c30-3490-08d75efa27d3 x-ms-traffictypediagnostic: VI1PR05MB4416: x-microsoft-antispam-prvs: x-ms-oob-tlc-oobclassifiers: OLM:6430; x-forefront-prvs: 020877E0CB x-forefront-antispam-report: SFV:NSPM; SFS:(10009020)(4636009)(366004)(136003)(396003)(376002)(39860400002)(346002)(199004)(189003)(36756003)(81156014)(86362001)(102836004)(54906003)(476003)(11346002)(446003)(14454004)(6916009)(6512007)(486006)(2616005)(99286004)(14444005)(6436002)(66066001)(256004)(6486002)(6116002)(2906002)(8676002)(25786009)(71200400001)(3846002)(4326008)(478600001)(71190400001)(33656002)(30864003)(5660300002)(66946007)(81166006)(8936002)(7736002)(52116002)(66556008)(66476007)(386003)(6506007)(1076003)(316002)(66446008)(186003)(305945005)(26005)(7416002)(76176011)(64756008); DIR:OUT; SFP:1101; SCL:1; SRVR:VI1PR05MB4416; H:VI1PR05MB4141.eurprd05.prod.outlook.com; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; A:1; MX:1; received-spf: None (protection.outlook.com: mellanox.com does not designate permitted sender hosts) x-ms-exchange-senderadcheck: 1 x-microsoft-antispam: BCL:0; x-microsoft-antispam-message-info: fWNQ+BZa7hfC/4uLDbkIzf190FXkgTVGRQKdPvrvbvJpoBtJPgrsM7NGgZQ1QolaRtrYNrap2uwCvyZBwc+s1RJrMJs0W4wt38pjuaPPJHfnwuNoqyOnrYlMsQwNybX+mi4Q5WE4Pg0wiaVGQDLKd/jzIznyDxANtLOIJkay4xVDUZuqQJg0ZJ5lwxg9w7eTS8jfnmflWgEN1kT2Vh17iuWWQZ3VwGzrMwd3SehhT5moiR+3hN8s058c3TYlgBggqYdEGdDYMmVxzwWbZ1hRnOtvnkbCjHalAFCEwBe2F4KYWoOr44uRyLV32bUbwHLWYknPvscKcWD2/FgOmTHQPiVPsk9o16OhK4JhXmP+uYkdvjkbZgWiPYIElS4dXYek7ygn7Xc0XKeD/JE/rH5lLTVBDLeo3+S2wC+qVP+/j2+4kf1uzHXjbfJLmDORfGdY x-ms-exchange-transport-forked: True Content-ID: MIME-Version: 1.0 X-OriginatorOrg: Mellanox.com X-MS-Exchange-CrossTenant-Network-Message-Id: 7fd1dc84-23d9-4c30-3490-08d75efa27d3 X-MS-Exchange-CrossTenant-originalarrivaltime: 01 Nov 2019 18:34:40.7437 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: a652971c-7d2e-4d9b-a6a4-d149256f461b X-MS-Exchange-CrossTenant-mailboxtype: HOSTED X-MS-Exchange-CrossTenant-userprincipalname: 6w7Cky8H25cOW4Dxqgj7Dr4BIQtw+qoZ/7TjiXWzab8P8ekkpF8unK6sBjda6ZrGlvHzuK1g8e6b2fcbAMO5Iw== X-MS-Exchange-Transport-CrossTenantHeadersStamped: VI1PR05MB4416 Subject: [Xen-devel] [PATCH v2a 14/15] drm/amdgpu: Use mmu_range_notifier instead of hmm_mirror X-BeenThere: xen-devel@lists.xenproject.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Cc: "nouveau@lists.freedesktop.org" , "dri-devel@lists.freedesktop.org" , "linux-mm@kvack.org" , "Zhou, David\(ChunMing\)" , Stefano Stabellini , Oleksandr Andrushchenko , "linux-rdma@vger.kernel.org" , "amd-gfx@lists.freedesktop.org" , Christoph Hellwig , Ben Skeggs , "xen-devel@lists.xenproject.org" , Ralph Campbell , John Hubbard , Jerome Glisse , Dennis Dalessandro , Boris Ostrovsky , Petr Cvek , Juergen Gross , Mike Marciniszyn , "Kuehling, Felix" , "Deucher, Alexander" , "Koenig, Christian" Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" Q29udmVydCB0aGUgY29sbGlzaW9uLXJldHJ5IGxvY2sgYXJvdW5kIGhtbV9yYW5nZV9mYXVsdCB0 byB1c2UgdGhlIG9uZSBub3cKcHJvdmlkZWQgYnkgdGhlIG1tdV9yYW5nZSBub3RpZmllci4KCkFs dGhvdWdoIHRoaXMgZHJpdmVyIGRvZXMgbm90IHNlZW0gdG8gdXNlIHRoZSBjb2xsaXNpb24gcmV0 cnkgbG9jayB0aGF0CmhtbSBwcm92aWRlcyBjb3JyZWN0bHksIGl0IGNhbiBzdGlsbCBiZSBjb252 ZXJ0ZWQgb3ZlciB0byB1c2UgdGhlCm1tdV9yYW5nZV9ub3RpZmllciBhcGkgaW5zdGVhZCBvZiBo bW1fbWlycm9yIHdpdGhvdXQgdG9vIG11Y2ggdHJvdWJsZS4KClRoaXMgYWxzbyBkZWxldGVzIGFu b3RoZXIgcGxhY2Ugd2hlcmUgYSBkcml2ZXIgaXMgYXNzb2NpYXRpbmcgYWRkaXRpb25hbApkYXRh IChzdHJ1Y3QgYW1kZ3B1X21uKSB3aXRoIGEgbW11X3N0cnVjdC4KClNpZ25lZC1vZmYtYnk6IFBo aWxpcCBZYW5nIDxQaGlsaXAuWWFuZ0BhbWQuY29tPgpSZXZpZXdlZC1ieTogUGhpbGlwIFlhbmcg PFBoaWxpcC5ZYW5nQGFtZC5jb20+ClRlc3RlZC1ieTogUGhpbGlwIFlhbmcgPFBoaWxpcC5ZYW5n QGFtZC5jb20+ClNpZ25lZC1vZmYtYnk6IEphc29uIEd1bnRob3JwZSA8amdnQG1lbGxhbm94LmNv bT4KLS0tCiAuLi4vZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYyAgfCAg IDQgKwogZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2NzLmMgICAgICAgIHwgIDE0 ICstCiBkcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uYyAgICAgICAgfCAxNTAg KystLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4u aCAgICAgICAgfCAgNDkgLS0tLS0tCiBkcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVf dHRtLmMgICAgICAgfCAxMTYgKysrKysrKysrLS0tLS0KIDUgZmlsZXMgY2hhbmdlZCwgOTYgaW5z ZXJ0aW9ucygrKSwgMjM3IGRlbGV0aW9ucygtKQoKUGhpbGlwLCBoZXJlIGlzIHdoYXQgaXQgbG9v cyBsaWtlIGFmdGVyIGNvbWJpbmluZyB0aGUgdHdvIHBhdGNoZXMsIHRoYW5rcwoKZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYyBiL2Ry aXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYwppbmRleCA0Nzcw MDMwMmEwOGI3Zi4uMWJjZWRiOWI0NzdkY2UgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9h bWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1k L2FtZGdwdS9hbWRncHVfYW1ka2ZkX2dwdXZtLmMKQEAgLTE3MzgsNiArMTczOCwxMCBAQCBzdGF0 aWMgaW50IHVwZGF0ZV9pbnZhbGlkX3VzZXJfcGFnZXMoc3RydWN0IGFtZGtmZF9wcm9jZXNzX2lu Zm8gKnByb2Nlc3NfaW5mbywKIAkJCXJldHVybiByZXQ7CiAJCX0KIAorCQkvKgorCQkgKiBGSVhN RTogQ2Fubm90IGlnbm9yZSB0aGUgcmV0dXJuIGNvZGUsIG11c3QgaG9sZAorCQkgKiBub3RpZmll cl9sb2NrCisJCSAqLwogCQlhbWRncHVfdHRtX3R0X2dldF91c2VyX3BhZ2VzX2RvbmUoYm8tPnRi by50dG0pOwogCiAJCS8qIE1hcmsgdGhlIEJPIGFzIHZhbGlkIHVubGVzcyBpdCB3YXMgaW52YWxp ZGF0ZWQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9jcy5j IGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2NzLmMKaW5kZXggODI4MjNkOWE4 YmE4ODcuLjIyYzk4OWJjYTc1MTRjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2Ft ZGdwdS9hbWRncHVfY3MuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVf Y3MuYwpAQCAtNjAzLDggKzYwMyw2IEBAIHN0YXRpYyBpbnQgYW1kZ3B1X2NzX3BhcnNlcl9ib3Mo c3RydWN0IGFtZGdwdV9jc19wYXJzZXIgKnAsCiAJCWUtPnR2Lm51bV9zaGFyZWQgPSAyOwogCiAJ YW1kZ3B1X2JvX2xpc3RfZ2V0X2xpc3QocC0+Ym9fbGlzdCwgJnAtPnZhbGlkYXRlZCk7Ci0JaWYg KHAtPmJvX2xpc3QtPmZpcnN0X3VzZXJwdHIgIT0gcC0+Ym9fbGlzdC0+bnVtX2VudHJpZXMpCi0J CXAtPm1uID0gYW1kZ3B1X21uX2dldChwLT5hZGV2LCBBTURHUFVfTU5fVFlQRV9HRlgpOwogCiAJ SU5JVF9MSVNUX0hFQUQoJmR1cGxpY2F0ZXMpOwogCWFtZGdwdV92bV9nZXRfcGRfYm8oJmZwcml2 LT52bSwgJnAtPnZhbGlkYXRlZCwgJnAtPnZtX3BkKTsKQEAgLTEyODcsMTEgKzEyODUsMTEgQEAg c3RhdGljIGludCBhbWRncHVfY3Nfc3VibWl0KHN0cnVjdCBhbWRncHVfY3NfcGFyc2VyICpwLAog CWlmIChyKQogCQlnb3RvIGVycm9yX3VubG9jazsKIAotCS8qIE5vIG1lbW9yeSBhbGxvY2F0aW9u IGlzIGFsbG93ZWQgd2hpbGUgaG9sZGluZyB0aGUgbW4gbG9jay4KLQkgKiBwLT5tbiBpcyBob2xk IHVudGlsIGFtZGdwdV9jc19zdWJtaXQgaXMgZmluaXNoZWQgYW5kIGZlbmNlIGlzIGFkZGVkCi0J ICogdG8gQk9zLgorCS8qIE5vIG1lbW9yeSBhbGxvY2F0aW9uIGlzIGFsbG93ZWQgd2hpbGUgaG9s ZGluZyB0aGUgbm90aWZpZXIgbG9jay4KKwkgKiBUaGUgbG9jayBpcyBoZWxkIHVudGlsIGFtZGdw dV9jc19zdWJtaXQgaXMgZmluaXNoZWQgYW5kIGZlbmNlIGlzCisJICogYWRkZWQgdG8gQk9zLgog CSAqLwotCWFtZGdwdV9tbl9sb2NrKHAtPm1uKTsKKwltdXRleF9sb2NrKCZwLT5hZGV2LT5ub3Rp Zmllcl9sb2NrKTsKIAogCS8qIElmIHVzZXJwdHIgYXJlIGludmFsaWRhdGVkIGFmdGVyIGFtZGdw dV9jc19wYXJzZXJfYm9zKCksIHJldHVybgogCSAqIC1FQUdBSU4sIGRybUlvY3RsIGluIGxpYmRy bSB3aWxsIHJlc3RhcnQgdGhlIGFtZGdwdV9jc19pb2N0bC4KQEAgLTEzMzQsMTMgKzEzMzIsMTMg QEAgc3RhdGljIGludCBhbWRncHVfY3Nfc3VibWl0KHN0cnVjdCBhbWRncHVfY3NfcGFyc2VyICpw LAogCWFtZGdwdV92bV9tb3ZlX3RvX2xydV90YWlsKHAtPmFkZXYsICZmcHJpdi0+dm0pOwogCiAJ dHRtX2V1X2ZlbmNlX2J1ZmZlcl9vYmplY3RzKCZwLT50aWNrZXQsICZwLT52YWxpZGF0ZWQsIHAt PmZlbmNlKTsKLQlhbWRncHVfbW5fdW5sb2NrKHAtPm1uKTsKKwltdXRleF91bmxvY2soJnAtPmFk ZXYtPm5vdGlmaWVyX2xvY2spOwogCiAJcmV0dXJuIDA7CiAKIGVycm9yX2Fib3J0OgogCWRybV9z Y2hlZF9qb2JfY2xlYW51cCgmam9iLT5iYXNlKTsKLQlhbWRncHVfbW5fdW5sb2NrKHAtPm1uKTsK KwltdXRleF91bmxvY2soJnAtPmFkZXYtPm5vdGlmaWVyX2xvY2spOwogCiBlcnJvcl91bmxvY2s6 CiAJYW1kZ3B1X2pvYl9mcmVlKGpvYik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1k L2FtZGdwdS9hbWRncHVfbW4uYyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9t bi5jCmluZGV4IGFjNzQzMjBiNzFlNGU3Li5mN2JlMzQ5MDdlNTRmNSAxMDA2NDQKLS0tIGEvZHJp dmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmMKKysrIGIvZHJpdmVycy9ncHUvZHJt L2FtZC9hbWRncHUvYW1kZ3B1X21uLmMKQEAgLTUwLDI4ICs1MCw2IEBACiAjaW5jbHVkZSAiYW1k Z3B1LmgiCiAjaW5jbHVkZSAiYW1kZ3B1X2FtZGtmZC5oIgogCi0vKioKLSAqIGFtZGdwdV9tbl9s b2NrIC0gdGFrZSB0aGUgd3JpdGUgc2lkZSBsb2NrIGZvciB0aGlzIG5vdGlmaWVyCi0gKgotICog QG1uOiBvdXIgbm90aWZpZXIKLSAqLwotdm9pZCBhbWRncHVfbW5fbG9jayhzdHJ1Y3QgYW1kZ3B1 X21uICptbikKLXsKLQlpZiAobW4pCi0JCWRvd25fd3JpdGUoJm1uLT5sb2NrKTsKLX0KLQotLyoq Ci0gKiBhbWRncHVfbW5fdW5sb2NrIC0gZHJvcCB0aGUgd3JpdGUgc2lkZSBsb2NrIGZvciB0aGlz IG5vdGlmaWVyCi0gKgotICogQG1uOiBvdXIgbm90aWZpZXIKLSAqLwotdm9pZCBhbWRncHVfbW5f dW5sb2NrKHN0cnVjdCBhbWRncHVfbW4gKm1uKQotewotCWlmIChtbikKLQkJdXBfd3JpdGUoJm1u LT5sb2NrKTsKLX0KLQogLyoqCiAgKiBhbWRncHVfbW5faW52YWxpZGF0ZV9nZnggLSBjYWxsYmFj ayB0byBub3RpZnkgYWJvdXQgbW0gY2hhbmdlCiAgKgpAQCAtODIsMTYgKzYwLDIwIEBAIHZvaWQg YW1kZ3B1X21uX3VubG9jayhzdHJ1Y3QgYW1kZ3B1X21uICptbikKICAqIHBvdGVudGlhbGx5IGRp cnR5LgogICovCiBzdGF0aWMgYm9vbCBhbWRncHVfbW5faW52YWxpZGF0ZV9nZngoc3RydWN0IG1t dV9yYW5nZV9ub3RpZmllciAqbXJuLAotCQkJCSAgICAgY29uc3Qgc3RydWN0IG1tdV9ub3RpZmll cl9yYW5nZSAqcmFuZ2UpCisJCQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3Jhbmdl ICpyYW5nZSwKKwkJCQkgICAgIHVuc2lnbmVkIGxvbmcgY3VyX3NlcSkKIHsKIAlzdHJ1Y3QgYW1k Z3B1X2JvICpibyA9IGNvbnRhaW5lcl9vZihtcm4sIHN0cnVjdCBhbWRncHVfYm8sIG5vdGlmaWVy KTsKIAlzdHJ1Y3QgYW1kZ3B1X2RldmljZSAqYWRldiA9IGFtZGdwdV90dG1fYWRldihiby0+dGJv LmJkZXYpOwogCWxvbmcgcjsKIAotCWlmICghbW11X25vdGlmaWVyX3JhbmdlX2Jsb2NrYWJsZShy YW5nZSkpCisJaWYgKG1tdV9ub3RpZmllcl9yYW5nZV9ibG9ja2FibGUocmFuZ2UpKQorCQltdXRl eF9sb2NrKCZhZGV2LT5ub3RpZmllcl9sb2NrKTsKKwllbHNlIGlmICghbXV0ZXhfdHJ5bG9jaygm YWRldi0+bm90aWZpZXJfbG9jaykpCiAJCXJldHVybiBmYWxzZTsKIAotCW11dGV4X2xvY2soJmFk ZXYtPm5vdGlmaWVyX2xvY2spOworCW1tdV9yYW5nZV9zZXRfc2VxKG1ybiwgY3VyX3NlcSk7CisK IAlyID0gZG1hX3Jlc3Zfd2FpdF90aW1lb3V0X3JjdShiby0+dGJvLmJhc2UucmVzdiwgdHJ1ZSwg ZmFsc2UsCiAJCQkJICAgICAgTUFYX1NDSEVEVUxFX1RJTUVPVVQpOwogCW11dGV4X3VubG9jaygm YWRldi0+bm90aWZpZXJfbG9jayk7CkBAIC0xMTQsMTUgKzk2LDE5IEBAIHN0YXRpYyBjb25zdCBz dHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyX29wcyBhbWRncHVfbW5fZ2Z4X29wcyA9IHsKICAqIGV2 aWN0aW5nIGFsbCB1c2VyLW1vZGUgcXVldWVzIG9mIHRoZSBwcm9jZXNzLgogICovCiBzdGF0aWMg Ym9vbCBhbWRncHVfbW5faW52YWxpZGF0ZV9oc2Eoc3RydWN0IG1tdV9yYW5nZV9ub3RpZmllciAq bXJuLAotCQkJCSAgICAgY29uc3Qgc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAqcmFuZ2UpCisJ CQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICpyYW5nZSwKKwkJCQkgICAg IHVuc2lnbmVkIGxvbmcgY3VyX3NlcSkKIHsKIAlzdHJ1Y3QgYW1kZ3B1X2JvICpibyA9IGNvbnRh aW5lcl9vZihtcm4sIHN0cnVjdCBhbWRncHVfYm8sIG5vdGlmaWVyKTsKIAlzdHJ1Y3QgYW1kZ3B1 X2RldmljZSAqYWRldiA9IGFtZGdwdV90dG1fYWRldihiby0+dGJvLmJkZXYpOwogCi0JaWYgKCFt bXVfbm90aWZpZXJfcmFuZ2VfYmxvY2thYmxlKHJhbmdlKSkKKwlpZiAobW11X25vdGlmaWVyX3Jh bmdlX2Jsb2NrYWJsZShyYW5nZSkpCisJCW11dGV4X2xvY2soJmFkZXYtPm5vdGlmaWVyX2xvY2sp OworCWVsc2UgaWYgKCFtdXRleF90cnlsb2NrKCZhZGV2LT5ub3RpZmllcl9sb2NrKSkKIAkJcmV0 dXJuIGZhbHNlOwogCi0JbXV0ZXhfbG9jaygmYWRldi0+bm90aWZpZXJfbG9jayk7CisJbW11X3Jh bmdlX3NldF9zZXEobXJuLCBjdXJfc2VxKTsKKwogCWFtZGdwdV9hbWRrZmRfZXZpY3RfdXNlcnB0 cihiby0+a2ZkX2JvLCBiby0+bm90aWZpZXIubW0pOwogCW11dGV4X3VubG9jaygmYWRldi0+bm90 aWZpZXJfbG9jayk7CiAKQEAgLTEzMyw5MiArMTE5LDYgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBt bXVfcmFuZ2Vfbm90aWZpZXJfb3BzIGFtZGdwdV9tbl9oc2Ffb3BzID0gewogCS5pbnZhbGlkYXRl ID0gYW1kZ3B1X21uX2ludmFsaWRhdGVfaHNhLAogfTsKIAotc3RhdGljIGludCBhbWRncHVfbW5f c3luY19wYWdldGFibGVzKHN0cnVjdCBobW1fbWlycm9yICptaXJyb3IsCi0JCQkJICAgICBjb25z dCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICp1cGRhdGUpCi17Ci0Jc3RydWN0IGFtZGdwdV9t biAqYW1uID0gY29udGFpbmVyX29mKG1pcnJvciwgc3RydWN0IGFtZGdwdV9tbiwgbWlycm9yKTsK LQotCWlmICghbW11X25vdGlmaWVyX3JhbmdlX2Jsb2NrYWJsZSh1cGRhdGUpKQotCQlyZXR1cm4g LUVBR0FJTjsKLQotCWRvd25fcmVhZCgmYW1uLT5sb2NrKTsKLQl1cF9yZWFkKCZhbW4tPmxvY2sp OwotCXJldHVybiAwOwotfQotCi0vKiBMb3cgYml0cyBvZiBhbnkgcmVhc29uYWJsZSBtbSBwb2lu dGVyIHdpbGwgYmUgdW51c2VkIGR1ZSB0byBzdHJ1Y3QKLSAqIGFsaWdubWVudC4gVXNlIHRoZXNl IGJpdHMgdG8gbWFrZSBhIHVuaXF1ZSBrZXkgZnJvbSB0aGUgbW0gcG9pbnRlcgotICogYW5kIG5v dGlmaWVyIHR5cGUuCi0gKi8KLSNkZWZpbmUgQU1ER1BVX01OX0tFWShtbSwgdHlwZSkgKCh1bnNp Z25lZCBsb25nKShtbSkgKyAodHlwZSkpCi0KLXN0YXRpYyBzdHJ1Y3QgaG1tX21pcnJvcl9vcHMg YW1kZ3B1X2htbV9taXJyb3Jfb3BzW10gPSB7Ci0JW0FNREdQVV9NTl9UWVBFX0dGWF0gPSB7Ci0J CS5zeW5jX2NwdV9kZXZpY2VfcGFnZXRhYmxlcyA9IGFtZGdwdV9tbl9zeW5jX3BhZ2V0YWJsZXMs Ci0JfSwKLQlbQU1ER1BVX01OX1RZUEVfSFNBXSA9IHsKLQkJLnN5bmNfY3B1X2RldmljZV9wYWdl dGFibGVzID0gYW1kZ3B1X21uX3N5bmNfcGFnZXRhYmxlcywKLQl9LAotfTsKLQotLyoqCi0gKiBh bWRncHVfbW5fZ2V0IC0gY3JlYXRlIEhNTSBtaXJyb3IgY29udGV4dAotICoKLSAqIEBhZGV2OiBh bWRncHUgZGV2aWNlIHBvaW50ZXIKLSAqIEB0eXBlOiB0eXBlIG9mIE1NVSBub3RpZmllciBjb250 ZXh0Ci0gKgotICogQ3JlYXRlcyBhIEhNTSBtaXJyb3IgY29udGV4dCBmb3IgY3VycmVudC0+bW0u Ci0gKi8KLXN0cnVjdCBhbWRncHVfbW4gKmFtZGdwdV9tbl9nZXQoc3RydWN0IGFtZGdwdV9kZXZp Y2UgKmFkZXYsCi0JCQkJZW51bSBhbWRncHVfbW5fdHlwZSB0eXBlKQotewotCXN0cnVjdCBtbV9z dHJ1Y3QgKm1tID0gY3VycmVudC0+bW07Ci0Jc3RydWN0IGFtZGdwdV9tbiAqYW1uOwotCXVuc2ln bmVkIGxvbmcga2V5ID0gQU1ER1BVX01OX0tFWShtbSwgdHlwZSk7Ci0JaW50IHI7Ci0KLQltdXRl eF9sb2NrKCZhZGV2LT5tbl9sb2NrKTsKLQlpZiAoZG93bl93cml0ZV9raWxsYWJsZSgmbW0tPm1t YXBfc2VtKSkgewotCQltdXRleF91bmxvY2soJmFkZXYtPm1uX2xvY2spOwotCQlyZXR1cm4gRVJS X1BUUigtRUlOVFIpOwotCX0KLQotCWhhc2hfZm9yX2VhY2hfcG9zc2libGUoYWRldi0+bW5faGFz aCwgYW1uLCBub2RlLCBrZXkpCi0JCWlmIChBTURHUFVfTU5fS0VZKGFtbi0+bWlycm9yLmhtbS0+ bW11X25vdGlmaWVyLm1tLAotCQkJCSAgYW1uLT50eXBlKSA9PSBrZXkpCi0JCQlnb3RvIHJlbGVh c2VfbG9ja3M7Ci0KLQlhbW4gPSBremFsbG9jKHNpemVvZigqYW1uKSwgR0ZQX0tFUk5FTCk7Ci0J aWYgKCFhbW4pIHsKLQkJYW1uID0gRVJSX1BUUigtRU5PTUVNKTsKLQkJZ290byByZWxlYXNlX2xv Y2tzOwotCX0KLQotCWFtbi0+YWRldiA9IGFkZXY7Ci0JaW5pdF9yd3NlbSgmYW1uLT5sb2NrKTsK LQlhbW4tPnR5cGUgPSB0eXBlOwotCi0JYW1uLT5taXJyb3Iub3BzID0gJmFtZGdwdV9obW1fbWly cm9yX29wc1t0eXBlXTsKLQlyID0gaG1tX21pcnJvcl9yZWdpc3RlcigmYW1uLT5taXJyb3IsIG1t KTsKLQlpZiAocikKLQkJZ290byBmcmVlX2FtbjsKLQotCWhhc2hfYWRkKGFkZXYtPm1uX2hhc2gs ICZhbW4tPm5vZGUsIEFNREdQVV9NTl9LRVkobW0sIHR5cGUpKTsKLQotcmVsZWFzZV9sb2NrczoK LQl1cF93cml0ZSgmbW0tPm1tYXBfc2VtKTsKLQltdXRleF91bmxvY2soJmFkZXYtPm1uX2xvY2sp OwotCi0JcmV0dXJuIGFtbjsKLQotZnJlZV9hbW46Ci0JdXBfd3JpdGUoJm1tLT5tbWFwX3NlbSk7 Ci0JbXV0ZXhfdW5sb2NrKCZhZGV2LT5tbl9sb2NrKTsKLQlrZnJlZShhbW4pOwotCi0JcmV0dXJu IEVSUl9QVFIocik7Ci19Ci0KIC8qKgogICogYW1kZ3B1X21uX3JlZ2lzdGVyIC0gcmVnaXN0ZXIg YSBCTyBmb3Igbm90aWZpZXIgdXBkYXRlcwogICoKQEAgLTI1MywyNSArMTUzLDMgQEAgdm9pZCBh bWRncHVfbW5fdW5yZWdpc3RlcihzdHJ1Y3QgYW1kZ3B1X2JvICpibykKIAltbXVfcmFuZ2Vfbm90 aWZpZXJfcmVtb3ZlKCZiby0+bm90aWZpZXIpOwogCWJvLT5ub3RpZmllci5tbSA9IE5VTEw7CiB9 Ci0KLS8qIGZsYWdzIHVzZWQgYnkgSE1NIGludGVybmFsLCBub3QgcmVsYXRlZCB0byBDUFUvR1BV IFBURSBmbGFncyAqLwotc3RhdGljIGNvbnN0IHVpbnQ2NF90IGhtbV9yYW5nZV9mbGFnc1tITU1f UEZOX0ZMQUdfTUFYXSA9IHsKLQkJKDEgPDwgMCksIC8qIEhNTV9QRk5fVkFMSUQgKi8KLQkJKDEg PDwgMSksIC8qIEhNTV9QRk5fV1JJVEUgKi8KLQkJMCAvKiBITU1fUEZOX0RFVklDRV9QUklWQVRF ICovCi19OwotCi1zdGF0aWMgY29uc3QgdWludDY0X3QgaG1tX3JhbmdlX3ZhbHVlc1tITU1fUEZO X1ZBTFVFX01BWF0gPSB7Ci0JCTB4ZmZmZmZmZmZmZmZmZmZmZVVMLCAvKiBITU1fUEZOX0VSUk9S ICovCi0JCTAsIC8qIEhNTV9QRk5fTk9ORSAqLwotCQkweGZmZmZmZmZmZmZmZmZmZmNVTCAvKiBI TU1fUEZOX1NQRUNJQUwgKi8KLX07Ci0KLXZvaWQgYW1kZ3B1X2htbV9pbml0X3JhbmdlKHN0cnVj dCBobW1fcmFuZ2UgKnJhbmdlKQotewotCWlmIChyYW5nZSkgewotCQlyYW5nZS0+ZmxhZ3MgPSBo bW1fcmFuZ2VfZmxhZ3M7Ci0JCXJhbmdlLT52YWx1ZXMgPSBobW1fcmFuZ2VfdmFsdWVzOwotCQly YW5nZS0+cGZuX3NoaWZ0ID0gUEFHRV9TSElGVDsKLQl9Ci19CmRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uaCBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1k Z3B1L2FtZGdwdV9tbi5oCmluZGV4IGQ3M2FiMjk0N2IyMmIyLi5hMjkyMjM4Zjc1ZWJhZSAxMDA2 NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmgKKysrIGIvZHJp dmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmgKQEAgLTMwLDU5ICszMCwxMCBAQAog I2luY2x1ZGUgPGxpbnV4L3dvcmtxdWV1ZS5oPgogI2luY2x1ZGUgPGxpbnV4L2ludGVydmFsX3Ry ZWUuaD4KIAotZW51bSBhbWRncHVfbW5fdHlwZSB7Ci0JQU1ER1BVX01OX1RZUEVfR0ZYLAotCUFN REdQVV9NTl9UWVBFX0hTQSwKLX07Ci0KLS8qKgotICogc3RydWN0IGFtZGdwdV9tbgotICoKLSAq IEBhZGV2OiBhbWRncHUgZGV2aWNlIHBvaW50ZXIKLSAqIEB0eXBlOiB0eXBlIG9mIE1NVSBub3Rp ZmllcgotICogQHdvcms6IGRlc3RydWN0aW9uIHdvcmsgaXRlbQotICogQG5vZGU6IGhhc2ggdGFi bGUgbm9kZSB0byBmaW5kIHN0cnVjdHVyZSBieSBhZGV2IGFuZCBtbgotICogQGxvY2s6IHJ3IHNl bWFwaG9yZSBwcm90ZWN0aW5nIHRoZSBub3RpZmllciBub2RlcwotICogQG1pcnJvcjogSE1NIG1p cnJvciBmdW5jdGlvbiBzdXBwb3J0Ci0gKgotICogRGF0YSBmb3IgZWFjaCBhbWRncHUgZGV2aWNl IGFuZCBwcm9jZXNzIGFkZHJlc3Mgc3BhY2UuCi0gKi8KLXN0cnVjdCBhbWRncHVfbW4gewotCS8q IGNvbnN0YW50IGFmdGVyIGluaXRpYWxpc2F0aW9uICovCi0Jc3RydWN0IGFtZGdwdV9kZXZpY2UJ KmFkZXY7Ci0JZW51bSBhbWRncHVfbW5fdHlwZQl0eXBlOwotCi0JLyogb25seSB1c2VkIG9uIGRl c3RydWN0aW9uICovCi0Jc3RydWN0IHdvcmtfc3RydWN0CXdvcms7Ci0KLQkvKiBwcm90ZWN0ZWQg YnkgYWRldi0+bW5fbG9jayAqLwotCXN0cnVjdCBobGlzdF9ub2RlCW5vZGU7Ci0KLQkvKiBvYmpl Y3RzIHByb3RlY3RlZCBieSBsb2NrICovCi0Jc3RydWN0IHJ3X3NlbWFwaG9yZQlsb2NrOwotCi0j aWZkZWYgQ09ORklHX0hNTV9NSVJST1IKLQkvKiBITU0gbWlycm9yICovCi0Jc3RydWN0IGhtbV9t aXJyb3IJbWlycm9yOwotI2VuZGlmCi19OwotCiAjaWYgZGVmaW5lZChDT05GSUdfSE1NX01JUlJP UikKLXZvaWQgYW1kZ3B1X21uX2xvY2soc3RydWN0IGFtZGdwdV9tbiAqbW4pOwotdm9pZCBhbWRn cHVfbW5fdW5sb2NrKHN0cnVjdCBhbWRncHVfbW4gKm1uKTsKLXN0cnVjdCBhbWRncHVfbW4gKmFt ZGdwdV9tbl9nZXQoc3RydWN0IGFtZGdwdV9kZXZpY2UgKmFkZXYsCi0JCQkJZW51bSBhbWRncHVf bW5fdHlwZSB0eXBlKTsKIGludCBhbWRncHVfbW5fcmVnaXN0ZXIoc3RydWN0IGFtZGdwdV9ibyAq Ym8sIHVuc2lnbmVkIGxvbmcgYWRkcik7CiB2b2lkIGFtZGdwdV9tbl91bnJlZ2lzdGVyKHN0cnVj dCBhbWRncHVfYm8gKmJvKTsKLXZvaWQgYW1kZ3B1X2htbV9pbml0X3JhbmdlKHN0cnVjdCBobW1f cmFuZ2UgKnJhbmdlKTsKICNlbHNlCi1zdGF0aWMgaW5saW5lIHZvaWQgYW1kZ3B1X21uX2xvY2so c3RydWN0IGFtZGdwdV9tbiAqbW4pIHt9Ci1zdGF0aWMgaW5saW5lIHZvaWQgYW1kZ3B1X21uX3Vu bG9jayhzdHJ1Y3QgYW1kZ3B1X21uICptbikge30KLXN0YXRpYyBpbmxpbmUgc3RydWN0IGFtZGdw dV9tbiAqYW1kZ3B1X21uX2dldChzdHJ1Y3QgYW1kZ3B1X2RldmljZSAqYWRldiwKLQkJCQkJICAg ICAgZW51bSBhbWRncHVfbW5fdHlwZSB0eXBlKQotewotCXJldHVybiBOVUxMOwotfQogc3RhdGlj IGlubGluZSBpbnQgYW1kZ3B1X21uX3JlZ2lzdGVyKHN0cnVjdCBhbWRncHVfYm8gKmJvLCB1bnNp Z25lZCBsb25nIGFkZHIpCiB7CiAJRFJNX1dBUk5fT05DRSgiSE1NX01JUlJPUiBrZXJuZWwgY29u ZmlnIG9wdGlvbiBpcyBub3QgZW5hYmxlZCwgIgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L2FtZC9hbWRncHUvYW1kZ3B1X3R0bS5jIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1k Z3B1X3R0bS5jCmluZGV4IGMwZTQxZjFmMGMyMzY1Li41ZjRkOGFiNzZmMWRhMCAxMDA2NDQKLS0t IGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X3R0bS5jCisrKyBiL2RyaXZlcnMv Z3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV90dG0uYwpAQCAtNzczLDYgKzc3MywyMCBAQCBzdHJ1 Y3QgYW1kZ3B1X3R0bV90dCB7CiAjZW5kaWYKIH07CiAKKyNpZmRlZiBDT05GSUdfRFJNX0FNREdQ VV9VU0VSUFRSCisvKiBmbGFncyB1c2VkIGJ5IEhNTSBpbnRlcm5hbCwgbm90IHJlbGF0ZWQgdG8g Q1BVL0dQVSBQVEUgZmxhZ3MgKi8KK3N0YXRpYyBjb25zdCB1aW50NjRfdCBobW1fcmFuZ2VfZmxh Z3NbSE1NX1BGTl9GTEFHX01BWF0gPSB7CisJKDEgPDwgMCksIC8qIEhNTV9QRk5fVkFMSUQgKi8K KwkoMSA8PCAxKSwgLyogSE1NX1BGTl9XUklURSAqLworCTAgLyogSE1NX1BGTl9ERVZJQ0VfUFJJ VkFURSAqLworfTsKKworc3RhdGljIGNvbnN0IHVpbnQ2NF90IGhtbV9yYW5nZV92YWx1ZXNbSE1N X1BGTl9WQUxVRV9NQVhdID0geworCTB4ZmZmZmZmZmZmZmZmZmZmZVVMLCAvKiBITU1fUEZOX0VS Uk9SICovCisJMCwgLyogSE1NX1BGTl9OT05FICovCisJMHhmZmZmZmZmZmZmZmZmZmZjVUwgLyog SE1NX1BGTl9TUEVDSUFMICovCit9OworCiAvKioKICAqIGFtZGdwdV90dG1fdHRfZ2V0X3VzZXJf cGFnZXMgLSBnZXQgZGV2aWNlIGFjY2Vzc2libGUgcGFnZXMgdGhhdCBiYWNrIHVzZXIKICAqIG1l bW9yeSBhbmQgc3RhcnQgSE1NIHRyYWNraW5nIENQVSBwYWdlIHRhYmxlIHVwZGF0ZQpAQCAtNzgw LDI5ICs3OTQsMjggQEAgc3RydWN0IGFtZGdwdV90dG1fdHQgewogICogQ2FsbGluZyBmdW5jdGlv biBtdXN0IGNhbGwgYW1kZ3B1X3R0bV90dF91c2VycHRyX3JhbmdlX2RvbmUoKSBvbmNlIGFuZCBv bmx5CiAgKiBvbmNlIGFmdGVyd2FyZHMgdG8gc3RvcCBITU0gdHJhY2tpbmcKICAqLwotI2lmIElT X0VOQUJMRUQoQ09ORklHX0RSTV9BTURHUFVfVVNFUlBUUikKLQotI2RlZmluZSBNQVhfUkVUUllf SE1NX1JBTkdFX0ZBVUxUCTE2Ci0KIGludCBhbWRncHVfdHRtX3R0X2dldF91c2VyX3BhZ2VzKHN0 cnVjdCBhbWRncHVfYm8gKmJvLCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKQogewotCXN0cnVjdCBobW1f bWlycm9yICptaXJyb3IgPSBiby0+bW4gPyAmYm8tPm1uLT5taXJyb3IgOiBOVUxMOwogCXN0cnVj dCB0dG1fdHQgKnR0bSA9IGJvLT50Ym8udHRtOwogCXN0cnVjdCBhbWRncHVfdHRtX3R0ICpndHQg PSAodm9pZCAqKXR0bTsKLQlzdHJ1Y3QgbW1fc3RydWN0ICptbTsKIAl1bnNpZ25lZCBsb25nIHN0 YXJ0ID0gZ3R0LT51c2VycHRyOwogCXN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hOwogCXN0cnVj dCBobW1fcmFuZ2UgKnJhbmdlOworCXVuc2lnbmVkIGxvbmcgdGltZW91dDsKKwlzdHJ1Y3QgbW1f c3RydWN0ICptbTsKIAl1bnNpZ25lZCBsb25nIGk7Ci0JdWludDY0X3QgKnBmbnM7CiAJaW50IHIg PSAwOwogCi0JaWYgKHVubGlrZWx5KCFtaXJyb3IpKSB7Ci0JCURSTV9ERUJVR19EUklWRVIoIkZh aWxlZCB0byBnZXQgaG1tX21pcnJvclxuIik7CisJbW0gPSBiby0+bm90aWZpZXIubW07CisJaWYg KHVubGlrZWx5KCFtbSkpIHsKKwkJRFJNX0RFQlVHX0RSSVZFUigiQk8gaXMgbm90IHJlZ2lzdGVy ZWQ/XG4iKTsKIAkJcmV0dXJuIC1FRkFVTFQ7CiAJfQogCi0JbW0gPSBtaXJyb3ItPmhtbS0+bW11 X25vdGlmaWVyLm1tOworCS8qIEFub3RoZXIgZ2V0X3VzZXJfcGFnZXMgaXMgcnVubmluZyBhdCB0 aGUgc2FtZSB0aW1lPz8gKi8KKwlpZiAoV0FSTl9PTihndHQtPnJhbmdlKSkKKwkJcmV0dXJuIC1F RkFVTFQ7CisKIAlpZiAoIW1tZ2V0X25vdF96ZXJvKG1tKSkgLyogSGFwcGVucyBkdXJpbmcgcHJv Y2VzcyBzaHV0ZG93biAqLwogCQlyZXR1cm4gLUVTUkNIOwogCkBAIC04MTEsMzEgKzgyNCwyMyBA QCBpbnQgYW1kZ3B1X3R0bV90dF9nZXRfdXNlcl9wYWdlcyhzdHJ1Y3QgYW1kZ3B1X2JvICpibywg c3RydWN0IHBhZ2UgKipwYWdlcykKIAkJciA9IC1FTk9NRU07CiAJCWdvdG8gb3V0OwogCX0KKwly YW5nZS0+bm90aWZpZXIgPSAmYm8tPm5vdGlmaWVyOworCXJhbmdlLT5mbGFncyA9IGhtbV9yYW5n ZV9mbGFnczsKKwlyYW5nZS0+dmFsdWVzID0gaG1tX3JhbmdlX3ZhbHVlczsKKwlyYW5nZS0+cGZu X3NoaWZ0ID0gUEFHRV9TSElGVDsKKwlyYW5nZS0+c3RhcnQgPSBiby0+bm90aWZpZXIuaW50ZXJ2 YWxfdHJlZS5zdGFydDsKKwlyYW5nZS0+ZW5kID0gYm8tPm5vdGlmaWVyLmludGVydmFsX3RyZWUu bGFzdCArIDE7CisJcmFuZ2UtPmRlZmF1bHRfZmxhZ3MgPSBobW1fcmFuZ2VfZmxhZ3NbSE1NX1BG Tl9WQUxJRF07CisJaWYgKCFhbWRncHVfdHRtX3R0X2lzX3JlYWRvbmx5KHR0bSkpCisJCXJhbmdl LT5kZWZhdWx0X2ZsYWdzIHw9IHJhbmdlLT5mbGFnc1tITU1fUEZOX1dSSVRFXTsKIAotCXBmbnMg PSBrdm1hbGxvY19hcnJheSh0dG0tPm51bV9wYWdlcywgc2l6ZW9mKCpwZm5zKSwgR0ZQX0tFUk5F TCk7Ci0JaWYgKHVubGlrZWx5KCFwZm5zKSkgeworCXJhbmdlLT5wZm5zID0ga3ZtYWxsb2NfYXJy YXkodHRtLT5udW1fcGFnZXMsIHNpemVvZigqcmFuZ2UtPnBmbnMpLAorCQkJCSAgICAgR0ZQX0tF Uk5FTCk7CisJaWYgKHVubGlrZWx5KCFyYW5nZS0+cGZucykpIHsKIAkJciA9IC1FTk9NRU07CiAJ CWdvdG8gb3V0X2ZyZWVfcmFuZ2VzOwogCX0KIAotCWFtZGdwdV9obW1faW5pdF9yYW5nZShyYW5n ZSk7Ci0JcmFuZ2UtPmRlZmF1bHRfZmxhZ3MgPSByYW5nZS0+ZmxhZ3NbSE1NX1BGTl9WQUxJRF07 Ci0JcmFuZ2UtPmRlZmF1bHRfZmxhZ3MgfD0gYW1kZ3B1X3R0bV90dF9pc19yZWFkb25seSh0dG0p ID8KLQkJCQkwIDogcmFuZ2UtPmZsYWdzW0hNTV9QRk5fV1JJVEVdOwotCXJhbmdlLT5wZm5fZmxh Z3NfbWFzayA9IDA7Ci0JcmFuZ2UtPnBmbnMgPSBwZm5zOwotCXJhbmdlLT5zdGFydCA9IHN0YXJ0 OwotCXJhbmdlLT5lbmQgPSBzdGFydCArIHR0bS0+bnVtX3BhZ2VzICogUEFHRV9TSVpFOwotCi0J aG1tX3JhbmdlX3JlZ2lzdGVyKHJhbmdlLCBtaXJyb3IpOwotCi0JLyoKLQkgKiBKdXN0IHdhaXQg Zm9yIHJhbmdlIHRvIGJlIHZhbGlkLCBzYWZlIHRvIGlnbm9yZSByZXR1cm4gdmFsdWUgYXMgd2UK LQkgKiB3aWxsIHVzZSB0aGUgcmV0dXJuIHZhbHVlIG9mIGhtbV9yYW5nZV9mYXVsdCgpIGJlbG93 IHVuZGVyIHRoZQotCSAqIG1tYXBfc2VtIHRvIGFzY2VydGFpbiB0aGUgdmFsaWRpdHkgb2YgdGhl IHJhbmdlLgotCSAqLwotCWhtbV9yYW5nZV93YWl0X3VudGlsX3ZhbGlkKHJhbmdlLCBITU1fUkFO R0VfREVGQVVMVF9USU1FT1VUKTsKLQogCWRvd25fcmVhZCgmbW0tPm1tYXBfc2VtKTsKIAl2bWEg PSBmaW5kX3ZtYShtbSwgc3RhcnQpOwogCWlmICh1bmxpa2VseSghdm1hIHx8IHN0YXJ0IDwgdm1h LT52bV9zdGFydCkpIHsKQEAgLTg0NywxOCArODUyLDMxIEBAIGludCBhbWRncHVfdHRtX3R0X2dl dF91c2VyX3BhZ2VzKHN0cnVjdCBhbWRncHVfYm8gKmJvLCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKQog CQlyID0gLUVQRVJNOwogCQlnb3RvIG91dF91bmxvY2s7CiAJfQorCXVwX3JlYWQoJm1tLT5tbWFw X3NlbSk7CisJdGltZW91dCA9IGppZmZpZXMgKyBtc2Vjc190b19qaWZmaWVzKEhNTV9SQU5HRV9E RUZBVUxUX1RJTUVPVVQpOwogCityZXRyeToKKwlyYW5nZS0+bm90aWZpZXJfc2VxID0gbW11X3Jh bmdlX3JlYWRfYmVnaW4oJmJvLT5ub3RpZmllcik7CisKKwlkb3duX3JlYWQoJm1tLT5tbWFwX3Nl bSk7CiAJciA9IGhtbV9yYW5nZV9mYXVsdChyYW5nZSwgMCk7CiAJdXBfcmVhZCgmbW0tPm1tYXBf c2VtKTsKLQotCWlmICh1bmxpa2VseShyIDwgMCkpCisJaWYgKHVubGlrZWx5KHIgPD0gMCkpIHsK KwkJLyoKKwkJICogRklYTUU6IFRoaXMgdGltZW91dCBzaG91bGQgZW5jb21wYXNzIHRoZSByZXRy eSBmcm9tCisJCSAqIG1tdV9yYW5nZV9yZWFkX3JldHJ5KCkgYXMgd2VsbC4KKwkJICovCisJCWlm ICgociA9PSAwIHx8IHIgPT0gLUVCVVNZKSAmJiAhdGltZV9hZnRlcihqaWZmaWVzLCB0aW1lb3V0 KSkKKwkJCWdvdG8gcmV0cnk7CiAJCWdvdG8gb3V0X2ZyZWVfcGZuczsKKwl9CiAKIAlmb3IgKGkg PSAwOyBpIDwgdHRtLT5udW1fcGFnZXM7IGkrKykgewotCQlwYWdlc1tpXSA9IGhtbV9kZXZpY2Vf ZW50cnlfdG9fcGFnZShyYW5nZSwgcGZuc1tpXSk7CisJCS8qIEZJWE1FOiBUaGUgcGFnZXMgY2Fu bm90IGJlIHRvdWNoZWQgb3V0c2lkZSB0aGUgbm90aWZpZXJfbG9jayAqLworCQlwYWdlc1tpXSA9 IGhtbV9kZXZpY2VfZW50cnlfdG9fcGFnZShyYW5nZSwgcmFuZ2UtPnBmbnNbaV0pOwogCQlpZiAo dW5saWtlbHkoIXBhZ2VzW2ldKSkgewogCQkJcHJfZXJyKCJQYWdlIGZhdWx0IGZhaWxlZCBmb3Ig cGZuWyVsdV0gPSAweCVsbHhcbiIsCi0JCQkgICAgICAgaSwgcGZuc1tpXSk7CisJCQkgICAgICAg aSwgcmFuZ2UtPnBmbnNbaV0pOwogCQkJciA9IC1FTk9NRU07CiAKIAkJCWdvdG8gb3V0X2ZyZWVf cGZuczsKQEAgLTg3Myw4ICs4OTEsNyBAQCBpbnQgYW1kZ3B1X3R0bV90dF9nZXRfdXNlcl9wYWdl cyhzdHJ1Y3QgYW1kZ3B1X2JvICpibywgc3RydWN0IHBhZ2UgKipwYWdlcykKIG91dF91bmxvY2s6 CiAJdXBfcmVhZCgmbW0tPm1tYXBfc2VtKTsKIG91dF9mcmVlX3BmbnM6Ci0JaG1tX3JhbmdlX3Vu cmVnaXN0ZXIocmFuZ2UpOwotCWt2ZnJlZShwZm5zKTsKKwlrdmZyZWUocmFuZ2UtPnBmbnMpOwog b3V0X2ZyZWVfcmFuZ2VzOgogCWtmcmVlKHJhbmdlKTsKIG91dDoKQEAgLTkwMywxNSArOTIwLDE4 IEBAIGJvb2wgYW1kZ3B1X3R0bV90dF9nZXRfdXNlcl9wYWdlc19kb25lKHN0cnVjdCB0dG1fdHQg KnR0bSkKIAkJIk5vIHVzZXIgcGFnZXMgdG8gY2hlY2tcbiIpOwogCiAJaWYgKGd0dC0+cmFuZ2Up IHsKLQkJciA9IGhtbV9yYW5nZV92YWxpZChndHQtPnJhbmdlKTsKLQkJaG1tX3JhbmdlX3VucmVn aXN0ZXIoZ3R0LT5yYW5nZSk7Ci0KKwkJLyoKKwkJICogRklYTUU6IE11c3QgYWx3YXlzIGhvbGQg bm90aWZpZXJfbG9jayBmb3IgdGhpcywgYW5kIG11c3QKKwkJICogbm90IGlnbm9yZSB0aGUgcmV0 dXJuIGNvZGUuCisJCSAqLworCQlyID0gbW11X3JhbmdlX3JlYWRfcmV0cnkoZ3R0LT5yYW5nZS0+ bm90aWZpZXIsCisJCQkJCSBndHQtPnJhbmdlLT5ub3RpZmllcl9zZXEpOwogCQlrdmZyZWUoZ3R0 LT5yYW5nZS0+cGZucyk7CiAJCWtmcmVlKGd0dC0+cmFuZ2UpOwogCQlndHQtPnJhbmdlID0gTlVM TDsKIAl9CiAKLQlyZXR1cm4gcjsKKwlyZXR1cm4gIXI7CiB9CiAjZW5kaWYKIApAQCAtOTkyLDEw ICsxMDEyLDE4IEBAIHN0YXRpYyB2b2lkIGFtZGdwdV90dG1fdHRfdW5waW5fdXNlcnB0cihzdHJ1 Y3QgdHRtX3R0ICp0dG0pCiAJc2dfZnJlZV90YWJsZSh0dG0tPnNnKTsKIAogI2lmIElTX0VOQUJM RUQoQ09ORklHX0RSTV9BTURHUFVfVVNFUlBUUikKLQlpZiAoZ3R0LT5yYW5nZSAmJgotCSAgICB0 dG0tPnBhZ2VzWzBdID09IGhtbV9kZXZpY2VfZW50cnlfdG9fcGFnZShndHQtPnJhbmdlLAotCQkJ CQkJICAgICAgZ3R0LT5yYW5nZS0+cGZuc1swXSkpCi0JCVdBUk5fT05DRSgxLCAiTWlzc2luZyBn ZXRfdXNlcl9wYWdlX2RvbmVcbiIpOworCWlmIChndHQtPnJhbmdlKSB7CisJCXVuc2lnbmVkIGxv bmcgaTsKKworCQlmb3IgKGkgPSAwOyBpIDwgdHRtLT5udW1fcGFnZXM7IGkrKykgeworCQkJaWYg KHR0bS0+cGFnZXNbaV0gIT0KKwkJCQlobW1fZGV2aWNlX2VudHJ5X3RvX3BhZ2UoZ3R0LT5yYW5n ZSwKKwkJCQkJICAgICAgZ3R0LT5yYW5nZS0+cGZuc1tpXSkpCisJCQkJYnJlYWs7CisJCX0KKwor CQlXQVJOKChpID09IHR0bS0+bnVtX3BhZ2VzKSwgIk1pc3NpbmcgZ2V0X3VzZXJfcGFnZV9kb25l XG4iKTsKKwl9CiAjZW5kaWYKIH0KIAotLSAKMi4yMy4wCgoKX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX18KWGVuLWRldmVsIG1haWxpbmcgbGlzdApYZW4tZGV2 ZWxAbGlzdHMueGVucHJvamVjdC5vcmcKaHR0cHM6Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9tYWls bWFuL2xpc3RpbmZvL3hlbi1kZXZlbA== 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=-6.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS 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 E4102CA9ECF for ; Fri, 1 Nov 2019 18:43:08 +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 BE52A21734 for ; Fri, 1 Nov 2019 18:43:08 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org BE52A21734 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=mellanox.com 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 4BBF26F70A; Fri, 1 Nov 2019 18:43:08 +0000 (UTC) Received: from EUR03-AM5-obe.outbound.protection.outlook.com (mail-eopbgr30077.outbound.protection.outlook.com [40.107.3.77]) by gabe.freedesktop.org (Postfix) with ESMTPS id 15C0B6F852; Fri, 1 Nov 2019 18:34:45 +0000 (UTC) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=ID1czwKAJLJjyQE30wEVEYNJTUEtpI7Qkl24FrPbmXzaju2x222SlxL+11q/UDBdUsYq/Z2/UvM7LVb9kuBkmxRiPd+cG27JIs/5anPSLrc7aT3QaOrgcKpwM8i5z2Mu+VXBiwW83tEQNE5hJXvc+XrdZie0X3djGlK9VtdfANz/f9HA6j0tymIPobevmbRt5At9dvqKzmAlICQVL+C5KxnYAZUX1XsZDwxeeap+ii3cUXxe6a6LXB6Y9Z2CLEUZrgZfETf0RDCkTFrDGtTCi21B8u9CnCEWoplFgFw+ldPZqhwRHcWF5oC5uiLKC4BAedJEJltsMdcJCdpwIM9Ntw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=oXuOHTtipoYkfU5LykKoTmwF4/VlgjtrC3fuHXm5AjI=; b=Ua7vkWayi5JBuLpIWZDwMR6AU8/DU7mhA0xCZewXDuUeeom3QLuwm1csS/Ijbju+vpjF5akTq0bN0oEELJ/Kenn1bIACSln3frAm66Gi8wdxfLhRqTQ+N8LJ2dpvGazDJQ9x9GjhAtvjf0jWi9ZpO9RhsiChXpx2x0XeytZp+nweQxxTcQXG22ZsGL5xqq1RfQ6lSkx9Yu/VeSvwR2JR/7hDMR5ENG++Gq98I60v1tkMK9wUXyvj65jfuM/79MVATfvMzpRzm1WpRXaXg6xWxf5XH6Ldn86uJDqZtAtFu3WnXOsCN8l+OGWxqAgNf56bqEnegkHrJwtC6tD56Ps3+g== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=mellanox.com; dmarc=pass action=none header.from=mellanox.com; dkim=pass header.d=mellanox.com; arc=none Received: from VI1PR05MB4141.eurprd05.prod.outlook.com (52.133.14.15) by VI1PR05MB4416.eurprd05.prod.outlook.com (52.134.123.146) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.2387.22; Fri, 1 Nov 2019 18:34:40 +0000 Received: from VI1PR05MB4141.eurprd05.prod.outlook.com ([fe80::b179:e8bf:22d4:bf8d]) by VI1PR05MB4141.eurprd05.prod.outlook.com ([fe80::b179:e8bf:22d4:bf8d%5]) with mapi id 15.20.2387.028; Fri, 1 Nov 2019 18:34:40 +0000 From: Jason Gunthorpe To: "Yang, Philip" Subject: [PATCH v2a 14/15] drm/amdgpu: Use mmu_range_notifier instead of hmm_mirror Thread-Topic: [PATCH v2a 14/15] drm/amdgpu: Use mmu_range_notifier instead of hmm_mirror Thread-Index: AQHVkOMFaRcJHQRrK0S6ryutY4Fnpg== Date: Fri, 1 Nov 2019 18:34:40 +0000 Message-ID: <20191101183435.GR22766@mellanox.com> References: <20191028201032.6352-1-jgg@ziepe.ca> <20191028201032.6352-15-jgg@ziepe.ca> <20191029192544.GU22766@mellanox.com> <30b2f569-bf7a-5166-c98d-4a4a13d1351f@amd.com> In-Reply-To: <30b2f569-bf7a-5166-c98d-4a4a13d1351f@amd.com> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-clientproxiedby: BN4PR12CA0013.namprd12.prod.outlook.com (2603:10b6:403:2::23) To VI1PR05MB4141.eurprd05.prod.outlook.com (2603:10a6:803:44::15) x-ms-exchange-messagesentrepresentingtype: 1 x-originating-ip: [142.162.113.180] x-ms-publictraffictype: Email x-ms-office365-filtering-ht: Tenant x-ms-office365-filtering-correlation-id: 7fd1dc84-23d9-4c30-3490-08d75efa27d3 x-ms-traffictypediagnostic: VI1PR05MB4416: x-microsoft-antispam-prvs: x-ms-oob-tlc-oobclassifiers: OLM:6430; x-forefront-prvs: 020877E0CB x-forefront-antispam-report: SFV:NSPM; SFS:(10009020)(4636009)(366004)(136003)(396003)(376002)(39860400002)(346002)(199004)(189003)(36756003)(81156014)(86362001)(102836004)(54906003)(476003)(11346002)(446003)(14454004)(6916009)(6512007)(486006)(2616005)(99286004)(14444005)(6436002)(66066001)(256004)(6486002)(6116002)(2906002)(8676002)(25786009)(71200400001)(3846002)(4326008)(478600001)(71190400001)(33656002)(30864003)(5660300002)(66946007)(81166006)(8936002)(7736002)(52116002)(66556008)(66476007)(386003)(6506007)(1076003)(316002)(66446008)(186003)(305945005)(26005)(7416002)(76176011)(64756008); DIR:OUT; SFP:1101; SCL:1; SRVR:VI1PR05MB4416; H:VI1PR05MB4141.eurprd05.prod.outlook.com; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; A:1; MX:1; received-spf: None (protection.outlook.com: mellanox.com does not designate permitted sender hosts) x-ms-exchange-senderadcheck: 1 x-microsoft-antispam: BCL:0; x-microsoft-antispam-message-info: fWNQ+BZa7hfC/4uLDbkIzf190FXkgTVGRQKdPvrvbvJpoBtJPgrsM7NGgZQ1QolaRtrYNrap2uwCvyZBwc+s1RJrMJs0W4wt38pjuaPPJHfnwuNoqyOnrYlMsQwNybX+mi4Q5WE4Pg0wiaVGQDLKd/jzIznyDxANtLOIJkay4xVDUZuqQJg0ZJ5lwxg9w7eTS8jfnmflWgEN1kT2Vh17iuWWQZ3VwGzrMwd3SehhT5moiR+3hN8s058c3TYlgBggqYdEGdDYMmVxzwWbZ1hRnOtvnkbCjHalAFCEwBe2F4KYWoOr44uRyLV32bUbwHLWYknPvscKcWD2/FgOmTHQPiVPsk9o16OhK4JhXmP+uYkdvjkbZgWiPYIElS4dXYek7ygn7Xc0XKeD/JE/rH5lLTVBDLeo3+S2wC+qVP+/j2+4kf1uzHXjbfJLmDORfGdY x-ms-exchange-transport-forked: True Content-ID: MIME-Version: 1.0 X-OriginatorOrg: Mellanox.com X-MS-Exchange-CrossTenant-Network-Message-Id: 7fd1dc84-23d9-4c30-3490-08d75efa27d3 X-MS-Exchange-CrossTenant-originalarrivaltime: 01 Nov 2019 18:34:40.7437 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: a652971c-7d2e-4d9b-a6a4-d149256f461b X-MS-Exchange-CrossTenant-mailboxtype: HOSTED X-MS-Exchange-CrossTenant-userprincipalname: 6w7Cky8H25cOW4Dxqgj7Dr4BIQtw+qoZ/7TjiXWzab8P8ekkpF8unK6sBjda6ZrGlvHzuK1g8e6b2fcbAMO5Iw== X-MS-Exchange-Transport-CrossTenantHeadersStamped: VI1PR05MB4416 X-Mailman-Approved-At: Fri, 01 Nov 2019 18:43:07 +0000 X-Mailman-Original-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=Mellanox.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=oXuOHTtipoYkfU5LykKoTmwF4/VlgjtrC3fuHXm5AjI=; b=SVt+wZWfddkHw40mdehiJvucDKT2KvzDlrQP55Ml/4rWjve2GuEe2xqxPo73B2fRqrFrHqK5bx8O/xIaihWeqPjCshAWTaYAbnXeNPUgKNFCym3gLpiowXTwCoZckm0xfZGrKXjiAUW/JE5DWbv0znRymHJP/wjis3b6AfDHIX8= X-Mailman-Original-Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=jgg@mellanox.com; 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: "nouveau@lists.freedesktop.org" , "dri-devel@lists.freedesktop.org" , "linux-mm@kvack.org" , "Zhou, David\(ChunMing\)" , Stefano Stabellini , Oleksandr Andrushchenko , "linux-rdma@vger.kernel.org" , "amd-gfx@lists.freedesktop.org" , Christoph Hellwig , Ben Skeggs , "xen-devel@lists.xenproject.org" , Ralph Campbell , John Hubbard , Jerome Glisse , Dennis Dalessandro , Boris Ostrovsky , Petr Cvek , Juergen Gross , Mike Marciniszyn , "Kuehling, Felix" , "Deucher, Alexander" , "Koenig, Christian" Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: amd-gfx-bounces@lists.freedesktop.org Sender: "amd-gfx" Message-ID: <20191101183440.5rlWhJqFTMuTwFrWXjPmits1-eXnEO8UV9fPMTUzKw0@z> Q29udmVydCB0aGUgY29sbGlzaW9uLXJldHJ5IGxvY2sgYXJvdW5kIGhtbV9yYW5nZV9mYXVsdCB0 byB1c2UgdGhlIG9uZSBub3cKcHJvdmlkZWQgYnkgdGhlIG1tdV9yYW5nZSBub3RpZmllci4KCkFs dGhvdWdoIHRoaXMgZHJpdmVyIGRvZXMgbm90IHNlZW0gdG8gdXNlIHRoZSBjb2xsaXNpb24gcmV0 cnkgbG9jayB0aGF0CmhtbSBwcm92aWRlcyBjb3JyZWN0bHksIGl0IGNhbiBzdGlsbCBiZSBjb252 ZXJ0ZWQgb3ZlciB0byB1c2UgdGhlCm1tdV9yYW5nZV9ub3RpZmllciBhcGkgaW5zdGVhZCBvZiBo bW1fbWlycm9yIHdpdGhvdXQgdG9vIG11Y2ggdHJvdWJsZS4KClRoaXMgYWxzbyBkZWxldGVzIGFu b3RoZXIgcGxhY2Ugd2hlcmUgYSBkcml2ZXIgaXMgYXNzb2NpYXRpbmcgYWRkaXRpb25hbApkYXRh IChzdHJ1Y3QgYW1kZ3B1X21uKSB3aXRoIGEgbW11X3N0cnVjdC4KClNpZ25lZC1vZmYtYnk6IFBo aWxpcCBZYW5nIDxQaGlsaXAuWWFuZ0BhbWQuY29tPgpSZXZpZXdlZC1ieTogUGhpbGlwIFlhbmcg PFBoaWxpcC5ZYW5nQGFtZC5jb20+ClRlc3RlZC1ieTogUGhpbGlwIFlhbmcgPFBoaWxpcC5ZYW5n QGFtZC5jb20+ClNpZ25lZC1vZmYtYnk6IEphc29uIEd1bnRob3JwZSA8amdnQG1lbGxhbm94LmNv bT4KLS0tCiAuLi4vZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYyAgfCAg IDQgKwogZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2NzLmMgICAgICAgIHwgIDE0 ICstCiBkcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uYyAgICAgICAgfCAxNTAg KystLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4u aCAgICAgICAgfCAgNDkgLS0tLS0tCiBkcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVf dHRtLmMgICAgICAgfCAxMTYgKysrKysrKysrLS0tLS0KIDUgZmlsZXMgY2hhbmdlZCwgOTYgaW5z ZXJ0aW9ucygrKSwgMjM3IGRlbGV0aW9ucygtKQoKUGhpbGlwLCBoZXJlIGlzIHdoYXQgaXQgbG9v cyBsaWtlIGFmdGVyIGNvbWJpbmluZyB0aGUgdHdvIHBhdGNoZXMsIHRoYW5rcwoKZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYyBiL2Ry aXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYwppbmRleCA0Nzcw MDMwMmEwOGI3Zi4uMWJjZWRiOWI0NzdkY2UgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9h bWQvYW1kZ3B1L2FtZGdwdV9hbWRrZmRfZ3B1dm0uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1k L2FtZGdwdS9hbWRncHVfYW1ka2ZkX2dwdXZtLmMKQEAgLTE3MzgsNiArMTczOCwxMCBAQCBzdGF0 aWMgaW50IHVwZGF0ZV9pbnZhbGlkX3VzZXJfcGFnZXMoc3RydWN0IGFtZGtmZF9wcm9jZXNzX2lu Zm8gKnByb2Nlc3NfaW5mbywKIAkJCXJldHVybiByZXQ7CiAJCX0KIAorCQkvKgorCQkgKiBGSVhN RTogQ2Fubm90IGlnbm9yZSB0aGUgcmV0dXJuIGNvZGUsIG11c3QgaG9sZAorCQkgKiBub3RpZmll cl9sb2NrCisJCSAqLwogCQlhbWRncHVfdHRtX3R0X2dldF91c2VyX3BhZ2VzX2RvbmUoYm8tPnRi by50dG0pOwogCiAJCS8qIE1hcmsgdGhlIEJPIGFzIHZhbGlkIHVubGVzcyBpdCB3YXMgaW52YWxp ZGF0ZWQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9jcy5j IGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X2NzLmMKaW5kZXggODI4MjNkOWE4 YmE4ODcuLjIyYzk4OWJjYTc1MTRjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2Ft ZGdwdS9hbWRncHVfY3MuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVf Y3MuYwpAQCAtNjAzLDggKzYwMyw2IEBAIHN0YXRpYyBpbnQgYW1kZ3B1X2NzX3BhcnNlcl9ib3Mo c3RydWN0IGFtZGdwdV9jc19wYXJzZXIgKnAsCiAJCWUtPnR2Lm51bV9zaGFyZWQgPSAyOwogCiAJ YW1kZ3B1X2JvX2xpc3RfZ2V0X2xpc3QocC0+Ym9fbGlzdCwgJnAtPnZhbGlkYXRlZCk7Ci0JaWYg KHAtPmJvX2xpc3QtPmZpcnN0X3VzZXJwdHIgIT0gcC0+Ym9fbGlzdC0+bnVtX2VudHJpZXMpCi0J CXAtPm1uID0gYW1kZ3B1X21uX2dldChwLT5hZGV2LCBBTURHUFVfTU5fVFlQRV9HRlgpOwogCiAJ SU5JVF9MSVNUX0hFQUQoJmR1cGxpY2F0ZXMpOwogCWFtZGdwdV92bV9nZXRfcGRfYm8oJmZwcml2 LT52bSwgJnAtPnZhbGlkYXRlZCwgJnAtPnZtX3BkKTsKQEAgLTEyODcsMTEgKzEyODUsMTEgQEAg c3RhdGljIGludCBhbWRncHVfY3Nfc3VibWl0KHN0cnVjdCBhbWRncHVfY3NfcGFyc2VyICpwLAog CWlmIChyKQogCQlnb3RvIGVycm9yX3VubG9jazsKIAotCS8qIE5vIG1lbW9yeSBhbGxvY2F0aW9u IGlzIGFsbG93ZWQgd2hpbGUgaG9sZGluZyB0aGUgbW4gbG9jay4KLQkgKiBwLT5tbiBpcyBob2xk IHVudGlsIGFtZGdwdV9jc19zdWJtaXQgaXMgZmluaXNoZWQgYW5kIGZlbmNlIGlzIGFkZGVkCi0J ICogdG8gQk9zLgorCS8qIE5vIG1lbW9yeSBhbGxvY2F0aW9uIGlzIGFsbG93ZWQgd2hpbGUgaG9s ZGluZyB0aGUgbm90aWZpZXIgbG9jay4KKwkgKiBUaGUgbG9jayBpcyBoZWxkIHVudGlsIGFtZGdw dV9jc19zdWJtaXQgaXMgZmluaXNoZWQgYW5kIGZlbmNlIGlzCisJICogYWRkZWQgdG8gQk9zLgog CSAqLwotCWFtZGdwdV9tbl9sb2NrKHAtPm1uKTsKKwltdXRleF9sb2NrKCZwLT5hZGV2LT5ub3Rp Zmllcl9sb2NrKTsKIAogCS8qIElmIHVzZXJwdHIgYXJlIGludmFsaWRhdGVkIGFmdGVyIGFtZGdw dV9jc19wYXJzZXJfYm9zKCksIHJldHVybgogCSAqIC1FQUdBSU4sIGRybUlvY3RsIGluIGxpYmRy bSB3aWxsIHJlc3RhcnQgdGhlIGFtZGdwdV9jc19pb2N0bC4KQEAgLTEzMzQsMTMgKzEzMzIsMTMg QEAgc3RhdGljIGludCBhbWRncHVfY3Nfc3VibWl0KHN0cnVjdCBhbWRncHVfY3NfcGFyc2VyICpw LAogCWFtZGdwdV92bV9tb3ZlX3RvX2xydV90YWlsKHAtPmFkZXYsICZmcHJpdi0+dm0pOwogCiAJ dHRtX2V1X2ZlbmNlX2J1ZmZlcl9vYmplY3RzKCZwLT50aWNrZXQsICZwLT52YWxpZGF0ZWQsIHAt PmZlbmNlKTsKLQlhbWRncHVfbW5fdW5sb2NrKHAtPm1uKTsKKwltdXRleF91bmxvY2soJnAtPmFk ZXYtPm5vdGlmaWVyX2xvY2spOwogCiAJcmV0dXJuIDA7CiAKIGVycm9yX2Fib3J0OgogCWRybV9z Y2hlZF9qb2JfY2xlYW51cCgmam9iLT5iYXNlKTsKLQlhbWRncHVfbW5fdW5sb2NrKHAtPm1uKTsK KwltdXRleF91bmxvY2soJnAtPmFkZXYtPm5vdGlmaWVyX2xvY2spOwogCiBlcnJvcl91bmxvY2s6 CiAJYW1kZ3B1X2pvYl9mcmVlKGpvYik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1k L2FtZGdwdS9hbWRncHVfbW4uYyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9t bi5jCmluZGV4IGFjNzQzMjBiNzFlNGU3Li5mN2JlMzQ5MDdlNTRmNSAxMDA2NDQKLS0tIGEvZHJp dmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmMKKysrIGIvZHJpdmVycy9ncHUvZHJt L2FtZC9hbWRncHUvYW1kZ3B1X21uLmMKQEAgLTUwLDI4ICs1MCw2IEBACiAjaW5jbHVkZSAiYW1k Z3B1LmgiCiAjaW5jbHVkZSAiYW1kZ3B1X2FtZGtmZC5oIgogCi0vKioKLSAqIGFtZGdwdV9tbl9s b2NrIC0gdGFrZSB0aGUgd3JpdGUgc2lkZSBsb2NrIGZvciB0aGlzIG5vdGlmaWVyCi0gKgotICog QG1uOiBvdXIgbm90aWZpZXIKLSAqLwotdm9pZCBhbWRncHVfbW5fbG9jayhzdHJ1Y3QgYW1kZ3B1 X21uICptbikKLXsKLQlpZiAobW4pCi0JCWRvd25fd3JpdGUoJm1uLT5sb2NrKTsKLX0KLQotLyoq Ci0gKiBhbWRncHVfbW5fdW5sb2NrIC0gZHJvcCB0aGUgd3JpdGUgc2lkZSBsb2NrIGZvciB0aGlz IG5vdGlmaWVyCi0gKgotICogQG1uOiBvdXIgbm90aWZpZXIKLSAqLwotdm9pZCBhbWRncHVfbW5f dW5sb2NrKHN0cnVjdCBhbWRncHVfbW4gKm1uKQotewotCWlmIChtbikKLQkJdXBfd3JpdGUoJm1u LT5sb2NrKTsKLX0KLQogLyoqCiAgKiBhbWRncHVfbW5faW52YWxpZGF0ZV9nZnggLSBjYWxsYmFj ayB0byBub3RpZnkgYWJvdXQgbW0gY2hhbmdlCiAgKgpAQCAtODIsMTYgKzYwLDIwIEBAIHZvaWQg YW1kZ3B1X21uX3VubG9jayhzdHJ1Y3QgYW1kZ3B1X21uICptbikKICAqIHBvdGVudGlhbGx5IGRp cnR5LgogICovCiBzdGF0aWMgYm9vbCBhbWRncHVfbW5faW52YWxpZGF0ZV9nZngoc3RydWN0IG1t dV9yYW5nZV9ub3RpZmllciAqbXJuLAotCQkJCSAgICAgY29uc3Qgc3RydWN0IG1tdV9ub3RpZmll cl9yYW5nZSAqcmFuZ2UpCisJCQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3Jhbmdl ICpyYW5nZSwKKwkJCQkgICAgIHVuc2lnbmVkIGxvbmcgY3VyX3NlcSkKIHsKIAlzdHJ1Y3QgYW1k Z3B1X2JvICpibyA9IGNvbnRhaW5lcl9vZihtcm4sIHN0cnVjdCBhbWRncHVfYm8sIG5vdGlmaWVy KTsKIAlzdHJ1Y3QgYW1kZ3B1X2RldmljZSAqYWRldiA9IGFtZGdwdV90dG1fYWRldihiby0+dGJv LmJkZXYpOwogCWxvbmcgcjsKIAotCWlmICghbW11X25vdGlmaWVyX3JhbmdlX2Jsb2NrYWJsZShy YW5nZSkpCisJaWYgKG1tdV9ub3RpZmllcl9yYW5nZV9ibG9ja2FibGUocmFuZ2UpKQorCQltdXRl eF9sb2NrKCZhZGV2LT5ub3RpZmllcl9sb2NrKTsKKwllbHNlIGlmICghbXV0ZXhfdHJ5bG9jaygm YWRldi0+bm90aWZpZXJfbG9jaykpCiAJCXJldHVybiBmYWxzZTsKIAotCW11dGV4X2xvY2soJmFk ZXYtPm5vdGlmaWVyX2xvY2spOworCW1tdV9yYW5nZV9zZXRfc2VxKG1ybiwgY3VyX3NlcSk7CisK IAlyID0gZG1hX3Jlc3Zfd2FpdF90aW1lb3V0X3JjdShiby0+dGJvLmJhc2UucmVzdiwgdHJ1ZSwg ZmFsc2UsCiAJCQkJICAgICAgTUFYX1NDSEVEVUxFX1RJTUVPVVQpOwogCW11dGV4X3VubG9jaygm YWRldi0+bm90aWZpZXJfbG9jayk7CkBAIC0xMTQsMTUgKzk2LDE5IEBAIHN0YXRpYyBjb25zdCBz dHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyX29wcyBhbWRncHVfbW5fZ2Z4X29wcyA9IHsKICAqIGV2 aWN0aW5nIGFsbCB1c2VyLW1vZGUgcXVldWVzIG9mIHRoZSBwcm9jZXNzLgogICovCiBzdGF0aWMg Ym9vbCBhbWRncHVfbW5faW52YWxpZGF0ZV9oc2Eoc3RydWN0IG1tdV9yYW5nZV9ub3RpZmllciAq bXJuLAotCQkJCSAgICAgY29uc3Qgc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAqcmFuZ2UpCisJ CQkJICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICpyYW5nZSwKKwkJCQkgICAg IHVuc2lnbmVkIGxvbmcgY3VyX3NlcSkKIHsKIAlzdHJ1Y3QgYW1kZ3B1X2JvICpibyA9IGNvbnRh aW5lcl9vZihtcm4sIHN0cnVjdCBhbWRncHVfYm8sIG5vdGlmaWVyKTsKIAlzdHJ1Y3QgYW1kZ3B1 X2RldmljZSAqYWRldiA9IGFtZGdwdV90dG1fYWRldihiby0+dGJvLmJkZXYpOwogCi0JaWYgKCFt bXVfbm90aWZpZXJfcmFuZ2VfYmxvY2thYmxlKHJhbmdlKSkKKwlpZiAobW11X25vdGlmaWVyX3Jh bmdlX2Jsb2NrYWJsZShyYW5nZSkpCisJCW11dGV4X2xvY2soJmFkZXYtPm5vdGlmaWVyX2xvY2sp OworCWVsc2UgaWYgKCFtdXRleF90cnlsb2NrKCZhZGV2LT5ub3RpZmllcl9sb2NrKSkKIAkJcmV0 dXJuIGZhbHNlOwogCi0JbXV0ZXhfbG9jaygmYWRldi0+bm90aWZpZXJfbG9jayk7CisJbW11X3Jh bmdlX3NldF9zZXEobXJuLCBjdXJfc2VxKTsKKwogCWFtZGdwdV9hbWRrZmRfZXZpY3RfdXNlcnB0 cihiby0+a2ZkX2JvLCBiby0+bm90aWZpZXIubW0pOwogCW11dGV4X3VubG9jaygmYWRldi0+bm90 aWZpZXJfbG9jayk7CiAKQEAgLTEzMyw5MiArMTE5LDYgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBt bXVfcmFuZ2Vfbm90aWZpZXJfb3BzIGFtZGdwdV9tbl9oc2Ffb3BzID0gewogCS5pbnZhbGlkYXRl ID0gYW1kZ3B1X21uX2ludmFsaWRhdGVfaHNhLAogfTsKIAotc3RhdGljIGludCBhbWRncHVfbW5f c3luY19wYWdldGFibGVzKHN0cnVjdCBobW1fbWlycm9yICptaXJyb3IsCi0JCQkJICAgICBjb25z dCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICp1cGRhdGUpCi17Ci0Jc3RydWN0IGFtZGdwdV9t biAqYW1uID0gY29udGFpbmVyX29mKG1pcnJvciwgc3RydWN0IGFtZGdwdV9tbiwgbWlycm9yKTsK LQotCWlmICghbW11X25vdGlmaWVyX3JhbmdlX2Jsb2NrYWJsZSh1cGRhdGUpKQotCQlyZXR1cm4g LUVBR0FJTjsKLQotCWRvd25fcmVhZCgmYW1uLT5sb2NrKTsKLQl1cF9yZWFkKCZhbW4tPmxvY2sp OwotCXJldHVybiAwOwotfQotCi0vKiBMb3cgYml0cyBvZiBhbnkgcmVhc29uYWJsZSBtbSBwb2lu dGVyIHdpbGwgYmUgdW51c2VkIGR1ZSB0byBzdHJ1Y3QKLSAqIGFsaWdubWVudC4gVXNlIHRoZXNl IGJpdHMgdG8gbWFrZSBhIHVuaXF1ZSBrZXkgZnJvbSB0aGUgbW0gcG9pbnRlcgotICogYW5kIG5v dGlmaWVyIHR5cGUuCi0gKi8KLSNkZWZpbmUgQU1ER1BVX01OX0tFWShtbSwgdHlwZSkgKCh1bnNp Z25lZCBsb25nKShtbSkgKyAodHlwZSkpCi0KLXN0YXRpYyBzdHJ1Y3QgaG1tX21pcnJvcl9vcHMg YW1kZ3B1X2htbV9taXJyb3Jfb3BzW10gPSB7Ci0JW0FNREdQVV9NTl9UWVBFX0dGWF0gPSB7Ci0J CS5zeW5jX2NwdV9kZXZpY2VfcGFnZXRhYmxlcyA9IGFtZGdwdV9tbl9zeW5jX3BhZ2V0YWJsZXMs Ci0JfSwKLQlbQU1ER1BVX01OX1RZUEVfSFNBXSA9IHsKLQkJLnN5bmNfY3B1X2RldmljZV9wYWdl dGFibGVzID0gYW1kZ3B1X21uX3N5bmNfcGFnZXRhYmxlcywKLQl9LAotfTsKLQotLyoqCi0gKiBh bWRncHVfbW5fZ2V0IC0gY3JlYXRlIEhNTSBtaXJyb3IgY29udGV4dAotICoKLSAqIEBhZGV2OiBh bWRncHUgZGV2aWNlIHBvaW50ZXIKLSAqIEB0eXBlOiB0eXBlIG9mIE1NVSBub3RpZmllciBjb250 ZXh0Ci0gKgotICogQ3JlYXRlcyBhIEhNTSBtaXJyb3IgY29udGV4dCBmb3IgY3VycmVudC0+bW0u Ci0gKi8KLXN0cnVjdCBhbWRncHVfbW4gKmFtZGdwdV9tbl9nZXQoc3RydWN0IGFtZGdwdV9kZXZp Y2UgKmFkZXYsCi0JCQkJZW51bSBhbWRncHVfbW5fdHlwZSB0eXBlKQotewotCXN0cnVjdCBtbV9z dHJ1Y3QgKm1tID0gY3VycmVudC0+bW07Ci0Jc3RydWN0IGFtZGdwdV9tbiAqYW1uOwotCXVuc2ln bmVkIGxvbmcga2V5ID0gQU1ER1BVX01OX0tFWShtbSwgdHlwZSk7Ci0JaW50IHI7Ci0KLQltdXRl eF9sb2NrKCZhZGV2LT5tbl9sb2NrKTsKLQlpZiAoZG93bl93cml0ZV9raWxsYWJsZSgmbW0tPm1t YXBfc2VtKSkgewotCQltdXRleF91bmxvY2soJmFkZXYtPm1uX2xvY2spOwotCQlyZXR1cm4gRVJS X1BUUigtRUlOVFIpOwotCX0KLQotCWhhc2hfZm9yX2VhY2hfcG9zc2libGUoYWRldi0+bW5faGFz aCwgYW1uLCBub2RlLCBrZXkpCi0JCWlmIChBTURHUFVfTU5fS0VZKGFtbi0+bWlycm9yLmhtbS0+ bW11X25vdGlmaWVyLm1tLAotCQkJCSAgYW1uLT50eXBlKSA9PSBrZXkpCi0JCQlnb3RvIHJlbGVh c2VfbG9ja3M7Ci0KLQlhbW4gPSBremFsbG9jKHNpemVvZigqYW1uKSwgR0ZQX0tFUk5FTCk7Ci0J aWYgKCFhbW4pIHsKLQkJYW1uID0gRVJSX1BUUigtRU5PTUVNKTsKLQkJZ290byByZWxlYXNlX2xv Y2tzOwotCX0KLQotCWFtbi0+YWRldiA9IGFkZXY7Ci0JaW5pdF9yd3NlbSgmYW1uLT5sb2NrKTsK LQlhbW4tPnR5cGUgPSB0eXBlOwotCi0JYW1uLT5taXJyb3Iub3BzID0gJmFtZGdwdV9obW1fbWly cm9yX29wc1t0eXBlXTsKLQlyID0gaG1tX21pcnJvcl9yZWdpc3RlcigmYW1uLT5taXJyb3IsIG1t KTsKLQlpZiAocikKLQkJZ290byBmcmVlX2FtbjsKLQotCWhhc2hfYWRkKGFkZXYtPm1uX2hhc2gs ICZhbW4tPm5vZGUsIEFNREdQVV9NTl9LRVkobW0sIHR5cGUpKTsKLQotcmVsZWFzZV9sb2NrczoK LQl1cF93cml0ZSgmbW0tPm1tYXBfc2VtKTsKLQltdXRleF91bmxvY2soJmFkZXYtPm1uX2xvY2sp OwotCi0JcmV0dXJuIGFtbjsKLQotZnJlZV9hbW46Ci0JdXBfd3JpdGUoJm1tLT5tbWFwX3NlbSk7 Ci0JbXV0ZXhfdW5sb2NrKCZhZGV2LT5tbl9sb2NrKTsKLQlrZnJlZShhbW4pOwotCi0JcmV0dXJu IEVSUl9QVFIocik7Ci19Ci0KIC8qKgogICogYW1kZ3B1X21uX3JlZ2lzdGVyIC0gcmVnaXN0ZXIg YSBCTyBmb3Igbm90aWZpZXIgdXBkYXRlcwogICoKQEAgLTI1MywyNSArMTUzLDMgQEAgdm9pZCBh bWRncHVfbW5fdW5yZWdpc3RlcihzdHJ1Y3QgYW1kZ3B1X2JvICpibykKIAltbXVfcmFuZ2Vfbm90 aWZpZXJfcmVtb3ZlKCZiby0+bm90aWZpZXIpOwogCWJvLT5ub3RpZmllci5tbSA9IE5VTEw7CiB9 Ci0KLS8qIGZsYWdzIHVzZWQgYnkgSE1NIGludGVybmFsLCBub3QgcmVsYXRlZCB0byBDUFUvR1BV IFBURSBmbGFncyAqLwotc3RhdGljIGNvbnN0IHVpbnQ2NF90IGhtbV9yYW5nZV9mbGFnc1tITU1f UEZOX0ZMQUdfTUFYXSA9IHsKLQkJKDEgPDwgMCksIC8qIEhNTV9QRk5fVkFMSUQgKi8KLQkJKDEg PDwgMSksIC8qIEhNTV9QRk5fV1JJVEUgKi8KLQkJMCAvKiBITU1fUEZOX0RFVklDRV9QUklWQVRF ICovCi19OwotCi1zdGF0aWMgY29uc3QgdWludDY0X3QgaG1tX3JhbmdlX3ZhbHVlc1tITU1fUEZO X1ZBTFVFX01BWF0gPSB7Ci0JCTB4ZmZmZmZmZmZmZmZmZmZmZVVMLCAvKiBITU1fUEZOX0VSUk9S ICovCi0JCTAsIC8qIEhNTV9QRk5fTk9ORSAqLwotCQkweGZmZmZmZmZmZmZmZmZmZmNVTCAvKiBI TU1fUEZOX1NQRUNJQUwgKi8KLX07Ci0KLXZvaWQgYW1kZ3B1X2htbV9pbml0X3JhbmdlKHN0cnVj dCBobW1fcmFuZ2UgKnJhbmdlKQotewotCWlmIChyYW5nZSkgewotCQlyYW5nZS0+ZmxhZ3MgPSBo bW1fcmFuZ2VfZmxhZ3M7Ci0JCXJhbmdlLT52YWx1ZXMgPSBobW1fcmFuZ2VfdmFsdWVzOwotCQly YW5nZS0+cGZuX3NoaWZ0ID0gUEFHRV9TSElGVDsKLQl9Ci19CmRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uaCBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1k Z3B1L2FtZGdwdV9tbi5oCmluZGV4IGQ3M2FiMjk0N2IyMmIyLi5hMjkyMjM4Zjc1ZWJhZSAxMDA2 NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmgKKysrIGIvZHJp dmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmgKQEAgLTMwLDU5ICszMCwxMCBAQAog I2luY2x1ZGUgPGxpbnV4L3dvcmtxdWV1ZS5oPgogI2luY2x1ZGUgPGxpbnV4L2ludGVydmFsX3Ry ZWUuaD4KIAotZW51bSBhbWRncHVfbW5fdHlwZSB7Ci0JQU1ER1BVX01OX1RZUEVfR0ZYLAotCUFN REdQVV9NTl9UWVBFX0hTQSwKLX07Ci0KLS8qKgotICogc3RydWN0IGFtZGdwdV9tbgotICoKLSAq IEBhZGV2OiBhbWRncHUgZGV2aWNlIHBvaW50ZXIKLSAqIEB0eXBlOiB0eXBlIG9mIE1NVSBub3Rp ZmllcgotICogQHdvcms6IGRlc3RydWN0aW9uIHdvcmsgaXRlbQotICogQG5vZGU6IGhhc2ggdGFi bGUgbm9kZSB0byBmaW5kIHN0cnVjdHVyZSBieSBhZGV2IGFuZCBtbgotICogQGxvY2s6IHJ3IHNl bWFwaG9yZSBwcm90ZWN0aW5nIHRoZSBub3RpZmllciBub2RlcwotICogQG1pcnJvcjogSE1NIG1p cnJvciBmdW5jdGlvbiBzdXBwb3J0Ci0gKgotICogRGF0YSBmb3IgZWFjaCBhbWRncHUgZGV2aWNl IGFuZCBwcm9jZXNzIGFkZHJlc3Mgc3BhY2UuCi0gKi8KLXN0cnVjdCBhbWRncHVfbW4gewotCS8q IGNvbnN0YW50IGFmdGVyIGluaXRpYWxpc2F0aW9uICovCi0Jc3RydWN0IGFtZGdwdV9kZXZpY2UJ KmFkZXY7Ci0JZW51bSBhbWRncHVfbW5fdHlwZQl0eXBlOwotCi0JLyogb25seSB1c2VkIG9uIGRl c3RydWN0aW9uICovCi0Jc3RydWN0IHdvcmtfc3RydWN0CXdvcms7Ci0KLQkvKiBwcm90ZWN0ZWQg YnkgYWRldi0+bW5fbG9jayAqLwotCXN0cnVjdCBobGlzdF9ub2RlCW5vZGU7Ci0KLQkvKiBvYmpl Y3RzIHByb3RlY3RlZCBieSBsb2NrICovCi0Jc3RydWN0IHJ3X3NlbWFwaG9yZQlsb2NrOwotCi0j aWZkZWYgQ09ORklHX0hNTV9NSVJST1IKLQkvKiBITU0gbWlycm9yICovCi0Jc3RydWN0IGhtbV9t aXJyb3IJbWlycm9yOwotI2VuZGlmCi19OwotCiAjaWYgZGVmaW5lZChDT05GSUdfSE1NX01JUlJP UikKLXZvaWQgYW1kZ3B1X21uX2xvY2soc3RydWN0IGFtZGdwdV9tbiAqbW4pOwotdm9pZCBhbWRn cHVfbW5fdW5sb2NrKHN0cnVjdCBhbWRncHVfbW4gKm1uKTsKLXN0cnVjdCBhbWRncHVfbW4gKmFt ZGdwdV9tbl9nZXQoc3RydWN0IGFtZGdwdV9kZXZpY2UgKmFkZXYsCi0JCQkJZW51bSBhbWRncHVf bW5fdHlwZSB0eXBlKTsKIGludCBhbWRncHVfbW5fcmVnaXN0ZXIoc3RydWN0IGFtZGdwdV9ibyAq Ym8sIHVuc2lnbmVkIGxvbmcgYWRkcik7CiB2b2lkIGFtZGdwdV9tbl91bnJlZ2lzdGVyKHN0cnVj dCBhbWRncHVfYm8gKmJvKTsKLXZvaWQgYW1kZ3B1X2htbV9pbml0X3JhbmdlKHN0cnVjdCBobW1f cmFuZ2UgKnJhbmdlKTsKICNlbHNlCi1zdGF0aWMgaW5saW5lIHZvaWQgYW1kZ3B1X21uX2xvY2so c3RydWN0IGFtZGdwdV9tbiAqbW4pIHt9Ci1zdGF0aWMgaW5saW5lIHZvaWQgYW1kZ3B1X21uX3Vu bG9jayhzdHJ1Y3QgYW1kZ3B1X21uICptbikge30KLXN0YXRpYyBpbmxpbmUgc3RydWN0IGFtZGdw dV9tbiAqYW1kZ3B1X21uX2dldChzdHJ1Y3QgYW1kZ3B1X2RldmljZSAqYWRldiwKLQkJCQkJICAg ICAgZW51bSBhbWRncHVfbW5fdHlwZSB0eXBlKQotewotCXJldHVybiBOVUxMOwotfQogc3RhdGlj IGlubGluZSBpbnQgYW1kZ3B1X21uX3JlZ2lzdGVyKHN0cnVjdCBhbWRncHVfYm8gKmJvLCB1bnNp Z25lZCBsb25nIGFkZHIpCiB7CiAJRFJNX1dBUk5fT05DRSgiSE1NX01JUlJPUiBrZXJuZWwgY29u ZmlnIG9wdGlvbiBpcyBub3QgZW5hYmxlZCwgIgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L2FtZC9hbWRncHUvYW1kZ3B1X3R0bS5jIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1k Z3B1X3R0bS5jCmluZGV4IGMwZTQxZjFmMGMyMzY1Li41ZjRkOGFiNzZmMWRhMCAxMDA2NDQKLS0t IGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X3R0bS5jCisrKyBiL2RyaXZlcnMv Z3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV90dG0uYwpAQCAtNzczLDYgKzc3MywyMCBAQCBzdHJ1 Y3QgYW1kZ3B1X3R0bV90dCB7CiAjZW5kaWYKIH07CiAKKyNpZmRlZiBDT05GSUdfRFJNX0FNREdQ VV9VU0VSUFRSCisvKiBmbGFncyB1c2VkIGJ5IEhNTSBpbnRlcm5hbCwgbm90IHJlbGF0ZWQgdG8g Q1BVL0dQVSBQVEUgZmxhZ3MgKi8KK3N0YXRpYyBjb25zdCB1aW50NjRfdCBobW1fcmFuZ2VfZmxh Z3NbSE1NX1BGTl9GTEFHX01BWF0gPSB7CisJKDEgPDwgMCksIC8qIEhNTV9QRk5fVkFMSUQgKi8K KwkoMSA8PCAxKSwgLyogSE1NX1BGTl9XUklURSAqLworCTAgLyogSE1NX1BGTl9ERVZJQ0VfUFJJ VkFURSAqLworfTsKKworc3RhdGljIGNvbnN0IHVpbnQ2NF90IGhtbV9yYW5nZV92YWx1ZXNbSE1N X1BGTl9WQUxVRV9NQVhdID0geworCTB4ZmZmZmZmZmZmZmZmZmZmZVVMLCAvKiBITU1fUEZOX0VS Uk9SICovCisJMCwgLyogSE1NX1BGTl9OT05FICovCisJMHhmZmZmZmZmZmZmZmZmZmZjVUwgLyog SE1NX1BGTl9TUEVDSUFMICovCit9OworCiAvKioKICAqIGFtZGdwdV90dG1fdHRfZ2V0X3VzZXJf cGFnZXMgLSBnZXQgZGV2aWNlIGFjY2Vzc2libGUgcGFnZXMgdGhhdCBiYWNrIHVzZXIKICAqIG1l bW9yeSBhbmQgc3RhcnQgSE1NIHRyYWNraW5nIENQVSBwYWdlIHRhYmxlIHVwZGF0ZQpAQCAtNzgw LDI5ICs3OTQsMjggQEAgc3RydWN0IGFtZGdwdV90dG1fdHQgewogICogQ2FsbGluZyBmdW5jdGlv biBtdXN0IGNhbGwgYW1kZ3B1X3R0bV90dF91c2VycHRyX3JhbmdlX2RvbmUoKSBvbmNlIGFuZCBv bmx5CiAgKiBvbmNlIGFmdGVyd2FyZHMgdG8gc3RvcCBITU0gdHJhY2tpbmcKICAqLwotI2lmIElT X0VOQUJMRUQoQ09ORklHX0RSTV9BTURHUFVfVVNFUlBUUikKLQotI2RlZmluZSBNQVhfUkVUUllf SE1NX1JBTkdFX0ZBVUxUCTE2Ci0KIGludCBhbWRncHVfdHRtX3R0X2dldF91c2VyX3BhZ2VzKHN0 cnVjdCBhbWRncHVfYm8gKmJvLCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKQogewotCXN0cnVjdCBobW1f bWlycm9yICptaXJyb3IgPSBiby0+bW4gPyAmYm8tPm1uLT5taXJyb3IgOiBOVUxMOwogCXN0cnVj dCB0dG1fdHQgKnR0bSA9IGJvLT50Ym8udHRtOwogCXN0cnVjdCBhbWRncHVfdHRtX3R0ICpndHQg PSAodm9pZCAqKXR0bTsKLQlzdHJ1Y3QgbW1fc3RydWN0ICptbTsKIAl1bnNpZ25lZCBsb25nIHN0 YXJ0ID0gZ3R0LT51c2VycHRyOwogCXN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hOwogCXN0cnVj dCBobW1fcmFuZ2UgKnJhbmdlOworCXVuc2lnbmVkIGxvbmcgdGltZW91dDsKKwlzdHJ1Y3QgbW1f c3RydWN0ICptbTsKIAl1bnNpZ25lZCBsb25nIGk7Ci0JdWludDY0X3QgKnBmbnM7CiAJaW50IHIg PSAwOwogCi0JaWYgKHVubGlrZWx5KCFtaXJyb3IpKSB7Ci0JCURSTV9ERUJVR19EUklWRVIoIkZh aWxlZCB0byBnZXQgaG1tX21pcnJvclxuIik7CisJbW0gPSBiby0+bm90aWZpZXIubW07CisJaWYg KHVubGlrZWx5KCFtbSkpIHsKKwkJRFJNX0RFQlVHX0RSSVZFUigiQk8gaXMgbm90IHJlZ2lzdGVy ZWQ/XG4iKTsKIAkJcmV0dXJuIC1FRkFVTFQ7CiAJfQogCi0JbW0gPSBtaXJyb3ItPmhtbS0+bW11 X25vdGlmaWVyLm1tOworCS8qIEFub3RoZXIgZ2V0X3VzZXJfcGFnZXMgaXMgcnVubmluZyBhdCB0 aGUgc2FtZSB0aW1lPz8gKi8KKwlpZiAoV0FSTl9PTihndHQtPnJhbmdlKSkKKwkJcmV0dXJuIC1F RkFVTFQ7CisKIAlpZiAoIW1tZ2V0X25vdF96ZXJvKG1tKSkgLyogSGFwcGVucyBkdXJpbmcgcHJv Y2VzcyBzaHV0ZG93biAqLwogCQlyZXR1cm4gLUVTUkNIOwogCkBAIC04MTEsMzEgKzgyNCwyMyBA QCBpbnQgYW1kZ3B1X3R0bV90dF9nZXRfdXNlcl9wYWdlcyhzdHJ1Y3QgYW1kZ3B1X2JvICpibywg c3RydWN0IHBhZ2UgKipwYWdlcykKIAkJciA9IC1FTk9NRU07CiAJCWdvdG8gb3V0OwogCX0KKwly YW5nZS0+bm90aWZpZXIgPSAmYm8tPm5vdGlmaWVyOworCXJhbmdlLT5mbGFncyA9IGhtbV9yYW5n ZV9mbGFnczsKKwlyYW5nZS0+dmFsdWVzID0gaG1tX3JhbmdlX3ZhbHVlczsKKwlyYW5nZS0+cGZu X3NoaWZ0ID0gUEFHRV9TSElGVDsKKwlyYW5nZS0+c3RhcnQgPSBiby0+bm90aWZpZXIuaW50ZXJ2 YWxfdHJlZS5zdGFydDsKKwlyYW5nZS0+ZW5kID0gYm8tPm5vdGlmaWVyLmludGVydmFsX3RyZWUu bGFzdCArIDE7CisJcmFuZ2UtPmRlZmF1bHRfZmxhZ3MgPSBobW1fcmFuZ2VfZmxhZ3NbSE1NX1BG Tl9WQUxJRF07CisJaWYgKCFhbWRncHVfdHRtX3R0X2lzX3JlYWRvbmx5KHR0bSkpCisJCXJhbmdl LT5kZWZhdWx0X2ZsYWdzIHw9IHJhbmdlLT5mbGFnc1tITU1fUEZOX1dSSVRFXTsKIAotCXBmbnMg PSBrdm1hbGxvY19hcnJheSh0dG0tPm51bV9wYWdlcywgc2l6ZW9mKCpwZm5zKSwgR0ZQX0tFUk5F TCk7Ci0JaWYgKHVubGlrZWx5KCFwZm5zKSkgeworCXJhbmdlLT5wZm5zID0ga3ZtYWxsb2NfYXJy YXkodHRtLT5udW1fcGFnZXMsIHNpemVvZigqcmFuZ2UtPnBmbnMpLAorCQkJCSAgICAgR0ZQX0tF Uk5FTCk7CisJaWYgKHVubGlrZWx5KCFyYW5nZS0+cGZucykpIHsKIAkJciA9IC1FTk9NRU07CiAJ CWdvdG8gb3V0X2ZyZWVfcmFuZ2VzOwogCX0KIAotCWFtZGdwdV9obW1faW5pdF9yYW5nZShyYW5n ZSk7Ci0JcmFuZ2UtPmRlZmF1bHRfZmxhZ3MgPSByYW5nZS0+ZmxhZ3NbSE1NX1BGTl9WQUxJRF07 Ci0JcmFuZ2UtPmRlZmF1bHRfZmxhZ3MgfD0gYW1kZ3B1X3R0bV90dF9pc19yZWFkb25seSh0dG0p ID8KLQkJCQkwIDogcmFuZ2UtPmZsYWdzW0hNTV9QRk5fV1JJVEVdOwotCXJhbmdlLT5wZm5fZmxh Z3NfbWFzayA9IDA7Ci0JcmFuZ2UtPnBmbnMgPSBwZm5zOwotCXJhbmdlLT5zdGFydCA9IHN0YXJ0 OwotCXJhbmdlLT5lbmQgPSBzdGFydCArIHR0bS0+bnVtX3BhZ2VzICogUEFHRV9TSVpFOwotCi0J aG1tX3JhbmdlX3JlZ2lzdGVyKHJhbmdlLCBtaXJyb3IpOwotCi0JLyoKLQkgKiBKdXN0IHdhaXQg Zm9yIHJhbmdlIHRvIGJlIHZhbGlkLCBzYWZlIHRvIGlnbm9yZSByZXR1cm4gdmFsdWUgYXMgd2UK LQkgKiB3aWxsIHVzZSB0aGUgcmV0dXJuIHZhbHVlIG9mIGhtbV9yYW5nZV9mYXVsdCgpIGJlbG93 IHVuZGVyIHRoZQotCSAqIG1tYXBfc2VtIHRvIGFzY2VydGFpbiB0aGUgdmFsaWRpdHkgb2YgdGhl IHJhbmdlLgotCSAqLwotCWhtbV9yYW5nZV93YWl0X3VudGlsX3ZhbGlkKHJhbmdlLCBITU1fUkFO R0VfREVGQVVMVF9USU1FT1VUKTsKLQogCWRvd25fcmVhZCgmbW0tPm1tYXBfc2VtKTsKIAl2bWEg PSBmaW5kX3ZtYShtbSwgc3RhcnQpOwogCWlmICh1bmxpa2VseSghdm1hIHx8IHN0YXJ0IDwgdm1h LT52bV9zdGFydCkpIHsKQEAgLTg0NywxOCArODUyLDMxIEBAIGludCBhbWRncHVfdHRtX3R0X2dl dF91c2VyX3BhZ2VzKHN0cnVjdCBhbWRncHVfYm8gKmJvLCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKQog CQlyID0gLUVQRVJNOwogCQlnb3RvIG91dF91bmxvY2s7CiAJfQorCXVwX3JlYWQoJm1tLT5tbWFw X3NlbSk7CisJdGltZW91dCA9IGppZmZpZXMgKyBtc2Vjc190b19qaWZmaWVzKEhNTV9SQU5HRV9E RUZBVUxUX1RJTUVPVVQpOwogCityZXRyeToKKwlyYW5nZS0+bm90aWZpZXJfc2VxID0gbW11X3Jh bmdlX3JlYWRfYmVnaW4oJmJvLT5ub3RpZmllcik7CisKKwlkb3duX3JlYWQoJm1tLT5tbWFwX3Nl bSk7CiAJciA9IGhtbV9yYW5nZV9mYXVsdChyYW5nZSwgMCk7CiAJdXBfcmVhZCgmbW0tPm1tYXBf c2VtKTsKLQotCWlmICh1bmxpa2VseShyIDwgMCkpCisJaWYgKHVubGlrZWx5KHIgPD0gMCkpIHsK KwkJLyoKKwkJICogRklYTUU6IFRoaXMgdGltZW91dCBzaG91bGQgZW5jb21wYXNzIHRoZSByZXRy eSBmcm9tCisJCSAqIG1tdV9yYW5nZV9yZWFkX3JldHJ5KCkgYXMgd2VsbC4KKwkJICovCisJCWlm ICgociA9PSAwIHx8IHIgPT0gLUVCVVNZKSAmJiAhdGltZV9hZnRlcihqaWZmaWVzLCB0aW1lb3V0 KSkKKwkJCWdvdG8gcmV0cnk7CiAJCWdvdG8gb3V0X2ZyZWVfcGZuczsKKwl9CiAKIAlmb3IgKGkg PSAwOyBpIDwgdHRtLT5udW1fcGFnZXM7IGkrKykgewotCQlwYWdlc1tpXSA9IGhtbV9kZXZpY2Vf ZW50cnlfdG9fcGFnZShyYW5nZSwgcGZuc1tpXSk7CisJCS8qIEZJWE1FOiBUaGUgcGFnZXMgY2Fu bm90IGJlIHRvdWNoZWQgb3V0c2lkZSB0aGUgbm90aWZpZXJfbG9jayAqLworCQlwYWdlc1tpXSA9 IGhtbV9kZXZpY2VfZW50cnlfdG9fcGFnZShyYW5nZSwgcmFuZ2UtPnBmbnNbaV0pOwogCQlpZiAo dW5saWtlbHkoIXBhZ2VzW2ldKSkgewogCQkJcHJfZXJyKCJQYWdlIGZhdWx0IGZhaWxlZCBmb3Ig cGZuWyVsdV0gPSAweCVsbHhcbiIsCi0JCQkgICAgICAgaSwgcGZuc1tpXSk7CisJCQkgICAgICAg aSwgcmFuZ2UtPnBmbnNbaV0pOwogCQkJciA9IC1FTk9NRU07CiAKIAkJCWdvdG8gb3V0X2ZyZWVf cGZuczsKQEAgLTg3Myw4ICs4OTEsNyBAQCBpbnQgYW1kZ3B1X3R0bV90dF9nZXRfdXNlcl9wYWdl cyhzdHJ1Y3QgYW1kZ3B1X2JvICpibywgc3RydWN0IHBhZ2UgKipwYWdlcykKIG91dF91bmxvY2s6 CiAJdXBfcmVhZCgmbW0tPm1tYXBfc2VtKTsKIG91dF9mcmVlX3BmbnM6Ci0JaG1tX3JhbmdlX3Vu cmVnaXN0ZXIocmFuZ2UpOwotCWt2ZnJlZShwZm5zKTsKKwlrdmZyZWUocmFuZ2UtPnBmbnMpOwog b3V0X2ZyZWVfcmFuZ2VzOgogCWtmcmVlKHJhbmdlKTsKIG91dDoKQEAgLTkwMywxNSArOTIwLDE4 IEBAIGJvb2wgYW1kZ3B1X3R0bV90dF9nZXRfdXNlcl9wYWdlc19kb25lKHN0cnVjdCB0dG1fdHQg KnR0bSkKIAkJIk5vIHVzZXIgcGFnZXMgdG8gY2hlY2tcbiIpOwogCiAJaWYgKGd0dC0+cmFuZ2Up IHsKLQkJciA9IGhtbV9yYW5nZV92YWxpZChndHQtPnJhbmdlKTsKLQkJaG1tX3JhbmdlX3VucmVn aXN0ZXIoZ3R0LT5yYW5nZSk7Ci0KKwkJLyoKKwkJICogRklYTUU6IE11c3QgYWx3YXlzIGhvbGQg bm90aWZpZXJfbG9jayBmb3IgdGhpcywgYW5kIG11c3QKKwkJICogbm90IGlnbm9yZSB0aGUgcmV0 dXJuIGNvZGUuCisJCSAqLworCQlyID0gbW11X3JhbmdlX3JlYWRfcmV0cnkoZ3R0LT5yYW5nZS0+ bm90aWZpZXIsCisJCQkJCSBndHQtPnJhbmdlLT5ub3RpZmllcl9zZXEpOwogCQlrdmZyZWUoZ3R0 LT5yYW5nZS0+cGZucyk7CiAJCWtmcmVlKGd0dC0+cmFuZ2UpOwogCQlndHQtPnJhbmdlID0gTlVM TDsKIAl9CiAKLQlyZXR1cm4gcjsKKwlyZXR1cm4gIXI7CiB9CiAjZW5kaWYKIApAQCAtOTkyLDEw ICsxMDEyLDE4IEBAIHN0YXRpYyB2b2lkIGFtZGdwdV90dG1fdHRfdW5waW5fdXNlcnB0cihzdHJ1 Y3QgdHRtX3R0ICp0dG0pCiAJc2dfZnJlZV90YWJsZSh0dG0tPnNnKTsKIAogI2lmIElTX0VOQUJM RUQoQ09ORklHX0RSTV9BTURHUFVfVVNFUlBUUikKLQlpZiAoZ3R0LT5yYW5nZSAmJgotCSAgICB0 dG0tPnBhZ2VzWzBdID09IGhtbV9kZXZpY2VfZW50cnlfdG9fcGFnZShndHQtPnJhbmdlLAotCQkJ CQkJICAgICAgZ3R0LT5yYW5nZS0+cGZuc1swXSkpCi0JCVdBUk5fT05DRSgxLCAiTWlzc2luZyBn ZXRfdXNlcl9wYWdlX2RvbmVcbiIpOworCWlmIChndHQtPnJhbmdlKSB7CisJCXVuc2lnbmVkIGxv bmcgaTsKKworCQlmb3IgKGkgPSAwOyBpIDwgdHRtLT5udW1fcGFnZXM7IGkrKykgeworCQkJaWYg KHR0bS0+cGFnZXNbaV0gIT0KKwkJCQlobW1fZGV2aWNlX2VudHJ5X3RvX3BhZ2UoZ3R0LT5yYW5n ZSwKKwkJCQkJICAgICAgZ3R0LT5yYW5nZS0+cGZuc1tpXSkpCisJCQkJYnJlYWs7CisJCX0KKwor CQlXQVJOKChpID09IHR0bS0+bnVtX3BhZ2VzKSwgIk1pc3NpbmcgZ2V0X3VzZXJfcGFnZV9kb25l XG4iKTsKKwl9CiAjZW5kaWYKIH0KIAotLSAKMi4yMy4wCgpfX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fXwphbWQtZ2Z4IG1haWxpbmcgbGlzdAphbWQtZ2Z4QGxp c3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFu L2xpc3RpbmZvL2FtZC1nZng=