rm->vlib_main = vm;
rm->vnet_main = vnet_get_main ();
- rm->api_main = &api_main;
+ rm->api_main = vlibapi_get_main ();
rm->node_index = dhcp6_client_cp_process_node.index;
return NULL;
rm->vlib_main = vm;
rm->vnet_main = vnet_get_main ();
- rm->api_main = &api_main;
+ rm->api_main = vlibapi_get_main ();
rm->node_index = dhcp6_pd_client_cp_process_node.index;
return (NULL);
dm->name_cache_size = 1000;
dm->max_ttl_in_seconds = 86400;
dm->random_seed = 0xDEADDABE;
- dm->api_main = &api_main;
+ dm->api_main = vlibapi_get_main ();
/* Ask for a correctly-sized block of API message decode slots */
dm->msg_id_base = setup_message_id_table ();
static int
create_api_loopback (echo_client_main_t * ecm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
vl_shmem_hdr_t *shmem_hdr;
shmem_hdr = am->shmem_hdr;
create_api_loopback (vlib_main_t * vm)
{
echo_server_main_t *esm = &echo_server_main;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
vl_shmem_hdr_t *shmem_hdr;
shmem_hdr = am->shmem_hdr;
create_api_loopbacks (vlib_main_t * vm)
{
proxy_main_t *pm = &proxy_main;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
vl_shmem_hdr_t *shmem_hdr;
shmem_hdr = am->shmem_hdr;
connect_to_vpp (char *name)
{
echo_main_t *em = &echo_main;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
if (em->use_sock_api)
{
lacp_plugin_api_hookup (vlib_main_t * vm)
{
lacp_main_t *lm = &lacp_main;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
/* Ask for a correctly-sized block of API message decode slots */
lm->msg_id_base = setup_message_id_table ();
u8 *name;
vl_api_mactime_add_del_range_t *mp;
- am = &api_main;
+ am = vlibapi_get_main ();
shmem_hdr = am->shmem_hdr;
mp = vl_msg_api_alloc_as_if_client (sizeof (*mp));
clib_memset (mp, 0, sizeof (*mp));
static int
connect_to_vpp (char *name)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
mt_main_t *mm = &mt_main;
u8 *msg_base_lookup_name;
sm->vnet_main = vnet_get_main ();
sm->ip4_main = im;
sm->ip4_lookup_main = lm;
- sm->api_main = &api_main;
+ sm->api_main = vlibapi_get_main ();
sm->first_worker_index = 0;
sm->num_workers = 0;
sm->num_snat_thread = 1;
error = nsh_plugin_api_hookup (vm);
/* Add our API messages to the global name_crc hash table */
- setup_message_id_table (nm, &api_main);
+ setup_message_id_table (nm, vlibapi_get_main ());
vec_free (name);
shm_name = shm_name_from_svm_map_region_args (a);
- if (CLIB_DEBUG > 1)
+ if (1 || CLIB_DEBUG > 1)
clib_warning ("[%d] map region %s: shm_open (%s)",
getpid (), a->name, shm_name);
write(hdr.format(module=module))
write('static u16\n')
write('setup_message_id_table (void) {\n')
- write(' api_main_t *am = &api_main;\n')
+ write(' api_main_t *am = my_api_main;\n')
write(' u16 msg_id_base = vl_msg_api_get_msg_ids ("{}_{crc:08x}", VL_MSG_FIRST_AVAILABLE);\n'
.format(module, crc=file_crc))
{
vat_main_t *vam = &vat_main;
vat_json_node_t node;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
void *oldheap;
u8 *reply;
(vl_api_get_node_graph_reply_t * mp)
{
vat_main_t *vam = &vat_main;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
i32 retval = ntohl (mp->retval);
u8 *pvt_copy, *reply;
void *oldheap;
(vl_api_get_node_graph_reply_t * mp)
{
vat_main_t *vam = &vat_main;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
void *oldheap;
vat_json_node_t node;
u8 *reply;
static int
dump_msg_api_table (vat_main_t * vam)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
name_sort_t *nses = 0, *ns;
hash_pair_t *hp;
int i;
connect_to_vpe (char *name)
{
vat_main_t *vam = &vat_main;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
if (vl_client_connect_to_vlib ("/vpe-api", name, 32) < 0)
return -1;
if (vam->client_index_invalid)
{
vat_main_t *vam = &vat_main;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
vam->vl_input_queue = am->shmem_hdr->vl_input_queue;
vam->my_client_index = am->my_client_index;
vppcom_connect_to_vpp (char *app_name)
{
vcl_worker_t *wrk = vcl_worker_get_current ();
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
vppcom_cfg_t *vcl_cfg = &vcm->cfg;
if (vcl_cfg->vpp_api_socket_name)
vcl_cleanup_bapi (void)
{
socket_client_main_t *scm = &socket_client_main;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
am->my_client_index = ~0;
am->my_registration = 0;
\
static void __vl_msg_api_add_##tag##_function_##x (void) \
{ \
- api_main_t * am = &api_main; \
+ api_main_t * am = vlibapi_get_main(); \
static _vl_msg_api_function_list_elt_t _vl_msg_api_function; \
_vl_msg_api_function.next_init_function \
= am->tag##_function_registrations; \
} api_main_t;
-extern api_main_t api_main;
+extern __thread api_main_t *my_api_main;
+extern api_main_t api_global_main;
+
+always_inline api_main_t *
+vlibapi_get_main (void)
+{
+ return my_api_main;
+}
#endif /* included_api_common_h */
#include <vppinfra/elog.h>
/* *INDENT-OFF* */
-api_main_t api_main =
+api_main_t api_global_main =
{
.region_name = "/unset",
.api_uid = -1,
};
/* *INDENT-ON* */
+/* Please use vlibapi_get_main() to access my_api_main */
+__thread api_main_t *my_api_main = &api_global_main;
+
+void
+vl_msg_api_set_global_main (void *am_arg)
+{
+ ASSERT (am_arg);
+ my_api_main = (api_main_t *) am_arg;
+}
+
void
vl_msg_api_increment_missing_client_counter (void)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
am->missing_clients++;
}
void
vl_msg_api_handler (void *the_msg)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
msg_handler_internal (am, the_msg,
(am->rx_trace
void
vl_msg_api_handler_no_free (void *the_msg)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
msg_handler_internal (am, the_msg,
(am->rx_trace
&& am->rx_trace->enabled) /* trace_it */ ,
void
vl_msg_api_handler_no_trace_no_free (void *the_msg)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
msg_handler_internal (am, the_msg, 0 /* trace_it */ , 1 /* do_it */ ,
0 /* free_it */ );
}
void
vl_msg_api_trace_only (void *the_msg)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
msg_handler_internal (am, the_msg,
(am->rx_trace
void
vl_msg_api_cleanup_handler (void *the_msg)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
u16 id = clib_net_to_host_u16 (*((u16 *) the_msg));
if (PREDICT_FALSE (id >= vec_len (am->msg_cleanup_handlers)))
void
vl_msg_api_replay_handler (void *the_msg)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
u16 id = clib_net_to_host_u16 (*((u16 *) the_msg));
void
vl_msg_api_socket_handler (void *the_msg)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
msg_handler_internal (am, the_msg,
(am->rx_trace
void
vl_msg_api_config (vl_msg_api_msg_config_t * c)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
/*
* This happens during the java core tests if the message
void
vl_msg_api_set_cleanup_handler (int msg_id, void *fp)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
ASSERT (msg_id > 0);
vec_validate (am->msg_cleanup_handlers, msg_id);
void
vl_msg_api_post_mortem_dump (void)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
FILE *fp;
char filename[64];
int rv;
void
vl_msg_api_register_pd_handler (void *fp, u16 msg_id_host_byte_order)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
/* Mild idiot proofing */
if (msg_id_host_byte_order > 10000)
int
vl_msg_api_pd_handler (void *mp, int rv)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
int (*fp) (void *, int);
u16 msg_id;
void
vl_msg_api_set_first_available_msg_id (u16 first_avail)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
am->first_available_msg_id = first_avail;
}
u16
vl_msg_api_get_msg_ids (const char *name, int n)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
u8 *name_copy;
vl_api_msg_range_t *rp;
uword *p;
u32
vl_msg_api_get_msg_index (u8 * name_and_crc)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
uword *p;
if (am->msg_index_by_name_and_crc)
void *
vl_msg_push_heap (void)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
pthread_mutex_lock (&am->vlib_rp->mutex);
return svm_push_data_heap (am->vlib_rp);
}
void
vl_msg_pop_heap (void *oldheap)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
svm_pop_heap (oldheap);
pthread_mutex_unlock (&am->vlib_rp->mutex);
}
void
vl_api_set_elog_main (elog_main_t * m)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
am->elog_main = m;
}
vl_api_set_elog_trace_api_messages (int enable)
{
int rv;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
rv = am->elog_trace_api_messages;
am->elog_trace_api_messages = enable;
int
vl_api_get_elog_trace_api_messages (void)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
return am->elog_trace_api_messages;
}
memclnt_queue_callback (vlib_main_t * vm)
{
int i;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
if (PREDICT_FALSE (vec_len (vl_api_queue_cursizes) !=
1 + vec_len (am->vlib_private_rps)))
vl_api_registration_t *regp;
svm_region_t *svm;
void *oldheap;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
ASSERT (vlib_get_thread_index () == 0);
pool_get (am->vl_clients, regpp);
svm_queue_t *q;
int rv = 0;
void *oldheap;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
u8 *msg_table;
/*
clib_error_t *error = 0;
_vl_msg_api_function_list_elt_t *i;
- i = api_main.reaper_function_registrations;
+ i = vlibapi_get_main ()->reaper_function_registrations;
while (i)
{
error = i->f (client_index);
vl_api_memclnt_delete_reply_t *rp;
svm_region_t *svm;
void *oldheap;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
u32 handle, client_index, epoch;
handle = mp->index;
api_main_t *am;
vl_shmem_hdr_t *shmem_hdr;
- am = &api_main;
+ am = vlibapi_get_main ();
shmem_hdr = am->shmem_hdr;
rmp = vl_msg_api_alloc_as_if_client (sizeof (*rmp));
vl_mem_api_init (const char *region_name)
{
int rv;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
vl_msg_api_msg_config_t cfg;
vl_msg_api_msg_config_t *c = &cfg;
vl_shmem_hdr_t *shm;
clib_error_t *
map_api_segment_init (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
int rv;
if ((rv = vl_mem_api_init (am->region_name)) < 0)
send_memclnt_keepalive (vl_api_registration_t * regp, f64 now)
{
vl_api_memclnt_keepalive_t *mp;
- api_main_t *am = &api_main;
svm_queue_t *q;
+ api_main_t *am = vlibapi_get_main ();
q = regp->vl_input_queue;
int
vl_mem_api_handle_msg_main (vlib_main_t * vm, vlib_node_runtime_t * node)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
return void_mem_api_handle_msg_i (am, am->vlib_rp, vm, node,
0 /* is_private */ );
}
int
vl_mem_api_handle_rpc (vlib_main_t * vm, vlib_node_runtime_t * node)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
int i;
uword *tmp, mp;
vl_mem_api_handle_msg_private (vlib_main_t * vm, vlib_node_runtime_t * node,
u32 reg_index)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
return void_mem_api_handle_msg_i (am, am->vlib_private_rps[reg_index], vm,
node, 1 /* is_private */ );
{
vl_api_registration_t **regpp;
vl_api_registration_t *regp;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
vl_shmem_hdr_t *shmem_hdr;
u32 index;
vl_api_client_index_to_input_queue (u32 index)
{
vl_api_registration_t *regp;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
/* Special case: vlib trying to send itself a message */
if (index == (u32) ~ 0)
{
int i;
vl_shmem_hdr_t *shmem_hdr;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
/* First, dump the primary region rings.. */
clib_error_t *
vlibmemory_init (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
svm_map_region_args_t _a, *a = &_a;
u8 *remove_path1, *remove_path2;
void vlibsocket_reference (void);
void
vl_set_memory_region_name (const char *name)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
am->region_name = name;
}
#include <vppinfra/serialize.h>
#include <vppinfra/hash.h>
#include <vlibmemory/memory_client.h>
+#include <vlibapi/api_common.h>
/* A hack. vl_client_get_first_plugin_msg_id depends on it */
#include <vlibmemory/socket_client.h>
#undef vl_printfun
memory_client_main_t memory_client_main;
+__thread memory_client_main_t *my_memory_client_main = &memory_client_main;
static void *
rx_thread_fn (void *arg)
{
svm_queue_t *q;
- memory_client_main_t *mm = &memory_client_main;
- api_main_t *am = &api_main;
+ memory_client_main_t *mm = vlibapi_get_memory_client_main ();
- q = am->vl_input_queue;
+ q = vlibapi_get_main ()->vl_input_queue;
/* So we can make the rx thread terminate cleanly */
if (setjmp (mm->rx_thread_jmpbuf) == 0)
static void
vl_api_rx_thread_exit_t_handler (vl_api_rx_thread_exit_t * mp)
{
- memory_client_main_t *mm = &memory_client_main;
+ memory_client_main_t *mm = vlibapi_get_memory_client_main ();
if (mm->rx_thread_jmpbuf_valid)
longjmp (mm->rx_thread_jmpbuf, 1);
}
static void
vl_api_name_and_crc_free (void)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
int i;
u8 **keys = 0;
hash_pair_t *hp;
vl_api_memclnt_create_reply_t_handler (vl_api_memclnt_create_reply_t * mp)
{
serialize_main_t _sm, *sm = &_sm;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
u8 *tblv;
u32 nmsgs;
int i;
vl_shmem_hdr_t *shmem_hdr;
int rv = 0;
void *oldheap;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
if (am->my_registration)
{
vl_api_memclnt_delete_reply_t_handler (vl_api_memclnt_delete_reply_t * mp)
{
void *oldheap;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
pthread_mutex_lock (&am->vlib_rp->mutex);
oldheap = svm_push_data_heap (am->vlib_rp);
{
vl_api_memclnt_delete_t *mp;
vl_shmem_hdr_t *shmem_hdr;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
ASSERT (am->vlib_rp);
shmem_hdr = am->shmem_hdr;
{
vl_api_memclnt_delete_reply_t *rp;
svm_queue_t *vl_input_queue;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
time_t begin;
vl_input_queue = am->vl_input_queue;
api_main_t *am;
vl_shmem_hdr_t *shmem_hdr;
- am = &api_main;
+ am = vlibapi_get_main ();
shmem_hdr = am->shmem_hdr;
rmp = vl_msg_api_alloc_as_if_client (sizeof (*rmp));
connect_to_vlib_internal (const char *svm_name,
const char *client_name,
int rx_queue_size, void *(*thread_fn) (void *),
- int do_map)
+ void *thread_fn_arg, int do_map)
{
int rv = 0;
- memory_client_main_t *mm = &memory_client_main;
- api_main_t *am = &api_main;
+ memory_client_main_t *mm = vlibapi_get_memory_client_main ();
+ api_main_t *am = vlibapi_get_main ();
if (do_map && (rv = vl_client_api_map (svm_name)))
{
if (thread_fn)
{
rv = pthread_create (&mm->rx_thread_handle,
- NULL /*attr */ , thread_fn, 0);
+ NULL /*attr */ , thread_fn, thread_fn_arg);
if (rv)
{
clib_warning ("pthread_create returned %d", rv);
const char *client_name, int rx_queue_size)
{
return connect_to_vlib_internal (svm_name, client_name, rx_queue_size,
- rx_thread_fn, 1 /* do map */ );
+ rx_thread_fn, 0 /* thread fn arg */ ,
+ 1 /* do map */ );
}
int
{
return connect_to_vlib_internal (svm_name, client_name, rx_queue_size,
0 /* no rx_thread_fn */ ,
+ 0 /* no thread fn arg */ ,
1 /* do map */ );
}
const char *client_name, int rx_queue_size)
{
return connect_to_vlib_internal (svm_name, client_name, rx_queue_size,
- rx_thread_fn, 0 /* dont map */ );
+ rx_thread_fn, 0 /* no thread fn arg */ ,
+ 0 /* dont map */ );
}
int
int rx_queue_size)
{
return connect_to_vlib_internal (svm_name, client_name, rx_queue_size,
- 0 /* want pthread */ ,
+ 0 /* no thread_fn */ ,
+ 0 /* no thread fn arg */ ,
0 /* dont map */ );
}
vl_client_connect_to_vlib_thread_fn (const char *svm_name,
const char *client_name,
int rx_queue_size,
- void *(*thread_fn) (void *))
+ void *(*thread_fn) (void *), void *arg)
{
return connect_to_vlib_internal (svm_name, client_name, rx_queue_size,
- thread_fn, 1 /* do map */ );
+ thread_fn, arg, 1 /* do map */ );
}
static void
disconnect_from_vlib_internal (u8 do_unmap)
{
- memory_client_main_t *mm = &memory_client_main;
- api_main_t *am = &api_main;
+ memory_client_main_t *mm = vlibapi_get_memory_client_main ();
+ api_main_t *am = vlibapi_get_main ();
uword junk;
if (mm->rx_thread_jmpbuf_valid)
static void vl_api_get_first_msg_id_reply_t_handler
(vl_api_get_first_msg_id_reply_t * mp)
{
- memory_client_main_t *mm = &memory_client_main;
+ memory_client_main_t *mm = vlibapi_get_memory_client_main ();
i32 retval = ntohl (mp->retval);
mm->first_msg_id_reply = (retval >= 0) ? ntohs (mp->first_msg_id) : ~0;
vl_client_get_first_plugin_msg_id (const char *plugin_name)
{
vl_api_get_first_msg_id_t *mp;
- api_main_t *am = &api_main;
- memory_client_main_t *mm = &memory_client_main;
+ api_main_t *am = vlibapi_get_main ();
+ memory_client_main_t *mm = vlibapi_get_memory_client_main ();
f64 timeout;
void *old_handler;
clib_time_t clib_time;
} memory_client_main_t;
extern memory_client_main_t memory_client_main;
+extern __thread memory_client_main_t *my_memory_client_main;
int vl_client_connect (const char *name, int ctx_quota, int input_queue_size);
void vl_client_send_disconnect (u8 do_cleanup);
int vl_client_connect_to_vlib_thread_fn (const char *svm_name,
const char *client_name,
int rx_queue_size,
- void *(*)(void *));
+ void *(*)(void *), void *);
int vl_client_connect_to_vlib_no_rx_pthread (const char *svm_name,
const char *client_name,
int rx_queue_size);
void vl_client_install_client_message_handlers (void);
u8 vl_mem_client_is_connected (void);
+always_inline memory_client_main_t *
+vlibapi_get_memory_client_main (void)
+{
+ ASSERT (my_memory_client_main);
+ return my_memory_client_main;
+}
+
#endif /* SRC_VLIBMEMORY_MEMORY_CLIENT_H_ */
/*
#include <vlib/unix/unix.h>
#include <vlibmemory/memory_api.h>
#include <vlibmemory/vl_memory_msg_enum.h>
+#include <vlibapi/api_common.h>
#define vl_typedefs
#include <vlibmemory/vl_memory_api_h.h>
svm_queue_t *q;
void *oldheap;
vl_shmem_hdr_t *shmem_hdr;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
shmem_hdr = (void *) vlib_rp->user_ctx;
q->head);
msg_idp = (u16 *) (rv->data);
msg_id = clib_net_to_host_u16 (*msg_idp);
- if (msg_id < vec_len (api_main.msg_names))
+ if (msg_id < vec_len (vlibapi_get_main ()->msg_names))
clib_warning ("msg id %d name %s", (u32) msg_id,
- api_main.msg_names[msg_id]);
+ vlibapi_get_main ()->msg_names[msg_id]);
}
shmem_hdr->garbage_collects++;
goto collected;
vl_msg_api_alloc (int nbytes)
{
int pool;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr;
/*
vl_msg_api_alloc_or_null (int nbytes)
{
int pool;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr;
pool = (am->our_pid == shmem_hdr->vl_pid);
void *
vl_msg_api_alloc_as_if_client (int nbytes)
{
- return vl_msg_api_alloc_internal (api_main.vlib_rp, nbytes, 0,
+ api_main_t *am = vlibapi_get_main ();
+ return vl_msg_api_alloc_internal (am->vlib_rp, nbytes, 0,
0 /* may_return_null */ );
}
void *
vl_msg_api_alloc_as_if_client_or_null (int nbytes)
{
- return vl_msg_api_alloc_internal (api_main.vlib_rp, nbytes, 0,
+ api_main_t *am = vlibapi_get_main ();
+ return vl_msg_api_alloc_internal (am->vlib_rp, nbytes, 0,
1 /* may_return_null */ );
}
void
vl_msg_api_free (void *a)
{
- vl_msg_api_free_w_region (api_main.vlib_rp, a);
+ api_main_t *am = vlibapi_get_main ();
+ vl_msg_api_free_w_region (am->vlib_rp, a);
}
static void
{
msgbuf_t *rv;
void *oldheap;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
rv = (msgbuf_t *) (((u8 *) a) - offsetof (msgbuf_t, data));
/*
void
vl_set_memory_root_path (const char *name)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
am->root_path = name;
}
void
vl_set_memory_uid (int uid)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
am->api_uid = uid;
}
void
vl_set_memory_gid (int gid)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
am->api_gid = gid;
}
void
vl_set_global_memory_baseva (u64 baseva)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
am->global_baseva = baseva;
}
void
vl_set_global_memory_size (u64 size)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
am->global_size = size;
}
void
vl_set_api_memory_size (u64 size)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
am->api_size = size;
}
void
vl_set_global_pvt_heap_size (u64 size)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
am->global_pvt_heap_size = size;
}
void
vl_set_api_pvt_heap_size (u64 size)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
am->api_pvt_heap_size = size;
}
static void
vl_api_default_mem_config (vl_shmem_hdr_t * shmem_hdr)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
u32 vlib_input_queue_length;
/* vlib main input queue */
vl_init_shmem (svm_region_t * vlib_rp, vl_api_shm_elem_config_t * config,
int is_vlib, int is_private_region)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
vl_shmem_hdr_t *shmem_hdr = 0;
void *oldheap;
ASSERT (vlib_rp);
{
svm_map_region_args_t _a, *a = &_a;
svm_region_t *vlib_rp, *root_rp;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
int i;
struct timespec ts, tsrem;
char *vpe_api_region_suffix = "-vpe-api";
void
vl_register_mapped_shmem_region (svm_region_t * rp)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
vec_add1 (am->mapped_shmem_regions, rp);
}
{
svm_region_t *rp;
int i;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
if (!svm_get_root_rp ())
return;
void
vl_msg_api_send_shmem (svm_queue_t * q, u8 * elem)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
void *msg = (void *) *(uword *) elem;
if (am->tx_trace && am->tx_trace->enabled)
void
vl_msg_api_send_shmem_nolock (svm_queue_t * q, u8 * elem)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
void *msg = (void *) *(uword *) elem;
if (am->tx_trace && am->tx_trace->enabled)
#endif
socket_main_t *sm = &socket_main;
u16 msg_id = ntohs (*(u16 *) elem);
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
msgbuf_t *mb = (msgbuf_t *) (elem - offsetof (msgbuf_t, data));
vl_api_registration_t *sock_rp;
clib_file_main_t *fm = &file_main;
{
vl_api_registration_t *regp;
vl_api_sockclnt_create_reply_t *rp;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
hash_pair_t *hp;
int rv = 0;
u32 nmsg = hash_elts (am->msg_index_by_name_and_crc);
ssvm_private_t _memfd_private, *memfd = &_memfd_private;
svm_map_region_args_t _args, *a = &_args;
vl_api_registration_t *regp;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
svm_region_t *vlib_rp;
clib_file_t *cf;
vl_api_shm_elem_config_t *config = 0;
socket_client_main_t *scm = socket_client_ctx;
ssvm_private_t *memfd = &scm->memfd_segment;
i32 retval = ntohl (mp->retval);
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
clib_error_t *error;
int my_fd = -1;
u8 *new_name;
vl_api_get_first_msg_id_reply_t *rmp;
vl_api_registration_t *regp;
uword *p;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
vl_api_msg_range_t *rp;
u8 name[64];
u16 first_msg_id = ~0;
void
vl_api_api_versions_t_handler (vl_api_api_versions_t * mp)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
vl_api_api_versions_reply_t *rmp;
vl_api_registration_t *reg;
u32 nmsg = vec_len (am->api_version_list);
send_one_plugin_msg_ids_msg (u8 * name, u16 first_msg_id, u16 last_msg_id)
{
vl_api_trace_plugin_msg_ids_t *mp;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr;
svm_queue_t *q;
vl_api_save_msg_table (void)
{
u8 *serialized_message_table;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
u8 *chroot_file;
int fd, rv;
vl_shmem_hdr_t *shm;
svm_queue_t *q;
clib_error_t *e;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
f64 dead_client_scan_time;
f64 sleep_time, start_time;
f64 vector_rate;
static void
vl_api_trace_plugin_msg_ids_t_handler (vl_api_trace_plugin_msg_ids_t * mp)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
vl_api_msg_range_t *rp;
uword *p;
static clib_error_t *
rpc_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
vl_api_##n##_t_handler, \
vl_api_registration_t **regpp, *regp;
svm_queue_t *q;
char *health;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
u32 *confused_indices = 0;
if (!pool_elts (am->vl_clients))
vl_api_status_command (vlib_main_t * vm,
unformat_input_t * input, vlib_cli_command_t * cli_cmd)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
/* check if rx_trace and tx_trace are not null pointers */
if (am->rx_trace == 0)
unformat_input_t * input,
vlib_cli_command_t * cli_cmd)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
int i;
int verbose = 0;
unformat_input_t * input,
vlib_cli_command_t * cli_cmd)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
vl_api_msg_range_t *rp = 0;
int i;
struct stat statb;
size_t file_size;
u8 *msg;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
u8 *tmpbuf = 0;
u32 nitems, nitems_msgtbl;
void **saved_print_handlers = 0;
unformat_input_t * input, vlib_cli_command_t * cmd)
{
u32 nitems = 256 << 10;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
vl_api_trace_which_t which = VL_API_TRACE_RX;
u8 *filename = 0;
u8 *chroot_filename = 0;
{
u32 nitems = 1024;
vl_api_trace_which_t which = VL_API_TRACE_RX;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
{
u32 nitems = 256 << 10;
vl_api_trace_which_t which = VL_API_TRACE_RX;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
static clib_error_t *
api_queue_config_fn (vlib_main_t * vm, unformat_input_t * input)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
u32 nitems;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
vlib_cli_command_t * cmd)
{
u8 *filename = 0;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
serialize_main_t _sm, *sm = &_sm;
clib_error_t *error;
u32 nmsgs;
static clib_error_t *
bfd_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N, n) \
vl_msg_api_set_handlers (VL_API_##N, #n, vl_api_##n##_t_handler, \
static clib_error_t *
bier_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
bond_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
classify_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
cop_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
af_packet_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
netmap_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
pipe_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
tapv2_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
vhost_user_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
virtio_pci_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
p2p_ethernet_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
feature_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
geneve_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
gre_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
feature_gso_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
interface_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
ip_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
punt_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
rd_cp_init (vlib_main_t * vm)
{
rd_cp_main_t *rm = &rd_cp_main;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
rm->vlib_main = vm;
rm->vnet_main = vnet_get_main ();
static clib_error_t *
flow_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
ipsec_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
l2_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
l2tp_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
lisp_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
one_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
gpe_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
lldp_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
mpls_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
pg_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
policer_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
qos_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
{
u32 evt_q_length = 2048, evt_size = sizeof (session_event_t);
ssvm_private_t *eqs = &smm->evt_qs_segment;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
uword eqs_size = 64 << 20;
pid_t vpp_pid = getpid ();
void *oldheap;
static clib_error_t *
session_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
span_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
sr_mpls_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
sr_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
syslog_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
tcp_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
udp_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
vxlan_gbp_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
vxlan_gpe_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
static clib_error_t *
vxlan_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
vl_api_memclnt_keepalive_t *mp;
vl_api_memclnt_keepalive_reply_t *rmp;
vac_main_t *pm = &vac_main;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main();
vl_shmem_hdr_t *shmem_hdr;
uword msg;
{
vl_api_memclnt_read_timeout_t *ep;
vac_main_t *pm = &vac_main;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main();
struct timespec ts;
struct timeval tv;
int rv;
void
vac_rx_suspend (void)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main();
vac_main_t *pm = &vac_main;
vl_api_memclnt_rx_thread_suspend_t *ep;
static uword *
vac_msg_table_get_hash (void)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main();
return (am->msg_index_by_name_and_crc);
}
int
vac_msg_table_size(void)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main();
return hash_elts(am->msg_index_by_name_and_crc);
}
int
vac_disconnect (void)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main();
vac_main_t *pm = &vac_main;
uword junk;
int rv = 0;
vac_read (char **p, int *l, u16 timeout)
{
svm_queue_t *q;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main();
vac_main_t *pm = &vac_main;
vl_api_memclnt_keepalive_t *mp;
vl_api_memclnt_keepalive_reply_t *rmp;
shmem_hdr = am->shmem_hdr;
vl_msg_api_send_shmem(shmem_hdr->vl_input_queue, (u8 *)&rmp);
vl_msg_api_free((void *) msg);
- /*
+ /*
* Python code is blissfully unaware of these pings, so
* act as if it never happened...
*/
static u32
vac_client_index (void)
{
- return (api_main.my_client_index);
+ return (vlibapi_get_main()->my_client_index);
}
int
vac_write (char *p, int l)
{
int rv = -1;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main();
vl_api_header_t *mp = vl_msg_api_alloc(l);
svm_queue_t *q;
vac_main_t *pm = &vac_main;
static void
test_messages (void)
{
- api_main_t * am = &api_main;
+ api_main_t * am = vlibapi_get_main();
vl_api_show_version_t message;
vl_api_show_version_t *mp;
int async = 1;
goto out;
}
int tmp;
- svm_queue_t *q = api_main.shmem_hdr->vl_input_queue;
+ svm_queue_t *q = vlibapi_get_main ()->shmem_hdr->vl_input_queue;
#if VAPI_DEBUG
unsigned msgid = be16toh (*(u16 *) msg);
if (msgid <= ctx->vl_msg_id_max)
rv = VAPI_EINVAL;
goto out;
}
- svm_queue_t *q = api_main.shmem_hdr->vl_input_queue;
+ svm_queue_t *q = vlibapi_get_main ()->shmem_hdr->vl_input_queue;
#if VAPI_DEBUG
unsigned msgid1 = be16toh (*(u16 *) msg1);
unsigned msgid2 = be16toh (*(u16 *) msg2);
return VAPI_EINVAL;
}
vapi_error_e rv = VAPI_OK;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
uword data;
if (am->our_pid == 0)
int
vapi_get_client_index (vapi_ctx_t ctx)
{
- return api_main.my_client_index;
+ return vlibapi_get_main ()->my_client_index;
}
bool
u8 **shmem_vecp = (u8 **) arg;
u8 *shmem_vec;
void *oldheap;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
u32 offset;
shmem_vec = *shmem_vecp;
vl_api_cli_reply_t *rp;
vl_api_registration_t *reg;
vlib_main_t *vm = vlib_get_main ();
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
unformat_input_t input;
u8 *shmem_vec = 0;
void *oldheap;
{
int rv = 0;
u8 *vector = 0;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
vlib_main_t *vm = vlib_get_main ();
void *oldheap;
vl_api_get_node_graph_reply_t *rmp;
static clib_error_t *
vpe_api_hookup (vlib_main_t * vm)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
vl_api_registration_t *regp;
svm_region_t *svm;
void *oldheap;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
if (vam->my_client_index != ~0)
return;
u16
vl_client_get_first_plugin_msg_id (const char *plugin_name)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
vl_api_msg_range_t *rp;
uword *p;
gmon_init (vlib_main_t * vm)
{
gmon_main_t *gm = &gmon_main;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
pid_t *swp = 0;
f64 *v = 0;
clib_error_t *error;
int
main (int argc, char **argv)
{
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
test_main_t *tm = &test_main;
int ch;
{
int rv = 0;
test_main_t *tm = &test_main;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
rv = vl_client_connect_to_vlib ("/vpe-api", name, 32);
if (rv < 0)
main (int argc, char **argv)
{
test_main_t *tm = &test_main;
- api_main_t *am = &api_main;
+ api_main_t *am = vlibapi_get_main ();
u32 swt_pid = 0;
int connected = 0;