X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Fsession%2Fsegment_manager.c;h=2b8a7326ea763b89292b9697d4fc596cb73e26c4;hb=5a2ec8fc41d14ffc5275ab88761c1fb7e0420a33;hp=9304dd70b5df1a34add1733cf78ca6638980aff2;hpb=ae9533a80eaa535bec5d493803aef0e5a5452518;p=vpp.git diff --git a/src/vnet/session/segment_manager.c b/src/vnet/session/segment_manager.c index 9304dd70b5d..2b8a7326ea7 100644 --- a/src/vnet/session/segment_manager.c +++ b/src/vnet/session/segment_manager.c @@ -34,7 +34,8 @@ static u32 default_app_evt_queue_size = 128; 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 * @@ -50,13 +51,13 @@ segment_manager_properties_init (segment_manager_properties_t * props) 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 @@ -81,14 +82,14 @@ segment_manager_del_segment (segment_manager_t * sm, 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; @@ -116,6 +117,36 @@ segment_manager_get_segment (segment_manager_t * sm, u32 segment_index) 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 * @@ -153,7 +184,7 @@ int segment_manager_add_segment (segment_manager_t * sm, u32 segment_size) { segment_manager_main_t *smm = &segment_manager_main; - u32 rnd_margin = 128 << 10, seg_index; + u32 rnd_margin = 128 << 10, seg_index, page_size; segment_manager_properties_t *props; uword baseva = (u64) ~ 0, alloc_size; svm_fifo_segment_private_t *seg; @@ -181,16 +212,18 @@ segment_manager_add_segment (segment_manager_t * sm, u32 segment_size) { pool_get (sm->segments, seg); } - memset (seg, 0, sizeof (*seg)); + clib_memset (seg, 0, sizeof (*seg)); /* * Initialize ssvm segment and svm fifo private header */ segment_size = segment_size ? segment_size : props->add_segment_size; + page_size = clib_mem_get_page_size (); + segment_size = (segment_size + page_size - 1) & ~(page_size - 1); 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) { @@ -235,7 +268,7 @@ segment_manager_new () 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; } @@ -250,8 +283,7 @@ segment_manager_init (segment_manager_t * sm, u32 first_seg_size, { 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; @@ -288,8 +320,7 @@ segment_manager_init (segment_manager_t * sm, u32 first_seg_size, 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, @@ -309,8 +340,7 @@ segment_manager_init (segment_manager_t * sm, u32 first_seg_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; @@ -366,9 +396,17 @@ segment_manager_del_sessions (segment_manager_t * sm) */ while (fifo) { + if (fifo->ct_session_index != SVM_FIFO_INVALID_SESSION_INDEX) + { + svm_fifo_t *next = fifo->next; + application_local_session_disconnect_w_index (sm->app_wrk_index, + fifo->ct_session_index); + fifo = next; + continue; + } session = session_get (fifo->master_session_index, fifo->master_thread_index); - stream_session_disconnect (session); + session_close (session); fifo = fifo->next; } @@ -411,7 +449,7 @@ segment_manager_del (segment_manager_t * sm) 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); } @@ -476,6 +514,7 @@ segment_manager_alloc_session_fifos (segment_manager_t * 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); @@ -505,13 +544,18 @@ alloc_check: 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); + { + segment_handle = segment_manager_segment_handle (sm, fifo_segment); + rv = app_worker_add_segment_notify (sm->app_wrk_index, + segment_handle); + } /* Drop the lock after app is notified */ segment_manager_segment_reader_unlock (sm); return rv; @@ -583,32 +627,67 @@ segment_manager_dealloc_fifos (u32 segment_index, svm_fifo_t * rx_fifo, /* 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; } @@ -680,8 +759,8 @@ segment_manager_show_fn (vlib_main_t * vm, unformat_input_t * input, /* *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* */