wlcontext: use poll with wake pipe instead of read deadlines

core/internal/server/clipboard/manager.go

@@ -500,14 +500,13 @@ func (m *Manager) receiveData(offer *ext_data_control.ExtDataControlOfferV1, mim
 	receiveErr := make(chan error, 1)
 	m.post(func() {
 		err := offer.Receive(mimeType, int(w.Fd()))
+		w.Close()
 		receiveErr <- err
 	})
 
 	if err := <-receiveErr; err != nil {
-		w.Close()
 		return nil, err
 	}
-	w.Close()
 
 	type result struct {
 		data []byte

core/internal/server/wlcontext/context.go

@@ -1,11 +1,11 @@
 package wlcontext
 
 import (
-	"errors"
 	"fmt"
 	"os"
 	"sync"
-	"time"
+
+	"golang.org/x/sys/unix"
 
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/errdefs"
 	"github.com/AvengeMedia/DankMaterialShell/core/internal/log"
@@ -27,6 +27,8 @@ type SharedContext struct {
 	stopChan   chan struct{}
 	fatalError chan error
 	cmdQueue   chan func()
+	wakeR      int
+	wakeW      int
 	wg         sync.WaitGroup
 	mu         sync.Mutex
 	started    bool
@@ -38,11 +40,31 @@ func New() (*SharedContext, error) {
 		return nil, fmt.Errorf("%w: %v", errdefs.ErrNoWaylandDisplay, err)
 	}
 
+	fds := make([]int, 2)
+	if err := unix.Pipe(fds); err != nil {
+		display.Context().Close()
+		return nil, fmt.Errorf("failed to create wake pipe: %w", err)
+	}
+	if err := unix.SetNonblock(fds[0], true); err != nil {
+		unix.Close(fds[0])
+		unix.Close(fds[1])
+		display.Context().Close()
+		return nil, fmt.Errorf("failed to set wake pipe nonblock: %w", err)
+	}
+	if err := unix.SetNonblock(fds[1], true); err != nil {
+		unix.Close(fds[0])
+		unix.Close(fds[1])
+		display.Context().Close()
+		return nil, fmt.Errorf("failed to set wake pipe nonblock: %w", err)
+	}
+
 	sc := &SharedContext{
 		display:    display,
 		stopChan:   make(chan struct{}),
 		fatalError: make(chan error, 1),
 		cmdQueue:   make(chan func(), 256),
+		wakeR:      fds[0],
+		wakeW:      fds[1],
 		started:    false,
 	}
 
@@ -69,6 +91,9 @@ func (sc *SharedContext) Display() *wlclient.Display {
 func (sc *SharedContext) Post(fn func()) {
 	select {
 	case sc.cmdQueue <- fn:
+		if _, err := unix.Write(sc.wakeW, []byte{1}); err != nil && err != unix.EAGAIN {
+			log.Errorf("wake pipe write error: %v", err)
+		}
 	default:
 	}
 }
@@ -89,7 +114,14 @@ func (sc *SharedContext) eventDispatcher() {
 			}
 		}
 	}()
+
 	ctx := sc.display.Context()
+	wlFd := ctx.Fd()
+
+	pollFds := []unix.PollFd{
+		{Fd: int32(wlFd), Events: unix.POLLIN},
+		{Fd: int32(sc.wakeR), Events: unix.POLLIN},
+	}
 
 	for {
 		select {
@@ -100,20 +132,33 @@ func (sc *SharedContext) eventDispatcher() {
 
 		sc.drainCmdQueue()
 
-		if err := ctx.SetReadDeadline(time.Now().Add(50 * time.Millisecond)); err != nil {
+		n, err := unix.Poll(pollFds, 50)
-			log.Errorf("Failed to set read deadline: %v", err)
+		if err != nil {
-		}
+			if err == unix.EINTR {
-		err := ctx.Dispatch()
+				continue
-		if err := ctx.SetReadDeadline(time.Time{}); err != nil {
+			}
-			log.Errorf("Failed to clear read deadline: %v", err)
+			log.Errorf("Poll error: %v", err)
+			return
 		}
 
-		switch {
+		if n == 0 {
-		case err == nil:
+			continue
-		case errors.Is(err, os.ErrDeadlineExceeded):
+		}
-		default:
+
-			log.Errorf("Wayland connection error: %v", err)
+		if pollFds[1].Revents&unix.POLLIN != 0 {
-			return
+			var buf [64]byte
+			if _, err := unix.Read(sc.wakeR, buf[:]); err != nil && err != unix.EAGAIN {
+				log.Errorf("wake pipe read error: %v", err)
+			}
+		}
+
+		if pollFds[0].Revents&unix.POLLIN != 0 {
+			if err := ctx.Dispatch(); err != nil {
+				if !os.IsTimeout(err) {
+					log.Errorf("Wayland connection error: %v", err)
+					return
+				}
+			}
 		}
 	}
 }
@@ -133,6 +178,9 @@ func (sc *SharedContext) Close() {
 	close(sc.stopChan)
 	sc.wg.Wait()
 
+	unix.Close(sc.wakeR)
+	unix.Close(sc.wakeW)
+
 	if sc.display != nil {
 		sc.display.Context().Close()
 	}

core/pkg/go-wayland/wayland/client/context.go

@@ -58,6 +58,18 @@ func (ctx *Context) SetReadDeadline(t time.Time) error {
 	return ctx.conn.SetReadDeadline(t)
 }
 
+func (ctx *Context) Fd() int {
+	rawConn, err := ctx.conn.SyscallConn()
+	if err != nil {
+		return -1
+	}
+	var fd int
+	rawConn.Control(func(f uintptr) {
+		fd = int(f)
+	})
+	return fd
+}
+
 // Dispatch reads and processes incoming messages and calls [client.Dispatcher.Dispatch] on the
 // respective wayland protocol.
 // Dispatch must be called on the same goroutine as other interactions with the Context.

distro/scripts/ppa-status.sh

@@ -215,4 +215,3 @@ done
 echo "=========================================="
 echo "Status check complete!"
 echo ""
-