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.6 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, 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 009A3C3A59E for ; Wed, 21 Aug 2019 12:32:00 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id C0EB822D6D for ; Wed, 21 Aug 2019 12:31:59 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="C6avVw5s" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728267AbfHUMb7 (ORCPT ); Wed, 21 Aug 2019 08:31:59 -0400 Received: from mail-wr1-f68.google.com ([209.85.221.68]:43704 "EHLO mail-wr1-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728279AbfHUMb6 (ORCPT ); Wed, 21 Aug 2019 08:31:58 -0400 Received: by mail-wr1-f68.google.com with SMTP id y8so1848646wrn.10 for ; Wed, 21 Aug 2019 05:31:56 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:subject:date:message-id:in-reply-to:references:mime-version :content-transfer-encoding; bh=aRXsJmbmtfPxPUN8vKc2ijDmbdxfggBJHwv1ymZT7tU=; b=C6avVw5s+Madbo3fCVkLSXse+ieMoqWibO2MBnIklPeM7GNILrlT4uSMLyqQ/UctNz hgFVDsBB/ij8pU43oinM9JVa/MIysUAMIx7yswR9kN8yf4dYIFg5b/kfbmaHT/ELsBN0 PKQxjnIhy9avvJVioQ69szQ50wkhbYmVDwL12x+dL9gfDi9uQGdQCGSkvGTac0je8pCS qStOOU8gAkkvRF4hSpfQ8aviFUR7nF8p3lgRwsHynFHoICvmIUwcJFit57U3jMoH4tN1 4f3ZMQkLGfCCEdUBxb3wHuwChyeQNf97cKSwFmU+p3d9mQzdszwq8FGoHNYzfZhdSCZN FGyw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=aRXsJmbmtfPxPUN8vKc2ijDmbdxfggBJHwv1ymZT7tU=; b=JCm/ayuXn4qrRFHUFWoz9XZbz3006UQ9eTu+rDMlmB+ld5bJlMl9uB9pb1X3Gw4+aU Ud33m5RxEb2P2+L3xXhRoTNiH4Mxb03gz0IhPasqAjCSsFDW+iMAD+Ak4BZCmjbkSIGK YZ77fmFWDGQAPX25YAuItejjvCbRyWkhA1yu0nmQQMRD1vHcc7xITueEW2/HTDk+TYxz 52Y3d4i3KF5i7IA/IYHuF8RRzvyJyEqVK6XDWghr1L92QHcACMtkB830XISYrhdATNFG BY57sdx2vnjN8tnwkWqnV21ezjPXNHZTSpEUylI4mKcwNVn23oGAGD47WYMyv10GxjcV D9bA== X-Gm-Message-State: APjAAAW+NL6Hj48MouZv47wawYvKVdDC675lzaFXK4E1pg6y7+J+ywhm ZAZwHjpo7KKd13hhNXWe5hxO3Ejv X-Google-Smtp-Source: APXvYqyBNotk8B8aMjwkVU5PjZ14VCximu9p4qoWqEdX3ZKXwTSeKwyq8A3a0zKymAwNIBHgkTA3Rw== X-Received: by 2002:a5d:6ccd:: with SMTP id c13mr34422352wrc.4.1566390715621; Wed, 21 Aug 2019 05:31:55 -0700 (PDT) Received: from abel.fritz.box ([2a02:908:1252:fb60:8189:dd33:a934:c4fa]) by smtp.gmail.com with ESMTPSA id v3sm23084571wrq.34.2019.08.21.05.31.54 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 21 Aug 2019 05:31:55 -0700 (PDT) From: "=?UTF-8?q?Christian=20K=C3=B6nig?=" X-Google-Original-From: =?UTF-8?q?Christian=20K=C3=B6nig?= To: dri-devel@lists.freedesktop.org, chris@chris-wilson.co.uk, daniel.vetter@ffwll.ch, sumit.semwal@linaro.org, linux-media@vger.kernel.org, linaro-mm-sig@lists.linaro.org Subject: [PATCH 07/10] dma-buf/resv: add new fences container implementation Date: Wed, 21 Aug 2019 14:31:44 +0200 Message-Id: <20190821123147.110736-8-christian.koenig@amd.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190821123147.110736-1-christian.koenig@amd.com> References: <20190821123147.110736-1-christian.koenig@amd.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-media-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-media@vger.kernel.org Add a new container for fences which internally uses dma_fence_array's to store the fences. Signed-off-by: Christian König --- drivers/dma-buf/dma-resv.c | 221 +++++++++++++++++++++++++++++++++++++ include/linux/dma-resv.h | 49 ++++++++ 2 files changed, 270 insertions(+) diff --git a/drivers/dma-buf/dma-resv.c b/drivers/dma-buf/dma-resv.c index d3a9a3bb15f0..83033b3e8521 100644 --- a/drivers/dma-buf/dma-resv.c +++ b/drivers/dma-buf/dma-resv.c @@ -33,6 +33,7 @@ */ #include +#include #include /** @@ -55,6 +56,226 @@ EXPORT_SYMBOL(reservation_seqcount_class); const char reservation_seqcount_string[] = "reservation_seqcount"; EXPORT_SYMBOL(reservation_seqcount_string); +static void dma_resv_fences_init(struct dma_resv_fences *fences) +{ + RCU_INIT_POINTER(fences->fence, NULL); + fences->staged = NULL; +} + +static void dma_resv_fences_fini(struct dma_resv_fences *fences) +{ + /* + * This object should be dead and all references must have + * been released to it, so no need to be protected with rcu. + */ + dma_fence_put(rcu_dereference_protected(fences->fence, true)); + dma_fence_array_free(fences->staged); +} + +/** + * dma_resv_fences_reserve - allocate fence slots + * @fences: fences object where we need slots + * @num_fences: number of fence slots we need + * + * Make sure that we have at least @num_fences + all the existing ones free + * slots in the staged dma_fence_array. + * + * Returns -ENOMEM on allocation failure, 0 otherwise. + */ +int dma_resv_fences_reserve(struct dma_resv *obj, + struct dma_resv_fences *fences, + unsigned int num_fences) +{ + struct dma_fence *fence = dma_resv_fences_deref(obj, fences); + struct dma_fence_array *staged, *array; + unsigned int i; + + array = fences->staged; + if (!array) + array = to_dma_fence_array(fence); + + if (array) + num_fences += array->num_fences; + else if (fence) + num_fences += 1; + + staged = fences->staged; + if (staged && dma_fence_array_max_fences(staged) >= num_fences) + return 0; + + staged = dma_fence_array_alloc(num_fences, NULL); + if (!staged) + return -ENOMEM; + + /* Copy over all fences from the old object */ + if (array) { + for (i = 0; i < array->num_fences; ++i) { + struct dma_fence *f = array->fences[i]; + + staged->fences[i] = dma_fence_get(f); + } + staged->num_fences = array->num_fences; + + } else if (fence) { + staged->fences[0] = dma_fence_get(fence); + staged->num_fences = 1; + + } else { + staged->num_fences = 0; + } + + dma_fence_array_free(fences->staged); + fences->staged = staged; + + return 0; +} +EXPORT_SYMBOL(dma_resv_fences_reserve); + +/** + * dma_resv_fences_assign - set the singleton fence + * @fences: fences object where to set the fence + * @fence: singleton fence for the object + * + * Internal helper to assign the signleton fence without grapping a reference. + * If the old fence is a dma_fence_array try to recycle it. + */ +static void dma_resv_fences_assign(struct dma_resv *obj, + struct dma_resv_fences *fences, + struct dma_fence *fence) +{ + struct dma_fence_array *array, *staged; + unsigned int num_fences, i; + struct dma_fence *old; + + old = dma_resv_fences_deref(obj, fences); + rcu_assign_pointer(fences->fence, fence); + + dma_fence_array_free(fences->staged); + fences->staged = NULL; + + /* Try to recycle the old fence array */ + staged = to_dma_fence_array(old); + if (!staged) + goto drop_old; + + array = to_dma_fence_array(fence); + if (array) + num_fences = array->num_fences; + else + num_fences = fence ? 1 : 0; + + if (dma_fence_array_max_fences(staged) < num_fences) + goto drop_old; + + /* Try to drop the last reference */ + if (!dma_fence_array_recycle(staged)) + return; + + /* Make sure the staged array has the latest fences */ + if (array) { + for (i = 0; i < array->num_fences; ++i) { + struct dma_fence *f = array->fences[i]; + + if (f == staged->fences[i]) + continue; + + dma_fence_put(staged->fences[i]); + staged->fences[i] = dma_fence_get(f); + } + for (;i < staged->num_fences; ++i) + dma_fence_put(staged->fences[i]); + staged->num_fences = array->num_fences; + + } else if (fence) { + for (i = 0; i < staged->num_fences; ++i) + dma_fence_put(staged->fences[i]); + staged->fences[0] = dma_fence_get(fence); + staged->num_fences = 1; + } else { + for (i = 0; i < staged->num_fences; ++i) + dma_fence_put(staged->fences[i]); + staged->num_fences = 0; + } + + fences->staged = staged; + return; + +drop_old: + dma_fence_put(old); +} + +/** + * dma_resv_fences_set - set the singleton fence + * @fences: fences object where to set the fence + * @fence: singleton fence for the object + * + * Grabs a reference to the new fence and replaces the current singleton fence + * with a new one. If the old fence is a dma_fence_array try to recycle it. + */ +void dma_resv_fences_set(struct dma_resv *obj, + struct dma_resv_fences *fences, + struct dma_fence *fence) +{ + dma_fence_get(fence); + dma_resv_fences_assign(obj, fences, fence); +} +EXPORT_SYMBOL(dma_resv_fences_set); + +/** + * dma_resv_fences_add - add a fence to the staged fence_array + * @fences: fences object where to add the fence to + * @fence: fence to add + * + * Add a new fence to the staged fence_array. + */ +void dma_resv_fences_add(struct dma_resv_fences *fences, + struct dma_fence *fence) +{ + struct dma_fence_array *staged = fences->staged; + struct dma_fence *old; + unsigned int i; + +#ifndef CONFIG_DEBUG_MUTEXES + for (i = 0; i < staged->num_fences; ++i) { + old = staged->fences[i]; + + if (old->context == fence->context || + dma_fence_is_signaled(old)) { + dma_fence_put(old); + goto replace; + } + } +#endif + + BUG_ON(staged->num_fences >= dma_fence_array_max_fences(staged)); + i = staged->num_fences++; + +replace: + staged->fences[i] = dma_fence_get(fence); +} +EXPORT_SYMBOL(dma_resv_fences_add); + +/** + * dma_resv_fences_commit - commit the staged dma_fence_array + * @fences: fences object where the commit should happen + * + * Commit the fences staged in the dma_fence_array and make them visible to + * other threads. + */ +void dma_resv_fences_commit(struct dma_resv *obj, + struct dma_resv_fences *fences) +{ + struct dma_fence_array *staged = fences->staged; + + if (!staged || !staged->num_fences) + return; + + fences->staged = NULL; + dma_fence_array_init(staged, dma_fence_context_alloc(1), 1, false); + dma_resv_fences_assign(obj, fences, &staged->base); +} +EXPORT_SYMBOL(dma_resv_fences_commit); + /** * dma_resv_list_alloc - allocate fence list * @shared_max: number of fences we need space for diff --git a/include/linux/dma-resv.h b/include/linux/dma-resv.h index 03b0f95682b0..c70f13fa6789 100644 --- a/include/linux/dma-resv.h +++ b/include/linux/dma-resv.h @@ -45,10 +45,33 @@ #include #include +struct dma_resv; + extern struct ww_class reservation_ww_class; extern struct lock_class_key reservation_seqcount_class; extern const char reservation_seqcount_string[]; +/** + * struct dma_resv_fences - fences inside a reservation object + * @fence: the current RCU protected singleton fence + * @staged: optional staged dma_fence_array to replace @fence + */ +struct dma_resv_fences { + struct dma_fence __rcu *fence; + struct dma_fence_array *staged; +}; + +int dma_resv_fences_reserve(struct dma_resv *obj, + struct dma_resv_fences *fences, + unsigned int num_fences); +void dma_resv_fences_set(struct dma_resv *obj, + struct dma_resv_fences *fences, + struct dma_fence *fence); +void dma_resv_fences_add(struct dma_resv_fences *fences, + struct dma_fence *fence); +void dma_resv_fences_commit(struct dma_resv *obj, + struct dma_resv_fences *fences); + /** * struct dma_resv_list - a list of shared fences * @rcu: for internal use @@ -80,6 +103,32 @@ struct dma_resv { #define dma_resv_held(obj) lockdep_is_held(&(obj)->lock.base) #define dma_resv_assert_held(obj) lockdep_assert_held(&(obj)->lock.base) +/** + * dma_resv_fences_deref - get singleton fence + * @obj: the reservation object + * @fences: the fences object + * + * Returns the singleton fence from a resv_fences object. + */ +static inline struct dma_fence * +dma_resv_fences_deref(struct dma_resv *obj, struct dma_resv_fences *fences) +{ + return rcu_dereference_protected(fences->fence, + dma_resv_held(obj)); +} + +/** + * dma_resv_fences_get_rcu - RCU get single fence + * @fences: fences structure where we need to get a reference for + * + * Get a reference to the single fence representing the synchronization. + */ +static inline struct dma_fence * +dma_resv_fences_get_rcu(struct dma_resv_fences *fences) +{ + return dma_fence_get_rcu_safe(&fences->fence); +} + /** * dma_resv_get_list - get the reservation object's * shared fence list, with update-side lock held -- 2.17.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: "=?UTF-8?q?Christian=20K=C3=B6nig?=" Subject: [PATCH 07/10] dma-buf/resv: add new fences container implementation Date: Wed, 21 Aug 2019 14:31:44 +0200 Message-ID: <20190821123147.110736-8-christian.koenig@amd.com> References: <20190821123147.110736-1-christian.koenig@amd.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-wr1-x441.google.com (mail-wr1-x441.google.com [IPv6:2a00:1450:4864:20::441]) by gabe.freedesktop.org (Postfix) with ESMTPS id 98B776E316 for ; Wed, 21 Aug 2019 12:31:57 +0000 (UTC) Received: by mail-wr1-x441.google.com with SMTP id q12so1836817wrj.12 for ; Wed, 21 Aug 2019 05:31:57 -0700 (PDT) In-Reply-To: <20190821123147.110736-1-christian.koenig@amd.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: dri-devel@lists.freedesktop.org, chris@chris-wilson.co.uk, daniel.vetter@ffwll.ch, sumit.semwal@linaro.org, linux-media@vger.kernel.org, linaro-mm-sig@lists.linaro.org List-Id: dri-devel@lists.freedesktop.org QWRkIGEgbmV3IGNvbnRhaW5lciBmb3IgZmVuY2VzIHdoaWNoIGludGVybmFsbHkgdXNlcwpkbWFf ZmVuY2VfYXJyYXkncyB0byBzdG9yZSB0aGUgZmVuY2VzLgoKU2lnbmVkLW9mZi1ieTogQ2hyaXN0 aWFuIEvDtm5pZyA8Y2hyaXN0aWFuLmtvZW5pZ0BhbWQuY29tPgotLS0KIGRyaXZlcnMvZG1hLWJ1 Zi9kbWEtcmVzdi5jIHwgMjIxICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysK IGluY2x1ZGUvbGludXgvZG1hLXJlc3YuaCAgIHwgIDQ5ICsrKysrKysrCiAyIGZpbGVzIGNoYW5n ZWQsIDI3MCBpbnNlcnRpb25zKCspCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEtYnVmL2RtYS1y ZXN2LmMgYi9kcml2ZXJzL2RtYS1idWYvZG1hLXJlc3YuYwppbmRleCBkM2E5YTNiYjE1ZjAuLjgz MDMzYjNlODUyMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9kbWEtYnVmL2RtYS1yZXN2LmMKKysrIGIv ZHJpdmVycy9kbWEtYnVmL2RtYS1yZXN2LmMKQEAgLTMzLDYgKzMzLDcgQEAKICAqLwogCiAjaW5j bHVkZSA8bGludXgvZG1hLXJlc3YuaD4KKyNpbmNsdWRlIDxsaW51eC9kbWEtZmVuY2UtYXJyYXku aD4KICNpbmNsdWRlIDxsaW51eC9leHBvcnQuaD4KIAogLyoqCkBAIC01NSw2ICs1NiwyMjYgQEAg RVhQT1JUX1NZTUJPTChyZXNlcnZhdGlvbl9zZXFjb3VudF9jbGFzcyk7CiBjb25zdCBjaGFyIHJl c2VydmF0aW9uX3NlcWNvdW50X3N0cmluZ1tdID0gInJlc2VydmF0aW9uX3NlcWNvdW50IjsKIEVY UE9SVF9TWU1CT0wocmVzZXJ2YXRpb25fc2VxY291bnRfc3RyaW5nKTsKIAorc3RhdGljIHZvaWQg ZG1hX3Jlc3ZfZmVuY2VzX2luaXQoc3RydWN0IGRtYV9yZXN2X2ZlbmNlcyAqZmVuY2VzKQorewor CVJDVV9JTklUX1BPSU5URVIoZmVuY2VzLT5mZW5jZSwgTlVMTCk7CisJZmVuY2VzLT5zdGFnZWQg PSBOVUxMOworfQorCitzdGF0aWMgdm9pZCBkbWFfcmVzdl9mZW5jZXNfZmluaShzdHJ1Y3QgZG1h X3Jlc3ZfZmVuY2VzICpmZW5jZXMpCit7CisJLyoKKwkgKiBUaGlzIG9iamVjdCBzaG91bGQgYmUg ZGVhZCBhbmQgYWxsIHJlZmVyZW5jZXMgbXVzdCBoYXZlCisJICogYmVlbiByZWxlYXNlZCB0byBp dCwgc28gbm8gbmVlZCB0byBiZSBwcm90ZWN0ZWQgd2l0aCByY3UuCisJICovCisJZG1hX2ZlbmNl X3B1dChyY3VfZGVyZWZlcmVuY2VfcHJvdGVjdGVkKGZlbmNlcy0+ZmVuY2UsIHRydWUpKTsKKwlk bWFfZmVuY2VfYXJyYXlfZnJlZShmZW5jZXMtPnN0YWdlZCk7Cit9CisKKy8qKgorICogZG1hX3Jl c3ZfZmVuY2VzX3Jlc2VydmUgLSBhbGxvY2F0ZSBmZW5jZSBzbG90cworICogQGZlbmNlczogZmVu Y2VzIG9iamVjdCB3aGVyZSB3ZSBuZWVkIHNsb3RzCisgKiBAbnVtX2ZlbmNlczogbnVtYmVyIG9m IGZlbmNlIHNsb3RzIHdlIG5lZWQKKyAqCisgKiBNYWtlIHN1cmUgdGhhdCB3ZSBoYXZlIGF0IGxl YXN0IEBudW1fZmVuY2VzICsgYWxsIHRoZSBleGlzdGluZyBvbmVzIGZyZWUKKyAqIHNsb3RzIGlu IHRoZSBzdGFnZWQgZG1hX2ZlbmNlX2FycmF5LgorICoKKyAqIFJldHVybnMgLUVOT01FTSBvbiBh bGxvY2F0aW9uIGZhaWx1cmUsIDAgb3RoZXJ3aXNlLgorICovCitpbnQgZG1hX3Jlc3ZfZmVuY2Vz X3Jlc2VydmUoc3RydWN0IGRtYV9yZXN2ICpvYmosCisJCQkgICAgc3RydWN0IGRtYV9yZXN2X2Zl bmNlcyAqZmVuY2VzLAorCQkJICAgIHVuc2lnbmVkIGludCBudW1fZmVuY2VzKQoreworCXN0cnVj dCBkbWFfZmVuY2UgKmZlbmNlID0gZG1hX3Jlc3ZfZmVuY2VzX2RlcmVmKG9iaiwgZmVuY2VzKTsK KwlzdHJ1Y3QgZG1hX2ZlbmNlX2FycmF5ICpzdGFnZWQsICphcnJheTsKKwl1bnNpZ25lZCBpbnQg aTsKKworCWFycmF5ID0gZmVuY2VzLT5zdGFnZWQ7CisJaWYgKCFhcnJheSkKKwkJYXJyYXkgPSB0 b19kbWFfZmVuY2VfYXJyYXkoZmVuY2UpOworCisJaWYgKGFycmF5KQorCQludW1fZmVuY2VzICs9 IGFycmF5LT5udW1fZmVuY2VzOworCWVsc2UgaWYgKGZlbmNlKQorCQludW1fZmVuY2VzICs9IDE7 CisKKwlzdGFnZWQgPSBmZW5jZXMtPnN0YWdlZDsKKwlpZiAoc3RhZ2VkICYmIGRtYV9mZW5jZV9h cnJheV9tYXhfZmVuY2VzKHN0YWdlZCkgPj0gbnVtX2ZlbmNlcykKKwkJcmV0dXJuIDA7CisKKwlz dGFnZWQgPSBkbWFfZmVuY2VfYXJyYXlfYWxsb2MobnVtX2ZlbmNlcywgTlVMTCk7CisJaWYgKCFz dGFnZWQpCisJCXJldHVybiAtRU5PTUVNOworCisJLyogQ29weSBvdmVyIGFsbCBmZW5jZXMgZnJv bSB0aGUgb2xkIG9iamVjdCAqLworCWlmIChhcnJheSkgeworCQlmb3IgKGkgPSAwOyBpIDwgYXJy YXktPm51bV9mZW5jZXM7ICsraSkgeworCQkJc3RydWN0IGRtYV9mZW5jZSAqZiA9IGFycmF5LT5m ZW5jZXNbaV07CisKKwkJCXN0YWdlZC0+ZmVuY2VzW2ldID0gZG1hX2ZlbmNlX2dldChmKTsKKwkJ fQorCQlzdGFnZWQtPm51bV9mZW5jZXMgPSBhcnJheS0+bnVtX2ZlbmNlczsKKworCX0gZWxzZSBp ZiAoZmVuY2UpIHsKKwkJc3RhZ2VkLT5mZW5jZXNbMF0gPSBkbWFfZmVuY2VfZ2V0KGZlbmNlKTsK KwkJc3RhZ2VkLT5udW1fZmVuY2VzID0gMTsKKworCX0gZWxzZSB7CisJCXN0YWdlZC0+bnVtX2Zl bmNlcyA9IDA7CisJfQorCisJZG1hX2ZlbmNlX2FycmF5X2ZyZWUoZmVuY2VzLT5zdGFnZWQpOwor CWZlbmNlcy0+c3RhZ2VkID0gc3RhZ2VkOworCisJcmV0dXJuIDA7Cit9CitFWFBPUlRfU1lNQk9M KGRtYV9yZXN2X2ZlbmNlc19yZXNlcnZlKTsKKworLyoqCisgKiBkbWFfcmVzdl9mZW5jZXNfYXNz aWduIC0gc2V0IHRoZSBzaW5nbGV0b24gZmVuY2UKKyAqIEBmZW5jZXM6IGZlbmNlcyBvYmplY3Qg d2hlcmUgdG8gc2V0IHRoZSBmZW5jZQorICogQGZlbmNlOiBzaW5nbGV0b24gZmVuY2UgZm9yIHRo ZSBvYmplY3QKKyAqCisgKiBJbnRlcm5hbCBoZWxwZXIgdG8gYXNzaWduIHRoZSBzaWdubGV0b24g ZmVuY2Ugd2l0aG91dCBncmFwcGluZyBhIHJlZmVyZW5jZS4KKyAqIElmIHRoZSBvbGQgZmVuY2Ug aXMgYSBkbWFfZmVuY2VfYXJyYXkgdHJ5IHRvIHJlY3ljbGUgaXQuCisgKi8KK3N0YXRpYyB2b2lk IGRtYV9yZXN2X2ZlbmNlc19hc3NpZ24oc3RydWN0IGRtYV9yZXN2ICpvYmosCisJCQkJICAgc3Ry dWN0IGRtYV9yZXN2X2ZlbmNlcyAqZmVuY2VzLAorCQkJCSAgIHN0cnVjdCBkbWFfZmVuY2UgKmZl bmNlKQoreworCXN0cnVjdCBkbWFfZmVuY2VfYXJyYXkgKmFycmF5LCAqc3RhZ2VkOworCXVuc2ln bmVkIGludCBudW1fZmVuY2VzLCBpOworCXN0cnVjdCBkbWFfZmVuY2UgKm9sZDsKKworCW9sZCA9 IGRtYV9yZXN2X2ZlbmNlc19kZXJlZihvYmosIGZlbmNlcyk7CisJcmN1X2Fzc2lnbl9wb2ludGVy KGZlbmNlcy0+ZmVuY2UsIGZlbmNlKTsKKworCWRtYV9mZW5jZV9hcnJheV9mcmVlKGZlbmNlcy0+ c3RhZ2VkKTsKKwlmZW5jZXMtPnN0YWdlZCA9IE5VTEw7CisKKwkvKiBUcnkgdG8gcmVjeWNsZSB0 aGUgb2xkIGZlbmNlIGFycmF5ICovCisJc3RhZ2VkID0gdG9fZG1hX2ZlbmNlX2FycmF5KG9sZCk7 CisJaWYgKCFzdGFnZWQpCisJCWdvdG8gZHJvcF9vbGQ7CisKKwlhcnJheSA9IHRvX2RtYV9mZW5j ZV9hcnJheShmZW5jZSk7CisJaWYgKGFycmF5KQorCQludW1fZmVuY2VzID0gYXJyYXktPm51bV9m ZW5jZXM7CisJZWxzZQorCQludW1fZmVuY2VzID0gZmVuY2UgPyAxIDogMDsKKworCWlmIChkbWFf ZmVuY2VfYXJyYXlfbWF4X2ZlbmNlcyhzdGFnZWQpIDwgbnVtX2ZlbmNlcykKKwkJZ290byBkcm9w X29sZDsKKworCS8qIFRyeSB0byBkcm9wIHRoZSBsYXN0IHJlZmVyZW5jZSAqLworCWlmICghZG1h X2ZlbmNlX2FycmF5X3JlY3ljbGUoc3RhZ2VkKSkKKwkJcmV0dXJuOworCisJLyogTWFrZSBzdXJl IHRoZSBzdGFnZWQgYXJyYXkgaGFzIHRoZSBsYXRlc3QgZmVuY2VzICovCisJaWYgKGFycmF5KSB7 CisJCWZvciAoaSA9IDA7IGkgPCBhcnJheS0+bnVtX2ZlbmNlczsgKytpKSB7CisJCQlzdHJ1Y3Qg ZG1hX2ZlbmNlICpmID0gYXJyYXktPmZlbmNlc1tpXTsKKworCQkJaWYgKGYgPT0gc3RhZ2VkLT5m ZW5jZXNbaV0pCisJCQkJY29udGludWU7CisKKwkJCWRtYV9mZW5jZV9wdXQoc3RhZ2VkLT5mZW5j ZXNbaV0pOworCQkJc3RhZ2VkLT5mZW5jZXNbaV0gPSBkbWFfZmVuY2VfZ2V0KGYpOworCQl9CisJ CWZvciAoO2kgPCBzdGFnZWQtPm51bV9mZW5jZXM7ICsraSkKKwkJCWRtYV9mZW5jZV9wdXQoc3Rh Z2VkLT5mZW5jZXNbaV0pOworCQlzdGFnZWQtPm51bV9mZW5jZXMgPSBhcnJheS0+bnVtX2ZlbmNl czsKKworCX0gZWxzZSBpZiAoZmVuY2UpIHsKKwkJZm9yIChpID0gMDsgaSA8IHN0YWdlZC0+bnVt X2ZlbmNlczsgKytpKQorCQkJZG1hX2ZlbmNlX3B1dChzdGFnZWQtPmZlbmNlc1tpXSk7CisJCXN0 YWdlZC0+ZmVuY2VzWzBdID0gZG1hX2ZlbmNlX2dldChmZW5jZSk7CisJCXN0YWdlZC0+bnVtX2Zl bmNlcyA9IDE7CisJfSBlbHNlIHsKKwkJZm9yIChpID0gMDsgaSA8IHN0YWdlZC0+bnVtX2ZlbmNl czsgKytpKQorCQkJZG1hX2ZlbmNlX3B1dChzdGFnZWQtPmZlbmNlc1tpXSk7CisJCXN0YWdlZC0+ bnVtX2ZlbmNlcyA9IDA7CisJfQorCisJZmVuY2VzLT5zdGFnZWQgPSBzdGFnZWQ7CisJcmV0dXJu OworCitkcm9wX29sZDoKKwlkbWFfZmVuY2VfcHV0KG9sZCk7Cit9CisKKy8qKgorICogZG1hX3Jl c3ZfZmVuY2VzX3NldCAtIHNldCB0aGUgc2luZ2xldG9uIGZlbmNlCisgKiBAZmVuY2VzOiBmZW5j ZXMgb2JqZWN0IHdoZXJlIHRvIHNldCB0aGUgZmVuY2UKKyAqIEBmZW5jZTogc2luZ2xldG9uIGZl bmNlIGZvciB0aGUgb2JqZWN0CisgKgorICogR3JhYnMgYSByZWZlcmVuY2UgdG8gdGhlIG5ldyBm ZW5jZSBhbmQgcmVwbGFjZXMgdGhlIGN1cnJlbnQgc2luZ2xldG9uIGZlbmNlCisgKiB3aXRoIGEg bmV3IG9uZS4gSWYgdGhlIG9sZCBmZW5jZSBpcyBhIGRtYV9mZW5jZV9hcnJheSB0cnkgdG8gcmVj eWNsZSBpdC4KKyAqLwordm9pZCBkbWFfcmVzdl9mZW5jZXNfc2V0KHN0cnVjdCBkbWFfcmVzdiAq b2JqLAorCQkJIHN0cnVjdCBkbWFfcmVzdl9mZW5jZXMgKmZlbmNlcywKKwkJCSBzdHJ1Y3QgZG1h X2ZlbmNlICpmZW5jZSkKK3sKKwlkbWFfZmVuY2VfZ2V0KGZlbmNlKTsKKwlkbWFfcmVzdl9mZW5j ZXNfYXNzaWduKG9iaiwgZmVuY2VzLCBmZW5jZSk7Cit9CitFWFBPUlRfU1lNQk9MKGRtYV9yZXN2 X2ZlbmNlc19zZXQpOworCisvKioKKyAqIGRtYV9yZXN2X2ZlbmNlc19hZGQgLSBhZGQgYSBmZW5j ZSB0byB0aGUgc3RhZ2VkIGZlbmNlX2FycmF5CisgKiBAZmVuY2VzOiBmZW5jZXMgb2JqZWN0IHdo ZXJlIHRvIGFkZCB0aGUgZmVuY2UgdG8KKyAqIEBmZW5jZTogZmVuY2UgdG8gYWRkCisgKgorICog QWRkIGEgbmV3IGZlbmNlIHRvIHRoZSBzdGFnZWQgZmVuY2VfYXJyYXkuCisgKi8KK3ZvaWQgZG1h X3Jlc3ZfZmVuY2VzX2FkZChzdHJ1Y3QgZG1hX3Jlc3ZfZmVuY2VzICpmZW5jZXMsCisJCQkgc3Ry dWN0IGRtYV9mZW5jZSAqZmVuY2UpCit7CisJc3RydWN0IGRtYV9mZW5jZV9hcnJheSAqc3RhZ2Vk ID0gZmVuY2VzLT5zdGFnZWQ7CisJc3RydWN0IGRtYV9mZW5jZSAqb2xkOworCXVuc2lnbmVkIGlu dCBpOworCisjaWZuZGVmIENPTkZJR19ERUJVR19NVVRFWEVTCisJZm9yIChpID0gMDsgaSA8IHN0 YWdlZC0+bnVtX2ZlbmNlczsgKytpKSB7CisJCW9sZCA9IHN0YWdlZC0+ZmVuY2VzW2ldOworCisJ CWlmIChvbGQtPmNvbnRleHQgPT0gZmVuY2UtPmNvbnRleHQgfHwKKwkJICAgIGRtYV9mZW5jZV9p c19zaWduYWxlZChvbGQpKSB7CisJCQlkbWFfZmVuY2VfcHV0KG9sZCk7CisJCQlnb3RvIHJlcGxh Y2U7CisJCX0KKwl9CisjZW5kaWYKKworCUJVR19PTihzdGFnZWQtPm51bV9mZW5jZXMgPj0gZG1h X2ZlbmNlX2FycmF5X21heF9mZW5jZXMoc3RhZ2VkKSk7CisJaSA9IHN0YWdlZC0+bnVtX2ZlbmNl cysrOworCityZXBsYWNlOgorCXN0YWdlZC0+ZmVuY2VzW2ldID0gZG1hX2ZlbmNlX2dldChmZW5j ZSk7Cit9CitFWFBPUlRfU1lNQk9MKGRtYV9yZXN2X2ZlbmNlc19hZGQpOworCisvKioKKyAqIGRt YV9yZXN2X2ZlbmNlc19jb21taXQgLSBjb21taXQgdGhlIHN0YWdlZCBkbWFfZmVuY2VfYXJyYXkK KyAqIEBmZW5jZXM6IGZlbmNlcyBvYmplY3Qgd2hlcmUgdGhlIGNvbW1pdCBzaG91bGQgaGFwcGVu CisgKgorICogQ29tbWl0IHRoZSBmZW5jZXMgc3RhZ2VkIGluIHRoZSBkbWFfZmVuY2VfYXJyYXkg YW5kIG1ha2UgdGhlbSB2aXNpYmxlIHRvCisgKiBvdGhlciB0aHJlYWRzLgorICovCit2b2lkIGRt YV9yZXN2X2ZlbmNlc19jb21taXQoc3RydWN0IGRtYV9yZXN2ICpvYmosCisJCQkgICAgc3RydWN0 IGRtYV9yZXN2X2ZlbmNlcyAqZmVuY2VzKQoreworCXN0cnVjdCBkbWFfZmVuY2VfYXJyYXkgKnN0 YWdlZCA9IGZlbmNlcy0+c3RhZ2VkOworCisJaWYgKCFzdGFnZWQgfHwgIXN0YWdlZC0+bnVtX2Zl bmNlcykKKwkJcmV0dXJuOworCisJZmVuY2VzLT5zdGFnZWQgPSBOVUxMOworCWRtYV9mZW5jZV9h cnJheV9pbml0KHN0YWdlZCwgZG1hX2ZlbmNlX2NvbnRleHRfYWxsb2MoMSksIDEsIGZhbHNlKTsK KwlkbWFfcmVzdl9mZW5jZXNfYXNzaWduKG9iaiwgZmVuY2VzLCAmc3RhZ2VkLT5iYXNlKTsKK30K K0VYUE9SVF9TWU1CT0woZG1hX3Jlc3ZfZmVuY2VzX2NvbW1pdCk7CisKIC8qKgogICogZG1hX3Jl c3ZfbGlzdF9hbGxvYyAtIGFsbG9jYXRlIGZlbmNlIGxpc3QKICAqIEBzaGFyZWRfbWF4OiBudW1i ZXIgb2YgZmVuY2VzIHdlIG5lZWQgc3BhY2UgZm9yCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4 L2RtYS1yZXN2LmggYi9pbmNsdWRlL2xpbnV4L2RtYS1yZXN2LmgKaW5kZXggMDNiMGY5NTY4MmIw Li5jNzBmMTNmYTY3ODkgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvZG1hLXJlc3YuaAorKysg Yi9pbmNsdWRlL2xpbnV4L2RtYS1yZXN2LmgKQEAgLTQ1LDEwICs0NSwzMyBAQAogI2luY2x1ZGUg PGxpbnV4L3NlcWxvY2suaD4KICNpbmNsdWRlIDxsaW51eC9yY3VwZGF0ZS5oPgogCitzdHJ1Y3Qg ZG1hX3Jlc3Y7CisKIGV4dGVybiBzdHJ1Y3Qgd3dfY2xhc3MgcmVzZXJ2YXRpb25fd3dfY2xhc3M7 CiBleHRlcm4gc3RydWN0IGxvY2tfY2xhc3Nfa2V5IHJlc2VydmF0aW9uX3NlcWNvdW50X2NsYXNz OwogZXh0ZXJuIGNvbnN0IGNoYXIgcmVzZXJ2YXRpb25fc2VxY291bnRfc3RyaW5nW107CiAKKy8q KgorICogc3RydWN0IGRtYV9yZXN2X2ZlbmNlcyAtIGZlbmNlcyBpbnNpZGUgYSByZXNlcnZhdGlv biBvYmplY3QKKyAqIEBmZW5jZTogdGhlIGN1cnJlbnQgUkNVIHByb3RlY3RlZCBzaW5nbGV0b24g ZmVuY2UKKyAqIEBzdGFnZWQ6IG9wdGlvbmFsIHN0YWdlZCBkbWFfZmVuY2VfYXJyYXkgdG8gcmVw bGFjZSBAZmVuY2UKKyAqLworc3RydWN0IGRtYV9yZXN2X2ZlbmNlcyB7CisJc3RydWN0IGRtYV9m ZW5jZSBfX3JjdSAqZmVuY2U7CisJc3RydWN0IGRtYV9mZW5jZV9hcnJheSAqc3RhZ2VkOworfTsK KworaW50IGRtYV9yZXN2X2ZlbmNlc19yZXNlcnZlKHN0cnVjdCBkbWFfcmVzdiAqb2JqLAorCQkJ ICAgIHN0cnVjdCBkbWFfcmVzdl9mZW5jZXMgKmZlbmNlcywKKwkJCSAgICB1bnNpZ25lZCBpbnQg bnVtX2ZlbmNlcyk7Cit2b2lkIGRtYV9yZXN2X2ZlbmNlc19zZXQoc3RydWN0IGRtYV9yZXN2ICpv YmosCisJCQkgc3RydWN0IGRtYV9yZXN2X2ZlbmNlcyAqZmVuY2VzLAorCQkJIHN0cnVjdCBkbWFf ZmVuY2UgKmZlbmNlKTsKK3ZvaWQgZG1hX3Jlc3ZfZmVuY2VzX2FkZChzdHJ1Y3QgZG1hX3Jlc3Zf ZmVuY2VzICpmZW5jZXMsCisJCQkgc3RydWN0IGRtYV9mZW5jZSAqZmVuY2UpOwordm9pZCBkbWFf cmVzdl9mZW5jZXNfY29tbWl0KHN0cnVjdCBkbWFfcmVzdiAqb2JqLAorCQkJICAgIHN0cnVjdCBk bWFfcmVzdl9mZW5jZXMgKmZlbmNlcyk7CisKIC8qKgogICogc3RydWN0IGRtYV9yZXN2X2xpc3Qg LSBhIGxpc3Qgb2Ygc2hhcmVkIGZlbmNlcwogICogQHJjdTogZm9yIGludGVybmFsIHVzZQpAQCAt ODAsNiArMTAzLDMyIEBAIHN0cnVjdCBkbWFfcmVzdiB7CiAjZGVmaW5lIGRtYV9yZXN2X2hlbGQo b2JqKSBsb2NrZGVwX2lzX2hlbGQoJihvYmopLT5sb2NrLmJhc2UpCiAjZGVmaW5lIGRtYV9yZXN2 X2Fzc2VydF9oZWxkKG9iaikgbG9ja2RlcF9hc3NlcnRfaGVsZCgmKG9iaiktPmxvY2suYmFzZSkK IAorLyoqCisgKiBkbWFfcmVzdl9mZW5jZXNfZGVyZWYgLSBnZXQgc2luZ2xldG9uIGZlbmNlCisg KiBAb2JqOiB0aGUgcmVzZXJ2YXRpb24gb2JqZWN0CisgKiBAZmVuY2VzOiB0aGUgZmVuY2VzIG9i amVjdAorICoKKyAqIFJldHVybnMgdGhlIHNpbmdsZXRvbiBmZW5jZSBmcm9tIGEgcmVzdl9mZW5j ZXMgb2JqZWN0LgorICovCitzdGF0aWMgaW5saW5lIHN0cnVjdCBkbWFfZmVuY2UgKgorZG1hX3Jl c3ZfZmVuY2VzX2RlcmVmKHN0cnVjdCBkbWFfcmVzdiAqb2JqLCBzdHJ1Y3QgZG1hX3Jlc3ZfZmVu Y2VzICpmZW5jZXMpCit7CisJcmV0dXJuIHJjdV9kZXJlZmVyZW5jZV9wcm90ZWN0ZWQoZmVuY2Vz LT5mZW5jZSwKKwkJCQkJIGRtYV9yZXN2X2hlbGQob2JqKSk7Cit9CisKKy8qKgorICogZG1hX3Jl c3ZfZmVuY2VzX2dldF9yY3UgLSBSQ1UgZ2V0IHNpbmdsZSBmZW5jZQorICogQGZlbmNlczogZmVu Y2VzIHN0cnVjdHVyZSB3aGVyZSB3ZSBuZWVkIHRvIGdldCBhIHJlZmVyZW5jZSBmb3IKKyAqCisg KiBHZXQgYSByZWZlcmVuY2UgdG8gdGhlIHNpbmdsZSBmZW5jZSByZXByZXNlbnRpbmcgdGhlIHN5 bmNocm9uaXphdGlvbi4KKyAqLworc3RhdGljIGlubGluZSBzdHJ1Y3QgZG1hX2ZlbmNlICoKK2Rt YV9yZXN2X2ZlbmNlc19nZXRfcmN1KHN0cnVjdCBkbWFfcmVzdl9mZW5jZXMgKmZlbmNlcykKK3sK KwlyZXR1cm4gZG1hX2ZlbmNlX2dldF9yY3Vfc2FmZSgmZmVuY2VzLT5mZW5jZSk7Cit9CisKIC8q KgogICogZG1hX3Jlc3ZfZ2V0X2xpc3QgLSBnZXQgdGhlIHJlc2VydmF0aW9uIG9iamVjdCdzCiAg KiBzaGFyZWQgZmVuY2UgbGlzdCwgd2l0aCB1cGRhdGUtc2lkZSBsb2NrIGhlbGQKLS0gCjIuMTcu MQoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRl dmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8v bGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVs