Merge pull request #796 from hzxuzhonghu/start-type

some cleanups and rename on start type

Author: kmesh-bot

daemon/manager/manager.go

@@ -113,7 +113,8 @@ func Execute(configs *options.BootstrapConfigs) error {
 	log.Info("start cni successfully")
 
 	setupSignalHandler()
-	bpf.SetCloseStatus()
+	// set exit type, which can be used by bpf loader to decide whether to cleanup bpf prog
+	bpf.SetExitType()
 	return nil
 }
 

pkg/bpf/bpf.go

@@ -58,13 +58,13 @@ type BpfLoader struct {
 	obj         *BpfKmesh
 	workloadObj *BpfKmeshWorkload
 	bpfLogLevel *ebpf.Map
-	VersionMap  *ebpf.Map
+	versionMap  *ebpf.Map
 }
 
 func NewBpfLoader(config *options.BpfConfig) *BpfLoader {
 	return &BpfLoader{
 		config:     config,
-		VersionMap: NewVersionMap(config),
+		versionMap: NewVersionMap(config),
 	}
 }
 
@@ -119,7 +119,7 @@ func StartMda() error {
 func (l *BpfLoader) Start(config *options.BpfConfig) error {
 	var err error
 
-	if l.VersionMap == nil {
+	if l.versionMap == nil {
 		return fmt.Errorf("NewVersionMap failed")
 	}
 
@@ -173,12 +173,12 @@ func StopMda() error {
 
 func (l *BpfLoader) Stop() {
 	var err error
-	if GetStartType() == Restart {
+	if GetExitType() == Restart {
 		log.Infof("kmesh restart, not clean bpf map and prog")
 		return
 	}
 
-	Close(l.VersionMap)
+	closeMap(l.versionMap)
 
 	if l.config.AdsEnabled() {
 		C.deserial_uninit()
@@ -206,14 +206,15 @@ func NewVersionMap(config *options.BpfConfig) *ebpf.Map {
 	var versionPath string
 	var versionMap *ebpf.Map
 	if config.AdsEnabled() {
-		versionPath = filepath.Join(config.BpfFsPath + constants.VersionPath)
+		versionPath = filepath.Join(config.BpfFsPath, constants.VersionPath)
 	} else if config.WdsEnabled() {
-		versionPath = filepath.Join(config.BpfFsPath + constants.WorkloadVersionPath)
+		versionPath = filepath.Join(config.BpfFsPath, constants.WorkloadVersionPath)
 	}
 
+	versionMapPinPath := filepath.Join(versionPath, "kmesh_version")
 	_, err := os.Stat(versionPath)
 	if err == nil {
-		versionMap = recoverVersionMap(config, versionPath)
+		versionMap = recoverVersionMap(versionMapPinPath)
 		if versionMap != nil {
 			SetStartStatus(versionMap)
 		}
@@ -229,8 +230,7 @@ func NewVersionMap(config *options.BpfConfig) *ebpf.Map {
 	}
 
 	// Make sure the directory about to use is clean
-	kmeshBpfPath := filepath.Dir(versionPath)
-	err = os.RemoveAll(kmeshBpfPath)
+	err = os.RemoveAll(versionPath)
 	if err != nil {
 		log.Errorf("Clean bpf maps and progs failed, err is:%v", err)
 		return nil
@@ -255,7 +255,7 @@ func NewVersionMap(config *options.BpfConfig) *ebpf.Map {
 		return nil
 	}
 
-	err = m.Pin(filepath.Join(versionPath + "/kmesh_version"))
+	err = m.Pin(versionMapPinPath)
 	if err != nil {
 		log.Errorf("kmesh_version pin failed: %v", err)
 		return nil
@@ -288,14 +288,14 @@ func getOldVersionFromMap(m *ebpf.Map, key uint32) uint32 {
 	return value
 }
 
-func recoverVersionMap(config *options.BpfConfig, versionPath string) *ebpf.Map {
+func recoverVersionMap(pinPath string) *ebpf.Map {
 	opts := &ebpf.LoadPinOptions{
 		ReadOnly:  false,
 		WriteOnly: false,
 		Flags:     0,
 	}
 
-	versionMap, err := ebpf.LoadPinnedMap(filepath.Join(versionPath+"/kmesh_version"), opts)
+	versionMap, err := ebpf.LoadPinnedMap(pinPath, opts)
 	if err != nil {
 		log.Infof("kmesh version map loadfailed: %v, start normally", err)
 
@@ -306,17 +306,17 @@ func recoverVersionMap(config *options.BpfConfig, versionPath string) *ebpf.Map
 	return versionMap
 }
 
-func Close(m *ebpf.Map) {
+func closeMap(m *ebpf.Map) {
 	var err error
 	err = m.Unpin()
 	if err != nil {
-		log.Errorf("Failed to Unpin kmesh_version :%v", err)
+		log.Errorf("Failed to unpin kmesh_version: %v", err)
 	}
 
 	err = m.Close()
 	if err != nil {
-		log.Errorf("Failed to Close kmesh_version :%v", err)
+		log.Errorf("Failed to close kmesh_version: %v", err)
 	}
 
-	log.Infof("Clean kmesh_version map and bpf prog")
+	log.Infof("cleaned kmesh_version map")
 }

pkg/bpf/bpf_restart.go

@@ -38,10 +38,10 @@ import (
  *		Normal: a normal new start
  *		Restart: reusing the previous kmesh configuration
  *		Update: upgrading kmesh and reusing part of previous kmesh configuration
- * Close Kmesh:
+ * Exit Kmesh:
  *		Normal: normal close, cleanup all the bpf prog and maps
  *		Restart: not clean kmesh configuration and bpf map, for next launch
- *		Update: not clean part of kmesh configuration, for next launch
+ *		Update: not supported yet
  */
 
 type StartType uint8
@@ -52,8 +52,12 @@ const (
 	Update
 )
 
+// kmeshStartType is used during bootstrap to indicate how to initiate bpf prog and maps
 var kmeshStartType StartType
 
+// kmeshStartType is used during exit to indicate how to cleanup bpf prog and maps
+var kmeshExitType StartType
+
 func GetStartType() StartType {
 	return kmeshStartType
 }
@@ -62,7 +66,15 @@ func SetStartType(Status StartType) {
 	kmeshStartType = Status
 }
 
-func inferRestartStatus() StartType {
+func SetExitType() {
+	kmeshExitType = inferNextStartType()
+}
+
+func GetExitType() StartType {
+	return kmeshExitType
+}
+
+func inferNextStartType() StartType {
 	clientset, err := utils.GetK8sclient()
 	if err != nil {
 		return Normal
@@ -80,10 +92,6 @@ func inferRestartStatus() StartType {
 	return Normal
 }
 
-func SetCloseStatus() {
-	SetStartType(inferRestartStatus())
-}
-
 func SetStartStatus(versionMap *ebpf.Map) {
 	var GitVersion uint32
 	hash.Reset()
@@ -94,6 +102,10 @@ func SetStartStatus(versionMap *ebpf.Map) {
 	if GitVersion == oldGitVersion {
 		log.Infof("kmesh start with Restart, load bpf maps and prog from last")
 		SetStartType(Restart)
+	} else if oldGitVersion == 0 {
+		// version not found, it is a fresh start
+		log.Infof("kmesh start with Normal")
+		SetStartType(Normal)
 	} else {
 		log.Infof("kmesh start with Update")
 		SetStartType(Update)

pkg/bpf/bpf_restart_test.go

@@ -75,8 +75,8 @@ func runTestNormal(t *testing.T) {
 		assert.ErrorIsf(t, err, nil, "bpfLoader start failed %v", err)
 	}
 	assert.Equal(t, Normal, GetStartType(), "set kmesh start status failed")
-	SetCloseStatus()
-	assert.Equal(t, Normal, GetStartType(), "set kmesh close status failed")
+
+	SetExitType()
 	bpfLoader.Stop()
 }
 
@@ -89,24 +89,23 @@ func runTestRestart(t *testing.T) {
 		assert.ErrorIsf(t, err, nil, "bpfLoader start failed %v", err)
 	}
 	assert.Equal(t, Normal, GetStartType(), "set kmesh start status:Normal failed")
-	SetStartType(Restart)
+	kmeshExitType = Restart
 	bpfLoader.Stop()
-	assert.Equal(t, Restart, GetStartType(), "set kmesh close status:Restart failed")
 
 	if config.AdsEnabled() {
 		versionPath = filepath.Join(config.BpfFsPath + "/bpf_kmesh/map/")
 	} else if config.WdsEnabled() {
 		versionPath = filepath.Join(config.BpfFsPath + "/bpf_kmesh_workload/map/")
 	}
 	_, err := os.Stat(versionPath)
-	assert.ErrorIsf(t, err, nil, "bpfLoader Stop failed,versionPath is not exist: %v", err)
+	assert.ErrorIsf(t, err, nil, "bpfLoader Stop failed, versionPath is not exist: %v", err)
 
 	// Restart
 	bpfLoader = NewBpfLoader(&config)
 	if err := bpfLoader.Start(&config); err != nil {
 		assert.ErrorIsf(t, err, nil, "bpfLoader start failed %v", err)
 	}
 	assert.Equal(t, Restart, GetStartType(), "set kmesh start status:Restart failed")
-	SetStartType(Normal)
+	kmeshExitType = Normal
 	bpfLoader.Stop()
 }