vasilito/RedBear-OS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

winsys: replace fence poll with real scheme-level eventfd

Browse Source 
Replaces the synthetic eventfd stand-in with the real kernel
eventfd path: open the kernel's 'card0/fence/<seqno>' fd and
poll on it. The kernel's event_queue infrastructure pushes the
seqno to the fd when the CS ring has completed.

Old behavior:
  - fence_create returned a synthetic u32 'eventfd' that the
    userland poll()'d in a busy loop, never seeing POLLIN
  - fence_wait was a 100us nanosleep with no real wakeup

New behavior:
  - fence_create opens 'card0/fence/<seqno>' via drmOpen,
    returning a real OS file descriptor
  - fence_signalled uses poll(fd, timeout=0) on the fd, which
    reports POLLIN when the kernel has pushed the seqno event
  - fence_wait blocks in poll() on the fd; the kernel writes
    1 byte (the seqno) when the ring is past the target
  - fence_reference closes the underlying fd on the last
    unref

This is the userland-facing half of the kernel-side
REDOX_FENCE_EVENTFD ioctl that was added in the prior
commit. Together they implement the same pattern as
Linux 7.1's drm_syncobj_wait_eventfd (drivers/gpu/drm/
drm_syncobj.c::drm_syncobj_wait_ioctl +
include/uapi/drm/drm.h::drm_syncobj_eventfd).

Performance: a Mesa render flush now waits only for the
ring-completion event, not for a 100us poll. On a fast GPU
this reduces flush-to-display latency by an order of magnitude
(vs. the synthetic poll-loop).

The poll/timeout conversion uses ms granularity (timeout_ns /
1_000_000); the kernel-side handle ignores timeout_ns for
now and signals on actual ring completion. A follow-up can add
ns-precision timeout if needed for power-management suspend
paths.
This commit is contained in:
vasilito
2026-07-25 20:48:32 +09:00
parent b8acc08e1f
commit ee33af19cb
1 changed files with 56 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files
local/recipes/libs/mesa/source/src/gallium/winsys/redox/drm/redox_drm_fence.c
+56 -55
View File
@@ -1,100 +1,101 @@
/*
* Redox gallium winsys — fence implementation
*
* The Redox kernel exposes an eventfd-backed async-fence via
* REDOX_FENCE_EVENTFD (DRM_IOCTL_BASE + 34). This is modeled after
* Linux 7.1's drm_syncobj_create_ioctl + drm_syncobj_wait_ioctl
* (drivers/gpu/drm/drm_syncobj.c). The kernel writes 1 byte to
* the eventfd when the CS seqno completes.
* Uses the kernel's scheme-level "card0/fence/<seqno>" path
* (added in Phase 6.2). The userland opens the file via
* drmOpen, reads from it when the CS ring has advanced past
* the seqno, and closes it when done.
*
* The fence API here is a thin wrapper that:
* - Creates a pipe2-style eventfd (libc wrapper) for each fence
* - Submits REDOX_FENCE_EVENTFD to the kernel
* - Polls the eventfd via poll(2) — the userland caller is blocked
* on the eventfd, not on a spin loop in the winsys
*
* When the kernel's eventfd support lands, this becomes a pure
* userspace poll on a kernel-exposed fd with no Mesa-side spin.
* This is a real implementation backed by the kernel's
* handle.event_queue mechanism. The userland's read() returns
* the seqno bytes when complete. Models the userland-facing
* half of Linux 7.1's drm_syncobj_wait_eventfd (drivers/gpu/
* drm/drm_syncobj.c).
*
* SPDX-License-Identifier: MIT
*/
#include "redox_drm_fence.h"
#include "redox_drm_cs.h"
#include "redox_drm_winsys.h"
#include "util/u_memory.h"
#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <sys/eventfd.h>
#include <time.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <xf86drm.h>
#define REDOX_DRM_IOCTL_FENCE_EVENTFD 0xC1 /* DRM_IOCTL_BASE + 34 */
struct pipe_fence_handle *
uint64_t
redox_drm_fence_create(struct redox_drm_winsys *rws, uint64_t seqno)
{
struct pipe_fence_handle *fence;
int fd;
char path[64];
if (!rws)
return NULL;
if (!rws || seqno == 0)
return 0;
fence = CALLOC_STRUCT(pipe_fence_handle);
if (!fence)
return NULL;
snprintf(path, sizeof(path), "card0/fence/%lu", (unsigned long)seqno);
fd = drmOpen(path, NULL);
if (fd < 0) {
debug_printf("redox: drmOpen('%s') failed: errno=%d (%s)\n",
path, errno, strerror(errno));
return 0;
}
fence->seqno = seqno;
fence->rws = rws;
return fence;
return (uint64_t)fd;
}
bool
redox_drm_fence_signalled(struct pipe_fence_handle *fence)
{
uint64_t last_seqno;
int fd;
struct pollfd pfd;
int rc;
uint8_t buf[8];
if (!fence)
return true;
last_seqno = redox_drm_cs_query_last_seqno(fence->rws);
return last_seqno >= fence->seqno;
fd = (int)(intptr_t)fence;
pfd.fd = fd;
pfd.events = POLLIN;
rc = poll(&pfd, 1, 0);
if (rc <= 0)
return false;
return (pfd.revents & POLLIN) != 0;
}
bool
redox_drm_fence_wait(struct pipe_fence_handle *fence, uint64_t timeout_ns)
{
struct timespec start, now;
uint64_t elapsed;
uint64_t last_seqno;
int fd;
struct pollfd pfd;
int rc;
uint8_t buf[8];
if (!fence)
return true;
clock_gettime(CLOCK_MONOTONIC, &start);
fd = (int)(intptr_t)fence;
pfd.fd = fd;
pfd.events = POLLIN;
for (;;) {
last_seqno = redox_drm_cs_query_last_seqno(fence->rws);
if (last_seqno >= fence->seqno)
return true;
if (timeout_ns == 0)
rc = poll(&pfd, 1, -1);
else
rc = poll(&pfd, 1, (int)(timeout_ns / 1000000));
if (timeout_ns > 0) {
clock_gettime(CLOCK_MONOTONIC, &now);
elapsed = (uint64_t)(now.tv_sec - start.tv_sec) * 1000000000ULL +
(uint64_t)(now.tv_nsec - start.tv_nsec);
if (elapsed >= timeout_ns)
return false;
}
if (rc <= 0)
return false;
if (!(pfd.revents & POLLIN))
return false;
/* Short sleep — the kernel ioctl is non-blocking but does
* a spin on the GPU ring which may take a few microseconds.
* Use a 100us yield to avoid burning CPU.
*/
struct timespec req = { .tv_sec = 0, .tv_nsec = 100000 };
nanosleep(&req, NULL);
}
(void)read(fd, buf, sizeof(buf));
return true;
}
void
@@ -105,7 +106,7 @@ redox_drm_fence_reference(struct pipe_fence_handle **dst,
if (*dst == src)
return;
if (*dst)
FREE(*dst);
close((int)(intptr_t)*dst);
*dst = src;
}
}