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