From mboxrd@z Thu Jan 1 00:00:00 1970 From: Alex Williamson Subject: Re: [PATCH v7 09/24] vfio, mm: fix get_user_pages_remote() and FOLL_LONGTERM Date: Thu, 21 Nov 2019 14:35:25 -0700 Message-ID: <20191121143525.50deb72f@x1.home> References: <20191121071354.456618-1-jhubbard@nvidia.com> <20191121071354.456618-10-jhubbard@nvidia.com> Mime-Version: 1.0 Content-Type: text/plain; charset=WINDOWS-1252 Content-Transfer-Encoding: quoted-printable Return-path: In-Reply-To: <20191121071354.456618-10-jhubbard@nvidia.com> Sender: linux-kernel-owner@vger.kernel.org To: John Hubbard Cc: Andrew Morton , Al Viro , Benjamin Herrenschmidt , =?UTF-8?B?QmrDtnJuIFTDtnBlbA==?= , 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?B?SsOpcsO0?= =?UTF-8?B?bWU=?= Glisse , Magnus Karlsson , Mauro Carvalho Chehab , Michael Ellerman List-Id: dri-devel@lists.freedesktop.org On Wed, 20 Nov 2019 23:13:39 -0800 John Hubbard wrote: > 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. >=20 > 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. >=20 > 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. >=20 > 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(). >=20 > 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. >=20 > Thanks to Jason Gunthorpe for pointing out a clean way to fix this, > and to Dan Williams for helping clarify the DAX refactoring. >=20 > 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(-) Tested with device assignment and Intel mdev vGPU assignment with QEMU userspace: Tested-by: Alex Williamson Acked-by: Alex Williamson Feel free to include for 19/24 as well. Thanks, Alex > diff --git a/drivers/vfio/vfio_iommu_type1.c b/drivers/vfio/vfio_iommu_ty= pe1.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, unsign= ed long vaddr, > { > =09struct page *page[1]; > =09struct vm_area_struct *vma; > -=09struct vm_area_struct *vmas[1]; > =09unsigned int flags =3D 0; > =09int ret; > =20 > @@ -348,33 +347,14 @@ static int vaddr_get_pfn(struct mm_struct *mm, unsi= gned long vaddr, > =09=09flags |=3D FOLL_WRITE; > =20 > =09down_read(&mm->mmap_sem); > -=09if (mm =3D=3D current->mm) { > -=09=09ret =3D get_user_pages(vaddr, 1, flags | FOLL_LONGTERM, page, > -=09=09=09=09 vmas); > -=09} else { > -=09=09ret =3D get_user_pages_remote(NULL, mm, vaddr, 1, flags, page, > -=09=09=09=09=09 vmas, NULL); > -=09=09/* > -=09=09 * The lifetime of a vaddr_get_pfn() page pin is > -=09=09 * userspace-controlled. In the fs-dax case this could > -=09=09 * lead to indefinite stalls in filesystem operations. > -=09=09 * Disallow attempts to pin fs-dax pages via this > -=09=09 * interface. > -=09=09 */ > -=09=09if (ret > 0 && vma_is_fsdax(vmas[0])) { > -=09=09=09ret =3D -EOPNOTSUPP; > -=09=09=09put_page(page[0]); > -=09=09} > -=09} > -=09up_read(&mm->mmap_sem); > - > +=09ret =3D get_user_pages_remote(NULL, mm, vaddr, 1, flags | FOLL_LONGTE= RM, > +=09=09=09=09 page, NULL, NULL); > =09if (ret =3D=3D 1) { > =09=09*pfn =3D page_to_pfn(page[0]); > -=09=09return 0; > +=09=09ret =3D 0; > +=09=09goto done; > =09} > =20 > -=09down_read(&mm->mmap_sem); > - > =09vaddr =3D untagged_addr(vaddr); > =20 > =09vma =3D find_vma_intersection(mm, vaddr, vaddr + 1); > @@ -384,7 +364,7 @@ static int vaddr_get_pfn(struct mm_struct *mm, unsign= ed long vaddr, > =09=09if (is_invalid_reserved_pfn(*pfn)) > =09=09=09ret =3D 0; > =09} > - > +done: > =09up_read(&mm->mmap_sem); > =09return 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 { > =09unsigned int page_mask; > }; > =20 > +static __always_inline long __gup_longterm_locked(struct task_struct *ts= k, > +=09=09=09=09=09=09 struct mm_struct *mm, > +=09=09=09=09=09=09 unsigned long start, > +=09=09=09=09=09=09 unsigned long nr_pages, > +=09=09=09=09=09=09 struct page **pages, > +=09=09=09=09=09=09 struct vm_area_struct **vmas, > +=09=09=09=09=09=09 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 *ts= k, struct mm_struct *mm, > =09=09struct vm_area_struct **vmas, int *locked) > { > =09/* > -=09 * FIXME: Current FOLL_LONGTERM behavior is incompatible with > +=09 * Parts of FOLL_LONGTERM behavior are incompatible with > =09 * FAULT_FLAG_ALLOW_RETRY because of the FS DAX check requirement on > -=09 * vmas. As there are no users of this flag in this call we simply > -=09 * disallow this option for now. > +=09 * vmas. However, this only comes up if locked is set, and there are > +=09 * callers that do request FOLL_LONGTERM, but do not set locked. So, > +=09 * allow what we can. > =09 */ > -=09if (WARN_ON_ONCE(gup_flags & FOLL_LONGTERM)) > -=09=09return -EINVAL; > +=09if (gup_flags & FOLL_LONGTERM) { > +=09=09if (WARN_ON_ONCE(locked)) > +=09=09=09return -EINVAL; > +=09=09/* > +=09=09 * This will check the vmas (even if our vmas arg is NULL) > +=09=09 * and return -ENOTSUPP if DAX isn't allowed in this case: > +=09=09 */ > +=09=09return __gup_longterm_locked(tsk, mm, start, nr_pages, pages, > +=09=09=09=09=09 vmas, gup_flags | FOLL_TOUCH | > +=09=09=09=09=09 FOLL_REMOTE); > +=09} > =20 > =09return __get_user_pages_locked(tsk, mm, start, nr_pages, pages, vmas, > =09=09=09=09 locked, 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=-6.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS 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 C79AAC432C0 for ; Thu, 21 Nov 2019 21:35:43 +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 A6298206CC for ; Thu, 21 Nov 2019 21:35:43 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org A6298206CC Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.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 CCF2F6E198; Thu, 21 Nov 2019 21:35:42 +0000 (UTC) Received: from us-smtp-1.mimecast.com (us-smtp-delivery-1.mimecast.com [207.211.31.120]) by gabe.freedesktop.org (Postfix) with ESMTPS id 24DD56E1B4 for ; Thu, 21 Nov 2019 21:35:41 +0000 (UTC) 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-353-_8mqkejRPqeFlprORl3o9g-1; Thu, 21 Nov 2019 16:35:36 -0500 Received: from smtp.corp.redhat.com (int-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.12]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 42006801E58; Thu, 21 Nov 2019 21:35:30 +0000 (UTC) Received: from x1.home (ovpn-116-56.phx2.redhat.com [10.3.116.56]) by smtp.corp.redhat.com (Postfix) with ESMTP id 2C5BA6E703; Thu, 21 Nov 2019 21:35:26 +0000 (UTC) Date: Thu, 21 Nov 2019 14:35:25 -0700 From: Alex Williamson To: John Hubbard Subject: Re: [PATCH v7 09/24] vfio, mm: fix get_user_pages_remote() and FOLL_LONGTERM Message-ID: <20191121143525.50deb72f@x1.home> In-Reply-To: <20191121071354.456618-10-jhubbard@nvidia.com> References: <20191121071354.456618-1-jhubbard@nvidia.com> <20191121071354.456618-10-jhubbard@nvidia.com> Organization: Red Hat MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.12 X-MC-Unique: _8mqkejRPqeFlprORl3o9g-1 X-Mimecast-Spam-Score: 0 X-Mailman-Original-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1574372140; 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=YslT4VlrB9mGxRqN5ZKGkdoWX+pImdvI3tx38/mJv/g=; b=X5e4M4gv3jIIaalyhLHz98y4WPGTAt2U5QYMx9b2Z1s9gCtZVRefmRPFttHQUqiEIl8QFP PsT25fJF1s1rpy8vuyo3yenWJ1n3ZRKH4RoSkAYN+ewndTVqtmkDd77b2TNO/GunrzQ51S WivTfa13X529VOdxcBmCAY1A0q11jzo= 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, 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?B?QmrDtnJuIFTDtnBlbA==?= , linux-media@vger.kernel.org, Shuah Khan , linux-block@vger.kernel.org, =?UTF-8?B?SsOpcsO0?= =?UTF-8?B?bWU=?= Glisse , Al Viro , Dan Williams , Mauro Carvalho Chehab , bpf@vger.kernel.org, Magnus Karlsson , Jens Axboe , netdev@vger.kernel.org, LKML , linux-fsdevel@vger.kernel.org, Andrew Morton , 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: <20191121213525.PQrxyj7KFuDYTkIMGIjle6JLI3ccQd7eVHcjF7EYcGU@z> T24gV2VkLCAyMCBOb3YgMjAxOSAyMzoxMzozOSAtMDgwMApKb2huIEh1YmJhcmQgPGpodWJiYXJk QG52aWRpYS5jb20+IHdyb3RlOgoKPiBBcyBpdCBzYXlzIGluIHRoZSB1cGRhdGVkIGNvbW1lbnQg aW4gZ3VwLmM6IGN1cnJlbnQgRk9MTF9MT05HVEVSTQo+IGJlaGF2aW9yIGlzIGluY29tcGF0aWJs ZSB3aXRoIEZBVUxUX0ZMQUdfQUxMT1dfUkVUUlkgYmVjYXVzZSBvZiB0aGUKPiBGUyBEQVggY2hl Y2sgcmVxdWlyZW1lbnQgb24gdm1hcy4KPiAKPiBIb3dldmVyLCB0aGUgY29ycmVzcG9uZGluZyBy ZXN0cmljdGlvbiBpbiBnZXRfdXNlcl9wYWdlc19yZW1vdGUoKSB3YXMKPiBzbGlnaHRseSBzdHJp Y3RlciB0aGFuIGlzIGFjdHVhbGx5IHJlcXVpcmVkOiBpdCBmb3JiYWRlIGFsbAo+IEZPTExfTE9O R1RFUk0gY2FsbGVycywgYnV0IHdlIGNhbiBhY3R1YWxseSBhbGxvdyBGT0xMX0xPTkdURVJNIGNh bGxlcnMKPiB0aGF0IGRvIG5vdCBzZXQgdGhlICJsb2NrZWQiIGFyZy4KPiAKPiBVcGRhdGUgdGhl IGNvZGUgYW5kIGNvbW1lbnRzIGFjY29yZGluZ2x5LCBhbmQgdXBkYXRlIHRoZSBWRklPIGNhbGxl cgo+IHRvIHRha2UgYWR2YW50YWdlIG9mIHRoaXMsIGZpeGluZyBhIGJ1ZyBhcyBhIHJlc3VsdDog dGhlIFZGSU8gY2FsbGVyCj4gaXMgbG9naWNhbGx5IGEgRk9MTF9MT05HVEVSTSB1c2VyLgo+IAo+ IEFsc28sIHJlbW92ZSBhbiB1bm5lc3NhcnkgcGFpciBvZiBjYWxscyB0aGF0IHdlcmUgcmVsZWFz aW5nIGFuZAo+IHJlYWNxdWlyaW5nIHRoZSBtbWFwX3NlbS4gVGhlcmUgaXMgbm8gbmVlZCB0byBh dm9pZCBob2xkaW5nIG1tYXBfc2VtCj4ganVzdCBpbiBvcmRlciB0byBjYWxsIHBhZ2VfdG9fcGZu KCkuCj4gCj4gQWxzbywgbW92ZSB0aGUgREFYIGNoZWNrICgiaWYgYSBWTUEgaXMgREFYLCBkb24n dCBhbGxvdyBsb25nIHRlcm0KPiBwaW5uaW5nIikgZnJvbSB0aGUgVkZJTyBjYWxsIHNpdGUsIGFs bCB0aGUgd2F5IGludG8gdGhlIGludGVybmFscwo+IG9mIGdldF91c2VyX3BhZ2VzX3JlbW90ZSgp IGFuZCBfX2d1cF9sb25ndGVybV9sb2NrZWQoKS4gVGhhdCBpczoKPiBnZXRfdXNlcl9wYWdlc19y ZW1vdGUoKSBjYWxscyBfX2d1cF9sb25ndGVybV9sb2NrZWQoKSwgd2hpY2ggaW4gdHVybgo+IGNh bGxzIGNoZWNrX2RheF92bWFzKCkuIEl0J3MgbGlnaHRseSBleHBsYWluZWQgaW4gdGhlIGNvbW1l bnRzIGFzIHdlbGwuCj4gCj4gVGhhbmtzIHRvIEphc29uIEd1bnRob3JwZSBmb3IgcG9pbnRpbmcg b3V0IGEgY2xlYW4gd2F5IHRvIGZpeCB0aGlzLAo+IGFuZCB0byBEYW4gV2lsbGlhbXMgZm9yIGhl bHBpbmcgY2xhcmlmeSB0aGUgREFYIHJlZmFjdG9yaW5nLgo+IAo+IFJldmlld2VkLWJ5OiBKYXNv biBHdW50aG9ycGUgPGpnZ0BtZWxsYW5veC5jb20+Cj4gUmV2aWV3ZWQtYnk6IElyYSBXZWlueSA8 aXJhLndlaW55QGludGVsLmNvbT4KPiBTdWdnZXN0ZWQtYnk6IEphc29uIEd1bnRob3JwZSA8amdn QHppZXBlLmNhPgo+IENjOiBEYW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1zQGludGVsLmNvbT4K PiBDYzogSmVyb21lIEdsaXNzZSA8amdsaXNzZUByZWRoYXQuY29tPgo+IFNpZ25lZC1vZmYtYnk6 IEpvaG4gSHViYmFyZCA8amh1YmJhcmRAbnZpZGlhLmNvbT4KPiAtLS0KPiAgZHJpdmVycy92Zmlv L3ZmaW9faW9tbXVfdHlwZTEuYyB8IDMwICsrKysrLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+ ICBtbS9ndXAuYyAgICAgICAgICAgICAgICAgICAgICAgIHwgMjcgKysrKysrKysrKysrKysrKysr KysrKy0tLS0tCj4gIDIgZmlsZXMgY2hhbmdlZCwgMjcgaW5zZXJ0aW9ucygrKSwgMzAgZGVsZXRp b25zKC0pCgpUZXN0ZWQgd2l0aCBkZXZpY2UgYXNzaWdubWVudCBhbmQgSW50ZWwgbWRldiB2R1BV IGFzc2lnbm1lbnQgd2l0aCBRRU1VCnVzZXJzcGFjZToKClRlc3RlZC1ieTogQWxleCBXaWxsaWFt c29uIDxhbGV4LndpbGxpYW1zb25AcmVkaGF0LmNvbT4KQWNrZWQtYnk6IEFsZXggV2lsbGlhbXNv biA8YWxleC53aWxsaWFtc29uQHJlZGhhdC5jb20+CgpGZWVsIGZyZWUgdG8gaW5jbHVkZSBmb3Ig MTkvMjQgYXMgd2VsbC4gIFRoYW5rcywKCkFsZXgKCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmZp by92ZmlvX2lvbW11X3R5cGUxLmMgYi9kcml2ZXJzL3ZmaW8vdmZpb19pb21tdV90eXBlMS5jCj4g aW5kZXggZDg2NDI3N2VhMTZmLi5jN2ExMTFhZDk5NzUgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy92 ZmlvL3ZmaW9faW9tbXVfdHlwZTEuYwo+ICsrKyBiL2RyaXZlcnMvdmZpby92ZmlvX2lvbW11X3R5 cGUxLmMKPiBAQCAtMzQwLDcgKzM0MCw2IEBAIHN0YXRpYyBpbnQgdmFkZHJfZ2V0X3BmbihzdHJ1 Y3QgbW1fc3RydWN0ICptbSwgdW5zaWduZWQgbG9uZyB2YWRkciwKPiAgewo+ICAJc3RydWN0IHBh Z2UgKnBhZ2VbMV07Cj4gIAlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYTsKPiAtCXN0cnVjdCB2 bV9hcmVhX3N0cnVjdCAqdm1hc1sxXTsKPiAgCXVuc2lnbmVkIGludCBmbGFncyA9IDA7Cj4gIAlp bnQgcmV0Owo+ICAKPiBAQCAtMzQ4LDMzICszNDcsMTQgQEAgc3RhdGljIGludCB2YWRkcl9nZXRf cGZuKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCB1bnNpZ25lZCBsb25nIHZhZGRyLAo+ICAJCWZsYWdz IHw9IEZPTExfV1JJVEU7Cj4gIAo+ICAJZG93bl9yZWFkKCZtbS0+bW1hcF9zZW0pOwo+IC0JaWYg KG1tID09IGN1cnJlbnQtPm1tKSB7Cj4gLQkJcmV0ID0gZ2V0X3VzZXJfcGFnZXModmFkZHIsIDEs IGZsYWdzIHwgRk9MTF9MT05HVEVSTSwgcGFnZSwKPiAtCQkJCSAgICAgdm1hcyk7Cj4gLQl9IGVs c2Ugewo+IC0JCXJldCA9IGdldF91c2VyX3BhZ2VzX3JlbW90ZShOVUxMLCBtbSwgdmFkZHIsIDEs IGZsYWdzLCBwYWdlLAo+IC0JCQkJCSAgICB2bWFzLCBOVUxMKTsKPiAtCQkvKgo+IC0JCSAqIFRo ZSBsaWZldGltZSBvZiBhIHZhZGRyX2dldF9wZm4oKSBwYWdlIHBpbiBpcwo+IC0JCSAqIHVzZXJz cGFjZS1jb250cm9sbGVkLiBJbiB0aGUgZnMtZGF4IGNhc2UgdGhpcyBjb3VsZAo+IC0JCSAqIGxl YWQgdG8gaW5kZWZpbml0ZSBzdGFsbHMgaW4gZmlsZXN5c3RlbSBvcGVyYXRpb25zLgo+IC0JCSAq IERpc2FsbG93IGF0dGVtcHRzIHRvIHBpbiBmcy1kYXggcGFnZXMgdmlhIHRoaXMKPiAtCQkgKiBp bnRlcmZhY2UuCj4gLQkJICovCj4gLQkJaWYgKHJldCA+IDAgJiYgdm1hX2lzX2ZzZGF4KHZtYXNb MF0pKSB7Cj4gLQkJCXJldCA9IC1FT1BOT1RTVVBQOwo+IC0JCQlwdXRfcGFnZShwYWdlWzBdKTsK PiAtCQl9Cj4gLQl9Cj4gLQl1cF9yZWFkKCZtbS0+bW1hcF9zZW0pOwo+IC0KPiArCXJldCA9IGdl dF91c2VyX3BhZ2VzX3JlbW90ZShOVUxMLCBtbSwgdmFkZHIsIDEsIGZsYWdzIHwgRk9MTF9MT05H VEVSTSwKPiArCQkJCSAgICBwYWdlLCBOVUxMLCBOVUxMKTsKPiAgCWlmIChyZXQgPT0gMSkgewo+ ICAJCSpwZm4gPSBwYWdlX3RvX3BmbihwYWdlWzBdKTsKPiAtCQlyZXR1cm4gMDsKPiArCQlyZXQg PSAwOwo+ICsJCWdvdG8gZG9uZTsKPiAgCX0KPiAgCj4gLQlkb3duX3JlYWQoJm1tLT5tbWFwX3Nl bSk7Cj4gLQo+ICAJdmFkZHIgPSB1bnRhZ2dlZF9hZGRyKHZhZGRyKTsKPiAgCj4gIAl2bWEgPSBm aW5kX3ZtYV9pbnRlcnNlY3Rpb24obW0sIHZhZGRyLCB2YWRkciArIDEpOwo+IEBAIC0zODQsNyAr MzY0LDcgQEAgc3RhdGljIGludCB2YWRkcl9nZXRfcGZuKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCB1 bnNpZ25lZCBsb25nIHZhZGRyLAo+ICAJCWlmIChpc19pbnZhbGlkX3Jlc2VydmVkX3BmbigqcGZu KSkKPiAgCQkJcmV0ID0gMDsKPiAgCX0KPiAtCj4gK2RvbmU6Cj4gIAl1cF9yZWFkKCZtbS0+bW1h cF9zZW0pOwo+ICAJcmV0dXJuIHJldDsKPiAgfQo+IGRpZmYgLS1naXQgYS9tbS9ndXAuYyBiL21t L2d1cC5jCj4gaW5kZXggMTRmY2RjNTAyMTY2Li5jY2UyYzk2NzY4NTMgMTAwNjQ0Cj4gLS0tIGEv bW0vZ3VwLmMKPiArKysgYi9tbS9ndXAuYwo+IEBAIC0yOSw2ICsyOSwxMyBAQCBzdHJ1Y3QgZm9s bG93X3BhZ2VfY29udGV4dCB7Cj4gIAl1bnNpZ25lZCBpbnQgcGFnZV9tYXNrOwo+ICB9Owo+ICAK PiArc3RhdGljIF9fYWx3YXlzX2lubGluZSBsb25nIF9fZ3VwX2xvbmd0ZXJtX2xvY2tlZChzdHJ1 Y3QgdGFza19zdHJ1Y3QgKnRzaywKPiArCQkJCQkJICBzdHJ1Y3QgbW1fc3RydWN0ICptbSwKPiAr CQkJCQkJICB1bnNpZ25lZCBsb25nIHN0YXJ0LAo+ICsJCQkJCQkgIHVuc2lnbmVkIGxvbmcgbnJf cGFnZXMsCj4gKwkJCQkJCSAgc3RydWN0IHBhZ2UgKipwYWdlcywKPiArCQkJCQkJICBzdHJ1Y3Qg dm1fYXJlYV9zdHJ1Y3QgKip2bWFzLAo+ICsJCQkJCQkgIHVuc2lnbmVkIGludCBmbGFncyk7Cj4g IC8qCj4gICAqIFJldHVybiB0aGUgY29tcG91bmQgaGVhZCBwYWdlIHdpdGggcmVmIGFwcHJvcHJp YXRlbHkgaW5jcmVtZW50ZWQsCj4gICAqIG9yIE5VTEwgaWYgdGhhdCBmYWlsZWQuCj4gQEAgLTEx NjcsMTMgKzExNzQsMjMgQEAgbG9uZyBnZXRfdXNlcl9wYWdlc19yZW1vdGUoc3RydWN0IHRhc2tf c3RydWN0ICp0c2ssIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLAo+ICAJCXN0cnVjdCB2bV9hcmVhX3N0 cnVjdCAqKnZtYXMsIGludCAqbG9ja2VkKQo+ICB7Cj4gIAkvKgo+IC0JICogRklYTUU6IEN1cnJl bnQgRk9MTF9MT05HVEVSTSBiZWhhdmlvciBpcyBpbmNvbXBhdGlibGUgd2l0aAo+ICsJICogUGFy dHMgb2YgRk9MTF9MT05HVEVSTSBiZWhhdmlvciBhcmUgaW5jb21wYXRpYmxlIHdpdGgKPiAgCSAq IEZBVUxUX0ZMQUdfQUxMT1dfUkVUUlkgYmVjYXVzZSBvZiB0aGUgRlMgREFYIGNoZWNrIHJlcXVp cmVtZW50IG9uCj4gLQkgKiB2bWFzLiAgQXMgdGhlcmUgYXJlIG5vIHVzZXJzIG9mIHRoaXMgZmxh ZyBpbiB0aGlzIGNhbGwgd2Ugc2ltcGx5Cj4gLQkgKiBkaXNhbGxvdyB0aGlzIG9wdGlvbiBmb3Ig bm93Lgo+ICsJICogdm1hcy4gSG93ZXZlciwgdGhpcyBvbmx5IGNvbWVzIHVwIGlmIGxvY2tlZCBp cyBzZXQsIGFuZCB0aGVyZSBhcmUKPiArCSAqIGNhbGxlcnMgdGhhdCBkbyByZXF1ZXN0IEZPTExf TE9OR1RFUk0sIGJ1dCBkbyBub3Qgc2V0IGxvY2tlZC4gU28sCj4gKwkgKiBhbGxvdyB3aGF0IHdl IGNhbi4KPiAgCSAqLwo+IC0JaWYgKFdBUk5fT05fT05DRShndXBfZmxhZ3MgJiBGT0xMX0xPTkdU RVJNKSkKPiAtCQlyZXR1cm4gLUVJTlZBTDsKPiArCWlmIChndXBfZmxhZ3MgJiBGT0xMX0xPTkdU RVJNKSB7Cj4gKwkJaWYgKFdBUk5fT05fT05DRShsb2NrZWQpKQo+ICsJCQlyZXR1cm4gLUVJTlZB TDsKPiArCQkvKgo+ICsJCSAqIFRoaXMgd2lsbCBjaGVjayB0aGUgdm1hcyAoZXZlbiBpZiBvdXIg dm1hcyBhcmcgaXMgTlVMTCkKPiArCQkgKiBhbmQgcmV0dXJuIC1FTk9UU1VQUCBpZiBEQVggaXNu J3QgYWxsb3dlZCBpbiB0aGlzIGNhc2U6Cj4gKwkJICovCj4gKwkJcmV0dXJuIF9fZ3VwX2xvbmd0 ZXJtX2xvY2tlZCh0c2ssIG1tLCBzdGFydCwgbnJfcGFnZXMsIHBhZ2VzLAo+ICsJCQkJCSAgICAg dm1hcywgZ3VwX2ZsYWdzIHwgRk9MTF9UT1VDSCB8Cj4gKwkJCQkJICAgICBGT0xMX1JFTU9URSk7 Cj4gKwl9Cj4gIAo+ICAJcmV0dXJuIF9fZ2V0X3VzZXJfcGFnZXNfbG9ja2VkKHRzaywgbW0sIHN0 YXJ0LCBucl9wYWdlcywgcGFnZXMsIHZtYXMsCj4gIAkJCQkgICAgICAgbG9ja2VkLAoKX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxp bmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJl ZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVs