FD.io VPP  v21.06-3-gbb25fbf28
Vector Packet Processing
segment_manager.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2017-2019 Cisco and/or its affiliates.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
17 #include <vnet/session/session.h>
19 
20 typedef struct segment_manager_main_
21 {
22  segment_manager_t *segment_managers; /**< Pool of segment managers */
23  u32 seg_name_counter; /**< Counter for segment names */
24 
25  /*
26  * Configuration
27  */
28  u32 default_fifo_size; /**< default rx/tx fifo size */
29  u32 default_segment_size; /**< default fifo segment size */
30  u32 default_app_mq_size; /**< default app msg q size */
31  u32 default_max_fifo_size; /**< default max fifo size */
32  u8 default_high_watermark; /**< default high watermark % */
33  u8 default_low_watermark; /**< default low watermark % */
35 
37 
38 #define segment_manager_foreach_segment_w_lock(VAR, SM, BODY) \
39 do { \
40  clib_rwlock_reader_lock (&(SM)->segments_rwlock); \
41  pool_foreach((VAR), ((SM)->segments)) (BODY); \
42  clib_rwlock_reader_unlock (&(SM)->segments_rwlock); \
43 } while (0)
44 
47 {
48  app_worker_t *app_wrk = app_worker_get (sm->app_wrk_index);
50 }
51 
54 {
55  props->add_segment_size = sm_main.default_segment_size;
56  props->rx_fifo_size = sm_main.default_fifo_size;
57  props->tx_fifo_size = sm_main.default_fifo_size;
58  props->evt_q_size = sm_main.default_app_mq_size;
59  props->max_fifo_size = sm_main.default_max_fifo_size;
60  props->high_watermark = sm_main.default_high_watermark;
61  props->low_watermark = sm_main.default_low_watermark;
62  props->n_slices = vlib_num_workers () + 1;
63  return props;
64 }
65 
66 u8
68 {
69  return (sm->flags & SEG_MANAGER_F_DETACHED);
70 }
71 
72 void
74 {
75  sm->flags |= SEG_MANAGER_F_DETACHED;
76 }
77 
80 {
81  return (seg - sm->segments);
82 }
83 
84 /**
85  * Adds segment to segment manager's pool
86  *
87  * If needed a writer's lock is acquired before allocating a new segment
88  * to avoid affecting any of the segments pool readers.
89  */
90 int
92  u8 notify_app)
93 {
96  fifo_segment_t *fs;
97  u32 fs_index = ~0;
98  u8 *seg_name;
99  int rv;
100 
101  props = segment_manager_properties_get (sm);
102 
103  /* Not configured for addition of new segments and not first */
104  if (!props->add_segment && !segment_size)
105  {
106  clib_warning ("cannot allocate new segment");
107  return VNET_API_ERROR_INVALID_VALUE;
108  }
109 
110  /*
111  * Allocate fifo segment and grab lock if needed
112  */
113  if (vlib_num_workers ())
114  clib_rwlock_writer_lock (&sm->segments_rwlock);
115 
116  pool_get_zero (sm->segments, fs);
117 
118  /*
119  * Allocate ssvm segment
120  */
121  segment_size = segment_size ? segment_size : props->add_segment_size;
122  segment_size = round_pow2 (segment_size, clib_mem_get_page_size ());
123 
124  if (props->segment_type != SSVM_SEGMENT_PRIVATE)
125  {
126  seg_name = format (0, "%d-%d%c", getpid (), smm->seg_name_counter++, 0);
127  }
128  else
129  {
130  app_worker_t *app_wrk = app_worker_get (sm->app_wrk_index);
131  application_t *app = application_get (app_wrk->app_index);
132  seg_name = format (0, "%v segment%c", app->name, 0);
133  }
134 
135  fs->ssvm.ssvm_size = segment_size;
136  fs->ssvm.name = seg_name;
137  fs->ssvm.requested_va = 0;
138 
139  if ((rv = ssvm_server_init (&fs->ssvm, props->segment_type)))
140  {
141  clib_warning ("svm_master_init ('%v', %u) failed", seg_name,
142  segment_size);
143  pool_put (sm->segments, fs);
144  goto done;
145  }
146 
147  /*
148  * Initialize fifo segment
149  */
150  fs->n_slices = props->n_slices;
151  fifo_segment_init (fs);
152 
153  /*
154  * Save segment index before dropping lock, if any held
155  */
156  fs_index = fs - sm->segments;
157 
158  /*
159  * Set watermarks in segment
160  */
161  fs->h->high_watermark = sm->high_watermark;
162  fs->h->low_watermark = sm->low_watermark;
163  fs->h->pct_first_alloc = props->pct_first_alloc;
165 
166  if (notify_app)
167  {
168  app_worker_t *app_wrk;
169  u64 fs_handle;
170  fs_handle = segment_manager_segment_handle (sm, fs);
171  app_wrk = app_worker_get (sm->app_wrk_index);
172  rv = app_worker_add_segment_notify (app_wrk, fs_handle);
173  if (rv)
174  return rv;
175  }
176 done:
177 
178  if (vlib_num_workers ())
179  clib_rwlock_writer_unlock (&sm->segments_rwlock);
180 
181  return fs_index;
182 }
183 
184 /**
185  * Remove segment without lock
186  */
187 void
189 {
190  if (ssvm_type (&fs->ssvm) != SSVM_SEGMENT_PRIVATE)
191  {
193  {
194  app_worker_t *app_wrk;
195  u64 segment_handle;
196  app_wrk = app_worker_get (sm->app_wrk_index);
197  segment_handle = segment_manager_segment_handle (sm, fs);
198  app_worker_del_segment_notify (app_wrk, segment_handle);
199  }
200  }
201 
203  ssvm_delete (&fs->ssvm);
204 
205  if (CLIB_DEBUG)
206  clib_memset (fs, 0xfb, sizeof (*fs));
207  pool_put (sm->segments, fs);
208 }
209 
210 static fifo_segment_t *
212  u32 segment_index)
213 {
214  if (pool_is_free_index (sm->segments, segment_index))
215  return 0;
216  return pool_elt_at_index (sm->segments, segment_index);
217 }
218 
219 /**
220  * Removes segment after acquiring writer lock
221  */
222 static inline void
224 {
225  fifo_segment_t *fs;
226  u8 is_prealloc;
227 
228  clib_rwlock_writer_lock (&sm->segments_rwlock);
229 
230  fs = segment_manager_get_segment_if_valid (sm, fs_index);
231  if (!fs)
232  goto done;
233 
235  if (is_prealloc && !segment_manager_app_detached (sm))
236  goto done;
237 
239 
240 done:
241  clib_rwlock_writer_unlock (&sm->segments_rwlock);
242 }
243 
244 void
246 {
247  sm_lock_and_del_segment_inline (sm, fs_index);
248 }
249 
250 /**
251  * Reads a segment from the segment manager's pool without lock
252  */
255 {
256  return pool_elt_at_index (sm->segments, segment_index);
257 }
258 
259 u64
261  fifo_segment_t * segment)
262 {
263  u32 segment_index = segment_manager_segment_index (sm, segment);
264  return (((u64) segment_manager_index (sm) << 32) | segment_index);
265 }
266 
267 u64
269  u32 segment_index)
270 {
271  return (((u64) segment_manager_index << 32) | segment_index);
272 }
273 
276 {
277  u32 sm_index, segment_index;
278  segment_manager_t *sm;
279 
280  segment_manager_parse_segment_handle (segment_handle, &sm_index,
281  &segment_index);
282  sm = segment_manager_get (sm_index);
283  if (!sm || pool_is_free_index (sm->segments, segment_index))
284  return 0;
285  return pool_elt_at_index (sm->segments, segment_index);
286 }
287 
288 /**
289  * Reads a segment from the segment manager's pool and acquires reader lock
290  *
291  * Caller must drop the reader's lock by calling
292  * @ref segment_manager_segment_reader_unlock once it finishes working with
293  * the segment.
294  */
297 {
298  clib_rwlock_reader_lock (&sm->segments_rwlock);
299  return pool_elt_at_index (sm->segments, segment_index);
300 }
301 
302 void
304 {
305  clib_rwlock_reader_lock (&sm->segments_rwlock);
306 }
307 
308 void
310 {
311  clib_rwlock_reader_unlock (&sm->segments_rwlock);
312 }
313 
314 void
316 {
317  clib_rwlock_writer_unlock (&sm->segments_rwlock);
318 }
319 
322 {
324  segment_manager_t *sm;
325 
326  pool_get_zero (smm->segment_managers, sm);
327  clib_rwlock_init (&sm->segments_rwlock);
328  return sm;
329 }
330 
331 int
333 {
335 
336  props = segment_manager_properties_get (sm);
337 
338  sm->max_fifo_size = props->max_fifo_size ?
339  props->max_fifo_size : sm_main.default_max_fifo_size;
340  sm->max_fifo_size = clib_max (sm->max_fifo_size, 4096);
341 
343  props->high_watermark,
344  props->low_watermark);
345  return 0;
346 }
347 
348 /**
349  * Initializes segment manager based on options provided.
350  * Returns error if ssvm segment(s) allocation fails.
351  */
352 int
354 {
356  uword first_seg_size;
357  fifo_segment_t *fs;
358  int fs_index, i;
359 
361  props = segment_manager_properties_get (sm);
362  first_seg_size = clib_max (props->segment_size,
364 
365  if (props->prealloc_fifos)
366  {
367  u64 approx_total_size, max_seg_size = ((u64) 1 << 32) - (128 << 10);
368  u32 rx_rounded_data_size, tx_rounded_data_size;
369  u32 prealloc_fifo_pairs = props->prealloc_fifos;
370  u32 rx_fifo_size, tx_fifo_size, pair_size;
371  u32 approx_segment_count;
372 
373  /* Figure out how many segments should be preallocated */
374  rx_rounded_data_size = (1 << (max_log2 (props->rx_fifo_size)));
375  tx_rounded_data_size = (1 << (max_log2 (props->tx_fifo_size)));
376 
377  rx_fifo_size = sizeof (svm_fifo_t) + rx_rounded_data_size;
378  tx_fifo_size = sizeof (svm_fifo_t) + tx_rounded_data_size;
379  pair_size = rx_fifo_size + tx_fifo_size;
380 
381  approx_total_size = (u64) prealloc_fifo_pairs *pair_size;
382  if (first_seg_size > approx_total_size)
383  max_seg_size = first_seg_size;
384  approx_segment_count = (approx_total_size + (max_seg_size - 1))
385  / max_seg_size;
386 
387  /* Allocate the segments */
388  for (i = 0; i < approx_segment_count + 1; i++)
389  {
390  fs_index = segment_manager_add_segment (sm, max_seg_size, 0);
391  if (fs_index < 0)
392  {
393  clib_warning ("Failed to preallocate segment %d", i);
394  return fs_index;
395  }
396 
397  fs = segment_manager_get_segment (sm, fs_index);
398  if (i == 0)
399  sm->event_queue = segment_manager_alloc_queue (fs, props);
400 
402  props->rx_fifo_size,
403  props->tx_fifo_size,
404  &prealloc_fifo_pairs);
406  if (prealloc_fifo_pairs == 0)
407  break;
408  }
409  return 0;
410  }
411 
412  fs_index = segment_manager_add_segment (sm, first_seg_size, 0);
413  if (fs_index < 0)
414  {
415  clib_warning ("Failed to allocate segment");
416  return fs_index;
417  }
418 
419  fs = segment_manager_get_segment (sm, fs_index);
420  sm->event_queue = segment_manager_alloc_queue (fs, props);
421 
422  if (props->prealloc_fifo_hdrs)
423  {
424  u32 hdrs_per_slice;
425 
426  /* Do not preallocate on slice associated to main thread */
427  i = (vlib_num_workers ()? 1 : 0);
428  hdrs_per_slice = props->prealloc_fifo_hdrs / (fs->n_slices - i);
429 
430  for (; i < fs->n_slices; i++)
431  {
432  if (fifo_segment_prealloc_fifo_hdrs (fs, i, hdrs_per_slice))
433  return VNET_API_ERROR_SVM_SEGMENT_CREATE_FAIL;
434  }
435  }
436 
437  return 0;
438 }
439 
440 void
442 {
443  app_worker_t *app_wrk;
444 
445  app_wrk = app_worker_get_if_valid (sm->app_wrk_index);
446  if (!app_wrk)
447  return;
448 
450 }
451 
452 /**
453  * Cleanup segment manager.
454  */
455 void
457 {
459  fifo_segment_t *fifo_segment;
460 
464 
465  if (sm->flags & SEG_MANAGER_F_DETACHED_LISTENER)
467 
468  /* If we have empty preallocated segments that haven't been removed, remove
469  * them now. Apart from that, the first segment in the first segment manager
470  * is not removed when all fifos are removed. It can only be removed when
471  * the manager is explicitly deleted/detached by the app. */
472  clib_rwlock_writer_lock (&sm->segments_rwlock);
473 
474  /* *INDENT-OFF* */
475  pool_foreach (fifo_segment, sm->segments) {
476  segment_manager_del_segment (sm, fifo_segment);
477  }
478  /* *INDENT-ON* */
479 
480  pool_free (sm->segments);
481  clib_rwlock_writer_unlock (&sm->segments_rwlock);
482 
483  clib_rwlock_free (&sm->segments_rwlock);
484  if (CLIB_DEBUG)
485  clib_memset (sm, 0xfe, sizeof (*sm));
486  pool_put (smm->segment_managers, sm);
487 }
488 
489 static void
491 {
492  u32 sm_index = *(u32 *) arg;
493  segment_manager_t *sm;
494 
495  ASSERT (vlib_get_thread_index () == 0);
496 
497  if ((sm = segment_manager_get_if_valid (sm_index)))
499 }
500 
501 static void
503 {
505  {
506  u32 sm_index = segment_manager_index (sm);
508  sizeof (sm_index));
509  }
510  else
511  {
513  }
514 }
515 
516 void
518 {
519  ASSERT (vlib_get_thread_index () == 0);
520 
522  if (segment_manager_has_fifos (sm))
524  else
525  {
526  ASSERT (!sm->first_is_protected || segment_manager_app_detached (sm));
528  }
529 }
530 
533 {
535 }
536 
539 {
541  return 0;
543 }
544 
545 u32
547 {
548  return sm - sm_main.segment_managers;
549 }
550 
551 u8
553 {
554  fifo_segment_t *seg;
555  u8 first = 1;
556 
557  /* *INDENT-OFF* */
559  if (CLIB_DEBUG && !first && !fifo_segment_has_fifos (seg)
561  {
562  clib_warning ("segment %d has no fifos!",
564  first = 0;
565  }
566  if (fifo_segment_has_fifos (seg))
567  {
569  return 1;
570  }
571  }));
572  /* *INDENT-ON* */
573 
574  return 0;
575 }
576 
577 /**
578  * Initiate disconnects for all sessions 'owned' by a segment manager
579  */
580 void
582 {
583  session_handle_t *handles = 0, *handle;
584  fifo_segment_t *fs;
585  session_t *session;
586  int slice_index;
587  svm_fifo_t *f;
588 
589  ASSERT (pool_elts (sm->segments) != 0);
590 
591  /* Across all fifo segments used by the server */
592  /* *INDENT-OFF* */
594  for (slice_index = 0; slice_index < fs->n_slices; slice_index++)
595  {
596  f = fifo_segment_get_slice_fifo_list (fs, slice_index);
597 
598  /*
599  * Remove any residual sessions from the session lookup table
600  * Don't bother deleting the individual fifos, we're going to
601  * throw away the fifo segment in a minute.
602  */
603  while (f)
604  {
605  session = session_get_if_valid (f->shr->master_session_index,
606  f->master_thread_index);
607  if (session)
608  vec_add1 (handles, session_handle (session));
609  f = f->next;
610  }
611  }
612 
613  /* Instead of removing the segment, test when cleaning up disconnected
614  * sessions if the segment can be removed.
615  */
616  }));
617  /* *INDENT-ON* */
618 
619  vec_foreach (handle, handles)
620  {
621  session = session_get_from_handle (*handle);
622  session_close (session);
623  /* Avoid propagating notifications back to the app */
624  session->app_wrk_index = APP_INVALID_INDEX;
625  }
626  vec_free (handles);
627 }
628 
629 /**
630  * Initiate disconnects for sessions in specified state 'owned' by a segment
631  * manager
632  */
633 void
635  session_state_t *states)
636 {
637  session_handle_t *handles = 0, *handle;
638  fifo_segment_t *fs;
639  session_t *session;
640  int slice_index;
641  svm_fifo_t *f;
642 
643  ASSERT (pool_elts (sm->segments) != 0);
644 
645  /* Across all fifo segments used by the server */
647  fs, sm, ({
648  for (slice_index = 0; slice_index < fs->n_slices; slice_index++)
649  {
650  f = fifo_segment_get_slice_fifo_list (fs, slice_index);
651  while (f)
652  {
653  session = session_get_if_valid (f->shr->master_session_index,
654  f->master_thread_index);
655  if (session)
656  {
658  vec_foreach (state, states)
659  {
660  if (session->session_state == *state)
661  {
662  vec_add1 (handles, session_handle (session));
663  break;
664  }
665  }
666  }
667  f = f->next;
668  }
669  }
670  }));
671 
672  vec_foreach (handle, handles)
673  {
674  session = session_get_from_handle (*handle);
675  session_close (session);
676  /* Avoid propagating notifications back to the app */
677  session->app_wrk_index = APP_INVALID_INDEX;
678  }
679  vec_free (handles);
680 }
681 
682 int
685  u32 rx_fifo_size, u32 tx_fifo_size,
686  svm_fifo_t ** rx_fifo, svm_fifo_t ** tx_fifo)
687 {
688  rx_fifo_size = clib_max (rx_fifo_size, sm_main.default_fifo_size);
689  *rx_fifo = fifo_segment_alloc_fifo_w_slice (fifo_segment, thread_index,
690  rx_fifo_size,
692 
693  tx_fifo_size = clib_max (tx_fifo_size, sm_main.default_fifo_size);
694  *tx_fifo = fifo_segment_alloc_fifo_w_slice (fifo_segment, thread_index,
695  tx_fifo_size,
697 
698  if (*rx_fifo == 0)
699  {
700  /* This would be very odd, but handle it... */
701  if (*tx_fifo != 0)
702  {
703  fifo_segment_free_fifo (fifo_segment, *tx_fifo);
704  *tx_fifo = 0;
705  }
706  return -1;
707  }
708  if (*tx_fifo == 0)
709  {
710  if (*rx_fifo != 0)
711  {
712  fifo_segment_free_fifo (fifo_segment, *rx_fifo);
713  *rx_fifo = 0;
714  }
715  return -1;
716  }
717 
718  return 0;
719 }
720 
721 int
724  svm_fifo_t ** rx_fifo,
725  svm_fifo_t ** tx_fifo)
726 {
727  int alloc_fail = 1, rv = 0, new_fs_index;
728  uword free_bytes, max_free_bytes = 0;
730  fifo_segment_t *fs = 0, *cur;
731  u32 sm_index, fs_index;
732 
733  props = segment_manager_properties_get (sm);
734 
735  /*
736  * Find the first free segment to allocate the fifos in
737  */
738 
740 
741  /* *INDENT-OFF* */
742  pool_foreach (cur, sm->segments) {
743  free_bytes = fifo_segment_available_bytes (cur);
744  if (free_bytes > max_free_bytes)
745  {
746  max_free_bytes = free_bytes;
747  fs = cur;
748  }
749  }
750  /* *INDENT-ON* */
751 
752  if (fs)
753  {
755  props->rx_fifo_size,
756  props->tx_fifo_size,
757  rx_fifo, tx_fifo);
758  /* On success, keep lock until fifos are initialized */
759  if (!alloc_fail)
760  goto alloc_success;
761  }
762 
764 
765  /*
766  * Allocation failed, see if we can add a new segment
767  */
768  if (props->add_segment)
769  {
770  if ((new_fs_index = segment_manager_add_segment (sm, 0, 1)) < 0)
771  {
772  clib_warning ("Failed to add new segment");
773  return SESSION_E_SEG_CREATE;
774  }
775  fs = segment_manager_get_segment_w_lock (sm, new_fs_index);
777  props->rx_fifo_size,
778  props->tx_fifo_size,
779  rx_fifo, tx_fifo);
780  if (alloc_fail)
781  {
782  clib_warning ("Added a segment, still can't allocate a fifo");
784  return SESSION_E_SEG_NO_SPACE2;
785  }
786  }
787  else
788  {
789  SESSION_DBG ("Can't add new seg and no space to allocate fifos!");
790  return SESSION_E_SEG_NO_SPACE;
791  }
792 
793 alloc_success:
794  ASSERT (rx_fifo && tx_fifo);
795 
796  sm_index = segment_manager_index (sm);
797  fs_index = segment_manager_segment_index (sm, fs);
798  (*tx_fifo)->segment_manager = sm_index;
799  (*rx_fifo)->segment_manager = sm_index;
800  (*tx_fifo)->segment_index = fs_index;
801  (*rx_fifo)->segment_index = fs_index;
802 
803  /* Drop the lock after app is notified */
805 
806  return rv;
807 }
808 
809 void
811 {
812  segment_manager_t *sm;
813  fifo_segment_t *fs;
814  u32 segment_index;
815 
816  if (!rx_fifo || !tx_fifo)
817  return;
818 
819  /* It's possible to have no segment manager if the session was removed
820  * as result of a detach. */
821  if (!(sm = segment_manager_get_if_valid (rx_fifo->segment_manager)))
822  return;
823 
824  segment_index = rx_fifo->segment_index;
825  fs = segment_manager_get_segment_w_lock (sm, segment_index);
826  fifo_segment_free_fifo (fs, rx_fifo);
827  fifo_segment_free_fifo (fs, tx_fifo);
828 
829  /*
830  * Try to remove svm segment if it has no fifos. This can be done only if
831  * the segment is not the first in the segment manager or if it is first
832  * and it is not protected. Moreover, if the segment is first and the app
833  * has detached from the segment manager, remove the segment manager.
834  */
835  if (!fifo_segment_has_fifos (fs))
836  {
838 
839  /* Remove segment if it holds no fifos or first but not protected */
840  if (segment_index != 0 || !sm->first_is_protected)
841  sm_lock_and_del_segment_inline (sm, segment_index);
842 
843  /* Remove segment manager if no sessions and detached from app */
845  && !segment_manager_has_fifos (sm))
847  }
848  else
850 }
851 
852 void
854 {
855  fifo_segment_t *fs;
856 
857  fs = segment_manager_get_segment_w_lock (sm, (*f)->segment_index);
860 }
861 
862 void
864  session_t *s)
865 {
866  fifo_segment_t *fs;
867 
868  fs = segment_manager_get_segment_w_lock (sm, (*f)->segment_index);
871 
872  (*f)->shr->master_session_index = s->session_index;
873  (*f)->master_thread_index = s->thread_index;
874 }
875 
876 u32
878 {
879  u32 fifo_evt_size, notif_q_size, q_hdrs;
880  u32 msg_q_sz, fifo_evt_ring_sz, session_ntf_ring_sz;
881 
882  fifo_evt_size = 1 << max_log2 (sizeof (session_event_t));
883  notif_q_size = clib_max (16, q_len >> 4);
884 
885  msg_q_sz = q_len * sizeof (svm_msg_q_msg_t);
886  fifo_evt_ring_sz = q_len * fifo_evt_size;
887  session_ntf_ring_sz = notif_q_size * 256;
888  q_hdrs = sizeof (svm_queue_t) + sizeof (svm_msg_q_t);
889 
890  return (msg_q_sz + fifo_evt_ring_sz + session_ntf_ring_sz + q_hdrs);
891 }
892 
893 /**
894  * Allocates shm queue in the first segment
895  *
896  * Must be called with lock held
897  */
898 svm_msg_q_t *
900  segment_manager_props_t * props)
901 {
902  u32 fifo_evt_size, session_evt_size = 256, notif_q_size;
903  svm_msg_q_cfg_t _cfg, *cfg = &_cfg;
904  svm_msg_q_t *q;
905 
906  fifo_evt_size = sizeof (session_event_t);
907  notif_q_size = clib_max (16, props->evt_q_size >> 4);
908  /* *INDENT-OFF* */
910  {props->evt_q_size, fifo_evt_size, 0},
911  {notif_q_size, session_evt_size, 0}
912  };
913  /* *INDENT-ON* */
914  cfg->consumer_pid = 0;
915  cfg->n_rings = 2;
916  cfg->q_nitems = props->evt_q_size;
917  cfg->ring_cfgs = rc;
918 
919  q = fifo_segment_msg_q_alloc (segment, 0, cfg);
920 
921  if (props->use_mq_eventfd)
922  {
923  if (svm_msg_q_alloc_eventfd (q))
924  clib_warning ("failed to alloc eventfd");
925  }
926  return q;
927 }
928 
929 svm_msg_q_t *
931 {
932  return sm->event_queue;
933 }
934 
935 /**
936  * Frees shm queue allocated in the first segment
937  */
938 void
940 {
941  fifo_segment_t *segment;
943  void *oldheap;
944 
945  ASSERT (!pool_is_free_index (sm->segments, 0));
946 
947  segment = segment_manager_get_segment_w_lock (sm, 0);
948  sh = segment->ssvm.sh;
949 
950  oldheap = ssvm_push_heap (sh);
951  svm_queue_free (q);
952  ssvm_pop_heap (oldheap);
954 }
955 
956 /*
957  * Init segment vm address allocator
958  */
959 void
961 {
963 
964  sm->default_fifo_size = 1 << 12;
965  sm->default_segment_size = 1 << 20;
966  sm->default_app_mq_size = 128;
967  sm->default_max_fifo_size = 4 << 20;
968  sm->default_high_watermark = 80;
969  sm->default_low_watermark = 50;
970 }
971 
972 static clib_error_t *
974  vlib_cli_command_t * cmd)
975 {
977  u8 show_segments = 0, verbose = 0;
978  uword max_fifo_size;
979  segment_manager_t *sm;
980  fifo_segment_t *seg;
981  app_worker_t *app_wrk;
982  application_t *app;
983  u8 custom_logic;
984 
986  {
987  if (unformat (input, "segments"))
988  show_segments = 1;
989  else if (unformat (input, "verbose"))
990  verbose = 1;
991  else
992  return clib_error_return (0, "unknown input `%U'",
993  format_unformat_error, input);
994  }
995  vlib_cli_output (vm, "%d segment managers allocated",
996  pool_elts (smm->segment_managers));
997  if (verbose && pool_elts (smm->segment_managers))
998  {
999  vlib_cli_output (vm, "%-6s%=10s%=10s%=13s%=11s%=11s%=12s",
1000  "Index", "AppIndex", "Segments", "MaxFifoSize",
1001  "HighWater", "LowWater", "FifoTuning");
1002 
1003  /* *INDENT-OFF* */
1004  pool_foreach (sm, smm->segment_managers) {
1005  app_wrk = app_worker_get_if_valid (sm->app_wrk_index);
1006  app = app_wrk ? application_get (app_wrk->app_index) : 0;
1007  custom_logic = (app && (app->cb_fns.fifo_tuning_callback)) ? 1 : 0;
1008  max_fifo_size = sm->max_fifo_size;
1009 
1010  vlib_cli_output (vm, "%-6d%=10d%=10d%=13U%=11d%=11d%=12s",
1011  segment_manager_index (sm),
1012  sm->app_wrk_index, pool_elts (sm->segments),
1013  format_memory_size, max_fifo_size,
1014  sm->high_watermark, sm->low_watermark,
1015  custom_logic ? "custom" : "none");
1016  }
1017  /* *INDENT-ON* */
1018 
1019  vlib_cli_output (vm, "\n");
1020  }
1021  if (show_segments)
1022  {
1023  vlib_cli_output (vm, "%U", format_fifo_segment, 0, verbose);
1024 
1025  /* *INDENT-OFF* */
1026  pool_foreach (sm, smm->segment_managers) {
1028  vlib_cli_output (vm, "%U", format_fifo_segment, seg, verbose);
1029  }));
1030  }
1031  /* *INDENT-ON* */
1032 
1033  }
1034  return 0;
1035 }
1036 
1037 /* *INDENT-OFF* */
1039 {
1040  .path = "show segment-manager",
1041  .short_help = "show segment-manager [segments][verbose]",
1042  .function = segment_manager_show_fn,
1043 };
1044 /* *INDENT-ON* */
1045 
1046 void
1048 {
1050  app_worker_t *app_wrk;
1051  fifo_segment_t *fs;
1052  const u8 *app_name;
1053  int slice_index;
1054  u8 *s = 0, *str;
1055  svm_fifo_t *f;
1056 
1057  if (!sm)
1058  {
1059  if (verbose)
1060  vlib_cli_output (vm, "%-40s%-20s%-15s%-10s", "Connection", "App",
1061  "API Client", "SegManager");
1062  else
1063  vlib_cli_output (vm, "%-40s%-20s", "Connection", "App");
1064  return;
1065  }
1066 
1067  app_wrk = app_worker_get (sm->app_wrk_index);
1069 
1070  clib_rwlock_reader_lock (&sm->segments_rwlock);
1071 
1072  /* *INDENT-OFF* */
1073  pool_foreach (fs, sm->segments) {
1074  for (slice_index = 0; slice_index < fs->n_slices; slice_index++)
1075  {
1076  f = fifo_segment_get_slice_fifo_list (fs, slice_index);
1077  while (f)
1078  {
1079  u32 session_index, thread_index;
1080  session_t *session;
1081 
1082  session_index = f->shr->master_session_index;
1083  thread_index = f->master_thread_index;
1084 
1085  session = session_get (session_index, thread_index);
1086  str = format (0, "%U", format_session, session, verbose);
1087 
1088  if (verbose)
1089  s = format (s, "%-40v%-20v%-15u%-10u", str, app_name,
1090  app_wrk->api_client_index,
1091  app_wrk->connects_seg_manager);
1092  else
1093  s = format (s, "%-40v%-20v", str, app_name);
1094 
1095  vlib_cli_output (vm, "%v", s);
1096  vec_reset_length (s);
1097  vec_free (str);
1098 
1099  f = f->next;
1100  }
1101  vec_free (s);
1102  }
1103  }
1104  /* *INDENT-ON* */
1105 
1106  clib_rwlock_reader_unlock (&sm->segments_rwlock);
1107 }
1108 
1109 void
1111  u8 high_watermark, u8 low_watermark)
1112 {
1113  ASSERT (high_watermark <= 100 && low_watermark <= 100 &&
1114  low_watermark <= high_watermark);
1115 
1116  sm->high_watermark = high_watermark;
1117  sm->low_watermark = low_watermark;
1118 }
1119 
1120 /*
1121  * fd.io coding-style-patch-verification: ON
1122  *
1123  * Local Variables:
1124  * eval: (c-set-style "gnu")
1125  * End:
1126  */
vec_reset_length
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
Definition: vec_bootstrap.h:194
ssvm_private_t::requested_va
uword requested_va
Definition: ssvm.h:85
segment_manager_main_t
struct segment_manager_main_ segment_manager_main_t
segment_manager_get_segment_w_lock
fifo_segment_t * segment_manager_get_segment_w_lock(segment_manager_t *sm, u32 segment_index)
Reads a segment from the segment manager's pool and acquires reader lock.
Definition: segment_manager.c:296
svm_msg_q_cfg_::n_rings
u32 n_rings
number of msg rings
Definition: message_queue.h:89
segment_manager_properties_get
static segment_manager_props_t * segment_manager_properties_get(segment_manager_t *sm)
Definition: segment_manager.c:46
vlib_num_workers
static u32 vlib_num_workers()
Definition: threads.h:354
segment_manager_segment_index
static u32 segment_manager_segment_index(segment_manager_t *sm, fifo_segment_t *seg)
Definition: segment_manager.c:79
SESSION_MQ_N_RINGS
@ SESSION_MQ_N_RINGS
Definition: session_types.h:403
thread_index
u32 thread_index
Definition: nat44_ei_hairpinning.c:492
segment_manager_segment_reader_lock
void segment_manager_segment_reader_lock(segment_manager_t *sm)
Definition: segment_manager.c:303
segment_manager_get
segment_manager_t * segment_manager_get(u32 index)
Definition: segment_manager.c:532
segment_manager_init_first
int segment_manager_init_first(segment_manager_t *sm)
Initializes segment manager based on options provided.
Definition: segment_manager.c:353
segment_manager_segment_writer_unlock
void segment_manager_segment_writer_unlock(segment_manager_t *sm)
Definition: segment_manager.c:315
segment_manager_show_fn
static clib_error_t * segment_manager_show_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: segment_manager.c:973
session_::session_index
u32 session_index
Index in thread pool where session was allocated.
Definition: session_types.h:188
fifo_segment_alloc_fifo_w_slice
svm_fifo_t * fifo_segment_alloc_fifo_w_slice(fifo_segment_t *fs, u32 slice_index, u32 data_bytes, fifo_segment_ftype_t ftype)
Allocate fifo in fifo segment.
Definition: fifo_segment.c:846
segment_manager_main_::segment_managers
segment_manager_t * segment_managers
Pool of segment managers.
Definition: segment_manager.c:22
session_close
void session_close(session_t *s)
Initialize session closing procedure.
Definition: session.c:1496
clib_max
#define clib_max(x, y)
Definition: clib.h:335
fifo_segment_attach_fifo
void fifo_segment_attach_fifo(fifo_segment_t *fs, svm_fifo_t **f, u32 slice_index)
Definition: fifo_segment.c:1011
sm_lock_and_del_segment_inline
static void sm_lock_and_del_segment_inline(segment_manager_t *sm, u32 fs_index)
Removes segment after acquiring writer lock.
Definition: segment_manager.c:223
f
vlib_frame_t * f
Definition: interface_output.c:1080
segment_manager_init
int segment_manager_init(segment_manager_t *sm)
Definition: segment_manager.c:332
ssvm_pop_heap
static void ssvm_pop_heap(void *oldheap)
Definition: ssvm.h:151
pool_elt_at_index
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:553
ssvm_private_t::ssvm_size
uword ssvm_size
Definition: ssvm.h:84
segment_manager_main_::default_low_watermark
u8 default_low_watermark
default low watermark %
Definition: segment_manager.c:33
fifo_segment_t
Definition: fifo_segment.h:67
segment_manager_props_init
segment_manager_props_t * segment_manager_props_init(segment_manager_props_t *props)
Definition: segment_manager.c:53
fifo_segment_detach_fifo
void fifo_segment_detach_fifo(fifo_segment_t *fs, svm_fifo_t **f)
Definition: fifo_segment.c:984
segment_manager_main_
Definition: segment_manager.c:20
session_
Definition: session_types.h:175
segment_manager_t
struct _segment_manager segment_manager_t
clib_error_return
#define clib_error_return(e, args...)
Definition: error.h:99
vlib_cli_command_t::path
char * path
Definition: cli.h:96
svm_queue_t
struct _svm_queue svm_queue_t
session_handle_t
u64 session_handle_t
Definition: session_types.h:111
ssvm_push_heap
static void * ssvm_push_heap(ssvm_shared_header_t *sh)
Definition: ssvm.h:143
svm_msg_q_cfg_::q_nitems
u32 q_nitems
msg queue size (not rings)
Definition: message_queue.h:88
first
static heap_elt_t * first(heap_header_t *h)
Definition: heap.c:59
APP_INVALID_INDEX
#define APP_INVALID_INDEX
Definition: application.h:226
svm_msg_q_msg_t
Definition: message_queue.h:93
session_::thread_index
u8 thread_index
Index of the thread that allocated the session.
Definition: session_types.h:194
pool_put
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:305
vm
vlib_main_t * vm
X-connect all packets from the HOST to the PHY.
Definition: nat44_ei.c:3047
fifo_segment_flags
#define fifo_segment_flags(_fs)
Definition: fifo_segment.h:93
state
vl_api_dhcp_client_state_t state
Definition: dhcp.api:201
svm_msg_q_alloc_eventfd
int svm_msg_q_alloc_eventfd(svm_msg_q_t *mq)
Allocate event fd for queue.
Definition: message_queue.c:491
application_
Definition: application.h:108
ssvm_private_t::sh
ssvm_shared_header_t * sh
Definition: ssvm.h:83
unformat_input_t
struct _unformat_input_t unformat_input_t
app_worker_del_segment_notify
int app_worker_del_segment_notify(app_worker_t *app_wrk, u64 segment_handle)
Definition: application_worker.c:600
clib_rwlock_reader_lock
static void clib_rwlock_reader_lock(clib_rwlock_t *p)
Definition: lock.h:169
segment_manager_parse_segment_handle
static void segment_manager_parse_segment_handle(u64 segment_handle, u32 *sm_index, u32 *segment_index)
Definition: segment_manager.h:172
clib_rwlock_reader_unlock
static void clib_rwlock_reader_unlock(clib_rwlock_t *p)
Definition: lock.h:184
segment_manager_alloc
segment_manager_t * segment_manager_alloc(void)
Definition: segment_manager.c:321
clib_rwlock_writer_unlock
static void clib_rwlock_writer_unlock(clib_rwlock_t *p)
Definition: lock.h:206
segment_manager_free_safe
static void segment_manager_free_safe(segment_manager_t *sm)
Definition: segment_manager.c:502
segment_manager_app_detached
u8 segment_manager_app_detached(segment_manager_t *sm)
Definition: segment_manager.c:67
svm_msg_q_ring_cfg_
Definition: message_queue.h:78
svm_fifo_t
struct _svm_fifo svm_fifo_t
max_log2
static uword max_log2(uword x)
Definition: clib.h:223
segment_manager_get_segment_w_handle
fifo_segment_t * segment_manager_get_segment_w_handle(u64 segment_handle)
Definition: segment_manager.c:275
unformat
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
pool_is_free_index
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:302
fifo_segment_header_::low_watermark
u8 low_watermark
Memory pressure watermark low.
Definition: fifo_types.h:146
segment_manager_main_::default_app_mq_size
u32 default_app_mq_size
default app msg q size
Definition: segment_manager.c:30
round_pow2
static uword round_pow2(uword x, uword pow2)
Definition: clib.h:279
application_get
application_t * application_get(u32 app_index)
Definition: application.c:710
session_::app_wrk_index
u32 app_wrk_index
Index of the app worker that owns the session.
Definition: session_types.h:191
segment_manager_alloc_session_fifos
int segment_manager_alloc_session_fifos(segment_manager_t *sm, u32 thread_index, svm_fifo_t **rx_fifo, svm_fifo_t **tx_fifo)
Definition: segment_manager.c:722
pool_foreach
#define pool_foreach(VAR, POOL)
Iterate through pool.
Definition: pool.h:534
segment_manager_app_detach
void segment_manager_app_detach(segment_manager_t *sm)
Definition: segment_manager.c:73
fifo_segment_cleanup
void fifo_segment_cleanup(fifo_segment_t *fs)
Definition: fifo_segment.c:826
svm_queue_free
void svm_queue_free(svm_queue_t *q)
Definition: queue.c:91
segment_manager_event_queue
svm_msg_q_t * segment_manager_event_queue(segment_manager_t *sm)
Definition: segment_manager.c:930
SEG_MANAGER_F_DETACHED_LISTENER
@ SEG_MANAGER_F_DETACHED_LISTENER
Definition: segment_manager.h:48
vec_add1
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:606
segment_manager_dealloc_fifos
void segment_manager_dealloc_fifos(svm_fifo_t *rx_fifo, svm_fifo_t *tx_fifo)
Definition: segment_manager.c:810
application_get_segment_manager_properties
segment_manager_props_t * application_get_segment_manager_properties(u32 app_index)
Definition: application.c:1642
segment_manager_del_sessions
void segment_manager_del_sessions(segment_manager_t *sm)
Initiate disconnects for all sessions 'owned' by a segment manager.
Definition: segment_manager.c:581
segment_manager_free
void segment_manager_free(segment_manager_t *sm)
Cleanup segment manager.
Definition: segment_manager.c:456
ssvm_delete
void ssvm_delete(ssvm_private_t *ssvm)
Definition: ssvm.c:445
fifo_segment_msg_q_alloc
svm_msg_q_t * fifo_segment_msg_q_alloc(fifo_segment_t *fs, u32 mq_index, svm_msg_q_cfg_t *cfg)
Allocate message queue on segment.
Definition: fifo_segment.c:1078
segment_manager_props_t
struct _segment_manager_props segment_manager_props_t
vlib_get_thread_index
static_always_inline uword vlib_get_thread_index(void)
Definition: threads.h:208
app_worker_get_if_valid
app_worker_t * app_worker_get_if_valid(u32 wrk_index)
Definition: application_worker.c:47
unformat_check_input
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:163
segment_manager_get_segment_if_valid
static fifo_segment_t * segment_manager_get_segment_if_valid(segment_manager_t *sm, u32 segment_index)
Definition: segment_manager.c:211
segment_manager_format_sessions
void segment_manager_format_sessions(segment_manager_t *sm, int verbose)
Definition: segment_manager.c:1047
fifo_segment_preallocate_fifo_pairs
void fifo_segment_preallocate_fifo_pairs(fifo_segment_t *fs, u32 rx_fifo_size, u32 tx_fifo_size, u32 *n_fifo_pairs)
Pre-allocates fifo pairs in fifo segment.
Definition: fifo_segment.c:1208
FIFO_SEGMENT_F_MEM_LIMIT
@ FIFO_SEGMENT_F_MEM_LIMIT
Definition: fifo_segment.h:40
clib_rwlock_writer_lock
static void clib_rwlock_writer_lock(clib_rwlock_t *p)
Definition: lock.h:192
uword
u64 uword
Definition: types.h:112
segment_manager_segment_reader_unlock
void segment_manager_segment_reader_unlock(segment_manager_t *sm)
Definition: segment_manager.c:309
vlib_thread_is_main_w_barrier
static u8 vlib_thread_is_main_w_barrier(void)
Definition: threads.h:506
segment_manager_get_segment
fifo_segment_t * segment_manager_get_segment(segment_manager_t *sm, u32 segment_index)
Reads a segment from the segment manager's pool without lock.
Definition: segment_manager.c:254
segment_manager_add_segment
int segment_manager_add_segment(segment_manager_t *sm, uword segment_size, u8 notify_app)
Adds segment to segment manager's pool.
Definition: segment_manager.c:91
segment_manager_show_command
static vlib_cli_command_t segment_manager_show_command
(constructor) VLIB_CLI_COMMAND (segment_manager_show_command)
Definition: segment_manager.c:1038
i
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:261
session_handle
static session_handle_t session_handle(session_t *s)
Definition: session_types.h:283
svm_msg_q_cfg_::ring_cfgs
svm_msg_q_ring_cfg_t * ring_cfgs
array of ring cfgs
Definition: message_queue.h:90
segment_manager_segment_handle
u64 segment_manager_segment_handle(segment_manager_t *sm, fifo_segment_t *segment)
Definition: segment_manager.c:260
format_unformat_error
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
session_get_from_handle
static session_t * session_get_from_handle(session_handle_t handle)
Definition: session.h:356
segment_manager_lock_and_del_segment
void segment_manager_lock_and_del_segment(segment_manager_t *sm, u32 fs_index)
Definition: segment_manager.c:245
segment_manager.h
app_name
static char * app_name
Definition: vapi_cpp_test.cpp:33
VLIB_CLI_COMMAND
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:163
FIFO_SEGMENT_TX_FIFO
@ FIFO_SEGMENT_TX_FIFO
Definition: fifo_segment.h:27
segment_manager_evt_q_expected_size
u32 segment_manager_evt_q_expected_size(u32 q_len)
Definition: segment_manager.c:877
segment_manager_index
u32 segment_manager_index(segment_manager_t *sm)
Definition: segment_manager.c:546
format_memory_size
u8 * format_memory_size(u8 *s, va_list *va)
Definition: std-formats.c:209
session_get
static session_t * session_get(u32 si, u32 thread_index)
Definition: session.h:336
vlib_cli_output
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:716
svm_msg_q_
Definition: message_queue.h:72
segment_manager_main_::default_fifo_size
u32 default_fifo_size
default rx/tx fifo size
Definition: segment_manager.c:28
clib_rwlock_init
static void clib_rwlock_init(clib_rwlock_t *p)
Definition: lock.h:152
SSVM_SEGMENT_PRIVATE
@ SSVM_SEGMENT_PRIVATE
Definition: ssvm.h:51
format_session
u8 * format_session(u8 *s, va_list *args)
Format stream session as per the following format.
Definition: session_cli.c:101
fifo_segment_t::n_slices
u8 n_slices
number of fifo segment slices
Definition: fifo_segment.h:72
FIFO_SEGMENT_RX_FIFO
@ FIFO_SEGMENT_RX_FIFO
Definition: fifo_segment.h:26
segment_manager_main_::default_segment_size
u32 default_segment_size
default fifo segment size
Definition: segment_manager.c:29
sm_free_w_index_helper
static void sm_free_w_index_helper(void *arg)
Definition: segment_manager.c:490
fifo_segment_t::ssvm
ssvm_private_t ssvm
ssvm segment data
Definition: fifo_segment.h:69
segment_manager_alloc_queue
svm_msg_q_t * segment_manager_alloc_queue(fifo_segment_t *segment, segment_manager_props_t *props)
Allocates shm queue in the first segment.
Definition: segment_manager.c:899
vec_free
#define vec_free(V)
Free vector's memory (no header).
Definition: vec.h:395
index
u32 index
Definition: flow_types.api:221
always_inline
#define always_inline
Definition: rdma_mlx5dv.h:23
fifo_segment_free_fifo
void fifo_segment_free_fifo(fifo_segment_t *fs, svm_fifo_t *f)
Free fifo allocated in fifo segment.
Definition: fifo_segment.c:918
segment_manager_init_free
void segment_manager_init_free(segment_manager_t *sm)
Initiate segment manager cleanup.
Definition: segment_manager.c:517
app_worker_::connects_seg_manager
u32 connects_seg_manager
Segment manager used for outgoing connects issued by the app.
Definition: application.h:54
segment_manager_get_if_valid
segment_manager_t * segment_manager_get_if_valid(u32 index)
Definition: segment_manager.c:538
u64
unsigned long u64
Definition: types.h:89
format
description fragment has unexpected format
Definition: map.api:433
ASSERT
#define ASSERT(truth)
Definition: error_bootstrap.h:69
segment_manager_main_::default_high_watermark
u8 default_high_watermark
default high watermark %
Definition: segment_manager.c:32
ssvm_server_init
int ssvm_server_init(ssvm_private_t *ssvm, ssvm_segment_type_t type)
Definition: ssvm.c:433
session_state_t
session_state_t
Definition: session_types.h:143
SESSION_DBG
#define SESSION_DBG(_fmt, _args...)
Definition: session_debug.h:329
session_get_if_valid
static session_t * session_get_if_valid(u64 si, u32 thread_index)
Definition: session.h:343
app_worker_add_segment_notify
int app_worker_add_segment_notify(app_worker_t *app_wrk, u64 segment_handle)
Send an API message to the external app, to map new segment.
Definition: application_worker.c:591
u32
unsigned int u32
Definition: types.h:88
ssvm_type
ssvm_segment_type_t ssvm_type(const ssvm_private_t *ssvm)
Definition: ssvm.c:451
app_worker_get
app_worker_t * app_worker_get(u32 wrk_index)
Definition: application_worker.c:41
app_worker_
Definition: application.h:32
segment_manager_del_sessions_filter
void segment_manager_del_sessions_filter(segment_manager_t *sm, session_state_t *states)
Initiate disconnects for sessions in specified state 'owned' by a segment manager.
Definition: segment_manager.c:634
vec_foreach
#define vec_foreach(var, vec)
Vector iterator.
Definition: vec_bootstrap.h:213
clib_mem_get_page_size
static_always_inline uword clib_mem_get_page_size(void)
Definition: mem.h:468
segment_manager_dealloc_queue
void segment_manager_dealloc_queue(segment_manager_t *sm, svm_queue_t *q)
Frees shm queue allocated in the first segment.
Definition: segment_manager.c:939
pool_elts
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:127
vlib_rpc_call_main_thread
void vlib_rpc_call_main_thread(void *callback, u8 *args, u32 arg_size)
Definition: threads.c:1637
application_name_from_index
const u8 * application_name_from_index(u32 app_index)
Returns app name for app-index.
Definition: application.c:386
segment_manager_main_init
void segment_manager_main_init(void)
Definition: segment_manager.c:960
fifo_segment_available_bytes
uword fifo_segment_available_bytes(fifo_segment_t *fs)
Definition: fifo_segment.c:1414
segment_manager_has_fifos
u8 segment_manager_has_fifos(segment_manager_t *sm)
Definition: segment_manager.c:552
fifo_segment_init
int fifo_segment_init(fifo_segment_t *fs)
Initialize fifo segment shared header.
Definition: fifo_segment.c:295
svm_msg_q_cfg_
Definition: message_queue.h:85
svm_msg_q_cfg_::consumer_pid
int consumer_pid
pid of msg consumer
Definition: message_queue.h:87
segment_manager_cleanup_detached_listener
void segment_manager_cleanup_detached_listener(segment_manager_t *sm)
Definition: segment_manager.c:441
clib_memset
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
vlib_main_t
Definition: main.h:102
vlib_get_main
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:38
pool_get_zero
#define pool_get_zero(P, E)
Allocate an object E from a pool P and zero it.
Definition: pool.h:258
u8
unsigned char u8
Definition: types.h:56
ssvm_private_t::name
u8 * name
Definition: ssvm.h:87
clib_error_t
Definition: clib_error.h:21
session.h
segment_manager_del_segment
void segment_manager_del_segment(segment_manager_t *sm, fifo_segment_t *fs)
Remove segment without lock.
Definition: segment_manager.c:188
pool_free
#define pool_free(p)
Free a pool.
Definition: pool.h:447
clib_warning
#define clib_warning(format, args...)
Definition: error.h:59
clib_rwlock_free
static void clib_rwlock_free(clib_rwlock_t *p)
Definition: lock.h:159
segment_manager_main_::default_max_fifo_size
u32 default_max_fifo_size
default max fifo size
Definition: segment_manager.c:31
session_cb_vft_::fifo_tuning_callback
int(* fifo_tuning_callback)(session_t *s, svm_fifo_t *f, session_ft_action_t act, u32 bytes)
Delegate fifo-tuning-logic to application.
Definition: application_interface.h:75
rv
int __clib_unused rv
Definition: application.c:491
application_::cb_fns
session_cb_vft_t cb_fns
Callbacks: shoulder-taps for the server/client.
Definition: application.h:117
application_::name
u8 * name
Name registered by builtin apps.
Definition: application.h:126
sm_main
static segment_manager_main_t sm_main
Definition: segment_manager.c:36
segment_manager_main_::seg_name_counter
u32 seg_name_counter
Counter for segment names.
Definition: segment_manager.c:23
app_worker_::app_index
u32 app_index
Index of owning app.
Definition: application.h:43
segment_manager_set_watermarks
void segment_manager_set_watermarks(segment_manager_t *sm, u8 high_watermark, u8 low_watermark)
Definition: segment_manager.c:1110
fifo_segment_prealloc_fifo_hdrs
int fifo_segment_prealloc_fifo_hdrs(fifo_segment_t *fs, u32 slice_index, u32 batch_size)
Try to preallocate fifo headers.
Definition: fifo_segment.c:1174
fifo_segment_t::h
fifo_segment_header_t * h
fifo segment data
Definition: fifo_segment.h:70
vlib_cli_command_t
Definition: cli.h:92
app_worker_::api_client_index
u32 api_client_index
API index for the worker.
Definition: application.h:60
fifo_segment_has_fifos
u8 fifo_segment_has_fifos(fifo_segment_t *fs)
Definition: fifo_segment.c:1437
segment_manager_foreach_segment_w_lock
#define segment_manager_foreach_segment_w_lock(VAR, SM, BODY)
Definition: segment_manager.c:38
fifo_segment_header_::flags
u8 flags
Segment flags.
Definition: fifo_types.h:143
fifo_segment_get_slice_fifo_list
svm_fifo_t * fifo_segment_get_slice_fifo_list(fifo_segment_t *fs, u32 slice_index)
Definition: fifo_segment.c:1443
session_::session_state
volatile u8 session_state
State in session layer state machine.
Definition: session_types.h:185
segment_manager_detach_fifo
void segment_manager_detach_fifo(segment_manager_t *sm, svm_fifo_t **f)
Definition: segment_manager.c:853
FIFO_SEGMENT_F_IS_PREALLOCATED
@ FIFO_SEGMENT_F_IS_PREALLOCATED
Definition: fifo_segment.h:38
segment_manager_try_alloc_fifos
int segment_manager_try_alloc_fifos(fifo_segment_t *fifo_segment, u32 thread_index, u32 rx_fifo_size, u32 tx_fifo_size, svm_fifo_t **rx_fifo, svm_fifo_t **tx_fifo)
Definition: segment_manager.c:683
fifo_segment_header_::pct_first_alloc
u8 pct_first_alloc
Pct of fifo size to alloc.
Definition: fifo_types.h:147
ssvm_shared_header_t
Definition: ssvm.h:55
UNFORMAT_END_OF_INPUT
#define UNFORMAT_END_OF_INPUT
Definition: format.h:137
segment_manager_attach_fifo
void segment_manager_attach_fifo(segment_manager_t *sm, svm_fifo_t **f, session_t *s)
Definition: segment_manager.c:863
fifo_segment_header_::high_watermark
u8 high_watermark
Memory pressure watermark high.
Definition: fifo_types.h:145
format_fifo_segment
format_function_t format_fifo_segment
Definition: fifo_segment.h:358
SEG_MANAGER_F_DETACHED
@ SEG_MANAGER_F_DETACHED
Definition: segment_manager.h:47
application.h
segment_manager_make_segment_handle
u64 segment_manager_make_segment_handle(u32 segment_manager_index, u32 segment_index)
Definition: segment_manager.c:268
app_worker_del_detached_sm
void app_worker_del_detached_sm(app_worker_t *app_wrk, u32 sm_index)
Definition: application_worker.c:237