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.
This patch series actually contains two new ioctls. There is the export one mentioned above as well as an RFC for an import ioctl which provides the other half. The intention is to land the export ioctl since it seems like there's no real disagreement on that one. The import ioctl, however, has a lot of debate around it so it's intended to be RFC-only for now.
Mesa MR: https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/4037 IGT tests: https://patchwork.freedesktop.org/series/90490/
v10 (Jason Ekstrand, Daniel Vetter): - Add reviews/acks - Add a patch to rename _rcu to _unlocked - Split things better so import is clearly RFC status
v11 (Daniel Vetter): - Add more CCs to try and get maintainers - Add a patch to document DMA_BUF_IOCTL_SYNC - Generally better docs - Use separate structs for import/export (easier to document) - Fix an issue in the import patch
v12 (Daniel Vetter): - Better docs for DMA_BUF_IOCTL_SYNC
v12 (Christian König): - Drop the rename patch in favor of Christian's series - Add a comment to the commit message for the dma-buf sync_file export ioctl saying why we made it an ioctl on dma-buf
v13 (Jason Ekstrand): - Rebase on Christian König's fence rework
v14 (Daniel Vetter and Christian König): - Use dma_rev_usage_rw to get the properly inverted usage to pass to dma_resv_get_singleton() for export - Clean up the sync_file and fd if copy_to_user() fails - Fix -EINVAL checks for the flags parameter in import - Add documentation about read/write fences for import - Add documentation about the expected usage of import/export and specifically call out the possible userspace race.
Jason Ekstrand (2): dma-buf: Add an API for exporting sync files (v14) dma-buf: Add an API for importing sync files (v9)
drivers/dma-buf/dma-buf.c | 106 +++++++++++++++++++++++++++++++++++ include/uapi/linux/dma-buf.h | 84 +++++++++++++++++++++++++++ 2 files changed, 190 insertions(+)
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.
By making this an ioctl on the dma-buf itself, it allows this new functionality to be used in an entirely driver-agnostic way without having access to a DRM fd. This makes it ideal for use in driver-generic code in Mesa or in a client such as a compositor where the DRM fd may be hard to reach.
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
v12 (Christian König): - Document why we chose to make it an ioctl on dma-buf
v13 (Jason Ekstrand): - Rebase on Christian König's fence rework
v14 (Daniel Vetter & Christian König): - Use dma_rev_usage_rw to get the properly inverted usage to pass to dma_resv_get_singleton() - Clean up the sync_file and fd if copy_to_user() fails
Signed-off-by: Jason Ekstrand jason@jlekstrand.net Signed-off-by: Jason Ekstrand jason.ekstrand@intel.com Signed-off-by: Jason Ekstrand jason.ekstrand@collabora.com Acked-by: Simon Ser contact@emersion.fr Acked-by: Christian König christian.koenig@amd.com Reviewed-by: Daniel Vetter daniel.vetter@ffwll.ch Cc: Sumit Semwal sumit.semwal@linaro.org Cc: Maarten Lankhorst maarten.lankhorst@linux.intel.com --- 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 79795857be3e..6ff54f7e6119 100644 --- a/drivers/dma-buf/dma-buf.c +++ b/drivers/dma-buf/dma-buf.c @@ -20,6 +20,7 @@ #include <linux/debugfs.h> #include <linux/module.h> #include <linux/seq_file.h> +#include <linux/sync_file.h> #include <linux/poll.h> #include <linux/dma-resv.h> #include <linux/mm.h> @@ -192,6 +193,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) @@ -326,6 +330,64 @@ static long dma_buf_set_name(struct dma_buf *dmabuf, const char __user *buf) return 0; }
+#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; + enum dma_resv_usage usage; + 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; + + usage = dma_resv_usage_rw(arg.flags & DMA_BUF_SYNC_WRITE); + ret = dma_resv_get_singleton(dmabuf->resv, usage, &fence); + if (ret) + goto err_put_fd; + + 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; + } + + arg.fd = fd; + if (copy_to_user(user_data, &arg, sizeof(arg))) { + ret = -EFAULT; + goto err_put_file; + } + + fd_install(fd, sync_file->file); + + return 0; + +err_put_file: + fput(sync_file->file); +err_put_fd: + put_unused_fd(fd); + return ret; +} +#endif + static long dma_buf_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { @@ -369,6 +431,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 8e4a2ca0bcbf..46f1e3e98b02 100644 --- a/include/uapi/linux/dma-buf.h +++ b/include/uapi/linux/dma-buf.h @@ -85,6 +85,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)
@@ -94,5 +128,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
Reviewed-by: Christian König christian.koenig@amd.com for the series.
I assume you have the userspace part ready as well? If yes let's push this to drm-misc-next asap.
Christian.
Am 06.05.22 um 20:02 schrieb Jason Ekstrand:
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.
By making this an ioctl on the dma-buf itself, it allows this new functionality to be used in an entirely driver-agnostic way without having access to a DRM fd. This makes it ideal for use in driver-generic code in Mesa or in a client such as a compositor where the DRM fd may be hard to reach.
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
v12 (Christian König):
- Document why we chose to make it an ioctl on dma-buf
v13 (Jason Ekstrand):
- Rebase on Christian König's fence rework
v14 (Daniel Vetter & Christian König):
- Use dma_rev_usage_rw to get the properly inverted usage to pass to dma_resv_get_singleton()
- Clean up the sync_file and fd if copy_to_user() fails
Signed-off-by: Jason Ekstrand jason@jlekstrand.net Signed-off-by: Jason Ekstrand jason.ekstrand@intel.com Signed-off-by: Jason Ekstrand jason.ekstrand@collabora.com Acked-by: Simon Ser contact@emersion.fr Acked-by: Christian König christian.koenig@amd.com Reviewed-by: Daniel Vetter daniel.vetter@ffwll.ch Cc: Sumit Semwal sumit.semwal@linaro.org Cc: Maarten Lankhorst maarten.lankhorst@linux.intel.com
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 79795857be3e..6ff54f7e6119 100644 --- a/drivers/dma-buf/dma-buf.c +++ b/drivers/dma-buf/dma-buf.c @@ -20,6 +20,7 @@ #include <linux/debugfs.h> #include <linux/module.h> #include <linux/seq_file.h> +#include <linux/sync_file.h> #include <linux/poll.h> #include <linux/dma-resv.h> #include <linux/mm.h> @@ -192,6 +193,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)
@@ -326,6 +330,64 @@ static long dma_buf_set_name(struct dma_buf *dmabuf, const char __user *buf) return 0; }
+#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;
- enum dma_resv_usage usage;
- 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;- usage = dma_resv_usage_rw(arg.flags & DMA_BUF_SYNC_WRITE);
- ret = dma_resv_get_singleton(dmabuf->resv, usage, &fence);
- if (ret)
goto err_put_fd;- 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;- }
- arg.fd = fd;
- if (copy_to_user(user_data, &arg, sizeof(arg))) {
ret = -EFAULT;goto err_put_file;- }
- fd_install(fd, sync_file->file);
- return 0;
+err_put_file:
- fput(sync_file->file);
+err_put_fd:
- put_unused_fd(fd);
- return ret;
+} +#endif
- static long dma_buf_ioctl(struct file *file, unsigned int cmd, unsigned long arg) {
@@ -369,6 +431,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 8e4a2ca0bcbf..46f1e3e98b02 100644 --- a/include/uapi/linux/dma-buf.h +++ b/include/uapi/linux/dma-buf.h @@ -85,6 +85,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)
@@ -94,5 +128,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
On Mon, May 09, 2022 at 07:54:19AM +0200, Christian König wrote:
Reviewed-by: Christian König christian.koenig@amd.com for the series.
I assume you have the userspace part ready as well? If yes let's push this to drm-misc-next asap.
Hopefully I'm not too late, but I think all my review has also been addressed. On the series:
Reviewed-by: Daniel Vetter daniel.vetter@ffwll.ch
Christian.
Am 06.05.22 um 20:02 schrieb Jason Ekstrand:
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.
By making this an ioctl on the dma-buf itself, it allows this new functionality to be used in an entirely driver-agnostic way without having access to a DRM fd. This makes it ideal for use in driver-generic code in Mesa or in a client such as a compositor where the DRM fd may be hard to reach.
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
v12 (Christian König):
- Document why we chose to make it an ioctl on dma-buf
v13 (Jason Ekstrand):
- Rebase on Christian König's fence rework
v14 (Daniel Vetter & Christian König):
- Use dma_rev_usage_rw to get the properly inverted usage to pass to dma_resv_get_singleton()
- Clean up the sync_file and fd if copy_to_user() fails
Signed-off-by: Jason Ekstrand jason@jlekstrand.net Signed-off-by: Jason Ekstrand jason.ekstrand@intel.com Signed-off-by: Jason Ekstrand jason.ekstrand@collabora.com Acked-by: Simon Ser contact@emersion.fr Acked-by: Christian König christian.koenig@amd.com Reviewed-by: Daniel Vetter daniel.vetter@ffwll.ch Cc: Sumit Semwal sumit.semwal@linaro.org Cc: Maarten Lankhorst maarten.lankhorst@linux.intel.com
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 79795857be3e..6ff54f7e6119 100644 --- a/drivers/dma-buf/dma-buf.c +++ b/drivers/dma-buf/dma-buf.c @@ -20,6 +20,7 @@ #include <linux/debugfs.h> #include <linux/module.h> #include <linux/seq_file.h> +#include <linux/sync_file.h> #include <linux/poll.h> #include <linux/dma-resv.h> #include <linux/mm.h> @@ -192,6 +193,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
*/ static void dma_buf_poll_cb(struct dma_fence *fence, struct dma_fence_cb *cb)
- exported as a &sync_file using &dma_buf_sync_file_export.
@@ -326,6 +330,64 @@ static long dma_buf_set_name(struct dma_buf *dmabuf, const char __user *buf) return 0; } +#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;
- enum dma_resv_usage usage;
- 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;- usage = dma_resv_usage_rw(arg.flags & DMA_BUF_SYNC_WRITE);
- ret = dma_resv_get_singleton(dmabuf->resv, usage, &fence);
- if (ret)
goto err_put_fd;- 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;- }
- arg.fd = fd;
- if (copy_to_user(user_data, &arg, sizeof(arg))) {
ret = -EFAULT;goto err_put_file;- }
- fd_install(fd, sync_file->file);
- return 0;
+err_put_file:
- fput(sync_file->file);
+err_put_fd:
- put_unused_fd(fd);
- return ret;
+} +#endif
- static long dma_buf_ioctl(struct file *file, unsigned int cmd, unsigned long arg) {
@@ -369,6 +431,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 8e4a2ca0bcbf..46f1e3e98b02 100644 --- a/include/uapi/linux/dma-buf.h +++ b/include/uapi/linux/dma-buf.h @@ -85,6 +85,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)
@@ -94,5 +128,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
On Wed, May 25, 2022 at 8:20 AM Daniel Vetter daniel@ffwll.ch wrote:
On Mon, May 09, 2022 at 07:54:19AM +0200, Christian König wrote:
Reviewed-by: Christian König christian.koenig@amd.com for the series.
I assume you have the userspace part ready as well? If yes let's push
this
to drm-misc-next asap.
Hopefully I'm not too late, but I think all my review has also been addressed. On the series:
Reviewed-by: Daniel Vetter daniel.vetter@ffwll.ch
Thanks! If Christian hasn't already, can we get this in drm-misc-next please? I don't have access AFAIK.
--Jason
Christian.
Am 06.05.22 um 20:02 schrieb Jason Ekstrand:
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.
By making this an ioctl on the dma-buf itself, it allows this new functionality to be used in an entirely driver-agnostic way without having access to a DRM fd. This makes it ideal for use in
driver-generic
code in Mesa or in a client such as a compositor where the DRM fd may
be
hard to reach.
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
v12 (Christian König):
- Document why we chose to make it an ioctl on dma-buf
v13 (Jason Ekstrand):
- Rebase on Christian König's fence rework
v14 (Daniel Vetter & Christian König):
- Use dma_rev_usage_rw to get the properly inverted usage to pass to dma_resv_get_singleton()
- Clean up the sync_file and fd if copy_to_user() fails
Signed-off-by: Jason Ekstrand jason@jlekstrand.net Signed-off-by: Jason Ekstrand jason.ekstrand@intel.com Signed-off-by: Jason Ekstrand jason.ekstrand@collabora.com Acked-by: Simon Ser contact@emersion.fr Acked-by: Christian König christian.koenig@amd.com Reviewed-by: Daniel Vetter daniel.vetter@ffwll.ch Cc: Sumit Semwal sumit.semwal@linaro.org Cc: Maarten Lankhorst maarten.lankhorst@linux.intel.com
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 79795857be3e..6ff54f7e6119 100644 --- a/drivers/dma-buf/dma-buf.c +++ b/drivers/dma-buf/dma-buf.c @@ -20,6 +20,7 @@ #include <linux/debugfs.h> #include <linux/module.h> #include <linux/seq_file.h> +#include <linux/sync_file.h> #include <linux/poll.h> #include <linux/dma-resv.h> #include <linux/mm.h> @@ -192,6 +193,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
*/ static void dma_buf_poll_cb(struct dma_fence *fence, struct
- exported as a &sync_file using &dma_buf_sync_file_export.
dma_fence_cb *cb)
@@ -326,6 +330,64 @@ static long dma_buf_set_name(struct dma_buf
*dmabuf, const char __user *buf)
return 0;} +#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;
- enum dma_resv_usage usage;
- 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;- usage = dma_resv_usage_rw(arg.flags & DMA_BUF_SYNC_WRITE);
- ret = dma_resv_get_singleton(dmabuf->resv, usage, &fence);
- if (ret)
goto err_put_fd;- 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;- }
- arg.fd = fd;
- if (copy_to_user(user_data, &arg, sizeof(arg))) {
ret = -EFAULT;goto err_put_file;- }
- fd_install(fd, sync_file->file);
- return 0;
+err_put_file:
- fput(sync_file->file);
+err_put_fd:
- put_unused_fd(fd);
- return ret;
+} +#endif
- static long dma_buf_ioctl(struct file *file, unsigned int cmd, unsigned long arg) {
@@ -369,6 +431,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 8e4a2ca0bcbf..46f1e3e98b02 100644 --- a/include/uapi/linux/dma-buf.h +++ b/include/uapi/linux/dma-buf.h @@ -85,6 +85,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)
@@ -94,5 +128,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
-- Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch
On Wed, May 25, 2022 at 10:35:47AM -0500, Jason Ekstrand wrote:
On Wed, May 25, 2022 at 8:20 AM Daniel Vetter daniel@ffwll.ch wrote:
On Mon, May 09, 2022 at 07:54:19AM +0200, Christian König wrote:
Reviewed-by: Christian König christian.koenig@amd.com for the series.
I assume you have the userspace part ready as well? If yes let's push
this
to drm-misc-next asap.
Hopefully I'm not too late, but I think all my review has also been addressed. On the series:
Reviewed-by: Daniel Vetter daniel.vetter@ffwll.ch
Thanks! If Christian hasn't already, can we get this in drm-misc-next please? I don't have access AFAIK.
We need to fix this? -Daniel
--Jason
Christian.
Am 06.05.22 um 20:02 schrieb Jason Ekstrand:
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.
By making this an ioctl on the dma-buf itself, it allows this new functionality to be used in an entirely driver-agnostic way without having access to a DRM fd. This makes it ideal for use in
driver-generic
code in Mesa or in a client such as a compositor where the DRM fd may
be
hard to reach.
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
v12 (Christian König):
- Document why we chose to make it an ioctl on dma-buf
v13 (Jason Ekstrand):
- Rebase on Christian König's fence rework
v14 (Daniel Vetter & Christian König):
- Use dma_rev_usage_rw to get the properly inverted usage to pass to dma_resv_get_singleton()
- Clean up the sync_file and fd if copy_to_user() fails
Signed-off-by: Jason Ekstrand jason@jlekstrand.net Signed-off-by: Jason Ekstrand jason.ekstrand@intel.com Signed-off-by: Jason Ekstrand jason.ekstrand@collabora.com Acked-by: Simon Ser contact@emersion.fr Acked-by: Christian König christian.koenig@amd.com Reviewed-by: Daniel Vetter daniel.vetter@ffwll.ch Cc: Sumit Semwal sumit.semwal@linaro.org Cc: Maarten Lankhorst maarten.lankhorst@linux.intel.com
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 79795857be3e..6ff54f7e6119 100644 --- a/drivers/dma-buf/dma-buf.c +++ b/drivers/dma-buf/dma-buf.c @@ -20,6 +20,7 @@ #include <linux/debugfs.h> #include <linux/module.h> #include <linux/seq_file.h> +#include <linux/sync_file.h> #include <linux/poll.h> #include <linux/dma-resv.h> #include <linux/mm.h> @@ -192,6 +193,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
*/ static void dma_buf_poll_cb(struct dma_fence *fence, struct
- exported as a &sync_file using &dma_buf_sync_file_export.
dma_fence_cb *cb)
@@ -326,6 +330,64 @@ static long dma_buf_set_name(struct dma_buf
*dmabuf, const char __user *buf)
return 0;} +#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;
- enum dma_resv_usage usage;
- 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;- usage = dma_resv_usage_rw(arg.flags & DMA_BUF_SYNC_WRITE);
- ret = dma_resv_get_singleton(dmabuf->resv, usage, &fence);
- if (ret)
goto err_put_fd;- 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;- }
- arg.fd = fd;
- if (copy_to_user(user_data, &arg, sizeof(arg))) {
ret = -EFAULT;goto err_put_file;- }
- fd_install(fd, sync_file->file);
- return 0;
+err_put_file:
- fput(sync_file->file);
+err_put_fd:
- put_unused_fd(fd);
- return ret;
+} +#endif
- static long dma_buf_ioctl(struct file *file, unsigned int cmd, unsigned long arg) {
@@ -369,6 +431,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 8e4a2ca0bcbf..46f1e3e98b02 100644 --- a/include/uapi/linux/dma-buf.h +++ b/include/uapi/linux/dma-buf.h @@ -85,6 +85,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)
@@ -94,5 +128,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
-- Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch
On Wed, May 25, 2022 at 10:43 AM Daniel Vetter daniel@ffwll.ch wrote:
On Wed, May 25, 2022 at 10:35:47AM -0500, Jason Ekstrand wrote:
On Wed, May 25, 2022 at 8:20 AM Daniel Vetter daniel@ffwll.ch wrote:
On Mon, May 09, 2022 at 07:54:19AM +0200, Christian König wrote:
Reviewed-by: Christian König christian.koenig@amd.com for the
series.
I assume you have the userspace part ready as well? If yes let's push
this
to drm-misc-next asap.
Hopefully I'm not too late, but I think all my review has also been addressed. On the series:
Reviewed-by: Daniel Vetter daniel.vetter@ffwll.ch
Thanks! If Christian hasn't already, can we get this in drm-misc-next please? I don't have access AFAIK.
We need to fix this?
I don't do enough kernel dev to be worth giving access, I don't think. It's infrequent enough that I'm going to have to ask someone else how to use the tools to push stuff every time anyway.
--Jason
-Daniel
--Jason
Christian.
Am 06.05.22 um 20:02 schrieb Jason Ekstrand:
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.
By making this an ioctl on the dma-buf itself, it allows this new functionality to be used in an entirely driver-agnostic way without having access to a DRM fd. This makes it ideal for use in
driver-generic
code in Mesa or in a client such as a compositor where the DRM fd
may
be
hard to reach.
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
v12 (Christian König):
- Document why we chose to make it an ioctl on dma-buf
v13 (Jason Ekstrand):
- Rebase on Christian König's fence rework
v14 (Daniel Vetter & Christian König):
- Use dma_rev_usage_rw to get the properly inverted usage to
pass to
dma_resv_get_singleton()
- Clean up the sync_file and fd if copy_to_user() fails
Signed-off-by: Jason Ekstrand jason@jlekstrand.net Signed-off-by: Jason Ekstrand jason.ekstrand@intel.com Signed-off-by: Jason Ekstrand jason.ekstrand@collabora.com Acked-by: Simon Ser contact@emersion.fr Acked-by: Christian König christian.koenig@amd.com Reviewed-by: Daniel Vetter daniel.vetter@ffwll.ch Cc: Sumit Semwal sumit.semwal@linaro.org Cc: Maarten Lankhorst maarten.lankhorst@linux.intel.com
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 79795857be3e..6ff54f7e6119 100644 --- a/drivers/dma-buf/dma-buf.c +++ b/drivers/dma-buf/dma-buf.c @@ -20,6 +20,7 @@ #include <linux/debugfs.h> #include <linux/module.h> #include <linux/seq_file.h> +#include <linux/sync_file.h> #include <linux/poll.h> #include <linux/dma-resv.h> #include <linux/mm.h> @@ -192,6 +193,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
*/ static void dma_buf_poll_cb(struct dma_fence *fence, struct
- exported as a &sync_file using &dma_buf_sync_file_export.
dma_fence_cb *cb)
@@ -326,6 +330,64 @@ static long dma_buf_set_name(struct dma_buf
*dmabuf, const char __user *buf)
return 0;} +#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;
- enum dma_resv_usage usage;
- 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;- usage = dma_resv_usage_rw(arg.flags & DMA_BUF_SYNC_WRITE);
- ret = dma_resv_get_singleton(dmabuf->resv, usage, &fence);
- if (ret)
goto err_put_fd;- 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;- }
- arg.fd = fd;
- if (copy_to_user(user_data, &arg, sizeof(arg))) {
ret = -EFAULT;goto err_put_file;- }
- fd_install(fd, sync_file->file);
- return 0;
+err_put_file:
- fput(sync_file->file);
+err_put_fd:
- put_unused_fd(fd);
- return ret;
+} +#endif
- static long dma_buf_ioctl(struct file *file, unsigned int cmd, unsigned long arg) {
@@ -369,6 +431,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 8e4a2ca0bcbf..46f1e3e98b02 100644 --- a/include/uapi/linux/dma-buf.h +++ b/include/uapi/linux/dma-buf.h @@ -85,6 +85,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)
@@ -94,5 +128,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
-- Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch
-- Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch
This patch is analogous to the previous sync file export patch in that it allows you to import a sync_file into a dma-buf. Unlike the previous patch, however, this does add genuinely new functionality to dma-buf. Without this, the only way to attach a sync_file to a dma-buf is to submit a batch to your driver of choice which waits on the sync_file and claims to write to the dma-buf. Even if said batch is a no-op, a submit is typically way more overhead than just attaching a fence. A submit may also imply extra synchronization with other work because it happens on a hardware queue.
In the Vulkan world, this is useful for dealing with the out-fence from vkQueuePresent. Current Linux window-systems (X11, Wayland, etc.) all rely on dma-buf implicit sync. Since Vulkan is an explicit sync API, we get a set of fences (VkSemaphores) in vkQueuePresent and have to stash those as an exclusive (write) fence on the dma-buf. We handle it in Mesa today with the above mentioned dummy submit trick. This ioctl would allow us to set it directly without the dummy submit.
This may also open up possibilities for GPU drivers to move away from implicit sync for their kernel driver uAPI and instead provide sync files and rely on dma-buf import/export for communicating with other implicit sync clients.
We make the explicit choice here to only allow setting RW fences which translates to an exclusive fence on the dma_resv. There's no use for read-only fences for communicating with other implicit sync userspace and any such attempts are likely to be racy at best. When we got to insert the RW fence, the actual fence we set as the new exclusive fence is a combination of the sync_file provided by the user and all the other fences on the dma_resv. This ensures that the newly added exclusive fence will never signal before the old one would have and ensures that we don't break any dma_resv contracts. We require userspace to specify RW in the flags for symmetry with the export ioctl and in case we ever want to support read fences in the future.
There is one downside here that's worth documenting: If two clients writing to the same dma-buf using this API race with each other, their actions on the dma-buf may happen in parallel or in an undefined order. Both with and without this API, the pattern is the same: Collect all the fences on dma-buf, submit work which depends on said fences, and then set a new exclusive (write) fence on the dma-buf which depends on said work. The difference is that, when it's all handled by the GPU driver's submit ioctl, the three operations happen atomically under the dma_resv lock. If two userspace submits race, one will happen before the other. You aren't guaranteed which but you are guaranteed that they're strictly ordered. If userspace manages the fences itself, then these three operations happen separately and the two render operations may happen genuinely in parallel or get interleaved. However, this is a case of userspace racing with itself. As long as we ensure userspace can't back the kernel into a corner, it should be fine.
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): - Split import and export into separate patches - New commit message
v7 (Daniel Vetter): - Fix the uapi header to use the right struct in the ioctl - Use a separate dma_buf_import_sync_file struct - Add kerneldoc for dma_buf_import_sync_file
v8 (Jason Ekstrand): - Rebase on Christian König's fence rework
v9 (Daniel Vetter): - Fix -EINVAL checks for the flags parameter - Add documentation about read/write fences - Add documentation about the expected usage of import/export and specifically call out the possible userspace race.
Signed-off-by: Jason Ekstrand jason@jlekstrand.net Signed-off-by: Jason Ekstrand jason.ekstrand@intel.com Signed-off-by: Jason Ekstrand jason.ekstrand@collabora.com Cc: Christian König christian.koenig@amd.com Cc: Daniel Vetter daniel.vetter@ffwll.ch Cc: Sumit Semwal sumit.semwal@linaro.org Cc: Maarten Lankhorst maarten.lankhorst@linux.intel.com --- drivers/dma-buf/dma-buf.c | 39 ++++++++++++++++++++++++++++ include/uapi/linux/dma-buf.h | 49 ++++++++++++++++++++++++++++++++++++ 2 files changed, 88 insertions(+)
diff --git a/drivers/dma-buf/dma-buf.c b/drivers/dma-buf/dma-buf.c index 6ff54f7e6119..f23f1482eb38 100644 --- a/drivers/dma-buf/dma-buf.c +++ b/drivers/dma-buf/dma-buf.c @@ -386,6 +386,43 @@ static long dma_buf_export_sync_file(struct dma_buf *dmabuf, put_unused_fd(fd); return ret; } + +static long dma_buf_import_sync_file(struct dma_buf *dmabuf, + const void __user *user_data) +{ + struct dma_buf_import_sync_file arg; + struct dma_fence *fence; + enum dma_resv_usage usage; + int ret = 0; + + 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; + + fence = sync_file_get_fence(arg.fd); + if (!fence) + return -EINVAL; + + usage = (arg.flags & DMA_BUF_SYNC_WRITE) ? DMA_RESV_USAGE_WRITE : + DMA_RESV_USAGE_READ; + + dma_resv_lock(dmabuf->resv, NULL); + + ret = dma_resv_reserve_fences(dmabuf->resv, 1); + if (!ret) + dma_resv_add_fence(dmabuf->resv, fence, usage); + + dma_resv_unlock(dmabuf->resv); + + dma_fence_put(fence); + + return ret; +} #endif
static long dma_buf_ioctl(struct file *file, @@ -434,6 +471,8 @@ static long dma_buf_ioctl(struct file *file, #if IS_ENABLED(CONFIG_SYNC_FILE) case DMA_BUF_IOCTL_EXPORT_SYNC_FILE: return dma_buf_export_sync_file(dmabuf, (void __user *)arg); + case DMA_BUF_IOCTL_IMPORT_SYNC_FILE: + return dma_buf_import_sync_file(dmabuf, (const void __user *)arg); #endif
default: diff --git a/include/uapi/linux/dma-buf.h b/include/uapi/linux/dma-buf.h index 46f1e3e98b02..70e213a0d7d9 100644 --- a/include/uapi/linux/dma-buf.h +++ b/include/uapi/linux/dma-buf.h @@ -96,6 +96,24 @@ struct dma_buf_sync { * 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. + * + * The intended usage pattern is the following: + * + * 1. Export a sync_file with flags corresponding to the expected GPU usage + * via DMA_BUF_IOCTL_EXPORT_SYNC_FILE. + * + * 2. Submit rendering work which uses the dma-buf. The work should wait on + * the exported sync file before rendering and produce another sync_file + * when complete. + * + * 3. Import the rendering-complete sync_file into the dma-buf with flags + * corresponding to the GPU usage via DMA_BUF_IOCTL_EXPORT_SYNC_FILE. + * + * Unlike doing implicit synchronization via a GPU kernel driver's exec ioctl, + * the above is not a single atomic operation. If userspace wants to ensure + * ordering via these fences, it is the respnosibility of userspace to use + * locks or other mechanisms to ensure that no other context adds fences or + * submits work between steps 1 and 3 above. */ struct dma_buf_export_sync_file { /** @@ -119,6 +137,36 @@ struct dma_buf_export_sync_file { __s32 fd; };
+/** + * struct dma_buf_import_sync_file - Insert a sync_file into a dma-buf + * + * Userspace can perform a DMA_BUF_IOCTL_IMPORT_SYNC_FILE to insert a + * sync_file into a dma-buf for the purposes of implicit synchronization + * with other dma-buf consumers. This allows clients using explicitly + * synchronized APIs such as Vulkan to inter-op with dma-buf consumers + * which expect implicit synchronization such as OpenGL or most media + * drivers/video. + */ +struct dma_buf_import_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, + * this inserts the sync_file as a read-only fence. Any subsequent + * implicitly synchronized writes to this dma-buf will wait on this + * fence but reads will not. + * + * If DMA_BUF_SYNC_WRITE is set, this inserts the sync_file as a + * write fence. All subsequent implicitly synchronized access to + * this dma-buf will wait on this fence. + */ + __u32 flags; + /** @fd: Sync file descriptor */ + __s32 fd; +}; + #define DMA_BUF_BASE 'b' #define DMA_BUF_IOCTL_SYNC _IOW(DMA_BUF_BASE, 0, struct dma_buf_sync)
@@ -129,5 +177,6 @@ struct dma_buf_export_sync_file { #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) +#define DMA_BUF_IOCTL_IMPORT_SYNC_FILE _IOW(DMA_BUF_BASE, 3, struct dma_buf_import_sync_file)
#endif
On Friday, May 6th, 2022 at 20:02, Jason Ekstrand jason@jlekstrand.net wrote:
diff --git a/include/uapi/linux/dma-buf.h b/include/uapi/linux/dma-buf.h index 46f1e3e98b02..70e213a0d7d9 100644 --- a/include/uapi/linux/dma-buf.h +++ b/include/uapi/linux/dma-buf.h @@ -96,6 +96,24 @@ struct dma_buf_sync {
- 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.
- The intended usage pattern is the following:
- Export a sync_file with flags corresponding to the expected GPU usage
via DMA_BUF_IOCTL_EXPORT_SYNC_FILE.
- Submit rendering work which uses the dma-buf. The work should wait on
the exported sync file before rendering and produce another sync_file
when complete.
- Import the rendering-complete sync_file into the dma-buf with flags
corresponding to the GPU usage via DMA_BUF_IOCTL_EXPORT_SYNC_FILE.
This should read DMA_BUF_IOCTL_IMPORT_SYNC_FILE I think?
- Unlike doing implicit synchronization via a GPU kernel driver's exec ioctl,
- the above is not a single atomic operation. If userspace wants to ensure
- ordering via these fences, it is the respnosibility of userspace to use
- locks or other mechanisms to ensure that no other context adds fences or
*/
- submits work between steps 1 and 3 above.
struct dma_buf_export_sync_file { /**
On Sat, 7 May 2022 at 14:18, Jason Ekstrand jason@jlekstrand.net wrote:
This patch series actually contains two new ioctls. There is the export one mentioned above as well as an RFC for an import ioctl which provides the other half. The intention is to land the export ioctl since it seems like there's no real disagreement on that one. The import ioctl, however, has a lot of debate around it so it's intended to be RFC-only for now.
Errr, I think we're good with this one now right?
From the uAPI point of view, having looked through the Mesa MR, both are:
Acked-by: Daniel Stone daniels@collabora.com
Cheers, Daniel
On Wed, May 25, 2022 at 5:02 AM Daniel Stone daniel@fooishbar.org wrote:
On Sat, 7 May 2022 at 14:18, Jason Ekstrand jason@jlekstrand.net wrote:
This patch series actually contains two new ioctls. There is the export
one
mentioned above as well as an RFC for an import ioctl which provides the
other
half. The intention is to land the export ioctl since it seems like
there's
no real disagreement on that one. The import ioctl, however, has a lot
of
debate around it so it's intended to be RFC-only for now.
Errr, I think we're good with this one now right?
Yeah, I dropped the RFC from the patch, just not the description in the cover letter, apparently.
From the uAPI point of view, having looked through the Mesa MR, both are: Acked-by: Daniel Stone daniels@collabora.com
For reference: https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/4037
Yes, I agree it's gotten sufficient review at this point that I think we can call the uAPI reviewed. I'm good with landing now. Sorry that took so long but the original version I had only used half of the new API and I wanted to make sure both halves got good testing.
--Jason
Cheers, Daniel
Acked-by: Bas Nieuwenhuizen bas@basnieuwenhuizen.nl
Didn't test the latest version of everything, but I can confirm the UAPI worked fine for what we'd want to use it for with radv.
On Thu, May 26, 2022 at 8:47 AM Jason Ekstrand jason@jlekstrand.net wrote:
On Wed, May 25, 2022 at 5:02 AM Daniel Stone daniel@fooishbar.org wrote:
On Sat, 7 May 2022 at 14:18, Jason Ekstrand jason@jlekstrand.net wrote:
This patch series actually contains two new ioctls. There is the export one mentioned above as well as an RFC for an import ioctl which provides the other half. The intention is to land the export ioctl since it seems like there's no real disagreement on that one. The import ioctl, however, has a lot of debate around it so it's intended to be RFC-only for now.
Errr, I think we're good with this one now right?
Yeah, I dropped the RFC from the patch, just not the description in the cover letter, apparently.
From the uAPI point of view, having looked through the Mesa MR, both are: Acked-by: Daniel Stone daniels@collabora.com
For reference: https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/4037
Yes, I agree it's gotten sufficient review at this point that I think we can call the uAPI reviewed. I'm good with landing now. Sorry that took so long but the original version I had only used half of the new API and I wanted to make sure both halves got good testing.
--Jason
Cheers, Daniel
The uAPI looks good to me as well, if that helps.
Acked-by: Simon Ser contact@emersion.fr
dri-devel@lists.freedesktop.org
-
Bas Nieuwenhuizen -
Christian König -
Daniel Stone -
Daniel Vetter -
Jason Ekstrand -
Simon Ser