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=-26.2 required=3.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_CR_TRAILER,INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,USER_AGENT_GIT,USER_IN_DEF_DKIM_WL 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 03E68C433DB for ; Wed, 27 Jan 2021 10:32:04 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id AACBC2072C for ; Wed, 27 Jan 2021 10:32:03 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235816AbhA0KcA (ORCPT ); Wed, 27 Jan 2021 05:32:00 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:43416 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S314168AbhAZXAH (ORCPT ); Tue, 26 Jan 2021 18:00:07 -0500 Received: from mail-qv1-xf49.google.com (mail-qv1-xf49.google.com [IPv6:2607:f8b0:4864:20::f49]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B4345C06178C for ; Tue, 26 Jan 2021 14:51:58 -0800 (PST) Received: by mail-qv1-xf49.google.com with SMTP id b1so1653192qvk.17 for ; Tue, 26 Jan 2021 14:51:58 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=sender:date:message-id:mime-version:subject:from:cc :content-transfer-encoding; bh=uE2e2OS2E1G/7i2lOQq95uvgCrCFJov5e2Iib9uvchA=; b=wTpv/75XLm7qTP8od0HgwhwDlVlUeQFw+OGtLVXGXEoZtSBbiUQ8Q2+LBZJ8jSU6WV RSrm3uc0rhyrerM5G27Xy1Eh2ykoh4WuLTSkxpSkU9llMISP2KEWndhuFw2JzerTd03S 13sPsUktt1KR+4uaxX+BRnDRFjGGtCsClCtw3SDy2ty7uCU8C0utRnK3usg8V4C9+LCa 5326E9zv2nxvXy938ztZuODJL/byNuJaeVvabfVs9UVVvdsX3RX4EXKkv3lv6FF355MJ M2CtsXtNDzJ7mWrF4dPaLSTHktz5xpNLj8YQfgAlBJVruiTJCz76lDzBRXpVxykw2T3o ZSGA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:message-id:mime-version:subject:from :cc:content-transfer-encoding; bh=uE2e2OS2E1G/7i2lOQq95uvgCrCFJov5e2Iib9uvchA=; b=jMivEqt7jySbjhM4jrwg1QxHqkZ2ziYSZaM85TCk3fmN/x5O81RFw7rpW6tlyEHOoL uoNNfPc3Sqf6DogAI7lclsQxHPufElezUD7ZYVxtrkUf5B+5bHP1dzpUnVKVWGWLLjIh clhS5ca9Lf+M3GGDRp44nDK8TnjKN/eSy8mNPEg45/f5cYtER5J0s9hK+eIY4umo77VN krN8QgunugK/r8jXeEJa7/Wa9gP+MlDnNFZN2TRE2GCYtAE8l3vzYIux8r25cQb9HwhV my+IMJrrk/me+Q+CWvmcX0JTpanVW1o5iLx2llGAJJhswt2foIp3wKE5s1JnFOCF5uRw 0KeQ== X-Gm-Message-State: AOAM532ru2qZmxEeV5/n4mF/HHe2d2+mXKiY6n+HbOpa6gRDtqdg+4gu RwFC4IHw2oRqqvvSxUP9cecWaWTypOk41YILwg== X-Google-Smtp-Source: ABdhPJydV7GgC2jGZASO+sFhG7s0/GHbSsb0nr1mv9wi7Ric72ACN8X8QQK0dbF4E45gSNGlGO4U3jG5zSXx2ILsGQ== Sender: "kaleshsingh via sendgmr" X-Received: from kaleshsingh.c.googlers.com ([fda3:e722:ac3:10:14:4d90:c0a8:2145]) (user=kaleshsingh job=sendgmr) by 2002:a05:6214:54a:: with SMTP id ci10mr7902818qvb.20.1611701517597; Tue, 26 Jan 2021 14:51:57 -0800 (PST) Date: Tue, 26 Jan 2021 22:51:28 +0000 Message-Id: <20210126225138.1823266-1-kaleshsingh@google.com> Mime-Version: 1.0 X-Mailer: git-send-email 2.30.0.280.ga3ce27912f-goog Subject: [PATCH] procfs/dmabuf: Add /proc//task//dmabuf_fds From: Kalesh Singh Cc: surenb@google.com, minchan@kernel.org, gregkh@linuxfoundation.org, hridya@google.com, jannh@google.com, kernel-team@android.com, Kalesh Singh , Alexey Dobriyan , Jonathan Corbet , Sumit Semwal , "=?UTF-8?q?Christian=20K=C3=B6nig?=" , Mauro Carvalho Chehab , Andrew Morton , Michal Hocko , Kees Cook , Alexey Gladkov , Szabolcs Nagy , "Eric W. Biederman" , Daniel Jordan , Michel Lespinasse , Bernd Edlinger , Andrei Vagin , Yafang Shao , Hui Su , linux-kernel@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-doc@vger.kernel.org, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable To: unlisted-recipients:; (no To-header on input) Precedence: bulk List-ID: X-Mailing-List: linux-doc@vger.kernel.org In order to measure how much memory a process actually consumes, it is necessary to include the DMA buffer sizes for that process in the memory accounting. Since the handle to DMA buffers are raw FDs, it is important to be able to identify which processes have FD references to a DMA buffer. Currently, DMA buffer FDs can be accounted using /proc//fd/* and /proc//fdinfo -- both of which are only root readable, as follows: 1. Do a readlink on each FD. 2. If the target path begins with "/dmabuf", then the FD is a dmabuf FD. 3. stat the file to get the dmabuf inode number. 4. Read/ proc//fdinfo/, to get the DMA buffer size. Android captures per-process system memory state when certain low memory events (e.g a foreground app kill) occur, to identify potential memory hoggers. To include a process=E2=80=99s dmabuf usage as part of its memory = state, the data collection needs to be fast enough to reflect the memory state at the time of such events. Since reading /proc//fd/ and /proc//fdinfo/ requires root privileges, this approach is not suitable for production builds. Granting root privileges even to a system process increases the attack surface and is highly undesirable. Additionally this is slow as it requires many context switches for searching and getting the dma-buf info. With the addition of per-buffer dmabuf stats in sysfs [1], the DMA buffer details can be queried using their unique inode numbers. This patch proposes adding a /proc//task//dmabuf_fds interface. /proc//task//dmabuf_fds contains a list of inode numbers for every DMA buffer FD that the task has. Entries with the same inode number can appear more than once, indicating the total FD references for the associated DMA buffer. If a thread shares the same files as the group leader then its dmabuf_fds file will be empty, as these dmabufs are reported by the group leader. The interface requires PTRACE_MODE_READ_FSCRED (same as /proc//maps) and allows the efficient accounting of per-process DMA buffer usage without requiring root privileges. (See data below) Performance Comparison: ----------------------- The following data compares the time to capture the sizes of all DMA buffers referenced by FDs for all processes on an arm64 android device. ------------------------------------------------------- | Core 0 (Little) | Core 7 (Big) | ------------------------------------------------------- >From /fdinfo | 318 ms | 145 ms | ------------------------------------------------------- Inodes from | 114 ms | 27 ms | dmabuf_fds; | (2.8x ^) | (5.4x ^) | data from sysfs | | | ------------------------------------------------------- It can be inferred that in the worst case there is a 2.8x speedup for determining per-process DMA buffer FD sizes, when using the proposed interfaces. [1] https://lore.kernel.org/dri-devel/20210119225723.388883-1-hridya@google= .com/ Signed-off-by: Kalesh Singh --- Documentation/filesystems/proc.rst | 30 ++++++ drivers/dma-buf/dma-buf.c | 7 +- fs/proc/Makefile | 1 + fs/proc/base.c | 1 + fs/proc/dma_bufs.c | 159 +++++++++++++++++++++++++++++ fs/proc/internal.h | 1 + include/linux/dma-buf.h | 5 + 7 files changed, 198 insertions(+), 6 deletions(-) create mode 100644 fs/proc/dma_bufs.c diff --git a/Documentation/filesystems/proc.rst b/Documentation/filesystems= /proc.rst index 2fa69f710e2a..757dd47ab679 100644 --- a/Documentation/filesystems/proc.rst +++ b/Documentation/filesystems/proc.rst @@ -47,6 +47,7 @@ fixes/update part 1.1 Stefani Seibold June 9 2009 3.10 /proc//timerslack_ns - Task timerslack value 3.11 /proc//patch_state - Livepatch patch operation state 3.12 /proc//arch_status - Task architecture specific information + 3.13 /proc//task//dmabuf_fds - DMA buffers referenced by an FD =20 4 Configuring procfs 4.1 Mount options @@ -2131,6 +2132,35 @@ AVX512_elapsed_ms the task is unlikely an AVX512 user, but depends on the workload and the scheduling scenario, it also could be a false negative mentioned above. =20 +3.13 /proc//task//dmabuf_fds - DMA buffers referenced by an FD +------------------------------------------------------------------------- +This file exposes a list of the inode numbers for every DMA buffer +FD that the task has. + +The same inode number can appear more than once, indicating the total +FD references for the associated DMA buffer. + +The inode number can be used to lookup the DMA buffer information in +the sysfs interface /sys/kernel/dmabuf/buffers//. + +Example Output +~~~~~~~~~~~~~~ +$ cat /proc/612/task/612/dmabuf_fds +30972 30973 45678 49326 + +Permission to access this file is governed by a ptrace access mode +PTRACE_MODE_READ_FSCREDS. + +Threads can have different files when created without specifying +the CLONE_FILES flag. For this reason the interface is presented as +/proc//task//dmabuf_fds and not /proc//dmabuf_fds. +This simplifies kernel code and aggregation can be handled in +userspace. + +If a thread has the same files as its group leader, then its dmabuf_fds +file will be empty as these dmabufs are already reported by the +group leader. + Chapter 4: Configuring procfs =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D =20 diff --git a/drivers/dma-buf/dma-buf.c b/drivers/dma-buf/dma-buf.c index 9ad6397aaa97..0660c06be4c6 100644 --- a/drivers/dma-buf/dma-buf.c +++ b/drivers/dma-buf/dma-buf.c @@ -29,8 +29,6 @@ #include #include =20 -static inline int is_dma_buf_file(struct file *); - struct dma_buf_list { struct list_head head; struct mutex lock; @@ -434,10 +432,7 @@ static const struct file_operations dma_buf_fops =3D { .show_fdinfo =3D dma_buf_show_fdinfo, }; =20 -/* - * is_dma_buf_file - Check if struct file* is associated with dma_buf - */ -static inline int is_dma_buf_file(struct file *file) +int is_dma_buf_file(struct file *file) { return file->f_op =3D=3D &dma_buf_fops; } diff --git a/fs/proc/Makefile b/fs/proc/Makefile index bd08616ed8ba..91a67f43ddf4 100644 --- a/fs/proc/Makefile +++ b/fs/proc/Makefile @@ -16,6 +16,7 @@ proc-y +=3D cmdline.o proc-y +=3D consoles.o proc-y +=3D cpuinfo.o proc-y +=3D devices.o +proc-y +=3D dma_bufs.o proc-y +=3D interrupts.o proc-y +=3D loadavg.o proc-y +=3D meminfo.o diff --git a/fs/proc/base.c b/fs/proc/base.c index b3422cda2a91..af15a60b9831 100644 --- a/fs/proc/base.c +++ b/fs/proc/base.c @@ -3598,6 +3598,7 @@ static const struct pid_entry tid_base_stuff[] =3D { #ifdef CONFIG_SECCOMP_CACHE_DEBUG ONE("seccomp_cache", S_IRUSR, proc_pid_seccomp_cache), #endif + REG("dmabuf_fds", 0444, proc_tid_dmabuf_fds_operations), }; =20 static int proc_tid_base_readdir(struct file *file, struct dir_context *ct= x) diff --git a/fs/proc/dma_bufs.c b/fs/proc/dma_bufs.c new file mode 100644 index 000000000000..46ea9cf968ed --- /dev/null +++ b/fs/proc/dma_bufs.c @@ -0,0 +1,159 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Per-process DMA-BUF Stats + * + * Copyright (C) 2021 Google LLC. + */ + +#include +#include +#include +#include + +#include "internal.h" + +struct dmabuf_fds_private { + struct inode *inode; + struct task_struct *task; + struct file *dmabuf_file; +}; + +static loff_t *next_dmabuf(struct dmabuf_fds_private *priv, + loff_t *pos) +{ + struct fdtable *fdt; + struct file *file; + + rcu_read_lock(); + fdt =3D files_fdtable(priv->task->files); + for (; *pos < fdt->max_fds; ++*pos) { + file =3D files_lookup_fd_rcu(priv->task->files, (unsigned int) *pos); + if (file && is_dma_buf_file(file) && get_file_rcu(file)) { + priv->dmabuf_file =3D file; + break; + } + } + if (*pos >=3D fdt->max_fds) + pos =3D NULL; + rcu_read_unlock(); + + return pos; +} + +static void *dmabuf_fds_seq_start(struct seq_file *s, loff_t *pos) +{ + struct dmabuf_fds_private *priv =3D s->private; + struct files_struct *group_leader_files; + + priv->task =3D get_proc_task(priv->inode); + + if (!priv->task) + return ERR_PTR(-ESRCH); + + /* Hold task lock for duration that files need to be stable */ + task_lock(priv->task); + + /* + * If this task is not the group leader but shares the same files, leave = file empty. + * These dmabufs are already reported in the group leader's dmabuf_fds. + */ + group_leader_files =3D priv->task->group_leader->files; + if (priv->task !=3D priv->task->group_leader && priv->task->files =3D=3D = group_leader_files) { + task_unlock(priv->task); + put_task_struct(priv->task); + priv->task =3D NULL; + return NULL; + } + + return next_dmabuf(priv, pos); +} + +static void *dmabuf_fds_seq_next(struct seq_file *s, void *v, loff_t *pos) +{ + ++*pos; + return next_dmabuf(s->private, pos); +} + +static void dmabuf_fds_seq_stop(struct seq_file *s, void *v) +{ + struct dmabuf_fds_private *priv =3D s->private; + + if (priv->task) { + task_unlock(priv->task); + put_task_struct(priv->task); + + } + if (priv->dmabuf_file) + fput(priv->dmabuf_file); +} + +static int dmabuf_fds_seq_show(struct seq_file *s, void *v) +{ + struct dmabuf_fds_private *priv =3D s->private; + struct file *file =3D priv->dmabuf_file; + struct dma_buf *dmabuf =3D file->private_data; + + if (!dmabuf) + return -ESRCH; + + seq_printf(s, "%8lu ", file_inode(file)->i_ino); + + fput(priv->dmabuf_file); + priv->dmabuf_file =3D NULL; + + return 0; +} + +static const struct seq_operations proc_tid_dmabuf_fds_seq_ops =3D { + .start =3D dmabuf_fds_seq_start, + .next =3D dmabuf_fds_seq_next, + .stop =3D dmabuf_fds_seq_stop, + .show =3D dmabuf_fds_seq_show +}; + +static int proc_dmabuf_fds_open(struct inode *inode, struct file *file, + const struct seq_operations *ops) +{ + struct dmabuf_fds_private *priv; + struct task_struct *task; + bool allowed =3D false; + + task =3D get_proc_task(inode); + if (!task) + return -ESRCH; + + allowed =3D ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS); + put_task_struct(task); + + if (!allowed) + return -EACCES; + + priv =3D __seq_open_private(file, ops, sizeof(*priv)); + if (!priv) + return -ENOMEM; + + priv->inode =3D inode; + priv->task =3D NULL; + priv->dmabuf_file =3D NULL; + + return 0; +} + +static int proc_dmabuf_fds_release(struct inode *inode, struct file *file) +{ + return seq_release_private(inode, file); +} + +static int tid_dmabuf_fds_open(struct inode *inode, struct file *file) +{ + return proc_dmabuf_fds_open(inode, file, + &proc_tid_dmabuf_fds_seq_ops); +} + +const struct file_operations proc_tid_dmabuf_fds_operations =3D { + .open =3D tid_dmabuf_fds_open, + .read =3D seq_read, + .llseek =3D seq_lseek, + .release =3D proc_dmabuf_fds_release, +}; + diff --git a/fs/proc/internal.h b/fs/proc/internal.h index f60b379dcdc7..4ca74220db9c 100644 --- a/fs/proc/internal.h +++ b/fs/proc/internal.h @@ -303,6 +303,7 @@ extern const struct file_operations proc_pid_smaps_oper= ations; extern const struct file_operations proc_pid_smaps_rollup_operations; extern const struct file_operations proc_clear_refs_operations; extern const struct file_operations proc_pagemap_operations; +extern const struct file_operations proc_tid_dmabuf_fds_operations; =20 extern unsigned long task_vsize(struct mm_struct *); extern unsigned long task_statm(struct mm_struct *, diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h index cf72699cb2bc..087e11f7f193 100644 --- a/include/linux/dma-buf.h +++ b/include/linux/dma-buf.h @@ -27,6 +27,11 @@ struct device; struct dma_buf; struct dma_buf_attachment; =20 +/** + * Check if struct file* is associated with dma_buf. + */ +int is_dma_buf_file(struct file *file); + /** * struct dma_buf_ops - operations possible on struct dma_buf * @vmap: [optional] creates a virtual mapping for the buffer into kernel --=20 2.30.0.280.ga3ce27912f-goog 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.5 required=3.0 tests=BAYES_00, DKIM_ADSP_CUSTOM_MED,DKIM_INVALID,DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_CR_TRAILER,INCLUDES_PATCH,MAILING_LIST_MULTI,MISSING_HEADERS, 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 CD264C433E0 for ; Wed, 27 Jan 2021 08:30:11 +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 73F0A2073C for ; Wed, 27 Jan 2021 08:30:11 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 73F0A2073C Authentication-Results: mail.kernel.org; dmarc=fail (p=reject dis=none) header.from=google.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 003986E5CE; Wed, 27 Jan 2021 08:29:49 +0000 (UTC) Received: from mail-qk1-x74a.google.com (mail-qk1-x74a.google.com [IPv6:2607:f8b0:4864:20::74a]) by gabe.freedesktop.org (Postfix) with ESMTPS id AB25A89AB7 for ; Tue, 26 Jan 2021 22:51:58 +0000 (UTC) Received: by mail-qk1-x74a.google.com with SMTP id 70so96647qkh.4 for ; Tue, 26 Jan 2021 14:51:58 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=sender:date:message-id:mime-version:subject:from:cc :content-transfer-encoding; bh=uE2e2OS2E1G/7i2lOQq95uvgCrCFJov5e2Iib9uvchA=; b=wTpv/75XLm7qTP8od0HgwhwDlVlUeQFw+OGtLVXGXEoZtSBbiUQ8Q2+LBZJ8jSU6WV RSrm3uc0rhyrerM5G27Xy1Eh2ykoh4WuLTSkxpSkU9llMISP2KEWndhuFw2JzerTd03S 13sPsUktt1KR+4uaxX+BRnDRFjGGtCsClCtw3SDy2ty7uCU8C0utRnK3usg8V4C9+LCa 5326E9zv2nxvXy938ztZuODJL/byNuJaeVvabfVs9UVVvdsX3RX4EXKkv3lv6FF355MJ M2CtsXtNDzJ7mWrF4dPaLSTHktz5xpNLj8YQfgAlBJVruiTJCz76lDzBRXpVxykw2T3o ZSGA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:message-id:mime-version:subject:from :cc:content-transfer-encoding; bh=uE2e2OS2E1G/7i2lOQq95uvgCrCFJov5e2Iib9uvchA=; b=XXkkNBzfybB3C9SbcuaMQ3PBmXnDW9fA3yf+SlSwYeBBMn8NjE3xCxwgeq8H5QziZG Y7twDvNUHw1zs5OvkNg+5HXme0Sa2qGgeRm05BQSVfY5/8Ey3cS4lDF1oxMmNtow8EKe LgWhr6D8hZuKaaRDGnVIct5CjyN55i1nxG2SpmwINEVn55Nug/BaJQmkuyHU/EFcFRrz Uyd7e7TpsleEjmD9fW/TdTrXTYUOQ9fD3Akx7TrqZkknvte5aRRyzV0VA45n8yj1V19S vyCLx7XeI74Z+bJ+SHzroP7Bl9GCmtNpgFGB6oimaJCz9wXUeqrB8MKn2ATg1Pi60Yio cJMA== X-Gm-Message-State: AOAM530DITW/J+OAaUqtG49TlIY/hRZjD4+P07w8O3P3DNDA94lmlsn7 ClUkqHLDi2HmHzITa9s/GVpNPTQcUTDD1wYuUA== X-Google-Smtp-Source: ABdhPJydV7GgC2jGZASO+sFhG7s0/GHbSsb0nr1mv9wi7Ric72ACN8X8QQK0dbF4E45gSNGlGO4U3jG5zSXx2ILsGQ== X-Received: from kaleshsingh.c.googlers.com ([fda3:e722:ac3:10:14:4d90:c0a8:2145]) (user=kaleshsingh job=sendgmr) by 2002:a05:6214:54a:: with SMTP id ci10mr7902818qvb.20.1611701517597; Tue, 26 Jan 2021 14:51:57 -0800 (PST) Date: Tue, 26 Jan 2021 22:51:28 +0000 Message-Id: <20210126225138.1823266-1-kaleshsingh@google.com> Mime-Version: 1.0 X-Mailer: git-send-email 2.30.0.280.ga3ce27912f-goog Subject: [PATCH] procfs/dmabuf: Add /proc//task//dmabuf_fds From: Kalesh Singh X-Mailman-Approved-At: Wed, 27 Jan 2021 08:29:46 +0000 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: Michal Hocko , linux-doc@vger.kernel.org, Szabolcs Nagy , dri-devel@lists.freedesktop.org, Andrei Vagin , Kalesh Singh , Hui Su , Michel Lespinasse , Jonathan Corbet , Mauro Carvalho Chehab , Daniel Jordan , kernel-team@android.com, Alexey Dobriyan , linux-media@vger.kernel.org, Kees Cook , jannh@google.com, linaro-mm-sig@lists.linaro.org, linux-fsdevel@vger.kernel.org, Bernd Edlinger , surenb@google.com, Alexey Gladkov , linux-kernel@vger.kernel.org, minchan@kernel.org, Yafang Shao , "Eric W. Biederman" , gregkh@linuxfoundation.org, hridya@google.com, Andrew Morton , =?UTF-8?q?Christian=20K=C3=B6nig?= Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" SW4gb3JkZXIgdG8gbWVhc3VyZSBob3cgbXVjaCBtZW1vcnkgYSBwcm9jZXNzIGFjdHVhbGx5IGNv bnN1bWVzLCBpdCBpcwpuZWNlc3NhcnkgdG8gaW5jbHVkZSB0aGUgRE1BIGJ1ZmZlciBzaXplcyBm b3IgdGhhdCBwcm9jZXNzIGluIHRoZSBtZW1vcnkKYWNjb3VudGluZy4gU2luY2UgdGhlIGhhbmRs ZSB0byBETUEgYnVmZmVycyBhcmUgcmF3IEZEcywgaXQgaXMgaW1wb3J0YW50CnRvIGJlIGFibGUg dG8gaWRlbnRpZnkgd2hpY2ggcHJvY2Vzc2VzIGhhdmUgRkQgcmVmZXJlbmNlcyB0byBhIERNQSBi dWZmZXIuCgpDdXJyZW50bHksIERNQSBidWZmZXIgRkRzIGNhbiBiZSBhY2NvdW50ZWQgdXNpbmcg L3Byb2MvPHBpZD4vZmQvKiBhbmQKL3Byb2MvPHBpZD4vZmRpbmZvIC0tIGJvdGggb2Ygd2hpY2gg YXJlIG9ubHkgcm9vdCByZWFkYWJsZSwgYXMgZm9sbG93czoKICAxLiBEbyBhIHJlYWRsaW5rIG9u IGVhY2ggRkQuCiAgMi4gSWYgdGhlIHRhcmdldCBwYXRoIGJlZ2lucyB3aXRoICIvZG1hYnVmIiwg dGhlbiB0aGUgRkQgaXMgYSBkbWFidWYgRkQuCiAgMy4gc3RhdCB0aGUgZmlsZSB0byBnZXQgdGhl IGRtYWJ1ZiBpbm9kZSBudW1iZXIuCiAgNC4gUmVhZC8gcHJvYy88cGlkPi9mZGluZm8vPGZkPiwg dG8gZ2V0IHRoZSBETUEgYnVmZmVyIHNpemUuCgpBbmRyb2lkIGNhcHR1cmVzIHBlci1wcm9jZXNz IHN5c3RlbSBtZW1vcnkgc3RhdGUgd2hlbiBjZXJ0YWluIGxvdyBtZW1vcnkKZXZlbnRzIChlLmcg YSBmb3JlZ3JvdW5kIGFwcCBraWxsKSBvY2N1ciwgdG8gaWRlbnRpZnkgcG90ZW50aWFsIG1lbW9y eQpob2dnZXJzLiBUbyBpbmNsdWRlIGEgcHJvY2Vzc+KAmXMgZG1hYnVmIHVzYWdlIGFzIHBhcnQg b2YgaXRzIG1lbW9yeSBzdGF0ZSwKdGhlIGRhdGEgY29sbGVjdGlvbiBuZWVkcyB0byBiZSBmYXN0 IGVub3VnaCB0byByZWZsZWN0IHRoZSBtZW1vcnkgc3RhdGUgYXQKdGhlIHRpbWUgb2Ygc3VjaCBl dmVudHMuCgpTaW5jZSByZWFkaW5nIC9wcm9jLzxwaWQ+L2ZkLyBhbmQgL3Byb2MvPHBpZD4vZmRp bmZvLyByZXF1aXJlcyByb290CnByaXZpbGVnZXMsIHRoaXMgYXBwcm9hY2ggaXMgbm90IHN1aXRh YmxlIGZvciBwcm9kdWN0aW9uIGJ1aWxkcy4gR3JhbnRpbmcKcm9vdCBwcml2aWxlZ2VzIGV2ZW4g dG8gYSBzeXN0ZW0gcHJvY2VzcyBpbmNyZWFzZXMgdGhlIGF0dGFjayBzdXJmYWNlIGFuZAppcyBo aWdobHkgdW5kZXNpcmFibGUuIEFkZGl0aW9uYWxseSB0aGlzIGlzIHNsb3cgYXMgaXQgcmVxdWly ZXMgbWFueQpjb250ZXh0IHN3aXRjaGVzIGZvciBzZWFyY2hpbmcgYW5kIGdldHRpbmcgdGhlIGRt YS1idWYgaW5mby4KCldpdGggdGhlIGFkZGl0aW9uIG9mIHBlci1idWZmZXIgZG1hYnVmIHN0YXRz IGluIHN5c2ZzIFsxXSwgdGhlIERNQSBidWZmZXIKZGV0YWlscyBjYW4gYmUgcXVlcmllZCB1c2lu ZyB0aGVpciB1bmlxdWUgaW5vZGUgbnVtYmVycy4KClRoaXMgcGF0Y2ggcHJvcG9zZXMgYWRkaW5n IGEgL3Byb2MvPHBpZD4vdGFzay88dGlkPi9kbWFidWZfZmRzIGludGVyZmFjZS4KCi9wcm9jLzxw aWQ+L3Rhc2svPHRpZD4vZG1hYnVmX2ZkcyBjb250YWlucyBhIGxpc3Qgb2YgaW5vZGUgbnVtYmVy cyBmb3IKZXZlcnkgRE1BIGJ1ZmZlciBGRCB0aGF0IHRoZSB0YXNrIGhhcy4gRW50cmllcyB3aXRo IHRoZSBzYW1lIGlub2RlCm51bWJlciBjYW4gYXBwZWFyIG1vcmUgdGhhbiBvbmNlLCBpbmRpY2F0 aW5nIHRoZSB0b3RhbCBGRCByZWZlcmVuY2VzCmZvciB0aGUgYXNzb2NpYXRlZCBETUEgYnVmZmVy LgoKSWYgYSB0aHJlYWQgc2hhcmVzIHRoZSBzYW1lIGZpbGVzIGFzIHRoZSBncm91cCBsZWFkZXIg dGhlbiBpdHMKZG1hYnVmX2ZkcyBmaWxlIHdpbGwgYmUgZW1wdHksIGFzIHRoZXNlIGRtYWJ1ZnMg YXJlIHJlcG9ydGVkIGJ5IHRoZQpncm91cCBsZWFkZXIuCgpUaGUgaW50ZXJmYWNlIHJlcXVpcmVz IFBUUkFDRV9NT0RFX1JFQURfRlNDUkVEIChzYW1lIGFzIC9wcm9jLzxwaWQ+L21hcHMpCmFuZCBh bGxvd3MgdGhlIGVmZmljaWVudCBhY2NvdW50aW5nIG9mIHBlci1wcm9jZXNzIERNQSBidWZmZXIg dXNhZ2Ugd2l0aG91dApyZXF1aXJpbmcgcm9vdCBwcml2aWxlZ2VzLiAoU2VlIGRhdGEgYmVsb3cp CgpQZXJmb3JtYW5jZSBDb21wYXJpc29uOgotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQoKVGhlIGZv bGxvd2luZyBkYXRhIGNvbXBhcmVzIHRoZSB0aW1lIHRvIGNhcHR1cmUgdGhlIHNpemVzIG9mIGFs bCBETUEKYnVmZmVycyByZWZlcmVuY2VkIGJ5IEZEcyBmb3IgYWxsIHByb2Nlc3NlcyBvbiBhbiBh cm02NCBhbmRyb2lkIGRldmljZS4KCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0KICAgICAgICAgICAgICAgICAgIHwgIENvcmUgMCAoTGl0dGxl KSAgfCAgQ29yZSA3IChCaWcpIHwKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLQpGcm9tIDxwaWQ+L2ZkaW5mbyAgfCAgICAgIDMxOCBtcyAgICAg ICB8ICAgICAxNDUgbXMgICAgfAotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tCklub2RlcyBmcm9tICAgICAgICB8ICAgICAgMTE0IG1zICAgICAg IHwgICAgICAyNyBtcyAgICB8CmRtYWJ1Zl9mZHM7ICAgICAgICB8ICAgICgyLjh4ICBeKSAgICAg IHwgICAoNS40eCAgXikgICB8CmRhdGEgZnJvbSBzeXNmcyAgICB8ICAgICAgICAgICAgICAgICAg IHwgICAgICAgICAgICAgICB8Ci0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0KCkl0IGNhbiBiZSBpbmZlcnJlZCB0aGF0IGluIHRoZSB3b3JzdCBj YXNlIHRoZXJlIGlzIGEgMi44eCBzcGVlZHVwIGZvcgpkZXRlcm1pbmluZyBwZXItcHJvY2VzcyBE TUEgYnVmZmVyIEZEIHNpemVzLCB3aGVuIHVzaW5nIHRoZSBwcm9wb3NlZAppbnRlcmZhY2VzLgoK WzFdIGh0dHBzOi8vbG9yZS5rZXJuZWwub3JnL2RyaS1kZXZlbC8yMDIxMDExOTIyNTcyMy4zODg4 ODMtMS1ocmlkeWFAZ29vZ2xlLmNvbS8KClNpZ25lZC1vZmYtYnk6IEthbGVzaCBTaW5naCA8a2Fs ZXNoc2luZ2hAZ29vZ2xlLmNvbT4KLS0tCiBEb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL3Byb2Mu cnN0IHwgIDMwICsrKysrKwogZHJpdmVycy9kbWEtYnVmL2RtYS1idWYuYyAgICAgICAgICB8ICAg NyArLQogZnMvcHJvYy9NYWtlZmlsZSAgICAgICAgICAgICAgICAgICB8ICAgMSArCiBmcy9wcm9j L2Jhc2UuYyAgICAgICAgICAgICAgICAgICAgIHwgICAxICsKIGZzL3Byb2MvZG1hX2J1ZnMuYyAg ICAgICAgICAgICAgICAgfCAxNTkgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKIGZzL3By b2MvaW50ZXJuYWwuaCAgICAgICAgICAgICAgICAgfCAgIDEgKwogaW5jbHVkZS9saW51eC9kbWEt YnVmLmggICAgICAgICAgICB8ICAgNSArCiA3IGZpbGVzIGNoYW5nZWQsIDE5OCBpbnNlcnRpb25z KCspLCA2IGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGZzL3Byb2MvZG1hX2J1ZnMu YwoKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvcHJvYy5yc3QgYi9Eb2N1 bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL3Byb2MucnN0CmluZGV4IDJmYTY5ZjcxMGUyYS4uNzU3ZGQ0 N2FiNjc5IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL3Byb2MucnN0Cisr KyBiL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvcHJvYy5yc3QKQEAgLTQ3LDYgKzQ3LDcgQEAg Zml4ZXMvdXBkYXRlIHBhcnQgMS4xICBTdGVmYW5pIFNlaWJvbGQgPHN0ZWZhbmlAc2VpYm9sZC5u ZXQ+ICAgIEp1bmUgOSAyMDA5CiAgIDMuMTAgIC9wcm9jLzxwaWQ+L3RpbWVyc2xhY2tfbnMgLSBU YXNrIHRpbWVyc2xhY2sgdmFsdWUKICAgMy4xMQkvcHJvYy88cGlkPi9wYXRjaF9zdGF0ZSAtIExp dmVwYXRjaCBwYXRjaCBvcGVyYXRpb24gc3RhdGUKICAgMy4xMgkvcHJvYy88cGlkPi9hcmNoX3N0 YXR1cyAtIFRhc2sgYXJjaGl0ZWN0dXJlIHNwZWNpZmljIGluZm9ybWF0aW9uCisgIDMuMTMJL3By b2MvPHBpZD4vdGFzay88dGlkPi9kbWFidWZfZmRzIC0gRE1BIGJ1ZmZlcnMgcmVmZXJlbmNlZCBi eSBhbiBGRAogCiAgIDQJQ29uZmlndXJpbmcgcHJvY2ZzCiAgIDQuMQlNb3VudCBvcHRpb25zCkBA IC0yMTMxLDYgKzIxMzIsMzUgQEAgQVZYNTEyX2VsYXBzZWRfbXMKICAgdGhlIHRhc2sgaXMgdW5s aWtlbHkgYW4gQVZYNTEyIHVzZXIsIGJ1dCBkZXBlbmRzIG9uIHRoZSB3b3JrbG9hZCBhbmQgdGhl CiAgIHNjaGVkdWxpbmcgc2NlbmFyaW8sIGl0IGFsc28gY291bGQgYmUgYSBmYWxzZSBuZWdhdGl2 ZSBtZW50aW9uZWQgYWJvdmUuCiAKKzMuMTMgL3Byb2MvPHBpZD4vdGFzay88dGlkPi9kbWFidWZf ZmRzIC0gRE1BIGJ1ZmZlcnMgcmVmZXJlbmNlZCBieSBhbiBGRAorLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQor VGhpcyBmaWxlICBleHBvc2VzIGEgbGlzdCBvZiB0aGUgaW5vZGUgbnVtYmVycyBmb3IgZXZlcnkg RE1BIGJ1ZmZlcgorRkQgdGhhdCB0aGUgdGFzayBoYXMuCisKK1RoZSBzYW1lIGlub2RlIG51bWJl ciBjYW4gYXBwZWFyIG1vcmUgdGhhbiBvbmNlLCBpbmRpY2F0aW5nIHRoZSB0b3RhbAorRkQgcmVm ZXJlbmNlcyBmb3IgdGhlIGFzc29jaWF0ZWQgRE1BIGJ1ZmZlci4KKworVGhlIGlub2RlIG51bWJl ciBjYW4gYmUgdXNlZCB0byBsb29rdXAgdGhlIERNQSBidWZmZXIgaW5mb3JtYXRpb24gaW4KK3Ro ZSBzeXNmcyBpbnRlcmZhY2UgL3N5cy9rZXJuZWwvZG1hYnVmL2J1ZmZlcnMvPGlub2RlLW5vPi8u CisKK0V4YW1wbGUgT3V0cHV0Cit+fn5+fn5+fn5+fn5+fgorJCBjYXQgL3Byb2MvNjEyL3Rhc2sv NjEyL2RtYWJ1Zl9mZHMKKzMwOTcyIDMwOTczIDQ1Njc4IDQ5MzI2CisKK1Blcm1pc3Npb24gdG8g YWNjZXNzIHRoaXMgZmlsZSBpcyBnb3Zlcm5lZCBieSBhIHB0cmFjZSBhY2Nlc3MgbW9kZQorUFRS QUNFX01PREVfUkVBRF9GU0NSRURTLgorCitUaHJlYWRzIGNhbiBoYXZlIGRpZmZlcmVudCBmaWxl cyB3aGVuIGNyZWF0ZWQgd2l0aG91dCBzcGVjaWZ5aW5nCit0aGUgQ0xPTkVfRklMRVMgZmxhZy4g Rm9yIHRoaXMgcmVhc29uIHRoZSBpbnRlcmZhY2UgaXMgcHJlc2VudGVkIGFzCisvcHJvYy88cGlk Pi90YXNrLzx0aWQ+L2RtYWJ1Zl9mZHMgYW5kIG5vdCAvcHJvYy88cGlkPi9kbWFidWZfZmRzLgor VGhpcyBzaW1wbGlmaWVzIGtlcm5lbCBjb2RlIGFuZCBhZ2dyZWdhdGlvbiBjYW4gYmUgaGFuZGxl ZCBpbgordXNlcnNwYWNlLgorCitJZiBhIHRocmVhZCBoYXMgdGhlIHNhbWUgZmlsZXMgYXMgaXRz IGdyb3VwIGxlYWRlciwgdGhlbiBpdHMgZG1hYnVmX2ZkcworZmlsZSB3aWxsIGJlIGVtcHR5IGFz IHRoZXNlIGRtYWJ1ZnMgYXJlIGFscmVhZHkgcmVwb3J0ZWQgYnkgdGhlCitncm91cCBsZWFkZXIu CisKIENoYXB0ZXIgNDogQ29uZmlndXJpbmcgcHJvY2ZzCiA9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2RtYS1idWYvZG1hLWJ1Zi5jIGIvZHJpdmVy cy9kbWEtYnVmL2RtYS1idWYuYwppbmRleCA5YWQ2Mzk3YWFhOTcuLjA2NjBjMDZiZTRjNiAxMDA2 NDQKLS0tIGEvZHJpdmVycy9kbWEtYnVmL2RtYS1idWYuYworKysgYi9kcml2ZXJzL2RtYS1idWYv ZG1hLWJ1Zi5jCkBAIC0yOSw4ICsyOSw2IEBACiAjaW5jbHVkZSA8dWFwaS9saW51eC9kbWEtYnVm Lmg+CiAjaW5jbHVkZSA8dWFwaS9saW51eC9tYWdpYy5oPgogCi1zdGF0aWMgaW5saW5lIGludCBp c19kbWFfYnVmX2ZpbGUoc3RydWN0IGZpbGUgKik7Ci0KIHN0cnVjdCBkbWFfYnVmX2xpc3Qgewog CXN0cnVjdCBsaXN0X2hlYWQgaGVhZDsKIAlzdHJ1Y3QgbXV0ZXggbG9jazsKQEAgLTQzNCwxMCAr NDMyLDcgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgZG1hX2J1Zl9mb3Bz ID0gewogCS5zaG93X2ZkaW5mbwk9IGRtYV9idWZfc2hvd19mZGluZm8sCiB9OwogCi0vKgotICog aXNfZG1hX2J1Zl9maWxlIC0gQ2hlY2sgaWYgc3RydWN0IGZpbGUqIGlzIGFzc29jaWF0ZWQgd2l0 aCBkbWFfYnVmCi0gKi8KLXN0YXRpYyBpbmxpbmUgaW50IGlzX2RtYV9idWZfZmlsZShzdHJ1Y3Qg ZmlsZSAqZmlsZSkKK2ludCBpc19kbWFfYnVmX2ZpbGUoc3RydWN0IGZpbGUgKmZpbGUpCiB7CiAJ cmV0dXJuIGZpbGUtPmZfb3AgPT0gJmRtYV9idWZfZm9wczsKIH0KZGlmZiAtLWdpdCBhL2ZzL3By b2MvTWFrZWZpbGUgYi9mcy9wcm9jL01ha2VmaWxlCmluZGV4IGJkMDg2MTZlZDhiYS4uOTFhNjdm NDNkZGY0IDEwMDY0NAotLS0gYS9mcy9wcm9jL01ha2VmaWxlCisrKyBiL2ZzL3Byb2MvTWFrZWZp bGUKQEAgLTE2LDYgKzE2LDcgQEAgcHJvYy15CSs9IGNtZGxpbmUubwogcHJvYy15CSs9IGNvbnNv bGVzLm8KIHByb2MteQkrPSBjcHVpbmZvLm8KIHByb2MteQkrPSBkZXZpY2VzLm8KK3Byb2MteQkr PSBkbWFfYnVmcy5vCiBwcm9jLXkJKz0gaW50ZXJydXB0cy5vCiBwcm9jLXkJKz0gbG9hZGF2Zy5v CiBwcm9jLXkJKz0gbWVtaW5mby5vCmRpZmYgLS1naXQgYS9mcy9wcm9jL2Jhc2UuYyBiL2ZzL3By b2MvYmFzZS5jCmluZGV4IGIzNDIyY2RhMmE5MS4uYWYxNWE2MGI5ODMxIDEwMDY0NAotLS0gYS9m cy9wcm9jL2Jhc2UuYworKysgYi9mcy9wcm9jL2Jhc2UuYwpAQCAtMzU5OCw2ICszNTk4LDcgQEAg c3RhdGljIGNvbnN0IHN0cnVjdCBwaWRfZW50cnkgdGlkX2Jhc2Vfc3R1ZmZbXSA9IHsKICNpZmRl ZiBDT05GSUdfU0VDQ09NUF9DQUNIRV9ERUJVRwogCU9ORSgic2VjY29tcF9jYWNoZSIsIFNfSVJV U1IsIHByb2NfcGlkX3NlY2NvbXBfY2FjaGUpLAogI2VuZGlmCisJUkVHKCJkbWFidWZfZmRzIiwg MDQ0NCwgcHJvY190aWRfZG1hYnVmX2Zkc19vcGVyYXRpb25zKSwKIH07CiAKIHN0YXRpYyBpbnQg cHJvY190aWRfYmFzZV9yZWFkZGlyKHN0cnVjdCBmaWxlICpmaWxlLCBzdHJ1Y3QgZGlyX2NvbnRl eHQgKmN0eCkKZGlmZiAtLWdpdCBhL2ZzL3Byb2MvZG1hX2J1ZnMuYyBiL2ZzL3Byb2MvZG1hX2J1 ZnMuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjQ2ZWE5Y2Y5Njhl ZAotLS0gL2Rldi9udWxsCisrKyBiL2ZzL3Byb2MvZG1hX2J1ZnMuYwpAQCAtMCwwICsxLDE1OSBA QAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKKy8qCisgKiBQZXItcHJvY2Vz cyBETUEtQlVGIFN0YXRzCisgKgorICogQ29weXJpZ2h0IChDKSAyMDIxIEdvb2dsZSBMTEMuCisg Ki8KKworI2luY2x1ZGUgPGxpbnV4L2RtYS1idWYuaD4KKyNpbmNsdWRlIDxsaW51eC9mZHRhYmxl Lmg+CisjaW5jbHVkZSA8bGludXgvcHRyYWNlLmg+CisjaW5jbHVkZSA8bGludXgvc2VxX2ZpbGUu aD4KKworI2luY2x1ZGUgImludGVybmFsLmgiCisKK3N0cnVjdCBkbWFidWZfZmRzX3ByaXZhdGUg eworCXN0cnVjdCBpbm9kZSAqaW5vZGU7CisJc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrOworCXN0 cnVjdCBmaWxlICpkbWFidWZfZmlsZTsKK307CisKK3N0YXRpYyBsb2ZmX3QgKm5leHRfZG1hYnVm KHN0cnVjdCBkbWFidWZfZmRzX3ByaXZhdGUgKnByaXYsCisJCWxvZmZfdCAqcG9zKQoreworCXN0 cnVjdCBmZHRhYmxlICpmZHQ7CisJc3RydWN0IGZpbGUgKmZpbGU7CisKKwlyY3VfcmVhZF9sb2Nr KCk7CisJZmR0ID0gZmlsZXNfZmR0YWJsZShwcml2LT50YXNrLT5maWxlcyk7CisJZm9yICg7ICpw b3MgPCBmZHQtPm1heF9mZHM7ICsrKnBvcykgeworCQlmaWxlID0gZmlsZXNfbG9va3VwX2ZkX3Jj dShwcml2LT50YXNrLT5maWxlcywgKHVuc2lnbmVkIGludCkgKnBvcyk7CisJCWlmIChmaWxlICYm IGlzX2RtYV9idWZfZmlsZShmaWxlKSAmJiBnZXRfZmlsZV9yY3UoZmlsZSkpIHsKKwkJCXByaXYt PmRtYWJ1Zl9maWxlID0gZmlsZTsKKwkJCWJyZWFrOworCQl9CisJfQorCWlmICgqcG9zID49IGZk dC0+bWF4X2ZkcykKKwkJcG9zID0gTlVMTDsKKwlyY3VfcmVhZF91bmxvY2soKTsKKworCXJldHVy biBwb3M7Cit9CisKK3N0YXRpYyB2b2lkICpkbWFidWZfZmRzX3NlcV9zdGFydChzdHJ1Y3Qgc2Vx X2ZpbGUgKnMsIGxvZmZfdCAqcG9zKQoreworCXN0cnVjdCBkbWFidWZfZmRzX3ByaXZhdGUgKnBy aXYgPSBzLT5wcml2YXRlOworCXN0cnVjdCBmaWxlc19zdHJ1Y3QgKmdyb3VwX2xlYWRlcl9maWxl czsKKworCXByaXYtPnRhc2sgPSBnZXRfcHJvY190YXNrKHByaXYtPmlub2RlKTsKKworCWlmICgh cHJpdi0+dGFzaykKKwkJcmV0dXJuIEVSUl9QVFIoLUVTUkNIKTsKKworCS8qIEhvbGQgdGFzayBs b2NrIGZvciBkdXJhdGlvbiB0aGF0IGZpbGVzIG5lZWQgdG8gYmUgc3RhYmxlICovCisJdGFza19s b2NrKHByaXYtPnRhc2spOworCisJLyoKKwkgKiBJZiB0aGlzIHRhc2sgaXMgbm90IHRoZSBncm91 cCBsZWFkZXIgYnV0IHNoYXJlcyB0aGUgc2FtZSBmaWxlcywgbGVhdmUgZmlsZSBlbXB0eS4KKwkg KiBUaGVzZSBkbWFidWZzIGFyZSBhbHJlYWR5IHJlcG9ydGVkIGluIHRoZSBncm91cCBsZWFkZXIn cyBkbWFidWZfZmRzLgorCSAqLworCWdyb3VwX2xlYWRlcl9maWxlcyA9IHByaXYtPnRhc2stPmdy b3VwX2xlYWRlci0+ZmlsZXM7CisJaWYgKHByaXYtPnRhc2sgIT0gcHJpdi0+dGFzay0+Z3JvdXBf bGVhZGVyICYmIHByaXYtPnRhc2stPmZpbGVzID09IGdyb3VwX2xlYWRlcl9maWxlcykgeworCQl0 YXNrX3VubG9jayhwcml2LT50YXNrKTsKKwkJcHV0X3Rhc2tfc3RydWN0KHByaXYtPnRhc2spOwor CQlwcml2LT50YXNrID0gTlVMTDsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJcmV0dXJuIG5leHRf ZG1hYnVmKHByaXYsIHBvcyk7Cit9CisKK3N0YXRpYyB2b2lkICpkbWFidWZfZmRzX3NlcV9uZXh0 KHN0cnVjdCBzZXFfZmlsZSAqcywgdm9pZCAqdiwgbG9mZl90ICpwb3MpCit7CisJKysqcG9zOwor CXJldHVybiBuZXh0X2RtYWJ1ZihzLT5wcml2YXRlLCBwb3MpOworfQorCitzdGF0aWMgdm9pZCBk bWFidWZfZmRzX3NlcV9zdG9wKHN0cnVjdCBzZXFfZmlsZSAqcywgdm9pZCAqdikKK3sKKwlzdHJ1 Y3QgZG1hYnVmX2Zkc19wcml2YXRlICpwcml2ID0gcy0+cHJpdmF0ZTsKKworCWlmIChwcml2LT50 YXNrKSB7CisJCXRhc2tfdW5sb2NrKHByaXYtPnRhc2spOworCQlwdXRfdGFza19zdHJ1Y3QocHJp di0+dGFzayk7CisKKwl9CisJaWYgKHByaXYtPmRtYWJ1Zl9maWxlKQorCQlmcHV0KHByaXYtPmRt YWJ1Zl9maWxlKTsKK30KKworc3RhdGljIGludCBkbWFidWZfZmRzX3NlcV9zaG93KHN0cnVjdCBz ZXFfZmlsZSAqcywgdm9pZCAqdikKK3sKKwlzdHJ1Y3QgZG1hYnVmX2Zkc19wcml2YXRlICpwcml2 ID0gcy0+cHJpdmF0ZTsKKwlzdHJ1Y3QgZmlsZSAqZmlsZSA9IHByaXYtPmRtYWJ1Zl9maWxlOwor CXN0cnVjdCBkbWFfYnVmICpkbWFidWYgPSBmaWxlLT5wcml2YXRlX2RhdGE7CisKKwlpZiAoIWRt YWJ1ZikKKwkJcmV0dXJuIC1FU1JDSDsKKworCXNlcV9wcmludGYocywgIiU4bHUgIiwgZmlsZV9p bm9kZShmaWxlKS0+aV9pbm8pOworCisJZnB1dChwcml2LT5kbWFidWZfZmlsZSk7CisJcHJpdi0+ ZG1hYnVmX2ZpbGUgPSBOVUxMOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1 Y3Qgc2VxX29wZXJhdGlvbnMgcHJvY190aWRfZG1hYnVmX2Zkc19zZXFfb3BzID0geworCS5zdGFy dCA9IGRtYWJ1Zl9mZHNfc2VxX3N0YXJ0LAorCS5uZXh0ICA9IGRtYWJ1Zl9mZHNfc2VxX25leHQs CisJLnN0b3AgID0gZG1hYnVmX2Zkc19zZXFfc3RvcCwKKwkuc2hvdyAgPSBkbWFidWZfZmRzX3Nl cV9zaG93Cit9OworCitzdGF0aWMgaW50IHByb2NfZG1hYnVmX2Zkc19vcGVuKHN0cnVjdCBpbm9k ZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlLAorCQkgICAgIGNvbnN0IHN0cnVjdCBzZXFfb3Bl cmF0aW9ucyAqb3BzKQoreworCXN0cnVjdCBkbWFidWZfZmRzX3ByaXZhdGUgKnByaXY7CisJc3Ry dWN0IHRhc2tfc3RydWN0ICp0YXNrOworCWJvb2wgYWxsb3dlZCA9IGZhbHNlOworCisJdGFzayA9 IGdldF9wcm9jX3Rhc2soaW5vZGUpOworCWlmICghdGFzaykKKwkJcmV0dXJuIC1FU1JDSDsKKwor CWFsbG93ZWQgPSBwdHJhY2VfbWF5X2FjY2Vzcyh0YXNrLCBQVFJBQ0VfTU9ERV9SRUFEX0ZTQ1JF RFMpOworCXB1dF90YXNrX3N0cnVjdCh0YXNrKTsKKworCWlmICghYWxsb3dlZCkKKwkJcmV0dXJu IC1FQUNDRVM7CisKKwlwcml2ID0gX19zZXFfb3Blbl9wcml2YXRlKGZpbGUsIG9wcywgc2l6ZW9m KCpwcml2KSk7CisJaWYgKCFwcml2KQorCQlyZXR1cm4gLUVOT01FTTsKKworCXByaXYtPmlub2Rl ID0gaW5vZGU7CisJcHJpdi0+dGFzayA9IE5VTEw7CisJcHJpdi0+ZG1hYnVmX2ZpbGUgPSBOVUxM OworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgcHJvY19kbWFidWZfZmRzX3JlbGVhc2Uo c3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpCit7CisJcmV0dXJuIHNlcV9y ZWxlYXNlX3ByaXZhdGUoaW5vZGUsIGZpbGUpOworfQorCitzdGF0aWMgaW50IHRpZF9kbWFidWZf ZmRzX29wZW4oc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpCit7CisJcmV0 dXJuIHByb2NfZG1hYnVmX2Zkc19vcGVuKGlub2RlLCBmaWxlLAorCQkJJnByb2NfdGlkX2RtYWJ1 Zl9mZHNfc2VxX29wcyk7Cit9CisKK2NvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgcHJvY190 aWRfZG1hYnVmX2Zkc19vcGVyYXRpb25zID0geworCS5vcGVuCQk9IHRpZF9kbWFidWZfZmRzX29w ZW4sCisJLnJlYWQJCT0gc2VxX3JlYWQsCisJLmxsc2VlawkJPSBzZXFfbHNlZWssCisJLnJlbGVh c2UJPSBwcm9jX2RtYWJ1Zl9mZHNfcmVsZWFzZSwKK307CisKZGlmZiAtLWdpdCBhL2ZzL3Byb2Mv aW50ZXJuYWwuaCBiL2ZzL3Byb2MvaW50ZXJuYWwuaAppbmRleCBmNjBiMzc5ZGNkYzcuLjRjYTc0 MjIwZGI5YyAxMDA2NDQKLS0tIGEvZnMvcHJvYy9pbnRlcm5hbC5oCisrKyBiL2ZzL3Byb2MvaW50 ZXJuYWwuaApAQCAtMzAzLDYgKzMwMyw3IEBAIGV4dGVybiBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVy YXRpb25zIHByb2NfcGlkX3NtYXBzX29wZXJhdGlvbnM7CiBleHRlcm4gY29uc3Qgc3RydWN0IGZp bGVfb3BlcmF0aW9ucyBwcm9jX3BpZF9zbWFwc19yb2xsdXBfb3BlcmF0aW9uczsKIGV4dGVybiBj b25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIHByb2NfY2xlYXJfcmVmc19vcGVyYXRpb25zOwog ZXh0ZXJuIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgcHJvY19wYWdlbWFwX29wZXJhdGlv bnM7CitleHRlcm4gY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBwcm9jX3RpZF9kbWFidWZf ZmRzX29wZXJhdGlvbnM7CiAKIGV4dGVybiB1bnNpZ25lZCBsb25nIHRhc2tfdnNpemUoc3RydWN0 IG1tX3N0cnVjdCAqKTsKIGV4dGVybiB1bnNpZ25lZCBsb25nIHRhc2tfc3RhdG0oc3RydWN0IG1t X3N0cnVjdCAqLApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9kbWEtYnVmLmggYi9pbmNsdWRl L2xpbnV4L2RtYS1idWYuaAppbmRleCBjZjcyNjk5Y2IyYmMuLjA4N2UxMWY3ZjE5MyAxMDA2NDQK LS0tIGEvaW5jbHVkZS9saW51eC9kbWEtYnVmLmgKKysrIGIvaW5jbHVkZS9saW51eC9kbWEtYnVm LmgKQEAgLTI3LDYgKzI3LDExIEBAIHN0cnVjdCBkZXZpY2U7CiBzdHJ1Y3QgZG1hX2J1ZjsKIHN0 cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQ7CiAKKy8qKgorICogQ2hlY2sgaWYgc3RydWN0IGZpbGUq IGlzIGFzc29jaWF0ZWQgd2l0aCBkbWFfYnVmLgorICovCitpbnQgaXNfZG1hX2J1Zl9maWxlKHN0 cnVjdCBmaWxlICpmaWxlKTsKKwogLyoqCiAgKiBzdHJ1Y3QgZG1hX2J1Zl9vcHMgLSBvcGVyYXRp b25zIHBvc3NpYmxlIG9uIHN0cnVjdCBkbWFfYnVmCiAgKiBAdm1hcDogW29wdGlvbmFsXSBjcmVh dGVzIGEgdmlydHVhbCBtYXBwaW5nIGZvciB0aGUgYnVmZmVyIGludG8ga2VybmVsCi0tIAoyLjMw LjAuMjgwLmdhM2NlMjc5MTJmLWdvb2cKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZy ZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3Rp bmZvL2RyaS1kZXZlbAo=