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=-8.3 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,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 BC74ECA9EB5 for ; Mon, 4 Nov 2019 18:52:58 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 805762080F for ; Mon, 4 Nov 2019 18:52:58 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="AwPUH1Gw" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728268AbfKDSw5 (ORCPT ); Mon, 4 Nov 2019 13:52:57 -0500 Received: from us-smtp-1.mimecast.com ([205.139.110.61]:54331 "EHLO us-smtp-delivery-1.mimecast.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1728409AbfKDSw5 (ORCPT ); Mon, 4 Nov 2019 13:52:57 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1572893575; 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=vhvFv/gKEXA1cmin4yO0xx1/Gf0U1DoUV0cjNAwwQns=; b=AwPUH1Gw9pb2VEuimGsZm+pjX1CrtX1/7Ed6HwMaKy/ZPUFZ0zSVYAO0Z54UIpDwl8H69t gWhD+1ZLensUPVPHSFxB9TOGSe88J7eC6ZI4L0LyPYTrr9ONpXlB7K7kmlv9RccXfesO2B tzG2CoqH/FEbnYvo+xskH7FTRFMnj4E= 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-106-BYegrK4JPIWXqhL6bCqv8A-1; Mon, 04 Nov 2019 13:52:51 -0500 Received: from smtp.corp.redhat.com (int-mx03.intmail.prod.int.phx2.redhat.com [10.5.11.13]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 0F2011800D53; Mon, 4 Nov 2019 18:52:47 +0000 (UTC) Received: from redhat.com (unknown [10.20.6.178]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 1977960878; Mon, 4 Nov 2019 18:52:40 +0000 (UTC) Date: Mon, 4 Nov 2019 13:52:38 -0500 From: Jerome Glisse To: John Hubbard Cc: Andrew Morton , Al Viro , Alex Williamson , Benjamin Herrenschmidt , =?iso-8859-1?Q?Bj=F6rn_T=F6pel?= , Christoph Hellwig , Dan Williams , Daniel Vetter , Dave Chinner , David Airlie , "David S . Miller" , Ira Weiny , Jan Kara , Jason Gunthorpe , Jens Axboe , Jonathan Corbet , Magnus Karlsson , Mauro Carvalho Chehab , Michael Ellerman , Michal Hocko , Mike Kravetz , Paul Mackerras , Shuah Khan , Vlastimil Babka , bpf@vger.kernel.org, dri-devel@lists.freedesktop.org, kvm@vger.kernel.org, linux-block@vger.kernel.org, linux-doc@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kselftest@vger.kernel.org, linux-media@vger.kernel.org, linux-rdma@vger.kernel.org, linuxppc-dev@lists.ozlabs.org, netdev@vger.kernel.org, linux-mm@kvack.org, LKML Subject: Re: [PATCH v2 12/18] mm/gup: track FOLL_PIN pages Message-ID: <20191104185238.GG5134@redhat.com> References: <20191103211813.213227-1-jhubbard@nvidia.com> <20191103211813.213227-13-jhubbard@nvidia.com> MIME-Version: 1.0 In-Reply-To: <20191103211813.213227-13-jhubbard@nvidia.com> User-Agent: Mutt/1.12.1 (2019-06-15) X-Scanned-By: MIMEDefang 2.79 on 10.5.11.13 X-MC-Unique: BYegrK4JPIWXqhL6bCqv8A-1 X-Mimecast-Spam-Score: 0 Content-Type: text/plain; charset=WINDOWS-1252 Content-Transfer-Encoding: quoted-printable Content-Disposition: inline Sender: bpf-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: bpf@vger.kernel.org On Sun, Nov 03, 2019 at 01:18:07PM -0800, John Hubbard wrote: > Add tracking of pages that were pinned via FOLL_PIN. >=20 > As mentioned in the FOLL_PIN documentation, callers who effectively set > FOLL_PIN are required to ultimately free such pages via put_user_page(). > The effect is similar to FOLL_GET, and may be thought of as "FOLL_GET > for DIO and/or RDMA use". >=20 > Pages that have been pinned via FOLL_PIN are identifiable via a > new function call: >=20 > bool page_dma_pinned(struct page *page); >=20 > What to do in response to encountering such a page, is left to later > patchsets. There is discussion about this in [1]. >=20 > This also changes a BUG_ON(), to a WARN_ON(), in follow_page_mask(). >=20 > This also has a couple of trivial, non-functional change fixes to > try_get_compound_head(). That function got moved to the top of the > file. Maybe split that as a separate trivial patch. >=20 > This includes the following fix from Ira Weiny: >=20 > DAX requires detection of a page crossing to a ref count of 1. Fix this > for GUP pages by introducing put_devmap_managed_user_page() which > accounts for GUP_PIN_COUNTING_BIAS now used by GUP. Please do the put_devmap_managed_page() changes in a separate patch, it would be a lot easier to follow, also on that front see comments below. >=20 > [1] https://lwn.net/Articles/784574/ "Some slow progress on > get_user_pages()" >=20 > Suggested-by: Jan Kara > Suggested-by: J=E9r=F4me Glisse > Signed-off-by: Ira Weiny > Signed-off-by: John Hubbard > --- > include/linux/mm.h | 80 +++++++++++---- > include/linux/mmzone.h | 2 + > include/linux/page_ref.h | 10 ++ > mm/gup.c | 213 +++++++++++++++++++++++++++++++-------- > mm/huge_memory.c | 32 +++++- > mm/hugetlb.c | 28 ++++- > mm/memremap.c | 4 +- > mm/vmstat.c | 2 + > 8 files changed, 300 insertions(+), 71 deletions(-) >=20 > diff --git a/include/linux/mm.h b/include/linux/mm.h > index cdfb6fedb271..03b3600843b7 100644 > --- a/include/linux/mm.h > +++ b/include/linux/mm.h > @@ -972,9 +972,10 @@ static inline bool is_zone_device_page(const struct = page *page) > #endif > =20 > #ifdef CONFIG_DEV_PAGEMAP_OPS > -void __put_devmap_managed_page(struct page *page); > +void __put_devmap_managed_page(struct page *page, int count); > DECLARE_STATIC_KEY_FALSE(devmap_managed_key); > -static inline bool put_devmap_managed_page(struct page *page) > + > +static inline bool page_is_devmap_managed(struct page *page) > { > =09if (!static_branch_unlikely(&devmap_managed_key)) > =09=09return false; > @@ -983,7 +984,6 @@ static inline bool put_devmap_managed_page(struct pag= e *page) > =09switch (page->pgmap->type) { > =09case MEMORY_DEVICE_PRIVATE: > =09case MEMORY_DEVICE_FS_DAX: > -=09=09__put_devmap_managed_page(page); > =09=09return true; > =09default: > =09=09break; > @@ -991,6 +991,19 @@ static inline bool put_devmap_managed_page(struct pa= ge *page) > =09return false; > } > =20 > +static inline bool put_devmap_managed_page(struct page *page) > +{ > +=09bool is_devmap =3D page_is_devmap_managed(page); > + > +=09if (is_devmap) { > +=09=09int count =3D page_ref_dec_return(page); > + > +=09=09__put_devmap_managed_page(page, count); > +=09} > + > +=09return is_devmap; > +} I think the __put_devmap_managed_page() should be rename to free_devmap_managed_page() and that the count !=3D 1 case move to this inline function ie: static inline bool put_devmap_managed_page(struct page *page) { =09bool is_devmap =3D page_is_devmap_managed(page); =09if (is_devmap) { =09=09int count =3D page_ref_dec_return(page); =09=09/* =09=09 * If refcount is 1 then page is freed and refcount is stable as nobo= dy =09=09 * holds a reference on the page. =09=09 */ =09=09if (count =3D=3D 1) =09=09=09free_devmap_managed_page(page, count); =09=09else if (!count) =09=09=09__put_page(page); =09} =09return is_devmap; } > + > #else /* CONFIG_DEV_PAGEMAP_OPS */ > static inline bool put_devmap_managed_page(struct page *page) > { > @@ -1038,6 +1051,8 @@ static inline __must_check bool try_get_page(struct= page *page) > =09return true; > } > =20 > +__must_check bool user_page_ref_inc(struct page *page); > + What about having it as an inline here as it is pretty small. > static inline void put_page(struct page *page) > { > =09page =3D compound_head(page); > @@ -1055,31 +1070,56 @@ static inline void put_page(struct page *page) > =09=09__put_page(page); > } > =20 > -/** > - * put_user_page() - release a gup-pinned page > - * @page: pointer to page to be released > +/* > + * GUP_PIN_COUNTING_BIAS, and the associated functions that use it, over= load > + * the page's refcount so that two separate items are tracked: the origi= nal page > + * reference count, and also a new count of how many get_user_pages() ca= lls were > + * made against the page. ("gup-pinned" is another term for the latter). > + * > + * With this scheme, get_user_pages() becomes special: such pages are ma= rked > + * as distinct from normal pages. As such, the new put_user_page() call = (and > + * its variants) must be used in order to release gup-pinned pages. > + * > + * Choice of value: > * > - * Pages that were pinned via get_user_pages*() must be released via > - * either put_user_page(), or one of the put_user_pages*() routines > - * below. This is so that eventually, pages that are pinned via > - * get_user_pages*() can be separately tracked and uniquely handled. In > - * particular, interactions with RDMA and filesystems need special > - * handling. > + * By making GUP_PIN_COUNTING_BIAS a power of two, debugging of page ref= erence > + * counts with respect to get_user_pages() and put_user_page() becomes s= impler, > + * due to the fact that adding an even power of two to the page refcount= has > + * the effect of using only the upper N bits, for the code that counts u= p using > + * the bias value. This means that the lower bits are left for the exclu= sive > + * use of the original code that increments and decrements by one (or at= least, > + * by much smaller values than the bias value). > * > - * put_user_page() and put_page() are not interchangeable, despite this = early > - * implementation that makes them look the same. put_user_page() calls m= ust > - * be perfectly matched up with get_user_page() calls. > + * Of course, once the lower bits overflow into the upper bits (and this= is > + * OK, because subtraction recovers the original values), then visual in= spection > + * no longer suffices to directly view the separate counts. However, for= normal > + * applications that don't have huge page reference counts, this won't b= e an > + * issue. > + * > + * Locking: the lockless algorithm described in page_cache_get_speculati= ve() > + * and page_cache_gup_pin_speculative() provides safe operation for > + * get_user_pages and page_mkclean and other calls that race to set up p= age > + * table entries. > */ > -static inline void put_user_page(struct page *page) > -{ > -=09put_page(page); > -} > +#define GUP_PIN_COUNTING_BIAS (1UL << 10) > =20 > +void put_user_page(struct page *page); > void put_user_pages_dirty_lock(struct page **pages, unsigned long npages= , > =09=09=09 bool make_dirty); > - > void put_user_pages(struct page **pages, unsigned long npages); > =20 > +/** > + * page_dma_pinned() - report if a page is pinned by a call to pin_user_= pages*() > + * or pin_longterm_pages*() > + * @page:=09pointer to page to be queried. > + * @Return:=09True, if it is likely that the page has been "dma-pinned". > + *=09=09False, if the page is definitely not dma-pinned. > + */ Maybe add a small comment about wrap around :) > +static inline bool page_dma_pinned(struct page *page) > +{ > +=09return (page_ref_count(compound_head(page))) >=3D GUP_PIN_COUNTING_BI= AS; > +} > + > #if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP) > #define SECTION_IN_PAGE_FLAGS > #endif [...] > diff --git a/mm/gup.c b/mm/gup.c > index 1aea48427879..c9727e65fad3 100644 > --- a/mm/gup.c > +++ b/mm/gup.c [...] > @@ -1930,12 +2028,20 @@ static int __gup_device_huge(unsigned long pfn, u= nsigned long addr, > =20 > =09=09pgmap =3D get_dev_pagemap(pfn, pgmap); > =09=09if (unlikely(!pgmap)) { > -=09=09=09undo_dev_pagemap(nr, nr_start, pages); > +=09=09=09undo_dev_pagemap(nr, nr_start, flags, pages); > =09=09=09return 0; > =09=09} > =09=09SetPageReferenced(page); > =09=09pages[*nr] =3D page; > -=09=09get_page(page); > + > +=09=09if (flags & FOLL_PIN) { > +=09=09=09if (unlikely(!user_page_ref_inc(page))) { > +=09=09=09=09undo_dev_pagemap(nr, nr_start, flags, pages); > +=09=09=09=09return 0; > +=09=09=09} Maybe add a comment about a case that should never happens ie user_page_ref_inc() fails after the second iteration of the loop as it would be broken and a bug to call undo_dev_pagemap() after the first iteration of that loop. Also i believe that this should never happens as if first iteration succeed than __page_cache_add_speculative() will succeed for all the iterations. Note that the pgmap case above follows that too ie the call to get_dev_pagemap() can only fail on first iteration of the loop, well i assume you can never have a huge device page that span different pgmap ie different devices (which is a reasonable assumption). So maybe this code needs fixing ie : =09=09pgmap =3D get_dev_pagemap(pfn, pgmap); =09=09if (unlikely(!pgmap)) =09=09=09return 0; > +=09=09} else > +=09=09=09get_page(page); > + > =09=09(*nr)++; > =09=09pfn++; > =09} while (addr +=3D PAGE_SIZE, addr !=3D end); [...] > @@ -2409,7 +2540,7 @@ static int internal_get_user_pages_fast(unsigned lo= ng start, int nr_pages, > =09unsigned long addr, len, end; > =09int nr =3D 0, ret =3D 0; > =20 > -=09if (WARN_ON_ONCE(gup_flags & ~(FOLL_WRITE | FOLL_LONGTERM))) > +=09if (WARN_ON_ONCE(gup_flags & ~(FOLL_WRITE | FOLL_LONGTERM | FOLL_PIN)= )) Maybe add a comments to explain, something like: /* * The only flags allowed here are: FOLL_WRITE, FOLL_LONGTERM, FOLL_PIN * * Note that get_user_pages_fast() imply FOLL_GET flag by default but * callers can over-ride this default to pin case by setting FOLL_PIN. */ > =09=09return -EINVAL; > =20 > =09start =3D untagged_addr(start) & PAGE_MASK; > diff --git a/mm/huge_memory.c b/mm/huge_memory.c > index 13cc93785006..66bf4c8b88f1 100644 > --- a/mm/huge_memory.c > +++ b/mm/huge_memory.c [...] > @@ -968,7 +973,12 @@ struct page *follow_devmap_pmd(struct vm_area_struct= *vma, unsigned long addr, > =09if (!*pgmap) > =09=09return ERR_PTR(-EFAULT); > =09page =3D pfn_to_page(pfn); > -=09get_page(page); > + > +=09if (flags & FOLL_GET) > +=09=09get_page(page); > +=09else if (flags & FOLL_PIN) > +=09=09if (unlikely(!user_page_ref_inc(page))) > +=09=09=09page =3D ERR_PTR(-ENOMEM); While i agree that user_page_ref_inc() (ie page_cache_add_speculative()) should never fails here as we are holding the pmd lock and thus no one can unmap the pmd and free the page it points to. I believe you should return -EFAULT like for the pgmap and not -ENOMEM as the pgmap should not fail either for the same reason. Thus it would be better to have consistent error. Maybe also add a comments explaining that it should not fail here. > =20 > =09return page; > } [...] > @@ -1100,7 +1115,7 @@ struct page *follow_devmap_pud(struct vm_area_struc= t *vma, unsigned long addr, > =09 * device mapped pages can only be returned if the > =09 * caller will manage the page reference count. > =09 */ > -=09if (!(flags & FOLL_GET)) > +=09if (!(flags & (FOLL_GET | FOLL_PIN))) > =09=09return ERR_PTR(-EEXIST); Maybe add a comment that FOLL_GET or FOLL_PIN must be set. > =09pfn +=3D (addr & ~PUD_MASK) >> PAGE_SHIFT; > @@ -1108,7 +1123,12 @@ struct page *follow_devmap_pud(struct vm_area_stru= ct *vma, unsigned long addr, > =09if (!*pgmap) > =09=09return ERR_PTR(-EFAULT); > =09page =3D pfn_to_page(pfn); > -=09get_page(page); > + > +=09if (flags & FOLL_GET) > +=09=09get_page(page); > +=09else if (flags & FOLL_PIN) > +=09=09if (unlikely(!user_page_ref_inc(page))) > +=09=09=09page =3D ERR_PTR(-ENOMEM); Same as for follow_devmap_pmd() see above. > =20 > =09return page; > } > @@ -1522,8 +1542,12 @@ struct page *follow_trans_huge_pmd(struct vm_area_= struct *vma, > skip_mlock: > =09page +=3D (addr & ~HPAGE_PMD_MASK) >> PAGE_SHIFT; > =09VM_BUG_ON_PAGE(!PageCompound(page) && !is_zone_device_page(page), pag= e); > + > =09if (flags & FOLL_GET) > =09=09get_page(page); > +=09else if (flags & FOLL_PIN) > +=09=09if (unlikely(!user_page_ref_inc(page))) > +=09=09=09page =3D NULL; This should not fail either as we are holding the pmd lock maybe add a comment. Dunno if we want a WARN() or something to catch this degenerate case, or dump the page. > =20 > out: > =09return page; > diff --git a/mm/hugetlb.c b/mm/hugetlb.c > index b45a95363a84..da335b1cd798 100644 > --- a/mm/hugetlb.c > +++ b/mm/hugetlb.c > @@ -4462,7 +4462,17 @@ long follow_hugetlb_page(struct mm_struct *mm, str= uct vm_area_struct *vma, > same_page: > =09=09if (pages) { > =09=09=09pages[i] =3D mem_map_offset(page, pfn_offset); > -=09=09=09get_page(pages[i]); > + > +=09=09=09if (flags & FOLL_GET) > +=09=09=09=09get_page(pages[i]); > +=09=09=09else if (flags & FOLL_PIN) > +=09=09=09=09if (unlikely(!user_page_ref_inc(pages[i]))) { > +=09=09=09=09=09spin_unlock(ptl); > +=09=09=09=09=09remainder =3D 0; > +=09=09=09=09=09err =3D -ENOMEM; > +=09=09=09=09=09WARN_ON_ONCE(1); > +=09=09=09=09=09break; > +=09=09=09=09} > =09=09} user_page_ref_inc() should not fail here either because we hold the ptl, so the WAR_ON_ONCE() is right but maybe add a comment. > =20 > =09=09if (vmas) [...] > @@ -5034,8 +5050,14 @@ follow_huge_pmd(struct mm_struct *mm, unsigned lon= g address, > =09pte =3D huge_ptep_get((pte_t *)pmd); > =09if (pte_present(pte)) { > =09=09page =3D pmd_page(*pmd) + ((address & ~PMD_MASK) >> PAGE_SHIFT); > + > =09=09if (flags & FOLL_GET) > =09=09=09get_page(page); > +=09=09else if (flags & FOLL_PIN) > +=09=09=09if (unlikely(!user_page_ref_inc(page))) { > +=09=09=09=09page =3D NULL; > +=09=09=09=09goto out; > +=09=09=09} This should not fail either (again holding pmd lock), dunno if we want a warn or something to catch this degenerate case. > =09} else { > =09=09if (is_hugetlb_entry_migration(pte)) { > =09=09=09spin_unlock(ptl); [...] 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=-8.0 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, 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 2B00FCA9EB5 for ; Mon, 4 Nov 2019 18:55:01 +0000 (UTC) Received: from lists.ozlabs.org (lists.ozlabs.org [203.11.71.2]) (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 545F22080F for ; Mon, 4 Nov 2019 18:55:00 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="O8apvPvq" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 545F22080F Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=linuxppc-dev-bounces+linuxppc-dev=archiver.kernel.org@lists.ozlabs.org Received: from bilbo.ozlabs.org (lists.ozlabs.org [IPv6:2401:3900:2:1::3]) by lists.ozlabs.org (Postfix) with ESMTP id 476MRj3RN4zF3k4 for ; Tue, 5 Nov 2019 05:54:57 +1100 (AEDT) Authentication-Results: lists.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=redhat.com (client-ip=205.139.110.120; helo=us-smtp-1.mimecast.com; envelope-from=jglisse@redhat.com; receiver=) Authentication-Results: lists.ozlabs.org; dmarc=pass (p=none dis=none) header.from=redhat.com Authentication-Results: lists.ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=redhat.com header.i=@redhat.com header.b="O8apvPvq"; dkim-atps=neutral Received: from us-smtp-1.mimecast.com (us-smtp-delivery-1.mimecast.com [205.139.110.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by lists.ozlabs.org (Postfix) with ESMTPS id 476MPR1NCdzF3M5 for ; Tue, 5 Nov 2019 05:52:58 +1100 (AEDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1572893576; 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=vhvFv/gKEXA1cmin4yO0xx1/Gf0U1DoUV0cjNAwwQns=; b=O8apvPvqdUgzEVrGx/5y0LW7ta59KzWUgaroqBGhFE1bBVW4qknnBHhY4Ea26pQl6tp6M7 2idja1rHkSdwitqLjGmf/N2+BNQEprFUswBF/dbzm/p6Yt9C2Xr47wztpYYCb+7jeyB4pQ JT2vjS9Ek0uC61GvQ873tEi7ALcfqew= 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-106-BYegrK4JPIWXqhL6bCqv8A-1; Mon, 04 Nov 2019 13:52:51 -0500 Received: from smtp.corp.redhat.com (int-mx03.intmail.prod.int.phx2.redhat.com [10.5.11.13]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 0F2011800D53; Mon, 4 Nov 2019 18:52:47 +0000 (UTC) Received: from redhat.com (unknown [10.20.6.178]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 1977960878; Mon, 4 Nov 2019 18:52:40 +0000 (UTC) Date: Mon, 4 Nov 2019 13:52:38 -0500 From: Jerome Glisse To: John Hubbard Subject: Re: [PATCH v2 12/18] mm/gup: track FOLL_PIN pages Message-ID: <20191104185238.GG5134@redhat.com> References: <20191103211813.213227-1-jhubbard@nvidia.com> <20191103211813.213227-13-jhubbard@nvidia.com> MIME-Version: 1.0 In-Reply-To: <20191103211813.213227-13-jhubbard@nvidia.com> User-Agent: Mutt/1.12.1 (2019-06-15) X-Scanned-By: MIMEDefang 2.79 on 10.5.11.13 X-MC-Unique: BYegrK4JPIWXqhL6bCqv8A-1 X-Mimecast-Spam-Score: 0 Content-Type: text/plain; charset=WINDOWS-1252 Content-Transfer-Encoding: quoted-printable Content-Disposition: inline X-BeenThere: linuxppc-dev@lists.ozlabs.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Linux on PowerPC Developers Mail List 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, Christoph Hellwig , Jason Gunthorpe , Vlastimil Babka , =?iso-8859-1?Q?Bj=F6rn_T=F6pel?= , linux-media@vger.kernel.org, Shuah Khan , linux-block@vger.kernel.org, Alex Williamson , Al Viro , Dan Williams , Mauro Carvalho Chehab , bpf@vger.kernel.org, Magnus Karlsson , Jens Axboe , netdev@vger.kernel.org, LKML , Daniel Vetter , linux-fsdevel@vger.kernel.org, Andrew Morton , linuxppc-dev@lists.ozlabs.org, "David S . Miller" , Mike Kravetz Errors-To: linuxppc-dev-bounces+linuxppc-dev=archiver.kernel.org@lists.ozlabs.org Sender: "Linuxppc-dev" On Sun, Nov 03, 2019 at 01:18:07PM -0800, John Hubbard wrote: > Add tracking of pages that were pinned via FOLL_PIN. >=20 > As mentioned in the FOLL_PIN documentation, callers who effectively set > FOLL_PIN are required to ultimately free such pages via put_user_page(). > The effect is similar to FOLL_GET, and may be thought of as "FOLL_GET > for DIO and/or RDMA use". >=20 > Pages that have been pinned via FOLL_PIN are identifiable via a > new function call: >=20 > bool page_dma_pinned(struct page *page); >=20 > What to do in response to encountering such a page, is left to later > patchsets. There is discussion about this in [1]. >=20 > This also changes a BUG_ON(), to a WARN_ON(), in follow_page_mask(). >=20 > This also has a couple of trivial, non-functional change fixes to > try_get_compound_head(). That function got moved to the top of the > file. Maybe split that as a separate trivial patch. >=20 > This includes the following fix from Ira Weiny: >=20 > DAX requires detection of a page crossing to a ref count of 1. Fix this > for GUP pages by introducing put_devmap_managed_user_page() which > accounts for GUP_PIN_COUNTING_BIAS now used by GUP. Please do the put_devmap_managed_page() changes in a separate patch, it would be a lot easier to follow, also on that front see comments below. >=20 > [1] https://lwn.net/Articles/784574/ "Some slow progress on > get_user_pages()" >=20 > Suggested-by: Jan Kara > Suggested-by: J=E9r=F4me Glisse > Signed-off-by: Ira Weiny > Signed-off-by: John Hubbard > --- > include/linux/mm.h | 80 +++++++++++---- > include/linux/mmzone.h | 2 + > include/linux/page_ref.h | 10 ++ > mm/gup.c | 213 +++++++++++++++++++++++++++++++-------- > mm/huge_memory.c | 32 +++++- > mm/hugetlb.c | 28 ++++- > mm/memremap.c | 4 +- > mm/vmstat.c | 2 + > 8 files changed, 300 insertions(+), 71 deletions(-) >=20 > diff --git a/include/linux/mm.h b/include/linux/mm.h > index cdfb6fedb271..03b3600843b7 100644 > --- a/include/linux/mm.h > +++ b/include/linux/mm.h > @@ -972,9 +972,10 @@ static inline bool is_zone_device_page(const struct = page *page) > #endif > =20 > #ifdef CONFIG_DEV_PAGEMAP_OPS > -void __put_devmap_managed_page(struct page *page); > +void __put_devmap_managed_page(struct page *page, int count); > DECLARE_STATIC_KEY_FALSE(devmap_managed_key); > -static inline bool put_devmap_managed_page(struct page *page) > + > +static inline bool page_is_devmap_managed(struct page *page) > { > =09if (!static_branch_unlikely(&devmap_managed_key)) > =09=09return false; > @@ -983,7 +984,6 @@ static inline bool put_devmap_managed_page(struct pag= e *page) > =09switch (page->pgmap->type) { > =09case MEMORY_DEVICE_PRIVATE: > =09case MEMORY_DEVICE_FS_DAX: > -=09=09__put_devmap_managed_page(page); > =09=09return true; > =09default: > =09=09break; > @@ -991,6 +991,19 @@ static inline bool put_devmap_managed_page(struct pa= ge *page) > =09return false; > } > =20 > +static inline bool put_devmap_managed_page(struct page *page) > +{ > +=09bool is_devmap =3D page_is_devmap_managed(page); > + > +=09if (is_devmap) { > +=09=09int count =3D page_ref_dec_return(page); > + > +=09=09__put_devmap_managed_page(page, count); > +=09} > + > +=09return is_devmap; > +} I think the __put_devmap_managed_page() should be rename to free_devmap_managed_page() and that the count !=3D 1 case move to this inline function ie: static inline bool put_devmap_managed_page(struct page *page) { =09bool is_devmap =3D page_is_devmap_managed(page); =09if (is_devmap) { =09=09int count =3D page_ref_dec_return(page); =09=09/* =09=09 * If refcount is 1 then page is freed and refcount is stable as nobo= dy =09=09 * holds a reference on the page. =09=09 */ =09=09if (count =3D=3D 1) =09=09=09free_devmap_managed_page(page, count); =09=09else if (!count) =09=09=09__put_page(page); =09} =09return is_devmap; } > + > #else /* CONFIG_DEV_PAGEMAP_OPS */ > static inline bool put_devmap_managed_page(struct page *page) > { > @@ -1038,6 +1051,8 @@ static inline __must_check bool try_get_page(struct= page *page) > =09return true; > } > =20 > +__must_check bool user_page_ref_inc(struct page *page); > + What about having it as an inline here as it is pretty small. > static inline void put_page(struct page *page) > { > =09page =3D compound_head(page); > @@ -1055,31 +1070,56 @@ static inline void put_page(struct page *page) > =09=09__put_page(page); > } > =20 > -/** > - * put_user_page() - release a gup-pinned page > - * @page: pointer to page to be released > +/* > + * GUP_PIN_COUNTING_BIAS, and the associated functions that use it, over= load > + * the page's refcount so that two separate items are tracked: the origi= nal page > + * reference count, and also a new count of how many get_user_pages() ca= lls were > + * made against the page. ("gup-pinned" is another term for the latter). > + * > + * With this scheme, get_user_pages() becomes special: such pages are ma= rked > + * as distinct from normal pages. As such, the new put_user_page() call = (and > + * its variants) must be used in order to release gup-pinned pages. > + * > + * Choice of value: > * > - * Pages that were pinned via get_user_pages*() must be released via > - * either put_user_page(), or one of the put_user_pages*() routines > - * below. This is so that eventually, pages that are pinned via > - * get_user_pages*() can be separately tracked and uniquely handled. In > - * particular, interactions with RDMA and filesystems need special > - * handling. > + * By making GUP_PIN_COUNTING_BIAS a power of two, debugging of page ref= erence > + * counts with respect to get_user_pages() and put_user_page() becomes s= impler, > + * due to the fact that adding an even power of two to the page refcount= has > + * the effect of using only the upper N bits, for the code that counts u= p using > + * the bias value. This means that the lower bits are left for the exclu= sive > + * use of the original code that increments and decrements by one (or at= least, > + * by much smaller values than the bias value). > * > - * put_user_page() and put_page() are not interchangeable, despite this = early > - * implementation that makes them look the same. put_user_page() calls m= ust > - * be perfectly matched up with get_user_page() calls. > + * Of course, once the lower bits overflow into the upper bits (and this= is > + * OK, because subtraction recovers the original values), then visual in= spection > + * no longer suffices to directly view the separate counts. However, for= normal > + * applications that don't have huge page reference counts, this won't b= e an > + * issue. > + * > + * Locking: the lockless algorithm described in page_cache_get_speculati= ve() > + * and page_cache_gup_pin_speculative() provides safe operation for > + * get_user_pages and page_mkclean and other calls that race to set up p= age > + * table entries. > */ > -static inline void put_user_page(struct page *page) > -{ > -=09put_page(page); > -} > +#define GUP_PIN_COUNTING_BIAS (1UL << 10) > =20 > +void put_user_page(struct page *page); > void put_user_pages_dirty_lock(struct page **pages, unsigned long npages= , > =09=09=09 bool make_dirty); > - > void put_user_pages(struct page **pages, unsigned long npages); > =20 > +/** > + * page_dma_pinned() - report if a page is pinned by a call to pin_user_= pages*() > + * or pin_longterm_pages*() > + * @page:=09pointer to page to be queried. > + * @Return:=09True, if it is likely that the page has been "dma-pinned". > + *=09=09False, if the page is definitely not dma-pinned. > + */ Maybe add a small comment about wrap around :) > +static inline bool page_dma_pinned(struct page *page) > +{ > +=09return (page_ref_count(compound_head(page))) >=3D GUP_PIN_COUNTING_BI= AS; > +} > + > #if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP) > #define SECTION_IN_PAGE_FLAGS > #endif [...] > diff --git a/mm/gup.c b/mm/gup.c > index 1aea48427879..c9727e65fad3 100644 > --- a/mm/gup.c > +++ b/mm/gup.c [...] > @@ -1930,12 +2028,20 @@ static int __gup_device_huge(unsigned long pfn, u= nsigned long addr, > =20 > =09=09pgmap =3D get_dev_pagemap(pfn, pgmap); > =09=09if (unlikely(!pgmap)) { > -=09=09=09undo_dev_pagemap(nr, nr_start, pages); > +=09=09=09undo_dev_pagemap(nr, nr_start, flags, pages); > =09=09=09return 0; > =09=09} > =09=09SetPageReferenced(page); > =09=09pages[*nr] =3D page; > -=09=09get_page(page); > + > +=09=09if (flags & FOLL_PIN) { > +=09=09=09if (unlikely(!user_page_ref_inc(page))) { > +=09=09=09=09undo_dev_pagemap(nr, nr_start, flags, pages); > +=09=09=09=09return 0; > +=09=09=09} Maybe add a comment about a case that should never happens ie user_page_ref_inc() fails after the second iteration of the loop as it would be broken and a bug to call undo_dev_pagemap() after the first iteration of that loop. Also i believe that this should never happens as if first iteration succeed than __page_cache_add_speculative() will succeed for all the iterations. Note that the pgmap case above follows that too ie the call to get_dev_pagemap() can only fail on first iteration of the loop, well i assume you can never have a huge device page that span different pgmap ie different devices (which is a reasonable assumption). So maybe this code needs fixing ie : =09=09pgmap =3D get_dev_pagemap(pfn, pgmap); =09=09if (unlikely(!pgmap)) =09=09=09return 0; > +=09=09} else > +=09=09=09get_page(page); > + > =09=09(*nr)++; > =09=09pfn++; > =09} while (addr +=3D PAGE_SIZE, addr !=3D end); [...] > @@ -2409,7 +2540,7 @@ static int internal_get_user_pages_fast(unsigned lo= ng start, int nr_pages, > =09unsigned long addr, len, end; > =09int nr =3D 0, ret =3D 0; > =20 > -=09if (WARN_ON_ONCE(gup_flags & ~(FOLL_WRITE | FOLL_LONGTERM))) > +=09if (WARN_ON_ONCE(gup_flags & ~(FOLL_WRITE | FOLL_LONGTERM | FOLL_PIN)= )) Maybe add a comments to explain, something like: /* * The only flags allowed here are: FOLL_WRITE, FOLL_LONGTERM, FOLL_PIN * * Note that get_user_pages_fast() imply FOLL_GET flag by default but * callers can over-ride this default to pin case by setting FOLL_PIN. */ > =09=09return -EINVAL; > =20 > =09start =3D untagged_addr(start) & PAGE_MASK; > diff --git a/mm/huge_memory.c b/mm/huge_memory.c > index 13cc93785006..66bf4c8b88f1 100644 > --- a/mm/huge_memory.c > +++ b/mm/huge_memory.c [...] > @@ -968,7 +973,12 @@ struct page *follow_devmap_pmd(struct vm_area_struct= *vma, unsigned long addr, > =09if (!*pgmap) > =09=09return ERR_PTR(-EFAULT); > =09page =3D pfn_to_page(pfn); > -=09get_page(page); > + > +=09if (flags & FOLL_GET) > +=09=09get_page(page); > +=09else if (flags & FOLL_PIN) > +=09=09if (unlikely(!user_page_ref_inc(page))) > +=09=09=09page =3D ERR_PTR(-ENOMEM); While i agree that user_page_ref_inc() (ie page_cache_add_speculative()) should never fails here as we are holding the pmd lock and thus no one can unmap the pmd and free the page it points to. I believe you should return -EFAULT like for the pgmap and not -ENOMEM as the pgmap should not fail either for the same reason. Thus it would be better to have consistent error. Maybe also add a comments explaining that it should not fail here. > =20 > =09return page; > } [...] > @@ -1100,7 +1115,7 @@ struct page *follow_devmap_pud(struct vm_area_struc= t *vma, unsigned long addr, > =09 * device mapped pages can only be returned if the > =09 * caller will manage the page reference count. > =09 */ > -=09if (!(flags & FOLL_GET)) > +=09if (!(flags & (FOLL_GET | FOLL_PIN))) > =09=09return ERR_PTR(-EEXIST); Maybe add a comment that FOLL_GET or FOLL_PIN must be set. > =09pfn +=3D (addr & ~PUD_MASK) >> PAGE_SHIFT; > @@ -1108,7 +1123,12 @@ struct page *follow_devmap_pud(struct vm_area_stru= ct *vma, unsigned long addr, > =09if (!*pgmap) > =09=09return ERR_PTR(-EFAULT); > =09page =3D pfn_to_page(pfn); > -=09get_page(page); > + > +=09if (flags & FOLL_GET) > +=09=09get_page(page); > +=09else if (flags & FOLL_PIN) > +=09=09if (unlikely(!user_page_ref_inc(page))) > +=09=09=09page =3D ERR_PTR(-ENOMEM); Same as for follow_devmap_pmd() see above. > =20 > =09return page; > } > @@ -1522,8 +1542,12 @@ struct page *follow_trans_huge_pmd(struct vm_area_= struct *vma, > skip_mlock: > =09page +=3D (addr & ~HPAGE_PMD_MASK) >> PAGE_SHIFT; > =09VM_BUG_ON_PAGE(!PageCompound(page) && !is_zone_device_page(page), pag= e); > + > =09if (flags & FOLL_GET) > =09=09get_page(page); > +=09else if (flags & FOLL_PIN) > +=09=09if (unlikely(!user_page_ref_inc(page))) > +=09=09=09page =3D NULL; This should not fail either as we are holding the pmd lock maybe add a comment. Dunno if we want a WARN() or something to catch this degenerate case, or dump the page. > =20 > out: > =09return page; > diff --git a/mm/hugetlb.c b/mm/hugetlb.c > index b45a95363a84..da335b1cd798 100644 > --- a/mm/hugetlb.c > +++ b/mm/hugetlb.c > @@ -4462,7 +4462,17 @@ long follow_hugetlb_page(struct mm_struct *mm, str= uct vm_area_struct *vma, > same_page: > =09=09if (pages) { > =09=09=09pages[i] =3D mem_map_offset(page, pfn_offset); > -=09=09=09get_page(pages[i]); > + > +=09=09=09if (flags & FOLL_GET) > +=09=09=09=09get_page(pages[i]); > +=09=09=09else if (flags & FOLL_PIN) > +=09=09=09=09if (unlikely(!user_page_ref_inc(pages[i]))) { > +=09=09=09=09=09spin_unlock(ptl); > +=09=09=09=09=09remainder =3D 0; > +=09=09=09=09=09err =3D -ENOMEM; > +=09=09=09=09=09WARN_ON_ONCE(1); > +=09=09=09=09=09break; > +=09=09=09=09} > =09=09} user_page_ref_inc() should not fail here either because we hold the ptl, so the WAR_ON_ONCE() is right but maybe add a comment. > =20 > =09=09if (vmas) [...] > @@ -5034,8 +5050,14 @@ follow_huge_pmd(struct mm_struct *mm, unsigned lon= g address, > =09pte =3D huge_ptep_get((pte_t *)pmd); > =09if (pte_present(pte)) { > =09=09page =3D pmd_page(*pmd) + ((address & ~PMD_MASK) >> PAGE_SHIFT); > + > =09=09if (flags & FOLL_GET) > =09=09=09get_page(page); > +=09=09else if (flags & FOLL_PIN) > +=09=09=09if (unlikely(!user_page_ref_inc(page))) { > +=09=09=09=09page =3D NULL; > +=09=09=09=09goto out; > +=09=09=09} This should not fail either (again holding pmd lock), dunno if we want a warn or something to catch this degenerate case. > =09} else { > =09=09if (is_hugetlb_entry_migration(pte)) { > =09=09=09spin_unlock(ptl); [...] From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jerome Glisse Subject: Re: [PATCH v2 12/18] mm/gup: track FOLL_PIN pages Date: Mon, 4 Nov 2019 13:52:38 -0500 Message-ID: <20191104185238.GG5134@redhat.com> References: <20191103211813.213227-1-jhubbard@nvidia.com> <20191103211813.213227-13-jhubbard@nvidia.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from us-smtp-1.mimecast.com (us-smtp-delivery-1.mimecast.com [205.139.110.120]) by gabe.freedesktop.org (Postfix) with ESMTPS id 000A66E81E for ; Mon, 4 Nov 2019 18:52:56 +0000 (UTC) In-Reply-To: <20191103211813.213227-13-jhubbard@nvidia.com> Content-Disposition: inline List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: John Hubbard 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 , Vlastimil Babka , =?iso-8859-1?Q?Bj=F6rn_T=F6pel?= , linux-media@vger.kernel.org, Shuah Khan , linux-block@vger.kernel.org, Alex Williamson , Al Viro , Dan Williams , Mauro Carvalho Chehab , bpf@vger.kernel.org, Magnus List-Id: dri-devel@lists.freedesktop.org T24gU3VuLCBOb3YgMDMsIDIwMTkgYXQgMDE6MTg6MDdQTSAtMDgwMCwgSm9obiBIdWJiYXJkIHdy b3RlOgo+IEFkZCB0cmFja2luZyBvZiBwYWdlcyB0aGF0IHdlcmUgcGlubmVkIHZpYSBGT0xMX1BJ Ti4KPiAKPiBBcyBtZW50aW9uZWQgaW4gdGhlIEZPTExfUElOIGRvY3VtZW50YXRpb24sIGNhbGxl cnMgd2hvIGVmZmVjdGl2ZWx5IHNldAo+IEZPTExfUElOIGFyZSByZXF1aXJlZCB0byB1bHRpbWF0 ZWx5IGZyZWUgc3VjaCBwYWdlcyB2aWEgcHV0X3VzZXJfcGFnZSgpLgo+IFRoZSBlZmZlY3QgaXMg c2ltaWxhciB0byBGT0xMX0dFVCwgYW5kIG1heSBiZSB0aG91Z2h0IG9mIGFzICJGT0xMX0dFVAo+ IGZvciBESU8gYW5kL29yIFJETUEgdXNlIi4KPiAKPiBQYWdlcyB0aGF0IGhhdmUgYmVlbiBwaW5u ZWQgdmlhIEZPTExfUElOIGFyZSBpZGVudGlmaWFibGUgdmlhIGEKPiBuZXcgZnVuY3Rpb24gY2Fs bDoKPiAKPiAgICBib29sIHBhZ2VfZG1hX3Bpbm5lZChzdHJ1Y3QgcGFnZSAqcGFnZSk7Cj4gCj4g V2hhdCB0byBkbyBpbiByZXNwb25zZSB0byBlbmNvdW50ZXJpbmcgc3VjaCBhIHBhZ2UsIGlzIGxl ZnQgdG8gbGF0ZXIKPiBwYXRjaHNldHMuIFRoZXJlIGlzIGRpc2N1c3Npb24gYWJvdXQgdGhpcyBp biBbMV0uCj4gCj4gVGhpcyBhbHNvIGNoYW5nZXMgYSBCVUdfT04oKSwgdG8gYSBXQVJOX09OKCks IGluIGZvbGxvd19wYWdlX21hc2soKS4KPiAKPiBUaGlzIGFsc28gaGFzIGEgY291cGxlIG9mIHRy aXZpYWwsIG5vbi1mdW5jdGlvbmFsIGNoYW5nZSBmaXhlcyB0bwo+IHRyeV9nZXRfY29tcG91bmRf aGVhZCgpLiBUaGF0IGZ1bmN0aW9uIGdvdCBtb3ZlZCB0byB0aGUgdG9wIG9mIHRoZQo+IGZpbGUu CgpNYXliZSBzcGxpdCB0aGF0IGFzIGEgc2VwYXJhdGUgdHJpdmlhbCBwYXRjaC4KCj4gCj4gVGhp cyBpbmNsdWRlcyB0aGUgZm9sbG93aW5nIGZpeCBmcm9tIElyYSBXZWlueToKPiAKPiBEQVggcmVx dWlyZXMgZGV0ZWN0aW9uIG9mIGEgcGFnZSBjcm9zc2luZyB0byBhIHJlZiBjb3VudCBvZiAxLiAg Rml4IHRoaXMKPiBmb3IgR1VQIHBhZ2VzIGJ5IGludHJvZHVjaW5nIHB1dF9kZXZtYXBfbWFuYWdl ZF91c2VyX3BhZ2UoKSB3aGljaAo+IGFjY291bnRzIGZvciBHVVBfUElOX0NPVU5USU5HX0JJQVMg bm93IHVzZWQgYnkgR1VQLgoKUGxlYXNlIGRvIHRoZSBwdXRfZGV2bWFwX21hbmFnZWRfcGFnZSgp IGNoYW5nZXMgaW4gYSBzZXBhcmF0ZQpwYXRjaCwgaXQgd291bGQgYmUgYSBsb3QgZWFzaWVyIHRv IGZvbGxvdywgYWxzbyBvbiB0aGF0IGZyb250CnNlZSBjb21tZW50cyBiZWxvdy4KCj4gCj4gWzFd IGh0dHBzOi8vbHduLm5ldC9BcnRpY2xlcy83ODQ1NzQvICJTb21lIHNsb3cgcHJvZ3Jlc3Mgb24K PiBnZXRfdXNlcl9wYWdlcygpIgo+IAo+IFN1Z2dlc3RlZC1ieTogSmFuIEthcmEgPGphY2tAc3Vz ZS5jej4KPiBTdWdnZXN0ZWQtYnk6IErDqXLDtG1lIEdsaXNzZSA8amdsaXNzZUByZWRoYXQuY29t Pgo+IFNpZ25lZC1vZmYtYnk6IElyYSBXZWlueSA8aXJhLndlaW55QGludGVsLmNvbT4KPiBTaWdu ZWQtb2ZmLWJ5OiBKb2huIEh1YmJhcmQgPGpodWJiYXJkQG52aWRpYS5jb20+Cj4gLS0tCj4gIGlu Y2x1ZGUvbGludXgvbW0uaCAgICAgICB8ICA4MCArKysrKysrKysrKy0tLS0KPiAgaW5jbHVkZS9s aW51eC9tbXpvbmUuaCAgIHwgICAyICsKPiAgaW5jbHVkZS9saW51eC9wYWdlX3JlZi5oIHwgIDEw ICsrCj4gIG1tL2d1cC5jICAgICAgICAgICAgICAgICB8IDIxMyArKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrLS0tLS0tLS0KPiAgbW0vaHVnZV9tZW1vcnkuYyAgICAgICAgIHwgIDMyICsr KysrLQo+ICBtbS9odWdldGxiLmMgICAgICAgICAgICAgfCAgMjggKysrKy0KPiAgbW0vbWVtcmVt YXAuYyAgICAgICAgICAgIHwgICA0ICstCj4gIG1tL3Ztc3RhdC5jICAgICAgICAgICAgICB8ICAg MiArCj4gIDggZmlsZXMgY2hhbmdlZCwgMzAwIGluc2VydGlvbnMoKyksIDcxIGRlbGV0aW9ucygt KQo+IAo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21tLmggYi9pbmNsdWRlL2xpbnV4L21t LmgKPiBpbmRleCBjZGZiNmZlZGIyNzEuLjAzYjM2MDA4NDNiNyAxMDA2NDQKPiAtLS0gYS9pbmNs dWRlL2xpbnV4L21tLmgKPiArKysgYi9pbmNsdWRlL2xpbnV4L21tLmgKPiBAQCAtOTcyLDkgKzk3 MiwxMCBAQCBzdGF0aWMgaW5saW5lIGJvb2wgaXNfem9uZV9kZXZpY2VfcGFnZShjb25zdCBzdHJ1 Y3QgcGFnZSAqcGFnZSkKPiAgI2VuZGlmCj4gIAo+ICAjaWZkZWYgQ09ORklHX0RFVl9QQUdFTUFQ X09QUwo+IC12b2lkIF9fcHV0X2Rldm1hcF9tYW5hZ2VkX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2Up Owo+ICt2b2lkIF9fcHV0X2Rldm1hcF9tYW5hZ2VkX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UsIGlu dCBjb3VudCk7Cj4gIERFQ0xBUkVfU1RBVElDX0tFWV9GQUxTRShkZXZtYXBfbWFuYWdlZF9rZXkp Owo+IC1zdGF0aWMgaW5saW5lIGJvb2wgcHV0X2Rldm1hcF9tYW5hZ2VkX3BhZ2Uoc3RydWN0IHBh Z2UgKnBhZ2UpCj4gKwo+ICtzdGF0aWMgaW5saW5lIGJvb2wgcGFnZV9pc19kZXZtYXBfbWFuYWdl ZChzdHJ1Y3QgcGFnZSAqcGFnZSkKPiAgewo+ICAJaWYgKCFzdGF0aWNfYnJhbmNoX3VubGlrZWx5 KCZkZXZtYXBfbWFuYWdlZF9rZXkpKQo+ICAJCXJldHVybiBmYWxzZTsKPiBAQCAtOTgzLDcgKzk4 NCw2IEBAIHN0YXRpYyBpbmxpbmUgYm9vbCBwdXRfZGV2bWFwX21hbmFnZWRfcGFnZShzdHJ1Y3Qg cGFnZSAqcGFnZSkKPiAgCXN3aXRjaCAocGFnZS0+cGdtYXAtPnR5cGUpIHsKPiAgCWNhc2UgTUVN T1JZX0RFVklDRV9QUklWQVRFOgo+ICAJY2FzZSBNRU1PUllfREVWSUNFX0ZTX0RBWDoKPiAtCQlf X3B1dF9kZXZtYXBfbWFuYWdlZF9wYWdlKHBhZ2UpOwo+ICAJCXJldHVybiB0cnVlOwo+ICAJZGVm YXVsdDoKPiAgCQlicmVhazsKPiBAQCAtOTkxLDYgKzk5MSwxOSBAQCBzdGF0aWMgaW5saW5lIGJv b2wgcHV0X2Rldm1hcF9tYW5hZ2VkX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UpCj4gIAlyZXR1cm4g ZmFsc2U7Cj4gIH0KPiAgCj4gK3N0YXRpYyBpbmxpbmUgYm9vbCBwdXRfZGV2bWFwX21hbmFnZWRf cGFnZShzdHJ1Y3QgcGFnZSAqcGFnZSkKPiArewo+ICsJYm9vbCBpc19kZXZtYXAgPSBwYWdlX2lz X2Rldm1hcF9tYW5hZ2VkKHBhZ2UpOwo+ICsKPiArCWlmIChpc19kZXZtYXApIHsKPiArCQlpbnQg Y291bnQgPSBwYWdlX3JlZl9kZWNfcmV0dXJuKHBhZ2UpOwo+ICsKPiArCQlfX3B1dF9kZXZtYXBf bWFuYWdlZF9wYWdlKHBhZ2UsIGNvdW50KTsKPiArCX0KPiArCj4gKwlyZXR1cm4gaXNfZGV2bWFw Owo+ICt9CgpJIHRoaW5rIHRoZSBfX3B1dF9kZXZtYXBfbWFuYWdlZF9wYWdlKCkgc2hvdWxkIGJl IHJlbmFtZQp0byBmcmVlX2Rldm1hcF9tYW5hZ2VkX3BhZ2UoKSBhbmQgdGhhdCB0aGUgY291bnQg IT0gMQpjYXNlIG1vdmUgdG8gdGhpcyBpbmxpbmUgZnVuY3Rpb24gaWU6CgpzdGF0aWMgaW5saW5l IGJvb2wgcHV0X2Rldm1hcF9tYW5hZ2VkX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UpCnsKCWJvb2wg aXNfZGV2bWFwID0gcGFnZV9pc19kZXZtYXBfbWFuYWdlZChwYWdlKTsKCglpZiAoaXNfZGV2bWFw KSB7CgkJaW50IGNvdW50ID0gcGFnZV9yZWZfZGVjX3JldHVybihwYWdlKTsKCgkJLyoKCQkgKiBJ ZiByZWZjb3VudCBpcyAxIHRoZW4gcGFnZSBpcyBmcmVlZCBhbmQgcmVmY291bnQgaXMgc3RhYmxl IGFzIG5vYm9keQoJCSAqIGhvbGRzIGEgcmVmZXJlbmNlIG9uIHRoZSBwYWdlLgoJCSAqLwoJCWlm IChjb3VudCA9PSAxKQoJCQlmcmVlX2Rldm1hcF9tYW5hZ2VkX3BhZ2UocGFnZSwgY291bnQpOwoJ CWVsc2UgaWYgKCFjb3VudCkKCQkJX19wdXRfcGFnZShwYWdlKTsKCX0KCglyZXR1cm4gaXNfZGV2 bWFwOwp9CgoKPiArCj4gICNlbHNlIC8qIENPTkZJR19ERVZfUEFHRU1BUF9PUFMgKi8KPiAgc3Rh dGljIGlubGluZSBib29sIHB1dF9kZXZtYXBfbWFuYWdlZF9wYWdlKHN0cnVjdCBwYWdlICpwYWdl KQo+ICB7Cj4gQEAgLTEwMzgsNiArMTA1MSw4IEBAIHN0YXRpYyBpbmxpbmUgX19tdXN0X2NoZWNr IGJvb2wgdHJ5X2dldF9wYWdlKHN0cnVjdCBwYWdlICpwYWdlKQo+ICAJcmV0dXJuIHRydWU7Cj4g IH0KPiAgCj4gK19fbXVzdF9jaGVjayBib29sIHVzZXJfcGFnZV9yZWZfaW5jKHN0cnVjdCBwYWdl ICpwYWdlKTsKPiArCgpXaGF0IGFib3V0IGhhdmluZyBpdCBhcyBhbiBpbmxpbmUgaGVyZSBhcyBp dCBpcyBwcmV0dHkgc21hbGwuCgoKPiAgc3RhdGljIGlubGluZSB2b2lkIHB1dF9wYWdlKHN0cnVj dCBwYWdlICpwYWdlKQo+ICB7Cj4gIAlwYWdlID0gY29tcG91bmRfaGVhZChwYWdlKTsKPiBAQCAt MTA1NSwzMSArMTA3MCw1NiBAQCBzdGF0aWMgaW5saW5lIHZvaWQgcHV0X3BhZ2Uoc3RydWN0IHBh Z2UgKnBhZ2UpCj4gIAkJX19wdXRfcGFnZShwYWdlKTsKPiAgfQo+ICAKPiAtLyoqCj4gLSAqIHB1 dF91c2VyX3BhZ2UoKSAtIHJlbGVhc2UgYSBndXAtcGlubmVkIHBhZ2UKPiAtICogQHBhZ2U6ICAg ICAgICAgICAgcG9pbnRlciB0byBwYWdlIHRvIGJlIHJlbGVhc2VkCj4gKy8qCj4gKyAqIEdVUF9Q SU5fQ09VTlRJTkdfQklBUywgYW5kIHRoZSBhc3NvY2lhdGVkIGZ1bmN0aW9ucyB0aGF0IHVzZSBp dCwgb3ZlcmxvYWQKPiArICogdGhlIHBhZ2UncyByZWZjb3VudCBzbyB0aGF0IHR3byBzZXBhcmF0 ZSBpdGVtcyBhcmUgdHJhY2tlZDogdGhlIG9yaWdpbmFsIHBhZ2UKPiArICogcmVmZXJlbmNlIGNv dW50LCBhbmQgYWxzbyBhIG5ldyBjb3VudCBvZiBob3cgbWFueSBnZXRfdXNlcl9wYWdlcygpIGNh bGxzIHdlcmUKPiArICogbWFkZSBhZ2FpbnN0IHRoZSBwYWdlLiAoImd1cC1waW5uZWQiIGlzIGFu b3RoZXIgdGVybSBmb3IgdGhlIGxhdHRlcikuCj4gKyAqCj4gKyAqIFdpdGggdGhpcyBzY2hlbWUs IGdldF91c2VyX3BhZ2VzKCkgYmVjb21lcyBzcGVjaWFsOiBzdWNoIHBhZ2VzIGFyZSBtYXJrZWQK PiArICogYXMgZGlzdGluY3QgZnJvbSBub3JtYWwgcGFnZXMuIEFzIHN1Y2gsIHRoZSBuZXcgcHV0 X3VzZXJfcGFnZSgpIGNhbGwgKGFuZAo+ICsgKiBpdHMgdmFyaWFudHMpIG11c3QgYmUgdXNlZCBp biBvcmRlciB0byByZWxlYXNlIGd1cC1waW5uZWQgcGFnZXMuCj4gKyAqCj4gKyAqIENob2ljZSBv ZiB2YWx1ZToKPiAgICoKPiAtICogUGFnZXMgdGhhdCB3ZXJlIHBpbm5lZCB2aWEgZ2V0X3VzZXJf cGFnZXMqKCkgbXVzdCBiZSByZWxlYXNlZCB2aWEKPiAtICogZWl0aGVyIHB1dF91c2VyX3BhZ2Uo KSwgb3Igb25lIG9mIHRoZSBwdXRfdXNlcl9wYWdlcyooKSByb3V0aW5lcwo+IC0gKiBiZWxvdy4g VGhpcyBpcyBzbyB0aGF0IGV2ZW50dWFsbHksIHBhZ2VzIHRoYXQgYXJlIHBpbm5lZCB2aWEKPiAt ICogZ2V0X3VzZXJfcGFnZXMqKCkgY2FuIGJlIHNlcGFyYXRlbHkgdHJhY2tlZCBhbmQgdW5pcXVl bHkgaGFuZGxlZC4gSW4KPiAtICogcGFydGljdWxhciwgaW50ZXJhY3Rpb25zIHdpdGggUkRNQSBh bmQgZmlsZXN5c3RlbXMgbmVlZCBzcGVjaWFsCj4gLSAqIGhhbmRsaW5nLgo+ICsgKiBCeSBtYWtp bmcgR1VQX1BJTl9DT1VOVElOR19CSUFTIGEgcG93ZXIgb2YgdHdvLCBkZWJ1Z2dpbmcgb2YgcGFn ZSByZWZlcmVuY2UKPiArICogY291bnRzIHdpdGggcmVzcGVjdCB0byBnZXRfdXNlcl9wYWdlcygp IGFuZCBwdXRfdXNlcl9wYWdlKCkgYmVjb21lcyBzaW1wbGVyLAo+ICsgKiBkdWUgdG8gdGhlIGZh Y3QgdGhhdCBhZGRpbmcgYW4gZXZlbiBwb3dlciBvZiB0d28gdG8gdGhlIHBhZ2UgcmVmY291bnQg aGFzCj4gKyAqIHRoZSBlZmZlY3Qgb2YgdXNpbmcgb25seSB0aGUgdXBwZXIgTiBiaXRzLCBmb3Ig dGhlIGNvZGUgdGhhdCBjb3VudHMgdXAgdXNpbmcKPiArICogdGhlIGJpYXMgdmFsdWUuIFRoaXMg bWVhbnMgdGhhdCB0aGUgbG93ZXIgYml0cyBhcmUgbGVmdCBmb3IgdGhlIGV4Y2x1c2l2ZQo+ICsg KiB1c2Ugb2YgdGhlIG9yaWdpbmFsIGNvZGUgdGhhdCBpbmNyZW1lbnRzIGFuZCBkZWNyZW1lbnRz IGJ5IG9uZSAob3IgYXQgbGVhc3QsCj4gKyAqIGJ5IG11Y2ggc21hbGxlciB2YWx1ZXMgdGhhbiB0 aGUgYmlhcyB2YWx1ZSkuCj4gICAqCj4gLSAqIHB1dF91c2VyX3BhZ2UoKSBhbmQgcHV0X3BhZ2Uo KSBhcmUgbm90IGludGVyY2hhbmdlYWJsZSwgZGVzcGl0ZSB0aGlzIGVhcmx5Cj4gLSAqIGltcGxl bWVudGF0aW9uIHRoYXQgbWFrZXMgdGhlbSBsb29rIHRoZSBzYW1lLiBwdXRfdXNlcl9wYWdlKCkg Y2FsbHMgbXVzdAo+IC0gKiBiZSBwZXJmZWN0bHkgbWF0Y2hlZCB1cCB3aXRoIGdldF91c2VyX3Bh Z2UoKSBjYWxscy4KPiArICogT2YgY291cnNlLCBvbmNlIHRoZSBsb3dlciBiaXRzIG92ZXJmbG93 IGludG8gdGhlIHVwcGVyIGJpdHMgKGFuZCB0aGlzIGlzCj4gKyAqIE9LLCBiZWNhdXNlIHN1YnRy YWN0aW9uIHJlY292ZXJzIHRoZSBvcmlnaW5hbCB2YWx1ZXMpLCB0aGVuIHZpc3VhbCBpbnNwZWN0 aW9uCj4gKyAqIG5vIGxvbmdlciBzdWZmaWNlcyB0byBkaXJlY3RseSB2aWV3IHRoZSBzZXBhcmF0 ZSBjb3VudHMuIEhvd2V2ZXIsIGZvciBub3JtYWwKPiArICogYXBwbGljYXRpb25zIHRoYXQgZG9u J3QgaGF2ZSBodWdlIHBhZ2UgcmVmZXJlbmNlIGNvdW50cywgdGhpcyB3b24ndCBiZSBhbgo+ICsg KiBpc3N1ZS4KPiArICoKPiArICogTG9ja2luZzogdGhlIGxvY2tsZXNzIGFsZ29yaXRobSBkZXNj cmliZWQgaW4gcGFnZV9jYWNoZV9nZXRfc3BlY3VsYXRpdmUoKQo+ICsgKiBhbmQgcGFnZV9jYWNo ZV9ndXBfcGluX3NwZWN1bGF0aXZlKCkgcHJvdmlkZXMgc2FmZSBvcGVyYXRpb24gZm9yCj4gKyAq IGdldF91c2VyX3BhZ2VzIGFuZCBwYWdlX21rY2xlYW4gYW5kIG90aGVyIGNhbGxzIHRoYXQgcmFj ZSB0byBzZXQgdXAgcGFnZQo+ICsgKiB0YWJsZSBlbnRyaWVzLgo+ICAgKi8KPiAtc3RhdGljIGlu bGluZSB2b2lkIHB1dF91c2VyX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UpCj4gLXsKPiAtCXB1dF9w YWdlKHBhZ2UpOwo+IC19Cj4gKyNkZWZpbmUgR1VQX1BJTl9DT1VOVElOR19CSUFTICgxVUwgPDwg MTApCj4gIAo+ICt2b2lkIHB1dF91c2VyX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UpOwo+ICB2b2lk IHB1dF91c2VyX3BhZ2VzX2RpcnR5X2xvY2soc3RydWN0IHBhZ2UgKipwYWdlcywgdW5zaWduZWQg bG9uZyBucGFnZXMsCj4gIAkJCSAgICAgICBib29sIG1ha2VfZGlydHkpOwo+IC0KPiAgdm9pZCBw dXRfdXNlcl9wYWdlcyhzdHJ1Y3QgcGFnZSAqKnBhZ2VzLCB1bnNpZ25lZCBsb25nIG5wYWdlcyk7 Cj4gIAo+ICsvKioKPiArICogcGFnZV9kbWFfcGlubmVkKCkgLSByZXBvcnQgaWYgYSBwYWdlIGlz IHBpbm5lZCBieSBhIGNhbGwgdG8gcGluX3VzZXJfcGFnZXMqKCkKPiArICogb3IgcGluX2xvbmd0 ZXJtX3BhZ2VzKigpCj4gKyAqIEBwYWdlOglwb2ludGVyIHRvIHBhZ2UgdG8gYmUgcXVlcmllZC4K PiArICogQFJldHVybjoJVHJ1ZSwgaWYgaXQgaXMgbGlrZWx5IHRoYXQgdGhlIHBhZ2UgaGFzIGJl ZW4gImRtYS1waW5uZWQiLgo+ICsgKgkJRmFsc2UsIGlmIHRoZSBwYWdlIGlzIGRlZmluaXRlbHkg bm90IGRtYS1waW5uZWQuCj4gKyAqLwoKTWF5YmUgYWRkIGEgc21hbGwgY29tbWVudCBhYm91dCB3 cmFwIGFyb3VuZCA6KQoKPiArc3RhdGljIGlubGluZSBib29sIHBhZ2VfZG1hX3Bpbm5lZChzdHJ1 Y3QgcGFnZSAqcGFnZSkKPiArewo+ICsJcmV0dXJuIChwYWdlX3JlZl9jb3VudChjb21wb3VuZF9o ZWFkKHBhZ2UpKSkgPj0gR1VQX1BJTl9DT1VOVElOR19CSUFTOwo+ICt9Cj4gKwo+ICAjaWYgZGVm aW5lZChDT05GSUdfU1BBUlNFTUVNKSAmJiAhZGVmaW5lZChDT05GSUdfU1BBUlNFTUVNX1ZNRU1N QVApCj4gICNkZWZpbmUgU0VDVElPTl9JTl9QQUdFX0ZMQUdTCj4gICNlbmRpZgoKWy4uLl0KCj4g ZGlmZiAtLWdpdCBhL21tL2d1cC5jIGIvbW0vZ3VwLmMKPiBpbmRleCAxYWVhNDg0Mjc4NzkuLmM5 NzI3ZTY1ZmFkMyAxMDA2NDQKPiAtLS0gYS9tbS9ndXAuYwo+ICsrKyBiL21tL2d1cC5jCgpbLi4u XQoKPiBAQCAtMTkzMCwxMiArMjAyOCwyMCBAQCBzdGF0aWMgaW50IF9fZ3VwX2RldmljZV9odWdl KHVuc2lnbmVkIGxvbmcgcGZuLCB1bnNpZ25lZCBsb25nIGFkZHIsCj4gIAo+ICAJCXBnbWFwID0g Z2V0X2Rldl9wYWdlbWFwKHBmbiwgcGdtYXApOwo+ICAJCWlmICh1bmxpa2VseSghcGdtYXApKSB7 Cj4gLQkJCXVuZG9fZGV2X3BhZ2VtYXAobnIsIG5yX3N0YXJ0LCBwYWdlcyk7Cj4gKwkJCXVuZG9f ZGV2X3BhZ2VtYXAobnIsIG5yX3N0YXJ0LCBmbGFncywgcGFnZXMpOwo+ICAJCQlyZXR1cm4gMDsK PiAgCQl9Cj4gIAkJU2V0UGFnZVJlZmVyZW5jZWQocGFnZSk7Cj4gIAkJcGFnZXNbKm5yXSA9IHBh Z2U7Cj4gLQkJZ2V0X3BhZ2UocGFnZSk7Cj4gKwo+ICsJCWlmIChmbGFncyAmIEZPTExfUElOKSB7 Cj4gKwkJCWlmICh1bmxpa2VseSghdXNlcl9wYWdlX3JlZl9pbmMocGFnZSkpKSB7Cj4gKwkJCQl1 bmRvX2Rldl9wYWdlbWFwKG5yLCBucl9zdGFydCwgZmxhZ3MsIHBhZ2VzKTsKPiArCQkJCXJldHVy biAwOwo+ICsJCQl9CgpNYXliZSBhZGQgYSBjb21tZW50IGFib3V0IGEgY2FzZSB0aGF0IHNob3Vs ZCBuZXZlciBoYXBwZW5zIGllCnVzZXJfcGFnZV9yZWZfaW5jKCkgZmFpbHMgYWZ0ZXIgdGhlIHNl Y29uZCBpdGVyYXRpb24gb2YgdGhlCmxvb3AgYXMgaXQgd291bGQgYmUgYnJva2VuIGFuZCBhIGJ1 ZyB0byBjYWxsIHVuZG9fZGV2X3BhZ2VtYXAoKQphZnRlciB0aGUgZmlyc3QgaXRlcmF0aW9uIG9m IHRoYXQgbG9vcC4KCkFsc28gaSBiZWxpZXZlIHRoYXQgdGhpcyBzaG91bGQgbmV2ZXIgaGFwcGVu cyBhcyBpZiBmaXJzdAppdGVyYXRpb24gc3VjY2VlZCB0aGFuIF9fcGFnZV9jYWNoZV9hZGRfc3Bl Y3VsYXRpdmUoKSB3aWxsCnN1Y2NlZWQgZm9yIGFsbCB0aGUgaXRlcmF0aW9ucy4KCk5vdGUgdGhh dCB0aGUgcGdtYXAgY2FzZSBhYm92ZSBmb2xsb3dzIHRoYXQgdG9vIGllIHRoZSBjYWxsIHRvCmdl dF9kZXZfcGFnZW1hcCgpIGNhbiBvbmx5IGZhaWwgb24gZmlyc3QgaXRlcmF0aW9uIG9mIHRoZSBs b29wLAp3ZWxsIGkgYXNzdW1lIHlvdSBjYW4gbmV2ZXIgaGF2ZSBhIGh1Z2UgZGV2aWNlIHBhZ2Ug dGhhdCBzcGFuCmRpZmZlcmVudCBwZ21hcCBpZSBkaWZmZXJlbnQgZGV2aWNlcyAod2hpY2ggaXMg YSByZWFzb25hYmxlCmFzc3VtcHRpb24pLiBTbyBtYXliZSB0aGlzIGNvZGUgbmVlZHMgZml4aW5n IGllIDoKCgkJcGdtYXAgPSBnZXRfZGV2X3BhZ2VtYXAocGZuLCBwZ21hcCk7CgkJaWYgKHVubGlr ZWx5KCFwZ21hcCkpCgkJCXJldHVybiAwOwoKCj4gKwkJfSBlbHNlCj4gKwkJCWdldF9wYWdlKHBh Z2UpOwo+ICsKPiAgCQkoKm5yKSsrOwo+ICAJCXBmbisrOwo+ICAJfSB3aGlsZSAoYWRkciArPSBQ QUdFX1NJWkUsIGFkZHIgIT0gZW5kKTsKClsuLi5dCgo+IEBAIC0yNDA5LDcgKzI1NDAsNyBAQCBz dGF0aWMgaW50IGludGVybmFsX2dldF91c2VyX3BhZ2VzX2Zhc3QodW5zaWduZWQgbG9uZyBzdGFy dCwgaW50IG5yX3BhZ2VzLAo+ICAJdW5zaWduZWQgbG9uZyBhZGRyLCBsZW4sIGVuZDsKPiAgCWlu dCBuciA9IDAsIHJldCA9IDA7Cj4gIAo+IC0JaWYgKFdBUk5fT05fT05DRShndXBfZmxhZ3MgJiB+ KEZPTExfV1JJVEUgfCBGT0xMX0xPTkdURVJNKSkpCj4gKwlpZiAoV0FSTl9PTl9PTkNFKGd1cF9m bGFncyAmIH4oRk9MTF9XUklURSB8IEZPTExfTE9OR1RFUk0gfCBGT0xMX1BJTikpKQoKTWF5YmUg YWRkIGEgY29tbWVudHMgdG8gZXhwbGFpbiwgc29tZXRoaW5nIGxpa2U6CgovKgogKiBUaGUgb25s eSBmbGFncyBhbGxvd2VkIGhlcmUgYXJlOiBGT0xMX1dSSVRFLCBGT0xMX0xPTkdURVJNLCBGT0xM X1BJTgogKgogKiBOb3RlIHRoYXQgZ2V0X3VzZXJfcGFnZXNfZmFzdCgpIGltcGx5IEZPTExfR0VU IGZsYWcgYnkgZGVmYXVsdCBidXQKICogY2FsbGVycyBjYW4gb3Zlci1yaWRlIHRoaXMgZGVmYXVs dCB0byBwaW4gY2FzZSBieSBzZXR0aW5nIEZPTExfUElOLgogKi8KCj4gIAkJcmV0dXJuIC1FSU5W QUw7Cj4gIAo+ICAJc3RhcnQgPSB1bnRhZ2dlZF9hZGRyKHN0YXJ0KSAmIFBBR0VfTUFTSzsKPiBk aWZmIC0tZ2l0IGEvbW0vaHVnZV9tZW1vcnkuYyBiL21tL2h1Z2VfbWVtb3J5LmMKPiBpbmRleCAx M2NjOTM3ODUwMDYuLjY2YmY0YzhiODhmMSAxMDA2NDQKPiAtLS0gYS9tbS9odWdlX21lbW9yeS5j Cj4gKysrIGIvbW0vaHVnZV9tZW1vcnkuYwoKWy4uLl0KCj4gQEAgLTk2OCw3ICs5NzMsMTIgQEAg c3RydWN0IHBhZ2UgKmZvbGxvd19kZXZtYXBfcG1kKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1h LCB1bnNpZ25lZCBsb25nIGFkZHIsCj4gIAlpZiAoISpwZ21hcCkKPiAgCQlyZXR1cm4gRVJSX1BU UigtRUZBVUxUKTsKPiAgCXBhZ2UgPSBwZm5fdG9fcGFnZShwZm4pOwo+IC0JZ2V0X3BhZ2UocGFn ZSk7Cj4gKwo+ICsJaWYgKGZsYWdzICYgRk9MTF9HRVQpCj4gKwkJZ2V0X3BhZ2UocGFnZSk7Cj4g KwllbHNlIGlmIChmbGFncyAmIEZPTExfUElOKQo+ICsJCWlmICh1bmxpa2VseSghdXNlcl9wYWdl X3JlZl9pbmMocGFnZSkpKQo+ICsJCQlwYWdlID0gRVJSX1BUUigtRU5PTUVNKTsKCldoaWxlIGkg YWdyZWUgdGhhdCB1c2VyX3BhZ2VfcmVmX2luYygpIChpZSBwYWdlX2NhY2hlX2FkZF9zcGVjdWxh dGl2ZSgpKQpzaG91bGQgbmV2ZXIgZmFpbHMgaGVyZSBhcyB3ZSBhcmUgaG9sZGluZyB0aGUgcG1k IGxvY2sgYW5kIHRodXMgbm8gb25lCmNhbiB1bm1hcCB0aGUgcG1kIGFuZCBmcmVlIHRoZSBwYWdl IGl0IHBvaW50cyB0by4gSSBiZWxpZXZlIHlvdSBzaG91bGQKcmV0dXJuIC1FRkFVTFQgbGlrZSBm b3IgdGhlIHBnbWFwIGFuZCBub3QgLUVOT01FTSBhcyB0aGUgcGdtYXAgc2hvdWxkCm5vdCBmYWls IGVpdGhlciBmb3IgdGhlIHNhbWUgcmVhc29uLiBUaHVzIGl0IHdvdWxkIGJlIGJldHRlciB0byBo YXZlCmNvbnNpc3RlbnQgZXJyb3IuIE1heWJlIGFsc28gYWRkIGEgY29tbWVudHMgZXhwbGFpbmlu ZyB0aGF0IGl0IHNob3VsZApub3QgZmFpbCBoZXJlLgoKPiAgCj4gIAlyZXR1cm4gcGFnZTsKPiAg fQoKWy4uLl0KCj4gQEAgLTExMDAsNyArMTExNSw3IEBAIHN0cnVjdCBwYWdlICpmb2xsb3dfZGV2 bWFwX3B1ZChzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwgdW5zaWduZWQgbG9uZyBhZGRyLAo+ ICAJICogZGV2aWNlIG1hcHBlZCBwYWdlcyBjYW4gb25seSBiZSByZXR1cm5lZCBpZiB0aGUKPiAg CSAqIGNhbGxlciB3aWxsIG1hbmFnZSB0aGUgcGFnZSByZWZlcmVuY2UgY291bnQuCj4gIAkgKi8K PiAtCWlmICghKGZsYWdzICYgRk9MTF9HRVQpKQo+ICsJaWYgKCEoZmxhZ3MgJiAoRk9MTF9HRVQg fCBGT0xMX1BJTikpKQo+ICAJCXJldHVybiBFUlJfUFRSKC1FRVhJU1QpOwoKTWF5YmUgYWRkIGEg Y29tbWVudCB0aGF0IEZPTExfR0VUIG9yIEZPTExfUElOIG11c3QgYmUgc2V0LgoKPiAgCXBmbiAr PSAoYWRkciAmIH5QVURfTUFTSykgPj4gUEFHRV9TSElGVDsKPiBAQCAtMTEwOCw3ICsxMTIzLDEy IEBAIHN0cnVjdCBwYWdlICpmb2xsb3dfZGV2bWFwX3B1ZChzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3Qg KnZtYSwgdW5zaWduZWQgbG9uZyBhZGRyLAo+ICAJaWYgKCEqcGdtYXApCj4gIAkJcmV0dXJuIEVS Ul9QVFIoLUVGQVVMVCk7Cj4gIAlwYWdlID0gcGZuX3RvX3BhZ2UocGZuKTsKPiAtCWdldF9wYWdl KHBhZ2UpOwo+ICsKPiArCWlmIChmbGFncyAmIEZPTExfR0VUKQo+ICsJCWdldF9wYWdlKHBhZ2Up Owo+ICsJZWxzZSBpZiAoZmxhZ3MgJiBGT0xMX1BJTikKPiArCQlpZiAodW5saWtlbHkoIXVzZXJf cGFnZV9yZWZfaW5jKHBhZ2UpKSkKPiArCQkJcGFnZSA9IEVSUl9QVFIoLUVOT01FTSk7CgpTYW1l IGFzIGZvciBmb2xsb3dfZGV2bWFwX3BtZCgpIHNlZSBhYm92ZS4KCj4gIAo+ICAJcmV0dXJuIHBh Z2U7Cj4gIH0KPiBAQCAtMTUyMiw4ICsxNTQyLDEyIEBAIHN0cnVjdCBwYWdlICpmb2xsb3dfdHJh bnNfaHVnZV9wbWQoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCj4gIHNraXBfbWxvY2s6Cj4g IAlwYWdlICs9IChhZGRyICYgfkhQQUdFX1BNRF9NQVNLKSA+PiBQQUdFX1NISUZUOwo+ICAJVk1f QlVHX09OX1BBR0UoIVBhZ2VDb21wb3VuZChwYWdlKSAmJiAhaXNfem9uZV9kZXZpY2VfcGFnZShw YWdlKSwgcGFnZSk7Cj4gKwo+ICAJaWYgKGZsYWdzICYgRk9MTF9HRVQpCj4gIAkJZ2V0X3BhZ2Uo cGFnZSk7Cj4gKwllbHNlIGlmIChmbGFncyAmIEZPTExfUElOKQo+ICsJCWlmICh1bmxpa2VseSgh dXNlcl9wYWdlX3JlZl9pbmMocGFnZSkpKQo+ICsJCQlwYWdlID0gTlVMTDsKClRoaXMgc2hvdWxk IG5vdCBmYWlsIGVpdGhlciBhcyB3ZSBhcmUgaG9sZGluZyB0aGUgcG1kIGxvY2sgbWF5YmUgYWRk CmEgY29tbWVudC4gRHVubm8gaWYgd2Ugd2FudCBhIFdBUk4oKSBvciBzb21ldGhpbmcgdG8gY2F0 Y2ggdGhpcwpkZWdlbmVyYXRlIGNhc2UsIG9yIGR1bXAgdGhlIHBhZ2UuCgo+ICAKPiAgb3V0Ogo+ ICAJcmV0dXJuIHBhZ2U7Cj4gZGlmZiAtLWdpdCBhL21tL2h1Z2V0bGIuYyBiL21tL2h1Z2V0bGIu Ywo+IGluZGV4IGI0NWE5NTM2M2E4NC4uZGEzMzViMWNkNzk4IDEwMDY0NAo+IC0tLSBhL21tL2h1 Z2V0bGIuYwo+ICsrKyBiL21tL2h1Z2V0bGIuYwo+IEBAIC00NDYyLDcgKzQ0NjIsMTcgQEAgbG9u ZyBmb2xsb3dfaHVnZXRsYl9wYWdlKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCBzdHJ1Y3Qgdm1fYXJl YV9zdHJ1Y3QgKnZtYSwKPiAgc2FtZV9wYWdlOgo+ICAJCWlmIChwYWdlcykgewo+ICAJCQlwYWdl c1tpXSA9IG1lbV9tYXBfb2Zmc2V0KHBhZ2UsIHBmbl9vZmZzZXQpOwo+IC0JCQlnZXRfcGFnZShw YWdlc1tpXSk7Cj4gKwo+ICsJCQlpZiAoZmxhZ3MgJiBGT0xMX0dFVCkKPiArCQkJCWdldF9wYWdl KHBhZ2VzW2ldKTsKPiArCQkJZWxzZSBpZiAoZmxhZ3MgJiBGT0xMX1BJTikKPiArCQkJCWlmICh1 bmxpa2VseSghdXNlcl9wYWdlX3JlZl9pbmMocGFnZXNbaV0pKSkgewo+ICsJCQkJCXNwaW5fdW5s b2NrKHB0bCk7Cj4gKwkJCQkJcmVtYWluZGVyID0gMDsKPiArCQkJCQllcnIgPSAtRU5PTUVNOwo+ ICsJCQkJCVdBUk5fT05fT05DRSgxKTsKPiArCQkJCQlicmVhazsKPiArCQkJCX0KPiAgCQl9Cgp1 c2VyX3BhZ2VfcmVmX2luYygpIHNob3VsZCBub3QgZmFpbCBoZXJlIGVpdGhlciBiZWNhdXNlIHdl IGhvbGQgdGhlCnB0bCwgc28gdGhlIFdBUl9PTl9PTkNFKCkgaXMgcmlnaHQgYnV0IG1heWJlIGFk ZCBhIGNvbW1lbnQuCgo+ICAKPiAgCQlpZiAodm1hcykKClsuLi5dCgo+IEBAIC01MDM0LDggKzUw NTAsMTQgQEAgZm9sbG93X2h1Z2VfcG1kKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCB1bnNpZ25lZCBs b25nIGFkZHJlc3MsCj4gIAlwdGUgPSBodWdlX3B0ZXBfZ2V0KChwdGVfdCAqKXBtZCk7Cj4gIAlp ZiAocHRlX3ByZXNlbnQocHRlKSkgewo+ICAJCXBhZ2UgPSBwbWRfcGFnZSgqcG1kKSArICgoYWRk cmVzcyAmIH5QTURfTUFTSykgPj4gUEFHRV9TSElGVCk7Cj4gKwo+ICAJCWlmIChmbGFncyAmIEZP TExfR0VUKQo+ICAJCQlnZXRfcGFnZShwYWdlKTsKPiArCQllbHNlIGlmIChmbGFncyAmIEZPTExf UElOKQo+ICsJCQlpZiAodW5saWtlbHkoIXVzZXJfcGFnZV9yZWZfaW5jKHBhZ2UpKSkgewo+ICsJ CQkJcGFnZSA9IE5VTEw7Cj4gKwkJCQlnb3RvIG91dDsKPiArCQkJfQoKVGhpcyBzaG91bGQgbm90 IGZhaWwgZWl0aGVyIChhZ2FpbiBob2xkaW5nIHBtZCBsb2NrKSwgZHVubm8gaWYgd2Ugd2FudAph IHdhcm4gb3Igc29tZXRoaW5nIHRvIGNhdGNoIHRoaXMgZGVnZW5lcmF0ZSBjYXNlLgoKPiAgCX0g ZWxzZSB7Cj4gIAkJaWYgKGlzX2h1Z2V0bGJfZW50cnlfbWlncmF0aW9uKHB0ZSkpIHsKPiAgCQkJ c3Bpbl91bmxvY2socHRsKTsKClsuLi5dCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5m cmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0 aW5mby9kcmktZGV2ZWw= 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=-8.2 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, 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 3273FCA9ED3 for ; Mon, 4 Nov 2019 18:52:59 +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 15D522084D for ; Mon, 4 Nov 2019 18:52:59 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 15D522084D 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 8544E6E81E; Mon, 4 Nov 2019 18:52:58 +0000 (UTC) Received: from us-smtp-1.mimecast.com (us-smtp-delivery-1.mimecast.com [205.139.110.120]) by gabe.freedesktop.org (Postfix) with ESMTPS id 000A66E81E for ; Mon, 4 Nov 2019 18:52:56 +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-106-BYegrK4JPIWXqhL6bCqv8A-1; Mon, 04 Nov 2019 13:52:51 -0500 Received: from smtp.corp.redhat.com (int-mx03.intmail.prod.int.phx2.redhat.com [10.5.11.13]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 0F2011800D53; Mon, 4 Nov 2019 18:52:47 +0000 (UTC) Received: from redhat.com (unknown [10.20.6.178]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 1977960878; Mon, 4 Nov 2019 18:52:40 +0000 (UTC) Date: Mon, 4 Nov 2019 13:52:38 -0500 From: Jerome Glisse To: John Hubbard Subject: Re: [PATCH v2 12/18] mm/gup: track FOLL_PIN pages Message-ID: <20191104185238.GG5134@redhat.com> References: <20191103211813.213227-1-jhubbard@nvidia.com> <20191103211813.213227-13-jhubbard@nvidia.com> MIME-Version: 1.0 In-Reply-To: <20191103211813.213227-13-jhubbard@nvidia.com> User-Agent: Mutt/1.12.1 (2019-06-15) X-Scanned-By: MIMEDefang 2.79 on 10.5.11.13 X-MC-Unique: BYegrK4JPIWXqhL6bCqv8A-1 X-Mimecast-Spam-Score: 0 Content-Disposition: inline X-Mailman-Original-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1572893575; 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=vhvFv/gKEXA1cmin4yO0xx1/Gf0U1DoUV0cjNAwwQns=; b=AwPUH1Gw9pb2VEuimGsZm+pjX1CrtX1/7Ed6HwMaKy/ZPUFZ0zSVYAO0Z54UIpDwl8H69t gWhD+1ZLensUPVPHSFxB9TOGSe88J7eC6ZI4L0LyPYTrr9ONpXlB7K7kmlv9RccXfesO2B tzG2CoqH/FEbnYvo+xskH7FTRFMnj4E= 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 , Vlastimil Babka , =?iso-8859-1?Q?Bj=F6rn_T=F6pel?= , linux-media@vger.kernel.org, Shuah Khan , linux-block@vger.kernel.org, Alex Williamson , 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: <20191104185238.FHSCbMN5EbaTlBbaiHWGVj_2aBqPkNhKwIWMH6lzOa4@z> T24gU3VuLCBOb3YgMDMsIDIwMTkgYXQgMDE6MTg6MDdQTSAtMDgwMCwgSm9obiBIdWJiYXJkIHdy b3RlOgo+IEFkZCB0cmFja2luZyBvZiBwYWdlcyB0aGF0IHdlcmUgcGlubmVkIHZpYSBGT0xMX1BJ Ti4KPiAKPiBBcyBtZW50aW9uZWQgaW4gdGhlIEZPTExfUElOIGRvY3VtZW50YXRpb24sIGNhbGxl cnMgd2hvIGVmZmVjdGl2ZWx5IHNldAo+IEZPTExfUElOIGFyZSByZXF1aXJlZCB0byB1bHRpbWF0 ZWx5IGZyZWUgc3VjaCBwYWdlcyB2aWEgcHV0X3VzZXJfcGFnZSgpLgo+IFRoZSBlZmZlY3QgaXMg c2ltaWxhciB0byBGT0xMX0dFVCwgYW5kIG1heSBiZSB0aG91Z2h0IG9mIGFzICJGT0xMX0dFVAo+ IGZvciBESU8gYW5kL29yIFJETUEgdXNlIi4KPiAKPiBQYWdlcyB0aGF0IGhhdmUgYmVlbiBwaW5u ZWQgdmlhIEZPTExfUElOIGFyZSBpZGVudGlmaWFibGUgdmlhIGEKPiBuZXcgZnVuY3Rpb24gY2Fs bDoKPiAKPiAgICBib29sIHBhZ2VfZG1hX3Bpbm5lZChzdHJ1Y3QgcGFnZSAqcGFnZSk7Cj4gCj4g V2hhdCB0byBkbyBpbiByZXNwb25zZSB0byBlbmNvdW50ZXJpbmcgc3VjaCBhIHBhZ2UsIGlzIGxl ZnQgdG8gbGF0ZXIKPiBwYXRjaHNldHMuIFRoZXJlIGlzIGRpc2N1c3Npb24gYWJvdXQgdGhpcyBp biBbMV0uCj4gCj4gVGhpcyBhbHNvIGNoYW5nZXMgYSBCVUdfT04oKSwgdG8gYSBXQVJOX09OKCks IGluIGZvbGxvd19wYWdlX21hc2soKS4KPiAKPiBUaGlzIGFsc28gaGFzIGEgY291cGxlIG9mIHRy aXZpYWwsIG5vbi1mdW5jdGlvbmFsIGNoYW5nZSBmaXhlcyB0bwo+IHRyeV9nZXRfY29tcG91bmRf aGVhZCgpLiBUaGF0IGZ1bmN0aW9uIGdvdCBtb3ZlZCB0byB0aGUgdG9wIG9mIHRoZQo+IGZpbGUu CgpNYXliZSBzcGxpdCB0aGF0IGFzIGEgc2VwYXJhdGUgdHJpdmlhbCBwYXRjaC4KCj4gCj4gVGhp cyBpbmNsdWRlcyB0aGUgZm9sbG93aW5nIGZpeCBmcm9tIElyYSBXZWlueToKPiAKPiBEQVggcmVx dWlyZXMgZGV0ZWN0aW9uIG9mIGEgcGFnZSBjcm9zc2luZyB0byBhIHJlZiBjb3VudCBvZiAxLiAg Rml4IHRoaXMKPiBmb3IgR1VQIHBhZ2VzIGJ5IGludHJvZHVjaW5nIHB1dF9kZXZtYXBfbWFuYWdl ZF91c2VyX3BhZ2UoKSB3aGljaAo+IGFjY291bnRzIGZvciBHVVBfUElOX0NPVU5USU5HX0JJQVMg bm93IHVzZWQgYnkgR1VQLgoKUGxlYXNlIGRvIHRoZSBwdXRfZGV2bWFwX21hbmFnZWRfcGFnZSgp IGNoYW5nZXMgaW4gYSBzZXBhcmF0ZQpwYXRjaCwgaXQgd291bGQgYmUgYSBsb3QgZWFzaWVyIHRv IGZvbGxvdywgYWxzbyBvbiB0aGF0IGZyb250CnNlZSBjb21tZW50cyBiZWxvdy4KCj4gCj4gWzFd IGh0dHBzOi8vbHduLm5ldC9BcnRpY2xlcy83ODQ1NzQvICJTb21lIHNsb3cgcHJvZ3Jlc3Mgb24K PiBnZXRfdXNlcl9wYWdlcygpIgo+IAo+IFN1Z2dlc3RlZC1ieTogSmFuIEthcmEgPGphY2tAc3Vz ZS5jej4KPiBTdWdnZXN0ZWQtYnk6IErDqXLDtG1lIEdsaXNzZSA8amdsaXNzZUByZWRoYXQuY29t Pgo+IFNpZ25lZC1vZmYtYnk6IElyYSBXZWlueSA8aXJhLndlaW55QGludGVsLmNvbT4KPiBTaWdu ZWQtb2ZmLWJ5OiBKb2huIEh1YmJhcmQgPGpodWJiYXJkQG52aWRpYS5jb20+Cj4gLS0tCj4gIGlu Y2x1ZGUvbGludXgvbW0uaCAgICAgICB8ICA4MCArKysrKysrKysrKy0tLS0KPiAgaW5jbHVkZS9s aW51eC9tbXpvbmUuaCAgIHwgICAyICsKPiAgaW5jbHVkZS9saW51eC9wYWdlX3JlZi5oIHwgIDEw ICsrCj4gIG1tL2d1cC5jICAgICAgICAgICAgICAgICB8IDIxMyArKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrLS0tLS0tLS0KPiAgbW0vaHVnZV9tZW1vcnkuYyAgICAgICAgIHwgIDMyICsr KysrLQo+ICBtbS9odWdldGxiLmMgICAgICAgICAgICAgfCAgMjggKysrKy0KPiAgbW0vbWVtcmVt YXAuYyAgICAgICAgICAgIHwgICA0ICstCj4gIG1tL3Ztc3RhdC5jICAgICAgICAgICAgICB8ICAg MiArCj4gIDggZmlsZXMgY2hhbmdlZCwgMzAwIGluc2VydGlvbnMoKyksIDcxIGRlbGV0aW9ucygt KQo+IAo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21tLmggYi9pbmNsdWRlL2xpbnV4L21t LmgKPiBpbmRleCBjZGZiNmZlZGIyNzEuLjAzYjM2MDA4NDNiNyAxMDA2NDQKPiAtLS0gYS9pbmNs dWRlL2xpbnV4L21tLmgKPiArKysgYi9pbmNsdWRlL2xpbnV4L21tLmgKPiBAQCAtOTcyLDkgKzk3 MiwxMCBAQCBzdGF0aWMgaW5saW5lIGJvb2wgaXNfem9uZV9kZXZpY2VfcGFnZShjb25zdCBzdHJ1 Y3QgcGFnZSAqcGFnZSkKPiAgI2VuZGlmCj4gIAo+ICAjaWZkZWYgQ09ORklHX0RFVl9QQUdFTUFQ X09QUwo+IC12b2lkIF9fcHV0X2Rldm1hcF9tYW5hZ2VkX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2Up Owo+ICt2b2lkIF9fcHV0X2Rldm1hcF9tYW5hZ2VkX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UsIGlu dCBjb3VudCk7Cj4gIERFQ0xBUkVfU1RBVElDX0tFWV9GQUxTRShkZXZtYXBfbWFuYWdlZF9rZXkp Owo+IC1zdGF0aWMgaW5saW5lIGJvb2wgcHV0X2Rldm1hcF9tYW5hZ2VkX3BhZ2Uoc3RydWN0IHBh Z2UgKnBhZ2UpCj4gKwo+ICtzdGF0aWMgaW5saW5lIGJvb2wgcGFnZV9pc19kZXZtYXBfbWFuYWdl ZChzdHJ1Y3QgcGFnZSAqcGFnZSkKPiAgewo+ICAJaWYgKCFzdGF0aWNfYnJhbmNoX3VubGlrZWx5 KCZkZXZtYXBfbWFuYWdlZF9rZXkpKQo+ICAJCXJldHVybiBmYWxzZTsKPiBAQCAtOTgzLDcgKzk4 NCw2IEBAIHN0YXRpYyBpbmxpbmUgYm9vbCBwdXRfZGV2bWFwX21hbmFnZWRfcGFnZShzdHJ1Y3Qg cGFnZSAqcGFnZSkKPiAgCXN3aXRjaCAocGFnZS0+cGdtYXAtPnR5cGUpIHsKPiAgCWNhc2UgTUVN T1JZX0RFVklDRV9QUklWQVRFOgo+ICAJY2FzZSBNRU1PUllfREVWSUNFX0ZTX0RBWDoKPiAtCQlf X3B1dF9kZXZtYXBfbWFuYWdlZF9wYWdlKHBhZ2UpOwo+ICAJCXJldHVybiB0cnVlOwo+ICAJZGVm YXVsdDoKPiAgCQlicmVhazsKPiBAQCAtOTkxLDYgKzk5MSwxOSBAQCBzdGF0aWMgaW5saW5lIGJv b2wgcHV0X2Rldm1hcF9tYW5hZ2VkX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UpCj4gIAlyZXR1cm4g ZmFsc2U7Cj4gIH0KPiAgCj4gK3N0YXRpYyBpbmxpbmUgYm9vbCBwdXRfZGV2bWFwX21hbmFnZWRf cGFnZShzdHJ1Y3QgcGFnZSAqcGFnZSkKPiArewo+ICsJYm9vbCBpc19kZXZtYXAgPSBwYWdlX2lz X2Rldm1hcF9tYW5hZ2VkKHBhZ2UpOwo+ICsKPiArCWlmIChpc19kZXZtYXApIHsKPiArCQlpbnQg Y291bnQgPSBwYWdlX3JlZl9kZWNfcmV0dXJuKHBhZ2UpOwo+ICsKPiArCQlfX3B1dF9kZXZtYXBf bWFuYWdlZF9wYWdlKHBhZ2UsIGNvdW50KTsKPiArCX0KPiArCj4gKwlyZXR1cm4gaXNfZGV2bWFw Owo+ICt9CgpJIHRoaW5rIHRoZSBfX3B1dF9kZXZtYXBfbWFuYWdlZF9wYWdlKCkgc2hvdWxkIGJl IHJlbmFtZQp0byBmcmVlX2Rldm1hcF9tYW5hZ2VkX3BhZ2UoKSBhbmQgdGhhdCB0aGUgY291bnQg IT0gMQpjYXNlIG1vdmUgdG8gdGhpcyBpbmxpbmUgZnVuY3Rpb24gaWU6CgpzdGF0aWMgaW5saW5l IGJvb2wgcHV0X2Rldm1hcF9tYW5hZ2VkX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UpCnsKCWJvb2wg aXNfZGV2bWFwID0gcGFnZV9pc19kZXZtYXBfbWFuYWdlZChwYWdlKTsKCglpZiAoaXNfZGV2bWFw KSB7CgkJaW50IGNvdW50ID0gcGFnZV9yZWZfZGVjX3JldHVybihwYWdlKTsKCgkJLyoKCQkgKiBJ ZiByZWZjb3VudCBpcyAxIHRoZW4gcGFnZSBpcyBmcmVlZCBhbmQgcmVmY291bnQgaXMgc3RhYmxl IGFzIG5vYm9keQoJCSAqIGhvbGRzIGEgcmVmZXJlbmNlIG9uIHRoZSBwYWdlLgoJCSAqLwoJCWlm IChjb3VudCA9PSAxKQoJCQlmcmVlX2Rldm1hcF9tYW5hZ2VkX3BhZ2UocGFnZSwgY291bnQpOwoJ CWVsc2UgaWYgKCFjb3VudCkKCQkJX19wdXRfcGFnZShwYWdlKTsKCX0KCglyZXR1cm4gaXNfZGV2 bWFwOwp9CgoKPiArCj4gICNlbHNlIC8qIENPTkZJR19ERVZfUEFHRU1BUF9PUFMgKi8KPiAgc3Rh dGljIGlubGluZSBib29sIHB1dF9kZXZtYXBfbWFuYWdlZF9wYWdlKHN0cnVjdCBwYWdlICpwYWdl KQo+ICB7Cj4gQEAgLTEwMzgsNiArMTA1MSw4IEBAIHN0YXRpYyBpbmxpbmUgX19tdXN0X2NoZWNr IGJvb2wgdHJ5X2dldF9wYWdlKHN0cnVjdCBwYWdlICpwYWdlKQo+ICAJcmV0dXJuIHRydWU7Cj4g IH0KPiAgCj4gK19fbXVzdF9jaGVjayBib29sIHVzZXJfcGFnZV9yZWZfaW5jKHN0cnVjdCBwYWdl ICpwYWdlKTsKPiArCgpXaGF0IGFib3V0IGhhdmluZyBpdCBhcyBhbiBpbmxpbmUgaGVyZSBhcyBp dCBpcyBwcmV0dHkgc21hbGwuCgoKPiAgc3RhdGljIGlubGluZSB2b2lkIHB1dF9wYWdlKHN0cnVj dCBwYWdlICpwYWdlKQo+ICB7Cj4gIAlwYWdlID0gY29tcG91bmRfaGVhZChwYWdlKTsKPiBAQCAt MTA1NSwzMSArMTA3MCw1NiBAQCBzdGF0aWMgaW5saW5lIHZvaWQgcHV0X3BhZ2Uoc3RydWN0IHBh Z2UgKnBhZ2UpCj4gIAkJX19wdXRfcGFnZShwYWdlKTsKPiAgfQo+ICAKPiAtLyoqCj4gLSAqIHB1 dF91c2VyX3BhZ2UoKSAtIHJlbGVhc2UgYSBndXAtcGlubmVkIHBhZ2UKPiAtICogQHBhZ2U6ICAg ICAgICAgICAgcG9pbnRlciB0byBwYWdlIHRvIGJlIHJlbGVhc2VkCj4gKy8qCj4gKyAqIEdVUF9Q SU5fQ09VTlRJTkdfQklBUywgYW5kIHRoZSBhc3NvY2lhdGVkIGZ1bmN0aW9ucyB0aGF0IHVzZSBp dCwgb3ZlcmxvYWQKPiArICogdGhlIHBhZ2UncyByZWZjb3VudCBzbyB0aGF0IHR3byBzZXBhcmF0 ZSBpdGVtcyBhcmUgdHJhY2tlZDogdGhlIG9yaWdpbmFsIHBhZ2UKPiArICogcmVmZXJlbmNlIGNv dW50LCBhbmQgYWxzbyBhIG5ldyBjb3VudCBvZiBob3cgbWFueSBnZXRfdXNlcl9wYWdlcygpIGNh bGxzIHdlcmUKPiArICogbWFkZSBhZ2FpbnN0IHRoZSBwYWdlLiAoImd1cC1waW5uZWQiIGlzIGFu b3RoZXIgdGVybSBmb3IgdGhlIGxhdHRlcikuCj4gKyAqCj4gKyAqIFdpdGggdGhpcyBzY2hlbWUs IGdldF91c2VyX3BhZ2VzKCkgYmVjb21lcyBzcGVjaWFsOiBzdWNoIHBhZ2VzIGFyZSBtYXJrZWQK PiArICogYXMgZGlzdGluY3QgZnJvbSBub3JtYWwgcGFnZXMuIEFzIHN1Y2gsIHRoZSBuZXcgcHV0 X3VzZXJfcGFnZSgpIGNhbGwgKGFuZAo+ICsgKiBpdHMgdmFyaWFudHMpIG11c3QgYmUgdXNlZCBp biBvcmRlciB0byByZWxlYXNlIGd1cC1waW5uZWQgcGFnZXMuCj4gKyAqCj4gKyAqIENob2ljZSBv ZiB2YWx1ZToKPiAgICoKPiAtICogUGFnZXMgdGhhdCB3ZXJlIHBpbm5lZCB2aWEgZ2V0X3VzZXJf cGFnZXMqKCkgbXVzdCBiZSByZWxlYXNlZCB2aWEKPiAtICogZWl0aGVyIHB1dF91c2VyX3BhZ2Uo KSwgb3Igb25lIG9mIHRoZSBwdXRfdXNlcl9wYWdlcyooKSByb3V0aW5lcwo+IC0gKiBiZWxvdy4g VGhpcyBpcyBzbyB0aGF0IGV2ZW50dWFsbHksIHBhZ2VzIHRoYXQgYXJlIHBpbm5lZCB2aWEKPiAt ICogZ2V0X3VzZXJfcGFnZXMqKCkgY2FuIGJlIHNlcGFyYXRlbHkgdHJhY2tlZCBhbmQgdW5pcXVl bHkgaGFuZGxlZC4gSW4KPiAtICogcGFydGljdWxhciwgaW50ZXJhY3Rpb25zIHdpdGggUkRNQSBh bmQgZmlsZXN5c3RlbXMgbmVlZCBzcGVjaWFsCj4gLSAqIGhhbmRsaW5nLgo+ICsgKiBCeSBtYWtp bmcgR1VQX1BJTl9DT1VOVElOR19CSUFTIGEgcG93ZXIgb2YgdHdvLCBkZWJ1Z2dpbmcgb2YgcGFn ZSByZWZlcmVuY2UKPiArICogY291bnRzIHdpdGggcmVzcGVjdCB0byBnZXRfdXNlcl9wYWdlcygp IGFuZCBwdXRfdXNlcl9wYWdlKCkgYmVjb21lcyBzaW1wbGVyLAo+ICsgKiBkdWUgdG8gdGhlIGZh Y3QgdGhhdCBhZGRpbmcgYW4gZXZlbiBwb3dlciBvZiB0d28gdG8gdGhlIHBhZ2UgcmVmY291bnQg aGFzCj4gKyAqIHRoZSBlZmZlY3Qgb2YgdXNpbmcgb25seSB0aGUgdXBwZXIgTiBiaXRzLCBmb3Ig dGhlIGNvZGUgdGhhdCBjb3VudHMgdXAgdXNpbmcKPiArICogdGhlIGJpYXMgdmFsdWUuIFRoaXMg bWVhbnMgdGhhdCB0aGUgbG93ZXIgYml0cyBhcmUgbGVmdCBmb3IgdGhlIGV4Y2x1c2l2ZQo+ICsg KiB1c2Ugb2YgdGhlIG9yaWdpbmFsIGNvZGUgdGhhdCBpbmNyZW1lbnRzIGFuZCBkZWNyZW1lbnRz IGJ5IG9uZSAob3IgYXQgbGVhc3QsCj4gKyAqIGJ5IG11Y2ggc21hbGxlciB2YWx1ZXMgdGhhbiB0 aGUgYmlhcyB2YWx1ZSkuCj4gICAqCj4gLSAqIHB1dF91c2VyX3BhZ2UoKSBhbmQgcHV0X3BhZ2Uo KSBhcmUgbm90IGludGVyY2hhbmdlYWJsZSwgZGVzcGl0ZSB0aGlzIGVhcmx5Cj4gLSAqIGltcGxl bWVudGF0aW9uIHRoYXQgbWFrZXMgdGhlbSBsb29rIHRoZSBzYW1lLiBwdXRfdXNlcl9wYWdlKCkg Y2FsbHMgbXVzdAo+IC0gKiBiZSBwZXJmZWN0bHkgbWF0Y2hlZCB1cCB3aXRoIGdldF91c2VyX3Bh Z2UoKSBjYWxscy4KPiArICogT2YgY291cnNlLCBvbmNlIHRoZSBsb3dlciBiaXRzIG92ZXJmbG93 IGludG8gdGhlIHVwcGVyIGJpdHMgKGFuZCB0aGlzIGlzCj4gKyAqIE9LLCBiZWNhdXNlIHN1YnRy YWN0aW9uIHJlY292ZXJzIHRoZSBvcmlnaW5hbCB2YWx1ZXMpLCB0aGVuIHZpc3VhbCBpbnNwZWN0 aW9uCj4gKyAqIG5vIGxvbmdlciBzdWZmaWNlcyB0byBkaXJlY3RseSB2aWV3IHRoZSBzZXBhcmF0 ZSBjb3VudHMuIEhvd2V2ZXIsIGZvciBub3JtYWwKPiArICogYXBwbGljYXRpb25zIHRoYXQgZG9u J3QgaGF2ZSBodWdlIHBhZ2UgcmVmZXJlbmNlIGNvdW50cywgdGhpcyB3b24ndCBiZSBhbgo+ICsg KiBpc3N1ZS4KPiArICoKPiArICogTG9ja2luZzogdGhlIGxvY2tsZXNzIGFsZ29yaXRobSBkZXNj cmliZWQgaW4gcGFnZV9jYWNoZV9nZXRfc3BlY3VsYXRpdmUoKQo+ICsgKiBhbmQgcGFnZV9jYWNo ZV9ndXBfcGluX3NwZWN1bGF0aXZlKCkgcHJvdmlkZXMgc2FmZSBvcGVyYXRpb24gZm9yCj4gKyAq IGdldF91c2VyX3BhZ2VzIGFuZCBwYWdlX21rY2xlYW4gYW5kIG90aGVyIGNhbGxzIHRoYXQgcmFj ZSB0byBzZXQgdXAgcGFnZQo+ICsgKiB0YWJsZSBlbnRyaWVzLgo+ICAgKi8KPiAtc3RhdGljIGlu bGluZSB2b2lkIHB1dF91c2VyX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UpCj4gLXsKPiAtCXB1dF9w YWdlKHBhZ2UpOwo+IC19Cj4gKyNkZWZpbmUgR1VQX1BJTl9DT1VOVElOR19CSUFTICgxVUwgPDwg MTApCj4gIAo+ICt2b2lkIHB1dF91c2VyX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UpOwo+ICB2b2lk IHB1dF91c2VyX3BhZ2VzX2RpcnR5X2xvY2soc3RydWN0IHBhZ2UgKipwYWdlcywgdW5zaWduZWQg bG9uZyBucGFnZXMsCj4gIAkJCSAgICAgICBib29sIG1ha2VfZGlydHkpOwo+IC0KPiAgdm9pZCBw dXRfdXNlcl9wYWdlcyhzdHJ1Y3QgcGFnZSAqKnBhZ2VzLCB1bnNpZ25lZCBsb25nIG5wYWdlcyk7 Cj4gIAo+ICsvKioKPiArICogcGFnZV9kbWFfcGlubmVkKCkgLSByZXBvcnQgaWYgYSBwYWdlIGlz IHBpbm5lZCBieSBhIGNhbGwgdG8gcGluX3VzZXJfcGFnZXMqKCkKPiArICogb3IgcGluX2xvbmd0 ZXJtX3BhZ2VzKigpCj4gKyAqIEBwYWdlOglwb2ludGVyIHRvIHBhZ2UgdG8gYmUgcXVlcmllZC4K PiArICogQFJldHVybjoJVHJ1ZSwgaWYgaXQgaXMgbGlrZWx5IHRoYXQgdGhlIHBhZ2UgaGFzIGJl ZW4gImRtYS1waW5uZWQiLgo+ICsgKgkJRmFsc2UsIGlmIHRoZSBwYWdlIGlzIGRlZmluaXRlbHkg bm90IGRtYS1waW5uZWQuCj4gKyAqLwoKTWF5YmUgYWRkIGEgc21hbGwgY29tbWVudCBhYm91dCB3 cmFwIGFyb3VuZCA6KQoKPiArc3RhdGljIGlubGluZSBib29sIHBhZ2VfZG1hX3Bpbm5lZChzdHJ1 Y3QgcGFnZSAqcGFnZSkKPiArewo+ICsJcmV0dXJuIChwYWdlX3JlZl9jb3VudChjb21wb3VuZF9o ZWFkKHBhZ2UpKSkgPj0gR1VQX1BJTl9DT1VOVElOR19CSUFTOwo+ICt9Cj4gKwo+ICAjaWYgZGVm aW5lZChDT05GSUdfU1BBUlNFTUVNKSAmJiAhZGVmaW5lZChDT05GSUdfU1BBUlNFTUVNX1ZNRU1N QVApCj4gICNkZWZpbmUgU0VDVElPTl9JTl9QQUdFX0ZMQUdTCj4gICNlbmRpZgoKWy4uLl0KCj4g ZGlmZiAtLWdpdCBhL21tL2d1cC5jIGIvbW0vZ3VwLmMKPiBpbmRleCAxYWVhNDg0Mjc4NzkuLmM5 NzI3ZTY1ZmFkMyAxMDA2NDQKPiAtLS0gYS9tbS9ndXAuYwo+ICsrKyBiL21tL2d1cC5jCgpbLi4u XQoKPiBAQCAtMTkzMCwxMiArMjAyOCwyMCBAQCBzdGF0aWMgaW50IF9fZ3VwX2RldmljZV9odWdl KHVuc2lnbmVkIGxvbmcgcGZuLCB1bnNpZ25lZCBsb25nIGFkZHIsCj4gIAo+ICAJCXBnbWFwID0g Z2V0X2Rldl9wYWdlbWFwKHBmbiwgcGdtYXApOwo+ICAJCWlmICh1bmxpa2VseSghcGdtYXApKSB7 Cj4gLQkJCXVuZG9fZGV2X3BhZ2VtYXAobnIsIG5yX3N0YXJ0LCBwYWdlcyk7Cj4gKwkJCXVuZG9f ZGV2X3BhZ2VtYXAobnIsIG5yX3N0YXJ0LCBmbGFncywgcGFnZXMpOwo+ICAJCQlyZXR1cm4gMDsK PiAgCQl9Cj4gIAkJU2V0UGFnZVJlZmVyZW5jZWQocGFnZSk7Cj4gIAkJcGFnZXNbKm5yXSA9IHBh Z2U7Cj4gLQkJZ2V0X3BhZ2UocGFnZSk7Cj4gKwo+ICsJCWlmIChmbGFncyAmIEZPTExfUElOKSB7 Cj4gKwkJCWlmICh1bmxpa2VseSghdXNlcl9wYWdlX3JlZl9pbmMocGFnZSkpKSB7Cj4gKwkJCQl1 bmRvX2Rldl9wYWdlbWFwKG5yLCBucl9zdGFydCwgZmxhZ3MsIHBhZ2VzKTsKPiArCQkJCXJldHVy biAwOwo+ICsJCQl9CgpNYXliZSBhZGQgYSBjb21tZW50IGFib3V0IGEgY2FzZSB0aGF0IHNob3Vs ZCBuZXZlciBoYXBwZW5zIGllCnVzZXJfcGFnZV9yZWZfaW5jKCkgZmFpbHMgYWZ0ZXIgdGhlIHNl Y29uZCBpdGVyYXRpb24gb2YgdGhlCmxvb3AgYXMgaXQgd291bGQgYmUgYnJva2VuIGFuZCBhIGJ1 ZyB0byBjYWxsIHVuZG9fZGV2X3BhZ2VtYXAoKQphZnRlciB0aGUgZmlyc3QgaXRlcmF0aW9uIG9m IHRoYXQgbG9vcC4KCkFsc28gaSBiZWxpZXZlIHRoYXQgdGhpcyBzaG91bGQgbmV2ZXIgaGFwcGVu cyBhcyBpZiBmaXJzdAppdGVyYXRpb24gc3VjY2VlZCB0aGFuIF9fcGFnZV9jYWNoZV9hZGRfc3Bl Y3VsYXRpdmUoKSB3aWxsCnN1Y2NlZWQgZm9yIGFsbCB0aGUgaXRlcmF0aW9ucy4KCk5vdGUgdGhh dCB0aGUgcGdtYXAgY2FzZSBhYm92ZSBmb2xsb3dzIHRoYXQgdG9vIGllIHRoZSBjYWxsIHRvCmdl dF9kZXZfcGFnZW1hcCgpIGNhbiBvbmx5IGZhaWwgb24gZmlyc3QgaXRlcmF0aW9uIG9mIHRoZSBs b29wLAp3ZWxsIGkgYXNzdW1lIHlvdSBjYW4gbmV2ZXIgaGF2ZSBhIGh1Z2UgZGV2aWNlIHBhZ2Ug dGhhdCBzcGFuCmRpZmZlcmVudCBwZ21hcCBpZSBkaWZmZXJlbnQgZGV2aWNlcyAod2hpY2ggaXMg YSByZWFzb25hYmxlCmFzc3VtcHRpb24pLiBTbyBtYXliZSB0aGlzIGNvZGUgbmVlZHMgZml4aW5n IGllIDoKCgkJcGdtYXAgPSBnZXRfZGV2X3BhZ2VtYXAocGZuLCBwZ21hcCk7CgkJaWYgKHVubGlr ZWx5KCFwZ21hcCkpCgkJCXJldHVybiAwOwoKCj4gKwkJfSBlbHNlCj4gKwkJCWdldF9wYWdlKHBh Z2UpOwo+ICsKPiAgCQkoKm5yKSsrOwo+ICAJCXBmbisrOwo+ICAJfSB3aGlsZSAoYWRkciArPSBQ QUdFX1NJWkUsIGFkZHIgIT0gZW5kKTsKClsuLi5dCgo+IEBAIC0yNDA5LDcgKzI1NDAsNyBAQCBz dGF0aWMgaW50IGludGVybmFsX2dldF91c2VyX3BhZ2VzX2Zhc3QodW5zaWduZWQgbG9uZyBzdGFy dCwgaW50IG5yX3BhZ2VzLAo+ICAJdW5zaWduZWQgbG9uZyBhZGRyLCBsZW4sIGVuZDsKPiAgCWlu dCBuciA9IDAsIHJldCA9IDA7Cj4gIAo+IC0JaWYgKFdBUk5fT05fT05DRShndXBfZmxhZ3MgJiB+ KEZPTExfV1JJVEUgfCBGT0xMX0xPTkdURVJNKSkpCj4gKwlpZiAoV0FSTl9PTl9PTkNFKGd1cF9m bGFncyAmIH4oRk9MTF9XUklURSB8IEZPTExfTE9OR1RFUk0gfCBGT0xMX1BJTikpKQoKTWF5YmUg YWRkIGEgY29tbWVudHMgdG8gZXhwbGFpbiwgc29tZXRoaW5nIGxpa2U6CgovKgogKiBUaGUgb25s eSBmbGFncyBhbGxvd2VkIGhlcmUgYXJlOiBGT0xMX1dSSVRFLCBGT0xMX0xPTkdURVJNLCBGT0xM X1BJTgogKgogKiBOb3RlIHRoYXQgZ2V0X3VzZXJfcGFnZXNfZmFzdCgpIGltcGx5IEZPTExfR0VU IGZsYWcgYnkgZGVmYXVsdCBidXQKICogY2FsbGVycyBjYW4gb3Zlci1yaWRlIHRoaXMgZGVmYXVs dCB0byBwaW4gY2FzZSBieSBzZXR0aW5nIEZPTExfUElOLgogKi8KCj4gIAkJcmV0dXJuIC1FSU5W QUw7Cj4gIAo+ICAJc3RhcnQgPSB1bnRhZ2dlZF9hZGRyKHN0YXJ0KSAmIFBBR0VfTUFTSzsKPiBk aWZmIC0tZ2l0IGEvbW0vaHVnZV9tZW1vcnkuYyBiL21tL2h1Z2VfbWVtb3J5LmMKPiBpbmRleCAx M2NjOTM3ODUwMDYuLjY2YmY0YzhiODhmMSAxMDA2NDQKPiAtLS0gYS9tbS9odWdlX21lbW9yeS5j Cj4gKysrIGIvbW0vaHVnZV9tZW1vcnkuYwoKWy4uLl0KCj4gQEAgLTk2OCw3ICs5NzMsMTIgQEAg c3RydWN0IHBhZ2UgKmZvbGxvd19kZXZtYXBfcG1kKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1h LCB1bnNpZ25lZCBsb25nIGFkZHIsCj4gIAlpZiAoISpwZ21hcCkKPiAgCQlyZXR1cm4gRVJSX1BU UigtRUZBVUxUKTsKPiAgCXBhZ2UgPSBwZm5fdG9fcGFnZShwZm4pOwo+IC0JZ2V0X3BhZ2UocGFn ZSk7Cj4gKwo+ICsJaWYgKGZsYWdzICYgRk9MTF9HRVQpCj4gKwkJZ2V0X3BhZ2UocGFnZSk7Cj4g KwllbHNlIGlmIChmbGFncyAmIEZPTExfUElOKQo+ICsJCWlmICh1bmxpa2VseSghdXNlcl9wYWdl X3JlZl9pbmMocGFnZSkpKQo+ICsJCQlwYWdlID0gRVJSX1BUUigtRU5PTUVNKTsKCldoaWxlIGkg YWdyZWUgdGhhdCB1c2VyX3BhZ2VfcmVmX2luYygpIChpZSBwYWdlX2NhY2hlX2FkZF9zcGVjdWxh dGl2ZSgpKQpzaG91bGQgbmV2ZXIgZmFpbHMgaGVyZSBhcyB3ZSBhcmUgaG9sZGluZyB0aGUgcG1k IGxvY2sgYW5kIHRodXMgbm8gb25lCmNhbiB1bm1hcCB0aGUgcG1kIGFuZCBmcmVlIHRoZSBwYWdl IGl0IHBvaW50cyB0by4gSSBiZWxpZXZlIHlvdSBzaG91bGQKcmV0dXJuIC1FRkFVTFQgbGlrZSBm b3IgdGhlIHBnbWFwIGFuZCBub3QgLUVOT01FTSBhcyB0aGUgcGdtYXAgc2hvdWxkCm5vdCBmYWls IGVpdGhlciBmb3IgdGhlIHNhbWUgcmVhc29uLiBUaHVzIGl0IHdvdWxkIGJlIGJldHRlciB0byBo YXZlCmNvbnNpc3RlbnQgZXJyb3IuIE1heWJlIGFsc28gYWRkIGEgY29tbWVudHMgZXhwbGFpbmlu ZyB0aGF0IGl0IHNob3VsZApub3QgZmFpbCBoZXJlLgoKPiAgCj4gIAlyZXR1cm4gcGFnZTsKPiAg fQoKWy4uLl0KCj4gQEAgLTExMDAsNyArMTExNSw3IEBAIHN0cnVjdCBwYWdlICpmb2xsb3dfZGV2 bWFwX3B1ZChzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwgdW5zaWduZWQgbG9uZyBhZGRyLAo+ ICAJICogZGV2aWNlIG1hcHBlZCBwYWdlcyBjYW4gb25seSBiZSByZXR1cm5lZCBpZiB0aGUKPiAg CSAqIGNhbGxlciB3aWxsIG1hbmFnZSB0aGUgcGFnZSByZWZlcmVuY2UgY291bnQuCj4gIAkgKi8K PiAtCWlmICghKGZsYWdzICYgRk9MTF9HRVQpKQo+ICsJaWYgKCEoZmxhZ3MgJiAoRk9MTF9HRVQg fCBGT0xMX1BJTikpKQo+ICAJCXJldHVybiBFUlJfUFRSKC1FRVhJU1QpOwoKTWF5YmUgYWRkIGEg Y29tbWVudCB0aGF0IEZPTExfR0VUIG9yIEZPTExfUElOIG11c3QgYmUgc2V0LgoKPiAgCXBmbiAr PSAoYWRkciAmIH5QVURfTUFTSykgPj4gUEFHRV9TSElGVDsKPiBAQCAtMTEwOCw3ICsxMTIzLDEy IEBAIHN0cnVjdCBwYWdlICpmb2xsb3dfZGV2bWFwX3B1ZChzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3Qg KnZtYSwgdW5zaWduZWQgbG9uZyBhZGRyLAo+ICAJaWYgKCEqcGdtYXApCj4gIAkJcmV0dXJuIEVS Ul9QVFIoLUVGQVVMVCk7Cj4gIAlwYWdlID0gcGZuX3RvX3BhZ2UocGZuKTsKPiAtCWdldF9wYWdl KHBhZ2UpOwo+ICsKPiArCWlmIChmbGFncyAmIEZPTExfR0VUKQo+ICsJCWdldF9wYWdlKHBhZ2Up Owo+ICsJZWxzZSBpZiAoZmxhZ3MgJiBGT0xMX1BJTikKPiArCQlpZiAodW5saWtlbHkoIXVzZXJf cGFnZV9yZWZfaW5jKHBhZ2UpKSkKPiArCQkJcGFnZSA9IEVSUl9QVFIoLUVOT01FTSk7CgpTYW1l IGFzIGZvciBmb2xsb3dfZGV2bWFwX3BtZCgpIHNlZSBhYm92ZS4KCj4gIAo+ICAJcmV0dXJuIHBh Z2U7Cj4gIH0KPiBAQCAtMTUyMiw4ICsxNTQyLDEyIEBAIHN0cnVjdCBwYWdlICpmb2xsb3dfdHJh bnNfaHVnZV9wbWQoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCj4gIHNraXBfbWxvY2s6Cj4g IAlwYWdlICs9IChhZGRyICYgfkhQQUdFX1BNRF9NQVNLKSA+PiBQQUdFX1NISUZUOwo+ICAJVk1f QlVHX09OX1BBR0UoIVBhZ2VDb21wb3VuZChwYWdlKSAmJiAhaXNfem9uZV9kZXZpY2VfcGFnZShw YWdlKSwgcGFnZSk7Cj4gKwo+ICAJaWYgKGZsYWdzICYgRk9MTF9HRVQpCj4gIAkJZ2V0X3BhZ2Uo cGFnZSk7Cj4gKwllbHNlIGlmIChmbGFncyAmIEZPTExfUElOKQo+ICsJCWlmICh1bmxpa2VseSgh dXNlcl9wYWdlX3JlZl9pbmMocGFnZSkpKQo+ICsJCQlwYWdlID0gTlVMTDsKClRoaXMgc2hvdWxk IG5vdCBmYWlsIGVpdGhlciBhcyB3ZSBhcmUgaG9sZGluZyB0aGUgcG1kIGxvY2sgbWF5YmUgYWRk CmEgY29tbWVudC4gRHVubm8gaWYgd2Ugd2FudCBhIFdBUk4oKSBvciBzb21ldGhpbmcgdG8gY2F0 Y2ggdGhpcwpkZWdlbmVyYXRlIGNhc2UsIG9yIGR1bXAgdGhlIHBhZ2UuCgo+ICAKPiAgb3V0Ogo+ ICAJcmV0dXJuIHBhZ2U7Cj4gZGlmZiAtLWdpdCBhL21tL2h1Z2V0bGIuYyBiL21tL2h1Z2V0bGIu Ywo+IGluZGV4IGI0NWE5NTM2M2E4NC4uZGEzMzViMWNkNzk4IDEwMDY0NAo+IC0tLSBhL21tL2h1 Z2V0bGIuYwo+ICsrKyBiL21tL2h1Z2V0bGIuYwo+IEBAIC00NDYyLDcgKzQ0NjIsMTcgQEAgbG9u ZyBmb2xsb3dfaHVnZXRsYl9wYWdlKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCBzdHJ1Y3Qgdm1fYXJl YV9zdHJ1Y3QgKnZtYSwKPiAgc2FtZV9wYWdlOgo+ICAJCWlmIChwYWdlcykgewo+ICAJCQlwYWdl c1tpXSA9IG1lbV9tYXBfb2Zmc2V0KHBhZ2UsIHBmbl9vZmZzZXQpOwo+IC0JCQlnZXRfcGFnZShw YWdlc1tpXSk7Cj4gKwo+ICsJCQlpZiAoZmxhZ3MgJiBGT0xMX0dFVCkKPiArCQkJCWdldF9wYWdl KHBhZ2VzW2ldKTsKPiArCQkJZWxzZSBpZiAoZmxhZ3MgJiBGT0xMX1BJTikKPiArCQkJCWlmICh1 bmxpa2VseSghdXNlcl9wYWdlX3JlZl9pbmMocGFnZXNbaV0pKSkgewo+ICsJCQkJCXNwaW5fdW5s b2NrKHB0bCk7Cj4gKwkJCQkJcmVtYWluZGVyID0gMDsKPiArCQkJCQllcnIgPSAtRU5PTUVNOwo+ ICsJCQkJCVdBUk5fT05fT05DRSgxKTsKPiArCQkJCQlicmVhazsKPiArCQkJCX0KPiAgCQl9Cgp1 c2VyX3BhZ2VfcmVmX2luYygpIHNob3VsZCBub3QgZmFpbCBoZXJlIGVpdGhlciBiZWNhdXNlIHdl IGhvbGQgdGhlCnB0bCwgc28gdGhlIFdBUl9PTl9PTkNFKCkgaXMgcmlnaHQgYnV0IG1heWJlIGFk ZCBhIGNvbW1lbnQuCgo+ICAKPiAgCQlpZiAodm1hcykKClsuLi5dCgo+IEBAIC01MDM0LDggKzUw NTAsMTQgQEAgZm9sbG93X2h1Z2VfcG1kKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCB1bnNpZ25lZCBs b25nIGFkZHJlc3MsCj4gIAlwdGUgPSBodWdlX3B0ZXBfZ2V0KChwdGVfdCAqKXBtZCk7Cj4gIAlp ZiAocHRlX3ByZXNlbnQocHRlKSkgewo+ICAJCXBhZ2UgPSBwbWRfcGFnZSgqcG1kKSArICgoYWRk cmVzcyAmIH5QTURfTUFTSykgPj4gUEFHRV9TSElGVCk7Cj4gKwo+ICAJCWlmIChmbGFncyAmIEZP TExfR0VUKQo+ICAJCQlnZXRfcGFnZShwYWdlKTsKPiArCQllbHNlIGlmIChmbGFncyAmIEZPTExf UElOKQo+ICsJCQlpZiAodW5saWtlbHkoIXVzZXJfcGFnZV9yZWZfaW5jKHBhZ2UpKSkgewo+ICsJ CQkJcGFnZSA9IE5VTEw7Cj4gKwkJCQlnb3RvIG91dDsKPiArCQkJfQoKVGhpcyBzaG91bGQgbm90 IGZhaWwgZWl0aGVyIChhZ2FpbiBob2xkaW5nIHBtZCBsb2NrKSwgZHVubm8gaWYgd2Ugd2FudAph IHdhcm4gb3Igc29tZXRoaW5nIHRvIGNhdGNoIHRoaXMgZGVnZW5lcmF0ZSBjYXNlLgoKPiAgCX0g ZWxzZSB7Cj4gIAkJaWYgKGlzX2h1Z2V0bGJfZW50cnlfbWlncmF0aW9uKHB0ZSkpIHsKPiAgCQkJ c3Bpbl91bmxvY2socHRsKTsKClsuLi5dCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5m cmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0 aW5mby9kcmktZGV2ZWw=