fix(compositor): hold releases from synchronized subsurfaces until the parent commits (#2721)

* fix(compositor): hold releases from synchronized subsurfaces until the parent commits

gamescope's Wayland backend moves layers between synchronized subsurface
planes and commits the parent last. Each child commit was applied at once,
so a buffer leaving one plane could be released before the next plane took
it, and gamescope then logged "Compositor released us but we were not
acquired". A buffer attached again also dropped its queued release, and the
buffer trace records every attach.

* fix(compositor): hold a synchronized release at its sync boundary and recheck holds on set_desync

---------

Co-authored-by: maxjivi05 <maxjividen@gmail.com>
This commit is contained in:
The412Bannerandmaxjivi05 authored and GitHub committed 2026-11-18 11:10:57 -05:00
1 parent 2a274623da
commit a139d9eff4
6 files changed
+508 -22

No files matched your search

+82 -18
View File
@@ -256,6 +256,7 @@ struct surface {
struct wl_list child_link;
int sub_x, sub_y, sub_pending_x, sub_pending_y, sub_pending;
int below_parent;
int sub_desync;
int fullscreen;
int toplevel_committed;
@@ -332,6 +333,7 @@ struct pending_release {
struct wl_resource *buffer;
struct wl_listener destroy;
struct surface *surface;
struct surface *held_by;
int64_t at_ns;
int64_t since_ns;
struct wl_list link;
@@ -434,10 +436,54 @@ static void pending_release_free(struct pending_release *pr) {
free(pr);
}
static void release_due_buffers(void);
static void arm_release_timer(void);
static void pending_releases_forget_surface(struct surface *s) {
struct pending_release *pr;
wl_list_for_each(pr, &g_pending_releases, link)
int unheld = 0;
wl_list_for_each(pr, &g_pending_releases, link) {
if (pr->surface == s) pr->surface = NULL;
if (pr->held_by == s) { pr->held_by = NULL; unheld = 1; }
}
if (unheld) { release_due_buffers(); arm_release_timer(); }
}
static void pending_releases_cancel(struct wl_resource *buffer) {
struct pending_release *pr, *tmp;
wl_list_for_each_safe(pr, tmp, &g_pending_releases, link)
if (pr->buffer == buffer) pending_release_free(pr);
}
static void pending_releases_apply(struct surface *holder) {
struct pending_release *pr;
int unheld = 0;
wl_list_for_each(pr, &g_pending_releases, link)
if (pr->held_by == holder) { pr->held_by = NULL; unheld = 1; }
if (unheld) { release_due_buffers(); arm_release_timer(); }
}
static struct surface *sync_holder(struct surface *s) {
struct surface *holder = NULL;
for (int depth = 0; s && s->role == ROLE_SUBSURFACE && s->parent && depth < 8; depth++) {
if (!s->sub_desync) holder = s->parent;
s = s->parent;
}
return holder;
}
static void pending_releases_rehold(struct surface *changed) {
struct pending_release *pr;
int unheld = 0;
wl_list_for_each(pr, &g_pending_releases, link) {
if (!pr->held_by || !pr->surface) continue;
struct surface *s = pr->surface;
for (int depth = 0; s && s != changed && depth < 8; depth++) s = s->parent;
if (s != changed) continue;
pr->held_by = sync_holder(pr->surface);
if (!pr->held_by) unheld = 1;
}
if (unheld) { release_due_buffers(); arm_release_timer(); }
}
static void on_pending_release_buffer_destroyed(struct wl_listener *l, void *data) {
@@ -450,20 +496,18 @@ static void arm_release_timer(void) {
int64_t earliest = 0;
if (g_release_timer_fd < 0) return;
wl_list_for_each(pr, &g_pending_releases, link)
if (!buffer_release_blocked(pr->buffer) && (!earliest || pr->at_ns < earliest))
if (!pr->held_by && !buffer_release_blocked(pr->buffer) && (!earliest || pr->at_ns < earliest))
earliest = pr->at_ns;
struct itimerspec its = {0};
if (earliest) { its.it_value.tv_sec = earliest / 1000000000LL; its.it_value.tv_nsec = earliest % 1000000000LL; }
timerfd_settime(g_release_timer_fd, TFD_TIMER_ABSTIME, &its, NULL);
}
static int on_release_timer(int fd, uint32_t mask, void *data) {
static void release_due_buffers(void) {
struct pending_release *pr, *tmp;
uint64_t expirations;
int64_t now = now_ns() + 300000;
if (read(fd, &expirations, sizeof(expirations)) < 0 && errno != EAGAIN) return 0;
wl_list_for_each_safe(pr, tmp, &g_pending_releases, link) {
if (pr->at_ns <= now && !buffer_release_blocked(pr->buffer)) {
if (!pr->held_by && pr->at_ns <= now && !buffer_release_blocked(pr->buffer)) {
/* Attached again since (to its surface or another): that surface releases it later. */
if (buffer_shown_elsewhere(pr->buffer, NULL)) {
pending_release_free(pr);
@@ -474,28 +518,39 @@ static int on_release_timer(int fd, uint32_t mask, void *data) {
pending_release_free(pr);
}
}
}
static int on_release_timer(int fd, uint32_t mask, void *data) {
uint64_t expirations;
if (read(fd, &expirations, sizeof(expirations)) < 0 && errno != EAGAIN) return 0;
release_due_buffers();
wl_display_flush_clients(g_display);
arm_release_timer();
return 0;
}
static void release_buffer(struct surface *s, struct wl_resource *buffer, int64_t since_ns) {
static void release_buffer(struct surface *s, struct wl_resource *buffer, int64_t since_ns, struct surface *holder) {
/* No allocation or immediate-release fallback is allowed for a quarantined
* DMA-BUF. Existing queued releases stay held; their timer is disarmed. */
if (buffer_release_blocked(buffer)) return;
const int limit = g_fps_limit;
const int64_t interval = limit > 0 ? 1000000000LL / limit : g_refresh_ns;
if (g_release_unpaced || interval <= 0 || g_release_timer_fd < 0) { send_buffer_release(buffer); perf_note_release(since_ns); return; }
const int paced = !g_release_unpaced && interval > 0 && g_release_timer_fd >= 0;
if (!paced && !holder) { send_buffer_release(buffer); perf_note_release(since_ns); return; }
int64_t now = now_ns();
int64_t at = s->next_release_ns + interval;
int64_t latest = now + interval * (int64_t)(s->releases_pending + 1);
if (at < now) at = now;
if (at > latest) at = latest;
s->next_release_ns = at;
int64_t at = now;
if (paced) {
int64_t latest = now + interval * (int64_t)(s->releases_pending + 1);
at = s->next_release_ns + interval;
if (at < now) at = now;
if (at > latest) at = latest;
s->next_release_ns = at;
}
struct pending_release *pr = calloc(1, sizeof(*pr));
if (!pr) { send_buffer_release(buffer); perf_note_release(since_ns); return; }
pr->buffer = buffer;
pr->surface = s;
pr->held_by = holder;
pr->at_ns = at;
pr->since_ns = since_ns;
pr->destroy.notify = on_pending_release_buffer_destroyed;
@@ -721,7 +776,7 @@ static void drop_dmabuf(struct surface *s, int paced) {
wl_list_remove(&s->dmabuf_destroy.link);
if (buffer_shown_elsewhere(s->dmabuf, s)) {
} else if (!ahb_swapchain_defer_release(s->dmabuf_buf, s->dmabuf, s, paced)) {
if (paced) release_buffer(s, s->dmabuf, now_ns());
if (paced) release_buffer(s, s->dmabuf, now_ns(), sync_holder(s));
else send_buffer_release(s->dmabuf);
}
s->dmabuf = NULL;
@@ -887,6 +942,7 @@ static void take_dmabuf(struct surface *s, struct dmabuf_buffer *b, struct wl_re
s->last_dmabuf = buffer;
pace_note_buffer(buffer);
drop_dmabuf(s, 1);
pending_releases_cancel(buffer);
s->dmabuf = buffer;
s->dmabuf_buf = b;
b->refs++;
@@ -977,7 +1033,7 @@ void droiddeck_dmabuf_ref(struct dmabuf_buffer *b) { b->refs++; }
void droiddeck_dmabuf_unref(struct dmabuf_buffer *b) { dmabuf_buffer_unref(b); }
void droiddeck_release_buffer(struct surface *s, struct wl_resource *buffer, int paced, int64_t since_ns) {
if (buffer_release_blocked(buffer)) return;
if (paced && s) release_buffer(s, buffer, since_ns);
if (paced && s) release_buffer(s, buffer, since_ns, NULL);
else { send_buffer_release(buffer); perf_note_release(since_ns); }
}
void droiddeck_surface_describe(const struct surface *s, char *out, size_t size) { describe(s, out, size); }
@@ -1265,6 +1321,7 @@ static void surface_commit(struct wl_client *c, struct wl_resource *r) {
s->pending_attach = 0;
surface_drop_idle(s);
buf_trace_attach(buffer);
if (s->role == ROLE_CURSOR) {
if (!buffer) {
cursor_publish_hidden();
@@ -1275,7 +1332,6 @@ static void surface_commit(struct wl_client *c, struct wl_resource *r) {
} else if (s->role == ROLE_NONE) {
if (buffer) surface_hold_idle(s, buffer);
} else if (db) {
buf_trace_attach(buffer);
take_dmabuf(s, db, buffer);
} else if (shm) {
drop_dmabuf(s, 1);
@@ -1289,6 +1345,7 @@ static void surface_commit(struct wl_client *c, struct wl_resource *r) {
if (buffer) send_buffer_release(buffer);
}
}
pending_releases_apply(s);
wl_list_for_each(child, &s->children, child_link) {
if (child->sub_pending) {
@@ -1486,8 +1543,14 @@ static void subsurface_place_below(struct wl_client *c, struct wl_resource *r,
struct wl_resource *sibling) {
restack_child(wl_resource_get_user_data(r), wl_resource_get_user_data(sibling), 0);
}
static void subsurface_set_sync(struct wl_client *c, struct wl_resource *r) {}
static void subsurface_set_desync(struct wl_client *c, struct wl_resource *r) {}
static void subsurface_set_sync(struct wl_client *c, struct wl_resource *r) {
struct surface *s = wl_resource_get_user_data(r);
if (s) s->sub_desync = 0;
}
static void subsurface_set_desync(struct wl_client *c, struct wl_resource *r) {
struct surface *s = wl_resource_get_user_data(r);
if (s) { s->sub_desync = 1; pending_releases_rehold(s); }
}
static const struct wl_subsurface_interface subsurface_impl = {
.destroy = subsurface_destroy,
.set_position = subsurface_set_position,
@@ -1521,6 +1584,7 @@ static void subcompositor_get_subsurface(struct wl_client *c, struct wl_resource
s->subsurface = sub;
s->parent = p;
s->below_parent = 0;
s->sub_desync = 0;
s->sub_x = s->sub_y = 0;
wl_list_insert(p->children.prev, &s->child_link);
}
+318
View File
@@ -0,0 +1,318 @@
#define _POSIX_C_SOURCE 200809L
#include <assert.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "wayland-util.h"
void wl_list_init(struct wl_list *list) { list->prev = list->next = list; }
void wl_list_insert(struct wl_list *list, struct wl_list *elm) {
elm->prev = list;
elm->next = list->next;
list->next = elm;
elm->next->prev = elm;
}
void wl_list_remove(struct wl_list *elm) {
elm->prev->next = elm->next;
elm->next->prev = elm->prev;
elm->next = elm->prev = NULL;
}
int wl_list_empty(const struct wl_list *list) { return list->next == list; }
struct wl_listener { struct wl_list link; void (*notify)(struct wl_listener *, void *); };
struct wl_resource { struct wl_list listeners; int acquired, releases, errors; };
struct dmabuf_buffer { int unused; };
enum surface_role { ROLE_NONE, ROLE_TOPLEVEL, ROLE_SUBSURFACE };
struct surface {
struct wl_list link;
struct wl_resource *dmabuf;
struct dmabuf_buffer *dmabuf_buf;
struct wl_listener dmabuf_destroy;
int64_t next_release_ns;
int releases_pending;
enum surface_role role;
struct surface *parent;
int sub_desync;
};
#define TFD_TIMER_ABSTIME 1
static struct wl_list g_surfaces;
static struct wl_list g_pending_releases;
static int g_release_timer_fd = 3;
static int g_fps_limit;
static int64_t g_refresh_ns = 8333333;
static int g_release_unpaced;
static int64_t g_now = 1000000000LL;
static int64_t g_armed;
static struct dmabuf_buffer g_buf;
static int64_t now_ns(void) { return g_now; }
static void perf_note_release(int64_t since) { (void)since; }
static int buffer_release_blocked(struct wl_resource *b) { (void)b; return 0; }
static int ahb_swapchain_defer_release(struct dmabuf_buffer *b, struct wl_resource *r, struct surface *s, int paced) {
(void)b; (void)r; (void)s; (void)paced;
return 0;
}
static void dmabuf_buffer_unref(struct dmabuf_buffer *b) { (void)b; }
static void wl_resource_add_destroy_listener(struct wl_resource *r, struct wl_listener *l) {
wl_list_insert(r->listeners.prev, &l->link);
}
static int timerfd_settime(int fd, int flags, const struct itimerspec *its, struct itimerspec *old) {
(void)fd; (void)flags; (void)old;
g_armed = (int64_t)its->it_value.tv_sec * 1000000000LL + its->it_value.tv_nsec;
return 0;
}
static void send_buffer_release(struct wl_resource *b) {
b->releases++;
if (b->acquired) b->acquired = 0;
else b->errors++;
}
#include "release.inc"
static void present(struct wl_resource *b) { b->acquired = 1; }
static void commit(struct surface *s, struct wl_resource *b) {
if (s->dmabuf != b) {
drop_dmabuf(s, 1);
if (b) {
pending_releases_cancel(b);
s->dmabuf = b;
s->dmabuf_buf = &g_buf;
wl_resource_add_destroy_listener(b, &s->dmabuf_destroy);
}
}
pending_releases_apply(s);
}
static void timer_fires(int64_t at) {
if (g_now < at) g_now = at;
release_due_buffers();
arm_release_timer();
}
static void surface_init(struct surface *s, enum surface_role role, struct surface *parent) {
memset(s, 0, sizeof(*s));
s->role = role;
s->parent = parent;
wl_list_insert(g_surfaces.prev, &s->link);
}
static void buffer_init(struct wl_resource *b) {
memset(b, 0, sizeof(*b));
wl_list_init(&b->listeners);
}
static void check(const struct wl_resource *b, int releases) {
if (b->releases != releases || b->errors) {
fprintf(stderr, "releases %d (want %d), released while not acquired %d\n", b->releases, releases, b->errors);
exit(1);
}
}
static void moved_between_planes(void) {
struct surface root, low, high;
struct wl_resource a, b, c;
surface_init(&root, ROLE_TOPLEVEL, NULL);
surface_init(&low, ROLE_SUBSURFACE, &root);
surface_init(&high, ROLE_SUBSURFACE, &root);
buffer_init(&a); buffer_init(&b); buffer_init(&c);
present(&a); present(&b);
commit(&high, &a);
commit(&low, &b);
commit(&root, NULL);
present(&a); present(&b);
commit(&high, NULL);
timer_fires(g_now);
check(&a, 0);
commit(&low, &a);
timer_fires(g_now);
commit(&root, &b);
timer_fires(g_now + 100000000LL);
check(&a, 0);
check(&b, 0);
present(&c);
commit(&high, NULL);
commit(&low, NULL);
commit(&root, &c);
timer_fires(g_now + 100000000LL);
check(&a, 1);
check(&b, 1);
check(&c, 0);
}
static void reattached_before_release(void) {
struct surface s;
struct wl_resource a, b, c;
surface_init(&s, ROLE_TOPLEVEL, NULL);
buffer_init(&a); buffer_init(&b); buffer_init(&c);
g_fps_limit = 60;
present(&a); commit(&s, &a);
present(&b); commit(&s, &b);
present(&a); commit(&s, &a);
present(&c); commit(&s, &c);
timer_fires(g_now + 1000000000LL);
check(&a, 1);
check(&b, 1);
check(&c, 0);
}
static void desync_child_not_held(void) {
struct surface root, child;
struct wl_resource a, b;
surface_init(&root, ROLE_TOPLEVEL, NULL);
surface_init(&child, ROLE_SUBSURFACE, &root);
child.sub_desync = 1;
buffer_init(&a); buffer_init(&b);
present(&a); commit(&child, &a);
present(&b); commit(&child, &b);
timer_fires(g_now + 100000000LL);
check(&a, 1);
check(&b, 0);
}
static void toplevel_pacing_kept(void) {
struct surface s;
struct wl_resource a, b, c;
surface_init(&s, ROLE_TOPLEVEL, NULL);
buffer_init(&a); buffer_init(&b); buffer_init(&c);
g_fps_limit = 60;
const int64_t interval = 1000000000LL / 60;
present(&a); commit(&s, &a);
present(&b); commit(&s, &b);
present(&c); commit(&s, &c);
const int64_t start = g_now;
timer_fires(g_now);
check(&a, 1);
check(&b, 0);
assert(g_armed == start + interval);
timer_fires(start + interval / 2);
check(&b, 0);
timer_fires(g_armed);
check(&b, 1);
check(&c, 0);
}
static void unpaced_sync_child(void) {
struct surface root, low, high;
struct wl_resource a, b;
surface_init(&root, ROLE_TOPLEVEL, NULL);
surface_init(&low, ROLE_SUBSURFACE, &root);
surface_init(&high, ROLE_SUBSURFACE, &root);
buffer_init(&a); buffer_init(&b);
g_release_unpaced = 1;
present(&a); commit(&high, &a); commit(&root, NULL);
present(&a);
commit(&high, NULL);
check(&a, 0);
commit(&low, &a);
commit(&root, NULL);
check(&a, 0);
commit(&low, NULL);
check(&a, 0);
commit(&root, NULL);
check(&a, 1);
present(&b); commit(&root, &b);
commit(&root, NULL);
check(&b, 1);
}
static void holder_destroyed(void) {
struct surface root, child;
struct wl_resource a, b;
surface_init(&root, ROLE_TOPLEVEL, NULL);
surface_init(&child, ROLE_SUBSURFACE, &root);
buffer_init(&a); buffer_init(&b);
present(&a); commit(&child, &a); commit(&root, NULL);
present(&b); commit(&child, &b);
timer_fires(g_now + 100000000LL);
check(&a, 0);
child.parent = NULL;
wl_list_remove(&root.link);
pending_releases_forget_surface(&root);
check(&a, 1);
}
static void cycled_faster_than_releases(void) {
struct surface s;
struct wl_resource a, b, c;
struct wl_resource *order[3] = {&a, &b, &c};
surface_init(&s, ROLE_TOPLEVEL, NULL);
buffer_init(&a); buffer_init(&b); buffer_init(&c);
g_fps_limit = 60;
const int64_t interval = 1000000000LL / 60;
for (int i = 0; i < 30; i++) {
present(order[i % 3]);
commit(&s, order[i % 3]);
assert(s.releases_pending <= 2);
assert(g_armed <= g_now + 3 * interval);
}
timer_fires(g_now + 1000000000LL);
check(&a, 1);
check(&b, 1);
check(&c, 0);
}
static void desync_parent_holds_sync_grandchild(void) {
struct surface root, middle, child;
struct wl_resource a, b;
surface_init(&root, ROLE_TOPLEVEL, NULL);
surface_init(&middle, ROLE_SUBSURFACE, &root);
surface_init(&child, ROLE_SUBSURFACE, &middle);
middle.sub_desync = 1;
buffer_init(&a); buffer_init(&b);
present(&a); commit(&child, &a); commit(&middle, NULL);
present(&b); commit(&child, &b);
timer_fires(g_now + 100000000LL);
check(&a, 0);
commit(&middle, NULL);
timer_fires(g_now + 100000000LL);
check(&a, 1);
check(&b, 0);
}
static void set_desync_frees_held_release(void) {
struct surface root, outer, inner;
struct wl_resource a, b, c, d;
surface_init(&root, ROLE_TOPLEVEL, NULL);
surface_init(&outer, ROLE_SUBSURFACE, &root);
surface_init(&inner, ROLE_SUBSURFACE, &outer);
buffer_init(&a); buffer_init(&b); buffer_init(&c); buffer_init(&d);
present(&a); commit(&inner, &a); commit(&root, NULL);
present(&b); commit(&inner, &b);
present(&c); commit(&outer, &c); commit(&root, NULL);
present(&d); commit(&outer, &d);
inner.sub_desync = 1;
pending_releases_rehold(&inner);
timer_fires(g_now + 100000000LL);
check(&a, 1);
check(&c, 0);
outer.sub_desync = 1;
pending_releases_rehold(&outer);
timer_fires(g_now + 100000000LL);
check(&c, 1);
check(&b, 0);
check(&d, 0);
}
int main(int argc, char **argv) {
assert(argc == 2);
wl_list_init(&g_surfaces);
wl_list_init(&g_pending_releases);
if (!strcmp(argv[1], "moved")) moved_between_planes();
else if (!strcmp(argv[1], "reattached")) reattached_before_release();
else if (!strcmp(argv[1], "cycled")) cycled_faster_than_releases();
else if (!strcmp(argv[1], "desync")) desync_child_not_held();
else if (!strcmp(argv[1], "toplevel")) toplevel_pacing_kept();
else if (!strcmp(argv[1], "unpaced")) unpaced_sync_child();
else if (!strcmp(argv[1], "destroyed")) holder_destroyed();
else if (!strcmp(argv[1], "nested")) desync_parent_holds_sync_grandchild();
else if (!strcmp(argv[1], "set-desync")) set_desync_frees_held_release();
else return 2;
return 0;
}
+96
View File
@@ -0,0 +1,96 @@
import os
from pathlib import Path
import re
import shutil
import subprocess
import tempfile
import unittest
REPO = Path(__file__).resolve().parents[2]
SOURCE = REPO / 'app/src/main/cpp/waylandcomp/src/compositor.c'
FUNCTIONS = (
'pending_release_free', 'pending_releases_forget_surface', 'pending_releases_cancel',
'pending_releases_apply', 'sync_holder', 'pending_releases_rehold', 'on_pending_release_buffer_destroyed',
'arm_release_timer', 'release_due_buffers', 'release_buffer', 'buffer_shown_elsewhere',
'drop_dmabuf',
)
def extract_function(source, name):
match = re.search(r'^static [^\n;]*?\b' + re.escape(name) + r'\([^;{]*\) \{$', source, re.MULTILINE)
if match is None:
raise AssertionError(f'Missing compositor function: {name}')
cursor, depth = match.end(), 1
while depth:
depth += (source[cursor] == '{') - (source[cursor] == '}')
cursor += 1
return match.group(0)[:-2] + ';', source[match.start():cursor]
def function_body(source, name):
return extract_function(source, name)[1]
class SubsurfaceReleaseTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
compiler = shutil.which(os.environ.get('CC', 'cc'))
if compiler is None:
raise unittest.SkipTest('A host C compiler is required')
cls.source = SOURCE.read_text()
start = cls.source.index('struct pending_release {')
end = cls.source.index('\n};\n', start) + 4
parts = [extract_function(cls.source, name) for name in FUNCTIONS]
code = cls.source[start:end] + '\n'.join(p[0] for p in parts) + '\n' + '\n'.join(p[1] for p in parts) + '\n'
cls.temp = tempfile.TemporaryDirectory(prefix='droiddeck-subsurface-release-')
cls.addClassCleanup(cls.temp.cleanup)
folder = Path(cls.temp.name)
(folder / 'release.inc').write_text(code)
cls.binary = folder / 'release-test'
subprocess.run([compiler, '-std=c11', '-Wall', '-Werror', '-Wno-unused-function',
'-I', str(folder), '-I', str(REPO / 'app/src/main/cpp/waylandcomp/prebuilt/include'),
str(REPO / 'tools/tests/subsurface_release_harness.c'), '-o', str(cls.binary)],
check=True, capture_output=True, text=True)
def check_case(self, case):
result = subprocess.run([str(self.binary), case], capture_output=True, text=True)
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
def test_buffer_moved_to_another_plane_is_released_once_after_the_parent_commit(self):
self.check_case('moved')
def test_buffer_attached_again_before_its_paced_release_is_released_once(self):
self.check_case('reattached')
def test_buffers_cycled_faster_than_their_paced_releases_are_released_once_each(self):
self.check_case('cycled')
def test_unpaced_sync_child_waits_for_the_parent_commit(self):
self.check_case('unpaced')
def test_desynchronized_child_is_released_without_a_parent_commit(self):
self.check_case('desync')
def test_toplevel_release_pacing_is_unchanged(self):
self.check_case('toplevel')
def test_held_release_is_sent_when_the_parent_is_destroyed(self):
self.check_case('destroyed')
def test_desynchronized_parent_releases_its_synchronized_child(self):
self.check_case('nested')
def test_set_desync_releases_what_the_old_parent_held(self):
self.check_case('set-desync')
def test_compositor_attach_and_commit_use_the_release_hold(self):
self.assertIn('pending_releases_cancel(buffer);', function_body(self.source, 'take_dmabuf'))
commit = function_body(self.source, 'surface_commit')
self.assertIn('pending_releases_apply(s);', commit)
self.assertLess(commit.index('take_dmabuf(s, db, buffer);'), commit.index('pending_releases_apply(s);'))
self.assertLess(commit.index('buf_trace_attach(buffer);'), commit.index('if (s->role == ROLE_CURSOR)'))
self.assertIn('pending_releases_rehold(s);', function_body(self.source, 'subsurface_set_desync'))
if __name__ == '__main__':
unittest.main()
+4
View File
@@ -51,6 +51,10 @@ class VkDmabufQuarantineTest(unittest.TestCase):
# One surface per buffer in these scenarios: never shown elsewhere.
helpers += ['static int buffer_shown_elsewhere(struct wl_resource *b, const struct surface *e) '
'{ (void)b; (void)e; return 0; }']
if re.search(r'^static void release_due_buffers\(void\) \{', comp, re.M):
helpers += ['static void release_due_buffers(void);', 'static void arm_release_timer(void);',
function(comp, 'sync_holder')]
names.insert(names.index('on_release_timer'), 'release_due_buffers')
if re.search(r'\bvolatile int g_release_unpaced;', comp):
# Releases stay paced in these scenarios (fps limit -1 sends them at once).
helpers.insert(0, 'static int g_release_unpaced;')
+3 -3
View File
@@ -58,7 +58,7 @@ class WaylandClockDomainTest(unittest.TestCase):
#include <unistd.h>
#include "clock_domain.h"
struct pending_release { void *buffer; int64_t at_ns; struct pending_release *next; };
struct pending_release { void *buffer; int64_t at_ns; struct pending_release *next; void *held_by; };
static struct pending_release *g_pending_releases;
static int g_release_timer_fd;
#define wl_list_for_each(pr, list, link) for (pr = *(list); pr; pr = pr->next)
@@ -79,8 +79,8 @@ int main(int argc, char **argv) {
struct timespec started, ended;
clock_gettime(CLOCK_MONOTONIC, &started);
int64_t start = now_ns();
struct pending_release blocked = {(void *)1, start + 1000000LL, NULL};
struct pending_release release = {NULL, start + 60000000LL, &blocked};
struct pending_release blocked = {(void *)1, start + 1000000LL, NULL, NULL};
struct pending_release release = {NULL, start + 60000000LL, &blocked, NULL};
g_pending_releases = &release;
arm_release_timer();
int64_t next_offset = offsets[i] + 10000000000LL;
+5 -1
View File
@@ -25,7 +25,11 @@ struct dmabuf_buffer {
struct vkp_image *img;
void *ahb_state;
};
enum surface_role { ROLE_NONE, ROLE_TOPLEVEL, ROLE_SUBSURFACE };
struct surface {
enum surface_role role;
struct surface *parent;
int sub_desync;
struct wl_resource *dmabuf;
struct dmabuf_buffer *dmabuf_buf;
struct wl_listener dmabuf_destroy;
@@ -113,7 +117,7 @@ static void test_queue(int mixed, int client_gone) {
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()); }
if (mixed) { init_resource(&shm, NULL); droiddeck_release_buffer(&s, &shm, 1, now_ns()); }
pending_releases_forget_surface(&s);
g_dev_state = -3;
fire_timer();