Optimised handling of address calculations

Signed-off-by: LiZhenCheng9527 <lizhencheng6@huawei.com>

Author: LiZhenCheng9527

pkg/bpf/bpf.go

@@ -23,6 +23,7 @@ import (
 	"context"
 	"hash/fnv"
 	"net"
+	"net/netip"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -39,6 +40,7 @@ import (
 	"kmesh.net/kmesh/pkg/bpf/workload"
 	"kmesh.net/kmesh/pkg/constants"
 	"kmesh.net/kmesh/pkg/logger"
+	"kmesh.net/kmesh/pkg/nets"
 	"kmesh.net/kmesh/pkg/utils"
 	"kmesh.net/kmesh/pkg/version"
 )
@@ -57,6 +59,12 @@ type BpfLoader struct {
 	versionMap  *ebpf.Map
 }
 
+type KmeshBpfConfig struct {
+	BpfLogLevel uint32
+	NodeIP      [16]byte
+	PodGateway  [16]byte
+}
+
 func NewBpfLoader(config *options.BpfConfig) *BpfLoader {
 	return &BpfLoader{
 		config:     config,
@@ -94,6 +102,8 @@ func (l *BpfLoader) Start() error {
 			return err
 		}
 		l.kmeshConfig = l.workloadObj.GetKmeshConfigMap()
+		// TODO: set bpf prog option in kernel native node
+		l.setBpfProgOptions()
 	}
 
 	// TODO: move start mds out of bpf loader
@@ -103,8 +113,6 @@ func (l *BpfLoader) Start() error {
 		}
 	}
 
-	l.UpdateBpfProgOptions()
-
 	if restart.GetStartType() == restart.Restart {
 		log.Infof("bpf load from last pinPath")
 	}
@@ -271,10 +279,10 @@ func recoverVersionMap(pinPath string) *ebpf.Map {
 	return versionMap
 }
 
-func (l *BpfLoader) UpdateBpfProgOptions() {
+func (l *BpfLoader) setBpfProgOptions() {
 	nodeName := os.Getenv("NODE_NAME")
 	if nodeName == "" {
-		log.Errorf("skip kubelet probe failed: %s", "node name empty")
+		log.Error("skip kubelet probe failed: node name empty")
 		return
 	}
 
@@ -291,13 +299,13 @@ func (l *BpfLoader) UpdateBpfProgOptions() {
 	}
 
 	// pass node ip and pod gateway to skip processing of kubelet access traffic.
-	nodeIP := getNodeIPAddress(nodeName, node)
-	gateway := getNodePodSubGateway(nodeName, node)
+	nodeIP := getNodeIPAddress(node)
+	gateway := getNodePodSubGateway(node)
 
 	keyOfKmeshBpfConfig := uint32(0)
-	ValueOfKmeshBpfConfig := constants.KmeshBpfConfig{
+	ValueOfKmeshBpfConfig := KmeshBpfConfig{
 		// Write this map only when the kmesh daemon starts, so set bpfloglevel to the default value.
-		BpfLogLevel: uint32(2),
+		BpfLogLevel: constants.BPF_LOG_INFO,
 		NodeIP:      nodeIP,
 		PodGateway:  gateway,
 	}
@@ -312,7 +320,7 @@ func (l *BpfLoader) UpdateBpfProgOptions() {
 	}
 }
 
-func getNodeIPAddress(nodeName string, node *corev1.Node) [4]uint32 {
+func getNodeIPAddress(node *corev1.Node) [16]byte {
 	var nodeIPStr string
 	nodeAddresses := node.Status.Addresses
 	for _, address := range nodeAddresses {
@@ -321,65 +329,30 @@ func getNodeIPAddress(nodeName string, node *corev1.Node) [4]uint32 {
 		}
 	}
 
-	nodeIP := net.ParseIP(nodeIPStr)
-	nodeIPToUint := IPToUint32(nodeIP)
+	nodeIP, err := netip.ParseAddr(nodeIPStr)
+	if err != nil {
+		log.Errorf("failed to parse node ip: %v", err)
+		return [16]byte{}
+	}
 
-	return nodeIPToUint
+	return nodeIP.As16()
 }
 
-func getNodePodSubGateway(nodeName string, node *corev1.Node) [4]uint32 {
+func getNodePodSubGateway(node *corev1.Node) [16]byte {
 	podCIDR := node.Spec.PodCIDR
-	ip, _, err := net.ParseCIDR(podCIDR)
+	_, subNet, err := net.ParseCIDR(podCIDR)
 	if err != nil {
 		log.Errorf("failed to resolve ip from podCIDR: %v", err)
-		return [4]uint32{0, 0, 0, 0}
-	}
-
-	podGateway := IPToUint32(ip)
-	podGateway[3] = podGateway[3] + 1<<24
-	return podGateway
-}
-
-func IPToUint32(ip net.IP) [4]uint32 {
-	ipToUint32 := [4]uint32{0, 0, 0, 0}
-	if isIPv6(ip) {
-		ipToUint32[0] = binaryToUint32(ip[:4])
-		ipToUint32[1] = binaryToUint32(ip[4:8])
-		ipToUint32[2] = binaryToUint32(ip[8:12])
-		ipToUint32[3] = binaryToUint32(ip[12:16])
-	} else {
-		if len(ip) == 16 {
-			// ipv4 to ipv6
-			ipToUint32[3] = binaryToUint32(ip[12:16])
-		} else {
-			ipToUint32[3] = binaryToUint32(ip)
-		}
+		return [16]byte{0}
 	}
-
-	return ipToUint32
-}
-
-func isIPv6(ip net.IP) bool {
-	if len(ip) == 16 {
-		for i := 0; i < 10; i++ {
-			if ip[i] != 0 {
-				return true
-			}
-		}
-
-		if ip[10] != 0xff {
-			return true
-		}
-
-		if ip[11] != 0xff {
-			return true
-		}
+	podGateway := [16]byte{0}
+	nets.CopyIpByteFromSlice(&podGateway, subNet.IP.To16())
+	if err != nil {
+		log.Errorf("failed to parse pod gateway: %v", err)
+		return [16]byte{}
 	}
-	return false
-}
-
-func binaryToUint32(ip net.IP) uint32 {
-	return uint32(ip[3])<<24 + uint32(ip[2])<<16 + uint32(ip[1])<<8 + uint32(ip[0])
+	podGateway[15] = podGateway[15] + 1
+	return podGateway
 }
 
 func closeMap(m *ebpf.Map) {

pkg/bpf/bpf_test.go

@@ -22,8 +22,11 @@ import (
 	"syscall"
 	"testing"
 
+	"reflect"
+
 	"github.com/cilium/ebpf/rlimit"
 	"github.com/stretchr/testify/assert"
+	corev1 "k8s.io/api/core/v1"
 
 	"kmesh.net/kmesh/daemon/options"
 	"kmesh.net/kmesh/pkg/bpf/restart"
@@ -106,3 +109,33 @@ func runTestRestart(t *testing.T) {
 	restart.SetExitType(restart.Normal)
 	bpfLoader.Stop()
 }
+
+func TestGetNodePodSubGateway(t *testing.T) {
+	type args struct {
+		node *corev1.Node
+	}
+	tests := []struct {
+		name string
+		args args
+		want [16]byte
+	}{
+		{
+			name: "test Generated nodeIP",
+			args: args{
+				node: &corev1.Node{
+					Spec: corev1.NodeSpec{
+						PodCIDR: "10.244.0.0/24",
+					},
+				},
+			},
+			want: [16]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 10, 244, 0, 1},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := getNodePodSubGateway(tt.args.node); !reflect.DeepEqual(got, tt.want) {
+				assert.Equal(t, tt.want, got)
+			}
+		})
+	}
+}

pkg/constants/constants.go

@@ -61,9 +61,3 @@ const (
 	VersionPath         = "/bpf_kmesh/map/"
 	WorkloadVersionPath = "/bpf_kmesh_workload/map/"
 )
-
-type KmeshBpfConfig struct {
-	BpfLogLevel uint32
-	NodeIP      [4]uint32
-	PodGateway  [4]uint32
-}

pkg/status/status_server.go

@@ -33,6 +33,7 @@ import (
 	adminv2 "kmesh.net/kmesh/api/v2/admin"
 	"kmesh.net/kmesh/api/v2/workloadapi/security"
 	"kmesh.net/kmesh/daemon/options"
+	"kmesh.net/kmesh/pkg/bpf"
 	bpfads "kmesh.net/kmesh/pkg/bpf/ads"
 	maps_v2 "kmesh.net/kmesh/pkg/cache/v2/maps"
 	"kmesh.net/kmesh/pkg/constants"
@@ -407,7 +408,7 @@ func (s *Server) readyProbe(w http.ResponseWriter, r *http.Request) {
 
 func (s *Server) getBpfLogLevel() (*LoggerInfo, error) {
 	key := uint32(0)
-	value := constants.KmeshBpfConfig{}
+	value := bpf.KmeshBpfConfig{}
 	if err := s.kmeshConfigMap.Lookup(&key, &value); err != nil {
 		return nil, fmt.Errorf("get log level error: %v", err)
 	}
@@ -451,7 +452,7 @@ func (s *Server) setBpfLogLevel(w http.ResponseWriter, levelStr string) {
 		return
 	}
 	key := uint32(0)
-	value := constants.KmeshBpfConfig{}
+	value := bpf.KmeshBpfConfig{}
 	if s.kmeshConfigMap == nil {
 		http.Error(w, fmt.Sprintf("update log level error: %v", "kmeshConfigMap is nil"), http.StatusBadRequest)
 		return