/*
* Copyright (c) 2018 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef VPP_VCL_EVENT_H
#define VPP_VCL_EVENT_H
#include <vppinfra/cache.h>
#include <vppinfra/mem.h>
#define VCE_EVENTS_LOCK() clib_spinlock_lock (&(evt->events_lockp))
#define VCE_EVENTS_UNLOCK() clib_spinlock_unlock (&(evt->events_lockp))
#define VCE_HANDLERS_LOCK() clib_spinlock_lock (&(evt->handlers_lockp))
#define VCE_HANDLERS_UNLOCK() clib_spinlock_unlock (&(evt->handlers_lockp))
#define VCE_IO_SESSIONS_LOCK() clib_spinlock_lock (&(evt->io_sessions_lockp))
#define VCE_IO_SESSIONS_UNLOCK() \
clib_spinlock_unlock (&(evt->io_sessions_lockp))
typedef struct vppcom_ioevent_
{
uint32_t session_index;
size_t bytes;
} vppcom_ioevent_t;
/**
* @file
* @brief VPP Communications Library (VCL) event handler.
*
* Declarations for generic event handling in VCL.
*/
#include <vppinfra/types.h>
#include <vppinfra/lock.h>
#include <pthread.h>
/**
* User registered callback for when connection arrives on listener created
* with vppcom_session_register_listener()
* @param uint32_t - newly accepted session_index
* @param vppcom_endpt_t* - ip/port information of remote
* @param void* - user passed arg to pass back
*/
typedef void (*vppcom_session_listener_cb) (uint32_t, vppcom_endpt_t *,
void *);
/**
* User registered callback for IO events (rx/tx)
* @param vppcom_ioevent_t* -
* @param void* - user passed arg to pass back
*/
typedef void (*vppcom_session_ioevent_cb) (vppcom_ioevent_t *, void *);
/**
* User registered ERROR callback for any errors associated with
* handling vppcom_session_register_listener() and connections
* @param void* - user passed arg to pass back
*/
typedef void (*vppcom_session_listener_errcb) (void *);
typedef enum vcl_event_id_
{
VCL_EVENT_INVALID_EVENT,
VCL_EVENT_CONNECT_REQ_ACCEPTED,
VCL_EVENT_IOEVENT_RX_FIFO,
VCL_EVENT_IOEVENT_TX_FIFO,
VCL_EVENT_N_EVENTS
} vcl_event_id_t;
/* VPPCOM Event typedefs */
typedef struct vppcom_session_listener
{
vppcom_session_listener_cb user_cb;
vppcom_session_listener_errcb user_errcb;
void *user_cb_data;
} vppcom_session_listener_t;
typedef struct vppcom_session_ioevent_
{
vppcom_session_ioevent_cb user_cb;
void *user_cb_data;
} vppcom_session_ioevent_t;
typedef struct vppcom_session_io_thread_
{
pthread_t thread;
pthread_mutex_t vce_io_lock;
pthread_cond_t vce_io_cond;
u32 *active_session_indexes; //pool
vppcom_session_ioevent_t *ioevents; //pool
clib_spinlock_t io_sessions_lockp;
} vppcom_session_io_thread_t;
typedef struct vce_event_connect_request_
{
u32 accepted_session_index;
} vce_event_connect_request_t;
typedef union vce_event_key_
{
struct {
u32 eid;
u32 session_index;
};
u64 as_u64;
} vce_event_key_t;
typedef struct vce_event_
{
vce_event_key_t evk;
u32 recycle;
u64 data[2]; // Hard code size to avoid allocator thrashing.
} vce_event_t;
typedef void (*vce_event_callback_t) (void *reg /*vce_event_handler_reg_t* */);
typedef struct vce_event_handler_reg_
{
vce_event_callback_t handler_fn;
pthread_mutex_t handler_lock;
pthread_cond_t handler_cond;
u32 ev_idx;
u64 evk; //Event key
u32 replaced_handler_idx;
void *handler_fn_args;
} vce_event_handler_reg_t;
typedef struct vce_event_thread_
{
pthread_t thread;
pthread_mutex_t generator_lock;
pthread_cond_t generator_cond;
u32 *event_index_fifo;
u8 recycle_event;
clib_spinlock_t events_lockp;
vce_event_t *vce_events; //pool
clib_spinlock_t handlers_lockp;
vce_event_handler_reg_t *vce_event_handlers; //pool
uword *handlers_index_by_event_key; //hash
} vce_event_thread_t;
/**
* @brief vppcom_session_register_listener accepts a bound session_index, and
* listens for connections.
*
* On successful connection, calls registered callback (cb) with new
* session_index.
*
* On error, calls registered error callback (errcb).
*
* @param session_index - bound session_index to create listener on
* @param cb - on new accepted session callback
* @param errcb - on failure callback
* @param flags - placeholder for future use. Must be ZERO
* @param q_len - max listener connection backlog
* @param ptr - user data
* @return
*/
extern int vppcom_session_register_ioevent_cb (uint32_t session_index,
vppcom_session_ioevent_cb cb,
uint8_t rx, void *ptr);
/**
* @brief vppcom_session_register_listener accepts a bound session_index, and
* listens for connections.
*
* On successful connection, calls registered callback (cb) with new
* session_index.
*
* On error, calls registered error callback (errcb).
*
* @param session_index - bound session_index to create listener on
* @param cb - on new accepted session callback
* @param errcb - on failure callback
* @param flags - placeholder for future use. Must be ZERO
* @param q_len - max listener connection backlog
* @param ptr - user data
* @return
*/
extern int vppcom_session_register_listener (uint32_t session_index,
vppcom_session_listener_cb cb,
vppcom_session_listener_errcb
errcb, uint8_t flags, int q_len,
void *ptr);
/**
* @brief vce_generate_event
* - used to trigger an event in the event thread so that registered
* handlers are notified
*
* @param evt - vce_event_thread_t - event system state
* @param ev_idx - index to vce_event_thread_t vce_event pool
*
* @return success/failure rv
*/
int vce_generate_event (vce_event_thread_t *evt, u32 ev_idx);
/**
* @brief vce_clear_event()
* - removes event from event_pool
*
* @param evt - vce_event_thread_t - event system state
* @param ev_idx - u32 - index of event to remove
*/
void vce_clear_event (vce_event_thread_t *evt, u32 ev_idx);
/**
* @brief vce_get_event_from_index()
*
* @param evt - vce_event_thread_t - event system state
* @param ev_idx - index to vce_event_thread_t vce_event pool
*
* @return vce_event_t *
*/
vce_event_t * vce_get_event_from_index(vce_event_thread_t *evt, u32 ev_idx);
/**
* @brief vce_get_event_data()
*
* @param ev - vce_event_t * - event
* @param data_size - u32 - required size of data
*
* @return vce_event_t *
*/
always_inline void * vce_get_event_data(vce_event_t *ev, u32 data_size)
{
ASSERT(sizeof(ev->data) >= data_size);
return (&ev->data);
}
/**
* @brief vce_get_event_handler()
* - returns handler if exists or 0
* @param evt - vce_event_thread_t - event system state
* @param evk - event key
* @return vce_event_handler_reg_t *
*/
vce_event_handler_reg_t * vce_get_event_handler (vc