Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2017 Cisco and/or its affiliates. |
| 3 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 | * you may not use this file except in compliance with the License. |
| 5 | * You may obtain a copy of the License at: |
| 6 | * |
| 7 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 8 | * |
| 9 | * Unless required by applicable law or agreed to in writing, software |
| 10 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 11 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 | * See the License for the specific language governing permissions and |
| 13 | * limitations under the License. |
| 14 | */ |
| 15 | |
| 16 | #include <vnet/session/application.h> |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 17 | #include <vnet/session/application_interface.h> |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 18 | #include <vnet/session/application_namespace.h> |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 19 | #include <vnet/session/session.h> |
| 20 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 21 | /** |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 22 | * Pool from which we allocate all applications |
| 23 | */ |
| 24 | static application_t *app_pool; |
| 25 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 26 | /** |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 27 | * Hash table of apps by api client index |
| 28 | */ |
| 29 | static uword *app_by_api_client_index; |
| 30 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 31 | /** |
| 32 | * Default application event queue size |
| 33 | */ |
| 34 | static u32 default_app_evt_queue_size = 128; |
| 35 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 36 | static u8 * |
| 37 | app_get_name_from_reg_index (application_t * app) |
| 38 | { |
| 39 | u8 *app_name; |
| 40 | |
| 41 | vl_api_registration_t *regp; |
| 42 | regp = vl_api_client_index_to_registration (app->api_client_index); |
| 43 | if (!regp) |
| 44 | app_name = format (0, "builtin-%d%c", app->index, 0); |
| 45 | else |
| 46 | app_name = format (0, "%s%c", regp->name, 0); |
| 47 | |
| 48 | return app_name; |
| 49 | } |
| 50 | |
| 51 | u32 |
| 52 | application_session_table (application_t * app, u8 fib_proto) |
| 53 | { |
| 54 | app_namespace_t *app_ns; |
| 55 | app_ns = app_namespace_get (app->ns_index); |
| 56 | if (!application_has_global_scope (app)) |
| 57 | return APP_INVALID_INDEX; |
| 58 | if (fib_proto == FIB_PROTOCOL_IP4) |
| 59 | return session_lookup_get_index_for_fib (fib_proto, |
| 60 | app_ns->ip4_fib_index); |
| 61 | else |
| 62 | return session_lookup_get_index_for_fib (fib_proto, |
| 63 | app_ns->ip6_fib_index); |
| 64 | } |
| 65 | |
| 66 | u32 |
| 67 | application_local_session_table (application_t * app) |
| 68 | { |
| 69 | app_namespace_t *app_ns; |
| 70 | if (!application_has_local_scope (app)) |
| 71 | return APP_INVALID_INDEX; |
| 72 | app_ns = app_namespace_get (app->ns_index); |
| 73 | return app_ns->local_table_index; |
| 74 | } |
| 75 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 76 | int |
| 77 | application_api_queue_is_full (application_t * app) |
| 78 | { |
| 79 | unix_shared_memory_queue_t *q; |
| 80 | |
| 81 | /* builtin servers are always OK */ |
| 82 | if (app->api_client_index == ~0) |
| 83 | return 0; |
| 84 | |
| 85 | q = vl_api_client_index_to_input_queue (app->api_client_index); |
| 86 | if (!q) |
| 87 | return 1; |
| 88 | |
| 89 | if (q->cursize == q->maxsize) |
| 90 | return 1; |
| 91 | return 0; |
| 92 | } |
| 93 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 94 | /** |
| 95 | * Returns app name |
| 96 | * |
| 97 | * Since the name is not stored per app, we generate it on the fly. It is |
| 98 | * the caller's responsibility to free the vector |
| 99 | */ |
| 100 | u8 * |
| 101 | application_name_from_index (u32 app_index) |
| 102 | { |
| 103 | application_t *app = application_get (app_index); |
| 104 | if (!app) |
| 105 | return 0; |
| 106 | return app_get_name_from_reg_index (app); |
| 107 | } |
| 108 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 109 | static void |
| 110 | application_table_add (application_t * app) |
| 111 | { |
| 112 | hash_set (app_by_api_client_index, app->api_client_index, app->index); |
| 113 | } |
| 114 | |
| 115 | static void |
| 116 | application_table_del (application_t * app) |
| 117 | { |
| 118 | hash_unset (app_by_api_client_index, app->api_client_index); |
| 119 | } |
| 120 | |
| 121 | application_t * |
| 122 | application_lookup (u32 api_client_index) |
| 123 | { |
| 124 | uword *p; |
| 125 | p = hash_get (app_by_api_client_index, api_client_index); |
| 126 | if (p) |
| 127 | return application_get (p[0]); |
| 128 | |
| 129 | return 0; |
| 130 | } |
| 131 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 132 | application_t * |
| 133 | application_new () |
| 134 | { |
| 135 | application_t *app; |
| 136 | pool_get (app_pool, app); |
| 137 | memset (app, 0, sizeof (*app)); |
| 138 | app->index = application_get_index (app); |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 139 | app->connects_seg_manager = APP_INVALID_SEGMENT_MANAGER_INDEX; |
| 140 | app->first_segment_manager = APP_INVALID_SEGMENT_MANAGER_INDEX; |
Dave Wallace | 7b749fe | 2017-07-05 14:30:46 -0400 | [diff] [blame] | 141 | if (CLIB_DEBUG > 1) |
| 142 | clib_warning ("[%d] New app (%d)", getpid (), app->index); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 143 | return app; |
| 144 | } |
| 145 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 146 | void |
| 147 | application_del (application_t * app) |
| 148 | { |
Florin Coras | ad0c77f | 2017-11-09 18:00:15 -0800 | [diff] [blame] | 149 | segment_manager_properties_t *props; |
| 150 | vnet_unbind_args_t _a, *a = &_a; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 151 | segment_manager_t *sm; |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 152 | u64 handle, *handles = 0; |
| 153 | u32 index; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 154 | int i; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 155 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 156 | /* |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 157 | * The app event queue allocated in first segment is cleared with |
| 158 | * the segment manager. No need to explicitly free it. |
| 159 | */ |
Dave Wallace | 7b749fe | 2017-07-05 14:30:46 -0400 | [diff] [blame] | 160 | if (CLIB_DEBUG > 1) |
| 161 | clib_warning ("[%d] Delete app (%d)", getpid (), app->index); |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 162 | |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 163 | if (application_is_proxy (app)) |
| 164 | application_remove_proxy (app); |
| 165 | |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 166 | /* |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 167 | * Listener cleanup |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 168 | */ |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 169 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 170 | /* *INDENT-OFF* */ |
| 171 | hash_foreach (handle, index, app->listeners_table, |
| 172 | ({ |
| 173 | vec_add1 (handles, handle); |
Florin Coras | 9d06304 | 2017-09-14 03:08:00 -0400 | [diff] [blame] | 174 | sm = segment_manager_get (index); |
| 175 | sm->app_index = SEGMENT_MANAGER_INVALID_APP_INDEX; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 176 | })); |
| 177 | /* *INDENT-ON* */ |
| 178 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 179 | for (i = 0; i < vec_len (handles); i++) |
| 180 | { |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 181 | a->app_index = app->index; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 182 | a->handle = handles[i]; |
| 183 | /* seg manager is removed when unbind completes */ |
| 184 | vnet_unbind (a); |
| 185 | } |
| 186 | |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 187 | /* |
| 188 | * Connects segment manager cleanup |
| 189 | */ |
| 190 | |
| 191 | if (app->connects_seg_manager != APP_INVALID_SEGMENT_MANAGER_INDEX) |
| 192 | { |
| 193 | sm = segment_manager_get (app->connects_seg_manager); |
| 194 | sm->app_index = SEGMENT_MANAGER_INVALID_APP_INDEX; |
| 195 | segment_manager_init_del (sm); |
| 196 | } |
| 197 | |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 198 | /* If first segment manager is used by a listener */ |
| 199 | if (app->first_segment_manager != APP_INVALID_SEGMENT_MANAGER_INDEX |
| 200 | && app->first_segment_manager != app->connects_seg_manager) |
Dave Wallace | 7b749fe | 2017-07-05 14:30:46 -0400 | [diff] [blame] | 201 | { |
| 202 | sm = segment_manager_get (app->first_segment_manager); |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 203 | /* .. and has no fifos, e.g. it might be used for redirected sessions, |
| 204 | * remove it */ |
| 205 | if (!segment_manager_has_fifos (sm)) |
| 206 | { |
| 207 | sm->app_index = SEGMENT_MANAGER_INVALID_APP_INDEX; |
| 208 | segment_manager_del (sm); |
| 209 | } |
Dave Wallace | 7b749fe | 2017-07-05 14:30:46 -0400 | [diff] [blame] | 210 | } |
Florin Coras | ad0c77f | 2017-11-09 18:00:15 -0800 | [diff] [blame] | 211 | props = segment_manager_properties_get (app->sm_properties); |
| 212 | segment_manager_properties_free (props); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 213 | application_table_del (app); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 214 | pool_put (app_pool, app); |
| 215 | } |
| 216 | |
Florin Coras | d79b41e | 2017-03-04 05:37:52 -0800 | [diff] [blame] | 217 | static void |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 218 | application_verify_cb_fns (session_cb_vft_t * cb_fns) |
Florin Coras | d79b41e | 2017-03-04 05:37:52 -0800 | [diff] [blame] | 219 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 220 | if (cb_fns->session_accept_callback == 0) |
Florin Coras | d79b41e | 2017-03-04 05:37:52 -0800 | [diff] [blame] | 221 | clib_warning ("No accept callback function provided"); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 222 | if (cb_fns->session_connected_callback == 0) |
Florin Coras | d79b41e | 2017-03-04 05:37:52 -0800 | [diff] [blame] | 223 | clib_warning ("No session connected callback function provided"); |
| 224 | if (cb_fns->session_disconnect_callback == 0) |
| 225 | clib_warning ("No session disconnect callback function provided"); |
| 226 | if (cb_fns->session_reset_callback == 0) |
| 227 | clib_warning ("No session reset callback function provided"); |
| 228 | } |
| 229 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 230 | int |
| 231 | application_init (application_t * app, u32 api_client_index, u64 * options, |
| 232 | session_cb_vft_t * cb_fns) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 233 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 234 | segment_manager_t *sm; |
| 235 | segment_manager_properties_t *props; |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 236 | u32 app_evt_queue_size, first_seg_size; |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 237 | u32 default_rx_fifo_size = 16 << 10, default_tx_fifo_size = 16 << 10; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 238 | int rv; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 239 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 240 | app_evt_queue_size = options[APP_EVT_QUEUE_SIZE] > 0 ? |
| 241 | options[APP_EVT_QUEUE_SIZE] : default_app_evt_queue_size; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 242 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 243 | /* |
| 244 | * Setup segment manager |
| 245 | */ |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 246 | sm = segment_manager_new (); |
| 247 | sm->app_index = app->index; |
Florin Coras | ad0c77f | 2017-11-09 18:00:15 -0800 | [diff] [blame] | 248 | props = segment_manager_properties_alloc (); |
| 249 | app->sm_properties = segment_manager_properties_index (props); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 250 | props->add_segment_size = options[SESSION_OPTIONS_ADD_SEGMENT_SIZE]; |
| 251 | props->rx_fifo_size = options[SESSION_OPTIONS_RX_FIFO_SIZE]; |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 252 | props->rx_fifo_size = |
| 253 | props->rx_fifo_size ? props->rx_fifo_size : default_rx_fifo_size; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 254 | props->tx_fifo_size = options[SESSION_OPTIONS_TX_FIFO_SIZE]; |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 255 | props->tx_fifo_size = |
| 256 | props->tx_fifo_size ? props->tx_fifo_size : default_tx_fifo_size; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 257 | props->add_segment = props->add_segment_size != 0; |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 258 | props->preallocated_fifo_pairs = options[APP_OPTIONS_PREALLOC_FIFO_PAIRS]; |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 259 | props->use_private_segment = options[APP_OPTIONS_FLAGS] |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 260 | & APP_OPTIONS_FLAGS_IS_BUILTIN; |
Dave Barach | 2c25a62 | 2017-06-26 11:35:07 -0400 | [diff] [blame] | 261 | props->private_segment_count = options[APP_OPTIONS_PRIVATE_SEGMENT_COUNT]; |
| 262 | props->private_segment_size = options[APP_OPTIONS_PRIVATE_SEGMENT_SIZE]; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 263 | |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 264 | first_seg_size = options[SESSION_OPTIONS_SEGMENT_SIZE]; |
Florin Coras | ad0c77f | 2017-11-09 18:00:15 -0800 | [diff] [blame] | 265 | if ((rv = segment_manager_init (sm, app->sm_properties, first_seg_size))) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 266 | return rv; |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 267 | sm->first_is_protected = 1; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 268 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 269 | /* |
| 270 | * Setup application |
| 271 | */ |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 272 | app->first_segment_manager = segment_manager_index (sm); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 273 | app->api_client_index = api_client_index; |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 274 | app->flags = options[APP_OPTIONS_FLAGS]; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 275 | app->cb_fns = *cb_fns; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 276 | app->ns_index = options[APP_OPTIONS_NAMESPACE]; |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 277 | app->listeners_table = hash_create (0, sizeof (u64)); |
| 278 | app->proxied_transports = options[APP_OPTIONS_PROXY_TRANSPORT]; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 279 | |
| 280 | /* If no scope enabled, default to global */ |
| 281 | if (!application_has_global_scope (app) |
| 282 | && !application_has_local_scope (app)) |
| 283 | app->flags |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 284 | |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 285 | /* Allocate app event queue in the first shared-memory segment */ |
| 286 | app->event_queue = segment_manager_alloc_queue (sm, app_evt_queue_size); |
| 287 | |
Florin Coras | d79b41e | 2017-03-04 05:37:52 -0800 | [diff] [blame] | 288 | /* Check that the obvious things are properly set up */ |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 289 | application_verify_cb_fns (cb_fns); |
Florin Coras | d79b41e | 2017-03-04 05:37:52 -0800 | [diff] [blame] | 290 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 291 | /* Add app to lookup by api_client_index table */ |
| 292 | application_table_add (app); |
| 293 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 294 | return 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 295 | } |
| 296 | |
| 297 | application_t * |
| 298 | application_get (u32 index) |
| 299 | { |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 300 | if (index == APP_INVALID_INDEX) |
| 301 | return 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 302 | return pool_elt_at_index (app_pool, index); |
| 303 | } |
| 304 | |
Florin Coras | e04c299 | 2017-03-01 08:17:34 -0800 | [diff] [blame] | 305 | application_t * |
| 306 | application_get_if_valid (u32 index) |
| 307 | { |
| 308 | if (pool_is_free_index (app_pool, index)) |
| 309 | return 0; |
| 310 | |
| 311 | return pool_elt_at_index (app_pool, index); |
| 312 | } |
| 313 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 314 | u32 |
| 315 | application_get_index (application_t * app) |
| 316 | { |
| 317 | return app - app_pool; |
| 318 | } |
| 319 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 320 | static segment_manager_t * |
| 321 | application_alloc_segment_manager (application_t * app) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 322 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 323 | segment_manager_t *sm = 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 324 | |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 325 | /* If the first segment manager is not in use, don't allocate a new one */ |
| 326 | if (app->first_segment_manager != APP_INVALID_SEGMENT_MANAGER_INDEX |
Florin Coras | 0e9c33b | 2017-08-14 22:33:41 -0700 | [diff] [blame] | 327 | && app->first_segment_manager_in_use == 0) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 328 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 329 | sm = segment_manager_get (app->first_segment_manager); |
Florin Coras | 0e9c33b | 2017-08-14 22:33:41 -0700 | [diff] [blame] | 330 | app->first_segment_manager_in_use = 1; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 331 | return sm; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 332 | } |
| 333 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 334 | sm = segment_manager_new (); |
Florin Coras | ad0c77f | 2017-11-09 18:00:15 -0800 | [diff] [blame] | 335 | sm->properties_index = app->sm_properties; |
Florin Coras | 0e9c33b | 2017-08-14 22:33:41 -0700 | [diff] [blame] | 336 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 337 | return sm; |
| 338 | } |
| 339 | |
| 340 | /** |
| 341 | * Start listening local transport endpoint for requested transport. |
| 342 | * |
| 343 | * Creates a 'dummy' stream session with state LISTENING to be used in session |
| 344 | * lookups, prior to establishing connection. Requests transport to build |
| 345 | * it's own specific listening connection. |
| 346 | */ |
| 347 | int |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 348 | application_start_listen (application_t * srv, session_endpoint_t * sep, |
| 349 | u64 * res) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 350 | { |
| 351 | segment_manager_t *sm; |
| 352 | stream_session_t *s; |
| 353 | u64 handle; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 354 | session_type_t sst; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 355 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 356 | sst = session_type_from_proto_and_ip (sep->transport_proto, sep->is_ip4); |
| 357 | s = listen_session_new (sst); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 358 | s->app_index = srv->index; |
| 359 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 360 | if (stream_session_listen (s, sep)) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 361 | goto err; |
| 362 | |
| 363 | /* Allocate segment manager. All sessions derived out of a listen session |
| 364 | * have fifos allocated by the same segment manager. */ |
| 365 | sm = application_alloc_segment_manager (srv); |
| 366 | if (sm == 0) |
| 367 | goto err; |
| 368 | |
| 369 | /* Add to app's listener table. Useful to find all child listeners |
| 370 | * when app goes down, although, just for unbinding this is not needed */ |
| 371 | handle = listen_session_get_handle (s); |
| 372 | hash_set (srv->listeners_table, handle, segment_manager_index (sm)); |
| 373 | |
| 374 | *res = handle; |
| 375 | return 0; |
| 376 | |
| 377 | err: |
| 378 | listen_session_del (s); |
| 379 | return -1; |
| 380 | } |
| 381 | |
| 382 | /** |
| 383 | * Stop listening on session associated to handle |
| 384 | */ |
| 385 | int |
| 386 | application_stop_listen (application_t * srv, u64 handle) |
| 387 | { |
| 388 | stream_session_t *listener; |
| 389 | uword *indexp; |
| 390 | segment_manager_t *sm; |
| 391 | |
| 392 | if (srv && hash_get (srv->listeners_table, handle) == 0) |
| 393 | { |
| 394 | clib_warning ("app doesn't own handle %llu!", handle); |
| 395 | return -1; |
| 396 | } |
| 397 | |
| 398 | listener = listen_session_get_from_handle (handle); |
| 399 | stream_session_stop_listen (listener); |
| 400 | |
| 401 | indexp = hash_get (srv->listeners_table, handle); |
| 402 | ASSERT (indexp); |
| 403 | |
| 404 | sm = segment_manager_get (*indexp); |
Florin Coras | 0e9c33b | 2017-08-14 22:33:41 -0700 | [diff] [blame] | 405 | if (srv->first_segment_manager == *indexp) |
| 406 | { |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 407 | /* Delete sessions but don't remove segment manager */ |
Florin Coras | 0e9c33b | 2017-08-14 22:33:41 -0700 | [diff] [blame] | 408 | srv->first_segment_manager_in_use = 0; |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 409 | segment_manager_del_sessions (sm); |
| 410 | } |
| 411 | else |
| 412 | { |
| 413 | segment_manager_init_del (sm); |
Florin Coras | 0e9c33b | 2017-08-14 22:33:41 -0700 | [diff] [blame] | 414 | } |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 415 | hash_unset (srv->listeners_table, handle); |
| 416 | listen_session_del (listener); |
| 417 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 418 | return 0; |
| 419 | } |
| 420 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 421 | int |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 422 | application_open_session (application_t * app, session_endpoint_t * sep, |
| 423 | u32 api_context) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 424 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 425 | segment_manager_t *sm; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 426 | int rv; |
| 427 | |
| 428 | /* Make sure we have a segment manager for connects */ |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 429 | if (app->connects_seg_manager == APP_INVALID_SEGMENT_MANAGER_INDEX) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 430 | { |
| 431 | sm = application_alloc_segment_manager (app); |
| 432 | if (sm == 0) |
| 433 | return -1; |
| 434 | app->connects_seg_manager = segment_manager_index (sm); |
| 435 | } |
| 436 | |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 437 | if ((rv = session_open (app->index, sep, api_context))) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 438 | return rv; |
| 439 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 440 | return 0; |
| 441 | } |
| 442 | |
| 443 | segment_manager_t * |
| 444 | application_get_connect_segment_manager (application_t * app) |
| 445 | { |
| 446 | ASSERT (app->connects_seg_manager != (u32) ~ 0); |
| 447 | return segment_manager_get (app->connects_seg_manager); |
| 448 | } |
| 449 | |
| 450 | segment_manager_t * |
| 451 | application_get_listen_segment_manager (application_t * app, |
| 452 | stream_session_t * s) |
| 453 | { |
| 454 | uword *smp; |
| 455 | smp = hash_get (app->listeners_table, listen_session_get_handle (s)); |
| 456 | ASSERT (smp != 0); |
| 457 | return segment_manager_get (*smp); |
| 458 | } |
| 459 | |
Dave Barach | 52851e6 | 2017-08-07 09:35:25 -0400 | [diff] [blame] | 460 | int |
| 461 | application_is_proxy (application_t * app) |
| 462 | { |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 463 | return (app->flags & APP_OPTIONS_FLAGS_IS_PROXY); |
| 464 | } |
| 465 | |
| 466 | int |
| 467 | application_is_builtin (application_t * app) |
| 468 | { |
| 469 | return (app->flags & APP_OPTIONS_FLAGS_IS_BUILTIN); |
| 470 | } |
| 471 | |
| 472 | int |
| 473 | application_is_builtin_proxy (application_t * app) |
| 474 | { |
| 475 | return (application_is_proxy (app) && application_is_builtin (app)); |
Dave Barach | 52851e6 | 2017-08-07 09:35:25 -0400 | [diff] [blame] | 476 | } |
| 477 | |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 478 | int |
| 479 | application_add_segment_notify (u32 app_index, u32 fifo_segment_index) |
| 480 | { |
| 481 | application_t *app = application_get (app_index); |
| 482 | u32 seg_size = 0; |
| 483 | u8 *seg_name; |
| 484 | |
| 485 | /* Send an API message to the external app, to map new segment */ |
| 486 | ASSERT (app->cb_fns.add_segment_callback); |
| 487 | |
| 488 | segment_manager_get_segment_info (fifo_segment_index, &seg_name, &seg_size); |
| 489 | return app->cb_fns.add_segment_callback (app->api_client_index, seg_name, |
| 490 | seg_size); |
| 491 | } |
| 492 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 493 | u8 |
| 494 | application_has_local_scope (application_t * app) |
| 495 | { |
| 496 | return app->flags & APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE; |
| 497 | } |
| 498 | |
| 499 | u8 |
| 500 | application_has_global_scope (application_t * app) |
| 501 | { |
| 502 | return app->flags & APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE; |
| 503 | } |
| 504 | |
Florin Coras | 1c71045 | 2017-10-17 00:03:13 -0700 | [diff] [blame] | 505 | u32 |
| 506 | application_n_listeners (application_t * app) |
| 507 | { |
| 508 | return hash_elts (app->listeners_table); |
| 509 | } |
| 510 | |
| 511 | stream_session_t * |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 512 | application_first_listener (application_t * app, u8 fib_proto, |
| 513 | u8 transport_proto) |
Florin Coras | 1c71045 | 2017-10-17 00:03:13 -0700 | [diff] [blame] | 514 | { |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 515 | stream_session_t *listener; |
Florin Coras | 1c71045 | 2017-10-17 00:03:13 -0700 | [diff] [blame] | 516 | u64 handle; |
| 517 | u32 sm_index; |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 518 | u8 sst; |
| 519 | |
| 520 | sst = session_type_from_proto_and_ip (transport_proto, |
| 521 | fib_proto == FIB_PROTOCOL_IP4); |
Florin Coras | 1c71045 | 2017-10-17 00:03:13 -0700 | [diff] [blame] | 522 | |
| 523 | /* *INDENT-OFF* */ |
| 524 | hash_foreach (handle, sm_index, app->listeners_table, ({ |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 525 | listener = listen_session_get_from_handle (handle); |
Florin Coras | c3ddea8 | 2017-11-27 03:12:00 -0800 | [diff] [blame^] | 526 | if (listener->session_type == sst |
| 527 | && listener->listener_index != SESSION_PROXY_LISTENER_INDEX) |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 528 | return listener; |
Florin Coras | 1c71045 | 2017-10-17 00:03:13 -0700 | [diff] [blame] | 529 | })); |
| 530 | /* *INDENT-ON* */ |
| 531 | |
| 532 | return 0; |
| 533 | } |
| 534 | |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 535 | static clib_error_t * |
| 536 | application_start_stop_proxy_fib_proto (application_t * app, u8 fib_proto, |
| 537 | u8 transport_proto, u8 is_start) |
| 538 | { |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 539 | app_namespace_t *app_ns = app_namespace_get (app->ns_index); |
| 540 | u8 is_ip4 = (fib_proto == FIB_PROTOCOL_IP4); |
| 541 | session_endpoint_t sep = SESSION_ENDPOINT_NULL; |
| 542 | transport_connection_t *tc; |
| 543 | stream_session_t *s; |
| 544 | u64 handle; |
| 545 | |
| 546 | if (is_start) |
| 547 | { |
| 548 | sep.is_ip4 = is_ip4; |
| 549 | sep.fib_index = app_namespace_get_fib_index (app_ns, fib_proto); |
| 550 | sep.sw_if_index = app_ns->sw_if_index; |
| 551 | sep.transport_proto = transport_proto; |
| 552 | application_start_listen (app, &sep, &handle); |
| 553 | s = listen_session_get_from_handle (handle); |
Florin Coras | c3ddea8 | 2017-11-27 03:12:00 -0800 | [diff] [blame^] | 554 | s->listener_index = SESSION_PROXY_LISTENER_INDEX; |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 555 | } |
| 556 | else |
| 557 | { |
| 558 | s = application_first_listener (app, fib_proto, transport_proto); |
| 559 | } |
| 560 | tc = listen_session_get_transport (s); |
| 561 | |
| 562 | if (!ip_is_zero (&tc->lcl_ip, 1)) |
| 563 | { |
Florin Coras | dbd4456 | 2017-11-09 19:30:17 -0800 | [diff] [blame] | 564 | u32 sti; |
| 565 | sep.is_ip4 = is_ip4; |
| 566 | sep.fib_index = app_namespace_get_fib_index (app_ns, fib_proto); |
| 567 | sep.transport_proto = transport_proto; |
| 568 | sep.port = 0; |
| 569 | sti = session_lookup_get_index_for_fib (fib_proto, sep.fib_index); |
| 570 | session_lookup_add_session_endpoint (sti, &sep, s->session_index); |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 571 | } |
| 572 | return 0; |
| 573 | } |
| 574 | |
| 575 | void |
| 576 | application_start_stop_proxy (application_t * app, u8 transport_proto, |
| 577 | u8 is_start) |
| 578 | { |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 579 | if (application_has_local_scope (app)) |
| 580 | { |
Florin Coras | dbd4456 | 2017-11-09 19:30:17 -0800 | [diff] [blame] | 581 | session_endpoint_t sep = SESSION_ENDPOINT_NULL; |
| 582 | app_namespace_t *app_ns; |
| 583 | app_ns = app_namespace_get (app->ns_index); |
| 584 | sep.is_ip4 = 1; |
| 585 | sep.transport_proto = transport_proto; |
| 586 | sep.port = 0; |
| 587 | session_lookup_add_session_endpoint (app_ns->local_table_index, &sep, |
| 588 | app->index); |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 589 | |
Florin Coras | dbd4456 | 2017-11-09 19:30:17 -0800 | [diff] [blame] | 590 | sep.is_ip4 = 0; |
| 591 | session_lookup_add_session_endpoint (app_ns->local_table_index, &sep, |
| 592 | app->index); |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 593 | } |
| 594 | |
| 595 | if (application_has_global_scope (app)) |
| 596 | { |
| 597 | application_start_stop_proxy_fib_proto (app, FIB_PROTOCOL_IP4, |
| 598 | transport_proto, is_start); |
| 599 | application_start_stop_proxy_fib_proto (app, FIB_PROTOCOL_IP6, |
| 600 | transport_proto, is_start); |
| 601 | } |
| 602 | } |
| 603 | |
| 604 | void |
| 605 | application_setup_proxy (application_t * app) |
| 606 | { |
| 607 | u16 transports = app->proxied_transports; |
| 608 | ASSERT (application_is_proxy (app)); |
| 609 | if (application_is_builtin (app)) |
| 610 | return; |
| 611 | if (transports & (1 << TRANSPORT_PROTO_TCP)) |
| 612 | application_start_stop_proxy (app, TRANSPORT_PROTO_TCP, 1); |
| 613 | if (transports & (1 << TRANSPORT_PROTO_UDP)) |
| 614 | application_start_stop_proxy (app, TRANSPORT_PROTO_UDP, 1); |
| 615 | } |
| 616 | |
| 617 | void |
| 618 | application_remove_proxy (application_t * app) |
| 619 | { |
| 620 | u16 transports = app->proxied_transports; |
| 621 | ASSERT (application_is_proxy (app)); |
| 622 | if (transports & (1 << TRANSPORT_PROTO_TCP)) |
| 623 | application_start_stop_proxy (app, TRANSPORT_PROTO_TCP, 0); |
| 624 | if (transports & (1 << TRANSPORT_PROTO_UDP)) |
| 625 | application_start_stop_proxy (app, TRANSPORT_PROTO_UDP, 0); |
| 626 | } |
| 627 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 628 | u8 * |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 629 | format_application_listener (u8 * s, va_list * args) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 630 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 631 | application_t *app = va_arg (*args, application_t *); |
| 632 | u64 handle = va_arg (*args, u64); |
| 633 | u32 index = va_arg (*args, u32); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 634 | int verbose = va_arg (*args, int); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 635 | stream_session_t *listener; |
| 636 | u8 *app_name, *str; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 637 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 638 | if (app == 0) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 639 | { |
| 640 | if (verbose) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 641 | s = format (s, "%-40s%-20s%-15s%-15s%-10s", "Connection", "App", |
| 642 | "API Client", "ListenerID", "SegManager"); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 643 | else |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 644 | s = format (s, "%-40s%-20s", "Connection", "App"); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 645 | |
| 646 | return s; |
| 647 | } |
| 648 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 649 | app_name = app_get_name_from_reg_index (app); |
| 650 | listener = listen_session_get_from_handle (handle); |
| 651 | str = format (0, "%U", format_stream_session, listener, verbose); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 652 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 653 | if (verbose) |
| 654 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 655 | s = format (s, "%-40s%-20s%-15u%-15u%-10u", str, app_name, |
| 656 | app->api_client_index, handle, index); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 657 | } |
| 658 | else |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 659 | s = format (s, "%-40s%-20s", str, app_name); |
| 660 | |
| 661 | vec_free (app_name); |
| 662 | return s; |
| 663 | } |
| 664 | |
| 665 | void |
| 666 | application_format_connects (application_t * app, int verbose) |
| 667 | { |
| 668 | vlib_main_t *vm = vlib_get_main (); |
| 669 | segment_manager_t *sm; |
| 670 | u8 *app_name, *s = 0; |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 671 | int j; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 672 | |
| 673 | /* Header */ |
| 674 | if (app == 0) |
| 675 | { |
| 676 | if (verbose) |
| 677 | vlib_cli_output (vm, "%-40s%-20s%-15s%-10s", "Connection", "App", |
| 678 | "API Client", "SegManager"); |
| 679 | else |
| 680 | vlib_cli_output (vm, "%-40s%-20s", "Connection", "App"); |
| 681 | return; |
| 682 | } |
| 683 | |
| 684 | /* make sure */ |
| 685 | if (app->connects_seg_manager == (u32) ~ 0) |
| 686 | return; |
| 687 | |
| 688 | app_name = app_get_name_from_reg_index (app); |
| 689 | |
| 690 | /* Across all fifo segments */ |
| 691 | sm = segment_manager_get (app->connects_seg_manager); |
| 692 | for (j = 0; j < vec_len (sm->segment_indices); j++) |
| 693 | { |
| 694 | svm_fifo_segment_private_t *fifo_segment; |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 695 | svm_fifo_t *fifo; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 696 | u8 *str; |
| 697 | |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 698 | fifo_segment = svm_fifo_segment_get_segment (sm->segment_indices[j]); |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 699 | fifo = svm_fifo_segment_get_fifo_list (fifo_segment); |
| 700 | while (fifo) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 701 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 702 | u32 session_index, thread_index; |
| 703 | stream_session_t *session; |
| 704 | |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 705 | session_index = fifo->master_session_index; |
| 706 | thread_index = fifo->master_thread_index; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 707 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 708 | session = session_get (session_index, thread_index); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 709 | str = format (0, "%U", format_stream_session, session, verbose); |
| 710 | |
| 711 | if (verbose) |
| 712 | s = format (s, "%-40s%-20s%-15u%-10u", str, app_name, |
| 713 | app->api_client_index, app->connects_seg_manager); |
| 714 | else |
| 715 | s = format (s, "%-40s%-20s", str, app_name); |
| 716 | |
| 717 | vlib_cli_output (vm, "%v", s); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 718 | vec_reset_length (s); |
| 719 | vec_free (str); |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 720 | |
| 721 | fifo = fifo->next; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 722 | } |
| 723 | vec_free (s); |
| 724 | } |
| 725 | |
| 726 | vec_free (app_name); |
| 727 | } |
| 728 | |
| 729 | u8 * |
| 730 | format_application (u8 * s, va_list * args) |
| 731 | { |
| 732 | application_t *app = va_arg (*args, application_t *); |
| 733 | CLIB_UNUSED (int verbose) = va_arg (*args, int); |
Florin Coras | ad0c77f | 2017-11-09 18:00:15 -0800 | [diff] [blame] | 734 | segment_manager_properties_t *props; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 735 | const u8 *app_ns_name; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 736 | u8 *app_name; |
| 737 | |
| 738 | if (app == 0) |
| 739 | { |
| 740 | if (verbose) |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 741 | s = format (s, "%-10s%-20s%-15s%-15s%-15s%-15s%-15s", "Index", "Name", |
Florin Coras | 8f107b3 | 2017-11-21 22:13:03 -0800 | [diff] [blame] | 742 | "API Client", "Namespace", "Add seg size", "Rx fifo size", |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 743 | "Tx fifo size"); |
| 744 | else |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 745 | s = |
Florin Coras | 8f107b3 | 2017-11-21 22:13:03 -0800 | [diff] [blame] | 746 | format (s, "%-10s%-20s%-15s%-40s", "Index", "Name", "API Client", |
| 747 | "Namespace"); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 748 | return s; |
| 749 | } |
| 750 | |
| 751 | app_name = app_get_name_from_reg_index (app); |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 752 | app_ns_name = app_namespace_id_from_index (app->ns_index); |
Florin Coras | ad0c77f | 2017-11-09 18:00:15 -0800 | [diff] [blame] | 753 | props = segment_manager_properties_get (app->sm_properties); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 754 | if (verbose) |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 755 | s = |
Florin Coras | 8f107b3 | 2017-11-21 22:13:03 -0800 | [diff] [blame] | 756 | format (s, "%-10d%-20s%-15d%-15d%-15d%-15d%-15d", app->index, app_name, |
| 757 | app->api_client_index, app->ns_index, |
Florin Coras | ad0c77f | 2017-11-09 18:00:15 -0800 | [diff] [blame] | 758 | props->add_segment_size, |
| 759 | props->rx_fifo_size, props->tx_fifo_size); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 760 | else |
Florin Coras | 8f107b3 | 2017-11-21 22:13:03 -0800 | [diff] [blame] | 761 | s = format (s, "%-10d%-20s%-15d%-40s", app->index, app_name, |
| 762 | app->api_client_index, app_ns_name); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 763 | return s; |
| 764 | } |
| 765 | |
| 766 | static clib_error_t * |
| 767 | show_app_command_fn (vlib_main_t * vm, unformat_input_t * input, |
| 768 | vlib_cli_command_t * cmd) |
| 769 | { |
| 770 | application_t *app; |
| 771 | int do_server = 0; |
| 772 | int do_client = 0; |
| 773 | int verbose = 0; |
| 774 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 775 | session_cli_return_if_not_enabled (); |
Florin Coras | e04c299 | 2017-03-01 08:17:34 -0800 | [diff] [blame] | 776 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 777 | while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) |
| 778 | { |
| 779 | if (unformat (input, "server")) |
| 780 | do_server = 1; |
| 781 | else if (unformat (input, "client")) |
| 782 | do_client = 1; |
| 783 | else if (unformat (input, "verbose")) |
| 784 | verbose = 1; |
| 785 | else |
| 786 | break; |
| 787 | } |
| 788 | |
| 789 | if (do_server) |
| 790 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 791 | u64 handle; |
| 792 | u32 index; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 793 | if (pool_elts (app_pool)) |
| 794 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 795 | vlib_cli_output (vm, "%U", format_application_listener, |
| 796 | 0 /* header */ , 0, 0, |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 797 | verbose); |
Florin Coras | 1c71045 | 2017-10-17 00:03:13 -0700 | [diff] [blame] | 798 | /* *INDENT-OFF* */ |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 799 | pool_foreach (app, app_pool, |
| 800 | ({ |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 801 | /* App's listener sessions */ |
| 802 | if (hash_elts (app->listeners_table) == 0) |
| 803 | continue; |
| 804 | hash_foreach (handle, index, app->listeners_table, |
| 805 | ({ |
| 806 | vlib_cli_output (vm, "%U", format_application_listener, app, |
| 807 | handle, index, verbose); |
| 808 | })); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 809 | })); |
| 810 | /* *INDENT-ON* */ |
| 811 | } |
| 812 | else |
| 813 | vlib_cli_output (vm, "No active server bindings"); |
| 814 | } |
| 815 | |
| 816 | if (do_client) |
| 817 | { |
| 818 | if (pool_elts (app_pool)) |
| 819 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 820 | application_format_connects (0, verbose); |
| 821 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 822 | /* *INDENT-OFF* */ |
| 823 | pool_foreach (app, app_pool, |
| 824 | ({ |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 825 | if (app->connects_seg_manager == (u32)~0) |
| 826 | continue; |
| 827 | application_format_connects (app, verbose); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 828 | })); |
| 829 | /* *INDENT-ON* */ |
| 830 | } |
| 831 | else |
Florin Coras | e04c299 | 2017-03-01 08:17:34 -0800 | [diff] [blame] | 832 | vlib_cli_output (vm, "No active client bindings"); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 833 | } |
| 834 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 835 | /* Print app related info */ |
| 836 | if (!do_server && !do_client) |
| 837 | { |
| 838 | vlib_cli_output (vm, "%U", format_application, 0, verbose); |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 839 | /* *INDENT-OFF* */ |
| 840 | pool_foreach (app, app_pool, ({ |
| 841 | vlib_cli_output (vm, "%U", format_application, app, verbose); |
| 842 | })); |
| 843 | /* *INDENT-ON* */ |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 844 | } |
| 845 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 846 | return 0; |
| 847 | } |
| 848 | |
Florin Coras | e04c299 | 2017-03-01 08:17:34 -0800 | [diff] [blame] | 849 | /* *INDENT-OFF* */ |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 850 | VLIB_CLI_COMMAND (show_app_command, static) = |
| 851 | { |
Florin Coras | e04c299 | 2017-03-01 08:17:34 -0800 | [diff] [blame] | 852 | .path = "show app", |
| 853 | .short_help = "show app [server|client] [verbose]", |
| 854 | .function = show_app_command_fn, |
| 855 | }; |
| 856 | /* *INDENT-ON* */ |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 857 | |
| 858 | /* |
| 859 | * fd.io coding-style-patch-verification: ON |
| 860 | * |
| 861 | * Local Variables: |
| 862 | * eval: (c-set-style "gnu") |
| 863 | * End: |
| 864 | */ |