fix: Clean up interfaceLockMap entries on endpoint deletion

pkg/plugin/packetparser/packetparser_linux.go

@@ -373,33 +373,44 @@ func (p *packetParser) clean(rtnl nltc, qdisc *tc.Object) {
 }
 
 func (p *packetParser) endpointWatcherCallbackFn(obj interface{}) {
-	// Contract is that we will receive an endpoint event pointer.
 	event := obj.(*endpoint.EndpointEvent)
 	if event == nil {
 		return
 	}
 
 	iface := event.Obj.(netlink.LinkAttrs)
-
 	ifaceKey := ifaceToKey(iface)
-	lockMapVal, _ := p.interfaceLockMap.LoadOrStore(ifaceKey, &sync.Mutex{})
-	mu := lockMapVal.(*sync.Mutex)
-	mu.Lock()
-	defer mu.Unlock()
 
 	switch event.Type {
 	case endpoint.EndpointCreated:
-		p.l.Debug("Endpoint created", zap.String("name", iface.Name))
-		p.createQdiscAndAttach(iface, Veth)
+		// Get or create mutex atomically
+		lockMapVal, loaded := p.interfaceLockMap.LoadOrStore(ifaceKey, &sync.Mutex{})
+		mu := lockMapVal.(*sync.Mutex)
+		mu.Lock()
+		defer mu.Unlock()
+
+		// Only proceed with creation if this is a new interface
+		if !loaded {
+			p.l.Debug("Endpoint created", zap.String("name", iface.Name))
+			p.createQdiscAndAttach(iface, Veth)
+		}
+
 	case endpoint.EndpointDeleted:
-		p.l.Debug("Endpoint deleted", zap.String("name", iface.Name))
-		// Clean.
+		lockMapVal, ok := p.interfaceLockMap.Load(ifaceKey)
+		if !ok {
+			return
+		}
+		mu := lockMapVal.(*sync.Mutex)
+		mu.Lock()
+		defer mu.Unlock()
+
+		// Clean up operations
 		if value, ok := p.tcMap.Load(ifaceKey); ok {
 			v := value.(*tcValue)
 			p.clean(v.tc, v.qdisc)
-			// Delete from map.
 			p.tcMap.Delete(ifaceKey)
 		}
+		p.interfaceLockMap.Delete(ifaceKey)
 	default:
 		// Unknown.
 		p.l.Debug("Unknown event", zap.String("type", event.Type.String()))

pkg/plugin/packetparser/packetparser_linux_test.go

@@ -162,18 +162,24 @@ func TestEndpointWatcherCallbackFn_EndpointDeleted(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 
+	// Initialize packetParser with both maps.
 	p := &packetParser{
 		cfg:              cfgPodLevelEnabled,
 		l:                log.Logger().Named("test"),
 		interfaceLockMap: &sync.Map{},
+		tcMap:            &sync.Map{},
 	}
-	p.tcMap = &sync.Map{}
+
+	// Create test interface attributes.
 	linkAttr := netlink.LinkAttrs{
 		Name:         "test",
 		HardwareAddr: []byte("test"),
 		NetNsID:      1,
 	}
 	key := ifaceToKey(linkAttr)
+
+	// Pre-populate both maps to simulate existing interface
+	p.interfaceLockMap.Store(key, &sync.Mutex{})
 	p.tcMap.Store(key, &tcValue{nil, &tc.Object{}})
 
 	// Create EndpointDeleted event.
@@ -182,10 +188,16 @@ func TestEndpointWatcherCallbackFn_EndpointDeleted(t *testing.T) {
 		Obj:  linkAttr,
 	}
 
+	// Execute the callback.
 	p.endpointWatcherCallbackFn(e)
 
-	_, ok := p.tcMap.Load(key)
-	assert.False(t, ok)
+	// Verify both maps are cleaned up.
+	_, tcMapExists := p.tcMap.Load(key)
+	_, lockMapExists := p.interfaceLockMap.Load(key)
+
+	// Assert both maps are cleaned up
+	assert.False(t, tcMapExists, "tcMap entry should be deleted")
+	assert.False(t, lockMapExists, "interfaceLockMap entry should be deleted")
 }
 
 func TestCreateQdiscAndAttach(t *testing.T) {