1.fix potential target port modify error when access backend directly

2.fix a backend that belongs to multi services
3.store waypoint info in service to accelerate waypoint access

Signed-off-by: kwb0523 <kwb0523@163.com>

bpf/kmesh/workload/include/backend.h

@@ -30,15 +30,15 @@ static inline backend_value *map_lookup_backend(const backend_key *key)
     return kmesh_map_lookup_elem(&map_of_backend, key);
 }
 
-static inline int backend_manager(ctx_buff_t *ctx, backend_value *backend_v)
+static inline int waypoint_manager(ctx_buff_t *ctx, __u32 addr, __u32 port)
 {
     int ret;
     address_t target_addr;
     __u32 *sk = (__u32 *)ctx->sk;
     struct bpf_sock_tuple value_tuple = {0};
 
-    if (backend_v->waypoint_addr != 0 && backend_v->waypoint_port != 0) {
-        BPF_LOG(DEBUG, BACKEND, "find waypoint addr=[%u:%u]\n", backend_v->waypoint_addr, backend_v->waypoint_port);
+    if (addr != 0 && port != 0) {
+        BPF_LOG(DEBUG, BACKEND, "find waypoint addr=[%u:%u]\n", addr, port);
         value_tuple.ipv4.daddr = ctx->user_ip4;
         value_tuple.ipv4.dport = ctx->user_port;
 
@@ -47,8 +47,8 @@ static inline int backend_manager(ctx_buff_t *ctx, backend_value *backend_v)
             BPF_LOG(ERR, BACKEND, "record metadata origin address and port failed, ret is %d\n", ret);
             return ret;
         }
-        target_addr.ipv4 = backend_v->waypoint_addr;
-        target_addr.port = backend_v->waypoint_port;
+        target_addr.ipv4 = addr;
+        target_addr.port = port;
         SET_CTX_ADDRESS(ctx, target_addr);
         kmesh_workload_tail_call(ctx, TAIL_CALL_CONNECT4_INDEX);
 
@@ -57,24 +57,58 @@ static inline int backend_manager(ctx_buff_t *ctx, backend_value *backend_v)
         return -ENOEXEC;
     }
 
+    return 0;
+}
+
+// through service to access the backend
+static inline int
+service_backend_manager(ctx_buff_t *ctx, backend_value *backend_v, __u32 service_id, service_value *service_v)
+{
+    int ret;
+    address_t target_addr;
+    __u32 user_port = ctx->user_port;
+
+    ret = waypoint_manager(ctx, backend_v->waypoint_addr, backend_v->waypoint_port);
+    if (ret != 0) {
+        BPF_LOG(ERR, BACKEND, "waypoint_manager failed, ret:%d\n", ret);
+        return ret;
+    }
+
 #pragma unroll
-    for (unsigned int i = 0; i < backend_v->port_count; i++) {
-        if (i >= MAX_PORT_COUNT) {
+    for (__u32 i = 0; i < backend_v->service_count; i++) {
+        if (i >= MAX_SERVICE_COUNT) {
             BPF_LOG(WARN, BACKEND, "exceed the max port count\n");
             return -EINVAL;
         }
-
-        if (ctx->user_port == backend_v->service_port[i]) {
-            target_addr.ipv4 = backend_v->ipv4;
-            target_addr.port = backend_v->target_port[i];
-            SET_CTX_ADDRESS(ctx, target_addr);
-            BPF_LOG(DEBUG, BACKEND, "get the backend addr=[%u:%u]\n", target_addr.ipv4, target_addr.port);
-            return 0;
+        if (service_id == backend_v->service[i]) {
+            BPF_LOG(DEBUG, BACKEND, "access the backend by service:%d \n", service_id);
+#pragma unroll
+            for (__u32 j = 0; j < MAX_PORT_COUNT; j++) {
+                if (service_v->service_port[j] != 0 && user_port == service_v->service_port[j]) {
+                    target_addr.ipv4 = backend_v->ipv4;
+                    target_addr.port = service_v->target_port[j];
+                    SET_CTX_ADDRESS(ctx, target_addr);
+                    BPF_LOG(DEBUG, BACKEND, "get the backend addr=[%u:%u]\n", target_addr.ipv4, target_addr.port);
+                    return 0;
+                }
+            }
         }
     }
 
     BPF_LOG(ERR, BACKEND, "failed to get the backend\n");
     return -ENOENT;
 }
 
+// access the backend directly
+static inline int direct_backend_manager(ctx_buff_t *ctx, backend_value *backend_v)
+{
+    int ret = waypoint_manager(ctx, backend_v->waypoint_addr, backend_v->waypoint_port);
+    if (ret != 0) {
+        BPF_LOG(ERR, BACKEND, "waypoint_manager failed, ret:%d\n", ret);
+        return ret;
+    }
+
+    return 0;
+}
+
 #endif

bpf/kmesh/workload/include/endpoint.h

@@ -28,7 +28,8 @@ static inline endpoint_value *map_lookup_endpoint(const endpoint_key *key)
     return kmesh_map_lookup_elem(&map_of_endpoint, key);
 }
 
-static inline int endpoint_manager(ctx_buff_t *ctx, endpoint_value *endpoint_v)
+static inline int
+endpoint_manager(ctx_buff_t *ctx, endpoint_value *endpoint_v, __u32 service_id, service_value *service_v)
 {
     int ret = 0;
     backend_key backend_k = {0};
@@ -41,7 +42,7 @@ static inline int endpoint_manager(ctx_buff_t *ctx, endpoint_value *endpoint_v)
         return -ENOENT;
     }
 
-    ret = backend_manager(ctx, backend_v);
+    ret = service_backend_manager(ctx, backend_v, service_id, service_v);
     if (ret != 0) {
         if (ret != -ENOENT)
             BPF_LOG(ERR, ENDPOINT, "backend_manager failed, ret:%d\n", ret);

bpf/kmesh/workload/include/frontend.h

@@ -50,7 +50,7 @@ static inline int frontend_manager(ctx_buff_t *ctx, frontend_value *frontend_v)
     }
 
     if (direct_backend) {
-        ret = backend_manager(ctx, backend_v);
+        ret = direct_backend_manager(ctx, backend_v);
         if (ret != 0) {
             if (ret != -ENOENT)
                 BPF_LOG(ERR, FRONTEND, "backend_manager failed, ret:%d\n", ret);

bpf/kmesh/workload/include/service.h

@@ -27,7 +27,7 @@ static inline service_value *map_lookup_service(const service_key *key)
     return kmesh_map_lookup_elem(&map_of_service, key);
 }
 
-static inline int lb_random_handle(ctx_buff_t *ctx, int service_id, service_value *service_v)
+static inline int lb_random_handle(ctx_buff_t *ctx, __u32 service_id, service_value *service_v)
 {
     int ret = 0;
     endpoint_key endpoint_k = {0};
@@ -42,7 +42,7 @@ static inline int lb_random_handle(ctx_buff_t *ctx, int service_id, service_valu
         return -ENOENT;
     }
 
-    ret = endpoint_manager(ctx, endpoint_v);
+    ret = endpoint_manager(ctx, endpoint_v, service_id, service_v);
     if (ret != 0) {
         if (ret != -ENOENT)
             BPF_LOG(ERR, SERVICE, "endpoint_manager failed, ret:%d\n", ret);
@@ -52,10 +52,16 @@ static inline int lb_random_handle(ctx_buff_t *ctx, int service_id, service_valu
     return 0;
 }
 
-static inline int service_manager(ctx_buff_t *ctx, int service_id, service_value *service_v)
+static inline int service_manager(ctx_buff_t *ctx, __u32 service_id, service_value *service_v)
 {
     int ret = 0;
 
+    ret = waypoint_manager(ctx, service_v->waypoint_addr, service_v->waypoint_port);
+    if (ret != 0) {
+        BPF_LOG(ERR, BACKEND, "waypoint_manager failed, ret:%d\n", ret);
+        return ret;
+    }
+
     BPF_LOG(DEBUG, SERVICE, "load balance type:%u", service_v->lb_policy);
     switch (service_v->lb_policy) {
     case LB_POLICY_RANDOM:

bpf/kmesh/workload/include/workload.h

@@ -22,8 +22,9 @@
 
 #include "config.h"
 
-#define MAX_PORT_COUNT 10
-#define RINGBUF_SIZE   (1 << 12)
+#define MAX_PORT_COUNT    10
+#define MAX_SERVICE_COUNT 10
+#define RINGBUF_SIZE      (1 << 12)
 
 // frontend map
 typedef struct {
@@ -40,8 +41,13 @@ typedef struct {
 } __attribute__((packed)) service_key;
 
 typedef struct {
-    __u32 endpoint_count; // endpoint count of current service
-    __u32 lb_policy;      // load balancing algorithm, currently only supports random algorithm
+    __u32 endpoint_count;               // endpoint count of current service
+    __u32 lb_policy;                    // load balancing algorithm, currently only supports random algorithm
+    __u32 service_port[MAX_PORT_COUNT]; // service_port[i] and target_port[i] are a pair, i starts from 0 and max value
+                                        // is MAX_PORT_COUNT-1
+    __u32 target_port[MAX_PORT_COUNT];
+    __u32 waypoint_addr;
+    __u32 waypoint_port;
 } __attribute__((packed)) service_value;
 
 // endpoint map
@@ -61,9 +67,8 @@ typedef struct {
 
 typedef struct {
     __u32 ipv4; // backend ip
-    __u32 port_count;
-    __u32 service_port[MAX_PORT_COUNT];
-    __u32 target_port[MAX_PORT_COUNT];
+    __u32 service_count;
+    __u32 service[MAX_SERVICE_COUNT];
     __u32 waypoint_addr;
     __u32 waypoint_port;
 } __attribute__((packed)) backend_value;
@@ -112,4 +117,11 @@ struct {
     __uint(max_entries, RINGBUF_SIZE);
 } map_of_tuple SEC(".maps");
 
+struct {
+    __uint(type, BPF_MAP_TYPE_HASH);
+    __type(key, __u64);
+    __type(value, __u32);
+    __uint(max_entries, MAP_SIZE_OF_MANAGER);
+    __uint(map_flags, 0);
+} map_of_manager SEC(".maps");
 #endif

pkg/controller/workload/bpfcache/backend.go

@@ -21,22 +21,20 @@ import (
 )
 
 const (
-	ConverNumBase  = 10
-	MaxPortPairNum = 10
+	ConverNumBase = 10
+	MaxServiceNum = 10
 )
 
 type BackendKey struct {
 	BackendUid uint32 // workloadUid to uint32
 }
 
-type ServicePorts [MaxPortPairNum]uint32
-type TargetPorts [MaxPortPairNum]uint32
+type ServiceList [MaxServiceNum]uint32
 
 type BackendValue struct {
 	IPv4         uint32 // backend ip
-	PortCount    uint32
-	ServicePort  ServicePorts // ServicePort[i] and TargetPort[i] are a pair, i starts from 0 and max value is PortCount-1
-	TargetPort   TargetPorts
+	ServiceCount uint32
+	Services     ServiceList
 	WaypointAddr uint32
 	WaypointPort uint32
 }

pkg/controller/workload/bpfcache/service.go

@@ -20,13 +20,24 @@ import (
 	"github.com/cilium/ebpf"
 )
 
+const (
+	MaxPortNum = 10
+)
+
 type ServiceKey struct {
 	ServiceId uint32 // service id
 }
 
+type ServicePorts [MaxPortNum]uint32
+type TargetPorts [MaxPortNum]uint32
+
 type ServiceValue struct {
-	EndpointCount uint32 // endpoint count of current service
-	LbPolicy      uint32 // load balancing algorithm, currently only supports random algorithm
+	EndpointCount uint32       // endpoint count of current service
+	LbPolicy      uint32       // load balancing algorithm, currently only supports random algorithm
+	ServicePort   ServicePorts // ServicePort[i] and TargetPort[i] are a pair, i starts from 0 and max value is MaxPortNum-1
+	TargetPort    TargetPorts
+	WaypointAddr  uint32
+	WaypointPort  uint32
 }
 
 func (c *Cache) ServiceUpdate(key *ServiceKey, value *ServiceValue) error {