src/vnet/session/segment_manager.c

   1 /*
   2  * Copyright (c) 2017 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 = (u64) ~ 0, 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   stream_session_t *session;
 383   svm_fifo_t *fifo;
 384
 385   ASSERT (pool_elts (sm->segments) != 0);
 386
 387   /* Across all fifo segments used by the server */
 388   /* *INDENT-OFF* */
 389   segment_manager_foreach_segment_w_lock (fifo_segment, sm, ({
 390     fifo = svm_fifo_segment_get_fifo_list (fifo_segment);
 391
 392     /*
 393      * Remove any residual sessions from the session lookup table
 394      * Don't bother deleting the individual fifos, we're going to
 395      * throw away the fifo segment in a minute.
 396      */
 397     while (fifo)
 398       {
 399         if (fifo->ct_session_index != SVM_FIFO_INVALID_SESSION_INDEX)
 400           {
 401             svm_fifo_t *next = fifo->next;
 402             application_local_session_disconnect_w_index (sm->app_wrk_index,
 403                                                           fifo->ct_session_index);
 404             fifo = next;
 405             continue;
 406           }
 407         session = session_get (fifo->master_session_index,
 408                                fifo->master_thread_index);
 409         stream_session_disconnect (session);
 410         fifo = fifo->next;
 411       }
 412
 413     /* Instead of removing the segment, test when cleaning up disconnected
 414      * sessions if the segment can be removed.
 415      */
 416   }));
 417   /* *INDENT-ON* */
 418 }
 419
 420 /**
 421  * Removes segment manager.
 422  *
 423  * Since the fifos allocated in the segment keep backpointers to the sessions
 424  * prior to removing the segment, we call session disconnect. This
 425  * subsequently propagates into transport.
 426  */
 427 void
 428 segment_manager_del (segment_manager_t * sm)
 429 {
 430   segment_manager_main_t *smm = &segment_manager_main;
 431   svm_fifo_segment_private_t *fifo_segment;
 432
 433   ASSERT (!segment_manager_has_fifos (sm)
 434           && segment_manager_app_detached (sm));
 435
 436   /* If we have empty preallocated segments that haven't been removed, remove
 437    * them now. Apart from that, the first segment in the first segment manager
 438    * is not removed when all fifos are removed. It can only be removed when
 439    * the manager is explicitly deleted/detached by the app. */
 440   clib_rwlock_writer_lock (&sm->segments_rwlock);
 441
 442   /* *INDENT-OFF* */
 443   pool_foreach (fifo_segment, sm->segments, ({
 444     segment_manager_del_segment (sm, fifo_segment);
 445   }));
 446   /* *INDENT-ON* */
 447
 448   clib_rwlock_writer_unlock (&sm->segments_rwlock);
 449
 450   clib_rwlock_free (&sm->segments_rwlock);
 451   if (CLIB_DEBUG)
 452     clib_memset (sm, 0xfe, sizeof (*sm));
 453   pool_put (smm->segment_managers, sm);
 454 }
 455
 456 void
 457 segment_manager_init_del (segment_manager_t * sm)
 458 {
 459   segment_manager_app_detach (sm);
 460   if (segment_manager_has_fifos (sm))
 461     segment_manager_del_sessions (sm);
 462   else
 463     {
 464       ASSERT (!sm->first_is_protected || segment_manager_app_detached (sm));
 465       segment_manager_del (sm);
 466     }
 467 }
 468
 469 int
 470 segment_manager_try_alloc_fifos (svm_fifo_segment_private_t * fifo_segment,
 471                                  u32 rx_fifo_size, u32 tx_fifo_size,
 472                                  svm_fifo_t ** rx_fifo, svm_fifo_t ** tx_fifo)
 473 {
 474   rx_fifo_size = clib_max (rx_fifo_size, default_fifo_size);
 475   *rx_fifo = svm_fifo_segment_alloc_fifo (fifo_segment, rx_fifo_size,
 476                                           FIFO_SEGMENT_RX_FREELIST);
 477
 478   tx_fifo_size = clib_max (tx_fifo_size, default_fifo_size);
 479   *tx_fifo = svm_fifo_segment_alloc_fifo (fifo_segment, tx_fifo_size,
 480                                           FIFO_SEGMENT_TX_FREELIST);
 481
 482   if (*rx_fifo == 0)
 483     {
 484       /* This would be very odd, but handle it... */
 485       if (*tx_fifo != 0)
 486         {
 487           svm_fifo_segment_free_fifo (fifo_segment, *tx_fifo,
 488                                       FIFO_SEGMENT_TX_FREELIST);
 489           *tx_fifo = 0;
 490         }
 491       return -1;
 492     }
 493   if (*tx_fifo == 0)
 494     {
 495       if (*rx_fifo != 0)
 496         {
 497           svm_fifo_segment_free_fifo (fifo_segment, *rx_fifo,
 498                                       FIFO_SEGMENT_RX_FREELIST);
 499           *rx_fifo = 0;
 500         }
 501       return -1;
 502     }
 503
 504   return 0;
 505 }
 506
 507 int
 508 segment_manager_alloc_session_fifos (segment_manager_t * sm,
 509                                      svm_fifo_t ** rx_fifo,
 510                                      svm_fifo_t ** tx_fifo,
 511                                      u32 * fifo_segment_index)
 512 {
 513   svm_fifo_segment_private_t *fifo_segment = 0;
 514   int alloc_fail = 1, rv = 0, new_fs_index;
 515   segment_manager_properties_t *props;
 516   u8 added_a_segment = 0;
 517   u64 segment_handle;
 518   u32 sm_index;
 519
 520   props = segment_manager_properties_get (sm);
 521
 522   /*
 523    * Find the first free segment to allocate the fifos in
 524    */
 525
 526   /* *INDENT-OFF* */
 527   segment_manager_foreach_segment_w_lock (fifo_segment, sm, ({
 528     alloc_fail = segment_manager_try_alloc_fifos (fifo_segment,
 529                                                   props->rx_fifo_size,
 530                                                   props->tx_fifo_size,
 531                                                   rx_fifo, tx_fifo);
 532     /* Exit with lock held, drop it after notifying app */
 533     if (!alloc_fail)
 534       goto alloc_success;
 535   }));
 536   /* *INDENT-ON* */
 537
 538 alloc_check:
 539
 540   if (!alloc_fail)
 541     {
 542
 543     alloc_success:
 544
 545       ASSERT (rx_fifo && tx_fifo);
 546       sm_index = segment_manager_index (sm);
 547       *fifo_segment_index = segment_manager_segment_index (sm, fifo_segment);
 548       (*tx_fifo)->segment_manager = sm_index;
 549       (*rx_fifo)->segment_manager = sm_index;
 550       (*tx_fifo)->segment_index = *fifo_segment_index;
 551       (*rx_fifo)->segment_index = *fifo_segment_index;
 552
 553       if (added_a_segment)
 554         {
 555           segment_handle = segment_manager_segment_handle (sm, fifo_segment);
 556           rv = app_worker_add_segment_notify (sm->app_wrk_index,
 557                                               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   /* It's possible to have no segment manager if the session was removed
 603    * as result of a detach. */
 604   if (!(sm = segment_manager_get_if_valid (rx_fifo->segment_manager)))
 605     return;
 606
 607   fifo_segment = segment_manager_get_segment_w_lock (sm, segment_index);
 608   svm_fifo_segment_free_fifo (fifo_segment, rx_fifo,
 609                               FIFO_SEGMENT_RX_FREELIST);
 610   svm_fifo_segment_free_fifo (fifo_segment, tx_fifo,
 611                               FIFO_SEGMENT_TX_FREELIST);
 612
 613   /*
 614    * Try to remove svm segment if it has no fifos. This can be done only if
 615    * the segment is not the first in the segment manager or if it is first
 616    * and it is not protected. Moreover, if the segment is first and the app
 617    * has detached from the segment manager, remove the segment manager.
 618    */
 619   if (!svm_fifo_segment_has_fifos (fifo_segment))
 620     {
 621       segment_manager_segment_reader_unlock (sm);
 622
 623       /* Remove segment if it holds no fifos or first but not protected */
 624       if (segment_index != 0 || !sm->first_is_protected)
 625         segment_manager_lock_and_del_segment (sm, segment_index);
 626
 627       /* Remove segment manager if no sessions and detached from app */
 628       if (segment_manager_app_detached (sm)
 629           && !segment_manager_has_fifos (sm))
 630         {
 631           segment_manager_del (sm);
 632         }
 633     }
 634   else
 635     segment_manager_segment_reader_unlock (sm);
 636 }
 637
 638 u32
 639 segment_manager_evt_q_expected_size (u32 q_len)
 640 {
 641   u32 fifo_evt_size, notif_q_size, q_hdrs;
 642   u32 msg_q_sz, fifo_evt_ring_sz, session_ntf_ring_sz;
 643
 644   fifo_evt_size = 1 << max_log2 (sizeof (session_event_t));
 645   notif_q_size = clib_max (16, q_len >> 4);
 646
 647   msg_q_sz = q_len * sizeof (svm_msg_q_msg_t);
 648   fifo_evt_ring_sz = q_len * fifo_evt_size;
 649   session_ntf_ring_sz = notif_q_size * 256;
 650   q_hdrs = sizeof (svm_queue_t) + sizeof (svm_msg_q_t);
 651
 652   return (msg_q_sz + fifo_evt_ring_sz + session_ntf_ring_sz + q_hdrs);
 653 }
 654
 655 /**
 656  * Allocates shm queue in the first segment
 657  *
 658  * Must be called with lock held
 659  */
 660 svm_msg_q_t *
 661 segment_manager_alloc_queue (svm_fifo_segment_private_t * segment,
 662                              segment_manager_properties_t * props)
 663 {
 664   u32 fifo_evt_size, session_evt_size = 256, notif_q_size;
 665   svm_msg_q_cfg_t _cfg, *cfg = &_cfg;
 666   svm_msg_q_t *q;
 667   void *oldheap;
 668
 669   fifo_evt_size = sizeof (session_event_t);
 670   notif_q_size = clib_max (16, props->evt_q_size >> 4);
 671   /* *INDENT-OFF* */
 672   svm_msg_q_ring_cfg_t rc[SESSION_MQ_N_RINGS] = {
 673     {props->evt_q_size, fifo_evt_size, 0},
 674     {notif_q_size, session_evt_size, 0}
 675   };
 676   /* *INDENT-ON* */
 677   cfg->consumer_pid = 0;
 678   cfg->n_rings = 2;
 679   cfg->q_nitems = props->evt_q_size;
 680   cfg->ring_cfgs = rc;
 681
 682   oldheap = ssvm_push_heap (segment->ssvm.sh);
 683   q = svm_msg_q_alloc (cfg);
 684   ssvm_pop_heap (oldheap);
 685
 686   if (props->use_mq_eventfd)
 687     {
 688       if (svm_msg_q_alloc_producer_eventfd (q))
 689         clib_warning ("failed to alloc eventfd");
 690     }
 691   return q;
 692 }
 693
 694 /**
 695  * Frees shm queue allocated in the first segment
 696  */
 697 void
 698 segment_manager_dealloc_queue (segment_manager_t * sm, svm_queue_t * q)
 699 {
 700   svm_fifo_segment_private_t *segment;
 701   ssvm_shared_header_t *sh;
 702   void *oldheap;
 703
 704   ASSERT (!pool_is_free_index (sm->segments, 0));
 705
 706   segment = segment_manager_get_segment_w_lock (sm, 0);
 707   sh = segment->ssvm.sh;
 708
 709   oldheap = ssvm_push_heap (sh);
 710   svm_queue_free (q);
 711   ssvm_pop_heap (oldheap);
 712   segment_manager_segment_reader_unlock (sm);
 713 }
 714
 715 /*
 716  * Init segment vm address allocator
 717  */
 718 void
 719 segment_manager_main_init (segment_manager_main_init_args_t * a)
 720 {
 721   segment_manager_main_t *sm = &segment_manager_main;
 722   clib_valloc_chunk_t _ip, *ip = &_ip;
 723
 724   ip->baseva = a->baseva;
 725   ip->size = a->size;
 726
 727   clib_valloc_init (&sm->va_allocator, ip, 1 /* lock */ );
 728 }
 729
 730 static clib_error_t *
 731 segment_manager_show_fn (vlib_main_t * vm, unformat_input_t * input,
 732                          vlib_cli_command_t * cmd)
 733 {
 734   segment_manager_main_t *smm = &segment_manager_main;
 735   svm_fifo_segment_private_t *seg;
 736   segment_manager_t *sm;
 737   u8 show_segments = 0, verbose = 0;
 738   uword address;
 739   u64 size;
 740   u32 active_fifos;
 741   u32 free_fifos;
 742
 743   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 744     {
 745       if (unformat (input, "segments"))
 746         show_segments = 1;
 747       else if (unformat (input, "verbose"))
 748         verbose = 1;
 749       else
 750         return clib_error_return (0, "unknown input `%U'",
 751                                   format_unformat_error, input);
 752     }
 753   vlib_cli_output (vm, "%d segment managers allocated",
 754                    pool_elts (smm->segment_managers));
 755   if (verbose && pool_elts (smm->segment_managers))
 756     {
 757       vlib_cli_output (vm, "%-10s%=15s%=12s", "Index", "App Index",
 758                        "Segments");
 759
 760       /* *INDENT-OFF* */
 761       pool_foreach (sm, smm->segment_managers, ({
 762         vlib_cli_output (vm, "%-10d%=15d%=12d", segment_manager_index (sm),
 763                            sm->app_wrk_index, pool_elts (sm->segments));
 764       }));
 765       /* *INDENT-ON* */
 766
 767     }
 768   if (show_segments)
 769     {
 770       vlib_cli_output (vm, "%-15s%15s%15s%15s%15s%15s", "Name", "Type",
 771                        "HeapSize (M)", "ActiveFifos", "FreeFifos", "Address");
 772
 773       /* *INDENT-OFF* */
 774       pool_foreach (sm, smm->segment_managers, ({
 775           segment_manager_foreach_segment_w_lock (seg, sm, ({
 776             svm_fifo_segment_info (seg, &address, &size);
 777             active_fifos = svm_fifo_segment_num_fifos (seg);
 778             free_fifos = svm_fifo_segment_num_free_fifos (seg, ~0 /* size */);
 779             vlib_cli_output (vm, "%-15v%15U%15llu%15u%15u%15llx",
 780                              ssvm_name (&seg->ssvm), format_svm_fifo_segment_type,
 781                              seg, size >> 20ULL, active_fifos, free_fifos,
 782                              address);
 783             if (verbose)
 784               vlib_cli_output (vm, "%U", format_svm_fifo_segment, seg, verbose);
 785           }));
 786       }));
 787       /* *INDENT-ON* */
 788
 789     }
 790   return 0;
 791 }
 792
 793 /* *INDENT-OFF* */
 794 VLIB_CLI_COMMAND (segment_manager_show_command, static) =
 795 {
 796   .path = "show segment-manager",
 797   .short_help = "show segment-manager [segments][verbose]",
 798   .function = segment_manager_show_fn,
 799 };
 800 /* *INDENT-ON* */
 801
 802 /*
 803  * fd.io coding-style-patch-verification: ON
 804  *
 805  * Local Variables:
 806  * eval: (c-set-style "gnu")
 807  * End:
 808  */