本文用于分析dpvs的启动流程，会对主要逻辑进行解析，忽略了一些边缘代码，比如配置文件解析，函数指针的注册等等。在阅读主逻辑的时候，如果有疑问的地方，再去看一些配置相关，初始化相关的代码。这样不仅高效而且不会那么枯燥。被忽略的代码将在本文中用...代替。

从main函数开始

在src/mian.c文件中，main函数还是比较清晰的。首先是初始 -> 然后启动端口 -> 然后启动工作线程 -> 主线程进入循环。

int main(int argc, char *argv[])
{
    ...
    //各种初始化，暂不关心，用到的时候再看。
    err = rte_eal_init(argc, argv);
    if (err < 0)
        rte_exit(EXIT_FAILURE, "Invalid EAL parameters\n");
    argc -= err, argv += err;

    rte_timer_subsystem_init();

    if ((err = cfgfile_init()) != EDPVS_OK)
        rte_exit(EXIT_FAILURE, "Fail init configuration file: %s\n",
                 dpvs_strerror(err));

    if ((err = netif_virtual_devices_add()) != EDPVS_OK)
        rte_exit(EXIT_FAILURE, "Fail add virtual devices:%s\n",
                 dpvs_strerror(err));

    if ((err = dpvs_timer_init()) != EDPVS_OK)
        rte_exit(EXIT_FAILURE, "Fail init timer on %s\n", dpvs_strerror(err));

    if ((err = tc_init()) != EDPVS_OK)
        rte_exit(EXIT_FAILURE, "Fail to init traffic control: %s\n",
                 dpvs_strerror(err));

    if ((err = netif_init(NULL)) != EDPVS_OK)
        rte_exit(EXIT_FAILURE, "Fail to init netif: %s\n", dpvs_strerror(err));
    /* Default lcore conf and port conf are used and may be changed here 
     * with "netif_port_conf_update" and "netif_lcore_conf_set" */

    if ((err = ctrl_init()) != EDPVS_OK)
        rte_exit(EXIT_FAILURE, "Fail to init ctrl plane: %s\n",
                 dpvs_strerror(err));

    if ((err = tc_ctrl_init()) != EDPVS_OK)
        rte_exit(EXIT_FAILURE, "Fail to init tc control plane: %s\n",
                 dpvs_strerror(err));

    if ((err = vlan_init()) != EDPVS_OK)
        rte_exit(EXIT_FAILURE, "Fail to init vlan: %s\n", dpvs_strerror(err));

    if ((err = inet_init()) != EDPVS_OK)
        rte_exit(EXIT_FAILURE, "Fail to init inet: %s\n", dpvs_strerror(err));

    if ((err = sa_pool_init()) != EDPVS_OK)
        rte_exit(EXIT_FAILURE, "Fail to init sa_pool: %s\n", dpvs_strerror(err));

    if ((err = dp_vs_init()) != EDPVS_OK)
        rte_exit(EXIT_FAILURE, "Fail to init ipvs: %s\n", dpvs_strerror(err));

    if ((err = netif_ctrl_init()) != EDPVS_OK)
        rte_exit(EXIT_FAILURE, "Fail to init netif_ctrl: %s\n",
                 dpvs_strerror(err));

    /* config and start all available dpdk ports */
    nports = rte_eth_dev_count();
    for (pid = 0; pid < nports; pid++) {
        dev = netif_port_get(pid);
        if (!dev) {
            RTE_LOG(WARNING, DPVS, "port %d not found\n", pid);
            continue;
        }
        //启动端口，配置端口。比如端口，队列，cpu的绑定等等。
        err = netif_port_start(dev);
        if (err != EDPVS_OK)
            RTE_LOG(WARNING, DPVS, "Start %s failed, skipping ...\n",
                    dev->name);
    }

    /* print port-queue-lcore relation */
    netif_print_lcore_conf(pql_conf_buf, &pql_conf_buf_len, true, 0);
    RTE_LOG(INFO, DPVS, "\nport-queue-lcore relation array: \n%s\n",
            pql_conf_buf);

    /* start data plane threads */
    netif_lcore_start(); //这里就是干活的线程，通过跟踪这个函数，最后会调用到netif_loop，即工作线程的loop

    /* write pid file */
    if (!pidfile_write(DPVS_PIDFILE, getpid()))
        goto end;

    timer_sched_loop_interval = dpvs_timer_sched_interval_get();
    assert(timer_sched_loop_interval > 0);

    dpvs_state_set(DPVS_STATE_NORMAL);

    /* start control plane thread */
    // 主线程循环，用于处理ctrl plane等消息，这里占不讨论，后续文章再讨论。
    while (1) {
        /* reload configuations if reload flag is set */
        try_reload();
        /* IPC loop */
        sockopt_ctl(NULL);
        /* msg loop */
        msg_master_process();

        /* timer */
        loop_cnt++;
        if (loop_cnt % timer_sched_loop_interval == 0)
            rte_timer_manage();
        /* kni */
        kni_process_on_master();

        /* process mac ring on master */
        neigh_process_ring(NULL);
 
        /* increase loop counts */
        netif_update_master_loop_cnt();
    }

    ...

    exit(0);
}

