diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index 686e903f2..a2070135d 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -39,6 +39,7 @@ diff --git a/tools/vr/src/producer_lease.h b/tools/vr/src/producer_lease.h index f5b8a7ef4..d5a75694b 100644 --- a/tools/vr/src/producer_lease.h +++ b/tools/vr/src/producer_lease.h @@ -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) { diff --git a/tools/vr/src/vk_layer_droiddeck_vr.c b/tools/vr/src/vk_layer_droiddeck_vr.c index 7b9edbc94..ed0213cb8 100644 --- a/tools/vr/src/vk_layer_droiddeck_vr.c +++ b/tools/vr/src/vk_layer_droiddeck_vr.c @@ -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) diff --git a/tools/vr/src/xr_frame_channel.h b/tools/vr/src/xr_frame_channel.h index 61027ba82..ceffe5a9b 100644 --- a/tools/vr/src/xr_frame_channel.h +++ b/tools/vr/src/xr_frame_channel.h @@ -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; diff --git a/tools/vr/tests/test_producer_lease.c b/tools/vr/tests/test_producer_lease.c index 481585ab2..c7a006d90 100644 --- a/tools/vr/tests/test_producer_lease.c +++ b/tools/vr/tests/test_producer_lease.c @@ -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); diff --git a/tools/vr/tests/test_semaphore_layer.c b/tools/vr/tests/test_semaphore_layer.c index ffb869e78..81a4b5a74 100644 --- a/tools/vr/tests/test_semaphore_layer.c +++ b/tools/vr/tests/test_semaphore_layer.c @@ -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}; diff --git a/tools/vr/tests/test_xr_frames.cpp b/tools/vr/tests/test_xr_frames.cpp index 932f683f7..76b8cc53c 100644 --- a/tools/vr/tests/test_xr_frames.cpp +++ b/tools/vr/tests/test_xr_frames.cpp @@ -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));