dp_vs_service

最新推荐文章于 2020-11-30 14:03:59 发布
最新推荐文章于 2020-11-30 14:03:59 发布
阅读量413 收藏 1
点赞数
分类专栏： dpvs源码阅读笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjx345438858/article/details/108092734
版权

  • dp_vs_service结构体

    /* virtual service */
//lvs服务
struct dp_vs_service {
    struct list_head    s_list;     /* node for normal service table */
    struct list_head    f_list;     /* node for fwmark service table */
    struct list_head    m_list;     /* node for match  service table */
    //引用计数
    rte_atomic32_t      refcnt;     /* svc is per core, conn will not refer to svc, but dest will.
                                     *  while conn will refer to dest */

    /*
     * to identify a service
     * 1. <af, proto, vip, vport>
     * 2. fwmark (no use now).
     * 3. match.
     */
    //协议族
    int                 af;
    //传输层协议 TCP,UDP等
    uint8_t             proto;      /* TCP/UDP/... */
    //vip地址
    union inet_addr     addr;       /* virtual IP address */
    uint16_t            port;
    uint32_t            fwmark;
		//snat查找相关
    struct dp_vs_match  *match;

    unsigned            flags;
    unsigned            timeout;
    unsigned            conn_timeout;
    unsigned            bps;
    unsigned            limit_proportion;
    uint32_t            netmask;
		//后端real server列表
    struct list_head    dests;      /* real services (dp_vs_dest{}) */
    uint32_t            num_dests;
    long                weight;     /* sum of servers weight */

    struct dp_vs_scheduler  *scheduler;
    void                *sched_data;

    struct dp_vs_stats  stats;

    /* FNAT only */
    struct list_head    laddr_list; /* local address (LIP) pool */
    struct list_head    *laddr_curr;
    uint32_t            num_laddrs;

    /* ... flags, timer ... */
} __rte_cache_aligned;

  • dp_vs_dest

    • 后端real server
    struct dp_vs_dest {
    //通过该list node链接在dp_vs_service->dests链表中
    struct list_head    n_list;     /* for the dests in the service */
    //协议族
    int                 af;         /* address family */
    /*
     * normally, addr/port is for Real Server,
     * but for SNAT, addr/port is the "to-source"
     * (the target source ip/port translated to).
     */
     //<ip,port>, snat模式时不同
    union inet_addr     addr;       /* IP address of the server */
    uint16_t            port;       /* port number of the server */
    //dest相关标志
    volatile unsigned   flags;      /* dest status flags */
    rte_atomic16_t      conn_flags; /* flags to copy to conn */
    rte_atomic16_t      weight;     /* server weight */

    rte_atomic32_t      refcnt;     /* reference counter */
    struct dp_vs_stats  stats;      /* Use per-cpu statistics for destination server */
    //转发模式
    enum dpvs_fwd_mode  fwdmode;

    /* connection counters and thresholds */
    rte_atomic32_t      actconns;   /* active connections */
    rte_atomic32_t      inactconns; /* inactive connections */
    rte_atomic32_t      persistconns;   /* persistent connections */
    uint32_t            max_conn;   /* upper threshold */
    uint32_t            min_conn;   /* lower threshold */

    /* for virtual service */
    uint16_t            proto;      /* which protocol (TCP/UDP) */
    uint16_t            vport;      /* virtual port number */
    uint32_t            vfwmark;    /* firewall mark of service */
    //所属的dp_vs_service
    struct dp_vs_service *svc;      /* service it belongs to */
    union inet_addr     vaddr;      /* virtual IP address */
    unsigned            conn_timeout; /* conn timeout copied from svc*/
    unsigned            limit_proportion; /* limit copied from svc*/
} __rte_cache_aligned;