DPVS dataplane线程，即工作线程

DPVS在netif.c文件中static int netif_loop(void * dummy) 函数中收取，处理和发送数据包。

static int netif_loop(void *dummy)
{
    ...

    try_isol_rxq_lcore_loop();
    if (0 == lcore_conf[lcore2index[cid]].nports) {
        RTE_LOG(INFO, NETIF, "[%s] Lcore %d has nothing to do.\n", __func__, cid);
        return EDPVS_IDLE;
    }
    /* 这里收包和处理CPU分离，是指收包的CPU和处理包的CPU不同，应该是为了增加网卡的吞吐能力吧。
    只有在/etc/dpvs.conf配置文件中配置了isol_rx_cpu_ids才会生效，暂时用不到，在后文中再来分析吧*/

    list_for_each_entry(job, &netif_lcore_jobs[NETIF_LCORE_JOB_INIT], list) {
        do_lcore_job(job);
    }
    /* NETIF_LCORE_JOB_INIT type类型暂时没有用到，忽略之*/

    while (1) {
#ifdef CONFIG_RECORD_BIG_LOOP
        loop_start = rte_get_timer_cycles();
#endif
/* CONFIG_RECORD_BIG_LOOP给统计和debug用，暂不关心 */

        lcore_stats[cid].lcore_loop++;
        list_for_each_entry(job, &netif_lcore_jobs[NETIF_LCORE_JOB_LOOP], list) {
            do_lcore_job(job);
        }
        ++netif_loop_tick[cid];
        list_for_each_entry(job, &netif_lcore_jobs[NETIF_LCORE_JOB_SLOW], list) {
            if (netif_loop_tick[cid] % job->skip_loops == 0) {
                do_lcore_job(job);
                //netif_loop_tick[cid] = 0;
            }
        }
        /* 上面代码有点类似于netfilter处理链，数据包会被处理链的job依次处理, 这些job链放在netif_lcore_jobs 这个全局变量中。
        那么，有哪些job呢，在什么地方初始化这个全局变量的呢？他们的处理顺序是怎么样的？在下一节会有说明*/
#ifdef CONFIG_RECORD_BIG_LOOP
        loop_end = rte_get_timer_cycles();
        loop_time = (loop_end - loop_start) * 1E6 / cycles_per_sec;
        if (loop_time > longest_lcore_loop[cid]) {
            RTE_LOG(WARNING, NETIF, "update longest_lcore_loop[%d] = %d (<- %d)\n",
                    cid, loop_time, longest_lcore_loop[cid]);
            longest_lcore_loop[cid] = loop_time;
        }
        if (loop_time > BIG_LOOP_THRESH) {
            print_job_time(buf, sizeof(buf));
            RTE_LOG(WARNING, NETIF, "lcore[%d] loop over %d usecs (actual=%d, max=%d):\n%s\n",
                    cid, BIG_LOOP_THRESH, loop_time, longest_lcore_loop[cid], buf);
        }
#endif
/* CONFIG_RECORD_BIG_LOOP给统计和debug用，暂不关心 */
    }
    return EDPVS_OK;
}

//那么do_lcore_job 做了什么呢？ 其实do_lcore_job就是调用了job结构体中注册的函数指针指向的函数。

static inline void do_lcore_job(struct netif_lcore_loop_job *job)
{
#ifdef CONFIG_RECORD_BIG_LOOP
    uint64_t job_start, job_end;
    job_start = rte_get_timer_cycles();
#endif

    job->func(job->data);
    // 这里就是真正干活的地方了。
    // func 函数指针在main函数中进行了初始化，初始化过程及代码位置在下一节会讲到。

#ifdef CONFIG_RECORD_BIG_LOOP
    job_end = rte_get_timer_cycles();
    job->job_time[rte_lcore_id()] = (job_end - job_start) * 1E6 / cycles_per_sec;
#endif
}

DPVS dataplane线程job初始化（ 也就是 netif_lcore_jobs 全局变量的初始化）

