Support ads bpf map lookup all

bpf/deserialization_to_bpf_map/deserialization_to_bpf_map.c

@@ -19,9 +19,15 @@
 #include "deserialization_to_bpf_map.h"
 #include "../../config/kmesh_marcos_def.h"
 
-#define LOG_ERR(fmt, args...)  printf(fmt, ##args)
-#define LOG_WARN(fmt, args...) printf(fmt, ##args)
-#define LOG_INFO(fmt, args...) printf(fmt, ##args)
+#define PRINTF(fmt, args...)                                                                                           \
+    do {                                                                                                               \
+        printf(fmt, ##args);                                                                                           \
+        fflush(stdout);                                                                                                \
+    } while (0)
+
+#define LOG_ERR(fmt, args...)  PRINTF(fmt, ##args)
+#define LOG_WARN(fmt, args...) PRINTF(fmt, ##args)
+#define LOG_INFO(fmt, args...) PRINTF(fmt, ##args)
 
 struct op_context {
     void *key;
@@ -37,10 +43,10 @@ struct op_context {
     const ProtobufCMessageDescriptor *desc;
 };
 
-#define init_op_context(context, key, val, desc, o_fd, fd, o_info, i_info, m_info)                                     \
+#define init_op_context(context, k, v, desc, o_fd, fd, o_info, i_info, m_info)                                         \
     do {                                                                                                               \
-        (context).key = (key);                                                                                         \
-        (context).value = (val);                                                                                       \
+        (context).key = (k);                                                                                           \
+        (context).value = (v);                                                                                         \
         (context).desc = (desc);                                                                                       \
         (context).outter_fd = (o_fd);                                                                                  \
         (context).map_fd = (fd);                                                                                       \
@@ -771,6 +777,56 @@ static int repeat_field_query(struct op_context *ctx, const ProtobufCFieldDescri
     return ret;
 }
 
+void deserial_free_elem_list(struct element_list_node *head)
+{
+    while (head != NULL) {
+        struct element_list_node *n = head;
+        deserial_free_elem(n->elem);
+        head = n->next;
+        free(n);
+    }
+}
+
+static void *create_struct_list(struct op_context *ctx, int *err)
+{
+    void *prev_key = NULL;
+    void *value;
+    struct element_list_node *elem_list_head = NULL;
+    struct element_list_node *curr_elem_list_node = NULL;
+
+    *err = 0;
+    ctx->key = calloc(1, ctx->curr_info->key_size);
+    while (!bpf_map_get_next_key(ctx->curr_fd, prev_key, ctx->key)) {
+        prev_key = ctx->key;
+
+        value = create_struct(ctx, err);
+        if (*err != 0) {
+            LOG_ERR("create_struct failed, err = %d\n", err);
+            deserial_free_elem_list(elem_list_head);
+            value = NULL;
+        }
+
+        if (value == NULL) {
+            continue;
+        }
+
+        struct element_list_node *new_node = (struct element_list_node *)calloc(1, sizeof(struct element_list_node));
+        if (!new_node) {
+            deserial_free_elem_list(elem_list_head);
+            return NULL;
+        }
+        new_node->elem = value;
+        new_node->next = NULL;
+        if (curr_elem_list_node == NULL) {
+            curr_elem_list_node = elem_list_head = new_node;
+        } else {
+            curr_elem_list_node->next = new_node;
+            curr_elem_list_node = new_node;
+        }
+    }
+    return elem_list_head;
+}
+
 static void *create_struct(struct op_context *ctx, int *err)
 {
     void *value;
@@ -821,6 +877,61 @@ static void *create_struct(struct op_context *ctx, int *err)
     return value;
 }
 
+struct element_list_node *deserial_lookup_all_elems(const void *msg_desciptor)
+{
+    int ret, err;
+    struct element_list_node *value_list_head = NULL;
+    const char *map_name = NULL;
+    struct op_context context = {.inner_map_object = NULL};
+    const ProtobufCMessageDescriptor *desc;
+    struct bpf_map_info outter_info = {0}, inner_info = {0}, info = {0};
+    int map_fd, outter_fd = 0, inner_fd = 0;
+    unsigned int id, outter_id = 0, inner_id = 0;
+
+    if (msg_desciptor == NULL)
+        return NULL;
+
+    desc = (ProtobufCMessageDescriptor *)msg_desciptor;
+    if (desc->magic != PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC)
+        return NULL;
+
+    map_name = desc->short_name;
+    ret = get_map_ids(map_name, &id, &outter_id, &inner_id);
+    if (ret)
+        return NULL;
+
+    ret = get_map_fd_info(id, &map_fd, &info);
+    if (ret < 0) {
+        LOG_ERR("invalid MAP_ID: %d\n", id);
+        return NULL;
+    }
+
+    ret = get_map_fd_info(inner_id, &inner_fd, &inner_info);
+    ret |= get_map_fd_info(outter_id, &outter_fd, &outter_info);
+    if (ret < 0 || map_info_check(&outter_info, &inner_info))
+        goto end;
+
+    init_op_context(context, NULL, NULL, desc, outter_fd, map_fd, &outter_info, &inner_info, &info);
+
+    value_list_head = create_struct_list(&context, &err);
+    if (err != 0) {
+        LOG_ERR("create_struct_list failed, err = %d", err);
+        deserial_free_elem_list(value_list_head);
+        value_list_head = NULL;
+    }
+
+end:
+    if (context.key != NULL)
+        free(context.key);
+    if (map_fd > 0)
+        close(map_fd);
+    if (outter_fd > 0)
+        close(outter_fd);
+    if (inner_fd > 0)
+        close(inner_fd);
+    return value_list_head;
+}
+
 void *deserial_lookup_elem(void *key, const void *msg_desciptor)
 {
     int ret, err;

bpf/deserialization_to_bpf_map/deserialization_to_bpf_map.h

@@ -7,9 +7,16 @@
 /* equal MAP_SIZE_OF_OUTTER_MAP */
 #define MAX_OUTTER_MAP_ENTRIES (8192)
 
+struct element_list_node {
+    void *elem;
+    struct element_list_node *next;
+};
+
 int deserial_update_elem(void *key, void *value);
 void *deserial_lookup_elem(void *key, const void *msg_desciptor);
+struct element_list_node *deserial_lookup_all_elems(const void *msg_desciptor);
 void deserial_free_elem(void *value);
+void deserial_free_elem_list(struct element_list_node *head);
 int deserial_delete_elem(void *key, const void *msg_desciptor);
 
 int deserial_init();

pkg/bpf/bpf_kmesh.go

@@ -441,3 +441,7 @@ func (sc *BpfKmesh) Detach() error {
 	}
 	return nil
 }
+
+func AdsL7Enabled() bool {
+	return true
+}

pkg/bpf/bpf_kmesh_l4.go

@@ -111,3 +111,7 @@
 	}
 	return nil
 }
+
+func AdsL7Enabled() bool {
+	return false
+}

pkg/cache/v2/cluster.go

@@ -165,20 +165,10 @@
 }
 
 func (cache *ClusterCache) DumpBpf() []*cluster_v2.Cluster {
-	cache.mutex.RLock()
-	defer cache.mutex.RUnlock()
-	clusters := make([]*cluster_v2.Cluster, 0, len(cache.apiClusterCache))
-	for name, c := range cache.apiClusterCache {
-		tmp := &cluster_v2.Cluster{}
-		if err := maps_v2.ClusterLookup(name, tmp); err != nil {
-			log.Errorf("ClusterLookup failed, %s", name)
-			continue
-		}
-
-		tmp.ApiStatus = c.ApiStatus
-		clusters = append(clusters, tmp)
+	clusters, err := maps_v2.ClusterLookupAll()
+	if err != nil {
+		log.Errorf("ClusterLookup failed, %v", err)
 	}
-
 	return clusters
 }
 

pkg/cache/v2/cluster_test.go

@@ -17,6 +17,7 @@
 package cache_v2
 
 import (
+	"sort"
 	"testing"
 
 	"github.com/agiledragon/gomonkey/v2"
@@ -177,6 +178,33 @@ func TestClusterFlush(t *testing.T) {
 	})
 }
 
