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 D96C6C433B4 for ; Thu, 13 May 2021 11:00:15 +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 6F20E6143E for ; Thu, 13 May 2021 11:00:14 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 6F20E6143E 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 871676E879; Thu, 13 May 2021 11:00:13 +0000 (UTC) Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by gabe.freedesktop.org (Postfix) with ESMTPS id 286DD6E879; Thu, 13 May 2021 11:00:12 +0000 (UTC) IronPort-SDR: ar+mLABCh2WzbxQ22jnfW+3Yslbj2EE0EPHrBj9kUtg/xioWDnL5BgqW8YiSE2KlKk/qqEcL1v t0KrPT7n5eLg== X-IronPort-AV: E=McAfee;i="6200,9189,9982"; a="187048069" X-IronPort-AV: E=Sophos;i="5.82,296,1613462400"; d="scan'208";a="187048069" Received: from fmsmga007.fm.intel.com ([10.253.24.52]) by orsmga101.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 13 May 2021 04:00:11 -0700 IronPort-SDR: XAf2XGpzVYQVDKdadks1L5CUPuUvzB/SpNus/JZK+rQ8orzIScX2R2Jx09sNLfql56Aoqh+LLx FbbKZf+xj0Xw== X-IronPort-AV: E=Sophos;i="5.82,296,1613462400"; d="scan'208";a="400930390" Received: from hcadcock-mobl1.ger.corp.intel.com (HELO tursulin-mobl2.home) ([10.213.209.166]) by fmsmga007-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 13 May 2021 04:00:10 -0700 From: Tvrtko Ursulin To: Intel-gfx@lists.freedesktop.org Subject: [PATCH 1/7] drm/i915: Expose list of clients in sysfs Date: Thu, 13 May 2021 11:59:56 +0100 Message-Id: <20210513110002.3641705-2-tvrtko.ursulin@linux.intel.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20210513110002.3641705-1-tvrtko.ursulin@linux.intel.com> References: <20210513110002.3641705-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: dri-devel@lists.freedesktop.org Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" From: Tvrtko Ursulin Expose a list of clients with open file handles in sysfs. This will be a basis for a top-like utility showing per-client and per- engine GPU load. Currently we only expose each client's pid and name under opaque numbered directories in /sys/class/drm/card0/clients/. For instance: /sys/class/drm/card0/clients/3/name: Xorg /sys/class/drm/card0/clients/3/pid: 5664 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 on upstream Signed-off-by: Tvrtko Ursulin Reviewed-by: Chris Wilson Reviewed-by: Aravind Iddamsetty # v11 Signed-off-by: Chris Wilson Link: https://patchwork.freedesktop.org/patch/msgid/20210123153733.18139-2-chris@chris-wilson.co.uk Link: https://patchwork.freedesktop.org/patch/msgid/20210124153136.19124-2-chris@chris-wilson.co.uk --- drivers/gpu/drm/i915/Makefile | 5 +- drivers/gpu/drm/i915/i915_drm_client.c | 200 +++++++++++++++++++++++++ drivers/gpu/drm/i915/i915_drm_client.h | 71 +++++++++ drivers/gpu/drm/i915/i915_drv.c | 6 + drivers/gpu/drm/i915/i915_drv.h | 5 + drivers/gpu/drm/i915/i915_gem.c | 21 ++- drivers/gpu/drm/i915/i915_sysfs.c | 8 + 7 files changed, 311 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 d0d936d9137b..e89ce541fe68 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..7c2d36860ac1 --- /dev/null +++ b/drivers/gpu/drm/i915/i915_drm_client.c @@ -0,0 +1,200 @@ +// 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 ssize_t +show_client_name(struct device *kdev, struct device_attribute *attr, char *buf) +{ + struct i915_drm_client *client = + container_of(attr, typeof(*client), attr.name); + + return sysfs_emit(buf, + READ_ONCE(client->closed) ? "<%s>\n" : "%s\n", + client->name); +} + +static ssize_t +show_client_pid(struct device *kdev, struct device_attribute *attr, char *buf) +{ + struct i915_drm_client *client = + container_of(attr, typeof(*client), attr.pid); + + return sysfs_emit(buf, + READ_ONCE(client->closed) ? "<%u>\n" : "%u\n", + pid_nr(client->pid)); +} + +static int __client_register_sysfs(struct i915_drm_client *client) +{ + const struct { + const char *name; + struct device_attribute *attr; + ssize_t (*show)(struct device *dev, + struct device_attribute *attr, + char *buf); + } files[] = { + { "name", &client->attr.name, show_client_name }, + { "pid", &client->attr.pid, show_client_pid }, + }; + unsigned int i; + char buf[16]; + int ret; + + ret = scnprintf(buf, sizeof(buf), "%u", client->id); + if (ret == sizeof(buf)) + return -EINVAL; + + client->root = kobject_create_and_add(buf, client->clients->root); + if (!client->root) + return -ENOMEM; + + for (i = 0; i < ARRAY_SIZE(files); i++) { + struct device_attribute *attr = files[i].attr; + + sysfs_attr_init(&attr->attr); + + attr->attr.name = files[i].name; + attr->attr.mode = 0444; + attr->show = files[i].show; + + ret = sysfs_create_file(client->root, &attr->attr); + if (ret) + break; + } + + if (ret) + kobject_put(client->root); + + return ret; +} + +static void __client_unregister_sysfs(struct i915_drm_client *client) +{ + kobject_put(fetch_and_zero(&client->root)); +} + +static int +__i915_drm_client_register(struct i915_drm_client *client, + struct task_struct *task) +{ + struct i915_drm_clients *clients = client->clients; + char *name; + int ret; + + name = kstrdup(task->comm, GFP_KERNEL); + if (!name) + return -ENOMEM; + + client->pid = get_task_pid(task, PIDTYPE_PID); + client->name = name; + + if (!clients->root) + return 0; /* intel_fbdev_init registers a client before sysfs */ + + ret = __client_register_sysfs(client); + if (ret) + goto err_sysfs; + + return 0; + +err_sysfs: + put_pid(client->pid); + kfree(client->name); + + return ret; +} + +static void __i915_drm_client_unregister(struct i915_drm_client *client) +{ + __client_unregister_sysfs(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); + + __i915_drm_client_unregister(client); + + xa_erase(&client->clients->xarray, client->id); + 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..150f8e8d34e6 --- /dev/null +++ b/drivers/gpu/drm/i915/i915_drm_client.h @@ -0,0 +1,71 @@ +/* SPDX-License-Identifier: MIT */ +/* + * Copyright © 2020 Intel Corporation + */ + +#ifndef __I915_DRM_CLIENT_H__ +#define __I915_DRM_CLIENT_H__ + +#include +#include +#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 kobject *root; +}; + +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; + + struct kobject *root; + struct { + struct device_attribute pid; + struct device_attribute name; + } attr; +}; + +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 5118dc8386b2..2be26aea035b 100644 --- a/drivers/gpu/drm/i915/i915_drv.c +++ b/drivers/gpu/drm/i915/i915_drv.c @@ -69,6 +69,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" @@ -339,6 +340,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_* */ @@ -358,6 +361,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); vlv_suspend_cleanup(dev_priv); err_workqueues: @@ -375,6 +379,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); vlv_suspend_cleanup(dev_priv); i915_workqueues_cleanup(dev_priv); @@ -984,6 +989,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 61308ce19059..6c0f12248156 100644 --- a/drivers/gpu/drm/i915/i915_drv.h +++ b/drivers/gpu/drm/i915/i915_drv.h @@ -95,6 +95,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" @@ -221,6 +222,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: @@ -1160,6 +1163,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 d0018c5f88bd..8643b2a67f6d 100644 --- a/drivers/gpu/drm/i915/i915_gem.c +++ b/drivers/gpu/drm/i915/i915_gem.c @@ -1182,25 +1182,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; } diff --git a/drivers/gpu/drm/i915/i915_sysfs.c b/drivers/gpu/drm/i915/i915_sysfs.c index 4c6b5d52b5ca..e7aef29068ac 100644 --- a/drivers/gpu/drm/i915/i915_sysfs.c +++ b/drivers/gpu/drm/i915/i915_sysfs.c @@ -554,6 +554,11 @@ void i915_setup_sysfs(struct drm_i915_private *dev_priv) struct device *kdev = dev_priv->drm.primary->kdev; int ret; + dev_priv->clients.root = + kobject_create_and_add("clients", &kdev->kobj); + if (!dev_priv->clients.root) + drm_warn(&dev_priv->drm, "Per-client sysfs setup failed\n"); + #ifdef CONFIG_PM if (HAS_RC6(dev_priv)) { ret = sysfs_merge_group(&kdev->kobj, @@ -621,4 +626,7 @@ void i915_teardown_sysfs(struct drm_i915_private *dev_priv) sysfs_unmerge_group(&kdev->kobj, &rc6_attr_group); sysfs_unmerge_group(&kdev->kobj, &rc6p_attr_group); #endif + + if (dev_priv->clients.root) + kobject_put(dev_priv->clients.root); } -- 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 710E1C433B4 for ; Thu, 13 May 2021 11:00:20 +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 232796143E for ; Thu, 13 May 2021 11:00:20 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 232796143E 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 BDB4C6E87D; Thu, 13 May 2021 11:00:14 +0000 (UTC) Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by gabe.freedesktop.org (Postfix) with ESMTPS id 286DD6E879; Thu, 13 May 2021 11:00:12 +0000 (UTC) IronPort-SDR: ar+mLABCh2WzbxQ22jnfW+3Yslbj2EE0EPHrBj9kUtg/xioWDnL5BgqW8YiSE2KlKk/qqEcL1v t0KrPT7n5eLg== X-IronPort-AV: E=McAfee;i="6200,9189,9982"; a="187048069" X-IronPort-AV: E=Sophos;i="5.82,296,1613462400"; d="scan'208";a="187048069" Received: from fmsmga007.fm.intel.com ([10.253.24.52]) by orsmga101.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 13 May 2021 04:00:11 -0700 IronPort-SDR: XAf2XGpzVYQVDKdadks1L5CUPuUvzB/SpNus/JZK+rQ8orzIScX2R2Jx09sNLfql56Aoqh+LLx FbbKZf+xj0Xw== X-IronPort-AV: E=Sophos;i="5.82,296,1613462400"; d="scan'208";a="400930390" Received: from hcadcock-mobl1.ger.corp.intel.com (HELO tursulin-mobl2.home) ([10.213.209.166]) by fmsmga007-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 13 May 2021 04:00:10 -0700 From: Tvrtko Ursulin To: Intel-gfx@lists.freedesktop.org Date: Thu, 13 May 2021 11:59:56 +0100 Message-Id: <20210513110002.3641705-2-tvrtko.ursulin@linux.intel.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20210513110002.3641705-1-tvrtko.ursulin@linux.intel.com> References: <20210513110002.3641705-1-tvrtko.ursulin@linux.intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH 1/7] drm/i915: Expose list of clients in sysfs 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: 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" RnJvbTogVHZydGtvIFVyc3VsaW4gPHR2cnRrby51cnN1bGluQGludGVsLmNvbT4KCkV4cG9zZSBh IGxpc3Qgb2YgY2xpZW50cyB3aXRoIG9wZW4gZmlsZSBoYW5kbGVzIGluIHN5c2ZzLgoKVGhpcyB3 aWxsIGJlIGEgYmFzaXMgZm9yIGEgdG9wLWxpa2UgdXRpbGl0eSBzaG93aW5nIHBlci1jbGllbnQg YW5kIHBlci0KZW5naW5lIEdQVSBsb2FkLgoKQ3VycmVudGx5IHdlIG9ubHkgZXhwb3NlIGVhY2gg Y2xpZW50J3MgcGlkIGFuZCBuYW1lIHVuZGVyIG9wYXF1ZSBudW1iZXJlZApkaXJlY3RvcmllcyBp biAvc3lzL2NsYXNzL2RybS9jYXJkMC9jbGllbnRzLy4KCkZvciBpbnN0YW5jZToKCi9zeXMvY2xh c3MvZHJtL2NhcmQwL2NsaWVudHMvMy9uYW1lOiBYb3JnCi9zeXMvY2xhc3MvZHJtL2NhcmQwL2Ns aWVudHMvMy9waWQ6IDU2NjQKCnYyOgogQ2hyaXMgV2lsc29uOgogKiBFbmNsb3NlIG5ldyBtZW1i ZXJzIGludG8gZGVkaWNhdGVkIHN0cnVjdHMuCiAqIFByb3RlY3QgYWdhaW5zdCBmYWlsZWQgc3lz ZnMgcmVnaXN0cmF0aW9uLgoKdjM6CiAqIHN5c2ZzX2F0dHJfaW5pdC4KCnY0OgogKiBGaXggZm9y IGludGVybmFsIGNsaWVudHMuCgp2NToKICogVXNlIGN5Y2xpYyBpZGEgZm9yIGNsaWVudCBpZC4g KENocmlzKQogKiBEbyBub3QgbGVhayBwaWQgcmVmZXJlbmNlLiAoQ2hyaXMpCiAqIFRpZHkgY29k ZSB3aXRoIHNvbWUgbG9jYWxzLgoKdjY6CiAqIFVzZSB4YV9hbGxvY19jeWNsaWMgdG8gc2ltcGxp ZnkgbG9ja2luZy4gKENocmlzKQogKiBObyBuZWVkIHRvIHVucmVnaXN0ZXIgaW5kaXZpZGlhbCBz eXNmcyBmaWxlcy4gKENocmlzKQogKiBSZWJhc2Ugb24gdG9wIG9mIGZwcml2IGtyZWYuCiAqIFRy YWNrIGNsaWVudCBjbG9zZWQgc3RhdHVzIGFuZCByZWZsZWN0IGluIHN5c2ZzLgoKdjc6CiAqIE1h a2UgZHJtX2NsaWVudCBtb3JlIHN0YW5kYWxvbmUgY29uY2VwdC4KCnY4OgogKiBTaW1wbGlmeSBz eXNmcyBzaG93LiAoQ2hyaXMpCiAqIEFsd2F5cyB0cmFjayBuYW1lIGFuZCBwaWQuCgp2OToKICog Rml4IGN5Y2xpYyBpZCBhc3NpZ25tZW50LgoKdjEwOgogKiBObyBuZWVkIGZvciBhIG11dGV4IGFy b3VuZCB4YV9hbGxvY19jeWNsaWMuCiAqIFJlZmFjdG9yIHN5c2ZzIGludG8gb3duIGZ1bmN0aW9u LgogKiBVbnJlZ2lzdGVyIHN5c2ZzIGJlZm9yZSBmcmVlaW5nIHBpZCBhbmQgbmFtZS4KICogTW92 ZSBjbGllbnRzIHNldHVwIGludG8gb3duIGZ1bmN0aW9uLgoKdjExOgogKiBDYWxsIGNsaWVudHMg aW5pdCBkaXJlY3RseSBmcm9tIGRyaXZlciBpbml0LiAoQ2hyaXMpCgp2MTI6CiAqIERvIG5vdCBm YWlsIGNsaWVudCBhZGQgb24gaWQgd3JhcC4gKE1hY2llaikKCnYxMyAoTHVjYXMpOiBSZWJhc2Ug b24gdXBzdHJlYW0KClNpZ25lZC1vZmYtYnk6IFR2cnRrbyBVcnN1bGluIDx0dnJ0a28udXJzdWxp bkBpbnRlbC5jb20+ClJldmlld2VkLWJ5OiBDaHJpcyBXaWxzb24gPGNocmlzQGNocmlzLXdpbHNv bi5jby51az4KUmV2aWV3ZWQtYnk6IEFyYXZpbmQgSWRkYW1zZXR0eSA8YXJhdmluZC5pZGRhbXNl dHR5QGludGVsLmNvbT4gIyB2MTEKU2lnbmVkLW9mZi1ieTogQ2hyaXMgV2lsc29uIDxjaHJpc0Bj aHJpcy13aWxzb24uY28udWs+Ckxpbms6IGh0dHBzOi8vcGF0Y2h3b3JrLmZyZWVkZXNrdG9wLm9y Zy9wYXRjaC9tc2dpZC8yMDIxMDEyMzE1MzczMy4xODEzOS0yLWNocmlzQGNocmlzLXdpbHNvbi5j by51awpMaW5rOiBodHRwczovL3BhdGNod29yay5mcmVlZGVza3RvcC5vcmcvcGF0Y2gvbXNnaWQv MjAyMTAxMjQxNTMxMzYuMTkxMjQtMi1jaHJpc0BjaHJpcy13aWxzb24uY28udWsKLS0tCiBkcml2 ZXJzL2dwdS9kcm0vaTkxNS9NYWtlZmlsZSAgICAgICAgICB8ICAgNSArLQogZHJpdmVycy9ncHUv ZHJtL2k5MTUvaTkxNV9kcm1fY2xpZW50LmMgfCAyMDAgKysrKysrKysrKysrKysrKysrKysrKysr KwogZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcm1fY2xpZW50LmggfCAgNzEgKysrKysrKysr CiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5jICAgICAgICB8ICAgNiArCiBkcml2ZXJz L2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oICAgICAgICB8ICAgNSArCiBkcml2ZXJzL2dwdS9kcm0v aTkxNS9pOTE1X2dlbS5jICAgICAgICB8ICAyMSArKy0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2k5 MTVfc3lzZnMuYyAgICAgIHwgICA4ICsKIDcgZmlsZXMgY2hhbmdlZCwgMzExIGluc2VydGlvbnMo KyksIDUgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL2k5 MTUvaTkxNV9kcm1fY2xpZW50LmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0v aTkxNS9pOTE1X2RybV9jbGllbnQuaAoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L01ha2VmaWxlIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvTWFrZWZpbGUKaW5kZXggZDBkOTM2ZDkx MzdiLi5lODljZTU0MWZlNjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L01ha2Vm aWxlCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L01ha2VmaWxlCkBAIC0zMyw4ICszMyw5IEBA IHN1YmRpci1jY2ZsYWdzLXkgKz0gLUkkKHNyY3RyZWUpLyQoc3JjKQogIyBQbGVhc2Uga2VlcCB0 aGVzZSBidWlsZCBsaXN0cyBzb3J0ZWQhCiAKICMgY29yZSBkcml2ZXIgY29kZQotaTkxNS15ICs9 IGk5MTVfZHJ2Lm8gXAotCSAgaTkxNV9jb25maWcubyBcCitpOTE1LXkgKz0gaTkxNV9jb25maWcu byBcCisJICBpOTE1X2RybV9jbGllbnQubyBcCisJICBpOTE1X2Rydi5vIFwKIAkgIGk5MTVfaXJx Lm8gXAogCSAgaTkxNV9nZXRwYXJhbS5vIFwKIAkgIGk5MTVfbWl0aWdhdGlvbnMubyBcCmRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2RybV9jbGllbnQuYyBiL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2k5MTVfZHJtX2NsaWVudC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAwMC4uN2MyZDM2ODYwYWMxCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9n cHUvZHJtL2k5MTUvaTkxNV9kcm1fY2xpZW50LmMKQEAgLTAsMCArMSwyMDAgQEAKKy8vIFNQRFgt TGljZW5zZS1JZGVudGlmaWVyOiBNSVQKKy8qCisgKiBDb3B5cmlnaHQgwqkgMjAyMCBJbnRlbCBD b3Jwb3JhdGlvbgorICovCisKKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxs aW51eC9zbGFiLmg+CisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKworI2luY2x1ZGUgImk5MTVf ZHJtX2NsaWVudC5oIgorI2luY2x1ZGUgImk5MTVfZ2VtLmgiCisjaW5jbHVkZSAiaTkxNV91dGls cy5oIgorCit2b2lkIGk5MTVfZHJtX2NsaWVudHNfaW5pdChzdHJ1Y3QgaTkxNV9kcm1fY2xpZW50 cyAqY2xpZW50cywKKwkJCSAgIHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1KQoreworCWNs aWVudHMtPmk5MTUgPSBpOTE1OworCisJY2xpZW50cy0+bmV4dF9pZCA9IDA7CisJeGFfaW5pdF9m bGFncygmY2xpZW50cy0+eGFycmF5LCBYQV9GTEFHU19BTExPQyk7Cit9CisKK3N0YXRpYyBzc2l6 ZV90CitzaG93X2NsaWVudF9uYW1lKHN0cnVjdCBkZXZpY2UgKmtkZXYsIHN0cnVjdCBkZXZpY2Vf YXR0cmlidXRlICphdHRyLCBjaGFyICpidWYpCit7CisJc3RydWN0IGk5MTVfZHJtX2NsaWVudCAq Y2xpZW50ID0KKwkJY29udGFpbmVyX29mKGF0dHIsIHR5cGVvZigqY2xpZW50KSwgYXR0ci5uYW1l KTsKKworCXJldHVybiBzeXNmc19lbWl0KGJ1ZiwKKwkJCSAgUkVBRF9PTkNFKGNsaWVudC0+Y2xv c2VkKSA/ICI8JXM+XG4iIDogIiVzXG4iLAorCQkJICBjbGllbnQtPm5hbWUpOworfQorCitzdGF0 aWMgc3NpemVfdAorc2hvd19jbGllbnRfcGlkKHN0cnVjdCBkZXZpY2UgKmtkZXYsIHN0cnVjdCBk ZXZpY2VfYXR0cmlidXRlICphdHRyLCBjaGFyICpidWYpCit7CisJc3RydWN0IGk5MTVfZHJtX2Ns aWVudCAqY2xpZW50ID0KKwkJY29udGFpbmVyX29mKGF0dHIsIHR5cGVvZigqY2xpZW50KSwgYXR0 ci5waWQpOworCisJcmV0dXJuIHN5c2ZzX2VtaXQoYnVmLAorCQkJICBSRUFEX09OQ0UoY2xpZW50 LT5jbG9zZWQpID8gIjwldT5cbiIgOiAiJXVcbiIsCisJCQkgIHBpZF9ucihjbGllbnQtPnBpZCkp OworfQorCitzdGF0aWMgaW50IF9fY2xpZW50X3JlZ2lzdGVyX3N5c2ZzKHN0cnVjdCBpOTE1X2Ry bV9jbGllbnQgKmNsaWVudCkKK3sKKwljb25zdCBzdHJ1Y3QgeworCQljb25zdCBjaGFyICpuYW1l OworCQlzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0cjsKKwkJc3NpemVfdCAoKnNob3cpKHN0 cnVjdCBkZXZpY2UgKmRldiwKKwkJCQlzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKKwkJ CQljaGFyICpidWYpOworCX0gZmlsZXNbXSA9IHsKKwkJeyAibmFtZSIsICZjbGllbnQtPmF0dHIu bmFtZSwgc2hvd19jbGllbnRfbmFtZSB9LAorCQl7ICJwaWQiLCAmY2xpZW50LT5hdHRyLnBpZCwg c2hvd19jbGllbnRfcGlkIH0sCisJfTsKKwl1bnNpZ25lZCBpbnQgaTsKKwljaGFyIGJ1ZlsxNl07 CisJaW50IHJldDsKKworCXJldCA9IHNjbnByaW50ZihidWYsIHNpemVvZihidWYpLCAiJXUiLCBj bGllbnQtPmlkKTsKKwlpZiAocmV0ID09IHNpemVvZihidWYpKQorCQlyZXR1cm4gLUVJTlZBTDsK KworCWNsaWVudC0+cm9vdCA9IGtvYmplY3RfY3JlYXRlX2FuZF9hZGQoYnVmLCBjbGllbnQtPmNs aWVudHMtPnJvb3QpOworCWlmICghY2xpZW50LT5yb290KQorCQlyZXR1cm4gLUVOT01FTTsKKwor CWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKGZpbGVzKTsgaSsrKSB7CisJCXN0cnVjdCBkZXZp Y2VfYXR0cmlidXRlICphdHRyID0gZmlsZXNbaV0uYXR0cjsKKworCQlzeXNmc19hdHRyX2luaXQo JmF0dHItPmF0dHIpOworCisJCWF0dHItPmF0dHIubmFtZSA9IGZpbGVzW2ldLm5hbWU7CisJCWF0 dHItPmF0dHIubW9kZSA9IDA0NDQ7CisJCWF0dHItPnNob3cgPSBmaWxlc1tpXS5zaG93OworCisJ CXJldCA9IHN5c2ZzX2NyZWF0ZV9maWxlKGNsaWVudC0+cm9vdCwgJmF0dHItPmF0dHIpOworCQlp ZiAocmV0KQorCQkJYnJlYWs7CisJfQorCisJaWYgKHJldCkKKwkJa29iamVjdF9wdXQoY2xpZW50 LT5yb290KTsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyB2b2lkIF9fY2xpZW50X3VucmVn aXN0ZXJfc3lzZnMoc3RydWN0IGk5MTVfZHJtX2NsaWVudCAqY2xpZW50KQoreworCWtvYmplY3Rf cHV0KGZldGNoX2FuZF96ZXJvKCZjbGllbnQtPnJvb3QpKTsKK30KKworc3RhdGljIGludAorX19p OTE1X2RybV9jbGllbnRfcmVnaXN0ZXIoc3RydWN0IGk5MTVfZHJtX2NsaWVudCAqY2xpZW50LAor CQkJICAgc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrKQoreworCXN0cnVjdCBpOTE1X2RybV9jbGll bnRzICpjbGllbnRzID0gY2xpZW50LT5jbGllbnRzOworCWNoYXIgKm5hbWU7CisJaW50IHJldDsK KworCW5hbWUgPSBrc3RyZHVwKHRhc2stPmNvbW0sIEdGUF9LRVJORUwpOworCWlmICghbmFtZSkK KwkJcmV0dXJuIC1FTk9NRU07CisKKwljbGllbnQtPnBpZCA9IGdldF90YXNrX3BpZCh0YXNrLCBQ SURUWVBFX1BJRCk7CisJY2xpZW50LT5uYW1lID0gbmFtZTsKKworCWlmICghY2xpZW50cy0+cm9v dCkKKwkJcmV0dXJuIDA7IC8qIGludGVsX2ZiZGV2X2luaXQgcmVnaXN0ZXJzIGEgY2xpZW50IGJl Zm9yZSBzeXNmcyAqLworCisJcmV0ID0gX19jbGllbnRfcmVnaXN0ZXJfc3lzZnMoY2xpZW50KTsK KwlpZiAocmV0KQorCQlnb3RvIGVycl9zeXNmczsKKworCXJldHVybiAwOworCitlcnJfc3lzZnM6 CisJcHV0X3BpZChjbGllbnQtPnBpZCk7CisJa2ZyZWUoY2xpZW50LT5uYW1lKTsKKworCXJldHVy biByZXQ7Cit9CisKK3N0YXRpYyB2b2lkIF9faTkxNV9kcm1fY2xpZW50X3VucmVnaXN0ZXIoc3Ry dWN0IGk5MTVfZHJtX2NsaWVudCAqY2xpZW50KQoreworCV9fY2xpZW50X3VucmVnaXN0ZXJfc3lz ZnMoY2xpZW50KTsKKworCXB1dF9waWQoZmV0Y2hfYW5kX3plcm8oJmNsaWVudC0+cGlkKSk7CisJ a2ZyZWUoZmV0Y2hfYW5kX3plcm8oJmNsaWVudC0+bmFtZSkpOworfQorCitzdGF0aWMgdm9pZCBf X3JjdV9pOTE1X2RybV9jbGllbnRfZnJlZShzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndyaykKK3sKKwlz dHJ1Y3QgaTkxNV9kcm1fY2xpZW50ICpjbGllbnQgPQorCQljb250YWluZXJfb2Yod3JrLCB0eXBl b2YoKmNsaWVudCksIHJjdS53b3JrKTsKKworCV9faTkxNV9kcm1fY2xpZW50X3VucmVnaXN0ZXIo Y2xpZW50KTsKKworCXhhX2VyYXNlKCZjbGllbnQtPmNsaWVudHMtPnhhcnJheSwgY2xpZW50LT5p ZCk7CisJa2ZyZWUoY2xpZW50KTsKK30KKworc3RydWN0IGk5MTVfZHJtX2NsaWVudCAqCitpOTE1 X2RybV9jbGllbnRfYWRkKHN0cnVjdCBpOTE1X2RybV9jbGllbnRzICpjbGllbnRzLCBzdHJ1Y3Qg dGFza19zdHJ1Y3QgKnRhc2spCit7CisJc3RydWN0IGk5MTVfZHJtX2NsaWVudCAqY2xpZW50Owor CWludCByZXQ7CisKKwljbGllbnQgPSBremFsbG9jKHNpemVvZigqY2xpZW50KSwgR0ZQX0tFUk5F TCk7CisJaWYgKCFjbGllbnQpCisJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOworCisJa3JlZl9p bml0KCZjbGllbnQtPmtyZWYpOworCWNsaWVudC0+Y2xpZW50cyA9IGNsaWVudHM7CisJSU5JVF9S Q1VfV09SSygmY2xpZW50LT5yY3UsIF9fcmN1X2k5MTVfZHJtX2NsaWVudF9mcmVlKTsKKworCXJl dCA9IHhhX2FsbG9jX2N5Y2xpYygmY2xpZW50cy0+eGFycmF5LCAmY2xpZW50LT5pZCwgY2xpZW50 LAorCQkJICAgICAgeGFfbGltaXRfMzJiLCAmY2xpZW50cy0+bmV4dF9pZCwgR0ZQX0tFUk5FTCk7 CisJaWYgKHJldCA8IDApCisJCWdvdG8gZXJyX2lkOworCisJcmV0ID0gX19pOTE1X2RybV9jbGll bnRfcmVnaXN0ZXIoY2xpZW50LCB0YXNrKTsKKwlpZiAocmV0KQorCQlnb3RvIGVycl9yZWdpc3Rl cjsKKworCXJldHVybiBjbGllbnQ7CisKK2Vycl9yZWdpc3RlcjoKKwl4YV9lcmFzZSgmY2xpZW50 cy0+eGFycmF5LCBjbGllbnQtPmlkKTsKK2Vycl9pZDoKKwlrZnJlZShjbGllbnQpOworCisJcmV0 dXJuIEVSUl9QVFIocmV0KTsKK30KKwordm9pZCBfX2k5MTVfZHJtX2NsaWVudF9mcmVlKHN0cnVj dCBrcmVmICprcmVmKQoreworCXN0cnVjdCBpOTE1X2RybV9jbGllbnQgKmNsaWVudCA9CisJCWNv bnRhaW5lcl9vZihrcmVmLCB0eXBlb2YoKmNsaWVudCksIGtyZWYpOworCisJcXVldWVfcmN1X3dv cmsoc3lzdGVtX3dxLCAmY2xpZW50LT5yY3UpOworfQorCit2b2lkIGk5MTVfZHJtX2NsaWVudF9j bG9zZShzdHJ1Y3QgaTkxNV9kcm1fY2xpZW50ICpjbGllbnQpCit7CisJR0VNX0JVR19PTihSRUFE X09OQ0UoY2xpZW50LT5jbG9zZWQpKTsKKwlXUklURV9PTkNFKGNsaWVudC0+Y2xvc2VkLCB0cnVl KTsKKwlpOTE1X2RybV9jbGllbnRfcHV0KGNsaWVudCk7Cit9CisKK3ZvaWQgaTkxNV9kcm1fY2xp ZW50c19maW5pKHN0cnVjdCBpOTE1X2RybV9jbGllbnRzICpjbGllbnRzKQoreworCXdoaWxlICgh eGFfZW1wdHkoJmNsaWVudHMtPnhhcnJheSkpIHsKKwkJcmN1X2JhcnJpZXIoKTsKKwkJZmx1c2hf d29ya3F1ZXVlKHN5c3RlbV93cSk7CisJfQorCisJeGFfZGVzdHJveSgmY2xpZW50cy0+eGFycmF5 KTsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJtX2NsaWVudC5o IGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcm1fY2xpZW50LmgKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4xNTBmOGU4ZDM0ZTYKLS0tIC9kZXYvbnVsbAorKysg Yi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2RybV9jbGllbnQuaApAQCAtMCwwICsxLDcxIEBA CisvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTUlUICovCisvKgorICogQ29weXJpZ2h0IMKp IDIwMjAgSW50ZWwgQ29ycG9yYXRpb24KKyAqLworCisjaWZuZGVmIF9fSTkxNV9EUk1fQ0xJRU5U X0hfXworI2RlZmluZSBfX0k5MTVfRFJNX0NMSUVOVF9IX18KKworI2luY2x1ZGUgPGxpbnV4L2Rl dmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L2tvYmplY3QuaD4KKyNpbmNsdWRlIDxsaW51eC9rcmVm Lmg+CisjaW5jbHVkZSA8bGludXgvcGlkLmg+CisjaW5jbHVkZSA8bGludXgvcmN1cGRhdGUuaD4K KyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgorI2luY2x1ZGUgPGxpbnV4L3hhcnJheS5oPgorCitz dHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZTsKKworc3RydWN0IGk5MTVfZHJtX2NsaWVudHMgeworCXN0 cnVjdCBkcm1faTkxNV9wcml2YXRlICppOTE1OworCisJc3RydWN0IHhhcnJheSB4YXJyYXk7CisJ dTMyIG5leHRfaWQ7CisKKwlzdHJ1Y3Qga29iamVjdCAqcm9vdDsKK307CisKK3N0cnVjdCBpOTE1 X2RybV9jbGllbnQgeworCXN0cnVjdCBrcmVmIGtyZWY7CisKKwlzdHJ1Y3QgcmN1X3dvcmsgcmN1 OworCisJdW5zaWduZWQgaW50IGlkOworCXN0cnVjdCBwaWQgKnBpZDsKKwljaGFyICpuYW1lOwor CWJvb2wgY2xvc2VkOworCisJc3RydWN0IGk5MTVfZHJtX2NsaWVudHMgKmNsaWVudHM7CisKKwlz dHJ1Y3Qga29iamVjdCAqcm9vdDsKKwlzdHJ1Y3QgeworCQlzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0 ZSBwaWQ7CisJCXN0cnVjdCBkZXZpY2VfYXR0cmlidXRlIG5hbWU7CisJfSBhdHRyOworfTsKKwor dm9pZCBpOTE1X2RybV9jbGllbnRzX2luaXQoc3RydWN0IGk5MTVfZHJtX2NsaWVudHMgKmNsaWVu dHMsCisJCQkgICBzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSk7CisKK3N0YXRpYyBpbmxp bmUgc3RydWN0IGk5MTVfZHJtX2NsaWVudCAqCitpOTE1X2RybV9jbGllbnRfZ2V0KHN0cnVjdCBp OTE1X2RybV9jbGllbnQgKmNsaWVudCkKK3sKKwlrcmVmX2dldCgmY2xpZW50LT5rcmVmKTsKKwly ZXR1cm4gY2xpZW50OworfQorCit2b2lkIF9faTkxNV9kcm1fY2xpZW50X2ZyZWUoc3RydWN0IGty ZWYgKmtyZWYpOworCitzdGF0aWMgaW5saW5lIHZvaWQgaTkxNV9kcm1fY2xpZW50X3B1dChzdHJ1 Y3QgaTkxNV9kcm1fY2xpZW50ICpjbGllbnQpCit7CisJa3JlZl9wdXQoJmNsaWVudC0+a3JlZiwg X19pOTE1X2RybV9jbGllbnRfZnJlZSk7Cit9CisKK3ZvaWQgaTkxNV9kcm1fY2xpZW50X2Nsb3Nl KHN0cnVjdCBpOTE1X2RybV9jbGllbnQgKmNsaWVudCk7CisKK3N0cnVjdCBpOTE1X2RybV9jbGll bnQgKmk5MTVfZHJtX2NsaWVudF9hZGQoc3RydWN0IGk5MTVfZHJtX2NsaWVudHMgKmNsaWVudHMs CisJCQkJCSAgICBzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhc2spOworCit2b2lkIGk5MTVfZHJtX2Ns aWVudHNfZmluaShzdHJ1Y3QgaTkxNV9kcm1fY2xpZW50cyAqY2xpZW50cyk7CisKKyNlbmRpZiAv KiAhX19JOTE1X0RSTV9DTElFTlRfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pOTE1X2Rydi5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuYwppbmRleCA1 MTE4ZGM4Mzg2YjIuLjJiZTI2YWVhMDM1YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaTkxNV9kcnYuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5jCkBAIC02 OSw2ICs2OSw3IEBACiAjaW5jbHVkZSAiZ3QvaW50ZWxfcmM2LmgiCiAKICNpbmNsdWRlICJpOTE1 X2RlYnVnZnMuaCIKKyNpbmNsdWRlICJpOTE1X2RybV9jbGllbnQuaCIKICNpbmNsdWRlICJpOTE1 X2Rydi5oIgogI2luY2x1ZGUgImk5MTVfaW9jMzIuaCIKICNpbmNsdWRlICJpOTE1X2lycS5oIgpA QCAtMzM5LDYgKzM0MCw4IEBAIHN0YXRpYyBpbnQgaTkxNV9kcml2ZXJfZWFybHlfcHJvYmUoc3Ry dWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2KQogCiAJaW50ZWxfZ3RfaW5pdF9lYXJseSgm ZGV2X3ByaXYtPmd0LCBkZXZfcHJpdik7CiAKKwlpOTE1X2RybV9jbGllbnRzX2luaXQoJmRldl9w cml2LT5jbGllbnRzLCBkZXZfcHJpdik7CisKIAlpOTE1X2dlbV9pbml0X2Vhcmx5KGRldl9wcml2 KTsKIAogCS8qIFRoaXMgbXVzdCBiZSBjYWxsZWQgYmVmb3JlIGFueSBjYWxscyB0byBIQVNfUENI XyogKi8KQEAgLTM1OCw2ICszNjEsNyBAQCBzdGF0aWMgaW50IGk5MTVfZHJpdmVyX2Vhcmx5X3By b2JlKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdikKIAogZXJyX2dlbToKIAlpOTE1 X2dlbV9jbGVhbnVwX2Vhcmx5KGRldl9wcml2KTsKKwlpOTE1X2RybV9jbGllbnRzX2ZpbmkoJmRl dl9wcml2LT5jbGllbnRzKTsKIAlpbnRlbF9ndF9kcml2ZXJfbGF0ZV9yZWxlYXNlKCZkZXZfcHJp di0+Z3QpOwogCXZsdl9zdXNwZW5kX2NsZWFudXAoZGV2X3ByaXYpOwogZXJyX3dvcmtxdWV1ZXM6 CkBAIC0zNzUsNiArMzc5LDcgQEAgc3RhdGljIHZvaWQgaTkxNV9kcml2ZXJfbGF0ZV9yZWxlYXNl KHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdikKIAlpbnRlbF9pcnFfZmluaShkZXZf cHJpdik7CiAJaW50ZWxfcG93ZXJfZG9tYWluc19jbGVhbnVwKGRldl9wcml2KTsKIAlpOTE1X2dl bV9jbGVhbnVwX2Vhcmx5KGRldl9wcml2KTsKKwlpOTE1X2RybV9jbGllbnRzX2ZpbmkoJmRldl9w cml2LT5jbGllbnRzKTsKIAlpbnRlbF9ndF9kcml2ZXJfbGF0ZV9yZWxlYXNlKCZkZXZfcHJpdi0+ Z3QpOwogCXZsdl9zdXNwZW5kX2NsZWFudXAoZGV2X3ByaXYpOwogCWk5MTVfd29ya3F1ZXVlc19j bGVhbnVwKGRldl9wcml2KTsKQEAgLTk4NCw2ICs5ODksNyBAQCBzdGF0aWMgdm9pZCBpOTE1X2Ry aXZlcl9wb3N0Y2xvc2Uoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgc3RydWN0IGRybV9maWxlICpm aWxlKQogCXN0cnVjdCBkcm1faTkxNV9maWxlX3ByaXZhdGUgKmZpbGVfcHJpdiA9IGZpbGUtPmRy aXZlcl9wcml2OwogCiAJaTkxNV9nZW1fY29udGV4dF9jbG9zZShmaWxlKTsKKwlpOTE1X2RybV9j bGllbnRfY2xvc2UoZmlsZV9wcml2LT5jbGllbnQpOwogCiAJa2ZyZWVfcmN1KGZpbGVfcHJpdiwg cmN1KTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaCBiL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmgKaW5kZXggNjEzMDhjZTE5MDU5Li42YzBmMTIy NDgxNTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmgKKysrIGIv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaApAQCAtOTUsNiArOTUsNyBAQAogI2luY2x1 ZGUgImludGVsX3dha2VyZWYuaCIKICNpbmNsdWRlICJpbnRlbF93b3BjbS5oIgogCisjaW5jbHVk ZSAiaTkxNV9kcm1fY2xpZW50LmgiCiAjaW5jbHVkZSAiaTkxNV9nZW0uaCIKICNpbmNsdWRlICJp OTE1X2dlbV9ndHQuaCIKICNpbmNsdWRlICJpOTE1X2dwdV9lcnJvci5oIgpAQCAtMjIxLDYgKzIy Miw4IEBAIHN0cnVjdCBkcm1faTkxNV9maWxlX3ByaXZhdGUgewogCS8qKiBiYW5fc2NvcmU6IEFj Y3VtdWxhdGVkIHNjb3JlIG9mIGFsbCBjdHggYmFucyBhbmQgZmFzdCBoYW5ncy4gKi8KIAlhdG9t aWNfdCBiYW5fc2NvcmU7CiAJdW5zaWduZWQgbG9uZyBoYW5nX3RpbWVzdGFtcDsKKworCXN0cnVj dCBpOTE1X2RybV9jbGllbnQgKmNsaWVudDsKIH07CiAKIC8qIEludGVyZmFjZSBoaXN0b3J5OgpA QCAtMTE2MCw2ICsxMTYzLDggQEAgc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgewogCiAJc3RydWN0 IGk5MTVfcG11IHBtdTsKIAorCXN0cnVjdCBpOTE1X2RybV9jbGllbnRzIGNsaWVudHM7CisKIAlz dHJ1Y3QgaTkxNV9oZGNwX2NvbXBfbWFzdGVyICpoZGNwX21hc3RlcjsKIAlib29sIGhkY3BfY29t cF9hZGRlZDsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW0uYyBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtLmMKaW5kZXggZDAwMThjNWY4OGJkLi44NjQz YjJhNjdmNmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtLmMKKysr IGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW0uYwpAQCAtMTE4MiwyNSArMTE4Miw0MCBA QCB2b2lkIGk5MTVfZ2VtX2NsZWFudXBfZWFybHkoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRl dl9wcml2KQogaW50IGk5MTVfZ2VtX29wZW4oc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUs IHN0cnVjdCBkcm1fZmlsZSAqZmlsZSkKIHsKIAlzdHJ1Y3QgZHJtX2k5MTVfZmlsZV9wcml2YXRl ICpmaWxlX3ByaXY7Ci0JaW50IHJldDsKKwlzdHJ1Y3QgaTkxNV9kcm1fY2xpZW50ICpjbGllbnQ7 CisJaW50IHJldCA9IC1FTk9NRU07CiAKIAlEUk1fREVCVUcoIlxuIik7CiAKIAlmaWxlX3ByaXYg PSBremFsbG9jKHNpemVvZigqZmlsZV9wcml2KSwgR0ZQX0tFUk5FTCk7CiAJaWYgKCFmaWxlX3By aXYpCi0JCXJldHVybiAtRU5PTUVNOworCQlnb3RvIGVycl9hbGxvYzsKKworCWNsaWVudCA9IGk5 MTVfZHJtX2NsaWVudF9hZGQoJmk5MTUtPmNsaWVudHMsIGN1cnJlbnQpOworCWlmIChJU19FUlIo Y2xpZW50KSkgeworCQlyZXQgPSBQVFJfRVJSKGNsaWVudCk7CisJCWdvdG8gZXJyX2NsaWVudDsK Kwl9CiAKIAlmaWxlLT5kcml2ZXJfcHJpdiA9IGZpbGVfcHJpdjsKIAlmaWxlX3ByaXYtPmRldl9w cml2ID0gaTkxNTsKIAlmaWxlX3ByaXYtPmZpbGUgPSBmaWxlOworCWZpbGVfcHJpdi0+Y2xpZW50 ID0gY2xpZW50OwogCiAJZmlsZV9wcml2LT5ic2RfZW5naW5lID0gLTE7CiAJZmlsZV9wcml2LT5o YW5nX3RpbWVzdGFtcCA9IGppZmZpZXM7CiAKIAlyZXQgPSBpOTE1X2dlbV9jb250ZXh0X29wZW4o aTkxNSwgZmlsZSk7CiAJaWYgKHJldCkKLQkJa2ZyZWUoZmlsZV9wcml2KTsKKwkJZ290byBlcnJf Y29udGV4dDsKKworCXJldHVybiAwOwogCitlcnJfY29udGV4dDoKKwlpOTE1X2RybV9jbGllbnRf Y2xvc2UoY2xpZW50KTsKK2Vycl9jbGllbnQ6CisJa2ZyZWUoZmlsZV9wcml2KTsKK2Vycl9hbGxv YzoKIAlyZXR1cm4gcmV0OwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9p OTE1X3N5c2ZzLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3N5c2ZzLmMKaW5kZXggNGM2 YjVkNTJiNWNhLi5lN2FlZjI5MDY4YWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2k5MTVfc3lzZnMuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3N5c2ZzLmMKQEAg LTU1NCw2ICs1NTQsMTEgQEAgdm9pZCBpOTE1X3NldHVwX3N5c2ZzKHN0cnVjdCBkcm1faTkxNV9w cml2YXRlICpkZXZfcHJpdikKIAlzdHJ1Y3QgZGV2aWNlICprZGV2ID0gZGV2X3ByaXYtPmRybS5w cmltYXJ5LT5rZGV2OwogCWludCByZXQ7CiAKKwlkZXZfcHJpdi0+Y2xpZW50cy5yb290ID0KKwkJ a29iamVjdF9jcmVhdGVfYW5kX2FkZCgiY2xpZW50cyIsICZrZGV2LT5rb2JqKTsKKwlpZiAoIWRl dl9wcml2LT5jbGllbnRzLnJvb3QpCisJCWRybV93YXJuKCZkZXZfcHJpdi0+ZHJtLCAiUGVyLWNs aWVudCBzeXNmcyBzZXR1cCBmYWlsZWRcbiIpOworCiAjaWZkZWYgQ09ORklHX1BNCiAJaWYgKEhB U19SQzYoZGV2X3ByaXYpKSB7CiAJCXJldCA9IHN5c2ZzX21lcmdlX2dyb3VwKCZrZGV2LT5rb2Jq LApAQCAtNjIxLDQgKzYyNiw3IEBAIHZvaWQgaTkxNV90ZWFyZG93bl9zeXNmcyhzdHJ1Y3QgZHJt X2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYpCiAJc3lzZnNfdW5tZXJnZV9ncm91cCgma2Rldi0+a29i aiwgJnJjNl9hdHRyX2dyb3VwKTsKIAlzeXNmc191bm1lcmdlX2dyb3VwKCZrZGV2LT5rb2JqLCAm cmM2cF9hdHRyX2dyb3VwKTsKICNlbmRpZgorCisJaWYgKGRldl9wcml2LT5jbGllbnRzLnJvb3Qp CisJCWtvYmplY3RfcHV0KGRldl9wcml2LT5jbGllbnRzLnJvb3QpOwogfQotLSAKMi4zMC4yCgpf X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZngg bWFpbGluZyBsaXN0CkludGVsLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0 cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZngK