DPDK rte_eal_init 初始化分析(根据最新的更新)

端口初始化流程

  • 1. 注册设备驱动到“dev_driver_list”链表中
  • 2.扫描系统中的pci设备,并注册到“pci_device_list”中
  • 3、初始化注册的驱动
  • 4、网卡设备初始化

端口初始化流程
 
如上所示给出了端口打开的简单流程图,下面以ixgbe驱动为例详细说明:

端å£çåå§åæµç¨

1. 注册设备驱动到“dev_driver_list”链表中

这个链表节点为:
 

/**
 * A structure describing a device driver.
 */
struct rte_driver {
    TAILQ_ENTRY(rte_driver) next;  /**< Next in list. */
    enum pmd_type type;            /**< PMD Driver type */
    const char *name;              /**< Driver name. */
    rte_dev_init_t *init;          /**< Device init. function. */
    rte_dev_uninit_t *uninit;      /**< Device uninit. function. */
};


将ixgbe的这些信息注册到该链表中:

static struct rte_driver rte_ixgbe_driver = {
    .type = PMD_PDEV,
    .init = rte_ixgbe_pmd_init,
};

PMD_REGISTER_DRIVER(rte_ixgbe_driver);


PMD_REGISTER_DRIVER为dpdk定义的宏,使用了GNU C提供的“__attribute__(constructor)”机制,使得注册设备驱动的过程在main函数执行之前完成。 
这样就有了设备驱动类型、设备驱动的初始化函数

2.扫描系统中的pci设备,并注册到“pci_device_list”中

链表节点为:

/**
 * A structure describing a PCI device.
 */
struct rte_pci_device {
    TAILQ_ENTRY(rte_pci_device) next;       /**< Next probed PCI device. */
    struct rte_pci_addr addr;               /**< PCI location. */
    struct rte_pci_id id;                   /**< PCI ID. */
    struct rte_pci_resource mem_resource[PCI_MAX_RESOURCE];   /**< PCI Memory Resource */
    struct rte_intr_handle intr_handle;     /**< Interrupt handle */
    struct rte_pci_driver *driver;          /**< Associated driver */
    uint16_t max_vfs;                       /**< sriov enable if not zero */
    int numa_node;                          /**< NUMA node connection */
    struct rte_devargs *devargs;            /**< Device user arguments */
    enum rte_kernel_driver kdrv;            /**< Kernel driver passthrough */
};

从系统中获取到PCI设备的相关信息后,记录到这样的一个结构体中。如何获取到这些信息: 
在main函数的一开始,调用rte_eal_init()获取用户、系统的相关配置信息以及设置基础运行环境,其中包括调用rte_eal_pci_init()来扫描、获取系统中的CPI网卡信息; 
首先,初始化pci_device_list链表,后面扫描的到的pci网卡设备信息会记录到这个链表中; 
然后,调用rte_eal_pci_scan()扫描系统中的PCI网卡:遍历”/sys/bus/pci/devices”目录下的所有pci地址,逐个获取对应的pci地址、pci id、sriov使能时的vf个数、亲和的numa、设备地址空间、驱动类型等;

/*
 * Scan the content of the PCI bus, and the devices in the devices list
 */
int rte_eal_pci_scan(void)
{
    struct dirent *e;
    DIR *dir;
    char dirname[PATH_MAX];
    uint16_t domain;
    uint8_t bus, devid, function;

    dir = opendir(SYSFS_PCI_DEVICES);
    if (dir == NULL) {
        RTE_LOG(ERR, EAL, "%s(): opendir failed: %s\n",
            __func__, strerror(errno));
        return -1;
    }

    while ((e = readdir(dir)) != NULL) {
        if (e->d_name[0] == '.')
            continue;

        if (parse_pci_addr_format(e->d_name, sizeof(e->d_name), &domain,
                &bus, &devid, &function) != 0)
            continue;

        snprintf(dirname, sizeof(dirname), "%s/%s", SYSFS_PCI_DEVICES,
             e->d_name);
        if (pci_scan_one(dirname, domain, bus, devid, function) < 0)
            goto error;
    }
    closedir(dir);
    return 0;

error:
    closedir(dir);
    return -1;
}