+func TestClusterLookupAll(t *testing.T) {
+	config := options.BpfConfig{
+		Mode:        "ads",
+		BpfFsPath:   "/sys/fs/bpf",
+		Cgroup2Path: "/mnt/kmesh_cgroup2",
+	}
+	cleanup, _ := test.InitBpfMap(t, config)
+	t.Cleanup(cleanup)
+	testClusterNames := []string{"ut-cluster-1", "ut-cluster-2", "ut-cluster-3"}
+	for _, testClusterName := range testClusterNames {
+		err := maps_v2.ClusterUpdate(testClusterName, &cluster_v2.Cluster{Name: testClusterName})
+		assert.Nil(t, err)
+	}
+
+	clusters, err := maps_v2.ClusterLookupAll()
+	assert.Nil(t, err)
+
+	var actualClusterNames []string
+
+	for _, cluster := range clusters {
+		actualClusterNames = append(actualClusterNames, cluster.Name)
+	}
+
+	sort.Strings(actualClusterNames)
+	assert.Equal(t, actualClusterNames, testClusterNames)
+}
+
 func BenchmarkClusterFlush(b *testing.B) {
 	t := &testing.T{}
 	config := options.BpfConfig{

pkg/cache/v2/listener.go

@@ -128,20 +128,10 @@
 }
 
 func (cache *ListenerCache) DumpBpf() []*listener_v2.Listener {
-	cache.mutex.RLock()
-	defer cache.mutex.RUnlock()
-	listeners := make([]*listener_v2.Listener, 0, len(cache.apiListenerCache))
-	for name, listener := range cache.apiListenerCache {
-		tmp := &listener_v2.Listener{}
-		if err := maps_v2.ListenerLookup(listener.GetAddress(), tmp); err != nil {
-			log.Errorf("ListenerLookup failed, %s", name)
-			continue
-		}
-
-		tmp.ApiStatus = listener.ApiStatus
-		listeners = append(listeners, tmp)
+	listeners, err := maps_v2.ListenerLookupAll()
+	if err != nil {
+		log.Errorf("ListenerLookupAll failed, %v", err)
 	}
-
 	return listeners
 }
 

pkg/cache/v2/listener_test.go

@@ -18,6 +18,7 @@ package cache_v2
 
 import (
 	"fmt"
+	"sort"
 	"testing"
 
 	"github.com/agiledragon/gomonkey/v2"
@@ -36,6 +37,35 @@ import (
 	"kmesh.net/kmesh/pkg/utils/test"
 )
 
+func TestListenerLookupAll(t *testing.T) {
+	config := options.BpfConfig{
+		Mode:        "ads",
+		BpfFsPath:   "/sys/fs/bpf",
+		Cgroup2Path: "/mnt/kmesh_cgroup2",
+	}
+	cleanup, _ := test.InitBpfMap(t, config)
+	t.Cleanup(cleanup)
+	testListenerNames := []string{"ut-listener-1", "ut-listener-2", "ut-listener-3"}
+	for i, testListenerName := range testListenerNames {
+		err := maps_v2.ListenerUpdate(&core_v2.SocketAddress{
+			Port: uint32(i + 1),
+		}, &listener_v2.Listener{Name: testListenerName})
+		assert.Nil(t, err)
+	}
+
+	listeners, err := maps_v2.ListenerLookupAll()
+	assert.Nil(t, err)
+
+	var actualListenerNames []string
+
+	for _, listener := range listeners {
+		actualListenerNames = append(actualListenerNames, listener.Name)
+	}
+
+	sort.Strings(actualListenerNames)
+	assert.Equal(t, actualListenerNames, testListenerNames)
+}
+
 func TestListenerFlush(t *testing.T) {
 	t.Run("listener status is UPDATE", func(t *testing.T) {
 		updateListenerAddress := []*core_v2.SocketAddress{}

pkg/cache/v2/maps/authz.go

@@ -21,6 +21,7 @@
 // #include "workloadapi/security/authorization.pb-c.h"
 import "C"
 import (
+	"errors"
 	"fmt"
 	"unsafe"
 
@@ -71,6 +72,34 @@
 	return err
 }
 
+func AuthorizationLookupAll() ([]*security_v2.Authorization, error) {
+	cMsg := C.deserial_lookup_all_elems(unsafe.Pointer(&C.istio__security__authorization__descriptor))
+	if cMsg == nil {
+		return nil, errors.New("AuthorizationLookupAll deserial_lookup_all_elems failed")
+	}
+
+	elem_list_head := (*C.struct_element_list_node)(cMsg)
+	defer C.deserial_free_elem_list(elem_list_head)
+
+	var (
+		authorizations []*security_v2.Authorization
+		err            error
+	)
+	for elem_list_head != nil {
+		cValue := elem_list_head.elem
+		elem_list_head = elem_list_head.next
+		authorization := security_v2.Authorization{}
+		err = authorizationToGolang(&authorization, (*C.Istio__Security__Authorization)(cValue))
+		log.Debugf("AuthorizationLookupAll, value [%s]", authorization.String())
+		if err != nil {
+			return nil, err
+		}
+		authorizations = append(authorizations, &authorization)
+	}
+
+	return authorizations, nil
+}
+
 func AuthorizationUpdate(policyKey uint32, value *security_v2.Authorization) error {
 	cKey := C.uint(policyKey)
 	cMsg, err := authorizationToClang(value)