FD.io VPP  v19.04.2-12-g66b1689
Vector Packet Processing
svm_fifo_segment.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2016-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 
16 #include <svm/svm_fifo_segment.h>
17 
18 static void
20  u32 data_size_in_bytes, int chunk_size)
21 {
22  int freelist_index;
23  u32 size;
24  u8 *fifo_space;
25  u32 rounded_data_size;
26  svm_fifo_t *f;
27  int i;
28 
29  rounded_data_size = (1 << (max_log2 (data_size_in_bytes)));
30  freelist_index = max_log2 (rounded_data_size)
32 
33  /* Calculate space requirement $$$ round-up data_size_in_bytes */
34  size = (sizeof (*f) + rounded_data_size) * chunk_size;
35 
36  /* Allocate fifo space. May fail. */
38  (size, CLIB_CACHE_LINE_BYTES, 0 /* align_offset */ ,
39  0 /* os_out_of_memory */ );
40 
41  /* Out of space.. */
42  if (fifo_space == 0)
43  return;
44 
45  /* Carve fifo space */
46  f = (svm_fifo_t *) fifo_space;
47  for (i = 0; i < chunk_size; i++)
48  {
49  f->freelist_index = freelist_index;
50  f->next = fsh->free_fifos[freelist_index];
51  fsh->free_fifos[freelist_index] = f;
52  fifo_space += sizeof (*f) + rounded_data_size;
53  f = (svm_fifo_t *) fifo_space;
54  }
55 }
56 
57 /**
58  * Pre-allocates fifo pairs in fifo segment
59  *
60  * The number of fifos pre-allocated is the minimum of the requested number
61  * of pairs and the maximum number that fit within the segment. If the maximum
62  * is hit, the number of fifo pairs requested is updated by subtracting the
63  * number of fifos that have been successfully allocated.
64  */
65 void
67  u32 rx_fifo_size, u32 tx_fifo_size,
68  u32 * n_fifo_pairs)
69 {
70  u32 rx_rounded_data_size, tx_rounded_data_size, pair_size;
71  u32 rx_fifos_size, tx_fifos_size, pairs_to_allocate;
72  int rx_freelist_index, tx_freelist_index;
73  ssvm_shared_header_t *sh = s->ssvm.sh;
74  svm_fifo_segment_header_t *fsh = s->h;
75  u8 *rx_fifo_space, *tx_fifo_space;
76  uword space_available;
77  void *oldheap;
78  svm_fifo_t *f;
79  int i;
80 
81  /* Parameter check */
82  if (rx_fifo_size == 0 || tx_fifo_size == 0 || *n_fifo_pairs == 0)
83  return;
84 
85  if (rx_fifo_size < FIFO_SEGMENT_MIN_FIFO_SIZE ||
86  rx_fifo_size > FIFO_SEGMENT_MAX_FIFO_SIZE)
87  {
88  clib_warning ("rx fifo_size out of range %d", rx_fifo_size);
89  return;
90  }
91 
92  if (tx_fifo_size < FIFO_SEGMENT_MIN_FIFO_SIZE ||
93  tx_fifo_size > FIFO_SEGMENT_MAX_FIFO_SIZE)
94  {
95  clib_warning ("tx fifo_size out of range %d", rx_fifo_size);
96  return;
97  }
98 
99  rx_rounded_data_size = (1 << (max_log2 (rx_fifo_size)));
100  rx_freelist_index = max_log2 (rx_fifo_size)
102  tx_rounded_data_size = (1 << (max_log2 (tx_fifo_size)));
103  tx_freelist_index = max_log2 (tx_fifo_size)
105 
106  /* Calculate space requirements */
107  pair_size = 2 * sizeof (*f) + rx_rounded_data_size + tx_rounded_data_size;
108 #if USE_DLMALLOC == 0
109  space_available = s->ssvm.ssvm_size - mheap_bytes (sh->heap);
110 #else
111  space_available = s->ssvm.ssvm_size - mspace_usable_size (sh->heap);
112 #endif
113 
114  pairs_to_allocate = clib_min (space_available / pair_size, *n_fifo_pairs);
115  rx_fifos_size = (sizeof (*f) + rx_rounded_data_size) * pairs_to_allocate;
116  tx_fifos_size = (sizeof (*f) + tx_rounded_data_size) * pairs_to_allocate;
117 
119  clib_max (rx_freelist_index, tx_freelist_index),
120  0);
121 
122  oldheap = ssvm_push_heap (sh);
123  /* Allocate rx fifo space. May fail. */
124  rx_fifo_space = clib_mem_alloc_aligned_at_offset
125  (rx_fifos_size, CLIB_CACHE_LINE_BYTES, 0 /* align_offset */ ,
126  0 /* os_out_of_memory */ );
127 
128  /* Same for TX */
129  tx_fifo_space = clib_mem_alloc_aligned_at_offset
130  (tx_fifos_size, CLIB_CACHE_LINE_BYTES, 0 /* align_offset */ ,
131  0 /* os_out_of_memory */ );
132 
133  /* Make sure it worked. Clean up if it didn't... */
134  if (rx_fifo_space == 0 || tx_fifo_space == 0)
135  {
136  if (rx_fifo_space)
137  clib_mem_free (rx_fifo_space);
138  else
139  clib_warning ("rx fifo preallocation failure: size %d npairs %d",
140  rx_fifo_size, *n_fifo_pairs);
141 
142  if (tx_fifo_space)
143  clib_mem_free (tx_fifo_space);
144  else
145  clib_warning ("tx fifo preallocation failure: size %d nfifos %d",
146  tx_fifo_size, *n_fifo_pairs);
147  ssvm_pop_heap (oldheap);
148  return;
149  }
150 
151  /* Carve rx fifo space */
152  f = (svm_fifo_t *) rx_fifo_space;
153  for (i = 0; i < pairs_to_allocate; i++)
154  {
155  f->freelist_index = rx_freelist_index;
156  f->next = fsh->free_fifos[rx_freelist_index];
157  fsh->free_fifos[rx_freelist_index] = f;
158  rx_fifo_space += sizeof (*f) + rx_rounded_data_size;
159  f = (svm_fifo_t *) rx_fifo_space;
160  }
161  /* Carve tx fifo space */
162  f = (svm_fifo_t *) tx_fifo_space;
163  for (i = 0; i < pairs_to_allocate; i++)
164  {
165  f->freelist_index = tx_freelist_index;
166  f->next = fsh->free_fifos[tx_freelist_index];
167  fsh->free_fifos[tx_freelist_index] = f;
168  tx_fifo_space += sizeof (*f) + tx_rounded_data_size;
169  f = (svm_fifo_t *) tx_fifo_space;
170  }
171 
172  /* Account for the pairs allocated */
173  *n_fifo_pairs -= pairs_to_allocate;
174  ssvm_pop_heap (oldheap);
175 }
176 
177 /**
178  * Initialize svm fifo segment shared header
179  */
180 int
182 {
185  void *oldheap;
186 
187  sh = s->ssvm.sh;
188  oldheap = ssvm_push_heap (sh);
189 
190  fsh = clib_mem_alloc (sizeof (*fsh));
191  clib_memset (fsh, 0, sizeof (*fsh));
192  s->h = sh->opaque[0] = fsh;
193 
194  ssvm_pop_heap (oldheap);
195 
196  sh->ready = 1;
197  return (0);
198 }
199 
200 /**
201  * Create an svm fifo segment and initialize as master
202  */
203 int
206 {
208  int rv;
209 
210  /* Allocate a fresh segment */
211  pool_get (sm->segments, s);
212  clib_memset (s, 0, sizeof (*s));
213 
214  s->ssvm.ssvm_size = a->segment_size;
215  s->ssvm.i_am_master = 1;
216  s->ssvm.my_pid = getpid ();
217  s->ssvm.name = format (0, "%s%c", a->segment_name, 0);
218  s->ssvm.requested_va = sm->next_baseva;
219 
220  if ((rv = ssvm_master_init (&s->ssvm, a->segment_type)))
221  {
222  pool_put (sm->segments, s);
223  return (rv);
224  }
225 
226  /* Note: requested_va updated due to seg base addr randomization */
227  sm->next_baseva = s->ssvm.sh->ssvm_va + a->segment_size;
228 
230  vec_add1 (a->new_segment_indices, s - sm->segments);
231  return (0);
232 }
233 
234 /**
235  * Create an svm fifo segment in process-private memory
236  */
237 int
240 {
243  u32 rnd_size = 0;
244  u8 *heap;
245  u32 pagesize = clib_mem_get_page_size ();
246 
247  pool_get (sm->segments, s);
248  clib_memset (s, 0, sizeof (*s));
249 
250  rnd_size = (a->segment_size + (pagesize - 1)) & ~pagesize;
251 
252 #if USE_DLMALLOC == 0
253  heap = mheap_alloc (0, rnd_size);
254  if (heap == 0)
255  {
256  clib_unix_warning ("mheap alloc");
257  pool_put (sm->segments, s);
258  return -1;
259  }
260  {
262  heap_header = mheap_header (heap);
263  heap_header->flags |= MHEAP_FLAG_THREAD_SAFE;
264  }
265 #else
266  heap = create_mspace (rnd_size, 1 /* locked */ );
267 #endif
268 
269  s->ssvm.ssvm_size = rnd_size;
270  s->ssvm.i_am_master = 1;
271  s->ssvm.my_pid = getpid ();
272  s->ssvm.name = format (0, "%s%c", a->segment_name, 0);
273  s->ssvm.requested_va = ~0;
274 
275  /* Allocate a [sic] shared memory header, in process memory... */
276  sh = clib_mem_alloc_aligned (sizeof (*sh), CLIB_CACHE_LINE_BYTES);
277  s->ssvm.sh = sh;
278 
279  clib_memset (sh, 0, sizeof (*sh));
280  sh->heap = heap;
281 
283  vec_add1 (a->new_segment_indices, s - sm->segments);
284 
285  return (0);
286 }
287 
288 /**
289  * Attach as slave to an svm fifo segment
290  */
291 int
294 {
296  int rv;
297 
298  /* Allocate a fresh segment */
299  pool_get (sm->segments, s);
300  clib_memset (s, 0, sizeof (*s));
301 
302  s->ssvm.ssvm_size = a->segment_size;
303  s->ssvm.my_pid = getpid ();
304  s->ssvm.name = format (0, "%s%c", a->segment_name, 0);
305  s->ssvm.requested_va = sm->next_baseva;
307  s->ssvm.fd = a->memfd_fd;
308  else
310 
311  if ((rv = ssvm_slave_init (&s->ssvm, a->segment_type)))
312  {
313  _vec_len (s) = vec_len (s) - 1;
314  return (rv);
315  }
316 
317  /* Fish the segment header */
318  s->h = s->ssvm.sh->opaque[0];
319 
320  vec_add1 (a->new_segment_indices, s - sm->segments);
321  return (0);
322 }
323 
324 void
327 {
328  ssvm_delete (&s->ssvm);
329  clib_memset (s, 0xfe, sizeof (*s));
330  pool_put (sm->segments, s);
331 }
332 
333 /**
334  * Allocate fifo in svm segment
335  */
336 svm_fifo_t *
338  u32 data_size_in_bytes,
339  svm_fifo_segment_freelist_t list_index)
340 {
343  svm_fifo_t *f = 0;
344  void *oldheap;
345  int freelist_index;
346 
347  /*
348  * 4K minimum. It's not likely that anything good will happen
349  * with a smaller FIFO.
350  */
351  if (data_size_in_bytes < FIFO_SEGMENT_MIN_FIFO_SIZE ||
352  data_size_in_bytes > FIFO_SEGMENT_MAX_FIFO_SIZE)
353  {
354  clib_warning ("fifo size out of range %d", data_size_in_bytes);
355  return 0;
356  }
357 
358  freelist_index = max_log2 (data_size_in_bytes)
360 
361  sh = fs->ssvm.sh;
362  ssvm_lock_non_recursive (sh, 1);
363  fsh = (svm_fifo_segment_header_t *) sh->opaque[0];
364 
365  switch (list_index)
366  {
369  vec_validate_init_empty (fsh->free_fifos, freelist_index, 0);
370  f = fsh->free_fifos[freelist_index];
371  if (PREDICT_FALSE (!f))
372  {
373  oldheap = ssvm_push_heap (sh);
374  allocate_new_fifo_chunk (fsh, data_size_in_bytes,
376  ssvm_pop_heap (oldheap);
377  f = fsh->free_fifos[freelist_index];
378  }
379  if (PREDICT_TRUE (f != 0))
380  {
381  fsh->free_fifos[freelist_index] = f->next;
382  /* (re)initialize the fifo, as in svm_fifo_create */
383  clib_memset (f, 0, sizeof (*f));
384  f->nitems = data_size_in_bytes;
385  f->ooos_list_head = OOO_SEGMENT_INVALID_INDEX;
386  f->ct_session_index = SVM_FIFO_INVALID_SESSION_INDEX;
387  f->refcnt = 1;
388  f->freelist_index = freelist_index;
389  goto found;
390  }
391  break;
393  break;
394 
395  default:
396  clib_warning ("ignore bogus freelist %d", list_index);
397  break;
398  }
399 
400  /* Catch all that allocates just one fifo. Note: this can fail,
401  * in which case: create another segment */
402  oldheap = ssvm_push_heap (sh);
403  f = svm_fifo_create (data_size_in_bytes);
404  ssvm_pop_heap (oldheap);
405  if (PREDICT_FALSE (f == 0))
406  goto done;
407  f->freelist_index = freelist_index;
408 
409 found:
410  /* If rx_freelist add to active fifos list. When cleaning up segment,
411  * we need a list of active sessions that should be disconnected. Since
412  * both rx and tx fifos keep pointers to the session, it's enough to track
413  * only one. */
414  if (list_index == FIFO_SEGMENT_RX_FREELIST)
415  {
416  if (fsh->fifos)
417  {
418  fsh->fifos->prev = f;
419  f->next = fsh->fifos;
420  }
421  fsh->fifos = f;
422  }
423  fsh->n_active_fifos++;
424 
425 done:
427  return (f);
428 }
429 
430 void
432  svm_fifo_segment_freelist_t list_index)
433 {
436  int freelist_index;
437 
438  ASSERT (f->refcnt > 0);
439 
440  if (--f->refcnt > 0)
441  return;
442 
443  sh = s->ssvm.sh;
444  fsh = (svm_fifo_segment_header_t *) sh->opaque[0];
445 
446  freelist_index = f->freelist_index;
447 
448  ASSERT (freelist_index < vec_len (fsh->free_fifos));
449 
450  ssvm_lock_non_recursive (sh, 2);
451 
452  switch (list_index)
453  {
455  /* Remove from active list */
456  if (f->prev)
457  f->prev->next = f->next;
458  else
459  fsh->fifos = f->next;
460  if (f->next)
461  f->next->prev = f->prev;
462  /* Fall through: we add only rx fifos to active pool */
464  /* Add to free list */
465  f->next = fsh->free_fifos[freelist_index];
466  f->prev = 0;
467  fsh->free_fifos[freelist_index] = f;
468  break;
470  break;
471 
472  default:
473  clib_warning ("ignore bogus freelist %d", list_index);
474  break;
475  }
476 
477  if (CLIB_DEBUG)
478  {
479  f->master_session_index = ~0;
480  f->master_thread_index = ~0;
481  }
482 
483  fsh->n_active_fifos--;
485 }
486 
487 void
489  u32 timeout_in_seconds)
490 {
491  sm->next_baseva = baseva;
492  sm->timeout_in_seconds = timeout_in_seconds;
493 }
494 
495 u32
498 {
499  return s - sm->segments;
500 }
501 
502 /**
503  * Retrieve svm segments pool. Used only for debug purposes.
504  */
507 {
508  return sm->segments;
509 }
510 
511 /**
512  * Get number of active fifos
513  */
514 u32
516 {
517  return fifo_segment->h->n_active_fifos;
518 }
519 
520 u32
522  u32 fifo_size_in_bytes)
523 {
526  svm_fifo_t *f;
527  int i;
528  u32 count = 0, rounded_data_size, freelist_index;
529 
530  sh = fifo_segment->ssvm.sh;
531  fsh = (svm_fifo_segment_header_t *) sh->opaque[0];
532 
533  /* Count all free fifos? */
534  if (fifo_size_in_bytes == ~0)
535  {
536  for (i = 0; i < vec_len (fsh->free_fifos); i++)
537  {
538  f = fsh->free_fifos[i];
539  if (f == 0)
540  continue;
541 
542  while (f)
543  {
544  f = f->next;
545  count++;
546  }
547  }
548  return count;
549  }
550 
551  rounded_data_size = (1 << (max_log2 (fifo_size_in_bytes)));
552  freelist_index = max_log2 (rounded_data_size)
554 
555  if (freelist_index >= vec_len (fsh->free_fifos))
556  return 0;
557 
558  f = fsh->free_fifos[freelist_index];
559  if (f == 0)
560  return 0;
561 
562  while (f)
563  {
564  f = f->next;
565  count++;
566  }
567  return count;
568 }
569 
570 void
572  size_t * size)
573 {
574  if (ssvm_type (&seg->ssvm) == SSVM_SEGMENT_PRIVATE)
575  {
576 #if USE_DLMALLOC == 0
578 
579  *address = pointer_to_uword (seg->ssvm.sh->heap);
580  heap_header = mheap_header (seg->ssvm.sh->heap);
581  *size = heap_header->max_size;
582 #else
583  mspace_get_address_and_size (seg->ssvm.sh->heap, address, size);
584 #endif
585  }
586  else
587  {
588  *address = (char *) seg->ssvm.sh->ssvm_va;
589  *size = seg->ssvm.ssvm_size;
590  }
591 }
592 
593 void *
595 {
596  return seg->ssvm.sh->heap;
597 }
598 
599 u8 *
600 format_svm_fifo_segment_type (u8 * s, va_list * args)
601 {
603  sp = va_arg (*args, svm_fifo_segment_private_t *);
604  ssvm_segment_type_t st = ssvm_type (&sp->ssvm);
605 
606  if (st == SSVM_SEGMENT_PRIVATE)
607  s = format (s, "%s", "private-heap");
608  else if (st == SSVM_SEGMENT_MEMFD)
609  s = format (s, "%s", "memfd");
610  else if (st == SSVM_SEGMENT_SHM)
611  s = format (s, "%s", "shm");
612  else
613  s = format (s, "%s", "unknown");
614  return s;
615 }
616 
617 /**
618  * Segment format function
619  */
620 u8 *
621 format_svm_fifo_segment (u8 * s, va_list * args)
622 {
624  = va_arg (*args, svm_fifo_segment_private_t *);
625  int verbose __attribute__ ((unused)) = va_arg (*args, int);
626  svm_fifo_segment_header_t *fsh = sp->h;
627  u32 count, indent;
628  svm_fifo_t *f;
629  int i;
630 
631  indent = format_get_indent (s) + 2;
632 #if USE_DLMALLOC == 0
633  s = format (s, "%U segment heap: %U\n", format_white_space, indent,
634  format_mheap, svm_fifo_segment_heap (sp), verbose);
635  s = format (s, "%U segment has %u active fifos\n",
637 #endif
638 
639  for (i = 0; i < vec_len (fsh->free_fifos); i++)
640  {
641  f = fsh->free_fifos[i];
642  if (f == 0)
643  continue;
644  count = 0;
645  while (f)
646  {
647  f = f->next;
648  count++;
649  }
650 
651  s = format (s, "%U%-5u Kb: %u free",
652  format_white_space, indent + 2,
653  1 << (i + max_log2 (FIFO_SEGMENT_MIN_FIFO_SIZE) - 10),
654  count);
655  }
656  return s;
657 }
658 
659 /*
660  * fd.io coding-style-patch-verification: ON
661  *
662  * Local Variables:
663  * eval: (c-set-style "gnu")
664  * End:
665  */
u64 ssvm_size
Definition: ssvm.h:84
void svm_fifo_segment_info(svm_fifo_segment_private_t *seg, char **address, size_t *size)
typedef address
Definition: ip_types.api:30
#define clib_min(x, y)
Definition: clib.h:295
uword requested_va
Definition: ssvm.h:87
static void * clib_mem_alloc_aligned_at_offset(uword size, uword align, uword align_offset, int os_out_of_memory_on_failure)
Definition: mem.h:81
a
Definition: bitmap.h:538
#define PREDICT_TRUE(x)
Definition: clib.h:112
volatile u32 ready
Definition: ssvm.h:76
unsigned long u64
Definition: types.h:89
void * mheap_alloc(void *memory, uword size)
Definition: mheap.c:963
svm_fifo_segment_freelist_t
void * opaque[SSVM_N_OPAQUE]
Definition: ssvm.h:73
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:522
int i
static mheap_t * mheap_header(u8 *v)
static u32 format_get_indent(u8 *s)
Definition: format.h:72
clib_memset(h->entries, 0, sizeof(h->entries[0])*entries)
ssvm_shared_header_t * sh
Definition: ssvm.h:83
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
#define MHEAP_FLAG_THREAD_SAFE
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:236
void svm_fifo_segment_preallocate_fifo_pairs(svm_fifo_segment_private_t *s, u32 rx_fifo_size, u32 tx_fifo_size, u32 *n_fifo_pairs)
Pre-allocates fifo pairs in fifo segment.
unsigned char u8
Definition: types.h:56
void ssvm_delete(ssvm_private_t *ssvm)
Definition: ssvm.c:423
struct _svm_fifo svm_fifo_t
enum ssvm_segment_type_ ssvm_segment_type_t
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:113
static void * ssvm_push_heap(ssvm_shared_header_t *sh)
Definition: ssvm.h:144
unsigned int u32
Definition: types.h:88
int attach_timeout
shm segments attach timeout (sec)
Definition: ssvm.h:93
int ssvm_master_init(ssvm_private_t *ssvm, ssvm_segment_type_t type)
Definition: ssvm.c:411
static void ssvm_pop_heap(void *oldheap)
Definition: ssvm.h:152
#define FIFO_SEGMENT_MIN_FIFO_SIZE
ssvm_segment_type_t segment_type
u8 * format_svm_fifo_segment_type(u8 *s, va_list *args)
u8 * format_mheap(u8 *s, va_list *va)
Definition: mem_dlmalloc.c:354
u32 svm_fifo_segment_num_fifos(svm_fifo_segment_private_t *fifo_segment)
Get number of active fifos.
uword size
uword clib_mem_get_page_size(void)
Definition: mem.c:51
svm_fifo_t * fifos
Linked list of active RX fifos.
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:286
svm_fifo_t ** free_fifos
Freelists, by fifo size.
#define PREDICT_FALSE(x)
Definition: clib.h:111
svm_fifo_segment_header_t * h
#define FIFO_SEGMENT_ALLOC_CHUNK_SIZE
int svm_fifo_segment_attach(svm_fifo_segment_main_t *sm, svm_fifo_segment_create_args_t *a)
Attach as slave to an svm fifo segment.
void svm_fifo_segment_delete(svm_fifo_segment_main_t *sm, svm_fifo_segment_private_t *s)
DLMALLOC_EXPORT mspace create_mspace(size_t capacity, int locked)
DLMALLOC_EXPORT void mspace_get_address_and_size(mspace msp, char **addrp, size_t *sizep)
u32 n_active_fifos
Number of active fifos.
int svm_fifo_segment_create_process_private(svm_fifo_segment_main_t *sm, svm_fifo_segment_create_args_t *a)
Create an svm fifo segment in process-private memory.
#define clib_warning(format, args...)
Definition: error.h:59
static void allocate_new_fifo_chunk(svm_fifo_segment_header_t *fsh, u32 data_size_in_bytes, int chunk_size)
int ssvm_slave_init(ssvm_private_t *ssvm, ssvm_segment_type_t type)
Definition: ssvm.c:417
u32 my_pid
Definition: ssvm.h:85
#define OOO_SEGMENT_INVALID_INDEX
Definition: svm_fifo.h:40
int fd
memfd segments
Definition: ssvm.h:92
#define FIFO_SEGMENT_MAX_FIFO_SIZE
int svm_fifo_segment_create(svm_fifo_segment_main_t *sm, svm_fifo_segment_create_args_t *a)
Create an svm fifo segment and initialize as master.
#define ASSERT(truth)
void * svm_fifo_segment_heap(svm_fifo_segment_private_t *seg)
u32 svm_fifo_segment_index(svm_fifo_segment_main_t *sm, svm_fifo_segment_private_t *s)
static void clib_mem_free(void *p)
Definition: mem.h:205
svm_fifo_t * svm_fifo_segment_alloc_fifo(svm_fifo_segment_private_t *fs, u32 data_size_in_bytes, svm_fifo_segment_freelist_t list_index)
Allocate fifo in svm segment.
size_t count
Definition: vapi.c:47
static heap_header_t * heap_header(void *v)
Definition: heap.h:161
static void * clib_mem_alloc(uword size)
Definition: mem.h:132
static uword pointer_to_uword(const void *p)
Definition: types.h:131
void svm_fifo_segment_free_fifo(svm_fifo_segment_private_t *s, svm_fifo_t *f, svm_fifo_segment_freelist_t list_index)
#define clib_max(x, y)
Definition: clib.h:288
u8 * name
Definition: ssvm.h:86
uword mheap_bytes(void *v)
Definition: mheap.c:1069
DLMALLOC_EXPORT size_t mspace_usable_size(const void *mem)
svm_fifo_segment_private_t * segments
pool of segments
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
static uword max_log2(uword x)
Definition: clib.h:191
u64 uword
Definition: types.h:112
#define clib_unix_warning(format, args...)
Definition: error.h:68
int svm_fifo_segment_init(svm_fifo_segment_private_t *s)
Initialize svm fifo segment shared header.
static void * clib_mem_alloc_aligned(uword size, uword align)
Definition: mem.h:140
u32 svm_fifo_segment_num_free_fifos(svm_fifo_segment_private_t *fifo_segment, u32 fifo_size_in_bytes)
#define SVM_FIFO_INVALID_SESSION_INDEX
Definition: svm_fifo.h:41
static void ssvm_unlock_non_recursive(ssvm_shared_header_t *h)
Definition: ssvm.h:136
void svm_fifo_segment_main_init(svm_fifo_segment_main_t *sm, u64 baseva, u32 timeout_in_seconds)
#define vec_validate_init_empty(V, I, INIT)
Make sure vector is long enough for given index and initialize empty space (no header, unspecified alignment)
Definition: vec.h:486
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:59
u8 * format_svm_fifo_segment(u8 *s, va_list *args)
Segment format function.
svm_fifo_segment_private_t * svm_fifo_segment_segments_pool(svm_fifo_segment_main_t *sm)
Retrieve svm segments pool.
int i_am_master
Definition: ssvm.h:88
static void ssvm_lock_non_recursive(ssvm_shared_header_t *h, u32 tag)
Definition: ssvm.h:115
ssvm_segment_type_t ssvm_type(const ssvm_private_t *ssvm)
Definition: ssvm.c:429
svm_fifo_t * svm_fifo_create(u32 data_size_in_bytes)
create an svm fifo, in the current heap.
Definition: svm_fifo.c:205