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=-15.3 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,NICE_REPLY_A,SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_1 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 90C21C433B4 for ; Tue, 18 May 2021 08:59:46 +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 311446135B for ; Tue, 18 May 2021 08:59:46 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 311446135B Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.intel.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 60FED6EAD1; Tue, 18 May 2021 08:59:45 +0000 (UTC) Received: from mga07.intel.com (mga07.intel.com [134.134.136.100]) by gabe.freedesktop.org (Postfix) with ESMTPS id F33DD6EAD1; Tue, 18 May 2021 08:59:43 +0000 (UTC) IronPort-SDR: DmLnXFckeuWPuDYEaRBuwA6/Lm8ZG6lDeG3sVLwsZIx5JUw663awOsEYdBYxdMXkVYWv6h0WuG kSNMqWtIElvg== X-IronPort-AV: E=McAfee;i="6200,9189,9987"; a="264577174" X-IronPort-AV: E=Sophos;i="5.82,309,1613462400"; d="scan'208";a="264577174" Received: from fmsmga003.fm.intel.com ([10.253.24.29]) by orsmga105.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 18 May 2021 01:59:43 -0700 IronPort-SDR: 6ePXdr3bJxWPmvJW8eEIMS5tsen+WkLYPg5GTMiWT10jOtKj85TTgTn+Y6sZu19l1uCzxriA/h FFJeOYNG+TUg== X-IronPort-AV: E=Sophos;i="5.82,309,1613462400"; d="scan'208";a="466331559" Received: from cmutgix-mobl.gar.corp.intel.com (HELO [10.249.254.195]) ([10.249.254.195]) by fmsmga003-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 18 May 2021 01:59:41 -0700 Subject: Re: [Intel-gfx] [PATCH v2 13/15] drm/ttm: Add BO and offset arguments for vm_access and vm_fault ttm handlers. From: =?UTF-8?Q?Thomas_Hellstr=c3=b6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org References: <20210518082701.997251-1-thomas.hellstrom@linux.intel.com> <20210518082701.997251-14-thomas.hellstrom@linux.intel.com> Message-ID: <7ce49dd3-d4f9-61c1-dcc6-a5d303dc36fc@linux.intel.com> Date: Tue, 18 May 2021 10:59:39 +0200 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Thunderbird/78.10.1 MIME-Version: 1.0 In-Reply-To: <20210518082701.997251-14-thomas.hellstrom@linux.intel.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit Content-Language: en-US X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: =?UTF-8?Q?Christian_K=c3=b6nig?= Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" + Christian König On 5/18/21 10:26 AM, Thomas Hellström wrote: > From: Maarten Lankhorst > > This allows other drivers that may not setup the vma in the same way > to use the ttm bo helpers. > > Also clarify the documentation a bit, especially related to VM_FAULT_RETRY. > > Signed-off-by: Maarten Lankhorst Lgtm. Reviewed-by: Thomas Hellström > --- > drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c | 4 +- > drivers/gpu/drm/nouveau/nouveau_ttm.c | 4 +- > drivers/gpu/drm/radeon/radeon_ttm.c | 4 +- > drivers/gpu/drm/ttm/ttm_bo_vm.c | 84 +++++++++++++--------- > drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c | 8 ++- > include/drm/ttm/ttm_bo_api.h | 9 ++- > 6 files changed, 75 insertions(+), 38 deletions(-) > > diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c > index d5a9d7a88315..89dafe14f828 100644 > --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c > +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c > @@ -1919,7 +1919,9 @@ static vm_fault_t amdgpu_ttm_fault(struct vm_fault *vmf) > if (ret) > goto unlock; > > - ret = ttm_bo_vm_fault_reserved(vmf, vmf->vma->vm_page_prot, > + ret = ttm_bo_vm_fault_reserved(bo, vmf, > + drm_vma_node_start(&bo->base.vma_node), > + vmf->vma->vm_page_prot, > TTM_BO_VM_NUM_PREFAULT, 1); > if (ret == VM_FAULT_RETRY && !(vmf->flags & FAULT_FLAG_RETRY_NOWAIT)) > return ret; > diff --git a/drivers/gpu/drm/nouveau/nouveau_ttm.c b/drivers/gpu/drm/nouveau/nouveau_ttm.c > index b81ae90b8449..555fb6d8be8b 100644 > --- a/drivers/gpu/drm/nouveau/nouveau_ttm.c > +++ b/drivers/gpu/drm/nouveau/nouveau_ttm.c > @@ -144,7 +144,9 @@ static vm_fault_t nouveau_ttm_fault(struct vm_fault *vmf) > > nouveau_bo_del_io_reserve_lru(bo); > prot = vm_get_page_prot(vma->vm_flags); > - ret = ttm_bo_vm_fault_reserved(vmf, prot, TTM_BO_VM_NUM_PREFAULT, 1); > + ret = ttm_bo_vm_fault_reserved(bo, vmf, > + drm_vma_node_start(&bo->base.vma_node), > + prot, TTM_BO_VM_NUM_PREFAULT, 1); > nouveau_bo_add_io_reserve_lru(bo); > if (ret == VM_FAULT_RETRY && !(vmf->flags & FAULT_FLAG_RETRY_NOWAIT)) > return ret; > diff --git a/drivers/gpu/drm/radeon/radeon_ttm.c b/drivers/gpu/drm/radeon/radeon_ttm.c > index 3361d11769a2..ba48a2acdef0 100644 > --- a/drivers/gpu/drm/radeon/radeon_ttm.c > +++ b/drivers/gpu/drm/radeon/radeon_ttm.c > @@ -816,7 +816,9 @@ static vm_fault_t radeon_ttm_fault(struct vm_fault *vmf) > if (ret) > goto unlock_resv; > > - ret = ttm_bo_vm_fault_reserved(vmf, vmf->vma->vm_page_prot, > + ret = ttm_bo_vm_fault_reserved(bo, vmf, > + drm_vma_node_start(&bo->base.vma_node), > + vmf->vma->vm_page_prot, > TTM_BO_VM_NUM_PREFAULT, 1); > if (ret == VM_FAULT_RETRY && !(vmf->flags & FAULT_FLAG_RETRY_NOWAIT)) > goto unlock_mclk; > diff --git a/drivers/gpu/drm/ttm/ttm_bo_vm.c b/drivers/gpu/drm/ttm/ttm_bo_vm.c > index b31b18058965..ed00ccf1376e 100644 > --- a/drivers/gpu/drm/ttm/ttm_bo_vm.c > +++ b/drivers/gpu/drm/ttm/ttm_bo_vm.c > @@ -42,7 +42,7 @@ > #include > > static vm_fault_t ttm_bo_vm_fault_idle(struct ttm_buffer_object *bo, > - struct vm_fault *vmf) > + struct vm_fault *vmf) > { > vm_fault_t ret = 0; > int err = 0; > @@ -122,7 +122,8 @@ static unsigned long ttm_bo_io_mem_pfn(struct ttm_buffer_object *bo, > * Return: > * 0 on success and the bo was reserved. > * VM_FAULT_RETRY if blocking wait. > - * VM_FAULT_NOPAGE if blocking wait and retrying was not allowed. > + * VM_FAULT_NOPAGE if blocking wait and retrying was not allowed, or wait interrupted. > + * VM_FAULT_SIGBUS if wait on bo->moving failed for reason other than a signal. > */ > vm_fault_t ttm_bo_vm_reserve(struct ttm_buffer_object *bo, > struct vm_fault *vmf) > @@ -254,7 +255,9 @@ static vm_fault_t ttm_bo_vm_insert_huge(struct vm_fault *vmf, > > /** > * ttm_bo_vm_fault_reserved - TTM fault helper > + * @bo: The buffer object > * @vmf: The struct vm_fault given as argument to the fault callback > + * @mmap_base: The base of the mmap, to which the @vmf fault is relative to. > * @prot: The page protection to be used for this memory area. > * @num_prefault: Maximum number of prefault pages. The caller may want to > * specify this based on madvice settings and the size of the GPU object > @@ -265,19 +268,28 @@ static vm_fault_t ttm_bo_vm_insert_huge(struct vm_fault *vmf, > * memory backing the buffer object, and then returns a return code > * instructing the caller to retry the page access. > * > + * This function ensures any pipelined wait is finished. > + * > + * WARNING: > + * On VM_FAULT_RETRY, the bo will be unlocked by this function when > + * #FAULT_FLAG_RETRY_NOWAIT is not set inside @vmf->flags. In this > + * case, the caller should not unlock the @bo. > + * > * Return: > - * VM_FAULT_NOPAGE on success or pending signal > + * 0 on success. > + * VM_FAULT_NOPAGE on pending signal > * VM_FAULT_SIGBUS on unspecified error > * VM_FAULT_OOM on out-of-memory > - * VM_FAULT_RETRY if retryable wait > + * VM_FAULT_RETRY if retryable wait, see WARNING above. > */ > -vm_fault_t ttm_bo_vm_fault_reserved(struct vm_fault *vmf, > +vm_fault_t ttm_bo_vm_fault_reserved(struct ttm_buffer_object *bo, > + struct vm_fault *vmf, > + unsigned long mmap_base, > pgprot_t prot, > pgoff_t num_prefault, > pgoff_t fault_page_size) > { > struct vm_area_struct *vma = vmf->vma; > - struct ttm_buffer_object *bo = vma->vm_private_data; > struct ttm_device *bdev = bo->bdev; > unsigned long page_offset; > unsigned long page_last; > @@ -286,15 +298,11 @@ vm_fault_t ttm_bo_vm_fault_reserved(struct vm_fault *vmf, > struct page *page; > int err; > pgoff_t i; > - vm_fault_t ret = VM_FAULT_NOPAGE; > + vm_fault_t ret; > unsigned long address = vmf->address; > > - /* > - * Wait for buffer data in transit, due to a pipelined > - * move. > - */ > ret = ttm_bo_vm_fault_idle(bo, vmf); > - if (unlikely(ret != 0)) > + if (ret) > return ret; > > err = ttm_mem_io_reserve(bdev, &bo->mem); > @@ -302,9 +310,8 @@ vm_fault_t ttm_bo_vm_fault_reserved(struct vm_fault *vmf, > return VM_FAULT_SIGBUS; > > page_offset = ((address - vma->vm_start) >> PAGE_SHIFT) + > - vma->vm_pgoff - drm_vma_node_start(&bo->base.vma_node); > - page_last = vma_pages(vma) + vma->vm_pgoff - > - drm_vma_node_start(&bo->base.vma_node); > + vma->vm_pgoff - mmap_base; > + page_last = vma_pages(vma) + vma->vm_pgoff - mmap_base; > > if (unlikely(page_offset >= bo->mem.num_pages)) > return VM_FAULT_SIGBUS; > @@ -344,8 +351,7 @@ vm_fault_t ttm_bo_vm_fault_reserved(struct vm_fault *vmf, > } else if (unlikely(!page)) { > break; > } > - page->index = drm_vma_node_start(&bo->base.vma_node) + > - page_offset; > + page->index = mmap_base + page_offset; > pfn = page_to_pfn(page); > } > > @@ -392,7 +398,10 @@ vm_fault_t ttm_bo_vm_fault(struct vm_fault *vmf) > return ret; > > prot = vma->vm_page_prot; > - ret = ttm_bo_vm_fault_reserved(vmf, prot, TTM_BO_VM_NUM_PREFAULT, 1); > + ret = ttm_bo_vm_fault_reserved(bo, vmf, > + drm_vma_node_start(&bo->base.vma_node), > + prot, TTM_BO_VM_NUM_PREFAULT, 1); > + > if (ret == VM_FAULT_RETRY && !(vmf->flags & FAULT_FLAG_RETRY_NOWAIT)) > return ret; > > @@ -460,22 +469,16 @@ static int ttm_bo_vm_access_kmap(struct ttm_buffer_object *bo, > return len; > } > > -int ttm_bo_vm_access(struct vm_area_struct *vma, unsigned long addr, > - void *buf, int len, int write) > +int ttm_bo_vm_access_reserved(struct ttm_buffer_object *bo, > + struct vm_area_struct *vma, > + unsigned long offset, > + void *buf, int len, int write) > { > - struct ttm_buffer_object *bo = vma->vm_private_data; > - unsigned long offset = (addr) - vma->vm_start + > - ((vma->vm_pgoff - drm_vma_node_start(&bo->base.vma_node)) > - << PAGE_SHIFT); > int ret; > > if (len < 1 || (offset + len) >> PAGE_SHIFT > bo->mem.num_pages) > return -EIO; > > - ret = ttm_bo_reserve(bo, true, false, NULL); > - if (ret) > - return ret; > - > switch (bo->mem.mem_type) { > case TTM_PL_SYSTEM: > if (unlikely(bo->ttm->page_flags & TTM_PAGE_FLAG_SWAPPED)) { > @@ -485,16 +488,33 @@ int ttm_bo_vm_access(struct vm_area_struct *vma, unsigned long addr, > } > fallthrough; > case TTM_PL_TT: > - ret = ttm_bo_vm_access_kmap(bo, offset, buf, len, write); > - break; > + return ttm_bo_vm_access_kmap(bo, offset, buf, len, write); > default: > if (bo->bdev->funcs->access_memory) > - ret = bo->bdev->funcs->access_memory( > + return bo->bdev->funcs->access_memory( > bo, offset, buf, len, write); > else > - ret = -EIO; > + return -EIO; > } > > + return ret; > +} > +EXPORT_SYMBOL(ttm_bo_vm_access_reserved); > + > +int ttm_bo_vm_access(struct vm_area_struct *vma, unsigned long addr, > + void *buf, int len, int write) > +{ > + struct ttm_buffer_object *bo = vma->vm_private_data; > + unsigned long offset = (addr) - vma->vm_start + > + ((vma->vm_pgoff - drm_vma_node_start(&bo->base.vma_node)) > + << PAGE_SHIFT); > + int ret; > + > + ret = ttm_bo_reserve(bo, true, false, NULL); > + if (ret) > + return ret; > + > + ret = ttm_bo_vm_access_reserved(bo, vma, offset, buf, len, write); > ttm_bo_unreserve(bo); > > return ret; > diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c b/drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c > index 45c9c6a7f1d6..56ecace0cf5c 100644 > --- a/drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c > +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c > @@ -477,7 +477,9 @@ vm_fault_t vmw_bo_vm_fault(struct vm_fault *vmf) > else > prot = vm_get_page_prot(vma->vm_flags); > > - ret = ttm_bo_vm_fault_reserved(vmf, prot, num_prefault, 1); > + ret = ttm_bo_vm_fault_reserved(bo, vmf, > + drm_vma_node_start(&bo->base.vma_node), > + prot, num_prefault, 1); > if (ret == VM_FAULT_RETRY && !(vmf->flags & FAULT_FLAG_RETRY_NOWAIT)) > return ret; > > @@ -546,7 +548,9 @@ vm_fault_t vmw_bo_vm_huge_fault(struct vm_fault *vmf, > prot = vm_get_page_prot(vma->vm_flags); > } > > - ret = ttm_bo_vm_fault_reserved(vmf, prot, 1, fault_page_size); > + ret = ttm_bo_vm_fault_reserved(bo, vmf, > + drm_vma_node_start(&bo->base.vma_node), > + prot, 1, fault_page_size); > if (ret == VM_FAULT_RETRY && !(vmf->flags & FAULT_FLAG_RETRY_NOWAIT)) > return ret; > > diff --git a/include/drm/ttm/ttm_bo_api.h b/include/drm/ttm/ttm_bo_api.h > index 639521880c29..434f91f1fdbf 100644 > --- a/include/drm/ttm/ttm_bo_api.h > +++ b/include/drm/ttm/ttm_bo_api.h > @@ -605,7 +605,9 @@ int ttm_mem_evict_first(struct ttm_device *bdev, > vm_fault_t ttm_bo_vm_reserve(struct ttm_buffer_object *bo, > struct vm_fault *vmf); > > -vm_fault_t ttm_bo_vm_fault_reserved(struct vm_fault *vmf, > +vm_fault_t ttm_bo_vm_fault_reserved(struct ttm_buffer_object *bo, > + struct vm_fault *vmf, > + unsigned long mmap_base, > pgprot_t prot, > pgoff_t num_prefault, > pgoff_t fault_page_size); > @@ -616,6 +618,11 @@ void ttm_bo_vm_open(struct vm_area_struct *vma); > > void ttm_bo_vm_close(struct vm_area_struct *vma); > > +int ttm_bo_vm_access_reserved(struct ttm_buffer_object *bo, > + struct vm_area_struct *vma, > + unsigned long offset, > + void *buf, int len, int write); > + > int ttm_bo_vm_access(struct vm_area_struct *vma, unsigned long addr, > void *buf, int len, int write); > bool ttm_bo_delayed_delete(struct ttm_device *bdev, bool remove_all); 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=-15.3 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,NICE_REPLY_A,SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_1 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 A64D9C43460 for ; Tue, 18 May 2021 08:59:47 +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 6ED2361285 for ; Tue, 18 May 2021 08:59:47 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 6ED2361285 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=intel-gfx-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 7B3066EADA; Tue, 18 May 2021 08:59:45 +0000 (UTC) Received: from mga07.intel.com (mga07.intel.com [134.134.136.100]) by gabe.freedesktop.org (Postfix) with ESMTPS id F33DD6EAD1; Tue, 18 May 2021 08:59:43 +0000 (UTC) IronPort-SDR: DmLnXFckeuWPuDYEaRBuwA6/Lm8ZG6lDeG3sVLwsZIx5JUw663awOsEYdBYxdMXkVYWv6h0WuG kSNMqWtIElvg== X-IronPort-AV: E=McAfee;i="6200,9189,9987"; a="264577174" X-IronPort-AV: E=Sophos;i="5.82,309,1613462400"; d="scan'208";a="264577174" Received: from fmsmga003.fm.intel.com ([10.253.24.29]) by orsmga105.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 18 May 2021 01:59:43 -0700 IronPort-SDR: 6ePXdr3bJxWPmvJW8eEIMS5tsen+WkLYPg5GTMiWT10jOtKj85TTgTn+Y6sZu19l1uCzxriA/h FFJeOYNG+TUg== X-IronPort-AV: E=Sophos;i="5.82,309,1613462400"; d="scan'208";a="466331559" Received: from cmutgix-mobl.gar.corp.intel.com (HELO [10.249.254.195]) ([10.249.254.195]) by fmsmga003-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 18 May 2021 01:59:41 -0700 From: =?UTF-8?Q?Thomas_Hellstr=c3=b6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org References: <20210518082701.997251-1-thomas.hellstrom@linux.intel.com> <20210518082701.997251-14-thomas.hellstrom@linux.intel.com> Message-ID: <7ce49dd3-d4f9-61c1-dcc6-a5d303dc36fc@linux.intel.com> Date: Tue, 18 May 2021 10:59:39 +0200 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Thunderbird/78.10.1 MIME-Version: 1.0 In-Reply-To: <20210518082701.997251-14-thomas.hellstrom@linux.intel.com> Content-Language: en-US Subject: Re: [Intel-gfx] [PATCH v2 13/15] drm/ttm: Add BO and offset arguments for vm_access and vm_fault ttm handlers. X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: =?UTF-8?Q?Christian_K=c3=b6nig?= Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" KyBDaHJpc3RpYW4gS8O2bmlnCgpPbiA1LzE4LzIxIDEwOjI2IEFNLCBUaG9tYXMgSGVsbHN0csO2 bSB3cm90ZToKPiBGcm9tOiBNYWFydGVuIExhbmtob3JzdCA8bWFhcnRlbi5sYW5raG9yc3RAbGlu dXguaW50ZWwuY29tPgo+Cj4gVGhpcyBhbGxvd3Mgb3RoZXIgZHJpdmVycyB0aGF0IG1heSBub3Qg c2V0dXAgdGhlIHZtYSBpbiB0aGUgc2FtZSB3YXkKPiB0byB1c2UgdGhlIHR0bSBibyBoZWxwZXJz Lgo+Cj4gQWxzbyBjbGFyaWZ5IHRoZSBkb2N1bWVudGF0aW9uIGEgYml0LCBlc3BlY2lhbGx5IHJl bGF0ZWQgdG8gVk1fRkFVTFRfUkVUUlkuCj4KPiBTaWduZWQtb2ZmLWJ5OiBNYWFydGVuIExhbmto b3JzdCA8bWFhcnRlbi5sYW5raG9yc3RAbGludXguaW50ZWwuY29tPgoKTGd0bS4gUmV2aWV3ZWQt Ynk6IFRob21hcyBIZWxsc3Ryw7ZtIDx0aG9tYXMuaGVsbHN0cm9tQGxpbnV4LmludGVsLmNvbT4K Cj4gLS0tCj4gICBkcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfdHRtLmMgICAgfCAg NCArLQo+ICAgZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV90dG0uYyAgICAgIHwgIDQg Ky0KPiAgIGRyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX3R0bS5jICAgICAgICB8ICA0ICst Cj4gICBkcml2ZXJzL2dwdS9kcm0vdHRtL3R0bV9ib192bS5jICAgICAgICAgICAgfCA4NCArKysr KysrKysrKysrLS0tLS0tLS0tCj4gICBkcml2ZXJzL2dwdS9kcm0vdm13Z2Z4L3Ztd2dmeF9wYWdl X2RpcnR5LmMgfCAgOCArKy0KPiAgIGluY2x1ZGUvZHJtL3R0bS90dG1fYm9fYXBpLmggICAgICAg ICAgICAgICB8ICA5ICsrLQo+ICAgNiBmaWxlcyBjaGFuZ2VkLCA3NSBpbnNlcnRpb25zKCspLCAz OCBkZWxldGlvbnMoLSkKPgo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdw dS9hbWRncHVfdHRtLmMgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfdHRtLmMK PiBpbmRleCBkNWE5ZDdhODgzMTUuLjg5ZGFmZTE0ZjgyOCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJz L2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfdHRtLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0v YW1kL2FtZGdwdS9hbWRncHVfdHRtLmMKPiBAQCAtMTkxOSw3ICsxOTE5LDkgQEAgc3RhdGljIHZt X2ZhdWx0X3QgYW1kZ3B1X3R0bV9mYXVsdChzdHJ1Y3Qgdm1fZmF1bHQgKnZtZikKPiAgIAlpZiAo cmV0KQo+ICAgCQlnb3RvIHVubG9jazsKPiAgIAo+IC0JcmV0ID0gdHRtX2JvX3ZtX2ZhdWx0X3Jl c2VydmVkKHZtZiwgdm1mLT52bWEtPnZtX3BhZ2VfcHJvdCwKPiArCXJldCA9IHR0bV9ib192bV9m YXVsdF9yZXNlcnZlZChibywgdm1mLAo+ICsJCQkJICAgICAgIGRybV92bWFfbm9kZV9zdGFydCgm Ym8tPmJhc2Uudm1hX25vZGUpLAo+ICsJCQkJICAgICAgIHZtZi0+dm1hLT52bV9wYWdlX3Byb3Qs Cj4gICAJCQkJICAgICAgIFRUTV9CT19WTV9OVU1fUFJFRkFVTFQsIDEpOwo+ICAgCWlmIChyZXQg PT0gVk1fRkFVTFRfUkVUUlkgJiYgISh2bWYtPmZsYWdzICYgRkFVTFRfRkxBR19SRVRSWV9OT1dB SVQpKQo+ICAgCQlyZXR1cm4gcmV0Owo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbm91 dmVhdS9ub3V2ZWF1X3R0bS5jIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbm91dmVhdV90dG0u Ywo+IGluZGV4IGI4MWFlOTBiODQ0OS4uNTU1ZmI2ZDhiZThiIDEwMDY0NAo+IC0tLSBhL2RyaXZl cnMvZ3B1L2RybS9ub3V2ZWF1L25vdXZlYXVfdHRtLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0v bm91dmVhdS9ub3V2ZWF1X3R0bS5jCj4gQEAgLTE0NCw3ICsxNDQsOSBAQCBzdGF0aWMgdm1fZmF1 bHRfdCBub3V2ZWF1X3R0bV9mYXVsdChzdHJ1Y3Qgdm1fZmF1bHQgKnZtZikKPiAgIAo+ICAgCW5v dXZlYXVfYm9fZGVsX2lvX3Jlc2VydmVfbHJ1KGJvKTsKPiAgIAlwcm90ID0gdm1fZ2V0X3BhZ2Vf cHJvdCh2bWEtPnZtX2ZsYWdzKTsKPiAtCXJldCA9IHR0bV9ib192bV9mYXVsdF9yZXNlcnZlZCh2 bWYsIHByb3QsIFRUTV9CT19WTV9OVU1fUFJFRkFVTFQsIDEpOwo+ICsJcmV0ID0gdHRtX2JvX3Zt X2ZhdWx0X3Jlc2VydmVkKGJvLCB2bWYsCj4gKwkJCQkgICAgICAgZHJtX3ZtYV9ub2RlX3N0YXJ0 KCZiby0+YmFzZS52bWFfbm9kZSksCj4gKwkJCQkgICAgICAgcHJvdCwgVFRNX0JPX1ZNX05VTV9Q UkVGQVVMVCwgMSk7Cj4gICAJbm91dmVhdV9ib19hZGRfaW9fcmVzZXJ2ZV9scnUoYm8pOwo+ICAg CWlmIChyZXQgPT0gVk1fRkFVTFRfUkVUUlkgJiYgISh2bWYtPmZsYWdzICYgRkFVTFRfRkxBR19S RVRSWV9OT1dBSVQpKQo+ICAgCQlyZXR1cm4gcmV0Owo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0vcmFkZW9uL3JhZGVvbl90dG0uYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9u X3R0bS5jCj4gaW5kZXggMzM2MWQxMTc2OWEyLi5iYTQ4YTJhY2RlZjAgMTAwNjQ0Cj4gLS0tIGEv ZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fdHRtLmMKPiArKysgYi9kcml2ZXJzL2dwdS9k cm0vcmFkZW9uL3JhZGVvbl90dG0uYwo+IEBAIC04MTYsNyArODE2LDkgQEAgc3RhdGljIHZtX2Zh dWx0X3QgcmFkZW9uX3R0bV9mYXVsdChzdHJ1Y3Qgdm1fZmF1bHQgKnZtZikKPiAgIAlpZiAocmV0 KQo+ICAgCQlnb3RvIHVubG9ja19yZXN2Owo+ICAgCj4gLQlyZXQgPSB0dG1fYm9fdm1fZmF1bHRf cmVzZXJ2ZWQodm1mLCB2bWYtPnZtYS0+dm1fcGFnZV9wcm90LAo+ICsJcmV0ID0gdHRtX2JvX3Zt X2ZhdWx0X3Jlc2VydmVkKGJvLCB2bWYsCj4gKwkJCQkgICAgICAgZHJtX3ZtYV9ub2RlX3N0YXJ0 KCZiby0+YmFzZS52bWFfbm9kZSksCj4gKwkJCQkgICAgICAgdm1mLT52bWEtPnZtX3BhZ2VfcHJv dCwKPiAgIAkJCQkgICAgICAgVFRNX0JPX1ZNX05VTV9QUkVGQVVMVCwgMSk7Cj4gICAJaWYgKHJl dCA9PSBWTV9GQVVMVF9SRVRSWSAmJiAhKHZtZi0+ZmxhZ3MgJiBGQVVMVF9GTEFHX1JFVFJZX05P V0FJVCkpCj4gICAJCWdvdG8gdW5sb2NrX21jbGs7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS90dG0vdHRtX2JvX3ZtLmMgYi9kcml2ZXJzL2dwdS9kcm0vdHRtL3R0bV9ib192bS5jCj4g aW5kZXggYjMxYjE4MDU4OTY1Li5lZDAwY2NmMTM3NmUgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9n cHUvZHJtL3R0bS90dG1fYm9fdm0uYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS90dG0vdHRtX2Jv X3ZtLmMKPiBAQCAtNDIsNyArNDIsNyBAQAo+ICAgI2luY2x1ZGUgPGxpbnV4L21lbV9lbmNyeXB0 Lmg+Cj4gICAKPiAgIHN0YXRpYyB2bV9mYXVsdF90IHR0bV9ib192bV9mYXVsdF9pZGxlKHN0cnVj dCB0dG1fYnVmZmVyX29iamVjdCAqYm8sCj4gLQkJCQlzdHJ1Y3Qgdm1fZmF1bHQgKnZtZikKPiAr CQkJCSAgICAgICBzdHJ1Y3Qgdm1fZmF1bHQgKnZtZikKPiAgIHsKPiAgIAl2bV9mYXVsdF90IHJl dCA9IDA7Cj4gICAJaW50IGVyciA9IDA7Cj4gQEAgLTEyMiw3ICsxMjIsOCBAQCBzdGF0aWMgdW5z aWduZWQgbG9uZyB0dG1fYm9faW9fbWVtX3BmbihzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJv LAo+ICAgICogUmV0dXJuOgo+ICAgICogICAgMCBvbiBzdWNjZXNzIGFuZCB0aGUgYm8gd2FzIHJl c2VydmVkLgo+ICAgICogICAgVk1fRkFVTFRfUkVUUlkgaWYgYmxvY2tpbmcgd2FpdC4KPiAtICog ICAgVk1fRkFVTFRfTk9QQUdFIGlmIGJsb2NraW5nIHdhaXQgYW5kIHJldHJ5aW5nIHdhcyBub3Qg YWxsb3dlZC4KPiArICogICAgVk1fRkFVTFRfTk9QQUdFIGlmIGJsb2NraW5nIHdhaXQgYW5kIHJl dHJ5aW5nIHdhcyBub3QgYWxsb3dlZCwgb3Igd2FpdCBpbnRlcnJ1cHRlZC4KPiArICogICAgVk1f RkFVTFRfU0lHQlVTIGlmIHdhaXQgb24gYm8tPm1vdmluZyBmYWlsZWQgZm9yIHJlYXNvbiBvdGhl ciB0aGFuIGEgc2lnbmFsLgo+ICAgICovCj4gICB2bV9mYXVsdF90IHR0bV9ib192bV9yZXNlcnZl KHN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8sCj4gICAJCQkgICAgIHN0cnVjdCB2bV9mYXVs dCAqdm1mKQo+IEBAIC0yNTQsNyArMjU1LDkgQEAgc3RhdGljIHZtX2ZhdWx0X3QgdHRtX2JvX3Zt X2luc2VydF9odWdlKHN0cnVjdCB2bV9mYXVsdCAqdm1mLAo+ICAgCj4gICAvKioKPiAgICAqIHR0 bV9ib192bV9mYXVsdF9yZXNlcnZlZCAtIFRUTSBmYXVsdCBoZWxwZXIKPiArICogQGJvOiBUaGUg YnVmZmVyIG9iamVjdAo+ICAgICogQHZtZjogVGhlIHN0cnVjdCB2bV9mYXVsdCBnaXZlbiBhcyBh cmd1bWVudCB0byB0aGUgZmF1bHQgY2FsbGJhY2sKPiArICogQG1tYXBfYmFzZTogVGhlIGJhc2Ug b2YgdGhlIG1tYXAsIHRvIHdoaWNoIHRoZSBAdm1mIGZhdWx0IGlzIHJlbGF0aXZlIHRvLgo+ICAg ICogQHByb3Q6IFRoZSBwYWdlIHByb3RlY3Rpb24gdG8gYmUgdXNlZCBmb3IgdGhpcyBtZW1vcnkg YXJlYS4KPiAgICAqIEBudW1fcHJlZmF1bHQ6IE1heGltdW0gbnVtYmVyIG9mIHByZWZhdWx0IHBh Z2VzLiBUaGUgY2FsbGVyIG1heSB3YW50IHRvCj4gICAgKiBzcGVjaWZ5IHRoaXMgYmFzZWQgb24g bWFkdmljZSBzZXR0aW5ncyBhbmQgdGhlIHNpemUgb2YgdGhlIEdQVSBvYmplY3QKPiBAQCAtMjY1 LDE5ICsyNjgsMjggQEAgc3RhdGljIHZtX2ZhdWx0X3QgdHRtX2JvX3ZtX2luc2VydF9odWdlKHN0 cnVjdCB2bV9mYXVsdCAqdm1mLAo+ICAgICogbWVtb3J5IGJhY2tpbmcgdGhlIGJ1ZmZlciBvYmpl Y3QsIGFuZCB0aGVuIHJldHVybnMgYSByZXR1cm4gY29kZQo+ICAgICogaW5zdHJ1Y3RpbmcgdGhl IGNhbGxlciB0byByZXRyeSB0aGUgcGFnZSBhY2Nlc3MuCj4gICAgKgo+ICsgKiBUaGlzIGZ1bmN0 aW9uIGVuc3VyZXMgYW55IHBpcGVsaW5lZCB3YWl0IGlzIGZpbmlzaGVkLgo+ICsgKgo+ICsgKiBX QVJOSU5HOgo+ICsgKiBPbiBWTV9GQVVMVF9SRVRSWSwgdGhlIGJvIHdpbGwgYmUgdW5sb2NrZWQg YnkgdGhpcyBmdW5jdGlvbiB3aGVuCj4gKyAqICNGQVVMVF9GTEFHX1JFVFJZX05PV0FJVCBpcyBu b3Qgc2V0IGluc2lkZSBAdm1mLT5mbGFncy4gSW4gdGhpcwo+ICsgKiBjYXNlLCB0aGUgY2FsbGVy IHNob3VsZCBub3QgdW5sb2NrIHRoZSBAYm8uCj4gKyAqCj4gICAgKiBSZXR1cm46Cj4gLSAqICAg Vk1fRkFVTFRfTk9QQUdFIG9uIHN1Y2Nlc3Mgb3IgcGVuZGluZyBzaWduYWwKPiArICogICAwIG9u IHN1Y2Nlc3MuCj4gKyAqICAgVk1fRkFVTFRfTk9QQUdFIG9uIHBlbmRpbmcgc2lnbmFsCj4gICAg KiAgIFZNX0ZBVUxUX1NJR0JVUyBvbiB1bnNwZWNpZmllZCBlcnJvcgo+ICAgICogICBWTV9GQVVM VF9PT00gb24gb3V0LW9mLW1lbW9yeQo+IC0gKiAgIFZNX0ZBVUxUX1JFVFJZIGlmIHJldHJ5YWJs ZSB3YWl0Cj4gKyAqICAgVk1fRkFVTFRfUkVUUlkgaWYgcmV0cnlhYmxlIHdhaXQsIHNlZSBXQVJO SU5HIGFib3ZlLgo+ICAgICovCj4gLXZtX2ZhdWx0X3QgdHRtX2JvX3ZtX2ZhdWx0X3Jlc2VydmVk KHN0cnVjdCB2bV9mYXVsdCAqdm1mLAo+ICt2bV9mYXVsdF90IHR0bV9ib192bV9mYXVsdF9yZXNl cnZlZChzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvLAo+ICsJCQkJICAgIHN0cnVjdCB2bV9m YXVsdCAqdm1mLAo+ICsJCQkJICAgIHVuc2lnbmVkIGxvbmcgbW1hcF9iYXNlLAo+ICAgCQkJCSAg ICBwZ3Byb3RfdCBwcm90LAo+ICAgCQkJCSAgICBwZ29mZl90IG51bV9wcmVmYXVsdCwKPiAgIAkJ CQkgICAgcGdvZmZfdCBmYXVsdF9wYWdlX3NpemUpCj4gICB7Cj4gICAJc3RydWN0IHZtX2FyZWFf c3RydWN0ICp2bWEgPSB2bWYtPnZtYTsKPiAtCXN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8g PSB2bWEtPnZtX3ByaXZhdGVfZGF0YTsKPiAgIAlzdHJ1Y3QgdHRtX2RldmljZSAqYmRldiA9IGJv LT5iZGV2Owo+ICAgCXVuc2lnbmVkIGxvbmcgcGFnZV9vZmZzZXQ7Cj4gICAJdW5zaWduZWQgbG9u ZyBwYWdlX2xhc3Q7Cj4gQEAgLTI4NiwxNSArMjk4LDExIEBAIHZtX2ZhdWx0X3QgdHRtX2JvX3Zt X2ZhdWx0X3Jlc2VydmVkKHN0cnVjdCB2bV9mYXVsdCAqdm1mLAo+ICAgCXN0cnVjdCBwYWdlICpw YWdlOwo+ICAgCWludCBlcnI7Cj4gICAJcGdvZmZfdCBpOwo+IC0Jdm1fZmF1bHRfdCByZXQgPSBW TV9GQVVMVF9OT1BBR0U7Cj4gKwl2bV9mYXVsdF90IHJldDsKPiAgIAl1bnNpZ25lZCBsb25nIGFk ZHJlc3MgPSB2bWYtPmFkZHJlc3M7Cj4gICAKPiAtCS8qCj4gLQkgKiBXYWl0IGZvciBidWZmZXIg ZGF0YSBpbiB0cmFuc2l0LCBkdWUgdG8gYSBwaXBlbGluZWQKPiAtCSAqIG1vdmUuCj4gLQkgKi8K PiAgIAlyZXQgPSB0dG1fYm9fdm1fZmF1bHRfaWRsZShibywgdm1mKTsKPiAtCWlmICh1bmxpa2Vs eShyZXQgIT0gMCkpCj4gKwlpZiAocmV0KQo+ICAgCQlyZXR1cm4gcmV0Owo+ICAgCj4gICAJZXJy ID0gdHRtX21lbV9pb19yZXNlcnZlKGJkZXYsICZiby0+bWVtKTsKPiBAQCAtMzAyLDkgKzMxMCw4 IEBAIHZtX2ZhdWx0X3QgdHRtX2JvX3ZtX2ZhdWx0X3Jlc2VydmVkKHN0cnVjdCB2bV9mYXVsdCAq dm1mLAo+ICAgCQlyZXR1cm4gVk1fRkFVTFRfU0lHQlVTOwo+ICAgCj4gICAJcGFnZV9vZmZzZXQg PSAoKGFkZHJlc3MgLSB2bWEtPnZtX3N0YXJ0KSA+PiBQQUdFX1NISUZUKSArCj4gLQkJdm1hLT52 bV9wZ29mZiAtIGRybV92bWFfbm9kZV9zdGFydCgmYm8tPmJhc2Uudm1hX25vZGUpOwo+IC0JcGFn ZV9sYXN0ID0gdm1hX3BhZ2VzKHZtYSkgKyB2bWEtPnZtX3Bnb2ZmIC0KPiAtCQlkcm1fdm1hX25v ZGVfc3RhcnQoJmJvLT5iYXNlLnZtYV9ub2RlKTsKPiArCQl2bWEtPnZtX3Bnb2ZmIC0gbW1hcF9i YXNlOwo+ICsJcGFnZV9sYXN0ID0gdm1hX3BhZ2VzKHZtYSkgKyB2bWEtPnZtX3Bnb2ZmIC0gbW1h cF9iYXNlOwo+ICAgCj4gICAJaWYgKHVubGlrZWx5KHBhZ2Vfb2Zmc2V0ID49IGJvLT5tZW0ubnVt X3BhZ2VzKSkKPiAgIAkJcmV0dXJuIFZNX0ZBVUxUX1NJR0JVUzsKPiBAQCAtMzQ0LDggKzM1MSw3 IEBAIHZtX2ZhdWx0X3QgdHRtX2JvX3ZtX2ZhdWx0X3Jlc2VydmVkKHN0cnVjdCB2bV9mYXVsdCAq dm1mLAo+ICAgCQkJfSBlbHNlIGlmICh1bmxpa2VseSghcGFnZSkpIHsKPiAgIAkJCQlicmVhazsK PiAgIAkJCX0KPiAtCQkJcGFnZS0+aW5kZXggPSBkcm1fdm1hX25vZGVfc3RhcnQoJmJvLT5iYXNl LnZtYV9ub2RlKSArCj4gLQkJCQlwYWdlX29mZnNldDsKPiArCQkJcGFnZS0+aW5kZXggPSBtbWFw X2Jhc2UgKyBwYWdlX29mZnNldDsKPiAgIAkJCXBmbiA9IHBhZ2VfdG9fcGZuKHBhZ2UpOwo+ICAg CQl9Cj4gICAKPiBAQCAtMzkyLDcgKzM5OCwxMCBAQCB2bV9mYXVsdF90IHR0bV9ib192bV9mYXVs dChzdHJ1Y3Qgdm1fZmF1bHQgKnZtZikKPiAgIAkJcmV0dXJuIHJldDsKPiAgIAo+ICAgCXByb3Qg PSB2bWEtPnZtX3BhZ2VfcHJvdDsKPiAtCXJldCA9IHR0bV9ib192bV9mYXVsdF9yZXNlcnZlZCh2 bWYsIHByb3QsIFRUTV9CT19WTV9OVU1fUFJFRkFVTFQsIDEpOwo+ICsJcmV0ID0gdHRtX2JvX3Zt X2ZhdWx0X3Jlc2VydmVkKGJvLCB2bWYsCj4gKwkJCQkgICAgICAgZHJtX3ZtYV9ub2RlX3N0YXJ0 KCZiby0+YmFzZS52bWFfbm9kZSksCj4gKwkJCQkgICAgICAgcHJvdCwgVFRNX0JPX1ZNX05VTV9Q UkVGQVVMVCwgMSk7Cj4gKwo+ICAgCWlmIChyZXQgPT0gVk1fRkFVTFRfUkVUUlkgJiYgISh2bWYt PmZsYWdzICYgRkFVTFRfRkxBR19SRVRSWV9OT1dBSVQpKQo+ICAgCQlyZXR1cm4gcmV0Owo+ICAg Cj4gQEAgLTQ2MCwyMiArNDY5LDE2IEBAIHN0YXRpYyBpbnQgdHRtX2JvX3ZtX2FjY2Vzc19rbWFw KHN0cnVjdCB0dG1fYnVmZmVyX29iamVjdCAqYm8sCj4gICAJcmV0dXJuIGxlbjsKPiAgIH0KPiAg IAo+IC1pbnQgdHRtX2JvX3ZtX2FjY2VzcyhzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwgdW5z aWduZWQgbG9uZyBhZGRyLAo+IC0JCSAgICAgdm9pZCAqYnVmLCBpbnQgbGVuLCBpbnQgd3JpdGUp Cj4gK2ludCB0dG1fYm9fdm1fYWNjZXNzX3Jlc2VydmVkKHN0cnVjdCB0dG1fYnVmZmVyX29iamVj dCAqYm8sCj4gKwkJCSAgICAgIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAo+ICsJCQkgICAg ICB1bnNpZ25lZCBsb25nIG9mZnNldCwKPiArCQkJICAgICAgdm9pZCAqYnVmLCBpbnQgbGVuLCBp bnQgd3JpdGUpCj4gICB7Cj4gLQlzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QgKmJvID0gdm1hLT52 bV9wcml2YXRlX2RhdGE7Cj4gLQl1bnNpZ25lZCBsb25nIG9mZnNldCA9IChhZGRyKSAtIHZtYS0+ dm1fc3RhcnQgKwo+IC0JCSgodm1hLT52bV9wZ29mZiAtIGRybV92bWFfbm9kZV9zdGFydCgmYm8t PmJhc2Uudm1hX25vZGUpKQo+IC0JCSA8PCBQQUdFX1NISUZUKTsKPiAgIAlpbnQgcmV0Owo+ICAg Cj4gICAJaWYgKGxlbiA8IDEgfHwgKG9mZnNldCArIGxlbikgPj4gUEFHRV9TSElGVCA+IGJvLT5t ZW0ubnVtX3BhZ2VzKQo+ICAgCQlyZXR1cm4gLUVJTzsKPiAgIAo+IC0JcmV0ID0gdHRtX2JvX3Jl c2VydmUoYm8sIHRydWUsIGZhbHNlLCBOVUxMKTsKPiAtCWlmIChyZXQpCj4gLQkJcmV0dXJuIHJl dDsKPiAtCj4gICAJc3dpdGNoIChiby0+bWVtLm1lbV90eXBlKSB7Cj4gICAJY2FzZSBUVE1fUExf U1lTVEVNOgo+ICAgCQlpZiAodW5saWtlbHkoYm8tPnR0bS0+cGFnZV9mbGFncyAmIFRUTV9QQUdF X0ZMQUdfU1dBUFBFRCkpIHsKPiBAQCAtNDg1LDE2ICs0ODgsMzMgQEAgaW50IHR0bV9ib192bV9h Y2Nlc3Moc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsIHVuc2lnbmVkIGxvbmcgYWRkciwKPiAg IAkJfQo+ICAgCQlmYWxsdGhyb3VnaDsKPiAgIAljYXNlIFRUTV9QTF9UVDoKPiAtCQlyZXQgPSB0 dG1fYm9fdm1fYWNjZXNzX2ttYXAoYm8sIG9mZnNldCwgYnVmLCBsZW4sIHdyaXRlKTsKPiAtCQli cmVhazsKPiArCQlyZXR1cm4gdHRtX2JvX3ZtX2FjY2Vzc19rbWFwKGJvLCBvZmZzZXQsIGJ1Ziwg bGVuLCB3cml0ZSk7Cj4gICAJZGVmYXVsdDoKPiAgIAkJaWYgKGJvLT5iZGV2LT5mdW5jcy0+YWNj ZXNzX21lbW9yeSkKPiAtCQkJcmV0ID0gYm8tPmJkZXYtPmZ1bmNzLT5hY2Nlc3NfbWVtb3J5KAo+ ICsJCQlyZXR1cm4gYm8tPmJkZXYtPmZ1bmNzLT5hY2Nlc3NfbWVtb3J5KAo+ICAgCQkJCWJvLCBv ZmZzZXQsIGJ1ZiwgbGVuLCB3cml0ZSk7Cj4gICAJCWVsc2UKPiAtCQkJcmV0ID0gLUVJTzsKPiAr CQkJcmV0dXJuIC1FSU87Cj4gICAJfQo+ICAgCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gK0VYUE9S VF9TWU1CT0wodHRtX2JvX3ZtX2FjY2Vzc19yZXNlcnZlZCk7Cj4gKwo+ICtpbnQgdHRtX2JvX3Zt X2FjY2VzcyhzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwgdW5zaWduZWQgbG9uZyBhZGRyLAo+ ICsJCSAgICAgdm9pZCAqYnVmLCBpbnQgbGVuLCBpbnQgd3JpdGUpCj4gK3sKPiArCXN0cnVjdCB0 dG1fYnVmZmVyX29iamVjdCAqYm8gPSB2bWEtPnZtX3ByaXZhdGVfZGF0YTsKPiArCXVuc2lnbmVk IGxvbmcgb2Zmc2V0ID0gKGFkZHIpIC0gdm1hLT52bV9zdGFydCArCj4gKwkJKCh2bWEtPnZtX3Bn b2ZmIC0gZHJtX3ZtYV9ub2RlX3N0YXJ0KCZiby0+YmFzZS52bWFfbm9kZSkpCj4gKwkJIDw8IFBB R0VfU0hJRlQpOwo+ICsJaW50IHJldDsKPiArCj4gKwlyZXQgPSB0dG1fYm9fcmVzZXJ2ZShibywg dHJ1ZSwgZmFsc2UsIE5VTEwpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiAr CXJldCA9IHR0bV9ib192bV9hY2Nlc3NfcmVzZXJ2ZWQoYm8sIHZtYSwgb2Zmc2V0LCBidWYsIGxl biwgd3JpdGUpOwo+ICAgCXR0bV9ib191bnJlc2VydmUoYm8pOwo+ICAgCj4gICAJcmV0dXJuIHJl dDsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3Ztd2dmeC92bXdnZnhfcGFnZV9kaXJ0 eS5jIGIvZHJpdmVycy9ncHUvZHJtL3Ztd2dmeC92bXdnZnhfcGFnZV9kaXJ0eS5jCj4gaW5kZXgg NDVjOWM2YTdmMWQ2Li41NmVjYWNlMGNmNWMgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJt L3Ztd2dmeC92bXdnZnhfcGFnZV9kaXJ0eS5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3Ztd2dm eC92bXdnZnhfcGFnZV9kaXJ0eS5jCj4gQEAgLTQ3Nyw3ICs0NzcsOSBAQCB2bV9mYXVsdF90IHZt d19ib192bV9mYXVsdChzdHJ1Y3Qgdm1fZmF1bHQgKnZtZikKPiAgIAllbHNlCj4gICAJCXByb3Qg PSB2bV9nZXRfcGFnZV9wcm90KHZtYS0+dm1fZmxhZ3MpOwo+ICAgCj4gLQlyZXQgPSB0dG1fYm9f dm1fZmF1bHRfcmVzZXJ2ZWQodm1mLCBwcm90LCBudW1fcHJlZmF1bHQsIDEpOwo+ICsJcmV0ID0g dHRtX2JvX3ZtX2ZhdWx0X3Jlc2VydmVkKGJvLCB2bWYsCj4gKwkJCQkgICAgICAgZHJtX3ZtYV9u b2RlX3N0YXJ0KCZiby0+YmFzZS52bWFfbm9kZSksCj4gKwkJCQkgICAgICAgcHJvdCwgbnVtX3By ZWZhdWx0LCAxKTsKPiAgIAlpZiAocmV0ID09IFZNX0ZBVUxUX1JFVFJZICYmICEodm1mLT5mbGFn cyAmIEZBVUxUX0ZMQUdfUkVUUllfTk9XQUlUKSkKPiAgIAkJcmV0dXJuIHJldDsKPiAgIAo+IEBA IC01NDYsNyArNTQ4LDkgQEAgdm1fZmF1bHRfdCB2bXdfYm9fdm1faHVnZV9mYXVsdChzdHJ1Y3Qg dm1fZmF1bHQgKnZtZiwKPiAgIAkJcHJvdCA9IHZtX2dldF9wYWdlX3Byb3Qodm1hLT52bV9mbGFn cyk7Cj4gICAJfQo+ICAgCj4gLQlyZXQgPSB0dG1fYm9fdm1fZmF1bHRfcmVzZXJ2ZWQodm1mLCBw cm90LCAxLCBmYXVsdF9wYWdlX3NpemUpOwo+ICsJcmV0ID0gdHRtX2JvX3ZtX2ZhdWx0X3Jlc2Vy dmVkKGJvLCB2bWYsCj4gKwkJCQkgICAgICAgZHJtX3ZtYV9ub2RlX3N0YXJ0KCZiby0+YmFzZS52 bWFfbm9kZSksCj4gKwkJCQkgICAgICAgcHJvdCwgMSwgZmF1bHRfcGFnZV9zaXplKTsKPiAgIAlp ZiAocmV0ID09IFZNX0ZBVUxUX1JFVFJZICYmICEodm1mLT5mbGFncyAmIEZBVUxUX0ZMQUdfUkVU UllfTk9XQUlUKSkKPiAgIAkJcmV0dXJuIHJldDsKPiAgIAo+IGRpZmYgLS1naXQgYS9pbmNsdWRl L2RybS90dG0vdHRtX2JvX2FwaS5oIGIvaW5jbHVkZS9kcm0vdHRtL3R0bV9ib19hcGkuaAo+IGlu ZGV4IDYzOTUyMTg4MGMyOS4uNDM0ZjkxZjFmZGJmIDEwMDY0NAo+IC0tLSBhL2luY2x1ZGUvZHJt L3R0bS90dG1fYm9fYXBpLmgKPiArKysgYi9pbmNsdWRlL2RybS90dG0vdHRtX2JvX2FwaS5oCj4g QEAgLTYwNSw3ICs2MDUsOSBAQCBpbnQgdHRtX21lbV9ldmljdF9maXJzdChzdHJ1Y3QgdHRtX2Rl dmljZSAqYmRldiwKPiAgIHZtX2ZhdWx0X3QgdHRtX2JvX3ZtX3Jlc2VydmUoc3RydWN0IHR0bV9i dWZmZXJfb2JqZWN0ICpibywKPiAgIAkJCSAgICAgc3RydWN0IHZtX2ZhdWx0ICp2bWYpOwo+ICAg Cj4gLXZtX2ZhdWx0X3QgdHRtX2JvX3ZtX2ZhdWx0X3Jlc2VydmVkKHN0cnVjdCB2bV9mYXVsdCAq dm1mLAo+ICt2bV9mYXVsdF90IHR0bV9ib192bV9mYXVsdF9yZXNlcnZlZChzdHJ1Y3QgdHRtX2J1 ZmZlcl9vYmplY3QgKmJvLAo+ICsJCQkJICAgIHN0cnVjdCB2bV9mYXVsdCAqdm1mLAo+ICsJCQkJ ICAgIHVuc2lnbmVkIGxvbmcgbW1hcF9iYXNlLAo+ICAgCQkJCSAgICBwZ3Byb3RfdCBwcm90LAo+ ICAgCQkJCSAgICBwZ29mZl90IG51bV9wcmVmYXVsdCwKPiAgIAkJCQkgICAgcGdvZmZfdCBmYXVs dF9wYWdlX3NpemUpOwo+IEBAIC02MTYsNiArNjE4LDExIEBAIHZvaWQgdHRtX2JvX3ZtX29wZW4o c3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpOwo+ICAgCj4gICB2b2lkIHR0bV9ib192bV9jbG9z ZShzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSk7Cj4gICAKPiAraW50IHR0bV9ib192bV9hY2Nl c3NfcmVzZXJ2ZWQoc3RydWN0IHR0bV9idWZmZXJfb2JqZWN0ICpibywKPiArCQkJICAgICAgc3Ry dWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCj4gKwkJCSAgICAgIHVuc2lnbmVkIGxvbmcgb2Zmc2V0 LAo+ICsJCQkgICAgICB2b2lkICpidWYsIGludCBsZW4sIGludCB3cml0ZSk7Cj4gKwo+ICAgaW50 IHR0bV9ib192bV9hY2Nlc3Moc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsIHVuc2lnbmVkIGxv bmcgYWRkciwKPiAgIAkJICAgICB2b2lkICpidWYsIGludCBsZW4sIGludCB3cml0ZSk7Cj4gICBi b29sIHR0bV9ib19kZWxheWVkX2RlbGV0ZShzdHJ1Y3QgdHRtX2RldmljZSAqYmRldiwgYm9vbCBy ZW1vdmVfYWxsKTsKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3Jn Cmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vaW50ZWwtZ2Z4 Cg==