mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-22 14:26:00 +00:00
fix: harden Quest SteamVR frame transport
This commit is contained in:
1 parent
fd6111fc69
commit
d344b7dcba
7 files changed
+109
-3
No files matched your search
@@ -145,7 +145,12 @@ static void *droiddeck_producer_serve(void *argument) {
|
||||
}
|
||||
uint64_t granted = ++ticket;
|
||||
message = (struct droiddeck_producer_message){DROIDDECK_PRODUCER_MAGIC, DROIDDECK_PRODUCER_READY, granted};
|
||||
int valid = droiddeck_producer_io(connection, &message, 1, deadline);
|
||||
if (!droiddeck_producer_io(connection, &message, 1, droiddeck_producer_now() + 100000000LL)) {
|
||||
server->release();
|
||||
close(connection);
|
||||
continue;
|
||||
}
|
||||
int valid = 1;
|
||||
while (valid) {
|
||||
struct pollfd request = {connection, POLLIN, 0};
|
||||
int ready = poll(&request, 1, -1);
|
||||
@@ -174,6 +179,16 @@ static int droiddeck_producer_start(struct droiddeck_producer_server *server) {
|
||||
address.sun_family = AF_UNIX;
|
||||
if (!droiddeck_producer_path(address.sun_path, sizeof(address.sun_path), getpid()) ||
|
||||
!droiddeck_producer_private_parent(address.sun_path)) return 0;
|
||||
struct stat existing;
|
||||
if (lstat(address.sun_path, &existing) == 0) {
|
||||
if (!S_ISSOCK(existing.st_mode) || existing.st_uid != getuid()) return 0;
|
||||
int probe = socket(AF_UNIX, SOCK_SEQPACKET | SOCK_CLOEXEC | SOCK_NONBLOCK, 0);
|
||||
if (probe < 0) return 0;
|
||||
int connected = connect(probe, (struct sockaddr *)&address, sizeof(address));
|
||||
int error = errno;
|
||||
close(probe);
|
||||
if (connected == 0 || error != ECONNREFUSED || unlink(address.sun_path) != 0) return 0;
|
||||
} else if (errno != ENOENT) return 0;
|
||||
server->listener = socket(AF_UNIX, SOCK_SEQPACKET | SOCK_CLOEXEC, 0);
|
||||
if (server->listener < 0) return 0;
|
||||
if (bind(server->listener, (struct sockaddr *)&address, sizeof(address)) != 0) {
|
||||
|
||||
@@ -497,6 +497,7 @@ struct producer_queue {
|
||||
static struct producer_queue g_producer_queues[MAX_OBJS];
|
||||
static int g_producer_overflow;
|
||||
static int g_producer_started;
|
||||
static int64_t g_producer_retry_at;
|
||||
static struct droiddeck_producer_server g_producer_server;
|
||||
|
||||
__attribute__((destructor)) static void producer_process_exit(void) {
|
||||
@@ -558,7 +559,8 @@ static void producer_quarantine(void) {
|
||||
}
|
||||
|
||||
static void producer_record(struct dev *device, VkQueue queue) {
|
||||
if (!g_producer_started) {
|
||||
if (!g_producer_started && droiddeck_producer_now() >= g_producer_retry_at) {
|
||||
g_producer_retry_at = droiddeck_producer_now() + 1000000000LL;
|
||||
g_producer_server.acquire = producer_acquire;
|
||||
g_producer_server.release = producer_release;
|
||||
g_producer_server.quarantine = producer_quarantine;
|
||||
@@ -885,6 +887,24 @@ static VkResult VKAPI_CALL QueueBindSparse(VkQueue queue, uint32_t count, const
|
||||
return result;
|
||||
}
|
||||
|
||||
static VkResult VKAPI_CALL QueueWaitIdle(VkQueue queue) {
|
||||
struct dev *device = dev_for(queue);
|
||||
PFN_vkQueueWaitIdle next = (PFN_vkQueueWaitIdle)device->gdpa(device->handle, "vkQueueWaitIdle");
|
||||
if (device->producer) pthread_mutex_lock(&g_submission_lock);
|
||||
VkResult result = next(queue);
|
||||
if (device->producer) pthread_mutex_unlock(&g_submission_lock);
|
||||
return result;
|
||||
}
|
||||
|
||||
static VkResult VKAPI_CALL DeviceWaitIdle(VkDevice handle) {
|
||||
struct dev *device = dev_for(handle);
|
||||
PFN_vkDeviceWaitIdle next = (PFN_vkDeviceWaitIdle)device->gdpa(handle, "vkDeviceWaitIdle");
|
||||
if (device->producer) pthread_mutex_lock(&g_submission_lock);
|
||||
VkResult result = next(handle);
|
||||
if (device->producer) pthread_mutex_unlock(&g_submission_lock);
|
||||
return result;
|
||||
}
|
||||
|
||||
static VkResult VKAPI_CALL WaitSemaphores(VkDevice d, const VkSemaphoreWaitInfo *info, uint64_t timeout) {
|
||||
PFN_vkWaitSemaphores next = (PFN_vkWaitSemaphores)dev_for(d)->gdpa(d, "vkWaitSemaphores");
|
||||
if (!next) next = (PFN_vkWaitSemaphores)dev_for(d)->gdpa(d, "vkWaitSemaphoresKHR");
|
||||
@@ -928,6 +948,8 @@ static PFN_vkVoidFunction semaphore_hook(const char *name) {
|
||||
HOOK_AS("vkQueueSubmit2KHR", QueueSubmit2)
|
||||
HOOK_AS("vkQueuePresentKHR", QueuePresentKHR)
|
||||
HOOK_AS("vkQueueBindSparse", QueueBindSparse)
|
||||
HOOK_AS("vkQueueWaitIdle", QueueWaitIdle)
|
||||
HOOK_AS("vkDeviceWaitIdle", DeviceWaitIdle)
|
||||
HOOK_AS("vkWaitSemaphores", WaitSemaphores)
|
||||
HOOK_AS("vkWaitSemaphoresKHR", WaitSemaphores)
|
||||
HOOK_AS("vkGetSemaphoreCounterValue", GetSemaphoreCounterValue)
|
||||
|
||||
@@ -124,6 +124,7 @@ private:
|
||||
|| now - frame.header.captured_ns > 500000000LL || frame.header.frame_id <= lastFrame) { rejected_++; break; }
|
||||
try { frame.pixels.resize(frame.header.bytes); }
|
||||
catch (...) { rejected_++; break; }
|
||||
deadline = xr_frame_now() + 200000000LL;
|
||||
if (!xr_frame_io(client, frame.pixels.data(), frame.pixels.size(), false, deadline)) { rejected_++; break; }
|
||||
if (xr_frame_now() - frame.header.captured_ns > 500000000LL) { rejected_++; break; }
|
||||
uint64_t acknowledgement = frame.header.frame_id;
|
||||
|
||||
@@ -9,12 +9,14 @@ static atomic_int completed;
|
||||
static atomic_int released;
|
||||
static atomic_int quarantined;
|
||||
static atomic_int available;
|
||||
static atomic_int slow;
|
||||
|
||||
static int acquire(int64_t deadline) {
|
||||
assert(deadline > droiddeck_producer_now());
|
||||
if (!atomic_load(&available)) return 0;
|
||||
assert(pthread_mutex_lock(&queue_lock) == 0);
|
||||
atomic_fetch_add(&completed, 1);
|
||||
if (atomic_load(&slow)) usleep(170000);
|
||||
return 1;
|
||||
}
|
||||
|
||||
@@ -43,6 +45,17 @@ int main(void) {
|
||||
struct droiddeck_producer_server server = {.acquire = acquire, .release = release, .quarantine = quarantine};
|
||||
assert(!droiddeck_producer_start(&server));
|
||||
assert(chmod(parent, 0700) == 0);
|
||||
char path[128];
|
||||
assert(droiddeck_producer_path(path, sizeof(path), getpid()));
|
||||
int regular = open(path, O_CREAT | O_RDWR, 0600);
|
||||
assert(regular >= 0); close(regular);
|
||||
assert(!droiddeck_producer_start(&server));
|
||||
assert(unlink(path) == 0);
|
||||
int stale = socket(AF_UNIX, SOCK_SEQPACKET, 0);
|
||||
struct sockaddr_un address = {.sun_family = AF_UNIX};
|
||||
strcpy(address.sun_path, path);
|
||||
assert(bind(stale, (struct sockaddr *)&address, sizeof(address)) == 0);
|
||||
close(stale);
|
||||
assert(droiddeck_producer_start(&server));
|
||||
struct stat metadata;
|
||||
assert(stat(server.path, &metadata) == 0 && (metadata.st_mode & 0777) == 0600);
|
||||
@@ -65,6 +78,21 @@ int main(void) {
|
||||
assert(droiddeck_producer_acquire(getpid(), &lease));
|
||||
assert(lease.ticket > first_ticket);
|
||||
assert(droiddeck_producer_release(&lease));
|
||||
atomic_store(&slow, 1);
|
||||
assert(droiddeck_producer_acquire(getpid(), &lease));
|
||||
assert(droiddeck_producer_release(&lease));
|
||||
atomic_store(&slow, 0);
|
||||
int abandoned = socket(AF_UNIX, SOCK_SEQPACKET, 0);
|
||||
assert(connect(abandoned, (struct sockaddr *)&address, sizeof(address)) == 0);
|
||||
struct droiddeck_producer_message request = {DROIDDECK_PRODUCER_MAGIC, DROIDDECK_PRODUCER_ACQUIRE, 0};
|
||||
atomic_store(&slow, 1);
|
||||
int before = atomic_load(&completed);
|
||||
assert(send(abandoned, &request, sizeof(request), MSG_NOSIGNAL) == sizeof(request));
|
||||
wait_count(&completed, before + 1);
|
||||
close(abandoned);
|
||||
wait_count(&released, 4);
|
||||
assert(!atomic_load(&quarantined));
|
||||
atomic_store(&slow, 0);
|
||||
char wrong_path[128];
|
||||
assert(droiddeck_producer_path(wrong_path, sizeof(wrong_path), (uint32_t)getpid() + 1));
|
||||
assert(link(server.path, wrong_path) == 0);
|
||||
@@ -76,7 +104,7 @@ int main(void) {
|
||||
assert(droiddeck_producer_acquire(getpid(), &lease));
|
||||
close(lease.descriptor);
|
||||
wait_count(&quarantined, 1);
|
||||
assert(atomic_load(&released) == 2);
|
||||
assert(atomic_load(&released) == 4);
|
||||
assert(pthread_mutex_trylock(&queue_lock) == EBUSY);
|
||||
assert(pthread_join(server.thread, NULL) == 0);
|
||||
close(server.listener);
|
||||
|
||||
@@ -48,8 +48,26 @@ static void VKAPI_CALL mock_destroy(VkDevice device, VkSemaphore semaphore, cons
|
||||
destroyed++;
|
||||
}
|
||||
|
||||
static int expect_queue_lock;
|
||||
|
||||
static void check_queue_lock(void) {
|
||||
int acquired = pthread_mutex_trylock(&g_submission_lock);
|
||||
assert(acquired == (expect_queue_lock ? EBUSY : 0));
|
||||
if (!acquired) pthread_mutex_unlock(&g_submission_lock);
|
||||
}
|
||||
|
||||
static VkResult VKAPI_CALL mock_queue_idle(VkQueue queue) {
|
||||
assert(queue); check_queue_lock(); return VK_ERROR_DEVICE_LOST;
|
||||
}
|
||||
|
||||
static VkResult VKAPI_CALL mock_device_idle(VkDevice device) {
|
||||
assert(device); check_queue_lock(); return VK_ERROR_DEVICE_LOST;
|
||||
}
|
||||
|
||||
static PFN_vkVoidFunction VKAPI_CALL mock_proc(VkDevice device, const char *name) {
|
||||
(void)device;
|
||||
if (!strcmp(name, "vkQueueWaitIdle")) return (PFN_vkVoidFunction)mock_queue_idle;
|
||||
if (!strcmp(name, "vkDeviceWaitIdle")) return (PFN_vkVoidFunction)mock_device_idle;
|
||||
if (!strcmp(name, "vkQueueSubmit")) return (PFN_vkVoidFunction)mock_submit;
|
||||
if (!strcmp(name, "vkQueueSubmit2")) return (PFN_vkVoidFunction)mock_submit2;
|
||||
if (!strcmp(name, "vkWaitSemaphores")) return (PFN_vkVoidFunction)mock_wait;
|
||||
@@ -66,6 +84,16 @@ int main(void) {
|
||||
VkQueue queue = (VkQueue)&dispatch;
|
||||
g_dev[0] = (struct dev){device, mock_proc, NULL, 1, 0, 0};
|
||||
g_poller_started = 1;
|
||||
PFN_vkQueueWaitIdle queue_idle = (PFN_vkQueueWaitIdle)semaphore_hook("vkQueueWaitIdle");
|
||||
PFN_vkDeviceWaitIdle device_idle = (PFN_vkDeviceWaitIdle)semaphore_hook("vkDeviceWaitIdle");
|
||||
assert(queue_idle && device_idle);
|
||||
for (int producer = 0; producer <= 1; producer++) {
|
||||
g_dev[0].producer = producer;
|
||||
expect_queue_lock = producer;
|
||||
assert(queue_idle(queue) == VK_ERROR_DEVICE_LOST);
|
||||
assert(device_idle(device) == VK_ERROR_DEVICE_LOST);
|
||||
}
|
||||
g_dev[0].producer = 0;
|
||||
VkExportSemaphoreCreateInfo export_info = {VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, NULL,
|
||||
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT};
|
||||
VkSemaphoreCreateInfo create = {VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, &export_info, 0};
|
||||
|
||||
@@ -97,6 +97,17 @@ int main(int argc, char **argv) {
|
||||
assert(receiver.Start(socketPath)); assert(sender.Send(socketPath, Header(1), pixels.data()));
|
||||
assert(receiver.Take(&taken));
|
||||
receiver.Stop(); assert(receiver.Start(socketPath));
|
||||
int delayed = Connect(socketPath);
|
||||
usleep(140000);
|
||||
auto delayedHeader = Header();
|
||||
assert(xr_frame_io(delayed, &delayedHeader, sizeof(delayedHeader), true, xr_frame_now() + 200000000LL));
|
||||
usleep(110000);
|
||||
assert(xr_frame_io(delayed, pixels.data(), pixels.size(), true, xr_frame_now() + 200000000LL));
|
||||
uint64_t acknowledged = 0;
|
||||
assert(xr_frame_io(delayed, &acknowledged, sizeof(acknowledged), false, xr_frame_now() + 200000000LL));
|
||||
assert(acknowledged == delayedHeader.frame_id && receiver.Take(&taken));
|
||||
close(delayed);
|
||||
receiver.Stop(); assert(receiver.Start(socketPath));
|
||||
int descriptor = Connect(socketPath); auto header = Header(); header.version++;
|
||||
assert(xr_frame_io(descriptor, &header, sizeof(header), true, xr_frame_now() + 200000000LL));
|
||||
close(descriptor); WaitRejected(receiver, 1); assert(!receiver.Take(&taken));
|
||||
|
||||
Reference in new issue
Block a user