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 4C75EC433B4 for ; Tue, 18 May 2021 06:54:01 +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 0E08F611BD for ; Tue, 18 May 2021 06:54:01 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 0E08F611BD 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 E8C886EAA6; Tue, 18 May 2021 06:53:59 +0000 (UTC) Received: from mga07.intel.com (mga07.intel.com [134.134.136.100]) by gabe.freedesktop.org (Postfix) with ESMTPS id A0A4E6EAA4; Tue, 18 May 2021 06:53:55 +0000 (UTC) IronPort-SDR: 8jIvYL70Xalr+Nf9Uo3hw88/iLGfx1yiN0hYBMEZRN3Y+w2Ak06opXsVU/x41rIf5jAg2KypDP A/kJZgwvQJvg== X-IronPort-AV: E=McAfee;i="6200,9189,9987"; a="264557082" X-IronPort-AV: E=Sophos;i="5.82,309,1613462400"; d="scan'208";a="264557082" Received: from fmsmga005.fm.intel.com ([10.253.24.32]) by orsmga105.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 17 May 2021 23:53:54 -0700 IronPort-SDR: GqxkomgBO4iFfW77yt0y8MDhwb3eybEW09m3K8Tv3oTObFqFVAT0wTWjF5/W6F6gUX41Q8mlLv fTfmikk8u58w== X-IronPort-AV: E=Sophos;i="5.82,309,1613462400"; d="scan'208";a="630333059" Received: from cmutgix-mobl.gar.corp.intel.com (HELO [10.249.254.195]) ([10.249.254.195]) by fmsmga005-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 17 May 2021 23:53:52 -0700 Subject: Re: [Intel-gfx] [PATCH 5/7] drm/i915/ttm, drm/ttm: Add a generic TTM memcpy move for page-based iomem To: Jani Nikula , intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org References: <20210511132525.377190-1-thomas.hellstrom@linux.intel.com> <20210511132525.377190-6-thomas.hellstrom@linux.intel.com> <87pmxphbll.fsf@intel.com> From: =?UTF-8?Q?Thomas_Hellstr=c3=b6m?= Message-ID: Date: Tue, 18 May 2021 08:53:50 +0200 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Thunderbird/78.8.1 MIME-Version: 1.0 In-Reply-To: <87pmxphbll.fsf@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" On 5/17/21 12:57 PM, Jani Nikula wrote: > On Tue, 11 May 2021, Thomas Hellström wrote: >> The internal ttm_bo_util memcpy uses vmap functionality, and while it >> probably might be possible to use it for copying in- and out of >> sglist represented io memory, using io_mem_reserve() / io_mem_free() >> callbacks, that would cause problems with fault(). >> Instead, implement a method mapping page-by-page using kmap_local() >> semantics. As an additional benefit we then avoid the occasional global >> TLB flushes of vmap() and consuming vmap space, elimination of a critical >> point of failure and with a slight change of semantics we could also push >> the memcpy out async for testing and async driver develpment purposes. >> Pushing out async can be done since there is no memory allocation going on >> that could violate the dma_fence lockdep rules. >> >> Note that drivers that don't want to use struct io_mapping but relies on >> memremap functionality, and that don't want to use scatterlists for >> VRAM may well define specialized (hopefully reusable) iterators for their >> particular environment. >> >> Cc: Christian König >> Signed-off-by: Thomas Hellström >> --- >> drivers/gpu/drm/i915/Makefile | 1 + >> .../gpu/drm/i915/gem/i915_gem_ttm_bo_util.c | 155 ++++++++++++++++++ >> .../gpu/drm/i915/gem/i915_gem_ttm_bo_util.h | 141 ++++++++++++++++ >> drivers/gpu/drm/ttm/ttm_bo.c | 1 + >> 4 files changed, 298 insertions(+) >> create mode 100644 drivers/gpu/drm/i915/gem/i915_gem_ttm_bo_util.c >> create mode 100644 drivers/gpu/drm/i915/gem/i915_gem_ttm_bo_util.h >> >> diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile >> index cb8823570996..958ccc1edfed 100644 >> --- a/drivers/gpu/drm/i915/Makefile >> +++ b/drivers/gpu/drm/i915/Makefile >> @@ -155,6 +155,7 @@ gem-y += \ >> gem/i915_gem_stolen.o \ >> gem/i915_gem_throttle.o \ >> gem/i915_gem_tiling.o \ >> + gem/i915_gem_ttm_bo_util.o \ >> gem/i915_gem_userptr.o \ >> gem/i915_gem_wait.o \ >> gem/i915_gemfs.o >> diff --git a/drivers/gpu/drm/i915/gem/i915_gem_ttm_bo_util.c b/drivers/gpu/drm/i915/gem/i915_gem_ttm_bo_util.c >> new file mode 100644 >> index 000000000000..1116d7df1461 >> --- /dev/null >> +++ b/drivers/gpu/drm/i915/gem/i915_gem_ttm_bo_util.c >> @@ -0,0 +1,155 @@ >> +// SPDX-License-Identifier: MIT >> +/* >> + * Copyright © 2021 Intel Corporation >> + */ >> + >> +/** >> + * DOC: Usage and intentions. >> + * >> + * This file contains functionality that we might want to move into >> + * ttm_bo_util.c if there is a common interest. >> + * Currently a kmap_local only memcpy with support for page-based iomem regions, >> + * and fast memcpy from write-combined memory. >> + */ >> + >> +#include >> +#include >> +#include >> +#include >> + >> +#include "i915_memcpy.h" >> + >> +#include "gem/i915_gem_ttm_bo_util.h" >> + >> +static void i915_ttm_kmap_iter_tt_kmap_local(struct i915_ttm_kmap_iter *iter, >> + struct dma_buf_map *dmap, >> + pgoff_t i) >> +{ >> + struct i915_ttm_kmap_iter_tt *iter_tt = >> + container_of(iter, typeof(*iter_tt), base); >> + >> + dma_buf_map_set_vaddr(dmap, kmap_local_page(iter_tt->tt->pages[i])); >> +} >> + >> +static void i915_ttm_kmap_iter_iomap_kmap_local(struct i915_ttm_kmap_iter *iter, >> + struct dma_buf_map *dmap, >> + pgoff_t i) >> +{ >> + struct i915_ttm_kmap_iter_iomap *iter_io = >> + container_of(iter, typeof(*iter_io), base); >> + void __iomem *addr; >> + >> +retry: >> + while (i >= iter_io->cache.end) { >> + iter_io->cache.sg = iter_io->cache.sg ? >> + sg_next(iter_io->cache.sg) : iter_io->st->sgl; >> + iter_io->cache.i = iter_io->cache.end; >> + iter_io->cache.end += sg_dma_len(iter_io->cache.sg) >> >> + PAGE_SHIFT; >> + iter_io->cache.offs = sg_dma_address(iter_io->cache.sg) - >> + iter_io->start; >> + } >> + >> + if (i < iter_io->cache.i) { >> + iter_io->cache.end = 0; >> + iter_io->cache.sg = NULL; >> + goto retry; >> + } >> + >> + addr = io_mapping_map_local_wc(iter_io->iomap, iter_io->cache.offs + >> + (((resource_size_t)i - iter_io->cache.i) >> + << PAGE_SHIFT)); >> + dma_buf_map_set_vaddr_iomem(dmap, addr); >> +} >> + >> +struct i915_ttm_kmap_iter_ops i915_ttm_kmap_iter_tt_ops = { >> + .kmap_local = i915_ttm_kmap_iter_tt_kmap_local >> +}; >> + >> +struct i915_ttm_kmap_iter_ops i915_ttm_kmap_iter_io_ops = { >> + .kmap_local = i915_ttm_kmap_iter_iomap_kmap_local >> +}; >> + >> +static void kunmap_local_dma_buf_map(struct dma_buf_map *map) >> +{ >> + if (map->is_iomem) >> + io_mapping_unmap_local(map->vaddr_iomem); >> + else >> + kunmap_local(map->vaddr); >> +} >> + >> +/** >> + * i915_ttm_move_memcpy - Helper to perform a memcpy ttm move operation. >> + * @bo: The struct ttm_buffer_object. >> + * @new_mem: The struct ttm_resource we're moving to (copy destination). >> + * @new_kmap: A struct i915_ttm_kmap_iter representing the destination resource. >> + * @old_kmap: A struct i915_ttm_kmap_iter representing the source resource. >> + */ >> +void i915_ttm_move_memcpy(struct ttm_buffer_object *bo, >> + struct ttm_resource *new_mem, >> + struct i915_ttm_kmap_iter *new_kmap, >> + struct i915_ttm_kmap_iter *old_kmap) >> +{ >> + struct ttm_device *bdev = bo->bdev; >> + struct ttm_resource_manager *man = ttm_manager_type(bdev, new_mem->mem_type); >> + struct ttm_tt *ttm = bo->ttm; >> + struct ttm_resource *old_mem = &bo->mem; >> + struct ttm_resource old_copy = *old_mem; >> + struct ttm_resource_manager *old_man = ttm_manager_type(bdev, old_mem->mem_type); >> + struct dma_buf_map old_map, new_map; >> + pgoff_t i; >> + >> + /* For the page-based allocator we need sgtable iterators as well.*/ >> + >> + /* Single TTM move. NOP */ >> + if (old_man->use_tt && man->use_tt) >> + goto done; >> + >> + /* Don't move nonexistent data. Clear destination instead. */ >> + if (old_man->use_tt && !man->use_tt && >> + (ttm == NULL || !ttm_tt_is_populated(ttm))) { >> + if (ttm && !(ttm->page_flags & TTM_PAGE_FLAG_ZERO_ALLOC)) >> + goto done; >> + >> + for (i = 0; i < new_mem->num_pages; ++i) { >> + new_kmap->ops->kmap_local(new_kmap, &new_map, i); >> + memset_io(new_map.vaddr_iomem, 0, PAGE_SIZE); >> + kunmap_local_dma_buf_map(&new_map); >> + } >> + goto done; >> + } >> + >> + for (i = 0; i < new_mem->num_pages; ++i) { >> + new_kmap->ops->kmap_local(new_kmap, &new_map, i); >> + old_kmap->ops->kmap_local(old_kmap, &old_map, i); >> + if (!old_map.is_iomem || >> + !i915_memcpy_from_wc(new_map.vaddr, old_map.vaddr, PAGE_SIZE)) { >> + if (!old_map.is_iomem) { >> + dma_buf_map_memcpy_to(&new_map, old_map.vaddr, >> + PAGE_SIZE); >> + } else if (!new_map.is_iomem) { >> + memcpy_fromio(new_map.vaddr, old_map.vaddr_iomem, >> + PAGE_SIZE); >> + } else { >> + pgoff_t j; >> + u32 __iomem *src = old_map.vaddr_iomem; >> + u32 __iomem *dst = new_map.vaddr_iomem; >> + >> + for (j = 0; j < (PAGE_SIZE >> 2); ++j) >> + iowrite32(ioread32(src++), dst++); >> + } >> + } >> + kunmap_local_dma_buf_map(&old_map); >> + kunmap_local_dma_buf_map(&new_map); >> + } >> + >> +done: >> + old_copy = *old_mem; >> + >> + ttm_bo_assign_mem(bo, new_mem); >> + >> + if (!man->use_tt) >> + ttm_bo_tt_destroy(bo); >> + >> + ttm_resource_free(bo, &old_copy); >> +} >> diff --git a/drivers/gpu/drm/i915/gem/i915_gem_ttm_bo_util.h b/drivers/gpu/drm/i915/gem/i915_gem_ttm_bo_util.h >> new file mode 100644 >> index 000000000000..82c92176718d >> --- /dev/null >> +++ b/drivers/gpu/drm/i915/gem/i915_gem_ttm_bo_util.h >> @@ -0,0 +1,141 @@ >> +/* SPDX-License-Identifier: MIT */ >> +/* >> + * Copyright © 2021 Intel Corporation >> + */ >> + >> +/* >> + * This files contains functionality that we might want to move into >> + * ttm_bo_util.c if there is a common interest. >> + */ >> +#ifndef _I915_GEM_TTM_BO_UTIL_H_ >> +#define _I915_GEM_TTM_BO_UTIL_H_ >> + >> +#include >> +struct dma_buf_map; >> +struct io_mapping; >> +struct sg_table; >> +struct scatterlist; >> + >> +struct ttm_tt; >> +struct i915_ttm_kmap_iter; >> + >> +/** >> + * struct i915_ttm_kmap_iter_ops - Ops structure for a struct >> + * i915_ttm_kmap_iter. >> + */ >> +struct i915_ttm_kmap_iter_ops { >> + /** >> + * kmap_local - Map a PAGE_SIZE part of the resource using >> + * kmap_local semantics. >> + * @res_kmap: Pointer to the struct i915_ttm_kmap_iter representing >> + * the resource. >> + * @dmap: The struct dma_buf_map holding the virtual address after >> + * the operation. >> + * @i: The location within the resource to map. PAGE_SIZE granularity. >> + */ >> + void (*kmap_local)(struct i915_ttm_kmap_iter *res_kmap, >> + struct dma_buf_map *dmap, pgoff_t i); >> +}; >> + >> +/** >> + * struct i915_ttm_kmap_iter - Iterator for kmap_local type operations on a >> + * resource. >> + * @ops: Pointer to the operations struct. >> + * >> + * This struct is intended to be embedded in a resource-specific specialization >> + * implementing operations for the resource. >> + * >> + * Nothing stops us from extending the operations to vmap, vmap_pfn etc, >> + * replacing some or parts of the ttm_bo_util. cpu-map functionality. >> + */ >> +struct i915_ttm_kmap_iter { >> + const struct i915_ttm_kmap_iter_ops *ops; >> +}; >> + >> +/** >> + * struct i915_ttm_kmap_iter_tt - Specialization for a tt (page) backed struct >> + * ttm_resource. >> + * @base: Embedded struct i915_ttm_kmap_iter providing the usage interface >> + * @tt: Cached struct ttm_tt. >> + */ >> +struct i915_ttm_kmap_iter_tt { >> + struct i915_ttm_kmap_iter base; >> + struct ttm_tt *tt; >> +}; >> + >> +/** >> + * struct i915_ttm_kmap_iter_iomap - Specialization for a struct io_mapping + >> + * struct sg_table backed struct ttm_resource. >> + * @base: Embedded struct i915_ttm_kmap_iter providing the usage interface. >> + * @iomap: struct io_mapping representing the underlying linear io_memory. >> + * @st: sg_table into @iomap, representing the memory of the struct ttm_resource. >> + * @start: Offset that needs to be subtracted from @st to make >> + * sg_dma_address(st->sgl) - @start == 0 for @iomap start. >> + * @cache: Scatterlist traversal cache for fast lookups. >> + * @cache.sg: Pointer to the currently cached scatterlist segment. >> + * @cache.i: First index of @sg. PAGE_SIZE granularity. >> + * @cache.end: Last index + 1 of @sg. PAGE_SIZE granularity. >> + * @cache.offs: First offset into @iomap of @sg. PAGE_SIZE granularity. >> + */ >> +struct i915_ttm_kmap_iter_iomap { >> + struct i915_ttm_kmap_iter base; >> + struct io_mapping *iomap; >> + struct sg_table *st; >> + resource_size_t start; >> + struct { >> + struct scatterlist *sg; >> + pgoff_t i; >> + pgoff_t end; >> + pgoff_t offs; >> + } cache; >> +}; >> + >> +extern struct i915_ttm_kmap_iter_ops i915_ttm_kmap_iter_tt_ops; >> +extern struct i915_ttm_kmap_iter_ops i915_ttm_kmap_iter_io_ops; >> + >> +/** >> + * i915_ttm_kmap_iter_iomap_init - Initialize a struct i915_ttm_kmap_iter_iomap >> + * @iter_io: The struct i915_ttm_kmap_iter_iomap to initialize. >> + * @iomap: The struct io_mapping representing the underlying linear io_memory. >> + * @st: sg_table into @iomap, representing the memory of the struct >> + * ttm_resource. >> + * @start: Offset that needs to be subtracted from @st to make >> + * sg_dma_address(st->sgl) - @start == 0 for @iomap start. >> + * >> + * Return: Pointer to the embedded struct i915_ttm_kmap_iter. >> + */ >> +static inline struct i915_ttm_kmap_iter * >> +i915_ttm_kmap_iter_iomap_init(struct i915_ttm_kmap_iter_iomap *iter_io, >> + struct io_mapping *iomap, >> + struct sg_table *st, >> + resource_size_t start) >> +{ >> + iter_io->base.ops = &i915_ttm_kmap_iter_io_ops; >> + iter_io->iomap = iomap; >> + iter_io->st = st; >> + iter_io->start = start; >> + memset(&iter_io->cache, 0, sizeof(iter_io->cache)); >> + return &iter_io->base; >> +} >> + >> +/** >> + * ttm_kmap_iter_tt_init - Initialize a struct i915_ttm_kmap_iter_tt >> + * @iter_tt: The struct i915_ttm_kmap_iter_tt to initialize. >> + * @tt: Struct ttm_tt holding page pointers of the struct ttm_resource. >> + * >> + * Return: Pointer to the embedded struct i915_ttm_kmap_iter. >> + */ >> +static inline struct i915_ttm_kmap_iter * >> +i915_ttm_kmap_iter_tt_init(struct i915_ttm_kmap_iter_tt *iter_tt, >> + struct ttm_tt *tt) >> +{ >> + iter_tt->base.ops = &i915_ttm_kmap_iter_tt_ops; >> + iter_tt->tt = tt; >> + return &iter_tt->base; >> +} > Do there functions have a valid *performance* reason to be inline? I > think that's pretty much the only valid reason. > > Having these inline forces i915_ttm_kmap_iter_*_ops extern, and they > should really be static. Inline functions complicate header dependencies > and leak the abstractions. > > BR, > Jani. Hi, Thanks for reviewing. I don't think there really is a performance reason for keeping these functions inline. While in this case there is not really much change either in leaking abstractions nor in header dependencies I agree keeping those ops static is probably a better choice. I'll respin. Thanks, Thomas 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 1FA4AC433ED for ; Tue, 18 May 2021 06:54:00 +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 DA94561007 for ; Tue, 18 May 2021 06:53:59 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org DA94561007 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 5D5BE6EAA4; Tue, 18 May 2021 06:53:59 +0000 (UTC) Received: from mga07.intel.com (mga07.intel.com [134.134.136.100]) by gabe.freedesktop.org (Postfix) with ESMTPS id A0A4E6EAA4; Tue, 18 May 2021 06:53:55 +0000 (UTC) IronPort-SDR: 8jIvYL70Xalr+Nf9Uo3hw88/iLGfx1yiN0hYBMEZRN3Y+w2Ak06opXsVU/x41rIf5jAg2KypDP A/kJZgwvQJvg== X-IronPort-AV: E=McAfee;i="6200,9189,9987"; a="264557082" X-IronPort-AV: E=Sophos;i="5.82,309,1613462400"; d="scan'208";a="264557082" Received: from fmsmga005.fm.intel.com ([10.253.24.32]) by orsmga105.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 17 May 2021 23:53:54 -0700 IronPort-SDR: GqxkomgBO4iFfW77yt0y8MDhwb3eybEW09m3K8Tv3oTObFqFVAT0wTWjF5/W6F6gUX41Q8mlLv fTfmikk8u58w== X-IronPort-AV: E=Sophos;i="5.82,309,1613462400"; d="scan'208";a="630333059" Received: from cmutgix-mobl.gar.corp.intel.com (HELO [10.249.254.195]) ([10.249.254.195]) by fmsmga005-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 17 May 2021 23:53:52 -0700 To: Jani Nikula , intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org References: <20210511132525.377190-1-thomas.hellstrom@linux.intel.com> <20210511132525.377190-6-thomas.hellstrom@linux.intel.com> <87pmxphbll.fsf@intel.com> From: =?UTF-8?Q?Thomas_Hellstr=c3=b6m?= Message-ID: Date: Tue, 18 May 2021 08:53:50 +0200 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Thunderbird/78.8.1 MIME-Version: 1.0 In-Reply-To: <87pmxphbll.fsf@intel.com> Content-Language: en-US Subject: Re: [Intel-gfx] [PATCH 5/7] drm/i915/ttm, drm/ttm: Add a generic TTM memcpy move for page-based iomem 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" Ck9uIDUvMTcvMjEgMTI6NTcgUE0sIEphbmkgTmlrdWxhIHdyb3RlOgo+IE9uIFR1ZSwgMTEgTWF5 IDIwMjEsIFRob21hcyBIZWxsc3Ryw7ZtIDx0aG9tYXMuaGVsbHN0cm9tQGxpbnV4LmludGVsLmNv bT4gd3JvdGU6Cj4+IFRoZSBpbnRlcm5hbCB0dG1fYm9fdXRpbCBtZW1jcHkgdXNlcyB2bWFwIGZ1 bmN0aW9uYWxpdHksIGFuZCB3aGlsZSBpdAo+PiBwcm9iYWJseSBtaWdodCBiZSBwb3NzaWJsZSB0 byB1c2UgaXQgZm9yIGNvcHlpbmcgaW4tIGFuZCBvdXQgb2YKPj4gc2dsaXN0IHJlcHJlc2VudGVk IGlvIG1lbW9yeSwgdXNpbmcgaW9fbWVtX3Jlc2VydmUoKSAvIGlvX21lbV9mcmVlKCkKPj4gY2Fs bGJhY2tzLCB0aGF0IHdvdWxkIGNhdXNlIHByb2JsZW1zIHdpdGggZmF1bHQoKS4KPj4gSW5zdGVh ZCwgaW1wbGVtZW50IGEgbWV0aG9kIG1hcHBpbmcgcGFnZS1ieS1wYWdlIHVzaW5nIGttYXBfbG9j YWwoKQo+PiBzZW1hbnRpY3MuIEFzIGFuIGFkZGl0aW9uYWwgYmVuZWZpdCB3ZSB0aGVuIGF2b2lk IHRoZSBvY2Nhc2lvbmFsIGdsb2JhbAo+PiBUTEIgZmx1c2hlcyBvZiB2bWFwKCkgYW5kIGNvbnN1 bWluZyB2bWFwIHNwYWNlLCBlbGltaW5hdGlvbiBvZiBhIGNyaXRpY2FsCj4+IHBvaW50IG9mIGZh aWx1cmUgYW5kIHdpdGggYSBzbGlnaHQgY2hhbmdlIG9mIHNlbWFudGljcyB3ZSBjb3VsZCBhbHNv IHB1c2gKPj4gdGhlIG1lbWNweSBvdXQgYXN5bmMgZm9yIHRlc3RpbmcgYW5kIGFzeW5jIGRyaXZl ciBkZXZlbHBtZW50IHB1cnBvc2VzLgo+PiBQdXNoaW5nIG91dCBhc3luYyBjYW4gYmUgZG9uZSBz aW5jZSB0aGVyZSBpcyBubyBtZW1vcnkgYWxsb2NhdGlvbiBnb2luZyBvbgo+PiB0aGF0IGNvdWxk IHZpb2xhdGUgdGhlIGRtYV9mZW5jZSBsb2NrZGVwIHJ1bGVzLgo+Pgo+PiBOb3RlIHRoYXQgZHJp dmVycyB0aGF0IGRvbid0IHdhbnQgdG8gdXNlIHN0cnVjdCBpb19tYXBwaW5nIGJ1dCByZWxpZXMg b24KPj4gbWVtcmVtYXAgZnVuY3Rpb25hbGl0eSwgYW5kIHRoYXQgZG9uJ3Qgd2FudCB0byB1c2Ug c2NhdHRlcmxpc3RzIGZvcgo+PiBWUkFNIG1heSB3ZWxsIGRlZmluZSBzcGVjaWFsaXplZCAoaG9w ZWZ1bGx5IHJldXNhYmxlKSBpdGVyYXRvcnMgZm9yIHRoZWlyCj4+IHBhcnRpY3VsYXIgZW52aXJv bm1lbnQuCj4+Cj4+IENjOiBDaHJpc3RpYW4gS8O2bmlnIDxjaHJpc3RpYW4ua29lbmlnQGFtZC5j b20+Cj4+IFNpZ25lZC1vZmYtYnk6IFRob21hcyBIZWxsc3Ryw7ZtIDx0aG9tYXMuaGVsbHN0cm9t QGxpbnV4LmludGVsLmNvbT4KPj4gLS0tCj4+ICAgZHJpdmVycy9ncHUvZHJtL2k5MTUvTWFrZWZp bGUgICAgICAgICAgICAgICAgIHwgICAxICsKPj4gICAuLi4vZ3B1L2RybS9pOTE1L2dlbS9pOTE1 X2dlbV90dG1fYm9fdXRpbC5jICAgfCAxNTUgKysrKysrKysrKysrKysrKysrCj4+ICAgLi4uL2dw dS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fdHRtX2JvX3V0aWwuaCAgIHwgMTQxICsrKysrKysrKysr KysrKysKPj4gICBkcml2ZXJzL2dwdS9kcm0vdHRtL3R0bV9iby5jICAgICAgICAgICAgICAgICAg fCAgIDEgKwo+PiAgIDQgZmlsZXMgY2hhbmdlZCwgMjk4IGluc2VydGlvbnMoKykKPj4gICBjcmVh dGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bV9ib191 dGlsLmMKPj4gICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5 MTVfZ2VtX3R0bV9ib191dGlsLmgKPj4KPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9p OTE1L01ha2VmaWxlIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvTWFrZWZpbGUKPj4gaW5kZXggY2I4 ODIzNTcwOTk2Li45NThjY2MxZWRmZWQgMTAwNjQ0Cj4+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9p OTE1L01ha2VmaWxlCj4+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L01ha2VmaWxlCj4+IEBA IC0xNTUsNiArMTU1LDcgQEAgZ2VtLXkgKz0gXAo+PiAgIAlnZW0vaTkxNV9nZW1fc3RvbGVuLm8g XAo+PiAgIAlnZW0vaTkxNV9nZW1fdGhyb3R0bGUubyBcCj4+ICAgCWdlbS9pOTE1X2dlbV90aWxp bmcubyBcCj4+ICsJZ2VtL2k5MTVfZ2VtX3R0bV9ib191dGlsLm8gXAo+PiAgIAlnZW0vaTkxNV9n ZW1fdXNlcnB0ci5vIFwKPj4gICAJZ2VtL2k5MTVfZ2VtX3dhaXQubyBcCj4+ICAgCWdlbS9pOTE1 X2dlbWZzLm8KPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dl bV90dG1fYm9fdXRpbC5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bV9i b191dGlsLmMKPj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPj4gaW5kZXggMDAwMDAwMDAwMDAwLi4x MTE2ZDdkZjE0NjEKPj4gLS0tIC9kZXYvbnVsbAo+PiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkx NS9nZW0vaTkxNV9nZW1fdHRtX2JvX3V0aWwuYwo+PiBAQCAtMCwwICsxLDE1NSBAQAo+PiArLy8g U1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IE1JVAo+PiArLyoKPj4gKyAqIENvcHlyaWdodCDCqSAy MDIxIEludGVsIENvcnBvcmF0aW9uCj4+ICsgKi8KPj4gKwo+PiArLyoqCj4+ICsgKiBET0M6IFVz YWdlIGFuZCBpbnRlbnRpb25zLgo+PiArICoKPj4gKyAqIFRoaXMgZmlsZSBjb250YWlucyBmdW5j dGlvbmFsaXR5IHRoYXQgd2UgbWlnaHQgd2FudCB0byBtb3ZlIGludG8KPj4gKyAqIHR0bV9ib191 dGlsLmMgaWYgdGhlcmUgaXMgYSBjb21tb24gaW50ZXJlc3QuCj4+ICsgKiBDdXJyZW50bHkgYSBr bWFwX2xvY2FsIG9ubHkgbWVtY3B5IHdpdGggc3VwcG9ydCBmb3IgcGFnZS1iYXNlZCBpb21lbSBy ZWdpb25zLAo+PiArICogYW5kIGZhc3QgbWVtY3B5IGZyb20gd3JpdGUtY29tYmluZWQgbWVtb3J5 Lgo+PiArICovCj4+ICsKPj4gKyNpbmNsdWRlIDxsaW51eC9kbWEtYnVmLW1hcC5oPgo+PiArI2lu Y2x1ZGUgPGxpbnV4L2hpZ2htZW0uaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9pby1tYXBwaW5nLmg+ Cj4+ICsjaW5jbHVkZSA8bGludXgvc2NhdHRlcmxpc3QuaD4KPj4gKwo+PiArI2luY2x1ZGUgImk5 MTVfbWVtY3B5LmgiCj4+ICsKPj4gKyNpbmNsdWRlICJnZW0vaTkxNV9nZW1fdHRtX2JvX3V0aWwu aCIKPj4gKwo+PiArc3RhdGljIHZvaWQgaTkxNV90dG1fa21hcF9pdGVyX3R0X2ttYXBfbG9jYWwo c3RydWN0IGk5MTVfdHRtX2ttYXBfaXRlciAqaXRlciwKPj4gKwkJCQkJICAgICBzdHJ1Y3QgZG1h X2J1Zl9tYXAgKmRtYXAsCj4+ICsJCQkJCSAgICAgcGdvZmZfdCBpKQo+PiArewo+PiArCXN0cnVj dCBpOTE1X3R0bV9rbWFwX2l0ZXJfdHQgKml0ZXJfdHQgPQo+PiArCQljb250YWluZXJfb2YoaXRl ciwgdHlwZW9mKCppdGVyX3R0KSwgYmFzZSk7Cj4+ICsKPj4gKwlkbWFfYnVmX21hcF9zZXRfdmFk ZHIoZG1hcCwga21hcF9sb2NhbF9wYWdlKGl0ZXJfdHQtPnR0LT5wYWdlc1tpXSkpOwo+PiArfQo+ PiArCj4+ICtzdGF0aWMgdm9pZCBpOTE1X3R0bV9rbWFwX2l0ZXJfaW9tYXBfa21hcF9sb2NhbChz dHJ1Y3QgaTkxNV90dG1fa21hcF9pdGVyICppdGVyLAo+PiArCQkJCQkJc3RydWN0IGRtYV9idWZf bWFwICpkbWFwLAo+PiArCQkJCQkJcGdvZmZfdCBpKQo+PiArewo+PiArCXN0cnVjdCBpOTE1X3R0 bV9rbWFwX2l0ZXJfaW9tYXAgKml0ZXJfaW8gPQo+PiArCQljb250YWluZXJfb2YoaXRlciwgdHlw ZW9mKCppdGVyX2lvKSwgYmFzZSk7Cj4+ICsJdm9pZCBfX2lvbWVtICphZGRyOwo+PiArCj4+ICty ZXRyeToKPj4gKwl3aGlsZSAoaSA+PSBpdGVyX2lvLT5jYWNoZS5lbmQpIHsKPj4gKwkJaXRlcl9p by0+Y2FjaGUuc2cgPSBpdGVyX2lvLT5jYWNoZS5zZyA/Cj4+ICsJCQlzZ19uZXh0KGl0ZXJfaW8t PmNhY2hlLnNnKSA6IGl0ZXJfaW8tPnN0LT5zZ2w7Cj4+ICsJCWl0ZXJfaW8tPmNhY2hlLmkgPSBp dGVyX2lvLT5jYWNoZS5lbmQ7Cj4+ICsJCWl0ZXJfaW8tPmNhY2hlLmVuZCArPSBzZ19kbWFfbGVu KGl0ZXJfaW8tPmNhY2hlLnNnKSA+Pgo+PiArCQkJUEFHRV9TSElGVDsKPj4gKwkJaXRlcl9pby0+ Y2FjaGUub2ZmcyA9IHNnX2RtYV9hZGRyZXNzKGl0ZXJfaW8tPmNhY2hlLnNnKSAtCj4+ICsJCQlp dGVyX2lvLT5zdGFydDsKPj4gKwl9Cj4+ICsKPj4gKwlpZiAoaSA8IGl0ZXJfaW8tPmNhY2hlLmkp IHsKPj4gKwkJaXRlcl9pby0+Y2FjaGUuZW5kID0gMDsKPj4gKwkJaXRlcl9pby0+Y2FjaGUuc2cg PSBOVUxMOwo+PiArCQlnb3RvIHJldHJ5Owo+PiArCX0KPj4gKwo+PiArCWFkZHIgPSBpb19tYXBw aW5nX21hcF9sb2NhbF93YyhpdGVyX2lvLT5pb21hcCwgaXRlcl9pby0+Y2FjaGUub2ZmcyArCj4+ ICsJCQkJICAgICAgICgoKHJlc291cmNlX3NpemVfdClpIC0gaXRlcl9pby0+Y2FjaGUuaSkKPj4g KwkJCQkJPDwgUEFHRV9TSElGVCkpOwo+PiArCWRtYV9idWZfbWFwX3NldF92YWRkcl9pb21lbShk bWFwLCBhZGRyKTsKPj4gK30KPj4gKwo+PiArc3RydWN0IGk5MTVfdHRtX2ttYXBfaXRlcl9vcHMg aTkxNV90dG1fa21hcF9pdGVyX3R0X29wcyA9IHsKPj4gKwkua21hcF9sb2NhbCA9IGk5MTVfdHRt X2ttYXBfaXRlcl90dF9rbWFwX2xvY2FsCj4+ICt9Owo+PiArCj4+ICtzdHJ1Y3QgaTkxNV90dG1f a21hcF9pdGVyX29wcyBpOTE1X3R0bV9rbWFwX2l0ZXJfaW9fb3BzID0gewo+PiArCS5rbWFwX2xv Y2FsID0gIGk5MTVfdHRtX2ttYXBfaXRlcl9pb21hcF9rbWFwX2xvY2FsCj4+ICt9Owo+PiArCj4+ ICtzdGF0aWMgdm9pZCBrdW5tYXBfbG9jYWxfZG1hX2J1Zl9tYXAoc3RydWN0IGRtYV9idWZfbWFw ICptYXApCj4+ICt7Cj4+ICsJaWYgKG1hcC0+aXNfaW9tZW0pCj4+ICsJCWlvX21hcHBpbmdfdW5t YXBfbG9jYWwobWFwLT52YWRkcl9pb21lbSk7Cj4+ICsJZWxzZQo+PiArCQlrdW5tYXBfbG9jYWwo bWFwLT52YWRkcik7Cj4+ICt9Cj4+ICsKPj4gKy8qKgo+PiArICogaTkxNV90dG1fbW92ZV9tZW1j cHkgLSBIZWxwZXIgdG8gcGVyZm9ybSBhIG1lbWNweSB0dG0gbW92ZSBvcGVyYXRpb24uCj4+ICsg KiBAYm86IFRoZSBzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3QuCj4+ICsgKiBAbmV3X21lbTogVGhl IHN0cnVjdCB0dG1fcmVzb3VyY2Ugd2UncmUgbW92aW5nIHRvIChjb3B5IGRlc3RpbmF0aW9uKS4K Pj4gKyAqIEBuZXdfa21hcDogQSBzdHJ1Y3QgaTkxNV90dG1fa21hcF9pdGVyIHJlcHJlc2VudGlu ZyB0aGUgZGVzdGluYXRpb24gcmVzb3VyY2UuCj4+ICsgKiBAb2xkX2ttYXA6IEEgc3RydWN0IGk5 MTVfdHRtX2ttYXBfaXRlciByZXByZXNlbnRpbmcgdGhlIHNvdXJjZSByZXNvdXJjZS4KPj4gKyAq Lwo+PiArdm9pZCBpOTE1X3R0bV9tb3ZlX21lbWNweShzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmplY3Qg KmJvLAo+PiArCQkJICBzdHJ1Y3QgdHRtX3Jlc291cmNlICpuZXdfbWVtLAo+PiArCQkJICBzdHJ1 Y3QgaTkxNV90dG1fa21hcF9pdGVyICpuZXdfa21hcCwKPj4gKwkJCSAgc3RydWN0IGk5MTVfdHRt X2ttYXBfaXRlciAqb2xkX2ttYXApCj4+ICt7Cj4+ICsJc3RydWN0IHR0bV9kZXZpY2UgKmJkZXYg PSBiby0+YmRldjsKPj4gKwlzdHJ1Y3QgdHRtX3Jlc291cmNlX21hbmFnZXIgKm1hbiA9IHR0bV9t YW5hZ2VyX3R5cGUoYmRldiwgbmV3X21lbS0+bWVtX3R5cGUpOwo+PiArCXN0cnVjdCB0dG1fdHQg KnR0bSA9IGJvLT50dG07Cj4+ICsJc3RydWN0IHR0bV9yZXNvdXJjZSAqb2xkX21lbSA9ICZiby0+ bWVtOwo+PiArCXN0cnVjdCB0dG1fcmVzb3VyY2Ugb2xkX2NvcHkgPSAqb2xkX21lbTsKPj4gKwlz dHJ1Y3QgdHRtX3Jlc291cmNlX21hbmFnZXIgKm9sZF9tYW4gPSB0dG1fbWFuYWdlcl90eXBlKGJk ZXYsIG9sZF9tZW0tPm1lbV90eXBlKTsKPj4gKwlzdHJ1Y3QgZG1hX2J1Zl9tYXAgb2xkX21hcCwg bmV3X21hcDsKPj4gKwlwZ29mZl90IGk7Cj4+ICsKPj4gKwkvKiBGb3IgdGhlIHBhZ2UtYmFzZWQg YWxsb2NhdG9yIHdlIG5lZWQgc2d0YWJsZSBpdGVyYXRvcnMgYXMgd2VsbC4qLwo+PiArCj4+ICsJ LyogU2luZ2xlIFRUTSBtb3ZlLiBOT1AgKi8KPj4gKwlpZiAob2xkX21hbi0+dXNlX3R0ICYmIG1h bi0+dXNlX3R0KQo+PiArCQlnb3RvIGRvbmU7Cj4+ICsKPj4gKwkvKiBEb24ndCBtb3ZlIG5vbmV4 aXN0ZW50IGRhdGEuIENsZWFyIGRlc3RpbmF0aW9uIGluc3RlYWQuICovCj4+ICsJaWYgKG9sZF9t YW4tPnVzZV90dCAmJiAhbWFuLT51c2VfdHQgJiYKPj4gKwkgICAgKHR0bSA9PSBOVUxMIHx8ICF0 dG1fdHRfaXNfcG9wdWxhdGVkKHR0bSkpKSB7Cj4+ICsJCWlmICh0dG0gJiYgISh0dG0tPnBhZ2Vf ZmxhZ3MgJiBUVE1fUEFHRV9GTEFHX1pFUk9fQUxMT0MpKQo+PiArCQkJZ290byBkb25lOwo+PiAr Cj4+ICsJCWZvciAoaSA9IDA7IGkgPCBuZXdfbWVtLT5udW1fcGFnZXM7ICsraSkgewo+PiArCQkJ bmV3X2ttYXAtPm9wcy0+a21hcF9sb2NhbChuZXdfa21hcCwgJm5ld19tYXAsIGkpOwo+PiArCQkJ bWVtc2V0X2lvKG5ld19tYXAudmFkZHJfaW9tZW0sIDAsIFBBR0VfU0laRSk7Cj4+ICsJCQlrdW5t YXBfbG9jYWxfZG1hX2J1Zl9tYXAoJm5ld19tYXApOwo+PiArCQl9Cj4+ICsJCWdvdG8gZG9uZTsK Pj4gKwl9Cj4+ICsKPj4gKwlmb3IgKGkgPSAwOyBpIDwgbmV3X21lbS0+bnVtX3BhZ2VzOyArK2kp IHsKPj4gKwkJbmV3X2ttYXAtPm9wcy0+a21hcF9sb2NhbChuZXdfa21hcCwgJm5ld19tYXAsIGkp Owo+PiArCQlvbGRfa21hcC0+b3BzLT5rbWFwX2xvY2FsKG9sZF9rbWFwLCAmb2xkX21hcCwgaSk7 Cj4+ICsJCWlmICghb2xkX21hcC5pc19pb21lbSB8fAo+PiArCQkgICAgIWk5MTVfbWVtY3B5X2Zy b21fd2MobmV3X21hcC52YWRkciwgb2xkX21hcC52YWRkciwgUEFHRV9TSVpFKSkgewo+PiArCQkJ aWYgKCFvbGRfbWFwLmlzX2lvbWVtKSB7Cj4+ICsJCQkJZG1hX2J1Zl9tYXBfbWVtY3B5X3RvKCZu ZXdfbWFwLCBvbGRfbWFwLnZhZGRyLAo+PiArCQkJCQkJICAgICAgUEFHRV9TSVpFKTsKPj4gKwkJ CX0gZWxzZSBpZiAoIW5ld19tYXAuaXNfaW9tZW0pIHsKPj4gKwkJCQltZW1jcHlfZnJvbWlvKG5l d19tYXAudmFkZHIsIG9sZF9tYXAudmFkZHJfaW9tZW0sCj4+ICsJCQkJCSAgICAgIFBBR0VfU0la RSk7Cj4+ICsJCQl9IGVsc2Ugewo+PiArCQkJCXBnb2ZmX3QgajsKPj4gKwkJCQl1MzIgX19pb21l bSAqc3JjID0gb2xkX21hcC52YWRkcl9pb21lbTsKPj4gKwkJCQl1MzIgX19pb21lbSAqZHN0ID0g bmV3X21hcC52YWRkcl9pb21lbTsKPj4gKwo+PiArCQkJCWZvciAoaiA9IDA7IGogPCAoUEFHRV9T SVpFID4+IDIpOyArK2opCj4+ICsJCQkJCWlvd3JpdGUzMihpb3JlYWQzMihzcmMrKyksIGRzdCsr KTsKPj4gKwkJCX0KPj4gKwkJfQo+PiArCQlrdW5tYXBfbG9jYWxfZG1hX2J1Zl9tYXAoJm9sZF9t YXApOwo+PiArCQlrdW5tYXBfbG9jYWxfZG1hX2J1Zl9tYXAoJm5ld19tYXApOwo+PiArCX0KPj4g Kwo+PiArZG9uZToKPj4gKwlvbGRfY29weSA9ICpvbGRfbWVtOwo+PiArCj4+ICsJdHRtX2JvX2Fz c2lnbl9tZW0oYm8sIG5ld19tZW0pOwo+PiArCj4+ICsJaWYgKCFtYW4tPnVzZV90dCkKPj4gKwkJ dHRtX2JvX3R0X2Rlc3Ryb3koYm8pOwo+PiArCj4+ICsJdHRtX3Jlc291cmNlX2ZyZWUoYm8sICZv bGRfY29weSk7Cj4+ICt9Cj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0v aTkxNV9nZW1fdHRtX2JvX3V0aWwuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dl bV90dG1fYm9fdXRpbC5oCj4+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4+IGluZGV4IDAwMDAwMDAw MDAwMC4uODJjOTIxNzY3MThkCj4+IC0tLSAvZGV2L251bGwKPj4gKysrIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bV9ib191dGlsLmgKPj4gQEAgLTAsMCArMSwxNDEgQEAK Pj4gKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNSVQgKi8KPj4gKy8qCj4+ICsgKiBDb3B5 cmlnaHQgwqkgMjAyMSBJbnRlbCBDb3Jwb3JhdGlvbgo+PiArICovCj4+ICsKPj4gKy8qCj4+ICsg KiBUaGlzIGZpbGVzIGNvbnRhaW5zIGZ1bmN0aW9uYWxpdHkgdGhhdCB3ZSBtaWdodCB3YW50IHRv IG1vdmUgaW50bwo+PiArICogdHRtX2JvX3V0aWwuYyBpZiB0aGVyZSBpcyBhIGNvbW1vbiBpbnRl cmVzdC4KPj4gKyAqLwo+PiArI2lmbmRlZiBfSTkxNV9HRU1fVFRNX0JPX1VUSUxfSF8KPj4gKyNk ZWZpbmUgX0k5MTVfR0VNX1RUTV9CT19VVElMX0hfCj4+ICsKPj4gKyNpbmNsdWRlIDxkcm0vdHRt L3R0bV9ib19kcml2ZXIuaD4KPj4gK3N0cnVjdCBkbWFfYnVmX21hcDsKPj4gK3N0cnVjdCBpb19t YXBwaW5nOwo+PiArc3RydWN0IHNnX3RhYmxlOwo+PiArc3RydWN0IHNjYXR0ZXJsaXN0Owo+PiAr Cj4+ICtzdHJ1Y3QgdHRtX3R0Owo+PiArc3RydWN0IGk5MTVfdHRtX2ttYXBfaXRlcjsKPj4gKwo+ PiArLyoqCj4+ICsgKiBzdHJ1Y3QgaTkxNV90dG1fa21hcF9pdGVyX29wcyAtIE9wcyBzdHJ1Y3R1 cmUgZm9yIGEgc3RydWN0Cj4+ICsgKiBpOTE1X3R0bV9rbWFwX2l0ZXIuCj4+ICsgKi8KPj4gK3N0 cnVjdCBpOTE1X3R0bV9rbWFwX2l0ZXJfb3BzIHsKPj4gKwkvKioKPj4gKwkgKiBrbWFwX2xvY2Fs IC0gTWFwIGEgUEFHRV9TSVpFIHBhcnQgb2YgdGhlIHJlc291cmNlIHVzaW5nCj4+ICsJICoga21h cF9sb2NhbCBzZW1hbnRpY3MuCj4+ICsJICogQHJlc19rbWFwOiBQb2ludGVyIHRvIHRoZSBzdHJ1 Y3QgaTkxNV90dG1fa21hcF9pdGVyIHJlcHJlc2VudGluZwo+PiArCSAqIHRoZSByZXNvdXJjZS4K Pj4gKwkgKiBAZG1hcDogVGhlIHN0cnVjdCBkbWFfYnVmX21hcCBob2xkaW5nIHRoZSB2aXJ0dWFs IGFkZHJlc3MgYWZ0ZXIKPj4gKwkgKiB0aGUgb3BlcmF0aW9uLgo+PiArCSAqIEBpOiBUaGUgbG9j YXRpb24gd2l0aGluIHRoZSByZXNvdXJjZSB0byBtYXAuIFBBR0VfU0laRSBncmFudWxhcml0eS4K Pj4gKwkgKi8KPj4gKwl2b2lkICgqa21hcF9sb2NhbCkoc3RydWN0IGk5MTVfdHRtX2ttYXBfaXRl ciAqcmVzX2ttYXAsCj4+ICsJCQkgICBzdHJ1Y3QgZG1hX2J1Zl9tYXAgKmRtYXAsIHBnb2ZmX3Qg aSk7Cj4+ICt9Owo+PiArCj4+ICsvKioKPj4gKyAqIHN0cnVjdCBpOTE1X3R0bV9rbWFwX2l0ZXIg LSBJdGVyYXRvciBmb3Iga21hcF9sb2NhbCB0eXBlIG9wZXJhdGlvbnMgb24gYQo+PiArICogcmVz b3VyY2UuCj4+ICsgKiBAb3BzOiBQb2ludGVyIHRvIHRoZSBvcGVyYXRpb25zIHN0cnVjdC4KPj4g KyAqCj4+ICsgKiBUaGlzIHN0cnVjdCBpcyBpbnRlbmRlZCB0byBiZSBlbWJlZGRlZCBpbiBhIHJl c291cmNlLXNwZWNpZmljIHNwZWNpYWxpemF0aW9uCj4+ICsgKiBpbXBsZW1lbnRpbmcgb3BlcmF0 aW9ucyBmb3IgdGhlIHJlc291cmNlLgo+PiArICoKPj4gKyAqIE5vdGhpbmcgc3RvcHMgdXMgZnJv bSBleHRlbmRpbmcgdGhlIG9wZXJhdGlvbnMgdG8gdm1hcCwgdm1hcF9wZm4gZXRjLAo+PiArICog cmVwbGFjaW5nIHNvbWUgb3IgcGFydHMgb2YgdGhlIHR0bV9ib191dGlsLiBjcHUtbWFwIGZ1bmN0 aW9uYWxpdHkuCj4+ICsgKi8KPj4gK3N0cnVjdCBpOTE1X3R0bV9rbWFwX2l0ZXIgewo+PiArCWNv bnN0IHN0cnVjdCBpOTE1X3R0bV9rbWFwX2l0ZXJfb3BzICpvcHM7Cj4+ICt9Owo+PiArCj4+ICsv KioKPj4gKyAqIHN0cnVjdCBpOTE1X3R0bV9rbWFwX2l0ZXJfdHQgLSBTcGVjaWFsaXphdGlvbiBm b3IgYSB0dCAocGFnZSkgYmFja2VkIHN0cnVjdAo+PiArICogdHRtX3Jlc291cmNlLgo+PiArICog QGJhc2U6IEVtYmVkZGVkIHN0cnVjdCBpOTE1X3R0bV9rbWFwX2l0ZXIgcHJvdmlkaW5nIHRoZSB1 c2FnZSBpbnRlcmZhY2UKPj4gKyAqIEB0dDogQ2FjaGVkIHN0cnVjdCB0dG1fdHQuCj4+ICsgKi8K Pj4gK3N0cnVjdCBpOTE1X3R0bV9rbWFwX2l0ZXJfdHQgewo+PiArCXN0cnVjdCBpOTE1X3R0bV9r bWFwX2l0ZXIgYmFzZTsKPj4gKwlzdHJ1Y3QgdHRtX3R0ICp0dDsKPj4gK307Cj4+ICsKPj4gKy8q Kgo+PiArICogc3RydWN0IGk5MTVfdHRtX2ttYXBfaXRlcl9pb21hcCAtIFNwZWNpYWxpemF0aW9u IGZvciBhIHN0cnVjdCBpb19tYXBwaW5nICsKPj4gKyAqIHN0cnVjdCBzZ190YWJsZSBiYWNrZWQg c3RydWN0IHR0bV9yZXNvdXJjZS4KPj4gKyAqIEBiYXNlOiBFbWJlZGRlZCBzdHJ1Y3QgaTkxNV90 dG1fa21hcF9pdGVyIHByb3ZpZGluZyB0aGUgdXNhZ2UgaW50ZXJmYWNlLgo+PiArICogQGlvbWFw OiBzdHJ1Y3QgaW9fbWFwcGluZyByZXByZXNlbnRpbmcgdGhlIHVuZGVybHlpbmcgbGluZWFyIGlv X21lbW9yeS4KPj4gKyAqIEBzdDogc2dfdGFibGUgaW50byBAaW9tYXAsIHJlcHJlc2VudGluZyB0 aGUgbWVtb3J5IG9mIHRoZSBzdHJ1Y3QgdHRtX3Jlc291cmNlLgo+PiArICogQHN0YXJ0OiBPZmZz ZXQgdGhhdCBuZWVkcyB0byBiZSBzdWJ0cmFjdGVkIGZyb20gQHN0IHRvIG1ha2UKPj4gKyAqIHNn X2RtYV9hZGRyZXNzKHN0LT5zZ2wpIC0gQHN0YXJ0ID09IDAgZm9yIEBpb21hcCBzdGFydC4KPj4g KyAqIEBjYWNoZTogU2NhdHRlcmxpc3QgdHJhdmVyc2FsIGNhY2hlIGZvciBmYXN0IGxvb2t1cHMu Cj4+ICsgKiBAY2FjaGUuc2c6IFBvaW50ZXIgdG8gdGhlIGN1cnJlbnRseSBjYWNoZWQgc2NhdHRl cmxpc3Qgc2VnbWVudC4KPj4gKyAqIEBjYWNoZS5pOiBGaXJzdCBpbmRleCBvZiBAc2cuIFBBR0Vf U0laRSBncmFudWxhcml0eS4KPj4gKyAqIEBjYWNoZS5lbmQ6IExhc3QgaW5kZXggKyAxIG9mIEBz Zy4gUEFHRV9TSVpFIGdyYW51bGFyaXR5Lgo+PiArICogQGNhY2hlLm9mZnM6IEZpcnN0IG9mZnNl dCBpbnRvIEBpb21hcCBvZiBAc2cuIFBBR0VfU0laRSBncmFudWxhcml0eS4KPj4gKyAqLwo+PiAr c3RydWN0IGk5MTVfdHRtX2ttYXBfaXRlcl9pb21hcCB7Cj4+ICsJc3RydWN0IGk5MTVfdHRtX2tt YXBfaXRlciBiYXNlOwo+PiArCXN0cnVjdCBpb19tYXBwaW5nICppb21hcDsKPj4gKwlzdHJ1Y3Qg c2dfdGFibGUgKnN0Owo+PiArCXJlc291cmNlX3NpemVfdCBzdGFydDsKPj4gKwlzdHJ1Y3Qgewo+ PiArCQlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnOwo+PiArCQlwZ29mZl90IGk7Cj4+ICsJCXBnb2Zm X3QgZW5kOwo+PiArCQlwZ29mZl90IG9mZnM7Cj4+ICsJfSBjYWNoZTsKPj4gK307Cj4+ICsKPj4g K2V4dGVybiBzdHJ1Y3QgaTkxNV90dG1fa21hcF9pdGVyX29wcyBpOTE1X3R0bV9rbWFwX2l0ZXJf dHRfb3BzOwo+PiArZXh0ZXJuIHN0cnVjdCBpOTE1X3R0bV9rbWFwX2l0ZXJfb3BzIGk5MTVfdHRt X2ttYXBfaXRlcl9pb19vcHM7Cj4+ICsKPj4gKy8qKgo+PiArICogaTkxNV90dG1fa21hcF9pdGVy X2lvbWFwX2luaXQgLSBJbml0aWFsaXplIGEgc3RydWN0IGk5MTVfdHRtX2ttYXBfaXRlcl9pb21h cAo+PiArICogQGl0ZXJfaW86IFRoZSBzdHJ1Y3QgaTkxNV90dG1fa21hcF9pdGVyX2lvbWFwIHRv IGluaXRpYWxpemUuCj4+ICsgKiBAaW9tYXA6IFRoZSBzdHJ1Y3QgaW9fbWFwcGluZyByZXByZXNl bnRpbmcgdGhlIHVuZGVybHlpbmcgbGluZWFyIGlvX21lbW9yeS4KPj4gKyAqIEBzdDogc2dfdGFi bGUgaW50byBAaW9tYXAsIHJlcHJlc2VudGluZyB0aGUgbWVtb3J5IG9mIHRoZSBzdHJ1Y3QKPj4g KyAqIHR0bV9yZXNvdXJjZS4KPj4gKyAqIEBzdGFydDogT2Zmc2V0IHRoYXQgbmVlZHMgdG8gYmUg c3VidHJhY3RlZCBmcm9tIEBzdCB0byBtYWtlCj4+ICsgKiBzZ19kbWFfYWRkcmVzcyhzdC0+c2ds KSAtIEBzdGFydCA9PSAwIGZvciBAaW9tYXAgc3RhcnQuCj4+ICsgKgo+PiArICogUmV0dXJuOiBQ b2ludGVyIHRvIHRoZSBlbWJlZGRlZCBzdHJ1Y3QgaTkxNV90dG1fa21hcF9pdGVyLgo+PiArICov Cj4+ICtzdGF0aWMgaW5saW5lIHN0cnVjdCBpOTE1X3R0bV9rbWFwX2l0ZXIgKgo+PiAraTkxNV90 dG1fa21hcF9pdGVyX2lvbWFwX2luaXQoc3RydWN0IGk5MTVfdHRtX2ttYXBfaXRlcl9pb21hcCAq aXRlcl9pbywKPj4gKwkJCSAgICAgIHN0cnVjdCBpb19tYXBwaW5nICppb21hcCwKPj4gKwkJCSAg ICAgIHN0cnVjdCBzZ190YWJsZSAqc3QsCj4+ICsJCQkgICAgICByZXNvdXJjZV9zaXplX3Qgc3Rh cnQpCj4+ICt7Cj4+ICsJaXRlcl9pby0+YmFzZS5vcHMgPSAmaTkxNV90dG1fa21hcF9pdGVyX2lv X29wczsKPj4gKwlpdGVyX2lvLT5pb21hcCA9IGlvbWFwOwo+PiArCWl0ZXJfaW8tPnN0ID0gc3Q7 Cj4+ICsJaXRlcl9pby0+c3RhcnQgPSBzdGFydDsKPj4gKwltZW1zZXQoJml0ZXJfaW8tPmNhY2hl LCAwLCBzaXplb2YoaXRlcl9pby0+Y2FjaGUpKTsKPj4gKwlyZXR1cm4gJml0ZXJfaW8tPmJhc2U7 Cj4+ICt9Cj4+ICsKPj4gKy8qKgo+PiArICogdHRtX2ttYXBfaXRlcl90dF9pbml0IC0gSW5pdGlh bGl6ZSBhIHN0cnVjdCBpOTE1X3R0bV9rbWFwX2l0ZXJfdHQKPj4gKyAqIEBpdGVyX3R0OiBUaGUg c3RydWN0IGk5MTVfdHRtX2ttYXBfaXRlcl90dCB0byBpbml0aWFsaXplLgo+PiArICogQHR0OiBT dHJ1Y3QgdHRtX3R0IGhvbGRpbmcgcGFnZSBwb2ludGVycyBvZiB0aGUgc3RydWN0IHR0bV9yZXNv dXJjZS4KPj4gKyAqCj4+ICsgKiBSZXR1cm46IFBvaW50ZXIgdG8gdGhlIGVtYmVkZGVkIHN0cnVj dCBpOTE1X3R0bV9rbWFwX2l0ZXIuCj4+ICsgKi8KPj4gK3N0YXRpYyBpbmxpbmUgc3RydWN0IGk5 MTVfdHRtX2ttYXBfaXRlciAqCj4+ICtpOTE1X3R0bV9rbWFwX2l0ZXJfdHRfaW5pdChzdHJ1Y3Qg aTkxNV90dG1fa21hcF9pdGVyX3R0ICppdGVyX3R0LAo+PiArCQkJICAgc3RydWN0IHR0bV90dCAq dHQpCj4+ICt7Cj4+ICsJaXRlcl90dC0+YmFzZS5vcHMgPSAmaTkxNV90dG1fa21hcF9pdGVyX3R0 X29wczsKPj4gKwlpdGVyX3R0LT50dCA9IHR0Owo+PiArCXJldHVybiAmaXRlcl90dC0+YmFzZTsK Pj4gK30KPiBEbyB0aGVyZSBmdW5jdGlvbnMgaGF2ZSBhIHZhbGlkICpwZXJmb3JtYW5jZSogcmVh c29uIHRvIGJlIGlubGluZT8gSQo+IHRoaW5rIHRoYXQncyBwcmV0dHkgbXVjaCB0aGUgb25seSB2 YWxpZCByZWFzb24uCj4KPiBIYXZpbmcgdGhlc2UgaW5saW5lIGZvcmNlcyBpOTE1X3R0bV9rbWFw X2l0ZXJfKl9vcHMgZXh0ZXJuLCBhbmQgdGhleQo+IHNob3VsZCByZWFsbHkgYmUgc3RhdGljLiBJ bmxpbmUgZnVuY3Rpb25zIGNvbXBsaWNhdGUgaGVhZGVyIGRlcGVuZGVuY2llcwo+IGFuZCBsZWFr IHRoZSBhYnN0cmFjdGlvbnMuCj4KPiBCUiwKPiBKYW5pLgoKSGksCgpUaGFua3MgZm9yIHJldmll d2luZy4gSSBkb24ndCB0aGluayB0aGVyZSByZWFsbHkgaXMgYSBwZXJmb3JtYW5jZSByZWFzb24g CmZvciBrZWVwaW5nIHRoZXNlIGZ1bmN0aW9ucyBpbmxpbmUuIFdoaWxlIGluIHRoaXMgY2FzZSB0 aGVyZSBpcyBub3QgCnJlYWxseSBtdWNoIGNoYW5nZSBlaXRoZXIgaW4gbGVha2luZyBhYnN0cmFj dGlvbnMgbm9yIGluIGhlYWRlciAKZGVwZW5kZW5jaWVzIEkgYWdyZWUga2VlcGluZyB0aG9zZSBv cHMgc3RhdGljIGlzIHByb2JhYmx5IGEgYmV0dGVyIApjaG9pY2UuIEknbGwgcmVzcGluLgoKVGhh bmtzLAoKVGhvbWFzCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Au b3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vaW50ZWwt Z2Z4Cg==