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=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 49242C4743C for ; Wed, 23 Jun 2021 14:16:36 +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 D97376101D for ; Wed, 23 Jun 2021 14:16:35 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org D97376101D Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=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 42BD56E905; Wed, 23 Jun 2021 14:16:35 +0000 (UTC) Received: from mga18.intel.com (mga18.intel.com [134.134.136.126]) by gabe.freedesktop.org (Postfix) with ESMTPS id 298306E905; Wed, 23 Jun 2021 14:16:33 +0000 (UTC) IronPort-SDR: U99SBXiRtOnisj+zX9PpYXTUWuRUga3wbWkq0r7n1ilzODjlnmmEMuAZBu5zbQdElk430lrU6X ZgdMp6JmQePg== X-IronPort-AV: E=McAfee;i="6200,9189,10024"; a="194575749" X-IronPort-AV: E=Sophos;i="5.83,294,1616482800"; d="scan'208";a="194575749" Received: from fmsmga001.fm.intel.com ([10.253.24.23]) by orsmga106.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 23 Jun 2021 07:16:32 -0700 IronPort-SDR: q0c52GuoH/DI1KRE3Oshh36axwXKPYiqUcipNSiWrMJGxjVRQkg6dlXo5wec53pwpD8/NXECoy jkWPbFaAi6GQ== X-IronPort-AV: E=Sophos;i="5.83,294,1616482800"; d="scan'208";a="556982695" Received: from dconnon-mobl.ger.corp.intel.com (HELO mwauld-desk1.intel.com) ([10.252.14.111]) by fmsmga001-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 23 Jun 2021 07:16:31 -0700 From: Matthew Auld To: intel-gfx@lists.freedesktop.org Subject: [PATCH v2 1/2] drm/i915: support forcing the page size with lmem Date: Wed, 23 Jun 2021 15:16:14 +0100 Message-Id: <20210623141615.291391-1-matthew.auld@intel.com> X-Mailer: git-send-email 2.26.3 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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?Thomas=20Hellstr=C3=B6m?= , dri-devel@lists.freedesktop.org Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" For some specialised objects we might need something larger than the regions min_page_size due to some hw restriction, and slightly more hairy is needing something smaller with the guarantee that such objects will never be inserted into any GTT, which is the case for the paging structures. This also fixes how we setup the BO page_alignment, if we later migrate the object somewhere else. For example if the placements are {SMEM, LMEM}, then we might get this wrong. Pushing the min_page_size behaviour into the manager should fix this. v2(Thomas): push the default page size behaviour into buddy_man, and let the user override it with the page-alignment, which looks cleaner Signed-off-by: Matthew Auld Cc: Thomas Hellström --- drivers/gpu/drm/i915/gem/i915_gem_create.c | 2 +- drivers/gpu/drm/i915/gem/i915_gem_lmem.c | 33 +++++++++- drivers/gpu/drm/i915/gem/i915_gem_lmem.h | 5 ++ drivers/gpu/drm/i915/gem/i915_gem_region.c | 13 +++- drivers/gpu/drm/i915/gem/i915_gem_region.h | 1 + drivers/gpu/drm/i915/gem/i915_gem_shmem.c | 3 +- drivers/gpu/drm/i915/gem/i915_gem_stolen.c | 3 +- drivers/gpu/drm/i915/gem/i915_gem_ttm.c | 6 +- drivers/gpu/drm/i915/gem/i915_gem_ttm.h | 1 + .../gpu/drm/i915/gem/selftests/huge_pages.c | 3 +- .../drm/i915/gem/selftests/i915_gem_mman.c | 8 +-- drivers/gpu/drm/i915/i915_ttm_buddy_manager.c | 14 ++++- drivers/gpu/drm/i915/i915_ttm_buddy_manager.h | 2 +- drivers/gpu/drm/i915/intel_memory_region.h | 1 + drivers/gpu/drm/i915/intel_region_ttm.c | 4 +- .../drm/i915/selftests/intel_memory_region.c | 63 ++++++++++++++++++- drivers/gpu/drm/i915/selftests/mock_region.c | 1 + 17 files changed, 143 insertions(+), 20 deletions(-) diff --git a/drivers/gpu/drm/i915/gem/i915_gem_create.c b/drivers/gpu/drm/i915/gem/i915_gem_create.c index 93bf63bbaff1..51f92e4b1a69 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_create.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_create.c @@ -90,7 +90,7 @@ i915_gem_setup(struct drm_i915_gem_object *obj, u64 size) */ flags = I915_BO_ALLOC_USER; - ret = mr->ops->init_object(mr, obj, size, flags); + ret = mr->ops->init_object(mr, obj, size, 0, flags); if (ret) return ret; diff --git a/drivers/gpu/drm/i915/gem/i915_gem_lmem.c b/drivers/gpu/drm/i915/gem/i915_gem_lmem.c index d539dffa1554..174a9e34ad93 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_lmem.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_lmem.c @@ -71,11 +71,42 @@ bool i915_gem_object_is_lmem(struct drm_i915_gem_object *obj) mr->type == INTEL_MEMORY_STOLEN_LOCAL); } +/** + * __i915_gem_object_create_lmem_with_ps - Create lmem object and force the + * minimum page size for the backing pages. + * @i915: The i915 instance. + * @size: The size in bytes for the object. Note that we need to round the size + * up depending on the @page_size. The final object size can be fished out from + * the drm GEM object. + * @page_size: The requested minimum page size in bytes for this object. The is + * useful if we need something bigger than the regions min_page_size due to some + * hw restriction, or in some very specialised cases where it needs to be + * smaller, where the internal fragmentation cost is too great when rounding up + * the object size. + * @flags: the optional BO allocation flags + * + * Note that this interface assumes you know what you are doing when forcing the + * page_size. If this is smaller than the regions min_page_size then it can + * never be inserted into any GTT, otherwise it might lead to undefined + * behaviour. + * + * Return: The object pointer, which might be an ERR_PTR in the case of failure. + */ +struct drm_i915_gem_object * +__i915_gem_object_create_lmem_with_ps(struct drm_i915_private *i915, + resource_size_t size, + resource_size_t page_size, + unsigned int flags) +{ + return i915_gem_object_create_region(i915->mm.regions[INTEL_REGION_LMEM], + size, page_size, flags); +} + struct drm_i915_gem_object * i915_gem_object_create_lmem(struct drm_i915_private *i915, resource_size_t size, unsigned int flags) { return i915_gem_object_create_region(i915->mm.regions[INTEL_REGION_LMEM], - size, flags); + size, 0, flags); } diff --git a/drivers/gpu/drm/i915/gem/i915_gem_lmem.h b/drivers/gpu/drm/i915/gem/i915_gem_lmem.h index ea76fd11ccb0..e98608cebbbc 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_lmem.h +++ b/drivers/gpu/drm/i915/gem/i915_gem_lmem.h @@ -21,6 +21,11 @@ i915_gem_object_lmem_io_map(struct drm_i915_gem_object *obj, bool i915_gem_object_is_lmem(struct drm_i915_gem_object *obj); +struct drm_i915_gem_object * +__i915_gem_object_create_lmem_with_ps(struct drm_i915_private *i915, + resource_size_t size, + resource_size_t page_size, + unsigned int flags); struct drm_i915_gem_object * i915_gem_object_create_lmem(struct drm_i915_private *i915, resource_size_t size, diff --git a/drivers/gpu/drm/i915/gem/i915_gem_region.c b/drivers/gpu/drm/i915/gem/i915_gem_region.c index d1f1840540dd..63a6ce6cc5fe 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_region.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_region.c @@ -36,9 +36,11 @@ void i915_gem_object_release_memory_region(struct drm_i915_gem_object *obj) struct drm_i915_gem_object * i915_gem_object_create_region(struct intel_memory_region *mem, resource_size_t size, + resource_size_t page_size, unsigned int flags) { struct drm_i915_gem_object *obj; + resource_size_t default_page_size; int err; /* @@ -52,7 +54,14 @@ i915_gem_object_create_region(struct intel_memory_region *mem, if (!mem) return ERR_PTR(-ENODEV); - size = round_up(size, mem->min_page_size); + default_page_size = mem->min_page_size; + if (page_size) + default_page_size = page_size; + + GEM_BUG_ON(!is_power_of_2_u64(default_page_size)); + GEM_BUG_ON(default_page_size < PAGE_SIZE); + + size = round_up(size, default_page_size); GEM_BUG_ON(!size); GEM_BUG_ON(!IS_ALIGNED(size, I915_GTT_MIN_ALIGNMENT)); @@ -64,7 +73,7 @@ i915_gem_object_create_region(struct intel_memory_region *mem, if (!obj) return ERR_PTR(-ENOMEM); - err = mem->ops->init_object(mem, obj, size, flags); + err = mem->ops->init_object(mem, obj, size, page_size, flags); if (err) goto err_object_free; diff --git a/drivers/gpu/drm/i915/gem/i915_gem_region.h b/drivers/gpu/drm/i915/gem/i915_gem_region.h index 84fcb3297400..1008e580a89a 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_region.h +++ b/drivers/gpu/drm/i915/gem/i915_gem_region.h @@ -19,6 +19,7 @@ void i915_gem_object_release_memory_region(struct drm_i915_gem_object *obj); struct drm_i915_gem_object * i915_gem_object_create_region(struct intel_memory_region *mem, resource_size_t size, + resource_size_t page_size, unsigned int flags); #endif diff --git a/drivers/gpu/drm/i915/gem/i915_gem_shmem.c b/drivers/gpu/drm/i915/gem/i915_gem_shmem.c index 5d16c4462fda..f5791611b9ca 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_shmem.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_shmem.c @@ -489,6 +489,7 @@ static int __create_shmem(struct drm_i915_private *i915, static int shmem_object_init(struct intel_memory_region *mem, struct drm_i915_gem_object *obj, resource_size_t size, + resource_size_t page_size, unsigned int flags) { static struct lock_class_key lock_class; @@ -548,7 +549,7 @@ i915_gem_object_create_shmem(struct drm_i915_private *i915, resource_size_t size) { return i915_gem_object_create_region(i915->mm.regions[INTEL_REGION_SMEM], - size, 0); + size, 0, 0); } /* Allocate a new GEM object and fill it with the supplied data */ diff --git a/drivers/gpu/drm/i915/gem/i915_gem_stolen.c b/drivers/gpu/drm/i915/gem/i915_gem_stolen.c index b0c3a7dc60d1..90708de27684 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_stolen.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_stolen.c @@ -670,6 +670,7 @@ static int __i915_gem_object_create_stolen(struct intel_memory_region *mem, static int _i915_gem_object_stolen_init(struct intel_memory_region *mem, struct drm_i915_gem_object *obj, resource_size_t size, + resource_size_t page_size, unsigned int flags) { struct drm_i915_private *i915 = mem->i915; @@ -708,7 +709,7 @@ struct drm_i915_gem_object * i915_gem_object_create_stolen(struct drm_i915_private *i915, resource_size_t size) { - return i915_gem_object_create_region(i915->mm.stolen_region, size, 0); + return i915_gem_object_create_region(i915->mm.stolen_region, size, 0, 0); } static int init_stolen_smem(struct intel_memory_region *mem) diff --git a/drivers/gpu/drm/i915/gem/i915_gem_ttm.c b/drivers/gpu/drm/i915/gem/i915_gem_ttm.c index c5deb8b7227c..51f22f9607f6 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_ttm.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_ttm.c @@ -765,6 +765,7 @@ void i915_ttm_bo_destroy(struct ttm_buffer_object *bo) int __i915_gem_ttm_object_init(struct intel_memory_region *mem, struct drm_i915_gem_object *obj, resource_size_t size, + resource_size_t page_size, unsigned int flags) { static struct lock_class_key lock_class; @@ -783,6 +784,9 @@ int __i915_gem_ttm_object_init(struct intel_memory_region *mem, bo_type = (obj->flags & I915_BO_ALLOC_USER) ? ttm_bo_type_device : ttm_bo_type_kernel; + /* Forcing the page size is kernel internal only */ + GEM_BUG_ON(page_size && obj->mm.n_placements); + /* * If this function fails, it will call the destructor, but * our caller still owns the object. So no freeing in the @@ -793,7 +797,7 @@ int __i915_gem_ttm_object_init(struct intel_memory_region *mem, obj->base.vma_node.driver_private = i915_gem_to_ttm(obj); ret = ttm_bo_init(&i915->bdev, i915_gem_to_ttm(obj), size, bo_type, &i915_sys_placement, - mem->min_page_size >> PAGE_SHIFT, + page_size >> PAGE_SHIFT, true, NULL, NULL, i915_ttm_bo_destroy); if (!ret) obj->ttm.created = true; diff --git a/drivers/gpu/drm/i915/gem/i915_gem_ttm.h b/drivers/gpu/drm/i915/gem/i915_gem_ttm.h index b8d3dcbb50df..40927f67b6d9 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_ttm.h +++ b/drivers/gpu/drm/i915/gem/i915_gem_ttm.h @@ -44,5 +44,6 @@ i915_ttm_to_gem(struct ttm_buffer_object *bo) int __i915_gem_ttm_object_init(struct intel_memory_region *mem, struct drm_i915_gem_object *obj, resource_size_t size, + resource_size_t page_size, unsigned int flags); #endif diff --git a/drivers/gpu/drm/i915/gem/selftests/huge_pages.c b/drivers/gpu/drm/i915/gem/selftests/huge_pages.c index dadd485bc52f..9d17bff8b36d 100644 --- a/drivers/gpu/drm/i915/gem/selftests/huge_pages.c +++ b/drivers/gpu/drm/i915/gem/selftests/huge_pages.c @@ -497,7 +497,8 @@ static int igt_mock_memory_region_huge_pages(void *arg) int i; for (i = 0; i < ARRAY_SIZE(flags); ++i) { - obj = i915_gem_object_create_region(mem, page_size, + obj = i915_gem_object_create_region(mem, + page_size, page_size, flags[i]); if (IS_ERR(obj)) { err = PTR_ERR(obj); diff --git a/drivers/gpu/drm/i915/gem/selftests/i915_gem_mman.c b/drivers/gpu/drm/i915/gem/selftests/i915_gem_mman.c index 44b5de06ce64..7398b502738a 100644 --- a/drivers/gpu/drm/i915/gem/selftests/i915_gem_mman.c +++ b/drivers/gpu/drm/i915/gem/selftests/i915_gem_mman.c @@ -955,7 +955,7 @@ static int igt_mmap(void *arg) struct drm_i915_gem_object *obj; int err; - obj = i915_gem_object_create_region(mr, sizes[i], I915_BO_ALLOC_USER); + obj = i915_gem_object_create_region(mr, sizes[i], 0, I915_BO_ALLOC_USER); if (obj == ERR_PTR(-ENODEV)) continue; @@ -1075,7 +1075,7 @@ static int igt_mmap_access(void *arg) struct drm_i915_gem_object *obj; int err; - obj = i915_gem_object_create_region(mr, PAGE_SIZE, I915_BO_ALLOC_USER); + obj = i915_gem_object_create_region(mr, PAGE_SIZE, 0, I915_BO_ALLOC_USER); if (obj == ERR_PTR(-ENODEV)) continue; @@ -1220,7 +1220,7 @@ static int igt_mmap_gpu(void *arg) struct drm_i915_gem_object *obj; int err; - obj = i915_gem_object_create_region(mr, PAGE_SIZE, I915_BO_ALLOC_USER); + obj = i915_gem_object_create_region(mr, PAGE_SIZE, 0, I915_BO_ALLOC_USER); if (obj == ERR_PTR(-ENODEV)) continue; @@ -1375,7 +1375,7 @@ static int igt_mmap_revoke(void *arg) struct drm_i915_gem_object *obj; int err; - obj = i915_gem_object_create_region(mr, PAGE_SIZE, I915_BO_ALLOC_USER); + obj = i915_gem_object_create_region(mr, PAGE_SIZE, 0, I915_BO_ALLOC_USER); if (obj == ERR_PTR(-ENODEV)) continue; diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c index fc7ad5c035b8..2c143034cbd9 100644 --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.c @@ -18,6 +18,7 @@ struct i915_ttm_buddy_manager { struct i915_buddy_mm mm; struct list_head reserved; struct mutex lock; + u64 default_page_size; }; static struct i915_ttm_buddy_manager * @@ -53,7 +54,10 @@ static int i915_ttm_buddy_man_alloc(struct ttm_resource_manager *man, GEM_BUG_ON(!bman_res->base.num_pages); size = bman_res->base.num_pages << PAGE_SHIFT; - min_page_size = bo->page_alignment << PAGE_SHIFT; + min_page_size = bman->default_page_size; + if (bo->page_alignment) + min_page_size = bo->page_alignment << PAGE_SHIFT; + GEM_BUG_ON(min_page_size < mm->chunk_size); min_order = ilog2(min_page_size) - ilog2(mm->chunk_size); if (place->flags & TTM_PL_FLAG_CONTIGUOUS) { @@ -134,6 +138,9 @@ static const struct ttm_resource_manager_func i915_ttm_buddy_manager_func = { * @type: Memory type we want to manage * @use_tt: Set use_tt for the manager * @size: The size in bytes to manage + * @default_page_size: The default minimum page size in bytes for allocations, + * this must be at least as large as @chunk_size, and can be overriden by + * setting the BO page_alignment, to be larger or smaller as needed. * @chunk_size: The minimum page size in bytes for our allocations i.e * order-zero * @@ -154,7 +161,8 @@ static const struct ttm_resource_manager_func i915_ttm_buddy_manager_func = { */ int i915_ttm_buddy_man_init(struct ttm_device *bdev, unsigned int type, bool use_tt, - u64 size, u64 chunk_size) + u64 size, u64 default_page_size, + u64 chunk_size) { struct ttm_resource_manager *man; struct i915_ttm_buddy_manager *bman; @@ -170,6 +178,8 @@ int i915_ttm_buddy_man_init(struct ttm_device *bdev, mutex_init(&bman->lock); INIT_LIST_HEAD(&bman->reserved); + GEM_BUG_ON(default_page_size < chunk_size); + bman->default_page_size = default_page_size; man = &bman->manager; man->use_tt = use_tt; diff --git a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h index 26026213e20a..0722d33f3e14 100644 --- a/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h +++ b/drivers/gpu/drm/i915/i915_ttm_buddy_manager.h @@ -46,7 +46,7 @@ to_ttm_buddy_resource(struct ttm_resource *res) int i915_ttm_buddy_man_init(struct ttm_device *bdev, unsigned type, bool use_tt, - u64 size, u64 chunk_size); + u64 size, u64 default_page_size, u64 chunk_size); int i915_ttm_buddy_man_fini(struct ttm_device *bdev, unsigned int type); diff --git a/drivers/gpu/drm/i915/intel_memory_region.h b/drivers/gpu/drm/i915/intel_memory_region.h index 2be8433d373a..359cd8424b9a 100644 --- a/drivers/gpu/drm/i915/intel_memory_region.h +++ b/drivers/gpu/drm/i915/intel_memory_region.h @@ -55,6 +55,7 @@ struct intel_memory_region_ops { int (*init_object)(struct intel_memory_region *mem, struct drm_i915_gem_object *obj, resource_size_t size, + resource_size_t page_size, unsigned int flags); }; diff --git a/drivers/gpu/drm/i915/intel_region_ttm.c b/drivers/gpu/drm/i915/intel_region_ttm.c index 4cd10f364e84..98c7339bf8ba 100644 --- a/drivers/gpu/drm/i915/intel_region_ttm.c +++ b/drivers/gpu/drm/i915/intel_region_ttm.c @@ -86,7 +86,8 @@ int intel_region_ttm_init(struct intel_memory_region *mem) int ret; ret = i915_ttm_buddy_man_init(bdev, mem_type, false, - resource_size(&mem->region), PAGE_SIZE); + resource_size(&mem->region), + mem->min_page_size, PAGE_SIZE); if (ret) return ret; @@ -167,7 +168,6 @@ intel_region_ttm_resource_alloc(struct intel_memory_region *mem, int ret; mock_bo.base.size = size; - mock_bo.page_alignment = mem->min_page_size >> PAGE_SHIFT; place.flags = flags; ret = man->func->alloc(man, &mock_bo, &place, &res); diff --git a/drivers/gpu/drm/i915/selftests/intel_memory_region.c b/drivers/gpu/drm/i915/selftests/intel_memory_region.c index ecc3b9e6c22b..1aaccb9841a0 100644 --- a/drivers/gpu/drm/i915/selftests/intel_memory_region.c +++ b/drivers/gpu/drm/i915/selftests/intel_memory_region.c @@ -68,7 +68,7 @@ static int igt_mock_fill(void *arg) resource_size_t size = page_num * page_size; struct drm_i915_gem_object *obj; - obj = i915_gem_object_create_region(mem, size, 0); + obj = i915_gem_object_create_region(mem, size, 0, 0); if (IS_ERR(obj)) { err = PTR_ERR(obj); break; @@ -110,7 +110,7 @@ igt_object_create(struct intel_memory_region *mem, struct drm_i915_gem_object *obj; int err; - obj = i915_gem_object_create_region(mem, size, flags); + obj = i915_gem_object_create_region(mem, size, 0, flags); if (IS_ERR(obj)) return obj; @@ -647,6 +647,62 @@ static int igt_lmem_create(void *arg) return err; } +static int igt_lmem_create_with_ps(void *arg) +{ + struct drm_i915_private *i915 = arg; + int err = 0; + u32 ps; + + for (ps = PAGE_SIZE; ps <= SZ_1G; ps <<= 1) { + struct drm_i915_gem_object *obj; + dma_addr_t daddr; + + obj = __i915_gem_object_create_lmem_with_ps(i915, ps, ps, 0); + if (IS_ERR(obj)) { + err = PTR_ERR(obj); + if (err == -ENXIO || err == -E2BIG) { + pr_info("%s not enough lmem for ps(%u) err=%d\n", + __func__, ps, err); + err = 0; + } + + break; + } + + if (obj->base.size != ps) { + pr_err("%s size(%zu) != ps(%u)\n", + __func__, obj->base.size, ps); + err = -EINVAL; + goto out_put; + } + + i915_gem_object_lock(obj, NULL); + err = i915_gem_object_pin_pages(obj); + if (err) + goto out_put; + + daddr = i915_gem_object_get_dma_address(obj, 0); + if (!IS_ALIGNED(daddr, ps)) { + pr_err("%s daddr(%pa) not aligned with ps(%u)\n", + __func__, &daddr, ps); + err = -EINVAL; + goto out_unpin; + } + +out_unpin: + i915_gem_object_unpin_pages(obj); + __i915_gem_object_put_pages(obj); +out_put: + i915_gem_object_unlock(obj); + i915_gem_object_put(obj); + + if (err) + break; + } + + return err; +} + static int igt_lmem_create_cleared_cpu(void *arg) { struct drm_i915_private *i915 = arg; @@ -932,7 +988,7 @@ create_region_for_mapping(struct intel_memory_region *mr, u64 size, u32 type, struct drm_i915_gem_object *obj; void *addr; - obj = i915_gem_object_create_region(mr, size, 0); + obj = i915_gem_object_create_region(mr, size, 0, 0); if (IS_ERR(obj)) { if (PTR_ERR(obj) == -ENOSPC) /* Stolen memory */ return ERR_PTR(-ENODEV); @@ -1149,6 +1205,7 @@ int intel_memory_region_live_selftests(struct drm_i915_private *i915) { static const struct i915_subtest tests[] = { SUBTEST(igt_lmem_create), + SUBTEST(igt_lmem_create_with_ps), SUBTEST(igt_lmem_create_cleared_cpu), SUBTEST(igt_lmem_write_cpu), SUBTEST(igt_lmem_write_gpu), diff --git a/drivers/gpu/drm/i915/selftests/mock_region.c b/drivers/gpu/drm/i915/selftests/mock_region.c index fa786dede608..efa86dffe3c6 100644 --- a/drivers/gpu/drm/i915/selftests/mock_region.c +++ b/drivers/gpu/drm/i915/selftests/mock_region.c @@ -63,6 +63,7 @@ static const struct drm_i915_gem_object_ops mock_region_obj_ops = { static int mock_object_init(struct intel_memory_region *mem, struct drm_i915_gem_object *obj, resource_size_t size, + resource_size_t page_size, unsigned int flags) { static struct lock_class_key lock_class; -- 2.26.3 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=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 2A0D6C48BE5 for ; Wed, 23 Jun 2021 14:16:40 +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 E5AEA6101D for ; Wed, 23 Jun 2021 14:16:39 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org E5AEA6101D Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=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 4879E6E906; Wed, 23 Jun 2021 14:16:36 +0000 (UTC) Received: from mga18.intel.com (mga18.intel.com [134.134.136.126]) by gabe.freedesktop.org (Postfix) with ESMTPS id 298306E905; Wed, 23 Jun 2021 14:16:33 +0000 (UTC) IronPort-SDR: U99SBXiRtOnisj+zX9PpYXTUWuRUga3wbWkq0r7n1ilzODjlnmmEMuAZBu5zbQdElk430lrU6X ZgdMp6JmQePg== X-IronPort-AV: E=McAfee;i="6200,9189,10024"; a="194575749" X-IronPort-AV: E=Sophos;i="5.83,294,1616482800"; d="scan'208";a="194575749" Received: from fmsmga001.fm.intel.com ([10.253.24.23]) by orsmga106.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 23 Jun 2021 07:16:32 -0700 IronPort-SDR: q0c52GuoH/DI1KRE3Oshh36axwXKPYiqUcipNSiWrMJGxjVRQkg6dlXo5wec53pwpD8/NXECoy jkWPbFaAi6GQ== X-IronPort-AV: E=Sophos;i="5.83,294,1616482800"; d="scan'208";a="556982695" Received: from dconnon-mobl.ger.corp.intel.com (HELO mwauld-desk1.intel.com) ([10.252.14.111]) by fmsmga001-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 23 Jun 2021 07:16:31 -0700 From: Matthew Auld To: intel-gfx@lists.freedesktop.org Date: Wed, 23 Jun 2021 15:16:14 +0100 Message-Id: <20210623141615.291391-1-matthew.auld@intel.com> X-Mailer: git-send-email 2.26.3 MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH v2 1/2] drm/i915: support forcing the page size with lmem 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?Thomas=20Hellstr=C3=B6m?= , dri-devel@lists.freedesktop.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" Rm9yIHNvbWUgc3BlY2lhbGlzZWQgb2JqZWN0cyB3ZSBtaWdodCBuZWVkIHNvbWV0aGluZyBsYXJn ZXIgdGhhbiB0aGUKcmVnaW9ucyBtaW5fcGFnZV9zaXplIGR1ZSB0byBzb21lIGh3IHJlc3RyaWN0 aW9uLCBhbmQgc2xpZ2h0bHkgbW9yZQpoYWlyeSBpcyBuZWVkaW5nIHNvbWV0aGluZyBzbWFsbGVy IHdpdGggdGhlIGd1YXJhbnRlZSB0aGF0IHN1Y2ggb2JqZWN0cwp3aWxsIG5ldmVyIGJlIGluc2Vy dGVkIGludG8gYW55IEdUVCwgd2hpY2ggaXMgdGhlIGNhc2UgZm9yIHRoZSBwYWdpbmcKc3RydWN0 dXJlcy4KClRoaXMgYWxzbyBmaXhlcyBob3cgd2Ugc2V0dXAgdGhlIEJPIHBhZ2VfYWxpZ25tZW50 LCBpZiB3ZSBsYXRlciBtaWdyYXRlCnRoZSBvYmplY3Qgc29tZXdoZXJlIGVsc2UuIEZvciBleGFt cGxlIGlmIHRoZSBwbGFjZW1lbnRzIGFyZSB7U01FTSwKTE1FTX0sIHRoZW4gd2UgbWlnaHQgZ2V0 IHRoaXMgd3JvbmcuIFB1c2hpbmcgdGhlIG1pbl9wYWdlX3NpemUgYmVoYXZpb3VyCmludG8gdGhl IG1hbmFnZXIgc2hvdWxkIGZpeCB0aGlzLgoKdjIoVGhvbWFzKTogcHVzaCB0aGUgZGVmYXVsdCBw YWdlIHNpemUgYmVoYXZpb3VyIGludG8gYnVkZHlfbWFuLCBhbmQgbGV0CnRoZSB1c2VyIG92ZXJy aWRlIGl0IHdpdGggdGhlIHBhZ2UtYWxpZ25tZW50LCB3aGljaCBsb29rcyBjbGVhbmVyCgpTaWdu ZWQtb2ZmLWJ5OiBNYXR0aGV3IEF1bGQgPG1hdHRoZXcuYXVsZEBpbnRlbC5jb20+CkNjOiBUaG9t YXMgSGVsbHN0csO2bSA8dGhvbWFzLmhlbGxzdHJvbUBsaW51eC5pbnRlbC5jb20+Ci0tLQogZHJp dmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2NyZWF0ZS5jICAgIHwgIDIgKy0KIGRyaXZl cnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9sbWVtLmMgICAgICB8IDMzICsrKysrKysrKy0K IGRyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9sbWVtLmggICAgICB8ICA1ICsrCiBk cml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fcmVnaW9uLmMgICAgfCAxMyArKystCiBk cml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fcmVnaW9uLmggICAgfCAgMSArCiBkcml2 ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fc2htZW0uYyAgICAgfCAgMyArLQogZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3N0b2xlbi5jICAgIHwgIDMgKy0KIGRyaXZlcnMv Z3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV90dG0uYyAgICAgICB8ICA2ICstCiBkcml2ZXJzL2dw dS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fdHRtLmggICAgICAgfCAgMSArCiAuLi4vZ3B1L2RybS9p OTE1L2dlbS9zZWxmdGVzdHMvaHVnZV9wYWdlcy5jICAgfCAgMyArLQogLi4uL2RybS9pOTE1L2dl bS9zZWxmdGVzdHMvaTkxNV9nZW1fbW1hbi5jICAgIHwgIDggKy0tCiBkcml2ZXJzL2dwdS9kcm0v aTkxNS9pOTE1X3R0bV9idWRkeV9tYW5hZ2VyLmMgfCAxNCArKysrLQogZHJpdmVycy9ncHUvZHJt L2k5MTUvaTkxNV90dG1fYnVkZHlfbWFuYWdlci5oIHwgIDIgKy0KIGRyaXZlcnMvZ3B1L2RybS9p OTE1L2ludGVsX21lbW9yeV9yZWdpb24uaCAgICB8ICAxICsKIGRyaXZlcnMvZ3B1L2RybS9pOTE1 L2ludGVsX3JlZ2lvbl90dG0uYyAgICAgICB8ICA0ICstCiAuLi4vZHJtL2k5MTUvc2VsZnRlc3Rz L2ludGVsX21lbW9yeV9yZWdpb24uYyAgfCA2MyArKysrKysrKysrKysrKysrKystCiBkcml2ZXJz L2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvbW9ja19yZWdpb24uYyAgfCAgMSArCiAxNyBmaWxlcyBj aGFuZ2VkLCAxNDMgaW5zZXJ0aW9ucygrKSwgMjAgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2NyZWF0ZS5jIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2NyZWF0ZS5jCmluZGV4IDkzYmY2M2JiYWZmMS4uNTFmOTJl NGIxYTY5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fY3Jl YXRlLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2NyZWF0ZS5jCkBA IC05MCw3ICs5MCw3IEBAIGk5MTVfZ2VtX3NldHVwKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0 ICpvYmosIHU2NCBzaXplKQogCSAqLwogCWZsYWdzID0gSTkxNV9CT19BTExPQ19VU0VSOwogCi0J cmV0ID0gbXItPm9wcy0+aW5pdF9vYmplY3QobXIsIG9iaiwgc2l6ZSwgZmxhZ3MpOworCXJldCA9 IG1yLT5vcHMtPmluaXRfb2JqZWN0KG1yLCBvYmosIHNpemUsIDAsIGZsYWdzKTsKIAlpZiAocmV0 KQogCQlyZXR1cm4gcmV0OwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0v aTkxNV9nZW1fbG1lbS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2xtZW0u YwppbmRleCBkNTM5ZGZmYTE1NTQuLjE3NGE5ZTM0YWQ5MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9n cHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2xtZW0uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkx NS9nZW0vaTkxNV9nZW1fbG1lbS5jCkBAIC03MSwxMSArNzEsNDIgQEAgYm9vbCBpOTE1X2dlbV9v YmplY3RfaXNfbG1lbShzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKQogCQkgICAgICBt ci0+dHlwZSA9PSBJTlRFTF9NRU1PUllfU1RPTEVOX0xPQ0FMKTsKIH0KIAorLyoqCisgKiBfX2k5 MTVfZ2VtX29iamVjdF9jcmVhdGVfbG1lbV93aXRoX3BzIC0gQ3JlYXRlIGxtZW0gb2JqZWN0IGFu ZCBmb3JjZSB0aGUKKyAqIG1pbmltdW0gcGFnZSBzaXplIGZvciB0aGUgYmFja2luZyBwYWdlcy4K KyAqIEBpOTE1OiBUaGUgaTkxNSBpbnN0YW5jZS4KKyAqIEBzaXplOiBUaGUgc2l6ZSBpbiBieXRl cyBmb3IgdGhlIG9iamVjdC4gTm90ZSB0aGF0IHdlIG5lZWQgdG8gcm91bmQgdGhlIHNpemUKKyAq IHVwIGRlcGVuZGluZyBvbiB0aGUgQHBhZ2Vfc2l6ZS4gVGhlIGZpbmFsIG9iamVjdCBzaXplIGNh biBiZSBmaXNoZWQgb3V0IGZyb20KKyAqIHRoZSBkcm0gR0VNIG9iamVjdC4KKyAqIEBwYWdlX3Np emU6IFRoZSByZXF1ZXN0ZWQgbWluaW11bSBwYWdlIHNpemUgaW4gYnl0ZXMgZm9yIHRoaXMgb2Jq ZWN0LiBUaGUgaXMKKyAqIHVzZWZ1bCBpZiB3ZSBuZWVkIHNvbWV0aGluZyBiaWdnZXIgdGhhbiB0 aGUgcmVnaW9ucyBtaW5fcGFnZV9zaXplIGR1ZSB0byBzb21lCisgKiBodyByZXN0cmljdGlvbiwg b3IgaW4gc29tZSB2ZXJ5IHNwZWNpYWxpc2VkIGNhc2VzIHdoZXJlIGl0IG5lZWRzIHRvIGJlCisg KiBzbWFsbGVyLCB3aGVyZSB0aGUgaW50ZXJuYWwgZnJhZ21lbnRhdGlvbiBjb3N0IGlzIHRvbyBn cmVhdCB3aGVuIHJvdW5kaW5nIHVwCisgKiB0aGUgb2JqZWN0IHNpemUuCisgKiBAZmxhZ3M6IHRo ZSBvcHRpb25hbCBCTyBhbGxvY2F0aW9uIGZsYWdzCisgKgorICogTm90ZSB0aGF0IHRoaXMgaW50 ZXJmYWNlIGFzc3VtZXMgeW91IGtub3cgd2hhdCB5b3UgYXJlIGRvaW5nIHdoZW4gZm9yY2luZyB0 aGUKKyAqIHBhZ2Vfc2l6ZS4gSWYgdGhpcyBpcyBzbWFsbGVyIHRoYW4gdGhlIHJlZ2lvbnMgbWlu X3BhZ2Vfc2l6ZSB0aGVuIGl0IGNhbgorICogbmV2ZXIgYmUgaW5zZXJ0ZWQgaW50byBhbnkgR1RU LCBvdGhlcndpc2UgaXQgbWlnaHQgbGVhZCB0byB1bmRlZmluZWQKKyAqIGJlaGF2aW91ci4KKyAq CisgKiBSZXR1cm46IFRoZSBvYmplY3QgcG9pbnRlciwgd2hpY2ggbWlnaHQgYmUgYW4gRVJSX1BU UiBpbiB0aGUgY2FzZSBvZiBmYWlsdXJlLgorICovCitzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVj dCAqCitfX2k5MTVfZ2VtX29iamVjdF9jcmVhdGVfbG1lbV93aXRoX3BzKHN0cnVjdCBkcm1faTkx NV9wcml2YXRlICppOTE1LAorCQkJCSAgICAgIHJlc291cmNlX3NpemVfdCBzaXplLAorCQkJCSAg ICAgIHJlc291cmNlX3NpemVfdCBwYWdlX3NpemUsCisJCQkJICAgICAgdW5zaWduZWQgaW50IGZs YWdzKQoreworCXJldHVybiBpOTE1X2dlbV9vYmplY3RfY3JlYXRlX3JlZ2lvbihpOTE1LT5tbS5y ZWdpb25zW0lOVEVMX1JFR0lPTl9MTUVNXSwKKwkJCQkJICAgICBzaXplLCBwYWdlX3NpemUsIGZs YWdzKTsKK30KKwogc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKgogaTkxNV9nZW1fb2JqZWN0 X2NyZWF0ZV9sbWVtKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1LAogCQkJICAgIHJlc291 cmNlX3NpemVfdCBzaXplLAogCQkJICAgIHVuc2lnbmVkIGludCBmbGFncykKIHsKIAlyZXR1cm4g aTkxNV9nZW1fb2JqZWN0X2NyZWF0ZV9yZWdpb24oaTkxNS0+bW0ucmVnaW9uc1tJTlRFTF9SRUdJ T05fTE1FTV0sCi0JCQkJCSAgICAgc2l6ZSwgZmxhZ3MpOworCQkJCQkgICAgIHNpemUsIDAsIGZs YWdzKTsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9s bWVtLmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fbG1lbS5oCmluZGV4IGVh NzZmZDExY2NiMC4uZTk4NjA4Y2ViYmJjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkx NS9nZW0vaTkxNV9nZW1fbG1lbS5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1 X2dlbV9sbWVtLmgKQEAgLTIxLDYgKzIxLDExIEBAIGk5MTVfZ2VtX29iamVjdF9sbWVtX2lvX21h cChzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqLAogCiBib29sIGk5MTVfZ2VtX29iamVj dF9pc19sbWVtKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopOwogCitzdHJ1Y3QgZHJt X2k5MTVfZ2VtX29iamVjdCAqCitfX2k5MTVfZ2VtX29iamVjdF9jcmVhdGVfbG1lbV93aXRoX3Bz KHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1LAorCQkJCSAgICAgIHJlc291cmNlX3NpemVf dCBzaXplLAorCQkJCSAgICAgIHJlc291cmNlX3NpemVfdCBwYWdlX3NpemUsCisJCQkJICAgICAg dW5zaWduZWQgaW50IGZsYWdzKTsKIHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICoKIGk5MTVf Z2VtX29iamVjdF9jcmVhdGVfbG1lbShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSwKIAkJ CSAgICByZXNvdXJjZV9zaXplX3Qgc2l6ZSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2dlbS9pOTE1X2dlbV9yZWdpb24uYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1 X2dlbV9yZWdpb24uYwppbmRleCBkMWYxODQwNTQwZGQuLjYzYTZjZTZjYzVmZSAxMDA2NDQKLS0t IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3JlZ2lvbi5jCisrKyBiL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9yZWdpb24uYwpAQCAtMzYsOSArMzYsMTEgQEAg dm9pZCBpOTE1X2dlbV9vYmplY3RfcmVsZWFzZV9tZW1vcnlfcmVnaW9uKHN0cnVjdCBkcm1faTkx NV9nZW1fb2JqZWN0ICpvYmopCiBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqCiBpOTE1X2dl bV9vYmplY3RfY3JlYXRlX3JlZ2lvbihzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtLAog CQkJICAgICAgcmVzb3VyY2Vfc2l6ZV90IHNpemUsCisJCQkgICAgICByZXNvdXJjZV9zaXplX3Qg cGFnZV9zaXplLAogCQkJICAgICAgdW5zaWduZWQgaW50IGZsYWdzKQogewogCXN0cnVjdCBkcm1f aTkxNV9nZW1fb2JqZWN0ICpvYmo7CisJcmVzb3VyY2Vfc2l6ZV90IGRlZmF1bHRfcGFnZV9zaXpl OwogCWludCBlcnI7CiAKIAkvKgpAQCAtNTIsNyArNTQsMTQgQEAgaTkxNV9nZW1fb2JqZWN0X2Ny ZWF0ZV9yZWdpb24oc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwKIAlpZiAoIW1lbSkK IAkJcmV0dXJuIEVSUl9QVFIoLUVOT0RFVik7CiAKLQlzaXplID0gcm91bmRfdXAoc2l6ZSwgbWVt LT5taW5fcGFnZV9zaXplKTsKKwlkZWZhdWx0X3BhZ2Vfc2l6ZSA9IG1lbS0+bWluX3BhZ2Vfc2l6 ZTsKKwlpZiAocGFnZV9zaXplKQorCQlkZWZhdWx0X3BhZ2Vfc2l6ZSA9IHBhZ2Vfc2l6ZTsKKwor CUdFTV9CVUdfT04oIWlzX3Bvd2VyX29mXzJfdTY0KGRlZmF1bHRfcGFnZV9zaXplKSk7CisJR0VN X0JVR19PTihkZWZhdWx0X3BhZ2Vfc2l6ZSA8IFBBR0VfU0laRSk7CisKKwlzaXplID0gcm91bmRf dXAoc2l6ZSwgZGVmYXVsdF9wYWdlX3NpemUpOwogCiAJR0VNX0JVR19PTighc2l6ZSk7CiAJR0VN X0JVR19PTighSVNfQUxJR05FRChzaXplLCBJOTE1X0dUVF9NSU5fQUxJR05NRU5UKSk7CkBAIC02 NCw3ICs3Myw3IEBAIGk5MTVfZ2VtX29iamVjdF9jcmVhdGVfcmVnaW9uKHN0cnVjdCBpbnRlbF9t ZW1vcnlfcmVnaW9uICptZW0sCiAJaWYgKCFvYmopCiAJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0p OwogCi0JZXJyID0gbWVtLT5vcHMtPmluaXRfb2JqZWN0KG1lbSwgb2JqLCBzaXplLCBmbGFncyk7 CisJZXJyID0gbWVtLT5vcHMtPmluaXRfb2JqZWN0KG1lbSwgb2JqLCBzaXplLCBwYWdlX3NpemUs IGZsYWdzKTsKIAlpZiAoZXJyKQogCQlnb3RvIGVycl9vYmplY3RfZnJlZTsKIApkaWZmIC0tZ2l0 IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3JlZ2lvbi5oIGIvZHJpdmVycy9n cHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3JlZ2lvbi5oCmluZGV4IDg0ZmNiMzI5NzQwMC4uMTAw OGU1ODBhODlhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1f cmVnaW9uLmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3JlZ2lvbi5o CkBAIC0xOSw2ICsxOSw3IEBAIHZvaWQgaTkxNV9nZW1fb2JqZWN0X3JlbGVhc2VfbWVtb3J5X3Jl Z2lvbihzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqKTsKIHN0cnVjdCBkcm1faTkxNV9n ZW1fb2JqZWN0ICoKIGk5MTVfZ2VtX29iamVjdF9jcmVhdGVfcmVnaW9uKHN0cnVjdCBpbnRlbF9t ZW1vcnlfcmVnaW9uICptZW0sCiAJCQkgICAgICByZXNvdXJjZV9zaXplX3Qgc2l6ZSwKKwkJCSAg ICAgIHJlc291cmNlX3NpemVfdCBwYWdlX3NpemUsCiAJCQkgICAgICB1bnNpZ25lZCBpbnQgZmxh Z3MpOwogCiAjZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1 X2dlbV9zaG1lbS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3NobWVtLmMK aW5kZXggNWQxNmM0NDYyZmRhLi5mNTc5MTYxMWI5Y2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9zaG1lbS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2dlbS9pOTE1X2dlbV9zaG1lbS5jCkBAIC00ODksNiArNDg5LDcgQEAgc3RhdGljIGludCBfX2Ny ZWF0ZV9zaG1lbShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSwKIHN0YXRpYyBpbnQgc2ht ZW1fb2JqZWN0X2luaXQoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwKIAkJCSAgICAg c3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iaiwKIAkJCSAgICAgcmVzb3VyY2Vfc2l6ZV90 IHNpemUsCisJCQkgICAgIHJlc291cmNlX3NpemVfdCBwYWdlX3NpemUsCiAJCQkgICAgIHVuc2ln bmVkIGludCBmbGFncykKIHsKIAlzdGF0aWMgc3RydWN0IGxvY2tfY2xhc3Nfa2V5IGxvY2tfY2xh c3M7CkBAIC01NDgsNyArNTQ5LDcgQEAgaTkxNV9nZW1fb2JqZWN0X2NyZWF0ZV9zaG1lbShzdHJ1 Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSwKIAkJCSAgICAgcmVzb3VyY2Vfc2l6ZV90IHNpemUp CiB7CiAJcmV0dXJuIGk5MTVfZ2VtX29iamVjdF9jcmVhdGVfcmVnaW9uKGk5MTUtPm1tLnJlZ2lv bnNbSU5URUxfUkVHSU9OX1NNRU1dLAotCQkJCQkgICAgIHNpemUsIDApOworCQkJCQkgICAgIHNp emUsIDAsIDApOwogfQogCiAvKiBBbGxvY2F0ZSBhIG5ldyBHRU0gb2JqZWN0IGFuZCBmaWxsIGl0 IHdpdGggdGhlIHN1cHBsaWVkIGRhdGEgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2dlbS9pOTE1X2dlbV9zdG9sZW4uYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1 X2dlbV9zdG9sZW4uYwppbmRleCBiMGMzYTdkYzYwZDEuLjkwNzA4ZGUyNzY4NCAxMDA2NDQKLS0t IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3N0b2xlbi5jCisrKyBiL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9zdG9sZW4uYwpAQCAtNjcwLDYgKzY3MCw3IEBA IHN0YXRpYyBpbnQgX19pOTE1X2dlbV9vYmplY3RfY3JlYXRlX3N0b2xlbihzdHJ1Y3QgaW50ZWxf bWVtb3J5X3JlZ2lvbiAqbWVtLAogc3RhdGljIGludCBfaTkxNV9nZW1fb2JqZWN0X3N0b2xlbl9p bml0KHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0sCiAJCQkJCXN0cnVjdCBkcm1faTkx NV9nZW1fb2JqZWN0ICpvYmosCiAJCQkJCXJlc291cmNlX3NpemVfdCBzaXplLAorCQkJCQlyZXNv dXJjZV9zaXplX3QgcGFnZV9zaXplLAogCQkJCQl1bnNpZ25lZCBpbnQgZmxhZ3MpCiB7CiAJc3Ry dWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUgPSBtZW0tPmk5MTU7CkBAIC03MDgsNyArNzA5LDcg QEAgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKgogaTkxNV9nZW1fb2JqZWN0X2NyZWF0ZV9z dG9sZW4oc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUsCiAJCQkgICAgICByZXNvdXJjZV9z aXplX3Qgc2l6ZSkKIHsKLQlyZXR1cm4gaTkxNV9nZW1fb2JqZWN0X2NyZWF0ZV9yZWdpb24oaTkx NS0+bW0uc3RvbGVuX3JlZ2lvbiwgc2l6ZSwgMCk7CisJcmV0dXJuIGk5MTVfZ2VtX29iamVjdF9j cmVhdGVfcmVnaW9uKGk5MTUtPm1tLnN0b2xlbl9yZWdpb24sIHNpemUsIDAsIDApOwogfQogCiBz dGF0aWMgaW50IGluaXRfc3RvbGVuX3NtZW0oc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1l bSkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV90dG0uYyBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV90dG0uYwppbmRleCBjNWRlYjhiNzIy N2MuLjUxZjIyZjk2MDdmNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5 MTVfZ2VtX3R0bS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV90dG0u YwpAQCAtNzY1LDYgKzc2NSw3IEBAIHZvaWQgaTkxNV90dG1fYm9fZGVzdHJveShzdHJ1Y3QgdHRt X2J1ZmZlcl9vYmplY3QgKmJvKQogaW50IF9faTkxNV9nZW1fdHRtX29iamVjdF9pbml0KHN0cnVj dCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0sCiAJCQkgICAgICAgc3RydWN0IGRybV9pOTE1X2dl bV9vYmplY3QgKm9iaiwKIAkJCSAgICAgICByZXNvdXJjZV9zaXplX3Qgc2l6ZSwKKwkJCSAgICAg ICByZXNvdXJjZV9zaXplX3QgcGFnZV9zaXplLAogCQkJICAgICAgIHVuc2lnbmVkIGludCBmbGFn cykKIHsKIAlzdGF0aWMgc3RydWN0IGxvY2tfY2xhc3Nfa2V5IGxvY2tfY2xhc3M7CkBAIC03ODMs NiArNzg0LDkgQEAgaW50IF9faTkxNV9nZW1fdHRtX29iamVjdF9pbml0KHN0cnVjdCBpbnRlbF9t ZW1vcnlfcmVnaW9uICptZW0sCiAJYm9fdHlwZSA9IChvYmotPmZsYWdzICYgSTkxNV9CT19BTExP Q19VU0VSKSA/IHR0bV9ib190eXBlX2RldmljZSA6CiAJCXR0bV9ib190eXBlX2tlcm5lbDsKIAor CS8qIEZvcmNpbmcgdGhlIHBhZ2Ugc2l6ZSBpcyBrZXJuZWwgaW50ZXJuYWwgb25seSAqLworCUdF TV9CVUdfT04ocGFnZV9zaXplICYmIG9iai0+bW0ubl9wbGFjZW1lbnRzKTsKKwogCS8qCiAJICog SWYgdGhpcyBmdW5jdGlvbiBmYWlscywgaXQgd2lsbCBjYWxsIHRoZSBkZXN0cnVjdG9yLCBidXQK IAkgKiBvdXIgY2FsbGVyIHN0aWxsIG93bnMgdGhlIG9iamVjdC4gU28gbm8gZnJlZWluZyBpbiB0 aGUKQEAgLTc5Myw3ICs3OTcsNyBAQCBpbnQgX19pOTE1X2dlbV90dG1fb2JqZWN0X2luaXQoc3Ry dWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwKIAlvYmotPmJhc2Uudm1hX25vZGUuZHJpdmVy X3ByaXZhdGUgPSBpOTE1X2dlbV90b190dG0ob2JqKTsKIAlyZXQgPSB0dG1fYm9faW5pdCgmaTkx NS0+YmRldiwgaTkxNV9nZW1fdG9fdHRtKG9iaiksIHNpemUsCiAJCQkgIGJvX3R5cGUsICZpOTE1 X3N5c19wbGFjZW1lbnQsCi0JCQkgIG1lbS0+bWluX3BhZ2Vfc2l6ZSA+PiBQQUdFX1NISUZULAor CQkJICBwYWdlX3NpemUgPj4gUEFHRV9TSElGVCwKIAkJCSAgdHJ1ZSwgTlVMTCwgTlVMTCwgaTkx NV90dG1fYm9fZGVzdHJveSk7CiAJaWYgKCFyZXQpCiAJCW9iai0+dHRtLmNyZWF0ZWQgPSB0cnVl OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5oIGIv ZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5oCmluZGV4IGI4ZDNkY2JiNTBk Zi4uNDA5MjdmNjdiNmQ5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkx NV9nZW1fdHRtLmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX3R0bS5o CkBAIC00NCw1ICs0NCw2IEBAIGk5MTVfdHRtX3RvX2dlbShzdHJ1Y3QgdHRtX2J1ZmZlcl9vYmpl Y3QgKmJvKQogaW50IF9faTkxNV9nZW1fdHRtX29iamVjdF9pbml0KHN0cnVjdCBpbnRlbF9tZW1v cnlfcmVnaW9uICptZW0sCiAJCQkgICAgICAgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9i aiwKIAkJCSAgICAgICByZXNvdXJjZV9zaXplX3Qgc2l6ZSwKKwkJCSAgICAgICByZXNvdXJjZV9z aXplX3QgcGFnZV9zaXplLAogCQkJICAgICAgIHVuc2lnbmVkIGludCBmbGFncyk7CiAjZW5kaWYK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9zZWxmdGVzdHMvaHVnZV9wYWdl cy5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL3NlbGZ0ZXN0cy9odWdlX3BhZ2VzLmMKaW5k ZXggZGFkZDQ4NWJjNTJmLi45ZDE3YmZmOGIzNmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2dlbS9zZWxmdGVzdHMvaHVnZV9wYWdlcy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2dlbS9zZWxmdGVzdHMvaHVnZV9wYWdlcy5jCkBAIC00OTcsNyArNDk3LDggQEAgc3RhdGlj IGludCBpZ3RfbW9ja19tZW1vcnlfcmVnaW9uX2h1Z2VfcGFnZXModm9pZCAqYXJnKQogCQlpbnQg aTsKIAogCQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShmbGFncyk7ICsraSkgewotCQkJb2Jq ID0gaTkxNV9nZW1fb2JqZWN0X2NyZWF0ZV9yZWdpb24obWVtLCBwYWdlX3NpemUsCisJCQlvYmog PSBpOTE1X2dlbV9vYmplY3RfY3JlYXRlX3JlZ2lvbihtZW0sCisJCQkJCQkJICAgIHBhZ2Vfc2l6 ZSwgcGFnZV9zaXplLAogCQkJCQkJCSAgICBmbGFnc1tpXSk7CiAJCQlpZiAoSVNfRVJSKG9iaikp IHsKIAkJCQllcnIgPSBQVFJfRVJSKG9iaik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v aTkxNS9nZW0vc2VsZnRlc3RzL2k5MTVfZ2VtX21tYW4uYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2dlbS9zZWxmdGVzdHMvaTkxNV9nZW1fbW1hbi5jCmluZGV4IDQ0YjVkZTA2Y2U2NC4uNzM5OGI1 MDI3MzhhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vc2VsZnRlc3RzL2k5 MTVfZ2VtX21tYW4uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vc2VsZnRlc3RzL2k5 MTVfZ2VtX21tYW4uYwpAQCAtOTU1LDcgKzk1NSw3IEBAIHN0YXRpYyBpbnQgaWd0X21tYXAodm9p ZCAqYXJnKQogCQkJc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iajsKIAkJCWludCBlcnI7 CiAKLQkJCW9iaiA9IGk5MTVfZ2VtX29iamVjdF9jcmVhdGVfcmVnaW9uKG1yLCBzaXplc1tpXSwg STkxNV9CT19BTExPQ19VU0VSKTsKKwkJCW9iaiA9IGk5MTVfZ2VtX29iamVjdF9jcmVhdGVfcmVn aW9uKG1yLCBzaXplc1tpXSwgMCwgSTkxNV9CT19BTExPQ19VU0VSKTsKIAkJCWlmIChvYmogPT0g RVJSX1BUUigtRU5PREVWKSkKIAkJCQljb250aW51ZTsKIApAQCAtMTA3NSw3ICsxMDc1LDcgQEAg c3RhdGljIGludCBpZ3RfbW1hcF9hY2Nlc3Modm9pZCAqYXJnKQogCQlzdHJ1Y3QgZHJtX2k5MTVf Z2VtX29iamVjdCAqb2JqOwogCQlpbnQgZXJyOwogCi0JCW9iaiA9IGk5MTVfZ2VtX29iamVjdF9j cmVhdGVfcmVnaW9uKG1yLCBQQUdFX1NJWkUsIEk5MTVfQk9fQUxMT0NfVVNFUik7CisJCW9iaiA9 IGk5MTVfZ2VtX29iamVjdF9jcmVhdGVfcmVnaW9uKG1yLCBQQUdFX1NJWkUsIDAsIEk5MTVfQk9f QUxMT0NfVVNFUik7CiAJCWlmIChvYmogPT0gRVJSX1BUUigtRU5PREVWKSkKIAkJCWNvbnRpbnVl OwogCkBAIC0xMjIwLDcgKzEyMjAsNyBAQCBzdGF0aWMgaW50IGlndF9tbWFwX2dwdSh2b2lkICph cmcpCiAJCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmo7CiAJCWludCBlcnI7CiAKLQkJ b2JqID0gaTkxNV9nZW1fb2JqZWN0X2NyZWF0ZV9yZWdpb24obXIsIFBBR0VfU0laRSwgSTkxNV9C T19BTExPQ19VU0VSKTsKKwkJb2JqID0gaTkxNV9nZW1fb2JqZWN0X2NyZWF0ZV9yZWdpb24obXIs IFBBR0VfU0laRSwgMCwgSTkxNV9CT19BTExPQ19VU0VSKTsKIAkJaWYgKG9iaiA9PSBFUlJfUFRS KC1FTk9ERVYpKQogCQkJY29udGludWU7CiAKQEAgLTEzNzUsNyArMTM3NSw3IEBAIHN0YXRpYyBp bnQgaWd0X21tYXBfcmV2b2tlKHZvaWQgKmFyZykKIAkJc3RydWN0IGRybV9pOTE1X2dlbV9vYmpl Y3QgKm9iajsKIAkJaW50IGVycjsKIAotCQlvYmogPSBpOTE1X2dlbV9vYmplY3RfY3JlYXRlX3Jl Z2lvbihtciwgUEFHRV9TSVpFLCBJOTE1X0JPX0FMTE9DX1VTRVIpOworCQlvYmogPSBpOTE1X2dl bV9vYmplY3RfY3JlYXRlX3JlZ2lvbihtciwgUEFHRV9TSVpFLCAwLCBJOTE1X0JPX0FMTE9DX1VT RVIpOwogCQlpZiAob2JqID09IEVSUl9QVFIoLUVOT0RFVikpCiAJCQljb250aW51ZTsKIApkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV90dG1fYnVkZHlfbWFuYWdlci5jIGIv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV90dG1fYnVkZHlfbWFuYWdlci5jCmluZGV4IGZjN2Fk NWMwMzViOC4uMmMxNDMwMzRjYmQ5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9p OTE1X3R0bV9idWRkeV9tYW5hZ2VyLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV90 dG1fYnVkZHlfbWFuYWdlci5jCkBAIC0xOCw2ICsxOCw3IEBAIHN0cnVjdCBpOTE1X3R0bV9idWRk eV9tYW5hZ2VyIHsKIAlzdHJ1Y3QgaTkxNV9idWRkeV9tbSBtbTsKIAlzdHJ1Y3QgbGlzdF9oZWFk IHJlc2VydmVkOwogCXN0cnVjdCBtdXRleCBsb2NrOworCXU2NCBkZWZhdWx0X3BhZ2Vfc2l6ZTsK IH07CiAKIHN0YXRpYyBzdHJ1Y3QgaTkxNV90dG1fYnVkZHlfbWFuYWdlciAqCkBAIC01Myw3ICs1 NCwxMCBAQCBzdGF0aWMgaW50IGk5MTVfdHRtX2J1ZGR5X21hbl9hbGxvYyhzdHJ1Y3QgdHRtX3Jl c291cmNlX21hbmFnZXIgKm1hbiwKIAlHRU1fQlVHX09OKCFibWFuX3Jlcy0+YmFzZS5udW1fcGFn ZXMpOwogCXNpemUgPSBibWFuX3Jlcy0+YmFzZS5udW1fcGFnZXMgPDwgUEFHRV9TSElGVDsKIAot CW1pbl9wYWdlX3NpemUgPSBiby0+cGFnZV9hbGlnbm1lbnQgPDwgUEFHRV9TSElGVDsKKwltaW5f cGFnZV9zaXplID0gYm1hbi0+ZGVmYXVsdF9wYWdlX3NpemU7CisJaWYgKGJvLT5wYWdlX2FsaWdu bWVudCkKKwkJbWluX3BhZ2Vfc2l6ZSA9IGJvLT5wYWdlX2FsaWdubWVudCA8PCBQQUdFX1NISUZU OworCiAJR0VNX0JVR19PTihtaW5fcGFnZV9zaXplIDwgbW0tPmNodW5rX3NpemUpOwogCW1pbl9v cmRlciA9IGlsb2cyKG1pbl9wYWdlX3NpemUpIC0gaWxvZzIobW0tPmNodW5rX3NpemUpOwogCWlm IChwbGFjZS0+ZmxhZ3MgJiBUVE1fUExfRkxBR19DT05USUdVT1VTKSB7CkBAIC0xMzQsNiArMTM4 LDkgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCB0dG1fcmVzb3VyY2VfbWFuYWdlcl9mdW5jIGk5MTVf dHRtX2J1ZGR5X21hbmFnZXJfZnVuYyA9IHsKICAqIEB0eXBlOiBNZW1vcnkgdHlwZSB3ZSB3YW50 IHRvIG1hbmFnZQogICogQHVzZV90dDogU2V0IHVzZV90dCBmb3IgdGhlIG1hbmFnZXIKICAqIEBz aXplOiBUaGUgc2l6ZSBpbiBieXRlcyB0byBtYW5hZ2UKKyAqIEBkZWZhdWx0X3BhZ2Vfc2l6ZTog VGhlIGRlZmF1bHQgbWluaW11bSBwYWdlIHNpemUgaW4gYnl0ZXMgZm9yIGFsbG9jYXRpb25zLAor ICogdGhpcyBtdXN0IGJlIGF0IGxlYXN0IGFzIGxhcmdlIGFzIEBjaHVua19zaXplLCBhbmQgY2Fu IGJlIG92ZXJyaWRlbiBieQorICogc2V0dGluZyB0aGUgQk8gcGFnZV9hbGlnbm1lbnQsIHRvIGJl IGxhcmdlciBvciBzbWFsbGVyIGFzIG5lZWRlZC4KICAqIEBjaHVua19zaXplOiBUaGUgbWluaW11 bSBwYWdlIHNpemUgaW4gYnl0ZXMgZm9yIG91ciBhbGxvY2F0aW9ucyBpLmUKICAqIG9yZGVyLXpl cm8KICAqCkBAIC0xNTQsNyArMTYxLDggQEAgc3RhdGljIGNvbnN0IHN0cnVjdCB0dG1fcmVzb3Vy Y2VfbWFuYWdlcl9mdW5jIGk5MTVfdHRtX2J1ZGR5X21hbmFnZXJfZnVuYyA9IHsKICAqLwogaW50 IGk5MTVfdHRtX2J1ZGR5X21hbl9pbml0KHN0cnVjdCB0dG1fZGV2aWNlICpiZGV2LAogCQkJICAg IHVuc2lnbmVkIGludCB0eXBlLCBib29sIHVzZV90dCwKLQkJCSAgICB1NjQgc2l6ZSwgdTY0IGNo dW5rX3NpemUpCisJCQkgICAgdTY0IHNpemUsIHU2NCBkZWZhdWx0X3BhZ2Vfc2l6ZSwKKwkJCSAg ICB1NjQgY2h1bmtfc2l6ZSkKIHsKIAlzdHJ1Y3QgdHRtX3Jlc291cmNlX21hbmFnZXIgKm1hbjsK IAlzdHJ1Y3QgaTkxNV90dG1fYnVkZHlfbWFuYWdlciAqYm1hbjsKQEAgLTE3MCw2ICsxNzgsOCBA QCBpbnQgaTkxNV90dG1fYnVkZHlfbWFuX2luaXQoc3RydWN0IHR0bV9kZXZpY2UgKmJkZXYsCiAK IAltdXRleF9pbml0KCZibWFuLT5sb2NrKTsKIAlJTklUX0xJU1RfSEVBRCgmYm1hbi0+cmVzZXJ2 ZWQpOworCUdFTV9CVUdfT04oZGVmYXVsdF9wYWdlX3NpemUgPCBjaHVua19zaXplKTsKKwlibWFu LT5kZWZhdWx0X3BhZ2Vfc2l6ZSA9IGRlZmF1bHRfcGFnZV9zaXplOwogCiAJbWFuID0gJmJtYW4t Pm1hbmFnZXI7CiAJbWFuLT51c2VfdHQgPSB1c2VfdHQ7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0vaTkxNS9pOTE1X3R0bV9idWRkeV9tYW5hZ2VyLmggYi9kcml2ZXJzL2dwdS9kcm0vaTkx NS9pOTE1X3R0bV9idWRkeV9tYW5hZ2VyLmgKaW5kZXggMjYwMjYyMTNlMjBhLi4wNzIyZDMzZjNl MTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfdHRtX2J1ZGR5X21hbmFn ZXIuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3R0bV9idWRkeV9tYW5hZ2VyLmgK QEAgLTQ2LDcgKzQ2LDcgQEAgdG9fdHRtX2J1ZGR5X3Jlc291cmNlKHN0cnVjdCB0dG1fcmVzb3Vy Y2UgKnJlcykKIAogaW50IGk5MTVfdHRtX2J1ZGR5X21hbl9pbml0KHN0cnVjdCB0dG1fZGV2aWNl ICpiZGV2LAogCQkJICAgIHVuc2lnbmVkIHR5cGUsIGJvb2wgdXNlX3R0LAotCQkJICAgIHU2NCBz aXplLCB1NjQgY2h1bmtfc2l6ZSk7CisJCQkgICAgdTY0IHNpemUsIHU2NCBkZWZhdWx0X3BhZ2Vf c2l6ZSwgdTY0IGNodW5rX3NpemUpOwogaW50IGk5MTVfdHRtX2J1ZGR5X21hbl9maW5pKHN0cnVj dCB0dG1fZGV2aWNlICpiZGV2LAogCQkJICAgIHVuc2lnbmVkIGludCB0eXBlKTsKIApkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfbWVtb3J5X3JlZ2lvbi5oIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvaW50ZWxfbWVtb3J5X3JlZ2lvbi5oCmluZGV4IDJiZTg0MzNkMzczYS4u MzU5Y2Q4NDI0YjlhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9tZW1v cnlfcmVnaW9uLmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfbWVtb3J5X3JlZ2lv bi5oCkBAIC01NSw2ICs1NSw3IEBAIHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uX29wcyB7CiAJ aW50ICgqaW5pdF9vYmplY3QpKHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0sCiAJCQkg ICBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqLAogCQkJICAgcmVzb3VyY2Vfc2l6ZV90 IHNpemUsCisJCQkgICByZXNvdXJjZV9zaXplX3QgcGFnZV9zaXplLAogCQkJICAgdW5zaWduZWQg aW50IGZsYWdzKTsKIH07CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVs X3JlZ2lvbl90dG0uYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3JlZ2lvbl90dG0uYwpp bmRleCA0Y2QxMGYzNjRlODQuLjk4YzczMzliZjhiYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaW50ZWxfcmVnaW9uX3R0bS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2lu dGVsX3JlZ2lvbl90dG0uYwpAQCAtODYsNyArODYsOCBAQCBpbnQgaW50ZWxfcmVnaW9uX3R0bV9p bml0KHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVnaW9uICptZW0pCiAJaW50IHJldDsKIAogCXJldCA9 IGk5MTVfdHRtX2J1ZGR5X21hbl9pbml0KGJkZXYsIG1lbV90eXBlLCBmYWxzZSwKLQkJCQkgICAg ICByZXNvdXJjZV9zaXplKCZtZW0tPnJlZ2lvbiksIFBBR0VfU0laRSk7CisJCQkJICAgICAgcmVz b3VyY2Vfc2l6ZSgmbWVtLT5yZWdpb24pLAorCQkJCSAgICAgIG1lbS0+bWluX3BhZ2Vfc2l6ZSwg UEFHRV9TSVpFKTsKIAlpZiAocmV0KQogCQlyZXR1cm4gcmV0OwogCkBAIC0xNjcsNyArMTY4LDYg QEAgaW50ZWxfcmVnaW9uX3R0bV9yZXNvdXJjZV9hbGxvYyhzdHJ1Y3QgaW50ZWxfbWVtb3J5X3Jl Z2lvbiAqbWVtLAogCWludCByZXQ7CiAKIAltb2NrX2JvLmJhc2Uuc2l6ZSA9IHNpemU7Ci0JbW9j a19iby5wYWdlX2FsaWdubWVudCA9IG1lbS0+bWluX3BhZ2Vfc2l6ZSA+PiBQQUdFX1NISUZUOwog CXBsYWNlLmZsYWdzID0gZmxhZ3M7CiAKIAlyZXQgPSBtYW4tPmZ1bmMtPmFsbG9jKG1hbiwgJm1v Y2tfYm8sICZwbGFjZSwgJnJlcyk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9z ZWxmdGVzdHMvaW50ZWxfbWVtb3J5X3JlZ2lvbi5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvc2Vs ZnRlc3RzL2ludGVsX21lbW9yeV9yZWdpb24uYwppbmRleCBlY2MzYjllNmMyMmIuLjFhYWNjYjk4 NDFhMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvc2VsZnRlc3RzL2ludGVsX21l bW9yeV9yZWdpb24uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvaW50ZWxf bWVtb3J5X3JlZ2lvbi5jCkBAIC02OCw3ICs2OCw3IEBAIHN0YXRpYyBpbnQgaWd0X21vY2tfZmls bCh2b2lkICphcmcpCiAJCXJlc291cmNlX3NpemVfdCBzaXplID0gcGFnZV9udW0gKiBwYWdlX3Np emU7CiAJCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmo7CiAKLQkJb2JqID0gaTkxNV9n ZW1fb2JqZWN0X2NyZWF0ZV9yZWdpb24obWVtLCBzaXplLCAwKTsKKwkJb2JqID0gaTkxNV9nZW1f b2JqZWN0X2NyZWF0ZV9yZWdpb24obWVtLCBzaXplLCAwLCAwKTsKIAkJaWYgKElTX0VSUihvYmop KSB7CiAJCQllcnIgPSBQVFJfRVJSKG9iaik7CiAJCQlicmVhazsKQEAgLTExMCw3ICsxMTAsNyBA QCBpZ3Rfb2JqZWN0X2NyZWF0ZShzdHJ1Y3QgaW50ZWxfbWVtb3J5X3JlZ2lvbiAqbWVtLAogCXN0 cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmo7CiAJaW50IGVycjsKIAotCW9iaiA9IGk5MTVf Z2VtX29iamVjdF9jcmVhdGVfcmVnaW9uKG1lbSwgc2l6ZSwgZmxhZ3MpOworCW9iaiA9IGk5MTVf Z2VtX29iamVjdF9jcmVhdGVfcmVnaW9uKG1lbSwgc2l6ZSwgMCwgZmxhZ3MpOwogCWlmIChJU19F UlIob2JqKSkKIAkJcmV0dXJuIG9iajsKIApAQCAtNjQ3LDYgKzY0Nyw2MiBAQCBzdGF0aWMgaW50 IGlndF9sbWVtX2NyZWF0ZSh2b2lkICphcmcpCiAJcmV0dXJuIGVycjsKIH0KIAorc3RhdGljIGlu dCBpZ3RfbG1lbV9jcmVhdGVfd2l0aF9wcyh2b2lkICphcmcpCit7CisJc3RydWN0IGRybV9pOTE1 X3ByaXZhdGUgKmk5MTUgPSBhcmc7CisJaW50IGVyciA9IDA7CisJdTMyIHBzOworCisJZm9yIChw cyA9IFBBR0VfU0laRTsgcHMgPD0gU1pfMUc7IHBzIDw8PSAxKSB7CisJCXN0cnVjdCBkcm1faTkx NV9nZW1fb2JqZWN0ICpvYmo7CisJCWRtYV9hZGRyX3QgZGFkZHI7CisKKwkJb2JqID0gX19pOTE1 X2dlbV9vYmplY3RfY3JlYXRlX2xtZW1fd2l0aF9wcyhpOTE1LCBwcywgcHMsIDApOworCQlpZiAo SVNfRVJSKG9iaikpIHsKKwkJCWVyciA9IFBUUl9FUlIob2JqKTsKKwkJCWlmIChlcnIgPT0gLUVO WElPIHx8IGVyciA9PSAtRTJCSUcpIHsKKwkJCQlwcl9pbmZvKCIlcyBub3QgZW5vdWdoIGxtZW0g Zm9yIHBzKCV1KSBlcnI9JWRcbiIsCisJCQkJCV9fZnVuY19fLCBwcywgZXJyKTsKKwkJCQllcnIg PSAwOworCQkJfQorCisJCQlicmVhazsKKwkJfQorCisJCWlmIChvYmotPmJhc2Uuc2l6ZSAhPSBw cykgeworCQkJcHJfZXJyKCIlcyBzaXplKCV6dSkgIT0gcHMoJXUpXG4iLAorCQkJICAgICAgIF9f ZnVuY19fLCBvYmotPmJhc2Uuc2l6ZSwgcHMpOworCQkJZXJyID0gLUVJTlZBTDsKKwkJCWdvdG8g b3V0X3B1dDsKKwkJfQorCisJCWk5MTVfZ2VtX29iamVjdF9sb2NrKG9iaiwgTlVMTCk7CisJCWVy ciA9IGk5MTVfZ2VtX29iamVjdF9waW5fcGFnZXMob2JqKTsKKwkJaWYgKGVycikKKwkJCWdvdG8g b3V0X3B1dDsKKworCQlkYWRkciA9IGk5MTVfZ2VtX29iamVjdF9nZXRfZG1hX2FkZHJlc3Mob2Jq LCAwKTsKKwkJaWYgKCFJU19BTElHTkVEKGRhZGRyLCBwcykpIHsKKwkJCXByX2VycigiJXMgZGFk ZHIoJXBhKSBub3QgYWxpZ25lZCB3aXRoIHBzKCV1KVxuIiwKKwkJCSAgICAgICBfX2Z1bmNfXywg JmRhZGRyLCBwcyk7CisJCQllcnIgPSAtRUlOVkFMOworCQkJZ290byBvdXRfdW5waW47CisJCX0K Kworb3V0X3VucGluOgorCQlpOTE1X2dlbV9vYmplY3RfdW5waW5fcGFnZXMob2JqKTsKKwkJX19p OTE1X2dlbV9vYmplY3RfcHV0X3BhZ2VzKG9iaik7CitvdXRfcHV0OgorCQlpOTE1X2dlbV9vYmpl Y3RfdW5sb2NrKG9iaik7CisJCWk5MTVfZ2VtX29iamVjdF9wdXQob2JqKTsKKworCQlpZiAoZXJy KQorCQkJYnJlYWs7CisJfQorCisJcmV0dXJuIGVycjsKK30KKwogc3RhdGljIGludCBpZ3RfbG1l bV9jcmVhdGVfY2xlYXJlZF9jcHUodm9pZCAqYXJnKQogewogCXN0cnVjdCBkcm1faTkxNV9wcml2 YXRlICppOTE1ID0gYXJnOwpAQCAtOTMyLDcgKzk4OCw3IEBAIGNyZWF0ZV9yZWdpb25fZm9yX21h cHBpbmcoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1yLCB1NjQgc2l6ZSwgdTMyIHR5cGUs CiAJc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iajsKIAl2b2lkICphZGRyOwogCi0Jb2Jq ID0gaTkxNV9nZW1fb2JqZWN0X2NyZWF0ZV9yZWdpb24obXIsIHNpemUsIDApOworCW9iaiA9IGk5 MTVfZ2VtX29iamVjdF9jcmVhdGVfcmVnaW9uKG1yLCBzaXplLCAwLCAwKTsKIAlpZiAoSVNfRVJS KG9iaikpIHsKIAkJaWYgKFBUUl9FUlIob2JqKSA9PSAtRU5PU1BDKSAvKiBTdG9sZW4gbWVtb3J5 ICovCiAJCQlyZXR1cm4gRVJSX1BUUigtRU5PREVWKTsKQEAgLTExNDksNiArMTIwNSw3IEBAIGlu dCBpbnRlbF9tZW1vcnlfcmVnaW9uX2xpdmVfc2VsZnRlc3RzKHN0cnVjdCBkcm1faTkxNV9wcml2 YXRlICppOTE1KQogewogCXN0YXRpYyBjb25zdCBzdHJ1Y3QgaTkxNV9zdWJ0ZXN0IHRlc3RzW10g PSB7CiAJCVNVQlRFU1QoaWd0X2xtZW1fY3JlYXRlKSwKKwkJU1VCVEVTVChpZ3RfbG1lbV9jcmVh dGVfd2l0aF9wcyksCiAJCVNVQlRFU1QoaWd0X2xtZW1fY3JlYXRlX2NsZWFyZWRfY3B1KSwKIAkJ U1VCVEVTVChpZ3RfbG1lbV93cml0ZV9jcHUpLAogCQlTVUJURVNUKGlndF9sbWVtX3dyaXRlX2dw dSksCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvbW9ja19yZWdp b24uYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9tb2NrX3JlZ2lvbi5jCmluZGV4 IGZhNzg2ZGVkZTYwOC4uZWZhODZkZmZlM2M2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0v aTkxNS9zZWxmdGVzdHMvbW9ja19yZWdpb24uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9z ZWxmdGVzdHMvbW9ja19yZWdpb24uYwpAQCAtNjMsNiArNjMsNyBAQCBzdGF0aWMgY29uc3Qgc3Ry dWN0IGRybV9pOTE1X2dlbV9vYmplY3Rfb3BzIG1vY2tfcmVnaW9uX29ial9vcHMgPSB7CiBzdGF0 aWMgaW50IG1vY2tfb2JqZWN0X2luaXQoc3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKm1lbSwK IAkJCSAgICBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqLAogCQkJICAgIHJlc291cmNl X3NpemVfdCBzaXplLAorCQkJICAgIHJlc291cmNlX3NpemVfdCBwYWdlX3NpemUsCiAJCQkgICAg dW5zaWduZWQgaW50IGZsYWdzKQogewogCXN0YXRpYyBzdHJ1Y3QgbG9ja19jbGFzc19rZXkgbG9j a19jbGFzczsKLS0gCjIuMjYuMwoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJlZWRl c2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8v aW50ZWwtZ2Z4Cg==