init

  • dp_vs_service_init
    • 初始化用于查找vs_service的hash表
    • 注册控制平面相关的msg_type，消息基本为multicast类型 
      int dp_vs_service_init(void)
{
    int idx, cid, err;
    struct dpvs_msg_type msg_type;

    for (cid = 0; cid < DPVS_MAX_LCORE; cid++) {
        for (idx = 0; idx < DP_VS_SVC_TAB_SIZE; idx++) {
            INIT_LIST_HEAD(&dp_vs_svc_table[cid][idx]);
            INIT_LIST_HEAD(&dp_vs_svc_fwm_table[cid][idx]);
        }
        INIT_LIST_HEAD(&dp_vs_svc_match_list[cid]);
        rte_atomic16_init(&dp_vs_num_services[cid]);
    }
    dp_vs_dest_init();
    sockopt_register(&sockopts_svc);

    memset(&msg_type, 0, sizeof(struct dpvs_msg_type));
    msg_type.type   = MSG_TYPE_SVC_SET_FLUSH;
    msg_type.mode   = DPVS_MSG_MULTICAST;
    msg_type.prio   = MSG_PRIO_NORM;
    msg_type.cid    = rte_lcore_id();
    msg_type.unicast_msg_cb = flush_msg_cb;
    err = msg_type_mc_register(&msg_type);
    if (err != EDPVS_OK) {
        RTE_LOG(ERR, SERVICE, "%s: fail to register msg.\\n", __func__);
        return err;
    }

    memset(&msg_type, 0, sizeof(struct dpvs_msg_type));
    msg_type.type   = MSG_TYPE_SVC_SET_ZERO;
    msg_type.mode   = DPVS_MSG_MULTICAST;
    msg_type.prio   = MSG_PRIO_NORM;
    msg_type.cid    = rte_lcore_id();
    msg_type.unicast_msg_cb = zero_msg_cb;
    err = msg_type_mc_register(&msg_type);
    if (err != EDPVS_OK) {
        RTE_LOG(ERR, SERVICE, "%s: fail to register msg.\\n", __func__);
        return err;
    }

    memset(&msg_type, 0, sizeof(struct dpvs_msg_type));
    msg_type.type   = MSG_TYPE_SVC_SET_ADD;
    msg_type.mode   = DPVS_MSG_MULTICAST;
    msg_type.prio   = MSG_PRIO_NORM;
    msg_type.cid    = rte_lcore_id();
    msg_type.unicast_msg_cb = add_msg_cb;
    err = msg_type_mc_register(&msg_type);
    if (err != EDPVS_OK) {
         RTE_LOG(ERR, SERVICE, "%s: fail to register msg.\\n", __func__);
         return err;
    }

    memset(&msg_type, 0, sizeof(struct dpvs_msg_type));
    msg_type.type   = MSG_TYPE_SVC_SET_EDIT;
    msg_type.mode   = DPVS_MSG_MULTICAST;
    msg_type.prio   = MSG_PRIO_NORM;
    msg_type.cid    = rte_lcore_id();
    msg_type.unicast_msg_cb = edit_msg_cb;
    err = msg_type_mc_register(&msg_type);
    if (err != EDPVS_OK) {
         RTE_LOG(ERR, SERVICE, "%s: fail to register msg.\\n", __func__);
         return err;
    }

    memset(&msg_type, 0, sizeof(struct dpvs_msg_type));
    msg_type.type   = MSG_TYPE_SVC_SET_DEL;
    msg_type.mode   = DPVS_MSG_MULTICAST;
    msg_type.prio   = MSG_PRIO_NORM;
    msg_type.cid    = rte_lcore_id();
    msg_type.unicast_msg_cb = del_msg_cb;
    err = msg_type_mc_register(&msg_type);
    if (err != EDPVS_OK) {
         RTE_LOG(ERR, SERVICE, "%s: fail to register msg.\\n", __func__);
         return err;
    }

    memset(&msg_type, 0, sizeof(struct dpvs_msg_type));
    msg_type.type   = MSG_TYPE_SVC_SET_ADDDEST;
    msg_type.mode   = DPVS_MSG_MULTICAST;
    msg_type.prio   = MSG_PRIO_NORM;
    msg_type.cid    = rte_lcore_id();
    msg_type.unicast_msg_cb = adddest_msg_cb;
    err = msg_type_mc_register(&msg_type);
    if (err != EDPVS_OK) {
         RTE_LOG(ERR, SERVICE, "%s: fail to register msg.\\n", __func__);
         return err;
    }

    memset(&msg_type, 0, sizeof(struct dpvs_msg_type));
    msg_type.type   = MSG_TYPE_SVC_SET_EDITDEST;
    msg_type.mode   = DPVS_MSG_MULTICAST;
    msg_type.prio   = MSG_PRIO_NORM;
    msg_type.cid    = rte_lcore_id();
    msg_type.unicast_msg_cb = editdest_msg_cb;
    err = msg_type_mc_register(&msg_type);
    if (err != EDPVS_OK) {
         RTE_LOG(ERR, SERVICE, "%s: fail to register msg.\\n", __func__);
         return err;
    }

    memset(&msg_type, 0, sizeof(struct dpvs_msg_type));
    msg_type.type   = MSG_TYPE_SVC_SET_DELDEST;
    msg_type.mode   = DPVS_MSG_MULTICAST;
    msg_type.prio   = MSG_PRIO_NORM;
    msg_type.cid    = rte_lcore_id();
    msg_type.unicast_msg_cb = deldest_msg_cb;
    err = msg_type_mc_register(&msg_type);
    if (err != EDPVS_OK) {
         RTE_LOG(ERR, SERVICE, "%s: fail to register msg.\\n", __func__);
         return err;
    }

    memset(&msg_type, 0, sizeof(struct dpvs_msg_type));
    msg_type.type   = MSG_TYPE_SVC_GET_SERVICES;
    msg_type.mode   = DPVS_MSG_MULTICAST;
    msg_type.prio   = MSG_PRIO_LOW;
    msg_type.cid    = rte_lcore_id();
    msg_type.unicast_msg_cb = dp_vs_services_get_uc_cb;
    err = msg_type_mc_register(&msg_type);
    if (err != EDPVS_OK) {
         RTE_LOG(ERR, SERVICE, "%s: fail to register msg.\\n", __func__);
         return err;
    }

    memset(&msg_type, 0, sizeof(struct dpvs_msg_type));
    msg_type.type   = MSG_TYPE_SVC_GET_SERVICE;
    msg_type.mode   = DPVS_MSG_MULTICAST;
    msg_type.prio   = MSG_PRIO_LOW;
    msg_type.cid    = rte_lcore_id();
    msg_type.unicast_msg_cb = dp_vs_service_get_uc_cb;
    err = msg_type_mc_register(&msg_type);
    if (err != EDPVS_OK) {
         RTE_LOG(ERR, SERVICE, "%s: fail to register msg.\\n", __func__);
         return err;
    }

    memset(&msg_type, 0, sizeof(struct dpvs_msg_type));
    msg_type.type   = MSG_TYPE_SVC_GET_DESTS;
    msg_type.mode   = DPVS_MSG_MULTICAST;
    msg_type.prio   = MSG_PRIO_LOW;
    msg_type.cid    = rte_lcore_id();
    msg_type.unicast_msg_cb = dp_vs_dests_get_uc_cb;
    err = msg_type_mc_register(&msg_type);
    if (err != EDPVS_OK) {
         RTE_LOG(ERR, SERVICE, "%s: fail to register msg.\\n", __func__);
         return err;
    }

    return EDPVS_OK;
}

