引入mr_buffer，对core库的接口进行改动。

12 files changed, 233 insertions, 175 deletions

diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt
index 288f41e..249f3bb 100644
--- a/core/CMakeLists.txt
+++ b/core/CMakeLists.txt
@@ -6,7 +6,7 @@ include_directories(${DPDK_INCLUDE_DIR})
 

 add_definitions(${DPDK_C_PREDEFINED})

 include_directories(include)

-add_library(core src/core.c src/device.c src/vnode.c src/stat.c src/rtdev.c)

+add_library(core src/core.c src/buffer.c src/device.c src/vnode.c src/stat.c src/rtdev.c)

 target_link_libraries(core MESA_prof_load_static mruntime)

 target_link_libraries(core rt pthread dl)

 target_include_directories(core INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/include/")
\ No newline at end of file
diff --git a/core/include/mr_buffer.h b/core/include/mr_buffer.h
index 8ad34f7..07bb31c 100644
--- a/core/include/mr_buffer.h
+++ b/core/include/mr_buffer.h
@@ -6,6 +6,7 @@ extern "C" {
 
 #include <stdint.h>
 #include <rte_mempool.h>
+#include <mr_core.h>
 
 struct mrb_pool_t
 {
@@ -15,17 +16,16 @@ struct mrb_pool_t
 	struct rte_mempool ** mr_indirect_pool;
 };
 
-enum MRB_para_type_t
-{
-	MRB_PARA_DATA_SIZE,
-	MRB_PARA_CACHE_SIZE,
-	MRB_PARA_USR_POOL_SIZE,
-};
+struct mrb_pool_t * MRB_pool_handle_create();
+
+int mr_buffer_user_pool_produce(struct mr_core_instance* instance, unsigned int socket_id, unsigned int data_size,
+	unsigned int pool_size, unsigned int cache_size);
+
+int mr_buffer_pool_produce(struct mr_core_instance* instance, unsigned int socket_id, unsigned int data_size,
+	unsigned int pool_size, unsigned int cache_size);
+
+int mr_buffer_ctrlzone_register(struct mr_core_instance* instance, uint8_t id, uint8_t size);
 
-struct mrb_pool_t* MRB_pool_handle_create(void);
-int MRB_set_pool_handle(struct mrb_pool_t *handle, enum MRB_para_type_t type, uint32_t value);
-int MRB_pool_produce(struct mrb_pool_t* handle, unsigned int socket_id, unsigned int pool_size);
-int MRB_ctrlzone_register(struct mrb_pool_t * handle, uint8_t id, uint8_t size);
 
 #ifdef __cplusplus
 }
diff --git a/core/include/mr_device.h b/core/include/mr_device.h
index 42c128a..90679fd 100644
--- a/core/include/mr_device.h
+++ b/core/include/mr_device.h
@@ -12,7 +12,8 @@ extern "C" {
 #include <rte_config.h>
 #include <rte_spinlock.h>
 #include <assert.h>
-	
+#include "mr_core.h"
+
 #ifndef MR_DEVICE_DEFAULT_NR_PKTMBUF
 #define MR_DEVICE_DEFAULT_NR_PKTMBUF	8192
 #endif
@@ -162,11 +163,11 @@ struct mr_devq
 	unsigned int enable;
 };
 
-int mr_device_list(struct mr_dev * devs[], int nr_max_devs, flags_t flags);
+int mr_device_list(struct mr_core_instance* instance, struct mr_dev * devs[], int nr_max_devs, flags_t flags);
 struct mr_device_stat * mr_device_stat_get();
-struct mr_dev * mr_device_open(struct mr_dev_param * param);
-struct mr_dev * mr_device_lookup(const char * devsym);
-int mr_device_list(struct mr_dev * devs[], int nr_max_devs, flags_t flags);
+struct mr_dev * mr_device_open(struct mr_core_instance* instance, struct mr_dev_param * param);
+struct mr_dev * mr_device_lookup(struct mr_core_instance* instance, const char * devsym);
+int mr_device_list(struct mr_core_instance* instance, struct mr_dev * devs[], int nr_max_devs, flags_t flags);
 int mr_device_close(struct mr_dev_q * devq);
 struct mr_dev_q * mr_device_attach(struct mr_dev * dev, enum dev_q_type q_type);
 void mr_device_deattach(struct mr_dev_q * dev_q);
diff --git a/core/src/buffer.c b/core/src/buffer.c
index fe640b7..615bd3d 100644
--- a/core/src/buffer.c
+++ b/core/src/buffer.c
@@ -19,8 +19,9 @@
 #include <rte_common.h>
 #include <marsio_buffer_user_api.h>
 
-
+#ifndef MRB_MAX_CTRLZONE_NUM
 #define	MRB_MAX_CTRLZONE_NUM	16
+#endif
 
 struct mrb_zone_idx_t
 {
@@ -38,13 +39,10 @@ struct mrb_priv_zone_t
 struct whole_mrb_pool_t
 {
 	struct mrb_pool_t external;	//"external" must be the first member of this struct
-	struct rte_mempool * usr_pkt_pool;
-	struct rte_mempool * usr_indirect_pool;
-
-	unsigned int usr_pool_size;
+	struct rte_mempool * user_pkt_pool;
+	struct rte_mempool * user_indirect_pool;
+	
 	unsigned int total_ctrl_zone_size;
-	unsigned int cache_size;
-	unsigned int data_size;
 	uint8_t ctrlzone_num;
 	struct mrb_zone_idx_t ctrlzone[MRB_MAX_CTRLZONE_NUM];
 };
@@ -65,121 +63,137 @@ static void set_element_ctrlzone(__attribute__((unused))struct rte_mempool *mp,
 	return;
 }
 
-struct mrb_pool_t * MRB_pool_handle_create(void)
-{
-	struct mrb_pool_t *handle = rte_zmalloc("mrb_handle", sizeof(struct mrb_pool_t), 0);
-	handle->pool_num = 0;
-	handle->total_ctrl_zone_size = sizeof(struct mrb_priv_zone_t);
-	return handle;
-}
-
-int MRB_set_pool_handle(struct mrb_pool_t *handle, enum MRB_para_type_t type, uint32_t value)
+struct mrb_pool_t * MRB_pool_handle_create()
 {
-	struct whole_mrb_pool_t *_handle = (struct whole_mrb_pool_t *)handle;
+	struct whole_mrb_pool_t *handle = rte_zmalloc(NULL, sizeof(struct whole_mrb_pool_t), 0);
+	MR_CHECK(handle != NULL, "Cannot alloc memory for MRB Pool handle. ");
 
-	switch (type)
-	{
-	case MRB_PARA_DATA_SIZE:
-		_handle->data_size = value;
-		break;
-	case MRB_PARA_USR_POOL_SIZE:
-		_handle->usr_pool_size = value;
-		break;
-	case MRB_PARA_CACHE_SIZE:
-		_handle->cache_size = value;
-		break;
-		
-	default:
-		return -1;
-		break;
-	}
-	return 0;
+	handle->external.pool_num = 0;
+	handle->total_ctrl_zone_size = sizeof(struct mrb_priv_zone_t);
+	return (struct mrb_pool_t *)handle;
 }
 
-int MRB_pool_produce(struct mrb_pool_t* handle, unsigned int socket_id, unsigned int pool_size)
+int mr_buffer_user_pool_produce(struct mr_core_instance* instance, unsigned int socket_id, unsigned int data_size,
+	unsigned int pool_size, unsigned int cache_size)
 {
-	struct whole_mrb_pool_t *_handle = (struct whole_mrb_pool_t *)handle;
+	struct whole_mrb_pool_t *_handle = (struct whole_mrb_pool_t *)instance->mrb_pool_handle;
 	char str_pool_sym[MR_SYMBOL_MAX];
-	int i = _handle->external.pool_num;
-	uint32_t ret;
+	int ret = 0;
 
-	if (_handle->usr_pkt_pool == NULL)
+	unsigned int priv_size = RTE_ALIGN(_handle->total_ctrl_zone_size, RTE_MBUF_PRIV_ALIGN);
+
+	if (_handle->user_pkt_pool == NULL)
 	{
-		snprintf(str_pool_sym, sizeof(str_pool_sym), "mrb_usr_pkt_pool");
-		_handle->usr_pkt_pool = rte_pktmbuf_pool_create(str_pool_sym, _handle->usr_pool_size,
-			_handle->cache_size, _handle->total_ctrl_zone_size, _handle->data_size,	socket_id);
+		snprintf(str_pool_sym, sizeof(str_pool_sym), "mrb_usr_pkt_pool_%d", socket_id);
+		_handle->user_pkt_pool = rte_pktmbuf_pool_create(str_pool_sym, pool_size, cache_size,
+			priv_size, data_size, socket_id);
 	}
 
-	if (_handle->usr_pkt_pool == NULL)
+	if (_handle->user_pkt_pool == NULL)
 	{
 		MR_LOG(WARNING, BASE, "Creating user direct pktmbuf pool(symbol=%s, size=%d, cache=%d, "
-			"ctrlzone=%d, datasize=%d) : failed - %s)", str_pool_sym, _handle->usr_pool_size,
-			_handle->cache_size, _handle->total_ctrl_zone_size, _handle->data_size, __str_errno());
-		return -1;
+			"ctrlzone=%d, datasize=%d) : failed - %s)", str_pool_sym, pool_size, cache_size,
+			priv_size, data_size, __str_errno());
+
+		ret = -1; goto errout;
 	}
 
-	if (_handle->usr_indirect_pool == NULL)
+	if (_handle->user_indirect_pool == NULL)
 	{
 		snprintf(str_pool_sym, sizeof(str_pool_sym), "mrb_usr_indirect_pool");
-		_handle->usr_pkt_pool = rte_pktmbuf_pool_create(str_pool_sym, _handle->usr_pool_size,
-			_handle->cache_size, _handle->total_ctrl_zone_size, _handle->data_size, socket_id);
+		_handle->user_pkt_pool = rte_pktmbuf_pool_create(str_pool_sym, pool_size, cache_size,
+			priv_size, data_size, socket_id);
 	}
 
-	if(_handle->usr_indirect_pool == NULL)
+	if (_handle->user_indirect_pool == NULL)
 	{
 		MR_LOG(WARNING, BASE, "Creating user indrect pktmbuf pool(symbol=%s, size=%d, cache=%d, "
-			"ctrlzone=%d, datasize=%d) : failed - %s)", str_pool_sym, _handle->usr_pool_size,
-			_handle->cache_size, _handle->total_ctrl_zone_size, _handle->data_size, __str_errno());
-		return -1;
+			"ctrlzone=%d, datasize=%d) : failed - %s)", str_pool_sym, pool_size, cache_size,
+			priv_size, data_size, __str_errno());
+
+		ret = -2; goto errout;
 	}
 
-	handle->mr_pkt_pool = (struct rte_mempool **)rte_realloc(handle->mr_pkt_pool, 
+	ret = rte_mempool_obj_iter(_handle->user_pkt_pool, set_element_ctrlzone, _handle);
+	assert(ret == pool_size);
+
+	ret = rte_mempool_obj_iter(_handle->user_indirect_pool, set_element_ctrlzone, _handle);
+	assert(ret == pool_size);
+	
+	return 0;
+
+errout:
+	if (_handle->user_pkt_pool != NULL) rte_mempool_free(_handle->user_pkt_pool);
+	if (_handle->user_indirect_pool != NULL) rte_mempool_free(_handle->user_indirect_pool);
+	return ret;
+}
+
+
+int mr_buffer_pool_produce(struct mr_core_instance* instance, unsigned int socket_id, unsigned int data_size,
+	unsigned int pool_size, unsigned int cache_size)
+{
+	struct whole_mrb_pool_t *_handle = (struct whole_mrb_pool_t *)instance->mrb_pool_handle;
+	struct mrb_pool_t * handle = instance->mrb_pool_handle;
+
+	char str_pool_sym[MR_SYMBOL_MAX];
+	int ret = 0;
+
+	unsigned int priv_size = RTE_ALIGN(_handle->total_ctrl_zone_size, RTE_MBUF_PRIV_ALIGN);
+	int i = _handle->external.pool_num;
+
+	handle->mr_pkt_pool = (struct rte_mempool **)rte_realloc(handle->mr_pkt_pool,
 		sizeof(struct rte_mempool*)*(i + 1), 0);
 
 	handle->mr_indirect_pool = (struct rte_mempool **)rte_realloc(handle->mr_indirect_pool,
 		sizeof(struct rte_mempool*)*(i + 1), 0);
 
 	snprintf(str_pool_sym, sizeof(str_pool_sym), "mrb_pkt_pool_%d", i);
-	handle->mr_pkt_pool[i] = rte_pktmbuf_pool_create(str_pool_sym, pool_size,_handle->cache_size,
-		_handle->total_ctrl_zone_size, _handle->data_size, socket_id);
+	handle->mr_pkt_pool[i] = rte_pktmbuf_pool_create(str_pool_sym, pool_size, cache_size,
+		priv_size, data_size, socket_id);
 
-	if(handle->mr_pkt_pool[i] == NULL)
+	if (handle->mr_pkt_pool[i] == NULL)
 	{
 		MR_LOG(WARNING, BASE, "Creating dataplane pktmbuf pool(symbol=%s, size=%d, cache=%d, "
-			"ctrlzone=%d, datasize=%d) : failed - %s)", str_pool_sym, pool_size, _handle->cache_size,
-			_handle->total_ctrl_zone_size, _handle->data_size, __str_errno());
+			"ctrlzone=%d, datasize=%d) : failed - %s)\n", str_pool_sym, pool_size, cache_size,
+			priv_size, data_size, __str_errno());
 		return -3;
 	}
-	
+
 	ret = rte_mempool_obj_iter(handle->mr_pkt_pool[i], set_element_ctrlzone, _handle);
-	assert(ret == _handle->usr_pool_size);
-	
+	assert(ret == pool_size);
+
+	MR_LOG(DEBUG, BASE, "Creating dataplane pktmbuf pool(symbol=%s, size=%d, cache=%d, "
+		"ctrlzone=%d, datasize=%d) : Success\n", str_pool_sym, pool_size, cache_size,
+		priv_size, data_size);
+
 	snprintf(str_pool_sym, sizeof(str_pool_sym), "mrb_indirect_pool_%d", i);
-	handle->mr_indirect_pool[i] = rte_pktmbuf_pool_create(str_pool_sym, pool_size,
-		_handle->cache_size, _handle->total_ctrl_zone_size, 0, socket_id);
-	
+	handle->mr_indirect_pool[i] = rte_pktmbuf_pool_create(str_pool_sym, pool_size, cache_size,
+		priv_size, 0, socket_id);
+
 	if (handle->mr_indirect_pool[i] == NULL)
 	{
 		MR_LOG(WARNING, BASE, "Creating dataplane indirect pktmbuf pool(symbol=%s, size=%d, cache=%d, "
-			"ctrlzone=%d, datasize=%d) : failed - %s)", str_pool_sym, pool_size, _handle->cache_size,
-			_handle->total_ctrl_zone_size, _handle->data_size, __str_errno());
+			"ctrlzone=%d, datasize=%d) : failed - %s)", str_pool_sym, pool_size, cache_size,
+			priv_size, 0, __str_errno());
 		return -4;
 	}