这样,扫描并记录了系统中所有的pci设备的相关信息,后面根据上面获取的这些设备信息以及前面注册的驱动信息,就可以完成具体网卡设备的初始化;

3、初始化注册的驱动

在rte_eal_init()函数中,后面会调用rte_eal_dev_init()来初始化前面注册的驱动“dev_driver_list”:分别调用注册的每款驱动的初始化函数,把每款驱动的一些信息记录到“pci_driver_list”链表中,链表节点为:

/**
 * @internal
 * The structure associated with a PMD Ethernet driver.
 *
 * Each Ethernet driver acts as a PCI driver and is represented by a generic
 * *eth_driver* structure that holds:
 *
 * - An *rte_pci_driver* structure (which must be the first field).
 *
 * - The *eth_dev_init* function invoked for each matching PCI device.
 *
 * - The *eth_dev_uninit* function invoked for each matching PCI device.
 *
 * - The size of the private data to allocate for each matching device.
 */
struct eth_driver {
    struct rte_pci_driver pci_drv;    /**< The PMD is also a PCI driver. */
    eth_dev_init_t eth_dev_init;      /**< Device init function. */
    eth_dev_uninit_t eth_dev_uninit;  /**< Device uninit function. */
    unsigned int dev_private_size;    /**< Size of device private data. */
};


结构中记录设备的init、uinit、私有数据大小以及pci driver信息,而struct rte_pci_driver中的记录了驱动支持的网卡设备的verder id、device id信息,这个在后面具体的PCI网卡设备初始化时,会根据这些信息来匹配驱动:

/**
 * A structure describing a PCI driver.
 */
struct rte_pci_driver {
    TAILQ_ENTRY(rte_pci_driver) next;       /**< Next in list. */
    const char *name;                       /**< Driver name. */
    pci_devinit_t *devinit;                 /**< Device init. function. */
    pci_devuninit_t *devuninit;             /**< Device uninit function. */
    const struct rte_pci_id *id_table;      /**< ID table, NULL terminated. */
    uint32_t drv_flags;                     /**< Flags contolling handling of device. */
};

/**
 * A structure describing an ID for a PCI driver. Each driver provides a
 * table of these IDs for each device that it supports.
 */
struct rte_pci_id {
    uint16_t vendor_id;           /**< Vendor ID or PCI_ANY_ID. */
    uint16_t device_id;           /**< Device ID or PCI_ANY_ID. */
    uint16_t subsystem_vendor_id; /**< Subsystem vendor ID or PCI_ANY_ID. */
    uint16_t subsystem_device_id; /**< Subsystem device ID or PCI_ANY_ID. */
};


已ixgbe类型的网卡为例,注册的信息为rte_ixgbe_pmd:

static struct eth_driver rte_ixgbe_pmd = {
    .pci_drv = {
        .name = "rte_ixgbe_pmd",
        .id_table = pci_id_ixgbe_map,
        .drv_flags = RTE_PCI_DRV_NEED_MAPPING | RTE_PCI_DRV_INTR_LSC |
            RTE_PCI_DRV_DETACHABLE,
    },
    .eth_dev_init = eth_ixgbe_dev_init,
    .eth_dev_uninit = eth_ixgbe_dev_uninit,
    .dev_private_size = sizeof(struct ixgbe_adapter),
};

至此,注册的每款驱动的设备初始化,支持的设备等信息以及系统中所有的pci设备信息就已经都有了,分别记录在”pci_driver_list”和”pci_device_list”这两个全局的链表中,接下来就可以完成设备匹配驱动,别初始化设备了。

4、网卡设备初始化

rte_eal_init()函数接下来调用rte_eal_pci_probe()函数完成具体的设备的初始化

