fix: Clean up interfaceLockMap entries on endpoint deletion

pkg/plugin/packetparser/packetparser_linux.go

@@ -380,26 +380,38 @@ func (p *packetParser) endpointWatcherCallbackFn(obj interface{}) {
 	}
 
 	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:
+		// Create mutex only when needed
+		lockMapVal, _ := p.interfaceLockMap.LoadOrStore(ifaceKey, &sync.Mutex{})
+		mu := lockMapVal.(*sync.Mutex)
+		mu.Lock()
+		defer mu.Unlock()
+
 		p.l.Debug("Endpoint created", zap.String("name", iface.Name))
 		p.createQdiscAndAttach(iface, Veth)
 	case endpoint.EndpointDeleted:
+		// Get the mutex only if it exists
+		lockMapVal, exists := p.interfaceLockMap.Load(ifaceKey)
+		if !exists {
+			return
+		}
+		mu := lockMapVal.(*sync.Mutex)
+		mu.Lock()
+		defer mu.Unlock()
+
 		p.l.Debug("Endpoint deleted", zap.String("name", iface.Name))
-		// Clean.
+		// Clean tcMap.
 		if value, ok := p.tcMap.Load(ifaceKey); ok {
 			v := value.(*tcValue)
 			p.clean(v.tc, v.qdisc)
-			// Delete from map.
 			p.tcMap.Delete(ifaceKey)
 		}
+
+		// Clean interfaceLockMap.
+		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) {