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 958D7ECE59F 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 6843522459 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="WiNBwI0G" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1731849AbfJOSQh (ORCPT ); Tue, 15 Oct 2019 14:16:37 -0400 Received: from mail-pf1-f194.google.com ([209.85.210.194]:40745 "EHLO mail-pf1-f194.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726597AbfJOSQh (ORCPT ); Tue, 15 Oct 2019 14:16:37 -0400 Received: by mail-pf1-f194.google.com with SMTP id x127so12982791pfb.7 for ; Tue, 15 Oct 2019 11:16:36 -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=MxqnjxtjZspeclsXsb8TqT2XAaJcx6OqXrPL9/3uTio=; b=WiNBwI0GEvMvrWy1ehAPzHRxBZcfkJSDVZrcxckbtOPYt0vilEpIpP8MuNdNVhWXh/ SoU7AiEKzDV+QL81bsPgbpfq+LBhaGTtTP+QDOvoWJqBswnzIRdWSR+anuvJLw7gZoEz MG2BHvGJ2xGRlTL7RhF6fFc30sLQFXJNGWjEm9KetbUqhrj/xaFnsKMGwsr42FtdSvLx XqrWoiB1312d7qQdNj5TiQHX313Me5YQ0lbuuEp5CyhbguZepRaNWvZh8D2ULLwEGn8F xAFRajXxsiJOuRNHlRfUZavKLGb1h6R5WAprKRtw1VwU9Pgku3H2/DtvLcTXlbyGYLGD 6i5w== 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=MxqnjxtjZspeclsXsb8TqT2XAaJcx6OqXrPL9/3uTio=; b=r9PTBkYf4p2JjmawbjbgMBw7k9tofJMo5hVGxaPm67RPngQi0Z+zHl/synf5oc//0c x+je6+eQ9CSe5GRa3nfI8fNWF1KsUgYL47J4IJ5QOCDTnym7UcB5Hhhub5fZZfROFSUD EVwf/iDWq5LBHKi0qRXoFJcWC9jE3YMt+ocUZ3nStuES9SVsmmCOasRvMgio/xCbZacd BMEkT4LJG4ktEzlOdyG3ilHdU4FBesEQVJUwfaMPGWZ23P0MoDmdtj4N4vIPIE9hcJ3a 4IMbM6J9JVLBArLxB6jr9SKsWTxtgqw3V+RyeWgCHBRAoWlZXM1O+/rCoexStj4dV7a/ BGuw== X-Gm-Message-State: APjAAAWGyodMRt8rUmB4wV4Bfb1m1ZnzTTLaXmBocKjd4q+M+lRND/b/ gjtzKF8//Hi0/TK22MVgpu7i5w== X-Google-Smtp-Source: APXvYqw20wAIkHWageKs4SNh5mkhjScT2YJ5H9fLuHv7ambuFgJzJJY4hoXPq9r1gGkqghcn4QMTOQ== X-Received: by 2002:a17:90a:fb92:: with SMTP id cp18mr45187520pjb.2.1571163395890; Tue, 15 Oct 2019 11:16:35 -0700 (PDT) Received: from ziepe.ca ([24.114.26.129]) by smtp.gmail.com with ESMTPSA id o11sm19024878pgp.13.2019.10.15.11.16.35 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Tue, 15 Oct 2019 11:16:35 -0700 (PDT) Received: from jgg by jggl.ziepe.ca with local (Exim 4.90_1) (envelope-from ) id 1iKRJT-0002CG-Gd; 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 , Alex Deucher , =?UTF-8?q?Christian=20K=C3=B6nig?= , David Zhou , Petr Cvek Subject: [PATCH hmm 07/15] drm/radeon: use mmu_range_notifier_insert Date: Tue, 15 Oct 2019 15:12:34 -0300 Message-Id: <20191015181242.8343-8-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-Type: text/plain; charset=UTF-8 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 The new API is an exact match for the needs of radeon. For some reason radeon tries to remove overlapping ranges from the interval tree, but interval trees (and mmu_range_notifier_insert) support overlapping ranges directly. Simply delete all this code. Since this driver is missing a invalidate_range_end callback, but still calls get_user_pages(), it cannot be correct against all races. Cc: Alex Deucher Cc: Christian König Cc: David (ChunMing) Zhou Cc: amd-gfx@lists.freedesktop.org Cc: Petr Cvek Signed-off-by: Jason Gunthorpe --- drivers/gpu/drm/radeon/radeon.h | 9 +- drivers/gpu/drm/radeon/radeon_mn.c | 218 ++++++----------------------- 2 files changed, 51 insertions(+), 176 deletions(-) diff --git a/drivers/gpu/drm/radeon/radeon.h b/drivers/gpu/drm/radeon/radeon.h index d59b004f669583..27959f3ace1152 100644 --- a/drivers/gpu/drm/radeon/radeon.h +++ b/drivers/gpu/drm/radeon/radeon.h @@ -68,6 +68,10 @@ #include #include +#ifdef CONFIG_MMU_NOTIFIER +#include +#endif + #include #include #include @@ -509,8 +513,9 @@ struct radeon_bo { struct ttm_bo_kmap_obj dma_buf_vmap; pid_t pid; - struct radeon_mn *mn; - struct list_head mn_list; +#ifdef CONFIG_MMU_NOTIFIER + struct mmu_range_notifier notifier; +#endif }; #define gem_to_radeon_bo(gobj) container_of((gobj), struct radeon_bo, tbo.base) diff --git a/drivers/gpu/drm/radeon/radeon_mn.c b/drivers/gpu/drm/radeon/radeon_mn.c index dbab9a3a969b9e..2ea90874c535f5 100644 --- a/drivers/gpu/drm/radeon/radeon_mn.c +++ b/drivers/gpu/drm/radeon/radeon_mn.c @@ -36,131 +36,50 @@ #include "radeon.h" -struct radeon_mn { - struct mmu_notifier mn; - - /* objects protected by lock */ - struct mutex lock; - struct rb_root_cached objects; -}; - -struct radeon_mn_node { - struct interval_tree_node it; - struct list_head bos; -}; - /** - * radeon_mn_invalidate_range_start - callback to notify about mm change + * radeon_mn_invalidate - callback to notify about mm change * * @mn: our notifier - * @mn: the mm this callback is about - * @start: start of updated range - * @end: end of updated range + * @range: the VMA under invalidation * * We block for all BOs between start and end to be idle and * unmap them by move them into system domain again. */ -static int radeon_mn_invalidate_range_start(struct mmu_notifier *mn, - const struct mmu_notifier_range *range) +static bool radeon_mn_invalidate(struct mmu_range_notifier *mn, + const struct mmu_notifier_range *range) { - struct radeon_mn *rmn = container_of(mn, struct radeon_mn, mn); + struct radeon_bo *bo = container_of(mn, struct radeon_bo, notifier); struct ttm_operation_ctx ctx = { false, false }; - struct interval_tree_node *it; - unsigned long end; - int ret = 0; - - /* notification is exclusive, but interval is inclusive */ - end = range->end - 1; - - /* TODO we should be able to split locking for interval tree and - * the tear down. - */ - if (mmu_notifier_range_blockable(range)) - mutex_lock(&rmn->lock); - else if (!mutex_trylock(&rmn->lock)) - return -EAGAIN; - - it = interval_tree_iter_first(&rmn->objects, range->start, end); - while (it) { - struct radeon_mn_node *node; - struct radeon_bo *bo; - long r; - - if (!mmu_notifier_range_blockable(range)) { - ret = -EAGAIN; - goto out_unlock; - } - - node = container_of(it, struct radeon_mn_node, it); - it = interval_tree_iter_next(it, range->start, end); + long r; - list_for_each_entry(bo, &node->bos, mn_list) { + if (!bo->tbo.ttm || bo->tbo.ttm->state != tt_bound) + return true; - if (!bo->tbo.ttm || bo->tbo.ttm->state != tt_bound) - continue; + if (!mmu_notifier_range_blockable(range)) + return false; - r = radeon_bo_reserve(bo, true); - if (r) { - DRM_ERROR("(%ld) failed to reserve user bo\n", r); - continue; - } - - r = dma_resv_wait_timeout_rcu(bo->tbo.base.resv, - true, false, MAX_SCHEDULE_TIMEOUT); - if (r <= 0) - DRM_ERROR("(%ld) failed to wait for user bo\n", r); - - radeon_ttm_placement_from_domain(bo, RADEON_GEM_DOMAIN_CPU); - r = ttm_bo_validate(&bo->tbo, &bo->placement, &ctx); - if (r) - DRM_ERROR("(%ld) failed to validate user bo\n", r); - - radeon_bo_unreserve(bo); - } + r = radeon_bo_reserve(bo, true); + if (r) { + DRM_ERROR("(%ld) failed to reserve user bo\n", r); + return true; } - -out_unlock: - mutex_unlock(&rmn->lock); - - return ret; -} - -static void radeon_mn_release(struct mmu_notifier *mn, struct mm_struct *mm) -{ - struct mmu_notifier_range range = { - .mm = mm, - .start = 0, - .end = ULONG_MAX, - .flags = 0, - .event = MMU_NOTIFY_UNMAP, - }; - - radeon_mn_invalidate_range_start(mn, &range); -} - -static struct mmu_notifier *radeon_mn_alloc_notifier(struct mm_struct *mm) -{ - struct radeon_mn *rmn; - rmn = kzalloc(sizeof(*rmn), GFP_KERNEL); - if (!rmn) - return ERR_PTR(-ENOMEM); + r = dma_resv_wait_timeout_rcu(bo->tbo.base.resv, true, false, + MAX_SCHEDULE_TIMEOUT); + if (r <= 0) + DRM_ERROR("(%ld) failed to wait for user bo\n", r); - mutex_init(&rmn->lock); - rmn->objects = RB_ROOT_CACHED; - return &rmn->mn; -} + radeon_ttm_placement_from_domain(bo, RADEON_GEM_DOMAIN_CPU); + r = ttm_bo_validate(&bo->tbo, &bo->placement, &ctx); + if (r) + DRM_ERROR("(%ld) failed to validate user bo\n", r); -static void radeon_mn_free_notifier(struct mmu_notifier *mn) -{ - kfree(container_of(mn, struct radeon_mn, mn)); + radeon_bo_unreserve(bo); + return true; } -static const struct mmu_notifier_ops radeon_mn_ops = { - .release = radeon_mn_release, - .invalidate_range_start = radeon_mn_invalidate_range_start, - .alloc_notifier = radeon_mn_alloc_notifier, - .free_notifier = radeon_mn_free_notifier, +static const struct mmu_range_notifier_ops radeon_mn_ops = { + .invalidate = radeon_mn_invalidate, }; /** @@ -174,51 +93,21 @@ static const struct mmu_notifier_ops radeon_mn_ops = { */ int radeon_mn_register(struct radeon_bo *bo, unsigned long addr) { - unsigned long end = addr + radeon_bo_size(bo) - 1; - struct mmu_notifier *mn; - struct radeon_mn *rmn; - struct radeon_mn_node *node = NULL; - struct list_head bos; - struct interval_tree_node *it; - - mn = mmu_notifier_get(&radeon_mn_ops, current->mm); - if (IS_ERR(mn)) - return PTR_ERR(mn); - rmn = container_of(mn, struct radeon_mn, mn); - - INIT_LIST_HEAD(&bos); - - mutex_lock(&rmn->lock); - - while ((it = interval_tree_iter_first(&rmn->objects, addr, end))) { - kfree(node); - node = container_of(it, struct radeon_mn_node, it); - interval_tree_remove(&node->it, &rmn->objects); - addr = min(it->start, addr); - end = max(it->last, end); - list_splice(&node->bos, &bos); - } - - if (!node) { - node = kmalloc(sizeof(struct radeon_mn_node), GFP_KERNEL); - if (!node) { - mutex_unlock(&rmn->lock); - return -ENOMEM; - } - } - - bo->mn = rmn; - - node->it.start = addr; - node->it.last = end; - INIT_LIST_HEAD(&node->bos); - list_splice(&bos, &node->bos); - list_add(&bo->mn_list, &node->bos); - - interval_tree_insert(&node->it, &rmn->objects); - - mutex_unlock(&rmn->lock); - + int ret; + + bo->notifier.ops = &radeon_mn_ops; + ret = mmu_range_notifier_insert(&bo->notifier, addr, radeon_bo_size(bo), + current->mm); + if (ret) + return ret; + + /* + * FIXME: radeon appears to allow get_user_pages to run during + * invalidate_range_start/end, which is not a safe way to read the + * PTEs. It should use the mmu_range_read_begin() scheme around the + * get_user_pages to ensure that the PTEs are read properly + */ + mmu_range_read_begin(&bo->notifier); return 0; } @@ -231,27 +120,8 @@ int radeon_mn_register(struct radeon_bo *bo, unsigned long addr) */ void radeon_mn_unregister(struct radeon_bo *bo) { - struct radeon_mn *rmn = bo->mn; - struct list_head *head; - - if (!rmn) + if (!bo->notifier.mm) return; - - mutex_lock(&rmn->lock); - /* save the next list entry for later */ - head = bo->mn_list.next; - - list_del(&bo->mn_list); - - if (list_empty(head)) { - struct radeon_mn_node *node; - node = container_of(head, struct radeon_mn_node, bos); - interval_tree_remove(&node->it, &rmn->objects); - kfree(node); - } - - mutex_unlock(&rmn->lock); - - mmu_notifier_put(&rmn->mn); - bo->mn = NULL; + mmu_range_notifier_remove(&bo->notifier); + bo->notifier.mm = NULL; } -- 2.23.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jason Gunthorpe Subject: [PATCH hmm 07/15] drm/radeon: use mmu_range_notifier_insert Date: Tue, 15 Oct 2019 15:12:34 -0300 Message-ID: <20191015181242.8343-8-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 , David Zhou , linux-rdma-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, amd-gfx-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, linux-mm-Bw31MaZKKs3YtjvyW6yDsg@public.gmane.org, Jason Gunthorpe , dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, Alex Deucher , Petr Cvek , =?UTF-8?q?Christian=20K=C3=B6nig?= , Ben Skeggs List-Id: dri-devel@lists.freedesktop.org RnJvbTogSmFzb24gR3VudGhvcnBlIDxqZ2dAbWVsbGFub3guY29tPgoKVGhlIG5ldyBBUEkgaXMg YW4gZXhhY3QgbWF0Y2ggZm9yIHRoZSBuZWVkcyBvZiByYWRlb24uCgpGb3Igc29tZSByZWFzb24g cmFkZW9uIHRyaWVzIHRvIHJlbW92ZSBvdmVybGFwcGluZyByYW5nZXMgZnJvbSB0aGUKaW50ZXJ2 YWwgdHJlZSwgYnV0IGludGVydmFsIHRyZWVzIChhbmQgbW11X3JhbmdlX25vdGlmaWVyX2luc2Vy dCkKc3VwcG9ydCBvdmVybGFwcGluZyByYW5nZXMgZGlyZWN0bHkuIFNpbXBseSBkZWxldGUgYWxs IHRoaXMgY29kZS4KClNpbmNlIHRoaXMgZHJpdmVyIGlzIG1pc3NpbmcgYSBpbnZhbGlkYXRlX3Jh bmdlX2VuZCBjYWxsYmFjaywgYnV0CnN0aWxsIGNhbGxzIGdldF91c2VyX3BhZ2VzKCksIGl0IGNh bm5vdCBiZSBjb3JyZWN0IGFnYWluc3QgYWxsIHJhY2VzLgoKQ2M6IEFsZXggRGV1Y2hlciA8YWxl eGFuZGVyLmRldWNoZXJAYW1kLmNvbT4KQ2M6IENocmlzdGlhbiBLw7ZuaWcgPGNocmlzdGlhbi5r b2VuaWdAYW1kLmNvbT4KQ2M6IERhdmlkIChDaHVuTWluZykgWmhvdSA8RGF2aWQxLlpob3VAYW1k LmNvbT4KQ2M6IGFtZC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCkNjOiBQZXRyIEN2ZWsgPHBl dHJjdmVrY3pAZ21haWwuY29tPgpTaWduZWQtb2ZmLWJ5OiBKYXNvbiBHdW50aG9ycGUgPGpnZ0Bt ZWxsYW5veC5jb20+Ci0tLQogZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb24uaCAgICB8ICAg OSArLQogZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fbW4uYyB8IDIxOCArKysrKystLS0t LS0tLS0tLS0tLS0tLS0tLS0tLQogMiBmaWxlcyBjaGFuZ2VkLCA1MSBpbnNlcnRpb25zKCspLCAx NzYgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRl b24uaCBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uLmgKaW5kZXggZDU5YjAwNGY2Njk1 ODMuLjI3OTU5ZjNhY2UxMTUyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3Jh ZGVvbi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uLmgKQEAgLTY4LDYgKzY4 LDEwIEBACiAjaW5jbHVkZSA8bGludXgvaGFzaHRhYmxlLmg+CiAjaW5jbHVkZSA8bGludXgvZG1h LWZlbmNlLmg+CiAKKyNpZmRlZiBDT05GSUdfTU1VX05PVElGSUVSCisjaW5jbHVkZSA8bGludXgv bW11X25vdGlmaWVyLmg+CisjZW5kaWYKKwogI2luY2x1ZGUgPGRybS90dG0vdHRtX2JvX2FwaS5o PgogI2luY2x1ZGUgPGRybS90dG0vdHRtX2JvX2RyaXZlci5oPgogI2luY2x1ZGUgPGRybS90dG0v dHRtX3BsYWNlbWVudC5oPgpAQCAtNTA5LDggKzUxMyw5IEBAIHN0cnVjdCByYWRlb25fYm8gewog CXN0cnVjdCB0dG1fYm9fa21hcF9vYmoJCWRtYV9idWZfdm1hcDsKIAlwaWRfdAkJCQlwaWQ7CiAK LQlzdHJ1Y3QgcmFkZW9uX21uCQkqbW47Ci0Jc3RydWN0IGxpc3RfaGVhZAkJbW5fbGlzdDsKKyNp ZmRlZiBDT05GSUdfTU1VX05PVElGSUVSCisJc3RydWN0IG1tdV9yYW5nZV9ub3RpZmllcglub3Rp ZmllcjsKKyNlbmRpZgogfTsKICNkZWZpbmUgZ2VtX3RvX3JhZGVvbl9ibyhnb2JqKSBjb250YWlu ZXJfb2YoKGdvYmopLCBzdHJ1Y3QgcmFkZW9uX2JvLCB0Ym8uYmFzZSkKIApkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fbW4uYyBiL2RyaXZlcnMvZ3B1L2RybS9yYWRl b24vcmFkZW9uX21uLmMKaW5kZXggZGJhYjlhM2E5NjliOWUuLjJlYTkwODc0YzUzNWY1IDEwMDY0 NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9tbi5jCisrKyBiL2RyaXZlcnMv Z3B1L2RybS9yYWRlb24vcmFkZW9uX21uLmMKQEAgLTM2LDEzMSArMzYsNTAgQEAKIAogI2luY2x1 ZGUgInJhZGVvbi5oIgogCi1zdHJ1Y3QgcmFkZW9uX21uIHsKLQlzdHJ1Y3QgbW11X25vdGlmaWVy CW1uOwotCi0JLyogb2JqZWN0cyBwcm90ZWN0ZWQgYnkgbG9jayAqLwotCXN0cnVjdCBtdXRleAkJ bG9jazsKLQlzdHJ1Y3QgcmJfcm9vdF9jYWNoZWQJb2JqZWN0czsKLX07Ci0KLXN0cnVjdCByYWRl b25fbW5fbm9kZSB7Ci0Jc3RydWN0IGludGVydmFsX3RyZWVfbm9kZQlpdDsKLQlzdHJ1Y3QgbGlz dF9oZWFkCQlib3M7Ci19OwotCiAvKioKLSAqIHJhZGVvbl9tbl9pbnZhbGlkYXRlX3JhbmdlX3N0 YXJ0IC0gY2FsbGJhY2sgdG8gbm90aWZ5IGFib3V0IG1tIGNoYW5nZQorICogcmFkZW9uX21uX2lu dmFsaWRhdGUgLSBjYWxsYmFjayB0byBub3RpZnkgYWJvdXQgbW0gY2hhbmdlCiAgKgogICogQG1u OiBvdXIgbm90aWZpZXIKLSAqIEBtbjogdGhlIG1tIHRoaXMgY2FsbGJhY2sgaXMgYWJvdXQKLSAq IEBzdGFydDogc3RhcnQgb2YgdXBkYXRlZCByYW5nZQotICogQGVuZDogZW5kIG9mIHVwZGF0ZWQg cmFuZ2UKKyAqIEByYW5nZTogdGhlIFZNQSB1bmRlciBpbnZhbGlkYXRpb24KICAqCiAgKiBXZSBi bG9jayBmb3IgYWxsIEJPcyBiZXR3ZWVuIHN0YXJ0IGFuZCBlbmQgdG8gYmUgaWRsZSBhbmQKICAq IHVubWFwIHRoZW0gYnkgbW92ZSB0aGVtIGludG8gc3lzdGVtIGRvbWFpbiBhZ2Fpbi4KICAqLwot c3RhdGljIGludCByYWRlb25fbW5faW52YWxpZGF0ZV9yYW5nZV9zdGFydChzdHJ1Y3QgbW11X25v dGlmaWVyICptbiwKLQkJCQljb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICpyYW5nZSkK K3N0YXRpYyBib29sIHJhZGVvbl9tbl9pbnZhbGlkYXRlKHN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZp ZXIgKm1uLAorCQkJCSBjb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3JhbmdlICpyYW5nZSkKIHsK LQlzdHJ1Y3QgcmFkZW9uX21uICpybW4gPSBjb250YWluZXJfb2YobW4sIHN0cnVjdCByYWRlb25f bW4sIG1uKTsKKwlzdHJ1Y3QgcmFkZW9uX2JvICpibyA9IGNvbnRhaW5lcl9vZihtbiwgc3RydWN0 IHJhZGVvbl9ibywgbm90aWZpZXIpOwogCXN0cnVjdCB0dG1fb3BlcmF0aW9uX2N0eCBjdHggPSB7 IGZhbHNlLCBmYWxzZSB9OwotCXN0cnVjdCBpbnRlcnZhbF90cmVlX25vZGUgKml0OwotCXVuc2ln bmVkIGxvbmcgZW5kOwotCWludCByZXQgPSAwOwotCi0JLyogbm90aWZpY2F0aW9uIGlzIGV4Y2x1 c2l2ZSwgYnV0IGludGVydmFsIGlzIGluY2x1c2l2ZSAqLwotCWVuZCA9IHJhbmdlLT5lbmQgLSAx OwotCi0JLyogVE9ETyB3ZSBzaG91bGQgYmUgYWJsZSB0byBzcGxpdCBsb2NraW5nIGZvciBpbnRl cnZhbCB0cmVlIGFuZAotCSAqIHRoZSB0ZWFyIGRvd24uCi0JICovCi0JaWYgKG1tdV9ub3RpZmll cl9yYW5nZV9ibG9ja2FibGUocmFuZ2UpKQotCQltdXRleF9sb2NrKCZybW4tPmxvY2spOwotCWVs c2UgaWYgKCFtdXRleF90cnlsb2NrKCZybW4tPmxvY2spKQotCQlyZXR1cm4gLUVBR0FJTjsKLQot CWl0ID0gaW50ZXJ2YWxfdHJlZV9pdGVyX2ZpcnN0KCZybW4tPm9iamVjdHMsIHJhbmdlLT5zdGFy dCwgZW5kKTsKLQl3aGlsZSAoaXQpIHsKLQkJc3RydWN0IHJhZGVvbl9tbl9ub2RlICpub2RlOwot CQlzdHJ1Y3QgcmFkZW9uX2JvICpibzsKLQkJbG9uZyByOwotCi0JCWlmICghbW11X25vdGlmaWVy X3JhbmdlX2Jsb2NrYWJsZShyYW5nZSkpIHsKLQkJCXJldCA9IC1FQUdBSU47Ci0JCQlnb3RvIG91 dF91bmxvY2s7Ci0JCX0KLQotCQlub2RlID0gY29udGFpbmVyX29mKGl0LCBzdHJ1Y3QgcmFkZW9u X21uX25vZGUsIGl0KTsKLQkJaXQgPSBpbnRlcnZhbF90cmVlX2l0ZXJfbmV4dChpdCwgcmFuZ2Ut PnN0YXJ0LCBlbmQpOworCWxvbmcgcjsKIAotCQlsaXN0X2Zvcl9lYWNoX2VudHJ5KGJvLCAmbm9k ZS0+Ym9zLCBtbl9saXN0KSB7CisJaWYgKCFiby0+dGJvLnR0bSB8fCBiby0+dGJvLnR0bS0+c3Rh dGUgIT0gdHRfYm91bmQpCisJCXJldHVybiB0cnVlOwogCi0JCQlpZiAoIWJvLT50Ym8udHRtIHx8 IGJvLT50Ym8udHRtLT5zdGF0ZSAhPSB0dF9ib3VuZCkKLQkJCQljb250aW51ZTsKKwlpZiAoIW1t dV9ub3RpZmllcl9yYW5nZV9ibG9ja2FibGUocmFuZ2UpKQorCQlyZXR1cm4gZmFsc2U7CiAKLQkJ CXIgPSByYWRlb25fYm9fcmVzZXJ2ZShibywgdHJ1ZSk7Ci0JCQlpZiAocikgewotCQkJCURSTV9F UlJPUigiKCVsZCkgZmFpbGVkIHRvIHJlc2VydmUgdXNlciBib1xuIiwgcik7Ci0JCQkJY29udGlu dWU7Ci0JCQl9Ci0KLQkJCXIgPSBkbWFfcmVzdl93YWl0X3RpbWVvdXRfcmN1KGJvLT50Ym8uYmFz ZS5yZXN2LAotCQkJCXRydWUsIGZhbHNlLCBNQVhfU0NIRURVTEVfVElNRU9VVCk7Ci0JCQlpZiAo ciA8PSAwKQotCQkJCURSTV9FUlJPUigiKCVsZCkgZmFpbGVkIHRvIHdhaXQgZm9yIHVzZXIgYm9c biIsIHIpOwotCi0JCQlyYWRlb25fdHRtX3BsYWNlbWVudF9mcm9tX2RvbWFpbihibywgUkFERU9O X0dFTV9ET01BSU5fQ1BVKTsKLQkJCXIgPSB0dG1fYm9fdmFsaWRhdGUoJmJvLT50Ym8sICZiby0+ cGxhY2VtZW50LCAmY3R4KTsKLQkJCWlmIChyKQotCQkJCURSTV9FUlJPUigiKCVsZCkgZmFpbGVk IHRvIHZhbGlkYXRlIHVzZXIgYm9cbiIsIHIpOwotCi0JCQlyYWRlb25fYm9fdW5yZXNlcnZlKGJv KTsKLQkJfQorCXIgPSByYWRlb25fYm9fcmVzZXJ2ZShibywgdHJ1ZSk7CisJaWYgKHIpIHsKKwkJ RFJNX0VSUk9SKCIoJWxkKSBmYWlsZWQgdG8gcmVzZXJ2ZSB1c2VyIGJvXG4iLCByKTsKKwkJcmV0 dXJuIHRydWU7CiAJfQotCQotb3V0X3VubG9jazoKLQltdXRleF91bmxvY2soJnJtbi0+bG9jayk7 Ci0KLQlyZXR1cm4gcmV0OwotfQotCi1zdGF0aWMgdm9pZCByYWRlb25fbW5fcmVsZWFzZShzdHJ1 Y3QgbW11X25vdGlmaWVyICptbiwgc3RydWN0IG1tX3N0cnVjdCAqbW0pCi17Ci0Jc3RydWN0IG1t dV9ub3RpZmllcl9yYW5nZSByYW5nZSA9IHsKLQkJLm1tID0gbW0sCi0JCS5zdGFydCA9IDAsCi0J CS5lbmQgPSBVTE9OR19NQVgsCi0JCS5mbGFncyA9IDAsCi0JCS5ldmVudCA9IE1NVV9OT1RJRllf VU5NQVAsCi0JfTsKLQotCXJhZGVvbl9tbl9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KG1uLCAmcmFu Z2UpOwotfQotCi1zdGF0aWMgc3RydWN0IG1tdV9ub3RpZmllciAqcmFkZW9uX21uX2FsbG9jX25v dGlmaWVyKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQotewotCXN0cnVjdCByYWRlb25fbW4gKnJtbjsK IAotCXJtbiA9IGt6YWxsb2Moc2l6ZW9mKCpybW4pLCBHRlBfS0VSTkVMKTsKLQlpZiAoIXJtbikK LQkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7CisJciA9IGRtYV9yZXN2X3dhaXRfdGltZW91dF9y Y3UoYm8tPnRiby5iYXNlLnJlc3YsIHRydWUsIGZhbHNlLAorCQkJCSAgICAgIE1BWF9TQ0hFRFVM RV9USU1FT1VUKTsKKwlpZiAociA8PSAwKQorCQlEUk1fRVJST1IoIiglbGQpIGZhaWxlZCB0byB3 YWl0IGZvciB1c2VyIGJvXG4iLCByKTsKIAotCW11dGV4X2luaXQoJnJtbi0+bG9jayk7Ci0Jcm1u LT5vYmplY3RzID0gUkJfUk9PVF9DQUNIRUQ7Ci0JcmV0dXJuICZybW4tPm1uOwotfQorCXJhZGVv bl90dG1fcGxhY2VtZW50X2Zyb21fZG9tYWluKGJvLCBSQURFT05fR0VNX0RPTUFJTl9DUFUpOwor CXIgPSB0dG1fYm9fdmFsaWRhdGUoJmJvLT50Ym8sICZiby0+cGxhY2VtZW50LCAmY3R4KTsKKwlp ZiAocikKKwkJRFJNX0VSUk9SKCIoJWxkKSBmYWlsZWQgdG8gdmFsaWRhdGUgdXNlciBib1xuIiwg cik7CiAKLXN0YXRpYyB2b2lkIHJhZGVvbl9tbl9mcmVlX25vdGlmaWVyKHN0cnVjdCBtbXVfbm90 aWZpZXIgKm1uKQotewotCWtmcmVlKGNvbnRhaW5lcl9vZihtbiwgc3RydWN0IHJhZGVvbl9tbiwg bW4pKTsKKwlyYWRlb25fYm9fdW5yZXNlcnZlKGJvKTsKKwlyZXR1cm4gdHJ1ZTsKIH0KIAotc3Rh dGljIGNvbnN0IHN0cnVjdCBtbXVfbm90aWZpZXJfb3BzIHJhZGVvbl9tbl9vcHMgPSB7Ci0JLnJl bGVhc2UgPSByYWRlb25fbW5fcmVsZWFzZSwKLQkuaW52YWxpZGF0ZV9yYW5nZV9zdGFydCA9IHJh ZGVvbl9tbl9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0LAotCS5hbGxvY19ub3RpZmllciA9IHJhZGVv bl9tbl9hbGxvY19ub3RpZmllciwKLQkuZnJlZV9ub3RpZmllciA9IHJhZGVvbl9tbl9mcmVlX25v dGlmaWVyLAorc3RhdGljIGNvbnN0IHN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXJfb3BzIHJhZGVv bl9tbl9vcHMgPSB7CisJLmludmFsaWRhdGUgPSByYWRlb25fbW5faW52YWxpZGF0ZSwKIH07CiAK IC8qKgpAQCAtMTc0LDUxICs5MywyMSBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IG1tdV9ub3RpZmll cl9vcHMgcmFkZW9uX21uX29wcyA9IHsKICAqLwogaW50IHJhZGVvbl9tbl9yZWdpc3RlcihzdHJ1 Y3QgcmFkZW9uX2JvICpibywgdW5zaWduZWQgbG9uZyBhZGRyKQogewotCXVuc2lnbmVkIGxvbmcg ZW5kID0gYWRkciArIHJhZGVvbl9ib19zaXplKGJvKSAtIDE7Ci0Jc3RydWN0IG1tdV9ub3RpZmll ciAqbW47Ci0Jc3RydWN0IHJhZGVvbl9tbiAqcm1uOwotCXN0cnVjdCByYWRlb25fbW5fbm9kZSAq bm9kZSA9IE5VTEw7Ci0Jc3RydWN0IGxpc3RfaGVhZCBib3M7Ci0Jc3RydWN0IGludGVydmFsX3Ry ZWVfbm9kZSAqaXQ7Ci0KLQltbiA9IG1tdV9ub3RpZmllcl9nZXQoJnJhZGVvbl9tbl9vcHMsIGN1 cnJlbnQtPm1tKTsKLQlpZiAoSVNfRVJSKG1uKSkKLQkJcmV0dXJuIFBUUl9FUlIobW4pOwotCXJt biA9IGNvbnRhaW5lcl9vZihtbiwgc3RydWN0IHJhZGVvbl9tbiwgbW4pOwotCi0JSU5JVF9MSVNU X0hFQUQoJmJvcyk7Ci0KLQltdXRleF9sb2NrKCZybW4tPmxvY2spOwotCi0Jd2hpbGUgKChpdCA9 IGludGVydmFsX3RyZWVfaXRlcl9maXJzdCgmcm1uLT5vYmplY3RzLCBhZGRyLCBlbmQpKSkgewot CQlrZnJlZShub2RlKTsKLQkJbm9kZSA9IGNvbnRhaW5lcl9vZihpdCwgc3RydWN0IHJhZGVvbl9t bl9ub2RlLCBpdCk7Ci0JCWludGVydmFsX3RyZWVfcmVtb3ZlKCZub2RlLT5pdCwgJnJtbi0+b2Jq ZWN0cyk7Ci0JCWFkZHIgPSBtaW4oaXQtPnN0YXJ0LCBhZGRyKTsKLQkJZW5kID0gbWF4KGl0LT5s YXN0LCBlbmQpOwotCQlsaXN0X3NwbGljZSgmbm9kZS0+Ym9zLCAmYm9zKTsKLQl9Ci0KLQlpZiAo IW5vZGUpIHsKLQkJbm9kZSA9IGttYWxsb2Moc2l6ZW9mKHN0cnVjdCByYWRlb25fbW5fbm9kZSks IEdGUF9LRVJORUwpOwotCQlpZiAoIW5vZGUpIHsKLQkJCW11dGV4X3VubG9jaygmcm1uLT5sb2Nr KTsKLQkJCXJldHVybiAtRU5PTUVNOwotCQl9Ci0JfQotCi0JYm8tPm1uID0gcm1uOwotCi0Jbm9k ZS0+aXQuc3RhcnQgPSBhZGRyOwotCW5vZGUtPml0Lmxhc3QgPSBlbmQ7Ci0JSU5JVF9MSVNUX0hF QUQoJm5vZGUtPmJvcyk7Ci0JbGlzdF9zcGxpY2UoJmJvcywgJm5vZGUtPmJvcyk7Ci0JbGlzdF9h ZGQoJmJvLT5tbl9saXN0LCAmbm9kZS0+Ym9zKTsKLQotCWludGVydmFsX3RyZWVfaW5zZXJ0KCZu b2RlLT5pdCwgJnJtbi0+b2JqZWN0cyk7Ci0KLQltdXRleF91bmxvY2soJnJtbi0+bG9jayk7Ci0K KwlpbnQgcmV0OworCisJYm8tPm5vdGlmaWVyLm9wcyA9ICZyYWRlb25fbW5fb3BzOworCXJldCA9 IG1tdV9yYW5nZV9ub3RpZmllcl9pbnNlcnQoJmJvLT5ub3RpZmllciwgYWRkciwgcmFkZW9uX2Jv X3NpemUoYm8pLAorCQkJCQljdXJyZW50LT5tbSk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsK KworCS8qCisJICogRklYTUU6IHJhZGVvbiBhcHBlYXJzIHRvIGFsbG93IGdldF91c2VyX3BhZ2Vz IHRvIHJ1biBkdXJpbmcKKwkgKiBpbnZhbGlkYXRlX3JhbmdlX3N0YXJ0L2VuZCwgd2hpY2ggaXMg bm90IGEgc2FmZSB3YXkgdG8gcmVhZCB0aGUKKwkgKiBQVEVzLiBJdCBzaG91bGQgdXNlIHRoZSBt bXVfcmFuZ2VfcmVhZF9iZWdpbigpIHNjaGVtZSBhcm91bmQgdGhlCisJICogZ2V0X3VzZXJfcGFn ZXMgdG8gZW5zdXJlIHRoYXQgdGhlIFBURXMgYXJlIHJlYWQgcHJvcGVybHkKKwkgKi8KKwltbXVf cmFuZ2VfcmVhZF9iZWdpbigmYm8tPm5vdGlmaWVyKTsKIAlyZXR1cm4gMDsKIH0KIApAQCAtMjMx LDI3ICsxMjAsOCBAQCBpbnQgcmFkZW9uX21uX3JlZ2lzdGVyKHN0cnVjdCByYWRlb25fYm8gKmJv LCB1bnNpZ25lZCBsb25nIGFkZHIpCiAgKi8KIHZvaWQgcmFkZW9uX21uX3VucmVnaXN0ZXIoc3Ry dWN0IHJhZGVvbl9ibyAqYm8pCiB7Ci0Jc3RydWN0IHJhZGVvbl9tbiAqcm1uID0gYm8tPm1uOwot CXN0cnVjdCBsaXN0X2hlYWQgKmhlYWQ7Ci0KLQlpZiAoIXJtbikKKwlpZiAoIWJvLT5ub3RpZmll ci5tbSkKIAkJcmV0dXJuOwotCi0JbXV0ZXhfbG9jaygmcm1uLT5sb2NrKTsKLQkvKiBzYXZlIHRo ZSBuZXh0IGxpc3QgZW50cnkgZm9yIGxhdGVyICovCi0JaGVhZCA9IGJvLT5tbl9saXN0Lm5leHQ7 Ci0KLQlsaXN0X2RlbCgmYm8tPm1uX2xpc3QpOwotCi0JaWYgKGxpc3RfZW1wdHkoaGVhZCkpIHsK LQkJc3RydWN0IHJhZGVvbl9tbl9ub2RlICpub2RlOwotCQlub2RlID0gY29udGFpbmVyX29mKGhl YWQsIHN0cnVjdCByYWRlb25fbW5fbm9kZSwgYm9zKTsKLQkJaW50ZXJ2YWxfdHJlZV9yZW1vdmUo Jm5vZGUtPml0LCAmcm1uLT5vYmplY3RzKTsKLQkJa2ZyZWUobm9kZSk7Ci0JfQotCi0JbXV0ZXhf dW5sb2NrKCZybW4tPmxvY2spOwotCi0JbW11X25vdGlmaWVyX3B1dCgmcm1uLT5tbik7Ci0JYm8t Pm1uID0gTlVMTDsKKwltbXVfcmFuZ2Vfbm90aWZpZXJfcmVtb3ZlKCZiby0+bm90aWZpZXIpOwor CWJvLT5ub3RpZmllci5tbSA9IE5VTEw7CiB9Ci0tIAoyLjIzLjAKCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmFtZC1nZnggbWFpbGluZyBsaXN0CmFtZC1n ZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21h aWxtYW4vbGlzdGluZm8vYW1kLWdmeA==