Merbridge: 基于 eBPF 加速 Istio 的流量转发能力

static __u32 outip = 1;

static inline int tcp_connect4(struct bpf_sock_addr *ctx)
{
    // 通过从 cgroup_info_map 中获取的 cgroup_info 来判断是否为服务网格中 Pod 的流量
    // ...
    
    __u32 curr_pod_ip;
    __u32 _curr_pod_ip[4];
    set_ipv6(_curr_pod_ip, cg_info.cgroup_ip);
    curr_pod_ip = get_ipv4(_curr_pod_ip);
    
    __u64 uid = bpf_get_current_uid_gid() & 0xffffffff;
    __u32 dst_ip = ctx->user_ip4;
    if (uid != SIDECAR_USER_ID) {  // 1337 是 Istio 为 sidecar 预留的 Application UIDs
        // 忽略目的地址为 127 开头的本地流量
        if ((dst_ip & 0xff) == 0x7f) {
            return 1;
        }
        
        __u64 cookie = bpf_get_socket_cookie_addr(ctx);

        // 即将重定向流量至 Envoy，此处把重定向之前真正要发往的目的地信息记录下来，即原始目的地址
        struct origin_info origin;
        memset(&origin, 0, sizeof(origin));
        set_ipv4(origin.ip, dst_ip);
        origin.port = ctx->user_port;
        origin.flags = 1;
        if (bpf_map_update_elem(&cookie_original_dst, &cookie, &origin, BPF_ANY)) {
            return 0;
        }
        
        if (curr_pod_ip) {
            struct pod_config *pod = bpf_map_lookup_elem(&local_pod_ips, _curr_pod_ip);
            if (pod) {
	            /* 根据各种 Exclude/Include Out Ports/Ranges 信息来判断是否还进一步向后执行；
	               podConfig 中的各种 Pod 配置信息是经由 Local IP Controller 获取的。
	             */
	            // ...
            }

            // 对于存在 Pod IP 的情况，将与 ctx 关联的 socket 绑定到 Pod 的 IP 地址上
            struct sockaddr_in addr = {
                .sin_addr =
                    {
                        .s_addr = curr_pod_ip,
                    },
                .sin_port = 0,    // 端口由内核随机指定一个未被使用的
                .sin_family = 2,  // aka. AF_INET
            };
            bpf_bind(ctx, &addr, sizeof(struct sockaddr_in))
            ctx->user_ip4 = localhost;  // 修改数据包目的地址
            
        } else {
            // 对于无法获取 Pod IP 的情况，目的地址为自定义地址
            // The reason we try the IP of the 127.128.0.0/20 segment instead of
            // using 127.0.0.1 directly is to avoid conflicts between the
            // quaternions of different Pods when the quaternions are
            // subsequently processed.
            ctx->user_ip4 = bpf_htonl(0x7f800000 | (outip++));  // 修改数据包目的地址
            if (outip >> 20) {
                outip = 1;
            }
        }
        
        ctx->user_port = bpf_htons(OUT_REDIRECT_PORT);  // 修改数据包目的端口，即 sidecar 的 15001 端口
    }
    
    // ...

    return 1;
}

static inline int sockops_ipv4(struct bpf_sock_ops *skops)
{
    __u64 cookie = bpf_get_socket_cookie_ops(skops);

    struct pair p;
    set_ipv4(p.sip, skops->local_ip4);
    p.sport = bpf_htons(skops->local_port);
    set_ipv4(p.dip, skops->remote_ip4);  // 在应用侧 socket，拿到的目的地址和端口已经是发往 envoy 15001 的地址和端口
    p.dport = skops->remote_port >> 16;

    struct origin_info *dst =
        bpf_map_lookup_elem(&cookie_original_dst, &cookie);
    if (dst) {
        struct origin_info dd = *dst;
        
        // ...
	    
        bpf_map_update_elem(&pair_original_dst, &p, &dd, BPF_ANY);
		bpf_sock_hash_update(skops, &sock_pair_map, &p, BPF_NOEXIST); // key 为四元组
    } else if (skops->local_port == OUT_REDIRECT_PORT ||
               skops->local_port == IN_REDIRECT_PORT ||
               skops->remote_ip4 == envoy_ip) {
        // 在 envoy 侧 socket，同样将其 socket 与对应的四元组写入 map
        bpf_sock_hash_update(skops, &sock_pair_map, &p, BPF_NOEXIST);
    }
    // ...
    return 0;
}

