Gitiles
Code Review Sign In
gerrit.nordix.org / fdio / vpp / fef15b4bb88c61248393b93d13b1f79bb628def0 / . / vlib-api / vlibmemory / memory_vlib.c
blob: 107fddc31ada933c2cdf4d13a329519d3cd0d33c [file] [log] [blame]
/*
*------------------------------------------------------------------
* memory_vlib.c
*
* Copyright (c) 2009 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*------------------------------------------------------------------
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <signal.h>
#include <pthread.h>
#include <vppinfra/vec.h>
#include <vppinfra/hash.h>
#include <vppinfra/pool.h>
#include <vppinfra/format.h>
#include <vppinfra/byte_order.h>
#include <vppinfra/elog.h>
#include <stdarg.h>
#include <vlib/vlib.h>
#include <vlib/unix/unix.h>
#include <vlibapi/api.h>
#include <vlibmemory/api.h>
#define TRACE_VLIB_MEMORY_QUEUE 0
#include <vlibmemory/vl_memory_msg_enum.h> /* enumerate all vlib messages */
#define vl_typedefs /* define message structures */
#include <vlibmemory/vl_memory_api_h.h>
#undef vl_typedefs
/* instantiate all the print functions we know about */
#define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
#define vl_printfun
#include <vlibmemory/vl_memory_api_h.h>
#undef vl_printfun
static inline void *
vl_api_memclnt_create_t_print (vl_api_memclnt_create_t *a,void *handle)
{
vl_print(handle, "vl_api_memclnt_create_t:\n");
vl_print(handle, "name: %s\n", a->name);
vl_print(handle, "input_queue: 0x%wx\n", a->input_queue);
vl_print(handle, "context: %u\n", (unsigned) a->context);
vl_print(handle, "ctx_quota: %ld\n", (long) a->ctx_quota);
return handle;
}
static inline void *
vl_api_memclnt_delete_t_print (vl_api_memclnt_delete_t *a,void *handle)
{
vl_print(handle, "vl_api_memclnt_delete_t:\n");
vl_print(handle, "index: %u\n", (unsigned) a->index);
vl_print(handle, "handle: 0x%wx\n", a->handle);
return handle;
}
/* instantiate all the endian swap functions we know about */
#define vl_endianfun
#include <vlibmemory/vl_memory_api_h.h>
#undef vl_endianfun
void vl_socket_api_send (vl_api_registration_t *rp, u8 *elem)
__attribute__((weak));
void
vl_socket_api_send (vl_api_registration_t *rp, u8 *elem)
{
static int count;
if (count++ < 5)
clib_warning ("need to link against -lvlibsocket, msg not sent!");
}
void vl_msg_api_send (vl_api_registration_t *rp, u8 *elem)
{
if (PREDICT_FALSE(rp->registration_type > REGISTRATION_TYPE_SHMEM)) {
vl_socket_api_send (rp, elem);
} else {
vl_msg_api_send_shmem (rp->vl_input_queue, elem);
}
}
int vl_msg_api_version_check (vl_api_memclnt_create_t * mp)
__attribute__((weak));
int vl_msg_api_version_check (vl_api_memclnt_create_t * mp) { return 0; }
/*
* vl_api_memclnt_create_t_handler
*/
void vl_api_memclnt_create_t_handler (vl_api_memclnt_create_t *mp)
{
vl_api_registration_t **regpp;
vl_api_registration_t *regp;
vl_api_memclnt_create_reply_t *rp;
svm_region_t *svm;
unix_shared_memory_queue_t *q;
int rv;
void *oldheap;
api_main_t *am = &api_main;
/* Indicate API version mismatch if appropriate */
rv = vl_msg_api_version_check (mp);
/*
* This is tortured. Maintain a vlib-address-space private
* pool of client registrations. We use the shared-memory virtual
* address of client structure as a handle, to allow direct
* manipulation of context quota vbls from the client library.
*
* This scheme causes trouble w/ API message trace replay, since
* some random VA from clib_mem_alloc() certainly won't
* occur in the Linux sim. The (very) few places
* that care need to use the pool index.
*
* Putting the registration object(s) into a pool in shared memory and
* using the pool index as a handle seems like a great idea.
* Unfortunately, each and every reference to that pool would need
* to be protected by a mutex:
*
* Client VLIB
* ------ ----
* convert pool index to
* pointer.
* <deschedule>
* expand pool
* <deschedule>
* kaboom!
*/
pool_get(am->vl_clients, regpp);
svm = am->vlib_rp;
pthread_mutex_lock (&svm->mutex);
oldheap = svm_push_data_heap(svm);
*regpp = clib_mem_alloc(sizeof(vl_api_registration_t));
regp = *regpp;
memset(regp, 0, sizeof(*regp));
regp->registration_type = REGISTRATION_TYPE_SHMEM;
regp->vl_api_registration_pool_index = regpp - am->vl_clients;
q = regp->vl_input_queue = (unix_shared_memory_queue_t *)(uword)
mp->input_queue;
regp->name = format(0, "%s", mp->name);
vec_add1(regp->name, 0);
pthread_mutex_unlock(&svm->mutex);
svm_pop_heap (oldheap);
rp = vl_msg_api_alloc(sizeof(*rp));
rp->_vl_msg_id = ntohs(VL_API_MEMCLNT_CREATE_REPLY);
rp->handle = (uword)regp;
rp->index = vl_msg_api_handle_from_index_and_epoch
(regp->vl_api_registration_pool_index,
am->shmem_hdr->application_restarts);
rp->context = mp->context;
rp->response = ntohl(rv);
vl_msg_api_send_shmem(q, (u8 *)&rp);
}
/* Application callback to clean up leftover registrations from this client */
int vl_api_memclnt_delete_callback (u32 client_index)
__attribute__((weak));
int vl_api_memclnt_delete_callback (u32 client_index)
{ return 0; }
/*
* vl_api_memclnt_delete_t_handler
*/
void vl_api_memclnt_delete_t_handler (vl_api_memclnt_delete_t *mp)
{
vl_api_registration_t **regpp;
vl_api_registration_t *regp;
vl_api_memclnt_delete_reply_t *rp;
svm_region_t *svm;
void *oldheap;
api_main_t *am = &api_main;
u32 handle, client_index, epoch;
handle = mp->index;
if (vl_api_memclnt_delete_callback (handle))
return;
epoch = vl_msg_api_handle_get_epoch (handle);
client_index = vl_msg_api_handle_get_index (handle);
if (epoch != (am->shmem_hdr->application_restarts & VL_API_EPOCH_MASK)) {
clib_warning
("Stale clnt delete index %d old epoch %d cur epoch %d",
client_index, epoch,
(am->shmem_hdr->application_restarts & VL_API_EPOCH_MASK));
return;
}
regpp = am->vl_clients + client_index;
if (!pool_is_free(am->vl_clients, regpp)) {
regp = *regpp;
svm = am->vlib_rp;
/* $$$ check the input queue for e.g. punted sf's */
rp = vl_msg_api_alloc(sizeof(*rp));
rp->_vl_msg_id = ntohs(VL_API_MEMCLNT_DELETE_REPLY);
rp->handle = mp->handle;
rp->response = 1;
vl_msg_api_send_shmem (regp->vl_input_queue, (u8 *)&rp);
if (client_index != regp->vl_api_registration_pool_index) {
clib_warning ("mismatch client_index %d pool_index %d",
client_index, regp->vl_api_registration_pool_index);
vl_msg_api_free (rp);
return;
}
/* No dangling references, please */
*regpp = 0;
pool_put_index(am->vl_clients,
regp->vl_api_registration_pool_index);
pthread_mutex_lock (&svm->mutex);
oldheap = svm_push_data_heap(svm);
/* Poison the old registration */
memset (regp, 0xF1, sizeof (*regp));
clib_mem_free (regp);
pthread_mutex_unlock(&svm->mutex);
svm_pop_heap (oldheap);
} else {
clib_warning("unknown client ID %d", mp->index);
}
}
void vl_api_get_first_msg_id_t_handler (vl_api_get_first_msg_id_t * mp)
{
vl_api_get_first_msg_id_reply_t * rmp;
unix_shared_memory_queue_t * q;
uword * p;
api_main_t *am = &api_main;
vl_api_msg_range_t * rp;
u8 name[64];
u16 first_msg_id = ~0;
int rv = -7; /* VNET_API_ERROR_INVALID_VALUE */
q = vl_api_client_index_to_input_queue (mp->client_index);
if (!q)
return;
if (am->msg_range_by_name == 0)
goto out;
strncpy ((char *)name, (char *) mp->name, ARRAY_LEN(name)-1);
p = hash_get_mem (am->msg_range_by_name, name);
if (p == 0)
goto out;
rp = vec_elt_at_index (am->msg_ranges, p[0]);
first_msg_id = rp->first_msg_id;
rv = 0;
out:
rmp = vl_msg_api_alloc (sizeof (*rmp));
rmp->_vl_msg_id = ntohs(VL_API_GET_FIRST_MSG_ID_REPLY);
rmp->context = mp->context;
rmp->retval = ntohl(rv);
rmp->first_msg_id = ntohs(first_msg_id);
vl_msg_api_send_shmem (q, (u8 *)&rmp);
}
#define foreach_vlib_api_msg \
_(MEMCLNT_CREATE, memclnt_create) \
_(MEMCLNT_DELETE, memclnt_delete) \
_(GET_FIRST_MSG_ID, get_first_msg_id)
/*
* vl_api_init
*/
static int memory_api_init(char *region_name)
{
int rv;
vl_msg_api_msg_config_t cfg;
vl_msg_api_msg_config_t *c = &cfg;
if ((rv = vl_map_shmem(region_name, 1 /* is_vlib */)) < 0)
return rv;
#define _(N,n) do { \
c->id = VL_API_##N; \
c->name = #n; \
c->handler = vl_api_##n##_t_handler; \
c->cleanup = vl_noop_handler; \
c->endian = vl_api_##n##_t_endian; \
c->print = vl_api_##n##_t_print; \
c->size = sizeof(vl_api_##n##_t); \
c->traced = 1; /* trace, so these msgs print */ \
c->replay = 0; /* don't replay client create/delete msgs */ \
vl_msg_api_config(c);} while (0);
foreach_vlib_api_msg;
#undef _
return 0;
}
#define foreach_histogram_bucket \
_(400) \
_(200) \
_(100) \
_(10)
typedef enum {
#define _(n) SLEEP_##n##_US,
foreach_histogram_bucket
#undef _
SLEEP_N_BUCKETS,
} histogram_index_t;
static u64 vector_rate_histogram[SLEEP_N_BUCKETS];
static void memclnt_queue_signal (int signum);
static void memclnt_queue_callback (vlib_main_t *vm);
static uword
memclnt_process (vlib_main_t * vm,
vlib_node_runtime_t * node,
vlib_frame_t * f)
{
uword mp;
vl_shmem_hdr_t *shm;
unix_shared_memory_queue_t *q;
clib_error_t *e;
int rv;
api_main_t *am = &api_main;
f64 dead_client_scan_time;
f64 sleep_time, start_time;
f64 vector_rate;
vlib_set_queue_signal_callback (vm, memclnt_queue_callback);
am->vlib_signal = SIGUSR1;
signal (am->vlib_signal, memclnt_queue_signal);
if ((rv = memory_api_init(am->region_name)) < 0) {
clib_warning("memory_api_init returned %d, wait for godot...", rv);
vlib_process_suspend (vm, 1e70);
}
shm = am->shmem_hdr;
ASSERT(shm);
q = shm->vl_input_queue;
ASSERT(q);
e = vlib_call_init_exit_functions
(vm, vm->api_init_function_registrations, 1 /* call_once */);
if (e)
clib_error_report (e);
sleep_time = 20.0;
dead_client_scan_time = vlib_time_now(vm) + 20.0;
/* $$$ pay attention to frame size, control CPU usage */
while (1) {
uword event_type __attribute__((unused));
i8 *headp;
int need_broadcast;
/*
* There's a reason for checking the queue before
* sleeping. If the vlib application crashes, it's entirely
* possible for a client to enqueue a connect request
* during the process restart interval.
*
* Unless some force of physics causes the new incarnation
* of the application to process the request, the client will
* sit and wait for Godot...
*/
vector_rate = vlib_last_vector_length_per_node(vm);
start_time = vlib_time_now (vm);
while (1) {
pthread_mutex_lock (&q->mutex);
if (q->cursize == 0) {
pthread_mutex_unlock (&q->mutex);
if (TRACE_VLIB_MEMORY_QUEUE)
{
ELOG_TYPE_DECLARE (e) = {
.format = "q-underflow: len %d",
.format_args = "i4",
};
struct { u32 len; } * ed;
ed = ELOG_DATA (&vm->elog_main, e);
ed->len = 0;
}
sleep_time = 20.0;
break;
}
headp = (i8 *) (q->data + sizeof(uword)*q->head);
memcpy (&mp, headp, sizeof(uword));
q->head++;
need_broadcast = (q->cursize == q->maxsize/2);
q->cursize--;
if (PREDICT_FALSE(q->head == q->maxsize))
q->head = 0;
pthread_mutex_unlock(&q->mutex);
if (need_broadcast)
(void) pthread_cond_broadcast(&q->condvar);
vl_msg_api_handler_with_vm_node (am, (void *)mp, vm, node);
/* Allow no more than 10us without a pause */
if (vlib_time_now(vm) > start_time + 10e-6) {
int index = SLEEP_400_US;
if (vector_rate > 40.0)
sleep_time = 400e-6;
else if (vector_rate > 20.0) {
index = SLEEP_200_US;
sleep_time = 200e-6;
} else if (vector_rate >= 1.0) {
index = SLEEP_100_US;
sleep_time = 100e-6;
}
else {
index = SLEEP_10_US;
sleep_time = 10e-6;
}
vector_rate_histogram[index] += 1;
break;
}
}
event_type = vlib_process_wait_for_event_or_clock (vm, sleep_time);
vlib_process_get_events (vm, 0 /* event_data */);
if (vlib_time_now (vm) > dead_client_scan_time) {
vl_api_registration_t **regpp;
vl_api_registration_t *regp;
unix_shared_memory_queue_t *q;
static u32 * dead_indices;
static u32 * confused_indices;
vec_reset_length (dead_indices);
vec_reset_length (confused_indices);
pool_foreach (regpp, am->vl_clients,
({
regp = *regpp;
if (regp) {
q = regp->vl_input_queue;
if (kill (q->consumer_pid, 0) < 0) {
vec_add1(dead_indices, regpp - am->vl_clients);
}
} else {
clib_warning ("NULL client registration index %d",
regpp - am->vl_clients);
vec_add1 (confused_indices, regpp - am->vl_clients);
}
}));
/* This should "never happen," but if it does, fix it... */
if (PREDICT_FALSE (vec_len(confused_indices) > 0)) {
int i;
for (i = 0; i < vec_len (confused_indices); i++) {
pool_put_index (am->vl_clients, confused_indices[i]);
}
}
if (PREDICT_FALSE (vec_len(dead_indices) > 0)) {
int i;
svm_region_t *svm;
void * oldheap;
/* Allow the application to clean up its registrations */
for (i = 0; i < vec_len(dead_indices); i++) {
regpp = pool_elt_at_index (am->vl_clients, dead_indices[i]);
if (regpp) {
u32 handle;
handle = vl_msg_api_handle_from_index_and_epoch
(dead_indices[i], shm->application_restarts);
(void) vl_api_memclnt_delete_callback (handle);
}
}
svm = am->vlib_rp;
pthread_mutex_lock (&svm->mutex);
oldheap = svm_push_data_heap(svm);
for (i = 0; i < vec_len(dead_indices); i++) {
regpp = pool_elt_at_index (am->vl_clients, dead_indices[i]);
if (regpp) {
/* Poison the old registration */
memset (*regpp, 0xF3, sizeof (**regpp));
clib_mem_free (*regpp);
/* no dangling references, please */
*regpp = 0;
} else {
svm_pop_heap (oldheap);
clib_warning ("Duplicate free, client index %d",
regpp - am->vl_clients);
oldheap = svm_push_data_heap(svm);
}
}
svm_client_scan_this_region_nolock (am->vlib_rp);
pthread_mutex_unlock(&svm->mutex);
svm_pop_heap (oldheap);
for (i = 0; i < vec_len (dead_indices); i++)
pool_put_index (am->vl_clients, dead_indices[i]);
}
dead_client_scan_time = vlib_time_now (vm) + 20.0;
}
if (TRACE_VLIB_MEMORY_QUEUE)
{
ELOG_TYPE_DECLARE (e) = {
.format = "q-awake: len %d",
.format_args = "i4",
};
struct { u32 len; } * ed;
ed = ELOG_DATA (&vm->elog_main, e);
ed->len = q->cursize;
}
}
return 0;
}
static clib_error_t *
vl_api_show_histogram_command(vlib_main_t * vm,
unformat_input_t * input,
vlib_cli_command_t * cli_cmd)
{
u64 total_counts = 0;
int i;
for (i = 0; i < SLEEP_N_BUCKETS; i++) {
total_counts += vector_rate_histogram [i];
}
if (total_counts == 0) {
vlib_cli_output (vm, "No control-plane activity.");
return 0;
}
#define _(n) \
do { \
f64 percent; \
percent = ((f64) vector_rate_histogram[SLEEP_##n##_US]) \
/ (f64) total_counts; \
percent *= 100.0; \
vlib_cli_output (vm, "Sleep %3d us: %llu, %.2f%%",n, \
vector_rate_histogram[SLEEP_##n##_US], \
percent); \
} while (0);
foreach_histogram_bucket;
#undef _
return 0;
}
VLIB_CLI_COMMAND (cli_show_api_histogram_command, static) = {
.path = "show api histogram",
.short_help = "show api histogram",
.function = vl_api_show_histogram_command,
};
static clib_error_t *
vl_api_clear_histogram_command(vlib_main_t * vm,
unformat_input_t * input,
vlib_cli_command_t * cli_cmd)
{
int i;
for (i = 0; i < SLEEP_N_BUCKETS; i++)
vector_rate_histogram[i] = 0;
return 0;
}
VLIB_CLI_COMMAND (cli_clear_api_histogram_command, static) = {
.path = "clear api histogram",
.short_help = "clear api histogram",
.function = vl_api_clear_histogram_command,
};
VLIB_REGISTER_NODE (memclnt_node,static) = {
.function = memclnt_process,
.type = VLIB_NODE_TYPE_PROCESS,
.name = "api-rx-from-ring",
.state = VLIB_NODE_STATE_DISABLED,
};
static void
memclnt_queue_signal (int signum)
{
vlib_main_t * vm = vlib_get_main();
vm->queue_signal_pending = 1;
}
static void
memclnt_queue_callback (vlib_main_t *vm)
{
#if 0
/* If we need to manually suspend / resume the memclnt process */
vlib_node_t * n = vlib_get_node (vm, memclnt_node.index);
vlib_process_t * p = vlib_get_process_from_node (vm, n);
#endif
vm->queue_signal_pending = 0;
vlib_process_signal_event
(vm, memclnt_node.index, /* event_type */ 0, /* event_data */ 0);
}
void vl_enable_disable_memory_api (vlib_main_t *vm, int enable)
{
vlib_node_set_state (vm, memclnt_node.index,
(enable
? VLIB_NODE_STATE_POLLING
: VLIB_NODE_STATE_DISABLED));
}
static uword
api_rx_from_node (vlib_main_t * vm,
vlib_node_runtime_t * node,
vlib_frame_t * frame)
{
uword n_packets = frame->n_vectors;
uword n_left_from;
u32 * from;
static u8 * long_msg;
vec_validate (long_msg, 4095);
n_left_from = frame->n_vectors;
from = vlib_frame_args (frame);
while (n_left_from > 0) {
u32 bi0;
vlib_buffer_t * b0;
void * msg;
uword msg_len;
bi0 = from[0];
b0 = vlib_get_buffer (vm, bi0);
from += 1;
n_left_from -= 1;
msg = b0->data + b0->current_data;
msg_len = b0->current_length;
if (b0->flags & VLIB_BUFFER_NEXT_PRESENT) {
ASSERT (long_msg != 0);
_vec_len (long_msg) = 0;
vec_add (long_msg, msg, msg_len);
while (b0->flags & VLIB_BUFFER_NEXT_PRESENT) {
b0 = vlib_get_buffer (vm, b0->next_buffer);
msg = b0->data + b0->current_data;
msg_len = b0->current_length;
vec_add (long_msg, msg, msg_len);
}
msg = long_msg;
}
vl_msg_api_handler_no_trace_no_free (msg);
}
/* Free what we've been given. */
vlib_buffer_free (vm, vlib_frame_args (frame), n_packets);
return n_packets;
}
VLIB_REGISTER_NODE (api_rx_from_node_node,static) = {
.function = api_rx_from_node,
.type = VLIB_NODE_TYPE_INTERNAL,
.vector_size = 4,
.name = "api-rx-from-node",
};
static clib_error_t *
setup_memclnt_exit (vlib_main_t * vm)
{
atexit (vl_unmap_shmem);
return 0;
}
VLIB_INIT_FUNCTION (setup_memclnt_exit);
static clib_error_t *
vl_api_ring_command(vlib_main_t * vm,
unformat_input_t * input,
vlib_cli_command_t * cli_cmd)
{
int i;
ring_alloc_t *ap;
vl_shmem_hdr_t *shmem_hdr;
api_main_t *am = &api_main;
shmem_hdr = am->shmem_hdr;
if (shmem_hdr == 0) {
vlib_cli_output (vm, "Shared memory segment not initialized...\n");
return 0;
}
vlib_cli_output (vm, "%8s %8s %8s %8s %8s\n",
"Owner", "Size", "Nitems", "Hits", "Misses");
ap = shmem_hdr->vl_rings;
for (i = 0; i < vec_len(shmem_hdr->vl_rings); i++) {
vlib_cli_output(vm, "%8s %8d %8d %8d %8d\n",
"vlib", ap->size, ap->nitems, ap->hits, ap->misses);
ap++;
}
ap = shmem_hdr->client_rings;
for (i = 0; i < vec_len(shmem_hdr->client_rings); i++) {
vlib_cli_output(vm, "%8s %8d %8d %8d %8d\n",
"clnt", ap->size, ap->nitems, ap->hits, ap->misses);
ap++;
}
vlib_cli_output (vm, "%d ring miss fallback allocations\n",
am->ring_misses);
vlib_cli_output (vm, "%d application restarts, %d reclaimed msgs\n",
shmem_hdr->application_restarts,
shmem_hdr->restart_reclaims);
return 0;
}
void dump_socket_clients (vlib_main_t *vm, api_main_t *am)
__attribute__((weak));
void dump_socket_clients (vlib_main_t *vm, api_main_t *am)
{
}
static clib_error_t *
vl_api_client_command(vlib_main_t * vm,
unformat_input_t * input,
vlib_cli_command_t * cli_cmd)
{
vl_api_registration_t **regpp, *regp;
unix_shared_memory_queue_t *q;
char *health;
api_main_t *am = &api_main;
u32 * confused_indices = 0;
if (!pool_elts (am->vl_clients))
goto socket_clients;
vlib_cli_output (vm, "Shared memory clients");
vlib_cli_output (vm, "%16s %8s %14s %18s %s",
"Name", "PID", "Queue Length", "Queue VA", "Health");
pool_foreach (regpp, am->vl_clients,
({
regp = *regpp;
if (regp) {
q = regp->vl_input_queue;
if (kill (q->consumer_pid, 0) < 0) {
health = "DEAD";
} else {
health = "alive";
}
vlib_cli_output (vm, "%16s %8d %14d 0x%016llx %s\n",
regp->name, q->consumer_pid, q->cursize,
q, health);
} else {
clib_warning ("NULL client registration index %d",
regpp - am->vl_clients);
vec_add1 (confused_indices, regpp - am->vl_clients);
}
}));
/* This should "never happen," but if it does, fix it... */
if (PREDICT_FALSE (vec_len(confused_indices) > 0)) {
int i;
for (i = 0; i < vec_len (confused_indices); i++) {
pool_put_index (am->vl_clients, confused_indices[i]);
}
}
vec_free (confused_indices);
if (am->missing_clients)
vlib_cli_output (vm, "%u messages with missing clients",
am->missing_clients);
socket_clients:
dump_socket_clients (vm, am);
return 0;
}
VLIB_CLI_COMMAND (cli_show_api_command, static) = {
.path = "show api",
.short_help = "Show API information",
};
VLIB_CLI_COMMAND (cli_show_api_ring_command, static) = {
.path = "show api ring-stats",
.short_help = "Message ring statistics",
.function = vl_api_ring_command,
};
VLIB_CLI_COMMAND (cli_show_api_clients_command, static) = {
.path = "show api clients",
.short_help = "Client information",
.function = vl_api_client_command,
};
static clib_error_t *
vl_api_message_table_command(vlib_main_t * vm,
unformat_input_t * input,
vlib_cli_command_t * cli_cmd)
{
api_main_t *am = &api_main;
int i;
int verbose = 0;
if (unformat (input, "verbose"))
verbose = 1;
if (verbose == 0)
vlib_cli_output (vm, "%-4s %s", "ID", "Name");
else
vlib_cli_output (vm, "%-4s %-40s %6s %7s", "ID", "Name", "Bounce",
"MP-safe");
for (i = 1; i < vec_len (am->msg_names); i++) {
if (verbose == 0) {
vlib_cli_output (vm, "%-4d %s", i,
am->msg_names[i] ? am->msg_names[i] :
" [no handler]");
} else {
vlib_cli_output (vm, "%-4d %-40s %6d %7d", i,
am->msg_names[i] ? am->msg_names[i] :
" [no handler]", am->message_bounce[i],
am->is_mp_safe[i]);
}
}
return 0;
}
VLIB_CLI_COMMAND (cli_show_api_message_table_command, static) = {
.path = "show api message-table",
.short_help = "Message Table",
.function = vl_api_message_table_command,
};
void vl_api_trace_print_file_cmd(vlib_main_t *vm, u32 first, u32 last,
u8 *filename)
{
FILE *fp;
static vl_api_trace_t *tp = 0;
int endian_swap = 0;
u32 i;
u16 msg_id;
static u8 *msg_buf=0;
void (*endian_fp)(void *);
u8 *(*print_fp)(void *, void *);
int size;
api_main_t *am = &api_main;
/*
* On-demand: allocate enough space for the largest message
*/
if (msg_buf == 0) {
vec_validate(tp, 0);
int max_size = 0;
for (i = 0; i < vec_len(am->api_trace_cfg); i++) {
if (am->api_trace_cfg[i].size > max_size)
max_size = am->api_trace_cfg[i].size;
}
/* round size to a multiple of the cache-line size */
max_size = (max_size + (CLIB_CACHE_LINE_BYTES-1)) &
(~(CLIB_CACHE_LINE_BYTES-1));
vec_validate (msg_buf, max_size-1);
}
fp = fopen ((char *)filename, "r");
if (fp == NULL) {
vlib_cli_output (vm, "Couldn't open %s\n", filename);
return;
}
/* first, fish the header record from the file */
if (fread(tp, sizeof(*tp), 1, fp) != 1) {
fclose(fp);
vlib_cli_output (vm, "Header read error\n");
return;
}
/* Endian swap required? */
if (clib_arch_is_big_endian != tp->endian) {
endian_swap = 1;
}
for (i = 0; i <= last; i++) {
/* First 2 bytes are the message type */
if (fread(&msg_id, sizeof(u16), 1, fp) != 1) {
break;
}
msg_id = ntohs(msg_id);
fseek(fp, -2, SEEK_CUR);
/* Mild sanity check */
if (msg_id >= vec_len(am->msg_handlers)) {
fclose(fp);
vlib_cli_output (vm, "msg_id %d out of bounds\n",
msg_id);
return;
}
size = am->api_trace_cfg[msg_id].size;
if (fread(msg_buf, size, 1, fp) != 1) {
fclose(fp);
vlib_cli_output (vm, "read error on %s\n", filename);
return;
}
if (i < first)
continue;
if (endian_swap) {
endian_fp = am->msg_endian_handlers[msg_id];
(*endian_fp)(msg_buf);
}
vlib_cli_output (vm, "[%d]: %s\n", i,
am->msg_names[msg_id]);
print_fp = (void *)am->msg_print_handlers[msg_id];
(*print_fp)(msg_buf, vm);
vlib_cli_output (vm, "-------------\n");
}
fclose(fp);
}
static clib_error_t *
vl_api_trace_command(vlib_main_t * vm,
unformat_input_t * input,
vlib_cli_command_t * cli_cmd)
{
u32 nitems=1024;
vl_api_trace_which_t which=VL_API_TRACE_RX;
u8 *filename;
u32 first = 0;
u32 last = ~0;
api_main_t *am = &api_main;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
if (unformat (input, "rx nitems %u", &nitems)
|| unformat (input, "rx"))
goto configure;
else if (unformat (input, "tx nitems %u", &nitems)
|| unformat (input, "tx")) {
which = VL_API_TRACE_RX;
goto configure;
} else if (unformat (input, "on rx")) {
vl_msg_api_trace_onoff (am, VL_API_TRACE_RX, 1);
} else if (unformat (input, "on tx")) {
vl_msg_api_trace_onoff (am, VL_API_TRACE_TX, 1);
} else if (unformat (input, "on")) {
vl_msg_api_trace_onoff (am, VL_API_TRACE_RX, 1);
} else if (unformat (input, "off")) {
vl_msg_api_trace_onoff (am, VL_API_TRACE_RX, 0);
vl_msg_api_trace_onoff (am, VL_API_TRACE_TX, 0);
} else if (unformat (input, "free")) {
vl_msg_api_trace_onoff (am, VL_API_TRACE_RX, 0);
vl_msg_api_trace_onoff (am, VL_API_TRACE_TX, 0);
vl_msg_api_trace_free (am, VL_API_TRACE_RX);
vl_msg_api_trace_free (am, VL_API_TRACE_TX);
} else if (unformat (input, "print %s from %d to %d", &filename,
&first, &last)
|| unformat (input, "print %s", &filename)) {
goto print;
} else if (unformat (input, "debug on")) {
am->msg_print_flag = 1;
} else if (unformat (input, "debug off")) {
am->msg_print_flag = 0;
}
else
return clib_error_return (0, "unknown input `%U'",
format_unformat_error, input);
}
return 0;
print:
vl_api_trace_print_file_cmd (vm, first, last, filename);
goto out;
configure:
if (vl_msg_api_trace_configure (am, which, nitems)) {
vlib_cli_output (vm, "warning: trace configure error (%d, %d)",
which, nitems);
}
out:
return 0;
}
VLIB_CLI_COMMAND (trace, static) = {
.path = "set api-trace",
.short_help = "API trace",
.function = vl_api_trace_command,
};
clib_error_t *
vlibmemory_init (vlib_main_t * vm)
{
api_main_t *am = &api_main;
/* Normally NULL, can be set by cmd line "chroot {prefix foo}" */
svm_region_init_chroot (am->root_path);
return 0;
}
VLIB_INIT_FUNCTION (vlibmemory_init);
void vl_set_memory_region_name (char *name)
{
api_main_t *am = &api_main;
am->region_name = name;
}
static int range_compare (vl_api_msg_range_t * a0, vl_api_msg_range_t * a1)
{
int len0, len1, clen;
len0 = vec_len (a0->name);
len1 = vec_len (a1->name);
clen = len0 < len1 ? len0 : len1;
return (strncmp ((char *) a0->name, (char *)a1->name, clen));
}
static u8 * format_api_msg_range (u8 * s, va_list * args)
{
vl_api_msg_range_t * rp = va_arg (*args, vl_api_msg_range_t *);
if (rp == 0)
s = format (s, "%-20s%9s%9s", "Name", "First-ID", "Last-ID");
else
s = format (s, "%-20s%9d%9d", rp->name, rp->first_msg_id,
rp->last_msg_id);
return s;
}
static clib_error_t *
vl_api_show_plugin_command(vlib_main_t * vm,
unformat_input_t * input,
vlib_cli_command_t * cli_cmd)
{
api_main_t *am = &api_main;
vl_api_msg_range_t * rp = 0;
int i;
if (vec_len (am->msg_ranges) == 0) {
vlib_cli_output (vm, "No plugin API message ranges configured...");
return 0;
}
rp = vec_dup (am->msg_ranges);
vec_sort_with_function (rp, range_compare);
vlib_cli_output (vm, "Plugin API message ID ranges...\n");
vlib_cli_output (vm, "%U", format_api_msg_range, 0 /* header */);
for (i = 0; i < vec_len (rp); i++)
vlib_cli_output (vm, "%U", format_api_msg_range, rp+i);
return 0;
}
VLIB_CLI_COMMAND (cli_show_api_plugin_command, static) = {
.path = "show api plugin",
.short_help = "show api plugin",
.function = vl_api_show_plugin_command,
};
static void vl_api_rpc_call_t_handler (vl_api_rpc_call_t * mp)
{
vl_api_rpc_reply_t * rmp;
int (*fp)(void *);
i32 rv = 0;
vlib_main_t * vm = vlib_get_main();
if (mp->function == 0)
{
rv = -1;
clib_warning ("rpc NULL function pointer");
}
else
{
if (mp->need_barrier_sync)
vlib_worker_thread_barrier_sync (vm);
fp = uword_to_pointer(mp->function, int(*)(void *));
rv = fp(mp->data);
if (mp->need_barrier_sync)
vlib_worker_thread_barrier_release (vm);
}
if (mp->send_reply)
{
unix_shared_memory_queue_t * q =
vl_api_client_index_to_input_queue (mp->client_index);
if (q)
{
rmp = vl_msg_api_alloc_as_if_client (sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_RPC_REPLY);
rmp->context = mp->context;
rmp->retval = rv;
vl_msg_api_send_shmem (q, (u8 *)&rmp);
}
}
if (mp->multicast)
{
clib_warning ("multicast not yet implemented...");
}
}
static void vl_api_rpc_reply_t_handler (vl_api_rpc_reply_t * mp)
{ clib_warning ("unimplemented"); }
void vl_api_rpc_call_main_thread (void *fp, u8 * data, u32 data_length)
{
vl_api_rpc_call_t * mp;
api_main_t *am = &api_main;
vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr;
mp = vl_msg_api_alloc_as_if_client (sizeof (*mp) + data_length);
memset (mp, 0, sizeof (*mp));
memcpy (mp->data, data, data_length);
mp->_vl_msg_id = ntohs (VL_API_RPC_CALL);
mp->function = pointer_to_uword(fp);
mp->need_barrier_sync = 1;
/* Use the "normal" control-plane mechanism for the main thread */
vl_msg_api_send_shmem (shmem_hdr->vl_input_queue, (u8 *)&mp);
}
#define foreach_rpc_api_msg \
_(RPC_CALL,rpc_call) \
_(RPC_REPLY,rpc_reply)
static clib_error_t *
rpc_api_hookup (vlib_main_t *vm)
{
#define _(N,n) \
vl_msg_api_set_handlers(VL_API_##N, #n, \
vl_api_##n##_t_handler, \
vl_noop_handler, \
vl_noop_handler, \
vl_api_##n##_t_print, \
sizeof(vl_api_##n##_t), 0 /* do not trace */);
foreach_rpc_api_msg;
#undef _
return 0;
}
VLIB_API_INIT_FUNCTION(rpc_api_hookup);