path: root/stack/src/device.c

/* 简单数据通信用户态协议栈——设备管理器
*  
*  本模块提供协议栈使用的设备管理功能。负责管理真实（或虚拟）设备之：
*  A. IP地址、子网掩码、默认网关等网络层信息；
*  B. MTU、VLAN等数据链路层信息。
*  
* \author Lu Qiuwen<[email protected]>
* \date 2016-10-18
*/

#include <sys/queue.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <rte_ether.h>
#include <mr_rtdev.h>
#include <rte_malloc.h>

#include <sk_stack.h>
#include <sk_device.h>
#include <assert.h>

struct sk_dev_info * sk_device_lookup(struct sk_instance * instance, const char * symbol)
{
	struct sk_dev_info * dev_info_iter;
	TAILQ_FOREACH(dev_info_iter, &instance->dev_info_list, next)
	{
		if (strcmp(dev_info_iter->symbol, symbol) == 0)
			return dev_info_iter;
	}

	return NULL;
}

struct sk_dev_desc * sk_device_desc_lookup(struct sk_app_instance* app_instance, const char * symbol)
{
	struct sk_dev_desc * dev_desc_iter;
	TAILQ_FOREACH(dev_desc_iter, &app_instance->dev_desc_list, next)
	{
		if (strcmp(dev_desc_iter->dev_info->symbol, symbol) == 0)
			return dev_desc_iter;
	}

	return NULL;
}

int sk_device_iterate(struct sk_instance * instance, struct sk_dev_info ** dev_info)
{
	// 迭代器为空，从头开始迭代，否则查找迭代器下一个对象
	if(*dev_info == NULL)
	{
		*dev_info = TAILQ_FIRST(&instance->dev_info_list);
		return 0;
	}
	else
	{
		*dev_info = TAILQ_NEXT(*dev_info, next);
	}

	// 迭代到尾部，返回错误码
	if (*dev_info == NULL) return -ENOENT;
	return 0;
}


static void __rte_unused sk_dev_desc_delete(struct sk_dev_desc * dev_desc)
{
	// 释放RX侧自循环缓冲区
	for (int i = 0; i < RTE_DIM(dev_desc->rx_loop_buffer); i++)
	{
		if (dev_desc->rx_loop_buffer[i] != NULL)
			rte_ring_free(dev_desc->rx_loop_buffer[i]);
	}

	// 释放TX侧自循环缓冲区
	for (int i = 0; i < RTE_DIM(dev_desc->tx_loop_buffer); i++)
	{
		if (dev_desc->tx_loop_buffer[i] != NULL)
			rte_ring_free(dev_desc->tx_loop_buffer[i]);
	}

	rte_free(dev_desc);
	return;
}

static int __sk_device_create_loop_buffer(const char * prefix, const char * devsym, 
	unsigned int nr_stream, unsigned int sz_tunnel, struct rte_ring * object[])
{
	for (int i = 0; i < nr_stream; i++)
	{
		char str_loop_buffer[MR_SYMBOL_MAX];
		snprintf(str_loop_buffer, sizeof(str_loop_buffer), "%s-%s-%d", prefix, devsym, i);

		object[i] = rte_ring_create(str_loop_buffer, sz_tunnel, SOCKET_ID_ANY, 
			RING_F_SC_DEQ | RING_F_SP_ENQ);

		if (object[i] == NULL)
		{
			MR_LOG(WARNING, STACK, "Create loop buffer for sk-dev %s(sym=%s, size=%d) failed. : %s\n", 
				devsym, str_loop_buffer, sz_tunnel, __str_errno());
			goto err_out;
		}
	}
	
	return 0;

err_out:
	for (int i = 0; i < nr_stream; i++)	if (object[i] != NULL) rte_ring_free(object[i]);
	return -1;
}


// 创建一个协议栈设备
int sk_device_create(struct sk_instance* instance, struct sk_dev_param* param)
{
	// 检查设备是否已经存在，不允许重复创建
	struct sk_dev_info * dev_info = sk_device_lookup(instance, param->symbol);
	if(dev_info != NULL)
	{
		MR_LOG(INFO, STACK, "StackCreateDevice, StackDevice %s has been created. failed. \n",
			param->symbol);
		goto err_out;
	}

	// 申请Info结构体的空间
	dev_info = rte_zmalloc(NULL, sizeof(struct sk_dev_info), 0);
	if(unlikely(dev_info == NULL))
	{
		MR_LOG(WARNING, STACK, "StackCreateDevice, Cannot alloc memory for device info.\n");
		goto err_out;
	}

	snprintf(dev_info->symbol, sizeof(dev_info->symbol), "%s", param->symbol);
	dev_info->param = *param;
	dev_info->instance_ = instance;
	dev_info->in_addr = param->in_addr;
	dev_info->in_mask = param->in_mask;
	dev_info->in_gateway = param->in_gateway;
	dev_info->mac_addr = param->mac_addr;
	dev_info->mtu = param->mtu;
	dev_info->promisc = 0;

	int ret = route_tbl_insert(instance->default_route, dev_info->in_addr, 
		dev_info->in_mask, dev_info);

	if (unlikely(ret < 0)) goto err_out;

	// 设置默认网关，默认网关只能有一个。若以前设置过，此处不生效
	if (dev_info->in_gateway.s_addr != 0 && 
		route_tbl_get_default_hop(instance->default_route) != NULL)
	{
		MR_LOG(WARNING, STACK, "Duplicated default gateway setting, "
		"not available(see at device %s setting)\n", dev_info->symbol);
	}
	
	if (dev_info->in_gateway.s_addr != 0 &&
		route_tbl_get_default_hop(instance->default_route) == NULL)
	{
		route_tbl_set_default_hop(instance->default_route, dev_info);
	}
		
	char str_in_addr[INET_ADDRSTRLEN];
	char str_in_mask[INET_ADDRSTRLEN];
	inet_ntop(AF_INET, &dev_info->in_addr, str_in_addr, sizeof(str_in_addr));
	inet_ntop(AF_INET, &dev_info->in_mask, str_in_mask, sizeof(str_in_mask));
	MR_LOG(NOTICE, STACK, "Stack device %s(in_addr=%s, in_mask=%s) created. \n",
		dev_info->symbol, str_in_addr, str_in_mask);

	TAILQ_INSERT_TAIL(&instance->dev_info_list, dev_info, next);
	return 0;
	
err_out:
	MR_LOG(ERR, STACK, "Sk-device %s create failed. \n", dev_info->symbol);
	if (dev_info) rte_free(dev_info);
	return ret;
}

