From mboxrd@z Thu Jan 1 00:00:00 1970 From: John Hubbard Subject: [PATCH v6 24/24] mm, tree-wide: rename put_user_page*() to unpin_user_page*() Date: Tue, 19 Nov 2019 00:16:43 -0800 Message-ID: <20191119081643.1866232-25-jhubbard@nvidia.com> References: <20191119081643.1866232-1-jhubbard@nvidia.com> Mime-Version: 1.0 Content-Type: text/plain Content-Transfer-Encoding: quoted-printable Return-path: In-Reply-To: <20191119081643.1866232-1-jhubbard@nvidia.com> Sender: linux-kernel-owner@vger.kernel.org To: Andrew Morton Cc: Al Viro , Alex Williamson , Benjamin Herrenschmidt , =?UTF-8?q?Bj=C3=B6rn=20T=C3=B6pel?= , Christoph Hellwig , Dan Williams , Daniel Vetter , Dave Chinner , David Airlie , "David S . Miller" , Ira Weiny , Jan Kara , Jason Gunthorpe , Jens Axboe , Jonathan Corbet , =?UTF-8?q?J=C3=A9r=C3=B4me=20Glisse?= , Magnus Karlsson , Mauro Carvalho Chehab , Michael Ellerman List-Id: dri-devel@lists.freedesktop.org In order to provide a clearer, more symmetric API for pinning and unpinning DMA pages. This way, pin_user_pages*() calls match up with unpin_user_pages*() calls, and the API is a lot closer to being self-explanatory. Signed-off-by: John Hubbard --- Documentation/core-api/pin_user_pages.rst | 2 +- arch/powerpc/mm/book3s64/iommu_api.c | 6 +-- drivers/gpu/drm/via/via_dmablit.c | 4 +- drivers/infiniband/core/umem.c | 2 +- drivers/infiniband/hw/hfi1/user_pages.c | 2 +- drivers/infiniband/hw/mthca/mthca_memfree.c | 6 +-- drivers/infiniband/hw/qib/qib_user_pages.c | 2 +- drivers/infiniband/hw/qib/qib_user_sdma.c | 6 +-- drivers/infiniband/hw/usnic/usnic_uiom.c | 2 +- drivers/infiniband/sw/siw/siw_mem.c | 2 +- drivers/media/v4l2-core/videobuf-dma-sg.c | 4 +- drivers/platform/goldfish/goldfish_pipe.c | 4 +- drivers/vfio/vfio_iommu_type1.c | 2 +- fs/io_uring.c | 4 +- include/linux/mm.h | 30 +++++++------- include/linux/mmzone.h | 2 +- mm/gup.c | 46 ++++++++++----------- mm/gup_benchmark.c | 2 +- mm/process_vm_access.c | 4 +- net/xdp/xdp_umem.c | 2 +- 20 files changed, 67 insertions(+), 67 deletions(-) diff --git a/Documentation/core-api/pin_user_pages.rst b/Documentation/core= -api/pin_user_pages.rst index baa288a44a77..6d93ef203561 100644 --- a/Documentation/core-api/pin_user_pages.rst +++ b/Documentation/core-api/pin_user_pages.rst @@ -220,7 +220,7 @@ since the system was booted, via two new /proc/vmstat e= ntries: :: /proc/vmstat/nr_foll_pin_requested =20 Those are both going to show zero, unless CONFIG_DEBUG_VM is set. This is -because there is a noticeable performance drop in put_user_page(), when th= ey +because there is a noticeable performance drop in unpin_user_page(), when = they are activated. =20 References diff --git a/arch/powerpc/mm/book3s64/iommu_api.c b/arch/powerpc/mm/book3s6= 4/iommu_api.c index 196383e8e5a9..dd7aa5a4f33c 100644 --- a/arch/powerpc/mm/book3s64/iommu_api.c +++ b/arch/powerpc/mm/book3s64/iommu_api.c @@ -168,7 +168,7 @@ static long mm_iommu_do_alloc(struct mm_struct *mm, uns= igned long ua, =20 free_exit: /* free the references taken */ - put_user_pages(mem->hpages, pinned); + unpin_user_pages(mem->hpages, pinned); =20 vfree(mem->hpas); kfree(mem); @@ -211,8 +211,8 @@ static void mm_iommu_unpin(struct mm_iommu_table_group_= mem_t *mem) if (!page) continue; =20 - put_user_pages_dirty_lock(&mem->hpages[i], 1, - MM_IOMMU_TABLE_GROUP_PAGE_DIRTY); + unpin_user_pages_dirty_lock(&mem->hpages[i], 1, + MM_IOMMU_TABLE_GROUP_PAGE_DIRTY); =20 mem->hpas[i] =3D 0; } diff --git a/drivers/gpu/drm/via/via_dmablit.c b/drivers/gpu/drm/via/via_dm= ablit.c index 37c5e572993a..719d036c9384 100644 --- a/drivers/gpu/drm/via/via_dmablit.c +++ b/drivers/gpu/drm/via/via_dmablit.c @@ -188,8 +188,8 @@ via_free_sg_info(struct pci_dev *pdev, drm_via_sg_info_= t *vsg) kfree(vsg->desc_pages); /* fall through */ case dr_via_pages_locked: - put_user_pages_dirty_lock(vsg->pages, vsg->num_pages, - (vsg->direction =3D=3D DMA_FROM_DEVICE)); + unpin_user_pages_dirty_lock(vsg->pages, vsg->num_pages, + (vsg->direction =3D=3D DMA_FROM_DEVICE)); /* fall through */ case dr_via_pages_alloc: vfree(vsg->pages); diff --git a/drivers/infiniband/core/umem.c b/drivers/infiniband/core/umem.= c index 2c287ced3439..119a147da904 100644 --- a/drivers/infiniband/core/umem.c +++ b/drivers/infiniband/core/umem.c @@ -54,7 +54,7 @@ static void __ib_umem_release(struct ib_device *dev, stru= ct ib_umem *umem, int d =20 for_each_sg_page(umem->sg_head.sgl, &sg_iter, umem->sg_nents, 0) { page =3D sg_page_iter_page(&sg_iter); - put_user_pages_dirty_lock(&page, 1, umem->writable && dirty); + unpin_user_pages_dirty_lock(&page, 1, umem->writable && dirty); } =20 sg_free_table(&umem->sg_head); diff --git a/drivers/infiniband/hw/hfi1/user_pages.c b/drivers/infiniband/h= w/hfi1/user_pages.c index 9a94761765c0..3b505006c0a6 100644 --- a/drivers/infiniband/hw/hfi1/user_pages.c +++ b/drivers/infiniband/hw/hfi1/user_pages.c @@ -118,7 +118,7 @@ int hfi1_acquire_user_pages(struct mm_struct *mm, unsig= ned long vaddr, size_t np void hfi1_release_user_pages(struct mm_struct *mm, struct page **p, size_t npages, bool dirty) { - put_user_pages_dirty_lock(p, npages, dirty); + unpin_user_pages_dirty_lock(p, npages, dirty); =20 if (mm) { /* during close after signal, mm can be NULL */ atomic64_sub(npages, &mm->pinned_vm); diff --git a/drivers/infiniband/hw/mthca/mthca_memfree.c b/drivers/infiniba= nd/hw/mthca/mthca_memfree.c index 8269ab040c21..78a48aea3faf 100644 --- a/drivers/infiniband/hw/mthca/mthca_memfree.c +++ b/drivers/infiniband/hw/mthca/mthca_memfree.c @@ -482,7 +482,7 @@ int mthca_map_user_db(struct mthca_dev *dev, struct mth= ca_uar *uar, =20 ret =3D pci_map_sg(dev->pdev, &db_tab->page[i].mem, 1, PCI_DMA_TODEVICE); if (ret < 0) { - put_user_page(pages[0]); + unpin_user_page(pages[0]); goto out; } =20 @@ -490,7 +490,7 @@ int mthca_map_user_db(struct mthca_dev *dev, struct mth= ca_uar *uar, mthca_uarc_virt(dev, uar, i)); if (ret) { pci_unmap_sg(dev->pdev, &db_tab->page[i].mem, 1, PCI_DMA_TODEVICE); - put_user_page(sg_page(&db_tab->page[i].mem)); + unpin_user_page(sg_page(&db_tab->page[i].mem)); goto out; } =20 @@ -556,7 +556,7 @@ void mthca_cleanup_user_db_tab(struct mthca_dev *dev, s= truct mthca_uar *uar, if (db_tab->page[i].uvirt) { mthca_UNMAP_ICM(dev, mthca_uarc_virt(dev, uar, i), 1); pci_unmap_sg(dev->pdev, &db_tab->page[i].mem, 1, PCI_DMA_TODEVICE); - put_user_page(sg_page(&db_tab->page[i].mem)); + unpin_user_page(sg_page(&db_tab->page[i].mem)); } } =20 diff --git a/drivers/infiniband/hw/qib/qib_user_pages.c b/drivers/infiniban= d/hw/qib/qib_user_pages.c index 7fc4b5f81fcd..342e3172ca40 100644 --- a/drivers/infiniband/hw/qib/qib_user_pages.c +++ b/drivers/infiniband/hw/qib/qib_user_pages.c @@ -40,7 +40,7 @@ static void __qib_release_user_pages(struct page **p, size_t num_pages, int dirty) { - put_user_pages_dirty_lock(p, num_pages, dirty); + unpin_user_pages_dirty_lock(p, num_pages, dirty); } =20 /** diff --git a/drivers/infiniband/hw/qib/qib_user_sdma.c b/drivers/infiniband= /hw/qib/qib_user_sdma.c index 1a3cc2957e3a..a67599b5a550 100644 --- a/drivers/infiniband/hw/qib/qib_user_sdma.c +++ b/drivers/infiniband/hw/qib/qib_user_sdma.c @@ -317,7 +317,7 @@ static int qib_user_sdma_page_to_frags(const struct qib= _devdata *dd, * the caller can ignore this page. */ if (put) { - put_user_page(page); + unpin_user_page(page); } else { /* coalesce case */ kunmap(page); @@ -631,7 +631,7 @@ static void qib_user_sdma_free_pkt_frag(struct device *= dev, kunmap(pkt->addr[i].page); =20 if (pkt->addr[i].put_page) - put_user_page(pkt->addr[i].page); + unpin_user_page(pkt->addr[i].page); else __free_page(pkt->addr[i].page); } else if (pkt->addr[i].kvaddr) { @@ -706,7 +706,7 @@ static int qib_user_sdma_pin_pages(const struct qib_dev= data *dd, /* if error, return all pages not managed by pkt */ free_pages: while (i < j) - put_user_page(pages[i++]); + unpin_user_page(pages[i++]); =20 done: return ret; diff --git a/drivers/infiniband/hw/usnic/usnic_uiom.c b/drivers/infiniband/= hw/usnic/usnic_uiom.c index 600896727d34..bd9f944b68fc 100644 --- a/drivers/infiniband/hw/usnic/usnic_uiom.c +++ b/drivers/infiniband/hw/usnic/usnic_uiom.c @@ -75,7 +75,7 @@ static void usnic_uiom_put_pages(struct list_head *chunk_= list, int dirty) for_each_sg(chunk->page_list, sg, chunk->nents, i) { page =3D sg_page(sg); pa =3D sg_phys(sg); - put_user_pages_dirty_lock(&page, 1, dirty); + unpin_user_pages_dirty_lock(&page, 1, dirty); usnic_dbg("pa: %pa\n", &pa); } kfree(chunk); diff --git a/drivers/infiniband/sw/siw/siw_mem.c b/drivers/infiniband/sw/si= w/siw_mem.c index e53b07dcfed5..e2061dc0b043 100644 --- a/drivers/infiniband/sw/siw/siw_mem.c +++ b/drivers/infiniband/sw/siw/siw_mem.c @@ -63,7 +63,7 @@ struct siw_mem *siw_mem_id2obj(struct siw_device *sdev, i= nt stag_index) static void siw_free_plist(struct siw_page_chunk *chunk, int num_pages, bool dirty) { - put_user_pages_dirty_lock(chunk->plist, num_pages, dirty); + unpin_user_pages_dirty_lock(chunk->plist, num_pages, dirty); } =20 void siw_umem_release(struct siw_umem *umem, bool dirty) diff --git a/drivers/media/v4l2-core/videobuf-dma-sg.c b/drivers/media/v4l2= -core/videobuf-dma-sg.c index 162a2633b1e3..13b65ed9e74c 100644 --- a/drivers/media/v4l2-core/videobuf-dma-sg.c +++ b/drivers/media/v4l2-core/videobuf-dma-sg.c @@ -349,8 +349,8 @@ int videobuf_dma_free(struct videobuf_dmabuf *dma) BUG_ON(dma->sglen); =20 if (dma->pages) { - put_user_pages_dirty_lock(dma->pages, dma->nr_pages, - dma->direction =3D=3D DMA_FROM_DEVICE); + unpin_user_pages_dirty_lock(dma->pages, dma->nr_pages, + dma->direction =3D=3D DMA_FROM_DEVICE); kfree(dma->pages); dma->pages =3D NULL; } diff --git a/drivers/platform/goldfish/goldfish_pipe.c b/drivers/platform/g= oldfish/goldfish_pipe.c index 635a8bc1b480..bf523df2a90d 100644 --- a/drivers/platform/goldfish/goldfish_pipe.c +++ b/drivers/platform/goldfish/goldfish_pipe.c @@ -360,8 +360,8 @@ static int transfer_max_buffers(struct goldfish_pipe *p= ipe, =20 *consumed_size =3D pipe->command_buffer->rw_params.consumed_size; =20 - put_user_pages_dirty_lock(pipe->pages, pages_count, - !is_write && *consumed_size > 0); + unpin_user_pages_dirty_lock(pipe->pages, pages_count, + !is_write && *consumed_size > 0); =20 mutex_unlock(&pipe->lock); return 0; diff --git a/drivers/vfio/vfio_iommu_type1.c b/drivers/vfio/vfio_iommu_type= 1.c index 18aa36b56896..c48ac1567f14 100644 --- a/drivers/vfio/vfio_iommu_type1.c +++ b/drivers/vfio/vfio_iommu_type1.c @@ -328,7 +328,7 @@ static int put_pfn(unsigned long pfn, int prot) if (!is_invalid_reserved_pfn(pfn)) { struct page *page =3D pfn_to_page(pfn); =20 - put_user_pages_dirty_lock(&page, 1, prot & IOMMU_WRITE); + unpin_user_pages_dirty_lock(&page, 1, prot & IOMMU_WRITE); return 1; } return 0; diff --git a/fs/io_uring.c b/fs/io_uring.c index 15715eeebaec..0253a4d8fdc8 100644 --- a/fs/io_uring.c +++ b/fs/io_uring.c @@ -3328,7 +3328,7 @@ static int io_sqe_buffer_unregister(struct io_ring_ct= x *ctx) struct io_mapped_ubuf *imu =3D &ctx->user_bufs[i]; =20 for (j =3D 0; j < imu->nr_bvecs; j++) - put_user_page(imu->bvec[j].bv_page); + unpin_user_page(imu->bvec[j].bv_page); =20 if (ctx->account_mem) io_unaccount_mem(ctx->user, imu->nr_bvecs); @@ -3473,7 +3473,7 @@ static int io_sqe_buffer_register(struct io_ring_ctx = *ctx, void __user *arg, * release any pages we did get */ if (pret > 0) - put_user_pages(pages, pret); + unpin_user_pages(pages, pret); if (ctx->account_mem) io_unaccount_mem(ctx->user, nr_pages); kvfree(imu->bvec); diff --git a/include/linux/mm.h b/include/linux/mm.h index ab311b356ab1..775f6a3d615b 100644 --- a/include/linux/mm.h +++ b/include/linux/mm.h @@ -1093,18 +1093,18 @@ static inline void put_page(struct page *page) * 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 + * distinct from normal pages. As such, the unpin_user_page() call (and it= s * 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). + * counts with respect to pin_user_pages() and unpin_user_page() becomes + * simpler, 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 th= at + * counts up using the bias value. This means that the lower bits are left= for + * the exclusive use of the original code that increments and decrements b= y one + * (or at least, by much smaller values than the bias value). * * 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 @@ -1119,10 +1119,10 @@ static inline void put_page(struct 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); +void unpin_user_page(struct page *page); +void unpin_user_pages_dirty_lock(struct page **pages, unsigned long npages= , + bool make_dirty); +void unpin_user_pages(struct page **pages, unsigned long npages); =20 /** * page_dma_pinned() - report if a page is pinned for DMA. @@ -2673,7 +2673,7 @@ struct page *follow_page(struct vm_area_struct *vma, = unsigned long address, #define FOLL_ANON 0x8000 /* don't do file mappings */ #define FOLL_LONGTERM 0x10000 /* mapping lifetime is indefinite: see below= */ #define FOLL_SPLIT_PMD 0x20000 /* split huge pmd before returning */ -#define FOLL_PIN 0x40000 /* pages must be released via put_user_page() */ +#define FOLL_PIN 0x40000 /* pages must be released via unpin_user_page */ =20 /* * FOLL_PIN and FOLL_LONGTERM may be used in various combinations with eac= h @@ -2708,7 +2708,7 @@ struct page *follow_page(struct vm_area_struct *vma, = unsigned long address, * Direct IO). This lets the filesystem know that some non-file-system ent= ity is * potentially changing the pages' data. In contrast to FOLL_GET (whose pa= ges * are released via put_page()), FOLL_PIN pages must be released, ultimate= ly, by - * a call to put_user_page(). + * a call to unpin_user_page(). * * FOLL_PIN is similar to FOLL_GET: both of these pin pages. They use diff= erent * and separate refcounting mechanisms, however, and that means that each = has @@ -2716,7 +2716,7 @@ struct page *follow_page(struct vm_area_struct *vma, = unsigned long address, * * FOLL_GET: get_user_pages*() to acquire, and put_page() to release. * - * FOLL_PIN: pin_user_pages*() to acquire, and put_user_pages to relea= se. + * FOLL_PIN: pin_user_pages*() to acquire, and unpin_user_pages to rel= ease. * * FOLL_PIN and FOLL_GET are mutually exclusive for a given function call. * (The underlying pages may experience both FOLL_GET-based and FOLL_PIN-b= ased @@ -2726,7 +2726,7 @@ struct page *follow_page(struct vm_area_struct *vma, = unsigned long address, * FOLL_PIN should be set internally by the pin_user_pages*() APIs, never * directly by the caller. That's in order to help avoid mismatches when * releasing pages: get_user_pages*() pages must be released via put_page(= ), - * while pin_user_pages*() pages must be released via put_user_page(). + * while pin_user_pages*() pages must be released via unpin_user_page(). * * Please see Documentation/vm/pin_user_pages.rst for more information. */ diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h index 0485cba38d23..d66c1fb9d45e 100644 --- a/include/linux/mmzone.h +++ b/include/linux/mmzone.h @@ -245,7 +245,7 @@ enum node_stat_item { 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_FOLL_PIN_RETURNED, /* pages returned via unpin_user_page() */ NR_VM_NODE_STAT_ITEMS }; =20 diff --git a/mm/gup.c b/mm/gup.c index 002816526670..cebaf2d02f59 100644 --- a/mm/gup.c +++ b/mm/gup.c @@ -113,15 +113,15 @@ static bool __put_devmap_managed_user_page(struct pag= e *page) #endif /* CONFIG_DEV_PAGEMAP_OPS */ =20 /** - * put_user_page() - release a dma-pinned page + * unpin_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. + * unpin_user_page(), or one of the unpin_user_pages*() routines. This is = so + * that such pages can be separately tracked and uniquely handled. In + * particular, interactions with RDMA and filesystems need special handlin= g. */ -void put_user_page(struct page *page) +void unpin_user_page(struct page *page) { page =3D compound_head(page); =20 @@ -139,10 +139,10 @@ void put_user_page(struct page *page) =20 __update_proc_vmstat(page, NR_FOLL_PIN_RETURNED, 1); } -EXPORT_SYMBOL(put_user_page); +EXPORT_SYMBOL(unpin_user_page); =20 /** - * put_user_pages_dirty_lock() - release and optionally dirty gup-pinned p= ages + * unpin_user_pages_dirty_lock() - release and optionally dirty gup-pinned= pages * @pages: array of pages to be maybe marked dirty, and definitely releas= ed. * @npages: number of pages in the @pages array. * @make_dirty: whether to mark the pages dirty @@ -152,19 +152,19 @@ EXPORT_SYMBOL(put_user_page); * * For each page in the @pages array, make that page (or its head page, if= a * compound page) dirty, if @make_dirty is true, and if the page was previ= ously - * listed as clean. In any case, releases all pages using put_user_page(), - * possibly via put_user_pages(), for the non-dirty case. + * listed as clean. In any case, releases all pages using unpin_user_page(= ), + * possibly via unpin_user_pages(), for the non-dirty case. * - * Please see the put_user_page() documentation for details. + * Please see the unpin_user_page() documentation for details. * * set_page_dirty_lock() is used internally. If instead, set_page_dirty() = is * required, then the caller should a) verify that this is really correct, * because _lock() is usually required, and b) hand code it: - * set_page_dirty_lock(), put_user_page(). + * set_page_dirty_lock(), unpin_user_page(). * */ -void put_user_pages_dirty_lock(struct page **pages, unsigned long npages, - bool make_dirty) +void unpin_user_pages_dirty_lock(struct page **pages, unsigned long npages= , + bool make_dirty) { unsigned long index; =20 @@ -175,7 +175,7 @@ void put_user_pages_dirty_lock(struct page **pages, uns= igned long npages, */ =20 if (!make_dirty) { - put_user_pages(pages, npages); + unpin_user_pages(pages, npages); return; } =20 @@ -203,21 +203,21 @@ void put_user_pages_dirty_lock(struct page **pages, u= nsigned long npages, */ if (!PageDirty(page)) set_page_dirty_lock(page); - put_user_page(page); + unpin_user_page(page); } } -EXPORT_SYMBOL(put_user_pages_dirty_lock); +EXPORT_SYMBOL(unpin_user_pages_dirty_lock); =20 /** - * put_user_pages() - release an array of gup-pinned pages. + * unpin_user_pages() - release an array of gup-pinned pages. * @pages: array of pages to be marked dirty and released. * @npages: number of pages in the @pages array. * - * For each page in the @pages array, release the page using put_user_page= (). + * For each page in the @pages array, release the page using unpin_user_pa= ge(). * - * Please see the put_user_page() documentation for details. + * Please see the unpin_user_page() documentation for details. */ -void put_user_pages(struct page **pages, unsigned long npages) +void unpin_user_pages(struct page **pages, unsigned long npages) { unsigned long index; =20 @@ -227,9 +227,9 @@ void put_user_pages(struct page **pages, unsigned long = npages) * single operation to the head page should suffice. */ for (index =3D 0; index < npages; index++) - put_user_page(pages[index]); + unpin_user_page(pages[index]); } -EXPORT_SYMBOL(put_user_pages); +EXPORT_SYMBOL(unpin_user_pages); =20 #ifdef CONFIG_MMU static struct page *no_page_table(struct vm_area_struct *vma, @@ -1956,7 +1956,7 @@ static void __maybe_unused undo_dev_pagemap(int *nr, = int nr_start, =20 ClearPageReferenced(page); if (flags & FOLL_PIN) - put_user_page(page); + unpin_user_page(page); else put_page(page); } diff --git a/mm/gup_benchmark.c b/mm/gup_benchmark.c index 1ac089ad815f..76d32db48af8 100644 --- a/mm/gup_benchmark.c +++ b/mm/gup_benchmark.c @@ -35,7 +35,7 @@ static void put_back_pages(int cmd, struct page **pages, = unsigned long nr_pages) =20 case PIN_FAST_BENCHMARK: case PIN_BENCHMARK: - put_user_pages(pages, nr_pages); + unpin_user_pages(pages, nr_pages); break; } } diff --git a/mm/process_vm_access.c b/mm/process_vm_access.c index fd20ab675b85..de41e830cdac 100644 --- a/mm/process_vm_access.c +++ b/mm/process_vm_access.c @@ -126,8 +126,8 @@ static int process_vm_rw_single_vec(unsigned long addr, pa +=3D pinned_pages * PAGE_SIZE; =20 /* If vm_write is set, the pages need to be made dirty: */ - put_user_pages_dirty_lock(process_pages, pinned_pages, - vm_write); + unpin_user_pages_dirty_lock(process_pages, pinned_pages, + vm_write); } =20 return rc; diff --git a/net/xdp/xdp_umem.c b/net/xdp/xdp_umem.c index d071003b5e76..ac182c38f7b0 100644 --- a/net/xdp/xdp_umem.c +++ b/net/xdp/xdp_umem.c @@ -212,7 +212,7 @@ static int xdp_umem_map_pages(struct xdp_umem *umem) =20 static void xdp_umem_unpin_pages(struct xdp_umem *umem) { - put_user_pages_dirty_lock(umem->pgs, umem->npgs, true); + unpin_user_pages_dirty_lock(umem->pgs, umem->npgs, true); =20 kfree(umem->pgs); umem->pgs =3D NULL; --=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 4AD09C33CB6 for ; Tue, 19 Nov 2019 08:17:51 +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 2D31D22319 for ; Tue, 19 Nov 2019 08:17:51 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 2D31D22319 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 EBA0A6E27F; Tue, 19 Nov 2019 08:17:42 +0000 (UTC) Received: from hqemgate16.nvidia.com (hqemgate16.nvidia.com [216.228.121.65]) by gabe.freedesktop.org (Postfix) with ESMTPS id A3E596EC99 for ; Tue, 19 Nov 2019 08:17:16 +0000 (UTC) Received: from hqpgpgate102.nvidia.com (Not Verified[216.228.121.13]) by hqemgate16.nvidia.com (using TLS: TLSv1.2, DES-CBC3-SHA) id ; Tue, 19 Nov 2019 00:17:16 -0800 Received: from hqmail.nvidia.com ([172.20.161.6]) by hqpgpgate102.nvidia.com (PGP Universal service); Tue, 19 Nov 2019 00:17:16 -0800 X-PGP-Universal: processed; by hqpgpgate102.nvidia.com on Tue, 19 Nov 2019 00:17:16 -0800 Received: from HQMAIL109.nvidia.com (172.20.187.15) by HQMAIL101.nvidia.com (172.20.187.10) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Tue, 19 Nov 2019 08:17:15 +0000 Received: from HQMAIL109.nvidia.com (172.20.187.15) by HQMAIL109.nvidia.com (172.20.187.15) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Tue, 19 Nov 2019 08:17:15 +0000 Received: from rnnvemgw01.nvidia.com (10.128.109.123) by HQMAIL109.nvidia.com (172.20.187.15) with Microsoft SMTP Server (TLS) id 15.0.1473.3 via Frontend Transport; Tue, 19 Nov 2019 08:17:14 +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:13 -0800 From: John Hubbard To: Andrew Morton Subject: [PATCH v6 24/24] mm, tree-wide: rename put_user_page*() to unpin_user_page*() Date: Tue, 19 Nov 2019 00:16:43 -0800 Message-ID: <20191119081643.1866232-25-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=1574151437; bh=MEfoBt+IiZ18Wgtp83kPA3LpPDKdQT5/Eab3lDhjAQc=; h=X-PGP-Universal:From:To:CC:Subject:Date:Message-ID:X-Mailer: In-Reply-To:References:MIME-Version:X-NVConfidentiality: Content-Transfer-Encoding:Content-Type; b=aeVxSY5gm5IcJdWiwfRgw51S1BP0HaTyt2fkHCtpIKjABn2BCXf33C+HIPt4vfVzv I1VPCH730m4uuy367P31K4BaO5OQuC1wt9qHIdlnmM9pdDHrRJ63sY2+jxLaa/27Bv 5hX8Ndh3uWu1P3bwaBr0TK0SaSeeoiGnq6qVeCfCGst6mfY+hSzxK2KJdbH9JyLTsh tLZs5Lgy+lK55cJGEQ2ZaYiL6GO/DEo/i3ZdRz9W6ccdz9krNF1t7YgPw0VYHHYzIF xILP1peASqVD57X55obP/iJbzvYka5T2db367iM6wVxcYRCUZqCR0LYyOiFBWBtJq7 CDbhpz/3AtaBA== 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: <20191119081643.jvCf3Dlazo9Ukw03KmBU2gmxvQDLCfHK4Fq6bWPfcOA@z> SW4gb3JkZXIgdG8gcHJvdmlkZSBhIGNsZWFyZXIsIG1vcmUgc3ltbWV0cmljIEFQSSBmb3IgcGlu bmluZwphbmQgdW5waW5uaW5nIERNQSBwYWdlcy4gVGhpcyB3YXksIHBpbl91c2VyX3BhZ2VzKigp IGNhbGxzCm1hdGNoIHVwIHdpdGggdW5waW5fdXNlcl9wYWdlcyooKSBjYWxscywgYW5kIHRoZSBB UEkgaXMgYSBsb3QKY2xvc2VyIHRvIGJlaW5nIHNlbGYtZXhwbGFuYXRvcnkuCgpTaWduZWQtb2Zm LWJ5OiBKb2huIEh1YmJhcmQgPGpodWJiYXJkQG52aWRpYS5jb20+Ci0tLQogRG9jdW1lbnRhdGlv bi9jb3JlLWFwaS9waW5fdXNlcl9wYWdlcy5yc3QgICB8ICAyICstCiBhcmNoL3Bvd2VycGMvbW0v Ym9vazNzNjQvaW9tbXVfYXBpLmMgICAgICAgIHwgIDYgKy0tCiBkcml2ZXJzL2dwdS9kcm0vdmlh L3ZpYV9kbWFibGl0LmMgICAgICAgICAgIHwgIDQgKy0KIGRyaXZlcnMvaW5maW5pYmFuZC9jb3Jl L3VtZW0uYyAgICAgICAgICAgICAgfCAgMiArLQogZHJpdmVycy9pbmZpbmliYW5kL2h3L2hmaTEv dXNlcl9wYWdlcy5jICAgICB8ICAyICstCiBkcml2ZXJzL2luZmluaWJhbmQvaHcvbXRoY2EvbXRo Y2FfbWVtZnJlZS5jIHwgIDYgKy0tCiBkcml2ZXJzL2luZmluaWJhbmQvaHcvcWliL3FpYl91c2Vy X3BhZ2VzLmMgIHwgIDIgKy0KIGRyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX3VzZXJfc2Rt YS5jICAgfCAgNiArLS0KIGRyaXZlcnMvaW5maW5pYmFuZC9ody91c25pYy91c25pY191aW9tLmMg ICAgfCAgMiArLQogZHJpdmVycy9pbmZpbmliYW5kL3N3L3Npdy9zaXdfbWVtLmMgICAgICAgICB8 ICAyICstCiBkcml2ZXJzL21lZGlhL3Y0bDItY29yZS92aWRlb2J1Zi1kbWEtc2cuYyAgIHwgIDQg Ky0KIGRyaXZlcnMvcGxhdGZvcm0vZ29sZGZpc2gvZ29sZGZpc2hfcGlwZS5jICAgfCAgNCArLQog ZHJpdmVycy92ZmlvL3ZmaW9faW9tbXVfdHlwZTEuYyAgICAgICAgICAgICB8ICAyICstCiBmcy9p b191cmluZy5jICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDQgKy0KIGluY2x1ZGUv bGludXgvbW0uaCAgICAgICAgICAgICAgICAgICAgICAgICAgfCAzMCArKysrKysrLS0tLS0tLQog aW5jbHVkZS9saW51eC9tbXpvbmUuaCAgICAgICAgICAgICAgICAgICAgICB8ICAyICstCiBtbS9n dXAuYyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgNDYgKysrKysrKysrKy0t LS0tLS0tLS0tCiBtbS9ndXBfYmVuY2htYXJrLmMgICAgICAgICAgICAgICAgICAgICAgICAgIHwg IDIgKy0KIG1tL3Byb2Nlc3Nfdm1fYWNjZXNzLmMgICAgICAgICAgICAgICAgICAgICAgfCAgNCAr LQogbmV0L3hkcC94ZHBfdW1lbS5jICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAyICstCiAy MCBmaWxlcyBjaGFuZ2VkLCA2NyBpbnNlcnRpb25zKCspLCA2NyBkZWxldGlvbnMoLSkKCmRpZmYg LS1naXQgYS9Eb2N1bWVudGF0aW9uL2NvcmUtYXBpL3Bpbl91c2VyX3BhZ2VzLnJzdCBiL0RvY3Vt ZW50YXRpb24vY29yZS1hcGkvcGluX3VzZXJfcGFnZXMucnN0CmluZGV4IGJhYTI4OGE0NGE3Ny4u NmQ5M2VmMjAzNTYxIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2NvcmUtYXBpL3Bpbl91c2Vy X3BhZ2VzLnJzdAorKysgYi9Eb2N1bWVudGF0aW9uL2NvcmUtYXBpL3Bpbl91c2VyX3BhZ2VzLnJz dApAQCAtMjIwLDcgKzIyMCw3IEBAIHNpbmNlIHRoZSBzeXN0ZW0gd2FzIGJvb3RlZCwgdmlhIHR3 byBuZXcgL3Byb2Mvdm1zdGF0IGVudHJpZXM6IDo6CiAgICAgL3Byb2Mvdm1zdGF0L25yX2ZvbGxf cGluX3JlcXVlc3RlZAogCiBUaG9zZSBhcmUgYm90aCBnb2luZyB0byBzaG93IHplcm8sIHVubGVz cyBDT05GSUdfREVCVUdfVk0gaXMgc2V0LiBUaGlzIGlzCi1iZWNhdXNlIHRoZXJlIGlzIGEgbm90 aWNlYWJsZSBwZXJmb3JtYW5jZSBkcm9wIGluIHB1dF91c2VyX3BhZ2UoKSwgd2hlbiB0aGV5Citi ZWNhdXNlIHRoZXJlIGlzIGEgbm90aWNlYWJsZSBwZXJmb3JtYW5jZSBkcm9wIGluIHVucGluX3Vz ZXJfcGFnZSgpLCB3aGVuIHRoZXkKIGFyZSBhY3RpdmF0ZWQuCiAKIFJlZmVyZW5jZXMKZGlmZiAt LWdpdCBhL2FyY2gvcG93ZXJwYy9tbS9ib29rM3M2NC9pb21tdV9hcGkuYyBiL2FyY2gvcG93ZXJw Yy9tbS9ib29rM3M2NC9pb21tdV9hcGkuYwppbmRleCAxOTYzODNlOGU1YTkuLmRkN2FhNWE0ZjMz YyAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL21tL2Jvb2szczY0L2lvbW11X2FwaS5jCisrKyBi L2FyY2gvcG93ZXJwYy9tbS9ib29rM3M2NC9pb21tdV9hcGkuYwpAQCAtMTY4LDcgKzE2OCw3IEBA IHN0YXRpYyBsb25nIG1tX2lvbW11X2RvX2FsbG9jKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCB1bnNp Z25lZCBsb25nIHVhLAogCiBmcmVlX2V4aXQ6CiAJLyogZnJlZSB0aGUgcmVmZXJlbmNlcyB0YWtl biAqLwotCXB1dF91c2VyX3BhZ2VzKG1lbS0+aHBhZ2VzLCBwaW5uZWQpOworCXVucGluX3VzZXJf cGFnZXMobWVtLT5ocGFnZXMsIHBpbm5lZCk7CiAKIAl2ZnJlZShtZW0tPmhwYXMpOwogCWtmcmVl KG1lbSk7CkBAIC0yMTEsOCArMjExLDggQEAgc3RhdGljIHZvaWQgbW1faW9tbXVfdW5waW4oc3Ry dWN0IG1tX2lvbW11X3RhYmxlX2dyb3VwX21lbV90ICptZW0pCiAJCWlmICghcGFnZSkKIAkJCWNv bnRpbnVlOwogCi0JCXB1dF91c2VyX3BhZ2VzX2RpcnR5X2xvY2soJm1lbS0+aHBhZ2VzW2ldLCAx LAotCQkJCQkgIE1NX0lPTU1VX1RBQkxFX0dST1VQX1BBR0VfRElSVFkpOworCQl1bnBpbl91c2Vy X3BhZ2VzX2RpcnR5X2xvY2soJm1lbS0+aHBhZ2VzW2ldLCAxLAorCQkJCQkgICAgTU1fSU9NTVVf VEFCTEVfR1JPVVBfUEFHRV9ESVJUWSk7CiAKIAkJbWVtLT5ocGFzW2ldID0gMDsKIAl9CmRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vdmlhL3ZpYV9kbWFibGl0LmMgYi9kcml2ZXJzL2dwdS9k cm0vdmlhL3ZpYV9kbWFibGl0LmMKaW5kZXggMzdjNWU1NzI5OTNhLi43MTlkMDM2YzkzODQgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS92aWEvdmlhX2RtYWJsaXQuYworKysgYi9kcml2ZXJz L2dwdS9kcm0vdmlhL3ZpYV9kbWFibGl0LmMKQEAgLTE4OCw4ICsxODgsOCBAQCB2aWFfZnJlZV9z Z19pbmZvKHN0cnVjdCBwY2lfZGV2ICpwZGV2LCBkcm1fdmlhX3NnX2luZm9fdCAqdnNnKQogCQlr ZnJlZSh2c2ctPmRlc2NfcGFnZXMpOwogCQkvKiBmYWxsIHRocm91Z2ggKi8KIAljYXNlIGRyX3Zp YV9wYWdlc19sb2NrZWQ6Ci0JCXB1dF91c2VyX3BhZ2VzX2RpcnR5X2xvY2sodnNnLT5wYWdlcywg dnNnLT5udW1fcGFnZXMsCi0JCQkJCSAgKHZzZy0+ZGlyZWN0aW9uID09IERNQV9GUk9NX0RFVklD RSkpOworCQl1bnBpbl91c2VyX3BhZ2VzX2RpcnR5X2xvY2sodnNnLT5wYWdlcywgdnNnLT5udW1f cGFnZXMsCisJCQkJCSAgICh2c2ctPmRpcmVjdGlvbiA9PSBETUFfRlJPTV9ERVZJQ0UpKTsKIAkJ LyogZmFsbCB0aHJvdWdoICovCiAJY2FzZSBkcl92aWFfcGFnZXNfYWxsb2M6CiAJCXZmcmVlKHZz Zy0+cGFnZXMpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvdW1lbS5jIGIv ZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvdW1lbS5jCmluZGV4IDJjMjg3Y2VkMzQzOS4uMTE5YTE0 N2RhOTA0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvY29yZS91bWVtLmMKKysrIGIv ZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvdW1lbS5jCkBAIC01NCw3ICs1NCw3IEBAIHN0YXRpYyB2 b2lkIF9faWJfdW1lbV9yZWxlYXNlKHN0cnVjdCBpYl9kZXZpY2UgKmRldiwgc3RydWN0IGliX3Vt ZW0gKnVtZW0sIGludCBkCiAKIAlmb3JfZWFjaF9zZ19wYWdlKHVtZW0tPnNnX2hlYWQuc2dsLCAm c2dfaXRlciwgdW1lbS0+c2dfbmVudHMsIDApIHsKIAkJcGFnZSA9IHNnX3BhZ2VfaXRlcl9wYWdl KCZzZ19pdGVyKTsKLQkJcHV0X3VzZXJfcGFnZXNfZGlydHlfbG9jaygmcGFnZSwgMSwgdW1lbS0+ d3JpdGFibGUgJiYgZGlydHkpOworCQl1bnBpbl91c2VyX3BhZ2VzX2RpcnR5X2xvY2soJnBhZ2Us IDEsIHVtZW0tPndyaXRhYmxlICYmIGRpcnR5KTsKIAl9CiAKIAlzZ19mcmVlX3RhYmxlKCZ1bWVt LT5zZ19oZWFkKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9oZmkxL3VzZXJf cGFnZXMuYyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9oZmkxL3VzZXJfcGFnZXMuYwppbmRleCA5 YTk0NzYxNzY1YzAuLjNiNTA1MDA2YzBhNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5k L2h3L2hmaTEvdXNlcl9wYWdlcy5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9oZmkxL3Vz ZXJfcGFnZXMuYwpAQCAtMTE4LDcgKzExOCw3IEBAIGludCBoZmkxX2FjcXVpcmVfdXNlcl9wYWdl cyhzdHJ1Y3QgbW1fc3RydWN0ICptbSwgdW5zaWduZWQgbG9uZyB2YWRkciwgc2l6ZV90IG5wCiB2 b2lkIGhmaTFfcmVsZWFzZV91c2VyX3BhZ2VzKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCBzdHJ1Y3Qg cGFnZSAqKnAsCiAJCQkgICAgIHNpemVfdCBucGFnZXMsIGJvb2wgZGlydHkpCiB7Ci0JcHV0X3Vz ZXJfcGFnZXNfZGlydHlfbG9jayhwLCBucGFnZXMsIGRpcnR5KTsKKwl1bnBpbl91c2VyX3BhZ2Vz X2RpcnR5X2xvY2socCwgbnBhZ2VzLCBkaXJ0eSk7CiAKIAlpZiAobW0pIHsgLyogZHVyaW5nIGNs b3NlIGFmdGVyIHNpZ25hbCwgbW0gY2FuIGJlIE5VTEwgKi8KIAkJYXRvbWljNjRfc3ViKG5wYWdl cywgJm1tLT5waW5uZWRfdm0pOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L210 aGNhL210aGNhX21lbWZyZWUuYyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9tdGhjYS9tdGhjYV9t ZW1mcmVlLmMKaW5kZXggODI2OWFiMDQwYzIxLi43OGE0OGFlYTNmYWYgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvaW5maW5pYmFuZC9ody9tdGhjYS9tdGhjYV9tZW1mcmVlLmMKKysrIGIvZHJpdmVycy9p bmZpbmliYW5kL2h3L210aGNhL210aGNhX21lbWZyZWUuYwpAQCAtNDgyLDcgKzQ4Miw3IEBAIGlu dCBtdGhjYV9tYXBfdXNlcl9kYihzdHJ1Y3QgbXRoY2FfZGV2ICpkZXYsIHN0cnVjdCBtdGhjYV91 YXIgKnVhciwKIAogCXJldCA9IHBjaV9tYXBfc2coZGV2LT5wZGV2LCAmZGJfdGFiLT5wYWdlW2ld Lm1lbSwgMSwgUENJX0RNQV9UT0RFVklDRSk7CiAJaWYgKHJldCA8IDApIHsKLQkJcHV0X3VzZXJf cGFnZShwYWdlc1swXSk7CisJCXVucGluX3VzZXJfcGFnZShwYWdlc1swXSk7CiAJCWdvdG8gb3V0 OwogCX0KIApAQCAtNDkwLDcgKzQ5MCw3IEBAIGludCBtdGhjYV9tYXBfdXNlcl9kYihzdHJ1Y3Qg bXRoY2FfZGV2ICpkZXYsIHN0cnVjdCBtdGhjYV91YXIgKnVhciwKIAkJCQkgbXRoY2FfdWFyY192 aXJ0KGRldiwgdWFyLCBpKSk7CiAJaWYgKHJldCkgewogCQlwY2lfdW5tYXBfc2coZGV2LT5wZGV2 LCAmZGJfdGFiLT5wYWdlW2ldLm1lbSwgMSwgUENJX0RNQV9UT0RFVklDRSk7Ci0JCXB1dF91c2Vy X3BhZ2Uoc2dfcGFnZSgmZGJfdGFiLT5wYWdlW2ldLm1lbSkpOworCQl1bnBpbl91c2VyX3BhZ2Uo c2dfcGFnZSgmZGJfdGFiLT5wYWdlW2ldLm1lbSkpOwogCQlnb3RvIG91dDsKIAl9CiAKQEAgLTU1 Niw3ICs1NTYsNyBAQCB2b2lkIG10aGNhX2NsZWFudXBfdXNlcl9kYl90YWIoc3RydWN0IG10aGNh X2RldiAqZGV2LCBzdHJ1Y3QgbXRoY2FfdWFyICp1YXIsCiAJCWlmIChkYl90YWItPnBhZ2VbaV0u dXZpcnQpIHsKIAkJCW10aGNhX1VOTUFQX0lDTShkZXYsIG10aGNhX3VhcmNfdmlydChkZXYsIHVh ciwgaSksIDEpOwogCQkJcGNpX3VubWFwX3NnKGRldi0+cGRldiwgJmRiX3RhYi0+cGFnZVtpXS5t ZW0sIDEsIFBDSV9ETUFfVE9ERVZJQ0UpOwotCQkJcHV0X3VzZXJfcGFnZShzZ19wYWdlKCZkYl90 YWItPnBhZ2VbaV0ubWVtKSk7CisJCQl1bnBpbl91c2VyX3BhZ2Uoc2dfcGFnZSgmZGJfdGFiLT5w YWdlW2ldLm1lbSkpOwogCQl9CiAJfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQv aHcvcWliL3FpYl91c2VyX3BhZ2VzLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvcWliL3FpYl91 c2VyX3BhZ2VzLmMKaW5kZXggN2ZjNGI1ZjgxZmNkLi4zNDJlMzE3MmNhNDAgMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvaW5maW5pYmFuZC9ody9xaWIvcWliX3VzZXJfcGFnZXMuYworKysgYi9kcml2ZXJz L2luZmluaWJhbmQvaHcvcWliL3FpYl91c2VyX3BhZ2VzLmMKQEAgLTQwLDcgKzQwLDcgQEAKIHN0 YXRpYyB2b2lkIF9fcWliX3JlbGVhc2VfdXNlcl9wYWdlcyhzdHJ1Y3QgcGFnZSAqKnAsIHNpemVf dCBudW1fcGFnZXMsCiAJCQkJICAgICBpbnQgZGlydHkpCiB7Ci0JcHV0X3VzZXJfcGFnZXNfZGly dHlfbG9jayhwLCBudW1fcGFnZXMsIGRpcnR5KTsKKwl1bnBpbl91c2VyX3BhZ2VzX2RpcnR5X2xv Y2socCwgbnVtX3BhZ2VzLCBkaXJ0eSk7CiB9CiAKIC8qKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9p bmZpbmliYW5kL2h3L3FpYi9xaWJfdXNlcl9zZG1hLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcv cWliL3FpYl91c2VyX3NkbWEuYwppbmRleCAxYTNjYzI5NTdlM2EuLmE2NzU5OWI1YTU1MCAxMDA2 NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L3FpYi9xaWJfdXNlcl9zZG1hLmMKKysrIGIv ZHJpdmVycy9pbmZpbmliYW5kL2h3L3FpYi9xaWJfdXNlcl9zZG1hLmMKQEAgLTMxNyw3ICszMTcs NyBAQCBzdGF0aWMgaW50IHFpYl91c2VyX3NkbWFfcGFnZV90b19mcmFncyhjb25zdCBzdHJ1Y3Qg cWliX2RldmRhdGEgKmRkLAogCQkgKiB0aGUgY2FsbGVyIGNhbiBpZ25vcmUgdGhpcyBwYWdlLgog CQkgKi8KIAkJaWYgKHB1dCkgewotCQkJcHV0X3VzZXJfcGFnZShwYWdlKTsKKwkJCXVucGluX3Vz ZXJfcGFnZShwYWdlKTsKIAkJfSBlbHNlIHsKIAkJCS8qIGNvYWxlc2NlIGNhc2UgKi8KIAkJCWt1 bm1hcChwYWdlKTsKQEAgLTYzMSw3ICs2MzEsNyBAQCBzdGF0aWMgdm9pZCBxaWJfdXNlcl9zZG1h X2ZyZWVfcGt0X2ZyYWcoc3RydWN0IGRldmljZSAqZGV2LAogCQkJa3VubWFwKHBrdC0+YWRkcltp XS5wYWdlKTsKIAogCQlpZiAocGt0LT5hZGRyW2ldLnB1dF9wYWdlKQotCQkJcHV0X3VzZXJfcGFn ZShwa3QtPmFkZHJbaV0ucGFnZSk7CisJCQl1bnBpbl91c2VyX3BhZ2UocGt0LT5hZGRyW2ldLnBh Z2UpOwogCQllbHNlCiAJCQlfX2ZyZWVfcGFnZShwa3QtPmFkZHJbaV0ucGFnZSk7CiAJfSBlbHNl IGlmIChwa3QtPmFkZHJbaV0ua3ZhZGRyKSB7CkBAIC03MDYsNyArNzA2LDcgQEAgc3RhdGljIGlu dCBxaWJfdXNlcl9zZG1hX3Bpbl9wYWdlcyhjb25zdCBzdHJ1Y3QgcWliX2RldmRhdGEgKmRkLAog CS8qIGlmIGVycm9yLCByZXR1cm4gYWxsIHBhZ2VzIG5vdCBtYW5hZ2VkIGJ5IHBrdCAqLwogZnJl ZV9wYWdlczoKIAl3aGlsZSAoaSA8IGopCi0JCXB1dF91c2VyX3BhZ2UocGFnZXNbaSsrXSk7CisJ CXVucGluX3VzZXJfcGFnZShwYWdlc1tpKytdKTsKIAogZG9uZToKIAlyZXR1cm4gcmV0OwpkaWZm IC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L3VzbmljL3VzbmljX3Vpb20uYyBiL2RyaXZl cnMvaW5maW5pYmFuZC9ody91c25pYy91c25pY191aW9tLmMKaW5kZXggNjAwODk2NzI3ZDM0Li5i ZDlmOTQ0YjY4ZmMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody91c25pYy91c25p Y191aW9tLmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L3VzbmljL3VzbmljX3Vpb20uYwpA QCAtNzUsNyArNzUsNyBAQCBzdGF0aWMgdm9pZCB1c25pY191aW9tX3B1dF9wYWdlcyhzdHJ1Y3Qg bGlzdF9oZWFkICpjaHVua19saXN0LCBpbnQgZGlydHkpCiAJCWZvcl9lYWNoX3NnKGNodW5rLT5w YWdlX2xpc3QsIHNnLCBjaHVuay0+bmVudHMsIGkpIHsKIAkJCXBhZ2UgPSBzZ19wYWdlKHNnKTsK IAkJCXBhID0gc2dfcGh5cyhzZyk7Ci0JCQlwdXRfdXNlcl9wYWdlc19kaXJ0eV9sb2NrKCZwYWdl LCAxLCBkaXJ0eSk7CisJCQl1bnBpbl91c2VyX3BhZ2VzX2RpcnR5X2xvY2soJnBhZ2UsIDEsIGRp cnR5KTsKIAkJCXVzbmljX2RiZygicGE6ICVwYVxuIiwgJnBhKTsKIAkJfQogCQlrZnJlZShjaHVu ayk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvc3cvc2l3L3Npd19tZW0uYyBiL2Ry aXZlcnMvaW5maW5pYmFuZC9zdy9zaXcvc2l3X21lbS5jCmluZGV4IGU1M2IwN2RjZmVkNS4uZTIw NjFkYzBiMDQzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvc3cvc2l3L3Npd19tZW0u YworKysgYi9kcml2ZXJzL2luZmluaWJhbmQvc3cvc2l3L3Npd19tZW0uYwpAQCAtNjMsNyArNjMs NyBAQCBzdHJ1Y3Qgc2l3X21lbSAqc2l3X21lbV9pZDJvYmooc3RydWN0IHNpd19kZXZpY2UgKnNk ZXYsIGludCBzdGFnX2luZGV4KQogc3RhdGljIHZvaWQgc2l3X2ZyZWVfcGxpc3Qoc3RydWN0IHNp d19wYWdlX2NodW5rICpjaHVuaywgaW50IG51bV9wYWdlcywKIAkJCSAgIGJvb2wgZGlydHkpCiB7 Ci0JcHV0X3VzZXJfcGFnZXNfZGlydHlfbG9jayhjaHVuay0+cGxpc3QsIG51bV9wYWdlcywgZGly dHkpOworCXVucGluX3VzZXJfcGFnZXNfZGlydHlfbG9jayhjaHVuay0+cGxpc3QsIG51bV9wYWdl cywgZGlydHkpOwogfQogCiB2b2lkIHNpd191bWVtX3JlbGVhc2Uoc3RydWN0IHNpd191bWVtICp1 bWVtLCBib29sIGRpcnR5KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92NGwyLWNvcmUvdmlk ZW9idWYtZG1hLXNnLmMgYi9kcml2ZXJzL21lZGlhL3Y0bDItY29yZS92aWRlb2J1Zi1kbWEtc2cu YwppbmRleCAxNjJhMjYzM2IxZTMuLjEzYjY1ZWQ5ZTc0YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9t ZWRpYS92NGwyLWNvcmUvdmlkZW9idWYtZG1hLXNnLmMKKysrIGIvZHJpdmVycy9tZWRpYS92NGwy LWNvcmUvdmlkZW9idWYtZG1hLXNnLmMKQEAgLTM0OSw4ICszNDksOCBAQCBpbnQgdmlkZW9idWZf ZG1hX2ZyZWUoc3RydWN0IHZpZGVvYnVmX2RtYWJ1ZiAqZG1hKQogCUJVR19PTihkbWEtPnNnbGVu KTsKIAogCWlmIChkbWEtPnBhZ2VzKSB7Ci0JCXB1dF91c2VyX3BhZ2VzX2RpcnR5X2xvY2soZG1h LT5wYWdlcywgZG1hLT5ucl9wYWdlcywKLQkJCQkJICBkbWEtPmRpcmVjdGlvbiA9PSBETUFfRlJP TV9ERVZJQ0UpOworCQl1bnBpbl91c2VyX3BhZ2VzX2RpcnR5X2xvY2soZG1hLT5wYWdlcywgZG1h LT5ucl9wYWdlcywKKwkJCQkJICAgIGRtYS0+ZGlyZWN0aW9uID09IERNQV9GUk9NX0RFVklDRSk7 CiAJCWtmcmVlKGRtYS0+cGFnZXMpOwogCQlkbWEtPnBhZ2VzID0gTlVMTDsKIAl9CmRpZmYgLS1n aXQgYS9kcml2ZXJzL3BsYXRmb3JtL2dvbGRmaXNoL2dvbGRmaXNoX3BpcGUuYyBiL2RyaXZlcnMv cGxhdGZvcm0vZ29sZGZpc2gvZ29sZGZpc2hfcGlwZS5jCmluZGV4IDYzNWE4YmMxYjQ4MC4uYmY1 MjNkZjJhOTBkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BsYXRmb3JtL2dvbGRmaXNoL2dvbGRmaXNo X3BpcGUuYworKysgYi9kcml2ZXJzL3BsYXRmb3JtL2dvbGRmaXNoL2dvbGRmaXNoX3BpcGUuYwpA QCAtMzYwLDggKzM2MCw4IEBAIHN0YXRpYyBpbnQgdHJhbnNmZXJfbWF4X2J1ZmZlcnMoc3RydWN0 IGdvbGRmaXNoX3BpcGUgKnBpcGUsCiAKIAkqY29uc3VtZWRfc2l6ZSA9IHBpcGUtPmNvbW1hbmRf YnVmZmVyLT5yd19wYXJhbXMuY29uc3VtZWRfc2l6ZTsKIAotCXB1dF91c2VyX3BhZ2VzX2RpcnR5 X2xvY2socGlwZS0+cGFnZXMsIHBhZ2VzX2NvdW50LAotCQkJCSAgIWlzX3dyaXRlICYmICpjb25z dW1lZF9zaXplID4gMCk7CisJdW5waW5fdXNlcl9wYWdlc19kaXJ0eV9sb2NrKHBpcGUtPnBhZ2Vz LCBwYWdlc19jb3VudCwKKwkJCQkgICAgIWlzX3dyaXRlICYmICpjb25zdW1lZF9zaXplID4gMCk7 CiAKIAltdXRleF91bmxvY2soJnBpcGUtPmxvY2spOwogCXJldHVybiAwOwpkaWZmIC0tZ2l0IGEv ZHJpdmVycy92ZmlvL3ZmaW9faW9tbXVfdHlwZTEuYyBiL2RyaXZlcnMvdmZpby92ZmlvX2lvbW11 X3R5cGUxLmMKaW5kZXggMThhYTM2YjU2ODk2Li5jNDhhYzE1NjdmMTQgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvdmZpby92ZmlvX2lvbW11X3R5cGUxLmMKKysrIGIvZHJpdmVycy92ZmlvL3ZmaW9faW9t bXVfdHlwZTEuYwpAQCAtMzI4LDcgKzMyOCw3IEBAIHN0YXRpYyBpbnQgcHV0X3Bmbih1bnNpZ25l ZCBsb25nIHBmbiwgaW50IHByb3QpCiAJaWYgKCFpc19pbnZhbGlkX3Jlc2VydmVkX3BmbihwZm4p KSB7CiAJCXN0cnVjdCBwYWdlICpwYWdlID0gcGZuX3RvX3BhZ2UocGZuKTsKIAotCQlwdXRfdXNl cl9wYWdlc19kaXJ0eV9sb2NrKCZwYWdlLCAxLCBwcm90ICYgSU9NTVVfV1JJVEUpOworCQl1bnBp bl91c2VyX3BhZ2VzX2RpcnR5X2xvY2soJnBhZ2UsIDEsIHByb3QgJiBJT01NVV9XUklURSk7CiAJ CXJldHVybiAxOwogCX0KIAlyZXR1cm4gMDsKZGlmZiAtLWdpdCBhL2ZzL2lvX3VyaW5nLmMgYi9m cy9pb191cmluZy5jCmluZGV4IDE1NzE1ZWVlYmFlYy4uMDI1M2E0ZDhmZGM4IDEwMDY0NAotLS0g YS9mcy9pb191cmluZy5jCisrKyBiL2ZzL2lvX3VyaW5nLmMKQEAgLTMzMjgsNyArMzMyOCw3IEBA IHN0YXRpYyBpbnQgaW9fc3FlX2J1ZmZlcl91bnJlZ2lzdGVyKHN0cnVjdCBpb19yaW5nX2N0eCAq Y3R4KQogCQlzdHJ1Y3QgaW9fbWFwcGVkX3VidWYgKmltdSA9ICZjdHgtPnVzZXJfYnVmc1tpXTsK IAogCQlmb3IgKGogPSAwOyBqIDwgaW11LT5ucl9idmVjczsgaisrKQotCQkJcHV0X3VzZXJfcGFn ZShpbXUtPmJ2ZWNbal0uYnZfcGFnZSk7CisJCQl1bnBpbl91c2VyX3BhZ2UoaW11LT5idmVjW2pd LmJ2X3BhZ2UpOwogCiAJCWlmIChjdHgtPmFjY291bnRfbWVtKQogCQkJaW9fdW5hY2NvdW50X21l bShjdHgtPnVzZXIsIGltdS0+bnJfYnZlY3MpOwpAQCAtMzQ3Myw3ICszNDczLDcgQEAgc3RhdGlj IGludCBpb19zcWVfYnVmZmVyX3JlZ2lzdGVyKHN0cnVjdCBpb19yaW5nX2N0eCAqY3R4LCB2b2lk IF9fdXNlciAqYXJnLAogCQkJICogcmVsZWFzZSBhbnkgcGFnZXMgd2UgZGlkIGdldAogCQkJICov CiAJCQlpZiAocHJldCA+IDApCi0JCQkJcHV0X3VzZXJfcGFnZXMocGFnZXMsIHByZXQpOworCQkJ CXVucGluX3VzZXJfcGFnZXMocGFnZXMsIHByZXQpOwogCQkJaWYgKGN0eC0+YWNjb3VudF9tZW0p CiAJCQkJaW9fdW5hY2NvdW50X21lbShjdHgtPnVzZXIsIG5yX3BhZ2VzKTsKIAkJCWt2ZnJlZShp bXUtPmJ2ZWMpOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tbS5oIGIvaW5jbHVkZS9saW51 eC9tbS5oCmluZGV4IGFiMzExYjM1NmFiMS4uNzc1ZjZhM2Q2MTViIDEwMDY0NAotLS0gYS9pbmNs dWRlL2xpbnV4L21tLmgKKysrIGIvaW5jbHVkZS9saW51eC9tbS5oCkBAIC0xMDkzLDE4ICsxMDkz LDE4IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBwdXRfcGFnZShzdHJ1Y3QgcGFnZSAqcGFnZSkKICAq IG1hZGUgYWdhaW5zdCB0aGUgcGFnZS4gKCJndXAtcGlubmVkIiBpcyBhbm90aGVyIHRlcm0gZm9y IHRoZSBsYXR0ZXIpLgogICoKICAqIFdpdGggdGhpcyBzY2hlbWUsIHBpbl91c2VyX3BhZ2VzKCkg YmVjb21lcyBzcGVjaWFsOiBzdWNoIHBhZ2VzIGFyZSBtYXJrZWQgYXMKLSAqIGRpc3RpbmN0IGZy b20gbm9ybWFsIHBhZ2VzLiBBcyBzdWNoLCB0aGUgcHV0X3VzZXJfcGFnZSgpIGNhbGwgKGFuZCBp dHMKKyAqIGRpc3RpbmN0IGZyb20gbm9ybWFsIHBhZ2VzLiBBcyBzdWNoLCB0aGUgdW5waW5fdXNl cl9wYWdlKCkgY2FsbCAoYW5kIGl0cwogICogdmFyaWFudHMpIG11c3QgYmUgdXNlZCBpbiBvcmRl ciB0byByZWxlYXNlIGd1cC1waW5uZWQgcGFnZXMuCiAgKgogICogQ2hvaWNlIG9mIHZhbHVlOgog ICoKICAqIEJ5IG1ha2luZyBHVVBfUElOX0NPVU5USU5HX0JJQVMgYSBwb3dlciBvZiB0d28sIGRl YnVnZ2luZyBvZiBwYWdlIHJlZmVyZW5jZQotICogY291bnRzIHdpdGggcmVzcGVjdCB0byBwaW5f dXNlcl9wYWdlcygpIGFuZCBwdXRfdXNlcl9wYWdlKCkgYmVjb21lcyBzaW1wbGVyLAotICogZHVl IHRvIHRoZSBmYWN0IHRoYXQgYWRkaW5nIGFuIGV2ZW4gcG93ZXIgb2YgdHdvIHRvIHRoZSBwYWdl IHJlZmNvdW50IGhhcyB0aGUKLSAqIGVmZmVjdCBvZiB1c2luZyBvbmx5IHRoZSB1cHBlciBOIGJp dHMsIGZvciB0aGUgY29kZSB0aGF0IGNvdW50cyB1cCB1c2luZyB0aGUKLSAqIGJpYXMgdmFsdWUu IFRoaXMgbWVhbnMgdGhhdCB0aGUgbG93ZXIgYml0cyBhcmUgbGVmdCBmb3IgdGhlIGV4Y2x1c2l2 ZSB1c2Ugb2YKLSAqIHRoZSBvcmlnaW5hbCBjb2RlIHRoYXQgaW5jcmVtZW50cyBhbmQgZGVjcmVt ZW50cyBieSBvbmUgKG9yIGF0IGxlYXN0LCBieSBtdWNoCi0gKiBzbWFsbGVyIHZhbHVlcyB0aGFu IHRoZSBiaWFzIHZhbHVlKS4KKyAqIGNvdW50cyB3aXRoIHJlc3BlY3QgdG8gcGluX3VzZXJfcGFn ZXMoKSBhbmQgdW5waW5fdXNlcl9wYWdlKCkgYmVjb21lcworICogc2ltcGxlciwgZHVlIHRvIHRo ZSBmYWN0IHRoYXQgYWRkaW5nIGFuIGV2ZW4gcG93ZXIgb2YgdHdvIHRvIHRoZSBwYWdlCisgKiBy ZWZjb3VudCBoYXMgdGhlIGVmZmVjdCBvZiB1c2luZyBvbmx5IHRoZSB1cHBlciBOIGJpdHMsIGZv ciB0aGUgY29kZSB0aGF0CisgKiBjb3VudHMgdXAgdXNpbmcgdGhlIGJpYXMgdmFsdWUuIFRoaXMg bWVhbnMgdGhhdCB0aGUgbG93ZXIgYml0cyBhcmUgbGVmdCBmb3IKKyAqIHRoZSBleGNsdXNpdmUg dXNlIG9mIHRoZSBvcmlnaW5hbCBjb2RlIHRoYXQgaW5jcmVtZW50cyBhbmQgZGVjcmVtZW50cyBi eSBvbmUKKyAqIChvciBhdCBsZWFzdCwgYnkgbXVjaCBzbWFsbGVyIHZhbHVlcyB0aGFuIHRoZSBi aWFzIHZhbHVlKS4KICAqCiAgKiBPZiBjb3Vyc2UsIG9uY2UgdGhlIGxvd2VyIGJpdHMgb3ZlcmZs b3cgaW50byB0aGUgdXBwZXIgYml0cyAoYW5kIHRoaXMgaXMKICAqIE9LLCBiZWNhdXNlIHN1YnRy YWN0aW9uIHJlY292ZXJzIHRoZSBvcmlnaW5hbCB2YWx1ZXMpLCB0aGVuIHZpc3VhbCBpbnNwZWN0 aW9uCkBAIC0xMTE5LDEwICsxMTE5LDEwIEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBwdXRfcGFnZShz dHJ1Y3QgcGFnZSAqcGFnZSkKICAqLwogI2RlZmluZSBHVVBfUElOX0NPVU5USU5HX0JJQVMgKDFV TCA8PCAxMCkKIAotdm9pZCBwdXRfdXNlcl9wYWdlKHN0cnVjdCBwYWdlICpwYWdlKTsKLXZvaWQg cHV0X3VzZXJfcGFnZXNfZGlydHlfbG9jayhzdHJ1Y3QgcGFnZSAqKnBhZ2VzLCB1bnNpZ25lZCBs b25nIG5wYWdlcywKLQkJCSAgICAgICBib29sIG1ha2VfZGlydHkpOwotdm9pZCBwdXRfdXNlcl9w YWdlcyhzdHJ1Y3QgcGFnZSAqKnBhZ2VzLCB1bnNpZ25lZCBsb25nIG5wYWdlcyk7Cit2b2lkIHVu cGluX3VzZXJfcGFnZShzdHJ1Y3QgcGFnZSAqcGFnZSk7Cit2b2lkIHVucGluX3VzZXJfcGFnZXNf ZGlydHlfbG9jayhzdHJ1Y3QgcGFnZSAqKnBhZ2VzLCB1bnNpZ25lZCBsb25nIG5wYWdlcywKKwkJ CQkgYm9vbCBtYWtlX2RpcnR5KTsKK3ZvaWQgdW5waW5fdXNlcl9wYWdlcyhzdHJ1Y3QgcGFnZSAq KnBhZ2VzLCB1bnNpZ25lZCBsb25nIG5wYWdlcyk7CiAKIC8qKgogICogcGFnZV9kbWFfcGlubmVk KCkgLSByZXBvcnQgaWYgYSBwYWdlIGlzIHBpbm5lZCBmb3IgRE1BLgpAQCAtMjY3Myw3ICsyNjcz LDcgQEAgc3RydWN0IHBhZ2UgKmZvbGxvd19wYWdlKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1h LCB1bnNpZ25lZCBsb25nIGFkZHJlc3MsCiAjZGVmaW5lIEZPTExfQU5PTgkweDgwMDAJLyogZG9u J3QgZG8gZmlsZSBtYXBwaW5ncyAqLwogI2RlZmluZSBGT0xMX0xPTkdURVJNCTB4MTAwMDAJLyog bWFwcGluZyBsaWZldGltZSBpcyBpbmRlZmluaXRlOiBzZWUgYmVsb3cgKi8KICNkZWZpbmUgRk9M TF9TUExJVF9QTUQJMHgyMDAwMAkvKiBzcGxpdCBodWdlIHBtZCBiZWZvcmUgcmV0dXJuaW5nICov Ci0jZGVmaW5lIEZPTExfUElOCTB4NDAwMDAJLyogcGFnZXMgbXVzdCBiZSByZWxlYXNlZCB2aWEg cHV0X3VzZXJfcGFnZSgpICovCisjZGVmaW5lIEZPTExfUElOCTB4NDAwMDAJLyogcGFnZXMgbXVz dCBiZSByZWxlYXNlZCB2aWEgdW5waW5fdXNlcl9wYWdlICovCiAKIC8qCiAgKiBGT0xMX1BJTiBh bmQgRk9MTF9MT05HVEVSTSBtYXkgYmUgdXNlZCBpbiB2YXJpb3VzIGNvbWJpbmF0aW9ucyB3aXRo IGVhY2gKQEAgLTI3MDgsNyArMjcwOCw3IEBAIHN0cnVjdCBwYWdlICpmb2xsb3dfcGFnZShzdHJ1 Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwgdW5zaWduZWQgbG9uZyBhZGRyZXNzLAogICogRGlyZWN0 IElPKS4gVGhpcyBsZXRzIHRoZSBmaWxlc3lzdGVtIGtub3cgdGhhdCBzb21lIG5vbi1maWxlLXN5 c3RlbSBlbnRpdHkgaXMKICAqIHBvdGVudGlhbGx5IGNoYW5naW5nIHRoZSBwYWdlcycgZGF0YS4g SW4gY29udHJhc3QgdG8gRk9MTF9HRVQgKHdob3NlIHBhZ2VzCiAgKiBhcmUgcmVsZWFzZWQgdmlh IHB1dF9wYWdlKCkpLCBGT0xMX1BJTiBwYWdlcyBtdXN0IGJlIHJlbGVhc2VkLCB1bHRpbWF0ZWx5 LCBieQotICogYSBjYWxsIHRvIHB1dF91c2VyX3BhZ2UoKS4KKyAqIGEgY2FsbCB0byB1bnBpbl91 c2VyX3BhZ2UoKS4KICAqCiAgKiBGT0xMX1BJTiBpcyBzaW1pbGFyIHRvIEZPTExfR0VUOiBib3Ro IG9mIHRoZXNlIHBpbiBwYWdlcy4gVGhleSB1c2UgZGlmZmVyZW50CiAgKiBhbmQgc2VwYXJhdGUg cmVmY291bnRpbmcgbWVjaGFuaXNtcywgaG93ZXZlciwgYW5kIHRoYXQgbWVhbnMgdGhhdCBlYWNo IGhhcwpAQCAtMjcxNiw3ICsyNzE2LDcgQEAgc3RydWN0IHBhZ2UgKmZvbGxvd19wYWdlKHN0cnVj dCB2bV9hcmVhX3N0cnVjdCAqdm1hLCB1bnNpZ25lZCBsb25nIGFkZHJlc3MsCiAgKgogICogICAg IEZPTExfR0VUOiBnZXRfdXNlcl9wYWdlcyooKSB0byBhY3F1aXJlLCBhbmQgcHV0X3BhZ2UoKSB0 byByZWxlYXNlLgogICoKLSAqICAgICBGT0xMX1BJTjogcGluX3VzZXJfcGFnZXMqKCkgdG8gYWNx dWlyZSwgYW5kIHB1dF91c2VyX3BhZ2VzIHRvIHJlbGVhc2UuCisgKiAgICAgRk9MTF9QSU46IHBp bl91c2VyX3BhZ2VzKigpIHRvIGFjcXVpcmUsIGFuZCB1bnBpbl91c2VyX3BhZ2VzIHRvIHJlbGVh c2UuCiAgKgogICogRk9MTF9QSU4gYW5kIEZPTExfR0VUIGFyZSBtdXR1YWxseSBleGNsdXNpdmUg Zm9yIGEgZ2l2ZW4gZnVuY3Rpb24gY2FsbC4KICAqIChUaGUgdW5kZXJseWluZyBwYWdlcyBtYXkg ZXhwZXJpZW5jZSBib3RoIEZPTExfR0VULWJhc2VkIGFuZCBGT0xMX1BJTi1iYXNlZApAQCAtMjcy Niw3ICsyNzI2LDcgQEAgc3RydWN0IHBhZ2UgKmZvbGxvd19wYWdlKHN0cnVjdCB2bV9hcmVhX3N0 cnVjdCAqdm1hLCB1bnNpZ25lZCBsb25nIGFkZHJlc3MsCiAgKiBGT0xMX1BJTiBzaG91bGQgYmUg c2V0IGludGVybmFsbHkgYnkgdGhlIHBpbl91c2VyX3BhZ2VzKigpIEFQSXMsIG5ldmVyCiAgKiBk aXJlY3RseSBieSB0aGUgY2FsbGVyLiBUaGF0J3MgaW4gb3JkZXIgdG8gaGVscCBhdm9pZCBtaXNt YXRjaGVzIHdoZW4KICAqIHJlbGVhc2luZyBwYWdlczogZ2V0X3VzZXJfcGFnZXMqKCkgcGFnZXMg bXVzdCBiZSByZWxlYXNlZCB2aWEgcHV0X3BhZ2UoKSwKLSAqIHdoaWxlIHBpbl91c2VyX3BhZ2Vz KigpIHBhZ2VzIG11c3QgYmUgcmVsZWFzZWQgdmlhIHB1dF91c2VyX3BhZ2UoKS4KKyAqIHdoaWxl IHBpbl91c2VyX3BhZ2VzKigpIHBhZ2VzIG11c3QgYmUgcmVsZWFzZWQgdmlhIHVucGluX3VzZXJf cGFnZSgpLgogICoKICAqIFBsZWFzZSBzZWUgRG9jdW1lbnRhdGlvbi92bS9waW5fdXNlcl9wYWdl cy5yc3QgZm9yIG1vcmUgaW5mb3JtYXRpb24uCiAgKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGlu dXgvbW16b25lLmggYi9pbmNsdWRlL2xpbnV4L21tem9uZS5oCmluZGV4IDA0ODVjYmEzOGQyMy4u ZDY2YzFmYjlkNDVlIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L21tem9uZS5oCisrKyBiL2lu Y2x1ZGUvbGludXgvbW16b25lLmgKQEAgLTI0NSw3ICsyNDUsNyBAQCBlbnVtIG5vZGVfc3RhdF9p dGVtIHsKIAlOUl9XUklUVEVOLAkJLyogcGFnZSB3cml0aW5ncyBzaW5jZSBib290dXAgKi8KIAlO Ul9LRVJORUxfTUlTQ19SRUNMQUlNQUJMRSwJLyogcmVjbGFpbWFibGUgbm9uLXNsYWIga2VybmVs IHBhZ2VzICovCiAJTlJfRk9MTF9QSU5fUkVRVUVTVEVELAkvKiB2aWE6IHBpbl91c2VyX3BhZ2Uo KSwgZ3VwIGZsYWc6IEZPTExfUElOICovCi0JTlJfRk9MTF9QSU5fUkVUVVJORUQsCS8qIHBhZ2Vz IHJldHVybmVkIHZpYSBwdXRfdXNlcl9wYWdlKCkgKi8KKwlOUl9GT0xMX1BJTl9SRVRVUk5FRCwJ LyogcGFnZXMgcmV0dXJuZWQgdmlhIHVucGluX3VzZXJfcGFnZSgpICovCiAJTlJfVk1fTk9ERV9T VEFUX0lURU1TCiB9OwogCmRpZmYgLS1naXQgYS9tbS9ndXAuYyBiL21tL2d1cC5jCmluZGV4IDAw MjgxNjUyNjY3MC4uY2ViYWYyZDAyZjU5IDEwMDY0NAotLS0gYS9tbS9ndXAuYworKysgYi9tbS9n dXAuYwpAQCAtMTEzLDE1ICsxMTMsMTUgQEAgc3RhdGljIGJvb2wgX19wdXRfZGV2bWFwX21hbmFn ZWRfdXNlcl9wYWdlKHN0cnVjdCBwYWdlICpwYWdlKQogI2VuZGlmIC8qIENPTkZJR19ERVZfUEFH RU1BUF9PUFMgKi8KIAogLyoqCi0gKiBwdXRfdXNlcl9wYWdlKCkgLSByZWxlYXNlIGEgZG1hLXBp bm5lZCBwYWdlCisgKiB1bnBpbl91c2VyX3BhZ2UoKSAtIHJlbGVhc2UgYSBkbWEtcGlubmVkIHBh Z2UKICAqIEBwYWdlOiAgICAgICAgICAgIHBvaW50ZXIgdG8gcGFnZSB0byBiZSByZWxlYXNlZAog ICoKICAqIFBhZ2VzIHRoYXQgd2VyZSBwaW5uZWQgdmlhIHBpbl91c2VyX3BhZ2VzKigpIG11c3Qg YmUgcmVsZWFzZWQgdmlhIGVpdGhlcgotICogcHV0X3VzZXJfcGFnZSgpLCBvciBvbmUgb2YgdGhl IHB1dF91c2VyX3BhZ2VzKigpIHJvdXRpbmVzLiBUaGlzIGlzIHNvIHRoYXQKLSAqIHN1Y2ggcGFn ZXMgY2FuIGJlIHNlcGFyYXRlbHkgdHJhY2tlZCBhbmQgdW5pcXVlbHkgaGFuZGxlZC4gSW4gcGFy dGljdWxhciwKLSAqIGludGVyYWN0aW9ucyB3aXRoIFJETUEgYW5kIGZpbGVzeXN0ZW1zIG5lZWQg c3BlY2lhbCBoYW5kbGluZy4KKyAqIHVucGluX3VzZXJfcGFnZSgpLCBvciBvbmUgb2YgdGhlIHVu cGluX3VzZXJfcGFnZXMqKCkgcm91dGluZXMuIFRoaXMgaXMgc28KKyAqIHRoYXQgc3VjaCBwYWdl cyBjYW4gYmUgc2VwYXJhdGVseSB0cmFja2VkIGFuZCB1bmlxdWVseSBoYW5kbGVkLiBJbgorICog cGFydGljdWxhciwgaW50ZXJhY3Rpb25zIHdpdGggUkRNQSBhbmQgZmlsZXN5c3RlbXMgbmVlZCBz cGVjaWFsIGhhbmRsaW5nLgogICovCi12b2lkIHB1dF91c2VyX3BhZ2Uoc3RydWN0IHBhZ2UgKnBh Z2UpCit2b2lkIHVucGluX3VzZXJfcGFnZShzdHJ1Y3QgcGFnZSAqcGFnZSkKIHsKIAlwYWdlID0g Y29tcG91bmRfaGVhZChwYWdlKTsKIApAQCAtMTM5LDEwICsxMzksMTAgQEAgdm9pZCBwdXRfdXNl cl9wYWdlKHN0cnVjdCBwYWdlICpwYWdlKQogCiAJX191cGRhdGVfcHJvY192bXN0YXQocGFnZSwg TlJfRk9MTF9QSU5fUkVUVVJORUQsIDEpOwogfQotRVhQT1JUX1NZTUJPTChwdXRfdXNlcl9wYWdl KTsKK0VYUE9SVF9TWU1CT0wodW5waW5fdXNlcl9wYWdlKTsKIAogLyoqCi0gKiBwdXRfdXNlcl9w YWdlc19kaXJ0eV9sb2NrKCkgLSByZWxlYXNlIGFuZCBvcHRpb25hbGx5IGRpcnR5IGd1cC1waW5u ZWQgcGFnZXMKKyAqIHVucGluX3VzZXJfcGFnZXNfZGlydHlfbG9jaygpIC0gcmVsZWFzZSBhbmQg b3B0aW9uYWxseSBkaXJ0eSBndXAtcGlubmVkIHBhZ2VzCiAgKiBAcGFnZXM6ICBhcnJheSBvZiBw YWdlcyB0byBiZSBtYXliZSBtYXJrZWQgZGlydHksIGFuZCBkZWZpbml0ZWx5IHJlbGVhc2VkLgog ICogQG5wYWdlczogbnVtYmVyIG9mIHBhZ2VzIGluIHRoZSBAcGFnZXMgYXJyYXkuCiAgKiBAbWFr ZV9kaXJ0eTogd2hldGhlciB0byBtYXJrIHRoZSBwYWdlcyBkaXJ0eQpAQCAtMTUyLDE5ICsxNTIs MTkgQEAgRVhQT1JUX1NZTUJPTChwdXRfdXNlcl9wYWdlKTsKICAqCiAgKiBGb3IgZWFjaCBwYWdl IGluIHRoZSBAcGFnZXMgYXJyYXksIG1ha2UgdGhhdCBwYWdlIChvciBpdHMgaGVhZCBwYWdlLCBp ZiBhCiAgKiBjb21wb3VuZCBwYWdlKSBkaXJ0eSwgaWYgQG1ha2VfZGlydHkgaXMgdHJ1ZSwgYW5k IGlmIHRoZSBwYWdlIHdhcyBwcmV2aW91c2x5Ci0gKiBsaXN0ZWQgYXMgY2xlYW4uIEluIGFueSBj YXNlLCByZWxlYXNlcyBhbGwgcGFnZXMgdXNpbmcgcHV0X3VzZXJfcGFnZSgpLAotICogcG9zc2li bHkgdmlhIHB1dF91c2VyX3BhZ2VzKCksIGZvciB0aGUgbm9uLWRpcnR5IGNhc2UuCisgKiBsaXN0 ZWQgYXMgY2xlYW4uIEluIGFueSBjYXNlLCByZWxlYXNlcyBhbGwgcGFnZXMgdXNpbmcgdW5waW5f dXNlcl9wYWdlKCksCisgKiBwb3NzaWJseSB2aWEgdW5waW5fdXNlcl9wYWdlcygpLCBmb3IgdGhl IG5vbi1kaXJ0eSBjYXNlLgogICoKLSAqIFBsZWFzZSBzZWUgdGhlIHB1dF91c2VyX3BhZ2UoKSBk b2N1bWVudGF0aW9uIGZvciBkZXRhaWxzLgorICogUGxlYXNlIHNlZSB0aGUgdW5waW5fdXNlcl9w YWdlKCkgZG9jdW1lbnRhdGlvbiBmb3IgZGV0YWlscy4KICAqCiAgKiBzZXRfcGFnZV9kaXJ0eV9s b2NrKCkgaXMgdXNlZCBpbnRlcm5hbGx5LiBJZiBpbnN0ZWFkLCBzZXRfcGFnZV9kaXJ0eSgpIGlz CiAgKiByZXF1aXJlZCwgdGhlbiB0aGUgY2FsbGVyIHNob3VsZCBhKSB2ZXJpZnkgdGhhdCB0aGlz IGlzIHJlYWxseSBjb3JyZWN0LAogICogYmVjYXVzZSBfbG9jaygpIGlzIHVzdWFsbHkgcmVxdWly ZWQsIGFuZCBiKSBoYW5kIGNvZGUgaXQ6Ci0gKiBzZXRfcGFnZV9kaXJ0eV9sb2NrKCksIHB1dF91 c2VyX3BhZ2UoKS4KKyAqIHNldF9wYWdlX2RpcnR5X2xvY2soKSwgdW5waW5fdXNlcl9wYWdlKCku CiAgKgogICovCi12b2lkIHB1dF91c2VyX3BhZ2VzX2RpcnR5X2xvY2soc3RydWN0IHBhZ2UgKipw YWdlcywgdW5zaWduZWQgbG9uZyBucGFnZXMsCi0JCQkgICAgICAgYm9vbCBtYWtlX2RpcnR5KQor dm9pZCB1bnBpbl91c2VyX3BhZ2VzX2RpcnR5X2xvY2soc3RydWN0IHBhZ2UgKipwYWdlcywgdW5z aWduZWQgbG9uZyBucGFnZXMsCisJCQkJIGJvb2wgbWFrZV9kaXJ0eSkKIHsKIAl1bnNpZ25lZCBs b25nIGluZGV4OwogCkBAIC0xNzUsNyArMTc1LDcgQEAgdm9pZCBwdXRfdXNlcl9wYWdlc19kaXJ0 eV9sb2NrKHN0cnVjdCBwYWdlICoqcGFnZXMsIHVuc2lnbmVkIGxvbmcgbnBhZ2VzLAogCSAqLwog CiAJaWYgKCFtYWtlX2RpcnR5KSB7Ci0JCXB1dF91c2VyX3BhZ2VzKHBhZ2VzLCBucGFnZXMpOwor CQl1bnBpbl91c2VyX3BhZ2VzKHBhZ2VzLCBucGFnZXMpOwogCQlyZXR1cm47CiAJfQogCkBAIC0y MDMsMjEgKzIwMywyMSBAQCB2b2lkIHB1dF91c2VyX3BhZ2VzX2RpcnR5X2xvY2soc3RydWN0IHBh Z2UgKipwYWdlcywgdW5zaWduZWQgbG9uZyBucGFnZXMsCiAJCSAqLwogCQlpZiAoIVBhZ2VEaXJ0 eShwYWdlKSkKIAkJCXNldF9wYWdlX2RpcnR5X2xvY2socGFnZSk7Ci0JCXB1dF91c2VyX3BhZ2Uo cGFnZSk7CisJCXVucGluX3VzZXJfcGFnZShwYWdlKTsKIAl9CiB9Ci1FWFBPUlRfU1lNQk9MKHB1 dF91c2VyX3BhZ2VzX2RpcnR5X2xvY2spOworRVhQT1JUX1NZTUJPTCh1bnBpbl91c2VyX3BhZ2Vz X2RpcnR5X2xvY2spOwogCiAvKioKLSAqIHB1dF91c2VyX3BhZ2VzKCkgLSByZWxlYXNlIGFuIGFy cmF5IG9mIGd1cC1waW5uZWQgcGFnZXMuCisgKiB1bnBpbl91c2VyX3BhZ2VzKCkgLSByZWxlYXNl IGFuIGFycmF5IG9mIGd1cC1waW5uZWQgcGFnZXMuCiAgKiBAcGFnZXM6ICBhcnJheSBvZiBwYWdl cyB0byBiZSBtYXJrZWQgZGlydHkgYW5kIHJlbGVhc2VkLgogICogQG5wYWdlczogbnVtYmVyIG9m IHBhZ2VzIGluIHRoZSBAcGFnZXMgYXJyYXkuCiAgKgotICogRm9yIGVhY2ggcGFnZSBpbiB0aGUg QHBhZ2VzIGFycmF5LCByZWxlYXNlIHRoZSBwYWdlIHVzaW5nIHB1dF91c2VyX3BhZ2UoKS4KKyAq IEZvciBlYWNoIHBhZ2UgaW4gdGhlIEBwYWdlcyBhcnJheSwgcmVsZWFzZSB0aGUgcGFnZSB1c2lu ZyB1bnBpbl91c2VyX3BhZ2UoKS4KICAqCi0gKiBQbGVhc2Ugc2VlIHRoZSBwdXRfdXNlcl9wYWdl KCkgZG9jdW1lbnRhdGlvbiBmb3IgZGV0YWlscy4KKyAqIFBsZWFzZSBzZWUgdGhlIHVucGluX3Vz ZXJfcGFnZSgpIGRvY3VtZW50YXRpb24gZm9yIGRldGFpbHMuCiAgKi8KLXZvaWQgcHV0X3VzZXJf cGFnZXMoc3RydWN0IHBhZ2UgKipwYWdlcywgdW5zaWduZWQgbG9uZyBucGFnZXMpCit2b2lkIHVu cGluX3VzZXJfcGFnZXMoc3RydWN0IHBhZ2UgKipwYWdlcywgdW5zaWduZWQgbG9uZyBucGFnZXMp CiB7CiAJdW5zaWduZWQgbG9uZyBpbmRleDsKIApAQCAtMjI3LDkgKzIyNyw5IEBAIHZvaWQgcHV0 X3VzZXJfcGFnZXMoc3RydWN0IHBhZ2UgKipwYWdlcywgdW5zaWduZWQgbG9uZyBucGFnZXMpCiAJ ICogc2luZ2xlIG9wZXJhdGlvbiB0byB0aGUgaGVhZCBwYWdlIHNob3VsZCBzdWZmaWNlLgogCSAq LwogCWZvciAoaW5kZXggPSAwOyBpbmRleCA8IG5wYWdlczsgaW5kZXgrKykKLQkJcHV0X3VzZXJf cGFnZShwYWdlc1tpbmRleF0pOworCQl1bnBpbl91c2VyX3BhZ2UocGFnZXNbaW5kZXhdKTsKIH0K LUVYUE9SVF9TWU1CT0wocHV0X3VzZXJfcGFnZXMpOworRVhQT1JUX1NZTUJPTCh1bnBpbl91c2Vy X3BhZ2VzKTsKIAogI2lmZGVmIENPTkZJR19NTVUKIHN0YXRpYyBzdHJ1Y3QgcGFnZSAqbm9fcGFn ZV90YWJsZShzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKQEAgLTE5NTYsNyArMTk1Niw3IEBA IHN0YXRpYyB2b2lkIF9fbWF5YmVfdW51c2VkIHVuZG9fZGV2X3BhZ2VtYXAoaW50ICpuciwgaW50 IG5yX3N0YXJ0LAogCiAJCUNsZWFyUGFnZVJlZmVyZW5jZWQocGFnZSk7CiAJCWlmIChmbGFncyAm IEZPTExfUElOKQotCQkJcHV0X3VzZXJfcGFnZShwYWdlKTsKKwkJCXVucGluX3VzZXJfcGFnZShw YWdlKTsKIAkJZWxzZQogCQkJcHV0X3BhZ2UocGFnZSk7CiAJfQpkaWZmIC0tZ2l0IGEvbW0vZ3Vw X2JlbmNobWFyay5jIGIvbW0vZ3VwX2JlbmNobWFyay5jCmluZGV4IDFhYzA4OWFkODE1Zi4uNzZk MzJkYjQ4YWY4IDEwMDY0NAotLS0gYS9tbS9ndXBfYmVuY2htYXJrLmMKKysrIGIvbW0vZ3VwX2Jl bmNobWFyay5jCkBAIC0zNSw3ICszNSw3IEBAIHN0YXRpYyB2b2lkIHB1dF9iYWNrX3BhZ2VzKGlu dCBjbWQsIHN0cnVjdCBwYWdlICoqcGFnZXMsIHVuc2lnbmVkIGxvbmcgbnJfcGFnZXMpCiAKIAlj YXNlIFBJTl9GQVNUX0JFTkNITUFSSzoKIAljYXNlIFBJTl9CRU5DSE1BUks6Ci0JCXB1dF91c2Vy X3BhZ2VzKHBhZ2VzLCBucl9wYWdlcyk7CisJCXVucGluX3VzZXJfcGFnZXMocGFnZXMsIG5yX3Bh Z2VzKTsKIAkJYnJlYWs7CiAJfQogfQpkaWZmIC0tZ2l0IGEvbW0vcHJvY2Vzc192bV9hY2Nlc3Mu YyBiL21tL3Byb2Nlc3Nfdm1fYWNjZXNzLmMKaW5kZXggZmQyMGFiNjc1Yjg1Li5kZTQxZTgzMGNk YWMgMTAwNjQ0Ci0tLSBhL21tL3Byb2Nlc3Nfdm1fYWNjZXNzLmMKKysrIGIvbW0vcHJvY2Vzc192 bV9hY2Nlc3MuYwpAQCAtMTI2LDggKzEyNiw4IEBAIHN0YXRpYyBpbnQgcHJvY2Vzc192bV9yd19z aW5nbGVfdmVjKHVuc2lnbmVkIGxvbmcgYWRkciwKIAkJcGEgKz0gcGlubmVkX3BhZ2VzICogUEFH RV9TSVpFOwogCiAJCS8qIElmIHZtX3dyaXRlIGlzIHNldCwgdGhlIHBhZ2VzIG5lZWQgdG8gYmUg bWFkZSBkaXJ0eTogKi8KLQkJcHV0X3VzZXJfcGFnZXNfZGlydHlfbG9jayhwcm9jZXNzX3BhZ2Vz LCBwaW5uZWRfcGFnZXMsCi0JCQkJCSAgdm1fd3JpdGUpOworCQl1bnBpbl91c2VyX3BhZ2VzX2Rp cnR5X2xvY2socHJvY2Vzc19wYWdlcywgcGlubmVkX3BhZ2VzLAorCQkJCQkgICAgdm1fd3JpdGUp OwogCX0KIAogCXJldHVybiByYzsKZGlmZiAtLWdpdCBhL25ldC94ZHAveGRwX3VtZW0uYyBiL25l dC94ZHAveGRwX3VtZW0uYwppbmRleCBkMDcxMDAzYjVlNzYuLmFjMTgyYzM4ZjdiMCAxMDA2NDQK LS0tIGEvbmV0L3hkcC94ZHBfdW1lbS5jCisrKyBiL25ldC94ZHAveGRwX3VtZW0uYwpAQCAtMjEy LDcgKzIxMiw3IEBAIHN0YXRpYyBpbnQgeGRwX3VtZW1fbWFwX3BhZ2VzKHN0cnVjdCB4ZHBfdW1l bSAqdW1lbSkKIAogc3RhdGljIHZvaWQgeGRwX3VtZW1fdW5waW5fcGFnZXMoc3RydWN0IHhkcF91 bWVtICp1bWVtKQogewotCXB1dF91c2VyX3BhZ2VzX2RpcnR5X2xvY2sodW1lbS0+cGdzLCB1bWVt LT5ucGdzLCB0cnVlKTsKKwl1bnBpbl91c2VyX3BhZ2VzX2RpcnR5X2xvY2sodW1lbS0+cGdzLCB1 bWVtLT5ucGdzLCB0cnVlKTsKIAogCWtmcmVlKHVtZW0tPnBncyk7CiAJdW1lbS0+cGdzID0gTlVM TDsKLS0gCjIuMjQuMAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Au b3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRl dmVs