mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-22 06:15:58 +00:00
Retain external DMA-BUF ownership after GPU quarantine
This commit is contained in:
1 parent
37b775a9b6
commit
9fffb08f5a
9 files changed
+384
-19
No files matched your search
@@ -0,0 +1,106 @@
|
||||
"""Exercise production DMA-BUF release/ownership paths without a GPU.
|
||||
|
||||
Wayland resources and OS timer/Android AHB endpoints are fake; list macros and
|
||||
the compositor/AHB lifecycle functions come directly from the repository.
|
||||
"""
|
||||
import os
|
||||
from pathlib import Path
|
||||
import re
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
from test_vk_pending_completion import function
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
SRC = ROOT / 'app/src/main/cpp/waylandcomp/src'
|
||||
|
||||
|
||||
class VkDmabufQuarantineTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cc = shutil.which(os.environ.get('CC', 'cc'))
|
||||
if not cc:
|
||||
raise AssertionError('C compiler required')
|
||||
# Optional old-head input allows a genuine negative control using the
|
||||
# identical harness, rather than a model of the previous behaviour.
|
||||
source_dir = Path(os.environ.get('DROIDDECK_DMABUF_TEST_SOURCE', SRC))
|
||||
comp = (source_dir / 'compositor.c').read_text()
|
||||
ahb = (source_dir / 'ahb_swapchain.c').read_text()
|
||||
vk = (source_dir / 'vk_present.c').read_text()
|
||||
names = ['get_dmabuf', 'pending_release_free',
|
||||
'pending_releases_forget_surface', 'on_pending_release_buffer_destroyed',
|
||||
'arm_release_timer', 'on_release_timer', 'release_buffer',
|
||||
'dmabuf_buffer_unref', 'drop_dmabuf', 'on_dmabuf_destroyed',
|
||||
'droiddeck_dmabuf_ahb_slot', 'droiddeck_dmabuf_unref',
|
||||
'droiddeck_release_buffer']
|
||||
helpers = []
|
||||
if re.search(r'\bstatic int buffer_release_blocked\(', comp):
|
||||
helpers = [function(comp, n) for n in ('buffer_release_blocked', 'send_buffer_release')]
|
||||
else:
|
||||
helpers = ['static int __attribute__((unused)) buffer_release_blocked(struct wl_resource *b) { (void)b; return 0; }']
|
||||
query = function(vk, 'vkp_completion_unknown') if 'int vkp_completion_unknown(' in vk else \
|
||||
'int vkp_completion_unknown(void) { return g_dev_state == -3; }'
|
||||
comp_functions = [function(comp, names[0])] + helpers + [function(comp, n) for n in names[1:]]
|
||||
ahb_functions = [function(ahb, n) for n in ('buf_free', 'maybe_free',
|
||||
'on_buffer_resource_destroyed', 'send_deferred_release',
|
||||
'on_fence_readable', 'ahb_swapchain_defer_release',
|
||||
'ahb_swapchain_surface_gone')]
|
||||
structs = re.search(r'struct pending_release \{.*?\n\};', comp, re.S).group() + '\n' + \
|
||||
re.search(r'struct ahb_buf \{.*?\n\};', ahb, re.S).group()
|
||||
harness = Path(__file__).with_name('vk_dmabuf_quarantine_test.c').read_text()
|
||||
harness = harness.replace('/* PRODUCTION_STRUCTS */', structs)
|
||||
harness = harness.replace('/* PRODUCTION_FUNCTIONS */', '\n'.join([query] + comp_functions + ahb_functions))
|
||||
cls.tmp = tempfile.TemporaryDirectory(prefix='droiddeck-dmabuf-')
|
||||
cls.addClassCleanup(cls.tmp.cleanup)
|
||||
probe = Path(cls.tmp.name) / 'probe.c'
|
||||
probe.write_text(harness)
|
||||
cls.binary = probe.with_suffix('')
|
||||
built = subprocess.run([cc, '-std=c11', '-Wall', '-Wextra', '-Werror',
|
||||
'-Wno-unused-parameter', '-UNDEBUG',
|
||||
'-I', str(SRC.parent / 'prebuilt/include'),
|
||||
str(probe), '-o', str(cls.binary)], capture_output=True, text=True)
|
||||
if built.returncode:
|
||||
raise AssertionError(built.stdout + built.stderr)
|
||||
|
||||
def run_scenario(self, name):
|
||||
result = subprocess.run([str(self.binary), name], capture_output=True, text=True, timeout=10)
|
||||
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
||||
|
||||
def test_replacement_retains_reference_and_release(self):
|
||||
self.run_scenario('replacement')
|
||||
|
||||
def test_surface_destroy_retains_reference_and_release(self):
|
||||
self.run_scenario('surface-gone')
|
||||
|
||||
def test_queued_release_is_held_and_timer_disarmed(self):
|
||||
self.run_scenario('queued')
|
||||
|
||||
def test_mixed_queue_releases_only_copied_shm(self):
|
||||
self.run_scenario('mixed')
|
||||
|
||||
def test_client_destroy_retains_backing_fd(self):
|
||||
self.run_scenario('client-gone')
|
||||
|
||||
def test_ahb_callback_retains_ownership_and_release(self):
|
||||
self.run_scenario('ahb')
|
||||
|
||||
def test_active_client_destroy_retains_reference(self):
|
||||
self.run_scenario('active-client-gone')
|
||||
|
||||
def test_healthy_ahb_callback_and_cleanup(self):
|
||||
self.run_scenario('ahb-healthy')
|
||||
|
||||
def test_device_lost_ahb_callback_and_cleanup(self):
|
||||
self.run_scenario('ahb-device-lost')
|
||||
|
||||
def test_healthy_release_and_reference_cleanup(self):
|
||||
self.run_scenario('healthy')
|
||||
|
||||
def test_genuine_device_loss_keeps_existing_cleanup(self):
|
||||
self.run_scenario('device-lost')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -57,7 +57,7 @@ int __android_log_print(int, const char *, const char *, ...);
|
||||
''')
|
||||
(tmp / 'wayland-server.h').write_text('#pragma once\nstruct wl_display; struct wl_resource; struct wl_client;\n')
|
||||
compositor = (SOURCE.parent / 'compositor.c').read_text()
|
||||
callers = '\n'.join(function(compositor, n) for n in ('take_shm', 'take_pixel'))
|
||||
callers = '\n'.join(function(compositor, n) for n in ('buffer_release_blocked', 'send_buffer_release', 'take_shm', 'take_pixel'))
|
||||
harness = (Path(__file__).with_name('vk_terminal_callers_test.c')).read_text()
|
||||
probe = tmp / 'probe.c'
|
||||
probe.write_text(harness.replace('/* COMPOSITOR_CALLERS */', callers))
|
||||
|
||||
@@ -0,0 +1,199 @@
|
||||
/* Production lifecycle functions are inserted verbatim by Python. No GPU,
|
||||
* Android app, external client or real timer is involved in this probe. */
|
||||
#define _POSIX_C_SOURCE 200809L
|
||||
#include <assert.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
#include <wayland-util.h>
|
||||
#ifndef __linux__
|
||||
struct itimerspec { struct timespec it_interval, it_value; };
|
||||
#endif
|
||||
|
||||
struct wl_listener { struct wl_list link; void (*notify)(struct wl_listener *, void *); };
|
||||
struct wl_resource { int dma; void *user_data; struct wl_list listeners; unsigned releases; };
|
||||
struct wl_client;
|
||||
struct wl_event_source { int unused; };
|
||||
typedef struct AHardwareBuffer { int unused; } AHardwareBuffer;
|
||||
struct vkp_image { int unused; };
|
||||
struct dmabuf_buffer {
|
||||
int refs, n_planes, fd[4];
|
||||
struct vkp_image *img;
|
||||
void *ahb_state;
|
||||
};
|
||||
struct surface {
|
||||
struct wl_resource *dmabuf;
|
||||
struct dmabuf_buffer *dmabuf_buf;
|
||||
struct wl_listener dmabuf_destroy;
|
||||
int releases_pending;
|
||||
int64_t next_release_ns;
|
||||
};
|
||||
/* PRODUCTION_STRUCTS */
|
||||
static int g_dev_state, g_fps_limit, g_release_timer_fd;
|
||||
static int64_t g_refresh_ns;
|
||||
static struct wl_list g_pending_releases, g_bufs;
|
||||
static void *g_display;
|
||||
static unsigned image_destroys, ahb_releases, source_removes;
|
||||
static struct itimerspec last_timer;
|
||||
static const int wl_buffer_interface = 1, dbuf_buffer_impl = 2;
|
||||
#define TFD_TIMER_ABSTIME 1
|
||||
|
||||
/* List operations use the real Wayland layouts/macros. OS/IPC endpoints alone
|
||||
* are fakes, so no event is sent and no process or hardware is touched. */
|
||||
void wl_list_init(struct wl_list *l) { l->prev = l; l->next = l; }
|
||||
void wl_list_insert(struct wl_list *l, struct wl_list *e) {
|
||||
e->next = l->next; e->prev = l; l->next->prev = e; l->next = e;
|
||||
}
|
||||
void wl_list_remove(struct wl_list *e) { e->next->prev = e->prev; e->prev->next = e->next; }
|
||||
static int wl_resource_instance_of(struct wl_resource *r, const void *i, const void *impl) { return r->dma; }
|
||||
static void *wl_resource_get_user_data(struct wl_resource *r) { return r->user_data; }
|
||||
static void wl_resource_add_destroy_listener(struct wl_resource *r, struct wl_listener *l) {
|
||||
wl_list_insert(r->listeners.prev, &l->link);
|
||||
}
|
||||
static void wl_buffer_send_release(struct wl_resource *r) { ++r->releases; }
|
||||
static void wl_display_flush_clients(void *d) {}
|
||||
static int timerfd_settime(int fd, int flags, const struct itimerspec *v, void *old) { last_timer = *v; return 0; }
|
||||
static void perf_note_release(int64_t since) {}
|
||||
static int64_t now_ns(void) { return 1000000000LL; }
|
||||
static void vkp_image_destroy(struct vkp_image *img) { ++image_destroys; }
|
||||
static void AHardwareBuffer_release(AHardwareBuffer *ahb) { ++ahb_releases; }
|
||||
static int wl_event_source_remove(struct wl_event_source *src) { ++source_removes; return 0; }
|
||||
static struct dmabuf_buffer *get_dmabuf(struct wl_resource *r);
|
||||
int ahb_swapchain_defer_release(struct dmabuf_buffer *, struct wl_resource *, struct surface *, int);
|
||||
/* PRODUCTION_FUNCTIONS */
|
||||
|
||||
static void init_resource(struct wl_resource *r, struct dmabuf_buffer *b) {
|
||||
*r = (struct wl_resource){.dma = b != NULL, .user_data = b};
|
||||
wl_list_init(&r->listeners);
|
||||
}
|
||||
static struct dmabuf_buffer *init_buffer(struct surface *s, struct wl_resource *r) {
|
||||
struct dmabuf_buffer *b = calloc(1, sizeof(*b)); assert(b);
|
||||
b->refs = 2; b->n_planes = 1;
|
||||
int fds[2]; assert(pipe(fds) == 0); b->fd[0] = fds[0]; close(fds[1]);
|
||||
init_resource(r, b);
|
||||
assert(get_dmabuf(r) == b);
|
||||
*s = (struct surface){.dmabuf = r, .dmabuf_buf = b};
|
||||
s->dmabuf_destroy.notify = on_dmabuf_destroyed;
|
||||
wl_resource_add_destroy_listener(r, &s->dmabuf_destroy);
|
||||
return b;
|
||||
}
|
||||
static void destroy_resource(struct wl_resource *r) {
|
||||
while (r->listeners.next != &r->listeners) {
|
||||
struct wl_listener *l = wl_container_of(r->listeners.next, l, link);
|
||||
l->notify(l, r);
|
||||
}
|
||||
if (r->dma) dmabuf_buffer_unref(r->user_data);
|
||||
r->user_data = NULL;
|
||||
}
|
||||
static void fire_timer(void) {
|
||||
int fd[2]; uint64_t expirations = 1;
|
||||
assert(pipe(fd) == 0 && write(fd[1], &expirations, sizeof(expirations)) == sizeof(expirations));
|
||||
on_release_timer(fd[0], 0, NULL); close(fd[0]); close(fd[1]);
|
||||
}
|
||||
static void assert_retained(struct dmabuf_buffer *b, int refs) {
|
||||
assert(b->refs == refs && fcntl(b->fd[0], F_GETFD) >= 0 && !image_destroys);
|
||||
}
|
||||
static void test_drop(int paced) {
|
||||
struct surface s; struct wl_resource r;
|
||||
struct dmabuf_buffer *b = init_buffer(&s, &r);
|
||||
g_dev_state = -3; drop_dmabuf(&s, paced);
|
||||
assert(!s.dmabuf && !s.dmabuf_buf && !r.releases && !s.releases_pending);
|
||||
assert(r.listeners.next == &r.listeners); /* no listener into a dead surface */
|
||||
assert_retained(b, 2);
|
||||
destroy_resource(&r); assert_retained(b, 2);
|
||||
close(b->fd[0]); free(b); /* fake GPU only */
|
||||
}
|
||||
static void test_queue(int mixed, int client_gone) {
|
||||
struct surface s; struct wl_resource r, shm;
|
||||
struct dmabuf_buffer *b = init_buffer(&s, &r);
|
||||
g_release_timer_fd = 123; g_refresh_ns = 100000;
|
||||
drop_dmabuf(&s, 1); assert(s.releases_pending == 1 && !r.releases);
|
||||
assert(last_timer.it_value.tv_sec || last_timer.it_value.tv_nsec);
|
||||
if (mixed) { init_resource(&shm, NULL); release_buffer(&s, &shm, now_ns()); }
|
||||
pending_releases_forget_surface(&s);
|
||||
g_dev_state = -3;
|
||||
fire_timer();
|
||||
assert(!r.releases && g_pending_releases.next != &g_pending_releases);
|
||||
if (mixed) assert(shm.releases == 1);
|
||||
assert(!last_timer.it_value.tv_sec && !last_timer.it_value.tv_nsec);
|
||||
assert_retained(b, 1);
|
||||
if (client_gone) {
|
||||
destroy_resource(&r);
|
||||
assert(g_pending_releases.next == &g_pending_releases);
|
||||
assert_retained(b, 1);
|
||||
}
|
||||
close(b->fd[0]); free(b); /* fake GPU only */
|
||||
}
|
||||
static void test_active_client_destroy(void) {
|
||||
struct surface s; struct wl_resource r;
|
||||
struct dmabuf_buffer *b = init_buffer(&s, &r);
|
||||
g_dev_state = -3;
|
||||
destroy_resource(&r);
|
||||
assert(!s.dmabuf && s.dmabuf_buf == b && !r.releases);
|
||||
drop_dmabuf(&s, 0); assert(!s.dmabuf_buf);
|
||||
assert_retained(b, 2);
|
||||
close(b->fd[0]); free(b); /* fake GPU only */
|
||||
}
|
||||
static void test_ahb(int terminal, int lost) {
|
||||
struct surface s; struct wl_resource r;
|
||||
struct dmabuf_buffer *b = init_buffer(&s, &r);
|
||||
struct ahb_buf *ab = calloc(1, sizeof(*ab)); assert(ab);
|
||||
AHardwareBuffer ahb;
|
||||
*ab = (struct ahb_buf){.b = b, .ahb = &ahb, .resource = &r, .on_layer = 1, .fence_fd = -1};
|
||||
b->ahb_state = ab; ++b->refs;
|
||||
ab->resource_destroy.notify = on_buffer_resource_destroyed;
|
||||
wl_resource_add_destroy_listener(&r, &ab->resource_destroy);
|
||||
wl_list_insert(&g_bufs, &ab->link);
|
||||
drop_dmabuf(&s, 1); assert(ab->release_pending && ab->surface == &s);
|
||||
int backing_fd = b->fd[0];
|
||||
g_dev_state = terminal ? -3 : lost ? -2 : 1;
|
||||
ahb_swapchain_surface_gone(&s); assert(!ab->surface);
|
||||
/* Actual event-loop callback after the display's fence becomes readable. */
|
||||
struct wl_event_source source; int fds[2]; assert(pipe(fds) == 0);
|
||||
ab->on_layer = 0; ab->fence_src = &source; ab->fence_fd = fds[0];
|
||||
on_fence_readable(fds[0], 0, ab); close(fds[1]);
|
||||
assert(source_removes == 1 && ab->fence_fd == -1 && !ab->fence_src);
|
||||
assert(r.releases == (terminal ? 0u : 1u));
|
||||
assert(ab->release_pending == terminal && !ahb_releases);
|
||||
destroy_resource(&r);
|
||||
if (terminal) {
|
||||
assert(!ab->resource && b->ahb_state == ab && !ahb_releases);
|
||||
assert_retained(b, 2);
|
||||
close(b->fd[0]); free(ab); free(b); /* fake GPU only */
|
||||
} else {
|
||||
assert(ahb_releases == 1 && image_destroys == 1);
|
||||
errno = 0; assert(fcntl(backing_fd, F_GETFD) == -1 && errno == EBADF);
|
||||
}
|
||||
}
|
||||
static void test_cleanup(int lost) {
|
||||
struct surface s; struct wl_resource r;
|
||||
struct dmabuf_buffer *b = init_buffer(&s, &r);
|
||||
int fd = b->fd[0]; g_dev_state = lost ? -2 : 1;
|
||||
assert(!vkp_completion_unknown());
|
||||
drop_dmabuf(&s, 0);
|
||||
assert(r.releases == 1 && b->refs == 1 && !image_destroys);
|
||||
destroy_resource(&r); assert(image_destroys == 1);
|
||||
errno = 0; assert(fcntl(fd, F_GETFD) == -1 && errno == EBADF);
|
||||
}
|
||||
int main(int argc, char **argv) {
|
||||
assert(argc == 2);
|
||||
wl_list_init(&g_pending_releases); wl_list_init(&g_bufs);
|
||||
g_dev_state = 1; g_release_timer_fd = -1;
|
||||
if (!strcmp(argv[1], "replacement")) test_drop(1);
|
||||
else if (!strcmp(argv[1], "surface-gone")) test_drop(0);
|
||||
else if (!strcmp(argv[1], "queued")) test_queue(0, 0);
|
||||
else if (!strcmp(argv[1], "mixed")) test_queue(1, 0);
|
||||
else if (!strcmp(argv[1], "client-gone")) test_queue(0, 1);
|
||||
else if (!strcmp(argv[1], "ahb")) test_ahb(1, 0);
|
||||
else if (!strcmp(argv[1], "ahb-healthy")) test_ahb(0, 0);
|
||||
else if (!strcmp(argv[1], "ahb-device-lost")) test_ahb(0, 1);
|
||||
else if (!strcmp(argv[1], "active-client-gone")) test_active_client_destroy();
|
||||
else if (!strcmp(argv[1], "healthy")) test_cleanup(0);
|
||||
else if (!strcmp(argv[1], "device-lost")) test_cleanup(1);
|
||||
else assert(0 && "unknown scenario");
|
||||
return 0;
|
||||
}
|
||||
@@ -108,6 +108,10 @@ static void wl_shm_buffer_end_access(struct wl_shm_buffer *b) {}
|
||||
static void wl_buffer_send_release(struct wl_resource *b) { ++releases; }
|
||||
static struct wl_client *wl_resource_get_client(struct wl_resource *r) { return NULL; }
|
||||
static struct client_info *client_info_of(struct wl_client *c) { return NULL; }
|
||||
/* This harness exercises copied SHM/pixel callers; DMA-BUF lifecycle paths are
|
||||
* compiled separately by test_vk_dmabuf_quarantine.py. */
|
||||
struct dmabuf_buffer;
|
||||
static struct dmabuf_buffer *get_dmabuf(struct wl_resource *buffer) { return NULL; }
|
||||
/* COMPOSITOR_CALLERS */
|
||||
|
||||
static void setup(int extra) {
|
||||
@@ -174,7 +178,7 @@ static void acquire_failure(int later, VkResult result) {
|
||||
idle_answer = VK_ERROR_OUT_OF_HOST_MEMORY;
|
||||
VkImage *retained = g_images;
|
||||
assert(vkp_render(64, 64, NULL, 0) == -1);
|
||||
assert(g_dev_state == -3 && !vkp_device_lost());
|
||||
assert(g_dev_state == -3 && vkp_completion_unknown() && !vkp_device_lost());
|
||||
assert(acquires == fail_acquire_at && idle_calls == 1);
|
||||
assert(submits == (unsigned)later && markers == 0 && waits == 0);
|
||||
assert(destroys == 0 && g_images == retained && g_nimg == 1);
|
||||
@@ -234,6 +238,7 @@ int main(int argc, char **argv) {
|
||||
if (!strcmp(name, "acquire-device-lost")) { fail_acquire_at = 2; acquire_answer = VK_ERROR_DEVICE_LOST; }
|
||||
else present_answer = VK_ERROR_DEVICE_LOST;
|
||||
assert(vkp_render(64, 64, NULL, 0) == -1 && vkp_device_lost());
|
||||
assert(!vkp_completion_unknown());
|
||||
assert(g_dev_state == -2 && lost_notifications == 1 && markers == 0 && waits == 0);
|
||||
assert(!g_images && !g_swapchain && !g_surface && destroys == 2);
|
||||
assert_stopped();
|
||||
|
||||
Reference in new issue
Block a user