dp_vs_vip_lookup

  • 主要通过vip查找相关的dp_vs_service
  • #define DP_VS_SVC_TAB_BITS 8
#define DP_VS_SVC_TAB_SIZE (1 << DP_VS_SVC_TAB_BITS)
#define DP_VS_SVC_TAB_MASK (DP_VS_SVC_TAB_SIZE - 1)

//第一维数组对应lcore id，第二维数组为<af,proto,vip>对应的hashkey
static struct list_head dp_vs_svc_table[DPVS_MAX_LCORE][DP_VS_SVC_TAB_SIZE];

static struct list_head dp_vs_svc_fwm_table[DPVS_MAX_LCORE][DP_VS_SVC_TAB_SIZE];

static struct list_head dp_vs_svc_match_list[DPVS_MAX_LCORE];
struct dp_vs_service *dp_vs_vip_lookup(int af, uint16_t protocol,
                                       const union inet_addr *vaddr,
                                       lcoreid_t cid)
{
    struct dp_vs_service *svc;
    int hash;
    //计算hash
    hash = dp_vs_service_hashkey(af, protocol, vaddr);
    if (hash < 0)
        return NULL;
    //遍历hash表头链表,查找匹配的dp_vs_service
    list_for_each_entry(svc, &dp_vs_svc_table[cid][hash], s_list) {
        if ((svc->af == af)
            && inet_addr_equal(af, &svc->addr, vaddr)
            && (svc->proto == protocol)) {
            /* HIT */
            return svc;
        }
    }

    return NULL;
}

 注册

  • dp_vs_service注册

    static int dp_vs_service_hash(struct dp_vs_service *svc, lcoreid_t cid)
{
    int hash;

    //service已经加入进hash了
    if (svc->flags & DP_VS_SVC_F_HASHED)
    {
        RTE_LOG(DEBUG, SERVICE, "%s: request for already hashed.\\n", __func__);
        return(EDPVS_EXIST);
    }
    //fwmark目前未使用
    if (svc->fwmark)
    {
        //如果fwmark设置了,同时加入dp_vs_svc_fwm_table对应hash表中
        hash = dp_vs_service_fwm_hashkey(svc->fwmark);
        list_add(&svc->f_list, &dp_vs_svc_fwm_table[cid][hash]);
    }
    else if (svc->match)
    {
        //如果match指定了,加入dp_vs_svc_match_list链表中,match应用在类似snat模式中
        list_add(&svc->m_list, &dp_vs_svc_match_list[cid]);
    }
    else
    {
        /*
         *  Hash it by <protocol,addr,port> in dp_vs_svc_table
         */
        //否则添加至所在lcore对应的hash表中
        hash = dp_vs_service_hashkey(svc->af, svc->proto, &svc->addr);
        if (hash < 0)
        {
            return(EDPVS_INVAL);
        }

        list_add(&svc->s_list, &dp_vs_svc_table[cid][hash]);
    }
    //设置DP_VS_SVC_F_HASHED标志
    svc->flags |= DP_VS_SVC_F_HASHED;
    return(EDPVS_OK);
}

