/*
- * Copyright (c) 2017 Cisco and/or its affiliates.
+ * Copyright (c) 2017-2019 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
segment_manager_properties_t *
segment_manager_properties_get (segment_manager_t * sm)
{
- return application_get_segment_manager_properties (sm->app_index);
+ app_worker_t *app_wrk = app_worker_get (sm->app_wrk_index);
+ return application_get_segment_manager_properties (app_wrk->app_index);
}
segment_manager_properties_t *
static u8
segment_manager_app_detached (segment_manager_t * sm)
{
- return (sm->app_index == SEGMENT_MANAGER_INVALID_APP_INDEX);
+ return (sm->app_wrk_index == SEGMENT_MANAGER_INVALID_APP_INDEX);
}
void
segment_manager_app_detach (segment_manager_t * sm)
{
- sm->app_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
+ sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
}
always_inline u32
ssvm_delete (&fs->ssvm);
if (CLIB_DEBUG)
- memset (fs, 0xfb, sizeof (*fs));
+ clib_memset (fs, 0xfb, sizeof (*fs));
pool_put (sm->segments, fs);
}
/**
* Removes segment after acquiring writer lock
*/
-always_inline void
+static inline void
segment_manager_lock_and_del_segment (segment_manager_t * sm, u32 fs_index)
{
svm_fifo_segment_private_t *fs;
return pool_elt_at_index (sm->segments, segment_index);
}
+u64
+segment_manager_segment_handle (segment_manager_t * sm,
+ svm_fifo_segment_private_t * segment)
+{
+ u32 segment_index = segment_manager_segment_index (sm, segment);
+ return (((u64) segment_manager_index (sm) << 32) | segment_index);
+}
+
+void
+segment_manager_parse_segment_handle (u64 segment_handle, u32 * sm_index,
+ u32 * segment_index)
+{
+ *sm_index = segment_handle >> 32;
+ *segment_index = segment_handle & 0xFFFFFFFF;
+}
+
+svm_fifo_segment_private_t *
+segment_manager_get_segment_w_handle (u64 segment_handle)
+{
+ u32 sm_index, segment_index;
+ segment_manager_t *sm;
+
+ segment_manager_parse_segment_handle (segment_handle, &sm_index,
+ &segment_index);
+ sm = segment_manager_get (sm_index);
+ if (!sm || pool_is_free_index (sm->segments, segment_index))
+ return 0;
+ return pool_elt_at_index (sm->segments, segment_index);
+}
+
/**
* Reads a segment from the segment manager's pool and acquires reader lock
*
segment_manager_main_t *smm = &segment_manager_main;
u32 rnd_margin = 128 << 10, seg_index, page_size;
segment_manager_properties_t *props;
- uword baseva = (u64) ~ 0, alloc_size;
+ uword baseva = (uword) ~ 0ULL, alloc_size;
svm_fifo_segment_private_t *seg;
u8 *seg_name;
int rv;
{
pool_get (sm->segments, seg);
}
- memset (seg, 0, sizeof (*seg));
+ clib_memset (seg, 0, sizeof (*seg));
/*
* Initialize ssvm segment and svm fifo private header
if (props->segment_type != SSVM_SEGMENT_PRIVATE)
{
seg_name = format (0, "%d-%d%c", getpid (), segment_name_counter++, 0);
- alloc_size = segment_size + rnd_margin;
+ alloc_size = (uword) segment_size + rnd_margin;
baseva = clib_valloc_alloc (&smm->va_allocator, alloc_size, 0);
if (!baseva)
{
segment_manager_main_t *smm = &segment_manager_main;
segment_manager_t *sm;
pool_get (smm->segment_managers, sm);
- memset (sm, 0, sizeof (*sm));
+ clib_memset (sm, 0, sizeof (*sm));
clib_rwlock_init (&sm->segments_rwlock);
return sm;
}
{
u32 rx_fifo_size, tx_fifo_size, pair_size;
u32 rx_rounded_data_size, tx_rounded_data_size;
- u64 approx_total_size, max_seg_size =
- ((u64) 1 << 32) - clib_mem_get_page_size ();
+ u64 approx_total_size, max_seg_size = ((u64) 1 << 32) - (128 << 10);
segment_manager_properties_t *props;
svm_fifo_segment_private_t *segment;
u32 approx_segment_count;
segment = segment_manager_get_segment (sm, seg_index);
if (i == 0)
- sm->event_queue = segment_manager_alloc_queue (segment,
- props->evt_q_size);
+ sm->event_queue = segment_manager_alloc_queue (segment, props);
svm_fifo_segment_preallocate_fifo_pairs (segment,
props->rx_fifo_size,
return seg_index;
}
segment = segment_manager_get_segment (sm, seg_index);
- sm->event_queue = segment_manager_alloc_queue (segment,
- props->evt_q_size);
+ sm->event_queue = segment_manager_alloc_queue (segment, props);
}
return 0;
segment_manager_del_sessions (segment_manager_t * sm)
{
svm_fifo_segment_private_t *fifo_segment;
- stream_session_t *session;
+ session_handle_t *handles = 0, *handle;
+ session_t *session;
svm_fifo_t *fifo;
ASSERT (pool_elts (sm->segments) != 0);
*/
while (fifo)
{
- if (fifo->master_thread_index == 255)
- {
- svm_fifo_t *next = fifo->next;
- application_local_session_disconnect_w_index (sm->app_index,
- fifo->master_session_index);
- fifo = next;
- continue;
- }
- session = session_get (fifo->master_session_index,
- fifo->master_thread_index);
- stream_session_disconnect (session);
+ if (fifo->ct_session_index != SVM_FIFO_INVALID_SESSION_INDEX)
+ session = session_get (fifo->ct_session_index, 0);
+ else
+ session = session_get (fifo->master_session_index,
+ fifo->master_thread_index);
+ vec_add1 (handles, session_handle (session));
fifo = fifo->next;
}
*/
}));
/* *INDENT-ON* */
+
+ vec_foreach (handle, handles)
+ session_close (session_get_from_handle (*handle));
}
/**
clib_rwlock_free (&sm->segments_rwlock);
if (CLIB_DEBUG)
- memset (sm, 0xfe, sizeof (*sm));
+ clib_memset (sm, 0xfe, sizeof (*sm));
pool_put (smm->segment_managers, sm);
}
int alloc_fail = 1, rv = 0, new_fs_index;
segment_manager_properties_t *props;
u8 added_a_segment = 0;
+ u64 segment_handle;
u32 sm_index;
props = segment_manager_properties_get (sm);
ASSERT (rx_fifo && tx_fifo);
sm_index = segment_manager_index (sm);
+ *fifo_segment_index = segment_manager_segment_index (sm, fifo_segment);
(*tx_fifo)->segment_manager = sm_index;
(*rx_fifo)->segment_manager = sm_index;
- *fifo_segment_index = segment_manager_segment_index (sm, fifo_segment);
+ (*tx_fifo)->segment_index = *fifo_segment_index;
+ (*rx_fifo)->segment_index = *fifo_segment_index;
if (added_a_segment)
- rv = application_add_segment_notify (sm->app_index,
- &fifo_segment->ssvm);
+ {
+ app_worker_t *app_wrk;
+ segment_handle = segment_manager_segment_handle (sm, fifo_segment);
+ app_wrk = app_worker_get (sm->app_wrk_index);
+ rv = app_worker_add_segment_notify (app_wrk, segment_handle);
+ }
/* Drop the lock after app is notified */
segment_manager_segment_reader_unlock (sm);
return rv;
svm_fifo_segment_private_t *fifo_segment;
segment_manager_t *sm;
+ if (!rx_fifo || !tx_fifo)
+ return;
+
/* It's possible to have no segment manager if the session was removed
* as result of a detach. */
if (!(sm = segment_manager_get_if_valid (rx_fifo->segment_manager)))
/* Remove segment manager if no sessions and detached from app */
if (segment_manager_app_detached (sm)
&& !segment_manager_has_fifos (sm))
- segment_manager_del (sm);
+ {
+ segment_manager_del (sm);
+ }
}
else
segment_manager_segment_reader_unlock (sm);
}
+u32
+segment_manager_evt_q_expected_size (u32 q_len)
+{
+ u32 fifo_evt_size, notif_q_size, q_hdrs;
+ u32 msg_q_sz, fifo_evt_ring_sz, session_ntf_ring_sz;
+
+ fifo_evt_size = 1 << max_log2 (sizeof (session_event_t));
+ notif_q_size = clib_max (16, q_len >> 4);
+
+ msg_q_sz = q_len * sizeof (svm_msg_q_msg_t);
+ fifo_evt_ring_sz = q_len * fifo_evt_size;
+ session_ntf_ring_sz = notif_q_size * 256;
+ q_hdrs = sizeof (svm_queue_t) + sizeof (svm_msg_q_t);
+
+ return (msg_q_sz + fifo_evt_ring_sz + session_ntf_ring_sz + q_hdrs);
+}
+
/**
* Allocates shm queue in the first segment
*
* Must be called with lock held
*/
-svm_queue_t *
+svm_msg_q_t *
segment_manager_alloc_queue (svm_fifo_segment_private_t * segment,
- u32 queue_size)
+ segment_manager_properties_t * props)
{
- ssvm_shared_header_t *sh;
- svm_queue_t *q;
+ u32 fifo_evt_size, session_evt_size = 256, notif_q_size;
+ svm_msg_q_cfg_t _cfg, *cfg = &_cfg;
+ svm_msg_q_t *q;
void *oldheap;
- sh = segment->ssvm.sh;
+ fifo_evt_size = sizeof (session_event_t);
+ notif_q_size = clib_max (16, props->evt_q_size >> 4);
+ /* *INDENT-OFF* */
+ svm_msg_q_ring_cfg_t rc[SESSION_MQ_N_RINGS] = {
+ {props->evt_q_size, fifo_evt_size, 0},
+ {notif_q_size, session_evt_size, 0}
+ };
+ /* *INDENT-ON* */
+ cfg->consumer_pid = 0;
+ cfg->n_rings = 2;
+ cfg->q_nitems = props->evt_q_size;
+ cfg->ring_cfgs = rc;
- oldheap = ssvm_push_heap (sh);
- q = svm_queue_init (queue_size, sizeof (session_fifo_event_t),
- 0 /* consumer pid */ ,
- 0 /* signal when queue non-empty */ );
+ oldheap = ssvm_push_heap (segment->ssvm.sh);
+ q = svm_msg_q_alloc (cfg);
ssvm_pop_heap (oldheap);
+
+ if (props->use_mq_eventfd)
+ {
+ if (svm_msg_q_alloc_producer_eventfd (q))
+ clib_warning ("failed to alloc eventfd");
+ }
return q;
}
svm_fifo_segment_private_t *seg;
segment_manager_t *sm;
u8 show_segments = 0, verbose = 0;
- uword address;
- u64 size;
+ char *address;
+ size_t size;
u32 active_fifos;
u32 free_fifos;
/* *INDENT-OFF* */
pool_foreach (sm, smm->segment_managers, ({
- vlib_cli_output (vm, "%-10d%=15d%=12d", segment_manager_index(sm),
- sm->app_index, pool_elts (sm->segments));
+ vlib_cli_output (vm, "%-10d%=15d%=12d", segment_manager_index (sm),
+ sm->app_wrk_index, pool_elts (sm->segments));
}));
/* *INDENT-ON* */