Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2015 Cisco and/or its affiliates. |
| 3 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 | * you may not use this file except in compliance with the License. |
| 5 | * You may obtain a copy of the License at: |
| 6 | * |
| 7 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 8 | * |
| 9 | * Unless required by applicable law or agreed to in writing, software |
| 10 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 11 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 | * See the License for the specific language governing permissions and |
| 13 | * limitations under the License. |
| 14 | */ |
| 15 | /* |
| 16 | * interface.c: VNET interfaces/sub-interfaces |
| 17 | * |
| 18 | * Copyright (c) 2008 Eliot Dresselhaus |
| 19 | * |
| 20 | * Permission is hereby granted, free of charge, to any person obtaining |
| 21 | * a copy of this software and associated documentation files (the |
| 22 | * "Software"), to deal in the Software without restriction, including |
| 23 | * without limitation the rights to use, copy, modify, merge, publish, |
| 24 | * distribute, sublicense, and/or sell copies of the Software, and to |
| 25 | * permit persons to whom the Software is furnished to do so, subject to |
| 26 | * the following conditions: |
| 27 | * |
| 28 | * The above copyright notice and this permission notice shall be |
| 29 | * included in all copies or substantial portions of the Software. |
| 30 | * |
| 31 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| 32 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| 33 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| 34 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE |
| 35 | * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION |
| 36 | * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
| 37 | * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| 38 | */ |
| 39 | |
| 40 | #include <vnet/vnet.h> |
| 41 | #include <vnet/plugin/plugin.h> |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 42 | #include <vnet/adj/adj.h> |
Neale Ranns | 0117d24 | 2017-08-12 12:52:54 -0700 | [diff] [blame] | 43 | #include <vnet/adj/adj_mcast.h> |
Neale Ranns | 5a59b2b | 2020-10-19 14:47:20 +0000 | [diff] [blame] | 44 | #include <vnet/ip/ip.h> |
Damjan Marion | 9410053 | 2020-11-06 23:25:57 +0100 | [diff] [blame] | 45 | #include <vnet/interface/rx_queue_funcs.h> |
Damjan Marion | 1bd6cbb | 2021-04-15 13:12:51 +0200 | [diff] [blame] | 46 | #include <vnet/interface/tx_queue_funcs.h> |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 47 | |
Damjan Marion | d1bd5d2 | 2020-11-23 16:58:05 +0100 | [diff] [blame] | 48 | /* *INDENT-OFF* */ |
| 49 | VLIB_REGISTER_LOG_CLASS (if_default_log, static) = { |
| 50 | .class_name = "interface", |
| 51 | }; |
| 52 | /* *INDENT-ON* */ |
| 53 | |
| 54 | #define log_debug(fmt,...) vlib_log_debug(if_default_log.class, fmt, __VA_ARGS__) |
| 55 | #define log_err(fmt,...) vlib_log_err(if_default_log.class, fmt, __VA_ARGS__) |
Damjan Marion | 9410053 | 2020-11-06 23:25:57 +0100 | [diff] [blame] | 56 | |
Neale Ranns | 6e43e06 | 2018-10-26 05:17:03 -0700 | [diff] [blame] | 57 | typedef enum vnet_interface_helper_flags_t_ |
| 58 | { |
| 59 | VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE = (1 << 0), |
| 60 | VNET_INTERFACE_SET_FLAGS_HELPER_WANT_REDISTRIBUTE = (1 << 1), |
| 61 | } vnet_interface_helper_flags_t; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 62 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 63 | static clib_error_t *vnet_hw_interface_set_flags_helper (vnet_main_t * vnm, |
| 64 | u32 hw_if_index, |
Neale Ranns | 6e43e06 | 2018-10-26 05:17:03 -0700 | [diff] [blame] | 65 | vnet_hw_interface_flags_t |
| 66 | flags, |
| 67 | vnet_interface_helper_flags_t |
| 68 | helper_flags); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 69 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 70 | static clib_error_t *vnet_sw_interface_set_flags_helper (vnet_main_t * vnm, |
| 71 | u32 sw_if_index, |
Neale Ranns | 6e43e06 | 2018-10-26 05:17:03 -0700 | [diff] [blame] | 72 | vnet_sw_interface_flags_t |
| 73 | flags, |
| 74 | vnet_interface_helper_flags_t |
| 75 | helper_flags); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 76 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 77 | static clib_error_t *vnet_hw_interface_set_class_helper (vnet_main_t * vnm, |
| 78 | u32 hw_if_index, |
| 79 | u32 hw_class_index, |
| 80 | u32 redistribute); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 81 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 82 | typedef struct |
| 83 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 84 | /* Either sw or hw interface index. */ |
| 85 | u32 sw_hw_if_index; |
| 86 | |
| 87 | /* Flags. */ |
| 88 | u32 flags; |
| 89 | } vnet_sw_hw_interface_state_t; |
| 90 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 91 | static void |
| 92 | serialize_vec_vnet_sw_hw_interface_state (serialize_main_t * m, va_list * va) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 93 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 94 | vnet_sw_hw_interface_state_t *s = |
| 95 | va_arg (*va, vnet_sw_hw_interface_state_t *); |
| 96 | u32 n = va_arg (*va, u32); |
| 97 | u32 i; |
| 98 | for (i = 0; i < n; i++) |
| 99 | { |
| 100 | serialize_integer (m, s[i].sw_hw_if_index, |
| 101 | sizeof (s[i].sw_hw_if_index)); |
| 102 | serialize_integer (m, s[i].flags, sizeof (s[i].flags)); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 103 | } |
| 104 | } |
| 105 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 106 | static void |
| 107 | unserialize_vec_vnet_sw_hw_interface_state (serialize_main_t * m, |
| 108 | va_list * va) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 109 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 110 | vnet_sw_hw_interface_state_t *s = |
| 111 | va_arg (*va, vnet_sw_hw_interface_state_t *); |
| 112 | u32 n = va_arg (*va, u32); |
| 113 | u32 i; |
| 114 | for (i = 0; i < n; i++) |
| 115 | { |
| 116 | unserialize_integer (m, &s[i].sw_hw_if_index, |
| 117 | sizeof (s[i].sw_hw_if_index)); |
| 118 | unserialize_integer (m, &s[i].flags, sizeof (s[i].flags)); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 119 | } |
| 120 | } |
| 121 | |
Neale Ranns | b3a9381 | 2018-10-29 01:55:24 -0700 | [diff] [blame] | 122 | static vnet_sw_interface_flags_t |
| 123 | vnet_hw_interface_flags_to_sw (vnet_hw_interface_flags_t hwf) |
| 124 | { |
| 125 | vnet_sw_interface_flags_t swf = VNET_SW_INTERFACE_FLAG_NONE; |
| 126 | |
| 127 | if (hwf & VNET_HW_INTERFACE_FLAG_LINK_UP) |
| 128 | swf |= VNET_SW_INTERFACE_FLAG_ADMIN_UP; |
| 129 | |
| 130 | return (swf); |
| 131 | } |
| 132 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 133 | void |
| 134 | serialize_vnet_interface_state (serialize_main_t * m, va_list * va) |
| 135 | { |
| 136 | vnet_main_t *vnm = va_arg (*va, vnet_main_t *); |
| 137 | vnet_sw_hw_interface_state_t *sts = 0, *st; |
| 138 | vnet_sw_interface_t *sif; |
| 139 | vnet_hw_interface_t *hif; |
| 140 | vnet_interface_main_t *im = &vnm->interface_main; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 141 | |
| 142 | /* Serialize hardware interface classes since they may have changed. |
| 143 | Must do this before sending up/down flags. */ |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 144 | /* *INDENT-OFF* */ |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 145 | pool_foreach (hif, im->hw_interfaces) { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 146 | vnet_hw_interface_class_t * hw_class = vnet_get_hw_interface_class (vnm, hif->hw_class_index); |
| 147 | serialize_cstring (m, hw_class->name); |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 148 | } |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 149 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 150 | |
| 151 | /* Send sw/hw interface state when non-zero. */ |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 152 | /* *INDENT-OFF* */ |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 153 | pool_foreach (sif, im->sw_interfaces) { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 154 | if (sif->flags != 0) |
| 155 | { |
| 156 | vec_add2 (sts, st, 1); |
| 157 | st->sw_hw_if_index = sif->sw_if_index; |
| 158 | st->flags = sif->flags; |
| 159 | } |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 160 | } |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 161 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 162 | |
| 163 | vec_serialize (m, sts, serialize_vec_vnet_sw_hw_interface_state); |
| 164 | |
| 165 | if (sts) |
| 166 | _vec_len (sts) = 0; |
| 167 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 168 | /* *INDENT-OFF* */ |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 169 | pool_foreach (hif, im->hw_interfaces) { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 170 | if (hif->flags != 0) |
| 171 | { |
| 172 | vec_add2 (sts, st, 1); |
| 173 | st->sw_hw_if_index = hif->hw_if_index; |
Neale Ranns | b3a9381 | 2018-10-29 01:55:24 -0700 | [diff] [blame] | 174 | st->flags = vnet_hw_interface_flags_to_sw(hif->flags); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 175 | } |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 176 | } |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 177 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 178 | |
| 179 | vec_serialize (m, sts, serialize_vec_vnet_sw_hw_interface_state); |
| 180 | |
| 181 | vec_free (sts); |
| 182 | } |
| 183 | |
Neale Ranns | b3a9381 | 2018-10-29 01:55:24 -0700 | [diff] [blame] | 184 | static vnet_hw_interface_flags_t |
| 185 | vnet_sw_interface_flags_to_hw (vnet_sw_interface_flags_t swf) |
| 186 | { |
| 187 | vnet_hw_interface_flags_t hwf = VNET_HW_INTERFACE_FLAG_NONE; |
| 188 | |
| 189 | if (swf & VNET_SW_INTERFACE_FLAG_ADMIN_UP) |
| 190 | hwf |= VNET_HW_INTERFACE_FLAG_LINK_UP; |
| 191 | |
| 192 | return (hwf); |
| 193 | } |
| 194 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 195 | void |
| 196 | unserialize_vnet_interface_state (serialize_main_t * m, va_list * va) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 197 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 198 | vnet_main_t *vnm = va_arg (*va, vnet_main_t *); |
| 199 | vnet_sw_hw_interface_state_t *sts = 0, *st; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 200 | |
| 201 | /* First set interface hardware class. */ |
| 202 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 203 | vnet_interface_main_t *im = &vnm->interface_main; |
| 204 | vnet_hw_interface_t *hif; |
| 205 | char *class_name; |
| 206 | uword *p; |
| 207 | clib_error_t *error; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 208 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 209 | /* *INDENT-OFF* */ |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 210 | pool_foreach (hif, im->hw_interfaces) { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 211 | unserialize_cstring (m, &class_name); |
| 212 | p = hash_get_mem (im->hw_interface_class_by_name, class_name); |
Dave Barach | a6ef36b | 2020-02-11 10:29:13 -0500 | [diff] [blame] | 213 | if (p) |
| 214 | { |
| 215 | error = vnet_hw_interface_set_class_helper |
| 216 | (vnm, hif->hw_if_index, p[0], /* redistribute */ 0); |
| 217 | } |
| 218 | else |
| 219 | error = clib_error_return (0, "hw class %s AWOL?", class_name); |
| 220 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 221 | if (error) |
| 222 | clib_error_report (error); |
| 223 | vec_free (class_name); |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 224 | } |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 225 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 226 | } |
| 227 | |
| 228 | vec_unserialize (m, &sts, unserialize_vec_vnet_sw_hw_interface_state); |
| 229 | vec_foreach (st, sts) |
| 230 | vnet_sw_interface_set_flags_helper (vnm, st->sw_hw_if_index, st->flags, |
| 231 | /* no distribute */ 0); |
| 232 | vec_free (sts); |
| 233 | |
| 234 | vec_unserialize (m, &sts, unserialize_vec_vnet_sw_hw_interface_state); |
| 235 | vec_foreach (st, sts) |
Neale Ranns | b3a9381 | 2018-10-29 01:55:24 -0700 | [diff] [blame] | 236 | { |
| 237 | vnet_hw_interface_set_flags_helper |
| 238 | (vnm, st->sw_hw_if_index, vnet_sw_interface_flags_to_hw (st->flags), |
| 239 | /* no distribute */ 0); |
| 240 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 241 | vec_free (sts); |
| 242 | } |
| 243 | |
| 244 | static clib_error_t * |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 245 | call_elf_section_interface_callbacks (vnet_main_t * vnm, u32 if_index, |
| 246 | u32 flags, |
Neale Ranns | 8b37b87 | 2016-11-21 12:25:22 +0000 | [diff] [blame] | 247 | _vnet_interface_function_list_elt_t ** |
| 248 | elts) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 249 | { |
Neale Ranns | 8b37b87 | 2016-11-21 12:25:22 +0000 | [diff] [blame] | 250 | _vnet_interface_function_list_elt_t *elt; |
| 251 | vnet_interface_function_priority_t prio; |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 252 | clib_error_t *error = 0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 253 | |
Neale Ranns | 8b37b87 | 2016-11-21 12:25:22 +0000 | [diff] [blame] | 254 | for (prio = VNET_ITF_FUNC_PRIORITY_LOW; |
| 255 | prio <= VNET_ITF_FUNC_PRIORITY_HIGH; prio++) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 256 | { |
Neale Ranns | 8b37b87 | 2016-11-21 12:25:22 +0000 | [diff] [blame] | 257 | elt = elts[prio]; |
| 258 | |
| 259 | while (elt) |
| 260 | { |
| 261 | error = elt->fp (vnm, if_index, flags); |
| 262 | if (error) |
| 263 | return error; |
| 264 | elt = elt->next_interface_function; |
| 265 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 266 | } |
| 267 | return error; |
| 268 | } |
| 269 | |
| 270 | static clib_error_t * |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 271 | call_hw_interface_add_del_callbacks (vnet_main_t * vnm, u32 hw_if_index, |
| 272 | u32 is_create) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 273 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 274 | vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index); |
| 275 | vnet_hw_interface_class_t *hw_class = |
| 276 | vnet_get_hw_interface_class (vnm, hi->hw_class_index); |
| 277 | vnet_device_class_t *dev_class = |
| 278 | vnet_get_device_class (vnm, hi->dev_class_index); |
| 279 | clib_error_t *error = 0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 280 | |
| 281 | if (hw_class->interface_add_del_function |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 282 | && (error = |
| 283 | hw_class->interface_add_del_function (vnm, hw_if_index, is_create))) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 284 | return error; |
| 285 | |
| 286 | if (dev_class->interface_add_del_function |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 287 | && (error = |
| 288 | dev_class->interface_add_del_function (vnm, hw_if_index, |
| 289 | is_create))) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 290 | return error; |
| 291 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 292 | error = call_elf_section_interface_callbacks |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 293 | (vnm, hw_if_index, is_create, vnm->hw_interface_add_del_functions); |
| 294 | |
| 295 | return error; |
| 296 | } |
| 297 | |
| 298 | static clib_error_t * |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 299 | call_sw_interface_add_del_callbacks (vnet_main_t * vnm, u32 sw_if_index, |
| 300 | u32 is_create) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 301 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 302 | return call_elf_section_interface_callbacks |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 303 | (vnm, sw_if_index, is_create, vnm->sw_interface_add_del_functions); |
| 304 | } |
| 305 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 306 | static clib_error_t * |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 307 | vnet_hw_interface_set_flags_helper (vnet_main_t * vnm, u32 hw_if_index, |
Neale Ranns | 6e43e06 | 2018-10-26 05:17:03 -0700 | [diff] [blame] | 308 | vnet_hw_interface_flags_t flags, |
| 309 | vnet_interface_helper_flags_t |
| 310 | helper_flags) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 311 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 312 | vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index); |
| 313 | vnet_hw_interface_class_t *hw_class = |
| 314 | vnet_get_hw_interface_class (vnm, hi->hw_class_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 315 | u32 mask; |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 316 | clib_error_t *error = 0; |
| 317 | u32 is_create = |
| 318 | (helper_flags & VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE) != 0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 319 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 320 | mask = |
Damjan Marion | 5100aa9 | 2018-11-08 15:30:16 +0100 | [diff] [blame] | 321 | (VNET_HW_INTERFACE_FLAG_LINK_UP | VNET_HW_INTERFACE_FLAG_DUPLEX_MASK); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 322 | flags &= mask; |
| 323 | |
| 324 | /* Call hardware interface add/del callbacks. */ |
| 325 | if (is_create) |
| 326 | call_hw_interface_add_del_callbacks (vnm, hw_if_index, is_create); |
| 327 | |
| 328 | /* Already in the desired state? */ |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 329 | if (!is_create && (hi->flags & mask) == flags) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 330 | goto done; |
| 331 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 332 | if ((hi->flags & VNET_HW_INTERFACE_FLAG_LINK_UP) != |
| 333 | (flags & VNET_HW_INTERFACE_FLAG_LINK_UP)) |
| 334 | { |
| 335 | /* Do hardware class (e.g. ethernet). */ |
| 336 | if (hw_class->link_up_down_function |
| 337 | && (error = hw_class->link_up_down_function (vnm, hw_if_index, |
| 338 | flags))) |
| 339 | goto done; |
| 340 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 341 | error = call_elf_section_interface_callbacks |
Klement Sekera | 2cee01d | 2016-09-08 17:53:13 +0200 | [diff] [blame] | 342 | (vnm, hw_if_index, flags, vnm->hw_interface_link_up_down_functions); |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 343 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 344 | if (error) |
| 345 | goto done; |
| 346 | } |
| 347 | |
| 348 | hi->flags &= ~mask; |
| 349 | hi->flags |= flags; |
| 350 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 351 | done: |
Damjan Marion | d1bd5d2 | 2020-11-23 16:58:05 +0100 | [diff] [blame] | 352 | if (error) |
| 353 | log_err ("hw_set_flags_helper: %U", format_clib_error, error); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 354 | return error; |
| 355 | } |
| 356 | |
| 357 | static clib_error_t * |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 358 | vnet_sw_interface_set_flags_helper (vnet_main_t * vnm, u32 sw_if_index, |
Neale Ranns | 6e43e06 | 2018-10-26 05:17:03 -0700 | [diff] [blame] | 359 | vnet_sw_interface_flags_t flags, |
| 360 | vnet_interface_helper_flags_t |
| 361 | helper_flags) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 362 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 363 | vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 364 | u32 mask; |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 365 | clib_error_t *error = 0; |
| 366 | u32 is_create = |
| 367 | (helper_flags & VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE) != 0; |
Georgi Savov | 3a03598 | 2016-02-25 12:56:03 -0500 | [diff] [blame] | 368 | u32 old_flags; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 369 | |
| 370 | mask = VNET_SW_INTERFACE_FLAG_ADMIN_UP | VNET_SW_INTERFACE_FLAG_PUNT; |
| 371 | flags &= mask; |
| 372 | |
| 373 | if (is_create) |
| 374 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 375 | error = |
| 376 | call_sw_interface_add_del_callbacks (vnm, sw_if_index, is_create); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 377 | if (error) |
| 378 | goto done; |
| 379 | |
| 380 | if (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 381 | { |
| 382 | /* Notify everyone when the interface is created as admin up */ |
| 383 | error = call_elf_section_interface_callbacks (vnm, sw_if_index, |
| 384 | flags, |
| 385 | vnm-> |
| 386 | sw_interface_admin_up_down_functions); |
| 387 | if (error) |
| 388 | goto done; |
| 389 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 390 | } |
| 391 | else |
| 392 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 393 | vnet_sw_interface_t *si_sup = si; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 394 | |
| 395 | /* Check that super interface is in correct state. */ |
| 396 | if (si->type == VNET_SW_INTERFACE_TYPE_SUB) |
| 397 | { |
| 398 | si_sup = vnet_get_sw_interface (vnm, si->sup_sw_if_index); |
| 399 | |
Calvin | 31a3674 | 2016-07-04 14:14:46 -0400 | [diff] [blame] | 400 | /* Check to see if we're bringing down the soft interface and if it's parent is up */ |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 401 | if ((flags != (si_sup->flags & mask)) && |
| 402 | (!((flags == 0) |
| 403 | && ((si_sup->flags & mask) == |
| 404 | VNET_SW_INTERFACE_FLAG_ADMIN_UP)))) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 405 | { |
| 406 | error = clib_error_return (0, "super-interface %U must be %U", |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 407 | format_vnet_sw_interface_name, vnm, |
| 408 | si_sup, |
| 409 | format_vnet_sw_interface_flags, |
| 410 | flags); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 411 | goto done; |
| 412 | } |
| 413 | } |
| 414 | |
| 415 | /* Already in the desired state? */ |
| 416 | if ((si->flags & mask) == flags) |
| 417 | goto done; |
| 418 | |
| 419 | /* Sub-interfaces of hardware interfaces that do no redistribute, |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 420 | do not redistribute themselves. */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 421 | if (si_sup->type == VNET_SW_INTERFACE_TYPE_HARDWARE) |
| 422 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 423 | vnet_hw_interface_t *hi = |
| 424 | vnet_get_hw_interface (vnm, si_sup->hw_if_index); |
| 425 | vnet_device_class_t *dev_class = |
| 426 | vnet_get_device_class (vnm, hi->dev_class_index); |
| 427 | if (!dev_class->redistribute) |
| 428 | helper_flags &= |
| 429 | ~VNET_INTERFACE_SET_FLAGS_HELPER_WANT_REDISTRIBUTE; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 430 | } |
| 431 | |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 432 | /* set the flags now before invoking the registered clients |
| 433 | * so that the state they query is consistent with the state here notified */ |
| 434 | old_flags = si->flags; |
| 435 | si->flags &= ~mask; |
| 436 | si->flags |= flags; |
| 437 | if ((flags | old_flags) & VNET_SW_INTERFACE_FLAG_ADMIN_UP) |
| 438 | error = call_elf_section_interface_callbacks |
| 439 | (vnm, sw_if_index, flags, |
| 440 | vnm->sw_interface_admin_up_down_functions); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 441 | |
| 442 | if (error) |
Mohsin Kazmi | a50a14c | 2018-04-25 15:58:05 +0200 | [diff] [blame] | 443 | { |
| 444 | /* restore flags on error */ |
| 445 | si->flags = old_flags; |
| 446 | goto done; |
| 447 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 448 | |
| 449 | if (si->type == VNET_SW_INTERFACE_TYPE_HARDWARE) |
| 450 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 451 | vnet_hw_interface_t *hi = |
| 452 | vnet_get_hw_interface (vnm, si->hw_if_index); |
| 453 | vnet_hw_interface_class_t *hw_class = |
| 454 | vnet_get_hw_interface_class (vnm, hi->hw_class_index); |
| 455 | vnet_device_class_t *dev_class = |
| 456 | vnet_get_device_class (vnm, hi->dev_class_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 457 | |
Damjan Marion | abce509 | 2017-05-10 20:09:31 +0200 | [diff] [blame] | 458 | if ((flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) && |
| 459 | (si->flags & VNET_SW_INTERFACE_FLAG_ERROR)) |
| 460 | { |
| 461 | error = clib_error_return (0, "Interface in the error state"); |
| 462 | goto done; |
| 463 | } |
| 464 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 465 | /* update si admin up flag in advance if we are going admin down */ |
| 466 | if (!(flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)) |
| 467 | si->flags &= ~VNET_SW_INTERFACE_FLAG_ADMIN_UP; |
Georgi Savov | 3a03598 | 2016-02-25 12:56:03 -0500 | [diff] [blame] | 468 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 469 | if (dev_class->admin_up_down_function |
| 470 | && (error = dev_class->admin_up_down_function (vnm, |
| 471 | si->hw_if_index, |
| 472 | flags))) |
| 473 | { |
| 474 | /* restore si admin up flag to it's original state on errors */ |
| 475 | si->flags = old_flags; |
| 476 | goto done; |
| 477 | } |
Georgi Savov | 3a03598 | 2016-02-25 12:56:03 -0500 | [diff] [blame] | 478 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 479 | if (hw_class->admin_up_down_function |
| 480 | && (error = hw_class->admin_up_down_function (vnm, |
| 481 | si->hw_if_index, |
| 482 | flags))) |
| 483 | { |
| 484 | /* restore si admin up flag to it's original state on errors */ |
| 485 | si->flags = old_flags; |
| 486 | goto done; |
| 487 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 488 | |
| 489 | /* Admin down implies link down. */ |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 490 | if (!(flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 491 | && (hi->flags & VNET_HW_INTERFACE_FLAG_LINK_UP)) |
| 492 | vnet_hw_interface_set_flags_helper (vnm, si->hw_if_index, |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 493 | hi->flags & |
| 494 | ~VNET_HW_INTERFACE_FLAG_LINK_UP, |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 495 | helper_flags); |
Damjan Marion | 9410053 | 2020-11-06 23:25:57 +0100 | [diff] [blame] | 496 | vnet_hw_if_update_runtime_data (vnm, si->hw_if_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 497 | } |
| 498 | } |
| 499 | |
| 500 | si->flags &= ~mask; |
| 501 | si->flags |= flags; |
| 502 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 503 | done: |
Damjan Marion | d1bd5d2 | 2020-11-23 16:58:05 +0100 | [diff] [blame] | 504 | if (error) |
| 505 | log_err ("sw_set_flags_helper: %U", format_clib_error, error); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 506 | return error; |
| 507 | } |
| 508 | |
| 509 | clib_error_t * |
Neale Ranns | 6e43e06 | 2018-10-26 05:17:03 -0700 | [diff] [blame] | 510 | vnet_hw_interface_set_flags (vnet_main_t * vnm, u32 hw_if_index, |
| 511 | vnet_hw_interface_flags_t flags) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 512 | { |
Damjan Marion | d1bd5d2 | 2020-11-23 16:58:05 +0100 | [diff] [blame] | 513 | log_debug ("hw_set_flags: hw_if_index %u flags 0x%x", hw_if_index, flags); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 514 | return vnet_hw_interface_set_flags_helper |
| 515 | (vnm, hw_if_index, flags, |
| 516 | VNET_INTERFACE_SET_FLAGS_HELPER_WANT_REDISTRIBUTE); |
| 517 | } |
| 518 | |
| 519 | clib_error_t * |
Neale Ranns | 6e43e06 | 2018-10-26 05:17:03 -0700 | [diff] [blame] | 520 | vnet_sw_interface_set_flags (vnet_main_t * vnm, u32 sw_if_index, |
| 521 | vnet_sw_interface_flags_t flags) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 522 | { |
Damjan Marion | d1bd5d2 | 2020-11-23 16:58:05 +0100 | [diff] [blame] | 523 | log_debug ("sw_set_flags: sw_if_index %u flags 0x%x", sw_if_index, flags); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 524 | return vnet_sw_interface_set_flags_helper |
| 525 | (vnm, sw_if_index, flags, |
| 526 | VNET_INTERFACE_SET_FLAGS_HELPER_WANT_REDISTRIBUTE); |
| 527 | } |
| 528 | |
Neale Ranns | c87b66c | 2019-02-07 07:26:12 -0800 | [diff] [blame] | 529 | void |
| 530 | vnet_sw_interface_admin_up (vnet_main_t * vnm, u32 sw_if_index) |
| 531 | { |
| 532 | u32 flags = vnet_sw_interface_get_flags (vnm, sw_if_index); |
Damjan Marion | d1bd5d2 | 2020-11-23 16:58:05 +0100 | [diff] [blame] | 533 | log_debug ("sw_admin_up: sw_if_index %u", sw_if_index); |
Neale Ranns | c87b66c | 2019-02-07 07:26:12 -0800 | [diff] [blame] | 534 | |
| 535 | if (!(flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)) |
| 536 | { |
| 537 | flags |= VNET_SW_INTERFACE_FLAG_ADMIN_UP; |
| 538 | vnet_sw_interface_set_flags (vnm, sw_if_index, flags); |
| 539 | } |
| 540 | } |
| 541 | |
| 542 | void |
| 543 | vnet_sw_interface_admin_down (vnet_main_t * vnm, u32 sw_if_index) |
| 544 | { |
| 545 | u32 flags = vnet_sw_interface_get_flags (vnm, sw_if_index); |
Damjan Marion | d1bd5d2 | 2020-11-23 16:58:05 +0100 | [diff] [blame] | 546 | log_debug ("sw_admin_down: sw_if_index %u", sw_if_index); |
Neale Ranns | c87b66c | 2019-02-07 07:26:12 -0800 | [diff] [blame] | 547 | |
| 548 | if (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) |
| 549 | { |
| 550 | flags &= ~(VNET_SW_INTERFACE_FLAG_ADMIN_UP); |
| 551 | vnet_sw_interface_set_flags (vnm, sw_if_index, flags); |
| 552 | } |
| 553 | } |
| 554 | |
Damjan Marion | 8932e45 | 2021-04-16 11:49:26 +0200 | [diff] [blame] | 555 | static void |
| 556 | vnet_if_update_lookup_tables (vnet_main_t *vnm, u32 sw_if_index) |
| 557 | { |
| 558 | vnet_interface_main_t *im = &vnm->interface_main; |
| 559 | vnet_hw_interface_t *hi = vnet_get_sup_hw_interface (vnm, sw_if_index); |
| 560 | |
| 561 | vec_validate_init_empty (im->hw_if_index_by_sw_if_index, sw_if_index, ~0); |
| 562 | vec_validate_init_empty (im->if_out_arc_end_next_index_by_sw_if_index, |
| 563 | sw_if_index, ~0); |
| 564 | |
| 565 | im->hw_if_index_by_sw_if_index[sw_if_index] = hi->hw_if_index; |
| 566 | im->if_out_arc_end_next_index_by_sw_if_index[sw_if_index] = |
| 567 | hi->if_out_arc_end_node_next_index; |
| 568 | } |
| 569 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 570 | static u32 |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 571 | vnet_create_sw_interface_no_callbacks (vnet_main_t * vnm, |
| 572 | vnet_sw_interface_t * template) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 573 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 574 | vnet_interface_main_t *im = &vnm->interface_main; |
| 575 | vnet_sw_interface_t *sw; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 576 | u32 sw_if_index; |
| 577 | |
| 578 | pool_get (im->sw_interfaces, sw); |
| 579 | sw_if_index = sw - im->sw_interfaces; |
| 580 | |
| 581 | sw[0] = template[0]; |
| 582 | |
| 583 | sw->flags = 0; |
| 584 | sw->sw_if_index = sw_if_index; |
| 585 | if (sw->type == VNET_SW_INTERFACE_TYPE_HARDWARE) |
| 586 | sw->sup_sw_if_index = sw->sw_if_index; |
| 587 | |
| 588 | /* Allocate counters for this interface. */ |
| 589 | { |
| 590 | u32 i; |
| 591 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 592 | vnet_interface_counter_lock (im); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 593 | |
| 594 | for (i = 0; i < vec_len (im->sw_if_counters); i++) |
| 595 | { |
| 596 | vlib_validate_simple_counter (&im->sw_if_counters[i], sw_if_index); |
| 597 | vlib_zero_simple_counter (&im->sw_if_counters[i], sw_if_index); |
| 598 | } |
| 599 | |
| 600 | for (i = 0; i < vec_len (im->combined_sw_if_counters); i++) |
| 601 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 602 | vlib_validate_combined_counter (&im->combined_sw_if_counters[i], |
| 603 | sw_if_index); |
| 604 | vlib_zero_combined_counter (&im->combined_sw_if_counters[i], |
| 605 | sw_if_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 606 | } |
| 607 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 608 | vnet_interface_counter_unlock (im); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 609 | } |
| 610 | |
Damjan Marion | 8932e45 | 2021-04-16 11:49:26 +0200 | [diff] [blame] | 611 | vnet_if_update_lookup_tables (vnm, sw_if_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 612 | return sw_if_index; |
| 613 | } |
| 614 | |
| 615 | clib_error_t * |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 616 | vnet_create_sw_interface (vnet_main_t * vnm, vnet_sw_interface_t * template, |
| 617 | u32 * sw_if_index) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 618 | { |
Damjan Marion | d1bd5d2 | 2020-11-23 16:58:05 +0100 | [diff] [blame] | 619 | vnet_interface_main_t *im = &vnm->interface_main; |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 620 | clib_error_t *error; |
| 621 | vnet_hw_interface_t *hi; |
| 622 | vnet_device_class_t *dev_class; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 623 | |
Jon Loeliger | b22e1f0 | 2019-12-19 09:03:52 -0600 | [diff] [blame] | 624 | if (template->sub.eth.flags.two_tags == 1 |
| 625 | && template->sub.eth.flags.exact_match == 1 |
| 626 | && (template->sub.eth.flags.inner_vlan_id_any == 1 |
| 627 | || template->sub.eth.flags.outer_vlan_id_any == 1)) |
| 628 | { |
Damjan Marion | d1bd5d2 | 2020-11-23 16:58:05 +0100 | [diff] [blame] | 629 | char *str = "inner-dot1q any exact-match is unsupported"; |
| 630 | error = clib_error_return (0, str); |
| 631 | log_err ("create_sw_interface: %s", str); |
Jon Loeliger | b22e1f0 | 2019-12-19 09:03:52 -0600 | [diff] [blame] | 632 | return error; |
| 633 | } |
| 634 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 635 | hi = vnet_get_sup_hw_interface (vnm, template->sup_sw_if_index); |
| 636 | dev_class = vnet_get_device_class (vnm, hi->dev_class_index); |
| 637 | |
| 638 | if (template->type == VNET_SW_INTERFACE_TYPE_SUB && |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 639 | dev_class->subif_add_del_function) |
| 640 | { |
| 641 | error = dev_class->subif_add_del_function (vnm, hi->hw_if_index, |
| 642 | (struct vnet_sw_interface_t |
| 643 | *) template, 1); |
| 644 | if (error) |
| 645 | return error; |
| 646 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 647 | |
| 648 | *sw_if_index = vnet_create_sw_interface_no_callbacks (vnm, template); |
| 649 | error = vnet_sw_interface_set_flags_helper |
| 650 | (vnm, *sw_if_index, template->flags, |
| 651 | VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE); |
| 652 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 653 | if (error) |
| 654 | { |
| 655 | /* undo the work done by vnet_create_sw_interface_no_callbacks() */ |
Damjan Marion | d1bd5d2 | 2020-11-23 16:58:05 +0100 | [diff] [blame] | 656 | log_err ("create_sw_interface: set flags failed\n %U", |
| 657 | format_clib_error, error); |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 658 | vnet_sw_interface_t *sw = |
| 659 | pool_elt_at_index (im->sw_interfaces, *sw_if_index); |
| 660 | pool_put (im->sw_interfaces, sw); |
| 661 | } |
Damjan Marion | d1bd5d2 | 2020-11-23 16:58:05 +0100 | [diff] [blame] | 662 | else |
| 663 | { |
| 664 | vnet_sw_interface_t *sw = |
| 665 | pool_elt_at_index (im->sw_interfaces, *sw_if_index); |
| 666 | log_debug ("create_sw_interface: interface %U (sw_if_index %u) created", |
| 667 | format_vnet_sw_interface_name, vnm, sw, *sw_if_index); |
| 668 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 669 | |
| 670 | return error; |
| 671 | } |
| 672 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 673 | void |
| 674 | vnet_delete_sw_interface (vnet_main_t * vnm, u32 sw_if_index) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 675 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 676 | vnet_interface_main_t *im = &vnm->interface_main; |
| 677 | vnet_sw_interface_t *sw = |
| 678 | pool_elt_at_index (im->sw_interfaces, sw_if_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 679 | |
Damjan Marion | d1bd5d2 | 2020-11-23 16:58:05 +0100 | [diff] [blame] | 680 | log_debug ("delete_sw_interface: sw_if_index %u, name '%U'", |
| 681 | sw_if_index, format_vnet_sw_if_index_name, vnm, sw_if_index); |
| 682 | |
Wojciech Dec | d63370c | 2017-01-03 10:27:03 +0100 | [diff] [blame] | 683 | /* Check if the interface has config and is removed from L2 BD or XConnect */ |
Neale Ranns | e8d7ff5 | 2018-05-31 21:23:37 -0700 | [diff] [blame] | 684 | vnet_clear_sw_interface_tag (vnm, sw_if_index); |
Pavel Kotucek | 7c8eda1 | 2016-10-17 15:31:59 +0200 | [diff] [blame] | 685 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 686 | /* Bring down interface in case it is up. */ |
| 687 | if (sw->flags != 0) |
| 688 | vnet_sw_interface_set_flags (vnm, sw_if_index, /* flags */ 0); |
| 689 | |
| 690 | call_sw_interface_add_del_callbacks (vnm, sw_if_index, /* is_create */ 0); |
| 691 | |
| 692 | pool_put (im->sw_interfaces, sw); |
| 693 | } |
| 694 | |
Ole Troan | d723161 | 2018-06-07 10:17:57 +0200 | [diff] [blame] | 695 | static clib_error_t * |
| 696 | call_sw_interface_mtu_change_callbacks (vnet_main_t * vnm, u32 sw_if_index) |
| 697 | { |
| 698 | return call_elf_section_interface_callbacks |
| 699 | (vnm, sw_if_index, 0, vnm->sw_interface_mtu_change_functions); |
| 700 | } |
| 701 | |
| 702 | void |
| 703 | vnet_sw_interface_set_mtu (vnet_main_t * vnm, u32 sw_if_index, u32 mtu) |
| 704 | { |
| 705 | vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index); |
| 706 | |
| 707 | if (si->mtu[VNET_MTU_L3] != mtu) |
| 708 | { |
| 709 | si->mtu[VNET_MTU_L3] = mtu; |
Damjan Marion | d1bd5d2 | 2020-11-23 16:58:05 +0100 | [diff] [blame] | 710 | log_debug ("set_mtu: interface %U, new mtu %u", |
| 711 | format_vnet_sw_if_index_name, vnm, sw_if_index, mtu); |
| 712 | |
Ole Troan | d723161 | 2018-06-07 10:17:57 +0200 | [diff] [blame] | 713 | call_sw_interface_mtu_change_callbacks (vnm, sw_if_index); |
| 714 | } |
| 715 | } |
| 716 | |
| 717 | void |
| 718 | vnet_sw_interface_set_protocol_mtu (vnet_main_t * vnm, u32 sw_if_index, |
| 719 | u32 mtu[]) |
| 720 | { |
| 721 | vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index); |
| 722 | bool changed = false; |
| 723 | int i; |
| 724 | |
| 725 | for (i = 0; i < VNET_N_MTU; i++) |
| 726 | { |
| 727 | if (si->mtu[i] != mtu[i]) |
| 728 | { |
| 729 | si->mtu[i] = mtu[i]; |
| 730 | changed = true; |
| 731 | } |
| 732 | } |
| 733 | /* Notify interested parties */ |
| 734 | if (changed) |
Damjan Marion | d1bd5d2 | 2020-11-23 16:58:05 +0100 | [diff] [blame] | 735 | { |
| 736 | log_debug ("set_protocol_mtu: interface %U l3 %u ip4 %u ip6 %u mpls %u", |
| 737 | format_vnet_sw_if_index_name, vnm, sw_if_index, |
| 738 | mtu[VNET_MTU_L3], mtu[VNET_MTU_IP4], mtu[VNET_MTU_IP6], |
| 739 | mtu[VNET_MTU_MPLS]); |
| 740 | call_sw_interface_mtu_change_callbacks (vnm, sw_if_index); |
| 741 | } |
Ole Troan | d723161 | 2018-06-07 10:17:57 +0200 | [diff] [blame] | 742 | } |
| 743 | |
Neale Ranns | 1855b8e | 2018-07-11 10:31:26 -0700 | [diff] [blame] | 744 | void |
| 745 | vnet_sw_interface_ip_directed_broadcast (vnet_main_t * vnm, |
| 746 | u32 sw_if_index, u8 enable) |
| 747 | { |
| 748 | vnet_sw_interface_t *si; |
| 749 | |
| 750 | si = vnet_get_sw_interface (vnm, sw_if_index); |
| 751 | |
| 752 | if (enable) |
| 753 | si->flags |= VNET_SW_INTERFACE_FLAG_DIRECTED_BCAST; |
| 754 | else |
| 755 | si->flags &= ~VNET_SW_INTERFACE_FLAG_DIRECTED_BCAST; |
| 756 | |
| 757 | ip4_directed_broadcast (sw_if_index, enable); |
| 758 | } |
| 759 | |
Ole Troan | d723161 | 2018-06-07 10:17:57 +0200 | [diff] [blame] | 760 | /* |
| 761 | * Reflect a change in hardware MTU on protocol MTUs |
| 762 | */ |
| 763 | static walk_rc_t |
| 764 | sw_interface_walk_callback (vnet_main_t * vnm, u32 sw_if_index, void *ctx) |
| 765 | { |
| 766 | u32 *link_mtu = ctx; |
| 767 | vnet_sw_interface_set_mtu (vnm, sw_if_index, *link_mtu); |
| 768 | return WALK_CONTINUE; |
| 769 | } |
| 770 | |
| 771 | void |
| 772 | vnet_hw_interface_set_mtu (vnet_main_t * vnm, u32 hw_if_index, u32 mtu) |
| 773 | { |
| 774 | vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index); |
| 775 | |
| 776 | if (hi->max_packet_bytes != mtu) |
| 777 | { |
| 778 | hi->max_packet_bytes = mtu; |
| 779 | ethernet_set_flags (vnm, hw_if_index, ETHERNET_INTERFACE_FLAG_MTU); |
| 780 | vnet_hw_interface_walk_sw (vnm, hw_if_index, sw_interface_walk_callback, |
| 781 | &mtu); |
| 782 | } |
| 783 | } |
| 784 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 785 | static void |
| 786 | setup_tx_node (vlib_main_t * vm, |
| 787 | u32 node_index, vnet_device_class_t * dev_class) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 788 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 789 | vlib_node_t *n = vlib_get_node (vm, node_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 790 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 791 | n->format_trace = dev_class->format_tx_trace; |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 792 | |
Ole Troan | f09d655 | 2021-03-10 12:52:53 +0100 | [diff] [blame] | 793 | vlib_register_errors (vm, node_index, dev_class->tx_function_n_errors, |
| 794 | dev_class->tx_function_error_strings, |
| 795 | dev_class->tx_function_error_counters); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 796 | } |
| 797 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 798 | static void |
| 799 | setup_output_node (vlib_main_t * vm, |
| 800 | u32 node_index, vnet_hw_interface_class_t * hw_class) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 801 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 802 | vlib_node_t *n = vlib_get_node (vm, node_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 803 | n->format_buffer = hw_class->format_header; |
| 804 | n->unformat_buffer = hw_class->unformat_header; |
| 805 | } |
| 806 | |
Neale Ranns | 6fdcc3d | 2021-10-08 07:30:47 +0000 | [diff] [blame] | 807 | void |
| 808 | vnet_reset_interface_l3_output_node (vlib_main_t *vm, u32 sw_if_index) |
| 809 | { |
| 810 | vnet_set_interface_l3_output_node (vm, sw_if_index, |
| 811 | (u8 *) "interface-output"); |
| 812 | } |
| 813 | |
| 814 | void |
| 815 | vnet_set_interface_l3_output_node (vlib_main_t *vm, u32 sw_if_index, |
| 816 | u8 *output_node) |
| 817 | { |
| 818 | vlib_node_t *l3_node; |
| 819 | |
| 820 | l3_node = vlib_get_node_by_name (vm, output_node); |
| 821 | |
| 822 | static char *arcs[] = { |
| 823 | "ip4-output", |
| 824 | "ip6-output", |
| 825 | "mpls-output", |
| 826 | "ethernet-output", |
| 827 | }; |
| 828 | u8 a; |
| 829 | |
| 830 | for (a = 0; a < ARRAY_LEN (arcs); a++) |
| 831 | { |
| 832 | u8 arc = vnet_get_feature_arc_index (arcs[a]); |
| 833 | vnet_feature_modify_end_node (arc, sw_if_index, l3_node->index); |
| 834 | } |
| 835 | } |
| 836 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 837 | /* Register an interface instance. */ |
| 838 | u32 |
| 839 | vnet_register_interface (vnet_main_t * vnm, |
| 840 | u32 dev_class_index, |
| 841 | u32 dev_instance, |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 842 | u32 hw_class_index, u32 hw_instance) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 843 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 844 | vnet_interface_main_t *im = &vnm->interface_main; |
| 845 | vnet_hw_interface_t *hw; |
| 846 | vnet_device_class_t *dev_class = |
| 847 | vnet_get_device_class (vnm, dev_class_index); |
| 848 | vnet_hw_interface_class_t *hw_class = |
| 849 | vnet_get_hw_interface_class (vnm, hw_class_index); |
| 850 | vlib_main_t *vm = vnm->vlib_main; |
Damjan Marion | 152e21d | 2016-11-29 14:55:43 +0100 | [diff] [blame] | 851 | vnet_feature_config_main_t *fcm; |
| 852 | vnet_config_main_t *cm; |
| 853 | u32 hw_index, i; |
Neale Ranns | cbe8d65 | 2018-04-27 04:42:47 -0700 | [diff] [blame] | 854 | char *tx_node_name = NULL, *output_node_name = NULL; |
Damjan Marion | f91098e | 2021-03-09 16:28:15 +0100 | [diff] [blame] | 855 | vlib_node_t *if_out_node = |
| 856 | vlib_get_node (vm, vnet_interface_output_node.index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 857 | |
| 858 | pool_get (im->hw_interfaces, hw); |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 859 | clib_memset (hw, 0, sizeof (*hw)); |
Dave Barach | f5667c3 | 2019-09-25 11:27:46 -0400 | [diff] [blame] | 860 | hw->trace_classify_table_index = ~0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 861 | |
| 862 | hw_index = hw - im->hw_interfaces; |
| 863 | hw->hw_if_index = hw_index; |
Damjan Marion | eabd424 | 2020-10-07 20:59:07 +0200 | [diff] [blame] | 864 | hw->default_rx_mode = VNET_HW_IF_RX_MODE_POLLING; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 865 | |
Mohsin Kazmi | 0d05c0d | 2021-11-09 17:44:10 +0000 | [diff] [blame] | 866 | if (hw_class->tx_hash_fn_type == VNET_HASH_FN_TYPE_ETHERNET || |
| 867 | hw_class->tx_hash_fn_type == VNET_HASH_FN_TYPE_IP) |
| 868 | hw->hf = vnet_hash_default_function (hw_class->tx_hash_fn_type); |
| 869 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 870 | if (dev_class->format_device_name) |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 871 | hw->name = format (0, "%U", dev_class->format_device_name, dev_instance); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 872 | else if (hw_class->format_interface_name) |
| 873 | hw->name = format (0, "%U", hw_class->format_interface_name, |
| 874 | dev_instance); |
| 875 | else |
| 876 | hw->name = format (0, "%s%x", hw_class->name, dev_instance); |
| 877 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 878 | if (!im->hw_interface_by_name) |
| 879 | im->hw_interface_by_name = hash_create_vec ( /* size */ 0, |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 880 | sizeof (hw->name[0]), |
| 881 | sizeof (uword)); |
| 882 | |
| 883 | hash_set_mem (im->hw_interface_by_name, hw->name, hw_index); |
| 884 | |
| 885 | /* Make hardware interface point to software interface. */ |
| 886 | { |
Eyal Bari | c5b1360 | 2016-11-24 19:42:43 +0200 | [diff] [blame] | 887 | vnet_sw_interface_t sw = { |
| 888 | .type = VNET_SW_INTERFACE_TYPE_HARDWARE, |
| 889 | .flood_class = VNET_FLOOD_CLASS_NORMAL, |
| 890 | .hw_if_index = hw_index |
| 891 | }; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 892 | hw->sw_if_index = vnet_create_sw_interface_no_callbacks (vnm, &sw); |
| 893 | } |
| 894 | |
| 895 | hw->dev_class_index = dev_class_index; |
| 896 | hw->dev_instance = dev_instance; |
| 897 | hw->hw_class_index = hw_class_index; |
| 898 | hw->hw_instance = hw_instance; |
| 899 | |
| 900 | hw->max_rate_bits_per_sec = 0; |
| 901 | hw->min_packet_bytes = 0; |
Ole Troan | d723161 | 2018-06-07 10:17:57 +0200 | [diff] [blame] | 902 | vnet_sw_interface_set_mtu (vnm, hw->sw_if_index, 0); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 903 | |
Damjan Marion | a31698b | 2021-03-10 14:35:28 +0100 | [diff] [blame] | 904 | if (dev_class->tx_function == 0 && dev_class->tx_fn_registrations == 0) |
John Lo | e5453d0 | 2018-01-23 19:21:34 -0500 | [diff] [blame] | 905 | goto no_output_nodes; /* No output/tx nodes to create */ |
| 906 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 907 | tx_node_name = (char *) format (0, "%v-tx", hw->name); |
| 908 | output_node_name = (char *) format (0, "%v-output", hw->name); |
| 909 | |
| 910 | /* If we have previously deleted interface nodes, re-use them. */ |
| 911 | if (vec_len (im->deleted_hw_interface_nodes) > 0) |
| 912 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 913 | vnet_hw_interface_nodes_t *hn; |
Pierre Pfister | 064f55d | 2016-10-17 15:58:29 +0100 | [diff] [blame] | 914 | vlib_node_t *node; |
| 915 | vlib_node_runtime_t *nrt; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 916 | |
| 917 | hn = vec_end (im->deleted_hw_interface_nodes) - 1; |
| 918 | |
| 919 | hw->tx_node_index = hn->tx_node_index; |
| 920 | hw->output_node_index = hn->output_node_index; |
| 921 | |
| 922 | vlib_node_rename (vm, hw->tx_node_index, "%v", tx_node_name); |
| 923 | vlib_node_rename (vm, hw->output_node_index, "%v", output_node_name); |
| 924 | |
Damjan Marion | 92ccf9b | 2021-03-26 11:38:01 +0100 | [diff] [blame] | 925 | foreach_vlib_main () |
| 926 | { |
| 927 | vnet_interface_output_runtime_t *rt; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 928 | |
Damjan Marion | 92ccf9b | 2021-03-26 11:38:01 +0100 | [diff] [blame] | 929 | rt = |
| 930 | vlib_node_get_runtime_data (this_vlib_main, hw->output_node_index); |
| 931 | ASSERT (rt->is_deleted == 1); |
| 932 | rt->is_deleted = 0; |
| 933 | rt->hw_if_index = hw_index; |
| 934 | rt->sw_if_index = hw->sw_if_index; |
| 935 | rt->dev_instance = hw->dev_instance; |
Igor Mikhailov (imichail) | 8249a58 | 2017-06-15 20:47:48 -0700 | [diff] [blame] | 936 | |
Damjan Marion | 92ccf9b | 2021-03-26 11:38:01 +0100 | [diff] [blame] | 937 | rt = vlib_node_get_runtime_data (this_vlib_main, hw->tx_node_index); |
| 938 | rt->hw_if_index = hw_index; |
| 939 | rt->sw_if_index = hw->sw_if_index; |
| 940 | rt->dev_instance = hw->dev_instance; |
| 941 | } |
Dave Barach | b8dca74 | 2016-07-01 12:38:11 -0400 | [diff] [blame] | 942 | |
Pierre Pfister | 064f55d | 2016-10-17 15:58:29 +0100 | [diff] [blame] | 943 | /* The new class may differ from the old one. |
| 944 | * Functions have to be updated. */ |
| 945 | node = vlib_get_node (vm, hw->output_node_index); |
Pierre Pfister | 064f55d | 2016-10-17 15:58:29 +0100 | [diff] [blame] | 946 | node->format_trace = format_vnet_interface_output_trace; |
Damjan Marion | f91098e | 2021-03-09 16:28:15 +0100 | [diff] [blame] | 947 | node->node_fn_registrations = if_out_node->node_fn_registrations; |
| 948 | node->function = if_out_node->function; |
| 949 | |
Damjan Marion | 92ccf9b | 2021-03-26 11:38:01 +0100 | [diff] [blame] | 950 | foreach_vlib_main () |
| 951 | { |
| 952 | nrt = vlib_node_get_runtime (this_vlib_main, hw->output_node_index); |
| 953 | nrt->function = node->function; |
| 954 | vlib_node_runtime_perf_counter (this_vlib_main, nrt, 0, 0, 0, |
| 955 | VLIB_NODE_RUNTIME_PERF_RESET); |
| 956 | } |
Pierre Pfister | 064f55d | 2016-10-17 15:58:29 +0100 | [diff] [blame] | 957 | |
| 958 | node = vlib_get_node (vm, hw->tx_node_index); |
Damjan Marion | a31698b | 2021-03-10 14:35:28 +0100 | [diff] [blame] | 959 | if (dev_class->tx_fn_registrations) |
| 960 | { |
| 961 | node->node_fn_registrations = dev_class->tx_fn_registrations; |
| 962 | node->function = vlib_node_get_preferred_node_fn_variant ( |
| 963 | vm, dev_class->tx_fn_registrations); |
| 964 | } |
| 965 | else |
| 966 | node->function = dev_class->tx_function; |
Pierre Pfister | 064f55d | 2016-10-17 15:58:29 +0100 | [diff] [blame] | 967 | node->format_trace = dev_class->format_tx_trace; |
Damjan Marion | 92ccf9b | 2021-03-26 11:38:01 +0100 | [diff] [blame] | 968 | |
| 969 | foreach_vlib_main () |
| 970 | { |
| 971 | nrt = vlib_node_get_runtime (this_vlib_main, hw->tx_node_index); |
| 972 | nrt->function = node->function; |
| 973 | vlib_node_runtime_perf_counter (this_vlib_main, nrt, 0, 0, 0, |
| 974 | VLIB_NODE_RUNTIME_PERF_RESET); |
| 975 | } |
Pierre Pfister | 064f55d | 2016-10-17 15:58:29 +0100 | [diff] [blame] | 976 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 977 | _vec_len (im->deleted_hw_interface_nodes) -= 1; |
| 978 | } |
| 979 | else |
| 980 | { |
| 981 | vlib_node_registration_t r; |
| 982 | vnet_interface_output_runtime_t rt = { |
| 983 | .hw_if_index = hw_index, |
| 984 | .sw_if_index = hw->sw_if_index, |
| 985 | .dev_instance = hw->dev_instance, |
| 986 | .is_deleted = 0, |
| 987 | }; |
| 988 | |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 989 | clib_memset (&r, 0, sizeof (r)); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 990 | r.type = VLIB_NODE_TYPE_INTERNAL; |
| 991 | r.runtime_data = &rt; |
| 992 | r.runtime_data_bytes = sizeof (rt); |
Damjan Marion | 1bd6cbb | 2021-04-15 13:12:51 +0200 | [diff] [blame] | 993 | r.scalar_size = sizeof (vnet_hw_if_tx_frame_t); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 994 | r.vector_size = sizeof (u32); |
| 995 | |
| 996 | r.flags = VLIB_NODE_FLAG_IS_OUTPUT; |
| 997 | r.name = tx_node_name; |
Damjan Marion | f91098e | 2021-03-09 16:28:15 +0100 | [diff] [blame] | 998 | if (dev_class->tx_fn_registrations) |
| 999 | { |
| 1000 | r.function = 0; |
| 1001 | r.node_fn_registrations = dev_class->tx_fn_registrations; |
| 1002 | } |
| 1003 | else |
| 1004 | r.function = dev_class->tx_function; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1005 | |
| 1006 | hw->tx_node_index = vlib_register_node (vm, &r); |
| 1007 | |
| 1008 | vlib_node_add_named_next_with_slot (vm, hw->tx_node_index, |
| 1009 | "error-drop", |
| 1010 | VNET_INTERFACE_TX_NEXT_DROP); |
| 1011 | |
| 1012 | r.flags = 0; |
| 1013 | r.name = output_node_name; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1014 | r.format_trace = format_vnet_interface_output_trace; |
Damjan Marion | f91098e | 2021-03-09 16:28:15 +0100 | [diff] [blame] | 1015 | if (if_out_node->node_fn_registrations) |
| 1016 | { |
| 1017 | r.function = 0; |
| 1018 | r.node_fn_registrations = if_out_node->node_fn_registrations; |
| 1019 | } |
| 1020 | else |
| 1021 | r.function = if_out_node->function; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1022 | |
| 1023 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1024 | static char *e[] = { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1025 | "interface is down", |
| 1026 | "interface is deleted", |
Mohsin Kazmi | 0d05c0d | 2021-11-09 17:44:10 +0000 | [diff] [blame] | 1027 | "no tx queue available", |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1028 | }; |
| 1029 | |
| 1030 | r.n_errors = ARRAY_LEN (e); |
| 1031 | r.error_strings = e; |
| 1032 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1033 | hw->output_node_index = vlib_register_node (vm, &r); |
| 1034 | |
Damjan Marion | 9c6ae5f | 2016-11-15 23:20:01 +0100 | [diff] [blame] | 1035 | vlib_node_add_named_next_with_slot (vm, hw->output_node_index, |
| 1036 | "error-drop", |
| 1037 | VNET_INTERFACE_OUTPUT_NEXT_DROP); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1038 | vlib_node_add_next_with_slot (vm, hw->output_node_index, |
| 1039 | hw->tx_node_index, |
| 1040 | VNET_INTERFACE_OUTPUT_NEXT_TX); |
Damjan Marion | 152e21d | 2016-11-29 14:55:43 +0100 | [diff] [blame] | 1041 | /* add interface to the list of "output-interface" feature arc start nodes |
| 1042 | and clone nexts from 1st interface if it exists */ |
| 1043 | fcm = vnet_feature_get_config_main (im->output_feature_arc_index); |
| 1044 | cm = &fcm->config_main; |
| 1045 | i = vec_len (cm->start_node_indices); |
| 1046 | vec_validate (cm->start_node_indices, i); |
| 1047 | cm->start_node_indices[i] = hw->output_node_index; |
| 1048 | if (hw_index) |
| 1049 | { |
| 1050 | /* copy nexts from 1st interface */ |
| 1051 | vnet_hw_interface_t *first_hw; |
| 1052 | vlib_node_t *first_node; |
| 1053 | |
| 1054 | first_hw = vnet_get_hw_interface (vnm, /* hw_if_index */ 0); |
| 1055 | first_node = vlib_get_node (vm, first_hw->output_node_index); |
| 1056 | |
| 1057 | /* 1st 2 nexts are already added above */ |
| 1058 | for (i = 2; i < vec_len (first_node->next_nodes); i++) |
| 1059 | vlib_node_add_next_with_slot (vm, hw->output_node_index, |
| 1060 | first_node->next_nodes[i], i); |
| 1061 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1062 | } |
| 1063 | |
Damjan Marion | 8932e45 | 2021-04-16 11:49:26 +0200 | [diff] [blame] | 1064 | hw->if_out_arc_end_node_next_index = vlib_node_add_next ( |
| 1065 | vm, vnet_interface_output_arc_end_node.index, hw->tx_node_index); |
| 1066 | vnet_if_update_lookup_tables (vnm, hw->sw_if_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1067 | setup_output_node (vm, hw->output_node_index, hw_class); |
| 1068 | setup_tx_node (vm, hw->tx_node_index, dev_class); |
| 1069 | |
John Lo | e5453d0 | 2018-01-23 19:21:34 -0500 | [diff] [blame] | 1070 | no_output_nodes: |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1071 | /* Call all up/down callbacks with zero flags when interface is created. */ |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1072 | vnet_sw_interface_set_flags_helper (vnm, hw->sw_if_index, /* flags */ 0, |
| 1073 | VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE); |
| 1074 | vnet_hw_interface_set_flags_helper (vnm, hw_index, /* flags */ 0, |
| 1075 | VNET_INTERFACE_SET_FLAGS_HELPER_IS_CREATE); |
Neale Ranns | cbe8d65 | 2018-04-27 04:42:47 -0700 | [diff] [blame] | 1076 | vec_free (tx_node_name); |
| 1077 | vec_free (output_node_name); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1078 | |
| 1079 | return hw_index; |
| 1080 | } |
| 1081 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1082 | void |
| 1083 | vnet_delete_hw_interface (vnet_main_t * vnm, u32 hw_if_index) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1084 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1085 | vnet_interface_main_t *im = &vnm->interface_main; |
| 1086 | vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index); |
| 1087 | vlib_main_t *vm = vnm->vlib_main; |
John Lo | e5453d0 | 2018-01-23 19:21:34 -0500 | [diff] [blame] | 1088 | vnet_device_class_t *dev_class = vnet_get_device_class (vnm, |
| 1089 | hw->dev_class_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1090 | /* If it is up, mark it down. */ |
| 1091 | if (hw->flags != 0) |
| 1092 | vnet_hw_interface_set_flags (vnm, hw_if_index, /* flags */ 0); |
| 1093 | |
| 1094 | /* Call delete callbacks. */ |
| 1095 | call_hw_interface_add_del_callbacks (vnm, hw_if_index, /* is_create */ 0); |
| 1096 | |
Damjan Marion | 1bd6cbb | 2021-04-15 13:12:51 +0200 | [diff] [blame] | 1097 | /* delete rx & tx queues */ |
Damjan Marion | 9410053 | 2020-11-06 23:25:57 +0100 | [diff] [blame] | 1098 | vnet_hw_if_unregister_all_rx_queues (vnm, hw_if_index); |
Damjan Marion | 1bd6cbb | 2021-04-15 13:12:51 +0200 | [diff] [blame] | 1099 | vnet_hw_if_unregister_all_tx_queues (vnm, hw_if_index); |
Damjan Marion | 9410053 | 2020-11-06 23:25:57 +0100 | [diff] [blame] | 1100 | vnet_hw_if_update_runtime_data (vnm, hw_if_index); |
| 1101 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1102 | /* Delete any sub-interfaces. */ |
| 1103 | { |
| 1104 | u32 id, sw_if_index; |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1105 | /* *INDENT-OFF* */ |
John Lo | 5957a14 | 2018-01-18 12:44:50 -0500 | [diff] [blame] | 1106 | hash_foreach (id, sw_if_index, hw->sub_interface_sw_if_index_by_id, |
| 1107 | ({ |
| 1108 | vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index); |
| 1109 | u64 sup_and_sub_key = |
| 1110 | ((u64) (si->sup_sw_if_index) << 32) | (u64) si->sub.id; |
| 1111 | hash_unset_mem_free (&im->sw_if_index_by_sup_and_sub, &sup_and_sub_key); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1112 | vnet_delete_sw_interface (vnm, sw_if_index); |
| 1113 | })); |
John Lo | 5957a14 | 2018-01-18 12:44:50 -0500 | [diff] [blame] | 1114 | hash_free (hw->sub_interface_sw_if_index_by_id); |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1115 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1116 | } |
| 1117 | |
John Lo | 5957a14 | 2018-01-18 12:44:50 -0500 | [diff] [blame] | 1118 | /* Delete software interface corresponding to hardware interface. */ |
| 1119 | vnet_delete_sw_interface (vnm, hw->sw_if_index); |
| 1120 | |
John Lo | e5453d0 | 2018-01-23 19:21:34 -0500 | [diff] [blame] | 1121 | if (dev_class->tx_function) |
| 1122 | { |
| 1123 | /* Put output/tx nodes into recycle pool */ |
| 1124 | vnet_hw_interface_nodes_t *dn; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1125 | |
Damjan Marion | 92ccf9b | 2021-03-26 11:38:01 +0100 | [diff] [blame] | 1126 | foreach_vlib_main () |
| 1127 | { |
John Lo | e5453d0 | 2018-01-23 19:21:34 -0500 | [diff] [blame] | 1128 | vnet_interface_output_runtime_t *rt = |
| 1129 | vlib_node_get_runtime_data (this_vlib_main, hw->output_node_index); |
Igor Mikhailov (imichail) | 8249a58 | 2017-06-15 20:47:48 -0700 | [diff] [blame] | 1130 | |
John Lo | e5453d0 | 2018-01-23 19:21:34 -0500 | [diff] [blame] | 1131 | /* Mark node runtime as deleted so output node (if called) |
| 1132 | * will drop packets. */ |
| 1133 | rt->is_deleted = 1; |
Damjan Marion | 92ccf9b | 2021-03-26 11:38:01 +0100 | [diff] [blame] | 1134 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1135 | |
John Lo | e5453d0 | 2018-01-23 19:21:34 -0500 | [diff] [blame] | 1136 | vlib_node_rename (vm, hw->output_node_index, |
| 1137 | "interface-%d-output-deleted", hw_if_index); |
| 1138 | vlib_node_rename (vm, hw->tx_node_index, "interface-%d-tx-deleted", |
| 1139 | hw_if_index); |
| 1140 | vec_add2 (im->deleted_hw_interface_nodes, dn, 1); |
| 1141 | dn->tx_node_index = hw->tx_node_index; |
| 1142 | dn->output_node_index = hw->output_node_index; |
| 1143 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1144 | hash_unset_mem (im->hw_interface_by_name, hw->name); |
| 1145 | vec_free (hw->name); |
Neale Ranns | cbe8d65 | 2018-04-27 04:42:47 -0700 | [diff] [blame] | 1146 | vec_free (hw->hw_address); |
Mohsin Kazmi | 7318c42 | 2021-10-04 11:29:08 +0200 | [diff] [blame] | 1147 | vec_free (hw->output_node_thread_runtimes); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1148 | pool_put (im->hw_interfaces, hw); |
| 1149 | } |
| 1150 | |
Neale Ranns | 8b37b87 | 2016-11-21 12:25:22 +0000 | [diff] [blame] | 1151 | void |
| 1152 | vnet_hw_interface_walk_sw (vnet_main_t * vnm, |
| 1153 | u32 hw_if_index, |
| 1154 | vnet_hw_sw_interface_walk_t fn, void *ctx) |
| 1155 | { |
| 1156 | vnet_hw_interface_t *hi; |
| 1157 | u32 id, sw_if_index; |
| 1158 | |
| 1159 | hi = vnet_get_hw_interface (vnm, hw_if_index); |
Neale Ranns | 17ff3c1 | 2018-07-04 10:24:24 -0700 | [diff] [blame] | 1160 | /* the super first, then the sub interfaces */ |
| 1161 | if (WALK_STOP == fn (vnm, hi->sw_if_index, ctx)) |
| 1162 | return; |
Neale Ranns | 8b37b87 | 2016-11-21 12:25:22 +0000 | [diff] [blame] | 1163 | |
| 1164 | /* *INDENT-OFF* */ |
| 1165 | hash_foreach (id, sw_if_index, |
| 1166 | hi->sub_interface_sw_if_index_by_id, |
| 1167 | ({ |
Neale Ranns | 0053de6 | 2018-05-22 08:40:52 -0700 | [diff] [blame] | 1168 | if (WALK_STOP == fn (vnm, sw_if_index, ctx)) |
| 1169 | break; |
Neale Ranns | 8b37b87 | 2016-11-21 12:25:22 +0000 | [diff] [blame] | 1170 | })); |
| 1171 | /* *INDENT-ON* */ |
| 1172 | } |
| 1173 | |
Neale Ranns | 0053de6 | 2018-05-22 08:40:52 -0700 | [diff] [blame] | 1174 | void |
Neale Ranns | 17ff3c1 | 2018-07-04 10:24:24 -0700 | [diff] [blame] | 1175 | vnet_hw_interface_walk (vnet_main_t * vnm, |
| 1176 | vnet_hw_interface_walk_t fn, void *ctx) |
| 1177 | { |
| 1178 | vnet_interface_main_t *im; |
| 1179 | vnet_hw_interface_t *hi; |
| 1180 | |
| 1181 | im = &vnm->interface_main; |
| 1182 | |
| 1183 | /* *INDENT-OFF* */ |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 1184 | pool_foreach (hi, im->hw_interfaces) |
| 1185 | { |
Neale Ranns | 17ff3c1 | 2018-07-04 10:24:24 -0700 | [diff] [blame] | 1186 | if (WALK_STOP == fn(vnm, hi->hw_if_index, ctx)) |
| 1187 | break; |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 1188 | } |
Neale Ranns | 17ff3c1 | 2018-07-04 10:24:24 -0700 | [diff] [blame] | 1189 | /* *INDENT-ON* */ |
| 1190 | } |
| 1191 | |
| 1192 | void |
Neale Ranns | 0053de6 | 2018-05-22 08:40:52 -0700 | [diff] [blame] | 1193 | vnet_sw_interface_walk (vnet_main_t * vnm, |
| 1194 | vnet_sw_interface_walk_t fn, void *ctx) |
| 1195 | { |
| 1196 | vnet_interface_main_t *im; |
| 1197 | vnet_sw_interface_t *si; |
| 1198 | |
| 1199 | im = &vnm->interface_main; |
| 1200 | |
| 1201 | /* *INDENT-OFF* */ |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 1202 | pool_foreach (si, im->sw_interfaces) |
Neale Ranns | 0053de6 | 2018-05-22 08:40:52 -0700 | [diff] [blame] | 1203 | { |
| 1204 | if (WALK_STOP == fn (vnm, si, ctx)) |
| 1205 | break; |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 1206 | } |
Neale Ranns | 0053de6 | 2018-05-22 08:40:52 -0700 | [diff] [blame] | 1207 | /* *INDENT-ON* */ |
| 1208 | } |
| 1209 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1210 | void |
| 1211 | vnet_hw_interface_init_for_class (vnet_main_t * vnm, u32 hw_if_index, |
| 1212 | u32 hw_class_index, u32 hw_instance) |
| 1213 | { |
| 1214 | vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index); |
| 1215 | vnet_hw_interface_class_t *hc = |
| 1216 | vnet_get_hw_interface_class (vnm, hw_class_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1217 | |
| 1218 | hi->hw_class_index = hw_class_index; |
| 1219 | hi->hw_instance = hw_instance; |
| 1220 | setup_output_node (vnm->vlib_main, hi->output_node_index, hc); |
| 1221 | } |
| 1222 | |
| 1223 | static clib_error_t * |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1224 | vnet_hw_interface_set_class_helper (vnet_main_t * vnm, u32 hw_if_index, |
| 1225 | u32 hw_class_index, u32 redistribute) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1226 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1227 | vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index); |
| 1228 | vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, hi->sw_if_index); |
| 1229 | vnet_hw_interface_class_t *old_class = |
| 1230 | vnet_get_hw_interface_class (vnm, hi->hw_class_index); |
| 1231 | vnet_hw_interface_class_t *new_class = |
| 1232 | vnet_get_hw_interface_class (vnm, hw_class_index); |
| 1233 | vnet_device_class_t *dev_class = |
| 1234 | vnet_get_device_class (vnm, hi->dev_class_index); |
| 1235 | clib_error_t *error = 0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1236 | |
| 1237 | /* New class equals old class? Nothing to do. */ |
| 1238 | if (hi->hw_class_index == hw_class_index) |
| 1239 | return 0; |
| 1240 | |
| 1241 | /* No need (and incorrect since admin up flag may be set) to do error checking when |
| 1242 | receiving unserialize message. */ |
| 1243 | if (redistribute) |
| 1244 | { |
| 1245 | if (si->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1246 | return clib_error_return (0, |
| 1247 | "%v must be admin down to change class from %s to %s", |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1248 | hi->name, old_class->name, new_class->name); |
| 1249 | |
| 1250 | /* Make sure interface supports given class. */ |
| 1251 | if ((new_class->is_valid_class_for_interface |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1252 | && !new_class->is_valid_class_for_interface (vnm, hw_if_index, |
| 1253 | hw_class_index)) |
| 1254 | || (dev_class->is_valid_class_for_interface |
| 1255 | && !dev_class->is_valid_class_for_interface (vnm, hw_if_index, |
| 1256 | hw_class_index))) |
| 1257 | return clib_error_return (0, |
| 1258 | "%v class cannot be changed from %s to %s", |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1259 | hi->name, old_class->name, new_class->name); |
| 1260 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1261 | } |
| 1262 | |
| 1263 | if (old_class->hw_class_change) |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1264 | old_class->hw_class_change (vnm, hw_if_index, old_class->index, |
| 1265 | new_class->index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1266 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1267 | vnet_hw_interface_init_for_class (vnm, hw_if_index, new_class->index, |
| 1268 | /* instance */ ~0); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1269 | |
| 1270 | if (new_class->hw_class_change) |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1271 | new_class->hw_class_change (vnm, hw_if_index, old_class->index, |
| 1272 | new_class->index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1273 | |
| 1274 | if (dev_class->hw_class_change) |
| 1275 | dev_class->hw_class_change (vnm, hw_if_index, new_class->index); |
| 1276 | |
| 1277 | return error; |
| 1278 | } |
| 1279 | |
| 1280 | clib_error_t * |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1281 | vnet_hw_interface_set_class (vnet_main_t * vnm, u32 hw_if_index, |
| 1282 | u32 hw_class_index) |
| 1283 | { |
| 1284 | return vnet_hw_interface_set_class_helper (vnm, hw_if_index, hw_class_index, |
| 1285 | /* redistribute */ 1); |
| 1286 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1287 | |
| 1288 | static int |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1289 | vnet_hw_interface_rx_redirect_to_node_helper (vnet_main_t * vnm, |
| 1290 | u32 hw_if_index, |
| 1291 | u32 node_index, |
| 1292 | u32 redistribute) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1293 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1294 | vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index); |
| 1295 | vnet_device_class_t *dev_class = vnet_get_device_class |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1296 | (vnm, hi->dev_class_index); |
| 1297 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1298 | if (dev_class->rx_redirect_to_node) |
| 1299 | { |
| 1300 | dev_class->rx_redirect_to_node (vnm, hw_if_index, node_index); |
| 1301 | return 0; |
| 1302 | } |
| 1303 | |
| 1304 | return VNET_API_ERROR_UNIMPLEMENTED; |
| 1305 | } |
| 1306 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1307 | int |
| 1308 | vnet_hw_interface_rx_redirect_to_node (vnet_main_t * vnm, u32 hw_if_index, |
| 1309 | u32 node_index) |
| 1310 | { |
| 1311 | return vnet_hw_interface_rx_redirect_to_node_helper (vnm, hw_if_index, |
| 1312 | node_index, |
| 1313 | 1 /* redistribute */ ); |
| 1314 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1315 | |
| 1316 | word |
| 1317 | vnet_sw_interface_compare (vnet_main_t * vnm, |
| 1318 | uword sw_if_index0, uword sw_if_index1) |
| 1319 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1320 | vnet_sw_interface_t *sup0 = vnet_get_sup_sw_interface (vnm, sw_if_index0); |
| 1321 | vnet_sw_interface_t *sup1 = vnet_get_sup_sw_interface (vnm, sw_if_index1); |
| 1322 | vnet_hw_interface_t *h0 = vnet_get_hw_interface (vnm, sup0->hw_if_index); |
| 1323 | vnet_hw_interface_t *h1 = vnet_get_hw_interface (vnm, sup1->hw_if_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1324 | |
| 1325 | if (h0 != h1) |
| 1326 | return vec_cmp (h0->name, h1->name); |
| 1327 | return (word) h0->hw_instance - (word) h1->hw_instance; |
| 1328 | } |
| 1329 | |
| 1330 | word |
| 1331 | vnet_hw_interface_compare (vnet_main_t * vnm, |
| 1332 | uword hw_if_index0, uword hw_if_index1) |
| 1333 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1334 | vnet_hw_interface_t *h0 = vnet_get_hw_interface (vnm, hw_if_index0); |
| 1335 | vnet_hw_interface_t *h1 = vnet_get_hw_interface (vnm, hw_if_index1); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1336 | |
| 1337 | if (h0 != h1) |
| 1338 | return vec_cmp (h0->name, h1->name); |
| 1339 | return (word) h0->hw_instance - (word) h1->hw_instance; |
| 1340 | } |
| 1341 | |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 1342 | int |
| 1343 | vnet_sw_interface_is_p2p (vnet_main_t * vnm, u32 sw_if_index) |
| 1344 | { |
Pavel Kotucek | 15ac81c | 2017-06-20 14:00:26 +0200 | [diff] [blame] | 1345 | vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index); |
Neale Ranns | 17ff3c1 | 2018-07-04 10:24:24 -0700 | [diff] [blame] | 1346 | if ((si->type == VNET_SW_INTERFACE_TYPE_P2P) || |
| 1347 | (si->type == VNET_SW_INTERFACE_TYPE_PIPE)) |
Pavel Kotucek | 15ac81c | 2017-06-20 14:00:26 +0200 | [diff] [blame] | 1348 | return 1; |
| 1349 | |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 1350 | vnet_hw_interface_t *hw = vnet_get_sup_hw_interface (vnm, sw_if_index); |
| 1351 | vnet_hw_interface_class_t *hc = |
| 1352 | vnet_get_hw_interface_class (vnm, hw->hw_class_index); |
| 1353 | |
| 1354 | return (hc->flags & VNET_HW_INTERFACE_CLASS_FLAG_P2P); |
| 1355 | } |
| 1356 | |
Neale Ranns | 5f8f617 | 2019-04-18 10:23:56 +0000 | [diff] [blame] | 1357 | int |
| 1358 | vnet_sw_interface_is_nbma (vnet_main_t * vnm, u32 sw_if_index) |
| 1359 | { |
| 1360 | vnet_hw_interface_t *hw = vnet_get_sup_hw_interface (vnm, sw_if_index); |
| 1361 | vnet_hw_interface_class_t *hc = |
| 1362 | vnet_get_hw_interface_class (vnm, hw->hw_class_index); |
| 1363 | |
| 1364 | return (hc->flags & VNET_HW_INTERFACE_CLASS_FLAG_NBMA); |
| 1365 | } |
| 1366 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1367 | clib_error_t * |
Pim van Pelt | 76b19ce | 2021-08-10 23:44:44 +0200 | [diff] [blame] | 1368 | vnet_sw_interface_supports_addressing (vnet_main_t *vnm, u32 sw_if_index) |
| 1369 | { |
| 1370 | if (sw_if_index == 0) |
| 1371 | { |
| 1372 | return clib_error_create ( |
| 1373 | "local0 interface doesn't support IP addressing"); |
| 1374 | } |
| 1375 | |
| 1376 | if (vnet_sw_interface_is_sub (vnm, sw_if_index)) |
| 1377 | { |
| 1378 | vnet_sw_interface_t *si; |
| 1379 | si = vnet_get_sw_interface_or_null (vnm, sw_if_index); |
| 1380 | if (si && si->type == VNET_SW_INTERFACE_TYPE_SUB && |
| 1381 | si->sub.eth.flags.exact_match == 0) |
| 1382 | { |
| 1383 | return clib_error_create ( |
| 1384 | "sub-interface without exact-match doesn't support IP addressing"); |
| 1385 | } |
| 1386 | } |
| 1387 | return NULL; |
| 1388 | } |
| 1389 | |
| 1390 | clib_error_t * |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1391 | vnet_interface_init (vlib_main_t * vm) |
| 1392 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1393 | vnet_main_t *vnm = vnet_get_main (); |
| 1394 | vnet_interface_main_t *im = &vnm->interface_main; |
| 1395 | vlib_buffer_t *b = 0; |
| 1396 | vnet_buffer_opaque_t *o = 0; |
Dave Barach | 7bee773 | 2017-10-18 18:48:11 -0400 | [diff] [blame] | 1397 | clib_error_t *error; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1398 | |
| 1399 | /* |
| 1400 | * Keep people from shooting themselves in the foot. |
| 1401 | */ |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1402 | if (sizeof (b->opaque) != sizeof (vnet_buffer_opaque_t)) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1403 | { |
| 1404 | #define _(a) if (sizeof(o->a) > sizeof (o->unused)) \ |
| 1405 | clib_warning \ |
| 1406 | ("FATAL: size of opaque union subtype %s is %d (max %d)", \ |
| 1407 | #a, sizeof(o->a), sizeof (o->unused)); |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1408 | foreach_buffer_opaque_union_subtype; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1409 | #undef _ |
| 1410 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1411 | return clib_error_return |
| 1412 | (0, "FATAL: size of vlib buffer opaque %d, size of vnet opaque %d", |
| 1413 | sizeof (b->opaque), sizeof (vnet_buffer_opaque_t)); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1414 | } |
| 1415 | |
jaszha03 | 5cdde5c | 2019-07-11 20:47:24 +0000 | [diff] [blame] | 1416 | clib_spinlock_init (&im->sw_if_counter_lock); |
| 1417 | clib_spinlock_lock (&im->sw_if_counter_lock); /* should be no need */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1418 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1419 | vec_validate (im->sw_if_counters, VNET_N_SIMPLE_INTERFACE_COUNTER - 1); |
Ole Troan | 1ec0ea8 | 2018-06-14 09:28:27 +0200 | [diff] [blame] | 1420 | #define _(E,n,p) \ |
| 1421 | im->sw_if_counters[VNET_INTERFACE_COUNTER_##E].name = #n; \ |
| 1422 | im->sw_if_counters[VNET_INTERFACE_COUNTER_##E].stat_segment_name = "/" #p "/" #n; |
| 1423 | foreach_simple_interface_counter_name |
| 1424 | #undef _ |
| 1425 | vec_validate (im->combined_sw_if_counters, |
| 1426 | VNET_N_COMBINED_INTERFACE_COUNTER - 1); |
| 1427 | #define _(E,n,p) \ |
| 1428 | im->combined_sw_if_counters[VNET_INTERFACE_COUNTER_##E].name = #n; \ |
| 1429 | im->combined_sw_if_counters[VNET_INTERFACE_COUNTER_##E].stat_segment_name = "/" #p "/" #n; |
| 1430 | foreach_combined_interface_counter_name |
| 1431 | #undef _ |
jaszha03 | 5cdde5c | 2019-07-11 20:47:24 +0000 | [diff] [blame] | 1432 | clib_spinlock_unlock (&im->sw_if_counter_lock); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1433 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1434 | im->device_class_by_name = hash_create_string ( /* size */ 0, |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1435 | sizeof (uword)); |
| 1436 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1437 | vnet_device_class_t *c; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1438 | |
| 1439 | c = vnm->device_class_registrations; |
| 1440 | |
| 1441 | while (c) |
| 1442 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1443 | c->index = vec_len (im->device_classes); |
| 1444 | hash_set_mem (im->device_class_by_name, c->name, c->index); |
Mohsin Kazmi | dd8e7d0 | 2018-07-23 14:45:57 +0200 | [diff] [blame] | 1445 | |
Damjan Marion | a31698b | 2021-03-10 14:35:28 +0100 | [diff] [blame] | 1446 | /* to avoid confusion, please remove ".tx_function" statement |
| 1447 | from VNET_DEVICE_CLASS() if using function candidates */ |
| 1448 | ASSERT (c->tx_fn_registrations == 0 || c->tx_function == 0); |
| 1449 | |
Mohsin Kazmi | dd8e7d0 | 2018-07-23 14:45:57 +0200 | [diff] [blame] | 1450 | if (c->tx_fn_registrations) |
Damjan Marion | a31698b | 2021-03-10 14:35:28 +0100 | [diff] [blame] | 1451 | c->tx_function = vlib_node_get_preferred_node_fn_variant ( |
| 1452 | vm, c->tx_fn_registrations); |
Mohsin Kazmi | dd8e7d0 | 2018-07-23 14:45:57 +0200 | [diff] [blame] | 1453 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1454 | vec_add1 (im->device_classes, c[0]); |
| 1455 | c = c->next_class_registration; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1456 | } |
| 1457 | } |
| 1458 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1459 | im->hw_interface_class_by_name = hash_create_string ( /* size */ 0, |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1460 | sizeof (uword)); |
| 1461 | |
Damjan Marion | 9410053 | 2020-11-06 23:25:57 +0100 | [diff] [blame] | 1462 | im->rxq_index_by_hw_if_index_and_queue_id = |
| 1463 | hash_create_mem (0, sizeof (u64), sizeof (u32)); |
Damjan Marion | 1bd6cbb | 2021-04-15 13:12:51 +0200 | [diff] [blame] | 1464 | im->txq_index_by_hw_if_index_and_queue_id = |
| 1465 | hash_create_mem (0, sizeof (u64), sizeof (u32)); |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1466 | im->sw_if_index_by_sup_and_sub = hash_create_mem (0, sizeof (u64), |
| 1467 | sizeof (uword)); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1468 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1469 | vnet_hw_interface_class_t *c; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1470 | |
| 1471 | c = vnm->hw_interface_class_registrations; |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1472 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1473 | while (c) |
| 1474 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1475 | c->index = vec_len (im->hw_interface_classes); |
| 1476 | hash_set_mem (im->hw_interface_class_by_name, c->name, c->index); |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 1477 | |
| 1478 | if (NULL == c->build_rewrite) |
| 1479 | c->build_rewrite = default_build_rewrite; |
| 1480 | if (NULL == c->update_adjacency) |
| 1481 | c->update_adjacency = default_update_adjacency; |
| 1482 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1483 | vec_add1 (im->hw_interface_classes, c[0]); |
| 1484 | c = c->next_class_registration; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1485 | } |
| 1486 | } |
| 1487 | |
Andrew Yourtchenko | 6a7cff7 | 2018-10-12 16:09:22 +0200 | [diff] [blame] | 1488 | /* init per-thread data */ |
| 1489 | vec_validate_aligned (im->per_thread_data, vlib_num_workers (), |
| 1490 | CLIB_CACHE_LINE_BYTES); |
| 1491 | |
Dave Barach | 7bee773 | 2017-10-18 18:48:11 -0400 | [diff] [blame] | 1492 | if ((error = vlib_call_init_function (vm, vnet_interface_cli_init))) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1493 | return error; |
Dave Barach | 7bee773 | 2017-10-18 18:48:11 -0400 | [diff] [blame] | 1494 | |
Dave Barach | 7be864a | 2016-11-28 11:41:35 -0500 | [diff] [blame] | 1495 | vnm->interface_tag_by_sw_if_index = hash_create (0, sizeof (uword)); |
Dave Barach | 7bee773 | 2017-10-18 18:48:11 -0400 | [diff] [blame] | 1496 | |
Dave Barach | 7bee773 | 2017-10-18 18:48:11 -0400 | [diff] [blame] | 1497 | return 0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1498 | } |
| 1499 | |
| 1500 | VLIB_INIT_FUNCTION (vnet_interface_init); |
| 1501 | |
| 1502 | /* Kludge to renumber interface names [only!] */ |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1503 | int |
| 1504 | vnet_interface_name_renumber (u32 sw_if_index, u32 new_show_dev_instance) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1505 | { |
| 1506 | int rv; |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1507 | vnet_main_t *vnm = vnet_get_main (); |
| 1508 | vnet_interface_main_t *im = &vnm->interface_main; |
| 1509 | vnet_hw_interface_t *hi = vnet_get_sup_hw_interface (vnm, sw_if_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1510 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1511 | vnet_device_class_t *dev_class = vnet_get_device_class |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1512 | (vnm, hi->dev_class_index); |
| 1513 | |
| 1514 | if (dev_class->name_renumber == 0 || dev_class->format_device_name == 0) |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1515 | return VNET_API_ERROR_UNIMPLEMENTED; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1516 | |
| 1517 | rv = dev_class->name_renumber (hi, new_show_dev_instance); |
| 1518 | |
| 1519 | if (rv) |
| 1520 | return rv; |
| 1521 | |
| 1522 | hash_unset_mem (im->hw_interface_by_name, hi->name); |
| 1523 | vec_free (hi->name); |
| 1524 | /* Use the mapping we set up to call it Ishmael */ |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1525 | hi->name = format (0, "%U", dev_class->format_device_name, |
| 1526 | hi->dev_instance); |
| 1527 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1528 | hash_set_mem (im->hw_interface_by_name, hi->name, hi->hw_if_index); |
| 1529 | return rv; |
| 1530 | } |
| 1531 | |
Sean Hope | 608d1ed | 2016-03-09 00:35:21 -0500 | [diff] [blame] | 1532 | clib_error_t * |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1533 | vnet_rename_interface (vnet_main_t * vnm, u32 hw_if_index, char *new_name) |
Sean Hope | 608d1ed | 2016-03-09 00:35:21 -0500 | [diff] [blame] | 1534 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1535 | vnet_interface_main_t *im = &vnm->interface_main; |
| 1536 | vlib_main_t *vm = vnm->vlib_main; |
| 1537 | vnet_hw_interface_t *hw; |
| 1538 | u8 *old_name; |
| 1539 | clib_error_t *error = 0; |
Sean Hope | 608d1ed | 2016-03-09 00:35:21 -0500 | [diff] [blame] | 1540 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1541 | hw = vnet_get_hw_interface (vnm, hw_if_index); |
Sean Hope | 608d1ed | 2016-03-09 00:35:21 -0500 | [diff] [blame] | 1542 | if (!hw) |
| 1543 | { |
| 1544 | return clib_error_return (0, |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1545 | "unable to find hw interface for index %u", |
| 1546 | hw_if_index); |
Sean Hope | 608d1ed | 2016-03-09 00:35:21 -0500 | [diff] [blame] | 1547 | } |
| 1548 | |
| 1549 | old_name = hw->name; |
| 1550 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1551 | /* set new hw->name */ |
Sean Hope | 608d1ed | 2016-03-09 00:35:21 -0500 | [diff] [blame] | 1552 | hw->name = format (0, "%s", new_name); |
| 1553 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1554 | /* remove the old name to hw_if_index mapping and install the new one */ |
Sean Hope | 608d1ed | 2016-03-09 00:35:21 -0500 | [diff] [blame] | 1555 | hash_unset_mem (im->hw_interface_by_name, old_name); |
| 1556 | hash_set_mem (im->hw_interface_by_name, hw->name, hw_if_index); |
| 1557 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1558 | /* rename tx/output nodes */ |
Sean Hope | 608d1ed | 2016-03-09 00:35:21 -0500 | [diff] [blame] | 1559 | vlib_node_rename (vm, hw->tx_node_index, "%v-tx", hw->name); |
| 1560 | vlib_node_rename (vm, hw->output_node_index, "%v-output", hw->name); |
| 1561 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1562 | /* free the old name vector */ |
Sean Hope | 608d1ed | 2016-03-09 00:35:21 -0500 | [diff] [blame] | 1563 | vec_free (old_name); |
| 1564 | |
| 1565 | return error; |
| 1566 | } |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1567 | |
Matthew Smith | e0792fd | 2019-07-12 11:48:24 -0500 | [diff] [blame] | 1568 | clib_error_t * |
| 1569 | vnet_hw_interface_add_del_mac_address (vnet_main_t * vnm, |
| 1570 | u32 hw_if_index, |
| 1571 | const u8 * mac_address, u8 is_add) |
| 1572 | { |
| 1573 | clib_error_t *error = 0; |
| 1574 | vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index); |
| 1575 | |
| 1576 | vnet_device_class_t *dev_class = |
| 1577 | vnet_get_device_class (vnm, hi->dev_class_index); |
| 1578 | |
| 1579 | if (!hi->hw_address) |
| 1580 | { |
| 1581 | error = |
| 1582 | clib_error_return |
| 1583 | (0, "Secondary MAC Addresses not supported for interface index %u", |
| 1584 | hw_if_index); |
| 1585 | goto done; |
| 1586 | } |
| 1587 | |
| 1588 | if (dev_class->mac_addr_add_del_function) |
| 1589 | error = dev_class->mac_addr_add_del_function (hi, mac_address, is_add); |
| 1590 | |
| 1591 | if (!error) |
| 1592 | { |
| 1593 | vnet_hw_interface_class_t *hw_class; |
| 1594 | |
| 1595 | hw_class = vnet_get_hw_interface_class (vnm, hi->hw_class_index); |
| 1596 | |
| 1597 | if (NULL != hw_class->mac_addr_add_del_function) |
| 1598 | error = hw_class->mac_addr_add_del_function (hi, mac_address, is_add); |
| 1599 | } |
| 1600 | |
| 1601 | /* If no errors, add to the list of secondary MACs on the ethernet intf */ |
| 1602 | if (!error) |
| 1603 | ethernet_interface_add_del_address (ðernet_main, hw_if_index, |
| 1604 | mac_address, is_add); |
| 1605 | |
| 1606 | done: |
Damjan Marion | d1bd5d2 | 2020-11-23 16:58:05 +0100 | [diff] [blame] | 1607 | if (error) |
| 1608 | log_err ("hw_add_del_mac_address: %U", format_clib_error, error); |
Matthew Smith | e0792fd | 2019-07-12 11:48:24 -0500 | [diff] [blame] | 1609 | return error; |
| 1610 | } |
| 1611 | |
Pavel Kotucek | c631f2d | 2016-09-26 10:40:02 +0200 | [diff] [blame] | 1612 | static clib_error_t * |
| 1613 | vnet_hw_interface_change_mac_address_helper (vnet_main_t * vnm, |
John Lo | 62fcc0a | 2017-10-31 14:31:10 -0400 | [diff] [blame] | 1614 | u32 hw_if_index, |
Neale Ranns | 8f8994a | 2018-10-30 03:47:20 -0700 | [diff] [blame] | 1615 | const u8 * mac_address) |
Pavel Kotucek | c631f2d | 2016-09-26 10:40:02 +0200 | [diff] [blame] | 1616 | { |
| 1617 | clib_error_t *error = 0; |
| 1618 | vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index); |
| 1619 | |
| 1620 | if (hi->hw_address) |
| 1621 | { |
Neale Ranns | 3b81a1e | 2018-09-06 09:50:26 -0700 | [diff] [blame] | 1622 | u8 *old_address = vec_dup (hi->hw_address); |
Pavel Kotucek | c631f2d | 2016-09-26 10:40:02 +0200 | [diff] [blame] | 1623 | vnet_device_class_t *dev_class = |
| 1624 | vnet_get_device_class (vnm, hi->dev_class_index); |
| 1625 | if (dev_class->mac_addr_change_function) |
| 1626 | { |
| 1627 | error = |
Neale Ranns | 3b81a1e | 2018-09-06 09:50:26 -0700 | [diff] [blame] | 1628 | dev_class->mac_addr_change_function (hi, old_address, |
| 1629 | mac_address); |
Pavel Kotucek | c631f2d | 2016-09-26 10:40:02 +0200 | [diff] [blame] | 1630 | } |
| 1631 | if (!error) |
| 1632 | { |
Neale Ranns | 3be6b28 | 2016-12-20 14:24:01 +0000 | [diff] [blame] | 1633 | vnet_hw_interface_class_t *hw_class; |
Pavel Kotucek | c631f2d | 2016-09-26 10:40:02 +0200 | [diff] [blame] | 1634 | |
Neale Ranns | 3be6b28 | 2016-12-20 14:24:01 +0000 | [diff] [blame] | 1635 | hw_class = vnet_get_hw_interface_class (vnm, hi->hw_class_index); |
Pavel Kotucek | a6b3177 | 2016-10-14 10:20:59 +0200 | [diff] [blame] | 1636 | |
Neale Ranns | 3be6b28 | 2016-12-20 14:24:01 +0000 | [diff] [blame] | 1637 | if (NULL != hw_class->mac_addr_change_function) |
Neale Ranns | 3b81a1e | 2018-09-06 09:50:26 -0700 | [diff] [blame] | 1638 | hw_class->mac_addr_change_function (hi, old_address, mac_address); |
Pavel Kotucek | c631f2d | 2016-09-26 10:40:02 +0200 | [diff] [blame] | 1639 | } |
| 1640 | else |
| 1641 | { |
| 1642 | error = |
| 1643 | clib_error_return (0, |
| 1644 | "MAC Address Change is not supported on this interface"); |
| 1645 | } |
Neale Ranns | 3b81a1e | 2018-09-06 09:50:26 -0700 | [diff] [blame] | 1646 | vec_free (old_address); |
Pavel Kotucek | c631f2d | 2016-09-26 10:40:02 +0200 | [diff] [blame] | 1647 | } |
| 1648 | else |
| 1649 | { |
| 1650 | error = |
| 1651 | clib_error_return (0, |
| 1652 | "mac address change is not supported for interface index %u", |
| 1653 | hw_if_index); |
| 1654 | } |
| 1655 | return error; |
| 1656 | } |
| 1657 | |
| 1658 | clib_error_t * |
| 1659 | vnet_hw_interface_change_mac_address (vnet_main_t * vnm, u32 hw_if_index, |
Neale Ranns | 8f8994a | 2018-10-30 03:47:20 -0700 | [diff] [blame] | 1660 | const u8 * mac_address) |
Pavel Kotucek | c631f2d | 2016-09-26 10:40:02 +0200 | [diff] [blame] | 1661 | { |
| 1662 | return vnet_hw_interface_change_mac_address_helper |
| 1663 | (vnm, hw_if_index, mac_address); |
| 1664 | } |
| 1665 | |
Stanislav Zaikin | 328b5da | 2021-07-15 16:27:29 +0200 | [diff] [blame] | 1666 | static int |
| 1667 | vnet_sw_interface_check_table_same (u32 unnumbered_sw_if_index, |
| 1668 | u32 ip_sw_if_index) |
| 1669 | { |
Stanislav Zaikin | 328b5da | 2021-07-15 16:27:29 +0200 | [diff] [blame] | 1670 | if (ip4_main.fib_index_by_sw_if_index[unnumbered_sw_if_index] != |
| 1671 | ip4_main.fib_index_by_sw_if_index[ip_sw_if_index]) |
| 1672 | return VNET_API_ERROR_UNEXPECTED_INTF_STATE; |
| 1673 | |
| 1674 | if (ip4_main.mfib_index_by_sw_if_index[unnumbered_sw_if_index] != |
| 1675 | ip4_main.mfib_index_by_sw_if_index[ip_sw_if_index]) |
| 1676 | return VNET_API_ERROR_UNEXPECTED_INTF_STATE; |
| 1677 | |
| 1678 | if (ip6_main.fib_index_by_sw_if_index[unnumbered_sw_if_index] != |
| 1679 | ip6_main.fib_index_by_sw_if_index[ip_sw_if_index]) |
| 1680 | return VNET_API_ERROR_UNEXPECTED_INTF_STATE; |
| 1681 | |
| 1682 | if (ip6_main.mfib_index_by_sw_if_index[unnumbered_sw_if_index] != |
| 1683 | ip6_main.mfib_index_by_sw_if_index[ip_sw_if_index]) |
| 1684 | return VNET_API_ERROR_UNEXPECTED_INTF_STATE; |
| 1685 | |
| 1686 | return 0; |
| 1687 | } |
| 1688 | |
Neale Ranns | 2ae2bc5 | 2018-03-16 03:22:39 -0700 | [diff] [blame] | 1689 | /* update the unnumbered state of an interface*/ |
Stanislav Zaikin | 328b5da | 2021-07-15 16:27:29 +0200 | [diff] [blame] | 1690 | int |
Neale Ranns | 2ae2bc5 | 2018-03-16 03:22:39 -0700 | [diff] [blame] | 1691 | vnet_sw_interface_update_unnumbered (u32 unnumbered_sw_if_index, |
| 1692 | u32 ip_sw_if_index, u8 enable) |
| 1693 | { |
| 1694 | vnet_main_t *vnm = vnet_get_main (); |
| 1695 | vnet_sw_interface_t *si; |
| 1696 | u32 was_unnum; |
Stanislav Zaikin | 328b5da | 2021-07-15 16:27:29 +0200 | [diff] [blame] | 1697 | int rv = 0; |
Neale Ranns | 2ae2bc5 | 2018-03-16 03:22:39 -0700 | [diff] [blame] | 1698 | |
| 1699 | si = vnet_get_sw_interface (vnm, unnumbered_sw_if_index); |
| 1700 | was_unnum = (si->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED); |
| 1701 | |
| 1702 | if (enable) |
| 1703 | { |
Stanislav Zaikin | 328b5da | 2021-07-15 16:27:29 +0200 | [diff] [blame] | 1704 | rv = vnet_sw_interface_check_table_same (unnumbered_sw_if_index, |
| 1705 | ip_sw_if_index); |
| 1706 | if (rv != 0) |
| 1707 | return rv; |
Neale Ranns | 2ae2bc5 | 2018-03-16 03:22:39 -0700 | [diff] [blame] | 1708 | si->flags |= VNET_SW_INTERFACE_FLAG_UNNUMBERED; |
| 1709 | si->unnumbered_sw_if_index = ip_sw_if_index; |
| 1710 | |
| 1711 | ip4_main.lookup_main.if_address_pool_index_by_sw_if_index |
| 1712 | [unnumbered_sw_if_index] = |
| 1713 | ip4_main. |
| 1714 | lookup_main.if_address_pool_index_by_sw_if_index[ip_sw_if_index]; |
| 1715 | ip6_main. |
| 1716 | lookup_main.if_address_pool_index_by_sw_if_index |
| 1717 | [unnumbered_sw_if_index] = |
| 1718 | ip6_main. |
| 1719 | lookup_main.if_address_pool_index_by_sw_if_index[ip_sw_if_index]; |
| 1720 | } |
| 1721 | else |
| 1722 | { |
Dave Barach | 64d20e7 | 2021-05-29 09:00:45 -0400 | [diff] [blame] | 1723 | /* |
| 1724 | * Unless the interface is actually unnumbered, don't |
| 1725 | * smash e.g. if_address_pool_index_by_sw_if_index |
| 1726 | */ |
| 1727 | if (si->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED) |
| 1728 | { |
| 1729 | si->flags &= ~(VNET_SW_INTERFACE_FLAG_UNNUMBERED); |
| 1730 | si->unnumbered_sw_if_index = (u32) ~0; |
Neale Ranns | 2ae2bc5 | 2018-03-16 03:22:39 -0700 | [diff] [blame] | 1731 | |
Dave Barach | 64d20e7 | 2021-05-29 09:00:45 -0400 | [diff] [blame] | 1732 | ip4_main.lookup_main |
| 1733 | .if_address_pool_index_by_sw_if_index[unnumbered_sw_if_index] = ~0; |
| 1734 | ip6_main.lookup_main |
| 1735 | .if_address_pool_index_by_sw_if_index[unnumbered_sw_if_index] = ~0; |
| 1736 | } |
Neale Ranns | 2ae2bc5 | 2018-03-16 03:22:39 -0700 | [diff] [blame] | 1737 | } |
| 1738 | |
| 1739 | if (was_unnum != (si->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED)) |
| 1740 | { |
| 1741 | ip4_sw_interface_enable_disable (unnumbered_sw_if_index, enable); |
| 1742 | ip6_sw_interface_enable_disable (unnumbered_sw_if_index, enable); |
| 1743 | } |
Stanislav Zaikin | 328b5da | 2021-07-15 16:27:29 +0200 | [diff] [blame] | 1744 | |
| 1745 | return 0; |
Neale Ranns | 2ae2bc5 | 2018-03-16 03:22:39 -0700 | [diff] [blame] | 1746 | } |
| 1747 | |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 1748 | vnet_l3_packet_type_t |
| 1749 | vnet_link_to_l3_proto (vnet_link_t link) |
| 1750 | { |
| 1751 | switch (link) |
| 1752 | { |
| 1753 | case VNET_LINK_IP4: |
| 1754 | return (VNET_L3_PACKET_TYPE_IP4); |
| 1755 | case VNET_LINK_IP6: |
| 1756 | return (VNET_L3_PACKET_TYPE_IP6); |
| 1757 | case VNET_LINK_MPLS: |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 1758 | return (VNET_L3_PACKET_TYPE_MPLS); |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 1759 | case VNET_LINK_ARP: |
| 1760 | return (VNET_L3_PACKET_TYPE_ARP); |
| 1761 | case VNET_LINK_ETHERNET: |
Florin Coras | ce1b4c7 | 2017-01-26 14:25:34 -0800 | [diff] [blame] | 1762 | case VNET_LINK_NSH: |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 1763 | ASSERT (0); |
| 1764 | break; |
| 1765 | } |
| 1766 | ASSERT (0); |
| 1767 | return (0); |
| 1768 | } |
| 1769 | |
Ole Troan | d723161 | 2018-06-07 10:17:57 +0200 | [diff] [blame] | 1770 | vnet_mtu_t |
| 1771 | vnet_link_to_mtu (vnet_link_t link) |
| 1772 | { |
| 1773 | switch (link) |
| 1774 | { |
| 1775 | case VNET_LINK_IP4: |
| 1776 | return (VNET_MTU_IP4); |
| 1777 | case VNET_LINK_IP6: |
| 1778 | return (VNET_MTU_IP6); |
| 1779 | case VNET_LINK_MPLS: |
| 1780 | return (VNET_MTU_MPLS); |
| 1781 | default: |
| 1782 | return (VNET_MTU_L3); |
| 1783 | } |
| 1784 | } |
| 1785 | |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 1786 | u8 * |
| 1787 | default_build_rewrite (vnet_main_t * vnm, |
| 1788 | u32 sw_if_index, |
| 1789 | vnet_link_t link_type, const void *dst_address) |
| 1790 | { |
| 1791 | return (NULL); |
| 1792 | } |
| 1793 | |
| 1794 | void |
| 1795 | default_update_adjacency (vnet_main_t * vnm, u32 sw_if_index, u32 ai) |
| 1796 | { |
Neale Ranns | 0117d24 | 2017-08-12 12:52:54 -0700 | [diff] [blame] | 1797 | ip_adjacency_t *adj; |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 1798 | |
Neale Ranns | 0117d24 | 2017-08-12 12:52:54 -0700 | [diff] [blame] | 1799 | adj = adj_get (ai); |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 1800 | |
Neale Ranns | 0117d24 | 2017-08-12 12:52:54 -0700 | [diff] [blame] | 1801 | switch (adj->lookup_next_index) |
| 1802 | { |
Ole Trøan | 438f630 | 2018-02-15 21:56:06 +0000 | [diff] [blame] | 1803 | case IP_LOOKUP_NEXT_GLEAN: |
Neale Ranns | c819fc6 | 2018-02-16 02:44:05 -0800 | [diff] [blame] | 1804 | adj_glean_update_rewrite (ai); |
| 1805 | break; |
| 1806 | case IP_LOOKUP_NEXT_ARP: |
Neale Ranns | 1855b8e | 2018-07-11 10:31:26 -0700 | [diff] [blame] | 1807 | case IP_LOOKUP_NEXT_BCAST: |
Neale Ranns | 0117d24 | 2017-08-12 12:52:54 -0700 | [diff] [blame] | 1808 | /* |
Paul Vinciguerra | bdc0e6b | 2018-09-22 05:32:50 -0700 | [diff] [blame] | 1809 | * default rewrite in neighbour adj |
Neale Ranns | 0117d24 | 2017-08-12 12:52:54 -0700 | [diff] [blame] | 1810 | */ |
| 1811 | adj_nbr_update_rewrite |
| 1812 | (ai, |
| 1813 | ADJ_NBR_REWRITE_FLAG_COMPLETE, |
| 1814 | vnet_build_rewrite_for_sw_interface (vnm, |
| 1815 | sw_if_index, |
| 1816 | adj_get_link_type (ai), NULL)); |
| 1817 | break; |
| 1818 | case IP_LOOKUP_NEXT_MCAST: |
| 1819 | /* |
| 1820 | * mcast traffic also uses default rewrite string with no mcast |
| 1821 | * switch time updates. |
| 1822 | */ |
| 1823 | adj_mcast_update_rewrite |
| 1824 | (ai, |
| 1825 | vnet_build_rewrite_for_sw_interface (vnm, |
| 1826 | sw_if_index, |
| 1827 | adj_get_link_type (ai), |
Neale Ranns | 889fe94 | 2017-06-01 05:43:19 -0400 | [diff] [blame] | 1828 | NULL), 0); |
Neale Ranns | 0117d24 | 2017-08-12 12:52:54 -0700 | [diff] [blame] | 1829 | break; |
| 1830 | case IP_LOOKUP_NEXT_DROP: |
| 1831 | case IP_LOOKUP_NEXT_PUNT: |
| 1832 | case IP_LOOKUP_NEXT_LOCAL: |
| 1833 | case IP_LOOKUP_NEXT_REWRITE: |
| 1834 | case IP_LOOKUP_NEXT_MCAST_MIDCHAIN: |
| 1835 | case IP_LOOKUP_NEXT_MIDCHAIN: |
| 1836 | case IP_LOOKUP_NEXT_ICMP_ERROR: |
| 1837 | case IP_LOOKUP_N_NEXT: |
| 1838 | ASSERT (0); |
| 1839 | break; |
| 1840 | } |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 1841 | } |
| 1842 | |
Chenmin Sun | c466509 | 2020-07-06 08:20:39 +0800 | [diff] [blame] | 1843 | clib_error_t * |
| 1844 | vnet_hw_interface_set_rss_queues (vnet_main_t * vnm, |
| 1845 | vnet_hw_interface_t * hi, |
| 1846 | clib_bitmap_t * bitmap) |
| 1847 | { |
| 1848 | clib_error_t *error = 0; |
| 1849 | vnet_device_class_t *dev_class = |
| 1850 | vnet_get_device_class (vnm, hi->dev_class_index); |
| 1851 | |
| 1852 | if (dev_class->set_rss_queues_function) |
| 1853 | { |
| 1854 | if (clib_bitmap_count_set_bits (bitmap) == 0) |
| 1855 | { |
| 1856 | error = clib_error_return (0, |
| 1857 | "must assign at least one valid rss queue"); |
| 1858 | goto done; |
| 1859 | } |
| 1860 | |
| 1861 | error = dev_class->set_rss_queues_function (vnm, hi, bitmap); |
| 1862 | } |
| 1863 | else |
| 1864 | { |
| 1865 | error = clib_error_return (0, |
| 1866 | "setting rss queues is not supported on this interface"); |
| 1867 | } |
| 1868 | |
| 1869 | if (!error) |
| 1870 | { |
| 1871 | clib_bitmap_free (hi->rss_queues); |
| 1872 | hi->rss_queues = clib_bitmap_dup (bitmap); |
| 1873 | } |
| 1874 | |
| 1875 | done: |
Damjan Marion | d1bd5d2 | 2020-11-23 16:58:05 +0100 | [diff] [blame] | 1876 | if (error) |
| 1877 | log_err ("hw_set_rss_queues: %U", format_clib_error, error); |
Chenmin Sun | c466509 | 2020-07-06 08:20:39 +0800 | [diff] [blame] | 1878 | return error; |
| 1879 | } |
| 1880 | |
Neale Ranns | 6f4a6be | 2018-03-16 16:26:21 -0700 | [diff] [blame] | 1881 | int collect_detailed_interface_stats_flag = 0; |
| 1882 | |
| 1883 | void |
Neale Ranns | f704f38 | 2018-03-19 12:24:07 -0400 | [diff] [blame] | 1884 | collect_detailed_interface_stats_flag_set (void) |
Neale Ranns | 6f4a6be | 2018-03-16 16:26:21 -0700 | [diff] [blame] | 1885 | { |
| 1886 | collect_detailed_interface_stats_flag = 1; |
| 1887 | } |
| 1888 | |
| 1889 | void |
Neale Ranns | f704f38 | 2018-03-19 12:24:07 -0400 | [diff] [blame] | 1890 | collect_detailed_interface_stats_flag_clear (void) |
Neale Ranns | 6f4a6be | 2018-03-16 16:26:21 -0700 | [diff] [blame] | 1891 | { |
| 1892 | collect_detailed_interface_stats_flag = 0; |
| 1893 | } |
| 1894 | |
| 1895 | static clib_error_t * |
| 1896 | collect_detailed_interface_stats_cli (vlib_main_t * vm, |
| 1897 | unformat_input_t * input, |
| 1898 | vlib_cli_command_t * cmd) |
| 1899 | { |
| 1900 | unformat_input_t _line_input, *line_input = &_line_input; |
| 1901 | clib_error_t *error = NULL; |
| 1902 | |
| 1903 | /* Get a line of input. */ |
| 1904 | if (!unformat_user (input, unformat_line_input, line_input)) |
| 1905 | return clib_error_return (0, "expected enable | disable"); |
| 1906 | |
| 1907 | while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) |
| 1908 | { |
| 1909 | if (unformat (line_input, "enable") || unformat (line_input, "on")) |
| 1910 | collect_detailed_interface_stats_flag_set (); |
| 1911 | else if (unformat (line_input, "disable") |
| 1912 | || unformat (line_input, "off")) |
| 1913 | collect_detailed_interface_stats_flag_clear (); |
| 1914 | else |
| 1915 | { |
| 1916 | error = clib_error_return (0, "unknown input `%U'", |
| 1917 | format_unformat_error, line_input); |
| 1918 | goto done; |
| 1919 | } |
| 1920 | } |
| 1921 | |
| 1922 | done: |
| 1923 | unformat_free (line_input); |
| 1924 | return error; |
| 1925 | } |
| 1926 | |
| 1927 | /* *INDENT-OFF* */ |
| 1928 | VLIB_CLI_COMMAND (collect_detailed_interface_stats_command, static) = { |
| 1929 | .path = "interface collect detailed-stats", |
| 1930 | .short_help = "interface collect detailed-stats <enable|disable>", |
| 1931 | .function = collect_detailed_interface_stats_cli, |
| 1932 | }; |
| 1933 | /* *INDENT-ON* */ |
| 1934 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 1935 | /* |
| 1936 | * fd.io coding-style-patch-verification: ON |
| 1937 | * |
| 1938 | * Local Variables: |
| 1939 | * eval: (c-set-style "gnu") |
| 1940 | * End: |
| 1941 | */ |