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=-14.3 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,NICE_REPLY_A,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED, USER_AGENT_SANE_1 autolearn=unavailable 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 6A604C433DB for ; Wed, 20 Jan 2021 13:08:55 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 0BDAF23139 for ; Wed, 20 Jan 2021 13:08:55 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1732356AbhATNIV (ORCPT ); Wed, 20 Jan 2021 08:08:21 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53960 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1731437AbhATMXV (ORCPT ); Wed, 20 Jan 2021 07:23:21 -0500 Received: from mail-ed1-x535.google.com (mail-ed1-x535.google.com [IPv6:2a00:1450:4864:20::535]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 2A484C061575; Wed, 20 Jan 2021 04:22:37 -0800 (PST) Received: by mail-ed1-x535.google.com with SMTP id g24so25453421edw.9; Wed, 20 Jan 2021 04:22:37 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=reply-to:subject:to:cc:references:from:message-id:date:user-agent :mime-version:in-reply-to:content-transfer-encoding:content-language; bh=YVN4dveU+Kxh5RsV6Ry0fUuW9778LU4mvXed3iC1j7g=; b=CEzhFvb9fyCffEsXUZ/DGC/VxulMVboPoo+npEx6pORZK4lu6Kadml0/d15ptYWjsn QVHEgWY7qrqh/zbDWX2gDaoR9tzpzBmBCsu4/HuotBwkybQydO6fw1MltrGkCuhh5qSU 2NT8U+unjRfhGkedSreGR5Qc3nMA0nS9mYO4goyZf2+lgFF3RctP1T8t7yzExatCfmCW 3L/inbbbmJoqeIHh5F3Q+7x6iqcSfuJr+OsJ/3mA93g+HdV8w9XqP62IuqSpq8pY2AE6 CXfI+LcrhxgAAWULwTVa2NlqCMPtGKDCRENpAEr8BZgU9zfRzJUBWgBrn2TSgkP8OVWG Ey9w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:reply-to:subject:to:cc:references:from :message-id:date:user-agent:mime-version:in-reply-to :content-transfer-encoding:content-language; bh=YVN4dveU+Kxh5RsV6Ry0fUuW9778LU4mvXed3iC1j7g=; b=W+WrO/AyzPUtVi+G50u4zfYasVrIEywFLmqZ1LGNLG4wgvDSONRnuKV44qAdLFxD8d 0Cl6eVzxhd+TFrA8rz9X/SvFUvvg4T2Q5FX7gfJ7NE1dJf4nueZAmDm8jfrTGUVhDECp 3SEdi2tXsG4mGxVP/ZN8E5dBH5iIgg9JTufdtNMrFpqhShMxU/9Yc/nWf5OaisezOG3x ySVPqY4KLiRg4z6KLMuWk1qh3O3bip+B+LGJkFJWrKAN5recb6lh/O8+VXfbwdgjqkFD c+/Uyi0rE0lLfqL99pAxZWFFtbmttNC8Bgxng/VngBKlFLjVk7fMzELiy48XB/SeBkEd JpcQ== X-Gm-Message-State: AOAM530wcgvVhO1P45HeULn83wcGVNrVrtE6n1Pm2dxT9Y2/AkUVO943 6n7+TjNtKc2ToIj1K2aLYvA= X-Google-Smtp-Source: ABdhPJzPAQzRwxI45Uo6fSw5FEhHdI7+ZocD7dBZXk6qxNxBbNqx+7KICTuBUEYFx0vRUS7rY8pwAw== X-Received: by 2002:a50:d484:: with SMTP id s4mr7082577edi.13.1611145355689; Wed, 20 Jan 2021 04:22:35 -0800 (PST) Received: from ?IPv6:2a02:908:1252:fb60:be8a:bd56:1f94:86e7? ([2a02:908:1252:fb60:be8a:bd56:1f94:86e7]) by smtp.gmail.com with ESMTPSA id t19sm821498ejc.62.2021.01.20.04.22.34 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Wed, 20 Jan 2021 04:22:34 -0800 (PST) Reply-To: christian.koenig@amd.com Subject: Re: [Linaro-mm-sig] [PATCH v2] dmabuf: Add the capability to expose DMA-BUF stats in sysfs To: Hridya Valsaraju , Sumit Semwal , =?UTF-8?Q?Christian_K=c3=b6nig?= , linux-kernel@vger.kernel.org, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org Cc: john.stultz@linaro.org, gregkh@linuxfoundation.org, kernel-team@android.com, surenb@google.com, hyesoo.yu@samsung.com References: <20210119225723.388883-1-hridya@google.com> From: =?UTF-8?Q?Christian_K=c3=b6nig?= Message-ID: Date: Wed, 20 Jan 2021 13:22:33 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.10.0 MIME-Version: 1.0 In-Reply-To: <20210119225723.388883-1-hridya@google.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit Content-Language: en-US Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Am 19.01.21 um 23:57 schrieb Hridya Valsaraju: > This patch allows statistics to be enabled for each DMA-BUF in > sysfs by enabling the config CONFIG_DMABUF_SYSFS_STATS. > > The following stats will be exposed by the interface: > > /sys/kernel/dmabuf/buffers//exporter_name > /sys/kernel/dmabuf/buffers//size > /sys/kernel/dmabuf/buffers//attachments//device > /sys/kernel/dmabuf/buffers//attachments//map_counter > > The inode_number is unique for each DMA-BUF and was added earlier [1] > in order to allow userspace to track DMA-BUF usage across different > processes. > > Currently, this information is exposed in > /sys/kernel/debug/dma_buf/bufinfo. > However, since debugfs is considered unsafe to be mounted in production, > it is being duplicated in sysfs. > > This information will be used to derive DMA-BUF > per-exporter stats and per-device usage stats for Android Bug reports. > The corresponding userspace changes can be found at [2]. > Telemetry tools will also capture this information(along with other > memory metrics) periodically as well as on important events like a > foreground app kill (which might have been triggered by Low Memory > Killer). It will also contribute to provide a snapshot of the system > memory usage on other events such as OOM kills and Application Not > Responding events. > > A shell script that can be run on a classic Linux environment to read > out the DMA-BUF statistics can be found at [3](suggested by John > Stultz). > > The patch contains the following improvements over the previous version: > 1) Each attachment is represented by its own directory to allow creating > a symlink to the importing device and to also provide room for future > expansion. > 2) The number of distinct mappings of each attachment is exposed in a > separate file. > 3) The per-buffer statistics are now in /sys/kernel/dmabuf/buffers > inorder to make the interface expandable in future. > > All of the improvements above are based on suggestions/feedback from > Daniel Vetter and Christian König. > > [1]: https://lore.kernel.org/patchwork/patch/1088791/ > [2]: https://android-review.googlesource.com/q/topic:%22dmabuf-sysfs%22+(status:open%20OR%20status:merged) > [3]: https://android-review.googlesource.com/c/platform/system/memory/libmeminfo/+/1549734 > > Signed-off-by: Hridya Valsaraju > --- > Changes in v2: > -Move statistics to /sys/kernel/dmabuf/buffers in oder to allow addition > of other DMA-BUF-related sysfs stats in future. Based on feedback from > Daniel Vetter. > -Each attachment has its own directory to represent attaching devices as > symlinks and to introduce map_count as a separate file. Based on > feedback from Daniel Vetter and Christian König. Thank you both! > -Commit messages updated to point to userspace code in AOSP that will > read the DMA-BUF sysfs stats. > > .../ABI/testing/sysfs-kernel-dmabuf-buffers | 52 ++++ > drivers/dma-buf/Kconfig | 11 + > drivers/dma-buf/Makefile | 1 + > drivers/dma-buf/dma-buf-sysfs-stats.c | 283 ++++++++++++++++++ > drivers/dma-buf/dma-buf-sysfs-stats.h | 62 ++++ > drivers/dma-buf/dma-buf.c | 37 +++ > include/linux/dma-buf.h | 20 ++ > 7 files changed, 466 insertions(+) > create mode 100644 Documentation/ABI/testing/sysfs-kernel-dmabuf-buffers > create mode 100644 drivers/dma-buf/dma-buf-sysfs-stats.c > create mode 100644 drivers/dma-buf/dma-buf-sysfs-stats.h > > diff --git a/Documentation/ABI/testing/sysfs-kernel-dmabuf-buffers b/Documentation/ABI/testing/sysfs-kernel-dmabuf-buffers > new file mode 100644 > index 000000000000..6f7c65209f07 > --- /dev/null > +++ b/Documentation/ABI/testing/sysfs-kernel-dmabuf-buffers > @@ -0,0 +1,52 @@ > +What: /sys/kernel/dmabuf/buffers > +Date: January 2021 > +KernelVersion: v5.12 > +Contact: Hridya Valsaraju > +Description: The /sys/kernel/dmabuf/buffers directory contains a > + snapshot of the internal state of every DMA-BUF. > + /sys/kernel/dmabuf/buffers/ will contain the > + statistics for the DMA-BUF with the unique inode number > + > +Users: kernel memory tuning/debugging tools > + > +What: /sys/kernel/dmabuf/buffers//exporter_name > +Date: January 2021 > +KernelVersion: v5.12 > +Contact: Hridya Valsaraju > +Description: This file is read-only and contains the name of the exporter of > + the DMA-BUF. > + > +What: /sys/kernel/dmabuf/buffers//size > +Date: January 2021 > +KernelVersion: v5.12 > +Contact: Hridya Valsaraju > +Description: This file is read-only and specifies the size of the DMA-BUF in > + bytes. > + > +What: /sys/kernel/dmabuf/buffers//attachments > +Date: January 2021 > +KernelVersion: v5.12 > +Contact: Hridya Valsaraju > +Description: This directory will contain subdirectories representing every > + attachment of the DMA-BUF. > + > +What: /sys/kernel/dmabuf/buffers//attachments/ > +Date: January 2021 > +KernelVersion: v5.12 > +Contact: Hridya Valsaraju > +Description: This directory will contain information on the attaching device > + and the number of current distinct device mappings. > + > +What: /sys/kernel/dmabuf/buffers//attachments//device > +Date: January 2021 > +KernelVersion: v5.12 > +Contact: Hridya Valsaraju > +Description: This file is read-only and is a symlink to the attaching devices's > + sysfs entry. > + > +What: /sys/kernel/dmabuf/buffers//attachments//map_counter > +Date: January 2021 > +KernelVersion: v5.12 > +Contact: Hridya Valsaraju > +Description: This file is read-only and contains a map_counter indicating the > + number of distinct device mappings of the attachment. > diff --git a/drivers/dma-buf/Kconfig b/drivers/dma-buf/Kconfig > index 4f8224a6ac95..27e6a2dafeaa 100644 > --- a/drivers/dma-buf/Kconfig > +++ b/drivers/dma-buf/Kconfig > @@ -64,6 +64,17 @@ menuconfig DMABUF_HEAPS > allows userspace to allocate dma-bufs that can be shared > between drivers. > > +menuconfig DMABUF_SYSFS_STATS > + bool "DMA-BUF sysfs statistics" > + select DMA_SHARED_BUFFER > + help > + Choose this option to enable DMA-BUF sysfs statistics > + in location /sys/kernel/dmabuf/buffers. > + > + /sys/kernel/dmabuf/buffers/ will contain > + statistics for the DMA-BUF with the unique inode number > + . > + > source "drivers/dma-buf/heaps/Kconfig" > > endmenu > diff --git a/drivers/dma-buf/Makefile b/drivers/dma-buf/Makefile > index 995e05f609ff..40d81f23cacf 100644 > --- a/drivers/dma-buf/Makefile > +++ b/drivers/dma-buf/Makefile > @@ -6,6 +6,7 @@ obj-$(CONFIG_DMABUF_HEAPS) += heaps/ > obj-$(CONFIG_SYNC_FILE) += sync_file.o > obj-$(CONFIG_SW_SYNC) += sw_sync.o sync_debug.o > obj-$(CONFIG_UDMABUF) += udmabuf.o > +obj-$(CONFIG_DMABUF_SYSFS_STATS) += dma-buf-sysfs-stats.o > > dmabuf_selftests-y := \ > selftest.o \ > diff --git a/drivers/dma-buf/dma-buf-sysfs-stats.c b/drivers/dma-buf/dma-buf-sysfs-stats.c > new file mode 100644 > index 000000000000..61f85c3d16a5 > --- /dev/null > +++ b/drivers/dma-buf/dma-buf-sysfs-stats.c > @@ -0,0 +1,283 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * DMA-BUF sysfs statistics. > + * > + * Copyright (C) 2021 Google LLC. > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > + > +#define to_dma_buf_entry_from_kobj(x) container_of(x, struct dma_buf_sysfs_entry, kobj) > + > +struct dma_buf_stats_attribute { > + struct attribute attr; > + ssize_t (*show)(struct dma_buf *dmabuf, > + struct dma_buf_stats_attribute *attr, char *buf); > +}; > +#define to_dma_buf_stats_attr(x) container_of(x, struct dma_buf_stats_attribute, attr) > + > +static ssize_t dma_buf_stats_attribute_show(struct kobject *kobj, > + struct attribute *attr, > + char *buf) > +{ > + struct dma_buf_stats_attribute *attribute; > + struct dma_buf_sysfs_entry *sysfs_entry; > + struct dma_buf *dmabuf; > + > + attribute = to_dma_buf_stats_attr(attr); > + sysfs_entry = to_dma_buf_entry_from_kobj(kobj); > + dmabuf = sysfs_entry->dmabuf; > + > + if (!dmabuf || !attribute->show) > + return -EIO; > + > + return attribute->show(dmabuf, attribute, buf); > +} > + > +static const struct sysfs_ops dma_buf_stats_sysfs_ops = { > + .show = dma_buf_stats_attribute_show, > +}; > + > +static ssize_t exporter_name_show(struct dma_buf *dmabuf, > + struct dma_buf_stats_attribute *attr, > + char *buf) > +{ > + return sysfs_emit(buf, "%s\n", dmabuf->exp_name); > +} > + > +static ssize_t size_show(struct dma_buf *dmabuf, > + struct dma_buf_stats_attribute *attr, > + char *buf) > +{ > + return sysfs_emit(buf, "%zu\n", dmabuf->size); > +} > + > +static struct dma_buf_stats_attribute exporter_name_attribute = > + __ATTR_RO(exporter_name); > +static struct dma_buf_stats_attribute size_attribute = __ATTR_RO(size); > + > +static struct attribute *dma_buf_stats_default_attrs[] = { > + &exporter_name_attribute.attr, > + &size_attribute.attr, > + NULL, > +}; > +ATTRIBUTE_GROUPS(dma_buf_stats_default); > + > +static void dma_buf_sysfs_release(struct kobject *kobj) > +{ > + struct dma_buf_sysfs_entry *sysfs_entry; > + > + sysfs_entry = to_dma_buf_entry_from_kobj(kobj); > + kfree(sysfs_entry); > +} > + > +static struct kobj_type dma_buf_ktype = { > + .sysfs_ops = &dma_buf_stats_sysfs_ops, > + .release = dma_buf_sysfs_release, > + .default_groups = dma_buf_stats_default_groups, > +}; > + > +#define to_dma_buf_attach_entry_from_kobj(x) container_of(x, struct dma_buf_attach_sysfs_entry, kobj) > + > +struct dma_buf_attach_stats_attribute { > + struct attribute attr; > + ssize_t (*show)(struct dma_buf_attach_sysfs_entry *sysfs_entry, > + struct dma_buf_attach_stats_attribute *attr, char *buf); > +}; > +#define to_dma_buf_attach_stats_attr(x) container_of(x, struct dma_buf_attach_stats_attribute, attr) > + > +static ssize_t dma_buf_attach_stats_attribute_show(struct kobject *kobj, > + struct attribute *attr, > + char *buf) > +{ > + struct dma_buf_attach_stats_attribute *attribute; > + struct dma_buf_attach_sysfs_entry *sysfs_entry; > + > + attribute = to_dma_buf_attach_stats_attr(attr); > + sysfs_entry = to_dma_buf_attach_entry_from_kobj(kobj); > + > + if (!attribute->show) > + return -EIO; > + > + return attribute->show(sysfs_entry, attribute, buf); > +} > + > +static const struct sysfs_ops dma_buf_attach_stats_sysfs_ops = { > + .show = dma_buf_attach_stats_attribute_show, > +}; > + > +static ssize_t map_counter_show(struct dma_buf_attach_sysfs_entry *sysfs_entry, > + struct dma_buf_attach_stats_attribute *attr, > + char *buf) > +{ > + return sysfs_emit(buf, "%u\n", sysfs_entry->map_counter); > +} > + > +static struct dma_buf_attach_stats_attribute map_counter_attribute = > + __ATTR_RO(map_counter); > + > +static struct attribute *dma_buf_attach_stats_default_attrs[] = { > + &map_counter_attribute.attr, > + NULL, > +}; > +ATTRIBUTE_GROUPS(dma_buf_attach_stats_default); > + > +static void dma_buf_attach_sysfs_release(struct kobject *kobj) > +{ > + struct dma_buf_attach_sysfs_entry *sysfs_entry; > + > + sysfs_entry = to_dma_buf_attach_entry_from_kobj(kobj); > + kfree(sysfs_entry); > +} > + > +static struct kobj_type dma_buf_attach_ktype = { > + .sysfs_ops = &dma_buf_attach_stats_sysfs_ops, > + .release = dma_buf_attach_sysfs_release, > + .default_groups = dma_buf_attach_stats_default_groups, > +}; > + > +void dma_buf_attach_stats_teardown(struct dma_buf_attachment *attach) > +{ > + struct dma_buf_attach_sysfs_entry *sysfs_entry; > + > + sysfs_entry = attach->sysfs_entry; > + if (!sysfs_entry) > + return; > + > + sysfs_delete_link(&sysfs_entry->kobj, &attach->dev->kobj, "device"); > + > + kobject_del(&sysfs_entry->kobj); > + kobject_put(&sysfs_entry->kobj); > +} > + > +int dma_buf_attach_stats_setup(struct dma_buf_attachment *attach, > + unsigned int uid) > +{ > + struct dma_buf_attach_sysfs_entry *sysfs_entry; > + int ret; > + struct dma_buf *dmabuf; > + > + if (!attach) > + return -EINVAL; > + > + dmabuf = attach->dmabuf; > + > + sysfs_entry = kzalloc(sizeof(struct dma_buf_attach_sysfs_entry), > + GFP_KERNEL); > + if (!sysfs_entry) > + return -ENOMEM; > + > + sysfs_entry->kobj.kset = dmabuf->sysfs_entry->attach_stats_kset; > + > + attach->sysfs_entry = sysfs_entry; > + > + ret = kobject_init_and_add(&sysfs_entry->kobj, &dma_buf_attach_ktype, > + NULL, "%u", uid); > + if (ret) > + goto kobj_err; > + > + ret = sysfs_create_link(&sysfs_entry->kobj, &attach->dev->kobj, > + "device"); > + if (ret) > + goto link_err; > + > + return 0; > + > +link_err: > + kobject_del(&sysfs_entry->kobj); > +kobj_err: > + kobject_put(&sysfs_entry->kobj); > + attach->sysfs_entry = NULL; > + > + return ret; > +} > +void dma_buf_stats_teardown(struct dma_buf *dmabuf) > +{ > + struct dma_buf_sysfs_entry *sysfs_entry; > + > + sysfs_entry = dmabuf->sysfs_entry; > + if (!sysfs_entry) > + return; > + > + kset_unregister(sysfs_entry->attach_stats_kset); > + kobject_del(&sysfs_entry->kobj); > + kobject_put(&sysfs_entry->kobj); > +} > + > +static struct kset *dma_buf_stats_kset; > +static struct kset *dma_buf_per_buffer_stats_kset; > +int dma_buf_init_sysfs_statistics(void) > +{ > + dma_buf_stats_kset = kset_create_and_add("dmabuf", NULL, kernel_kobj); > + if (!dma_buf_stats_kset) > + return -ENOMEM; > + > + dma_buf_per_buffer_stats_kset = kset_create_and_add("buffers", NULL, > + &dma_buf_stats_kset->kobj); > + if (!dma_buf_per_buffer_stats_kset) { > + kset_unregister(dma_buf_stats_kset); > + return -ENOMEM; > + } > + > + return 0; > +} > + > +void dma_buf_uninit_sysfs_statistics(void) > +{ > + kset_unregister(dma_buf_per_buffer_stats_kset); > + kset_unregister(dma_buf_stats_kset); > +} > + > +int dma_buf_stats_setup(struct dma_buf *dmabuf) > +{ > + struct dma_buf_sysfs_entry *sysfs_entry; > + int ret; > + struct kset *attach_stats_kset; > + > + if (!dmabuf || !dmabuf->file) > + return -EINVAL; > + > + if (!dmabuf->exp_name) { > + pr_err("exporter name must not be empty if stats needed\n"); > + return -EINVAL; > + } > + > + sysfs_entry = kzalloc(sizeof(struct dma_buf_sysfs_entry), GFP_KERNEL); > + if (!sysfs_entry) > + return -ENOMEM; > + > + sysfs_entry->kobj.kset = dma_buf_per_buffer_stats_kset; > + sysfs_entry->dmabuf = dmabuf; > + > + dmabuf->sysfs_entry = sysfs_entry; > + > + /* create the directory for buffer stats */ > + ret = kobject_init_and_add(&sysfs_entry->kobj, &dma_buf_ktype, NULL, > + "%lu", file_inode(dmabuf->file)->i_ino); > + if (ret) > + goto err_sysfs_dmabuf; > + > + /* create the directory for attachment stats */ > + attach_stats_kset = kset_create_and_add("attachments", NULL, > + &sysfs_entry->kobj); > + if (!attach_stats_kset) { > + ret = -ENOMEM; > + goto err_sysfs_attach; > + } > + > + sysfs_entry->attach_stats_kset = attach_stats_kset; > + > + return 0; > + > +err_sysfs_attach: > + kobject_del(&sysfs_entry->kobj); > +err_sysfs_dmabuf: > + kobject_put(&sysfs_entry->kobj); > + dmabuf->sysfs_entry = NULL; > + return ret; > +} > diff --git a/drivers/dma-buf/dma-buf-sysfs-stats.h b/drivers/dma-buf/dma-buf-sysfs-stats.h > new file mode 100644 > index 000000000000..5f4703249117 > --- /dev/null > +++ b/drivers/dma-buf/dma-buf-sysfs-stats.h > @@ -0,0 +1,62 @@ > +/* SPDX-License-Identifier: GPL-2.0-only */ > +/* > + * DMA-BUF sysfs statistics. > + * > + * Copyright (C) 2021 Google LLC. > + */ > + > +#ifndef _DMA_BUF_SYSFS_STATS_H > +#define _DMA_BUF_SYSFS_STATS_H > + > +#ifdef CONFIG_DMABUF_SYSFS_STATS > + > +int dma_buf_init_sysfs_statistics(void); > +void dma_buf_uninit_sysfs_statistics(void); > + > +int dma_buf_stats_setup(struct dma_buf *dmabuf); > +int dma_buf_attach_stats_setup(struct dma_buf_attachment *attach, > + unsigned int uid); > +static inline void dma_buf_update_attachment_map_count(struct dma_buf_attachment *attach, > + int delta) > +{ > + struct dma_buf_attach_sysfs_entry *entry = attach->sysfs_entry; > + > + entry->map_counter += delta; > +} > +void dma_buf_stats_teardown(struct dma_buf *dmabuf); > +void dma_buf_attach_stats_teardown(struct dma_buf_attachment *attach); > +static inline unsigned int dma_buf_update_attach_uid(struct dma_buf *dmabuf) > +{ > + struct dma_buf_sysfs_entry *entry = dmabuf->sysfs_entry; > + > + return entry->attachment_uid++; > +} > +#else > + > +static inline int dma_buf_init_sysfs_statistics(void) > +{ > + return 0; > +} > + > +static inline void dma_buf_uninit_sysfs_statistics(void) {} > + > +static inline int dma_buf_stats_setup(struct dma_buf *dmabuf) > +{ > + return 0; > +} > +static inline int dma_buf_attach_stats_setup(struct dma_buf_attachment *attach, > + unsigned int uid) > +{ > + return 0; > +} > + > +static inline void dma_buf_stats_teardown(struct dma_buf *dmabuf) {} > +static inline void dma_buf_attach_stats_teardown(struct dma_buf_attachment *attach) {} > +static inline void dma_buf_update_attachment_map_count(struct dma_buf_attachment *attach, > + int delta) {} > +static inline unsigned int dma_buf_update_attach_uid(struct dma_buf *dmabuf) > +{ > + return 0; > +} > +#endif > +#endif // _DMA_BUF_SYSFS_STATS_H > diff --git a/drivers/dma-buf/dma-buf.c b/drivers/dma-buf/dma-buf.c > index 9ad6397aaa97..29f9ea18eb47 100644 > --- a/drivers/dma-buf/dma-buf.c > +++ b/drivers/dma-buf/dma-buf.c > @@ -29,6 +29,8 @@ > #include > #include > > +#include "dma-buf-sysfs-stats.h" > + > static inline int is_dma_buf_file(struct file *); > > struct dma_buf_list { > @@ -79,6 +81,7 @@ static void dma_buf_release(struct dentry *dentry) > if (dmabuf->resv == (struct dma_resv *)&dmabuf[1]) > dma_resv_fini(dmabuf->resv); > > + dma_buf_stats_teardown(dmabuf); > module_put(dmabuf->owner); > kfree(dmabuf->name); > kfree(dmabuf); > @@ -579,6 +582,10 @@ struct dma_buf *dma_buf_export(const struct dma_buf_export_info *exp_info) > file->f_mode |= FMODE_LSEEK; > dmabuf->file = file; > > + ret = dma_buf_stats_setup(dmabuf); > + if (ret) > + goto err_sysfs; > + > mutex_init(&dmabuf->lock); > INIT_LIST_HEAD(&dmabuf->attachments); > > @@ -588,6 +595,14 @@ struct dma_buf *dma_buf_export(const struct dma_buf_export_info *exp_info) > > return dmabuf; > > +err_sysfs: > + /* > + * Set file->f_path.dentry->d_fsdata to NULL so that when > + * dma_buf_release() gets invoked by dentry_ops, it exits > + * early before calling the release() dma_buf op. > + */ > + file->f_path.dentry->d_fsdata = NULL; > + fput(file); > err_dmabuf: > kfree(dmabuf); > err_module: > @@ -692,6 +707,7 @@ dma_buf_dynamic_attach(struct dma_buf *dmabuf, struct device *dev, > { > struct dma_buf_attachment *attach; > int ret; > + unsigned int attach_uid; > > if (WARN_ON(!dmabuf || !dev)) > return ERR_PTR(-EINVAL); > @@ -717,8 +733,13 @@ dma_buf_dynamic_attach(struct dma_buf *dmabuf, struct device *dev, > } > dma_resv_lock(dmabuf->resv, NULL); > list_add(&attach->node, &dmabuf->attachments); > + attach_uid = dma_buf_update_attach_uid(dmabuf); > dma_resv_unlock(dmabuf->resv); > > + ret = dma_buf_attach_stats_setup(attach, attach_uid); > + if (ret) > + goto err_sysfs; > + > /* When either the importer or the exporter can't handle dynamic > * mappings we cache the mapping here to avoid issues with the > * reservation object lock. > @@ -745,6 +766,7 @@ dma_buf_dynamic_attach(struct dma_buf *dmabuf, struct device *dev, > dma_resv_unlock(attach->dmabuf->resv); > attach->sgt = sgt; > attach->dir = DMA_BIDIRECTIONAL; > + dma_buf_update_attachment_map_count(attach, 1 /* delta */); > } > > return attach; > @@ -761,6 +783,7 @@ dma_buf_dynamic_attach(struct dma_buf *dmabuf, struct device *dev, > if (dma_buf_is_dynamic(attach->dmabuf)) > dma_resv_unlock(attach->dmabuf->resv); > > +err_sysfs: > dma_buf_detach(dmabuf, attach); > return ERR_PTR(ret); > } > @@ -799,6 +822,7 @@ void dma_buf_detach(struct dma_buf *dmabuf, struct dma_buf_attachment *attach) > dma_resv_lock(attach->dmabuf->resv, NULL); > > dmabuf->ops->unmap_dma_buf(attach, attach->sgt, attach->dir); > + dma_buf_update_attachment_map_count(attach, -1 /* delta */); > > if (dma_buf_is_dynamic(attach->dmabuf)) { > dma_buf_unpin(attach); > @@ -812,6 +836,7 @@ void dma_buf_detach(struct dma_buf *dmabuf, struct dma_buf_attachment *attach) > if (dmabuf->ops->detach) > dmabuf->ops->detach(dmabuf, attach); > > + dma_buf_attach_stats_teardown(attach); > kfree(attach); > } > EXPORT_SYMBOL_GPL(dma_buf_detach); > @@ -938,6 +963,9 @@ struct sg_table *dma_buf_map_attachment(struct dma_buf_attachment *attach, > } > #endif /* CONFIG_DMA_API_DEBUG */ > > + if (!IS_ERR(sg_table)) > + dma_buf_update_attachment_map_count(attach, 1 /* delta */); > + > return sg_table; > } > EXPORT_SYMBOL_GPL(dma_buf_map_attachment); > @@ -975,6 +1003,8 @@ void dma_buf_unmap_attachment(struct dma_buf_attachment *attach, > if (dma_buf_is_dynamic(attach->dmabuf) && > !IS_ENABLED(CONFIG_DMABUF_MOVE_NOTIFY)) > dma_buf_unpin(attach); > + > + dma_buf_update_attachment_map_count(attach, -1 /* delta */); > } > EXPORT_SYMBOL_GPL(dma_buf_unmap_attachment); > > @@ -1412,6 +1442,12 @@ static inline void dma_buf_uninit_debugfs(void) > > static int __init dma_buf_init(void) > { > + int ret; > + > + ret = dma_buf_init_sysfs_statistics(); > + if (ret) > + return ret; > + > dma_buf_mnt = kern_mount(&dma_buf_fs_type); > if (IS_ERR(dma_buf_mnt)) > return PTR_ERR(dma_buf_mnt); > @@ -1427,5 +1463,6 @@ static void __exit dma_buf_deinit(void) > { > dma_buf_uninit_debugfs(); > kern_unmount(dma_buf_mnt); > + dma_buf_uninit_sysfs_statistics(); > } > __exitcall(dma_buf_deinit); > diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h > index cf72699cb2bc..4ae5cc38a4a7 100644 > --- a/include/linux/dma-buf.h > +++ b/include/linux/dma-buf.h > @@ -294,6 +294,9 @@ struct dma_buf_ops { > * @poll: for userspace poll support > * @cb_excl: for userspace poll support > * @cb_shared: for userspace poll support > + * @sysfs_entry: for exposing information about this buffer in sysfs. > + * The attachment_uid member of @sysfs_entry is protected by dma_resv lock > + * and is incremented on each attach. > * > * This represents a shared buffer, created by calling dma_buf_export(). The > * userspace representation is a normal file descriptor, which can be created by > @@ -329,6 +332,15 @@ struct dma_buf { > > __poll_t active; > } cb_excl, cb_shared; > +#ifdef CONFIG_DMABUF_SYSFS_STATS > + /* for sysfs stats */ > + struct dma_buf_sysfs_entry { > + struct kobject kobj; > + struct dma_buf *dmabuf; > + unsigned int attachment_uid; > + struct kset *attach_stats_kset; > + } *sysfs_entry; > +#endif Why not directly embed that? > }; > > /** > @@ -378,6 +390,7 @@ struct dma_buf_attach_ops { > * @importer_ops: importer operations for this attachment, if provided > * dma_buf_map/unmap_attachment() must be called with the dma_resv lock held. > * @importer_priv: importer specific attachment data. > + * @sysfs_entry: For exposing information about this attachment in sysfs. > * > * This structure holds the attachment information between the dma_buf buffer > * and its user device(s). The list contains one attachment struct per device > @@ -398,6 +411,13 @@ struct dma_buf_attachment { > const struct dma_buf_attach_ops *importer_ops; > void *importer_priv; > void *priv; > +#ifdef CONFIG_DMABUF_SYSFS_STATS > + /* for sysfs stats */ > + struct dma_buf_attach_sysfs_entry { > + struct kobject kobj; > + unsigned int map_counter; > + } *sysfs_entry; > +#endif Same question here. Apart from that the general approach looks solid to me now. But somebody with more sysfs background should check if everything there is the right thing to do. Regards, Christian. > }; > > /** 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=-12.1 required=3.0 tests=BAYES_00, DKIM_ADSP_CUSTOM_MED,DKIM_INVALID,DKIM_SIGNED,FREEMAIL_FORGED_FROMDOMAIN, FREEMAIL_FROM,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,NICE_REPLY_A,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,USER_AGENT_SANE_1 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 BD2C8C433DB for ; Wed, 20 Jan 2021 12:22:42 +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 735FD221FB for ; Wed, 20 Jan 2021 12:22:42 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 735FD221FB Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=gmail.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 34B866E898; Wed, 20 Jan 2021 12:22:39 +0000 (UTC) Received: from mail-ed1-x534.google.com (mail-ed1-x534.google.com [IPv6:2a00:1450:4864:20::534]) by gabe.freedesktop.org (Postfix) with ESMTPS id 42C0C6E896 for ; Wed, 20 Jan 2021 12:22:37 +0000 (UTC) Received: by mail-ed1-x534.google.com with SMTP id h16so25500515edt.7 for ; Wed, 20 Jan 2021 04:22:37 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=reply-to:subject:to:cc:references:from:message-id:date:user-agent :mime-version:in-reply-to:content-transfer-encoding:content-language; bh=YVN4dveU+Kxh5RsV6Ry0fUuW9778LU4mvXed3iC1j7g=; b=CEzhFvb9fyCffEsXUZ/DGC/VxulMVboPoo+npEx6pORZK4lu6Kadml0/d15ptYWjsn QVHEgWY7qrqh/zbDWX2gDaoR9tzpzBmBCsu4/HuotBwkybQydO6fw1MltrGkCuhh5qSU 2NT8U+unjRfhGkedSreGR5Qc3nMA0nS9mYO4goyZf2+lgFF3RctP1T8t7yzExatCfmCW 3L/inbbbmJoqeIHh5F3Q+7x6iqcSfuJr+OsJ/3mA93g+HdV8w9XqP62IuqSpq8pY2AE6 CXfI+LcrhxgAAWULwTVa2NlqCMPtGKDCRENpAEr8BZgU9zfRzJUBWgBrn2TSgkP8OVWG Ey9w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:reply-to:subject:to:cc:references:from :message-id:date:user-agent:mime-version:in-reply-to :content-transfer-encoding:content-language; bh=YVN4dveU+Kxh5RsV6Ry0fUuW9778LU4mvXed3iC1j7g=; b=V8/sEUpG2SwLUGHa2l6l8HtvRwn7SGDyvOxBB/MgdaiffAM1P9k0exEzeIRoaE2Vix Nzn4y/pscfD2BvWnw9/7vijDtFHTujxPlIMhcx0zGbuCNsBlhx8jGaKjQLEe5T/zAvFn 5mwJdiQI/OeGHjWPGIw7RDOwIgJKs8xNM9Wu5tJeXyLZ5YfRTF5An+qjOuwfzouYD3pl ZhMBsrthZyV6qAtSWHU1cfpM+xUqJB0/RRiU77LN4kfR3dtF16Qd5giz3p0sCw05syP3 5Q+e1bW6u1zsToPgbqT91k4lb+9eKkkutbfXkjgKuNvJ+aCmk9KMW4hDT0wec463LStO W3Sw== X-Gm-Message-State: AOAM533/gHUnNJGl0/BJYyza3MbHezIiceut/LQ/RTI434AKqbeE70FB f8WJA/Kv/2TTQFbrWGEP4yg= X-Google-Smtp-Source: ABdhPJzPAQzRwxI45Uo6fSw5FEhHdI7+ZocD7dBZXk6qxNxBbNqx+7KICTuBUEYFx0vRUS7rY8pwAw== X-Received: by 2002:a50:d484:: with SMTP id s4mr7082577edi.13.1611145355689; Wed, 20 Jan 2021 04:22:35 -0800 (PST) Received: from ?IPv6:2a02:908:1252:fb60:be8a:bd56:1f94:86e7? ([2a02:908:1252:fb60:be8a:bd56:1f94:86e7]) by smtp.gmail.com with ESMTPSA id t19sm821498ejc.62.2021.01.20.04.22.34 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Wed, 20 Jan 2021 04:22:34 -0800 (PST) Subject: Re: [Linaro-mm-sig] [PATCH v2] dmabuf: Add the capability to expose DMA-BUF stats in sysfs To: Hridya Valsaraju , Sumit Semwal , =?UTF-8?Q?Christian_K=c3=b6nig?= , linux-kernel@vger.kernel.org, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org References: <20210119225723.388883-1-hridya@google.com> From: =?UTF-8?Q?Christian_K=c3=b6nig?= Message-ID: Date: Wed, 20 Jan 2021 13:22:33 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.10.0 MIME-Version: 1.0 In-Reply-To: <20210119225723.388883-1-hridya@google.com> Content-Language: en-US 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: , Reply-To: christian.koenig@amd.com Cc: surenb@google.com, gregkh@linuxfoundation.org, kernel-team@android.com, hyesoo.yu@samsung.com Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" QW0gMTkuMDEuMjEgdW0gMjM6NTcgc2NocmllYiBIcmlkeWEgVmFsc2FyYWp1Ogo+IFRoaXMgcGF0 Y2ggYWxsb3dzIHN0YXRpc3RpY3MgdG8gYmUgZW5hYmxlZCBmb3IgZWFjaCBETUEtQlVGIGluCj4g c3lzZnMgYnkgZW5hYmxpbmcgdGhlIGNvbmZpZyBDT05GSUdfRE1BQlVGX1NZU0ZTX1NUQVRTLgo+ Cj4gVGhlIGZvbGxvd2luZyBzdGF0cyB3aWxsIGJlIGV4cG9zZWQgYnkgdGhlIGludGVyZmFjZToK Pgo+IC9zeXMva2VybmVsL2RtYWJ1Zi9idWZmZXJzLzxpbm9kZV9udW1iZXI+L2V4cG9ydGVyX25h bWUKPiAvc3lzL2tlcm5lbC9kbWFidWYvYnVmZmVycy88aW5vZGVfbnVtYmVyPi9zaXplCj4gL3N5 cy9rZXJuZWwvZG1hYnVmL2J1ZmZlcnMvPGlub2RlX251bWJlcj4vYXR0YWNobWVudHMvPGF0dGFj aF91aWQ+L2RldmljZQo+IC9zeXMva2VybmVsL2RtYWJ1Zi9idWZmZXJzLzxpbm9kZV9udW1iZXI+ L2F0dGFjaG1lbnRzLzxhdHRhY2hfdWlkPi9tYXBfY291bnRlcgo+Cj4gVGhlIGlub2RlX251bWJl ciBpcyB1bmlxdWUgZm9yIGVhY2ggRE1BLUJVRiBhbmQgd2FzIGFkZGVkIGVhcmxpZXIgWzFdCj4g aW4gb3JkZXIgdG8gYWxsb3cgdXNlcnNwYWNlIHRvIHRyYWNrIERNQS1CVUYgdXNhZ2UgYWNyb3Nz IGRpZmZlcmVudAo+IHByb2Nlc3Nlcy4KPgo+IEN1cnJlbnRseSwgdGhpcyBpbmZvcm1hdGlvbiBp cyBleHBvc2VkIGluCj4gL3N5cy9rZXJuZWwvZGVidWcvZG1hX2J1Zi9idWZpbmZvLgo+IEhvd2V2 ZXIsIHNpbmNlIGRlYnVnZnMgaXMgY29uc2lkZXJlZCB1bnNhZmUgdG8gYmUgbW91bnRlZCBpbiBw cm9kdWN0aW9uLAo+IGl0IGlzIGJlaW5nIGR1cGxpY2F0ZWQgaW4gc3lzZnMuCj4KPiBUaGlzIGlu Zm9ybWF0aW9uIHdpbGwgYmUgdXNlZCB0byBkZXJpdmUgRE1BLUJVRgo+IHBlci1leHBvcnRlciBz dGF0cyBhbmQgcGVyLWRldmljZSB1c2FnZSBzdGF0cyBmb3IgQW5kcm9pZCBCdWcgcmVwb3J0cy4K PiBUaGUgY29ycmVzcG9uZGluZyB1c2Vyc3BhY2UgY2hhbmdlcyBjYW4gYmUgZm91bmQgYXQgWzJd Lgo+IFRlbGVtZXRyeSB0b29scyB3aWxsIGFsc28gY2FwdHVyZSB0aGlzIGluZm9ybWF0aW9uKGFs b25nIHdpdGggb3RoZXIKPiBtZW1vcnkgbWV0cmljcykgcGVyaW9kaWNhbGx5IGFzIHdlbGwgYXMg b24gaW1wb3J0YW50IGV2ZW50cyBsaWtlIGEKPiBmb3JlZ3JvdW5kIGFwcCBraWxsICh3aGljaCBt aWdodCBoYXZlIGJlZW4gdHJpZ2dlcmVkIGJ5IExvdyBNZW1vcnkKPiBLaWxsZXIpLiBJdCB3aWxs IGFsc28gY29udHJpYnV0ZSB0byBwcm92aWRlIGEgc25hcHNob3Qgb2YgdGhlIHN5c3RlbQo+IG1l bW9yeSB1c2FnZSBvbiBvdGhlciBldmVudHMgc3VjaCBhcyBPT00ga2lsbHMgYW5kIEFwcGxpY2F0 aW9uIE5vdAo+IFJlc3BvbmRpbmcgZXZlbnRzLgo+Cj4gQSBzaGVsbCBzY3JpcHQgdGhhdCBjYW4g YmUgcnVuIG9uIGEgY2xhc3NpYyBMaW51eCBlbnZpcm9ubWVudCB0byByZWFkCj4gb3V0IHRoZSBE TUEtQlVGIHN0YXRpc3RpY3MgY2FuIGJlIGZvdW5kIGF0IFszXShzdWdnZXN0ZWQgYnkgSm9obgo+ IFN0dWx0eikuCj4KPiBUaGUgcGF0Y2ggY29udGFpbnMgdGhlIGZvbGxvd2luZyBpbXByb3ZlbWVu dHMgb3ZlciB0aGUgcHJldmlvdXMgdmVyc2lvbjoKPiAxKSBFYWNoIGF0dGFjaG1lbnQgaXMgcmVw cmVzZW50ZWQgYnkgaXRzIG93biBkaXJlY3RvcnkgdG8gYWxsb3cgY3JlYXRpbmcKPiBhIHN5bWxp bmsgdG8gdGhlIGltcG9ydGluZyBkZXZpY2UgYW5kIHRvIGFsc28gcHJvdmlkZSByb29tIGZvciBm dXR1cmUKPiBleHBhbnNpb24uCj4gMikgVGhlIG51bWJlciBvZiBkaXN0aW5jdCBtYXBwaW5ncyBv ZiBlYWNoIGF0dGFjaG1lbnQgaXMgZXhwb3NlZCBpbiBhCj4gc2VwYXJhdGUgZmlsZS4KPiAzKSBU aGUgcGVyLWJ1ZmZlciBzdGF0aXN0aWNzIGFyZSBub3cgaW4gL3N5cy9rZXJuZWwvZG1hYnVmL2J1 ZmZlcnMKPiBpbm9yZGVyIHRvIG1ha2UgdGhlIGludGVyZmFjZSBleHBhbmRhYmxlIGluIGZ1dHVy ZS4KPgo+IEFsbCBvZiB0aGUgaW1wcm92ZW1lbnRzIGFib3ZlIGFyZSBiYXNlZCBvbiBzdWdnZXN0 aW9ucy9mZWVkYmFjayBmcm9tCj4gRGFuaWVsIFZldHRlciBhbmQgQ2hyaXN0aWFuIEvDtm5pZy4K Pgo+IFsxXTogaHR0cHM6Ly9sb3JlLmtlcm5lbC5vcmcvcGF0Y2h3b3JrL3BhdGNoLzEwODg3OTEv Cj4gWzJdOiBodHRwczovL2FuZHJvaWQtcmV2aWV3Lmdvb2dsZXNvdXJjZS5jb20vcS90b3BpYzol MjJkbWFidWYtc3lzZnMlMjIrKHN0YXR1czpvcGVuJTIwT1IlMjBzdGF0dXM6bWVyZ2VkKQo+IFsz XTogaHR0cHM6Ly9hbmRyb2lkLXJldmlldy5nb29nbGVzb3VyY2UuY29tL2MvcGxhdGZvcm0vc3lz dGVtL21lbW9yeS9saWJtZW1pbmZvLysvMTU0OTczNAo+Cj4gU2lnbmVkLW9mZi1ieTogSHJpZHlh IFZhbHNhcmFqdSA8aHJpZHlhQGdvb2dsZS5jb20+Cj4gLS0tCj4gQ2hhbmdlcyBpbiB2MjoKPiAt TW92ZSBzdGF0aXN0aWNzIHRvIC9zeXMva2VybmVsL2RtYWJ1Zi9idWZmZXJzIGluIG9kZXIgdG8g YWxsb3cgYWRkaXRpb24KPiBvZiBvdGhlciBETUEtQlVGLXJlbGF0ZWQgc3lzZnMgc3RhdHMgaW4g ZnV0dXJlLiBCYXNlZCBvbiBmZWVkYmFjayBmcm9tCj4gRGFuaWVsIFZldHRlci4KPiAtRWFjaCBh dHRhY2htZW50IGhhcyBpdHMgb3duIGRpcmVjdG9yeSB0byByZXByZXNlbnQgYXR0YWNoaW5nIGRl dmljZXMgYXMKPiBzeW1saW5rcyBhbmQgdG8gaW50cm9kdWNlIG1hcF9jb3VudCBhcyBhIHNlcGFy YXRlIGZpbGUuIEJhc2VkIG9uCj4gZmVlZGJhY2sgZnJvbSBEYW5pZWwgVmV0dGVyIGFuZCBDaHJp c3RpYW4gS8O2bmlnLiBUaGFuayB5b3UgYm90aCEKPiAtQ29tbWl0IG1lc3NhZ2VzIHVwZGF0ZWQg dG8gcG9pbnQgdG8gdXNlcnNwYWNlIGNvZGUgaW4gQU9TUCB0aGF0IHdpbGwKPiByZWFkIHRoZSBE TUEtQlVGIHN5c2ZzIHN0YXRzLgo+Cj4gICAuLi4vQUJJL3Rlc3Rpbmcvc3lzZnMta2VybmVsLWRt YWJ1Zi1idWZmZXJzICAgfCAgNTIgKysrKwo+ICAgZHJpdmVycy9kbWEtYnVmL0tjb25maWcgICAg ICAgICAgICAgICAgICAgICAgIHwgIDExICsKPiAgIGRyaXZlcnMvZG1hLWJ1Zi9NYWtlZmlsZSAg ICAgICAgICAgICAgICAgICAgICB8ICAgMSArCj4gICBkcml2ZXJzL2RtYS1idWYvZG1hLWJ1Zi1z eXNmcy1zdGF0cy5jICAgICAgICAgfCAyODMgKysrKysrKysrKysrKysrKysrCj4gICBkcml2ZXJz L2RtYS1idWYvZG1hLWJ1Zi1zeXNmcy1zdGF0cy5oICAgICAgICAgfCAgNjIgKysrKwo+ICAgZHJp dmVycy9kbWEtYnVmL2RtYS1idWYuYyAgICAgICAgICAgICAgICAgICAgIHwgIDM3ICsrKwo+ICAg aW5jbHVkZS9saW51eC9kbWEtYnVmLmggICAgICAgICAgICAgICAgICAgICAgIHwgIDIwICsrCj4g ICA3IGZpbGVzIGNoYW5nZWQsIDQ2NiBpbnNlcnRpb25zKCspCj4gICBjcmVhdGUgbW9kZSAxMDA2 NDQgRG9jdW1lbnRhdGlvbi9BQkkvdGVzdGluZy9zeXNmcy1rZXJuZWwtZG1hYnVmLWJ1ZmZlcnMK PiAgIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2RtYS1idWYvZG1hLWJ1Zi1zeXNmcy1zdGF0 cy5jCj4gICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9kbWEtYnVmL2RtYS1idWYtc3lzZnMt c3RhdHMuaAo+Cj4gZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vQUJJL3Rlc3Rpbmcvc3lzZnMt a2VybmVsLWRtYWJ1Zi1idWZmZXJzIGIvRG9jdW1lbnRhdGlvbi9BQkkvdGVzdGluZy9zeXNmcy1r ZXJuZWwtZG1hYnVmLWJ1ZmZlcnMKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAw MDAwMDAwMC4uNmY3YzY1MjA5ZjA3Cj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL0RvY3VtZW50YXRp b24vQUJJL3Rlc3Rpbmcvc3lzZnMta2VybmVsLWRtYWJ1Zi1idWZmZXJzCj4gQEAgLTAsMCArMSw1 MiBAQAo+ICtXaGF0OgkJL3N5cy9rZXJuZWwvZG1hYnVmL2J1ZmZlcnMKPiArRGF0ZToJCUphbnVh cnkgMjAyMQo+ICtLZXJuZWxWZXJzaW9uOgl2NS4xMgo+ICtDb250YWN0OglIcmlkeWEgVmFsc2Fy YWp1IDxocmlkeWFAZ29vZ2xlLmNvbT4KPiArRGVzY3JpcHRpb246CVRoZSAvc3lzL2tlcm5lbC9k bWFidWYvYnVmZmVycyBkaXJlY3RvcnkgY29udGFpbnMgYQo+ICsJCXNuYXBzaG90IG9mIHRoZSBp bnRlcm5hbCBzdGF0ZSBvZiBldmVyeSBETUEtQlVGLgo+ICsJCS9zeXMva2VybmVsL2RtYWJ1Zi9i dWZmZXJzLzxpbm9kZV9udW1iZXI+IHdpbGwgY29udGFpbiB0aGUKPiArCQlzdGF0aXN0aWNzIGZv ciB0aGUgRE1BLUJVRiB3aXRoIHRoZSB1bmlxdWUgaW5vZGUgbnVtYmVyCj4gKwkJPGlub2RlX251 bWJlcj4KPiArVXNlcnM6CQlrZXJuZWwgbWVtb3J5IHR1bmluZy9kZWJ1Z2dpbmcgdG9vbHMKPiAr Cj4gK1doYXQ6CQkvc3lzL2tlcm5lbC9kbWFidWYvYnVmZmVycy88aW5vZGVfbnVtYmVyPi9leHBv cnRlcl9uYW1lCj4gK0RhdGU6CQlKYW51YXJ5IDIwMjEKPiArS2VybmVsVmVyc2lvbjoJdjUuMTIK PiArQ29udGFjdDoJSHJpZHlhIFZhbHNhcmFqdSA8aHJpZHlhQGdvb2dsZS5jb20+Cj4gK0Rlc2Ny aXB0aW9uOglUaGlzIGZpbGUgaXMgcmVhZC1vbmx5IGFuZCBjb250YWlucyB0aGUgbmFtZSBvZiB0 aGUgZXhwb3J0ZXIgb2YKPiArCQl0aGUgRE1BLUJVRi4KPiArCj4gK1doYXQ6CQkvc3lzL2tlcm5l bC9kbWFidWYvYnVmZmVycy88aW5vZGVfbnVtYmVyPi9zaXplCj4gK0RhdGU6CQlKYW51YXJ5IDIw MjEKPiArS2VybmVsVmVyc2lvbjoJdjUuMTIKPiArQ29udGFjdDoJSHJpZHlhIFZhbHNhcmFqdSA8 aHJpZHlhQGdvb2dsZS5jb20+Cj4gK0Rlc2NyaXB0aW9uOglUaGlzIGZpbGUgaXMgcmVhZC1vbmx5 IGFuZCBzcGVjaWZpZXMgdGhlIHNpemUgb2YgdGhlIERNQS1CVUYgaW4KPiArCQlieXRlcy4KPiAr Cj4gK1doYXQ6CQkvc3lzL2tlcm5lbC9kbWFidWYvYnVmZmVycy88aW5vZGVfbnVtYmVyPi9hdHRh Y2htZW50cwo+ICtEYXRlOgkJSmFudWFyeSAyMDIxCj4gK0tlcm5lbFZlcnNpb246CXY1LjEyCj4g K0NvbnRhY3Q6CUhyaWR5YSBWYWxzYXJhanUgPGhyaWR5YUBnb29nbGUuY29tPgo+ICtEZXNjcmlw dGlvbjoJVGhpcyBkaXJlY3Rvcnkgd2lsbCBjb250YWluIHN1YmRpcmVjdG9yaWVzIHJlcHJlc2Vu dGluZyBldmVyeQo+ICsJCWF0dGFjaG1lbnQgb2YgdGhlIERNQS1CVUYuCj4gKwo+ICtXaGF0OgkJ L3N5cy9rZXJuZWwvZG1hYnVmL2J1ZmZlcnMvPGlub2RlX251bWJlcj4vYXR0YWNobWVudHMvPGF0 dGFjaG1lbnRfdWlkPgo+ICtEYXRlOgkJSmFudWFyeSAyMDIxCj4gK0tlcm5lbFZlcnNpb246CXY1 LjEyCj4gK0NvbnRhY3Q6CUhyaWR5YSBWYWxzYXJhanUgPGhyaWR5YUBnb29nbGUuY29tPgo+ICtE ZXNjcmlwdGlvbjoJVGhpcyBkaXJlY3Rvcnkgd2lsbCBjb250YWluIGluZm9ybWF0aW9uIG9uIHRo ZSBhdHRhY2hpbmcgZGV2aWNlCj4gKwkJYW5kIHRoZSBudW1iZXIgb2YgY3VycmVudCBkaXN0aW5j dCBkZXZpY2UgbWFwcGluZ3MuCj4gKwo+ICtXaGF0OgkJL3N5cy9rZXJuZWwvZG1hYnVmL2J1ZmZl cnMvPGlub2RlX251bWJlcj4vYXR0YWNobWVudHMvPGF0dGFjaG1lbnRfdWlkPi9kZXZpY2UKPiAr RGF0ZToJCUphbnVhcnkgMjAyMQo+ICtLZXJuZWxWZXJzaW9uOgl2NS4xMgo+ICtDb250YWN0OglI cmlkeWEgVmFsc2FyYWp1IDxocmlkeWFAZ29vZ2xlLmNvbT4KPiArRGVzY3JpcHRpb246CVRoaXMg ZmlsZSBpcyByZWFkLW9ubHkgYW5kIGlzIGEgc3ltbGluayB0byB0aGUgYXR0YWNoaW5nIGRldmlj ZXMncwo+ICsJCXN5c2ZzIGVudHJ5Lgo+ICsKPiArV2hhdDoJCS9zeXMva2VybmVsL2RtYWJ1Zi9i dWZmZXJzLzxpbm9kZV9udW1iZXI+L2F0dGFjaG1lbnRzLzxhdHRhY2htZW50X3VpZD4vbWFwX2Nv dW50ZXIKPiArRGF0ZToJCUphbnVhcnkgMjAyMQo+ICtLZXJuZWxWZXJzaW9uOgl2NS4xMgo+ICtD b250YWN0OglIcmlkeWEgVmFsc2FyYWp1IDxocmlkeWFAZ29vZ2xlLmNvbT4KPiArRGVzY3JpcHRp b246CVRoaXMgZmlsZSBpcyByZWFkLW9ubHkgYW5kIGNvbnRhaW5zIGEgbWFwX2NvdW50ZXIgaW5k aWNhdGluZyB0aGUKPiArCQludW1iZXIgb2YgZGlzdGluY3QgZGV2aWNlIG1hcHBpbmdzIG9mIHRo ZSBhdHRhY2htZW50Lgo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2RtYS1idWYvS2NvbmZpZyBiL2Ry aXZlcnMvZG1hLWJ1Zi9LY29uZmlnCj4gaW5kZXggNGY4MjI0YTZhYzk1Li4yN2U2YTJkYWZlYWEg MTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9kbWEtYnVmL0tjb25maWcKPiArKysgYi9kcml2ZXJzL2Rt YS1idWYvS2NvbmZpZwo+IEBAIC02NCw2ICs2NCwxNyBAQCBtZW51Y29uZmlnIERNQUJVRl9IRUFQ Uwo+ICAgCSAgYWxsb3dzIHVzZXJzcGFjZSB0byBhbGxvY2F0ZSBkbWEtYnVmcyB0aGF0IGNhbiBi ZSBzaGFyZWQKPiAgIAkgIGJldHdlZW4gZHJpdmVycy4KPiAgIAo+ICttZW51Y29uZmlnIERNQUJV Rl9TWVNGU19TVEFUUwo+ICsJYm9vbCAiRE1BLUJVRiBzeXNmcyBzdGF0aXN0aWNzIgo+ICsJc2Vs ZWN0IERNQV9TSEFSRURfQlVGRkVSCj4gKwloZWxwCj4gKwkgICBDaG9vc2UgdGhpcyBvcHRpb24g dG8gZW5hYmxlIERNQS1CVUYgc3lzZnMgc3RhdGlzdGljcwo+ICsJICAgaW4gbG9jYXRpb24gL3N5 cy9rZXJuZWwvZG1hYnVmL2J1ZmZlcnMuCj4gKwo+ICsJICAgL3N5cy9rZXJuZWwvZG1hYnVmL2J1 ZmZlcnMvPGlub2RlX251bWJlcj4gd2lsbCBjb250YWluCj4gKwkgICBzdGF0aXN0aWNzIGZvciB0 aGUgRE1BLUJVRiB3aXRoIHRoZSB1bmlxdWUgaW5vZGUgbnVtYmVyCj4gKwkgICA8aW5vZGVfbnVt YmVyPi4KPiArCj4gICBzb3VyY2UgImRyaXZlcnMvZG1hLWJ1Zi9oZWFwcy9LY29uZmlnIgo+ICAg Cj4gICBlbmRtZW51Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZG1hLWJ1Zi9NYWtlZmlsZSBiL2Ry aXZlcnMvZG1hLWJ1Zi9NYWtlZmlsZQo+IGluZGV4IDk5NWUwNWY2MDlmZi4uNDBkODFmMjNjYWNm IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZG1hLWJ1Zi9NYWtlZmlsZQo+ICsrKyBiL2RyaXZlcnMv ZG1hLWJ1Zi9NYWtlZmlsZQo+IEBAIC02LDYgKzYsNyBAQCBvYmotJChDT05GSUdfRE1BQlVGX0hF QVBTKQkrPSBoZWFwcy8KPiAgIG9iai0kKENPTkZJR19TWU5DX0ZJTEUpCQkrPSBzeW5jX2ZpbGUu bwo+ICAgb2JqLSQoQ09ORklHX1NXX1NZTkMpCQkrPSBzd19zeW5jLm8gc3luY19kZWJ1Zy5vCj4g ICBvYmotJChDT05GSUdfVURNQUJVRikJCSs9IHVkbWFidWYubwo+ICtvYmotJChDT05GSUdfRE1B QlVGX1NZU0ZTX1NUQVRTKSArPSBkbWEtYnVmLXN5c2ZzLXN0YXRzLm8KPiAgIAo+ICAgZG1hYnVm X3NlbGZ0ZXN0cy15IDo9IFwKPiAgIAlzZWxmdGVzdC5vIFwKPiBkaWZmIC0tZ2l0IGEvZHJpdmVy cy9kbWEtYnVmL2RtYS1idWYtc3lzZnMtc3RhdHMuYyBiL2RyaXZlcnMvZG1hLWJ1Zi9kbWEtYnVm LXN5c2ZzLXN0YXRzLmMKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAw MC4uNjFmODVjM2QxNmE1Cj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMvZG1hLWJ1Zi9k bWEtYnVmLXN5c2ZzLXN0YXRzLmMKPiBAQCAtMCwwICsxLDI4MyBAQAo+ICsvLyBTUERYLUxpY2Vu c2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5Cj4gKy8qCj4gKyAqIERNQS1CVUYgc3lzZnMgc3Rh dGlzdGljcy4KPiArICoKPiArICogQ29weXJpZ2h0IChDKSAyMDIxIEdvb2dsZSBMTEMuCj4gKyAq Lwo+ICsKPiArI2luY2x1ZGUgPGxpbnV4L2RtYS1idWYuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2Rt YS1yZXN2Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9rb2JqZWN0Lmg+Cj4gKyNpbmNsdWRlIDxsaW51 eC9wcmludGsuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KPiArI2luY2x1ZGUgPGxpbnV4 L3N5c2ZzLmg+Cj4gKwo+ICsjZGVmaW5lIHRvX2RtYV9idWZfZW50cnlfZnJvbV9rb2JqKHgpIGNv bnRhaW5lcl9vZih4LCBzdHJ1Y3QgZG1hX2J1Zl9zeXNmc19lbnRyeSwga29iaikKPiArCj4gK3N0 cnVjdCBkbWFfYnVmX3N0YXRzX2F0dHJpYnV0ZSB7Cj4gKwlzdHJ1Y3QgYXR0cmlidXRlIGF0dHI7 Cj4gKwlzc2l6ZV90ICgqc2hvdykoc3RydWN0IGRtYV9idWYgKmRtYWJ1ZiwKPiArCQkJc3RydWN0 IGRtYV9idWZfc3RhdHNfYXR0cmlidXRlICphdHRyLCBjaGFyICpidWYpOwo+ICt9Owo+ICsjZGVm aW5lIHRvX2RtYV9idWZfc3RhdHNfYXR0cih4KSBjb250YWluZXJfb2YoeCwgc3RydWN0IGRtYV9i dWZfc3RhdHNfYXR0cmlidXRlLCBhdHRyKQo+ICsKPiArc3RhdGljIHNzaXplX3QgZG1hX2J1Zl9z dGF0c19hdHRyaWJ1dGVfc2hvdyhzdHJ1Y3Qga29iamVjdCAqa29iaiwKPiArCQkJCQkgICAgc3Ry dWN0IGF0dHJpYnV0ZSAqYXR0ciwKPiArCQkJCQkgICAgY2hhciAqYnVmKQo+ICt7Cj4gKwlzdHJ1 Y3QgZG1hX2J1Zl9zdGF0c19hdHRyaWJ1dGUgKmF0dHJpYnV0ZTsKPiArCXN0cnVjdCBkbWFfYnVm X3N5c2ZzX2VudHJ5ICpzeXNmc19lbnRyeTsKPiArCXN0cnVjdCBkbWFfYnVmICpkbWFidWY7Cj4g Kwo+ICsJYXR0cmlidXRlID0gdG9fZG1hX2J1Zl9zdGF0c19hdHRyKGF0dHIpOwo+ICsJc3lzZnNf ZW50cnkgPSB0b19kbWFfYnVmX2VudHJ5X2Zyb21fa29iaihrb2JqKTsKPiArCWRtYWJ1ZiA9IHN5 c2ZzX2VudHJ5LT5kbWFidWY7Cj4gKwo+ICsJaWYgKCFkbWFidWYgfHwgIWF0dHJpYnV0ZS0+c2hv dykKPiArCQlyZXR1cm4gLUVJTzsKPiArCj4gKwlyZXR1cm4gYXR0cmlidXRlLT5zaG93KGRtYWJ1 ZiwgYXR0cmlidXRlLCBidWYpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IHN5c2Zz X29wcyBkbWFfYnVmX3N0YXRzX3N5c2ZzX29wcyA9IHsKPiArCS5zaG93ID0gZG1hX2J1Zl9zdGF0 c19hdHRyaWJ1dGVfc2hvdywKPiArfTsKPiArCj4gK3N0YXRpYyBzc2l6ZV90IGV4cG9ydGVyX25h bWVfc2hvdyhzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLAo+ICsJCQkJICBzdHJ1Y3QgZG1hX2J1Zl9z dGF0c19hdHRyaWJ1dGUgKmF0dHIsCj4gKwkJCQkgIGNoYXIgKmJ1ZikKPiArewo+ICsJcmV0dXJu IHN5c2ZzX2VtaXQoYnVmLCAiJXNcbiIsIGRtYWJ1Zi0+ZXhwX25hbWUpOwo+ICt9Cj4gKwo+ICtz dGF0aWMgc3NpemVfdCBzaXplX3Nob3coc3RydWN0IGRtYV9idWYgKmRtYWJ1ZiwKPiArCQkJIHN0 cnVjdCBkbWFfYnVmX3N0YXRzX2F0dHJpYnV0ZSAqYXR0ciwKPiArCQkJIGNoYXIgKmJ1ZikKPiAr ewo+ICsJcmV0dXJuIHN5c2ZzX2VtaXQoYnVmLCAiJXp1XG4iLCBkbWFidWYtPnNpemUpOwo+ICt9 Cj4gKwo+ICtzdGF0aWMgc3RydWN0IGRtYV9idWZfc3RhdHNfYXR0cmlidXRlIGV4cG9ydGVyX25h bWVfYXR0cmlidXRlID0KPiArCV9fQVRUUl9STyhleHBvcnRlcl9uYW1lKTsKPiArc3RhdGljIHN0 cnVjdCBkbWFfYnVmX3N0YXRzX2F0dHJpYnV0ZSBzaXplX2F0dHJpYnV0ZSA9IF9fQVRUUl9STyhz aXplKTsKPiArCj4gK3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICpkbWFfYnVmX3N0YXRzX2RlZmF1 bHRfYXR0cnNbXSA9IHsKPiArCSZleHBvcnRlcl9uYW1lX2F0dHJpYnV0ZS5hdHRyLAo+ICsJJnNp emVfYXR0cmlidXRlLmF0dHIsCj4gKwlOVUxMLAo+ICt9Owo+ICtBVFRSSUJVVEVfR1JPVVBTKGRt YV9idWZfc3RhdHNfZGVmYXVsdCk7Cj4gKwo+ICtzdGF0aWMgdm9pZCBkbWFfYnVmX3N5c2ZzX3Jl bGVhc2Uoc3RydWN0IGtvYmplY3QgKmtvYmopCj4gK3sKPiArCXN0cnVjdCBkbWFfYnVmX3N5c2Zz X2VudHJ5ICpzeXNmc19lbnRyeTsKPiArCj4gKwlzeXNmc19lbnRyeSA9IHRvX2RtYV9idWZfZW50 cnlfZnJvbV9rb2JqKGtvYmopOwo+ICsJa2ZyZWUoc3lzZnNfZW50cnkpOwo+ICt9Cj4gKwo+ICtz dGF0aWMgc3RydWN0IGtvYmpfdHlwZSBkbWFfYnVmX2t0eXBlID0gewo+ICsJLnN5c2ZzX29wcyA9 ICZkbWFfYnVmX3N0YXRzX3N5c2ZzX29wcywKPiArCS5yZWxlYXNlID0gZG1hX2J1Zl9zeXNmc19y ZWxlYXNlLAo+ICsJLmRlZmF1bHRfZ3JvdXBzID0gZG1hX2J1Zl9zdGF0c19kZWZhdWx0X2dyb3Vw cywKPiArfTsKPiArCj4gKyNkZWZpbmUgdG9fZG1hX2J1Zl9hdHRhY2hfZW50cnlfZnJvbV9rb2Jq KHgpIGNvbnRhaW5lcl9vZih4LCBzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfc3lzZnNfZW50cnksIGtv YmopCj4gKwo+ICtzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfc3RhdHNfYXR0cmlidXRlIHsKPiArCXN0 cnVjdCBhdHRyaWJ1dGUgYXR0cjsKPiArCXNzaXplX3QgKCpzaG93KShzdHJ1Y3QgZG1hX2J1Zl9h dHRhY2hfc3lzZnNfZW50cnkgKnN5c2ZzX2VudHJ5LAo+ICsJCQlzdHJ1Y3QgZG1hX2J1Zl9hdHRh Y2hfc3RhdHNfYXR0cmlidXRlICphdHRyLCBjaGFyICpidWYpOwo+ICt9Owo+ICsjZGVmaW5lIHRv X2RtYV9idWZfYXR0YWNoX3N0YXRzX2F0dHIoeCkgY29udGFpbmVyX29mKHgsIHN0cnVjdCBkbWFf YnVmX2F0dGFjaF9zdGF0c19hdHRyaWJ1dGUsIGF0dHIpCj4gKwo+ICtzdGF0aWMgc3NpemVfdCBk bWFfYnVmX2F0dGFjaF9zdGF0c19hdHRyaWJ1dGVfc2hvdyhzdHJ1Y3Qga29iamVjdCAqa29iaiwK PiArCQkJCQkJICAgc3RydWN0IGF0dHJpYnV0ZSAqYXR0ciwKPiArCQkJCQkJICAgY2hhciAqYnVm KQo+ICt7Cj4gKwlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfc3RhdHNfYXR0cmlidXRlICphdHRyaWJ1 dGU7Cj4gKwlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfc3lzZnNfZW50cnkgKnN5c2ZzX2VudHJ5Owo+ ICsKPiArCWF0dHJpYnV0ZSA9IHRvX2RtYV9idWZfYXR0YWNoX3N0YXRzX2F0dHIoYXR0cik7Cj4g KwlzeXNmc19lbnRyeSA9IHRvX2RtYV9idWZfYXR0YWNoX2VudHJ5X2Zyb21fa29iaihrb2JqKTsK PiArCj4gKwlpZiAoIWF0dHJpYnV0ZS0+c2hvdykKPiArCQlyZXR1cm4gLUVJTzsKPiArCj4gKwly ZXR1cm4gYXR0cmlidXRlLT5zaG93KHN5c2ZzX2VudHJ5LCBhdHRyaWJ1dGUsIGJ1Zik7Cj4gK30K PiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc3lzZnNfb3BzIGRtYV9idWZfYXR0YWNoX3N0YXRz X3N5c2ZzX29wcyA9IHsKPiArCS5zaG93ID0gZG1hX2J1Zl9hdHRhY2hfc3RhdHNfYXR0cmlidXRl X3Nob3csCj4gK307Cj4gKwo+ICtzdGF0aWMgc3NpemVfdCBtYXBfY291bnRlcl9zaG93KHN0cnVj dCBkbWFfYnVmX2F0dGFjaF9zeXNmc19lbnRyeSAqc3lzZnNfZW50cnksCj4gKwkJCQlzdHJ1Y3Qg ZG1hX2J1Zl9hdHRhY2hfc3RhdHNfYXR0cmlidXRlICphdHRyLAo+ICsJCQkJY2hhciAqYnVmKQo+ ICt7Cj4gKwlyZXR1cm4gc3lzZnNfZW1pdChidWYsICIldVxuIiwgc3lzZnNfZW50cnktPm1hcF9j b3VudGVyKTsKPiArfQo+ICsKPiArc3RhdGljIHN0cnVjdCBkbWFfYnVmX2F0dGFjaF9zdGF0c19h dHRyaWJ1dGUgbWFwX2NvdW50ZXJfYXR0cmlidXRlID0KPiArCV9fQVRUUl9STyhtYXBfY291bnRl cik7Cj4gKwo+ICtzdGF0aWMgc3RydWN0IGF0dHJpYnV0ZSAqZG1hX2J1Zl9hdHRhY2hfc3RhdHNf ZGVmYXVsdF9hdHRyc1tdID0gewo+ICsJJm1hcF9jb3VudGVyX2F0dHJpYnV0ZS5hdHRyLAo+ICsJ TlVMTCwKPiArfTsKPiArQVRUUklCVVRFX0dST1VQUyhkbWFfYnVmX2F0dGFjaF9zdGF0c19kZWZh dWx0KTsKPiArCj4gK3N0YXRpYyB2b2lkIGRtYV9idWZfYXR0YWNoX3N5c2ZzX3JlbGVhc2Uoc3Ry dWN0IGtvYmplY3QgKmtvYmopCj4gK3sKPiArCXN0cnVjdCBkbWFfYnVmX2F0dGFjaF9zeXNmc19l bnRyeSAqc3lzZnNfZW50cnk7Cj4gKwo+ICsJc3lzZnNfZW50cnkgPSB0b19kbWFfYnVmX2F0dGFj aF9lbnRyeV9mcm9tX2tvYmooa29iaik7Cj4gKwlrZnJlZShzeXNmc19lbnRyeSk7Cj4gK30KPiAr Cj4gK3N0YXRpYyBzdHJ1Y3Qga29ial90eXBlIGRtYV9idWZfYXR0YWNoX2t0eXBlID0gewo+ICsJ LnN5c2ZzX29wcyA9ICZkbWFfYnVmX2F0dGFjaF9zdGF0c19zeXNmc19vcHMsCj4gKwkucmVsZWFz ZSA9IGRtYV9idWZfYXR0YWNoX3N5c2ZzX3JlbGVhc2UsCj4gKwkuZGVmYXVsdF9ncm91cHMgPSBk bWFfYnVmX2F0dGFjaF9zdGF0c19kZWZhdWx0X2dyb3VwcywKPiArfTsKPiArCj4gK3ZvaWQgZG1h X2J1Zl9hdHRhY2hfc3RhdHNfdGVhcmRvd24oc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0 YWNoKQo+ICt7Cj4gKwlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfc3lzZnNfZW50cnkgKnN5c2ZzX2Vu dHJ5Owo+ICsKPiArCXN5c2ZzX2VudHJ5ID0gYXR0YWNoLT5zeXNmc19lbnRyeTsKPiArCWlmICgh c3lzZnNfZW50cnkpCj4gKwkJcmV0dXJuOwo+ICsKPiArCXN5c2ZzX2RlbGV0ZV9saW5rKCZzeXNm c19lbnRyeS0+a29iaiwgJmF0dGFjaC0+ZGV2LT5rb2JqLCAiZGV2aWNlIik7Cj4gKwo+ICsJa29i amVjdF9kZWwoJnN5c2ZzX2VudHJ5LT5rb2JqKTsKPiArCWtvYmplY3RfcHV0KCZzeXNmc19lbnRy eS0+a29iaik7Cj4gK30KPiArCj4gK2ludCBkbWFfYnVmX2F0dGFjaF9zdGF0c19zZXR1cChzdHJ1 Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2gsCj4gKwkJCSAgICAgICB1bnNpZ25lZCBpbnQg dWlkKQo+ICt7Cj4gKwlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfc3lzZnNfZW50cnkgKnN5c2ZzX2Vu dHJ5Owo+ICsJaW50IHJldDsKPiArCXN0cnVjdCBkbWFfYnVmICpkbWFidWY7Cj4gKwo+ICsJaWYg KCFhdHRhY2gpCj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJZG1hYnVmID0gYXR0YWNoLT5k bWFidWY7Cj4gKwo+ICsJc3lzZnNfZW50cnkgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgZG1hX2J1 Zl9hdHRhY2hfc3lzZnNfZW50cnkpLAo+ICsJCQkgICAgICBHRlBfS0VSTkVMKTsKPiArCWlmICgh c3lzZnNfZW50cnkpCj4gKwkJcmV0dXJuIC1FTk9NRU07Cj4gKwo+ICsJc3lzZnNfZW50cnktPmtv Ymoua3NldCA9IGRtYWJ1Zi0+c3lzZnNfZW50cnktPmF0dGFjaF9zdGF0c19rc2V0Owo+ICsKPiAr CWF0dGFjaC0+c3lzZnNfZW50cnkgPSBzeXNmc19lbnRyeTsKPiArCj4gKwlyZXQgPSBrb2JqZWN0 X2luaXRfYW5kX2FkZCgmc3lzZnNfZW50cnktPmtvYmosICZkbWFfYnVmX2F0dGFjaF9rdHlwZSwK PiArCQkJCSAgIE5VTEwsICIldSIsIHVpZCk7Cj4gKwlpZiAocmV0KQo+ICsJCWdvdG8ga29ial9l cnI7Cj4gKwo+ICsJcmV0ID0gc3lzZnNfY3JlYXRlX2xpbmsoJnN5c2ZzX2VudHJ5LT5rb2JqLCAm YXR0YWNoLT5kZXYtPmtvYmosCj4gKwkJCQkiZGV2aWNlIik7Cj4gKwlpZiAocmV0KQo+ICsJCWdv dG8gbGlua19lcnI7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gKwo+ICtsaW5rX2VycjoKPiArCWtvYmpl Y3RfZGVsKCZzeXNmc19lbnRyeS0+a29iaik7Cj4gK2tvYmpfZXJyOgo+ICsJa29iamVjdF9wdXQo JnN5c2ZzX2VudHJ5LT5rb2JqKTsKPiArCWF0dGFjaC0+c3lzZnNfZW50cnkgPSBOVUxMOwo+ICsK PiArCXJldHVybiByZXQ7Cj4gK30KPiArdm9pZCBkbWFfYnVmX3N0YXRzX3RlYXJkb3duKHN0cnVj dCBkbWFfYnVmICpkbWFidWYpCj4gK3sKPiArCXN0cnVjdCBkbWFfYnVmX3N5c2ZzX2VudHJ5ICpz eXNmc19lbnRyeTsKPiArCj4gKwlzeXNmc19lbnRyeSA9IGRtYWJ1Zi0+c3lzZnNfZW50cnk7Cj4g KwlpZiAoIXN5c2ZzX2VudHJ5KQo+ICsJCXJldHVybjsKPiArCj4gKwlrc2V0X3VucmVnaXN0ZXIo c3lzZnNfZW50cnktPmF0dGFjaF9zdGF0c19rc2V0KTsKPiArCWtvYmplY3RfZGVsKCZzeXNmc19l bnRyeS0+a29iaik7Cj4gKwlrb2JqZWN0X3B1dCgmc3lzZnNfZW50cnktPmtvYmopOwo+ICt9Cj4g Kwo+ICtzdGF0aWMgc3RydWN0IGtzZXQgKmRtYV9idWZfc3RhdHNfa3NldDsKPiArc3RhdGljIHN0 cnVjdCBrc2V0ICpkbWFfYnVmX3Blcl9idWZmZXJfc3RhdHNfa3NldDsKPiAraW50IGRtYV9idWZf aW5pdF9zeXNmc19zdGF0aXN0aWNzKHZvaWQpCj4gK3sKPiArCWRtYV9idWZfc3RhdHNfa3NldCA9 IGtzZXRfY3JlYXRlX2FuZF9hZGQoImRtYWJ1ZiIsIE5VTEwsIGtlcm5lbF9rb2JqKTsKPiArCWlm ICghZG1hX2J1Zl9zdGF0c19rc2V0KQo+ICsJCXJldHVybiAtRU5PTUVNOwo+ICsKPiArCWRtYV9i dWZfcGVyX2J1ZmZlcl9zdGF0c19rc2V0ID0ga3NldF9jcmVhdGVfYW5kX2FkZCgiYnVmZmVycyIs IE5VTEwsCj4gKwkJCQkJCQkgICAgJmRtYV9idWZfc3RhdHNfa3NldC0+a29iaik7Cj4gKwlpZiAo IWRtYV9idWZfcGVyX2J1ZmZlcl9zdGF0c19rc2V0KSB7Cj4gKwkJa3NldF91bnJlZ2lzdGVyKGRt YV9idWZfc3RhdHNfa3NldCk7Cj4gKwkJcmV0dXJuIC1FTk9NRU07Cj4gKwl9Cj4gKwo+ICsJcmV0 dXJuIDA7Cj4gK30KPiArCj4gK3ZvaWQgZG1hX2J1Zl91bmluaXRfc3lzZnNfc3RhdGlzdGljcyh2 b2lkKQo+ICt7Cj4gKwlrc2V0X3VucmVnaXN0ZXIoZG1hX2J1Zl9wZXJfYnVmZmVyX3N0YXRzX2tz ZXQpOwo+ICsJa3NldF91bnJlZ2lzdGVyKGRtYV9idWZfc3RhdHNfa3NldCk7Cj4gK30KPiArCj4g K2ludCBkbWFfYnVmX3N0YXRzX3NldHVwKHN0cnVjdCBkbWFfYnVmICpkbWFidWYpCj4gK3sKPiAr CXN0cnVjdCBkbWFfYnVmX3N5c2ZzX2VudHJ5ICpzeXNmc19lbnRyeTsKPiArCWludCByZXQ7Cj4g KwlzdHJ1Y3Qga3NldCAqYXR0YWNoX3N0YXRzX2tzZXQ7Cj4gKwo+ICsJaWYgKCFkbWFidWYgfHwg IWRtYWJ1Zi0+ZmlsZSkKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCj4gKwlpZiAoIWRtYWJ1Zi0+ ZXhwX25hbWUpIHsKPiArCQlwcl9lcnIoImV4cG9ydGVyIG5hbWUgbXVzdCBub3QgYmUgZW1wdHkg aWYgc3RhdHMgbmVlZGVkXG4iKTsKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCX0KPiArCj4gKwlz eXNmc19lbnRyeSA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBkbWFfYnVmX3N5c2ZzX2VudHJ5KSwg R0ZQX0tFUk5FTCk7Cj4gKwlpZiAoIXN5c2ZzX2VudHJ5KQo+ICsJCXJldHVybiAtRU5PTUVNOwo+ ICsKPiArCXN5c2ZzX2VudHJ5LT5rb2JqLmtzZXQgPSBkbWFfYnVmX3Blcl9idWZmZXJfc3RhdHNf a3NldDsKPiArCXN5c2ZzX2VudHJ5LT5kbWFidWYgPSBkbWFidWY7Cj4gKwo+ICsJZG1hYnVmLT5z eXNmc19lbnRyeSA9IHN5c2ZzX2VudHJ5Owo+ICsKPiArCS8qIGNyZWF0ZSB0aGUgZGlyZWN0b3J5 IGZvciBidWZmZXIgc3RhdHMgKi8KPiArCXJldCA9IGtvYmplY3RfaW5pdF9hbmRfYWRkKCZzeXNm c19lbnRyeS0+a29iaiwgJmRtYV9idWZfa3R5cGUsIE5VTEwsCj4gKwkJCQkgICAiJWx1IiwgZmls ZV9pbm9kZShkbWFidWYtPmZpbGUpLT5pX2lubyk7Cj4gKwlpZiAocmV0KQo+ICsJCWdvdG8gZXJy X3N5c2ZzX2RtYWJ1ZjsKPiArCj4gKwkvKiBjcmVhdGUgdGhlIGRpcmVjdG9yeSBmb3IgYXR0YWNo bWVudCBzdGF0cyAqLwo+ICsJYXR0YWNoX3N0YXRzX2tzZXQgPSBrc2V0X2NyZWF0ZV9hbmRfYWRk KCJhdHRhY2htZW50cyIsIE5VTEwsCj4gKwkJCQkJCSZzeXNmc19lbnRyeS0+a29iaik7Cj4gKwlp ZiAoIWF0dGFjaF9zdGF0c19rc2V0KSB7Cj4gKwkJcmV0ID0gLUVOT01FTTsKPiArCQlnb3RvIGVy cl9zeXNmc19hdHRhY2g7Cj4gKwl9Cj4gKwo+ICsJc3lzZnNfZW50cnktPmF0dGFjaF9zdGF0c19r c2V0ID0gYXR0YWNoX3N0YXRzX2tzZXQ7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gKwo+ICtlcnJfc3lz ZnNfYXR0YWNoOgo+ICsJa29iamVjdF9kZWwoJnN5c2ZzX2VudHJ5LT5rb2JqKTsKPiArZXJyX3N5 c2ZzX2RtYWJ1ZjoKPiArCWtvYmplY3RfcHV0KCZzeXNmc19lbnRyeS0+a29iaik7Cj4gKwlkbWFi dWYtPnN5c2ZzX2VudHJ5ID0gTlVMTDsKPiArCXJldHVybiByZXQ7Cj4gK30KPiBkaWZmIC0tZ2l0 IGEvZHJpdmVycy9kbWEtYnVmL2RtYS1idWYtc3lzZnMtc3RhdHMuaCBiL2RyaXZlcnMvZG1hLWJ1 Zi9kbWEtYnVmLXN5c2ZzLXN0YXRzLmgKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAw MDAwMDAwMDAwMC4uNWY0NzAzMjQ5MTE3Cj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMv ZG1hLWJ1Zi9kbWEtYnVmLXN5c2ZzLXN0YXRzLmgKPiBAQCAtMCwwICsxLDYyIEBACj4gKy8qIFNQ RFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9ubHkgKi8KPiArLyoKPiArICogRE1BLUJV RiBzeXNmcyBzdGF0aXN0aWNzLgo+ICsgKgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMjEgR29vZ2xl IExMQy4KPiArICovCj4gKwo+ICsjaWZuZGVmIF9ETUFfQlVGX1NZU0ZTX1NUQVRTX0gKPiArI2Rl ZmluZSBfRE1BX0JVRl9TWVNGU19TVEFUU19ICj4gKwo+ICsjaWZkZWYgQ09ORklHX0RNQUJVRl9T WVNGU19TVEFUUwo+ICsKPiAraW50IGRtYV9idWZfaW5pdF9zeXNmc19zdGF0aXN0aWNzKHZvaWQp Owo+ICt2b2lkIGRtYV9idWZfdW5pbml0X3N5c2ZzX3N0YXRpc3RpY3Modm9pZCk7Cj4gKwo+ICtp bnQgZG1hX2J1Zl9zdGF0c19zZXR1cChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmKTsKPiAraW50IGRt YV9idWZfYXR0YWNoX3N0YXRzX3NldHVwKHN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFj aCwKPiArCQkJICAgICAgIHVuc2lnbmVkIGludCB1aWQpOwo+ICtzdGF0aWMgaW5saW5lIHZvaWQg ZG1hX2J1Zl91cGRhdGVfYXR0YWNobWVudF9tYXBfY291bnQoc3RydWN0IGRtYV9idWZfYXR0YWNo bWVudCAqYXR0YWNoLAo+ICsJCQkJCQkgICAgICAgaW50IGRlbHRhKQo+ICt7Cj4gKwlzdHJ1Y3Qg ZG1hX2J1Zl9hdHRhY2hfc3lzZnNfZW50cnkgKmVudHJ5ID0gYXR0YWNoLT5zeXNmc19lbnRyeTsK PiArCj4gKwllbnRyeS0+bWFwX2NvdW50ZXIgKz0gZGVsdGE7Cj4gK30KPiArdm9pZCBkbWFfYnVm X3N0YXRzX3RlYXJkb3duKHN0cnVjdCBkbWFfYnVmICpkbWFidWYpOwo+ICt2b2lkIGRtYV9idWZf YXR0YWNoX3N0YXRzX3RlYXJkb3duKHN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaCk7 Cj4gK3N0YXRpYyBpbmxpbmUgdW5zaWduZWQgaW50IGRtYV9idWZfdXBkYXRlX2F0dGFjaF91aWQo c3RydWN0IGRtYV9idWYgKmRtYWJ1ZikKPiArewo+ICsJc3RydWN0IGRtYV9idWZfc3lzZnNfZW50 cnkgKmVudHJ5ID0gZG1hYnVmLT5zeXNmc19lbnRyeTsKPiArCj4gKwlyZXR1cm4gZW50cnktPmF0 dGFjaG1lbnRfdWlkKys7Cj4gK30KPiArI2Vsc2UKPiArCj4gK3N0YXRpYyBpbmxpbmUgaW50IGRt YV9idWZfaW5pdF9zeXNmc19zdGF0aXN0aWNzKHZvaWQpCj4gK3sKPiArCXJldHVybiAwOwo+ICt9 Cj4gKwo+ICtzdGF0aWMgaW5saW5lIHZvaWQgZG1hX2J1Zl91bmluaXRfc3lzZnNfc3RhdGlzdGlj cyh2b2lkKSB7fQo+ICsKPiArc3RhdGljIGlubGluZSBpbnQgZG1hX2J1Zl9zdGF0c19zZXR1cChz dHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmKQo+ICt7Cj4gKwlyZXR1cm4gMDsKPiArfQo+ICtzdGF0aWMg aW5saW5lIGludCBkbWFfYnVmX2F0dGFjaF9zdGF0c19zZXR1cChzdHJ1Y3QgZG1hX2J1Zl9hdHRh Y2htZW50ICphdHRhY2gsCj4gKwkJCQkJICAgICB1bnNpZ25lZCBpbnQgdWlkKQo+ICt7Cj4gKwly ZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIGlubGluZSB2b2lkIGRtYV9idWZfc3RhdHNfdGVh cmRvd24oc3RydWN0IGRtYV9idWYgKmRtYWJ1Zikge30KPiArc3RhdGljIGlubGluZSB2b2lkIGRt YV9idWZfYXR0YWNoX3N0YXRzX3RlYXJkb3duKHN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0 dGFjaCkge30KPiArc3RhdGljIGlubGluZSB2b2lkIGRtYV9idWZfdXBkYXRlX2F0dGFjaG1lbnRf bWFwX2NvdW50KHN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaCwKPiArCQkJCQkJICAg ICAgIGludCBkZWx0YSkge30KPiArc3RhdGljIGlubGluZSB1bnNpZ25lZCBpbnQgZG1hX2J1Zl91 cGRhdGVfYXR0YWNoX3VpZChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmKQo+ICt7Cj4gKwlyZXR1cm4g MDsKPiArfQo+ICsjZW5kaWYKPiArI2VuZGlmIC8vIF9ETUFfQlVGX1NZU0ZTX1NUQVRTX0gKPiBk aWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEtYnVmL2RtYS1idWYuYyBiL2RyaXZlcnMvZG1hLWJ1Zi9k bWEtYnVmLmMKPiBpbmRleCA5YWQ2Mzk3YWFhOTcuLjI5ZjllYTE4ZWI0NyAxMDA2NDQKPiAtLS0g YS9kcml2ZXJzL2RtYS1idWYvZG1hLWJ1Zi5jCj4gKysrIGIvZHJpdmVycy9kbWEtYnVmL2RtYS1i dWYuYwo+IEBAIC0yOSw2ICsyOSw4IEBACj4gICAjaW5jbHVkZSA8dWFwaS9saW51eC9kbWEtYnVm Lmg+Cj4gICAjaW5jbHVkZSA8dWFwaS9saW51eC9tYWdpYy5oPgo+ICAgCj4gKyNpbmNsdWRlICJk bWEtYnVmLXN5c2ZzLXN0YXRzLmgiCj4gKwo+ICAgc3RhdGljIGlubGluZSBpbnQgaXNfZG1hX2J1 Zl9maWxlKHN0cnVjdCBmaWxlICopOwo+ICAgCj4gICBzdHJ1Y3QgZG1hX2J1Zl9saXN0IHsKPiBA QCAtNzksNiArODEsNyBAQCBzdGF0aWMgdm9pZCBkbWFfYnVmX3JlbGVhc2Uoc3RydWN0IGRlbnRy eSAqZGVudHJ5KQo+ICAgCWlmIChkbWFidWYtPnJlc3YgPT0gKHN0cnVjdCBkbWFfcmVzdiAqKSZk bWFidWZbMV0pCj4gICAJCWRtYV9yZXN2X2ZpbmkoZG1hYnVmLT5yZXN2KTsKPiAgIAo+ICsJZG1h X2J1Zl9zdGF0c190ZWFyZG93bihkbWFidWYpOwo+ICAgCW1vZHVsZV9wdXQoZG1hYnVmLT5vd25l cik7Cj4gICAJa2ZyZWUoZG1hYnVmLT5uYW1lKTsKPiAgIAlrZnJlZShkbWFidWYpOwo+IEBAIC01 NzksNiArNTgyLDEwIEBAIHN0cnVjdCBkbWFfYnVmICpkbWFfYnVmX2V4cG9ydChjb25zdCBzdHJ1 Y3QgZG1hX2J1Zl9leHBvcnRfaW5mbyAqZXhwX2luZm8pCj4gICAJZmlsZS0+Zl9tb2RlIHw9IEZN T0RFX0xTRUVLOwo+ICAgCWRtYWJ1Zi0+ZmlsZSA9IGZpbGU7Cj4gICAKPiArCXJldCA9IGRtYV9i dWZfc3RhdHNfc2V0dXAoZG1hYnVmKTsKPiArCWlmIChyZXQpCj4gKwkJZ290byBlcnJfc3lzZnM7 Cj4gKwo+ICAgCW11dGV4X2luaXQoJmRtYWJ1Zi0+bG9jayk7Cj4gICAJSU5JVF9MSVNUX0hFQUQo JmRtYWJ1Zi0+YXR0YWNobWVudHMpOwo+ICAgCj4gQEAgLTU4OCw2ICs1OTUsMTQgQEAgc3RydWN0 IGRtYV9idWYgKmRtYV9idWZfZXhwb3J0KGNvbnN0IHN0cnVjdCBkbWFfYnVmX2V4cG9ydF9pbmZv ICpleHBfaW5mbykKPiAgIAo+ICAgCXJldHVybiBkbWFidWY7Cj4gICAKPiArZXJyX3N5c2ZzOgo+ ICsJLyoKPiArCSAqIFNldCBmaWxlLT5mX3BhdGguZGVudHJ5LT5kX2ZzZGF0YSB0byBOVUxMIHNv IHRoYXQgd2hlbgo+ICsJICogZG1hX2J1Zl9yZWxlYXNlKCkgZ2V0cyBpbnZva2VkIGJ5IGRlbnRy eV9vcHMsIGl0IGV4aXRzCj4gKwkgKiBlYXJseSBiZWZvcmUgY2FsbGluZyB0aGUgcmVsZWFzZSgp IGRtYV9idWYgb3AuCj4gKwkgKi8KPiArCWZpbGUtPmZfcGF0aC5kZW50cnktPmRfZnNkYXRhID0g TlVMTDsKPiArCWZwdXQoZmlsZSk7Cj4gICBlcnJfZG1hYnVmOgo+ICAgCWtmcmVlKGRtYWJ1Zik7 Cj4gICBlcnJfbW9kdWxlOgo+IEBAIC02OTIsNiArNzA3LDcgQEAgZG1hX2J1Zl9keW5hbWljX2F0 dGFjaChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLCBzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gICB7Cj4g ICAJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoOwo+ICAgCWludCByZXQ7Cj4gKwl1 bnNpZ25lZCBpbnQgYXR0YWNoX3VpZDsKPiAgIAo+ICAgCWlmIChXQVJOX09OKCFkbWFidWYgfHwg IWRldikpCj4gICAJCXJldHVybiBFUlJfUFRSKC1FSU5WQUwpOwo+IEBAIC03MTcsOCArNzMzLDEz IEBAIGRtYV9idWZfZHluYW1pY19hdHRhY2goc3RydWN0IGRtYV9idWYgKmRtYWJ1Ziwgc3RydWN0 IGRldmljZSAqZGV2LAo+ICAgCX0KPiAgIAlkbWFfcmVzdl9sb2NrKGRtYWJ1Zi0+cmVzdiwgTlVM TCk7Cj4gICAJbGlzdF9hZGQoJmF0dGFjaC0+bm9kZSwgJmRtYWJ1Zi0+YXR0YWNobWVudHMpOwo+ ICsJYXR0YWNoX3VpZCA9IGRtYV9idWZfdXBkYXRlX2F0dGFjaF91aWQoZG1hYnVmKTsKPiAgIAlk bWFfcmVzdl91bmxvY2soZG1hYnVmLT5yZXN2KTsKPiAgIAo+ICsJcmV0ID0gZG1hX2J1Zl9hdHRh Y2hfc3RhdHNfc2V0dXAoYXR0YWNoLCBhdHRhY2hfdWlkKTsKPiArCWlmIChyZXQpCj4gKwkJZ290 byBlcnJfc3lzZnM7Cj4gKwo+ICAgCS8qIFdoZW4gZWl0aGVyIHRoZSBpbXBvcnRlciBvciB0aGUg ZXhwb3J0ZXIgY2FuJ3QgaGFuZGxlIGR5bmFtaWMKPiAgIAkgKiBtYXBwaW5ncyB3ZSBjYWNoZSB0 aGUgbWFwcGluZyBoZXJlIHRvIGF2b2lkIGlzc3VlcyB3aXRoIHRoZQo+ICAgCSAqIHJlc2VydmF0 aW9uIG9iamVjdCBsb2NrLgo+IEBAIC03NDUsNiArNzY2LDcgQEAgZG1hX2J1Zl9keW5hbWljX2F0 dGFjaChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLCBzdHJ1Y3QgZGV2aWNlICpkZXYsCj4gICAJCQlk bWFfcmVzdl91bmxvY2soYXR0YWNoLT5kbWFidWYtPnJlc3YpOwo+ICAgCQlhdHRhY2gtPnNndCA9 IHNndDsKPiAgIAkJYXR0YWNoLT5kaXIgPSBETUFfQklESVJFQ1RJT05BTDsKPiArCQlkbWFfYnVm X3VwZGF0ZV9hdHRhY2htZW50X21hcF9jb3VudChhdHRhY2gsIDEgLyogZGVsdGEgKi8pOwo+ICAg CX0KPiAgIAo+ICAgCXJldHVybiBhdHRhY2g7Cj4gQEAgLTc2MSw2ICs3ODMsNyBAQCBkbWFfYnVm X2R5bmFtaWNfYXR0YWNoKHN0cnVjdCBkbWFfYnVmICpkbWFidWYsIHN0cnVjdCBkZXZpY2UgKmRl diwKPiAgIAlpZiAoZG1hX2J1Zl9pc19keW5hbWljKGF0dGFjaC0+ZG1hYnVmKSkKPiAgIAkJZG1h X3Jlc3ZfdW5sb2NrKGF0dGFjaC0+ZG1hYnVmLT5yZXN2KTsKPiAgIAo+ICtlcnJfc3lzZnM6Cj4g ICAJZG1hX2J1Zl9kZXRhY2goZG1hYnVmLCBhdHRhY2gpOwo+ICAgCXJldHVybiBFUlJfUFRSKHJl dCk7Cj4gICB9Cj4gQEAgLTc5OSw2ICs4MjIsNyBAQCB2b2lkIGRtYV9idWZfZGV0YWNoKHN0cnVj dCBkbWFfYnVmICpkbWFidWYsIHN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaCkKPiAg IAkJCWRtYV9yZXN2X2xvY2soYXR0YWNoLT5kbWFidWYtPnJlc3YsIE5VTEwpOwo+ICAgCj4gICAJ CWRtYWJ1Zi0+b3BzLT51bm1hcF9kbWFfYnVmKGF0dGFjaCwgYXR0YWNoLT5zZ3QsIGF0dGFjaC0+ ZGlyKTsKPiArCQlkbWFfYnVmX3VwZGF0ZV9hdHRhY2htZW50X21hcF9jb3VudChhdHRhY2gsIC0x IC8qIGRlbHRhICovKTsKPiAgIAo+ICAgCQlpZiAoZG1hX2J1Zl9pc19keW5hbWljKGF0dGFjaC0+ ZG1hYnVmKSkgewo+ICAgCQkJZG1hX2J1Zl91bnBpbihhdHRhY2gpOwo+IEBAIC04MTIsNiArODM2 LDcgQEAgdm9pZCBkbWFfYnVmX2RldGFjaChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLCBzdHJ1Y3Qg ZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2gpCj4gICAJaWYgKGRtYWJ1Zi0+b3BzLT5kZXRhY2gp Cj4gICAJCWRtYWJ1Zi0+b3BzLT5kZXRhY2goZG1hYnVmLCBhdHRhY2gpOwo+ICAgCj4gKwlkbWFf YnVmX2F0dGFjaF9zdGF0c190ZWFyZG93bihhdHRhY2gpOwo+ICAgCWtmcmVlKGF0dGFjaCk7Cj4g ICB9Cj4gICBFWFBPUlRfU1lNQk9MX0dQTChkbWFfYnVmX2RldGFjaCk7Cj4gQEAgLTkzOCw2ICs5 NjMsOSBAQCBzdHJ1Y3Qgc2dfdGFibGUgKmRtYV9idWZfbWFwX2F0dGFjaG1lbnQoc3RydWN0IGRt YV9idWZfYXR0YWNobWVudCAqYXR0YWNoLAo+ICAgCX0KPiAgICNlbmRpZiAvKiBDT05GSUdfRE1B X0FQSV9ERUJVRyAqLwo+ICAgCj4gKwlpZiAoIUlTX0VSUihzZ190YWJsZSkpCj4gKwkJZG1hX2J1 Zl91cGRhdGVfYXR0YWNobWVudF9tYXBfY291bnQoYXR0YWNoLCAxIC8qIGRlbHRhICovKTsKPiAr Cj4gICAJcmV0dXJuIHNnX3RhYmxlOwo+ICAgfQo+ICAgRVhQT1JUX1NZTUJPTF9HUEwoZG1hX2J1 Zl9tYXBfYXR0YWNobWVudCk7Cj4gQEAgLTk3NSw2ICsxMDAzLDggQEAgdm9pZCBkbWFfYnVmX3Vu bWFwX2F0dGFjaG1lbnQoc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoLAo+ICAgCWlm IChkbWFfYnVmX2lzX2R5bmFtaWMoYXR0YWNoLT5kbWFidWYpICYmCj4gICAJICAgICFJU19FTkFC TEVEKENPTkZJR19ETUFCVUZfTU9WRV9OT1RJRlkpKQo+ICAgCQlkbWFfYnVmX3VucGluKGF0dGFj aCk7Cj4gKwo+ICsJZG1hX2J1Zl91cGRhdGVfYXR0YWNobWVudF9tYXBfY291bnQoYXR0YWNoLCAt MSAvKiBkZWx0YSAqLyk7Cj4gICB9Cj4gICBFWFBPUlRfU1lNQk9MX0dQTChkbWFfYnVmX3VubWFw X2F0dGFjaG1lbnQpOwo+ICAgCj4gQEAgLTE0MTIsNiArMTQ0MiwxMiBAQCBzdGF0aWMgaW5saW5l IHZvaWQgZG1hX2J1Zl91bmluaXRfZGVidWdmcyh2b2lkKQo+ICAgCj4gICBzdGF0aWMgaW50IF9f aW5pdCBkbWFfYnVmX2luaXQodm9pZCkKPiAgIHsKPiArCWludCByZXQ7Cj4gKwo+ICsJcmV0ID0g ZG1hX2J1Zl9pbml0X3N5c2ZzX3N0YXRpc3RpY3MoKTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJu IHJldDsKPiArCj4gICAJZG1hX2J1Zl9tbnQgPSBrZXJuX21vdW50KCZkbWFfYnVmX2ZzX3R5cGUp Owo+ICAgCWlmIChJU19FUlIoZG1hX2J1Zl9tbnQpKQo+ICAgCQlyZXR1cm4gUFRSX0VSUihkbWFf YnVmX21udCk7Cj4gQEAgLTE0MjcsNSArMTQ2Myw2IEBAIHN0YXRpYyB2b2lkIF9fZXhpdCBkbWFf YnVmX2RlaW5pdCh2b2lkKQo+ICAgewo+ICAgCWRtYV9idWZfdW5pbml0X2RlYnVnZnMoKTsKPiAg IAlrZXJuX3VubW91bnQoZG1hX2J1Zl9tbnQpOwo+ICsJZG1hX2J1Zl91bmluaXRfc3lzZnNfc3Rh dGlzdGljcygpOwo+ICAgfQo+ICAgX19leGl0Y2FsbChkbWFfYnVmX2RlaW5pdCk7Cj4gZGlmZiAt LWdpdCBhL2luY2x1ZGUvbGludXgvZG1hLWJ1Zi5oIGIvaW5jbHVkZS9saW51eC9kbWEtYnVmLmgK PiBpbmRleCBjZjcyNjk5Y2IyYmMuLjRhZTVjYzM4YTRhNyAxMDA2NDQKPiAtLS0gYS9pbmNsdWRl L2xpbnV4L2RtYS1idWYuaAo+ICsrKyBiL2luY2x1ZGUvbGludXgvZG1hLWJ1Zi5oCj4gQEAgLTI5 NCw2ICsyOTQsOSBAQCBzdHJ1Y3QgZG1hX2J1Zl9vcHMgewo+ICAgICogQHBvbGw6IGZvciB1c2Vy c3BhY2UgcG9sbCBzdXBwb3J0Cj4gICAgKiBAY2JfZXhjbDogZm9yIHVzZXJzcGFjZSBwb2xsIHN1 cHBvcnQKPiAgICAqIEBjYl9zaGFyZWQ6IGZvciB1c2Vyc3BhY2UgcG9sbCBzdXBwb3J0Cj4gKyAq IEBzeXNmc19lbnRyeTogZm9yIGV4cG9zaW5nIGluZm9ybWF0aW9uIGFib3V0IHRoaXMgYnVmZmVy IGluIHN5c2ZzLgo+ICsgKiBUaGUgYXR0YWNobWVudF91aWQgbWVtYmVyIG9mIEBzeXNmc19lbnRy eSBpcyBwcm90ZWN0ZWQgYnkgZG1hX3Jlc3YgbG9jawo+ICsgKiBhbmQgaXMgaW5jcmVtZW50ZWQg b24gZWFjaCBhdHRhY2guCj4gICAgKgo+ICAgICogVGhpcyByZXByZXNlbnRzIGEgc2hhcmVkIGJ1 ZmZlciwgY3JlYXRlZCBieSBjYWxsaW5nIGRtYV9idWZfZXhwb3J0KCkuIFRoZQo+ICAgICogdXNl cnNwYWNlIHJlcHJlc2VudGF0aW9uIGlzIGEgbm9ybWFsIGZpbGUgZGVzY3JpcHRvciwgd2hpY2gg Y2FuIGJlIGNyZWF0ZWQgYnkKPiBAQCAtMzI5LDYgKzMzMiwxNSBAQCBzdHJ1Y3QgZG1hX2J1ZiB7 Cj4gICAKPiAgIAkJX19wb2xsX3QgYWN0aXZlOwo+ICAgCX0gY2JfZXhjbCwgY2Jfc2hhcmVkOwo+ ICsjaWZkZWYgQ09ORklHX0RNQUJVRl9TWVNGU19TVEFUUwo+ICsJLyogZm9yIHN5c2ZzIHN0YXRz ICovCj4gKwlzdHJ1Y3QgZG1hX2J1Zl9zeXNmc19lbnRyeSB7Cj4gKwkJc3RydWN0IGtvYmplY3Qg a29iajsKPiArCQlzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmOwo+ICsJCXVuc2lnbmVkIGludCBhdHRh Y2htZW50X3VpZDsKPiArCQlzdHJ1Y3Qga3NldCAqYXR0YWNoX3N0YXRzX2tzZXQ7Cj4gKwl9ICpz eXNmc19lbnRyeTsKPiArI2VuZGlmCgpXaHkgbm90IGRpcmVjdGx5IGVtYmVkIHRoYXQ/Cgo+ICAg fTsKPiAgIAo+ICAgLyoqCj4gQEAgLTM3OCw2ICszOTAsNyBAQCBzdHJ1Y3QgZG1hX2J1Zl9hdHRh Y2hfb3BzIHsKPiAgICAqIEBpbXBvcnRlcl9vcHM6IGltcG9ydGVyIG9wZXJhdGlvbnMgZm9yIHRo aXMgYXR0YWNobWVudCwgaWYgcHJvdmlkZWQKPiAgICAqIGRtYV9idWZfbWFwL3VubWFwX2F0dGFj aG1lbnQoKSBtdXN0IGJlIGNhbGxlZCB3aXRoIHRoZSBkbWFfcmVzdiBsb2NrIGhlbGQuCj4gICAg KiBAaW1wb3J0ZXJfcHJpdjogaW1wb3J0ZXIgc3BlY2lmaWMgYXR0YWNobWVudCBkYXRhLgo+ICsg KiBAc3lzZnNfZW50cnk6IEZvciBleHBvc2luZyBpbmZvcm1hdGlvbiBhYm91dCB0aGlzIGF0dGFj aG1lbnQgaW4gc3lzZnMuCj4gICAgKgo+ICAgICogVGhpcyBzdHJ1Y3R1cmUgaG9sZHMgdGhlIGF0 dGFjaG1lbnQgaW5mb3JtYXRpb24gYmV0d2VlbiB0aGUgZG1hX2J1ZiBidWZmZXIKPiAgICAqIGFu ZCBpdHMgdXNlciBkZXZpY2UocykuIFRoZSBsaXN0IGNvbnRhaW5zIG9uZSBhdHRhY2htZW50IHN0 cnVjdCBwZXIgZGV2aWNlCj4gQEAgLTM5OCw2ICs0MTEsMTMgQEAgc3RydWN0IGRtYV9idWZfYXR0 YWNobWVudCB7Cj4gICAJY29uc3Qgc3RydWN0IGRtYV9idWZfYXR0YWNoX29wcyAqaW1wb3J0ZXJf b3BzOwo+ICAgCXZvaWQgKmltcG9ydGVyX3ByaXY7Cj4gICAJdm9pZCAqcHJpdjsKPiArI2lmZGVm IENPTkZJR19ETUFCVUZfU1lTRlNfU1RBVFMKPiArCS8qIGZvciBzeXNmcyBzdGF0cyAqLwo+ICsJ c3RydWN0IGRtYV9idWZfYXR0YWNoX3N5c2ZzX2VudHJ5IHsKPiArCQlzdHJ1Y3Qga29iamVjdCBr b2JqOwo+ICsJCXVuc2lnbmVkIGludCBtYXBfY291bnRlcjsKPiArCX0gKnN5c2ZzX2VudHJ5Owo+ ICsjZW5kaWYKClNhbWUgcXVlc3Rpb24gaGVyZS4KCkFwYXJ0IGZyb20gdGhhdCB0aGUgZ2VuZXJh bCBhcHByb2FjaCBsb29rcyBzb2xpZCB0byBtZSBub3cuCgpCdXQgc29tZWJvZHkgd2l0aCBtb3Jl IHN5c2ZzIGJhY2tncm91bmQgc2hvdWxkIGNoZWNrIGlmIGV2ZXJ5dGhpbmcgdGhlcmUgCmlzIHRo ZSByaWdodCB0aGluZyB0byBkby4KClJlZ2FyZHMsCkNocmlzdGlhbi4KCgoKPiAgIH07Cj4gICAK PiAgIC8qKgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpk cmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0 cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK