Miroirs/libliftoff
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/emersion/libliftoff.git synced 2025-01-18 10:27:00 +01:00
Code Issues Projects Releases Packages Wiki Activity

Make liftoff_output_apply return an int

Browse source 
Callers may want to get more details about the failure, in
particular EPERM indicates that the user isn't DRM master (can
happen on VT switch).
This commit is contained in:
Simon Ser 2021-07-27 12:28:00 +02:00
parent a58b638736
commit 61fd4c099a
16 changed files with 143 additions and 138 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
README.md
View file

@ -44,7 +44,8 @@ liftoff_layer_set_property(layer, "FB_ID", fb_id);
/* Probably setup more properties and more layers */
req = drmModeAtomicAlloc();
if (!liftoff_output_apply(output, req)) {
ret = liftoff_output_apply(output, req);
if (ret < 0) {
perror("liftoff_output_apply");
exit(1);
}

107
alloc.c
View file

@ -344,15 +344,14 @@ bool check_alloc_valid(struct alloc_result *result, struct alloc_step *step)
return true;
}
bool output_choose_layers(struct liftoff_output *output,
int output_choose_layers(struct liftoff_output *output,
struct alloc_result *result, struct alloc_step *step)
{
struct liftoff_device *device;
struct liftoff_plane *plane;
struct liftoff_layer *layer;
int cursor;
int cursor, ret;
size_t remaining_planes;
bool compatible;
struct alloc_step next_step;
device = output->device;
@ -368,7 +367,7 @@ bool output_choose_layers(struct liftoff_output *output,
memcpy(result->best, step->alloc,
result->planes_len * sizeof(struct liftoff_layer *));
}
return true;
return 0;
}
plane = liftoff_container_of(step->plane_link, plane, link);
@ -379,7 +378,7 @@ bool output_choose_layers(struct liftoff_output *output,
* find a better allocation. Give up. */
/* TODO: change remaining_planes to only count those whose
* possible CRTC match and which aren't allocated */
return true;
return 0;
}
cursor = drmModeAtomicGetCursor(result->req);
@ -410,30 +409,30 @@ bool output_choose_layers(struct liftoff_output *output,
liftoff_log(LIFTOFF_DEBUG, " Layer %p -> plane %"PRIu32": "
"applying properties...",
(void *)layer, plane->id);
if (!plane_apply(plane, layer, result->req, &compatible)) {
return false;
}
if (!compatible) {
ret = plane_apply(plane, layer, result->req);
if (ret == -EINVAL) {
liftoff_log(LIFTOFF_DEBUG,
" Layer %p -> plane %"PRIu32": "
"incompatible properties",
(void *)layer, plane->id);
continue;
} else if (ret != 0) {
return ret;
}
if (!device_test_commit(device, result->req, result->flags,
&compatible)) {
return false;
}
if (compatible) {
ret = device_test_commit(device, result->req, result->flags);
if (ret == 0) {
liftoff_log(LIFTOFF_DEBUG,
" Layer %p -> plane %"PRIu32": success",
(void *)layer, plane->id);
/* Continue with the next plane */
plane_step_init_next(&next_step, step, layer);
if (!output_choose_layers(output, result, &next_step)) {
return false;
ret = output_choose_layers(output, result, &next_step);
if (ret != 0) {
return ret;
}
} else if (ret != -EINVAL && ret != -ERANGE) {
return ret;
}
drmModeAtomicSetCursor(result->req, cursor);
@ -442,32 +441,32 @@ bool output_choose_layers(struct liftoff_output *output,
skip:
/* Try not to use the current plane */
plane_step_init_next(&next_step, step, NULL);
if (!output_choose_layers(output, result, &next_step)) {
return false;
ret = output_choose_layers(output, result, &next_step);
if (ret != 0) {
return ret;
}
drmModeAtomicSetCursor(result->req, cursor);
return true;
return 0;
}
static bool apply_current(struct liftoff_device *device,
drmModeAtomicReq *req)
static int apply_current(struct liftoff_device *device, drmModeAtomicReq *req)
{
struct liftoff_plane *plane;
int cursor;
bool compatible;
int cursor, ret;
cursor = drmModeAtomicGetCursor(req);
liftoff_list_for_each(plane, &device->planes, link) {
if (!plane_apply(plane, plane->layer, req, &compatible)) {
ret = plane_apply(plane, plane->layer, req);
assert(ret != -EINVAL);
if (ret != 0) {
drmModeAtomicSetCursor(req, cursor);
return false;
return ret;
}
assert(compatible);
}
return true;
return 0;
}
static bool layer_needs_realloc(struct liftoff_layer *layer)
@ -525,37 +524,37 @@ static bool layer_needs_realloc(struct liftoff_layer *layer)
return false;
}
static bool reuse_previous_alloc(struct liftoff_output *output,
static int reuse_previous_alloc(struct liftoff_output *output,
drmModeAtomicReq *req, uint32_t flags)
{
struct liftoff_device *device;
struct liftoff_layer *layer;
int cursor;
bool compatible;
int cursor, ret;
device = output->device;
if (output->layers_changed) {
return false;
return -EINVAL;
}
liftoff_list_for_each(layer, &output->layers, link) {
if (layer_needs_realloc(layer)) {
return false;
return -EINVAL;
}
}
cursor = drmModeAtomicGetCursor(req);
if (!apply_current(device, req)) {
return false;
}
if (!device_test_commit(device, req, flags, &compatible) || !compatible) {
drmModeAtomicSetCursor(req, cursor);
return false;
ret = apply_current(device, req);
if (ret != 0) {
return ret;
}
return true;
ret = device_test_commit(device, req, flags);
if (ret != 0) {
drmModeAtomicSetCursor(req, cursor);
}
return ret;
}
static void mark_layers_clean(struct liftoff_output *output)
@ -628,7 +627,7 @@ static size_t non_composition_layers_length(struct liftoff_output *output)
return n;
}
bool liftoff_output_apply(struct liftoff_output *output, drmModeAtomicReq *req,
int liftoff_output_apply(struct liftoff_output *output, drmModeAtomicReq *req,
uint32_t flags)
{
struct liftoff_device *device;
@ -637,15 +636,16 @@ bool liftoff_output_apply(struct liftoff_output *output, drmModeAtomicReq *req,
struct alloc_result result;
struct alloc_step step;
size_t i;
bool compatible;
int ret;
device = output->device;
update_layers_priority(device);
if (reuse_previous_alloc(output, req, flags)) {
ret = reuse_previous_alloc(output, req, flags);
if (ret == 0) {
log_reuse(output);
return true;
return 0;
}
log_no_reuse(output);
@ -665,10 +665,11 @@ bool liftoff_output_apply(struct liftoff_output *output, drmModeAtomicReq *req,
if (plane->layer == NULL) {
liftoff_log(LIFTOFF_DEBUG,
"Disabling plane %"PRIu32, plane->id);
if (!plane_apply(plane, NULL, req, &compatible)) {
return false;
ret = plane_apply(plane, NULL, req);
assert(ret != -EINVAL);
if (ret != 0) {
return ret;
}
assert(compatible);
}
}
@ -680,7 +681,7 @@ bool liftoff_output_apply(struct liftoff_output *output, drmModeAtomicReq *req,
result.best = malloc(result.planes_len * sizeof(*result.best));
if (step.alloc == NULL || result.best == NULL) {
liftoff_log_errno(LIFTOFF_ERROR, "malloc");
return false;
return -ENOMEM;
}
/* For each plane, try to find a layer. Don't do it the other
@ -698,8 +699,9 @@ bool liftoff_output_apply(struct liftoff_output *output, drmModeAtomicReq *req,
step.score = 0;
step.last_layer_zpos = INT_MAX;
step.composited = false;
if (!output_choose_layers(output, &result, &step)) {
return false;
ret = output_choose_layers(output, &result, &step);
if (ret != 0) {
return ret;
}
liftoff_log(LIFTOFF_DEBUG,
@ -724,8 +726,9 @@ bool liftoff_output_apply(struct liftoff_output *output, drmModeAtomicReq *req,
layer->plane = plane;
}
if (!apply_current(device, req)) {
return false;
ret = apply_current(device, req);
if (ret != 0) {
return ret;
}
free(step.alloc);
@ -733,5 +736,5 @@ bool liftoff_output_apply(struct liftoff_output *output, drmModeAtomicReq *req,
mark_layers_clean(output);
return true;
return 0;
}

20
device.c
View file

@ -86,8 +86,8 @@ bool liftoff_device_register_all_planes(struct liftoff_device *device)
return true;
}
bool device_test_commit(struct liftoff_device *device,
drmModeAtomicReq *req, uint32_t flags, bool *compatible)
int device_test_commit(struct liftoff_device *device,
drmModeAtomicReq *req, uint32_t flags)
{
int ret;
@ -96,16 +96,12 @@ bool device_test_commit(struct liftoff_device *device,
ret = drmModeAtomicCommit(device->drm_fd, req,
DRM_MODE_ATOMIC_TEST_ONLY | flags,
NULL);
} while (-ret == EINTR || -ret == EAGAIN);
if (ret == 0) {
*compatible = true;
} else if (-ret == EINVAL || -ret == ERANGE) {
*compatible = false;
} else {
liftoff_log_errno(LIFTOFF_ERROR, "drmModeAtomicCommit");
*compatible = false;
return false;
} while (ret == -EINTR || ret == -EAGAIN);
if (ret != 0 && ret != -EINVAL && ret != -ERANGE) {
liftoff_log(LIFTOFF_ERROR, "drmModeAtomicCommit: %s",
strerror(-ret));
}
return true;
return ret;
}

3
example/compositor.c
View file

@ -194,7 +194,8 @@ int main(int argc, char *argv[])
flags = DRM_MODE_ATOMIC_NONBLOCK;
req = drmModeAtomicAlloc();
if (!liftoff_output_apply(output, req, flags)) {
ret = liftoff_output_apply(output, req, flags);
if (ret != 0) {
perror("liftoff_output_apply");
return 1;
}

3
example/dynamic.c
View file

@ -111,7 +111,8 @@ static bool draw(void)
flags = DRM_MODE_ATOMIC_NONBLOCK | DRM_MODE_PAGE_FLIP_EVENT;
req = drmModeAtomicAlloc();
if (!liftoff_output_apply(output, req, flags)) {
ret = liftoff_output_apply(output, req, flags);
if (ret != 0) {
perror("liftoff_output_apply");
return false;
}

3
example/multi-output.c
View file

@ -156,7 +156,8 @@ int main(int argc, char *argv[])
flags = DRM_MODE_ATOMIC_NONBLOCK;
req = drmModeAtomicAlloc();
for (i = 0; i < outputs_len; i++) {
if (!liftoff_output_apply(outputs[i], req, flags)) {
ret = liftoff_output_apply(outputs[i], req, flags);
if (ret != 0) {
perror("liftoff_output_apply");
return 1;
}

3
example/simple.c
View file

@ -129,7 +129,8 @@ int main(int argc, char *argv[])
flags = DRM_MODE_ATOMIC_NONBLOCK;
req = drmModeAtomicAlloc();
if (!liftoff_output_apply(output, req, flags)) {
ret = liftoff_output_apply(output, req, flags);
if (ret != 0) {
perror("liftoff_output_apply");
return 1;
}

4
include/libliftoff.h
View file

@ -59,8 +59,10 @@ uint32_t liftoff_plane_get_id(struct liftoff_plane *plane);
* plane mapping with `liftoff_layer_get_plane`.
*
* `flags` is the atomic commit flags the caller intends to use.
*
* Zero is returned on success, negative errno on error.
*/
bool liftoff_output_apply(struct liftoff_output *output, drmModeAtomicReq *req,
int liftoff_output_apply(struct liftoff_output *output, drmModeAtomicReq *req,
uint32_t flags);
/**

2
include/log.h
View file

@ -1,6 +1,8 @@
#ifndef LOG_H
#define LOG_H
#include <stdbool.h>
#include <libliftoff.h>
#ifdef __GNUC__

8
include/private.h
View file

@ -81,8 +81,8 @@ struct liftoff_rect {
int width, height;
};
bool device_test_commit(struct liftoff_device *device,
drmModeAtomicReq *req, uint32_t flags, bool *compatible);
int device_test_commit(struct liftoff_device *device,
drmModeAtomicReq *req, uint32_t flags);
struct liftoff_layer_property *layer_get_property(struct liftoff_layer *layer,
const char *name);
@ -95,8 +95,8 @@ bool layer_is_visible(struct liftoff_layer *layer);
struct liftoff_plane_property *plane_get_property(struct liftoff_plane *plane,
const char *name);
bool plane_apply(struct liftoff_plane *plane, struct liftoff_layer *layer,
drmModeAtomicReq *req, bool *compatible);
int plane_apply(struct liftoff_plane *plane, struct liftoff_layer *layer,
drmModeAtomicReq *req);
void output_log_layers(struct liftoff_output *output);

43
plane.c
View file

@ -1,3 +1,4 @@
#include <errno.h>
#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
@ -165,21 +166,22 @@ struct liftoff_plane_property *plane_get_property(struct liftoff_plane *plane,
return NULL;
}
static bool plane_set_prop(struct liftoff_plane *plane, drmModeAtomicReq *req,
static int plane_set_prop(struct liftoff_plane *plane, drmModeAtomicReq *req,
struct liftoff_plane_property *prop, uint64_t value)
{
int ret;
ret = drmModeAtomicAddProperty(req, plane->id, prop->id, value);
if (ret < 0) {
liftoff_log_errno(LIFTOFF_ERROR, "drmModeAtomicAddProperty");
return false;
liftoff_log(LIFTOFF_ERROR, "drmModeAtomicAddProperty: %s",
strerror(-ret));
return ret;
}
return true;
return 0;
}
static bool set_plane_prop_str(struct liftoff_plane *plane,
static int set_plane_prop_str(struct liftoff_plane *plane,
drmModeAtomicReq *req, const char *name,
uint64_t value)
{
@ -190,30 +192,33 @@ static bool set_plane_prop_str(struct liftoff_plane *plane,
liftoff_log(LIFTOFF_DEBUG,
"plane %"PRIu32" is missing the %s property",
plane->id, name);
return false;
return -EINVAL;
}
return plane_set_prop(plane, req, prop, value);
}
bool plane_apply(struct liftoff_plane *plane, struct liftoff_layer *layer,
drmModeAtomicReq *req, bool *compatible)
int plane_apply(struct liftoff_plane *plane, struct liftoff_layer *layer,
drmModeAtomicReq *req)
{
int cursor;
int cursor, ret;
size_t i;
struct liftoff_layer_property *layer_prop;
struct liftoff_plane_property *plane_prop;
*compatible = true;
cursor = drmModeAtomicGetCursor(req);
if (layer == NULL) {
return set_plane_prop_str(plane, req, "FB_ID", 0) &&
set_plane_prop_str(plane, req, "CRTC_ID", 0);
ret = set_plane_prop_str(plane, req, "FB_ID", 0);
if (ret != 0) {
return ret;
}
return set_plane_prop_str(plane, req, "CRTC_ID", 0);
}
if (!set_plane_prop_str(plane, req, "CRTC_ID", layer->output->crtc_id)) {
return false;
ret = set_plane_prop_str(plane, req, "CRTC_ID", layer->output->crtc_id);
if (ret != 0) {
return ret;
}
for (i = 0; i < layer->props_len; i++) {
@ -234,16 +239,16 @@ bool plane_apply(struct liftoff_plane *plane, struct liftoff_layer *layer,
layer_prop->value == DRM_MODE_ROTATE_0) {
continue; /* Layer isn't rotated */
}
*compatible = false;
drmModeAtomicSetCursor(req, cursor);
return true;
return -EINVAL;
}
if (!plane_set_prop(plane, req, plane_prop, layer_prop->value)) {
ret = plane_set_prop(plane, req, plane_prop, layer_prop->value);
if (ret != 0) {
drmModeAtomicSetCursor(req, cursor);
return false;
return ret;
}
}
return true;
return 0;
}

6
test/bench.c
View file

@ -45,7 +45,7 @@ int main(int argc, char *argv[])
struct liftoff_output *output;
struct liftoff_layer *layers[MAX_LAYERS];
drmModeAtomicReq *req;
bool ok;
int ret;
planes_len = 5;
layers_len = 10;
@ -101,8 +101,8 @@ int main(int argc, char *argv[])
clock_gettime(CLOCK_MONOTONIC, &start);
req = drmModeAtomicAlloc();
ok = liftoff_output_apply(output, req, 0);
assert(ok);
ret = liftoff_output_apply(output, req, 0);
assert(ret == 0);
drmModeAtomicFree(req);
clock_gettime(CLOCK_MONOTONIC, &end);

20
test/test_alloc.c
View file

@ -656,12 +656,13 @@ static void run_test(struct test_layer *test_layers)
}
req = drmModeAtomicAlloc();
ok = liftoff_output_apply(output, req, 0);
assert(ok);
ret = liftoff_output_apply(output, req, 0);
assert(ret == 0);
ret = drmModeAtomicCommit(drm_fd, req, 0, NULL);
assert(ret == 0);
drmModeAtomicFree(req);
ok = true;
for (i = 0; test_layers[i].width > 0; i++) {
plane = liftoff_layer_get_plane(layers[i]);
mock_plane = NULL;
@ -707,7 +708,6 @@ static void test_basic(void)
struct liftoff_output *output;
struct liftoff_layer *layer;
drmModeAtomicReq *req;
bool ok;
int ret;
mock_plane = liftoff_mock_drm_create_plane(DRM_PLANE_TYPE_PRIMARY);
@ -724,8 +724,8 @@ static void test_basic(void)
liftoff_mock_plane_add_compatible_layer(mock_plane, layer);
req = drmModeAtomicAlloc();
ok = liftoff_output_apply(output, req, 0);
assert(ok);
ret = liftoff_output_apply(output, req, 0);
assert(ret == 0);
ret = drmModeAtomicCommit(drm_fd, req, 0, NULL);
assert(ret == 0);
assert(liftoff_mock_plane_get_layer(mock_plane) == layer);
@ -745,7 +745,6 @@ static void test_no_fb_fail(bool zero_fb_id)
struct liftoff_output *output;
struct liftoff_layer *layer;
drmModeAtomicReq *req;
bool ok;
int ret;
mock_plane = liftoff_mock_drm_create_plane(DRM_PLANE_TYPE_PRIMARY);
@ -765,8 +764,8 @@ static void test_no_fb_fail(bool zero_fb_id)
liftoff_mock_plane_add_compatible_layer(mock_plane, layer);
req = drmModeAtomicAlloc();
ok = liftoff_output_apply(output, req, 0);
assert(ok);
ret = liftoff_output_apply(output, req, 0);
assert(ret == 0);
ret = drmModeAtomicCommit(drm_fd, req, 0, NULL);
assert(ret == 0);
assert(liftoff_mock_plane_get_layer(mock_plane) == NULL);
@ -787,7 +786,6 @@ static void test_composition_zero_fb(void)
struct liftoff_layer *composition_layer, *layer_with_fb,
*layer_without_fb;
drmModeAtomicReq *req;
bool ok;
int ret;
mock_plane = liftoff_mock_drm_create_plane(DRM_PLANE_TYPE_PRIMARY);
@ -811,8 +809,8 @@ static void test_composition_zero_fb(void)
liftoff_mock_plane_add_compatible_layer(mock_plane, layer_with_fb);
req = drmModeAtomicAlloc();
ok = liftoff_output_apply(output, req, 0);
assert(ok);
ret = liftoff_output_apply(output, req, 0);
assert(ret == 0);
ret = drmModeAtomicCommit(drm_fd, req, 0, NULL);
assert(ret == 0);
assert(liftoff_mock_plane_get_layer(mock_plane) == layer_with_fb);

10
test/test_dynamic.c
View file

@ -41,14 +41,13 @@ static struct liftoff_layer *add_layer(struct liftoff_output *output,
static void first_commit(struct context *ctx) {
drmModeAtomicReq *req;
bool ok;
int ret;
assert(ctx->commit_count == 0);
req = drmModeAtomicAlloc();
ok = liftoff_output_apply(ctx->output, req, 0);
assert(ok);
ret = liftoff_output_apply(ctx->output, req, 0);
assert(ret == 0);
ret = drmModeAtomicCommit(ctx->drm_fd, req, 0, NULL);
assert(ret == 0);
drmModeAtomicFree(req);
@ -64,12 +63,11 @@ static void first_commit(struct context *ctx) {
static void second_commit(struct context *ctx, bool want_reuse_prev_alloc) {
drmModeAtomicReq *req;
bool ok;
int ret;
req = drmModeAtomicAlloc();
ok = liftoff_output_apply(ctx->output, req, 0);
assert(ok);
ret = liftoff_output_apply(ctx->output, req, 0);
assert(ret == 0);
if (want_reuse_prev_alloc) {
/* The library should perform only one TEST_ONLY commit with the
* previous plane allocation. */

5
test/test_priority.c
View file

@ -37,7 +37,6 @@ int main(int argc, char *argv[]) {
struct liftoff_layer *layers[2], *layer;
uint32_t fbs[2];
drmModeAtomicReq *req;
bool ok;
int ret;
liftoff_log_set_priority(LIFTOFF_SILENT);
@ -75,8 +74,8 @@ int main(int argc, char *argv[]) {
liftoff_layer_set_property(layer, "FB_ID", fbs[j % 2]);
ok = liftoff_output_apply(output, req, 0);
assert(ok);
ret = liftoff_output_apply(output, req, 0);
assert(ret == 0);
ret = drmModeAtomicCommit(drm_fd, req, 0, NULL);
assert(ret == 0);
}

27
test/test_prop.c
View file

@ -35,7 +35,6 @@ static int test_prop_default(const char *prop_name)
struct liftoff_output *output;
struct liftoff_layer *layer;
drmModeAtomicReq *req;
bool ok;
int ret;
mock_plane_without_prop = liftoff_mock_drm_create_plane(DRM_PLANE_TYPE_OVERLAY);
@ -80,8 +79,8 @@ static int test_prop_default(const char *prop_name)
liftoff_layer_set_property(layer, prop.name, require_prop_value);
ok = liftoff_output_apply(output, req, 0);
assert(ok);
ret = liftoff_output_apply(output, req, 0);
assert(ret == 0);
ret = drmModeAtomicCommit(drm_fd, req, 0, NULL);
assert(ret == 0);
assert(liftoff_layer_get_plane(layer) == NULL);
@ -94,8 +93,8 @@ static int test_prop_default(const char *prop_name)
liftoff_layer_set_property(layer, prop.name, default_value);
ok = liftoff_output_apply(output, req, 0);
assert(ok);
ret = liftoff_output_apply(output, req, 0);
assert(ret == 0);
ret = drmModeAtomicCommit(drm_fd, req, 0, NULL);
assert(ret == 0);
assert(liftoff_layer_get_plane(layer) != NULL);
@ -110,8 +109,8 @@ static int test_prop_default(const char *prop_name)
liftoff_layer_set_property(layer, prop.name, require_prop_value);
ok = liftoff_output_apply(output, req, 0);
assert(ok);
ret = liftoff_output_apply(output, req, 0);
assert(ret == 0);
ret = drmModeAtomicCommit(drm_fd, req, 0, NULL);
assert(ret == 0);
assert(liftoff_layer_get_plane(layer) != NULL);
@ -133,7 +132,6 @@ static int test_ignore_alpha(void)
struct liftoff_output *output;
struct liftoff_layer *layer;
drmModeAtomicReq *req;
bool ok;
int ret;
mock_plane = liftoff_mock_drm_create_plane(DRM_PLANE_TYPE_PRIMARY);
@ -154,8 +152,8 @@ static int test_ignore_alpha(void)
liftoff_mock_plane_add_compatible_layer(mock_plane, layer);
req = drmModeAtomicAlloc();
ok = liftoff_output_apply(output, req, 0);
assert(ok);
ret = liftoff_output_apply(output, req, 0);
assert(ret == 0);
ret = drmModeAtomicCommit(drm_fd, req, 0, NULL);
assert(ret == 0);
assert(liftoff_mock_plane_get_layer(mock_plane) == NULL);
@ -176,7 +174,6 @@ static int test_immutable_zpos(void) {
struct liftoff_output *output;
struct liftoff_layer *layer1, *layer2;
drmModeAtomicReq *req;
bool ok;
int ret;
mock_plane1 = liftoff_mock_drm_create_plane(DRM_PLANE_TYPE_OVERLAY);
@ -214,8 +211,8 @@ static int test_immutable_zpos(void) {
liftoff_layer_set_property(layer2, "zpos", 43);
req = drmModeAtomicAlloc();
ok = liftoff_output_apply(output, req, 0);
assert(ok);
ret = liftoff_output_apply(output, req, 0);
assert(ret == 0);
ret = drmModeAtomicCommit(drm_fd, req, 0, NULL);
assert(ret == 0);
assert(liftoff_mock_plane_get_layer(mock_plane1) == layer1);
@ -227,8 +224,8 @@ static int test_immutable_zpos(void) {
liftoff_layer_set_property(layer2, "zpos", 42);
req = drmModeAtomicAlloc();
ok = liftoff_output_apply(output, req, 0);
assert(ok);
ret = liftoff_output_apply(output, req, 0);
assert(ret == 0);
ret = drmModeAtomicCommit(drm_fd, req, 0, NULL);
assert(ret == 0);
assert(liftoff_mock_plane_get_layer(mock_plane1) == layer2);