From 05c62481f8f904787c43b3336fc56dfc059d7cd8 Mon Sep 17 00:00:00 2001 From: Ahmad Sayed Alsayed Ebrahim Date: Sat, 10 Oct 2026 16:03:14 +0300 Subject: [PATCH] fix(vkbridge): server killed at session start; AHB lookup on Android; memory self-test diagnostics First device run (SM-X826B, Mali-G720, driver 44.1): - The server got SIGTERM 6 ms after the guest started: PR_SET_PDEATHSIG fires when the parent THREAD exits, and ProcessBuilder forks from the session's start-up thread. A watchdog thread now exits when the parent process goes. - AHB sharing looked up vkGetAndroidHardwareBufferPropertiesANDROID through vkGetInstanceProcAddr(NULL, "vkGetDeviceProcAddr"), which Android's loader answers with NULL; now through the instance's vkGetDeviceProcAddr. - dma-buf export failed without saying where. The self-test now logs the driver's external buffer properties per handle type, each failing step's VkResult, and the full device extension list (the server saw no VK_EXT_robustness2 or mutable_descriptor_type, which the capability viewer listed). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01S1U9H1evGNjHRQ3wRUdv5V --- app/src/main/cpp/vkbridge/server_instance.c | 13 +++- app/src/main/cpp/vkbridge/server_main.c | 34 +++++++++- app/src/main/cpp/vkbridge/server_memory.c | 69 ++++++++++++++++++--- app/src/main/cpp/vkbridge/vkb_server.h | 1 + 4 files changed, 105 insertions(+), 12 deletions(-) diff --git a/app/src/main/cpp/vkbridge/server_instance.c b/app/src/main/cpp/vkbridge/server_instance.c index 7233c6c97..bead3238b 100644 --- a/app/src/main/cpp/vkbridge/server_instance.c +++ b/app/src/main/cpp/vkbridge/server_instance.c @@ -78,7 +78,18 @@ static void log_device(const vkb_dispatch *dt, VkPhysicalDevice pd, const VkPhys } } VKB_INFO("%u device extensions in total", n); - for (uint32_t i = 0; i < n; i++) VKB_DBG(" %s (rev %u)", e[i].extensionName, e[i].specVersion); + /* All of them, until the device runs show which ones the server's process sees (it is not an + * app process, and saw fewer than the capability viewer on the same tablet). */ + len = 0; + line[0] = 0; + for (uint32_t i = 0; i < n; i++) { + len += (size_t)snprintf(line + len, sizeof(line) - len, "%s%s:%u", len ? " " : "", e[i].extensionName + 3, e[i].specVersion); + if (len > 700 || i + 1 == n) { + VKB_INFO(" all: %s", line); + len = 0; + line[0] = 0; + } + } free(e); VkPhysicalDeviceMemoryProperties mp; dt->vkGetPhysicalDeviceMemoryProperties(pd, &mp); diff --git a/app/src/main/cpp/vkbridge/server_main.c b/app/src/main/cpp/vkbridge/server_main.c index 74ad8a9d1..dc948cf88 100644 --- a/app/src/main/cpp/vkbridge/server_main.c +++ b/app/src/main/cpp/vkbridge/server_main.c @@ -151,6 +151,33 @@ static void usage(void) fprintf(stderr, "usage: vkbridge-server --socket PATH [--log FILE] [--vulkan LIB] [--cache-dir DIR] [--selftest] [--verbose]\n"); } +static pid_t parent_pid; + +static void *parent_watch(void *arg) +{ + (void)arg; + for (;;) { + sleep(1); + if (getppid() != parent_pid) { + VKB_INFO("the app (pid %d) is gone; exiting", (int)parent_pid); + _exit(0); + } + } + return NULL; +} + +static void start_parent_watch(void) +{ + parent_pid = getppid(); + if (parent_pid <= 1) return; /* started by init or a shell that already left: nothing to watch */ + pthread_t t; + pthread_attr_t a; + pthread_attr_init(&a); + pthread_attr_setdetachstate(&a, PTHREAD_CREATE_DETACHED); + pthread_create(&t, &a, parent_watch, NULL); + pthread_attr_destroy(&a); +} + int main(int argc, char **argv) { const char *sock_path = getenv("VKBRIDGE_SOCKET"); @@ -182,8 +209,11 @@ int main(int argc, char **argv) signal(SIGABRT, on_crash); signal(SIGILL, on_crash); signal(SIGFPE, on_crash); - /* The server is the app's child: when the app dies, so does the session's GPU. */ - prctl(PR_SET_PDEATHSIG, SIGTERM); + /* The server is the app's child: when the app dies, so does the session's GPU. Not with + * PR_SET_PDEATHSIG: that fires when the parent THREAD exits, and Android's ProcessBuilder forks + * from the session's start-up thread, which ends right after starting the guest (the server + * was killed 6 ms into the first device run). The parent process is watched instead. */ + start_parent_watch(); VKB_INFO("starting (pid %d, protocol %016llx)", getpid(), (unsigned long long)VKB_PROTOCOL_HASH); void *lib = load_vulkan(vk_lib); diff --git a/app/src/main/cpp/vkbridge/server_memory.c b/app/src/main/cpp/vkbridge/server_memory.c index f80313162..88c1259da 100644 --- a/app/src/main/cpp/vkbridge/server_memory.c +++ b/app/src/main/cpp/vkbridge/server_memory.c @@ -170,6 +170,9 @@ void vkb_mem_free_all(vkb_srv_table *dev) } } +/* The driver's vkGetDeviceProcAddr (for entry points the dispatch table does not carry). */ +PFN_vkGetDeviceProcAddr vkb_mem_gdpa; + /* ------------------------------------------------------------------ allocation */ /* @@ -230,10 +233,16 @@ static VkResult alloc_shared(const vkb_dispatch *dt, VkDevice dev, uint32_t s, c } if (exp.sType != VK_STRUCTURE_TYPE_MAX_ENUM) info.pNext = &exp; r = dt->vkAllocateMemory(dev, &info, NULL, &m->mem); - if (r != VK_SUCCESS) break; + if (r != VK_SUCCESS) { + VKB_INFO("dmabuf: exportable allocation of %llu bytes (type %u) failed: %d", (unsigned long long)info.allocationSize, + info.memoryTypeIndex, r); + break; + } VkMemoryGetFdInfoKHR gi = {VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR, NULL, m->mem, VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT}; int fd = -1; - if (!dt->vkGetMemoryFdKHR || dt->vkGetMemoryFdKHR(dev, &gi, &fd) != VK_SUCCESS || fd < 0) { + VkResult fr = dt->vkGetMemoryFdKHR ? dt->vkGetMemoryFdKHR(dev, &gi, &fd) : VK_ERROR_EXTENSION_NOT_PRESENT; + if (fr != VK_SUCCESS || fd < 0) { + VKB_INFO("dmabuf: vkGetMemoryFdKHR %s: %d (fd %d)", dt->vkGetMemoryFdKHR ? "failed" : "not loaded", fr, fd); dt->vkFreeMemory(dev, m->mem, NULL); m->mem = VK_NULL_HANDLE; r = VK_ERROR_INVALID_EXTERNAL_HANDLE; @@ -245,12 +254,15 @@ static VkResult alloc_shared(const vkb_dispatch *dt, VkDevice dev, uint32_t s, c #ifdef __ANDROID__ case VKB_MEM_AHB: { if (!ahb_load()) break; - static PFN_vkGetAndroidHardwareBufferPropertiesANDROID get_props; + /* Through the device's own vkGetDeviceProcAddr: Android's loader answers NULL for it from + * vkGetInstanceProcAddr(NULL, ...), which desktop loaders allow (the first device run). */ + PFN_vkGetAndroidHardwareBufferPropertiesANDROID get_props = NULL; + if (vkb_mem_gdpa) + get_props = (PFN_vkGetAndroidHardwareBufferPropertiesANDROID)vkb_mem_gdpa(dev, "vkGetAndroidHardwareBufferPropertiesANDROID"); if (!get_props) { - PFN_vkGetDeviceProcAddr gdpa = (PFN_vkGetDeviceProcAddr)vkb_gipa(VK_NULL_HANDLE, "vkGetDeviceProcAddr"); - if (gdpa) get_props = (PFN_vkGetAndroidHardwareBufferPropertiesANDROID)gdpa(dev, "vkGetAndroidHardwareBufferPropertiesANDROID"); + VKB_INFO("ahb: vkGetAndroidHardwareBufferPropertiesANDROID not found"); + break; } - if (!get_props) break; uint64_t sz = ai->allocationSize; if (sz > 0xFFFFFFFFull) { r = VK_ERROR_OUT_OF_DEVICE_MEMORY; @@ -259,13 +271,17 @@ static VkResult alloc_shared(const vkb_dispatch *dt, VkDevice dev, uint32_t s, c vkb_ahb_desc d = {(uint32_t)sz, 1, 1, AHB_FORMAT_BLOB, AHB_USAGE_CPU_READ_OFTEN | AHB_USAGE_CPU_WRITE_OFTEN | AHB_USAGE_GPU_DATA_BUFFER, 0, 0, 0}; struct AHardwareBuffer *ahb = NULL; - if (p_AHardwareBuffer_allocate(&d, &ahb) != 0 || !ahb) { + int ar = p_AHardwareBuffer_allocate(&d, &ahb); + if (ar != 0 || !ahb) { + VKB_INFO("ahb: AHardwareBuffer_allocate(%u bytes) failed: %d", (unsigned)sz, ar); r = VK_ERROR_OUT_OF_DEVICE_MEMORY; break; } m->ahb = ahb; VkAndroidHardwareBufferPropertiesANDROID props = {VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID}; - if (get_props(dev, ahb, &props) != VK_SUCCESS || !(props.memoryTypeBits & (1u << ai->memoryTypeIndex))) { + VkResult pr = get_props(dev, ahb, &props); + if (pr != VK_SUCCESS || !(props.memoryTypeBits & (1u << ai->memoryTypeIndex))) { + VKB_INFO("ahb: properties %d, memory types 0x%x (want type %u)", pr, props.memoryTypeBits, ai->memoryTypeIndex); r = VK_ERROR_INVALID_EXTERNAL_HANDLE; break; } @@ -273,9 +289,13 @@ static VkResult alloc_shared(const vkb_dispatch *dt, VkDevice dev, uint32_t s, c info.pNext = &imp; info.allocationSize = props.allocationSize; r = dt->vkAllocateMemory(dev, &info, NULL, &m->mem); - if (r != VK_SUCCESS) break; + if (r != VK_SUCCESS) { + VKB_INFO("ahb: import of %llu bytes failed: %d", (unsigned long long)info.allocationSize, r); + break; + } const vkb_native_handle *nh = p_AHardwareBuffer_getNativeHandle(ahb); if (!nh || nh->numFds < 1) { + VKB_INFO("ahb: no fd in the native handle (%d)", nh ? nh->numFds : -1); dt->vkFreeMemory(dev, m->mem, NULL); m->mem = VK_NULL_HANDLE; r = VK_ERROR_INVALID_EXTERNAL_HANDLE; @@ -559,6 +579,35 @@ static int has_ext(const VkExtensionProperties *e, uint32_t n, const char *name) return 0; } +/* What the driver says it can do with each kind of external buffer memory (the device runs). */ +static void log_external_props(const vkb_dispatch *idt, VkPhysicalDevice pd) +{ + if (!idt->vkGetPhysicalDeviceExternalBufferProperties) return; + static const struct { uint32_t bit; const char *name; } types[] = { + {VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, "opaque fd"}, + {VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT, "dma-buf"}, + {VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, "host allocation"}, +#ifdef __ANDROID__ + {VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, "AHB"}, +#endif + }; + for (size_t i = 0; i < sizeof(types) / sizeof(types[0]); i++) { + VkPhysicalDeviceExternalBufferInfo bi = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, NULL, 0, + VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT | + VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, + (VkExternalMemoryHandleTypeFlagBits)types[i].bit}; + VkExternalBufferProperties ep = {VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES}; + idt->vkGetPhysicalDeviceExternalBufferProperties(pd, &bi, &ep); + const VkExternalMemoryProperties *p = &ep.externalMemoryProperties; + VKB_INFO("external buffers, %s: features 0x%x (%s%s%s), export from 0x%x, compatible 0x%x", types[i].name, + p->externalMemoryFeatures, + p->externalMemoryFeatures & VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT ? "dedicated-only " : "", + p->externalMemoryFeatures & VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT ? "exportable " : "", + p->externalMemoryFeatures & VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT ? "importable" : "", + p->exportFromImportedHandleTypes, p->compatibleHandleTypes); + } +} + void vkb_mem_selftest(vkb_pd_knowledge *k, VkInstance inst, const vkb_dispatch *idt, VkPhysicalDevice pd) { selftest st; @@ -627,6 +676,8 @@ void vkb_mem_selftest(vkb_pd_knowledge *k, VkInstance inst, const vkb_dispatch * } st.dt = *idt; PFN_vkGetDeviceProcAddr gdpa = (PFN_vkGetDeviceProcAddr)vkb_gipa(inst, "vkGetDeviceProcAddr"); + vkb_mem_gdpa = gdpa; + log_external_props(idt, pd); vkb_dispatch_load_device(&st.dt, gdpa, st.dev); st.dt.vkGetDeviceQueue(st.dev, st.qf, 0, &st.queue); VkCommandPoolCreateInfo pci = {VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, NULL, 0, st.qf}; diff --git a/app/src/main/cpp/vkbridge/vkb_server.h b/app/src/main/cpp/vkbridge/vkb_server.h index 0321c6e47..33c1d2573 100644 --- a/app/src/main/cpp/vkbridge/vkb_server.h +++ b/app/src/main/cpp/vkbridge/vkb_server.h @@ -121,6 +121,7 @@ extern vkb_pd_knowledge vkb_pds[VKB_MAX_PDS]; extern int vkb_npds; /* server_memory.c */ +extern PFN_vkGetDeviceProcAddr vkb_mem_gdpa; void vkb_mem_selftest(vkb_pd_knowledge *k, VkInstance inst, const vkb_dispatch *idt, VkPhysicalDevice pd); const char *const *vkb_mem_required_extensions(uint32_t strategy, uint32_t *count); void vkb_mem_track(vkb_srv_table *dev, vkb_srv_mem *m);