src/vcl/vcl_private.c

   1 /*
   2  * Copyright (c) 2018-2019 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this
   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 <vcl/vcl_private.h>
  17
  18 static pthread_key_t vcl_worker_stop_key;
  19
  20 static const char *
  21 vppcom_app_state_str (app_state_t state)
  22 {
  23   char *st;
  24
  25   switch (state)
  26     {
  27     case STATE_APP_START:
  28       st = "STATE_APP_START";
  29       break;
  30
  31     case STATE_APP_CONN_VPP:
  32       st = "STATE_APP_CONN_VPP";
  33       break;
  34
  35     case STATE_APP_ENABLED:
  36       st = "STATE_APP_ENABLED";
  37       break;
  38
  39     case STATE_APP_ATTACHED:
  40       st = "STATE_APP_ATTACHED";
  41       break;
  42
  43     default:
  44       st = "UNKNOWN_APP_STATE";
  45       break;
  46     }
  47
  48   return st;
  49 }
  50
  51 int
  52 vcl_wait_for_app_state_change (app_state_t app_state)
  53 {
  54   vcl_worker_t *wrk = vcl_worker_get_current ();
  55   f64 timeout = clib_time_now (&wrk->clib_time) + vcm->cfg.app_timeout;
  56
  57   while (clib_time_now (&wrk->clib_time) < timeout)
  58     {
  59       if (vcm->app_state == app_state)
  60         return VPPCOM_OK;
  61       if (vcm->app_state == STATE_APP_FAILED)
  62         return VPPCOM_ECONNABORTED;
  63     }
  64   VDBG (0, "timeout waiting for state %s (%d)",
  65         vppcom_app_state_str (app_state), app_state);
  66   vcl_evt (VCL_EVT_SESSION_TIMEOUT, vcm, app_state);
  67
  68   return VPPCOM_ETIMEDOUT;
  69 }
  70
  71 vcl_mq_evt_conn_t *
  72 vcl_mq_evt_conn_alloc (vcl_worker_t * wrk)
  73 {
  74   vcl_mq_evt_conn_t *mqc;
  75   pool_get (wrk->mq_evt_conns, mqc);
  76   memset (mqc, 0, sizeof (*mqc));
  77   return mqc;
  78 }
  79
  80 u32
  81 vcl_mq_evt_conn_index (vcl_worker_t * wrk, vcl_mq_evt_conn_t * mqc)
  82 {
  83   return (mqc - wrk->mq_evt_conns);
  84 }
  85
  86 vcl_mq_evt_conn_t *
  87 vcl_mq_evt_conn_get (vcl_worker_t * wrk, u32 mq_conn_idx)
  88 {
  89   return pool_elt_at_index (wrk->mq_evt_conns, mq_conn_idx);
  90 }
  91
  92 int
  93 vcl_mq_epoll_add_evfd (vcl_worker_t * wrk, svm_msg_q_t * mq)
  94 {
  95   struct epoll_event e = { 0 };
  96   vcl_mq_evt_conn_t *mqc;
  97   u32 mqc_index;
  98   int mq_fd;
  99
 100   mq_fd = svm_msg_q_get_consumer_eventfd (mq);
 101
 102   if (wrk->mqs_epfd < 0 || mq_fd == -1)
 103     return -1;
 104
 105   mqc = vcl_mq_evt_conn_alloc (wrk);
 106   mqc_index = vcl_mq_evt_conn_index (wrk, mqc);
 107   mqc->mq_fd = mq_fd;
 108   mqc->mq = mq;
 109
 110   e.events = EPOLLIN;
 111   e.data.u32 = mqc_index;
 112   if (epoll_ctl (wrk->mqs_epfd, EPOLL_CTL_ADD, mq_fd, &e) < 0)
 113     {
 114       VDBG (0, "failed to add mq eventfd to mq epoll fd");
 115       return -1;
 116     }
 117
 118   return mqc_index;
 119 }
 120
 121 int
 122 vcl_mq_epoll_del_evfd (vcl_worker_t * wrk, u32 mqc_index)
 123 {
 124   vcl_mq_evt_conn_t *mqc;
 125
 126   if (wrk->mqs_epfd || mqc_index == ~0)
 127     return -1;
 128
 129   mqc = vcl_mq_evt_conn_get (wrk, mqc_index);
 130   if (epoll_ctl (wrk->mqs_epfd, EPOLL_CTL_DEL, mqc->mq_fd, 0) < 0)
 131     {
 132       VDBG (0, "failed to del mq eventfd to mq epoll fd");
 133       return -1;
 134     }
 135   return 0;
 136 }
 137
 138 static vcl_worker_t *
 139 vcl_worker_alloc (void)
 140 {
 141   vcl_worker_t *wrk;
 142   pool_get (vcm->workers, wrk);
 143   memset (wrk, 0, sizeof (*wrk));
 144   wrk->wrk_index = wrk - vcm->workers;
 145   wrk->forked_child = ~0;
 146   return wrk;
 147 }
 148
 149 static void
 150 vcl_worker_free (vcl_worker_t * wrk)
 151 {
 152   pool_put (vcm->workers, wrk);
 153 }
 154
 155 void
 156 vcl_worker_cleanup (vcl_worker_t * wrk, u8 notify_vpp)
 157 {
 158   clib_spinlock_lock (&vcm->workers_lock);
 159   if (notify_vpp)
 160     {
 161       if (wrk->wrk_index == vcl_get_worker_index ())
 162         vcl_send_app_worker_add_del (0 /* is_add */ );
 163       else
 164         vcl_send_child_worker_del (wrk);
 165     }
 166   if (wrk->mqs_epfd > 0)
 167     close (wrk->mqs_epfd);
 168   hash_free (wrk->session_index_by_vpp_handles);
 169   vec_free (wrk->mq_events);
 170   vec_free (wrk->mq_msg_vector);
 171   vcl_worker_free (wrk);
 172   clib_spinlock_unlock (&vcm->workers_lock);
 173 }
 174
 175 static void
 176 vcl_worker_cleanup_cb (void *arg)
 177 {
 178   vcl_worker_t *wrk = vcl_worker_get_current ();
 179   u32 wrk_index = wrk->wrk_index;
 180   vcl_worker_cleanup (wrk, 1 /* notify vpp */ );
 181   vcl_set_worker_index (~0);
 182   VDBG (0, "cleaned up worker %u", wrk_index);
 183 }
 184
 185 vcl_worker_t *
 186 vcl_worker_alloc_and_init ()
 187 {
 188   vcl_worker_t *wrk;
 189
 190   /* This was initialized already */
 191   if (vcl_get_worker_index () != ~0)
 192     return 0;
 193
 194   if (pool_elts (vcm->workers) == vcm->cfg.max_workers)
 195     {
 196       VDBG (0, "max-workers %u limit reached", vcm->cfg.max_workers);
 197       return 0;
 198     }
 199
 200   clib_spinlock_lock (&vcm->workers_lock);
 201   wrk = vcl_worker_alloc ();
 202   vcl_set_worker_index (wrk->wrk_index);
 203   wrk->thread_id = pthread_self ();
 204   wrk->current_pid = getpid ();
 205
 206   wrk->mqs_epfd = -1;
 207   if (vcm->cfg.use_mq_eventfd)
 208     {
 209       wrk->mqs_epfd = epoll_create (1);
 210       if (wrk->mqs_epfd < 0)
 211         {
 212           clib_unix_warning ("epoll_create() returned");
 213           goto done;
 214         }
 215     }
 216
 217   wrk->session_index_by_vpp_handles = hash_create (0, sizeof (uword));
 218   clib_time_init (&wrk->clib_time);
 219   vec_validate (wrk->mq_events, 64);
 220   vec_validate (wrk->mq_msg_vector, 128);
 221   vec_reset_length (wrk->mq_msg_vector);
 222   vec_validate (wrk->unhandled_evts_vector, 128);
 223   vec_reset_length (wrk->unhandled_evts_vector);
 224   clib_spinlock_unlock (&vcm->workers_lock);
 225
 226 done:
 227   return wrk;
 228 }
 229
 230 int
 231 vcl_worker_register_with_vpp (void)
 232 {
 233   vcl_worker_t *wrk = vcl_worker_get_current ();
 234
 235   clib_spinlock_lock (&vcm->workers_lock);
 236
 237   vcm->app_state = STATE_APP_ADDING_WORKER;
 238   vcl_send_app_worker_add_del (1 /* is_add */ );
 239   if (vcl_wait_for_app_state_change (STATE_APP_READY))
 240     {
 241       VDBG (0, "failed to add worker to vpp");
 242       return -1;
 243     }
 244   if (pthread_key_create (&vcl_worker_stop_key, vcl_worker_cleanup_cb))
 245     VDBG (0, "failed to add pthread cleanup function");
 246   if (pthread_setspecific (vcl_worker_stop_key, &wrk->thread_id))
 247     VDBG (0, "failed to setup key value");
 248
 249   clib_spinlock_unlock (&vcm->workers_lock);
 250
 251   VDBG (0, "added worker %u", wrk->wrk_index);
 252   return 0;
 253 }
 254
 255 int
 256 vcl_worker_set_bapi (void)
 257 {
 258   vcl_worker_t *wrk = vcl_worker_get_current ();
 259   int i;
 260
 261   /* Find the first worker with the same pid */
 262   for (i = 0; i < vec_len (vcm->workers); i++)
 263     {
 264       if (i == wrk->wrk_index)
 265         continue;
 266       if (vcm->workers[i].current_pid == wrk->current_pid)
 267         {
 268           wrk->vl_input_queue = vcm->workers[i].vl_input_queue;
 269           wrk->my_client_index = vcm->workers[i].my_client_index;
 270           return 0;
 271         }
 272     }
 273   return -1;
 274 }
 275
 276 void
 277 vcl_segment_table_add (u64 segment_handle, u32 svm_segment_index)
 278 {
 279   clib_rwlock_writer_lock (&vcm->segment_table_lock);
 280   hash_set (vcm->segment_table, segment_handle, svm_segment_index);
 281   clib_rwlock_writer_unlock (&vcm->segment_table_lock);
 282 }
 283
 284 u32
 285 vcl_segment_table_lookup (u64 segment_handle)
 286 {
 287   uword *seg_indexp;
 288
 289   clib_rwlock_reader_lock (&vcm->segment_table_lock);
 290   seg_indexp = hash_get (vcm->segment_table, segment_handle);
 291   clib_rwlock_reader_unlock (&vcm->segment_table_lock);
 292
 293   if (!seg_indexp)
 294     return VCL_INVALID_SEGMENT_INDEX;
 295   return ((u32) * seg_indexp);
 296 }
 297
 298 void
 299 vcl_segment_table_del (u64 segment_handle)
 300 {
 301   clib_rwlock_writer_lock (&vcm->segment_table_lock);
 302   hash_unset (vcm->segment_table, segment_handle);
 303   clib_rwlock_writer_unlock (&vcm->segment_table_lock);
 304 }
 305
 306 void
 307 vcl_cleanup_bapi (void)
 308 {
 309   socket_client_main_t *scm = &socket_client_main;
 310   api_main_t *am = &api_main;
 311
 312   am->my_client_index = ~0;
 313   am->my_registration = 0;
 314   am->vl_input_queue = 0;
 315   am->msg_index_by_name_and_crc = 0;
 316   scm->socket_fd = 0;
 317
 318   vl_client_api_unmap ();
 319 }
 320
 321 int
 322 vcl_session_read_ready (vcl_session_t * session)
 323 {
 324   /* Assumes caller has acquired spinlock: vcm->sessions_lockp */
 325   if (PREDICT_FALSE (session->is_vep))
 326     {
 327       VDBG (0, "ERROR: session %u: cannot read from an epoll session!",
 328             session->session_index);
 329       return VPPCOM_EBADFD;
 330     }
 331
 332   if (PREDICT_FALSE (!(session->session_state & (STATE_OPEN | STATE_LISTEN))))
 333     {
 334       vcl_session_state_t state = session->session_state;
 335       int rv;
 336
 337       rv = ((state & STATE_DISCONNECT) ? VPPCOM_ECONNRESET : VPPCOM_ENOTCONN);
 338
 339       VDBG (1, "session %u [0x%llx]: not open! state 0x%x (%s), ret %d (%s)",
 340             session->session_index, session->vpp_handle, state,
 341             vppcom_session_state_str (state), rv, vppcom_retval_str (rv));
 342       return rv;
 343     }
 344
 345   if (session->session_state & STATE_LISTEN)
 346     return clib_fifo_elts (session->accept_evts_fifo);
 347
 348   if (vcl_session_is_ct (session))
 349     return svm_fifo_max_dequeue_cons (session->ct_rx_fifo);
 350
 351   return svm_fifo_max_dequeue_cons (session->rx_fifo);
 352 }
 353
 354 int
 355 vcl_session_write_ready (vcl_session_t * session)
 356 {
 357   /* Assumes caller has acquired spinlock: vcm->sessions_lockp */
 358   if (PREDICT_FALSE (session->is_vep))
 359     {
 360       VDBG (0, "session %u [0x%llx]: cannot write to an epoll session!",
 361             session->session_index, session->vpp_handle);
 362       return VPPCOM_EBADFD;
 363     }
 364
 365   if (PREDICT_FALSE (session->session_state & STATE_LISTEN))
 366     {
 367       if (session->tx_fifo)
 368         return svm_fifo_max_enqueue_prod (session->tx_fifo);
 369       else
 370         return VPPCOM_EBADFD;
 371     }
 372
 373   if (PREDICT_FALSE (!(session->session_state & STATE_OPEN)))
 374     {
 375       vcl_session_state_t state = session->session_state;
 376       int rv;
 377
 378       rv = ((state & STATE_DISCONNECT) ? VPPCOM_ECONNRESET : VPPCOM_ENOTCONN);
 379       VDBG (0, "session %u [0x%llx]: not open! state 0x%x (%s), ret %d (%s)",
 380             session->session_index, session->vpp_handle, state,
 381             vppcom_session_state_str (state), rv, vppcom_retval_str (rv));
 382       return rv;
 383     }
 384
 385   if (vcl_session_is_ct (session))
 386     return svm_fifo_max_enqueue_prod (session->ct_tx_fifo);
 387
 388   return svm_fifo_max_enqueue_prod (session->tx_fifo);
 389 }
 390
 391 /*
 392  * fd.io coding-style-patch-verification: ON
 393  *
 394  * Local Variables:
 395  * eval: (c-set-style "gnu")
 396  * End:
 397  */