kqueue: add non-recursive watches

Add Watcher.AddNonRecursive for raw kqueue event masks without the directory child-watching behavior used to mimic inotify.

Track non-recursive directory watches so directory NOTE_WRITE events are delivered directly instead of triggering child scans later. This is useful for device directories such as /dev where opening existing entries can fail with EBUSY.

Validation: go test -run TestAddNonRecursiveDoesNotWatchChildren; go test -run TestRemoveState

Author: kdrag0n

backend_kqueue.go

@@ -124,17 +124,18 @@ type Watcher struct {
 	// Errors sends any errors.
 	Errors chan error
 
-	done         chan struct{}
-	kq           int                         // File descriptor (as returned by the kqueue() syscall).
-	closepipe    [2]int                      // Pipe used for closing.
-	mu           sync.Mutex                  // Protects access to watcher data
-	watches      map[string]int              // Watched file descriptors (key: path).
-	watchesByDir map[string]map[int]struct{} // Watched file descriptors indexed by the parent directory (key: dirname(path)).
-	userWatches  map[string]struct{}         // Watches added with Watcher.Add()
-	dirFlags     map[string]uint32           // Watched directories to fflags used in kqueue.
-	paths        map[int]pathInfo            // File descriptors to path names for processing kqueue events.
-	fileExists   map[string]struct{}         // Keep track of if we know this file exists (to stop duplicate create events).
-	isClosed     bool                        // Set to true when Close() is first called
+	done             chan struct{}
+	kq               int                         // File descriptor (as returned by the kqueue() syscall).
+	closepipe        [2]int                      // Pipe used for closing.
+	mu               sync.Mutex                  // Protects access to watcher data
+	watches          map[string]int              // Watched file descriptors (key: path).
+	watchesByDir     map[string]map[int]struct{} // Watched file descriptors indexed by the parent directory (key: dirname(path)).
+	userWatches      map[string]struct{}         // Watches added with Watcher.Add()
+	dirFlags         map[string]uint32           // Watched directories to fflags used in kqueue.
+	nonRecursiveDirs map[string]struct{}         // Watched directories that should not watch children.
+	paths            map[int]pathInfo            // File descriptors to path names for processing kqueue events.
+	fileExists       map[string]struct{}         // Keep track of if we know this file exists (to stop duplicate create events).
+	isClosed         bool                        // Set to true when Close() is first called
 }
 
 type pathInfo struct {
@@ -162,17 +163,18 @@ func NewBufferedWatcher(sz uint) (*Watcher, error) {
 	}
 
 	w := &Watcher{
-		kq:           kq,
-		closepipe:    closepipe,
-		watches:      make(map[string]int),
-		watchesByDir: make(map[string]map[int]struct{}),
-		dirFlags:     make(map[string]uint32),
-		paths:        make(map[int]pathInfo),
-		fileExists:   make(map[string]struct{}),
-		userWatches:  make(map[string]struct{}),
-		Events:       make(chan Event, sz),
-		Errors:       make(chan error),
-		done:         make(chan struct{}),
+		kq:               kq,
+		closepipe:        closepipe,
+		watches:          make(map[string]int),
+		watchesByDir:     make(map[string]map[int]struct{}),
+		dirFlags:         make(map[string]uint32),
+		nonRecursiveDirs: make(map[string]struct{}),
+		paths:            make(map[int]pathInfo),
+		fileExists:       make(map[string]struct{}),
+		userWatches:      make(map[string]struct{}),
+		Events:           make(chan Event, sz),
+		Errors:           make(chan error),
+		done:             make(chan struct{}),
 	}
 
 	go w.readEvents()
@@ -313,15 +315,23 @@ func (w *Watcher) AddWith(name string, opts ...addOpt) error {
 	w.mu.Lock()
 	w.userWatches[name] = struct{}{}
 	w.mu.Unlock()
-	_, err := w.addWatch(name, noteAllEvents)
+	_, err := w.addWatch(name, noteAllEvents, true)
 	return err
 }
 
 func (w *Watcher) AddWithEvents(name string, flags uint32) error {
 	w.mu.Lock()
 	w.userWatches[name] = struct{}{}
 	w.mu.Unlock()
-	_, err := w.addWatch(name, flags)
+	_, err := w.addWatch(name, flags, true)
+	return err
+}
+
+func (w *Watcher) AddNonRecursive(name string, flags uint32) error {
+	w.mu.Lock()
+	w.userWatches[name] = struct{}{}
+	w.mu.Unlock()
+	_, err := w.addWatch(name, flags, false)
 	return err
 }
 
@@ -371,6 +381,7 @@ func (w *Watcher) remove(name string, unwatchFiles bool) error {
 
 	delete(w.paths, watchfd)
 	delete(w.dirFlags, name)
+	delete(w.nonRecursiveDirs, name)
 	delete(w.fileExists, name)
 	w.mu.Unlock()
 
@@ -421,7 +432,7 @@ const noteAllEvents = unix.NOTE_DELETE | unix.NOTE_WRITE | unix.NOTE_ATTRIB | un
 // described in kevent(2).
 //
 // Returns the real path to the file which was added, with symlinks resolved.
-func (w *Watcher) addWatch(name string, flags uint32) (string, error) {
+func (w *Watcher) addWatch(name string, flags uint32, recursive bool) (string, error) {
 	var isDir bool
 	name = filepath.Clean(name)
 
@@ -522,9 +533,15 @@ func (w *Watcher) addWatch(name string, flags uint32) (string, error) {
 		w.mu.Lock()
 
 		watchDir := (flags&unix.NOTE_WRITE) == unix.NOTE_WRITE &&
+			recursive &&
 			(!alreadyWatching || (w.dirFlags[name]&unix.NOTE_WRITE) != unix.NOTE_WRITE)
 		// Store flags so this watch can be updated later
 		w.dirFlags[name] = flags
+		if recursive {
+			delete(w.nonRecursiveDirs, name)
+		} else {
+			w.nonRecursiveDirs[name] = struct{}{}
+		}
 		w.mu.Unlock()
 
 		if watchDir {
@@ -584,7 +601,11 @@ func (w *Watcher) readEvents() {
 				w.mu.Unlock()
 			}
 
-			if path.isDir && event.Has(Write) && !event.Has(Remove) {
+			w.mu.Lock()
+			_, nonRecursive := w.nonRecursiveDirs[event.Name]
+			w.mu.Unlock()
+
+			if path.isDir && event.Has(Write) && !event.Has(Remove) && !nonRecursive {
 				w.sendDirectoryChangeEvents(event.Name)
 			} else {
 				if !w.sendEvent(event) {
@@ -752,11 +773,11 @@ func (w *Watcher) internalWatch(name string, fi os.FileInfo) (string, error) {
 		w.mu.Unlock()
 
 		flags |= unix.NOTE_DELETE | unix.NOTE_RENAME
-		return w.addWatch(name, flags)
+		return w.addWatch(name, flags, true)
 	}
 
 	// watch file to mimic Linux inotify
-	return w.addWatch(name, noteAllEvents)
+	return w.addWatch(name, noteAllEvents, true)
 }
 
 // Register events with the queue.

backend_kqueue_test.go

@@ -7,6 +7,8 @@ import (
 	"fmt"
 	"strings"
 	"testing"
+
+	"golang.org/x/sys/unix"
 )
 
 func TestRemoveState(t *testing.T) {
@@ -94,3 +96,29 @@ func TestRemoveState(t *testing.T) {
 		}
 	}
 }
+
+func TestAddNonRecursiveDoesNotWatchChildren(t *testing.T) {
+	var (
+		tmp  = t.TempDir()
+		dir  = join(tmp, "dir")
+		file = join(dir, "file")
+	)
+	mkdir(t, dir)
+	touch(t, file)
+
+	w := newWatcher(t)
+	defer w.Close()
+	if err := w.AddNonRecursive(dir, unix.NOTE_WRITE); err != nil {
+		t.Fatal(err)
+	}
+
+	if len(w.watches) != 1 {
+		t.Fatalf("unexpected number of entries in w.watches: have %d, want 1", len(w.watches))
+	}
+	if _, ok := w.watches[file]; ok {
+		t.Fatalf("child file %q should not be watched", file)
+	}
+	if _, ok := w.nonRecursiveDirs[dir]; !ok {
+		t.Fatalf("directory %q should be marked non-recursive", dir)
+	}
+}