X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvpp%2Fapi%2Fapi.c;h=2ed9ceec62cad2445524f058c932f72ab669aecb;hb=cbe25aab3be72154f2c706c39eeba6a77f34450f;hp=70b104234b77423d5f4c0bd9c36ad550835c18a7;hpb=e86a8edd3c14fb41ace2a12efd17bc7772bf623f;p=vpp.git diff --git a/src/vpp/api/api.c b/src/vpp/api/api.c index 70b104234b7..2ed9ceec62c 100644 --- a/src/vpp/api/api.c +++ b/src/vpp/api/api.c @@ -2,7 +2,7 @@ *------------------------------------------------------------------ * api.c - message handler registration * - * Copyright (c) 2010-2016 Cisco and/or its affiliates. + * Copyright (c) 2010-2018 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: @@ -48,6 +48,7 @@ #include #include +#include #include #include #include @@ -56,9 +57,10 @@ #undef BIHASH_TYPE #undef __included_bihash_template_h__ -#include +#include #include +#include #define vl_typedefs /* define message structures */ #include @@ -76,12 +78,17 @@ #define foreach_vpe_api_msg \ _(CONTROL_PING, control_ping) \ _(CLI, cli) \ -_(CLI_INBAND, cli_inband) \ +_(CLI_INBAND, cli_inband) \ _(GET_NODE_INDEX, get_node_index) \ -_(ADD_NODE_NEXT, add_node_next) \ -_(SHOW_VERSION, show_version) \ +_(ADD_NODE_NEXT, add_node_next) \ +_(SHOW_VERSION, show_version) \ +_(SHOW_THREADS, show_threads) \ _(GET_NODE_GRAPH, get_node_graph) \ _(GET_NEXT_INDEX, get_next_index) \ +_(LOG_DUMP, log_dump) \ +_(SHOW_VPE_SYSTEM_TIME, show_vpe_system_time) \ +_(GET_F64_ENDIAN_VALUE, get_f64_endian_value) \ +_(GET_F64_INCREMENT_BY_ONE, get_f64_increment_by_one) \ #define QUOTE_(x) #x #define QUOTE(x) QUOTE_(x) @@ -101,9 +108,6 @@ memclnt_delete_callback (u32 client_index) vpe_api_main_t *vam = &vpe_api_main; vpe_client_registration_t *rp; uword *p; - int stats_memclnt_delete_callback (u32 client_index); - - stats_memclnt_delete_callback (client_index); #define _(a) \ p = hash_get (vam->a##_registration_hash, client_index); \ @@ -139,22 +143,19 @@ shmem_cli_output (uword arg, u8 * buffer, uword buffer_bytes) u8 **shmem_vecp = (u8 **) arg; u8 *shmem_vec; void *oldheap; - api_main_t *am = &api_main; u32 offset; shmem_vec = *shmem_vecp; offset = vec_len (shmem_vec); - pthread_mutex_lock (&am->vlib_rp->mutex); - oldheap = svm_push_data_heap (am->vlib_rp); + oldheap = vl_msg_push_heap (); vec_validate (shmem_vec, offset + buffer_bytes - 1); clib_memcpy (shmem_vec + offset, buffer, buffer_bytes); - svm_pop_heap (oldheap); - pthread_mutex_unlock (&am->vlib_rp->mutex); + vl_msg_pop_heap (oldheap); *shmem_vecp = shmem_vec; } @@ -164,16 +165,15 @@ static void vl_api_cli_t_handler (vl_api_cli_t * mp) { vl_api_cli_reply_t *rp; - svm_queue_t *q; + vl_api_registration_t *reg; vlib_main_t *vm = vlib_get_main (); - api_main_t *am = &api_main; unformat_input_t input; u8 *shmem_vec = 0; void *oldheap; - q = vl_api_client_index_to_input_queue (mp->client_index); - if (!q) - return; + reg = vl_api_client_index_to_registration (mp->client_index); + if (!reg) + return;; rp = vl_msg_api_alloc (sizeof (*rp)); rp->_vl_msg_id = ntohs (VL_API_CLI_REPLY); @@ -183,17 +183,13 @@ vl_api_cli_t_handler (vl_api_cli_t * mp) vlib_cli_input (vm, &input, shmem_cli_output, (uword) & shmem_vec); - pthread_mutex_lock (&am->vlib_rp->mutex); - oldheap = svm_push_data_heap (am->vlib_rp); - + oldheap = vl_msg_push_heap (); vec_add1 (shmem_vec, 0); - - svm_pop_heap (oldheap); - pthread_mutex_unlock (&am->vlib_rp->mutex); + vl_msg_pop_heap (oldheap); rp->reply_in_shmem = (uword) shmem_vec; - vl_msg_api_send_shmem (q, (u8 *) & rp); + vl_api_send_msg (reg, (u8 *) rp); } static void @@ -216,16 +212,26 @@ vl_api_cli_inband_t_handler (vl_api_cli_inband_t * mp) vlib_main_t *vm = vlib_get_main (); unformat_input_t input; u8 *out_vec = 0; + u32 len = 0; + + if (vl_msg_api_get_msg_length (mp) < + vl_api_string_len (&mp->cmd) + sizeof (*mp)) + { + rv = -1; + goto error; + } - unformat_init_string (&input, (char *) mp->cmd, ntohl (mp->length)); - vlib_cli_input (vm, &input, inband_cli_output, (uword) & out_vec); + unformat_init_string (&input, (char *) vl_api_from_api_string (&mp->cmd), + vl_api_string_len (&mp->cmd)); + rv = vlib_cli_input (vm, &input, inband_cli_output, (uword) & out_vec); - u32 len = vec_len (out_vec); + len = vec_len (out_vec); + +error: /* *INDENT-OFF* */ REPLY_MACRO3(VL_API_CLI_INBAND_REPLY, len, ({ - rmp->length = htonl (len); - clib_memcpy (rmp->reply, out_vec, len); + vl_api_to_api_string(len, (const char *)out_vec, &rmp->reply); })); /* *INDENT-ON* */ vec_free (out_vec); @@ -254,6 +260,68 @@ vl_api_show_version_t_handler (vl_api_show_version_t * mp) /* *INDENT-ON* */ } +static void +get_thread_data (vl_api_thread_data_t * td, int index) +{ + vlib_worker_thread_t *w = vlib_worker_threads + index; + td->id = htonl (index); + if (w->name) + strncpy ((char *) td->name, (char *) w->name, ARRAY_LEN (td->name) - 1); + if (w->registration) + strncpy ((char *) td->type, (char *) w->registration->name, + ARRAY_LEN (td->type) - 1); + td->pid = htonl (w->lwp); + td->cpu_id = htonl (w->cpu_id); + td->core = htonl (w->core_id); + td->cpu_socket = htonl (w->socket_id); +} + +static void +vl_api_show_threads_t_handler (vl_api_show_threads_t * mp) +{ + int count = 0; + +#if !defined(__powerpc64__) + vl_api_registration_t *reg; + vl_api_show_threads_reply_t *rmp; + vl_api_thread_data_t *td; + int i, msg_size = 0; + count = vec_len (vlib_worker_threads); + if (!count) + return; + + msg_size = sizeof (*rmp) + sizeof (rmp->thread_data[0]) * count; + reg = vl_api_client_index_to_registration (mp->client_index); + if (!reg) + return; + + rmp = vl_msg_api_alloc (msg_size); + clib_memset (rmp, 0, msg_size); + rmp->_vl_msg_id = htons (VL_API_SHOW_THREADS_REPLY); + rmp->context = mp->context; + rmp->count = htonl (count); + td = rmp->thread_data; + + for (i = 0; i < count; i++) + { + get_thread_data (&td[i], i); + } + + vl_api_send_msg (reg, (u8 *) rmp); +#else + + /* unimplemented support */ + rv = -9; + clib_warning ("power pc does not support show threads api"); + /* *INDENT-OFF* */ + REPLY_MACRO2(VL_API_SHOW_THREADS_REPLY, + ({ + rmp->count = htonl(count); + })); + /* *INDENT-ON* */ +#endif +} + static void vl_api_get_node_index_t_handler (vl_api_get_node_index_t * mp) { @@ -363,14 +431,13 @@ vl_api_get_node_graph_t_handler (vl_api_get_node_graph_t * mp) { int rv = 0; u8 *vector = 0; - api_main_t *am = &api_main; vlib_main_t *vm = vlib_get_main (); void *oldheap; vl_api_get_node_graph_reply_t *rmp; - vlib_node_t ***node_dups; + static vlib_node_t ***node_dups; + static vlib_main_t **stat_vms; - pthread_mutex_lock (&am->vlib_rp->mutex); - oldheap = svm_push_data_heap (am->vlib_rp); + oldheap = vl_msg_push_heap (); /* * Keep the number of memcpy ops to a minimum (e.g. 1). @@ -378,14 +445,14 @@ vl_api_get_node_graph_t_handler (vl_api_get_node_graph_t * mp) vec_validate (vector, 16384); vec_reset_length (vector); - /* $$$$ FIXME */ - node_dups = vlib_node_get_nodes (vm, (u32) ~ 0 /* all threads */ , - 1 /* include stats */ ); + vlib_node_get_nodes (vm, 0 /* main threads */ , + 0 /* include stats */ , + 1 /* barrier sync */ , + &node_dups, &stat_vms); vector = vlib_node_serialize (vm, node_dups, vector, 1 /* include nexts */ , 1 /* include stats */ ); - svm_pop_heap (oldheap); - pthread_mutex_unlock (&am->vlib_rp->mutex); + vl_msg_pop_heap (oldheap); /* *INDENT-OFF* */ REPLY_MACRO2(VL_API_GET_NODE_GRAPH_REPLY, @@ -395,6 +462,116 @@ vl_api_get_node_graph_t_handler (vl_api_get_node_graph_t * mp) /* *INDENT-ON* */ } +static void +show_log_details (vl_api_registration_t * reg, u32 context, + f64 timestamp, + vl_api_log_level_t * level, u8 * msg_class, u8 * message) +{ + u32 msg_size; + + vl_api_log_details_t *rmp; + int class_len = + clib_min (vec_len (msg_class) + 1, ARRAY_LEN (rmp->msg_class)); + int message_len = + clib_min (vec_len (message) + 1, ARRAY_LEN (rmp->message)); + msg_size = sizeof (*rmp) + class_len + message_len; + + rmp = vl_msg_api_alloc (msg_size); + clib_memset (rmp, 0, msg_size); + rmp->_vl_msg_id = ntohs (VL_API_LOG_DETAILS); + + rmp->context = context; + rmp->timestamp = clib_host_to_net_f64 (timestamp); + rmp->level = htonl (*level); + + memcpy (rmp->msg_class, msg_class, class_len - 1); + memcpy (rmp->message, message, message_len - 1); + /* enforced by memset() above */ + ASSERT (0 == rmp->msg_class[class_len - 1]); + ASSERT (0 == rmp->message[message_len - 1]); + + vl_api_send_msg (reg, (u8 *) rmp); +} + +static void +vl_api_log_dump_t_handler (vl_api_log_dump_t * mp) +{ + + /* from log.c */ + vlib_log_main_t *lm = &log_main; + vlib_log_entry_t *e; + int i = last_log_entry (); + int count = lm->count; + f64 time_offset, start_time; + vl_api_registration_t *reg; + + reg = vl_api_client_index_to_registration (mp->client_index); + if (reg == 0) + return; + + start_time = clib_net_to_host_f64 (mp->start_timestamp); + + time_offset = (f64) lm->time_zero_timeval.tv_sec + + (((f64) lm->time_zero_timeval.tv_usec) * 1e-6) - lm->time_zero; + + while (count--) + { + e = vec_elt_at_index (lm->entries, i); + if (start_time <= e->timestamp + time_offset) + show_log_details (reg, mp->context, e->timestamp + time_offset, + (vl_api_log_level_t *) & e->level, + format (0, "%U", format_vlib_log_class, e->class), + e->string); + i = (i + 1) % lm->size; + } + +} + +static void +vl_api_show_vpe_system_time_t_handler (vl_api_show_vpe_system_time_t * mp) +{ + int rv = 0; + vl_api_show_vpe_system_time_reply_t *rmp; + /* *INDENT-OFF* */ + REPLY_MACRO2(VL_API_SHOW_VPE_SYSTEM_TIME_REPLY, + ({ + rmp->vpe_system_time = clib_host_to_net_f64 (unix_time_now ()); + })); + /* *INDENT-ON* */ +} + +static void +vl_api_get_f64_endian_value_t_handler (vl_api_get_f64_endian_value_t * mp) +{ + int rv = 0; + f64 one = 1.0; + vl_api_get_f64_endian_value_reply_t *rmp; + if (1.0 != clib_net_to_host_f64 (mp->f64_one)) + rv = VNET_API_ERROR_API_ENDIAN_FAILED; + + /* *INDENT-OFF* */ + REPLY_MACRO2(VL_API_GET_F64_ENDIAN_VALUE_REPLY, + ({ + rmp->f64_one_result = clib_host_to_net_f64 (one); + })); + /* *INDENT-ON* */ +} + +static void +vl_api_get_f64_increment_by_one_t_handler (vl_api_get_f64_increment_by_one_t * + mp) +{ + int rv = 0; + vl_api_get_f64_increment_by_one_reply_t *rmp; + + /* *INDENT-OFF* */ + REPLY_MACRO2(VL_API_GET_F64_INCREMENT_BY_ONE_REPLY, + ({ + rmp->f64_value = clib_host_to_net_f64 (clib_net_to_host_f64(mp->f64_value) + 1.0); + })); + /* *INDENT-ON* */ +} + #define BOUNCE_HANDLER(nn) \ static void vl_api_##nn##_t_handler ( \ vl_api_##nn##_t *mp) \ @@ -430,14 +607,14 @@ static void setup_message_id_table (api_main_t * am); /* * vpe_api_hookup * Add vpe's API message handlers to the table. - * vlib has alread mapped shared memory and + * vlib has already mapped shared memory and * added the client registration handlers. * See .../open-repo/vlib/memclnt_vlib.c:memclnt_process() */ static clib_error_t * vpe_api_hookup (vlib_main_t * vm) { - api_main_t *am = &api_main; + api_main_t *am = vlibapi_get_main (); #define _(N,n) \ vl_msg_api_set_handlers(VL_API_##N, #n, \ @@ -453,13 +630,15 @@ vpe_api_hookup (vlib_main_t * vm) * Trace space for classifier mask+match */ am->api_trace_cfg[VL_API_CLASSIFY_ADD_DEL_TABLE].size += 5 * sizeof (u32x4); - am->api_trace_cfg[VL_API_CLASSIFY_ADD_DEL_SESSION].size - += 5 * sizeof (u32x4); + am->api_trace_cfg[VL_API_CLASSIFY_ADD_DEL_SESSION].size += + 5 * sizeof (u32x4); /* * Thread-safe API messages */ - am->is_mp_safe[VL_API_IP_ADD_DEL_ROUTE] = 1; + am->is_mp_safe[VL_API_CONTROL_PING] = 1; + am->is_mp_safe[VL_API_CONTROL_PING_REPLY] = 1; + am->is_mp_safe[VL_API_IP_ROUTE_ADD_DEL] = 1; am->is_mp_safe[VL_API_GET_NODE_GRAPH] = 1; /* @@ -472,7 +651,7 @@ vpe_api_hookup (vlib_main_t * vm) VLIB_API_INIT_FUNCTION (vpe_api_hookup); -static clib_error_t * +clib_error_t * vpe_api_init (vlib_main_t * vm) { vpe_api_main_t *am = &vpe_api_main; @@ -490,9 +669,6 @@ vpe_api_init (vlib_main_t * vm) return 0; } -VLIB_INIT_FUNCTION (vpe_api_init); - - static clib_error_t * api_segment_config (vlib_main_t * vm, unformat_input_t * input) { @@ -576,7 +752,8 @@ api_segment_config (vlib_main_t * vm, unformat_input_t * input) /* lookup the group name */ grp = NULL; while (((rv = - getgrnam_r (s, &_grp, buf, vec_len (buf), &grp)) == ERANGE) + getgrnam_r (s, &_grp, buf, vec_len (buf), + &grp)) == ERANGE) && (vec_len (buf) <= max_buf_size)) { vec_resize (buf, vec_len (buf) * 2); @@ -617,78 +794,6 @@ get_unformat_vnet_sw_interface (void) return (void *) &unformat_vnet_sw_interface; } -static u8 * -format_arp_event (u8 * s, va_list * args) -{ - vl_api_ip4_arp_event_t *event = va_arg (*args, vl_api_ip4_arp_event_t *); - - s = format (s, "pid %d: ", ntohl (event->pid)); - s = format (s, "resolution for %U", format_ip4_address, &event->address); - return s; -} - -static u8 * -format_nd_event (u8 * s, va_list * args) -{ - vl_api_ip6_nd_event_t *event = va_arg (*args, vl_api_ip6_nd_event_t *); - - s = format (s, "pid %d: ", ntohl (event->pid)); - s = format (s, "resolution for %U", format_ip6_address, event->address); - return s; -} - -static clib_error_t * -show_ip_arp_nd_events_fn (vlib_main_t * vm, - unformat_input_t * input, vlib_cli_command_t * cmd) -{ - vpe_api_main_t *am = &vpe_api_main; - vl_api_ip4_arp_event_t *arp_event; - vl_api_ip6_nd_event_t *nd_event; - - if (pool_elts (am->arp_events) == 0 && pool_elts (am->nd_events) == 0 && - pool_elts (am->wc_ip4_arp_events_registrations) == 0 && - pool_elts (am->wc_ip6_nd_events_registrations) == 0) - { - vlib_cli_output (vm, "No active arp or nd event registrations"); - return 0; - } - - /* *INDENT-OFF* */ - pool_foreach (arp_event, am->arp_events, - ({ - vlib_cli_output (vm, "%U", format_arp_event, arp_event); - })); - - vpe_client_registration_t *reg; - pool_foreach(reg, am->wc_ip4_arp_events_registrations, - ({ - vlib_cli_output (vm, "pid %d: bd mac/ip4 binding events", - ntohl (reg->client_pid)); - })); - - pool_foreach (nd_event, am->nd_events, - ({ - vlib_cli_output (vm, "%U", format_nd_event, nd_event); - })); - - pool_foreach(reg, am->wc_ip6_nd_events_registrations, - ({ - vlib_cli_output (vm, "pid %d: bd mac/ip6 binding events", - ntohl (reg->client_pid)); - })); - /* *INDENT-ON* */ - - return 0; -} - -/* *INDENT-OFF* */ -VLIB_CLI_COMMAND (show_ip_arp_nd_events, static) = { - .path = "show arp-nd-event registrations", - .function = show_ip_arp_nd_events_fn, - .short_help = "Show ip4 arp and ip6 nd event registrations", -}; -/* *INDENT-ON* */ - #define vl_msg_name_crc_list #include #undef vl_msg_name_crc_list