/*
 * Scan the content of the PCI bus, and call the devinit() function for
 * all registered drivers that have a matching entry in its id_table
 * for discovered devices.
 */
int rte_eal_pci_probe(void)
{
    struct rte_pci_device *dev = NULL;
    struct rte_devargs *devargs;
    int probe_all = 0;
    int ret = 0;

    /* 如果配置了白名单,只初始化白名单中的设备,否则所有支持的设备都初始化 */
    if (rte_eal_devargs_type_count(RTE_DEVTYPE_WHITELISTED_PCI) == 0)
        probe_all = 1;

    TAILQ_FOREACH(dev, &pci_device_list, next) {

        /* set devargs in PCI structure */
        devargs = pci_devargs_lookup(dev);
        if (devargs != NULL)
            dev->devargs = devargs;

        /* probe all or only whitelisted devices */
        if (probe_all)
            ret = pci_probe_all_drivers(dev);
        else if (devargs != NULL &&
            devargs->type == RTE_DEVTYPE_WHITELISTED_PCI)
            ret = pci_probe_all_drivers(dev);
        if (ret < 0)
            rte_exit(EXIT_FAILURE, "Requested device " PCI_PRI_FMT
                 " cannot be used\n", dev->addr.domain, dev->addr.bus,
                 dev->addr.devid, dev->addr.function);
    }

    return 0;
}

rte_eal_pci_probe_one_driver()函数中,在probe一个具体的设备时,比较vendor id、device id,然后映射设备资源、调用驱动的设备初始化函数:

/*
 * If vendor/device ID match, call the devinit() function of the
 * driver.
 */
static int
rte_eal_pci_probe_one_driver(struct rte_pci_driver *dr, struct rte_pci_device *dev)
{
    int ret;
    const struct rte_pci_id *id_table;

    for (id_table = dr->id_table; id_table->vendor_id != 0; id_table++) {

        /* check if device's identifiers match the driver's ones */
        ... ...

        if (dr->drv_flags & RTE_PCI_DRV_NEED_MAPPING) {
            /* map resources for devices that use igb_uio */
            ret = rte_eal_pci_map_device(dev);
            if (ret != 0)
                return ret;
        } else if (dr->drv_flags & RTE_PCI_DRV_FORCE_UNBIND &&
                rte_eal_process_type() == RTE_PROC_PRIMARY) {
            /* unbind current driver */
            if (pci_unbind_kernel_driver(dev) < 0)
                return -1;
        }
        /* call the driver devinit() function */
        return dr->devinit(dr, dev);
    }
    /* return positive value if driver doesn't support this device */
    return 1;
}

pci_uio_map_resource()函数为pci设备在虚拟地址空间映射pci资源,后续直接通过操作内存来操作pci设备; 
驱动的设备初始化函数rte_eth_dev_init()主要是初始化dpdk驱动框架中,为每个设备分配资源以及资源的初始化:

/* 每个设备对应数组的一个成员,记录了设备相关的所有信息 */
struct rte_eth_dev rte_eth_devices[RTE_MAX_ETHPORTS];

/* 端口相关的配置 */
struct rte_eth_dev_data *dat;


dpdk框架中,对端口的初始化操作已经基本完成,后面则是根据用户的设置,配置端口的收发包队列以及最终start端口,开始收发包: 
a、rte_eth_dev_configure()函数完成端口配置:队列数配置、RSS、offload等等设置; 
b、rte_eth_rx_queue_setup()、rte_eth_tx_queue_setup()函数分别设置端口的每个收发队列:ring空间申请、初始化等; 
c、rte_eth_dev_start()函数:发送队列初始化buf填充,端口使能(具体可以参考代码或网卡芯片手册,均是相关寄存器设置);

 

rte_eal_init

├──rte_atomic32_test_and_set:操作静态局部变量run_once确保函数只执行一次

├──获取主线程的线程ID