目前job的类型为，又有NETIF_LCORE_JOB_LOOP和NETIF_LCORE_JOB_SLOW有用到：

enum netif_lcore_job_type {
    NETIF_LCORE_JOB_INIT      = 0,
    NETIF_LCORE_JOB_LOOP      = 1,
    NETIF_LCORE_JOB_SLOW      = 2,
    NETIF_LCORE_JOB_TYPE_MAX  = 3,
};

job注册函数

netif_lcore_loop_job_register 函数将job这测到netif_lcore_jobs这个全局变量中。

int netif_lcore_loop_job_register(struct netif_lcore_loop_job *lcore_job)
{
    struct netif_lcore_loop_job *cur;
    if (unlikely(NULL == lcore_job))
        return EDPVS_INVAL;

    list_for_each_entry(cur, &netif_lcore_jobs[lcore_job->type], list) {
        if (cur == lcore_job) {
            return EDPVS_EXIST;
        }
    }

    if (unlikely(NETIF_LCORE_JOB_SLOW == lcore_job->type && lcore_job->skip_loops <= 0))
        return EDPVS_INVAL;

    list_add_tail(&lcore_job->list, &netif_lcore_jobs[lcore_job->type]);
    //netif_lcore_jobs 记录job的全局变量，这个在netif_loop用到了
    return EDPVS_OK;
}

那么在哪些位置调用了netif_lcore_loop_job_register 注册job，通过阅读源代码，可以发现注册NETIF_LCORE_JOB_LOOP， NETIF_LCORE_JOB_SLOW 这两种类型的job分布在如下所示位置。

NETIF_LCORE_JOB_LOOP job注册

** 第一处： main->netif_init->netif_lcore_init函数中：**

/* register lcore jobs*/
snprintf(netif_jobs[0].name, sizeof(netif_jobs[0].name) - 1, "%s", "recv_fwd");
netif_jobs[0].func = lcore_job_recv_fwd;
netif_jobs[0].data = NULL;
netif_jobs[0].type = NETIF_LCORE_JOB_LOOP;
snprintf(netif_jobs[1].name, sizeof(netif_jobs[1].name) - 1, "%s", "xmit");
netif_jobs[1].func = lcore_job_xmit;
netif_jobs[1].data = NULL;
netif_jobs[1].type = NETIF_LCORE_JOB_LOOP;
snprintf(netif_jobs[2].name, sizeof(netif_jobs[2].name) - 1, "%s", "timer_manage");
netif_jobs[2].func = lcore_job_timer_manage;
netif_jobs[2].data = NULL;
netif_jobs[2].type = NETIF_LCORE_JOB_LOOP;

** 第二处： main->ctrl_init->msg_init**

ctrl_lcore_job.func = slave_lcore_loop_func;
ctrl_lcore_job.data = NULL;
ctrl_lcore_job.type = NETIF_LCORE_JOB_LOOP;
if ((ret = netif_lcore_loop_job_register(&ctrl_lcore_job)) < 0) {
    RTE_LOG(ERR, MSGMGR, "%s: fail to register ctrl func on slave lcores\n", __func__);
    return ret;
}

NETIF_LCORE_JOB_SLOW job注册

** 第一处： main->inet_init -> ipv4_init-> ipv4_frag_init **

frag_job.func = ipv4_frag_job;
frag_job.data = NULL;
frag_job.type = NETIF_LCORE_JOB_SLOW;
frag_job.skip_loops = IP4_FRAG_FREE_DEATH_ROW_INTERVAL;
err = netif_lcore_loop_job_register(&frag_job);

** 第二处： mian->inet_init -> neigh_init -> arp_init **

neigh_sync_job.func = neigh_process_ring;
neigh_sync_job.data = NULL;
neigh_sync_job.type = NETIF_LCORE_JOB_SLOW;
neigh_sync_job.skip_loops = NEIGH_PROCESS_MAC_RING_INTERVAL;
err = netif_lcore_loop_job_register(&neigh_sync_job);

** 通过上述分析，那么我们可以知道job的处理流程为 **
以下流程虽然都要执行，但是函数前后并不是强制依赖，比如lcore_job_timer_manage 不依赖于lcore_job_xmit的执行结果

lcore_job_recv_fwd -> lcore_job_xmit -> lcore_job_timer_manage -> slave_lcore_loop_func ->
ipv4_frag_job -> neigh_process_ring

这些函数的具体功能，将在下一章节进行分析。

启动过程就到此结束了，若有疑问，欢迎发邮件和我联系。