// 打开一个协议栈设备
struct sk_dev_desc * sk_device_open(struct sk_app_instance * app_instance, 
	struct sk_dev_open_param * open_param)
{
	struct sk_instance * instance = app_instance->instance;
	struct sk_param * instance_param = &instance->param;

	struct sk_dev_info * dev_info = sk_device_lookup(instance, open_param->symbol);

	if (unlikely(dev_info == NULL))
	{
		MR_LOG(ERR, STACK, "Stack Device %s does not existed. failed. \n",
			open_param->symbol);
		return NULL;
	}

	struct sk_dev_desc * dev_desc = rte_zmalloc(NULL, sizeof(struct sk_dev_desc), 0);
	if (unlikely(dev_desc == NULL))
	{
		MR_LOG(WARNING, STACK, "Cannot alloc memory for sk-dev %s desc. Failed. \n",
			dev_info->symbol);
		goto err_out;
	}

	dev_desc->dev_info = dev_info;
	dev_desc->direct_pool = dev_info->param.direct_pktmbuf_pool;
	dev_desc->indirect_pool = dev_info->param.indirect_pktmbuf_pool;
	dev_desc->app_instance_ = app_instance;
	assert(dev_desc->direct_pool != NULL && dev_desc->indirect_pool != NULL);

	int ret = 0;

	if(open_param->nr_loop_rxstream)
	{
		ret = __sk_device_create_loop_buffer("skd-rx", dev_info->symbol, 
			open_param->nr_loop_rxstream, instance_param->sz_loop_ring, dev_desc->rx_loop_buffer);
		if (ret < 0) goto err_out;
	}

	if(open_param->nr_loop_txstream)
	{
		ret = __sk_device_create_loop_buffer("skd-tx", dev_info->symbol, 
			open_param->nr_loop_txstream, instance_param->sz_loop_ring, dev_desc->tx_loop_buffer);
		if (ret < 0) goto err_out;
	}
	
	TAILQ_INSERT_TAIL(&app_instance->dev_desc_list, dev_desc, next);
	MR_LOG(ERR, STACK, "Sk-device %s opened. \n", dev_info->symbol);
	return dev_desc;

err_out:
	MR_LOG(ERR, STACK, "Sk-device %s open failed. \n", dev_info->symbol);
	if (dev_desc != NULL) rte_free(dev_desc);
	return NULL;
}

int sk_device_attach(struct sk_dev_desc * dev_desc, enum sk_dev_sid_type type,
	thread_id_t * out_sid)
{
	rte_spinlock_lock(&dev_desc->sid_alloc_lock);
	int ret = -1;
	for(int i = 0; i < dev_desc->nr_sid[type]; i++)
	{
		if (dev_desc->sid_alloc_record[type][i]) continue;
		dev_desc->sid_alloc_record[type][i] = 1;
		*out_sid = i;
		ret = 0; break;
	}
	rte_spinlock_lock(&dev_desc->sid_alloc_lock);
	return ret;
}

void sk_device_deattach(struct sk_dev_desc * dev_desc, enum sk_dev_sid_type type,
	thread_id_t sid)
{
	rte_spinlock_lock(&dev_desc->sid_alloc_lock);
	dev_desc->sid_alloc_record[type][sid] = 0;
	rte_spinlock_lock(&dev_desc->sid_alloc_lock);
}

struct rte_mempool * sk_device_direct_pktmbuf_pool(struct sk_dev_desc * dev_desc)
{
	return dev_desc->direct_pool;
}

struct rte_mempool * sk_device_indirect_pktmbuf_pool(struct sk_dev_desc * dev_desc)
{
	return dev_desc->indirect_pool;
}

// 销毁协议栈设备
int sk_device_destory(struct sk_dev_info * devinfo)
{
	assert(0);
	return 0;
}

// 设置协议栈的IP地址
int sk_device_set_inaddr(struct sk_dev_info * dev_info, struct in_addr in_addr,
	struct in_addr in_mask)
{
	dev_info->in_addr = in_addr;
	dev_info->in_mask = in_mask;
	return 0;
}

// 读取协议栈设备的IP地址
int sk_device_get_inaddr(struct sk_dev_info * devinfo, 
	struct in_addr * in_addr, struct in_addr * in_mask)
{
	*in_addr = devinfo->in_addr;
	*in_mask = devinfo->in_mask;
	return 0;
}

// 设置协议栈设备的MTU
int sk_device_set_mtu(struct sk_dev_info * devinfo, unsigned int mtu)
{
	devinfo->mtu = mtu;
	return 0;
}

// 读取协议栈设备的MTU
int sk_device_get_mtu(struct sk_dev_info * devinfo)
{
	return devinfo->mtu;
}

// 启动设备
int sk_device_enable(struct sk_dev_info * devinfo)
{
	return 0;
}

// 禁用设备
int sk_device_disable(struct sk_dev_info * devinfo)
{
	return 0;
}