From mboxrd@z Thu Jan 1 00:00:00 1970 From: John Hubbard Subject: [PATCH v6 09/24] vfio, mm: fix get_user_pages_remote() and FOLL_LONGTERM Date: Tue, 19 Nov 2019 00:16:28 -0800 Message-ID: <20191119081643.1866232-10-jhubbard@nvidia.com> References: <20191119081643.1866232-1-jhubbard@nvidia.com> Mime-Version: 1.0 Content-Type: text/plain Content-Transfer-Encoding: quoted-printable Return-path: In-Reply-To: <20191119081643.1866232-1-jhubbard@nvidia.com> Sender: linux-kernel-owner@vger.kernel.org To: Andrew Morton Cc: Al Viro , Alex Williamson , Benjamin Herrenschmidt , =?UTF-8?q?Bj=C3=B6rn=20T=C3=B6pel?= , Christoph Hellwig , Dan Williams , Daniel Vetter , Dave Chinner , David Airlie , "David S . Miller" , Ira Weiny , Jan Kara , Jason Gunthorpe , Jens Axboe , Jonathan Corbet , =?UTF-8?q?J=C3=A9r=C3=B4me=20Glisse?= , Magnus Karlsson , Mauro Carvalho Chehab , Michael Ellerman List-Id: dri-devel@lists.freedesktop.org As it says in the updated comment in gup.c: current FOLL_LONGTERM behavior is incompatible with FAULT_FLAG_ALLOW_RETRY because of the FS DAX check requirement on vmas. However, the corresponding restriction in get_user_pages_remote() was slightly stricter than is actually required: it forbade all FOLL_LONGTERM callers, but we can actually allow FOLL_LONGTERM callers that do not set the "locked" arg. Update the code and comments accordingly, and update the VFIO caller to take advantage of this, fixing a bug as a result: the VFIO caller is logically a FOLL_LONGTERM user. Also, remove an unnessary pair of calls that were releasing and reacquiring the mmap_sem. There is no need to avoid holding mmap_sem just in order to call page_to_pfn(). Also, move the DAX check ("if a VMA is DAX, don't allow long term pinning") from the VFIO call site, all the way into the internals of get_user_pages_remote() and __gup_longterm_locked(). That is: get_user_pages_remote() calls __gup_longterm_locked(), which in turn calls check_dax_vmas(). It's lightly explained in the comments as well. Thanks to Jason Gunthorpe for pointing out a clean way to fix this, and to Dan Williams for helping clarify the DAX refactoring. Reviewed-by: Jason Gunthorpe Reviewed-by: Ira Weiny Suggested-by: Jason Gunthorpe Cc: Dan Williams Cc: Jerome Glisse Signed-off-by: John Hubbard --- drivers/vfio/vfio_iommu_type1.c | 30 +++++------------------------- mm/gup.c | 27 ++++++++++++++++++++++----- 2 files changed, 27 insertions(+), 30 deletions(-) diff --git a/drivers/vfio/vfio_iommu_type1.c b/drivers/vfio/vfio_iommu_type= 1.c index d864277ea16f..c7a111ad9975 100644 --- a/drivers/vfio/vfio_iommu_type1.c +++ b/drivers/vfio/vfio_iommu_type1.c @@ -340,7 +340,6 @@ static int vaddr_get_pfn(struct mm_struct *mm, unsigned= long vaddr, { struct page *page[1]; struct vm_area_struct *vma; - struct vm_area_struct *vmas[1]; unsigned int flags =3D 0; int ret; =20 @@ -348,33 +347,14 @@ static int vaddr_get_pfn(struct mm_struct *mm, unsign= ed long vaddr, flags |=3D FOLL_WRITE; =20 down_read(&mm->mmap_sem); - if (mm =3D=3D current->mm) { - ret =3D get_user_pages(vaddr, 1, flags | FOLL_LONGTERM, page, - vmas); - } else { - ret =3D get_user_pages_remote(NULL, mm, vaddr, 1, flags, page, - vmas, NULL); - /* - * The lifetime of a vaddr_get_pfn() page pin is - * userspace-controlled. In the fs-dax case this could - * lead to indefinite stalls in filesystem operations. - * Disallow attempts to pin fs-dax pages via this - * interface. - */ - if (ret > 0 && vma_is_fsdax(vmas[0])) { - ret =3D -EOPNOTSUPP; - put_page(page[0]); - } - } - up_read(&mm->mmap_sem); - + ret =3D get_user_pages_remote(NULL, mm, vaddr, 1, flags | FOLL_LONGTERM, + page, NULL, NULL); if (ret =3D=3D 1) { *pfn =3D page_to_pfn(page[0]); - return 0; + ret =3D 0; + goto done; } =20 - down_read(&mm->mmap_sem); - vaddr =3D untagged_addr(vaddr); =20 vma =3D find_vma_intersection(mm, vaddr, vaddr + 1); @@ -384,7 +364,7 @@ static int vaddr_get_pfn(struct mm_struct *mm, unsigned= long vaddr, if (is_invalid_reserved_pfn(*pfn)) ret =3D 0; } - +done: up_read(&mm->mmap_sem); return ret; } diff --git a/mm/gup.c b/mm/gup.c index 14fcdc502166..cce2c9676853 100644 --- a/mm/gup.c +++ b/mm/gup.c @@ -29,6 +29,13 @@ struct follow_page_context { unsigned int page_mask; }; =20 +static __always_inline long __gup_longterm_locked(struct task_struct *tsk, + struct mm_struct *mm, + unsigned long start, + unsigned long nr_pages, + struct page **pages, + struct vm_area_struct **vmas, + unsigned int flags); /* * Return the compound head page with ref appropriately incremented, * or NULL if that failed. @@ -1167,13 +1174,23 @@ long get_user_pages_remote(struct task_struct *tsk,= struct mm_struct *mm, struct vm_area_struct **vmas, int *locked) { /* - * FIXME: Current FOLL_LONGTERM behavior is incompatible with + * Parts of FOLL_LONGTERM behavior are incompatible with * FAULT_FLAG_ALLOW_RETRY because of the FS DAX check requirement on - * vmas. As there are no users of this flag in this call we simply - * disallow this option for now. + * vmas. However, this only comes up if locked is set, and there are + * callers that do request FOLL_LONGTERM, but do not set locked. So, + * allow what we can. */ - if (WARN_ON_ONCE(gup_flags & FOLL_LONGTERM)) - return -EINVAL; + if (gup_flags & FOLL_LONGTERM) { + if (WARN_ON_ONCE(locked)) + return -EINVAL; + /* + * This will check the vmas (even if our vmas arg is NULL) + * and return -ENOTSUPP if DAX isn't allowed in this case: + */ + return __gup_longterm_locked(tsk, mm, start, nr_pages, pages, + vmas, gup_flags | FOLL_TOUCH | + FOLL_REMOTE); + } =20 return __get_user_pages_locked(tsk, mm, start, nr_pages, pages, vmas, locked, --=20 2.24.0 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=-9.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, USER_AGENT_GIT 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 7ACD3C33CA6 for ; Tue, 19 Nov 2019 08:17:18 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (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 5B70122317 for ; Tue, 19 Nov 2019 08:17:18 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 5B70122317 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=nvidia.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id C2F016ECA0; Tue, 19 Nov 2019 08:17:06 +0000 (UTC) Received: from hqemgate15.nvidia.com (hqemgate15.nvidia.com [216.228.121.64]) by gabe.freedesktop.org (Postfix) with ESMTPS id E96926EC80 for ; Tue, 19 Nov 2019 08:16:58 +0000 (UTC) Received: from hqpgpgate101.nvidia.com (Not Verified[216.228.121.13]) by hqemgate15.nvidia.com (using TLS: TLSv1.2, DES-CBC3-SHA) id ; Tue, 19 Nov 2019 00:16:55 -0800 Received: from hqmail.nvidia.com ([172.20.161.6]) by hqpgpgate101.nvidia.com (PGP Universal service); Tue, 19 Nov 2019 00:16:58 -0800 X-PGP-Universal: processed; by hqpgpgate101.nvidia.com on Tue, 19 Nov 2019 00:16:58 -0800 Received: from HQMAIL101.nvidia.com (172.20.187.10) by HQMAIL101.nvidia.com (172.20.187.10) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Tue, 19 Nov 2019 08:16:57 +0000 Received: from rnnvemgw01.nvidia.com (10.128.109.123) by HQMAIL101.nvidia.com (172.20.187.10) with Microsoft SMTP Server (TLS) id 15.0.1473.3 via Frontend Transport; Tue, 19 Nov 2019 08:16:56 +0000 Received: from blueforge.nvidia.com (Not Verified[10.110.48.28]) by rnnvemgw01.nvidia.com with Trustwave SEG (v7, 5, 8, 10121) id ; Tue, 19 Nov 2019 00:16:56 -0800 From: John Hubbard To: Andrew Morton Subject: [PATCH v6 09/24] vfio, mm: fix get_user_pages_remote() and FOLL_LONGTERM Date: Tue, 19 Nov 2019 00:16:28 -0800 Message-ID: <20191119081643.1866232-10-jhubbard@nvidia.com> X-Mailer: git-send-email 2.24.0 In-Reply-To: <20191119081643.1866232-1-jhubbard@nvidia.com> References: <20191119081643.1866232-1-jhubbard@nvidia.com> MIME-Version: 1.0 X-NVConfidentiality: public X-Mailman-Original-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nvidia.com; s=n1; t=1574151415; bh=Uwl18s1SSepFZDEDvXpYEZES6pW0/uOIoLMPiWyv/Qc=; h=X-PGP-Universal:From:To:CC:Subject:Date:Message-ID:X-Mailer: In-Reply-To:References:MIME-Version:X-NVConfidentiality: Content-Transfer-Encoding:Content-Type; b=YtMyFr5erHVXUCjsMDsjjgLg4lSF2Y9fvOsQo86jWJ7BUwHkX6LBaSd7rOkfzV94h slHGFOI6hw8R762F/hWZmbNcc2HrbBz4uxHF0G5r6S3HFMz0Q2XSDCNY3RvR1lhlMD wln4GKCMtPhFzEiJhUiS1jzz5ufqYANvmVYepYMWplXCCnH13reieJiD9UKiZHdL0X MLRlJwOpuHqs4qjRuTPv/s/AsCZ++qcDmCWJbqOATMIXDtfM5R288EfjM+aqAJ9dD8 fJNHp/uGHebrvIo5xxadpQZ2gg9IHYW/nbnuLqaXW9QnnpfjEejs9M3jJcgUnh0bOn JV3dIABS1uI4A== X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Michal Hocko , Jan Kara , kvm@vger.kernel.org, linux-doc@vger.kernel.org, David Airlie , Dave Chinner , dri-devel@lists.freedesktop.org, LKML , linux-mm@kvack.org, Paul Mackerras , linux-kselftest@vger.kernel.org, Ira Weiny , Jonathan Corbet , linux-rdma@vger.kernel.org, Michael Ellerman , Christoph Hellwig , Jason Gunthorpe , Jason Gunthorpe , Vlastimil Babka , =?UTF-8?q?Bj=C3=B6rn=20T=C3=B6pel?= , linux-media@vger.kernel.org, Shuah Khan , John Hubbard , linux-block@vger.kernel.org, =?UTF-8?q?J=C3=A9r=C3=B4me=20Glisse?= , Al Viro , Dan Williams , Mauro Carvalho Chehab , Magnus Karlsson , Jens Axboe , netdev@vger.kernel.org, Alex Williamson , linux-fsdevel@vger.kernel.org, bpf@vger.kernel.org, linuxppc-dev@lists.ozlabs.org, "David S . Miller" , Mike Kravetz Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Message-ID: <20191119081628.WoFzh-Fqf3B273T1qdyY6xq7O_BuY6NDRz_JX9NLKhc@z> QXMgaXQgc2F5cyBpbiB0aGUgdXBkYXRlZCBjb21tZW50IGluIGd1cC5jOiBjdXJyZW50IEZPTExf TE9OR1RFUk0KYmVoYXZpb3IgaXMgaW5jb21wYXRpYmxlIHdpdGggRkFVTFRfRkxBR19BTExPV19S RVRSWSBiZWNhdXNlIG9mIHRoZQpGUyBEQVggY2hlY2sgcmVxdWlyZW1lbnQgb24gdm1hcy4KCkhv d2V2ZXIsIHRoZSBjb3JyZXNwb25kaW5nIHJlc3RyaWN0aW9uIGluIGdldF91c2VyX3BhZ2VzX3Jl bW90ZSgpIHdhcwpzbGlnaHRseSBzdHJpY3RlciB0aGFuIGlzIGFjdHVhbGx5IHJlcXVpcmVkOiBp dCBmb3JiYWRlIGFsbApGT0xMX0xPTkdURVJNIGNhbGxlcnMsIGJ1dCB3ZSBjYW4gYWN0dWFsbHkg YWxsb3cgRk9MTF9MT05HVEVSTSBjYWxsZXJzCnRoYXQgZG8gbm90IHNldCB0aGUgImxvY2tlZCIg YXJnLgoKVXBkYXRlIHRoZSBjb2RlIGFuZCBjb21tZW50cyBhY2NvcmRpbmdseSwgYW5kIHVwZGF0 ZSB0aGUgVkZJTyBjYWxsZXIKdG8gdGFrZSBhZHZhbnRhZ2Ugb2YgdGhpcywgZml4aW5nIGEgYnVn IGFzIGEgcmVzdWx0OiB0aGUgVkZJTyBjYWxsZXIKaXMgbG9naWNhbGx5IGEgRk9MTF9MT05HVEVS TSB1c2VyLgoKQWxzbywgcmVtb3ZlIGFuIHVubmVzc2FyeSBwYWlyIG9mIGNhbGxzIHRoYXQgd2Vy ZSByZWxlYXNpbmcgYW5kCnJlYWNxdWlyaW5nIHRoZSBtbWFwX3NlbS4gVGhlcmUgaXMgbm8gbmVl ZCB0byBhdm9pZCBob2xkaW5nIG1tYXBfc2VtCmp1c3QgaW4gb3JkZXIgdG8gY2FsbCBwYWdlX3Rv X3BmbigpLgoKQWxzbywgbW92ZSB0aGUgREFYIGNoZWNrICgiaWYgYSBWTUEgaXMgREFYLCBkb24n dCBhbGxvdyBsb25nIHRlcm0KcGlubmluZyIpIGZyb20gdGhlIFZGSU8gY2FsbCBzaXRlLCBhbGwg dGhlIHdheSBpbnRvIHRoZSBpbnRlcm5hbHMKb2YgZ2V0X3VzZXJfcGFnZXNfcmVtb3RlKCkgYW5k IF9fZ3VwX2xvbmd0ZXJtX2xvY2tlZCgpLiBUaGF0IGlzOgpnZXRfdXNlcl9wYWdlc19yZW1vdGUo KSBjYWxscyBfX2d1cF9sb25ndGVybV9sb2NrZWQoKSwgd2hpY2ggaW4gdHVybgpjYWxscyBjaGVj a19kYXhfdm1hcygpLiBJdCdzIGxpZ2h0bHkgZXhwbGFpbmVkIGluIHRoZSBjb21tZW50cyBhcyB3 ZWxsLgoKVGhhbmtzIHRvIEphc29uIEd1bnRob3JwZSBmb3IgcG9pbnRpbmcgb3V0IGEgY2xlYW4g d2F5IHRvIGZpeCB0aGlzLAphbmQgdG8gRGFuIFdpbGxpYW1zIGZvciBoZWxwaW5nIGNsYXJpZnkg dGhlIERBWCByZWZhY3RvcmluZy4KClJldmlld2VkLWJ5OiBKYXNvbiBHdW50aG9ycGUgPGpnZ0Bt ZWxsYW5veC5jb20+ClJldmlld2VkLWJ5OiBJcmEgV2VpbnkgPGlyYS53ZWlueUBpbnRlbC5jb20+ ClN1Z2dlc3RlZC1ieTogSmFzb24gR3VudGhvcnBlIDxqZ2dAemllcGUuY2E+CkNjOiBEYW4gV2ls bGlhbXMgPGRhbi5qLndpbGxpYW1zQGludGVsLmNvbT4KQ2M6IEplcm9tZSBHbGlzc2UgPGpnbGlz c2VAcmVkaGF0LmNvbT4KU2lnbmVkLW9mZi1ieTogSm9obiBIdWJiYXJkIDxqaHViYmFyZEBudmlk aWEuY29tPgotLS0KIGRyaXZlcnMvdmZpby92ZmlvX2lvbW11X3R5cGUxLmMgfCAzMCArKysrKy0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIG1tL2d1cC5jICAgICAgICAgICAgICAgICAgICAgICAg fCAyNyArKysrKysrKysrKysrKysrKysrKysrLS0tLS0KIDIgZmlsZXMgY2hhbmdlZCwgMjcgaW5z ZXJ0aW9ucygrKSwgMzAgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy92ZmlvL3Zm aW9faW9tbXVfdHlwZTEuYyBiL2RyaXZlcnMvdmZpby92ZmlvX2lvbW11X3R5cGUxLmMKaW5kZXgg ZDg2NDI3N2VhMTZmLi5jN2ExMTFhZDk5NzUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmZpby92Zmlv X2lvbW11X3R5cGUxLmMKKysrIGIvZHJpdmVycy92ZmlvL3ZmaW9faW9tbXVfdHlwZTEuYwpAQCAt MzQwLDcgKzM0MCw2IEBAIHN0YXRpYyBpbnQgdmFkZHJfZ2V0X3BmbihzdHJ1Y3QgbW1fc3RydWN0 ICptbSwgdW5zaWduZWQgbG9uZyB2YWRkciwKIHsKIAlzdHJ1Y3QgcGFnZSAqcGFnZVsxXTsKIAlz dHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYTsKLQlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYXNb MV07CiAJdW5zaWduZWQgaW50IGZsYWdzID0gMDsKIAlpbnQgcmV0OwogCkBAIC0zNDgsMzMgKzM0 NywxNCBAQCBzdGF0aWMgaW50IHZhZGRyX2dldF9wZm4oc3RydWN0IG1tX3N0cnVjdCAqbW0sIHVu c2lnbmVkIGxvbmcgdmFkZHIsCiAJCWZsYWdzIHw9IEZPTExfV1JJVEU7CiAKIAlkb3duX3JlYWQo Jm1tLT5tbWFwX3NlbSk7Ci0JaWYgKG1tID09IGN1cnJlbnQtPm1tKSB7Ci0JCXJldCA9IGdldF91 c2VyX3BhZ2VzKHZhZGRyLCAxLCBmbGFncyB8IEZPTExfTE9OR1RFUk0sIHBhZ2UsCi0JCQkJICAg ICB2bWFzKTsKLQl9IGVsc2UgewotCQlyZXQgPSBnZXRfdXNlcl9wYWdlc19yZW1vdGUoTlVMTCwg bW0sIHZhZGRyLCAxLCBmbGFncywgcGFnZSwKLQkJCQkJICAgIHZtYXMsIE5VTEwpOwotCQkvKgot CQkgKiBUaGUgbGlmZXRpbWUgb2YgYSB2YWRkcl9nZXRfcGZuKCkgcGFnZSBwaW4gaXMKLQkJICog dXNlcnNwYWNlLWNvbnRyb2xsZWQuIEluIHRoZSBmcy1kYXggY2FzZSB0aGlzIGNvdWxkCi0JCSAq IGxlYWQgdG8gaW5kZWZpbml0ZSBzdGFsbHMgaW4gZmlsZXN5c3RlbSBvcGVyYXRpb25zLgotCQkg KiBEaXNhbGxvdyBhdHRlbXB0cyB0byBwaW4gZnMtZGF4IHBhZ2VzIHZpYSB0aGlzCi0JCSAqIGlu dGVyZmFjZS4KLQkJICovCi0JCWlmIChyZXQgPiAwICYmIHZtYV9pc19mc2RheCh2bWFzWzBdKSkg ewotCQkJcmV0ID0gLUVPUE5PVFNVUFA7Ci0JCQlwdXRfcGFnZShwYWdlWzBdKTsKLQkJfQotCX0K LQl1cF9yZWFkKCZtbS0+bW1hcF9zZW0pOwotCisJcmV0ID0gZ2V0X3VzZXJfcGFnZXNfcmVtb3Rl KE5VTEwsIG1tLCB2YWRkciwgMSwgZmxhZ3MgfCBGT0xMX0xPTkdURVJNLAorCQkJCSAgICBwYWdl LCBOVUxMLCBOVUxMKTsKIAlpZiAocmV0ID09IDEpIHsKIAkJKnBmbiA9IHBhZ2VfdG9fcGZuKHBh Z2VbMF0pOwotCQlyZXR1cm4gMDsKKwkJcmV0ID0gMDsKKwkJZ290byBkb25lOwogCX0KIAotCWRv d25fcmVhZCgmbW0tPm1tYXBfc2VtKTsKLQogCXZhZGRyID0gdW50YWdnZWRfYWRkcih2YWRkcik7 CiAKIAl2bWEgPSBmaW5kX3ZtYV9pbnRlcnNlY3Rpb24obW0sIHZhZGRyLCB2YWRkciArIDEpOwpA QCAtMzg0LDcgKzM2NCw3IEBAIHN0YXRpYyBpbnQgdmFkZHJfZ2V0X3BmbihzdHJ1Y3QgbW1fc3Ry dWN0ICptbSwgdW5zaWduZWQgbG9uZyB2YWRkciwKIAkJaWYgKGlzX2ludmFsaWRfcmVzZXJ2ZWRf cGZuKCpwZm4pKQogCQkJcmV0ID0gMDsKIAl9Ci0KK2RvbmU6CiAJdXBfcmVhZCgmbW0tPm1tYXBf c2VtKTsKIAlyZXR1cm4gcmV0OwogfQpkaWZmIC0tZ2l0IGEvbW0vZ3VwLmMgYi9tbS9ndXAuYwpp bmRleCAxNGZjZGM1MDIxNjYuLmNjZTJjOTY3Njg1MyAxMDA2NDQKLS0tIGEvbW0vZ3VwLmMKKysr IGIvbW0vZ3VwLmMKQEAgLTI5LDYgKzI5LDEzIEBAIHN0cnVjdCBmb2xsb3dfcGFnZV9jb250ZXh0 IHsKIAl1bnNpZ25lZCBpbnQgcGFnZV9tYXNrOwogfTsKIAorc3RhdGljIF9fYWx3YXlzX2lubGlu ZSBsb25nIF9fZ3VwX2xvbmd0ZXJtX2xvY2tlZChzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRzaywKKwkJ CQkJCSAgc3RydWN0IG1tX3N0cnVjdCAqbW0sCisJCQkJCQkgIHVuc2lnbmVkIGxvbmcgc3RhcnQs CisJCQkJCQkgIHVuc2lnbmVkIGxvbmcgbnJfcGFnZXMsCisJCQkJCQkgIHN0cnVjdCBwYWdlICoq cGFnZXMsCisJCQkJCQkgIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqKnZtYXMsCisJCQkJCQkgIHVu c2lnbmVkIGludCBmbGFncyk7CiAvKgogICogUmV0dXJuIHRoZSBjb21wb3VuZCBoZWFkIHBhZ2Ug d2l0aCByZWYgYXBwcm9wcmlhdGVseSBpbmNyZW1lbnRlZCwKICAqIG9yIE5VTEwgaWYgdGhhdCBm YWlsZWQuCkBAIC0xMTY3LDEzICsxMTc0LDIzIEBAIGxvbmcgZ2V0X3VzZXJfcGFnZXNfcmVtb3Rl KHN0cnVjdCB0YXNrX3N0cnVjdCAqdHNrLCBzdHJ1Y3QgbW1fc3RydWN0ICptbSwKIAkJc3RydWN0 IHZtX2FyZWFfc3RydWN0ICoqdm1hcywgaW50ICpsb2NrZWQpCiB7CiAJLyoKLQkgKiBGSVhNRTog Q3VycmVudCBGT0xMX0xPTkdURVJNIGJlaGF2aW9yIGlzIGluY29tcGF0aWJsZSB3aXRoCisJICog UGFydHMgb2YgRk9MTF9MT05HVEVSTSBiZWhhdmlvciBhcmUgaW5jb21wYXRpYmxlIHdpdGgKIAkg KiBGQVVMVF9GTEFHX0FMTE9XX1JFVFJZIGJlY2F1c2Ugb2YgdGhlIEZTIERBWCBjaGVjayByZXF1 aXJlbWVudCBvbgotCSAqIHZtYXMuICBBcyB0aGVyZSBhcmUgbm8gdXNlcnMgb2YgdGhpcyBmbGFn IGluIHRoaXMgY2FsbCB3ZSBzaW1wbHkKLQkgKiBkaXNhbGxvdyB0aGlzIG9wdGlvbiBmb3Igbm93 LgorCSAqIHZtYXMuIEhvd2V2ZXIsIHRoaXMgb25seSBjb21lcyB1cCBpZiBsb2NrZWQgaXMgc2V0 LCBhbmQgdGhlcmUgYXJlCisJICogY2FsbGVycyB0aGF0IGRvIHJlcXVlc3QgRk9MTF9MT05HVEVS TSwgYnV0IGRvIG5vdCBzZXQgbG9ja2VkLiBTbywKKwkgKiBhbGxvdyB3aGF0IHdlIGNhbi4KIAkg Ki8KLQlpZiAoV0FSTl9PTl9PTkNFKGd1cF9mbGFncyAmIEZPTExfTE9OR1RFUk0pKQotCQlyZXR1 cm4gLUVJTlZBTDsKKwlpZiAoZ3VwX2ZsYWdzICYgRk9MTF9MT05HVEVSTSkgeworCQlpZiAoV0FS Tl9PTl9PTkNFKGxvY2tlZCkpCisJCQlyZXR1cm4gLUVJTlZBTDsKKwkJLyoKKwkJICogVGhpcyB3 aWxsIGNoZWNrIHRoZSB2bWFzIChldmVuIGlmIG91ciB2bWFzIGFyZyBpcyBOVUxMKQorCQkgKiBh bmQgcmV0dXJuIC1FTk9UU1VQUCBpZiBEQVggaXNuJ3QgYWxsb3dlZCBpbiB0aGlzIGNhc2U6CisJ CSAqLworCQlyZXR1cm4gX19ndXBfbG9uZ3Rlcm1fbG9ja2VkKHRzaywgbW0sIHN0YXJ0LCBucl9w YWdlcywgcGFnZXMsCisJCQkJCSAgICAgdm1hcywgZ3VwX2ZsYWdzIHwgRk9MTF9UT1VDSCB8CisJ CQkJCSAgICAgRk9MTF9SRU1PVEUpOworCX0KIAogCXJldHVybiBfX2dldF91c2VyX3BhZ2VzX2xv Y2tlZCh0c2ssIG1tLCBzdGFydCwgbnJfcGFnZXMsIHBhZ2VzLCB2bWFzLAogCQkJCSAgICAgICBs b2NrZWQsCi0tIAoyLjI0LjAKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNr dG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2Ry aS1kZXZlbA==