2 * Copyright (c) 2019 Cisco and/or its affiliates.
3 * Licensed under the Apache License, Version 2.0 (the "License");
5 * You may obtain a copy of the License at:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
16 #include <vppinfra/fifo.h>
17 #include <vppinfra/pool.h>
18 #include <vppinfra/hash.h>
19 #include <vnet/api_errno.h>
21 #include <vcl/vppcom.h>
22 #include <vcl/vcl_event.h>
26 * @brief VPP Communications Library (VCL) event handler.
28 * Definitions for generic event handling in VCL.
32 vce_generate_event (vce_event_thread_t *evt, u32 ev_idx)
37 pthread_mutex_lock (&(evt->generator_lock));
39 /* Check there is event data for this event */
42 p = pool_elt_at_index (evt->vce_events, ev_idx);
45 elts = (int) clib_fifo_free_elts (evt->event_index_fifo);
46 if (PREDICT_TRUE (elts))
48 /* Add event to queue */
49 clib_fifo_add1 (evt->event_index_fifo, ev_idx);
50 pthread_cond_signal (&(evt->generator_cond));
54 rv = VNET_API_ERROR_QUEUE_FULL;
58 pthread_mutex_unlock (&(evt->generator_lock));
64 vce_clear_event (vce_event_thread_t *evt, u32 ev_idx)
67 pool_put_index (evt->vce_events, ev_idx);
72 vce_get_event_from_index(vce_event_thread_t *evt, u32 ev_idx)
75 /* Assumes caller has obtained the spinlock (evt->events_lockp) */
77 if ( ! pool_is_free_index (evt->vce_events, ev_idx))
78 ev = pool_elt_at_index (evt->vce_events, ev_idx);
83 vce_event_handler_reg_t *
84 vce_get_event_handler (vce_event_thread_t *evt, vce_event_key_t *evk)
86 vce_event_handler_reg_t *handler = 0;
90 p = hash_get (evt->handlers_index_by_event_key, evk->as_u64);
92 handler = pool_elt_at_index (evt->vce_event_handlers, p[0]);
93 VCE_HANDLERS_UNLOCK ();
98 vce_event_handler_reg_t *
99 vce_register_handler (vce_event_thread_t *evt, vce_event_key_t *evk,
100 vce_event_callback_t cb, void *cb_args)
102 vce_event_handler_reg_t *handler;
103 vce_event_handler_reg_t *old_handler = 0;
107 /* TODO - multiple handler support. For now we can replace
108 * and re-instate, which is useful for event recycling */
110 VCE_HANDLERS_LOCK ();
112 p = hash_get (evt->handlers_index_by_event_key, evk->as_u64);
115 old_handler = pool_elt_at_index (evt->vce_event_handlers, p[0]);
116 /* If we are just re-registering, ignore and move on
117 * else store the old handler_fn for unregister to re-instate */
118 if (old_handler->handler_fn == cb)
121 VCE_HANDLERS_UNLOCK ();
123 /* Signal event thread that a handler exists in case any
124 * recycled events requiring this handler are pending */
125 pthread_mutex_lock (&(evt->generator_lock));
126 pthread_cond_signal (&(evt->generator_cond));
127 pthread_mutex_unlock (&(evt->generator_lock));
132 pool_get (evt->vce_event_handlers, handler);
133 handler_index = (u32) (handler - evt->vce_event_handlers);
135 handler->handler_fn = cb;
136 handler->replaced_handler_idx = (u32) ((p) ? p[0] : ~0);
137 handler->ev_idx = (u32) ~0; //This will be set by the event thread if event happens
138 handler->evk = evk->as_u64;
139 handler->handler_fn_args = cb_args;
141 hash_set (evt->handlers_index_by_event_key, evk->as_u64, handler_index);
143 pthread_cond_init (&(handler->handler_cond), NULL);
144 pthread_mutex_init (&(handler->handler_lock), NULL);
146 VCE_HANDLERS_UNLOCK ();
148 /* Signal event thread that a new handler exists in case any
149 * recycled events requiring this handler are pending */
150 pthread_mutex_lock (&(evt->generator_lock));
151 pthread_cond_signal (&(evt->generator_cond));
152 pthread_mutex_unlock (&(evt->generator_lock));
158 vce_unregister_handler (vce_event_thread_t *evt,
159 vce_event_handler_reg_t *handler)
162 u64 evk = handler->evk;
163 u8 generate_signal = 0;
165 VCE_HANDLERS_LOCK ();
167 p = hash_get (evt->handlers_index_by_event_key, evk);
170 VCE_HANDLERS_UNLOCK ();
171 return VNET_API_ERROR_NO_SUCH_ENTRY;
174 handler = pool_elt_at_index (evt->vce_event_handlers, p[0]);
176 /* If this handler replaced another handler, re-instate it */
177 if (handler->replaced_handler_idx != ~0)
179 hash_set (evt->handlers_index_by_event_key, evk,
180 handler->replaced_handler_idx);
185 hash_unset (evt->handlers_index_by_event_key, evk);
188 pthread_mutex_destroy (&(handler->handler_lock));
189 pthread_cond_destroy (&(handler->handler_cond));
190 pool_put (evt->vce_event_handlers, handler);
192 VCE_HANDLERS_UNLOCK ();
196 /* Signal event thread that a new handler exists in case any
197 * recycled events requiring this handler are pending */
198 pthread_mutex_lock (&(evt->generator_lock));
199 pthread_cond_signal (&(evt->generator_cond));
200 pthread_mutex_unlock (&(evt->generator_lock));
207 vce_event_thread_fn (void *arg)
209 vce_event_thread_t *evt = (vce_event_thread_t *) arg;
212 vce_event_handler_reg_t *handler;
214 u32 recycle_count = 0;
216 pthread_mutex_lock (&(evt->generator_lock));
219 uword fifo_depth = clib_fifo_elts (evt->event_index_fifo);
220 while ((fifo_depth == 0) || (recycle_count == fifo_depth))
223 pthread_cond_wait (&(evt->generator_cond), &(evt->generator_lock));
224 fifo_depth = clib_fifo_elts (evt->event_index_fifo);
229 clib_fifo_sub1 (evt->event_index_fifo, ev_idx);
230 ev = vce_get_event_from_index (evt, ev_idx);
232 if (recycle_count && ev->recycle)
234 clib_fifo_add1 (evt->event_index_fifo, ev_idx);
235 VCE_EVENTS_UNLOCK ();
238 VCE_HANDLERS_LOCK ();
240 p = hash_get (evt->handlers_index_by_event_key, ev->evk.as_u64);
243 /* If an event falls in the woods, and there is no handler to hear it,
244 * does it make any sound?
245 * I don't know either, so lets biff the event */
246 pool_put(evt->vce_events, ev);
247 VCE_EVENTS_UNLOCK ();
248 VCE_HANDLERS_UNLOCK ();
249 pthread_mutex_unlock (&(evt->generator_lock));
253 u32 evt_recycle = ev->recycle;
254 handler = pool_elt_at_index (evt->vce_event_handlers, p[0]);
255 handler->ev_idx = ev_idx;
258 VCE_EVENTS_UNLOCK ();
259 VCE_HANDLERS_UNLOCK ();
260 pthread_mutex_unlock (&(evt->generator_lock));
262 (handler->handler_fn)(handler);
265 ev = vce_get_event_from_index (evt, ev_idx);
266 recycle_count += (!evt_recycle && ev && ev->recycle) ? 1 : 0;
267 VCE_EVENTS_UNLOCK ();
270 pthread_mutex_lock (&(evt->generator_lock));
276 vce_start_event_thread (vce_event_thread_t *evt, u8 max_events)
278 clib_fifo_validate (evt->event_index_fifo, max_events);
279 evt->handlers_index_by_event_key = hash_create (0, sizeof (uword));
281 pthread_cond_init (&(evt->generator_cond), NULL);
282 pthread_mutex_init (&(evt->generator_lock), NULL);
284 clib_spinlock_init (&(evt->events_lockp));
285 clib_spinlock_init (&(evt->handlers_lockp));
287 return pthread_create (&(evt->thread), NULL /* attr */ ,
288 vce_event_thread_fn, evt);