From mboxrd@z Thu Jan 1 00:00:00 1970 From: John Hubbard Subject: [PATCH v6 17/24] mm/gup: track FOLL_PIN pages Date: Tue, 19 Nov 2019 00:16:36 -0800 Message-ID: <20191119081643.1866232-18-jhubbard@nvidia.com> References: <20191119081643.1866232-1-jhubbard@nvidia.com> Mime-Version: 1.0 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Return-path: In-Reply-To: <20191119081643.1866232-1-jhubbard@nvidia.com> Sender: netdev-owner@vger.kernel.org To: Andrew Morton Cc: Al Viro , Alex Williamson , Benjamin Herrenschmidt , =?UTF-8?q?Bj=C3=B6rn=20T=C3=B6pel?= , Christoph Hellwig , Dan Williams , Daniel Vetter , Dave Chinner , David Airlie , "David S . Miller" , Ira Weiny , Jan Kara , Jason Gunthorpe , Jens Axboe , Jonathan Corbet , =?UTF-8?q?J=C3=A9r=C3=B4me=20Glisse?= , Magnus Karlsson , Mauro Carvalho Chehab , Michael Ellerman M List-Id: dri-devel@lists.freedesktop.org Add tracking of pages that were pinned via FOLL_PIN. 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". Pages that have been pinned via FOLL_PIN are identifiable via a new function call: bool page_dma_pinned(struct page *page); What to do in response to encountering such a page, is left to later patchsets. There is discussion about this in [1], [2], and [3]. This also changes a BUG_ON(), to a WARN_ON(), in follow_page_mask(). [1] Some slow progress on get_user_pages() (Apr 2, 2019): https://lwn.net/Articles/784574/ [2] DMA and get_user_pages() (LPC: Dec 12, 2018): https://lwn.net/Articles/774411/ [3] The trouble with get_user_pages() (Apr 30, 2018): https://lwn.net/Articles/753027/ Suggested-by: Jan Kara Suggested-by: J=C3=A9r=C3=B4me Glisse Signed-off-by: John Hubbard --- Documentation/core-api/pin_user_pages.rst | 2 +- include/linux/mm.h | 86 +++++-- include/linux/mmzone.h | 2 + include/linux/page_ref.h | 10 + mm/gup.c | 290 ++++++++++++++++------ mm/huge_memory.c | 54 +++- mm/hugetlb.c | 39 ++- mm/vmstat.c | 2 + 8 files changed, 390 insertions(+), 95 deletions(-) diff --git a/Documentation/core-api/pin_user_pages.rst b/Documentation/core= -api/pin_user_pages.rst index 4f26637a5005..baa288a44a77 100644 --- a/Documentation/core-api/pin_user_pages.rst +++ b/Documentation/core-api/pin_user_pages.rst @@ -53,7 +53,7 @@ Which flags are set by each wrapper For these pin_user_pages*() functions, FOLL_PIN is OR'd in with whatever g= up flags the caller provides. The caller is required to pass in a non-null st= ruct pages* array, and the function then pin pages by incrementing each by a sp= ecial -value. For now, that value is +1, just like get_user_pages*().:: +value: GUP_PIN_COUNTING_BIAS.:: =20 Function -------- diff --git a/include/linux/mm.h b/include/linux/mm.h index 568cbb895f03..ab311b356ab1 100644 --- a/include/linux/mm.h +++ b/include/linux/mm.h @@ -1054,6 +1054,21 @@ static inline __must_check bool try_get_page(struct = page *page) return true; } =20 +__must_check bool try_pin_compound_head(struct page *page, int refs); + +/** + * try_pin_page() - mark a page as being used by pin_user_pages*(). + * + * This is the FOLL_PIN counterpart to try_get_page(). + * + * @page: pointer to page to be marked + * @Return: true for success, false for failure + */ +static inline __must_check bool try_pin_page(struct page *page) +{ + return try_pin_compound_head(page, 1); +} + static inline void put_page(struct page *page) { page =3D compound_head(page); @@ -1071,29 +1086,70 @@ static inline void put_page(struct page *page) __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, overlo= ad + * the page's refcount so that two separate items are tracked: the origina= l page + * reference count, and also a new count of how many pin_user_pages() call= s were + * made against the page. ("gup-pinned" is another term for the latter). + * + * With this scheme, pin_user_pages() becomes special: such pages are mark= ed as + * distinct from normal pages. As such, the put_user_page() call (and its + * variants) must be used in order to release gup-pinned pages. + * + * Choice of value: + * + * By making GUP_PIN_COUNTING_BIAS a power of two, debugging of page refer= ence + * counts with respect to pin_user_pages() and put_user_page() becomes sim= pler, + * due to the fact that adding an even power of two to the page refcount h= as the + * effect of using only the upper N bits, for the code that counts up usin= g the + * bias value. This means that the lower bits are left for the exclusive u= se of + * the original code that increments and decrements by one (or at least, b= y much + * smaller values than the bias value). * - * Pages that were pinned via pin_user_pages*() must be released via eithe= r - * put_user_page(), or one of the put_user_pages*() routines. This is so t= hat - * eventually such pages can be separately tracked and uniquely handled. I= n - * particular, interactions with RDMA and filesystems need special handlin= g. + * Of course, once the lower bits overflow into the upper bits (and this i= s + * OK, because subtraction recovers the original values), then visual insp= ection + * no longer suffices to directly view the separate counts. However, for n= ormal + * applications that don't have huge page reference counts, this won't be = an + * issue. * - * put_user_page() and put_page() are not interchangeable, despite this ea= rly - * implementation that makes them look the same. put_user_page() calls mus= t - * be perfectly matched up with pin*() calls. + * Locking: the lockless algorithm described in page_cache_get_speculative= () + * and page_cache_gup_pin_speculative() provides safe operation for + * get_user_pages and page_mkclean and other calls that race to set up pag= e + * table entries. */ -static inline void put_user_page(struct page *page) -{ - put_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, bool make_dirty); - void put_user_pages(struct page **pages, unsigned long npages); =20 +/** + * page_dma_pinned() - report if a page is pinned for DMA. + * + * This function checks if a page has been pinned via a call to + * pin_user_pages*(). + * + * The return value is partially fuzzy: false is not fuzzy, because it mea= ns + * "definitely not pinned for DMA", but true means "probably pinned for DM= A, but + * possibly a false positive due to having at least GUP_PIN_COUNTING_BIAS = worth + * of normal page references". + * + * False positives are OK, because: a) it's unlikely for a page to get tha= t many + * refcounts, and b) all the callers of this routine are expected to be ab= le to + * deal gracefully with a false positive. + * + * For more information, please see Documentation/vm/pin_user_pages.rst. + * + * @page: pointer to page to be queried. + * @Return: True, if it is likely that the page has been "dma-pinned". + * False, if the page is definitely not dma-pinned. + */ +static inline bool page_dma_pinned(struct page *page) +{ + return (page_ref_count(compound_head(page))) >=3D GUP_PIN_COUNTING_BIAS; +} + #if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP) #define SECTION_IN_PAGE_FLAGS #endif diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h index bda20282746b..0485cba38d23 100644 --- a/include/linux/mmzone.h +++ b/include/linux/mmzone.h @@ -244,6 +244,8 @@ enum node_stat_item { NR_DIRTIED, /* page dirtyings since bootup */ NR_WRITTEN, /* page writings since bootup */ NR_KERNEL_MISC_RECLAIMABLE, /* reclaimable non-slab kernel pages */ + NR_FOLL_PIN_REQUESTED, /* via: pin_user_page(), gup flag: FOLL_PIN */ + NR_FOLL_PIN_RETURNED, /* pages returned via put_user_page() */ NR_VM_NODE_STAT_ITEMS }; =20 diff --git a/include/linux/page_ref.h b/include/linux/page_ref.h index 14d14beb1f7f..b9cbe553d1e7 100644 --- a/include/linux/page_ref.h +++ b/include/linux/page_ref.h @@ -102,6 +102,16 @@ static inline void page_ref_sub(struct page *page, int= nr) __page_ref_mod(page, -nr); } =20 +static inline int page_ref_sub_return(struct page *page, int nr) +{ + int ret =3D atomic_sub_return(nr, &page->_refcount); + + if (page_ref_tracepoint_active(__tracepoint_page_ref_mod)) + __page_ref_mod(page, -nr); + + return ret; +} + static inline void page_ref_inc(struct page *page) { atomic_inc(&page->_refcount); diff --git a/mm/gup.c b/mm/gup.c index f72d7a1635b4..002816526670 100644 --- a/mm/gup.c +++ b/mm/gup.c @@ -51,6 +51,96 @@ static inline struct page *try_get_compound_head(struct = page *page, int refs) return head; } =20 +#ifdef CONFIG_DEBUG_VM +static inline void __update_proc_vmstat(struct page *page, + enum node_stat_item item, int count) +{ + mod_node_page_state(page_pgdat(page), item, count); +} +#else +static inline void __update_proc_vmstat(struct page *page, + enum node_stat_item item, int count) +{ +} +#endif + +/** + * try_pin_compound_head() - mark a compound page as being used by + * pin_user_pages*(). + * + * This is the FOLL_PIN counterpart to try_get_compound_head(). + * + * @page: pointer to page to be marked + * @Return: true for success, false for failure + */ +__must_check bool try_pin_compound_head(struct page *page, int refs) +{ + page =3D try_get_compound_head(page, GUP_PIN_COUNTING_BIAS * refs); + if (!page) + return false; + + __update_proc_vmstat(page, NR_FOLL_PIN_REQUESTED, refs); + return true; +} + +#ifdef CONFIG_DEV_PAGEMAP_OPS +static bool __put_devmap_managed_user_page(struct page *page) +{ + bool is_devmap =3D page_is_devmap_managed(page); + + if (is_devmap) { + int count =3D page_ref_sub_return(page, GUP_PIN_COUNTING_BIAS); + + __update_proc_vmstat(page, NR_FOLL_PIN_RETURNED, 1); + /* + * devmap page refcounts are 1-based, rather than 0-based: if + * refcount is 1, then the page is free and the refcount is + * stable because nobody holds a reference on the page. + */ + if (count =3D=3D 1) + free_devmap_managed_page(page); + else if (!count) + __put_page(page); + } + + return is_devmap; +} +#else +static bool __put_devmap_managed_user_page(struct page *page) +{ + return false; +} +#endif /* CONFIG_DEV_PAGEMAP_OPS */ + +/** + * put_user_page() - release a dma-pinned page + * @page: pointer to page to be released + * + * Pages that were pinned via pin_user_pages*() must be released via eithe= r + * put_user_page(), or one of the put_user_pages*() routines. This is so t= hat + * such pages can be separately tracked and uniquely handled. In particula= r, + * interactions with RDMA and filesystems need special handling. + */ +void put_user_page(struct page *page) +{ + page =3D compound_head(page); + + /* + * For devmap managed pages we need to catch refcount transition from + * GUP_PIN_COUNTING_BIAS to 1, when refcount reach one it means the + * page is free and we need to inform the device driver through + * callback. See include/linux/memremap.h and HMM for details. + */ + if (__put_devmap_managed_user_page(page)) + return; + + if (page_ref_sub_and_test(page, GUP_PIN_COUNTING_BIAS)) + __put_page(page); + + __update_proc_vmstat(page, NR_FOLL_PIN_RETURNED, 1); +} +EXPORT_SYMBOL(put_user_page); + /** * put_user_pages_dirty_lock() - release and optionally dirty gup-pinned p= ages * @pages: array of pages to be maybe marked dirty, and definitely releas= ed. @@ -237,10 +327,11 @@ static struct page *follow_page_pte(struct vm_area_st= ruct *vma, } =20 page =3D vm_normal_page(vma, address, pte); - if (!page && pte_devmap(pte) && (flags & FOLL_GET)) { + if (!page && pte_devmap(pte) && (flags & (FOLL_GET | FOLL_PIN))) { /* - * Only return device mapping pages in the FOLL_GET case since - * they are only valid while holding the pgmap reference. + * Only return device mapping pages in the FOLL_GET or FOLL_PIN + * case since they are only valid while holding the pgmap + * reference. */ *pgmap =3D get_dev_pagemap(pte_pfn(pte), *pgmap); if (*pgmap) @@ -283,6 +374,11 @@ static struct page *follow_page_pte(struct vm_area_str= uct *vma, page =3D ERR_PTR(-ENOMEM); goto out; } + } else if (flags & FOLL_PIN) { + if (unlikely(!try_pin_page(page))) { + page =3D ERR_PTR(-ENOMEM); + goto out; + } } if (flags & FOLL_TOUCH) { if ((flags & FOLL_WRITE) && @@ -544,8 +640,8 @@ static struct page *follow_page_mask(struct vm_area_str= uct *vma, /* make this handle hugepd */ page =3D follow_huge_addr(mm, address, flags & FOLL_WRITE); if (!IS_ERR(page)) { - BUG_ON(flags & FOLL_GET); - return page; + WARN_ON_ONCE(flags & (FOLL_GET | FOLL_PIN)); + return NULL; } =20 pgd =3D pgd_offset(mm, address); @@ -1125,6 +1221,36 @@ static __always_inline long __get_user_pages_locked(= struct task_struct *tsk, return pages_done; } =20 +static long __get_user_pages_remote(struct task_struct *tsk, + struct mm_struct *mm, + unsigned long start, unsigned long nr_pages, + unsigned int gup_flags, struct page **pages, + struct vm_area_struct **vmas, int *locked) +{ + /* + * Parts of FOLL_LONGTERM behavior are incompatible with + * FAULT_FLAG_ALLOW_RETRY because of the FS DAX check requirement on + * vmas. However, this only comes up if locked is set, and there are + * callers that do request FOLL_LONGTERM, but do not set locked. So, + * allow what we can. + */ + if (gup_flags & FOLL_LONGTERM) { + if (WARN_ON_ONCE(locked)) + return -EINVAL; + /* + * This will check the vmas (even if our vmas arg is NULL) + * and return -ENOTSUPP if DAX isn't allowed in this case: + */ + return __gup_longterm_locked(tsk, mm, start, nr_pages, pages, + vmas, gup_flags | FOLL_TOUCH | + FOLL_REMOTE); + } + + return __get_user_pages_locked(tsk, mm, start, nr_pages, pages, vmas, + locked, + gup_flags | FOLL_TOUCH | FOLL_REMOTE); +} + /* * get_user_pages_remote() - pin user pages in memory * @tsk: the task_struct to use for page fault accounting, or @@ -1193,28 +1319,8 @@ long get_user_pages_remote(struct task_struct *tsk, = struct mm_struct *mm, if (WARN_ON_ONCE(gup_flags & FOLL_PIN)) return -EINVAL; =20 - /* - * Parts of FOLL_LONGTERM behavior are incompatible with - * FAULT_FLAG_ALLOW_RETRY because of the FS DAX check requirement on - * vmas. However, this only comes up if locked is set, and there are - * callers that do request FOLL_LONGTERM, but do not set locked. So, - * allow what we can. - */ - if (gup_flags & FOLL_LONGTERM) { - if (WARN_ON_ONCE(locked)) - return -EINVAL; - /* - * This will check the vmas (even if our vmas arg is NULL) - * and return -ENOTSUPP if DAX isn't allowed in this case: - */ - return __gup_longterm_locked(tsk, mm, start, nr_pages, pages, - vmas, gup_flags | FOLL_TOUCH | - FOLL_REMOTE); - } - - return __get_user_pages_locked(tsk, mm, start, nr_pages, pages, vmas, - locked, - gup_flags | FOLL_TOUCH | FOLL_REMOTE); + return __get_user_pages_remote(tsk, mm, start, nr_pages, gup_flags, + pages, vmas, locked); } EXPORT_SYMBOL(get_user_pages_remote); =20 @@ -1842,13 +1948,17 @@ static inline pte_t gup_get_pte(pte_t *ptep) #endif /* CONFIG_GUP_GET_PTE_LOW_HIGH */ =20 static void __maybe_unused undo_dev_pagemap(int *nr, int nr_start, + unsigned int flags, struct page **pages) { while ((*nr) - nr_start) { struct page *page =3D pages[--(*nr)]; =20 ClearPageReferenced(page); - put_page(page); + if (flags & FOLL_PIN) + put_user_page(page); + else + put_page(page); } } =20 @@ -1881,7 +1991,7 @@ static int gup_pte_range(pmd_t pmd, unsigned long add= r, unsigned long end, =20 pgmap =3D get_dev_pagemap(pte_pfn(pte), pgmap); if (unlikely(!pgmap)) { - undo_dev_pagemap(nr, nr_start, pages); + undo_dev_pagemap(nr, nr_start, flags, pages); goto pte_unmap; } } else if (pte_special(pte)) @@ -1890,9 +2000,15 @@ static int gup_pte_range(pmd_t pmd, unsigned long ad= dr, unsigned long end, VM_BUG_ON(!pfn_valid(pte_pfn(pte))); page =3D pte_page(pte); =20 - head =3D try_get_compound_head(page, 1); - if (!head) - goto pte_unmap; + if (flags & FOLL_PIN) { + head =3D page; + if (unlikely(!try_pin_page(head))) + goto pte_unmap; + } else { + head =3D try_get_compound_head(page, 1); + if (!head) + goto pte_unmap; + } =20 if (unlikely(pte_val(pte) !=3D pte_val(*ptep))) { put_page(head); @@ -1946,12 +2062,20 @@ static int __gup_device_huge(unsigned long pfn, uns= igned long addr, =20 pgmap =3D get_dev_pagemap(pfn, pgmap); if (unlikely(!pgmap)) { - undo_dev_pagemap(nr, nr_start, pages); + undo_dev_pagemap(nr, nr_start, flags, pages); return 0; } SetPageReferenced(page); pages[*nr] =3D page; - get_page(page); + + if (flags & FOLL_PIN) { + if (unlikely(!try_pin_page(page))) { + undo_dev_pagemap(nr, nr_start, flags, pages); + return 0; + } + } else + get_page(page); + (*nr)++; pfn++; } while (addr +=3D PAGE_SIZE, addr !=3D end); @@ -1973,7 +2097,7 @@ static int __gup_device_huge_pmd(pmd_t orig, pmd_t *p= mdp, unsigned long addr, return 0; =20 if (unlikely(pmd_val(orig) !=3D pmd_val(*pmdp))) { - undo_dev_pagemap(nr, nr_start, pages); + undo_dev_pagemap(nr, nr_start, flags, pages); return 0; } return 1; @@ -1991,7 +2115,7 @@ static int __gup_device_huge_pud(pud_t orig, pud_t *p= udp, unsigned long addr, return 0; =20 if (unlikely(pud_val(orig) !=3D pud_val(*pudp))) { - undo_dev_pagemap(nr, nr_start, pages); + undo_dev_pagemap(nr, nr_start, flags, pages); return 0; } return 1; @@ -2025,6 +2149,20 @@ static int __record_subpages(struct page *page, unsi= gned long addr, return nr; } =20 +static bool __pin_compound_head(struct page *head, int refs, unsigned int = flags) +{ + if (flags & FOLL_PIN) { + if (unlikely(!try_pin_compound_head(head, refs))) + return false; + } else { + head =3D try_get_compound_head(head, refs); + if (!head) + return false; + } + + return true; +} + static void put_compound_head(struct page *page, int refs) { /* Do a get_page() first, in case refs =3D=3D page->_refcount */ @@ -2066,8 +2204,7 @@ static int gup_hugepte(pte_t *ptep, unsigned long sz,= unsigned long addr, page =3D head + ((addr & (sz-1)) >> PAGE_SHIFT); refs =3D __record_subpages(page, addr, end, pages + *nr); =20 - head =3D try_get_compound_head(head, refs); - if (!head) + if (!__pin_compound_head(head, refs, flags)) return 0; =20 if (unlikely(pte_val(pte) !=3D pte_val(*ptep))) { @@ -2126,8 +2263,8 @@ static int gup_huge_pmd(pmd_t orig, pmd_t *pmdp, unsi= gned long addr, page =3D pmd_page(orig) + ((addr & ~PMD_MASK) >> PAGE_SHIFT); refs =3D __record_subpages(page, addr, end, pages + *nr); =20 - head =3D try_get_compound_head(pmd_page(orig), refs); - if (!head) + head =3D pmd_page(orig); + if (!__pin_compound_head(head, refs, flags)) return 0; =20 if (unlikely(pmd_val(orig) !=3D pmd_val(*pmdp))) { @@ -2160,8 +2297,8 @@ static int gup_huge_pud(pud_t orig, pud_t *pudp, unsi= gned long addr, page =3D pud_page(orig) + ((addr & ~PUD_MASK) >> PAGE_SHIFT); refs =3D __record_subpages(page, addr, end, pages + *nr); =20 - head =3D try_get_compound_head(pud_page(orig), refs); - if (!head) + head =3D pud_page(orig); + if (!__pin_compound_head(head, refs, flags)) return 0; =20 if (unlikely(pud_val(orig) !=3D pud_val(*pudp))) { @@ -2189,8 +2326,8 @@ static int gup_huge_pgd(pgd_t orig, pgd_t *pgdp, unsi= gned long addr, page =3D pgd_page(orig) + ((addr & ~PGDIR_MASK) >> PAGE_SHIFT); refs =3D __record_subpages(page, addr, end, pages + *nr); =20 - head =3D try_get_compound_head(pgd_page(orig), refs); - if (!head) + head =3D pgd_page(orig); + if (!__pin_compound_head(head, refs, flags)) return 0; =20 if (unlikely(pgd_val(orig) !=3D pgd_val(*pgdp))) { @@ -2494,9 +2631,12 @@ EXPORT_SYMBOL_GPL(get_user_pages_fast); /** * pin_user_pages_fast() - pin user pages in memory without taking locks * - * For now, this is a placeholder function, until various call sites are - * converted to use the correct get_user_pages*() or pin_user_pages*() API= . So, - * this is identical to get_user_pages_fast(). + * Nearly the same as get_user_pages_fast(), except that FOLL_PIN is set. = See + * get_user_pages_fast() for documentation on the function arguments, beca= use + * the arguments here are identical. + * + * FOLL_PIN means that the pages must be released via unpin_user_page(). P= lease + * see Documentation/vm/pin_user_pages.rst for further details. * * This is intended for Case 1 (DIO) in Documentation/vm/pin_user_pages.rs= t. It * is NOT intended for Case 2 (RDMA: long-term pins). @@ -2504,21 +2644,24 @@ EXPORT_SYMBOL_GPL(get_user_pages_fast); int pin_user_pages_fast(unsigned long start, int nr_pages, unsigned int gup_flags, struct page **pages) { - /* - * This is a placeholder, until the pin functionality is activated. - * Until then, just behave like the corresponding get_user_pages*() - * routine. - */ - return get_user_pages_fast(start, nr_pages, gup_flags, pages); + /* FOLL_GET and FOLL_PIN are mutually exclusive. */ + if (WARN_ON_ONCE(gup_flags & FOLL_GET)) + return -EINVAL; + + gup_flags |=3D FOLL_PIN; + return internal_get_user_pages_fast(start, nr_pages, gup_flags, pages); } EXPORT_SYMBOL_GPL(pin_user_pages_fast); =20 /** * pin_user_pages_remote() - pin pages of a remote process (task !=3D curr= ent) * - * For now, this is a placeholder function, until various call sites are - * converted to use the correct get_user_pages*() or pin_user_pages*() API= . So, - * this is identical to get_user_pages_remote(). + * Nearly the same as get_user_pages_remote(), except that FOLL_PIN is set= . See + * get_user_pages_remote() for documentation on the function arguments, be= cause + * the arguments here are identical. + * + * FOLL_PIN means that the pages must be released via unpin_user_page(). P= lease + * see Documentation/vm/pin_user_pages.rst for details. * * This is intended for Case 1 (DIO) in Documentation/vm/pin_user_pages.rs= t. It * is NOT intended for Case 2 (RDMA: long-term pins). @@ -2528,22 +2671,24 @@ long pin_user_pages_remote(struct task_struct *tsk,= struct mm_struct *mm, unsigned int gup_flags, struct page **pages, struct vm_area_struct **vmas, int *locked) { - /* - * This is a placeholder, until the pin functionality is activated. - * Until then, just behave like the corresponding get_user_pages*() - * routine. - */ - return get_user_pages_remote(tsk, mm, start, nr_pages, gup_flags, pages, - vmas, locked); + /* FOLL_GET and FOLL_PIN are mutually exclusive. */ + if (WARN_ON_ONCE(gup_flags & FOLL_GET)) + return -EINVAL; + + gup_flags |=3D FOLL_PIN; + return __get_user_pages_remote(tsk, mm, start, nr_pages, gup_flags, + pages, vmas, locked); } EXPORT_SYMBOL(pin_user_pages_remote); =20 /** * pin_user_pages() - pin user pages in memory for use by other devices * - * For now, this is a placeholder function, until various call sites are - * converted to use the correct get_user_pages*() or pin_user_pages*() API= . So, - * this is identical to get_user_pages(). + * Nearly the same as get_user_pages(), except that FOLL_TOUCH is not set,= and + * FOLL_PIN is set. + * + * FOLL_PIN means that the pages must be released via unpin_user_page(). P= lease + * see Documentation/vm/pin_user_pages.rst for details. * * This is intended for Case 1 (DIO) in Documentation/vm/pin_user_pages.rs= t. It * is NOT intended for Case 2 (RDMA: long-term pins). @@ -2552,11 +2697,12 @@ long pin_user_pages(unsigned long start, unsigned l= ong nr_pages, unsigned int gup_flags, struct page **pages, struct vm_area_struct **vmas) { - /* - * This is a placeholder, until the pin functionality is activated. - * Until then, just behave like the corresponding get_user_pages*() - * routine. - */ - return get_user_pages(start, nr_pages, gup_flags, pages, vmas); + /* FOLL_GET and FOLL_PIN are mutually exclusive. */ + if (WARN_ON_ONCE(gup_flags & FOLL_GET)) + return -EINVAL; + + gup_flags |=3D FOLL_PIN; + return __gup_longterm_locked(current, current->mm, start, nr_pages, + pages, vmas, gup_flags); } EXPORT_SYMBOL(pin_user_pages); diff --git a/mm/huge_memory.c b/mm/huge_memory.c index 13cc93785006..e94297799041 100644 --- a/mm/huge_memory.c +++ b/mm/huge_memory.c @@ -945,6 +945,11 @@ struct page *follow_devmap_pmd(struct vm_area_struct *= vma, unsigned long addr, */ WARN_ONCE(flags & FOLL_COW, "mm: In follow_devmap_pmd with FOLL_COW set")= ; =20 + /* FOLL_GET and FOLL_PIN are mutually exclusive. */ + if (WARN_ON_ONCE((flags & (FOLL_PIN | FOLL_GET)) =3D=3D + (FOLL_PIN | FOLL_GET))) + return NULL; + if (flags & FOLL_WRITE && !pmd_write(*pmd)) return NULL; =20 @@ -960,7 +965,7 @@ struct page *follow_devmap_pmd(struct vm_area_struct *v= ma, unsigned long addr, * device mapped pages can only be returned if the * caller will manage the page reference count. */ - if (!(flags & FOLL_GET)) + if (!(flags & (FOLL_GET | FOLL_PIN))) return ERR_PTR(-EEXIST); =20 pfn +=3D (addr & ~PMD_MASK) >> PAGE_SHIFT; @@ -968,7 +973,18 @@ struct page *follow_devmap_pmd(struct vm_area_struct *= vma, unsigned long addr, if (!*pgmap) return ERR_PTR(-EFAULT); page =3D pfn_to_page(pfn); - get_page(page); + + if (flags & FOLL_GET) + get_page(page); + else if (flags & FOLL_PIN) { + /* + * try_pin_page() is not actually expected to fail here because + * we hold the pmd lock so no one can unmap the pmd and free the + * page that it points to. + */ + if (unlikely(!try_pin_page(page))) + page =3D ERR_PTR(-EFAULT); + } =20 return page; } @@ -1088,6 +1104,11 @@ struct page *follow_devmap_pud(struct vm_area_struct= *vma, unsigned long addr, if (flags & FOLL_WRITE && !pud_write(*pud)) return NULL; =20 + /* FOLL_GET and FOLL_PIN are mutually exclusive. */ + if (WARN_ON_ONCE((flags & (FOLL_PIN | FOLL_GET)) =3D=3D + (FOLL_PIN | FOLL_GET))) + return NULL; + if (pud_present(*pud) && pud_devmap(*pud)) /* pass */; else @@ -1099,8 +1120,10 @@ struct page *follow_devmap_pud(struct vm_area_struct= *vma, unsigned long addr, /* * device mapped pages can only be returned if the * caller will manage the page reference count. + * + * At least one of FOLL_GET | FOLL_PIN must be set, so assert that here: */ - if (!(flags & FOLL_GET)) + if (!(flags & (FOLL_GET | FOLL_PIN))) return ERR_PTR(-EEXIST); =20 pfn +=3D (addr & ~PUD_MASK) >> PAGE_SHIFT; @@ -1108,7 +1131,18 @@ struct page *follow_devmap_pud(struct vm_area_struct= *vma, unsigned long addr, if (!*pgmap) return ERR_PTR(-EFAULT); page =3D pfn_to_page(pfn); - get_page(page); + + if (flags & FOLL_GET) + get_page(page); + else if (flags & FOLL_PIN) { + /* + * try_pin_page() is not actually expected to fail here because + * we hold the pud lock so no one can unmap the pud and free the + * page that it points to. + */ + if (unlikely(!try_pin_page(page))) + page =3D ERR_PTR(-EFAULT); + } =20 return page; } @@ -1522,8 +1556,20 @@ struct page *follow_trans_huge_pmd(struct vm_area_st= ruct *vma, skip_mlock: page +=3D (addr & ~HPAGE_PMD_MASK) >> PAGE_SHIFT; VM_BUG_ON_PAGE(!PageCompound(page) && !is_zone_device_page(page), page); + if (flags & FOLL_GET) get_page(page); + else if (flags & FOLL_PIN) { + /* + * try_pin_page() is not actually expected to fail here because + * we hold the pmd lock so no one can unmap the pmd and free the + * page that it points to. + */ + if (unlikely(!try_pin_page(page))) { + WARN_ON_ONCE(1); + page =3D NULL; + } + } =20 out: return page; diff --git a/mm/hugetlb.c b/mm/hugetlb.c index b45a95363a84..0abde7288127 100644 --- a/mm/hugetlb.c +++ b/mm/hugetlb.c @@ -4462,7 +4462,22 @@ long follow_hugetlb_page(struct mm_struct *mm, struc= t vm_area_struct *vma, same_page: if (pages) { pages[i] =3D mem_map_offset(page, pfn_offset); - get_page(pages[i]); + + if (flags & FOLL_GET) + get_page(pages[i]); + else if (flags & FOLL_PIN) { + /* + * try_pin_page() is not actually expected to + * fail here because we hold the ptl. + */ + if (unlikely(!try_pin_page(pages[i]))) { + spin_unlock(ptl); + remainder =3D 0; + err =3D -ENOMEM; + WARN_ON_ONCE(1); + break; + } + } } =20 if (vmas) @@ -5022,6 +5037,12 @@ follow_huge_pmd(struct mm_struct *mm, unsigned long = address, struct page *page =3D NULL; spinlock_t *ptl; pte_t pte; + + /* FOLL_GET and FOLL_PIN are mutually exclusive. */ + if (WARN_ON_ONCE((flags & (FOLL_PIN | FOLL_GET)) =3D=3D + (FOLL_PIN | FOLL_GET))) + return NULL; + retry: ptl =3D pmd_lockptr(mm, pmd); spin_lock(ptl); @@ -5034,8 +5055,20 @@ follow_huge_pmd(struct mm_struct *mm, unsigned long = address, pte =3D huge_ptep_get((pte_t *)pmd); if (pte_present(pte)) { page =3D pmd_page(*pmd) + ((address & ~PMD_MASK) >> PAGE_SHIFT); + if (flags & FOLL_GET) get_page(page); + else if (flags & FOLL_PIN) { + /* + * try_pin_page() is not actually expected to fail + * here because we hold the ptl. + */ + if (unlikely(!try_pin_page(page))) { + WARN_ON_ONCE(1); + page =3D NULL; + goto out; + } + } } else { if (is_hugetlb_entry_migration(pte)) { spin_unlock(ptl); @@ -5056,7 +5089,7 @@ struct page * __weak follow_huge_pud(struct mm_struct *mm, unsigned long address, pud_t *pud, int flags) { - if (flags & FOLL_GET) + if (flags & (FOLL_GET | FOLL_PIN)) return NULL; =20 return pte_page(*(pte_t *)pud) + ((address & ~PUD_MASK) >> PAGE_SHIFT); @@ -5065,7 +5098,7 @@ follow_huge_pud(struct mm_struct *mm, unsigned long a= ddress, struct page * __weak follow_huge_pgd(struct mm_struct *mm, unsigned long address, pgd_t *pgd, i= nt flags) { - if (flags & FOLL_GET) + if (flags & (FOLL_GET | FOLL_PIN)) return NULL; =20 return pte_page(*(pte_t *)pgd) + ((address & ~PGDIR_MASK) >> PAGE_SHIFT); diff --git a/mm/vmstat.c b/mm/vmstat.c index a8222041bd44..fdad40ccde7b 100644 --- a/mm/vmstat.c +++ b/mm/vmstat.c @@ -1167,6 +1167,8 @@ const char * const vmstat_text[] =3D { "nr_dirtied", "nr_written", "nr_kernel_misc_reclaimable", + "nr_foll_pin_requested", + "nr_foll_pin_returned", =20 /* enum writeback_stat_item counters */ "nr_dirty_threshold", --=20 2.24.0 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 4E8E5C33CB4 for ; Tue, 19 Nov 2019 08:17:42 +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 2B2CB22303 for ; Tue, 19 Nov 2019 08:17:42 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 2B2CB22303 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=nvidia.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 9765B6E1A2; Tue, 19 Nov 2019 08:17:32 +0000 (UTC) Received: from hqemgate15.nvidia.com (hqemgate15.nvidia.com [216.228.121.64]) by gabe.freedesktop.org (Postfix) with ESMTPS id C804D6ECA7 for ; Tue, 19 Nov 2019 08:17:07 +0000 (UTC) Received: from hqpgpgate101.nvidia.com (Not Verified[216.228.121.13]) by hqemgate15.nvidia.com (using TLS: TLSv1.2, DES-CBC3-SHA) id ; Tue, 19 Nov 2019 00:17:04 -0800 Received: from hqmail.nvidia.com ([172.20.161.6]) by hqpgpgate101.nvidia.com (PGP Universal service); Tue, 19 Nov 2019 00:17:07 -0800 X-PGP-Universal: processed; by hqpgpgate101.nvidia.com on Tue, 19 Nov 2019 00:17:07 -0800 Received: from HQMAIL101.nvidia.com (172.20.187.10) by HQMAIL101.nvidia.com (172.20.187.10) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Tue, 19 Nov 2019 08:17:06 +0000 Received: from rnnvemgw01.nvidia.com (10.128.109.123) by HQMAIL101.nvidia.com (172.20.187.10) with Microsoft SMTP Server (TLS) id 15.0.1473.3 via Frontend Transport; Tue, 19 Nov 2019 08:17:06 +0000 Received: from blueforge.nvidia.com (Not Verified[10.110.48.28]) by rnnvemgw01.nvidia.com with Trustwave SEG (v7, 5, 8, 10121) id ; Tue, 19 Nov 2019 00:17:05 -0800 From: John Hubbard To: Andrew Morton Subject: [PATCH v6 17/24] mm/gup: track FOLL_PIN pages Date: Tue, 19 Nov 2019 00:16:36 -0800 Message-ID: <20191119081643.1866232-18-jhubbard@nvidia.com> X-Mailer: git-send-email 2.24.0 In-Reply-To: <20191119081643.1866232-1-jhubbard@nvidia.com> References: <20191119081643.1866232-1-jhubbard@nvidia.com> MIME-Version: 1.0 X-NVConfidentiality: public X-Mailman-Original-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nvidia.com; s=n1; t=1574151424; bh=wtc4OGG1myCaQvSLfF2EwmSb+AVBg0MGEpAmtpgReDY=; h=X-PGP-Universal:From:To:CC:Subject:Date:Message-ID:X-Mailer: In-Reply-To:References:MIME-Version:X-NVConfidentiality: Content-Type:Content-Transfer-Encoding; b=SiHBSDIkS0ogQ8mztNa2tgrhWbCPG8ZOVzVzAGXQCxh5o9NFPHVtkNx4maNpjEg4X C4UTpt/o6GSaRU7SxjvlKfBG3/fWxBumTnowVgwbm2dedZPF52SeiZ0P7YSGkwmgNH etgElA2uIMF+rLtW70GWPAzsEVs5+Ym6uORxUeXtQaYUkQNBk3h++tmaT8UglO+iHT d5wEvk+0EksrgDw4q79RA+LYAN4K+OT2x2JaDjSF8897V6CmaT129FdV/kmM6OO/PC xq6PwX1MQgNT1xeejlDqwqSJ01xcuvM5Pkq6BBzmVTuAZx8K/oC2QefRCFVmJrGQFe JwGxlO9ykZA+g== X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Michal Hocko , Jan Kara , kvm@vger.kernel.org, linux-doc@vger.kernel.org, David Airlie , Dave Chinner , dri-devel@lists.freedesktop.org, LKML , linux-mm@kvack.org, Paul Mackerras , linux-kselftest@vger.kernel.org, Ira Weiny , Jonathan Corbet , linux-rdma@vger.kernel.org, Michael Ellerman , Christoph Hellwig , Jason Gunthorpe , Vlastimil Babka , =?UTF-8?q?Bj=C3=B6rn=20T=C3=B6pel?= , linux-media@vger.kernel.org, Shuah Khan , John Hubbard , linux-block@vger.kernel.org, =?UTF-8?q?J=C3=A9r=C3=B4me=20Glisse?= , Al Viro , Dan Williams , Mauro Carvalho Chehab , Magnus Karlsson , Jens Axboe , netdev@vger.kernel.org, Alex Williamson , linux-fsdevel@vger.kernel.org, bpf@vger.kernel.org, linuxppc-dev@lists.ozlabs.org, "David S . Miller" , Mike Kravetz Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Message-ID: <20191119081636.YuqVB0h5NTzKeSjR72MLUm7DsRYq8Ik3BS3ELisq__k@z> QWRkIHRyYWNraW5nIG9mIHBhZ2VzIHRoYXQgd2VyZSBwaW5uZWQgdmlhIEZPTExfUElOLgoKQXMg bWVudGlvbmVkIGluIHRoZSBGT0xMX1BJTiBkb2N1bWVudGF0aW9uLCBjYWxsZXJzIHdobyBlZmZl Y3RpdmVseSBzZXQKRk9MTF9QSU4gYXJlIHJlcXVpcmVkIHRvIHVsdGltYXRlbHkgZnJlZSBzdWNo IHBhZ2VzIHZpYSBwdXRfdXNlcl9wYWdlKCkuClRoZSBlZmZlY3QgaXMgc2ltaWxhciB0byBGT0xM X0dFVCwgYW5kIG1heSBiZSB0aG91Z2h0IG9mIGFzICJGT0xMX0dFVApmb3IgRElPIGFuZC9vciBS RE1BIHVzZSIuCgpQYWdlcyB0aGF0IGhhdmUgYmVlbiBwaW5uZWQgdmlhIEZPTExfUElOIGFyZSBp ZGVudGlmaWFibGUgdmlhIGEKbmV3IGZ1bmN0aW9uIGNhbGw6CgogICBib29sIHBhZ2VfZG1hX3Bp bm5lZChzdHJ1Y3QgcGFnZSAqcGFnZSk7CgpXaGF0IHRvIGRvIGluIHJlc3BvbnNlIHRvIGVuY291 bnRlcmluZyBzdWNoIGEgcGFnZSwgaXMgbGVmdCB0byBsYXRlcgpwYXRjaHNldHMuIFRoZXJlIGlz IGRpc2N1c3Npb24gYWJvdXQgdGhpcyBpbiBbMV0sIFsyXSwgYW5kIFszXS4KClRoaXMgYWxzbyBj aGFuZ2VzIGEgQlVHX09OKCksIHRvIGEgV0FSTl9PTigpLCBpbiBmb2xsb3dfcGFnZV9tYXNrKCku CgpbMV0gU29tZSBzbG93IHByb2dyZXNzIG9uIGdldF91c2VyX3BhZ2VzKCkgKEFwciAyLCAyMDE5 KToKICAgIGh0dHBzOi8vbHduLm5ldC9BcnRpY2xlcy83ODQ1NzQvClsyXSBETUEgYW5kIGdldF91 c2VyX3BhZ2VzKCkgKExQQzogRGVjIDEyLCAyMDE4KToKICAgIGh0dHBzOi8vbHduLm5ldC9BcnRp Y2xlcy83NzQ0MTEvClszXSBUaGUgdHJvdWJsZSB3aXRoIGdldF91c2VyX3BhZ2VzKCkgKEFwciAz MCwgMjAxOCk6CiAgICBodHRwczovL2x3bi5uZXQvQXJ0aWNsZXMvNzUzMDI3LwoKU3VnZ2VzdGVk LWJ5OiBKYW4gS2FyYSA8amFja0BzdXNlLmN6PgpTdWdnZXN0ZWQtYnk6IErDqXLDtG1lIEdsaXNz ZSA8amdsaXNzZUByZWRoYXQuY29tPgpTaWduZWQtb2ZmLWJ5OiBKb2huIEh1YmJhcmQgPGpodWJi YXJkQG52aWRpYS5jb20+Ci0tLQogRG9jdW1lbnRhdGlvbi9jb3JlLWFwaS9waW5fdXNlcl9wYWdl cy5yc3QgfCAgIDIgKy0KIGluY2x1ZGUvbGludXgvbW0uaCAgICAgICAgICAgICAgICAgICAgICAg IHwgIDg2ICsrKysrLS0KIGluY2x1ZGUvbGludXgvbW16b25lLmggICAgICAgICAgICAgICAgICAg IHwgICAyICsKIGluY2x1ZGUvbGludXgvcGFnZV9yZWYuaCAgICAgICAgICAgICAgICAgIHwgIDEw ICsKIG1tL2d1cC5jICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgMjkwICsrKysr KysrKysrKysrKystLS0tLS0KIG1tL2h1Z2VfbWVtb3J5LmMgICAgICAgICAgICAgICAgICAgICAg ICAgIHwgIDU0ICsrKy0KIG1tL2h1Z2V0bGIuYyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IHwgIDM5ICsrLQogbW0vdm1zdGF0LmMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAg IDIgKwogOCBmaWxlcyBjaGFuZ2VkLCAzOTAgaW5zZXJ0aW9ucygrKSwgOTUgZGVsZXRpb25zKC0p CgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9jb3JlLWFwaS9waW5fdXNlcl9wYWdlcy5yc3Qg Yi9Eb2N1bWVudGF0aW9uL2NvcmUtYXBpL3Bpbl91c2VyX3BhZ2VzLnJzdAppbmRleCA0ZjI2NjM3 YTUwMDUuLmJhYTI4OGE0NGE3NyAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9jb3JlLWFwaS9w aW5fdXNlcl9wYWdlcy5yc3QKKysrIGIvRG9jdW1lbnRhdGlvbi9jb3JlLWFwaS9waW5fdXNlcl9w YWdlcy5yc3QKQEAgLTUzLDcgKzUzLDcgQEAgV2hpY2ggZmxhZ3MgYXJlIHNldCBieSBlYWNoIHdy YXBwZXIKIEZvciB0aGVzZSBwaW5fdXNlcl9wYWdlcyooKSBmdW5jdGlvbnMsIEZPTExfUElOIGlz IE9SJ2QgaW4gd2l0aCB3aGF0ZXZlciBndXAKIGZsYWdzIHRoZSBjYWxsZXIgcHJvdmlkZXMuIFRo ZSBjYWxsZXIgaXMgcmVxdWlyZWQgdG8gcGFzcyBpbiBhIG5vbi1udWxsIHN0cnVjdAogcGFnZXMq IGFycmF5LCBhbmQgdGhlIGZ1bmN0aW9uIHRoZW4gcGluIHBhZ2VzIGJ5IGluY3JlbWVudGluZyBl YWNoIGJ5IGEgc3BlY2lhbAotdmFsdWUuIEZvciBub3csIHRoYXQgdmFsdWUgaXMgKzEsIGp1c3Qg bGlrZSBnZXRfdXNlcl9wYWdlcyooKS46OgordmFsdWU6IEdVUF9QSU5fQ09VTlRJTkdfQklBUy46 OgogCiAgRnVuY3Rpb24KICAtLS0tLS0tLQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tbS5o IGIvaW5jbHVkZS9saW51eC9tbS5oCmluZGV4IDU2OGNiYjg5NWYwMy4uYWIzMTFiMzU2YWIxIDEw MDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L21tLmgKKysrIGIvaW5jbHVkZS9saW51eC9tbS5oCkBA IC0xMDU0LDYgKzEwNTQsMjEgQEAgc3RhdGljIGlubGluZSBfX211c3RfY2hlY2sgYm9vbCB0cnlf Z2V0X3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UpCiAJcmV0dXJuIHRydWU7CiB9CiAKK19fbXVzdF9j aGVjayBib29sIHRyeV9waW5fY29tcG91bmRfaGVhZChzdHJ1Y3QgcGFnZSAqcGFnZSwgaW50IHJl ZnMpOworCisvKioKKyAqIHRyeV9waW5fcGFnZSgpIC0gbWFyayBhIHBhZ2UgYXMgYmVpbmcgdXNl ZCBieSBwaW5fdXNlcl9wYWdlcyooKS4KKyAqCisgKiBUaGlzIGlzIHRoZSBGT0xMX1BJTiBjb3Vu dGVycGFydCB0byB0cnlfZ2V0X3BhZ2UoKS4KKyAqCisgKiBAcGFnZToJcG9pbnRlciB0byBwYWdl IHRvIGJlIG1hcmtlZAorICogQFJldHVybjoJdHJ1ZSBmb3Igc3VjY2VzcywgZmFsc2UgZm9yIGZh aWx1cmUKKyAqLworc3RhdGljIGlubGluZSBfX211c3RfY2hlY2sgYm9vbCB0cnlfcGluX3BhZ2Uo c3RydWN0IHBhZ2UgKnBhZ2UpCit7CisJcmV0dXJuIHRyeV9waW5fY29tcG91bmRfaGVhZChwYWdl LCAxKTsKK30KKwogc3RhdGljIGlubGluZSB2b2lkIHB1dF9wYWdlKHN0cnVjdCBwYWdlICpwYWdl KQogewogCXBhZ2UgPSBjb21wb3VuZF9oZWFkKHBhZ2UpOwpAQCAtMTA3MSwyOSArMTA4Niw3MCBA QCBzdGF0aWMgaW5saW5lIHZvaWQgcHV0X3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UpCiAJCV9fcHV0 X3BhZ2UocGFnZSk7CiB9CiAKLS8qKgotICogcHV0X3VzZXJfcGFnZSgpIC0gcmVsZWFzZSBhIGd1 cC1waW5uZWQgcGFnZQotICogQHBhZ2U6ICAgICAgICAgICAgcG9pbnRlciB0byBwYWdlIHRvIGJl IHJlbGVhc2VkCisvKgorICogR1VQX1BJTl9DT1VOVElOR19CSUFTLCBhbmQgdGhlIGFzc29jaWF0 ZWQgZnVuY3Rpb25zIHRoYXQgdXNlIGl0LCBvdmVybG9hZAorICogdGhlIHBhZ2UncyByZWZjb3Vu dCBzbyB0aGF0IHR3byBzZXBhcmF0ZSBpdGVtcyBhcmUgdHJhY2tlZDogdGhlIG9yaWdpbmFsIHBh Z2UKKyAqIHJlZmVyZW5jZSBjb3VudCwgYW5kIGFsc28gYSBuZXcgY291bnQgb2YgaG93IG1hbnkg cGluX3VzZXJfcGFnZXMoKSBjYWxscyB3ZXJlCisgKiBtYWRlIGFnYWluc3QgdGhlIHBhZ2UuICgi Z3VwLXBpbm5lZCIgaXMgYW5vdGhlciB0ZXJtIGZvciB0aGUgbGF0dGVyKS4KKyAqCisgKiBXaXRo IHRoaXMgc2NoZW1lLCBwaW5fdXNlcl9wYWdlcygpIGJlY29tZXMgc3BlY2lhbDogc3VjaCBwYWdl cyBhcmUgbWFya2VkIGFzCisgKiBkaXN0aW5jdCBmcm9tIG5vcm1hbCBwYWdlcy4gQXMgc3VjaCwg dGhlIHB1dF91c2VyX3BhZ2UoKSBjYWxsIChhbmQgaXRzCisgKiB2YXJpYW50cykgbXVzdCBiZSB1 c2VkIGluIG9yZGVyIHRvIHJlbGVhc2UgZ3VwLXBpbm5lZCBwYWdlcy4KKyAqCisgKiBDaG9pY2Ug b2YgdmFsdWU6CisgKgorICogQnkgbWFraW5nIEdVUF9QSU5fQ09VTlRJTkdfQklBUyBhIHBvd2Vy IG9mIHR3bywgZGVidWdnaW5nIG9mIHBhZ2UgcmVmZXJlbmNlCisgKiBjb3VudHMgd2l0aCByZXNw ZWN0IHRvIHBpbl91c2VyX3BhZ2VzKCkgYW5kIHB1dF91c2VyX3BhZ2UoKSBiZWNvbWVzIHNpbXBs ZXIsCisgKiBkdWUgdG8gdGhlIGZhY3QgdGhhdCBhZGRpbmcgYW4gZXZlbiBwb3dlciBvZiB0d28g dG8gdGhlIHBhZ2UgcmVmY291bnQgaGFzIHRoZQorICogZWZmZWN0IG9mIHVzaW5nIG9ubHkgdGhl IHVwcGVyIE4gYml0cywgZm9yIHRoZSBjb2RlIHRoYXQgY291bnRzIHVwIHVzaW5nIHRoZQorICog YmlhcyB2YWx1ZS4gVGhpcyBtZWFucyB0aGF0IHRoZSBsb3dlciBiaXRzIGFyZSBsZWZ0IGZvciB0 aGUgZXhjbHVzaXZlIHVzZSBvZgorICogdGhlIG9yaWdpbmFsIGNvZGUgdGhhdCBpbmNyZW1lbnRz IGFuZCBkZWNyZW1lbnRzIGJ5IG9uZSAob3IgYXQgbGVhc3QsIGJ5IG11Y2gKKyAqIHNtYWxsZXIg dmFsdWVzIHRoYW4gdGhlIGJpYXMgdmFsdWUpLgogICoKLSAqIFBhZ2VzIHRoYXQgd2VyZSBwaW5u ZWQgdmlhIHBpbl91c2VyX3BhZ2VzKigpIG11c3QgYmUgcmVsZWFzZWQgdmlhIGVpdGhlcgotICog cHV0X3VzZXJfcGFnZSgpLCBvciBvbmUgb2YgdGhlIHB1dF91c2VyX3BhZ2VzKigpIHJvdXRpbmVz LiBUaGlzIGlzIHNvIHRoYXQKLSAqIGV2ZW50dWFsbHkgc3VjaCBwYWdlcyBjYW4gYmUgc2VwYXJh dGVseSB0cmFja2VkIGFuZCB1bmlxdWVseSBoYW5kbGVkLiBJbgotICogcGFydGljdWxhciwgaW50 ZXJhY3Rpb25zIHdpdGggUkRNQSBhbmQgZmlsZXN5c3RlbXMgbmVlZCBzcGVjaWFsIGhhbmRsaW5n LgorICogT2YgY291cnNlLCBvbmNlIHRoZSBsb3dlciBiaXRzIG92ZXJmbG93IGludG8gdGhlIHVw cGVyIGJpdHMgKGFuZCB0aGlzIGlzCisgKiBPSywgYmVjYXVzZSBzdWJ0cmFjdGlvbiByZWNvdmVy cyB0aGUgb3JpZ2luYWwgdmFsdWVzKSwgdGhlbiB2aXN1YWwgaW5zcGVjdGlvbgorICogbm8gbG9u Z2VyIHN1ZmZpY2VzIHRvIGRpcmVjdGx5IHZpZXcgdGhlIHNlcGFyYXRlIGNvdW50cy4gSG93ZXZl ciwgZm9yIG5vcm1hbAorICogYXBwbGljYXRpb25zIHRoYXQgZG9uJ3QgaGF2ZSBodWdlIHBhZ2Ug cmVmZXJlbmNlIGNvdW50cywgdGhpcyB3b24ndCBiZSBhbgorICogaXNzdWUuCiAgKgotICogcHV0 X3VzZXJfcGFnZSgpIGFuZCBwdXRfcGFnZSgpIGFyZSBub3QgaW50ZXJjaGFuZ2VhYmxlLCBkZXNw aXRlIHRoaXMgZWFybHkKLSAqIGltcGxlbWVudGF0aW9uIHRoYXQgbWFrZXMgdGhlbSBsb29rIHRo ZSBzYW1lLiBwdXRfdXNlcl9wYWdlKCkgY2FsbHMgbXVzdAotICogYmUgcGVyZmVjdGx5IG1hdGNo ZWQgdXAgd2l0aCBwaW4qKCkgY2FsbHMuCisgKiBMb2NraW5nOiB0aGUgbG9ja2xlc3MgYWxnb3Jp dGhtIGRlc2NyaWJlZCBpbiBwYWdlX2NhY2hlX2dldF9zcGVjdWxhdGl2ZSgpCisgKiBhbmQgcGFn ZV9jYWNoZV9ndXBfcGluX3NwZWN1bGF0aXZlKCkgcHJvdmlkZXMgc2FmZSBvcGVyYXRpb24gZm9y CisgKiBnZXRfdXNlcl9wYWdlcyBhbmQgcGFnZV9ta2NsZWFuIGFuZCBvdGhlciBjYWxscyB0aGF0 IHJhY2UgdG8gc2V0IHVwIHBhZ2UKKyAqIHRhYmxlIGVudHJpZXMuCiAgKi8KLXN0YXRpYyBpbmxp bmUgdm9pZCBwdXRfdXNlcl9wYWdlKHN0cnVjdCBwYWdlICpwYWdlKQotewotCXB1dF9wYWdlKHBh Z2UpOwotfQorI2RlZmluZSBHVVBfUElOX0NPVU5USU5HX0JJQVMgKDFVTCA8PCAxMCkKIAordm9p ZCBwdXRfdXNlcl9wYWdlKHN0cnVjdCBwYWdlICpwYWdlKTsKIHZvaWQgcHV0X3VzZXJfcGFnZXNf ZGlydHlfbG9jayhzdHJ1Y3QgcGFnZSAqKnBhZ2VzLCB1bnNpZ25lZCBsb25nIG5wYWdlcywKIAkJ CSAgICAgICBib29sIG1ha2VfZGlydHkpOwotCiB2b2lkIHB1dF91c2VyX3BhZ2VzKHN0cnVjdCBw YWdlICoqcGFnZXMsIHVuc2lnbmVkIGxvbmcgbnBhZ2VzKTsKIAorLyoqCisgKiBwYWdlX2RtYV9w aW5uZWQoKSAtIHJlcG9ydCBpZiBhIHBhZ2UgaXMgcGlubmVkIGZvciBETUEuCisgKgorICogVGhp cyBmdW5jdGlvbiBjaGVja3MgaWYgYSBwYWdlIGhhcyBiZWVuIHBpbm5lZCB2aWEgYSBjYWxsIHRv CisgKiBwaW5fdXNlcl9wYWdlcyooKS4KKyAqCisgKiBUaGUgcmV0dXJuIHZhbHVlIGlzIHBhcnRp YWxseSBmdXp6eTogZmFsc2UgaXMgbm90IGZ1enp5LCBiZWNhdXNlIGl0IG1lYW5zCisgKiAiZGVm aW5pdGVseSBub3QgcGlubmVkIGZvciBETUEiLCBidXQgdHJ1ZSBtZWFucyAicHJvYmFibHkgcGlu bmVkIGZvciBETUEsIGJ1dAorICogcG9zc2libHkgYSBmYWxzZSBwb3NpdGl2ZSBkdWUgdG8gaGF2 aW5nIGF0IGxlYXN0IEdVUF9QSU5fQ09VTlRJTkdfQklBUyB3b3J0aAorICogb2Ygbm9ybWFsIHBh Z2UgcmVmZXJlbmNlcyIuCisgKgorICogRmFsc2UgcG9zaXRpdmVzIGFyZSBPSywgYmVjYXVzZTog YSkgaXQncyB1bmxpa2VseSBmb3IgYSBwYWdlIHRvIGdldCB0aGF0IG1hbnkKKyAqIHJlZmNvdW50 cywgYW5kIGIpIGFsbCB0aGUgY2FsbGVycyBvZiB0aGlzIHJvdXRpbmUgYXJlIGV4cGVjdGVkIHRv IGJlIGFibGUgdG8KKyAqIGRlYWwgZ3JhY2VmdWxseSB3aXRoIGEgZmFsc2UgcG9zaXRpdmUuCisg KgorICogRm9yIG1vcmUgaW5mb3JtYXRpb24sIHBsZWFzZSBzZWUgRG9jdW1lbnRhdGlvbi92bS9w aW5fdXNlcl9wYWdlcy5yc3QuCisgKgorICogQHBhZ2U6CXBvaW50ZXIgdG8gcGFnZSB0byBiZSBx dWVyaWVkLgorICogQFJldHVybjoJVHJ1ZSwgaWYgaXQgaXMgbGlrZWx5IHRoYXQgdGhlIHBhZ2Ug aGFzIGJlZW4gImRtYS1waW5uZWQiLgorICoJCUZhbHNlLCBpZiB0aGUgcGFnZSBpcyBkZWZpbml0 ZWx5IG5vdCBkbWEtcGlubmVkLgorICovCitzdGF0aWMgaW5saW5lIGJvb2wgcGFnZV9kbWFfcGlu bmVkKHN0cnVjdCBwYWdlICpwYWdlKQoreworCXJldHVybiAocGFnZV9yZWZfY291bnQoY29tcG91 bmRfaGVhZChwYWdlKSkpID49IEdVUF9QSU5fQ09VTlRJTkdfQklBUzsKK30KKwogI2lmIGRlZmlu ZWQoQ09ORklHX1NQQVJTRU1FTSkgJiYgIWRlZmluZWQoQ09ORklHX1NQQVJTRU1FTV9WTUVNTUFQ KQogI2RlZmluZSBTRUNUSU9OX0lOX1BBR0VfRkxBR1MKICNlbmRpZgpkaWZmIC0tZ2l0IGEvaW5j bHVkZS9saW51eC9tbXpvbmUuaCBiL2luY2x1ZGUvbGludXgvbW16b25lLmgKaW5kZXggYmRhMjAy ODI3NDZiLi4wNDg1Y2JhMzhkMjMgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbW16b25lLmgK KysrIGIvaW5jbHVkZS9saW51eC9tbXpvbmUuaApAQCAtMjQ0LDYgKzI0NCw4IEBAIGVudW0gbm9k ZV9zdGF0X2l0ZW0gewogCU5SX0RJUlRJRUQsCQkvKiBwYWdlIGRpcnR5aW5ncyBzaW5jZSBib290 dXAgKi8KIAlOUl9XUklUVEVOLAkJLyogcGFnZSB3cml0aW5ncyBzaW5jZSBib290dXAgKi8KIAlO Ul9LRVJORUxfTUlTQ19SRUNMQUlNQUJMRSwJLyogcmVjbGFpbWFibGUgbm9uLXNsYWIga2VybmVs IHBhZ2VzICovCisJTlJfRk9MTF9QSU5fUkVRVUVTVEVELAkvKiB2aWE6IHBpbl91c2VyX3BhZ2Uo KSwgZ3VwIGZsYWc6IEZPTExfUElOICovCisJTlJfRk9MTF9QSU5fUkVUVVJORUQsCS8qIHBhZ2Vz IHJldHVybmVkIHZpYSBwdXRfdXNlcl9wYWdlKCkgKi8KIAlOUl9WTV9OT0RFX1NUQVRfSVRFTVMK IH07CiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcGFnZV9yZWYuaCBiL2luY2x1ZGUvbGlu dXgvcGFnZV9yZWYuaAppbmRleCAxNGQxNGJlYjFmN2YuLmI5Y2JlNTUzZDFlNyAxMDA2NDQKLS0t IGEvaW5jbHVkZS9saW51eC9wYWdlX3JlZi5oCisrKyBiL2luY2x1ZGUvbGludXgvcGFnZV9yZWYu aApAQCAtMTAyLDYgKzEwMiwxNiBAQCBzdGF0aWMgaW5saW5lIHZvaWQgcGFnZV9yZWZfc3ViKHN0 cnVjdCBwYWdlICpwYWdlLCBpbnQgbnIpCiAJCV9fcGFnZV9yZWZfbW9kKHBhZ2UsIC1ucik7CiB9 CiAKK3N0YXRpYyBpbmxpbmUgaW50IHBhZ2VfcmVmX3N1Yl9yZXR1cm4oc3RydWN0IHBhZ2UgKnBh Z2UsIGludCBucikKK3sKKwlpbnQgcmV0ID0gYXRvbWljX3N1Yl9yZXR1cm4obnIsICZwYWdlLT5f cmVmY291bnQpOworCisJaWYgKHBhZ2VfcmVmX3RyYWNlcG9pbnRfYWN0aXZlKF9fdHJhY2Vwb2lu dF9wYWdlX3JlZl9tb2QpKQorCQlfX3BhZ2VfcmVmX21vZChwYWdlLCAtbnIpOworCisJcmV0dXJu IHJldDsKK30KKwogc3RhdGljIGlubGluZSB2b2lkIHBhZ2VfcmVmX2luYyhzdHJ1Y3QgcGFnZSAq cGFnZSkKIHsKIAlhdG9taWNfaW5jKCZwYWdlLT5fcmVmY291bnQpOwpkaWZmIC0tZ2l0IGEvbW0v Z3VwLmMgYi9tbS9ndXAuYwppbmRleCBmNzJkN2ExNjM1YjQuLjAwMjgxNjUyNjY3MCAxMDA2NDQK LS0tIGEvbW0vZ3VwLmMKKysrIGIvbW0vZ3VwLmMKQEAgLTUxLDYgKzUxLDk2IEBAIHN0YXRpYyBp bmxpbmUgc3RydWN0IHBhZ2UgKnRyeV9nZXRfY29tcG91bmRfaGVhZChzdHJ1Y3QgcGFnZSAqcGFn ZSwgaW50IHJlZnMpCiAJcmV0dXJuIGhlYWQ7CiB9CiAKKyNpZmRlZiBDT05GSUdfREVCVUdfVk0K K3N0YXRpYyBpbmxpbmUgdm9pZCBfX3VwZGF0ZV9wcm9jX3Ztc3RhdChzdHJ1Y3QgcGFnZSAqcGFn ZSwKKwkJCQkJZW51bSBub2RlX3N0YXRfaXRlbSBpdGVtLCBpbnQgY291bnQpCit7CisJbW9kX25v ZGVfcGFnZV9zdGF0ZShwYWdlX3BnZGF0KHBhZ2UpLCBpdGVtLCBjb3VudCk7Cit9CisjZWxzZQor c3RhdGljIGlubGluZSB2b2lkIF9fdXBkYXRlX3Byb2Nfdm1zdGF0KHN0cnVjdCBwYWdlICpwYWdl LAorCQkJCQllbnVtIG5vZGVfc3RhdF9pdGVtIGl0ZW0sIGludCBjb3VudCkKK3sKK30KKyNlbmRp ZgorCisvKioKKyAqIHRyeV9waW5fY29tcG91bmRfaGVhZCgpIC0gbWFyayBhIGNvbXBvdW5kIHBh Z2UgYXMgYmVpbmcgdXNlZCBieQorICogcGluX3VzZXJfcGFnZXMqKCkuCisgKgorICogVGhpcyBp cyB0aGUgRk9MTF9QSU4gY291bnRlcnBhcnQgdG8gdHJ5X2dldF9jb21wb3VuZF9oZWFkKCkuCisg KgorICogQHBhZ2U6CXBvaW50ZXIgdG8gcGFnZSB0byBiZSBtYXJrZWQKKyAqIEBSZXR1cm46CXRy dWUgZm9yIHN1Y2Nlc3MsIGZhbHNlIGZvciBmYWlsdXJlCisgKi8KK19fbXVzdF9jaGVjayBib29s IHRyeV9waW5fY29tcG91bmRfaGVhZChzdHJ1Y3QgcGFnZSAqcGFnZSwgaW50IHJlZnMpCit7CisJ cGFnZSA9IHRyeV9nZXRfY29tcG91bmRfaGVhZChwYWdlLCBHVVBfUElOX0NPVU5USU5HX0JJQVMg KiByZWZzKTsKKwlpZiAoIXBhZ2UpCisJCXJldHVybiBmYWxzZTsKKworCV9fdXBkYXRlX3Byb2Nf dm1zdGF0KHBhZ2UsIE5SX0ZPTExfUElOX1JFUVVFU1RFRCwgcmVmcyk7CisJcmV0dXJuIHRydWU7 Cit9CisKKyNpZmRlZiBDT05GSUdfREVWX1BBR0VNQVBfT1BTCitzdGF0aWMgYm9vbCBfX3B1dF9k ZXZtYXBfbWFuYWdlZF91c2VyX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UpCit7CisJYm9vbCBpc19k ZXZtYXAgPSBwYWdlX2lzX2Rldm1hcF9tYW5hZ2VkKHBhZ2UpOworCisJaWYgKGlzX2Rldm1hcCkg eworCQlpbnQgY291bnQgPSBwYWdlX3JlZl9zdWJfcmV0dXJuKHBhZ2UsIEdVUF9QSU5fQ09VTlRJ TkdfQklBUyk7CisKKwkJX191cGRhdGVfcHJvY192bXN0YXQocGFnZSwgTlJfRk9MTF9QSU5fUkVU VVJORUQsIDEpOworCQkvKgorCQkgKiBkZXZtYXAgcGFnZSByZWZjb3VudHMgYXJlIDEtYmFzZWQs IHJhdGhlciB0aGFuIDAtYmFzZWQ6IGlmCisJCSAqIHJlZmNvdW50IGlzIDEsIHRoZW4gdGhlIHBh Z2UgaXMgZnJlZSBhbmQgdGhlIHJlZmNvdW50IGlzCisJCSAqIHN0YWJsZSBiZWNhdXNlIG5vYm9k eSBob2xkcyBhIHJlZmVyZW5jZSBvbiB0aGUgcGFnZS4KKwkJICovCisJCWlmIChjb3VudCA9PSAx KQorCQkJZnJlZV9kZXZtYXBfbWFuYWdlZF9wYWdlKHBhZ2UpOworCQllbHNlIGlmICghY291bnQp CisJCQlfX3B1dF9wYWdlKHBhZ2UpOworCX0KKworCXJldHVybiBpc19kZXZtYXA7Cit9CisjZWxz ZQorc3RhdGljIGJvb2wgX19wdXRfZGV2bWFwX21hbmFnZWRfdXNlcl9wYWdlKHN0cnVjdCBwYWdl ICpwYWdlKQoreworCXJldHVybiBmYWxzZTsKK30KKyNlbmRpZiAvKiBDT05GSUdfREVWX1BBR0VN QVBfT1BTICovCisKKy8qKgorICogcHV0X3VzZXJfcGFnZSgpIC0gcmVsZWFzZSBhIGRtYS1waW5u ZWQgcGFnZQorICogQHBhZ2U6ICAgICAgICAgICAgcG9pbnRlciB0byBwYWdlIHRvIGJlIHJlbGVh c2VkCisgKgorICogUGFnZXMgdGhhdCB3ZXJlIHBpbm5lZCB2aWEgcGluX3VzZXJfcGFnZXMqKCkg bXVzdCBiZSByZWxlYXNlZCB2aWEgZWl0aGVyCisgKiBwdXRfdXNlcl9wYWdlKCksIG9yIG9uZSBv ZiB0aGUgcHV0X3VzZXJfcGFnZXMqKCkgcm91dGluZXMuIFRoaXMgaXMgc28gdGhhdAorICogc3Vj aCBwYWdlcyBjYW4gYmUgc2VwYXJhdGVseSB0cmFja2VkIGFuZCB1bmlxdWVseSBoYW5kbGVkLiBJ biBwYXJ0aWN1bGFyLAorICogaW50ZXJhY3Rpb25zIHdpdGggUkRNQSBhbmQgZmlsZXN5c3RlbXMg bmVlZCBzcGVjaWFsIGhhbmRsaW5nLgorICovCit2b2lkIHB1dF91c2VyX3BhZ2Uoc3RydWN0IHBh Z2UgKnBhZ2UpCit7CisJcGFnZSA9IGNvbXBvdW5kX2hlYWQocGFnZSk7CisKKwkvKgorCSAqIEZv ciBkZXZtYXAgbWFuYWdlZCBwYWdlcyB3ZSBuZWVkIHRvIGNhdGNoIHJlZmNvdW50IHRyYW5zaXRp b24gZnJvbQorCSAqIEdVUF9QSU5fQ09VTlRJTkdfQklBUyB0byAxLCB3aGVuIHJlZmNvdW50IHJl YWNoIG9uZSBpdCBtZWFucyB0aGUKKwkgKiBwYWdlIGlzIGZyZWUgYW5kIHdlIG5lZWQgdG8gaW5m b3JtIHRoZSBkZXZpY2UgZHJpdmVyIHRocm91Z2gKKwkgKiBjYWxsYmFjay4gU2VlIGluY2x1ZGUv bGludXgvbWVtcmVtYXAuaCBhbmQgSE1NIGZvciBkZXRhaWxzLgorCSAqLworCWlmIChfX3B1dF9k ZXZtYXBfbWFuYWdlZF91c2VyX3BhZ2UocGFnZSkpCisJCXJldHVybjsKKworCWlmIChwYWdlX3Jl Zl9zdWJfYW5kX3Rlc3QocGFnZSwgR1VQX1BJTl9DT1VOVElOR19CSUFTKSkKKwkJX19wdXRfcGFn ZShwYWdlKTsKKworCV9fdXBkYXRlX3Byb2Nfdm1zdGF0KHBhZ2UsIE5SX0ZPTExfUElOX1JFVFVS TkVELCAxKTsKK30KK0VYUE9SVF9TWU1CT0wocHV0X3VzZXJfcGFnZSk7CisKIC8qKgogICogcHV0 X3VzZXJfcGFnZXNfZGlydHlfbG9jaygpIC0gcmVsZWFzZSBhbmQgb3B0aW9uYWxseSBkaXJ0eSBn dXAtcGlubmVkIHBhZ2VzCiAgKiBAcGFnZXM6ICBhcnJheSBvZiBwYWdlcyB0byBiZSBtYXliZSBt YXJrZWQgZGlydHksIGFuZCBkZWZpbml0ZWx5IHJlbGVhc2VkLgpAQCAtMjM3LDEwICszMjcsMTEg QEAgc3RhdGljIHN0cnVjdCBwYWdlICpmb2xsb3dfcGFnZV9wdGUoc3RydWN0IHZtX2FyZWFfc3Ry dWN0ICp2bWEsCiAJfQogCiAJcGFnZSA9IHZtX25vcm1hbF9wYWdlKHZtYSwgYWRkcmVzcywgcHRl KTsKLQlpZiAoIXBhZ2UgJiYgcHRlX2Rldm1hcChwdGUpICYmIChmbGFncyAmIEZPTExfR0VUKSkg eworCWlmICghcGFnZSAmJiBwdGVfZGV2bWFwKHB0ZSkgJiYgKGZsYWdzICYgKEZPTExfR0VUIHwg Rk9MTF9QSU4pKSkgewogCQkvKgotCQkgKiBPbmx5IHJldHVybiBkZXZpY2UgbWFwcGluZyBwYWdl cyBpbiB0aGUgRk9MTF9HRVQgY2FzZSBzaW5jZQotCQkgKiB0aGV5IGFyZSBvbmx5IHZhbGlkIHdo aWxlIGhvbGRpbmcgdGhlIHBnbWFwIHJlZmVyZW5jZS4KKwkJICogT25seSByZXR1cm4gZGV2aWNl IG1hcHBpbmcgcGFnZXMgaW4gdGhlIEZPTExfR0VUIG9yIEZPTExfUElOCisJCSAqIGNhc2Ugc2lu Y2UgdGhleSBhcmUgb25seSB2YWxpZCB3aGlsZSBob2xkaW5nIHRoZSBwZ21hcAorCQkgKiByZWZl cmVuY2UuCiAJCSAqLwogCQkqcGdtYXAgPSBnZXRfZGV2X3BhZ2VtYXAocHRlX3BmbihwdGUpLCAq cGdtYXApOwogCQlpZiAoKnBnbWFwKQpAQCAtMjgzLDYgKzM3NCwxMSBAQCBzdGF0aWMgc3RydWN0 IHBhZ2UgKmZvbGxvd19wYWdlX3B0ZShzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKIAkJCXBh Z2UgPSBFUlJfUFRSKC1FTk9NRU0pOwogCQkJZ290byBvdXQ7CiAJCX0KKwl9IGVsc2UgaWYgKGZs YWdzICYgRk9MTF9QSU4pIHsKKwkJaWYgKHVubGlrZWx5KCF0cnlfcGluX3BhZ2UocGFnZSkpKSB7 CisJCQlwYWdlID0gRVJSX1BUUigtRU5PTUVNKTsKKwkJCWdvdG8gb3V0OworCQl9CiAJfQogCWlm IChmbGFncyAmIEZPTExfVE9VQ0gpIHsKIAkJaWYgKChmbGFncyAmIEZPTExfV1JJVEUpICYmCkBA IC01NDQsOCArNjQwLDggQEAgc3RhdGljIHN0cnVjdCBwYWdlICpmb2xsb3dfcGFnZV9tYXNrKHN0 cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAogCS8qIG1ha2UgdGhpcyBoYW5kbGUgaHVnZXBkICov CiAJcGFnZSA9IGZvbGxvd19odWdlX2FkZHIobW0sIGFkZHJlc3MsIGZsYWdzICYgRk9MTF9XUklU RSk7CiAJaWYgKCFJU19FUlIocGFnZSkpIHsKLQkJQlVHX09OKGZsYWdzICYgRk9MTF9HRVQpOwot CQlyZXR1cm4gcGFnZTsKKwkJV0FSTl9PTl9PTkNFKGZsYWdzICYgKEZPTExfR0VUIHwgRk9MTF9Q SU4pKTsKKwkJcmV0dXJuIE5VTEw7CiAJfQogCiAJcGdkID0gcGdkX29mZnNldChtbSwgYWRkcmVz cyk7CkBAIC0xMTI1LDYgKzEyMjEsMzYgQEAgc3RhdGljIF9fYWx3YXlzX2lubGluZSBsb25nIF9f Z2V0X3VzZXJfcGFnZXNfbG9ja2VkKHN0cnVjdCB0YXNrX3N0cnVjdCAqdHNrLAogCXJldHVybiBw YWdlc19kb25lOwogfQogCitzdGF0aWMgbG9uZyBfX2dldF91c2VyX3BhZ2VzX3JlbW90ZShzdHJ1 Y3QgdGFza19zdHJ1Y3QgKnRzaywKKwkJCQkgICAgc3RydWN0IG1tX3N0cnVjdCAqbW0sCisJCQkJ ICAgIHVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxvbmcgbnJfcGFnZXMsCisJCQkJICAg IHVuc2lnbmVkIGludCBndXBfZmxhZ3MsIHN0cnVjdCBwYWdlICoqcGFnZXMsCisJCQkJICAgIHN0 cnVjdCB2bV9hcmVhX3N0cnVjdCAqKnZtYXMsIGludCAqbG9ja2VkKQoreworCS8qCisJICogUGFy dHMgb2YgRk9MTF9MT05HVEVSTSBiZWhhdmlvciBhcmUgaW5jb21wYXRpYmxlIHdpdGgKKwkgKiBG QVVMVF9GTEFHX0FMTE9XX1JFVFJZIGJlY2F1c2Ugb2YgdGhlIEZTIERBWCBjaGVjayByZXF1aXJl bWVudCBvbgorCSAqIHZtYXMuIEhvd2V2ZXIsIHRoaXMgb25seSBjb21lcyB1cCBpZiBsb2NrZWQg aXMgc2V0LCBhbmQgdGhlcmUgYXJlCisJICogY2FsbGVycyB0aGF0IGRvIHJlcXVlc3QgRk9MTF9M T05HVEVSTSwgYnV0IGRvIG5vdCBzZXQgbG9ja2VkLiBTbywKKwkgKiBhbGxvdyB3aGF0IHdlIGNh bi4KKwkgKi8KKwlpZiAoZ3VwX2ZsYWdzICYgRk9MTF9MT05HVEVSTSkgeworCQlpZiAoV0FSTl9P Tl9PTkNFKGxvY2tlZCkpCisJCQlyZXR1cm4gLUVJTlZBTDsKKwkJLyoKKwkJICogVGhpcyB3aWxs IGNoZWNrIHRoZSB2bWFzIChldmVuIGlmIG91ciB2bWFzIGFyZyBpcyBOVUxMKQorCQkgKiBhbmQg cmV0dXJuIC1FTk9UU1VQUCBpZiBEQVggaXNuJ3QgYWxsb3dlZCBpbiB0aGlzIGNhc2U6CisJCSAq LworCQlyZXR1cm4gX19ndXBfbG9uZ3Rlcm1fbG9ja2VkKHRzaywgbW0sIHN0YXJ0LCBucl9wYWdl cywgcGFnZXMsCisJCQkJCSAgICAgdm1hcywgZ3VwX2ZsYWdzIHwgRk9MTF9UT1VDSCB8CisJCQkJ CSAgICAgRk9MTF9SRU1PVEUpOworCX0KKworCXJldHVybiBfX2dldF91c2VyX3BhZ2VzX2xvY2tl ZCh0c2ssIG1tLCBzdGFydCwgbnJfcGFnZXMsIHBhZ2VzLCB2bWFzLAorCQkJCSAgICAgICBsb2Nr ZWQsCisJCQkJICAgICAgIGd1cF9mbGFncyB8IEZPTExfVE9VQ0ggfCBGT0xMX1JFTU9URSk7Cit9 CisKIC8qCiAgKiBnZXRfdXNlcl9wYWdlc19yZW1vdGUoKSAtIHBpbiB1c2VyIHBhZ2VzIGluIG1l bW9yeQogICogQHRzazoJdGhlIHRhc2tfc3RydWN0IHRvIHVzZSBmb3IgcGFnZSBmYXVsdCBhY2Nv dW50aW5nLCBvcgpAQCAtMTE5MywyOCArMTMxOSw4IEBAIGxvbmcgZ2V0X3VzZXJfcGFnZXNfcmVt b3RlKHN0cnVjdCB0YXNrX3N0cnVjdCAqdHNrLCBzdHJ1Y3QgbW1fc3RydWN0ICptbSwKIAlpZiAo V0FSTl9PTl9PTkNFKGd1cF9mbGFncyAmIEZPTExfUElOKSkKIAkJcmV0dXJuIC1FSU5WQUw7CiAK LQkvKgotCSAqIFBhcnRzIG9mIEZPTExfTE9OR1RFUk0gYmVoYXZpb3IgYXJlIGluY29tcGF0aWJs ZSB3aXRoCi0JICogRkFVTFRfRkxBR19BTExPV19SRVRSWSBiZWNhdXNlIG9mIHRoZSBGUyBEQVgg Y2hlY2sgcmVxdWlyZW1lbnQgb24KLQkgKiB2bWFzLiBIb3dldmVyLCB0aGlzIG9ubHkgY29tZXMg dXAgaWYgbG9ja2VkIGlzIHNldCwgYW5kIHRoZXJlIGFyZQotCSAqIGNhbGxlcnMgdGhhdCBkbyBy ZXF1ZXN0IEZPTExfTE9OR1RFUk0sIGJ1dCBkbyBub3Qgc2V0IGxvY2tlZC4gU28sCi0JICogYWxs b3cgd2hhdCB3ZSBjYW4uCi0JICovCi0JaWYgKGd1cF9mbGFncyAmIEZPTExfTE9OR1RFUk0pIHsK LQkJaWYgKFdBUk5fT05fT05DRShsb2NrZWQpKQotCQkJcmV0dXJuIC1FSU5WQUw7Ci0JCS8qCi0J CSAqIFRoaXMgd2lsbCBjaGVjayB0aGUgdm1hcyAoZXZlbiBpZiBvdXIgdm1hcyBhcmcgaXMgTlVM TCkKLQkJICogYW5kIHJldHVybiAtRU5PVFNVUFAgaWYgREFYIGlzbid0IGFsbG93ZWQgaW4gdGhp cyBjYXNlOgotCQkgKi8KLQkJcmV0dXJuIF9fZ3VwX2xvbmd0ZXJtX2xvY2tlZCh0c2ssIG1tLCBz dGFydCwgbnJfcGFnZXMsIHBhZ2VzLAotCQkJCQkgICAgIHZtYXMsIGd1cF9mbGFncyB8IEZPTExf VE9VQ0ggfAotCQkJCQkgICAgIEZPTExfUkVNT1RFKTsKLQl9Ci0KLQlyZXR1cm4gX19nZXRfdXNl cl9wYWdlc19sb2NrZWQodHNrLCBtbSwgc3RhcnQsIG5yX3BhZ2VzLCBwYWdlcywgdm1hcywKLQkJ CQkgICAgICAgbG9ja2VkLAotCQkJCSAgICAgICBndXBfZmxhZ3MgfCBGT0xMX1RPVUNIIHwgRk9M TF9SRU1PVEUpOworCXJldHVybiBfX2dldF91c2VyX3BhZ2VzX3JlbW90ZSh0c2ssIG1tLCBzdGFy dCwgbnJfcGFnZXMsIGd1cF9mbGFncywKKwkJCQkgICAgICAgcGFnZXMsIHZtYXMsIGxvY2tlZCk7 CiB9CiBFWFBPUlRfU1lNQk9MKGdldF91c2VyX3BhZ2VzX3JlbW90ZSk7CiAKQEAgLTE4NDIsMTMg KzE5NDgsMTcgQEAgc3RhdGljIGlubGluZSBwdGVfdCBndXBfZ2V0X3B0ZShwdGVfdCAqcHRlcCkK ICNlbmRpZiAvKiBDT05GSUdfR1VQX0dFVF9QVEVfTE9XX0hJR0ggKi8KIAogc3RhdGljIHZvaWQg X19tYXliZV91bnVzZWQgdW5kb19kZXZfcGFnZW1hcChpbnQgKm5yLCBpbnQgbnJfc3RhcnQsCisJ CQkJCSAgICB1bnNpZ25lZCBpbnQgZmxhZ3MsCiAJCQkJCSAgICBzdHJ1Y3QgcGFnZSAqKnBhZ2Vz KQogewogCXdoaWxlICgoKm5yKSAtIG5yX3N0YXJ0KSB7CiAJCXN0cnVjdCBwYWdlICpwYWdlID0g cGFnZXNbLS0oKm5yKV07CiAKIAkJQ2xlYXJQYWdlUmVmZXJlbmNlZChwYWdlKTsKLQkJcHV0X3Bh Z2UocGFnZSk7CisJCWlmIChmbGFncyAmIEZPTExfUElOKQorCQkJcHV0X3VzZXJfcGFnZShwYWdl KTsKKwkJZWxzZQorCQkJcHV0X3BhZ2UocGFnZSk7CiAJfQogfQogCkBAIC0xODgxLDcgKzE5OTEs NyBAQCBzdGF0aWMgaW50IGd1cF9wdGVfcmFuZ2UocG1kX3QgcG1kLCB1bnNpZ25lZCBsb25nIGFk ZHIsIHVuc2lnbmVkIGxvbmcgZW5kLAogCiAJCQlwZ21hcCA9IGdldF9kZXZfcGFnZW1hcChwdGVf cGZuKHB0ZSksIHBnbWFwKTsKIAkJCWlmICh1bmxpa2VseSghcGdtYXApKSB7Ci0JCQkJdW5kb19k ZXZfcGFnZW1hcChuciwgbnJfc3RhcnQsIHBhZ2VzKTsKKwkJCQl1bmRvX2Rldl9wYWdlbWFwKG5y LCBucl9zdGFydCwgZmxhZ3MsIHBhZ2VzKTsKIAkJCQlnb3RvIHB0ZV91bm1hcDsKIAkJCX0KIAkJ fSBlbHNlIGlmIChwdGVfc3BlY2lhbChwdGUpKQpAQCAtMTg5MCw5ICsyMDAwLDE1IEBAIHN0YXRp YyBpbnQgZ3VwX3B0ZV9yYW5nZShwbWRfdCBwbWQsIHVuc2lnbmVkIGxvbmcgYWRkciwgdW5zaWdu ZWQgbG9uZyBlbmQsCiAJCVZNX0JVR19PTighcGZuX3ZhbGlkKHB0ZV9wZm4ocHRlKSkpOwogCQlw YWdlID0gcHRlX3BhZ2UocHRlKTsKIAotCQloZWFkID0gdHJ5X2dldF9jb21wb3VuZF9oZWFkKHBh Z2UsIDEpOwotCQlpZiAoIWhlYWQpCi0JCQlnb3RvIHB0ZV91bm1hcDsKKwkJaWYgKGZsYWdzICYg Rk9MTF9QSU4pIHsKKwkJCWhlYWQgPSBwYWdlOworCQkJaWYgKHVubGlrZWx5KCF0cnlfcGluX3Bh Z2UoaGVhZCkpKQorCQkJCWdvdG8gcHRlX3VubWFwOworCQl9IGVsc2UgeworCQkJaGVhZCA9IHRy eV9nZXRfY29tcG91bmRfaGVhZChwYWdlLCAxKTsKKwkJCWlmICghaGVhZCkKKwkJCQlnb3RvIHB0 ZV91bm1hcDsKKwkJfQogCiAJCWlmICh1bmxpa2VseShwdGVfdmFsKHB0ZSkgIT0gcHRlX3ZhbCgq cHRlcCkpKSB7CiAJCQlwdXRfcGFnZShoZWFkKTsKQEAgLTE5NDYsMTIgKzIwNjIsMjAgQEAgc3Rh dGljIGludCBfX2d1cF9kZXZpY2VfaHVnZSh1bnNpZ25lZCBsb25nIHBmbiwgdW5zaWduZWQgbG9u ZyBhZGRyLAogCiAJCXBnbWFwID0gZ2V0X2Rldl9wYWdlbWFwKHBmbiwgcGdtYXApOwogCQlpZiAo dW5saWtlbHkoIXBnbWFwKSkgewotCQkJdW5kb19kZXZfcGFnZW1hcChuciwgbnJfc3RhcnQsIHBh Z2VzKTsKKwkJCXVuZG9fZGV2X3BhZ2VtYXAobnIsIG5yX3N0YXJ0LCBmbGFncywgcGFnZXMpOwog CQkJcmV0dXJuIDA7CiAJCX0KIAkJU2V0UGFnZVJlZmVyZW5jZWQocGFnZSk7CiAJCXBhZ2VzWypu cl0gPSBwYWdlOwotCQlnZXRfcGFnZShwYWdlKTsKKworCQlpZiAoZmxhZ3MgJiBGT0xMX1BJTikg eworCQkJaWYgKHVubGlrZWx5KCF0cnlfcGluX3BhZ2UocGFnZSkpKSB7CisJCQkJdW5kb19kZXZf cGFnZW1hcChuciwgbnJfc3RhcnQsIGZsYWdzLCBwYWdlcyk7CisJCQkJcmV0dXJuIDA7CisJCQl9 CisJCX0gZWxzZQorCQkJZ2V0X3BhZ2UocGFnZSk7CisKIAkJKCpucikrKzsKIAkJcGZuKys7CiAJ fSB3aGlsZSAoYWRkciArPSBQQUdFX1NJWkUsIGFkZHIgIT0gZW5kKTsKQEAgLTE5NzMsNyArMjA5 Nyw3IEBAIHN0YXRpYyBpbnQgX19ndXBfZGV2aWNlX2h1Z2VfcG1kKHBtZF90IG9yaWcsIHBtZF90 ICpwbWRwLCB1bnNpZ25lZCBsb25nIGFkZHIsCiAJCXJldHVybiAwOwogCiAJaWYgKHVubGlrZWx5 KHBtZF92YWwob3JpZykgIT0gcG1kX3ZhbCgqcG1kcCkpKSB7Ci0JCXVuZG9fZGV2X3BhZ2VtYXAo bnIsIG5yX3N0YXJ0LCBwYWdlcyk7CisJCXVuZG9fZGV2X3BhZ2VtYXAobnIsIG5yX3N0YXJ0LCBm bGFncywgcGFnZXMpOwogCQlyZXR1cm4gMDsKIAl9CiAJcmV0dXJuIDE7CkBAIC0xOTkxLDcgKzIx MTUsNyBAQCBzdGF0aWMgaW50IF9fZ3VwX2RldmljZV9odWdlX3B1ZChwdWRfdCBvcmlnLCBwdWRf dCAqcHVkcCwgdW5zaWduZWQgbG9uZyBhZGRyLAogCQlyZXR1cm4gMDsKIAogCWlmICh1bmxpa2Vs eShwdWRfdmFsKG9yaWcpICE9IHB1ZF92YWwoKnB1ZHApKSkgewotCQl1bmRvX2Rldl9wYWdlbWFw KG5yLCBucl9zdGFydCwgcGFnZXMpOworCQl1bmRvX2Rldl9wYWdlbWFwKG5yLCBucl9zdGFydCwg ZmxhZ3MsIHBhZ2VzKTsKIAkJcmV0dXJuIDA7CiAJfQogCXJldHVybiAxOwpAQCAtMjAyNSw2ICsy MTQ5LDIwIEBAIHN0YXRpYyBpbnQgX19yZWNvcmRfc3VicGFnZXMoc3RydWN0IHBhZ2UgKnBhZ2Us IHVuc2lnbmVkIGxvbmcgYWRkciwKIAlyZXR1cm4gbnI7CiB9CiAKK3N0YXRpYyBib29sIF9fcGlu X2NvbXBvdW5kX2hlYWQoc3RydWN0IHBhZ2UgKmhlYWQsIGludCByZWZzLCB1bnNpZ25lZCBpbnQg ZmxhZ3MpCit7CisJaWYgKGZsYWdzICYgRk9MTF9QSU4pIHsKKwkJaWYgKHVubGlrZWx5KCF0cnlf cGluX2NvbXBvdW5kX2hlYWQoaGVhZCwgcmVmcykpKQorCQkJcmV0dXJuIGZhbHNlOworCX0gZWxz ZSB7CisJCWhlYWQgPSB0cnlfZ2V0X2NvbXBvdW5kX2hlYWQoaGVhZCwgcmVmcyk7CisJCWlmICgh aGVhZCkKKwkJCXJldHVybiBmYWxzZTsKKwl9CisKKwlyZXR1cm4gdHJ1ZTsKK30KKwogc3RhdGlj IHZvaWQgcHV0X2NvbXBvdW5kX2hlYWQoc3RydWN0IHBhZ2UgKnBhZ2UsIGludCByZWZzKQogewog CS8qIERvIGEgZ2V0X3BhZ2UoKSBmaXJzdCwgaW4gY2FzZSByZWZzID09IHBhZ2UtPl9yZWZjb3Vu dCAqLwpAQCAtMjA2Niw4ICsyMjA0LDcgQEAgc3RhdGljIGludCBndXBfaHVnZXB0ZShwdGVfdCAq cHRlcCwgdW5zaWduZWQgbG9uZyBzeiwgdW5zaWduZWQgbG9uZyBhZGRyLAogCXBhZ2UgPSBoZWFk ICsgKChhZGRyICYgKHN6LTEpKSA+PiBQQUdFX1NISUZUKTsKIAlyZWZzID0gX19yZWNvcmRfc3Vi cGFnZXMocGFnZSwgYWRkciwgZW5kLCBwYWdlcyArICpucik7CiAKLQloZWFkID0gdHJ5X2dldF9j b21wb3VuZF9oZWFkKGhlYWQsIHJlZnMpOwotCWlmICghaGVhZCkKKwlpZiAoIV9fcGluX2NvbXBv dW5kX2hlYWQoaGVhZCwgcmVmcywgZmxhZ3MpKQogCQlyZXR1cm4gMDsKIAogCWlmICh1bmxpa2Vs eShwdGVfdmFsKHB0ZSkgIT0gcHRlX3ZhbCgqcHRlcCkpKSB7CkBAIC0yMTI2LDggKzIyNjMsOCBA QCBzdGF0aWMgaW50IGd1cF9odWdlX3BtZChwbWRfdCBvcmlnLCBwbWRfdCAqcG1kcCwgdW5zaWdu ZWQgbG9uZyBhZGRyLAogCXBhZ2UgPSBwbWRfcGFnZShvcmlnKSArICgoYWRkciAmIH5QTURfTUFT SykgPj4gUEFHRV9TSElGVCk7CiAJcmVmcyA9IF9fcmVjb3JkX3N1YnBhZ2VzKHBhZ2UsIGFkZHIs IGVuZCwgcGFnZXMgKyAqbnIpOwogCi0JaGVhZCA9IHRyeV9nZXRfY29tcG91bmRfaGVhZChwbWRf cGFnZShvcmlnKSwgcmVmcyk7Ci0JaWYgKCFoZWFkKQorCWhlYWQgPSBwbWRfcGFnZShvcmlnKTsK KwlpZiAoIV9fcGluX2NvbXBvdW5kX2hlYWQoaGVhZCwgcmVmcywgZmxhZ3MpKQogCQlyZXR1cm4g MDsKIAogCWlmICh1bmxpa2VseShwbWRfdmFsKG9yaWcpICE9IHBtZF92YWwoKnBtZHApKSkgewpA QCAtMjE2MCw4ICsyMjk3LDggQEAgc3RhdGljIGludCBndXBfaHVnZV9wdWQocHVkX3Qgb3JpZywg cHVkX3QgKnB1ZHAsIHVuc2lnbmVkIGxvbmcgYWRkciwKIAlwYWdlID0gcHVkX3BhZ2Uob3JpZykg KyAoKGFkZHIgJiB+UFVEX01BU0spID4+IFBBR0VfU0hJRlQpOwogCXJlZnMgPSBfX3JlY29yZF9z dWJwYWdlcyhwYWdlLCBhZGRyLCBlbmQsIHBhZ2VzICsgKm5yKTsKIAotCWhlYWQgPSB0cnlfZ2V0 X2NvbXBvdW5kX2hlYWQocHVkX3BhZ2Uob3JpZyksIHJlZnMpOwotCWlmICghaGVhZCkKKwloZWFk ID0gcHVkX3BhZ2Uob3JpZyk7CisJaWYgKCFfX3Bpbl9jb21wb3VuZF9oZWFkKGhlYWQsIHJlZnMs IGZsYWdzKSkKIAkJcmV0dXJuIDA7CiAKIAlpZiAodW5saWtlbHkocHVkX3ZhbChvcmlnKSAhPSBw dWRfdmFsKCpwdWRwKSkpIHsKQEAgLTIxODksOCArMjMyNiw4IEBAIHN0YXRpYyBpbnQgZ3VwX2h1 Z2VfcGdkKHBnZF90IG9yaWcsIHBnZF90ICpwZ2RwLCB1bnNpZ25lZCBsb25nIGFkZHIsCiAJcGFn ZSA9IHBnZF9wYWdlKG9yaWcpICsgKChhZGRyICYgflBHRElSX01BU0spID4+IFBBR0VfU0hJRlQp OwogCXJlZnMgPSBfX3JlY29yZF9zdWJwYWdlcyhwYWdlLCBhZGRyLCBlbmQsIHBhZ2VzICsgKm5y KTsKIAotCWhlYWQgPSB0cnlfZ2V0X2NvbXBvdW5kX2hlYWQocGdkX3BhZ2Uob3JpZyksIHJlZnMp OwotCWlmICghaGVhZCkKKwloZWFkID0gcGdkX3BhZ2Uob3JpZyk7CisJaWYgKCFfX3Bpbl9jb21w b3VuZF9oZWFkKGhlYWQsIHJlZnMsIGZsYWdzKSkKIAkJcmV0dXJuIDA7CiAKIAlpZiAodW5saWtl bHkocGdkX3ZhbChvcmlnKSAhPSBwZ2RfdmFsKCpwZ2RwKSkpIHsKQEAgLTI0OTQsOSArMjYzMSwx MiBAQCBFWFBPUlRfU1lNQk9MX0dQTChnZXRfdXNlcl9wYWdlc19mYXN0KTsKIC8qKgogICogcGlu X3VzZXJfcGFnZXNfZmFzdCgpIC0gcGluIHVzZXIgcGFnZXMgaW4gbWVtb3J5IHdpdGhvdXQgdGFr aW5nIGxvY2tzCiAgKgotICogRm9yIG5vdywgdGhpcyBpcyBhIHBsYWNlaG9sZGVyIGZ1bmN0aW9u LCB1bnRpbCB2YXJpb3VzIGNhbGwgc2l0ZXMgYXJlCi0gKiBjb252ZXJ0ZWQgdG8gdXNlIHRoZSBj b3JyZWN0IGdldF91c2VyX3BhZ2VzKigpIG9yIHBpbl91c2VyX3BhZ2VzKigpIEFQSS4gU28sCi0g KiB0aGlzIGlzIGlkZW50aWNhbCB0byBnZXRfdXNlcl9wYWdlc19mYXN0KCkuCisgKiBOZWFybHkg dGhlIHNhbWUgYXMgZ2V0X3VzZXJfcGFnZXNfZmFzdCgpLCBleGNlcHQgdGhhdCBGT0xMX1BJTiBp cyBzZXQuIFNlZQorICogZ2V0X3VzZXJfcGFnZXNfZmFzdCgpIGZvciBkb2N1bWVudGF0aW9uIG9u IHRoZSBmdW5jdGlvbiBhcmd1bWVudHMsIGJlY2F1c2UKKyAqIHRoZSBhcmd1bWVudHMgaGVyZSBh cmUgaWRlbnRpY2FsLgorICoKKyAqIEZPTExfUElOIG1lYW5zIHRoYXQgdGhlIHBhZ2VzIG11c3Qg YmUgcmVsZWFzZWQgdmlhIHVucGluX3VzZXJfcGFnZSgpLiBQbGVhc2UKKyAqIHNlZSBEb2N1bWVu dGF0aW9uL3ZtL3Bpbl91c2VyX3BhZ2VzLnJzdCBmb3IgZnVydGhlciBkZXRhaWxzLgogICoKICAq IFRoaXMgaXMgaW50ZW5kZWQgZm9yIENhc2UgMSAoRElPKSBpbiBEb2N1bWVudGF0aW9uL3ZtL3Bp bl91c2VyX3BhZ2VzLnJzdC4gSXQKICAqIGlzIE5PVCBpbnRlbmRlZCBmb3IgQ2FzZSAyIChSRE1B OiBsb25nLXRlcm0gcGlucykuCkBAIC0yNTA0LDIxICsyNjQ0LDI0IEBAIEVYUE9SVF9TWU1CT0xf R1BMKGdldF91c2VyX3BhZ2VzX2Zhc3QpOwogaW50IHBpbl91c2VyX3BhZ2VzX2Zhc3QodW5zaWdu ZWQgbG9uZyBzdGFydCwgaW50IG5yX3BhZ2VzLAogCQkJdW5zaWduZWQgaW50IGd1cF9mbGFncywg c3RydWN0IHBhZ2UgKipwYWdlcykKIHsKLQkvKgotCSAqIFRoaXMgaXMgYSBwbGFjZWhvbGRlciwg dW50aWwgdGhlIHBpbiBmdW5jdGlvbmFsaXR5IGlzIGFjdGl2YXRlZC4KLQkgKiBVbnRpbCB0aGVu LCBqdXN0IGJlaGF2ZSBsaWtlIHRoZSBjb3JyZXNwb25kaW5nIGdldF91c2VyX3BhZ2VzKigpCi0J ICogcm91dGluZS4KLQkgKi8KLQlyZXR1cm4gZ2V0X3VzZXJfcGFnZXNfZmFzdChzdGFydCwgbnJf cGFnZXMsIGd1cF9mbGFncywgcGFnZXMpOworCS8qIEZPTExfR0VUIGFuZCBGT0xMX1BJTiBhcmUg bXV0dWFsbHkgZXhjbHVzaXZlLiAqLworCWlmIChXQVJOX09OX09OQ0UoZ3VwX2ZsYWdzICYgRk9M TF9HRVQpKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWd1cF9mbGFncyB8PSBGT0xMX1BJTjsKKwly ZXR1cm4gaW50ZXJuYWxfZ2V0X3VzZXJfcGFnZXNfZmFzdChzdGFydCwgbnJfcGFnZXMsIGd1cF9m bGFncywgcGFnZXMpOwogfQogRVhQT1JUX1NZTUJPTF9HUEwocGluX3VzZXJfcGFnZXNfZmFzdCk7 CiAKIC8qKgogICogcGluX3VzZXJfcGFnZXNfcmVtb3RlKCkgLSBwaW4gcGFnZXMgb2YgYSByZW1v dGUgcHJvY2VzcyAodGFzayAhPSBjdXJyZW50KQogICoKLSAqIEZvciBub3csIHRoaXMgaXMgYSBw bGFjZWhvbGRlciBmdW5jdGlvbiwgdW50aWwgdmFyaW91cyBjYWxsIHNpdGVzIGFyZQotICogY29u dmVydGVkIHRvIHVzZSB0aGUgY29ycmVjdCBnZXRfdXNlcl9wYWdlcyooKSBvciBwaW5fdXNlcl9w YWdlcyooKSBBUEkuIFNvLAotICogdGhpcyBpcyBpZGVudGljYWwgdG8gZ2V0X3VzZXJfcGFnZXNf cmVtb3RlKCkuCisgKiBOZWFybHkgdGhlIHNhbWUgYXMgZ2V0X3VzZXJfcGFnZXNfcmVtb3RlKCks IGV4Y2VwdCB0aGF0IEZPTExfUElOIGlzIHNldC4gU2VlCisgKiBnZXRfdXNlcl9wYWdlc19yZW1v dGUoKSBmb3IgZG9jdW1lbnRhdGlvbiBvbiB0aGUgZnVuY3Rpb24gYXJndW1lbnRzLCBiZWNhdXNl CisgKiB0aGUgYXJndW1lbnRzIGhlcmUgYXJlIGlkZW50aWNhbC4KKyAqCisgKiBGT0xMX1BJTiBt ZWFucyB0aGF0IHRoZSBwYWdlcyBtdXN0IGJlIHJlbGVhc2VkIHZpYSB1bnBpbl91c2VyX3BhZ2Uo KS4gUGxlYXNlCisgKiBzZWUgRG9jdW1lbnRhdGlvbi92bS9waW5fdXNlcl9wYWdlcy5yc3QgZm9y IGRldGFpbHMuCiAgKgogICogVGhpcyBpcyBpbnRlbmRlZCBmb3IgQ2FzZSAxIChESU8pIGluIERv Y3VtZW50YXRpb24vdm0vcGluX3VzZXJfcGFnZXMucnN0LiBJdAogICogaXMgTk9UIGludGVuZGVk IGZvciBDYXNlIDIgKFJETUE6IGxvbmctdGVybSBwaW5zKS4KQEAgLTI1MjgsMjIgKzI2NzEsMjQg QEAgbG9uZyBwaW5fdXNlcl9wYWdlc19yZW1vdGUoc3RydWN0IHRhc2tfc3RydWN0ICp0c2ssIHN0 cnVjdCBtbV9zdHJ1Y3QgKm1tLAogCQkJICAgdW5zaWduZWQgaW50IGd1cF9mbGFncywgc3RydWN0 IHBhZ2UgKipwYWdlcywKIAkJCSAgIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqKnZtYXMsIGludCAq bG9ja2VkKQogewotCS8qCi0JICogVGhpcyBpcyBhIHBsYWNlaG9sZGVyLCB1bnRpbCB0aGUgcGlu IGZ1bmN0aW9uYWxpdHkgaXMgYWN0aXZhdGVkLgotCSAqIFVudGlsIHRoZW4sIGp1c3QgYmVoYXZl IGxpa2UgdGhlIGNvcnJlc3BvbmRpbmcgZ2V0X3VzZXJfcGFnZXMqKCkKLQkgKiByb3V0aW5lLgot CSAqLwotCXJldHVybiBnZXRfdXNlcl9wYWdlc19yZW1vdGUodHNrLCBtbSwgc3RhcnQsIG5yX3Bh Z2VzLCBndXBfZmxhZ3MsIHBhZ2VzLAotCQkJCSAgICAgdm1hcywgbG9ja2VkKTsKKwkvKiBGT0xM X0dFVCBhbmQgRk9MTF9QSU4gYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZS4gKi8KKwlpZiAoV0FSTl9P Tl9PTkNFKGd1cF9mbGFncyAmIEZPTExfR0VUKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlndXBf ZmxhZ3MgfD0gRk9MTF9QSU47CisJcmV0dXJuIF9fZ2V0X3VzZXJfcGFnZXNfcmVtb3RlKHRzaywg bW0sIHN0YXJ0LCBucl9wYWdlcywgZ3VwX2ZsYWdzLAorCQkJCSAgICAgICBwYWdlcywgdm1hcywg bG9ja2VkKTsKIH0KIEVYUE9SVF9TWU1CT0wocGluX3VzZXJfcGFnZXNfcmVtb3RlKTsKIAogLyoq CiAgKiBwaW5fdXNlcl9wYWdlcygpIC0gcGluIHVzZXIgcGFnZXMgaW4gbWVtb3J5IGZvciB1c2Ug Ynkgb3RoZXIgZGV2aWNlcwogICoKLSAqIEZvciBub3csIHRoaXMgaXMgYSBwbGFjZWhvbGRlciBm dW5jdGlvbiwgdW50aWwgdmFyaW91cyBjYWxsIHNpdGVzIGFyZQotICogY29udmVydGVkIHRvIHVz ZSB0aGUgY29ycmVjdCBnZXRfdXNlcl9wYWdlcyooKSBvciBwaW5fdXNlcl9wYWdlcyooKSBBUEku IFNvLAotICogdGhpcyBpcyBpZGVudGljYWwgdG8gZ2V0X3VzZXJfcGFnZXMoKS4KKyAqIE5lYXJs eSB0aGUgc2FtZSBhcyBnZXRfdXNlcl9wYWdlcygpLCBleGNlcHQgdGhhdCBGT0xMX1RPVUNIIGlz IG5vdCBzZXQsIGFuZAorICogRk9MTF9QSU4gaXMgc2V0LgorICoKKyAqIEZPTExfUElOIG1lYW5z IHRoYXQgdGhlIHBhZ2VzIG11c3QgYmUgcmVsZWFzZWQgdmlhIHVucGluX3VzZXJfcGFnZSgpLiBQ bGVhc2UKKyAqIHNlZSBEb2N1bWVudGF0aW9uL3ZtL3Bpbl91c2VyX3BhZ2VzLnJzdCBmb3IgZGV0 YWlscy4KICAqCiAgKiBUaGlzIGlzIGludGVuZGVkIGZvciBDYXNlIDEgKERJTykgaW4gRG9jdW1l bnRhdGlvbi92bS9waW5fdXNlcl9wYWdlcy5yc3QuIEl0CiAgKiBpcyBOT1QgaW50ZW5kZWQgZm9y IENhc2UgMiAoUkRNQTogbG9uZy10ZXJtIHBpbnMpLgpAQCAtMjU1MiwxMSArMjY5NywxMiBAQCBs b25nIHBpbl91c2VyX3BhZ2VzKHVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxvbmcgbnJf cGFnZXMsCiAJCSAgICB1bnNpZ25lZCBpbnQgZ3VwX2ZsYWdzLCBzdHJ1Y3QgcGFnZSAqKnBhZ2Vz LAogCQkgICAgc3RydWN0IHZtX2FyZWFfc3RydWN0ICoqdm1hcykKIHsKLQkvKgotCSAqIFRoaXMg aXMgYSBwbGFjZWhvbGRlciwgdW50aWwgdGhlIHBpbiBmdW5jdGlvbmFsaXR5IGlzIGFjdGl2YXRl ZC4KLQkgKiBVbnRpbCB0aGVuLCBqdXN0IGJlaGF2ZSBsaWtlIHRoZSBjb3JyZXNwb25kaW5nIGdl dF91c2VyX3BhZ2VzKigpCi0JICogcm91dGluZS4KLQkgKi8KLQlyZXR1cm4gZ2V0X3VzZXJfcGFn ZXMoc3RhcnQsIG5yX3BhZ2VzLCBndXBfZmxhZ3MsIHBhZ2VzLCB2bWFzKTsKKwkvKiBGT0xMX0dF VCBhbmQgRk9MTF9QSU4gYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZS4gKi8KKwlpZiAoV0FSTl9PTl9P TkNFKGd1cF9mbGFncyAmIEZPTExfR0VUKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlndXBfZmxh Z3MgfD0gRk9MTF9QSU47CisJcmV0dXJuIF9fZ3VwX2xvbmd0ZXJtX2xvY2tlZChjdXJyZW50LCBj dXJyZW50LT5tbSwgc3RhcnQsIG5yX3BhZ2VzLAorCQkJCSAgICAgcGFnZXMsIHZtYXMsIGd1cF9m bGFncyk7CiB9CiBFWFBPUlRfU1lNQk9MKHBpbl91c2VyX3BhZ2VzKTsKZGlmZiAtLWdpdCBhL21t L2h1Z2VfbWVtb3J5LmMgYi9tbS9odWdlX21lbW9yeS5jCmluZGV4IDEzY2M5Mzc4NTAwNi4uZTk0 Mjk3Nzk5MDQxIDEwMDY0NAotLS0gYS9tbS9odWdlX21lbW9yeS5jCisrKyBiL21tL2h1Z2VfbWVt b3J5LmMKQEAgLTk0NSw2ICs5NDUsMTEgQEAgc3RydWN0IHBhZ2UgKmZvbGxvd19kZXZtYXBfcG1k KHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLCB1bnNpZ25lZCBsb25nIGFkZHIsCiAJICovCiAJ V0FSTl9PTkNFKGZsYWdzICYgRk9MTF9DT1csICJtbTogSW4gZm9sbG93X2Rldm1hcF9wbWQgd2l0 aCBGT0xMX0NPVyBzZXQiKTsKIAorCS8qIEZPTExfR0VUIGFuZCBGT0xMX1BJTiBhcmUgbXV0dWFs bHkgZXhjbHVzaXZlLiAqLworCWlmIChXQVJOX09OX09OQ0UoKGZsYWdzICYgKEZPTExfUElOIHwg Rk9MTF9HRVQpKSA9PQorCQkJIChGT0xMX1BJTiB8IEZPTExfR0VUKSkpCisJCXJldHVybiBOVUxM OworCiAJaWYgKGZsYWdzICYgRk9MTF9XUklURSAmJiAhcG1kX3dyaXRlKCpwbWQpKQogCQlyZXR1 cm4gTlVMTDsKIApAQCAtOTYwLDcgKzk2NSw3IEBAIHN0cnVjdCBwYWdlICpmb2xsb3dfZGV2bWFw X3BtZChzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwgdW5zaWduZWQgbG9uZyBhZGRyLAogCSAq IGRldmljZSBtYXBwZWQgcGFnZXMgY2FuIG9ubHkgYmUgcmV0dXJuZWQgaWYgdGhlCiAJICogY2Fs bGVyIHdpbGwgbWFuYWdlIHRoZSBwYWdlIHJlZmVyZW5jZSBjb3VudC4KIAkgKi8KLQlpZiAoIShm bGFncyAmIEZPTExfR0VUKSkKKwlpZiAoIShmbGFncyAmIChGT0xMX0dFVCB8IEZPTExfUElOKSkp CiAJCXJldHVybiBFUlJfUFRSKC1FRVhJU1QpOwogCiAJcGZuICs9IChhZGRyICYgflBNRF9NQVNL KSA+PiBQQUdFX1NISUZUOwpAQCAtOTY4LDcgKzk3MywxOCBAQCBzdHJ1Y3QgcGFnZSAqZm9sbG93 X2Rldm1hcF9wbWQoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsIHVuc2lnbmVkIGxvbmcgYWRk ciwKIAlpZiAoISpwZ21hcCkKIAkJcmV0dXJuIEVSUl9QVFIoLUVGQVVMVCk7CiAJcGFnZSA9IHBm bl90b19wYWdlKHBmbik7Ci0JZ2V0X3BhZ2UocGFnZSk7CisKKwlpZiAoZmxhZ3MgJiBGT0xMX0dF VCkKKwkJZ2V0X3BhZ2UocGFnZSk7CisJZWxzZSBpZiAoZmxhZ3MgJiBGT0xMX1BJTikgeworCQkv KgorCQkgKiB0cnlfcGluX3BhZ2UoKSBpcyBub3QgYWN0dWFsbHkgZXhwZWN0ZWQgdG8gZmFpbCBo ZXJlIGJlY2F1c2UKKwkJICogd2UgaG9sZCB0aGUgcG1kIGxvY2sgc28gbm8gb25lIGNhbiB1bm1h cCB0aGUgcG1kIGFuZCBmcmVlIHRoZQorCQkgKiBwYWdlIHRoYXQgaXQgcG9pbnRzIHRvLgorCQkg Ki8KKwkJaWYgKHVubGlrZWx5KCF0cnlfcGluX3BhZ2UocGFnZSkpKQorCQkJcGFnZSA9IEVSUl9Q VFIoLUVGQVVMVCk7CisJfQogCiAJcmV0dXJuIHBhZ2U7CiB9CkBAIC0xMDg4LDYgKzExMDQsMTEg QEAgc3RydWN0IHBhZ2UgKmZvbGxvd19kZXZtYXBfcHVkKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAq dm1hLCB1bnNpZ25lZCBsb25nIGFkZHIsCiAJaWYgKGZsYWdzICYgRk9MTF9XUklURSAmJiAhcHVk X3dyaXRlKCpwdWQpKQogCQlyZXR1cm4gTlVMTDsKIAorCS8qIEZPTExfR0VUIGFuZCBGT0xMX1BJ TiBhcmUgbXV0dWFsbHkgZXhjbHVzaXZlLiAqLworCWlmIChXQVJOX09OX09OQ0UoKGZsYWdzICYg KEZPTExfUElOIHwgRk9MTF9HRVQpKSA9PQorCQkJIChGT0xMX1BJTiB8IEZPTExfR0VUKSkpCisJ CXJldHVybiBOVUxMOworCiAJaWYgKHB1ZF9wcmVzZW50KCpwdWQpICYmIHB1ZF9kZXZtYXAoKnB1 ZCkpCiAJCS8qIHBhc3MgKi87CiAJZWxzZQpAQCAtMTA5OSw4ICsxMTIwLDEwIEBAIHN0cnVjdCBw YWdlICpmb2xsb3dfZGV2bWFwX3B1ZChzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwgdW5zaWdu ZWQgbG9uZyBhZGRyLAogCS8qCiAJICogZGV2aWNlIG1hcHBlZCBwYWdlcyBjYW4gb25seSBiZSBy ZXR1cm5lZCBpZiB0aGUKIAkgKiBjYWxsZXIgd2lsbCBtYW5hZ2UgdGhlIHBhZ2UgcmVmZXJlbmNl IGNvdW50LgorCSAqCisJICogQXQgbGVhc3Qgb25lIG9mIEZPTExfR0VUIHwgRk9MTF9QSU4gbXVz dCBiZSBzZXQsIHNvIGFzc2VydCB0aGF0IGhlcmU6CiAJICovCi0JaWYgKCEoZmxhZ3MgJiBGT0xM X0dFVCkpCisJaWYgKCEoZmxhZ3MgJiAoRk9MTF9HRVQgfCBGT0xMX1BJTikpKQogCQlyZXR1cm4g RVJSX1BUUigtRUVYSVNUKTsKIAogCXBmbiArPSAoYWRkciAmIH5QVURfTUFTSykgPj4gUEFHRV9T SElGVDsKQEAgLTExMDgsNyArMTEzMSwxOCBAQCBzdHJ1Y3QgcGFnZSAqZm9sbG93X2Rldm1hcF9w dWQoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsIHVuc2lnbmVkIGxvbmcgYWRkciwKIAlpZiAo ISpwZ21hcCkKIAkJcmV0dXJuIEVSUl9QVFIoLUVGQVVMVCk7CiAJcGFnZSA9IHBmbl90b19wYWdl KHBmbik7Ci0JZ2V0X3BhZ2UocGFnZSk7CisKKwlpZiAoZmxhZ3MgJiBGT0xMX0dFVCkKKwkJZ2V0 X3BhZ2UocGFnZSk7CisJZWxzZSBpZiAoZmxhZ3MgJiBGT0xMX1BJTikgeworCQkvKgorCQkgKiB0 cnlfcGluX3BhZ2UoKSBpcyBub3QgYWN0dWFsbHkgZXhwZWN0ZWQgdG8gZmFpbCBoZXJlIGJlY2F1 c2UKKwkJICogd2UgaG9sZCB0aGUgcHVkIGxvY2sgc28gbm8gb25lIGNhbiB1bm1hcCB0aGUgcHVk IGFuZCBmcmVlIHRoZQorCQkgKiBwYWdlIHRoYXQgaXQgcG9pbnRzIHRvLgorCQkgKi8KKwkJaWYg KHVubGlrZWx5KCF0cnlfcGluX3BhZ2UocGFnZSkpKQorCQkJcGFnZSA9IEVSUl9QVFIoLUVGQVVM VCk7CisJfQogCiAJcmV0dXJuIHBhZ2U7CiB9CkBAIC0xNTIyLDggKzE1NTYsMjAgQEAgc3RydWN0 IHBhZ2UgKmZvbGxvd190cmFuc19odWdlX3BtZChzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwK IHNraXBfbWxvY2s6CiAJcGFnZSArPSAoYWRkciAmIH5IUEFHRV9QTURfTUFTSykgPj4gUEFHRV9T SElGVDsKIAlWTV9CVUdfT05fUEFHRSghUGFnZUNvbXBvdW5kKHBhZ2UpICYmICFpc196b25lX2Rl dmljZV9wYWdlKHBhZ2UpLCBwYWdlKTsKKwogCWlmIChmbGFncyAmIEZPTExfR0VUKQogCQlnZXRf cGFnZShwYWdlKTsKKwllbHNlIGlmIChmbGFncyAmIEZPTExfUElOKSB7CisJCS8qCisJCSAqIHRy eV9waW5fcGFnZSgpIGlzIG5vdCBhY3R1YWxseSBleHBlY3RlZCB0byBmYWlsIGhlcmUgYmVjYXVz ZQorCQkgKiB3ZSBob2xkIHRoZSBwbWQgbG9jayBzbyBubyBvbmUgY2FuIHVubWFwIHRoZSBwbWQg YW5kIGZyZWUgdGhlCisJCSAqIHBhZ2UgdGhhdCBpdCBwb2ludHMgdG8uCisJCSAqLworCQlpZiAo dW5saWtlbHkoIXRyeV9waW5fcGFnZShwYWdlKSkpIHsKKwkJCVdBUk5fT05fT05DRSgxKTsKKwkJ CXBhZ2UgPSBOVUxMOworCQl9CisJfQogCiBvdXQ6CiAJcmV0dXJuIHBhZ2U7CmRpZmYgLS1naXQg YS9tbS9odWdldGxiLmMgYi9tbS9odWdldGxiLmMKaW5kZXggYjQ1YTk1MzYzYTg0Li4wYWJkZTcy ODgxMjcgMTAwNjQ0Ci0tLSBhL21tL2h1Z2V0bGIuYworKysgYi9tbS9odWdldGxiLmMKQEAgLTQ0 NjIsNyArNDQ2MiwyMiBAQCBsb25nIGZvbGxvd19odWdldGxiX3BhZ2Uoc3RydWN0IG1tX3N0cnVj dCAqbW0sIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAogc2FtZV9wYWdlOgogCQlpZiAocGFn ZXMpIHsKIAkJCXBhZ2VzW2ldID0gbWVtX21hcF9vZmZzZXQocGFnZSwgcGZuX29mZnNldCk7Ci0J CQlnZXRfcGFnZShwYWdlc1tpXSk7CisKKwkJCWlmIChmbGFncyAmIEZPTExfR0VUKQorCQkJCWdl dF9wYWdlKHBhZ2VzW2ldKTsKKwkJCWVsc2UgaWYgKGZsYWdzICYgRk9MTF9QSU4pIHsKKwkJCQkv KgorCQkJCSAqIHRyeV9waW5fcGFnZSgpIGlzIG5vdCBhY3R1YWxseSBleHBlY3RlZCB0bworCQkJ CSAqIGZhaWwgaGVyZSBiZWNhdXNlIHdlIGhvbGQgdGhlIHB0bC4KKwkJCQkgKi8KKwkJCQlpZiAo dW5saWtlbHkoIXRyeV9waW5fcGFnZShwYWdlc1tpXSkpKSB7CisJCQkJCXNwaW5fdW5sb2NrKHB0 bCk7CisJCQkJCXJlbWFpbmRlciA9IDA7CisJCQkJCWVyciA9IC1FTk9NRU07CisJCQkJCVdBUk5f T05fT05DRSgxKTsKKwkJCQkJYnJlYWs7CisJCQkJfQorCQkJfQogCQl9CiAKIAkJaWYgKHZtYXMp CkBAIC01MDIyLDYgKzUwMzcsMTIgQEAgZm9sbG93X2h1Z2VfcG1kKHN0cnVjdCBtbV9zdHJ1Y3Qg Km1tLCB1bnNpZ25lZCBsb25nIGFkZHJlc3MsCiAJc3RydWN0IHBhZ2UgKnBhZ2UgPSBOVUxMOwog CXNwaW5sb2NrX3QgKnB0bDsKIAlwdGVfdCBwdGU7CisKKwkvKiBGT0xMX0dFVCBhbmQgRk9MTF9Q SU4gYXJlIG11dHVhbGx5IGV4Y2x1c2l2ZS4gKi8KKwlpZiAoV0FSTl9PTl9PTkNFKChmbGFncyAm IChGT0xMX1BJTiB8IEZPTExfR0VUKSkgPT0KKwkJCSAoRk9MTF9QSU4gfCBGT0xMX0dFVCkpKQor CQlyZXR1cm4gTlVMTDsKKwogcmV0cnk6CiAJcHRsID0gcG1kX2xvY2twdHIobW0sIHBtZCk7CiAJ c3Bpbl9sb2NrKHB0bCk7CkBAIC01MDM0LDggKzUwNTUsMjAgQEAgZm9sbG93X2h1Z2VfcG1kKHN0 cnVjdCBtbV9zdHJ1Y3QgKm1tLCB1bnNpZ25lZCBsb25nIGFkZHJlc3MsCiAJcHRlID0gaHVnZV9w dGVwX2dldCgocHRlX3QgKilwbWQpOwogCWlmIChwdGVfcHJlc2VudChwdGUpKSB7CiAJCXBhZ2Ug PSBwbWRfcGFnZSgqcG1kKSArICgoYWRkcmVzcyAmIH5QTURfTUFTSykgPj4gUEFHRV9TSElGVCk7 CisKIAkJaWYgKGZsYWdzICYgRk9MTF9HRVQpCiAJCQlnZXRfcGFnZShwYWdlKTsKKwkJZWxzZSBp ZiAoZmxhZ3MgJiBGT0xMX1BJTikgeworCQkJLyoKKwkJCSAqIHRyeV9waW5fcGFnZSgpIGlzIG5v dCBhY3R1YWxseSBleHBlY3RlZCB0byBmYWlsCisJCQkgKiBoZXJlIGJlY2F1c2Ugd2UgaG9sZCB0 aGUgcHRsLgorCQkJICovCisJCQlpZiAodW5saWtlbHkoIXRyeV9waW5fcGFnZShwYWdlKSkpIHsK KwkJCQlXQVJOX09OX09OQ0UoMSk7CisJCQkJcGFnZSA9IE5VTEw7CisJCQkJZ290byBvdXQ7CisJ CQl9CisJCX0KIAl9IGVsc2UgewogCQlpZiAoaXNfaHVnZXRsYl9lbnRyeV9taWdyYXRpb24ocHRl KSkgewogCQkJc3Bpbl91bmxvY2socHRsKTsKQEAgLTUwNTYsNyArNTA4OSw3IEBAIHN0cnVjdCBw YWdlICogX193ZWFrCiBmb2xsb3dfaHVnZV9wdWQoc3RydWN0IG1tX3N0cnVjdCAqbW0sIHVuc2ln bmVkIGxvbmcgYWRkcmVzcywKIAkJcHVkX3QgKnB1ZCwgaW50IGZsYWdzKQogewotCWlmIChmbGFn cyAmIEZPTExfR0VUKQorCWlmIChmbGFncyAmIChGT0xMX0dFVCB8IEZPTExfUElOKSkKIAkJcmV0 dXJuIE5VTEw7CiAKIAlyZXR1cm4gcHRlX3BhZ2UoKihwdGVfdCAqKXB1ZCkgKyAoKGFkZHJlc3Mg JiB+UFVEX01BU0spID4+IFBBR0VfU0hJRlQpOwpAQCAtNTA2NSw3ICs1MDk4LDcgQEAgZm9sbG93 X2h1Z2VfcHVkKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCB1bnNpZ25lZCBsb25nIGFkZHJlc3MsCiBz dHJ1Y3QgcGFnZSAqIF9fd2VhawogZm9sbG93X2h1Z2VfcGdkKHN0cnVjdCBtbV9zdHJ1Y3QgKm1t LCB1bnNpZ25lZCBsb25nIGFkZHJlc3MsIHBnZF90ICpwZ2QsIGludCBmbGFncykKIHsKLQlpZiAo ZmxhZ3MgJiBGT0xMX0dFVCkKKwlpZiAoZmxhZ3MgJiAoRk9MTF9HRVQgfCBGT0xMX1BJTikpCiAJ CXJldHVybiBOVUxMOwogCiAJcmV0dXJuIHB0ZV9wYWdlKCoocHRlX3QgKilwZ2QpICsgKChhZGRy ZXNzICYgflBHRElSX01BU0spID4+IFBBR0VfU0hJRlQpOwpkaWZmIC0tZ2l0IGEvbW0vdm1zdGF0 LmMgYi9tbS92bXN0YXQuYwppbmRleCBhODIyMjA0MWJkNDQuLmZkYWQ0MGNjZGU3YiAxMDA2NDQK LS0tIGEvbW0vdm1zdGF0LmMKKysrIGIvbW0vdm1zdGF0LmMKQEAgLTExNjcsNiArMTE2Nyw4IEBA IGNvbnN0IGNoYXIgKiBjb25zdCB2bXN0YXRfdGV4dFtdID0gewogCSJucl9kaXJ0aWVkIiwKIAki bnJfd3JpdHRlbiIsCiAJIm5yX2tlcm5lbF9taXNjX3JlY2xhaW1hYmxlIiwKKwkibnJfZm9sbF9w aW5fcmVxdWVzdGVkIiwKKwkibnJfZm9sbF9waW5fcmV0dXJuZWQiLAogCiAJLyogZW51bSB3cml0 ZWJhY2tfc3RhdF9pdGVtIGNvdW50ZXJzICovCiAJIm5yX2RpcnR5X3RocmVzaG9sZCIsCi0tIAoy LjI0LjAKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRy aS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRw czovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbA==