Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1 | /* |
Florin Coras | 288eaab | 2019-02-03 15:26:14 -0800 | [diff] [blame] | 2 | * Copyright (c) 2017-2019 Cisco and/or its affiliates. |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 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/segment_manager.h> |
| 17 | #include <vnet/session/session.h> |
| 18 | #include <vnet/session/application.h> |
| 19 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 20 | typedef struct segment_manager_main_ |
| 21 | { |
| 22 | segment_manager_t *segment_managers; /**< Pool of segment managers */ |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 23 | u32 seg_name_counter; /**< Counter for segment names */ |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 24 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 25 | /* |
| 26 | * Configuration |
| 27 | */ |
Ryujiro Shibuya | d8f48e2 | 2020-01-22 12:11:42 +0000 | [diff] [blame] | 28 | u32 default_fifo_size; /**< default rx/tx fifo size */ |
| 29 | u32 default_segment_size; /**< default fifo segment size */ |
| 30 | u32 default_app_mq_size; /**< default app msg q size */ |
| 31 | u32 default_max_fifo_size; /**< default max fifo size */ |
| 32 | u8 default_high_watermark; /**< default high watermark % */ |
| 33 | u8 default_low_watermark; /**< default low watermark % */ |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 34 | } segment_manager_main_t; |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 35 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 36 | static segment_manager_main_t sm_main; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 37 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 38 | #define segment_manager_foreach_segment_w_lock(VAR, SM, BODY) \ |
| 39 | do { \ |
| 40 | clib_rwlock_reader_lock (&(SM)->segments_rwlock); \ |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 41 | pool_foreach((VAR), ((SM)->segments)) (BODY); \ |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 42 | clib_rwlock_reader_unlock (&(SM)->segments_rwlock); \ |
| 43 | } while (0) |
| 44 | |
| 45 | static segment_manager_props_t * |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 46 | segment_manager_properties_get (segment_manager_t * sm) |
Florin Coras | ad0c77f | 2017-11-09 18:00:15 -0800 | [diff] [blame] | 47 | { |
Florin Coras | ab2f6db | 2018-08-31 14:31:41 -0700 | [diff] [blame] | 48 | app_worker_t *app_wrk = app_worker_get (sm->app_wrk_index); |
| 49 | return application_get_segment_manager_properties (app_wrk->app_index); |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 50 | } |
| 51 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 52 | segment_manager_props_t * |
| 53 | segment_manager_props_init (segment_manager_props_t * props) |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 54 | { |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 55 | props->add_segment_size = sm_main.default_segment_size; |
| 56 | props->rx_fifo_size = sm_main.default_fifo_size; |
| 57 | props->tx_fifo_size = sm_main.default_fifo_size; |
| 58 | props->evt_q_size = sm_main.default_app_mq_size; |
Ryujiro Shibuya | d8f48e2 | 2020-01-22 12:11:42 +0000 | [diff] [blame] | 59 | props->max_fifo_size = sm_main.default_max_fifo_size; |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 60 | props->high_watermark = sm_main.default_high_watermark; |
| 61 | props->low_watermark = sm_main.default_low_watermark; |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 62 | props->n_slices = vlib_num_workers () + 1; |
Florin Coras | ad0c77f | 2017-11-09 18:00:15 -0800 | [diff] [blame] | 63 | return props; |
| 64 | } |
| 65 | |
Florin Coras | bf39597 | 2020-04-30 15:05:24 +0000 | [diff] [blame] | 66 | u8 |
Florin Coras | 9d06304 | 2017-09-14 03:08:00 -0400 | [diff] [blame] | 67 | segment_manager_app_detached (segment_manager_t * sm) |
| 68 | { |
Florin Coras | c8e812f | 2020-05-14 05:32:18 +0000 | [diff] [blame] | 69 | return (sm->flags & SEG_MANAGER_F_DETACHED); |
Dave Wallace | 7b749fe | 2017-07-05 14:30:46 -0400 | [diff] [blame] | 70 | } |
| 71 | |
Florin Coras | 4e4531e | 2017-11-06 23:27:56 -0800 | [diff] [blame] | 72 | void |
| 73 | segment_manager_app_detach (segment_manager_t * sm) |
| 74 | { |
Florin Coras | c8e812f | 2020-05-14 05:32:18 +0000 | [diff] [blame] | 75 | sm->flags |= SEG_MANAGER_F_DETACHED; |
Florin Coras | 4e4531e | 2017-11-06 23:27:56 -0800 | [diff] [blame] | 76 | } |
| 77 | |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 78 | always_inline u32 |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 79 | segment_manager_segment_index (segment_manager_t * sm, fifo_segment_t * seg) |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 80 | { |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 81 | return (seg - sm->segments); |
| 82 | } |
| 83 | |
| 84 | /** |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 85 | * Adds segment to segment manager's pool |
| 86 | * |
| 87 | * If needed a writer's lock is acquired before allocating a new segment |
| 88 | * to avoid affecting any of the segments pool readers. |
| 89 | */ |
Florin Coras | 6973c73 | 2021-06-17 15:53:38 -0700 | [diff] [blame] | 90 | static inline int |
| 91 | segment_manager_add_segment_inline (segment_manager_t *sm, uword segment_size, |
| 92 | u8 notify_app, u8 flags) |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 93 | { |
| 94 | segment_manager_main_t *smm = &sm_main; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 95 | segment_manager_props_t *props; |
| 96 | fifo_segment_t *fs; |
Florin Coras | 9a45bd8 | 2020-12-28 16:28:07 -0800 | [diff] [blame] | 97 | u32 fs_index = ~0; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 98 | u8 *seg_name; |
| 99 | int rv; |
| 100 | |
| 101 | props = segment_manager_properties_get (sm); |
| 102 | |
| 103 | /* Not configured for addition of new segments and not first */ |
| 104 | if (!props->add_segment && !segment_size) |
| 105 | { |
| 106 | clib_warning ("cannot allocate new segment"); |
| 107 | return VNET_API_ERROR_INVALID_VALUE; |
| 108 | } |
| 109 | |
| 110 | /* |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 111 | * Allocate fifo segment and grab lock if needed |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 112 | */ |
| 113 | if (vlib_num_workers ()) |
| 114 | clib_rwlock_writer_lock (&sm->segments_rwlock); |
| 115 | |
| 116 | pool_get_zero (sm->segments, fs); |
| 117 | |
| 118 | /* |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 119 | * Allocate ssvm segment |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 120 | */ |
| 121 | segment_size = segment_size ? segment_size : props->add_segment_size; |
Florin Coras | 9a45bd8 | 2020-12-28 16:28:07 -0800 | [diff] [blame] | 122 | segment_size = round_pow2 (segment_size, clib_mem_get_page_size ()); |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 123 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 124 | if (props->segment_type != SSVM_SEGMENT_PRIVATE) |
| 125 | { |
| 126 | seg_name = format (0, "%d-%d%c", getpid (), smm->seg_name_counter++, 0); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 127 | } |
| 128 | else |
Florin Coras | 2a7c0b6 | 2020-09-28 23:40:28 -0700 | [diff] [blame] | 129 | { |
| 130 | app_worker_t *app_wrk = app_worker_get (sm->app_wrk_index); |
| 131 | application_t *app = application_get (app_wrk->app_index); |
| 132 | seg_name = format (0, "%v segment%c", app->name, 0); |
| 133 | } |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 134 | |
| 135 | fs->ssvm.ssvm_size = segment_size; |
| 136 | fs->ssvm.name = seg_name; |
Florin Coras | 9a45bd8 | 2020-12-28 16:28:07 -0800 | [diff] [blame] | 137 | fs->ssvm.requested_va = 0; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 138 | |
Florin Coras | 5220a26 | 2020-09-29 18:11:24 -0700 | [diff] [blame] | 139 | if ((rv = ssvm_server_init (&fs->ssvm, props->segment_type))) |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 140 | { |
| 141 | clib_warning ("svm_master_init ('%v', %u) failed", seg_name, |
| 142 | segment_size); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 143 | pool_put (sm->segments, fs); |
| 144 | goto done; |
| 145 | } |
| 146 | |
Florin Coras | f9d4ab4 | 2019-05-11 16:55:53 -0700 | [diff] [blame] | 147 | /* |
| 148 | * Initialize fifo segment |
| 149 | */ |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 150 | fs->n_slices = props->n_slices; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 151 | fifo_segment_init (fs); |
| 152 | |
| 153 | /* |
| 154 | * Save segment index before dropping lock, if any held |
| 155 | */ |
| 156 | fs_index = fs - sm->segments; |
| 157 | |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 158 | /* |
| 159 | * Set watermarks in segment |
| 160 | */ |
Florin Coras | afbb33a | 2021-08-10 16:56:34 -0700 | [diff] [blame] | 161 | fs->high_watermark = sm->high_watermark; |
| 162 | fs->low_watermark = sm->low_watermark; |
| 163 | fs->flags = flags; |
| 164 | fs->flags &= ~FIFO_SEGMENT_F_MEM_LIMIT; |
Florin Coras | 2de9c0f | 2020-02-02 19:30:39 +0000 | [diff] [blame] | 165 | fs->h->pct_first_alloc = props->pct_first_alloc; |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 166 | |
liuyacan | 9f29903 | 2021-04-25 20:11:30 +0800 | [diff] [blame] | 167 | if (notify_app) |
| 168 | { |
| 169 | app_worker_t *app_wrk; |
| 170 | u64 fs_handle; |
| 171 | fs_handle = segment_manager_segment_handle (sm, fs); |
| 172 | app_wrk = app_worker_get (sm->app_wrk_index); |
| 173 | rv = app_worker_add_segment_notify (app_wrk, fs_handle); |
| 174 | if (rv) |
| 175 | return rv; |
| 176 | } |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 177 | done: |
| 178 | |
| 179 | if (vlib_num_workers ()) |
| 180 | clib_rwlock_writer_unlock (&sm->segments_rwlock); |
| 181 | |
| 182 | return fs_index; |
| 183 | } |
| 184 | |
Florin Coras | 6973c73 | 2021-06-17 15:53:38 -0700 | [diff] [blame] | 185 | int |
| 186 | segment_manager_add_segment (segment_manager_t *sm, uword segment_size, |
| 187 | u8 notify_app) |
| 188 | { |
| 189 | return segment_manager_add_segment_inline (sm, segment_size, notify_app, 0); |
| 190 | } |
| 191 | |
| 192 | int |
| 193 | segment_manager_add_segment2 (segment_manager_t *sm, uword segment_size, |
| 194 | u8 flags) |
| 195 | { |
| 196 | return segment_manager_add_segment_inline (sm, segment_size, 0, flags); |
| 197 | } |
| 198 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 199 | /** |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 200 | * Remove segment without lock |
| 201 | */ |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 202 | void |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 203 | segment_manager_del_segment (segment_manager_t * sm, fifo_segment_t * fs) |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 204 | { |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 205 | if (ssvm_type (&fs->ssvm) != SSVM_SEGMENT_PRIVATE) |
Florin Coras | a0dbf9e | 2019-03-01 17:12:02 -0800 | [diff] [blame] | 206 | { |
Florin Coras | ea7e708 | 2020-07-07 17:57:28 -0700 | [diff] [blame] | 207 | if (!segment_manager_app_detached (sm)) |
Florin Coras | a0dbf9e | 2019-03-01 17:12:02 -0800 | [diff] [blame] | 208 | { |
| 209 | app_worker_t *app_wrk; |
| 210 | u64 segment_handle; |
| 211 | app_wrk = app_worker_get (sm->app_wrk_index); |
| 212 | segment_handle = segment_manager_segment_handle (sm, fs); |
| 213 | app_worker_del_segment_notify (app_wrk, segment_handle); |
| 214 | } |
| 215 | } |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 216 | |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 217 | fifo_segment_cleanup (fs); |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 218 | ssvm_delete (&fs->ssvm); |
| 219 | |
| 220 | if (CLIB_DEBUG) |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 221 | clib_memset (fs, 0xfb, sizeof (*fs)); |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 222 | pool_put (sm->segments, fs); |
| 223 | } |
| 224 | |
Florin Coras | 57660d9 | 2020-04-04 22:45:34 +0000 | [diff] [blame] | 225 | static fifo_segment_t * |
| 226 | segment_manager_get_segment_if_valid (segment_manager_t * sm, |
| 227 | u32 segment_index) |
| 228 | { |
| 229 | if (pool_is_free_index (sm->segments, segment_index)) |
| 230 | return 0; |
| 231 | return pool_elt_at_index (sm->segments, segment_index); |
| 232 | } |
| 233 | |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 234 | /** |
| 235 | * Removes segment after acquiring writer lock |
| 236 | */ |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 237 | static inline void |
Florin Coras | 2d0e3de | 2020-10-23 16:31:40 -0700 | [diff] [blame] | 238 | sm_lock_and_del_segment_inline (segment_manager_t * sm, u32 fs_index) |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 239 | { |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 240 | fifo_segment_t *fs; |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 241 | u8 is_prealloc; |
| 242 | |
| 243 | clib_rwlock_writer_lock (&sm->segments_rwlock); |
Florin Coras | 57660d9 | 2020-04-04 22:45:34 +0000 | [diff] [blame] | 244 | |
| 245 | fs = segment_manager_get_segment_if_valid (sm, fs_index); |
| 246 | if (!fs) |
| 247 | goto done; |
| 248 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 249 | is_prealloc = fifo_segment_flags (fs) & FIFO_SEGMENT_F_IS_PREALLOCATED; |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 250 | if (is_prealloc && !segment_manager_app_detached (sm)) |
Florin Coras | 57660d9 | 2020-04-04 22:45:34 +0000 | [diff] [blame] | 251 | goto done; |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 252 | |
| 253 | segment_manager_del_segment (sm, fs); |
Florin Coras | 57660d9 | 2020-04-04 22:45:34 +0000 | [diff] [blame] | 254 | |
| 255 | done: |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 256 | clib_rwlock_writer_unlock (&sm->segments_rwlock); |
| 257 | } |
| 258 | |
Florin Coras | 2d0e3de | 2020-10-23 16:31:40 -0700 | [diff] [blame] | 259 | void |
| 260 | segment_manager_lock_and_del_segment (segment_manager_t * sm, u32 fs_index) |
| 261 | { |
| 262 | sm_lock_and_del_segment_inline (sm, fs_index); |
| 263 | } |
| 264 | |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 265 | /** |
| 266 | * Reads a segment from the segment manager's pool without lock |
| 267 | */ |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 268 | fifo_segment_t * |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 269 | segment_manager_get_segment (segment_manager_t * sm, u32 segment_index) |
| 270 | { |
| 271 | return pool_elt_at_index (sm->segments, segment_index); |
| 272 | } |
| 273 | |
Florin Coras | fa76a76 | 2018-11-29 12:40:10 -0800 | [diff] [blame] | 274 | u64 |
| 275 | segment_manager_segment_handle (segment_manager_t * sm, |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 276 | fifo_segment_t * segment) |
Florin Coras | fa76a76 | 2018-11-29 12:40:10 -0800 | [diff] [blame] | 277 | { |
| 278 | u32 segment_index = segment_manager_segment_index (sm, segment); |
| 279 | return (((u64) segment_manager_index (sm) << 32) | segment_index); |
| 280 | } |
| 281 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 282 | u64 |
| 283 | segment_manager_make_segment_handle (u32 segment_manager_index, |
| 284 | u32 segment_index) |
| 285 | { |
| 286 | return (((u64) segment_manager_index << 32) | segment_index); |
| 287 | } |
| 288 | |
| 289 | fifo_segment_t * |
Florin Coras | fa76a76 | 2018-11-29 12:40:10 -0800 | [diff] [blame] | 290 | segment_manager_get_segment_w_handle (u64 segment_handle) |
| 291 | { |
| 292 | u32 sm_index, segment_index; |
| 293 | segment_manager_t *sm; |
| 294 | |
| 295 | segment_manager_parse_segment_handle (segment_handle, &sm_index, |
| 296 | &segment_index); |
| 297 | sm = segment_manager_get (sm_index); |
| 298 | if (!sm || pool_is_free_index (sm->segments, segment_index)) |
| 299 | return 0; |
| 300 | return pool_elt_at_index (sm->segments, segment_index); |
| 301 | } |
| 302 | |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 303 | /** |
| 304 | * Reads a segment from the segment manager's pool and acquires reader lock |
| 305 | * |
| 306 | * Caller must drop the reader's lock by calling |
| 307 | * @ref segment_manager_segment_reader_unlock once it finishes working with |
| 308 | * the segment. |
| 309 | */ |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 310 | fifo_segment_t * |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 311 | segment_manager_get_segment_w_lock (segment_manager_t * sm, u32 segment_index) |
| 312 | { |
| 313 | clib_rwlock_reader_lock (&sm->segments_rwlock); |
| 314 | return pool_elt_at_index (sm->segments, segment_index); |
| 315 | } |
| 316 | |
| 317 | void |
Florin Coras | 75ccf7b | 2020-03-05 19:44:02 +0000 | [diff] [blame] | 318 | segment_manager_segment_reader_lock (segment_manager_t * sm) |
| 319 | { |
| 320 | clib_rwlock_reader_lock (&sm->segments_rwlock); |
| 321 | } |
| 322 | |
| 323 | void |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 324 | segment_manager_segment_reader_unlock (segment_manager_t * sm) |
| 325 | { |
| 326 | clib_rwlock_reader_unlock (&sm->segments_rwlock); |
| 327 | } |
| 328 | |
| 329 | void |
| 330 | segment_manager_segment_writer_unlock (segment_manager_t * sm) |
| 331 | { |
| 332 | clib_rwlock_writer_unlock (&sm->segments_rwlock); |
| 333 | } |
| 334 | |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 335 | segment_manager_t * |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 336 | segment_manager_alloc (void) |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 337 | { |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 338 | segment_manager_main_t *smm = &sm_main; |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 339 | segment_manager_t *sm; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 340 | |
| 341 | pool_get_zero (smm->segment_managers, sm); |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 342 | clib_rwlock_init (&sm->segments_rwlock); |
| 343 | return sm; |
| 344 | } |
| 345 | |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 346 | int |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 347 | segment_manager_init (segment_manager_t * sm) |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 348 | { |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 349 | segment_manager_props_t *props; |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 350 | |
| 351 | props = segment_manager_properties_get (sm); |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 352 | |
Ryujiro Shibuya | d8f48e2 | 2020-01-22 12:11:42 +0000 | [diff] [blame] | 353 | sm->max_fifo_size = props->max_fifo_size ? |
| 354 | props->max_fifo_size : sm_main.default_max_fifo_size; |
| 355 | sm->max_fifo_size = clib_max (sm->max_fifo_size, 4096); |
| 356 | |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 357 | segment_manager_set_watermarks (sm, |
| 358 | props->high_watermark, |
| 359 | props->low_watermark); |
Florin Coras | a107f40 | 2020-09-29 19:18:46 -0700 | [diff] [blame] | 360 | return 0; |
| 361 | } |
| 362 | |
| 363 | /** |
| 364 | * Initializes segment manager based on options provided. |
| 365 | * Returns error if ssvm segment(s) allocation fails. |
| 366 | */ |
| 367 | int |
| 368 | segment_manager_init_first (segment_manager_t * sm) |
| 369 | { |
| 370 | segment_manager_props_t *props; |
| 371 | uword first_seg_size; |
| 372 | fifo_segment_t *fs; |
| 373 | int fs_index, i; |
| 374 | |
| 375 | segment_manager_init (sm); |
| 376 | props = segment_manager_properties_get (sm); |
| 377 | first_seg_size = clib_max (props->segment_size, |
| 378 | sm_main.default_segment_size); |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 379 | |
Florin Coras | 9845c20 | 2020-04-28 01:54:22 +0000 | [diff] [blame] | 380 | if (props->prealloc_fifos) |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 381 | { |
Florin Coras | 9845c20 | 2020-04-28 01:54:22 +0000 | [diff] [blame] | 382 | u64 approx_total_size, max_seg_size = ((u64) 1 << 32) - (128 << 10); |
| 383 | u32 rx_rounded_data_size, tx_rounded_data_size; |
| 384 | u32 prealloc_fifo_pairs = props->prealloc_fifos; |
| 385 | u32 rx_fifo_size, tx_fifo_size, pair_size; |
| 386 | u32 approx_segment_count; |
| 387 | |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 388 | /* Figure out how many segments should be preallocated */ |
| 389 | rx_rounded_data_size = (1 << (max_log2 (props->rx_fifo_size))); |
| 390 | tx_rounded_data_size = (1 << (max_log2 (props->tx_fifo_size))); |
| 391 | |
| 392 | rx_fifo_size = sizeof (svm_fifo_t) + rx_rounded_data_size; |
| 393 | tx_fifo_size = sizeof (svm_fifo_t) + tx_rounded_data_size; |
| 394 | pair_size = rx_fifo_size + tx_fifo_size; |
| 395 | |
| 396 | approx_total_size = (u64) prealloc_fifo_pairs *pair_size; |
| 397 | if (first_seg_size > approx_total_size) |
| 398 | max_seg_size = first_seg_size; |
| 399 | approx_segment_count = (approx_total_size + (max_seg_size - 1)) |
| 400 | / max_seg_size; |
| 401 | |
| 402 | /* Allocate the segments */ |
| 403 | for (i = 0; i < approx_segment_count + 1; i++) |
| 404 | { |
liuyacan | 9f29903 | 2021-04-25 20:11:30 +0800 | [diff] [blame] | 405 | fs_index = segment_manager_add_segment (sm, max_seg_size, 0); |
Florin Coras | 9845c20 | 2020-04-28 01:54:22 +0000 | [diff] [blame] | 406 | if (fs_index < 0) |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 407 | { |
| 408 | clib_warning ("Failed to preallocate segment %d", i); |
Florin Coras | 9845c20 | 2020-04-28 01:54:22 +0000 | [diff] [blame] | 409 | return fs_index; |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 410 | } |
| 411 | |
Florin Coras | 9845c20 | 2020-04-28 01:54:22 +0000 | [diff] [blame] | 412 | fs = segment_manager_get_segment (sm, fs_index); |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 413 | if (i == 0) |
Florin Coras | 9845c20 | 2020-04-28 01:54:22 +0000 | [diff] [blame] | 414 | sm->event_queue = segment_manager_alloc_queue (fs, props); |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 415 | |
Florin Coras | 9845c20 | 2020-04-28 01:54:22 +0000 | [diff] [blame] | 416 | fifo_segment_preallocate_fifo_pairs (fs, |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 417 | props->rx_fifo_size, |
| 418 | props->tx_fifo_size, |
| 419 | &prealloc_fifo_pairs); |
Florin Coras | 9845c20 | 2020-04-28 01:54:22 +0000 | [diff] [blame] | 420 | fifo_segment_flags (fs) = FIFO_SEGMENT_F_IS_PREALLOCATED; |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 421 | if (prealloc_fifo_pairs == 0) |
| 422 | break; |
| 423 | } |
Florin Coras | 9845c20 | 2020-04-28 01:54:22 +0000 | [diff] [blame] | 424 | return 0; |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 425 | } |
Florin Coras | 9845c20 | 2020-04-28 01:54:22 +0000 | [diff] [blame] | 426 | |
liuyacan | 9f29903 | 2021-04-25 20:11:30 +0800 | [diff] [blame] | 427 | fs_index = segment_manager_add_segment (sm, first_seg_size, 0); |
Florin Coras | 9845c20 | 2020-04-28 01:54:22 +0000 | [diff] [blame] | 428 | if (fs_index < 0) |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 429 | { |
Florin Coras | 9845c20 | 2020-04-28 01:54:22 +0000 | [diff] [blame] | 430 | clib_warning ("Failed to allocate segment"); |
| 431 | return fs_index; |
| 432 | } |
| 433 | |
| 434 | fs = segment_manager_get_segment (sm, fs_index); |
| 435 | sm->event_queue = segment_manager_alloc_queue (fs, props); |
| 436 | |
| 437 | if (props->prealloc_fifo_hdrs) |
| 438 | { |
| 439 | u32 hdrs_per_slice; |
| 440 | |
| 441 | /* Do not preallocate on slice associated to main thread */ |
| 442 | i = (vlib_num_workers ()? 1 : 0); |
| 443 | hdrs_per_slice = props->prealloc_fifo_hdrs / (fs->n_slices - i); |
| 444 | |
| 445 | for (; i < fs->n_slices; i++) |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 446 | { |
Florin Coras | 9845c20 | 2020-04-28 01:54:22 +0000 | [diff] [blame] | 447 | if (fifo_segment_prealloc_fifo_hdrs (fs, i, hdrs_per_slice)) |
| 448 | return VNET_API_ERROR_SVM_SEGMENT_CREATE_FAIL; |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 449 | } |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 450 | } |
| 451 | |
| 452 | return 0; |
| 453 | } |
| 454 | |
Florin Coras | c8e812f | 2020-05-14 05:32:18 +0000 | [diff] [blame] | 455 | void |
| 456 | segment_manager_cleanup_detached_listener (segment_manager_t * sm) |
| 457 | { |
| 458 | app_worker_t *app_wrk; |
| 459 | |
| 460 | app_wrk = app_worker_get_if_valid (sm->app_wrk_index); |
| 461 | if (!app_wrk) |
| 462 | return; |
| 463 | |
| 464 | app_worker_del_detached_sm (app_wrk, segment_manager_index (sm)); |
| 465 | } |
| 466 | |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 467 | /** |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 468 | * Cleanup segment manager. |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 469 | */ |
| 470 | void |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 471 | segment_manager_free (segment_manager_t * sm) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 472 | { |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 473 | segment_manager_main_t *smm = &sm_main; |
| 474 | fifo_segment_t *fifo_segment; |
Dave Wallace | 7b749fe | 2017-07-05 14:30:46 -0400 | [diff] [blame] | 475 | |
Florin Coras | 506aa3c | 2020-12-13 21:09:59 -0800 | [diff] [blame] | 476 | ASSERT (vlib_get_thread_index () == 0 |
| 477 | && !segment_manager_has_fifos (sm) |
Florin Coras | 9d06304 | 2017-09-14 03:08:00 -0400 | [diff] [blame] | 478 | && segment_manager_app_detached (sm)); |
| 479 | |
Florin Coras | c8e812f | 2020-05-14 05:32:18 +0000 | [diff] [blame] | 480 | if (sm->flags & SEG_MANAGER_F_DETACHED_LISTENER) |
| 481 | segment_manager_cleanup_detached_listener (sm); |
| 482 | |
Florin Coras | 9d06304 | 2017-09-14 03:08:00 -0400 | [diff] [blame] | 483 | /* If we have empty preallocated segments that haven't been removed, remove |
| 484 | * them now. Apart from that, the first segment in the first segment manager |
| 485 | * is not removed when all fifos are removed. It can only be removed when |
| 486 | * the manager is explicitly deleted/detached by the app. */ |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 487 | clib_rwlock_writer_lock (&sm->segments_rwlock); |
| 488 | |
| 489 | /* *INDENT-OFF* */ |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 490 | pool_foreach (fifo_segment, sm->segments) { |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 491 | segment_manager_del_segment (sm, fifo_segment); |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 492 | } |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 493 | /* *INDENT-ON* */ |
| 494 | |
Florin Coras | f1af21c | 2021-02-26 19:19:11 -0800 | [diff] [blame] | 495 | pool_free (sm->segments); |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 496 | clib_rwlock_writer_unlock (&sm->segments_rwlock); |
| 497 | |
| 498 | clib_rwlock_free (&sm->segments_rwlock); |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 499 | if (CLIB_DEBUG) |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 500 | clib_memset (sm, 0xfe, sizeof (*sm)); |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 501 | pool_put (smm->segment_managers, sm); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 502 | } |
| 503 | |
Florin Coras | 506aa3c | 2020-12-13 21:09:59 -0800 | [diff] [blame] | 504 | static void |
| 505 | sm_free_w_index_helper (void *arg) |
| 506 | { |
| 507 | u32 sm_index = *(u32 *) arg; |
| 508 | segment_manager_t *sm; |
| 509 | |
| 510 | ASSERT (vlib_get_thread_index () == 0); |
| 511 | |
| 512 | if ((sm = segment_manager_get_if_valid (sm_index))) |
| 513 | segment_manager_free (sm); |
| 514 | } |
| 515 | |
Florin Coras | da78c5a | 2021-06-09 14:55:24 -0700 | [diff] [blame] | 516 | void |
| 517 | segment_manager_free_safe (segment_manager_t *sm) |
Florin Coras | 506aa3c | 2020-12-13 21:09:59 -0800 | [diff] [blame] | 518 | { |
| 519 | if (!vlib_thread_is_main_w_barrier ()) |
| 520 | { |
| 521 | u32 sm_index = segment_manager_index (sm); |
| 522 | vlib_rpc_call_main_thread (sm_free_w_index_helper, (u8 *) & sm_index, |
| 523 | sizeof (sm_index)); |
| 524 | } |
| 525 | else |
| 526 | { |
| 527 | segment_manager_free (sm); |
| 528 | } |
| 529 | } |
| 530 | |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 531 | void |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 532 | segment_manager_init_free (segment_manager_t * sm) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 533 | { |
Florin Coras | 506aa3c | 2020-12-13 21:09:59 -0800 | [diff] [blame] | 534 | ASSERT (vlib_get_thread_index () == 0); |
| 535 | |
Florin Coras | 4e4531e | 2017-11-06 23:27:56 -0800 | [diff] [blame] | 536 | segment_manager_app_detach (sm); |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 537 | if (segment_manager_has_fifos (sm)) |
| 538 | segment_manager_del_sessions (sm); |
| 539 | else |
| 540 | { |
Florin Coras | 9d06304 | 2017-09-14 03:08:00 -0400 | [diff] [blame] | 541 | ASSERT (!sm->first_is_protected || segment_manager_app_detached (sm)); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 542 | segment_manager_free (sm); |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 543 | } |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 544 | } |
| 545 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 546 | segment_manager_t * |
| 547 | segment_manager_get (u32 index) |
| 548 | { |
| 549 | return pool_elt_at_index (sm_main.segment_managers, index); |
| 550 | } |
| 551 | |
| 552 | segment_manager_t * |
| 553 | segment_manager_get_if_valid (u32 index) |
| 554 | { |
| 555 | if (pool_is_free_index (sm_main.segment_managers, index)) |
| 556 | return 0; |
| 557 | return pool_elt_at_index (sm_main.segment_managers, index); |
| 558 | } |
| 559 | |
| 560 | u32 |
| 561 | segment_manager_index (segment_manager_t * sm) |
| 562 | { |
| 563 | return sm - sm_main.segment_managers; |
| 564 | } |
| 565 | |
| 566 | u8 |
| 567 | segment_manager_has_fifos (segment_manager_t * sm) |
| 568 | { |
| 569 | fifo_segment_t *seg; |
| 570 | u8 first = 1; |
| 571 | |
| 572 | /* *INDENT-OFF* */ |
| 573 | segment_manager_foreach_segment_w_lock (seg, sm, ({ |
| 574 | if (CLIB_DEBUG && !first && !fifo_segment_has_fifos (seg) |
| 575 | && !(fifo_segment_flags (seg) & FIFO_SEGMENT_F_IS_PREALLOCATED)) |
| 576 | { |
| 577 | clib_warning ("segment %d has no fifos!", |
| 578 | segment_manager_segment_index (sm, seg)); |
| 579 | first = 0; |
| 580 | } |
| 581 | if (fifo_segment_has_fifos (seg)) |
| 582 | { |
| 583 | segment_manager_segment_reader_unlock (sm); |
| 584 | return 1; |
| 585 | } |
| 586 | })); |
| 587 | /* *INDENT-ON* */ |
| 588 | |
| 589 | return 0; |
| 590 | } |
| 591 | |
| 592 | /** |
| 593 | * Initiate disconnects for all sessions 'owned' by a segment manager |
| 594 | */ |
| 595 | void |
| 596 | segment_manager_del_sessions (segment_manager_t * sm) |
| 597 | { |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 598 | session_handle_t *handles = 0, *handle; |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 599 | fifo_segment_t *fs; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 600 | session_t *session; |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 601 | int slice_index; |
| 602 | svm_fifo_t *f; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 603 | |
| 604 | ASSERT (pool_elts (sm->segments) != 0); |
| 605 | |
| 606 | /* Across all fifo segments used by the server */ |
| 607 | /* *INDENT-OFF* */ |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 608 | segment_manager_foreach_segment_w_lock (fs, sm, ({ |
| 609 | for (slice_index = 0; slice_index < fs->n_slices; slice_index++) |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 610 | { |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 611 | f = fifo_segment_get_slice_fifo_list (fs, slice_index); |
| 612 | |
| 613 | /* |
| 614 | * Remove any residual sessions from the session lookup table |
| 615 | * Don't bother deleting the individual fifos, we're going to |
| 616 | * throw away the fifo segment in a minute. |
| 617 | */ |
| 618 | while (f) |
| 619 | { |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 620 | session = session_get_if_valid (f->shr->master_session_index, |
| 621 | f->master_thread_index); |
| 622 | if (session) |
| 623 | vec_add1 (handles, session_handle (session)); |
| 624 | f = f->next; |
| 625 | } |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 626 | } |
| 627 | |
| 628 | /* Instead of removing the segment, test when cleaning up disconnected |
| 629 | * sessions if the segment can be removed. |
| 630 | */ |
| 631 | })); |
| 632 | /* *INDENT-ON* */ |
| 633 | |
| 634 | vec_foreach (handle, handles) |
Florin Coras | 77ea42b | 2020-04-14 23:52:12 +0000 | [diff] [blame] | 635 | { |
| 636 | session = session_get_from_handle (*handle); |
| 637 | session_close (session); |
| 638 | /* Avoid propagating notifications back to the app */ |
| 639 | session->app_wrk_index = APP_INVALID_INDEX; |
| 640 | } |
Florin Coras | f1af21c | 2021-02-26 19:19:11 -0800 | [diff] [blame] | 641 | vec_free (handles); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 642 | } |
| 643 | |
liuyacan | 87d48ad | 2021-04-28 11:34:03 +0000 | [diff] [blame] | 644 | /** |
| 645 | * Initiate disconnects for sessions in specified state 'owned' by a segment |
| 646 | * manager |
| 647 | */ |
| 648 | void |
| 649 | segment_manager_del_sessions_filter (segment_manager_t *sm, |
| 650 | session_state_t *states) |
| 651 | { |
| 652 | session_handle_t *handles = 0, *handle; |
| 653 | fifo_segment_t *fs; |
| 654 | session_t *session; |
| 655 | int slice_index; |
| 656 | svm_fifo_t *f; |
| 657 | |
| 658 | ASSERT (pool_elts (sm->segments) != 0); |
| 659 | |
| 660 | /* Across all fifo segments used by the server */ |
| 661 | segment_manager_foreach_segment_w_lock ( |
| 662 | fs, sm, ({ |
| 663 | for (slice_index = 0; slice_index < fs->n_slices; slice_index++) |
| 664 | { |
| 665 | f = fifo_segment_get_slice_fifo_list (fs, slice_index); |
| 666 | while (f) |
| 667 | { |
| 668 | session = session_get_if_valid (f->shr->master_session_index, |
| 669 | f->master_thread_index); |
| 670 | if (session) |
| 671 | { |
| 672 | session_state_t *state; |
| 673 | vec_foreach (state, states) |
| 674 | { |
| 675 | if (session->session_state == *state) |
| 676 | { |
| 677 | vec_add1 (handles, session_handle (session)); |
| 678 | break; |
| 679 | } |
| 680 | } |
| 681 | } |
| 682 | f = f->next; |
| 683 | } |
| 684 | } |
| 685 | })); |
| 686 | |
| 687 | vec_foreach (handle, handles) |
| 688 | { |
| 689 | session = session_get_from_handle (*handle); |
| 690 | session_close (session); |
| 691 | /* Avoid propagating notifications back to the app */ |
| 692 | session->app_wrk_index = APP_INVALID_INDEX; |
| 693 | } |
| 694 | vec_free (handles); |
| 695 | } |
| 696 | |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 697 | int |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 698 | segment_manager_try_alloc_fifos (fifo_segment_t * fifo_segment, |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 699 | u32 thread_index, |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 700 | u32 rx_fifo_size, u32 tx_fifo_size, |
| 701 | svm_fifo_t ** rx_fifo, svm_fifo_t ** tx_fifo) |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 702 | { |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 703 | rx_fifo_size = clib_max (rx_fifo_size, sm_main.default_fifo_size); |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 704 | *rx_fifo = fifo_segment_alloc_fifo_w_slice (fifo_segment, thread_index, |
| 705 | rx_fifo_size, |
| 706 | FIFO_SEGMENT_RX_FIFO); |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 707 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 708 | tx_fifo_size = clib_max (tx_fifo_size, sm_main.default_fifo_size); |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 709 | *tx_fifo = fifo_segment_alloc_fifo_w_slice (fifo_segment, thread_index, |
| 710 | tx_fifo_size, |
| 711 | FIFO_SEGMENT_TX_FIFO); |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 712 | |
| 713 | if (*rx_fifo == 0) |
| 714 | { |
| 715 | /* This would be very odd, but handle it... */ |
| 716 | if (*tx_fifo != 0) |
| 717 | { |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 718 | fifo_segment_free_fifo (fifo_segment, *tx_fifo); |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 719 | *tx_fifo = 0; |
| 720 | } |
| 721 | return -1; |
| 722 | } |
| 723 | if (*tx_fifo == 0) |
| 724 | { |
| 725 | if (*rx_fifo != 0) |
| 726 | { |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 727 | fifo_segment_free_fifo (fifo_segment, *rx_fifo); |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 728 | *rx_fifo = 0; |
| 729 | } |
| 730 | return -1; |
| 731 | } |
| 732 | |
| 733 | return 0; |
| 734 | } |
| 735 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 736 | int |
| 737 | segment_manager_alloc_session_fifos (segment_manager_t * sm, |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 738 | u32 thread_index, |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 739 | svm_fifo_t ** rx_fifo, |
Florin Coras | 1219b2d | 2019-04-23 15:53:43 -0700 | [diff] [blame] | 740 | svm_fifo_t ** tx_fifo) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 741 | { |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 742 | int alloc_fail = 1, rv = 0, new_fs_index; |
Florin Coras | 75ccf7b | 2020-03-05 19:44:02 +0000 | [diff] [blame] | 743 | uword free_bytes, max_free_bytes = 0; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 744 | segment_manager_props_t *props; |
Florin Coras | 75ccf7b | 2020-03-05 19:44:02 +0000 | [diff] [blame] | 745 | fifo_segment_t *fs = 0, *cur; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 746 | u32 sm_index, fs_index; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 747 | |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 748 | props = segment_manager_properties_get (sm); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 749 | |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 750 | /* |
| 751 | * Find the first free segment to allocate the fifos in |
| 752 | */ |
Florin Coras | 75ccf7b | 2020-03-05 19:44:02 +0000 | [diff] [blame] | 753 | |
| 754 | segment_manager_segment_reader_lock (sm); |
| 755 | |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 756 | pool_foreach (cur, sm->segments) { |
Florin Coras | da78c5a | 2021-06-09 14:55:24 -0700 | [diff] [blame] | 757 | if (fifo_segment_flags (cur) & FIFO_SEGMENT_F_CUSTOM_USE) |
| 758 | continue; |
| 759 | free_bytes = fifo_segment_available_bytes (cur); |
| 760 | if (free_bytes > max_free_bytes) |
| 761 | { |
| 762 | max_free_bytes = free_bytes; |
| 763 | fs = cur; |
| 764 | } |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 765 | } |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 766 | |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 767 | if (fs) |
| 768 | { |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 769 | alloc_fail = segment_manager_try_alloc_fifos (fs, thread_index, |
| 770 | props->rx_fifo_size, |
| 771 | props->tx_fifo_size, |
| 772 | rx_fifo, tx_fifo); |
| 773 | /* On success, keep lock until fifos are initialized */ |
| 774 | if (!alloc_fail) |
| 775 | goto alloc_success; |
Florin Coras | 75ccf7b | 2020-03-05 19:44:02 +0000 | [diff] [blame] | 776 | } |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 777 | |
Florin Coras | 75ccf7b | 2020-03-05 19:44:02 +0000 | [diff] [blame] | 778 | segment_manager_segment_reader_unlock (sm); |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 779 | |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 780 | /* |
| 781 | * Allocation failed, see if we can add a new segment |
| 782 | */ |
| 783 | if (props->add_segment) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 784 | { |
liuyacan | 9f29903 | 2021-04-25 20:11:30 +0800 | [diff] [blame] | 785 | if ((new_fs_index = segment_manager_add_segment (sm, 0, 1)) < 0) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 786 | { |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 787 | clib_warning ("Failed to add new segment"); |
Florin Coras | 00e01d3 | 2019-10-21 16:07:46 -0700 | [diff] [blame] | 788 | return SESSION_E_SEG_CREATE; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 789 | } |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 790 | fs = segment_manager_get_segment_w_lock (sm, new_fs_index); |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 791 | alloc_fail = segment_manager_try_alloc_fifos (fs, thread_index, |
| 792 | props->rx_fifo_size, |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 793 | props->tx_fifo_size, |
| 794 | rx_fifo, tx_fifo); |
liuyacan | 9f29903 | 2021-04-25 20:11:30 +0800 | [diff] [blame] | 795 | if (alloc_fail) |
| 796 | { |
| 797 | clib_warning ("Added a segment, still can't allocate a fifo"); |
| 798 | segment_manager_segment_reader_unlock (sm); |
| 799 | return SESSION_E_SEG_NO_SPACE2; |
| 800 | } |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 801 | } |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 802 | else |
| 803 | { |
Florin Coras | 47cb248 | 2020-07-13 08:52:53 -0700 | [diff] [blame] | 804 | SESSION_DBG ("Can't add new seg and no space to allocate fifos!"); |
Florin Coras | 00e01d3 | 2019-10-21 16:07:46 -0700 | [diff] [blame] | 805 | return SESSION_E_SEG_NO_SPACE; |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 806 | } |
liuyacan | 9f29903 | 2021-04-25 20:11:30 +0800 | [diff] [blame] | 807 | |
| 808 | alloc_success: |
| 809 | ASSERT (rx_fifo && tx_fifo); |
| 810 | |
| 811 | sm_index = segment_manager_index (sm); |
| 812 | fs_index = segment_manager_segment_index (sm, fs); |
| 813 | (*tx_fifo)->segment_manager = sm_index; |
| 814 | (*rx_fifo)->segment_manager = sm_index; |
| 815 | (*tx_fifo)->segment_index = fs_index; |
| 816 | (*rx_fifo)->segment_index = fs_index; |
| 817 | |
| 818 | /* Drop the lock after app is notified */ |
| 819 | segment_manager_segment_reader_unlock (sm); |
| 820 | |
| 821 | return rv; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 822 | } |
| 823 | |
| 824 | void |
Florin Coras | 19223e0 | 2019-03-03 14:56:05 -0800 | [diff] [blame] | 825 | segment_manager_dealloc_fifos (svm_fifo_t * rx_fifo, svm_fifo_t * tx_fifo) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 826 | { |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 827 | segment_manager_t *sm; |
Florin Coras | b095a3c | 2019-04-25 12:58:46 -0700 | [diff] [blame] | 828 | fifo_segment_t *fs; |
Florin Coras | 19223e0 | 2019-03-03 14:56:05 -0800 | [diff] [blame] | 829 | u32 segment_index; |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 830 | |
Florin Coras | 58a93e8 | 2019-01-14 23:33:46 -0800 | [diff] [blame] | 831 | if (!rx_fifo || !tx_fifo) |
| 832 | return; |
| 833 | |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 834 | /* It's possible to have no segment manager if the session was removed |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 835 | * as result of a detach. */ |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 836 | if (!(sm = segment_manager_get_if_valid (rx_fifo->segment_manager))) |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 837 | return; |
| 838 | |
Florin Coras | 19223e0 | 2019-03-03 14:56:05 -0800 | [diff] [blame] | 839 | segment_index = rx_fifo->segment_index; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 840 | fs = segment_manager_get_segment_w_lock (sm, segment_index); |
| 841 | fifo_segment_free_fifo (fs, rx_fifo); |
| 842 | fifo_segment_free_fifo (fs, tx_fifo); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 843 | |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 844 | /* |
| 845 | * Try to remove svm segment if it has no fifos. This can be done only if |
| 846 | * the segment is not the first in the segment manager or if it is first |
| 847 | * and it is not protected. Moreover, if the segment is first and the app |
| 848 | * has detached from the segment manager, remove the segment manager. |
| 849 | */ |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 850 | if (!fifo_segment_has_fifos (fs)) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 851 | { |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 852 | segment_manager_segment_reader_unlock (sm); |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 853 | |
| 854 | /* Remove segment if it holds no fifos or first but not protected */ |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 855 | if (segment_index != 0 || !sm->first_is_protected) |
Florin Coras | 2d0e3de | 2020-10-23 16:31:40 -0700 | [diff] [blame] | 856 | sm_lock_and_del_segment_inline (sm, segment_index); |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 857 | |
| 858 | /* Remove segment manager if no sessions and detached from app */ |
Florin Coras | 9d06304 | 2017-09-14 03:08:00 -0400 | [diff] [blame] | 859 | if (segment_manager_app_detached (sm) |
| 860 | && !segment_manager_has_fifos (sm)) |
Florin Coras | 506aa3c | 2020-12-13 21:09:59 -0800 | [diff] [blame] | 861 | segment_manager_free_safe (sm); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 862 | } |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 863 | else |
| 864 | segment_manager_segment_reader_unlock (sm); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 865 | } |
| 866 | |
Florin Coras | 6d7552c | 2020-04-09 01:49:45 +0000 | [diff] [blame] | 867 | void |
Florin Coras | 0bc78d8 | 2021-01-09 14:34:01 -0800 | [diff] [blame] | 868 | segment_manager_detach_fifo (segment_manager_t *sm, svm_fifo_t **f) |
Florin Coras | 6d7552c | 2020-04-09 01:49:45 +0000 | [diff] [blame] | 869 | { |
| 870 | fifo_segment_t *fs; |
| 871 | |
Florin Coras | 0bc78d8 | 2021-01-09 14:34:01 -0800 | [diff] [blame] | 872 | fs = segment_manager_get_segment_w_lock (sm, (*f)->segment_index); |
Florin Coras | 6d7552c | 2020-04-09 01:49:45 +0000 | [diff] [blame] | 873 | fifo_segment_detach_fifo (fs, f); |
| 874 | segment_manager_segment_reader_unlock (sm); |
| 875 | } |
| 876 | |
| 877 | void |
Florin Coras | 0bc78d8 | 2021-01-09 14:34:01 -0800 | [diff] [blame] | 878 | segment_manager_attach_fifo (segment_manager_t *sm, svm_fifo_t **f, |
| 879 | session_t *s) |
Florin Coras | 6d7552c | 2020-04-09 01:49:45 +0000 | [diff] [blame] | 880 | { |
| 881 | fifo_segment_t *fs; |
| 882 | |
Florin Coras | 0bc78d8 | 2021-01-09 14:34:01 -0800 | [diff] [blame] | 883 | fs = segment_manager_get_segment_w_lock (sm, (*f)->segment_index); |
Florin Coras | 6d7552c | 2020-04-09 01:49:45 +0000 | [diff] [blame] | 884 | fifo_segment_attach_fifo (fs, f, s->thread_index); |
| 885 | segment_manager_segment_reader_unlock (sm); |
| 886 | |
Florin Coras | 0bc78d8 | 2021-01-09 14:34:01 -0800 | [diff] [blame] | 887 | (*f)->shr->master_session_index = s->session_index; |
| 888 | (*f)->master_thread_index = s->thread_index; |
Florin Coras | 6d7552c | 2020-04-09 01:49:45 +0000 | [diff] [blame] | 889 | } |
| 890 | |
Florin Coras | 3c2fed5 | 2018-07-04 04:15:05 -0700 | [diff] [blame] | 891 | u32 |
| 892 | segment_manager_evt_q_expected_size (u32 q_len) |
| 893 | { |
| 894 | u32 fifo_evt_size, notif_q_size, q_hdrs; |
| 895 | u32 msg_q_sz, fifo_evt_ring_sz, session_ntf_ring_sz; |
| 896 | |
Florin Coras | 52207f1 | 2018-07-12 14:48:06 -0700 | [diff] [blame] | 897 | fifo_evt_size = 1 << max_log2 (sizeof (session_event_t)); |
Florin Coras | 3c2fed5 | 2018-07-04 04:15:05 -0700 | [diff] [blame] | 898 | notif_q_size = clib_max (16, q_len >> 4); |
| 899 | |
| 900 | msg_q_sz = q_len * sizeof (svm_msg_q_msg_t); |
| 901 | fifo_evt_ring_sz = q_len * fifo_evt_size; |
| 902 | session_ntf_ring_sz = notif_q_size * 256; |
| 903 | q_hdrs = sizeof (svm_queue_t) + sizeof (svm_msg_q_t); |
| 904 | |
| 905 | return (msg_q_sz + fifo_evt_ring_sz + session_ntf_ring_sz + q_hdrs); |
| 906 | } |
| 907 | |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 908 | /** |
| 909 | * Allocates shm queue in the first segment |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 910 | * |
| 911 | * Must be called with lock held |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 912 | */ |
Florin Coras | 3c2fed5 | 2018-07-04 04:15:05 -0700 | [diff] [blame] | 913 | svm_msg_q_t * |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 914 | segment_manager_alloc_queue (fifo_segment_t * segment, |
| 915 | segment_manager_props_t * props) |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 916 | { |
Florin Coras | 3c2fed5 | 2018-07-04 04:15:05 -0700 | [diff] [blame] | 917 | u32 fifo_evt_size, session_evt_size = 256, notif_q_size; |
| 918 | svm_msg_q_cfg_t _cfg, *cfg = &_cfg; |
| 919 | svm_msg_q_t *q; |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 920 | |
Florin Coras | 52207f1 | 2018-07-12 14:48:06 -0700 | [diff] [blame] | 921 | fifo_evt_size = sizeof (session_event_t); |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 922 | notif_q_size = clib_max (16, props->evt_q_size >> 4); |
Florin Coras | 3c2fed5 | 2018-07-04 04:15:05 -0700 | [diff] [blame] | 923 | /* *INDENT-OFF* */ |
| 924 | svm_msg_q_ring_cfg_t rc[SESSION_MQ_N_RINGS] = { |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 925 | {props->evt_q_size, fifo_evt_size, 0}, |
Florin Coras | 3c2fed5 | 2018-07-04 04:15:05 -0700 | [diff] [blame] | 926 | {notif_q_size, session_evt_size, 0} |
| 927 | }; |
| 928 | /* *INDENT-ON* */ |
| 929 | cfg->consumer_pid = 0; |
| 930 | cfg->n_rings = 2; |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 931 | cfg->q_nitems = props->evt_q_size; |
Florin Coras | 3c2fed5 | 2018-07-04 04:15:05 -0700 | [diff] [blame] | 932 | cfg->ring_cfgs = rc; |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 933 | |
Florin Coras | b462418 | 2020-12-11 13:58:12 -0800 | [diff] [blame] | 934 | q = fifo_segment_msg_q_alloc (segment, 0, cfg); |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 935 | |
| 936 | if (props->use_mq_eventfd) |
| 937 | { |
Florin Coras | 86f1232 | 2021-01-22 15:05:14 -0800 | [diff] [blame] | 938 | if (svm_msg_q_alloc_eventfd (q)) |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 939 | clib_warning ("failed to alloc eventfd"); |
| 940 | } |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 941 | return q; |
| 942 | } |
| 943 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 944 | svm_msg_q_t * |
| 945 | segment_manager_event_queue (segment_manager_t * sm) |
| 946 | { |
| 947 | return sm->event_queue; |
| 948 | } |
| 949 | |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 950 | /** |
| 951 | * Frees shm queue allocated in the first segment |
| 952 | */ |
| 953 | void |
Florin Coras | e86a8ed | 2018-01-05 03:20:25 -0800 | [diff] [blame] | 954 | segment_manager_dealloc_queue (segment_manager_t * sm, svm_queue_t * q) |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 955 | { |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 956 | fifo_segment_t *segment; |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 957 | ssvm_shared_header_t *sh; |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 958 | void *oldheap; |
| 959 | |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 960 | ASSERT (!pool_is_free_index (sm->segments, 0)); |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 961 | |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 962 | segment = segment_manager_get_segment_w_lock (sm, 0); |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 963 | sh = segment->ssvm.sh; |
| 964 | |
| 965 | oldheap = ssvm_push_heap (sh); |
Florin Coras | e86a8ed | 2018-01-05 03:20:25 -0800 | [diff] [blame] | 966 | svm_queue_free (q); |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 967 | ssvm_pop_heap (oldheap); |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 968 | segment_manager_segment_reader_unlock (sm); |
| 969 | } |
| 970 | |
| 971 | /* |
| 972 | * Init segment vm address allocator |
| 973 | */ |
| 974 | void |
Florin Coras | 9a45bd8 | 2020-12-28 16:28:07 -0800 | [diff] [blame] | 975 | segment_manager_main_init (void) |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 976 | { |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 977 | segment_manager_main_t *sm = &sm_main; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 978 | |
| 979 | sm->default_fifo_size = 1 << 12; |
| 980 | sm->default_segment_size = 1 << 20; |
| 981 | sm->default_app_mq_size = 128; |
Ryujiro Shibuya | d8f48e2 | 2020-01-22 12:11:42 +0000 | [diff] [blame] | 982 | sm->default_max_fifo_size = 4 << 20; |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 983 | sm->default_high_watermark = 80; |
| 984 | sm->default_low_watermark = 50; |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 985 | } |
| 986 | |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 987 | static clib_error_t * |
| 988 | segment_manager_show_fn (vlib_main_t * vm, unformat_input_t * input, |
| 989 | vlib_cli_command_t * cmd) |
| 990 | { |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 991 | segment_manager_main_t *smm = &sm_main; |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 992 | u8 show_segments = 0, verbose = 0; |
Ryujiro Shibuya | 65c30ce | 2020-03-26 07:29:09 +0000 | [diff] [blame] | 993 | uword max_fifo_size; |
Florin Coras | 5368bb0 | 2019-06-09 09:24:33 -0700 | [diff] [blame] | 994 | segment_manager_t *sm; |
| 995 | fifo_segment_t *seg; |
Ryujiro Shibuya | d8f48e2 | 2020-01-22 12:11:42 +0000 | [diff] [blame] | 996 | app_worker_t *app_wrk; |
| 997 | application_t *app; |
| 998 | u8 custom_logic; |
Dave Barach | 91f3e74 | 2017-09-01 19:12:11 -0400 | [diff] [blame] | 999 | |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 1000 | while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) |
| 1001 | { |
| 1002 | if (unformat (input, "segments")) |
| 1003 | show_segments = 1; |
| 1004 | else if (unformat (input, "verbose")) |
| 1005 | verbose = 1; |
| 1006 | else |
| 1007 | return clib_error_return (0, "unknown input `%U'", |
| 1008 | format_unformat_error, input); |
| 1009 | } |
| 1010 | vlib_cli_output (vm, "%d segment managers allocated", |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 1011 | pool_elts (smm->segment_managers)); |
| 1012 | if (verbose && pool_elts (smm->segment_managers)) |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 1013 | { |
Ryujiro Shibuya | d8f48e2 | 2020-01-22 12:11:42 +0000 | [diff] [blame] | 1014 | vlib_cli_output (vm, "%-6s%=10s%=10s%=13s%=11s%=11s%=12s", |
| 1015 | "Index", "AppIndex", "Segments", "MaxFifoSize", |
| 1016 | "HighWater", "LowWater", "FifoTuning"); |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 1017 | |
| 1018 | /* *INDENT-OFF* */ |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 1019 | pool_foreach (sm, smm->segment_managers) { |
Ryujiro Shibuya | d8f48e2 | 2020-01-22 12:11:42 +0000 | [diff] [blame] | 1020 | app_wrk = app_worker_get_if_valid (sm->app_wrk_index); |
| 1021 | app = app_wrk ? application_get (app_wrk->app_index) : 0; |
| 1022 | custom_logic = (app && (app->cb_fns.fifo_tuning_callback)) ? 1 : 0; |
Ryujiro Shibuya | 65c30ce | 2020-03-26 07:29:09 +0000 | [diff] [blame] | 1023 | max_fifo_size = sm->max_fifo_size; |
Ryujiro Shibuya | d8f48e2 | 2020-01-22 12:11:42 +0000 | [diff] [blame] | 1024 | |
| 1025 | vlib_cli_output (vm, "%-6d%=10d%=10d%=13U%=11d%=11d%=12s", |
| 1026 | segment_manager_index (sm), |
| 1027 | sm->app_wrk_index, pool_elts (sm->segments), |
Ryujiro Shibuya | 65c30ce | 2020-03-26 07:29:09 +0000 | [diff] [blame] | 1028 | format_memory_size, max_fifo_size, |
Ryujiro Shibuya | d8f48e2 | 2020-01-22 12:11:42 +0000 | [diff] [blame] | 1029 | sm->high_watermark, sm->low_watermark, |
| 1030 | custom_logic ? "custom" : "none"); |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 1031 | } |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 1032 | /* *INDENT-ON* */ |
| 1033 | |
Florin Coras | 2a7c0b6 | 2020-09-28 23:40:28 -0700 | [diff] [blame] | 1034 | vlib_cli_output (vm, "\n"); |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 1035 | } |
| 1036 | if (show_segments) |
| 1037 | { |
Florin Coras | 5368bb0 | 2019-06-09 09:24:33 -0700 | [diff] [blame] | 1038 | vlib_cli_output (vm, "%U", format_fifo_segment, 0, verbose); |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 1039 | |
| 1040 | /* *INDENT-OFF* */ |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 1041 | pool_foreach (sm, smm->segment_managers) { |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 1042 | segment_manager_foreach_segment_w_lock (seg, sm, ({ |
Florin Coras | 5368bb0 | 2019-06-09 09:24:33 -0700 | [diff] [blame] | 1043 | vlib_cli_output (vm, "%U", format_fifo_segment, seg, verbose); |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 1044 | })); |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 1045 | } |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 1046 | /* *INDENT-ON* */ |
| 1047 | |
| 1048 | } |
| 1049 | return 0; |
| 1050 | } |
| 1051 | |
Florin Coras | ad0c77f | 2017-11-09 18:00:15 -0800 | [diff] [blame] | 1052 | /* *INDENT-OFF* */ |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 1053 | VLIB_CLI_COMMAND (segment_manager_show_command, static) = |
| 1054 | { |
| 1055 | .path = "show segment-manager", |
Dave Barach | 91f3e74 | 2017-09-01 19:12:11 -0400 | [diff] [blame] | 1056 | .short_help = "show segment-manager [segments][verbose]", |
Florin Coras | c87c91d | 2017-08-16 19:55:49 -0700 | [diff] [blame] | 1057 | .function = segment_manager_show_fn, |
| 1058 | }; |
| 1059 | /* *INDENT-ON* */ |
| 1060 | |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1061 | void |
| 1062 | segment_manager_format_sessions (segment_manager_t * sm, int verbose) |
| 1063 | { |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1064 | vlib_main_t *vm = vlib_get_main (); |
| 1065 | app_worker_t *app_wrk; |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1066 | fifo_segment_t *fs; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1067 | const u8 *app_name; |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1068 | int slice_index; |
| 1069 | u8 *s = 0, *str; |
| 1070 | svm_fifo_t *f; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1071 | |
| 1072 | if (!sm) |
| 1073 | { |
| 1074 | if (verbose) |
Xiaoming Jiang | 806709f | 2021-06-23 09:07:57 +0000 | [diff] [blame] | 1075 | vlib_cli_output (vm, "%-" SESSION_CLI_ID_LEN "s%-20s%-15s%-10s", |
| 1076 | "Connection", "App", "API Client", "SegManager"); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1077 | else |
Xiaoming Jiang | 806709f | 2021-06-23 09:07:57 +0000 | [diff] [blame] | 1078 | vlib_cli_output (vm, "%-" SESSION_CLI_ID_LEN "s%-20s", "Connection", |
| 1079 | "App"); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1080 | return; |
| 1081 | } |
| 1082 | |
| 1083 | app_wrk = app_worker_get (sm->app_wrk_index); |
| 1084 | app_name = application_name_from_index (app_wrk->app_index); |
| 1085 | |
| 1086 | clib_rwlock_reader_lock (&sm->segments_rwlock); |
| 1087 | |
| 1088 | /* *INDENT-OFF* */ |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 1089 | pool_foreach (fs, sm->segments) { |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1090 | for (slice_index = 0; slice_index < fs->n_slices; slice_index++) |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1091 | { |
Florin Coras | 62ddc03 | 2019-12-08 18:30:42 -0800 | [diff] [blame] | 1092 | f = fifo_segment_get_slice_fifo_list (fs, slice_index); |
| 1093 | while (f) |
| 1094 | { |
| 1095 | u32 session_index, thread_index; |
| 1096 | session_t *session; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1097 | |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 1098 | session_index = f->shr->master_session_index; |
| 1099 | thread_index = f->master_thread_index; |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1100 | |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 1101 | session = session_get (session_index, thread_index); |
| 1102 | str = format (0, "%U", format_session, session, verbose); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1103 | |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 1104 | if (verbose) |
Xiaoming Jiang | 806709f | 2021-06-23 09:07:57 +0000 | [diff] [blame] | 1105 | s = format (s, "%-" SESSION_CLI_ID_LEN "v%-20v%-15u%-10u", str, |
| 1106 | app_name, app_wrk->api_client_index, |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 1107 | app_wrk->connects_seg_manager); |
| 1108 | else |
Xiaoming Jiang | 806709f | 2021-06-23 09:07:57 +0000 | [diff] [blame] | 1109 | s = format (s, "%-" SESSION_CLI_ID_LEN "v%-20v", str, app_name); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1110 | |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 1111 | vlib_cli_output (vm, "%v", s); |
| 1112 | vec_reset_length (s); |
| 1113 | vec_free (str); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1114 | |
Florin Coras | c547e91 | 2020-12-08 17:50:45 -0800 | [diff] [blame] | 1115 | f = f->next; |
| 1116 | } |
| 1117 | vec_free (s); |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1118 | } |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 1119 | } |
Florin Coras | 88001c6 | 2019-04-24 14:44:46 -0700 | [diff] [blame] | 1120 | /* *INDENT-ON* */ |
| 1121 | |
| 1122 | clib_rwlock_reader_unlock (&sm->segments_rwlock); |
| 1123 | } |
| 1124 | |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 1125 | void |
| 1126 | segment_manager_set_watermarks (segment_manager_t * sm, |
| 1127 | u8 high_watermark, u8 low_watermark) |
| 1128 | { |
Florin Coras | 8c79a4e | 2020-02-25 22:28:27 +0000 | [diff] [blame] | 1129 | ASSERT (high_watermark <= 100 && low_watermark <= 100 && |
Ryujiro Shibuya | 234fe89 | 2019-12-25 07:40:54 +0000 | [diff] [blame] | 1130 | low_watermark <= high_watermark); |
| 1131 | |
| 1132 | sm->high_watermark = high_watermark; |
| 1133 | sm->low_watermark = low_watermark; |
| 1134 | } |
| 1135 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1136 | /* |
| 1137 | * fd.io coding-style-patch-verification: ON |
| 1138 | * |
| 1139 | * Local Variables: |
| 1140 | * eval: (c-set-style "gnu") |
| 1141 | * End: |
| 1142 | */ |