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 C52FDC433EF for ; Thu, 14 Apr 2022 19:20:33 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1345378AbiDNTWa (ORCPT ); Thu, 14 Apr 2022 15:22:30 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:52346 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1345197AbiDNTWO (ORCPT ); Thu, 14 Apr 2022 15:22:14 -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 BB27AA776F for ; Thu, 14 Apr 2022 12:19:44 -0700 (PDT) Received: by mail-lj1-x22b.google.com with SMTP id 17so7279860lji.1 for ; Thu, 14 Apr 2022 12:19:44 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=HH0lNJhCKrn1KVzcgV/uI3rqOPkxUwMay92nkSrAjww=; b=CSmQsWmMPhKn65VWOLhlyWUk/5YwfpW6oHGmDgSr8oyIRtln1bgL/FxXCzwqOQ2scW Kul15jhG/xUMsrq9hwxgzV7VZ+jj3hupZRanvoSdnRr8nY+F8D9bVK1bhDZDRzNimT23 LAh7fUHs+YKWYCqE86acY6uO/YWr6KZAKVBtZxwCRFor0ambo4hAmrApMjmGMTo04/Vx omjZqW9FpYwni3wQwXilVmnhhBiTL44fcofN4KwMa0r/naLAzWmPO9D0cVR9OT/QkH7A h4d5ucGnzxq/vZwtYADqFA6IbCHPqfZ2O1SM0pyYOBrcVF6qgnYeOnQS+OhyTtG8dwru XDgw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=HH0lNJhCKrn1KVzcgV/uI3rqOPkxUwMay92nkSrAjww=; b=ydxKMx2xkDrYbQvKlDsaCjVX2I7F7UDHJj41FTTJWNgFWfeUVEk+t3A09sydwjNXxQ SekNHUN3buiFbLGKhDNp3y82w2BEw+S8F6svGx1RzxixqhqLf3FPxd6v7HnQh01zgzV8 x6mzC/6OyoXqOOhX+M1k7yJGv3+fG+ZQQW9r54gY3H/dECAf05rOUEAODmWmYH4p45sT 79CaZyLSDb6uquSTmG2X2WtzNfqMohvcmg14mfw+c7kHeS28fVF28KXzU1vyhDgPjOVR VvlWcAt4zrgI9a81coSNgjLS0y408A6B5v0+RA9lszwaAxxLGs4lWce4rcQk4V3LgkP1 NV+g== X-Gm-Message-State: AOAM531abLyklzSNFPBXSyORu4+D5IXO4S5TyFdCuAsrB33BPcI+wcx2 YinMxGd3zfRSAKLXpHB11R4/icdIcWg= X-Google-Smtp-Source: ABdhPJyqaIJqLPokLPf5w1P1n+RXHoKfPPFHkJ8cRMG0ZDENL1jq4zsAVzAnYaGGBHo3X65+xfsMjQ== X-Received: by 2002:a2e:9c2:0:b0:24a:c757:b9bb with SMTP id 185-20020a2e09c2000000b0024ac757b9bbmr2493120ljj.360.1649963982965; Thu, 14 Apr 2022 12:19:42 -0700 (PDT) Received: from otyshchenko.router ([212.22.223.21]) by smtp.gmail.com with ESMTPSA id l3-20020a194943000000b0046b928d2795sm85001lfj.67.2022.04.14.12.19.41 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Thu, 14 Apr 2022 12:19:42 -0700 (PDT) From: Oleksandr Tyshchenko To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Cc: Oleksandr Tyshchenko , Stefano Stabellini , Russell King , Boris Ostrovsky , Juergen Gross , Julien Grall Subject: [RFC PATCH 4/6] virtio: Various updates to xen-virtio DMA ops layer Date: Thu, 14 Apr 2022 22:19:31 +0300 Message-Id: <1649963973-22879-5-git-send-email-olekstysh@gmail.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1649963973-22879-1-git-send-email-olekstysh@gmail.com> References: <1649963973-22879-1-git-send-email-olekstysh@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org 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; + + 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) 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; +}; + +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; + + 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 */ -- 2.7.4 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 3A24BC433F5 for ; Thu, 14 Apr 2022 19:21:05 +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-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=AdzPEyh7naj1Q29sEN9FLMLUqxARD9fsjZBfqz42V+o=; b=30Y9V0w9kXbKfC obIdajVdwTx3RVgPrQbjfIUsN1Vb9hRktwTc40gZn38pJ+oaj0ho3ci/y0zM0mw0i6RlBwlwPsfQt Tlgd+RkkbpwQ+1JK36MDPvvoWHOQtB5R4Ku5/StBaSG7sJE03MO2hjm8nkCYIeX3/5N1+rRrLHfru CpBoTpZALPalkgZvX0KxYexkOV45gu4Cl8HV0O8ieG2EB0kwPfH7a7GkL6BfsGDOZFhGrilgMRUsD B8sFuLYDjL12pzl594g51irLL/+tqa6JueO6Deqh8GMfXEUwXDs2K4BCXPvOfhfFy5qKtTF9MWtAP fsrX8wmEh6riNcrTd4hA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nf50X-00722C-Ip; Thu, 14 Apr 2022 19:19:57 +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 1nf50L-0071vs-7r for linux-arm-kernel@lists.infradead.org; Thu, 14 Apr 2022 19:19:47 +0000 Received: by mail-lj1-x231.google.com with SMTP id c15so7251212ljr.9 for ; Thu, 14 Apr 2022 12:19:44 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=HH0lNJhCKrn1KVzcgV/uI3rqOPkxUwMay92nkSrAjww=; b=CSmQsWmMPhKn65VWOLhlyWUk/5YwfpW6oHGmDgSr8oyIRtln1bgL/FxXCzwqOQ2scW Kul15jhG/xUMsrq9hwxgzV7VZ+jj3hupZRanvoSdnRr8nY+F8D9bVK1bhDZDRzNimT23 LAh7fUHs+YKWYCqE86acY6uO/YWr6KZAKVBtZxwCRFor0ambo4hAmrApMjmGMTo04/Vx omjZqW9FpYwni3wQwXilVmnhhBiTL44fcofN4KwMa0r/naLAzWmPO9D0cVR9OT/QkH7A h4d5ucGnzxq/vZwtYADqFA6IbCHPqfZ2O1SM0pyYOBrcVF6qgnYeOnQS+OhyTtG8dwru XDgw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=HH0lNJhCKrn1KVzcgV/uI3rqOPkxUwMay92nkSrAjww=; b=TWFtw3wWoDd1OMqEuTxy10ereXrj/mpO2K6w4wqljq7u3Rb0ZR1oTt2IFTlwVuiiOO guPY/ISkV8F8b6igHFMazSN/51MXBhJ0Ynx/7pufsUqdPDCWOP+YJh85TkDV9/cznNbs 1ZhSVtipeULDz+Zr8zTM6PPODU7WtnAlc20IfG+uQpOsaHNKdzqEJWhcoCChzzWlkHlN d0c9iItmLNzhHwXblzT56UY0rs2yx/Z6UZX60jx9B1qZO+YsJh/bStelvuvSxXSjuj7G 4E/JB1Fb966bpfWLGI9Y+V+JYbydQN5kirAhuIuH7v2wvRYE9qtdyMM8FBv3NgiNQ1SQ kafQ== X-Gm-Message-State: AOAM531wg0cVl5w0OFqHWYssMXGkQuvDhWPwKCah7lsXzkAo0wSBvFmG +pgLOC6+vGwtacNWWdisKOU= X-Google-Smtp-Source: ABdhPJyqaIJqLPokLPf5w1P1n+RXHoKfPPFHkJ8cRMG0ZDENL1jq4zsAVzAnYaGGBHo3X65+xfsMjQ== X-Received: by 2002:a2e:9c2:0:b0:24a:c757:b9bb with SMTP id 185-20020a2e09c2000000b0024ac757b9bbmr2493120ljj.360.1649963982965; Thu, 14 Apr 2022 12:19:42 -0700 (PDT) Received: from otyshchenko.router ([212.22.223.21]) by smtp.gmail.com with ESMTPSA id l3-20020a194943000000b0046b928d2795sm85001lfj.67.2022.04.14.12.19.41 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Thu, 14 Apr 2022 12:19:42 -0700 (PDT) From: Oleksandr Tyshchenko To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Cc: Oleksandr Tyshchenko , Stefano Stabellini , Russell King , Boris Ostrovsky , Juergen Gross , Julien Grall Subject: [RFC PATCH 4/6] virtio: Various updates to xen-virtio DMA ops layer Date: Thu, 14 Apr 2022 22:19:31 +0300 Message-Id: <1649963973-22879-5-git-send-email-olekstysh@gmail.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1649963973-22879-1-git-send-email-olekstysh@gmail.com> References: <1649963973-22879-1-git-send-email-olekstysh@gmail.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220414_121945_359268_CB782323 X-CRM114-Status: GOOD ( 29.98 ) 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-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org RnJvbTogT2xla3NhbmRyIFR5c2hjaGVua28gPG9sZWtzYW5kcl90eXNoY2hlbmtvQGVwYW0uY29t PgoKSW4gdGhlIGNvbnRleHQgb2YgY3VycmVudCBwYXRjaCBkbyB0aGUgZm9sbG93aW5nOgoxLiBV cGRhdGUgY29kZSB0byBzdXBwb3J0IHZpcnRpby1tbWlvIGRldmljZXMKMi4gSW50cm9kdWNlIHN0 cnVjdCB4ZW5fdmlydGlvX2RhdGEgYW5kIGFjY291bnQgcGFzc2VkIHZpcnRpbyBkZXZpY2VzCiAg ICh1c2luZyBsaXN0KSBhcyB3ZSBuZWVkIHRvIHN0b3JlIHNvbWUgcGVyLWRldmljZSBkYXRhCjMu IEFkZCBtdWx0aS1wYWdlIHN1cHBvcnQgZm9yIHhlbl92aXJ0aW9fZG1hX21hcCh1bm1hcClfcGFn ZSBjYWxsYmFja3MKNC4gSGFyZGVuIGNvZGUgYWdhaW5zdCBtYWxpY2lvdXMgYmFja2VuZAo1LiBD aGFuZ2UgdG8gdXNlIGFsbG9jX3BhZ2VzX2V4YWN0KCkgaW5zdGVhZCBvZiBfX2dldF9mcmVlX3Bh Z2VzKCkKNi4gSW50cm9kdWNlIGxvY2tpbmcgc2NoZW1lIHRvIHByb3RlY3QgbWFwcGluZ3MgKEkg YW0gbm90IDEwMCUgc3VyZQogICB3aGV0aGVyIHBlci1kZXZpY2UgbG9jayBpcyByZWFsbHkgbmVl ZGVkKQo3LiBIYW5kbGUgdmlydGlvIGRldmljZSdzIERNQSBtYXNrCjguIFJldHJpZXZlIHRoZSBJ RCBvZiBiYWNrZW5kIGRvbWFpbiBmcm9tIERUIGZvciB2aXJ0aW8tbW1pbyBkZXZpY2UKICAgaW5z dGVhZCBvZiBoYXJkY29kaW5nIGl0LgoKU2lnbmVkLW9mZi1ieTogT2xla3NhbmRyIFR5c2hjaGVu a28gPG9sZWtzYW5kcl90eXNoY2hlbmtvQGVwYW0uY29tPgotLS0KIGFyY2gvYXJtL3hlbi9lbmxp Z2h0ZW4uYyB8ICAxMSArKysKIGRyaXZlcnMveGVuL0tjb25maWcgICAgICB8ICAgMiArLQogZHJp dmVycy94ZW4veGVuLXZpcnRpby5jIHwgMjAwICsrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKy0tLS0tCiBpbmNsdWRlL3hlbi94ZW4tb3BzLmggICAgfCAgIDUgKysKIDQg ZmlsZXMgY2hhbmdlZCwgMTk2IGluc2VydGlvbnMoKyksIDIyIGRlbGV0aW9ucygtKQoKZGlmZiAt LWdpdCBhL2FyY2gvYXJtL3hlbi9lbmxpZ2h0ZW4uYyBiL2FyY2gvYXJtL3hlbi9lbmxpZ2h0ZW4u YwppbmRleCBlYzViMDgyLi44NzBkOTJmIDEwMDY0NAotLS0gYS9hcmNoL2FybS94ZW4vZW5saWdo dGVuLmMKKysrIGIvYXJjaC9hcm0veGVuL2VubGlnaHRlbi5jCkBAIC00MDksNiArNDA5LDE3IEBA IGludCBfX2luaXQgYXJjaF94ZW5fdW5wb3B1bGF0ZWRfaW5pdChzdHJ1Y3QgcmVzb3VyY2UgKipy ZXMpCiB9CiAjZW5kaWYKIAorI2lmZGVmIENPTkZJR19BUkNIX0hBU19SRVNUUklDVEVEX1ZJUlRJ T19NRU1PUllfQUNDRVNTCitpbnQgYXJjaF9oYXNfcmVzdHJpY3RlZF92aXJ0aW9fbWVtb3J5X2Fj Y2Vzcyh2b2lkKQoreworCWlmIChJU19FTkFCTEVEKENPTkZJR19YRU5fSFZNX1ZJUlRJT19HUkFO VCkgJiYgeGVuX2h2bV9kb21haW4oKSkKKwkJcmV0dXJuIDE7CisKKwlyZXR1cm4gMDsKK30KK0VY UE9SVF9TWU1CT0xfR1BMKGFyY2hfaGFzX3Jlc3RyaWN0ZWRfdmlydGlvX21lbW9yeV9hY2Nlc3Mp OworI2VuZGlmCisKIHN0YXRpYyB2b2lkIF9faW5pdCB4ZW5fZHRfZ3Vlc3RfaW5pdCh2b2lkKQog ewogCXN0cnVjdCBkZXZpY2Vfbm9kZSAqeGVuX25vZGU7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3hl bi9LY29uZmlnIGIvZHJpdmVycy94ZW4vS2NvbmZpZwppbmRleCBmYzYxZjdhLi41NmFmZTZhIDEw MDY0NAotLS0gYS9kcml2ZXJzL3hlbi9LY29uZmlnCisrKyBiL2RyaXZlcnMveGVuL0tjb25maWcK QEAgLTM0Nyw3ICszNDcsNyBAQCBjb25maWcgWEVOX1ZJUlRJTwogCiBjb25maWcgWEVOX0hWTV9W SVJUSU9fR1JBTlQKIAlib29sICJSZXF1aXJlIHZpcnRpbyBmb3IgZnVsbHkgdmlydHVhbGl6ZWQg Z3Vlc3RzIHRvIHVzZSBncmFudCBtYXBwaW5ncyIKLQlkZXBlbmRzIG9uIFhFTl9WSVJUSU8gJiYg WDg2XzY0CisJZGVwZW5kcyBvbiBYRU5fVklSVElPICYmIChYODZfNjQgfHwgQVJNIHx8IEFSTTY0 KQogCWRlZmF1bHQgeQogCWhlbHAKIAkgIFJlcXVpcmUgdmlydGlvIGZvciBmdWxseSB2aXJ0dWFs aXplZCBndWVzdHMgdG8gdXNlIGdyYW50IG1hcHBpbmdzLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy94 ZW4veGVuLXZpcnRpby5jIGIvZHJpdmVycy94ZW4veGVuLXZpcnRpby5jCmluZGV4IGNmZDVlZGEu LmM1YjJlYzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL3hlbi12aXJ0aW8uYworKysgYi9kcml2 ZXJzL3hlbi94ZW4tdmlydGlvLmMKQEAgLTcsMTIgKzcsMjYgQEAKIAogI2luY2x1ZGUgPGxpbnV4 L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L2RtYS1tYXAtb3BzLmg+CisjaW5jbHVkZSA8bGlu dXgvb2YuaD4KICNpbmNsdWRlIDxsaW51eC9wY2kuaD4KICNpbmNsdWRlIDxsaW51eC9wZm4uaD4K ICNpbmNsdWRlIDxsaW51eC92aXJ0aW9fY29uZmlnLmg+CiAjaW5jbHVkZSA8eGVuL3hlbi5oPgog I2luY2x1ZGUgPHhlbi9ncmFudF90YWJsZS5oPgogCitzdHJ1Y3QgeGVuX3ZpcnRpb19kYXRhIHsK KwkvKiBUaGUgSUQgb2YgYmFja2VuZCBkb21haW4gKi8KKwlkb21pZF90IGRldl9kb21pZDsKKwlz dHJ1Y3QgZGV2aWNlICpkZXY7CisJc3RydWN0IGxpc3RfaGVhZCBsaXN0OworCXNwaW5sb2NrX3Qg bG9jazsKKwkvKiBJcyBkZXZpY2UgYmVoYXZpbmcgc2FuZT8gKi8KKwlib29sIGJyb2tlbjsKK307 CisKK3N0YXRpYyBMSVNUX0hFQUQoeGVuX3ZpcnRpb19kZXZpY2VzKTsKK3N0YXRpYyBERUZJTkVf U1BJTkxPQ0soeGVuX3ZpcnRpb19sb2NrKTsKKwogI2RlZmluZSBYRU5fR1JBTlRfQUREUl9PRkYJ MHg4MDAwMDAwMDAwMDAwMDAwVUxMCiAKIHN0YXRpYyBpbmxpbmUgZG1hX2FkZHJfdCBncmFudF90 b19kbWEoZ3JhbnRfcmVmX3QgZ3JhbnQpCkBAIC0yNSw2ICszOSwyNSBAQCBzdGF0aWMgaW5saW5l IGdyYW50X3JlZl90IGRtYV90b19ncmFudChkbWFfYWRkcl90IGRtYSkKIAlyZXR1cm4gKGdyYW50 X3JlZl90KSgoZG1hICYgflhFTl9HUkFOVF9BRERSX09GRikgPj4gUEFHRV9TSElGVCk7CiB9CiAK K3N0YXRpYyBzdHJ1Y3QgeGVuX3ZpcnRpb19kYXRhICpmaW5kX3hlbl92aXJ0aW9fZGF0YShzdHJ1 Y3QgZGV2aWNlICpkZXYpCit7CisJc3RydWN0IHhlbl92aXJ0aW9fZGF0YSAqZGF0YSA9IE5VTEw7 CisJYm9vbCBmb3VuZCA9IGZhbHNlOworCisJc3Bpbl9sb2NrKCZ4ZW5fdmlydGlvX2xvY2spOwor CisJbGlzdF9mb3JfZWFjaF9lbnRyeSggZGF0YSwgJnhlbl92aXJ0aW9fZGV2aWNlcywgbGlzdCkg eworCQlpZiAoZGF0YS0+ZGV2ID09IGRldikgeworCQkJZm91bmQgPSB0cnVlOworCQkJYnJlYWs7 CisJCX0KKwl9CisKKwlzcGluX3VubG9jaygmeGVuX3ZpcnRpb19sb2NrKTsKKworCXJldHVybiBm b3VuZCA/IGRhdGEgOiBOVUxMOworfQorCiAvKgogICogRE1BIG9wcyBmb3IgWGVuIHZpcnRpbyBm cm9udGVuZHMuCiAgKgpAQCAtNDMsNDggKzc2LDc4IEBAIHN0YXRpYyB2b2lkICp4ZW5fdmlydGlv X2RtYV9hbGxvYyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHNpemVfdCBzaXplLAogCQkJCSAgZG1hX2Fk ZHJfdCAqZG1hX2hhbmRsZSwgZ2ZwX3QgZ2ZwLAogCQkJCSAgdW5zaWduZWQgbG9uZyBhdHRycykK IHsKLQl1bnNpZ25lZCBpbnQgbl9wYWdlcyA9IFBGTl9VUChzaXplKTsKLQl1bnNpZ25lZCBpbnQg aTsKKwlzdHJ1Y3QgeGVuX3ZpcnRpb19kYXRhICpkYXRhOworCXVuc2lnbmVkIGludCBpLCBuX3Bh Z2VzID0gUEZOX1VQKHNpemUpOwogCXVuc2lnbmVkIGxvbmcgcGZuOwogCWdyYW50X3JlZl90IGdy YW50OwotCXZvaWQgKnJldDsKKwl2b2lkICpyZXQgPSBOVUxMOwogCi0JcmV0ID0gKHZvaWQgKilf X2dldF9mcmVlX3BhZ2VzKGdmcCwgZ2V0X29yZGVyKHNpemUpKTsKLQlpZiAoIXJldCkKKwlkYXRh ID0gZmluZF94ZW5fdmlydGlvX2RhdGEoZGV2KTsKKwlpZiAoIWRhdGEpCiAJCXJldHVybiBOVUxM OwogCisJc3Bpbl9sb2NrKCZkYXRhLT5sb2NrKTsKKworCWlmICh1bmxpa2VseShkYXRhLT5icm9r ZW4pKQorCQlnb3RvIG91dDsKKworCXJldCA9IGFsbG9jX3BhZ2VzX2V4YWN0KG5fcGFnZXMgKiBQ QUdFX1NJWkUsIGdmcCk7CisJaWYgKCFyZXQpCisJCWdvdG8gb3V0OworCiAJcGZuID0gdmlydF90 b19wZm4ocmV0KTsKIAogCWlmIChnbnR0YWJfYWxsb2NfZ3JhbnRfcmVmZXJlbmNlX3NlcShuX3Bh Z2VzLCAmZ3JhbnQpKSB7Ci0JCWZyZWVfcGFnZXMoKHVuc2lnbmVkIGxvbmcpcmV0LCBnZXRfb3Jk ZXIoc2l6ZSkpOwotCQlyZXR1cm4gTlVMTDsKKwkJZnJlZV9wYWdlc19leGFjdChyZXQsIG5fcGFn ZXMgKiBQQUdFX1NJWkUpOworCQlyZXQgPSBOVUxMOworCQlnb3RvIG91dDsKIAl9CiAKIAlmb3Ig KGkgPSAwOyBpIDwgbl9wYWdlczsgaSsrKSB7Ci0JCWdudHRhYl9ncmFudF9mb3JlaWduX2FjY2Vz c19yZWYoZ3JhbnQgKyBpLCAwLAorCQlnbnR0YWJfZ3JhbnRfZm9yZWlnbl9hY2Nlc3NfcmVmKGdy YW50ICsgaSwgZGF0YS0+ZGV2X2RvbWlkLAogCQkJCQkJcGZuX3RvX2dmbihwZm4gKyBpKSwgMCk7 CiAJfQogCiAJKmRtYV9oYW5kbGUgPSBncmFudF90b19kbWEoZ3JhbnQpOwogCitvdXQ6CisJc3Bp bl91bmxvY2soJmRhdGEtPmxvY2spOworCiAJcmV0dXJuIHJldDsKIH0KIAogc3RhdGljIHZvaWQg eGVuX3ZpcnRpb19kbWFfZnJlZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHNpemVfdCBzaXplLCB2b2lk ICp2YWRkciwKIAkJCQlkbWFfYWRkcl90IGRtYV9oYW5kbGUsIHVuc2lnbmVkIGxvbmcgYXR0cnMp CiB7Ci0JdW5zaWduZWQgaW50IG5fcGFnZXMgPSBQRk5fVVAoc2l6ZSk7Ci0JdW5zaWduZWQgaW50 IGk7CisJc3RydWN0IHhlbl92aXJ0aW9fZGF0YSAqZGF0YTsKKwl1bnNpZ25lZCBpbnQgaSwgbl9w YWdlcyA9IFBGTl9VUChzaXplKTsKIAlncmFudF9yZWZfdCBncmFudDsKIAorCWRhdGEgPSBmaW5k X3hlbl92aXJ0aW9fZGF0YShkZXYpOworCWlmICghZGF0YSkKKwkJcmV0dXJuOworCisJc3Bpbl9s b2NrKCZkYXRhLT5sb2NrKTsKKworCWlmICh1bmxpa2VseShkYXRhLT5icm9rZW4pKQorCQlnb3Rv IG91dDsKKwogCWdyYW50ID0gZG1hX3RvX2dyYW50KGRtYV9oYW5kbGUpOwogCi0JZm9yIChpID0g MDsgaSA8IG5fcGFnZXM7IGkrKykKLQkJZ250dGFiX2VuZF9mb3JlaWduX2FjY2Vzc19yZWYoZ3Jh bnQgKyBpKTsKKwlmb3IgKGkgPSAwOyBpIDwgbl9wYWdlczsgaSsrKSB7CisJCWlmICh1bmxpa2Vs eSghZ250dGFiX2VuZF9mb3JlaWduX2FjY2Vzc19yZWYoZ3JhbnQgKyBpKSkpIHsKKwkJCWRldl9h bGVydChkZXYsICJHcmFudCBzdGlsbCBpbiB1c2UgYnkgYmFja2VuZCBkb21haW4sIGRpc2FibGVk IGZvciBmdXJ0aGVyIHVzZVxuIik7CisJCQlkYXRhLT5icm9rZW4gPSB0cnVlOworCQkJZ290byBv dXQ7CisJCX0KKwl9CiAKIAlnbnR0YWJfZnJlZV9ncmFudF9yZWZlcmVuY2Vfc2VxKGdyYW50LCBu X3BhZ2VzKTsKIAotCWZyZWVfcGFnZXMoKHVuc2lnbmVkIGxvbmcpdmFkZHIsIGdldF9vcmRlcihz aXplKSk7CisJZnJlZV9wYWdlc19leGFjdCh2YWRkciwgbl9wYWdlcyAqIFBBR0VfU0laRSk7CisK K291dDoKKwlzcGluX3VubG9jaygmZGF0YS0+bG9jayk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgcGFn ZSAqeGVuX3ZpcnRpb19kbWFfYWxsb2NfcGFnZXMoc3RydWN0IGRldmljZSAqZGV2LCBzaXplX3Qg c2l6ZSwKQEAgLTEwOCwyOCArMTcxLDcxIEBAIHN0YXRpYyBkbWFfYWRkcl90IHhlbl92aXJ0aW9f ZG1hX21hcF9wYWdlKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHBhZ2UgKnBhZ2UsCiAJCQkJ CSAgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAogCQkJCQkgIHVuc2lnbmVkIGxvbmcgYXR0 cnMpCiB7CisJc3RydWN0IHhlbl92aXJ0aW9fZGF0YSAqZGF0YTsKKwl1bnNpZ25lZCBpbnQgaSwg bl9wYWdlcyA9IFBGTl9VUChzaXplKTsKIAlncmFudF9yZWZfdCBncmFudDsKKwlkbWFfYWRkcl90 IGRtYV9oYW5kbGUgPSBETUFfTUFQUElOR19FUlJPUjsKKworCUJVR19PTihkaXIgPT0gRE1BX05P TkUpOworCisJZGF0YSA9IGZpbmRfeGVuX3ZpcnRpb19kYXRhKGRldik7CisJaWYgKCFkYXRhKQor CQlyZXR1cm4gRE1BX01BUFBJTkdfRVJST1I7CisKKwlzcGluX2xvY2soJmRhdGEtPmxvY2spOwog Ci0JaWYgKGdudHRhYl9hbGxvY19ncmFudF9yZWZlcmVuY2VzKDEsICZncmFudCkpCi0JCXJldHVy biAwOworCWlmICh1bmxpa2VseShkYXRhLT5icm9rZW4pKQorCQlnb3RvIG91dDsKIAotCWdudHRh Yl9ncmFudF9mb3JlaWduX2FjY2Vzc19yZWYoZ3JhbnQsIDAsIHhlbl9wYWdlX3RvX2dmbihwYWdl KSwKLQkJCQkJZGlyID09IERNQV9UT19ERVZJQ0UpOworCWlmIChnbnR0YWJfYWxsb2NfZ3JhbnRf cmVmZXJlbmNlX3NlcShuX3BhZ2VzLCAmZ3JhbnQpKQorCQlnb3RvIG91dDsKIAotCXJldHVybiBn cmFudF90b19kbWEoZ3JhbnQpICsgb2Zmc2V0OworCWZvciAoaSA9IDA7IGkgPCBuX3BhZ2VzOyBp KyspIHsKKwkJZ250dGFiX2dyYW50X2ZvcmVpZ25fYWNjZXNzX3JlZihncmFudCArIGksIGRhdGEt PmRldl9kb21pZCwKKwkJCQl4ZW5fcGFnZV90b19nZm4ocGFnZSkgKyBpLCBkaXIgPT0gRE1BX1RP X0RFVklDRSk7CisJfQorCisJZG1hX2hhbmRsZSA9IGdyYW50X3RvX2RtYShncmFudCkgKyBvZmZz ZXQ7CisKK291dDoKKwlzcGluX3VubG9jaygmZGF0YS0+bG9jayk7CisKKwlyZXR1cm4gZG1hX2hh bmRsZTsKIH0KIAogc3RhdGljIHZvaWQgeGVuX3ZpcnRpb19kbWFfdW5tYXBfcGFnZShzdHJ1Y3Qg ZGV2aWNlICpkZXYsIGRtYV9hZGRyX3QgZG1hX2hhbmRsZSwKIAkJCQkgICAgICBzaXplX3Qgc2l6 ZSwgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyLAogCQkJCSAgICAgIHVuc2lnbmVkIGxvbmcg YXR0cnMpCiB7CisJc3RydWN0IHhlbl92aXJ0aW9fZGF0YSAqZGF0YTsKKwl1bnNpZ25lZCBpbnQg aSwgbl9wYWdlcyA9IFBGTl9VUChzaXplKTsKIAlncmFudF9yZWZfdCBncmFudDsKIAorCUJVR19P TihkaXIgPT0gRE1BX05PTkUpOworCisJZGF0YSA9IGZpbmRfeGVuX3ZpcnRpb19kYXRhKGRldik7 CisJaWYgKCFkYXRhKQorCQlyZXR1cm47CisKKwlzcGluX2xvY2soJmRhdGEtPmxvY2spOworCisJ aWYgKHVubGlrZWx5KGRhdGEtPmJyb2tlbikpCisJCWdvdG8gb3V0OworCiAJZ3JhbnQgPSBkbWFf dG9fZ3JhbnQoZG1hX2hhbmRsZSk7CiAKLQlnbnR0YWJfZW5kX2ZvcmVpZ25fYWNjZXNzX3JlZihn cmFudCk7CisJZm9yIChpID0gMDsgaSA8IG5fcGFnZXM7IGkrKykgeworCQlpZiAodW5saWtlbHko IWdudHRhYl9lbmRfZm9yZWlnbl9hY2Nlc3NfcmVmKGdyYW50ICsgaSkpKSB7CisJCQlkZXZfYWxl cnQoZGV2LCAiR3JhbnQgc3RpbGwgaW4gdXNlIGJ5IGJhY2tlbmQgZG9tYWluLCBkaXNhYmxlZCBm b3IgZnVydGhlciB1c2VcbiIpOworCQkJZGF0YS0+YnJva2VuID0gdHJ1ZTsKKwkJCWdvdG8gb3V0 OworCQl9CisJfQorCisJZ250dGFiX2ZyZWVfZ3JhbnRfcmVmZXJlbmNlX3NlcShncmFudCwgbl9w YWdlcyk7CiAKLQlnbnR0YWJfZnJlZV9ncmFudF9yZWZlcmVuY2UoZ3JhbnQpOworb3V0OgorCXNw aW5fdW5sb2NrKCZkYXRhLT5sb2NrKTsKIH0KIAogc3RhdGljIGludCB4ZW5fdmlydGlvX2RtYV9t YXBfc2coc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnLApAQCAtMTQ5 LDcgKzI1NSw3IEBAIHN0YXRpYyB2b2lkIHhlbl92aXJ0aW9fZG1hX3VubWFwX3NnKHN0cnVjdCBk ZXZpY2UgKmRldiwgc3RydWN0IHNjYXR0ZXJsaXN0ICpzZywKIAogc3RhdGljIGludCB4ZW5fdmly dGlvX2RtYV9kbWFfc3VwcG9ydGVkKHN0cnVjdCBkZXZpY2UgKmRldiwgdTY0IG1hc2spCiB7Ci0J cmV0dXJuIDE7CisJcmV0dXJuIG1hc2sgPT0gRE1BX0JJVF9NQVNLKDY0KTsKIH0KIAogc3RhdGlj IGNvbnN0IHN0cnVjdCBkbWFfbWFwX29wcyB4ZW5fdmlydGlvX2RtYV9vcHMgPSB7CkBAIC0xNjYs OSArMjcyLDYxIEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZG1hX21hcF9vcHMgeGVuX3ZpcnRpb19k bWFfb3BzID0gewogCS5kbWFfc3VwcG9ydGVkID0geGVuX3ZpcnRpb19kbWFfZG1hX3N1cHBvcnRl ZCwKIH07CiAKK2Jvb2wgeGVuX2lzX3ZpcnRpb19kZXZpY2Uoc3RydWN0IGRldmljZSAqZGV2KQor eworCS8qIFhYWCBIYW5kbGUgb25seSBEVCBkZXZpY2VzIGZvciBub3cgKi8KKwlpZiAoIWRldi0+ b2Zfbm9kZSkKKwkJcmV0dXJuIGZhbHNlOworCisJaWYgKCFvZl9kZXZpY2VfaXNfY29tcGF0aWJs ZShkZXYtPm9mX25vZGUsICJ2aXJ0aW8sbW1pbyIpKQorCQlyZXR1cm4gZmFsc2U7CisKKwlyZXR1 cm4gb2ZfcHJvcGVydHlfcmVhZF9ib29sKGRldi0+b2Zfbm9kZSwgInhlbixkZXYtZG9taWQiKTsK K30KK0VYUE9SVF9TWU1CT0xfR1BMKHhlbl9pc192aXJ0aW9fZGV2aWNlKTsKKwogdm9pZCB4ZW5f dmlydGlvX3NldHVwX2RtYV9vcHMoc3RydWN0IGRldmljZSAqZGV2KQogeworCXN0cnVjdCB4ZW5f dmlydGlvX2RhdGEgKmRhdGE7CisJdWludDMyX3QgZGV2X2RvbWlkOworCisJZGF0YSA9IGZpbmRf eGVuX3ZpcnRpb19kYXRhKGRldik7CisJaWYgKGRhdGEpIHsKKwkJZGV2X2VycihkZXYsICJ4ZW5f dmlydGlvIGRhdGEgaXMgYWxyZWFkeSBjcmVhdGVkXG4iKTsKKwkJcmV0dXJuOworCX0KKworCWlm IChkZXZfaXNfcGNpKGRldikpIHsKKwkJLyogWFhYIExlYXZlIGl0IGhhcmQgd2lyZWQgdG8gZG9t MCBmb3Igbm93ICovCisJCWRldl9kb21pZCA9IDA7CisJfSBlbHNlIGlmIChkZXYtPm9mX25vZGUp IHsKKwkJaWYgKG9mX3Byb3BlcnR5X3JlYWRfdTMyKGRldi0+b2Zfbm9kZSwgInhlbixkZXYtZG9t aWQiLCAmZGV2X2RvbWlkKSkgeworCQkJZGV2X2VycihkZXYsICJ4ZW4sZGV2LWRvbWlkIHByb3Bl cnR5IGlzIG5vdCBwcmVzZW50XG4iKTsKKwkJCWdvdG8gZXJyOworCQl9CisJfSBlbHNlCisJCS8q IFRoZSBBQ1BJIGNhc2UgaXMgbm90IHN1cHBvcnRlZCAqLworCQlnb3RvIGVycjsKKworCWRhdGEg PSBkZXZtX2t6YWxsb2MoZGV2LCBzaXplb2YoKmRhdGEpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWRh dGEpIHsKKwkJZGV2X2VycihkZXYsICLQoWFubm90IGFsbG9jYXRlIHhlbl92aXJ0aW8gZGF0YVxu Iik7CisJCWdvdG8gZXJyOworCX0KKwlkYXRhLT5kZXZfZG9taWQgPSBkZXZfZG9taWQ7CisJZGF0 YS0+ZGV2ID0gZGV2OworCXNwaW5fbG9ja19pbml0KCZkYXRhLT5sb2NrKTsKKworCXNwaW5fbG9j aygmeGVuX3ZpcnRpb19sb2NrKTsKKwlsaXN0X2FkZCgmZGF0YS0+bGlzdCwgJnhlbl92aXJ0aW9f ZGV2aWNlcyk7CisJc3Bpbl91bmxvY2soJnhlbl92aXJ0aW9fbG9jayk7CisKIAlkZXYtPmRtYV9v cHMgPSAmeGVuX3ZpcnRpb19kbWFfb3BzOworCisJcmV0dXJuOworCitlcnI6CisJZGV2X2Vycihk ZXYsICLQoWFubm90IHNldCB1cCB4ZW5fdmlydGlvIERNQSBvcHMsIHJldGFpbiBwbGF0Zm9ybSBE TUEgb3BzXG4iKTsKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKHhlbl92aXJ0aW9fc2V0dXBfZG1hX29w cyk7CiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUveGVuL3hlbi1vcHMuaCBiL2luY2x1ZGUveGVuL3hl bi1vcHMuaAppbmRleCBhZTNjMWJjLi5mZGJjYjk5IDEwMDY0NAotLS0gYS9pbmNsdWRlL3hlbi94 ZW4tb3BzLmgKKysrIGIvaW5jbHVkZS94ZW4veGVuLW9wcy5oCkBAIC0yMjMsMTAgKzIyMywxNSBA QCBzdGF0aWMgaW5saW5lIHZvaWQgeGVuX3ByZWVtcHRpYmxlX2hjYWxsX2VuZCh2b2lkKSB7IH0K IAogI2lmZGVmIENPTkZJR19YRU5fVklSVElPCiB2b2lkIHhlbl92aXJ0aW9fc2V0dXBfZG1hX29w cyhzdHJ1Y3QgZGV2aWNlICpkZXYpOworYm9vbCB4ZW5faXNfdmlydGlvX2RldmljZShzdHJ1Y3Qg ZGV2aWNlICpkZXYpOwogI2Vsc2UKIHN0YXRpYyBpbmxpbmUgdm9pZCB4ZW5fdmlydGlvX3NldHVw X2RtYV9vcHMoc3RydWN0IGRldmljZSAqZGV2KQogewogfQorc3RhdGljIGlubGluZSBib29sIHhl bl9pc192aXJ0aW9fZGV2aWNlKHN0cnVjdCBkZXZpY2UgKmRldikKK3sKKwlyZXR1cm4gZmFsc2U7 Cit9CiAjZW5kaWYgLyogQ09ORklHX1hFTl9WSVJUSU8gKi8KIAogI2VuZGlmIC8qIElOQ0xVREVf WEVOX09QU19IICovCi0tIAoyLjcuNAoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1r ZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWls bWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK