DPDK初始化

一. DPDK源码版本： DPDK19.02    http://core.dpdk.org/download/

二. DPDK 初始化部分

　　1.初始化EAL环境，rte_eal_init();

　　2.解析参数，因为DPDK的参数在EAL初始化时就进行了解析，所以，这里主要解析的是我们自己的参数，可以使用getopt_long函数。

　　3.初始化内存池等，这里要注意放在接口的初始化之前，为接收数据包做准备。

　　4.初始化接口

　　5.启动所有核上的线程。rte_eal_mp_remote_launch()

三. 下面详细讲解初始化作用过程：

2.1 EAL初始化

1）EAL功能作用：

• Intel® DPDK loading and launching
• Support for multi-process and multi-thread execution types
• Core affinity/assignment procedures
• System memory allocation/de-allocation
• Atomic/lock operations
• Time reference
• PCI bus access
• Trace and debug functions
• CPU feature identification
• Interrupt handling
• Alarm operations

ref: http://doc.dpdk.org/guides/prog_guide/   （详细可参考文章）

2) 初始化程序： 源文件eal.c

/* Launch threads, called at application init(). */
int
rte_eal_init(int argc, char **argv)
{
    int i, fctret, ret;
    pthread_t thread_id;
    static rte_atomic32_t run_once = RTE_ATOMIC32_INIT(0);
    const char *p;
    static char logid[PATH_MAX];
    char cpuset[RTE_CPU_AFFINITY_STR_LEN];
    char thread_name[RTE_MAX_THREAD_NAME_LEN];

    /* checks if the machine is adequate */
    //检测cpu的标识是否支持
    //dpdk在进行cpu运行时，会考虑采用cpu高级指令来优化运算速度。
    if (!rte_cpu_is_supported()) {   
        rte_eal_init_alert("unsupported cpu type.");
        rte_errno = ENOTSUP;
        return -1;
    }

    //操作静态局部变量run_once确保函数只执行一次
    if (!rte_atomic32_test_and_set(&run_once)) {
        rte_eal_init_alert("already called initialization.");
        rte_errno = EALREADY;
        return -1;
    }

    p = strrchr(argv[0], '/');
    strlcpy(logid, p ? p + 1 : argv[0], sizeof(logid));
    thread_id = pthread_self();

    //初始化结构体struct internal_config
    eal_reset_internal_config(&internal_config);

    /* set log level as early as possible */
    //解析命令行参数，只处理“--log-level”，保存在internal_config.log_level
    eal_log_level_parse(argc, argv);

    //获取系统中的CPU数量
    if (rte_eal_cpu_init() < 0) {
        rte_eal_init_alert("Cannot detect lcores.");
        rte_errno = ENOTSUP;
        return -1;
    }

    /*
    EAL初始化参数：
        -c COREMASK：要使用CPU core16进制掩码。注意core编号在不同的平台不一样，需要事先确定好。
        -n NUM：每个处理器socket的内存通道数
        -b domain:bus:devid.func:网口黑名单,EAL不能使用的PCI设备（可以同时存在多个-b选项）
        –socket-mem:在指定socket上分配大页内存
        -m MB：指定分配大大页内存数，不限处理器的socket。加以使用—socket-mem代替这个参数
        -r NUM:内存的rank数
        -v：显示程序版本号
        –huge-dir:大页内存的挂载点
        –file-prefix:大页内存文件的前缀
        –proc-type:进程类型（primary,secondary,auto）
        –xen-dom0:支持程序在Xen Domain0中非大页内存下运行
        –vmware-tsc-map:使用VMware TSC代替本地的RDTSC
        –base-virtaddr :指定虚拟地址的基址
        –vfio-intr:指定VFIO使用的中断类型（如果不是用VFIO则无效） 
        -c是必须的，其它都是可选的。
    */
    fctret = eal_parse_args(argc, argv);
    if (fctret < 0) {
        rte_eal_init_alert("Invalid 'command line' arguments.");
        rte_errno = EINVAL;
        rte_atomic32_clear(&run_once);
        return -1;
    }
    
    //根据命令行参数初始化internal_config
    if (eal_plugins_init() < 0) {
        rte_eal_init_alert("Cannot init plugins");
        rte_errno = EINVAL;
        rte_atomic32_clear(&run_once);
        return -1;
    }

    if (eal_option_device_parse()) {
        rte_errno = ENODEV;
        rte_atomic32_clear(&run_once);
        return -1;
    }

    /*
    主应用的情况(RTE_PROC_PRIMARY)
        rte_eal_config_create
        eal_runtime_config_path：获取runtime配置文件路径，如“/var/run/.rte_config”
        打开文件，上锁，mmap映射文件到内存
        将early configuration structure(全局变量early_mem_config)拷贝到此内存中，rte_config.mem_config指向这块内存
        映射地址保存在rte_config.mem_config->mem_cfg_addr中，用于从应用将来映射到相同的地址
    从应用的情况(RTE_PROC_SECONDARY)
        rte_eal_config_attach
            eal_runtime_config_path
            打开文件，mmap映射文件到内存
            rte_config.mem_config指向映射的内存
        rte_eal_mcfg_wait_complete
            如果struct rte_mem_config结构的magic成员没有被写成RTE_MAGIC，就继续等待
            (主应用ready后会将struct rte_mem_config结构的magic成员写成RTE_MAGIC)
        rte_eal_config_reattach
            从前面mmap映射文件中获取主应用mmap的映射地址(即rte_config.mem_config->mem_cfg_addr)
            munmap解除先前的映射
            指定主应用映射地址重新执行mmap映射，如果最终映射地址和指定映射地址不一致，则出错退出
            将rte_config.mem_config指向重新映射的内存
    */
    rte_config_init();

    
    /*
    初始化global interrupt source head
    创建pipe
    创建线程来等待处理中断，线程执行函数为eal_intr_thread_main
        线程运行循环
            epoll_create：创建epoll文件描述符
            epoll_ctl：把前面创建的the read end of the pipe，添加到epoll wait list中
            遍历以global interrupt source head为头部的struct rte_intr_source结构链表
                如果当前struct rte_intr_source结构没有挂载的callback函数，跳过
                把所有的uio device file descriptor，添加到epoll wait list中
            eal_intr_handle_interrupts
                epoll_wait：wait for an I/O event on an epoll file descriptor
                eal_intr_process_interrupts
                    遍历所有发生的I/O eventc
                    如果the read end of the pipe可用，执行read操作，函数返回
                    遍历struct rte_intr_source结构链表，查找当前I/O event对应的structrte_intr_source结构
                    根据interrupt handle type(uio/alarm/…)，确定需要读取的字节长度
                    执行文件read操作
                    如果read数据成功，执行当前struct rte_intr_source结构挂载的所有callback函数
                调用eal_intr_process_interrupts返回负数，本次中断处理结束返回
            关闭epoll文件描述符
        如果创建线程成功，调用rte_thread_setname给线程设置名称“eal-intr-thread”
            pthread_setname_np
    循环(browse all running lcores except the master lcore)
        创建主线程与子线程通信使用的pipe
        设置子线程状态为WAIT
        创建子线程，线程执行函数为eal_thread_loop
            根据线程ID，获取当前线程的lcore_id
            获取主线程向子线程通信所用管道，子线程读取数据的file descriptor(m2s)
            获取子线程向主线程通信所用管道，子线程发送数据的file descriptor(s2m)
            eal_thread_set_affinity：设置子线程cpu affinity
            eal_thread_dump_affinity
            线程主循环
                等待读取主线程发送的命令
                设置线程状态为RUNNING
                向主线程发送ack
                读取当前lcore对应的structlcore_config结构中的lcore_function_t类型函数指针，及调用参数
                执行所指函数，并存储返回值
                设置线程状态为FINISHED
    如果创建线程成功，调用rte_thread_setname给线程设置名称“lcore-slave-xx”
    
    */
    if (rte_eal_intr_init() < 0) {
        rte_eal_init_alert("Cannot init interrupt-handling thread");
        return -1;
    }

    /* Put mp channel init before bus scan so that we can init the vdev
     * bus through mp channel in the secondary process before the bus scan.
     */
     /*
        多进程的情况稍微复杂一些，除了线程间的通信外，还要完成primary进程和其他secondary进程的通信
        模块初始化中的下面函数完成的(mp表示multiple process)
        其内部会单独创建一个线程用来接收来自其他进程的消息
     */
    if (rte_mp_channel_init() < 0) {
        rte_eal_init_alert("failed to init mp channel");
        if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
            rte_errno = EFAULT;
            return -1;
        }
    }

    /* register multi-process action callbacks for hotplug */
    //注册一个action
    if (rte_mp_dev_hotplug_init() < 0) {
        rte_eal_init_alert("failed to register mp callback for hotplug");
        return -1;
    }

    /*
        bus scan提供的主接口，内部会调用所有bus->scan。接口的目的是扫描所有bus下注册的设备
        bus下默认的设备路径在/sys/bus/pci/devices
        同内核扫描流程不同，DPDK只是将kernel扫描pci后建立的sysfs信息读取出来，获得内核已经扫描好的pci信息
        在linux设备模型中总线类型下挂有属于该bus的device和driver的文件夹，每个文件夹里存在具体的device指向实际的设备文件
            /sys/bus/pci/devices/
        
    */
    if (rte_bus_scan()) {
        rte_eal_init_alert("Cannot scan the buses for devices");
        rte_errno = ENODEV;
        rte_atomic32_clear(&run_once);
        return -1;
    }

    /* if no EAL option "--iova-mode=<pa|va>", use bus IOVA scheme */
    if (internal_config.iova_mode == RTE_IOVA_DC) {
        /* autodetect the IOVA mapping mode (default is RTE_IOVA_PA) */
        //获取全局配置结构struct rte_config，初始指向全局变量early_mem_config
        rte_eal_get_configuration()->iova_mode =
            rte_bus_get_iommu_class();

        /* Workaround for KNI which requires physical address to work */
        if (rte_eal_get_configuration()->iova_mode == RTE_IOVA_VA &&
                rte_eal_check_module("rte_kni") == 1) {
            rte_eal_get_configuration()->iova_mode = RTE_IOVA_PA;
            RTE_LOG(WARNING, EAL,
                "Some devices want IOVA as VA but PA will be used because.. "
                "KNI module inserted
");
        }
    } else {
        rte_eal_get_configuration()->iova_mode =
            internal_config.iova_mode;
    }

    if (internal_config.no_hugetlbfs == 0) {
        /* rte_config isn't initialized yet */
        ret = internal_config.process_type == RTE_PROC_PRIMARY ?
                eal_hugepage_info_init() :
                eal_hugepage_info_read();
        if (ret < 0) {
            rte_eal_init_alert("Cannot get hugepage information.");
            rte_errno = EACCES;
            rte_atomic32_clear(&run_once);
            return -1;
        }
    }

    if (internal_config.memory == 0 && internal_config.force_sockets == 0) {
        if (internal_config.no_hugetlbfs)
            internal_config.memory = MEMSIZE_IF_NO_HUGE_PAGE;
    }

    if (internal_config.vmware_tsc_map == 1) {
#ifdef RTE_LIBRTE_EAL_VMWARE_TSC_MAP_SUPPORT
        rte_cycles_vmware_tsc_map = 1;
        RTE_LOG (DEBUG, EAL, "Using VMWARE TSC MAP, "
                "you must have monitor_control.pseudo_perfctr = TRUE
");
#else
        RTE_LOG (WARNING, EAL, "Ignoring --vmware-tsc-map because "
                "RTE_LIBRTE_EAL_VMWARE_TSC_MAP_SUPPORT is not set
");
#endif
    }

    rte_srand(rte_rdtsc());

    /*
        调用fopencookie，定义一个定制的写日志接口
        调用openlog打开日志
        rte_eal_common_log_init:
            STAILQ_INIT：初始化Singly-linked Tail queue，队头为log_history
            rte_mempool_create
            如果创建mempool失败，调用rte_mempool_lookup
                获取链接所有mempool结构链表的头结构structrte_mempool_list
                遍历链接所有mempool结构链表的所有结点
                比较struct rte_tailq_entry结构的data域指向的struct rte_mempool结构的名称，
                是否与指定名称相同
            返回找到的指向struct rte_mempool结构的指针，或NULL
    */
    if (rte_eal_log_init(logid, internal_config.syslog_facility) < 0) {
        rte_eal_init_alert("Cannot init logging.");
        rte_errno = ENOMEM;
        rte_atomic32_clear(&run_once);
        return -1;
    }

#ifdef VFIO_PRESENT
    if (rte_eal_vfio_setup() < 0) {
        rte_eal_init_alert("Cannot init VFIO");
        rte_errno = EAGAIN;
        rte_atomic32_clear(&run_once);
        return -1;
    }
#endif
    /* in secondary processes, memory init may allocate additional fbarrays
     * not present in primary processes, so to avoid any potential issues,
     * initialize memzones first.
     */
     /*
     rte_memzone在DPDK的内存资源管理中起到的是其他资源管家的作用，默认情况下，
     在DPDK初始化时会创建RTE_MAX_MEMZONE个rte_memzone,
     每一个都可以记录一个rte_ring或者rte_mempool的内存位置
     每一个rte_ring或者rte_mempool都有一个指针回指到它关联的rte_memzone
     Memzone是内存分配的基本单元，mempool,malloc_heap在需要内存时，都会执行rte_memzone_reserve操作
     rte_memzone_reserve 从memseg中分配一块内存出来
     */
    if (rte_eal_memzone_init() < 0) {
        rte_eal_init_alert("Cannot init memzone");
        rte_errno = ENODEV;
        return -1;
    }

    /*
    1.获取所有预留hugepage的物理地址并按物理地址进行排序
    2.根据物理物理地址，虚拟地址，soket_id等将hugpages组合成memseg
    3.将所有memseg信息在所有dpdk程序间共享
    */
    if (rte_eal_memory_init() < 0) {
        rte_eal_init_alert("Cannot init memory");
        rte_errno = ENOMEM;
        return -1;
    }

    /* the directories are locked during eal_hugepage_info_init */
    //解锁hugepage目录(由前面的eal_hugepage_info_init函数加锁)
    eal_hugedirs_unlock();

    /*
    1.函数将连续的memseg使用heap的方式管理起来，heap数据抽象
    2.注册register_mp_requests
    3.rte_memseg_contig_walk遍历memseg list中连续的mem seg,然后使用malloc_add_seg将这些内存加入heap的管理
    4.heap的管理在malloc_heap_add_memory中实现
    */
    if (rte_eal_malloc_heap_init() < 0) {
        rte_eal_init_alert("Cannot init malloc heap");
        rte_errno = ENODEV;
        return -1;
    }

    if (rte_eal_tailqs_init() < 0) {
        rte_eal_init_alert("Cannot init tail queues for objects");
        rte_errno = EFAULT;
        return -1;
    }

    //赋值全局的struct rte_intr_handle结构，调用timerfd_create函数创建定时器timer对象
    if (rte_eal_alarm_init() < 0) {
        rte_eal_init_alert("Cannot init interrupt-handling thread");
        /* rte_eal_alarm_init sets rte_errno on failure. */
        return -1;
    }

    /*
        设定全局变量eal_timer_source为EAL_TIMER_TSC(TSC/HPET)
        set_tsc_freq：设置TSC frequency(每秒钟时钟中断的次数)
        解析文件“/proc/cpuinfo”，检查“flags”属性中“constant_tsc”和“nonstop_tsc”是否存在
    */
    if (rte_eal_timer_init() < 0) {
        rte_eal_init_alert("Cannot init HPET or TSC timers");
        rte_errno = ENOTSUP;
        return -1;
    }

    /*
        获取masterlcore对应的numa socket
        rte_eal_get_physmem_layout：获取struct rte_memseg结构数组地址
        遍历struct rte_memseg结构数组，检查特定struct rte_memseg结构是否存在(对应此numa socket，并且长度大于0)
    */
    eal_check_mem_on_local_socket();

    /*
        设置主线程的lcore_id
        eal_thread_set_affinity
            rte_sys_gettid：获取线程的tid
            设置线程的CPU亲和性，记录numasocket等信息
    */
    eal_thread_init_master(rte_config.master_lcore);

    //dump当前线程的CPU affinity
    ret = eal_thread_dump_affinity(cpuset, sizeof(cpuset));

    RTE_LOG(DEBUG, EAL, "Master lcore %u is ready (tid=%zx;cpuset=[%s%s])
",
        rte_config.master_lcore, (uintptr_t)thread_id, cpuset,
        ret == 0 ? "" : "...");

    RTE_LCORE_FOREACH_SLAVE(i) {

        /*
         * create communication pipes between master thread
         * and children
         */
        if (pipe(lcore_config[i].pipe_master2slave) < 0)
            rte_panic("Cannot create pipe
");
        if (pipe(lcore_config[i].pipe_slave2master) < 0)
            rte_panic("Cannot create pipe
");

        lcore_config[i].state = WAIT;

        /* create a thread for each lcore */
        ret = pthread_create(&lcore_config[i].thread_id, NULL,
                     eal_thread_loop, NULL);
        if (ret != 0)
            rte_panic("Cannot create thread
");

        /* Set thread_name for aid in debugging. */
        snprintf(thread_name, sizeof(thread_name),
            "lcore-slave-%d", i);
        ret = rte_thread_setname(lcore_config[i].thread_id,
                        thread_name);
        if (ret != 0)
            RTE_LOG(DEBUG, EAL,
                "Cannot set name for lcore thread
");
    }

    /*
     * Launch a dummy function on all slave lcores, so that master lcore
     * knows they are all ready when this function returns.
     */
     /*指示所有子线程启动一个dummyfunction*/
     /*
        检查各个子线程/lcore的状态是否处于WAIT
            rte_eal_remote_launch：向各个子线程/lcore发送执行命令
                获取主线程向子线程通信所用管道，主线程发送数据的file descriptor(m2s)
                获取子线程向主线程通信所用管道，主线程读取数据的file descriptor(s2m)
                将lcore_function_t类型函数指针，及调用参数填入当前lcore对应的structlcore_config结构
                向子线程发送命令
                等待读取子线程发送的ack
            如果最后一个参数值为CALL_MASTER(lcore handler executed by master core)，主线程也执行所指函数
    */
    rte_eal_mp_remote_launch(sync_func, NULL, SKIP_MASTER);
    rte_eal_mp_wait_lcore();

    /* initialize services so vdevs register service during bus_probe. */
    ret = rte_service_init();
    if (ret) {
        rte_eal_init_alert("rte_service_init() failed");
        rte_errno = ENOEXEC;
        return -1;
    }

    /* Probe all the buses and devices/drivers on them */
    if (rte_bus_probe()) {
        rte_eal_init_alert("Cannot probe devices");
        rte_errno = ENOTSUP;
        return -1;
    }

#ifdef VFIO_PRESENT
    /* Register mp action after probe() so that we got enough info */
    if (rte_vfio_is_enabled("vfio") && vfio_mp_sync_setup() < 0)
        return -1;
#endif

    /* initialize default service/lcore mappings and start running. Ignore
     * -ENOTSUP, as it indicates no service coremask passed to EAL.
     */
    ret = rte_service_start_with_defaults();
    if (ret < 0 && ret != -ENOTSUP) {
        rte_errno = ENOEXEC;
        return -1;
    }

    /*
     * Clean up unused files in runtime directory. We do this at the end of
     * init and not at the beginning because we want to clean stuff up
     * whether we are primary or secondary process, but we cannot remove
     * primary process' files because secondary should be able to run even
     * if primary process is dead.
     *
     * In no_shconf mode, no runtime directory is created in the first
     * place, so no cleanup needed.
     */
    if (!internal_config.no_shconf && eal_clean_runtime_dir() < 0) {
        rte_eal_init_alert("Cannot clear runtime directory
");
        return -1;
    }
    
    /*
        如果是主应用，将全局内存配置struct rte_mem_config结构的magic成员写成RTE_MAGIC，
        表明主应用EAL初始化完成
    */
    rte_eal_mcfg_complete();

    /* Call each registered callback, if enabled */
    rte_option_init();

    return fctret;
}