Test

Signed-off-by: Anastasios Papagiannis <tasos.papagiannnis@gmail.com>

pkg/selectors/kernel.go

@@ -1258,16 +1258,16 @@ func parseSelector(
 //
 // For some examples, see kernel_test.go
 func InitKernelSelectors(selectors []v1alpha1.KProbeSelector, args []v1alpha1.KProbeArg, actionArgTable *idtable.Table) ([4096]byte, error) {
-	kernelSelectors, err := InitKernelSelectorState(selectors, args, actionArgTable, nil)
+	kernelSelectors, err := InitKernelSelectorState(selectors, args, actionArgTable, nil, true)
 	if err != nil {
 		return [4096]byte{}, err
 	}
 	return kernelSelectors.e, nil
 }
 
 func InitKernelSelectorState(selectors []v1alpha1.KProbeSelector, args []v1alpha1.KProbeArg,
-	actionArgTable *idtable.Table, listReader ValueReader) (*KernelSelectorState, error) {
-	kernelSelectors := NewKernelSelectorState(listReader)
+	actionArgTable *idtable.Table, listReader ValueReader, newMaps bool) (*KernelSelectorState, error) {
+	kernelSelectors := NewKernelSelectorState(listReader, newMaps)
 
 	WriteSelectorUint32(kernelSelectors, uint32(len(selectors)))
 	soff := make([]uint32, len(selectors))

pkg/selectors/kernel_test.go

@@ -318,7 +318,7 @@ func TestParseMatchArg(t *testing.T) {
 		expected3 := append(length, expected1[:]...)
 		expected3 = append(expected3, expected2[:]...)
 		arg12 := []v1alpha1.ArgSelector{*arg1, *arg2}
-		ks := &KernelSelectorState{off: 0}
+		ks := NewKernelSelectorState(nil, true)
 		if err := ParseMatchArgs(ks, arg12, sig); err != nil || bytes.Equal(expected3, ks.e[0:ks.off]) == false {
 			t.Errorf("parseMatchArgs: error %v expected:\n%v\nbytes:\n%v\nparsing %v\n", err, expected3, ks.e[0:k.off], arg3)
 		}

pkg/selectors/selectors.go

@@ -75,6 +75,10 @@ type KernelLPMTrieStringPostfix struct {
 	data      [StringPostfixMaxLength]byte
 }
 
+var gStringMaps StringMapLists
+var gStringPrefixMaps []map[KernelLPMTrieStringPrefix]struct{}
+var gStringPostfixMaps []map[KernelLPMTrieStringPostfix]struct{}
+
 type KernelSelectorState struct {
 	off uint32     // offset into encoding
 	e   [4096]byte // kernel encoding of selectors
@@ -93,19 +97,29 @@ type KernelSelectorState struct {
 
 	listReader ValueReader
 	// stringMaps are used to populate string and char buf matches
-	stringMaps StringMapLists
+	stringMaps *StringMapLists
 
 	// stringPrefixMaps are used to populate string and char buf prefix matches
-	stringPrefixMaps []map[KernelLPMTrieStringPrefix]struct{}
+	stringPrefixMaps *[]map[KernelLPMTrieStringPrefix]struct{}
 	// stringPostfixMaps are used to populate string and char buf postfix matches
-	stringPostfixMaps []map[KernelLPMTrieStringPostfix]struct{}
+	stringPostfixMaps *[]map[KernelLPMTrieStringPostfix]struct{}
 }
 
-func NewKernelSelectorState(listReader ValueReader) *KernelSelectorState {
+func NewKernelSelectorState(listReader ValueReader, newMaps bool) *KernelSelectorState {
+	if newMaps {
+		for i := 0; i < StringMapsNumSubMaps; i++ {
+			gStringMaps[i] = nil
+		}
+		gStringPrefixMaps = nil
+		gStringPostfixMaps = nil
+	}
 	return &KernelSelectorState{
-		matchBinaries: make(map[int]*MatchBinariesMappings),
-		newBinVals:    make(map[uint32]string),
-		listReader:    listReader,
+		matchBinaries:     make(map[int]*MatchBinariesMappings),
+		newBinVals:        make(map[uint32]string),
+		listReader:        listReader,
+		stringMaps:        &gStringMaps,
+		stringPrefixMaps:  &gStringPrefixMaps,
+		stringPostfixMaps: &gStringPostfixMaps,
 	}
 }
 
@@ -169,11 +183,11 @@ func (k *KernelSelectorState) StringMaps(subMap int) []map[[MaxStringMapsSize]by
 }
 
 func (k *KernelSelectorState) StringPrefixMaps() []map[KernelLPMTrieStringPrefix]struct{} {
-	return k.stringPrefixMaps
+	return *k.stringPrefixMaps
 }
 
 func (k *KernelSelectorState) StringPostfixMaps() []map[KernelLPMTrieStringPostfix]struct{} {
-	return k.stringPostfixMaps
+	return *k.stringPostfixMaps
 }
 
 // ValueMapsMaxEntries returns the maximum entries over all maps
@@ -223,7 +237,7 @@ func (k *KernelSelectorState) StringMapsMaxEntries(subMap int) int {
 // StringPrefixMapsMaxEntries returns the maximum entries over all maps
 func (k *KernelSelectorState) StringPrefixMapsMaxEntries() int {
 	maxEntries := 1
-	for _, vm := range k.stringPrefixMaps {
+	for _, vm := range *k.stringPrefixMaps {
 		if l := len(vm); l > maxEntries {
 			maxEntries = l
 		}
@@ -234,7 +248,7 @@ func (k *KernelSelectorState) StringPrefixMapsMaxEntries() int {
 // StringPostfixMapsMaxEntries returns the maximum entries over all maps
 func (k *KernelSelectorState) StringPostfixMapsMaxEntries() int {
 	maxEntries := 1
-	for _, vm := range k.stringPostfixMaps {
+	for _, vm := range *k.stringPostfixMaps {
 		if l := len(vm); l > maxEntries {
 			maxEntries = l
 		}
@@ -402,8 +416,8 @@ func (k *KernelSelectorState) insertStringMaps(stringMaps SelectorStringMaps) [S
 
 	for subMap := 0; subMap < StringMapsNumSubMaps; subMap++ {
 		if len(stringMaps[subMap]) > 0 {
-			mapid = uint32(len(k.stringMaps[subMap]))
-			k.stringMaps[subMap] = append(k.stringMaps[subMap], stringMaps[subMap])
+			mapid = uint32(len(gStringMaps[subMap]))
+			gStringMaps[subMap] = append(gStringMaps[subMap], stringMaps[subMap])
 		} else {
 			mapid = 0xffffffff
 		}
@@ -414,13 +428,13 @@ func (k *KernelSelectorState) insertStringMaps(stringMaps SelectorStringMaps) [S
 }
 
 func (k *KernelSelectorState) newStringPrefixMap() (uint32, map[KernelLPMTrieStringPrefix]struct{}) {
-	mapid := len(k.stringPrefixMaps)
-	k.stringPrefixMaps = append(k.stringPrefixMaps, map[KernelLPMTrieStringPrefix]struct{}{})
-	return uint32(mapid), k.stringPrefixMaps[mapid]
+	mapid := len(gStringPrefixMaps)
+	gStringPrefixMaps = append(gStringPrefixMaps, map[KernelLPMTrieStringPrefix]struct{}{})
+	return uint32(mapid), gStringPrefixMaps[mapid]
 }
 
 func (k *KernelSelectorState) newStringPostfixMap() (uint32, map[KernelLPMTrieStringPostfix]struct{}) {
-	mapid := len(k.stringPostfixMaps)
-	k.stringPostfixMaps = append(k.stringPostfixMaps, map[KernelLPMTrieStringPostfix]struct{}{})
-	return uint32(mapid), k.stringPostfixMaps[mapid]
+	mapid := len(gStringPostfixMaps)
+	gStringPostfixMaps = append(gStringPostfixMaps, map[KernelLPMTrieStringPostfix]struct{}{})
+	return uint32(mapid), gStringPostfixMaps[mapid]
 }

pkg/sensors/tracing/generickprobe.go

@@ -528,7 +528,7 @@ func createGenericKprobeSensor(
 		kprobes[i].Syscall = syscall
 
 		for idx := range syms {
-			out, err := addKprobe(syms[idx], &kprobes[i], &in)
+			out, err := addKprobe(i, syms[idx], &kprobes[i], &in)
 			if err != nil {
 				return nil, err
 			}
@@ -581,7 +581,7 @@ func createGenericKprobeSensor(
 // addKprobe will, amongst other things, create a generic kprobe entry and add
 // it to the genericKprobeTable. The caller should make sure that this entry is
 // properly removed on kprobe unload.
-func addKprobe(funcName string, f *v1alpha1.KProbeSpec, in *addKprobeIn) (out *addKprobeOut, err error) {
+func addKprobe(index int, funcName string, f *v1alpha1.KProbeSpec, in *addKprobeIn) (out *addKprobeOut, err error) {
 	var argSigPrinters []argPrinters
 	var argReturnPrinters []argPrinters
 	var setRetprobe bool
@@ -747,7 +747,7 @@ func addKprobe(funcName string, f *v1alpha1.KProbeSpec, in *addKprobeIn) (out *a
 	}
 
 	// Parse Filters into kernel filter logic
-	kprobeEntry.loadArgs.selectors, err = selectors.InitKernelSelectorState(f.Selectors, f.Args, &kprobeEntry.actionArgs, nil)
+	kprobeEntry.loadArgs.selectors, err = selectors.InitKernelSelectorState(f.Selectors, f.Args, &kprobeEntry.actionArgs, nil, !in.useMulti || (in.useMulti && index == 0))
 	if err != nil {
 		return nil, err
 	}

pkg/sensors/tracing/generictracepoint.go

@@ -508,7 +508,7 @@ func (tp *genericTracepoint) InitKernelSelectors(lists []v1alpha1.ListSpec) erro
 		}
 	}
 
-	selectors, err := selectors.InitKernelSelectorState(selSelectors, selArgs, &tp.actionArgs, &listReader{lists})
+	selectors, err := selectors.InitKernelSelectorState(selSelectors, selArgs, &tp.actionArgs, &listReader{lists}, true)
 	if err != nil {
 		return err
 	}

pkg/sensors/tracing/genericuprobe.go

@@ -200,7 +200,7 @@ func createGenericUprobeSensor(
 		}
 
 		// Parse Filters into kernel filter logic
-		uprobeSelectorState, err := selectors.InitKernelSelectorState(spec.Selectors, args, nil, nil)
+		uprobeSelectorState, err := selectors.InitKernelSelectorState(spec.Selectors, args, nil, nil, true)
 		if err != nil {
 			return nil, err
 		}