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=-16.6 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9382CC47088 for ; Tue, 25 May 2021 21:18:24 +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 60C76611BE for ; Tue, 25 May 2021 21:18:24 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 60C76611BE Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=jlekstrand.net 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 88F916EB46; Tue, 25 May 2021 21:18:17 +0000 (UTC) Received: from mail-pl1-x62a.google.com (mail-pl1-x62a.google.com [IPv6:2607:f8b0:4864:20::62a]) by gabe.freedesktop.org (Postfix) with ESMTPS id E04446EB49 for ; Tue, 25 May 2021 21:18:10 +0000 (UTC) Received: by mail-pl1-x62a.google.com with SMTP id z4so14840106plg.8 for ; Tue, 25 May 2021 14:18:10 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=jlekstrand-net.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=aVRWHUdIShQi1nsSzSKZUPU5qNRn//26RDAX0L399dc=; b=My6+y+nJzz50Iyxuc4xCyjJoOEy50Z47yu3tVntkp8cHx8geMn/VP7UA4B/wIUx7qM rQSfJcJxoadYt7Y18TakvxExwWMZJIizfL59AnHiSzt8ZqYOSMi9iOkkvPegFREKp18o WIw9scla1s6XmVU2j26QiYDrwMh8e0OqEgopS9abSkPxc6UQG01tzXDEQxIlonTkWzIb 1z44pSNyM4R8jE+XhtN4T9PHgHVtpCvdPB4YoSD9N3paiVpj6c8ow4WWfJpbOYvWuTeV DNKI2Rqd3Mo6/xFzjYt5Vt/Iki9UHOLV99qH/68JjmXefXVy/jgXDQVB0P+84g/yxNIc GT0A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=aVRWHUdIShQi1nsSzSKZUPU5qNRn//26RDAX0L399dc=; b=arZaYiVfjH1w3MMUeSHhM2nMOe8M4J+9fXNvRSgbfv8YSmpxn+pQsU1sXl2IYjSP4T gJdUp4vXlabyEEMGpBoNgo/FCL54KpQs8kNOLFj7as6tHiCf51K0EdboBKxh6jqE7/aN 3t7QcHcZbcun/9+ZyxHrYQ9dhFYoB20dl+57ipSNNC1LARuVjgXCMcT1eStayUGiCDWO w2X4S0yDA2OWPDdatDb20mPkPLCSHr7lJYh44yfz2ucC24Rb9kS8vhJwlGR58ELwm0GM 61IJhMJuNpRtklnE2lfmazrkla6Lsjv1KSbELK0ixq40ktnDYAmjcxWK9g13d+vQcSU2 ZqjA== X-Gm-Message-State: AOAM53002XP9TAcCwhAUmGpBRYc1dAAff/2lZn0mzfdw9VkxBLPPm8O+ kS2y11Sjd2n0bBFV/e5yEYqJE1EY7Cg1yg== X-Google-Smtp-Source: ABdhPJwCB9VBuDNuH2qw9I1VG0qkdO3HU+K/LR3AH5yUvGtVrQeZw4SdEMtOd2oOL+wll/50afRLSg== X-Received: by 2002:a17:90a:4105:: with SMTP id u5mr31251452pjf.45.1621977489868; Tue, 25 May 2021 14:18:09 -0700 (PDT) Received: from omlet.lan ([134.134.139.83]) by smtp.gmail.com with ESMTPSA id e186sm14342278pfa.145.2021.05.25.14.18.08 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 25 May 2021 14:18:09 -0700 (PDT) From: Jason Ekstrand To: dri-devel@lists.freedesktop.org, intel-gfx@lists.freedesktop.org Subject: [PATCH 5/7] dma-buf: Add an API for exporting sync files (v11) Date: Tue, 25 May 2021 16:17:51 -0500 Message-Id: <20210525211753.1086069-6-jason@jlekstrand.net> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210525211753.1086069-1-jason@jlekstrand.net> References: <20210525211753.1086069-1-jason@jlekstrand.net> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: =?UTF-8?q?Christian=20K=C3=B6nig?= , Jason Ekstrand , Daniel Vetter Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Modern userspace APIs like Vulkan are built on an explicit synchronization model. This doesn't always play nicely with the implicit synchronization used in the kernel and assumed by X11 and Wayland. The client -> compositor half of the synchronization isn't too bad, at least on intel, because we can control whether or not i915 synchronizes on the buffer and whether or not it's considered written. The harder part is the compositor -> client synchronization when we get the buffer back from the compositor. We're required to be able to provide the client with a VkSemaphore and VkFence representing the point in time where the window system (compositor and/or display) finished using the buffer. With current APIs, it's very hard to do this in such a way that we don't get confused by the Vulkan driver's access of the buffer. In particular, once we tell the kernel that we're rendering to the buffer again, any CPU waits on the buffer or GPU dependencies will wait on some of the client rendering and not just the compositor. This new IOCTL solves this problem by allowing us to get a snapshot of the implicit synchronization state of a given dma-buf in the form of a sync file. It's effectively the same as a poll() or I915_GEM_WAIT only, instead of CPU waiting directly, it encapsulates the wait operation, at the current moment in time, in a sync_file so we can check/wait on it later. As long as the Vulkan driver does the sync_file export from the dma-buf before we re-introduce it for rendering, it will only contain fences from the compositor or display. This allows to accurately turn it into a VkFence or VkSemaphore without any over- synchronization. v2 (Jason Ekstrand): - Use a wrapper dma_fence_array of all fences including the new one when importing an exclusive fence. v3 (Jason Ekstrand): - Lock around setting shared fences as well as exclusive - Mark SIGNAL_SYNC_FILE as a read-write ioctl. - Initialize ret to 0 in dma_buf_wait_sync_file v4 (Jason Ekstrand): - Use the new dma_resv_get_singleton helper v5 (Jason Ekstrand): - Rename the IOCTLs to import/export rather than wait/signal - Drop the WRITE flag and always get/set the exclusive fence v6 (Jason Ekstrand): - Drop the sync_file import as it was all-around sketchy and not nearly as useful as import. - Re-introduce READ/WRITE flag support for export - Rework the commit message v7 (Jason Ekstrand): - Require at least one sync flag - Fix a refcounting bug: dma_resv_get_excl() doesn't take a reference - Use _rcu helpers since we're accessing the dma_resv read-only v8 (Jason Ekstrand): - Return -ENOMEM if the sync_file_create fails - Predicate support on IS_ENABLED(CONFIG_SYNC_FILE) v9 (Jason Ekstrand): - Add documentation for the new ioctl v10 (Jason Ekstrand): - Go back to dma_buf_sync_file as the ioctl struct name v11 (Daniel Vetter): - Go back to dma_buf_export_sync_file as the ioctl struct name - Better kerneldoc describing what the read/write flags do Signed-off-by: Jason Ekstrand Acked-by: Simon Ser Acked-by: Christian König Reviewed-by: Daniel Vetter Cc: Sumit Semwal Cc: Maarten Lankhorst --- drivers/dma-buf/dma-buf.c | 67 ++++++++++++++++++++++++++++++++++++ include/uapi/linux/dma-buf.h | 35 +++++++++++++++++++ 2 files changed, 102 insertions(+) diff --git a/drivers/dma-buf/dma-buf.c b/drivers/dma-buf/dma-buf.c index ed6451d55d663..65a9574ee04ed 100644 --- a/drivers/dma-buf/dma-buf.c +++ b/drivers/dma-buf/dma-buf.c @@ -20,6 +20,7 @@ #include #include #include +#include #include #include #include @@ -191,6 +192,9 @@ static loff_t dma_buf_llseek(struct file *file, loff_t offset, int whence) * Note that this only signals the completion of the respective fences, i.e. the * DMA transfers are complete. Cache flushing and any other necessary * preparations before CPU access can begin still need to happen. + * + * As an alternative to poll(), the set of fences on DMA buffer can be + * exported as a &sync_file using &dma_buf_sync_file_export. */ static void dma_buf_poll_cb(struct dma_fence *fence, struct dma_fence_cb *cb) @@ -362,6 +366,64 @@ static long dma_buf_set_name(struct dma_buf *dmabuf, const char __user *buf) return ret; } +#if IS_ENABLED(CONFIG_SYNC_FILE) +static long dma_buf_export_sync_file(struct dma_buf *dmabuf, + void __user *user_data) +{ + struct dma_buf_export_sync_file arg; + struct dma_fence *fence = NULL; + struct sync_file *sync_file; + int fd, ret; + + if (copy_from_user(&arg, user_data, sizeof(arg))) + return -EFAULT; + + if (arg.flags & ~DMA_BUF_SYNC_RW) + return -EINVAL; + + if ((arg.flags & DMA_BUF_SYNC_RW) == 0) + return -EINVAL; + + fd = get_unused_fd_flags(O_CLOEXEC); + if (fd < 0) + return fd; + + if (arg.flags & DMA_BUF_SYNC_WRITE) { + fence = dma_resv_get_singleton_unlocked(dmabuf->resv); + if (IS_ERR(fence)) { + ret = PTR_ERR(fence); + goto err_put_fd; + } + } else if (arg.flags & DMA_BUF_SYNC_READ) { + fence = dma_resv_get_excl_unlocked(dmabuf->resv); + } + + if (!fence) + fence = dma_fence_get_stub(); + + sync_file = sync_file_create(fence); + + dma_fence_put(fence); + + if (!sync_file) { + ret = -ENOMEM; + goto err_put_fd; + } + + fd_install(fd, sync_file->file); + + arg.fd = fd; + if (copy_to_user(user_data, &arg, sizeof(arg))) + return -EFAULT; + + return 0; + +err_put_fd: + put_unused_fd(fd); + return ret; +} +#endif + static long dma_buf_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { @@ -405,6 +467,11 @@ static long dma_buf_ioctl(struct file *file, case DMA_BUF_SET_NAME_B: return dma_buf_set_name(dmabuf, (const char __user *)arg); +#if IS_ENABLED(CONFIG_SYNC_FILE) + case DMA_BUF_IOCTL_EXPORT_SYNC_FILE: + return dma_buf_export_sync_file(dmabuf, (void __user *)arg); +#endif + default: return -ENOTTY; } diff --git a/include/uapi/linux/dma-buf.h b/include/uapi/linux/dma-buf.h index 1f67ced853b14..aeba45180b028 100644 --- a/include/uapi/linux/dma-buf.h +++ b/include/uapi/linux/dma-buf.h @@ -67,6 +67,40 @@ struct dma_buf_sync { #define DMA_BUF_NAME_LEN 32 +/** + * struct dma_buf_export_sync_file - Get a sync_file from a dma-buf + * + * Userspace can perform a DMA_BUF_IOCTL_EXPORT_SYNC_FILE to retrieve the + * current set of fences on a dma-buf file descriptor as a sync_file. CPU + * waits via poll() or other driver-specific mechanisms typically wait on + * whatever fences are on the dma-buf at the time the wait begins. This + * is similar except that it takes a snapshot of the current fences on the + * dma-buf for waiting later instead of waiting immediately. This is + * useful for modern graphics APIs such as Vulkan which assume an explicit + * synchronization model but still need to inter-operate with dma-buf. + */ +struct dma_buf_export_sync_file { + /** + * @flags: Read/write flags + * + * Must be DMA_BUF_SYNC_READ, DMA_BUF_SYNC_WRITE, or both. + * + * If DMA_BUF_SYNC_READ is set and DMA_BUF_SYNC_WRITE is not set, + * the returned sync file waits on any writers of the dma-buf to + * complete. Waiting on the returned sync file is equivalent to + * poll() with POLLIN. + * + * If DMA_BUF_SYNC_WRITE is set, the returned sync file waits on + * any users of the dma-buf (read or write) to complete. Waiting + * on the returned sync file is equivalent to poll() with POLLOUT. + * If both DMA_BUF_SYNC_WRITE and DMA_BUF_SYNC_READ are set, this + * is equivalent to just DMA_BUF_SYNC_WRITE. + */ + __u32 flags; + /** @fd: Returned sync file descriptor */ + __s32 fd; +}; + #define DMA_BUF_BASE 'b' #define DMA_BUF_IOCTL_SYNC _IOW(DMA_BUF_BASE, 0, struct dma_buf_sync) @@ -76,5 +110,6 @@ struct dma_buf_sync { #define DMA_BUF_SET_NAME _IOW(DMA_BUF_BASE, 1, const char *) #define DMA_BUF_SET_NAME_A _IOW(DMA_BUF_BASE, 1, u32) #define DMA_BUF_SET_NAME_B _IOW(DMA_BUF_BASE, 1, u64) +#define DMA_BUF_IOCTL_EXPORT_SYNC_FILE _IOWR(DMA_BUF_BASE, 2, struct dma_buf_export_sync_file) #endif -- 2.31.1 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=-16.6 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 33D3EC47087 for ; Tue, 25 May 2021 21:18:31 +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 F20EB611BE for ; Tue, 25 May 2021 21:18:30 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org F20EB611BE Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=jlekstrand.net Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=intel-gfx-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id DC70C6EB47; Tue, 25 May 2021 21:18:23 +0000 (UTC) Received: from mail-pl1-x62f.google.com (mail-pl1-x62f.google.com [IPv6:2607:f8b0:4864:20::62f]) by gabe.freedesktop.org (Postfix) with ESMTPS id 6C3E26EB49 for ; Tue, 25 May 2021 21:18:10 +0000 (UTC) Received: by mail-pl1-x62f.google.com with SMTP id t21so17042842plo.2 for ; Tue, 25 May 2021 14:18:10 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=jlekstrand-net.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=aVRWHUdIShQi1nsSzSKZUPU5qNRn//26RDAX0L399dc=; b=My6+y+nJzz50Iyxuc4xCyjJoOEy50Z47yu3tVntkp8cHx8geMn/VP7UA4B/wIUx7qM rQSfJcJxoadYt7Y18TakvxExwWMZJIizfL59AnHiSzt8ZqYOSMi9iOkkvPegFREKp18o WIw9scla1s6XmVU2j26QiYDrwMh8e0OqEgopS9abSkPxc6UQG01tzXDEQxIlonTkWzIb 1z44pSNyM4R8jE+XhtN4T9PHgHVtpCvdPB4YoSD9N3paiVpj6c8ow4WWfJpbOYvWuTeV DNKI2Rqd3Mo6/xFzjYt5Vt/Iki9UHOLV99qH/68JjmXefXVy/jgXDQVB0P+84g/yxNIc GT0A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=aVRWHUdIShQi1nsSzSKZUPU5qNRn//26RDAX0L399dc=; b=UvNkG6QIhw613a6LfGn0DhLXEajwL3AqKZUo5U5VIybCeAIATzyyaxBeprrfpS+pS5 rP/Rz/fvXFwrx8wAjUAPjTAdxiqT/wa9tmGHn87nj1OQrsKi+Iy4oTDoSW3+Lym9s27t Z0/TkeMaQfoZAOwz0iVtWub6BackCfuYz4YEe3ol79JzNt8yUqb9vkZ7gP/O7LNQvGrg upQebqN0aPbIylR1AotUdMnb38ODY507wQxs6HJ1ymtc7vzjw0Rv9PW/OPqwI1Zy2fe8 nfPDXKTC4dheElXXmnTzYIATACN3G5VEpXzmTRpauoikLEdoO2AHgdzd5uiyS3FFoiMV dg2w== X-Gm-Message-State: AOAM532qni8R6nGEHjW30pOK9ChD1NeDsWokcANb5N0PEZVXyxvN5Ejx aEQZQC4KAfpffpFXg5N5LCCZqA== X-Google-Smtp-Source: ABdhPJwCB9VBuDNuH2qw9I1VG0qkdO3HU+K/LR3AH5yUvGtVrQeZw4SdEMtOd2oOL+wll/50afRLSg== X-Received: by 2002:a17:90a:4105:: with SMTP id u5mr31251452pjf.45.1621977489868; Tue, 25 May 2021 14:18:09 -0700 (PDT) Received: from omlet.lan ([134.134.139.83]) by smtp.gmail.com with ESMTPSA id e186sm14342278pfa.145.2021.05.25.14.18.08 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 25 May 2021 14:18:09 -0700 (PDT) From: Jason Ekstrand To: dri-devel@lists.freedesktop.org, intel-gfx@lists.freedesktop.org Date: Tue, 25 May 2021 16:17:51 -0500 Message-Id: <20210525211753.1086069-6-jason@jlekstrand.net> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210525211753.1086069-1-jason@jlekstrand.net> References: <20210525211753.1086069-1-jason@jlekstrand.net> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH 5/7] dma-buf: Add an API for exporting sync files (v11) X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Simon Ser , =?UTF-8?q?Christian=20K=C3=B6nig?= , Daniel Vetter , Sumit Semwal Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" TW9kZXJuIHVzZXJzcGFjZSBBUElzIGxpa2UgVnVsa2FuIGFyZSBidWlsdCBvbiBhbiBleHBsaWNp dApzeW5jaHJvbml6YXRpb24gbW9kZWwuICBUaGlzIGRvZXNuJ3QgYWx3YXlzIHBsYXkgbmljZWx5 IHdpdGggdGhlCmltcGxpY2l0IHN5bmNocm9uaXphdGlvbiB1c2VkIGluIHRoZSBrZXJuZWwgYW5k IGFzc3VtZWQgYnkgWDExIGFuZApXYXlsYW5kLiAgVGhlIGNsaWVudCAtPiBjb21wb3NpdG9yIGhh bGYgb2YgdGhlIHN5bmNocm9uaXphdGlvbiBpc24ndCB0b28KYmFkLCBhdCBsZWFzdCBvbiBpbnRl bCwgYmVjYXVzZSB3ZSBjYW4gY29udHJvbCB3aGV0aGVyIG9yIG5vdCBpOTE1CnN5bmNocm9uaXpl cyBvbiB0aGUgYnVmZmVyIGFuZCB3aGV0aGVyIG9yIG5vdCBpdCdzIGNvbnNpZGVyZWQgd3JpdHRl bi4KClRoZSBoYXJkZXIgcGFydCBpcyB0aGUgY29tcG9zaXRvciAtPiBjbGllbnQgc3luY2hyb25p emF0aW9uIHdoZW4gd2UgZ2V0CnRoZSBidWZmZXIgYmFjayBmcm9tIHRoZSBjb21wb3NpdG9yLiAg V2UncmUgcmVxdWlyZWQgdG8gYmUgYWJsZSB0bwpwcm92aWRlIHRoZSBjbGllbnQgd2l0aCBhIFZr U2VtYXBob3JlIGFuZCBWa0ZlbmNlIHJlcHJlc2VudGluZyB0aGUgcG9pbnQKaW4gdGltZSB3aGVy ZSB0aGUgd2luZG93IHN5c3RlbSAoY29tcG9zaXRvciBhbmQvb3IgZGlzcGxheSkgZmluaXNoZWQK dXNpbmcgdGhlIGJ1ZmZlci4gIFdpdGggY3VycmVudCBBUElzLCBpdCdzIHZlcnkgaGFyZCB0byBk byB0aGlzIGluIHN1Y2gKYSB3YXkgdGhhdCB3ZSBkb24ndCBnZXQgY29uZnVzZWQgYnkgdGhlIFZ1 bGthbiBkcml2ZXIncyBhY2Nlc3Mgb2YgdGhlCmJ1ZmZlci4gIEluIHBhcnRpY3VsYXIsIG9uY2Ug d2UgdGVsbCB0aGUga2VybmVsIHRoYXQgd2UncmUgcmVuZGVyaW5nIHRvCnRoZSBidWZmZXIgYWdh aW4sIGFueSBDUFUgd2FpdHMgb24gdGhlIGJ1ZmZlciBvciBHUFUgZGVwZW5kZW5jaWVzIHdpbGwK d2FpdCBvbiBzb21lIG9mIHRoZSBjbGllbnQgcmVuZGVyaW5nIGFuZCBub3QganVzdCB0aGUgY29t cG9zaXRvci4KClRoaXMgbmV3IElPQ1RMIHNvbHZlcyB0aGlzIHByb2JsZW0gYnkgYWxsb3dpbmcg dXMgdG8gZ2V0IGEgc25hcHNob3Qgb2YKdGhlIGltcGxpY2l0IHN5bmNocm9uaXphdGlvbiBzdGF0 ZSBvZiBhIGdpdmVuIGRtYS1idWYgaW4gdGhlIGZvcm0gb2YgYQpzeW5jIGZpbGUuICBJdCdzIGVm ZmVjdGl2ZWx5IHRoZSBzYW1lIGFzIGEgcG9sbCgpIG9yIEk5MTVfR0VNX1dBSVQgb25seSwKaW5z dGVhZCBvZiBDUFUgd2FpdGluZyBkaXJlY3RseSwgaXQgZW5jYXBzdWxhdGVzIHRoZSB3YWl0IG9w ZXJhdGlvbiwgYXQKdGhlIGN1cnJlbnQgbW9tZW50IGluIHRpbWUsIGluIGEgc3luY19maWxlIHNv IHdlIGNhbiBjaGVjay93YWl0IG9uIGl0CmxhdGVyLiAgQXMgbG9uZyBhcyB0aGUgVnVsa2FuIGRy aXZlciBkb2VzIHRoZSBzeW5jX2ZpbGUgZXhwb3J0IGZyb20gdGhlCmRtYS1idWYgYmVmb3JlIHdl IHJlLWludHJvZHVjZSBpdCBmb3IgcmVuZGVyaW5nLCBpdCB3aWxsIG9ubHkgY29udGFpbgpmZW5j ZXMgZnJvbSB0aGUgY29tcG9zaXRvciBvciBkaXNwbGF5LiAgVGhpcyBhbGxvd3MgdG8gYWNjdXJh dGVseSB0dXJuCml0IGludG8gYSBWa0ZlbmNlIG9yIFZrU2VtYXBob3JlIHdpdGhvdXQgYW55IG92 ZXItIHN5bmNocm9uaXphdGlvbi4KCnYyIChKYXNvbiBFa3N0cmFuZCk6CiAtIFVzZSBhIHdyYXBw ZXIgZG1hX2ZlbmNlX2FycmF5IG9mIGFsbCBmZW5jZXMgaW5jbHVkaW5nIHRoZSBuZXcgb25lCiAg IHdoZW4gaW1wb3J0aW5nIGFuIGV4Y2x1c2l2ZSBmZW5jZS4KCnYzIChKYXNvbiBFa3N0cmFuZCk6 CiAtIExvY2sgYXJvdW5kIHNldHRpbmcgc2hhcmVkIGZlbmNlcyBhcyB3ZWxsIGFzIGV4Y2x1c2l2 ZQogLSBNYXJrIFNJR05BTF9TWU5DX0ZJTEUgYXMgYSByZWFkLXdyaXRlIGlvY3RsLgogLSBJbml0 aWFsaXplIHJldCB0byAwIGluIGRtYV9idWZfd2FpdF9zeW5jX2ZpbGUKCnY0IChKYXNvbiBFa3N0 cmFuZCk6CiAtIFVzZSB0aGUgbmV3IGRtYV9yZXN2X2dldF9zaW5nbGV0b24gaGVscGVyCgp2NSAo SmFzb24gRWtzdHJhbmQpOgogLSBSZW5hbWUgdGhlIElPQ1RMcyB0byBpbXBvcnQvZXhwb3J0IHJh dGhlciB0aGFuIHdhaXQvc2lnbmFsCiAtIERyb3AgdGhlIFdSSVRFIGZsYWcgYW5kIGFsd2F5cyBn ZXQvc2V0IHRoZSBleGNsdXNpdmUgZmVuY2UKCnY2IChKYXNvbiBFa3N0cmFuZCk6CiAtIERyb3Ag dGhlIHN5bmNfZmlsZSBpbXBvcnQgYXMgaXQgd2FzIGFsbC1hcm91bmQgc2tldGNoeSBhbmQgbm90 IG5lYXJseQogICBhcyB1c2VmdWwgYXMgaW1wb3J0LgogLSBSZS1pbnRyb2R1Y2UgUkVBRC9XUklU RSBmbGFnIHN1cHBvcnQgZm9yIGV4cG9ydAogLSBSZXdvcmsgdGhlIGNvbW1pdCBtZXNzYWdlCgp2 NyAoSmFzb24gRWtzdHJhbmQpOgogLSBSZXF1aXJlIGF0IGxlYXN0IG9uZSBzeW5jIGZsYWcKIC0g Rml4IGEgcmVmY291bnRpbmcgYnVnOiBkbWFfcmVzdl9nZXRfZXhjbCgpIGRvZXNuJ3QgdGFrZSBh IHJlZmVyZW5jZQogLSBVc2UgX3JjdSBoZWxwZXJzIHNpbmNlIHdlJ3JlIGFjY2Vzc2luZyB0aGUg ZG1hX3Jlc3YgcmVhZC1vbmx5Cgp2OCAoSmFzb24gRWtzdHJhbmQpOgogLSBSZXR1cm4gLUVOT01F TSBpZiB0aGUgc3luY19maWxlX2NyZWF0ZSBmYWlscwogLSBQcmVkaWNhdGUgc3VwcG9ydCBvbiBJ U19FTkFCTEVEKENPTkZJR19TWU5DX0ZJTEUpCgp2OSAoSmFzb24gRWtzdHJhbmQpOgogLSBBZGQg ZG9jdW1lbnRhdGlvbiBmb3IgdGhlIG5ldyBpb2N0bAoKdjEwIChKYXNvbiBFa3N0cmFuZCk6CiAt IEdvIGJhY2sgdG8gZG1hX2J1Zl9zeW5jX2ZpbGUgYXMgdGhlIGlvY3RsIHN0cnVjdCBuYW1lCgp2 MTEgKERhbmllbCBWZXR0ZXIpOgogLSBHbyBiYWNrIHRvIGRtYV9idWZfZXhwb3J0X3N5bmNfZmls ZSBhcyB0aGUgaW9jdGwgc3RydWN0IG5hbWUKIC0gQmV0dGVyIGtlcm5lbGRvYyBkZXNjcmliaW5n IHdoYXQgdGhlIHJlYWQvd3JpdGUgZmxhZ3MgZG8KClNpZ25lZC1vZmYtYnk6IEphc29uIEVrc3Ry YW5kIDxqYXNvbkBqbGVrc3RyYW5kLm5ldD4KQWNrZWQtYnk6IFNpbW9uIFNlciA8Y29udGFjdEBl bWVyc2lvbi5mcj4KQWNrZWQtYnk6IENocmlzdGlhbiBLw7ZuaWcgPGNocmlzdGlhbi5rb2VuaWdA YW1kLmNvbT4KUmV2aWV3ZWQtYnk6IERhbmllbCBWZXR0ZXIgPGRhbmllbC52ZXR0ZXJAZmZ3bGwu Y2g+CkNjOiBTdW1pdCBTZW13YWwgPHN1bWl0LnNlbXdhbEBsaW5hcm8ub3JnPgpDYzogTWFhcnRl biBMYW5raG9yc3QgPG1hYXJ0ZW4ubGFua2hvcnN0QGxpbnV4LmludGVsLmNvbT4KLS0tCiBkcml2 ZXJzL2RtYS1idWYvZG1hLWJ1Zi5jICAgIHwgNjcgKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrCiBpbmNsdWRlL3VhcGkvbGludXgvZG1hLWJ1Zi5oIHwgMzUgKysrKysrKysrKysr KysrKysrKwogMiBmaWxlcyBjaGFuZ2VkLCAxMDIgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBh L2RyaXZlcnMvZG1hLWJ1Zi9kbWEtYnVmLmMgYi9kcml2ZXJzL2RtYS1idWYvZG1hLWJ1Zi5jCmlu ZGV4IGVkNjQ1MWQ1NWQ2NjMuLjY1YTk1NzRlZTA0ZWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZG1h LWJ1Zi9kbWEtYnVmLmMKKysrIGIvZHJpdmVycy9kbWEtYnVmL2RtYS1idWYuYwpAQCAtMjAsNiAr MjAsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2RlYnVnZnMuaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1 bGUuaD4KICNpbmNsdWRlIDxsaW51eC9zZXFfZmlsZS5oPgorI2luY2x1ZGUgPGxpbnV4L3N5bmNf ZmlsZS5oPgogI2luY2x1ZGUgPGxpbnV4L3BvbGwuaD4KICNpbmNsdWRlIDxsaW51eC9kbWEtcmVz di5oPgogI2luY2x1ZGUgPGxpbnV4L21tLmg+CkBAIC0xOTEsNiArMTkyLDkgQEAgc3RhdGljIGxv ZmZfdCBkbWFfYnVmX2xsc2VlayhzdHJ1Y3QgZmlsZSAqZmlsZSwgbG9mZl90IG9mZnNldCwgaW50 IHdoZW5jZSkKICAqIE5vdGUgdGhhdCB0aGlzIG9ubHkgc2lnbmFscyB0aGUgY29tcGxldGlvbiBv ZiB0aGUgcmVzcGVjdGl2ZSBmZW5jZXMsIGkuZS4gdGhlCiAgKiBETUEgdHJhbnNmZXJzIGFyZSBj b21wbGV0ZS4gQ2FjaGUgZmx1c2hpbmcgYW5kIGFueSBvdGhlciBuZWNlc3NhcnkKICAqIHByZXBh cmF0aW9ucyBiZWZvcmUgQ1BVIGFjY2VzcyBjYW4gYmVnaW4gc3RpbGwgbmVlZCB0byBoYXBwZW4u CisgKgorICogQXMgYW4gYWx0ZXJuYXRpdmUgdG8gcG9sbCgpLCB0aGUgc2V0IG9mIGZlbmNlcyBv biBETUEgYnVmZmVyIGNhbiBiZQorICogZXhwb3J0ZWQgYXMgYSAmc3luY19maWxlIHVzaW5nICZk bWFfYnVmX3N5bmNfZmlsZV9leHBvcnQuCiAgKi8KIAogc3RhdGljIHZvaWQgZG1hX2J1Zl9wb2xs X2NiKHN0cnVjdCBkbWFfZmVuY2UgKmZlbmNlLCBzdHJ1Y3QgZG1hX2ZlbmNlX2NiICpjYikKQEAg LTM2Miw2ICszNjYsNjQgQEAgc3RhdGljIGxvbmcgZG1hX2J1Zl9zZXRfbmFtZShzdHJ1Y3QgZG1h X2J1ZiAqZG1hYnVmLCBjb25zdCBjaGFyIF9fdXNlciAqYnVmKQogCXJldHVybiByZXQ7CiB9CiAK KyNpZiBJU19FTkFCTEVEKENPTkZJR19TWU5DX0ZJTEUpCitzdGF0aWMgbG9uZyBkbWFfYnVmX2V4 cG9ydF9zeW5jX2ZpbGUoc3RydWN0IGRtYV9idWYgKmRtYWJ1ZiwKKwkJCQkgICAgIHZvaWQgX191 c2VyICp1c2VyX2RhdGEpCit7CisJc3RydWN0IGRtYV9idWZfZXhwb3J0X3N5bmNfZmlsZSBhcmc7 CisJc3RydWN0IGRtYV9mZW5jZSAqZmVuY2UgPSBOVUxMOworCXN0cnVjdCBzeW5jX2ZpbGUgKnN5 bmNfZmlsZTsKKwlpbnQgZmQsIHJldDsKKworCWlmIChjb3B5X2Zyb21fdXNlcigmYXJnLCB1c2Vy X2RhdGEsIHNpemVvZihhcmcpKSkKKwkJcmV0dXJuIC1FRkFVTFQ7CisKKwlpZiAoYXJnLmZsYWdz ICYgfkRNQV9CVUZfU1lOQ19SVykKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlpZiAoKGFyZy5mbGFn cyAmIERNQV9CVUZfU1lOQ19SVykgPT0gMCkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlmZCA9IGdl dF91bnVzZWRfZmRfZmxhZ3MoT19DTE9FWEVDKTsKKwlpZiAoZmQgPCAwKQorCQlyZXR1cm4gZmQ7 CisKKwlpZiAoYXJnLmZsYWdzICYgRE1BX0JVRl9TWU5DX1dSSVRFKSB7CisJCWZlbmNlID0gZG1h X3Jlc3ZfZ2V0X3NpbmdsZXRvbl91bmxvY2tlZChkbWFidWYtPnJlc3YpOworCQlpZiAoSVNfRVJS KGZlbmNlKSkgeworCQkJcmV0ID0gUFRSX0VSUihmZW5jZSk7CisJCQlnb3RvIGVycl9wdXRfZmQ7 CisJCX0KKwl9IGVsc2UgaWYgKGFyZy5mbGFncyAmIERNQV9CVUZfU1lOQ19SRUFEKSB7CisJCWZl bmNlID0gZG1hX3Jlc3ZfZ2V0X2V4Y2xfdW5sb2NrZWQoZG1hYnVmLT5yZXN2KTsKKwl9CisKKwlp ZiAoIWZlbmNlKQorCQlmZW5jZSA9IGRtYV9mZW5jZV9nZXRfc3R1YigpOworCisJc3luY19maWxl ID0gc3luY19maWxlX2NyZWF0ZShmZW5jZSk7CisKKwlkbWFfZmVuY2VfcHV0KGZlbmNlKTsKKwor CWlmICghc3luY19maWxlKSB7CisJCXJldCA9IC1FTk9NRU07CisJCWdvdG8gZXJyX3B1dF9mZDsK Kwl9CisKKwlmZF9pbnN0YWxsKGZkLCBzeW5jX2ZpbGUtPmZpbGUpOworCisJYXJnLmZkID0gZmQ7 CisJaWYgKGNvcHlfdG9fdXNlcih1c2VyX2RhdGEsICZhcmcsIHNpemVvZihhcmcpKSkKKwkJcmV0 dXJuIC1FRkFVTFQ7CisKKwlyZXR1cm4gMDsKKworZXJyX3B1dF9mZDoKKwlwdXRfdW51c2VkX2Zk KGZkKTsKKwlyZXR1cm4gcmV0OworfQorI2VuZGlmCisKIHN0YXRpYyBsb25nIGRtYV9idWZfaW9j dGwoc3RydWN0IGZpbGUgKmZpbGUsCiAJCQkgIHVuc2lnbmVkIGludCBjbWQsIHVuc2lnbmVkIGxv bmcgYXJnKQogewpAQCAtNDA1LDYgKzQ2NywxMSBAQCBzdGF0aWMgbG9uZyBkbWFfYnVmX2lvY3Rs KHN0cnVjdCBmaWxlICpmaWxlLAogCWNhc2UgRE1BX0JVRl9TRVRfTkFNRV9COgogCQlyZXR1cm4g ZG1hX2J1Zl9zZXRfbmFtZShkbWFidWYsIChjb25zdCBjaGFyIF9fdXNlciAqKWFyZyk7CiAKKyNp ZiBJU19FTkFCTEVEKENPTkZJR19TWU5DX0ZJTEUpCisJY2FzZSBETUFfQlVGX0lPQ1RMX0VYUE9S VF9TWU5DX0ZJTEU6CisJCXJldHVybiBkbWFfYnVmX2V4cG9ydF9zeW5jX2ZpbGUoZG1hYnVmLCAo dm9pZCBfX3VzZXIgKilhcmcpOworI2VuZGlmCisKIAlkZWZhdWx0OgogCQlyZXR1cm4gLUVOT1RU WTsKIAl9CmRpZmYgLS1naXQgYS9pbmNsdWRlL3VhcGkvbGludXgvZG1hLWJ1Zi5oIGIvaW5jbHVk ZS91YXBpL2xpbnV4L2RtYS1idWYuaAppbmRleCAxZjY3Y2VkODUzYjE0Li5hZWJhNDUxODBiMDI4 IDEwMDY0NAotLS0gYS9pbmNsdWRlL3VhcGkvbGludXgvZG1hLWJ1Zi5oCisrKyBiL2luY2x1ZGUv dWFwaS9saW51eC9kbWEtYnVmLmgKQEAgLTY3LDYgKzY3LDQwIEBAIHN0cnVjdCBkbWFfYnVmX3N5 bmMgewogCiAjZGVmaW5lIERNQV9CVUZfTkFNRV9MRU4JMzIKIAorLyoqCisgKiBzdHJ1Y3QgZG1h X2J1Zl9leHBvcnRfc3luY19maWxlIC0gR2V0IGEgc3luY19maWxlIGZyb20gYSBkbWEtYnVmCisg KgorICogVXNlcnNwYWNlIGNhbiBwZXJmb3JtIGEgRE1BX0JVRl9JT0NUTF9FWFBPUlRfU1lOQ19G SUxFIHRvIHJldHJpZXZlIHRoZQorICogY3VycmVudCBzZXQgb2YgZmVuY2VzIG9uIGEgZG1hLWJ1 ZiBmaWxlIGRlc2NyaXB0b3IgYXMgYSBzeW5jX2ZpbGUuICBDUFUKKyAqIHdhaXRzIHZpYSBwb2xs KCkgb3Igb3RoZXIgZHJpdmVyLXNwZWNpZmljIG1lY2hhbmlzbXMgdHlwaWNhbGx5IHdhaXQgb24K KyAqIHdoYXRldmVyIGZlbmNlcyBhcmUgb24gdGhlIGRtYS1idWYgYXQgdGhlIHRpbWUgdGhlIHdh aXQgYmVnaW5zLiAgVGhpcworICogaXMgc2ltaWxhciBleGNlcHQgdGhhdCBpdCB0YWtlcyBhIHNu YXBzaG90IG9mIHRoZSBjdXJyZW50IGZlbmNlcyBvbiB0aGUKKyAqIGRtYS1idWYgZm9yIHdhaXRp bmcgbGF0ZXIgaW5zdGVhZCBvZiB3YWl0aW5nIGltbWVkaWF0ZWx5LiAgVGhpcyBpcworICogdXNl ZnVsIGZvciBtb2Rlcm4gZ3JhcGhpY3MgQVBJcyBzdWNoIGFzIFZ1bGthbiB3aGljaCBhc3N1bWUg YW4gZXhwbGljaXQKKyAqIHN5bmNocm9uaXphdGlvbiBtb2RlbCBidXQgc3RpbGwgbmVlZCB0byBp bnRlci1vcGVyYXRlIHdpdGggZG1hLWJ1Zi4KKyAqLworc3RydWN0IGRtYV9idWZfZXhwb3J0X3N5 bmNfZmlsZSB7CisJLyoqCisJICogQGZsYWdzOiBSZWFkL3dyaXRlIGZsYWdzCisJICoKKwkgKiBN dXN0IGJlIERNQV9CVUZfU1lOQ19SRUFELCBETUFfQlVGX1NZTkNfV1JJVEUsIG9yIGJvdGguCisJ ICoKKwkgKiBJZiBETUFfQlVGX1NZTkNfUkVBRCBpcyBzZXQgYW5kIERNQV9CVUZfU1lOQ19XUklU RSBpcyBub3Qgc2V0LAorCSAqIHRoZSByZXR1cm5lZCBzeW5jIGZpbGUgd2FpdHMgb24gYW55IHdy aXRlcnMgb2YgdGhlIGRtYS1idWYgdG8KKwkgKiBjb21wbGV0ZS4gIFdhaXRpbmcgb24gdGhlIHJl dHVybmVkIHN5bmMgZmlsZSBpcyBlcXVpdmFsZW50IHRvCisJICogcG9sbCgpIHdpdGggUE9MTElO LgorCSAqCisJICogSWYgRE1BX0JVRl9TWU5DX1dSSVRFIGlzIHNldCwgdGhlIHJldHVybmVkIHN5 bmMgZmlsZSB3YWl0cyBvbgorCSAqIGFueSB1c2VycyBvZiB0aGUgZG1hLWJ1ZiAocmVhZCBvciB3 cml0ZSkgdG8gY29tcGxldGUuICBXYWl0aW5nCisJICogb24gdGhlIHJldHVybmVkIHN5bmMgZmls ZSBpcyBlcXVpdmFsZW50IHRvIHBvbGwoKSB3aXRoIFBPTExPVVQuCisJICogSWYgYm90aCBETUFf QlVGX1NZTkNfV1JJVEUgYW5kIERNQV9CVUZfU1lOQ19SRUFEIGFyZSBzZXQsIHRoaXMKKwkgKiBp cyBlcXVpdmFsZW50IHRvIGp1c3QgRE1BX0JVRl9TWU5DX1dSSVRFLgorCSAqLworCV9fdTMyIGZs YWdzOworCS8qKiBAZmQ6IFJldHVybmVkIHN5bmMgZmlsZSBkZXNjcmlwdG9yICovCisJX19zMzIg ZmQ7Cit9OworCiAjZGVmaW5lIERNQV9CVUZfQkFTRQkJJ2InCiAjZGVmaW5lIERNQV9CVUZfSU9D VExfU1lOQwlfSU9XKERNQV9CVUZfQkFTRSwgMCwgc3RydWN0IGRtYV9idWZfc3luYykKIApAQCAt NzYsNSArMTEwLDYgQEAgc3RydWN0IGRtYV9idWZfc3luYyB7CiAjZGVmaW5lIERNQV9CVUZfU0VU X05BTUUJX0lPVyhETUFfQlVGX0JBU0UsIDEsIGNvbnN0IGNoYXIgKikKICNkZWZpbmUgRE1BX0JV Rl9TRVRfTkFNRV9BCV9JT1coRE1BX0JVRl9CQVNFLCAxLCB1MzIpCiAjZGVmaW5lIERNQV9CVUZf U0VUX05BTUVfQglfSU9XKERNQV9CVUZfQkFTRSwgMSwgdTY0KQorI2RlZmluZSBETUFfQlVGX0lP Q1RMX0VYUE9SVF9TWU5DX0ZJTEUJX0lPV1IoRE1BX0JVRl9CQVNFLCAyLCBzdHJ1Y3QgZG1hX2J1 Zl9leHBvcnRfc3luY19maWxlKQogCiAjZW5kaWYKLS0gCjIuMzEuMQoKX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJ bnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Au b3JnL21haWxtYW4vbGlzdGluZm8vaW50ZWwtZ2Z4Cg==