__section("cgroup/getsockopt") int mb_get_sockopt(struct bpf_sockopt *ctx)
{
    // ...
	
    struct pair p;
    memset(&p, 0, sizeof(p));
    p.dport = bpf_htons(ctx->sk->src_port);  // 15001 端口，作为四元组的目的端口，顺序交互是为了能通过四元组查找出原始地址信息
    p.sport = ctx->sk->dst_port;
    struct origin_info *origin;
    switch (ctx->sk->family) {
    case 2: // ipv4
        set_ipv4(p.dip, ctx->sk->src_ip4);  // envoy 地址，作为四元组的目的地址
        set_ipv4(p.sip, ctx->sk->dst_ip4);
        // 四元组准备完毕
        
        // 根据四元组获取上一步中保存的原始目的地址 
        origin = bpf_map_lookup_elem(&pair_original_dst, &p);
        if (origin) {
            // 重写当前 socket
            ctx->optlen = (__s32)sizeof(struct sockaddr_in);
            if ((void *)((struct sockaddr_in *)ctx->optval + 1) > ctx->optval_end) {
                return 1;
            }
            
            ctx->retval = 0;
            
            struct sockaddr_in sa = {
                .sin_family = ctx->sk->family,
                .sin_addr.s_addr = get_ipv4(origin->ip),
                .sin_port = origin->port,
            };
            *(struct sockaddr_in *)ctx->optval = sa;  // 写入请求选项的 buffer
        }
        break;
    case 10: // ipv6
        // ...
    }
    return 1;
}

__section("sk_msg") int mb_msg_redir(struct sk_msg_md *msg)
{
    struct pair p;
    memset(&p, 0, sizeof(p));
    p.dport = bpf_htons(msg->local_port);
    p.sport = msg->remote_port >> 16; // 目的端口 15001 作为四元组的原端口，为了获取四元组对应的 socket 信息

    switch (msg->family) {
#if ENABLE_IPV4
    case 2:
        // ipv4
        set_ipv4(p.dip, msg->local_ip4);
        set_ipv4(p.sip, msg->remote_ip4);
        break;
#endif
#if ENABLE_IPV6
    case 10:
        // ipv6 ...
#endif
    }

    long ret = bpf_msg_redirect_hash(msg, &sock_pair_map, &p, BPF_F_INGRESS);
    return 1;
}

static inline int tcp_connect4(struct bpf_sock_addr *ctx)
{
    // ...
    if (uid != SIDECAR_USER_ID) {
        // 见上文
        // ...
    } else {
        __u32 _dst_ip[4];
        set_ipv4(_dst_ip, dst_ip);
        struct pod_config *pod = bpf_map_lookup_elem(&local_pod_ips, _dst_ip);
        // 若目的地址非本地 Node 中的 Pod IP，则跳过处理
        if (!pod) {
            return 1;
        }

        // 目的地址在本地，但并非当前 Pod
        // 记录原始目的地址信息，以便后续修改数据包信息
        struct origin_info origin;
        memset(&origin, 0, sizeof(origin));
        set_ipv4(origin.ip, dst_ip);
        origin.port = ctx->user_port;

        if (curr_pod_ip) {
	        // 对于目的地址非当前 Pod 的流量，需要重定向数据包端口
            if (curr_pod_ip != dst_ip) {
                /* 根据各种 Exclude/Include Out Ports 信息来判断是否还进一步向后执行；
	               podConfig 中的各种 Pod 配置信息是经由 Local IP Controller 获取的。
	             */
                 // ...
	            
                ctx->user_port = bpf_htons(IN_REDIRECT_PORT);  // 修改目的端口为 15006
            }
            origin.flags |= 1;
        } else {
	        // 若 Pod IP 获取失败，则使用传统方式获取 Pod IP
            __u32 pid = bpf_get_current_pid_tgid() >> 32; // tgid
            void *curr_ip = bpf_map_lookup_elem(&process_ip, &pid);
            if (curr_ip) {
                if (*(__u32 *)curr_ip != dst_ip) {
                    ctx->user_port = bpf_htons(IN_REDIRECT_PORT);  // 修改目的端口为 15006
                }
                origin.flags |= 1;
            } else {
                // 若 Pod IP 仍然获取失败，envoy 向自身 pod 发送了流量
                origin.flags = 0;
                origin.pid = pid;
                ctx->user_port = bpf_htons(IN_REDIRECT_PORT);  // 修改目的端口为 15006
            }
        }
        
        __u64 cookie = bpf_get_socket_cookie_addr(ctx);
        if (bpf_map_update_elem(&cookie_original_dst, &cookie, &origin, BPF_NOEXIST)) {
            return 0;
        }
    }

    return 1;
}