mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-19 12:56:06 +00:00
Squash of Droid-Deck/DroidDeck#517 (ASEbrahim/DroidDeck mali-bridge @ 6b823341): the Vulkan
bridge (tools/vkbridge) that runs the guest's Vulkan on the phone's own driver, with BC1-BC7,
clip/cull distance, vertex-divisor and depth-clip emulation and dma-heap memory sharing for Mali.
All of the bridge is ASEbrahim's work; squashed only to carry it on this test branch.
Combined with #570 on this branch, a device draws through exactly one path:
- Adreno: Turnip, unchanged (checked first; the bridge setting is ignored there).
- PowerVR / Xclipse with the system HAL and a render node: the system-Vulkan path (#570).
- Anything else with the Setup toggle on (Mali): the bridge.
711 lines
21 KiB
C
711 lines
21 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 caller-provided arrays (the two-call idiom inside a struct). An
|
|
* "empty" one is always answered with no elements (its elements carry chains of their own). */
|
|
typedef struct out_arr {
|
|
VkStructureType t;
|
|
size_t count_off, ptr_off, elem;
|
|
int empty;
|
|
} out_arr;
|
|
|
|
#define OA(T, ST, CNT, PTR, ELEM, EMPTY) {ST, offsetof(T, CNT), offsetof(T, PTR), sizeof(ELEM), EMPTY}
|
|
static const out_arr out_arrays[] = {
|
|
OA(VkDrmFormatModifierPropertiesListEXT, VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT,
|
|
drmFormatModifierCount, pDrmFormatModifierProperties, VkDrmFormatModifierPropertiesEXT, 0),
|
|
OA(VkDrmFormatModifierPropertiesList2EXT, VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT,
|
|
drmFormatModifierCount, pDrmFormatModifierProperties, VkDrmFormatModifierProperties2EXT, 0),
|
|
OA(VkPhysicalDeviceVulkan14Properties, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES,
|
|
copySrcLayoutCount, pCopySrcLayouts, VkImageLayout, 0),
|
|
OA(VkPhysicalDeviceVulkan14Properties, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES,
|
|
copyDstLayoutCount, pCopyDstLayouts, VkImageLayout, 0),
|
|
OA(VkPhysicalDeviceHostImageCopyProperties, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES,
|
|
copySrcLayoutCount, pCopySrcLayouts, VkImageLayout, 0),
|
|
OA(VkPhysicalDeviceHostImageCopyProperties, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES,
|
|
copyDstLayoutCount, pCopyDstLayouts, VkImageLayout, 0),
|
|
OA(VkPhysicalDeviceLayeredApiPropertiesListKHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR,
|
|
layeredApiCount, pLayeredApis, VkPhysicalDeviceLayeredApiPropertiesKHR, 1),
|
|
};
|
|
#undef OA
|
|
#define N_OUT_ARRAYS (sizeof(out_arrays) / sizeof(out_arrays[0]))
|
|
|
|
static uint32_t rd32(const void *base, size_t off) { uint32_t v; memcpy(&v, (const uint8_t *)base + off, 4); return v; }
|
|
static void wr32(void *base, size_t off, uint32_t v) { memcpy((uint8_t *)base + off, &v, 4); }
|
|
static void *rdp(const void *base, size_t off) { void *v; memcpy(&v, (const uint8_t *)base + off, sizeof(v)); return v; }
|
|
static void wrp(void *base, size_t off, void *v) { memcpy((uint8_t *)base + off, &v, sizeof(v)); }
|
|
|
|
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);
|
|
for (size_t i = 0; i < N_OUT_ARRAYS; i++)
|
|
if (out_arrays[i].t == b->sType) vkb_enc_u8(e, !out_arrays[i].empty && rdp(b, out_arrays[i].ptr_off) != 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);
|
|
for (size_t i = 0; i < N_OUT_ARRAYS; i++) {
|
|
const out_arr *oa = &out_arrays[i];
|
|
if (oa->t != b->sType) continue;
|
|
const void *arr = rdp(b, oa->ptr_off);
|
|
vkb_enc_u8(e, arr != NULL);
|
|
if (arr) {
|
|
uint32_t n = rd32(b, oa->count_off);
|
|
vkb_enc_u32(e, n);
|
|
vkb_enc_raw(e, arr, (size_t)n * oa->elem);
|
|
}
|
|
}
|
|
}
|
|
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;
|
|
for (size_t i = 0; i < N_OUT_ARRAYS; i++) {
|
|
const out_arr *oa = &out_arrays[i];
|
|
if (oa->t != (VkStructureType)t) continue;
|
|
void *arr = NULL;
|
|
if (vkb_dec_u8(d)) {
|
|
uint32_t n = rd32(el, oa->count_off);
|
|
arr = vkb_dec_alloc(d, (size_t)(n ? n : 1) * oa->elem);
|
|
} else {
|
|
wr32(el, oa->count_off, 0);
|
|
}
|
|
wrp(el, oa->ptr_off, 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;
|
|
}
|
|
if (!app || (uint32_t)app->sType != t) {
|
|
/* The server answered for a structure we did not send: protocol mismatch. */
|
|
d->err = 1;
|
|
break;
|
|
}
|
|
/* The caller's own pointers and array capacities survive the copy. */
|
|
VkBaseOutStructure *keep_next = app->pNext;
|
|
void *app_arr[4] = {0};
|
|
uint32_t cap[4] = {0};
|
|
int na = 0;
|
|
for (size_t i = 0; i < N_OUT_ARRAYS && na < 4; i++) {
|
|
if (out_arrays[i].t != (VkStructureType)t) continue;
|
|
app_arr[na] = rdp(app, out_arrays[i].ptr_off);
|
|
cap[na] = rd32(app, out_arrays[i].count_off);
|
|
na++;
|
|
}
|
|
memcpy(app, src, sz);
|
|
app->pNext = keep_next;
|
|
na = 0;
|
|
for (size_t i = 0; i < N_OUT_ARRAYS && na < 4; i++) {
|
|
const out_arr *oa = &out_arrays[i];
|
|
if (oa->t != (VkStructureType)t) continue;
|
|
wrp(app, oa->ptr_off, app_arr[na]);
|
|
uint8_t present = vkb_dec_u8(d);
|
|
uint32_t n = 0;
|
|
const uint8_t *arr_src = NULL;
|
|
if (present) {
|
|
n = vkb_dec_u32(d);
|
|
arr_src = vkb_dec_raw_view(d, (size_t)n * oa->elem);
|
|
}
|
|
if (oa->empty) {
|
|
wr32(app, oa->count_off, 0);
|
|
} else if (app_arr[na] && arr_src) {
|
|
uint32_t m = n < cap[na] ? n : cap[na];
|
|
memcpy(app_arr[na], arr_src, (size_t)m * oa->elem);
|
|
wr32(app, oa->count_off, m);
|
|
}
|
|
na++;
|
|
}
|
|
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;
|
|
}
|