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 240CCC433F8 for ; Mon, 27 Jul 2020 09:15:30 +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 DDA8220656 for ; Mon, 27 Jul 2020 09:15:29 +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="YOu20+2J" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org DDA8220656 Authentication-Results: mail.kernel.org; dmarc=fail (p=none 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 1jzzE5-0004Qd-EA; Mon, 27 Jul 2020 09:15:17 +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 1jzzE4-0004QL-6C for xen-devel@lists.xenproject.org; Mon, 27 Jul 2020 09:15:16 +0000 X-Inumbo-ID: ae45e47c-cfe9-11ea-a777-12813bfff9fa Received: from esa1.hc3370-68.iphmx.com (unknown [216.71.145.142]) by us1-amaz-eas2.inumbo.com (Halon) with ESMTPS id ae45e47c-cfe9-11ea-a777-12813bfff9fa; Mon, 27 Jul 2020 09:15:15 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=citrix.com; s=securemail; t=1595841315; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=ypPb5+5mjFQ6dtbL/IxbCNOjD1qVztAdhRNp+jbSIJA=; b=YOu20+2J3S4EXyVWKe5hlF3hV02HsKdRExG+iIbFbWxemjji63rodA/L sv9V8YWbM5FAnpJT835248CjJ2VGK5IMfuumzbP+3sB48kcbs7E7k0Zuc XcXPbbtHU2v8fyqZv0+B0X/bl+0GbmDp4Y9XKVV72bqFdupGNm3r0qLPw w=; Authentication-Results: esa1.hc3370-68.iphmx.com; dkim=none (message not signed) header.i=none IronPort-SDR: WXyj5KnFWi7XSH4TWCBzVsr8ZMwp+EDQ+LH8inkEJ8y5c8ZI7GpHdELUbkfU50zaT0y+UJ2bg3 tGkQTS7Cd3n2F0avfc4p3Tv4Om4nVMPdfCIP2fH81xedkGHO42gQj0gaw5WITMYWnXwXlCpuOv fYda7epWjgoXV8dnH06TOLIkMc6zV5hwVEA84Nsa63862itJEJbTBUF/qzfcmTAgkBOmuv72yn QGZrTN5pyKY/pg/gEvRVPcy84WdrnQKei0WAIP2Epw33rEGjpdrfi7j5pDPW8jfmK3gQUzufVG K4A= X-SBRS: 2.7 X-MesageID: 23569868 X-Ironport-Server: esa1.hc3370-68.iphmx.com X-Remote-IP: 162.221.158.21 X-Policy: $RELAYED X-IronPort-AV: E=Sophos;i="5.75,402,1589256000"; d="scan'208";a="23569868" From: Roger Pau Monne To: Subject: [PATCH v3 4/4] xen: add helpers to allocate unpopulated memory Date: Mon, 27 Jul 2020 11:13:42 +0200 Message-ID: <20200727091342.52325-5-roger.pau@citrix.com> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20200727091342.52325-1-roger.pau@citrix.com> References: <20200727091342.52325-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. Signed-off-by: Roger Pau Monné --- I've not added a new memory_type type and just used MEMORY_DEVICE_DEVDAX which seems to be what we want for such memory regions. I'm unsure whether abusing this type is fine, or if I should instead add a specific type, maybe MEMORY_DEVICE_GENERIC? I don't think we should be using a specific Xen type at all. --- 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 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/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 ++ 9 files changed, 211 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/Makefile b/drivers/xen/Makefile index 0d322f3d90cd..788a5d9c8ef0 100644 --- a/drivers/xen/Makefile +++ b/drivers/xen/Makefile @@ -42,3 +42,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_ZONE_DEVICE) += unpopulated-alloc.o diff --git a/drivers/xen/balloon.c b/drivers/xen/balloon.c index b1d8b028bf80..815ef10eb2ff 100644 --- a/drivers/xen/balloon.c +++ b/drivers/xen/balloon.c @@ -654,7 +654,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_ZONE_DEVICE) static void __init balloon_add_region(unsigned long start_pfn, unsigned long pages) { @@ -708,7 +708,7 @@ static int __init balloon_init(void) register_sysctl_table(xen_root); #endif -#ifdef CONFIG_XEN_PV +#if defined(CONFIG_XEN_PV) && !defined(CONFIG_ZONE_DEVICE) { 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 a250d118144a..56000ab70974 100644 --- a/drivers/xen/privcmd.c +++ b/drivers/xen/privcmd.c @@ -425,7 +425,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); @@ -900,7 +900,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..c50450375922 --- /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_DEVDAX; + 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..e93b47e5e378 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_ZONE_DEVICE +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.27.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=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 11A73C433E8 for ; Mon, 27 Jul 2020 23:33:01 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id D5F9A20809 for ; Mon, 27 Jul 2020 23:33:00 +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="YOu20+2J" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org D5F9A20809 Authentication-Results: mail.kernel.org; dmarc=fail (p=none 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 39E9E6E0D0; Mon, 27 Jul 2020 23:32:44 +0000 (UTC) Received: from esa1.hc3370-68.iphmx.com (esa1.hc3370-68.iphmx.com [216.71.145.142]) by gabe.freedesktop.org (Postfix) with ESMTPS id 61ED88990D for ; Mon, 27 Jul 2020 09:15:15 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=citrix.com; s=securemail; t=1595841315; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=ypPb5+5mjFQ6dtbL/IxbCNOjD1qVztAdhRNp+jbSIJA=; b=YOu20+2J3S4EXyVWKe5hlF3hV02HsKdRExG+iIbFbWxemjji63rodA/L sv9V8YWbM5FAnpJT835248CjJ2VGK5IMfuumzbP+3sB48kcbs7E7k0Zuc XcXPbbtHU2v8fyqZv0+B0X/bl+0GbmDp4Y9XKVV72bqFdupGNm3r0qLPw w=; Authentication-Results: esa1.hc3370-68.iphmx.com; dkim=none (message not signed) header.i=none IronPort-SDR: WXyj5KnFWi7XSH4TWCBzVsr8ZMwp+EDQ+LH8inkEJ8y5c8ZI7GpHdELUbkfU50zaT0y+UJ2bg3 tGkQTS7Cd3n2F0avfc4p3Tv4Om4nVMPdfCIP2fH81xedkGHO42gQj0gaw5WITMYWnXwXlCpuOv fYda7epWjgoXV8dnH06TOLIkMc6zV5hwVEA84Nsa63862itJEJbTBUF/qzfcmTAgkBOmuv72yn QGZrTN5pyKY/pg/gEvRVPcy84WdrnQKei0WAIP2Epw33rEGjpdrfi7j5pDPW8jfmK3gQUzufVG K4A= X-SBRS: 2.7 X-MesageID: 23569868 X-Ironport-Server: esa1.hc3370-68.iphmx.com X-Remote-IP: 162.221.158.21 X-Policy: $RELAYED X-IronPort-AV: E=Sophos;i="5.75,402,1589256000"; d="scan'208";a="23569868" From: Roger Pau Monne To: Subject: [PATCH v3 4/4] xen: add helpers to allocate unpopulated memory Date: Mon, 27 Jul 2020 11:13:42 +0200 Message-ID: <20200727091342.52325-5-roger.pau@citrix.com> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20200727091342.52325-1-roger.pau@citrix.com> References: <20200727091342.52325-1-roger.pau@citrix.com> MIME-Version: 1.0 X-Mailman-Approved-At: Mon, 27 Jul 2020 23:32:42 +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 bWFwcGluZ3Mgb2YgZm9yZWlnbiBwYWdlcyBkZXBlbmQKb24gbWVtb3J5IGhvdHBsdWcuCgpTaWdu ZWQtb2ZmLWJ5OiBSb2dlciBQYXUgTW9ubsOpIDxyb2dlci5wYXVAY2l0cml4LmNvbT4KLS0tCkkn dmUgbm90IGFkZGVkIGEgbmV3IG1lbW9yeV90eXBlIHR5cGUgYW5kIGp1c3QgdXNlZApNRU1PUllf REVWSUNFX0RFVkRBWCB3aGljaCBzZWVtcyB0byBiZSB3aGF0IHdlIHdhbnQgZm9yIHN1Y2ggbWVt b3J5CnJlZ2lvbnMuIEknbSB1bnN1cmUgd2hldGhlciBhYnVzaW5nIHRoaXMgdHlwZSBpcyBmaW5l LCBvciBpZiBJIHNob3VsZAppbnN0ZWFkIGFkZCBhIHNwZWNpZmljIHR5cGUsIG1heWJlIE1FTU9S WV9ERVZJQ0VfR0VORVJJQz8gSSBkb24ndAp0aGluayB3ZSBzaG91bGQgYmUgdXNpbmcgYSBzcGVj aWZpYyBYZW4gdHlwZSBhdCBhbGwuCi0tLQpDYzogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9s ZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgpDYzogRGF2aWQgQWlybGllIDxhaXJsaWVk QGxpbnV4LmllPgpDYzogRGFuaWVsIFZldHRlciA8ZGFuaWVsQGZmd2xsLmNoPgpDYzogQm9yaXMg T3N0cm92c2t5IDxib3Jpcy5vc3Ryb3Zza3lAb3JhY2xlLmNvbT4KQ2M6IEp1ZXJnZW4gR3Jvc3Mg PGpncm9zc0BzdXNlLmNvbT4KQ2M6IFN0ZWZhbm8gU3RhYmVsbGluaSA8c3N0YWJlbGxpbmlAa2Vy bmVsLm9yZz4KQ2M6IERhbiBDYXJwZW50ZXIgPGRhbi5jYXJwZW50ZXJAb3JhY2xlLmNvbT4KQ2M6 IFJvZ2VyIFBhdSBNb25uZSA8cm9nZXIucGF1QGNpdHJpeC5jb20+CkNjOiBXZWkgTGl1IDx3bEB4 ZW4ub3JnPgpDYzogWWFuIFlhbmtvdnNreWkgPHl5YW5rb3Zza3lpQGdtYWlsLmNvbT4KQ2M6IGRy aS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKQ2M6IHhlbi1kZXZlbEBsaXN0cy54ZW5wcm9q ZWN0Lm9yZwpDYzogbGludXgtbW1Aa3ZhY2sub3JnCkNjOiBEYXZpZCBIaWxkZW5icmFuZCA8ZGF2 aWRAcmVkaGF0LmNvbT4KQ2M6IE1pY2hhbCBIb2NrbyA8bWhvY2tvQGtlcm5lbC5vcmc+CkNjOiBE YW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1zQGludGVsLmNvbT4KLS0tCkNoYW5nZXMgc2luY2Ug djI6CiAtIERyb3AgQlVJTERfQlVHX09OIHJlZ2FyZGluZyBQVk1NVSBwYWdlIHNpemVzLgogLSBV c2UgYSBTUERYIGxpY2Vuc2UgaWRlbnRpZmllci4KIC0gQ2FsbCBmaWxsIHdpdGggb25seSB0aGUg bWluaW11bSByZXF1aXJlZCBudW1iZXIgb2YgcGFnZXMuCiAtIEluY2x1ZGUgeGVuLmggaGVhZGVy IGluIHhlbl9kcm1fZnJvbnRfZ2VtLmMuCiAtIFVzZSBsZXNzIGdlbmVyaWMgZnVuY3Rpb24gbmFt ZXMuCiAtIEV4aXQgZWFybHkgZnJvbSB0aGUgaW5pdCBmdW5jdGlvbiBpZiBub3QgYSBQViBndWVz dC4KIC0gRG9uJ3QgdXNlIGFsbCBjYXBzIGZvciByZWdpb24gbmFtZS4KLS0tCiBkcml2ZXJzL2dw dS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZ2VtLmMgfCAgIDkgKy0KIGRyaXZlcnMveGVuL01ha2Vm aWxlICAgICAgICAgICAgICAgICAgICB8ICAgMSArCiBkcml2ZXJzL3hlbi9iYWxsb29uLmMgICAg ICAgICAgICAgICAgICAgfCAgIDQgKy0KIGRyaXZlcnMveGVuL2dyYW50LXRhYmxlLmMgICAgICAg ICAgICAgICB8ICAgNCArLQogZHJpdmVycy94ZW4vcHJpdmNtZC5jICAgICAgICAgICAgICAgICAg IHwgICA0ICstCiBkcml2ZXJzL3hlbi91bnBvcHVsYXRlZC1hbGxvYy5jICAgICAgICAgfCAxODUg KysrKysrKysrKysrKysrKysrKysrKysrCiBkcml2ZXJzL3hlbi94ZW5idXMveGVuYnVzX2NsaWVu dC5jICAgICAgfCAgIDYgKy0KIGRyaXZlcnMveGVuL3hsYXRlX21tdS5jICAgICAgICAgICAgICAg ICB8ICAgNCArLQogaW5jbHVkZS94ZW4veGVuLmggICAgICAgICAgICAgICAgICAgICAgIHwgICA5 ICsrCiA5IGZpbGVzIGNoYW5nZWQsIDIxMSBpbnNlcnRpb25zKCspLCAxNSBkZWxldGlvbnMoLSkK IGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL3hlbi91bnBvcHVsYXRlZC1hbGxvYy5jCgpkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2dlbS5jIGIvZHJpdmVy cy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2dlbS5jCmluZGV4IGYwYjg1ZTA5NDExMS4uMjcw ZTFiZDNlNGRhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRf Z2VtLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2dlbS5jCkBAIC0x OCw2ICsxOCw3IEBACiAjaW5jbHVkZSA8ZHJtL2RybV9wcm9iZV9oZWxwZXIuaD4KIAogI2luY2x1 ZGUgPHhlbi9iYWxsb29uLmg+CisjaW5jbHVkZSA8eGVuL3hlbi5oPgogCiAjaW5jbHVkZSAieGVu X2RybV9mcm9udC5oIgogI2luY2x1ZGUgInhlbl9kcm1fZnJvbnRfZ2VtLmgiCkBAIC05OSw4ICsx MDAsOCBAQCBzdGF0aWMgc3RydWN0IHhlbl9nZW1fb2JqZWN0ICpnZW1fY3JlYXRlKHN0cnVjdCBk cm1fZGV2aWNlICpkZXYsIHNpemVfdCBzaXplKQogCQkgKiBhbGxvY2F0ZSBiYWxsb29uZWQgcGFn ZXMgd2hpY2ggd2lsbCBiZSB1c2VkIHRvIG1hcAogCQkgKiBncmFudCByZWZlcmVuY2VzIHByb3Zp ZGVkIGJ5IHRoZSBiYWNrZW5kCiAJCSAqLwotCQlyZXQgPSBhbGxvY194ZW5iYWxsb29uZWRfcGFn ZXMoeGVuX29iai0+bnVtX3BhZ2VzLAotCQkJCQkgICAgICAgeGVuX29iai0+cGFnZXMpOworCQly ZXQgPSB4ZW5fYWxsb2NfdW5wb3B1bGF0ZWRfcGFnZXMoeGVuX29iai0+bnVtX3BhZ2VzLAorCQkJ CQkgICAgICAgICAgeGVuX29iai0+cGFnZXMpOwogCQlpZiAocmV0IDwgMCkgewogCQkJRFJNX0VS Uk9SKCJDYW5ub3QgYWxsb2NhdGUgJXp1IGJhbGxvb25lZCBwYWdlczogJWRcbiIsCiAJCQkJICB4 ZW5fb2JqLT5udW1fcGFnZXMsIHJldCk7CkBAIC0xNTIsOCArMTUzLDggQEAgdm9pZCB4ZW5fZHJt X2Zyb250X2dlbV9mcmVlX29iamVjdF91bmxvY2tlZChzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmdl bV9vYmopCiAJfSBlbHNlIHsKIAkJaWYgKHhlbl9vYmotPnBhZ2VzKSB7CiAJCQlpZiAoeGVuX29i ai0+YmVfYWxsb2MpIHsKLQkJCQlmcmVlX3hlbmJhbGxvb25lZF9wYWdlcyh4ZW5fb2JqLT5udW1f cGFnZXMsCi0JCQkJCQkJeGVuX29iai0+cGFnZXMpOworCQkJCXhlbl9mcmVlX3VucG9wdWxhdGVk X3BhZ2VzKHhlbl9vYmotPm51bV9wYWdlcywKKwkJCQkJCQkgICB4ZW5fb2JqLT5wYWdlcyk7CiAJ CQkJZ2VtX2ZyZWVfcGFnZXNfYXJyYXkoeGVuX29iaik7CiAJCQl9IGVsc2UgewogCQkJCWRybV9n ZW1fcHV0X3BhZ2VzKCZ4ZW5fb2JqLT5iYXNlLApkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vTWFr ZWZpbGUgYi9kcml2ZXJzL3hlbi9NYWtlZmlsZQppbmRleCAwZDMyMmYzZDkwY2QuLjc4OGE1ZDlj OGVmMCAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vTWFrZWZpbGUKKysrIGIvZHJpdmVycy94ZW4v TWFrZWZpbGUKQEAgLTQyLDMgKzQyLDQgQEAgeGVuLWdudGRldi0kKENPTkZJR19YRU5fR05UREVW X0RNQUJVRikJKz0gZ250ZGV2LWRtYWJ1Zi5vCiB4ZW4tZ250YWxsb2MteQkJCQk6PSBnbnRhbGxv Yy5vCiB4ZW4tcHJpdmNtZC15CQkJCTo9IHByaXZjbWQubyBwcml2Y21kLWJ1Zi5vCiBvYmotJChD T05GSUdfWEVOX0ZST05UX1BHRElSX1NIQlVGKQkrPSB4ZW4tZnJvbnQtcGdkaXItc2hidWYubwor b2JqLSQoQ09ORklHX1pPTkVfREVWSUNFKQkJKz0gdW5wb3B1bGF0ZWQtYWxsb2MubwpkaWZmIC0t Z2l0IGEvZHJpdmVycy94ZW4vYmFsbG9vbi5jIGIvZHJpdmVycy94ZW4vYmFsbG9vbi5jCmluZGV4 IGIxZDhiMDI4YmY4MC4uODE1ZWYxMGViMmZmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi9iYWxs b29uLmMKKysrIGIvZHJpdmVycy94ZW4vYmFsbG9vbi5jCkBAIC02NTQsNyArNjU0LDcgQEAgdm9p ZCBmcmVlX3hlbmJhbGxvb25lZF9wYWdlcyhpbnQgbnJfcGFnZXMsIHN0cnVjdCBwYWdlICoqcGFn ZXMpCiB9CiBFWFBPUlRfU1lNQk9MKGZyZWVfeGVuYmFsbG9vbmVkX3BhZ2VzKTsKIAotI2lmZGVm IENPTkZJR19YRU5fUFYKKyNpZiBkZWZpbmVkKENPTkZJR19YRU5fUFYpICYmICFkZWZpbmVkKENP TkZJR19aT05FX0RFVklDRSkKIHN0YXRpYyB2b2lkIF9faW5pdCBiYWxsb29uX2FkZF9yZWdpb24o dW5zaWduZWQgbG9uZyBzdGFydF9wZm4sCiAJCQkJICAgICAgdW5zaWduZWQgbG9uZyBwYWdlcykK IHsKQEAgLTcwOCw3ICs3MDgsNyBAQCBzdGF0aWMgaW50IF9faW5pdCBiYWxsb29uX2luaXQodm9p ZCkKIAlyZWdpc3Rlcl9zeXNjdGxfdGFibGUoeGVuX3Jvb3QpOwogI2VuZGlmCiAKLSNpZmRlZiBD T05GSUdfWEVOX1BWCisjaWYgZGVmaW5lZChDT05GSUdfWEVOX1BWKSAmJiAhZGVmaW5lZChDT05G SUdfWk9ORV9ERVZJQ0UpCiAJewogCQlpbnQgaTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4v Z3JhbnQtdGFibGUuYyBiL2RyaXZlcnMveGVuL2dyYW50LXRhYmxlLmMKaW5kZXggOGQwNmJmMWNj MzQ3Li41MjNkY2RmMzljYzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL2dyYW50LXRhYmxlLmMK KysrIGIvZHJpdmVycy94ZW4vZ3JhbnQtdGFibGUuYwpAQCAtODAxLDcgKzgwMSw3IEBAIGludCBn bnR0YWJfYWxsb2NfcGFnZXMoaW50IG5yX3BhZ2VzLCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKQogewog CWludCByZXQ7CiAKLQlyZXQgPSBhbGxvY194ZW5iYWxsb29uZWRfcGFnZXMobnJfcGFnZXMsIHBh Z2VzKTsKKwlyZXQgPSB4ZW5fYWxsb2NfdW5wb3B1bGF0ZWRfcGFnZXMobnJfcGFnZXMsIHBhZ2Vz KTsKIAlpZiAocmV0IDwgMCkKIAkJcmV0dXJuIHJldDsKIApAQCAtODM2LDcgKzgzNiw3IEBAIEVY UE9SVF9TWU1CT0xfR1BMKGdudHRhYl9wYWdlc19jbGVhcl9wcml2YXRlKTsKIHZvaWQgZ250dGFi X2ZyZWVfcGFnZXMoaW50IG5yX3BhZ2VzLCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKQogewogCWdudHRh Yl9wYWdlc19jbGVhcl9wcml2YXRlKG5yX3BhZ2VzLCBwYWdlcyk7Ci0JZnJlZV94ZW5iYWxsb29u ZWRfcGFnZXMobnJfcGFnZXMsIHBhZ2VzKTsKKwl4ZW5fZnJlZV91bnBvcHVsYXRlZF9wYWdlcyhu cl9wYWdlcywgcGFnZXMpOwogfQogRVhQT1JUX1NZTUJPTF9HUEwoZ250dGFiX2ZyZWVfcGFnZXMp OwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9wcml2Y21kLmMgYi9kcml2ZXJzL3hlbi9wcml2 Y21kLmMKaW5kZXggYTI1MGQxMTgxNDRhLi41NjAwMGFiNzA5NzQgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMveGVuL3ByaXZjbWQuYworKysgYi9kcml2ZXJzL3hlbi9wcml2Y21kLmMKQEAgLTQyNSw3ICs0 MjUsNyBAQCBzdGF0aWMgaW50IGFsbG9jX2VtcHR5X3BhZ2VzKHN0cnVjdCB2bV9hcmVhX3N0cnVj dCAqdm1hLCBpbnQgbnVtcGdzKQogCWlmIChwYWdlcyA9PSBOVUxMKQogCQlyZXR1cm4gLUVOT01F TTsKIAotCXJjID0gYWxsb2NfeGVuYmFsbG9vbmVkX3BhZ2VzKG51bXBncywgcGFnZXMpOworCXJj ID0geGVuX2FsbG9jX3VucG9wdWxhdGVkX3BhZ2VzKG51bXBncywgcGFnZXMpOwogCWlmIChyYyAh PSAwKSB7CiAJCXByX3dhcm4oIiVzIENvdWxkIG5vdCBhbGxvYyAlZCBwZm5zIHJjOiVkXG4iLCBf X2Z1bmNfXywKIAkJCW51bXBncywgcmMpOwpAQCAtOTAwLDcgKzkwMCw3IEBAIHN0YXRpYyB2b2lk IHByaXZjbWRfY2xvc2Uoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCiAKIAlyYyA9IHhlbl91 bm1hcF9kb21haW5fZ2ZuX3JhbmdlKHZtYSwgbnVtZ2ZucywgcGFnZXMpOwogCWlmIChyYyA9PSAw KQotCQlmcmVlX3hlbmJhbGxvb25lZF9wYWdlcyhudW1wZ3MsIHBhZ2VzKTsKKwkJeGVuX2ZyZWVf dW5wb3B1bGF0ZWRfcGFnZXMobnVtcGdzLCBwYWdlcyk7CiAJZWxzZQogCQlwcl9jcml0KCJ1bmFi bGUgdG8gdW5tYXAgTUZOIHJhbmdlOiBsZWFraW5nICVkIHBhZ2VzLiByYz0lZFxuIiwKIAkJCW51 bXBncywgcmMpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vdW5wb3B1bGF0ZWQtYWxsb2MuYyBi L2RyaXZlcnMveGVuL3VucG9wdWxhdGVkLWFsbG9jLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAwLi5jNTA0NTAzNzU5MjIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJz L3hlbi91bnBvcHVsYXRlZC1hbGxvYy5jCkBAIC0wLDAgKzEsMTg1IEBACisvLyBTUERYLUxpY2Vu c2UtSWRlbnRpZmllcjogR1BMLTIuMAorI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+CisjaW5jbHVk ZSA8bGludXgvZ2ZwLmg+CisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGlu dXgvbW0uaD4KKyNpbmNsdWRlIDxsaW51eC9tZW1yZW1hcC5oPgorI2luY2x1ZGUgPGxpbnV4L3Ns YWIuaD4KKworI2luY2x1ZGUgPGFzbS9wYWdlLmg+CisKKyNpbmNsdWRlIDx4ZW4vcGFnZS5oPgor I2luY2x1ZGUgPHhlbi94ZW4uaD4KKworc3RhdGljIERFRklORV9NVVRFWChsaXN0X2xvY2spOwor c3RhdGljIExJU1RfSEVBRChwYWdlX2xpc3QpOworc3RhdGljIHVuc2lnbmVkIGludCBsaXN0X2Nv dW50OworCitzdGF0aWMgaW50IGZpbGxfbGlzdCh1bnNpZ25lZCBpbnQgbnJfcGFnZXMpCit7CisJ c3RydWN0IGRldl9wYWdlbWFwICpwZ21hcDsKKwl2b2lkICp2YWRkcjsKKwl1bnNpZ25lZCBpbnQg aSwgYWxsb2NfcGFnZXMgPSByb3VuZF91cChucl9wYWdlcywgUEFHRVNfUEVSX1NFQ1RJT04pOwor CWludCBuaWQsIHJldDsKKworCXBnbWFwID0ga3phbGxvYyhzaXplb2YoKnBnbWFwKSwgR0ZQX0tF Uk5FTCk7CisJaWYgKCFwZ21hcCkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlwZ21hcC0+dHlwZSA9 IE1FTU9SWV9ERVZJQ0VfREVWREFYOworCXBnbWFwLT5yZXMubmFtZSA9ICJYZW4gc2NyYXRjaCI7 CisJcGdtYXAtPnJlcy5mbGFncyA9IElPUkVTT1VSQ0VfTUVNIHwgSU9SRVNPVVJDRV9CVVNZOwor CisJcmV0ID0gYWxsb2NhdGVfcmVzb3VyY2UoJmlvbWVtX3Jlc291cmNlLCAmcGdtYXAtPnJlcywK KwkJCQlhbGxvY19wYWdlcyAqIFBBR0VfU0laRSwgMCwgLTEsCisJCQkJUEFHRVNfUEVSX1NFQ1RJ T04gKiBQQUdFX1NJWkUsIE5VTEwsIE5VTEwpOworCWlmIChyZXQgPCAwKSB7CisJCXByX2Vycigi Q2Fubm90IGFsbG9jYXRlIG5ldyBJT01FTSByZXNvdXJjZVxuIik7CisJCWtmcmVlKHBnbWFwKTsK KwkJcmV0dXJuIHJldDsKKwl9CisKKwluaWQgPSBtZW1vcnlfYWRkX3BoeXNhZGRyX3RvX25pZChw Z21hcC0+cmVzLnN0YXJ0KTsKKworI2lmZGVmIENPTkZJR19YRU5fSEFWRV9QVk1NVQorICAgICAg ICAvKgorICAgICAgICAgKiBtZW1yZW1hcCB3aWxsIGJ1aWxkIHBhZ2UgdGFibGVzIGZvciB0aGUg bmV3IG1lbW9yeSBzbworICAgICAgICAgKiB0aGUgcDJtIG11c3QgY29udGFpbiBpbnZhbGlkIGVu dHJpZXMgc28gdGhlIGNvcnJlY3QKKyAgICAgICAgICogbm9uLXByZXNlbnQgUFRFcyB3aWxsIGJl IHdyaXR0ZW4uCisgICAgICAgICAqCisgICAgICAgICAqIElmIGEgZmFpbHVyZSBvY2N1cnMsIHRo ZSBvcmlnaW5hbCAoaWRlbnRpdHkpIHAybSBlbnRyaWVzCisgICAgICAgICAqIGFyZSBub3QgcmVz dG9yZWQgc2luY2UgdGhpcyByZWdpb24gaXMgbm93IGtub3duIG5vdCB0bworICAgICAgICAgKiBj b25mbGljdCB3aXRoIGFueSBkZXZpY2VzLgorICAgICAgICAgKi8KKwlpZiAoIXhlbl9mZWF0dXJl KFhFTkZFQVRfYXV0b190cmFuc2xhdGVkX3BoeXNtYXApKSB7CisJCXhlbl9wZm5fdCBwZm4gPSBQ Rk5fRE9XTihwZ21hcC0+cmVzLnN0YXJ0KTsKKworCQlmb3IgKGkgPSAwOyBpIDwgYWxsb2NfcGFn ZXM7IGkrKykgeworCQkJaWYgKCFzZXRfcGh5c190b19tYWNoaW5lKHBmbiArIGksIElOVkFMSURf UDJNX0VOVFJZKSkgeworCQkJCXByX3dhcm4oInNldF9waHlzX3RvX21hY2hpbmUoKSBmYWlsZWQs IG5vIG1lbW9yeSBhZGRlZFxuIik7CisJCQkJcmVsZWFzZV9yZXNvdXJjZSgmcGdtYXAtPnJlcyk7 CisJCQkJa2ZyZWUocGdtYXApOworCQkJCXJldHVybiAtRU5PTUVNOworCQkJfQorICAgICAgICAg ICAgICAgIH0KKwl9CisjZW5kaWYKKworCXZhZGRyID0gbWVtcmVtYXBfcGFnZXMocGdtYXAsIG5p ZCk7CisJaWYgKElTX0VSUih2YWRkcikpIHsKKwkJcHJfZXJyKCJDYW5ub3QgcmVtYXAgbWVtb3J5 IHJhbmdlXG4iKTsKKwkJcmVsZWFzZV9yZXNvdXJjZSgmcGdtYXAtPnJlcyk7CisJCWtmcmVlKHBn bWFwKTsKKwkJcmV0dXJuIFBUUl9FUlIodmFkZHIpOworCX0KKworCWZvciAoaSA9IDA7IGkgPCBh bGxvY19wYWdlczsgaSsrKSB7CisJCXN0cnVjdCBwYWdlICpwZyA9IHZpcnRfdG9fcGFnZSh2YWRk ciArIFBBR0VfU0laRSAqIGkpOworCisJCUJVR19PTighdmlydF9hZGRyX3ZhbGlkKHZhZGRyICsg UEFHRV9TSVpFICogaSkpOworCQlsaXN0X2FkZCgmcGctPmxydSwgJnBhZ2VfbGlzdCk7CisJCWxp c3RfY291bnQrKzsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworLyoqCisgKiB4ZW5fYWxsb2NfdW5w b3B1bGF0ZWRfcGFnZXMgLSBhbGxvYyB1bnBvcHVsYXRlZCBwYWdlcworICogQG5yX3BhZ2VzOiBO dW1iZXIgb2YgcGFnZXMKKyAqIEBwYWdlczogcGFnZXMgcmV0dXJuZWQKKyAqIEByZXR1cm4gMCBv biBzdWNjZXNzLCBlcnJvciBvdGhlcndpc2UKKyAqLworaW50IHhlbl9hbGxvY191bnBvcHVsYXRl ZF9wYWdlcyh1bnNpZ25lZCBpbnQgbnJfcGFnZXMsIHN0cnVjdCBwYWdlICoqcGFnZXMpCit7CisJ dW5zaWduZWQgaW50IGk7CisJaW50IHJldCA9IDA7CisKKwltdXRleF9sb2NrKCZsaXN0X2xvY2sp OworCWlmIChsaXN0X2NvdW50IDwgbnJfcGFnZXMpIHsKKwkJcmV0ID0gZmlsbF9saXN0KG5yX3Bh Z2VzIC0gbGlzdF9jb3VudCk7CisJCWlmIChyZXQpCisJCQlnb3RvIG91dDsKKwl9CisKKwlmb3Ig KGkgPSAwOyBpIDwgbnJfcGFnZXM7IGkrKykgeworCQlzdHJ1Y3QgcGFnZSAqcGcgPSBsaXN0X2Zp cnN0X2VudHJ5X29yX251bGwoJnBhZ2VfbGlzdCwKKwkJCQkJCQkgICBzdHJ1Y3QgcGFnZSwKKwkJ CQkJCQkgICBscnUpOworCisJCUJVR19PTighcGcpOworCQlsaXN0X2RlbCgmcGctPmxydSk7CisJ CWxpc3RfY291bnQtLTsKKwkJcGFnZXNbaV0gPSBwZzsKKworI2lmZGVmIENPTkZJR19YRU5fSEFW RV9QVk1NVQorCQlpZiAoIXhlbl9mZWF0dXJlKFhFTkZFQVRfYXV0b190cmFuc2xhdGVkX3BoeXNt YXApKSB7CisJCQlyZXQgPSB4ZW5fYWxsb2NfcDJtX2VudHJ5KHBhZ2VfdG9fcGZuKHBnKSk7CisJ CQlpZiAocmV0IDwgMCkgeworCQkJCXVuc2lnbmVkIGludCBqOworCisJCQkJZm9yIChqID0gMDsg aiA8PSBpOyBqKyspIHsKKwkJCQkJbGlzdF9hZGQoJnBhZ2VzW2pdLT5scnUsICZwYWdlX2xpc3Qp OworCQkJCQlsaXN0X2NvdW50Kys7CisJCQkJfQorCQkJCWdvdG8gb3V0OworCQkJfQorCQl9Cisj ZW5kaWYKKwl9CisKK291dDoKKwltdXRleF91bmxvY2soJmxpc3RfbG9jayk7CisJcmV0dXJuIHJl dDsKK30KK0VYUE9SVF9TWU1CT0woeGVuX2FsbG9jX3VucG9wdWxhdGVkX3BhZ2VzKTsKKworLyoq CisgKiB4ZW5fZnJlZV91bnBvcHVsYXRlZF9wYWdlcyAtIHJldHVybiB1bnBvcHVsYXRlZCBwYWdl cworICogQG5yX3BhZ2VzOiBOdW1iZXIgb2YgcGFnZXMKKyAqIEBwYWdlczogcGFnZXMgdG8gcmV0 dXJuCisgKi8KK3ZvaWQgeGVuX2ZyZWVfdW5wb3B1bGF0ZWRfcGFnZXModW5zaWduZWQgaW50IG5y X3BhZ2VzLCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKQoreworCXVuc2lnbmVkIGludCBpOworCisJbXV0 ZXhfbG9jaygmbGlzdF9sb2NrKTsKKwlmb3IgKGkgPSAwOyBpIDwgbnJfcGFnZXM7IGkrKykgewor CQlsaXN0X2FkZCgmcGFnZXNbaV0tPmxydSwgJnBhZ2VfbGlzdCk7CisJCWxpc3RfY291bnQrKzsK Kwl9CisJbXV0ZXhfdW5sb2NrKCZsaXN0X2xvY2spOworfQorRVhQT1JUX1NZTUJPTCh4ZW5fZnJl ZV91bnBvcHVsYXRlZF9wYWdlcyk7CisKKyNpZmRlZiBDT05GSUdfWEVOX1BWCitzdGF0aWMgaW50 IF9faW5pdCBpbml0KHZvaWQpCit7CisJdW5zaWduZWQgaW50IGk7CisKKwlpZiAoIXhlbl9kb21h aW4oKSkKKwkJcmV0dXJuIC1FTk9ERVY7CisKKwlpZiAoIXhlbl9wdl9kb21haW4oKSkKKwkJcmV0 dXJuIDA7CisKKwkvKgorCSAqIEluaXRpYWxpemUgd2l0aCBwYWdlcyBmcm9tIHRoZSBleHRyYSBt ZW1vcnkgcmVnaW9ucyAoc2VlCisJICogYXJjaC94ODYveGVuL3NldHVwLmMpLgorCSAqLworCWZv ciAoaSA9IDA7IGkgPCBYRU5fRVhUUkFfTUVNX01BWF9SRUdJT05TOyBpKyspIHsKKwkJdW5zaWdu ZWQgaW50IGo7CisKKwkJZm9yIChqID0gMDsgaiA8IHhlbl9leHRyYV9tZW1baV0ubl9wZm5zOyBq KyspIHsKKwkJCXN0cnVjdCBwYWdlICpwZyA9CisJCQkJcGZuX3RvX3BhZ2UoeGVuX2V4dHJhX21l bVtpXS5zdGFydF9wZm4gKyBqKTsKKworCQkJbGlzdF9hZGQoJnBnLT5scnUsICZwYWdlX2xpc3Qp OworCQkJbGlzdF9jb3VudCsrOworCQl9CisJfQorCisJcmV0dXJuIDA7Cit9CitzdWJzeXNfaW5p dGNhbGwoaW5pdCk7CisjZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL3hlbmJ1cy94ZW5i dXNfY2xpZW50LmMgYi9kcml2ZXJzL3hlbi94ZW5idXMveGVuYnVzX2NsaWVudC5jCmluZGV4IDc4 NmZiYjdkOGJlMC4uNzBiNmM0NzgwZmJkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi94ZW5idXMv eGVuYnVzX2NsaWVudC5jCisrKyBiL2RyaXZlcnMveGVuL3hlbmJ1cy94ZW5idXNfY2xpZW50LmMK QEAgLTYxNSw3ICs2MTUsNyBAQCBzdGF0aWMgaW50IHhlbmJ1c19tYXBfcmluZ19odm0oc3RydWN0 IHhlbmJ1c19kZXZpY2UgKmRldiwKIAlib29sIGxlYWtlZCA9IGZhbHNlOwogCXVuc2lnbmVkIGlu dCBucl9wYWdlcyA9IFhFTkJVU19QQUdFUyhucl9ncmVmcyk7CiAKLQllcnIgPSBhbGxvY194ZW5i YWxsb29uZWRfcGFnZXMobnJfcGFnZXMsIG5vZGUtPmh2bS5wYWdlcyk7CisJZXJyID0geGVuX2Fs bG9jX3VucG9wdWxhdGVkX3BhZ2VzKG5yX3BhZ2VzLCBub2RlLT5odm0ucGFnZXMpOwogCWlmIChl cnIpCiAJCWdvdG8gb3V0X2VycjsKIApAQCAtNjU2LDcgKzY1Niw3IEBAIHN0YXRpYyBpbnQgeGVu YnVzX21hcF9yaW5nX2h2bShzdHJ1Y3QgeGVuYnVzX2RldmljZSAqZGV2LAogCQkJIGFkZHIsIG5y X3BhZ2VzKTsKICBvdXRfZnJlZV9iYWxsb29uZWRfcGFnZXM6CiAJaWYgKCFsZWFrZWQpCi0JCWZy ZWVfeGVuYmFsbG9vbmVkX3BhZ2VzKG5yX3BhZ2VzLCBub2RlLT5odm0ucGFnZXMpOworCQl4ZW5f ZnJlZV91bnBvcHVsYXRlZF9wYWdlcyhucl9wYWdlcywgbm9kZS0+aHZtLnBhZ2VzKTsKICBvdXRf ZXJyOgogCXJldHVybiBlcnI7CiB9CkBAIC04NTIsNyArODUyLDcgQEAgc3RhdGljIGludCB4ZW5i dXNfdW5tYXBfcmluZ19odm0oc3RydWN0IHhlbmJ1c19kZXZpY2UgKmRldiwgdm9pZCAqdmFkZHIp CiAJCQkgICAgICAgaW5mby5hZGRycyk7CiAJaWYgKCFydikgewogCQl2dW5tYXAodmFkZHIpOwot CQlmcmVlX3hlbmJhbGxvb25lZF9wYWdlcyhucl9wYWdlcywgbm9kZS0+aHZtLnBhZ2VzKTsKKwkJ eGVuX2ZyZWVfdW5wb3B1bGF0ZWRfcGFnZXMobnJfcGFnZXMsIG5vZGUtPmh2bS5wYWdlcyk7CiAJ fQogCWVsc2UKIAkJV0FSTigxLCAiTGVha2luZyAlcCwgc2l6ZSAldSBwYWdlKHMpXG4iLCB2YWRk ciwgbnJfcGFnZXMpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4veGxhdGVfbW11LmMgYi9kcml2 ZXJzL3hlbi94bGF0ZV9tbXUuYwppbmRleCA3YjEwNzdmMGFiY2IuLjM0NzQyYzZlMTg5ZSAxMDA2 NDQKLS0tIGEvZHJpdmVycy94ZW4veGxhdGVfbW11LmMKKysrIGIvZHJpdmVycy94ZW4veGxhdGVf bW11LmMKQEAgLTIzMiw3ICsyMzIsNyBAQCBpbnQgX19pbml0IHhlbl94bGF0ZV9tYXBfYmFsbG9v bmVkX3BhZ2VzKHhlbl9wZm5fdCAqKmdmbnMsIHZvaWQgKip2aXJ0LAogCQlrZnJlZShwYWdlcyk7 CiAJCXJldHVybiAtRU5PTUVNOwogCX0KLQlyYyA9IGFsbG9jX3hlbmJhbGxvb25lZF9wYWdlcyhu cl9wYWdlcywgcGFnZXMpOworCXJjID0geGVuX2FsbG9jX3VucG9wdWxhdGVkX3BhZ2VzKG5yX3Bh Z2VzLCBwYWdlcyk7CiAJaWYgKHJjKSB7CiAJCXByX3dhcm4oIiVzIENvdWxkbid0IGJhbGxvb24g YWxsb2MgJWxkIHBhZ2VzIHJjOiVkXG4iLCBfX2Z1bmNfXywKIAkJCW5yX3BhZ2VzLCByYyk7CkBA IC0yNDksNyArMjQ5LDcgQEAgaW50IF9faW5pdCB4ZW5feGxhdGVfbWFwX2JhbGxvb25lZF9wYWdl cyh4ZW5fcGZuX3QgKipnZm5zLCB2b2lkICoqdmlydCwKIAlpZiAoIXZhZGRyKSB7CiAJCXByX3dh cm4oIiVzIENvdWxkbid0IG1hcCAlbGQgcGFnZXMgcmM6JWRcbiIsIF9fZnVuY19fLAogCQkJbnJf cGFnZXMsIHJjKTsKLQkJZnJlZV94ZW5iYWxsb29uZWRfcGFnZXMobnJfcGFnZXMsIHBhZ2VzKTsK KwkJeGVuX2ZyZWVfdW5wb3B1bGF0ZWRfcGFnZXMobnJfcGFnZXMsIHBhZ2VzKTsKIAkJa2ZyZWUo cGFnZXMpOwogCQlrZnJlZShwZm5zKTsKIAkJcmV0dXJuIC1FTk9NRU07CmRpZmYgLS1naXQgYS9p bmNsdWRlL3hlbi94ZW4uaCBiL2luY2x1ZGUveGVuL3hlbi5oCmluZGV4IDE5YTcyZjU5MWUyYi4u ZTkzYjQ3ZTVlMzc4IDEwMDY0NAotLS0gYS9pbmNsdWRlL3hlbi94ZW4uaAorKysgYi9pbmNsdWRl L3hlbi94ZW4uaApAQCAtNTIsNCArNTIsMTMgQEAgYm9vbCB4ZW5fYmlvdmVjX3BoeXNfbWVyZ2Vh YmxlKGNvbnN0IHN0cnVjdCBiaW9fdmVjICp2ZWMxLAogZXh0ZXJuIHU2NCB4ZW5fc2F2ZWRfbWF4 X21lbV9zaXplOwogI2VuZGlmCiAKKyNpZmRlZiBDT05GSUdfWk9ORV9ERVZJQ0UKK2ludCB4ZW5f YWxsb2NfdW5wb3B1bGF0ZWRfcGFnZXModW5zaWduZWQgaW50IG5yX3BhZ2VzLCBzdHJ1Y3QgcGFn ZSAqKnBhZ2VzKTsKK3ZvaWQgeGVuX2ZyZWVfdW5wb3B1bGF0ZWRfcGFnZXModW5zaWduZWQgaW50 IG5yX3BhZ2VzLCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKTsKKyNlbHNlCisjZGVmaW5lIHhlbl9hbGxv Y191bnBvcHVsYXRlZF9wYWdlcyBhbGxvY194ZW5iYWxsb29uZWRfcGFnZXMKKyNkZWZpbmUgeGVu X2ZyZWVfdW5wb3B1bGF0ZWRfcGFnZXMgZnJlZV94ZW5iYWxsb29uZWRfcGFnZXMKKyNpbmNsdWRl IDx4ZW4vYmFsbG9vbi5oPgorI2VuZGlmCisKICNlbmRpZgkvKiBfWEVOX1hFTl9IICovCi0tIAoy LjI3LjAKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRy aS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRw czovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo= 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 7E44FC433ED for ; Mon, 27 Jul 2020 09:15:20 +0000 (UTC) Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by mail.kernel.org (Postfix) with ESMTP id 26A1920656 for ; Mon, 27 Jul 2020 09:15:20 +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="NhJEftkg" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 26A1920656 Authentication-Results: mail.kernel.org; dmarc=fail (p=none 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 9AECB8D0001; Mon, 27 Jul 2020 05:15:19 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 960436B0007; Mon, 27 Jul 2020 05:15:19 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 84E508D0001; Mon, 27 Jul 2020 05:15:19 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from forelay.hostedemail.com (smtprelay0021.hostedemail.com [216.40.44.21]) by kanga.kvack.org (Postfix) with ESMTP id 6E54A6B0005 for ; Mon, 27 Jul 2020 05:15:19 -0400 (EDT) Received: from smtpin17.hostedemail.com (10.5.19.251.rfc1918.com [10.5.19.251]) by forelay05.hostedemail.com (Postfix) with ESMTP id 22E28181AC9BF for ; Mon, 27 Jul 2020 09:15:19 +0000 (UTC) X-FDA: 77083297158.17.sink42_450dfc326f60 Received: from filter.hostedemail.com (10.5.16.251.rfc1918.com [10.5.16.251]) by smtpin17.hostedemail.com (Postfix) with ESMTP id CC6AB180D01BC for ; Mon, 27 Jul 2020 09:15:16 +0000 (UTC) X-HE-Tag: sink42_450dfc326f60 X-Filterd-Recvd-Size: 16914 Received: from esa1.hc3370-68.iphmx.com (esa1.hc3370-68.iphmx.com [216.71.145.142]) by imf36.hostedemail.com (Postfix) with ESMTP for ; Mon, 27 Jul 2020 09:15:15 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=citrix.com; s=securemail; t=1595841316; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=ypPb5+5mjFQ6dtbL/IxbCNOjD1qVztAdhRNp+jbSIJA=; b=NhJEftkgeJZjqomfSQFgUNECyrNA+sbrkcXlYYYDEoil/fyNLhMbX8uc hYL3m6iRn8RJOXLIaoTf+6facrmqaxxDPcx0An8rXR0Wn74teWgvkBQkS SW5NIZNo7q9i2ShSMUXMX3Si/hfOGMUGnupkzy5Sa6gxJVmgZHyRbN0pE M=; Authentication-Results: esa1.hc3370-68.iphmx.com; dkim=none (message not signed) header.i=none IronPort-SDR: WXyj5KnFWi7XSH4TWCBzVsr8ZMwp+EDQ+LH8inkEJ8y5c8ZI7GpHdELUbkfU50zaT0y+UJ2bg3 tGkQTS7Cd3n2F0avfc4p3Tv4Om4nVMPdfCIP2fH81xedkGHO42gQj0gaw5WITMYWnXwXlCpuOv fYda7epWjgoXV8dnH06TOLIkMc6zV5hwVEA84Nsa63862itJEJbTBUF/qzfcmTAgkBOmuv72yn QGZrTN5pyKY/pg/gEvRVPcy84WdrnQKei0WAIP2Epw33rEGjpdrfi7j5pDPW8jfmK3gQUzufVG K4A= X-SBRS: 2.7 X-MesageID: 23569868 X-Ironport-Server: esa1.hc3370-68.iphmx.com X-Remote-IP: 162.221.158.21 X-Policy: $RELAYED X-IronPort-AV: E=Sophos;i="5.75,402,1589256000"; d="scan'208";a="23569868" 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 v3 4/4] xen: add helpers to allocate unpopulated memory Date: Mon, 27 Jul 2020 11:13:42 +0200 Message-ID: <20200727091342.52325-5-roger.pau@citrix.com> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20200727091342.52325-1-roger.pau@citrix.com> References: <20200727091342.52325-1-roger.pau@citrix.com> MIME-Version: 1.0 Content-Type: text/plain; charset="UTF-8" X-Rspamd-Queue-Id: CC6AB180D01BC X-Spamd-Result: default: False [0.00 / 100.00] X-Rspamd-Server: rspam03 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. Signed-off-by: Roger Pau Monn=C3=A9 --- I've not added a new memory_type type and just used MEMORY_DEVICE_DEVDAX which seems to be what we want for such memory regions. I'm unsure whether abusing this type is fine, or if I should instead add a specific type, maybe MEMORY_DEVICE_GENERIC? I don't think we should be using a specific Xen type at all. --- 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 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/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 ++ 9 files changed, 211 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/Makefile b/drivers/xen/Makefile index 0d322f3d90cd..788a5d9c8ef0 100644 --- a/drivers/xen/Makefile +++ b/drivers/xen/Makefile @@ -42,3 +42,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_ZONE_DEVICE) +=3D unpopulated-alloc.o diff --git a/drivers/xen/balloon.c b/drivers/xen/balloon.c index b1d8b028bf80..815ef10eb2ff 100644 --- a/drivers/xen/balloon.c +++ b/drivers/xen/balloon.c @@ -654,7 +654,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_ZONE_DEVICE) static void __init balloon_add_region(unsigned long start_pfn, unsigned long pages) { @@ -708,7 +708,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_ZONE_DEVICE) { 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 a250d118144a..56000ab70974 100644 --- a/drivers/xen/privcmd.c +++ b/drivers/xen/privcmd.c @@ -425,7 +425,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); @@ -900,7 +900,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..c50450375922 --- /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_DEVDAX; + 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..e93b47e5e378 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_ZONE_DEVICE +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.27.0