Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2018 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 | |
Florin Coras | 3348a4c | 2018-09-07 17:09:35 -0700 | [diff] [blame] | 18 | static pthread_key_t vcl_worker_stop_key; |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 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, "VCL<%d>: timeout waiting for state %s (%d)", getpid (), |
| 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 | |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 71 | vcl_cut_through_registration_t * |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 72 | vcl_ct_registration_lock_and_alloc (vcl_worker_t * wrk) |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 73 | { |
| 74 | vcl_cut_through_registration_t *cr; |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 75 | clib_spinlock_lock (&wrk->ct_registration_lock); |
| 76 | pool_get (wrk->cut_through_registrations, cr); |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 77 | memset (cr, 0, sizeof (*cr)); |
| 78 | cr->epoll_evt_conn_index = -1; |
| 79 | return cr; |
| 80 | } |
| 81 | |
| 82 | u32 |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 83 | vcl_ct_registration_index (vcl_worker_t * wrk, |
| 84 | vcl_cut_through_registration_t * ctr) |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 85 | { |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 86 | return (ctr - wrk->cut_through_registrations); |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 87 | } |
| 88 | |
| 89 | void |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 90 | vcl_ct_registration_lock (vcl_worker_t * wrk) |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 91 | { |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 92 | clib_spinlock_lock (&wrk->ct_registration_lock); |
| 93 | } |
| 94 | |
| 95 | void |
| 96 | vcl_ct_registration_unlock (vcl_worker_t * wrk) |
| 97 | { |
| 98 | clib_spinlock_unlock (&wrk->ct_registration_lock); |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 99 | } |
| 100 | |
| 101 | vcl_cut_through_registration_t * |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 102 | vcl_ct_registration_get (vcl_worker_t * wrk, u32 ctr_index) |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 103 | { |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 104 | if (pool_is_free_index (wrk->cut_through_registrations, ctr_index)) |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 105 | return 0; |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 106 | return pool_elt_at_index (wrk->cut_through_registrations, ctr_index); |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 107 | } |
| 108 | |
| 109 | vcl_cut_through_registration_t * |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 110 | vcl_ct_registration_lock_and_lookup (vcl_worker_t * wrk, uword mq_addr) |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 111 | { |
| 112 | uword *p; |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 113 | clib_spinlock_lock (&wrk->ct_registration_lock); |
| 114 | p = hash_get (wrk->ct_registration_by_mq, mq_addr); |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 115 | if (!p) |
| 116 | return 0; |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 117 | return vcl_ct_registration_get (wrk, p[0]); |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 118 | } |
| 119 | |
| 120 | void |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 121 | vcl_ct_registration_lookup_add (vcl_worker_t * wrk, uword mq_addr, |
| 122 | u32 ctr_index) |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 123 | { |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 124 | hash_set (wrk->ct_registration_by_mq, mq_addr, ctr_index); |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 125 | } |
| 126 | |
| 127 | void |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 128 | vcl_ct_registration_lookup_del (vcl_worker_t * wrk, uword mq_addr) |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 129 | { |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 130 | hash_unset (wrk->ct_registration_by_mq, mq_addr); |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 131 | } |
| 132 | |
| 133 | void |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 134 | vcl_ct_registration_del (vcl_worker_t * wrk, |
| 135 | vcl_cut_through_registration_t * ctr) |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 136 | { |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 137 | pool_put (wrk->cut_through_registrations, ctr); |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 138 | } |
| 139 | |
| 140 | vcl_mq_evt_conn_t * |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 141 | vcl_mq_evt_conn_alloc (vcl_worker_t * wrk) |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 142 | { |
| 143 | vcl_mq_evt_conn_t *mqc; |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 144 | pool_get (wrk->mq_evt_conns, mqc); |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 145 | memset (mqc, 0, sizeof (*mqc)); |
| 146 | return mqc; |
| 147 | } |
| 148 | |
| 149 | u32 |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 150 | vcl_mq_evt_conn_index (vcl_worker_t * wrk, vcl_mq_evt_conn_t * mqc) |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 151 | { |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 152 | return (mqc - wrk->mq_evt_conns); |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 153 | } |
| 154 | |
| 155 | vcl_mq_evt_conn_t * |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 156 | vcl_mq_evt_conn_get (vcl_worker_t * wrk, u32 mq_conn_idx) |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 157 | { |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 158 | return pool_elt_at_index (wrk->mq_evt_conns, mq_conn_idx); |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 159 | } |
| 160 | |
| 161 | int |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 162 | vcl_mq_epoll_add_evfd (vcl_worker_t * wrk, svm_msg_q_t * mq) |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 163 | { |
| 164 | struct epoll_event e = { 0 }; |
| 165 | vcl_mq_evt_conn_t *mqc; |
| 166 | u32 mqc_index; |
| 167 | int mq_fd; |
| 168 | |
| 169 | mq_fd = svm_msg_q_get_consumer_eventfd (mq); |
| 170 | |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 171 | if (wrk->mqs_epfd < 0 || mq_fd == -1) |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 172 | return -1; |
| 173 | |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 174 | mqc = vcl_mq_evt_conn_alloc (wrk); |
| 175 | mqc_index = vcl_mq_evt_conn_index (wrk, mqc); |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 176 | mqc->mq_fd = mq_fd; |
| 177 | mqc->mq = mq; |
| 178 | |
| 179 | e.events = EPOLLIN; |
| 180 | e.data.u32 = mqc_index; |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 181 | if (epoll_ctl (wrk->mqs_epfd, EPOLL_CTL_ADD, mq_fd, &e) < 0) |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 182 | { |
| 183 | clib_warning ("failed to add mq eventfd to mq epoll fd"); |
| 184 | return -1; |
| 185 | } |
| 186 | |
| 187 | return mqc_index; |
| 188 | } |
| 189 | |
| 190 | int |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 191 | vcl_mq_epoll_del_evfd (vcl_worker_t * wrk, u32 mqc_index) |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 192 | { |
| 193 | vcl_mq_evt_conn_t *mqc; |
| 194 | |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 195 | if (wrk->mqs_epfd || mqc_index == ~0) |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 196 | return -1; |
| 197 | |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 198 | mqc = vcl_mq_evt_conn_get (wrk, mqc_index); |
| 199 | if (epoll_ctl (wrk->mqs_epfd, EPOLL_CTL_DEL, mqc->mq_fd, 0) < 0) |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 200 | { |
| 201 | clib_warning ("failed to del mq eventfd to mq epoll fd"); |
| 202 | return -1; |
| 203 | } |
| 204 | return 0; |
| 205 | } |
| 206 | |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 207 | static vcl_worker_t * |
| 208 | vcl_worker_alloc (void) |
| 209 | { |
| 210 | vcl_worker_t *wrk; |
| 211 | pool_get (vcm->workers, wrk); |
| 212 | memset (wrk, 0, sizeof (*wrk)); |
| 213 | wrk->wrk_index = wrk - vcm->workers; |
| 214 | return wrk; |
| 215 | } |
| 216 | |
| 217 | static void |
| 218 | vcl_worker_free (vcl_worker_t * wrk) |
| 219 | { |
| 220 | pool_put (vcm->workers, wrk); |
| 221 | } |
| 222 | |
| 223 | static void |
| 224 | vcl_worker_cleanup (void *arg) |
| 225 | { |
| 226 | vcl_worker_t *wrk = vcl_worker_get_current (); |
Florin Coras | 3348a4c | 2018-09-07 17:09:35 -0700 | [diff] [blame] | 227 | |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 228 | VDBG (0, "cleaning up worker %u", wrk->wrk_index); |
| 229 | vcl_send_app_worker_add_del (0 /* is_add */ ); |
| 230 | close (wrk->mqs_epfd); |
| 231 | hash_free (wrk->session_index_by_vpp_handles); |
| 232 | hash_free (wrk->ct_registration_by_mq); |
| 233 | clib_spinlock_free (&wrk->ct_registration_lock); |
| 234 | vec_free (wrk->mq_events); |
| 235 | vec_free (wrk->mq_msg_vector); |
| 236 | vcl_set_worker_index (~0); |
| 237 | vcl_worker_free (wrk); |
| 238 | } |
| 239 | |
| 240 | vcl_worker_t * |
| 241 | vcl_worker_alloc_and_init () |
| 242 | { |
| 243 | vcl_worker_t *wrk; |
| 244 | |
| 245 | /* This was initialized already */ |
| 246 | if (vcl_get_worker_index () != ~0) |
| 247 | return 0; |
| 248 | |
Florin Coras | de9f08b | 2018-09-07 14:32:58 -0700 | [diff] [blame] | 249 | if (pool_elts (vcm->workers) == vcm->cfg.max_workers) |
| 250 | { |
| 251 | VDBG (0, "max-workers %u limit reached", vcm->cfg.max_workers); |
| 252 | return 0; |
| 253 | } |
| 254 | |
| 255 | clib_spinlock_lock (&vcm->workers_lock); |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 256 | wrk = vcl_worker_alloc (); |
| 257 | vcl_set_worker_index (wrk->wrk_index); |
| 258 | |
| 259 | wrk->mqs_epfd = -1; |
| 260 | if (vcm->cfg.use_mq_eventfd) |
| 261 | { |
| 262 | wrk->mqs_epfd = epoll_create (1); |
| 263 | if (wrk->mqs_epfd < 0) |
| 264 | { |
| 265 | clib_unix_warning ("epoll_create() returned"); |
| 266 | return 0; |
| 267 | } |
| 268 | } |
| 269 | |
| 270 | wrk->session_index_by_vpp_handles = hash_create (0, sizeof (uword)); |
| 271 | wrk->ct_registration_by_mq = hash_create (0, sizeof (uword)); |
| 272 | clib_spinlock_init (&wrk->ct_registration_lock); |
| 273 | clib_time_init (&wrk->clib_time); |
| 274 | vec_validate (wrk->mq_events, 64); |
| 275 | vec_validate (wrk->mq_msg_vector, 128); |
| 276 | vec_reset_length (wrk->mq_msg_vector); |
Florin Coras | 86f0450 | 2018-09-12 16:08:01 -0700 | [diff] [blame^] | 277 | vec_validate (wrk->unhandled_evts_vector, 128); |
| 278 | vec_reset_length (wrk->unhandled_evts_vector); |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 279 | |
| 280 | if (wrk->wrk_index == 0) |
Florin Coras | de9f08b | 2018-09-07 14:32:58 -0700 | [diff] [blame] | 281 | { |
| 282 | clib_spinlock_unlock (&vcm->workers_lock); |
| 283 | return wrk; |
| 284 | } |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 285 | |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 286 | vcm->app_state = STATE_APP_ADDING_WORKER; |
| 287 | vcl_send_app_worker_add_del (1 /* is_add */ ); |
| 288 | if (vcl_wait_for_app_state_change (STATE_APP_READY)) |
| 289 | { |
| 290 | clib_warning ("failed to add worker to vpp"); |
| 291 | return 0; |
| 292 | } |
| 293 | |
| 294 | if (pthread_key_create (&vcl_worker_stop_key, vcl_worker_cleanup)) |
| 295 | clib_warning ("failed to add pthread cleanup function"); |
Florin Coras | 3348a4c | 2018-09-07 17:09:35 -0700 | [diff] [blame] | 296 | if (pthread_setspecific (vcl_worker_stop_key, &wrk->thread_id)) |
| 297 | clib_warning ("failed to setup key value"); |
| 298 | wrk->thread_id = pthread_self (); |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 299 | |
Florin Coras | de9f08b | 2018-09-07 14:32:58 -0700 | [diff] [blame] | 300 | clib_spinlock_unlock (&vcm->workers_lock); |
| 301 | |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 302 | VDBG (0, "added worker %u", wrk->wrk_index); |
| 303 | |
| 304 | return wrk; |
| 305 | } |
| 306 | |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 307 | /* |
| 308 | * fd.io coding-style-patch-verification: ON |
| 309 | * |
| 310 | * Local Variables: |
| 311 | * eval: (c-set-style "gnu") |
| 312 | * End: |
| 313 | */ |