Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 1 | /* |
| 2 | * builtin_client.c - vpp built-in tcp client/connect code |
| 3 | * |
| 4 | * Copyright (c) 2017 by Cisco and/or its affiliates. |
| 5 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | * you may not use this file except in compliance with the License. |
| 7 | * You may obtain a copy of the License at: |
| 8 | * |
| 9 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 10 | * |
| 11 | * Unless required by applicable law or agreed to in writing, software |
| 12 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | * See the License for the specific language governing permissions and |
| 15 | * limitations under the License. |
| 16 | */ |
| 17 | |
| 18 | #include <vnet/vnet.h> |
| 19 | #include <vnet/plugin/plugin.h> |
| 20 | #include <vnet/tcp/builtin_client.h> |
| 21 | |
| 22 | #include <vlibapi/api.h> |
| 23 | #include <vlibmemory/api.h> |
| 24 | #include <vlibsocket/api.h> |
| 25 | #include <vpp/app/version.h> |
| 26 | |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 27 | #define TCP_BUILTIN_CLIENT_DBG (0) |
Florin Coras | 3e350af | 2017-03-30 02:54:28 -0700 | [diff] [blame] | 28 | |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 29 | static void |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 30 | signal_evt_to_cli_i (int *code) |
| 31 | { |
| 32 | tclient_main_t *tm = &tclient_main; |
| 33 | ASSERT (vlib_get_thread_index () == 0); |
| 34 | vlib_process_signal_event (tm->vlib_main, tm->cli_node_index, *code, 0); |
| 35 | } |
| 36 | |
| 37 | static void |
| 38 | signal_evt_to_cli (int code) |
| 39 | { |
| 40 | if (vlib_get_thread_index () != 0) |
| 41 | vl_api_rpc_call_main_thread (signal_evt_to_cli_i, (u8 *) & code, |
| 42 | sizeof (code)); |
| 43 | else |
| 44 | signal_evt_to_cli_i (&code); |
| 45 | } |
| 46 | |
| 47 | static void |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 48 | send_test_chunk (tclient_main_t * tm, session_t * s) |
| 49 | { |
| 50 | u8 *test_data = tm->connect_test_data; |
Dave Barach | 45ce3fb | 2017-03-28 12:31:33 -0400 | [diff] [blame] | 51 | int test_buf_offset; |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 52 | u32 bytes_this_chunk; |
| 53 | session_fifo_event_t evt; |
| 54 | static int serial_number = 0; |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 55 | svm_fifo_t *txf; |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 56 | int rv; |
Florin Coras | 82b13a8 | 2017-04-25 11:58:06 -0700 | [diff] [blame] | 57 | |
| 58 | ASSERT (vec_len (test_data) > 0); |
| 59 | |
Florin Coras | 3e350af | 2017-03-30 02:54:28 -0700 | [diff] [blame] | 60 | test_buf_offset = s->bytes_sent % vec_len (test_data); |
| 61 | bytes_this_chunk = vec_len (test_data) - test_buf_offset; |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 62 | |
Florin Coras | 3e350af | 2017-03-30 02:54:28 -0700 | [diff] [blame] | 63 | bytes_this_chunk = bytes_this_chunk < s->bytes_to_send |
| 64 | ? bytes_this_chunk : s->bytes_to_send; |
| 65 | |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 66 | txf = s->server_tx_fifo; |
| 67 | rv = svm_fifo_enqueue_nowait (txf, bytes_this_chunk, |
Florin Coras | 3e350af | 2017-03-30 02:54:28 -0700 | [diff] [blame] | 68 | test_data + test_buf_offset); |
| 69 | |
| 70 | /* If we managed to enqueue data... */ |
| 71 | if (rv > 0) |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 72 | { |
Dave Barach | 0194f1a | 2017-05-15 10:11:39 -0400 | [diff] [blame] | 73 | /* Account for it... */ |
| 74 | s->bytes_to_send -= rv; |
| 75 | s->bytes_sent += rv; |
| 76 | |
Florin Coras | 3e350af | 2017-03-30 02:54:28 -0700 | [diff] [blame] | 77 | if (TCP_BUILTIN_CLIENT_DBG) |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 78 | { |
Florin Coras | 3e350af | 2017-03-30 02:54:28 -0700 | [diff] [blame] | 79 | /* *INDENT-OFF* */ |
| 80 | ELOG_TYPE_DECLARE (e) = |
| 81 | { |
Dave Barach | 0194f1a | 2017-05-15 10:11:39 -0400 | [diff] [blame] | 82 | .format = "tx-enq: xfer %d bytes, sent %u remain %u", |
| 83 | .format_args = "i4i4i4", |
Florin Coras | 3e350af | 2017-03-30 02:54:28 -0700 | [diff] [blame] | 84 | }; |
| 85 | /* *INDENT-ON* */ |
| 86 | struct |
| 87 | { |
Dave Barach | 0194f1a | 2017-05-15 10:11:39 -0400 | [diff] [blame] | 88 | u32 data[3]; |
Florin Coras | 3e350af | 2017-03-30 02:54:28 -0700 | [diff] [blame] | 89 | } *ed; |
| 90 | ed = ELOG_DATA (&vlib_global_main.elog_main, e); |
| 91 | ed->data[0] = rv; |
Dave Barach | 0194f1a | 2017-05-15 10:11:39 -0400 | [diff] [blame] | 92 | ed->data[1] = s->bytes_sent; |
| 93 | ed->data[2] = s->bytes_to_send; |
Florin Coras | 3e350af | 2017-03-30 02:54:28 -0700 | [diff] [blame] | 94 | } |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 95 | |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 96 | /* Poke the session layer */ |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 97 | if (svm_fifo_set_event (txf)) |
Florin Coras | 3e350af | 2017-03-30 02:54:28 -0700 | [diff] [blame] | 98 | { |
| 99 | /* Fabricate TX event, send to vpp */ |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 100 | evt.fifo = txf; |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 101 | evt.event_type = FIFO_EVENT_APP_TX; |
Florin Coras | 3e350af | 2017-03-30 02:54:28 -0700 | [diff] [blame] | 102 | evt.event_id = serial_number++; |
| 103 | |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 104 | if (unix_shared_memory_queue_add |
| 105 | (tm->vpp_event_queue[txf->master_thread_index], (u8 *) & evt, |
| 106 | 0 /* do wait for mutex */ )) |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 107 | clib_warning ("could not enqueue event"); |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 108 | } |
| 109 | } |
| 110 | } |
| 111 | |
| 112 | static void |
| 113 | receive_test_chunk (tclient_main_t * tm, session_t * s) |
| 114 | { |
| 115 | svm_fifo_t *rx_fifo = s->server_rx_fifo; |
Florin Coras | 3e350af | 2017-03-30 02:54:28 -0700 | [diff] [blame] | 116 | int n_read, test_bytes = 0; |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 117 | u32 my_thread_index = vlib_get_thread_index (); |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 118 | |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 119 | /* Allow enqueuing of new event */ |
Florin Coras | 3e350af | 2017-03-30 02:54:28 -0700 | [diff] [blame] | 120 | // svm_fifo_unset_event (rx_fifo); |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 121 | |
Florin Coras | 93992a9 | 2017-05-24 18:03:56 -0700 | [diff] [blame] | 122 | if (test_bytes) |
| 123 | { |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 124 | n_read = svm_fifo_dequeue_nowait (rx_fifo, |
| 125 | vec_len (tm->rx_buf[my_thread_index]), |
| 126 | tm->rx_buf[my_thread_index]); |
Florin Coras | 93992a9 | 2017-05-24 18:03:56 -0700 | [diff] [blame] | 127 | } |
| 128 | else |
| 129 | { |
| 130 | n_read = svm_fifo_max_dequeue (rx_fifo); |
| 131 | svm_fifo_dequeue_drop (rx_fifo, n_read); |
| 132 | } |
| 133 | |
Florin Coras | 3e350af | 2017-03-30 02:54:28 -0700 | [diff] [blame] | 134 | if (n_read > 0) |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 135 | { |
Florin Coras | 3e350af | 2017-03-30 02:54:28 -0700 | [diff] [blame] | 136 | if (TCP_BUILTIN_CLIENT_DBG) |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 137 | { |
Florin Coras | 3e350af | 2017-03-30 02:54:28 -0700 | [diff] [blame] | 138 | /* *INDENT-OFF* */ |
| 139 | ELOG_TYPE_DECLARE (e) = |
| 140 | { |
| 141 | .format = "rx-deq: %d bytes", |
| 142 | .format_args = "i4", |
| 143 | }; |
| 144 | /* *INDENT-ON* */ |
| 145 | struct |
| 146 | { |
| 147 | u32 data[1]; |
| 148 | } *ed; |
| 149 | ed = ELOG_DATA (&vlib_global_main.elog_main, e); |
| 150 | ed->data[0] = n_read; |
| 151 | } |
| 152 | |
| 153 | if (test_bytes) |
| 154 | { |
| 155 | int i; |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 156 | for (i = 0; i < n_read; i++) |
| 157 | { |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 158 | if (tm->rx_buf[my_thread_index][i] |
| 159 | != ((s->bytes_received + i) & 0xff)) |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 160 | { |
| 161 | clib_warning ("read %d error at byte %lld, 0x%x not 0x%x", |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 162 | n_read, s->bytes_received + i, |
| 163 | tm->rx_buf[my_thread_index][i], |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 164 | ((s->bytes_received + i) & 0xff)); |
| 165 | } |
| 166 | } |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 167 | } |
Florin Coras | 3e350af | 2017-03-30 02:54:28 -0700 | [diff] [blame] | 168 | s->bytes_to_receive -= n_read; |
| 169 | s->bytes_received += n_read; |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 170 | } |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 171 | } |
| 172 | |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 173 | static uword |
| 174 | builtin_client_node_fn (vlib_main_t * vm, vlib_node_runtime_t * node, |
| 175 | vlib_frame_t * frame) |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 176 | { |
| 177 | tclient_main_t *tm = &tclient_main; |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 178 | int my_thread_index = vlib_get_thread_index (); |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 179 | session_t *sp; |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 180 | int i; |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 181 | int delete_session; |
| 182 | u32 *connection_indices; |
Dave Barach | 2c25a62 | 2017-06-26 11:35:07 -0400 | [diff] [blame] | 183 | u32 *connections_this_batch; |
| 184 | u32 nconnections_this_batch; |
Dave Barach | 0194f1a | 2017-05-15 10:11:39 -0400 | [diff] [blame] | 185 | |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 186 | connection_indices = tm->connection_index_by_thread[my_thread_index]; |
Dave Barach | 2c25a62 | 2017-06-26 11:35:07 -0400 | [diff] [blame] | 187 | connections_this_batch = |
| 188 | tm->connections_this_batch_by_thread[my_thread_index]; |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 189 | |
Dave Barach | 2c25a62 | 2017-06-26 11:35:07 -0400 | [diff] [blame] | 190 | if ((tm->run_test == 0) || |
| 191 | ((vec_len (connection_indices) == 0) |
| 192 | && vec_len (connections_this_batch) == 0)) |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 193 | return 0; |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 194 | |
Dave Barach | 2c25a62 | 2017-06-26 11:35:07 -0400 | [diff] [blame] | 195 | /* Grab another pile of connections */ |
| 196 | if (PREDICT_FALSE (vec_len (connections_this_batch) == 0)) |
| 197 | { |
| 198 | nconnections_this_batch = |
| 199 | clib_min (tm->connections_per_batch, vec_len (connection_indices)); |
| 200 | |
| 201 | ASSERT (nconnections_this_batch > 0); |
| 202 | vec_validate (connections_this_batch, nconnections_this_batch - 1); |
| 203 | clib_memcpy (connections_this_batch, |
| 204 | connection_indices + vec_len (connection_indices) |
| 205 | - nconnections_this_batch, |
| 206 | nconnections_this_batch * sizeof (u32)); |
| 207 | _vec_len (connection_indices) -= nconnections_this_batch; |
| 208 | } |
| 209 | |
| 210 | if (PREDICT_FALSE (tm->prev_conns != tm->connections_per_batch |
| 211 | && tm->prev_conns == vec_len (connections_this_batch))) |
| 212 | { |
| 213 | tm->repeats++; |
| 214 | tm->prev_conns = vec_len (connections_this_batch); |
| 215 | if (tm->repeats == 500000) |
| 216 | { |
| 217 | clib_warning ("stuck clients"); |
| 218 | } |
| 219 | } |
| 220 | else |
| 221 | { |
| 222 | tm->prev_conns = vec_len (connections_this_batch); |
| 223 | tm->repeats = 0; |
| 224 | } |
| 225 | |
| 226 | for (i = 0; i < vec_len (connections_this_batch); i++) |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 227 | { |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 228 | delete_session = 1; |
| 229 | |
Dave Barach | 2c25a62 | 2017-06-26 11:35:07 -0400 | [diff] [blame] | 230 | sp = pool_elt_at_index (tm->sessions, connections_this_batch[i]); |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 231 | |
Dave Barach | 2c25a62 | 2017-06-26 11:35:07 -0400 | [diff] [blame] | 232 | if (sp->bytes_to_send > 0) |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 233 | { |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 234 | send_test_chunk (tm, sp); |
| 235 | delete_session = 0; |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 236 | } |
Dave Barach | 2c25a62 | 2017-06-26 11:35:07 -0400 | [diff] [blame] | 237 | if (sp->bytes_to_receive > 0) |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 238 | { |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 239 | receive_test_chunk (tm, sp); |
| 240 | delete_session = 0; |
| 241 | } |
| 242 | if (PREDICT_FALSE (delete_session == 1)) |
| 243 | { |
Dave Barach | 2c25a62 | 2017-06-26 11:35:07 -0400 | [diff] [blame] | 244 | u32 index, thread_index; |
| 245 | stream_session_t *s; |
| 246 | |
| 247 | __sync_fetch_and_add (&tm->tx_total, sp->bytes_sent); |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 248 | __sync_fetch_and_add (&tm->rx_total, sp->bytes_received); |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 249 | |
Dave Barach | 2c25a62 | 2017-06-26 11:35:07 -0400 | [diff] [blame] | 250 | stream_session_parse_handle (sp->vpp_session_handle, |
| 251 | &index, &thread_index); |
| 252 | s = stream_session_get_if_valid (index, thread_index); |
| 253 | |
| 254 | if (s) |
Florin Coras | 93992a9 | 2017-05-24 18:03:56 -0700 | [diff] [blame] | 255 | { |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 256 | vnet_disconnect_args_t _a, *a = &_a; |
| 257 | a->handle = stream_session_handle (s); |
| 258 | a->app_index = tm->app_index; |
| 259 | vnet_disconnect_session (a); |
| 260 | |
Dave Barach | 2c25a62 | 2017-06-26 11:35:07 -0400 | [diff] [blame] | 261 | vec_delete (connections_this_batch, 1, i); |
| 262 | i--; |
Florin Coras | 93992a9 | 2017-05-24 18:03:56 -0700 | [diff] [blame] | 263 | __sync_fetch_and_add (&tm->ready_connections, -1); |
| 264 | } |
| 265 | else |
Dave Barach | 2c25a62 | 2017-06-26 11:35:07 -0400 | [diff] [blame] | 266 | clib_warning ("session AWOL?"); |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 267 | |
| 268 | /* Kick the debug CLI process */ |
| 269 | if (tm->ready_connections == 0) |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 270 | { |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 271 | signal_evt_to_cli (2); |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 272 | } |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 273 | } |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 274 | } |
Dave Barach | 2c25a62 | 2017-06-26 11:35:07 -0400 | [diff] [blame] | 275 | |
| 276 | tm->connection_index_by_thread[my_thread_index] = connection_indices; |
| 277 | tm->connections_this_batch_by_thread[my_thread_index] = |
| 278 | connections_this_batch; |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 279 | return 0; |
| 280 | } |
| 281 | |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 282 | /* *INDENT-OFF* */ |
| 283 | VLIB_REGISTER_NODE (builtin_client_node) = |
| 284 | { |
| 285 | .function = builtin_client_node_fn, |
| 286 | .name = "builtin-tcp-client", |
| 287 | .type = VLIB_NODE_TYPE_INPUT, |
| 288 | .state = VLIB_NODE_STATE_DISABLED, |
| 289 | }; |
| 290 | /* *INDENT-ON* */ |
| 291 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 292 | static int |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 293 | create_api_loopback (tclient_main_t * tm) |
| 294 | { |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 295 | api_main_t *am = &api_main; |
| 296 | vl_shmem_hdr_t *shmem_hdr; |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 297 | |
| 298 | shmem_hdr = am->shmem_hdr; |
| 299 | tm->vl_input_queue = shmem_hdr->vl_input_queue; |
Dave Barach | 52851e6 | 2017-08-07 09:35:25 -0400 | [diff] [blame] | 300 | tm->my_client_index = |
| 301 | vl_api_memclnt_create_internal ("tcp_test_client", tm->vl_input_queue); |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 302 | return 0; |
| 303 | } |
| 304 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 305 | static int |
| 306 | tcp_test_clients_init (vlib_main_t * vm) |
| 307 | { |
| 308 | tclient_main_t *tm = &tclient_main; |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 309 | vlib_thread_main_t *vtm = vlib_get_thread_main (); |
| 310 | u32 num_threads; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 311 | int i; |
| 312 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 313 | if (create_api_loopback (tm)) |
| 314 | return -1; |
| 315 | |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 316 | num_threads = 1 /* main thread */ + vtm->n_threads; |
| 317 | |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 318 | /* Init test data. Big buffer */ |
| 319 | vec_validate (tm->connect_test_data, 1024 * 1024 - 1); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 320 | for (i = 0; i < vec_len (tm->connect_test_data); i++) |
| 321 | tm->connect_test_data[i] = i & 0xff; |
| 322 | |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 323 | vec_validate (tm->rx_buf, num_threads - 1); |
| 324 | for (i = 0; i < num_threads; i++) |
| 325 | vec_validate (tm->rx_buf[i], vec_len (tm->connect_test_data) - 1); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 326 | |
| 327 | tm->is_init = 1; |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 328 | |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 329 | vec_validate (tm->connection_index_by_thread, vtm->n_vlib_mains); |
| 330 | vec_validate (tm->connections_this_batch_by_thread, vtm->n_vlib_mains); |
| 331 | vec_validate (tm->vpp_event_queue, vtm->n_vlib_mains); |
| 332 | |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 333 | return 0; |
| 334 | } |
| 335 | |
| 336 | static int |
| 337 | builtin_session_connected_callback (u32 app_index, u32 api_context, |
| 338 | stream_session_t * s, u8 is_fail) |
| 339 | { |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 340 | tclient_main_t *tm = &tclient_main; |
| 341 | session_t *session; |
| 342 | u32 session_index; |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 343 | u8 thread_index = vlib_get_thread_index (); |
| 344 | |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 345 | if (is_fail) |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 346 | { |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 347 | clib_warning ("connection %d failed!", api_context); |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 348 | signal_evt_to_cli (-1); |
| 349 | return 0; |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 350 | } |
| 351 | |
Dave Barach | ac0c96b | 2017-08-02 09:19:32 -0400 | [diff] [blame] | 352 | ASSERT (s->thread_index == thread_index); |
| 353 | |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 354 | if (!tm->vpp_event_queue[thread_index]) |
| 355 | tm->vpp_event_queue[thread_index] = |
| 356 | session_manager_get_vpp_event_queue (thread_index); |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 357 | |
| 358 | /* |
| 359 | * Setup session |
| 360 | */ |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 361 | clib_spinlock_lock_if_init (&tm->sessions_lock); |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 362 | pool_get (tm->sessions, session); |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 363 | clib_spinlock_unlock_if_init (&tm->sessions_lock); |
| 364 | |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 365 | memset (session, 0, sizeof (*session)); |
| 366 | session_index = session - tm->sessions; |
Dave Barach | 2c25a62 | 2017-06-26 11:35:07 -0400 | [diff] [blame] | 367 | session->bytes_to_send = tm->bytes_to_send; |
| 368 | session->bytes_to_receive = tm->no_return ? 0ULL : tm->bytes_to_send; |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 369 | session->server_rx_fifo = s->server_rx_fifo; |
| 370 | session->server_rx_fifo->client_session_index = session_index; |
| 371 | session->server_tx_fifo = s->server_tx_fifo; |
| 372 | session->server_tx_fifo->client_session_index = session_index; |
| 373 | session->vpp_session_handle = stream_session_handle (s); |
| 374 | |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 375 | vec_add1 (tm->connection_index_by_thread[thread_index], session_index); |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 376 | __sync_fetch_and_add (&tm->ready_connections, 1); |
| 377 | if (tm->ready_connections == tm->expected_connections) |
| 378 | { |
| 379 | tm->run_test = 1; |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 380 | /* Signal the CLI process that the action is starting... */ |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 381 | signal_evt_to_cli (1); |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 382 | } |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 383 | |
| 384 | return 0; |
| 385 | } |
| 386 | |
| 387 | static void |
| 388 | builtin_session_reset_callback (stream_session_t * s) |
| 389 | { |
Florin Coras | 3eb5062 | 2017-07-13 01:24:57 -0400 | [diff] [blame] | 390 | if (s->session_state == SESSION_STATE_READY) |
| 391 | clib_warning ("Reset active connection %U", format_stream_session, s, 2); |
Florin Coras | 6534b7a | 2017-07-18 05:38:03 -0400 | [diff] [blame] | 392 | stream_session_cleanup (s); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 393 | return; |
| 394 | } |
| 395 | |
| 396 | static int |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 397 | builtin_session_create_callback (stream_session_t * s) |
| 398 | { |
| 399 | return 0; |
| 400 | } |
| 401 | |
| 402 | static void |
| 403 | builtin_session_disconnect_callback (stream_session_t * s) |
| 404 | { |
Florin Coras | 6534b7a | 2017-07-18 05:38:03 -0400 | [diff] [blame] | 405 | tclient_main_t *tm = &tclient_main; |
| 406 | vnet_disconnect_args_t _a, *a = &_a; |
| 407 | a->handle = stream_session_handle (s); |
| 408 | a->app_index = tm->app_index; |
| 409 | vnet_disconnect_session (a); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 410 | return; |
| 411 | } |
| 412 | |
| 413 | static int |
| 414 | builtin_server_rx_callback (stream_session_t * s) |
| 415 | { |
| 416 | return 0; |
| 417 | } |
| 418 | |
| 419 | /* *INDENT-OFF* */ |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 420 | static session_cb_vft_t builtin_clients = { |
| 421 | .session_reset_callback = builtin_session_reset_callback, |
| 422 | .session_connected_callback = builtin_session_connected_callback, |
| 423 | .session_accept_callback = builtin_session_create_callback, |
| 424 | .session_disconnect_callback = builtin_session_disconnect_callback, |
| 425 | .builtin_server_rx_callback = builtin_server_rx_callback |
| 426 | }; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 427 | /* *INDENT-ON* */ |
| 428 | |
| 429 | static int |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 430 | attach_builtin_test_clients_app (void) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 431 | { |
Dave Barach | 0194f1a | 2017-05-15 10:11:39 -0400 | [diff] [blame] | 432 | tclient_main_t *tm = &tclient_main; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 433 | vnet_app_attach_args_t _a, *a = &_a; |
| 434 | u8 segment_name[128]; |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 435 | u32 segment_name_length, prealloc_fifos; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 436 | u64 options[16]; |
| 437 | |
| 438 | segment_name_length = ARRAY_LEN (segment_name); |
| 439 | |
| 440 | memset (a, 0, sizeof (*a)); |
| 441 | memset (options, 0, sizeof (options)); |
| 442 | |
Dave Barach | 0194f1a | 2017-05-15 10:11:39 -0400 | [diff] [blame] | 443 | a->api_client_index = tm->my_client_index; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 444 | a->segment_name = segment_name; |
| 445 | a->segment_name_length = segment_name_length; |
| 446 | a->session_cb_vft = &builtin_clients; |
| 447 | |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 448 | prealloc_fifos = tm->prealloc_fifos ? tm->expected_connections : 1; |
| 449 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 450 | options[SESSION_OPTIONS_ACCEPT_COOKIE] = 0x12345678; |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 451 | options[SESSION_OPTIONS_SEGMENT_SIZE] = (2ULL << 32); |
| 452 | options[SESSION_OPTIONS_RX_FIFO_SIZE] = tm->fifo_size; |
Florin Coras | 6534b7a | 2017-07-18 05:38:03 -0400 | [diff] [blame] | 453 | options[SESSION_OPTIONS_TX_FIFO_SIZE] = tm->fifo_size; |
Dave Barach | 2c25a62 | 2017-06-26 11:35:07 -0400 | [diff] [blame] | 454 | options[APP_OPTIONS_PRIVATE_SEGMENT_COUNT] = tm->private_segment_count; |
| 455 | options[APP_OPTIONS_PRIVATE_SEGMENT_SIZE] = tm->private_segment_size; |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 456 | options[APP_OPTIONS_PREALLOC_FIFO_PAIRS] = prealloc_fifos; |
| 457 | |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 458 | options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_BUILTIN_APP; |
| 459 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 460 | a->options = options; |
| 461 | |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 462 | if (vnet_application_attach (a)) |
| 463 | return -1; |
| 464 | |
| 465 | tm->app_index = a->app_index; |
| 466 | return 0; |
| 467 | } |
| 468 | |
| 469 | static void * |
| 470 | tclient_thread_fn (void *arg) |
| 471 | { |
| 472 | return 0; |
| 473 | } |
| 474 | |
| 475 | /** Start a transmit thread */ |
| 476 | int |
| 477 | start_tx_pthread (tclient_main_t * tm) |
| 478 | { |
| 479 | if (tm->client_thread_handle == 0) |
| 480 | { |
| 481 | int rv = pthread_create (&tm->client_thread_handle, |
| 482 | NULL /*attr */ , |
| 483 | tclient_thread_fn, 0); |
| 484 | if (rv) |
| 485 | { |
| 486 | tm->client_thread_handle = 0; |
| 487 | return -1; |
| 488 | } |
| 489 | } |
| 490 | return 0; |
| 491 | } |
| 492 | |
| 493 | void |
| 494 | clients_connect (vlib_main_t * vm, u8 * uri, u32 n_clients) |
| 495 | { |
| 496 | tclient_main_t *tm = &tclient_main; |
| 497 | vnet_connect_args_t _a, *a = &_a; |
| 498 | int i; |
| 499 | for (i = 0; i < n_clients; i++) |
| 500 | { |
| 501 | memset (a, 0, sizeof (*a)); |
| 502 | |
| 503 | a->uri = (char *) uri; |
| 504 | a->api_context = i; |
| 505 | a->app_index = tm->app_index; |
| 506 | a->mp = 0; |
| 507 | vnet_connect_uri (a); |
| 508 | |
Florin Coras | 66b1131 | 2017-07-31 17:18:03 -0700 | [diff] [blame] | 509 | /* Crude pacing for call setups */ |
| 510 | if ((i % 4) == 0) |
| 511 | vlib_process_suspend (vm, 10e-6); |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 512 | } |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 513 | } |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 514 | |
| 515 | static clib_error_t * |
| 516 | test_tcp_clients_command_fn (vlib_main_t * vm, |
| 517 | unformat_input_t * input, |
| 518 | vlib_cli_command_t * cmd) |
| 519 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 520 | tclient_main_t *tm = &tclient_main; |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 521 | vlib_thread_main_t *thread_main = vlib_get_thread_main (); |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 522 | uword *event_data = 0, event_type; |
| 523 | u8 *default_connect_uri = (u8 *) "tcp://6.0.1.1/1234", *uri; |
| 524 | u64 tmp, total_bytes; |
Florin Coras | 66b1131 | 2017-07-31 17:18:03 -0700 | [diff] [blame] | 525 | f64 test_timeout = 20.0, syn_timeout = 20.0, delta; |
| 526 | f64 time_before_connects; |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 527 | u32 n_clients = 1; |
Florin Coras | 66b1131 | 2017-07-31 17:18:03 -0700 | [diff] [blame] | 528 | int preallocate_sessions = 0; |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 529 | char *transfer_type; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 530 | int i; |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 531 | |
| 532 | tm->bytes_to_send = 8192; |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 533 | tm->no_return = 0; |
| 534 | tm->fifo_size = 64 << 10; |
Dave Barach | 2c25a62 | 2017-06-26 11:35:07 -0400 | [diff] [blame] | 535 | tm->connections_per_batch = 1000; |
| 536 | tm->private_segment_count = 0; |
| 537 | tm->private_segment_size = 0; |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 538 | tm->vlib_main = vm; |
| 539 | if (thread_main->n_vlib_mains > 1) |
| 540 | clib_spinlock_init (&tm->sessions_lock); |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 541 | vec_free (tm->connect_uri); |
| 542 | |
| 543 | while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) |
| 544 | { |
| 545 | if (unformat (input, "nclients %d", &n_clients)) |
| 546 | ; |
Dave Barach | 0194f1a | 2017-05-15 10:11:39 -0400 | [diff] [blame] | 547 | else if (unformat (input, "mbytes %lld", &tmp)) |
| 548 | tm->bytes_to_send = tmp << 20; |
| 549 | else if (unformat (input, "gbytes %lld", &tmp)) |
| 550 | tm->bytes_to_send = tmp << 30; |
Florin Coras | 3e350af | 2017-03-30 02:54:28 -0700 | [diff] [blame] | 551 | else if (unformat (input, "bytes %lld", &tm->bytes_to_send)) |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 552 | ; |
| 553 | else if (unformat (input, "uri %s", &tm->connect_uri)) |
| 554 | ; |
Florin Coras | 66b1131 | 2017-07-31 17:18:03 -0700 | [diff] [blame] | 555 | else if (unformat (input, "test-timeout %f", &test_timeout)) |
| 556 | ; |
| 557 | else if (unformat (input, "syn-timeout %f", &syn_timeout)) |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 558 | ; |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 559 | else if (unformat (input, "no-return")) |
| 560 | tm->no_return = 1; |
| 561 | else if (unformat (input, "fifo-size %d", &tm->fifo_size)) |
| 562 | tm->fifo_size <<= 10; |
Dave Barach | 2c25a62 | 2017-06-26 11:35:07 -0400 | [diff] [blame] | 563 | else if (unformat (input, "private-segment-count %d", |
| 564 | &tm->private_segment_count)) |
| 565 | ; |
| 566 | else if (unformat (input, "private-segment-size %dm", &tmp)) |
| 567 | tm->private_segment_size = tmp << 20; |
| 568 | else if (unformat (input, "private-segment-size %dg", &tmp)) |
| 569 | tm->private_segment_size = tmp << 30; |
| 570 | else if (unformat (input, "private-segment-size %d", &tmp)) |
| 571 | tm->private_segment_size = tmp; |
| 572 | else if (unformat (input, "preallocate-fifos")) |
| 573 | tm->prealloc_fifos = 1; |
Florin Coras | 66b1131 | 2017-07-31 17:18:03 -0700 | [diff] [blame] | 574 | else if (unformat (input, "preallocate-sessions")) |
| 575 | preallocate_sessions = 1; |
Dave Barach | 2c25a62 | 2017-06-26 11:35:07 -0400 | [diff] [blame] | 576 | else |
| 577 | if (unformat (input, "client-batch %d", &tm->connections_per_batch)) |
| 578 | ; |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 579 | else |
| 580 | return clib_error_return (0, "unknown input `%U'", |
| 581 | format_unformat_error, input); |
| 582 | } |
| 583 | |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 584 | /* Store cli process node index for signalling */ |
| 585 | tm->cli_node_index = vlib_get_current_process (vm)->node_runtime.node_index; |
| 586 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 587 | if (tm->is_init == 0) |
| 588 | { |
| 589 | if (tcp_test_clients_init (vm)) |
| 590 | return clib_error_return (0, "failed init"); |
| 591 | } |
| 592 | |
Florin Coras | 66b1131 | 2017-07-31 17:18:03 -0700 | [diff] [blame] | 593 | |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 594 | tm->ready_connections = 0; |
| 595 | tm->expected_connections = n_clients; |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 596 | tm->rx_total = 0; |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 597 | tm->tx_total = 0; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 598 | |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 599 | uri = default_connect_uri; |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 600 | if (tm->connect_uri) |
| 601 | uri = tm->connect_uri; |
| 602 | |
Florin Coras | 3e350af | 2017-03-30 02:54:28 -0700 | [diff] [blame] | 603 | #if TCP_BUILTIN_CLIENT_PTHREAD |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 604 | start_tx_pthread (); |
| 605 | #endif |
| 606 | |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 607 | vlib_worker_thread_barrier_sync (vm); |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 608 | vnet_session_enable_disable (vm, 1 /* turn on TCP, etc. */ ); |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 609 | vlib_worker_thread_barrier_release (vm); |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 610 | |
| 611 | if (tm->test_client_attached == 0) |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 612 | { |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 613 | if (attach_builtin_test_clients_app ()) |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 614 | { |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 615 | return clib_error_return (0, "app attach failed"); |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 616 | } |
| 617 | } |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 618 | tm->test_client_attached = 1; |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 619 | |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 620 | /* Turn on the builtin client input nodes */ |
| 621 | for (i = 0; i < thread_main->n_vlib_mains; i++) |
| 622 | vlib_node_set_state (vlib_mains[i], builtin_client_node.index, |
| 623 | VLIB_NODE_STATE_POLLING); |
| 624 | |
Florin Coras | 66b1131 | 2017-07-31 17:18:03 -0700 | [diff] [blame] | 625 | if (preallocate_sessions) |
| 626 | { |
| 627 | session_t *sp __attribute__ ((unused)); |
| 628 | for (i = 0; i < n_clients; i++) |
| 629 | pool_get (tm->sessions, sp); |
| 630 | for (i = 0; i < n_clients; i++) |
| 631 | pool_put_index (tm->sessions, i); |
| 632 | } |
| 633 | |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 634 | /* Fire off connect requests */ |
Florin Coras | 66b1131 | 2017-07-31 17:18:03 -0700 | [diff] [blame] | 635 | time_before_connects = vlib_time_now (vm); |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 636 | clients_connect (vm, uri, n_clients); |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 637 | |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 638 | /* Park until the sessions come up, or ten seconds elapse... */ |
Florin Coras | 66b1131 | 2017-07-31 17:18:03 -0700 | [diff] [blame] | 639 | vlib_process_wait_for_event_or_clock (vm, syn_timeout); |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 640 | event_type = vlib_process_get_events (vm, &event_data); |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 641 | switch (event_type) |
| 642 | { |
| 643 | case ~0: |
| 644 | vlib_cli_output (vm, "Timeout with only %d sessions active...", |
| 645 | tm->ready_connections); |
| 646 | goto cleanup; |
| 647 | |
| 648 | case 1: |
Florin Coras | 66b1131 | 2017-07-31 17:18:03 -0700 | [diff] [blame] | 649 | delta = vlib_time_now (vm) - time_before_connects; |
| 650 | |
| 651 | if (delta != 0.0) |
| 652 | { |
| 653 | vlib_cli_output |
| 654 | (vm, "%d three-way handshakes in %.2f seconds, %.2f/sec", |
| 655 | n_clients, delta, ((f64) n_clients) / delta); |
| 656 | } |
| 657 | |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 658 | tm->test_start_time = vlib_time_now (tm->vlib_main); |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 659 | vlib_cli_output (vm, "Test started at %.6f", tm->test_start_time); |
| 660 | break; |
| 661 | |
| 662 | default: |
| 663 | vlib_cli_output (vm, "unexpected event(1): %d", event_type); |
| 664 | goto cleanup; |
| 665 | } |
| 666 | |
| 667 | /* Now wait for the sessions to finish... */ |
Florin Coras | 66b1131 | 2017-07-31 17:18:03 -0700 | [diff] [blame] | 668 | vlib_process_wait_for_event_or_clock (vm, test_timeout); |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 669 | event_type = vlib_process_get_events (vm, &event_data); |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 670 | switch (event_type) |
| 671 | { |
| 672 | case ~0: |
| 673 | vlib_cli_output (vm, "Timeout with %d sessions still active...", |
| 674 | tm->ready_connections); |
| 675 | goto cleanup; |
| 676 | |
| 677 | case 2: |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 678 | tm->test_end_time = vlib_time_now (vm); |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 679 | vlib_cli_output (vm, "Test finished at %.6f", tm->test_end_time); |
| 680 | break; |
| 681 | |
| 682 | default: |
| 683 | vlib_cli_output (vm, "unexpected event(2): %d", event_type); |
| 684 | goto cleanup; |
| 685 | } |
| 686 | |
| 687 | delta = tm->test_end_time - tm->test_start_time; |
| 688 | |
| 689 | if (delta != 0.0) |
| 690 | { |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 691 | total_bytes = (tm->no_return ? tm->tx_total : tm->rx_total); |
| 692 | transfer_type = tm->no_return ? "half-duplex" : "full-duplex"; |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 693 | vlib_cli_output (vm, |
| 694 | "%lld bytes (%lld mbytes, %lld gbytes) in %.2f seconds", |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 695 | total_bytes, total_bytes / (1ULL << 20), |
| 696 | total_bytes / (1ULL << 30), delta); |
| 697 | vlib_cli_output (vm, "%.2f bytes/second %s", |
| 698 | ((f64) total_bytes) / (delta), transfer_type); |
| 699 | vlib_cli_output (vm, "%.4f gbit/second %s", |
| 700 | (((f64) total_bytes * 8.0) / delta / 1e9), |
| 701 | transfer_type); |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 702 | } |
| 703 | else |
| 704 | vlib_cli_output (vm, "zero delta-t?"); |
| 705 | |
| 706 | cleanup: |
Dave Barach | 2c25a62 | 2017-06-26 11:35:07 -0400 | [diff] [blame] | 707 | tm->run_test = 0; |
Dave Barach | 10d8cc6 | 2017-05-30 09:30:07 -0400 | [diff] [blame] | 708 | for (i = 0; i < vec_len (tm->connection_index_by_thread); i++) |
Dave Barach | 2c25a62 | 2017-06-26 11:35:07 -0400 | [diff] [blame] | 709 | { |
| 710 | vec_reset_length (tm->connection_index_by_thread[i]); |
| 711 | vec_reset_length (tm->connections_this_batch_by_thread[i]); |
| 712 | } |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 713 | |
Dave Barach | 2c25a62 | 2017-06-26 11:35:07 -0400 | [diff] [blame] | 714 | pool_free (tm->sessions); |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 715 | |
Dave Barach | 818eb54 | 2017-08-02 13:56:13 -0400 | [diff] [blame] | 716 | /* Detach the application, so we can use different fifo sizes next time */ |
| 717 | if (tm->test_client_attached) |
| 718 | { |
| 719 | vnet_app_detach_args_t _da, *da = &_da; |
| 720 | int rv; |
| 721 | |
| 722 | da->app_index = tm->app_index; |
| 723 | |
| 724 | rv = vnet_application_detach (da); |
| 725 | if (rv) |
| 726 | vlib_cli_output (vm, "WARNING: app detach failed..."); |
| 727 | tm->test_client_attached = 0; |
| 728 | tm->app_index = ~0; |
| 729 | } |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 730 | return 0; |
| 731 | } |
| 732 | |
Florin Coras | 3e350af | 2017-03-30 02:54:28 -0700 | [diff] [blame] | 733 | /* *INDENT-OFF* */ |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 734 | VLIB_CLI_COMMAND (test_clients_command, static) = |
| 735 | { |
| 736 | .path = "test tcp clients", |
Dave Barach | 0194f1a | 2017-05-15 10:11:39 -0400 | [diff] [blame] | 737 | .short_help = "test tcp clients [nclients %d]" |
| 738 | "[iterations %d] [bytes %d] [uri tcp://6.0.1.1/1234]", |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 739 | .function = test_tcp_clients_command_fn, |
Florin Coras | 6881062 | 2017-07-24 17:40:28 -0700 | [diff] [blame] | 740 | .is_mp_safe = 1, |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 741 | }; |
| 742 | /* *INDENT-ON* */ |
| 743 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 744 | clib_error_t * |
| 745 | tcp_test_clients_main_init (vlib_main_t * vm) |
| 746 | { |
| 747 | tclient_main_t *tm = &tclient_main; |
| 748 | tm->is_init = 0; |
| 749 | return 0; |
| 750 | } |
| 751 | |
| 752 | VLIB_INIT_FUNCTION (tcp_test_clients_main_init); |
| 753 | |
Florin Coras | 6792ec0 | 2017-03-13 03:49:51 -0700 | [diff] [blame] | 754 | /* |
| 755 | * fd.io coding-style-patch-verification: ON |
| 756 | * |
| 757 | * Local Variables: |
| 758 | * eval: (c-set-style "gnu") |
| 759 | * End: |
| 760 | */ |