diff options
author | sreejith <sreejith.surendrannair@linaro.org> | 2017-03-29 01:15:02 -0400 |
---|---|---|
committer | sreejith <sreejith.surendrannair@linaro.org> | 2017-03-29 02:23:59 -0400 |
commit | a23197980e40d4d9414bcfaf59005a1dc2a89251 (patch) | |
tree | da3fc5410a9cda99e05d2e0f6dae06072a0c50b8 /vpp/vlib-api | |
parent | 746b57564deede624261ab8a96c94f562f24d22c (diff) |
Added vpp intial source code from master branch 17.01.1
Change-Id: I81bdace6f330825a1746a853766779dfb24765fd
Signed-off-by: sreejith <sreejith.surendrannair@linaro.org>
Diffstat (limited to 'vpp/vlib-api')
23 files changed, 6876 insertions, 0 deletions
diff --git a/vpp/vlib-api/Makefile.am b/vpp/vlib-api/Makefile.am new file mode 100644 index 00000000..d9f4a27b --- /dev/null +++ b/vpp/vlib-api/Makefile.am @@ -0,0 +1,84 @@ +# Copyright (c) 2015 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. + +AUTOMAKE_OPTIONS = foreign subdir-objects + +AM_CFLAGS = -Wall + +lib_LTLIBRARIES = libvlibapi.la libvlibmemory.la libvlibmemoryclient.la \ + libvlibsocket.la + +libvlibapi_la_SOURCES = \ + vlibapi/api.h \ + vlibapi/api_helper_macros.h \ + vlibapi/api_shared.c \ + vlibapi/node_serialize.c + +nobase_include_HEADERS = vlibapi/api.h vlibapi/api_helper_macros.h + +libvlibmemory_la_SOURCES = \ + vlibmemory/api.h \ + vlibmemory/memclnt.api \ + vlibmemory/memory_shared.c \ + vlibmemory/memory_vlib.c \ + vlibmemory/vl_memory_api_h.h \ + vlibmemory/vl_memory_msg_enum.h \ + vlibmemory/unix_shared_memory_queue.c \ + vlibmemory/unix_shared_memory_queue.h + +libvlibmemoryclient_la_SOURCES = \ + vlibmemory/api.h \ + vlibmemory/memclnt.api \ + vlibmemory/memory_shared.c \ + vlibmemory/memory_client.c \ + vlibmemory/vl_memory_api_h.h \ + vlibmemory/vl_memory_msg_enum.h \ + vlibmemory/unix_shared_memory_queue.c \ + vlibmemory/unix_shared_memory_queue.h + +nobase_include_HEADERS += \ + vlibmemory/api.h \ + vlibmemory/vl_memory_api_h.h \ + vlibmemory/vl_memory_msg_enum.h \ + vlibmemory/unix_shared_memory_queue.h \ + vlibmemory/memclnt.api.h + +libvlibsocket_la_SOURCES = \ + vlibsocket/api.h \ + vlibsocket/sockclnt.api \ + vlibsocket/sockclnt_vlib.c \ + vlibsocket/socksvr_vlib.c \ + vlibsocket/vl_socket_api_h.h \ + vlibsocket/vl_socket_msg_enum.h + +nobase_include_HEADERS += \ + vlibsocket/api.h \ + vlibsocket/vl_socket_api_h.h \ + vlibsocket/vl_socket_msg_enum.h \ + vlibsocket/sockclnt.api.h + +BUILT_SOURCES = \ + vlibsocket/sockclnt.api.h \ + vlibmemory/memclnt.api.h \ + vlibmemory/memclnt.api.json + +SUFFIXES = .api.h .api .api.json + +# The actual %.api.h rule is in .../build-data/packages/suffix-rules.mk +# and requires a symbolic link at the top of the vnet source tree + +include $(top_srcdir)/suffix-rules.mk + +# install the API definition, so we can produce java bindings, etc. +apidir = $(prefix)/vlibmemory +api_DATA = vlibmemory/memclnt.api.json diff --git a/vpp/vlib-api/configure.ac b/vpp/vlib-api/configure.ac new file mode 100644 index 00000000..f0aa3083 --- /dev/null +++ b/vpp/vlib-api/configure.ac @@ -0,0 +1,9 @@ +AC_INIT(vlibapi, 1.0) +LT_INIT +AM_INIT_AUTOMAKE + +AM_SILENT_RULES([yes]) + +AC_PROG_CC + +AC_OUTPUT([Makefile]) diff --git a/vpp/vlib-api/suffix-rules.mk b/vpp/vlib-api/suffix-rules.mk new file mode 120000 index 00000000..f6098400 --- /dev/null +++ b/vpp/vlib-api/suffix-rules.mk @@ -0,0 +1 @@ +../build-data/suffix-rules.mk
\ No newline at end of file diff --git a/vpp/vlib-api/vlibapi/api.h b/vpp/vlib-api/vlibapi/api.h new file mode 100644 index 00000000..62745335 --- /dev/null +++ b/vpp/vlib-api/vlibapi/api.h @@ -0,0 +1,281 @@ +/* + *------------------------------------------------------------------ + * api.h + * + * Copyright (c) 2009-2015 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. + *------------------------------------------------------------------ + */ + +#ifndef included_api_h +#define included_api_h + +#include <vppinfra/error.h> +#include <svm.h> +#include <vlib/vlib.h> +#include <vlibmemory/unix_shared_memory_queue.h> +#include <vlib/unix/unix.h> + +typedef enum +{ + REGISTRATION_TYPE_FREE = 0, + REGISTRATION_TYPE_SHMEM, + REGISTRATION_TYPE_SOCKET_LISTEN, + REGISTRATION_TYPE_SOCKET_SERVER, + REGISTRATION_TYPE_SOCKET_CLIENT, +} vl_registration_type_t; + +typedef struct vl_api_registration_ +{ + vl_registration_type_t registration_type; + + /* Index in VLIB's brain (not shared memory). */ + u32 vl_api_registration_pool_index; + + u8 *name; + + /* + * The following groups of data could be unioned, but my fingers are + * going to be sore enough. + */ + + /* shared memory only */ + unix_shared_memory_queue_t *vl_input_queue; + + /* socket server and client */ + u32 unix_file_index; + i8 *unprocessed_input; + u32 unprocessed_msg_length; + u8 *output_vector; + + /* socket client only */ + u32 server_handle; + u32 server_index; + +} vl_api_registration_t; + + +/* Trace configuration for a single message */ +typedef struct +{ + int size; + int trace_enable; + int replay_enable; +} trace_cfg_t; + +/* + * API recording + */ +typedef struct +{ + u8 endian; + u8 enabled; + u8 wrapped; + u8 pad; + u32 nitems; + u32 curindex; + u8 **traces; +} vl_api_trace_t; + +/* *INDENT-OFF* */ +typedef CLIB_PACKED +(struct + { + u8 endian; u8 wrapped; + u32 nitems; +}) vl_api_trace_file_header_t; +/* *INDENT-ON* */ + +typedef enum +{ + VL_API_TRACE_TX, + VL_API_TRACE_RX, +} vl_api_trace_which_t; + +#define VL_API_LITTLE_ENDIAN 0x00 +#define VL_API_BIG_ENDIAN 0x01 + +typedef struct +{ + u8 *name; + u16 first_msg_id; + u16 last_msg_id; +} vl_api_msg_range_t; + +typedef struct +{ + void (**msg_handlers) (void *); + int (**pd_msg_handlers) (void *, int); + void (**msg_cleanup_handlers) (void *); + void (**msg_endian_handlers) (void *); + void (**msg_print_handlers) (void *, void *); + char **msg_names; + u8 *message_bounce; + u8 *is_mp_safe; + struct ring_alloc_ *arings; + u32 ring_misses; + u32 missing_clients; + vl_api_trace_t *rx_trace; + vl_api_trace_t *tx_trace; + int msg_print_flag; + trace_cfg_t *api_trace_cfg; + int our_pid; + svm_region_t *vlib_rp; + svm_region_t **mapped_shmem_regions; + struct vl_shmem_hdr_ *shmem_hdr; + vl_api_registration_t **vl_clients; + + u8 *serialized_message_table_in_shmem; + + /* For plugin msg allocator */ + u16 first_available_msg_id; + + /* message range by name hash */ + uword *msg_range_by_name; + + /* vector of message ranges */ + vl_api_msg_range_t *msg_ranges; + + /* uid for the api shared memory region */ + int api_uid; + /* gid for the api shared memory region */ + int api_gid; + + /* base virtual address for global VM region */ + u64 global_baseva; + + /* size of the global VM region */ + u64 global_size; + + /* size of the API region */ + u64 api_size; + + /* size of the global VM private mheap */ + u64 global_pvt_heap_size; + + /* size of the api private mheap */ + u64 api_pvt_heap_size; + + /* Client-only data structures */ + unix_shared_memory_queue_t *vl_input_queue; + + /* + * All VLIB-side message handlers use my_client_index to identify + * the queue / client. This works in sim replay. + */ + int my_client_index; + /* + * This is the (shared VM) address of the registration, + * don't use it to id the connection since it can't possibly + * work in simulator replay. + */ + vl_api_registration_t *my_registration; + + i32 vlib_signal; + + /* client side message index hash table */ + uword *msg_index_by_name_and_crc; + + char *region_name; + char *root_path; +} api_main_t; + +extern api_main_t api_main; + +typedef struct +{ + int id; + char *name; + u32 crc; + void *handler; + void *cleanup; + void *endian; + void *print; + int size; + int traced; + int replay; + int message_bounce; + int is_mp_safe; +} vl_msg_api_msg_config_t; + +typedef struct msgbuf_ +{ + unix_shared_memory_queue_t *q; + u32 data_len; + u32 pad; + u8 data[0]; +} msgbuf_t; + +/* api_shared.c prototypes */ +int vl_msg_api_rx_trace_enabled (api_main_t * am); +int vl_msg_api_tx_trace_enabled (api_main_t * am); +void vl_msg_api_trace (api_main_t * am, vl_api_trace_t * tp, void *msg); +int vl_msg_api_trace_onoff (api_main_t * am, vl_api_trace_which_t which, + int onoff); +int vl_msg_api_trace_free (api_main_t * am, vl_api_trace_which_t which); +int vl_msg_api_trace_save (api_main_t * am, + vl_api_trace_which_t which, FILE * fp); +int vl_msg_api_trace_configure (api_main_t * am, vl_api_trace_which_t which, + u32 nitems); +void vl_msg_api_handler_with_vm_node (api_main_t * am, + void *the_msg, vlib_main_t * vm, + vlib_node_runtime_t * node); +void vl_msg_api_handler (void *the_msg); +void vl_msg_api_handler_no_free (void *the_msg); +void vl_msg_api_handler_no_trace_no_free (void *the_msg); +void vl_msg_api_trace_only (void *the_msg); +void vl_msg_api_cleanup_handler (void *the_msg); +void vl_msg_api_replay_handler (void *the_msg); +void vl_msg_api_socket_handler (void *the_msg); +void vl_msg_api_set_handlers (int msg_id, char *msg_name, + void *handler, + void *cleanup, + void *endian, + void *print, int msg_size, int traced); +void vl_msg_api_config (vl_msg_api_msg_config_t *); +void vl_msg_api_set_cleanup_handler (int msg_id, void *fp); +void vl_msg_api_queue_handler (unix_shared_memory_queue_t * q); +vl_api_trace_t *vl_msg_api_trace_get (api_main_t * am, + vl_api_trace_which_t which); + +void vl_msg_api_free (void *); +void vl_noop_handler (void *mp); +clib_error_t *vl_api_init (vlib_main_t * vm); +void vl_msg_api_increment_missing_client_counter (void); +void vl_msg_api_post_mortem_dump (void); +void vl_msg_api_register_pd_handler (void *handler, + u16 msg_id_host_byte_order); +int vl_msg_api_pd_handler (void *mp, int rv); + +void vl_msg_api_set_first_available_msg_id (u16 first_avail); +u16 vl_msg_api_get_msg_ids (char *name, int n); +void vl_msg_api_add_msg_name_crc (api_main_t * am, char *string, u32 id); +u32 vl_api_get_msg_index (u8 * name_and_crc); + +/* node_serialize.c prototypes */ +u8 *vlib_node_serialize (vlib_node_main_t * nm, u8 * vector, + u32 max_threads, int include_nexts, + int include_stats); +vlib_node_t **vlib_node_unserialize (u8 * vector); + +#define VLIB_API_INIT_FUNCTION(x) VLIB_DECLARE_INIT_FUNCTION(x,api_init) + +#endif /* included_api_h */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vpp/vlib-api/vlibapi/api_helper_macros.h b/vpp/vlib-api/vlibapi/api_helper_macros.h new file mode 100644 index 00000000..16f34cfc --- /dev/null +++ b/vpp/vlib-api/vlibapi/api_helper_macros.h @@ -0,0 +1,243 @@ +/* + *------------------------------------------------------------------ + * api_helper_macros.h - message handler helper macros + * + * Copyright (c) 2016 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. + *------------------------------------------------------------------ + */ + + +#ifndef __api_helper_macros_h__ +#define __api_helper_macros_h__ + +#define f64_endian(a) +#define f64_print(a,b) + +#define REPLY_MACRO(t) \ +do { \ + unix_shared_memory_queue_t * q; \ + rv = vl_msg_api_pd_handler (mp, rv); \ + q = vl_api_client_index_to_input_queue (mp->client_index); \ + if (!q) \ + return; \ + \ + rmp = vl_msg_api_alloc (sizeof (*rmp)); \ + rmp->_vl_msg_id = ntohs((t)); \ + rmp->context = mp->context; \ + rmp->retval = ntohl(rv); \ + \ + vl_msg_api_send_shmem (q, (u8 *)&rmp); \ +} while(0); + +#define REPLY_MACRO2(t, body) \ +do { \ + unix_shared_memory_queue_t * q; \ + rv = vl_msg_api_pd_handler (mp, rv); \ + q = vl_api_client_index_to_input_queue (mp->client_index); \ + if (!q) \ + return; \ + \ + rmp = vl_msg_api_alloc (sizeof (*rmp)); \ + rmp->_vl_msg_id = ntohs((t)); \ + rmp->context = mp->context; \ + rmp->retval = ntohl(rv); \ + do {body;} while (0); \ + vl_msg_api_send_shmem (q, (u8 *)&rmp); \ +} while(0); + +#define REPLY_MACRO3(t, n, body) \ +do { \ + unix_shared_memory_queue_t * q; \ + rv = vl_msg_api_pd_handler (mp, rv); \ + q = vl_api_client_index_to_input_queue (mp->client_index); \ + if (!q) \ + return; \ + \ + rmp = vl_msg_api_alloc (sizeof (*rmp) + n); \ + rmp->_vl_msg_id = ntohs((t)); \ + rmp->context = mp->context; \ + rmp->retval = ntohl(rv); \ + do {body;} while (0); \ + vl_msg_api_send_shmem (q, (u8 *)&rmp); \ +} while(0); + +#define REPLY_MACRO4(t, n, body) \ +do { \ + unix_shared_memory_queue_t * q; \ + u8 is_error = 0; \ + rv = vl_msg_api_pd_handler (mp, rv); \ + q = vl_api_client_index_to_input_queue (mp->client_index); \ + if (!q) \ + return; \ + \ + rmp = vl_msg_api_alloc_or_null (sizeof (*rmp) + n); \ + if (!rmp) \ + { \ + /* if there isn't enough memory, try to allocate */ \ + /* some at least for returning an error */ \ + rmp = vl_msg_api_alloc (sizeof (*rmp)); \ + if (!rmp) \ + return; \ + \ + memset (rmp, 0, sizeof (*rmp)); \ + rv = VNET_API_ERROR_TABLE_TOO_BIG; \ + is_error = 1; \ + } \ + rmp->_vl_msg_id = ntohs((t)); \ + rmp->context = mp->context; \ + rmp->retval = ntohl(rv); \ + if (!is_error) \ + do {body;} while (0); \ + vl_msg_api_send_shmem (q, (u8 *)&rmp); \ +} while(0); + +/* "trust, but verify" */ + +#define VALIDATE_SW_IF_INDEX(mp) \ + do { u32 __sw_if_index = ntohl(mp->sw_if_index); \ + vnet_main_t *__vnm = vnet_get_main(); \ + if (pool_is_free_index(__vnm->interface_main.sw_interfaces, \ + __sw_if_index)) { \ + rv = VNET_API_ERROR_INVALID_SW_IF_INDEX; \ + goto bad_sw_if_index; \ + } \ +} while(0); + +#define BAD_SW_IF_INDEX_LABEL \ +do { \ +bad_sw_if_index: \ + ; \ +} while (0); + +#define VALIDATE_RX_SW_IF_INDEX(mp) \ + do { u32 __rx_sw_if_index = ntohl(mp->rx_sw_if_index); \ + vnet_main_t *__vnm = vnet_get_main(); \ + if (pool_is_free_index(__vnm->interface_main.sw_interfaces, \ + __rx_sw_if_index)) { \ + rv = VNET_API_ERROR_INVALID_SW_IF_INDEX; \ + goto bad_rx_sw_if_index; \ + } \ +} while(0); + +#define BAD_RX_SW_IF_INDEX_LABEL \ +do { \ +bad_rx_sw_if_index: \ + ; \ +} while (0); + +#define VALIDATE_TX_SW_IF_INDEX(mp) \ + do { u32 __tx_sw_if_index = ntohl(mp->tx_sw_if_index); \ + vnet_main_t *__vnm = vnet_get_main(); \ + if (pool_is_free_index(__vnm->interface_main.sw_interfaces, \ + __tx_sw_if_index)) { \ + rv = VNET_API_ERROR_INVALID_SW_IF_INDEX; \ + goto bad_tx_sw_if_index; \ + } \ +} while(0); + +#define BAD_TX_SW_IF_INDEX_LABEL \ +do { \ +bad_tx_sw_if_index: \ + ; \ +} while (0); + +#define pub_sub_handler(lca,UCA) \ +static void vl_api_want_##lca##_t_handler ( \ + vl_api_want_##lca##_t *mp) \ +{ \ + vpe_api_main_t *vam = &vpe_api_main; \ + vpe_client_registration_t *rp; \ + vl_api_want_##lca##_reply_t *rmp; \ + uword *p; \ + i32 rv = 0; \ + \ + p = hash_get (vam->lca##_registration_hash, mp->client_index); \ + if (p) { \ + if (mp->enable_disable) { \ + clib_warning ("pid %d: already enabled...", mp->pid); \ + rv = VNET_API_ERROR_INVALID_REGISTRATION; \ + goto reply; \ + } else { \ + rp = pool_elt_at_index (vam->lca##_registrations, p[0]); \ + pool_put (vam->lca##_registrations, rp); \ + hash_unset (vam->lca##_registration_hash, \ + mp->client_index); \ + goto reply; \ + } \ + } \ + if (mp->enable_disable == 0) { \ + clib_warning ("pid %d: already disabled...", mp->pid); \ + rv = VNET_API_ERROR_INVALID_REGISTRATION; \ + goto reply; \ + } \ + pool_get (vam->lca##_registrations, rp); \ + rp->client_index = mp->client_index; \ + rp->client_pid = mp->pid; \ + hash_set (vam->lca##_registration_hash, rp->client_index, \ + rp - vam->lca##_registrations); \ + \ +reply: \ + REPLY_MACRO (VL_API_WANT_##UCA##_REPLY); \ +} + +#define foreach_registration_hash \ +_(interface_events) \ +_(to_netconf_server) \ +_(from_netconf_server) \ +_(to_netconf_client) \ +_(from_netconf_client) \ +_(oam_events) \ +_(bfd_events) + +/* WARNING: replicated in vpp/stats.h */ +typedef struct +{ + u32 client_index; /* in memclnt registration pool */ + u32 client_pid; +} vpe_client_registration_t; + +struct _vl_api_ip4_arp_event; +struct _vl_api_ip6_nd_event; + +typedef struct +{ +#define _(a) uword *a##_registration_hash; \ + vpe_client_registration_t * a##_registrations; + foreach_registration_hash +#undef _ + /* notifications happen really early in the game */ + u8 link_state_process_up; + + /* ip4 arp event registration pool */ + struct _vl_api_ip4_arp_event *arp_events; + + /* ip6 nd event registration pool */ + struct _vl_api_ip6_nd_event *nd_events; + + /* convenience */ + vlib_main_t *vlib_main; + vnet_main_t *vnet_main; +} vpe_api_main_t; + +extern vpe_api_main_t vpe_api_main; + +#endif /* __api_helper_macros_h__ */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vpp/vlib-api/vlibapi/api_shared.c b/vpp/vlib-api/vlibapi/api_shared.c new file mode 100644 index 00000000..18067d1d --- /dev/null +++ b/vpp/vlib-api/vlibapi/api_shared.c @@ -0,0 +1,1377 @@ +/* + *------------------------------------------------------------------ + * api_shared.c - API message handling, common code for both clients + * and the vlib process itself. + * + * + * 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 <stddef.h> +#include <string.h> +#include <sys/types.h> +#include <sys/mman.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <unistd.h> +#include <vppinfra/format.h> +#include <vppinfra/byte_order.h> +#include <vppinfra/error.h> +#include <vlib/vlib.h> +#include <vlib/unix/unix.h> +#include <vlibapi/api.h> +#include <vppinfra/elog.h> + +api_main_t api_main; + +void vl_msg_api_barrier_sync (void) __attribute__ ((weak)); +void +vl_msg_api_barrier_sync (void) +{ +} + +void vl_msg_api_barrier_release (void) __attribute__ ((weak)); +void +vl_msg_api_barrier_release (void) +{ +} + +void +vl_msg_api_increment_missing_client_counter (void) +{ + api_main_t *am = &api_main; + am->missing_clients++; +} + +typedef enum +{ + DUMP, + CUSTOM_DUMP, + REPLAY, + INITIALIZERS, +} vl_api_replay_t; + +int +vl_msg_api_rx_trace_enabled (api_main_t * am) +{ + return (am->rx_trace && am->rx_trace->enabled); +} + +int +vl_msg_api_tx_trace_enabled (api_main_t * am) +{ + return (am->tx_trace && am->tx_trace->enabled); +} + +/* + * vl_msg_api_trace + */ +void +vl_msg_api_trace (api_main_t * am, vl_api_trace_t * tp, void *msg) +{ + u8 **this_trace; + u8 **old_trace; + u8 *msg_copy; + u32 length; + trace_cfg_t *cfgp; + u16 msg_id = ntohs (*((u16 *) msg)); + msgbuf_t *header = (msgbuf_t *) (((u8 *) msg) - offsetof (msgbuf_t, data)); + + cfgp = am->api_trace_cfg + msg_id; + + if (!cfgp || !cfgp->trace_enable) + return; + + msg_copy = 0; + + if (tp->nitems == 0) + { + clib_warning ("tp->nitems is 0"); + return; + } + + if (vec_len (tp->traces) < tp->nitems) + { + vec_add1 (tp->traces, 0); + this_trace = tp->traces + vec_len (tp->traces) - 1; + } + else + { + tp->wrapped = 1; + old_trace = tp->traces + tp->curindex++; + if (tp->curindex == tp->nitems) + tp->curindex = 0; + vec_free (*old_trace); + this_trace = old_trace; + } + + length = clib_net_to_host_u32 (header->data_len); + + vec_validate (msg_copy, length - 1); + clib_memcpy (msg_copy, msg, length); + *this_trace = msg_copy; +} + +int +vl_msg_api_trace_onoff (api_main_t * am, vl_api_trace_which_t which, + int onoff) +{ + vl_api_trace_t *tp; + int rv; + + switch (which) + { + case VL_API_TRACE_TX: + tp = am->tx_trace; + if (tp == 0) + { + vl_msg_api_trace_configure (am, which, 1024); + tp = am->tx_trace; + } + break; + + case VL_API_TRACE_RX: + tp = am->rx_trace; + if (tp == 0) + { + vl_msg_api_trace_configure (am, which, 1024); + tp = am->rx_trace; + } + break; + + default: + /* duh? */ + return -1; + } + + /* Configured? */ + if (tp == 0 || tp->nitems == 0) + return -1; + + rv = tp->enabled; + tp->enabled = onoff; + + return rv; +} + +int +vl_msg_api_trace_free (api_main_t * am, vl_api_trace_which_t which) +{ + vl_api_trace_t *tp; + int i; + + switch (which) + { + case VL_API_TRACE_TX: + tp = am->tx_trace; + break; + + case VL_API_TRACE_RX: + tp = am->rx_trace; + break; + + default: + /* duh? */ + return -1; + } + + /* Configured? */ + if (!tp || tp->nitems == 0) + return -1; + + tp->curindex = 0; + tp->wrapped = 0; + + for (i = 0; i < vec_len (tp->traces); i++) + { + vec_free (tp->traces[i]); + } + vec_free (tp->traces); + + return 0; +} + +int +vl_msg_api_trace_save (api_main_t * am, vl_api_trace_which_t which, FILE * fp) +{ + vl_api_trace_t *tp; + vl_api_trace_file_header_t fh; + int i; + u8 *msg; + + switch (which) + { + case VL_API_TRACE_TX: + tp = am->tx_trace; + break; + + case VL_API_TRACE_RX: + tp = am->rx_trace; + break; + + default: + /* duh? */ + return -1; + } + + /* Configured, data present? */ + if (tp == 0 || tp->nitems == 0 || vec_len (tp->traces) == 0) + return -1; + + /* "Dare to be stupid" check */ + if (fp == 0) + { + return -2; + } + + /* Write the file header */ + fh.nitems = vec_len (tp->traces); + fh.endian = tp->endian; + fh.wrapped = tp->wrapped; + + if (fwrite (&fh, sizeof (fh), 1, fp) != 1) + { + return (-10); + } + + /* No-wrap case */ + if (tp->wrapped == 0) + { + /* + * Note: vec_len return 0 when fed a NULL pointer. + * Unfortunately, the static analysis tool doesn't + * figure it out, hence the suppressed warnings. + * What a great use of my time. + */ + for (i = 0; i < vec_len (tp->traces); i++) + { + u32 msg_length; + /*sa_ignore NO_NULL_CHK */ + msg = tp->traces[i]; + /* + * This retarded check required to pass + * [sic] SA-checking. + */ + if (!msg) + continue; + + msg_length = clib_host_to_net_u32 (vec_len (msg)); + if (fwrite (&msg_length, 1, sizeof (msg_length), fp) + != sizeof (msg_length)) + { + return (-14); + } + if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg)) + { + return (-11); + } + } + } + else + { + /* Wrap case: write oldest -> end of buffer */ + for (i = tp->curindex; i < vec_len (tp->traces); i++) + { + u32 msg_length; + msg = tp->traces[i]; + /* + * This retarded check required to pass + * [sic] SA-checking + */ + if (!msg) + continue; + + msg_length = clib_host_to_net_u32 (vec_len (msg)); + if (fwrite (&msg_length, 1, sizeof (msg_length), fp) + != sizeof (msg_length)) + { + return (-14); + } + + if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg)) + { + return (-12); + } + } + /* write beginning of buffer -> oldest-1 */ + for (i = 0; i < tp->curindex; i++) + { + u32 msg_length; + /*sa_ignore NO_NULL_CHK */ + msg = tp->traces[i]; + /* + * This retarded check required to pass + * [sic] SA-checking + */ + if (!msg) + continue; + + msg_length = clib_host_to_net_u32 (vec_len (msg)); + if (fwrite (&msg_length, 1, sizeof (msg_length), fp) + != sizeof (msg_length)) + { + return (-14); + } + + if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg)) + { + return (-13); + } + } + } + return 0; +} + +int +vl_msg_api_trace_configure (api_main_t * am, vl_api_trace_which_t which, + u32 nitems) +{ + vl_api_trace_t *tp; + int was_on = 0; + + switch (which) + { + case VL_API_TRACE_TX: + tp = am->tx_trace; + if (tp == 0) + { + vec_validate (am->tx_trace, 0); + tp = am->tx_trace; + } + break; + + case VL_API_TRACE_RX: + tp = am->rx_trace; + if (tp == 0) + { + vec_validate (am->rx_trace, 0); + tp = am->rx_trace; + } + + break; + + default: + return -1; + + } + + if (tp->enabled) + { + was_on = vl_msg_api_trace_onoff (am, which, 0); + } + if (tp->traces) + { + vl_msg_api_trace_free (am, which); + } + + memset (tp, 0, sizeof (*tp)); + + if (clib_arch_is_big_endian) + { + tp->endian = VL_API_BIG_ENDIAN; + } + else + { + tp->endian = VL_API_LITTLE_ENDIAN; + } + + tp->nitems = nitems; + if (was_on) + { + (void) vl_msg_api_trace_onoff (am, which, was_on); + } + return 0; +} + +always_inline void +msg_handler_internal (api_main_t * am, + void *the_msg, int trace_it, int do_it, int free_it) +{ + u16 id = ntohs (*((u16 *) the_msg)); + u8 *(*print_fp) (void *, void *); + + if (id < vec_len (am->msg_handlers) && am->msg_handlers[id]) + { + if (trace_it) + vl_msg_api_trace (am, am->rx_trace, the_msg); + + if (am->msg_print_flag) + { + fformat (stdout, "[%d]: %s\n", id, am->msg_names[id]); + print_fp = (void *) am->msg_print_handlers[id]; + if (print_fp == 0) + { + fformat (stdout, " [no registered print fn]\n"); + } + else + { + (*print_fp) (the_msg, stdout); + } + } + + if (do_it) + { + if (!am->is_mp_safe[id]) + vl_msg_api_barrier_sync (); + (*am->msg_handlers[id]) (the_msg); + if (!am->is_mp_safe[id]) + vl_msg_api_barrier_release (); + } + } + else + { + clib_warning ("no handler for msg id %d", id); + } + + if (free_it) + vl_msg_api_free (the_msg); +} + +/* set to 1 if you want before/after message handler event logging */ +#define ELOG_API_MESSAGE_HANDLERS 0 + +#if ELOG_API_MESSAGE_HANDLERS > 0 +static u32 +elog_id_for_msg_name (vlib_main_t * vm, char *msg_name) +{ + uword *p, r; + static uword *h; + u8 *name_copy; + + if (!h) + h = hash_create_string (0, sizeof (uword)); + + p = hash_get_mem (h, msg_name); + if (p) + return p[0]; + r = elog_string (&vm->elog_main, "%s", msg_name); + + name_copy = format (0, "%s%c", msg_name, 0); + + hash_set_mem (h, name_copy, r); + + return r; +} +#endif + +/* This is only to be called from a vlib/vnet app */ +void +vl_msg_api_handler_with_vm_node (api_main_t * am, + void *the_msg, vlib_main_t * vm, + vlib_node_runtime_t * node) +{ + u16 id = ntohs (*((u16 *) the_msg)); + u8 *(*handler) (void *, void *, void *); + +#if ELOG_API_MESSAGE_HANDLERS > 0 + { + /* *INDENT-OFF* */ + ELOG_TYPE_DECLARE (e) = + { + .format = "api-msg: %s", + .format_args = "T4", + }; + /* *INDENT-ON* */ + struct + { + u32 c; + } *ed; + ed = ELOG_DATA (&vm->elog_main, e); + if (id < vec_len (am->msg_names)) + ed->c = elog_id_for_msg_name (vm, am->msg_names[id]); + else + ed->c = elog_id_for_msg_name (vm, "BOGUS"); + } +#endif + + if (id < vec_len (am->msg_handlers) && am->msg_handlers[id]) + { + handler = (void *) am->msg_handlers[id]; + + if (am->rx_trace && am->rx_trace->enabled) + vl_msg_api_trace (am, am->rx_trace, the_msg); + + if (!am->is_mp_safe[id]) + vl_msg_api_barrier_sync (); + (*handler) (the_msg, vm, node); + if (!am->is_mp_safe[id]) + vl_msg_api_barrier_release (); + } + else + { + clib_warning ("no hander for msg id %d", id); + } + + /* + * Special-case, so we can e.g. bounce messages off the vnet + * main thread without copying them... + */ + if (!(am->message_bounce[id])) + vl_msg_api_free (the_msg); + +#if ELOG_API_MESSAGE_HANDLERS > 0 + { + /* *INDENT-OFF* */ + ELOG_TYPE_DECLARE (e) = { + .format = "api-msg-done: %s", + .format_args = "T4", + }; + /* *INDENT-ON* */ + + struct + { + u32 c; + } *ed; + ed = ELOG_DATA (&vm->elog_main, e); + if (id < vec_len (am->msg_names)) + ed->c = elog_id_for_msg_name (vm, am->msg_names[id]); + else + ed->c = elog_id_for_msg_name (vm, "BOGUS"); + } +#endif +} + +void +vl_msg_api_handler (void *the_msg) +{ + api_main_t *am = &api_main; + + msg_handler_internal (am, the_msg, + (am->rx_trace + && am->rx_trace->enabled) /* trace_it */ , + 1 /* do_it */ , 1 /* free_it */ ); +} + +void +vl_msg_api_handler_no_free (void *the_msg) +{ + api_main_t *am = &api_main; + msg_handler_internal (am, the_msg, + (am->rx_trace + && am->rx_trace->enabled) /* trace_it */ , + 1 /* do_it */ , 0 /* free_it */ ); +} + +void +vl_msg_api_handler_no_trace_no_free (void *the_msg) +{ + api_main_t *am = &api_main; + msg_handler_internal (am, the_msg, 0 /* trace_it */ , 1 /* do_it */ , + 0 /* free_it */ ); +} + +/* + * Add a trace record to the API message trace buffer, if + * API message tracing is enabled. Handy for adding sufficient + * data to the trace to reproduce autonomous state, as opposed to + * state downloaded via control-plane API messages. Example: the NAT + * application creates database entries based on packet traffic, not + * control-plane messages. + * + */ +void +vl_msg_api_trace_only (void *the_msg) +{ + api_main_t *am = &api_main; + + msg_handler_internal (am, the_msg, + (am->rx_trace + && am->rx_trace->enabled) /* trace_it */ , + 0 /* do_it */ , 0 /* free_it */ ); +} + +void +vl_msg_api_cleanup_handler (void *the_msg) +{ + api_main_t *am = &api_main; + u16 id = ntohs (*((u16 *) the_msg)); + + if (PREDICT_FALSE (id >= vec_len (am->msg_cleanup_handlers))) + { + clib_warning ("_vl_msg_id too large: %d\n", id); + return; + } + if (am->msg_cleanup_handlers[id]) + (*am->msg_cleanup_handlers[id]) (the_msg); + + vl_msg_api_free (the_msg); +} + +/* + * vl_msg_api_replay_handler + */ +void +vl_msg_api_replay_handler (void *the_msg) +{ + api_main_t *am = &api_main; + + u16 id = ntohs (*((u16 *) the_msg)); + + if (PREDICT_FALSE (id >= vec_len (am->msg_handlers))) + { + clib_warning ("_vl_msg_id too large: %d\n", id); + return; + } + /* do NOT trace the message... */ + if (am->msg_handlers[id]) + (*am->msg_handlers[id]) (the_msg); + /* do NOT free the message buffer... */ +} + +/* + * vl_msg_api_socket_handler + */ +void +vl_msg_api_socket_handler (void *the_msg) +{ + api_main_t *am = &api_main; + + msg_handler_internal (am, the_msg, + (am->rx_trace + && am->rx_trace->enabled) /* trace_it */ , + 1 /* do_it */ , 0 /* free_it */ ); +} + +#define foreach_msg_api_vector \ +_(msg_names) \ +_(msg_handlers) \ +_(msg_cleanup_handlers) \ +_(msg_endian_handlers) \ +_(msg_print_handlers) \ +_(api_trace_cfg) \ +_(message_bounce) \ +_(is_mp_safe) + +void +vl_msg_api_config (vl_msg_api_msg_config_t * c) +{ + api_main_t *am = &api_main; + + ASSERT (c->id > 0); + +#define _(a) vec_validate (am->a, c->id); + foreach_msg_api_vector; +#undef _ + + am->msg_names[c->id] = c->name; + am->msg_handlers[c->id] = c->handler; + am->msg_cleanup_handlers[c->id] = c->cleanup; + am->msg_endian_handlers[c->id] = c->endian; + am->msg_print_handlers[c->id] = c->print; + am->message_bounce[c->id] = c->message_bounce; + am->is_mp_safe[c->id] = c->is_mp_safe; + + am->api_trace_cfg[c->id].size = c->size; + am->api_trace_cfg[c->id].trace_enable = c->traced; + am->api_trace_cfg[c->id].replay_enable = c->replay; +} + +/* + * vl_msg_api_set_handlers + * preserve the old API for a while + */ +void +vl_msg_api_set_handlers (int id, char *name, void *handler, void *cleanup, + void *endian, void *print, int size, int traced) +{ + vl_msg_api_msg_config_t cfg; + vl_msg_api_msg_config_t *c = &cfg; + + memset (c, 0, sizeof (*c)); + + c->id = id; + c->name = name; + c->handler = handler; + c->cleanup = cleanup; + c->endian = endian; + c->print = print; + c->traced = traced; + c->replay = 1; + c->message_bounce = 0; + c->is_mp_safe = 0; + vl_msg_api_config (c); +} + +void +vl_msg_api_set_cleanup_handler (int msg_id, void *fp) +{ + api_main_t *am = &api_main; + ASSERT (msg_id > 0); + + vec_validate (am->msg_cleanup_handlers, msg_id); + am->msg_cleanup_handlers[msg_id] = fp; +} + +void +vl_msg_api_queue_handler (unix_shared_memory_queue_t * q) +{ + uword msg; + + while (!unix_shared_memory_queue_sub (q, (u8 *) & msg, 0)) + vl_msg_api_handler ((void *) msg); +} + +vl_api_trace_t * +vl_msg_api_trace_get (api_main_t * am, vl_api_trace_which_t which) +{ + switch (which) + { + case VL_API_TRACE_RX: + return am->rx_trace; + case VL_API_TRACE_TX: + return am->tx_trace; + default: + return 0; + } +} + +void +vl_noop_handler (void *mp) +{ +} + +clib_error_t * +vl_api_init (vlib_main_t * vm) +{ + static u8 once; + api_main_t *am = &api_main; + + if (once) + return 0; + + once = 1; + + am->region_name = "/unset"; + /* + * Eventually passed to fchown, -1 => "current user" + * instead of 0 => "root". A very fine disctinction at best. + */ + if (am->api_uid == 0) + am->api_uid = -1; + if (am->api_gid == 0) + am->api_gid = -1; + + return (0); +} + +void vl_msg_api_custom_dump_configure (api_main_t * am) + __attribute__ ((weak)); +void +vl_msg_api_custom_dump_configure (api_main_t * am) +{ +} + +VLIB_INIT_FUNCTION (vl_api_init); + +static void +vl_msg_api_process_file (vlib_main_t * vm, u8 * filename, + u32 first_index, u32 last_index, + vl_api_replay_t which) +{ + vl_api_trace_file_header_t *hp; + int i, fd; + struct stat statb; + size_t file_size; + u8 *msg; + u8 endian_swap_needed = 0; + api_main_t *am = &api_main; + u8 *tmpbuf = 0; + u32 nitems; + void **saved_print_handlers = 0; + + fd = open ((char *) filename, O_RDONLY); + + if (fd < 0) + { + vlib_cli_output (vm, "Couldn't open %s\n", filename); + return; + } + + if (fstat (fd, &statb) < 0) + { + vlib_cli_output (vm, "Couldn't stat %s\n", filename); + close (fd); + return; + } + + if (!(statb.st_mode & S_IFREG) || (statb.st_size < sizeof (*hp))) + { + vlib_cli_output (vm, "File not plausible: %s\n", filename); + close (fd); + return; + } + + file_size = statb.st_size; + file_size = (file_size + 4095) & ~(4096); + + hp = mmap (0, file_size, PROT_READ, MAP_PRIVATE, fd, 0); + + if (hp == (vl_api_trace_file_header_t *) MAP_FAILED) + { + vlib_cli_output (vm, "mmap failed: %s\n", filename); + close (fd); + return; + } + close (fd); + + if ((clib_arch_is_little_endian && hp->endian == VL_API_BIG_ENDIAN) + || (clib_arch_is_big_endian && hp->endian == VL_API_LITTLE_ENDIAN)) + endian_swap_needed = 1; + + if (endian_swap_needed) + nitems = ntohl (hp->nitems); + else + nitems = hp->nitems; + + if (last_index == (u32) ~ 0) + { + last_index = nitems - 1; + } + + if (first_index >= nitems || last_index >= nitems) + { + vlib_cli_output (vm, "Range (%d, %d) outside file range (0, %d)\n", + first_index, last_index, nitems - 1); + munmap (hp, file_size); + return; + } + if (hp->wrapped) + vlib_cli_output (vm, + "Note: wrapped/incomplete trace, results may vary\n"); + + if (which == CUSTOM_DUMP) + { + saved_print_handlers = (void **) vec_dup (am->msg_print_handlers); + vl_msg_api_custom_dump_configure (am); + } + + + msg = (u8 *) (hp + 1); + + for (i = 0; i < first_index; i++) + { + trace_cfg_t *cfgp; + int size; + u16 msg_id; + + size = clib_host_to_net_u32 (*(u32 *) msg); + msg += sizeof (u32); + + if (clib_arch_is_little_endian) + msg_id = ntohs (*((u16 *) msg)); + else + msg_id = *((u16 *) msg); + + cfgp = am->api_trace_cfg + msg_id; + if (!cfgp) + { + vlib_cli_output (vm, "Ugh: msg id %d no trace config\n", msg_id); + munmap (hp, file_size); + return; + } + msg += size; + } + + for (; i <= last_index; i++) + { + trace_cfg_t *cfgp; + u16 *msg_idp; + u16 msg_id; + int size; + + if (which == DUMP) + vlib_cli_output (vm, "---------- trace %d -----------\n", i); + + size = clib_host_to_net_u32 (*(u32 *) msg); + msg += sizeof (u32); + + if (clib_arch_is_little_endian) + msg_id = ntohs (*((u16 *) msg)); + else + msg_id = *((u16 *) msg); + + cfgp = am->api_trace_cfg + msg_id; + if (!cfgp) + { + vlib_cli_output (vm, "Ugh: msg id %d no trace config\n", msg_id); + munmap (hp, file_size); + vec_free (tmpbuf); + return; + } + + /* Copy the buffer (from the read-only mmap'ed file) */ + vec_validate (tmpbuf, size - 1 + sizeof (uword)); + clib_memcpy (tmpbuf + sizeof (uword), msg, size); + memset (tmpbuf, 0xf, sizeof (uword)); + + /* + * Endian swap if needed. All msg data is supposed to be + * in network byte order. All msg handlers are supposed to + * know that. The generic message dumpers don't know that. + * One could fix apigen, I suppose. + */ + if ((which == DUMP && clib_arch_is_little_endian) || endian_swap_needed) + { + void (*endian_fp) (void *); + if (msg_id >= vec_len (am->msg_endian_handlers) + || (am->msg_endian_handlers[msg_id] == 0)) + { + vlib_cli_output (vm, "Ugh: msg id %d no endian swap\n", msg_id); + munmap (hp, file_size); + vec_free (tmpbuf); + return; + } + endian_fp = am->msg_endian_handlers[msg_id]; + (*endian_fp) (tmpbuf + sizeof (uword)); + } + + /* msg_id always in network byte order */ + if (clib_arch_is_little_endian) + { + msg_idp = (u16 *) (tmpbuf + sizeof (uword)); + *msg_idp = msg_id; + } + + switch (which) + { + case CUSTOM_DUMP: + case DUMP: + if (msg_id < vec_len (am->msg_print_handlers) && + am->msg_print_handlers[msg_id]) + { + u8 *(*print_fp) (void *, void *); + + print_fp = (void *) am->msg_print_handlers[msg_id]; + (*print_fp) (tmpbuf + sizeof (uword), vm); + } + else + { + vlib_cli_output (vm, "Skipping msg id %d: no print fcn\n", + msg_id); + break; + } + break; + + case INITIALIZERS: + if (msg_id < vec_len (am->msg_print_handlers) && + am->msg_print_handlers[msg_id]) + { + u8 *s; + int j; + u8 *(*print_fp) (void *, void *); + + print_fp = (void *) am->msg_print_handlers[msg_id]; + + vlib_cli_output (vm, "/*"); + + (*print_fp) (tmpbuf + sizeof (uword), vm); + vlib_cli_output (vm, "*/\n"); + + s = format (0, "static u8 * vl_api_%s_%d[%d] = {", + am->msg_names[msg_id], i, + am->api_trace_cfg[msg_id].size); + + for (j = 0; j < am->api_trace_cfg[msg_id].size; j++) + { + if ((j & 7) == 0) + s = format (s, "\n "); + s = format (s, "0x%02x,", tmpbuf[sizeof (uword) + j]); + } + s = format (s, "\n};\n%c", 0); + vlib_cli_output (vm, (char *) s); + vec_free (s); + } + break; + + case REPLAY: + if (msg_id < vec_len (am->msg_print_handlers) && + am->msg_print_handlers[msg_id] && cfgp->replay_enable) + { + void (*handler) (void *); + + handler = (void *) am->msg_handlers[msg_id]; + + if (!am->is_mp_safe[msg_id]) + vl_msg_api_barrier_sync (); + (*handler) (tmpbuf + sizeof (uword)); + if (!am->is_mp_safe[msg_id]) + vl_msg_api_barrier_release (); + } + else + { + if (cfgp->replay_enable) + vlib_cli_output (vm, "Skipping msg id %d: no handler\n", + msg_id); + break; + } + break; + } + + _vec_len (tmpbuf) = 0; + msg += size; + } + + if (saved_print_handlers) + { + clib_memcpy (am->msg_print_handlers, saved_print_handlers, + vec_len (am->msg_print_handlers) * sizeof (void *)); + vec_free (saved_print_handlers); + } + + munmap (hp, file_size); + vec_free (tmpbuf); +} + +u8 * +format_vl_msg_api_trace_status (u8 * s, va_list * args) +{ + api_main_t *am = va_arg (*args, api_main_t *); + vl_api_trace_which_t which = va_arg (*args, vl_api_trace_which_t); + vl_api_trace_t *tp; + char *trace_name; + + switch (which) + { + case VL_API_TRACE_TX: + tp = am->tx_trace; + trace_name = "TX trace"; + break; + + case VL_API_TRACE_RX: + tp = am->rx_trace; + trace_name = "RX trace"; + break; + + default: + abort (); + } + + if (tp == 0) + { + s = format (s, "%s: not yet configured.\n", trace_name); + return s; + } + + s = format (s, "%s: used %d of %d items, %s enabled, %s wrapped\n", + trace_name, vec_len (tp->traces), tp->nitems, + tp->enabled ? "is" : "is not", tp->wrapped ? "has" : "has not"); + return s; +} + +static u8 post_mortem_dump_enabled; + +static clib_error_t * +api_trace_command_fn (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) +{ + u32 nitems = 256 << 10; + api_main_t *am = &api_main; + vl_api_trace_which_t which = VL_API_TRACE_RX; + u8 *filename; + u32 first = 0; + u32 last = (u32) ~ 0; + FILE *fp; + int rv; + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "on") || unformat (input, "enable")) + { + if (unformat (input, "nitems %d", &nitems)) + ; + vl_msg_api_trace_configure (am, which, nitems); + vl_msg_api_trace_onoff (am, which, 1 /* on */ ); + } + else if (unformat (input, "off")) + { + vl_msg_api_trace_onoff (am, which, 0); + } + else if (unformat (input, "save %s", &filename)) + { + u8 *chroot_filename; + if (strstr ((char *) filename, "..") + || index ((char *) filename, '/')) + { + vlib_cli_output (vm, "illegal characters in filename '%s'", + filename); + return 0; + } + + chroot_filename = format (0, "/tmp/%s%c", filename, 0); + + vec_free (filename); + + fp = fopen ((char *) chroot_filename, "w"); + if (fp == NULL) + { + vlib_cli_output (vm, "Couldn't create %s\n", chroot_filename); + return 0; + } + rv = vl_msg_api_trace_save (am, which, fp); + fclose (fp); + if (rv == -1) + vlib_cli_output (vm, "API Trace data not present\n"); + else if (rv == -2) + vlib_cli_output (vm, "File for writing is closed\n"); + else if (rv == -10) + vlib_cli_output (vm, "Error while writing header to file\n"); + else if (rv == -11) + vlib_cli_output (vm, "Error while writing trace to file\n"); + else if (rv == -12) + vlib_cli_output (vm, + "Error while writing end of buffer trace to file\n"); + else if (rv == -13) + vlib_cli_output (vm, + "Error while writing start of buffer trace to file\n"); + else if (rv < 0) + vlib_cli_output (vm, "Unkown error while saving: %d", rv); + else + vlib_cli_output (vm, "API trace saved to %s\n", chroot_filename); + vec_free (chroot_filename); + } + else if (unformat (input, "dump %s", &filename)) + { + vl_msg_api_process_file (vm, filename, first, last, DUMP); + } + else if (unformat (input, "custom-dump %s", &filename)) + { + vl_msg_api_process_file (vm, filename, first, last, CUSTOM_DUMP); + } + else if (unformat (input, "replay %s", &filename)) + { + vl_msg_api_process_file (vm, filename, first, last, REPLAY); + } + else if (unformat (input, "initializers %s", &filename)) + { + vl_msg_api_process_file (vm, filename, first, last, INITIALIZERS); + } + else if (unformat (input, "tx")) + { + which = VL_API_TRACE_TX; + } + else if (unformat (input, "first %d", &first)) + { + ; + } + else if (unformat (input, "last %d", &last)) + { + ; + } + else if (unformat (input, "status")) + { + vlib_cli_output (vm, "%U", format_vl_msg_api_trace_status, + am, which); + } + else if (unformat (input, "free")) + { + vl_msg_api_trace_onoff (am, which, 0); + vl_msg_api_trace_free (am, which); + } + else if (unformat (input, "post-mortem-on")) + post_mortem_dump_enabled = 1; + else if (unformat (input, "post-mortem-off")) + post_mortem_dump_enabled = 0; + else + return clib_error_return (0, "unknown input `%U'", + format_unformat_error, input); + } + return 0; +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (api_trace_command, static) = { + .path = "api trace", + .short_help = + "api trace [on|off][dump|save|replay <file>][status][free][post-mortem-on]", + .function = api_trace_command_fn, +}; +/* *INDENT-ON* */ + +static clib_error_t * +api_config_fn (vlib_main_t * vm, unformat_input_t * input) +{ + u32 nitems = 256 << 10; + vl_api_trace_which_t which = VL_API_TRACE_RX; + api_main_t *am = &api_main; + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "on") || unformat (input, "enable")) + { + if (unformat (input, "nitems %d", &nitems)) + ; + vl_msg_api_trace_configure (am, which, nitems); + vl_msg_api_trace_onoff (am, which, 1 /* on */ ); + post_mortem_dump_enabled = 1; + } + else + return clib_error_return (0, "unknown input `%U'", + format_unformat_error, input); + } + return 0; +} + +VLIB_CONFIG_FUNCTION (api_config_fn, "api-trace"); + +void +vl_msg_api_post_mortem_dump (void) +{ + api_main_t *am = &api_main; + FILE *fp; + char filename[64]; + int rv; + + if (post_mortem_dump_enabled == 0) + return; + + snprintf (filename, sizeof (filename), "/tmp/api_post_mortem.%d", + getpid ()); + + fp = fopen (filename, "w"); + if (fp == NULL) + { + rv = write (2, "Couldn't create ", 16); + rv = write (2, filename, strlen (filename)); + rv = write (2, "\n", 1); + return; + } + rv = vl_msg_api_trace_save (am, VL_API_TRACE_RX, fp); + fclose (fp); + if (rv < 0) + { + rv = write (2, "Failed to save post-mortem API trace to ", 40); + rv = write (2, filename, strlen (filename)); + rv = write (2, "\n", 1); + } + +} + +/* Layered message handling support */ + +void +vl_msg_api_register_pd_handler (void *fp, u16 msg_id_host_byte_order) +{ + api_main_t *am = &api_main; + + /* Mild idiot proofing */ + if (msg_id_host_byte_order > 10000) + clib_warning ("msg_id_host_byte_order endian issue? %d arg vs %d", + msg_id_host_byte_order, + clib_net_to_host_u16 (msg_id_host_byte_order)); + vec_validate (am->pd_msg_handlers, msg_id_host_byte_order); + am->pd_msg_handlers[msg_id_host_byte_order] = fp; +} + +int +vl_msg_api_pd_handler (void *mp, int rv) +{ + api_main_t *am = &api_main; + int (*fp) (void *, int); + u16 msg_id; + + if (clib_arch_is_little_endian) + msg_id = clib_net_to_host_u16 (*((u16 *) mp)); + else + msg_id = *((u16 *) mp); + + if (msg_id >= vec_len (am->pd_msg_handlers) + || am->pd_msg_handlers[msg_id] == 0) + return rv; + + fp = am->pd_msg_handlers[msg_id]; + rv = (*fp) (mp, rv); + return rv; +} + +void +vl_msg_api_set_first_available_msg_id (u16 first_avail) +{ + api_main_t *am = &api_main; + + am->first_available_msg_id = first_avail; +} + +u16 +vl_msg_api_get_msg_ids (char *name, int n) +{ + api_main_t *am = &api_main; + u8 *name_copy; + vl_api_msg_range_t *rp; + uword *p; + u16 rv; + + if (am->msg_range_by_name == 0) + am->msg_range_by_name = hash_create_string (0, sizeof (uword)); + + name_copy = format (0, "%s%c", name, 0); + + p = hash_get_mem (am->msg_range_by_name, name_copy); + if (p) + { + clib_warning ("WARNING: duplicate message range registration for '%s'", + name_copy); + vec_free (name_copy); + return ((u16) ~ 0); + } + + if (n < 0 || n > 1024) + { + clib_warning + ("WARNING: bad number of message-IDs (%d) requested by '%s'", + n, name_copy); + vec_free (name_copy); + return ((u16) ~ 0); + } + + vec_add2 (am->msg_ranges, rp, 1); + + rv = rp->first_msg_id = am->first_available_msg_id; + am->first_available_msg_id += n; + rp->last_msg_id = am->first_available_msg_id - 1; + rp->name = name_copy; + + hash_set_mem (am->msg_range_by_name, name_copy, rp - am->msg_ranges); + + return rv; +} + +void +vl_msg_api_add_msg_name_crc (api_main_t * am, char *string, u32 id) +{ + uword *p; + + if (am->msg_index_by_name_and_crc == 0) + am->msg_index_by_name_and_crc = hash_create_string (0, sizeof (uword)); + + p = hash_get_mem (am->msg_index_by_name_and_crc, string); + if (p) + { + clib_warning ("attempt to redefine '%s' ignored...", string); + return; + } + + hash_set_mem (am->msg_index_by_name_and_crc, string, id); +} + + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vpp/vlib-api/vlibapi/node_serialize.c b/vpp/vlib-api/vlibapi/node_serialize.c new file mode 100644 index 00000000..4dc1a7d2 --- /dev/null +++ b/vpp/vlib-api/vlibapi/node_serialize.c @@ -0,0 +1,399 @@ +/* + * Copyright (c) 2016 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 <vlib/vlib.h> + +#include <vppinfra/serialize.h> + +extern void vl_msg_api_barrier_sync (void); +extern void vl_msg_api_barrier_release (void); + +/* serialized representation of state strings */ + +#define foreach_state_string_code \ +_(STATE_DONE, "done") \ +_(STATE_DISABLED, "disabled") \ +_(STATE_TIME_WAIT, "time wait") \ +_(STATE_EVENT_WAIT, "event wait") \ +_(STATE_ANY_WAIT, "any wait") \ +_(STATE_POLLING, "polling") \ +_(STATE_INTERRUPT_WAIT, "interrupt wait") \ +_(STATE_INTERNAL, "internal") + +typedef enum +{ +#define _(a,b) a, + foreach_state_string_code +#undef _ +} state_string_enum_t; + +static char *state_strings[] = { +#define _(a,b) b, + foreach_state_string_code +#undef _ +}; + +/* + * Serialize a vlib_node_main_t. Appends the result to vector. + * Pass 0 to create a new vector, use vec_reset_length(vector) + * to recycle a vector / avoid memory allocation, etc. + * Switch heaps before/after to serialize into API client shared memory. + */ + +u8 * +vlib_node_serialize (vlib_node_main_t * nm, u8 * vector, + u32 max_threads, int include_nexts, int include_stats) +{ + serialize_main_t _sm, *sm = &_sm; + vlib_main_t *vm = vlib_get_main (); + vlib_node_t *n; + static vlib_node_t ***node_dups; + vlib_node_t **nodes; + static vlib_main_t **stat_vms; + vlib_main_t *stat_vm; + u8 *namep; + u32 name_bytes; + uword i, j, k; + u64 l, v, c, d; + state_string_enum_t state_code; + u32 threads_to_serialize; + + vec_reset_length (node_dups); + + if (vec_len (stat_vms) == 0) + { + if (vec_len (vlib_mains) == 0) + vec_add1 (stat_vms, vm); + else + { + for (i = 0; i < vec_len (vlib_mains); i++) + { + stat_vm = vlib_mains[i]; + if (stat_vm) + vec_add1 (stat_vms, stat_vm); + } + } + } + + threads_to_serialize = clib_min (max_threads, vec_len (stat_vms)); + + /* + * Barrier sync across stats scraping. + * Otherwise, the counts will be grossly inaccurate. + */ + vl_msg_api_barrier_sync (); + + for (j = 0; j < threads_to_serialize; j++) + { + stat_vm = stat_vms[j]; + nm = &stat_vm->node_main; + + if (include_stats) + { + for (i = 0; i < vec_len (nm->nodes); i++) + { + n = nm->nodes[i]; + vlib_node_sync_stats (stat_vm, n); + } + } + + nodes = vec_dup (nm->nodes); + + vec_add1 (node_dups, nodes); + } + vl_msg_api_barrier_release (); + + serialize_open_vector (sm, vector); + + serialize_likely_small_unsigned_integer (sm, vec_len (stat_vms)); + + for (j = 0; j < vec_len (stat_vms); j++) + { + stat_vm = stat_vms[j]; + nodes = node_dups[j]; + + serialize_likely_small_unsigned_integer (sm, vec_len (nodes)); + + for (i = 0; i < vec_len (nodes); i++) + { + n = nodes[i]; + + l = n->stats_total.clocks - n->stats_last_clear.clocks; + v = n->stats_total.vectors - n->stats_last_clear.vectors; + c = n->stats_total.calls - n->stats_last_clear.calls; + d = n->stats_total.suspends - n->stats_last_clear.suspends; + + state_code = STATE_INTERNAL; + + if (n->type == VLIB_NODE_TYPE_PROCESS) + { + vlib_process_t *p = vlib_get_process_from_node (vm, n); + + switch (p->flags + & (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK + | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT)) + { + default: + if (!(p->flags & VLIB_PROCESS_IS_RUNNING)) + state_code = STATE_DONE; + break; + + case VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK: + state_code = STATE_TIME_WAIT; + break; + + case VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT: + state_code = STATE_EVENT_WAIT; + break; + + case (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK): + state_code = + STATE_ANY_WAIT; + break; + } + } + else if (n->type != VLIB_NODE_TYPE_INTERNAL) + { + state_code = STATE_POLLING; + if (n->state == VLIB_NODE_STATE_DISABLED) + state_code = STATE_DISABLED; + else if (n->state == VLIB_NODE_STATE_INTERRUPT) + state_code = STATE_INTERRUPT_WAIT; + } + + /* See unserialize_cstring */ + name_bytes = vec_len (n->name); + serialize_likely_small_unsigned_integer (sm, name_bytes); + namep = serialize_get (sm, name_bytes); + memcpy (namep, n->name, name_bytes); + + serialize_likely_small_unsigned_integer (sm, (u64) state_code); + serialize_likely_small_unsigned_integer (sm, n->type); + + if (include_nexts) + { + serialize_likely_small_unsigned_integer + (sm, vec_len (n->next_nodes)); + for (k = 0; k < vec_len (n->next_nodes); k++) + serialize_likely_small_unsigned_integer (sm, + n->next_nodes[k]); + } + else + serialize_likely_small_unsigned_integer (sm, 0); + + if (include_stats) + { + /* stats present */ + serialize_likely_small_unsigned_integer (sm, 1); + /* total clocks */ + serialize_integer (sm, l, 8); + /* Total calls */ + serialize_integer (sm, c, 8); + /* Total vectors */ + serialize_integer (sm, v, 8); + /* Total suspends */ + serialize_integer (sm, d, 8); + } + else /* no stats */ + serialize_likely_small_unsigned_integer (sm, 0); + } + vec_free (nodes); + } + return (serialize_close_vector (sm)); +} + +vlib_node_t *** +vlib_node_unserialize (u8 * vector) +{ + serialize_main_t _sm, *sm = &_sm; + u32 nnodes, nnexts; + u32 nstat_vms; + vlib_node_t *node; + vlib_node_t **nodes; + vlib_node_t ***nodes_by_thread = 0; + int i, j, k; + u64 l, v, c, d; + state_string_enum_t state_code; + int stats_present; + + serialize_open_vector (sm, vector); + + nstat_vms = unserialize_likely_small_unsigned_integer (sm); + + vec_validate (nodes_by_thread, nstat_vms - 1); + _vec_len (nodes_by_thread) = 0; + + for (i = 0; i < nstat_vms; i++) + { + nnodes = unserialize_likely_small_unsigned_integer (sm); + + nodes = 0; + vec_validate (nodes, nnodes - 1); + vec_add1 (nodes_by_thread, nodes); + + for (j = 0; j < nnodes; j++) + { + node = 0; + vec_validate (node, 0); + nodes[j] = node; + + unserialize_cstring (sm, (char **) &(node->name)); + state_code = unserialize_likely_small_unsigned_integer (sm); + node->state_string = (u8 *) state_strings[state_code]; + + node->type = unserialize_likely_small_unsigned_integer (sm); + nnexts = unserialize_likely_small_unsigned_integer (sm); + if (nnexts > 0) + vec_validate (node->next_nodes, nnexts - 1); + for (k = 0; k < nnexts; k++) + node->next_nodes[k] = + unserialize_likely_small_unsigned_integer (sm); + + stats_present = unserialize_likely_small_unsigned_integer (sm); + + if (stats_present) + { + /* total clocks */ + unserialize_integer (sm, &l, 8); + node->stats_total.clocks = l; + node->stats_last_clear.clocks = 0; + + /* Total calls */ + unserialize_integer (sm, &c, 8); + node->stats_total.calls = c; + + /* Total vectors */ + unserialize_integer (sm, &v, 8); + node->stats_total.vectors = v; + + /* Total suspends */ + unserialize_integer (sm, &d, 8); + node->stats_total.suspends = d; + } + } + } + return nodes_by_thread; +} + +#if CLIB_DEBUG > 0 + +static clib_error_t * +test_node_serialize_command_fn (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + vlib_node_main_t *nm = &vm->node_main; + u8 *vector = 0; + vlib_node_t ***nodes_by_thread; + vlib_node_t **nodes; + vlib_node_t *node; + vlib_node_t *next_node; + int i, j, k; + u32 max_threads = (u32) ~ 0; + int include_nexts = 0; + int include_stats = 0; + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "max-threads %d", &max_threads)) + ; + else if (unformat (input, "stats")) + include_stats = 1; + else if (unformat (input, "nexts")) + include_nexts = 1; + else + break; + } + + /* + * Keep the number of memcpy ops to a minimum (e.g. 1). + * The current size of the serialized vector is + * slightly under 4K. + */ + vec_validate (vector, 16383); + vec_reset_length (vector); + + vector = vlib_node_serialize (nm, vector, max_threads, + include_nexts, include_stats); + + vlib_cli_output (vm, "result vector %d bytes", vec_len (vector)); + + nodes_by_thread = vlib_node_unserialize (vector); + + vec_free (vector); + + for (i = 0; i < vec_len (nodes_by_thread); i++) + { + nodes = nodes_by_thread[i]; + + vlib_cli_output (vm, "thread %d", i); + + for (j = 0; j < vec_len (nodes); j++) + { + node = nodes[j]; + + vlib_cli_output (vm, "[%d] %s state %s", j, node->name, + node->state_string); + + vlib_cli_output + (vm, " clocks %lld calls %lld suspends" + " %lld vectors %lld", + node->stats_total.clocks, + node->stats_total.calls, + node->stats_total.suspends, node->stats_total.vectors); + + for (k = 0; k < vec_len (node->next_nodes); k++) + { + if (node->next_nodes[k] != ~0) + { + next_node = nodes[node->next_nodes[k]]; + vlib_cli_output (vm, " [%d] %s", k, next_node->name); + } + } + } + } + + for (j = 0; j < vec_len (nodes_by_thread); j++) + { + nodes = nodes_by_thread[j]; + + for (i = 0; i < vec_len (nodes); i++) + { + vec_free (nodes[i]->name); + vec_free (nodes[i]->next_nodes); + vec_free (nodes[i]); + } + vec_free (nodes); + } + vec_free (nodes_by_thread); + + return 0; +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (test_node_serialize_node, static) = { + .path = "test node serialize", + .short_help = "test node serialize [max-threads NN] nexts stats", + .function = test_node_serialize_command_fn, +}; +/* *INDENT-ON* */ +#endif + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vpp/vlib-api/vlibmemory/api.h b/vpp/vlib-api/vlibmemory/api.h new file mode 100644 index 00000000..f1f8bb73 --- /dev/null +++ b/vpp/vlib-api/vlibmemory/api.h @@ -0,0 +1,163 @@ +/* + *------------------------------------------------------------------ + * api.h + * + * 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. + *------------------------------------------------------------------ + */ + +#ifndef included_vlibmemory_api_h +#define included_vlibmemory_api_h + +#include <vppinfra/error.h> +#include <svm.h> +#include <vlib/vlib.h> +#include <vlibmemory/unix_shared_memory_queue.h> +#include <vlib/unix/unix.h> +#include <vlibapi/api.h> + +/* Allocated in shared memory */ + +/* + * Ring-allocation scheme for client API messages + * + * Only one proc/thread has control of a given message buffer. + * To free a buffer allocated from one of these rings, we clear + * a field in the buffer (header), and leave. + * + * No locks, no hits, no errors... + */ +typedef struct ring_alloc_ +{ + unix_shared_memory_queue_t *rp; + u16 size; + u16 nitems; + u32 hits; + u32 misses; +} ring_alloc_t; + +/* + * Initializers for the (shared-memory) rings + * _(size, n). Note: each msg has an 8 byte header. + * Might want to change that to an index sometime. + */ +#define foreach_vl_aring_size \ +_(64+8, 1024) \ +_(256+8, 128) \ +_(1024+8, 64) + +#define foreach_clnt_aring_size \ +_(1024+8, 1024) \ +_(2048+8, 128) \ +_(4096+8, 8) + +typedef struct vl_shmem_hdr_ +{ + int version; + + /* getpid () for the VLIB client process */ + volatile int vl_pid; + + /* Client sends VLIB msgs here. */ + unix_shared_memory_queue_t *vl_input_queue; + + /* Vector of rings; one for each size. */ + + /* VLIB allocates buffers to send msgs to clients here. */ + ring_alloc_t *vl_rings; + + /* Clients allocate buffer to send msgs to VLIB here. */ + ring_alloc_t *client_rings; + + /* Number of detected application restarts */ + u32 application_restarts; + + /* Number of messages reclaimed during application restart */ + u32 restart_reclaims; + +} vl_shmem_hdr_t; + +#define VL_SHM_VERSION 2 + +#define VL_API_EPOCH_MASK 0xFF +#define VL_API_EPOCH_SHIFT 8 + +static inline u32 +vl_msg_api_handle_get_epoch (u32 index) +{ + return (index & VL_API_EPOCH_MASK); +} + +static inline u32 +vl_msg_api_handle_get_index (u32 index) +{ + return (index >> VL_API_EPOCH_SHIFT); +} + +static inline u32 +vl_msg_api_handle_from_index_and_epoch (u32 index, u32 epoch) +{ + u32 handle; + ASSERT (index < 0x00FFFFFF); + + handle = (index << VL_API_EPOCH_SHIFT) | (epoch & VL_API_EPOCH_MASK); + return handle; +} + +void *vl_msg_api_alloc (int nbytes); +void *vl_msg_api_alloc_or_null (int nbytes); +void *vl_msg_api_alloc_as_if_client (int nbytes); +void *vl_msg_api_alloc_as_if_client_or_null (int nbytes); +void vl_msg_api_free (void *a); +int vl_map_shmem (char *region_name, int is_vlib); +void vl_register_mapped_shmem_region (svm_region_t * rp); +void vl_unmap_shmem (void); +void vl_msg_api_send_shmem (unix_shared_memory_queue_t * q, u8 * elem); +void vl_msg_api_send_shmem_nolock (unix_shared_memory_queue_t * q, u8 * elem); +void vl_msg_api_send (vl_api_registration_t * rp, u8 * elem); +int vl_client_connect (char *name, int ctx_quota, int input_queue_size); +void vl_client_disconnect (void); +unix_shared_memory_queue_t *vl_api_client_index_to_input_queue (u32 index); +vl_api_registration_t *vl_api_client_index_to_registration (u32 index); +int vl_client_api_map (char *region_name); +void vl_client_api_unmap (void); +void vl_set_memory_region_name (char *name); +void vl_set_memory_root_path (char *root_path); +void vl_set_memory_uid (int uid); +void vl_set_memory_gid (int gid); +void vl_set_global_memory_baseva (u64 baseva); +void vl_set_global_memory_size (u64 size); +void vl_set_api_memory_size (u64 size); +void vl_set_global_pvt_heap_size (u64 size); +void vl_set_api_pvt_heap_size (u64 size); +void vl_enable_disable_memory_api (vlib_main_t * vm, int yesno); +void vl_client_disconnect_from_vlib (void); +int vl_client_connect_to_vlib (char *svm_name, char *client_name, + int rx_queue_size); +int vl_client_connect_to_vlib_no_rx_pthread (char *svm_name, + char *client_name, + int rx_queue_size); +u16 vl_client_get_first_plugin_msg_id (char *plugin_name); + +void vl_api_rpc_call_main_thread (void *fp, u8 * data, u32 data_length); + +#endif /* included_vlibmemory_api_h */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vpp/vlib-api/vlibmemory/memclnt.api b/vpp/vlib-api/vlibmemory/memclnt.api new file mode 100644 index 00000000..2f654caf --- /dev/null +++ b/vpp/vlib-api/vlibmemory/memclnt.api @@ -0,0 +1,91 @@ +/* Hey Emacs use -*- mode: C -*- */ +/* + * Copyright (c) 2015 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. + */ + +/* + * Create a client registration + */ +manual_print +define memclnt_create { + i32 ctx_quota; /* requested punt context quota */ + u32 context; /* opaque value to be returned in the reply */ + u64 input_queue; /* client's queue */ + u8 name[64]; /* for show, find by name, whatever */ + u32 api_versions[8]; /* client-server pairs use as desired */ +}; + +define memclnt_create_reply { + i32 response; /* Non-negative = success */ + u64 handle; /* handle by which vlib knows this client */ + u32 index; /* index, used e.g. by API trace replay */ + u32 context; /* opaque value from the create request */ + u64 message_table; /* serialized message table in shmem */ +}; + +/* + * Delete a client registration + */ +manual_print +define memclnt_delete { + u32 index; /* index, used e.g. by API trace replay */ + u64 handle; /* handle by which vlib knows this client */ +}; + +define memclnt_delete_reply { + i32 response; /* Non-negative = success */ + u64 handle; /* in case the client wonders */ +}; + +/* + * Client RX thread exit + */ + +define rx_thread_exit { + u8 dummy; +}; + +/* + * RPC + */ +define rpc_call { + u32 client_index; + u32 context; + u64 function; + u8 multicast; + u8 need_barrier_sync; + u8 send_reply; + u8 data[0]; +}; + +define rpc_reply { + i32 retval; + u32 context; +}; + +/* + * Lookup message-ID base by name + */ +define get_first_msg_id { + u32 client_index; + u32 context; + u8 name[64]; +}; + +define get_first_msg_id_reply { + u32 client_index; + u32 context; + i32 retval; + u16 first_msg_id; +}; diff --git a/vpp/vlib-api/vlibmemory/memory_client.c b/vpp/vlib-api/vlibmemory/memory_client.c new file mode 100644 index 00000000..234a0a5a --- /dev/null +++ b/vpp/vlib-api/vlibmemory/memory_client.c @@ -0,0 +1,283 @@ +/* + *------------------------------------------------------------------ + * memory_client.c - API message handling, client code. + * + * Copyright (c) 2010 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 <setjmp.h> +#include <sys/types.h> +#include <sys/mman.h> +#include <sys/stat.h> +#include <netinet/in.h> +#include <signal.h> +#include <pthread.h> +#include <unistd.h> +#include <time.h> +#include <fcntl.h> +#include <string.h> +#include <vppinfra/clib.h> +#include <vppinfra/vec.h> +#include <vppinfra/hash.h> +#include <vppinfra/bitmap.h> +#include <vppinfra/fifo.h> +#include <vppinfra/time.h> +#include <vppinfra/mheap.h> +#include <vppinfra/heap.h> +#include <vppinfra/pool.h> +#include <vppinfra/format.h> + +#include <vlib/vlib.h> +#include <vlib/unix/unix.h> +#include <vlibmemory/api.h> + +#include <vlibmemory/vl_memory_msg_enum.h> + +#define vl_typedefs /* define message structures */ +#include <vlibmemory/vl_memory_api_h.h> +#undef vl_typedefs + +#define vl_endianfun /* define message structures */ +#include <vlibmemory/vl_memory_api_h.h> +#undef vl_endianfun + +/* instantiate all the print functions we know about */ +#define vl_print(handle, ...) clib_warning (__VA_ARGS__) +#define vl_printfun +#include <vlibmemory/vl_memory_api_h.h> +#undef vl_printfun + +typedef struct +{ + u8 rx_thread_jmpbuf_valid; + u8 connected_to_vlib; + jmp_buf rx_thread_jmpbuf; + pthread_t rx_thread_handle; + /* Plugin message base lookup scheme */ + volatile u8 first_msg_id_reply_ready; + u16 first_msg_id_reply; +} memory_client_main_t; + +memory_client_main_t memory_client_main; + +static void * +rx_thread_fn (void *arg) +{ + unix_shared_memory_queue_t *q; + memory_client_main_t *mm = &memory_client_main; + api_main_t *am = &api_main; + + q = am->vl_input_queue; + + /* So we can make the rx thread terminate cleanly */ + if (setjmp (mm->rx_thread_jmpbuf) == 0) + { + mm->rx_thread_jmpbuf_valid = 1; + while (1) + { + vl_msg_api_queue_handler (q); + } + } + pthread_exit (0); +} + +static void +vl_api_rx_thread_exit_t_handler (vl_api_rx_thread_exit_t * mp) +{ + memory_client_main_t *mm = &memory_client_main; + vl_msg_api_free (mp); + longjmp (mm->rx_thread_jmpbuf, 1); +} + +static void +noop_handler (void *notused) +{ +} + +#define foreach_api_msg \ +_(RX_THREAD_EXIT, rx_thread_exit) + +static int +connect_to_vlib_internal (char *svm_name, char *client_name, + int rx_queue_size, int want_pthread) +{ + int rv = 0; + memory_client_main_t *mm = &memory_client_main; + + if ((rv = vl_client_api_map (svm_name))) + { + clib_warning ("vl_client_api map rv %d", rv); + return rv; + } + +#define _(N,n) \ + vl_msg_api_set_handlers(VL_API_##N, #n, \ + vl_api_##n##_t_handler, \ + noop_handler, \ + vl_api_##n##_t_endian, \ + vl_api_##n##_t_print, \ + sizeof(vl_api_##n##_t), 1); + foreach_api_msg; +#undef _ + + if (vl_client_connect (client_name, 0 /* punt quota */ , + rx_queue_size /* input queue */ ) < 0) + { + vl_client_api_unmap (); + return -1; + } + + /* Start the rx queue thread */ + + if (want_pthread) + { + rv = pthread_create (&mm->rx_thread_handle, + NULL /*attr */ , rx_thread_fn, 0); + if (rv) + clib_warning ("pthread_create returned %d", rv); + } + + mm->connected_to_vlib = 1; + return 0; +} + +int +vl_client_connect_to_vlib (char *svm_name, char *client_name, + int rx_queue_size) +{ + return connect_to_vlib_internal (svm_name, client_name, rx_queue_size, + 1 /* want pthread */ ); +} + +int +vl_client_connect_to_vlib_no_rx_pthread (char *svm_name, char *client_name, + int rx_queue_size) +{ + return connect_to_vlib_internal (svm_name, client_name, rx_queue_size, + 0 /* want pthread */ ); +} + +void +vl_client_disconnect_from_vlib (void) +{ + memory_client_main_t *mm = &memory_client_main; + api_main_t *am = &api_main; + uword junk; + + if (mm->rx_thread_jmpbuf_valid) + { + vl_api_rx_thread_exit_t *ep; + ep = vl_msg_api_alloc (sizeof (*ep)); + ep->_vl_msg_id = ntohs (VL_API_RX_THREAD_EXIT); + vl_msg_api_send_shmem (am->vl_input_queue, (u8 *) & ep); + pthread_join (mm->rx_thread_handle, (void **) &junk); + } + if (mm->connected_to_vlib) + { + vl_client_disconnect (); + vl_client_api_unmap (); + } + memset (mm, 0, sizeof (*mm)); +} + +static void vl_api_get_first_msg_id_reply_t_handler + (vl_api_get_first_msg_id_reply_t * mp) +{ + memory_client_main_t *mm = &memory_client_main; + i32 retval = ntohl (mp->retval); + + mm->first_msg_id_reply = (retval >= 0) ? ntohs (mp->first_msg_id) : ~0; + mm->first_msg_id_reply_ready = 1; +} + +u16 +vl_client_get_first_plugin_msg_id (char *plugin_name) +{ + vl_api_get_first_msg_id_t *mp; + api_main_t *am = &api_main; + memory_client_main_t *mm = &memory_client_main; + f64 timeout; + void *old_handler; + clib_time_t clib_time; + u16 rv = ~0; + + if (strlen (plugin_name) + 1 > sizeof (mp->name)) + return (rv); + + memset (&clib_time, 0, sizeof (clib_time)); + clib_time_init (&clib_time); + + /* Push this plugin's first_msg_id_reply handler */ + old_handler = am->msg_handlers[VL_API_GET_FIRST_MSG_ID_REPLY]; + am->msg_handlers[VL_API_GET_FIRST_MSG_ID_REPLY] = (void *) + vl_api_get_first_msg_id_reply_t_handler; + + /* Ask the data-plane for the message-ID base of the indicated plugin */ + mm->first_msg_id_reply_ready = 0; + + mp = vl_msg_api_alloc (sizeof (*mp)); + memset (mp, 0, sizeof (*mp)); + mp->_vl_msg_id = ntohs (VL_API_GET_FIRST_MSG_ID); + mp->client_index = am->my_client_index; + strncpy ((char *) mp->name, plugin_name, sizeof (mp->name) - 1); + + vl_msg_api_send_shmem (am->shmem_hdr->vl_input_queue, (u8 *) & mp); + + /* Synchronously wait for the answer */ + do + { + timeout = clib_time_now (&clib_time) + 1.0; + + while (clib_time_now (&clib_time) < timeout) + { + if (mm->first_msg_id_reply_ready == 1) + { + rv = mm->first_msg_id_reply; + goto result; + } + } + /* Restore old handler */ + am->msg_handlers[VL_API_GET_FIRST_MSG_ID_REPLY] = old_handler; + + return rv; + } + while (0); + +result: + + /* Restore the old handler */ + am->msg_handlers[VL_API_GET_FIRST_MSG_ID_REPLY] = old_handler; + + if (rv == (u16) ~ 0) + clib_warning ("plugin '%s' not registered", plugin_name); + + return rv; +} + +void +vlib_node_sync_stats (vlib_main_t * vm, vlib_node_t * n) +{ + clib_warning ("STUB called..."); +} + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vpp/vlib-api/vlibmemory/memory_shared.c b/vpp/vlib-api/vlibmemory/memory_shared.c new file mode 100644 index 00000000..6adc69fc --- /dev/null +++ b/vpp/vlib-api/vlibmemory/memory_shared.c @@ -0,0 +1,847 @@ +/* + *------------------------------------------------------------------ + * memclnt_shared.c - API message handling, common code for both clients + * and the vlib process itself. + * + * + * 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 <stddef.h> +#include <string.h> +#include <unistd.h> +#include <signal.h> +#include <vppinfra/format.h> +#include <vppinfra/byte_order.h> +#include <vppinfra/error.h> +#include <vlib/vlib.h> +#include <vlib/unix/unix.h> +#include <vlibmemory/api.h> +#include <vlibmemory/unix_shared_memory_queue.h> + +#include <vlibmemory/vl_memory_msg_enum.h> + +#define vl_typedefs +#include <vlibmemory/vl_memory_api_h.h> +#undef vl_typedefs + +static inline void * +vl_msg_api_alloc_internal (int nbytes, int pool, int may_return_null) +{ + int i; + msgbuf_t *rv; + ring_alloc_t *ap; + unix_shared_memory_queue_t *q; + void *oldheap; + vl_shmem_hdr_t *shmem_hdr; + api_main_t *am = &api_main; + + shmem_hdr = am->shmem_hdr; + + if (shmem_hdr == 0) + { + clib_warning ("shared memory header NULL"); + return 0; + } + + /* account for the msgbuf_t header */ + nbytes += sizeof (msgbuf_t); + + if (shmem_hdr->vl_rings == 0) + { + clib_warning ("vl_rings NULL"); + ASSERT (0); + abort (); + } + + if (shmem_hdr->client_rings == 0) + { + clib_warning ("client_rings NULL"); + ASSERT (0); + abort (); + } + + ap = pool ? shmem_hdr->vl_rings : shmem_hdr->client_rings; + for (i = 0; i < vec_len (ap); i++) + { + /* Too big? */ + if (nbytes > ap[i].size) + { + continue; + } + + q = ap[i].rp; + if (pool == 0) + { + pthread_mutex_lock (&q->mutex); + } + rv = (msgbuf_t *) (&q->data[0] + q->head * q->elsize); + /* + * Is this item still in use? + */ + if (rv->q) + { + /* yes, loser; try next larger pool */ + ap[i].misses++; + if (pool == 0) + pthread_mutex_unlock (&q->mutex); + continue; + } + /* OK, we have a winner */ + ap[i].hits++; + /* + * Remember the source queue, although we + * don't need to know the queue to free the item. + */ + rv->q = q; + q->head++; + if (q->head == q->maxsize) + q->head = 0; + + if (pool == 0) + pthread_mutex_unlock (&q->mutex); + goto out; + } + + /* + * Request too big, or head element of all size-compatible rings + * still in use. Fall back to shared-memory malloc. + */ + am->ring_misses++; + + pthread_mutex_lock (&am->vlib_rp->mutex); + oldheap = svm_push_data_heap (am->vlib_rp); + if (may_return_null) + { + rv = clib_mem_alloc_or_null (nbytes); + if (PREDICT_FALSE (rv == 0)) + { + svm_pop_heap (oldheap); + pthread_mutex_unlock (&am->vlib_rp->mutex); + return 0; + } + } + else + rv = clib_mem_alloc (nbytes); + + rv->q = 0; + svm_pop_heap (oldheap); + pthread_mutex_unlock (&am->vlib_rp->mutex); + +out: + rv->data_len = htonl (nbytes - sizeof (msgbuf_t)); + return (rv->data); +} + +void * +vl_msg_api_alloc (int nbytes) +{ + int pool; + api_main_t *am = &api_main; + vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr; + + /* + * Clients use pool-0, vlib proc uses pool 1 + */ + pool = (am->our_pid == shmem_hdr->vl_pid); + return vl_msg_api_alloc_internal (nbytes, pool, 0 /* may_return_null */ ); +} + +void * +vl_msg_api_alloc_or_null (int nbytes) +{ + int pool; + api_main_t *am = &api_main; + vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr; + + pool = (am->our_pid == shmem_hdr->vl_pid); + return vl_msg_api_alloc_internal (nbytes, pool, 1 /* may_return_null */ ); +} + +void * +vl_msg_api_alloc_as_if_client (int nbytes) +{ + return vl_msg_api_alloc_internal (nbytes, 0, 0 /* may_return_null */ ); +} + +void * +vl_msg_api_alloc_as_if_client_or_null (int nbytes) +{ + return vl_msg_api_alloc_internal (nbytes, 0, 1 /* may_return_null */ ); +} + +void +vl_msg_api_free (void *a) +{ + msgbuf_t *rv; + void *oldheap; + api_main_t *am = &api_main; + + rv = (msgbuf_t *) (((u8 *) a) - offsetof (msgbuf_t, data)); + + /* + * Here's the beauty of the scheme. Only one proc/thread has + * control of a given message buffer. To free a buffer, we just clear the + * queue field, and leave. No locks, no hits, no errors... + */ + if (rv->q) + { + rv->q = 0; + return; + } + + pthread_mutex_lock (&am->vlib_rp->mutex); + oldheap = svm_push_data_heap (am->vlib_rp); + clib_mem_free (rv); + svm_pop_heap (oldheap); + pthread_mutex_unlock (&am->vlib_rp->mutex); +} + +static void +vl_msg_api_free_nolock (void *a) +{ + msgbuf_t *rv; + void *oldheap; + api_main_t *am = &api_main; + + rv = (msgbuf_t *) (((u8 *) a) - offsetof (msgbuf_t, data)); + /* + * Here's the beauty of the scheme. Only one proc/thread has + * control of a given message buffer. To free a buffer, we just clear the + * queue field, and leave. No locks, no hits, no errors... + */ + if (rv->q) + { + rv->q = 0; + return; + } + + oldheap = svm_push_data_heap (am->vlib_rp); + clib_mem_free (rv); + svm_pop_heap (oldheap); +} + +void +vl_set_memory_root_path (char *name) +{ + api_main_t *am = &api_main; + + am->root_path = name; +} + +void +vl_set_memory_uid (int uid) +{ + api_main_t *am = &api_main; + + am->api_uid = uid; +} + +void +vl_set_memory_gid (int gid) +{ + api_main_t *am = &api_main; + + am->api_gid = gid; +} + +void +vl_set_global_memory_baseva (u64 baseva) +{ + api_main_t *am = &api_main; + + am->global_baseva = baseva; +} + +void +vl_set_global_memory_size (u64 size) +{ + api_main_t *am = &api_main; + + am->global_size = size; +} + +void +vl_set_api_memory_size (u64 size) +{ + api_main_t *am = &api_main; + + am->api_size = size; +} + +void +vl_set_global_pvt_heap_size (u64 size) +{ + api_main_t *am = &api_main; + + am->global_pvt_heap_size = size; +} + +void +vl_set_api_pvt_heap_size (u64 size) +{ + api_main_t *am = &api_main; + + am->api_pvt_heap_size = size; +} + +int +vl_map_shmem (char *region_name, int is_vlib) +{ + svm_map_region_args_t _a, *a = &_a; + svm_region_t *vlib_rp, *root_rp; + void *oldheap; + vl_shmem_hdr_t *shmem_hdr = 0; + api_main_t *am = &api_main; + int i; + struct timespec ts, tsrem; + + if (is_vlib == 0) + svm_region_init_chroot (am->root_path); + + memset (a, 0, sizeof (*a)); + + a->name = region_name; + a->size = am->api_size ? am->api_size : (16 << 20); + a->flags = SVM_FLAGS_MHEAP; + a->uid = am->api_uid; + a->gid = am->api_gid; + a->pvt_heap_size = am->api_pvt_heap_size; + + vlib_rp = svm_region_find_or_create (a); + + if (vlib_rp == 0) + return (-2); + + pthread_mutex_lock (&vlib_rp->mutex); + /* Has someone else set up the shared-memory variable table? */ + if (vlib_rp->user_ctx) + { + am->shmem_hdr = (void *) vlib_rp->user_ctx; + am->our_pid = getpid (); + if (is_vlib) + { + unix_shared_memory_queue_t *q; + uword old_msg; + /* + * application restart. Reset cached pids, API message + * rings, list of clients; otherwise, various things + * fail. (e.g. queue non-empty notification) + */ + + /* ghosts keep the region from disappearing properly */ + svm_client_scan_this_region_nolock (vlib_rp); + am->shmem_hdr->application_restarts++; + q = am->shmem_hdr->vl_input_queue; + am->shmem_hdr->vl_pid = getpid (); + q->consumer_pid = am->shmem_hdr->vl_pid; + /* Drain the input queue, freeing msgs */ + for (i = 0; i < 10; i++) + { + if (pthread_mutex_trylock (&q->mutex) == 0) + { + pthread_mutex_unlock (&q->mutex); + goto mutex_ok; + } + ts.tv_sec = 0; + ts.tv_nsec = 10000 * 1000; /* 10 ms */ + while (nanosleep (&ts, &tsrem) < 0) + ts = tsrem; + } + /* Mutex buggered, "fix" it */ + memset (&q->mutex, 0, sizeof (q->mutex)); + clib_warning ("forcibly release main input queue mutex"); + + mutex_ok: + am->vlib_rp = vlib_rp; + while (unix_shared_memory_queue_sub (q, + (u8 *) & old_msg, + 1 /* nowait */ ) + != -2 /* queue underflow */ ) + { + vl_msg_api_free_nolock ((void *) old_msg); + am->shmem_hdr->restart_reclaims++; + } + pthread_mutex_unlock (&vlib_rp->mutex); + root_rp = svm_get_root_rp (); + ASSERT (root_rp); + /* Clean up the root region client list */ + pthread_mutex_lock (&root_rp->mutex); + svm_client_scan_this_region_nolock (root_rp); + pthread_mutex_unlock (&root_rp->mutex); + } + else + { + pthread_mutex_unlock (&vlib_rp->mutex); + } + am->vlib_rp = vlib_rp; + vec_add1 (am->mapped_shmem_regions, vlib_rp); + return 0; + } + /* Clients simply have to wait... */ + if (!is_vlib) + { + pthread_mutex_unlock (&vlib_rp->mutex); + + /* Wait up to 100 seconds... */ + for (i = 0; i < 10000; i++) + { + ts.tv_sec = 0; + ts.tv_nsec = 10000 * 1000; /* 10 ms */ + while (nanosleep (&ts, &tsrem) < 0) + ts = tsrem; + if (vlib_rp->user_ctx) + goto ready; + } + /* Clean up and leave... */ + svm_region_unmap (vlib_rp); + clib_warning ("region init fail"); + return (-2); + + ready: + am->shmem_hdr = (void *) vlib_rp->user_ctx; + am->our_pid = getpid (); + am->vlib_rp = vlib_rp; + vec_add1 (am->mapped_shmem_regions, vlib_rp); + return 0; + } + + /* Nope, it's our problem... */ + + oldheap = svm_push_data_heap (vlib_rp); + + vec_validate (shmem_hdr, 0); + shmem_hdr->version = VL_SHM_VERSION; + + /* vlib main input queue */ + shmem_hdr->vl_input_queue = + unix_shared_memory_queue_init (1024, sizeof (uword), getpid (), + am->vlib_signal); + + /* Set up the msg ring allocator */ +#define _(sz,n) \ + do { \ + ring_alloc_t _rp; \ + _rp.rp = unix_shared_memory_queue_init ((n), (sz), 0, 0); \ + _rp.size = (sz); \ + _rp.nitems = n; \ + _rp.hits = 0; \ + _rp.misses = 0; \ + vec_add1(shmem_hdr->vl_rings, _rp); \ + } while (0); + + foreach_vl_aring_size; +#undef _ + +#define _(sz,n) \ + do { \ + ring_alloc_t _rp; \ + _rp.rp = unix_shared_memory_queue_init ((n), (sz), 0, 0); \ + _rp.size = (sz); \ + _rp.nitems = n; \ + _rp.hits = 0; \ + _rp.misses = 0; \ + vec_add1(shmem_hdr->client_rings, _rp); \ + } while (0); + + foreach_clnt_aring_size; +#undef _ + + am->shmem_hdr = shmem_hdr; + am->vlib_rp = vlib_rp; + am->our_pid = getpid (); + if (is_vlib) + am->shmem_hdr->vl_pid = am->our_pid; + + svm_pop_heap (oldheap); + + /* + * After absolutely everything that a client might see is set up, + * declare the shmem region valid + */ + vlib_rp->user_ctx = shmem_hdr; + + pthread_mutex_unlock (&vlib_rp->mutex); + vec_add1 (am->mapped_shmem_regions, vlib_rp); + return 0; +} + +void +vl_register_mapped_shmem_region (svm_region_t * rp) +{ + api_main_t *am = &api_main; + + vec_add1 (am->mapped_shmem_regions, rp); +} + +void +vl_unmap_shmem (void) +{ + svm_region_t *rp; + int i; + api_main_t *am = &api_main; + + if (!svm_get_root_rp ()) + return; + + for (i = 0; i < vec_len (am->mapped_shmem_regions); i++) + { + rp = am->mapped_shmem_regions[i]; + svm_region_unmap (rp); + } + + vec_free (am->mapped_shmem_regions); + am->shmem_hdr = 0; + + svm_region_exit (); + /* $$$ more careful cleanup, valgrind run... */ + vec_free (am->msg_handlers); + vec_free (am->msg_endian_handlers); + vec_free (am->msg_print_handlers); +} + +void +vl_msg_api_send_shmem (unix_shared_memory_queue_t * q, u8 * elem) +{ + api_main_t *am = &api_main; + uword *trace = (uword *) elem; + + if (am->tx_trace && am->tx_trace->enabled) + vl_msg_api_trace (am, am->tx_trace, (void *) trace[0]); + + (void) unix_shared_memory_queue_add (q, elem, 0 /* nowait */ ); +} + +void +vl_msg_api_send_shmem_nolock (unix_shared_memory_queue_t * q, u8 * elem) +{ + api_main_t *am = &api_main; + uword *trace = (uword *) elem; + + if (am->tx_trace && am->tx_trace->enabled) + vl_msg_api_trace (am, am->tx_trace, (void *) trace[0]); + + (void) unix_shared_memory_queue_add_nolock (q, elem); +} + +static void +vl_api_memclnt_create_reply_t_handler (vl_api_memclnt_create_reply_t * mp) +{ + serialize_main_t _sm, *sm = &_sm; + api_main_t *am = &api_main; + u8 *tblv; + u32 nmsgs; + int i; + u8 *name_and_crc; + u32 msg_index; + + am->my_client_index = mp->index; + am->my_registration = (vl_api_registration_t *) (uword) mp->handle; + + /* Clean out any previous hash table (unlikely) */ + if (am->msg_index_by_name_and_crc) + { + int i; + u8 **keys = 0; + hash_pair_t *hp; + /* *INDENT-OFF* */ + hash_foreach_pair (hp, am->msg_index_by_name_and_crc, + ({ + vec_add1 (keys, (u8 *) hp->key); + })); + /* *INDENT-ON* */ + for (i = 0; i < vec_len (keys); i++) + vec_free (keys[i]); + vec_free (keys); + } + + am->msg_index_by_name_and_crc = hash_create_string (0, sizeof (uword)); + + /* Recreate the vnet-side API message handler table */ + tblv = (u8 *) mp->message_table; + serialize_open_vector (sm, tblv); + unserialize_integer (sm, &nmsgs, sizeof (u32)); + + for (i = 0; i < nmsgs; i++) + { + msg_index = unserialize_likely_small_unsigned_integer (sm); + unserialize_cstring (sm, (char **) &name_and_crc); + hash_set_mem (am->msg_index_by_name_and_crc, name_and_crc, msg_index); + } +} + +u32 +vl_api_get_msg_index (u8 * name_and_crc) +{ + api_main_t *am = &api_main; + uword *p; + + if (am->msg_index_by_name_and_crc) + { + p = hash_get_mem (am->msg_index_by_name_and_crc, name_and_crc); + if (p) + return p[0]; + } + return ~0; +} + +int +vl_client_connect (char *name, int ctx_quota, int input_queue_size) +{ + svm_region_t *svm; + vl_api_memclnt_create_t *mp; + vl_api_memclnt_create_reply_t *rp; + unix_shared_memory_queue_t *vl_input_queue; + vl_shmem_hdr_t *shmem_hdr; + int rv = 0; + void *oldheap; + api_main_t *am = &api_main; + + if (am->my_registration) + { + clib_warning ("client %s already connected...", name); + return -1; + } + + if (am->vlib_rp == 0) + { + clib_warning ("am->vlib_rp NULL"); + return -1; + } + + svm = am->vlib_rp; + shmem_hdr = am->shmem_hdr; + + if (shmem_hdr == 0 || shmem_hdr->vl_input_queue == 0) + { + clib_warning ("shmem_hdr / input queue NULL"); + return -1; + } + + pthread_mutex_lock (&svm->mutex); + oldheap = svm_push_data_heap (svm); + vl_input_queue = + unix_shared_memory_queue_init (input_queue_size, sizeof (uword), + getpid (), 0); + pthread_mutex_unlock (&svm->mutex); + svm_pop_heap (oldheap); + + am->my_client_index = ~0; + am->my_registration = 0; + am->vl_input_queue = vl_input_queue; + + mp = vl_msg_api_alloc (sizeof (vl_api_memclnt_create_t)); + memset (mp, 0, sizeof (*mp)); + mp->_vl_msg_id = ntohs (VL_API_MEMCLNT_CREATE); + mp->ctx_quota = ctx_quota; + mp->input_queue = (uword) vl_input_queue; + strncpy ((char *) mp->name, name, sizeof (mp->name) - 1); + + 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 = unix_shared_memory_queue_sub (vl_input_queue, (u8 *) & rp, + 1 /* nowait */ ); + 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... */ + clib_warning ("memclnt_create_reply timeout"); + return -1; + + read_one_msg: + if (ntohs (rp->_vl_msg_id) != VL_API_MEMCLNT_CREATE_REPLY) + { + clib_warning ("unexpected reply: id %d", ntohs (rp->_vl_msg_id)); + continue; + } + rv = clib_net_to_host_u32 (rp->response); + + vl_msg_api_handler ((void *) rp); + break; + } + return (rv); +} + +static void +vl_api_memclnt_delete_reply_t_handler (vl_api_memclnt_delete_reply_t * mp) +{ + void *oldheap; + api_main_t *am = &api_main; + + pthread_mutex_lock (&am->vlib_rp->mutex); + oldheap = svm_push_data_heap (am->vlib_rp); + unix_shared_memory_queue_free (am->vl_input_queue); + pthread_mutex_unlock (&am->vlib_rp->mutex); + svm_pop_heap (oldheap); + + am->my_client_index = ~0; + am->my_registration = 0; + am->vl_input_queue = 0; +} + +void +vl_client_disconnect (void) +{ + vl_api_memclnt_delete_t *mp; + vl_api_memclnt_delete_reply_t *rp; + unix_shared_memory_queue_t *vl_input_queue; + vl_shmem_hdr_t *shmem_hdr; + time_t begin; + api_main_t *am = &api_main; + + ASSERT (am->vlib_rp); + shmem_hdr = am->shmem_hdr; + ASSERT (shmem_hdr && shmem_hdr->vl_input_queue); + + vl_input_queue = am->vl_input_queue; + + mp = vl_msg_api_alloc (sizeof (vl_api_memclnt_delete_t)); + memset (mp, 0, sizeof (*mp)); + mp->_vl_msg_id = ntohs (VL_API_MEMCLNT_DELETE); + mp->index = am->my_client_index; + mp->handle = (uword) am->my_registration; + + vl_msg_api_send_shmem (shmem_hdr->vl_input_queue, (u8 *) & mp); + + /* + * Have to be careful here, in case the client is disconnecting + * because e.g. the vlib process died, or is unresponsive. + */ + + begin = time (0); + while (1) + { + time_t now; + + now = time (0); + + if (now >= (begin + 2)) + { + clib_warning ("peer unresponsive, give up"); + am->my_client_index = ~0; + am->my_registration = 0; + am->shmem_hdr = 0; + break; + } + if (unix_shared_memory_queue_sub (vl_input_queue, (u8 *) & rp, 1) < 0) + continue; + + /* drain the queue */ + if (ntohs (rp->_vl_msg_id) != VL_API_MEMCLNT_DELETE_REPLY) + { + vl_msg_api_handler ((void *) rp); + continue; + } + vl_msg_api_handler ((void *) rp); + break; + } +} + +static inline vl_api_registration_t * +vl_api_client_index_to_registration_internal (u32 handle) +{ + vl_api_registration_t **regpp; + vl_api_registration_t *regp; + api_main_t *am = &api_main; + u32 index; + + index = vl_msg_api_handle_get_index (handle); + if ((am->shmem_hdr->application_restarts & VL_API_EPOCH_MASK) + != vl_msg_api_handle_get_epoch (handle)) + { + vl_msg_api_increment_missing_client_counter (); + return 0; + } + + regpp = am->vl_clients + index; + + if (pool_is_free (am->vl_clients, regpp)) + { + vl_msg_api_increment_missing_client_counter (); + return 0; + } + regp = *regpp; + return (regp); +} + +vl_api_registration_t * +vl_api_client_index_to_registration (u32 index) +{ + return (vl_api_client_index_to_registration_internal (index)); +} + +unix_shared_memory_queue_t * +vl_api_client_index_to_input_queue (u32 index) +{ + vl_api_registration_t *regp; + + regp = vl_api_client_index_to_registration_internal (index); + if (!regp) + return 0; + return (regp->vl_input_queue); +} + +#define foreach_api_client_msg \ +_(MEMCLNT_CREATE_REPLY, memclnt_create_reply) \ +_(MEMCLNT_DELETE_REPLY, memclnt_delete_reply) + +int +vl_client_api_map (char *region_name) +{ + int rv; + + if ((rv = vl_map_shmem (region_name, 0 /* is_vlib */ )) < 0) + { + return rv; + } + +#define _(N,n) \ + vl_msg_api_set_handlers(VL_API_##N, 0 /* name */, \ + vl_api_##n##_t_handler, \ + 0/* cleanup */, 0/* endian */, 0/* print */, \ + sizeof(vl_api_##n##_t), 1); + foreach_api_client_msg; +#undef _ + return 0; +} + +void +vl_client_api_unmap (void) +{ + vl_unmap_shmem (); +} + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vpp/vlib-api/vlibmemory/memory_vlib.c b/vpp/vlib-api/vlibmemory/memory_vlib.c new file mode 100644 index 00000000..69f35d72 --- /dev/null +++ b/vpp/vlib-api/vlibmemory/memory_vlib.c @@ -0,0 +1,1349 @@ +/* + *------------------------------------------------------------------ + * 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); + } +} + +u8 * +vl_api_serialize_message_table (api_main_t * am, u8 * vector) +{ + serialize_main_t _sm, *sm = &_sm; + hash_pair_t *hp; + u32 nmsg = hash_elts (am->msg_index_by_name_and_crc); + + serialize_open_vector (sm, vector); + + /* serialize the count */ + serialize_integer (sm, nmsg, sizeof (u32)); + + hash_foreach_pair (hp, am->msg_index_by_name_and_crc, ( + { + serialize_likely_small_unsigned_integer + (sm, hp->value[0]); + serialize_cstring + (sm, + (char *) hp->key); + })); + + return serialize_close_vector (sm); +} + +/* + * 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 = 0; + void *oldheap; + api_main_t *am = &api_main; + u8 *serialized_message_table = 0; + + /* + * 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; + + if (am->serialized_message_table_in_shmem == 0) + serialized_message_table = vl_api_serialize_message_table (am, 0); + + 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); + if (serialized_message_table) + am->serialized_message_table_in_shmem = + vec_dup (serialized_message_table); + + pthread_mutex_unlock (&svm->mutex); + svm_pop_heap (oldheap); + + vec_free (serialized_message_table); + + 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); + rp->message_table = (u64) am->serialized_message_table_in_shmem; + + 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; + + memset (c, 0, sizeof (*c)); + + 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 */ \ + c->message_bounce = 0; /* don't bounce this message */ \ + 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_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); + + 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) + { + vm->api_queue_nonempty = 0; + pthread_mutex_unlock (&q->mutex); + + if (TRACE_VLIB_MEMORY_QUEUE) + { + /* *INDENT-OFF* */ + ELOG_TYPE_DECLARE (e) = + { + .format = "q-underflow: len %d", + .format_args = "i4", + }; + /* *INDENT-ON* */ + 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); + clib_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); + vm->queue_signal_pending = 0; + 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); + + /* *INDENT-OFF* */ + 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); + } + })); + /* *INDENT-ON* */ + /* 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) + { + /* *INDENT-OFF* */ + ELOG_TYPE_DECLARE (e) = { + .format = "q-awake: len %d", + .format_args = "i4", + }; + /* *INDENT-ON* */ + 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; +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (cli_show_api_histogram_command, static) = { + .path = "show api histogram", + .short_help = "show api histogram", + .function = vl_api_show_histogram_command, +}; +/* *INDENT-ON* */ + +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; +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (cli_clear_api_histogram_command, static) = { + .path = "clear api histogram", + .short_help = "clear api histogram", + .function = vl_api_clear_histogram_command, +}; +/* *INDENT-ON* */ + + +/* *INDENT-OFF* */ +VLIB_REGISTER_NODE (memclnt_node,static) = { + .function = memclnt_process, + .type = VLIB_NODE_TYPE_PROCESS, + .name = "api-rx-from-ring", + .state = VLIB_NODE_STATE_DISABLED, +}; +/* *INDENT-ON* */ + +static void +memclnt_queue_callback (vlib_main_t * vm) +{ + static volatile int *cursizep; + + if (PREDICT_FALSE (cursizep == 0)) + { + api_main_t *am = &api_main; + vl_shmem_hdr_t *shmem_hdr = am->shmem_hdr; + unix_shared_memory_queue_t *q; + + if (shmem_hdr == 0) + return; + + q = shmem_hdr->vl_input_queue; + if (q == 0) + return; + cursizep = &q->cursize; + } + + if (*cursizep >= 1) + { + vm->queue_signal_pending = 1; + vm->api_queue_nonempty = 1; + 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; +} + +/* *INDENT-OFF* */ +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", +}; +/* *INDENT-ON* */ + +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"); + + /* *INDENT-OFF* */ + 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); + } + })); + /* *INDENT-ON* */ + + /* 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; +} + +static clib_error_t * +vl_api_status_command (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cli_cmd) +{ + api_main_t *am = &api_main; + + // check if rx_trace and tx_trace are not null pointers + + if (am->rx_trace == 0) + { + vlib_cli_output (vm, "RX Trace disabled\n"); + } + else + { + if (am->rx_trace->enabled == 0) + vlib_cli_output (vm, "RX Trace disabled\n"); + else + vlib_cli_output (vm, "RX Trace enabled\n"); + } + + if (am->tx_trace == 0) + { + vlib_cli_output (vm, "TX Trace disabled\n"); + } + else + { + if (am->tx_trace->enabled == 0) + vlib_cli_output (vm, "TX Trace disabled\n"); + else + vlib_cli_output (vm, "TX Trace enabled\n"); + } + + return 0; +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (cli_show_api_command, static) = { + .path = "show api", + .short_help = "Show API information", +}; +/* *INDENT-ON* */ + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (cli_show_api_ring_command, static) = { + .path = "show api ring-stats", + .short_help = "Message ring statistics", + .function = vl_api_ring_command, +}; +/* *INDENT-ON* */ + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (cli_show_api_clients_command, static) = { + .path = "show api clients", + .short_help = "Client information", + .function = vl_api_client_command, +}; +/* *INDENT-ON* */ + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (cli_show_api_status_command, static) = { + .path = "show api status", + .short_help = "Show API trace status", + .function = vl_api_status_command, +}; +/* *INDENT-ON* */ + +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; +} + +/* *INDENT-OFF* */ +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, +}; +/* *INDENT-ON* */ + +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; + 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, "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; + +configure: + if (vl_msg_api_trace_configure (am, which, nitems)) + { + vlib_cli_output (vm, "warning: trace configure error (%d, %d)", + which, nitems); + } + + return 0; +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (trace, static) = { + .path = "set api-trace", + .short_help = "API trace", + .function = vl_api_trace_command, +}; +/* *INDENT-ON* */ + +clib_error_t * +vlibmemory_init (vlib_main_t * vm) +{ + api_main_t *am = &api_main; + svm_map_region_args_t _a, *a = &_a; + + memset (a, 0, sizeof (*a)); + a->root_path = am->root_path; + a->name = SVM_GLOBAL_REGION_NAME; + a->baseva = (am->global_baseva != 0) ? + am->global_baseva : SVM_GLOBAL_REGION_BASEVA; + a->size = (am->global_size != 0) ? am->global_size : SVM_GLOBAL_REGION_SIZE; + a->flags = SVM_FLAGS_NODATA; + a->uid = am->api_uid; + a->gid = am->api_gid; + a->pvt_heap_size = + (am->global_pvt_heap_size != + 0) ? am->global_pvt_heap_size : SVM_PVT_MHEAP_SIZE; + + svm_region_init_args (a); + 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; +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (cli_show_api_plugin_command, static) = { + .path = "show api plugin", + .short_help = "show api plugin", + .function = vl_api_show_plugin_command, +}; +/* *INDENT-ON* */ + +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; + unix_shared_memory_queue_t *q; + + /* Main thread: call the function directly */ + if (os_get_cpu_number () == 0) + { + vlib_main_t *vm = vlib_get_main (); + void (*call_fp) (void *); + + vlib_worker_thread_barrier_sync (vm); + + call_fp = fp; + call_fp (data); + + vlib_worker_thread_barrier_release (vm); + return; + } + + /* Any other thread, actually do an RPC call... */ + mp = vl_msg_api_alloc_as_if_client (sizeof (*mp) + data_length); + + memset (mp, 0, sizeof (*mp)); + clib_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. + * Well, almost. if the main input queue is full, we cannot + * block. Otherwise, we can expect a barrier sync timeout. + */ + q = shmem_hdr->vl_input_queue; + + while (pthread_mutex_trylock (&q->mutex)) + vlib_worker_thread_barrier_check (); + + while (PREDICT_FALSE (unix_shared_memory_queue_is_full (q))) + { + pthread_mutex_unlock (&q->mutex); + vlib_worker_thread_barrier_check (); + while (pthread_mutex_trylock (&q->mutex)) + vlib_worker_thread_barrier_check (); + } + + vl_msg_api_send_shmem_nolock (q, (u8 *) & mp); + + pthread_mutex_unlock (&q->mutex); +} + +#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); + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vpp/vlib-api/vlibmemory/unix_shared_memory_queue.c b/vpp/vlib-api/vlibmemory/unix_shared_memory_queue.c new file mode 100644 index 00000000..25d28910 --- /dev/null +++ b/vpp/vlib-api/vlibmemory/unix_shared_memory_queue.c @@ -0,0 +1,324 @@ +/* + *------------------------------------------------------------------ + * unix_shared_memory_queue.c - unidirectional shared-memory queues + * + * 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 <pthread.h> +#include <vppinfra/mem.h> +#include <vppinfra/format.h> +#include <vppinfra/cache.h> +#include <vlibmemory/unix_shared_memory_queue.h> +#include <signal.h> + +/* + * unix_shared_memory_queue_init + * + * nels = number of elements on the queue + * elsize = element size, presumably 4 and cacheline-size will + * be popular choices. + * coid = consumer coid, from ChannelCreate + * pid = consumer pid + * pulse_code = pulse code consumer expects + * pulse_value = pulse value consumer expects + * consumer_prio = consumer's priority, so pulses won't change + * the consumer's priority. + * + * The idea is to call this function in the queue consumer, + * and e-mail the queue pointer to the producer(s). + * + * The spp process / main thread allocates one of these + * at startup; its main input queue. The spp main input queue + * has a pointer to it in the shared memory segment header. + * + * You probably want to be on an svm data heap before calling this + * function. + */ +unix_shared_memory_queue_t * +unix_shared_memory_queue_init (int nels, + int elsize, + int consumer_pid, + int signal_when_queue_non_empty) +{ + unix_shared_memory_queue_t *q; + pthread_mutexattr_t attr; + pthread_condattr_t cattr; + + q = clib_mem_alloc_aligned (sizeof (unix_shared_memory_queue_t) + + nels * elsize, CLIB_CACHE_LINE_BYTES); + memset (q, 0, sizeof (*q)); + + q->elsize = elsize; + q->maxsize = nels; + q->consumer_pid = consumer_pid; + q->signal_when_queue_non_empty = signal_when_queue_non_empty; + + memset (&attr, 0, sizeof (attr)); + memset (&cattr, 0, sizeof (attr)); + + if (pthread_mutexattr_init (&attr)) + clib_unix_warning ("mutexattr_init"); + if (pthread_mutexattr_setpshared (&attr, PTHREAD_PROCESS_SHARED)) + clib_unix_warning ("pthread_mutexattr_setpshared"); + if (pthread_mutex_init (&q->mutex, &attr)) + clib_unix_warning ("mutex_init"); + if (pthread_mutexattr_destroy (&attr)) + clib_unix_warning ("mutexattr_destroy"); + if (pthread_condattr_init (&cattr)) + clib_unix_warning ("condattr_init"); + /* prints funny-looking messages in the Linux target */ + if (pthread_condattr_setpshared (&cattr, PTHREAD_PROCESS_SHARED)) + clib_unix_warning ("condattr_setpshared"); + if (pthread_cond_init (&q->condvar, &cattr)) + clib_unix_warning ("cond_init1"); + if (pthread_condattr_destroy (&cattr)) + clib_unix_warning ("cond_init2"); + + return (q); +} + +/* + * unix_shared_memory_queue_free + */ +void +unix_shared_memory_queue_free (unix_shared_memory_queue_t * q) +{ + (void) pthread_mutex_destroy (&q->mutex); + (void) pthread_cond_destroy (&q->condvar); + clib_mem_free (q); +} + +void +unix_shared_memory_queue_lock (unix_shared_memory_queue_t * q) +{ + pthread_mutex_lock (&q->mutex); +} + +void +unix_shared_memory_queue_unlock (unix_shared_memory_queue_t * q) +{ + pthread_mutex_unlock (&q->mutex); +} + +int +unix_shared_memory_queue_is_full (unix_shared_memory_queue_t * q) +{ + return q->cursize == q->maxsize; +} + +/* + * unix_shared_memory_queue_add_nolock + */ +int +unix_shared_memory_queue_add_nolock (unix_shared_memory_queue_t * q, + u8 * elem) +{ + i8 *tailp; + int need_broadcast = 0; + + if (PREDICT_FALSE (q->cursize == q->maxsize)) + { + while (q->cursize == q->maxsize) + { + (void) pthread_cond_wait (&q->condvar, &q->mutex); + } + } + + tailp = (i8 *) (&q->data[0] + q->elsize * q->tail); + clib_memcpy (tailp, elem, q->elsize); + + q->tail++; + q->cursize++; + + need_broadcast = (q->cursize == 1); + + if (q->tail == q->maxsize) + q->tail = 0; + + if (need_broadcast) + { + (void) pthread_cond_broadcast (&q->condvar); + if (q->signal_when_queue_non_empty) + kill (q->consumer_pid, q->signal_when_queue_non_empty); + } + return 0; +} + +int +unix_shared_memory_queue_add_raw (unix_shared_memory_queue_t * q, u8 * elem) +{ + i8 *tailp; + + if (PREDICT_FALSE (q->cursize == q->maxsize)) + { + while (q->cursize == q->maxsize) + ; + } + + tailp = (i8 *) (&q->data[0] + q->elsize * q->tail); + clib_memcpy (tailp, elem, q->elsize); + + q->tail++; + q->cursize++; + + if (q->tail == q->maxsize) + q->tail = 0; + return 0; +} + + +/* + * unix_shared_memory_queue_add + */ +int +unix_shared_memory_queue_add (unix_shared_memory_queue_t * q, + u8 * elem, int nowait) +{ + i8 *tailp; + int need_broadcast = 0; + + if (nowait) + { + /* zero on success */ + if (pthread_mutex_trylock (&q->mutex)) + { + return (-1); + } + } + else + pthread_mutex_lock (&q->mutex); + + if (PREDICT_FALSE (q->cursize == q->maxsize)) + { + if (nowait) + { + pthread_mutex_unlock (&q->mutex); + return (-2); + } + while (q->cursize == q->maxsize) + { + (void) pthread_cond_wait (&q->condvar, &q->mutex); + } + } + + tailp = (i8 *) (&q->data[0] + q->elsize * q->tail); + clib_memcpy (tailp, elem, q->elsize); + + q->tail++; + q->cursize++; + + need_broadcast = (q->cursize == 1); + + if (q->tail == q->maxsize) + q->tail = 0; + + if (need_broadcast) + { + (void) pthread_cond_broadcast (&q->condvar); + if (q->signal_when_queue_non_empty) + kill (q->consumer_pid, q->signal_when_queue_non_empty); + } + pthread_mutex_unlock (&q->mutex); + + return 0; +} + +/* + * unix_shared_memory_queue_sub + */ +int +unix_shared_memory_queue_sub (unix_shared_memory_queue_t * q, + u8 * elem, int nowait) +{ + i8 *headp; + int need_broadcast = 0; + + if (nowait) + { + /* zero on success */ + if (pthread_mutex_trylock (&q->mutex)) + { + return (-1); + } + } + else + pthread_mutex_lock (&q->mutex); + + if (PREDICT_FALSE (q->cursize == 0)) + { + if (nowait) + { + pthread_mutex_unlock (&q->mutex); + return (-2); + } + while (q->cursize == 0) + { + (void) pthread_cond_wait (&q->condvar, &q->mutex); + } + } + + headp = (i8 *) (&q->data[0] + q->elsize * q->head); + clib_memcpy (elem, headp, q->elsize); + + q->head++; + if (q->cursize == q->maxsize) + need_broadcast = 1; + + q->cursize--; + + if (q->head == q->maxsize) + q->head = 0; + + if (need_broadcast) + (void) pthread_cond_broadcast (&q->condvar); + + pthread_mutex_unlock (&q->mutex); + + return 0; +} + +int +unix_shared_memory_queue_sub_raw (unix_shared_memory_queue_t * q, u8 * elem) +{ + i8 *headp; + + if (PREDICT_FALSE (q->cursize == 0)) + { + while (q->cursize == 0) + ; + } + + headp = (i8 *) (&q->data[0] + q->elsize * q->head); + clib_memcpy (elem, headp, q->elsize); + + q->head++; + q->cursize--; + + if (q->head == q->maxsize) + q->head = 0; + return 0; +} + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vpp/vlib-api/vlibmemory/unix_shared_memory_queue.h b/vpp/vlib-api/vlibmemory/unix_shared_memory_queue.h new file mode 100644 index 00000000..f758f17c --- /dev/null +++ b/vpp/vlib-api/vlibmemory/unix_shared_memory_queue.h @@ -0,0 +1,69 @@ +/* + *------------------------------------------------------------------ + * unix_shared_memory_queue.h - shared-memory queues + * + * 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. + *------------------------------------------------------------------ + */ + +#ifndef included_unix_shared_memory_queue_h +#define included_unix_shared_memory_queue_h + +#include <pthread.h> +#include <vppinfra/mem.h> + +typedef struct _unix_shared_memory_queue +{ + pthread_mutex_t mutex; /* 8 bytes */ + pthread_cond_t condvar; /* 8 bytes */ + int head; + int tail; + int cursize; + int maxsize; + int elsize; + int consumer_pid; + int signal_when_queue_non_empty; + char data[0]; +} unix_shared_memory_queue_t; + +unix_shared_memory_queue_t *unix_shared_memory_queue_init (int nels, + int elsize, + int consumer_pid, + int + signal_when_queue_non_empty); +void unix_shared_memory_queue_free (unix_shared_memory_queue_t * q); +int unix_shared_memory_queue_add (unix_shared_memory_queue_t * q, + u8 * elem, int nowait); +int unix_shared_memory_queue_sub (unix_shared_memory_queue_t * q, + u8 * elem, int nowait); +void unix_shared_memory_queue_lock (unix_shared_memory_queue_t * q); +void unix_shared_memory_queue_unlock (unix_shared_memory_queue_t * q); +int unix_shared_memory_queue_is_full (unix_shared_memory_queue_t * q); +int unix_shared_memory_queue_add_nolock (unix_shared_memory_queue_t * q, + u8 * elem); + +int unix_shared_memory_queue_sub_raw (unix_shared_memory_queue_t * q, + u8 * elem); +int unix_shared_memory_queue_add_raw (unix_shared_memory_queue_t * q, + u8 * elem); + +#endif /* included_unix_shared_memory_queue_h */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vpp/vlib-api/vlibmemory/vl_memory_api_h.h b/vpp/vlib-api/vlibmemory/vl_memory_api_h.h new file mode 100644 index 00000000..c1ae79b1 --- /dev/null +++ b/vpp/vlib-api/vlibmemory/vl_memory_api_h.h @@ -0,0 +1,32 @@ +/* + *------------------------------------------------------------------ + * vl_memory_api_h.h - memory API headers, in a specific order. + * + * Copyright (c) 2009-2010 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. + *------------------------------------------------------------------ + */ + +/* + * Add to the bottom of the #include list, or elves will steal your + * keyboard in the middle of the night! + */ +#include <vlibmemory/memclnt.api.h> + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vpp/vlib-api/vlibmemory/vl_memory_msg_enum.h b/vpp/vlib-api/vlibmemory/vl_memory_msg_enum.h new file mode 100644 index 00000000..974c0c21 --- /dev/null +++ b/vpp/vlib-api/vlibmemory/vl_memory_msg_enum.h @@ -0,0 +1,42 @@ +/* + *------------------------------------------------------------------ + * vl_memory_msg_enum.h - Our view of how to number API messages + * Clients have their own view, which has to agree with ours. + * + * Copyright (c) 2009-2010 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. + *------------------------------------------------------------------ + */ + +#ifndef __VL_MSG_ENUM_H__ +#define __VL_MSG_ENUM_H__ + +#include <vppinfra/byte_order.h> + +#define vl_msg_id(n,h) n, +typedef enum +{ + VL_ILLEGAL_MESSAGE_ID = 0, +#include <vlibmemory/vl_memory_api_h.h> +} vl_msg_id_t; +#undef vl_msg_id + +#endif /* __VL_MSG_ENUM_H__ */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vpp/vlib-api/vlibsocket/api.h b/vpp/vlib-api/vlibsocket/api.h new file mode 100644 index 00000000..79c0d08a --- /dev/null +++ b/vpp/vlib-api/vlibsocket/api.h @@ -0,0 +1,87 @@ +/* + *------------------------------------------------------------------ + * api.h + * + * 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. + *------------------------------------------------------------------ + */ + +#ifndef included_vlibsocket_api_h +#define included_vlibsocket_api_h + +#include <vlibapi/api.h> + +typedef struct +{ + /* Server port number */ + int portno; + + /* By default, localhost... */ + u32 bind_address; + + /* + * (listen, server, client) registrations. Shared memory + * registrations are in shared memory + */ + vl_api_registration_t *registration_pool; + /* + * Chain-drag variables, so message API handlers + * (generally) don't know whether they're talking to a socket + * or to a shared-memory connection. + */ + vl_api_registration_t *current_rp; + unix_file_t *current_uf; + /* One input buffer, shared across all sockets */ + i8 *input_buffer; +} socket_main_t; + +extern socket_main_t socket_main; + +void socksvr_add_pending_output (struct unix_file *uf, + struct vl_api_registration_ *cf, + u8 * buffer, uword buffer_bytes); + +#define SOCKSVR_DEFAULT_PORT 32741 /* whatever */ + +void vl_free_socket_registration_index (u32 pool_index); +void vl_socket_process_msg (struct unix_file *uf, + struct vl_api_registration_ *rp, i8 * input_v); +clib_error_t *vl_socket_read_ready (struct unix_file *uf); +void vl_socket_add_pending_output (struct unix_file *uf, + struct vl_api_registration_ *rp, + u8 * buffer, uword buffer_bytes); +clib_error_t *vl_socket_write_ready (struct unix_file *uf); +void vl_socket_api_send (vl_api_registration_t * rp, u8 * elem); +void vl_socket_api_send_with_data (vl_api_registration_t * rp, + u8 * elem, u8 * data_vector); +void vl_socket_api_send_with_length (vl_api_registration_t * rp, + u8 * elem, u32 msg_length); +void vl_socket_api_send_with_length_no_free (vl_api_registration_t * rp, + u8 * elem, u32 msg_length); +u32 sockclnt_open_index (char *client_name, char *hostname, int port); +void sockclnt_close_index (u32 index); +void vl_client_msg_api_send (vl_api_registration_t * cm, u8 * elem); +vl_api_registration_t *sockclnt_get_registration (u32 index); +void socksvr_set_port (u16 port); +void socksvr_set_bind_address (u32 bind_address); + +#endif /* included_vlibsocket_api_h */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vpp/vlib-api/vlibsocket/sock_test.c b/vpp/vlib-api/vlibsocket/sock_test.c new file mode 100644 index 00000000..3bded08f --- /dev/null +++ b/vpp/vlib-api/vlibsocket/sock_test.c @@ -0,0 +1,155 @@ +/* + * Copyright (c) 2015 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 <strings.h> +#include <unistd.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <netdb.h> + +#define SOCKCLNT_SERVER_PORT 32741 /* whatever */ + +typedef signed char i8; +typedef signed short i16; +typedef signed int i32; +typedef signed long long i64; +typedef unsigned char u8; +typedef unsigned short u16; +typedef unsigned int u32; +typedef unsigned long long u64; +typedef unsigned long uword; + +#define VL_API_PACKED(x) x __attribute__ ((packed)) + +typedef VL_API_PACKED (struct _vl_api_sockclnt_create + { + u16 _vl_msg_id; u8 name[64]; + u32 context; + }) vl_api_sockclnt_create_t; + +typedef VL_API_PACKED (struct _vl_api_sockclnt_create_reply + { + u16 _vl_msg_id; + i32 response; u64 handle; u32 index; u32 context; + }) vl_api_sockclnt_create_reply_t; + +typedef VL_API_PACKED (struct _vl_api_sockclnt_delete + { + u16 _vl_msg_id; u32 index; + u64 handle; + }) vl_api_sockclnt_delete_t; + +typedef VL_API_PACKED (struct _vl_api_sockclnt_delete_reply + { + u16 _vl_msg_id; i32 response; u64 handle; + }) vl_api_sockclnt_delete_reply_t; + +void +error (char *msg) +{ + perror (msg); + exit (0); +} + +int +main (int argc, char *argv[]) +{ + int sockfd, portno, n; + struct sockaddr_in serv_addr; + struct hostent *server; + char buffer[256]; + int i; + u32 nbytes; + vl_api_sockclnt_create_t *mp; + vl_api_sockclnt_create_reply_t *rp; + char *rdptr; + int total_bytes; + + for (i = 0; i < 1; i++) + { + portno = SOCKCLNT_SERVER_PORT; + sockfd = socket (AF_INET, SOCK_STREAM, 0); + if (sockfd < 0) + error ("ERROR opening socket"); + server = gethostbyname ("localhost"); + if (server == NULL) + { + fprintf (stderr, "ERROR, no such host\n"); + exit (0); + } + bzero ((char *) &serv_addr, sizeof (serv_addr)); + serv_addr.sin_family = AF_INET; + bcopy ((char *) server->h_addr, + (char *) &serv_addr.sin_addr.s_addr, server->h_length); + serv_addr.sin_port = htons (portno); + if (connect (sockfd, (const void *) &serv_addr, sizeof (serv_addr)) < 0) + error ("ERROR connecting"); + + memset (buffer, 0, sizeof (buffer)); + + mp = (vl_api_sockclnt_create_t *) buffer; + mp->_vl_msg_id = ntohs (8); /* VL_API_SOCKCLNT_CREATE */ + strncpy ((char *) mp->name, "socket-test", sizeof (mp->name) - 1); + mp->name[sizeof (mp->name) - 1] = 0; + mp->context = 0xfeedface; + /* length of the message, including the length itself */ + nbytes = sizeof (*mp) + sizeof (nbytes); + nbytes = ntohl (nbytes); + n = write (sockfd, &nbytes, sizeof (nbytes)); + if (n < 0) + error ("ERROR writing len to socket"); + n = write (sockfd, mp, sizeof (*mp)); + if (n < 0) + error ("ERROR writing msg to socket"); + + memset (buffer, 0, sizeof (buffer)); + + total_bytes = 0; + rdptr = buffer; + do + { + n = read (sockfd, rdptr, sizeof (buffer) - (rdptr - buffer)); + if (n < 0) + error ("ERROR reading from socket"); + printf ("read %d bytes\n", n); + total_bytes += n; + rdptr += n; + } + while (total_bytes < sizeof (vl_api_sockclnt_create_reply_t) + 4); + + rp = (vl_api_sockclnt_create_reply_t *) (buffer + 4); + /* VL_API_SOCKCLNT_CREATE_REPLY */ + if (ntohs (rp->_vl_msg_id) != 9) + { + printf ("WARNING: msg id %d\n", ntohs (rp->_vl_msg_id)); + } + + printf ("response %d, handle 0x%llx, index %d, context 0x%x\n", + ntohl (rp->response), rp->handle, rp->index, rp->context); + close (sockfd); + } + return 0; +} + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vpp/vlib-api/vlibsocket/sockclnt.api b/vpp/vlib-api/vlibsocket/sockclnt.api new file mode 100644 index 00000000..e0a7505f --- /dev/null +++ b/vpp/vlib-api/vlibsocket/sockclnt.api @@ -0,0 +1,50 @@ +/* Hey Emacs use -*- mode: C -*- */ + +/* + *------------------------------------------------------------------ + * sockclnt.api - API message(s) to hook up clients, pass traffic + * to client processes via TCP sockets + * + * 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. + *------------------------------------------------------------------ + */ + +/* + * Create a socket client registration + */ +define sockclnt_create { + u8 name[64]; /* for show, find by name, whatever */ + u32 context; /* opaque value to be returned in the reply */ +}; + +define sockclnt_create_reply { + i32 response; /* Non-negative = success */ + u64 handle; /* handle by which vlib knows this client */ + u32 index; /* index, used e.g. by API trace replay */ + u32 context; /* opaque value from the create request */ +}; + +/* + * Delete a client registration + */ +define sockclnt_delete { + u32 index; /* index, used e.g. by API trace replay */ + u64 handle; /* handle by which vlib knows this client */ +}; + +define sockclnt_delete_reply { + i32 response; /* Non-negative = success */ + u64 handle; /* in case the client wonders */ +}; + diff --git a/vpp/vlib-api/vlibsocket/sockclnt_vlib.c b/vpp/vlib-api/vlibsocket/sockclnt_vlib.c new file mode 100644 index 00000000..e16adfeb --- /dev/null +++ b/vpp/vlib-api/vlibsocket/sockclnt_vlib.c @@ -0,0 +1,209 @@ +/* + *------------------------------------------------------------------ + * sockclnt_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 <sys/types.h> +#include <sys/socket.h> +#include <unistd.h> +#include <netinet/in.h> +#include <sys/ioctl.h> +#include <vppinfra/byte_order.h> +#include <netdb.h> + +#include <fcntl.h> +#include <sys/stat.h> + +#include <vlibmemory/api.h> +#include <vlibsocket/api.h> + +#include <vlibsocket/vl_socket_msg_enum.h> + +#define vl_typedefs /* define message structures */ +#include <vlibsocket/vl_socket_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 <vlibsocket/vl_socket_api_h.h> +#undef vl_printfun + +/* instantiate all the endian swap functions we know about */ +#define vl_endianfun +#include <vlibsocket/vl_socket_api_h.h> +#undef vl_endianfun + +static void +vl_api_sockclnt_create_reply_t_handler (vl_api_sockclnt_create_reply_t * mp) +{ + vl_api_registration_t *rp = socket_main.current_rp; + + rp->server_handle = mp->handle; + rp->server_index = mp->index; +} + +static void +vl_api_sockclnt_delete_reply_t_handler (vl_api_sockclnt_delete_reply_t * mp) +{ + unix_main_t *um = &unix_main; + unix_file_t *uf = socket_main.current_uf; + vl_api_registration_t *rp = socket_main.current_rp; + + unix_file_del (um, uf); + vl_free_socket_registration_index (rp->vl_api_registration_pool_index); +} + +u32 +sockclnt_open_index (char *client_name, char *hostname, int port) +{ + vl_api_registration_t *rp; + unix_main_t *um = &unix_main; + unix_file_t template = { 0 }; + int sockfd; + int one = 1; + int rv; + struct sockaddr_in serv_addr; + struct hostent *server; + vl_api_sockclnt_create_t *mp; + char my_hostname[64]; + + server = gethostbyname (hostname); + if (server == NULL) + { + clib_warning ("Couldn't translate server name %s", hostname); + return ~0; + } + + /* Set up non-blocking server socket on CLIENT_API_SERVER_PORT */ + sockfd = socket (AF_INET, SOCK_STREAM, 0); + + if (sockfd < 0) + { + clib_unix_warning ("socket"); + return ~0; + } + + bzero ((char *) &serv_addr, sizeof (serv_addr)); + serv_addr.sin_family = AF_INET; + bcopy ((char *) server->h_addr, + (char *) &serv_addr.sin_addr.s_addr, server->h_length); + serv_addr.sin_port = htons (port); + + if (connect (sockfd, (const void *) &serv_addr, sizeof (serv_addr)) < 0) + { + clib_unix_warning ("Connect failure to (%s, %d)", hostname, port); + close (sockfd); + return ~0; + } + + rv = ioctl (sockfd, FIONBIO, &one); + if (rv < 0) + { + clib_unix_warning ("FIONBIO"); + close (sockfd); + return ~0; + } + + pool_get (socket_main.registration_pool, rp); + memset (rp, 0, sizeof (*rp)); + rp->registration_type = REGISTRATION_TYPE_SOCKET_CLIENT; + rp->vl_api_registration_pool_index = rp - socket_main.registration_pool; + + template.read_function = vl_socket_read_ready; + template.write_function = vl_socket_write_ready; + template.file_descriptor = sockfd; + template.private_data = rp - socket_main.registration_pool; + + rp->unix_file_index = unix_file_add (um, &template); + rp->name = format (0, "%s:%d", hostname, port); + + mp = vl_msg_api_alloc (sizeof (*mp)); + mp->_vl_msg_id = ntohs (VL_API_SOCKCLNT_CREATE); + mp->context = rp - socket_main.registration_pool; + + if (gethostname (my_hostname, sizeof (my_hostname)) < 0) + { + clib_unix_warning ("gethostname"); + strncpy (my_hostname, "unknown!", sizeof (my_hostname) - 1); + } + strncpy ((char *) mp->name, my_hostname, sizeof (mp->name) - 1); + + vl_msg_api_send (rp, (u8 *) mp); + return rp - socket_main.registration_pool; +} + +void +sockclnt_close_index (u32 index) +{ + vl_api_sockclnt_delete_t *mp; + vl_api_registration_t *rp; + + /* Don't crash / assert if fed garbage */ + if (pool_is_free_index (socket_main.registration_pool, index)) + { + clib_warning ("registration_pool index %d already free", index); + return; + } + rp = pool_elt_at_index (socket_main.registration_pool, index); + + mp = vl_msg_api_alloc (sizeof (*mp)); + mp->_vl_msg_id = ntohs (VL_API_SOCKCLNT_DELETE); + mp->handle = rp->server_handle; + mp->index = rp->server_index; + vl_msg_api_send (rp, (u8 *) mp); +} + +vl_api_registration_t * +sockclnt_get_registration (u32 index) +{ + return pool_elt_at_index (socket_main.registration_pool, index); +} + +/* + * Both rx and tx msgs MUST be initialized, or we'll have + * precisely no idea how many bytes to write into the API trace... + */ +#define foreach_sockclnt_api_msg \ +_(SOCKCLNT_CREATE_REPLY, sockclnt_create_reply) \ +_(SOCKCLNT_DELETE_REPLY, sockclnt_delete_reply) + + +static clib_error_t * +sockclnt_vlib_api_init (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_api_##n##_t_endian, \ + vl_api_##n##_t_print, \ + sizeof(vl_api_##n##_t), 1); + foreach_sockclnt_api_msg; +#undef _ + return 0; +} + +VLIB_API_INIT_FUNCTION (sockclnt_vlib_api_init); + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vpp/vlib-api/vlibsocket/socksvr_vlib.c b/vpp/vlib-api/vlibsocket/socksvr_vlib.c new file mode 100644 index 00000000..dc8c63eb --- /dev/null +++ b/vpp/vlib-api/vlibsocket/socksvr_vlib.c @@ -0,0 +1,706 @@ +/* + *------------------------------------------------------------------ + * socksvr_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 <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <sys/ioctl.h> +#include <vppinfra/byte_order.h> + +#include <fcntl.h> +#include <sys/stat.h> + +#include <vlibsocket/api.h> +#include <vlibmemory/api.h> + +#include <vlibsocket/vl_socket_msg_enum.h> /* enumerate all vlib messages */ + +#define vl_typedefs /* define message structures */ +#include <vlibsocket/vl_socket_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 <vlibsocket/vl_socket_api_h.h> +#undef vl_printfun + +/* instantiate all the endian swap functions we know about */ +#define vl_endianfun +#include <vlibsocket/vl_socket_api_h.h> +#undef vl_endianfun + +socket_main_t socket_main; + +void +dump_socket_clients (vlib_main_t * vm, api_main_t * am) +{ + vl_api_registration_t *reg; + socket_main_t *sm = &socket_main; + unix_main_t *um = &unix_main; + unix_file_t *f; + + /* + * Must have at least one active client, not counting the + * REGISTRATION_TYPE_SOCKET_LISTEN bind/accept socket + */ + if (pool_elts (sm->registration_pool) < 2) + return; + + vlib_cli_output (vm, "TCP socket clients"); + vlib_cli_output (vm, "%16s %8s", "Name", "Fildesc"); + /* *INDENT-OFF* */ + pool_foreach (reg, sm->registration_pool, + ({ + if (reg->registration_type == REGISTRATION_TYPE_SOCKET_SERVER) { + f = pool_elt_at_index (um->file_pool, reg->unix_file_index); + vlib_cli_output (vm, "%16s %8d", + reg->name, f->file_descriptor); + } + })); +/* *INDENT-ON* */ +} + +void +vl_socket_api_send (vl_api_registration_t * rp, u8 * elem) +{ + u32 nbytes = 4; /* for the length... */ + u16 msg_id = ntohs (*(u16 *) elem); + u32 msg_length; + u32 tmp; + api_main_t *am = &api_main; + + ASSERT (rp->registration_type > REGISTRATION_TYPE_SHMEM); + + if (msg_id >= vec_len (am->api_trace_cfg)) + { + clib_warning ("id out of range: %d", msg_id); + vl_msg_api_free ((void *) elem); + return; + } + + msg_length = am->api_trace_cfg[msg_id].size; + nbytes += msg_length; + tmp = clib_host_to_net_u32 (nbytes); + + vl_socket_add_pending_output (rp->unix_file_index + + unix_main.file_pool, + rp->vl_api_registration_pool_index + + socket_main.registration_pool, + (u8 *) & tmp, sizeof (tmp)); + vl_socket_add_pending_output (rp->unix_file_index + + unix_main.file_pool, + rp->vl_api_registration_pool_index + + socket_main.registration_pool, + elem, msg_length); + vl_msg_api_free ((void *) elem); +} + +void +vl_socket_api_send_with_data (vl_api_registration_t * rp, + u8 * elem, u8 * data_vector) +{ + u32 nbytes = 4; /* for the length... */ + u16 msg_id = ntohs (*(u16 *) elem); + u32 msg_length; + u32 tmp; + api_main_t *am = &api_main; + + ASSERT (rp->registration_type > REGISTRATION_TYPE_SHMEM); + + if (msg_id >= vec_len (am->api_trace_cfg)) + { + clib_warning ("id out of range: %d", msg_id); + vec_free (data_vector); + vl_msg_api_free ((void *) elem); + return; + } + + msg_length = am->api_trace_cfg[msg_id].size; + nbytes += msg_length; + nbytes += vec_len (data_vector); + + /* Length in network byte order */ + tmp = clib_host_to_net_u32 (nbytes); + + vl_socket_add_pending_output (rp->unix_file_index + + unix_main.file_pool, + rp->vl_api_registration_pool_index + + socket_main.registration_pool, + (u8 *) & tmp, sizeof (tmp)); + vl_socket_add_pending_output (rp->unix_file_index + + unix_main.file_pool, + rp->vl_api_registration_pool_index + + socket_main.registration_pool, + elem, msg_length); + vl_socket_add_pending_output (rp->unix_file_index + + unix_main.file_pool, + rp->vl_api_registration_pool_index + + socket_main.registration_pool, + data_vector, vec_len (data_vector)); + vl_msg_api_free ((void *) elem); +} + +static inline void +vl_socket_api_send_with_length_internal (vl_api_registration_t * rp, + u8 * elem, u32 msg_length, int free) +{ + u32 nbytes = 4; /* for the length... */ + u16 msg_id = ntohs (*(u16 *) elem); + u32 tmp; + api_main_t *am = &api_main; + + ASSERT (rp->registration_type > REGISTRATION_TYPE_SHMEM); + + if (msg_id >= vec_len (am->api_trace_cfg)) + { + clib_warning ("id out of range: %d", msg_id); + if (free) + vl_msg_api_free ((void *) elem); + return; + } + + nbytes += msg_length; + + /* Length in network byte order */ + tmp = clib_host_to_net_u32 (nbytes); + + vl_socket_add_pending_output (rp->unix_file_index + + unix_main.file_pool, + rp->vl_api_registration_pool_index + + socket_main.registration_pool, + (u8 *) & tmp, sizeof (tmp)); + vl_socket_add_pending_output (rp->unix_file_index + + unix_main.file_pool, + rp->vl_api_registration_pool_index + + socket_main.registration_pool, + elem, msg_length); + if (free) + vl_msg_api_free ((void *) elem); +} + +void +vl_socket_api_send_with_length (vl_api_registration_t * rp, + u8 * elem, u32 msg_length) +{ + vl_socket_api_send_with_length_internal (rp, elem, msg_length, + 1 /* free */ ); +} + +void +vl_socket_api_send_with_length_no_free (vl_api_registration_t * rp, + u8 * elem, u32 msg_length) +{ + vl_socket_api_send_with_length_internal (rp, elem, msg_length, + 0 /* free */ ); +} + +void +vl_free_socket_registration_index (u32 pool_index) +{ + vl_api_registration_t *rp; + if (pool_is_free_index (socket_main.registration_pool, pool_index)) + { + clib_warning ("main pool index %d already free", pool_index); + return; + } + rp = pool_elt_at_index (socket_main.registration_pool, pool_index); + + ASSERT (rp->registration_type != REGISTRATION_TYPE_FREE); + vec_free (rp->name); + vec_free (rp->unprocessed_input); + vec_free (rp->output_vector); + rp->registration_type = REGISTRATION_TYPE_FREE; + pool_put (socket_main.registration_pool, rp); +} + +static inline void +socket_process_msg (unix_file_t * uf, vl_api_registration_t * rp, + i8 * input_v) +{ + u8 *the_msg = (u8 *) (input_v + sizeof (u32)); + socket_main.current_uf = uf; + socket_main.current_rp = rp; + vl_msg_api_socket_handler (the_msg); + socket_main.current_uf = 0; + socket_main.current_rp = 0; +} + +clib_error_t * +vl_socket_read_ready (unix_file_t * uf) +{ + unix_main_t *um = &unix_main; + vl_api_registration_t *rp; + int n; + i8 *msg_buffer = 0; + u32 msg_len; + u32 save_input_buffer_length = vec_len (socket_main.input_buffer); + + rp = pool_elt_at_index (socket_main.registration_pool, uf->private_data); + + n = read (uf->file_descriptor, socket_main.input_buffer, + vec_len (socket_main.input_buffer)); + + if (n <= 0 && errno != EAGAIN) + { + unix_file_del (um, uf); + + if (!pool_is_free (socket_main.registration_pool, rp)) + { + u32 index = rp - socket_main.registration_pool; + vl_free_socket_registration_index (index); + } + else + { + clib_warning ("client index %d already free?", + rp->vl_api_registration_pool_index); + } + return 0; + } + + _vec_len (socket_main.input_buffer) = n; + + /* + * Look for bugs here. This code is tricky because + * data read from a stream socket does honor message + * boundaries. In the case of a long message (>4K bytes) + * we have to do (at least) 2 reads, etc. + */ + do + { + if (vec_len (rp->unprocessed_input)) + { + vec_append (rp->unprocessed_input, socket_main.input_buffer); + msg_buffer = rp->unprocessed_input; + msg_len = rp->unprocessed_msg_length; + } + else + { + msg_buffer = socket_main.input_buffer; + msg_len = 0; + } + + if (msg_len == 0) + { + /* Length may be split across two reads */ + if (vec_len (msg_buffer) < sizeof (u32)) + goto save_and_split; + + /* total length, including msg_len itself, in network byte order */ + msg_len = clib_net_to_host_u32 (*((u32 *) msg_buffer)); + } + + /* Happens if the client sent msg_len == 0 */ + if (msg_len == 0) + { + clib_warning ("msg_len == 0"); + goto turf_it; + } + + /* We don't have the entire message yet. */ + if (msg_len > vec_len (msg_buffer)) + { + save_and_split: + /* + * if we were using the shared input buffer, + * save the fragment. + */ + if (msg_buffer == socket_main.input_buffer) + { + ASSERT (vec_len (rp->unprocessed_input) == 0); + vec_validate (rp->unprocessed_input, vec_len (msg_buffer) - 1); + clib_memcpy (rp->unprocessed_input, msg_buffer, + vec_len (msg_buffer)); + _vec_len (rp->unprocessed_input) = vec_len (msg_buffer); + } + _vec_len (socket_main.input_buffer) = save_input_buffer_length; + rp->unprocessed_msg_length = msg_len; + return 0; + } + + socket_process_msg (uf, rp, msg_buffer); + if (n > msg_len) + vec_delete (msg_buffer, msg_len, 0); + else + _vec_len (msg_buffer) = 0; + n -= msg_len; + msg_len = 0; + rp->unprocessed_msg_length = 0; + } + while (n > 0); + +turf_it: + _vec_len (socket_main.input_buffer) = save_input_buffer_length; + + return 0; +} + +void +vl_socket_add_pending_output (unix_file_t * uf, + vl_api_registration_t * rp, + u8 * buffer, uword buffer_bytes) +{ + unix_main_t *um = &unix_main; + + vec_add (rp->output_vector, buffer, buffer_bytes); + if (vec_len (rp->output_vector) > 0) + { + int skip_update = 0 != (uf->flags & UNIX_FILE_DATA_AVAILABLE_TO_WRITE); + uf->flags |= UNIX_FILE_DATA_AVAILABLE_TO_WRITE; + if (!skip_update) + um->file_update (uf, UNIX_FILE_UPDATE_MODIFY); + } +} + +static void +socket_del_pending_output (unix_file_t * uf, + vl_api_registration_t * rp, uword n_bytes) +{ + unix_main_t *um = &unix_main; + + vec_delete (rp->output_vector, n_bytes, 0); + if (vec_len (rp->output_vector) <= 0) + { + int skip_update = 0 == (uf->flags & UNIX_FILE_DATA_AVAILABLE_TO_WRITE); + uf->flags &= ~UNIX_FILE_DATA_AVAILABLE_TO_WRITE; + if (!skip_update) + um->file_update (uf, UNIX_FILE_UPDATE_MODIFY); + } +} + +clib_error_t * +vl_socket_write_ready (unix_file_t * uf) +{ + unix_main_t *um = &unix_main; + vl_api_registration_t *rp; + int n; + + rp = pool_elt_at_index (socket_main.registration_pool, uf->private_data); + + /* Flush output vector. */ + n = write (uf->file_descriptor, + rp->output_vector, vec_len (rp->output_vector)); + + if (n < 0) + { +#if DEBUG > 2 + clib_warning ("write error, close the file...\n"); +#endif + unix_file_del (um, uf); + + vl_free_socket_registration_index (rp - socket_main.registration_pool); + return 0; + } + + else if (n > 0) + socket_del_pending_output (uf, rp, n); + + return 0; +} + +clib_error_t * +vl_socket_error_ready (unix_file_t * uf) +{ + vl_api_registration_t *rp; + unix_main_t *um = &unix_main; + + rp = pool_elt_at_index (socket_main.registration_pool, uf->private_data); + unix_file_del (um, uf); + vl_free_socket_registration_index (rp - socket_main.registration_pool); + + return 0; +} + +void +socksvr_file_add (unix_main_t * um, int fd) +{ + vl_api_registration_t *rp; + unix_file_t template = { 0 }; + + pool_get (socket_main.registration_pool, rp); + memset (rp, 0, sizeof (*rp)); + + template.read_function = vl_socket_read_ready; + template.write_function = vl_socket_write_ready; + template.error_function = vl_socket_error_ready; + template.file_descriptor = fd; + template.private_data = rp - socket_main.registration_pool; + + rp->registration_type = REGISTRATION_TYPE_SOCKET_SERVER; + rp->vl_api_registration_pool_index = rp - socket_main.registration_pool; + rp->unix_file_index = unix_file_add (um, &template); +} + +static clib_error_t * +socksvr_accept_ready (unix_file_t * uf) +{ + unix_main_t *um = &unix_main; + struct sockaddr_in client_addr; + int client_fd; + int client_len; + + client_len = sizeof (client_addr); + + /* + * Supposedly acquires the non-blocking attrib from the + * server socket. + */ + client_fd = accept (uf->file_descriptor, + (struct sockaddr *) &client_addr, + (socklen_t *) & client_len); + + if (client_fd < 0) + return clib_error_return_unix (0, "socksvr_accept_ready: accept"); + + socksvr_file_add (um, client_fd); + return 0; +} + +static clib_error_t * +socksvr_bogus_write (unix_file_t * uf) +{ + clib_warning ("why am I here?"); + return 0; +} + +/* + * vl_api_sockclnt_create_t_handler + */ +void +vl_api_sockclnt_create_t_handler (vl_api_sockclnt_create_t * mp) +{ + vl_api_registration_t *regp; + vl_api_sockclnt_create_reply_t *rp; + int rv = 1; + + regp = socket_main.current_rp; + + ASSERT (regp->registration_type == REGISTRATION_TYPE_SOCKET_SERVER); + + regp->name = format (0, "%s%c", mp->name, 0); + + rp = vl_msg_api_alloc (sizeof (*rp)); + rp->_vl_msg_id = htons (VL_API_SOCKCLNT_CREATE_REPLY); + rp->handle = (uword) regp; + rp->index = (uword) regp->vl_api_registration_pool_index; + rp->context = mp->context; + rp->response = htonl (rv); + + vl_msg_api_send (regp, (u8 *) rp); +} + +/* + * vl_api_sockclnt_delete_t_handler + */ +void +vl_api_sockclnt_delete_t_handler (vl_api_sockclnt_delete_t * mp) +{ + vl_api_registration_t *regp; + vl_api_sockclnt_delete_reply_t *rp; + + if (!pool_is_free_index (socket_main.registration_pool, mp->index)) + { + regp = pool_elt_at_index (socket_main.registration_pool, mp->index); + + rp = vl_msg_api_alloc (sizeof (*rp)); + rp->_vl_msg_id = htons (VL_API_SOCKCLNT_DELETE_REPLY); + rp->handle = mp->handle; + rp->response = htonl (1); + + vl_msg_api_send (regp, (u8 *) rp); + + unix_file_del (&unix_main, unix_main.file_pool + regp->unix_file_index); + + vl_free_socket_registration_index (mp->index); + } + else + { + clib_warning ("unknown client ID %d", mp->index); + } +} + +#define foreach_vlib_api_msg \ +_(SOCKCLNT_CREATE, sockclnt_create) \ +_(SOCKCLNT_DELETE, sockclnt_delete) + +static clib_error_t * +socksvr_api_init (vlib_main_t * vm) +{ + unix_main_t *um = &unix_main; + unix_file_t template = { 0 }; + int sockfd; + int one = 1; + int rv; + struct sockaddr_in serv_addr; + vl_api_registration_t *rp; + u16 portno; + u32 bind_address; + +#define _(N,n) \ + vl_msg_api_set_handlers(VL_API_##N, #n, \ + vl_api_##n##_t_handler, \ + vl_noop_handler, \ + vl_api_##n##_t_endian, \ + vl_api_##n##_t_print, \ + sizeof(vl_api_##n##_t), 1); + foreach_vlib_api_msg; +#undef _ + + vec_resize (socket_main.input_buffer, 4096); + + /* Set up non-blocking server socket on CLIENT_API_SERVER_PORT */ + sockfd = socket (AF_INET, SOCK_STREAM, 0); + + if (sockfd < 0) + { + return clib_error_return_unix (0, "socket"); + } + + rv = ioctl (sockfd, FIONBIO, &one); + if (rv < 0) + { + close (sockfd); + return clib_error_return_unix (0, "FIONBIO"); + } + + rv = setsockopt (sockfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof (one)); + if (rv < 0) + { + close (sockfd); + return clib_error_return_unix (0, "SO_REUSEADDR"); + } + + bzero ((char *) &serv_addr, sizeof (serv_addr)); + serv_addr.sin_family = AF_INET; + + if (socket_main.bind_address) + bind_address = socket_main.bind_address; + else + bind_address = INADDR_LOOPBACK; + + if (socket_main.portno) + portno = socket_main.portno; + else + portno = SOCKSVR_DEFAULT_PORT; + + serv_addr.sin_port = clib_host_to_net_u16 (portno); + serv_addr.sin_addr.s_addr = clib_host_to_net_u32 (bind_address); + + if (bind (sockfd, (struct sockaddr *) &serv_addr, sizeof (serv_addr)) < 0) + { + close (sockfd); + return clib_error_return_unix (0, "bind"); + } + + rv = listen (sockfd, 5); + if (rv < 0) + { + close (sockfd); + return clib_error_return_unix (0, "listen"); + } + + pool_get (socket_main.registration_pool, rp); + memset (rp, 0, sizeof (*rp)); + + rp->registration_type = REGISTRATION_TYPE_SOCKET_LISTEN; + + template.read_function = socksvr_accept_ready; + template.write_function = socksvr_bogus_write; + template.file_descriptor = sockfd; + template.private_data = rp - socket_main.registration_pool; + + rp->unix_file_index = unix_file_add (um, &template); + return 0; +} + +static clib_error_t * +socket_exit (vlib_main_t * vm) +{ + unix_main_t *um = &unix_main; + vl_api_registration_t *rp; + + /* Defensive driving in case something wipes out early */ + if (socket_main.registration_pool) + { + u32 index; + /* *INDENT-OFF* */ + pool_foreach (rp, socket_main.registration_pool, ({ + unix_file_del (um, um->file_pool + rp->unix_file_index); + index = rp->vl_api_registration_pool_index; + vl_free_socket_registration_index (index); + })); +/* *INDENT-ON* */ + } + + return 0; +} + +VLIB_MAIN_LOOP_EXIT_FUNCTION (socket_exit); + +static clib_error_t * +socksvr_config (vlib_main_t * vm, unformat_input_t * input) +{ + int portno; + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "port %d", &portno)) + { + socket_main.portno = portno; + } + else + { + return clib_error_return (0, "unknown input '%U'", + format_unformat_error, input); + } + } + return socksvr_api_init (vm); +} + +VLIB_CONFIG_FUNCTION (socksvr_config, "socksvr"); + +/* argument in host byte order */ +void +socksvr_set_port (u16 port) +{ + socket_main.portno = port; +} + +/* argument in host byte order */ +void +socksvr_set_bind_address (u32 bind_address) +{ + socket_main.bind_address = bind_address; +} + +clib_error_t * +vlibsocket_init (vlib_main_t * vm) +{ + return 0; +} + +VLIB_INIT_FUNCTION (vlibsocket_init); + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vpp/vlib-api/vlibsocket/vl_socket_api_h.h b/vpp/vlib-api/vlibsocket/vl_socket_api_h.h new file mode 100644 index 00000000..7fc53cef --- /dev/null +++ b/vpp/vlib-api/vlibsocket/vl_socket_api_h.h @@ -0,0 +1,33 @@ +/* + *------------------------------------------------------------------ + * vl_socket_api_h.h - all API headers, in a specific order. + * + * 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. + *------------------------------------------------------------------ + */ + +/* + * Add to the bottom of the #include list, or elves will steal your + * keyboard in the middle of the night! + */ +#include <vlibmemory/vl_memory_api_h.h> +#include <vlibsocket/sockclnt.api.h> + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vpp/vlib-api/vlibsocket/vl_socket_msg_enum.h b/vpp/vlib-api/vlibsocket/vl_socket_msg_enum.h new file mode 100644 index 00000000..cdc61a5b --- /dev/null +++ b/vpp/vlib-api/vlibsocket/vl_socket_msg_enum.h @@ -0,0 +1,42 @@ +/* + *------------------------------------------------------------------ + * vl_msg_enum.h - Our view of how to number API messages + * Clients have their own view, which has to agree with ours. + * + * 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. + *------------------------------------------------------------------ + */ + +#ifndef __VL_MSG_ENUM_H__ +#define __VL_MSG_ENUM_H__ + +#include <vppinfra/byte_order.h> + +#define vl_msg_id(n,h) n, +typedef enum +{ + VL_ILLEGAL_MESSAGE_ID = 0, +#include <vlibsocket/vl_socket_api_h.h> +} vl_msg_id_t; +#undef vl_msg_id + +#endif /* __VL_MSG_ENUM_H__ */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ |