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=-12.8 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 8552CC433E6 for ; Tue, 1 Sep 2020 08:33:52 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 5622A2071B for ; Tue, 1 Sep 2020 08:33:52 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=citrix.com header.i=@citrix.com header.b="Dca6lZ7e" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726543AbgIAIdv (ORCPT ); Tue, 1 Sep 2020 04:33:51 -0400 Received: from esa6.hc3370-68.iphmx.com ([216.71.155.175]:20476 "EHLO esa6.hc3370-68.iphmx.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726226AbgIAIdp (ORCPT ); Tue, 1 Sep 2020 04:33:45 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=citrix.com; s=securemail; t=1598949224; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=QzGqPaRCnZVxjqPpl6AF6iSX77/n0WkY1Cja56OEeNs=; b=Dca6lZ7e3ndoI8r6/qryN+E4h1kTIsgvEFK7IBkFa3P47phJ6r10vKr0 +z6LizmjeHbvQKJBMmGYi6qW+OG55AK9qnmYp25A7Y8XacbtHeueYZCpN J9VNE/xlOsBreZ4Z5kuJO9XktJ6+MrQBHFvq4Wpt7wp+LL64hTW3naVXh A=; Authentication-Results: esa6.hc3370-68.iphmx.com; dkim=none (message not signed) header.i=none IronPort-SDR: P0Ki/2b6mGa7pA1kqv/yHJEYGZ0xQ5RKAnnYciHHQu9+ozbehl7aTLhqS7TsmIqN1+lFdBA2a9 YM8aY9TgwPAc3ZTssNFiElD1kH3pZNZrmb9idWz2MNankSE+bm4Wh4gAgP/HZ0wtix/XOEQxz2 fahYv9vYNdm2yXqMi4Lx8AYZKjX0g3Wz6gC3nv5LsslNCzlzeU2Yxw6gdSPgs+07all1BEuJWf xBsiJhhiZ56EmPvlzqDlvphkbjyBG8gF8aXF6k+tJiRMgpJUdust+wSQCx3dbmJ4nY0YdY+Au0 418= X-SBRS: 2.7 X-MesageID: 26017058 X-Ironport-Server: esa6.hc3370-68.iphmx.com X-Remote-IP: 162.221.158.21 X-Policy: $RELAYED X-IronPort-AV: E=Sophos;i="5.76,378,1592884800"; d="scan'208";a="26017058" From: Roger Pau Monne To: CC: Roger Pau Monne , Oleksandr Andrushchenko , David Airlie , "Daniel Vetter" , Boris Ostrovsky , Juergen Gross , Stefano Stabellini , Dan Carpenter , Wei Liu , "Yan Yankovskyi" , , , , David Hildenbrand , Michal Hocko , Dan Williams Subject: [PATCH v5 3/3] xen: add helpers to allocate unpopulated memory Date: Tue, 1 Sep 2020 10:33:26 +0200 Message-ID: <20200901083326.21264-4-roger.pau@citrix.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20200901083326.21264-1-roger.pau@citrix.com> References: <20200901083326.21264-1-roger.pau@citrix.com> MIME-Version: 1.0 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org To be used in order to create foreign mappings. This is based on the ZONE_DEVICE facility which is used by persistent memory devices in order to create struct pages and kernel virtual mappings for the IOMEM areas of such devices. Note that on kernels without support for ZONE_DEVICE Xen will fallback to use ballooned pages in order to create foreign mappings. The newly added helpers use the same parameters as the existing {alloc/free}_xenballooned_pages functions, which allows for in-place replacement of the callers. Once a memory region has been added to be used as scratch mapping space it will no longer be released, and pages returned are kept in a linked list. This allows to have a buffer of pages and prevents resorting to frequent additions and removals of regions. If enabled (because ZONE_DEVICE is supported) the usage of the new functionality untangles Xen balloon and RAM hotplug from the usage of unpopulated physical memory ranges to map foreign pages, which is the correct thing to do in order to avoid mappings of foreign pages depend on memory hotplug. Note the driver is currently not enabled on Arm platforms because it would interfere with the identity mapping required on some platforms. Signed-off-by: Roger Pau Monné --- Cc: Oleksandr Andrushchenko Cc: David Airlie Cc: Daniel Vetter Cc: Boris Ostrovsky Cc: Juergen Gross Cc: Stefano Stabellini Cc: Dan Carpenter Cc: Roger Pau Monne Cc: Wei Liu Cc: Yan Yankovskyi Cc: dri-devel@lists.freedesktop.org Cc: xen-devel@lists.xenproject.org Cc: linux-mm@kvack.org Cc: David Hildenbrand Cc: Michal Hocko Cc: Dan Williams --- Changes since v4: - Introduce a description for the option. - Force selection of ZONE_DEVICE on X86 and select XEN_UNPOPULATED_ALLOC if running on dom0 mode or having any backends. Changes since v3: - Introduce a Kconfig option that gates the addition of the unpopulated alloc driver. This allows to easily disable it on Arm platforms. - Dropped Juergen RB due to the addition of the Kconfig option. - Switched from MEMORY_DEVICE_DEVDAX to MEMORY_DEVICE_GENERIC. Changes since v2: - Drop BUILD_BUG_ON regarding PVMMU page sizes. - Use a SPDX license identifier. - Call fill with only the minimum required number of pages. - Include xen.h header in xen_drm_front_gem.c. - Use less generic function names. - Exit early from the init function if not a PV guest. - Don't use all caps for region name. --- drivers/gpu/drm/xen/xen_drm_front_gem.c | 9 +- drivers/xen/Kconfig | 11 ++ drivers/xen/Makefile | 1 + drivers/xen/balloon.c | 4 +- drivers/xen/grant-table.c | 4 +- drivers/xen/privcmd.c | 4 +- drivers/xen/unpopulated-alloc.c | 185 ++++++++++++++++++++++++ drivers/xen/xenbus/xenbus_client.c | 6 +- drivers/xen/xlate_mmu.c | 4 +- include/xen/xen.h | 9 ++ 10 files changed, 222 insertions(+), 15 deletions(-) create mode 100644 drivers/xen/unpopulated-alloc.c diff --git a/drivers/gpu/drm/xen/xen_drm_front_gem.c b/drivers/gpu/drm/xen/xen_drm_front_gem.c index 39ff95b75357..534daf37c97e 100644 --- a/drivers/gpu/drm/xen/xen_drm_front_gem.c +++ b/drivers/gpu/drm/xen/xen_drm_front_gem.c @@ -18,6 +18,7 @@ #include #include +#include #include "xen_drm_front.h" #include "xen_drm_front_gem.h" @@ -99,8 +100,8 @@ static struct xen_gem_object *gem_create(struct drm_device *dev, size_t size) * allocate ballooned pages which will be used to map * grant references provided by the backend */ - ret = alloc_xenballooned_pages(xen_obj->num_pages, - xen_obj->pages); + ret = xen_alloc_unpopulated_pages(xen_obj->num_pages, + xen_obj->pages); if (ret < 0) { DRM_ERROR("Cannot allocate %zu ballooned pages: %d\n", xen_obj->num_pages, ret); @@ -152,8 +153,8 @@ void xen_drm_front_gem_free_object_unlocked(struct drm_gem_object *gem_obj) } else { if (xen_obj->pages) { if (xen_obj->be_alloc) { - free_xenballooned_pages(xen_obj->num_pages, - xen_obj->pages); + xen_free_unpopulated_pages(xen_obj->num_pages, + xen_obj->pages); gem_free_pages_array(xen_obj); } else { drm_gem_put_pages(&xen_obj->base, diff --git a/drivers/xen/Kconfig b/drivers/xen/Kconfig index ea6c1e7e3e42..e38c33558d0d 100644 --- a/drivers/xen/Kconfig +++ b/drivers/xen/Kconfig @@ -325,4 +325,15 @@ config XEN_HAVE_VPMU config XEN_FRONT_PGDIR_SHBUF tristate +config XEN_UNPOPULATED_ALLOC + bool "Use unpopulated memory ranges for guest mappings" + depends on X86 + select ZONE_DEVICE + default XEN_BACKEND || XEN_GNTDEV || XEN_DOM0 + help + Use unpopulated memory ranges in order to create mappings for guest + memory regions, including grant maps and foreign pages. This avoids + having to balloon out RAM regions in order to obtain physical memory + space to create such mappings. + endmenu diff --git a/drivers/xen/Makefile b/drivers/xen/Makefile index c25c9a699b48..babdca808861 100644 --- a/drivers/xen/Makefile +++ b/drivers/xen/Makefile @@ -41,3 +41,4 @@ xen-gntdev-$(CONFIG_XEN_GNTDEV_DMABUF) += gntdev-dmabuf.o xen-gntalloc-y := gntalloc.o xen-privcmd-y := privcmd.o privcmd-buf.o obj-$(CONFIG_XEN_FRONT_PGDIR_SHBUF) += xen-front-pgdir-shbuf.o +obj-$(CONFIG_XEN_UNPOPULATED_ALLOC) += unpopulated-alloc.o diff --git a/drivers/xen/balloon.c b/drivers/xen/balloon.c index 37ffccda8bb8..51427c752b37 100644 --- a/drivers/xen/balloon.c +++ b/drivers/xen/balloon.c @@ -653,7 +653,7 @@ void free_xenballooned_pages(int nr_pages, struct page **pages) } EXPORT_SYMBOL(free_xenballooned_pages); -#ifdef CONFIG_XEN_PV +#if defined(CONFIG_XEN_PV) && !defined(CONFIG_XEN_UNPOPULATED_ALLOC) static void __init balloon_add_region(unsigned long start_pfn, unsigned long pages) { @@ -707,7 +707,7 @@ static int __init balloon_init(void) register_sysctl_table(xen_root); #endif -#ifdef CONFIG_XEN_PV +#if defined(CONFIG_XEN_PV) && !defined(CONFIG_XEN_UNPOPULATED_ALLOC) { int i; diff --git a/drivers/xen/grant-table.c b/drivers/xen/grant-table.c index 8d06bf1cc347..523dcdf39cc9 100644 --- a/drivers/xen/grant-table.c +++ b/drivers/xen/grant-table.c @@ -801,7 +801,7 @@ int gnttab_alloc_pages(int nr_pages, struct page **pages) { int ret; - ret = alloc_xenballooned_pages(nr_pages, pages); + ret = xen_alloc_unpopulated_pages(nr_pages, pages); if (ret < 0) return ret; @@ -836,7 +836,7 @@ EXPORT_SYMBOL_GPL(gnttab_pages_clear_private); void gnttab_free_pages(int nr_pages, struct page **pages) { gnttab_pages_clear_private(nr_pages, pages); - free_xenballooned_pages(nr_pages, pages); + xen_free_unpopulated_pages(nr_pages, pages); } EXPORT_SYMBOL_GPL(gnttab_free_pages); diff --git a/drivers/xen/privcmd.c b/drivers/xen/privcmd.c index 63abe6c3642b..b0c73c58f987 100644 --- a/drivers/xen/privcmd.c +++ b/drivers/xen/privcmd.c @@ -424,7 +424,7 @@ static int alloc_empty_pages(struct vm_area_struct *vma, int numpgs) if (pages == NULL) return -ENOMEM; - rc = alloc_xenballooned_pages(numpgs, pages); + rc = xen_alloc_unpopulated_pages(numpgs, pages); if (rc != 0) { pr_warn("%s Could not alloc %d pfns rc:%d\n", __func__, numpgs, rc); @@ -895,7 +895,7 @@ static void privcmd_close(struct vm_area_struct *vma) rc = xen_unmap_domain_gfn_range(vma, numgfns, pages); if (rc == 0) - free_xenballooned_pages(numpgs, pages); + xen_free_unpopulated_pages(numpgs, pages); else pr_crit("unable to unmap MFN range: leaking %d pages. rc=%d\n", numpgs, rc); diff --git a/drivers/xen/unpopulated-alloc.c b/drivers/xen/unpopulated-alloc.c new file mode 100644 index 000000000000..1b5d157c6977 --- /dev/null +++ b/drivers/xen/unpopulated-alloc.c @@ -0,0 +1,185 @@ +// SPDX-License-Identifier: GPL-2.0 +#include +#include +#include +#include +#include +#include + +#include + +#include +#include + +static DEFINE_MUTEX(list_lock); +static LIST_HEAD(page_list); +static unsigned int list_count; + +static int fill_list(unsigned int nr_pages) +{ + struct dev_pagemap *pgmap; + void *vaddr; + unsigned int i, alloc_pages = round_up(nr_pages, PAGES_PER_SECTION); + int nid, ret; + + pgmap = kzalloc(sizeof(*pgmap), GFP_KERNEL); + if (!pgmap) + return -ENOMEM; + + pgmap->type = MEMORY_DEVICE_GENERIC; + pgmap->res.name = "Xen scratch"; + pgmap->res.flags = IORESOURCE_MEM | IORESOURCE_BUSY; + + ret = allocate_resource(&iomem_resource, &pgmap->res, + alloc_pages * PAGE_SIZE, 0, -1, + PAGES_PER_SECTION * PAGE_SIZE, NULL, NULL); + if (ret < 0) { + pr_err("Cannot allocate new IOMEM resource\n"); + kfree(pgmap); + return ret; + } + + nid = memory_add_physaddr_to_nid(pgmap->res.start); + +#ifdef CONFIG_XEN_HAVE_PVMMU + /* + * memremap will build page tables for the new memory so + * the p2m must contain invalid entries so the correct + * non-present PTEs will be written. + * + * If a failure occurs, the original (identity) p2m entries + * are not restored since this region is now known not to + * conflict with any devices. + */ + if (!xen_feature(XENFEAT_auto_translated_physmap)) { + xen_pfn_t pfn = PFN_DOWN(pgmap->res.start); + + for (i = 0; i < alloc_pages; i++) { + if (!set_phys_to_machine(pfn + i, INVALID_P2M_ENTRY)) { + pr_warn("set_phys_to_machine() failed, no memory added\n"); + release_resource(&pgmap->res); + kfree(pgmap); + return -ENOMEM; + } + } + } +#endif + + vaddr = memremap_pages(pgmap, nid); + if (IS_ERR(vaddr)) { + pr_err("Cannot remap memory range\n"); + release_resource(&pgmap->res); + kfree(pgmap); + return PTR_ERR(vaddr); + } + + for (i = 0; i < alloc_pages; i++) { + struct page *pg = virt_to_page(vaddr + PAGE_SIZE * i); + + BUG_ON(!virt_addr_valid(vaddr + PAGE_SIZE * i)); + list_add(&pg->lru, &page_list); + list_count++; + } + + return 0; +} + +/** + * xen_alloc_unpopulated_pages - alloc unpopulated pages + * @nr_pages: Number of pages + * @pages: pages returned + * @return 0 on success, error otherwise + */ +int xen_alloc_unpopulated_pages(unsigned int nr_pages, struct page **pages) +{ + unsigned int i; + int ret = 0; + + mutex_lock(&list_lock); + if (list_count < nr_pages) { + ret = fill_list(nr_pages - list_count); + if (ret) + goto out; + } + + for (i = 0; i < nr_pages; i++) { + struct page *pg = list_first_entry_or_null(&page_list, + struct page, + lru); + + BUG_ON(!pg); + list_del(&pg->lru); + list_count--; + pages[i] = pg; + +#ifdef CONFIG_XEN_HAVE_PVMMU + if (!xen_feature(XENFEAT_auto_translated_physmap)) { + ret = xen_alloc_p2m_entry(page_to_pfn(pg)); + if (ret < 0) { + unsigned int j; + + for (j = 0; j <= i; j++) { + list_add(&pages[j]->lru, &page_list); + list_count++; + } + goto out; + } + } +#endif + } + +out: + mutex_unlock(&list_lock); + return ret; +} +EXPORT_SYMBOL(xen_alloc_unpopulated_pages); + +/** + * xen_free_unpopulated_pages - return unpopulated pages + * @nr_pages: Number of pages + * @pages: pages to return + */ +void xen_free_unpopulated_pages(unsigned int nr_pages, struct page **pages) +{ + unsigned int i; + + mutex_lock(&list_lock); + for (i = 0; i < nr_pages; i++) { + list_add(&pages[i]->lru, &page_list); + list_count++; + } + mutex_unlock(&list_lock); +} +EXPORT_SYMBOL(xen_free_unpopulated_pages); + +#ifdef CONFIG_XEN_PV +static int __init init(void) +{ + unsigned int i; + + if (!xen_domain()) + return -ENODEV; + + if (!xen_pv_domain()) + return 0; + + /* + * Initialize with pages from the extra memory regions (see + * arch/x86/xen/setup.c). + */ + for (i = 0; i < XEN_EXTRA_MEM_MAX_REGIONS; i++) { + unsigned int j; + + for (j = 0; j < xen_extra_mem[i].n_pfns; j++) { + struct page *pg = + pfn_to_page(xen_extra_mem[i].start_pfn + j); + + list_add(&pg->lru, &page_list); + list_count++; + } + } + + return 0; +} +subsys_initcall(init); +#endif diff --git a/drivers/xen/xenbus/xenbus_client.c b/drivers/xen/xenbus/xenbus_client.c index 907bcbb93afb..2690318ad50f 100644 --- a/drivers/xen/xenbus/xenbus_client.c +++ b/drivers/xen/xenbus/xenbus_client.c @@ -621,7 +621,7 @@ static int xenbus_map_ring_hvm(struct xenbus_device *dev, bool leaked = false; unsigned int nr_pages = XENBUS_PAGES(nr_grefs); - err = alloc_xenballooned_pages(nr_pages, node->hvm.pages); + err = xen_alloc_unpopulated_pages(nr_pages, node->hvm.pages); if (err) goto out_err; @@ -662,7 +662,7 @@ static int xenbus_map_ring_hvm(struct xenbus_device *dev, addr, nr_pages); out_free_ballooned_pages: if (!leaked) - free_xenballooned_pages(nr_pages, node->hvm.pages); + xen_free_unpopulated_pages(nr_pages, node->hvm.pages); out_err: return err; } @@ -858,7 +858,7 @@ static int xenbus_unmap_ring_hvm(struct xenbus_device *dev, void *vaddr) info.addrs); if (!rv) { vunmap(vaddr); - free_xenballooned_pages(nr_pages, node->hvm.pages); + xen_free_unpopulated_pages(nr_pages, node->hvm.pages); } else WARN(1, "Leaking %p, size %u page(s)\n", vaddr, nr_pages); diff --git a/drivers/xen/xlate_mmu.c b/drivers/xen/xlate_mmu.c index 7b1077f0abcb..34742c6e189e 100644 --- a/drivers/xen/xlate_mmu.c +++ b/drivers/xen/xlate_mmu.c @@ -232,7 +232,7 @@ int __init xen_xlate_map_ballooned_pages(xen_pfn_t **gfns, void **virt, kfree(pages); return -ENOMEM; } - rc = alloc_xenballooned_pages(nr_pages, pages); + rc = xen_alloc_unpopulated_pages(nr_pages, pages); if (rc) { pr_warn("%s Couldn't balloon alloc %ld pages rc:%d\n", __func__, nr_pages, rc); @@ -249,7 +249,7 @@ int __init xen_xlate_map_ballooned_pages(xen_pfn_t **gfns, void **virt, if (!vaddr) { pr_warn("%s Couldn't map %ld pages rc:%d\n", __func__, nr_pages, rc); - free_xenballooned_pages(nr_pages, pages); + xen_free_unpopulated_pages(nr_pages, pages); kfree(pages); kfree(pfns); return -ENOMEM; diff --git a/include/xen/xen.h b/include/xen/xen.h index 19a72f591e2b..43efba045acc 100644 --- a/include/xen/xen.h +++ b/include/xen/xen.h @@ -52,4 +52,13 @@ bool xen_biovec_phys_mergeable(const struct bio_vec *vec1, extern u64 xen_saved_max_mem_size; #endif +#ifdef CONFIG_XEN_UNPOPULATED_ALLOC +int xen_alloc_unpopulated_pages(unsigned int nr_pages, struct page **pages); +void xen_free_unpopulated_pages(unsigned int nr_pages, struct page **pages); +#else +#define xen_alloc_unpopulated_pages alloc_xenballooned_pages +#define xen_free_unpopulated_pages free_xenballooned_pages +#include +#endif + #endif /* _XEN_XEN_H */ -- 2.28.0 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=-12.8 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id B4FD4C2BC11 for ; Tue, 1 Sep 2020 16:37:51 +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 8178E2078B for ; Tue, 1 Sep 2020 16:37:51 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=citrix.com header.i=@citrix.com header.b="Dca6lZ7e" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 8178E2078B Authentication-Results: mail.kernel.org; dmarc=fail (p=reject dis=none) header.from=citrix.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 7F8626E88A; Tue, 1 Sep 2020 16:37:29 +0000 (UTC) Received: from esa6.hc3370-68.iphmx.com (esa6.hc3370-68.iphmx.com [216.71.155.175]) by gabe.freedesktop.org (Postfix) with ESMTPS id 4CDBF6E427 for ; Tue, 1 Sep 2020 08:33:44 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=citrix.com; s=securemail; t=1598949224; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=QzGqPaRCnZVxjqPpl6AF6iSX77/n0WkY1Cja56OEeNs=; b=Dca6lZ7e3ndoI8r6/qryN+E4h1kTIsgvEFK7IBkFa3P47phJ6r10vKr0 +z6LizmjeHbvQKJBMmGYi6qW+OG55AK9qnmYp25A7Y8XacbtHeueYZCpN J9VNE/xlOsBreZ4Z5kuJO9XktJ6+MrQBHFvq4Wpt7wp+LL64hTW3naVXh A=; Authentication-Results: esa6.hc3370-68.iphmx.com; dkim=none (message not signed) header.i=none IronPort-SDR: P0Ki/2b6mGa7pA1kqv/yHJEYGZ0xQ5RKAnnYciHHQu9+ozbehl7aTLhqS7TsmIqN1+lFdBA2a9 YM8aY9TgwPAc3ZTssNFiElD1kH3pZNZrmb9idWz2MNankSE+bm4Wh4gAgP/HZ0wtix/XOEQxz2 fahYv9vYNdm2yXqMi4Lx8AYZKjX0g3Wz6gC3nv5LsslNCzlzeU2Yxw6gdSPgs+07all1BEuJWf xBsiJhhiZ56EmPvlzqDlvphkbjyBG8gF8aXF6k+tJiRMgpJUdust+wSQCx3dbmJ4nY0YdY+Au0 418= X-SBRS: 2.7 X-MesageID: 26017058 X-Ironport-Server: esa6.hc3370-68.iphmx.com X-Remote-IP: 162.221.158.21 X-Policy: $RELAYED X-IronPort-AV: E=Sophos;i="5.76,378,1592884800"; d="scan'208";a="26017058" From: Roger Pau Monne To: Subject: [PATCH v5 3/3] xen: add helpers to allocate unpopulated memory Date: Tue, 1 Sep 2020 10:33:26 +0200 Message-ID: <20200901083326.21264-4-roger.pau@citrix.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20200901083326.21264-1-roger.pau@citrix.com> References: <20200901083326.21264-1-roger.pau@citrix.com> MIME-Version: 1.0 X-Mailman-Approved-At: Tue, 01 Sep 2020 16:37:24 +0000 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: Juergen Gross , Stefano Stabellini , Wei Liu , Oleksandr Andrushchenko , David Airlie , Yan Yankovskyi , David Hildenbrand , dri-devel@lists.freedesktop.org, Michal Hocko , linux-mm@kvack.org, xen-devel@lists.xenproject.org, Boris Ostrovsky , Dan Williams , Dan Carpenter , Roger Pau Monne Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" VG8gYmUgdXNlZCBpbiBvcmRlciB0byBjcmVhdGUgZm9yZWlnbiBtYXBwaW5ncy4gVGhpcyBpcyBi YXNlZCBvbiB0aGUKWk9ORV9ERVZJQ0UgZmFjaWxpdHkgd2hpY2ggaXMgdXNlZCBieSBwZXJzaXN0 ZW50IG1lbW9yeSBkZXZpY2VzIGluCm9yZGVyIHRvIGNyZWF0ZSBzdHJ1Y3QgcGFnZXMgYW5kIGtl cm5lbCB2aXJ0dWFsIG1hcHBpbmdzIGZvciB0aGUgSU9NRU0KYXJlYXMgb2Ygc3VjaCBkZXZpY2Vz LiBOb3RlIHRoYXQgb24ga2VybmVscyB3aXRob3V0IHN1cHBvcnQgZm9yClpPTkVfREVWSUNFIFhl biB3aWxsIGZhbGxiYWNrIHRvIHVzZSBiYWxsb29uZWQgcGFnZXMgaW4gb3JkZXIgdG8KY3JlYXRl IGZvcmVpZ24gbWFwcGluZ3MuCgpUaGUgbmV3bHkgYWRkZWQgaGVscGVycyB1c2UgdGhlIHNhbWUg cGFyYW1ldGVycyBhcyB0aGUgZXhpc3RpbmcKe2FsbG9jL2ZyZWV9X3hlbmJhbGxvb25lZF9wYWdl cyBmdW5jdGlvbnMsIHdoaWNoIGFsbG93cyBmb3IgaW4tcGxhY2UKcmVwbGFjZW1lbnQgb2YgdGhl IGNhbGxlcnMuIE9uY2UgYSBtZW1vcnkgcmVnaW9uIGhhcyBiZWVuIGFkZGVkIHRvIGJlCnVzZWQg YXMgc2NyYXRjaCBtYXBwaW5nIHNwYWNlIGl0IHdpbGwgbm8gbG9uZ2VyIGJlIHJlbGVhc2VkLCBh bmQgcGFnZXMKcmV0dXJuZWQgYXJlIGtlcHQgaW4gYSBsaW5rZWQgbGlzdC4gVGhpcyBhbGxvd3Mg dG8gaGF2ZSBhIGJ1ZmZlciBvZgpwYWdlcyBhbmQgcHJldmVudHMgcmVzb3J0aW5nIHRvIGZyZXF1 ZW50IGFkZGl0aW9ucyBhbmQgcmVtb3ZhbHMgb2YKcmVnaW9ucy4KCklmIGVuYWJsZWQgKGJlY2F1 c2UgWk9ORV9ERVZJQ0UgaXMgc3VwcG9ydGVkKSB0aGUgdXNhZ2Ugb2YgdGhlIG5ldwpmdW5jdGlv bmFsaXR5IHVudGFuZ2xlcyBYZW4gYmFsbG9vbiBhbmQgUkFNIGhvdHBsdWcgZnJvbSB0aGUgdXNh Z2Ugb2YKdW5wb3B1bGF0ZWQgcGh5c2ljYWwgbWVtb3J5IHJhbmdlcyB0byBtYXAgZm9yZWlnbiBw YWdlcywgd2hpY2ggaXMgdGhlCmNvcnJlY3QgdGhpbmcgdG8gZG8gaW4gb3JkZXIgdG8gYXZvaWQg bWFwcGluZ3Mgb2YgZm9yZWlnbiBwYWdlcyBkZXBlbmQKb24gbWVtb3J5IGhvdHBsdWcuCgpOb3Rl IHRoZSBkcml2ZXIgaXMgY3VycmVudGx5IG5vdCBlbmFibGVkIG9uIEFybSBwbGF0Zm9ybXMgYmVj YXVzZSBpdAp3b3VsZCBpbnRlcmZlcmUgd2l0aCB0aGUgaWRlbnRpdHkgbWFwcGluZyByZXF1aXJl ZCBvbiBzb21lIHBsYXRmb3Jtcy4KClNpZ25lZC1vZmYtYnk6IFJvZ2VyIFBhdSBNb25uw6kgPHJv Z2VyLnBhdUBjaXRyaXguY29tPgotLS0KQ2M6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVr c2FuZHJfYW5kcnVzaGNoZW5rb0BlcGFtLmNvbT4KQ2M6IERhdmlkIEFpcmxpZSA8YWlybGllZEBs aW51eC5pZT4KQ2M6IERhbmllbCBWZXR0ZXIgPGRhbmllbEBmZndsbC5jaD4KQ2M6IEJvcmlzIE9z dHJvdnNreSA8Ym9yaXMub3N0cm92c2t5QG9yYWNsZS5jb20+CkNjOiBKdWVyZ2VuIEdyb3NzIDxq Z3Jvc3NAc3VzZS5jb20+CkNjOiBTdGVmYW5vIFN0YWJlbGxpbmkgPHNzdGFiZWxsaW5pQGtlcm5l bC5vcmc+CkNjOiBEYW4gQ2FycGVudGVyIDxkYW4uY2FycGVudGVyQG9yYWNsZS5jb20+CkNjOiBS b2dlciBQYXUgTW9ubmUgPHJvZ2VyLnBhdUBjaXRyaXguY29tPgpDYzogV2VpIExpdSA8d2xAeGVu Lm9yZz4KQ2M6IFlhbiBZYW5rb3Zza3lpIDx5eWFua292c2t5aUBnbWFpbC5jb20+CkNjOiBkcmkt ZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCkNjOiB4ZW4tZGV2ZWxAbGlzdHMueGVucHJvamVj dC5vcmcKQ2M6IGxpbnV4LW1tQGt2YWNrLm9yZwpDYzogRGF2aWQgSGlsZGVuYnJhbmQgPGRhdmlk QHJlZGhhdC5jb20+CkNjOiBNaWNoYWwgSG9ja28gPG1ob2Nrb0BrZXJuZWwub3JnPgpDYzogRGFu IFdpbGxpYW1zIDxkYW4uai53aWxsaWFtc0BpbnRlbC5jb20+Ci0tLQpDaGFuZ2VzIHNpbmNlIHY0 OgogLSBJbnRyb2R1Y2UgYSBkZXNjcmlwdGlvbiBmb3IgdGhlIG9wdGlvbi4KIC0gRm9yY2Ugc2Vs ZWN0aW9uIG9mIFpPTkVfREVWSUNFIG9uIFg4NiBhbmQgc2VsZWN0CiAgIFhFTl9VTlBPUFVMQVRF RF9BTExPQyBpZiBydW5uaW5nIG9uIGRvbTAgbW9kZSBvciBoYXZpbmcgYW55CiAgIGJhY2tlbmRz LgoKQ2hhbmdlcyBzaW5jZSB2MzoKIC0gSW50cm9kdWNlIGEgS2NvbmZpZyBvcHRpb24gdGhhdCBn YXRlcyB0aGUgYWRkaXRpb24gb2YgdGhlCiAgIHVucG9wdWxhdGVkIGFsbG9jIGRyaXZlci4gVGhp cyBhbGxvd3MgdG8gZWFzaWx5IGRpc2FibGUgaXQgb24gQXJtCiAgIHBsYXRmb3Jtcy4KIC0gRHJv cHBlZCBKdWVyZ2VuIFJCIGR1ZSB0byB0aGUgYWRkaXRpb24gb2YgdGhlIEtjb25maWcgb3B0aW9u LgogLSBTd2l0Y2hlZCBmcm9tIE1FTU9SWV9ERVZJQ0VfREVWREFYIHRvIE1FTU9SWV9ERVZJQ0Vf R0VORVJJQy4KCkNoYW5nZXMgc2luY2UgdjI6CiAtIERyb3AgQlVJTERfQlVHX09OIHJlZ2FyZGlu ZyBQVk1NVSBwYWdlIHNpemVzLgogLSBVc2UgYSBTUERYIGxpY2Vuc2UgaWRlbnRpZmllci4KIC0g Q2FsbCBmaWxsIHdpdGggb25seSB0aGUgbWluaW11bSByZXF1aXJlZCBudW1iZXIgb2YgcGFnZXMu CiAtIEluY2x1ZGUgeGVuLmggaGVhZGVyIGluIHhlbl9kcm1fZnJvbnRfZ2VtLmMuCiAtIFVzZSBs ZXNzIGdlbmVyaWMgZnVuY3Rpb24gbmFtZXMuCiAtIEV4aXQgZWFybHkgZnJvbSB0aGUgaW5pdCBm dW5jdGlvbiBpZiBub3QgYSBQViBndWVzdC4KIC0gRG9uJ3QgdXNlIGFsbCBjYXBzIGZvciByZWdp b24gbmFtZS4KLS0tCiBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZ2VtLmMgfCAg IDkgKy0KIGRyaXZlcnMveGVuL0tjb25maWcgICAgICAgICAgICAgICAgICAgICB8ICAxMSArKwog ZHJpdmVycy94ZW4vTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgIHwgICAxICsKIGRyaXZlcnMv eGVuL2JhbGxvb24uYyAgICAgICAgICAgICAgICAgICB8ICAgNCArLQogZHJpdmVycy94ZW4vZ3Jh bnQtdGFibGUuYyAgICAgICAgICAgICAgIHwgICA0ICstCiBkcml2ZXJzL3hlbi9wcml2Y21kLmMg ICAgICAgICAgICAgICAgICAgfCAgIDQgKy0KIGRyaXZlcnMveGVuL3VucG9wdWxhdGVkLWFsbG9j LmMgICAgICAgICB8IDE4NSArKysrKysrKysrKysrKysrKysrKysrKysKIGRyaXZlcnMveGVuL3hl bmJ1cy94ZW5idXNfY2xpZW50LmMgICAgICB8ICAgNiArLQogZHJpdmVycy94ZW4veGxhdGVfbW11 LmMgICAgICAgICAgICAgICAgIHwgICA0ICstCiBpbmNsdWRlL3hlbi94ZW4uaCAgICAgICAgICAg ICAgICAgICAgICAgfCAgIDkgKysKIDEwIGZpbGVzIGNoYW5nZWQsIDIyMiBpbnNlcnRpb25zKCsp LCAxNSBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL3hlbi91bnBvcHVs YXRlZC1hbGxvYy5jCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zy b250X2dlbS5jIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2dlbS5jCmluZGV4 IDM5ZmY5NWI3NTM1Ny4uNTM0ZGFmMzdjOTdlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0v eGVuL3hlbl9kcm1fZnJvbnRfZ2VtLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJt X2Zyb250X2dlbS5jCkBAIC0xOCw2ICsxOCw3IEBACiAjaW5jbHVkZSA8ZHJtL2RybV9wcm9iZV9o ZWxwZXIuaD4KIAogI2luY2x1ZGUgPHhlbi9iYWxsb29uLmg+CisjaW5jbHVkZSA8eGVuL3hlbi5o PgogCiAjaW5jbHVkZSAieGVuX2RybV9mcm9udC5oIgogI2luY2x1ZGUgInhlbl9kcm1fZnJvbnRf Z2VtLmgiCkBAIC05OSw4ICsxMDAsOCBAQCBzdGF0aWMgc3RydWN0IHhlbl9nZW1fb2JqZWN0ICpn ZW1fY3JlYXRlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHNpemVfdCBzaXplKQogCQkgKiBhbGxv Y2F0ZSBiYWxsb29uZWQgcGFnZXMgd2hpY2ggd2lsbCBiZSB1c2VkIHRvIG1hcAogCQkgKiBncmFu dCByZWZlcmVuY2VzIHByb3ZpZGVkIGJ5IHRoZSBiYWNrZW5kCiAJCSAqLwotCQlyZXQgPSBhbGxv Y194ZW5iYWxsb29uZWRfcGFnZXMoeGVuX29iai0+bnVtX3BhZ2VzLAotCQkJCQkgICAgICAgeGVu X29iai0+cGFnZXMpOworCQlyZXQgPSB4ZW5fYWxsb2NfdW5wb3B1bGF0ZWRfcGFnZXMoeGVuX29i ai0+bnVtX3BhZ2VzLAorCQkJCQkgICAgICAgICAgeGVuX29iai0+cGFnZXMpOwogCQlpZiAocmV0 IDwgMCkgewogCQkJRFJNX0VSUk9SKCJDYW5ub3QgYWxsb2NhdGUgJXp1IGJhbGxvb25lZCBwYWdl czogJWRcbiIsCiAJCQkJICB4ZW5fb2JqLT5udW1fcGFnZXMsIHJldCk7CkBAIC0xNTIsOCArMTUz LDggQEAgdm9pZCB4ZW5fZHJtX2Zyb250X2dlbV9mcmVlX29iamVjdF91bmxvY2tlZChzdHJ1Y3Qg ZHJtX2dlbV9vYmplY3QgKmdlbV9vYmopCiAJfSBlbHNlIHsKIAkJaWYgKHhlbl9vYmotPnBhZ2Vz KSB7CiAJCQlpZiAoeGVuX29iai0+YmVfYWxsb2MpIHsKLQkJCQlmcmVlX3hlbmJhbGxvb25lZF9w YWdlcyh4ZW5fb2JqLT5udW1fcGFnZXMsCi0JCQkJCQkJeGVuX29iai0+cGFnZXMpOworCQkJCXhl bl9mcmVlX3VucG9wdWxhdGVkX3BhZ2VzKHhlbl9vYmotPm51bV9wYWdlcywKKwkJCQkJCQkgICB4 ZW5fb2JqLT5wYWdlcyk7CiAJCQkJZ2VtX2ZyZWVfcGFnZXNfYXJyYXkoeGVuX29iaik7CiAJCQl9 IGVsc2UgewogCQkJCWRybV9nZW1fcHV0X3BhZ2VzKCZ4ZW5fb2JqLT5iYXNlLApkaWZmIC0tZ2l0 IGEvZHJpdmVycy94ZW4vS2NvbmZpZyBiL2RyaXZlcnMveGVuL0tjb25maWcKaW5kZXggZWE2YzFl N2UzZTQyLi5lMzhjMzM1NThkMGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL0tjb25maWcKKysr IGIvZHJpdmVycy94ZW4vS2NvbmZpZwpAQCAtMzI1LDQgKzMyNSwxNSBAQCBjb25maWcgWEVOX0hB VkVfVlBNVQogY29uZmlnIFhFTl9GUk9OVF9QR0RJUl9TSEJVRgogCXRyaXN0YXRlCiAKK2NvbmZp ZyBYRU5fVU5QT1BVTEFURURfQUxMT0MKKwlib29sICJVc2UgdW5wb3B1bGF0ZWQgbWVtb3J5IHJh bmdlcyBmb3IgZ3Vlc3QgbWFwcGluZ3MiCisJZGVwZW5kcyBvbiBYODYKKwlzZWxlY3QgWk9ORV9E RVZJQ0UKKwlkZWZhdWx0IFhFTl9CQUNLRU5EIHx8IFhFTl9HTlRERVYgfHwgWEVOX0RPTTAKKwlo ZWxwCisJICBVc2UgdW5wb3B1bGF0ZWQgbWVtb3J5IHJhbmdlcyBpbiBvcmRlciB0byBjcmVhdGUg bWFwcGluZ3MgZm9yIGd1ZXN0CisJICBtZW1vcnkgcmVnaW9ucywgaW5jbHVkaW5nIGdyYW50IG1h cHMgYW5kIGZvcmVpZ24gcGFnZXMuIFRoaXMgYXZvaWRzCisJICBoYXZpbmcgdG8gYmFsbG9vbiBv dXQgUkFNIHJlZ2lvbnMgaW4gb3JkZXIgdG8gb2J0YWluIHBoeXNpY2FsIG1lbW9yeQorCSAgc3Bh Y2UgdG8gY3JlYXRlIHN1Y2ggbWFwcGluZ3MuCisKIGVuZG1lbnUKZGlmZiAtLWdpdCBhL2RyaXZl cnMveGVuL01ha2VmaWxlIGIvZHJpdmVycy94ZW4vTWFrZWZpbGUKaW5kZXggYzI1YzlhNjk5YjQ4 Li5iYWJkY2E4MDg4NjEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL01ha2VmaWxlCisrKyBiL2Ry aXZlcnMveGVuL01ha2VmaWxlCkBAIC00MSwzICs0MSw0IEBAIHhlbi1nbnRkZXYtJChDT05GSUdf WEVOX0dOVERFVl9ETUFCVUYpCSs9IGdudGRldi1kbWFidWYubwogeGVuLWdudGFsbG9jLXkJCQkJ Oj0gZ250YWxsb2MubwogeGVuLXByaXZjbWQteQkJCQk6PSBwcml2Y21kLm8gcHJpdmNtZC1idWYu bwogb2JqLSQoQ09ORklHX1hFTl9GUk9OVF9QR0RJUl9TSEJVRikJKz0geGVuLWZyb250LXBnZGly LXNoYnVmLm8KK29iai0kKENPTkZJR19YRU5fVU5QT1BVTEFURURfQUxMT0MpCSs9IHVucG9wdWxh dGVkLWFsbG9jLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL2JhbGxvb24uYyBiL2RyaXZlcnMv eGVuL2JhbGxvb24uYwppbmRleCAzN2ZmY2NkYThiYjguLjUxNDI3Yzc1MmIzNyAxMDA2NDQKLS0t IGEvZHJpdmVycy94ZW4vYmFsbG9vbi5jCisrKyBiL2RyaXZlcnMveGVuL2JhbGxvb24uYwpAQCAt NjUzLDcgKzY1Myw3IEBAIHZvaWQgZnJlZV94ZW5iYWxsb29uZWRfcGFnZXMoaW50IG5yX3BhZ2Vz LCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKQogfQogRVhQT1JUX1NZTUJPTChmcmVlX3hlbmJhbGxvb25l ZF9wYWdlcyk7CiAKLSNpZmRlZiBDT05GSUdfWEVOX1BWCisjaWYgZGVmaW5lZChDT05GSUdfWEVO X1BWKSAmJiAhZGVmaW5lZChDT05GSUdfWEVOX1VOUE9QVUxBVEVEX0FMTE9DKQogc3RhdGljIHZv aWQgX19pbml0IGJhbGxvb25fYWRkX3JlZ2lvbih1bnNpZ25lZCBsb25nIHN0YXJ0X3BmbiwKIAkJ CQkgICAgICB1bnNpZ25lZCBsb25nIHBhZ2VzKQogewpAQCAtNzA3LDcgKzcwNyw3IEBAIHN0YXRp YyBpbnQgX19pbml0IGJhbGxvb25faW5pdCh2b2lkKQogCXJlZ2lzdGVyX3N5c2N0bF90YWJsZSh4 ZW5fcm9vdCk7CiAjZW5kaWYKIAotI2lmZGVmIENPTkZJR19YRU5fUFYKKyNpZiBkZWZpbmVkKENP TkZJR19YRU5fUFYpICYmICFkZWZpbmVkKENPTkZJR19YRU5fVU5QT1BVTEFURURfQUxMT0MpCiAJ ewogCQlpbnQgaTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vZ3JhbnQtdGFibGUuYyBiL2Ry aXZlcnMveGVuL2dyYW50LXRhYmxlLmMKaW5kZXggOGQwNmJmMWNjMzQ3Li41MjNkY2RmMzljYzkg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL2dyYW50LXRhYmxlLmMKKysrIGIvZHJpdmVycy94ZW4v Z3JhbnQtdGFibGUuYwpAQCAtODAxLDcgKzgwMSw3IEBAIGludCBnbnR0YWJfYWxsb2NfcGFnZXMo aW50IG5yX3BhZ2VzLCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKQogewogCWludCByZXQ7CiAKLQlyZXQg PSBhbGxvY194ZW5iYWxsb29uZWRfcGFnZXMobnJfcGFnZXMsIHBhZ2VzKTsKKwlyZXQgPSB4ZW5f YWxsb2NfdW5wb3B1bGF0ZWRfcGFnZXMobnJfcGFnZXMsIHBhZ2VzKTsKIAlpZiAocmV0IDwgMCkK IAkJcmV0dXJuIHJldDsKIApAQCAtODM2LDcgKzgzNiw3IEBAIEVYUE9SVF9TWU1CT0xfR1BMKGdu dHRhYl9wYWdlc19jbGVhcl9wcml2YXRlKTsKIHZvaWQgZ250dGFiX2ZyZWVfcGFnZXMoaW50IG5y X3BhZ2VzLCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKQogewogCWdudHRhYl9wYWdlc19jbGVhcl9wcml2 YXRlKG5yX3BhZ2VzLCBwYWdlcyk7Ci0JZnJlZV94ZW5iYWxsb29uZWRfcGFnZXMobnJfcGFnZXMs IHBhZ2VzKTsKKwl4ZW5fZnJlZV91bnBvcHVsYXRlZF9wYWdlcyhucl9wYWdlcywgcGFnZXMpOwog fQogRVhQT1JUX1NZTUJPTF9HUEwoZ250dGFiX2ZyZWVfcGFnZXMpOwogCmRpZmYgLS1naXQgYS9k cml2ZXJzL3hlbi9wcml2Y21kLmMgYi9kcml2ZXJzL3hlbi9wcml2Y21kLmMKaW5kZXggNjNhYmU2 YzM2NDJiLi5iMGM3M2M1OGY5ODcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL3ByaXZjbWQuYwor KysgYi9kcml2ZXJzL3hlbi9wcml2Y21kLmMKQEAgLTQyNCw3ICs0MjQsNyBAQCBzdGF0aWMgaW50 IGFsbG9jX2VtcHR5X3BhZ2VzKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLCBpbnQgbnVtcGdz KQogCWlmIChwYWdlcyA9PSBOVUxMKQogCQlyZXR1cm4gLUVOT01FTTsKIAotCXJjID0gYWxsb2Nf eGVuYmFsbG9vbmVkX3BhZ2VzKG51bXBncywgcGFnZXMpOworCXJjID0geGVuX2FsbG9jX3VucG9w dWxhdGVkX3BhZ2VzKG51bXBncywgcGFnZXMpOwogCWlmIChyYyAhPSAwKSB7CiAJCXByX3dhcm4o IiVzIENvdWxkIG5vdCBhbGxvYyAlZCBwZm5zIHJjOiVkXG4iLCBfX2Z1bmNfXywKIAkJCW51bXBn cywgcmMpOwpAQCAtODk1LDcgKzg5NSw3IEBAIHN0YXRpYyB2b2lkIHByaXZjbWRfY2xvc2Uoc3Ry dWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCiAKIAlyYyA9IHhlbl91bm1hcF9kb21haW5fZ2ZuX3Jh bmdlKHZtYSwgbnVtZ2ZucywgcGFnZXMpOwogCWlmIChyYyA9PSAwKQotCQlmcmVlX3hlbmJhbGxv b25lZF9wYWdlcyhudW1wZ3MsIHBhZ2VzKTsKKwkJeGVuX2ZyZWVfdW5wb3B1bGF0ZWRfcGFnZXMo bnVtcGdzLCBwYWdlcyk7CiAJZWxzZQogCQlwcl9jcml0KCJ1bmFibGUgdG8gdW5tYXAgTUZOIHJh bmdlOiBsZWFraW5nICVkIHBhZ2VzLiByYz0lZFxuIiwKIAkJCW51bXBncywgcmMpOwpkaWZmIC0t Z2l0IGEvZHJpdmVycy94ZW4vdW5wb3B1bGF0ZWQtYWxsb2MuYyBiL2RyaXZlcnMveGVuL3VucG9w dWxhdGVkLWFsbG9jLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4x YjVkMTU3YzY5NzcKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3hlbi91bnBvcHVsYXRlZC1h bGxvYy5jCkBAIC0wLDAgKzEsMTg1IEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BM LTIuMAorI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+CisjaW5jbHVkZSA8bGludXgvZ2ZwLmg+Cisj aW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvbW0uaD4KKyNpbmNsdWRl IDxsaW51eC9tZW1yZW1hcC5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKworI2luY2x1ZGUg PGFzbS9wYWdlLmg+CisKKyNpbmNsdWRlIDx4ZW4vcGFnZS5oPgorI2luY2x1ZGUgPHhlbi94ZW4u aD4KKworc3RhdGljIERFRklORV9NVVRFWChsaXN0X2xvY2spOworc3RhdGljIExJU1RfSEVBRChw YWdlX2xpc3QpOworc3RhdGljIHVuc2lnbmVkIGludCBsaXN0X2NvdW50OworCitzdGF0aWMgaW50 IGZpbGxfbGlzdCh1bnNpZ25lZCBpbnQgbnJfcGFnZXMpCit7CisJc3RydWN0IGRldl9wYWdlbWFw ICpwZ21hcDsKKwl2b2lkICp2YWRkcjsKKwl1bnNpZ25lZCBpbnQgaSwgYWxsb2NfcGFnZXMgPSBy b3VuZF91cChucl9wYWdlcywgUEFHRVNfUEVSX1NFQ1RJT04pOworCWludCBuaWQsIHJldDsKKwor CXBnbWFwID0ga3phbGxvYyhzaXplb2YoKnBnbWFwKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFwZ21h cCkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlwZ21hcC0+dHlwZSA9IE1FTU9SWV9ERVZJQ0VfR0VO RVJJQzsKKwlwZ21hcC0+cmVzLm5hbWUgPSAiWGVuIHNjcmF0Y2giOworCXBnbWFwLT5yZXMuZmxh Z3MgPSBJT1JFU09VUkNFX01FTSB8IElPUkVTT1VSQ0VfQlVTWTsKKworCXJldCA9IGFsbG9jYXRl X3Jlc291cmNlKCZpb21lbV9yZXNvdXJjZSwgJnBnbWFwLT5yZXMsCisJCQkJYWxsb2NfcGFnZXMg KiBQQUdFX1NJWkUsIDAsIC0xLAorCQkJCVBBR0VTX1BFUl9TRUNUSU9OICogUEFHRV9TSVpFLCBO VUxMLCBOVUxMKTsKKwlpZiAocmV0IDwgMCkgeworCQlwcl9lcnIoIkNhbm5vdCBhbGxvY2F0ZSBu ZXcgSU9NRU0gcmVzb3VyY2VcbiIpOworCQlrZnJlZShwZ21hcCk7CisJCXJldHVybiByZXQ7CisJ fQorCisJbmlkID0gbWVtb3J5X2FkZF9waHlzYWRkcl90b19uaWQocGdtYXAtPnJlcy5zdGFydCk7 CisKKyNpZmRlZiBDT05GSUdfWEVOX0hBVkVfUFZNTVUKKyAgICAgICAgLyoKKyAgICAgICAgICog bWVtcmVtYXAgd2lsbCBidWlsZCBwYWdlIHRhYmxlcyBmb3IgdGhlIG5ldyBtZW1vcnkgc28KKyAg ICAgICAgICogdGhlIHAybSBtdXN0IGNvbnRhaW4gaW52YWxpZCBlbnRyaWVzIHNvIHRoZSBjb3Jy ZWN0CisgICAgICAgICAqIG5vbi1wcmVzZW50IFBURXMgd2lsbCBiZSB3cml0dGVuLgorICAgICAg ICAgKgorICAgICAgICAgKiBJZiBhIGZhaWx1cmUgb2NjdXJzLCB0aGUgb3JpZ2luYWwgKGlkZW50 aXR5KSBwMm0gZW50cmllcworICAgICAgICAgKiBhcmUgbm90IHJlc3RvcmVkIHNpbmNlIHRoaXMg cmVnaW9uIGlzIG5vdyBrbm93biBub3QgdG8KKyAgICAgICAgICogY29uZmxpY3Qgd2l0aCBhbnkg ZGV2aWNlcy4KKyAgICAgICAgICovCisJaWYgKCF4ZW5fZmVhdHVyZShYRU5GRUFUX2F1dG9fdHJh bnNsYXRlZF9waHlzbWFwKSkgeworCQl4ZW5fcGZuX3QgcGZuID0gUEZOX0RPV04ocGdtYXAtPnJl cy5zdGFydCk7CisKKwkJZm9yIChpID0gMDsgaSA8IGFsbG9jX3BhZ2VzOyBpKyspIHsKKwkJCWlm ICghc2V0X3BoeXNfdG9fbWFjaGluZShwZm4gKyBpLCBJTlZBTElEX1AyTV9FTlRSWSkpIHsKKwkJ CQlwcl93YXJuKCJzZXRfcGh5c190b19tYWNoaW5lKCkgZmFpbGVkLCBubyBtZW1vcnkgYWRkZWRc biIpOworCQkJCXJlbGVhc2VfcmVzb3VyY2UoJnBnbWFwLT5yZXMpOworCQkJCWtmcmVlKHBnbWFw KTsKKwkJCQlyZXR1cm4gLUVOT01FTTsKKwkJCX0KKyAgICAgICAgICAgICAgICB9CisJfQorI2Vu ZGlmCisKKwl2YWRkciA9IG1lbXJlbWFwX3BhZ2VzKHBnbWFwLCBuaWQpOworCWlmIChJU19FUlIo dmFkZHIpKSB7CisJCXByX2VycigiQ2Fubm90IHJlbWFwIG1lbW9yeSByYW5nZVxuIik7CisJCXJl bGVhc2VfcmVzb3VyY2UoJnBnbWFwLT5yZXMpOworCQlrZnJlZShwZ21hcCk7CisJCXJldHVybiBQ VFJfRVJSKHZhZGRyKTsKKwl9CisKKwlmb3IgKGkgPSAwOyBpIDwgYWxsb2NfcGFnZXM7IGkrKykg eworCQlzdHJ1Y3QgcGFnZSAqcGcgPSB2aXJ0X3RvX3BhZ2UodmFkZHIgKyBQQUdFX1NJWkUgKiBp KTsKKworCQlCVUdfT04oIXZpcnRfYWRkcl92YWxpZCh2YWRkciArIFBBR0VfU0laRSAqIGkpKTsK KwkJbGlzdF9hZGQoJnBnLT5scnUsICZwYWdlX2xpc3QpOworCQlsaXN0X2NvdW50Kys7CisJfQor CisJcmV0dXJuIDA7Cit9CisKKy8qKgorICogeGVuX2FsbG9jX3VucG9wdWxhdGVkX3BhZ2VzIC0g YWxsb2MgdW5wb3B1bGF0ZWQgcGFnZXMKKyAqIEBucl9wYWdlczogTnVtYmVyIG9mIHBhZ2VzCisg KiBAcGFnZXM6IHBhZ2VzIHJldHVybmVkCisgKiBAcmV0dXJuIDAgb24gc3VjY2VzcywgZXJyb3Ig b3RoZXJ3aXNlCisgKi8KK2ludCB4ZW5fYWxsb2NfdW5wb3B1bGF0ZWRfcGFnZXModW5zaWduZWQg aW50IG5yX3BhZ2VzLCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKQoreworCXVuc2lnbmVkIGludCBpOwor CWludCByZXQgPSAwOworCisJbXV0ZXhfbG9jaygmbGlzdF9sb2NrKTsKKwlpZiAobGlzdF9jb3Vu dCA8IG5yX3BhZ2VzKSB7CisJCXJldCA9IGZpbGxfbGlzdChucl9wYWdlcyAtIGxpc3RfY291bnQp OworCQlpZiAocmV0KQorCQkJZ290byBvdXQ7CisJfQorCisJZm9yIChpID0gMDsgaSA8IG5yX3Bh Z2VzOyBpKyspIHsKKwkJc3RydWN0IHBhZ2UgKnBnID0gbGlzdF9maXJzdF9lbnRyeV9vcl9udWxs KCZwYWdlX2xpc3QsCisJCQkJCQkJICAgc3RydWN0IHBhZ2UsCisJCQkJCQkJICAgbHJ1KTsKKwor CQlCVUdfT04oIXBnKTsKKwkJbGlzdF9kZWwoJnBnLT5scnUpOworCQlsaXN0X2NvdW50LS07CisJ CXBhZ2VzW2ldID0gcGc7CisKKyNpZmRlZiBDT05GSUdfWEVOX0hBVkVfUFZNTVUKKwkJaWYgKCF4 ZW5fZmVhdHVyZShYRU5GRUFUX2F1dG9fdHJhbnNsYXRlZF9waHlzbWFwKSkgeworCQkJcmV0ID0g eGVuX2FsbG9jX3AybV9lbnRyeShwYWdlX3RvX3BmbihwZykpOworCQkJaWYgKHJldCA8IDApIHsK KwkJCQl1bnNpZ25lZCBpbnQgajsKKworCQkJCWZvciAoaiA9IDA7IGogPD0gaTsgaisrKSB7CisJ CQkJCWxpc3RfYWRkKCZwYWdlc1tqXS0+bHJ1LCAmcGFnZV9saXN0KTsKKwkJCQkJbGlzdF9jb3Vu dCsrOworCQkJCX0KKwkJCQlnb3RvIG91dDsKKwkJCX0KKwkJfQorI2VuZGlmCisJfQorCitvdXQ6 CisJbXV0ZXhfdW5sb2NrKCZsaXN0X2xvY2spOworCXJldHVybiByZXQ7Cit9CitFWFBPUlRfU1lN Qk9MKHhlbl9hbGxvY191bnBvcHVsYXRlZF9wYWdlcyk7CisKKy8qKgorICogeGVuX2ZyZWVfdW5w b3B1bGF0ZWRfcGFnZXMgLSByZXR1cm4gdW5wb3B1bGF0ZWQgcGFnZXMKKyAqIEBucl9wYWdlczog TnVtYmVyIG9mIHBhZ2VzCisgKiBAcGFnZXM6IHBhZ2VzIHRvIHJldHVybgorICovCit2b2lkIHhl bl9mcmVlX3VucG9wdWxhdGVkX3BhZ2VzKHVuc2lnbmVkIGludCBucl9wYWdlcywgc3RydWN0IHBh Z2UgKipwYWdlcykKK3sKKwl1bnNpZ25lZCBpbnQgaTsKKworCW11dGV4X2xvY2soJmxpc3RfbG9j ayk7CisJZm9yIChpID0gMDsgaSA8IG5yX3BhZ2VzOyBpKyspIHsKKwkJbGlzdF9hZGQoJnBhZ2Vz W2ldLT5scnUsICZwYWdlX2xpc3QpOworCQlsaXN0X2NvdW50Kys7CisJfQorCW11dGV4X3VubG9j aygmbGlzdF9sb2NrKTsKK30KK0VYUE9SVF9TWU1CT0woeGVuX2ZyZWVfdW5wb3B1bGF0ZWRfcGFn ZXMpOworCisjaWZkZWYgQ09ORklHX1hFTl9QVgorc3RhdGljIGludCBfX2luaXQgaW5pdCh2b2lk KQoreworCXVuc2lnbmVkIGludCBpOworCisJaWYgKCF4ZW5fZG9tYWluKCkpCisJCXJldHVybiAt RU5PREVWOworCisJaWYgKCF4ZW5fcHZfZG9tYWluKCkpCisJCXJldHVybiAwOworCisJLyoKKwkg KiBJbml0aWFsaXplIHdpdGggcGFnZXMgZnJvbSB0aGUgZXh0cmEgbWVtb3J5IHJlZ2lvbnMgKHNl ZQorCSAqIGFyY2gveDg2L3hlbi9zZXR1cC5jKS4KKwkgKi8KKwlmb3IgKGkgPSAwOyBpIDwgWEVO X0VYVFJBX01FTV9NQVhfUkVHSU9OUzsgaSsrKSB7CisJCXVuc2lnbmVkIGludCBqOworCisJCWZv ciAoaiA9IDA7IGogPCB4ZW5fZXh0cmFfbWVtW2ldLm5fcGZuczsgaisrKSB7CisJCQlzdHJ1Y3Qg cGFnZSAqcGcgPQorCQkJCXBmbl90b19wYWdlKHhlbl9leHRyYV9tZW1baV0uc3RhcnRfcGZuICsg aik7CisKKwkJCWxpc3RfYWRkKCZwZy0+bHJ1LCAmcGFnZV9saXN0KTsKKwkJCWxpc3RfY291bnQr KzsKKwkJfQorCX0KKworCXJldHVybiAwOworfQorc3Vic3lzX2luaXRjYWxsKGluaXQpOworI2Vu ZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi94ZW5idXMveGVuYnVzX2NsaWVudC5jIGIvZHJp dmVycy94ZW4veGVuYnVzL3hlbmJ1c19jbGllbnQuYwppbmRleCA5MDdiY2JiOTNhZmIuLjI2OTAz MThhZDUwZiAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4veGVuYnVzL3hlbmJ1c19jbGllbnQuYwor KysgYi9kcml2ZXJzL3hlbi94ZW5idXMveGVuYnVzX2NsaWVudC5jCkBAIC02MjEsNyArNjIxLDcg QEAgc3RhdGljIGludCB4ZW5idXNfbWFwX3JpbmdfaHZtKHN0cnVjdCB4ZW5idXNfZGV2aWNlICpk ZXYsCiAJYm9vbCBsZWFrZWQgPSBmYWxzZTsKIAl1bnNpZ25lZCBpbnQgbnJfcGFnZXMgPSBYRU5C VVNfUEFHRVMobnJfZ3JlZnMpOwogCi0JZXJyID0gYWxsb2NfeGVuYmFsbG9vbmVkX3BhZ2VzKG5y X3BhZ2VzLCBub2RlLT5odm0ucGFnZXMpOworCWVyciA9IHhlbl9hbGxvY191bnBvcHVsYXRlZF9w YWdlcyhucl9wYWdlcywgbm9kZS0+aHZtLnBhZ2VzKTsKIAlpZiAoZXJyKQogCQlnb3RvIG91dF9l cnI7CiAKQEAgLTY2Miw3ICs2NjIsNyBAQCBzdGF0aWMgaW50IHhlbmJ1c19tYXBfcmluZ19odm0o c3RydWN0IHhlbmJ1c19kZXZpY2UgKmRldiwKIAkJCSBhZGRyLCBucl9wYWdlcyk7CiAgb3V0X2Zy ZWVfYmFsbG9vbmVkX3BhZ2VzOgogCWlmICghbGVha2VkKQotCQlmcmVlX3hlbmJhbGxvb25lZF9w YWdlcyhucl9wYWdlcywgbm9kZS0+aHZtLnBhZ2VzKTsKKwkJeGVuX2ZyZWVfdW5wb3B1bGF0ZWRf cGFnZXMobnJfcGFnZXMsIG5vZGUtPmh2bS5wYWdlcyk7CiAgb3V0X2VycjoKIAlyZXR1cm4gZXJy OwogfQpAQCAtODU4LDcgKzg1OCw3IEBAIHN0YXRpYyBpbnQgeGVuYnVzX3VubWFwX3JpbmdfaHZt KHN0cnVjdCB4ZW5idXNfZGV2aWNlICpkZXYsIHZvaWQgKnZhZGRyKQogCQkJICAgICAgIGluZm8u YWRkcnMpOwogCWlmICghcnYpIHsKIAkJdnVubWFwKHZhZGRyKTsKLQkJZnJlZV94ZW5iYWxsb29u ZWRfcGFnZXMobnJfcGFnZXMsIG5vZGUtPmh2bS5wYWdlcyk7CisJCXhlbl9mcmVlX3VucG9wdWxh dGVkX3BhZ2VzKG5yX3BhZ2VzLCBub2RlLT5odm0ucGFnZXMpOwogCX0KIAllbHNlCiAJCVdBUk4o MSwgIkxlYWtpbmcgJXAsIHNpemUgJXUgcGFnZShzKVxuIiwgdmFkZHIsIG5yX3BhZ2VzKTsKZGlm ZiAtLWdpdCBhL2RyaXZlcnMveGVuL3hsYXRlX21tdS5jIGIvZHJpdmVycy94ZW4veGxhdGVfbW11 LmMKaW5kZXggN2IxMDc3ZjBhYmNiLi4zNDc0MmM2ZTE4OWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv eGVuL3hsYXRlX21tdS5jCisrKyBiL2RyaXZlcnMveGVuL3hsYXRlX21tdS5jCkBAIC0yMzIsNyAr MjMyLDcgQEAgaW50IF9faW5pdCB4ZW5feGxhdGVfbWFwX2JhbGxvb25lZF9wYWdlcyh4ZW5fcGZu X3QgKipnZm5zLCB2b2lkICoqdmlydCwKIAkJa2ZyZWUocGFnZXMpOwogCQlyZXR1cm4gLUVOT01F TTsKIAl9Ci0JcmMgPSBhbGxvY194ZW5iYWxsb29uZWRfcGFnZXMobnJfcGFnZXMsIHBhZ2VzKTsK KwlyYyA9IHhlbl9hbGxvY191bnBvcHVsYXRlZF9wYWdlcyhucl9wYWdlcywgcGFnZXMpOwogCWlm IChyYykgewogCQlwcl93YXJuKCIlcyBDb3VsZG4ndCBiYWxsb29uIGFsbG9jICVsZCBwYWdlcyBy YzolZFxuIiwgX19mdW5jX18sCiAJCQlucl9wYWdlcywgcmMpOwpAQCAtMjQ5LDcgKzI0OSw3IEBA IGludCBfX2luaXQgeGVuX3hsYXRlX21hcF9iYWxsb29uZWRfcGFnZXMoeGVuX3Bmbl90ICoqZ2Zu cywgdm9pZCAqKnZpcnQsCiAJaWYgKCF2YWRkcikgewogCQlwcl93YXJuKCIlcyBDb3VsZG4ndCBt YXAgJWxkIHBhZ2VzIHJjOiVkXG4iLCBfX2Z1bmNfXywKIAkJCW5yX3BhZ2VzLCByYyk7Ci0JCWZy ZWVfeGVuYmFsbG9vbmVkX3BhZ2VzKG5yX3BhZ2VzLCBwYWdlcyk7CisJCXhlbl9mcmVlX3VucG9w dWxhdGVkX3BhZ2VzKG5yX3BhZ2VzLCBwYWdlcyk7CiAJCWtmcmVlKHBhZ2VzKTsKIAkJa2ZyZWUo cGZucyk7CiAJCXJldHVybiAtRU5PTUVNOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS94ZW4veGVuLmgg Yi9pbmNsdWRlL3hlbi94ZW4uaAppbmRleCAxOWE3MmY1OTFlMmIuLjQzZWZiYTA0NWFjYyAxMDA2 NDQKLS0tIGEvaW5jbHVkZS94ZW4veGVuLmgKKysrIGIvaW5jbHVkZS94ZW4veGVuLmgKQEAgLTUy LDQgKzUyLDEzIEBAIGJvb2wgeGVuX2Jpb3ZlY19waHlzX21lcmdlYWJsZShjb25zdCBzdHJ1Y3Qg YmlvX3ZlYyAqdmVjMSwKIGV4dGVybiB1NjQgeGVuX3NhdmVkX21heF9tZW1fc2l6ZTsKICNlbmRp ZgogCisjaWZkZWYgQ09ORklHX1hFTl9VTlBPUFVMQVRFRF9BTExPQworaW50IHhlbl9hbGxvY191 bnBvcHVsYXRlZF9wYWdlcyh1bnNpZ25lZCBpbnQgbnJfcGFnZXMsIHN0cnVjdCBwYWdlICoqcGFn ZXMpOwordm9pZCB4ZW5fZnJlZV91bnBvcHVsYXRlZF9wYWdlcyh1bnNpZ25lZCBpbnQgbnJfcGFn ZXMsIHN0cnVjdCBwYWdlICoqcGFnZXMpOworI2Vsc2UKKyNkZWZpbmUgeGVuX2FsbG9jX3VucG9w dWxhdGVkX3BhZ2VzIGFsbG9jX3hlbmJhbGxvb25lZF9wYWdlcworI2RlZmluZSB4ZW5fZnJlZV91 bnBvcHVsYXRlZF9wYWdlcyBmcmVlX3hlbmJhbGxvb25lZF9wYWdlcworI2luY2x1ZGUgPHhlbi9i YWxsb29uLmg+CisjZW5kaWYKKwogI2VuZGlmCS8qIF9YRU5fWEVOX0ggKi8KLS0gCjIuMjguMAoK X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVs IG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlz dHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg== 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=-12.8 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 8F554C433E6 for ; Tue, 1 Sep 2020 08:34:01 +0000 (UTC) Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 40E14206A5 for ; Tue, 1 Sep 2020 08:34:01 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=citrix.com header.i=@citrix.com header.b="hBvtq703" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 40E14206A5 Authentication-Results: mail.kernel.org; dmarc=fail (p=reject dis=none) header.from=citrix.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=xen-devel-bounces@lists.xenproject.org Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1kD1jf-00026s-Aq; Tue, 01 Sep 2020 08:33:47 +0000 Received: from all-amaz-eas1.inumbo.com ([34.197.232.57] helo=us1-amaz-eas2.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1kD1jd-00026N-5x for xen-devel@lists.xenproject.org; Tue, 01 Sep 2020 08:33:45 +0000 X-Inumbo-ID: 72b2754f-b9de-48a7-9ab8-123625447bf8 Received: from esa6.hc3370-68.iphmx.com (unknown [216.71.155.175]) by us1-amaz-eas2.inumbo.com (Halon) with ESMTPS id 72b2754f-b9de-48a7-9ab8-123625447bf8; Tue, 01 Sep 2020 08:33:43 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=citrix.com; s=securemail; t=1598949223; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=QzGqPaRCnZVxjqPpl6AF6iSX77/n0WkY1Cja56OEeNs=; b=hBvtq703CGEh6UWzeErrkwWmcbtYGfKmbc/81GJDEiSTLliyr/AXndhR 32bsqRvudAK2Y63SWpyZ89mVYD6ORoYfimXG7n4kHiCOS9lYOLb4WKOtY TQRD6asZuY+Vij9poAajBePYIwUt6AukNgMLIn4lti/YhYi/6x85dOIiA Y=; Authentication-Results: esa6.hc3370-68.iphmx.com; dkim=none (message not signed) header.i=none IronPort-SDR: P0Ki/2b6mGa7pA1kqv/yHJEYGZ0xQ5RKAnnYciHHQu9+ozbehl7aTLhqS7TsmIqN1+lFdBA2a9 YM8aY9TgwPAc3ZTssNFiElD1kH3pZNZrmb9idWz2MNankSE+bm4Wh4gAgP/HZ0wtix/XOEQxz2 fahYv9vYNdm2yXqMi4Lx8AYZKjX0g3Wz6gC3nv5LsslNCzlzeU2Yxw6gdSPgs+07all1BEuJWf xBsiJhhiZ56EmPvlzqDlvphkbjyBG8gF8aXF6k+tJiRMgpJUdust+wSQCx3dbmJ4nY0YdY+Au0 418= X-SBRS: 2.7 X-MesageID: 26017058 X-Ironport-Server: esa6.hc3370-68.iphmx.com X-Remote-IP: 162.221.158.21 X-Policy: $RELAYED X-IronPort-AV: E=Sophos;i="5.76,378,1592884800"; d="scan'208";a="26017058" From: Roger Pau Monne To: CC: Roger Pau Monne , Oleksandr Andrushchenko , David Airlie , "Daniel Vetter" , Boris Ostrovsky , Juergen Gross , Stefano Stabellini , Dan Carpenter , Wei Liu , "Yan Yankovskyi" , , , , David Hildenbrand , Michal Hocko , Dan Williams Subject: [PATCH v5 3/3] xen: add helpers to allocate unpopulated memory Date: Tue, 1 Sep 2020 10:33:26 +0200 Message-ID: <20200901083326.21264-4-roger.pau@citrix.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20200901083326.21264-1-roger.pau@citrix.com> References: <20200901083326.21264-1-roger.pau@citrix.com> MIME-Version: 1.0 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: 8bit X-BeenThere: xen-devel@lists.xenproject.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" To be used in order to create foreign mappings. This is based on the ZONE_DEVICE facility which is used by persistent memory devices in order to create struct pages and kernel virtual mappings for the IOMEM areas of such devices. Note that on kernels without support for ZONE_DEVICE Xen will fallback to use ballooned pages in order to create foreign mappings. The newly added helpers use the same parameters as the existing {alloc/free}_xenballooned_pages functions, which allows for in-place replacement of the callers. Once a memory region has been added to be used as scratch mapping space it will no longer be released, and pages returned are kept in a linked list. This allows to have a buffer of pages and prevents resorting to frequent additions and removals of regions. If enabled (because ZONE_DEVICE is supported) the usage of the new functionality untangles Xen balloon and RAM hotplug from the usage of unpopulated physical memory ranges to map foreign pages, which is the correct thing to do in order to avoid mappings of foreign pages depend on memory hotplug. Note the driver is currently not enabled on Arm platforms because it would interfere with the identity mapping required on some platforms. Signed-off-by: Roger Pau Monné --- Cc: Oleksandr Andrushchenko Cc: David Airlie Cc: Daniel Vetter Cc: Boris Ostrovsky Cc: Juergen Gross Cc: Stefano Stabellini Cc: Dan Carpenter Cc: Roger Pau Monne Cc: Wei Liu Cc: Yan Yankovskyi Cc: dri-devel@lists.freedesktop.org Cc: xen-devel@lists.xenproject.org Cc: linux-mm@kvack.org Cc: David Hildenbrand Cc: Michal Hocko Cc: Dan Williams --- Changes since v4: - Introduce a description for the option. - Force selection of ZONE_DEVICE on X86 and select XEN_UNPOPULATED_ALLOC if running on dom0 mode or having any backends. Changes since v3: - Introduce a Kconfig option that gates the addition of the unpopulated alloc driver. This allows to easily disable it on Arm platforms. - Dropped Juergen RB due to the addition of the Kconfig option. - Switched from MEMORY_DEVICE_DEVDAX to MEMORY_DEVICE_GENERIC. Changes since v2: - Drop BUILD_BUG_ON regarding PVMMU page sizes. - Use a SPDX license identifier. - Call fill with only the minimum required number of pages. - Include xen.h header in xen_drm_front_gem.c. - Use less generic function names. - Exit early from the init function if not a PV guest. - Don't use all caps for region name. --- drivers/gpu/drm/xen/xen_drm_front_gem.c | 9 +- drivers/xen/Kconfig | 11 ++ drivers/xen/Makefile | 1 + drivers/xen/balloon.c | 4 +- drivers/xen/grant-table.c | 4 +- drivers/xen/privcmd.c | 4 +- drivers/xen/unpopulated-alloc.c | 185 ++++++++++++++++++++++++ drivers/xen/xenbus/xenbus_client.c | 6 +- drivers/xen/xlate_mmu.c | 4 +- include/xen/xen.h | 9 ++ 10 files changed, 222 insertions(+), 15 deletions(-) create mode 100644 drivers/xen/unpopulated-alloc.c diff --git a/drivers/gpu/drm/xen/xen_drm_front_gem.c b/drivers/gpu/drm/xen/xen_drm_front_gem.c index 39ff95b75357..534daf37c97e 100644 --- a/drivers/gpu/drm/xen/xen_drm_front_gem.c +++ b/drivers/gpu/drm/xen/xen_drm_front_gem.c @@ -18,6 +18,7 @@ #include #include +#include #include "xen_drm_front.h" #include "xen_drm_front_gem.h" @@ -99,8 +100,8 @@ static struct xen_gem_object *gem_create(struct drm_device *dev, size_t size) * allocate ballooned pages which will be used to map * grant references provided by the backend */ - ret = alloc_xenballooned_pages(xen_obj->num_pages, - xen_obj->pages); + ret = xen_alloc_unpopulated_pages(xen_obj->num_pages, + xen_obj->pages); if (ret < 0) { DRM_ERROR("Cannot allocate %zu ballooned pages: %d\n", xen_obj->num_pages, ret); @@ -152,8 +153,8 @@ void xen_drm_front_gem_free_object_unlocked(struct drm_gem_object *gem_obj) } else { if (xen_obj->pages) { if (xen_obj->be_alloc) { - free_xenballooned_pages(xen_obj->num_pages, - xen_obj->pages); + xen_free_unpopulated_pages(xen_obj->num_pages, + xen_obj->pages); gem_free_pages_array(xen_obj); } else { drm_gem_put_pages(&xen_obj->base, diff --git a/drivers/xen/Kconfig b/drivers/xen/Kconfig index ea6c1e7e3e42..e38c33558d0d 100644 --- a/drivers/xen/Kconfig +++ b/drivers/xen/Kconfig @@ -325,4 +325,15 @@ config XEN_HAVE_VPMU config XEN_FRONT_PGDIR_SHBUF tristate +config XEN_UNPOPULATED_ALLOC + bool "Use unpopulated memory ranges for guest mappings" + depends on X86 + select ZONE_DEVICE + default XEN_BACKEND || XEN_GNTDEV || XEN_DOM0 + help + Use unpopulated memory ranges in order to create mappings for guest + memory regions, including grant maps and foreign pages. This avoids + having to balloon out RAM regions in order to obtain physical memory + space to create such mappings. + endmenu diff --git a/drivers/xen/Makefile b/drivers/xen/Makefile index c25c9a699b48..babdca808861 100644 --- a/drivers/xen/Makefile +++ b/drivers/xen/Makefile @@ -41,3 +41,4 @@ xen-gntdev-$(CONFIG_XEN_GNTDEV_DMABUF) += gntdev-dmabuf.o xen-gntalloc-y := gntalloc.o xen-privcmd-y := privcmd.o privcmd-buf.o obj-$(CONFIG_XEN_FRONT_PGDIR_SHBUF) += xen-front-pgdir-shbuf.o +obj-$(CONFIG_XEN_UNPOPULATED_ALLOC) += unpopulated-alloc.o diff --git a/drivers/xen/balloon.c b/drivers/xen/balloon.c index 37ffccda8bb8..51427c752b37 100644 --- a/drivers/xen/balloon.c +++ b/drivers/xen/balloon.c @@ -653,7 +653,7 @@ void free_xenballooned_pages(int nr_pages, struct page **pages) } EXPORT_SYMBOL(free_xenballooned_pages); -#ifdef CONFIG_XEN_PV +#if defined(CONFIG_XEN_PV) && !defined(CONFIG_XEN_UNPOPULATED_ALLOC) static void __init balloon_add_region(unsigned long start_pfn, unsigned long pages) { @@ -707,7 +707,7 @@ static int __init balloon_init(void) register_sysctl_table(xen_root); #endif -#ifdef CONFIG_XEN_PV +#if defined(CONFIG_XEN_PV) && !defined(CONFIG_XEN_UNPOPULATED_ALLOC) { int i; diff --git a/drivers/xen/grant-table.c b/drivers/xen/grant-table.c index 8d06bf1cc347..523dcdf39cc9 100644 --- a/drivers/xen/grant-table.c +++ b/drivers/xen/grant-table.c @@ -801,7 +801,7 @@ int gnttab_alloc_pages(int nr_pages, struct page **pages) { int ret; - ret = alloc_xenballooned_pages(nr_pages, pages); + ret = xen_alloc_unpopulated_pages(nr_pages, pages); if (ret < 0) return ret; @@ -836,7 +836,7 @@ EXPORT_SYMBOL_GPL(gnttab_pages_clear_private); void gnttab_free_pages(int nr_pages, struct page **pages) { gnttab_pages_clear_private(nr_pages, pages); - free_xenballooned_pages(nr_pages, pages); + xen_free_unpopulated_pages(nr_pages, pages); } EXPORT_SYMBOL_GPL(gnttab_free_pages); diff --git a/drivers/xen/privcmd.c b/drivers/xen/privcmd.c index 63abe6c3642b..b0c73c58f987 100644 --- a/drivers/xen/privcmd.c +++ b/drivers/xen/privcmd.c @@ -424,7 +424,7 @@ static int alloc_empty_pages(struct vm_area_struct *vma, int numpgs) if (pages == NULL) return -ENOMEM; - rc = alloc_xenballooned_pages(numpgs, pages); + rc = xen_alloc_unpopulated_pages(numpgs, pages); if (rc != 0) { pr_warn("%s Could not alloc %d pfns rc:%d\n", __func__, numpgs, rc); @@ -895,7 +895,7 @@ static void privcmd_close(struct vm_area_struct *vma) rc = xen_unmap_domain_gfn_range(vma, numgfns, pages); if (rc == 0) - free_xenballooned_pages(numpgs, pages); + xen_free_unpopulated_pages(numpgs, pages); else pr_crit("unable to unmap MFN range: leaking %d pages. rc=%d\n", numpgs, rc); diff --git a/drivers/xen/unpopulated-alloc.c b/drivers/xen/unpopulated-alloc.c new file mode 100644 index 000000000000..1b5d157c6977 --- /dev/null +++ b/drivers/xen/unpopulated-alloc.c @@ -0,0 +1,185 @@ +// SPDX-License-Identifier: GPL-2.0 +#include +#include +#include +#include +#include +#include + +#include + +#include +#include + +static DEFINE_MUTEX(list_lock); +static LIST_HEAD(page_list); +static unsigned int list_count; + +static int fill_list(unsigned int nr_pages) +{ + struct dev_pagemap *pgmap; + void *vaddr; + unsigned int i, alloc_pages = round_up(nr_pages, PAGES_PER_SECTION); + int nid, ret; + + pgmap = kzalloc(sizeof(*pgmap), GFP_KERNEL); + if (!pgmap) + return -ENOMEM; + + pgmap->type = MEMORY_DEVICE_GENERIC; + pgmap->res.name = "Xen scratch"; + pgmap->res.flags = IORESOURCE_MEM | IORESOURCE_BUSY; + + ret = allocate_resource(&iomem_resource, &pgmap->res, + alloc_pages * PAGE_SIZE, 0, -1, + PAGES_PER_SECTION * PAGE_SIZE, NULL, NULL); + if (ret < 0) { + pr_err("Cannot allocate new IOMEM resource\n"); + kfree(pgmap); + return ret; + } + + nid = memory_add_physaddr_to_nid(pgmap->res.start); + +#ifdef CONFIG_XEN_HAVE_PVMMU + /* + * memremap will build page tables for the new memory so + * the p2m must contain invalid entries so the correct + * non-present PTEs will be written. + * + * If a failure occurs, the original (identity) p2m entries + * are not restored since this region is now known not to + * conflict with any devices. + */ + if (!xen_feature(XENFEAT_auto_translated_physmap)) { + xen_pfn_t pfn = PFN_DOWN(pgmap->res.start); + + for (i = 0; i < alloc_pages; i++) { + if (!set_phys_to_machine(pfn + i, INVALID_P2M_ENTRY)) { + pr_warn("set_phys_to_machine() failed, no memory added\n"); + release_resource(&pgmap->res); + kfree(pgmap); + return -ENOMEM; + } + } + } +#endif + + vaddr = memremap_pages(pgmap, nid); + if (IS_ERR(vaddr)) { + pr_err("Cannot remap memory range\n"); + release_resource(&pgmap->res); + kfree(pgmap); + return PTR_ERR(vaddr); + } + + for (i = 0; i < alloc_pages; i++) { + struct page *pg = virt_to_page(vaddr + PAGE_SIZE * i); + + BUG_ON(!virt_addr_valid(vaddr + PAGE_SIZE * i)); + list_add(&pg->lru, &page_list); + list_count++; + } + + return 0; +} + +/** + * xen_alloc_unpopulated_pages - alloc unpopulated pages + * @nr_pages: Number of pages + * @pages: pages returned + * @return 0 on success, error otherwise + */ +int xen_alloc_unpopulated_pages(unsigned int nr_pages, struct page **pages) +{ + unsigned int i; + int ret = 0; + + mutex_lock(&list_lock); + if (list_count < nr_pages) { + ret = fill_list(nr_pages - list_count); + if (ret) + goto out; + } + + for (i = 0; i < nr_pages; i++) { + struct page *pg = list_first_entry_or_null(&page_list, + struct page, + lru); + + BUG_ON(!pg); + list_del(&pg->lru); + list_count--; + pages[i] = pg; + +#ifdef CONFIG_XEN_HAVE_PVMMU + if (!xen_feature(XENFEAT_auto_translated_physmap)) { + ret = xen_alloc_p2m_entry(page_to_pfn(pg)); + if (ret < 0) { + unsigned int j; + + for (j = 0; j <= i; j++) { + list_add(&pages[j]->lru, &page_list); + list_count++; + } + goto out; + } + } +#endif + } + +out: + mutex_unlock(&list_lock); + return ret; +} +EXPORT_SYMBOL(xen_alloc_unpopulated_pages); + +/** + * xen_free_unpopulated_pages - return unpopulated pages + * @nr_pages: Number of pages + * @pages: pages to return + */ +void xen_free_unpopulated_pages(unsigned int nr_pages, struct page **pages) +{ + unsigned int i; + + mutex_lock(&list_lock); + for (i = 0; i < nr_pages; i++) { + list_add(&pages[i]->lru, &page_list); + list_count++; + } + mutex_unlock(&list_lock); +} +EXPORT_SYMBOL(xen_free_unpopulated_pages); + +#ifdef CONFIG_XEN_PV +static int __init init(void) +{ + unsigned int i; + + if (!xen_domain()) + return -ENODEV; + + if (!xen_pv_domain()) + return 0; + + /* + * Initialize with pages from the extra memory regions (see + * arch/x86/xen/setup.c). + */ + for (i = 0; i < XEN_EXTRA_MEM_MAX_REGIONS; i++) { + unsigned int j; + + for (j = 0; j < xen_extra_mem[i].n_pfns; j++) { + struct page *pg = + pfn_to_page(xen_extra_mem[i].start_pfn + j); + + list_add(&pg->lru, &page_list); + list_count++; + } + } + + return 0; +} +subsys_initcall(init); +#endif diff --git a/drivers/xen/xenbus/xenbus_client.c b/drivers/xen/xenbus/xenbus_client.c index 907bcbb93afb..2690318ad50f 100644 --- a/drivers/xen/xenbus/xenbus_client.c +++ b/drivers/xen/xenbus/xenbus_client.c @@ -621,7 +621,7 @@ static int xenbus_map_ring_hvm(struct xenbus_device *dev, bool leaked = false; unsigned int nr_pages = XENBUS_PAGES(nr_grefs); - err = alloc_xenballooned_pages(nr_pages, node->hvm.pages); + err = xen_alloc_unpopulated_pages(nr_pages, node->hvm.pages); if (err) goto out_err; @@ -662,7 +662,7 @@ static int xenbus_map_ring_hvm(struct xenbus_device *dev, addr, nr_pages); out_free_ballooned_pages: if (!leaked) - free_xenballooned_pages(nr_pages, node->hvm.pages); + xen_free_unpopulated_pages(nr_pages, node->hvm.pages); out_err: return err; } @@ -858,7 +858,7 @@ static int xenbus_unmap_ring_hvm(struct xenbus_device *dev, void *vaddr) info.addrs); if (!rv) { vunmap(vaddr); - free_xenballooned_pages(nr_pages, node->hvm.pages); + xen_free_unpopulated_pages(nr_pages, node->hvm.pages); } else WARN(1, "Leaking %p, size %u page(s)\n", vaddr, nr_pages); diff --git a/drivers/xen/xlate_mmu.c b/drivers/xen/xlate_mmu.c index 7b1077f0abcb..34742c6e189e 100644 --- a/drivers/xen/xlate_mmu.c +++ b/drivers/xen/xlate_mmu.c @@ -232,7 +232,7 @@ int __init xen_xlate_map_ballooned_pages(xen_pfn_t **gfns, void **virt, kfree(pages); return -ENOMEM; } - rc = alloc_xenballooned_pages(nr_pages, pages); + rc = xen_alloc_unpopulated_pages(nr_pages, pages); if (rc) { pr_warn("%s Couldn't balloon alloc %ld pages rc:%d\n", __func__, nr_pages, rc); @@ -249,7 +249,7 @@ int __init xen_xlate_map_ballooned_pages(xen_pfn_t **gfns, void **virt, if (!vaddr) { pr_warn("%s Couldn't map %ld pages rc:%d\n", __func__, nr_pages, rc); - free_xenballooned_pages(nr_pages, pages); + xen_free_unpopulated_pages(nr_pages, pages); kfree(pages); kfree(pfns); return -ENOMEM; diff --git a/include/xen/xen.h b/include/xen/xen.h index 19a72f591e2b..43efba045acc 100644 --- a/include/xen/xen.h +++ b/include/xen/xen.h @@ -52,4 +52,13 @@ bool xen_biovec_phys_mergeable(const struct bio_vec *vec1, extern u64 xen_saved_max_mem_size; #endif +#ifdef CONFIG_XEN_UNPOPULATED_ALLOC +int xen_alloc_unpopulated_pages(unsigned int nr_pages, struct page **pages); +void xen_free_unpopulated_pages(unsigned int nr_pages, struct page **pages); +#else +#define xen_alloc_unpopulated_pages alloc_xenballooned_pages +#define xen_free_unpopulated_pages free_xenballooned_pages +#include +#endif + #endif /* _XEN_XEN_H */ -- 2.28.0