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 Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7C3E6C433F5 for ; Fri, 15 Apr 2022 15:21:03 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1354953AbiDOPXa (ORCPT ); Fri, 15 Apr 2022 11:23:30 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:47544 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242475AbiDOPX3 (ORCPT ); Fri, 15 Apr 2022 11:23:29 -0400 Received: from mail-lj1-x22b.google.com (mail-lj1-x22b.google.com [IPv6:2a00:1450:4864:20::22b]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 827DB5C64F for ; Fri, 15 Apr 2022 08:20:59 -0700 (PDT) Received: by mail-lj1-x22b.google.com with SMTP id o16so9840441ljp.3 for ; Fri, 15 Apr 2022 08:20:59 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=subject:to:cc:references:from:message-id:date:user-agent :mime-version:in-reply-to:content-transfer-encoding:content-language; bh=tKPtQz+15frjCFqtKqOJi6EaMDFvouH7Zhy6D7XdcRQ=; b=iMQhO3UyThOnnoJuPW45l59saUXzOpnn2SSyXXhV0SO20SvDU4ozWdMEcvNk1cYhWE JJXUs8s8k7ddksgmfTzy0juYSOz3O2OPfA/xQuaDAUHQhtvtvvioZHE121kzLCXYCEIv w9OBPAWtl/2kxVdgDLFK+taJvIEqzadWKar7xfr1RhPp8OuuaOgsOIkCDBbQIf1tnNzI Okk3WO387jSJMT0Td/g756NWcFrxa+x/6s2PQEwj5758Q0xEaz3xa9LEh1SQwRoS2ucm CP0l4F/nBniNW/TODw0pTAKBtMyWrpUfJVf6RyIIXfI87N7xjLF9okkr/lJTtAiF1w7n VPxQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:subject:to:cc:references:from:message-id:date :user-agent:mime-version:in-reply-to:content-transfer-encoding :content-language; bh=tKPtQz+15frjCFqtKqOJi6EaMDFvouH7Zhy6D7XdcRQ=; b=0kZ44srqxGLwFSU9gAPovxmzmHRHiiyM19zlAVgrxTyrtwt6zI1yCJRDpIEB/E+TwQ G+f+dzOyU4B1d962zOJbs8GoetclM/SNHHBNWsgkd+zpqdBjyWKab5DbztDyVImrUzuy XvQy2HnRtxb8jaJAX4jthd1U3Lib1Rl8WkJh5f9jZGmA6iBzbf7nGE8a+RL/hFXs1Pzw mpJ0TRKOmr1rTN696jFnDgmeCtaHu8b+j6Y965XYVlGXGn/8oucRi3sCLKEAsDnAdrfi L9ugmL+RXLf0mWh5IHNg7aDn6f3egLJQx7Iy+hcwmQYa+nBwlWv6grPi1G6ulCokvL5E VNvQ== X-Gm-Message-State: AOAM532jS6crZCfRYzQQzQ8mLGcY2MJPdKpYw8GbDbBhPQaHgbx+Svyh S86WaI1fWEj0HJDI4KVO0mg= X-Google-Smtp-Source: ABdhPJziuyJyQYEu7x8SHebulqTxg+V1vpGA+dmLswY7ea4Efi9mFESgm9VTDaGLQC3z9xTvYuj0bg== X-Received: by 2002:a2e:a553:0:b0:24b:2081:2bbf with SMTP id e19-20020a2ea553000000b0024b20812bbfmr4632775ljn.414.1650036057479; Fri, 15 Apr 2022 08:20:57 -0700 (PDT) Received: from [192.168.1.7] ([212.22.223.21]) by smtp.gmail.com with ESMTPSA id p25-20020a056512313900b0046f4f252ebfsm175823lfd.226.2022.04.15.08.20.55 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Fri, 15 Apr 2022 08:20:56 -0700 (PDT) Subject: Re: [RFC PATCH 2/6] virtio: add option to restrict memory access under Xen To: "H. Peter Anvin" Cc: xen-devel@lists.xenproject.org, x86@kernel.org, linux-kernel@vger.kernel.org, Juergen Gross , Dave Hansen , Andy Lutomirski , Peter Zijlstra , Thomas Gleixner , Ingo Molnar , Borislav Petkov , Boris Ostrovsky , Stefano Stabellini , Julien Grall , Oleksandr Tyshchenko , Christoph Hellwig , "Michael S. Tsirkin" , linux-arm-kernel@lists.infradead.org References: <1649963973-22879-1-git-send-email-olekstysh@gmail.com> <1649963973-22879-3-git-send-email-olekstysh@gmail.com> <5A795507-715D-494B-B56B-B12E5BE348A4@zytor.com> From: Oleksandr Message-ID: <6b3ceb42-5848-4a1b-61d7-f37c4a18d725@gmail.com> Date: Fri, 15 Apr 2022 18:20:55 +0300 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.10.0 MIME-Version: 1.0 In-Reply-To: <5A795507-715D-494B-B56B-B12E5BE348A4@zytor.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit Content-Language: en-US Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 14.04.22 22:43, H. Peter Anvin wrote: Hello Peter > On April 14, 2022 12:19:29 PM PDT, Oleksandr Tyshchenko wrote: >> From: Juergen Gross >> >> In order to support virtio in Xen guests add a config option enabling >> the user to specify whether in all Xen guests virtio should be able to >> access memory via Xen grant mappings only on the host side. >> >> This applies to fully virtualized guests only, as for paravirtualized >> guests this is mandatory. >> >> This requires to switch arch_has_restricted_virtio_memory_access() > >from a pure stub to a real function on x86 systems (Arm systems are >> not covered by now). >> >> Add the needed functionality by providing a special set of DMA ops >> handling the needed grant operations for the I/O pages. >> >> Signed-off-by: Juergen Gross >> --- >> arch/x86/mm/init.c | 15 ++++ >> arch/x86/mm/mem_encrypt.c | 5 -- >> arch/x86/xen/Kconfig | 9 +++ >> drivers/xen/Kconfig | 20 ++++++ >> drivers/xen/Makefile | 1 + >> drivers/xen/xen-virtio.c | 177 ++++++++++++++++++++++++++++++++++++++++++++++ >> include/xen/xen-ops.h | 8 +++ >> 7 files changed, 230 insertions(+), 5 deletions(-) >> create mode 100644 drivers/xen/xen-virtio.c >> >> diff --git a/arch/x86/mm/init.c b/arch/x86/mm/init.c >> index d8cfce2..526a3b2 100644 >> --- a/arch/x86/mm/init.c >> +++ b/arch/x86/mm/init.c >> @@ -8,6 +8,8 @@ >> #include >> #include >> >> +#include >> + >> #include >> #include >> #include >> @@ -1065,3 +1067,16 @@ unsigned long max_swapfile_size(void) >> return pages; >> } >> #endif >> + >> +#ifdef CONFIG_ARCH_HAS_RESTRICTED_VIRTIO_MEMORY_ACCESS >> +int arch_has_restricted_virtio_memory_access(void) >> +{ >> + if (IS_ENABLED(CONFIG_XEN_PV_VIRTIO) && xen_pv_domain()) >> + return 1; >> + if (IS_ENABLED(CONFIG_XEN_HVM_VIRTIO_GRANT) && xen_hvm_domain()) >> + return 1; >> + >> + return cc_platform_has(CC_ATTR_GUEST_MEM_ENCRYPT); >> +} >> +EXPORT_SYMBOL_GPL(arch_has_restricted_virtio_memory_access); >> +#endif >> diff --git a/arch/x86/mm/mem_encrypt.c b/arch/x86/mm/mem_encrypt.c >> index 50d2099..dda020f 100644 >> --- a/arch/x86/mm/mem_encrypt.c >> +++ b/arch/x86/mm/mem_encrypt.c >> @@ -77,8 +77,3 @@ void __init mem_encrypt_init(void) >> print_mem_encrypt_feature_info(); >> } >> >> -int arch_has_restricted_virtio_memory_access(void) >> -{ >> - return cc_platform_has(CC_ATTR_GUEST_MEM_ENCRYPT); >> -} >> -EXPORT_SYMBOL_GPL(arch_has_restricted_virtio_memory_access); >> diff --git a/arch/x86/xen/Kconfig b/arch/x86/xen/Kconfig >> index 85246dd..dffdffd 100644 >> --- a/arch/x86/xen/Kconfig >> +++ b/arch/x86/xen/Kconfig >> @@ -92,3 +92,12 @@ config XEN_DOM0 >> select X86_X2APIC if XEN_PVH && X86_64 >> help >> Support running as a Xen Dom0 guest. >> + >> +config XEN_PV_VIRTIO >> + bool "Xen virtio support for PV guests" >> + depends on XEN_VIRTIO && XEN_PV >> + default y >> + help >> + Support virtio for running as a paravirtualized guest. This will >> + need support on the backend side (qemu or kernel, depending on the >> + virtio device types used). >> diff --git a/drivers/xen/Kconfig b/drivers/xen/Kconfig >> index 120d32f..fc61f7a 100644 >> --- a/drivers/xen/Kconfig >> +++ b/drivers/xen/Kconfig >> @@ -335,4 +335,24 @@ config XEN_UNPOPULATED_ALLOC >> having to balloon out RAM regions in order to obtain physical memory >> space to create such mappings. >> >> +config XEN_VIRTIO >> + bool "Xen virtio support" >> + default n >> + depends on VIRTIO && DMA_OPS >> + select ARCH_HAS_RESTRICTED_VIRTIO_MEMORY_ACCESS >> + help >> + Enable virtio support for running as Xen guest. Depending on the >> + guest type this will require special support on the backend side >> + (qemu or kernel, depending on the virtio device types used). >> + >> +config XEN_HVM_VIRTIO_GRANT >> + bool "Require virtio for fully virtualized guests to use grant mappings" >> + depends on XEN_VIRTIO && X86_64 >> + default y >> + help >> + Require virtio for fully virtualized guests to use grant mappings. >> + This will avoid the need to give the backend the right to map all >> + of the guest memory. This will need support on the backend side >> + (qemu or kernel, depending on the virtio device types used). >> + >> endmenu >> diff --git a/drivers/xen/Makefile b/drivers/xen/Makefile >> index 5aae66e..767009c 100644 >> --- a/drivers/xen/Makefile >> +++ b/drivers/xen/Makefile >> @@ -39,3 +39,4 @@ 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 >> +obj-$(CONFIG_XEN_VIRTIO) += xen-virtio.o >> diff --git a/drivers/xen/xen-virtio.c b/drivers/xen/xen-virtio.c >> new file mode 100644 >> index 00000000..cfd5eda >> --- /dev/null >> +++ b/drivers/xen/xen-virtio.c >> @@ -0,0 +1,177 @@ >> +// SPDX-License-Identifier: GPL-2.0-only >> +/****************************************************************************** >> + * Xen virtio driver - enables using virtio devices in Xen guests. >> + * >> + * Copyright (c) 2021, Juergen Gross >> + */ >> + >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> + >> +#define XEN_GRANT_ADDR_OFF 0x8000000000000000ULL >> + >> +static inline dma_addr_t grant_to_dma(grant_ref_t grant) >> +{ >> + return XEN_GRANT_ADDR_OFF | ((dma_addr_t)grant << PAGE_SHIFT); >> +} >> + >> +static inline grant_ref_t dma_to_grant(dma_addr_t dma) >> +{ >> + return (grant_ref_t)((dma & ~XEN_GRANT_ADDR_OFF) >> PAGE_SHIFT); >> +} >> + >> +/* >> + * DMA ops for Xen virtio frontends. >> + * >> + * Used to act as a kind of software IOMMU for Xen guests by using grants as >> + * DMA addresses. >> + * Such a DMA address is formed by using the grant reference as a frame >> + * number and setting the highest address bit (this bit is for the backend >> + * to be able to distinguish it from e.g. a mmio address). >> + * >> + * Note that for now we hard wire dom0 to be the backend domain. In order to >> + * support any domain as backend we'd need to add a way to communicate the >> + * domid of this backend, e.g. via Xenstore or via the PCI-device's config >> + * space. >> + */ >> +static void *xen_virtio_dma_alloc(struct device *dev, size_t size, >> + dma_addr_t *dma_handle, gfp_t gfp, >> + unsigned long attrs) >> +{ >> + unsigned int n_pages = PFN_UP(size); >> + unsigned int i; >> + unsigned long pfn; >> + grant_ref_t grant; >> + void *ret; >> + >> + ret = (void *)__get_free_pages(gfp, get_order(size)); >> + if (!ret) >> + return NULL; >> + >> + pfn = virt_to_pfn(ret); >> + >> + if (gnttab_alloc_grant_reference_seq(n_pages, &grant)) { >> + free_pages((unsigned long)ret, get_order(size)); >> + return NULL; >> + } >> + >> + for (i = 0; i < n_pages; i++) { >> + gnttab_grant_foreign_access_ref(grant + i, 0, >> + pfn_to_gfn(pfn + i), 0); >> + } >> + >> + *dma_handle = grant_to_dma(grant); >> + >> + return ret; >> +} >> + >> +static void xen_virtio_dma_free(struct device *dev, size_t size, void *vaddr, >> + dma_addr_t dma_handle, unsigned long attrs) >> +{ >> + unsigned int n_pages = PFN_UP(size); >> + unsigned int i; >> + grant_ref_t grant; >> + >> + grant = dma_to_grant(dma_handle); >> + >> + for (i = 0; i < n_pages; i++) >> + gnttab_end_foreign_access_ref(grant + i); >> + >> + gnttab_free_grant_reference_seq(grant, n_pages); >> + >> + free_pages((unsigned long)vaddr, get_order(size)); >> +} >> + >> +static struct page *xen_virtio_dma_alloc_pages(struct device *dev, size_t size, >> + dma_addr_t *dma_handle, >> + enum dma_data_direction dir, >> + gfp_t gfp) >> +{ >> + WARN_ONCE(1, "xen_virtio_dma_alloc_pages size %ld\n", size); >> + return NULL; >> +} >> + >> +static void xen_virtio_dma_free_pages(struct device *dev, size_t size, >> + struct page *vaddr, dma_addr_t dma_handle, >> + enum dma_data_direction dir) >> +{ >> + WARN_ONCE(1, "xen_virtio_dma_free_pages size %ld\n", size); >> +} >> + >> +static dma_addr_t xen_virtio_dma_map_page(struct device *dev, struct page *page, >> + unsigned long offset, size_t size, >> + enum dma_data_direction dir, >> + unsigned long attrs) >> +{ >> + grant_ref_t grant; >> + >> + if (gnttab_alloc_grant_references(1, &grant)) >> + return 0; >> + >> + gnttab_grant_foreign_access_ref(grant, 0, xen_page_to_gfn(page), >> + dir == DMA_TO_DEVICE); >> + >> + return grant_to_dma(grant) + offset; >> +} >> + >> +static void xen_virtio_dma_unmap_page(struct device *dev, dma_addr_t dma_handle, >> + size_t size, enum dma_data_direction dir, >> + unsigned long attrs) >> +{ >> + grant_ref_t grant; >> + >> + grant = dma_to_grant(dma_handle); >> + >> + gnttab_end_foreign_access_ref(grant); >> + >> + gnttab_free_grant_reference(grant); >> +} >> + >> +static int xen_virtio_dma_map_sg(struct device *dev, struct scatterlist *sg, >> + int nents, enum dma_data_direction dir, >> + unsigned long attrs) >> +{ >> + WARN_ONCE(1, "xen_virtio_dma_map_sg nents %d\n", nents); >> + return -EINVAL; >> +} >> + >> +static void xen_virtio_dma_unmap_sg(struct device *dev, struct scatterlist *sg, >> + int nents, enum dma_data_direction dir, >> + unsigned long attrs) >> +{ >> + WARN_ONCE(1, "xen_virtio_dma_unmap_sg nents %d\n", nents); >> +} >> + >> +static int xen_virtio_dma_dma_supported(struct device *dev, u64 mask) >> +{ >> + return 1; >> +} >> + >> +static const struct dma_map_ops xen_virtio_dma_ops = { >> + .alloc = xen_virtio_dma_alloc, >> + .free = xen_virtio_dma_free, >> + .alloc_pages = xen_virtio_dma_alloc_pages, >> + .free_pages = xen_virtio_dma_free_pages, >> + .mmap = dma_common_mmap, >> + .get_sgtable = dma_common_get_sgtable, >> + .map_page = xen_virtio_dma_map_page, >> + .unmap_page = xen_virtio_dma_unmap_page, >> + .map_sg = xen_virtio_dma_map_sg, >> + .unmap_sg = xen_virtio_dma_unmap_sg, >> + .dma_supported = xen_virtio_dma_dma_supported, >> +}; >> + >> +void xen_virtio_setup_dma_ops(struct device *dev) >> +{ >> + dev->dma_ops = &xen_virtio_dma_ops; >> +} >> +EXPORT_SYMBOL_GPL(xen_virtio_setup_dma_ops); >> + >> +MODULE_DESCRIPTION("Xen virtio support driver"); >> +MODULE_AUTHOR("Juergen Gross "); >> +MODULE_LICENSE("GPL"); >> diff --git a/include/xen/xen-ops.h b/include/xen/xen-ops.h >> index a3584a3..ae3c1bc 100644 >> --- a/include/xen/xen-ops.h >> +++ b/include/xen/xen-ops.h >> @@ -221,4 +221,12 @@ static inline void xen_preemptible_hcall_end(void) { } >> >> #endif /* CONFIG_XEN_PV && !CONFIG_PREEMPTION */ >> >> +#ifdef CONFIG_XEN_VIRTIO >> +void xen_virtio_setup_dma_ops(struct device *dev); >> +#else >> +static inline void xen_virtio_setup_dma_ops(struct device *dev) >> +{ >> +} >> +#endif /* CONFIG_XEN_VIRTIO */ >> + >> #endif /* INCLUDE_XEN_OPS_H */ > Can you please encapsulate the Xen part of the test in some Xen-specific file? I assume your question is about changes to common arch/x86/mm/init.c? #ifdef CONFIG_ARCH_HAS_RESTRICTED_VIRTIO_MEMORY_ACCESS int arch_has_restricted_virtio_memory_access(void) {     if (IS_ENABLED(CONFIG_XEN_PV_VIRTIO) && xen_pv_domain())         return 1;     if (IS_ENABLED(CONFIG_XEN_HVM_VIRTIO_GRANT) && xen_hvm_domain())         return 1;     return cc_platform_has(CC_ATTR_GUEST_MEM_ENCRYPT); } EXPORT_SYMBOL_GPL(arch_has_restricted_virtio_memory_access); If we are speaking about the whole function, then I am not sure, unfortunately. I think, if this was a purely Xen specific function (which was used by Xen guests only) I would move it somewhere to arch/x86/xen/...   (probably to arch/x86/xen/enlighten.c). As I understand (please bear in mind I am not too familiar with x86 code), so far this function was only used by SEV guests, but with current changes it is going to be used by both Xen and SEV guests, so it should be available even if Xen support is compiled out. Could you please suggest a better place to keep this stuff? If we are speaking about only Xen specific bits in that function, then definitely yes, for example, in this way: 1. arch/x86/mm/init.c or other common (non-Xen specific) location: #ifdef CONFIG_ARCH_HAS_RESTRICTED_VIRTIO_MEMORY_ACCESS int arch_has_restricted_virtio_memory_access(void) {     return (xen_has_restricted_virtio_memory_access() ||             cc_platform_has(CC_ATTR_GUEST_MEM_ENCRYPT)); } EXPORT_SYMBOL_GPL(arch_has_restricted_virtio_memory_access); #endif 2.  include/xen/xen.h or other Xen specific location: static inline int xen_has_restricted_virtio_memory_access(void) {     if (IS_ENABLED(CONFIG_XEN_PV_VIRTIO) && xen_pv_domain())         return 1;     if (IS_ENABLED(CONFIG_XEN_HVM_VIRTIO_GRANT) && xen_hvm_domain())         return 1;     return 0; } Or I misunderstood your question? -- Regards, Oleksandr Tyshchenko 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 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id AB3BBC433EF for ; Fri, 15 Apr 2022 15:22:28 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:Content-Type: Content-Transfer-Encoding:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:Date:Message-ID:From: References:Cc:To:Subject:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=9D8G58IuYCZoo/4ciNbuElUSemAG91MT6Wjk6Zjnkcs=; b=b5SrEBCucfWP3n/GSYpNH+8VmE CIPLgXCMmzlxKF5fKpgqw6ONLhnC6ebBjd+M/i/nwmkVW6a3tmGZJrKjg1NTEDCqOEbKd9XsVCsmV btl5bSigxmG40ObrdcUzEfZ/2qsLr3MTi7tg3rr/U2c0X6yZMl0TtGOcCxcWykV2STfx+/8xFGW/M xjQNxVxhDaSDhP7/HP/QTcmj7bXUBKR1dn++qCpytsStI2a+mCumNF3hHkHiawEJfTEFf4dMDvNIU l3qPVLUFPvvu8eT1iUVQji//qiM2DU3tUgJW6sUwea5uy7lcwWsZ/Bk+dTrO2qGyNqezrSdQONnPh 9znKzWpg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nfNkv-00ATcO-4G; Fri, 15 Apr 2022 15:21:05 +0000 Received: from mail-lj1-x231.google.com ([2a00:1450:4864:20::231]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1nfNkq-00ATbB-II for linux-arm-kernel@lists.infradead.org; Fri, 15 Apr 2022 15:21:02 +0000 Received: by mail-lj1-x231.google.com with SMTP id m8so9822385ljc.7 for ; Fri, 15 Apr 2022 08:20:59 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=subject:to:cc:references:from:message-id:date:user-agent :mime-version:in-reply-to:content-transfer-encoding:content-language; bh=tKPtQz+15frjCFqtKqOJi6EaMDFvouH7Zhy6D7XdcRQ=; b=iMQhO3UyThOnnoJuPW45l59saUXzOpnn2SSyXXhV0SO20SvDU4ozWdMEcvNk1cYhWE JJXUs8s8k7ddksgmfTzy0juYSOz3O2OPfA/xQuaDAUHQhtvtvvioZHE121kzLCXYCEIv w9OBPAWtl/2kxVdgDLFK+taJvIEqzadWKar7xfr1RhPp8OuuaOgsOIkCDBbQIf1tnNzI Okk3WO387jSJMT0Td/g756NWcFrxa+x/6s2PQEwj5758Q0xEaz3xa9LEh1SQwRoS2ucm CP0l4F/nBniNW/TODw0pTAKBtMyWrpUfJVf6RyIIXfI87N7xjLF9okkr/lJTtAiF1w7n VPxQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:subject:to:cc:references:from:message-id:date :user-agent:mime-version:in-reply-to:content-transfer-encoding :content-language; bh=tKPtQz+15frjCFqtKqOJi6EaMDFvouH7Zhy6D7XdcRQ=; b=0oqv7UFOnFwQn+LK3BKimq2oVv8438L9qeesfQ3W148TpEkYv9lJxutgyvl8lCA6hW ihqUIAToK/5x0+4F1Pr9hJYxdbY/5ehdd4SOdC9X9zBtC0zHamnRR0yERD3s00MrVaOM bp9dGVTYw6fUvITlb+J8ECGfnNjS1wwAqXS+Xe8dWNJ8/Lpr+smH2RpiPF11LDAZWnBD Y01xYFDngyJZQ7iqzJhzZBJVgwhWrhz4ow6U4kJYfLhBS/BckSU5HXptX9XWIhxKwogM bxC7GoDh7aIutu94zXVlAllvjs/F9uzzJzwKyXmFgVOWcJHpOFSGxXWdzCIqUYKRFMsU jUfA== X-Gm-Message-State: AOAM532jeR3dncR+hE6MGckMa1ieXIvv9LdprYmRvakHMRF+a3ZDbtSL D7wNbMBtmKBRDF8DVrV0EtYHmNqus8o= X-Google-Smtp-Source: ABdhPJziuyJyQYEu7x8SHebulqTxg+V1vpGA+dmLswY7ea4Efi9mFESgm9VTDaGLQC3z9xTvYuj0bg== X-Received: by 2002:a2e:a553:0:b0:24b:2081:2bbf with SMTP id e19-20020a2ea553000000b0024b20812bbfmr4632775ljn.414.1650036057479; Fri, 15 Apr 2022 08:20:57 -0700 (PDT) Received: from [192.168.1.7] ([212.22.223.21]) by smtp.gmail.com with ESMTPSA id p25-20020a056512313900b0046f4f252ebfsm175823lfd.226.2022.04.15.08.20.55 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Fri, 15 Apr 2022 08:20:56 -0700 (PDT) Subject: Re: [RFC PATCH 2/6] virtio: add option to restrict memory access under Xen To: "H. Peter Anvin" Cc: xen-devel@lists.xenproject.org, x86@kernel.org, linux-kernel@vger.kernel.org, Juergen Gross , Dave Hansen , Andy Lutomirski , Peter Zijlstra , Thomas Gleixner , Ingo Molnar , Borislav Petkov , Boris Ostrovsky , Stefano Stabellini , Julien Grall , Oleksandr Tyshchenko , Christoph Hellwig , "Michael S. Tsirkin" , linux-arm-kernel@lists.infradead.org References: <1649963973-22879-1-git-send-email-olekstysh@gmail.com> <1649963973-22879-3-git-send-email-olekstysh@gmail.com> <5A795507-715D-494B-B56B-B12E5BE348A4@zytor.com> From: Oleksandr Message-ID: <6b3ceb42-5848-4a1b-61d7-f37c4a18d725@gmail.com> Date: Fri, 15 Apr 2022 18:20:55 +0300 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.10.0 MIME-Version: 1.0 In-Reply-To: <5A795507-715D-494B-B56B-B12E5BE348A4@zytor.com> Content-Language: en-US X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220415_082100_636717_11EB2968 X-CRM114-Status: GOOD ( 37.93 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org Ck9uIDE0LjA0LjIyIDIyOjQzLCBILiBQZXRlciBBbnZpbiB3cm90ZToKCkhlbGxvIFBldGVyCgoK PiBPbiBBcHJpbCAxNCwgMjAyMiAxMjoxOToyOSBQTSBQRFQsIE9sZWtzYW5kciBUeXNoY2hlbmtv IDxvbGVrc3R5c2hAZ21haWwuY29tPiB3cm90ZToKPj4gRnJvbTogSnVlcmdlbiBHcm9zcyA8amdy b3NzQHN1c2UuY29tPgo+Pgo+PiBJbiBvcmRlciB0byBzdXBwb3J0IHZpcnRpbyBpbiBYZW4gZ3Vl c3RzIGFkZCBhIGNvbmZpZyBvcHRpb24gZW5hYmxpbmcKPj4gdGhlIHVzZXIgdG8gc3BlY2lmeSB3 aGV0aGVyIGluIGFsbCBYZW4gZ3Vlc3RzIHZpcnRpbyBzaG91bGQgYmUgYWJsZSB0bwo+PiBhY2Nl c3MgbWVtb3J5IHZpYSBYZW4gZ3JhbnQgbWFwcGluZ3Mgb25seSBvbiB0aGUgaG9zdCBzaWRlLgo+ Pgo+PiBUaGlzIGFwcGxpZXMgdG8gZnVsbHkgdmlydHVhbGl6ZWQgZ3Vlc3RzIG9ubHksIGFzIGZv ciBwYXJhdmlydHVhbGl6ZWQKPj4gZ3Vlc3RzIHRoaXMgaXMgbWFuZGF0b3J5Lgo+Pgo+PiBUaGlz IHJlcXVpcmVzIHRvIHN3aXRjaCBhcmNoX2hhc19yZXN0cmljdGVkX3ZpcnRpb19tZW1vcnlfYWNj ZXNzKCkKPiA+ZnJvbSBhIHB1cmUgc3R1YiB0byBhIHJlYWwgZnVuY3Rpb24gb24geDg2IHN5c3Rl bXMgKEFybSBzeXN0ZW1zIGFyZQo+PiBub3QgY292ZXJlZCBieSBub3cpLgo+Pgo+PiBBZGQgdGhl IG5lZWRlZCBmdW5jdGlvbmFsaXR5IGJ5IHByb3ZpZGluZyBhIHNwZWNpYWwgc2V0IG9mIERNQSBv cHMKPj4gaGFuZGxpbmcgdGhlIG5lZWRlZCBncmFudCBvcGVyYXRpb25zIGZvciB0aGUgSS9PIHBh Z2VzLgo+Pgo+PiBTaWduZWQtb2ZmLWJ5OiBKdWVyZ2VuIEdyb3NzIDxqZ3Jvc3NAc3VzZS5jb20+ Cj4+IC0tLQo+PiBhcmNoL3g4Ni9tbS9pbml0LmMgICAgICAgIHwgIDE1ICsrKysKPj4gYXJjaC94 ODYvbW0vbWVtX2VuY3J5cHQuYyB8ICAgNSAtLQo+PiBhcmNoL3g4Ni94ZW4vS2NvbmZpZyAgICAg IHwgICA5ICsrKwo+PiBkcml2ZXJzL3hlbi9LY29uZmlnICAgICAgIHwgIDIwICsrKysrKwo+PiBk cml2ZXJzL3hlbi9NYWtlZmlsZSAgICAgIHwgICAxICsKPj4gZHJpdmVycy94ZW4veGVuLXZpcnRp by5jICB8IDE3NyArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr Cj4+IGluY2x1ZGUveGVuL3hlbi1vcHMuaCAgICAgfCAgIDggKysrCj4+IDcgZmlsZXMgY2hhbmdl ZCwgMjMwIGluc2VydGlvbnMoKyksIDUgZGVsZXRpb25zKC0pCj4+IGNyZWF0ZSBtb2RlIDEwMDY0 NCBkcml2ZXJzL3hlbi94ZW4tdmlydGlvLmMKPj4KPj4gZGlmZiAtLWdpdCBhL2FyY2gveDg2L21t L2luaXQuYyBiL2FyY2gveDg2L21tL2luaXQuYwo+PiBpbmRleCBkOGNmY2UyLi41MjZhM2IyIDEw MDY0NAo+PiAtLS0gYS9hcmNoL3g4Ni9tbS9pbml0LmMKPj4gKysrIGIvYXJjaC94ODYvbW0vaW5p dC5jCj4+IEBAIC04LDYgKzgsOCBAQAo+PiAjaW5jbHVkZSA8bGludXgva21lbWxlYWsuaD4KPj4g I2luY2x1ZGUgPGxpbnV4L3NjaGVkL3Rhc2suaD4KPj4KPj4gKyNpbmNsdWRlIDx4ZW4veGVuLmg+ Cj4+ICsKPj4gI2luY2x1ZGUgPGFzbS9zZXRfbWVtb3J5Lmg+Cj4+ICNpbmNsdWRlIDxhc20vZTgy MC9hcGkuaD4KPj4gI2luY2x1ZGUgPGFzbS9pbml0Lmg+Cj4+IEBAIC0xMDY1LDMgKzEwNjcsMTYg QEAgdW5zaWduZWQgbG9uZyBtYXhfc3dhcGZpbGVfc2l6ZSh2b2lkKQo+PiAJcmV0dXJuIHBhZ2Vz Owo+PiB9Cj4+ICNlbmRpZgo+PiArCj4+ICsjaWZkZWYgQ09ORklHX0FSQ0hfSEFTX1JFU1RSSUNU RURfVklSVElPX01FTU9SWV9BQ0NFU1MKPj4gK2ludCBhcmNoX2hhc19yZXN0cmljdGVkX3ZpcnRp b19tZW1vcnlfYWNjZXNzKHZvaWQpCj4+ICt7Cj4+ICsJaWYgKElTX0VOQUJMRUQoQ09ORklHX1hF Tl9QVl9WSVJUSU8pICYmIHhlbl9wdl9kb21haW4oKSkKPj4gKwkJcmV0dXJuIDE7Cj4+ICsJaWYg KElTX0VOQUJMRUQoQ09ORklHX1hFTl9IVk1fVklSVElPX0dSQU5UKSAmJiB4ZW5faHZtX2RvbWFp bigpKQo+PiArCQlyZXR1cm4gMTsKPj4gKwo+PiArCXJldHVybiBjY19wbGF0Zm9ybV9oYXMoQ0Nf QVRUUl9HVUVTVF9NRU1fRU5DUllQVCk7Cj4+ICt9Cj4+ICtFWFBPUlRfU1lNQk9MX0dQTChhcmNo X2hhc19yZXN0cmljdGVkX3ZpcnRpb19tZW1vcnlfYWNjZXNzKTsKPj4gKyNlbmRpZgo+PiBkaWZm IC0tZ2l0IGEvYXJjaC94ODYvbW0vbWVtX2VuY3J5cHQuYyBiL2FyY2gveDg2L21tL21lbV9lbmNy eXB0LmMKPj4gaW5kZXggNTBkMjA5OS4uZGRhMDIwZiAxMDA2NDQKPj4gLS0tIGEvYXJjaC94ODYv bW0vbWVtX2VuY3J5cHQuYwo+PiArKysgYi9hcmNoL3g4Ni9tbS9tZW1fZW5jcnlwdC5jCj4+IEBA IC03Nyw4ICs3NywzIEBAIHZvaWQgX19pbml0IG1lbV9lbmNyeXB0X2luaXQodm9pZCkKPj4gCXBy aW50X21lbV9lbmNyeXB0X2ZlYXR1cmVfaW5mbygpOwo+PiB9Cj4+Cj4+IC1pbnQgYXJjaF9oYXNf cmVzdHJpY3RlZF92aXJ0aW9fbWVtb3J5X2FjY2Vzcyh2b2lkKQo+PiAtewo+PiAtCXJldHVybiBj Y19wbGF0Zm9ybV9oYXMoQ0NfQVRUUl9HVUVTVF9NRU1fRU5DUllQVCk7Cj4+IC19Cj4+IC1FWFBP UlRfU1lNQk9MX0dQTChhcmNoX2hhc19yZXN0cmljdGVkX3ZpcnRpb19tZW1vcnlfYWNjZXNzKTsK Pj4gZGlmZiAtLWdpdCBhL2FyY2gveDg2L3hlbi9LY29uZmlnIGIvYXJjaC94ODYveGVuL0tjb25m aWcKPj4gaW5kZXggODUyNDZkZC4uZGZmZGZmZCAxMDA2NDQKPj4gLS0tIGEvYXJjaC94ODYveGVu L0tjb25maWcKPj4gKysrIGIvYXJjaC94ODYveGVuL0tjb25maWcKPj4gQEAgLTkyLDMgKzkyLDEy IEBAIGNvbmZpZyBYRU5fRE9NMAo+PiAJc2VsZWN0IFg4Nl9YMkFQSUMgaWYgWEVOX1BWSCAmJiBY ODZfNjQKPj4gCWhlbHAKPj4gCSAgU3VwcG9ydCBydW5uaW5nIGFzIGEgWGVuIERvbTAgZ3Vlc3Qu Cj4+ICsKPj4gK2NvbmZpZyBYRU5fUFZfVklSVElPCj4+ICsJYm9vbCAiWGVuIHZpcnRpbyBzdXBw b3J0IGZvciBQViBndWVzdHMiCj4+ICsJZGVwZW5kcyBvbiBYRU5fVklSVElPICYmIFhFTl9QVgo+ PiArCWRlZmF1bHQgeQo+PiArCWhlbHAKPj4gKwkgIFN1cHBvcnQgdmlydGlvIGZvciBydW5uaW5n IGFzIGEgcGFyYXZpcnR1YWxpemVkIGd1ZXN0LiBUaGlzIHdpbGwKPj4gKwkgIG5lZWQgc3VwcG9y dCBvbiB0aGUgYmFja2VuZCBzaWRlIChxZW11IG9yIGtlcm5lbCwgZGVwZW5kaW5nIG9uIHRoZQo+ PiArCSAgdmlydGlvIGRldmljZSB0eXBlcyB1c2VkKS4KPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMv eGVuL0tjb25maWcgYi9kcml2ZXJzL3hlbi9LY29uZmlnCj4+IGluZGV4IDEyMGQzMmYuLmZjNjFm N2EgMTAwNjQ0Cj4+IC0tLSBhL2RyaXZlcnMveGVuL0tjb25maWcKPj4gKysrIGIvZHJpdmVycy94 ZW4vS2NvbmZpZwo+PiBAQCAtMzM1LDQgKzMzNSwyNCBAQCBjb25maWcgWEVOX1VOUE9QVUxBVEVE X0FMTE9DCj4+IAkgIGhhdmluZyB0byBiYWxsb29uIG91dCBSQU0gcmVnaW9ucyBpbiBvcmRlciB0 byBvYnRhaW4gcGh5c2ljYWwgbWVtb3J5Cj4+IAkgIHNwYWNlIHRvIGNyZWF0ZSBzdWNoIG1hcHBp bmdzLgo+Pgo+PiArY29uZmlnIFhFTl9WSVJUSU8KPj4gKwlib29sICJYZW4gdmlydGlvIHN1cHBv cnQiCj4+ICsJZGVmYXVsdCBuCj4+ICsJZGVwZW5kcyBvbiBWSVJUSU8gJiYgRE1BX09QUwo+PiAr CXNlbGVjdCBBUkNIX0hBU19SRVNUUklDVEVEX1ZJUlRJT19NRU1PUllfQUNDRVNTCj4+ICsJaGVs cAo+PiArCSAgRW5hYmxlIHZpcnRpbyBzdXBwb3J0IGZvciBydW5uaW5nIGFzIFhlbiBndWVzdC4g RGVwZW5kaW5nIG9uIHRoZQo+PiArCSAgZ3Vlc3QgdHlwZSB0aGlzIHdpbGwgcmVxdWlyZSBzcGVj aWFsIHN1cHBvcnQgb24gdGhlIGJhY2tlbmQgc2lkZQo+PiArCSAgKHFlbXUgb3Iga2VybmVsLCBk ZXBlbmRpbmcgb24gdGhlIHZpcnRpbyBkZXZpY2UgdHlwZXMgdXNlZCkuCj4+ICsKPj4gK2NvbmZp ZyBYRU5fSFZNX1ZJUlRJT19HUkFOVAo+PiArCWJvb2wgIlJlcXVpcmUgdmlydGlvIGZvciBmdWxs eSB2aXJ0dWFsaXplZCBndWVzdHMgdG8gdXNlIGdyYW50IG1hcHBpbmdzIgo+PiArCWRlcGVuZHMg b24gWEVOX1ZJUlRJTyAmJiBYODZfNjQKPj4gKwlkZWZhdWx0IHkKPj4gKwloZWxwCj4+ICsJICBS ZXF1aXJlIHZpcnRpbyBmb3IgZnVsbHkgdmlydHVhbGl6ZWQgZ3Vlc3RzIHRvIHVzZSBncmFudCBt YXBwaW5ncy4KPj4gKwkgIFRoaXMgd2lsbCBhdm9pZCB0aGUgbmVlZCB0byBnaXZlIHRoZSBiYWNr ZW5kIHRoZSByaWdodCB0byBtYXAgYWxsCj4+ICsJICBvZiB0aGUgZ3Vlc3QgbWVtb3J5LiBUaGlz IHdpbGwgbmVlZCBzdXBwb3J0IG9uIHRoZSBiYWNrZW5kIHNpZGUKPj4gKwkgIChxZW11IG9yIGtl cm5lbCwgZGVwZW5kaW5nIG9uIHRoZSB2aXJ0aW8gZGV2aWNlIHR5cGVzIHVzZWQpLgo+PiArCj4+ IGVuZG1lbnUKPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL01ha2VmaWxlIGIvZHJpdmVycy94 ZW4vTWFrZWZpbGUKPj4gaW5kZXggNWFhZTY2ZS4uNzY3MDA5YyAxMDA2NDQKPj4gLS0tIGEvZHJp dmVycy94ZW4vTWFrZWZpbGUKPj4gKysrIGIvZHJpdmVycy94ZW4vTWFrZWZpbGUKPj4gQEAgLTM5 LDMgKzM5LDQgQEAgeGVuLWdudGFsbG9jLXkJCQkJOj0gZ250YWxsb2Mubwo+PiB4ZW4tcHJpdmNt ZC15CQkJCTo9IHByaXZjbWQubyBwcml2Y21kLWJ1Zi5vCj4+IG9iai0kKENPTkZJR19YRU5fRlJP TlRfUEdESVJfU0hCVUYpCSs9IHhlbi1mcm9udC1wZ2Rpci1zaGJ1Zi5vCj4+IG9iai0kKENPTkZJ R19YRU5fVU5QT1BVTEFURURfQUxMT0MpCSs9IHVucG9wdWxhdGVkLWFsbG9jLm8KPj4gK29iai0k KENPTkZJR19YRU5fVklSVElPKQkJKz0geGVuLXZpcnRpby5vCj4+IGRpZmYgLS1naXQgYS9kcml2 ZXJzL3hlbi94ZW4tdmlydGlvLmMgYi9kcml2ZXJzL3hlbi94ZW4tdmlydGlvLmMKPj4gbmV3IGZp bGUgbW9kZSAxMDA2NDQKPj4gaW5kZXggMDAwMDAwMDAuLmNmZDVlZGEKPj4gLS0tIC9kZXYvbnVs bAo+PiArKysgYi9kcml2ZXJzL3hlbi94ZW4tdmlydGlvLmMKPj4gQEAgLTAsMCArMSwxNzcgQEAK Pj4gKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9ubHkKPj4gKy8qKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioKPj4gKyAqIFhlbiB2aXJ0aW8gZHJpdmVyIC0gZW5hYmxlcyB1c2luZyB2 aXJ0aW8gZGV2aWNlcyBpbiBYZW4gZ3Vlc3RzLgo+PiArICoKPj4gKyAqIENvcHlyaWdodCAoYykg MjAyMSwgSnVlcmdlbiBHcm9zcyA8amdyb3NzQHN1c2UuY29tPgo+PiArICovCj4+ICsKPj4gKyNp bmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9kbWEtbWFwLW9wcy5o Pgo+PiArI2luY2x1ZGUgPGxpbnV4L3BjaS5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L3Bmbi5oPgo+ PiArI2luY2x1ZGUgPGxpbnV4L3ZpcnRpb19jb25maWcuaD4KPj4gKyNpbmNsdWRlIDx4ZW4veGVu Lmg+Cj4+ICsjaW5jbHVkZSA8eGVuL2dyYW50X3RhYmxlLmg+Cj4+ICsKPj4gKyNkZWZpbmUgWEVO X0dSQU5UX0FERFJfT0ZGCTB4ODAwMDAwMDAwMDAwMDAwMFVMTAo+PiArCj4+ICtzdGF0aWMgaW5s aW5lIGRtYV9hZGRyX3QgZ3JhbnRfdG9fZG1hKGdyYW50X3JlZl90IGdyYW50KQo+PiArewo+PiAr CXJldHVybiBYRU5fR1JBTlRfQUREUl9PRkYgfCAoKGRtYV9hZGRyX3QpZ3JhbnQgPDwgUEFHRV9T SElGVCk7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBpbmxpbmUgZ3JhbnRfcmVmX3QgZG1hX3RvX2dy YW50KGRtYV9hZGRyX3QgZG1hKQo+PiArewo+PiArCXJldHVybiAoZ3JhbnRfcmVmX3QpKChkbWEg JiB+WEVOX0dSQU5UX0FERFJfT0ZGKSA+PiBQQUdFX1NISUZUKTsKPj4gK30KPj4gKwo+PiArLyoK Pj4gKyAqIERNQSBvcHMgZm9yIFhlbiB2aXJ0aW8gZnJvbnRlbmRzLgo+PiArICoKPj4gKyAqIFVz ZWQgdG8gYWN0IGFzIGEga2luZCBvZiBzb2Z0d2FyZSBJT01NVSBmb3IgWGVuIGd1ZXN0cyBieSB1 c2luZyBncmFudHMgYXMKPj4gKyAqIERNQSBhZGRyZXNzZXMuCj4+ICsgKiBTdWNoIGEgRE1BIGFk ZHJlc3MgaXMgZm9ybWVkIGJ5IHVzaW5nIHRoZSBncmFudCByZWZlcmVuY2UgYXMgYSBmcmFtZQo+ PiArICogbnVtYmVyIGFuZCBzZXR0aW5nIHRoZSBoaWdoZXN0IGFkZHJlc3MgYml0ICh0aGlzIGJp dCBpcyBmb3IgdGhlIGJhY2tlbmQKPj4gKyAqIHRvIGJlIGFibGUgdG8gZGlzdGluZ3Vpc2ggaXQg ZnJvbSBlLmcuIGEgbW1pbyBhZGRyZXNzKS4KPj4gKyAqCj4+ICsgKiBOb3RlIHRoYXQgZm9yIG5v dyB3ZSBoYXJkIHdpcmUgZG9tMCB0byBiZSB0aGUgYmFja2VuZCBkb21haW4uIEluIG9yZGVyIHRv Cj4+ICsgKiBzdXBwb3J0IGFueSBkb21haW4gYXMgYmFja2VuZCB3ZSdkIG5lZWQgdG8gYWRkIGEg d2F5IHRvIGNvbW11bmljYXRlIHRoZQo+PiArICogZG9taWQgb2YgdGhpcyBiYWNrZW5kLCBlLmcu IHZpYSBYZW5zdG9yZSBvciB2aWEgdGhlIFBDSS1kZXZpY2UncyBjb25maWcKPj4gKyAqIHNwYWNl Lgo+PiArICovCj4+ICtzdGF0aWMgdm9pZCAqeGVuX3ZpcnRpb19kbWFfYWxsb2Moc3RydWN0IGRl dmljZSAqZGV2LCBzaXplX3Qgc2l6ZSwKPj4gKwkJCQkgIGRtYV9hZGRyX3QgKmRtYV9oYW5kbGUs IGdmcF90IGdmcCwKPj4gKwkJCQkgIHVuc2lnbmVkIGxvbmcgYXR0cnMpCj4+ICt7Cj4+ICsJdW5z aWduZWQgaW50IG5fcGFnZXMgPSBQRk5fVVAoc2l6ZSk7Cj4+ICsJdW5zaWduZWQgaW50IGk7Cj4+ ICsJdW5zaWduZWQgbG9uZyBwZm47Cj4+ICsJZ3JhbnRfcmVmX3QgZ3JhbnQ7Cj4+ICsJdm9pZCAq cmV0Owo+PiArCj4+ICsJcmV0ID0gKHZvaWQgKilfX2dldF9mcmVlX3BhZ2VzKGdmcCwgZ2V0X29y ZGVyKHNpemUpKTsKPj4gKwlpZiAoIXJldCkKPj4gKwkJcmV0dXJuIE5VTEw7Cj4+ICsKPj4gKwlw Zm4gPSB2aXJ0X3RvX3BmbihyZXQpOwo+PiArCj4+ICsJaWYgKGdudHRhYl9hbGxvY19ncmFudF9y ZWZlcmVuY2Vfc2VxKG5fcGFnZXMsICZncmFudCkpIHsKPj4gKwkJZnJlZV9wYWdlcygodW5zaWdu ZWQgbG9uZylyZXQsIGdldF9vcmRlcihzaXplKSk7Cj4+ICsJCXJldHVybiBOVUxMOwo+PiArCX0K Pj4gKwo+PiArCWZvciAoaSA9IDA7IGkgPCBuX3BhZ2VzOyBpKyspIHsKPj4gKwkJZ250dGFiX2dy YW50X2ZvcmVpZ25fYWNjZXNzX3JlZihncmFudCArIGksIDAsCj4+ICsJCQkJCQlwZm5fdG9fZ2Zu KHBmbiArIGkpLCAwKTsKPj4gKwl9Cj4+ICsKPj4gKwkqZG1hX2hhbmRsZSA9IGdyYW50X3RvX2Rt YShncmFudCk7Cj4+ICsKPj4gKwlyZXR1cm4gcmV0Owo+PiArfQo+PiArCj4+ICtzdGF0aWMgdm9p ZCB4ZW5fdmlydGlvX2RtYV9mcmVlKHN0cnVjdCBkZXZpY2UgKmRldiwgc2l6ZV90IHNpemUsIHZv aWQgKnZhZGRyLAo+PiArCQkJCWRtYV9hZGRyX3QgZG1hX2hhbmRsZSwgdW5zaWduZWQgbG9uZyBh dHRycykKPj4gK3sKPj4gKwl1bnNpZ25lZCBpbnQgbl9wYWdlcyA9IFBGTl9VUChzaXplKTsKPj4g Kwl1bnNpZ25lZCBpbnQgaTsKPj4gKwlncmFudF9yZWZfdCBncmFudDsKPj4gKwo+PiArCWdyYW50 ID0gZG1hX3RvX2dyYW50KGRtYV9oYW5kbGUpOwo+PiArCj4+ICsJZm9yIChpID0gMDsgaSA8IG5f cGFnZXM7IGkrKykKPj4gKwkJZ250dGFiX2VuZF9mb3JlaWduX2FjY2Vzc19yZWYoZ3JhbnQgKyBp KTsKPj4gKwo+PiArCWdudHRhYl9mcmVlX2dyYW50X3JlZmVyZW5jZV9zZXEoZ3JhbnQsIG5fcGFn ZXMpOwo+PiArCj4+ICsJZnJlZV9wYWdlcygodW5zaWduZWQgbG9uZyl2YWRkciwgZ2V0X29yZGVy KHNpemUpKTsKPj4gK30KPj4gKwo+PiArc3RhdGljIHN0cnVjdCBwYWdlICp4ZW5fdmlydGlvX2Rt YV9hbGxvY19wYWdlcyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHNpemVfdCBzaXplLAo+PiArCQkJCQkg ICAgICAgZG1hX2FkZHJfdCAqZG1hX2hhbmRsZSwKPj4gKwkJCQkJICAgICAgIGVudW0gZG1hX2Rh dGFfZGlyZWN0aW9uIGRpciwKPj4gKwkJCQkJICAgICAgIGdmcF90IGdmcCkKPj4gK3sKPj4gKwlX QVJOX09OQ0UoMSwgInhlbl92aXJ0aW9fZG1hX2FsbG9jX3BhZ2VzIHNpemUgJWxkXG4iLCBzaXpl KTsKPj4gKwlyZXR1cm4gTlVMTDsKPj4gK30KPj4gKwo+PiArc3RhdGljIHZvaWQgeGVuX3ZpcnRp b19kbWFfZnJlZV9wYWdlcyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHNpemVfdCBzaXplLAo+PiArCQkJ CSAgICAgIHN0cnVjdCBwYWdlICp2YWRkciwgZG1hX2FkZHJfdCBkbWFfaGFuZGxlLAo+PiArCQkJ CSAgICAgIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpcikKPj4gK3sKPj4gKwlXQVJOX09OQ0Uo MSwgInhlbl92aXJ0aW9fZG1hX2ZyZWVfcGFnZXMgc2l6ZSAlbGRcbiIsIHNpemUpOwo+PiArfQo+ PiArCj4+ICtzdGF0aWMgZG1hX2FkZHJfdCB4ZW5fdmlydGlvX2RtYV9tYXBfcGFnZShzdHJ1Y3Qg ZGV2aWNlICpkZXYsIHN0cnVjdCBwYWdlICpwYWdlLAo+PiArCQkJCQkgIHVuc2lnbmVkIGxvbmcg b2Zmc2V0LCBzaXplX3Qgc2l6ZSwKPj4gKwkJCQkJICBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBk aXIsCj4+ICsJCQkJCSAgdW5zaWduZWQgbG9uZyBhdHRycykKPj4gK3sKPj4gKwlncmFudF9yZWZf dCBncmFudDsKPj4gKwo+PiArCWlmIChnbnR0YWJfYWxsb2NfZ3JhbnRfcmVmZXJlbmNlcygxLCAm Z3JhbnQpKQo+PiArCQlyZXR1cm4gMDsKPj4gKwo+PiArCWdudHRhYl9ncmFudF9mb3JlaWduX2Fj Y2Vzc19yZWYoZ3JhbnQsIDAsIHhlbl9wYWdlX3RvX2dmbihwYWdlKSwKPj4gKwkJCQkJZGlyID09 IERNQV9UT19ERVZJQ0UpOwo+PiArCj4+ICsJcmV0dXJuIGdyYW50X3RvX2RtYShncmFudCkgKyBv ZmZzZXQ7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyB2b2lkIHhlbl92aXJ0aW9fZG1hX3VubWFwX3Bh Z2Uoc3RydWN0IGRldmljZSAqZGV2LCBkbWFfYWRkcl90IGRtYV9oYW5kbGUsCj4+ICsJCQkJICAg ICAgc2l6ZV90IHNpemUsIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwKPj4gKwkJCQkgICAg ICB1bnNpZ25lZCBsb25nIGF0dHJzKQo+PiArewo+PiArCWdyYW50X3JlZl90IGdyYW50Owo+PiAr Cj4+ICsJZ3JhbnQgPSBkbWFfdG9fZ3JhbnQoZG1hX2hhbmRsZSk7Cj4+ICsKPj4gKwlnbnR0YWJf ZW5kX2ZvcmVpZ25fYWNjZXNzX3JlZihncmFudCk7Cj4+ICsKPj4gKwlnbnR0YWJfZnJlZV9ncmFu dF9yZWZlcmVuY2UoZ3JhbnQpOwo+PiArfQo+PiArCj4+ICtzdGF0aWMgaW50IHhlbl92aXJ0aW9f ZG1hX21hcF9zZyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBzY2F0dGVybGlzdCAqc2csCj4+ ICsJCQkJIGludCBuZW50cywgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAo+PiArCQkJCSB1 bnNpZ25lZCBsb25nIGF0dHJzKQo+PiArewo+PiArCVdBUk5fT05DRSgxLCAieGVuX3ZpcnRpb19k bWFfbWFwX3NnIG5lbnRzICVkXG4iLCBuZW50cyk7Cj4+ICsJcmV0dXJuIC1FSU5WQUw7Cj4+ICt9 Cj4+ICsKPj4gK3N0YXRpYyB2b2lkIHhlbl92aXJ0aW9fZG1hX3VubWFwX3NnKHN0cnVjdCBkZXZp Y2UgKmRldiwgc3RydWN0IHNjYXR0ZXJsaXN0ICpzZywKPj4gKwkJCQkgICAgaW50IG5lbnRzLCBl bnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIsCj4+ICsJCQkJICAgIHVuc2lnbmVkIGxvbmcgYXR0 cnMpCj4+ICt7Cj4+ICsJV0FSTl9PTkNFKDEsICJ4ZW5fdmlydGlvX2RtYV91bm1hcF9zZyBuZW50 cyAlZFxuIiwgbmVudHMpOwo+PiArfQo+PiArCj4+ICtzdGF0aWMgaW50IHhlbl92aXJ0aW9fZG1h X2RtYV9zdXBwb3J0ZWQoc3RydWN0IGRldmljZSAqZGV2LCB1NjQgbWFzaykKPj4gK3sKPj4gKwly ZXR1cm4gMTsKPj4gK30KPj4gKwo+PiArc3RhdGljIGNvbnN0IHN0cnVjdCBkbWFfbWFwX29wcyB4 ZW5fdmlydGlvX2RtYV9vcHMgPSB7Cj4+ICsJLmFsbG9jID0geGVuX3ZpcnRpb19kbWFfYWxsb2Ms Cj4+ICsJLmZyZWUgPSB4ZW5fdmlydGlvX2RtYV9mcmVlLAo+PiArCS5hbGxvY19wYWdlcyA9IHhl bl92aXJ0aW9fZG1hX2FsbG9jX3BhZ2VzLAo+PiArCS5mcmVlX3BhZ2VzID0geGVuX3ZpcnRpb19k bWFfZnJlZV9wYWdlcywKPj4gKwkubW1hcCA9IGRtYV9jb21tb25fbW1hcCwKPj4gKwkuZ2V0X3Nn dGFibGUgPSBkbWFfY29tbW9uX2dldF9zZ3RhYmxlLAo+PiArCS5tYXBfcGFnZSA9IHhlbl92aXJ0 aW9fZG1hX21hcF9wYWdlLAo+PiArCS51bm1hcF9wYWdlID0geGVuX3ZpcnRpb19kbWFfdW5tYXBf cGFnZSwKPj4gKwkubWFwX3NnID0geGVuX3ZpcnRpb19kbWFfbWFwX3NnLAo+PiArCS51bm1hcF9z ZyA9IHhlbl92aXJ0aW9fZG1hX3VubWFwX3NnLAo+PiArCS5kbWFfc3VwcG9ydGVkID0geGVuX3Zp cnRpb19kbWFfZG1hX3N1cHBvcnRlZCwKPj4gK307Cj4+ICsKPj4gK3ZvaWQgeGVuX3ZpcnRpb19z ZXR1cF9kbWFfb3BzKHN0cnVjdCBkZXZpY2UgKmRldikKPj4gK3sKPj4gKwlkZXYtPmRtYV9vcHMg PSAmeGVuX3ZpcnRpb19kbWFfb3BzOwo+PiArfQo+PiArRVhQT1JUX1NZTUJPTF9HUEwoeGVuX3Zp cnRpb19zZXR1cF9kbWFfb3BzKTsKPj4gKwo+PiArTU9EVUxFX0RFU0NSSVBUSU9OKCJYZW4gdmly dGlvIHN1cHBvcnQgZHJpdmVyIik7Cj4+ICtNT0RVTEVfQVVUSE9SKCJKdWVyZ2VuIEdyb3NzIDxq Z3Jvc3NAc3VzZS5jb20+Iik7Cj4+ICtNT0RVTEVfTElDRU5TRSgiR1BMIik7Cj4+IGRpZmYgLS1n aXQgYS9pbmNsdWRlL3hlbi94ZW4tb3BzLmggYi9pbmNsdWRlL3hlbi94ZW4tb3BzLmgKPj4gaW5k ZXggYTM1ODRhMy4uYWUzYzFiYyAxMDA2NDQKPj4gLS0tIGEvaW5jbHVkZS94ZW4veGVuLW9wcy5o Cj4+ICsrKyBiL2luY2x1ZGUveGVuL3hlbi1vcHMuaAo+PiBAQCAtMjIxLDQgKzIyMSwxMiBAQCBz dGF0aWMgaW5saW5lIHZvaWQgeGVuX3ByZWVtcHRpYmxlX2hjYWxsX2VuZCh2b2lkKSB7IH0KPj4K Pj4gI2VuZGlmIC8qIENPTkZJR19YRU5fUFYgJiYgIUNPTkZJR19QUkVFTVBUSU9OICovCj4+Cj4+ ICsjaWZkZWYgQ09ORklHX1hFTl9WSVJUSU8KPj4gK3ZvaWQgeGVuX3ZpcnRpb19zZXR1cF9kbWFf b3BzKHN0cnVjdCBkZXZpY2UgKmRldik7Cj4+ICsjZWxzZQo+PiArc3RhdGljIGlubGluZSB2b2lk IHhlbl92aXJ0aW9fc2V0dXBfZG1hX29wcyhzdHJ1Y3QgZGV2aWNlICpkZXYpCj4+ICt7Cj4+ICt9 Cj4+ICsjZW5kaWYgLyogQ09ORklHX1hFTl9WSVJUSU8gKi8KPj4gKwo+PiAjZW5kaWYgLyogSU5D TFVERV9YRU5fT1BTX0ggKi8KPiBDYW4geW91IHBsZWFzZSBlbmNhcHN1bGF0ZSB0aGUgWGVuIHBh cnQgb2YgdGhlIHRlc3QgaW4gc29tZSBYZW4tc3BlY2lmaWMgZmlsZT8KCkkgYXNzdW1lIHlvdXIg cXVlc3Rpb24gaXMgYWJvdXQgY2hhbmdlcyB0byBjb21tb24gYXJjaC94ODYvbW0vaW5pdC5jPwoK CiNpZmRlZiBDT05GSUdfQVJDSF9IQVNfUkVTVFJJQ1RFRF9WSVJUSU9fTUVNT1JZX0FDQ0VTUwpp bnQgYXJjaF9oYXNfcmVzdHJpY3RlZF92aXJ0aW9fbWVtb3J5X2FjY2Vzcyh2b2lkKQp7CiDCoMKg wqAgaWYgKElTX0VOQUJMRUQoQ09ORklHX1hFTl9QVl9WSVJUSU8pICYmIHhlbl9wdl9kb21haW4o KSkKIMKgwqDCoMKgwqDCoMKgIHJldHVybiAxOwogwqDCoMKgIGlmIChJU19FTkFCTEVEKENPTkZJ R19YRU5fSFZNX1ZJUlRJT19HUkFOVCkgJiYgeGVuX2h2bV9kb21haW4oKSkKIMKgwqDCoMKgwqDC oMKgIHJldHVybiAxOwoKIMKgwqDCoCByZXR1cm4gY2NfcGxhdGZvcm1faGFzKENDX0FUVFJfR1VF U1RfTUVNX0VOQ1JZUFQpOwp9CkVYUE9SVF9TWU1CT0xfR1BMKGFyY2hfaGFzX3Jlc3RyaWN0ZWRf dmlydGlvX21lbW9yeV9hY2Nlc3MpOwoKCklmIHdlIGFyZSBzcGVha2luZyBhYm91dCB0aGUgd2hv bGUgZnVuY3Rpb24sIHRoZW4gSSBhbSBub3Qgc3VyZSwgCnVuZm9ydHVuYXRlbHkuIEkgdGhpbmss IGlmIHRoaXMgd2FzIGEgcHVyZWx5IFhlbiBzcGVjaWZpYyBmdW5jdGlvbiAKKHdoaWNoIHdhcyB1 c2VkIGJ5IFhlbiBndWVzdHMgb25seSkgSSB3b3VsZCBtb3ZlIGl0IHNvbWV3aGVyZSB0byAKYXJj aC94ODYveGVuLy4uLsKgwqAgKHByb2JhYmx5IHRvIGFyY2gveDg2L3hlbi9lbmxpZ2h0ZW4uYyku CgpBcyBJIHVuZGVyc3RhbmQgKHBsZWFzZSBiZWFyIGluIG1pbmQgSSBhbSBub3QgdG9vIGZhbWls aWFyIHdpdGggeDg2IApjb2RlKSwgc28gZmFyIHRoaXMgZnVuY3Rpb24gd2FzIG9ubHkgdXNlZCBi eSBTRVYgZ3Vlc3RzLCBidXQgd2l0aCAKY3VycmVudCBjaGFuZ2VzIGl0IGlzIGdvaW5nIHRvIGJl IHVzZWQgYnkgYm90aCBYZW4gYW5kIFNFViBndWVzdHMsIHNvIGl0IApzaG91bGQgYmUgYXZhaWxh YmxlIGV2ZW4gaWYgWGVuIHN1cHBvcnQgaXMgY29tcGlsZWQgb3V0LiBDb3VsZCB5b3UgCnBsZWFz ZSBzdWdnZXN0IGEgYmV0dGVyIHBsYWNlIHRvIGtlZXAgdGhpcyBzdHVmZj8KCgpJZiB3ZSBhcmUg c3BlYWtpbmcgYWJvdXQgb25seSBYZW4gc3BlY2lmaWMgYml0cyBpbiB0aGF0IGZ1bmN0aW9uLCB0 aGVuIApkZWZpbml0ZWx5IHllcywgZm9yIGV4YW1wbGUsIGluIHRoaXMgd2F5OgoKMS4gYXJjaC94 ODYvbW0vaW5pdC5jIG9yIG90aGVyIGNvbW1vbiAobm9uLVhlbiBzcGVjaWZpYykgbG9jYXRpb246 CgojaWZkZWYgQ09ORklHX0FSQ0hfSEFTX1JFU1RSSUNURURfVklSVElPX01FTU9SWV9BQ0NFU1MK aW50IGFyY2hfaGFzX3Jlc3RyaWN0ZWRfdmlydGlvX21lbW9yeV9hY2Nlc3Modm9pZCkKewogwqDC oMKgIHJldHVybiAoeGVuX2hhc19yZXN0cmljdGVkX3ZpcnRpb19tZW1vcnlfYWNjZXNzKCkgfHwK IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgY2NfcGxhdGZvcm1faGFzKENDX0FUVFJfR1VFU1RfTUVN X0VOQ1JZUFQpKTsKfQpFWFBPUlRfU1lNQk9MX0dQTChhcmNoX2hhc19yZXN0cmljdGVkX3ZpcnRp b19tZW1vcnlfYWNjZXNzKTsKI2VuZGlmCgoyLsKgIGluY2x1ZGUveGVuL3hlbi5oIG9yIG90aGVy IFhlbiBzcGVjaWZpYyBsb2NhdGlvbjoKCnN0YXRpYyBpbmxpbmUgaW50IHhlbl9oYXNfcmVzdHJp Y3RlZF92aXJ0aW9fbWVtb3J5X2FjY2Vzcyh2b2lkKQp7CiDCoMKgwqAgaWYgKElTX0VOQUJMRUQo Q09ORklHX1hFTl9QVl9WSVJUSU8pICYmIHhlbl9wdl9kb21haW4oKSkKIMKgwqDCoMKgwqDCoMKg IHJldHVybiAxOwogwqDCoMKgIGlmIChJU19FTkFCTEVEKENPTkZJR19YRU5fSFZNX1ZJUlRJT19H UkFOVCkgJiYgeGVuX2h2bV9kb21haW4oKSkKIMKgwqDCoMKgwqDCoMKgIHJldHVybiAxOwoKIMKg wqDCoCByZXR1cm4gMDsKfQoKT3IgSSBtaXN1bmRlcnN0b29kIHlvdXIgcXVlc3Rpb24/CgotLSAK UmVnYXJkcywKCk9sZWtzYW5kciBUeXNoY2hlbmtvCgoKX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX18KbGludXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxpc3QKbGlu dXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQu b3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtYXJtLWtlcm5lbAo=