-	
-	ret = rte_mempool_obj_iter(handle->mr_indirect_pool[i], set_element_ctrlzone, _handle);
-	assert(ret == _handle->usr_pool_size);
 
+	ret = rte_mempool_obj_iter(handle->mr_indirect_pool[i], set_element_ctrlzone, _handle);
+	assert(ret == pool_size);
 	handle->pool_num++;
+
+	MR_LOG(DEBUG, BASE, "Creating dataplane indirect pktmbuf pool(symbol=%s, size=%d, cache=%d, "
+		"ctrlzone=%d, datasize=%d) : Success\n", str_pool_sym, pool_size, cache_size,
+		priv_size, data_size);
+	
 	return i;
 }
 
-int MRB_ctrlzone_register(struct mrb_pool_t * handle, uint8_t id, uint8_t size)
+int mr_buffer_ctrlzone_register(struct mr_core_instance* instance, uint8_t id, uint8_t size)
 {
-	struct whole_mrb_pool_t *_handle = (struct whole_mrb_pool_t *)handle;
-	int i = 0;
-	_handle->ctrlzone_num++;
+	struct whole_mrb_pool_t *_handle = (struct whole_mrb_pool_t *)instance->mrb_pool_handle;
 
-	if (_handle->ctrlzone_num <= MRB_MAX_CTRLZONE_NUM)
+	if (_handle->ctrlzone_num >= MRB_MAX_CTRLZONE_NUM)
 	{
 		return -1;
 	}
@@ -192,17 +206,18 @@ int MRB_ctrlzone_register(struct mrb_pool_t * handle, uint8_t id, uint8_t size)
 	_handle->ctrlzone[id].size = size;
 	_handle->ctrlzone[id].offset = _handle->total_ctrl_zone_size;
 	_handle->total_ctrl_zone_size += (size + sizeof(struct mrb_zone_idx_t));
+	_handle->ctrlzone_num++;
+
 	return 0;
 }
 
