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=-15.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,HK_RANDOM_FROM,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,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 04AA4C07E99 for ; Mon, 12 Jul 2021 12:17:40 +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 A5B7661004 for ; Mon, 12 Jul 2021 12:17:39 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org A5B7661004 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.intel.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 8633689BD2; Mon, 12 Jul 2021 12:17:34 +0000 (UTC) Received: from mga09.intel.com (mga09.intel.com [134.134.136.24]) by gabe.freedesktop.org (Postfix) with ESMTPS id 6895C89AC2; Mon, 12 Jul 2021 12:17:33 +0000 (UTC) X-IronPort-AV: E=McAfee;i="6200,9189,10042"; a="209943837" X-IronPort-AV: E=Sophos;i="5.84,232,1620716400"; d="scan'208";a="209943837" Received: from fmsmga006.fm.intel.com ([10.253.24.20]) by orsmga102.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 12 Jul 2021 05:17:33 -0700 X-IronPort-AV: E=Sophos;i="5.84,232,1620716400"; d="scan'208";a="648236618" Received: from aaroncar-mobl2.ger.corp.intel.com (HELO tursulin-mobl2.home) ([10.213.240.41]) by fmsmga006-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 12 Jul 2021 05:17:31 -0700 From: Tvrtko Ursulin To: Intel-gfx@lists.freedesktop.org Subject: [PATCH 1/8] drm/i915: Explicitly track DRM clients Date: Mon, 12 Jul 2021 13:17:12 +0100 Message-Id: <20210712121719.891536-2-tvrtko.ursulin@linux.intel.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20210712121719.891536-1-tvrtko.ursulin@linux.intel.com> References: <20210712121719.891536-1-tvrtko.ursulin@linux.intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Chris Wilson , Aravind Iddamsetty , dri-devel@lists.freedesktop.org, Tvrtko Ursulin Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" From: Tvrtko Ursulin Tracking DRM clients more explicitly will allow later patches to accumulate past and current GPU usage in a centralised place and also consolidate access to owning task pid/name. Unique client id is also assigned for the purpose of distinguishing/ consolidating between multiple file descriptors owned by the same process. v2: Chris Wilson: * Enclose new members into dedicated structs. * Protect against failed sysfs registration. v3: * sysfs_attr_init. v4: * Fix for internal clients. v5: * Use cyclic ida for client id. (Chris) * Do not leak pid reference. (Chris) * Tidy code with some locals. v6: * Use xa_alloc_cyclic to simplify locking. (Chris) * No need to unregister individial sysfs files. (Chris) * Rebase on top of fpriv kref. * Track client closed status and reflect in sysfs. v7: * Make drm_client more standalone concept. v8: * Simplify sysfs show. (Chris) * Always track name and pid. v9: * Fix cyclic id assignment. v10: * No need for a mutex around xa_alloc_cyclic. * Refactor sysfs into own function. * Unregister sysfs before freeing pid and name. * Move clients setup into own function. v11: * Call clients init directly from driver init. (Chris) v12: * Do not fail client add on id wrap. (Maciej) v13 (Lucas): Rebase. v14: * Dropped sysfs bits. Signed-off-by: Tvrtko Ursulin Reviewed-by: Chris Wilson # v11 Reviewed-by: Aravind Iddamsetty # v11 Signed-off-by: Chris Wilson --- drivers/gpu/drm/i915/Makefile | 5 +- drivers/gpu/drm/i915/i915_drm_client.c | 113 +++++++++++++++++++++++++ drivers/gpu/drm/i915/i915_drm_client.h | 61 +++++++++++++ drivers/gpu/drm/i915/i915_drv.c | 6 ++ drivers/gpu/drm/i915/i915_drv.h | 5 ++ drivers/gpu/drm/i915/i915_gem.c | 21 ++++- 6 files changed, 206 insertions(+), 5 deletions(-) create mode 100644 drivers/gpu/drm/i915/i915_drm_client.c create mode 100644 drivers/gpu/drm/i915/i915_drm_client.h diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile index 10b3bb6207ba..784f99ca11fc 100644 --- a/drivers/gpu/drm/i915/Makefile +++ b/drivers/gpu/drm/i915/Makefile @@ -33,8 +33,9 @@ subdir-ccflags-y += -I$(srctree)/$(src) # Please keep these build lists sorted! # core driver code -i915-y += i915_drv.o \ - i915_config.o \ +i915-y += i915_config.o \ + i915_drm_client.o \ + i915_drv.o \ i915_irq.o \ i915_getparam.o \ i915_mitigations.o \ diff --git a/drivers/gpu/drm/i915/i915_drm_client.c b/drivers/gpu/drm/i915/i915_drm_client.c new file mode 100644 index 000000000000..83080d9836b0 --- /dev/null +++ b/drivers/gpu/drm/i915/i915_drm_client.c @@ -0,0 +1,113 @@ +// SPDX-License-Identifier: MIT +/* + * Copyright © 2020 Intel Corporation + */ + +#include +#include +#include + +#include "i915_drm_client.h" +#include "i915_gem.h" +#include "i915_utils.h" + +void i915_drm_clients_init(struct i915_drm_clients *clients, + struct drm_i915_private *i915) +{ + clients->i915 = i915; + + clients->next_id = 0; + xa_init_flags(&clients->xarray, XA_FLAGS_ALLOC); +} + +static int +__i915_drm_client_register(struct i915_drm_client *client, + struct task_struct *task) +{ + char *name; + + name = kstrdup(task->comm, GFP_KERNEL); + if (!name) + return -ENOMEM; + + client->pid = get_task_pid(task, PIDTYPE_PID); + client->name = name; + + return 0; +} + +static void __i915_drm_client_unregister(struct i915_drm_client *client) +{ + put_pid(fetch_and_zero(&client->pid)); + kfree(fetch_and_zero(&client->name)); +} + +static void __rcu_i915_drm_client_free(struct work_struct *wrk) +{ + struct i915_drm_client *client = + container_of(wrk, typeof(*client), rcu.work); + + xa_erase(&client->clients->xarray, client->id); + + __i915_drm_client_unregister(client); + + kfree(client); +} + +struct i915_drm_client * +i915_drm_client_add(struct i915_drm_clients *clients, struct task_struct *task) +{ + struct i915_drm_client *client; + int ret; + + client = kzalloc(sizeof(*client), GFP_KERNEL); + if (!client) + return ERR_PTR(-ENOMEM); + + kref_init(&client->kref); + client->clients = clients; + INIT_RCU_WORK(&client->rcu, __rcu_i915_drm_client_free); + + ret = xa_alloc_cyclic(&clients->xarray, &client->id, client, + xa_limit_32b, &clients->next_id, GFP_KERNEL); + if (ret < 0) + goto err_id; + + ret = __i915_drm_client_register(client, task); + if (ret) + goto err_register; + + return client; + +err_register: + xa_erase(&clients->xarray, client->id); +err_id: + kfree(client); + + return ERR_PTR(ret); +} + +void __i915_drm_client_free(struct kref *kref) +{ + struct i915_drm_client *client = + container_of(kref, typeof(*client), kref); + + queue_rcu_work(system_wq, &client->rcu); +} + +void i915_drm_client_close(struct i915_drm_client *client) +{ + GEM_BUG_ON(READ_ONCE(client->closed)); + WRITE_ONCE(client->closed, true); + i915_drm_client_put(client); +} + +void i915_drm_clients_fini(struct i915_drm_clients *clients) +{ + while (!xa_empty(&clients->xarray)) { + rcu_barrier(); + flush_workqueue(system_wq); + } + + xa_destroy(&clients->xarray); +} diff --git a/drivers/gpu/drm/i915/i915_drm_client.h b/drivers/gpu/drm/i915/i915_drm_client.h new file mode 100644 index 000000000000..396f1e336b3f --- /dev/null +++ b/drivers/gpu/drm/i915/i915_drm_client.h @@ -0,0 +1,61 @@ +/* SPDX-License-Identifier: MIT */ +/* + * Copyright © 2020 Intel Corporation + */ + +#ifndef __I915_DRM_CLIENT_H__ +#define __I915_DRM_CLIENT_H__ + +#include +#include +#include +#include +#include + +struct drm_i915_private; + +struct i915_drm_clients { + struct drm_i915_private *i915; + + struct xarray xarray; + u32 next_id; +}; + +struct i915_drm_client { + struct kref kref; + + struct rcu_work rcu; + + unsigned int id; + struct pid *pid; + char *name; + bool closed; + + struct i915_drm_clients *clients; +}; + +void i915_drm_clients_init(struct i915_drm_clients *clients, + struct drm_i915_private *i915); + +static inline struct i915_drm_client * +i915_drm_client_get(struct i915_drm_client *client) +{ + kref_get(&client->kref); + return client; +} + +void __i915_drm_client_free(struct kref *kref); + +static inline void i915_drm_client_put(struct i915_drm_client *client) +{ + kref_put(&client->kref, __i915_drm_client_free); +} + +void i915_drm_client_close(struct i915_drm_client *client); + +struct i915_drm_client *i915_drm_client_add(struct i915_drm_clients *clients, + struct task_struct *task); + +void i915_drm_clients_fini(struct i915_drm_clients *clients); + +#endif /* !__I915_DRM_CLIENT_H__ */ diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c index 30d8cd8c69b1..8247dcc7586e 100644 --- a/drivers/gpu/drm/i915/i915_drv.c +++ b/drivers/gpu/drm/i915/i915_drv.c @@ -68,6 +68,7 @@ #include "gt/intel_rc6.h" #include "i915_debugfs.h" +#include "i915_drm_client.h" #include "i915_drv.h" #include "i915_ioc32.h" #include "i915_irq.h" @@ -343,6 +344,8 @@ static int i915_driver_early_probe(struct drm_i915_private *dev_priv) intel_gt_init_early(&dev_priv->gt, dev_priv); + i915_drm_clients_init(&dev_priv->clients, dev_priv); + i915_gem_init_early(dev_priv); /* This must be called before any calls to HAS_PCH_* */ @@ -362,6 +365,7 @@ static int i915_driver_early_probe(struct drm_i915_private *dev_priv) err_gem: i915_gem_cleanup_early(dev_priv); + i915_drm_clients_fini(&dev_priv->clients); intel_gt_driver_late_release(&dev_priv->gt); intel_region_ttm_device_fini(dev_priv); err_ttm: @@ -381,6 +385,7 @@ static void i915_driver_late_release(struct drm_i915_private *dev_priv) intel_irq_fini(dev_priv); intel_power_domains_cleanup(dev_priv); i915_gem_cleanup_early(dev_priv); + i915_drm_clients_fini(&dev_priv->clients); intel_gt_driver_late_release(&dev_priv->gt); intel_region_ttm_device_fini(dev_priv); vlv_suspend_cleanup(dev_priv); @@ -996,6 +1001,7 @@ static void i915_driver_postclose(struct drm_device *dev, struct drm_file *file) struct drm_i915_file_private *file_priv = file->driver_priv; i915_gem_context_close(file); + i915_drm_client_close(file_priv->client); kfree_rcu(file_priv, rcu); diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h index c4747f4407ef..338d384c31eb 100644 --- a/drivers/gpu/drm/i915/i915_drv.h +++ b/drivers/gpu/drm/i915/i915_drv.h @@ -96,6 +96,7 @@ #include "intel_wakeref.h" #include "intel_wopcm.h" +#include "i915_drm_client.h" #include "i915_gem.h" #include "i915_gem_gtt.h" #include "i915_gpu_error.h" @@ -284,6 +285,8 @@ struct drm_i915_file_private { /** ban_score: Accumulated score of all ctx bans and fast hangs. */ atomic_t ban_score; unsigned long hang_timestamp; + + struct i915_drm_client *client; }; /* Interface history: @@ -1218,6 +1221,8 @@ struct drm_i915_private { struct i915_pmu pmu; + struct i915_drm_clients clients; + struct i915_hdcp_comp_master *hdcp_master; bool hdcp_comp_added; diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c index 590efc8b0265..ea6c88a99ed2 100644 --- a/drivers/gpu/drm/i915/i915_gem.c +++ b/drivers/gpu/drm/i915/i915_gem.c @@ -1179,25 +1179,40 @@ void i915_gem_cleanup_early(struct drm_i915_private *dev_priv) int i915_gem_open(struct drm_i915_private *i915, struct drm_file *file) { struct drm_i915_file_private *file_priv; - int ret; + struct i915_drm_client *client; + int ret = -ENOMEM; DRM_DEBUG("\n"); file_priv = kzalloc(sizeof(*file_priv), GFP_KERNEL); if (!file_priv) - return -ENOMEM; + goto err_alloc; + + client = i915_drm_client_add(&i915->clients, current); + if (IS_ERR(client)) { + ret = PTR_ERR(client); + goto err_client; + } file->driver_priv = file_priv; file_priv->dev_priv = i915; file_priv->file = file; + file_priv->client = client; file_priv->bsd_engine = -1; file_priv->hang_timestamp = jiffies; ret = i915_gem_context_open(i915, file); if (ret) - kfree(file_priv); + goto err_context; + + return 0; +err_context: + i915_drm_client_close(client); +err_client: + kfree(file_priv); +err_alloc: return ret; } -- 2.30.2 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=-15.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,HK_RANDOM_FROM,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,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 20265C11F66 for ; Mon, 12 Jul 2021 12:17:43 +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 D9D4A610E6 for ; Mon, 12 Jul 2021 12:17:42 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org D9D4A610E6 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=intel-gfx-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 07BFD89BFE; Mon, 12 Jul 2021 12:17:35 +0000 (UTC) Received: from mga09.intel.com (mga09.intel.com [134.134.136.24]) by gabe.freedesktop.org (Postfix) with ESMTPS id 6895C89AC2; Mon, 12 Jul 2021 12:17:33 +0000 (UTC) X-IronPort-AV: E=McAfee;i="6200,9189,10042"; a="209943837" X-IronPort-AV: E=Sophos;i="5.84,232,1620716400"; d="scan'208";a="209943837" Received: from fmsmga006.fm.intel.com ([10.253.24.20]) by orsmga102.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 12 Jul 2021 05:17:33 -0700 X-IronPort-AV: E=Sophos;i="5.84,232,1620716400"; d="scan'208";a="648236618" Received: from aaroncar-mobl2.ger.corp.intel.com (HELO tursulin-mobl2.home) ([10.213.240.41]) by fmsmga006-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 12 Jul 2021 05:17:31 -0700 From: Tvrtko Ursulin To: Intel-gfx@lists.freedesktop.org Date: Mon, 12 Jul 2021 13:17:12 +0100 Message-Id: <20210712121719.891536-2-tvrtko.ursulin@linux.intel.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20210712121719.891536-1-tvrtko.ursulin@linux.intel.com> References: <20210712121719.891536-1-tvrtko.ursulin@linux.intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH 1/8] drm/i915: Explicitly track DRM clients X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Chris Wilson , dri-devel@lists.freedesktop.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" RnJvbTogVHZydGtvIFVyc3VsaW4gPHR2cnRrby51cnN1bGluQGludGVsLmNvbT4KClRyYWNraW5n IERSTSBjbGllbnRzIG1vcmUgZXhwbGljaXRseSB3aWxsIGFsbG93IGxhdGVyIHBhdGNoZXMgdG8K YWNjdW11bGF0ZSBwYXN0IGFuZCBjdXJyZW50IEdQVSB1c2FnZSBpbiBhIGNlbnRyYWxpc2VkIHBs YWNlIGFuZCBhbHNvCmNvbnNvbGlkYXRlIGFjY2VzcyB0byBvd25pbmcgdGFzayBwaWQvbmFtZS4K ClVuaXF1ZSBjbGllbnQgaWQgaXMgYWxzbyBhc3NpZ25lZCBmb3IgdGhlIHB1cnBvc2Ugb2YgZGlz dGluZ3Vpc2hpbmcvCmNvbnNvbGlkYXRpbmcgYmV0d2VlbiBtdWx0aXBsZSBmaWxlIGRlc2NyaXB0 b3JzIG93bmVkIGJ5IHRoZSBzYW1lIHByb2Nlc3MuCgp2MjoKIENocmlzIFdpbHNvbjoKICogRW5j bG9zZSBuZXcgbWVtYmVycyBpbnRvIGRlZGljYXRlZCBzdHJ1Y3RzLgogKiBQcm90ZWN0IGFnYWlu c3QgZmFpbGVkIHN5c2ZzIHJlZ2lzdHJhdGlvbi4KCnYzOgogKiBzeXNmc19hdHRyX2luaXQuCgp2 NDoKICogRml4IGZvciBpbnRlcm5hbCBjbGllbnRzLgoKdjU6CiAqIFVzZSBjeWNsaWMgaWRhIGZv ciBjbGllbnQgaWQuIChDaHJpcykKICogRG8gbm90IGxlYWsgcGlkIHJlZmVyZW5jZS4gKENocmlz KQogKiBUaWR5IGNvZGUgd2l0aCBzb21lIGxvY2Fscy4KCnY2OgogKiBVc2UgeGFfYWxsb2NfY3lj bGljIHRvIHNpbXBsaWZ5IGxvY2tpbmcuIChDaHJpcykKICogTm8gbmVlZCB0byB1bnJlZ2lzdGVy IGluZGl2aWRpYWwgc3lzZnMgZmlsZXMuIChDaHJpcykKICogUmViYXNlIG9uIHRvcCBvZiBmcHJp diBrcmVmLgogKiBUcmFjayBjbGllbnQgY2xvc2VkIHN0YXR1cyBhbmQgcmVmbGVjdCBpbiBzeXNm cy4KCnY3OgogKiBNYWtlIGRybV9jbGllbnQgbW9yZSBzdGFuZGFsb25lIGNvbmNlcHQuCgp2ODoK ICogU2ltcGxpZnkgc3lzZnMgc2hvdy4gKENocmlzKQogKiBBbHdheXMgdHJhY2sgbmFtZSBhbmQg cGlkLgoKdjk6CiAqIEZpeCBjeWNsaWMgaWQgYXNzaWdubWVudC4KCnYxMDoKICogTm8gbmVlZCBm b3IgYSBtdXRleCBhcm91bmQgeGFfYWxsb2NfY3ljbGljLgogKiBSZWZhY3RvciBzeXNmcyBpbnRv IG93biBmdW5jdGlvbi4KICogVW5yZWdpc3RlciBzeXNmcyBiZWZvcmUgZnJlZWluZyBwaWQgYW5k IG5hbWUuCiAqIE1vdmUgY2xpZW50cyBzZXR1cCBpbnRvIG93biBmdW5jdGlvbi4KCnYxMToKICog Q2FsbCBjbGllbnRzIGluaXQgZGlyZWN0bHkgZnJvbSBkcml2ZXIgaW5pdC4gKENocmlzKQoKdjEy OgogKiBEbyBub3QgZmFpbCBjbGllbnQgYWRkIG9uIGlkIHdyYXAuIChNYWNpZWopCgp2MTMgKEx1 Y2FzKTogUmViYXNlLgoKdjE0OgogKiBEcm9wcGVkIHN5c2ZzIGJpdHMuCgpTaWduZWQtb2ZmLWJ5 OiBUdnJ0a28gVXJzdWxpbiA8dHZydGtvLnVyc3VsaW5AaW50ZWwuY29tPgpSZXZpZXdlZC1ieTog Q2hyaXMgV2lsc29uIDxjaHJpc0BjaHJpcy13aWxzb24uY28udWs+ICMgdjExClJldmlld2VkLWJ5 OiBBcmF2aW5kIElkZGFtc2V0dHkgPGFyYXZpbmQuaWRkYW1zZXR0eUBpbnRlbC5jb20+ICMgdjEx ClNpZ25lZC1vZmYtYnk6IENocmlzIFdpbHNvbiA8Y2hyaXNAY2hyaXMtd2lsc29uLmNvLnVrPgot LS0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L01ha2VmaWxlICAgICAgICAgIHwgICA1ICstCiBkcml2 ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2RybV9jbGllbnQuYyB8IDExMyArKysrKysrKysrKysrKysr KysrKysrKysrCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2RybV9jbGllbnQuaCB8ICA2MSAr KysrKysrKysrKysrCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5jICAgICAgICB8ICAg NiArKwogZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaCAgICAgICAgfCAgIDUgKysKIGRy aXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtLmMgICAgICAgIHwgIDIxICsrKystCiA2IGZpbGVz IGNoYW5nZWQsIDIwNiBpbnNlcnRpb25zKCspLCA1IGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUg MTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJtX2NsaWVudC5jCiBjcmVhdGUgbW9k ZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcm1fY2xpZW50LmgKCmRpZmYgLS1n aXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9NYWtlZmlsZSBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L01ha2VmaWxlCmluZGV4IDEwYjNiYjYyMDdiYS4uNzg0Zjk5Y2ExMWZjIDEwMDY0NAotLS0gYS9k cml2ZXJzL2dwdS9kcm0vaTkxNS9NYWtlZmlsZQorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9N YWtlZmlsZQpAQCAtMzMsOCArMzMsOSBAQCBzdWJkaXItY2NmbGFncy15ICs9IC1JJChzcmN0cmVl KS8kKHNyYykKICMgUGxlYXNlIGtlZXAgdGhlc2UgYnVpbGQgbGlzdHMgc29ydGVkIQogCiAjIGNv cmUgZHJpdmVyIGNvZGUKLWk5MTUteSArPSBpOTE1X2Rydi5vIFwKLQkgIGk5MTVfY29uZmlnLm8g XAoraTkxNS15ICs9IGk5MTVfY29uZmlnLm8gXAorCSAgaTkxNV9kcm1fY2xpZW50Lm8gXAorCSAg aTkxNV9kcnYubyBcCiAJICBpOTE1X2lycS5vIFwKIAkgIGk5MTVfZ2V0cGFyYW0ubyBcCiAJICBp OTE1X21pdGlnYXRpb25zLm8gXApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkx NV9kcm1fY2xpZW50LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2RybV9jbGllbnQuYwpu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjgzMDgwZDk4MzZiMAotLS0g L2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJtX2NsaWVudC5jCkBA IC0wLDAgKzEsMTEzIEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTUlUCisvKgorICog Q29weXJpZ2h0IMKpIDIwMjAgSW50ZWwgQ29ycG9yYXRpb24KKyAqLworCisjaW5jbHVkZSA8bGlu dXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvc2xhYi5oPgorI2luY2x1ZGUgPGxpbnV4L3R5 cGVzLmg+CisKKyNpbmNsdWRlICJpOTE1X2RybV9jbGllbnQuaCIKKyNpbmNsdWRlICJpOTE1X2dl bS5oIgorI2luY2x1ZGUgImk5MTVfdXRpbHMuaCIKKwordm9pZCBpOTE1X2RybV9jbGllbnRzX2lu aXQoc3RydWN0IGk5MTVfZHJtX2NsaWVudHMgKmNsaWVudHMsCisJCQkgICBzdHJ1Y3QgZHJtX2k5 MTVfcHJpdmF0ZSAqaTkxNSkKK3sKKwljbGllbnRzLT5pOTE1ID0gaTkxNTsKKworCWNsaWVudHMt Pm5leHRfaWQgPSAwOworCXhhX2luaXRfZmxhZ3MoJmNsaWVudHMtPnhhcnJheSwgWEFfRkxBR1Nf QUxMT0MpOworfQorCitzdGF0aWMgaW50CitfX2k5MTVfZHJtX2NsaWVudF9yZWdpc3RlcihzdHJ1 Y3QgaTkxNV9kcm1fY2xpZW50ICpjbGllbnQsCisJCQkgICBzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRh c2spCit7CisJY2hhciAqbmFtZTsKKworCW5hbWUgPSBrc3RyZHVwKHRhc2stPmNvbW0sIEdGUF9L RVJORUwpOworCWlmICghbmFtZSkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwljbGllbnQtPnBpZCA9 IGdldF90YXNrX3BpZCh0YXNrLCBQSURUWVBFX1BJRCk7CisJY2xpZW50LT5uYW1lID0gbmFtZTsK KworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBfX2k5MTVfZHJtX2NsaWVudF91bnJlZ2lz dGVyKHN0cnVjdCBpOTE1X2RybV9jbGllbnQgKmNsaWVudCkKK3sKKwlwdXRfcGlkKGZldGNoX2Fu ZF96ZXJvKCZjbGllbnQtPnBpZCkpOworCWtmcmVlKGZldGNoX2FuZF96ZXJvKCZjbGllbnQtPm5h bWUpKTsKK30KKworc3RhdGljIHZvaWQgX19yY3VfaTkxNV9kcm1fY2xpZW50X2ZyZWUoc3RydWN0 IHdvcmtfc3RydWN0ICp3cmspCit7CisJc3RydWN0IGk5MTVfZHJtX2NsaWVudCAqY2xpZW50ID0K KwkJY29udGFpbmVyX29mKHdyaywgdHlwZW9mKCpjbGllbnQpLCByY3Uud29yayk7CisKKwl4YV9l cmFzZSgmY2xpZW50LT5jbGllbnRzLT54YXJyYXksIGNsaWVudC0+aWQpOworCisJX19pOTE1X2Ry bV9jbGllbnRfdW5yZWdpc3RlcihjbGllbnQpOworCisJa2ZyZWUoY2xpZW50KTsKK30KKworc3Ry dWN0IGk5MTVfZHJtX2NsaWVudCAqCitpOTE1X2RybV9jbGllbnRfYWRkKHN0cnVjdCBpOTE1X2Ry bV9jbGllbnRzICpjbGllbnRzLCBzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2spCit7CisJc3RydWN0 IGk5MTVfZHJtX2NsaWVudCAqY2xpZW50OworCWludCByZXQ7CisKKwljbGllbnQgPSBremFsbG9j KHNpemVvZigqY2xpZW50KSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFjbGllbnQpCisJCXJldHVybiBF UlJfUFRSKC1FTk9NRU0pOworCisJa3JlZl9pbml0KCZjbGllbnQtPmtyZWYpOworCWNsaWVudC0+ Y2xpZW50cyA9IGNsaWVudHM7CisJSU5JVF9SQ1VfV09SSygmY2xpZW50LT5yY3UsIF9fcmN1X2k5 MTVfZHJtX2NsaWVudF9mcmVlKTsKKworCXJldCA9IHhhX2FsbG9jX2N5Y2xpYygmY2xpZW50cy0+ eGFycmF5LCAmY2xpZW50LT5pZCwgY2xpZW50LAorCQkJICAgICAgeGFfbGltaXRfMzJiLCAmY2xp ZW50cy0+bmV4dF9pZCwgR0ZQX0tFUk5FTCk7CisJaWYgKHJldCA8IDApCisJCWdvdG8gZXJyX2lk OworCisJcmV0ID0gX19pOTE1X2RybV9jbGllbnRfcmVnaXN0ZXIoY2xpZW50LCB0YXNrKTsKKwlp ZiAocmV0KQorCQlnb3RvIGVycl9yZWdpc3RlcjsKKworCXJldHVybiBjbGllbnQ7CisKK2Vycl9y ZWdpc3RlcjoKKwl4YV9lcmFzZSgmY2xpZW50cy0+eGFycmF5LCBjbGllbnQtPmlkKTsKK2Vycl9p ZDoKKwlrZnJlZShjbGllbnQpOworCisJcmV0dXJuIEVSUl9QVFIocmV0KTsKK30KKwordm9pZCBf X2k5MTVfZHJtX2NsaWVudF9mcmVlKHN0cnVjdCBrcmVmICprcmVmKQoreworCXN0cnVjdCBpOTE1 X2RybV9jbGllbnQgKmNsaWVudCA9CisJCWNvbnRhaW5lcl9vZihrcmVmLCB0eXBlb2YoKmNsaWVu dCksIGtyZWYpOworCisJcXVldWVfcmN1X3dvcmsoc3lzdGVtX3dxLCAmY2xpZW50LT5yY3UpOwor fQorCit2b2lkIGk5MTVfZHJtX2NsaWVudF9jbG9zZShzdHJ1Y3QgaTkxNV9kcm1fY2xpZW50ICpj bGllbnQpCit7CisJR0VNX0JVR19PTihSRUFEX09OQ0UoY2xpZW50LT5jbG9zZWQpKTsKKwlXUklU RV9PTkNFKGNsaWVudC0+Y2xvc2VkLCB0cnVlKTsKKwlpOTE1X2RybV9jbGllbnRfcHV0KGNsaWVu dCk7Cit9CisKK3ZvaWQgaTkxNV9kcm1fY2xpZW50c19maW5pKHN0cnVjdCBpOTE1X2RybV9jbGll bnRzICpjbGllbnRzKQoreworCXdoaWxlICgheGFfZW1wdHkoJmNsaWVudHMtPnhhcnJheSkpIHsK KwkJcmN1X2JhcnJpZXIoKTsKKwkJZmx1c2hfd29ya3F1ZXVlKHN5c3RlbV93cSk7CisJfQorCisJ eGFfZGVzdHJveSgmY2xpZW50cy0+eGFycmF5KTsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2k5MTVfZHJtX2NsaWVudC5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9k cm1fY2xpZW50LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4zOTZm MWUzMzZiM2YKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Ry bV9jbGllbnQuaApAQCAtMCwwICsxLDYxIEBACisvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjog TUlUICovCisvKgorICogQ29weXJpZ2h0IMKpIDIwMjAgSW50ZWwgQ29ycG9yYXRpb24KKyAqLwor CisjaWZuZGVmIF9fSTkxNV9EUk1fQ0xJRU5UX0hfXworI2RlZmluZSBfX0k5MTVfRFJNX0NMSUVO VF9IX18KKworI2luY2x1ZGUgPGxpbnV4L2tyZWYuaD4KKyNpbmNsdWRlIDxsaW51eC9waWQuaD4K KyNpbmNsdWRlIDxsaW51eC9yY3VwZGF0ZS5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+Cisj aW5jbHVkZSA8bGludXgveGFycmF5Lmg+CisKK3N0cnVjdCBkcm1faTkxNV9wcml2YXRlOworCitz dHJ1Y3QgaTkxNV9kcm1fY2xpZW50cyB7CisJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTU7 CisKKwlzdHJ1Y3QgeGFycmF5IHhhcnJheTsKKwl1MzIgbmV4dF9pZDsKK307CisKK3N0cnVjdCBp OTE1X2RybV9jbGllbnQgeworCXN0cnVjdCBrcmVmIGtyZWY7CisKKwlzdHJ1Y3QgcmN1X3dvcmsg cmN1OworCisJdW5zaWduZWQgaW50IGlkOworCXN0cnVjdCBwaWQgKnBpZDsKKwljaGFyICpuYW1l OworCWJvb2wgY2xvc2VkOworCisJc3RydWN0IGk5MTVfZHJtX2NsaWVudHMgKmNsaWVudHM7Cit9 OworCit2b2lkIGk5MTVfZHJtX2NsaWVudHNfaW5pdChzdHJ1Y3QgaTkxNV9kcm1fY2xpZW50cyAq Y2xpZW50cywKKwkJCSAgIHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1KTsKKworc3RhdGlj IGlubGluZSBzdHJ1Y3QgaTkxNV9kcm1fY2xpZW50ICoKK2k5MTVfZHJtX2NsaWVudF9nZXQoc3Ry dWN0IGk5MTVfZHJtX2NsaWVudCAqY2xpZW50KQoreworCWtyZWZfZ2V0KCZjbGllbnQtPmtyZWYp OworCXJldHVybiBjbGllbnQ7Cit9CisKK3ZvaWQgX19pOTE1X2RybV9jbGllbnRfZnJlZShzdHJ1 Y3Qga3JlZiAqa3JlZik7CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBpOTE1X2RybV9jbGllbnRfcHV0 KHN0cnVjdCBpOTE1X2RybV9jbGllbnQgKmNsaWVudCkKK3sKKwlrcmVmX3B1dCgmY2xpZW50LT5r cmVmLCBfX2k5MTVfZHJtX2NsaWVudF9mcmVlKTsKK30KKwordm9pZCBpOTE1X2RybV9jbGllbnRf Y2xvc2Uoc3RydWN0IGk5MTVfZHJtX2NsaWVudCAqY2xpZW50KTsKKworc3RydWN0IGk5MTVfZHJt X2NsaWVudCAqaTkxNV9kcm1fY2xpZW50X2FkZChzdHJ1Y3QgaTkxNV9kcm1fY2xpZW50cyAqY2xp ZW50cywKKwkJCQkJICAgIHN0cnVjdCB0YXNrX3N0cnVjdCAqdGFzayk7CisKK3ZvaWQgaTkxNV9k cm1fY2xpZW50c19maW5pKHN0cnVjdCBpOTE1X2RybV9jbGllbnRzICpjbGllbnRzKTsKKworI2Vu ZGlmIC8qICFfX0k5MTVfRFJNX0NMSUVOVF9IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2k5MTVfZHJ2LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5jCmlu ZGV4IDMwZDhjZDhjNjliMS4uODI0N2RjYzc1ODZlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9k cm0vaTkxNS9pOTE1X2Rydi5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmMK QEAgLTY4LDYgKzY4LDcgQEAKICNpbmNsdWRlICJndC9pbnRlbF9yYzYuaCIKIAogI2luY2x1ZGUg Imk5MTVfZGVidWdmcy5oIgorI2luY2x1ZGUgImk5MTVfZHJtX2NsaWVudC5oIgogI2luY2x1ZGUg Imk5MTVfZHJ2LmgiCiAjaW5jbHVkZSAiaTkxNV9pb2MzMi5oIgogI2luY2x1ZGUgImk5MTVfaXJx LmgiCkBAIC0zNDMsNiArMzQ0LDggQEAgc3RhdGljIGludCBpOTE1X2RyaXZlcl9lYXJseV9wcm9i ZShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYpCiAKIAlpbnRlbF9ndF9pbml0X2Vh cmx5KCZkZXZfcHJpdi0+Z3QsIGRldl9wcml2KTsKIAorCWk5MTVfZHJtX2NsaWVudHNfaW5pdCgm ZGV2X3ByaXYtPmNsaWVudHMsIGRldl9wcml2KTsKKwogCWk5MTVfZ2VtX2luaXRfZWFybHkoZGV2 X3ByaXYpOwogCiAJLyogVGhpcyBtdXN0IGJlIGNhbGxlZCBiZWZvcmUgYW55IGNhbGxzIHRvIEhB U19QQ0hfKiAqLwpAQCAtMzYyLDYgKzM2NSw3IEBAIHN0YXRpYyBpbnQgaTkxNV9kcml2ZXJfZWFy bHlfcHJvYmUoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2KQogCiBlcnJfZ2VtOgog CWk5MTVfZ2VtX2NsZWFudXBfZWFybHkoZGV2X3ByaXYpOworCWk5MTVfZHJtX2NsaWVudHNfZmlu aSgmZGV2X3ByaXYtPmNsaWVudHMpOwogCWludGVsX2d0X2RyaXZlcl9sYXRlX3JlbGVhc2UoJmRl dl9wcml2LT5ndCk7CiAJaW50ZWxfcmVnaW9uX3R0bV9kZXZpY2VfZmluaShkZXZfcHJpdik7CiBl cnJfdHRtOgpAQCAtMzgxLDYgKzM4NSw3IEBAIHN0YXRpYyB2b2lkIGk5MTVfZHJpdmVyX2xhdGVf cmVsZWFzZShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYpCiAJaW50ZWxfaXJxX2Zp bmkoZGV2X3ByaXYpOwogCWludGVsX3Bvd2VyX2RvbWFpbnNfY2xlYW51cChkZXZfcHJpdik7CiAJ aTkxNV9nZW1fY2xlYW51cF9lYXJseShkZXZfcHJpdik7CisJaTkxNV9kcm1fY2xpZW50c19maW5p KCZkZXZfcHJpdi0+Y2xpZW50cyk7CiAJaW50ZWxfZ3RfZHJpdmVyX2xhdGVfcmVsZWFzZSgmZGV2 X3ByaXYtPmd0KTsKIAlpbnRlbF9yZWdpb25fdHRtX2RldmljZV9maW5pKGRldl9wcml2KTsKIAl2 bHZfc3VzcGVuZF9jbGVhbnVwKGRldl9wcml2KTsKQEAgLTk5Niw2ICsxMDAxLDcgQEAgc3RhdGlj IHZvaWQgaTkxNV9kcml2ZXJfcG9zdGNsb3NlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHN0cnVj dCBkcm1fZmlsZSAqZmlsZSkKIAlzdHJ1Y3QgZHJtX2k5MTVfZmlsZV9wcml2YXRlICpmaWxlX3By aXYgPSBmaWxlLT5kcml2ZXJfcHJpdjsKIAogCWk5MTVfZ2VtX2NvbnRleHRfY2xvc2UoZmlsZSk7 CisJaTkxNV9kcm1fY2xpZW50X2Nsb3NlKGZpbGVfcHJpdi0+Y2xpZW50KTsKIAogCWtmcmVlX3Jj dShmaWxlX3ByaXYsIHJjdSk7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5 MTVfZHJ2LmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oCmluZGV4IGM0NzQ3ZjQ0 MDdlZi4uMzM4ZDM4NGMzMWViIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1 X2Rydi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmgKQEAgLTk2LDYgKzk2 LDcgQEAKICNpbmNsdWRlICJpbnRlbF93YWtlcmVmLmgiCiAjaW5jbHVkZSAiaW50ZWxfd29wY20u aCIKIAorI2luY2x1ZGUgImk5MTVfZHJtX2NsaWVudC5oIgogI2luY2x1ZGUgImk5MTVfZ2VtLmgi CiAjaW5jbHVkZSAiaTkxNV9nZW1fZ3R0LmgiCiAjaW5jbHVkZSAiaTkxNV9ncHVfZXJyb3IuaCIK QEAgLTI4NCw2ICsyODUsOCBAQCBzdHJ1Y3QgZHJtX2k5MTVfZmlsZV9wcml2YXRlIHsKIAkvKiog YmFuX3Njb3JlOiBBY2N1bXVsYXRlZCBzY29yZSBvZiBhbGwgY3R4IGJhbnMgYW5kIGZhc3QgaGFu Z3MuICovCiAJYXRvbWljX3QgYmFuX3Njb3JlOwogCXVuc2lnbmVkIGxvbmcgaGFuZ190aW1lc3Rh bXA7CisKKwlzdHJ1Y3QgaTkxNV9kcm1fY2xpZW50ICpjbGllbnQ7CiB9OwogCiAvKiBJbnRlcmZh Y2UgaGlzdG9yeToKQEAgLTEyMTgsNiArMTIyMSw4IEBAIHN0cnVjdCBkcm1faTkxNV9wcml2YXRl IHsKIAogCXN0cnVjdCBpOTE1X3BtdSBwbXU7CiAKKwlzdHJ1Y3QgaTkxNV9kcm1fY2xpZW50cyBj bGllbnRzOworCiAJc3RydWN0IGk5MTVfaGRjcF9jb21wX21hc3RlciAqaGRjcF9tYXN0ZXI7CiAJ Ym9vbCBoZGNwX2NvbXBfYWRkZWQ7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2k5MTVfZ2VtLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbS5jCmluZGV4IDU5MGVm YzhiMDI2NS4uZWE2Yzg4YTk5ZWQyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9p OTE1X2dlbS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtLmMKQEAgLTExNzks MjUgKzExNzksNDAgQEAgdm9pZCBpOTE1X2dlbV9jbGVhbnVwX2Vhcmx5KHN0cnVjdCBkcm1faTkx NV9wcml2YXRlICpkZXZfcHJpdikKIGludCBpOTE1X2dlbV9vcGVuKHN0cnVjdCBkcm1faTkxNV9w cml2YXRlICppOTE1LCBzdHJ1Y3QgZHJtX2ZpbGUgKmZpbGUpCiB7CiAJc3RydWN0IGRybV9pOTE1 X2ZpbGVfcHJpdmF0ZSAqZmlsZV9wcml2OwotCWludCByZXQ7CisJc3RydWN0IGk5MTVfZHJtX2Ns aWVudCAqY2xpZW50OworCWludCByZXQgPSAtRU5PTUVNOwogCiAJRFJNX0RFQlVHKCJcbiIpOwog CiAJZmlsZV9wcml2ID0ga3phbGxvYyhzaXplb2YoKmZpbGVfcHJpdiksIEdGUF9LRVJORUwpOwog CWlmICghZmlsZV9wcml2KQotCQlyZXR1cm4gLUVOT01FTTsKKwkJZ290byBlcnJfYWxsb2M7CisK KwljbGllbnQgPSBpOTE1X2RybV9jbGllbnRfYWRkKCZpOTE1LT5jbGllbnRzLCBjdXJyZW50KTsK KwlpZiAoSVNfRVJSKGNsaWVudCkpIHsKKwkJcmV0ID0gUFRSX0VSUihjbGllbnQpOworCQlnb3Rv IGVycl9jbGllbnQ7CisJfQogCiAJZmlsZS0+ZHJpdmVyX3ByaXYgPSBmaWxlX3ByaXY7CiAJZmls ZV9wcml2LT5kZXZfcHJpdiA9IGk5MTU7CiAJZmlsZV9wcml2LT5maWxlID0gZmlsZTsKKwlmaWxl X3ByaXYtPmNsaWVudCA9IGNsaWVudDsKIAogCWZpbGVfcHJpdi0+YnNkX2VuZ2luZSA9IC0xOwog CWZpbGVfcHJpdi0+aGFuZ190aW1lc3RhbXAgPSBqaWZmaWVzOwogCiAJcmV0ID0gaTkxNV9nZW1f Y29udGV4dF9vcGVuKGk5MTUsIGZpbGUpOwogCWlmIChyZXQpCi0JCWtmcmVlKGZpbGVfcHJpdik7 CisJCWdvdG8gZXJyX2NvbnRleHQ7CisKKwlyZXR1cm4gMDsKIAorZXJyX2NvbnRleHQ6CisJaTkx NV9kcm1fY2xpZW50X2Nsb3NlKGNsaWVudCk7CitlcnJfY2xpZW50OgorCWtmcmVlKGZpbGVfcHJp dik7CitlcnJfYWxsb2M6CiAJcmV0dXJuIHJldDsKIH0KIAotLSAKMi4zMC4yCgpfX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZnggbWFpbGluZyBs aXN0CkludGVsLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVz a3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZngK