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 F11C5C433DB for ; Thu, 4 Mar 2021 03:09:49 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id BCE3D64EBA for ; Thu, 4 Mar 2021 03:09:49 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232186AbhCDDJR (ORCPT ); Wed, 3 Mar 2021 22:09:17 -0500 Received: from us-smtp-delivery-124.mimecast.com ([216.205.24.124]:59782 "EHLO us-smtp-delivery-124.mimecast.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232190AbhCDDJG (ORCPT ); Wed, 3 Mar 2021 22:09:06 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1614827260; 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=UagpJKQ2wSQiWfJNEFP+FXSxL7/mE4JPZYXrdA8k32M=; b=eOEfURTs8h6PMbQiVyTTPSLMoyyj2a3rF/pRPUFRsWXa0r1vYnEUcRADUiDu/6BRyS41qf ZYzggLwQWD6PTgvnHqvg4NWmS5jGEVcN0rSnLGwp724ALLAi9GluKBuRO5JhJjMLxQu2+H SjWTTV1J94+keX9qT36kik02cKN/z88= 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-301-eJpn1_A2OlyoZlqmDd6XFA-1; Wed, 03 Mar 2021 22:07:35 -0500 X-MC-Unique: eJpn1_A2OlyoZlqmDd6XFA-1 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id CF2C8107ACE4; Thu, 4 Mar 2021 03:07:32 +0000 (UTC) Received: from wangxiaodeMacBook-Air.local (ovpn-13-244.pek2.redhat.com [10.72.13.244]) by smtp.corp.redhat.com (Postfix) with ESMTP id 1D74361D2E; Thu, 4 Mar 2021 03:07:16 +0000 (UTC) Subject: Re: [RFC v4 05/11] vdpa: Support transferring virtual addressing during DMA mapping To: Xie Yongji , mst@redhat.com, stefanha@redhat.com, sgarzare@redhat.com, parav@nvidia.com, bob.liu@oracle.com, hch@infradead.org, rdunlap@infradead.org, willy@infradead.org, viro@zeniv.linux.org.uk, axboe@kernel.dk, bcrl@kvack.org, corbet@lwn.net Cc: virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, kvm@vger.kernel.org, linux-aio@kvack.org, linux-fsdevel@vger.kernel.org References: <20210223115048.435-1-xieyongji@bytedance.com> <20210223115048.435-6-xieyongji@bytedance.com> From: Jason Wang Message-ID: <9a00b494-bcea-c874-4d3d-5378b62a8913@redhat.com> Date: Thu, 4 Mar 2021 11:07:15 +0800 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.16; rv:78.0) Gecko/20100101 Thunderbird/78.8.0 MIME-Version: 1.0 In-Reply-To: <20210223115048.435-6-xieyongji@bytedance.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit Content-Language: en-GB X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org On 2021/2/23 7:50 下午, Xie Yongji wrote: > 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 > --- > 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/vhost/vdpa.c | 104 +++++++++++++++++++++++++++++++------- > include/linux/vdpa.h | 20 ++++++-- > 6 files changed, 113 insertions(+), 26 deletions(-) > > diff --git a/drivers/vdpa/ifcvf/ifcvf_main.c b/drivers/vdpa/ifcvf/ifcvf_main.c > index 7c8bbfcf6c3e..228b9f920fea 100644 > --- a/drivers/vdpa/ifcvf/ifcvf_main.c > +++ b/drivers/vdpa/ifcvf/ifcvf_main.c > @@ -432,7 +432,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, > - IFCVF_MAX_QUEUE_PAIRS * 2, NULL); > + IFCVF_MAX_QUEUE_PAIRS * 2, 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 029822060017..54290438da28 100644 > --- a/drivers/vdpa/mlx5/net/mlx5_vnet.c > +++ b/drivers/vdpa/mlx5/net/mlx5_vnet.c > @@ -1964,7 +1964,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, > - 2 * mlx5_vdpa_max_qps(max_vqs), NULL); > + 2 * mlx5_vdpa_max_qps(max_vqs), NULL, false); > if (IS_ERR(ndev)) > return PTR_ERR(ndev); > > diff --git a/drivers/vdpa/vdpa.c b/drivers/vdpa/vdpa.c > index 9700a0adcca0..fafc0ee5eb05 100644 > --- a/drivers/vdpa/vdpa.c > +++ b/drivers/vdpa/vdpa.c > @@ -72,6 +72,7 @@ static void vdpa_release_dev(struct device *d) > * @nvqs: number of virtqueues 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 can be used by this device I think "use_va" means va must be used instead of "can be" here. > * > * Driver should use vdpa_alloc_device() wrapper macro instead of > * using this directly. > @@ -81,7 +82,8 @@ static void vdpa_release_dev(struct device *d) > */ > struct vdpa_device *__vdpa_alloc_device(struct device *parent, > const struct vdpa_config_ops *config, > - int nvqs, size_t size, const char *name) > + int nvqs, size_t size, const char *name, > + bool use_va) > { > struct vdpa_device *vdev; > int err = -EINVAL; > @@ -92,6 +94,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) > @@ -108,6 +114,7 @@ struct vdpa_device *__vdpa_alloc_device(struct device *parent, > vdev->config = config; > vdev->features_valid = false; > vdev->nvqs = nvqs; > + 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 5cfc262ce055..3a9a2dd4e987 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->nvqs, dev_attr->name); > + dev_attr->nvqs, dev_attr->name, false); > if (!vdpasim) > goto err_alloc; > > diff --git a/drivers/vhost/vdpa.c b/drivers/vhost/vdpa.c > index 70857fe3263c..93769ace34df 100644 > --- a/drivers/vhost/vdpa.c > +++ b/drivers/vhost/vdpa.c > @@ -480,21 +480,31 @@ static long vhost_vdpa_unlocked_ioctl(struct file *filep, > static void vhost_vdpa_iotlb_unmap(struct vhost_vdpa *v, u64 start, u64 last) > { > struct vhost_dev *dev = &v->vdev; > + struct vdpa_device *vdpa = v->vdpa; > struct vhost_iotlb *iotlb = dev->iotlb; > struct vhost_iotlb_map *map; > + struct vdpa_map_file *map_file; > struct page *page; > unsigned long pfn, pinned; > > while ((map = vhost_iotlb_itree_first(iotlb, start, last)) != NULL) { > - pinned = map->size >> PAGE_SHIFT; > - for (pfn = map->addr >> PAGE_SHIFT; > - pinned > 0; pfn++, pinned--) { > - page = pfn_to_page(pfn); > - if (map->perm & VHOST_ACCESS_WO) > - set_page_dirty_lock(page); > - unpin_user_page(page); > + if (!vdpa->use_va) { > + pinned = map->size >> PAGE_SHIFT; > + for (pfn = map->addr >> PAGE_SHIFT; > + pinned > 0; pfn++, pinned--) { > + page = pfn_to_page(pfn); > + if (map->perm & VHOST_ACCESS_WO) > + set_page_dirty_lock(page); > + unpin_user_page(page); > + } > + atomic64_sub(map->size >> PAGE_SHIFT, > + &dev->mm->pinned_vm); > + } else { > + map_file = (struct vdpa_map_file *)map->opaque; > + if (map_file->file) > + fput(map_file->file); > + kfree(map_file); > } > - atomic64_sub(map->size >> PAGE_SHIFT, &dev->mm->pinned_vm); > vhost_iotlb_map_free(iotlb, map); > } > } > @@ -530,21 +540,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); > @@ -552,13 +562,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) > @@ -579,10 +591,60 @@ 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; > + goto err; > + } > + map_size = min(size, vma->vm_end - uaddr); > + offset = (vma->vm_pgoff << PAGE_SHIFT) + uaddr - vma->vm_start; > + map_file = kzalloc(sizeof(*map_file), GFP_KERNEL); > + if (!map_file) { > + ret = -ENOMEM; > + goto err; > + } > + if (vma->vm_file && (vma->vm_flags & VM_SHARED) && > + !(vma->vm_flags & (VM_IO | VM_PFNMAP))) { > + map_file->file = get_file(vma->vm_file); > + map_file->offset = offset; > + } I think it's better to do the flag check right after find_vma(), this can avoid things like kfree etc (e.g the code will still call vhost_vdpa_map() even if the flag is not expected now). > + ret = vhost_vdpa_map(v, map_iova, map_size, uaddr, > + perm, map_file); > + if (ret) { > + if (map_file->file) > + fput(map_file->file); > + kfree(map_file); > + goto err; > + } > + size -= map_size; > + uaddr += map_size; > + map_iova += map_size; > + } > + mmap_read_unlock(dev->mm); > + > + return 0; > +err: > + vhost_vdpa_unmap(v, iova, map_iova - iova); > + return ret; > +} > + > 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; > struct page **page_list; > unsigned long list_size = PAGE_SIZE / sizeof(struct page *); > @@ -601,6 +663,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); If possible, I would like to factor out the pa map below into a something like vhost_vdpa_pa_map() first with a separated patch. Then introduce vhost_vdpa_va_map(). Thanks > + > /* Limit the use of memory for bookkeeping */ > page_list = (struct page **) __get_free_page(GFP_KERNEL); > if (!page_list) > @@ -654,7 +720,7 @@ static int vhost_vdpa_process_iotlb_update(struct vhost_vdpa *v, > csize = (last_pfn - map_pfn + 1) << PAGE_SHIFT; > ret = vhost_vdpa_map(v, iova, csize, > map_pfn << PAGE_SHIFT, > - msg->perm); > + msg->perm, NULL); > if (ret) { > /* > * Unpin the pages that are left unmapped > @@ -683,7 +749,7 @@ static int vhost_vdpa_process_iotlb_update(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, msg->perm); > + map_pfn << PAGE_SHIFT, msg->perm, NULL); > out: > if (ret) { > if (nchunks) { > diff --git a/include/linux/vdpa.h b/include/linux/vdpa.h > index 93dca2c328ae..bfae6d780c38 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 can 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,16 @@ struct vdpa_config_ops { > > struct vdpa_device *__vdpa_alloc_device(struct device *parent, > const struct vdpa_config_ops *config, > - int nvqs, size_t size, const char *name); > + int nvqs, size_t size, > + const char *name, bool use_va); > > -#define vdpa_alloc_device(dev_struct, member, parent, config, nvqs, name) \ > +#define vdpa_alloc_device(dev_struct, member, parent, config, \ > + nvqs, name, use_va) \ > container_of(__vdpa_alloc_device( \ > parent, config, nvqs, \ > 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); 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 782F7C433E0 for ; Thu, 4 Mar 2021 03:07:48 +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 EA09E64E99 for ; Thu, 4 Mar 2021 03:07:47 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org EA09E64E99 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 AB7036F4EE; Thu, 4 Mar 2021 03:07:47 +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 bn-nZOoQSg2m; Thu, 4 Mar 2021 03:07:46 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by smtp3.osuosl.org (Postfix) with ESMTP id DB468606C2; Thu, 4 Mar 2021 03:07:45 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id BF606C000B; Thu, 4 Mar 2021 03:07:45 +0000 (UTC) Received: from smtp4.osuosl.org (smtp4.osuosl.org [140.211.166.137]) by lists.linuxfoundation.org (Postfix) with ESMTP id 2432DC0001 for ; Thu, 4 Mar 2021 03:07:44 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp4.osuosl.org (Postfix) with ESMTP id F035C4D0A8 for ; Thu, 4 Mar 2021 03:07:43 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Authentication-Results: smtp4.osuosl.org (amavisd-new); dkim=pass (1024-bit key) header.d=redhat.com Received: from smtp4.osuosl.org ([127.0.0.1]) by localhost (smtp4.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id G_vjFRNs4moA for ; Thu, 4 Mar 2021 03:07:42 +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 smtp4.osuosl.org (Postfix) with ESMTPS id 7A4F64CACF for ; Thu, 4 Mar 2021 03:07:41 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1614827260; 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=UagpJKQ2wSQiWfJNEFP+FXSxL7/mE4JPZYXrdA8k32M=; b=eOEfURTs8h6PMbQiVyTTPSLMoyyj2a3rF/pRPUFRsWXa0r1vYnEUcRADUiDu/6BRyS41qf ZYzggLwQWD6PTgvnHqvg4NWmS5jGEVcN0rSnLGwp724ALLAi9GluKBuRO5JhJjMLxQu2+H SjWTTV1J94+keX9qT36kik02cKN/z88= 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-301-eJpn1_A2OlyoZlqmDd6XFA-1; Wed, 03 Mar 2021 22:07:35 -0500 X-MC-Unique: eJpn1_A2OlyoZlqmDd6XFA-1 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id CF2C8107ACE4; Thu, 4 Mar 2021 03:07:32 +0000 (UTC) Received: from wangxiaodeMacBook-Air.local (ovpn-13-244.pek2.redhat.com [10.72.13.244]) by smtp.corp.redhat.com (Postfix) with ESMTP id 1D74361D2E; Thu, 4 Mar 2021 03:07:16 +0000 (UTC) Subject: Re: [RFC v4 05/11] vdpa: Support transferring virtual addressing during DMA mapping To: Xie Yongji , mst@redhat.com, stefanha@redhat.com, sgarzare@redhat.com, parav@nvidia.com, bob.liu@oracle.com, hch@infradead.org, rdunlap@infradead.org, willy@infradead.org, viro@zeniv.linux.org.uk, axboe@kernel.dk, bcrl@kvack.org, corbet@lwn.net References: <20210223115048.435-1-xieyongji@bytedance.com> <20210223115048.435-6-xieyongji@bytedance.com> From: Jason Wang Message-ID: <9a00b494-bcea-c874-4d3d-5378b62a8913@redhat.com> Date: Thu, 4 Mar 2021 11:07:15 +0800 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.16; rv:78.0) Gecko/20100101 Thunderbird/78.8.0 MIME-Version: 1.0 In-Reply-To: <20210223115048.435-6-xieyongji@bytedance.com> Content-Language: en-GB X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 Cc: linux-aio@kvack.org, netdev@vger.kernel.org, linux-fsdevel@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="utf-8"; Format="flowed" Errors-To: virtualization-bounces@lists.linux-foundation.org Sender: "Virtualization" Ck9uIDIwMjEvMi8yMyA3OjUwIOS4i+WNiCwgWGllIFlvbmdqaSB3cm90ZToKPiBUaGlzIHBhdGNo IGludHJvZHVjZXMgYW4gYXR0cmlidXRlIGZvciB2RFBBIGRldmljZSB0byBpbmRpY2F0ZQo+IHdo ZXRoZXIgdmlydHVhbCBhZGRyZXNzIGNhbiBiZSB1c2VkLiBJZiB2RFBBIGRldmljZSBkcml2ZXIg c2V0Cj4gaXQsIHZob3N0LXZkcGEgYnVzIGRyaXZlciB3aWxsIG5vdCBwaW4gdXNlciBwYWdlIGFu ZCB0cmFuc2Zlcgo+IHVzZXJzcGFjZSB2aXJ0dWFsIGFkZHJlc3MgaW5zdGVhZCBvZiBwaHlzaWNh bCBhZGRyZXNzIGR1cmluZwo+IERNQSBtYXBwaW5nLiBBbmQgY29ycmVzcG9uZGluZyB2bWEtPnZt X2ZpbGUgYW5kIG9mZnNldCB3aWxsIGJlCj4gYWxzbyBwYXNzZWQgYXMgYW4gb3BhcXVlIHBvaW50 ZXIuCj4KPiBTdWdnZXN0ZWQtYnk6IEphc29uIFdhbmcgPGphc293YW5nQHJlZGhhdC5jb20+Cj4g U2lnbmVkLW9mZi1ieTogWGllIFlvbmdqaSA8eGlleW9uZ2ppQGJ5dGVkYW5jZS5jb20+Cj4gLS0t Cj4gICBkcml2ZXJzL3ZkcGEvaWZjdmYvaWZjdmZfbWFpbi5jICAgfCAgIDIgKy0KPiAgIGRyaXZl cnMvdmRwYS9tbHg1L25ldC9tbHg1X3ZuZXQuYyB8ICAgMiArLQo+ICAgZHJpdmVycy92ZHBhL3Zk cGEuYyAgICAgICAgICAgICAgIHwgICA5ICsrKy0KPiAgIGRyaXZlcnMvdmRwYS92ZHBhX3NpbS92 ZHBhX3NpbS5jICB8ICAgMiArLQo+ICAgZHJpdmVycy92aG9zdC92ZHBhLmMgICAgICAgICAgICAg IHwgMTA0ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystLS0tLS0tCj4gICBpbmNsdWRl L2xpbnV4L3ZkcGEuaCAgICAgICAgICAgICAgfCAgMjAgKysrKysrLS0KPiAgIDYgZmlsZXMgY2hh bmdlZCwgMTEzIGluc2VydGlvbnMoKyksIDI2IGRlbGV0aW9ucygtKQo+Cj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvdmRwYS9pZmN2Zi9pZmN2Zl9tYWluLmMgYi9kcml2ZXJzL3ZkcGEvaWZjdmYvaWZj dmZfbWFpbi5jCj4gaW5kZXggN2M4YmJmY2Y2YzNlLi4yMjhiOWY5MjBmZWEgMTAwNjQ0Cj4gLS0t IGEvZHJpdmVycy92ZHBhL2lmY3ZmL2lmY3ZmX21haW4uYwo+ICsrKyBiL2RyaXZlcnMvdmRwYS9p ZmN2Zi9pZmN2Zl9tYWluLmMKPiBAQCAtNDMyLDcgKzQzMiw3IEBAIHN0YXRpYyBpbnQgaWZjdmZf cHJvYmUoc3RydWN0IHBjaV9kZXYgKnBkZXYsIGNvbnN0IHN0cnVjdCBwY2lfZGV2aWNlX2lkICpp ZCkKPiAgIAo+ICAgCWFkYXB0ZXIgPSB2ZHBhX2FsbG9jX2RldmljZShzdHJ1Y3QgaWZjdmZfYWRh cHRlciwgdmRwYSwKPiAgIAkJCQkgICAgZGV2LCAmaWZjX3ZkcGFfb3BzLAo+IC0JCQkJICAgIElG Q1ZGX01BWF9RVUVVRV9QQUlSUyAqIDIsIE5VTEwpOwo+ICsJCQkJICAgIElGQ1ZGX01BWF9RVUVV RV9QQUlSUyAqIDIsIE5VTEwsIGZhbHNlKTsKPiAgIAlpZiAoYWRhcHRlciA9PSBOVUxMKSB7Cj4g ICAJCUlGQ1ZGX0VSUihwZGV2LCAiRmFpbGVkIHRvIGFsbG9jYXRlIHZEUEEgc3RydWN0dXJlIik7 Cj4gICAJCXJldHVybiAtRU5PTUVNOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3ZkcGEvbWx4NS9u ZXQvbWx4NV92bmV0LmMgYi9kcml2ZXJzL3ZkcGEvbWx4NS9uZXQvbWx4NV92bmV0LmMKPiBpbmRl eCAwMjk4MjIwNjAwMTcuLjU0MjkwNDM4ZGEyOCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL3ZkcGEv bWx4NS9uZXQvbWx4NV92bmV0LmMKPiArKysgYi9kcml2ZXJzL3ZkcGEvbWx4NS9uZXQvbWx4NV92 bmV0LmMKPiBAQCAtMTk2NCw3ICsxOTY0LDcgQEAgc3RhdGljIGludCBtbHg1dl9wcm9iZShzdHJ1 Y3QgYXV4aWxpYXJ5X2RldmljZSAqYWRldiwKPiAgIAltYXhfdnFzID0gbWluX3QodTMyLCBtYXhf dnFzLCBNTFg1X01BWF9TVVBQT1JURURfVlFTKTsKPiAgIAo+ICAgCW5kZXYgPSB2ZHBhX2FsbG9j X2RldmljZShzdHJ1Y3QgbWx4NV92ZHBhX25ldCwgbXZkZXYudmRldiwgbWRldi0+ZGV2aWNlLCAm bWx4NV92ZHBhX29wcywKPiAtCQkJCSAyICogbWx4NV92ZHBhX21heF9xcHMobWF4X3ZxcyksIE5V TEwpOwo+ICsJCQkJIDIgKiBtbHg1X3ZkcGFfbWF4X3FwcyhtYXhfdnFzKSwgTlVMTCwgZmFsc2Up Owo+ICAgCWlmIChJU19FUlIobmRldikpCj4gICAJCXJldHVybiBQVFJfRVJSKG5kZXYpOwo+ICAg Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmRwYS92ZHBhLmMgYi9kcml2ZXJzL3ZkcGEvdmRwYS5j Cj4gaW5kZXggOTcwMGEwYWRjY2EwLi5mYWZjMGVlNWViMDUgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVy cy92ZHBhL3ZkcGEuYwo+ICsrKyBiL2RyaXZlcnMvdmRwYS92ZHBhLmMKPiBAQCAtNzIsNiArNzIs NyBAQCBzdGF0aWMgdm9pZCB2ZHBhX3JlbGVhc2VfZGV2KHN0cnVjdCBkZXZpY2UgKmQpCj4gICAg KiBAbnZxczogbnVtYmVyIG9mIHZpcnRxdWV1ZXMgc3VwcG9ydGVkIGJ5IHRoaXMgZGV2aWNlCj4g ICAgKiBAc2l6ZTogc2l6ZSBvZiB0aGUgcGFyZW50IHN0cnVjdHVyZSB0aGF0IGNvbnRhaW5zIHBy aXZhdGUgZGF0YQo+ICAgICogQG5hbWU6IG5hbWUgb2YgdGhlIHZkcGEgZGV2aWNlOyBvcHRpb25h bC4KPiArICogQHVzZV92YTogaW5kaWNhdGUgd2hldGhlciB2aXJ0dWFsIGFkZHJlc3MgY2FuIGJl IHVzZWQgYnkgdGhpcyBkZXZpY2UKCgpJIHRoaW5rICJ1c2VfdmEiIG1lYW5zIHZhIG11c3QgYmUg dXNlZCBpbnN0ZWFkIG9mICJjYW4gYmUiIGhlcmUuCgoKPiAgICAqCj4gICAgKiBEcml2ZXIgc2hv dWxkIHVzZSB2ZHBhX2FsbG9jX2RldmljZSgpIHdyYXBwZXIgbWFjcm8gaW5zdGVhZCBvZgo+ICAg ICogdXNpbmcgdGhpcyBkaXJlY3RseS4KPiBAQCAtODEsNyArODIsOCBAQCBzdGF0aWMgdm9pZCB2 ZHBhX3JlbGVhc2VfZGV2KHN0cnVjdCBkZXZpY2UgKmQpCj4gICAgKi8KPiAgIHN0cnVjdCB2ZHBh X2RldmljZSAqX192ZHBhX2FsbG9jX2RldmljZShzdHJ1Y3QgZGV2aWNlICpwYXJlbnQsCj4gICAJ CQkJCWNvbnN0IHN0cnVjdCB2ZHBhX2NvbmZpZ19vcHMgKmNvbmZpZywKPiAtCQkJCQlpbnQgbnZx cywgc2l6ZV90IHNpemUsIGNvbnN0IGNoYXIgKm5hbWUpCj4gKwkJCQkJaW50IG52cXMsIHNpemVf dCBzaXplLCBjb25zdCBjaGFyICpuYW1lLAo+ICsJCQkJCWJvb2wgdXNlX3ZhKQo+ICAgewo+ICAg CXN0cnVjdCB2ZHBhX2RldmljZSAqdmRldjsKPiAgIAlpbnQgZXJyID0gLUVJTlZBTDsKPiBAQCAt OTIsNiArOTQsMTAgQEAgc3RydWN0IHZkcGFfZGV2aWNlICpfX3ZkcGFfYWxsb2NfZGV2aWNlKHN0 cnVjdCBkZXZpY2UgKnBhcmVudCwKPiAgIAlpZiAoISFjb25maWctPmRtYV9tYXAgIT0gISFjb25m aWctPmRtYV91bm1hcCkKPiAgIAkJZ290byBlcnI7Cj4gICAKPiArCS8qIEl0IHNob3VsZCBvbmx5 IHdvcmsgZm9yIHRoZSBkZXZpY2UgdGhhdCB1c2Ugb24tY2hpcCBJT01NVSAqLwo+ICsJaWYgKHVz ZV92YSAmJiAhKGNvbmZpZy0+ZG1hX21hcCB8fCBjb25maWctPnNldF9tYXApKQo+ICsJCWdvdG8g ZXJyOwo+ICsKPiAgIAllcnIgPSAtRU5PTUVNOwo+ICAgCXZkZXYgPSBremFsbG9jKHNpemUsIEdG UF9LRVJORUwpOwo+ICAgCWlmICghdmRldikKPiBAQCAtMTA4LDYgKzExNCw3IEBAIHN0cnVjdCB2 ZHBhX2RldmljZSAqX192ZHBhX2FsbG9jX2RldmljZShzdHJ1Y3QgZGV2aWNlICpwYXJlbnQsCj4g ICAJdmRldi0+Y29uZmlnID0gY29uZmlnOwo+ICAgCXZkZXYtPmZlYXR1cmVzX3ZhbGlkID0gZmFs c2U7Cj4gICAJdmRldi0+bnZxcyA9IG52cXM7Cj4gKwl2ZGV2LT51c2VfdmEgPSB1c2VfdmE7Cj4g ICAKPiAgIAlpZiAobmFtZSkKPiAgIAkJZXJyID0gZGV2X3NldF9uYW1lKCZ2ZGV2LT5kZXYsICIl cyIsIG5hbWUpOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3ZkcGEvdmRwYV9zaW0vdmRwYV9zaW0u YyBiL2RyaXZlcnMvdmRwYS92ZHBhX3NpbS92ZHBhX3NpbS5jCj4gaW5kZXggNWNmYzI2MmNlMDU1 Li4zYTlhMmRkNGU5ODcgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy92ZHBhL3ZkcGFfc2ltL3ZkcGFf c2ltLmMKPiArKysgYi9kcml2ZXJzL3ZkcGEvdmRwYV9zaW0vdmRwYV9zaW0uYwo+IEBAIC0yMzUs NyArMjM1LDcgQEAgc3RydWN0IHZkcGFzaW0gKnZkcGFzaW1fY3JlYXRlKHN0cnVjdCB2ZHBhc2lt X2Rldl9hdHRyICpkZXZfYXR0cikKPiAgIAkJb3BzID0gJnZkcGFzaW1fY29uZmlnX29wczsKPiAg IAo+ICAgCXZkcGFzaW0gPSB2ZHBhX2FsbG9jX2RldmljZShzdHJ1Y3QgdmRwYXNpbSwgdmRwYSwg TlVMTCwgb3BzLAo+IC0JCQkJICAgIGRldl9hdHRyLT5udnFzLCBkZXZfYXR0ci0+bmFtZSk7Cj4g KwkJCQkgICAgZGV2X2F0dHItPm52cXMsIGRldl9hdHRyLT5uYW1lLCBmYWxzZSk7Cj4gICAJaWYg KCF2ZHBhc2ltKQo+ICAgCQlnb3RvIGVycl9hbGxvYzsKPiAgIAo+IGRpZmYgLS1naXQgYS9kcml2 ZXJzL3Zob3N0L3ZkcGEuYyBiL2RyaXZlcnMvdmhvc3QvdmRwYS5jCj4gaW5kZXggNzA4NTdmZTMy NjNjLi45Mzc2OWFjZTM0ZGYgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy92aG9zdC92ZHBhLmMKPiAr KysgYi9kcml2ZXJzL3Zob3N0L3ZkcGEuYwo+IEBAIC00ODAsMjEgKzQ4MCwzMSBAQCBzdGF0aWMg bG9uZyB2aG9zdF92ZHBhX3VubG9ja2VkX2lvY3RsKHN0cnVjdCBmaWxlICpmaWxlcCwKPiAgIHN0 YXRpYyB2b2lkIHZob3N0X3ZkcGFfaW90bGJfdW5tYXAoc3RydWN0IHZob3N0X3ZkcGEgKnYsIHU2 NCBzdGFydCwgdTY0IGxhc3QpCj4gICB7Cj4gICAJc3RydWN0IHZob3N0X2RldiAqZGV2ID0gJnYt PnZkZXY7Cj4gKwlzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGEgPSB2LT52ZHBhOwo+ICAgCXN0cnVj dCB2aG9zdF9pb3RsYiAqaW90bGIgPSBkZXYtPmlvdGxiOwo+ICAgCXN0cnVjdCB2aG9zdF9pb3Rs Yl9tYXAgKm1hcDsKPiArCXN0cnVjdCB2ZHBhX21hcF9maWxlICptYXBfZmlsZTsKPiAgIAlzdHJ1 Y3QgcGFnZSAqcGFnZTsKPiAgIAl1bnNpZ25lZCBsb25nIHBmbiwgcGlubmVkOwo+ICAgCj4gICAJ d2hpbGUgKChtYXAgPSB2aG9zdF9pb3RsYl9pdHJlZV9maXJzdChpb3RsYiwgc3RhcnQsIGxhc3Qp KSAhPSBOVUxMKSB7Cj4gLQkJcGlubmVkID0gbWFwLT5zaXplID4+IFBBR0VfU0hJRlQ7Cj4gLQkJ Zm9yIChwZm4gPSBtYXAtPmFkZHIgPj4gUEFHRV9TSElGVDsKPiAtCQkgICAgIHBpbm5lZCA+IDA7 IHBmbisrLCBwaW5uZWQtLSkgewo+IC0JCQlwYWdlID0gcGZuX3RvX3BhZ2UocGZuKTsKPiAtCQkJ aWYgKG1hcC0+cGVybSAmIFZIT1NUX0FDQ0VTU19XTykKPiAtCQkJCXNldF9wYWdlX2RpcnR5X2xv Y2socGFnZSk7Cj4gLQkJCXVucGluX3VzZXJfcGFnZShwYWdlKTsKPiArCQlpZiAoIXZkcGEtPnVz ZV92YSkgewo+ICsJCQlwaW5uZWQgPSBtYXAtPnNpemUgPj4gUEFHRV9TSElGVDsKPiArCQkJZm9y IChwZm4gPSBtYXAtPmFkZHIgPj4gUEFHRV9TSElGVDsKPiArCQkJICAgICBwaW5uZWQgPiAwOyBw Zm4rKywgcGlubmVkLS0pIHsKPiArCQkJCXBhZ2UgPSBwZm5fdG9fcGFnZShwZm4pOwo+ICsJCQkJ aWYgKG1hcC0+cGVybSAmIFZIT1NUX0FDQ0VTU19XTykKPiArCQkJCQlzZXRfcGFnZV9kaXJ0eV9s b2NrKHBhZ2UpOwo+ICsJCQkJdW5waW5fdXNlcl9wYWdlKHBhZ2UpOwo+ICsJCQl9Cj4gKwkJCWF0 b21pYzY0X3N1YihtYXAtPnNpemUgPj4gUEFHRV9TSElGVCwKPiArCQkJCQkmZGV2LT5tbS0+cGlu bmVkX3ZtKTsKPiArCQl9IGVsc2Ugewo+ICsJCQltYXBfZmlsZSA9IChzdHJ1Y3QgdmRwYV9tYXBf ZmlsZSAqKW1hcC0+b3BhcXVlOwo+ICsJCQlpZiAobWFwX2ZpbGUtPmZpbGUpCj4gKwkJCQlmcHV0 KG1hcF9maWxlLT5maWxlKTsKPiArCQkJa2ZyZWUobWFwX2ZpbGUpOwo+ICAgCQl9Cj4gLQkJYXRv bWljNjRfc3ViKG1hcC0+c2l6ZSA+PiBQQUdFX1NISUZULCAmZGV2LT5tbS0+cGlubmVkX3ZtKTsK PiAgIAkJdmhvc3RfaW90bGJfbWFwX2ZyZWUoaW90bGIsIG1hcCk7Cj4gICAJfQo+ICAgfQo+IEBA IC01MzAsMjEgKzU0MCwyMSBAQCBzdGF0aWMgaW50IHBlcm1fdG9faW9tbXVfZmxhZ3ModTMyIHBl cm0pCj4gICAJcmV0dXJuIGZsYWdzIHwgSU9NTVVfQ0FDSEU7Cj4gICB9Cj4gICAKPiAtc3RhdGlj IGludCB2aG9zdF92ZHBhX21hcChzdHJ1Y3Qgdmhvc3RfdmRwYSAqdiwKPiAtCQkJICB1NjQgaW92 YSwgdTY0IHNpemUsIHU2NCBwYSwgdTMyIHBlcm0pCj4gK3N0YXRpYyBpbnQgdmhvc3RfdmRwYV9t YXAoc3RydWN0IHZob3N0X3ZkcGEgKnYsIHU2NCBpb3ZhLAo+ICsJCQkgIHU2NCBzaXplLCB1NjQg cGEsIHUzMiBwZXJtLCB2b2lkICpvcGFxdWUpCj4gICB7Cj4gICAJc3RydWN0IHZob3N0X2RldiAq ZGV2ID0gJnYtPnZkZXY7Cj4gICAJc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhID0gdi0+dmRwYTsK PiAgIAljb25zdCBzdHJ1Y3QgdmRwYV9jb25maWdfb3BzICpvcHMgPSB2ZHBhLT5jb25maWc7Cj4g ICAJaW50IHIgPSAwOwo+ICAgCj4gLQlyID0gdmhvc3RfaW90bGJfYWRkX3JhbmdlKGRldi0+aW90 bGIsIGlvdmEsIGlvdmEgKyBzaXplIC0gMSwKPiAtCQkJCSAgcGEsIHBlcm0pOwo+ICsJciA9IHZo b3N0X2lvdGxiX2FkZF9yYW5nZV9jdHgoZGV2LT5pb3RsYiwgaW92YSwgaW92YSArIHNpemUgLSAx LAo+ICsJCQkJICAgICAgcGEsIHBlcm0sIG9wYXF1ZSk7Cj4gICAJaWYgKHIpCj4gICAJCXJldHVy biByOwo+ICAgCj4gICAJaWYgKG9wcy0+ZG1hX21hcCkgewo+IC0JCXIgPSBvcHMtPmRtYV9tYXAo dmRwYSwgaW92YSwgc2l6ZSwgcGEsIHBlcm0sIE5VTEwpOwo+ICsJCXIgPSBvcHMtPmRtYV9tYXAo dmRwYSwgaW92YSwgc2l6ZSwgcGEsIHBlcm0sIG9wYXF1ZSk7Cj4gICAJfSBlbHNlIGlmIChvcHMt PnNldF9tYXApIHsKPiAgIAkJaWYgKCF2LT5pbl9iYXRjaCkKPiAgIAkJCXIgPSBvcHMtPnNldF9t YXAodmRwYSwgZGV2LT5pb3RsYik7Cj4gQEAgLTU1MiwxMyArNTYyLDE1IEBAIHN0YXRpYyBpbnQg dmhvc3RfdmRwYV9tYXAoc3RydWN0IHZob3N0X3ZkcGEgKnYsCj4gICAJCXIgPSBpb21tdV9tYXAo di0+ZG9tYWluLCBpb3ZhLCBwYSwgc2l6ZSwKPiAgIAkJCSAgICAgIHBlcm1fdG9faW9tbXVfZmxh Z3MocGVybSkpOwo+ICAgCX0KPiAtCj4gLQlpZiAocikKPiArCWlmIChyKSB7Cj4gICAJCXZob3N0 X2lvdGxiX2RlbF9yYW5nZShkZXYtPmlvdGxiLCBpb3ZhLCBpb3ZhICsgc2l6ZSAtIDEpOwo+IC0J ZWxzZQo+ICsJCXJldHVybiByOwo+ICsJfQo+ICsKPiArCWlmICghdmRwYS0+dXNlX3ZhKQo+ICAg CQlhdG9taWM2NF9hZGQoc2l6ZSA+PiBQQUdFX1NISUZULCAmZGV2LT5tbS0+cGlubmVkX3ZtKTsK PiAgIAo+IC0JcmV0dXJuIHI7Cj4gKwlyZXR1cm4gMDsKPiAgIH0KPiAgIAo+ICAgc3RhdGljIHZv aWQgdmhvc3RfdmRwYV91bm1hcChzdHJ1Y3Qgdmhvc3RfdmRwYSAqdiwgdTY0IGlvdmEsIHU2NCBz aXplKQo+IEBAIC01NzksMTAgKzU5MSw2MCBAQCBzdGF0aWMgdm9pZCB2aG9zdF92ZHBhX3VubWFw KHN0cnVjdCB2aG9zdF92ZHBhICp2LCB1NjQgaW92YSwgdTY0IHNpemUpCj4gICAJfQo+ICAgfQo+ ICAgCj4gK3N0YXRpYyBpbnQgdmhvc3RfdmRwYV92YV9tYXAoc3RydWN0IHZob3N0X3ZkcGEgKnYs Cj4gKwkJCSAgICAgdTY0IGlvdmEsIHU2NCBzaXplLCB1NjQgdWFkZHIsIHUzMiBwZXJtKQo+ICt7 Cj4gKwlzdHJ1Y3Qgdmhvc3RfZGV2ICpkZXYgPSAmdi0+dmRldjsKPiArCXU2NCBvZmZzZXQsIG1h cF9zaXplLCBtYXBfaW92YSA9IGlvdmE7Cj4gKwlzdHJ1Y3QgdmRwYV9tYXBfZmlsZSAqbWFwX2Zp bGU7Cj4gKwlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYTsKPiArCWludCByZXQ7Cj4gKwo+ICsJ bW1hcF9yZWFkX2xvY2soZGV2LT5tbSk7Cj4gKwo+ICsJd2hpbGUgKHNpemUpIHsKPiArCQl2bWEg PSBmaW5kX3ZtYShkZXYtPm1tLCB1YWRkcik7Cj4gKwkJaWYgKCF2bWEpIHsKPiArCQkJcmV0ID0g LUVJTlZBTDsKPiArCQkJZ290byBlcnI7Cj4gKwkJfQo+ICsJCW1hcF9zaXplID0gbWluKHNpemUs IHZtYS0+dm1fZW5kIC0gdWFkZHIpOwo+ICsJCW9mZnNldCA9ICh2bWEtPnZtX3Bnb2ZmIDw8IFBB R0VfU0hJRlQpICsgdWFkZHIgLSB2bWEtPnZtX3N0YXJ0Owo+ICsJCW1hcF9maWxlID0ga3phbGxv YyhzaXplb2YoKm1hcF9maWxlKSwgR0ZQX0tFUk5FTCk7Cj4gKwkJaWYgKCFtYXBfZmlsZSkgewo+ ICsJCQlyZXQgPSAtRU5PTUVNOwo+ICsJCQlnb3RvIGVycjsKPiArCQl9Cj4gKwkJaWYgKHZtYS0+ dm1fZmlsZSAmJiAodm1hLT52bV9mbGFncyAmIFZNX1NIQVJFRCkgJiYKPiArCQkJISh2bWEtPnZt X2ZsYWdzICYgKFZNX0lPIHwgVk1fUEZOTUFQKSkpIHsKPiArCQkJbWFwX2ZpbGUtPmZpbGUgPSBn ZXRfZmlsZSh2bWEtPnZtX2ZpbGUpOwo+ICsJCQltYXBfZmlsZS0+b2Zmc2V0ID0gb2Zmc2V0Owo+ ICsJCX0KCgpJIHRoaW5rIGl0J3MgYmV0dGVyIHRvIGRvIHRoZSBmbGFnIGNoZWNrIHJpZ2h0IGFm dGVyIGZpbmRfdm1hKCksIHRoaXMgCmNhbiBhdm9pZCB0aGluZ3MgbGlrZSBrZnJlZSBldGMgKGUu ZyB0aGUgY29kZSB3aWxsIHN0aWxsIGNhbGwgCnZob3N0X3ZkcGFfbWFwKCkgZXZlbiBpZiB0aGUg ZmxhZyBpcyBub3QgZXhwZWN0ZWQgbm93KS4KCgo+ICsJCXJldCA9IHZob3N0X3ZkcGFfbWFwKHYs IG1hcF9pb3ZhLCBtYXBfc2l6ZSwgdWFkZHIsCj4gKwkJCQkgICAgIHBlcm0sIG1hcF9maWxlKTsK PiArCQlpZiAocmV0KSB7Cj4gKwkJCWlmIChtYXBfZmlsZS0+ZmlsZSkKPiArCQkJCWZwdXQobWFw X2ZpbGUtPmZpbGUpOwo+ICsJCQlrZnJlZShtYXBfZmlsZSk7Cj4gKwkJCWdvdG8gZXJyOwo+ICsJ CX0KPiArCQlzaXplIC09IG1hcF9zaXplOwo+ICsJCXVhZGRyICs9IG1hcF9zaXplOwo+ICsJCW1h cF9pb3ZhICs9IG1hcF9zaXplOwo+ICsJfQo+ICsJbW1hcF9yZWFkX3VubG9jayhkZXYtPm1tKTsK PiArCj4gKwlyZXR1cm4gMDsKPiArZXJyOgo+ICsJdmhvc3RfdmRwYV91bm1hcCh2LCBpb3ZhLCBt YXBfaW92YSAtIGlvdmEpOwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiAgIHN0YXRpYyBpbnQg dmhvc3RfdmRwYV9wcm9jZXNzX2lvdGxiX3VwZGF0ZShzdHJ1Y3Qgdmhvc3RfdmRwYSAqdiwKPiAg IAkJCQkJICAgc3RydWN0IHZob3N0X2lvdGxiX21zZyAqbXNnKQo+ICAgewo+ICAgCXN0cnVjdCB2 aG9zdF9kZXYgKmRldiA9ICZ2LT52ZGV2Owo+ICsJc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhID0g di0+dmRwYTsKPiAgIAlzdHJ1Y3Qgdmhvc3RfaW90bGIgKmlvdGxiID0gZGV2LT5pb3RsYjsKPiAg IAlzdHJ1Y3QgcGFnZSAqKnBhZ2VfbGlzdDsKPiAgIAl1bnNpZ25lZCBsb25nIGxpc3Rfc2l6ZSA9 IFBBR0VfU0laRSAvIHNpemVvZihzdHJ1Y3QgcGFnZSAqKTsKPiBAQCAtNjAxLDYgKzY2MywxMCBA QCBzdGF0aWMgaW50IHZob3N0X3ZkcGFfcHJvY2Vzc19pb3RsYl91cGRhdGUoc3RydWN0IHZob3N0 X3ZkcGEgKnYsCj4gICAJCQkJICAgIG1zZy0+aW92YSArIG1zZy0+c2l6ZSAtIDEpKQo+ICAgCQly ZXR1cm4gLUVFWElTVDsKPiAgIAo+ICsJaWYgKHZkcGEtPnVzZV92YSkKPiArCQlyZXR1cm4gdmhv c3RfdmRwYV92YV9tYXAodiwgbXNnLT5pb3ZhLCBtc2ctPnNpemUsCj4gKwkJCQkJIG1zZy0+dWFk ZHIsIG1zZy0+cGVybSk7CgoKSWYgcG9zc2libGUsIEkgd291bGQgbGlrZSB0byBmYWN0b3Igb3V0 IHRoZSBwYSBtYXAgYmVsb3cgaW50byBhIApzb21ldGhpbmcgbGlrZSB2aG9zdF92ZHBhX3BhX21h cCgpIGZpcnN0IHdpdGggYSBzZXBhcmF0ZWQgcGF0Y2guIFRoZW4gCmludHJvZHVjZSB2aG9zdF92 ZHBhX3ZhX21hcCgpLgoKVGhhbmtzCgoKPiArCj4gICAJLyogTGltaXQgdGhlIHVzZSBvZiBtZW1v cnkgZm9yIGJvb2trZWVwaW5nICovCj4gICAJcGFnZV9saXN0ID0gKHN0cnVjdCBwYWdlICoqKSBf X2dldF9mcmVlX3BhZ2UoR0ZQX0tFUk5FTCk7Cj4gICAJaWYgKCFwYWdlX2xpc3QpCj4gQEAgLTY1 NCw3ICs3MjAsNyBAQCBzdGF0aWMgaW50IHZob3N0X3ZkcGFfcHJvY2Vzc19pb3RsYl91cGRhdGUo c3RydWN0IHZob3N0X3ZkcGEgKnYsCj4gICAJCQkJY3NpemUgPSAobGFzdF9wZm4gLSBtYXBfcGZu ICsgMSkgPDwgUEFHRV9TSElGVDsKPiAgIAkJCQlyZXQgPSB2aG9zdF92ZHBhX21hcCh2LCBpb3Zh LCBjc2l6ZSwKPiAgIAkJCQkJCSAgICAgbWFwX3BmbiA8PCBQQUdFX1NISUZULAo+IC0JCQkJCQkg ICAgIG1zZy0+cGVybSk7Cj4gKwkJCQkJCSAgICAgbXNnLT5wZXJtLCBOVUxMKTsKPiAgIAkJCQlp ZiAocmV0KSB7Cj4gICAJCQkJCS8qCj4gICAJCQkJCSAqIFVucGluIHRoZSBwYWdlcyB0aGF0IGFy ZSBsZWZ0IHVubWFwcGVkCj4gQEAgLTY4Myw3ICs3NDksNyBAQCBzdGF0aWMgaW50IHZob3N0X3Zk cGFfcHJvY2Vzc19pb3RsYl91cGRhdGUoc3RydWN0IHZob3N0X3ZkcGEgKnYsCj4gICAKPiAgIAkv KiBQaW4gdGhlIHJlc3QgY2h1bmsgKi8KPiAgIAlyZXQgPSB2aG9zdF92ZHBhX21hcCh2LCBpb3Zh LCAobGFzdF9wZm4gLSBtYXBfcGZuICsgMSkgPDwgUEFHRV9TSElGVCwKPiAtCQkJICAgICBtYXBf cGZuIDw8IFBBR0VfU0hJRlQsIG1zZy0+cGVybSk7Cj4gKwkJCSAgICAgbWFwX3BmbiA8PCBQQUdF X1NISUZULCBtc2ctPnBlcm0sIE5VTEwpOwo+ICAgb3V0Ogo+ICAgCWlmIChyZXQpIHsKPiAgIAkJ aWYgKG5jaHVua3MpIHsKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC92ZHBhLmggYi9pbmNs dWRlL2xpbnV4L3ZkcGEuaAo+IGluZGV4IDkzZGNhMmMzMjhhZS4uYmZhZTZkNzgwYzM4IDEwMDY0 NAo+IC0tLSBhL2luY2x1ZGUvbGludXgvdmRwYS5oCj4gKysrIGIvaW5jbHVkZS9saW51eC92ZHBh LmgKPiBAQCAtNDQsNiArNDQsNyBAQCBzdHJ1Y3QgdmRwYV9tZ210X2RldjsKPiAgICAqIEBjb25m aWc6IHRoZSBjb25maWd1cmF0aW9uIG9wcyBmb3IgdGhpcyBkZXZpY2UuCj4gICAgKiBAaW5kZXg6 IGRldmljZSBpbmRleAo+ICAgICogQGZlYXR1cmVzX3ZhbGlkOiB3ZXJlIGZlYXR1cmVzIGluaXRp YWxpemVkPyBmb3IgbGVnYWN5IGd1ZXN0cwo+ICsgKiBAdXNlX3ZhOiBpbmRpY2F0ZSB3aGV0aGVy IHZpcnR1YWwgYWRkcmVzcyBjYW4gYmUgdXNlZCBieSB0aGlzIGRldmljZQo+ICAgICogQG52cXM6 IG1heGltdW0gbnVtYmVyIG9mIHN1cHBvcnRlZCB2aXJ0cXVldWVzCj4gICAgKiBAbWRldjogbWFu YWdlbWVudCBkZXZpY2UgcG9pbnRlcjsgY2FsbGVyIG11c3Qgc2V0dXAgd2hlbiByZWdpc3Rlcmlu ZyBkZXZpY2UgYXMgcGFydAo+ICAgICoJICBvZiBkZXZfYWRkKCkgbWdtdGRldiBvcHMgY2FsbGJh Y2sgYmVmb3JlIGludm9raW5nIF92ZHBhX3JlZ2lzdGVyX2RldmljZSgpLgo+IEBAIC01NCw2ICs1 NSw3IEBAIHN0cnVjdCB2ZHBhX2RldmljZSB7Cj4gICAJY29uc3Qgc3RydWN0IHZkcGFfY29uZmln X29wcyAqY29uZmlnOwo+ICAgCXVuc2lnbmVkIGludCBpbmRleDsKPiAgIAlib29sIGZlYXR1cmVz X3ZhbGlkOwo+ICsJYm9vbCB1c2VfdmE7Cj4gICAJaW50IG52cXM7Cj4gICAJc3RydWN0IHZkcGFf bWdtdF9kZXYgKm1kZXY7Cj4gICB9Owo+IEBAIC02OSw2ICs3MSwxNiBAQCBzdHJ1Y3QgdmRwYV9p b3ZhX3JhbmdlIHsKPiAgIH07Cj4gICAKPiAgIC8qKgo+ICsgKiBDb3JyZXNwb25kaW5nIGZpbGUg YXJlYSBmb3IgZGV2aWNlIG1lbW9yeSBtYXBwaW5nCj4gKyAqIEBmaWxlOiB2bWEtPnZtX2ZpbGUg Zm9yIHRoZSBtYXBwaW5nCj4gKyAqIEBvZmZzZXQ6IG1hcHBpbmcgb2Zmc2V0IGluIHRoZSB2bV9m aWxlCj4gKyAqLwo+ICtzdHJ1Y3QgdmRwYV9tYXBfZmlsZSB7Cj4gKwlzdHJ1Y3QgZmlsZSAqZmls ZTsKPiArCXU2NCBvZmZzZXQ7Cj4gK307Cj4gKwo+ICsvKioKPiAgICAqIHZEUEFfY29uZmlnX29w cyAtIG9wZXJhdGlvbnMgZm9yIGNvbmZpZ3VyaW5nIGEgdkRQQSBkZXZpY2UuCj4gICAgKiBOb3Rl OiB2RFBBIGRldmljZSBkcml2ZXJzIGFyZSByZXF1aXJlZCB0byBpbXBsZW1lbnQgYWxsIG9mIHRo ZQo+ICAgICogb3BlcmF0aW9ucyB1bmxlc3MgaXQgaXMgbWVudGlvbmVkIHRvIGJlIG9wdGlvbmFs IGluIHRoZSBmb2xsb3dpbmcKPiBAQCAtMjUwLDE0ICsyNjIsMTYgQEAgc3RydWN0IHZkcGFfY29u ZmlnX29wcyB7Cj4gICAKPiAgIHN0cnVjdCB2ZHBhX2RldmljZSAqX192ZHBhX2FsbG9jX2Rldmlj ZShzdHJ1Y3QgZGV2aWNlICpwYXJlbnQsCj4gICAJCQkJCWNvbnN0IHN0cnVjdCB2ZHBhX2NvbmZp Z19vcHMgKmNvbmZpZywKPiAtCQkJCQlpbnQgbnZxcywgc2l6ZV90IHNpemUsIGNvbnN0IGNoYXIg Km5hbWUpOwo+ICsJCQkJCWludCBudnFzLCBzaXplX3Qgc2l6ZSwKPiArCQkJCQljb25zdCBjaGFy ICpuYW1lLCBib29sIHVzZV92YSk7Cj4gICAKPiAtI2RlZmluZSB2ZHBhX2FsbG9jX2RldmljZShk ZXZfc3RydWN0LCBtZW1iZXIsIHBhcmVudCwgY29uZmlnLCBudnFzLCBuYW1lKSAgIFwKPiArI2Rl ZmluZSB2ZHBhX2FsbG9jX2RldmljZShkZXZfc3RydWN0LCBtZW1iZXIsIHBhcmVudCwgY29uZmln LCBcCj4gKwkJCSAgbnZxcywgbmFtZSwgdXNlX3ZhKSBcCj4gICAJCQkgIGNvbnRhaW5lcl9vZihf X3ZkcGFfYWxsb2NfZGV2aWNlKCBcCj4gICAJCQkJICAgICAgIHBhcmVudCwgY29uZmlnLCBudnFz LCBcCj4gICAJCQkJICAgICAgIHNpemVvZihkZXZfc3RydWN0KSArIFwKPiAgIAkJCQkgICAgICAg QlVJTERfQlVHX09OX1pFUk8ob2Zmc2V0b2YoIFwKPiAtCQkJCSAgICAgICBkZXZfc3RydWN0LCBt ZW1iZXIpKSwgbmFtZSksIFwKPiArCQkJCSAgICAgICBkZXZfc3RydWN0LCBtZW1iZXIpKSwgbmFt ZSwgdXNlX3ZhKSwgXAo+ICAgCQkJCSAgICAgICBkZXZfc3RydWN0LCBtZW1iZXIpCj4gICAKPiAg IGludCB2ZHBhX3JlZ2lzdGVyX2RldmljZShzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkZXYpOwoKX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KVmlydHVhbGl6YXRp b24gbWFpbGluZyBsaXN0ClZpcnR1YWxpemF0aW9uQGxpc3RzLmxpbnV4LWZvdW5kYXRpb24ub3Jn Cmh0dHBzOi8vbGlzdHMubGludXhmb3VuZGF0aW9uLm9yZy9tYWlsbWFuL2xpc3RpbmZvL3ZpcnR1 YWxpemF0aW9u