├──rte_eal_log_early_init:将stderr作为日志输出的文件

│   │

│   └──rte_openlog_stream

├──eal_log_level_parse

│   │

│   ├──eal_reset_internal_config:初始化结构体struct internal_config

│   │

│   └──解析命令行参数,只处理“--log-level”,保存在internal_config.log_level

├──rte_set_log_level:设置log level

├──rte_eal_cpu_init:赋值全局结构struct lcore_config

│   │

│   ├──rte_eal_get_configuration:获取全局配置结构struct rte_config,初始指向全局变量early_mem_config

│   │

│   ├──eal_cpu_detected

│   │   │

│   │   └──如果文件“/sys/devices/system/cpu/cpu%u/topology/core_id”存在,则存在此编号的cpu

│   │

│   ├──eal_cpu_core_id

│   │   │

│   │   └──eal_parse_sysfs_value:读取文件“/sys/devices/system/cpu/cpu%u/topology/core_id”,

│   │         获取core number onsocket for this lcore

│   │

│   ├──eal_cpu_socket_id

│   │   │

│   │   └──如果目录“/sys/devices/system/node/node%u/cpu%u”存在,得到physical socket id for this lcore

│   │

│   └──计数得到number of available logical cores,保存在structrte_config.lcore_count中

├──eal_parse_args:解析处理EAL的命令行参数,赋值struct internal_config结构的相关字段

├──eal_hugepage_info_init:赋值struct hugepage_info数组(internal_config.hugepage_info)

│   │

│   ├──打开目录“/sys/kernel/mm/hugepages”

│   │

│   ├──遍历子目录,如“hugepages-2048kB”,即不同大小的hugepage

│   │   │

│   │   ├──获取当前大小hugepage对应的structhugepage_info结构体

│   │   │

│   │   ├──get_hugepage_dir

│   │   │   │

│   │   │   └──读取文件“/proc/mounts”,查找所有“hugetlbfs”,找到当前大小hugepage对应的挂载路径,

│   │   │         如“/mnt/huge”

│   │   │

│   │   ├──打开hugepage目录文件,上文件锁

│   │   │

│   │   ├──删除hugepage files,如“rtemap_xxx”

│   │   │

│   │   └──get_num_hugepages

│   │         │

│   │         └──读取文件“/sys/kernel/mm/hugepages/hugepages-2048kB/free_hugepages”和

│   │               “/sys/kernel/mm/hugepages/hugepages-2048kB/resv_hugepages”,获取hugepage总数

│   │

│   ├──对struct internal_config结构中的各个大小的struct hugepage_info进行排序,从大到小

│   │

│   └──检查是否至少有一个有效的struct hugepage_info

├──eal_get_hugepage_mem_size:

│   │

│   └──遍历struct hugepage_info,获取所有hugepage占用内存的总数,结果存放在internal_config.memory

├──将当前时间作为种子,产生伪随机数序列

├──rte_config_init

│   │