-void *marsio_buff_ctrlzone(marsio_buff_t *mr_buff, uint8_t id)
+void * marsio_buff_ctrlzone(marsio_buff_t *mr_buff, uint8_t id)
 {
-	struct mrb_zone_idx_t* cz = mrbuf_cz(mr_buff, id);
 	assert(id < mrbuf_cz_num(mr_buff));
 	return mrbuf_cz_data(mr_buff, id);
 }
 
-void *marsio_buff_ctrlzone_data(marsio_buff_t *mr_buff, uint8_t id, uint8_t *size)
+void * marsio_buff_ctrlzone_data(marsio_buff_t *mr_buff, uint8_t id, uint8_t *size)
 {
 	struct mrb_zone_idx_t* cz = mrbuf_cz(mr_buff, id);
 	assert(id < mrbuf_cz_num(mr_buff));
@@ -219,39 +234,36 @@ void marsio_buff_ctrlzone_set(marsio_buff_t *mr_buff, uint8_t id, void* ptr_data
 	return;
 }
 
-int marsio_buff_malloc(marsio_buff_t *marsio_buff[], unsigned int nb_buff, 
+int marsio_buff_malloc(marsio_buff_t *marsio_buff[], unsigned int nb_buff,
 	__attribute__((unused))unsigned int flags,
 	__attribute__((unused))int thread_seq)
 {
-	struct mr_core_instance *this_core = NULL;
-	struct whole_mrb_pool_t *_handle = NULL;
-	int i = 0;
+	struct mr_core_instance * this_core = NULL;
+	struct whole_mrb_pool_t * _handle = NULL;
 
 	this_core = mr_core_default_instance_get();
 	_handle = (struct whole_mrb_pool_t *)this_core->mrb_pool_handle;
-	for (i = 0; i < nb_buff; i++)
+	
+	for (int i = 0; i < nb_buff; i++)
 	{
-		marsio_buff[i] = rte_pktmbuf_alloc(_handle->usr_pkt_pool);
-		if (marsio_buff[i] == NULL)
-		{
-			break;
-		}
+		marsio_buff[i] = rte_pktmbuf_alloc(_handle->user_pkt_pool);
+		if (marsio_buff[i] == NULL)	return i;
 	}
 
-	return i;
+	return nb_buff;
 }
+
 void marsio_buff_free(marsio_buff_t *marsio_buff[], unsigned int nb_buff)
 {
-	int i = 0;
-	for (i = 0; i < nb_buff; i++)
+	for (int i = 0; i < nb_buff; i++)
 	{
 		mrbuf_priv(marsio_buff[i])->next = NULL;
 		rte_pktmbuf_free((struct rte_mbuf *)marsio_buff[i]);
 	}
+
 	return;
 }
 
-
 void marsio_buff_append_pkt(marsio_buff_t *previous, marsio_buff_t *next)
 {
 	mrbuf_priv(previous)->next = next;
@@ -339,7 +351,6 @@ uint32_t marsio_get_pkt_type(marsio_buff_t *m)
 
 marsio_buff_t *marsio_buff_dup(marsio_buff_t *m)
 {
-	mr_process_ctx_t *proc_ctx;
-	rte_mbuf_refcnt_update((struct rte_mbuf *)m, 1);
-	return m;
+	assert(0);
+	return NULL;
 }
\ No newline at end of file
diff --git a/core/src/core.c b/core/src/core.c
index 9bca28c..20e7dde 100644
--- a/core/src/core.c
+++ b/core/src/core.c
@@ -9,6 +9,7 @@
 #include <mr_runtime.h>
 #include <rte_ip_frag.h>
 #include <mr_core.h>
+#include "mr_buffer.h"
 
 // �ⲿ�����������豸������
 extern int devman_init(struct mr_core_instance * core_instance);
@@ -50,6 +51,11 @@ struct mr_core_instance * mr_core_instance_create(struct mr_core_config* config)
 
 	ret = stat_init(instance);
 	MR_CHECK(ret >= 0, "Failed at CoreStat Preinit stage.");
+
+	struct mrb_pool_t * pool = MRB_pool_handle_create();
+	MR_CHECK(pool != NULL, "Failed at MRB Pool create. ");
+
+	instance->mrb_pool_handle = pool;
 	return instance;
 }
 
diff --git a/core/src/device.c b/core/src/device.c
index c22a181..eca3aef 100644
--- a/core/src/device.c
+++ b/core/src/device.c
@@ -16,6 +16,7 @@
 #include <mr_common.h>
 #include <mr_device.h>
 #include <mr_core.h>
+#include "mr_buffer.h"
 
 #ifndef MR_DEVICE_DEFAULT_NR_RX_DESC
 #define MR_DEVICE_DEFAULT_NR_RX_DESC	128
@@ -273,48 +274,32 @@ static int device_usrset_queue(struct mr_dev * dev, unsigned int * out_rxq,
 }
 
 
-static int device_init(struct devman_ctx * ctx, struct mr_dev * dev)
+static int device_init(struct mr_core_instance* instance, 
+	struct devman_ctx * ctx, struct mr_dev * dev)
 {
 	int retval = 0;
 	socket_id_t socket_id = rte_eth_dev_socket_id(dev->port_id);
-
-	// 创建内存池
-	char str_direct_pool[MR_SYMBOL_MAX];
-	snprintf(str_direct_pool, sizeof(str_direct_pool), "%s-direct", dev->symbol);
-	
-	char str_indirect_pool[MR_SYMBOL_MAX];
-	snprintf(str_indirect_pool, sizeof(str_indirect_pool), "%s-indirect", dev->symbol);
-	
-	struct rte_mempool * direct_pool;
-	direct_pool = rte_pktmbuf_pool_create(str_direct_pool, dev->param.nr_direct_pktmbuf,
-		dev->param.nr_pktmbuf_cache, 128, dev->param.sz_pktmbuf, socket_id);
 	
-	if(direct_pool == NULL)
+	struct rte_mempool * direct_pool = NULL;
+	struct rte_mempool * indirect_pool = NULL;
+
+	int pool_id = mr_buffer_pool_produce(instance, SOCKET_ID_ANY, dev->param.sz_pktmbuf,
+	                               dev->param.nr_direct_pktmbuf, dev->param.nr_pktmbuf_cache);
+	if(pool_id < 0)
 	{
-		MR_LOG(ERR, BASE, "DeviceInit : Cannot create pktmbuf pool(symbol=%s, "
-			"n=%d, cache=%d, size=%d): %s\n", str_direct_pool, dev->param.nr_direct_pktmbuf,
+		MR_LOG(ERR, BASE, "DeviceInit : Cannot create pktmbuf pool(device=%s, "
+			"n=%d, cache=%d, size=%d): %s\n", dev->symbol, dev->param.nr_direct_pktmbuf,
 			dev->param.nr_pktmbuf_cache, dev->param.sz_pktmbuf, __str_errno());
 		return -1;
 	}
 
-	MR_LOG(INFO, BASE, "mempool %s(nr=%d, cache=%d, priv=%d, dataroom=%d) created. \n",
-		str_direct_pool, dev->param.nr_direct_pktmbuf, dev->param.nr_pktmbuf_cache, 128, dev->param.sz_pktmbuf);
+	direct_pool = instance->mrb_pool_handle->mr_pkt_pool[pool_id];
+	indirect_pool = instance->mrb_pool_handle->mr_indirect_pool[pool_id];
+	
+	assert(direct_pool != NULL && indirect_pool != NULL);
+	MR_LOG(INFO, BASE, "device %s pktmbuf pool(nr=%d, cache=%d, dataroom=%d) created. \n",
+		dev->symbol, dev->param.nr_direct_pktmbuf, dev->param.nr_pktmbuf_cache, dev->param.sz_pktmbuf);
 	
-	struct rte_mempool * indirect_pool;
-	indirect_pool = rte_pktmbuf_pool_create(str_indirect_pool, dev->param.nr_indirect_pktmbuf,
-		dev->param.nr_pktmbuf_cache, 0, 0, socket_id);
-
-	if(indirect_pool == NULL)
-	{
-		MR_LOG(ERR, BASE, "DeviceInit : Cannot create indirect pktmbuf pool(symbol=%s, "
-			"n=%d, cache=%d): %s\n", str_indirect_pool, dev->param.nr_indirect_pktmbuf,
-			dev->param.nr_pktmbuf_cache, __str_errno());
-		return -2;
-	}
-
-	MR_LOG(INFO, BASE, "mempool %s(nr=%d, cache=%d, priv=%d, dataroom=%d) created. \n",
-		str_indirect_pool, dev->param.nr_indirect_pktmbuf, dev->param.nr_pktmbuf_cache, 0, 0);
-
 	dev->direct_pool = direct_pool;
 	dev->indirect_pool = indirect_pool;
 	
@@ -423,7 +408,8 @@ static struct mr_dev * device_lookup(struct devman_ctx * ctx, const char * devsy
 	return dev_ret;
 }
 
-static struct mr_dev * device_open(struct devman_ctx * ctx, struct mr_dev_param * param)
+static struct mr_dev * device_open(struct mr_core_instance* instance, 
+	struct devman_ctx * ctx, struct mr_dev_param * param)
 {
 	struct mr_dev * dev = device_lookup(ctx, param->symbol);
 
@@ -434,7 +420,7 @@ static struct mr_dev * device_open(struct devman_ctx * ctx, struct mr_dev_param
 	}
 
 	dev->param = *param;
-	int ret = device_init(ctx, dev);
+	int ret = device_init(instance, ctx, dev);
 
 	if (ret < 0)
 	{
@@ -445,25 +431,19 @@ static struct mr_dev * device_open(struct devman_ctx * ctx, struct mr_dev_param
 	return dev;
 }
 
-struct mr_dev * mr_device_open(struct mr_dev_param * param)
+struct mr_dev * mr_device_open(struct mr_core_instance* instance, struct mr_dev_param * param)
 {
-	struct devman_ctx * module_ctx;
-	module_ctx = mr_core_default_instance_get()->devman_ctx;
-	return device_open(module_ctx, param);
+	return device_open(instance, instance->devman_ctx, param);
 }
 
-struct mr_dev * mr_device_lookup(const char * devsym)
+struct mr_dev * mr_device_lookup(struct mr_core_instance* instance, const char * devsym)
 {
-	struct devman_ctx * module_ctx;
-	module_ctx = mr_core_default_instance_get()->devman_ctx;
-	return device_lookup(module_ctx, devsym);
+	return device_lookup(instance->devman_ctx, devsym);
 }
 
-int mr_device_list(struct mr_dev * devs[], int nr_max_devs, flags_t flags)
+int mr_device_list(struct mr_core_instance* instance, struct mr_dev * devs[], int nr_max_devs, flags_t flags)
 {
-	struct devman_ctx * module_ctx;
-	module_ctx = mr_core_default_instance_get()->devman_ctx;
-	return __device_list(module_ctx, devs, nr_max_devs, flags);
+	return __device_list(instance->devman_ctx, devs, nr_max_devs, flags);
 }
 
 struct mr_dev_q * mr_device_attach(struct mr_dev * dev, enum dev_q_type q_type)
diff --git a/include/marsio_buffer_user_api.h b/include/marsio_buffer_user_api.h
index 6041a98..bb677ca 100644
--- a/include/marsio_buffer_user_api.h
+++ b/include/marsio_buffer_user_api.h
@@ -27,15 +27,6 @@ void marsio_buff_ctrlzone_set(marsio_buff_t *m,uint8_t id,void* ptr_data,uint8_t
 
 void marsio_buff_reset(marsio_buff_t *m);
 
-uint32_t marsio_buff_buflen(marsio_buff_t *m);
-uint32_t marsio_buff_datalen(marsio_buff_t *m);
-void *marsio_buff_mtod(marsio_buff_t *m);
-
-void *marsio_buff_prepend(marsio_buff_t *m, uint16_t len);  
-void *marsio_buff_append(marsio_buff_t *m, uint16_t len);
-void *marsio_buff_adj(marsio_buff_t *m, uint16_t len);
-void *marsio_buff_trim(marsio_buff_t *m, uint16_t len);
-
 marsio_buff_t *marsio_buff_getnext_seg(marsio_buff_t *m);
 marsio_buff_t *marsio_buff_getnext_pkt(marsio_buff_t *m);
 
@@ -45,15 +36,35 @@ void marsio_buff_append_seg(marsio_buff_t *previous, marsio_buff_t *next);
 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_buff_append_pkt(marsio_buff_t *previous, marsio_buff_t *next);
+void marsio_buff_append_seg(marsio_buff_t *previous, marsio_buff_t *next);
 
-marsio_buff_t *marsio_buff_dup(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_pkt_len(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);
 
-marsio_buff_t *marsio_buff_getnext(marsio_buff_t *m);
+int marsio_buff_trim(marsio_buff_t *m, uint16_t len);
 
-#ifdef __cplusplusW
+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);
+
+marsio_buff_t *marsio_buff_dup(marsio_buff_t *m);
+
+#ifdef __cplusplus
 }
 #endif
 
diff --git a/service/src/register.c b/service/src/register.c
index 2405e1e..7572204 100644
--- a/service/src/register.c
+++ b/service/src/register.c
@@ -40,6 +40,11 @@ static int sc_core_instance_register(struct sc_instance * instance)
 	return 0;
 }
 
+static int sc_core_ctrlzone_register(struct sc_instance * instance)
+{
+	return 0;
+}
+
 static int sc_stack_instance_register(struct sc_instance * instance)
 {
 	// 获取全局配置句柄和全局运行时句柄
@@ -69,7 +74,8 @@ static int __mr_dev_register(struct sc_instance * instance,
 		sc_dev->mr_dev_param.nr_rss_txq = sc_param->nr_serv_thread;
 
 	// 打开设备
-	struct mr_dev * dev = mr_device_open(&sc_dev->mr_dev_param);
+	struct mr_dev * dev = mr_device_open(instance->core_instance, 
+		&sc_dev->mr_dev_param);
 
 	// 失败
 	if (unlikely(dev == NULL))
@@ -134,7 +140,7 @@ static int __sk_dev_register(struct sc_instance * instance,
 	}
 
 	// 从真实设备中，填充MAC地址等信息
-	struct mr_dev * dev = mr_device_lookup(sc_dev->mr_dev_param.symbol);
+	struct mr_dev * dev = mr_device_lookup(instance->core_instance, sc_dev->mr_dev_param.symbol);
 	assert(dev != NULL);
 
 	sc_dev->sk_dev_param.mtu = dev->mtu;
diff --git a/stack/include/sk_stack.h b/stack/include/sk_stack.h
index 4b3b19b..ff09bcc 100644
--- a/stack/include/sk_stack.h
+++ b/stack/include/sk_stack.h
@@ -2,6 +2,7 @@
 #include <sk_device.h>
 #include <sk_neigh.h>
 #include <sk_route.h>
+#include <port_bitmap.h>
 
 #ifndef MR_STACK_DEFAULT_SZ_DELIVER_RING
 #define MR_STACK_DEFAULT_SZ_DELIVER_RING	1024
@@ -64,6 +65,17 @@ struct sk_instance
 	rte_atomic16_t ip_counter;
 };
 
+struct sk_ucb;
+TAILQ_HEAD(sk_ucb_list, sk_ucb);
+
+struct sk_stack_udp_ctx
+{
+	rte_rwlock_t rwlock;
+	struct portmap local_in_use;
+	struct sk_ucb * ucbs[MAX_PORT_NUM];
+	struct sk_ucb_list ucb_list;
+};
+
 struct sk_app_instance
 {	
 	// Ӧ������
@@ -72,6 +84,8 @@ struct sk_app_instance
 	struct sk_instance * instance;
 	// Э��ջ�豸���
 	struct sk_dev_desc_list dev_desc_list;
+	// UDP����ʱ�����Ļ���
+	struct sk_stack_udp_ctx udp_ctx;
 };
 
 struct sk_instance * sk_instance_create(struct mr_core_instance * core_instance, struct sk_param * param);
@@ -81,5 +95,5 @@ struct sk_app_instance * sk_app_instance_create(struct sk_instance * instance, c
 int sk_serv_device_rx_bulk(struct sk_dev_desc * dev_desc, thread_id_t sid,
 	struct rte_mbuf * mbufs_in[], int nr_mbufs_in);
 
-int sk_serv_device_tx_bulk(struct sk_dev_desc * dev_desc, thread_id_t sid,

+int sk_serv_device_tx_bulk(struct sk_dev_desc * dev_desc, thread_id_t sid,
 	struct rte_mbuf * mbufs_out[], int nr_mbufs_max);
\ No newline at end of file
diff --git a/stack/src/stack.c b/stack/src/stack.c
index 86f7560..fae19cb 100644
--- a/stack/src/stack.c
+++ b/stack/src/stack.c
@@ -65,6 +65,11 @@ errout:
 	return NULL;
 }
 
+#define LPORT_START			0x8000
+#define LPORT_END			MAX_PORT_NUM
+#define LPORT_START_BLK		PORT_BLK(LPORT_START)
+#define LPORT_END_BLCK		PORT_BLK(LPORT_END)
+
 struct sk_app_instance * sk_app_instance_create(struct sk_instance * instance, const char* appsym)
 {
 	struct sk_app_instance * app_instance;
@@ -76,8 +81,15 @@ struct sk_app_instance * sk_app_instance_create(struct sk_instance * instance, c
 		return NULL;
 	}
 
+	// 初始化内部句柄
 	app_instance->instance = instance;
 	snprintf(app_instance->appsym, sizeof(app_instance->appsym), "%s", appsym);
 	TAILQ_INIT(&app_instance->dev_desc_list);
+
+	// 初始化UDP CTX
+	rte_rwlock_init(&app_instance->udp_ctx.rwlock);
+	portmap_init(&app_instance->udp_ctx.local_in_use, LPORT_START_BLK);
+	TAILQ_INIT(&app_instance->udp_ctx.ucb_list);
+	
 	return app_instance;
 }
\ No newline at end of file
diff --git a/stack/src/ucb.c b/stack/src/ucb.c
new file mode 100644
index 0000000..7980408
--- /dev/null
+++ b/stack/src/ucb.c
@@ -0,0 +1,17 @@
+/* \brief MARSIO UDP控制与流表结构
+ * \author Qiuwen Lu<[email protected]>
+ * \date 2016-11-29
+ */
+
+/* UDP控制块，每个UDP控制块代表一个UDP流 */
+#include <port_bitmap.h>
+#include <sk_stack.h>
+
+struct sk_ucb
+{
+	TAILQ_ENTRY(sk_ucb) next;
+	struct sk_app_instance * app_instance_;
+
+
+
+};
\ No newline at end of file
diff --git a/tools/stat/dev_stat.c b/tools/stat/dev_stat.c
index b9ff0b1..e55b369 100644
--- a/tools/stat/dev_stat.c
+++ b/tools/stat/dev_stat.c
@@ -184,7 +184,7 @@ int main(int argc,char *argv[])
 {
 	mr_lib_init();
 	mr_dev_t * device_list[MR_DEVICE_MAX];
-	int device_list_count=mr_device_list(device_list,MR_DEVICE_MAX,0);
+	int device_list_count=mr_device_list(, device_list,MR_DEVICE_MAX), 0;
 	struct dev_stat_statics *g_dev_stat_statics=dev_stat_init(device_list,device_list_count);
 	while(1)
 	{