detached 223beec

#133 fix: resolve v0.15.0 release review findings

state
merged · 223beec · fast-forward
branch
fix/v0.15-review → main
opened
bnema ·
updated

Fixes from the v0.15.0 release review (v0.14.0..67bf3fe1). Four reviewers found 18 issues; all are resolved here, then the fixes were re-reviewed by two more reviewers.

Packaging and logs

  • neferwl-session: keep the graphical session, environment and portals when neferwl-server takes over (also while its start job is still queued).
  • Session logs: a root lifecycle lock serializes session creation and pruning; a live session directory is never removed.

Rendering, capture, screencast

  • Capture DMA-BUF: when sync-file export fails, finish the GPU copy before returning the buffer (fence wait, then queue/device idle fallback; otherwise keep the copy and report device loss).
  • Screencast allocates on the current render device after recovery; releases go to the creating device.
  • DRM supervisor publishes the render device atomically for cross-goroutine readers.
  • Headless continuous capture: probe directory write access before acknowledging; a later write error stops the recording, not the compositor; a start on an already-recording output is refused (bad-request).
  • Built-in HEADLESS-N outputs are paced at their advertised 60 Hz.
  • Raw HDR capture follows the confirmed live HDR state; virtual renderers always allow readback (no cost until used).

Core, config, Wayland

  • Removing the focused output moves its workspaces to a reachable output, not an isolated one.
  • output..keep-focus survives a later output. declaration.
  • Each queued commit reports the configure acknowledged when it was submitted.

Control socket and CLI

  • Injection translation is transactional: core acknowledges admission before executing events (ports.ControlAdmission); XKB state is committed only on admission and rolled back on refusal or cancellation.
  • do quit (and an injected quit bind) returns its committed reply and exits 0.
  • state honours an explicit NEFERWL_CONTROL target instead of falling back to another session.
  • session new: SIGINT/SIGTERM during startup kills and reaps the detached child.
  • Synthetic input devices use reserved ID ranges (virtual pointer 1<<62, control 1<<63) and no longer collide with libinput.
  • Skill recipes spawn their client inside the mapping wait.

Checks on 92e19fc

  • make check, make race, make mocks-check, staticcheck ./... pass.
  • Headless end-to-end on the branch binary: spawn + keybind recipe, /proc capture refused with session alive, duplicate recording refused, output add/rm, explicit control target error, do quit exit 0. Busy-refused Super then q (no quit) verified on the control branch.

Not verified

  • Live systemd handover, real GPU device loss, rare Vulkan wait failures (mock-tested only), Xwayland and wayvnc e2e.
  • Lint backlog tracked in #132.
CommitSubjectAuthorDateSignatureStatus
223beecdocs: trim capture, control device and server handover notesbrice GPG Verified
92e19fcfix(vulkan): fall back to idle sync after capture fence wait failsbrice GPG Verified
e2bb8a2test(cli): cover session new signal handling through the production pathbrice GPG Verified
e3ce792Merge branch 'fix/v0.15-control-cli' into fix/v0.15-reviewbrice GPG Verified
3eb770cfix(control): commit input translation only on core admissionbrice GPG Verified
c2057e4feat(control): acknowledge injection admission before executionbrice GPG Verified
bc910b3feat(xkb): support transactional input translationbrice GPG Verified
76f3e62docs(skill): spawn clients within recipe mapping waitsbrice GPG Verified
29bc182fix(input): reserve disjoint synthetic device namespacesbrice GPG Verified
c1119b5fix(cli): cancel detached session startup on signalsbrice GPG Verified
91c00c4fix(cli): honor explicit control target for state queriesbrice GPG Verified
761c504fix(control): flush committed quit replies before shutdownbrice GPG Verified
14d6a18Merge branch 'fix/v0.15-headless-capture' into fix/v0.15-reviewbrice GPG Verified
bf33629fix(headless): capture raw HDR from confirmed live statebrice GPG Verified
1a53fb2Merge branch 'fix/v0.15-vulkan-cast' into fix/v0.15-reviewbrice GPG Verified
33b706afix(headless): pace built-in outputs at advertised refreshbrice GPG Verified
3568546fix(headless): preserve active recordings on failed startsbrice GPG Verified
d415a14fix(headless): isolate continuous capture write failuresbrice GPG Verified
c68f814fix(drm): publish render device atomically during recoverybrice GPG Verified
be72c5dMerge branch 'fix/v0.15-core-wayland' into fix/v0.15-reviewbrice GPG Verified
1dce854fix(wayland): capture configure acknowledgement per queued commitbrice GPG Verified
aa2fef1Merge branch 'fix/v0.15-vulkan-cast' into fix/v0.15-reviewbrice GPG Verified
f3b3a37fix(screencast): allocate cast buffers on current render devicebrice GPG Verified
13d31a1Merge branch 'fix/v0.15-pkg-logging' into fix/v0.15-reviewbrice GPG Verified
493e4e2fix(logging): serialize session log creation and pruningbrice GPG Verified
0c6fec6fix(packaging): preserve the incoming server session on handoverbrice GPG Verified
cfa8c68fix(config): preserve output keep-focus before declarationbrice GPG Verified
5c48867fix(vulkan): finish capture writes when sync file export failsbrice GPG Verified
bd075edfix(core): prefer reachable output after focused output removalbrice GPG Verified

Checks 2

