fix: close the replaced cancel reader on RestoreTerminal (#1821)

Co-authored-by: Drew Smirnoff <drew@charm.land>
This commit is contained in:
Attila Fábián 2026-11-12 14:25:04 +01:00 committed by GitHub
parent f3d74b724c
commit 56a2fe7fed
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
2 changed files with 103 additions and 0 deletions

12
tty.go
View file

@ -60,6 +60,18 @@ func (p *Program) initInputReader(cancel bool) error {
p.waitForReadLoop()
}
// Close the reader we are about to replace, otherwise its resources (e.g.
// the epoll file descriptor on Linux) leak on every ReleaseTerminal and
// RestoreTerminal cycle. Only close it once its read loop has exited: if
// waitForReadLoop timed out, the loop may still be using it.
if p.cancelReader != nil && p.readLoopDone != nil {
select {
case <-p.readLoopDone:
_ = p.cancelReader.Close()
default:
}
}
term := p.environ.Getenv("TERM")
// Initialize the input reader.

91
tty_linux_test.go Normal file
View file

@ -0,0 +1,91 @@
//go:build linux
// +build linux
package tea
import (
"bytes"
"os"
"path/filepath"
"testing"
"time"
)
type readyMsg struct{}
type readyModel struct{ ready chan struct{} }
func (m readyModel) Init() Cmd { return func() Msg { return readyMsg{} } }
func (m readyModel) Update(msg Msg) (Model, Cmd) {
if _, ok := msg.(readyMsg); ok {
close(m.ready)
}
return m, nil
}
func (m readyModel) View() View { return NewView("") }
func countEpollFDs(t *testing.T) int {
t.Helper()
entries, err := os.ReadDir("/proc/self/fd")
if err != nil {
t.Skipf("cannot inspect file descriptors: %v", err)
}
var n int
for _, e := range entries {
target, err := os.Readlink(filepath.Join("/proc/self/fd", e.Name()))
if err == nil && target == "anon_inode:[eventpoll]" {
n++
}
}
return n
}
// Every ReleaseTerminal/RestoreTerminal cycle (Exec, suspend) replaces the
// input cancel reader. The replaced reader must be closed, or its epoll file
// descriptor leaks.
//
// Not parallel: it counts process-wide file descriptors.
func TestReleaseRestoreTerminalClosesCancelReader(t *testing.T) {
r, w, err := os.Pipe()
if err != nil {
t.Fatal(err)
}
defer r.Close() //nolint:errcheck
defer w.Close() //nolint:errcheck
m := readyModel{ready: make(chan struct{})}
var out bytes.Buffer
p := NewProgram(m, WithInput(r), WithOutput(&out))
done := make(chan struct{})
go func() {
defer close(done)
_, _ = p.Run()
}()
select {
case <-m.ready:
case <-time.After(5 * time.Second):
t.Fatal("program did not start")
}
before := countEpollFDs(t)
const cycles = 20
for i := range cycles {
if err := p.ReleaseTerminal(); err != nil {
t.Fatalf("release %d: %v", i, err)
}
if err := p.RestoreTerminal(); err != nil {
t.Fatalf("restore %d: %v", i, err)
}
}
after := countEpollFDs(t)
p.Quit()
<-done
if after > before {
t.Fatalf("epoll file descriptors grew by %d over %d release/restore cycles (before=%d, after=%d)",
after-before, cycles, before, after)
}
}