src/vnet/session/segment_manager.c

   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
  16 #include <vnet/session/segment_manager.h>
  17 #include <vnet/session/session.h>
  18 #include <vnet/session/application.h>
  19
  20 segment_manager_main_t segment_manager_main;
  21
  22 /**
  23  * Counter used to build segment names
  24  */
  25 static u32 segment_name_counter = 0;
  26
  27 /**
  28  * Default fifo and segment size. TODO config.
  29  */
  30 static u32 default_fifo_size = 1 << 12;
  31 static u32 default_segment_size = 1 << 20;
  32 static u32 default_app_evt_queue_size = 128;
  33
  34 segment_manager_properties_t *
  35 segment_manager_properties_get (segment_manager_t * sm)
  36 {
  37   app_worker_t *app_wrk = app_worker_get (sm->app_wrk_index);
  38   return application_get_segment_manager_properties (app_wrk->app_index);
  39 }
  40
  41 segment_manager_properties_t *
  42 segment_manager_properties_init (segment_manager_properties_t * props)
  43 {
  44   props->add_segment_size = default_segment_size;
  45   props->rx_fifo_size = default_fifo_size;
  46   props->tx_fifo_size = default_fifo_size;
  47   props->evt_q_size = default_app_evt_queue_size;
  48   return props;
  49 }
  50
  51 static u8
  52 segment_manager_app_detached (segment_manager_t * sm)
  53 {
  54   return (sm->app_wrk_index == SEGMENT_MANAGER_INVALID_APP_INDEX);
  55 }
  56
  57 void
  58 segment_manager_app_detach (segment_manager_t * sm)
  59 {
  60   sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
  61 }
  62
  63 always_inline u32
  64 segment_manager_segment_index (segment_manager_t * sm,
  65                                svm_fifo_segment_private_t * seg)
  66 {
  67   return (seg - sm->segments);
  68 }
  69
  70 /**
  71  * Remove segment without lock
  72  */
  73 void
  74 segment_manager_del_segment (segment_manager_t * sm,
  75                              svm_fifo_segment_private_t * fs)
  76 {
  77   segment_manager_main_t *smm = &segment_manager_main;
  78
  79   if (ssvm_type (&fs->ssvm) != SSVM_SEGMENT_PRIVATE)
  80     clib_valloc_free (&smm->va_allocator, fs->ssvm.requested_va);
  81
  82   ssvm_delete (&fs->ssvm);
  83
  84   if (CLIB_DEBUG)
  85     clib_memset (fs, 0xfb, sizeof (*fs));
  86   pool_put (sm->segments, fs);
  87 }
  88
  89 /**
  90  * Removes segment after acquiring writer lock
  91  */
  92 static inline void
  93 segment_manager_lock_and_del_segment (segment_manager_t * sm, u32 fs_index)
  94 {
  95   svm_fifo_segment_private_t *fs;
  96   u8 is_prealloc;
  97
  98   clib_rwlock_writer_lock (&sm->segments_rwlock);
  99   fs = segment_manager_get_segment (sm, fs_index);
 100   is_prealloc = svm_fifo_segment_flags (fs) & FIFO_SEGMENT_F_IS_PREALLOCATED;
 101   if (is_prealloc && !segment_manager_app_detached (sm))
 102     {
 103       clib_rwlock_writer_unlock (&sm->segments_rwlock);
 104       return;
 105     }
 106
 107   segment_manager_del_segment (sm, fs);
 108   clib_rwlock_writer_unlock (&sm->segments_rwlock);
 109 }
 110
 111 /**
 112  * Reads a segment from the segment manager's pool without lock
 113  */
 114 svm_fifo_segment_private_t *
 115 segment_manager_get_segment (segment_manager_t * sm, u32 segment_index)
 116 {
 117   return pool_elt_at_index (sm->segments, segment_index);
 118 }
 119
 120 u64
 121 segment_manager_segment_handle (segment_manager_t * sm,
 122                                 svm_fifo_segment_private_t * segment)
 123 {
 124   u32 segment_index = segment_manager_segment_index (sm, segment);
 125   return (((u64) segment_manager_index (sm) << 32) | segment_index);
 126 }
 127
 128 void
 129 segment_manager_parse_segment_handle (u64 segment_handle, u32 * sm_index,
 130                                       u32 * segment_index)
 131 {
 132   *sm_index = segment_handle >> 32;
 133   *segment_index = segment_handle & 0xFFFFFFFF;
 134 }
 135
 136 svm_fifo_segment_private_t *
 137 segment_manager_get_segment_w_handle (u64 segment_handle)
 138 {
 139   u32 sm_index, segment_index;
 140   segment_manager_t *sm;
 141
 142   segment_manager_parse_segment_handle (segment_handle, &sm_index,
 143                                         &segment_index);
 144   sm = segment_manager_get (sm_index);
 145   if (!sm || pool_is_free_index (sm->segments, segment_index))
 146     return 0;
 147   return pool_elt_at_index (sm->segments, segment_index);
 148 }
 149
 150 /**
 151  * Reads a segment from the segment manager's pool and acquires reader lock
 152  *
 153  * Caller must drop the reader's lock by calling
 154  * @ref segment_manager_segment_reader_unlock once it finishes working with
 155  * the segment.
 156  */
 157 svm_fifo_segment_private_t *
 158 segment_manager_get_segment_w_lock (segment_manager_t * sm, u32 segment_index)
 159 {
 160   clib_rwlock_reader_lock (&sm->segments_rwlock);
 161   return pool_elt_at_index (sm->segments, segment_index);
 162 }
 163
 164 void
 165 segment_manager_segment_reader_unlock (segment_manager_t * sm)
 166 {
 167   ASSERT (sm->segments_rwlock->n_readers > 0);
 168   clib_rwlock_reader_unlock (&sm->segments_rwlock);
 169 }
 170
 171 void
 172 segment_manager_segment_writer_unlock (segment_manager_t * sm)
 173 {
 174   clib_rwlock_writer_unlock (&sm->segments_rwlock);
 175 }
 176
 177 /**
 178  * Adds segment to segment manager's pool
 179  *
 180  * If needed a writer's lock is acquired before allocating a new segment
 181  * to avoid affecting any of the segments pool readers.
 182  */
 183 int
 184 segment_manager_add_segment (segment_manager_t * sm, u32 segment_size)
 185 {
 186   segment_manager_main_t *smm = &segment_manager_main;
 187   u32 rnd_margin = 128 << 10, seg_index, page_size;
 188   segment_manager_properties_t *props;
 189   uword baseva = (uword) ~ 0ULL, alloc_size;
 190   svm_fifo_segment_private_t *seg;
 191   u8 *seg_name;
 192   int rv;
 193
 194   props = segment_manager_properties_get (sm);
 195
 196   /* Not configured for addition of new segments and not first */
 197   if (!props->add_segment && !segment_size)
 198     {
 199       clib_warning ("cannot allocate new segment");
 200       return VNET_API_ERROR_INVALID_VALUE;
 201     }
 202
 203   /*
 204    * Allocate fifo segment and lock if needed
 205    */
 206   if (vlib_num_workers ())
 207     {
 208       clib_rwlock_writer_lock (&sm->segments_rwlock);
 209       pool_get (sm->segments, seg);
 210     }
 211   else
 212     {
 213       pool_get (sm->segments, seg);
 214     }
 215   clib_memset (seg, 0, sizeof (*seg));
 216
 217   /*
 218    * Initialize ssvm segment and svm fifo private header
 219    */
 220   segment_size = segment_size ? segment_size : props->add_segment_size;
 221   page_size = clib_mem_get_page_size ();
 222   segment_size = (segment_size + page_size - 1) & ~(page_size - 1);
 223   if (props->segment_type != SSVM_SEGMENT_PRIVATE)
 224     {
 225       seg_name = format (0, "%d-%d%c", getpid (), segment_name_counter++, 0);
 226       alloc_size = (uword) segment_size + rnd_margin;
 227       baseva = clib_valloc_alloc (&smm->va_allocator, alloc_size, 0);
 228       if (!baseva)
 229         {
 230           clib_warning ("out of space for segments");
 231           return -1;
 232         }
 233     }
 234   else
 235     seg_name = format (0, "%s%c", "process-private-segment", 0);
 236
 237   seg->ssvm.ssvm_size = segment_size;
 238   seg->ssvm.name = seg_name;
 239   seg->ssvm.requested_va = baseva;
 240
 241   if ((rv = ssvm_master_init (&seg->ssvm, props->segment_type)))
 242     {
 243       clib_warning ("svm_master_init ('%v', %u) failed", seg_name,
 244                     segment_size);
 245
 246       if (props->segment_type != SSVM_SEGMENT_PRIVATE)
 247         clib_valloc_free (&smm->va_allocator, baseva);
 248       pool_put (sm->segments, seg);
 249       return (rv);
 250     }
 251
 252   svm_fifo_segment_init (seg);
 253
 254   /*
 255    * Save segment index before dropping lock, if any held
 256    */
 257   seg_index = seg - sm->segments;
 258
 259   if (vlib_num_workers ())
 260     clib_rwlock_writer_unlock (&sm->segments_rwlock);
 261
 262   return seg_index;
 263 }
 264
 265 segment_manager_t *
 266 segment_manager_new ()
 267 {
 268   segment_manager_main_t *smm = &segment_manager_main;
 269   segment_manager_t *sm;
 270   pool_get (smm->segment_managers, sm);
 271   clib_memset (sm, 0, sizeof (*sm));
 272   clib_rwlock_init (&sm->segments_rwlock);
 273   return sm;
 274 }
 275
 276 /**
 277  * Initializes segment manager based on options provided.
 278  * Returns error if ssvm segment(s) allocation fails.
 279  */
 280 int
 281 segment_manager_init (segment_manager_t * sm, u32 first_seg_size,
 282                       u32 prealloc_fifo_pairs)
 283 {
 284   u32 rx_fifo_size, tx_fifo_size, pair_size;
 285   u32 rx_rounded_data_size, tx_rounded_data_size;
 286   u64 approx_total_size, max_seg_size = ((u64) 1 << 32) - (128 << 10);
 287   segment_manager_properties_t *props;
 288   svm_fifo_segment_private_t *segment;
 289   u32 approx_segment_count;
 290   int seg_index, i;
 291
 292   props = segment_manager_properties_get (sm);
 293   first_seg_size = clib_max (first_seg_size, default_segment_size);
 294
 295   if (prealloc_fifo_pairs)
 296     {
 297       /* Figure out how many segments should be preallocated */
 298       rx_rounded_data_size = (1 << (max_log2 (props->rx_fifo_size)));
 299       tx_rounded_data_size = (1 << (max_log2 (props->tx_fifo_size)));
 300
 301       rx_fifo_size = sizeof (svm_fifo_t) + rx_rounded_data_size;
 302       tx_fifo_size = sizeof (svm_fifo_t) + tx_rounded_data_size;
 303       pair_size = rx_fifo_size + tx_fifo_size;
 304
 305       approx_total_size = (u64) prealloc_fifo_pairs *pair_size;
 306       if (first_seg_size > approx_total_size)
 307         max_seg_size = first_seg_size;
 308       approx_segment_count = (approx_total_size + (max_seg_size - 1))
 309         / max_seg_size;
 310
 311       /* Allocate the segments */
 312       for (i = 0; i < approx_segment_count + 1; i++)
 313         {
 314           seg_index = segment_manager_add_segment (sm, max_seg_size);
 315           if (seg_index < 0)
 316             {
 317               clib_warning ("Failed to preallocate segment %d", i);
 318               return seg_index;
 319             }
 320
 321           segment = segment_manager_get_segment (sm, seg_index);
 322           if (i == 0)
 323             sm->event_queue = segment_manager_alloc_queue (segment, props);
 324
 325           svm_fifo_segment_preallocate_fifo_pairs (segment,
 326                                                    props->rx_fifo_size,
 327                                                    props->tx_fifo_size,
 328                                                    &prealloc_fifo_pairs);
 329           svm_fifo_segment_flags (segment) = FIFO_SEGMENT_F_IS_PREALLOCATED;
 330           if (prealloc_fifo_pairs == 0)
 331             break;
 332         }
 333     }
 334   else
 335     {
 336       seg_index = segment_manager_add_segment (sm, first_seg_size);
 337       if (seg_index)
 338         {
 339           clib_warning ("Failed to allocate segment");
 340           return seg_index;
 341         }
 342       segment = segment_manager_get_segment (sm, seg_index);
 343       sm->event_queue = segment_manager_alloc_queue (segment, props);
 344     }
 345
 346   return 0;
 347 }
 348
 349 u8
 350 segment_manager_has_fifos (segment_manager_t * sm)
 351 {
 352   svm_fifo_segment_private_t *seg;
 353   u8 first = 1;
 354
 355   /* *INDENT-OFF* */
 356   segment_manager_foreach_segment_w_lock (seg, sm, ({
 357     if (CLIB_DEBUG && !first && !svm_fifo_segment_has_fifos (seg)
 358         && !(svm_fifo_segment_flags (seg) & FIFO_SEGMENT_F_IS_PREALLOCATED))
 359       {
 360         clib_warning ("segment %d has no fifos!",
 361                       segment_manager_segment_index (sm, seg));
 362         first = 0;
 363       }
 364     if (svm_fifo_segment_has_fifos (seg))
 365       {
 366         segment_manager_segment_reader_unlock (sm);
 367         return 1;
 368       }
 369   }));
 370   /* *INDENT-ON* */
 371
 372   return 0;
 373 }
 374
 375 /**
 376  * Initiate disconnects for all sessions 'owned' by a segment manager
 377  */
 378 void
 379 segment_manager_del_sessions (segment_manager_t * sm)
 380 {
 381   svm_fifo_segment_private_t *fifo_segment;
 382   session_handle_t *handles = 0, *handle;
 383   session_t *session;
 384   svm_fifo_t *fifo;
 385
 386   ASSERT (pool_elts (sm->segments) != 0);
 387
 388   /* Across all fifo segments used by the server */
 389   /* *INDENT-OFF* */
 390   segment_manager_foreach_segment_w_lock (fifo_segment, sm, ({
 391     fifo = svm_fifo_segment_get_fifo_list (fifo_segment);
 392
 393     /*
 394      * Remove any residual sessions from the session lookup table
 395      * Don't bother deleting the individual fifos, we're going to
 396      * throw away the fifo segment in a minute.
 397      */
 398     while (fifo)
 399       {
 400         if (fifo->ct_session_index != SVM_FIFO_INVALID_SESSION_INDEX)
 401           session = session_get (fifo->ct_session_index, 0);
 402         else
 403           session = session_get (fifo->master_session_index,
 404                                  fifo->master_thread_index);
 405         vec_add1 (handles, session_handle (session));
 406         fifo = fifo->next;
 407       }
 408
 409     /* Instead of removing the segment, test when cleaning up disconnected
 410      * sessions if the segment can be removed.
 411      */
 412   }));
 413   /* *INDENT-ON* */
 414
 415   vec_foreach (handle, handles)
 416     session_close (session_get_from_handle (*handle));
 417 }
 418
 419 /**
 420  * Removes segment manager.
 421  *
 422  * Since the fifos allocated in the segment keep backpointers to the sessions
 423  * prior to removing the segment, we call session disconnect. This
 424  * subsequently propagates into transport.
 425  */
 426 void
 427 segment_manager_del (segment_manager_t * sm)
 428 {
 429   segment_manager_main_t *smm = &segment_manager_main;
 430   svm_fifo_segment_private_t *fifo_segment;
 431
 432   ASSERT (!segment_manager_has_fifos (sm)
 433           && segment_manager_app_detached (sm));
 434
 435   /* If we have empty preallocated segments that haven't been removed, remove
 436    * them now. Apart from that, the first segment in the first segment manager
 437    * is not removed when all fifos are removed. It can only be removed when
 438    * the manager is explicitly deleted/detached by the app. */
 439   clib_rwlock_writer_lock (&sm->segments_rwlock);
 440
 441   /* *INDENT-OFF* */
 442   pool_foreach (fifo_segment, sm->segments, ({
 443     segment_manager_del_segment (sm, fifo_segment);
 444   }));
 445   /* *INDENT-ON* */
 446
 447   clib_rwlock_writer_unlock (&sm->segments_rwlock);
 448
 449   clib_rwlock_free (&sm->segments_rwlock);
 450   if (CLIB_DEBUG)
 451     clib_memset (sm, 0xfe, sizeof (*sm));
 452   pool_put (smm->segment_managers, sm);
 453 }
 454
 455 void
 456 segment_manager_init_del (segment_manager_t * sm)
 457 {
 458   segment_manager_app_detach (sm);
 459   if (segment_manager_has_fifos (sm))
 460     segment_manager_del_sessions (sm);
 461   else
 462     {
 463       ASSERT (!sm->first_is_protected || segment_manager_app_detached (sm));
 464       segment_manager_del (sm);
 465     }
 466 }
 467
 468 int
 469 segment_manager_try_alloc_fifos (svm_fifo_segment_private_t * fifo_segment,
 470                                  u32 rx_fifo_size, u32 tx_fifo_size,
 471                                  svm_fifo_t ** rx_fifo, svm_fifo_t ** tx_fifo)
 472 {
 473   rx_fifo_size = clib_max (rx_fifo_size, default_fifo_size);
 474   *rx_fifo = svm_fifo_segment_alloc_fifo (fifo_segment, rx_fifo_size,
 475                                           FIFO_SEGMENT_RX_FREELIST);
 476
 477   tx_fifo_size = clib_max (tx_fifo_size, default_fifo_size);
 478   *tx_fifo = svm_fifo_segment_alloc_fifo (fifo_segment, tx_fifo_size,
 479                                           FIFO_SEGMENT_TX_FREELIST);
 480
 481   if (*rx_fifo == 0)
 482     {
 483       /* This would be very odd, but handle it... */
 484       if (*tx_fifo != 0)
 485         {
 486           svm_fifo_segment_free_fifo (fifo_segment, *tx_fifo,
 487                                       FIFO_SEGMENT_TX_FREELIST);
 488           *tx_fifo = 0;
 489         }
 490       return -1;
 491     }
 492   if (*tx_fifo == 0)
 493     {
 494       if (*rx_fifo != 0)
 495         {
 496           svm_fifo_segment_free_fifo (fifo_segment, *rx_fifo,
 497                                       FIFO_SEGMENT_RX_FREELIST);
 498           *rx_fifo = 0;
 499         }
 500       return -1;
 501     }
 502
 503   return 0;
 504 }
 505
 506 int
 507 segment_manager_alloc_session_fifos (segment_manager_t * sm,
 508                                      svm_fifo_t ** rx_fifo,
 509                                      svm_fifo_t ** tx_fifo,
 510                                      u32 * fifo_segment_index)
 511 {
 512   svm_fifo_segment_private_t *fifo_segment = 0;
 513   int alloc_fail = 1, rv = 0, new_fs_index;
 514   segment_manager_properties_t *props;
 515   u8 added_a_segment = 0;
 516   u64 segment_handle;
 517   u32 sm_index;
 518
 519   props = segment_manager_properties_get (sm);
 520
 521   /*
 522    * Find the first free segment to allocate the fifos in
 523    */
 524
 525   /* *INDENT-OFF* */
 526   segment_manager_foreach_segment_w_lock (fifo_segment, sm, ({
 527     alloc_fail = segment_manager_try_alloc_fifos (fifo_segment,
 528                                                   props->rx_fifo_size,
 529                                                   props->tx_fifo_size,
 530                                                   rx_fifo, tx_fifo);
 531     /* Exit with lock held, drop it after notifying app */
 532     if (!alloc_fail)
 533       goto alloc_success;
 534   }));
 535   /* *INDENT-ON* */
 536
 537 alloc_check:
 538
 539   if (!alloc_fail)
 540     {
 541
 542     alloc_success:
 543
 544       ASSERT (rx_fifo && tx_fifo);
 545       sm_index = segment_manager_index (sm);
 546       *fifo_segment_index = segment_manager_segment_index (sm, fifo_segment);
 547       (*tx_fifo)->segment_manager = sm_index;
 548       (*rx_fifo)->segment_manager = sm_index;
 549       (*tx_fifo)->segment_index = *fifo_segment_index;
 550       (*rx_fifo)->segment_index = *fifo_segment_index;
 551
 552       if (added_a_segment)
 553         {
 554           app_worker_t *app_wrk;
 555           segment_handle = segment_manager_segment_handle (sm, fifo_segment);
 556           app_wrk = app_worker_get (sm->app_wrk_index);
 557           rv = app_worker_add_segment_notify (app_wrk, segment_handle);
 558         }
 559       /* Drop the lock after app is notified */
 560       segment_manager_segment_reader_unlock (sm);
 561       return rv;
 562     }
 563
 564   /*
 565    * Allocation failed, see if we can add a new segment
 566    */
 567   if (props->add_segment)
 568     {
 569       if (added_a_segment)
 570         {
 571           clib_warning ("Added a segment, still can't allocate a fifo");
 572           segment_manager_segment_reader_unlock (sm);
 573           return SESSION_ERROR_NEW_SEG_NO_SPACE;
 574         }
 575       if ((new_fs_index = segment_manager_add_segment (sm, 0)) < 0)
 576         {
 577           clib_warning ("Failed to add new segment");
 578           return SESSION_ERROR_SEG_CREATE;
 579         }
 580       fifo_segment = segment_manager_get_segment_w_lock (sm, new_fs_index);
 581       alloc_fail = segment_manager_try_alloc_fifos (fifo_segment,
 582                                                     props->rx_fifo_size,
 583                                                     props->tx_fifo_size,
 584                                                     rx_fifo, tx_fifo);
 585       added_a_segment = 1;
 586       goto alloc_check;
 587     }
 588   else
 589     {
 590       clib_warning ("Can't add new seg and no space to allocate fifos!");
 591       return SESSION_ERROR_NO_SPACE;
 592     }
 593 }
 594
 595 void
 596 segment_manager_dealloc_fifos (u32 segment_index, svm_fifo_t * rx_fifo,
 597                                svm_fifo_t * tx_fifo)
 598 {
 599   svm_fifo_segment_private_t *fifo_segment;
 600   segment_manager_t *sm;
 601
 602   if (!rx_fifo || !tx_fifo)
 603     return;
 604
 605   /* It's possible to have no segment manager if the session was removed
 606    * as result of a detach. */
 607   if (!(sm = segment_manager_get_if_valid (rx_fifo->segment_manager)))
 608     return;
 609
 610   fifo_segment = segment_manager_get_segment_w_lock (sm, segment_index);
 611   svm_fifo_segment_free_fifo (fifo_segment, rx_fifo,
 612                               FIFO_SEGMENT_RX_FREELIST);
 613   svm_fifo_segment_free_fifo (fifo_segment, tx_fifo,
 614                               FIFO_SEGMENT_TX_FREELIST);
 615
 616   /*
 617    * Try to remove svm segment if it has no fifos. This can be done only if
 618    * the segment is not the first in the segment manager or if it is first
 619    * and it is not protected. Moreover, if the segment is first and the app
 620    * has detached from the segment manager, remove the segment manager.
 621    */
 622   if (!svm_fifo_segment_has_fifos (fifo_segment))
 623     {
 624       segment_manager_segment_reader_unlock (sm);
 625
 626       /* Remove segment if it holds no fifos or first but not protected */
 627       if (segment_index != 0 || !sm->first_is_protected)
 628         segment_manager_lock_and_del_segment (sm, segment_index);
 629
 630       /* Remove segment manager if no sessions and detached from app */
 631       if (segment_manager_app_detached (sm)
 632           && !segment_manager_has_fifos (sm))
 633         {
 634           segment_manager_del (sm);
 635         }
 636     }
 637   else
 638     segment_manager_segment_reader_unlock (sm);
 639 }
 640
 641 u32
 642 segment_manager_evt_q_expected_size (u32 q_len)
 643 {
 644   u32 fifo_evt_size, notif_q_size, q_hdrs;
 645   u32 msg_q_sz, fifo_evt_ring_sz, session_ntf_ring_sz;
 646
 647   fifo_evt_size = 1 << max_log2 (sizeof (session_event_t));
 648   notif_q_size = clib_max (16, q_len >> 4);
 649
 650   msg_q_sz = q_len * sizeof (svm_msg_q_msg_t);
 651   fifo_evt_ring_sz = q_len * fifo_evt_size;
 652   session_ntf_ring_sz = notif_q_size * 256;
 653   q_hdrs = sizeof (svm_queue_t) + sizeof (svm_msg_q_t);
 654
 655   return (msg_q_sz + fifo_evt_ring_sz + session_ntf_ring_sz + q_hdrs);
 656 }
 657
 658 /**
 659  * Allocates shm queue in the first segment
 660  *
 661  * Must be called with lock held
 662  */
 663 svm_msg_q_t *
 664 segment_manager_alloc_queue (svm_fifo_segment_private_t * segment,
 665                              segment_manager_properties_t * props)
 666 {
 667   u32 fifo_evt_size, session_evt_size = 256, notif_q_size;
 668   svm_msg_q_cfg_t _cfg, *cfg = &_cfg;
 669   svm_msg_q_t *q;
 670   void *oldheap;
 671
 672   fifo_evt_size = sizeof (session_event_t);
 673   notif_q_size = clib_max (16, props->evt_q_size >> 4);
 674   /* *INDENT-OFF* */
 675   svm_msg_q_ring_cfg_t rc[SESSION_MQ_N_RINGS] = {
 676     {props->evt_q_size, fifo_evt_size, 0},
 677     {notif_q_size, session_evt_size, 0}
 678   };
 679   /* *INDENT-ON* */
 680   cfg->consumer_pid = 0;
 681   cfg->n_rings = 2;
 682   cfg->q_nitems = props->evt_q_size;
 683   cfg->ring_cfgs = rc;
 684
 685   oldheap = ssvm_push_heap (segment->ssvm.sh);
 686   q = svm_msg_q_alloc (cfg);
 687   ssvm_pop_heap (oldheap);
 688
 689   if (props->use_mq_eventfd)
 690     {
 691       if (svm_msg_q_alloc_producer_eventfd (q))
 692         clib_warning ("failed to alloc eventfd");
 693     }
 694   return q;
 695 }
 696
 697 /**
 698  * Frees shm queue allocated in the first segment
 699  */
 700 void
 701 segment_manager_dealloc_queue (segment_manager_t * sm, svm_queue_t * q)
 702 {
 703   svm_fifo_segment_private_t *segment;
 704   ssvm_shared_header_t *sh;
 705   void *oldheap;
 706
 707   ASSERT (!pool_is_free_index (sm->segments, 0));
 708
 709   segment = segment_manager_get_segment_w_lock (sm, 0);
 710   sh = segment->ssvm.sh;
 711
 712   oldheap = ssvm_push_heap (sh);
 713   svm_queue_free (q);
 714   ssvm_pop_heap (oldheap);
 715   segment_manager_segment_reader_unlock (sm);
 716 }
 717
 718 /*
 719  * Init segment vm address allocator
 720  */
 721 void
 722 segment_manager_main_init (segment_manager_main_init_args_t * a)
 723 {
 724   segment_manager_main_t *sm = &segment_manager_main;
 725   clib_valloc_chunk_t _ip, *ip = &_ip;
 726
 727   ip->baseva = a->baseva;
 728   ip->size = a->size;
 729
 730   clib_valloc_init (&sm->va_allocator, ip, 1 /* lock */ );
 731 }
 732
 733 static clib_error_t *
 734 segment_manager_show_fn (vlib_main_t * vm, unformat_input_t * input,
 735                          vlib_cli_command_t * cmd)
 736 {
 737   segment_manager_main_t *smm = &segment_manager_main;
 738   svm_fifo_segment_private_t *seg;
 739   segment_manager_t *sm;
 740   u8 show_segments = 0, verbose = 0;
 741   char *address;
 742   size_t size;
 743   u32 active_fifos;
 744   u32 free_fifos;
 745
 746   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 747     {
 748       if (unformat (input, "segments"))
 749         show_segments = 1;
 750       else if (unformat (input, "verbose"))
 751         verbose = 1;
 752       else
 753         return clib_error_return (0, "unknown input `%U'",
 754                                   format_unformat_error, input);
 755     }
 756   vlib_cli_output (vm, "%d segment managers allocated",
 757                    pool_elts (smm->segment_managers));
 758   if (verbose && pool_elts (smm->segment_managers))
 759     {
 760       vlib_cli_output (vm, "%-10s%=15s%=12s", "Index", "App Index",
 761                        "Segments");
 762
 763       /* *INDENT-OFF* */
 764       pool_foreach (sm, smm->segment_managers, ({
 765         vlib_cli_output (vm, "%-10d%=15d%=12d", segment_manager_index (sm),
 766                            sm->app_wrk_index, pool_elts (sm->segments));
 767       }));
 768       /* *INDENT-ON* */
 769
 770     }
 771   if (show_segments)
 772     {
 773       vlib_cli_output (vm, "%-15s%15s%15s%15s%15s%15s", "Name", "Type",
 774                        "HeapSize (M)", "ActiveFifos", "FreeFifos", "Address");
 775
 776       /* *INDENT-OFF* */
 777       pool_foreach (sm, smm->segment_managers, ({
 778           segment_manager_foreach_segment_w_lock (seg, sm, ({
 779             svm_fifo_segment_info (seg, &address, &size);
 780             active_fifos = svm_fifo_segment_num_fifos (seg);
 781             free_fifos = svm_fifo_segment_num_free_fifos (seg, ~0 /* size */);
 782             vlib_cli_output (vm, "%-15v%15U%15llu%15u%15u%15llx",
 783                              ssvm_name (&seg->ssvm), format_svm_fifo_segment_type,
 784                              seg, size >> 20ULL, active_fifos, free_fifos,
 785                              address);
 786             if (verbose)
 787               vlib_cli_output (vm, "%U", format_svm_fifo_segment, seg, verbose);
 788           }));
 789       }));
 790       /* *INDENT-ON* */
 791
 792     }
 793   return 0;
 794 }
 795
 796 /* *INDENT-OFF* */
 797 VLIB_CLI_COMMAND (segment_manager_show_command, static) =
 798 {
 799   .path = "show segment-manager",
 800   .short_help = "show segment-manager [segments][verbose]",
 801   .function = segment_manager_show_fn,
 802 };
 803 /* *INDENT-ON* */
 804
 805 /*
 806  * fd.io coding-style-patch-verification: ON
 807  *
 808  * Local Variables:
 809  * eval: (c-set-style "gnu")
 810  * End:
 811  */