KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
mesa/src/vulkan/runtime/vk_drm_syncobj.c

450 lines
14 KiB
C
Raw Permalink Blame History

/*
* Copyright © 2021 Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
#include "vk_drm_syncobj.h"
#include <sched.h>
#include <xf86drm.h>
#include "drm-uapi/drm.h"
#include "util/os_time.h"
#include "vk_device.h"
#include "vk_log.h"
#include "vk_util.h"
static struct vk_drm_syncobj *
to_drm_syncobj(struct vk_sync *sync)
{
assert(vk_sync_type_is_drm_syncobj(sync->type));
return container_of(sync, struct vk_drm_syncobj, base);
}
static VkResult
vk_drm_syncobj_init(struct vk_device *device,
struct vk_sync *sync,
uint64_t initial_value)
{
struct vk_drm_syncobj *sobj = to_drm_syncobj(sync);
uint32_t flags = 0;
if (!(sync->flags & VK_SYNC_IS_TIMELINE) && initial_value)
flags |= DRM_SYNCOBJ_CREATE_SIGNALED;
assert(device->drm_fd >= 0);
int err = drmSyncobjCreate(device->drm_fd, flags, &sobj->syncobj);
if (err < 0) {
return vk_errorf(device, VK_ERROR_OUT_OF_HOST_MEMORY,
"DRM_IOCTL_SYNCOBJ_CREATE failed: %m");
}
if ((sync->flags & VK_SYNC_IS_TIMELINE) && initial_value) {
err = drmSyncobjTimelineSignal(device->drm_fd, &sobj->syncobj,
&initial_value, 1);
if (err < 0) {
vk_drm_syncobj_finish(device, sync);
return vk_errorf(device, VK_ERROR_OUT_OF_HOST_MEMORY,
"DRM_IOCTL_SYNCOBJ_CREATE failed: %m");
}
}
return VK_SUCCESS;
}
void
vk_drm_syncobj_finish(struct vk_device *device,
struct vk_sync *sync)
{
struct vk_drm_syncobj *sobj = to_drm_syncobj(sync);
assert(device->drm_fd >= 0);
ASSERTED int err = drmSyncobjDestroy(device->drm_fd, sobj->syncobj);
assert(err == 0);
}
static VkResult
vk_drm_syncobj_signal(struct vk_device *device,
struct vk_sync *sync,
uint64_t value)
{
struct vk_drm_syncobj *sobj = to_drm_syncobj(sync);
assert(device->drm_fd >= 0);
int err;
if (sync->flags & VK_SYNC_IS_TIMELINE)
err = drmSyncobjTimelineSignal(device->drm_fd, &sobj->syncobj, &value, 1);
else
err = drmSyncobjSignal(device->drm_fd, &sobj->syncobj, 1);
if (err) {
return vk_errorf(device, VK_ERROR_UNKNOWN,
"DRM_IOCTL_SYNCOBJ_SIGNAL failed: %m");
}
return VK_SUCCESS;
}
static VkResult
vk_drm_syncobj_get_value(struct vk_device *device,
struct vk_sync *sync,
uint64_t *value)
{
struct vk_drm_syncobj *sobj = to_drm_syncobj(sync);
assert(device->drm_fd >= 0);
int err = drmSyncobjQuery(device->drm_fd, &sobj->syncobj, value, 1);
if (err) {
return vk_errorf(device, VK_ERROR_UNKNOWN,
"DRM_IOCTL_SYNCOBJ_QUERY failed: %m");
}
return VK_SUCCESS;
}
static VkResult
vk_drm_syncobj_reset(struct vk_device *device,
struct vk_sync *sync)
{
struct vk_drm_syncobj *sobj = to_drm_syncobj(sync);
assert(device->drm_fd >= 0);
int err = drmSyncobjReset(device->drm_fd, &sobj->syncobj, 1);
if (err) {
return vk_errorf(device, VK_ERROR_UNKNOWN,
"DRM_IOCTL_SYNCOBJ_RESET failed: %m");
}
return VK_SUCCESS;
}
static VkResult
sync_has_sync_file(struct vk_device *device, struct vk_sync *sync)
{
uint32_t handle = to_drm_syncobj(sync)->syncobj;
int fd = -1;
int err = drmSyncobjExportSyncFile(device->drm_fd, handle, &fd);
if (!err) {
close(fd);
return VK_SUCCESS;
}
/* On the off chance the sync_file export repeatedly fails for some
* unexpected reason, we want to ensure this function will return success
* eventually. Do a zero-time syncobj wait if the export failed.
*/
err = drmSyncobjWait(device->drm_fd, &handle, 1, 0 /* timeout */,
DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT,
NULL /* first_signaled */);
if (!err) {
return VK_SUCCESS;
} else if (errno == ETIME) {
return VK_TIMEOUT;
} else {
return vk_errorf(device, VK_ERROR_UNKNOWN,
"DRM_IOCTL_SYNCOBJ_WAIT failed: %m");
}
}
static VkResult
spin_wait_for_sync_file(struct vk_device *device,
uint32_t wait_count,
const struct vk_sync_wait *waits,
enum vk_sync_wait_flags wait_flags,
uint64_t abs_timeout_ns)
{
if (wait_flags & VK_SYNC_WAIT_ANY) {
while (1) {
for (uint32_t i = 0; i < wait_count; i++) {
VkResult result = sync_has_sync_file(device, waits[i].sync);
if (result != VK_TIMEOUT)
return result;
}
if (os_time_get_nano() >= abs_timeout_ns)
return VK_TIMEOUT;
sched_yield();
}
} else {
for (uint32_t i = 0; i < wait_count; i++) {
while (1) {
VkResult result = sync_has_sync_file(device, waits[i].sync);
if (result != VK_TIMEOUT)
return result;
if (os_time_get_nano() >= abs_timeout_ns)
return VK_TIMEOUT;
sched_yield();
}
}
}
return VK_SUCCESS;
}
static VkResult
vk_drm_syncobj_wait_many(struct vk_device *device,
uint32_t wait_count,
const struct vk_sync_wait *waits,
enum vk_sync_wait_flags wait_flags,
uint64_t abs_timeout_ns)
{
if ((wait_flags & VK_SYNC_WAIT_PENDING) &&
!(waits[0].sync->type->features & VK_SYNC_FEATURE_TIMELINE)) {
/* Sadly, DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE was never implemented
* for drivers that don't support timelines. Instead, we have to spin
* on DRM_IOCTL_SYNCOBJ_FD_TO_HANDLE until it succeeds.
*/
return spin_wait_for_sync_file(device, wait_count, waits,
wait_flags, abs_timeout_ns);
}
/* Syncobj timeouts are signed */
abs_timeout_ns = MIN2(abs_timeout_ns, (uint64_t)INT64_MAX);
STACK_ARRAY(uint32_t, handles, wait_count);
STACK_ARRAY(uint64_t, wait_values, wait_count);
uint32_t j = 0;
bool has_timeline = false;
for (uint32_t i = 0; i < wait_count; i++) {
/* The syncobj API doesn't like wait values of 0 but it's safe to skip
* them because a wait for 0 is a no-op.
*/
if (waits[i].sync->flags & VK_SYNC_IS_TIMELINE) {
if (waits[i].wait_value == 0)
continue;
has_timeline = true;
}
handles[j] = to_drm_syncobj(waits[i].sync)->syncobj;
wait_values[j] = waits[i].wait_value;
j++;
}
assert(j <= wait_count);
wait_count = j;
uint32_t syncobj_wait_flags = DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT;
if (!(wait_flags & VK_SYNC_WAIT_ANY))
syncobj_wait_flags |= DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL;
assert(device->drm_fd >= 0);
int err;
if (wait_count == 0) {
err = 0;
} else if (wait_flags & VK_SYNC_WAIT_PENDING) {
/* We always use a timeline wait for WAIT_PENDING, even for binary
* syncobjs because the non-timeline wait doesn't support
* DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE.
*/
err = drmSyncobjTimelineWait(device->drm_fd, handles, wait_values,
wait_count, abs_timeout_ns,
syncobj_wait_flags |
DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE,
NULL /* first_signaled */);
} else if (has_timeline) {
err = drmSyncobjTimelineWait(device->drm_fd, handles, wait_values,
wait_count, abs_timeout_ns,
syncobj_wait_flags,
NULL /* first_signaled */);
} else {
err = drmSyncobjWait(device->drm_fd, handles,
wait_count, abs_timeout_ns,
syncobj_wait_flags,
NULL /* first_signaled */);
}
STACK_ARRAY_FINISH(handles);
STACK_ARRAY_FINISH(wait_values);
if (err && errno == ETIME) {
return VK_TIMEOUT;
} else if (err) {
return vk_errorf(device, VK_ERROR_UNKNOWN,
"DRM_IOCTL_SYNCOBJ_WAIT failed: %m");
}
return VK_SUCCESS;
}
static VkResult
vk_drm_syncobj_import_opaque_fd(struct vk_device *device,
struct vk_sync *sync,
int fd)
{
struct vk_drm_syncobj *sobj = to_drm_syncobj(sync);
assert(device->drm_fd >= 0);
uint32_t new_handle;
int err = drmSyncobjFDToHandle(device->drm_fd, fd, &new_handle);
if (err) {
return vk_errorf(device, VK_ERROR_UNKNOWN,
"DRM_IOCTL_SYNCOBJ_FD_TO_HANDLE failed: %m");
}
err = drmSyncobjDestroy(device->drm_fd, sobj->syncobj);
assert(!err);
sobj->syncobj = new_handle;
return VK_SUCCESS;
}
static VkResult
vk_drm_syncobj_export_opaque_fd(struct vk_device *device,
struct vk_sync *sync,
int *fd)
{
struct vk_drm_syncobj *sobj = to_drm_syncobj(sync);
assert(device->drm_fd >= 0);
int err = drmSyncobjHandleToFD(device->drm_fd, sobj->syncobj, fd);
if (err) {
return vk_errorf(device, VK_ERROR_UNKNOWN,
"DRM_IOCTL_SYNCOBJ_HANDLE_TO_FD failed: %m");
}
return VK_SUCCESS;
}
static VkResult
vk_drm_syncobj_import_sync_file(struct vk_device *device,
struct vk_sync *sync,
int sync_file)
{
struct vk_drm_syncobj *sobj = to_drm_syncobj(sync);
assert(device->drm_fd >= 0);
int err = drmSyncobjImportSyncFile(device->drm_fd, sobj->syncobj, sync_file);
if (err) {
return vk_errorf(device, VK_ERROR_UNKNOWN,
"DRM_IOCTL_SYNCOBJ_FD_TO_HANDLE failed: %m");
}
return VK_SUCCESS;
}
static VkResult
vk_drm_syncobj_export_sync_file(struct vk_device *device,
struct vk_sync *sync,
int *sync_file)
{
struct vk_drm_syncobj *sobj = to_drm_syncobj(sync);
assert(device->drm_fd >= 0);
int err = drmSyncobjExportSyncFile(device->drm_fd, sobj->syncobj, sync_file);
if (err) {
return vk_errorf(device, VK_ERROR_UNKNOWN,
"DRM_IOCTL_SYNCOBJ_HANDLE_TO_FD failed: %m");
}
return VK_SUCCESS;
}
static VkResult
vk_drm_syncobj_move(struct vk_device *device,
struct vk_sync *dst,
struct vk_sync *src)
{
struct vk_drm_syncobj *dst_sobj = to_drm_syncobj(dst);
struct vk_drm_syncobj *src_sobj = to_drm_syncobj(src);
VkResult result;
if (!(dst->flags & VK_SYNC_IS_SHARED) &&
!(src->flags & VK_SYNC_IS_SHARED)) {
result = vk_drm_syncobj_reset(device, dst);
if (unlikely(result != VK_SUCCESS))
return result;
uint32_t tmp = dst_sobj->syncobj;
dst_sobj->syncobj = src_sobj->syncobj;
src_sobj->syncobj = tmp;
return VK_SUCCESS;
} else {
int fd;
result = vk_drm_syncobj_export_sync_file(device, src, &fd);
if (result != VK_SUCCESS)
return result;
result = vk_drm_syncobj_import_sync_file(device, dst, fd);
if (fd >= 0)
close(fd);
if (result != VK_SUCCESS)
return result;
return vk_drm_syncobj_reset(device, src);
}
}
struct vk_sync_type
vk_drm_syncobj_get_type(int drm_fd)
{
uint32_t syncobj = 0;
int err = drmSyncobjCreate(drm_fd, DRM_SYNCOBJ_CREATE_SIGNALED, &syncobj);
if (err < 0)
return (struct vk_sync_type) { .features = 0 };
struct vk_sync_type type = {
.size = sizeof(struct vk_drm_syncobj),
.features = VK_SYNC_FEATURE_BINARY |
VK_SYNC_FEATURE_GPU_WAIT |
VK_SYNC_FEATURE_CPU_RESET |
VK_SYNC_FEATURE_CPU_SIGNAL |
VK_SYNC_FEATURE_WAIT_PENDING,
.init = vk_drm_syncobj_init,
.finish = vk_drm_syncobj_finish,
.signal = vk_drm_syncobj_signal,
.reset = vk_drm_syncobj_reset,
.move = vk_drm_syncobj_move,
.import_opaque_fd = vk_drm_syncobj_import_opaque_fd,
.export_opaque_fd = vk_drm_syncobj_export_opaque_fd,
.import_sync_file = vk_drm_syncobj_import_sync_file,
.export_sync_file = vk_drm_syncobj_export_sync_file,
};
err = drmSyncobjWait(drm_fd, &syncobj, 1, 0,
DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL,
NULL /* first_signaled */);
if (err == 0) {
type.wait_many = vk_drm_syncobj_wait_many;
type.features |= VK_SYNC_FEATURE_CPU_WAIT |
VK_SYNC_FEATURE_WAIT_ANY;
}
uint64_t cap;
err = drmGetCap(drm_fd, DRM_CAP_SYNCOBJ_TIMELINE, &cap);
if (err == 0 && cap != 0) {
type.get_value = vk_drm_syncobj_get_value;
type.features |= VK_SYNC_FEATURE_TIMELINE;
}
err = drmSyncobjDestroy(drm_fd, syncobj);
assert(err == 0);
return type;
}
Reference in New Issue View Git Blame Copy Permalink