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=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_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 CDD79ECE595 for ; Tue, 15 Oct 2019 18:17:30 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 9FB3D22459 for ; Tue, 15 Oct 2019 18:17:30 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=ziepe.ca header.i=@ziepe.ca header.b="Eiv4i3Fn" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1731867AbfJOSQj (ORCPT ); Tue, 15 Oct 2019 14:16:39 -0400 Received: from mail-pf1-f194.google.com ([209.85.210.194]:34752 "EHLO mail-pf1-f194.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726597AbfJOSQj (ORCPT ); Tue, 15 Oct 2019 14:16:39 -0400 Received: by mail-pf1-f194.google.com with SMTP id b128so13011285pfa.1 for ; Tue, 15 Oct 2019 11:16:38 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ziepe.ca; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=iRW3sh+/KRUt0IvjdYFL27lKQnR6JopWyEWGX3mhAm8=; b=Eiv4i3FnS+9AnZt+YbZ7uwkDRfoZtzmZHlf/1T6Dd+TGZm+IlbQdUSdoEknCGSJT74 NHOt1fJW8ppGprWjV+ZQYPbBf7qZUYJYFU/w5OBCKL2lFeXoF1HITZnMmdZ/5bENAh0C M9xiGwCNGfBNjqdoby7Du4vQTGl7Oj1wVRWwQlOdxEGgEaI66pUpPU5ImgkRbRKHUUIQ CsqQpVj6VqeG3eZMk7whUQDFdm9J3A2/g0W8IVTEMk/STm80nkPFwQcSWD6AHgwlBcB2 BbORyq+gZSHLYOXtikwSUIdzMNaGUecdS1CkW+jHUBTn7GcMhoxOBSDp2/E01qI0evFI PtOQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=iRW3sh+/KRUt0IvjdYFL27lKQnR6JopWyEWGX3mhAm8=; b=l6OopHNx1r5hWms0N7ba95ztjnoTQO3jCBETQUNYRYWCAAh+o6npYsOlhFC68pBYTV fdLuh+ap3kPjt99fF0i5hEoCPSXaWZdhPbLReqOrnBaIrolJCVsVYLyVfI42Suv1mJEN DsjqW8XD+JhXjwZj9wm7mfVBU3+YaBiPaSXiUlJyzJI8o6thoWmTB8oHBdMD3IHM4Udc ZX2yXyRBJN121Y1Ok6RFfaX4wRNQ8MdeaisgkWsmrCtrjwYeHBolLGfdDOQykhvDCeWO +M7SQyq/46wH98ETPzsvXxwGhd3QZBiqfUBs8zNRYPJkC4BFu6UJUYdywlK0cNvRXhc9 FRRw== X-Gm-Message-State: APjAAAU6kJQJYLu+1fSg+VEkhTlVyvIbphdw32dq1ODCC8daPCRyq37f Ph4bA7gOwqMaAXOt7iEJgPa6AQ== X-Google-Smtp-Source: APXvYqxn5GyOR9bQAeLu3rv5akSVrWu3Kb3RnrvMd5wFUn6mPQxIDLOICpAwdvPqp2qaflwt2NAGog== X-Received: by 2002:a63:cc4a:: with SMTP id q10mr40292268pgi.221.1571163397873; Tue, 15 Oct 2019 11:16:37 -0700 (PDT) Received: from ziepe.ca ([24.114.26.129]) by smtp.gmail.com with ESMTPSA id e3sm12863pjs.15.2019.10.15.11.16.37 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Tue, 15 Oct 2019 11:16:37 -0700 (PDT) Received: from jgg by jggl.ziepe.ca with local (Exim 4.90_1) (envelope-from ) id 1iKRJT-0002CB-F7; Tue, 15 Oct 2019 15:12:51 -0300 From: Jason Gunthorpe To: Jerome Glisse , Ralph Campbell , John Hubbard , Felix.Kuehling@amd.com Cc: linux-rdma@vger.kernel.org, linux-mm@kvack.org, Andrea Arcangeli , dri-devel@lists.freedesktop.org, amd-gfx@lists.freedesktop.org, Ben Skeggs , Jason Gunthorpe , Mike Marciniszyn , Dennis Dalessandro Subject: [PATCH hmm 06/15] RDMA/hfi1: Use mmu_range_notifier_inset for user_exp_rcv Date: Tue, 15 Oct 2019 15:12:33 -0300 Message-Id: <20191015181242.8343-7-jgg@ziepe.ca> X-Mailer: git-send-email 2.23.0 In-Reply-To: <20191015181242.8343-1-jgg@ziepe.ca> References: <20191015181242.8343-1-jgg@ziepe.ca> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: linux-rdma-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-rdma@vger.kernel.org From: Jason Gunthorpe This converts one of the two users of mmu_notifiers to use the new API. The conversion is fairly straightforward, however the existing use of notifiers here seems to be racey. Cc: Mike Marciniszyn Cc: Dennis Dalessandro Signed-off-by: Jason Gunthorpe --- drivers/infiniband/hw/hfi1/file_ops.c | 2 +- drivers/infiniband/hw/hfi1/hfi.h | 2 +- drivers/infiniband/hw/hfi1/user_exp_rcv.c | 144 ++++++++-------------- drivers/infiniband/hw/hfi1/user_exp_rcv.h | 3 +- 4 files changed, 58 insertions(+), 93 deletions(-) diff --git a/drivers/infiniband/hw/hfi1/file_ops.c b/drivers/infiniband/hw/hfi1/file_ops.c index f9a7e9d29c8ba2..7c5e3fb224139a 100644 --- a/drivers/infiniband/hw/hfi1/file_ops.c +++ b/drivers/infiniband/hw/hfi1/file_ops.c @@ -1138,7 +1138,7 @@ static int get_ctxt_info(struct hfi1_filedata *fd, unsigned long arg, u32 len) HFI1_CAP_UGET_MASK(uctxt->flags, MASK) | HFI1_CAP_KGET_MASK(uctxt->flags, K2U); /* adjust flag if this fd is not able to cache */ - if (!fd->handler) + if (!fd->use_mn) cinfo.runtime_flags |= HFI1_CAP_TID_UNMAP; /* no caching */ cinfo.num_active = hfi1_count_active_units(); diff --git a/drivers/infiniband/hw/hfi1/hfi.h b/drivers/infiniband/hw/hfi1/hfi.h index fa45350a9a1d32..fc10d65fc3e13c 100644 --- a/drivers/infiniband/hw/hfi1/hfi.h +++ b/drivers/infiniband/hw/hfi1/hfi.h @@ -1444,7 +1444,7 @@ struct hfi1_filedata { /* for cpu affinity; -1 if none */ int rec_cpu_num; u32 tid_n_pinned; - struct mmu_rb_handler *handler; + bool use_mn; struct tid_rb_node **entry_to_rb; spinlock_t tid_lock; /* protect tid_[limit,used] counters */ u32 tid_limit; diff --git a/drivers/infiniband/hw/hfi1/user_exp_rcv.c b/drivers/infiniband/hw/hfi1/user_exp_rcv.c index 3592a9ec155e85..2aca28a0b3ca47 100644 --- a/drivers/infiniband/hw/hfi1/user_exp_rcv.c +++ b/drivers/infiniband/hw/hfi1/user_exp_rcv.c @@ -59,11 +59,10 @@ static int set_rcvarray_entry(struct hfi1_filedata *fd, struct tid_user_buf *tbuf, u32 rcventry, struct tid_group *grp, u16 pageidx, unsigned int npages); -static int tid_rb_insert(void *arg, struct mmu_rb_node *node); static void cacheless_tid_rb_remove(struct hfi1_filedata *fdata, struct tid_rb_node *tnode); -static void tid_rb_remove(void *arg, struct mmu_rb_node *node); -static int tid_rb_invalidate(void *arg, struct mmu_rb_node *mnode); +static bool tid_rb_invalidate(struct mmu_range_notifier *mrn, + const struct mmu_notifier_range *range); static int program_rcvarray(struct hfi1_filedata *fd, struct tid_user_buf *, struct tid_group *grp, unsigned int start, u16 count, @@ -73,10 +72,8 @@ static int unprogram_rcvarray(struct hfi1_filedata *fd, u32 tidinfo, struct tid_group **grp); static void clear_tid_node(struct hfi1_filedata *fd, struct tid_rb_node *node); -static struct mmu_rb_ops tid_rb_ops = { - .insert = tid_rb_insert, - .remove = tid_rb_remove, - .invalidate = tid_rb_invalidate +static const struct mmu_range_notifier_ops tid_mn_ops = { + .invalidate = tid_rb_invalidate, }; /* @@ -87,7 +84,6 @@ static struct mmu_rb_ops tid_rb_ops = { int hfi1_user_exp_rcv_init(struct hfi1_filedata *fd, struct hfi1_ctxtdata *uctxt) { - struct hfi1_devdata *dd = uctxt->dd; int ret = 0; spin_lock_init(&fd->tid_lock); @@ -109,20 +105,7 @@ int hfi1_user_exp_rcv_init(struct hfi1_filedata *fd, fd->entry_to_rb = NULL; return -ENOMEM; } - - /* - * Register MMU notifier callbacks. If the registration - * fails, continue without TID caching for this context. - */ - ret = hfi1_mmu_rb_register(fd, fd->mm, &tid_rb_ops, - dd->pport->hfi1_wq, - &fd->handler); - if (ret) { - dd_dev_info(dd, - "Failed MMU notifier registration %d\n", - ret); - ret = 0; - } + fd->use_mn = true; } /* @@ -139,7 +122,7 @@ int hfi1_user_exp_rcv_init(struct hfi1_filedata *fd, * init. */ spin_lock(&fd->tid_lock); - if (uctxt->subctxt_cnt && fd->handler) { + if (uctxt->subctxt_cnt && fd->use_mn) { u16 remainder; fd->tid_limit = uctxt->expected_count / uctxt->subctxt_cnt; @@ -158,18 +141,10 @@ void hfi1_user_exp_rcv_free(struct hfi1_filedata *fd) { struct hfi1_ctxtdata *uctxt = fd->uctxt; - /* - * The notifier would have been removed when the process'es mm - * was freed. - */ - if (fd->handler) { - hfi1_mmu_rb_unregister(fd->handler); - } else { - if (!EXP_TID_SET_EMPTY(uctxt->tid_full_list)) - unlock_exp_tids(uctxt, &uctxt->tid_full_list, fd); - if (!EXP_TID_SET_EMPTY(uctxt->tid_used_list)) - unlock_exp_tids(uctxt, &uctxt->tid_used_list, fd); - } + if (!EXP_TID_SET_EMPTY(uctxt->tid_full_list)) + unlock_exp_tids(uctxt, &uctxt->tid_full_list, fd); + if (!EXP_TID_SET_EMPTY(uctxt->tid_used_list)) + unlock_exp_tids(uctxt, &uctxt->tid_used_list, fd); kfree(fd->invalid_tids); fd->invalid_tids = NULL; @@ -201,7 +176,7 @@ static void unpin_rcv_pages(struct hfi1_filedata *fd, if (mapped) { pci_unmap_single(dd->pcidev, node->dma_addr, - node->mmu.len, PCI_DMA_FROMDEVICE); + node->npages * PAGE_SIZE, PCI_DMA_FROMDEVICE); pages = &node->pages[idx]; } else { pages = &tidbuf->pages[idx]; @@ -777,8 +752,8 @@ static int set_rcvarray_entry(struct hfi1_filedata *fd, return -EFAULT; } - node->mmu.addr = tbuf->vaddr + (pageidx * PAGE_SIZE); - node->mmu.len = npages * PAGE_SIZE; + node->notifier.ops = &tid_mn_ops; + node->fdata = fd; node->phys = page_to_phys(pages[0]); node->npages = npages; node->rcventry = rcventry; @@ -787,23 +762,34 @@ static int set_rcvarray_entry(struct hfi1_filedata *fd, node->freed = false; memcpy(node->pages, pages, sizeof(struct page *) * npages); - if (!fd->handler) - ret = tid_rb_insert(fd, &node->mmu); - else - ret = hfi1_mmu_rb_insert(fd->handler, &node->mmu); - - if (ret) { - hfi1_cdbg(TID, "Failed to insert RB node %u 0x%lx, 0x%lx %d", - node->rcventry, node->mmu.addr, node->phys, ret); - pci_unmap_single(dd->pcidev, phys, npages * PAGE_SIZE, - PCI_DMA_FROMDEVICE); - kfree(node); - return -EFAULT; + if (fd->use_mn) { + ret = mmu_range_notifier_insert( + &node->notifier, tbuf->vaddr + (pageidx * PAGE_SIZE), + npages * PAGE_SIZE, fd->mm); + if (ret) + goto out_unmap; + /* + * FIXME: This is in the wrong order, the notifier should be + * established before the pages are pinned by pin_rcv_pages. + */ + mmu_range_read_begin(&node->notifier); } + fd->entry_to_rb[node->rcventry - uctxt->expected_base] = node; + hfi1_put_tid(dd, rcventry, PT_EXPECTED, phys, ilog2(npages) + 1); trace_hfi1_exp_tid_reg(uctxt->ctxt, fd->subctxt, rcventry, npages, - node->mmu.addr, node->phys, phys); + node->notifier.interval_tree.start, node->phys, + phys); return 0; + +out_unmap: + hfi1_cdbg(TID, "Failed to insert RB node %u 0x%lx, 0x%lx %d", + node->rcventry, node->notifier.interval_tree.start, + node->phys, ret); + pci_unmap_single(dd->pcidev, phys, npages * PAGE_SIZE, + PCI_DMA_FROMDEVICE); + kfree(node); + return -EFAULT; } static int unprogram_rcvarray(struct hfi1_filedata *fd, u32 tidinfo, @@ -833,10 +819,9 @@ static int unprogram_rcvarray(struct hfi1_filedata *fd, u32 tidinfo, if (grp) *grp = node->grp; - if (!fd->handler) - cacheless_tid_rb_remove(fd, node); - else - hfi1_mmu_rb_remove(fd->handler, &node->mmu); + if (fd->use_mn) + mmu_range_notifier_remove(&node->notifier); + cacheless_tid_rb_remove(fd, node); return 0; } @@ -847,7 +832,8 @@ static void clear_tid_node(struct hfi1_filedata *fd, struct tid_rb_node *node) struct hfi1_devdata *dd = uctxt->dd; trace_hfi1_exp_tid_unreg(uctxt->ctxt, fd->subctxt, node->rcventry, - node->npages, node->mmu.addr, node->phys, + node->npages, + node->notifier.interval_tree.start, node->phys, node->dma_addr); /* @@ -894,30 +880,28 @@ static void unlock_exp_tids(struct hfi1_ctxtdata *uctxt, if (!node || node->rcventry != rcventry) continue; + if (fd->use_mn) + mmu_range_notifier_remove( + &node->notifier); cacheless_tid_rb_remove(fd, node); } } } } -/* - * Always return 0 from this function. A non-zero return indicates that the - * remove operation will be called and that memory should be unpinned. - * However, the driver cannot unpin out from under PSM. Instead, retain the - * memory (by returning 0) and inform PSM that the memory is going away. PSM - * will call back later when it has removed the memory from its list. - */ -static int tid_rb_invalidate(void *arg, struct mmu_rb_node *mnode) +static bool tid_rb_invalidate(struct mmu_range_notifier *mrn, + const struct mmu_notifier_range *range) { - struct hfi1_filedata *fdata = arg; - struct hfi1_ctxtdata *uctxt = fdata->uctxt; struct tid_rb_node *node = - container_of(mnode, struct tid_rb_node, mmu); + container_of(mrn, struct tid_rb_node, notifier); + struct hfi1_filedata *fdata = node->fdata; + struct hfi1_ctxtdata *uctxt = fdata->uctxt; if (node->freed) - return 0; + return true; - trace_hfi1_exp_tid_inval(uctxt->ctxt, fdata->subctxt, node->mmu.addr, + trace_hfi1_exp_tid_inval(uctxt->ctxt, fdata->subctxt, + node->notifier.interval_tree.start, node->rcventry, node->npages, node->dma_addr); node->freed = true; @@ -946,18 +930,7 @@ static int tid_rb_invalidate(void *arg, struct mmu_rb_node *mnode) fdata->invalid_tid_idx++; } spin_unlock(&fdata->invalid_lock); - return 0; -} - -static int tid_rb_insert(void *arg, struct mmu_rb_node *node) -{ - struct hfi1_filedata *fdata = arg; - struct tid_rb_node *tnode = - container_of(node, struct tid_rb_node, mmu); - u32 base = fdata->uctxt->expected_base; - - fdata->entry_to_rb[tnode->rcventry - base] = tnode; - return 0; + return true; } static void cacheless_tid_rb_remove(struct hfi1_filedata *fdata, @@ -968,12 +941,3 @@ static void cacheless_tid_rb_remove(struct hfi1_filedata *fdata, fdata->entry_to_rb[tnode->rcventry - base] = NULL; clear_tid_node(fdata, tnode); } - -static void tid_rb_remove(void *arg, struct mmu_rb_node *node) -{ - struct hfi1_filedata *fdata = arg; - struct tid_rb_node *tnode = - container_of(node, struct tid_rb_node, mmu); - - cacheless_tid_rb_remove(fdata, tnode); -} diff --git a/drivers/infiniband/hw/hfi1/user_exp_rcv.h b/drivers/infiniband/hw/hfi1/user_exp_rcv.h index 43b105de1d5427..b5314db083b125 100644 --- a/drivers/infiniband/hw/hfi1/user_exp_rcv.h +++ b/drivers/infiniband/hw/hfi1/user_exp_rcv.h @@ -65,7 +65,8 @@ struct tid_user_buf { }; struct tid_rb_node { - struct mmu_rb_node mmu; + struct mmu_range_notifier notifier; + struct hfi1_filedata *fdata; unsigned long phys; struct tid_group *grp; u32 rcventry; -- 2.23.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jason Gunthorpe Subject: [PATCH hmm 06/15] RDMA/hfi1: Use mmu_range_notifier_inset for user_exp_rcv Date: Tue, 15 Oct 2019 15:12:33 -0300 Message-ID: <20191015181242.8343-7-jgg@ziepe.ca> References: <20191015181242.8343-1-jgg@ziepe.ca> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20191015181242.8343-1-jgg-uk2M96/98Pc@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: amd-gfx-bounces-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Sender: "amd-gfx" To: Jerome Glisse , Ralph Campbell , John Hubbard , Felix.Kuehling-5C7GfCeVMHo@public.gmane.org Cc: Andrea Arcangeli , Mike Marciniszyn , linux-rdma-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Dennis Dalessandro , amd-gfx-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, linux-mm-Bw31MaZKKs3YtjvyW6yDsg@public.gmane.org, Jason Gunthorpe , dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, Ben Skeggs List-Id: dri-devel@lists.freedesktop.org RnJvbTogSmFzb24gR3VudGhvcnBlIDxqZ2dAbWVsbGFub3guY29tPgoKVGhpcyBjb252ZXJ0cyBv bmUgb2YgdGhlIHR3byB1c2VycyBvZiBtbXVfbm90aWZpZXJzIHRvIHVzZSB0aGUgbmV3IEFQSS4K VGhlIGNvbnZlcnNpb24gaXMgZmFpcmx5IHN0cmFpZ2h0Zm9yd2FyZCwgaG93ZXZlciB0aGUgZXhp c3RpbmcgdXNlIG9mCm5vdGlmaWVycyBoZXJlIHNlZW1zIHRvIGJlIHJhY2V5LgoKQ2M6IE1pa2Ug TWFyY2luaXN6eW4gPG1pa2UubWFyY2luaXN6eW5AaW50ZWwuY29tPgpDYzogRGVubmlzIERhbGVz c2FuZHJvIDxkZW5uaXMuZGFsZXNzYW5kcm9AaW50ZWwuY29tPgpTaWduZWQtb2ZmLWJ5OiBKYXNv biBHdW50aG9ycGUgPGpnZ0BtZWxsYW5veC5jb20+Ci0tLQogZHJpdmVycy9pbmZpbmliYW5kL2h3 L2hmaTEvZmlsZV9vcHMuYyAgICAgfCAgIDIgKy0KIGRyaXZlcnMvaW5maW5pYmFuZC9ody9oZmkx L2hmaS5oICAgICAgICAgIHwgICAyICstCiBkcml2ZXJzL2luZmluaWJhbmQvaHcvaGZpMS91c2Vy X2V4cF9yY3YuYyB8IDE0NCArKysrKysrKy0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL2luZmluaWJh bmQvaHcvaGZpMS91c2VyX2V4cF9yY3YuaCB8ICAgMyArLQogNCBmaWxlcyBjaGFuZ2VkLCA1OCBp bnNlcnRpb25zKCspLCA5MyBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmlu aWJhbmQvaHcvaGZpMS9maWxlX29wcy5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L2hmaTEvZmls ZV9vcHMuYwppbmRleCBmOWE3ZTlkMjljOGJhMi4uN2M1ZTNmYjIyNDEzOWEgMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvaW5maW5pYmFuZC9ody9oZmkxL2ZpbGVfb3BzLmMKKysrIGIvZHJpdmVycy9pbmZp bmliYW5kL2h3L2hmaTEvZmlsZV9vcHMuYwpAQCAtMTEzOCw3ICsxMTM4LDcgQEAgc3RhdGljIGlu dCBnZXRfY3R4dF9pbmZvKHN0cnVjdCBoZmkxX2ZpbGVkYXRhICpmZCwgdW5zaWduZWQgbG9uZyBh cmcsIHUzMiBsZW4pCiAJCQlIRkkxX0NBUF9VR0VUX01BU0sodWN0eHQtPmZsYWdzLCBNQVNLKSB8 CiAJCQlIRkkxX0NBUF9LR0VUX01BU0sodWN0eHQtPmZsYWdzLCBLMlUpOwogCS8qIGFkanVzdCBm bGFnIGlmIHRoaXMgZmQgaXMgbm90IGFibGUgdG8gY2FjaGUgKi8KLQlpZiAoIWZkLT5oYW5kbGVy KQorCWlmICghZmQtPnVzZV9tbikKIAkJY2luZm8ucnVudGltZV9mbGFncyB8PSBIRkkxX0NBUF9U SURfVU5NQVA7IC8qIG5vIGNhY2hpbmcgKi8KIAogCWNpbmZvLm51bV9hY3RpdmUgPSBoZmkxX2Nv dW50X2FjdGl2ZV91bml0cygpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L2hm aTEvaGZpLmggYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvaGZpMS9oZmkuaAppbmRleCBmYTQ1MzUw YTlhMWQzMi4uZmMxMGQ2NWZjM2UxM2MgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9o dy9oZmkxL2hmaS5oCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9oZmkxL2hmaS5oCkBAIC0x NDQ0LDcgKzE0NDQsNyBAQCBzdHJ1Y3QgaGZpMV9maWxlZGF0YSB7CiAJLyogZm9yIGNwdSBhZmZp bml0eTsgLTEgaWYgbm9uZSAqLwogCWludCByZWNfY3B1X251bTsKIAl1MzIgdGlkX25fcGlubmVk OwotCXN0cnVjdCBtbXVfcmJfaGFuZGxlciAqaGFuZGxlcjsKKwlib29sIHVzZV9tbjsKIAlzdHJ1 Y3QgdGlkX3JiX25vZGUgKiplbnRyeV90b19yYjsKIAlzcGlubG9ja190IHRpZF9sb2NrOyAvKiBw cm90ZWN0IHRpZF9bbGltaXQsdXNlZF0gY291bnRlcnMgKi8KIAl1MzIgdGlkX2xpbWl0OwpkaWZm IC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L2hmaTEvdXNlcl9leHBfcmN2LmMgYi9kcml2 ZXJzL2luZmluaWJhbmQvaHcvaGZpMS91c2VyX2V4cF9yY3YuYwppbmRleCAzNTkyYTllYzE1NWU4 NS4uMmFjYTI4YTBiM2NhNDcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9oZmkx L3VzZXJfZXhwX3Jjdi5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9oZmkxL3VzZXJfZXhw X3Jjdi5jCkBAIC01OSwxMSArNTksMTAgQEAgc3RhdGljIGludCBzZXRfcmN2YXJyYXlfZW50cnko c3RydWN0IGhmaTFfZmlsZWRhdGEgKmZkLAogCQkJICAgICAgc3RydWN0IHRpZF91c2VyX2J1ZiAq dGJ1ZiwKIAkJCSAgICAgIHUzMiByY3ZlbnRyeSwgc3RydWN0IHRpZF9ncm91cCAqZ3JwLAogCQkJ ICAgICAgdTE2IHBhZ2VpZHgsIHVuc2lnbmVkIGludCBucGFnZXMpOwotc3RhdGljIGludCB0aWRf cmJfaW5zZXJ0KHZvaWQgKmFyZywgc3RydWN0IG1tdV9yYl9ub2RlICpub2RlKTsKIHN0YXRpYyB2 b2lkIGNhY2hlbGVzc190aWRfcmJfcmVtb3ZlKHN0cnVjdCBoZmkxX2ZpbGVkYXRhICpmZGF0YSwK IAkJCQkgICAgc3RydWN0IHRpZF9yYl9ub2RlICp0bm9kZSk7Ci1zdGF0aWMgdm9pZCB0aWRfcmJf cmVtb3ZlKHZvaWQgKmFyZywgc3RydWN0IG1tdV9yYl9ub2RlICpub2RlKTsKLXN0YXRpYyBpbnQg dGlkX3JiX2ludmFsaWRhdGUodm9pZCAqYXJnLCBzdHJ1Y3QgbW11X3JiX25vZGUgKm1ub2RlKTsK K3N0YXRpYyBib29sIHRpZF9yYl9pbnZhbGlkYXRlKHN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXIg Km1ybiwKKwkJCSAgICAgIGNvbnN0IHN0cnVjdCBtbXVfbm90aWZpZXJfcmFuZ2UgKnJhbmdlKTsK IHN0YXRpYyBpbnQgcHJvZ3JhbV9yY3ZhcnJheShzdHJ1Y3QgaGZpMV9maWxlZGF0YSAqZmQsIHN0 cnVjdCB0aWRfdXNlcl9idWYgKiwKIAkJCSAgICBzdHJ1Y3QgdGlkX2dyb3VwICpncnAsCiAJCQkg ICAgdW5zaWduZWQgaW50IHN0YXJ0LCB1MTYgY291bnQsCkBAIC03MywxMCArNzIsOCBAQCBzdGF0 aWMgaW50IHVucHJvZ3JhbV9yY3ZhcnJheShzdHJ1Y3QgaGZpMV9maWxlZGF0YSAqZmQsIHUzMiB0 aWRpbmZvLAogCQkJICAgICAgc3RydWN0IHRpZF9ncm91cCAqKmdycCk7CiBzdGF0aWMgdm9pZCBj bGVhcl90aWRfbm9kZShzdHJ1Y3QgaGZpMV9maWxlZGF0YSAqZmQsIHN0cnVjdCB0aWRfcmJfbm9k ZSAqbm9kZSk7CiAKLXN0YXRpYyBzdHJ1Y3QgbW11X3JiX29wcyB0aWRfcmJfb3BzID0gewotCS5p bnNlcnQgPSB0aWRfcmJfaW5zZXJ0LAotCS5yZW1vdmUgPSB0aWRfcmJfcmVtb3ZlLAotCS5pbnZh bGlkYXRlID0gdGlkX3JiX2ludmFsaWRhdGUKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgbW11X3Jhbmdl X25vdGlmaWVyX29wcyB0aWRfbW5fb3BzID0geworCS5pbnZhbGlkYXRlID0gdGlkX3JiX2ludmFs aWRhdGUsCiB9OwogCiAvKgpAQCAtODcsNyArODQsNiBAQCBzdGF0aWMgc3RydWN0IG1tdV9yYl9v cHMgdGlkX3JiX29wcyA9IHsKIGludCBoZmkxX3VzZXJfZXhwX3Jjdl9pbml0KHN0cnVjdCBoZmkx X2ZpbGVkYXRhICpmZCwKIAkJCSAgIHN0cnVjdCBoZmkxX2N0eHRkYXRhICp1Y3R4dCkKIHsKLQlz dHJ1Y3QgaGZpMV9kZXZkYXRhICpkZCA9IHVjdHh0LT5kZDsKIAlpbnQgcmV0ID0gMDsKIAogCXNw aW5fbG9ja19pbml0KCZmZC0+dGlkX2xvY2spOwpAQCAtMTA5LDIwICsxMDUsNyBAQCBpbnQgaGZp MV91c2VyX2V4cF9yY3ZfaW5pdChzdHJ1Y3QgaGZpMV9maWxlZGF0YSAqZmQsCiAJCQlmZC0+ZW50 cnlfdG9fcmIgPSBOVUxMOwogCQkJcmV0dXJuIC1FTk9NRU07CiAJCX0KLQotCQkvKgotCQkgKiBS ZWdpc3RlciBNTVUgbm90aWZpZXIgY2FsbGJhY2tzLiBJZiB0aGUgcmVnaXN0cmF0aW9uCi0JCSAq IGZhaWxzLCBjb250aW51ZSB3aXRob3V0IFRJRCBjYWNoaW5nIGZvciB0aGlzIGNvbnRleHQuCi0J CSAqLwotCQlyZXQgPSBoZmkxX21tdV9yYl9yZWdpc3RlcihmZCwgZmQtPm1tLCAmdGlkX3JiX29w cywKLQkJCQkJICAgZGQtPnBwb3J0LT5oZmkxX3dxLAotCQkJCQkgICAmZmQtPmhhbmRsZXIpOwot CQlpZiAocmV0KSB7Ci0JCQlkZF9kZXZfaW5mbyhkZCwKLQkJCQkgICAgIkZhaWxlZCBNTVUgbm90 aWZpZXIgcmVnaXN0cmF0aW9uICVkXG4iLAotCQkJCSAgICByZXQpOwotCQkJcmV0ID0gMDsKLQkJ fQorCQlmZC0+dXNlX21uID0gdHJ1ZTsKIAl9CiAKIAkvKgpAQCAtMTM5LDcgKzEyMiw3IEBAIGlu dCBoZmkxX3VzZXJfZXhwX3Jjdl9pbml0KHN0cnVjdCBoZmkxX2ZpbGVkYXRhICpmZCwKIAkgKiBp bml0LgogCSAqLwogCXNwaW5fbG9jaygmZmQtPnRpZF9sb2NrKTsKLQlpZiAodWN0eHQtPnN1YmN0 eHRfY250ICYmIGZkLT5oYW5kbGVyKSB7CisJaWYgKHVjdHh0LT5zdWJjdHh0X2NudCAmJiBmZC0+ dXNlX21uKSB7CiAJCXUxNiByZW1haW5kZXI7CiAKIAkJZmQtPnRpZF9saW1pdCA9IHVjdHh0LT5l eHBlY3RlZF9jb3VudCAvIHVjdHh0LT5zdWJjdHh0X2NudDsKQEAgLTE1OCwxOCArMTQxLDEwIEBA IHZvaWQgaGZpMV91c2VyX2V4cF9yY3ZfZnJlZShzdHJ1Y3QgaGZpMV9maWxlZGF0YSAqZmQpCiB7 CiAJc3RydWN0IGhmaTFfY3R4dGRhdGEgKnVjdHh0ID0gZmQtPnVjdHh0OwogCi0JLyoKLQkgKiBU aGUgbm90aWZpZXIgd291bGQgaGF2ZSBiZWVuIHJlbW92ZWQgd2hlbiB0aGUgcHJvY2VzcydlcyBt bQotCSAqIHdhcyBmcmVlZC4KLQkgKi8KLQlpZiAoZmQtPmhhbmRsZXIpIHsKLQkJaGZpMV9tbXVf cmJfdW5yZWdpc3RlcihmZC0+aGFuZGxlcik7Ci0JfSBlbHNlIHsKLQkJaWYgKCFFWFBfVElEX1NF VF9FTVBUWSh1Y3R4dC0+dGlkX2Z1bGxfbGlzdCkpCi0JCQl1bmxvY2tfZXhwX3RpZHModWN0eHQs ICZ1Y3R4dC0+dGlkX2Z1bGxfbGlzdCwgZmQpOwotCQlpZiAoIUVYUF9USURfU0VUX0VNUFRZKHVj dHh0LT50aWRfdXNlZF9saXN0KSkKLQkJCXVubG9ja19leHBfdGlkcyh1Y3R4dCwgJnVjdHh0LT50 aWRfdXNlZF9saXN0LCBmZCk7Ci0JfQorCWlmICghRVhQX1RJRF9TRVRfRU1QVFkodWN0eHQtPnRp ZF9mdWxsX2xpc3QpKQorCQl1bmxvY2tfZXhwX3RpZHModWN0eHQsICZ1Y3R4dC0+dGlkX2Z1bGxf bGlzdCwgZmQpOworCWlmICghRVhQX1RJRF9TRVRfRU1QVFkodWN0eHQtPnRpZF91c2VkX2xpc3Qp KQorCQl1bmxvY2tfZXhwX3RpZHModWN0eHQsICZ1Y3R4dC0+dGlkX3VzZWRfbGlzdCwgZmQpOwog CiAJa2ZyZWUoZmQtPmludmFsaWRfdGlkcyk7CiAJZmQtPmludmFsaWRfdGlkcyA9IE5VTEw7CkBA IC0yMDEsNyArMTc2LDcgQEAgc3RhdGljIHZvaWQgdW5waW5fcmN2X3BhZ2VzKHN0cnVjdCBoZmkx X2ZpbGVkYXRhICpmZCwKIAogCWlmIChtYXBwZWQpIHsKIAkJcGNpX3VubWFwX3NpbmdsZShkZC0+ cGNpZGV2LCBub2RlLT5kbWFfYWRkciwKLQkJCQkgbm9kZS0+bW11LmxlbiwgUENJX0RNQV9GUk9N REVWSUNFKTsKKwkJCQkgbm9kZS0+bnBhZ2VzICogUEFHRV9TSVpFLCBQQ0lfRE1BX0ZST01ERVZJ Q0UpOwogCQlwYWdlcyA9ICZub2RlLT5wYWdlc1tpZHhdOwogCX0gZWxzZSB7CiAJCXBhZ2VzID0g JnRpZGJ1Zi0+cGFnZXNbaWR4XTsKQEAgLTc3Nyw4ICs3NTIsOCBAQCBzdGF0aWMgaW50IHNldF9y Y3ZhcnJheV9lbnRyeShzdHJ1Y3QgaGZpMV9maWxlZGF0YSAqZmQsCiAJCXJldHVybiAtRUZBVUxU OwogCX0KIAotCW5vZGUtPm1tdS5hZGRyID0gdGJ1Zi0+dmFkZHIgKyAocGFnZWlkeCAqIFBBR0Vf U0laRSk7Ci0Jbm9kZS0+bW11LmxlbiA9IG5wYWdlcyAqIFBBR0VfU0laRTsKKwlub2RlLT5ub3Rp Zmllci5vcHMgPSAmdGlkX21uX29wczsKKwlub2RlLT5mZGF0YSA9IGZkOwogCW5vZGUtPnBoeXMg PSBwYWdlX3RvX3BoeXMocGFnZXNbMF0pOwogCW5vZGUtPm5wYWdlcyA9IG5wYWdlczsKIAlub2Rl LT5yY3ZlbnRyeSA9IHJjdmVudHJ5OwpAQCAtNzg3LDIzICs3NjIsMzQgQEAgc3RhdGljIGludCBz ZXRfcmN2YXJyYXlfZW50cnkoc3RydWN0IGhmaTFfZmlsZWRhdGEgKmZkLAogCW5vZGUtPmZyZWVk ID0gZmFsc2U7CiAJbWVtY3B5KG5vZGUtPnBhZ2VzLCBwYWdlcywgc2l6ZW9mKHN0cnVjdCBwYWdl ICopICogbnBhZ2VzKTsKIAotCWlmICghZmQtPmhhbmRsZXIpCi0JCXJldCA9IHRpZF9yYl9pbnNl cnQoZmQsICZub2RlLT5tbXUpOwotCWVsc2UKLQkJcmV0ID0gaGZpMV9tbXVfcmJfaW5zZXJ0KGZk LT5oYW5kbGVyLCAmbm9kZS0+bW11KTsKLQotCWlmIChyZXQpIHsKLQkJaGZpMV9jZGJnKFRJRCwg IkZhaWxlZCB0byBpbnNlcnQgUkIgbm9kZSAldSAweCVseCwgMHglbHggJWQiLAotCQkJICBub2Rl LT5yY3ZlbnRyeSwgbm9kZS0+bW11LmFkZHIsIG5vZGUtPnBoeXMsIHJldCk7Ci0JCXBjaV91bm1h cF9zaW5nbGUoZGQtPnBjaWRldiwgcGh5cywgbnBhZ2VzICogUEFHRV9TSVpFLAotCQkJCSBQQ0lf RE1BX0ZST01ERVZJQ0UpOwotCQlrZnJlZShub2RlKTsKLQkJcmV0dXJuIC1FRkFVTFQ7CisJaWYg KGZkLT51c2VfbW4pIHsKKwkJcmV0ID0gbW11X3JhbmdlX25vdGlmaWVyX2luc2VydCgKKwkJCSZu b2RlLT5ub3RpZmllciwgdGJ1Zi0+dmFkZHIgKyAocGFnZWlkeCAqIFBBR0VfU0laRSksCisJCQlu cGFnZXMgKiBQQUdFX1NJWkUsIGZkLT5tbSk7CisJCWlmIChyZXQpCisJCQlnb3RvIG91dF91bm1h cDsKKwkJLyoKKwkJICogRklYTUU6IFRoaXMgaXMgaW4gdGhlIHdyb25nIG9yZGVyLCB0aGUgbm90 aWZpZXIgc2hvdWxkIGJlCisJCSAqIGVzdGFibGlzaGVkIGJlZm9yZSB0aGUgcGFnZXMgYXJlIHBp bm5lZCBieSBwaW5fcmN2X3BhZ2VzLgorCQkgKi8KKwkJbW11X3JhbmdlX3JlYWRfYmVnaW4oJm5v ZGUtPm5vdGlmaWVyKTsKIAl9CisJZmQtPmVudHJ5X3RvX3JiW25vZGUtPnJjdmVudHJ5IC0gdWN0 eHQtPmV4cGVjdGVkX2Jhc2VdID0gbm9kZTsKKwogCWhmaTFfcHV0X3RpZChkZCwgcmN2ZW50cnks IFBUX0VYUEVDVEVELCBwaHlzLCBpbG9nMihucGFnZXMpICsgMSk7CiAJdHJhY2VfaGZpMV9leHBf dGlkX3JlZyh1Y3R4dC0+Y3R4dCwgZmQtPnN1YmN0eHQsIHJjdmVudHJ5LCBucGFnZXMsCi0JCQkg ICAgICAgbm9kZS0+bW11LmFkZHIsIG5vZGUtPnBoeXMsIHBoeXMpOworCQkJICAgICAgIG5vZGUt Pm5vdGlmaWVyLmludGVydmFsX3RyZWUuc3RhcnQsIG5vZGUtPnBoeXMsCisJCQkgICAgICAgcGh5 cyk7CiAJcmV0dXJuIDA7CisKK291dF91bm1hcDoKKwloZmkxX2NkYmcoVElELCAiRmFpbGVkIHRv IGluc2VydCBSQiBub2RlICV1IDB4JWx4LCAweCVseCAlZCIsCisJCSAgbm9kZS0+cmN2ZW50cnks IG5vZGUtPm5vdGlmaWVyLmludGVydmFsX3RyZWUuc3RhcnQsCisJCSAgbm9kZS0+cGh5cywgcmV0 KTsKKwlwY2lfdW5tYXBfc2luZ2xlKGRkLT5wY2lkZXYsIHBoeXMsIG5wYWdlcyAqIFBBR0VfU0la RSwKKwkJCSBQQ0lfRE1BX0ZST01ERVZJQ0UpOworCWtmcmVlKG5vZGUpOworCXJldHVybiAtRUZB VUxUOwogfQogCiBzdGF0aWMgaW50IHVucHJvZ3JhbV9yY3ZhcnJheShzdHJ1Y3QgaGZpMV9maWxl ZGF0YSAqZmQsIHUzMiB0aWRpbmZvLApAQCAtODMzLDEwICs4MTksOSBAQCBzdGF0aWMgaW50IHVu cHJvZ3JhbV9yY3ZhcnJheShzdHJ1Y3QgaGZpMV9maWxlZGF0YSAqZmQsIHUzMiB0aWRpbmZvLAog CWlmIChncnApCiAJCSpncnAgPSBub2RlLT5ncnA7CiAKLQlpZiAoIWZkLT5oYW5kbGVyKQotCQlj YWNoZWxlc3NfdGlkX3JiX3JlbW92ZShmZCwgbm9kZSk7Ci0JZWxzZQotCQloZmkxX21tdV9yYl9y ZW1vdmUoZmQtPmhhbmRsZXIsICZub2RlLT5tbXUpOworCWlmIChmZC0+dXNlX21uKQorCQltbXVf cmFuZ2Vfbm90aWZpZXJfcmVtb3ZlKCZub2RlLT5ub3RpZmllcik7CisJY2FjaGVsZXNzX3RpZF9y Yl9yZW1vdmUoZmQsIG5vZGUpOwogCiAJcmV0dXJuIDA7CiB9CkBAIC04NDcsNyArODMyLDggQEAg c3RhdGljIHZvaWQgY2xlYXJfdGlkX25vZGUoc3RydWN0IGhmaTFfZmlsZWRhdGEgKmZkLCBzdHJ1 Y3QgdGlkX3JiX25vZGUgKm5vZGUpCiAJc3RydWN0IGhmaTFfZGV2ZGF0YSAqZGQgPSB1Y3R4dC0+ ZGQ7CiAKIAl0cmFjZV9oZmkxX2V4cF90aWRfdW5yZWcodWN0eHQtPmN0eHQsIGZkLT5zdWJjdHh0 LCBub2RlLT5yY3ZlbnRyeSwKLQkJCQkgbm9kZS0+bnBhZ2VzLCBub2RlLT5tbXUuYWRkciwgbm9k ZS0+cGh5cywKKwkJCQkgbm9kZS0+bnBhZ2VzLAorCQkJCSBub2RlLT5ub3RpZmllci5pbnRlcnZh bF90cmVlLnN0YXJ0LCBub2RlLT5waHlzLAogCQkJCSBub2RlLT5kbWFfYWRkcik7CiAKIAkvKgpA QCAtODk0LDMwICs4ODAsMjggQEAgc3RhdGljIHZvaWQgdW5sb2NrX2V4cF90aWRzKHN0cnVjdCBo ZmkxX2N0eHRkYXRhICp1Y3R4dCwKIAkJCQlpZiAoIW5vZGUgfHwgbm9kZS0+cmN2ZW50cnkgIT0g cmN2ZW50cnkpCiAJCQkJCWNvbnRpbnVlOwogCisJCQkJaWYgKGZkLT51c2VfbW4pCisJCQkJCW1t dV9yYW5nZV9ub3RpZmllcl9yZW1vdmUoCisJCQkJCQkmbm9kZS0+bm90aWZpZXIpOwogCQkJCWNh Y2hlbGVzc190aWRfcmJfcmVtb3ZlKGZkLCBub2RlKTsKIAkJCX0KIAkJfQogCX0KIH0KIAotLyoK LSAqIEFsd2F5cyByZXR1cm4gMCBmcm9tIHRoaXMgZnVuY3Rpb24uICBBIG5vbi16ZXJvIHJldHVy biBpbmRpY2F0ZXMgdGhhdCB0aGUKLSAqIHJlbW92ZSBvcGVyYXRpb24gd2lsbCBiZSBjYWxsZWQg YW5kIHRoYXQgbWVtb3J5IHNob3VsZCBiZSB1bnBpbm5lZC4KLSAqIEhvd2V2ZXIsIHRoZSBkcml2 ZXIgY2Fubm90IHVucGluIG91dCBmcm9tIHVuZGVyIFBTTS4gIEluc3RlYWQsIHJldGFpbiB0aGUK LSAqIG1lbW9yeSAoYnkgcmV0dXJuaW5nIDApIGFuZCBpbmZvcm0gUFNNIHRoYXQgdGhlIG1lbW9y eSBpcyBnb2luZyBhd2F5LiAgUFNNCi0gKiB3aWxsIGNhbGwgYmFjayBsYXRlciB3aGVuIGl0IGhh cyByZW1vdmVkIHRoZSBtZW1vcnkgZnJvbSBpdHMgbGlzdC4KLSAqLwotc3RhdGljIGludCB0aWRf cmJfaW52YWxpZGF0ZSh2b2lkICphcmcsIHN0cnVjdCBtbXVfcmJfbm9kZSAqbW5vZGUpCitzdGF0 aWMgYm9vbCB0aWRfcmJfaW52YWxpZGF0ZShzdHJ1Y3QgbW11X3JhbmdlX25vdGlmaWVyICptcm4s CisJCQkgICAgICBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICpyYW5nZSkKIHsKLQlz dHJ1Y3QgaGZpMV9maWxlZGF0YSAqZmRhdGEgPSBhcmc7Ci0Jc3RydWN0IGhmaTFfY3R4dGRhdGEg KnVjdHh0ID0gZmRhdGEtPnVjdHh0OwogCXN0cnVjdCB0aWRfcmJfbm9kZSAqbm9kZSA9Ci0JCWNv bnRhaW5lcl9vZihtbm9kZSwgc3RydWN0IHRpZF9yYl9ub2RlLCBtbXUpOworCQljb250YWluZXJf b2YobXJuLCBzdHJ1Y3QgdGlkX3JiX25vZGUsIG5vdGlmaWVyKTsKKwlzdHJ1Y3QgaGZpMV9maWxl ZGF0YSAqZmRhdGEgPSBub2RlLT5mZGF0YTsKKwlzdHJ1Y3QgaGZpMV9jdHh0ZGF0YSAqdWN0eHQg PSBmZGF0YS0+dWN0eHQ7CiAKIAlpZiAobm9kZS0+ZnJlZWQpCi0JCXJldHVybiAwOworCQlyZXR1 cm4gdHJ1ZTsKIAotCXRyYWNlX2hmaTFfZXhwX3RpZF9pbnZhbCh1Y3R4dC0+Y3R4dCwgZmRhdGEt PnN1YmN0eHQsIG5vZGUtPm1tdS5hZGRyLAorCXRyYWNlX2hmaTFfZXhwX3RpZF9pbnZhbCh1Y3R4 dC0+Y3R4dCwgZmRhdGEtPnN1YmN0eHQsCisJCQkJIG5vZGUtPm5vdGlmaWVyLmludGVydmFsX3Ry ZWUuc3RhcnQsCiAJCQkJIG5vZGUtPnJjdmVudHJ5LCBub2RlLT5ucGFnZXMsIG5vZGUtPmRtYV9h ZGRyKTsKIAlub2RlLT5mcmVlZCA9IHRydWU7CiAKQEAgLTk0NiwxOCArOTMwLDcgQEAgc3RhdGlj IGludCB0aWRfcmJfaW52YWxpZGF0ZSh2b2lkICphcmcsIHN0cnVjdCBtbXVfcmJfbm9kZSAqbW5v ZGUpCiAJCWZkYXRhLT5pbnZhbGlkX3RpZF9pZHgrKzsKIAl9CiAJc3Bpbl91bmxvY2soJmZkYXRh LT5pbnZhbGlkX2xvY2spOwotCXJldHVybiAwOwotfQotCi1zdGF0aWMgaW50IHRpZF9yYl9pbnNl cnQodm9pZCAqYXJnLCBzdHJ1Y3QgbW11X3JiX25vZGUgKm5vZGUpCi17Ci0Jc3RydWN0IGhmaTFf ZmlsZWRhdGEgKmZkYXRhID0gYXJnOwotCXN0cnVjdCB0aWRfcmJfbm9kZSAqdG5vZGUgPQotCQlj b250YWluZXJfb2Yobm9kZSwgc3RydWN0IHRpZF9yYl9ub2RlLCBtbXUpOwotCXUzMiBiYXNlID0g ZmRhdGEtPnVjdHh0LT5leHBlY3RlZF9iYXNlOwotCi0JZmRhdGEtPmVudHJ5X3RvX3JiW3Rub2Rl LT5yY3ZlbnRyeSAtIGJhc2VdID0gdG5vZGU7Ci0JcmV0dXJuIDA7CisJcmV0dXJuIHRydWU7CiB9 CiAKIHN0YXRpYyB2b2lkIGNhY2hlbGVzc190aWRfcmJfcmVtb3ZlKHN0cnVjdCBoZmkxX2ZpbGVk YXRhICpmZGF0YSwKQEAgLTk2OCwxMiArOTQxLDMgQEAgc3RhdGljIHZvaWQgY2FjaGVsZXNzX3Rp ZF9yYl9yZW1vdmUoc3RydWN0IGhmaTFfZmlsZWRhdGEgKmZkYXRhLAogCWZkYXRhLT5lbnRyeV90 b19yYlt0bm9kZS0+cmN2ZW50cnkgLSBiYXNlXSA9IE5VTEw7CiAJY2xlYXJfdGlkX25vZGUoZmRh dGEsIHRub2RlKTsKIH0KLQotc3RhdGljIHZvaWQgdGlkX3JiX3JlbW92ZSh2b2lkICphcmcsIHN0 cnVjdCBtbXVfcmJfbm9kZSAqbm9kZSkKLXsKLQlzdHJ1Y3QgaGZpMV9maWxlZGF0YSAqZmRhdGEg PSBhcmc7Ci0Jc3RydWN0IHRpZF9yYl9ub2RlICp0bm9kZSA9Ci0JCWNvbnRhaW5lcl9vZihub2Rl LCBzdHJ1Y3QgdGlkX3JiX25vZGUsIG1tdSk7Ci0KLQljYWNoZWxlc3NfdGlkX3JiX3JlbW92ZShm ZGF0YSwgdG5vZGUpOwotfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L2hmaTEv dXNlcl9leHBfcmN2LmggYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvaGZpMS91c2VyX2V4cF9yY3Yu aAppbmRleCA0M2IxMDVkZTFkNTQyNy4uYjUzMTRkYjA4M2IxMjUgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvaW5maW5pYmFuZC9ody9oZmkxL3VzZXJfZXhwX3Jjdi5oCisrKyBiL2RyaXZlcnMvaW5maW5p YmFuZC9ody9oZmkxL3VzZXJfZXhwX3Jjdi5oCkBAIC02NSw3ICs2NSw4IEBAIHN0cnVjdCB0aWRf dXNlcl9idWYgewogfTsKIAogc3RydWN0IHRpZF9yYl9ub2RlIHsKLQlzdHJ1Y3QgbW11X3JiX25v ZGUgbW11OworCXN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXIgbm90aWZpZXI7CisJc3RydWN0IGhm aTFfZmlsZWRhdGEgKmZkYXRhOwogCXVuc2lnbmVkIGxvbmcgcGh5czsKIAlzdHJ1Y3QgdGlkX2dy b3VwICpncnA7CiAJdTMyIHJjdmVudHJ5OwotLSAKMi4yMy4wCgpfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwphbWQtZ2Z4IG1haWxpbmcgbGlzdAphbWQtZ2Z4 QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWls bWFuL2xpc3RpbmZvL2FtZC1nZng=