gfwleak/stellar-stellar-2022
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[PACKET_IO] finish marsio mode

Browse Source
This commit is contained in:
liuwentan
2022-07-28 21:22:44 +08:00
parent 536bf31be1
commit 90b60f637e
11 changed files with 87 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/main.cpp
View File

@@ -27,7 +27,7 @@ void packet_io_loop(struct packet_io_loop_arg *arg)
struct session_event *event;
while(1)
{
int fetch_num = packet_io_rx(arg->dev, arg->thread_id, &rx_pkt, 1);
int fetch_num = packet_io_device_rx(arg->dev, arg->thread_id, &rx_pkt, 1);
if(fetch_num > 0)
{
event = session_manager_commit(rx_pkt);
@@ -38,7 +38,7 @@ void packet_io_loop(struct packet_io_loop_arg *arg)
}
//clean session_manager event queue
packet_io_tx(arg->dev, arg->thread_id, &rx_pkt, 1);
packet_io_device_tx(arg->dev, arg->thread_id, &rx_pkt, 1);
}
else
{
@@ -52,15 +52,15 @@ void packet_io_loop(struct packet_io_loop_arg *arg)
struct packet_io_device *
packet_io_init(const char *instance_name, const enum packet_io_run_mode mode, const int worker_thread_num)
packet_io_init(const char *instance_name, const enum packet_io_run_mode mode, const int wrk_thread_num)
{
struct packet_io_instance *ppio_inst = packet_io_instance_create(instance_name, mode, worker_thread_num);
struct packet_io_instance *ppio_inst = packet_io_instance_create(instance_name, mode, wrk_thread_num);
if (nullptr == ppio_inst) {
log_error(ST_ERR_PIO_INSTANCE, "packet_io instance init failed.");
return nullptr;
}
struct packet_io_device *ppio_dev = packet_io_open_device(ppio_inst, "eth1", worker_thread_num, worker_thread_num);
struct packet_io_device *ppio_dev = packet_io_open_device(ppio_inst, "eth1", wrk_thread_num, wrk_thread_num);
if (nullptr == ppio_dev) {
log_error(ST_ERR_PIO_DEVICE, "packet_io device open failed.");

268
src/packet_io/marsio_mode/marsio.h
View File

@@ -1,268 +0,0 @@
/*
* \brief MARSIO Userspace ZeroCopy Driver Version 4
*
* This is the user api header file of MARSIOv4 ZeroCopy Driver
*
* \author Qiuwen Lu<luqiuwen@iie.ac.cn>
* Institute of Information Engineering, Chinese Academy of Sciences
*
* \date 2016-12-01
*/
#pragma once
typedef enum
{
/* 数据面线程数，没有缺省值 */
MARSIO_OPT_THREAD_NUM,
/* 数据面线程绑定掩码，没有缺省值，设置该掩码后，数据面线程数选项将被忽略。*/
MARSIO_OPT_THREAD_MASK,
/* 线程绑定模式，类型：uint32_t */
MARSIO_OPT_THREAD_AFFINITY_MODE,
/* 处理SIG信号，缺省值：类型：uint32_t，关闭（0）
* 启用该选项后，将自动处理SIGINT、SIGTERM信号
*/
MARSIO_OPT_EXIT_WHEN_ERR,
/* 拓展数据面线程绑定掩码，适应大于64个核处理器的硬件平台
* 设置该掩码后，数据面线程数选项将被忽略
*/
MARSIO_OPT_THREAD_MASK_IN_CPUSET,
} marsio_opt_type_t;
typedef enum
{
/* 发送后不释放数据包，由应用自行释放数据包 */
MARSIO_SEND_OPT_NO_FREE = 1 << 0,
/* 发送时计算发包哈希值，用于分流 */
MARSIO_SEND_OPT_REHASH = 1 << 1,
/* 快速报文路径 */
MARSIO_SEND_OPT_FAST = 1 << 2,
/* 报文追踪标记 */
MARSIO_SEND_OPT_TRACE = 1 << 3,
/* 控制报文标记 */
MARSIO_SEND_OPT_CTRL = 1 << 4
} marsio_opt_send_t;
enum mr_sendpath_type
{
/* 去往特定虚设备的发包路径 */
MR_SENDPATH_VDEV,
/* 路由查表确定发包路径 */
MR_SENDPATH_ROUTE_NORMAL,
/* 特定设备路由查表确定发包路径 */
MR_SENDPATH_ROUTE_SPEC_DEV,
/* MAX标记 */
MR_SENDPATH_MAX
};
enum mr_sendpath_option
{
/* 构建四层报文头 */
MR_SENDPATH_OPT_BUILD_L4 = 0,
/* 构建三层报文头 */
MR_SENDPATH_OPT_BUILD_L3 = 1,
/* 构建二层报文头 */
MR_SENDPATH_OPT_BUILD_L2 = 2,
/* 构建前Hook点回调 */
MR_SENDPATH_OPT_HOOK_PREBUILD = 50,
/* 构建后Hook点回调 */
MR_SENDPATH_OPT_HOOK_POSTBUILD = 51,
};
enum mr_clone_options
{
/* 拷贝区域 */
MR_BUFF_CLONE_DATA = 1 << 0,
MR_BUFF_CLONE_BUFF = 1 << 1,
MR_BUFF_CLONE_CTRLZONE = 1 << 2,
};
enum mr_thread_affinity_mode
{
/* 禁用线程亲和性设置 */
MR_THREAD_AFFINITY_DISABLE = 0,
/* 自动线程亲和性设置 */
MR_THREAD_AFFINITY_AUTO = 1,
/* 自定义线程亲和性设置 */
MR_THREAD_AFFINITY_USER = 255
};
enum mr_timestamp_type
{
/* 从网卡收取时或报文缓冲区申请时的时间戳 */
MR_TIMESTAMP_RX_OR_ALLOC = 0,
};
enum mr_buff_metadata_type
{
/* 分流哈希值，会根据该值计算分流队列 */
MR_BUFF_REHASH_INDEX = 0,
/* 网卡剥离的VLAN标签 */
MR_BUFF_METADATA_VLAN_TCI = 1,
};
#ifdef __cplusplus
extern "C" {
#endif
#include <netinet/in.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#ifndef MARSIO_SOCKET_ID_ANY
#define MARSIO_SOCKET_ID_ANY -1
#endif
#ifndef MARSIO_LCORE_ID_ANY
#define MARSIO_LCORE_ID_ANY -1
#endif
typedef uint32_t device_id_t;
typedef uint32_t port_id_t;
typedef uint32_t queue_id_t;
typedef uint32_t thread_id_t;
typedef void marsio_buff_t;
struct mr_sendpath;
struct mr_instance;
struct mr_vdev;
struct mr_instance * marsio_create();
struct mr_instance * marsio_current();
typedef int (*fn_sendpath_hook_t)(struct mr_sendpath * sendpath, marsio_buff_t * mbuf[], unsigned int nr_mbuf,
void * arg);
int marsio_option_get(struct mr_instance * instance, int opt_type, void * out_opt, size_t out_opt_buffer);
int marsio_option_set(struct mr_instance * instance, marsio_opt_type_t opt_type, void * opt, size_t sz_opt);
int marsio_init(struct mr_instance * instance, const char * appsym);
int marsio_thread_init(struct mr_instance * instance);
int marsio_destory(struct mr_instance * instance);
struct mr_vdev * marsio_open_device(struct mr_instance * instance, const char * devsym, unsigned int nr_rxstream,
unsigned int nr_txstream);
void marsio_close_device(struct mr_vdev * vdev);
struct mr_vdev * marsio_device_lookup(struct mr_instance * instance, const char * devsym);
int marsio_recv_burst(struct mr_vdev * vdev, queue_id_t qid, marsio_buff_t * mbufs[], int nr_mbufs);
int marsio_recv_all_burst(struct mr_instance * instance, queue_id_t qid, marsio_buff_t * mbufs[], int nr_mbufs);
int marsio_send_burst(struct mr_sendpath * sendpath, queue_id_t qid, marsio_buff_t * mbufs[], int nr_mbufs);
int marsio_send_burst_with_options(struct mr_sendpath * sendpath, queue_id_t sid, marsio_buff_t * mbufs[], int nr_mbufs,
uint16_t options);
void marsio_send_burst_flush(struct mr_sendpath * sendpath, queue_id_t sid);
int marsio_udp_header_construct(marsio_buff_t * buff, uint16_t s_port, uint16_t d_port);
int marsio_ipv4_header_construct(marsio_buff_t * buff, uint32_t s_ip, uint32_t d_ip, uint8_t proto);
struct mr_sendpath * marsio_sendpath_create_by_droute(struct mr_vdev * dest_device, struct in_addr addr);
struct mr_sendpath * marsio_sendpath_create_by_route(struct mr_instance * instance, struct in_addr addr);
struct mr_sendpath * marsio_sendpath_create_by_vdev(struct mr_vdev * dest_device);
struct mr_sendpath * marsio_sendpath_create(struct mr_instance * instance, int type, ...);
int marsio_sendpath_option_set(struct mr_instance * instance, struct mr_sendpath * sendpath, int opt, ...);
int marsio_sendpath_option_get(struct mr_instance * instance, struct mr_sendpath * sendpath, int opt, ...);
void marsio_sendpath_destory(struct mr_sendpath * sendpath);
// simply get control zone data ptr.
void * marsio_buff_ctrlzone(marsio_buff_t * m, uint8_t id);
// a safe way to read control zone data.
void * marsio_buff_ctrlzone_data(marsio_buff_t * m, uint8_t id, uint8_t * size);
// a safe way to set control zone data.
void marsio_buff_ctrlzone_set(marsio_buff_t * m, uint8_t id, void * ptr_data, uint8_t size);
void marsio_buff_reset(marsio_buff_t * m);
marsio_buff_t * marsio_buff_getnext_seg(marsio_buff_t * m);
marsio_buff_t * marsio_buff_getnext_pkt(marsio_buff_t * m);
void marsio_buff_append_pkt(marsio_buff_t * head, marsio_buff_t * next);
void marsio_buff_append_seg(marsio_buff_t * head, marsio_buff_t * next);
void marsio_buff_chain_pkt(marsio_buff_t * pkt, marsio_buff_t * next);
uint16_t marsio_buff_headroom(const marsio_buff_t * m);
uint16_t marsio_buff_tailroom(const marsio_buff_t * m);
marsio_buff_t * marsio_buff_getnext_seg(marsio_buff_t * m);
marsio_buff_t * marsio_buff_getnext_pkt(marsio_buff_t * m);
char * marsio_buff_mtod(marsio_buff_t * m);
uint32_t marsio_buff_buflen(marsio_buff_t * m);
uint32_t marsio_buff_datalen(marsio_buff_t * m);
char * marsio_buff_prepend(marsio_buff_t * m, uint16_t len);
char * marsio_buff_append(marsio_buff_t * m, uint16_t len);
char * marsio_buff_adj(marsio_buff_t * m, uint16_t len);
int marsio_buff_trim(marsio_buff_t * m, uint16_t len);
char * marsio_buff_offset_set(marsio_buff_t * m, off_t offset, int is_relative);
off_t marsio_buff_offset_get(marsio_buff_t * m);
/* 支持写时复制的报文修改裁剪函数 */
marsio_buff_t * marsio_buff_prepend_cw(struct mr_instance * instance, marsio_buff_t * m, uint16_t len, void ** ptr_out);
marsio_buff_t * marsio_buff_append_cw(struct mr_instance * instance, marsio_buff_t * m, uint16_t len, void ** ptr_out);
marsio_buff_t * marsio_buff_adj_cw(struct mr_instance * instance, marsio_buff_t * m, uint16_t len, void ** ptr_out);
marsio_buff_t * marsio_buff_trim_cw(struct mr_instance * instance, marsio_buff_t * m, uint16_t len, void ** ptr_out);
uint16_t marsio_buff_headroom(const marsio_buff_t * m);
uint16_t marsio_buff_tailroom(const marsio_buff_t * m);
uint32_t marsio_get_pkt_type(marsio_buff_t * m);
void marsio_pktmbuf_dump(FILE * f, const marsio_buff_t * m, unsigned dump_len);
marsio_buff_t * marsio_buff_clone_deep(struct mr_instance * instance, marsio_buff_t * md, int socket_id, int thread_id);
marsio_buff_t * marsio_buff_clone_with_options(struct mr_instance * instance, marsio_buff_t * md, int socket_id,
int thread_id, uint16_t options);
int marsio_buff_malloc_device(struct mr_vdev * vdev, marsio_buff_t * marsio_buff[], unsigned int nr_mbufs,
int socket_id, int thread_id);
int marsio_buff_malloc_global(struct mr_instance * instance, marsio_buff_t * marsio_buff[], unsigned int nr_mbufs,
int socket_id, int thread_id);
void marsio_buff_free(struct mr_instance * instance, marsio_buff_t * marsio_buff[], unsigned int nr_mbufs,
int socket_id, int thread_id);
int marsio_buff_is_ctrlbuf(marsio_buff_t * m);
void marsio_buff_set_ctrlbuf(marsio_buff_t * m);
marsio_buff_t * marsio_buff_malloc_smartoffload(struct mr_vdev * vdev, const char * pkt, unsigned int pkt_len);
uint64_t marsio_buff_get_timestamp(marsio_buff_t * m);
void marsio_buff_set_timestamp(marsio_buff_t * m, uint64_t timestamp);
int marsio_buff_get_timestamp_ex(marsio_buff_t * m, enum mr_timestamp_type ts_type, struct timespec * ts);
void marsio_buff_set_rehash_index(marsio_buff_t * m, uint32_t hash);
uint32_t marsio_buff_get_rehash_index(marsio_buff_t * m);
int marsio_buff_get_metadata(marsio_buff_t * m, enum mr_buff_metadata_type type, void * data, unsigned int sz_data);
int marsio_buff_set_metadata(marsio_buff_t * m, enum mr_buff_metadata_type type, void * data, unsigned int sz_data);
int marsio_buff_unset_metadata(marsio_buff_t * m, enum mr_buff_metadata_type type);
void * marsio_shared_mem_alloc(struct mr_instance * instance, size_t len);
void marsio_shared_mem_free(struct mr_instance * instance, void * mem);
#ifdef __cplusplus
}
#endif

54
src/packet_io/marsio_mode/pio_marsio.cpp
View File

@@ -18,6 +18,8 @@
#include "../../sdk/include/utils.h"
#include "../../sdk/include/util_errors.h"
#define MARSIO_BURST_PKT_MAX (256)
static struct marsio_dll_function_entries shared_marsio_dll_func_entries;
static void fake_marsio_buff_set_rehash_index(marsio_buff_t *m, uint32_t hash)
@@ -257,32 +259,50 @@ static int pio_get_marsio_dll_function_entries(void)
int pio_marsio_device_open(struct packet_io_device *pdev, const char *dev_name, uint32_t nr_rxq, uint32_t nr_txq)
{
struct mr_instance *mr_inst_handle = pdev->ppio_inst->entity.marsio_inst->mr_inst;
struct mr_vdev *mr_dev_handle = \
struct mr_instance *mr_inst_handle = pdev->ppio_inst->entity.marsio_inst->mr_inst_handle;
pdev->entity.marsio_dev->mr_dev_handle = \
shared_marsio_dll_func_entries.ptr_marsio_open_device(mr_inst_handle, dev_name, nr_rxq, nr_txq);
if (nullptr == pdev->entity.marsio_dev->mr_dev_handle) {
fprintf(stderr,"marsio_open_device:%s error\n", dev_name);
return -1;
}
return 0;
}
int pio_marsio_device_close(const void *init_data)
int pio_marsio_device_close(const struct packet_io_device *pdev)
{
if (nullptr == pdev) {
log_error(ST_ERR_PIO_DEVICE, "invalid pdev pointer so close marsio device failed!");
return -1;
}
shared_marsio_dll_func_entries.ptr_marsio_close_device(pdev->entity.marsio_dev->mr_dev_handle);
return 0;
}
int pio_marsio_device_receive(struct packet_io_device *pdev, uint32_t rxq_id, struct packet *p[], int nr_p)
{
return 0;
return shared_marsio_dll_func_entries.ptr_marsio_recv_burst(pdev->entity.marsio_dev->mr_dev_handle,
rxq_id, (marsio_buff_t **)p, nr_p);
}
int pio_marsio_device_send(struct packet_io_device *pdev, uint32_t txq_id, struct packet *p[], int nr_p)
{
struct mr_sendpath *sendpath = \
shared_marsio_dll_func_entries.ptr_marsio_sendpath_create_by_vdev(pdev->entity.marsio_dev->mr_dev_handle);
if (nullptr == sendpath) {
log_error(ST_ERR_PIO_DEVICE, "device:%s marsio_sendpath_create_by_vdev failed!", pdev->dev_name);
return -1;
}
shared_marsio_dll_func_entries.ptr_marsio_send_burst(sendpath, txq_id, (marsio_buff_t **)p, nr_p);
return 0;
}
static int marsio_instance_init(struct packet_io_instance *pinst, int worker_thread_num)
static int marsio_instance_init(struct packet_io_instance *pinst, int wrk_thread_num)
{
int ret = -1;
ret = pio_get_marsio_dll_function_entries();
@@ -291,21 +311,25 @@ static int marsio_instance_init(struct packet_io_instance *pinst, int worker_thr
return -1;
}
pinst->entity.marsio_inst->mr_inst = shared_marsio_dll_func_entries.ptr_marsio_create();
if (nullptr == pinst->entity.marsio_inst->mr_inst) {
pinst->entity.marsio_inst->mr_inst_handle = shared_marsio_dll_func_entries.ptr_marsio_create();
if (nullptr == pinst->entity.marsio_inst->mr_inst_handle) {
fprintf(stderr,"%s\n","marsio_create error!\n");
return -1;
}
/* TODO: MARSIO_OPT_THREAD_NUM */
shared_marsio_dll_func_entries.ptr_marsio_option_set(pinst->entity.marsio_inst->mr_inst,
MARSIO_OPT_THREAD_NUM,
&worker_thread_num, sizeof(int));
ret = shared_marsio_dll_func_entries.ptr_marsio_option_set(pinst->entity.marsio_inst->mr_inst_handle,
MARSIO_OPT_THREAD_NUM,
&wrk_thread_num, sizeof(int));
if (ret < 0) {
fprintf(stderr,"%s\n","marsio_option_set MARSIO_OPT_THREAD_NUM error!\n");
return -1;
}
/* TODO: MARSIO_OPT_THREAD_MASK_IN_CPUSET */
/* marsio_init */
ret = shared_marsio_dll_func_entries.ptr_marsio_init(pinst->entity.marsio_inst->mr_inst, pinst->inst_name);
ret = shared_marsio_dll_func_entries.ptr_marsio_init(pinst->entity.marsio_inst->mr_inst_handle, pinst->inst_name);
if (ret < 0) {
fprintf(stderr,"%s\n","marsio_init error!\n");
return -1;
@@ -319,10 +343,10 @@ static int marsio_instance_init(struct packet_io_instance *pinst, int worker_thr
*
* @param: pinst(in/out)
*/
int pio_marsio_instance_create(struct packet_io_instance *pinst, int worker_thread_num)
int pio_marsio_instance_create(struct packet_io_instance *pinst, int wrk_thread_num)
{
/* instance init */
int ret = marsio_instance_init(pinst, worker_thread_num);
int ret = marsio_instance_init(pinst, wrk_thread_num);
if (ret < 0) {
log_error(ST_ERR_PIO_INSTANCE, "marsio instance init failed.");
return -1;
@@ -334,4 +358,4 @@ int pio_marsio_instance_create(struct packet_io_instance *pinst, int worker_thre
void pio_marsio_instance_destroy(void)
{
}
}

8
src/packet_io/marsio_mode/pio_marsio.h
View File

@@ -103,11 +103,11 @@ struct marsio_dll_function_entries {
};
struct pio_marsio_instance {
struct mr_instance *mr_inst;
struct mr_instance *mr_inst_handle;
};
struct pio_marsio_device {
struct mr_vdev *mr_dev;
struct mr_vdev *mr_dev_handle;
};
struct pio_marsio_device_context {
@@ -127,12 +127,12 @@ int pio_marsio_device_open(struct packet_io_device *pdev, const char *dev_name,
/*
@brief close pcap_live device
*/
int pio_marsio_device_close(const void *init_data);
int pio_marsio_device_close(const struct packet_io_device *pdev);
int pio_marsio_device_receive(struct packet_io_device *pdev, uint32_t rxq_id, struct packet *p[], int nr_p);
int pio_marsio_device_send(struct packet_io_device *pdev, uint32_t txq_id, struct packet *p[], int nr_p);
int pio_marsio_instance_create(struct packet_io_instance *pinst, int worker_thread_num);
int pio_marsio_instance_create(struct packet_io_instance *pinst, int wrk_thread_num);
void pio_marsio_instance_destroy(void);

14
src/packet_io/packet_io.cpp
View File

@@ -59,7 +59,7 @@ struct pio_instance_operations pio_instance_ops_array[PACKET_IO_RUN_MODE_MAX] =
};
struct packet_io_instance *
packet_io_instance_create(const char *instance_name, const enum packet_io_run_mode mode, const int worker_thread_num)
packet_io_instance_create(const char *instance_name, const enum packet_io_run_mode mode, const int wrk_thread_num)
{
struct packet_io_instance *pio_instance = CALLOC(struct packet_io_instance, 1);
if (nullptr == pio_instance) {
@@ -72,7 +72,7 @@ packet_io_instance_create(const char *instance_name, const enum packet_io_run_mo
pio_instance->mode = mode;
pio_instance->inst_ops = &pio_instance_ops_array[mode];
int ret = pio_instance->inst_ops->create(pio_instance, worker_thread_num);
int ret = pio_instance->inst_ops->create(pio_instance, wrk_thread_num);
if (ret < 0) {
log_error(ST_ERR_PIO_INSTANCE, "packet_io instance create failed.");
return nullptr;
@@ -83,7 +83,7 @@ packet_io_instance_create(const char *instance_name, const enum packet_io_run_mo
void packet_io_instance_destroy(struct packet_io_instance *pinst) {
if (nullptr != pinst) {
if (nullptr != pinst->device_handle) {
if (nullptr != pinst->devices) {
}
}
@@ -106,10 +106,10 @@ packet_io_open_device(struct packet_io_instance *pinst, const char *dev_name, ui
ppio_dev->dev_ops = &pio_device_ops_array[pinst->mode];
/*
ppio_inst->device_handle --> | struct packet_io_device * | struct packet_io_device * | struct packet_io_device * |
ppio_inst->devices --> | struct packet_io_device * | struct packet_io_device * | struct packet_io_device * |
array[0] array[1] array[2]
*/
pinst->device_handle[pinst->dev_cnt++] = ppio_dev;
pinst->devices[pinst->dev_cnt++] = ppio_dev;
int ret = ppio_dev->dev_ops->open(ppio_dev, dev_name, nr_rxq, nr_txq);
if (ret < 0) {
@@ -133,12 +133,12 @@ void packet_io_close_device(struct packet_io_device *pdev)
}
}
int packet_io_rx(struct packet_io_device *pdev, uint32_t rxq_id, struct packet *p[], int nr_p)
int packet_io_device_rx(struct packet_io_device *pdev, uint32_t rxq_id, struct packet *p[], int nr_p)
{
return pdev->dev_ops->recv(pdev, rxq_id, p, nr_p);
}
int packet_io_tx(struct packet_io_device *pdev, uint32_t txq_id, struct packet *p[], int nr_p)
int packet_io_device_tx(struct packet_io_device *pdev, uint32_t txq_id, struct packet *p[], int nr_p)
{
return pdev->dev_ops->send(pdev, txq_id, p, nr_p);
}

25
src/packet_io/packet_io.h
View File

@@ -19,8 +19,13 @@
#include "./pcap_file_mode/pio_pcap_file.h"
#include "./marsio_mode/pio_marsio.h"
/*
note:
1. packet_io_XXX function is supported by packet_io.h
2. pio_XXX function is supported by pio_pcap_live.h/pio_pcap_file.h/pio_marsio.h
*/
struct pio_instance_operations {
int (*create)(struct packet_io_instance *instance, int worker_thread_num);
int (*create)(struct packet_io_instance *instance, int wrk_thread_num);
void (*destroy)(void);
};
@@ -33,7 +38,7 @@ struct packet_io_instance {
enum packet_io_run_mode mode;
/* device handle set in this instance */
struct packet_io_device *device_handle[DEV_MAX_CNT];
struct packet_io_device *devices[DEV_MAX_CNT];
/* device's exactly count */
uint32_t dev_cnt;
@@ -52,7 +57,7 @@ struct packet_io_instance {
struct pio_device_operations {
int (*open)(struct packet_io_device *pinst, const char *dev_name, uint32_t nr_rxq, uint32_t nr_txq);
int (*close)(const void *init_data);
int (*close)(const struct packet_io_device *pdev);
int (*recv)(struct packet_io_device *pdev, uint32_t rxq_id, struct packet *p[], int pkt_cnt);
@@ -79,8 +84,15 @@ struct packet_io_device {
struct packet_io_instance *ppio_inst;
};
/*
@brief create packet_io instance which will manage packet_io device
@param instance_name: packet_io instance name
@param mode: packet_io run mode
@param wrk_thread_num: expected number of packet receiving threads, which will be created by packet_io
*/
struct packet_io_instance *
packet_io_instance_create(const char *instance_name, const enum packet_io_run_mode mode, const int worker_thread_num);
packet_io_instance_create(const char *instance_name, const enum packet_io_run_mode mode, const int wrk_thread_num);
void packet_io_instance_destroy(struct packet_io_instance *pinst);
@@ -89,5 +101,6 @@ packet_io_open_device(struct packet_io_instance *instance, const char *dev_name,
void packet_io_close_device(struct packet_io_device *dev);
int packet_io_rx(struct packet_io_device *dev, uint32_t rx_queue_id, struct packet *p[], int nr_p);
int packet_io_tx(struct packet_io_device *dev, uint32_t rx_queue_id, struct packet *p[], int nr_p);
int packet_io_device_rx(struct packet_io_device *dev, uint32_t rx_queue_id, struct packet *p[], int nr_p);
int packet_io_device_tx(struct packet_io_device *dev, uint32_t rx_queue_id, struct packet *p[], int nr_p);

4
src/packet_io/pcap_file_mode/pio_pcap_file.cpp
View File

@@ -17,7 +17,7 @@ int pio_pcap_file_device_open(struct packet_io_device *pdev, const char *path, u
return 0;
}
int pio_pcap_file_device_close(const void *init_data) {
int pio_pcap_file_device_close(const struct packet_io_device *pdev) {
return 0;
}
@@ -33,7 +33,7 @@ int pio_pcap_file_device_send(struct packet_io_device *pdev, uint32_t txq_id, st
}
int pio_pcap_file_instance_create(struct packet_io_instance *pinst, int worker_thread_num) {
int pio_pcap_file_instance_create(struct packet_io_instance *pinst, int wrk_thread_num) {
return 0;
}

4
src/packet_io/pcap_file_mode/pio_pcap_file.h
View File

@@ -39,12 +39,12 @@ int pio_pcap_file_device_open(struct packet_io_device *pdev, const char *path, u
/*
@brief close pcap_live device
*/
int pio_pcap_file_device_close(const void *init_data);
int pio_pcap_file_device_close(const struct packet_io_device *pdev);
int pio_pcap_file_device_receive(struct packet_io_device *pdev, uint32_t rxq_id, struct packet *p[], int nr_p);
int pio_pcap_file_device_send(struct packet_io_device *pdev, uint32_t txq_id, struct packet *p[], int nr_p);
int pio_pcap_file_instance_create(struct packet_io_instance *pinst, int worker_thread_num);
int pio_pcap_file_instance_create(struct packet_io_instance *pinst, int wrk_thread_num);
void pio_pcap_file_instance_destroy(void);

4
src/packet_io/pcap_live_mode/pio_pcap_live.cpp
View File

@@ -15,7 +15,7 @@ int pio_pcap_live_device_open(struct packet_io_device *pdev, const char *dev_nam
return 0;
}
int pio_pcap_live_device_close(const void *init_data) {
int pio_pcap_live_device_close(const struct packet_io_device *pdev) {
return 0;
}
@@ -30,7 +30,7 @@ int pio_pcap_live_device_send(struct packet_io_device *pdev, uint32_t txq_id, st
return 0;
}
int pio_pcap_live_instance_create(struct packet_io_instance *pinst, int worker_thread_num) {
int pio_pcap_live_instance_create(struct packet_io_instance *pinst, int wrk_thread_num) {
return 0;
}

4
src/packet_io/pcap_live_mode/pio_pcap_live.h
View File

@@ -37,12 +37,12 @@ int pio_pcap_live_device_open(struct packet_io_device *pdev, const char *dev_nam
/*
@brief close pcap_live device
*/
int pio_pcap_live_device_close(const void *init_data);
int pio_pcap_live_device_close(const struct packet_io_device *pdev);
int pio_pcap_live_device_receive(struct packet_io_device *pdev, uint32_t rxq_id, struct packet *p[], int nr_p);
int pio_pcap_live_device_send(struct packet_io_device *pdev, uint32_t txq_id, struct packet *p[], int nr_p);
int pio_pcap_live_instance_create(struct packet_io_instance *pinst, int worker_thread_num);
int pio_pcap_live_instance_create(struct packet_io_instance *pinst, int wrk_thread_num);
void pio_pcap_live_instance_destroy(void);