stellar-stellar-2022/src/packet_io/packet_io.h

/*
**********************************************************************************************
*	File: packet_io.h
*   Description: packet io module entry
*	Authors: Liu WenTan <liuwentan@geedgenetworks.com>
*	Date:    2022-07-15
*   Copyright: (c) 2018-2022 Geedge Networks, Inc. All rights reserved.
***********************************************************************************************
*/

#pragma once

#include <stdint.h>
#include <limits.h>
#include <sys/queue.h>

#include "../common/global_var.h"
#include "./pcap_live_mode/pio_pcap_live.h"
#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 *pinst, int wrk_thread_num);

	void (*destroy)(struct packet_io_instance *pinst);
};

struct packet_io_instance {
	/* packet_io instance name */
	char inst_name[NAME_MAX];

	/* packet_io run mode of the instance */
	enum packet_io_run_mode mode;

	/* device handle set in this instance */
	struct packet_io_device *devices[DEV_MAX_CNT];

	/* device's exactly count */
	uint32_t dev_cnt;

	/* instance operations */
	struct pio_instance_operations *inst_ops;

	union 
	{
		struct pio_pcap_file_instance *pcap_file_inst;
		struct pio_pcap_live_instance *pcap_live_inst;
		struct pio_marsio_instance *marsio_inst;
	} entity;
};

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 struct packet_io_device *pdev);

	int (*recv)(struct packet_io_device *pdev, uint32_t rxq_id, struct packet *p[], int pkt_cnt);

	int (*send)(struct packet_io_device *pdev, uint32_t txq_id, struct packet *p[], int pkt_cnt);
};

struct packet_io_device {
	/* device name */
	char dev_name[NAME_MAX];

	/* device operations */
	struct pio_device_operations *dev_ops;

	union {
		struct pio_pcap_file_device *pcap_file_dev;
		struct pio_pcap_live_device *pcap_live_dev;
		struct pio_marsio_device *marsio_dev;
	} entity;

	/* packet io device context */
	void *dev_ctx;

	/* packet_io instance which the device belongs to */
	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 wrk_thread_num);

/* destroy packet_io instance */
void packet_io_instance_destroy(struct packet_io_instance *pinst);

/*
 * @brief open packet_io device for send/receive packets
 *
 * @param pinst:    packet_io instance pointer
 * @param dev_name: packet_io device name
 * @param nr_rxq:   number of receive queue for the device
 * @param nr_txq:   number of send queue for the device
**/
struct packet_io_device *
packet_io_device_open(struct packet_io_instance *pinst, const char *dev_name, uint32_t nr_rxq, uint32_t nr_txq);

/* close packet_io device */
void packet_io_device_close(struct packet_io_device *dev);

/*
 * @brief packet_io device receive function
 *
 * @param pdev:   packet_io device pointer
 * @param rxq_id: which queue will receive from
 * @param p:      received packet's pointer array
 * @param nr_p:   number of received packets
**/
int packet_io_device_rx(struct packet_io_device *pdev, uint32_t rxq_id, struct packet *p[], int nr_p);

/*
 * @brief packet_io device send function
 *
 * @param pdev:   packet_io device pointer
 * @param rxq_id: which queue will send to
 * @param p:      prepare to send packet's pointer array
 * @param nr_p:   number of packets which prepare to send
**/
int packet_io_device_tx(struct packet_io_device *pdev, uint32_t txq_id, struct packet *p[], int nr_p);