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));