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

0
src/packet_io/marsio_mode/marsio.h → sdk/include/marsio.h
View File

6
sdk/include/packet.h
View File

@@ -1,4 +1,8 @@
#pragma once
struct packet;
#include "marsio.h"
struct packet {
marsio_buff_t *rx_buf;
};

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.");

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);