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 6356DC433DF for ; Tue, 11 Aug 2020 09:45:35 +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 1D98E205CB for ; Tue, 11 Aug 2020 09:45:35 +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="FHh6+IOQ" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 1D98E205CB 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 1k5QqN-0004mB-Tj; Tue, 11 Aug 2020 09:45:19 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1k5QqM-0004ko-HX for xen-devel@lists.xenproject.org; Tue, 11 Aug 2020 09:45:18 +0000 X-Inumbo-ID: ac038769-5dfb-464e-9421-744c9e315f28 Received: from esa2.hc3370-68.iphmx.com (unknown [216.71.145.153]) by us1-rack-iad1.inumbo.com (Halon) with ESMTPS id ac038769-5dfb-464e-9421-744c9e315f28; Tue, 11 Aug 2020 09:45:16 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=citrix.com; s=securemail; t=1597139117; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=hNMxT76XSKdCteUGW9msiopo/AZmHOxBlEJvCXXEBjQ=; b=FHh6+IOQKGQjY0iC8/SF+okEmylW02N+pq7vTLVxrNYf1TybIFE11rLW AKLfOigxYRwJyOTStT3wQEA4XRv8dQCsMyvQsjzmJKzo4tFkrZqzgc8wB sxUD+Vj0QfKpSQe61Tvj444BGlY+8IamsqXoB5gftTTqqqqbUFVYXwSq2 s=; Authentication-Results: esa2.hc3370-68.iphmx.com; dkim=none (message not signed) header.i=none IronPort-SDR: JNy0mE7/pD2oU2ERTgVkOQ0ZhrpqC+8cRTjFWDvQN9ERrYWyfl6g2IOo3tjkeUs4aIEbPf0Uat 8+kcyQkVg3VRsmxwAl8SJMH4o8V/UWSHgrGlgfnaqA+Mj7oY7udJXqhj1qF3Jh9MlqeAbK42ci kRzqLxDwDRNl9nCcNMWYXjWBWTm26c0iTk36VqA7kxES7JKEfRM2VgP4MdPdKQk7l5nkDnm5Ba tVt34JjOgfMrPIUDTNE91m1NZkgVgd/2PVTNDzLkMGJCurfPg8fhkh+7q4PhHALhEqzt2bfovM 3hw= X-SBRS: 2.7 X-MesageID: 24269317 X-Ironport-Server: esa2.hc3370-68.iphmx.com X-Remote-IP: 162.221.158.21 X-Policy: $RELAYED X-IronPort-AV: E=Sophos;i="5.75,460,1589256000"; d="scan'208";a="24269317" From: Roger Pau Monne To: Subject: [PATCH v4 2/2] xen: add helpers to allocate unpopulated memory Date: Tue, 11 Aug 2020 11:44:47 +0200 Message-ID: <20200811094447.31208-3-roger.pau@citrix.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20200811094447.31208-1-roger.pau@citrix.com> References: <20200811094447.31208-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: , 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, Daniel Vetter , xen-devel@lists.xenproject.org, Boris Ostrovsky , Dan Williams , Dan Carpenter , Roger Pau Monne 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 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 | 4 + 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, 215 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 f0b85e094111..270e1bd3e4da 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 1d339ef92422..018020b91baa 100644 --- a/drivers/xen/Kconfig +++ b/drivers/xen/Kconfig @@ -327,4 +327,8 @@ config XEN_HAVE_VPMU config XEN_FRONT_PGDIR_SHBUF tristate +config XEN_UNPOPULATED_ALLOC + bool + default y if ZONE_DEVICE && !ARM && !ARM64 + 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 786fbb7d8be0..70b6c4780fbd 100644 --- a/drivers/xen/xenbus/xenbus_client.c +++ b/drivers/xen/xenbus/xenbus_client.c @@ -615,7 +615,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; @@ -656,7 +656,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; } @@ -852,7 +852,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,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 23C60C433E0 for ; Wed, 12 Aug 2020 07:05:38 +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 E48572053B for ; Wed, 12 Aug 2020 07:05:37 +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="FHh6+IOQ" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org E48572053B 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 1A35E6E8B3; Wed, 12 Aug 2020 07:05:27 +0000 (UTC) Received: from esa2.hc3370-68.iphmx.com (esa2.hc3370-68.iphmx.com [216.71.145.153]) by gabe.freedesktop.org (Postfix) with ESMTPS id BEB6C89EFF for ; Tue, 11 Aug 2020 09:45:16 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=citrix.com; s=securemail; t=1597139117; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=hNMxT76XSKdCteUGW9msiopo/AZmHOxBlEJvCXXEBjQ=; b=FHh6+IOQKGQjY0iC8/SF+okEmylW02N+pq7vTLVxrNYf1TybIFE11rLW AKLfOigxYRwJyOTStT3wQEA4XRv8dQCsMyvQsjzmJKzo4tFkrZqzgc8wB sxUD+Vj0QfKpSQe61Tvj444BGlY+8IamsqXoB5gftTTqqqqbUFVYXwSq2 s=; Authentication-Results: esa2.hc3370-68.iphmx.com; dkim=none (message not signed) header.i=none IronPort-SDR: JNy0mE7/pD2oU2ERTgVkOQ0ZhrpqC+8cRTjFWDvQN9ERrYWyfl6g2IOo3tjkeUs4aIEbPf0Uat 8+kcyQkVg3VRsmxwAl8SJMH4o8V/UWSHgrGlgfnaqA+Mj7oY7udJXqhj1qF3Jh9MlqeAbK42ci kRzqLxDwDRNl9nCcNMWYXjWBWTm26c0iTk36VqA7kxES7JKEfRM2VgP4MdPdKQk7l5nkDnm5Ba tVt34JjOgfMrPIUDTNE91m1NZkgVgd/2PVTNDzLkMGJCurfPg8fhkh+7q4PhHALhEqzt2bfovM 3hw= X-SBRS: 2.7 X-MesageID: 24269317 X-Ironport-Server: esa2.hc3370-68.iphmx.com X-Remote-IP: 162.221.158.21 X-Policy: $RELAYED X-IronPort-AV: E=Sophos;i="5.75,460,1589256000"; d="scan'208";a="24269317" From: Roger Pau Monne To: Subject: [PATCH v4 2/2] xen: add helpers to allocate unpopulated memory Date: Tue, 11 Aug 2020 11:44:47 +0200 Message-ID: <20200811094447.31208-3-roger.pau@citrix.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20200811094447.31208-1-roger.pau@citrix.com> References: <20200811094447.31208-1-roger.pau@citrix.com> MIME-Version: 1.0 X-Mailman-Approved-At: Wed, 12 Aug 2020 07:05:21 +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+Ci0tLQpDaGFuZ2VzIHNpbmNlIHYz OgogLSBJbnRyb2R1Y2UgYSBLY29uZmlnIG9wdGlvbiB0aGF0IGdhdGVzIHRoZSBhZGRpdGlvbiBv ZiB0aGUKICAgdW5wb3B1bGF0ZWQgYWxsb2MgZHJpdmVyLiBUaGlzIGFsbG93cyB0byBlYXNpbHkg ZGlzYWJsZSBpdCBvbiBBcm0KICAgcGxhdGZvcm1zLgogLSBEcm9wcGVkIEp1ZXJnZW4gUkIgZHVl IHRvIHRoZSBhZGRpdGlvbiBvZiB0aGUgS2NvbmZpZyBvcHRpb24uCiAtIFN3aXRjaGVkIGZyb20g TUVNT1JZX0RFVklDRV9ERVZEQVggdG8gTUVNT1JZX0RFVklDRV9HRU5FUklDLgoKQ2hhbmdlcyBz aW5jZSB2MjoKIC0gRHJvcCBCVUlMRF9CVUdfT04gcmVnYXJkaW5nIFBWTU1VIHBhZ2Ugc2l6ZXMu CiAtIFVzZSBhIFNQRFggbGljZW5zZSBpZGVudGlmaWVyLgogLSBDYWxsIGZpbGwgd2l0aCBvbmx5 IHRoZSBtaW5pbXVtIHJlcXVpcmVkIG51bWJlciBvZiBwYWdlcy4KIC0gSW5jbHVkZSB4ZW4uaCBo ZWFkZXIgaW4geGVuX2RybV9mcm9udF9nZW0uYy4KIC0gVXNlIGxlc3MgZ2VuZXJpYyBmdW5jdGlv biBuYW1lcy4KIC0gRXhpdCBlYXJseSBmcm9tIHRoZSBpbml0IGZ1bmN0aW9uIGlmIG5vdCBhIFBW IGd1ZXN0LgogLSBEb24ndCB1c2UgYWxsIGNhcHMgZm9yIHJlZ2lvbiBuYW1lLgotLS0KIGRyaXZl cnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9nZW0uYyB8ICAgOSArLQogZHJpdmVycy94ZW4v S2NvbmZpZyAgICAgICAgICAgICAgICAgICAgIHwgICA0ICsKIGRyaXZlcnMveGVuL01ha2VmaWxl ICAgICAgICAgICAgICAgICAgICB8ICAgMSArCiBkcml2ZXJzL3hlbi9iYWxsb29uLmMgICAgICAg ICAgICAgICAgICAgfCAgIDQgKy0KIGRyaXZlcnMveGVuL2dyYW50LXRhYmxlLmMgICAgICAgICAg ICAgICB8ICAgNCArLQogZHJpdmVycy94ZW4vcHJpdmNtZC5jICAgICAgICAgICAgICAgICAgIHwg ICA0ICstCiBkcml2ZXJzL3hlbi91bnBvcHVsYXRlZC1hbGxvYy5jICAgICAgICAgfCAxODUgKysr KysrKysrKysrKysrKysrKysrKysrCiBkcml2ZXJzL3hlbi94ZW5idXMveGVuYnVzX2NsaWVudC5j ICAgICAgfCAgIDYgKy0KIGRyaXZlcnMveGVuL3hsYXRlX21tdS5jICAgICAgICAgICAgICAgICB8 ICAgNCArLQogaW5jbHVkZS94ZW4veGVuLmggICAgICAgICAgICAgICAgICAgICAgIHwgICA5ICsr CiAxMCBmaWxlcyBjaGFuZ2VkLCAyMTUgaW5zZXJ0aW9ucygrKSwgMTUgZGVsZXRpb25zKC0pCiBj cmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy94ZW4vdW5wb3B1bGF0ZWQtYWxsb2MuYwoKZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9nZW0uYyBiL2RyaXZlcnMv Z3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9nZW0uYwppbmRleCBmMGI4NWUwOTQxMTEuLjI3MGUx YmQzZTRkYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2dl bS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9nZW0uYwpAQCAtMTgs NiArMTgsNyBAQAogI2luY2x1ZGUgPGRybS9kcm1fcHJvYmVfaGVscGVyLmg+CiAKICNpbmNsdWRl IDx4ZW4vYmFsbG9vbi5oPgorI2luY2x1ZGUgPHhlbi94ZW4uaD4KIAogI2luY2x1ZGUgInhlbl9k cm1fZnJvbnQuaCIKICNpbmNsdWRlICJ4ZW5fZHJtX2Zyb250X2dlbS5oIgpAQCAtOTksOCArMTAw LDggQEAgc3RhdGljIHN0cnVjdCB4ZW5fZ2VtX29iamVjdCAqZ2VtX2NyZWF0ZShzdHJ1Y3QgZHJt X2RldmljZSAqZGV2LCBzaXplX3Qgc2l6ZSkKIAkJICogYWxsb2NhdGUgYmFsbG9vbmVkIHBhZ2Vz IHdoaWNoIHdpbGwgYmUgdXNlZCB0byBtYXAKIAkJICogZ3JhbnQgcmVmZXJlbmNlcyBwcm92aWRl ZCBieSB0aGUgYmFja2VuZAogCQkgKi8KLQkJcmV0ID0gYWxsb2NfeGVuYmFsbG9vbmVkX3BhZ2Vz KHhlbl9vYmotPm51bV9wYWdlcywKLQkJCQkJICAgICAgIHhlbl9vYmotPnBhZ2VzKTsKKwkJcmV0 ID0geGVuX2FsbG9jX3VucG9wdWxhdGVkX3BhZ2VzKHhlbl9vYmotPm51bV9wYWdlcywKKwkJCQkJ ICAgICAgICAgIHhlbl9vYmotPnBhZ2VzKTsKIAkJaWYgKHJldCA8IDApIHsKIAkJCURSTV9FUlJP UigiQ2Fubm90IGFsbG9jYXRlICV6dSBiYWxsb29uZWQgcGFnZXM6ICVkXG4iLAogCQkJCSAgeGVu X29iai0+bnVtX3BhZ2VzLCByZXQpOwpAQCAtMTUyLDggKzE1Myw4IEBAIHZvaWQgeGVuX2RybV9m cm9udF9nZW1fZnJlZV9vYmplY3RfdW5sb2NrZWQoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpnZW1f b2JqKQogCX0gZWxzZSB7CiAJCWlmICh4ZW5fb2JqLT5wYWdlcykgewogCQkJaWYgKHhlbl9vYmot PmJlX2FsbG9jKSB7Ci0JCQkJZnJlZV94ZW5iYWxsb29uZWRfcGFnZXMoeGVuX29iai0+bnVtX3Bh Z2VzLAotCQkJCQkJCXhlbl9vYmotPnBhZ2VzKTsKKwkJCQl4ZW5fZnJlZV91bnBvcHVsYXRlZF9w YWdlcyh4ZW5fb2JqLT5udW1fcGFnZXMsCisJCQkJCQkJICAgeGVuX29iai0+cGFnZXMpOwogCQkJ CWdlbV9mcmVlX3BhZ2VzX2FycmF5KHhlbl9vYmopOwogCQkJfSBlbHNlIHsKIAkJCQlkcm1fZ2Vt X3B1dF9wYWdlcygmeGVuX29iai0+YmFzZSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL0tjb25m aWcgYi9kcml2ZXJzL3hlbi9LY29uZmlnCmluZGV4IDFkMzM5ZWY5MjQyMi4uMDE4MDIwYjkxYmFh IDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi9LY29uZmlnCisrKyBiL2RyaXZlcnMveGVuL0tjb25m aWcKQEAgLTMyNyw0ICszMjcsOCBAQCBjb25maWcgWEVOX0hBVkVfVlBNVQogY29uZmlnIFhFTl9G Uk9OVF9QR0RJUl9TSEJVRgogCXRyaXN0YXRlCiAKK2NvbmZpZyBYRU5fVU5QT1BVTEFURURfQUxM T0MKKwlib29sCisJZGVmYXVsdCB5IGlmIFpPTkVfREVWSUNFICYmICFBUk0gJiYgIUFSTTY0CisK IGVuZG1lbnUKZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL01ha2VmaWxlIGIvZHJpdmVycy94ZW4v TWFrZWZpbGUKaW5kZXggYzI1YzlhNjk5YjQ4Li5iYWJkY2E4MDg4NjEgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMveGVuL01ha2VmaWxlCisrKyBiL2RyaXZlcnMveGVuL01ha2VmaWxlCkBAIC00MSwzICs0 MSw0IEBAIHhlbi1nbnRkZXYtJChDT05GSUdfWEVOX0dOVERFVl9ETUFCVUYpCSs9IGdudGRldi1k bWFidWYubwogeGVuLWdudGFsbG9jLXkJCQkJOj0gZ250YWxsb2MubwogeGVuLXByaXZjbWQteQkJ CQk6PSBwcml2Y21kLm8gcHJpdmNtZC1idWYubwogb2JqLSQoQ09ORklHX1hFTl9GUk9OVF9QR0RJ Ul9TSEJVRikJKz0geGVuLWZyb250LXBnZGlyLXNoYnVmLm8KK29iai0kKENPTkZJR19YRU5fVU5Q T1BVTEFURURfQUxMT0MpCSs9IHVucG9wdWxhdGVkLWFsbG9jLm8KZGlmZiAtLWdpdCBhL2RyaXZl cnMveGVuL2JhbGxvb24uYyBiL2RyaXZlcnMveGVuL2JhbGxvb24uYwppbmRleCAzN2ZmY2NkYThi YjguLjUxNDI3Yzc1MmIzNyAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vYmFsbG9vbi5jCisrKyBi L2RyaXZlcnMveGVuL2JhbGxvb24uYwpAQCAtNjUzLDcgKzY1Myw3IEBAIHZvaWQgZnJlZV94ZW5i YWxsb29uZWRfcGFnZXMoaW50IG5yX3BhZ2VzLCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKQogfQogRVhQ T1JUX1NZTUJPTChmcmVlX3hlbmJhbGxvb25lZF9wYWdlcyk7CiAKLSNpZmRlZiBDT05GSUdfWEVO X1BWCisjaWYgZGVmaW5lZChDT05GSUdfWEVOX1BWKSAmJiAhZGVmaW5lZChDT05GSUdfWEVOX1VO UE9QVUxBVEVEX0FMTE9DKQogc3RhdGljIHZvaWQgX19pbml0IGJhbGxvb25fYWRkX3JlZ2lvbih1 bnNpZ25lZCBsb25nIHN0YXJ0X3BmbiwKIAkJCQkgICAgICB1bnNpZ25lZCBsb25nIHBhZ2VzKQog ewpAQCAtNzA3LDcgKzcwNyw3IEBAIHN0YXRpYyBpbnQgX19pbml0IGJhbGxvb25faW5pdCh2b2lk KQogCXJlZ2lzdGVyX3N5c2N0bF90YWJsZSh4ZW5fcm9vdCk7CiAjZW5kaWYKIAotI2lmZGVmIENP TkZJR19YRU5fUFYKKyNpZiBkZWZpbmVkKENPTkZJR19YRU5fUFYpICYmICFkZWZpbmVkKENPTkZJ R19YRU5fVU5QT1BVTEFURURfQUxMT0MpCiAJewogCQlpbnQgaTsKIApkaWZmIC0tZ2l0IGEvZHJp dmVycy94ZW4vZ3JhbnQtdGFibGUuYyBiL2RyaXZlcnMveGVuL2dyYW50LXRhYmxlLmMKaW5kZXgg OGQwNmJmMWNjMzQ3Li41MjNkY2RmMzljYzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL2dyYW50 LXRhYmxlLmMKKysrIGIvZHJpdmVycy94ZW4vZ3JhbnQtdGFibGUuYwpAQCAtODAxLDcgKzgwMSw3 IEBAIGludCBnbnR0YWJfYWxsb2NfcGFnZXMoaW50IG5yX3BhZ2VzLCBzdHJ1Y3QgcGFnZSAqKnBh Z2VzKQogewogCWludCByZXQ7CiAKLQlyZXQgPSBhbGxvY194ZW5iYWxsb29uZWRfcGFnZXMobnJf cGFnZXMsIHBhZ2VzKTsKKwlyZXQgPSB4ZW5fYWxsb2NfdW5wb3B1bGF0ZWRfcGFnZXMobnJfcGFn ZXMsIHBhZ2VzKTsKIAlpZiAocmV0IDwgMCkKIAkJcmV0dXJuIHJldDsKIApAQCAtODM2LDcgKzgz Niw3IEBAIEVYUE9SVF9TWU1CT0xfR1BMKGdudHRhYl9wYWdlc19jbGVhcl9wcml2YXRlKTsKIHZv aWQgZ250dGFiX2ZyZWVfcGFnZXMoaW50IG5yX3BhZ2VzLCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKQog ewogCWdudHRhYl9wYWdlc19jbGVhcl9wcml2YXRlKG5yX3BhZ2VzLCBwYWdlcyk7Ci0JZnJlZV94 ZW5iYWxsb29uZWRfcGFnZXMobnJfcGFnZXMsIHBhZ2VzKTsKKwl4ZW5fZnJlZV91bnBvcHVsYXRl ZF9wYWdlcyhucl9wYWdlcywgcGFnZXMpOwogfQogRVhQT1JUX1NZTUJPTF9HUEwoZ250dGFiX2Zy ZWVfcGFnZXMpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9wcml2Y21kLmMgYi9kcml2ZXJz L3hlbi9wcml2Y21kLmMKaW5kZXggNjNhYmU2YzM2NDJiLi5iMGM3M2M1OGY5ODcgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMveGVuL3ByaXZjbWQuYworKysgYi9kcml2ZXJzL3hlbi9wcml2Y21kLmMKQEAg LTQyNCw3ICs0MjQsNyBAQCBzdGF0aWMgaW50IGFsbG9jX2VtcHR5X3BhZ2VzKHN0cnVjdCB2bV9h cmVhX3N0cnVjdCAqdm1hLCBpbnQgbnVtcGdzKQogCWlmIChwYWdlcyA9PSBOVUxMKQogCQlyZXR1 cm4gLUVOT01FTTsKIAotCXJjID0gYWxsb2NfeGVuYmFsbG9vbmVkX3BhZ2VzKG51bXBncywgcGFn ZXMpOworCXJjID0geGVuX2FsbG9jX3VucG9wdWxhdGVkX3BhZ2VzKG51bXBncywgcGFnZXMpOwog CWlmIChyYyAhPSAwKSB7CiAJCXByX3dhcm4oIiVzIENvdWxkIG5vdCBhbGxvYyAlZCBwZm5zIHJj OiVkXG4iLCBfX2Z1bmNfXywKIAkJCW51bXBncywgcmMpOwpAQCAtODk1LDcgKzg5NSw3IEBAIHN0 YXRpYyB2b2lkIHByaXZjbWRfY2xvc2Uoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCiAKIAly YyA9IHhlbl91bm1hcF9kb21haW5fZ2ZuX3JhbmdlKHZtYSwgbnVtZ2ZucywgcGFnZXMpOwogCWlm IChyYyA9PSAwKQotCQlmcmVlX3hlbmJhbGxvb25lZF9wYWdlcyhudW1wZ3MsIHBhZ2VzKTsKKwkJ eGVuX2ZyZWVfdW5wb3B1bGF0ZWRfcGFnZXMobnVtcGdzLCBwYWdlcyk7CiAJZWxzZQogCQlwcl9j cml0KCJ1bmFibGUgdG8gdW5tYXAgTUZOIHJhbmdlOiBsZWFraW5nICVkIHBhZ2VzLiByYz0lZFxu IiwKIAkJCW51bXBncywgcmMpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vdW5wb3B1bGF0ZWQt YWxsb2MuYyBiL2RyaXZlcnMveGVuL3VucG9wdWxhdGVkLWFsbG9jLmMKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4xYjVkMTU3YzY5NzcKLS0tIC9kZXYvbnVsbAorKysg Yi9kcml2ZXJzL3hlbi91bnBvcHVsYXRlZC1hbGxvYy5jCkBAIC0wLDAgKzEsMTg1IEBACisvLyBT UERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAorI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+ CisjaW5jbHVkZSA8bGludXgvZ2ZwLmg+CisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5j bHVkZSA8bGludXgvbW0uaD4KKyNpbmNsdWRlIDxsaW51eC9tZW1yZW1hcC5oPgorI2luY2x1ZGUg PGxpbnV4L3NsYWIuaD4KKworI2luY2x1ZGUgPGFzbS9wYWdlLmg+CisKKyNpbmNsdWRlIDx4ZW4v cGFnZS5oPgorI2luY2x1ZGUgPHhlbi94ZW4uaD4KKworc3RhdGljIERFRklORV9NVVRFWChsaXN0 X2xvY2spOworc3RhdGljIExJU1RfSEVBRChwYWdlX2xpc3QpOworc3RhdGljIHVuc2lnbmVkIGlu dCBsaXN0X2NvdW50OworCitzdGF0aWMgaW50IGZpbGxfbGlzdCh1bnNpZ25lZCBpbnQgbnJfcGFn ZXMpCit7CisJc3RydWN0IGRldl9wYWdlbWFwICpwZ21hcDsKKwl2b2lkICp2YWRkcjsKKwl1bnNp Z25lZCBpbnQgaSwgYWxsb2NfcGFnZXMgPSByb3VuZF91cChucl9wYWdlcywgUEFHRVNfUEVSX1NF Q1RJT04pOworCWludCBuaWQsIHJldDsKKworCXBnbWFwID0ga3phbGxvYyhzaXplb2YoKnBnbWFw KSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFwZ21hcCkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlwZ21h cC0+dHlwZSA9IE1FTU9SWV9ERVZJQ0VfR0VORVJJQzsKKwlwZ21hcC0+cmVzLm5hbWUgPSAiWGVu IHNjcmF0Y2giOworCXBnbWFwLT5yZXMuZmxhZ3MgPSBJT1JFU09VUkNFX01FTSB8IElPUkVTT1VS Q0VfQlVTWTsKKworCXJldCA9IGFsbG9jYXRlX3Jlc291cmNlKCZpb21lbV9yZXNvdXJjZSwgJnBn bWFwLT5yZXMsCisJCQkJYWxsb2NfcGFnZXMgKiBQQUdFX1NJWkUsIDAsIC0xLAorCQkJCVBBR0VT X1BFUl9TRUNUSU9OICogUEFHRV9TSVpFLCBOVUxMLCBOVUxMKTsKKwlpZiAocmV0IDwgMCkgewor CQlwcl9lcnIoIkNhbm5vdCBhbGxvY2F0ZSBuZXcgSU9NRU0gcmVzb3VyY2VcbiIpOworCQlrZnJl ZShwZ21hcCk7CisJCXJldHVybiByZXQ7CisJfQorCisJbmlkID0gbWVtb3J5X2FkZF9waHlzYWRk cl90b19uaWQocGdtYXAtPnJlcy5zdGFydCk7CisKKyNpZmRlZiBDT05GSUdfWEVOX0hBVkVfUFZN TVUKKyAgICAgICAgLyoKKyAgICAgICAgICogbWVtcmVtYXAgd2lsbCBidWlsZCBwYWdlIHRhYmxl cyBmb3IgdGhlIG5ldyBtZW1vcnkgc28KKyAgICAgICAgICogdGhlIHAybSBtdXN0IGNvbnRhaW4g aW52YWxpZCBlbnRyaWVzIHNvIHRoZSBjb3JyZWN0CisgICAgICAgICAqIG5vbi1wcmVzZW50IFBU RXMgd2lsbCBiZSB3cml0dGVuLgorICAgICAgICAgKgorICAgICAgICAgKiBJZiBhIGZhaWx1cmUg b2NjdXJzLCB0aGUgb3JpZ2luYWwgKGlkZW50aXR5KSBwMm0gZW50cmllcworICAgICAgICAgKiBh cmUgbm90IHJlc3RvcmVkIHNpbmNlIHRoaXMgcmVnaW9uIGlzIG5vdyBrbm93biBub3QgdG8KKyAg ICAgICAgICogY29uZmxpY3Qgd2l0aCBhbnkgZGV2aWNlcy4KKyAgICAgICAgICovCisJaWYgKCF4 ZW5fZmVhdHVyZShYRU5GRUFUX2F1dG9fdHJhbnNsYXRlZF9waHlzbWFwKSkgeworCQl4ZW5fcGZu X3QgcGZuID0gUEZOX0RPV04ocGdtYXAtPnJlcy5zdGFydCk7CisKKwkJZm9yIChpID0gMDsgaSA8 IGFsbG9jX3BhZ2VzOyBpKyspIHsKKwkJCWlmICghc2V0X3BoeXNfdG9fbWFjaGluZShwZm4gKyBp LCBJTlZBTElEX1AyTV9FTlRSWSkpIHsKKwkJCQlwcl93YXJuKCJzZXRfcGh5c190b19tYWNoaW5l KCkgZmFpbGVkLCBubyBtZW1vcnkgYWRkZWRcbiIpOworCQkJCXJlbGVhc2VfcmVzb3VyY2UoJnBn bWFwLT5yZXMpOworCQkJCWtmcmVlKHBnbWFwKTsKKwkJCQlyZXR1cm4gLUVOT01FTTsKKwkJCX0K KyAgICAgICAgICAgICAgICB9CisJfQorI2VuZGlmCisKKwl2YWRkciA9IG1lbXJlbWFwX3BhZ2Vz KHBnbWFwLCBuaWQpOworCWlmIChJU19FUlIodmFkZHIpKSB7CisJCXByX2VycigiQ2Fubm90IHJl bWFwIG1lbW9yeSByYW5nZVxuIik7CisJCXJlbGVhc2VfcmVzb3VyY2UoJnBnbWFwLT5yZXMpOwor CQlrZnJlZShwZ21hcCk7CisJCXJldHVybiBQVFJfRVJSKHZhZGRyKTsKKwl9CisKKwlmb3IgKGkg PSAwOyBpIDwgYWxsb2NfcGFnZXM7IGkrKykgeworCQlzdHJ1Y3QgcGFnZSAqcGcgPSB2aXJ0X3Rv X3BhZ2UodmFkZHIgKyBQQUdFX1NJWkUgKiBpKTsKKworCQlCVUdfT04oIXZpcnRfYWRkcl92YWxp ZCh2YWRkciArIFBBR0VfU0laRSAqIGkpKTsKKwkJbGlzdF9hZGQoJnBnLT5scnUsICZwYWdlX2xp c3QpOworCQlsaXN0X2NvdW50Kys7CisJfQorCisJcmV0dXJuIDA7Cit9CisKKy8qKgorICogeGVu X2FsbG9jX3VucG9wdWxhdGVkX3BhZ2VzIC0gYWxsb2MgdW5wb3B1bGF0ZWQgcGFnZXMKKyAqIEBu cl9wYWdlczogTnVtYmVyIG9mIHBhZ2VzCisgKiBAcGFnZXM6IHBhZ2VzIHJldHVybmVkCisgKiBA cmV0dXJuIDAgb24gc3VjY2VzcywgZXJyb3Igb3RoZXJ3aXNlCisgKi8KK2ludCB4ZW5fYWxsb2Nf dW5wb3B1bGF0ZWRfcGFnZXModW5zaWduZWQgaW50IG5yX3BhZ2VzLCBzdHJ1Y3QgcGFnZSAqKnBh Z2VzKQoreworCXVuc2lnbmVkIGludCBpOworCWludCByZXQgPSAwOworCisJbXV0ZXhfbG9jaygm bGlzdF9sb2NrKTsKKwlpZiAobGlzdF9jb3VudCA8IG5yX3BhZ2VzKSB7CisJCXJldCA9IGZpbGxf bGlzdChucl9wYWdlcyAtIGxpc3RfY291bnQpOworCQlpZiAocmV0KQorCQkJZ290byBvdXQ7CisJ fQorCisJZm9yIChpID0gMDsgaSA8IG5yX3BhZ2VzOyBpKyspIHsKKwkJc3RydWN0IHBhZ2UgKnBn ID0gbGlzdF9maXJzdF9lbnRyeV9vcl9udWxsKCZwYWdlX2xpc3QsCisJCQkJCQkJICAgc3RydWN0 IHBhZ2UsCisJCQkJCQkJICAgbHJ1KTsKKworCQlCVUdfT04oIXBnKTsKKwkJbGlzdF9kZWwoJnBn LT5scnUpOworCQlsaXN0X2NvdW50LS07CisJCXBhZ2VzW2ldID0gcGc7CisKKyNpZmRlZiBDT05G SUdfWEVOX0hBVkVfUFZNTVUKKwkJaWYgKCF4ZW5fZmVhdHVyZShYRU5GRUFUX2F1dG9fdHJhbnNs YXRlZF9waHlzbWFwKSkgeworCQkJcmV0ID0geGVuX2FsbG9jX3AybV9lbnRyeShwYWdlX3RvX3Bm bihwZykpOworCQkJaWYgKHJldCA8IDApIHsKKwkJCQl1bnNpZ25lZCBpbnQgajsKKworCQkJCWZv ciAoaiA9IDA7IGogPD0gaTsgaisrKSB7CisJCQkJCWxpc3RfYWRkKCZwYWdlc1tqXS0+bHJ1LCAm cGFnZV9saXN0KTsKKwkJCQkJbGlzdF9jb3VudCsrOworCQkJCX0KKwkJCQlnb3RvIG91dDsKKwkJ CX0KKwkJfQorI2VuZGlmCisJfQorCitvdXQ6CisJbXV0ZXhfdW5sb2NrKCZsaXN0X2xvY2spOwor CXJldHVybiByZXQ7Cit9CitFWFBPUlRfU1lNQk9MKHhlbl9hbGxvY191bnBvcHVsYXRlZF9wYWdl cyk7CisKKy8qKgorICogeGVuX2ZyZWVfdW5wb3B1bGF0ZWRfcGFnZXMgLSByZXR1cm4gdW5wb3B1 bGF0ZWQgcGFnZXMKKyAqIEBucl9wYWdlczogTnVtYmVyIG9mIHBhZ2VzCisgKiBAcGFnZXM6IHBh Z2VzIHRvIHJldHVybgorICovCit2b2lkIHhlbl9mcmVlX3VucG9wdWxhdGVkX3BhZ2VzKHVuc2ln bmVkIGludCBucl9wYWdlcywgc3RydWN0IHBhZ2UgKipwYWdlcykKK3sKKwl1bnNpZ25lZCBpbnQg aTsKKworCW11dGV4X2xvY2soJmxpc3RfbG9jayk7CisJZm9yIChpID0gMDsgaSA8IG5yX3BhZ2Vz OyBpKyspIHsKKwkJbGlzdF9hZGQoJnBhZ2VzW2ldLT5scnUsICZwYWdlX2xpc3QpOworCQlsaXN0 X2NvdW50Kys7CisJfQorCW11dGV4X3VubG9jaygmbGlzdF9sb2NrKTsKK30KK0VYUE9SVF9TWU1C T0woeGVuX2ZyZWVfdW5wb3B1bGF0ZWRfcGFnZXMpOworCisjaWZkZWYgQ09ORklHX1hFTl9QVgor c3RhdGljIGludCBfX2luaXQgaW5pdCh2b2lkKQoreworCXVuc2lnbmVkIGludCBpOworCisJaWYg KCF4ZW5fZG9tYWluKCkpCisJCXJldHVybiAtRU5PREVWOworCisJaWYgKCF4ZW5fcHZfZG9tYWlu KCkpCisJCXJldHVybiAwOworCisJLyoKKwkgKiBJbml0aWFsaXplIHdpdGggcGFnZXMgZnJvbSB0 aGUgZXh0cmEgbWVtb3J5IHJlZ2lvbnMgKHNlZQorCSAqIGFyY2gveDg2L3hlbi9zZXR1cC5jKS4K KwkgKi8KKwlmb3IgKGkgPSAwOyBpIDwgWEVOX0VYVFJBX01FTV9NQVhfUkVHSU9OUzsgaSsrKSB7 CisJCXVuc2lnbmVkIGludCBqOworCisJCWZvciAoaiA9IDA7IGogPCB4ZW5fZXh0cmFfbWVtW2ld Lm5fcGZuczsgaisrKSB7CisJCQlzdHJ1Y3QgcGFnZSAqcGcgPQorCQkJCXBmbl90b19wYWdlKHhl bl9leHRyYV9tZW1baV0uc3RhcnRfcGZuICsgaik7CisKKwkJCWxpc3RfYWRkKCZwZy0+bHJ1LCAm cGFnZV9saXN0KTsKKwkJCWxpc3RfY291bnQrKzsKKwkJfQorCX0KKworCXJldHVybiAwOworfQor c3Vic3lzX2luaXRjYWxsKGluaXQpOworI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi94 ZW5idXMveGVuYnVzX2NsaWVudC5jIGIvZHJpdmVycy94ZW4veGVuYnVzL3hlbmJ1c19jbGllbnQu YwppbmRleCA3ODZmYmI3ZDhiZTAuLjcwYjZjNDc4MGZiZCAxMDA2NDQKLS0tIGEvZHJpdmVycy94 ZW4veGVuYnVzL3hlbmJ1c19jbGllbnQuYworKysgYi9kcml2ZXJzL3hlbi94ZW5idXMveGVuYnVz X2NsaWVudC5jCkBAIC02MTUsNyArNjE1LDcgQEAgc3RhdGljIGludCB4ZW5idXNfbWFwX3Jpbmdf aHZtKHN0cnVjdCB4ZW5idXNfZGV2aWNlICpkZXYsCiAJYm9vbCBsZWFrZWQgPSBmYWxzZTsKIAl1 bnNpZ25lZCBpbnQgbnJfcGFnZXMgPSBYRU5CVVNfUEFHRVMobnJfZ3JlZnMpOwogCi0JZXJyID0g YWxsb2NfeGVuYmFsbG9vbmVkX3BhZ2VzKG5yX3BhZ2VzLCBub2RlLT5odm0ucGFnZXMpOworCWVy ciA9IHhlbl9hbGxvY191bnBvcHVsYXRlZF9wYWdlcyhucl9wYWdlcywgbm9kZS0+aHZtLnBhZ2Vz KTsKIAlpZiAoZXJyKQogCQlnb3RvIG91dF9lcnI7CiAKQEAgLTY1Niw3ICs2NTYsNyBAQCBzdGF0 aWMgaW50IHhlbmJ1c19tYXBfcmluZ19odm0oc3RydWN0IHhlbmJ1c19kZXZpY2UgKmRldiwKIAkJ CSBhZGRyLCBucl9wYWdlcyk7CiAgb3V0X2ZyZWVfYmFsbG9vbmVkX3BhZ2VzOgogCWlmICghbGVh a2VkKQotCQlmcmVlX3hlbmJhbGxvb25lZF9wYWdlcyhucl9wYWdlcywgbm9kZS0+aHZtLnBhZ2Vz KTsKKwkJeGVuX2ZyZWVfdW5wb3B1bGF0ZWRfcGFnZXMobnJfcGFnZXMsIG5vZGUtPmh2bS5wYWdl cyk7CiAgb3V0X2VycjoKIAlyZXR1cm4gZXJyOwogfQpAQCAtODUyLDcgKzg1Miw3IEBAIHN0YXRp YyBpbnQgeGVuYnVzX3VubWFwX3JpbmdfaHZtKHN0cnVjdCB4ZW5idXNfZGV2aWNlICpkZXYsIHZv aWQgKnZhZGRyKQogCQkJICAgICAgIGluZm8uYWRkcnMpOwogCWlmICghcnYpIHsKIAkJdnVubWFw KHZhZGRyKTsKLQkJZnJlZV94ZW5iYWxsb29uZWRfcGFnZXMobnJfcGFnZXMsIG5vZGUtPmh2bS5w YWdlcyk7CisJCXhlbl9mcmVlX3VucG9wdWxhdGVkX3BhZ2VzKG5yX3BhZ2VzLCBub2RlLT5odm0u cGFnZXMpOwogCX0KIAllbHNlCiAJCVdBUk4oMSwgIkxlYWtpbmcgJXAsIHNpemUgJXUgcGFnZShz KVxuIiwgdmFkZHIsIG5yX3BhZ2VzKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL3hsYXRlX21t dS5jIGIvZHJpdmVycy94ZW4veGxhdGVfbW11LmMKaW5kZXggN2IxMDc3ZjBhYmNiLi4zNDc0MmM2 ZTE4OWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL3hsYXRlX21tdS5jCisrKyBiL2RyaXZlcnMv eGVuL3hsYXRlX21tdS5jCkBAIC0yMzIsNyArMjMyLDcgQEAgaW50IF9faW5pdCB4ZW5feGxhdGVf bWFwX2JhbGxvb25lZF9wYWdlcyh4ZW5fcGZuX3QgKipnZm5zLCB2b2lkICoqdmlydCwKIAkJa2Zy ZWUocGFnZXMpOwogCQlyZXR1cm4gLUVOT01FTTsKIAl9Ci0JcmMgPSBhbGxvY194ZW5iYWxsb29u ZWRfcGFnZXMobnJfcGFnZXMsIHBhZ2VzKTsKKwlyYyA9IHhlbl9hbGxvY191bnBvcHVsYXRlZF9w YWdlcyhucl9wYWdlcywgcGFnZXMpOwogCWlmIChyYykgewogCQlwcl93YXJuKCIlcyBDb3VsZG4n dCBiYWxsb29uIGFsbG9jICVsZCBwYWdlcyByYzolZFxuIiwgX19mdW5jX18sCiAJCQlucl9wYWdl cywgcmMpOwpAQCAtMjQ5LDcgKzI0OSw3IEBAIGludCBfX2luaXQgeGVuX3hsYXRlX21hcF9iYWxs b29uZWRfcGFnZXMoeGVuX3Bmbl90ICoqZ2Zucywgdm9pZCAqKnZpcnQsCiAJaWYgKCF2YWRkcikg ewogCQlwcl93YXJuKCIlcyBDb3VsZG4ndCBtYXAgJWxkIHBhZ2VzIHJjOiVkXG4iLCBfX2Z1bmNf XywKIAkJCW5yX3BhZ2VzLCByYyk7Ci0JCWZyZWVfeGVuYmFsbG9vbmVkX3BhZ2VzKG5yX3BhZ2Vz LCBwYWdlcyk7CisJCXhlbl9mcmVlX3VucG9wdWxhdGVkX3BhZ2VzKG5yX3BhZ2VzLCBwYWdlcyk7 CiAJCWtmcmVlKHBhZ2VzKTsKIAkJa2ZyZWUocGZucyk7CiAJCXJldHVybiAtRU5PTUVNOwpkaWZm IC0tZ2l0IGEvaW5jbHVkZS94ZW4veGVuLmggYi9pbmNsdWRlL3hlbi94ZW4uaAppbmRleCAxOWE3 MmY1OTFlMmIuLjQzZWZiYTA0NWFjYyAxMDA2NDQKLS0tIGEvaW5jbHVkZS94ZW4veGVuLmgKKysr IGIvaW5jbHVkZS94ZW4veGVuLmgKQEAgLTUyLDQgKzUyLDEzIEBAIGJvb2wgeGVuX2Jpb3ZlY19w aHlzX21lcmdlYWJsZShjb25zdCBzdHJ1Y3QgYmlvX3ZlYyAqdmVjMSwKIGV4dGVybiB1NjQgeGVu X3NhdmVkX21heF9tZW1fc2l6ZTsKICNlbmRpZgogCisjaWZkZWYgQ09ORklHX1hFTl9VTlBPUFVM QVRFRF9BTExPQworaW50IHhlbl9hbGxvY191bnBvcHVsYXRlZF9wYWdlcyh1bnNpZ25lZCBpbnQg bnJfcGFnZXMsIHN0cnVjdCBwYWdlICoqcGFnZXMpOwordm9pZCB4ZW5fZnJlZV91bnBvcHVsYXRl ZF9wYWdlcyh1bnNpZ25lZCBpbnQgbnJfcGFnZXMsIHN0cnVjdCBwYWdlICoqcGFnZXMpOworI2Vs c2UKKyNkZWZpbmUgeGVuX2FsbG9jX3VucG9wdWxhdGVkX3BhZ2VzIGFsbG9jX3hlbmJhbGxvb25l ZF9wYWdlcworI2RlZmluZSB4ZW5fZnJlZV91bnBvcHVsYXRlZF9wYWdlcyBmcmVlX3hlbmJhbGxv b25lZF9wYWdlcworI2luY2x1ZGUgPHhlbi9iYWxsb29uLmg+CisjZW5kaWYKKwogI2VuZGlmCS8q IF9YRU5fWEVOX0ggKi8KLS0gCjIuMjguMAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMu ZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlz dGluZm8vZHJpLWRldmVsCg== 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=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 CDC59C433E0 for ; Tue, 11 Aug 2020 09:45:19 +0000 (UTC) Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by mail.kernel.org (Postfix) with ESMTP id 68626205CB for ; Tue, 11 Aug 2020 09:45:19 +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="GoMldxrS" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 68626205CB Authentication-Results: mail.kernel.org; dmarc=fail (p=reject dis=none) header.from=citrix.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=owner-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix) id 046CB8D0001; Tue, 11 Aug 2020 05:45:19 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id F3A236B000A; Tue, 11 Aug 2020 05:45:18 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id E502C8D0001; Tue, 11 Aug 2020 05:45:18 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from forelay.hostedemail.com (smtprelay0147.hostedemail.com [216.40.44.147]) by kanga.kvack.org (Postfix) with ESMTP id CE5E86B0008 for ; Tue, 11 Aug 2020 05:45:18 -0400 (EDT) Received: from smtpin19.hostedemail.com (10.5.19.251.rfc1918.com [10.5.19.251]) by forelay01.hostedemail.com (Postfix) with ESMTP id 7ACA4180AD80F for ; Tue, 11 Aug 2020 09:45:18 +0000 (UTC) X-FDA: 77137804716.19.pull31_4e164ab26fe1 Received: from filter.hostedemail.com (10.5.16.251.rfc1918.com [10.5.16.251]) by smtpin19.hostedemail.com (Postfix) with ESMTP id 438061AD1B1 for ; Tue, 11 Aug 2020 09:45:18 +0000 (UTC) X-HE-Tag: pull31_4e164ab26fe1 X-Filterd-Recvd-Size: 17465 Received: from esa2.hc3370-68.iphmx.com (esa2.hc3370-68.iphmx.com [216.71.145.153]) by imf08.hostedemail.com (Postfix) with ESMTP for ; Tue, 11 Aug 2020 09:45:17 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=citrix.com; s=securemail; t=1597139118; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=hNMxT76XSKdCteUGW9msiopo/AZmHOxBlEJvCXXEBjQ=; b=GoMldxrSW4gpLkkjaIE9y7LHxH1loSB0jEtzp4+tMAfsTn7iugCx1/uD GoDxL6scmpExsAsff4xPznhOHM7wAjnNjDk0/y/YOv6YkSi4hjbRwN07P u35HcyTxKxM4UrcEuOZiFJuLxSRAYDp3agtw/rwVeL6mrx5ulDRmx/UGO o=; Authentication-Results: esa2.hc3370-68.iphmx.com; dkim=none (message not signed) header.i=none IronPort-SDR: JNy0mE7/pD2oU2ERTgVkOQ0ZhrpqC+8cRTjFWDvQN9ERrYWyfl6g2IOo3tjkeUs4aIEbPf0Uat 8+kcyQkVg3VRsmxwAl8SJMH4o8V/UWSHgrGlgfnaqA+Mj7oY7udJXqhj1qF3Jh9MlqeAbK42ci kRzqLxDwDRNl9nCcNMWYXjWBWTm26c0iTk36VqA7kxES7JKEfRM2VgP4MdPdKQk7l5nkDnm5Ba tVt34JjOgfMrPIUDTNE91m1NZkgVgd/2PVTNDzLkMGJCurfPg8fhkh+7q4PhHALhEqzt2bfovM 3hw= X-SBRS: 2.7 X-MesageID: 24269317 X-Ironport-Server: esa2.hc3370-68.iphmx.com X-Remote-IP: 162.221.158.21 X-Policy: $RELAYED X-IronPort-AV: E=Sophos;i="5.75,460,1589256000"; d="scan'208";a="24269317" 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 v4 2/2] xen: add helpers to allocate unpopulated memory Date: Tue, 11 Aug 2020 11:44:47 +0200 Message-ID: <20200811094447.31208-3-roger.pau@citrix.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20200811094447.31208-1-roger.pau@citrix.com> References: <20200811094447.31208-1-roger.pau@citrix.com> MIME-Version: 1.0 Content-Type: text/plain; charset="UTF-8" X-Rspamd-Queue-Id: 438061AD1B1 X-Spamd-Result: default: False [0.00 / 100.00] X-Rspamd-Server: rspam04 Content-Transfer-Encoding: quoted-printable X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: 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=C3=A9 --- 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 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 | 4 + 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, 215 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/xe= n/xen_drm_front_gem.c index f0b85e094111..270e1bd3e4da 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 =20 #include +#include =20 #include "xen_drm_front.h" #include "xen_drm_front_gem.h" @@ -99,8 +100,8 @@ static struct xen_gem_object *gem_create(struct drm_de= vice *dev, size_t size) * allocate ballooned pages which will be used to map * grant references provided by the backend */ - ret =3D alloc_xenballooned_pages(xen_obj->num_pages, - xen_obj->pages); + ret =3D 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 dr= m_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 1d339ef92422..018020b91baa 100644 --- a/drivers/xen/Kconfig +++ b/drivers/xen/Kconfig @@ -327,4 +327,8 @@ config XEN_HAVE_VPMU config XEN_FRONT_PGDIR_SHBUF tristate =20 +config XEN_UNPOPULATED_ALLOC + bool + default y if ZONE_DEVICE && !ARM && !ARM64 + 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) +=3D gntdev-dmab= uf.o xen-gntalloc-y :=3D gntalloc.o xen-privcmd-y :=3D privcmd.o privcmd-buf.o obj-$(CONFIG_XEN_FRONT_PGDIR_SHBUF) +=3D xen-front-pgdir-shbuf.o +obj-$(CONFIG_XEN_UNPOPULATED_ALLOC) +=3D 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 pag= e **pages) } EXPORT_SYMBOL(free_xenballooned_pages); =20 -#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 =20 -#ifdef CONFIG_XEN_PV +#if defined(CONFIG_XEN_PV) && !defined(CONFIG_XEN_UNPOPULATED_ALLOC) { int i; =20 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 **pa= ges) { int ret; =20 - ret =3D alloc_xenballooned_pages(nr_pages, pages); + ret =3D xen_alloc_unpopulated_pages(nr_pages, pages); if (ret < 0) return ret; =20 @@ -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); =20 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 *v= ma, int numpgs) if (pages =3D=3D NULL) return -ENOMEM; =20 - rc =3D alloc_xenballooned_pages(numpgs, pages); + rc =3D xen_alloc_unpopulated_pages(numpgs, pages); if (rc !=3D 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) =20 rc =3D xen_unmap_domain_gfn_range(vma, numgfns, pages); if (rc =3D=3D 0) - free_xenballooned_pages(numpgs, pages); + xen_free_unpopulated_pages(numpgs, pages); else pr_crit("unable to unmap MFN range: leaking %d pages. rc=3D%d\n", numpgs, rc); diff --git a/drivers/xen/unpopulated-alloc.c b/drivers/xen/unpopulated-al= loc.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 =3D round_up(nr_pages, PAGES_PER_SECTION); + int nid, ret; + + pgmap =3D kzalloc(sizeof(*pgmap), GFP_KERNEL); + if (!pgmap) + return -ENOMEM; + + pgmap->type =3D MEMORY_DEVICE_GENERIC; + pgmap->res.name =3D "Xen scratch"; + pgmap->res.flags =3D IORESOURCE_MEM | IORESOURCE_BUSY; + + ret =3D 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 =3D 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 =3D PFN_DOWN(pgmap->res.start); + + for (i =3D 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 =3D 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 =3D 0; i < alloc_pages; i++) { + struct page *pg =3D 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 **pag= es) +{ + unsigned int i; + int ret =3D 0; + + mutex_lock(&list_lock); + if (list_count < nr_pages) { + ret =3D fill_list(nr_pages - list_count); + if (ret) + goto out; + } + + for (i =3D 0; i < nr_pages; i++) { + struct page *pg =3D list_first_entry_or_null(&page_list, + struct page, + lru); + + BUG_ON(!pg); + list_del(&pg->lru); + list_count--; + pages[i] =3D pg; + +#ifdef CONFIG_XEN_HAVE_PVMMU + if (!xen_feature(XENFEAT_auto_translated_physmap)) { + ret =3D xen_alloc_p2m_entry(page_to_pfn(pg)); + if (ret < 0) { + unsigned int j; + + for (j =3D 0; j <=3D 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 **pag= es) +{ + unsigned int i; + + mutex_lock(&list_lock); + for (i =3D 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 =3D 0; i < XEN_EXTRA_MEM_MAX_REGIONS; i++) { + unsigned int j; + + for (j =3D 0; j < xen_extra_mem[i].n_pfns; j++) { + struct page *pg =3D + 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/xenb= us_client.c index 786fbb7d8be0..70b6c4780fbd 100644 --- a/drivers/xen/xenbus/xenbus_client.c +++ b/drivers/xen/xenbus/xenbus_client.c @@ -615,7 +615,7 @@ static int xenbus_map_ring_hvm(struct xenbus_device *= dev, bool leaked =3D false; unsigned int nr_pages =3D XENBUS_PAGES(nr_grefs); =20 - err =3D alloc_xenballooned_pages(nr_pages, node->hvm.pages); + err =3D xen_alloc_unpopulated_pages(nr_pages, node->hvm.pages); if (err) goto out_err; =20 @@ -656,7 +656,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; } @@ -852,7 +852,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 =3D alloc_xenballooned_pages(nr_pages, pages); + rc =3D 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 *v= ec1, extern u64 xen_saved_max_mem_size; #endif =20 +#ifdef CONFIG_XEN_UNPOPULATED_ALLOC +int xen_alloc_unpopulated_pages(unsigned int nr_pages, struct page **pag= es); +void xen_free_unpopulated_pages(unsigned int nr_pages, struct page **pag= es); +#else +#define xen_alloc_unpopulated_pages alloc_xenballooned_pages +#define xen_free_unpopulated_pages free_xenballooned_pages +#include +#endif + #endif /* _XEN_XEN_H */ --=20 2.28.0