/**
* Initialize memfd segment master
*/
int
ssvm_master_init_memfd (ssvm_private_t * memfd)
{
uword page_size;
ssvm_shared_header_t *sh;
void *oldheap;
clib_mem_vm_alloc_t alloc = { 0 };
clib_error_t *err;
if (memfd->ssvm_size == 0)
return SSVM_API_ERROR_NO_SIZE;
ASSERT (vec_c_string_is_terminated (memfd->name));
alloc.name = (char *) memfd->name;
alloc.size = memfd->ssvm_size;
alloc.flags = CLIB_MEM_VM_F_SHARED;
alloc.requested_va = memfd->requested_va;
if ((err = clib_mem_vm_ext_alloc (&alloc)))
{
clib_error_report (err);
return SSVM_API_ERROR_CREATE_FAILURE;
}
memfd->fd = alloc.fd;
memfd->sh = (ssvm_shared_header_t *) alloc.addr;
memfd->my_pid = getpid ();
memfd->i_am_master = 1;
page_size = 1ull << alloc.log2_page_size;
sh = memfd->sh;
sh->master_pid = memfd->my_pid;
sh->ssvm_size = memfd->ssvm_size;
sh->ssvm_va = pointer_to_uword (sh);
sh->type = SSVM_SEGMENT_MEMFD;
#if USE_DLMALLOC == 0
uword flags = MHEAP_FLAG_DISABLE_VM | MHEAP_FLAG_THREAD_SAFE;
sh->heap = mheap_alloc_with_flags (((u8 *) sh) + page_size,
memfd->ssvm_size - page_size, flags);
#else
sh->heap = create_mspace_with_base (((u8 *) sh) + page_size,
memfd->ssvm_size - page_size,
1 /* locked */ );
mspace_disable_expand (sh->heap);
#endif
oldheap = ssvm_push_heap (sh);
sh->name = format (0, "%s", memfd->name, 0);
ssvm_pop_heap (oldheap);
/* The application has to set set sh->ready... */
return 0;
}
int ssvm_eth_create (ssvm_eth_main_t * em, u8 * name, int is_master)
{
// ssvm_eth_main_t * em = &ssvm_eth_main;
ssvm_private_t * intfc;
void * oldheap;
clib_error_t * e;
unix_shared_memory_queue_t * q;
ssvm_shared_header_t * sh;
ssvm_eth_queue_elt_t * elts;
u32 * elt_indices;
u8 enet_addr[6];
int i, rv;
vec_add2 (em->intfcs, intfc, 1);
intfc->ssvm_size = em->segment_size;
intfc->i_am_master = 1;
intfc->name = name;
intfc->my_pid = getpid();
if (is_master == 0)
{
rv = ssvm_slave_init (intfc, 20 /* timeout in seconds */);
if (rv < 0)
return rv;
goto create_vnet_interface;
}
intfc->requested_va = em->next_base_va;
em->next_base_va += em->segment_size;
rv = ssvm_master_init (intfc, intfc - em->intfcs /* master index */);
if (rv < 0)
return rv;
/* OK, segment created, set up queues and so forth. */
sh = intfc->sh;
oldheap = ssvm_push_heap (sh);
q = unix_shared_memory_queue_init (em->queue_elts, sizeof (u32),
0 /* consumer pid not interesting */,
0 /* signal not sent */);
sh->opaque [TO_MASTER_Q_INDEX] = (void *)q;
q = unix_shared_memory_queue_init (em->queue_elts, sizeof (u32),
0 /* consumer pid not interesting */,
0 /* signal not sent */);
sh->opaque [TO_SLAVE_Q_INDEX] = (void *)q;
/*
* Preallocate the requested number of buffer chunks
* There must be a better way to do this, etc.
* Add some slop to avoid pool reallocation, which will not go well
*/
elts = 0;
elt_indices = 0;
vec_validate_aligned (elts, em->nbuffers - 1, CLIB_CACHE_LINE_BYTES);
vec_validate_aligned (elt_indices, em->nbuffers - 1, CLIB_CACHE_LINE_BYTES);
for (i = 0; i < em->nbuffers; i++)
elt_indices[i] = i;
sh->opaque [CHUNK_POOL_INDEX] = (void *) elts;
sh->opaque [CHUNK_POOL_FREELIST_INDEX] = (void *) elt_indices;
sh->opaque [CHUNK_POOL_NFREE] = (void *)(uword) em->nbuffers;
ssvm_pop_heap (oldheap);
create_vnet_interface:
sh = intfc->sh;
memset (enet_addr, 0, sizeof (enet_addr));
enet_addr[0] = 2;
enet_addr[1] = 0xFE;
enet_addr[2] = is_master;
enet_addr[5] = sh->master_index;
/* Let the games begin... */
if (is_master)
sh->ready = 1;
return 0;
}
int
ssvm_master_init_shm (ssvm_private_t * ssvm)
{
int ssvm_fd;
#if USE_DLMALLOC == 0
int mh_flags = MHEAP_FLAG_DISABLE_VM | MHEAP_FLAG_THREAD_SAFE;
#endif
clib_mem_vm_map_t mapa = { 0 };
u8 junk = 0, *ssvm_filename;
ssvm_shared_header_t *sh;
uword page_size, requested_va = 0;
void *oldheap;
if (ssvm->ssvm_size == 0)
return SSVM_API_ERROR_NO_SIZE;
if (CLIB_DEBUG > 1)
clib_warning ("[%d] creating segment '%s'", getpid (), ssvm->name);
ASSERT (vec_c_string_is_terminated (ssvm->name));
ssvm_filename = format (0, "/dev/shm/%s%c", ssvm->name, 0);
unlink ((char *) ssvm_filename);
vec_free (ssvm_filename);
ssvm_fd = shm_open ((char *) ssvm->name, O_RDWR | O_CREAT | O_EXCL, 0777);
if (ssvm_fd < 0)
{
clib_unix_warning ("create segment '%s'", ssvm->name);
return SSVM_API_ERROR_CREATE_FAILURE;
}
if (fchmod (ssvm_fd, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP) < 0)
clib_unix_warning ("ssvm segment chmod");
if (svm_get_root_rp ())
{
/* TODO: is this really needed? */
svm_main_region_t *smr = svm_get_root_rp ()->data_base;
if (fchown (ssvm_fd, smr->uid, smr->gid) < 0)
clib_unix_warning ("ssvm segment chown");
}
if (lseek (ssvm_fd, ssvm->ssvm_size, SEEK_SET) < 0)
{
clib_unix_warning ("lseek");
close (ssvm_fd);
return SSVM_API_ERROR_SET_SIZE;
}
if (write (ssvm_fd, &junk, 1) != 1)
{
clib_unix_warning ("set ssvm size");
close (ssvm_fd);
return SSVM_API_ERROR_SET_SIZE;
}
page_size = clib_mem_get_fd_page_size (ssvm_fd);
if (ssvm->requested_va)
{
requested_va = ssvm->requested_va;
clib_mem_vm_randomize_va (&requested_va, min_log2 (page_size));
}
mapa.requested_va = requested_va;
mapa.size = ssvm->ssvm_size;
mapa.fd = ssvm_fd;
if (clib_mem_vm_ext_map (&mapa))
{
clib_unix_warning ("mmap");
close (ssvm_fd);
return SSVM_API_ERROR_MMAP;
}
close (ssvm_fd);
sh = mapa.addr;
sh->master_pid = ssvm->my_pid;
sh->ssvm_size = ssvm->ssvm_size;
sh->ssvm_va = pointer_to_uword (sh);
sh->type = SSVM_SEGMENT_SHM;
#if USE_DLMALLOC == 0
sh->heap = mheap_alloc_with_flags (((u8 *) sh) + page_size,
ssvm->ssvm_size - page_size, mh_flags);
#else
sh->heap = create_mspace_with_base (((u8 *) sh) + page_size,
ssvm->ssvm_size - page_size,
1 /* locked */ );
mspace_disable_expand (sh->heap);
#endif
oldheap = ssvm_push_heap (sh);
sh->name = format (0, "%s", ssvm->name, 0);
ssvm_pop_heap (oldheap);
ssvm->sh = sh;
ssvm->my_pid = getpid ();
ssvm->i_am_master = 1;
/* The application has to set set sh->ready... */
return 0;
}
