From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752665AbdCBSuw (ORCPT ); Thu, 2 Mar 2017 13:50:52 -0500 Received: from mx1.redhat.com ([209.132.183.28]:33976 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751255AbdCBSur (ORCPT ); Thu, 2 Mar 2017 13:50:47 -0500 From: Vitaly Kuznetsov To: xen-devel@lists.xenproject.org Cc: x86@kernel.org, linux-kernel@vger.kernel.org, Boris Ostrovsky , Juergen Gross , Andrew Jones Subject: [PATCH v2 12/21] x86/xen: split off mmu_hvm.c Date: Thu, 2 Mar 2017 18:53:48 +0100 Message-Id: <20170302175357.8222-13-vkuznets@redhat.com> In-Reply-To: <20170302175357.8222-1-vkuznets@redhat.com> References: <20170302175357.8222-1-vkuznets@redhat.com> X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.39]); Thu, 02 Mar 2017 17:54:22 +0000 (UTC) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Move PVHVM related code to mmu_hvm.c. Signed-off-by: Vitaly Kuznetsov --- arch/x86/xen/Makefile | 2 +- arch/x86/xen/mmu.c | 74 ---------------------------------------------- arch/x86/xen/mmu_hvm.c | 79 ++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 80 insertions(+), 75 deletions(-) create mode 100644 arch/x86/xen/mmu_hvm.c diff --git a/arch/x86/xen/Makefile b/arch/x86/xen/Makefile index ebf3522..6a95a8b 100644 --- a/arch/x86/xen/Makefile +++ b/arch/x86/xen/Makefile @@ -15,7 +15,7 @@ obj-y := enlighten.o setup.o multicalls.o mmu.o irq.o \ grant-table.o suspend.o platform-pci-unplug.o \ p2m.o apic.o pmu.o enlighten_pv.o -obj-$(CONFIG_XEN_PVHVM) += enlighten_hvm.o +obj-$(CONFIG_XEN_PVHVM) += enlighten_hvm.o mmu_hvm.o obj-$(CONFIG_XEN_PVH) += enlighten_pvh.o obj-$(CONFIG_EVENT_TRACING) += trace.o diff --git a/arch/x86/xen/mmu.c b/arch/x86/xen/mmu.c index f6740b5..4dfcb06 100644 --- a/arch/x86/xen/mmu.c +++ b/arch/x86/xen/mmu.c @@ -2689,80 +2689,6 @@ void xen_destroy_contiguous_region(phys_addr_t pstart, unsigned int order) } EXPORT_SYMBOL_GPL(xen_destroy_contiguous_region); -#ifdef CONFIG_XEN_PVHVM -#ifdef CONFIG_PROC_VMCORE -/* - * This function is used in two contexts: - * - the kdump kernel has to check whether a pfn of the crashed kernel - * was a ballooned page. vmcore is using this function to decide - * whether to access a pfn of the crashed kernel. - * - the kexec kernel has to check whether a pfn was ballooned by the - * previous kernel. If the pfn is ballooned, handle it properly. - * Returns 0 if the pfn is not backed by a RAM page, the caller may - * handle the pfn special in this case. - */ -static int xen_oldmem_pfn_is_ram(unsigned long pfn) -{ - struct xen_hvm_get_mem_type a = { - .domid = DOMID_SELF, - .pfn = pfn, - }; - int ram; - - if (HYPERVISOR_hvm_op(HVMOP_get_mem_type, &a)) - return -ENXIO; - - switch (a.mem_type) { - case HVMMEM_mmio_dm: - ram = 0; - break; - case HVMMEM_ram_rw: - case HVMMEM_ram_ro: - default: - ram = 1; - break; - } - - return ram; -} -#endif - -static void xen_hvm_exit_mmap(struct mm_struct *mm) -{ - struct xen_hvm_pagetable_dying a; - int rc; - - a.domid = DOMID_SELF; - a.gpa = __pa(mm->pgd); - rc = HYPERVISOR_hvm_op(HVMOP_pagetable_dying, &a); - WARN_ON_ONCE(rc < 0); -} - -static int is_pagetable_dying_supported(void) -{ - struct xen_hvm_pagetable_dying a; - int rc = 0; - - a.domid = DOMID_SELF; - a.gpa = 0x00; - rc = HYPERVISOR_hvm_op(HVMOP_pagetable_dying, &a); - if (rc < 0) { - printk(KERN_DEBUG "HVMOP_pagetable_dying not supported\n"); - return 0; - } - return 1; -} - -void __init xen_hvm_init_mmu_ops(void) -{ - if (is_pagetable_dying_supported()) - pv_mmu_ops.exit_mmap = xen_hvm_exit_mmap; -#ifdef CONFIG_PROC_VMCORE - register_oldmem_pfn_is_ram(&xen_oldmem_pfn_is_ram); -#endif -} -#endif - #define REMAP_BATCH_SIZE 16 struct remap_data { diff --git a/arch/x86/xen/mmu_hvm.c b/arch/x86/xen/mmu_hvm.c new file mode 100644 index 0000000..1c57f1c --- /dev/null +++ b/arch/x86/xen/mmu_hvm.c @@ -0,0 +1,79 @@ +#include +#include + +#include +#include + +#include "mmu.h" + +#ifdef CONFIG_PROC_VMCORE +/* + * This function is used in two contexts: + * - the kdump kernel has to check whether a pfn of the crashed kernel + * was a ballooned page. vmcore is using this function to decide + * whether to access a pfn of the crashed kernel. + * - the kexec kernel has to check whether a pfn was ballooned by the + * previous kernel. If the pfn is ballooned, handle it properly. + * Returns 0 if the pfn is not backed by a RAM page, the caller may + * handle the pfn special in this case. + */ +static int xen_oldmem_pfn_is_ram(unsigned long pfn) +{ + struct xen_hvm_get_mem_type a = { + .domid = DOMID_SELF, + .pfn = pfn, + }; + int ram; + + if (HYPERVISOR_hvm_op(HVMOP_get_mem_type, &a)) + return -ENXIO; + + switch (a.mem_type) { + case HVMMEM_mmio_dm: + ram = 0; + break; + case HVMMEM_ram_rw: + case HVMMEM_ram_ro: + default: + ram = 1; + break; + } + + return ram; +} +#endif + +static void xen_hvm_exit_mmap(struct mm_struct *mm) +{ + struct xen_hvm_pagetable_dying a; + int rc; + + a.domid = DOMID_SELF; + a.gpa = __pa(mm->pgd); + rc = HYPERVISOR_hvm_op(HVMOP_pagetable_dying, &a); + WARN_ON_ONCE(rc < 0); +} + +static int is_pagetable_dying_supported(void) +{ + struct xen_hvm_pagetable_dying a; + int rc = 0; + + a.domid = DOMID_SELF; + a.gpa = 0x00; + rc = HYPERVISOR_hvm_op(HVMOP_pagetable_dying, &a); + if (rc < 0) { + printk(KERN_DEBUG "HVMOP_pagetable_dying not supported\n"); + return 0; + } + return 1; +} + +void __init xen_hvm_init_mmu_ops(void) +{ + if (is_pagetable_dying_supported()) + pv_mmu_ops.exit_mmap = xen_hvm_exit_mmap; +#ifdef CONFIG_PROC_VMCORE + register_oldmem_pfn_is_ram(&xen_oldmem_pfn_is_ram); +#endif +} -- 2.9.3 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Vitaly Kuznetsov Subject: [PATCH v2 12/21] x86/xen: split off mmu_hvm.c Date: Thu, 2 Mar 2017 18:53:48 +0100 Message-ID: <20170302175357.8222-13-vkuznets@redhat.com> References: <20170302175357.8222-1-vkuznets@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail6.bemta3.messagelabs.com ([195.245.230.39]) by lists.xenproject.org with esmtp (Exim 4.84_2) (envelope-from ) id 1cjUvo-0003e8-M4 for xen-devel@lists.xenproject.org; Thu, 02 Mar 2017 17:54:24 +0000 In-Reply-To: <20170302175357.8222-1-vkuznets@redhat.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: xen-devel@lists.xenproject.org Cc: Juergen Gross , Boris Ostrovsky , x86@kernel.org, Andrew Jones , linux-kernel@vger.kernel.org List-Id: xen-devel@lists.xenproject.org TW92ZSBQVkhWTSByZWxhdGVkIGNvZGUgdG8gbW11X2h2bS5jLgoKU2lnbmVkLW9mZi1ieTogVml0 YWx5IEt1em5ldHNvdiA8dmt1em5ldHNAcmVkaGF0LmNvbT4KLS0tCiBhcmNoL3g4Ni94ZW4vTWFr ZWZpbGUgIHwgIDIgKy0KIGFyY2gveDg2L3hlbi9tbXUuYyAgICAgfCA3NCAtLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiBhcmNoL3g4Ni94ZW4vbW11X2h2bS5j IHwgNzkgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysK IDMgZmlsZXMgY2hhbmdlZCwgODAgaW5zZXJ0aW9ucygrKSwgNzUgZGVsZXRpb25zKC0pCiBjcmVh dGUgbW9kZSAxMDA2NDQgYXJjaC94ODYveGVuL21tdV9odm0uYwoKZGlmZiAtLWdpdCBhL2FyY2gv eDg2L3hlbi9NYWtlZmlsZSBiL2FyY2gveDg2L3hlbi9NYWtlZmlsZQppbmRleCBlYmYzNTIyLi42 YTk1YThiIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni94ZW4vTWFrZWZpbGUKKysrIGIvYXJjaC94ODYv eGVuL01ha2VmaWxlCkBAIC0xNSw3ICsxNSw3IEBAIG9iai15CQk6PSBlbmxpZ2h0ZW4ubyBzZXR1 cC5vIG11bHRpY2FsbHMubyBtbXUubyBpcnEubyBcCiAJCQlncmFudC10YWJsZS5vIHN1c3BlbmQu byBwbGF0Zm9ybS1wY2ktdW5wbHVnLm8gXAogCQkJcDJtLm8gYXBpYy5vIHBtdS5vIGVubGlnaHRl bl9wdi5vCiAKLW9iai0kKENPTkZJR19YRU5fUFZIVk0pCQkrPSBlbmxpZ2h0ZW5faHZtLm8KK29i ai0kKENPTkZJR19YRU5fUFZIVk0pCQkrPSBlbmxpZ2h0ZW5faHZtLm8gbW11X2h2bS5vCiBvYmot JChDT05GSUdfWEVOX1BWSCkJCQkrPSBlbmxpZ2h0ZW5fcHZoLm8KIAogb2JqLSQoQ09ORklHX0VW RU5UX1RSQUNJTkcpICs9IHRyYWNlLm8KZGlmZiAtLWdpdCBhL2FyY2gveDg2L3hlbi9tbXUuYyBi L2FyY2gveDg2L3hlbi9tbXUuYwppbmRleCBmNjc0MGI1Li40ZGZjYjA2IDEwMDY0NAotLS0gYS9h cmNoL3g4Ni94ZW4vbW11LmMKKysrIGIvYXJjaC94ODYveGVuL21tdS5jCkBAIC0yNjg5LDgwICsy Njg5LDYgQEAgdm9pZCB4ZW5fZGVzdHJveV9jb250aWd1b3VzX3JlZ2lvbihwaHlzX2FkZHJfdCBw c3RhcnQsIHVuc2lnbmVkIGludCBvcmRlcikKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKHhlbl9kZXN0 cm95X2NvbnRpZ3VvdXNfcmVnaW9uKTsKIAotI2lmZGVmIENPTkZJR19YRU5fUFZIVk0KLSNpZmRl ZiBDT05GSUdfUFJPQ19WTUNPUkUKLS8qCi0gKiBUaGlzIGZ1bmN0aW9uIGlzIHVzZWQgaW4gdHdv IGNvbnRleHRzOgotICogLSB0aGUga2R1bXAga2VybmVsIGhhcyB0byBjaGVjayB3aGV0aGVyIGEg cGZuIG9mIHRoZSBjcmFzaGVkIGtlcm5lbAotICogICB3YXMgYSBiYWxsb29uZWQgcGFnZS4gdm1j b3JlIGlzIHVzaW5nIHRoaXMgZnVuY3Rpb24gdG8gZGVjaWRlCi0gKiAgIHdoZXRoZXIgdG8gYWNj ZXNzIGEgcGZuIG9mIHRoZSBjcmFzaGVkIGtlcm5lbC4KLSAqIC0gdGhlIGtleGVjIGtlcm5lbCBo YXMgdG8gY2hlY2sgd2hldGhlciBhIHBmbiB3YXMgYmFsbG9vbmVkIGJ5IHRoZQotICogICBwcmV2 aW91cyBrZXJuZWwuIElmIHRoZSBwZm4gaXMgYmFsbG9vbmVkLCBoYW5kbGUgaXQgcHJvcGVybHku Ci0gKiBSZXR1cm5zIDAgaWYgdGhlIHBmbiBpcyBub3QgYmFja2VkIGJ5IGEgUkFNIHBhZ2UsIHRo ZSBjYWxsZXIgbWF5Ci0gKiBoYW5kbGUgdGhlIHBmbiBzcGVjaWFsIGluIHRoaXMgY2FzZS4KLSAq Lwotc3RhdGljIGludCB4ZW5fb2xkbWVtX3Bmbl9pc19yYW0odW5zaWduZWQgbG9uZyBwZm4pCi17 Ci0Jc3RydWN0IHhlbl9odm1fZ2V0X21lbV90eXBlIGEgPSB7Ci0JCS5kb21pZCA9IERPTUlEX1NF TEYsCi0JCS5wZm4gPSBwZm4sCi0JfTsKLQlpbnQgcmFtOwotCi0JaWYgKEhZUEVSVklTT1JfaHZt X29wKEhWTU9QX2dldF9tZW1fdHlwZSwgJmEpKQotCQlyZXR1cm4gLUVOWElPOwotCi0Jc3dpdGNo IChhLm1lbV90eXBlKSB7Ci0JCWNhc2UgSFZNTUVNX21taW9fZG06Ci0JCQlyYW0gPSAwOwotCQkJ YnJlYWs7Ci0JCWNhc2UgSFZNTUVNX3JhbV9ydzoKLQkJY2FzZSBIVk1NRU1fcmFtX3JvOgotCQlk ZWZhdWx0OgotCQkJcmFtID0gMTsKLQkJCWJyZWFrOwotCX0KLQotCXJldHVybiByYW07Ci19Ci0j ZW5kaWYKLQotc3RhdGljIHZvaWQgeGVuX2h2bV9leGl0X21tYXAoc3RydWN0IG1tX3N0cnVjdCAq bW0pCi17Ci0Jc3RydWN0IHhlbl9odm1fcGFnZXRhYmxlX2R5aW5nIGE7Ci0JaW50IHJjOwotCi0J YS5kb21pZCA9IERPTUlEX1NFTEY7Ci0JYS5ncGEgPSBfX3BhKG1tLT5wZ2QpOwotCXJjID0gSFlQ RVJWSVNPUl9odm1fb3AoSFZNT1BfcGFnZXRhYmxlX2R5aW5nLCAmYSk7Ci0JV0FSTl9PTl9PTkNF KHJjIDwgMCk7Ci19Ci0KLXN0YXRpYyBpbnQgaXNfcGFnZXRhYmxlX2R5aW5nX3N1cHBvcnRlZCh2 b2lkKQotewotCXN0cnVjdCB4ZW5faHZtX3BhZ2V0YWJsZV9keWluZyBhOwotCWludCByYyA9IDA7 Ci0KLQlhLmRvbWlkID0gRE9NSURfU0VMRjsKLQlhLmdwYSA9IDB4MDA7Ci0JcmMgPSBIWVBFUlZJ U09SX2h2bV9vcChIVk1PUF9wYWdldGFibGVfZHlpbmcsICZhKTsKLQlpZiAocmMgPCAwKSB7Ci0J CXByaW50ayhLRVJOX0RFQlVHICJIVk1PUF9wYWdldGFibGVfZHlpbmcgbm90IHN1cHBvcnRlZFxu Iik7Ci0JCXJldHVybiAwOwotCX0KLQlyZXR1cm4gMTsKLX0KLQotdm9pZCBfX2luaXQgeGVuX2h2 bV9pbml0X21tdV9vcHModm9pZCkKLXsKLQlpZiAoaXNfcGFnZXRhYmxlX2R5aW5nX3N1cHBvcnRl ZCgpKQotCQlwdl9tbXVfb3BzLmV4aXRfbW1hcCA9IHhlbl9odm1fZXhpdF9tbWFwOwotI2lmZGVm IENPTkZJR19QUk9DX1ZNQ09SRQotCXJlZ2lzdGVyX29sZG1lbV9wZm5faXNfcmFtKCZ4ZW5fb2xk bWVtX3Bmbl9pc19yYW0pOwotI2VuZGlmCi19Ci0jZW5kaWYKLQogI2RlZmluZSBSRU1BUF9CQVRD SF9TSVpFIDE2CiAKIHN0cnVjdCByZW1hcF9kYXRhIHsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L3hl bi9tbXVfaHZtLmMgYi9hcmNoL3g4Ni94ZW4vbW11X2h2bS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAuLjFjNTdmMWMKLS0tIC9kZXYvbnVsbAorKysgYi9hcmNoL3g4Ni94ZW4v bW11X2h2bS5jCkBAIC0wLDAgKzEsNzkgQEAKKyNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgorI2lu Y2x1ZGUgPGxpbnV4L2NyYXNoX2R1bXAuaD4KKworI2luY2x1ZGUgPHhlbi9pbnRlcmZhY2UveGVu Lmg+CisjaW5jbHVkZSA8eGVuL2h2bS5oPgorCisjaW5jbHVkZSAibW11LmgiCisKKyNpZmRlZiBD T05GSUdfUFJPQ19WTUNPUkUKKy8qCisgKiBUaGlzIGZ1bmN0aW9uIGlzIHVzZWQgaW4gdHdvIGNv bnRleHRzOgorICogLSB0aGUga2R1bXAga2VybmVsIGhhcyB0byBjaGVjayB3aGV0aGVyIGEgcGZu IG9mIHRoZSBjcmFzaGVkIGtlcm5lbAorICogICB3YXMgYSBiYWxsb29uZWQgcGFnZS4gdm1jb3Jl IGlzIHVzaW5nIHRoaXMgZnVuY3Rpb24gdG8gZGVjaWRlCisgKiAgIHdoZXRoZXIgdG8gYWNjZXNz IGEgcGZuIG9mIHRoZSBjcmFzaGVkIGtlcm5lbC4KKyAqIC0gdGhlIGtleGVjIGtlcm5lbCBoYXMg dG8gY2hlY2sgd2hldGhlciBhIHBmbiB3YXMgYmFsbG9vbmVkIGJ5IHRoZQorICogICBwcmV2aW91 cyBrZXJuZWwuIElmIHRoZSBwZm4gaXMgYmFsbG9vbmVkLCBoYW5kbGUgaXQgcHJvcGVybHkuCisg KiBSZXR1cm5zIDAgaWYgdGhlIHBmbiBpcyBub3QgYmFja2VkIGJ5IGEgUkFNIHBhZ2UsIHRoZSBj YWxsZXIgbWF5CisgKiBoYW5kbGUgdGhlIHBmbiBzcGVjaWFsIGluIHRoaXMgY2FzZS4KKyAqLwor c3RhdGljIGludCB4ZW5fb2xkbWVtX3Bmbl9pc19yYW0odW5zaWduZWQgbG9uZyBwZm4pCit7CisJ c3RydWN0IHhlbl9odm1fZ2V0X21lbV90eXBlIGEgPSB7CisJCS5kb21pZCA9IERPTUlEX1NFTEYs CisJCS5wZm4gPSBwZm4sCisJfTsKKwlpbnQgcmFtOworCisJaWYgKEhZUEVSVklTT1JfaHZtX29w KEhWTU9QX2dldF9tZW1fdHlwZSwgJmEpKQorCQlyZXR1cm4gLUVOWElPOworCisJc3dpdGNoIChh Lm1lbV90eXBlKSB7CisJY2FzZSBIVk1NRU1fbW1pb19kbToKKwkJcmFtID0gMDsKKwkJYnJlYWs7 CisJY2FzZSBIVk1NRU1fcmFtX3J3OgorCWNhc2UgSFZNTUVNX3JhbV9ybzoKKwlkZWZhdWx0Ogor CQlyYW0gPSAxOworCQlicmVhazsKKwl9CisKKwlyZXR1cm4gcmFtOworfQorI2VuZGlmCisKK3N0 YXRpYyB2b2lkIHhlbl9odm1fZXhpdF9tbWFwKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQoreworCXN0 cnVjdCB4ZW5faHZtX3BhZ2V0YWJsZV9keWluZyBhOworCWludCByYzsKKworCWEuZG9taWQgPSBE T01JRF9TRUxGOworCWEuZ3BhID0gX19wYShtbS0+cGdkKTsKKwlyYyA9IEhZUEVSVklTT1JfaHZt X29wKEhWTU9QX3BhZ2V0YWJsZV9keWluZywgJmEpOworCVdBUk5fT05fT05DRShyYyA8IDApOwor fQorCitzdGF0aWMgaW50IGlzX3BhZ2V0YWJsZV9keWluZ19zdXBwb3J0ZWQodm9pZCkKK3sKKwlz dHJ1Y3QgeGVuX2h2bV9wYWdldGFibGVfZHlpbmcgYTsKKwlpbnQgcmMgPSAwOworCisJYS5kb21p ZCA9IERPTUlEX1NFTEY7CisJYS5ncGEgPSAweDAwOworCXJjID0gSFlQRVJWSVNPUl9odm1fb3Ao SFZNT1BfcGFnZXRhYmxlX2R5aW5nLCAmYSk7CisJaWYgKHJjIDwgMCkgeworCQlwcmludGsoS0VS Tl9ERUJVRyAiSFZNT1BfcGFnZXRhYmxlX2R5aW5nIG5vdCBzdXBwb3J0ZWRcbiIpOworCQlyZXR1 cm4gMDsKKwl9CisJcmV0dXJuIDE7Cit9CisKK3ZvaWQgX19pbml0IHhlbl9odm1faW5pdF9tbXVf b3BzKHZvaWQpCit7CisJaWYgKGlzX3BhZ2V0YWJsZV9keWluZ19zdXBwb3J0ZWQoKSkKKwkJcHZf bW11X29wcy5leGl0X21tYXAgPSB4ZW5faHZtX2V4aXRfbW1hcDsKKyNpZmRlZiBDT05GSUdfUFJP Q19WTUNPUkUKKwlyZWdpc3Rlcl9vbGRtZW1fcGZuX2lzX3JhbSgmeGVuX29sZG1lbV9wZm5faXNf cmFtKTsKKyNlbmRpZgorfQotLSAKMi45LjMKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fXwpYZW4tZGV2ZWwgbWFpbGluZyBsaXN0Clhlbi1kZXZlbEBsaXN0 cy54ZW4ub3JnCmh0dHBzOi8vbGlzdHMueGVuLm9yZy94ZW4tZGV2ZWwK