dp_vs_service_lookup

  • dp_vs_service_lookup

    struct dp_vs_service *dp_vs_service_lookup(int af, uint16_t protocol,
                                           const union inet_addr *vaddr,
                                           uint16_t vport, uint32_t fwmark,
                                           const struct rte_mbuf *mbuf,
                                           const struct dp_vs_match *match,
                                           bool *outwall, lcoreid_t cid)
{
    struct dp_vs_service *svc = NULL;
    //当设置fwmark标志时,在dp_vs_svc_fwm_table hash表中查找
    if (fwmark && (svc = __dp_vs_service_fwm_get(af, fwmark, cid)))
    {
        goto out;
    }
    //接着dp_vs_svc_table中根据<af，protocol，vaddr，vport>四元组查找对应的service
    if ((svc = __dp_vs_service_get(af, protocol, vaddr, vport, cid)))
    {
        goto out;
    }
    //如果在上面没有查找到，并且指定了match，通过match查找对应的service
    if (match && !is_empty_match(match))
    {
        if ((svc = __dp_vs_service_match_find(af, protocol, match, cid)))
        {
            goto out;
        }
    }
    //上面都未找到情况下，根据路由和mbuf中四元组，查看是否有匹配的match service，主要是针对于snat
    if (mbuf) /* lowest priority */
    {
        svc = __dp_vs_service_match_get(af, mbuf, outwall, cid);
    }

out:
#ifdef CONFIG_DPVS_MBUF_DEBUG
    if (!svc && mbuf)
    {
        dp_vs_mbuf_dump("found service failed.", af, mbuf);
    }
#endif
    return(svc);
}

  • __dp_vs_service_fwm_get

    • 根据fwmark标记查找对应的service
    static struct dp_vs_service *__dp_vs_service_fwm_get(int af, uint32_t fwmark, lcoreid_t cid)
{
    unsigned hash;
    struct dp_vs_service *svc;

    /* Check for fwmark addressed entries */
    hash = dp_vs_service_fwm_hashkey(fwmark);

    list_for_each_entry(svc, &dp_vs_svc_fwm_table[cid][hash], f_list)
    {
        if (svc->fwmark == fwmark && svc->af == af)
        {
            /* HIT */
            return(svc);
        }
    }

    return(NULL);
}

  • __dp_vs_service_get

    • 根据<af，protocol，vaddr，vport>四元组查找对应的service
    static struct dp_vs_service *__dp_vs_service_get(int af, uint16_t protocol,
                                                 const union inet_addr *vaddr,
                                                 uint16_t vport, lcoreid_t cid)
{
    int hash;
    struct dp_vs_service *svc;

    hash = dp_vs_service_hashkey(af, protocol, vaddr);
    if (hash < 0)
    {
        return(NULL);
    }
    list_for_each_entry(svc, &dp_vs_svc_table[cid][hash], s_list)
    {
        if ((svc->af == af) &&
            inet_addr_equal(af, &svc->addr, vaddr) &&
            (svc->port == vport) &&
            (svc->proto == protocol))
        {
            return(svc);
        }
    }

    return(NULL);
}

  • __dp_vs_service_match_find

    • 完全匹配match
    static struct dp_vs_service *
