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 36B98C433EF for ; Sun, 17 Apr 2022 17:02:34 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232858AbiDQRFH (ORCPT ); Sun, 17 Apr 2022 13:05:07 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:52596 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231211AbiDQRFG (ORCPT ); Sun, 17 Apr 2022 13:05:06 -0400 Received: from mail-lj1-x230.google.com (mail-lj1-x230.google.com [IPv6:2a00:1450:4864:20::230]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 976155F93 for ; Sun, 17 Apr 2022 10:02:29 -0700 (PDT) Received: by mail-lj1-x230.google.com with SMTP id h11so14604204ljb.2 for ; Sun, 17 Apr 2022 10:02:29 -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=hafAfueljTfqgLafYpJ0VMiQP+fHqJGqkLhjQLTHMfs=; b=KZJTT9SaRHmCQskg5KlLXLJayizDmfcXTulKEUTAmG26q9Ke698WoFa1dnScnVYZwM FmMTpBuiAZDzjQ6iaOFshvmdkkq9k+WFUSw+l7loDt6ZugMuE7lzvgO6gGUHj0jOL/2I iPzmbJTVDbT0pNBr0KOU7sCDqZQ5pLUIAEpisphAyO02bKLkAzoHdCAFGvaCQj6EtLNB 0rNvP5LejaJ2jOXJ1skyloepvxUjTTN61qIGxiBSo4qfv/aFoGzacNzTFjP8oDN+FQIn GuUAweqfRB4d6sfyyomA8t6W41kGI7HkO0bMDKExMbukUQ8NmWQl+1pDJh2eXU81M8lW hsvw== 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=hafAfueljTfqgLafYpJ0VMiQP+fHqJGqkLhjQLTHMfs=; b=IQxDPYNuP7Qq+HeVv6yK5B+7fmEUr3r9CcReyAIaNzWZZmn/5EoSwcTEjY5G8QFXbz hgjIzC4AnDLMgov3obqRQ7b5NGHHrVAGVzpq4BCEuV3wmjLHuvWebkS9X1RBQvAEkxG3 NKfZBWt1yOlqKLl5frAOe+AnqoBI7xyl165A2UwlwmD22cqsMas91W6JAWl6h+L/gBQN BK3ujYzJ7kz8cKM82rldSyicASjh4RQwQB0zAS2Xgu0w8yTe2PpjxUSOJGGn91wEoMAo vRbi5yO2qnq7Ox4MjkYQmbcs5H1VXzj8eqExlFTHB+FInnnO7dO0aYddVTIBU5Gik9oV hQiA== X-Gm-Message-State: AOAM532aiKeJk5RRmU6OwogwvXfp29rUgnh+KHW4LT8rOKwkkXbXyJyq ze/kYyIQw8irQUDzv4d5OUM= X-Google-Smtp-Source: ABdhPJx6FibJ/hCfUGzrlPei6jqFjeM4z16w/wWKJHfluEauRsSBrcOz2tinQuqtoorCY4g25STP/w== X-Received: by 2002:a2e:9c8f:0:b0:24d:ba11:7552 with SMTP id x15-20020a2e9c8f000000b0024dba117552mr1541735lji.260.1650214946667; Sun, 17 Apr 2022 10:02:26 -0700 (PDT) Received: from [192.168.1.7] ([212.22.223.21]) by smtp.gmail.com with ESMTPSA id e9-20020a05651c04c900b0024b6ce19ef1sm921681lji.96.2022.04.17.10.02.25 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Sun, 17 Apr 2022 10:02:26 -0700 (PDT) Subject: Re: [RFC PATCH 2/6] virtio: add option to restrict memory access under Xen To: Stefano Stabellini 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 , "H. Peter Anvin" , Boris Ostrovsky , Julien Grall , Oleksandr Tyshchenko , linux-arm-kernel@lists.infradead.org, Christoph Hellwig , "Michael S. Tsirkin" References: <1649963973-22879-1-git-send-email-olekstysh@gmail.com> <1649963973-22879-3-git-send-email-olekstysh@gmail.com> From: Oleksandr Message-ID: <8a66ad42-a3e7-c29d-7d4e-35766dcccd15@gmail.com> Date: Sun, 17 Apr 2022 20:02:24 +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: 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 16.04.22 01:01, Stefano Stabellini wrote: Hello Stefano > On Thu, 14 Apr 2022, 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; > I think these two checks could be moved to a separate function in a Xen > header, e.g. xen_restricted_virtio_memory_access, and here you could > just > > if (xen_restricted_virtio_memory_access()) > return 1; Agree, will do > > > >> + 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). > I don't think we need 3 visible kconfig options for this. > > In fact, I would only add one: XEN_VIRTIO. We can have any X86 (or ARM) > specific dependencies in the "depends" line under XEN_VIRTIO. And I > don't think we need XEN_HVM_VIRTIO_GRANT as a kconfig option > necessarely. It doesn't seem like some we want as build time option. At > most, it could be a runtime option (like a command line) or a debug > option (like an #define at the top of the source file.) I don't know what was the initial idea of having and extra XEN_HVM_VIRTIO and XEN_PV_VIRTIO options, but taking into the account that they are only used in arch_has_restricted_virtio_memory_access() currently, I share your opinion regarding a single XEN_VIRTIO option. Looking ahead (including changes in the commit #4), we can imagine the resulting option: config XEN_VIRTIO     bool "Xen virtio support"     default n     depends on VIRTIO && DMA_OPS     depends on (X86_64 || ARM || ARM64)     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). and then arch_has_restricted_virtio_memory_access() per arch: 1. x86: int arch_has_restricted_virtio_memory_access(void) {     return (xen_has_restricted_virtio_memory_access() ||             cc_platform_has(CC_ATTR_GUEST_MEM_ENCRYPT)); } 2. Arm: int arch_has_restricted_virtio_memory_access(void) {     return xen_has_restricted_virtio_memory_access(); } 3. xen.h: static inline int xen_has_restricted_virtio_memory_access(void) {     if (IS_ENABLED(CONFIG_XEN_VIRTIO) && (xen_pv_domain() || xen_hvm_domain()))         return 1;     return 0; } Actually, as domain type on Arm is always XEN_HVM_DOMAIN, we could probably have the following on Arm: int arch_has_restricted_virtio_memory_access(void) {     return IS_ENABLED(CONFIG_XEN_VIRTIO); } but I would prefer not to diverge and use common xen_has_restricted_virtio_memory_access(). Any thoughts? > > >> 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 > NIT: (1ULL << 31) ok, I assume you meant (1ULL << 63)? > > >> +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. > I would add device tree as possible way of domid communication I agree, but changes in the commit #4 (which add DT support and remove hardcoded domid 0) render this comment stale. For the next version I will squash changes and drop or rephrase this comment. > > >> + */ >> +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); >> +} > You can implement xen_virtio_dma_map_sg and xen_virtio_dma_unmap_sg > based on xen_virtio_dma_map_page and xen_virtio_dma_unmap_page, like we > do in drivers/xen/swiotlb-xen.c. Good point, thank you, will implement. > > >> +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 */ >> -- >> 2.7.4 >> -- 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 78E7BC433EF for ; Sun, 17 Apr 2022 17:04:11 +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=KULiWc0W8qBjjqsneG8emc4puCnXXJs8bDwvScwjxr8=; b=BgAk+jj9fo/xqKiNBpJ+OvjFyb KqlUOyVa0RKzj9dnbMBjDyUB545PKMbzzrTm7UPYGjJTuOz4M1WVem38A2jUSgK9Ok1oMQddk7r/R 017pbU+zNxH2GuT57WGukagdhWETNIvNu3Zb3v9wvRo6EXaMpFcRPHibFTr5fjFwUlIfXibVytjVd Zbq/MkuY+QSQ7Pys4LUiqL6RCaG9Fcao0szs5Brx5dgQXOUfFfvKQS39uaTVtVitMHutke3TbRZpA G52sZTYaiLpUCLwA7itL2ltW4BVExYBkV+vwQI5HJDUOr3ejlbclzlK24+dvwr8E2BTeBk43nND+c /xYgEwRg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1ng8IN-00Eg7y-82; Sun, 17 Apr 2022 17:02:43 +0000 Received: from mail-lj1-x22f.google.com ([2a00:1450:4864:20::22f]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1ng8IB-00Eg4Z-B3 for linux-arm-kernel@lists.infradead.org; Sun, 17 Apr 2022 17:02:33 +0000 Received: by mail-lj1-x22f.google.com with SMTP id n17so9687816ljc.11 for ; Sun, 17 Apr 2022 10:02:29 -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=hafAfueljTfqgLafYpJ0VMiQP+fHqJGqkLhjQLTHMfs=; b=KZJTT9SaRHmCQskg5KlLXLJayizDmfcXTulKEUTAmG26q9Ke698WoFa1dnScnVYZwM FmMTpBuiAZDzjQ6iaOFshvmdkkq9k+WFUSw+l7loDt6ZugMuE7lzvgO6gGUHj0jOL/2I iPzmbJTVDbT0pNBr0KOU7sCDqZQ5pLUIAEpisphAyO02bKLkAzoHdCAFGvaCQj6EtLNB 0rNvP5LejaJ2jOXJ1skyloepvxUjTTN61qIGxiBSo4qfv/aFoGzacNzTFjP8oDN+FQIn GuUAweqfRB4d6sfyyomA8t6W41kGI7HkO0bMDKExMbukUQ8NmWQl+1pDJh2eXU81M8lW hsvw== 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=hafAfueljTfqgLafYpJ0VMiQP+fHqJGqkLhjQLTHMfs=; b=K9KTCmPRRe9W83R0Nby7yvf/mVBJgHUfJ6fJXi0zWtHTob3nW0rQtebsGA8xjfF4s+ 15+jcmrgRoI70Oe1y2VLkE++hjUNB31FYHwjZAYTHsrljB+lMNR2bkfV3utmiW5a0pxc lJlpN7m2/zcGv/QFk8ARNJfOvc045ZeIlIOMXXMAeyY0aAj4S5ezFlhC9MF2vmB/dWAS ztwpja+HBHSEZ5R+qa/kD7m3h6X6KfDUU26kv/EJqA8SqnmEfdS8xeg3526MjCZoBcsP TkjYB05sk2cHvjbNWN+XQG6E6cuB+pr9KE+2lDigEfqqcmnOHRb/FdZkWLOBTcr0KBuq VBig== X-Gm-Message-State: AOAM532A0c51ulYB0iGB4Y8N1+56wUtlbWG3pbMu8qWfZ00pcBOvo4yQ KEKkuqxuNJ3yP+KtyLmznuE= X-Google-Smtp-Source: ABdhPJx6FibJ/hCfUGzrlPei6jqFjeM4z16w/wWKJHfluEauRsSBrcOz2tinQuqtoorCY4g25STP/w== X-Received: by 2002:a2e:9c8f:0:b0:24d:ba11:7552 with SMTP id x15-20020a2e9c8f000000b0024dba117552mr1541735lji.260.1650214946667; Sun, 17 Apr 2022 10:02:26 -0700 (PDT) Received: from [192.168.1.7] ([212.22.223.21]) by smtp.gmail.com with ESMTPSA id e9-20020a05651c04c900b0024b6ce19ef1sm921681lji.96.2022.04.17.10.02.25 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Sun, 17 Apr 2022 10:02:26 -0700 (PDT) Subject: Re: [RFC PATCH 2/6] virtio: add option to restrict memory access under Xen To: Stefano Stabellini 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 , "H. Peter Anvin" , Boris Ostrovsky , Julien Grall , Oleksandr Tyshchenko , linux-arm-kernel@lists.infradead.org, Christoph Hellwig , "Michael S. Tsirkin" References: <1649963973-22879-1-git-send-email-olekstysh@gmail.com> <1649963973-22879-3-git-send-email-olekstysh@gmail.com> From: Oleksandr Message-ID: <8a66ad42-a3e7-c29d-7d4e-35766dcccd15@gmail.com> Date: Sun, 17 Apr 2022 20:02:24 +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: Content-Language: en-US X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220417_100231_462022_9BE0FF72 X-CRM114-Status: GOOD ( 45.68 ) 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 Ck9uIDE2LjA0LjIyIDAxOjAxLCBTdGVmYW5vIFN0YWJlbGxpbmkgd3JvdGU6CgoKSGVsbG8gU3Rl ZmFubwoKCj4gT24gVGh1LCAxNCBBcHIgMjAyMiwgT2xla3NhbmRyIFR5c2hjaGVua28gd3JvdGU6 Cj4+IEZyb206IEp1ZXJnZW4gR3Jvc3MgPGpncm9zc0BzdXNlLmNvbT4KPj4KPj4gSW4gb3JkZXIg dG8gc3VwcG9ydCB2aXJ0aW8gaW4gWGVuIGd1ZXN0cyBhZGQgYSBjb25maWcgb3B0aW9uIGVuYWJs aW5nCj4+IHRoZSB1c2VyIHRvIHNwZWNpZnkgd2hldGhlciBpbiBhbGwgWGVuIGd1ZXN0cyB2aXJ0 aW8gc2hvdWxkIGJlIGFibGUgdG8KPj4gYWNjZXNzIG1lbW9yeSB2aWEgWGVuIGdyYW50IG1hcHBp bmdzIG9ubHkgb24gdGhlIGhvc3Qgc2lkZS4KPj4KPj4gVGhpcyBhcHBsaWVzIHRvIGZ1bGx5IHZp cnR1YWxpemVkIGd1ZXN0cyBvbmx5LCBhcyBmb3IgcGFyYXZpcnR1YWxpemVkCj4+IGd1ZXN0cyB0 aGlzIGlzIG1hbmRhdG9yeS4KPj4KPj4gVGhpcyByZXF1aXJlcyB0byBzd2l0Y2ggYXJjaF9oYXNf cmVzdHJpY3RlZF92aXJ0aW9fbWVtb3J5X2FjY2VzcygpCj4+IGZyb20gYSBwdXJlIHN0dWIgdG8g YSByZWFsIGZ1bmN0aW9uIG9uIHg4NiBzeXN0ZW1zIChBcm0gc3lzdGVtcyBhcmUKPj4gbm90IGNv dmVyZWQgYnkgbm93KS4KPj4KPj4gQWRkIHRoZSBuZWVkZWQgZnVuY3Rpb25hbGl0eSBieSBwcm92 aWRpbmcgYSBzcGVjaWFsIHNldCBvZiBETUEgb3BzCj4+IGhhbmRsaW5nIHRoZSBuZWVkZWQgZ3Jh bnQgb3BlcmF0aW9ucyBmb3IgdGhlIEkvTyBwYWdlcy4KPj4KPj4gU2lnbmVkLW9mZi1ieTogSnVl cmdlbiBHcm9zcyA8amdyb3NzQHN1c2UuY29tPgo+PiAtLS0KPj4gICBhcmNoL3g4Ni9tbS9pbml0 LmMgICAgICAgIHwgIDE1ICsrKysKPj4gICBhcmNoL3g4Ni9tbS9tZW1fZW5jcnlwdC5jIHwgICA1 IC0tCj4+ICAgYXJjaC94ODYveGVuL0tjb25maWcgICAgICB8ICAgOSArKysKPj4gICBkcml2ZXJz L3hlbi9LY29uZmlnICAgICAgIHwgIDIwICsrKysrKwo+PiAgIGRyaXZlcnMveGVuL01ha2VmaWxl ICAgICAgfCAgIDEgKwo+PiAgIGRyaXZlcnMveGVuL3hlbi12aXJ0aW8uYyAgfCAxNzcgKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+PiAgIGluY2x1ZGUveGVu L3hlbi1vcHMuaCAgICAgfCAgIDggKysrCj4+ICAgNyBmaWxlcyBjaGFuZ2VkLCAyMzAgaW5zZXJ0 aW9ucygrKSwgNSBkZWxldGlvbnMoLSkKPj4gICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy94 ZW4veGVuLXZpcnRpby5jCj4+Cj4+IGRpZmYgLS1naXQgYS9hcmNoL3g4Ni9tbS9pbml0LmMgYi9h cmNoL3g4Ni9tbS9pbml0LmMKPj4gaW5kZXggZDhjZmNlMi4uNTI2YTNiMiAxMDA2NDQKPj4gLS0t IGEvYXJjaC94ODYvbW0vaW5pdC5jCj4+ICsrKyBiL2FyY2gveDg2L21tL2luaXQuYwo+PiBAQCAt OCw2ICs4LDggQEAKPj4gICAjaW5jbHVkZSA8bGludXgva21lbWxlYWsuaD4KPj4gICAjaW5jbHVk ZSA8bGludXgvc2NoZWQvdGFzay5oPgo+PiAgIAo+PiArI2luY2x1ZGUgPHhlbi94ZW4uaD4KPj4g Kwo+PiAgICNpbmNsdWRlIDxhc20vc2V0X21lbW9yeS5oPgo+PiAgICNpbmNsdWRlIDxhc20vZTgy MC9hcGkuaD4KPj4gICAjaW5jbHVkZSA8YXNtL2luaXQuaD4KPj4gQEAgLTEwNjUsMyArMTA2Nywx NiBAQCB1bnNpZ25lZCBsb25nIG1heF9zd2FwZmlsZV9zaXplKHZvaWQpCj4+ICAgCXJldHVybiBw YWdlczsKPj4gICB9Cj4+ICAgI2VuZGlmCj4+ICsKPj4gKyNpZmRlZiBDT05GSUdfQVJDSF9IQVNf UkVTVFJJQ1RFRF9WSVJUSU9fTUVNT1JZX0FDQ0VTUwo+PiAraW50IGFyY2hfaGFzX3Jlc3RyaWN0 ZWRfdmlydGlvX21lbW9yeV9hY2Nlc3Modm9pZCkKPj4gK3sKPj4gKwlpZiAoSVNfRU5BQkxFRChD T05GSUdfWEVOX1BWX1ZJUlRJTykgJiYgeGVuX3B2X2RvbWFpbigpKQo+PiArCQlyZXR1cm4gMTsK Pj4gKwlpZiAoSVNfRU5BQkxFRChDT05GSUdfWEVOX0hWTV9WSVJUSU9fR1JBTlQpICYmIHhlbl9o dm1fZG9tYWluKCkpCj4+ICsJCXJldHVybiAxOwo+IEkgdGhpbmsgdGhlc2UgdHdvIGNoZWNrcyBj b3VsZCBiZSBtb3ZlZCB0byBhIHNlcGFyYXRlIGZ1bmN0aW9uIGluIGEgWGVuCj4gaGVhZGVyLCBl LmcuIHhlbl9yZXN0cmljdGVkX3ZpcnRpb19tZW1vcnlfYWNjZXNzLCBhbmQgaGVyZSB5b3UgY291 bGQKPiBqdXN0Cj4KPiBpZiAoeGVuX3Jlc3RyaWN0ZWRfdmlydGlvX21lbW9yeV9hY2Nlc3MoKSkK PiAgICAgIHJldHVybiAxOwoKQWdyZWUsIHdpbGwgZG8KCgo+Cj4KPgo+PiArCXJldHVybiBjY19w bGF0Zm9ybV9oYXMoQ0NfQVRUUl9HVUVTVF9NRU1fRU5DUllQVCk7Cj4+ICt9Cj4+ICtFWFBPUlRf U1lNQk9MX0dQTChhcmNoX2hhc19yZXN0cmljdGVkX3ZpcnRpb19tZW1vcnlfYWNjZXNzKTsKPj4g KyNlbmRpZgo+PiBkaWZmIC0tZ2l0IGEvYXJjaC94ODYvbW0vbWVtX2VuY3J5cHQuYyBiL2FyY2gv eDg2L21tL21lbV9lbmNyeXB0LmMKPj4gaW5kZXggNTBkMjA5OS4uZGRhMDIwZiAxMDA2NDQKPj4g LS0tIGEvYXJjaC94ODYvbW0vbWVtX2VuY3J5cHQuYwo+PiArKysgYi9hcmNoL3g4Ni9tbS9tZW1f ZW5jcnlwdC5jCj4+IEBAIC03Nyw4ICs3NywzIEBAIHZvaWQgX19pbml0IG1lbV9lbmNyeXB0X2lu aXQodm9pZCkKPj4gICAJcHJpbnRfbWVtX2VuY3J5cHRfZmVhdHVyZV9pbmZvKCk7Cj4+ICAgfQo+ PiAgIAo+PiAtaW50IGFyY2hfaGFzX3Jlc3RyaWN0ZWRfdmlydGlvX21lbW9yeV9hY2Nlc3Modm9p ZCkKPj4gLXsKPj4gLQlyZXR1cm4gY2NfcGxhdGZvcm1faGFzKENDX0FUVFJfR1VFU1RfTUVNX0VO Q1JZUFQpOwo+PiAtfQo+PiAtRVhQT1JUX1NZTUJPTF9HUEwoYXJjaF9oYXNfcmVzdHJpY3RlZF92 aXJ0aW9fbWVtb3J5X2FjY2Vzcyk7Cj4+IGRpZmYgLS1naXQgYS9hcmNoL3g4Ni94ZW4vS2NvbmZp ZyBiL2FyY2gveDg2L3hlbi9LY29uZmlnCj4+IGluZGV4IDg1MjQ2ZGQuLmRmZmRmZmQgMTAwNjQ0 Cj4+IC0tLSBhL2FyY2gveDg2L3hlbi9LY29uZmlnCj4+ICsrKyBiL2FyY2gveDg2L3hlbi9LY29u ZmlnCj4+IEBAIC05MiwzICs5MiwxMiBAQCBjb25maWcgWEVOX0RPTTAKPj4gICAJc2VsZWN0IFg4 Nl9YMkFQSUMgaWYgWEVOX1BWSCAmJiBYODZfNjQKPj4gICAJaGVscAo+PiAgIAkgIFN1cHBvcnQg cnVubmluZyBhcyBhIFhlbiBEb20wIGd1ZXN0Lgo+PiArCj4+ICtjb25maWcgWEVOX1BWX1ZJUlRJ Two+PiArCWJvb2wgIlhlbiB2aXJ0aW8gc3VwcG9ydCBmb3IgUFYgZ3Vlc3RzIgo+PiArCWRlcGVu ZHMgb24gWEVOX1ZJUlRJTyAmJiBYRU5fUFYKPj4gKwlkZWZhdWx0IHkKPj4gKwloZWxwCj4+ICsJ ICBTdXBwb3J0IHZpcnRpbyBmb3IgcnVubmluZyBhcyBhIHBhcmF2aXJ0dWFsaXplZCBndWVzdC4g VGhpcyB3aWxsCj4+ICsJICBuZWVkIHN1cHBvcnQgb24gdGhlIGJhY2tlbmQgc2lkZSAocWVtdSBv ciBrZXJuZWwsIGRlcGVuZGluZyBvbiB0aGUKPj4gKwkgIHZpcnRpbyBkZXZpY2UgdHlwZXMgdXNl ZCkuCj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9LY29uZmlnIGIvZHJpdmVycy94ZW4vS2Nv bmZpZwo+PiBpbmRleCAxMjBkMzJmLi5mYzYxZjdhIDEwMDY0NAo+PiAtLS0gYS9kcml2ZXJzL3hl bi9LY29uZmlnCj4+ICsrKyBiL2RyaXZlcnMveGVuL0tjb25maWcKPj4gQEAgLTMzNSw0ICszMzUs MjQgQEAgY29uZmlnIFhFTl9VTlBPUFVMQVRFRF9BTExPQwo+PiAgIAkgIGhhdmluZyB0byBiYWxs b29uIG91dCBSQU0gcmVnaW9ucyBpbiBvcmRlciB0byBvYnRhaW4gcGh5c2ljYWwgbWVtb3J5Cj4+ ICAgCSAgc3BhY2UgdG8gY3JlYXRlIHN1Y2ggbWFwcGluZ3MuCj4+ICAgCj4+ICtjb25maWcgWEVO X1ZJUlRJTwo+PiArCWJvb2wgIlhlbiB2aXJ0aW8gc3VwcG9ydCIKPj4gKwlkZWZhdWx0IG4KPj4g KwlkZXBlbmRzIG9uIFZJUlRJTyAmJiBETUFfT1BTCj4+ICsJc2VsZWN0IEFSQ0hfSEFTX1JFU1RS SUNURURfVklSVElPX01FTU9SWV9BQ0NFU1MKPj4gKwloZWxwCj4+ICsJICBFbmFibGUgdmlydGlv IHN1cHBvcnQgZm9yIHJ1bm5pbmcgYXMgWGVuIGd1ZXN0LiBEZXBlbmRpbmcgb24gdGhlCj4+ICsJ ICBndWVzdCB0eXBlIHRoaXMgd2lsbCByZXF1aXJlIHNwZWNpYWwgc3VwcG9ydCBvbiB0aGUgYmFj a2VuZCBzaWRlCj4+ICsJICAocWVtdSBvciBrZXJuZWwsIGRlcGVuZGluZyBvbiB0aGUgdmlydGlv IGRldmljZSB0eXBlcyB1c2VkKS4KPj4gKwo+PiArY29uZmlnIFhFTl9IVk1fVklSVElPX0dSQU5U Cj4+ICsJYm9vbCAiUmVxdWlyZSB2aXJ0aW8gZm9yIGZ1bGx5IHZpcnR1YWxpemVkIGd1ZXN0cyB0 byB1c2UgZ3JhbnQgbWFwcGluZ3MiCj4+ICsJZGVwZW5kcyBvbiBYRU5fVklSVElPICYmIFg4Nl82 NAo+PiArCWRlZmF1bHQgeQo+PiArCWhlbHAKPj4gKwkgIFJlcXVpcmUgdmlydGlvIGZvciBmdWxs eSB2aXJ0dWFsaXplZCBndWVzdHMgdG8gdXNlIGdyYW50IG1hcHBpbmdzLgo+PiArCSAgVGhpcyB3 aWxsIGF2b2lkIHRoZSBuZWVkIHRvIGdpdmUgdGhlIGJhY2tlbmQgdGhlIHJpZ2h0IHRvIG1hcCBh bGwKPj4gKwkgIG9mIHRoZSBndWVzdCBtZW1vcnkuIFRoaXMgd2lsbCBuZWVkIHN1cHBvcnQgb24g dGhlIGJhY2tlbmQgc2lkZQo+PiArCSAgKHFlbXUgb3Iga2VybmVsLCBkZXBlbmRpbmcgb24gdGhl IHZpcnRpbyBkZXZpY2UgdHlwZXMgdXNlZCkuCj4gSSBkb24ndCB0aGluayB3ZSBuZWVkIDMgdmlz aWJsZSBrY29uZmlnIG9wdGlvbnMgZm9yIHRoaXMuCj4KPiBJbiBmYWN0LCBJIHdvdWxkIG9ubHkg YWRkIG9uZTogWEVOX1ZJUlRJTy4gV2UgY2FuIGhhdmUgYW55IFg4NiAob3IgQVJNKQo+IHNwZWNp ZmljIGRlcGVuZGVuY2llcyBpbiB0aGUgImRlcGVuZHMiIGxpbmUgdW5kZXIgWEVOX1ZJUlRJTy4g QW5kIEkKPiBkb24ndCB0aGluayB3ZSBuZWVkIFhFTl9IVk1fVklSVElPX0dSQU5UIGFzIGEga2Nv bmZpZyBvcHRpb24KPiBuZWNlc3NhcmVseS4gSXQgZG9lc24ndCBzZWVtIGxpa2Ugc29tZSB3ZSB3 YW50IGFzIGJ1aWxkIHRpbWUgb3B0aW9uLiBBdAo+IG1vc3QsIGl0IGNvdWxkIGJlIGEgcnVudGlt ZSBvcHRpb24gKGxpa2UgYSBjb21tYW5kIGxpbmUpIG9yIGEgZGVidWcKPiBvcHRpb24gKGxpa2Ug YW4gI2RlZmluZSBhdCB0aGUgdG9wIG9mIHRoZSBzb3VyY2UgZmlsZS4pCgoKSSBkb24ndCBrbm93 IHdoYXQgd2FzIHRoZSBpbml0aWFsIGlkZWEgb2YgaGF2aW5nIGFuZCBleHRyYSAKWEVOX0hWTV9W SVJUSU8gYW5kIFhFTl9QVl9WSVJUSU8gb3B0aW9ucywgYnV0IHRha2luZyBpbnRvIHRoZSBhY2Nv dW50IHRoYXQKdGhleSBhcmUgb25seSB1c2VkIGluIGFyY2hfaGFzX3Jlc3RyaWN0ZWRfdmlydGlv X21lbW9yeV9hY2Nlc3MoKSAKY3VycmVudGx5LCBJIHNoYXJlIHlvdXIgb3BpbmlvbiByZWdhcmRp bmcgYSBzaW5nbGUgWEVOX1ZJUlRJTyBvcHRpb24uCgpMb29raW5nIGFoZWFkIChpbmNsdWRpbmcg Y2hhbmdlcyBpbiB0aGUgY29tbWl0ICM0KSwgd2UgY2FuIGltYWdpbmUgdGhlIApyZXN1bHRpbmcg b3B0aW9uOgoKY29uZmlnIFhFTl9WSVJUSU8KIMKgwqDCoCBib29sICJYZW4gdmlydGlvIHN1cHBv cnQiCiDCoMKgwqAgZGVmYXVsdCBuCiDCoMKgwqAgZGVwZW5kcyBvbiBWSVJUSU8gJiYgRE1BX09Q UwogwqDCoMKgIGRlcGVuZHMgb24gKFg4Nl82NCB8fCBBUk0gfHwgQVJNNjQpCiDCoMKgwqAgc2Vs ZWN0IEFSQ0hfSEFTX1JFU1RSSUNURURfVklSVElPX01FTU9SWV9BQ0NFU1MKIMKgwqDCoCBoZWxw CiDCoMKgwqAgwqAgRW5hYmxlIHZpcnRpbyBzdXBwb3J0IGZvciBydW5uaW5nIGFzIFhlbiBndWVz dC4gRGVwZW5kaW5nIG9uIHRoZQogwqDCoMKgIMKgIGd1ZXN0IHR5cGUgdGhpcyB3aWxsIHJlcXVp cmUgc3BlY2lhbCBzdXBwb3J0IG9uIHRoZSBiYWNrZW5kIHNpZGUKIMKgwqDCoCDCoCAocWVtdSBv ciBrZXJuZWwsIGRlcGVuZGluZyBvbiB0aGUgdmlydGlvIGRldmljZSB0eXBlcyB1c2VkKS4KCgph bmQgdGhlbiBhcmNoX2hhc19yZXN0cmljdGVkX3ZpcnRpb19tZW1vcnlfYWNjZXNzKCkgcGVyIGFy Y2g6CgoKMS4geDg2OgoKaW50IGFyY2hfaGFzX3Jlc3RyaWN0ZWRfdmlydGlvX21lbW9yeV9hY2Nl c3Modm9pZCkKewogwqDCoMKgIHJldHVybiAoeGVuX2hhc19yZXN0cmljdGVkX3ZpcnRpb19tZW1v cnlfYWNjZXNzKCkgfHwKIMKgwqDCoCDCoMKgwqAgwqDCoMKgIGNjX3BsYXRmb3JtX2hhcyhDQ19B VFRSX0dVRVNUX01FTV9FTkNSWVBUKSk7Cn0KCgoyLiBBcm06CgppbnQgYXJjaF9oYXNfcmVzdHJp Y3RlZF92aXJ0aW9fbWVtb3J5X2FjY2Vzcyh2b2lkKQp7CiDCoMKgwqAgcmV0dXJuIHhlbl9oYXNf cmVzdHJpY3RlZF92aXJ0aW9fbWVtb3J5X2FjY2VzcygpOwp9CgoKMy4geGVuLmg6CgpzdGF0aWMg aW5saW5lIGludCB4ZW5faGFzX3Jlc3RyaWN0ZWRfdmlydGlvX21lbW9yeV9hY2Nlc3Modm9pZCkK ewogwqDCoMKgIGlmIChJU19FTkFCTEVEKENPTkZJR19YRU5fVklSVElPKSAmJiAoeGVuX3B2X2Rv bWFpbigpIHx8IAp4ZW5faHZtX2RvbWFpbigpKSkKIMKgwqDCoCDCoMKgwqAgcmV0dXJuIDE7Cgog wqDCoMKgIHJldHVybiAwOwp9CgoKQWN0dWFsbHksIGFzIGRvbWFpbiB0eXBlIG9uIEFybSBpcyBh bHdheXMgWEVOX0hWTV9ET01BSU4sIHdlIGNvdWxkIApwcm9iYWJseSBoYXZlIHRoZSBmb2xsb3dp bmcgb24gQXJtOgoKaW50IGFyY2hfaGFzX3Jlc3RyaWN0ZWRfdmlydGlvX21lbW9yeV9hY2Nlc3Mo dm9pZCkKewogwqDCoMKgIHJldHVybiBJU19FTkFCTEVEKENPTkZJR19YRU5fVklSVElPKTsKfQoK YnV0IEkgd291bGQgcHJlZmVyIG5vdCB0byBkaXZlcmdlIGFuZCB1c2UgY29tbW9uIAp4ZW5faGFz X3Jlc3RyaWN0ZWRfdmlydGlvX21lbW9yeV9hY2Nlc3MoKS4KCkFueSB0aG91Z2h0cz8KCgoKPgo+ Cj4+ICAgZW5kbWVudQo+PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vTWFrZWZpbGUgYi9kcml2 ZXJzL3hlbi9NYWtlZmlsZQo+PiBpbmRleCA1YWFlNjZlLi43NjcwMDljIDEwMDY0NAo+PiAtLS0g YS9kcml2ZXJzL3hlbi9NYWtlZmlsZQo+PiArKysgYi9kcml2ZXJzL3hlbi9NYWtlZmlsZQo+PiBA QCAtMzksMyArMzksNCBAQCB4ZW4tZ250YWxsb2MteQkJCQk6PSBnbnRhbGxvYy5vCj4+ICAgeGVu LXByaXZjbWQteQkJCQk6PSBwcml2Y21kLm8gcHJpdmNtZC1idWYubwo+PiAgIG9iai0kKENPTkZJ R19YRU5fRlJPTlRfUEdESVJfU0hCVUYpCSs9IHhlbi1mcm9udC1wZ2Rpci1zaGJ1Zi5vCj4+ICAg b2JqLSQoQ09ORklHX1hFTl9VTlBPUFVMQVRFRF9BTExPQykJKz0gdW5wb3B1bGF0ZWQtYWxsb2Mu bwo+PiArb2JqLSQoQ09ORklHX1hFTl9WSVJUSU8pCQkrPSB4ZW4tdmlydGlvLm8KPj4gZGlmZiAt LWdpdCBhL2RyaXZlcnMveGVuL3hlbi12aXJ0aW8uYyBiL2RyaXZlcnMveGVuL3hlbi12aXJ0aW8u Ywo+PiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+PiBpbmRleCAwMDAwMDAwMC4uY2ZkNWVkYQo+PiAt LS0gL2Rldi9udWxsCj4+ICsrKyBiL2RyaXZlcnMveGVuL3hlbi12aXJ0aW8uYwo+PiBAQCAtMCww ICsxLDE3NyBAQAo+PiArLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAtb25seQo+ PiArLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKgo+PiArICogWGVuIHZpcnRpbyBkcml2ZXIgLSBlbmFi bGVzIHVzaW5nIHZpcnRpbyBkZXZpY2VzIGluIFhlbiBndWVzdHMuCj4+ICsgKgo+PiArICogQ29w eXJpZ2h0IChjKSAyMDIxLCBKdWVyZ2VuIEdyb3NzIDxqZ3Jvc3NAc3VzZS5jb20+Cj4+ICsgKi8K Pj4gKwo+PiArI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L2Rt YS1tYXAtb3BzLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvcGNpLmg+Cj4+ICsjaW5jbHVkZSA8bGlu dXgvcGZuLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvdmlydGlvX2NvbmZpZy5oPgo+PiArI2luY2x1 ZGUgPHhlbi94ZW4uaD4KPj4gKyNpbmNsdWRlIDx4ZW4vZ3JhbnRfdGFibGUuaD4KPj4gKwo+PiAr I2RlZmluZSBYRU5fR1JBTlRfQUREUl9PRkYJMHg4MDAwMDAwMDAwMDAwMDAwVUxMCj4gTklUOiAo MVVMTCA8PCAzMSkKCm9rLCBJIGFzc3VtZSB5b3UgbWVhbnQgKDFVTEwgPDwgNjMpPwoKCj4KPgo+ PiArc3RhdGljIGlubGluZSBkbWFfYWRkcl90IGdyYW50X3RvX2RtYShncmFudF9yZWZfdCBncmFu dCkKPj4gK3sKPj4gKwlyZXR1cm4gWEVOX0dSQU5UX0FERFJfT0ZGIHwgKChkbWFfYWRkcl90KWdy YW50IDw8IFBBR0VfU0hJRlQpOwo+PiArfQo+PiArCj4+ICtzdGF0aWMgaW5saW5lIGdyYW50X3Jl Zl90IGRtYV90b19ncmFudChkbWFfYWRkcl90IGRtYSkKPj4gK3sKPj4gKwlyZXR1cm4gKGdyYW50 X3JlZl90KSgoZG1hICYgflhFTl9HUkFOVF9BRERSX09GRikgPj4gUEFHRV9TSElGVCk7Cj4+ICt9 Cj4+ICsKPj4gKy8qCj4+ICsgKiBETUEgb3BzIGZvciBYZW4gdmlydGlvIGZyb250ZW5kcy4KPj4g KyAqCj4+ICsgKiBVc2VkIHRvIGFjdCBhcyBhIGtpbmQgb2Ygc29mdHdhcmUgSU9NTVUgZm9yIFhl biBndWVzdHMgYnkgdXNpbmcgZ3JhbnRzIGFzCj4+ICsgKiBETUEgYWRkcmVzc2VzLgo+PiArICog U3VjaCBhIERNQSBhZGRyZXNzIGlzIGZvcm1lZCBieSB1c2luZyB0aGUgZ3JhbnQgcmVmZXJlbmNl IGFzIGEgZnJhbWUKPj4gKyAqIG51bWJlciBhbmQgc2V0dGluZyB0aGUgaGlnaGVzdCBhZGRyZXNz IGJpdCAodGhpcyBiaXQgaXMgZm9yIHRoZSBiYWNrZW5kCj4+ICsgKiB0byBiZSBhYmxlIHRvIGRp c3Rpbmd1aXNoIGl0IGZyb20gZS5nLiBhIG1taW8gYWRkcmVzcykuCj4+ICsgKgo+PiArICogTm90 ZSB0aGF0IGZvciBub3cgd2UgaGFyZCB3aXJlIGRvbTAgdG8gYmUgdGhlIGJhY2tlbmQgZG9tYWlu LiBJbiBvcmRlciB0bwo+PiArICogc3VwcG9ydCBhbnkgZG9tYWluIGFzIGJhY2tlbmQgd2UnZCBu ZWVkIHRvIGFkZCBhIHdheSB0byBjb21tdW5pY2F0ZSB0aGUKPj4gKyAqIGRvbWlkIG9mIHRoaXMg YmFja2VuZCwgZS5nLiB2aWEgWGVuc3RvcmUgb3IgdmlhIHRoZSBQQ0ktZGV2aWNlJ3MgY29uZmln Cj4+ICsgKiBzcGFjZS4KPiBJIHdvdWxkIGFkZCBkZXZpY2UgdHJlZSBhcyBwb3NzaWJsZSB3YXkg b2YgZG9taWQgY29tbXVuaWNhdGlvbgoKSSBhZ3JlZSwgYnV0IGNoYW5nZXMgaW4gdGhlIGNvbW1p dCAjNCAod2hpY2ggYWRkIERUIHN1cHBvcnQgYW5kIHJlbW92ZSAKaGFyZGNvZGVkIGRvbWlkIDAp IHJlbmRlciB0aGlzIGNvbW1lbnQgc3RhbGUuIEZvciB0aGUgbmV4dCB2ZXJzaW9uIEkgCndpbGwg c3F1YXNoIGNoYW5nZXMgYW5kIGRyb3Agb3IgcmVwaHJhc2UgdGhpcyBjb21tZW50LgoKCj4KPgo+ PiArICovCj4+ICtzdGF0aWMgdm9pZCAqeGVuX3ZpcnRpb19kbWFfYWxsb2Moc3RydWN0IGRldmlj ZSAqZGV2LCBzaXplX3Qgc2l6ZSwKPj4gKwkJCQkgIGRtYV9hZGRyX3QgKmRtYV9oYW5kbGUsIGdm cF90IGdmcCwKPj4gKwkJCQkgIHVuc2lnbmVkIGxvbmcgYXR0cnMpCj4+ICt7Cj4+ICsJdW5zaWdu ZWQgaW50IG5fcGFnZXMgPSBQRk5fVVAoc2l6ZSk7Cj4+ICsJdW5zaWduZWQgaW50IGk7Cj4+ICsJ dW5zaWduZWQgbG9uZyBwZm47Cj4+ICsJZ3JhbnRfcmVmX3QgZ3JhbnQ7Cj4+ICsJdm9pZCAqcmV0 Owo+PiArCj4+ICsJcmV0ID0gKHZvaWQgKilfX2dldF9mcmVlX3BhZ2VzKGdmcCwgZ2V0X29yZGVy KHNpemUpKTsKPj4gKwlpZiAoIXJldCkKPj4gKwkJcmV0dXJuIE5VTEw7Cj4+ICsKPj4gKwlwZm4g PSB2aXJ0X3RvX3BmbihyZXQpOwo+PiArCj4+ICsJaWYgKGdudHRhYl9hbGxvY19ncmFudF9yZWZl cmVuY2Vfc2VxKG5fcGFnZXMsICZncmFudCkpIHsKPj4gKwkJZnJlZV9wYWdlcygodW5zaWduZWQg bG9uZylyZXQsIGdldF9vcmRlcihzaXplKSk7Cj4+ICsJCXJldHVybiBOVUxMOwo+PiArCX0KPj4g Kwo+PiArCWZvciAoaSA9IDA7IGkgPCBuX3BhZ2VzOyBpKyspIHsKPj4gKwkJZ250dGFiX2dyYW50 X2ZvcmVpZ25fYWNjZXNzX3JlZihncmFudCArIGksIDAsCj4+ICsJCQkJCQlwZm5fdG9fZ2ZuKHBm biArIGkpLCAwKTsKPj4gKwl9Cj4+ICsKPj4gKwkqZG1hX2hhbmRsZSA9IGdyYW50X3RvX2RtYShn cmFudCk7Cj4+ICsKPj4gKwlyZXR1cm4gcmV0Owo+PiArfQo+PiArCj4+ICtzdGF0aWMgdm9pZCB4 ZW5fdmlydGlvX2RtYV9mcmVlKHN0cnVjdCBkZXZpY2UgKmRldiwgc2l6ZV90IHNpemUsIHZvaWQg KnZhZGRyLAo+PiArCQkJCWRtYV9hZGRyX3QgZG1hX2hhbmRsZSwgdW5zaWduZWQgbG9uZyBhdHRy cykKPj4gK3sKPj4gKwl1bnNpZ25lZCBpbnQgbl9wYWdlcyA9IFBGTl9VUChzaXplKTsKPj4gKwl1 bnNpZ25lZCBpbnQgaTsKPj4gKwlncmFudF9yZWZfdCBncmFudDsKPj4gKwo+PiArCWdyYW50ID0g ZG1hX3RvX2dyYW50KGRtYV9oYW5kbGUpOwo+PiArCj4+ICsJZm9yIChpID0gMDsgaSA8IG5fcGFn ZXM7IGkrKykKPj4gKwkJZ250dGFiX2VuZF9mb3JlaWduX2FjY2Vzc19yZWYoZ3JhbnQgKyBpKTsK Pj4gKwo+PiArCWdudHRhYl9mcmVlX2dyYW50X3JlZmVyZW5jZV9zZXEoZ3JhbnQsIG5fcGFnZXMp Owo+PiArCj4+ICsJZnJlZV9wYWdlcygodW5zaWduZWQgbG9uZyl2YWRkciwgZ2V0X29yZGVyKHNp emUpKTsKPj4gK30KPj4gKwo+PiArc3RhdGljIHN0cnVjdCBwYWdlICp4ZW5fdmlydGlvX2RtYV9h bGxvY19wYWdlcyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHNpemVfdCBzaXplLAo+PiArCQkJCQkgICAg ICAgZG1hX2FkZHJfdCAqZG1hX2hhbmRsZSwKPj4gKwkJCQkJICAgICAgIGVudW0gZG1hX2RhdGFf ZGlyZWN0aW9uIGRpciwKPj4gKwkJCQkJICAgICAgIGdmcF90IGdmcCkKPj4gK3sKPj4gKwlXQVJO X09OQ0UoMSwgInhlbl92aXJ0aW9fZG1hX2FsbG9jX3BhZ2VzIHNpemUgJWxkXG4iLCBzaXplKTsK Pj4gKwlyZXR1cm4gTlVMTDsKPj4gK30KPj4gKwo+PiArc3RhdGljIHZvaWQgeGVuX3ZpcnRpb19k bWFfZnJlZV9wYWdlcyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHNpemVfdCBzaXplLAo+PiArCQkJCSAg ICAgIHN0cnVjdCBwYWdlICp2YWRkciwgZG1hX2FkZHJfdCBkbWFfaGFuZGxlLAo+PiArCQkJCSAg ICAgIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpcikKPj4gK3sKPj4gKwlXQVJOX09OQ0UoMSwg Inhlbl92aXJ0aW9fZG1hX2ZyZWVfcGFnZXMgc2l6ZSAlbGRcbiIsIHNpemUpOwo+PiArfQo+PiAr Cj4+ICtzdGF0aWMgZG1hX2FkZHJfdCB4ZW5fdmlydGlvX2RtYV9tYXBfcGFnZShzdHJ1Y3QgZGV2 aWNlICpkZXYsIHN0cnVjdCBwYWdlICpwYWdlLAo+PiArCQkJCQkgIHVuc2lnbmVkIGxvbmcgb2Zm c2V0LCBzaXplX3Qgc2l6ZSwKPj4gKwkJCQkJICBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIs Cj4+ICsJCQkJCSAgdW5zaWduZWQgbG9uZyBhdHRycykKPj4gK3sKPj4gKwlncmFudF9yZWZfdCBn cmFudDsKPj4gKwo+PiArCWlmIChnbnR0YWJfYWxsb2NfZ3JhbnRfcmVmZXJlbmNlcygxLCAmZ3Jh bnQpKQo+PiArCQlyZXR1cm4gMDsKPj4gKwo+PiArCWdudHRhYl9ncmFudF9mb3JlaWduX2FjY2Vz c19yZWYoZ3JhbnQsIDAsIHhlbl9wYWdlX3RvX2dmbihwYWdlKSwKPj4gKwkJCQkJZGlyID09IERN QV9UT19ERVZJQ0UpOwo+PiArCXJldHVybiBncmFudF90b19kbWEoZ3JhbnQpICsgb2Zmc2V0Owo+ PiArfQo+PiArCj4+ICtzdGF0aWMgdm9pZCB4ZW5fdmlydGlvX2RtYV91bm1hcF9wYWdlKHN0cnVj dCBkZXZpY2UgKmRldiwgZG1hX2FkZHJfdCBkbWFfaGFuZGxlLAo+PiArCQkJCSAgICAgIHNpemVf dCBzaXplLCBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIsCj4+ICsJCQkJICAgICAgdW5zaWdu ZWQgbG9uZyBhdHRycykKPj4gK3sKPj4gKwlncmFudF9yZWZfdCBncmFudDsKPj4gKwo+PiArCWdy YW50ID0gZG1hX3RvX2dyYW50KGRtYV9oYW5kbGUpOwo+PiArCj4+ICsJZ250dGFiX2VuZF9mb3Jl aWduX2FjY2Vzc19yZWYoZ3JhbnQpOwo+PiArCj4+ICsJZ250dGFiX2ZyZWVfZ3JhbnRfcmVmZXJl bmNlKGdyYW50KTsKPj4gK30KPj4gKwo+PiArc3RhdGljIGludCB4ZW5fdmlydGlvX2RtYV9tYXBf c2coc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnLAo+PiArCQkJCSBp bnQgbmVudHMsIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpciwKPj4gKwkJCQkgdW5zaWduZWQg bG9uZyBhdHRycykKPj4gK3sKPj4gKwlXQVJOX09OQ0UoMSwgInhlbl92aXJ0aW9fZG1hX21hcF9z ZyBuZW50cyAlZFxuIiwgbmVudHMpOwo+PiArCXJldHVybiAtRUlOVkFMOwo+PiArfQo+PiArCj4+ ICtzdGF0aWMgdm9pZCB4ZW5fdmlydGlvX2RtYV91bm1hcF9zZyhzdHJ1Y3QgZGV2aWNlICpkZXYs IHN0cnVjdCBzY2F0dGVybGlzdCAqc2csCj4+ICsJCQkJICAgIGludCBuZW50cywgZW51bSBkbWFf ZGF0YV9kaXJlY3Rpb24gZGlyLAo+PiArCQkJCSAgICB1bnNpZ25lZCBsb25nIGF0dHJzKQo+PiAr ewo+PiArCVdBUk5fT05DRSgxLCAieGVuX3ZpcnRpb19kbWFfdW5tYXBfc2cgbmVudHMgJWRcbiIs IG5lbnRzKTsKPj4gK30KPiBZb3UgY2FuIGltcGxlbWVudCB4ZW5fdmlydGlvX2RtYV9tYXBfc2cg YW5kIHhlbl92aXJ0aW9fZG1hX3VubWFwX3NnCj4gYmFzZWQgb24geGVuX3ZpcnRpb19kbWFfbWFw X3BhZ2UgYW5kIHhlbl92aXJ0aW9fZG1hX3VubWFwX3BhZ2UsIGxpa2Ugd2UKPiBkbyBpbiBkcml2 ZXJzL3hlbi9zd2lvdGxiLXhlbi5jLgoKR29vZCBwb2ludCwgdGhhbmsgeW91LCB3aWxsIGltcGxl bWVudC4KCgo+Cj4KPj4gK3N0YXRpYyBpbnQgeGVuX3ZpcnRpb19kbWFfZG1hX3N1cHBvcnRlZChz dHJ1Y3QgZGV2aWNlICpkZXYsIHU2NCBtYXNrKQo+PiArewo+PiArCXJldHVybiAxOwo+PiArfQo+ PiArCj4+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGRtYV9tYXBfb3BzIHhlbl92aXJ0aW9fZG1hX29w cyA9IHsKPj4gKwkuYWxsb2MgPSB4ZW5fdmlydGlvX2RtYV9hbGxvYywKPj4gKwkuZnJlZSA9IHhl bl92aXJ0aW9fZG1hX2ZyZWUsCj4+ICsJLmFsbG9jX3BhZ2VzID0geGVuX3ZpcnRpb19kbWFfYWxs b2NfcGFnZXMsCj4+ICsJLmZyZWVfcGFnZXMgPSB4ZW5fdmlydGlvX2RtYV9mcmVlX3BhZ2VzLAo+ PiArCS5tbWFwID0gZG1hX2NvbW1vbl9tbWFwLAo+PiArCS5nZXRfc2d0YWJsZSA9IGRtYV9jb21t b25fZ2V0X3NndGFibGUsCj4+ICsJLm1hcF9wYWdlID0geGVuX3ZpcnRpb19kbWFfbWFwX3BhZ2Us Cj4+ICsJLnVubWFwX3BhZ2UgPSB4ZW5fdmlydGlvX2RtYV91bm1hcF9wYWdlLAo+PiArCS5tYXBf c2cgPSB4ZW5fdmlydGlvX2RtYV9tYXBfc2csCj4+ICsJLnVubWFwX3NnID0geGVuX3ZpcnRpb19k bWFfdW5tYXBfc2csCj4+ICsJLmRtYV9zdXBwb3J0ZWQgPSB4ZW5fdmlydGlvX2RtYV9kbWFfc3Vw cG9ydGVkLAo+PiArfTsKPj4gKwo+PiArdm9pZCB4ZW5fdmlydGlvX3NldHVwX2RtYV9vcHMoc3Ry dWN0IGRldmljZSAqZGV2KQo+PiArewo+PiArCWRldi0+ZG1hX29wcyA9ICZ4ZW5fdmlydGlvX2Rt YV9vcHM7Cj4+ICt9Cj4+ICtFWFBPUlRfU1lNQk9MX0dQTCh4ZW5fdmlydGlvX3NldHVwX2RtYV9v cHMpOwo+PiArCj4+ICtNT0RVTEVfREVTQ1JJUFRJT04oIlhlbiB2aXJ0aW8gc3VwcG9ydCBkcml2 ZXIiKTsKPj4gK01PRFVMRV9BVVRIT1IoIkp1ZXJnZW4gR3Jvc3MgPGpncm9zc0BzdXNlLmNvbT4i KTsKPj4gK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsKPj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUveGVu L3hlbi1vcHMuaCBiL2luY2x1ZGUveGVuL3hlbi1vcHMuaAo+PiBpbmRleCBhMzU4NGEzLi5hZTNj MWJjIDEwMDY0NAo+PiAtLS0gYS9pbmNsdWRlL3hlbi94ZW4tb3BzLmgKPj4gKysrIGIvaW5jbHVk ZS94ZW4veGVuLW9wcy5oCj4+IEBAIC0yMjEsNCArMjIxLDEyIEBAIHN0YXRpYyBpbmxpbmUgdm9p ZCB4ZW5fcHJlZW1wdGlibGVfaGNhbGxfZW5kKHZvaWQpIHsgfQo+PiAgIAo+PiAgICNlbmRpZiAv KiBDT05GSUdfWEVOX1BWICYmICFDT05GSUdfUFJFRU1QVElPTiAqLwo+PiAgIAo+PiArI2lmZGVm IENPTkZJR19YRU5fVklSVElPCj4+ICt2b2lkIHhlbl92aXJ0aW9fc2V0dXBfZG1hX29wcyhzdHJ1 Y3QgZGV2aWNlICpkZXYpOwo+PiArI2Vsc2UKPj4gK3N0YXRpYyBpbmxpbmUgdm9pZCB4ZW5fdmly dGlvX3NldHVwX2RtYV9vcHMoc3RydWN0IGRldmljZSAqZGV2KQo+PiArewo+PiArfQo+PiArI2Vu ZGlmIC8qIENPTkZJR19YRU5fVklSVElPICovCj4+ICsKPj4gICAjZW5kaWYgLyogSU5DTFVERV9Y RU5fT1BTX0ggKi8KPj4gLS0gCj4+IDIuNy40Cj4+Ci0tIApSZWdhcmRzLAoKT2xla3NhbmRyIFR5 c2hjaGVua28KCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f XwpsaW51eC1hcm0ta2VybmVsIG1haWxpbmcgbGlzdApsaW51eC1hcm0ta2VybmVsQGxpc3RzLmlu ZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9s aW51eC1hcm0ta2VybmVsCg==