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 X-Spam-Level: X-Spam-Status: No, score=-17.3 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_CR_TRAILER,INCLUDES_PATCH,MAILING_LIST_MULTI,NICE_REPLY_A, SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_SANE_1 autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 4B505C43461 for ; Thu, 8 Apr 2021 02:36:54 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 21E9B61184 for ; Thu, 8 Apr 2021 02:36:54 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229831AbhDHChD (ORCPT ); Wed, 7 Apr 2021 22:37:03 -0400 Received: from us-smtp-delivery-124.mimecast.com ([216.205.24.124]:40843 "EHLO us-smtp-delivery-124.mimecast.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229600AbhDHChC (ORCPT ); Wed, 7 Apr 2021 22:37:02 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1617849411; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=6bIDlF6/Na7KbH3uL/VJXSdSX8DFa729DboJpmqpTTo=; b=O8ALbZp7r4J2ziUZsU0W/xmJcUEb7rhIWED3rz5fymGVYzk7EwnIuqMapul2CSsewRJrAO D/8NivpTCaAmIyhDlKRlfNMygWgy4usyTfIafAuWioKeMCMCqROgrUZDrSjc8I4043+MoD BkN82gcpZkD/qjN6yol40jfin1Rt9TA= Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-359-LcXRj1WPM_-7o8OuYqjwTg-1; Wed, 07 Apr 2021 22:36:47 -0400 X-MC-Unique: LcXRj1WPM_-7o8OuYqjwTg-1 Received: from smtp.corp.redhat.com (int-mx07.intmail.prod.int.phx2.redhat.com [10.5.11.22]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 3262764157; Thu, 8 Apr 2021 02:36:45 +0000 (UTC) Received: from wangxiaodeMacBook-Air.local (ovpn-12-194.pek2.redhat.com [10.72.12.194]) by smtp.corp.redhat.com (Postfix) with ESMTP id DBE1D10013D7; Thu, 8 Apr 2021 02:36:31 +0000 (UTC) Subject: Re: [PATCH v6 07/10] vdpa: Support transferring virtual addressing during DMA mapping To: Xie Yongji , mst@redhat.com, stefanha@redhat.com, sgarzare@redhat.com, parav@nvidia.com, hch@infradead.org, christian.brauner@canonical.com, rdunlap@infradead.org, willy@infradead.org, viro@zeniv.linux.org.uk, axboe@kernel.dk, bcrl@kvack.org, corbet@lwn.net, mika.penttila@nextfour.com, dan.carpenter@oracle.com Cc: virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, kvm@vger.kernel.org, linux-fsdevel@vger.kernel.org References: <20210331080519.172-1-xieyongji@bytedance.com> <20210331080519.172-8-xieyongji@bytedance.com> From: Jason Wang Message-ID: Date: Thu, 8 Apr 2021 10:36:30 +0800 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0) Gecko/20100101 Thunderbird/78.9.0 MIME-Version: 1.0 In-Reply-To: <20210331080519.172-8-xieyongji@bytedance.com> Content-Type: text/plain; charset=gbk; format=flowed Content-Transfer-Encoding: 8bit X-Scanned-By: MIMEDefang 2.84 on 10.5.11.22 Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org ÔÚ 2021/3/31 ÏÂÎç4:05, Xie Yongji дµÀ: > This patch introduces an attribute for vDPA device to indicate > whether virtual address can be used. If vDPA device driver set > it, vhost-vdpa bus driver will not pin user page and transfer > userspace virtual address instead of physical address during > DMA mapping. And corresponding vma->vm_file and offset will be > also passed as an opaque pointer. > > Suggested-by: Jason Wang > Signed-off-by: Xie Yongji Acked-by: Jason Wang > --- > drivers/vdpa/ifcvf/ifcvf_main.c | 2 +- > drivers/vdpa/mlx5/net/mlx5_vnet.c | 2 +- > drivers/vdpa/vdpa.c | 9 +++- > drivers/vdpa/vdpa_sim/vdpa_sim.c | 2 +- > drivers/vdpa/virtio_pci/vp_vdpa.c | 2 +- > drivers/vhost/vdpa.c | 99 ++++++++++++++++++++++++++++++++++----- > include/linux/vdpa.h | 19 ++++++-- > 7 files changed, 116 insertions(+), 19 deletions(-) > > diff --git a/drivers/vdpa/ifcvf/ifcvf_main.c b/drivers/vdpa/ifcvf/ifcvf_main.c > index d555a6a5d1ba..aee013f3eb5f 100644 > --- a/drivers/vdpa/ifcvf/ifcvf_main.c > +++ b/drivers/vdpa/ifcvf/ifcvf_main.c > @@ -431,7 +431,7 @@ static int ifcvf_probe(struct pci_dev *pdev, const struct pci_device_id *id) > } > > adapter = vdpa_alloc_device(struct ifcvf_adapter, vdpa, > - dev, &ifc_vdpa_ops, NULL); > + dev, &ifc_vdpa_ops, NULL, false); > if (adapter == NULL) { > IFCVF_ERR(pdev, "Failed to allocate vDPA structure"); > return -ENOMEM; > diff --git a/drivers/vdpa/mlx5/net/mlx5_vnet.c b/drivers/vdpa/mlx5/net/mlx5_vnet.c > index 71397fdafa6a..fb62ebcf464a 100644 > --- a/drivers/vdpa/mlx5/net/mlx5_vnet.c > +++ b/drivers/vdpa/mlx5/net/mlx5_vnet.c > @@ -1982,7 +1982,7 @@ static int mlx5v_probe(struct auxiliary_device *adev, > max_vqs = min_t(u32, max_vqs, MLX5_MAX_SUPPORTED_VQS); > > ndev = vdpa_alloc_device(struct mlx5_vdpa_net, mvdev.vdev, mdev->device, &mlx5_vdpa_ops, > - NULL); > + NULL, false); > if (IS_ERR(ndev)) > return PTR_ERR(ndev); > > diff --git a/drivers/vdpa/vdpa.c b/drivers/vdpa/vdpa.c > index 5cffce67cab0..97fbac276c72 100644 > --- a/drivers/vdpa/vdpa.c > +++ b/drivers/vdpa/vdpa.c > @@ -71,6 +71,7 @@ static void vdpa_release_dev(struct device *d) > * @config: the bus operations that is supported by this device > * @size: size of the parent structure that contains private data > * @name: name of the vdpa device; optional. > + * @use_va: indicate whether virtual address must be used by this device > * > * Driver should use vdpa_alloc_device() wrapper macro instead of > * using this directly. > @@ -80,7 +81,8 @@ static void vdpa_release_dev(struct device *d) > */ > struct vdpa_device *__vdpa_alloc_device(struct device *parent, > const struct vdpa_config_ops *config, > - size_t size, const char *name) > + size_t size, const char *name, > + bool use_va) > { > struct vdpa_device *vdev; > int err = -EINVAL; > @@ -91,6 +93,10 @@ struct vdpa_device *__vdpa_alloc_device(struct device *parent, > if (!!config->dma_map != !!config->dma_unmap) > goto err; > > + /* It should only work for the device that use on-chip IOMMU */ > + if (use_va && !(config->dma_map || config->set_map)) > + goto err; > + > err = -ENOMEM; > vdev = kzalloc(size, GFP_KERNEL); > if (!vdev) > @@ -106,6 +112,7 @@ struct vdpa_device *__vdpa_alloc_device(struct device *parent, > vdev->index = err; > vdev->config = config; > vdev->features_valid = false; > + vdev->use_va = use_va; > > if (name) > err = dev_set_name(&vdev->dev, "%s", name); > diff --git a/drivers/vdpa/vdpa_sim/vdpa_sim.c b/drivers/vdpa/vdpa_sim/vdpa_sim.c > index ff331f088baf..d26334e9a412 100644 > --- a/drivers/vdpa/vdpa_sim/vdpa_sim.c > +++ b/drivers/vdpa/vdpa_sim/vdpa_sim.c > @@ -235,7 +235,7 @@ struct vdpasim *vdpasim_create(struct vdpasim_dev_attr *dev_attr) > ops = &vdpasim_config_ops; > > vdpasim = vdpa_alloc_device(struct vdpasim, vdpa, NULL, ops, > - dev_attr->name); > + dev_attr->name, false); > if (!vdpasim) > goto err_alloc; > > diff --git a/drivers/vdpa/virtio_pci/vp_vdpa.c b/drivers/vdpa/virtio_pci/vp_vdpa.c > index 1321a2fcd088..03b36aed48d6 100644 > --- a/drivers/vdpa/virtio_pci/vp_vdpa.c > +++ b/drivers/vdpa/virtio_pci/vp_vdpa.c > @@ -377,7 +377,7 @@ static int vp_vdpa_probe(struct pci_dev *pdev, const struct pci_device_id *id) > return ret; > > vp_vdpa = vdpa_alloc_device(struct vp_vdpa, vdpa, > - dev, &vp_vdpa_ops, NULL); > + dev, &vp_vdpa_ops, NULL, false); > if (vp_vdpa == NULL) { > dev_err(dev, "vp_vdpa: Failed to allocate vDPA structure\n"); > return -ENOMEM; > diff --git a/drivers/vhost/vdpa.c b/drivers/vhost/vdpa.c > index f9aab9013745..613ea400e0e5 100644 > --- a/drivers/vhost/vdpa.c > +++ b/drivers/vhost/vdpa.c > @@ -505,8 +505,28 @@ static void vhost_vdpa_pa_unmap(struct vhost_vdpa *v, u64 start, u64 last) > } > } > > +static void vhost_vdpa_va_unmap(struct vhost_vdpa *v, u64 start, u64 last) > +{ > + struct vhost_dev *dev = &v->vdev; > + struct vhost_iotlb *iotlb = dev->iotlb; > + struct vhost_iotlb_map *map; > + struct vdpa_map_file *map_file; > + > + while ((map = vhost_iotlb_itree_first(iotlb, start, last)) != NULL) { > + map_file = (struct vdpa_map_file *)map->opaque; > + fput(map_file->file); > + kfree(map_file); > + vhost_iotlb_map_free(iotlb, map); > + } > +} > + > static void vhost_vdpa_iotlb_unmap(struct vhost_vdpa *v, u64 start, u64 last) > { > + struct vdpa_device *vdpa = v->vdpa; > + > + if (vdpa->use_va) > + return vhost_vdpa_va_unmap(v, start, last); > + > return vhost_vdpa_pa_unmap(v, start, last); > } > > @@ -541,21 +561,21 @@ static int perm_to_iommu_flags(u32 perm) > return flags | IOMMU_CACHE; > } > > -static int vhost_vdpa_map(struct vhost_vdpa *v, > - u64 iova, u64 size, u64 pa, u32 perm) > +static int vhost_vdpa_map(struct vhost_vdpa *v, u64 iova, > + u64 size, u64 pa, u32 perm, void *opaque) > { > struct vhost_dev *dev = &v->vdev; > struct vdpa_device *vdpa = v->vdpa; > const struct vdpa_config_ops *ops = vdpa->config; > int r = 0; > > - r = vhost_iotlb_add_range(dev->iotlb, iova, iova + size - 1, > - pa, perm); > + r = vhost_iotlb_add_range_ctx(dev->iotlb, iova, iova + size - 1, > + pa, perm, opaque); > if (r) > return r; > > if (ops->dma_map) { > - r = ops->dma_map(vdpa, iova, size, pa, perm, NULL); > + r = ops->dma_map(vdpa, iova, size, pa, perm, opaque); > } else if (ops->set_map) { > if (!v->in_batch) > r = ops->set_map(vdpa, dev->iotlb); > @@ -563,13 +583,15 @@ static int vhost_vdpa_map(struct vhost_vdpa *v, > r = iommu_map(v->domain, iova, pa, size, > perm_to_iommu_flags(perm)); > } > - > - if (r) > + if (r) { > vhost_iotlb_del_range(dev->iotlb, iova, iova + size - 1); > - else > + return r; > + } > + > + if (!vdpa->use_va) > atomic64_add(size >> PAGE_SHIFT, &dev->mm->pinned_vm); > > - return r; > + return 0; > } > > static void vhost_vdpa_unmap(struct vhost_vdpa *v, u64 iova, u64 size) > @@ -590,6 +612,56 @@ static void vhost_vdpa_unmap(struct vhost_vdpa *v, u64 iova, u64 size) > } > } > > +static int vhost_vdpa_va_map(struct vhost_vdpa *v, > + u64 iova, u64 size, u64 uaddr, u32 perm) > +{ > + struct vhost_dev *dev = &v->vdev; > + u64 offset, map_size, map_iova = iova; > + struct vdpa_map_file *map_file; > + struct vm_area_struct *vma; > + int ret; > + > + mmap_read_lock(dev->mm); > + > + while (size) { > + vma = find_vma(dev->mm, uaddr); > + if (!vma) { > + ret = -EINVAL; > + break; > + } > + map_size = min(size, vma->vm_end - uaddr); > + if (!(vma->vm_file && (vma->vm_flags & VM_SHARED) && > + !(vma->vm_flags & (VM_IO | VM_PFNMAP)))) > + goto next; > + > + map_file = kzalloc(sizeof(*map_file), GFP_KERNEL); > + if (!map_file) { > + ret = -ENOMEM; > + break; > + } > + offset = (vma->vm_pgoff << PAGE_SHIFT) + uaddr - vma->vm_start; > + map_file->offset = offset; > + map_file->file = get_file(vma->vm_file); > + ret = vhost_vdpa_map(v, map_iova, map_size, uaddr, > + perm, map_file); > + if (ret) { > + fput(map_file->file); > + kfree(map_file); > + break; > + } > +next: > + size -= map_size; > + uaddr += map_size; > + map_iova += map_size; > + } > + if (ret) > + vhost_vdpa_unmap(v, iova, map_iova - iova); > + > + mmap_read_unlock(dev->mm); > + > + return ret; > +} > + > static int vhost_vdpa_pa_map(struct vhost_vdpa *v, > u64 iova, u64 size, u64 uaddr, u32 perm) > { > @@ -656,7 +728,7 @@ static int vhost_vdpa_pa_map(struct vhost_vdpa *v, > csize = (last_pfn - map_pfn + 1) << PAGE_SHIFT; > ret = vhost_vdpa_map(v, iova, csize, > map_pfn << PAGE_SHIFT, > - perm); > + perm, NULL); > if (ret) { > /* > * Unpin the pages that are left unmapped > @@ -685,7 +757,7 @@ static int vhost_vdpa_pa_map(struct vhost_vdpa *v, > > /* Pin the rest chunk */ > ret = vhost_vdpa_map(v, iova, (last_pfn - map_pfn + 1) << PAGE_SHIFT, > - map_pfn << PAGE_SHIFT, perm); > + map_pfn << PAGE_SHIFT, perm, NULL); > out: > if (ret) { > if (nchunks) { > @@ -718,6 +790,7 @@ static int vhost_vdpa_process_iotlb_update(struct vhost_vdpa *v, > struct vhost_iotlb_msg *msg) > { > struct vhost_dev *dev = &v->vdev; > + struct vdpa_device *vdpa = v->vdpa; > struct vhost_iotlb *iotlb = dev->iotlb; > > if (msg->iova < v->range.first || > @@ -728,6 +801,10 @@ static int vhost_vdpa_process_iotlb_update(struct vhost_vdpa *v, > msg->iova + msg->size - 1)) > return -EEXIST; > > + if (vdpa->use_va) > + return vhost_vdpa_va_map(v, msg->iova, msg->size, > + msg->uaddr, msg->perm); > + > return vhost_vdpa_pa_map(v, msg->iova, msg->size, msg->uaddr, > msg->perm); > } > diff --git a/include/linux/vdpa.h b/include/linux/vdpa.h > index b01f7c9096bf..e67404e4b23e 100644 > --- a/include/linux/vdpa.h > +++ b/include/linux/vdpa.h > @@ -44,6 +44,7 @@ struct vdpa_mgmt_dev; > * @config: the configuration ops for this device. > * @index: device index > * @features_valid: were features initialized? for legacy guests > + * @use_va: indicate whether virtual address must be used by this device > * @nvqs: maximum number of supported virtqueues > * @mdev: management device pointer; caller must setup when registering device as part > * of dev_add() mgmtdev ops callback before invoking _vdpa_register_device(). > @@ -54,6 +55,7 @@ struct vdpa_device { > const struct vdpa_config_ops *config; > unsigned int index; > bool features_valid; > + bool use_va; > int nvqs; > struct vdpa_mgmt_dev *mdev; > }; > @@ -69,6 +71,16 @@ struct vdpa_iova_range { > }; > > /** > + * Corresponding file area for device memory mapping > + * @file: vma->vm_file for the mapping > + * @offset: mapping offset in the vm_file > + */ > +struct vdpa_map_file { > + struct file *file; > + u64 offset; > +}; > + > +/** > * vDPA_config_ops - operations for configuring a vDPA device. > * Note: vDPA device drivers are required to implement all of the > * operations unless it is mentioned to be optional in the following > @@ -250,14 +262,15 @@ struct vdpa_config_ops { > > struct vdpa_device *__vdpa_alloc_device(struct device *parent, > const struct vdpa_config_ops *config, > - size_t size, const char *name); > + size_t size, const char *name, > + bool use_va); > > -#define vdpa_alloc_device(dev_struct, member, parent, config, name) \ > +#define vdpa_alloc_device(dev_struct, member, parent, config, name, use_va) \ > container_of(__vdpa_alloc_device( \ > parent, config, \ > sizeof(dev_struct) + \ > BUILD_BUG_ON_ZERO(offsetof( \ > - dev_struct, member)), name), \ > + dev_struct, member)), name, use_va), \ > dev_struct, member) > > int vdpa_register_device(struct vdpa_device *vdev, int nvqs); 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 X-Spam-Level: X-Spam-Status: No, score=-15.1 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,NICE_REPLY_A,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED, USER_AGENT_SANE_1 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3D569C433B4 for ; Thu, 8 Apr 2021 02:36:56 +0000 (UTC) Received: from smtp3.osuosl.org (smtp3.osuosl.org [140.211.166.136]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id C33B561184 for ; Thu, 8 Apr 2021 02:36:55 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org C33B561184 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=virtualization-bounces@lists.linux-foundation.org Received: from localhost (localhost [127.0.0.1]) by smtp3.osuosl.org (Postfix) with ESMTP id 80BF060E2E; Thu, 8 Apr 2021 02:36:55 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp3.osuosl.org ([127.0.0.1]) by localhost (smtp3.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id FrSjwvYZRNcz; Thu, 8 Apr 2021 02:36:54 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [IPv6:2605:bc80:3010:104::8cd3:938]) by smtp3.osuosl.org (Postfix) with ESMTP id B0ED960D9C; Thu, 8 Apr 2021 02:36:53 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 84B92C000B; Thu, 8 Apr 2021 02:36:53 +0000 (UTC) Received: from smtp1.osuosl.org (smtp1.osuosl.org [140.211.166.138]) by lists.linuxfoundation.org (Postfix) with ESMTP id E0447C000A for ; Thu, 8 Apr 2021 02:36:52 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp1.osuosl.org (Postfix) with ESMTP id C17E884DB0 for ; Thu, 8 Apr 2021 02:36:52 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Authentication-Results: smtp1.osuosl.org (amavisd-new); dkim=pass (1024-bit key) header.d=redhat.com Received: from smtp1.osuosl.org ([127.0.0.1]) by localhost (smtp1.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 6fKauZSI-eST for ; Thu, 8 Apr 2021 02:36:51 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.8.0 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [216.205.24.124]) by smtp1.osuosl.org (Postfix) with ESMTPS id ECAD984DAC for ; Thu, 8 Apr 2021 02:36:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1617849409; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=6bIDlF6/Na7KbH3uL/VJXSdSX8DFa729DboJpmqpTTo=; b=jMJtk1sT0TnnnZL5BcyQT00qgM8KSpGk5hpZCqpLvef5qzPjeyFqN0cRphiBUlNup28uFX xmWDvekdmmL66o467et+Yzi1EzmnOYzYaFhR9PO4QzN1wDc9s8d1ZWGqj/K8OCxFRYki2U f8VdkNN58dmZ7SnytlEqXQwf2HA7ZW8= Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-359-LcXRj1WPM_-7o8OuYqjwTg-1; Wed, 07 Apr 2021 22:36:47 -0400 X-MC-Unique: LcXRj1WPM_-7o8OuYqjwTg-1 Received: from smtp.corp.redhat.com (int-mx07.intmail.prod.int.phx2.redhat.com [10.5.11.22]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 3262764157; Thu, 8 Apr 2021 02:36:45 +0000 (UTC) Received: from wangxiaodeMacBook-Air.local (ovpn-12-194.pek2.redhat.com [10.72.12.194]) by smtp.corp.redhat.com (Postfix) with ESMTP id DBE1D10013D7; Thu, 8 Apr 2021 02:36:31 +0000 (UTC) Subject: Re: [PATCH v6 07/10] vdpa: Support transferring virtual addressing during DMA mapping To: Xie Yongji , mst@redhat.com, stefanha@redhat.com, sgarzare@redhat.com, parav@nvidia.com, hch@infradead.org, christian.brauner@canonical.com, rdunlap@infradead.org, willy@infradead.org, viro@zeniv.linux.org.uk, axboe@kernel.dk, bcrl@kvack.org, corbet@lwn.net, mika.penttila@nextfour.com, dan.carpenter@oracle.com References: <20210331080519.172-1-xieyongji@bytedance.com> <20210331080519.172-8-xieyongji@bytedance.com> From: Jason Wang Message-ID: Date: Thu, 8 Apr 2021 10:36:30 +0800 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0) Gecko/20100101 Thunderbird/78.9.0 MIME-Version: 1.0 In-Reply-To: <20210331080519.172-8-xieyongji@bytedance.com> X-Scanned-By: MIMEDefang 2.84 on 10.5.11.22 Cc: linux-fsdevel@vger.kernel.org, netdev@vger.kernel.org, kvm@vger.kernel.org, virtualization@lists.linux-foundation.org X-BeenThere: virtualization@lists.linux-foundation.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: Linux virtualization List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="gbk"; Format="flowed" Errors-To: virtualization-bounces@lists.linux-foundation.org Sender: "Virtualization" CtTaIDIwMjEvMy8zMSDPws7nNDowNSwgWGllIFlvbmdqaSDQtLXAOgo+IFRoaXMgcGF0Y2ggaW50 cm9kdWNlcyBhbiBhdHRyaWJ1dGUgZm9yIHZEUEEgZGV2aWNlIHRvIGluZGljYXRlCj4gd2hldGhl ciB2aXJ0dWFsIGFkZHJlc3MgY2FuIGJlIHVzZWQuIElmIHZEUEEgZGV2aWNlIGRyaXZlciBzZXQK PiBpdCwgdmhvc3QtdmRwYSBidXMgZHJpdmVyIHdpbGwgbm90IHBpbiB1c2VyIHBhZ2UgYW5kIHRy YW5zZmVyCj4gdXNlcnNwYWNlIHZpcnR1YWwgYWRkcmVzcyBpbnN0ZWFkIG9mIHBoeXNpY2FsIGFk ZHJlc3MgZHVyaW5nCj4gRE1BIG1hcHBpbmcuIEFuZCBjb3JyZXNwb25kaW5nIHZtYS0+dm1fZmls ZSBhbmQgb2Zmc2V0IHdpbGwgYmUKPiBhbHNvIHBhc3NlZCBhcyBhbiBvcGFxdWUgcG9pbnRlci4K Pgo+IFN1Z2dlc3RlZC1ieTogSmFzb24gV2FuZyA8amFzb3dhbmdAcmVkaGF0LmNvbT4KPiBTaWdu ZWQtb2ZmLWJ5OiBYaWUgWW9uZ2ppIDx4aWV5b25namlAYnl0ZWRhbmNlLmNvbT4KCgpBY2tlZC1i eTogSmFzb24gV2FuZyA8amFzb3dhbmdAcmVkaGF0LmNvbT4KCgo+IC0tLQo+ICAgZHJpdmVycy92 ZHBhL2lmY3ZmL2lmY3ZmX21haW4uYyAgIHwgIDIgKy0KPiAgIGRyaXZlcnMvdmRwYS9tbHg1L25l dC9tbHg1X3ZuZXQuYyB8ICAyICstCj4gICBkcml2ZXJzL3ZkcGEvdmRwYS5jICAgICAgICAgICAg ICAgfCAgOSArKystCj4gICBkcml2ZXJzL3ZkcGEvdmRwYV9zaW0vdmRwYV9zaW0uYyAgfCAgMiAr LQo+ICAgZHJpdmVycy92ZHBhL3ZpcnRpb19wY2kvdnBfdmRwYS5jIHwgIDIgKy0KPiAgIGRyaXZl cnMvdmhvc3QvdmRwYS5jICAgICAgICAgICAgICB8IDk5ICsrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKystLS0tLQo+ICAgaW5jbHVkZS9saW51eC92ZHBhLmggICAgICAgICAgICAgIHwg MTkgKysrKysrLS0KPiAgIDcgZmlsZXMgY2hhbmdlZCwgMTE2IGluc2VydGlvbnMoKyksIDE5IGRl bGV0aW9ucygtKQo+Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmRwYS9pZmN2Zi9pZmN2Zl9tYWlu LmMgYi9kcml2ZXJzL3ZkcGEvaWZjdmYvaWZjdmZfbWFpbi5jCj4gaW5kZXggZDU1NWE2YTVkMWJh Li5hZWUwMTNmM2ViNWYgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy92ZHBhL2lmY3ZmL2lmY3ZmX21h aW4uYwo+ICsrKyBiL2RyaXZlcnMvdmRwYS9pZmN2Zi9pZmN2Zl9tYWluLmMKPiBAQCAtNDMxLDcg KzQzMSw3IEBAIHN0YXRpYyBpbnQgaWZjdmZfcHJvYmUoc3RydWN0IHBjaV9kZXYgKnBkZXYsIGNv bnN0IHN0cnVjdCBwY2lfZGV2aWNlX2lkICppZCkKPiAgIAl9Cj4gICAKPiAgIAlhZGFwdGVyID0g dmRwYV9hbGxvY19kZXZpY2Uoc3RydWN0IGlmY3ZmX2FkYXB0ZXIsIHZkcGEsCj4gLQkJCQkgICAg ZGV2LCAmaWZjX3ZkcGFfb3BzLCBOVUxMKTsKPiArCQkJCSAgICBkZXYsICZpZmNfdmRwYV9vcHMs IE5VTEwsIGZhbHNlKTsKPiAgIAlpZiAoYWRhcHRlciA9PSBOVUxMKSB7Cj4gICAJCUlGQ1ZGX0VS UihwZGV2LCAiRmFpbGVkIHRvIGFsbG9jYXRlIHZEUEEgc3RydWN0dXJlIik7Cj4gICAJCXJldHVy biAtRU5PTUVNOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3ZkcGEvbWx4NS9uZXQvbWx4NV92bmV0 LmMgYi9kcml2ZXJzL3ZkcGEvbWx4NS9uZXQvbWx4NV92bmV0LmMKPiBpbmRleCA3MTM5N2ZkYWZh NmEuLmZiNjJlYmNmNDY0YSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL3ZkcGEvbWx4NS9uZXQvbWx4 NV92bmV0LmMKPiArKysgYi9kcml2ZXJzL3ZkcGEvbWx4NS9uZXQvbWx4NV92bmV0LmMKPiBAQCAt MTk4Miw3ICsxOTgyLDcgQEAgc3RhdGljIGludCBtbHg1dl9wcm9iZShzdHJ1Y3QgYXV4aWxpYXJ5 X2RldmljZSAqYWRldiwKPiAgIAltYXhfdnFzID0gbWluX3QodTMyLCBtYXhfdnFzLCBNTFg1X01B WF9TVVBQT1JURURfVlFTKTsKPiAgIAo+ICAgCW5kZXYgPSB2ZHBhX2FsbG9jX2RldmljZShzdHJ1 Y3QgbWx4NV92ZHBhX25ldCwgbXZkZXYudmRldiwgbWRldi0+ZGV2aWNlLCAmbWx4NV92ZHBhX29w cywKPiAtCQkJCSBOVUxMKTsKPiArCQkJCSBOVUxMLCBmYWxzZSk7Cj4gICAJaWYgKElTX0VSUihu ZGV2KSkKPiAgIAkJcmV0dXJuIFBUUl9FUlIobmRldik7Cj4gICAKPiBkaWZmIC0tZ2l0IGEvZHJp dmVycy92ZHBhL3ZkcGEuYyBiL2RyaXZlcnMvdmRwYS92ZHBhLmMKPiBpbmRleCA1Y2ZmY2U2N2Nh YjAuLjk3ZmJhYzI3NmM3MiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL3ZkcGEvdmRwYS5jCj4gKysr IGIvZHJpdmVycy92ZHBhL3ZkcGEuYwo+IEBAIC03MSw2ICs3MSw3IEBAIHN0YXRpYyB2b2lkIHZk cGFfcmVsZWFzZV9kZXYoc3RydWN0IGRldmljZSAqZCkKPiAgICAqIEBjb25maWc6IHRoZSBidXMg b3BlcmF0aW9ucyB0aGF0IGlzIHN1cHBvcnRlZCBieSB0aGlzIGRldmljZQo+ICAgICogQHNpemU6 IHNpemUgb2YgdGhlIHBhcmVudCBzdHJ1Y3R1cmUgdGhhdCBjb250YWlucyBwcml2YXRlIGRhdGEK PiAgICAqIEBuYW1lOiBuYW1lIG9mIHRoZSB2ZHBhIGRldmljZTsgb3B0aW9uYWwuCj4gKyAqIEB1 c2VfdmE6IGluZGljYXRlIHdoZXRoZXIgdmlydHVhbCBhZGRyZXNzIG11c3QgYmUgdXNlZCBieSB0 aGlzIGRldmljZQo+ICAgICoKPiAgICAqIERyaXZlciBzaG91bGQgdXNlIHZkcGFfYWxsb2NfZGV2 aWNlKCkgd3JhcHBlciBtYWNybyBpbnN0ZWFkIG9mCj4gICAgKiB1c2luZyB0aGlzIGRpcmVjdGx5 Lgo+IEBAIC04MCw3ICs4MSw4IEBAIHN0YXRpYyB2b2lkIHZkcGFfcmVsZWFzZV9kZXYoc3RydWN0 IGRldmljZSAqZCkKPiAgICAqLwo+ICAgc3RydWN0IHZkcGFfZGV2aWNlICpfX3ZkcGFfYWxsb2Nf ZGV2aWNlKHN0cnVjdCBkZXZpY2UgKnBhcmVudCwKPiAgIAkJCQkJY29uc3Qgc3RydWN0IHZkcGFf Y29uZmlnX29wcyAqY29uZmlnLAo+IC0JCQkJCXNpemVfdCBzaXplLCBjb25zdCBjaGFyICpuYW1l KQo+ICsJCQkJCXNpemVfdCBzaXplLCBjb25zdCBjaGFyICpuYW1lLAo+ICsJCQkJCWJvb2wgdXNl X3ZhKQo+ICAgewo+ICAgCXN0cnVjdCB2ZHBhX2RldmljZSAqdmRldjsKPiAgIAlpbnQgZXJyID0g LUVJTlZBTDsKPiBAQCAtOTEsNiArOTMsMTAgQEAgc3RydWN0IHZkcGFfZGV2aWNlICpfX3ZkcGFf YWxsb2NfZGV2aWNlKHN0cnVjdCBkZXZpY2UgKnBhcmVudCwKPiAgIAlpZiAoISFjb25maWctPmRt YV9tYXAgIT0gISFjb25maWctPmRtYV91bm1hcCkKPiAgIAkJZ290byBlcnI7Cj4gICAKPiArCS8q IEl0IHNob3VsZCBvbmx5IHdvcmsgZm9yIHRoZSBkZXZpY2UgdGhhdCB1c2Ugb24tY2hpcCBJT01N VSAqLwo+ICsJaWYgKHVzZV92YSAmJiAhKGNvbmZpZy0+ZG1hX21hcCB8fCBjb25maWctPnNldF9t YXApKQo+ICsJCWdvdG8gZXJyOwo+ICsKPiAgIAllcnIgPSAtRU5PTUVNOwo+ICAgCXZkZXYgPSBr emFsbG9jKHNpemUsIEdGUF9LRVJORUwpOwo+ICAgCWlmICghdmRldikKPiBAQCAtMTA2LDYgKzEx Miw3IEBAIHN0cnVjdCB2ZHBhX2RldmljZSAqX192ZHBhX2FsbG9jX2RldmljZShzdHJ1Y3QgZGV2 aWNlICpwYXJlbnQsCj4gICAJdmRldi0+aW5kZXggPSBlcnI7Cj4gICAJdmRldi0+Y29uZmlnID0g Y29uZmlnOwo+ICAgCXZkZXYtPmZlYXR1cmVzX3ZhbGlkID0gZmFsc2U7Cj4gKwl2ZGV2LT51c2Vf dmEgPSB1c2VfdmE7Cj4gICAKPiAgIAlpZiAobmFtZSkKPiAgIAkJZXJyID0gZGV2X3NldF9uYW1l KCZ2ZGV2LT5kZXYsICIlcyIsIG5hbWUpOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3ZkcGEvdmRw YV9zaW0vdmRwYV9zaW0uYyBiL2RyaXZlcnMvdmRwYS92ZHBhX3NpbS92ZHBhX3NpbS5jCj4gaW5k ZXggZmYzMzFmMDg4YmFmLi5kMjYzMzRlOWE0MTIgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy92ZHBh L3ZkcGFfc2ltL3ZkcGFfc2ltLmMKPiArKysgYi9kcml2ZXJzL3ZkcGEvdmRwYV9zaW0vdmRwYV9z aW0uYwo+IEBAIC0yMzUsNyArMjM1LDcgQEAgc3RydWN0IHZkcGFzaW0gKnZkcGFzaW1fY3JlYXRl KHN0cnVjdCB2ZHBhc2ltX2Rldl9hdHRyICpkZXZfYXR0cikKPiAgIAkJb3BzID0gJnZkcGFzaW1f Y29uZmlnX29wczsKPiAgIAo+ICAgCXZkcGFzaW0gPSB2ZHBhX2FsbG9jX2RldmljZShzdHJ1Y3Qg dmRwYXNpbSwgdmRwYSwgTlVMTCwgb3BzLAo+IC0JCQkJICAgIGRldl9hdHRyLT5uYW1lKTsKPiAr CQkJCSAgICBkZXZfYXR0ci0+bmFtZSwgZmFsc2UpOwo+ICAgCWlmICghdmRwYXNpbSkKPiAgIAkJ Z290byBlcnJfYWxsb2M7Cj4gICAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy92ZHBhL3ZpcnRpb19w Y2kvdnBfdmRwYS5jIGIvZHJpdmVycy92ZHBhL3ZpcnRpb19wY2kvdnBfdmRwYS5jCj4gaW5kZXgg MTMyMWEyZmNkMDg4Li4wM2IzNmFlZDQ4ZDYgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy92ZHBhL3Zp cnRpb19wY2kvdnBfdmRwYS5jCj4gKysrIGIvZHJpdmVycy92ZHBhL3ZpcnRpb19wY2kvdnBfdmRw YS5jCj4gQEAgLTM3Nyw3ICszNzcsNyBAQCBzdGF0aWMgaW50IHZwX3ZkcGFfcHJvYmUoc3RydWN0 IHBjaV9kZXYgKnBkZXYsIGNvbnN0IHN0cnVjdCBwY2lfZGV2aWNlX2lkICppZCkKPiAgIAkJcmV0 dXJuIHJldDsKPiAgIAo+ICAgCXZwX3ZkcGEgPSB2ZHBhX2FsbG9jX2RldmljZShzdHJ1Y3QgdnBf dmRwYSwgdmRwYSwKPiAtCQkJCSAgICBkZXYsICZ2cF92ZHBhX29wcywgTlVMTCk7Cj4gKwkJCQkg ICAgZGV2LCAmdnBfdmRwYV9vcHMsIE5VTEwsIGZhbHNlKTsKPiAgIAlpZiAodnBfdmRwYSA9PSBO VUxMKSB7Cj4gICAJCWRldl9lcnIoZGV2LCAidnBfdmRwYTogRmFpbGVkIHRvIGFsbG9jYXRlIHZE UEEgc3RydWN0dXJlXG4iKTsKPiAgIAkJcmV0dXJuIC1FTk9NRU07Cj4gZGlmZiAtLWdpdCBhL2Ry aXZlcnMvdmhvc3QvdmRwYS5jIGIvZHJpdmVycy92aG9zdC92ZHBhLmMKPiBpbmRleCBmOWFhYjkw MTM3NDUuLjYxM2VhNDAwZTBlNSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL3Zob3N0L3ZkcGEuYwo+ ICsrKyBiL2RyaXZlcnMvdmhvc3QvdmRwYS5jCj4gQEAgLTUwNSw4ICs1MDUsMjggQEAgc3RhdGlj IHZvaWQgdmhvc3RfdmRwYV9wYV91bm1hcChzdHJ1Y3Qgdmhvc3RfdmRwYSAqdiwgdTY0IHN0YXJ0 LCB1NjQgbGFzdCkKPiAgIAl9Cj4gICB9Cj4gICAKPiArc3RhdGljIHZvaWQgdmhvc3RfdmRwYV92 YV91bm1hcChzdHJ1Y3Qgdmhvc3RfdmRwYSAqdiwgdTY0IHN0YXJ0LCB1NjQgbGFzdCkKPiArewo+ ICsJc3RydWN0IHZob3N0X2RldiAqZGV2ID0gJnYtPnZkZXY7Cj4gKwlzdHJ1Y3Qgdmhvc3RfaW90 bGIgKmlvdGxiID0gZGV2LT5pb3RsYjsKPiArCXN0cnVjdCB2aG9zdF9pb3RsYl9tYXAgKm1hcDsK PiArCXN0cnVjdCB2ZHBhX21hcF9maWxlICptYXBfZmlsZTsKPiArCj4gKwl3aGlsZSAoKG1hcCA9 IHZob3N0X2lvdGxiX2l0cmVlX2ZpcnN0KGlvdGxiLCBzdGFydCwgbGFzdCkpICE9IE5VTEwpIHsK PiArCQltYXBfZmlsZSA9IChzdHJ1Y3QgdmRwYV9tYXBfZmlsZSAqKW1hcC0+b3BhcXVlOwo+ICsJ CWZwdXQobWFwX2ZpbGUtPmZpbGUpOwo+ICsJCWtmcmVlKG1hcF9maWxlKTsKPiArCQl2aG9zdF9p b3RsYl9tYXBfZnJlZShpb3RsYiwgbWFwKTsKPiArCX0KPiArfQo+ICsKPiAgIHN0YXRpYyB2b2lk IHZob3N0X3ZkcGFfaW90bGJfdW5tYXAoc3RydWN0IHZob3N0X3ZkcGEgKnYsIHU2NCBzdGFydCwg dTY0IGxhc3QpCj4gICB7Cj4gKwlzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGEgPSB2LT52ZHBhOwo+ ICsKPiArCWlmICh2ZHBhLT51c2VfdmEpCj4gKwkJcmV0dXJuIHZob3N0X3ZkcGFfdmFfdW5tYXAo diwgc3RhcnQsIGxhc3QpOwo+ICsKPiAgIAlyZXR1cm4gdmhvc3RfdmRwYV9wYV91bm1hcCh2LCBz dGFydCwgbGFzdCk7Cj4gICB9Cj4gICAKPiBAQCAtNTQxLDIxICs1NjEsMjEgQEAgc3RhdGljIGlu dCBwZXJtX3RvX2lvbW11X2ZsYWdzKHUzMiBwZXJtKQo+ICAgCXJldHVybiBmbGFncyB8IElPTU1V X0NBQ0hFOwo+ICAgfQo+ICAgCj4gLXN0YXRpYyBpbnQgdmhvc3RfdmRwYV9tYXAoc3RydWN0IHZo b3N0X3ZkcGEgKnYsCj4gLQkJCSAgdTY0IGlvdmEsIHU2NCBzaXplLCB1NjQgcGEsIHUzMiBwZXJt KQo+ICtzdGF0aWMgaW50IHZob3N0X3ZkcGFfbWFwKHN0cnVjdCB2aG9zdF92ZHBhICp2LCB1NjQg aW92YSwKPiArCQkJICB1NjQgc2l6ZSwgdTY0IHBhLCB1MzIgcGVybSwgdm9pZCAqb3BhcXVlKQo+ ICAgewo+ICAgCXN0cnVjdCB2aG9zdF9kZXYgKmRldiA9ICZ2LT52ZGV2Owo+ICAgCXN0cnVjdCB2 ZHBhX2RldmljZSAqdmRwYSA9IHYtPnZkcGE7Cj4gICAJY29uc3Qgc3RydWN0IHZkcGFfY29uZmln X29wcyAqb3BzID0gdmRwYS0+Y29uZmlnOwo+ICAgCWludCByID0gMDsKPiAgIAo+IC0JciA9IHZo b3N0X2lvdGxiX2FkZF9yYW5nZShkZXYtPmlvdGxiLCBpb3ZhLCBpb3ZhICsgc2l6ZSAtIDEsCj4g LQkJCQkgIHBhLCBwZXJtKTsKPiArCXIgPSB2aG9zdF9pb3RsYl9hZGRfcmFuZ2VfY3R4KGRldi0+ aW90bGIsIGlvdmEsIGlvdmEgKyBzaXplIC0gMSwKPiArCQkJCSAgICAgIHBhLCBwZXJtLCBvcGFx dWUpOwo+ICAgCWlmIChyKQo+ICAgCQlyZXR1cm4gcjsKPiAgIAo+ICAgCWlmIChvcHMtPmRtYV9t YXApIHsKPiAtCQlyID0gb3BzLT5kbWFfbWFwKHZkcGEsIGlvdmEsIHNpemUsIHBhLCBwZXJtLCBO VUxMKTsKPiArCQlyID0gb3BzLT5kbWFfbWFwKHZkcGEsIGlvdmEsIHNpemUsIHBhLCBwZXJtLCBv cGFxdWUpOwo+ICAgCX0gZWxzZSBpZiAob3BzLT5zZXRfbWFwKSB7Cj4gICAJCWlmICghdi0+aW5f YmF0Y2gpCj4gICAJCQlyID0gb3BzLT5zZXRfbWFwKHZkcGEsIGRldi0+aW90bGIpOwo+IEBAIC01 NjMsMTMgKzU4MywxNSBAQCBzdGF0aWMgaW50IHZob3N0X3ZkcGFfbWFwKHN0cnVjdCB2aG9zdF92 ZHBhICp2LAo+ICAgCQlyID0gaW9tbXVfbWFwKHYtPmRvbWFpbiwgaW92YSwgcGEsIHNpemUsCj4g ICAJCQkgICAgICBwZXJtX3RvX2lvbW11X2ZsYWdzKHBlcm0pKTsKPiAgIAl9Cj4gLQo+IC0JaWYg KHIpCj4gKwlpZiAocikgewo+ICAgCQl2aG9zdF9pb3RsYl9kZWxfcmFuZ2UoZGV2LT5pb3RsYiwg aW92YSwgaW92YSArIHNpemUgLSAxKTsKPiAtCWVsc2UKPiArCQlyZXR1cm4gcjsKPiArCX0KPiAr Cj4gKwlpZiAoIXZkcGEtPnVzZV92YSkKPiAgIAkJYXRvbWljNjRfYWRkKHNpemUgPj4gUEFHRV9T SElGVCwgJmRldi0+bW0tPnBpbm5lZF92bSk7Cj4gICAKPiAtCXJldHVybiByOwo+ICsJcmV0dXJu IDA7Cj4gICB9Cj4gICAKPiAgIHN0YXRpYyB2b2lkIHZob3N0X3ZkcGFfdW5tYXAoc3RydWN0IHZo b3N0X3ZkcGEgKnYsIHU2NCBpb3ZhLCB1NjQgc2l6ZSkKPiBAQCAtNTkwLDYgKzYxMiw1NiBAQCBz dGF0aWMgdm9pZCB2aG9zdF92ZHBhX3VubWFwKHN0cnVjdCB2aG9zdF92ZHBhICp2LCB1NjQgaW92 YSwgdTY0IHNpemUpCj4gICAJfQo+ICAgfQo+ICAgCj4gK3N0YXRpYyBpbnQgdmhvc3RfdmRwYV92 YV9tYXAoc3RydWN0IHZob3N0X3ZkcGEgKnYsCj4gKwkJCSAgICAgdTY0IGlvdmEsIHU2NCBzaXpl LCB1NjQgdWFkZHIsIHUzMiBwZXJtKQo+ICt7Cj4gKwlzdHJ1Y3Qgdmhvc3RfZGV2ICpkZXYgPSAm di0+dmRldjsKPiArCXU2NCBvZmZzZXQsIG1hcF9zaXplLCBtYXBfaW92YSA9IGlvdmE7Cj4gKwlz dHJ1Y3QgdmRwYV9tYXBfZmlsZSAqbWFwX2ZpbGU7Cj4gKwlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3Qg KnZtYTsKPiArCWludCByZXQ7Cj4gKwo+ICsJbW1hcF9yZWFkX2xvY2soZGV2LT5tbSk7Cj4gKwo+ ICsJd2hpbGUgKHNpemUpIHsKPiArCQl2bWEgPSBmaW5kX3ZtYShkZXYtPm1tLCB1YWRkcik7Cj4g KwkJaWYgKCF2bWEpIHsKPiArCQkJcmV0ID0gLUVJTlZBTDsKPiArCQkJYnJlYWs7Cj4gKwkJfQo+ ICsJCW1hcF9zaXplID0gbWluKHNpemUsIHZtYS0+dm1fZW5kIC0gdWFkZHIpOwo+ICsJCWlmICgh KHZtYS0+dm1fZmlsZSAmJiAodm1hLT52bV9mbGFncyAmIFZNX1NIQVJFRCkgJiYKPiArCQkJISh2 bWEtPnZtX2ZsYWdzICYgKFZNX0lPIHwgVk1fUEZOTUFQKSkpKQo+ICsJCQlnb3RvIG5leHQ7Cj4g Kwo+ICsJCW1hcF9maWxlID0ga3phbGxvYyhzaXplb2YoKm1hcF9maWxlKSwgR0ZQX0tFUk5FTCk7 Cj4gKwkJaWYgKCFtYXBfZmlsZSkgewo+ICsJCQlyZXQgPSAtRU5PTUVNOwo+ICsJCQlicmVhazsK PiArCQl9Cj4gKwkJb2Zmc2V0ID0gKHZtYS0+dm1fcGdvZmYgPDwgUEFHRV9TSElGVCkgKyB1YWRk ciAtIHZtYS0+dm1fc3RhcnQ7Cj4gKwkJbWFwX2ZpbGUtPm9mZnNldCA9IG9mZnNldDsKPiArCQlt YXBfZmlsZS0+ZmlsZSA9IGdldF9maWxlKHZtYS0+dm1fZmlsZSk7Cj4gKwkJcmV0ID0gdmhvc3Rf dmRwYV9tYXAodiwgbWFwX2lvdmEsIG1hcF9zaXplLCB1YWRkciwKPiArCQkJCSAgICAgcGVybSwg bWFwX2ZpbGUpOwo+ICsJCWlmIChyZXQpIHsKPiArCQkJZnB1dChtYXBfZmlsZS0+ZmlsZSk7Cj4g KwkJCWtmcmVlKG1hcF9maWxlKTsKPiArCQkJYnJlYWs7Cj4gKwkJfQo+ICtuZXh0Ogo+ICsJCXNp emUgLT0gbWFwX3NpemU7Cj4gKwkJdWFkZHIgKz0gbWFwX3NpemU7Cj4gKwkJbWFwX2lvdmEgKz0g bWFwX3NpemU7Cj4gKwl9Cj4gKwlpZiAocmV0KQo+ICsJCXZob3N0X3ZkcGFfdW5tYXAodiwgaW92 YSwgbWFwX2lvdmEgLSBpb3ZhKTsKPiArCj4gKwltbWFwX3JlYWRfdW5sb2NrKGRldi0+bW0pOwo+ ICsKPiArCXJldHVybiByZXQ7Cj4gK30KPiArCj4gICBzdGF0aWMgaW50IHZob3N0X3ZkcGFfcGFf bWFwKHN0cnVjdCB2aG9zdF92ZHBhICp2LAo+ICAgCQkJICAgICB1NjQgaW92YSwgdTY0IHNpemUs IHU2NCB1YWRkciwgdTMyIHBlcm0pCj4gICB7Cj4gQEAgLTY1Niw3ICs3MjgsNyBAQCBzdGF0aWMg aW50IHZob3N0X3ZkcGFfcGFfbWFwKHN0cnVjdCB2aG9zdF92ZHBhICp2LAo+ICAgCQkJCWNzaXpl ID0gKGxhc3RfcGZuIC0gbWFwX3BmbiArIDEpIDw8IFBBR0VfU0hJRlQ7Cj4gICAJCQkJcmV0ID0g dmhvc3RfdmRwYV9tYXAodiwgaW92YSwgY3NpemUsCj4gICAJCQkJCQkgICAgIG1hcF9wZm4gPDwg UEFHRV9TSElGVCwKPiAtCQkJCQkJICAgICBwZXJtKTsKPiArCQkJCQkJICAgICBwZXJtLCBOVUxM KTsKPiAgIAkJCQlpZiAocmV0KSB7Cj4gICAJCQkJCS8qCj4gICAJCQkJCSAqIFVucGluIHRoZSBw YWdlcyB0aGF0IGFyZSBsZWZ0IHVubWFwcGVkCj4gQEAgLTY4NSw3ICs3NTcsNyBAQCBzdGF0aWMg aW50IHZob3N0X3ZkcGFfcGFfbWFwKHN0cnVjdCB2aG9zdF92ZHBhICp2LAo+ICAgCj4gICAJLyog UGluIHRoZSByZXN0IGNodW5rICovCj4gICAJcmV0ID0gdmhvc3RfdmRwYV9tYXAodiwgaW92YSwg KGxhc3RfcGZuIC0gbWFwX3BmbiArIDEpIDw8IFBBR0VfU0hJRlQsCj4gLQkJCSAgICAgbWFwX3Bm biA8PCBQQUdFX1NISUZULCBwZXJtKTsKPiArCQkJICAgICBtYXBfcGZuIDw8IFBBR0VfU0hJRlQs IHBlcm0sIE5VTEwpOwo+ICAgb3V0Ogo+ICAgCWlmIChyZXQpIHsKPiAgIAkJaWYgKG5jaHVua3Mp IHsKPiBAQCAtNzE4LDYgKzc5MCw3IEBAIHN0YXRpYyBpbnQgdmhvc3RfdmRwYV9wcm9jZXNzX2lv dGxiX3VwZGF0ZShzdHJ1Y3Qgdmhvc3RfdmRwYSAqdiwKPiAgIAkJCQkJICAgc3RydWN0IHZob3N0 X2lvdGxiX21zZyAqbXNnKQo+ICAgewo+ICAgCXN0cnVjdCB2aG9zdF9kZXYgKmRldiA9ICZ2LT52 ZGV2Owo+ICsJc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhID0gdi0+dmRwYTsKPiAgIAlzdHJ1Y3Qg dmhvc3RfaW90bGIgKmlvdGxiID0gZGV2LT5pb3RsYjsKPiAgIAo+ICAgCWlmIChtc2ctPmlvdmEg PCB2LT5yYW5nZS5maXJzdCB8fAo+IEBAIC03MjgsNiArODAxLDEwIEBAIHN0YXRpYyBpbnQgdmhv c3RfdmRwYV9wcm9jZXNzX2lvdGxiX3VwZGF0ZShzdHJ1Y3Qgdmhvc3RfdmRwYSAqdiwKPiAgIAkJ CQkgICAgbXNnLT5pb3ZhICsgbXNnLT5zaXplIC0gMSkpCj4gICAJCXJldHVybiAtRUVYSVNUOwo+ ICAgCj4gKwlpZiAodmRwYS0+dXNlX3ZhKQo+ICsJCXJldHVybiB2aG9zdF92ZHBhX3ZhX21hcCh2 LCBtc2ctPmlvdmEsIG1zZy0+c2l6ZSwKPiArCQkJCQkgbXNnLT51YWRkciwgbXNnLT5wZXJtKTsK PiArCj4gICAJcmV0dXJuIHZob3N0X3ZkcGFfcGFfbWFwKHYsIG1zZy0+aW92YSwgbXNnLT5zaXpl LCBtc2ctPnVhZGRyLAo+ICAgCQkJCSBtc2ctPnBlcm0pOwo+ICAgfQo+IGRpZmYgLS1naXQgYS9p bmNsdWRlL2xpbnV4L3ZkcGEuaCBiL2luY2x1ZGUvbGludXgvdmRwYS5oCj4gaW5kZXggYjAxZjdj OTA5NmJmLi5lNjc0MDRlNGIyM2UgMTAwNjQ0Cj4gLS0tIGEvaW5jbHVkZS9saW51eC92ZHBhLmgK PiArKysgYi9pbmNsdWRlL2xpbnV4L3ZkcGEuaAo+IEBAIC00NCw2ICs0NCw3IEBAIHN0cnVjdCB2 ZHBhX21nbXRfZGV2Owo+ICAgICogQGNvbmZpZzogdGhlIGNvbmZpZ3VyYXRpb24gb3BzIGZvciB0 aGlzIGRldmljZS4KPiAgICAqIEBpbmRleDogZGV2aWNlIGluZGV4Cj4gICAgKiBAZmVhdHVyZXNf dmFsaWQ6IHdlcmUgZmVhdHVyZXMgaW5pdGlhbGl6ZWQ/IGZvciBsZWdhY3kgZ3Vlc3RzCj4gKyAq IEB1c2VfdmE6IGluZGljYXRlIHdoZXRoZXIgdmlydHVhbCBhZGRyZXNzIG11c3QgYmUgdXNlZCBi eSB0aGlzIGRldmljZQo+ICAgICogQG52cXM6IG1heGltdW0gbnVtYmVyIG9mIHN1cHBvcnRlZCB2 aXJ0cXVldWVzCj4gICAgKiBAbWRldjogbWFuYWdlbWVudCBkZXZpY2UgcG9pbnRlcjsgY2FsbGVy IG11c3Qgc2V0dXAgd2hlbiByZWdpc3RlcmluZyBkZXZpY2UgYXMgcGFydAo+ICAgICoJICBvZiBk ZXZfYWRkKCkgbWdtdGRldiBvcHMgY2FsbGJhY2sgYmVmb3JlIGludm9raW5nIF92ZHBhX3JlZ2lz dGVyX2RldmljZSgpLgo+IEBAIC01NCw2ICs1NSw3IEBAIHN0cnVjdCB2ZHBhX2RldmljZSB7Cj4g ICAJY29uc3Qgc3RydWN0IHZkcGFfY29uZmlnX29wcyAqY29uZmlnOwo+ICAgCXVuc2lnbmVkIGlu dCBpbmRleDsKPiAgIAlib29sIGZlYXR1cmVzX3ZhbGlkOwo+ICsJYm9vbCB1c2VfdmE7Cj4gICAJ aW50IG52cXM7Cj4gICAJc3RydWN0IHZkcGFfbWdtdF9kZXYgKm1kZXY7Cj4gICB9Owo+IEBAIC02 OSw2ICs3MSwxNiBAQCBzdHJ1Y3QgdmRwYV9pb3ZhX3JhbmdlIHsKPiAgIH07Cj4gICAKPiAgIC8q Kgo+ICsgKiBDb3JyZXNwb25kaW5nIGZpbGUgYXJlYSBmb3IgZGV2aWNlIG1lbW9yeSBtYXBwaW5n Cj4gKyAqIEBmaWxlOiB2bWEtPnZtX2ZpbGUgZm9yIHRoZSBtYXBwaW5nCj4gKyAqIEBvZmZzZXQ6 IG1hcHBpbmcgb2Zmc2V0IGluIHRoZSB2bV9maWxlCj4gKyAqLwo+ICtzdHJ1Y3QgdmRwYV9tYXBf ZmlsZSB7Cj4gKwlzdHJ1Y3QgZmlsZSAqZmlsZTsKPiArCXU2NCBvZmZzZXQ7Cj4gK307Cj4gKwo+ ICsvKioKPiAgICAqIHZEUEFfY29uZmlnX29wcyAtIG9wZXJhdGlvbnMgZm9yIGNvbmZpZ3VyaW5n IGEgdkRQQSBkZXZpY2UuCj4gICAgKiBOb3RlOiB2RFBBIGRldmljZSBkcml2ZXJzIGFyZSByZXF1 aXJlZCB0byBpbXBsZW1lbnQgYWxsIG9mIHRoZQo+ICAgICogb3BlcmF0aW9ucyB1bmxlc3MgaXQg aXMgbWVudGlvbmVkIHRvIGJlIG9wdGlvbmFsIGluIHRoZSBmb2xsb3dpbmcKPiBAQCAtMjUwLDE0 ICsyNjIsMTUgQEAgc3RydWN0IHZkcGFfY29uZmlnX29wcyB7Cj4gICAKPiAgIHN0cnVjdCB2ZHBh X2RldmljZSAqX192ZHBhX2FsbG9jX2RldmljZShzdHJ1Y3QgZGV2aWNlICpwYXJlbnQsCj4gICAJ CQkJCWNvbnN0IHN0cnVjdCB2ZHBhX2NvbmZpZ19vcHMgKmNvbmZpZywKPiAtCQkJCQlzaXplX3Qg c2l6ZSwgY29uc3QgY2hhciAqbmFtZSk7Cj4gKwkJCQkJc2l6ZV90IHNpemUsIGNvbnN0IGNoYXIg Km5hbWUsCj4gKwkJCQkJYm9vbCB1c2VfdmEpOwo+ICAgCj4gLSNkZWZpbmUgdmRwYV9hbGxvY19k ZXZpY2UoZGV2X3N0cnVjdCwgbWVtYmVyLCBwYXJlbnQsIGNvbmZpZywgbmFtZSkgICBcCj4gKyNk ZWZpbmUgdmRwYV9hbGxvY19kZXZpY2UoZGV2X3N0cnVjdCwgbWVtYmVyLCBwYXJlbnQsIGNvbmZp ZywgbmFtZSwgdXNlX3ZhKSAgIFwKPiAgIAkJCSAgY29udGFpbmVyX29mKF9fdmRwYV9hbGxvY19k ZXZpY2UoIFwKPiAgIAkJCQkgICAgICAgcGFyZW50LCBjb25maWcsIFwKPiAgIAkJCQkgICAgICAg c2l6ZW9mKGRldl9zdHJ1Y3QpICsgXAo+ICAgCQkJCSAgICAgICBCVUlMRF9CVUdfT05fWkVSTyhv ZmZzZXRvZiggXAo+IC0JCQkJICAgICAgIGRldl9zdHJ1Y3QsIG1lbWJlcikpLCBuYW1lKSwgXAo+ ICsJCQkJICAgICAgIGRldl9zdHJ1Y3QsIG1lbWJlcikpLCBuYW1lLCB1c2VfdmEpLCBcCj4gICAJ CQkJICAgICAgIGRldl9zdHJ1Y3QsIG1lbWJlcikKPiAgIAo+ICAgaW50IHZkcGFfcmVnaXN0ZXJf ZGV2aWNlKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRldiwgaW50IG52cXMpOwoKX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KVmlydHVhbGl6YXRpb24gbWFpbGlu ZyBsaXN0ClZpcnR1YWxpemF0aW9uQGxpc3RzLmxpbnV4LWZvdW5kYXRpb24ub3JnCmh0dHBzOi8v bGlzdHMubGludXhmb3VuZGF0aW9uLm9yZy9tYWlsbWFuL2xpc3RpbmZvL3ZpcnR1YWxpemF0aW9u