__dp_vs_service_match_find(int af, uint8_t proto, const struct dp_vs_match *match,
                           lcoreid_t cid)
{
    struct dp_vs_service *svc;

    if (!match || is_empty_match(match))
    {
        return(NULL);
    }

    list_for_each_entry(svc, &dp_vs_svc_match_list[cid], m_list)
    {
        assert(svc->match);
        if (af == svc->af && proto == svc->proto &&
            memcmp(match, svc->match, sizeof(struct dp_vs_match)) == 0)
        {
            return(svc);
        }
    }

    return(NULL);
}

  • __dp_vs_service_match_get

    • 查找match类型的service
    • 根据mbuf中四元组信息和路由信息查找service
    • 主要用于snat情况下
    static struct dp_vs_service *
__dp_vs_service_match_get(int af, const struct rte_mbuf *mbuf, bool *outwall, lcoreid_t cid)
{
    if (af == AF_INET)
    {
        return(__dp_vs_service_match_get4(mbuf, outwall, cid));
    }
    else if (af == AF_INET6)
    {
        return(__dp_vs_service_match_get6(mbuf, cid));
    }
    else
    {
        return(NULL);
    }
}

static struct dp_vs_service *
__dp_vs_service_match_get4(const struct rte_mbuf *mbuf, bool *outwall, lcoreid_t cid)
{
    //获取路由缓存
    struct route_entry *  rt  = mbuf->userdata;
    struct ipv4_hdr *     iph = ip4_hdr(mbuf); /* ipv4 only */
    struct dp_vs_service *svc;
    union inet_addr       saddr, daddr;
    __be16   _ports[2], *ports;
    portid_t oif = NETIF_PORT_ID_ALL;
    
    saddr.in.s_addr = iph->src_addr;
    daddr.in.s_addr = iph->dst_addr;
    //将目的端口和源端口存放在ports数组中
    ports           = mbuf_header_pointer(mbuf, ip4_hdrlen(mbuf), sizeof(_ports), _ports);
    if (!ports)
    {
        return(NULL);
    }

    /* snat is handled at pre-routing to check if oif
     * is match perform route here. */
    if (rt)
    {
        if ((rt->flag & RTF_KNI) || (rt->flag & RTF_LOCALIN))
        {
            return(NULL);
        }
        oif = rt->port->id;
    }
    else if (outwall != NULL && (NULL != ipset_addr_lookup(AF_INET, &daddr)) &&
             (rt = route_gfw_net_lookup(&daddr.in)))
    {
        char dst[64];
        RTE_LOG(DEBUG, IPSET, "%s: IP %s is in the gfwip set, found route in the outwall table.\\n", __func__,
                inet_ntop(AF_INET, &daddr, dst, sizeof(dst)) ? dst : "");
        //设置出口oif
        oif = rt->port->id;
        route4_put(rt);
        *outwall = true;
    }
    else
    {
        //查找input路由
        rt = route4_input(mbuf, &daddr.in, &saddr.in,
                          iph->type_of_service,
                          netif_port_get(mbuf->port));
        if (!rt)
        {
            return(NULL);
        }
        //如果路由类型为RTF_KNI或者RTF_LOCALIN，则是发往本机的数据
        if ((rt->flag & RTF_KNI) || (rt->flag & RTF_LOCALIN))
        {
            route4_put(rt);
            return(NULL);
        }
        //设置出口oif
        oif = rt->port->id;
        route4_put(rt);
    }

    list_for_each_entry(svc, &dp_vs_svc_match_list[cid], m_list)
    {
        struct dp_vs_match *m = svc->match;
        struct netif_port * idev, *odev;

        assert(m);

        if (!strlen(m->oifname))
        {
            oif = NETIF_PORT_ID_ALL;
        }

        idev = netif_port_get_by_name(m->iifname);
        odev = netif_port_get_by_name(m->oifname);

        if (svc->af == AF_INET && svc->proto == iph->next_proto_id &&
            __service_in_range(AF_INET, &saddr, ports[0], &m->srange) &&
            __service_in_range(AF_INET, &daddr, ports[1], &m->drange) &&
            (!idev || idev->id == mbuf->port) &&
            (!odev || odev->id == oif)
            )
        {
            return(svc);
        }
    }

    return(NULL);
}
ss_chris
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
A2DP_v1.3.2.pdf
02-20
在A2DP中，服务发现协议（Service Discovery Protocol, SDP）用于发现和建立连接到A2DP服务的设备。设备配对过程涉及蓝牙的主/从角色分配，主设备通常为音频源，从设备则是音频播放设备。连接建立后，通过AVRCP...
dp_vs调度（一）：dp_vs_scheduler
chris的博客
08-19 324
dp_vs_scheduler struct dp_vs_scheduler { //用于将已注册的scheduler都挂接在全局dp_vs_schedulers链表中 struct list_head n_list; //调度算法名称 char *name; // rte_atomic32_t refcnt; //以下为虚函数表 struct dp_vs_dest * (*schedule)(..
【tyvj1061】Mobile Service（dp)
薇小薇
09-04 577
回班上课感觉不错
dpvs persistent调度
chris的博客
08-24 415
ipvsadmin配置命令，开启persistent选项之后，ipvs将来自同一个客户端的请求全部调度到一个固定的RS服务器上。对于SSL和FTP这类，其多个报文之间是相互关联的协议，需要开启此类功能。但是对于NAT转发模式，由于NAT将对端口号进行修改，FTP服务需要使用ip_vs_ftp模块才能正常工作 命令行选项netmask默认为255.255.255.255，仅对同一个客户端进行持续调度。如下指定掩码255.255.255.0，可对同一个网段内的所有客户端，调度到同一个目的服务器进行..
Mobile Service(dp)
FLY_WHITE的博客
08-27 369
Mobile Service(dp) 题目大意 一个公司的三个员工分别在1,2,3，现在从一个位置q前往一个地方p需要代价c(q,p).现在有一些任务地点需要依次每次有一个人前往，问最小代价 解题思路 很明显的一个四维DP，但是直接开四维的话空间和时间都不行，但是发现每个时间都至少有一个员工位于指定地点，由此可以优化成3维，只要简单地每次枚举上一次任务中除了在制定地点的人剩余的两个人的位置即可 A...
DPVS学习(二)DPVS教程
cuibin1991的专栏
11-30 4853
1.术语 关于全nat(FNAT)，DR，Tunnel，toa，OSPF/ECMP和keepalived的概念，可以参考LVS和阿里巴巴/LVS。 注:DPVS支持FNAT，DR，Tunnel，NAT，SNAT转发模式，有或没有OSFP/ECMP/keepalive，每个模式可以配置为单臂或两臂拓扑。后面给出一些日常工作中常用的工作模型。 1.1 单臂和多臂 双臂意味着，您在负载平衡器(LB)的一端拥有客户机，在另一端拥有服务器，然后LB在它的两个逻辑网络接口之间转发数据包。 ...
dpvs中lvs核心处理函数：dp_vs_in
chris的博客
08-19 607
__dp_vs_in 开始进入lvs模块,这块代码非常复杂,简单说,对于存在proxy连接,判断方向(client->LB或是rs->LB),直接发送流量.新来的连接,查找virtual server,根据LB算法查找对应后端real server,建立连接,并保存这个会话 static int __dp_vs_in(void *priv, struct rte_mbuf *mbuf, const struct inet_hook_stat..
Profibus_profibus-dp_
10-01
3. **SDO（Service Data Object）**：SDO用于配置和诊断，允许主站读取或写入从站的非过程数据。 4. **通信周期和实时性**：从站必须按照预设的通信周期响应主站请求，以满足实时性能需求。 5. **故障安全性和诊断**...
A2DP_v1.3.1_BluetoothA2DP协议_
10-01
2. **服务质量（Quality of Service, QoS）**：A2DP协议考虑了实时性和延迟问题，通过QoS机制确保音频数据流的顺畅传输，减少音质损失和延迟。 3. **编码支持**：A2DP支持多种音频编码格式，如SBC（Subband Coding...
FTP-SDAP-A2DP-CTP-BPP-SPEC.zip_A2DP_SPEC_SDAP_a2dp_ctp_ftp spec
09-14
在这个名为"FTP-SDAP-A2DP-CTP-BPP-SPEC.zip"的压缩包中，包含了五个关键协议的规范文档，分别是FTP（File Transfer Profile）、SDAP（Service Discovery Application Profile）、A2DP（Advanced Audio Distribution...
PROFIBUS-DP从站编程开发-从入门到精通_profibusdp_
09-30
书中可能涵盖DP从站的角色、功能及通信特性，如PDO（Process Data Object，过程数据对象）和SDO（Service Data Object，服务数据对象）的使用。 接着，书中会详细阐述PROFIBUS-DP的配置和参数化过程，包括创建和...
dpvs中fdir与sa_pool介绍
chris的博客
08-20 2105
问题引入 dpvs是dpdk程序，特点就是每个核尽可能不与其他核交互，这就要求共享数据都有一份拷贝，或是数据私有。fnat模式中流表（session）保存连接信息，每个核独有。但这里有个问题，full-nat模式下，返程数据outbound packet也必须分配到与inbound packet收取的同一个lcore，否则在流表中找不到conn dpvs解决方案 引入fdir机制 lcore上lip都是同步一致的，根据本地端口lport，来分配正确的核，此处用于fdir计算的lport根据启用的l
dpvs fnat模式
chris的博客
08-19 1249
inbound方向 dp_vs_xmit_nat //fnat模式inbound数据传输 int dp_vs_xmit_fnat(struct dp_vs_proto *proto, struct dp_vs_conn *conn, struct rte_mbuf *mbuf) { int af = conn->af; assert(af == AF_INET || af == AF_INET
linux内核中邻居项状态机
chris的博客
08-21 1112
邻居项状态机 NUD_NONE 邻居项刚建立时处于的初始状态 在此状态下,还没有硬件地址可使用,因此还不能发送请求报文.此时,一旦有报文要输出到该邻居,便会触发对该邻居硬件地址的请求,进入NUD_INCOMPLETE状态,并缓存发送的报文. 参见neigh_alloc和neigh_resolve_output NUD_INCOMPLETE 请求报文已经发送,但尚未收到应答的状态 在此状态下,还没有解析到硬件地址,因此尚无可用的硬件地址,如果有报文要输出到此邻居...
IPv4数据包处理
chris的博客
08-18 1086
IPv4协议pkt_type注册 ipv4_init时调用netif_register_pkt注册 static struct pkt_type ip4_pkt_type = { //.type = rte_cpu_to_be_16(ETHER_TYPE_IPv4), .func = ipv4_rcv, .port = NULL, }; int ipv4_init(void) { int err, i; ip4_id..
dpvs nat模式
chris的博客
08-19 830
NAT模式限制 NAT为双臂模式 拓扑实例 如上图所示，各节点的IP地址如下： client: 192.168.0.46 VIP: 192.168.0.89 DPVS local ip: 192.168.0.66, 10.140.31.48 RS1: 10.140.18.33 RS2: 10.140.18.33 可见，所有的IP地址都在一个局域网内 NAT模式约束 DPVS-NAT模式只能在单个lcore中工作。由于以上原因，dp
dpvs DR模式
chris的博客
08-19 749
简介 LB只处理进入的请求，将流量分发给后端，返回数据由Real Server直接返回到Client，所以模式叫Direct Routing 原理：修改二层头mac地址，所以它的局限性也很明显，只能在同一个二层，不能跨网段。由于直接返回给client，一般不会面对公网用户 部署图 DR Mode配置（one-arm） To use DR dpvs needs a LAN IP first. (for one-arm, it must be different
dpvs之l2层数据包处理
chris的博客
08-18 723
二层数据报处理入口函数 void lcore_process_packets(struct netif_queue_conf *qconf, struct rte_mbuf **mbufs, lcoreid_t cid, uint16_t count, bool pkts_from_ring) { int i, t; struct ether_hdr *eth_hdr; struct rte_mbuf * mbuf_copied
dpvs conn超时处理
chris的博客
08-20 671
连接定时器处理函数设置 超时处理函数为dp_vs_conn_expire 设置priv为当前conn static void dp_vs_conn_attach_timer(struct dp_vs_conn *conn, bool lock) { int rc; //如果conn->timer正在运行中，则直接返回 if (dp_vs_conn_is_in_timer(conn)) { return; } //如果为长连..
ps auxf | grep dp_service|grep -v grep | awk '{print $2}'| xargs kill > /dev/null 2>&1
最新发布
07-28
具体的步骤如下：首先使用ps auxf | grep dp_service命令查找包含"dp_service"关键字的进程，然后使用grep -v grep过滤掉grep进程本身，接着使用awk '{print $2}'截取进程号，最后使用xargs kill命令将进程号传递给...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值