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 AB9D4C433F5 for ; Sun, 17 Apr 2022 18:21:27 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234752AbiDQSYB (ORCPT ); Sun, 17 Apr 2022 14:24:01 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:43832 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231321AbiDQSX7 (ORCPT ); Sun, 17 Apr 2022 14:23:59 -0400 Received: from mail-lj1-x22a.google.com (mail-lj1-x22a.google.com [IPv6:2a00:1450:4864:20::22a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id C81835FD0 for ; Sun, 17 Apr 2022 11:21:22 -0700 (PDT) Received: by mail-lj1-x22a.google.com with SMTP id bj36so8845444ljb.13 for ; Sun, 17 Apr 2022 11:21:22 -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=HOTM5tpBYxAb1qtW2MCOB1TQN7ARlsIhllyek+NnKb0=; b=klCT/uoPzTl1EgjzQV3oH8Ani6TzcUI1aYpYynSRvEWYqqRCk3Jj1LNk9ZktsbF/i0 n79fletwteCSJ30Z6u4+dfPXavKY08Xjlm1NUblBXiD8OA12dG6srB9dGE4bVEElY6g9 4K8EhnEM8U1dhftqZ1vSaxBWtKzg9B7x69yu8AYA9Mue/OVMjGlby7Ap+keAnbYqbh5U ub6OC4DabnVDsPmAtDwGqfRCBpkvrzHF1wOACQujG7M5asYiz+MCzcYR2kWvwu2cd9lz NeeXAttlwuEvJoxWGwiGpaucZkJrCsbhO9PFumUrgQ8VQLHuB4JwS6zWIvO8/Ah12NSu x50A== 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=HOTM5tpBYxAb1qtW2MCOB1TQN7ARlsIhllyek+NnKb0=; b=0I/qDviXH327JrRtaJcVRxWLfaPYeAs6cLCW/XLypIkwO9Xlg7sLfdjPxByiglp1hg L/jJh0sSIV/J8ROC98TG04OxIEqDJ5vhkplVEuu+pi/BSWcf8hX4AbAYuKIZ5q6R1bb/ q+PnG2jFGeZ0X/foCBHBQ1PF98VrSwCbspniOehMRyku5lzZIA0mPtPahCTlgay8dT07 pWM0MzOPXvuCJvyUkDKpuNjURYf5ywtP6dubaqqY+fbilsLRM8Dn2RoOxofD2jH2TcwG T7VyFQxni8rXhFZyqL7uxhlhe+DTa78I0SC5lrN7cWItmYUY3ah33tj/lzg0g0EKKtC/ hVqQ== X-Gm-Message-State: AOAM531ex5ZOuKq7BWIoFHBsl0HSbit8LISEJmBLEYE3JkxiNkoeCvSR QoqxoTwDGdivf3BPCKHHBo4= X-Google-Smtp-Source: ABdhPJzQLr3slVx6P9rGKBRO6Z1L/UfXVkwFnZZYoGy4MSWTfhkB82YDTfnCzZbU0/6f7UzpkBAJ7A== X-Received: by 2002:a05:651c:54c:b0:249:9d06:24ef with SMTP id q12-20020a05651c054c00b002499d0624efmr5069689ljp.331.1650219680786; Sun, 17 Apr 2022 11:21:20 -0700 (PDT) Received: from [192.168.1.7] ([212.22.223.21]) by smtp.gmail.com with ESMTPSA id j17-20020a2e3c11000000b0024d5c9b8d8csm913188lja.67.2022.04.17.11.21.19 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Sun, 17 Apr 2022 11:21:20 -0700 (PDT) Subject: Re: [RFC PATCH 4/6] virtio: Various updates to xen-virtio DMA ops layer To: Stefano Stabellini Cc: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, Oleksandr Tyshchenko , Russell King , Boris Ostrovsky , Juergen Gross , Julien Grall , "Michael S. Tsirkin" , Christoph Hellwig References: <1649963973-22879-1-git-send-email-olekstysh@gmail.com> <1649963973-22879-5-git-send-email-olekstysh@gmail.com> From: Oleksandr Message-ID: <84f5264c-6b98-6d56-b7ca-61c19dc502ca@gmail.com> Date: Sun, 17 Apr 2022 21:21:19 +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:02, Stefano Stabellini wrote: Hello Stefano > On Thu, 14 Apr 2022, Oleksandr Tyshchenko wrote: >> From: Oleksandr Tyshchenko >> >> In the context of current patch do the following: >> 1. Update code to support virtio-mmio devices >> 2. Introduce struct xen_virtio_data and account passed virtio devices >> (using list) as we need to store some per-device data >> 3. Add multi-page support for xen_virtio_dma_map(unmap)_page callbacks >> 4. Harden code against malicious backend >> 5. Change to use alloc_pages_exact() instead of __get_free_pages() >> 6. Introduce locking scheme to protect mappings (I am not 100% sure >> whether per-device lock is really needed) >> 7. Handle virtio device's DMA mask >> 8. Retrieve the ID of backend domain from DT for virtio-mmio device >> instead of hardcoding it. >> >> Signed-off-by: Oleksandr Tyshchenko >> --- >> arch/arm/xen/enlighten.c | 11 +++ >> drivers/xen/Kconfig | 2 +- >> drivers/xen/xen-virtio.c | 200 ++++++++++++++++++++++++++++++++++++++++++----- >> include/xen/xen-ops.h | 5 ++ >> 4 files changed, 196 insertions(+), 22 deletions(-) >> >> diff --git a/arch/arm/xen/enlighten.c b/arch/arm/xen/enlighten.c >> index ec5b082..870d92f 100644 >> --- a/arch/arm/xen/enlighten.c >> +++ b/arch/arm/xen/enlighten.c >> @@ -409,6 +409,17 @@ int __init arch_xen_unpopulated_init(struct resource **res) >> } >> #endif >> >> +#ifdef CONFIG_ARCH_HAS_RESTRICTED_VIRTIO_MEMORY_ACCESS >> +int arch_has_restricted_virtio_memory_access(void) >> +{ >> + if (IS_ENABLED(CONFIG_XEN_HVM_VIRTIO_GRANT) && xen_hvm_domain()) >> + return 1; > Instead of xen_hvm_domain(), you can just use xen_domain(). Also there > is no need for the #ifdef > CONFIG_ARCH_HAS_RESTRICTED_VIRTIO_MEMORY_ACCESS, given that: > > CONFIG_XEN_HVM_VIRTIO_GRANT depends on XEN_VIRTIO which selects > ARCH_HAS_RESTRICTED_VIRTIO_MEMORY_ACCESS Yes, but please see my comments in commit #2 regarding CONFIG_XEN_HVM_VIRTIO_GRANT option and arch_has_restricted_virtio_memory_access() on Arm. I propose to have the following on Arm: int arch_has_restricted_virtio_memory_access(void) {      return xen_has_restricted_virtio_memory_access(); } where common xen.h contain a helper to be used by both Arm and x86: 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; } But I would be happy with what you propose as well. > > >> + return 0; >> +} >> +EXPORT_SYMBOL_GPL(arch_has_restricted_virtio_memory_access); >> +#endif >> + >> static void __init xen_dt_guest_init(void) >> { >> struct device_node *xen_node; >> diff --git a/drivers/xen/Kconfig b/drivers/xen/Kconfig >> index fc61f7a..56afe6a 100644 >> --- a/drivers/xen/Kconfig >> +++ b/drivers/xen/Kconfig >> @@ -347,7 +347,7 @@ config XEN_VIRTIO >> >> config XEN_HVM_VIRTIO_GRANT >> bool "Require virtio for fully virtualized guests to use grant mappings" >> - depends on XEN_VIRTIO && X86_64 >> + depends on XEN_VIRTIO && (X86_64 || ARM || ARM64) > you can remove the architectural dependencies According to the conversation in commit #2 we are considering just a single XEN_VIRTIO option, but it is going to has the same architectural dependencies: (X86_64 || ARM || ARM64) By removing the architectural dependencies here, we will leave also X86_32 covered (neither XEN_HVM_VIRTIO_GRANT nor XEN_PV_VIRTIO covered it). I don't know whether it is ok or not. Shall I remove dependencies anyway? > > >> default y >> help >> Require virtio for fully virtualized guests to use grant mappings. >> diff --git a/drivers/xen/xen-virtio.c b/drivers/xen/xen-virtio.c >> index cfd5eda..c5b2ec9 100644 >> --- a/drivers/xen/xen-virtio.c >> +++ b/drivers/xen/xen-virtio.c >> @@ -7,12 +7,26 @@ >> >> #include >> #include >> +#include >> #include >> #include >> #include >> #include >> #include >> >> +struct xen_virtio_data { >> + /* The ID of backend domain */ >> + domid_t dev_domid; >> + struct device *dev; >> + struct list_head list; >> + spinlock_t lock; >> + /* Is device behaving sane? */ >> + bool broken; > If you moved "broken" after "dev_domid" we would save a few bytes for > every allocation due to padding. ok, will do > > Is data->lock only there to protect accesses to "broken"? If so, we > might not need it, but I am not sure. Really good question, I introduced a lock for other purpose, I was thinking we needed to protect grants allocation and removing, but wasn't 100% sure about it (I wrote a remark in commit description). But looking into grant_table.c again I see that grant table code uses it's own lock, so looks like we don't need an extra lock here. I need to re-check regarding "broken", but likely we don't need here as well. If so, I will remove the lock. > > >> +}; >> + >> +static LIST_HEAD(xen_virtio_devices); >> +static DEFINE_SPINLOCK(xen_virtio_lock); >> + >> #define XEN_GRANT_ADDR_OFF 0x8000000000000000ULL >> >> static inline dma_addr_t grant_to_dma(grant_ref_t grant) >> @@ -25,6 +39,25 @@ static inline grant_ref_t dma_to_grant(dma_addr_t dma) >> return (grant_ref_t)((dma & ~XEN_GRANT_ADDR_OFF) >> PAGE_SHIFT); >> } >> >> +static struct xen_virtio_data *find_xen_virtio_data(struct device *dev) >> +{ >> + struct xen_virtio_data *data = NULL; >> + bool found = false; >> + >> + spin_lock(&xen_virtio_lock); >> + >> + list_for_each_entry( data, &xen_virtio_devices, list) { >> + if (data->dev == dev) { >> + found = true; >> + break; >> + } >> + } >> + >> + spin_unlock(&xen_virtio_lock); >> + >> + return found ? data : NULL; >> +} >> + >> /* >> * DMA ops for Xen virtio frontends. >> * >> @@ -43,48 +76,78 @@ 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; >> + struct xen_virtio_data *data; >> + unsigned int i, n_pages = PFN_UP(size); >> unsigned long pfn; >> grant_ref_t grant; >> - void *ret; >> + void *ret = NULL; >> >> - ret = (void *)__get_free_pages(gfp, get_order(size)); >> - if (!ret) >> + data = find_xen_virtio_data(dev); >> + if (!data) >> return NULL; >> >> + spin_lock(&data->lock); >> + >> + if (unlikely(data->broken)) >> + goto out; >> + >> + ret = alloc_pages_exact(n_pages * PAGE_SIZE, gfp); >> + if (!ret) >> + goto out; >> + >> pfn = virt_to_pfn(ret); >> >> if (gnttab_alloc_grant_reference_seq(n_pages, &grant)) { >> - free_pages((unsigned long)ret, get_order(size)); >> - return NULL; >> + free_pages_exact(ret, n_pages * PAGE_SIZE); >> + ret = NULL; >> + goto out; >> } >> >> for (i = 0; i < n_pages; i++) { >> - gnttab_grant_foreign_access_ref(grant + i, 0, >> + gnttab_grant_foreign_access_ref(grant + i, data->dev_domid, >> pfn_to_gfn(pfn + i), 0); >> } >> >> *dma_handle = grant_to_dma(grant); >> >> +out: >> + spin_unlock(&data->lock); >> + >> 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; >> + struct xen_virtio_data *data; >> + unsigned int i, n_pages = PFN_UP(size); >> grant_ref_t grant; >> >> + data = find_xen_virtio_data(dev); >> + if (!data) >> + return; >> + >> + spin_lock(&data->lock); >> + >> + if (unlikely(data->broken)) >> + goto out; >> + >> grant = dma_to_grant(dma_handle); >> >> - for (i = 0; i < n_pages; i++) >> - gnttab_end_foreign_access_ref(grant + i); >> + for (i = 0; i < n_pages; i++) { >> + if (unlikely(!gnttab_end_foreign_access_ref(grant + i))) { >> + dev_alert(dev, "Grant still in use by backend domain, disabled for further use\n"); >> + data->broken = true; >> + goto out; >> + } >> + } >> >> gnttab_free_grant_reference_seq(grant, n_pages); >> >> - free_pages((unsigned long)vaddr, get_order(size)); >> + free_pages_exact(vaddr, n_pages * PAGE_SIZE); >> + >> +out: >> + spin_unlock(&data->lock); >> } >> >> static struct page *xen_virtio_dma_alloc_pages(struct device *dev, size_t size, >> @@ -108,28 +171,71 @@ static dma_addr_t xen_virtio_dma_map_page(struct device *dev, struct page *page, >> enum dma_data_direction dir, >> unsigned long attrs) >> { >> + struct xen_virtio_data *data; >> + unsigned int i, n_pages = PFN_UP(size); >> grant_ref_t grant; >> + dma_addr_t dma_handle = DMA_MAPPING_ERROR; >> + >> + BUG_ON(dir == DMA_NONE); >> + >> + data = find_xen_virtio_data(dev); >> + if (!data) >> + return DMA_MAPPING_ERROR; >> + >> + spin_lock(&data->lock); >> >> - if (gnttab_alloc_grant_references(1, &grant)) >> - return 0; >> + if (unlikely(data->broken)) >> + goto out; >> >> - gnttab_grant_foreign_access_ref(grant, 0, xen_page_to_gfn(page), >> - dir == DMA_TO_DEVICE); >> + if (gnttab_alloc_grant_reference_seq(n_pages, &grant)) >> + goto out; >> >> - return grant_to_dma(grant) + offset; >> + for (i = 0; i < n_pages; i++) { >> + gnttab_grant_foreign_access_ref(grant + i, data->dev_domid, >> + xen_page_to_gfn(page) + i, dir == DMA_TO_DEVICE); >> + } >> + >> + dma_handle = grant_to_dma(grant) + offset; >> + >> +out: >> + spin_unlock(&data->lock); >> + >> + return dma_handle; >> } >> >> 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) >> { >> + struct xen_virtio_data *data; >> + unsigned int i, n_pages = PFN_UP(size); >> grant_ref_t grant; >> >> + BUG_ON(dir == DMA_NONE); >> + >> + data = find_xen_virtio_data(dev); >> + if (!data) >> + return; >> + >> + spin_lock(&data->lock); >> + >> + if (unlikely(data->broken)) >> + goto out; >> + >> grant = dma_to_grant(dma_handle); >> >> - gnttab_end_foreign_access_ref(grant); >> + for (i = 0; i < n_pages; i++) { >> + if (unlikely(!gnttab_end_foreign_access_ref(grant + i))) { >> + dev_alert(dev, "Grant still in use by backend domain, disabled for further use\n"); >> + data->broken = true; >> + goto out; >> + } >> + } >> + >> + gnttab_free_grant_reference_seq(grant, n_pages); >> >> - gnttab_free_grant_reference(grant); >> +out: >> + spin_unlock(&data->lock); >> } >> >> static int xen_virtio_dma_map_sg(struct device *dev, struct scatterlist *sg, >> @@ -149,7 +255,7 @@ static void xen_virtio_dma_unmap_sg(struct device *dev, struct scatterlist *sg, >> >> static int xen_virtio_dma_dma_supported(struct device *dev, u64 mask) >> { >> - return 1; >> + return mask == DMA_BIT_MASK(64); >> } >> >> static const struct dma_map_ops xen_virtio_dma_ops = { >> @@ -166,9 +272,61 @@ static const struct dma_map_ops xen_virtio_dma_ops = { >> .dma_supported = xen_virtio_dma_dma_supported, >> }; >> >> +bool xen_is_virtio_device(struct device *dev) >> +{ >> + /* XXX Handle only DT devices for now */ >> + if (!dev->of_node) >> + return false; >> + >> + if (!of_device_is_compatible(dev->of_node, "virtio,mmio")) >> + return false; >> + >> + return of_property_read_bool(dev->of_node, "xen,dev-domid"); >> +} >> +EXPORT_SYMBOL_GPL(xen_is_virtio_device); >> + >> void xen_virtio_setup_dma_ops(struct device *dev) >> { >> + struct xen_virtio_data *data; >> + uint32_t dev_domid; >> + >> + data = find_xen_virtio_data(dev); >> + if (data) { >> + dev_err(dev, "xen_virtio data is already created\n"); >> + return; >> + } >> + >> + if (dev_is_pci(dev)) { >> + /* XXX Leave it hard wired to dom0 for now */ >> + dev_domid = 0; >> + } else if (dev->of_node) { >> + if (of_property_read_u32(dev->of_node, "xen,dev-domid", &dev_domid)) { >> + dev_err(dev, "xen,dev-domid property is not present\n"); >> + goto err; >> + } >> + } else >> + /* The ACPI case is not supported */ >> + goto err; > If we get here, it means that xen_is_virtio_device returned true, so the > PCI case is actually impossible? Good catch, thank you. Yes, it is impossible on Arm for now (with changes in commit #6). > > I would rewrite these checks like this: > > /* XXX: ACPI and PCI unsupported for now */ > if (dev_is_pci(dev) || !dev->of_node) { > goto err; > } > if (of_property_read_u32(dev->of_node, "xen,dev-domid", &dev_domid)) { > dev_err(dev, "xen,dev-domid property is not present\n"); > goto err; > } ok, will do > > > >> + data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); >> + if (!data) { >> + dev_err(dev, "Сannot allocate xen_virtio data\n"); >> + goto err; >> + } >> + data->dev_domid = dev_domid; >> + data->dev = dev; >> + spin_lock_init(&data->lock); >> + >> + spin_lock(&xen_virtio_lock); >> + list_add(&data->list, &xen_virtio_devices); >> + spin_unlock(&xen_virtio_lock); >> + >> dev->dma_ops = &xen_virtio_dma_ops; >> + >> + return; >> + >> +err: >> + dev_err(dev, "Сannot set up xen_virtio DMA ops, retain platform DMA ops\n"); >> } >> EXPORT_SYMBOL_GPL(xen_virtio_setup_dma_ops); >> >> diff --git a/include/xen/xen-ops.h b/include/xen/xen-ops.h >> index ae3c1bc..fdbcb99 100644 >> --- a/include/xen/xen-ops.h >> +++ b/include/xen/xen-ops.h >> @@ -223,10 +223,15 @@ static inline void xen_preemptible_hcall_end(void) { } >> >> #ifdef CONFIG_XEN_VIRTIO >> void xen_virtio_setup_dma_ops(struct device *dev); >> +bool xen_is_virtio_device(struct device *dev); >> #else >> static inline void xen_virtio_setup_dma_ops(struct device *dev) >> { >> } >> +static inline bool xen_is_virtio_device(struct device *dev) >> +{ >> + return false; >> +} >> #endif /* CONFIG_XEN_VIRTIO */ >> >> #endif /* INCLUDE_XEN_OPS_H */ -- 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 A5F1FC433F5 for ; Sun, 17 Apr 2022 18:22:34 +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=VOoc3yYG7q9S7lbEq8pLWmu7phajGD+rXiuCx7gkizU=; b=13vsU0l7o6pgiIIaafd1fjju1/ DDvHV4Z1Pkyu9KsfSyJH/Xrl/3QhjXhQEwxTdRvDpo8w7GDVHiqtysPdjmuQsUszZPJOywC8CuazY 89tSXs30EJZroIZef0ERPnmSIiF7+Cjo8GPcPyKXBxrVl1d6YCStk7bAPEkmid3wPwzefFsri4BCj 4HjiezEzMNnyUF0ylggacYE6BWvEn4B4gn0Yf3AMuUL3hprbg17x6ZpHJJ77uXW930SiqNCUV1+fR bYpjoSKrYlD8PMh6a5P+sjGcSxyBC+QPBz49Yn4xWKfgYgUqGl1uwBT4ivpJeYkDIPM6J5nE+/mlM WJCgF5cA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1ng9WY-00EnA7-Sg; Sun, 17 Apr 2022 18:21:27 +0000 Received: from mail-lj1-x232.google.com ([2a00:1450:4864:20::232]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1ng9WV-00En9B-3a for linux-arm-kernel@lists.infradead.org; Sun, 17 Apr 2022 18:21:25 +0000 Received: by mail-lj1-x232.google.com with SMTP id o16so14741888ljp.3 for ; Sun, 17 Apr 2022 11:21:22 -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=HOTM5tpBYxAb1qtW2MCOB1TQN7ARlsIhllyek+NnKb0=; b=klCT/uoPzTl1EgjzQV3oH8Ani6TzcUI1aYpYynSRvEWYqqRCk3Jj1LNk9ZktsbF/i0 n79fletwteCSJ30Z6u4+dfPXavKY08Xjlm1NUblBXiD8OA12dG6srB9dGE4bVEElY6g9 4K8EhnEM8U1dhftqZ1vSaxBWtKzg9B7x69yu8AYA9Mue/OVMjGlby7Ap+keAnbYqbh5U ub6OC4DabnVDsPmAtDwGqfRCBpkvrzHF1wOACQujG7M5asYiz+MCzcYR2kWvwu2cd9lz NeeXAttlwuEvJoxWGwiGpaucZkJrCsbhO9PFumUrgQ8VQLHuB4JwS6zWIvO8/Ah12NSu x50A== 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=HOTM5tpBYxAb1qtW2MCOB1TQN7ARlsIhllyek+NnKb0=; b=pLfB3eunJ1x6+9Z0Cgj+zEyNA2GjVhGQ+x6YinRD7G2RWGSPfG9GaQ0bc7XK403vLq cwi9s/GAlrCzX4nJGx/+H1OLuq3IapIySl53+OM3owtKWsrSqN3WEIhw8odG3nswiwQ3 l5fJYxfqJfFGGpvxfVVvmyOHFScDKUvA8Wibfw6GTiwBo3BfkWH0XX97wPQLkJ3CL9/C N9golVu8rCymc9OizqTsUq9Eg5IUTFzp208ZJB4uaf8ZjCzqBo7fWZ3q+ihDaLbc8ZhS w6w5a8VNVwcOTZGZzgnw7CRnKIkSgobyIeFnwLviHJv4exll1pOqLJGiiRuVSIz5ECUw tDtQ== X-Gm-Message-State: AOAM533rhnqaPWj6MtjTMFTWrCiTcc6Ky3+s4BCcQCLvu772vWtO7Pf1 Jx0VTHzFNYi2PT5Oi5TX+SYwgm0hSXA= X-Google-Smtp-Source: ABdhPJzQLr3slVx6P9rGKBRO6Z1L/UfXVkwFnZZYoGy4MSWTfhkB82YDTfnCzZbU0/6f7UzpkBAJ7A== X-Received: by 2002:a05:651c:54c:b0:249:9d06:24ef with SMTP id q12-20020a05651c054c00b002499d0624efmr5069689ljp.331.1650219680786; Sun, 17 Apr 2022 11:21:20 -0700 (PDT) Received: from [192.168.1.7] ([212.22.223.21]) by smtp.gmail.com with ESMTPSA id j17-20020a2e3c11000000b0024d5c9b8d8csm913188lja.67.2022.04.17.11.21.19 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Sun, 17 Apr 2022 11:21:20 -0700 (PDT) Subject: Re: [RFC PATCH 4/6] virtio: Various updates to xen-virtio DMA ops layer To: Stefano Stabellini Cc: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, Oleksandr Tyshchenko , Russell King , Boris Ostrovsky , Juergen Gross , Julien Grall , "Michael S. Tsirkin" , Christoph Hellwig References: <1649963973-22879-1-git-send-email-olekstysh@gmail.com> <1649963973-22879-5-git-send-email-olekstysh@gmail.com> From: Oleksandr Message-ID: <84f5264c-6b98-6d56-b7ca-61c19dc502ca@gmail.com> Date: Sun, 17 Apr 2022 21:21:19 +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_112123_195309_0C167320 X-CRM114-Status: GOOD ( 38.89 ) 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 Ck9uIDE2LjA0LjIyIDAxOjAyLCBTdGVmYW5vIFN0YWJlbGxpbmkgd3JvdGU6CgpIZWxsbyBTdGVm YW5vCgoKPiBPbiBUaHUsIDE0IEFwciAyMDIyLCBPbGVrc2FuZHIgVHlzaGNoZW5rbyB3cm90ZToK Pj4gRnJvbTogT2xla3NhbmRyIFR5c2hjaGVua28gPG9sZWtzYW5kcl90eXNoY2hlbmtvQGVwYW0u Y29tPgo+Pgo+PiBJbiB0aGUgY29udGV4dCBvZiBjdXJyZW50IHBhdGNoIGRvIHRoZSBmb2xsb3dp bmc6Cj4+IDEuIFVwZGF0ZSBjb2RlIHRvIHN1cHBvcnQgdmlydGlvLW1taW8gZGV2aWNlcwo+PiAy LiBJbnRyb2R1Y2Ugc3RydWN0IHhlbl92aXJ0aW9fZGF0YSBhbmQgYWNjb3VudCBwYXNzZWQgdmly dGlvIGRldmljZXMKPj4gICAgICh1c2luZyBsaXN0KSBhcyB3ZSBuZWVkIHRvIHN0b3JlIHNvbWUg cGVyLWRldmljZSBkYXRhCj4+IDMuIEFkZCBtdWx0aS1wYWdlIHN1cHBvcnQgZm9yIHhlbl92aXJ0 aW9fZG1hX21hcCh1bm1hcClfcGFnZSBjYWxsYmFja3MKPj4gNC4gSGFyZGVuIGNvZGUgYWdhaW5z dCBtYWxpY2lvdXMgYmFja2VuZAo+PiA1LiBDaGFuZ2UgdG8gdXNlIGFsbG9jX3BhZ2VzX2V4YWN0 KCkgaW5zdGVhZCBvZiBfX2dldF9mcmVlX3BhZ2VzKCkKPj4gNi4gSW50cm9kdWNlIGxvY2tpbmcg c2NoZW1lIHRvIHByb3RlY3QgbWFwcGluZ3MgKEkgYW0gbm90IDEwMCUgc3VyZQo+PiAgICAgd2hl dGhlciBwZXItZGV2aWNlIGxvY2sgaXMgcmVhbGx5IG5lZWRlZCkKPj4gNy4gSGFuZGxlIHZpcnRp byBkZXZpY2UncyBETUEgbWFzawo+PiA4LiBSZXRyaWV2ZSB0aGUgSUQgb2YgYmFja2VuZCBkb21h aW4gZnJvbSBEVCBmb3IgdmlydGlvLW1taW8gZGV2aWNlCj4+ICAgICBpbnN0ZWFkIG9mIGhhcmRj b2RpbmcgaXQuCj4+Cj4+IFNpZ25lZC1vZmYtYnk6IE9sZWtzYW5kciBUeXNoY2hlbmtvIDxvbGVr c2FuZHJfdHlzaGNoZW5rb0BlcGFtLmNvbT4KPj4gLS0tCj4+ICAgYXJjaC9hcm0veGVuL2VubGln aHRlbi5jIHwgIDExICsrKwo+PiAgIGRyaXZlcnMveGVuL0tjb25maWcgICAgICB8ICAgMiArLQo+ PiAgIGRyaXZlcnMveGVuL3hlbi12aXJ0aW8uYyB8IDIwMCArKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKystLS0tLQo+PiAgIGluY2x1ZGUveGVuL3hlbi1vcHMuaCAgICB8 ICAgNSArKwo+PiAgIDQgZmlsZXMgY2hhbmdlZCwgMTk2IGluc2VydGlvbnMoKyksIDIyIGRlbGV0 aW9ucygtKQo+Pgo+PiBkaWZmIC0tZ2l0IGEvYXJjaC9hcm0veGVuL2VubGlnaHRlbi5jIGIvYXJj aC9hcm0veGVuL2VubGlnaHRlbi5jCj4+IGluZGV4IGVjNWIwODIuLjg3MGQ5MmYgMTAwNjQ0Cj4+ IC0tLSBhL2FyY2gvYXJtL3hlbi9lbmxpZ2h0ZW4uYwo+PiArKysgYi9hcmNoL2FybS94ZW4vZW5s aWdodGVuLmMKPj4gQEAgLTQwOSw2ICs0MDksMTcgQEAgaW50IF9faW5pdCBhcmNoX3hlbl91bnBv cHVsYXRlZF9pbml0KHN0cnVjdCByZXNvdXJjZSAqKnJlcykKPj4gICB9Cj4+ICAgI2VuZGlmCj4+ ICAgCj4+ICsjaWZkZWYgQ09ORklHX0FSQ0hfSEFTX1JFU1RSSUNURURfVklSVElPX01FTU9SWV9B Q0NFU1MKPj4gK2ludCBhcmNoX2hhc19yZXN0cmljdGVkX3ZpcnRpb19tZW1vcnlfYWNjZXNzKHZv aWQpCj4+ICt7Cj4+ICsJaWYgKElTX0VOQUJMRUQoQ09ORklHX1hFTl9IVk1fVklSVElPX0dSQU5U KSAmJiB4ZW5faHZtX2RvbWFpbigpKQo+PiArCQlyZXR1cm4gMTsKPiBJbnN0ZWFkIG9mIHhlbl9o dm1fZG9tYWluKCksIHlvdSBjYW4ganVzdCB1c2UgeGVuX2RvbWFpbigpLiBBbHNvIHRoZXJlCj4g aXMgbm8gbmVlZCBmb3IgdGhlICNpZmRlZgo+IENPTkZJR19BUkNIX0hBU19SRVNUUklDVEVEX1ZJ UlRJT19NRU1PUllfQUNDRVNTLCBnaXZlbiB0aGF0Ogo+Cj4gQ09ORklHX1hFTl9IVk1fVklSVElP X0dSQU5UIGRlcGVuZHMgb24gWEVOX1ZJUlRJTyB3aGljaCBzZWxlY3RzCj4gQVJDSF9IQVNfUkVT VFJJQ1RFRF9WSVJUSU9fTUVNT1JZX0FDQ0VTUwoKClllcywgYnV0IHBsZWFzZSBzZWUgbXkgY29t bWVudHMgaW4gY29tbWl0ICMyIHJlZ2FyZGluZyAKQ09ORklHX1hFTl9IVk1fVklSVElPX0dSQU5U IG9wdGlvbiBhbmQgCmFyY2hfaGFzX3Jlc3RyaWN0ZWRfdmlydGlvX21lbW9yeV9hY2Nlc3MoKSBv biBBcm0uCgpJIHByb3Bvc2UgdG8gaGF2ZSB0aGUgZm9sbG93aW5nIG9uIEFybToKCmludCBhcmNo X2hhc19yZXN0cmljdGVkX3ZpcnRpb19tZW1vcnlfYWNjZXNzKHZvaWQpCnsKIMKgwqDCoMKgIHJl dHVybiB4ZW5faGFzX3Jlc3RyaWN0ZWRfdmlydGlvX21lbW9yeV9hY2Nlc3MoKTsKfQoKCndoZXJl IGNvbW1vbiB4ZW4uaCBjb250YWluIGEgaGVscGVyIHRvIGJlIHVzZWQgYnkgYm90aCBBcm0gYW5k IHg4NjoKCnN0YXRpYyBpbmxpbmUgaW50IHhlbl9oYXNfcmVzdHJpY3RlZF92aXJ0aW9fbWVtb3J5 X2FjY2Vzcyh2b2lkKQp7CiDCoMKgwqDCoCBpZiAoSVNfRU5BQkxFRChDT05GSUdfWEVOX1ZJUlRJ TykgJiYgKHhlbl9wdl9kb21haW4oKSB8fCAKeGVuX2h2bV9kb21haW4oKSkpCiDCoMKgwqDCoMKg wqDCoMKgIHJldHVybiAxOwoKIMKgwqDCoMKgIHJldHVybiAwOwp9CgoKQnV0IEkgd291bGQgYmUg aGFwcHkgd2l0aCB3aGF0IHlvdSBwcm9wb3NlIGFzIHdlbGwuCgoKPgo+Cj4+ICsJcmV0dXJuIDA7 Cj4+ICt9Cj4+ICtFWFBPUlRfU1lNQk9MX0dQTChhcmNoX2hhc19yZXN0cmljdGVkX3ZpcnRpb19t ZW1vcnlfYWNjZXNzKTsKPj4gKyNlbmRpZgo+PiArCj4+ICAgc3RhdGljIHZvaWQgX19pbml0IHhl bl9kdF9ndWVzdF9pbml0KHZvaWQpCj4+ICAgewo+PiAgIAlzdHJ1Y3QgZGV2aWNlX25vZGUgKnhl bl9ub2RlOwo+PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vS2NvbmZpZyBiL2RyaXZlcnMveGVu L0tjb25maWcKPj4gaW5kZXggZmM2MWY3YS4uNTZhZmU2YSAxMDA2NDQKPj4gLS0tIGEvZHJpdmVy cy94ZW4vS2NvbmZpZwo+PiArKysgYi9kcml2ZXJzL3hlbi9LY29uZmlnCj4+IEBAIC0zNDcsNyAr MzQ3LDcgQEAgY29uZmlnIFhFTl9WSVJUSU8KPj4gICAKPj4gICBjb25maWcgWEVOX0hWTV9WSVJU SU9fR1JBTlQKPj4gICAJYm9vbCAiUmVxdWlyZSB2aXJ0aW8gZm9yIGZ1bGx5IHZpcnR1YWxpemVk IGd1ZXN0cyB0byB1c2UgZ3JhbnQgbWFwcGluZ3MiCj4+IC0JZGVwZW5kcyBvbiBYRU5fVklSVElP ICYmIFg4Nl82NAo+PiArCWRlcGVuZHMgb24gWEVOX1ZJUlRJTyAmJiAoWDg2XzY0IHx8IEFSTSB8 fCBBUk02NCkKPiB5b3UgY2FuIHJlbW92ZSB0aGUgYXJjaGl0ZWN0dXJhbCBkZXBlbmRlbmNpZXMK CgpBY2NvcmRpbmcgdG8gdGhlIGNvbnZlcnNhdGlvbiBpbiBjb21taXQgIzIgd2UgYXJlIGNvbnNp ZGVyaW5nIGp1c3QgYSAKc2luZ2xlIFhFTl9WSVJUSU8gb3B0aW9uLCBidXQgaXQgaXMgZ29pbmcg dG8gaGFzIHRoZQpzYW1lIGFyY2hpdGVjdHVyYWwgZGVwZW5kZW5jaWVzOiAoWDg2XzY0IHx8IEFS TSB8fCBBUk02NCkKCkJ5IHJlbW92aW5nIHRoZSBhcmNoaXRlY3R1cmFsIGRlcGVuZGVuY2llcyBo ZXJlLCB3ZSB3aWxsIGxlYXZlIGFsc28gClg4Nl8zMiBjb3ZlcmVkIChuZWl0aGVyIFhFTl9IVk1f VklSVElPX0dSQU5UIG5vciBYRU5fUFZfVklSVElPIGNvdmVyZWQgCml0KS4gSSBkb24ndCBrbm93 IHdoZXRoZXIgaXQgaXMgb2sgb3Igbm90LgoKU2hhbGwgSSByZW1vdmUgZGVwZW5kZW5jaWVzIGFu eXdheT8KCgo+Cj4KPj4gICAJZGVmYXVsdCB5Cj4+ICAgCWhlbHAKPj4gICAJICBSZXF1aXJlIHZp cnRpbyBmb3IgZnVsbHkgdmlydHVhbGl6ZWQgZ3Vlc3RzIHRvIHVzZSBncmFudCBtYXBwaW5ncy4K Pj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL3hlbi12aXJ0aW8uYyBiL2RyaXZlcnMveGVuL3hl bi12aXJ0aW8uYwo+PiBpbmRleCBjZmQ1ZWRhLi5jNWIyZWM5IDEwMDY0NAo+PiAtLS0gYS9kcml2 ZXJzL3hlbi94ZW4tdmlydGlvLmMKPj4gKysrIGIvZHJpdmVycy94ZW4veGVuLXZpcnRpby5jCj4+ IEBAIC03LDEyICs3LDI2IEBACj4+ICAgCj4+ICAgI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgo+ PiAgICNpbmNsdWRlIDxsaW51eC9kbWEtbWFwLW9wcy5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L29m Lmg+Cj4+ICAgI2luY2x1ZGUgPGxpbnV4L3BjaS5oPgo+PiAgICNpbmNsdWRlIDxsaW51eC9wZm4u aD4KPj4gICAjaW5jbHVkZSA8bGludXgvdmlydGlvX2NvbmZpZy5oPgo+PiAgICNpbmNsdWRlIDx4 ZW4veGVuLmg+Cj4+ICAgI2luY2x1ZGUgPHhlbi9ncmFudF90YWJsZS5oPgo+PiAgIAo+PiArc3Ry dWN0IHhlbl92aXJ0aW9fZGF0YSB7Cj4+ICsJLyogVGhlIElEIG9mIGJhY2tlbmQgZG9tYWluICov Cj4+ICsJZG9taWRfdCBkZXZfZG9taWQ7Cj4+ICsJc3RydWN0IGRldmljZSAqZGV2Owo+PiArCXN0 cnVjdCBsaXN0X2hlYWQgbGlzdDsKPj4gKwlzcGlubG9ja190IGxvY2s7Cj4+ICsJLyogSXMgZGV2 aWNlIGJlaGF2aW5nIHNhbmU/ICovCj4+ICsJYm9vbCBicm9rZW47Cj4gSWYgeW91IG1vdmVkICJi cm9rZW4iIGFmdGVyICJkZXZfZG9taWQiIHdlIHdvdWxkIHNhdmUgYSBmZXcgYnl0ZXMgZm9yCj4g ZXZlcnkgYWxsb2NhdGlvbiBkdWUgdG8gcGFkZGluZy4KCm9rLCB3aWxsIGRvCgoKPgo+IElzIGRh dGEtPmxvY2sgb25seSB0aGVyZSB0byBwcm90ZWN0IGFjY2Vzc2VzIHRvICJicm9rZW4iPyBJZiBz bywgd2UKPiBtaWdodCBub3QgbmVlZCBpdCwgYnV0IEkgYW0gbm90IHN1cmUuCgoKUmVhbGx5IGdv b2QgcXVlc3Rpb24sIEkgaW50cm9kdWNlZCBhIGxvY2sgZm9yIG90aGVyIHB1cnBvc2UsIEkgd2Fz IAp0aGlua2luZyB3ZSBuZWVkZWQgdG8gcHJvdGVjdCBncmFudHMgYWxsb2NhdGlvbiBhbmQgcmVt b3ZpbmcsIGJ1dCB3YXNuJ3QgCjEwMCUgc3VyZSBhYm91dCBpdCAoSSB3cm90ZSBhIHJlbWFyayBp biBjb21taXQgZGVzY3JpcHRpb24pLiBCdXQgbG9va2luZyAKaW50byBncmFudF90YWJsZS5jIGFn YWluIEkgc2VlIHRoYXQgZ3JhbnQgdGFibGUgY29kZSB1c2VzIGl0J3Mgb3duIGxvY2ssIApzbyBs b29rcyBsaWtlIHdlIGRvbid0IG5lZWQgYW4gZXh0cmEgbG9jayBoZXJlLiBJIG5lZWQgdG8gcmUt Y2hlY2sgCnJlZ2FyZGluZyAiYnJva2VuIiwgYnV0IGxpa2VseSB3ZSBkb24ndCBuZWVkIGhlcmUg YXMgd2VsbC4gSWYgc28sIEkgd2lsbCAKcmVtb3ZlIHRoZSBsb2NrLgoKCj4KPgo+PiArfTsKPj4g Kwo+PiArc3RhdGljIExJU1RfSEVBRCh4ZW5fdmlydGlvX2RldmljZXMpOwo+PiArc3RhdGljIERF RklORV9TUElOTE9DSyh4ZW5fdmlydGlvX2xvY2spOwo+PiArCj4+ICAgI2RlZmluZSBYRU5fR1JB TlRfQUREUl9PRkYJMHg4MDAwMDAwMDAwMDAwMDAwVUxMCj4+ICAgCj4+ICAgc3RhdGljIGlubGlu ZSBkbWFfYWRkcl90IGdyYW50X3RvX2RtYShncmFudF9yZWZfdCBncmFudCkKPj4gQEAgLTI1LDYg KzM5LDI1IEBAIHN0YXRpYyBpbmxpbmUgZ3JhbnRfcmVmX3QgZG1hX3RvX2dyYW50KGRtYV9hZGRy X3QgZG1hKQo+PiAgIAlyZXR1cm4gKGdyYW50X3JlZl90KSgoZG1hICYgflhFTl9HUkFOVF9BRERS X09GRikgPj4gUEFHRV9TSElGVCk7Cj4+ICAgfQo+PiAgIAo+PiArc3RhdGljIHN0cnVjdCB4ZW5f dmlydGlvX2RhdGEgKmZpbmRfeGVuX3ZpcnRpb19kYXRhKHN0cnVjdCBkZXZpY2UgKmRldikKPj4g K3sKPj4gKwlzdHJ1Y3QgeGVuX3ZpcnRpb19kYXRhICpkYXRhID0gTlVMTDsKPj4gKwlib29sIGZv dW5kID0gZmFsc2U7Cj4+ICsKPj4gKwlzcGluX2xvY2soJnhlbl92aXJ0aW9fbG9jayk7Cj4+ICsK Pj4gKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KCBkYXRhLCAmeGVuX3ZpcnRpb19kZXZpY2VzLCBsaXN0 KSB7Cj4+ICsJCWlmIChkYXRhLT5kZXYgPT0gZGV2KSB7Cj4+ICsJCQlmb3VuZCA9IHRydWU7Cj4+ ICsJCQlicmVhazsKPj4gKwkJfQo+PiArCX0KPj4gKwo+PiArCXNwaW5fdW5sb2NrKCZ4ZW5fdmly dGlvX2xvY2spOwo+PiArCj4+ICsJcmV0dXJuIGZvdW5kID8gZGF0YSA6IE5VTEw7Cj4+ICt9Cj4+ ICsKPj4gICAvKgo+PiAgICAqIERNQSBvcHMgZm9yIFhlbiB2aXJ0aW8gZnJvbnRlbmRzLgo+PiAg ICAqCj4+IEBAIC00Myw0OCArNzYsNzggQEAgc3RhdGljIHZvaWQgKnhlbl92aXJ0aW9fZG1hX2Fs bG9jKHN0cnVjdCBkZXZpY2UgKmRldiwgc2l6ZV90IHNpemUsCj4+ICAgCQkJCSAgZG1hX2FkZHJf dCAqZG1hX2hhbmRsZSwgZ2ZwX3QgZ2ZwLAo+PiAgIAkJCQkgIHVuc2lnbmVkIGxvbmcgYXR0cnMp Cj4+ICAgewo+PiAtCXVuc2lnbmVkIGludCBuX3BhZ2VzID0gUEZOX1VQKHNpemUpOwo+PiAtCXVu c2lnbmVkIGludCBpOwo+PiArCXN0cnVjdCB4ZW5fdmlydGlvX2RhdGEgKmRhdGE7Cj4+ICsJdW5z aWduZWQgaW50IGksIG5fcGFnZXMgPSBQRk5fVVAoc2l6ZSk7Cj4+ICAgCXVuc2lnbmVkIGxvbmcg cGZuOwo+PiAgIAlncmFudF9yZWZfdCBncmFudDsKPj4gLQl2b2lkICpyZXQ7Cj4+ICsJdm9pZCAq cmV0ID0gTlVMTDsKPj4gICAKPj4gLQlyZXQgPSAodm9pZCAqKV9fZ2V0X2ZyZWVfcGFnZXMoZ2Zw LCBnZXRfb3JkZXIoc2l6ZSkpOwo+PiAtCWlmICghcmV0KQo+PiArCWRhdGEgPSBmaW5kX3hlbl92 aXJ0aW9fZGF0YShkZXYpOwo+PiArCWlmICghZGF0YSkKPj4gICAJCXJldHVybiBOVUxMOwo+PiAg IAo+PiArCXNwaW5fbG9jaygmZGF0YS0+bG9jayk7Cj4+ICsKPj4gKwlpZiAodW5saWtlbHkoZGF0 YS0+YnJva2VuKSkKPj4gKwkJZ290byBvdXQ7Cj4+ICsKPj4gKwlyZXQgPSBhbGxvY19wYWdlc19l eGFjdChuX3BhZ2VzICogUEFHRV9TSVpFLCBnZnApOwo+PiArCWlmICghcmV0KQo+PiArCQlnb3Rv IG91dDsKPj4gKwo+PiAgIAlwZm4gPSB2aXJ0X3RvX3BmbihyZXQpOwo+PiAgIAo+PiAgIAlpZiAo Z250dGFiX2FsbG9jX2dyYW50X3JlZmVyZW5jZV9zZXEobl9wYWdlcywgJmdyYW50KSkgewo+PiAt CQlmcmVlX3BhZ2VzKCh1bnNpZ25lZCBsb25nKXJldCwgZ2V0X29yZGVyKHNpemUpKTsKPj4gLQkJ cmV0dXJuIE5VTEw7Cj4+ICsJCWZyZWVfcGFnZXNfZXhhY3QocmV0LCBuX3BhZ2VzICogUEFHRV9T SVpFKTsKPj4gKwkJcmV0ID0gTlVMTDsKPj4gKwkJZ290byBvdXQ7Cj4+ICAgCX0KPj4gICAKPj4g ICAJZm9yIChpID0gMDsgaSA8IG5fcGFnZXM7IGkrKykgewo+PiAtCQlnbnR0YWJfZ3JhbnRfZm9y ZWlnbl9hY2Nlc3NfcmVmKGdyYW50ICsgaSwgMCwKPj4gKwkJZ250dGFiX2dyYW50X2ZvcmVpZ25f YWNjZXNzX3JlZihncmFudCArIGksIGRhdGEtPmRldl9kb21pZCwKPj4gICAJCQkJCQlwZm5fdG9f Z2ZuKHBmbiArIGkpLCAwKTsKPj4gICAJfQo+PiAgIAo+PiAgIAkqZG1hX2hhbmRsZSA9IGdyYW50 X3RvX2RtYShncmFudCk7Cj4+ICAgCj4+ICtvdXQ6Cj4+ICsJc3Bpbl91bmxvY2soJmRhdGEtPmxv Y2spOwo+PiArCj4+ICAgCXJldHVybiByZXQ7Cj4+ICAgfQo+PiAgIAo+PiAgIHN0YXRpYyB2b2lk IHhlbl92aXJ0aW9fZG1hX2ZyZWUoc3RydWN0IGRldmljZSAqZGV2LCBzaXplX3Qgc2l6ZSwgdm9p ZCAqdmFkZHIsCj4+ICAgCQkJCWRtYV9hZGRyX3QgZG1hX2hhbmRsZSwgdW5zaWduZWQgbG9uZyBh dHRycykKPj4gICB7Cj4+IC0JdW5zaWduZWQgaW50IG5fcGFnZXMgPSBQRk5fVVAoc2l6ZSk7Cj4+ IC0JdW5zaWduZWQgaW50IGk7Cj4+ICsJc3RydWN0IHhlbl92aXJ0aW9fZGF0YSAqZGF0YTsKPj4g Kwl1bnNpZ25lZCBpbnQgaSwgbl9wYWdlcyA9IFBGTl9VUChzaXplKTsKPj4gICAJZ3JhbnRfcmVm X3QgZ3JhbnQ7Cj4+ICAgCj4+ICsJZGF0YSA9IGZpbmRfeGVuX3ZpcnRpb19kYXRhKGRldik7Cj4+ ICsJaWYgKCFkYXRhKQo+PiArCQlyZXR1cm47Cj4+ICsKPj4gKwlzcGluX2xvY2soJmRhdGEtPmxv Y2spOwo+PiArCj4+ICsJaWYgKHVubGlrZWx5KGRhdGEtPmJyb2tlbikpCj4+ICsJCWdvdG8gb3V0 Owo+PiArCj4+ICAgCWdyYW50ID0gZG1hX3RvX2dyYW50KGRtYV9oYW5kbGUpOwo+PiAgIAo+PiAt CWZvciAoaSA9IDA7IGkgPCBuX3BhZ2VzOyBpKyspCj4+IC0JCWdudHRhYl9lbmRfZm9yZWlnbl9h Y2Nlc3NfcmVmKGdyYW50ICsgaSk7Cj4+ICsJZm9yIChpID0gMDsgaSA8IG5fcGFnZXM7IGkrKykg ewo+PiArCQlpZiAodW5saWtlbHkoIWdudHRhYl9lbmRfZm9yZWlnbl9hY2Nlc3NfcmVmKGdyYW50 ICsgaSkpKSB7Cj4+ICsJCQlkZXZfYWxlcnQoZGV2LCAiR3JhbnQgc3RpbGwgaW4gdXNlIGJ5IGJh Y2tlbmQgZG9tYWluLCBkaXNhYmxlZCBmb3IgZnVydGhlciB1c2VcbiIpOwo+PiArCQkJZGF0YS0+ YnJva2VuID0gdHJ1ZTsKPj4gKwkJCWdvdG8gb3V0Owo+PiArCQl9Cj4+ICsJfQo+PiAgIAo+PiAg IAlnbnR0YWJfZnJlZV9ncmFudF9yZWZlcmVuY2Vfc2VxKGdyYW50LCBuX3BhZ2VzKTsKPj4gICAK Pj4gLQlmcmVlX3BhZ2VzKCh1bnNpZ25lZCBsb25nKXZhZGRyLCBnZXRfb3JkZXIoc2l6ZSkpOwo+ PiArCWZyZWVfcGFnZXNfZXhhY3QodmFkZHIsIG5fcGFnZXMgKiBQQUdFX1NJWkUpOwo+PiArCj4+ ICtvdXQ6Cj4+ICsJc3Bpbl91bmxvY2soJmRhdGEtPmxvY2spOwo+PiAgIH0KPj4gICAKPj4gICBz dGF0aWMgc3RydWN0IHBhZ2UgKnhlbl92aXJ0aW9fZG1hX2FsbG9jX3BhZ2VzKHN0cnVjdCBkZXZp Y2UgKmRldiwgc2l6ZV90IHNpemUsCj4+IEBAIC0xMDgsMjggKzE3MSw3MSBAQCBzdGF0aWMgZG1h X2FkZHJfdCB4ZW5fdmlydGlvX2RtYV9tYXBfcGFnZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVj dCBwYWdlICpwYWdlLAo+PiAgIAkJCQkJICBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXIsCj4+ ICAgCQkJCQkgIHVuc2lnbmVkIGxvbmcgYXR0cnMpCj4+ICAgewo+PiArCXN0cnVjdCB4ZW5fdmly dGlvX2RhdGEgKmRhdGE7Cj4+ICsJdW5zaWduZWQgaW50IGksIG5fcGFnZXMgPSBQRk5fVVAoc2l6 ZSk7Cj4+ICAgCWdyYW50X3JlZl90IGdyYW50Owo+PiArCWRtYV9hZGRyX3QgZG1hX2hhbmRsZSA9 IERNQV9NQVBQSU5HX0VSUk9SOwo+PiArCj4+ICsJQlVHX09OKGRpciA9PSBETUFfTk9ORSk7Cj4+ ICsKPj4gKwlkYXRhID0gZmluZF94ZW5fdmlydGlvX2RhdGEoZGV2KTsKPj4gKwlpZiAoIWRhdGEp Cj4+ICsJCXJldHVybiBETUFfTUFQUElOR19FUlJPUjsKPj4gKwo+PiArCXNwaW5fbG9jaygmZGF0 YS0+bG9jayk7Cj4+ICAgCj4+IC0JaWYgKGdudHRhYl9hbGxvY19ncmFudF9yZWZlcmVuY2VzKDEs ICZncmFudCkpCj4+IC0JCXJldHVybiAwOwo+PiArCWlmICh1bmxpa2VseShkYXRhLT5icm9rZW4p KQo+PiArCQlnb3RvIG91dDsKPj4gICAKPj4gLQlnbnR0YWJfZ3JhbnRfZm9yZWlnbl9hY2Nlc3Nf cmVmKGdyYW50LCAwLCB4ZW5fcGFnZV90b19nZm4ocGFnZSksCj4+IC0JCQkJCWRpciA9PSBETUFf VE9fREVWSUNFKTsKPj4gKwlpZiAoZ250dGFiX2FsbG9jX2dyYW50X3JlZmVyZW5jZV9zZXEobl9w YWdlcywgJmdyYW50KSkKPj4gKwkJZ290byBvdXQ7Cj4+ICAgCj4+IC0JcmV0dXJuIGdyYW50X3Rv X2RtYShncmFudCkgKyBvZmZzZXQ7Cj4+ICsJZm9yIChpID0gMDsgaSA8IG5fcGFnZXM7IGkrKykg ewo+PiArCQlnbnR0YWJfZ3JhbnRfZm9yZWlnbl9hY2Nlc3NfcmVmKGdyYW50ICsgaSwgZGF0YS0+ ZGV2X2RvbWlkLAo+PiArCQkJCXhlbl9wYWdlX3RvX2dmbihwYWdlKSArIGksIGRpciA9PSBETUFf VE9fREVWSUNFKTsKPj4gKwl9Cj4+ICsKPj4gKwlkbWFfaGFuZGxlID0gZ3JhbnRfdG9fZG1hKGdy YW50KSArIG9mZnNldDsKPj4gKwo+PiArb3V0Ogo+PiArCXNwaW5fdW5sb2NrKCZkYXRhLT5sb2Nr KTsKPj4gKwo+PiArCXJldHVybiBkbWFfaGFuZGxlOwo+PiAgIH0KPj4gICAKPj4gICBzdGF0aWMg dm9pZCB4ZW5fdmlydGlvX2RtYV91bm1hcF9wYWdlKHN0cnVjdCBkZXZpY2UgKmRldiwgZG1hX2Fk ZHJfdCBkbWFfaGFuZGxlLAo+PiAgIAkJCQkgICAgICBzaXplX3Qgc2l6ZSwgZW51bSBkbWFfZGF0 YV9kaXJlY3Rpb24gZGlyLAo+PiAgIAkJCQkgICAgICB1bnNpZ25lZCBsb25nIGF0dHJzKQo+PiAg IHsKPj4gKwlzdHJ1Y3QgeGVuX3ZpcnRpb19kYXRhICpkYXRhOwo+PiArCXVuc2lnbmVkIGludCBp LCBuX3BhZ2VzID0gUEZOX1VQKHNpemUpOwo+PiAgIAlncmFudF9yZWZfdCBncmFudDsKPj4gICAK Pj4gKwlCVUdfT04oZGlyID09IERNQV9OT05FKTsKPj4gKwo+PiArCWRhdGEgPSBmaW5kX3hlbl92 aXJ0aW9fZGF0YShkZXYpOwo+PiArCWlmICghZGF0YSkKPj4gKwkJcmV0dXJuOwo+PiArCj4+ICsJ c3Bpbl9sb2NrKCZkYXRhLT5sb2NrKTsKPj4gKwo+PiArCWlmICh1bmxpa2VseShkYXRhLT5icm9r ZW4pKQo+PiArCQlnb3RvIG91dDsKPj4gKwo+PiAgIAlncmFudCA9IGRtYV90b19ncmFudChkbWFf aGFuZGxlKTsKPj4gICAKPj4gLQlnbnR0YWJfZW5kX2ZvcmVpZ25fYWNjZXNzX3JlZihncmFudCk7 Cj4+ICsJZm9yIChpID0gMDsgaSA8IG5fcGFnZXM7IGkrKykgewo+PiArCQlpZiAodW5saWtlbHko IWdudHRhYl9lbmRfZm9yZWlnbl9hY2Nlc3NfcmVmKGdyYW50ICsgaSkpKSB7Cj4+ICsJCQlkZXZf YWxlcnQoZGV2LCAiR3JhbnQgc3RpbGwgaW4gdXNlIGJ5IGJhY2tlbmQgZG9tYWluLCBkaXNhYmxl ZCBmb3IgZnVydGhlciB1c2VcbiIpOwo+PiArCQkJZGF0YS0+YnJva2VuID0gdHJ1ZTsKPj4gKwkJ CWdvdG8gb3V0Owo+PiArCQl9Cj4+ICsJfQo+PiArCj4+ICsJZ250dGFiX2ZyZWVfZ3JhbnRfcmVm ZXJlbmNlX3NlcShncmFudCwgbl9wYWdlcyk7Cj4+ICAgCj4+IC0JZ250dGFiX2ZyZWVfZ3JhbnRf cmVmZXJlbmNlKGdyYW50KTsKPj4gK291dDoKPj4gKwlzcGluX3VubG9jaygmZGF0YS0+bG9jayk7 Cj4+ICAgfQo+PiAgIAo+PiAgIHN0YXRpYyBpbnQgeGVuX3ZpcnRpb19kbWFfbWFwX3NnKHN0cnVj dCBkZXZpY2UgKmRldiwgc3RydWN0IHNjYXR0ZXJsaXN0ICpzZywKPj4gQEAgLTE0OSw3ICsyNTUs NyBAQCBzdGF0aWMgdm9pZCB4ZW5fdmlydGlvX2RtYV91bm1hcF9zZyhzdHJ1Y3QgZGV2aWNlICpk ZXYsIHN0cnVjdCBzY2F0dGVybGlzdCAqc2csCj4+ICAgCj4+ICAgc3RhdGljIGludCB4ZW5fdmly dGlvX2RtYV9kbWFfc3VwcG9ydGVkKHN0cnVjdCBkZXZpY2UgKmRldiwgdTY0IG1hc2spCj4+ICAg ewo+PiAtCXJldHVybiAxOwo+PiArCXJldHVybiBtYXNrID09IERNQV9CSVRfTUFTSyg2NCk7Cj4+ ICAgfQo+PiAgIAo+PiAgIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZG1hX21hcF9vcHMgeGVuX3ZpcnRp b19kbWFfb3BzID0gewo+PiBAQCAtMTY2LDkgKzI3Miw2MSBAQCBzdGF0aWMgY29uc3Qgc3RydWN0 IGRtYV9tYXBfb3BzIHhlbl92aXJ0aW9fZG1hX29wcyA9IHsKPj4gICAJLmRtYV9zdXBwb3J0ZWQg PSB4ZW5fdmlydGlvX2RtYV9kbWFfc3VwcG9ydGVkLAo+PiAgIH07Cj4+ICAgCj4+ICtib29sIHhl bl9pc192aXJ0aW9fZGV2aWNlKHN0cnVjdCBkZXZpY2UgKmRldikKPj4gK3sKPj4gKwkvKiBYWFgg SGFuZGxlIG9ubHkgRFQgZGV2aWNlcyBmb3Igbm93ICovCj4+ICsJaWYgKCFkZXYtPm9mX25vZGUp Cj4+ICsJCXJldHVybiBmYWxzZTsKPj4gKwo+PiArCWlmICghb2ZfZGV2aWNlX2lzX2NvbXBhdGli bGUoZGV2LT5vZl9ub2RlLCAidmlydGlvLG1taW8iKSkKPj4gKwkJcmV0dXJuIGZhbHNlOwo+PiAr Cj4+ICsJcmV0dXJuIG9mX3Byb3BlcnR5X3JlYWRfYm9vbChkZXYtPm9mX25vZGUsICJ4ZW4sZGV2 LWRvbWlkIik7Cj4+ICt9Cj4+ICtFWFBPUlRfU1lNQk9MX0dQTCh4ZW5faXNfdmlydGlvX2Rldmlj ZSk7Cj4+ICsKPj4gICB2b2lkIHhlbl92aXJ0aW9fc2V0dXBfZG1hX29wcyhzdHJ1Y3QgZGV2aWNl ICpkZXYpCj4+ICAgewo+PiArCXN0cnVjdCB4ZW5fdmlydGlvX2RhdGEgKmRhdGE7Cj4+ICsJdWlu dDMyX3QgZGV2X2RvbWlkOwo+PiArCj4+ICsJZGF0YSA9IGZpbmRfeGVuX3ZpcnRpb19kYXRhKGRl dik7Cj4+ICsJaWYgKGRhdGEpIHsKPj4gKwkJZGV2X2VycihkZXYsICJ4ZW5fdmlydGlvIGRhdGEg aXMgYWxyZWFkeSBjcmVhdGVkXG4iKTsKPj4gKwkJcmV0dXJuOwo+PiArCX0KPj4gKwo+PiArCWlm IChkZXZfaXNfcGNpKGRldikpIHsKPj4gKwkJLyogWFhYIExlYXZlIGl0IGhhcmQgd2lyZWQgdG8g ZG9tMCBmb3Igbm93ICovCj4+ICsJCWRldl9kb21pZCA9IDA7Cj4+ICsJfSBlbHNlIGlmIChkZXYt Pm9mX25vZGUpIHsKPj4gKwkJaWYgKG9mX3Byb3BlcnR5X3JlYWRfdTMyKGRldi0+b2Zfbm9kZSwg InhlbixkZXYtZG9taWQiLCAmZGV2X2RvbWlkKSkgewo+PiArCQkJZGV2X2VycihkZXYsICJ4ZW4s ZGV2LWRvbWlkIHByb3BlcnR5IGlzIG5vdCBwcmVzZW50XG4iKTsKPj4gKwkJCWdvdG8gZXJyOwo+ PiArCQl9Cj4+ICsJfSBlbHNlCj4+ICsJCS8qIFRoZSBBQ1BJIGNhc2UgaXMgbm90IHN1cHBvcnRl ZCAqLwo+PiArCQlnb3RvIGVycjsKPiBJZiB3ZSBnZXQgaGVyZSwgaXQgbWVhbnMgdGhhdCB4ZW5f aXNfdmlydGlvX2RldmljZSByZXR1cm5lZCB0cnVlLCBzbyB0aGUKPiBQQ0kgY2FzZSBpcyBhY3R1 YWxseSBpbXBvc3NpYmxlPwoKR29vZCBjYXRjaCwgdGhhbmsgeW91LiBZZXMsIGl0IGlzIGltcG9z c2libGUgb24gQXJtIGZvciBub3cgKHdpdGggCmNoYW5nZXMgaW4gY29tbWl0ICM2KS4KCgo+Cj4g SSB3b3VsZCByZXdyaXRlIHRoZXNlIGNoZWNrcyBsaWtlIHRoaXM6Cj4KPiAvKiBYWFg6IEFDUEkg YW5kIFBDSSB1bnN1cHBvcnRlZCBmb3Igbm93ICovCj4gaWYgKGRldl9pc19wY2koZGV2KSB8fCAh ZGV2LT5vZl9ub2RlKSB7Cj4gCWdvdG8gZXJyOwo+IH0KPiBpZiAob2ZfcHJvcGVydHlfcmVhZF91 MzIoZGV2LT5vZl9ub2RlLCAieGVuLGRldi1kb21pZCIsICZkZXZfZG9taWQpKSB7Cj4gCWRldl9l cnIoZGV2LCAieGVuLGRldi1kb21pZCBwcm9wZXJ0eSBpcyBub3QgcHJlc2VudFxuIik7Cj4gCWdv dG8gZXJyOwo+IH0KCgpvaywgd2lsbCBkbwoKCj4KPgo+Cj4+ICsJZGF0YSA9IGRldm1fa3phbGxv YyhkZXYsIHNpemVvZigqZGF0YSksIEdGUF9LRVJORUwpOwo+PiArCWlmICghZGF0YSkgewo+PiAr CQlkZXZfZXJyKGRldiwgItChYW5ub3QgYWxsb2NhdGUgeGVuX3ZpcnRpbyBkYXRhXG4iKTsKPj4g KwkJZ290byBlcnI7Cj4+ICsJfQo+PiArCWRhdGEtPmRldl9kb21pZCA9IGRldl9kb21pZDsKPj4g KwlkYXRhLT5kZXYgPSBkZXY7Cj4+ICsJc3Bpbl9sb2NrX2luaXQoJmRhdGEtPmxvY2spOwo+PiAr Cj4+ICsJc3Bpbl9sb2NrKCZ4ZW5fdmlydGlvX2xvY2spOwo+PiArCWxpc3RfYWRkKCZkYXRhLT5s aXN0LCAmeGVuX3ZpcnRpb19kZXZpY2VzKTsKPj4gKwlzcGluX3VubG9jaygmeGVuX3ZpcnRpb19s b2NrKTsKPj4gKwo+PiAgIAlkZXYtPmRtYV9vcHMgPSAmeGVuX3ZpcnRpb19kbWFfb3BzOwo+PiAr Cj4+ICsJcmV0dXJuOwo+PiArCj4+ICtlcnI6Cj4+ICsJZGV2X2VycihkZXYsICLQoWFubm90IHNl dCB1cCB4ZW5fdmlydGlvIERNQSBvcHMsIHJldGFpbiBwbGF0Zm9ybSBETUEgb3BzXG4iKTsKPj4g ICB9Cj4+ICAgRVhQT1JUX1NZTUJPTF9HUEwoeGVuX3ZpcnRpb19zZXR1cF9kbWFfb3BzKTsKPj4g ICAKPj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUveGVuL3hlbi1vcHMuaCBiL2luY2x1ZGUveGVuL3hl bi1vcHMuaAo+PiBpbmRleCBhZTNjMWJjLi5mZGJjYjk5IDEwMDY0NAo+PiAtLS0gYS9pbmNsdWRl L3hlbi94ZW4tb3BzLmgKPj4gKysrIGIvaW5jbHVkZS94ZW4veGVuLW9wcy5oCj4+IEBAIC0yMjMs MTAgKzIyMywxNSBAQCBzdGF0aWMgaW5saW5lIHZvaWQgeGVuX3ByZWVtcHRpYmxlX2hjYWxsX2Vu ZCh2b2lkKSB7IH0KPj4gICAKPj4gICAjaWZkZWYgQ09ORklHX1hFTl9WSVJUSU8KPj4gICB2b2lk IHhlbl92aXJ0aW9fc2V0dXBfZG1hX29wcyhzdHJ1Y3QgZGV2aWNlICpkZXYpOwo+PiArYm9vbCB4 ZW5faXNfdmlydGlvX2RldmljZShzdHJ1Y3QgZGV2aWNlICpkZXYpOwo+PiAgICNlbHNlCj4+ICAg c3RhdGljIGlubGluZSB2b2lkIHhlbl92aXJ0aW9fc2V0dXBfZG1hX29wcyhzdHJ1Y3QgZGV2aWNl ICpkZXYpCj4+ICAgewo+PiAgIH0KPj4gK3N0YXRpYyBpbmxpbmUgYm9vbCB4ZW5faXNfdmlydGlv X2RldmljZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4+ICt7Cj4+ICsJcmV0dXJuIGZhbHNlOwo+PiAr fQo+PiAgICNlbmRpZiAvKiBDT05GSUdfWEVOX1ZJUlRJTyAqLwo+PiAgIAo+PiAgICNlbmRpZiAv KiBJTkNMVURFX1hFTl9PUFNfSCAqLwoKLS0gClJlZ2FyZHMsCgpPbGVrc2FuZHIgVHlzaGNoZW5r bwoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4 LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFk Lm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFy bS1rZXJuZWwK