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 | { |
Florin Coras | e86a8ed | 2018-01-05 03:20:25 -0800 | [diff] [blame] | 79 | svm_queue_t *q; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 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 | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame^] | 230 | /** |
| 231 | * Check app config for given segment type |
| 232 | * |
| 233 | * Returns 1 on success and 0 otherwise |
| 234 | */ |
| 235 | static u8 |
| 236 | application_verify_cfg (ssvm_segment_type_t st) |
| 237 | { |
| 238 | u8 is_valid; |
| 239 | if (st == SSVM_SEGMENT_MEMFD) |
| 240 | { |
| 241 | is_valid = (session_manager_get_evt_q_segment () != 0); |
| 242 | if (!is_valid) |
| 243 | clib_warning ("memfd seg: vpp's event qs IN binary api svm region"); |
| 244 | return is_valid; |
| 245 | } |
| 246 | else if (st == SSVM_SEGMENT_SHM) |
| 247 | { |
| 248 | is_valid = (session_manager_get_evt_q_segment () == 0); |
| 249 | if (!is_valid) |
| 250 | clib_warning ("shm seg: vpp's event qs NOT IN binary api svm region"); |
| 251 | return is_valid; |
| 252 | } |
| 253 | else |
| 254 | return 1; |
| 255 | } |
| 256 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 257 | int |
| 258 | application_init (application_t * app, u32 api_client_index, u64 * options, |
| 259 | session_cb_vft_t * cb_fns) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 260 | { |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame^] | 261 | ssvm_segment_type_t st = SSVM_SEGMENT_MEMFD; |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 262 | u32 app_evt_queue_size, first_seg_size; |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame^] | 263 | segment_manager_properties_t *props; |
| 264 | vl_api_registration_t *reg; |
| 265 | segment_manager_t *sm; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 266 | int rv; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 267 | |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame^] | 268 | /* |
| 269 | * Make sure we support the requested configuration |
| 270 | */ |
| 271 | reg = vl_api_client_index_to_registration (api_client_index); |
| 272 | if (!reg) |
| 273 | return VNET_API_ERROR_APP_UNSUPPORTED_CFG; |
| 274 | |
| 275 | if (vl_api_registration_file_index (reg) == ~0) |
| 276 | st = SSVM_SEGMENT_SHM; |
| 277 | |
| 278 | if (!application_verify_cfg (st)) |
| 279 | return VNET_API_ERROR_APP_UNSUPPORTED_CFG; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 280 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 281 | /* |
| 282 | * Setup segment manager |
| 283 | */ |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 284 | sm = segment_manager_new (); |
| 285 | sm->app_index = app->index; |
Florin Coras | ad0c77f | 2017-11-09 18:00:15 -0800 | [diff] [blame] | 286 | props = segment_manager_properties_alloc (); |
| 287 | app->sm_properties = segment_manager_properties_index (props); |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame^] | 288 | if (options[APP_OPTIONS_ADD_SEGMENT_SIZE]) |
| 289 | { |
| 290 | props->add_segment_size = options[APP_OPTIONS_ADD_SEGMENT_SIZE]; |
| 291 | props->add_segment = 1; |
| 292 | } |
| 293 | if (options[APP_OPTIONS_RX_FIFO_SIZE]) |
| 294 | props->rx_fifo_size = options[APP_OPTIONS_RX_FIFO_SIZE]; |
| 295 | if (options[APP_OPTIONS_TX_FIFO_SIZE]) |
| 296 | props->tx_fifo_size = options[APP_OPTIONS_TX_FIFO_SIZE]; |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 297 | props->preallocated_fifo_pairs = options[APP_OPTIONS_PREALLOC_FIFO_PAIRS]; |
Dave Barach | 2c25a62 | 2017-06-26 11:35:07 -0400 | [diff] [blame] | 298 | props->private_segment_count = options[APP_OPTIONS_PRIVATE_SEGMENT_COUNT]; |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame^] | 299 | if (options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_IS_BUILTIN) |
| 300 | props->segment_type = SSVM_N_SEGMENT_TYPES; |
| 301 | else |
| 302 | props->segment_type = st; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 303 | |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame^] | 304 | app_evt_queue_size = options[APP_OPTIONS_EVT_QUEUE_SIZE] > 0 ? |
| 305 | options[APP_OPTIONS_EVT_QUEUE_SIZE] : default_app_evt_queue_size; |
Florin Coras | ff6e769 | 2017-12-11 04:59:01 -0800 | [diff] [blame] | 306 | first_seg_size = options[APP_OPTIONS_SEGMENT_SIZE]; |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame^] | 307 | if ((rv = segment_manager_init (sm, app->sm_properties, first_seg_size, |
| 308 | app_evt_queue_size))) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 309 | return rv; |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 310 | sm->first_is_protected = 1; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 311 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 312 | /* |
| 313 | * Setup application |
| 314 | */ |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 315 | app->first_segment_manager = segment_manager_index (sm); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 316 | app->api_client_index = api_client_index; |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 317 | app->flags = options[APP_OPTIONS_FLAGS]; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 318 | app->cb_fns = *cb_fns; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 319 | app->ns_index = options[APP_OPTIONS_NAMESPACE]; |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 320 | app->listeners_table = hash_create (0, sizeof (u64)); |
| 321 | app->proxied_transports = options[APP_OPTIONS_PROXY_TRANSPORT]; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 322 | |
| 323 | /* If no scope enabled, default to global */ |
| 324 | if (!application_has_global_scope (app) |
| 325 | && !application_has_local_scope (app)) |
| 326 | app->flags |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 327 | |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 328 | /* Allocate app event queue in the first shared-memory segment */ |
| 329 | app->event_queue = segment_manager_alloc_queue (sm, app_evt_queue_size); |
| 330 | |
Florin Coras | d79b41e | 2017-03-04 05:37:52 -0800 | [diff] [blame] | 331 | /* Check that the obvious things are properly set up */ |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 332 | application_verify_cb_fns (cb_fns); |
Florin Coras | d79b41e | 2017-03-04 05:37:52 -0800 | [diff] [blame] | 333 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 334 | /* Add app to lookup by api_client_index table */ |
| 335 | application_table_add (app); |
| 336 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 337 | return 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 338 | } |
| 339 | |
| 340 | application_t * |
| 341 | application_get (u32 index) |
| 342 | { |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 343 | if (index == APP_INVALID_INDEX) |
| 344 | return 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 345 | return pool_elt_at_index (app_pool, index); |
| 346 | } |
| 347 | |
Florin Coras | e04c299 | 2017-03-01 08:17:34 -0800 | [diff] [blame] | 348 | application_t * |
| 349 | application_get_if_valid (u32 index) |
| 350 | { |
| 351 | if (pool_is_free_index (app_pool, index)) |
| 352 | return 0; |
| 353 | |
| 354 | return pool_elt_at_index (app_pool, index); |
| 355 | } |
| 356 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 357 | u32 |
| 358 | application_get_index (application_t * app) |
| 359 | { |
| 360 | return app - app_pool; |
| 361 | } |
| 362 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 363 | static segment_manager_t * |
| 364 | application_alloc_segment_manager (application_t * app) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 365 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 366 | segment_manager_t *sm = 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 367 | |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 368 | /* If the first segment manager is not in use, don't allocate a new one */ |
| 369 | if (app->first_segment_manager != APP_INVALID_SEGMENT_MANAGER_INDEX |
Florin Coras | 0e9c33b | 2017-08-14 22:33:41 -0700 | [diff] [blame] | 370 | && app->first_segment_manager_in_use == 0) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 371 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 372 | sm = segment_manager_get (app->first_segment_manager); |
Florin Coras | 0e9c33b | 2017-08-14 22:33:41 -0700 | [diff] [blame] | 373 | app->first_segment_manager_in_use = 1; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 374 | return sm; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 375 | } |
| 376 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 377 | sm = segment_manager_new (); |
Florin Coras | ad0c77f | 2017-11-09 18:00:15 -0800 | [diff] [blame] | 378 | sm->properties_index = app->sm_properties; |
Florin Coras | 0e9c33b | 2017-08-14 22:33:41 -0700 | [diff] [blame] | 379 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 380 | return sm; |
| 381 | } |
| 382 | |
| 383 | /** |
| 384 | * Start listening local transport endpoint for requested transport. |
| 385 | * |
| 386 | * Creates a 'dummy' stream session with state LISTENING to be used in session |
| 387 | * lookups, prior to establishing connection. Requests transport to build |
| 388 | * it's own specific listening connection. |
| 389 | */ |
| 390 | int |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 391 | application_start_listen (application_t * srv, session_endpoint_t * sep, |
| 392 | u64 * res) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 393 | { |
| 394 | segment_manager_t *sm; |
| 395 | stream_session_t *s; |
| 396 | u64 handle; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 397 | session_type_t sst; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 398 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 399 | sst = session_type_from_proto_and_ip (sep->transport_proto, sep->is_ip4); |
| 400 | s = listen_session_new (sst); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 401 | s->app_index = srv->index; |
| 402 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 403 | if (stream_session_listen (s, sep)) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 404 | goto err; |
| 405 | |
| 406 | /* Allocate segment manager. All sessions derived out of a listen session |
| 407 | * have fifos allocated by the same segment manager. */ |
| 408 | sm = application_alloc_segment_manager (srv); |
| 409 | if (sm == 0) |
| 410 | goto err; |
| 411 | |
| 412 | /* Add to app's listener table. Useful to find all child listeners |
| 413 | * when app goes down, although, just for unbinding this is not needed */ |
| 414 | handle = listen_session_get_handle (s); |
| 415 | hash_set (srv->listeners_table, handle, segment_manager_index (sm)); |
| 416 | |
| 417 | *res = handle; |
| 418 | return 0; |
| 419 | |
| 420 | err: |
| 421 | listen_session_del (s); |
| 422 | return -1; |
| 423 | } |
| 424 | |
| 425 | /** |
| 426 | * Stop listening on session associated to handle |
| 427 | */ |
| 428 | int |
| 429 | application_stop_listen (application_t * srv, u64 handle) |
| 430 | { |
| 431 | stream_session_t *listener; |
| 432 | uword *indexp; |
| 433 | segment_manager_t *sm; |
| 434 | |
| 435 | if (srv && hash_get (srv->listeners_table, handle) == 0) |
| 436 | { |
| 437 | clib_warning ("app doesn't own handle %llu!", handle); |
| 438 | return -1; |
| 439 | } |
| 440 | |
| 441 | listener = listen_session_get_from_handle (handle); |
| 442 | stream_session_stop_listen (listener); |
| 443 | |
| 444 | indexp = hash_get (srv->listeners_table, handle); |
| 445 | ASSERT (indexp); |
| 446 | |
| 447 | sm = segment_manager_get (*indexp); |
Florin Coras | 0e9c33b | 2017-08-14 22:33:41 -0700 | [diff] [blame] | 448 | if (srv->first_segment_manager == *indexp) |
| 449 | { |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 450 | /* Delete sessions but don't remove segment manager */ |
Florin Coras | 0e9c33b | 2017-08-14 22:33:41 -0700 | [diff] [blame] | 451 | srv->first_segment_manager_in_use = 0; |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 452 | segment_manager_del_sessions (sm); |
| 453 | } |
| 454 | else |
| 455 | { |
| 456 | segment_manager_init_del (sm); |
Florin Coras | 0e9c33b | 2017-08-14 22:33:41 -0700 | [diff] [blame] | 457 | } |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 458 | hash_unset (srv->listeners_table, handle); |
| 459 | listen_session_del (listener); |
| 460 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 461 | return 0; |
| 462 | } |
| 463 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 464 | int |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 465 | application_open_session (application_t * app, session_endpoint_t * sep, |
| 466 | u32 api_context) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 467 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 468 | segment_manager_t *sm; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 469 | int rv; |
| 470 | |
| 471 | /* Make sure we have a segment manager for connects */ |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 472 | if (app->connects_seg_manager == APP_INVALID_SEGMENT_MANAGER_INDEX) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 473 | { |
| 474 | sm = application_alloc_segment_manager (app); |
| 475 | if (sm == 0) |
| 476 | return -1; |
| 477 | app->connects_seg_manager = segment_manager_index (sm); |
| 478 | } |
| 479 | |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 480 | if ((rv = session_open (app->index, sep, api_context))) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 481 | return rv; |
| 482 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 483 | return 0; |
| 484 | } |
| 485 | |
| 486 | segment_manager_t * |
| 487 | application_get_connect_segment_manager (application_t * app) |
| 488 | { |
| 489 | ASSERT (app->connects_seg_manager != (u32) ~ 0); |
| 490 | return segment_manager_get (app->connects_seg_manager); |
| 491 | } |
| 492 | |
| 493 | segment_manager_t * |
| 494 | application_get_listen_segment_manager (application_t * app, |
| 495 | stream_session_t * s) |
| 496 | { |
| 497 | uword *smp; |
| 498 | smp = hash_get (app->listeners_table, listen_session_get_handle (s)); |
| 499 | ASSERT (smp != 0); |
| 500 | return segment_manager_get (*smp); |
| 501 | } |
| 502 | |
Dave Barach | 52851e6 | 2017-08-07 09:35:25 -0400 | [diff] [blame] | 503 | int |
| 504 | application_is_proxy (application_t * app) |
| 505 | { |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 506 | return (app->flags & APP_OPTIONS_FLAGS_IS_PROXY); |
| 507 | } |
| 508 | |
| 509 | int |
| 510 | application_is_builtin (application_t * app) |
| 511 | { |
| 512 | return (app->flags & APP_OPTIONS_FLAGS_IS_BUILTIN); |
| 513 | } |
| 514 | |
| 515 | int |
| 516 | application_is_builtin_proxy (application_t * app) |
| 517 | { |
| 518 | return (application_is_proxy (app) && application_is_builtin (app)); |
Dave Barach | 52851e6 | 2017-08-07 09:35:25 -0400 | [diff] [blame] | 519 | } |
| 520 | |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 521 | int |
| 522 | application_add_segment_notify (u32 app_index, u32 fifo_segment_index) |
| 523 | { |
| 524 | application_t *app = application_get (app_index); |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame^] | 525 | svm_fifo_segment_private_t *fs; |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 526 | |
| 527 | /* Send an API message to the external app, to map new segment */ |
| 528 | ASSERT (app->cb_fns.add_segment_callback); |
| 529 | |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame^] | 530 | fs = segment_manager_get_segment (fifo_segment_index); |
| 531 | return app->cb_fns.add_segment_callback (app->api_client_index, &fs->ssvm); |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 532 | } |
| 533 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 534 | u8 |
| 535 | application_has_local_scope (application_t * app) |
| 536 | { |
| 537 | return app->flags & APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE; |
| 538 | } |
| 539 | |
| 540 | u8 |
| 541 | application_has_global_scope (application_t * app) |
| 542 | { |
| 543 | return app->flags & APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE; |
| 544 | } |
| 545 | |
Florin Coras | 1c71045 | 2017-10-17 00:03:13 -0700 | [diff] [blame] | 546 | u32 |
| 547 | application_n_listeners (application_t * app) |
| 548 | { |
| 549 | return hash_elts (app->listeners_table); |
| 550 | } |
| 551 | |
| 552 | stream_session_t * |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 553 | application_first_listener (application_t * app, u8 fib_proto, |
| 554 | u8 transport_proto) |
Florin Coras | 1c71045 | 2017-10-17 00:03:13 -0700 | [diff] [blame] | 555 | { |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 556 | stream_session_t *listener; |
Florin Coras | 1c71045 | 2017-10-17 00:03:13 -0700 | [diff] [blame] | 557 | u64 handle; |
| 558 | u32 sm_index; |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 559 | u8 sst; |
| 560 | |
| 561 | sst = session_type_from_proto_and_ip (transport_proto, |
| 562 | fib_proto == FIB_PROTOCOL_IP4); |
Florin Coras | 1c71045 | 2017-10-17 00:03:13 -0700 | [diff] [blame] | 563 | |
| 564 | /* *INDENT-OFF* */ |
| 565 | hash_foreach (handle, sm_index, app->listeners_table, ({ |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 566 | listener = listen_session_get_from_handle (handle); |
Florin Coras | c3ddea8 | 2017-11-27 03:12:00 -0800 | [diff] [blame] | 567 | if (listener->session_type == sst |
| 568 | && listener->listener_index != SESSION_PROXY_LISTENER_INDEX) |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 569 | return listener; |
Florin Coras | 1c71045 | 2017-10-17 00:03:13 -0700 | [diff] [blame] | 570 | })); |
| 571 | /* *INDENT-ON* */ |
| 572 | |
| 573 | return 0; |
| 574 | } |
| 575 | |
Florin Coras | 19b1f6a | 2017-12-11 03:37:03 -0800 | [diff] [blame] | 576 | stream_session_t * |
| 577 | application_proxy_listener (application_t * app, u8 fib_proto, |
| 578 | u8 transport_proto) |
| 579 | { |
| 580 | stream_session_t *listener; |
| 581 | u64 handle; |
| 582 | u32 sm_index; |
| 583 | u8 sst; |
| 584 | |
| 585 | sst = session_type_from_proto_and_ip (transport_proto, |
| 586 | fib_proto == FIB_PROTOCOL_IP4); |
| 587 | |
| 588 | /* *INDENT-OFF* */ |
| 589 | hash_foreach (handle, sm_index, app->listeners_table, ({ |
| 590 | listener = listen_session_get_from_handle (handle); |
| 591 | if (listener->session_type == sst |
| 592 | && listener->listener_index == SESSION_PROXY_LISTENER_INDEX) |
| 593 | return listener; |
| 594 | })); |
| 595 | /* *INDENT-ON* */ |
| 596 | |
| 597 | return 0; |
| 598 | } |
| 599 | |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 600 | static clib_error_t * |
| 601 | application_start_stop_proxy_fib_proto (application_t * app, u8 fib_proto, |
| 602 | u8 transport_proto, u8 is_start) |
| 603 | { |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 604 | app_namespace_t *app_ns = app_namespace_get (app->ns_index); |
| 605 | u8 is_ip4 = (fib_proto == FIB_PROTOCOL_IP4); |
| 606 | session_endpoint_t sep = SESSION_ENDPOINT_NULL; |
| 607 | transport_connection_t *tc; |
| 608 | stream_session_t *s; |
| 609 | u64 handle; |
| 610 | |
| 611 | if (is_start) |
| 612 | { |
Florin Coras | 19b1f6a | 2017-12-11 03:37:03 -0800 | [diff] [blame] | 613 | s = application_first_listener (app, fib_proto, transport_proto); |
| 614 | if (!s) |
| 615 | { |
| 616 | sep.is_ip4 = is_ip4; |
| 617 | sep.fib_index = app_namespace_get_fib_index (app_ns, fib_proto); |
| 618 | sep.sw_if_index = app_ns->sw_if_index; |
| 619 | sep.transport_proto = transport_proto; |
| 620 | application_start_listen (app, &sep, &handle); |
| 621 | s = listen_session_get_from_handle (handle); |
| 622 | s->listener_index = SESSION_PROXY_LISTENER_INDEX; |
| 623 | } |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 624 | } |
| 625 | else |
| 626 | { |
Florin Coras | 19b1f6a | 2017-12-11 03:37:03 -0800 | [diff] [blame] | 627 | s = application_proxy_listener (app, fib_proto, transport_proto); |
| 628 | ASSERT (s); |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 629 | } |
Florin Coras | 19b1f6a | 2017-12-11 03:37:03 -0800 | [diff] [blame] | 630 | |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 631 | tc = listen_session_get_transport (s); |
| 632 | |
| 633 | if (!ip_is_zero (&tc->lcl_ip, 1)) |
| 634 | { |
Florin Coras | dbd4456 | 2017-11-09 19:30:17 -0800 | [diff] [blame] | 635 | u32 sti; |
| 636 | sep.is_ip4 = is_ip4; |
| 637 | sep.fib_index = app_namespace_get_fib_index (app_ns, fib_proto); |
| 638 | sep.transport_proto = transport_proto; |
| 639 | sep.port = 0; |
| 640 | sti = session_lookup_get_index_for_fib (fib_proto, sep.fib_index); |
Florin Coras | 19b1f6a | 2017-12-11 03:37:03 -0800 | [diff] [blame] | 641 | if (is_start) |
| 642 | session_lookup_add_session_endpoint (sti, &sep, s->session_index); |
| 643 | else |
| 644 | session_lookup_del_session_endpoint (sti, &sep); |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 645 | } |
Florin Coras | 19b1f6a | 2017-12-11 03:37:03 -0800 | [diff] [blame] | 646 | |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 647 | return 0; |
| 648 | } |
| 649 | |
Florin Coras | 19b1f6a | 2017-12-11 03:37:03 -0800 | [diff] [blame] | 650 | static void |
| 651 | application_start_stop_proxy_local_scope (application_t * app, |
| 652 | u8 transport_proto, u8 is_start) |
| 653 | { |
| 654 | session_endpoint_t sep = SESSION_ENDPOINT_NULL; |
| 655 | app_namespace_t *app_ns; |
| 656 | app_ns = app_namespace_get (app->ns_index); |
| 657 | sep.is_ip4 = 1; |
| 658 | sep.transport_proto = transport_proto; |
| 659 | sep.port = 0; |
| 660 | |
| 661 | if (is_start) |
| 662 | { |
| 663 | session_lookup_add_session_endpoint (app_ns->local_table_index, &sep, |
| 664 | app->index); |
| 665 | sep.is_ip4 = 0; |
| 666 | session_lookup_add_session_endpoint (app_ns->local_table_index, &sep, |
| 667 | app->index); |
| 668 | } |
| 669 | else |
| 670 | { |
| 671 | session_lookup_del_session_endpoint (app_ns->local_table_index, &sep); |
| 672 | sep.is_ip4 = 0; |
| 673 | session_lookup_del_session_endpoint (app_ns->local_table_index, &sep); |
| 674 | } |
| 675 | } |
| 676 | |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 677 | void |
Florin Coras | 561af9b | 2017-12-09 10:19:43 -0800 | [diff] [blame] | 678 | application_start_stop_proxy (application_t * app, |
| 679 | transport_proto_t transport_proto, u8 is_start) |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 680 | { |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 681 | if (application_has_local_scope (app)) |
Florin Coras | 19b1f6a | 2017-12-11 03:37:03 -0800 | [diff] [blame] | 682 | application_start_stop_proxy_local_scope (app, transport_proto, is_start); |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 683 | |
| 684 | if (application_has_global_scope (app)) |
| 685 | { |
| 686 | application_start_stop_proxy_fib_proto (app, FIB_PROTOCOL_IP4, |
| 687 | transport_proto, is_start); |
| 688 | application_start_stop_proxy_fib_proto (app, FIB_PROTOCOL_IP6, |
| 689 | transport_proto, is_start); |
| 690 | } |
| 691 | } |
| 692 | |
| 693 | void |
| 694 | application_setup_proxy (application_t * app) |
| 695 | { |
| 696 | u16 transports = app->proxied_transports; |
Florin Coras | 561af9b | 2017-12-09 10:19:43 -0800 | [diff] [blame] | 697 | transport_proto_t tp; |
| 698 | |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 699 | ASSERT (application_is_proxy (app)); |
| 700 | if (application_is_builtin (app)) |
| 701 | return; |
Florin Coras | 561af9b | 2017-12-09 10:19:43 -0800 | [diff] [blame] | 702 | |
| 703 | /* *INDENT-OFF* */ |
| 704 | transport_proto_foreach (tp, ({ |
| 705 | if (transports & (1 << tp)) |
| 706 | application_start_stop_proxy (app, tp, 1); |
| 707 | })); |
| 708 | /* *INDENT-ON* */ |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 709 | } |
| 710 | |
| 711 | void |
| 712 | application_remove_proxy (application_t * app) |
| 713 | { |
| 714 | u16 transports = app->proxied_transports; |
Florin Coras | 561af9b | 2017-12-09 10:19:43 -0800 | [diff] [blame] | 715 | transport_proto_t tp; |
| 716 | |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 717 | ASSERT (application_is_proxy (app)); |
Florin Coras | 561af9b | 2017-12-09 10:19:43 -0800 | [diff] [blame] | 718 | |
| 719 | /* *INDENT-OFF* */ |
| 720 | transport_proto_foreach (tp, ({ |
| 721 | if (transports & (1 << tp)) |
| 722 | application_start_stop_proxy (app, tp, 0); |
| 723 | })); |
| 724 | /* *INDENT-ON* */ |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 725 | } |
| 726 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 727 | u8 * |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 728 | format_application_listener (u8 * s, va_list * args) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 729 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 730 | application_t *app = va_arg (*args, application_t *); |
| 731 | u64 handle = va_arg (*args, u64); |
| 732 | u32 index = va_arg (*args, u32); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 733 | int verbose = va_arg (*args, int); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 734 | stream_session_t *listener; |
| 735 | u8 *app_name, *str; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 736 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 737 | if (app == 0) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 738 | { |
| 739 | if (verbose) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 740 | s = format (s, "%-40s%-20s%-15s%-15s%-10s", "Connection", "App", |
| 741 | "API Client", "ListenerID", "SegManager"); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 742 | else |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 743 | s = format (s, "%-40s%-20s", "Connection", "App"); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 744 | |
| 745 | return s; |
| 746 | } |
| 747 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 748 | app_name = app_get_name_from_reg_index (app); |
| 749 | listener = listen_session_get_from_handle (handle); |
| 750 | str = format (0, "%U", format_stream_session, listener, verbose); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 751 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 752 | if (verbose) |
| 753 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 754 | s = format (s, "%-40s%-20s%-15u%-15u%-10u", str, app_name, |
| 755 | app->api_client_index, handle, index); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 756 | } |
| 757 | else |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 758 | s = format (s, "%-40s%-20s", str, app_name); |
| 759 | |
| 760 | vec_free (app_name); |
| 761 | return s; |
| 762 | } |
| 763 | |
| 764 | void |
| 765 | application_format_connects (application_t * app, int verbose) |
| 766 | { |
| 767 | vlib_main_t *vm = vlib_get_main (); |
| 768 | segment_manager_t *sm; |
| 769 | u8 *app_name, *s = 0; |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 770 | int j; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 771 | |
| 772 | /* Header */ |
| 773 | if (app == 0) |
| 774 | { |
| 775 | if (verbose) |
| 776 | vlib_cli_output (vm, "%-40s%-20s%-15s%-10s", "Connection", "App", |
| 777 | "API Client", "SegManager"); |
| 778 | else |
| 779 | vlib_cli_output (vm, "%-40s%-20s", "Connection", "App"); |
| 780 | return; |
| 781 | } |
| 782 | |
| 783 | /* make sure */ |
| 784 | if (app->connects_seg_manager == (u32) ~ 0) |
| 785 | return; |
| 786 | |
| 787 | app_name = app_get_name_from_reg_index (app); |
| 788 | |
| 789 | /* Across all fifo segments */ |
| 790 | sm = segment_manager_get (app->connects_seg_manager); |
| 791 | for (j = 0; j < vec_len (sm->segment_indices); j++) |
| 792 | { |
| 793 | svm_fifo_segment_private_t *fifo_segment; |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 794 | svm_fifo_t *fifo; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 795 | u8 *str; |
| 796 | |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 797 | fifo_segment = svm_fifo_segment_get_segment (sm->segment_indices[j]); |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 798 | fifo = svm_fifo_segment_get_fifo_list (fifo_segment); |
| 799 | while (fifo) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 800 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 801 | u32 session_index, thread_index; |
| 802 | stream_session_t *session; |
| 803 | |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 804 | session_index = fifo->master_session_index; |
| 805 | thread_index = fifo->master_thread_index; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 806 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 807 | session = session_get (session_index, thread_index); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 808 | str = format (0, "%U", format_stream_session, session, verbose); |
| 809 | |
| 810 | if (verbose) |
| 811 | s = format (s, "%-40s%-20s%-15u%-10u", str, app_name, |
| 812 | app->api_client_index, app->connects_seg_manager); |
| 813 | else |
| 814 | s = format (s, "%-40s%-20s", str, app_name); |
| 815 | |
| 816 | vlib_cli_output (vm, "%v", s); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 817 | vec_reset_length (s); |
| 818 | vec_free (str); |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 819 | |
| 820 | fifo = fifo->next; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 821 | } |
| 822 | vec_free (s); |
| 823 | } |
| 824 | |
| 825 | vec_free (app_name); |
| 826 | } |
| 827 | |
| 828 | u8 * |
| 829 | format_application (u8 * s, va_list * args) |
| 830 | { |
| 831 | application_t *app = va_arg (*args, application_t *); |
| 832 | CLIB_UNUSED (int verbose) = va_arg (*args, int); |
Florin Coras | ad0c77f | 2017-11-09 18:00:15 -0800 | [diff] [blame] | 833 | segment_manager_properties_t *props; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 834 | const u8 *app_ns_name; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 835 | u8 *app_name; |
| 836 | |
| 837 | if (app == 0) |
| 838 | { |
| 839 | if (verbose) |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 840 | s = format (s, "%-10s%-20s%-15s%-15s%-15s%-15s%-15s", "Index", "Name", |
Florin Coras | 8f107b3 | 2017-11-21 22:13:03 -0800 | [diff] [blame] | 841 | "API Client", "Namespace", "Add seg size", "Rx fifo size", |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 842 | "Tx fifo size"); |
| 843 | else |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 844 | s = |
Florin Coras | 8f107b3 | 2017-11-21 22:13:03 -0800 | [diff] [blame] | 845 | format (s, "%-10s%-20s%-15s%-40s", "Index", "Name", "API Client", |
| 846 | "Namespace"); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 847 | return s; |
| 848 | } |
| 849 | |
| 850 | app_name = app_get_name_from_reg_index (app); |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 851 | app_ns_name = app_namespace_id_from_index (app->ns_index); |
Florin Coras | ad0c77f | 2017-11-09 18:00:15 -0800 | [diff] [blame] | 852 | props = segment_manager_properties_get (app->sm_properties); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 853 | if (verbose) |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 854 | s = |
Florin Coras | 8f107b3 | 2017-11-21 22:13:03 -0800 | [diff] [blame] | 855 | format (s, "%-10d%-20s%-15d%-15d%-15d%-15d%-15d", app->index, app_name, |
| 856 | app->api_client_index, app->ns_index, |
Florin Coras | ad0c77f | 2017-11-09 18:00:15 -0800 | [diff] [blame] | 857 | props->add_segment_size, |
| 858 | props->rx_fifo_size, props->tx_fifo_size); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 859 | else |
Florin Coras | 8f107b3 | 2017-11-21 22:13:03 -0800 | [diff] [blame] | 860 | s = format (s, "%-10d%-20s%-15d%-40s", app->index, app_name, |
| 861 | app->api_client_index, app_ns_name); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 862 | return s; |
| 863 | } |
| 864 | |
| 865 | static clib_error_t * |
| 866 | show_app_command_fn (vlib_main_t * vm, unformat_input_t * input, |
| 867 | vlib_cli_command_t * cmd) |
| 868 | { |
| 869 | application_t *app; |
| 870 | int do_server = 0; |
| 871 | int do_client = 0; |
| 872 | int verbose = 0; |
| 873 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 874 | session_cli_return_if_not_enabled (); |
Florin Coras | e04c299 | 2017-03-01 08:17:34 -0800 | [diff] [blame] | 875 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 876 | while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) |
| 877 | { |
| 878 | if (unformat (input, "server")) |
| 879 | do_server = 1; |
| 880 | else if (unformat (input, "client")) |
| 881 | do_client = 1; |
| 882 | else if (unformat (input, "verbose")) |
| 883 | verbose = 1; |
| 884 | else |
| 885 | break; |
| 886 | } |
| 887 | |
| 888 | if (do_server) |
| 889 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 890 | u64 handle; |
| 891 | u32 index; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 892 | if (pool_elts (app_pool)) |
| 893 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 894 | vlib_cli_output (vm, "%U", format_application_listener, |
| 895 | 0 /* header */ , 0, 0, |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 896 | verbose); |
Florin Coras | 1c71045 | 2017-10-17 00:03:13 -0700 | [diff] [blame] | 897 | /* *INDENT-OFF* */ |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 898 | pool_foreach (app, app_pool, |
| 899 | ({ |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 900 | /* App's listener sessions */ |
| 901 | if (hash_elts (app->listeners_table) == 0) |
| 902 | continue; |
| 903 | hash_foreach (handle, index, app->listeners_table, |
| 904 | ({ |
| 905 | vlib_cli_output (vm, "%U", format_application_listener, app, |
| 906 | handle, index, verbose); |
| 907 | })); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 908 | })); |
| 909 | /* *INDENT-ON* */ |
| 910 | } |
| 911 | else |
| 912 | vlib_cli_output (vm, "No active server bindings"); |
| 913 | } |
| 914 | |
| 915 | if (do_client) |
| 916 | { |
| 917 | if (pool_elts (app_pool)) |
| 918 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 919 | application_format_connects (0, verbose); |
| 920 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 921 | /* *INDENT-OFF* */ |
| 922 | pool_foreach (app, app_pool, |
| 923 | ({ |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 924 | if (app->connects_seg_manager == (u32)~0) |
| 925 | continue; |
| 926 | application_format_connects (app, verbose); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 927 | })); |
| 928 | /* *INDENT-ON* */ |
| 929 | } |
| 930 | else |
Florin Coras | e04c299 | 2017-03-01 08:17:34 -0800 | [diff] [blame] | 931 | vlib_cli_output (vm, "No active client bindings"); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 932 | } |
| 933 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 934 | /* Print app related info */ |
| 935 | if (!do_server && !do_client) |
| 936 | { |
| 937 | vlib_cli_output (vm, "%U", format_application, 0, verbose); |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 938 | /* *INDENT-OFF* */ |
| 939 | pool_foreach (app, app_pool, ({ |
| 940 | vlib_cli_output (vm, "%U", format_application, app, verbose); |
| 941 | })); |
| 942 | /* *INDENT-ON* */ |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 943 | } |
| 944 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 945 | return 0; |
| 946 | } |
| 947 | |
Florin Coras | e04c299 | 2017-03-01 08:17:34 -0800 | [diff] [blame] | 948 | /* *INDENT-OFF* */ |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 949 | VLIB_CLI_COMMAND (show_app_command, static) = |
| 950 | { |
Florin Coras | e04c299 | 2017-03-01 08:17:34 -0800 | [diff] [blame] | 951 | .path = "show app", |
| 952 | .short_help = "show app [server|client] [verbose]", |
| 953 | .function = show_app_command_fn, |
| 954 | }; |
| 955 | /* *INDENT-ON* */ |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 956 | |
| 957 | /* |
| 958 | * fd.io coding-style-patch-verification: ON |
| 959 | * |
| 960 | * Local Variables: |
| 961 | * eval: (c-set-style "gnu") |
| 962 | * End: |
| 963 | */ |