49 files · +1738 -107
2/2
M .mockery.yml +5 -0
@@ -76,6 +76,11 @@ packages:
7676 filename: seat_control_mock_test.go
7777 github.com/bnema/neferwl/internal/adapters/vulkan:
7878 interfaces:
79+ copyCompletion:
80+ config:
81+ dir: internal/adapters/vulkan
82+ pkgname: vulkan
83+ filename: copy_completion_mock_test.go
7984 captureSync:
8085 config:
8186 dir: internal/adapters/vulkan
@@ -76,6 +76,11 @@ packages:
76 filename: seat_control_mock_test.go76 filename: seat_control_mock_test.go
77 github.com/bnema/neferwl/internal/adapters/vulkan:77 github.com/bnema/neferwl/internal/adapters/vulkan:
78 interfaces:78 interfaces:
79+ copyCompletion:
80+ config:
81+ dir: internal/adapters/vulkan
82+ pkgname: vulkan
83+ filename: copy_completion_mock_test.go
79 captureSync:84 captureSync:
80 config:85 config:
81 dir: internal/adapters/vulkan86 dir: internal/adapters/vulkan
M docs/control.md +4 -1
@@ -152,7 +152,10 @@ Continuous capture writes `frame-NNNNNN.png` per presented frame, `latest.png`
152152 (a hard link to the newest frame) and `frames.ffconcat` with the frame timing.
153153 `--dir DIR` selects another directory and `--output NAME` limits capture to
154154 that output. With several outputs, each gets a subdirectory named after it.
155-The directory grows until `shot --stop`.
155+The directory grows until `shot --stop`. Starting on an output that is already
156+recording returns `bad-request`, and an unwritable directory returns
157+`capture-failed`. If a write fails later, that output stops recording and the
158+compositor logs a warning.
156159
157160 On an HDR output, `--every-frame --raw` also writes `latest-pq.png`, the newest
158161 frame in raw PQ.
@@ -152,7 +152,10 @@ Continuous capture writes `frame-NNNNNN.png` per presented frame, `latest.png`
152 (a hard link to the newest frame) and `frames.ffconcat` with the frame timing.152 (a hard link to the newest frame) and `frames.ffconcat` with the frame timing.
153 `--dir DIR` selects another directory and `--output NAME` limits capture to153 `--dir DIR` selects another directory and `--output NAME` limits capture to
154 that output. With several outputs, each gets a subdirectory named after it.154 that output. With several outputs, each gets a subdirectory named after it.
155-The directory grows until `shot --stop`.155+The directory grows until `shot --stop`. Starting on an output that is already
156+recording returns `bad-request`, and an unwritable directory returns
157+`capture-failed`. If a write fails later, that output stops recording and the
158+compositor logs a warning.
156 159
157 On an HDR output, `--every-frame --raw` also writes `latest-pq.png`, the newest160 On an HDR output, `--every-frame --raw` also writes `latest-pq.png`, the newest
158 frame in raw PQ.161 frame in raw PQ.
M docs/dev/headless.md +2 -1
@@ -239,7 +239,8 @@ HEADLESS-1 at (-640,0) and HEADLESS-2 at (0,0).
239239
240240 ## Control input device
241241
242-Control input announces device ID `1` named `control`. Use
242+Control input announces a device named `control` with ID
243+`9223372036854775808`, which no real device uses. Use
243244 `output.tv.input = control` to test device-bound focus on a virtual output.
244245 Control `move` coordinates stay global logical coordinates.
245246
@@ -239,7 +239,8 @@ HEADLESS-1 at (-640,0) and HEADLESS-2 at (0,0).
239 239
240 ## Control input device240 ## Control input device
241 241
242-Control input announces device ID `1` named `control`. Use242+Control input announces a device named `control` with ID
243+`9223372036854775808`, which no real device uses. Use
243 `output.tv.input = control` to test device-bound focus on a virtual output.244 `output.tv.input = control` to test device-bound focus on a virtual output.
244 Control `move` coordinates stay global logical coordinates.245 Control `move` coordinates stay global logical coordinates.
245 246
M docs/server.md +3 -0
@@ -58,6 +58,9 @@ The service runs `neferwl --backend=headless --profile=persistent --session --se
5858 It notifies systemd when ready, exports `WAYLAND_DISPLAY` and `DISPLAY` to the
5959 user manager, binds `graphical-session.target` and restarts on failure. It
6060 conflicts with `neferwl.service`, so it never runs beside a desktop session.
61+Starting it from a desktop session hands the graphical session over to the
62+server instead of tearing it down. A clean server exit removes its display
63+variables and stops its portals; a server crash leaves them in place.
6164
6265 Programs started by the compositor (`startup`, binds, `do spawn`) already have
6366 the right environment. To start a client yourself, take the display from the
@@ -58,6 +58,9 @@ The service runs `neferwl --backend=headless --profile=persistent --session --se
58 It notifies systemd when ready, exports `WAYLAND_DISPLAY` and `DISPLAY` to the58 It notifies systemd when ready, exports `WAYLAND_DISPLAY` and `DISPLAY` to the
59 user manager, binds `graphical-session.target` and restarts on failure. It59 user manager, binds `graphical-session.target` and restarts on failure. It
60 conflicts with `neferwl.service`, so it never runs beside a desktop session.60 conflicts with `neferwl.service`, so it never runs beside a desktop session.
61+Starting it from a desktop session hands the graphical session over to the
62+server instead of tearing it down. A clean server exit removes its display
63+variables and stops its portals; a server crash leaves them in place.
61 64
62 Programs started by the compositor (`startup`, binds, `do spawn`) already have65 Programs started by the compositor (`startup`, binds, `do spawn`) already have
63 the right environment. To start a client yourself, take the display from the66 the right environment. To start a client yourself, take the display from the
M internal/adapters/config/config.go +1 -1
@@ -557,7 +557,7 @@ func parseBytes(data []byte) (domain.Config, map[string]string, []Warning, error
557557 e := entry()
558558 o.Scale, o.Transform, o.Primary, o.HDR, o.SDRBrightness, o.Anchor = e.Scale, e.Transform, e.Primary, e.HDR, e.SDRBrightness, e.Anchor
559559 o.SDRExpand, o.SDRExpandIntensity, o.SDRExpandPeak, o.SDRDecode = e.SDRExpand, e.SDRExpandIntensity, e.SDRExpandPeak, e.SDRDecode
560- o.Inputs = e.Inputs
560+ o.Inputs, o.KeepFocus = e.Inputs, e.KeepFocus
561561 *e = o
562562 continue
563563 }
@@ -557,7 +557,7 @@ func parseBytes(data []byte) (domain.Config, map[string]string, []Warning, error
557 e := entry()557 e := entry()
558 o.Scale, o.Transform, o.Primary, o.HDR, o.SDRBrightness, o.Anchor = e.Scale, e.Transform, e.Primary, e.HDR, e.SDRBrightness, e.Anchor558 o.Scale, o.Transform, o.Primary, o.HDR, o.SDRBrightness, o.Anchor = e.Scale, e.Transform, e.Primary, e.HDR, e.SDRBrightness, e.Anchor
559 o.SDRExpand, o.SDRExpandIntensity, o.SDRExpandPeak, o.SDRDecode = e.SDRExpand, e.SDRExpandIntensity, e.SDRExpandPeak, e.SDRDecode559 o.SDRExpand, o.SDRExpandIntensity, o.SDRExpandPeak, o.SDRDecode = e.SDRExpand, e.SDRExpandIntensity, e.SDRExpandPeak, e.SDRDecode
560- o.Inputs = e.Inputs560+ o.Inputs, o.KeepFocus = e.Inputs, e.KeepFocus
561 *e = o561 *e = o
562 continue562 continue
563 }563 }
M internal/adapters/config/virtual_test.go +24 -0
@@ -109,3 +109,27 @@ func TestVirtualOutputOverrides(t *testing.T) {
109109 }
110110 }
111111 }
112+
113+func TestVirtualOutputKeepFocusKey(t *testing.T) {
114+ for _, tc := range []struct {
115+ name string
116+ input string
117+ }{
118+ {"before", "output.tv.keep-focus = on\noutput.tv = virtual 1920x1080\n"},
119+ {"after", "output.tv = virtual 1920x1080\noutput.tv.keep-focus = on\n"},
120+ } {
121+ t.Run(tc.name, func(t *testing.T) {
122+ c, raw, warnings, err := parseBytes([]byte(tc.input))
123+ if err != nil || len(warnings) != 0 || len(c.Outputs) != 1 {
124+ t.Fatalf("outputs=%+v err=%v warnings=%v", c.Outputs, err, warnings)
125+ }
126+ o := c.Outputs[0]
127+ if !o.Virtual || o.Mode != "1920x1080" || !o.KeepFocus || o.ScaleOnly {
128+ t.Fatalf("output=%+v", o)
129+ }
130+ if raw["output.tv.keep-focus"] != "on" {
131+ t.Fatal("keep-focus dropped from effective config")
132+ }
133+ })
134+ }
135+}
@@ -109,3 +109,27 @@ func TestVirtualOutputOverrides(t *testing.T) {
109 }109 }
110 }110 }
111 }111 }
112+
113+func TestVirtualOutputKeepFocusKey(t *testing.T) {
114+ for _, tc := range []struct {
115+ name string
116+ input string
117+ }{
118+ {"before", "output.tv.keep-focus = on\noutput.tv = virtual 1920x1080\n"},
119+ {"after", "output.tv = virtual 1920x1080\noutput.tv.keep-focus = on\n"},
120+ } {
121+ t.Run(tc.name, func(t *testing.T) {
122+ c, raw, warnings, err := parseBytes([]byte(tc.input))
123+ if err != nil || len(warnings) != 0 || len(c.Outputs) != 1 {
124+ t.Fatalf("outputs=%+v err=%v warnings=%v", c.Outputs, err, warnings)
125+ }
126+ o := c.Outputs[0]
127+ if !o.Virtual || o.Mode != "1920x1080" || !o.KeepFocus || o.ScaleOnly {
128+ t.Fatalf("output=%+v", o)
129+ }
130+ if raw["output.tv.keep-focus"] != "on" {
131+ t.Fatal("keep-focus dropped from effective config")
132+ }
133+ })
134+ }
135+}
M internal/adapters/control/control.go +94 -22
@@ -30,24 +30,26 @@ import (
3030 // each map it receives from Keymaps; producers own any maps left in the channel
3131 // after shutdown. Security is sampled before every translated event.
3232 type Options struct {
33- FramesDir string
34- Shooter *Shooter
35- Keymap *xkb.Keymap
36- Keymaps <-chan *xkb.Keymap
37- Security ports.SessionSecurity
33+ FramesDir string
34+ Shooter *Shooter
35+ Keymap *xkb.Keymap
36+ Keymaps <-chan *xkb.Keymap
37+ Security ports.SessionSecurity
3838 }
3939
4040 type Server struct {
41- framesDir string
42- shooter *Shooter
43- injectMu sync.Mutex
44- injector *injector
45- keymaps <-chan *xkb.Keymap
46- listener *net.UnixListener
47- ids *workspaceid.IDs
48- done chan struct{}
49- once sync.Once
50- err error
41+ framesDir string
42+ shooter *Shooter
43+ quitMu sync.Mutex
44+ quitReplies map[chan struct{}]struct{}
45+ injectMu sync.Mutex
46+ injector *injector
47+ keymaps <-chan *xkb.Keymap
48+ listener *net.UnixListener
49+ ids *workspaceid.IDs
50+ done chan struct{}
51+ once sync.Once
52+ err error
5153 }
5254
5355 // Listen creates a private socket using the same workspace IDs as statefile.
@@ -110,6 +112,40 @@ func (s *Server) Close() error {
110112 return s.err
111113 }
112114
115+// WaitQuitReplies lets shutdown flush outstanding quit replies before cancelling
116+// control connections. The caller bounds the wait in case a peer stops reading.
117+func (s *Server) WaitQuitReplies(ctx context.Context) {
118+ s.quitMu.Lock()
119+ pending := make([]chan struct{}, 0, len(s.quitReplies))
120+ for done := range s.quitReplies {
121+ pending = append(pending, done)
122+ }
123+ s.quitMu.Unlock()
124+ for _, done := range pending {
125+ select {
126+ case <-done:
127+ case <-ctx.Done():
128+ return
129+ }
130+ }
131+}
132+
133+func (s *Server) trackQuit() func() {
134+ done := make(chan struct{})
135+ s.quitMu.Lock()
136+ if s.quitReplies == nil {
137+ s.quitReplies = make(map[chan struct{}]struct{})
138+ }
139+ s.quitReplies[done] = struct{}{}
140+ s.quitMu.Unlock()
141+ return func() {
142+ s.quitMu.Lock()
143+ delete(s.quitReplies, done)
144+ close(done)
145+ s.quitMu.Unlock()
146+ }
147+}
148+
113149 // Run accepts connections until cancellation or Close, waiting for handlers to exit.
114150 func (s *Server) Run(ctx context.Context, out chan<- ports.ControlRequest) error {
115151 ctx, cancel := context.WithCancel(ctx)
@@ -263,11 +299,18 @@ func (s *Server) serve(ctx context.Context, conn *net.UnixConn, out chan<- ports
263299 }
264300 continue
265301 }
302+ finish := func() {}
303+ if req.Op == "do" || req.Op == "inject" {
304+ finish = s.trackQuit()
305+ }
266306 response := s.dispatch(ctx, req, out, &announced)
267307 if ctx.Err() != nil {
308+ finish()
268309 return
269310 }
270- if encoder.Encode(response) != nil {
311+ err := encoder.Encode(response)
312+ finish()
313+ if err != nil {
271314 return
272315 }
273316 }
@@ -282,6 +325,24 @@ func (s *Server) dispatch(ctx context.Context, req request, out chan<- ports.Con
282325 }
283326 ch := make(chan ports.ControlReply, 1)
284327 var message ports.ControlRequest
328+ var admission chan ports.ControlAdmission
329+ var transaction *xkb.Transaction
330+ locked := false
331+ finishTranslation := func(commit bool) {
332+ if !locked {
333+ return
334+ }
335+ if transaction != nil {
336+ if commit {
337+ transaction.Commit()
338+ } else {
339+ transaction.Rollback()
340+ }
341+ }
342+ locked = false
343+ s.injectMu.Unlock()
344+ }
345+ defer func() { finishTranslation(false) }()
285346 timeout := domain.DefaultControlTimeout
286347 switch req.Op {
287348 case "output-add", "output-rm":
@@ -338,11 +399,15 @@ func (s *Server) dispatch(ctx context.Context, req request, out chan<- ports.Con
338399 wait = domain.WaitPresented
339400 }
340401 if req.Op == "inject" {
341- events, err := s.translate(req, !*announced)
402+ s.injectMu.Lock()
403+ locked = true
404+ events, tx, err := s.translate(req, !*announced)
405+ transaction = tx
342406 if err != nil {
343407 return response
344408 }
345- message = ports.ControlInject{Shots: shots, Events: events, Wait: wait, Until: until, Timeout: timeout, Caps: domain.CapsAll, Reply: ch}
409+ admission = make(chan ports.ControlAdmission, 1)
410+ message = ports.ControlInject{Admission: admission, Shots: shots, Events: events, Wait: wait, Until: until, Timeout: timeout, Caps: domain.CapsAll, Reply: ch}
346411 } else {
347412 if req.Op == "shot" {
348413 req.Action = "none"
@@ -365,17 +430,24 @@ func (s *Server) dispatch(ctx context.Context, req request, out chan<- ports.Con
365430 case <-ctx.Done():
366431 return response
367432 }
433+ if admission != nil {
434+ select {
435+ case admitted := <-admission:
436+ finishTranslation(admitted.Err == "")
437+ if admitted.Err == "" {
438+ *announced = true
439+ }
440+ case <-ctx.Done():
441+ return response
442+ }
443+ }
368444 var result ports.ControlReply
369445 select {
370446 case result = <-ch:
371447 case <-ctx.Done():
372448 return response
373449 }
374- // The device announcement went through only if core ran the batch.
375450 code := result.Err
376- if _, inject := message.(ports.ControlInject); inject && (code == "" || code == ports.ControlErrTimeout) {
377- *announced = true
378- }
379451 response = reply{ID: req.ID, OK: code == "", Done: result.Done.String(), Diff: wireDiff(result.Diff), State: statewire.FromDomain(result.State, s.ids), Late: result.Late, Error: code}
380452 if len(result.Shots) > 0 {
381453 if s.shooter == nil {
@@ -30,24 +30,26 @@ import (
30 // each map it receives from Keymaps; producers own any maps left in the channel30 // each map it receives from Keymaps; producers own any maps left in the channel
31 // after shutdown. Security is sampled before every translated event.31 // after shutdown. Security is sampled before every translated event.
32 type Options struct {32 type Options struct {
33- FramesDir string33+ FramesDir string
34- Shooter *Shooter34+ Shooter *Shooter
35- Keymap *xkb.Keymap35+ Keymap *xkb.Keymap
36- Keymaps <-chan *xkb.Keymap36+ Keymaps <-chan *xkb.Keymap
37- Security ports.SessionSecurity37+ Security ports.SessionSecurity
38 }38 }
39 39
40 type Server struct {40 type Server struct {
41- framesDir string41+ framesDir string
42- shooter *Shooter42+ shooter *Shooter
43- injectMu sync.Mutex43+ quitMu sync.Mutex
44- injector *injector44+ quitReplies map[chan struct{}]struct{}
45- keymaps <-chan *xkb.Keymap45+ injectMu sync.Mutex
46- listener *net.UnixListener46+ injector *injector
47- ids *workspaceid.IDs47+ keymaps <-chan *xkb.Keymap
48- done chan struct{}48+ listener *net.UnixListener
49- once sync.Once49+ ids *workspaceid.IDs
50- err error50+ done chan struct{}
51+ once sync.Once
52+ err error
51 }53 }
52 54
53 // Listen creates a private socket using the same workspace IDs as statefile.55 // Listen creates a private socket using the same workspace IDs as statefile.
@@ -110,6 +112,40 @@ func (s *Server) Close() error {
110 return s.err112 return s.err
111 }113 }
112 114
115+// WaitQuitReplies lets shutdown flush outstanding quit replies before cancelling
116+// control connections. The caller bounds the wait in case a peer stops reading.
117+func (s *Server) WaitQuitReplies(ctx context.Context) {
118+ s.quitMu.Lock()
119+ pending := make([]chan struct{}, 0, len(s.quitReplies))
120+ for done := range s.quitReplies {
121+ pending = append(pending, done)
122+ }
123+ s.quitMu.Unlock()
124+ for _, done := range pending {
125+ select {
126+ case <-done:
127+ case <-ctx.Done():
128+ return
129+ }
130+ }
131+}
132+
133+func (s *Server) trackQuit() func() {
134+ done := make(chan struct{})
135+ s.quitMu.Lock()
136+ if s.quitReplies == nil {
137+ s.quitReplies = make(map[chan struct{}]struct{})
138+ }
139+ s.quitReplies[done] = struct{}{}
140+ s.quitMu.Unlock()
141+ return func() {
142+ s.quitMu.Lock()
143+ delete(s.quitReplies, done)
144+ close(done)
145+ s.quitMu.Unlock()
146+ }
147+}
148+
113 // Run accepts connections until cancellation or Close, waiting for handlers to exit.149 // Run accepts connections until cancellation or Close, waiting for handlers to exit.
114 func (s *Server) Run(ctx context.Context, out chan<- ports.ControlRequest) error {150 func (s *Server) Run(ctx context.Context, out chan<- ports.ControlRequest) error {
115 ctx, cancel := context.WithCancel(ctx)151 ctx, cancel := context.WithCancel(ctx)
@@ -263,11 +299,18 @@ func (s *Server) serve(ctx context.Context, conn *net.UnixConn, out chan<- ports
263 }299 }
264 continue300 continue
265 }301 }
302+ finish := func() {}
303+ if req.Op == "do" || req.Op == "inject" {
304+ finish = s.trackQuit()
305+ }
266 response := s.dispatch(ctx, req, out, &announced)306 response := s.dispatch(ctx, req, out, &announced)
267 if ctx.Err() != nil {307 if ctx.Err() != nil {
308+ finish()
268 return309 return
269 }310 }
270- if encoder.Encode(response) != nil {311+ err := encoder.Encode(response)
312+ finish()
313+ if err != nil {
271 return314 return
272 }315 }
273 }316 }
@@ -282,6 +325,24 @@ func (s *Server) dispatch(ctx context.Context, req request, out chan<- ports.Con
282 }325 }
283 ch := make(chan ports.ControlReply, 1)326 ch := make(chan ports.ControlReply, 1)
284 var message ports.ControlRequest327 var message ports.ControlRequest
328+ var admission chan ports.ControlAdmission
329+ var transaction *xkb.Transaction
330+ locked := false
331+ finishTranslation := func(commit bool) {
332+ if !locked {
333+ return
334+ }
335+ if transaction != nil {
336+ if commit {
337+ transaction.Commit()
338+ } else {
339+ transaction.Rollback()
340+ }
341+ }
342+ locked = false
343+ s.injectMu.Unlock()
344+ }
345+ defer func() { finishTranslation(false) }()
285 timeout := domain.DefaultControlTimeout346 timeout := domain.DefaultControlTimeout
286 switch req.Op {347 switch req.Op {
287 case "output-add", "output-rm":348 case "output-add", "output-rm":
@@ -338,11 +399,15 @@ func (s *Server) dispatch(ctx context.Context, req request, out chan<- ports.Con
338 wait = domain.WaitPresented399 wait = domain.WaitPresented
339 }400 }
340 if req.Op == "inject" {401 if req.Op == "inject" {
341- events, err := s.translate(req, !*announced)402+ s.injectMu.Lock()
403+ locked = true
404+ events, tx, err := s.translate(req, !*announced)
405+ transaction = tx
342 if err != nil {406 if err != nil {
343 return response407 return response
344 }408 }
345- message = ports.ControlInject{Shots: shots, Events: events, Wait: wait, Until: until, Timeout: timeout, Caps: domain.CapsAll, Reply: ch}409+ admission = make(chan ports.ControlAdmission, 1)
410+ message = ports.ControlInject{Admission: admission, Shots: shots, Events: events, Wait: wait, Until: until, Timeout: timeout, Caps: domain.CapsAll, Reply: ch}
346 } else {411 } else {
347 if req.Op == "shot" {412 if req.Op == "shot" {
348 req.Action = "none"413 req.Action = "none"
@@ -365,17 +430,24 @@ func (s *Server) dispatch(ctx context.Context, req request, out chan<- ports.Con
365 case <-ctx.Done():430 case <-ctx.Done():
366 return response431 return response
367 }432 }
433+ if admission != nil {
434+ select {
435+ case admitted := <-admission:
436+ finishTranslation(admitted.Err == "")
437+ if admitted.Err == "" {
438+ *announced = true
439+ }
440+ case <-ctx.Done():
441+ return response
442+ }
443+ }
368 var result ports.ControlReply444 var result ports.ControlReply
369 select {445 select {
370 case result = <-ch:446 case result = <-ch:
371 case <-ctx.Done():447 case <-ctx.Done():
372 return response448 return response
373 }449 }
374- // The device announcement went through only if core ran the batch.
375 code := result.Err450 code := result.Err
376- if _, inject := message.(ports.ControlInject); inject && (code == "" || code == ports.ControlErrTimeout) {
377- *announced = true
378- }
379 response = reply{ID: req.ID, OK: code == "", Done: result.Done.String(), Diff: wireDiff(result.Diff), State: statewire.FromDomain(result.State, s.ids), Late: result.Late, Error: code}451 response = reply{ID: req.ID, OK: code == "", Done: result.Done.String(), Diff: wireDiff(result.Diff), State: statewire.FromDomain(result.State, s.ids), Late: result.Late, Error: code}
380 if len(result.Shots) > 0 {452 if len(result.Shots) > 0 {
381 if s.shooter == nil {453 if s.shooter == nil {
M internal/adapters/control/control_test.go +48 -0
@@ -311,3 +311,51 @@ func TestConnectionOrderingAndClose(t *testing.T) {
311311 t.Fatal("Close did not stop Run")
312312 }
313313 }
314+
315+//testpolicy:realtime A real Unix socket verifies the reply is written before shutdown cancellation.
316+func TestQuitReplyBeforeShutdown(t *testing.T) {
317+ s, err := Listen(filepath.Join(t.TempDir(), "control.sock"), workspaceid.WithPrefix("quit"), Options{})
318+ if err != nil {
319+ t.Fatal(err)
320+ }
321+ defer s.Close()
322+ ctx, cancel := context.WithTimeout(t.Context(), 10*time.Second)
323+ defer cancel()
324+ out := make(chan ports.ControlRequest)
325+ done := make(chan error, 1)
326+ go func() { done <- s.Run(ctx, out) }()
327+ conn, err := net.Dial("unix", s.listener.Addr().String())
328+ if err != nil {
329+ t.Fatal(err)
330+ }
331+ defer conn.Close()
332+ if err := conn.SetDeadline(time.Now().Add(10 * time.Second)); err != nil {
333+ t.Fatal(err)
334+ }
335+ if _, err := conn.Write([]byte("{\"op\":\"do\",\"action\":\"quit\"}\n")); err != nil {
336+ t.Fatal(err)
337+ }
338+ var req ports.ControlDo
339+ select {
340+ case message := <-out:
341+ req = message.(ports.ControlDo)
342+ case <-ctx.Done():
343+ t.Fatal(ctx.Err())
344+ }
345+ if req.Wait != domain.DefaultWait {
346+ t.Fatalf("wait: %v", req.Wait)
347+ }
348+ req.Reply <- ports.ControlReply{Done: domain.WaitCommitted}
349+ s.WaitQuitReplies(ctx)
350+ cancel()
351+ var response reply
352+ if err := json.NewDecoder(conn).Decode(&response); err != nil {
353+ t.Fatal(err)
354+ }
355+ if !response.OK || response.Done != "committed" {
356+ t.Fatalf("reply: %+v", response)
357+ }
358+ if err := <-done; err != nil {
359+ t.Fatal(err)
360+ }
361+}
@@ -311,3 +311,51 @@ func TestConnectionOrderingAndClose(t *testing.T) {
311 t.Fatal("Close did not stop Run")311 t.Fatal("Close did not stop Run")
312 }312 }
313 }313 }
314+
315+//testpolicy:realtime A real Unix socket verifies the reply is written before shutdown cancellation.
316+func TestQuitReplyBeforeShutdown(t *testing.T) {
317+ s, err := Listen(filepath.Join(t.TempDir(), "control.sock"), workspaceid.WithPrefix("quit"), Options{})
318+ if err != nil {
319+ t.Fatal(err)
320+ }
321+ defer s.Close()
322+ ctx, cancel := context.WithTimeout(t.Context(), 10*time.Second)
323+ defer cancel()
324+ out := make(chan ports.ControlRequest)
325+ done := make(chan error, 1)
326+ go func() { done <- s.Run(ctx, out) }()
327+ conn, err := net.Dial("unix", s.listener.Addr().String())
328+ if err != nil {
329+ t.Fatal(err)
330+ }
331+ defer conn.Close()
332+ if err := conn.SetDeadline(time.Now().Add(10 * time.Second)); err != nil {
333+ t.Fatal(err)
334+ }
335+ if _, err := conn.Write([]byte("{\"op\":\"do\",\"action\":\"quit\"}\n")); err != nil {
336+ t.Fatal(err)
337+ }
338+ var req ports.ControlDo
339+ select {
340+ case message := <-out:
341+ req = message.(ports.ControlDo)
342+ case <-ctx.Done():
343+ t.Fatal(ctx.Err())
344+ }
345+ if req.Wait != domain.DefaultWait {
346+ t.Fatalf("wait: %v", req.Wait)
347+ }
348+ req.Reply <- ports.ControlReply{Done: domain.WaitCommitted}
349+ s.WaitQuitReplies(ctx)
350+ cancel()
351+ var response reply
352+ if err := json.NewDecoder(conn).Decode(&response); err != nil {
353+ t.Fatal(err)
354+ }
355+ if !response.OK || response.Done != "committed" {
356+ t.Fatalf("reply: %+v", response)
357+ }
358+ if err := <-done; err != nil {
359+ t.Fatal(err)
360+ }
361+}
M internal/adapters/control/inject.go +1 -1
@@ -15,7 +15,7 @@ import (
1515 "golang.org/x/sys/unix"
1616 )
1717
18-const controlDeviceID domain.InputDeviceID = 1
18+const controlDeviceID = domain.ControlDeviceID
1919
2020 // injector translates commands on its owner's goroutine. It borrows km; the
2121 // caller owns its lifetime and announces Device once before delivering input.
@@ -15,7 +15,7 @@ import (
15 "golang.org/x/sys/unix"15 "golang.org/x/sys/unix"
16 )16 )
17 17
18-const controlDeviceID domain.InputDeviceID = 118+const controlDeviceID = domain.ControlDeviceID
19 19
20 // injector translates commands on its owner's goroutine. It borrows km; the20 // injector translates commands on its owner's goroutine. It borrows km; the
21 // caller owns its lifetime and announces Device once before delivering input.21 // caller owns its lifetime and announces Device once before delivering input.
M internal/adapters/control/inject_wire.go +20 -11
@@ -3,21 +3,20 @@ package control
33 import (
44 "errors"
55
6+ "github.com/bnema/neferwl/internal/adapters/xkb"
67 "github.com/bnema/neferwl/internal/ports"
78 )
89
9-// translate serializes XKB access across connections and keymap reloads. The
10-// output batch is immutable; core receives it through the normal control port.
11-func (s *Server) translate(req request, announce bool) ([]ports.InputEvent, error) {
12- s.injectMu.Lock()
13- defer s.injectMu.Unlock()
10+// translate requires injectMu through admission. Reloads happen before Begin,
11+// never while the tentative translation is awaiting core admission.
12+func (s *Server) translate(req request, announce bool) ([]ports.InputEvent, *xkb.Transaction, error) {
1413 select {
1514 case <-s.done:
16- return nil, errors.New("control closed")
15+ return nil, nil, errors.New("control closed")
1716 default:
1817 }
1918 if s.injector == nil {
20- return nil, errors.New("input unavailable")
19+ return nil, nil, errors.New("input unavailable")
2120 }
2221 for s.keymaps != nil {
2322 select {
@@ -41,8 +40,17 @@ func (s *Server) translate(req request, announce bool) ([]ports.InputEvent, erro
4140 }
4241 ready:
4342 i := s.injector
43+ tx, err := i.km.Begin()
44+ if err != nil {
45+ return nil, nil, err
46+ }
47+ success := false
48+ defer func() {
49+ if !success {
50+ tx.Rollback()
51+ }
52+ }()
4453 var events []ports.InputEvent
45- var err error
4654 // Snapshot an announcement before translating the first event, but don't
4755 // deliver it or consume the connection's announcement on validation failure.
4856 var device ports.InputEvent
@@ -63,13 +71,14 @@ ready:
6371 case "swipe":
6472 events, err = i.Swipe(req.Fingers, req.Dir)
6573 default:
66- return nil, errors.New("unknown injection kind")
74+ return nil, nil, errors.New("unknown injection kind")
6775 }
6876 if err != nil {
69- return nil, err
77+ return nil, nil, err
7078 }
7179 if announce {
7280 events = append([]ports.InputEvent{device}, events...)
7381 }
74- return events, nil
82+ success = true
83+ return events, tx, nil
7584 }
@@ -3,21 +3,20 @@ package control
3 import (3 import (
4 "errors"4 "errors"
5 5
6+ "github.com/bnema/neferwl/internal/adapters/xkb"
6 "github.com/bnema/neferwl/internal/ports"7 "github.com/bnema/neferwl/internal/ports"
7 )8 )
8 9
9-// translate serializes XKB access across connections and keymap reloads. The10+// translate requires injectMu through admission. Reloads happen before Begin,
10-// output batch is immutable; core receives it through the normal control port.11+// never while the tentative translation is awaiting core admission.
11-func (s *Server) translate(req request, announce bool) ([]ports.InputEvent, error) {12+func (s *Server) translate(req request, announce bool) ([]ports.InputEvent, *xkb.Transaction, error) {
12- s.injectMu.Lock()
13- defer s.injectMu.Unlock()
14 select {13 select {
15 case <-s.done:14 case <-s.done:
16- return nil, errors.New("control closed")15+ return nil, nil, errors.New("control closed")
17 default:16 default:
18 }17 }
19 if s.injector == nil {18 if s.injector == nil {
20- return nil, errors.New("input unavailable")19+ return nil, nil, errors.New("input unavailable")
21 }20 }
22 for s.keymaps != nil {21 for s.keymaps != nil {
23 select {22 select {
@@ -41,8 +40,17 @@ func (s *Server) translate(req request, announce bool) ([]ports.InputEvent, erro
41 }40 }
42 ready:41 ready:
43 i := s.injector42 i := s.injector
43+ tx, err := i.km.Begin()
44+ if err != nil {
45+ return nil, nil, err
46+ }
47+ success := false
48+ defer func() {
49+ if !success {
50+ tx.Rollback()
51+ }
52+ }()
44 var events []ports.InputEvent53 var events []ports.InputEvent
45- var err error
46 // Snapshot an announcement before translating the first event, but don't54 // Snapshot an announcement before translating the first event, but don't
47 // deliver it or consume the connection's announcement on validation failure.55 // deliver it or consume the connection's announcement on validation failure.
48 var device ports.InputEvent56 var device ports.InputEvent
@@ -63,13 +71,14 @@ ready:
63 case "swipe":71 case "swipe":
64 events, err = i.Swipe(req.Fingers, req.Dir)72 events, err = i.Swipe(req.Fingers, req.Dir)
65 default:73 default:
66- return nil, errors.New("unknown injection kind")74+ return nil, nil, errors.New("unknown injection kind")
67 }75 }
68 if err != nil {76 if err != nil {
69- return nil, err77+ return nil, nil, err
70 }78 }
71 if announce {79 if announce {
72 events = append([]ports.InputEvent{device}, events...)80 events = append([]ports.InputEvent{device}, events...)
73 }81 }
74- return events, nil82+ success = true
83+ return events, tx, nil
75 }84 }
M internal/adapters/control/inject_wire_test.go +184 -0
@@ -103,6 +103,7 @@ func TestInjectProtocol(t *testing.T) {
103103 } else if message.Wait != domain.DefaultWait || message.Until != nil || message.Timeout != 10*time.Second {
104104 t.Fatal(message)
105105 }
106+ message.Admission <- ports.ControlAdmission{}
106107 message.Reply <- ports.ControlReply{Done: domain.WaitCommitted}
107108 var response reply
108109 if err := json.NewDecoder(conn).Decode(&response); err != nil || !response.OK {
@@ -157,6 +158,7 @@ func TestInjectAnnouncesUntilAccepted(t *testing.T) {
157158 if first == announced {
158159 t.Errorf("announcement sent=%v after announced=%v", first, announced)
159160 }
161+ r.Admission <- ports.ControlAdmission{Err: refuse}
160162 r.Reply <- ports.ControlReply{Err: refuse}
161163 }()
162164 s.dispatch(context.Background(), request{Op: "inject", Kind: "key", Combo: "a"}, out, &announced)
@@ -167,3 +169,185 @@ func TestInjectAnnouncesUntilAccepted(t *testing.T) {
167169 }
168170 })
169171 }
172+
173+func TestInjectionAdmissionOrderingAndReload(t *testing.T) {
174+ synctest.Test(t, func(t *testing.T) {
175+ updates := make(chan *xkb.Keymap, 1)
176+ s := &Server{ids: workspaceid.WithPrefix("order"), done: make(chan struct{}), injector: newInjector(injectKeymap(t), nil), keymaps: updates}
177+ out := make(chan ports.ControlRequest, 2)
178+ firstDone, secondDone := make(chan reply, 1), make(chan reply, 1)
179+ go func() {
180+ announced := false
181+ firstDone <- s.dispatch(t.Context(), request{Op: "inject", Kind: "press", Combo: "Super"}, out, &announced)
182+ }()
183+ synctest.Wait()
184+ first := (<-out).(ports.ControlInject)
185+ next := injectKeymap(t)
186+ updates <- next
187+ if s.injectMu.TryLock() {
188+ s.injectMu.Unlock()
189+ t.Fatal("admission serialization released early")
190+ }
191+ go func() {
192+ announced := false
193+ secondDone <- s.dispatch(t.Context(), request{Op: "inject", Kind: "key", Combo: "q"}, out, &announced)
194+ }()
195+ if len(out) != 0 || len(updates) != 1 {
196+ t.Fatal("second connection translated/reloaded before admission")
197+ }
198+ first.Admission <- ports.ControlAdmission{Err: ports.ControlErrBusy}
199+ synctest.Wait()
200+ second := (<-out).(ports.ControlInject)
201+ for _, ev := range second.Events {
202+ if key, ok := ev.(ports.KeyEvent); ok && key.Mods&domain.ModSuper != 0 {
203+ t.Fatal("refused Super leaked into q", key)
204+ }
205+ }
206+ // The second request passed admission serialization while first completion
207+ // is still pending; replacing the map happened only after rollback.
208+ if len(updates) != 0 {
209+ t.Fatal("reload not consumed")
210+ }
211+ second.Admission <- ports.ControlAdmission{}
212+ second.Reply <- ports.ControlReply{}
213+ first.Reply <- ports.ControlReply{Err: ports.ControlErrBusy}
214+ if r := <-firstDone; r.Error != ports.ControlErrBusy {
215+ t.Fatal(r)
216+ }
217+ if r := <-secondDone; !r.OK {
218+ t.Fatal(r)
219+ }
220+ })
221+}
222+
223+func TestInjectionRefusedSuperRollback(t *testing.T) {
224+ synctest.Test(t, func(t *testing.T) {
225+ s := &Server{ids: workspaceid.WithPrefix("busy"), done: make(chan struct{}), injector: newInjector(injectKeymap(t), nil)}
226+ out := make(chan ports.ControlRequest)
227+ announced := false
228+ go func() {
229+ r := (<-out).(ports.ControlInject)
230+ r.Admission <- ports.ControlAdmission{Err: ports.ControlErrBusy}
231+ r.Reply <- ports.ControlReply{Err: ports.ControlErrBusy}
232+ }()
233+ if r := s.dispatch(t.Context(), request{Op: "inject", Kind: "press", Combo: "Super"}, out, &announced); r.Error != ports.ControlErrBusy {
234+ t.Fatal(r)
235+ }
236+ go func() {
237+ r := (<-out).(ports.ControlInject)
238+ for _, ev := range r.Events {
239+ if key, ok := ev.(ports.KeyEvent); ok && key.Mods&domain.ModSuper != 0 {
240+ t.Error("q would trigger Super+q", key)
241+ }
242+ }
243+ r.Admission <- ports.ControlAdmission{}
244+ r.Reply <- ports.ControlReply{}
245+ }()
246+ if r := s.dispatch(t.Context(), request{Op: "inject", Kind: "key", Combo: "q"}, out, &announced); !r.OK {
247+ t.Fatal(r)
248+ }
249+ })
250+}
251+
252+func TestInjectionCancellationRollsBack(t *testing.T) {
253+ for _, sent := range []bool{false, true} {
254+ synctest.Test(t, func(t *testing.T) {
255+ s := &Server{ids: workspaceid.WithPrefix("cancel"), done: make(chan struct{}), injector: newInjector(injectKeymap(t), nil)}
256+ out := make(chan ports.ControlRequest)
257+ ctx, cancel := context.WithCancel(t.Context())
258+ done := make(chan struct{})
259+ go func() {
260+ defer close(done)
261+ announced := false
262+ s.dispatch(ctx, request{Op: "inject", Kind: "press", Combo: "Super"}, out, &announced)
263+ }()
264+ if sent {
265+ <-out
266+ }
267+ synctest.Wait()
268+ cancel()
269+ <-done
270+ s.injectMu.Lock()
271+ if ev := s.injector.km.Key(16, true, 0); ev.Mods&domain.ModSuper != 0 {
272+ t.Fatal("cancelled translation leaked", ev)
273+ }
274+ s.injectMu.Unlock()
275+ })
276+ }
277+}
278+
279+//testpolicy:realtime Two real socket clients verify admission ordering independently of completion.
280+func TestTwoConnectionsShareAdmittedModifiers(t *testing.T) {
281+ path := filepath.Join(t.TempDir(), "control.sock")
282+ s, err := Listen(path, workspaceid.WithPrefix("order"), Options{Keymap: injectKeymap(t)})
283+ if err != nil {
284+ t.Fatal(err)
285+ }
286+ defer s.Close()
287+ ctx, cancel := context.WithTimeout(t.Context(), 5*time.Second)
288+ defer cancel()
289+ out := make(chan ports.ControlRequest)
290+ done := make(chan error, 1)
291+ go func() { done <- s.Run(ctx, out) }()
292+ connect := func() net.Conn {
293+ t.Helper()
294+ conn, err := net.Dial("unix", path)
295+ if err != nil {
296+ t.Fatal(err)
297+ }
298+ t.Cleanup(func() { conn.Close() })
299+ if err := conn.SetDeadline(time.Now().Add(5 * time.Second)); err != nil {
300+ t.Fatal(err)
301+ }
302+ return conn
303+ }
304+ first, second := connect(), connect()
305+ if err := json.NewEncoder(first).Encode(request{Op: "inject", Kind: "press", Combo: "Super"}); err != nil {
306+ t.Fatal(err)
307+ }
308+ receive := func() ports.ControlInject {
309+ t.Helper()
310+ select {
311+ case r := <-out:
312+ return r.(ports.ControlInject)
313+ case <-ctx.Done():
314+ t.Fatal(ctx.Err())
315+ return ports.ControlInject{}
316+ }
317+ }
318+ a := receive()
319+ if err := json.NewEncoder(second).Encode(request{Op: "inject", Kind: "key", Combo: "q"}); err != nil {
320+ t.Fatal(err)
321+ }
322+ if s.injectMu.TryLock() {
323+ s.injectMu.Unlock()
324+ t.Fatal("serialization released before admission")
325+ }
326+ a.Admission <- ports.ControlAdmission{}
327+ b := receive() // Must arrive without completing a.
328+ found := false
329+ for _, ev := range b.Events {
330+ if key, ok := ev.(ports.KeyEvent); ok && key.Keysym == "q" && key.Pressed {
331+ found = true
332+ if key.Mods&domain.ModSuper == 0 {
333+ t.Fatal("second client lost admitted Super")
334+ }
335+ }
336+ }
337+ if !found {
338+ t.Fatal("missing q")
339+ }
340+ b.Admission <- ports.ControlAdmission{}
341+ b.Reply <- ports.ControlReply{}
342+ a.Reply <- ports.ControlReply{}
343+ for _, conn := range []net.Conn{first, second} {
344+ var r reply
345+ if err := json.NewDecoder(conn).Decode(&r); err != nil || !r.OK {
346+ t.Fatal(r, err)
347+ }
348+ }
349+ cancel()
350+ if err := <-done; err != nil {
351+ t.Fatal(err)
352+ }
353+}
@@ -103,6 +103,7 @@ func TestInjectProtocol(t *testing.T) {
103 } else if message.Wait != domain.DefaultWait || message.Until != nil || message.Timeout != 10*time.Second {103 } else if message.Wait != domain.DefaultWait || message.Until != nil || message.Timeout != 10*time.Second {
104 t.Fatal(message)104 t.Fatal(message)
105 }105 }
106+ message.Admission <- ports.ControlAdmission{}
106 message.Reply <- ports.ControlReply{Done: domain.WaitCommitted}107 message.Reply <- ports.ControlReply{Done: domain.WaitCommitted}
107 var response reply108 var response reply
108 if err := json.NewDecoder(conn).Decode(&response); err != nil || !response.OK {109 if err := json.NewDecoder(conn).Decode(&response); err != nil || !response.OK {
@@ -157,6 +158,7 @@ func TestInjectAnnouncesUntilAccepted(t *testing.T) {
157 if first == announced {158 if first == announced {
158 t.Errorf("announcement sent=%v after announced=%v", first, announced)159 t.Errorf("announcement sent=%v after announced=%v", first, announced)
159 }160 }
161+ r.Admission <- ports.ControlAdmission{Err: refuse}
160 r.Reply <- ports.ControlReply{Err: refuse}162 r.Reply <- ports.ControlReply{Err: refuse}
161 }()163 }()
162 s.dispatch(context.Background(), request{Op: "inject", Kind: "key", Combo: "a"}, out, &announced)164 s.dispatch(context.Background(), request{Op: "inject", Kind: "key", Combo: "a"}, out, &announced)
@@ -167,3 +169,185 @@ func TestInjectAnnouncesUntilAccepted(t *testing.T) {
167 }169 }
168 })170 })
169 }171 }
172+
173+func TestInjectionAdmissionOrderingAndReload(t *testing.T) {
174+ synctest.Test(t, func(t *testing.T) {
175+ updates := make(chan *xkb.Keymap, 1)
176+ s := &Server{ids: workspaceid.WithPrefix("order"), done: make(chan struct{}), injector: newInjector(injectKeymap(t), nil), keymaps: updates}
177+ out := make(chan ports.ControlRequest, 2)
178+ firstDone, secondDone := make(chan reply, 1), make(chan reply, 1)
179+ go func() {
180+ announced := false
181+ firstDone <- s.dispatch(t.Context(), request{Op: "inject", Kind: "press", Combo: "Super"}, out, &announced)
182+ }()
183+ synctest.Wait()
184+ first := (<-out).(ports.ControlInject)
185+ next := injectKeymap(t)
186+ updates <- next
187+ if s.injectMu.TryLock() {
188+ s.injectMu.Unlock()
189+ t.Fatal("admission serialization released early")
190+ }
191+ go func() {
192+ announced := false
193+ secondDone <- s.dispatch(t.Context(), request{Op: "inject", Kind: "key", Combo: "q"}, out, &announced)
194+ }()
195+ if len(out) != 0 || len(updates) != 1 {
196+ t.Fatal("second connection translated/reloaded before admission")
197+ }
198+ first.Admission <- ports.ControlAdmission{Err: ports.ControlErrBusy}
199+ synctest.Wait()
200+ second := (<-out).(ports.ControlInject)
201+ for _, ev := range second.Events {
202+ if key, ok := ev.(ports.KeyEvent); ok && key.Mods&domain.ModSuper != 0 {
203+ t.Fatal("refused Super leaked into q", key)
204+ }
205+ }
206+ // The second request passed admission serialization while first completion
207+ // is still pending; replacing the map happened only after rollback.
208+ if len(updates) != 0 {
209+ t.Fatal("reload not consumed")
210+ }
211+ second.Admission <- ports.ControlAdmission{}
212+ second.Reply <- ports.ControlReply{}
213+ first.Reply <- ports.ControlReply{Err: ports.ControlErrBusy}
214+ if r := <-firstDone; r.Error != ports.ControlErrBusy {
215+ t.Fatal(r)
216+ }
217+ if r := <-secondDone; !r.OK {
218+ t.Fatal(r)
219+ }
220+ })
221+}
222+
223+func TestInjectionRefusedSuperRollback(t *testing.T) {
224+ synctest.Test(t, func(t *testing.T) {
225+ s := &Server{ids: workspaceid.WithPrefix("busy"), done: make(chan struct{}), injector: newInjector(injectKeymap(t), nil)}
226+ out := make(chan ports.ControlRequest)
227+ announced := false
228+ go func() {
229+ r := (<-out).(ports.ControlInject)
230+ r.Admission <- ports.ControlAdmission{Err: ports.ControlErrBusy}
231+ r.Reply <- ports.ControlReply{Err: ports.ControlErrBusy}
232+ }()
233+ if r := s.dispatch(t.Context(), request{Op: "inject", Kind: "press", Combo: "Super"}, out, &announced); r.Error != ports.ControlErrBusy {
234+ t.Fatal(r)
235+ }
236+ go func() {
237+ r := (<-out).(ports.ControlInject)
238+ for _, ev := range r.Events {
239+ if key, ok := ev.(ports.KeyEvent); ok && key.Mods&domain.ModSuper != 0 {
240+ t.Error("q would trigger Super+q", key)
241+ }
242+ }
243+ r.Admission <- ports.ControlAdmission{}
244+ r.Reply <- ports.ControlReply{}
245+ }()
246+ if r := s.dispatch(t.Context(), request{Op: "inject", Kind: "key", Combo: "q"}, out, &announced); !r.OK {
247+ t.Fatal(r)
248+ }
249+ })
250+}
251+
252+func TestInjectionCancellationRollsBack(t *testing.T) {
253+ for _, sent := range []bool{false, true} {
254+ synctest.Test(t, func(t *testing.T) {
255+ s := &Server{ids: workspaceid.WithPrefix("cancel"), done: make(chan struct{}), injector: newInjector(injectKeymap(t), nil)}
256+ out := make(chan ports.ControlRequest)
257+ ctx, cancel := context.WithCancel(t.Context())
258+ done := make(chan struct{})
259+ go func() {
260+ defer close(done)
261+ announced := false
262+ s.dispatch(ctx, request{Op: "inject", Kind: "press", Combo: "Super"}, out, &announced)
263+ }()
264+ if sent {
265+ <-out
266+ }
267+ synctest.Wait()
268+ cancel()
269+ <-done
270+ s.injectMu.Lock()
271+ if ev := s.injector.km.Key(16, true, 0); ev.Mods&domain.ModSuper != 0 {
272+ t.Fatal("cancelled translation leaked", ev)
273+ }
274+ s.injectMu.Unlock()
275+ })
276+ }
277+}
278+
279+//testpolicy:realtime Two real socket clients verify admission ordering independently of completion.
280+func TestTwoConnectionsShareAdmittedModifiers(t *testing.T) {
281+ path := filepath.Join(t.TempDir(), "control.sock")
282+ s, err := Listen(path, workspaceid.WithPrefix("order"), Options{Keymap: injectKeymap(t)})
283+ if err != nil {
284+ t.Fatal(err)
285+ }
286+ defer s.Close()
287+ ctx, cancel := context.WithTimeout(t.Context(), 5*time.Second)
288+ defer cancel()
289+ out := make(chan ports.ControlRequest)
290+ done := make(chan error, 1)
291+ go func() { done <- s.Run(ctx, out) }()
292+ connect := func() net.Conn {
293+ t.Helper()
294+ conn, err := net.Dial("unix", path)
295+ if err != nil {
296+ t.Fatal(err)
297+ }
298+ t.Cleanup(func() { conn.Close() })
299+ if err := conn.SetDeadline(time.Now().Add(5 * time.Second)); err != nil {
300+ t.Fatal(err)
301+ }
302+ return conn
303+ }
304+ first, second := connect(), connect()
305+ if err := json.NewEncoder(first).Encode(request{Op: "inject", Kind: "press", Combo: "Super"}); err != nil {
306+ t.Fatal(err)
307+ }
308+ receive := func() ports.ControlInject {
309+ t.Helper()
310+ select {
311+ case r := <-out:
312+ return r.(ports.ControlInject)
313+ case <-ctx.Done():
314+ t.Fatal(ctx.Err())
315+ return ports.ControlInject{}
316+ }
317+ }
318+ a := receive()
319+ if err := json.NewEncoder(second).Encode(request{Op: "inject", Kind: "key", Combo: "q"}); err != nil {
320+ t.Fatal(err)
321+ }
322+ if s.injectMu.TryLock() {
323+ s.injectMu.Unlock()
324+ t.Fatal("serialization released before admission")
325+ }
326+ a.Admission <- ports.ControlAdmission{}
327+ b := receive() // Must arrive without completing a.
328+ found := false
329+ for _, ev := range b.Events {
330+ if key, ok := ev.(ports.KeyEvent); ok && key.Keysym == "q" && key.Pressed {
331+ found = true
332+ if key.Mods&domain.ModSuper == 0 {
333+ t.Fatal("second client lost admitted Super")
334+ }
335+ }
336+ }
337+ if !found {
338+ t.Fatal("missing q")
339+ }
340+ b.Admission <- ports.ControlAdmission{}
341+ b.Reply <- ports.ControlReply{}
342+ a.Reply <- ports.ControlReply{}
343+ for _, conn := range []net.Conn{first, second} {
344+ var r reply
345+ if err := json.NewDecoder(conn).Decode(&r); err != nil || !r.OK {
346+ t.Fatal(r, err)
347+ }
348+ }
349+ cancel()
350+ if err := <-done; err != nil {
351+ t.Fatal(err)
352+ }
353+}
M internal/adapters/control/shot_wire_test.go +1 -0
@@ -52,6 +52,7 @@ func TestShotDispatch(t *testing.T) {
5252 t.Errorf("action %q", r.Action)
5353 }
5454 case ports.ControlInject:
55+ r.Admission <- ports.ControlAdmission{}
5556 shots, wait, caps, response = r.Shots, r.Wait, r.Caps, r.Reply
5657 default:
5758 t.Errorf("message %T", message)
@@ -52,6 +52,7 @@ func TestShotDispatch(t *testing.T) {
52 t.Errorf("action %q", r.Action)52 t.Errorf("action %q", r.Action)
53 }53 }
54 case ports.ControlInject:54 case ports.ControlInject:
55+ r.Admission <- ports.ControlAdmission{}
55 shots, wait, caps, response = r.Shots, r.Wait, r.Caps, r.Reply56 shots, wait, caps, response = r.Shots, r.Wait, r.Caps, r.Reply
56 default:57 default:
57 t.Errorf("message %T", message)58 t.Errorf("message %T", message)
M internal/adapters/drm/supervisor/recovery.go +2 -2
@@ -162,13 +162,13 @@ func (run *outputsRun) finishRecovery() (error, bool) {
162162 return nil, false
163163 }
164164 old := run.b.render
165- run.b.render = nil // failure cleanup must not close the lost device again.
165+ run.b.setRender(nil) // failure cleanup must not close the lost device again.
166166 run.log.Warn().Str("card", run.b.renderInfo.Path).Msg("render device lost, reopening")
167167 next, reopenErr := reopenRender(run.b.opener, run.b.renderInfo, old, &run.policy.ReopenLimiter)
168168 if reopenErr != nil {
169169 return errors.Join(reopenErr, run.set.Wait()), true
170170 }
171- run.b.render = next
171+ run.b.setRender(next)
172172 if lost := core.LostFormats(run.b.advertised, next.DMABuf().Formats); lost > 0 {
173173 run.log.Warn().Str("card", run.b.renderInfo.Path).Int("lost_formats", lost).Msg("render device lost advertised formats")
174174 }
@@ -162,13 +162,13 @@ func (run *outputsRun) finishRecovery() (error, bool) {
162 return nil, false162 return nil, false
163 }163 }
164 old := run.b.render164 old := run.b.render
165- run.b.render = nil // failure cleanup must not close the lost device again.165+ run.b.setRender(nil) // failure cleanup must not close the lost device again.
166 run.log.Warn().Str("card", run.b.renderInfo.Path).Msg("render device lost, reopening")166 run.log.Warn().Str("card", run.b.renderInfo.Path).Msg("render device lost, reopening")
167 next, reopenErr := reopenRender(run.b.opener, run.b.renderInfo, old, &run.policy.ReopenLimiter)167 next, reopenErr := reopenRender(run.b.opener, run.b.renderInfo, old, &run.policy.ReopenLimiter)
168 if reopenErr != nil {168 if reopenErr != nil {
169 return errors.Join(reopenErr, run.set.Wait()), true169 return errors.Join(reopenErr, run.set.Wait()), true
170 }170 }
171- run.b.render = next171+ run.b.setRender(next)
172 if lost := core.LostFormats(run.b.advertised, next.DMABuf().Formats); lost > 0 {172 if lost := core.LostFormats(run.b.advertised, next.DMABuf().Formats); lost > 0 {
173 run.log.Warn().Str("card", run.b.renderInfo.Path).Int("lost_formats", lost).Msg("render device lost advertised formats")173 run.log.Warn().Str("card", run.b.renderInfo.Path).Int("lost_formats", lost).Msg("render device lost advertised formats")
174 }174 }
A internal/adapters/drm/supervisor/renderdevice_test.go +46 -0
@@ -0,0 +1,46 @@
1+package supervisor
2+
3+import (
4+ "sync"
5+ "testing"
6+ "testing/synctest"
7+
8+ portsmocks "github.com/bnema/neferwl/internal/mocks/ports"
9+ "github.com/stretchr/testify/require"
10+)
11+
12+func TestRenderDeviceConcurrentPublication(t *testing.T) {
13+ synctest.Test(t, func(t *testing.T) {
14+ a := portsmocks.NewMockRenderDevice(t)
15+ b := portsmocks.NewMockRenderDevice(t)
16+ backend := &Backend{}
17+ require.Nil(t, backend.RenderDevice())
18+ backend.setRender(a)
19+ require.Same(t, a, backend.RenderDevice())
20+ start := make(chan struct{})
21+ var readers sync.WaitGroup
22+ for range 4 {
23+ readers.Go(func() {
24+ <-start
25+ for range 10000 {
26+ dev := backend.RenderDevice()
27+ if dev != nil && dev != a && dev != b {
28+ t.Error("unexpected published render device")
29+ return
30+ }
31+ }
32+ })
33+ }
34+ close(start)
35+ for range 10000 {
36+ backend.setRender(nil)
37+ backend.setRender(b)
38+ backend.setRender(a)
39+ }
40+ readers.Wait()
41+ backend.setRender(nil)
42+ require.Nil(t, backend.RenderDevice())
43+ backend.setRender(b)
44+ require.Same(t, b, backend.RenderDevice())
45+ })
46+}
@@ -0,0 +1,46 @@
1+package supervisor
2+
3+import (
4+ "sync"
5+ "testing"
6+ "testing/synctest"
7+
8+ portsmocks "github.com/bnema/neferwl/internal/mocks/ports"
9+ "github.com/stretchr/testify/require"
10+)
11+
12+func TestRenderDeviceConcurrentPublication(t *testing.T) {
13+ synctest.Test(t, func(t *testing.T) {
14+ a := portsmocks.NewMockRenderDevice(t)
15+ b := portsmocks.NewMockRenderDevice(t)
16+ backend := &Backend{}
17+ require.Nil(t, backend.RenderDevice())
18+ backend.setRender(a)
19+ require.Same(t, a, backend.RenderDevice())
20+ start := make(chan struct{})
21+ var readers sync.WaitGroup
22+ for range 4 {
23+ readers.Go(func() {
24+ <-start
25+ for range 10000 {
26+ dev := backend.RenderDevice()
27+ if dev != nil && dev != a && dev != b {
28+ t.Error("unexpected published render device")
29+ return
30+ }
31+ }
32+ })
33+ }
34+ close(start)
35+ for range 10000 {
36+ backend.setRender(nil)
37+ backend.setRender(b)
38+ backend.setRender(a)
39+ }
40+ readers.Wait()
41+ backend.setRender(nil)
42+ require.Nil(t, backend.RenderDevice())
43+ backend.setRender(b)
44+ require.Same(t, b, backend.RenderDevice())
45+ })
46+}
M internal/adapters/drm/supervisor/supervisor.go +30 -11
@@ -113,14 +113,15 @@ const applyTimeout = 5 * time.Second
113113
114114 // Backend is the seat and the cards with at least one usable output.
115115 type Backend struct {
116- startupConfig domain.Config
117- selectConfig core.GPUSelectConfig
118- render ports.RenderDevice
119- opener ports.RenderDeviceOpener
120- renderInfo domain.GPUInfo
121- advertised []domain.DMABufFormat
122- seat *seat.Seat
123- cards []*drmCard
116+ startupConfig domain.Config
117+ selectConfig core.GPUSelectConfig
118+ render ports.RenderDevice // supervisor-owned; cross-goroutine readers use publishedRender
119+ publishedRender atomic.Pointer[renderDeviceSnapshot]
120+ opener ports.RenderDeviceOpener
121+ renderInfo domain.GPUInfo
122+ advertised []domain.DMABufFormat
123+ seat *seat.Seat
124+ cards []*drmCard
124125 // dying holds unplugged cards until their outputs are stopped. Only the
125126 // runOutputs goroutine touches it; close reads it after that returns.
126127 dying map[*drmCard]*core.CardTeardown
@@ -281,7 +282,8 @@ func Open(ctx context.Context, cfg domain.Config, opener ports.RenderDeviceOpene
281282 s.Close()
282283 return nil, err
283284 }
284- b.render, b.renderInfo = render, info
285+ b.setRender(render)
286+ b.renderInfo = info
285287 b.advertised = append([]domain.DMABufFormat(nil), render.DMABuf().Formats...)
286288 want.Sampled = render.DMABuf().Formats
287289 var errs []error
@@ -506,8 +508,25 @@ func safe(name string, fn func() error) (err error) {
506508 return fn()
507509 }
508510
509-func (b *Backend) RenderDevice() ports.RenderDevice { return b.render }
510-func (b *Backend) Seat() *seat.Seat { return b.seat }
511+// renderDeviceSnapshot wraps the interface so nil and different concrete device
512+// types can be published atomically without atomic.Value's type restrictions.
513+type renderDeviceSnapshot struct{ device ports.RenderDevice }
514+
515+// setRender is called only by the supervisor, preserving recovery ordering.
516+func (b *Backend) setRender(device ports.RenderDevice) {
517+ b.render = device
518+ b.publishedRender.Store(&renderDeviceSnapshot{device: device})
519+}
520+
521+// RenderDevice returns the published device, or nil while recovery reopens it.
522+// Publication protects the interface, not the lifetime of the returned device.
523+func (b *Backend) RenderDevice() ports.RenderDevice {
524+ if snapshot := b.publishedRender.Load(); snapshot != nil {
525+ return snapshot.device
526+ }
527+ return nil
528+}
529+func (b *Backend) Seat() *seat.Seat { return b.seat }
511530
512531 func logOutputApplied(heads []domain.HeadChange, log zerowrap.Logger) {
513532 for _, h := range heads {
@@ -113,14 +113,15 @@ const applyTimeout = 5 * time.Second
113 113
114 // Backend is the seat and the cards with at least one usable output.114 // Backend is the seat and the cards with at least one usable output.
115 type Backend struct {115 type Backend struct {
116- startupConfig domain.Config116+ startupConfig domain.Config
117- selectConfig core.GPUSelectConfig117+ selectConfig core.GPUSelectConfig
118- render ports.RenderDevice118+ render ports.RenderDevice // supervisor-owned; cross-goroutine readers use publishedRender
119- opener ports.RenderDeviceOpener119+ publishedRender atomic.Pointer[renderDeviceSnapshot]
120- renderInfo domain.GPUInfo120+ opener ports.RenderDeviceOpener
121- advertised []domain.DMABufFormat121+ renderInfo domain.GPUInfo
122- seat *seat.Seat122+ advertised []domain.DMABufFormat
123- cards []*drmCard123+ seat *seat.Seat
124+ cards []*drmCard
124 // dying holds unplugged cards until their outputs are stopped. Only the125 // dying holds unplugged cards until their outputs are stopped. Only the
125 // runOutputs goroutine touches it; close reads it after that returns.126 // runOutputs goroutine touches it; close reads it after that returns.
126 dying map[*drmCard]*core.CardTeardown127 dying map[*drmCard]*core.CardTeardown
@@ -281,7 +282,8 @@ func Open(ctx context.Context, cfg domain.Config, opener ports.RenderDeviceOpene
281 s.Close()282 s.Close()
282 return nil, err283 return nil, err
283 }284 }
284- b.render, b.renderInfo = render, info285+ b.setRender(render)
286+ b.renderInfo = info
285 b.advertised = append([]domain.DMABufFormat(nil), render.DMABuf().Formats...)287 b.advertised = append([]domain.DMABufFormat(nil), render.DMABuf().Formats...)
286 want.Sampled = render.DMABuf().Formats288 want.Sampled = render.DMABuf().Formats
287 var errs []error289 var errs []error
@@ -506,8 +508,25 @@ func safe(name string, fn func() error) (err error) {
506 return fn()508 return fn()
507 }509 }
508 510
509-func (b *Backend) RenderDevice() ports.RenderDevice { return b.render }511+// renderDeviceSnapshot wraps the interface so nil and different concrete device
510-func (b *Backend) Seat() *seat.Seat { return b.seat }512+// types can be published atomically without atomic.Value's type restrictions.
513+type renderDeviceSnapshot struct{ device ports.RenderDevice }
514+
515+// setRender is called only by the supervisor, preserving recovery ordering.
516+func (b *Backend) setRender(device ports.RenderDevice) {
517+ b.render = device
518+ b.publishedRender.Store(&renderDeviceSnapshot{device: device})
519+}
520+
521+// RenderDevice returns the published device, or nil while recovery reopens it.
522+// Publication protects the interface, not the lifetime of the returned device.
523+func (b *Backend) RenderDevice() ports.RenderDevice {
524+ if snapshot := b.publishedRender.Load(); snapshot != nil {
525+ return snapshot.device
526+ }
527+ return nil
528+}
529+func (b *Backend) Seat() *seat.Seat { return b.seat }
511 530
512 func logOutputApplied(heads []domain.HeadChange, log zerowrap.Logger) {531 func logOutputApplied(heads []domain.HeadChange, log zerowrap.Logger) {
513 for _, h := range heads {532 for _, h := range heads {
M internal/adapters/headless/continuous_test.go +107 -0
@@ -4,6 +4,7 @@ import (
44 "context"
55 "github.com/bnema/neferwl/internal/domain"
66 "github.com/bnema/neferwl/internal/ports"
7+ "image"
78 "os"
89 "path/filepath"
910 "testing"
@@ -81,3 +82,109 @@ func TestContinuousCaptureWritesIdleFrame(t *testing.T) {
8182 }
8283 })
8384 }
85+
86+func TestContinuousCaptureWriteFailureKeepsOutputRunning(t *testing.T) {
87+ synctest.Test(t, func(t *testing.T) {
88+ r, frames := recordingRenderer(t, nil)
89+ ctx, cancel := context.WithCancel(context.Background())
90+ defer cancel()
91+ scenes := make(chan domain.Scene)
92+ changes := make(chan ports.OutputContinuous)
93+ done := make(chan error, 1)
94+ go func() {
95+ done <- RunOutput(ctx, Options{Width: 2, Height: 2, Continuous: changes, NewRenderer: func(int, int) (ports.Renderer, error) { return r, nil }}, scenes, nil, nil, nil, nil)
96+ }()
97+ ack := make(chan ports.ContinuousCaptureResult, 1)
98+ // /proc exists but cannot hold capture files, even when tests run as root.
99+ changes <- ports.OutputContinuous{Dir: "/proc", Reply: ack}
100+ if result := <-ack; result.Err != ports.ControlErrCaptureFailed {
101+ t.Fatalf("unwritable directory: %+v", result)
102+ }
103+ dir := t.TempDir()
104+ changes <- ports.OutputContinuous{Dir: dir, Reply: ack}
105+ if result := <-ack; result.Err != "" {
106+ t.Fatal(result)
107+ }
108+ // Fail the first write after successful admission, without permissions
109+ // depending on the user running the test.
110+ if err := os.Remove(dir); err != nil {
111+ t.Fatal(err)
112+ }
113+ scenes <- domain.Scene{Seq: 1, Scale: 1, OutputWidth: 2, OutputHeight: 2}
114+ waitFrames(t, frames, 1)
115+ synctest.Wait()
116+ // Recreate the directory: a disabled writer must not resume writing.
117+ if err := os.Mkdir(dir, 0o700); err != nil {
118+ t.Fatal(err)
119+ }
120+ scenes <- domain.Scene{Seq: 2, Scale: 1, OutputWidth: 2, OutputHeight: 2}
121+ waitFrames(t, frames, 2)
122+ synctest.Wait()
123+ entries, err := os.ReadDir(dir)
124+ if err != nil {
125+ t.Fatal(err)
126+ }
127+ if len(entries) != 0 {
128+ t.Fatal("failed recording resumed", entries)
129+ }
130+ cancel()
131+ if err := <-done; err != nil {
132+ t.Fatal(err)
133+ }
134+ })
135+}
136+
137+func TestContinuousRawHDRLiveTransition(t *testing.T) {
138+ synctest.Test(t, func(t *testing.T) {
139+ ctx, cancel := context.WithCancel(context.Background())
140+ defer cancel()
141+ sdr, _ := recordingRenderer(t, nil)
142+ hdr, _ := recordingRenderer(t, nil)
143+ target, err := os.CreateTemp(t.TempDir(), "hdr-target")
144+ if err != nil {
145+ t.Fatal(err)
146+ }
147+ hdr.EXPECT().SetHDR(float64(203)).Return().Once()
148+ hdr.EXPECT().ExportTargets(1, []uint64(nil), false).Return([]domain.DMABuf{{Planes: []domain.DMABufPlane{{File: target}}}}, nil).Once()
149+ hdr.EXPECT().HDRPixels().Return(image.NewRGBA64(image.Rect(0, 0, 2, 2))).Once()
150+ scenes := make(chan domain.Scene)
151+ changes := make(chan ports.OutputContinuous)
152+ modes := make(chan ModeRequest)
153+ done := make(chan error, 1)
154+ calls := 0
155+ go func() {
156+ done <- RunOutput(ctx, Options{Width: 2, Height: 2, Continuous: changes, ModeRequests: modes, NewRenderer: func(int, int) (ports.Renderer, error) {
157+ calls++
158+ if calls == 1 {
159+ return sdr, nil
160+ }
161+ return hdr, nil
162+ }}, scenes, nil, nil, nil, nil)
163+ }()
164+ dir := t.TempDir()
165+ ack := make(chan ports.ContinuousCaptureResult, 1)
166+ changes <- ports.OutputContinuous{Dir: dir, Raw: true, Reply: ack}
167+ if result := <-ack; result.Err != "" {
168+ t.Fatal(result)
169+ }
170+ scenes <- domain.Scene{Seq: 1, Scale: 1, OutputWidth: 2, OutputHeight: 2}
171+ synctest.Wait()
172+ if _, err := os.Stat(filepath.Join(dir, "latest-pq.png")); !os.IsNotExist(err) {
173+ t.Fatal("SDR wrote PQ", err)
174+ }
175+ reply := make(chan error, 1)
176+ settings := domain.OutputHDRSettings{Enabled: true}
177+ modes <- ModeRequest{HDR: &settings, Result: reply}
178+ if err := <-reply; err != nil {
179+ t.Fatal(err)
180+ }
181+ synctest.Wait()
182+ if _, err := os.Stat(filepath.Join(dir, "latest-pq.png")); err != nil {
183+ t.Fatal("live HDR wrote no PQ", err)
184+ }
185+ cancel()
186+ if err := <-done; err != nil {
187+ t.Fatal(err)
188+ }
189+ })
190+}
@@ -4,6 +4,7 @@ import (
4 "context"4 "context"
5 "github.com/bnema/neferwl/internal/domain"5 "github.com/bnema/neferwl/internal/domain"
6 "github.com/bnema/neferwl/internal/ports"6 "github.com/bnema/neferwl/internal/ports"
7+ "image"
7 "os"8 "os"
8 "path/filepath"9 "path/filepath"
9 "testing"10 "testing"
@@ -81,3 +82,109 @@ func TestContinuousCaptureWritesIdleFrame(t *testing.T) {
81 }82 }
82 })83 })
83 }84 }
85+
86+func TestContinuousCaptureWriteFailureKeepsOutputRunning(t *testing.T) {
87+ synctest.Test(t, func(t *testing.T) {
88+ r, frames := recordingRenderer(t, nil)
89+ ctx, cancel := context.WithCancel(context.Background())
90+ defer cancel()
91+ scenes := make(chan domain.Scene)
92+ changes := make(chan ports.OutputContinuous)
93+ done := make(chan error, 1)
94+ go func() {
95+ done <- RunOutput(ctx, Options{Width: 2, Height: 2, Continuous: changes, NewRenderer: func(int, int) (ports.Renderer, error) { return r, nil }}, scenes, nil, nil, nil, nil)
96+ }()
97+ ack := make(chan ports.ContinuousCaptureResult, 1)
98+ // /proc exists but cannot hold capture files, even when tests run as root.
99+ changes <- ports.OutputContinuous{Dir: "/proc", Reply: ack}
100+ if result := <-ack; result.Err != ports.ControlErrCaptureFailed {
101+ t.Fatalf("unwritable directory: %+v", result)
102+ }
103+ dir := t.TempDir()
104+ changes <- ports.OutputContinuous{Dir: dir, Reply: ack}
105+ if result := <-ack; result.Err != "" {
106+ t.Fatal(result)
107+ }
108+ // Fail the first write after successful admission, without permissions
109+ // depending on the user running the test.
110+ if err := os.Remove(dir); err != nil {
111+ t.Fatal(err)
112+ }
113+ scenes <- domain.Scene{Seq: 1, Scale: 1, OutputWidth: 2, OutputHeight: 2}
114+ waitFrames(t, frames, 1)
115+ synctest.Wait()
116+ // Recreate the directory: a disabled writer must not resume writing.
117+ if err := os.Mkdir(dir, 0o700); err != nil {
118+ t.Fatal(err)
119+ }
120+ scenes <- domain.Scene{Seq: 2, Scale: 1, OutputWidth: 2, OutputHeight: 2}
121+ waitFrames(t, frames, 2)
122+ synctest.Wait()
123+ entries, err := os.ReadDir(dir)
124+ if err != nil {
125+ t.Fatal(err)
126+ }
127+ if len(entries) != 0 {
128+ t.Fatal("failed recording resumed", entries)
129+ }
130+ cancel()
131+ if err := <-done; err != nil {
132+ t.Fatal(err)
133+ }
134+ })
135+}
136+
137+func TestContinuousRawHDRLiveTransition(t *testing.T) {
138+ synctest.Test(t, func(t *testing.T) {
139+ ctx, cancel := context.WithCancel(context.Background())
140+ defer cancel()
141+ sdr, _ := recordingRenderer(t, nil)
142+ hdr, _ := recordingRenderer(t, nil)
143+ target, err := os.CreateTemp(t.TempDir(), "hdr-target")
144+ if err != nil {
145+ t.Fatal(err)
146+ }
147+ hdr.EXPECT().SetHDR(float64(203)).Return().Once()
148+ hdr.EXPECT().ExportTargets(1, []uint64(nil), false).Return([]domain.DMABuf{{Planes: []domain.DMABufPlane{{File: target}}}}, nil).Once()
149+ hdr.EXPECT().HDRPixels().Return(image.NewRGBA64(image.Rect(0, 0, 2, 2))).Once()
150+ scenes := make(chan domain.Scene)
151+ changes := make(chan ports.OutputContinuous)
152+ modes := make(chan ModeRequest)
153+ done := make(chan error, 1)
154+ calls := 0
155+ go func() {
156+ done <- RunOutput(ctx, Options{Width: 2, Height: 2, Continuous: changes, ModeRequests: modes, NewRenderer: func(int, int) (ports.Renderer, error) {
157+ calls++
158+ if calls == 1 {
159+ return sdr, nil
160+ }
161+ return hdr, nil
162+ }}, scenes, nil, nil, nil, nil)
163+ }()
164+ dir := t.TempDir()
165+ ack := make(chan ports.ContinuousCaptureResult, 1)
166+ changes <- ports.OutputContinuous{Dir: dir, Raw: true, Reply: ack}
167+ if result := <-ack; result.Err != "" {
168+ t.Fatal(result)
169+ }
170+ scenes <- domain.Scene{Seq: 1, Scale: 1, OutputWidth: 2, OutputHeight: 2}
171+ synctest.Wait()
172+ if _, err := os.Stat(filepath.Join(dir, "latest-pq.png")); !os.IsNotExist(err) {
173+ t.Fatal("SDR wrote PQ", err)
174+ }
175+ reply := make(chan error, 1)
176+ settings := domain.OutputHDRSettings{Enabled: true}
177+ modes <- ModeRequest{HDR: &settings, Result: reply}
178+ if err := <-reply; err != nil {
179+ t.Fatal(err)
180+ }
181+ synctest.Wait()
182+ if _, err := os.Stat(filepath.Join(dir, "latest-pq.png")); err != nil {
183+ t.Fatal("live HDR wrote no PQ", err)
184+ }
185+ cancel()
186+ if err := <-done; err != nil {
187+ t.Fatal(err)
188+ }
189+ })
190+}
M internal/adapters/headless/output.go +29 -6
@@ -13,6 +13,7 @@ import (
1313
1414 "bnema.dev/zerowrap"
1515 "github.com/bnema/neferwl/internal/adapters/clock"
16+ "github.com/bnema/neferwl/internal/adapters/logging"
1617 "github.com/bnema/neferwl/internal/adapters/outputkit/capture"
1718 "github.com/bnema/neferwl/internal/adapters/outputkit/corewake"
1819 "github.com/bnema/neferwl/internal/adapters/outputkit/presented"
@@ -555,9 +556,11 @@ func RunOutput(ctx context.Context, opts Options, scenes <-chan domain.Scene, co
555556 if opts.protected() {
556557 code = ports.ControlErrLocked
557558 } else if !req.Stop {
558- if req.Dir == "" {
559+ if writer.dir != "" {
559560 code = ports.ControlErrBadRequest
560- } else if err := os.MkdirAll(req.Dir, 0o700); err != nil {
561+ } else if req.Dir == "" {
562+ code = ports.ControlErrBadRequest
563+ } else if err := prepareRecordingDir(req.Dir); err != nil {
561564 code = ports.ControlErrCaptureFailed
562565 }
563566 }
@@ -868,9 +871,12 @@ func RunOutput(ctx context.Context, opts Options, scenes <-chan domain.Scene, co
868871 presentedSeq = max(presentedSeq, scene.Seq)
869872 reportFrame(scene.Animating)
870873 if writer.dir != "" && !opts.protected() {
871- skipped, err := writer.write(opts, r, scene, frame)
874+ skipped, err := writer.write(opts, r, scene, frame, confirmed != nil)
872875 if err != nil {
873- return err
876+ writer.close()
877+ writer = frameWriter{}
878+ log := logging.For(ctx, "headless")
879+ log.Warn().Str("output", opts.Name).Err(err).Msg("continuous capture stopped")
874880 }
875881 if skipped {
876882 continue
@@ -882,6 +888,23 @@ func RunOutput(ctx context.Context, opts Options, scenes <-chan domain.Scene, co
882888 }
883889 }
884890
891+// prepareRecordingDir checks write access before acknowledging a recording.
892+func prepareRecordingDir(dir string) error {
893+ if err := os.MkdirAll(dir, 0o700); err != nil {
894+ return err
895+ }
896+ f, err := os.CreateTemp(dir, ".capture-*")
897+ if err != nil {
898+ return err
899+ }
900+ closeErr := f.Close()
901+ removeErr := os.Remove(f.Name())
902+ if closeErr != nil {
903+ return closeErr
904+ }
905+ return removeErr
906+}
907+
885908 // frameWriter is the continuous capture state of one output: where frames go
886909 // and the ffconcat index being written.
887910 type frameWriter struct {
@@ -908,7 +931,7 @@ func (w *frameWriter) close() {
908931
909932 // write saves the presented frame. skipped reports a frame not written (the
910933 // security epoch moved, or no readback); the caller then skips its frame log.
911-func (w *frameWriter) write(opts Options, r ports.Renderer, scene domain.Scene, frame int) (skipped bool, err error) {
934+func (w *frameWriter) write(opts Options, r ports.Renderer, scene domain.Scene, frame int, hdrConfirmed bool) (skipped bool, err error) {
912935 shot := r.Pixels()
913936 if opts.protected() || opts.Security != nil && opts.Security.Snapshot() != scene.Security {
914937 return true, nil
@@ -958,7 +981,7 @@ func (w *frameWriter) write(opts Options, r ports.Renderer, scene domain.Scene,
958981 return false, fmt.Errorf("frame index: %w", err)
959982 }
960983 w.lastShot, w.lastShotName = now, name
961- if w.raw && opts.HDR.Enabled {
984+ if w.raw && hdrConfirmed {
962985 // No cursor on the raw image. Only a confirmed HDR output
963986 // has a readable PQ target; else HDRPixels is nil.
964987 if opts.protected() || opts.Security != nil && opts.Security.Snapshot() != scene.Security {
@@ -13,6 +13,7 @@ import (
13 13
14 "bnema.dev/zerowrap"14 "bnema.dev/zerowrap"
15 "github.com/bnema/neferwl/internal/adapters/clock"15 "github.com/bnema/neferwl/internal/adapters/clock"
16+ "github.com/bnema/neferwl/internal/adapters/logging"
16 "github.com/bnema/neferwl/internal/adapters/outputkit/capture"17 "github.com/bnema/neferwl/internal/adapters/outputkit/capture"
17 "github.com/bnema/neferwl/internal/adapters/outputkit/corewake"18 "github.com/bnema/neferwl/internal/adapters/outputkit/corewake"
18 "github.com/bnema/neferwl/internal/adapters/outputkit/presented"19 "github.com/bnema/neferwl/internal/adapters/outputkit/presented"
@@ -555,9 +556,11 @@ func RunOutput(ctx context.Context, opts Options, scenes <-chan domain.Scene, co
555 if opts.protected() {556 if opts.protected() {
556 code = ports.ControlErrLocked557 code = ports.ControlErrLocked
557 } else if !req.Stop {558 } else if !req.Stop {
558- if req.Dir == "" {559+ if writer.dir != "" {
559 code = ports.ControlErrBadRequest560 code = ports.ControlErrBadRequest
560- } else if err := os.MkdirAll(req.Dir, 0o700); err != nil {561+ } else if req.Dir == "" {
562+ code = ports.ControlErrBadRequest
563+ } else if err := prepareRecordingDir(req.Dir); err != nil {
561 code = ports.ControlErrCaptureFailed564 code = ports.ControlErrCaptureFailed
562 }565 }
563 }566 }
@@ -868,9 +871,12 @@ func RunOutput(ctx context.Context, opts Options, scenes <-chan domain.Scene, co
868 presentedSeq = max(presentedSeq, scene.Seq)871 presentedSeq = max(presentedSeq, scene.Seq)
869 reportFrame(scene.Animating)872 reportFrame(scene.Animating)
870 if writer.dir != "" && !opts.protected() {873 if writer.dir != "" && !opts.protected() {
871- skipped, err := writer.write(opts, r, scene, frame)874+ skipped, err := writer.write(opts, r, scene, frame, confirmed != nil)
872 if err != nil {875 if err != nil {
873- return err876+ writer.close()
877+ writer = frameWriter{}
878+ log := logging.For(ctx, "headless")
879+ log.Warn().Str("output", opts.Name).Err(err).Msg("continuous capture stopped")
874 }880 }
875 if skipped {881 if skipped {
876 continue882 continue
@@ -882,6 +888,23 @@ func RunOutput(ctx context.Context, opts Options, scenes <-chan domain.Scene, co
882 }888 }
883 }889 }
884 890
891+// prepareRecordingDir checks write access before acknowledging a recording.
892+func prepareRecordingDir(dir string) error {
893+ if err := os.MkdirAll(dir, 0o700); err != nil {
894+ return err
895+ }
896+ f, err := os.CreateTemp(dir, ".capture-*")
897+ if err != nil {
898+ return err
899+ }
900+ closeErr := f.Close()
901+ removeErr := os.Remove(f.Name())
902+ if closeErr != nil {
903+ return closeErr
904+ }
905+ return removeErr
906+}
907+
885 // frameWriter is the continuous capture state of one output: where frames go908 // frameWriter is the continuous capture state of one output: where frames go
886 // and the ffconcat index being written.909 // and the ffconcat index being written.
887 type frameWriter struct {910 type frameWriter struct {
@@ -908,7 +931,7 @@ func (w *frameWriter) close() {
908 931
909 // write saves the presented frame. skipped reports a frame not written (the932 // write saves the presented frame. skipped reports a frame not written (the
910 // security epoch moved, or no readback); the caller then skips its frame log.933 // security epoch moved, or no readback); the caller then skips its frame log.
911-func (w *frameWriter) write(opts Options, r ports.Renderer, scene domain.Scene, frame int) (skipped bool, err error) {934+func (w *frameWriter) write(opts Options, r ports.Renderer, scene domain.Scene, frame int, hdrConfirmed bool) (skipped bool, err error) {
912 shot := r.Pixels()935 shot := r.Pixels()
913 if opts.protected() || opts.Security != nil && opts.Security.Snapshot() != scene.Security {936 if opts.protected() || opts.Security != nil && opts.Security.Snapshot() != scene.Security {
914 return true, nil937 return true, nil
@@ -958,7 +981,7 @@ func (w *frameWriter) write(opts Options, r ports.Renderer, scene domain.Scene,
958 return false, fmt.Errorf("frame index: %w", err)981 return false, fmt.Errorf("frame index: %w", err)
959 }982 }
960 w.lastShot, w.lastShotName = now, name983 w.lastShot, w.lastShotName = now, name
961- if w.raw && opts.HDR.Enabled {984+ if w.raw && hdrConfirmed {
962 // No cursor on the raw image. Only a confirmed HDR output985 // No cursor on the raw image. Only a confirmed HDR output
963 // has a readable PQ target; else HDRPixels is nil.986 // has a readable PQ target; else HDRPixels is nil.
964 if opts.protected() || opts.Security != nil && opts.Security.Snapshot() != scene.Security {987 if opts.protected() || opts.Security != nil && opts.Security.Snapshot() != scene.Security {
M internal/adapters/logging/logging.go +32 -12
@@ -93,6 +93,11 @@ func OpenSession(ctx context.Context, id, level, debug string) (context.Context,
9393 return nil, nil, err
9494 }
9595 root := filepath.Join(state, "neferwl", "sessions")
96+ lifecycle, err := lockSessionRoot(root)
97+ if err != nil {
98+ return nil, nil, err
99+ }
100+ defer lifecycle.Close()
96101 dir := filepath.Join(root, id)
97102 if err := os.MkdirAll(dir, 0o700); err != nil {
98103 return nil, nil, err
@@ -192,7 +197,7 @@ func openDir(ctx context.Context, dir, level, debug string, lock *os.File) (_ co
192197
193198 // pruneSessions keeps the newest keepRuns session log directories of root
194199 // by modification time; current and directories whose lock is held by a
195-// live session are kept.
200+// live session are kept. The caller must hold the root lifecycle lock.
196201 func pruneSessions(root, current string) {
197202 entries, err := os.ReadDir(root)
198203 if err != nil {
@@ -219,25 +224,40 @@ func pruneSessions(root, current string) {
219224 }
220225 sort.Slice(old, func(i, j int) bool { return old[i].mod.After(old[j].mod) })
221226 for _, s := range old[keepRuns-1:] {
222- if sessionLive(s.path) {
223- continue
224- }
225- _ = os.RemoveAll(s.path)
227+ removeSession(s.path)
228+ }
229+}
230+
231+// lockSessionRoot serializes directory creation and pruning. The root lock file
232+// is never removed: every opener must lock the same inode before touching a
233+// session directory, then acquire its session lock before releasing this lock.
234+func lockSessionRoot(root string) (*os.File, error) {
235+ if err := os.MkdirAll(root, 0o700); err != nil {
236+ return nil, err
237+ }
238+ f, err := os.OpenFile(filepath.Join(root, ".lock"), os.O_CREATE|os.O_RDWR, 0o600)
239+ if err != nil {
240+ return nil, err
226241 }
242+ if err := syscall.Flock(int(f.Fd()), syscall.LOCK_EX); err != nil {
243+ _ = f.Close()
244+ return nil, err
245+ }
246+ return f, nil
227247 }
228248
229-// sessionLive reports whether another process holds the directory's lock.
230-func sessionLive(dir string) bool {
231- f, err := os.OpenFile(filepath.Join(dir, "lock"), os.O_RDWR, 0)
249+// removeSession holds the session lock through removal. On any lock error,
250+// conservatively keep the directory. The caller must hold the root lock.
251+func removeSession(dir string) {
252+ f, err := os.OpenFile(filepath.Join(dir, "lock"), os.O_CREATE|os.O_RDWR, 0o600)
232253 if err != nil {
233- return false
254+ return
234255 }
235256 defer f.Close()
236257 if err := syscall.Flock(int(f.Fd()), syscall.LOCK_EX|syscall.LOCK_NB); err != nil {
237- return true
258+ return
238259 }
239- _ = syscall.Flock(int(f.Fd()), syscall.LOCK_UN)
240- return false
260+ _ = os.RemoveAll(dir)
241261 }
242262
243263 // logQueue is how many entries may wait for the disk. Past it, entries are
@@ -93,6 +93,11 @@ func OpenSession(ctx context.Context, id, level, debug string) (context.Context,
93 return nil, nil, err93 return nil, nil, err
94 }94 }
95 root := filepath.Join(state, "neferwl", "sessions")95 root := filepath.Join(state, "neferwl", "sessions")
96+ lifecycle, err := lockSessionRoot(root)
97+ if err != nil {
98+ return nil, nil, err
99+ }
100+ defer lifecycle.Close()
96 dir := filepath.Join(root, id)101 dir := filepath.Join(root, id)
97 if err := os.MkdirAll(dir, 0o700); err != nil {102 if err := os.MkdirAll(dir, 0o700); err != nil {
98 return nil, nil, err103 return nil, nil, err
@@ -192,7 +197,7 @@ func openDir(ctx context.Context, dir, level, debug string, lock *os.File) (_ co
192 197
193 // pruneSessions keeps the newest keepRuns session log directories of root198 // pruneSessions keeps the newest keepRuns session log directories of root
194 // by modification time; current and directories whose lock is held by a199 // by modification time; current and directories whose lock is held by a
195-// live session are kept.200+// live session are kept. The caller must hold the root lifecycle lock.
196 func pruneSessions(root, current string) {201 func pruneSessions(root, current string) {
197 entries, err := os.ReadDir(root)202 entries, err := os.ReadDir(root)
198 if err != nil {203 if err != nil {
@@ -219,25 +224,40 @@ func pruneSessions(root, current string) {
219 }224 }
220 sort.Slice(old, func(i, j int) bool { return old[i].mod.After(old[j].mod) })225 sort.Slice(old, func(i, j int) bool { return old[i].mod.After(old[j].mod) })
221 for _, s := range old[keepRuns-1:] {226 for _, s := range old[keepRuns-1:] {
222- if sessionLive(s.path) {227+ removeSession(s.path)
223- continue228+ }
224- }229+}
225- _ = os.RemoveAll(s.path)230+
231+// lockSessionRoot serializes directory creation and pruning. The root lock file
232+// is never removed: every opener must lock the same inode before touching a
233+// session directory, then acquire its session lock before releasing this lock.
234+func lockSessionRoot(root string) (*os.File, error) {
235+ if err := os.MkdirAll(root, 0o700); err != nil {
236+ return nil, err
237+ }
238+ f, err := os.OpenFile(filepath.Join(root, ".lock"), os.O_CREATE|os.O_RDWR, 0o600)
239+ if err != nil {
240+ return nil, err
226 }241 }
242+ if err := syscall.Flock(int(f.Fd()), syscall.LOCK_EX); err != nil {
243+ _ = f.Close()
244+ return nil, err
245+ }
246+ return f, nil
227 }247 }
228 248
229-// sessionLive reports whether another process holds the directory's lock.249+// removeSession holds the session lock through removal. On any lock error,
230-func sessionLive(dir string) bool {250+// conservatively keep the directory. The caller must hold the root lock.
231- f, err := os.OpenFile(filepath.Join(dir, "lock"), os.O_RDWR, 0)251+func removeSession(dir string) {
252+ f, err := os.OpenFile(filepath.Join(dir, "lock"), os.O_CREATE|os.O_RDWR, 0o600)
232 if err != nil {253 if err != nil {
233- return false254+ return
234 }255 }
235 defer f.Close()256 defer f.Close()
236 if err := syscall.Flock(int(f.Fd()), syscall.LOCK_EX|syscall.LOCK_NB); err != nil {257 if err := syscall.Flock(int(f.Fd()), syscall.LOCK_EX|syscall.LOCK_NB); err != nil {
237- return true258+ return
238 }259 }
239- _ = syscall.Flock(int(f.Fd()), syscall.LOCK_UN)260+ _ = os.RemoveAll(dir)
240- return false
241 }261 }
242 262
243 // logQueue is how many entries may wait for the disk. Past it, entries are263 // logQueue is how many entries may wait for the disk. Past it, entries are
M internal/adapters/logging/logging_test.go +32 -1
@@ -295,7 +295,9 @@ func TestOpenSessionPrunesOldSessions(t *testing.T) {
295295 }
296296 var names []string
297297 for _, e := range entries {
298- names = append(names, e.Name())
298+ if e.IsDir() {
299+ names = append(names, e.Name())
300+ }
299301 }
300302 // current + the newest keepRuns-1 others + live s-00.
301303 want := []string{"current", "s-00"}
@@ -312,3 +314,32 @@ func TestOpenSessionPrunesOldSessions(t *testing.T) {
312314 }
313315 }
314316 }
317+
318+// Root lifecycle ownership excludes other openers and pruners on the same
319+// inode, including after release and reacquisition. No scheduling or waits
320+// are needed to probe real flock exclusion.
321+func TestSessionLifecycleLock(t *testing.T) {
322+ root := t.TempDir()
323+ for range 2 {
324+ owner, err := lockSessionRoot(root)
325+ if err != nil {
326+ t.Fatal(err)
327+ }
328+ probe, err := os.OpenFile(filepath.Join(root, ".lock"), os.O_RDWR, 0)
329+ if err != nil {
330+ _ = owner.Close()
331+ t.Fatal(err)
332+ }
333+ err = syscall.Flock(int(probe.Fd()), syscall.LOCK_EX|syscall.LOCK_NB)
334+ if err != syscall.EWOULDBLOCK {
335+ t.Errorf("lifecycle lock not exclusive: %v", err)
336+ }
337+ if err := owner.Close(); err != nil {
338+ t.Fatal(err)
339+ }
340+ if err := syscall.Flock(int(probe.Fd()), syscall.LOCK_EX|syscall.LOCK_NB); err != nil {
341+ t.Errorf("lifecycle lock not released: %v", err)
342+ }
343+ _ = probe.Close()
344+ }
345+}
@@ -295,7 +295,9 @@ func TestOpenSessionPrunesOldSessions(t *testing.T) {
295 }295 }
296 var names []string296 var names []string
297 for _, e := range entries {297 for _, e := range entries {
298- names = append(names, e.Name())298+ if e.IsDir() {
299+ names = append(names, e.Name())
300+ }
299 }301 }
300 // current + the newest keepRuns-1 others + live s-00.302 // current + the newest keepRuns-1 others + live s-00.
301 want := []string{"current", "s-00"}303 want := []string{"current", "s-00"}
@@ -312,3 +314,32 @@ func TestOpenSessionPrunesOldSessions(t *testing.T) {
312 }314 }
313 }315 }
314 }316 }
317+
318+// Root lifecycle ownership excludes other openers and pruners on the same
319+// inode, including after release and reacquisition. No scheduling or waits
320+// are needed to probe real flock exclusion.
321+func TestSessionLifecycleLock(t *testing.T) {
322+ root := t.TempDir()
323+ for range 2 {
324+ owner, err := lockSessionRoot(root)
325+ if err != nil {
326+ t.Fatal(err)
327+ }
328+ probe, err := os.OpenFile(filepath.Join(root, ".lock"), os.O_RDWR, 0)
329+ if err != nil {
330+ _ = owner.Close()
331+ t.Fatal(err)
332+ }
333+ err = syscall.Flock(int(probe.Fd()), syscall.LOCK_EX|syscall.LOCK_NB)
334+ if err != syscall.EWOULDBLOCK {
335+ t.Errorf("lifecycle lock not exclusive: %v", err)
336+ }
337+ if err := owner.Close(); err != nil {
338+ t.Fatal(err)
339+ }
340+ if err := syscall.Flock(int(probe.Fd()), syscall.LOCK_EX|syscall.LOCK_NB); err != nil {
341+ t.Errorf("lifecycle lock not released: %v", err)
342+ }
343+ _ = probe.Close()
344+ }
345+}
M internal/adapters/outputkit/headlessbackend/backend.go +2 -1
@@ -45,7 +45,8 @@ func Run(ctx context.Context, o BackendOptions, apply *core.OutputApply, ch rout
4545 cur := &headless.Cursor{}
4646 curs.Set(name, cur)
4747 opts := headless.Options{Continuous: writer, Cursor: cur, LoadCursor: xcursor.LoadCursor, Width: size[0], Height: size[1], HDR: domain.OutputHDRSettings{Enabled: o.HDR}.Normalized(), Formats: ch.Formats, Log: log, NewRenderer: newRenderer, NewCaptureRenderer: newRenderer, Name: name, Presented: ch.Presented, Frames: ch.Frames, Events: ch.Events, Captured: ch.Captured}
48- if !headless.StartOutput(ctx, set, ch, domain.OutputInfo{Name: name, Width: size[0], Height: size[1]}, opts) {
48+ opts.SetMode(size[0], size[1], 60000)
49+ if !headless.StartOutput(ctx, set, ch, domain.OutputInfo{Name: name, Width: size[0], Height: size[1], RefreshMilli: 60000}, opts) {
4950 return set.Wait()
5051 }
5152 }
@@ -45,7 +45,8 @@ func Run(ctx context.Context, o BackendOptions, apply *core.OutputApply, ch rout
45 cur := &headless.Cursor{}45 cur := &headless.Cursor{}
46 curs.Set(name, cur)46 curs.Set(name, cur)
47 opts := headless.Options{Continuous: writer, Cursor: cur, LoadCursor: xcursor.LoadCursor, Width: size[0], Height: size[1], HDR: domain.OutputHDRSettings{Enabled: o.HDR}.Normalized(), Formats: ch.Formats, Log: log, NewRenderer: newRenderer, NewCaptureRenderer: newRenderer, Name: name, Presented: ch.Presented, Frames: ch.Frames, Events: ch.Events, Captured: ch.Captured}47 opts := headless.Options{Continuous: writer, Cursor: cur, LoadCursor: xcursor.LoadCursor, Width: size[0], Height: size[1], HDR: domain.OutputHDRSettings{Enabled: o.HDR}.Normalized(), Formats: ch.Formats, Log: log, NewRenderer: newRenderer, NewCaptureRenderer: newRenderer, Name: name, Presented: ch.Presented, Frames: ch.Frames, Events: ch.Events, Captured: ch.Captured}
48- if !headless.StartOutput(ctx, set, ch, domain.OutputInfo{Name: name, Width: size[0], Height: size[1]}, opts) {48+ opts.SetMode(size[0], size[1], 60000)
49+ if !headless.StartOutput(ctx, set, ch, domain.OutputInfo{Name: name, Width: size[0], Height: size[1], RefreshMilli: 60000}, opts) {
49 return set.Wait()50 return set.Wait()
50 }51 }
51 }52 }
M internal/adapters/outputkit/headlessbackend/backend_test.go +109 -0
@@ -2,10 +2,13 @@ package headlessbackend
22
33 import (
44 "context"
5+ "github.com/stretchr/testify/mock"
6+ "image"
57 "os"
68 "path/filepath"
79 "testing"
810 "testing/synctest"
11+ "time"
912
1013 "github.com/bnema/neferwl/internal/adapters/logging"
1114 "github.com/bnema/neferwl/internal/adapters/outputkit/cursors"
@@ -134,6 +137,26 @@ func TestContinuousCapturePlan(t *testing.T) {
134137 if res := ask(plan); res.Err != "" || res.Dir != dir {
135138 t.Fatalf("start: %+v", res)
136139 }
140+ // Both outputs are recording. A failed replacement must preserve them.
141+ if res := ask(plan); res.Err != ports.ControlErrBadRequest {
142+ t.Fatalf("active recording replacement: %+v", res)
143+ }
144+ // Stop only the second: starting it first in a new plan must roll it
145+ // back when the already-active first target refuses, not stop first.
146+ if res := ask(ports.ContinuousCaptureRequest{Stop: true, Targets: []ports.ContinuousTarget{{Output: second}}}); res.Err != "" {
147+ t.Fatal(res)
148+ }
149+ reversed := plan
150+ reversed.Targets = []ports.ContinuousTarget{plan.Targets[1], plan.Targets[0]}
151+ if res := ask(reversed); res.Err != ports.ControlErrBadRequest {
152+ t.Fatalf("partial start with active recording: %+v", res)
153+ }
154+ if res := ask(ports.ContinuousCaptureRequest{Targets: []ports.ContinuousTarget{plan.Targets[0]}}); res.Err != ports.ControlErrBadRequest {
155+ t.Fatalf("active recording lost: %+v", res)
156+ }
157+ if res := ask(ports.ContinuousCaptureRequest{Targets: []ports.ContinuousTarget{plan.Targets[1]}}); res.Err != "" {
158+ t.Fatalf("new recording not rolled back: %+v", res)
159+ }
137160 if res := ask(ports.ContinuousCaptureRequest{Stop: true, Targets: []ports.ContinuousTarget{{Output: first}, {Output: second}}}); res.Err != "" {
138161 t.Fatalf("stop: %+v", res)
139162 }
@@ -143,3 +166,89 @@ func TestContinuousCapturePlan(t *testing.T) {
143166 }
144167 })
145168 }
169+
170+func TestBuiltinOutputRefresh(t *testing.T) {
171+ synctest.Test(t, func(t *testing.T) {
172+ ctx, cancel := context.WithCancel(context.Background())
173+ defer cancel()
174+ scenes := make(chan []domain.Scene)
175+ events := make(chan ports.OutputEvent, 16)
176+ reports := make(chan ports.OutputPresented, 8)
177+ sink := portsmocks.NewMockPresentationSink(t)
178+ sink.EXPECT().Push(mock.Anything).Run(func(p ports.OutputPresented) { reports <- p })
179+ r := portsmocks.NewMockRenderer(t)
180+ r.EXPECT().Close().Return()
181+ rendered := make(chan struct{}, 1)
182+ r.EXPECT().Render(mock.Anything, mock.Anything).Run(func(domain.Scene, map[domain.WindowID]domain.SurfaceContent) { rendered <- struct{}{} }).Return(nil, nil)
183+ r.EXPECT().TakeRedrawn().Return(0).Maybe()
184+ ch := routing.Channels{Events: events, Heads: make(chan domain.OutputHeads, 16), Scenes: scenes, Presented: sink}
185+ apply := core.NewOutputApply(core.NewOutputOverrides(domain.Config{}, true))
186+ done := make(chan error, 1)
187+ go func() {
188+ done <- Run(ctx, BackendOptions{Sizes: [][2]int{{20, 20}}}, apply, ch, cursors.New(nil, 0), func(int, int) (ports.Renderer, error) { return r, nil }, logging.For(ctx, "render"))
189+ }()
190+ added := (<-events).(ports.OutputAdded)
191+ if added.Info.RefreshMilli != 60000 {
192+ t.Fatal(added.Info)
193+ }
194+ synctest.Wait()
195+ start := time.Now()
196+ scenes <- []domain.Scene{{Output: "HEADLESS-1", Seq: 1}}
197+ <-rendered
198+ period := time.Duration(16666667)
199+ if time.Since(start) != period {
200+ t.Fatalf("unpaced output: elapsed=%v, want %v", time.Since(start), period)
201+ }
202+ cancel()
203+ if err := <-done; err != nil {
204+ t.Fatal(err)
205+ }
206+ })
207+}
208+
209+func TestConfigHDRRawCaptureWithoutGlobalFlag(t *testing.T) {
210+ synctest.Test(t, func(t *testing.T) {
211+ ctx, cancel := context.WithCancel(context.Background())
212+ defer cancel()
213+ file := domain.Config{Outputs: []domain.OutputConfig{{Name: "tv", Virtual: true, Mode: "2x2", HDR: true}}}
214+ apply := core.NewOutputApply(core.NewOutputOverrides(file, true))
215+ continuous := make(chan ports.ContinuousCaptureRequest)
216+ scenes := make(chan []domain.Scene)
217+ heads := make(chan domain.OutputHeads, 16)
218+ ch := routing.Channels{Events: make(chan ports.OutputEvent, 16), Heads: heads, Scenes: scenes, Continuous: continuous}
219+ r := portsmocks.NewMockRenderer(t)
220+ r.EXPECT().Close().Return().Once()
221+ r.EXPECT().SetHDR(float64(203)).Return().Once()
222+ target, err := os.CreateTemp(t.TempDir(), "target")
223+ if err != nil {
224+ t.Fatal(err)
225+ }
226+ r.EXPECT().ExportTargets(1, []uint64(nil), false).Return([]domain.DMABuf{{Planes: []domain.DMABufPlane{{File: target}}}}, nil).Once()
227+ r.EXPECT().Render(mock.Anything, mock.Anything).Return(nil, nil)
228+ r.EXPECT().Pixels().Return(image.NewRGBA(image.Rect(0, 0, 2, 2)))
229+ read := make(chan struct{}, 1)
230+ r.EXPECT().HDRPixels().Run(func() { read <- struct{}{} }).Return(image.NewRGBA64(image.Rect(0, 0, 2, 2))).Once()
231+ r.EXPECT().TakeRedrawn().Return(0).Maybe()
232+ done := make(chan error, 1)
233+ go func() {
234+ done <- Run(ctx, BackendOptions{}, apply, ch, cursors.New(nil, 0), func(int, int) (ports.Renderer, error) { return r, nil }, logging.For(ctx, "render"))
235+ }()
236+ <-heads
237+ dir := t.TempDir()
238+ ack := make(chan ports.ContinuousCaptureResult, 1)
239+ continuous <- ports.ContinuousCaptureRequest{Dir: dir, Raw: true, Targets: []ports.ContinuousTarget{{Output: "tv", Dir: dir}}, Reply: ack}
240+ if result := <-ack; result.Err != "" {
241+ t.Fatal(result)
242+ }
243+ scenes <- []domain.Scene{{Output: "tv", Seq: 1, Scale: 1, OutputWidth: 2, OutputHeight: 2}}
244+ <-read
245+ synctest.Wait()
246+ if _, err := os.Stat(filepath.Join(dir, "latest-pq.png")); err != nil {
247+ t.Fatal(err)
248+ }
249+ cancel()
250+ if err := <-done; err != nil {
251+ t.Fatal(err)
252+ }
253+ })
254+}
@@ -2,10 +2,13 @@ package headlessbackend
2 2
3 import (3 import (
4 "context"4 "context"
5+ "github.com/stretchr/testify/mock"
6+ "image"
5 "os"7 "os"
6 "path/filepath"8 "path/filepath"
7 "testing"9 "testing"
8 "testing/synctest"10 "testing/synctest"
11+ "time"
9 12
10 "github.com/bnema/neferwl/internal/adapters/logging"13 "github.com/bnema/neferwl/internal/adapters/logging"
11 "github.com/bnema/neferwl/internal/adapters/outputkit/cursors"14 "github.com/bnema/neferwl/internal/adapters/outputkit/cursors"
@@ -134,6 +137,26 @@ func TestContinuousCapturePlan(t *testing.T) {
134 if res := ask(plan); res.Err != "" || res.Dir != dir {137 if res := ask(plan); res.Err != "" || res.Dir != dir {
135 t.Fatalf("start: %+v", res)138 t.Fatalf("start: %+v", res)
136 }139 }
140+ // Both outputs are recording. A failed replacement must preserve them.
141+ if res := ask(plan); res.Err != ports.ControlErrBadRequest {
142+ t.Fatalf("active recording replacement: %+v", res)
143+ }
144+ // Stop only the second: starting it first in a new plan must roll it
145+ // back when the already-active first target refuses, not stop first.
146+ if res := ask(ports.ContinuousCaptureRequest{Stop: true, Targets: []ports.ContinuousTarget{{Output: second}}}); res.Err != "" {
147+ t.Fatal(res)
148+ }
149+ reversed := plan
150+ reversed.Targets = []ports.ContinuousTarget{plan.Targets[1], plan.Targets[0]}
151+ if res := ask(reversed); res.Err != ports.ControlErrBadRequest {
152+ t.Fatalf("partial start with active recording: %+v", res)
153+ }
154+ if res := ask(ports.ContinuousCaptureRequest{Targets: []ports.ContinuousTarget{plan.Targets[0]}}); res.Err != ports.ControlErrBadRequest {
155+ t.Fatalf("active recording lost: %+v", res)
156+ }
157+ if res := ask(ports.ContinuousCaptureRequest{Targets: []ports.ContinuousTarget{plan.Targets[1]}}); res.Err != "" {
158+ t.Fatalf("new recording not rolled back: %+v", res)
159+ }
137 if res := ask(ports.ContinuousCaptureRequest{Stop: true, Targets: []ports.ContinuousTarget{{Output: first}, {Output: second}}}); res.Err != "" {160 if res := ask(ports.ContinuousCaptureRequest{Stop: true, Targets: []ports.ContinuousTarget{{Output: first}, {Output: second}}}); res.Err != "" {
138 t.Fatalf("stop: %+v", res)161 t.Fatalf("stop: %+v", res)
139 }162 }
@@ -143,3 +166,89 @@ func TestContinuousCapturePlan(t *testing.T) {
143 }166 }
144 })167 })
145 }168 }
169+
170+func TestBuiltinOutputRefresh(t *testing.T) {
171+ synctest.Test(t, func(t *testing.T) {
172+ ctx, cancel := context.WithCancel(context.Background())
173+ defer cancel()
174+ scenes := make(chan []domain.Scene)
175+ events := make(chan ports.OutputEvent, 16)
176+ reports := make(chan ports.OutputPresented, 8)
177+ sink := portsmocks.NewMockPresentationSink(t)
178+ sink.EXPECT().Push(mock.Anything).Run(func(p ports.OutputPresented) { reports <- p })
179+ r := portsmocks.NewMockRenderer(t)
180+ r.EXPECT().Close().Return()
181+ rendered := make(chan struct{}, 1)
182+ r.EXPECT().Render(mock.Anything, mock.Anything).Run(func(domain.Scene, map[domain.WindowID]domain.SurfaceContent) { rendered <- struct{}{} }).Return(nil, nil)
183+ r.EXPECT().TakeRedrawn().Return(0).Maybe()
184+ ch := routing.Channels{Events: events, Heads: make(chan domain.OutputHeads, 16), Scenes: scenes, Presented: sink}
185+ apply := core.NewOutputApply(core.NewOutputOverrides(domain.Config{}, true))
186+ done := make(chan error, 1)
187+ go func() {
188+ done <- Run(ctx, BackendOptions{Sizes: [][2]int{{20, 20}}}, apply, ch, cursors.New(nil, 0), func(int, int) (ports.Renderer, error) { return r, nil }, logging.For(ctx, "render"))
189+ }()
190+ added := (<-events).(ports.OutputAdded)
191+ if added.Info.RefreshMilli != 60000 {
192+ t.Fatal(added.Info)
193+ }
194+ synctest.Wait()
195+ start := time.Now()
196+ scenes <- []domain.Scene{{Output: "HEADLESS-1", Seq: 1}}
197+ <-rendered
198+ period := time.Duration(16666667)
199+ if time.Since(start) != period {
200+ t.Fatalf("unpaced output: elapsed=%v, want %v", time.Since(start), period)
201+ }
202+ cancel()
203+ if err := <-done; err != nil {
204+ t.Fatal(err)
205+ }
206+ })
207+}
208+
209+func TestConfigHDRRawCaptureWithoutGlobalFlag(t *testing.T) {
210+ synctest.Test(t, func(t *testing.T) {
211+ ctx, cancel := context.WithCancel(context.Background())
212+ defer cancel()
213+ file := domain.Config{Outputs: []domain.OutputConfig{{Name: "tv", Virtual: true, Mode: "2x2", HDR: true}}}
214+ apply := core.NewOutputApply(core.NewOutputOverrides(file, true))
215+ continuous := make(chan ports.ContinuousCaptureRequest)
216+ scenes := make(chan []domain.Scene)
217+ heads := make(chan domain.OutputHeads, 16)
218+ ch := routing.Channels{Events: make(chan ports.OutputEvent, 16), Heads: heads, Scenes: scenes, Continuous: continuous}
219+ r := portsmocks.NewMockRenderer(t)
220+ r.EXPECT().Close().Return().Once()
221+ r.EXPECT().SetHDR(float64(203)).Return().Once()
222+ target, err := os.CreateTemp(t.TempDir(), "target")
223+ if err != nil {
224+ t.Fatal(err)
225+ }
226+ r.EXPECT().ExportTargets(1, []uint64(nil), false).Return([]domain.DMABuf{{Planes: []domain.DMABufPlane{{File: target}}}}, nil).Once()
227+ r.EXPECT().Render(mock.Anything, mock.Anything).Return(nil, nil)
228+ r.EXPECT().Pixels().Return(image.NewRGBA(image.Rect(0, 0, 2, 2)))
229+ read := make(chan struct{}, 1)
230+ r.EXPECT().HDRPixels().Run(func() { read <- struct{}{} }).Return(image.NewRGBA64(image.Rect(0, 0, 2, 2))).Once()
231+ r.EXPECT().TakeRedrawn().Return(0).Maybe()
232+ done := make(chan error, 1)
233+ go func() {
234+ done <- Run(ctx, BackendOptions{}, apply, ch, cursors.New(nil, 0), func(int, int) (ports.Renderer, error) { return r, nil }, logging.For(ctx, "render"))
235+ }()
236+ <-heads
237+ dir := t.TempDir()
238+ ack := make(chan ports.ContinuousCaptureResult, 1)
239+ continuous <- ports.ContinuousCaptureRequest{Dir: dir, Raw: true, Targets: []ports.ContinuousTarget{{Output: "tv", Dir: dir}}, Reply: ack}
240+ if result := <-ack; result.Err != "" {
241+ t.Fatal(result)
242+ }
243+ scenes <- []domain.Scene{{Output: "tv", Seq: 1, Scale: 1, OutputWidth: 2, OutputHeight: 2}}
244+ <-read
245+ synctest.Wait()
246+ if _, err := os.Stat(filepath.Join(dir, "latest-pq.png")); err != nil {
247+ t.Fatal(err)
248+ }
249+ cancel()
250+ if err := <-done; err != nil {
251+ t.Fatal(err)
252+ }
253+ })
254+}
A internal/adapters/screencast/current_buffers.go +60 -0
@@ -0,0 +1,60 @@
1+package screencast
2+
3+import (
4+ "errors"
5+ "os"
6+ "sync"
7+
8+ "github.com/bnema/neferwl/internal/domain"
9+ "github.com/bnema/neferwl/internal/ports"
10+)
11+
12+// CurrentBuffers resolves the current render device for formats and each new
13+// allocation. Releases remain bound to the device that created the buffer,
14+// including when PipeWire retires a pool after render-device recovery.
15+func CurrentBuffers(current func() ports.CastBufferAllocator) ports.CastBufferAllocator {
16+ return &currentBuffers{current: current, owners: make(map[*os.File]ports.CastBufferAllocator)}
17+}
18+
19+type currentBuffers struct {
20+ mu sync.Mutex
21+ current func() ports.CastBufferAllocator
22+ owners map[*os.File]ports.CastBufferAllocator
23+}
24+
25+func (a *currentBuffers) CastFormats() []domain.DMABufFormat {
26+ if dev := a.current(); dev != nil {
27+ return dev.CastFormats()
28+ }
29+ return nil
30+}
31+
32+func (a *currentBuffers) AllocCast(format uint32, w, h int, modifier uint64) (domain.DMABuf, error) {
33+ dev := a.current()
34+ if dev == nil {
35+ return domain.DMABuf{}, errors.New("screencast: no render device")
36+ }
37+ buf, err := dev.AllocCast(format, w, h, modifier)
38+ if err != nil {
39+ return buf, err
40+ }
41+ if len(buf.Planes) > 0 {
42+ a.mu.Lock()
43+ a.owners[buf.Planes[0].File] = dev
44+ a.mu.Unlock()
45+ }
46+ return buf, nil
47+}
48+
49+func (a *currentBuffers) ReleaseCast(buf domain.DMABuf) {
50+ if len(buf.Planes) == 0 {
51+ return
52+ }
53+ a.mu.Lock()
54+ dev := a.owners[buf.Planes[0].File]
55+ delete(a.owners, buf.Planes[0].File)
56+ a.mu.Unlock()
57+ if dev != nil {
58+ dev.ReleaseCast(buf)
59+ }
60+}
@@ -0,0 +1,60 @@
1+package screencast
2+
3+import (
4+ "errors"
5+ "os"
6+ "sync"
7+
8+ "github.com/bnema/neferwl/internal/domain"
9+ "github.com/bnema/neferwl/internal/ports"
10+)
11+
12+// CurrentBuffers resolves the current render device for formats and each new
13+// allocation. Releases remain bound to the device that created the buffer,
14+// including when PipeWire retires a pool after render-device recovery.
15+func CurrentBuffers(current func() ports.CastBufferAllocator) ports.CastBufferAllocator {
16+ return &currentBuffers{current: current, owners: make(map[*os.File]ports.CastBufferAllocator)}
17+}
18+
19+type currentBuffers struct {
20+ mu sync.Mutex
21+ current func() ports.CastBufferAllocator
22+ owners map[*os.File]ports.CastBufferAllocator
23+}
24+
25+func (a *currentBuffers) CastFormats() []domain.DMABufFormat {
26+ if dev := a.current(); dev != nil {
27+ return dev.CastFormats()
28+ }
29+ return nil
30+}
31+
32+func (a *currentBuffers) AllocCast(format uint32, w, h int, modifier uint64) (domain.DMABuf, error) {
33+ dev := a.current()
34+ if dev == nil {
35+ return domain.DMABuf{}, errors.New("screencast: no render device")
36+ }
37+ buf, err := dev.AllocCast(format, w, h, modifier)
38+ if err != nil {
39+ return buf, err
40+ }
41+ if len(buf.Planes) > 0 {
42+ a.mu.Lock()
43+ a.owners[buf.Planes[0].File] = dev
44+ a.mu.Unlock()
45+ }
46+ return buf, nil
47+}
48+
49+func (a *currentBuffers) ReleaseCast(buf domain.DMABuf) {
50+ if len(buf.Planes) == 0 {
51+ return
52+ }
53+ a.mu.Lock()
54+ dev := a.owners[buf.Planes[0].File]
55+ delete(a.owners, buf.Planes[0].File)
56+ a.mu.Unlock()
57+ if dev != nil {
58+ dev.ReleaseCast(buf)
59+ }
60+}
A internal/adapters/screencast/current_buffers_test.go +39 -0
@@ -0,0 +1,39 @@
1+package screencast
2+
3+import (
4+ "testing"
5+
6+ "bnema.dev/purego-pipewire/pipewire"
7+ "github.com/bnema/neferwl/internal/domain"
8+ portsmocks "github.com/bnema/neferwl/internal/mocks/ports"
9+ "github.com/bnema/neferwl/internal/ports"
10+ "github.com/stretchr/testify/require"
11+)
12+
13+func TestCurrentBuffersRecoveryPreservesReleaseOwner(t *testing.T) {
14+ a := portsmocks.NewMockCastBufferAllocator(t)
15+ b := portsmocks.NewMockCastBufferAllocator(t)
16+ first, firstFile := tempCast(t, domain.CastXRGB8888, 64, 32, 1, 8192)
17+ second, secondFile := tempCast(t, domain.CastXRGB8888, 64, 32, 1, 8192)
18+ formats := []domain.DMABufFormat{{Format: domain.CastXRGB8888, Modifier: 7}}
19+ a.EXPECT().CastFormats().Return(formats).Once()
20+ b.EXPECT().CastFormats().Return(formats).Once()
21+ a.EXPECT().AllocCast(domain.CastXRGB8888, 64, 32, uint64(7)).Return(first, nil).Once()
22+ b.EXPECT().AllocCast(domain.CastXRGB8888, 64, 32, uint64(7)).Return(second, nil).Once()
23+ a.EXPECT().ReleaseCast(first).Once()
24+ b.EXPECT().ReleaseCast(second).Once()
25+ var current ports.CastBufferAllocator = a
26+ buffers := CurrentBuffers(func() ports.CastBufferAllocator { return current })
27+ alloc := castAllocator{dev: buffers}
28+ require.Equal(t, formats, buffers.CastFormats())
29+ var out pipewire.VideoPlanes
30+ require.NoError(t, alloc.Alloc(0, pipewire.VideoFormatBGRx, 64, 32, 7, &out))
31+ current = b
32+ require.Equal(t, formats, buffers.CastFormats())
33+ // Renegotiation replaces the old allocation after recovery. Its release
34+ // must still reach A, while the replacement must be allocated on B.
35+ require.NoError(t, alloc.Alloc(0, pipewire.VideoFormatBGRx, 64, 32, 7, &out))
36+ require.True(t, closed(firstFile))
37+ alloc.freeAll()
38+ require.True(t, closed(secondFile))
39+}
@@ -0,0 +1,39 @@
1+package screencast
2+
3+import (
4+ "testing"
5+
6+ "bnema.dev/purego-pipewire/pipewire"
7+ "github.com/bnema/neferwl/internal/domain"
8+ portsmocks "github.com/bnema/neferwl/internal/mocks/ports"
9+ "github.com/bnema/neferwl/internal/ports"
10+ "github.com/stretchr/testify/require"
11+)
12+
13+func TestCurrentBuffersRecoveryPreservesReleaseOwner(t *testing.T) {
14+ a := portsmocks.NewMockCastBufferAllocator(t)
15+ b := portsmocks.NewMockCastBufferAllocator(t)
16+ first, firstFile := tempCast(t, domain.CastXRGB8888, 64, 32, 1, 8192)
17+ second, secondFile := tempCast(t, domain.CastXRGB8888, 64, 32, 1, 8192)
18+ formats := []domain.DMABufFormat{{Format: domain.CastXRGB8888, Modifier: 7}}
19+ a.EXPECT().CastFormats().Return(formats).Once()
20+ b.EXPECT().CastFormats().Return(formats).Once()
21+ a.EXPECT().AllocCast(domain.CastXRGB8888, 64, 32, uint64(7)).Return(first, nil).Once()
22+ b.EXPECT().AllocCast(domain.CastXRGB8888, 64, 32, uint64(7)).Return(second, nil).Once()
23+ a.EXPECT().ReleaseCast(first).Once()
24+ b.EXPECT().ReleaseCast(second).Once()
25+ var current ports.CastBufferAllocator = a
26+ buffers := CurrentBuffers(func() ports.CastBufferAllocator { return current })
27+ alloc := castAllocator{dev: buffers}
28+ require.Equal(t, formats, buffers.CastFormats())
29+ var out pipewire.VideoPlanes
30+ require.NoError(t, alloc.Alloc(0, pipewire.VideoFormatBGRx, 64, 32, 7, &out))
31+ current = b
32+ require.Equal(t, formats, buffers.CastFormats())
33+ // Renegotiation replaces the old allocation after recovery. Its release
34+ // must still reach A, while the replacement must be allocated on B.
35+ require.NoError(t, alloc.Alloc(0, pipewire.VideoFormatBGRx, 64, 32, 7, &out))
36+ require.True(t, closed(firstFile))
37+ alloc.freeAll()
38+ require.True(t, closed(secondFile))
39+}
M internal/adapters/vulkan/capture_dmabuf.go +66 -1
@@ -4,6 +4,7 @@ import (
44 "errors"
55 "fmt"
66 "image"
7+ "math"
78 "os"
89 "unsafe"
910
@@ -186,7 +187,7 @@ func (f *captureFrame) CopyTo(region image.Rectangle, dst domain.DMABuf) (*os.Fi
186187 c.get = vk.SemaphoreGetFdInfoKHR{SType: vk.StructureTypeSemaphoreGetFDInfoKHR, Semaphore: c.done, HandleType: vk.ExternalSemaphoreHandleTypeSyncFDBit}
187188 c.fd = -1
188189 if err := checked("vkGetSemaphoreFdKHR(capture dmabuf)", d.GetSemaphoreFdKHR(dev, &c.get, &c.fd)); err != nil {
189- return nil, err
190+ return nil, errors.Join(err, finishFailedExport(deviceCopyCompletion{r}, c.fence))
190191 }
191192 c.exported = true
192193 if c.fd < 0 {
@@ -380,3 +381,67 @@ func (r *Renderer) recycleDMACopy(c *dmaCopy) {
380381 }
381382 r.dmaIdle = append(r.dmaIdle, c)
382383 }
384+
385+// copyCompletion is the bounded synchronization fallback after sync-file export
386+// fails. The copy remains in the slot until its fence signals or device teardown.
387+type copyCompletion interface {
388+ waitCopy(vk.Fence) vk.Result
389+ queueIdle() vk.Result
390+ deviceIdle() vk.Result
391+}
392+
393+type deviceCopyCompletion struct{ r *Renderer }
394+
395+func (d deviceCopyCompletion) waitCopy(fence vk.Fence) vk.Result {
396+ return d.r.gpu.dd.WaitForFences(d.r.gpu.device, 1, &fence, 1, math.MaxUint64)
397+}
398+
399+func (d deviceCopyCompletion) queueIdle() vk.Result {
400+ q := d.r.q
401+ q.mu.Lock()
402+ defer q.mu.Unlock()
403+ return q.dd.QueueWaitIdle(q.q)
404+}
405+
406+func (d deviceCopyCompletion) deviceIdle() vk.Result {
407+ g := d.r.gpu
408+ // Match Close's lock order: pool first, then every submission lock in order.
409+ g.poolMu.Lock()
410+ defer g.poolMu.Unlock()
411+ for _, q := range g.queues {
412+ q.mu.Lock()
413+ }
414+ defer func() {
415+ for i := len(g.queues) - 1; i >= 0; i-- {
416+ g.queues[i].mu.Unlock()
417+ }
418+ }()
419+ return g.dd.DeviceWaitIdle(g.device)
420+}
421+
422+func finishFailedExport(sync copyCompletion, fence vk.Fence) error {
423+ res := sync.waitCopy(fence)
424+ if res == vk.Success {
425+ return nil
426+ }
427+ err := checked("vkWaitForFences(capture export failure)", res)
428+ if res == vk.ErrorDeviceLost {
429+ return err
430+ }
431+ // A wait allocation failure does not stop writes. Try broader synchronization
432+ // once each instead of retrying (and potentially spinning) on the owner.
433+ res = sync.queueIdle()
434+ err = errors.Join(err, checked("vkQueueWaitIdle(capture export failure)", res))
435+ if res == vk.Success || res == vk.ErrorDeviceLost {
436+ return err
437+ }
438+ res = sync.deviceIdle()
439+ err = errors.Join(err, checked("vkDeviceWaitIdle(capture export failure)", res))
440+ if res == vk.Success || res == vk.ErrorDeviceLost {
441+ return err
442+ }
443+ // Completion is still unproven. Keep the submitted copy in s.copies; do not
444+ // recycle its resources. Mark the device unusable: device teardown, not these
445+ // failed waits, is what must end the outstanding writes.
446+ return errors.Join(err, ports.ErrDeviceLost)
447+}
@@ -4,6 +4,7 @@ import (
4 "errors"4 "errors"
5 "fmt"5 "fmt"
6 "image"6 "image"
7+ "math"
7 "os"8 "os"
8 "unsafe"9 "unsafe"
9 10
@@ -186,7 +187,7 @@ func (f *captureFrame) CopyTo(region image.Rectangle, dst domain.DMABuf) (*os.Fi
186 c.get = vk.SemaphoreGetFdInfoKHR{SType: vk.StructureTypeSemaphoreGetFDInfoKHR, Semaphore: c.done, HandleType: vk.ExternalSemaphoreHandleTypeSyncFDBit}187 c.get = vk.SemaphoreGetFdInfoKHR{SType: vk.StructureTypeSemaphoreGetFDInfoKHR, Semaphore: c.done, HandleType: vk.ExternalSemaphoreHandleTypeSyncFDBit}
187 c.fd = -1188 c.fd = -1
188 if err := checked("vkGetSemaphoreFdKHR(capture dmabuf)", d.GetSemaphoreFdKHR(dev, &c.get, &c.fd)); err != nil {189 if err := checked("vkGetSemaphoreFdKHR(capture dmabuf)", d.GetSemaphoreFdKHR(dev, &c.get, &c.fd)); err != nil {
189- return nil, err190+ return nil, errors.Join(err, finishFailedExport(deviceCopyCompletion{r}, c.fence))
190 }191 }
191 c.exported = true192 c.exported = true
192 if c.fd < 0 {193 if c.fd < 0 {
@@ -380,3 +381,67 @@ func (r *Renderer) recycleDMACopy(c *dmaCopy) {
380 }381 }
381 r.dmaIdle = append(r.dmaIdle, c)382 r.dmaIdle = append(r.dmaIdle, c)
382 }383 }
384+
385+// copyCompletion is the bounded synchronization fallback after sync-file export
386+// fails. The copy remains in the slot until its fence signals or device teardown.
387+type copyCompletion interface {
388+ waitCopy(vk.Fence) vk.Result
389+ queueIdle() vk.Result
390+ deviceIdle() vk.Result
391+}
392+
393+type deviceCopyCompletion struct{ r *Renderer }
394+
395+func (d deviceCopyCompletion) waitCopy(fence vk.Fence) vk.Result {
396+ return d.r.gpu.dd.WaitForFences(d.r.gpu.device, 1, &fence, 1, math.MaxUint64)
397+}
398+
399+func (d deviceCopyCompletion) queueIdle() vk.Result {
400+ q := d.r.q
401+ q.mu.Lock()
402+ defer q.mu.Unlock()
403+ return q.dd.QueueWaitIdle(q.q)
404+}
405+
406+func (d deviceCopyCompletion) deviceIdle() vk.Result {
407+ g := d.r.gpu
408+ // Match Close's lock order: pool first, then every submission lock in order.
409+ g.poolMu.Lock()
410+ defer g.poolMu.Unlock()
411+ for _, q := range g.queues {
412+ q.mu.Lock()
413+ }
414+ defer func() {
415+ for i := len(g.queues) - 1; i >= 0; i-- {
416+ g.queues[i].mu.Unlock()
417+ }
418+ }()
419+ return g.dd.DeviceWaitIdle(g.device)
420+}
421+
422+func finishFailedExport(sync copyCompletion, fence vk.Fence) error {
423+ res := sync.waitCopy(fence)
424+ if res == vk.Success {
425+ return nil
426+ }
427+ err := checked("vkWaitForFences(capture export failure)", res)
428+ if res == vk.ErrorDeviceLost {
429+ return err
430+ }
431+ // A wait allocation failure does not stop writes. Try broader synchronization
432+ // once each instead of retrying (and potentially spinning) on the owner.
433+ res = sync.queueIdle()
434+ err = errors.Join(err, checked("vkQueueWaitIdle(capture export failure)", res))
435+ if res == vk.Success || res == vk.ErrorDeviceLost {
436+ return err
437+ }
438+ res = sync.deviceIdle()
439+ err = errors.Join(err, checked("vkDeviceWaitIdle(capture export failure)", res))
440+ if res == vk.Success || res == vk.ErrorDeviceLost {
441+ return err
442+ }
443+ // Completion is still unproven. Keep the submitted copy in s.copies; do not
444+ // recycle its resources. Mark the device unusable: device teardown, not these
445+ // failed waits, is what must end the outstanding writes.
446+ return errors.Join(err, ports.ErrDeviceLost)
447+}
A internal/adapters/vulkan/copy_completion_mock_test.go +185 -0
@@ -0,0 +1,185 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package vulkan
6+
7+import (
8+ "bnema.dev/purego-vulkan/vulkan"
9+ mock "github.com/stretchr/testify/mock"
10+)
11+
12+// newMockcopyCompletion creates a new instance of mockcopyCompletion. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
13+// The first argument is typically a *testing.T value.
14+func newMockcopyCompletion(t interface {
15+ mock.TestingT
16+ Cleanup(func())
17+}) *mockcopyCompletion {
18+ if helper, ok := t.(interface{ Helper() }); ok {
19+ helper.Helper()
20+ }
21+
22+ mock := &mockcopyCompletion{}
23+ mock.Mock.Test(t)
24+
25+ t.Cleanup(func() {
26+ if helper, ok := t.(interface{ Helper() }); ok {
27+ helper.Helper()
28+ }
29+ mock.AssertExpectations(t)
30+ })
31+
32+ return mock
33+}
34+
35+// mockcopyCompletion is an autogenerated mock type for the copyCompletion type
36+type mockcopyCompletion struct {
37+ mock.Mock
38+}
39+
40+type mockcopyCompletion_Expecter struct {
41+ mock *mock.Mock
42+}
43+
44+func (_m *mockcopyCompletion) EXPECT() *mockcopyCompletion_Expecter {
45+ return &mockcopyCompletion_Expecter{mock: &_m.Mock}
46+}
47+
48+// deviceIdle provides a mock function for the type mockcopyCompletion
49+func (_mock *mockcopyCompletion) deviceIdle() vulkan.Result {
50+ ret := _mock.Called()
51+
52+ if len(ret) == 0 {
53+ panic("no return value specified for deviceIdle")
54+ }
55+
56+ var r0 vulkan.Result
57+ if returnFunc, ok := ret.Get(0).(func() vulkan.Result); ok {
58+ r0 = returnFunc()
59+ } else {
60+ r0 = ret.Get(0).(vulkan.Result)
61+ }
62+ return r0
63+}
64+
65+// mockcopyCompletion_deviceIdle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'deviceIdle'
66+type mockcopyCompletion_deviceIdle_Call struct {
67+ *mock.Call
68+}
69+
70+// deviceIdle is a helper method to define mock.On call
71+func (_e *mockcopyCompletion_Expecter) deviceIdle() *mockcopyCompletion_deviceIdle_Call {
72+ return &mockcopyCompletion_deviceIdle_Call{Call: _e.mock.On("deviceIdle")}
73+}
74+
75+func (_c *mockcopyCompletion_deviceIdle_Call) Run(run func()) *mockcopyCompletion_deviceIdle_Call {
76+ _c.Call.Run(func(args mock.Arguments) {
77+ run()
78+ })
79+ return _c
80+}
81+
82+func (_c *mockcopyCompletion_deviceIdle_Call) Return(result vulkan.Result) *mockcopyCompletion_deviceIdle_Call {
83+ _c.Call.Return(result)
84+ return _c
85+}
86+
87+func (_c *mockcopyCompletion_deviceIdle_Call) RunAndReturn(run func() vulkan.Result) *mockcopyCompletion_deviceIdle_Call {
88+ _c.Call.Return(run)
89+ return _c
90+}
91+
92+// queueIdle provides a mock function for the type mockcopyCompletion
93+func (_mock *mockcopyCompletion) queueIdle() vulkan.Result {
94+ ret := _mock.Called()
95+
96+ if len(ret) == 0 {
97+ panic("no return value specified for queueIdle")
98+ }
99+
100+ var r0 vulkan.Result
101+ if returnFunc, ok := ret.Get(0).(func() vulkan.Result); ok {
102+ r0 = returnFunc()
103+ } else {
104+ r0 = ret.Get(0).(vulkan.Result)
105+ }
106+ return r0
107+}
108+
109+// mockcopyCompletion_queueIdle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'queueIdle'
110+type mockcopyCompletion_queueIdle_Call struct {
111+ *mock.Call
112+}
113+
114+// queueIdle is a helper method to define mock.On call
115+func (_e *mockcopyCompletion_Expecter) queueIdle() *mockcopyCompletion_queueIdle_Call {
116+ return &mockcopyCompletion_queueIdle_Call{Call: _e.mock.On("queueIdle")}
117+}
118+
119+func (_c *mockcopyCompletion_queueIdle_Call) Run(run func()) *mockcopyCompletion_queueIdle_Call {
120+ _c.Call.Run(func(args mock.Arguments) {
121+ run()
122+ })
123+ return _c
124+}
125+
126+func (_c *mockcopyCompletion_queueIdle_Call) Return(result vulkan.Result) *mockcopyCompletion_queueIdle_Call {
127+ _c.Call.Return(result)
128+ return _c
129+}
130+
131+func (_c *mockcopyCompletion_queueIdle_Call) RunAndReturn(run func() vulkan.Result) *mockcopyCompletion_queueIdle_Call {
132+ _c.Call.Return(run)
133+ return _c
134+}
135+
136+// waitCopy provides a mock function for the type mockcopyCompletion
137+func (_mock *mockcopyCompletion) waitCopy(fence vulkan.Fence) vulkan.Result {
138+ ret := _mock.Called(fence)
139+
140+ if len(ret) == 0 {
141+ panic("no return value specified for waitCopy")
142+ }
143+
144+ var r0 vulkan.Result
145+ if returnFunc, ok := ret.Get(0).(func(vulkan.Fence) vulkan.Result); ok {
146+ r0 = returnFunc(fence)
147+ } else {
148+ r0 = ret.Get(0).(vulkan.Result)
149+ }
150+ return r0
151+}
152+
153+// mockcopyCompletion_waitCopy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'waitCopy'
154+type mockcopyCompletion_waitCopy_Call struct {
155+ *mock.Call
156+}
157+
158+// waitCopy is a helper method to define mock.On call
159+// - fence vulkan.Fence
160+func (_e *mockcopyCompletion_Expecter) waitCopy(fence any) *mockcopyCompletion_waitCopy_Call {
161+ return &mockcopyCompletion_waitCopy_Call{Call: _e.mock.On("waitCopy", fence)}
162+}
163+
164+func (_c *mockcopyCompletion_waitCopy_Call) Run(run func(fence vulkan.Fence)) *mockcopyCompletion_waitCopy_Call {
165+ _c.Call.Run(func(args mock.Arguments) {
166+ var arg0 vulkan.Fence
167+ if args[0] != nil {
168+ arg0 = args[0].(vulkan.Fence)
169+ }
170+ run(
171+ arg0,
172+ )
173+ })
174+ return _c
175+}
176+
177+func (_c *mockcopyCompletion_waitCopy_Call) Return(result vulkan.Result) *mockcopyCompletion_waitCopy_Call {
178+ _c.Call.Return(result)
179+ return _c
180+}
181+
182+func (_c *mockcopyCompletion_waitCopy_Call) RunAndReturn(run func(fence vulkan.Fence) vulkan.Result) *mockcopyCompletion_waitCopy_Call {
183+ _c.Call.Return(run)
184+ return _c
185+}
@@ -0,0 +1,185 @@
1+// Code generated by mockery; DO NOT EDIT.
2+// github.com/vektra/mockery
3+// template: testify
4+
5+package vulkan
6+
7+import (
8+ "bnema.dev/purego-vulkan/vulkan"
9+ mock "github.com/stretchr/testify/mock"
10+)
11+
12+// newMockcopyCompletion creates a new instance of mockcopyCompletion. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
13+// The first argument is typically a *testing.T value.
14+func newMockcopyCompletion(t interface {
15+ mock.TestingT
16+ Cleanup(func())
17+}) *mockcopyCompletion {
18+ if helper, ok := t.(interface{ Helper() }); ok {
19+ helper.Helper()
20+ }
21+
22+ mock := &mockcopyCompletion{}
23+ mock.Mock.Test(t)
24+
25+ t.Cleanup(func() {
26+ if helper, ok := t.(interface{ Helper() }); ok {
27+ helper.Helper()
28+ }
29+ mock.AssertExpectations(t)
30+ })
31+
32+ return mock
33+}
34+
35+// mockcopyCompletion is an autogenerated mock type for the copyCompletion type
36+type mockcopyCompletion struct {
37+ mock.Mock
38+}
39+
40+type mockcopyCompletion_Expecter struct {
41+ mock *mock.Mock
42+}
43+
44+func (_m *mockcopyCompletion) EXPECT() *mockcopyCompletion_Expecter {
45+ return &mockcopyCompletion_Expecter{mock: &_m.Mock}
46+}
47+
48+// deviceIdle provides a mock function for the type mockcopyCompletion
49+func (_mock *mockcopyCompletion) deviceIdle() vulkan.Result {
50+ ret := _mock.Called()
51+
52+ if len(ret) == 0 {
53+ panic("no return value specified for deviceIdle")
54+ }
55+
56+ var r0 vulkan.Result
57+ if returnFunc, ok := ret.Get(0).(func() vulkan.Result); ok {
58+ r0 = returnFunc()
59+ } else {
60+ r0 = ret.Get(0).(vulkan.Result)
61+ }
62+ return r0
63+}
64+
65+// mockcopyCompletion_deviceIdle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'deviceIdle'
66+type mockcopyCompletion_deviceIdle_Call struct {
67+ *mock.Call
68+}
69+
70+// deviceIdle is a helper method to define mock.On call
71+func (_e *mockcopyCompletion_Expecter) deviceIdle() *mockcopyCompletion_deviceIdle_Call {
72+ return &mockcopyCompletion_deviceIdle_Call{Call: _e.mock.On("deviceIdle")}
73+}
74+
75+func (_c *mockcopyCompletion_deviceIdle_Call) Run(run func()) *mockcopyCompletion_deviceIdle_Call {
76+ _c.Call.Run(func(args mock.Arguments) {
77+ run()
78+ })
79+ return _c
80+}
81+
82+func (_c *mockcopyCompletion_deviceIdle_Call) Return(result vulkan.Result) *mockcopyCompletion_deviceIdle_Call {
83+ _c.Call.Return(result)
84+ return _c
85+}
86+
87+func (_c *mockcopyCompletion_deviceIdle_Call) RunAndReturn(run func() vulkan.Result) *mockcopyCompletion_deviceIdle_Call {
88+ _c.Call.Return(run)
89+ return _c
90+}
91+
92+// queueIdle provides a mock function for the type mockcopyCompletion
93+func (_mock *mockcopyCompletion) queueIdle() vulkan.Result {
94+ ret := _mock.Called()
95+
96+ if len(ret) == 0 {
97+ panic("no return value specified for queueIdle")
98+ }
99+
100+ var r0 vulkan.Result
101+ if returnFunc, ok := ret.Get(0).(func() vulkan.Result); ok {
102+ r0 = returnFunc()
103+ } else {
104+ r0 = ret.Get(0).(vulkan.Result)
105+ }
106+ return r0
107+}
108+
109+// mockcopyCompletion_queueIdle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'queueIdle'
110+type mockcopyCompletion_queueIdle_Call struct {
111+ *mock.Call
112+}
113+
114+// queueIdle is a helper method to define mock.On call
115+func (_e *mockcopyCompletion_Expecter) queueIdle() *mockcopyCompletion_queueIdle_Call {
116+ return &mockcopyCompletion_queueIdle_Call{Call: _e.mock.On("queueIdle")}
117+}
118+
119+func (_c *mockcopyCompletion_queueIdle_Call) Run(run func()) *mockcopyCompletion_queueIdle_Call {
120+ _c.Call.Run(func(args mock.Arguments) {
121+ run()
122+ })
123+ return _c
124+}
125+
126+func (_c *mockcopyCompletion_queueIdle_Call) Return(result vulkan.Result) *mockcopyCompletion_queueIdle_Call {
127+ _c.Call.Return(result)
128+ return _c
129+}
130+
131+func (_c *mockcopyCompletion_queueIdle_Call) RunAndReturn(run func() vulkan.Result) *mockcopyCompletion_queueIdle_Call {
132+ _c.Call.Return(run)
133+ return _c
134+}
135+
136+// waitCopy provides a mock function for the type mockcopyCompletion
137+func (_mock *mockcopyCompletion) waitCopy(fence vulkan.Fence) vulkan.Result {
138+ ret := _mock.Called(fence)
139+
140+ if len(ret) == 0 {
141+ panic("no return value specified for waitCopy")
142+ }
143+
144+ var r0 vulkan.Result
145+ if returnFunc, ok := ret.Get(0).(func(vulkan.Fence) vulkan.Result); ok {
146+ r0 = returnFunc(fence)
147+ } else {
148+ r0 = ret.Get(0).(vulkan.Result)
149+ }
150+ return r0
151+}
152+
153+// mockcopyCompletion_waitCopy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'waitCopy'
154+type mockcopyCompletion_waitCopy_Call struct {
155+ *mock.Call
156+}
157+
158+// waitCopy is a helper method to define mock.On call
159+// - fence vulkan.Fence
160+func (_e *mockcopyCompletion_Expecter) waitCopy(fence any) *mockcopyCompletion_waitCopy_Call {
161+ return &mockcopyCompletion_waitCopy_Call{Call: _e.mock.On("waitCopy", fence)}
162+}
163+
164+func (_c *mockcopyCompletion_waitCopy_Call) Run(run func(fence vulkan.Fence)) *mockcopyCompletion_waitCopy_Call {
165+ _c.Call.Run(func(args mock.Arguments) {
166+ var arg0 vulkan.Fence
167+ if args[0] != nil {
168+ arg0 = args[0].(vulkan.Fence)
169+ }
170+ run(
171+ arg0,
172+ )
173+ })
174+ return _c
175+}
176+
177+func (_c *mockcopyCompletion_waitCopy_Call) Return(result vulkan.Result) *mockcopyCompletion_waitCopy_Call {
178+ _c.Call.Return(result)
179+ return _c
180+}
181+
182+func (_c *mockcopyCompletion_waitCopy_Call) RunAndReturn(run func(fence vulkan.Fence) vulkan.Result) *mockcopyCompletion_waitCopy_Call {
183+ _c.Call.Return(run)
184+ return _c
185+}
A internal/adapters/vulkan/copy_completion_test.go +43 -0
M internal/adapters/wayland/configure_commit_test.go +76 -0
M internal/adapters/wayland/fifo.go +3 -2
M internal/adapters/wayland/surface.go +3 -3
M internal/adapters/wayland/virtualpointer.go +2 -2
M internal/adapters/wayland/xdg.go +4 -4
A internal/adapters/xkb/transaction.go +68 -0
A internal/adapters/xkb/transaction_test.go +119 -0
M internal/adapters/xkb/xkb.go +14 -1
M internal/app/session.go +12 -2
M internal/cli/commands.go +1 -1
M internal/cli/control_test.go +7 -1
M internal/cli/session_new.go +12 -3
M internal/cli/session_new_test.go +44 -0
M internal/core/control.go +22 -4
A internal/core/controladmission_test.go +58 -0
M internal/core/controlwait_test.go +4 -1
M internal/core/devicebinding_test.go +35 -0
M internal/core/isolation_test.go +39 -0
M internal/core/screens.go +6 -1
M internal/domain/input.go +10 -0
M internal/ports/control.go +18 -7
M packaging/neferwl-session +9 -0
M skills/neferwl/SKILL.md +3 -4

Comments00 unresolved

no comments yet.

Keyboard shortcuts

Single-key shortcuts are on. ctrl k and esc work whatever this says.

ctrl k :
go to a section, branch, tag, file or repository
?
this list
j k
move the row cursor down / up
enter
open the row under the cursor; on Files, a directory opens or closes in place
↑ ↓ ← → home end
in the file tree (focus on a row): previous / next row, close / open a directory or go to its parent / first entry, first / last row. They never open a file
l h
on Files: open a directory or a file / close a directory or go up to its parent, then to the parent page. On pages with a side panel: into the panel (on a merge request, its files) / back to the content; there j k move between its controls
g g G
first / last row
/
filter the list; on Files, find a file anywhere in the repository (esc clears, enter opens the best match)
b
switch branch or tag
g s g f g c g b g m g i g r g a
tabs: summary, files, commits, branches & tags, merge requests, issues, releases, actions (when available)
g h
home
w
wide mode: use the whole width of the screen, or not (remembered)
y
copy a permalink pinned to the commit; in a file, click a line number to select it, shift-click for a range
d u x
diff: split / unified / collapse or expand all
e E
diff: the whole file in view / every file, with the lines the hunks hide
n
merge request: next note in the diff
l
merge request: the list of files (j k move, enter opens, esc back)
M
merge request: the merge menu; there 1–3 pick the mode, D deletes the branch, enter merges
R
merge request: mark the head read
esc
close a dialog, leave a field

Branches 33

Tags 15

↑↓ moveenter openesc close