diff options
| -rw-r--r-- | src/plugins/unittest/CMakeLists.txt | 4 | ||||
| -rw-r--r-- | src/plugins/unittest/api_test.c | 101 | ||||
| -rw-r--r-- | src/vlibapi/api_common.h | 2 | ||||
| -rw-r--r-- | src/vlibmemory/memclnt.api | 16 | ||||
| -rw-r--r-- | src/vlibmemory/memory_api.c | 89 | ||||
| -rw-r--r-- | src/vnet/interface_api.c | 28 | ||||
| -rw-r--r-- | src/vpp-api/vapi/vapi.c | 423 | ||||
| -rw-r--r-- | src/vpp-api/vapi/vapi.h | 48 | ||||
| -rw-r--r-- | test/test_api_client.py | 20 |
9 files changed, 673 insertions, 58 deletions
diff --git a/src/plugins/unittest/CMakeLists.txt b/src/plugins/unittest/CMakeLists.txt index 34e47fa24f4..faf55dfec2d 100644 --- a/src/plugins/unittest/CMakeLists.txt +++ b/src/plugins/unittest/CMakeLists.txt @@ -15,9 +15,10 @@ set(chacha20_poly1305) if (OPENSSL_VERSION VERSION_GREATER_EQUAL 1.1.0) set(chacha20_poly1305 crypto/chacha20_poly1305.c) endif() - +include_directories(${CMAKE_SOURCE_DIR}/vpp-api ${CMAKE_CURRENT_BINARY_DIR}/../../vpp-api) add_vpp_plugin(unittest SOURCES + api_test.c api_fuzz_test.c bier_test.c bihash_test.c @@ -60,4 +61,5 @@ add_vpp_plugin(unittest COMPONENT vpp-plugin-devtools + LINK_LIBRARIES vapiclient ) diff --git a/src/plugins/unittest/api_test.c b/src/plugins/unittest/api_test.c new file mode 100644 index 00000000000..4bed50c2969 --- /dev/null +++ b/src/plugins/unittest/api_test.c @@ -0,0 +1,101 @@ +/* SPDX-License-Identifier: Apache-2.0 + * Copyright(c) 2022 Cisco Systems, Inc. + */ + +#include <vnet/vnet.h> +#include <vnet/plugin/plugin.h> + +#include <vlibapi/api.h> +#include <vlibmemory/api.h> +#include <vpp/app/version.h> +#include <stdbool.h> +#include <vapi/vapi.h> + +#include <vapi/memclnt.api.vapi.h> +#include <vapi/vlib.api.vapi.h> +#include <vapi/vpe.api.vapi.h> + +/* + * Example of how to call the VPP binary API from an internal API client. + * Using the VAPI C language binding. + */ + +DEFINE_VAPI_MSG_IDS_VPE_API_JSON; + +/* + * Connect an VPP binary API client to VPP API + */ +static vapi_ctx_t +connect_to_vpp (void) +{ + vapi_ctx_t ctx; + if (vapi_ctx_alloc (&ctx) != VAPI_OK) + { + clib_warning ("ctx_alloc failed"); + return 0; + } + if (vapi_connect_from_vpp (ctx, "apifromplugin", 64, 32, VAPI_MODE_BLOCKING, + true) != VAPI_OK) + { + clib_warning ("vapi_connect failed"); + return 0; + } + return ctx; +} + +/* + * Gets called when the show_version_reply message is received + */ +vapi_error_e +show_version_cb (vapi_ctx_t ctx, void *caller_ctx, vapi_error_e rv, + bool is_last, vapi_payload_show_version_reply *p) +{ + if (rv != VAPI_OK) + clib_warning ("Return value: %d", rv); + fformat ( + stdout, + "show_version_reply: program: `%s', version: `%s', build directory: " + "`%s', build date: `%s'\n", + p->program, p->version, p->build_directory, p->build_date); + return VAPI_OK; +} + +static void * +api_show_version_blocking_fn (void *args) +{ + vapi_ctx_t ctx; + + if ((ctx = connect_to_vpp ()) == 0) + return clib_error_return (0, "API connection failed"); + + int called; + vapi_msg_show_version *sv = vapi_alloc_show_version (ctx); + vapi_error_e vapi_rv = vapi_show_version (ctx, sv, show_version_cb, &called); + if (vapi_rv != VAPI_OK) + clib_warning ("call failed"); + + vapi_disconnect_from_vpp (ctx); + vapi_ctx_free (ctx); + + return 0; +} + +static clib_error_t * +test_api_test_command_fn (vlib_main_t *vm, unformat_input_t *input, + vlib_cli_command_t *cmd) +{ + /* Run call in a pthread */ + pthread_t thread; + int rv = pthread_create (&thread, NULL, api_show_version_blocking_fn, 0); + if (rv) + { + return clib_error_return (0, "API call failed"); + } + return 0; +} + +VLIB_CLI_COMMAND (test_api_command, static) = { + .path = "test api internal", + .short_help = "test internal api client", + .function = test_api_test_command_fn, +}; diff --git a/src/vlibapi/api_common.h b/src/vlibapi/api_common.h index 4c48b003e1e..491ecb8eaef 100644 --- a/src/vlibapi/api_common.h +++ b/src/vlibapi/api_common.h @@ -75,6 +75,8 @@ typedef struct vl_api_registration_ /* socket client only */ u32 server_handle; /**< Socket client only: server handle */ u32 server_index; /**< Socket client only: server index */ + + bool keepalive; /**< Dead client scan */ } vl_api_registration_t; #define VL_API_INVALID_FI ((u32)~0) diff --git a/src/vlibmemory/memclnt.api b/src/vlibmemory/memclnt.api index bd999b51dd0..0532f1734bf 100644 --- a/src/vlibmemory/memclnt.api +++ b/src/vlibmemory/memclnt.api @@ -232,3 +232,19 @@ define control_ping_reply u32 vpe_pid; }; +define memclnt_create_v2 { + u32 context; /* opaque value to be returned in the reply */ + i32 ctx_quota; /* requested punt context quota */ + u64 input_queue; /* client's queue */ + string name[64]; /* for show, find by name, whatever */ + u32 api_versions[8]; /* client-server pairs use as desired */ + bool keepalive[default=true]; /* dead client scan keepalives */ +}; + +define memclnt_create_v2_reply { + u32 context; /* opaque value from the create request */ + i32 response; /* Non-negative = success */ + u64 handle; /* handle by which vlib knows this client */ + u32 index; /* index, used e.g. by API trace replay */ + u64 message_table; /* serialized message table in shmem */ +}; diff --git a/src/vlibmemory/memory_api.c b/src/vlibmemory/memory_api.c index a16110f2fa1..b1d250b8a5f 100644 --- a/src/vlibmemory/memory_api.c +++ b/src/vlibmemory/memory_api.c @@ -192,6 +192,7 @@ vl_api_memclnt_create_t_handler (vl_api_memclnt_create_t * mp) regp->name = format (0, "%s", mp->name); vec_add1 (regp->name, 0); + regp->keepalive = true; if (am->serialized_message_table_in_shmem == 0) am->serialized_message_table_in_shmem = @@ -218,6 +219,87 @@ vl_api_memclnt_create_t_handler (vl_api_memclnt_create_t * mp) } void +vl_api_memclnt_create_v2_t_handler (vl_api_memclnt_create_v2_t *mp) +{ + vl_api_registration_t **regpp; + vl_api_registration_t *regp; + vl_api_memclnt_create_v2_reply_t *rp; + svm_queue_t *q; + int rv = 0; + void *oldheap; + api_main_t *am = vlibapi_get_main (); + u8 *msg_table; + + /* + * 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); + + oldheap = vl_msg_push_heap (); + *regpp = clib_mem_alloc (sizeof (vl_api_registration_t)); + + regp = *regpp; + clib_memset (regp, 0, sizeof (*regp)); + regp->registration_type = REGISTRATION_TYPE_SHMEM; + regp->vl_api_registration_pool_index = regpp - am->vl_clients; + regp->vlib_rp = am->vlib_rp; + regp->shmem_hdr = am->shmem_hdr; + regp->clib_file_index = am->shmem_hdr->clib_file_index; + + q = regp->vl_input_queue = (svm_queue_t *) (uword) mp->input_queue; + VL_MSG_API_SVM_QUEUE_UNPOISON (q); + + regp->name = format (0, "%s", mp->name); + vec_add1 (regp->name, 0); + regp->keepalive = mp->keepalive; + + if (am->serialized_message_table_in_shmem == 0) + am->serialized_message_table_in_shmem = + vl_api_serialize_message_table (am, 0); + + if (am->vlib_rp != am->vlib_primary_rp) + msg_table = vl_api_serialize_message_table (am, 0); + else + msg_table = am->serialized_message_table_in_shmem; + + vl_msg_pop_heap (oldheap); + + rp = vl_msg_api_alloc (sizeof (*rp)); + rp->_vl_msg_id = ntohs (VL_API_MEMCLNT_CREATE_V2_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); + rp->message_table = pointer_to_uword (msg_table); + + vl_msg_api_send_shmem (q, (u8 *) &rp); +} + +void vl_api_call_reaper_functions (u32 client_index) { clib_error_t *error = 0; @@ -399,6 +481,7 @@ vl_api_memclnt_keepalive_t_handler (vl_api_memclnt_keepalive_t * mp) #define foreach_vlib_api_msg \ _ (MEMCLNT_CREATE, memclnt_create, 0) \ + _ (MEMCLNT_CREATE_V2, memclnt_create_v2, 0) \ _ (MEMCLNT_DELETE, memclnt_delete, 0) \ _ (MEMCLNT_KEEPALIVE, memclnt_keepalive, 0) \ _ (MEMCLNT_KEEPALIVE_REPLY, memclnt_keepalive_reply, 0) @@ -578,8 +661,10 @@ vl_mem_api_dead_client_scan (api_main_t * am, vl_shmem_hdr_t * shm, f64 now) /* *INDENT-OFF* */ pool_foreach (regpp, am->vl_clients) { + if (!(*regpp)->keepalive) + continue; vl_mem_send_client_keepalive_w_reg (am, now, regpp, &dead_indices, - &confused_indices); + &confused_indices); } /* *INDENT-ON* */ @@ -944,7 +1029,7 @@ vl_api_client_index_to_input_queue (u32 index) static clib_error_t * setup_memclnt_exit (vlib_main_t * vm) { - atexit (vl_unmap_shmem); + atexit (vl_unmap_shmem_client); return 0; } diff --git a/src/vnet/interface_api.c b/src/vnet/interface_api.c index 00a1ce3a599..29f98f7851f 100644 --- a/src/vnet/interface_api.c +++ b/src/vnet/interface_api.c @@ -1624,23 +1624,27 @@ interface_api_hookup (vlib_main_t * vm) { api_main_t *am = vlibapi_get_main (); + /* + * Set up the (msg_name, crc, message-id) table + */ + REPLY_MSG_ID_BASE = setup_message_id_table (); + /* Mark these APIs as mp safe */ - am->is_mp_safe[VL_API_SW_INTERFACE_DUMP] = 1; - am->is_mp_safe[VL_API_SW_INTERFACE_DETAILS] = 1; - am->is_mp_safe[VL_API_SW_INTERFACE_TAG_ADD_DEL] = 1; - am->is_mp_safe[VL_API_SW_INTERFACE_SET_INTERFACE_NAME] = 1; + am->is_mp_safe[REPLY_MSG_ID_BASE + VL_API_SW_INTERFACE_DUMP] = 1; + am->is_mp_safe[REPLY_MSG_ID_BASE + VL_API_SW_INTERFACE_DETAILS] = 1; + am->is_mp_safe[REPLY_MSG_ID_BASE + VL_API_SW_INTERFACE_TAG_ADD_DEL] = 1; + am->is_mp_safe[REPLY_MSG_ID_BASE + VL_API_SW_INTERFACE_SET_INTERFACE_NAME] = + 1; /* Do not replay VL_API_SW_INTERFACE_DUMP messages */ - am->api_trace_cfg[VL_API_SW_INTERFACE_DUMP].replay_enable = 0; + am->api_trace_cfg[REPLY_MSG_ID_BASE + VL_API_SW_INTERFACE_DUMP] + .replay_enable = 0; /* Mark these APIs as autoendian */ - am->is_autoendian[VL_API_SW_INTERFACE_SET_TX_PLACEMENT] = 1; - am->is_autoendian[VL_API_SW_INTERFACE_TX_PLACEMENT_GET] = 1; - - /* - * Set up the (msg_name, crc, message-id) table - */ - REPLY_MSG_ID_BASE = setup_message_id_table (); + am->is_autoendian[REPLY_MSG_ID_BASE + VL_API_SW_INTERFACE_SET_TX_PLACEMENT] = + 1; + am->is_autoendian[REPLY_MSG_ID_BASE + VL_API_SW_INTERFACE_TX_PLACEMENT_GET] = + 1; return 0; } diff --git a/src/vpp-api/vapi/vapi.c b/src/vpp-api/vapi/vapi.c index ca46f8d3b84..7808bec8521 100644 --- a/src/vpp-api/vapi/vapi.c +++ b/src/vpp-api/vapi/vapi.c @@ -30,10 +30,18 @@ #include <vlib/vlib.h> #include <vlibapi/api_common.h> #include <vlibmemory/memory_client.h> +#include <vlibmemory/memory_api.h> +#include <vlibmemory/api.h> #include <vapi/memclnt.api.vapi.h> #include <vapi/vlib.api.vapi.h> +#include <vlibmemory/vl_memory_msg_enum.h> + +#define vl_typedefs /* define message structures */ +#include <vlibmemory/vl_memory_api_h.h> +#undef vl_typedefs + /* we need to use control pings for some stuff and because we're forced to put * the code in headers, we need a way to be able to grab the ids of these * messages - so declare them here as extern */ @@ -89,6 +97,11 @@ struct vapi_ctx_s bool connected; bool handle_keepalives; pthread_mutex_t requests_mutex; + + svm_queue_t *vl_input_queue; + u32 my_client_index; + /** client message index hash table */ + uword *msg_index_by_name_and_crc; }; u32 @@ -221,7 +234,7 @@ vapi_msg_alloc (vapi_ctx_t ctx, size_t size) { return NULL; } - void *rv = vl_msg_api_alloc_or_null (size); + void *rv = vl_msg_api_alloc_as_if_client_or_null (size); if (rv) { clib_memset (rv, 0, size); @@ -302,13 +315,174 @@ vapi_is_msg_available (vapi_ctx_t ctx, vapi_msg_id_t id) return vapi_lookup_vl_msg_id (ctx, id) != UINT16_MAX; } +/* Cut and paste to avoid adding dependency to client library */ +__clib_nosanitize_addr static void +VL_API_VEC_UNPOISON (const void *v) +{ + const vec_header_t *vh = &((vec_header_t *) v)[-1]; + clib_mem_unpoison (vh, sizeof (*vh) + vec_len (v)); +} + +static void +vapi_api_name_and_crc_free (vapi_ctx_t ctx) +{ + int i; + u8 **keys = 0; + hash_pair_t *hp; + + if (!ctx->msg_index_by_name_and_crc) + return; + hash_foreach_pair (hp, ctx->msg_index_by_name_and_crc, + ({ vec_add1 (keys, (u8 *) hp->key); })); + for (i = 0; i < vec_len (keys); i++) + vec_free (keys[i]); + vec_free (keys); + hash_free (ctx->msg_index_by_name_and_crc); +} + +static void +vapi_memclnt_create_v2_reply_t_handler (vapi_ctx_t ctx, + vl_api_memclnt_create_v2_reply_t *mp) +{ + serialize_main_t _sm, *sm = &_sm; + u8 *tblv; + u32 nmsgs; + int i; + u8 *name_and_crc; + u32 msg_index; + + ctx->my_client_index = mp->index; + + /* Clean out any previous hash table (unlikely) */ + vapi_api_name_and_crc_free (ctx); + + ctx->msg_index_by_name_and_crc = hash_create_string (0, sizeof (uword)); + + /* Recreate the vnet-side API message handler table */ + tblv = uword_to_pointer (mp->message_table, u8 *); + unserialize_open_data (sm, tblv, vec_len (tblv)); + unserialize_integer (sm, &nmsgs, sizeof (u32)); + + VL_API_VEC_UNPOISON (tblv); + + for (i = 0; i < nmsgs; i++) + { + msg_index = unserialize_likely_small_unsigned_integer (sm); + unserialize_cstring (sm, (char **) &name_and_crc); + hash_set_mem (ctx->msg_index_by_name_and_crc, name_and_crc, msg_index); + } +} + +static void +vapi_memclnt_delete_reply_t_handler (vapi_ctx_t ctx, + vl_api_memclnt_delete_reply_t *mp) +{ + void *oldheap; + oldheap = vl_msg_push_heap (); + svm_queue_free (ctx->vl_input_queue); + vl_msg_pop_heap (oldheap); + + ctx->my_client_index = ~0; + ctx->vl_input_queue = 0; +} + +int +vapi_client_connect (vapi_ctx_t ctx, const char *name, int ctx_quota, + int input_queue_size, bool keepalive) +{ + vl_api_memclnt_create_v2_t *mp; + vl_api_memclnt_create_v2_reply_t *rp; + svm_queue_t *vl_input_queue; + vl_shmem_hdr_t *shmem_hdr; + int rv = 0; + void *oldheap; + api_main_t *am = vlibapi_get_main (); + + shmem_hdr = am->shmem_hdr; + + if (shmem_hdr == 0 || shmem_hdr->vl_input_queue == 0) + { + clib_warning ("shmem_hdr / input queue NULL"); + return -1; + } + + clib_mem_unpoison (shmem_hdr, sizeof (*shmem_hdr)); + VL_MSG_API_SVM_QUEUE_UNPOISON (shmem_hdr->vl_input_queue); + + oldheap = vl_msg_push_heap (); + vl_input_queue = + svm_queue_alloc_and_init (input_queue_size, sizeof (uword), getpid ()); + vl_msg_pop_heap (oldheap); + + ctx->my_client_index = ~0; + ctx->vl_input_queue = vl_input_queue; + + mp = vl_msg_api_alloc_as_if_client (sizeof (vl_api_memclnt_create_v2_t)); + clib_memset (mp, 0, sizeof (*mp)); + mp->_vl_msg_id = ntohs (VL_API_MEMCLNT_CREATE_V2); + mp->ctx_quota = ctx_quota; + mp->input_queue = (uword) vl_input_queue; + strncpy ((char *) mp->name, name, sizeof (mp->name) - 1); + mp->keepalive = keepalive; + + vl_msg_api_send_shmem (shmem_hdr->vl_input_queue, (u8 *) &mp); + + while (1) + { + int qstatus; + struct timespec ts, tsrem; + int i; + + /* Wait up to 10 seconds */ + for (i = 0; i < 1000; i++) + { + qstatus = + svm_queue_sub (vl_input_queue, (u8 *) &rp, SVM_Q_NOWAIT, 0); + if (qstatus == 0) + goto read_one_msg; + ts.tv_sec = 0; + ts.tv_nsec = 10000 * 1000; /* 10 ms */ + while (nanosleep (&ts, &tsrem) < 0) + ts = tsrem; + } + /* Timeout... */ + return -1; + + read_one_msg: + VL_MSG_API_UNPOISON (rp); + if (ntohs (rp->_vl_msg_id) != VL_API_MEMCLNT_CREATE_V2_REPLY) + { + clib_warning ("unexpected reply: id %d", ntohs (rp->_vl_msg_id)); + continue; + } + rv = clib_net_to_host_u32 (rp->response); + vapi_memclnt_create_v2_reply_t_handler (ctx, rp); + break; + } + return (rv); +} + +u32 +vapi_api_get_msg_index (vapi_ctx_t ctx, u8 *name_and_crc) +{ + uword *p; + + if (ctx->msg_index_by_name_and_crc) + { + p = hash_get_mem (ctx->msg_index_by_name_and_crc, name_and_crc); + if (p) + return p[0]; + } + return ~0; +} + vapi_error_e -vapi_connect (vapi_ctx_t ctx, const char *name, - const char *chroot_prefix, - int max_outstanding_requests, - int response_queue_size, vapi_mode_e mode, - bool handle_keepalives) +vapi_connect (vapi_ctx_t ctx, const char *name, const char *chroot_prefix, + int max_outstanding_requests, int response_queue_size, + vapi_mode_e mode, bool handle_keepalives) { + int rv; + if (response_queue_size <= 0 || max_outstanding_requests <= 0) { return VAPI_EINVAL; @@ -317,6 +491,7 @@ vapi_connect (vapi_ctx_t ctx, const char *name, { return VAPI_ENOMEM; } + ctx->requests_size = max_outstanding_requests; const size_t size = ctx->requests_size * sizeof (*ctx->requests); void *tmp = realloc (ctx->requests, size); @@ -328,6 +503,7 @@ vapi_connect (vapi_ctx_t ctx, const char *name, clib_memset (ctx->requests, 0, size); /* coverity[MISSING_LOCK] - 177211 requests_mutex is not needed here */ ctx->requests_start = ctx->requests_count = 0; + if (chroot_prefix) { VAPI_DBG ("set memory root path `%s'", chroot_prefix); @@ -335,12 +511,13 @@ vapi_connect (vapi_ctx_t ctx, const char *name, } static char api_map[] = "/vpe-api"; VAPI_DBG ("client api map `%s'", api_map); - if ((vl_client_api_map (api_map)) < 0) + if ((rv = vl_map_shmem (api_map, 0 /* is_vlib */)) < 0) { return VAPI_EMAP_FAIL; } VAPI_DBG ("connect client `%s'", name); - if (vl_client_connect ((char *) name, 0, response_queue_size) < 0) + if (vapi_client_connect (ctx, (char *) name, 0, response_queue_size, true) < + 0) { vl_client_api_unmap (); return VAPI_ECON_FAIL; @@ -348,14 +525,15 @@ vapi_connect (vapi_ctx_t ctx, const char *name, #if VAPI_DEBUG_CONNECT VAPI_DBG ("start probing messages"); #endif - int rv; + int i; for (i = 0; i < __vapi_metadata.count; ++i) { vapi_message_desc_t *m = __vapi_metadata.msgs[i]; u8 scratch[m->name_with_crc_len + 1]; memcpy (scratch, m->name_with_crc, m->name_with_crc_len + 1); - u32 id = vl_msg_api_get_msg_index (scratch); + u32 id = vapi_api_get_msg_index (ctx, scratch); + if (VAPI_INVALID_MSG_ID != id) { if (id > UINT16_MAX) @@ -367,10 +545,9 @@ vapi_connect (vapi_ctx_t ctx, const char *name, } if (id > ctx->vl_msg_id_max) { - vapi_msg_id_t *tmp = realloc (ctx->vl_msg_id_to_vapi_msg_t, - sizeof - (*ctx->vl_msg_id_to_vapi_msg_t) * - (id + 1)); + vapi_msg_id_t *tmp = + realloc (ctx->vl_msg_id_to_vapi_msg_t, + sizeof (*ctx->vl_msg_id_to_vapi_msg_t) * (id + 1)); if (!tmp) { rv = VAPI_ENOMEM; @@ -398,8 +575,8 @@ vapi_connect (vapi_ctx_t ctx, const char *name, if (!vapi_is_msg_available (ctx, vapi_msg_id_control_ping) || !vapi_is_msg_available (ctx, vapi_msg_id_control_ping_reply)) { - VAPI_ERR - ("control ping or control ping reply not available, cannot connect"); + VAPI_ERR ( + "control ping or control ping reply not available, cannot connect"); rv = VAPI_EINCOMPATIBLE; goto fail; } @@ -420,6 +597,157 @@ fail: return rv; } +/* + * API client running in the same process as VPP + */ +vapi_error_e +vapi_connect_from_vpp (vapi_ctx_t ctx, const char *name, + int max_outstanding_requests, int response_queue_size, + vapi_mode_e mode, bool handle_keepalives) +{ + int rv; + + if (response_queue_size <= 0 || max_outstanding_requests <= 0) + { + return VAPI_EINVAL; + } + + ctx->requests_size = max_outstanding_requests; + const size_t size = ctx->requests_size * sizeof (*ctx->requests); + void *tmp = realloc (ctx->requests, size); + if (!tmp) + { + return VAPI_ENOMEM; + } + ctx->requests = tmp; + clib_memset (ctx->requests, 0, size); + /* coverity[MISSING_LOCK] - 177211 requests_mutex is not needed here */ + ctx->requests_start = ctx->requests_count = 0; + + VAPI_DBG ("connect client `%s'", name); + if (vapi_client_connect (ctx, (char *) name, 0, response_queue_size, + handle_keepalives) < 0) + { + return VAPI_ECON_FAIL; + } + + int i; + for (i = 0; i < __vapi_metadata.count; ++i) + { + vapi_message_desc_t *m = __vapi_metadata.msgs[i]; + u8 scratch[m->name_with_crc_len + 1]; + memcpy (scratch, m->name_with_crc, m->name_with_crc_len + 1); + u32 id = vapi_api_get_msg_index (ctx, scratch); + if (VAPI_INVALID_MSG_ID != id) + { + if (id > UINT16_MAX) + { + VAPI_ERR ("Returned vl_msg_id `%u' > UINT16MAX `%u'!", id, + UINT16_MAX); + rv = VAPI_EINVAL; + goto fail; + } + if (id > ctx->vl_msg_id_max) + { + vapi_msg_id_t *tmp = + realloc (ctx->vl_msg_id_to_vapi_msg_t, + sizeof (*ctx->vl_msg_id_to_vapi_msg_t) * (id + 1)); + if (!tmp) + { + rv = VAPI_ENOMEM; + goto fail; + } + ctx->vl_msg_id_to_vapi_msg_t = tmp; + ctx->vl_msg_id_max = id; + } + ctx->vl_msg_id_to_vapi_msg_t[id] = m->id; + ctx->vapi_msg_id_t_to_vl_msg_id[m->id] = id; + } + else + { + ctx->vapi_msg_id_t_to_vl_msg_id[m->id] = UINT16_MAX; + VAPI_DBG ("Message `%s' not available", m->name_with_crc); + } + } + if (!vapi_is_msg_available (ctx, vapi_msg_id_control_ping) || + !vapi_is_msg_available (ctx, vapi_msg_id_control_ping_reply)) + { + VAPI_ERR ( + "control ping or control ping reply not available, cannot connect"); + rv = VAPI_EINCOMPATIBLE; + goto fail; + } + ctx->mode = mode; + ctx->connected = true; + if (vapi_is_msg_available (ctx, vapi_msg_id_memclnt_keepalive)) + { + ctx->handle_keepalives = handle_keepalives; + } + else + { + ctx->handle_keepalives = false; + } + return VAPI_OK; +fail: + vl_client_disconnect (); + return rv; +} + +vapi_error_e +vapi_disconnect_from_vpp (vapi_ctx_t ctx) +{ + if (!ctx->connected) + { + return VAPI_EINVAL; + } + vl_api_memclnt_delete_reply_t *rp; + svm_queue_t *vl_input_queue; + time_t begin; + vl_input_queue = ctx->vl_input_queue; + vl_client_send_disconnect (0 /* wait for reply */); + + /* + * Have to be careful here, in case the client is disconnecting + * because e.g. the vlib process died, or is unresponsive. + */ + begin = time (0); + vapi_error_e rv = VAPI_OK; + while (1) + { + time_t now; + + now = time (0); + + if (now >= (begin + 2)) + { + clib_warning ("peer unresponsive, give up"); + ctx->my_client_index = ~0; + rv = VAPI_ENORESP; + goto fail; + } + if (svm_queue_sub (vl_input_queue, (u8 *) &rp, SVM_Q_NOWAIT, 0) < 0) + continue; + + VL_MSG_API_UNPOISON (rp); + + /* drain the queue */ + if (ntohs (rp->_vl_msg_id) != VL_API_MEMCLNT_DELETE_REPLY) + { + clib_warning ("queue drain: %d", ntohs (rp->_vl_msg_id)); + vl_msg_api_free (rp); + continue; + } + vapi_memclnt_delete_reply_t_handler ( + ctx, (void *) rp /*, ntohl (msgbuf->data_len)*/); + break; + } +fail: + vapi_api_name_and_crc_free (ctx); + + ctx->connected = false; + return rv; +} + vapi_error_e vapi_disconnect (vapi_ctx_t ctx) { @@ -427,13 +755,57 @@ vapi_disconnect (vapi_ctx_t ctx) { return VAPI_EINVAL; } - vl_client_disconnect (); + + vl_api_memclnt_delete_reply_t *rp; + svm_queue_t *vl_input_queue; + time_t begin; + vl_input_queue = ctx->vl_input_queue; + vl_client_send_disconnect (0 /* wait for reply */); + + /* + * Have to be careful here, in case the client is disconnecting + * because e.g. the vlib process died, or is unresponsive. + */ + begin = time (0); + vapi_error_e rv = VAPI_OK; + while (1) + { + time_t now; + + now = time (0); + + if (now >= (begin + 2)) + { + clib_warning ("peer unresponsive, give up"); + ctx->my_client_index = ~0; + rv = VAPI_ENORESP; + goto fail; + } + if (svm_queue_sub (vl_input_queue, (u8 *) &rp, SVM_Q_NOWAIT, 0) < 0) + continue; + + VL_MSG_API_UNPOISON (rp); + + /* drain the queue */ + if (ntohs (rp->_vl_msg_id) != VL_API_MEMCLNT_DELETE_REPLY) + { + clib_warning ("queue drain: %d", ntohs (rp->_vl_msg_id)); + vl_msg_api_free (rp); + continue; + } + vapi_memclnt_delete_reply_t_handler ( + ctx, (void *) rp /*, ntohl (msgbuf->data_len)*/); + break; + } +fail: + vapi_api_name_and_crc_free (ctx); + vl_client_api_unmap (); #if VAPI_DEBUG_ALLOC vapi_to_be_freed_validate (); #endif ctx->connected = false; - return VAPI_OK; + return rv; } vapi_error_e @@ -541,15 +913,10 @@ vapi_recv (vapi_ctx_t ctx, void **msg, size_t * msg_size, return VAPI_EINVAL; } vapi_error_e rv = VAPI_OK; - api_main_t *am = vlibapi_get_main (); uword data; - if (am->our_pid == 0) - { - return VAPI_EINVAL; - } + svm_queue_t *q = ctx->vl_input_queue; - svm_queue_t *q = am->vl_input_queue; again: VAPI_DBG ("doing shm queue sub"); @@ -610,7 +977,6 @@ again: vapi_msg_memclnt_keepalive_reply_hton (reply); while (VAPI_EAGAIN == vapi_send (ctx, reply)); vapi_msg_free (ctx, *msg); - VAPI_DBG ("autohandled memclnt_keepalive"); goto again; } } @@ -689,9 +1055,8 @@ vapi_dispatch_response (vapi_ctx_t ctx, vapi_msg_id_t id, } if (payload_offset != -1) { - rv = - ctx->requests[tmp].callback (ctx, ctx->requests[tmp].callback_ctx, - VAPI_OK, is_last, payload); + rv = ctx->requests[tmp].callback ( + ctx, ctx->requests[tmp].callback_ctx, VAPI_OK, is_last, payload); } else { @@ -870,7 +1235,7 @@ vapi_lookup_vl_msg_id (vapi_ctx_t ctx, vapi_msg_id_t id) int vapi_get_client_index (vapi_ctx_t ctx) { - return vlibapi_get_main ()->my_client_index; + return ctx->my_client_index; } bool diff --git a/src/vpp-api/vapi/vapi.h b/src/vpp-api/vapi/vapi.h index 08d016b0dd7..46666293e4b 100644 --- a/src/vpp-api/vapi/vapi.h +++ b/src/vpp-api/vapi/vapi.h @@ -44,7 +44,7 @@ extern "C" * process). It's not recommended to mix the higher and lower level APIs. Due * to version issues, the higher-level APIs are not part of the shared library. */ - typedef struct vapi_ctx_s *vapi_ctx_t; +typedef struct vapi_ctx_s *vapi_ctx_t; /** * @brief allocate vapi message of given size @@ -56,7 +56,7 @@ extern "C" * * @return pointer to message or NULL if out of memory */ - void *vapi_msg_alloc (vapi_ctx_t ctx, size_t size); +void *vapi_msg_alloc (vapi_ctx_t ctx, size_t size); /** * @brief free a vapi message @@ -66,7 +66,7 @@ extern "C" * @param ctx opaque vapi context * @param msg message to be freed */ - void vapi_msg_free (vapi_ctx_t ctx, void *msg); +void vapi_msg_free (vapi_ctx_t ctx, void *msg); /** * @brief allocate vapi context @@ -75,18 +75,18 @@ extern "C" * * @return VAPI_OK on success, other error code on error */ - vapi_error_e vapi_ctx_alloc (vapi_ctx_t * result); +vapi_error_e vapi_ctx_alloc (vapi_ctx_t *result); /** * @brief free vapi context */ - void vapi_ctx_free (vapi_ctx_t ctx); +void vapi_ctx_free (vapi_ctx_t ctx); /** * @brief check if message identified by it's message id is known by the vpp to * which the connection is open */ - bool vapi_is_msg_available (vapi_ctx_t ctx, vapi_msg_id_t type); +bool vapi_is_msg_available (vapi_ctx_t ctx, vapi_msg_id_t type); /** * @brief connect to vpp @@ -101,11 +101,30 @@ extern "C" * * @return VAPI_OK on success, other error code on error */ - vapi_error_e vapi_connect (vapi_ctx_t ctx, const char *name, - const char *chroot_prefix, - int max_outstanding_requests, - int response_queue_size, vapi_mode_e mode, - bool handle_keepalives); +vapi_error_e vapi_connect (vapi_ctx_t ctx, const char *name, + const char *chroot_prefix, + int max_outstanding_requests, + int response_queue_size, vapi_mode_e mode, + bool handle_keepalives); + +/** + * @brief connect to vpp from a client in same process + * @remark This MUST be called from a separate thread. If called + * from the main thread, it will deadlock. + * + * @param ctx opaque vapi context, must be allocated using vapi_ctx_alloc first + * @param name application name + * @param max_outstanding_requests max number of outstanding requests queued + * @param response_queue_size size of the response queue + * @param mode mode of operation - blocking or nonblocking + * @param handle_keepalives - if true, automatically handle memclnt_keepalive + * + * @return VAPI_OK on success, other error code on error + */ +vapi_error_e vapi_connect_from_vpp (vapi_ctx_t ctx, const char *name, + int max_outstanding_requests, + int response_queue_size, vapi_mode_e mode, + bool handle_keepalives); /** * @brief disconnect from vpp @@ -114,7 +133,8 @@ extern "C" * * @return VAPI_OK on success, other error code on error */ - vapi_error_e vapi_disconnect (vapi_ctx_t ctx); +vapi_error_e vapi_disconnect (vapi_ctx_t ctx); +vapi_error_e vapi_disconnect_from_vpp (vapi_ctx_t ctx); /** * @brief get event file descriptor @@ -127,7 +147,7 @@ extern "C" * * @return VAPI_OK on success, other error code on error */ - vapi_error_e vapi_get_fd (vapi_ctx_t ctx, int *fd); +vapi_error_e vapi_get_fd (vapi_ctx_t ctx, int *fd); /** * @brief low-level api for sending messages to vpp @@ -140,7 +160,7 @@ extern "C" * * @return VAPI_OK on success, other error code on error */ - vapi_error_e vapi_send (vapi_ctx_t ctx, void *msg); +vapi_error_e vapi_send (vapi_ctx_t ctx, void *msg); /** * @brief low-level api for atomically sending two messages to vpp - either diff --git a/test/test_api_client.py b/test/test_api_client.py new file mode 100644 index 00000000000..ec44be7e370 --- /dev/null +++ b/test/test_api_client.py @@ -0,0 +1,20 @@ +#!/usr/bin/env python3 + +import unittest + +from framework import VppTestCase, VppTestRunner +from vpp_ip_route import VppIpTable, VppIpRoute, VppRoutePath + + +class TestAPIClient(VppTestCase): + """ API Internal client Test Cases """ + + def test_client_unittest(self): + """ Internal API client """ + error = self.vapi.cli("test api internal") + if error: + self.logger.critical(error) + self.assertNotIn('failed', error) + +if __name__ == '__main__': + unittest.main(testRunner=VppTestRunner) |