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/vcl_event.h>
24 * @brief VPP Communications Library (VCL) event handler.
26 * Definitions for generic event handling in VCL.
30 vce_generate_event (vce_event_thread_t *evt, u32 ev_idx)
35 pthread_mutex_lock (&(evt->generator_lock));
37 /* Check there is event data for this event */
39 clib_spinlock_lock (&(evt->events_lockp));
40 p = pool_elt_at_index (evt->vce_events, ev_idx);
43 elts = (int) clib_fifo_free_elts (evt->event_index_fifo);
44 if (PREDICT_TRUE (elts))
46 /* Add event to queue */
47 clib_fifo_add1 (evt->event_index_fifo, ev_idx);
48 pthread_cond_signal (&(evt->generator_cond));
52 rv = VNET_API_ERROR_QUEUE_FULL;
55 clib_spinlock_unlock (&(evt->events_lockp));
56 pthread_mutex_unlock (&(evt->generator_lock));
62 vce_clear_event (vce_event_thread_t *evt, vce_event_t *ev)
64 clib_spinlock_lock (&(evt->events_lockp));
65 pool_put (evt->vce_events, ev);
66 clib_spinlock_unlock (&(evt->events_lockp));
70 vce_get_event_from_index(vce_event_thread_t *evt, u32 ev_idx)
74 clib_spinlock_lock (&(evt->events_lockp));
75 if ( ! pool_is_free_index (evt->vce_events, ev_idx))
76 ev = pool_elt_at_index (evt->vce_events, ev_idx);
77 clib_spinlock_unlock (&(evt->events_lockp));
82 vce_event_handler_reg_t *
83 vce_get_event_handler (vce_event_thread_t *evt, vce_event_key_t *evk)
85 vce_event_handler_reg_t *handler = 0;
88 clib_spinlock_lock (&evt->handlers_lockp);
89 p = hash_get (evt->handlers_index_by_event_key, evk->as_u64);
91 handler = pool_elt_at_index (evt->vce_event_handlers, p[0]);
92 clib_spinlock_unlock (&evt->handlers_lockp);
97 vce_event_handler_reg_t *
98 vce_register_handler (vce_event_thread_t *evt, vce_event_key_t *evk,
99 vce_event_callback_t cb, void *cb_args)
101 vce_event_handler_reg_t *handler;
102 vce_event_handler_reg_t *old_handler = 0;
106 /* TODO - multiple handler support. For now we can replace
107 * and re-instate, which is useful for event recycling */
109 clib_spinlock_lock (&evt->handlers_lockp);
111 p = hash_get (evt->handlers_index_by_event_key, evk->as_u64);
114 old_handler = pool_elt_at_index (evt->vce_event_handlers, p[0]);
115 /* If we are just re-registering, ignore and move on
116 * else store the old handler_fn for unregister to re-instate */
117 if (old_handler->handler_fn == cb)
120 clib_spinlock_unlock (&evt->handlers_lockp);
122 /* Signal event thread that a handler exists in case any
123 * recycled events requiring this handler are pending */
124 pthread_mutex_lock (&(evt->generator_lock));
125 pthread_cond_signal (&(evt->generator_cond));
126 pthread_mutex_unlock (&(evt->generator_lock));
131 pool_get (evt->vce_event_handlers, handler);
132 handler_index = (u32) (handler - evt->vce_event_handlers);
134 handler->handler_fn = cb;
135 handler->replaced_handler_idx = (p) ? p[0] : ~0;
136 handler->ev_idx = ~0; //This will be set by the event thread if event happens
137 handler->evk = evk->as_u64;
138 handler->handler_fn_args = cb_args;
140 hash_set (evt->handlers_index_by_event_key, evk->as_u64, handler_index);
142 pthread_cond_init (&(handler->handler_cond), NULL);
143 pthread_mutex_init (&(handler->handler_lock), NULL);
145 clib_spinlock_unlock (&evt->handlers_lockp);
147 /* Signal event thread that a new handler exists in case any
148 * recycled events requiring this handler are pending */
149 pthread_mutex_lock (&(evt->generator_lock));
150 pthread_cond_signal (&(evt->generator_cond));
151 pthread_mutex_unlock (&(evt->generator_lock));
157 vce_unregister_handler (vce_event_thread_t *evt,
158 vce_event_handler_reg_t *handler)
161 u64 evk = handler->evk;
162 u8 generate_signal = 0;
164 clib_spinlock_lock (&evt->handlers_lockp);
166 p = hash_get (evt->handlers_index_by_event_key, evk);
169 clib_spinlock_unlock (&evt->handlers_lockp);
170 return VNET_API_ERROR_NO_SUCH_ENTRY;
173 handler = pool_elt_at_index (evt->vce_event_handlers, p[0]);
175 /* If this handler replaced another handler, re-instate it */
176 if (handler->replaced_handler_idx != ~0)
178 hash_set (evt->handlers_index_by_event_key, evk,
179 handler->replaced_handler_idx);
184 hash_unset (evt->handlers_index_by_event_key, evk);
187 pthread_mutex_destroy (&(handler->handler_lock));
188 pthread_cond_destroy (&(handler->handler_cond));
189 pool_put (evt->vce_event_handlers, handler);
191 clib_spinlock_unlock (&evt->handlers_lockp);
195 /* Signal event thread that a new handler exists in case any
196 * recycled events requiring this handler are pending */
197 pthread_mutex_lock (&(evt->generator_lock));
198 pthread_cond_signal (&(evt->generator_cond));
199 pthread_mutex_unlock (&(evt->generator_lock));
206 vce_event_thread_fn (void *arg)
208 vce_event_thread_t *evt = (vce_event_thread_t *) arg;
211 vce_event_handler_reg_t *handler;
214 pthread_mutex_lock (&(evt->generator_lock));
215 clib_spinlock_lock (&(evt->events_lockp));
216 evt->recycle_event = 1; // Used for recycling events with no handlers
217 clib_spinlock_unlock (&(evt->events_lockp));
221 while ( (clib_fifo_elts (evt->event_index_fifo) == 0) ||
224 clib_spinlock_lock (&(evt->events_lockp));
225 evt->recycle_event = 0;
226 clib_spinlock_unlock (&(evt->events_lockp));
227 pthread_cond_wait (&(evt->generator_cond),
228 &(evt->generator_lock));
232 clib_spinlock_lock (&(evt->events_lockp));
234 clib_fifo_sub1 (evt->event_index_fifo, ev_idx);
235 ev = pool_elt_at_index (evt->vce_events, ev_idx);
239 clib_spinlock_lock (&evt->handlers_lockp);
241 p = hash_get (evt->handlers_index_by_event_key, ev->evk.as_u64);
244 /* If an event falls in the woods, and there is no handler to hear it,
245 * does it make any sound?
246 * I don't know either, so lets try recycling the event */
247 clib_fifo_add1 (evt->event_index_fifo, ev_idx);
248 evt->recycle_event = 1;
249 clib_spinlock_unlock (&(evt->events_lockp));
250 clib_spinlock_unlock (&evt->handlers_lockp);
251 pthread_mutex_unlock (&(evt->generator_lock));
255 handler = pool_elt_at_index (evt->vce_event_handlers, p[0]);
256 handler->ev_idx = ev_idx;
258 clib_spinlock_unlock (&(evt->events_lockp));
259 clib_spinlock_unlock (&evt->handlers_lockp);
260 pthread_mutex_unlock (&(evt->generator_lock));
262 (handler->handler_fn)(handler);
265 pthread_mutex_lock (&(evt->generator_lock));
272 vce_start_event_thread (vce_event_thread_t *evt, u8 max_events)
274 clib_fifo_validate (evt->event_index_fifo, max_events);
275 evt->handlers_index_by_event_key = hash_create (0, sizeof (uword));
277 pthread_cond_init (&(evt->generator_cond), NULL);
278 pthread_mutex_init (&(evt->generator_lock), NULL);
280 clib_spinlock_init (&(evt->events_lockp));
281 clib_spinlock_init (&(evt->handlers_lockp));
283 return pthread_create (&(evt->thread), NULL /* attr */ ,
284 vce_event_thread_fn, evt);