│   ├──主应用的情况(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_eal_pci_init

│   │

│   ├──初始化以全局变量pci_driver_list和pci_device_list为头的tail queue

│   │

│   └──rte_eal_pci_scan

│         │

│         └──遍历目录“/sys/bus/pci/devices”下的所有子目录

│               │

│               ├──parse_pci_addr_format:从目录名称中获取PCI设备的domain、bus、devid、function信息

│               │

│               └──pci_scan_one

│                     │

│                     ├──mallocstruct rte_pci_device结构

│                     │

│                     ├──读取目录“/sys/bus/pci/devices/0000\:03\:00.0/”下相关文件,填充struct rte_pci_device结构字段

│                     │

│                     ├──pci_get_kernel_driver_by_path:获取驱动名称

│                     │

│                     ├──赋值所支持的驱动(structrte_pci_device结构的kdrv字段)

│                     │

│                     └──将此struct rte_pci_device结构按序插入到全局队列pci_device_list

├──rte_eal_memory_init

├──eal_hugedirs_unlock:解锁hugepage目录(由前面的eal_hugepage_info_init函数加锁)

├──rte_eal_memzone_init

├──rte_eal_tailqs_init

│   │

│   └──遍历以全局变量rte_tailq_elem_head为头部的struct rte_tailq_elem结构tailq链表

│         │

│         └──rte_eal_tailq_update

│               │

│               ├──rte_eal_tailq_create:主应用的情况(RTE_PROC_PRIMARY)

│               │   │

│               │   ├──rte_eal_tailq_lookup

│               │   │   │

│               │   │   └──在struct rte_mem_config结构的structrte_tailq_head结构数组中查找

│               │   │

│               │   └──如果没找到,占用struct rte_tailq_head结构数组的一个空位

│               │

│               └──rte_eal_tailq_lookup:从应用的情况(RTE_PROC_SECONDARY)

├──rte_eal_log_init

│   │

│   ├──调用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

│         │

│         └──rte_openlog_stream:按照参数,修改struct rte_logs日志结构的相关参数

├──rte_eal_alarm_init

│   │

│   └──赋值全局的struct rte_intr_handle结构,调用timerfd_create函数创建定时器timer对象

├──rte_eal_timer_init

│   │

│   ├──设定全局变量eal_timer_source为EAL_TIMER_TSC(TSC/HPET)

│   │

│   ├──set_tsc_freq:设置TSC frequency(每秒钟时钟中断的次数)

│   │

│   └──check_tsc_flags

│         │

│         └──解析文件“/proc/cpuinfo”,检查“flags”属性中“constant_tsc”和“nonstop_tsc”是否存在

│                (“constant_tsc”和“nonstop_tsc”都存在,说明TSC计时是可靠的)

├──eal_check_mem_on_local_socket

│   │

│   ├──获取masterlcore对应的numa socket

│   │

│   ├──rte_eal_get_physmem_layout:获取struct rte_memseg结构数组地址

│   │

│   └──遍历struct rte_memseg结构数组,检查特定struct rte_memseg结构是否存在(对应此numa socket,并且长度大于0)

├──eal_plugins_init

│    (EAL的“-d”选项可以指定需要载入的动态链接库)

│   │

│   ├──如果全局变量default_solib_dir所指的Default path of external loadable drivers有效

│   │   │

│   │   └──eal_plugin_add

│   │         │

│   │         ├──malloc一个struct shared_driver结构,拷贝路径名称

│   │         │

│   │         └──将此struct shared_driver结构挂载到List of external loadable drivers中

│   │

│   └──遍历List of external loadable drivers上挂载的所有struct shared_driver结构

│         │

│         ├──如果当前struct shared_driver结构所保存的路径是目录

│         │   │

│         │   └──eal_plugindir_init

│         │         │

│         │         └──对目录中的每个普通文件,执行eal_plugin_add

│         │                (将文件挂载到Listof external loadable drivers的尾部,待接下来的遍历循环进行处理)

│         │

│         └──否则,是共享库的情况

│               │

│               └──调用dlopen打开指定的动态链接库

├──eal_thread_init_master

│   │

│   ├──设置主线程的lcore_id

│   │

│   └──eal_thread_set_affinity

│         │

│         ├──rte_gettid

│         │   │

│         │   └──rte_sys_gettid:获取线程的tid

│         │

│         └──rte_thread_set_affinity

│               │

│               └──设置线程的CPU亲和性,记录numasocket等信息

├──eal_thread_dump_affinity

│   │

│   ├──rte_thread_get_affinity

│   │

│   └──dump当前线程的CPU affinity

├──rte_eal_dev_init

│   │

│   ├──遍历以全局变量devargs_list为头的struct rte_devargs结构链表

│   │    (struct rte_devargs——Structure that stores a device given by the user with its arguments)

│   │   │

│   │   ├──跳过physical device

│   │   │

│   │   └──rte_eal_vdev_init

│   │         │

│   │         └──遍历以全局变量dev_driver_list为头的struct rte_driver结构链表

│   │               │

│   │               ├──跳过physicaldevicedriver

│   │               │

│   │               └──search a driver prefix in virtual device name,如果匹配执行struct rte_driver结构中的init函数

│   │

│   └──遍历以全局变量dev_driver_list为头的struct rte_driver结构链表

│          (进程main函数运行前,通过PMD_REGISTER_DRIVER(xxx)宏定义,内在调用rte_eal_driver_register

│         将各种structrte_driver结构(e.g.rte_ixgbe_driver),插入到此struct rte_driver结构链表中)

│         │

│         ├──跳过virtual devicedriver

│         │

│         └──执行struct rte_driver结构中的init函数

│                (e.g.rte_ixgbe_pmd_init)

│               │

│               └──rte_eth_driver_register:Register an Ethernet [Poll Mode] driver

│                     │

│                     ├──赋值struct eth_driver结构中的PCIdriver字段包含的Device init/uninit function pointer

│                     │

│                     └──rte_eal_pci_register

│                           │

│                           └──将刚赋值的PCIdriver数据结构插入到以全局变量pci_driver_list为头的struct rte_pci_driver结构链表中

├──rte_eal_intr_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 event

│   │         │         │         │

│   │         │         │         ├──如果the read end of the pipe可用,执行read操作,函数返回

│   │         │         │         │    (此时会rebuild thewait list)

│   │         │         │         │

│   │         │         │         ├──遍历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”

├──rte_eal_mp_remote_launch:指示所有子线程启动一个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_wait_lcore

│   │

│   └──rte_eal_wait_lcore:等待所有子线程完成工作

│         │

│         ├──如果子线程处于WAIT状态,直接返回

│         │

│         ├──如果子线程处于RUNNING状态,循环等待

│         │

│         └──将子线程状态从FINISHED改为WAIT

├──rte_eal_pci_probe

│   │

│   ├──rte_eal_devargs_type_count

│   │   │

│   │   └──遍历以全局变量devargs_list为头的struct rte_devargs结构链表,

│   │         计算指定类型(whitelist/blacklist/virtual)的设备数目

│   │

│   └──遍历以全局变量pci_device_list为头的struct rte_pci_device结构链表

│         │

│         ├──pci_devargs_lookup:当前PCI device是否由user在命令行参数中被指定

│         │   │

│         │   └──遍历以全局变量devargs_list为头的struct rte_devargs结构链表

│         │         │

│         │         ├──跳过virtual device

│         │         │

│         │         ├──rte_eal_compare_pci_addr

│         │         │   │

│         │         │   └──比较两个PCI devices的Domain-Bus-Device-Function

│         │         │

│         │         └──如果比较成功,返回此struct rte_devargs结构

│         │

│         ├──如果user在命令行中没有指定任何whitelist设备,执行pci_probe_all_drivers

│         │   │

│         │   └──遍历以全局变量pci_driver_list为头的struct rte_pci_driver结构链表

│         │         │

│         │         ├──rte_eal_pci_probe_one_driver

│         │         │   │

│         │         │   └──遍历当前PCI driver所支持的设备ID列表

│         │         │         │

│         │         │         ├──确认PCI device ID是否在列表中

│         │         │         │    (比较Vendor ID、Device ID、Subsystem vendor ID、Subsystem device ID)

│         │         │         │

│         │         │         ├──如果user在命令行中指定当前设备为blacklist设备,则直接返回1

│         │         │         │

│         │         │         ├──如果PCI driver指定RTE_PCI_DRV_NEED_MAPPING标志(Device needsPCI BAR mapping)

│         │         │         │   │

│         │         │         │   ├──rte_eal_pci_map_device

│         │         │         │   │

│         │         │         │   └──如果map resources不成功,直接返回

│         │         │         │

│         │         │         ├──如果PCI driver指定RTE_PCI_DRV_FORCE_UNBIND标志

│         │         │         │   │

│         │         │         │   ├──pci_unbind_kernel_driver

│         │         │         │   │

│         │         │         │   └──如果unbind current driver不成功,直接返回

│         │         │         │

│         │         │         └──调用PCI driver devinit() function

│         │         │                (e.g.rte_eth_dev_init)

│         │         │               │

│         │         │               ├──rte_eth_dev_create_unique_device_name

│         │         │               │    (Create unique Ethernet device name usingPCI address)

│         │         │               │

│         │         │               ├──rte_eth_dev_allocate

│         │         │               │   │

│         │         │               │   ├──rte_eth_dev_find_free_port

│         │         │               │   │   │

│         │         │               │   │   └──在全局struct rte_eth_dev结构数组rte_eth_devices中查找未使用的空位,返回空位索引

│         │         │               │   │

│         │         │               │   ├──如果struct rte_eth_dev_data结构类型全局指针rte_eth_dev_data为NULL,

│         │         │               │   │   执行rte_eth_dev_data_alloc

│         │         │               │   │   │

│         │         │               │   │   ├──主应用的情况(RTE_PROC_PRIMARY)

│         │         │               │   │   │   │

│         │         │               │   │   │   └──rte_memzone_reserve:reserve名称为“rte_eth_dev_data”的memzone,

│         │         │               │   │   │         存放各个ethernet device对应的struct rte_eth_dev_data结构数据

│         │         │               │   │   │

│         │         │               │   │   ├──从应用的情况(RTE_PROC_SECONDARY)

│         │         │               │   │   │   │

│         │         │               │   │   │   └──rte_memzone_lookup:lookup名称为“rte_eth_dev_data”的memzone

│         │         │               │   │   │

│         │         │               │   │   ├──全局指针rte_eth_dev_data指向memzone所引用的内存

│         │         │               │   │   │

│         │         │               │   │   └──如果是主应用,清空初始化这片struct rte_eth_dev_data结构内存

│         │         │               │   │

│         │         │               │   ├──rte_eth_dev_allocated

│         │         │               │   │   │

│         │         │               │   │   └──查找是否已存在相同名称的ethernet device

│         │         │               │   │

│         │         │               │   └──填写struct rte_eth_dev结构和structrte_eth_dev_data结构的相关字段

│         │         │               │

│         │         │               ├──如果是主应用,按照structrte_eth_dev结构dev_private_size域所指定的

│         │         │               │    Size of device private data(对应PMD Ethernetdriver定义时就会被指定),

│         │         │               │    rte_zmalloc对应大小内存,地址保存在struct rte_eth_dev_data结构的dev_private域

│         │         │               │

│         │         │               ├──TAILQ_INIT:初始化以struct rte_eth_dev结构link_intr_cbs域为链表头的,

│         │         │               │    struct rte_eth_dev_callback结构链表

│         │         │               │

│         │         │               ├──设置设备默认MTU

│         │         │               │

│         │         │               ├──Invoke PMD device initialization function,即struct eth_driver结构的eth_dev_init域所指函数

│         │         │               │     (e.g.eth_ixgbe_dev_init)

│         │         │               │

│         │         │               ├──如果是主应用,free地址保存在struct rte_eth_dev_data结构的dev_private域的内存区

│         │         │               │

│         │         │               └──rte_eth_dev_release_port

│         │         │                     │

│         │         │                     └──释放此struct rte_eth_dev结构在全局数组rte_eth_devices中所占用的位置

│         │         │

│         │         └──如果当前driver与设备不匹配,继续尝试下个driver

│         │

│         └──否则如果user指定当前PCIdevice为whitelist设备,也执行pci_probe_all_drivers

└──rte_eal_mcfg_complete

     │

     └──如果是主应用,将全局内存配置struct rte_mem_config结构的magic成员写成RTE_MAGIC,

           表明主应用EAL初始化完成
 

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页