From 344ee80ec0c8608e82ec7f6b1a83825a2ded1417 Mon Sep 17 00:00:00 2001 From: darxnet Date: Thu, 12 Nov 2026 13:08:51 +0100 Subject: [PATCH] fix: unlock the node when eq panics in CompareAndDelete CompareAndDelete called eq with the key's trie node locked and unlocked it only on the normal return paths, so a panicking eq - or == on a ComparableMap[K, any] value whose dynamic type is not comparable, such as []byte - left the node locked once the caller recovered, and every later write to that subtree blocked forever. The unlock is now deferred unless pruneEmpty takes the lock over. CompareAndSwap and LoadOrCompute already defer the unlock; a regression test now covers all three. The doc comments now say where eq runs: CompareAndSwap calls it once without the lock to find the entry and again with it, so in both methods it must not use the map. Deviation from upstream internal/sync.HashTrieMap: upstream CompareAndDelete unlocks explicitly on each path, as this code did. It only compares values with the runtime's type equality, so the same hazard exists there for sync.Map values of a non-comparable dynamic type; here eq is arbitrary user code, so the unlock is deferred. Co-Authored-By: Claude Opus 5.5 --- map.go | 23 ++++++--- map_extra_test.go | 2 + map_panic_test.go | 116 ++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 134 insertions(+), 7 deletions(-) create mode 100644 map_panic_test.go diff --git a/map.go b/map.go index 98a8574..2242460 100644 --- a/map.go +++ b/map.go @@ -355,8 +355,9 @@ func (m *Map[K, V]) Swap(key K, value V) (previous V, loaded bool) { } // CompareAndSwap swaps the old and new values for key if the value stored in -// the map is equal to old according to eq. The eq function is called while the -// node of the key is locked. +// the map is equal to old according to eq. The eq function may be called more +// than once: to find the entry, and again while the node of the key is locked, +// so it must not use m. If eq panics, the node is unlocked. // // If there is no current value for key in the map, CompareAndSwap returns false. func (m *Map[K, V]) CompareAndSwap(key K, old, new V, eq func(current, old V) bool) (swapped bool) { @@ -441,7 +442,8 @@ func (m *Map[K, V]) Delete(key K) { } // CompareAndDelete deletes the entry for key if its value is equal to old -// according to eq. The eq function is called while the node of the key is locked. +// according to eq. The eq function is called while the node of the key is +// locked, so it must not use m. If eq panics, the node is unlocked. // // If there is no current value for key in the map, CompareAndDelete returns false. func (m *Map[K, V]) CompareAndDelete(key K, old V, eq func(current, old V) bool) (deleted bool) { @@ -455,10 +457,18 @@ func (m *Map[K, V]) CompareAndDelete(key K, old V, eq func(current, old V) bool) // Find a node with the key. n != nil if we found the node. i, hashShift, slot, n := m.find(key, hash, nil, old) - if n == nil { - if i != nil { + if i == nil { + return false + } + // i.mu is unlocked by the deferred call unless pruneEmpty takes it over, + // so that a panic in eq does not leave the node locked. + locked := true + defer func() { + if locked { i.mu.Unlock() } + }() + if n == nil { return false } @@ -466,20 +476,19 @@ func (m *Map[K, V]) CompareAndDelete(key K, old V, eq func(current, old V) bool) e, deleted := n.entry().compareAndDelete(key, old, eq) if !deleted { // Nothing was actually deleted, which means the node is no longer there. - i.mu.Unlock() return false } if e != nil { // We didn't actually delete the whole entry, just one entry in the chain. // Nothing else to do, since the parent is definitely not empty. slot.Store(&e.node) - i.mu.Unlock() return true } // Delete the entry. slot.Store(nil) // Check if the node is now empty (and isn't the root), and delete it if able. + locked = false m.pruneEmpty(i, hash, hashShift) return true } diff --git a/map_extra_test.go b/map_extra_test.go index 1afe857..36f0ff7 100644 --- a/map_extra_test.go +++ b/map_extra_test.go @@ -170,6 +170,8 @@ func TestNoAlloc(t *testing.T) { //nolint:paralleltest // AllocsPerRun "LoadOrStoreExists": func() { m.LoadOrStore("gamma", 0) }, "DeleteMissing": func() { m.Delete("omega") }, "CompareAndSwapNo": func() { m.CompareAndSwap("gamma", -1, 0) }, + "CompareAndDelNo": func() { m.CompareAndDelete("gamma", -1) }, + "CompareAndDelMiss": func() { m.CompareAndDelete("omega", 0) }, "Range": func() { m.Range(func(string, int) bool { return true }) }, "Len": func() { m.Len() }, "Empty": func() { m.Empty() }, diff --git a/map_panic_test.go b/map_panic_test.go new file mode 100644 index 0000000..39e3af1 --- /dev/null +++ b/map_panic_test.go @@ -0,0 +1,116 @@ +package gosync_test + +import ( + "testing" + "time" + + "github.com/darxnet/gosync" +) + +// mustPanic calls f and fails the test if it does not panic. +func mustPanic(t *testing.T, name string, f func()) { + t.Helper() + + defer func() { + if recover() == nil { + t.Errorf("%s did not panic", name) + } + }() + + f() +} + +// completes fails the test if f does not return in time: a node left locked +// by a panic makes the next write to its subtree block forever. +func completes(t *testing.T, name string, f func()) { + t.Helper() + + done := make(chan struct{}) + + go func() { + defer close(done) + + f() + }() + + select { + case <-done: + case <-time.After(5 * time.Second): + t.Fatalf("%s blocked: a node is still locked after a panic in user code", name) + } +} + +// TestUserCodePanicUnlocks checks that a panic in a user function called with +// a node locked (eq, compute, or == on values of a dynamic type that is not +// comparable) unlocks the node, so later writes to the same key do not hang. +func TestUserCodePanicUnlocks(t *testing.T) { + t.Parallel() + + panicky := func(_, _ int) bool { panic("eq") } + + t.Run("CompareAndDelete", func(t *testing.T) { + t.Parallel() + + var m gosync.Map[string, int] + m.Store("k", 1) + + mustPanic(t, "CompareAndDelete", func() { m.CompareAndDelete("k", 1, panicky) }) + completes(t, "Store after CompareAndDelete", func() { m.Store("k", 2) }) + + if !m.CompareAndDelete("k", 2, func(a, b int) bool { return a == b }) { + t.Fatal("CompareAndDelete after the panic did not delete") + } + }) + + t.Run("CompareAndDeleteNotComparable", func(t *testing.T) { + t.Parallel() + + var m gosync.ComparableMap[string, any] + m.Store("k", []byte("v")) + + mustPanic(t, "CompareAndDelete", func() { m.CompareAndDelete("k", []byte("v")) }) + completes(t, "Store after CompareAndDelete", func() { m.Store("k", 2) }) + }) + + t.Run("CompareAndDeleteOverflow", func(t *testing.T) { + t.Parallel() + + // every key hashes to 0, so "b" sits in the overflow chain of "a" + m := gosync.NewBadMap[string, any]() + m.Store("b", []byte("v")) + m.Store("a", 1) + + mustPanic(t, "CompareAndDelete", func() { m.CompareAndDelete("b", []byte("v")) }) + completes(t, "Store after CompareAndDelete", func() { m.Store("c", 3) }) + }) + + t.Run("CompareAndSwap", func(t *testing.T) { + t.Parallel() + + var m gosync.Map[string, int] + m.Store("k", 1) + + // the first call is the unlocked lookup, the second runs locked + calls := 0 + eq := func(a, b int) bool { + calls++ + if calls > 1 { + panic("eq") + } + + return a == b + } + + mustPanic(t, "CompareAndSwap", func() { m.CompareAndSwap("k", 1, 2, eq) }) + completes(t, "Store after CompareAndSwap", func() { m.Store("k", 2) }) + }) + + t.Run("LoadOrCompute", func(t *testing.T) { + t.Parallel() + + var m gosync.Map[string, int] + + mustPanic(t, "LoadOrCompute", func() { m.LoadOrCompute("k", func() int { panic("compute") }) }) + completes(t, "Store after LoadOrCompute", func() { m.Store("k", 2) }) + }) +}