Files
DroidDeck/tools/vkbridge/common/vkb_wire.c
T
ahmadandClaude Opus 5.5 a8fd343fc1 feat(vkbridge): Vulkan bridge core - codegen, wire runtime, server, client ICD, WSI
Generated from vk.xml 1.3.247; server shares host-visible memory via a
self-tested strategy (hostptr/dmabuf/ahb). vulkaninfo runs through it on host.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KZqR8XUE8czvGzEpgSCVQR
2026-10-10 14:27:54 +03:00

692 lines
19 KiB
C

/* SPDX-License-Identifier: GPL-3.0-or-later */
#include "vkb_wire.h"
#include "vkb_log.h"
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/uio.h>
#include <unistd.h>
/* ------------------------------------------------------------------ arena */
struct vkb_arena_block {
vkb_arena_block *next;
size_t used, cap;
/* data follows, 16-aligned */
};
#define ARENA_HDR ((sizeof(vkb_arena_block) + 15) & ~(size_t)15)
void *vkb_arena_alloc(vkb_arena *a, size_t n)
{
n = (n + 15) & ~(size_t)15;
if (n == 0) n = 16;
vkb_arena_block *b = a->head;
if (!b || b->cap - b->used < n) {
size_t cap = n > 65536 ? n : 65536;
b = malloc(ARENA_HDR + cap);
if (!b) return NULL;
b->next = a->head;
b->used = 0;
b->cap = cap;
a->head = b;
}
void *p = (uint8_t *)b + ARENA_HDR + b->used;
b->used += n;
a->used_total += n;
memset(p, 0, n);
return p;
}
void vkb_arena_reset(vkb_arena *a)
{
/* Keep the most recent block if it is the default size; free the rest. */
vkb_arena_block *b = a->head, *keep = NULL;
while (b) {
vkb_arena_block *n = b->next;
if (!keep && b->cap == 65536) {
keep = b;
keep->next = NULL;
keep->used = 0;
} else {
free(b);
}
b = n;
}
a->head = keep;
a->used_total = 0;
}
void vkb_arena_free(vkb_arena *a)
{
vkb_arena_block *b = a->head;
while (b) {
vkb_arena_block *n = b->next;
free(b);
b = n;
}
a->head = NULL;
}
/* ------------------------------------------------------------------ encoder */
void vkb_enc_init(vkb_enc *e)
{
memset(e, 0, sizeof(*e));
}
void vkb_enc_reset(vkb_enc *e)
{
e->len = 0;
e->nfds = 0;
e->oom = 0;
}
void vkb_enc_free(vkb_enc *e)
{
free(e->buf);
memset(e, 0, sizeof(*e));
}
static int enc_grow(vkb_enc *e, size_t add)
{
if (e->oom) return 0;
size_t need = e->len + add;
if (need <= e->cap) return 1;
size_t cap = e->cap ? e->cap : 4096;
while (cap < need) cap *= 2;
uint8_t *nb = realloc(e->buf, cap);
if (!nb) {
e->oom = 1;
return 0;
}
e->buf = nb;
e->cap = cap;
return 1;
}
void vkb_enc_bytes(vkb_enc *e, const void *p, size_t n)
{
if (!n || !enc_grow(e, n)) return;
if (p) memcpy(e->buf + e->len, p, n);
else memset(e->buf + e->len, 0, n);
e->len += n;
}
void vkb_enc_u8(vkb_enc *e, uint8_t v) { vkb_enc_bytes(e, &v, 1); }
void vkb_enc_u32(vkb_enc *e, uint32_t v) { vkb_enc_bytes(e, &v, 4); }
void vkb_enc_u64(vkb_enc *e, uint64_t v) { vkb_enc_bytes(e, &v, 8); }
static void enc_align(vkb_enc *e)
{
size_t pad = (8 - (e->len & 7)) & 7;
if (pad) vkb_enc_bytes(e, NULL, pad);
}
size_t vkb_enc_raw(vkb_enc *e, const void *p, size_t n)
{
enc_align(e);
size_t off = e->len;
vkb_enc_bytes(e, p, n);
return off;
}
void vkb_enc_patch_u64(vkb_enc *e, size_t off, uint64_t v)
{
if (e->oom || off + 8 > e->len) return;
memcpy(e->buf + off, &v, 8);
}
void vkb_enc_str(vkb_enc *e, const char *s)
{
if (!s) {
vkb_enc_u8(e, 0);
return;
}
uint32_t n = (uint32_t)strlen(s);
vkb_enc_u8(e, 1);
vkb_enc_u32(e, n);
vkb_enc_bytes(e, s, n);
}
void vkb_enc_strarray(vkb_enc *e, const char *const *a, uint32_t n)
{
if (!a) {
vkb_enc_u8(e, 0);
return;
}
vkb_enc_u8(e, 1);
vkb_enc_u32(e, n);
for (uint32_t i = 0; i < n; i++) vkb_enc_str(e, a[i]);
}
void vkb_enc_blob(vkb_enc *e, const void *p, size_t n)
{
if (!p) {
vkb_enc_u8(e, 0);
return;
}
vkb_enc_u8(e, 1);
vkb_enc_u64(e, n);
vkb_enc_raw(e, p, n);
}
void vkb_enc_fd(vkb_enc *e, int fd)
{
if (fd < 0) {
vkb_enc_u32(e, VKB_FD_NONE);
return;
}
if (e->nfds >= VKB_MAX_FDS) {
VKB_ERR("too many file descriptors in one message");
e->oom = 1;
return;
}
e->fds[e->nfds] = fd;
vkb_enc_u32(e, (uint32_t)e->nfds);
e->nfds++;
}
void vkb_enc_append(vkb_enc *e, const vkb_enc *src)
{
enc_align(e);
/* fd indices inside src are relative to src; a stream that carries fds is not appendable. */
if (src->nfds) {
VKB_ERR("internal: appending a message that carries file descriptors");
e->oom = 1;
return;
}
vkb_enc_bytes(e, src->buf, src->len);
}
static const VkBaseInStructure *next_known(const void *p)
{
const VkBaseInStructure *b = p;
while (b) {
if (vkb_struct_size(b->sType)) return b;
VKB_ONCE(VKB_LOG_WARN, "pNext: structure type %d is not bridged; dropped (logged once)", (int)b->sType);
b = b->pNext;
}
return NULL;
}
void vkb_enc_chain(vkb_enc *e, const void *pNext)
{
const VkBaseInStructure *b = next_known(pNext);
if (!b) {
vkb_enc_u32(e, VKB_CHAIN_END);
return;
}
vkb_enc_u32(e, (uint32_t)b->sType);
vkb_enc_chain_elem(e, b);
}
/* Out-structs that carry a caller-provided array (two-call idiom inside a struct). */
static int out_array_info(VkStructureType t, size_t *count_off, size_t *ptr_off, size_t *elem)
{
switch ((int)t) {
case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
*count_off = offsetof(VkDrmFormatModifierPropertiesListEXT, drmFormatModifierCount);
*ptr_off = offsetof(VkDrmFormatModifierPropertiesListEXT, pDrmFormatModifierProperties);
*elem = sizeof(VkDrmFormatModifierPropertiesEXT);
return 1;
case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
*count_off = offsetof(VkDrmFormatModifierPropertiesList2EXT, drmFormatModifierCount);
*ptr_off = offsetof(VkDrmFormatModifierPropertiesList2EXT, pDrmFormatModifierProperties);
*elem = sizeof(VkDrmFormatModifierProperties2EXT);
return 1;
default:
return 0;
}
}
static const VkBaseInStructure *next_known_out(const void *p)
{
const VkBaseInStructure *b = p;
while (b) {
if (vkb_struct_size(b->sType)) return b;
VKB_ONCE(VKB_LOG_WARN, "output pNext: structure type %d is not bridged; left unfilled (logged once)", (int)b->sType);
b = b->pNext;
}
return NULL;
}
void vkb_enc_out_template(vkb_enc *e, const void *s, size_t size)
{
vkb_enc_raw(e, s, size);
const VkBaseInStructure *b = next_known_out(((const VkBaseInStructure *)s)->pNext);
while (b) {
size_t sz = vkb_struct_size(b->sType);
vkb_enc_u32(e, (uint32_t)b->sType);
vkb_enc_raw(e, b, sz);
size_t co, po, el;
if (out_array_info(b->sType, &co, &po, &el)) {
const void *arr;
memcpy(&arr, (const uint8_t *)b + po, sizeof(arr));
vkb_enc_u8(e, arr != NULL);
}
b = next_known_out(b->pNext);
}
vkb_enc_u32(e, VKB_CHAIN_END);
}
void vkb_enc_out_struct(vkb_enc *e, const void *s, size_t size)
{
vkb_enc_raw(e, s, size);
const VkBaseInStructure *b = ((const VkBaseInStructure *)s)->pNext;
for (; b; b = b->pNext) {
size_t sz = vkb_struct_size(b->sType);
if (!sz) continue;
vkb_enc_u32(e, (uint32_t)b->sType);
vkb_enc_raw(e, b, sz);
size_t co, po, el;
if (out_array_info(b->sType, &co, &po, &el)) {
const void *arr;
uint32_t n;
memcpy(&arr, (const uint8_t *)b + po, sizeof(arr));
memcpy(&n, (const uint8_t *)b + co, 4);
vkb_enc_u8(e, arr != NULL);
if (arr) {
vkb_enc_u32(e, n);
vkb_enc_raw(e, arr, (size_t)n * el);
}
}
}
vkb_enc_u32(e, VKB_CHAIN_END);
}
/* ------------------------------------------------------------------ decoder */
void vkb_dec_init(vkb_dec *d, const void *buf, size_t len, vkb_arena *a, int *fds, int nfds)
{
memset(d, 0, sizeof(*d));
d->buf = buf;
d->len = len;
d->arena = a;
d->fds = fds;
d->nfds = nfds;
}
void vkb_dec_bytes(vkb_dec *d, void *dst, size_t n)
{
if (d->err || d->len - d->pos < n) {
d->err = 1;
if (dst) memset(dst, 0, n);
return;
}
if (dst) memcpy(dst, d->buf + d->pos, n);
d->pos += n;
}
uint8_t vkb_dec_u8(vkb_dec *d) { uint8_t v; vkb_dec_bytes(d, &v, 1); return v; }
uint32_t vkb_dec_u32(vkb_dec *d) { uint32_t v; vkb_dec_bytes(d, &v, 4); return v; }
uint64_t vkb_dec_u64(vkb_dec *d) { uint64_t v; vkb_dec_bytes(d, &v, 8); return v; }
static void dec_align(vkb_dec *d)
{
size_t pad = (8 - (d->pos & 7)) & 7;
if (d->len - d->pos < pad) {
d->err = 1;
return;
}
d->pos += pad;
}
void vkb_dec_raw_into(vkb_dec *d, void *dst, size_t n)
{
dec_align(d);
vkb_dec_bytes(d, dst, n);
}
const void *vkb_dec_raw_view(vkb_dec *d, size_t n)
{
dec_align(d);
if (d->err || d->len - d->pos < n) {
d->err = 1;
return NULL;
}
const void *p = d->buf + d->pos;
d->pos += n;
return p;
}
void *vkb_dec_alloc(vkb_dec *d, size_t n)
{
if (d->err) return NULL;
if (n > ((size_t)1 << 32)) {
d->err = 1;
return NULL;
}
void *p = vkb_arena_alloc(d->arena, n);
if (!p) d->err = 1;
return p;
}
void *vkb_dec_alloc_zero(vkb_dec *d, size_t n) { return vkb_dec_alloc(d, n); }
const char *vkb_dec_str(vkb_dec *d)
{
if (!vkb_dec_u8(d)) return NULL;
uint32_t n = vkb_dec_u32(d);
if (d->err || d->len - d->pos < n) {
d->err = 1;
return NULL;
}
char *s = vkb_dec_alloc(d, (size_t)n + 1);
if (!s) return NULL;
memcpy(s, d->buf + d->pos, n);
s[n] = 0;
d->pos += n;
return s;
}
const char *const *vkb_dec_strarray(vkb_dec *d)
{
if (!vkb_dec_u8(d)) return NULL;
uint32_t n = vkb_dec_u32(d);
if (d->err || n > (d->len - d->pos)) {
d->err = 1;
return NULL;
}
const char **a = vkb_dec_alloc(d, (size_t)(n ? n : 1) * sizeof(char *));
for (uint32_t i = 0; a && i < n; i++) a[i] = vkb_dec_str(d);
return a;
}
const void *vkb_dec_blob(vkb_dec *d, size_t *n)
{
if (!vkb_dec_u8(d)) {
if (n) *n = 0;
return NULL;
}
uint64_t sz = vkb_dec_u64(d);
if (n) *n = (size_t)sz;
return vkb_dec_raw_view(d, (size_t)sz);
}
void vkb_dec_blob_into(vkb_dec *d, void *dst, size_t cap)
{
size_t n = 0;
const void *p = vkb_dec_blob(d, &n);
if (p && dst) memcpy(dst, p, n < cap ? n : cap);
}
int vkb_dec_fd(vkb_dec *d)
{
uint32_t i = vkb_dec_u32(d);
if (i == VKB_FD_NONE || d->err) return -1;
if ((int)i >= d->nfds || (d->fd_taken & (1u << i))) {
d->err = 1;
return -1;
}
d->fd_taken |= 1u << i;
return d->fds[i];
}
void vkb_dec_close_untaken(vkb_dec *d)
{
for (int i = 0; i < d->nfds; i++) {
if (!(d->fd_taken & (1u << i)) && d->fds[i] >= 0) close(d->fds[i]);
}
d->fd_taken = 0xffffffffu;
}
const void *vkb_dec_chain(vkb_dec *d)
{
uint32_t t = vkb_dec_u32(d);
if (d->err || t == VKB_CHAIN_END) return NULL;
size_t sz = vkb_struct_size((VkStructureType)t);
if (!sz) {
VKB_ERR("protocol: unknown structure type %u in a chain", t);
d->err = 1;
return NULL;
}
void *p = vkb_dec_alloc(d, sz);
if (!p) return NULL;
vkb_dec_chain_elem(d, (VkStructureType)t, p);
return p;
}
void vkb_dec_out_template(vkb_dec *d, void *dst, size_t size)
{
vkb_dec_raw_into(d, dst, size);
VkBaseOutStructure *prev = dst;
prev->pNext = NULL;
for (;;) {
uint32_t t = vkb_dec_u32(d);
if (d->err || t == VKB_CHAIN_END) break;
size_t sz = vkb_struct_size((VkStructureType)t);
if (!sz) {
d->err = 1;
break;
}
VkBaseOutStructure *el = vkb_dec_alloc(d, sz);
if (!el) break;
vkb_dec_raw_into(d, el, sz);
el->pNext = NULL;
size_t co, po, es;
if (out_array_info((VkStructureType)t, &co, &po, &es)) {
void *arr = NULL;
if (vkb_dec_u8(d)) {
uint32_t n;
memcpy(&n, (uint8_t *)el + co, 4);
arr = vkb_dec_alloc(d, (size_t)(n ? n : 1) * es);
}
memcpy((uint8_t *)el + po, &arr, sizeof(arr));
}
prev->pNext = el;
prev = el;
}
}
void vkb_dec_out_struct(vkb_dec *d, void *dst, size_t size)
{
VkBaseOutStructure *top = dst;
VkBaseOutStructure *keep = top->pNext;
vkb_dec_raw_into(d, dst, size);
top->pNext = keep;
VkBaseOutStructure *app = (VkBaseOutStructure *)next_known_out(keep);
for (;;) {
uint32_t t = vkb_dec_u32(d);
if (d->err || t == VKB_CHAIN_END) break;
size_t sz = vkb_struct_size((VkStructureType)t);
const uint8_t *src = vkb_dec_raw_view(d, sz);
if (!src || !sz) {
d->err = 1;
break;
}
size_t co, po, es;
int has_arr = out_array_info((VkStructureType)t, &co, &po, &es);
uint8_t arr_present = has_arr ? vkb_dec_u8(d) : 0;
uint32_t arr_n = 0;
const uint8_t *arr_src = NULL;
if (arr_present) {
arr_n = vkb_dec_u32(d);
arr_src = vkb_dec_raw_view(d, (size_t)arr_n * es);
}
if (!app || (uint32_t)app->sType != t) {
/* The server answered for a structure we did not send: protocol mismatch. */
d->err = 1;
break;
}
VkBaseOutStructure *keep_next = app->pNext;
uint32_t cap = 0;
void *app_arr = NULL;
if (has_arr) {
memcpy(&cap, (uint8_t *)app + co, 4);
memcpy(&app_arr, (uint8_t *)app + po, sizeof(app_arr));
}
memcpy(app, src, sz);
app->pNext = keep_next;
if (has_arr) {
memcpy((uint8_t *)app + po, &app_arr, sizeof(app_arr));
if (app_arr && arr_src) {
uint32_t n = arr_n < cap ? arr_n : cap;
memcpy(app_arr, arr_src, (size_t)n * es);
memcpy((uint8_t *)app + co, &n, 4);
}
}
app = (VkBaseOutStructure *)next_known_out(keep_next);
}
}
void vkb_close_fd(int fd)
{
if (fd >= 0) close(fd);
}
/* ------------------------------------------------------------------ predicates */
int vkb_desc_has_image(VkDescriptorType t)
{
return t == VK_DESCRIPTOR_TYPE_SAMPLER || t == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER ||
t == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE || t == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE ||
t == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT || t == VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM ||
t == VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM;
}
int vkb_desc_has_buffer(VkDescriptorType t)
{
return t == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER || t == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER ||
t == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC || t == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC;
}
int vkb_desc_has_texel(VkDescriptorType t)
{
return t == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER || t == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
}
int vkb_gp_has_tess(const VkGraphicsPipelineCreateInfo *s)
{
if (!s->pStages) return 1; /* library pieces: trust the pointer */
for (uint32_t i = 0; i < s->stageCount; i++) {
if (s->pStages[i].stage & (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT))
return 1;
}
return 0;
}
/* ------------------------------------------------------------------ transport */
int vkb_send_msg(int sock, const vkb_msg_hdr *h, const void *payload, const int *fds, int nfds)
{
struct iovec iov[2];
iov[0].iov_base = (void *)h;
iov[0].iov_len = sizeof(*h);
iov[1].iov_base = (void *)payload;
iov[1].iov_len = h->size;
union {
char buf[CMSG_SPACE(sizeof(int) * VKB_MAX_FDS)];
struct cmsghdr align;
} cm;
struct msghdr msg;
memset(&msg, 0, sizeof(msg));
msg.msg_iov = iov;
msg.msg_iovlen = h->size ? 2 : 1;
if (nfds > 0) {
memset(&cm, 0, sizeof(cm));
msg.msg_control = cm.buf;
msg.msg_controllen = CMSG_SPACE(sizeof(int) * nfds);
struct cmsghdr *c = CMSG_FIRSTHDR(&msg);
c->cmsg_level = SOL_SOCKET;
c->cmsg_type = SCM_RIGHTS;
c->cmsg_len = CMSG_LEN(sizeof(int) * nfds);
memcpy(CMSG_DATA(c), fds, sizeof(int) * nfds);
}
size_t total = sizeof(*h) + h->size;
size_t sent = 0;
while (sent < total) {
ssize_t r = sendmsg(sock, &msg, MSG_NOSIGNAL);
if (r < 0) {
if (errno == EINTR) continue;
return -1;
}
sent += (size_t)r;
if (sent >= total) break;
/* Partial write: advance the iovecs; fds went with the first chunk. */
msg.msg_control = NULL;
msg.msg_controllen = 0;
size_t skip = (size_t)r;
while (msg.msg_iovlen && skip >= msg.msg_iov[0].iov_len) {
skip -= msg.msg_iov[0].iov_len;
msg.msg_iov++;
msg.msg_iovlen--;
}
if (msg.msg_iovlen) {
msg.msg_iov[0].iov_base = (uint8_t *)msg.msg_iov[0].iov_base + skip;
msg.msg_iov[0].iov_len -= skip;
}
}
return 0;
}
static int read_full(int sock, void *buf, size_t n)
{
size_t got = 0;
while (got < n) {
ssize_t r = recv(sock, (uint8_t *)buf + got, n - got, 0);
if (r == 0) return -1;
if (r < 0) {
if (errno == EINTR) continue;
return -1;
}
got += (size_t)r;
}
return 0;
}
int vkb_recv_msg(int sock, vkb_msg_hdr *h, uint8_t **payload, size_t *cap, int *fds, int *nfds)
{
union {
char buf[CMSG_SPACE(sizeof(int) * VKB_MAX_FDS)];
struct cmsghdr align;
} cm;
struct iovec iov = {h, sizeof(*h)};
struct msghdr msg;
memset(&msg, 0, sizeof(msg));
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = cm.buf;
msg.msg_controllen = sizeof(cm.buf);
*nfds = 0;
ssize_t r;
do {
r = recvmsg(sock, &msg, MSG_CMSG_CLOEXEC);
} while (r < 0 && errno == EINTR);
if (r <= 0) return -1;
for (struct cmsghdr *c = CMSG_FIRSTHDR(&msg); c; c = CMSG_NXTHDR(&msg, c)) {
if (c->cmsg_level == SOL_SOCKET && c->cmsg_type == SCM_RIGHTS) {
int n = (int)((c->cmsg_len - CMSG_LEN(0)) / sizeof(int));
for (int i = 0; i < n; i++) {
int fd;
memcpy(&fd, CMSG_DATA(c) + i * sizeof(int), sizeof(int));
if (*nfds < VKB_MAX_FDS) fds[(*nfds)++] = fd;
else close(fd);
}
}
}
if ((size_t)r < sizeof(*h) && read_full(sock, (uint8_t *)h + r, sizeof(*h) - (size_t)r) < 0) goto fail;
if (h->magic != VKB_MAGIC) {
VKB_ERR("transport: bad message magic 0x%08x", h->magic);
goto fail;
}
if (h->size) {
if (h->size > *cap) {
size_t nc = *cap ? *cap : 65536;
while (nc < h->size) nc *= 2;
uint8_t *nb = realloc(*payload, nc);
if (!nb) goto fail;
*payload = nb;
*cap = nc;
}
if (read_full(sock, *payload, h->size) < 0) goto fail;
}
return 0;
fail:
for (int i = 0; i < *nfds; i++) close(fds[i]);
*nfds = 0;
return -1;
}