int edpnet_sock_create(edpnet_sock_t *sock, edpnet_sock_cbs_t *cbs, void *data){
edpnet_data_t *ed = &__edpnet_data;
struct edpnet_sock *s;
int ret;
if(!ed->ed_init){
log_warn("ednet not inited!\n");
return -1;
}
s = mheap_alloc(sizeof(*s));
if(s == NULL){
log_warn("no enough memory!\n");
return -ENOMEM;
}
memset(s, 0, sizeof(*s));
ret = emit_create(s, &s->es_emit);
if(ret !=0 ){
log_warn("create emit fail:%d\n", ret);
return ret;
}
emit_add_handler(s->es_emit, kEDPNET_SOCK_EPOLLOUT, edpnet_sock_epollout_handler);
emit_add_handler(s->es_emit, kEDPNET_SOCK_EPOLLIN, edpnet_sock_epollin_handler);
emit_add_handler(s->es_emit, kEDPNET_SOCK_EPOLLERR, edpnet_sock_epollerr_handler);
emit_add_handler(s->es_emit, kEDPNET_SOCK_EPOLLHUP, edpnet_sock_epollhup_handler);
s->es_sock = socket(PF_INET, SOCK_STREAM, 0);
if(s->es_sock < 0){
log_warn("init sock failure!\n");
emit_destroy(s->es_emit);
mheap_free(s);
return -1;
}
ret = sock_init(s);
if(ret != 0){
log_warn("initialize sock failure!\n");
emit_destroy(s->es_emit);
mheap_free(s);
return ret;
}
edpnet_sock_set(s, cbs, data);
*sock = s;
return 0;
}
int edpnet_serv_create(edpnet_serv_t *serv, edpnet_serv_cbs_t *cbs, void *data){
struct edpnet_serv *s;
ASSERT((serv != NULL) && (cbs != NULL));
s = mheap_alloc(sizeof(*s));
if(s == NULL){
log_warn("no enough memory for serv!\n");
return -ENOMEM;
}
memset(s, 0, sizeof(*s));
INIT_LIST_HEAD(&s->es_node);
INIT_LIST_HEAD(&s->es_socks);
s->es_cbs = cbs;
s->es_data = data;
s->es_sock = socket(PF_INET, SOCK_STREAM, 0);
if(s->es_sock < 0){
log_warn("init sock failure!\n");
mheap_free(s);
return -1;
}
if(set_nonblock(s->es_sock) < 0){
close(s->es_sock);
mheap_free(s);
return -1;
}
spi_spin_init(&s->es_lock);
if(eio_addfd(s->es_sock, serv_worker_cb, s) != 0){
log_warn("watch serv handle fail!\n");
spi_spin_fini(&s->es_lock);
close(s->es_sock);
mheap_free(s);
return -1;
}
s->es_status = kEDPNET_SERV_STATUS_INIT;
*serv = s;
return 0;
}
void
ssvm_delete_private (ssvm_private_t * ssvm)
{
vec_free (ssvm->name);
#if USE_DLMALLOC == 0
mheap_free (ssvm->sh->heap);
#else
destroy_mspace (ssvm->sh->heap);
#endif
clib_mem_free (ssvm->sh);
}
int mcache_destroy(mcache_t mc){
struct mem_cache *m = mc;
ASSERT(m != NULL);
if(m->mc_allocs != m->mc_frees){
return -EINVAL;
}
mheap_free(m);
return 0;
}
int edpnet_sock_destroy(edpnet_sock_t sock){
edpnet_data_t *ed = &__edpnet_data;
struct edpnet_sock *s = sock;
if(!ed->ed_init){
log_warn("ednet not inited!\n");
return -1;
}
s->es_status = kEDPNET_SOCK_STATUS_ZERO;
sock_fini(sock);
close(s->es_sock);
emit_destroy(s->es_emit);
mheap_free(s);
return 0;
}
int edpnet_serv_destroy(edpnet_serv_t serv){
struct edpnet_serv *s = serv;
ASSERT(s != NULL);
eio_delfd(s->es_sock);
spi_spin_lock(&s->es_lock);
s->es_status = kEDPNET_SERV_STATUS_ZERO;
spi_spin_unlock(&s->es_lock);
close(s->es_sock);
spi_spin_fini(&s->es_lock);
mheap_free(s);
return 0;
}
int emit_destroy(emit_t em){
struct edp_emit *ee = em;
ASSERT(ee != NULL);
if(ee->ee_pendings != 0){
log_warn("edpu still have pending events!\n");
return -EINVAL;
}
ee->ee_init = 0;
spi_spin_lock(&__emit_data.ed_lock);
list_del(&ee->ee_node);
spi_spin_unlock(&__emit_data.ed_lock);
spi_spin_fini(&ee->ee_lock);
mheap_free(ee);
return 0;
}
static void serv_worker_cb(uint32_t events, void *data){
struct edpnet_serv *s = (struct edpnet_serv *)data;
struct edpnet_sock *sock;
ASSERT(s != NULL);
if(events & EPOLLIN){
sock = mheap_alloc(sizeof(*sock));
if(sock == NULL){
log_warn("no memory for sock!\n");
return ;
}
memset(sock, 0, sizeof(*sock));
sock->es_sock = accept(s->es_sock, NULL, NULL);
if(sock->es_sock < 0){
log_warn("accept client fail!\n");
return ;
}
if(sock_init(sock) < 0){
sock_fini(sock);
mheap_free(sock);
}else{
s->es_cbs->connected(s, sock, s->es_data);
}
}
if(events & EPOLLOUT){
ASSERT(0);
}
if(events & (EPOLLERR | EPOLLHUP)){
s->es_cbs->close(s, s->es_data);
}
}
int
test_mheap_main (unformat_input_t * input)
{
int i, j, k, n_iterations;
void *h, *h_mem;
uword *objects = 0;
u32 objects_used, really_verbose, n_objects, max_object_size;
u32 check_mask, seed, trace, use_vm;
u32 print_every = 0;
u32 *data;
mheap_t *mh;
/* Validation flags. */
check_mask = 0;
#define CHECK_VALIDITY 1
#define CHECK_DATA 2
#define CHECK_ALIGN 4
#define TEST1 8
n_iterations = 10;
seed = 0;
max_object_size = 100;
n_objects = 1000;
trace = 0;
really_verbose = 0;
use_vm = 0;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (0 == unformat (input, "iter %d", &n_iterations)
&& 0 == unformat (input, "count %d", &n_objects)
&& 0 == unformat (input, "size %d", &max_object_size)
&& 0 == unformat (input, "seed %d", &seed)
&& 0 == unformat (input, "print %d", &print_every)
&& 0 == unformat (input, "validdata %|",
&check_mask, CHECK_DATA | CHECK_VALIDITY)
&& 0 == unformat (input, "valid %|",
&check_mask, CHECK_VALIDITY)
&& 0 == unformat (input, "verbose %=", &really_verbose, 1)
&& 0 == unformat (input, "trace %=", &trace, 1)
&& 0 == unformat (input, "vm %=", &use_vm, 1)
&& 0 == unformat (input, "align %|", &check_mask, CHECK_ALIGN)
&& 0 == unformat (input, "test1 %|", &check_mask, TEST1))
{
clib_warning ("unknown input `%U'", format_unformat_error, input);
return 1;
}
}
/* Zero seed means use default. */
if (!seed)
seed = random_default_seed ();
if (check_mask & TEST1)
{
return test1 ();
}
if_verbose
("testing %d iterations, %d %saligned objects, max. size %d, seed %d",
n_iterations, n_objects, (check_mask & CHECK_ALIGN) ? "randomly " : "un",
max_object_size, seed);
vec_resize (objects, n_objects);
if (vec_bytes (objects) > 0) /* stupid warning be gone */
clib_memset (objects, ~0, vec_bytes (objects));
objects_used = 0;
/* Allocate initial heap. */
{
uword size =
max_pow2 (2 * n_objects * max_object_size * sizeof (data[0]));
h_mem = clib_mem_alloc (size);
if (!h_mem)
return 0;
h = mheap_alloc (h_mem, size);
}
if (trace)
mheap_trace (h, trace);
mh = mheap_header (h);
if (use_vm)
mh->flags &= ~MHEAP_FLAG_DISABLE_VM;
else
mh->flags |= MHEAP_FLAG_DISABLE_VM;
if (check_mask & CHECK_VALIDITY)
mh->flags |= MHEAP_FLAG_VALIDATE;
for (i = 0; i < n_iterations; i++)
{
while (1)
{
j = random_u32 (&seed) % vec_len (objects);
if (objects[j] != ~0 || i + objects_used < n_iterations)
break;
}
if (objects[j] != ~0)
{
mheap_put (h, objects[j]);
objects_used--;
objects[j] = ~0;
}
else
{
uword size, align, align_offset;
size = (random_u32 (&seed) % max_object_size) * sizeof (data[0]);
align = align_offset = 0;
if (check_mask & CHECK_ALIGN)
{
align = 1 << (random_u32 (&seed) % 10);
align_offset = round_pow2 (random_u32 (&seed) & (align - 1),
sizeof (u32));
}
h = mheap_get_aligned (h, size, align, align_offset, &objects[j]);
if (align > 0)
ASSERT (0 == ((objects[j] + align_offset) & (align - 1)));
ASSERT (objects[j] != ~0);
objects_used++;
/* Set newly allocated object with test data. */
if (check_mask & CHECK_DATA)
{
uword len;
data = (void *) h + objects[j];
len = mheap_len (h, data);
ASSERT (size <= mheap_data_bytes (h, objects[j]));
data[0] = len;
for (k = 1; k < len; k++)
data[k] = objects[j] + k;
}
}
/* Verify that all used objects have correct test data. */
if (check_mask & 2)
{
for (j = 0; j < vec_len (objects); j++)
if (objects[j] != ~0)
{
u32 *data = h + objects[j];
uword len = data[0];
for (k = 1; k < len; k++)
ASSERT (data[k] == objects[j] + k);
}
}
if (print_every != 0 && i > 0 && (i % print_every) == 0)
fformat (stderr, "iteration %d: %U\n", i, format_mheap, h,
really_verbose);
}
if (verbose)
fformat (stderr, "%U\n", format_mheap, h, really_verbose);
mheap_free (h);
clib_mem_free (h_mem);
vec_free (objects);
return 0;
}
