// Create a new kernel event container
BSP_DECLARE(BSP_EVENT_CONTAINER *) bsp_new_event_container()
{
BSP_EVENT_CONTAINER *ec = bsp_calloc(1, sizeof(BSP_EVENT_CONTAINER));
if (!ec)
{
bsp_trace_message(BSP_TRACE_EMERGENCY, _tag_, "Create event container failed");
return NULL;
}
int epoll_fd = epoll_create(_BSP_MAX_EVENTS);
if (0 > epoll_fd)
{
switch (errno)
{
case ENFILE :
bsp_trace_message(BSP_TRACE_CRITICAL, _tag_, "Cannot open another file descriptor");
break;
case ENOMEM :
bsp_trace_message(BSP_TRACE_EMERGENCY, _tag_, "Kernel memory full");
break;
case EINVAL :
default :
bsp_trace_message(BSP_TRACE_ERROR, _tag_, "Cannot create event container");
break;
}
bsp_free(ec);
return NULL;
}
struct epoll_event *list = bsp_calloc(_BSP_MAX_EVENTS, sizeof(struct epoll_event));
if (!list)
{
bsp_free(ec);
return NULL;
}
ec->epoll_fd = epoll_fd;
ec->event_list = list;
bsp_trace_message(BSP_TRACE_INFORMATIONAL, _tag_, "Create new event container %d with Epoll", epoll_fd);
// Create event fd
#ifdef EFD_NONBLOCK
ec->notify_fd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
#else
ec->notify_fd = eventfd(0, 0);
bsp_set_blocking(ec->notify_fd, BSP_FD_NONBLOCK);
#endif
BSP_EVENT ev;
ev.data.fd = ec->notify_fd;
ev.data.fd_type = BSP_FD_EVENT;
ev.data.associate.buff = 0;
ev.events = BSP_EVENT_EVENT;
bsp_add_event(ec, &ev);
bsp_trace_message(BSP_TRACE_DEBUG, _tag_, "Create notification event of container %d", epoll_fd);
return ec;
}
// New IPv6 table
BSP_IPV6_LIST * new_ipv6_list()
{
BSP_IPV6_LIST *ret = bsp_calloc(1, sizeof(BSP_IPV6_LIST));
if (!ret)
{
trace_msg(TRACE_LEVEL_ERROR, "IpList : Create IP list error");
return NULL;
}
return ret;
}
static int _get_new_node(struct word_filter_t *flt)
{
if (!flt)
{
return -1;
}
bsp_spin_lock(&flt->node_lock);
int ret = flt->node_used, i;
int block_id = ret / BLOCK_NODE_SIZE;
struct hash_tree_node_t **tmp;
while (block_id >= flt->node_list_size)
{
int nlen = (flt->node_list_size) ? flt->node_list_size * 2 : BLOCK_LIST_INITIAL;
tmp = bsp_realloc(flt->node_list, nlen * sizeof(struct hash_tree_node_t *));
if (tmp)
{
for (i = flt->node_list_size; i < nlen; i ++)
{
tmp[i] = NULL;
}
flt->node_list = tmp;
flt->node_list_size = nlen;
}
else
{
bsp_spin_unlock(&flt->node_lock);
return -1;
}
}
// If block
if (!flt->node_list[block_id])
{
struct hash_tree_node_t *block = bsp_calloc(BLOCK_NODE_SIZE, sizeof(struct hash_tree_node_t));
if (block)
{
flt->node_list[block_id] = block;
}
else
{
bsp_spin_unlock(&flt->node_lock);
return -1;
}
}
flt->node_used ++;
bsp_spin_unlock(&flt->node_lock);
return ret;
}
static struct bspd_server_t * _parse_conf_server(BSP_OBJECT *desc)
{
if (!desc || BSP_OBJECT_HASH != desc->type)
{
return NULL;
}
struct bspd_server_t *ret = bsp_calloc(1, sizeof(struct bspd_server_t));
if (!ret)
{
return NULL;
}
ret->inet_type = BSP_INET_ANY;
ret->sock_type = BSP_SOCK_ANY;
ret->addr = NULL;
ret->port = 0;
ret->prop.type = BSPD_SERVER_NORMAL;
ret->prop.data_type = BSPD_DATA_RAW;
BSP_STRING *str = NULL;
BSP_VALUE *node = NULL;
node = bsp_object_value_hash_original(desc, "name");
if (node)
{
str = V_GET_STRING(node);
if (str)
{
ret->name = bsp_strndup(STR_STR(str), STR_LEN(str));
}
}
// Inet
node = bsp_object_value_hash_original(desc, "inet");
if (node)
{
str = V_GET_STRING(node);
if (str)
{
if (0 == strncasecmp(STR_STR(str), "ipv4", 4))
{
ret->inet_type = BSP_INET_IPV4;
}
else if (0 == strncasecmp(STR_STR(str), "ipv6", 4))
{
ret->inet_type = BSP_INET_IPV6;
}
else if (0 == strncasecmp(STR_STR(str), "local", 5))
{
ret->inet_type = BSP_INET_LOCAL;
}
}
}
// Sock
node = bsp_object_value_hash_original(desc, "sock");
if (node)
{
str = V_GET_STRING(node);
if (str)
{
if (0 == strncasecmp(STR_STR(str), "tcp", 3))
{
ret->sock_type = BSP_SOCK_TCP;
}
else if (0 == strncasecmp(STR_STR(str), "udp", 3))
{
ret->sock_type = BSP_SOCK_UDP;
}
else if (0 == strncasecmp(STR_STR(str), "sctp", 4))
{
ret->sock_type = BSP_SOCK_SCTP;
}
}
}
// Addr
node = bsp_object_value_hash_original(desc, "addr");
if (node)
{
str = V_GET_STRING(node);
if (str)
{
ret->addr = bsp_strndup(STR_STR(str), STR_LEN(str));
}
}
// Port
node = bsp_object_value_hash_original(desc, "port");
if (node)
{
ret->port = (uint16_t) V_GET_INT(node);
}
// Type
node = bsp_object_value_hash_original(desc, "type");
if (node)
{
str = V_GET_STRING(node);
if (str)
{
if (0 == strncasecmp(STR_STR(str), "internal", 8))
{
ret->prop.type = BSPD_SERVER_INTERNAL;
}
else if (0 == strncasecmp(STR_STR(str), "normal", 6))
{
ret->prop.type = BSPD_SERVER_NORMAL;
}
else if (0 == strncasecmp(STR_STR(str), "http", 0))
{
ret->prop.type = BSPD_SERVER_HTTP;
}
else if (0 == strncasecmp(STR_STR(str), "websocket", 9))
{
ret->prop.type = BSPD_SERVER_WEBSOCKET;
}
else
{
// Unsupported
}
}
}
// Data type
node = bsp_object_value_hash_original(desc, "data_type");
if (node)
{
str = V_GET_STRING(node);
if (str)
{
if (0 == strncasecmp(STR_STR(str), "packet", 6))
{
ret->prop.data_type = BSPD_DATA_PACKET;
}
}
}
// LUA hooks
node = bsp_object_value_hash_original(desc, "lua_hook_connect");
if (node)
{
str = V_GET_STRING(node);
if (str)
{
ret->prop.lua_hook_connect = bsp_strndup(STR_STR(str), STR_LEN(str));
}
}
node = bsp_object_value_hash_original(desc, "lua_hook_disconnect");
if (node)
{
str = V_GET_STRING(node);
if (str)
{
ret->prop.lua_hook_connect = bsp_strndup(STR_STR(str), STR_LEN(str));
}
}
node = bsp_object_value_hash_original(desc, "lua_hook_data");
if (node)
{
str = V_GET_STRING(node);
if (str)
{
ret->prop.lua_hook_data = bsp_strndup(STR_STR(str), STR_LEN(str));
}
}
return ret;
}
#include "bsp_abort.h"
#include "bsp_memreg.h"
#include "bsp_alloc.h"
/** Initializes a MemoryRegister object
@param table Reference to a MemoryRegister object
@param nprocs Number of processors
@param rows Initial number of rows
@param src_proc Rank of the local processor
*/
void
memoryRegister_initialize (ExpandableTable * RESTRICT table, const unsigned int nprocs,
const unsigned int rows, const unsigned int src_proc)
{
union SpecInfo info;
info.reg.removed = bsp_calloc (rows, sizeof (int));
info.reg.numremov = 0;
info.reg.memoized_data_iter = NULL;
info.reg.memoized_end = NULL;
info.reg.memoized_srccol=0;
info.reg.memoized_src_proc = src_proc;
fixedElSizeTable_initialize (table, nprocs, rows, sizeof (MemRegElement), info);
}
/** destructor of MemoryRegister
@param table Reference to a MemoryRegister object
*/
void
memoryRegister_destruct (ExpandableTable * RESTRICT table)
{
bsp_free(table->info.reg.removed);
