summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/ioctl.cpp55
-rw-r--r--src/syncobject.cpp432
-rw-r--r--src/syncobject.hpp225
3 files changed, 382 insertions, 330 deletions
diff --git a/src/ioctl.cpp b/src/ioctl.cpp
new file mode 100644
index 0000000..982e1e9
--- /dev/null
+++ b/src/ioctl.cpp
@@ -0,0 +1,55 @@
+/* SPDX-License-Identifier: MIT */
+
+#include "drm++/ioctl.hpp"
+
+#include <format>
+#include <string>
+
+#include <errno.h>
+
+using namespace drm::ioctl;
+
+Exception::Exception(int fd, unsigned long op)
+ : m_fd(fd), m_op(op), m_syserrno(errno) {
+ switch (errno) {
+ case EBADF:
+ m_code = Error::BadFileDescriptor;
+ break;
+ case EINVAL:
+ case ENOTTY:
+ m_code = Error::InvalidArgument;
+ break;
+ case ENOTSUP:
+ m_code = Error::NotSupported;
+ break;
+ default:
+ m_code = Error::Other;
+ }
+}
+
+std::string Exception::readable() {
+ switch (this->m_code) {
+ case Error::BadFileDescriptor:
+ return std::format(
+ "ioctl({}, {}) failed: Invalid file descriptor",
+ this->m_fd, this->m_op
+ );
+ case Error::InvalidArgument:
+ return std::format(
+ "ioctl({}, {}) failed: Invalid argument (errno {})",
+ this->m_fd, this->m_op, this->m_syserrno
+ );
+ case Error::NotSupported:
+ return std::format(
+ "ioctl({}, {}) failed: Operation not supported",
+ this->m_fd, this->m_op
+ );
+ case Error::Other:
+ return std::format(
+ "ioctl({}, {}) failed: Unknown error (errno {})",
+ this->m_fd, this->m_op, this->m_syserrno
+ );
+ }
+}
+
+Exception::~Exception() = default;
diff --git a/src/syncobject.cpp b/src/syncobject.cpp
index 8d5e8b5..6614a9d 100644
--- a/src/syncobject.cpp
+++ b/src/syncobject.cpp
@@ -1,20 +1,26 @@
/* SPDX-License-Identifier: MIT */
-#include "syncobject.hpp"
-#include "priv/ioctl.hpp"
+#include "drm++/syncobject.hpp"
+#include "drm++/helper.hpp"
+#include "drm++/ioctl.hpp"
-#include <cstdint>
+#include <cstddef>
+#include <functional>
#include <optional>
#include <stdexcept>
#include <vector>
#include <unistd.h>
+#include <drm.h>
using namespace drm;
+using namespace drm::syncobj;
-SyncObject::SyncObject(int fd, bool signal) : m_fd(fd) {
+/* Binary Sync Objects */
+
+SyncObject::SyncObject(int fd, bool signaled) : m_fd(fd) {
drm_syncobj_create args{
- .flags = signal ? DRM_SYNCOBJ_CREATE_SIGNALED : 0U
+ .flags = signaled ? DRM_SYNCOBJ_CREATE_SIGNALED : 0U
};
ioctl::perform(this->m_fd, DRM_IOCTL_SYNCOBJ_CREATE, args);
@@ -51,13 +57,12 @@ int SyncObject::exportFd() const {
return args.fd;
}
-void SyncObject::importSyncFile(int syncfile_fd, uint64_t point, bool close) const {
+void SyncObject::importSyncFile(int syncfile_fd, bool close) const {
try {
drm_syncobj_handle args{
.handle = this->m_handle,
.flags = DRM_SYNCOBJ_FD_TO_HANDLE_FLAGS_IMPORT_SYNC_FILE,
- .fd = syncfile_fd,
- .point = point
+ .fd = syncfile_fd
};
ioctl::perform(this->m_fd, DRM_IOCTL_SYNCOBJ_FD_TO_HANDLE, args);
} catch (...) {
@@ -73,169 +78,386 @@ void SyncObject::importSyncFile(int syncfile_fd, uint64_t point, bool close) con
}
}
-int SyncObject::exportSyncFile(uint64_t point) const {
+int SyncObject::exportSyncFile() const {
drm_syncobj_handle args{
.handle = this->m_handle,
- .flags = DRM_SYNCOBJ_HANDLE_TO_FD_FLAGS_EXPORT_SYNC_FILE,
- .point = point
+ .flags = DRM_SYNCOBJ_HANDLE_TO_FD_FLAGS_EXPORT_SYNC_FILE
};
ioctl::perform(this->m_fd, DRM_IOCTL_SYNCOBJ_HANDLE_TO_FD, args);
return args.fd;
}
-void SyncObject::registerEventFd(int eventfd_fd, uint64_t point, bool waitAvailable) const {
+void SyncObject::transfer(const SyncObject& dest) const {
+ drm_syncobj_transfer args{
+ .src_handle = this->m_handle,
+ .dst_handle = dest.m_handle
+ };
+ ioctl::perform(this->m_fd, DRM_IOCTL_SYNCOBJ_TRANSFER, args);
+}
+
+void SyncObject::transfer(const TimelineSyncObject& dest, u64 destPoint) const {
+ drm_syncobj_transfer args{
+ .src_handle = this->m_handle,
+ .dst_handle = dest.handle(),
+ .dst_point = destPoint
+ };
+ ioctl::perform(this->m_fd, DRM_IOCTL_SYNCOBJ_TRANSFER, args);
+}
+
+void SyncObject::signal() const {
+ drm_syncobj_array args{
+ .handles = reinterpret_cast<u64>(&this->m_handle),
+ .count_handles = 1
+ };
+ ioctl::perform(this->m_fd, DRM_IOCTL_SYNCOBJ_SIGNAL, args);
+}
+
+void SyncObject::reset() const {
+ drm_syncobj_array args{
+ .handles = reinterpret_cast<u64>(&this->m_handle),
+ .count_handles = 1
+ };
+ ioctl::perform(this->m_fd, DRM_IOCTL_SYNCOBJ_RESET, args);
+}
+
+void SyncObject::wait(
+ s64 timeout,
+ WaitMode waitMode,
+ std::optional<u64> deadlineHint
+) const {
+ drm_syncobj_wait args{
+ .handles = reinterpret_cast<u64>(&this->m_handle),
+ .timeout_nsec = timeout,
+ .count_handles = 1,
+ .flags = (waitMode == WaitMode::WaitEmpty ? DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT : 0U) |
+ (waitMode == WaitMode::WaitAvailable ? DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE : 0U) |
+ (deadlineHint.has_value() ? DRM_SYNCOBJ_WAIT_FLAGS_WAIT_DEADLINE : 0U),
+ .deadline_nsec = deadlineHint.value_or(0)
+ };
+ ioctl::perform(this->m_fd, DRM_IOCTL_SYNCOBJ_WAIT, args);
+}
+
+void SyncObject::registerEventFd(int eventfd_fd, bool waitAvailable) const {
drm_syncobj_eventfd args{
.handle = this->m_handle,
.flags = waitAvailable ? DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE : 0U,
- .point = point,
.fd = eventfd_fd
};
ioctl::perform(this->m_fd, DRM_IOCTL_SYNCOBJ_EVENTFD, args);
}
-void SyncObject::transfer(uint32_t dstObject, uint64_t srcPoint, uint64_t dstPoint) const {
+void SyncObject::destruct() noexcept {
+ if (this->m_fd < 0) {
+ return;
+ }
+
+ drm_syncobj_destroy args{
+ .handle = this->m_handle
+ };
+ try {
+ ioctl::perform(this->m_fd, DRM_IOCTL_SYNCOBJ_DESTROY, args);
+ } catch(...) {
+ (void) 0; // not much we can do about the leak
+ }
+
+ this->m_fd = -1;
+}
+
+/* Timeline Sync Objects */
+
+TimelineSyncObject::TimelineSyncObject(int fd) : m_fd(fd) {
+ drm_syncobj_create args{
+ .flags = 0U
+ };
+ ioctl::perform(this->m_fd, DRM_IOCTL_SYNCOBJ_CREATE, args);
+
+ this->m_handle = args.handle;
+}
+
+TimelineSyncObject::TimelineSyncObject(int fd, int syncobj_fd, bool close) : m_fd(fd) {
+ try {
+ drm_syncobj_handle args{
+ .fd = syncobj_fd
+ };
+ ioctl::perform(this->m_fd, DRM_IOCTL_SYNCOBJ_FD_TO_HANDLE, args);
+
+ this->m_handle = args.handle;
+ } catch (...) {
+ if (close) {
+ ::close(syncobj_fd);
+ }
+
+ throw;
+ }
+
+ if (close) {
+ ::close(syncobj_fd);
+ }
+}
+
+int TimelineSyncObject::exportFd() const {
+ drm_syncobj_handle args{
+ .handle = this->m_handle,
+ };
+ ioctl::perform(this->m_fd, DRM_IOCTL_SYNCOBJ_HANDLE_TO_FD, args);
+
+ return args.fd;
+}
+
+void TimelineSyncObject::importSyncFile(int syncfile_fd, u64 point, bool close) const {
+ try {
+ drm_syncobj_handle args{
+ .handle = this->m_handle,
+ .flags = DRM_SYNCOBJ_FD_TO_HANDLE_FLAGS_IMPORT_SYNC_FILE
+ | DRM_SYNCOBJ_FD_TO_HANDLE_FLAGS_TIMELINE,
+ .fd = syncfile_fd,
+ .point = point
+ };
+ ioctl::perform(this->m_fd, DRM_IOCTL_SYNCOBJ_FD_TO_HANDLE, args);
+ } catch (...) {
+ if (close) {
+ ::close(syncfile_fd);
+ }
+
+ throw;
+ }
+
+ if (close) {
+ ::close(syncfile_fd);
+ }
+}
+
+int TimelineSyncObject::exportSyncFile(u64 point) const {
+ drm_syncobj_handle args{
+ .handle = this->m_handle,
+ .flags = DRM_SYNCOBJ_HANDLE_TO_FD_FLAGS_EXPORT_SYNC_FILE
+ | DRM_SYNCOBJ_HANDLE_TO_FD_FLAGS_TIMELINE,
+ .point = point
+ };
+ ioctl::perform(this->m_fd, DRM_IOCTL_SYNCOBJ_HANDLE_TO_FD, args);
+
+ return args.fd;
+}
+
+void TimelineSyncObject::transfer(
+ const TimelineSyncObject& dest,
+ u64 srcPoint,
+ u64 destPoint
+) const {
drm_syncobj_transfer args{
.src_handle = this->m_handle,
- .dst_handle = dstObject,
+ .dst_handle = dest.m_handle,
.src_point = srcPoint,
- .dst_point = dstPoint
+ .dst_point = destPoint
};
ioctl::perform(this->m_fd, DRM_IOCTL_SYNCOBJ_TRANSFER, args);
}
-void SyncObject::signal(
- int fd,
- const std::vector<uint32_t>& objects,
- const std::vector<uint64_t>& points
-) {
- if (objects.empty()) {
- return;
- }
+void TimelineSyncObject::transfer(const SyncObject& dest, u64 srcPoint) const {
+ drm_syncobj_transfer args{
+ .src_handle = this->m_handle,
+ .dst_handle = dest.handle(),
+ .src_point = srcPoint
+ };
+ ioctl::perform(this->m_fd, DRM_IOCTL_SYNCOBJ_TRANSFER, args);
+}
- if (points.empty()) {
- drm_syncobj_array args{
- .handles = reinterpret_cast<uint64_t>(objects.data()),
- .count_handles = static_cast<uint32_t>(objects.size())
- };
- ioctl::perform(fd, DRM_IOCTL_SYNCOBJ_SIGNAL, args);
+void TimelineSyncObject::signal(u64 point) const {
+ drm_syncobj_timeline_array args{
+ .handles = reinterpret_cast<u64>(&this->m_handle),
+ .points = reinterpret_cast<u64>(&point),
+ .count_handles = 1
+ };
+ ioctl::perform(this->m_fd, DRM_IOCTL_SYNCOBJ_TIMELINE_SIGNAL, args);
+}
+
+void TimelineSyncObject::wait(
+ s64 timeout,
+ u64 point,
+ bool waitAvailable,
+ std::optional<u64> deadlineHint
+) const {
+ drm_syncobj_timeline_wait args{
+ .handles = reinterpret_cast<u64>(&this->m_handle),
+ .points = reinterpret_cast<u64>(&point),
+ .timeout_nsec = timeout,
+ .count_handles = 1,
+ .flags = (waitAvailable ? DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE : 0U) |
+ (deadlineHint.has_value() ? DRM_SYNCOBJ_WAIT_FLAGS_WAIT_DEADLINE : 0U),
+ .deadline_nsec = deadlineHint.value_or(0)
+ };
+ ioctl::perform(this->m_fd, DRM_IOCTL_SYNCOBJ_WAIT, args);
+}
+
+u64 TimelineSyncObject::query(bool lastSubmitted) const {
+ u64 point{};
+
+ drm_syncobj_timeline_array args{
+ .handles = reinterpret_cast<u64>(&this->m_handle),
+ .points = reinterpret_cast<u64>(&point),
+ .count_handles = 1,
+ .flags = lastSubmitted ? DRM_SYNCOBJ_QUERY_FLAGS_LAST_SUBMITTED : 0U
+ };
+ ioctl::perform(this->m_fd, DRM_IOCTL_SYNCOBJ_QUERY, args);
+
+ return point;
+}
+
+void TimelineSyncObject::registerEventFd(
+ int eventfd_fd,
+ u64 point,
+ bool waitAvailable
+) const {
+ drm_syncobj_eventfd args{
+ .handle = this->m_handle,
+ .flags = waitAvailable ? DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE : 0U,
+ .point = point,
+ .fd = eventfd_fd
+ };
+ ioctl::perform(this->m_fd, DRM_IOCTL_SYNCOBJ_EVENTFD, args);
+}
+
+/* Bulk Operations */
+
+void syncobj::signal(const std::vector<std::reference_wrapper<SyncObject>>& objs) {
+ if (objs.empty()) {
+ return;
}
- if (points.size() != objects.size()) {
- throw std::invalid_argument("points size must match objects size");
+ std::vector<u32> handles(objs.size());
+ for (size_t i = 0; i < objs.size(); ++i) {
+ handles.at(i) = objs.at(i).get().handle();
}
- drm_syncobj_timeline_array args{
- .handles = reinterpret_cast<uint64_t>(objects.data()),
- .points = reinterpret_cast<uint64_t>(points.data()),
- .count_handles = static_cast<uint32_t>(objects.size())
+ drm_syncobj_array args{
+ .handles = reinterpret_cast<u64>(handles.data()),
+ .count_handles = static_cast<u32>(handles.size())
};
- ioctl::perform(fd, DRM_IOCTL_SYNCOBJ_TIMELINE_SIGNAL, args);
+ ioctl::perform(objs.front().get().fd(), DRM_IOCTL_SYNCOBJ_SIGNAL, args);
}
-void SyncObject::reset(int fd, const std::vector<uint32_t>& objects) {
- if (objects.empty()) {
+void syncobj::reset(const std::vector<std::reference_wrapper<SyncObject>>& objs) {
+ if (objs.empty()) {
return;
}
+ std::vector<u32> handles(objs.size());
+ for (size_t i = 0; i < objs.size(); ++i) {
+ handles.at(i) = objs.at(i).get().handle();
+ }
+
drm_syncobj_array args{
- .handles = reinterpret_cast<uint64_t>(objects.data()),
- .count_handles = static_cast<uint32_t>(objects.size())
+ .handles = reinterpret_cast<u64>(handles.data()),
+ .count_handles = static_cast<u32>(handles.size())
};
- ioctl::perform(fd, DRM_IOCTL_SYNCOBJ_RESET, args);
+ ioctl::perform(objs.front().get().fd(), DRM_IOCTL_SYNCOBJ_RESET, args);
}
-uint32_t SyncObject::wait(
- int fd,
- const std::vector<uint32_t>& objects,
- const std::vector<uint64_t>& points,
- int64_t timeout,
+SyncObject& syncobj::wait(
+ const std::vector<std::reference_wrapper<SyncObject>>& objs,
+ s64 timeout,
bool waitAll,
- bool waitEmpty,
- bool waitAvailable,
- std::optional<uint64_t> deadlineHint
+ WaitMode waitMode,
+ std::optional<u64> deadlineHint
) {
- if (objects.empty()) {
- return 0;
+ if (objs.empty()) {
+ throw std::invalid_argument("must wait on at least one object");
}
- if (waitAvailable) {
- waitEmpty = false;
+ std::vector<u32> handles(objs.size());
+ for (size_t i = 0; i < objs.size(); ++i) {
+ handles.at(i) = objs.at(i).get().handle();
}
- if (points.empty()) {
- drm_syncobj_wait args{
- .handles = reinterpret_cast<uint64_t>(objects.data()),
- .timeout_nsec = timeout,
- .count_handles = static_cast<uint32_t>(objects.size()),
- .flags =
- (waitAll ? DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL : 0U) |
- (waitEmpty ? DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT : 0U) |
- (waitAvailable ? DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE : 0U) |
- (deadlineHint.has_value() ? DRM_SYNCOBJ_WAIT_FLAGS_WAIT_DEADLINE : 0U),
- .deadline_nsec = deadlineHint.value_or(0)
- };
- ioctl::perform(fd, DRM_IOCTL_SYNCOBJ_WAIT, args);
+ drm_syncobj_wait args{
+ .handles = reinterpret_cast<u64>(handles.data()),
+ .timeout_nsec = timeout,
+ .count_handles = static_cast<u32>(handles.size()),
+ .flags = (waitAll ? 0U : DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL) |
+ (waitMode == WaitMode::WaitEmpty ? DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT : 0U) |
+ (waitMode == WaitMode::WaitAvailable ? DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE : 0U) |
+ (deadlineHint.has_value() ? DRM_SYNCOBJ_WAIT_FLAGS_WAIT_DEADLINE : 0U),
+ .deadline_nsec = deadlineHint.value_or(0)
+ };
+ ioctl::perform(objs.front().get().fd(), DRM_IOCTL_SYNCOBJ_WAIT, args);
- return args.first_signaled;
+ return objs.at(args.first_signaled).get();
+}
+
+void syncobj::signal(
+ const std::vector<std::reference_wrapper<TimelineSyncObject>>& objs,
+ const std::vector<u64>& points
+) {
+ if (objs.empty()) {
+ return;
}
- if (points.size() != objects.size()) {
- throw std::invalid_argument("points size must match objects size");
+ std::vector<u32> handles(objs.size());
+ for (size_t i = 0; i < objs.size(); ++i) {
+ handles.at(i) = objs.at(i).get().handle();
+ }
+
+ drm_syncobj_timeline_array args{
+ .handles = reinterpret_cast<u64>(handles.data()),
+ .points = reinterpret_cast<u64>(points.data()),
+ .count_handles = static_cast<u32>(handles.size())
+ };
+ ioctl::perform(objs.front().get().fd(), DRM_IOCTL_SYNCOBJ_TIMELINE_SIGNAL, args);
+}
+
+void syncobj::wait(
+ const std::vector<std::reference_wrapper<TimelineSyncObject>>& objs,
+ const std::vector<u64>& points,
+ s64 timeout,
+ bool waitAll,
+ bool waitAvailable,
+ std::optional<u64> deadlineHint
+) {
+ if (objs.empty()) {
+ return;
+ }
+
+ std::vector<u32> handles(objs.size());
+ for (size_t i = 0; i < objs.size(); ++i) {
+ handles.at(i) = objs.at(i).get().handle();
}
drm_syncobj_timeline_wait args{
- .handles = reinterpret_cast<uint64_t>(objects.data()),
- .points = reinterpret_cast<uint64_t>(points.data()),
+ .handles = reinterpret_cast<u64>(handles.data()),
+ .points = reinterpret_cast<u64>(points.data()),
.timeout_nsec = timeout,
- .count_handles = static_cast<uint32_t>(objects.size()),
- .flags =
- (waitAll ? DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL : 0U) |
- (waitEmpty ? DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT : 0U) |
+ .count_handles = static_cast<u32>(handles.size()),
+ .flags = (waitAll ? 0U : DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL) |
(waitAvailable ? DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE : 0U) |
(deadlineHint.has_value() ? DRM_SYNCOBJ_WAIT_FLAGS_WAIT_DEADLINE : 0U),
.deadline_nsec = deadlineHint.value_or(0)
};
- ioctl::perform(fd, DRM_IOCTL_SYNCOBJ_TIMELINE_WAIT, args);
-
- return args.first_signaled;
+ ioctl::perform(objs.front().get().fd(), DRM_IOCTL_SYNCOBJ_TIMELINE_WAIT, args);
}
-std::vector<uint64_t> SyncObject::query(
- int fd,
- const std::vector<uint32_t>& objects,
+std::vector<u64> syncobj::query(
+ const std::vector<std::reference_wrapper<TimelineSyncObject>>& objs,
bool lastSubmitted
) {
- if (objects.empty()) {
+ if (objs.empty()) {
return {};
}
- std::vector<uint64_t> points(objects.size());
+ std::vector<u32> handles(objs.size());
+ for (size_t i = 0; i < objs.size(); ++i) {
+ handles.at(i) = objs.at(i).get().handle();
+ }
+
+ std::vector<u64> points(objs.size());
drm_syncobj_timeline_array args{
- .handles = reinterpret_cast<uint64_t>(objects.data()),
- .points = reinterpret_cast<uint64_t>(points.data()),
- .count_handles = static_cast<uint32_t>(objects.size()),
+ .handles = reinterpret_cast<u64>(handles.data()),
+ .points = reinterpret_cast<u64>(points.data()),
+ .count_handles = static_cast<u32>(handles.size()),
.flags = lastSubmitted ? DRM_SYNCOBJ_QUERY_FLAGS_LAST_SUBMITTED : 0U
};
- ioctl::perform(fd, DRM_IOCTL_SYNCOBJ_QUERY, args);
+ ioctl::perform(objs.front().get().fd(), DRM_IOCTL_SYNCOBJ_QUERY, args);
return points;
}
-
-void SyncObject::destruct() noexcept {
- if (this->m_fd < 0) {
- return;
- }
-
- drm_syncobj_destroy args{
- .handle = this->m_handle
- };
- try {
- ioctl::perform(this->m_fd, DRM_IOCTL_SYNCOBJ_DESTROY, args);
- } catch(...) {
- (void) 0; // not much we can do about the leak
- }
-
- this->m_fd = -1;
-}
diff --git a/src/syncobject.hpp b/src/syncobject.hpp
deleted file mode 100644
index 6221753..0000000
--- a/src/syncobject.hpp
+++ /dev/null
@@ -1,225 +0,0 @@
-/* SPDX-License-Identifier: MIT */
-
-#pragma once
-
-#include <cstdint>
-#include <optional>
-#include <vector>
-
-namespace drm {
-
- ///
- /// A DRM synchronization object is a container which can hold one DRM fence.
- ///
- /// Their primary use-case is to implement Vulkan fences & semaphores, however they can
- /// be used across ordinary processes as well.
- ///
- /// A sync object is reference counted, therefore destroying a sync object does not
- /// invalidate all exported opaque file descriptors.
- ///
- /// Ordinary use cases for sync objects include:
- /// - Creating two sync objects in separate processes, exporting a sync object fd into
- /// the other process. Then signaling/polling the shared sync object.
- /// - Exporting a Vulkan fence/semaphore as a sync file and importing it into a sync object.
- /// It is then possible to wait for a signal from Vulkan inside of the DRM subsystem.
- ///
- /// Timeline synchronization objects extend the single DRM fence to a list of fences, where
- /// fences are identified via 64-bit unsigned integer.
- ///
- /// https://www.kernel.org/doc/html/v6.19/gpu/drm-mm.html#drm-sync-objects
- ///
- class SyncObject {
- public:
- ///
- /// Create a new DRM sync object
- ///
- /// By default, the sync object will not have a DRM fence emplaced.
- ///
- /// @param fd DRM node file descriptor
- /// @param signal Emplace a signaled fence on creation
- /// @throws drm::ioctl::Exception on failure
- ///
- SyncObject(int fd, bool signal = false);
-
- ///
- /// Import a DRM sync object from a file descriptor
- ///
- /// @param fd DRM node file descriptor
- /// @param syncobj_fd Sync object file descriptor
- /// @param close Close the file descriptor after import (regardless of success)
- /// @throws drm::ioctl::Exception on failure
- ///
- SyncObject(int fd, int syncobj_fd, bool close = true);
-
- ///
- /// Export a reference to the sync object
- ///
- /// @throws drm::ioctl::Exception on failure
- /// @returns Exported file descriptor.
- ///
- [[nodiscard]] int exportFd() const;
-
- ///
- /// Import a sync file (DRM fence) into the sync object
- ///
- /// @param syncfile_fd File descriptor to import
- /// @param point Timeline point to export for timeline sync objects
- /// @param close Close the file descriptor after import (regardless of success)
- /// @throws drm::ioctl::Exception on failure
- ///
- void importSyncFile(int syncfile_fd, uint64_t point = 0, bool close = true) const;
-
- ///
- /// Export a sync file from the DRM fence within the sync object
- ///
- /// Any subsequent modifications to the sync object are not applied to
- /// the exported sync file.
- ///
- /// @param point Timeline point to export for timeline sync objects
- /// @throws drm::ioctl::Exception on failure
- /// @returns Exported file descriptor
- ///
- [[nodiscard]] int exportSyncFile(uint64_t point = 0) const;
-
- ///
- /// Register an eventfd to be signaled by a sync object
- ///
- /// @param eventfd_fd File descriptor to signal
- /// @param point Timeline point to signal for timeline sync objects
- /// @param waitAvailable Only wait for a fence to be available, as opposed to signaled.
- /// @throws drm::ioctl::Exception on failure
- ///
- void registerEventFd(int eventfd_fd, uint64_t point = 0, bool waitAvailable = false) const;
-
- ///
- /// Copy a DRM fence into another sync object
- ///
- /// @param dstObject Destination sync object handle
- /// @param srcPoint Timeline point to copy from
- /// @param dstPoint Timeline point to copy into
- /// @throws drm::ioctl::Exception on failure
- ///
- void transfer(uint32_t dstObject, uint64_t srcPoint = 0, uint64_t dstPoint = 0) const;
-
- ///
- /// Emplace signaled fences into a list of sync objects
- ///
- /// When not using timeline sync objects, pass an empty list of timeline points.
- ///
- /// @param fd DRM node file descriptor
- /// @param objects List of sync object handles
- /// @param points List of timeline points to signal for each sync object
- /// @throws drm::ioctl::Exception on failure
- /// @throws std::invalid_argument invalid points size
- ///
- static void signal(
- int fd,
- const std::vector<uint32_t>& objects,
- const std::vector<uint64_t>& points = {}
- );
-
- ///
- /// Remove the DRM fence from a list of sync objects
- ///
- /// @param fd DRM node file descriptor
- /// @param objects List of sync object handles
- /// @throws drm::ioctl::Exception on failure
- ///
- static void reset(int fd, const std::vector<uint32_t>& objects);
-
- ///
- /// Wait for a list of sync objects to be signaled
- ///
- /// When not using timeline sync objects, pass an empty list of timeline points.
- ///
- /// If waitEmpty or waitAvailable is not set, any empty sync object will result in
- /// an error.
- ///
- /// If waitAvailable is set, the function will return as soon as a fence is emplaced into
- /// all sync objects, as opposed to waiting for the fence to be signaled. This option
- /// should not be used together with waitEmpty.
- ///
- /// @param fd DRM node file descriptor
- /// @param objects List of sync object handles
- /// @param points List of timeline points to wait on for each sync object
- /// @param timeout Absolute timeout in nanoseconds, or zero for polling
- /// @param waitAll Wait for all sync objects, as opposed to a single one
- /// @param waitEmpty Wait for sync objects, which do not yet have a fence emplaced
- /// @param waitAvailable Only wait for a fence to be available, as opposed to signaled.
- /// @param deadlineHint Set a CLOCK_MONOTONIC deadline hint in nanoseconds on all fences
- /// @throws drm::ioctl::Exception on failure
- /// @throws std::invalid_argument invalid points size
- /// @return Handle which was signaled first, when waitAll is false.
- ///
- [[nodiscard]]
- static uint32_t wait(
- int fd,
- const std::vector<uint32_t>& objects,
- const std::vector<uint64_t>& points = {},
- int64_t timeout = 0,
- bool waitAll = false,
- bool waitEmpty = false,
- bool waitAvailable = false,
- std::optional<uint64_t> deadlineHint = std::nullopt
- );
-
- ///
- /// Query the timeline points of a list of sync objects
- ///
- /// This should only be used with timeline sync objects.
- ///
- /// @param fd DRM node file descriptor
- /// @param objects List of sync object handles
- /// @param lastSubmitted Query the last submitted instead of signaled point.
- /// @throws drm::ioctl::Exception on failure
- /// @returns List of timeline points
- ///
- [[nodiscard]]
- static std::vector<uint64_t> query(
- int fd,
- const std::vector<uint32_t>& objects,
- bool lastSubmitted = false
- );
-
- // Into handle
- operator uint32_t() const { return this->m_handle; }
-
- // Move constructor/operator
- SyncObject(SyncObject&& other) noexcept : m_fd(other.m_fd), m_handle(other.m_handle) {
- other.m_fd = -1; // invalidate other
- }
-
- SyncObject& operator=(SyncObject&& other) noexcept {
- if (this != &other) {
- this->destruct();
- m_handle = other.m_handle;
- m_fd = other.m_fd;
- other.m_fd = -1; // invalidate other
- }
-
- return *this;
- }
-
- // Copy constructor/operator
- SyncObject(const SyncObject& other)
- : SyncObject(other.m_fd, other.exportFd(), true) {}
-
- SyncObject& operator=(const SyncObject& other) {
- if (this != &other) {
- const int fd = other.exportFd();
- *this = SyncObject(other.m_fd, fd, true);
- }
-
- return *this;
- }
-
- // Destructor
- ~SyncObject();
- private:
- int m_fd; // indicates object validity (>= 0)
- uint32_t m_handle;
-
- void destruct() noexcept;
- };
-
-}
generated by cgit v1.3.1 (git 2.54.0) at 2026-08-13 04:35:47 +0000