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 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01S1U9H1evGNjHRQ3wRUdv5V
This commit is contained in:
Ahmad Sayed Alsayed EbrahimandClaude Opus 5.5 committed 2026-10-10 16:03:14 +03:00
1 parent 0e7f8e7170
commit 05c62481f8
4 files changed
+105 -12

No files matched your search

+12 -1
View File
@@ -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);
+32 -2
View File
@@ -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);
+60 -9
View File
@@ -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};
+1
View File
@@ -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);