23 #include <sys/types.h> 26 #include <netinet/in.h> 57 #undef __included_bihash_template_h__ 70 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__) 76 #define foreach_vpe_api_msg \ 77 _(CONTROL_PING, control_ping) \ 79 _(CLI_INBAND, cli_inband) \ 80 _(GET_NODE_INDEX, get_node_index) \ 81 _(ADD_NODE_NEXT, add_node_next) \ 82 _(SHOW_VERSION, show_version) \ 83 _(SHOW_THREADS, show_threads) \ 84 _(GET_NODE_GRAPH, get_node_graph) \ 85 _(GET_NEXT_INDEX, get_next_index) \ 88 #define QUOTE(x) QUOTE_(x) 107 p = hash_get (vam->a##_registration_hash, client_index); \ 109 rp = pool_elt_at_index (vam->a##_registrations, p[0]); \ 110 pool_put (vam->a##_registrations, rp); \ 111 hash_unset (vam->a##_registration_hash, client_index); \ 129 rmp->
vpe_pid = ntohl (getpid());
137 u8 **shmem_vecp = (
u8 **) arg;
143 shmem_vec = *shmem_vecp;
152 clib_memcpy (shmem_vec + offset, buffer, buffer_bytes);
157 *shmem_vecp = shmem_vec;
177 rp->_vl_msg_id = ntohs (VL_API_CLI_REPLY);
200 u8 **mem_vecp = (
u8 **) arg;
201 u8 *mem_vec = *mem_vecp;
205 clib_memcpy (mem_vec + offset, buffer, buffer_bytes);
252 u32 version_len =
strnlen_s (vpe_api_get_version (), 32);
253 u32 build_date_len =
strnlen_s (vpe_api_get_build_date (), 32);
254 u32 build_directory_len =
strnlen_s (vpe_api_get_build_directory (), 256);
256 u32 n = program_len + version_len + build_date_len + build_directory_len;
261 char *p = (
char *)&rmp->
program;
274 td->
id = htonl (index);
290 int rv = 0,
count = 0;
292 #if !defined(__powerpc64__) 308 rmp->_vl_msg_id = htons (VL_API_SHOW_THREADS_REPLY);
313 for (i = 0; i <
count; i++)
323 clib_warning (
"power pc does not support show threads api");
327 rmp->count = htonl(count);
345 rv = VNET_API_ERROR_NO_SUCH_NODE;
347 node_index = n->
index;
364 u32 next_node_index = ~0, next_index = ~0;
371 rv = VNET_API_ERROR_NO_SUCH_NODE;
379 rv = VNET_API_ERROR_NO_SUCH_NODE2;
383 next_node_index = next_node->
index;
389 rv = VNET_API_ERROR_NO_SUCH_ENTRY;
417 rv = VNET_API_ERROR_NO_SUCH_NODE;
424 rv = VNET_API_ERROR_NO_SUCH_NODE2;
461 &node_dups, &stat_vms);
476 #define BOUNCE_HANDLER(nn) \ 477 static void vl_api_##nn##_t_handler ( \ 478 vl_api_##nn##_t *mp) \ 480 vpe_client_registration_t *reg; \ 481 vpe_api_main_t * vam = &vpe_api_main; \ 485 pool_foreach(reg, vam->nn##_registrations, \ 487 q = vl_api_client_index_to_input_queue (reg->client_index); \ 494 if (q->cursize == q->maxsize) { \ 495 clib_warning ("ERROR: receiver queue full, drop msg"); \ 496 vl_msg_api_free (mp); \ 499 vl_msg_api_send_shmem (q, (u8 *)&mp); \ 503 vl_msg_api_free (mp); \ 521 vl_msg_api_set_handlers(VL_API_##N, #n, \ 522 vl_api_##n##_t_handler, \ 524 vl_api_##n##_t_endian, \ 525 vl_api_##n##_t_print, \ 526 sizeof(vl_api_##n##_t), 1); 535 += 5 *
sizeof (
u32x4);
541 am->
is_mp_safe[VL_API_CONTROL_PING_REPLY] = 1;
563 am->a##_registration_hash = hash_create (0, sizeof (uword)); 577 u64 baseva,
size, pvt_heap_size;
579 const int max_buf_size = 4096;
581 struct passwd _pw, *pw;
582 struct group _grp, *grp;
587 if (
unformat (input,
"prefix %s", &chroot_path))
592 else if (
unformat (input,
"uid %d", &uid))
594 else if (
unformat (input,
"gid %d", &gid))
596 else if (
unformat (input,
"baseva %llx", &baseva))
598 else if (
unformat (input,
"global-size %lldM", &size))
600 else if (
unformat (input,
"global-size %lldG", &size))
602 else if (
unformat (input,
"global-size %lld", &size))
604 else if (
unformat (input,
"global-pvt-heap-size %lldM", &pvt_heap_size))
606 else if (
unformat (input,
"global-pvt-heap-size size %lld",
609 else if (
unformat (input,
"api-pvt-heap-size %lldM", &pvt_heap_size))
611 else if (
unformat (input,
"api-pvt-heap-size size %lld",
614 else if (
unformat (input,
"api-size %lldM", &size))
616 else if (
unformat (input,
"api-size %lldG", &size))
618 else if (
unformat (input,
"api-size %lld", &size))
620 else if (
unformat (input,
"uid %s", &s))
625 getpwnam_r (s, &_pw, buf,
vec_len (buf), &pw)) == ERANGE)
626 && (
vec_len (buf) <= max_buf_size))
635 "cannot fetch username %s", s);
651 else if (
unformat (input,
"gid %s", &s))
656 getgrnam_r (s, &_grp, buf,
vec_len (buf), &grp)) == ERANGE)
657 && (
vec_len (buf) <= max_buf_size))
666 "cannot fetch group %s", s);
702 s =
format (s,
"pid %d: ", ntohl (event->pid));
712 s =
format (s,
"pid %d: ", ntohl (event->pid));
726 pool_elts (am->wc_ip4_arp_events_registrations) == 0 &&
727 pool_elts (am->wc_ip6_nd_events_registrations) == 0)
736 vlib_cli_output (vm,
"%U", format_arp_event, arp_event);
742 vlib_cli_output (vm,
"pid %d: bd mac/ip4 binding events",
743 ntohl (reg->client_pid));
748 vlib_cli_output (vm,
"%U", format_nd_event, nd_event);
753 vlib_cli_output (vm,
"pid %d: bd mac/ip6 binding events",
754 ntohl (reg->client_pid));
763 .path =
"show arp-nd-event registrations",
765 .short_help =
"Show ip4 arp and ip6 nd event registrations",
769 #define vl_msg_name_crc_list 771 #undef vl_msg_name_crc_list 776 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id); 777 foreach_vl_msg_name_crc_memclnt;
778 foreach_vl_msg_name_crc_vpe;
781 #define vl_api_version_tuple(n,mj, mi, p) \ 782 vl_msg_api_add_version (am, #n, mj, mi, p); 784 #undef vl_api_version_tuple #define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
static clib_error_t * memclnt_delete_callback(u32 client_index)
static void svm_pop_heap(void *oldheap)
Reply for get next node index.
vpe parser cli string response
#define foreach_vpe_api_msg
void vl_set_global_memory_baseva(u64 baseva)
static void vl_api_cli_t_handler(vl_api_cli_t *mp)
void vlib_cli_input(vlib_main_t *vm, unformat_input_t *input, vlib_cli_output_function_t *function, uword function_arg)
vnet_main_t * vnet_get_main(void)
Optimized string handling code, including c11-compliant "safe C library" variants.
Control ping from client to api server request.
int size
for sanity checking
void vl_set_memory_uid(int uid)
Fixed length block allocator.
void vl_set_global_pvt_heap_size(u64 size)
vl_api_thread_data_t thread_data[count]
#define REPLY_MACRO2(t, body)
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
VLIB_API_INIT_FUNCTION(vpe_api_hookup)
static void vl_api_send_msg(vl_api_registration_t *rp, u8 *elem)
static int vl_api_to_api_string(u32 len, const char *buf, vl_api_string_t *str)
static clib_error_t * api_segment_config(vlib_main_t *vm, unformat_input_t *input)
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
unformat_function_t unformat_vnet_sw_interface
u8 * vlib_node_serialize(vlib_main_t *vm, vlib_node_t ***node_dups, u8 *vector, int include_nexts, int include_stats)
void * vl_msg_api_alloc(int nbytes)
static uword vlib_node_add_next(vlib_main_t *vm, uword node, uword next_node)
trace_cfg_t * api_trace_cfg
Current trace configuration.
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
Process a vpe parser cli string request.
void vl_set_global_memory_size(u64 size)
#define clib_memcpy(d, s, n)
static void vl_api_get_next_index_t_handler(vl_api_get_next_index_t *mp)
Get node index using name request.
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
static void vl_api_get_node_graph_t_handler(vl_api_get_node_graph_t *mp)
static void * svm_push_data_heap(svm_region_t *rp)
void vlib_node_get_nodes(vlib_main_t *vm, u32 max_threads, int include_stats, int barrier_sync, vlib_node_t ****node_dupsp, vlib_main_t ***stat_vmsp)
Get list of nodes.
#define vec_new(T, N)
Create new vector of given type and length (unspecified alignment, no header).
struct _vl_api_ip4_arp_event * arp_events
#define clib_error_return_fatal(e, args...)
#define clib_error_return(e, args...)
svm_region_t * vlib_rp
Current binary api segment descriptor.
#define vec_resize(V, N)
Resize a vector (no header, unspecified alignment) Add N elements to end of given vector V...
size_t strnlen_s(const char *s, size_t maxsize)
compute the length in s, no more than maxsize
void vl_set_memory_root_path(const char *name)
vlib_worker_thread_t * vlib_worker_threads
static void shmem_cli_output(uword arg, u8 *buffer, uword buffer_bytes)
static void vl_api_get_node_index_t_handler(vl_api_get_node_index_t *mp)
char * vpe_api_get_version(void)
Return the image version string.
static u8 * format_nd_event(u8 *s, va_list *args)
Tell client about an IP4 ARP resolution event or MAC/IP info from ARP requests in L2 BDs...
void vl_set_api_pvt_heap_size(u64 size)
#define REPLY_MACRO3(t, n, body)
struct _vl_api_ip6_nd_event * nd_events
API main structure, used by both vpp and binary API clients.
IP Set the next node for a given node response.
Get node index using name request.
static void vl_api_add_node_next_t_handler(vl_api_add_node_next_t *mp)
An API client registration, only in vpp/vlib.
void vl_mem_api_enable_disable(vlib_main_t *vm, int yesno)
#define VLIB_EARLY_CONFIG_FUNCTION(x, n,...)
static u32 vl_api_string_len(vl_api_string_t *astr)
#define vec_free(V)
Free vector's memory (no header).
clib_error_t * vpe_api_init(vlib_main_t *vm)
static u8 * vl_api_from_api_string(vl_api_string_t *astr)
#define clib_warning(format, args...)
char * vpe_api_get_build_directory(void)
Return the image build directory name.
void vl_set_memory_gid(int gid)
static void inband_cli_output(uword arg, u8 *buffer, uword buffer_bytes)
static void vl_api_show_version_t_handler(vl_api_show_version_t *mp)
vlib_node_t * vlib_get_node_by_name(vlib_main_t *vm, u8 *name)
static vl_api_registration_t * vl_api_client_index_to_registration(u32 index)
#define VLIB_CLI_COMMAND(x,...)
static clib_error_t * show_ip_arp_nd_events_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
static void vl_api_cli_inband_t_handler(vl_api_cli_inband_t *mp)
static void setup_message_id_table(api_main_t *am)
Control ping from the client to the server response.
void vl_set_memory_region_name(const char *name)
Bitmaps built as vectors of machine words.
Set the next node for a given node request.
uword * next_slot_by_node
Query relative index via node names.
static void vl_api_show_threads_t_handler(vl_api_show_threads_t *mp)
VL_MSG_API_REAPER_FUNCTION(memclnt_delete_callback)
static vlib_main_t * vlib_get_main(void)
template key/value backing page structure
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
void * get_unformat_vnet_sw_interface(void)
static u8 * format_arp_event(u8 *s, va_list *args)
static void get_thread_data(vl_api_thread_data_t *td, int index)
vpe_api_main_t vpe_api_main
Tell client about an IP6 ND resolution or MAC/IP info from ICMP6 Neighbor Solicitation in L2 BDs...
static void vl_api_control_ping_t_handler(vl_api_control_ping_t *mp)
struct clib_bihash_value offset
template key/value backing page structure
char * vpe_api_get_build_date(void)
return the build date
void vl_set_api_memory_size(u64 size)
u8 * is_mp_safe
Message is mp safe vector.
#define clib_error_return_code(e, code, flags, args...)
u32 vl_msg_api_get_msg_length(void *msg_arg)
vlib_thread_registration_t * registration
static clib_error_t * vpe_api_hookup(vlib_main_t *vm)
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
#define foreach_registration_hash
CLIB vectors are ubiquitous dynamically resized arrays with by user defined "headers".
show_threads display the information about vpp threads running on system along with their process id...
static uword pool_elts(void *v)
Number of active elements in a pool.