blob: ca3eb141f7e50ca129b74fd5b72913d1786cc453 [file] [log] [blame]
Dave Barach371e4e12016-07-08 09:38:52 -04001/*
Ed Warnickecb9cada2015-12-08 15:45:58 -07002 *------------------------------------------------------------------
Dave Barach371e4e12016-07-08 09:38:52 -04003 * memory_vlib.c
Ed Warnickecb9cada2015-12-08 15:45:58 -07004 *
5 * Copyright (c) 2009 Cisco and/or its affiliates.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at:
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *------------------------------------------------------------------
18 */
19
20#include <stdio.h>
21#include <stdlib.h>
22#include <string.h>
23#include <unistd.h>
24#include <sys/types.h>
25#include <signal.h>
26#include <pthread.h>
27#include <vppinfra/vec.h>
28#include <vppinfra/hash.h>
29#include <vppinfra/pool.h>
30#include <vppinfra/format.h>
31#include <vppinfra/byte_order.h>
32#include <vppinfra/elog.h>
33#include <stdarg.h>
34#include <vlib/vlib.h>
35#include <vlib/unix/unix.h>
36#include <vlibapi/api.h>
37#include <vlibmemory/api.h>
38
39#define TRACE_VLIB_MEMORY_QUEUE 0
40
Dave Barach371e4e12016-07-08 09:38:52 -040041#include <vlibmemory/vl_memory_msg_enum.h> /* enumerate all vlib messages */
Ed Warnickecb9cada2015-12-08 15:45:58 -070042
Dave Barach371e4e12016-07-08 09:38:52 -040043#define vl_typedefs /* define message structures */
44#include <vlibmemory/vl_memory_api_h.h>
Ed Warnickecb9cada2015-12-08 15:45:58 -070045#undef vl_typedefs
46
47/* instantiate all the print functions we know about */
48#define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
49#define vl_printfun
Dave Barach371e4e12016-07-08 09:38:52 -040050#include <vlibmemory/vl_memory_api_h.h>
Ed Warnickecb9cada2015-12-08 15:45:58 -070051#undef vl_printfun
52
53static inline void *
Dave Barach371e4e12016-07-08 09:38:52 -040054vl_api_memclnt_create_t_print (vl_api_memclnt_create_t * a, void *handle)
Ed Warnickecb9cada2015-12-08 15:45:58 -070055{
Dave Barach371e4e12016-07-08 09:38:52 -040056 vl_print (handle, "vl_api_memclnt_create_t:\n");
57 vl_print (handle, "name: %s\n", a->name);
58 vl_print (handle, "input_queue: 0x%wx\n", a->input_queue);
59 vl_print (handle, "context: %u\n", (unsigned) a->context);
60 vl_print (handle, "ctx_quota: %ld\n", (long) a->ctx_quota);
61 return handle;
Ed Warnickecb9cada2015-12-08 15:45:58 -070062}
63
64static inline void *
Dave Barach371e4e12016-07-08 09:38:52 -040065vl_api_memclnt_delete_t_print (vl_api_memclnt_delete_t * a, void *handle)
Ed Warnickecb9cada2015-12-08 15:45:58 -070066{
Dave Barach371e4e12016-07-08 09:38:52 -040067 vl_print (handle, "vl_api_memclnt_delete_t:\n");
68 vl_print (handle, "index: %u\n", (unsigned) a->index);
69 vl_print (handle, "handle: 0x%wx\n", a->handle);
70 return handle;
Ed Warnickecb9cada2015-12-08 15:45:58 -070071}
72
73/* instantiate all the endian swap functions we know about */
74#define vl_endianfun
Dave Barach371e4e12016-07-08 09:38:52 -040075#include <vlibmemory/vl_memory_api_h.h>
Ed Warnickecb9cada2015-12-08 15:45:58 -070076#undef vl_endianfun
77
Dave Barach371e4e12016-07-08 09:38:52 -040078void vl_socket_api_send (vl_api_registration_t * rp, u8 * elem)
79 __attribute__ ((weak));
Ed Warnickecb9cada2015-12-08 15:45:58 -070080
Dave Barach371e4e12016-07-08 09:38:52 -040081void
82vl_socket_api_send (vl_api_registration_t * rp, u8 * elem)
Ed Warnickecb9cada2015-12-08 15:45:58 -070083{
Dave Barach371e4e12016-07-08 09:38:52 -040084 static int count;
Ed Warnickecb9cada2015-12-08 15:45:58 -070085
Dave Barach371e4e12016-07-08 09:38:52 -040086 if (count++ < 5)
87 clib_warning ("need to link against -lvlibsocket, msg not sent!");
Ed Warnickecb9cada2015-12-08 15:45:58 -070088}
89
Dave Barach371e4e12016-07-08 09:38:52 -040090void
91vl_msg_api_send (vl_api_registration_t * rp, u8 * elem)
Ed Warnickecb9cada2015-12-08 15:45:58 -070092{
Dave Barach371e4e12016-07-08 09:38:52 -040093 if (PREDICT_FALSE (rp->registration_type > REGISTRATION_TYPE_SHMEM))
94 {
95 vl_socket_api_send (rp, elem);
96 }
97 else
98 {
99 vl_msg_api_send_shmem (rp->vl_input_queue, elem);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700100 }
101}
102
Dave Barach371e4e12016-07-08 09:38:52 -0400103int vl_msg_api_version_check (vl_api_memclnt_create_t * mp)
104 __attribute__ ((weak));
Ed Warnickecb9cada2015-12-08 15:45:58 -0700105
Dave Barach371e4e12016-07-08 09:38:52 -0400106int
107vl_msg_api_version_check (vl_api_memclnt_create_t * mp)
108{
109 return 0;
110}
Ed Warnickecb9cada2015-12-08 15:45:58 -0700111
112/*
113 * vl_api_memclnt_create_t_handler
114 */
Dave Barach371e4e12016-07-08 09:38:52 -0400115void
116vl_api_memclnt_create_t_handler (vl_api_memclnt_create_t * mp)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700117{
Dave Barach371e4e12016-07-08 09:38:52 -0400118 vl_api_registration_t **regpp;
119 vl_api_registration_t *regp;
120 vl_api_memclnt_create_reply_t *rp;
121 svm_region_t *svm;
122 unix_shared_memory_queue_t *q;
123 int rv;
124 void *oldheap;
125 api_main_t *am = &api_main;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700126
Dave Barach371e4e12016-07-08 09:38:52 -0400127 /* Indicate API version mismatch if appropriate */
128 rv = vl_msg_api_version_check (mp);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700129
Dave Barach371e4e12016-07-08 09:38:52 -0400130 /*
131 * This is tortured. Maintain a vlib-address-space private
132 * pool of client registrations. We use the shared-memory virtual
133 * address of client structure as a handle, to allow direct
134 * manipulation of context quota vbls from the client library.
135 *
136 * This scheme causes trouble w/ API message trace replay, since
137 * some random VA from clib_mem_alloc() certainly won't
138 * occur in the Linux sim. The (very) few places
139 * that care need to use the pool index.
140 *
141 * Putting the registration object(s) into a pool in shared memory and
142 * using the pool index as a handle seems like a great idea.
143 * Unfortunately, each and every reference to that pool would need
144 * to be protected by a mutex:
145 *
146 * Client VLIB
147 * ------ ----
148 * convert pool index to
149 * pointer.
150 * <deschedule>
151 * expand pool
152 * <deschedule>
153 * kaboom!
154 */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700155
Dave Barach371e4e12016-07-08 09:38:52 -0400156 pool_get (am->vl_clients, regpp);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700157
Dave Barach371e4e12016-07-08 09:38:52 -0400158 svm = am->vlib_rp;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700159
Dave Barach371e4e12016-07-08 09:38:52 -0400160 pthread_mutex_lock (&svm->mutex);
161 oldheap = svm_push_data_heap (svm);
162 *regpp = clib_mem_alloc (sizeof (vl_api_registration_t));
Ed Warnickecb9cada2015-12-08 15:45:58 -0700163
Dave Barach371e4e12016-07-08 09:38:52 -0400164 regp = *regpp;
165 memset (regp, 0, sizeof (*regp));
166 regp->registration_type = REGISTRATION_TYPE_SHMEM;
167 regp->vl_api_registration_pool_index = regpp - am->vl_clients;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700168
Dave Barach371e4e12016-07-08 09:38:52 -0400169 q = regp->vl_input_queue = (unix_shared_memory_queue_t *) (uword)
170 mp->input_queue;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700171
Dave Barach371e4e12016-07-08 09:38:52 -0400172 regp->name = format (0, "%s", mp->name);
173 vec_add1 (regp->name, 0);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700174
Dave Barach371e4e12016-07-08 09:38:52 -0400175 pthread_mutex_unlock (&svm->mutex);
176 svm_pop_heap (oldheap);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700177
Dave Barach371e4e12016-07-08 09:38:52 -0400178 rp = vl_msg_api_alloc (sizeof (*rp));
179 rp->_vl_msg_id = ntohs (VL_API_MEMCLNT_CREATE_REPLY);
180 rp->handle = (uword) regp;
181 rp->index = vl_msg_api_handle_from_index_and_epoch
182 (regp->vl_api_registration_pool_index,
183 am->shmem_hdr->application_restarts);
184 rp->context = mp->context;
185 rp->response = ntohl (rv);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700186
Dave Barach371e4e12016-07-08 09:38:52 -0400187 vl_msg_api_send_shmem (q, (u8 *) & rp);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700188}
189
190/* Application callback to clean up leftover registrations from this client */
Dave Barach371e4e12016-07-08 09:38:52 -0400191int vl_api_memclnt_delete_callback (u32 client_index) __attribute__ ((weak));
Ed Warnickecb9cada2015-12-08 15:45:58 -0700192
Dave Barach371e4e12016-07-08 09:38:52 -0400193int
194vl_api_memclnt_delete_callback (u32 client_index)
195{
196 return 0;
197}
Ed Warnickecb9cada2015-12-08 15:45:58 -0700198
199/*
200 * vl_api_memclnt_delete_t_handler
201 */
Dave Barach371e4e12016-07-08 09:38:52 -0400202void
203vl_api_memclnt_delete_t_handler (vl_api_memclnt_delete_t * mp)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700204{
Dave Barach371e4e12016-07-08 09:38:52 -0400205 vl_api_registration_t **regpp;
206 vl_api_registration_t *regp;
207 vl_api_memclnt_delete_reply_t *rp;
208 svm_region_t *svm;
209 void *oldheap;
210 api_main_t *am = &api_main;
211 u32 handle, client_index, epoch;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700212
Dave Barach371e4e12016-07-08 09:38:52 -0400213 handle = mp->index;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700214
Dave Barach371e4e12016-07-08 09:38:52 -0400215 if (vl_api_memclnt_delete_callback (handle))
216 return;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700217
Dave Barach371e4e12016-07-08 09:38:52 -0400218 epoch = vl_msg_api_handle_get_epoch (handle);
219 client_index = vl_msg_api_handle_get_index (handle);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700220
Dave Barach371e4e12016-07-08 09:38:52 -0400221 if (epoch != (am->shmem_hdr->application_restarts & VL_API_EPOCH_MASK))
222 {
223 clib_warning
224 ("Stale clnt delete index %d old epoch %d cur epoch %d",
225 client_index, epoch,
226 (am->shmem_hdr->application_restarts & VL_API_EPOCH_MASK));
227 return;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700228 }
229
Dave Barach371e4e12016-07-08 09:38:52 -0400230 regpp = am->vl_clients + client_index;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700231
Dave Barach371e4e12016-07-08 09:38:52 -0400232 if (!pool_is_free (am->vl_clients, regpp))
233 {
234 regp = *regpp;
235 svm = am->vlib_rp;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700236
Dave Barach371e4e12016-07-08 09:38:52 -0400237 /* $$$ check the input queue for e.g. punted sf's */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700238
Dave Barach371e4e12016-07-08 09:38:52 -0400239 rp = vl_msg_api_alloc (sizeof (*rp));
240 rp->_vl_msg_id = ntohs (VL_API_MEMCLNT_DELETE_REPLY);
241 rp->handle = mp->handle;
242 rp->response = 1;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700243
Dave Barach371e4e12016-07-08 09:38:52 -0400244 vl_msg_api_send_shmem (regp->vl_input_queue, (u8 *) & rp);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700245
Dave Barach371e4e12016-07-08 09:38:52 -0400246 if (client_index != regp->vl_api_registration_pool_index)
247 {
248 clib_warning ("mismatch client_index %d pool_index %d",
249 client_index, regp->vl_api_registration_pool_index);
250 vl_msg_api_free (rp);
251 return;
252 }
Ed Warnickecb9cada2015-12-08 15:45:58 -0700253
Dave Barach371e4e12016-07-08 09:38:52 -0400254 /* No dangling references, please */
255 *regpp = 0;
256
257 pool_put_index (am->vl_clients, regp->vl_api_registration_pool_index);
258
259 pthread_mutex_lock (&svm->mutex);
260 oldheap = svm_push_data_heap (svm);
261 /* Poison the old registration */
262 memset (regp, 0xF1, sizeof (*regp));
263 clib_mem_free (regp);
264 pthread_mutex_unlock (&svm->mutex);
265 svm_pop_heap (oldheap);
266 }
267 else
268 {
269 clib_warning ("unknown client ID %d", mp->index);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700270 }
271}
272
Dave Barach371e4e12016-07-08 09:38:52 -0400273void
274vl_api_get_first_msg_id_t_handler (vl_api_get_first_msg_id_t * mp)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700275{
Dave Barach371e4e12016-07-08 09:38:52 -0400276 vl_api_get_first_msg_id_reply_t *rmp;
277 unix_shared_memory_queue_t *q;
278 uword *p;
279 api_main_t *am = &api_main;
280 vl_api_msg_range_t *rp;
281 u8 name[64];
282 u16 first_msg_id = ~0;
283 int rv = -7; /* VNET_API_ERROR_INVALID_VALUE */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700284
Dave Barach371e4e12016-07-08 09:38:52 -0400285 q = vl_api_client_index_to_input_queue (mp->client_index);
286 if (!q)
287 return;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700288
Dave Barach371e4e12016-07-08 09:38:52 -0400289 if (am->msg_range_by_name == 0)
290 goto out;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700291
Dave Barach371e4e12016-07-08 09:38:52 -0400292 strncpy ((char *) name, (char *) mp->name, ARRAY_LEN (name) - 1);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700293
Dave Barach371e4e12016-07-08 09:38:52 -0400294 p = hash_get_mem (am->msg_range_by_name, name);
295 if (p == 0)
296 goto out;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700297
Dave Barach371e4e12016-07-08 09:38:52 -0400298 rp = vec_elt_at_index (am->msg_ranges, p[0]);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700299
Dave Barach371e4e12016-07-08 09:38:52 -0400300 first_msg_id = rp->first_msg_id;
301 rv = 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700302
303out:
304
Dave Barach371e4e12016-07-08 09:38:52 -0400305 rmp = vl_msg_api_alloc (sizeof (*rmp));
306 rmp->_vl_msg_id = ntohs (VL_API_GET_FIRST_MSG_ID_REPLY);
307 rmp->context = mp->context;
308 rmp->retval = ntohl (rv);
309 rmp->first_msg_id = ntohs (first_msg_id);
310 vl_msg_api_send_shmem (q, (u8 *) & rmp);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700311}
312
313#define foreach_vlib_api_msg \
314_(MEMCLNT_CREATE, memclnt_create) \
315_(MEMCLNT_DELETE, memclnt_delete) \
316_(GET_FIRST_MSG_ID, get_first_msg_id)
317
318/*
319 * vl_api_init
320 */
Dave Barach371e4e12016-07-08 09:38:52 -0400321static int
322memory_api_init (char *region_name)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700323{
Dave Barach371e4e12016-07-08 09:38:52 -0400324 int rv;
325 vl_msg_api_msg_config_t cfg;
326 vl_msg_api_msg_config_t *c = &cfg;
327
328 if ((rv = vl_map_shmem (region_name, 1 /* is_vlib */ )) < 0)
329 return rv;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700330
331#define _(N,n) do { \
332 c->id = VL_API_##N; \
333 c->name = #n; \
334 c->handler = vl_api_##n##_t_handler; \
335 c->cleanup = vl_noop_handler; \
336 c->endian = vl_api_##n##_t_endian; \
337 c->print = vl_api_##n##_t_print; \
338 c->size = sizeof(vl_api_##n##_t); \
339 c->traced = 1; /* trace, so these msgs print */ \
340 c->replay = 0; /* don't replay client create/delete msgs */ \
341 vl_msg_api_config(c);} while (0);
Dave Barach371e4e12016-07-08 09:38:52 -0400342
343 foreach_vlib_api_msg;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700344#undef _
345
Dave Barach371e4e12016-07-08 09:38:52 -0400346 return 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700347}
348
349#define foreach_histogram_bucket \
350_(400) \
351_(200) \
352_(100) \
353_(10)
354
Dave Barach371e4e12016-07-08 09:38:52 -0400355typedef enum
356{
Ed Warnickecb9cada2015-12-08 15:45:58 -0700357#define _(n) SLEEP_##n##_US,
Dave Barach371e4e12016-07-08 09:38:52 -0400358 foreach_histogram_bucket
Ed Warnickecb9cada2015-12-08 15:45:58 -0700359#undef _
360 SLEEP_N_BUCKETS,
361} histogram_index_t;
362
363static u64 vector_rate_histogram[SLEEP_N_BUCKETS];
364
Dave Barach371e4e12016-07-08 09:38:52 -0400365static void memclnt_queue_callback (vlib_main_t * vm);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700366
367static uword
368memclnt_process (vlib_main_t * vm,
Dave Barach371e4e12016-07-08 09:38:52 -0400369 vlib_node_runtime_t * node, vlib_frame_t * f)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700370{
Dave Barach371e4e12016-07-08 09:38:52 -0400371 uword mp;
372 vl_shmem_hdr_t *shm;
373 unix_shared_memory_queue_t *q;
374 clib_error_t *e;
375 int rv;
376 api_main_t *am = &api_main;
377 f64 dead_client_scan_time;
378 f64 sleep_time, start_time;
379 f64 vector_rate;
380
381 vlib_set_queue_signal_callback (vm, memclnt_queue_callback);
382
383 if ((rv = memory_api_init (am->region_name)) < 0)
384 {
385 clib_warning ("memory_api_init returned %d, wait for godot...", rv);
386 vlib_process_suspend (vm, 1e70);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700387 }
388
Dave Barach371e4e12016-07-08 09:38:52 -0400389 shm = am->shmem_hdr;
390 ASSERT (shm);
391 q = shm->vl_input_queue;
392 ASSERT (q);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700393
Dave Barach371e4e12016-07-08 09:38:52 -0400394 e = vlib_call_init_exit_functions
395 (vm, vm->api_init_function_registrations, 1 /* call_once */ );
396 if (e)
397 clib_error_report (e);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700398
Dave Barach371e4e12016-07-08 09:38:52 -0400399 sleep_time = 20.0;
400 dead_client_scan_time = vlib_time_now (vm) + 20.0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700401
Dave Barach371e4e12016-07-08 09:38:52 -0400402 /* $$$ pay attention to frame size, control CPU usage */
403 while (1)
404 {
405 uword event_type __attribute__ ((unused));
406 i8 *headp;
407 int need_broadcast;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700408
Dave Barach371e4e12016-07-08 09:38:52 -0400409 /*
410 * There's a reason for checking the queue before
411 * sleeping. If the vlib application crashes, it's entirely
412 * possible for a client to enqueue a connect request
413 * during the process restart interval.
414 *
415 * Unless some force of physics causes the new incarnation
416 * of the application to process the request, the client will
417 * sit and wait for Godot...
418 */
419 vector_rate = vlib_last_vector_length_per_node (vm);
420 start_time = vlib_time_now (vm);
421 while (1)
422 {
423 pthread_mutex_lock (&q->mutex);
424 if (q->cursize == 0)
425 {
426 vm->api_queue_nonempty = 0;
427 pthread_mutex_unlock (&q->mutex);
428
429 if (TRACE_VLIB_MEMORY_QUEUE)
430 {
431 /* *INDENT-OFF* */
432 ELOG_TYPE_DECLARE (e) =
433 {
434 .format = "q-underflow: len %d",
435 .format_args = "i4",
Ed Warnickecb9cada2015-12-08 15:45:58 -0700436 };
Dave Barach371e4e12016-07-08 09:38:52 -0400437 /* *INDENT-ON* */
438 struct
439 {
440 u32 len;
441 } *ed;
442 ed = ELOG_DATA (&vm->elog_main, e);
443 ed->len = 0;
444 }
445 sleep_time = 20.0;
446 break;
447 }
Ed Warnickecb9cada2015-12-08 15:45:58 -0700448
Dave Barach371e4e12016-07-08 09:38:52 -0400449 headp = (i8 *) (q->data + sizeof (uword) * q->head);
450 clib_memcpy (&mp, headp, sizeof (uword));
Ed Warnickecb9cada2015-12-08 15:45:58 -0700451
Dave Barach371e4e12016-07-08 09:38:52 -0400452 q->head++;
453 need_broadcast = (q->cursize == q->maxsize / 2);
454 q->cursize--;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700455
Dave Barach371e4e12016-07-08 09:38:52 -0400456 if (PREDICT_FALSE (q->head == q->maxsize))
457 q->head = 0;
458 pthread_mutex_unlock (&q->mutex);
459 if (need_broadcast)
460 (void) pthread_cond_broadcast (&q->condvar);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700461
Dave Barach371e4e12016-07-08 09:38:52 -0400462 vl_msg_api_handler_with_vm_node (am, (void *) mp, vm, node);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700463
Dave Barach371e4e12016-07-08 09:38:52 -0400464 /* Allow no more than 10us without a pause */
465 if (vlib_time_now (vm) > start_time + 10e-6)
466 {
467 int index = SLEEP_400_US;
468 if (vector_rate > 40.0)
469 sleep_time = 400e-6;
470 else if (vector_rate > 20.0)
471 {
472 index = SLEEP_200_US;
473 sleep_time = 200e-6;
474 }
475 else if (vector_rate >= 1.0)
476 {
477 index = SLEEP_100_US;
478 sleep_time = 100e-6;
479 }
480 else
481 {
482 index = SLEEP_10_US;
483 sleep_time = 10e-6;
484 }
485 vector_rate_histogram[index] += 1;
486 break;
487 }
488 }
Ed Warnickecb9cada2015-12-08 15:45:58 -0700489
Dave Barach371e4e12016-07-08 09:38:52 -0400490 event_type = vlib_process_wait_for_event_or_clock (vm, sleep_time);
491 vm->queue_signal_pending = 0;
492 vlib_process_get_events (vm, 0 /* event_data */ );
Ed Warnickecb9cada2015-12-08 15:45:58 -0700493
Dave Barach371e4e12016-07-08 09:38:52 -0400494 if (vlib_time_now (vm) > dead_client_scan_time)
495 {
496 vl_api_registration_t **regpp;
497 vl_api_registration_t *regp;
498 unix_shared_memory_queue_t *q;
499 static u32 *dead_indices;
500 static u32 *confused_indices;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700501
Dave Barach371e4e12016-07-08 09:38:52 -0400502 vec_reset_length (dead_indices);
503 vec_reset_length (confused_indices);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700504
Dave Barach371e4e12016-07-08 09:38:52 -0400505 /* *INDENT-OFF* */
506 pool_foreach (regpp, am->vl_clients,
507 ({
508 regp = *regpp;
509 if (regp)
510 {
511 q = regp->vl_input_queue;
512 if (kill (q->consumer_pid, 0) < 0)
513 {
514 vec_add1(dead_indices, regpp - am->vl_clients);
515 }
516 }
517 else
518 {
519 clib_warning ("NULL client registration index %d",
520 regpp - am->vl_clients);
521 vec_add1 (confused_indices, regpp - am->vl_clients);
522 }
523 }));
524 /* *INDENT-ON* */
525 /* This should "never happen," but if it does, fix it... */
526 if (PREDICT_FALSE (vec_len (confused_indices) > 0))
527 {
528 int i;
529 for (i = 0; i < vec_len (confused_indices); i++)
530 {
531 pool_put_index (am->vl_clients, confused_indices[i]);
532 }
533 }
Ed Warnickecb9cada2015-12-08 15:45:58 -0700534
Dave Barach371e4e12016-07-08 09:38:52 -0400535 if (PREDICT_FALSE (vec_len (dead_indices) > 0))
536 {
537 int i;
538 svm_region_t *svm;
539 void *oldheap;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700540
Dave Barach371e4e12016-07-08 09:38:52 -0400541 /* Allow the application to clean up its registrations */
542 for (i = 0; i < vec_len (dead_indices); i++)
543 {
544 regpp = pool_elt_at_index (am->vl_clients, dead_indices[i]);
545 if (regpp)
546 {
547 u32 handle;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700548
Dave Barach371e4e12016-07-08 09:38:52 -0400549 handle = vl_msg_api_handle_from_index_and_epoch
550 (dead_indices[i], shm->application_restarts);
551 (void) vl_api_memclnt_delete_callback (handle);
552 }
553 }
554
555 svm = am->vlib_rp;
556 pthread_mutex_lock (&svm->mutex);
557 oldheap = svm_push_data_heap (svm);
558
559 for (i = 0; i < vec_len (dead_indices); i++)
560 {
561 regpp = pool_elt_at_index (am->vl_clients, dead_indices[i]);
562 if (regpp)
563 {
564 /* Poison the old registration */
565 memset (*regpp, 0xF3, sizeof (**regpp));
566 clib_mem_free (*regpp);
567 /* no dangling references, please */
568 *regpp = 0;
569 }
570 else
571 {
572 svm_pop_heap (oldheap);
573 clib_warning ("Duplicate free, client index %d",
574 regpp - am->vl_clients);
575 oldheap = svm_push_data_heap (svm);
576 }
577 }
578
579 svm_client_scan_this_region_nolock (am->vlib_rp);
580
581 pthread_mutex_unlock (&svm->mutex);
582 svm_pop_heap (oldheap);
583 for (i = 0; i < vec_len (dead_indices); i++)
584 pool_put_index (am->vl_clients, dead_indices[i]);
585 }
586
587 dead_client_scan_time = vlib_time_now (vm) + 20.0;
588 }
589
590 if (TRACE_VLIB_MEMORY_QUEUE)
591 {
592 /* *INDENT-OFF* */
593 ELOG_TYPE_DECLARE (e) = {
594 .format = "q-awake: len %d",
595 .format_args = "i4",
596 };
597 /* *INDENT-ON* */
598 struct
599 {
600 u32 len;
601 } *ed;
602 ed = ELOG_DATA (&vm->elog_main, e);
603 ed->len = q->cursize;
604 }
Ed Warnickecb9cada2015-12-08 15:45:58 -0700605 }
606
Dave Barach371e4e12016-07-08 09:38:52 -0400607 return 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700608}
609
610static clib_error_t *
Dave Barach371e4e12016-07-08 09:38:52 -0400611vl_api_show_histogram_command (vlib_main_t * vm,
612 unformat_input_t * input,
613 vlib_cli_command_t * cli_cmd)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700614{
Dave Barach371e4e12016-07-08 09:38:52 -0400615 u64 total_counts = 0;
616 int i;
617
618 for (i = 0; i < SLEEP_N_BUCKETS; i++)
619 {
620 total_counts += vector_rate_histogram[i];
Ed Warnickecb9cada2015-12-08 15:45:58 -0700621 }
622
Dave Barach371e4e12016-07-08 09:38:52 -0400623 if (total_counts == 0)
624 {
625 vlib_cli_output (vm, "No control-plane activity.");
626 return 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700627 }
628
629#define _(n) \
630 do { \
631 f64 percent; \
632 percent = ((f64) vector_rate_histogram[SLEEP_##n##_US]) \
633 / (f64) total_counts; \
634 percent *= 100.0; \
635 vlib_cli_output (vm, "Sleep %3d us: %llu, %.2f%%",n, \
636 vector_rate_histogram[SLEEP_##n##_US], \
637 percent); \
638 } while (0);
Dave Barach371e4e12016-07-08 09:38:52 -0400639 foreach_histogram_bucket;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700640#undef _
641
Dave Barach371e4e12016-07-08 09:38:52 -0400642 return 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700643}
644
Dave Barach371e4e12016-07-08 09:38:52 -0400645/* *INDENT-OFF* */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700646VLIB_CLI_COMMAND (cli_show_api_histogram_command, static) = {
Calvin16649372016-07-28 13:52:05 -0400647 .path = "show api histogram",
648 .short_help = "show api histogram",
649 .function = vl_api_show_histogram_command,
Ed Warnickecb9cada2015-12-08 15:45:58 -0700650};
Dave Barach371e4e12016-07-08 09:38:52 -0400651/* *INDENT-ON* */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700652
653static clib_error_t *
Dave Barach371e4e12016-07-08 09:38:52 -0400654vl_api_clear_histogram_command (vlib_main_t * vm,
655 unformat_input_t * input,
656 vlib_cli_command_t * cli_cmd)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700657{
Dave Barach371e4e12016-07-08 09:38:52 -0400658 int i;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700659
Dave Barach371e4e12016-07-08 09:38:52 -0400660 for (i = 0; i < SLEEP_N_BUCKETS; i++)
661 vector_rate_histogram[i] = 0;
662 return 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700663}
664
Dave Barach371e4e12016-07-08 09:38:52 -0400665/* *INDENT-OFF* */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700666VLIB_CLI_COMMAND (cli_clear_api_histogram_command, static) = {
667 .path = "clear api histogram",
668 .short_help = "clear api histogram",
669 .function = vl_api_clear_histogram_command,
670};
Dave Barach371e4e12016-07-08 09:38:52 -0400671/* *INDENT-ON* */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700672
673
Dave Barach371e4e12016-07-08 09:38:52 -0400674/* *INDENT-OFF* */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700675VLIB_REGISTER_NODE (memclnt_node,static) = {
676 .function = memclnt_process,
677 .type = VLIB_NODE_TYPE_PROCESS,
678 .name = "api-rx-from-ring",
679 .state = VLIB_NODE_STATE_DISABLED,
680};
Dave Barach371e4e12016-07-08 09:38:52 -0400681/* *INDENT-ON* */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700682
Dave Barach371e4e12016-07-08 09:38:52 -0400683static void
684memclnt_queue_callback (vlib_main_t * vm)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700685{
Dave Barach371e4e12016-07-08 09:38:52 -0400686 static volatile int *cursizep;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700687
Dave Barach16c75df2016-05-31 14:05:46 -0400688 if (PREDICT_FALSE (cursizep == 0))
689 {
690 api_main_t *am = &api_main;
691 vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr;
Dave Barach371e4e12016-07-08 09:38:52 -0400692 unix_shared_memory_queue_t *q;
693
Dave Barach16c75df2016-05-31 14:05:46 -0400694 if (shmem_hdr == 0)
Dave Barach371e4e12016-07-08 09:38:52 -0400695 return;
696
Dave Barach16c75df2016-05-31 14:05:46 -0400697 q = shmem_hdr->vl_input_queue;
698 if (q == 0)
Dave Barach371e4e12016-07-08 09:38:52 -0400699 return;
Dave Barach16c75df2016-05-31 14:05:46 -0400700 cursizep = &q->cursize;
701 }
Dave Barach371e4e12016-07-08 09:38:52 -0400702
Dave Barach16c75df2016-05-31 14:05:46 -0400703 if (*cursizep >= 1)
704 {
705 vm->queue_signal_pending = 1;
706 vm->api_queue_nonempty = 1;
Dave Barach371e4e12016-07-08 09:38:52 -0400707 vlib_process_signal_event (vm, memclnt_node.index,
708 /* event_type */ 0, /* event_data */ 0);
Dave Barach16c75df2016-05-31 14:05:46 -0400709 }
Ed Warnickecb9cada2015-12-08 15:45:58 -0700710}
711
Dave Barach371e4e12016-07-08 09:38:52 -0400712void
713vl_enable_disable_memory_api (vlib_main_t * vm, int enable)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700714{
Dave Barach371e4e12016-07-08 09:38:52 -0400715 vlib_node_set_state (vm, memclnt_node.index,
716 (enable
717 ? VLIB_NODE_STATE_POLLING
718 : VLIB_NODE_STATE_DISABLED));
Ed Warnickecb9cada2015-12-08 15:45:58 -0700719}
720
721static uword
722api_rx_from_node (vlib_main_t * vm,
Dave Barach371e4e12016-07-08 09:38:52 -0400723 vlib_node_runtime_t * node, vlib_frame_t * frame)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700724{
Dave Barach371e4e12016-07-08 09:38:52 -0400725 uword n_packets = frame->n_vectors;
726 uword n_left_from;
727 u32 *from;
728 static u8 *long_msg;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700729
Dave Barach371e4e12016-07-08 09:38:52 -0400730 vec_validate (long_msg, 4095);
731 n_left_from = frame->n_vectors;
732 from = vlib_frame_args (frame);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700733
Dave Barach371e4e12016-07-08 09:38:52 -0400734 while (n_left_from > 0)
735 {
736 u32 bi0;
737 vlib_buffer_t *b0;
738 void *msg;
739 uword msg_len;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700740
Dave Barach371e4e12016-07-08 09:38:52 -0400741 bi0 = from[0];
742 b0 = vlib_get_buffer (vm, bi0);
743 from += 1;
744 n_left_from -= 1;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700745
Dave Barach371e4e12016-07-08 09:38:52 -0400746 msg = b0->data + b0->current_data;
747 msg_len = b0->current_length;
748 if (b0->flags & VLIB_BUFFER_NEXT_PRESENT)
749 {
750 ASSERT (long_msg != 0);
751 _vec_len (long_msg) = 0;
752 vec_add (long_msg, msg, msg_len);
753 while (b0->flags & VLIB_BUFFER_NEXT_PRESENT)
754 {
755 b0 = vlib_get_buffer (vm, b0->next_buffer);
756 msg = b0->data + b0->current_data;
757 msg_len = b0->current_length;
758 vec_add (long_msg, msg, msg_len);
759 }
760 msg = long_msg;
761 }
762 vl_msg_api_handler_no_trace_no_free (msg);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700763 }
764
Dave Barach371e4e12016-07-08 09:38:52 -0400765 /* Free what we've been given. */
766 vlib_buffer_free (vm, vlib_frame_args (frame), n_packets);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700767
Dave Barach371e4e12016-07-08 09:38:52 -0400768 return n_packets;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700769}
770
Dave Barach371e4e12016-07-08 09:38:52 -0400771/* *INDENT-OFF* */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700772VLIB_REGISTER_NODE (api_rx_from_node_node,static) = {
773 .function = api_rx_from_node,
774 .type = VLIB_NODE_TYPE_INTERNAL,
775 .vector_size = 4,
776 .name = "api-rx-from-node",
777};
Dave Barach371e4e12016-07-08 09:38:52 -0400778/* *INDENT-ON* */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700779
780static clib_error_t *
781setup_memclnt_exit (vlib_main_t * vm)
782{
Dave Barach371e4e12016-07-08 09:38:52 -0400783 atexit (vl_unmap_shmem);
784 return 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700785}
786
787VLIB_INIT_FUNCTION (setup_memclnt_exit);
788
789
790static clib_error_t *
Dave Barach371e4e12016-07-08 09:38:52 -0400791vl_api_ring_command (vlib_main_t * vm,
792 unformat_input_t * input, vlib_cli_command_t * cli_cmd)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700793{
Dave Barach371e4e12016-07-08 09:38:52 -0400794 int i;
795 ring_alloc_t *ap;
796 vl_shmem_hdr_t *shmem_hdr;
797 api_main_t *am = &api_main;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700798
Dave Barach371e4e12016-07-08 09:38:52 -0400799 shmem_hdr = am->shmem_hdr;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700800
Dave Barach371e4e12016-07-08 09:38:52 -0400801 if (shmem_hdr == 0)
802 {
803 vlib_cli_output (vm, "Shared memory segment not initialized...\n");
804 return 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700805 }
806
Dave Barach371e4e12016-07-08 09:38:52 -0400807 vlib_cli_output (vm, "%8s %8s %8s %8s %8s\n",
808 "Owner", "Size", "Nitems", "Hits", "Misses");
Ed Warnickecb9cada2015-12-08 15:45:58 -0700809
Dave Barach371e4e12016-07-08 09:38:52 -0400810 ap = shmem_hdr->vl_rings;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700811
Dave Barach371e4e12016-07-08 09:38:52 -0400812 for (i = 0; i < vec_len (shmem_hdr->vl_rings); i++)
813 {
814 vlib_cli_output (vm, "%8s %8d %8d %8d %8d\n",
815 "vlib", ap->size, ap->nitems, ap->hits, ap->misses);
816 ap++;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700817 }
818
Dave Barach371e4e12016-07-08 09:38:52 -0400819 ap = shmem_hdr->client_rings;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700820
Dave Barach371e4e12016-07-08 09:38:52 -0400821 for (i = 0; i < vec_len (shmem_hdr->client_rings); i++)
822 {
823 vlib_cli_output (vm, "%8s %8d %8d %8d %8d\n",
824 "clnt", ap->size, ap->nitems, ap->hits, ap->misses);
825 ap++;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700826 }
827
Dave Barach371e4e12016-07-08 09:38:52 -0400828 vlib_cli_output (vm, "%d ring miss fallback allocations\n",
829 am->ring_misses);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700830
Dave Barach371e4e12016-07-08 09:38:52 -0400831 vlib_cli_output (vm, "%d application restarts, %d reclaimed msgs\n",
832 shmem_hdr->application_restarts,
833 shmem_hdr->restart_reclaims);
834 return 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700835}
836
Dave Barach371e4e12016-07-08 09:38:52 -0400837void dump_socket_clients (vlib_main_t * vm, api_main_t * am)
838 __attribute__ ((weak));
Ed Warnickecb9cada2015-12-08 15:45:58 -0700839
Dave Barach371e4e12016-07-08 09:38:52 -0400840void
841dump_socket_clients (vlib_main_t * vm, api_main_t * am)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700842{
843}
844
845static clib_error_t *
Dave Barach371e4e12016-07-08 09:38:52 -0400846vl_api_client_command (vlib_main_t * vm,
847 unformat_input_t * input, vlib_cli_command_t * cli_cmd)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700848{
Dave Barach371e4e12016-07-08 09:38:52 -0400849 vl_api_registration_t **regpp, *regp;
850 unix_shared_memory_queue_t *q;
851 char *health;
852 api_main_t *am = &api_main;
853 u32 *confused_indices = 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700854
Dave Barach371e4e12016-07-08 09:38:52 -0400855 if (!pool_elts (am->vl_clients))
856 goto socket_clients;
857 vlib_cli_output (vm, "Shared memory clients");
858 vlib_cli_output (vm, "%16s %8s %14s %18s %s",
859 "Name", "PID", "Queue Length", "Queue VA", "Health");
Ed Warnickecb9cada2015-12-08 15:45:58 -0700860
Dave Barach371e4e12016-07-08 09:38:52 -0400861 /* *INDENT-OFF* */
862 pool_foreach (regpp, am->vl_clients,
863 ({
864 regp = *regpp;
865
866 if (regp)
867 {
868 q = regp->vl_input_queue;
869 if (kill (q->consumer_pid, 0) < 0)
870 {
871 health = "DEAD";
872 }
873 else
874 {
875 health = "alive";
876 }
877 vlib_cli_output (vm, "%16s %8d %14d 0x%016llx %s\n",
878 regp->name, q->consumer_pid, q->cursize,
879 q, health);
880 }
881 else
882 {
883 clib_warning ("NULL client registration index %d",
884 regpp - am->vl_clients);
885 vec_add1 (confused_indices, regpp - am->vl_clients);
886 }
887 }));
888 /* *INDENT-ON* */
889
890 /* This should "never happen," but if it does, fix it... */
891 if (PREDICT_FALSE (vec_len (confused_indices) > 0))
892 {
893 int i;
894 for (i = 0; i < vec_len (confused_indices); i++)
895 {
896 pool_put_index (am->vl_clients, confused_indices[i]);
897 }
Ed Warnickecb9cada2015-12-08 15:45:58 -0700898 }
Dave Barach371e4e12016-07-08 09:38:52 -0400899 vec_free (confused_indices);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700900
Dave Barach371e4e12016-07-08 09:38:52 -0400901 if (am->missing_clients)
902 vlib_cli_output (vm, "%u messages with missing clients",
903 am->missing_clients);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700904socket_clients:
Dave Barach371e4e12016-07-08 09:38:52 -0400905 dump_socket_clients (vm, am);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700906
Dave Barach371e4e12016-07-08 09:38:52 -0400907 return 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700908}
909
Calvin16649372016-07-28 13:52:05 -0400910static clib_error_t *
911vl_api_status_command (vlib_main_t * vm,
912 unformat_input_t * input, vlib_cli_command_t * cli_cmd)
913{
914 api_main_t *am = &api_main;
915
916 // check if rx_trace and tx_trace are not null pointers
917
918 if (am->rx_trace == 0)
919 {
920 vlib_cli_output (vm, "RX Trace disabled\n");
921 }
922 else
923 {
924 if (am->rx_trace->enabled == 0)
925 vlib_cli_output (vm, "RX Trace disabled\n");
926 else
927 vlib_cli_output (vm, "RX Trace enabled\n");
928 }
929
930 if (am->tx_trace == 0)
931 {
932 vlib_cli_output (vm, "TX Trace disabled\n");
933 }
934 else
935 {
936 if (am->tx_trace->enabled == 0)
937 vlib_cli_output (vm, "TX Trace disabled\n");
938 else
939 vlib_cli_output (vm, "TX Trace enabled\n");
940 }
941
942 return 0;
943}
944
Dave Barach371e4e12016-07-08 09:38:52 -0400945/* *INDENT-OFF* */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700946VLIB_CLI_COMMAND (cli_show_api_command, static) = {
947 .path = "show api",
948 .short_help = "Show API information",
949};
Dave Barach371e4e12016-07-08 09:38:52 -0400950/* *INDENT-ON* */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700951
Dave Barach371e4e12016-07-08 09:38:52 -0400952/* *INDENT-OFF* */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700953VLIB_CLI_COMMAND (cli_show_api_ring_command, static) = {
954 .path = "show api ring-stats",
955 .short_help = "Message ring statistics",
956 .function = vl_api_ring_command,
957};
Dave Barach371e4e12016-07-08 09:38:52 -0400958/* *INDENT-ON* */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700959
Dave Barach371e4e12016-07-08 09:38:52 -0400960/* *INDENT-OFF* */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700961VLIB_CLI_COMMAND (cli_show_api_clients_command, static) = {
962 .path = "show api clients",
963 .short_help = "Client information",
964 .function = vl_api_client_command,
965};
Dave Barach371e4e12016-07-08 09:38:52 -0400966/* *INDENT-ON* */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700967
Calvin16649372016-07-28 13:52:05 -0400968/* *INDENT-OFF* */
969VLIB_CLI_COMMAND (cli_show_api_status_command, static) = {
970 .path = "show api status",
971 .short_help = "Show API trace status",
972 .function = vl_api_status_command,
973};
974/* *INDENT-ON* */
975
Ed Warnickecb9cada2015-12-08 15:45:58 -0700976static clib_error_t *
Dave Barach371e4e12016-07-08 09:38:52 -0400977vl_api_message_table_command (vlib_main_t * vm,
978 unformat_input_t * input,
979 vlib_cli_command_t * cli_cmd)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700980{
Dave Barach371e4e12016-07-08 09:38:52 -0400981 api_main_t *am = &api_main;
982 int i;
983 int verbose = 0;
984
985 if (unformat (input, "verbose"))
986 verbose = 1;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700987
988
Dave Barach371e4e12016-07-08 09:38:52 -0400989 if (verbose == 0)
990 vlib_cli_output (vm, "%-4s %s", "ID", "Name");
991 else
992 vlib_cli_output (vm, "%-4s %-40s %6s %7s", "ID", "Name", "Bounce",
993 "MP-safe");
Ed Warnickecb9cada2015-12-08 15:45:58 -0700994
Dave Barach371e4e12016-07-08 09:38:52 -0400995 for (i = 1; i < vec_len (am->msg_names); i++)
996 {
997 if (verbose == 0)
998 {
999 vlib_cli_output (vm, "%-4d %s", i,
1000 am->msg_names[i] ? am->msg_names[i] :
1001 " [no handler]");
1002 }
1003 else
1004 {
1005 vlib_cli_output (vm, "%-4d %-40s %6d %7d", i,
1006 am->msg_names[i] ? am->msg_names[i] :
1007 " [no handler]", am->message_bounce[i],
1008 am->is_mp_safe[i]);
1009 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07001010 }
1011
Dave Barach371e4e12016-07-08 09:38:52 -04001012 return 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001013}
1014
Dave Barach371e4e12016-07-08 09:38:52 -04001015/* *INDENT-OFF* */
Ed Warnickecb9cada2015-12-08 15:45:58 -07001016VLIB_CLI_COMMAND (cli_show_api_message_table_command, static) = {
1017 .path = "show api message-table",
1018 .short_help = "Message Table",
1019 .function = vl_api_message_table_command,
1020};
Dave Barach371e4e12016-07-08 09:38:52 -04001021/* *INDENT-ON* */
Ed Warnickecb9cada2015-12-08 15:45:58 -07001022
Dave Barach371e4e12016-07-08 09:38:52 -04001023void
1024vl_api_trace_print_file_cmd (vlib_main_t * vm, u32 first, u32 last,
1025 u8 * filename)
Ed Warnickecb9cada2015-12-08 15:45:58 -07001026{
Dave Barach371e4e12016-07-08 09:38:52 -04001027 FILE *fp;
1028 static vl_api_trace_t *tp = 0;
1029 int endian_swap = 0;
1030 u32 i;
1031 u16 msg_id;
1032 static u8 *msg_buf = 0;
1033 void (*endian_fp) (void *);
1034 u8 *(*print_fp) (void *, void *);
1035 int size;
1036 api_main_t *am = &api_main;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001037
Dave Barach371e4e12016-07-08 09:38:52 -04001038 /*
1039 * On-demand: allocate enough space for the largest message
1040 */
1041 if (msg_buf == 0)
1042 {
1043 vec_validate (tp, 0);
1044 int max_size = 0;
1045 for (i = 0; i < vec_len (am->api_trace_cfg); i++)
1046 {
1047 if (am->api_trace_cfg[i].size > max_size)
1048 max_size = am->api_trace_cfg[i].size;
1049 }
1050 /* round size to a multiple of the cache-line size */
1051 max_size = (max_size + (CLIB_CACHE_LINE_BYTES - 1)) &
1052 (~(CLIB_CACHE_LINE_BYTES - 1));
1053 vec_validate (msg_buf, max_size - 1);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001054 }
1055
Dave Barach371e4e12016-07-08 09:38:52 -04001056 fp = fopen ((char *) filename, "r");
Ed Warnickecb9cada2015-12-08 15:45:58 -07001057
Dave Barach371e4e12016-07-08 09:38:52 -04001058 if (fp == NULL)
1059 {
1060 vlib_cli_output (vm, "Couldn't open %s\n", filename);
1061 return;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001062 }
1063
Dave Barach371e4e12016-07-08 09:38:52 -04001064 /* first, fish the header record from the file */
Ed Warnickecb9cada2015-12-08 15:45:58 -07001065
Dave Barach371e4e12016-07-08 09:38:52 -04001066 if (fread (tp, sizeof (*tp), 1, fp) != 1)
1067 {
1068 fclose (fp);
1069 vlib_cli_output (vm, "Header read error\n");
1070 return;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001071 }
1072
Dave Barach371e4e12016-07-08 09:38:52 -04001073 /* Endian swap required? */
1074 if (clib_arch_is_big_endian != tp->endian)
1075 {
1076 endian_swap = 1;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001077 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07001078
Dave Barach371e4e12016-07-08 09:38:52 -04001079 for (i = 0; i <= last; i++)
1080 {
1081 /* First 2 bytes are the message type */
1082 if (fread (&msg_id, sizeof (u16), 1, fp) != 1)
1083 {
1084 break;
1085 }
1086 msg_id = ntohs (msg_id);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001087
Dave Barachac0798d2016-07-26 10:30:50 -04001088 if (fseek (fp, -2, SEEK_CUR) < 0)
Ed Warnicke853e7202016-08-12 11:42:26 -07001089 {
1090 vlib_cli_output (vm, "fseek failed, %s", strerror (errno));
1091 fclose (fp);
1092 return;
1093 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07001094
Dave Barach371e4e12016-07-08 09:38:52 -04001095 /* Mild sanity check */
1096 if (msg_id >= vec_len (am->msg_handlers))
1097 {
1098 fclose (fp);
1099 vlib_cli_output (vm, "msg_id %d out of bounds\n", msg_id);
1100 return;
1101 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07001102
Dave Barach371e4e12016-07-08 09:38:52 -04001103 size = am->api_trace_cfg[msg_id].size;
1104
1105 if (fread (msg_buf, size, 1, fp) != 1)
1106 {
1107 fclose (fp);
1108 vlib_cli_output (vm, "read error on %s\n", filename);
1109 return;
1110 }
1111
1112 if (i < first)
1113 continue;
1114
1115 if (endian_swap)
1116 {
1117 endian_fp = am->msg_endian_handlers[msg_id];
1118 (*endian_fp) (msg_buf);
1119 }
1120
1121 vlib_cli_output (vm, "[%d]: %s\n", i, am->msg_names[msg_id]);
1122
1123 print_fp = (void *) am->msg_print_handlers[msg_id];
1124 (*print_fp) (msg_buf, vm);
1125 vlib_cli_output (vm, "-------------\n");
Ed Warnickecb9cada2015-12-08 15:45:58 -07001126 }
Dave Barach371e4e12016-07-08 09:38:52 -04001127 fclose (fp);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001128}
1129
1130static clib_error_t *
Dave Barach371e4e12016-07-08 09:38:52 -04001131vl_api_trace_command (vlib_main_t * vm,
1132 unformat_input_t * input, vlib_cli_command_t * cli_cmd)
Ed Warnickecb9cada2015-12-08 15:45:58 -07001133{
Dave Barach371e4e12016-07-08 09:38:52 -04001134 u32 nitems = 1024;
1135 vl_api_trace_which_t which = VL_API_TRACE_RX;
1136 u8 *filename;
1137 u32 first = 0;
1138 u32 last = ~0;
1139 api_main_t *am = &api_main;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001140
Dave Barach371e4e12016-07-08 09:38:52 -04001141 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1142 {
1143 if (unformat (input, "rx nitems %u", &nitems) || unformat (input, "rx"))
1144 goto configure;
1145 else if (unformat (input, "tx nitems %u", &nitems)
1146 || unformat (input, "tx"))
1147 {
1148 which = VL_API_TRACE_RX;
1149 goto configure;
1150 }
1151 else if (unformat (input, "on rx"))
1152 {
1153 vl_msg_api_trace_onoff (am, VL_API_TRACE_RX, 1);
1154 }
1155 else if (unformat (input, "on tx"))
1156 {
1157 vl_msg_api_trace_onoff (am, VL_API_TRACE_TX, 1);
1158 }
1159 else if (unformat (input, "on"))
1160 {
1161 vl_msg_api_trace_onoff (am, VL_API_TRACE_RX, 1);
1162 }
1163 else if (unformat (input, "off"))
1164 {
1165 vl_msg_api_trace_onoff (am, VL_API_TRACE_RX, 0);
1166 vl_msg_api_trace_onoff (am, VL_API_TRACE_TX, 0);
1167 }
1168 else if (unformat (input, "free"))
1169 {
1170 vl_msg_api_trace_onoff (am, VL_API_TRACE_RX, 0);
1171 vl_msg_api_trace_onoff (am, VL_API_TRACE_TX, 0);
1172 vl_msg_api_trace_free (am, VL_API_TRACE_RX);
1173 vl_msg_api_trace_free (am, VL_API_TRACE_TX);
1174 }
1175 else if (unformat (input, "print %s from %d to %d", &filename,
1176 &first, &last)
1177 || unformat (input, "print %s", &filename))
1178 {
1179 goto print;
1180 }
1181 else if (unformat (input, "debug on"))
1182 {
1183 am->msg_print_flag = 1;
1184 }
1185 else if (unformat (input, "debug off"))
1186 {
1187 am->msg_print_flag = 0;
1188 }
1189 else
1190 return clib_error_return (0, "unknown input `%U'",
1191 format_unformat_error, input);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001192 }
Dave Barach371e4e12016-07-08 09:38:52 -04001193 return 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001194
Dave Barach371e4e12016-07-08 09:38:52 -04001195print:
1196 vl_api_trace_print_file_cmd (vm, first, last, filename);
1197 goto out;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001198
Dave Barach371e4e12016-07-08 09:38:52 -04001199configure:
1200 if (vl_msg_api_trace_configure (am, which, nitems))
1201 {
1202 vlib_cli_output (vm, "warning: trace configure error (%d, %d)",
1203 which, nitems);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001204 }
1205
Dave Barach371e4e12016-07-08 09:38:52 -04001206out:
1207 return 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001208}
1209
Dave Barach371e4e12016-07-08 09:38:52 -04001210/* *INDENT-OFF* */
Ed Warnickecb9cada2015-12-08 15:45:58 -07001211VLIB_CLI_COMMAND (trace, static) = {
1212 .path = "set api-trace",
1213 .short_help = "API trace",
1214 .function = vl_api_trace_command,
1215};
Dave Barach371e4e12016-07-08 09:38:52 -04001216/* *INDENT-ON* */
Ed Warnickecb9cada2015-12-08 15:45:58 -07001217
1218clib_error_t *
1219vlibmemory_init (vlib_main_t * vm)
1220{
Dave Barach309bef22016-01-22 16:09:52 -05001221 api_main_t *am = &api_main;
Dave Barachb3d93da2016-08-03 14:34:38 -04001222 svm_map_region_args_t _a, *a = &_a;
Dave Barachc3799992016-08-15 11:12:27 -04001223
Dave Barachb3d93da2016-08-03 14:34:38 -04001224 memset (a, 0, sizeof (*a));
1225 a->root_path = am->root_path;
1226 a->name = SVM_GLOBAL_REGION_NAME;
Dave Barachc3799992016-08-15 11:12:27 -04001227 a->baseva = (am->global_baseva != 0) ?
Dave Barachb3d93da2016-08-03 14:34:38 -04001228 am->global_baseva : SVM_GLOBAL_REGION_BASEVA;
1229 a->size = (am->global_size != 0) ? am->global_size : SVM_GLOBAL_REGION_SIZE;
1230 a->flags = SVM_FLAGS_NODATA;
1231 a->uid = am->api_uid;
1232 a->gid = am->api_gid;
Dave Barachc3799992016-08-15 11:12:27 -04001233 a->pvt_heap_size =
1234 (am->global_pvt_heap_size !=
1235 0) ? am->global_pvt_heap_size : SVM_PVT_MHEAP_SIZE;
Dave Barachb3d93da2016-08-03 14:34:38 -04001236
1237 svm_region_init_args (a);
Dave Barach309bef22016-01-22 16:09:52 -05001238 return 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001239}
1240
1241VLIB_INIT_FUNCTION (vlibmemory_init);
1242
Dave Barach371e4e12016-07-08 09:38:52 -04001243void
1244vl_set_memory_region_name (char *name)
Ed Warnickecb9cada2015-12-08 15:45:58 -07001245{
Dave Barach371e4e12016-07-08 09:38:52 -04001246 api_main_t *am = &api_main;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001247
Dave Barach371e4e12016-07-08 09:38:52 -04001248 am->region_name = name;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001249}
1250
Dave Barach371e4e12016-07-08 09:38:52 -04001251static int
1252range_compare (vl_api_msg_range_t * a0, vl_api_msg_range_t * a1)
Ed Warnickecb9cada2015-12-08 15:45:58 -07001253{
Dave Barach371e4e12016-07-08 09:38:52 -04001254 int len0, len1, clen;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001255
Dave Barach371e4e12016-07-08 09:38:52 -04001256 len0 = vec_len (a0->name);
1257 len1 = vec_len (a1->name);
1258 clen = len0 < len1 ? len0 : len1;
1259 return (strncmp ((char *) a0->name, (char *) a1->name, clen));
Ed Warnickecb9cada2015-12-08 15:45:58 -07001260}
1261
Dave Barach371e4e12016-07-08 09:38:52 -04001262static u8 *
1263format_api_msg_range (u8 * s, va_list * args)
Ed Warnickecb9cada2015-12-08 15:45:58 -07001264{
Dave Barach371e4e12016-07-08 09:38:52 -04001265 vl_api_msg_range_t *rp = va_arg (*args, vl_api_msg_range_t *);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001266
Dave Barach371e4e12016-07-08 09:38:52 -04001267 if (rp == 0)
1268 s = format (s, "%-20s%9s%9s", "Name", "First-ID", "Last-ID");
1269 else
1270 s = format (s, "%-20s%9d%9d", rp->name, rp->first_msg_id,
1271 rp->last_msg_id);
1272
1273 return s;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001274}
1275
1276static clib_error_t *
Dave Barach371e4e12016-07-08 09:38:52 -04001277vl_api_show_plugin_command (vlib_main_t * vm,
1278 unformat_input_t * input,
1279 vlib_cli_command_t * cli_cmd)
Ed Warnickecb9cada2015-12-08 15:45:58 -07001280{
Dave Barach371e4e12016-07-08 09:38:52 -04001281 api_main_t *am = &api_main;
1282 vl_api_msg_range_t *rp = 0;
1283 int i;
1284
1285 if (vec_len (am->msg_ranges) == 0)
1286 {
1287 vlib_cli_output (vm, "No plugin API message ranges configured...");
1288 return 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001289 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07001290
Dave Barach371e4e12016-07-08 09:38:52 -04001291 rp = vec_dup (am->msg_ranges);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001292
Dave Barach371e4e12016-07-08 09:38:52 -04001293 vec_sort_with_function (rp, range_compare);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001294
Dave Barach371e4e12016-07-08 09:38:52 -04001295 vlib_cli_output (vm, "Plugin API message ID ranges...\n");
1296 vlib_cli_output (vm, "%U", format_api_msg_range, 0 /* header */ );
1297
1298 for (i = 0; i < vec_len (rp); i++)
1299 vlib_cli_output (vm, "%U", format_api_msg_range, rp + i);
1300
1301 return 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001302}
1303
Dave Barach371e4e12016-07-08 09:38:52 -04001304/* *INDENT-OFF* */
Ed Warnickecb9cada2015-12-08 15:45:58 -07001305VLIB_CLI_COMMAND (cli_show_api_plugin_command, static) = {
1306 .path = "show api plugin",
1307 .short_help = "show api plugin",
1308 .function = vl_api_show_plugin_command,
1309};
Dave Barach371e4e12016-07-08 09:38:52 -04001310/* *INDENT-ON* */
Dave Barach4e281a42015-12-14 11:13:29 -05001311
Dave Barach371e4e12016-07-08 09:38:52 -04001312static void
1313vl_api_rpc_call_t_handler (vl_api_rpc_call_t * mp)
Dave Barach4e281a42015-12-14 11:13:29 -05001314{
Dave Barach371e4e12016-07-08 09:38:52 -04001315 vl_api_rpc_reply_t *rmp;
1316 int (*fp) (void *);
Dave Barach4e281a42015-12-14 11:13:29 -05001317 i32 rv = 0;
Dave Barach371e4e12016-07-08 09:38:52 -04001318 vlib_main_t *vm = vlib_get_main ();
Dave Barach4e281a42015-12-14 11:13:29 -05001319
1320 if (mp->function == 0)
1321 {
1322 rv = -1;
1323 clib_warning ("rpc NULL function pointer");
1324 }
Dave Barach371e4e12016-07-08 09:38:52 -04001325
Dave Barach4e281a42015-12-14 11:13:29 -05001326 else
1327 {
1328 if (mp->need_barrier_sync)
Dave Barach371e4e12016-07-08 09:38:52 -04001329 vlib_worker_thread_barrier_sync (vm);
Dave Barach4e281a42015-12-14 11:13:29 -05001330
Dave Barach371e4e12016-07-08 09:38:52 -04001331 fp = uword_to_pointer (mp->function, int (*)(void *));
1332 rv = fp (mp->data);
Dave Barach4e281a42015-12-14 11:13:29 -05001333
1334 if (mp->need_barrier_sync)
Dave Barach371e4e12016-07-08 09:38:52 -04001335 vlib_worker_thread_barrier_release (vm);
Dave Barach4e281a42015-12-14 11:13:29 -05001336 }
1337
1338 if (mp->send_reply)
1339 {
Dave Barach371e4e12016-07-08 09:38:52 -04001340 unix_shared_memory_queue_t *q =
1341 vl_api_client_index_to_input_queue (mp->client_index);
Dave Barach4e281a42015-12-14 11:13:29 -05001342 if (q)
Dave Barach371e4e12016-07-08 09:38:52 -04001343 {
1344 rmp = vl_msg_api_alloc_as_if_client (sizeof (*rmp));
1345 rmp->_vl_msg_id = ntohs (VL_API_RPC_REPLY);
1346 rmp->context = mp->context;
1347 rmp->retval = rv;
1348 vl_msg_api_send_shmem (q, (u8 *) & rmp);
1349 }
Dave Barach4e281a42015-12-14 11:13:29 -05001350 }
1351 if (mp->multicast)
1352 {
1353 clib_warning ("multicast not yet implemented...");
1354 }
1355}
1356
Dave Barach371e4e12016-07-08 09:38:52 -04001357static void
1358vl_api_rpc_reply_t_handler (vl_api_rpc_reply_t * mp)
Dave Barach4e281a42015-12-14 11:13:29 -05001359{
Dave Barach371e4e12016-07-08 09:38:52 -04001360 clib_warning ("unimplemented");
1361}
1362
1363void
1364vl_api_rpc_call_main_thread (void *fp, u8 * data, u32 data_length)
1365{
1366 vl_api_rpc_call_t *mp;
Dave Barach4e281a42015-12-14 11:13:29 -05001367 api_main_t *am = &api_main;
1368 vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr;
Dave Barache9183632016-10-04 16:53:56 -04001369 unix_shared_memory_queue_t *q;
Dave Barach4e281a42015-12-14 11:13:29 -05001370
Dave Barache9183632016-10-04 16:53:56 -04001371 /* Main thread: call the function directly */
1372 if (os_get_cpu_number () == 0)
1373 {
1374 vlib_main_t *vm = vlib_get_main ();
1375 void (*call_fp) (void *);
1376
1377 vlib_worker_thread_barrier_sync (vm);
1378
1379 call_fp = fp;
1380 call_fp (data);
1381
1382 vlib_worker_thread_barrier_release (vm);
1383 return;
1384 }
1385
1386 /* Any other thread, actually do an RPC call... */
Dave Barach4e281a42015-12-14 11:13:29 -05001387 mp = vl_msg_api_alloc_as_if_client (sizeof (*mp) + data_length);
Dave Barache9183632016-10-04 16:53:56 -04001388
Dave Barach4e281a42015-12-14 11:13:29 -05001389 memset (mp, 0, sizeof (*mp));
Damjan Marionf1213b82016-03-13 02:22:06 +01001390 clib_memcpy (mp->data, data, data_length);
Dave Barach4e281a42015-12-14 11:13:29 -05001391 mp->_vl_msg_id = ntohs (VL_API_RPC_CALL);
Dave Barach371e4e12016-07-08 09:38:52 -04001392 mp->function = pointer_to_uword (fp);
Dave Barach4e281a42015-12-14 11:13:29 -05001393 mp->need_barrier_sync = 1;
Dave Barach371e4e12016-07-08 09:38:52 -04001394
Dave Barache9183632016-10-04 16:53:56 -04001395 /*
1396 * Use the "normal" control-plane mechanism for the main thread.
1397 * Well, almost. if the main input queue is full, we cannot
1398 * block. Otherwise, we can expect a barrier sync timeout.
1399 */
1400 q = shmem_hdr->vl_input_queue;
1401
1402 while (pthread_mutex_trylock (&q->mutex))
1403 vlib_worker_thread_barrier_check ();
1404
1405 while (PREDICT_FALSE (unix_shared_memory_queue_is_full (q)))
1406 {
1407 pthread_mutex_unlock (&q->mutex);
1408 vlib_worker_thread_barrier_check ();
1409 while (pthread_mutex_trylock (&q->mutex))
1410 vlib_worker_thread_barrier_check ();
1411 }
1412
1413 vl_msg_api_send_shmem_nolock (q, (u8 *) & mp);
1414
1415 pthread_mutex_unlock (&q->mutex);
Dave Barach4e281a42015-12-14 11:13:29 -05001416}
1417
1418#define foreach_rpc_api_msg \
1419_(RPC_CALL,rpc_call) \
1420_(RPC_REPLY,rpc_reply)
1421
1422static clib_error_t *
Dave Barach371e4e12016-07-08 09:38:52 -04001423rpc_api_hookup (vlib_main_t * vm)
Dave Barach4e281a42015-12-14 11:13:29 -05001424{
1425#define _(N,n) \
1426 vl_msg_api_set_handlers(VL_API_##N, #n, \
1427 vl_api_##n##_t_handler, \
1428 vl_noop_handler, \
1429 vl_noop_handler, \
1430 vl_api_##n##_t_print, \
Dave Barach371e4e12016-07-08 09:38:52 -04001431 sizeof(vl_api_##n##_t), 0 /* do not trace */);
1432 foreach_rpc_api_msg;
Dave Barach4e281a42015-12-14 11:13:29 -05001433#undef _
Dave Barach371e4e12016-07-08 09:38:52 -04001434 return 0;
Dave Barach4e281a42015-12-14 11:13:29 -05001435}
1436
Dave Barach371e4e12016-07-08 09:38:52 -04001437VLIB_API_INIT_FUNCTION (rpc_api_hookup);
1438
1439/*
1440 * fd.io coding-style-patch-verification: ON
1441 *
1442 * Local Variables:
1443 * eval: (c-set-style "gnu")
1444 * End:
1445 */