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_funcs.h: VNET interfaces/sub-interfaces exported functions |
| 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 | #ifndef included_vnet_interface_funcs_h |
| 41 | #define included_vnet_interface_funcs_h |
| 42 | |
| 43 | always_inline vnet_hw_interface_t * |
| 44 | vnet_get_hw_interface (vnet_main_t * vnm, u32 hw_if_index) |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 45 | { |
| 46 | return pool_elt_at_index (vnm->interface_main.hw_interfaces, hw_if_index); |
| 47 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 48 | |
Damjan Marion | a35cc14 | 2018-03-16 01:25:27 +0100 | [diff] [blame] | 49 | always_inline vnet_hw_interface_t * |
Dave Barach | 3940de3 | 2019-07-23 16:28:36 -0400 | [diff] [blame] | 50 | vnet_get_hw_interface_or_null (vnet_main_t * vnm, u32 hw_if_index) |
Damjan Marion | a35cc14 | 2018-03-16 01:25:27 +0100 | [diff] [blame] | 51 | { |
| 52 | if (!pool_is_free_index (vnm->interface_main.hw_interfaces, hw_if_index)) |
| 53 | return pool_elt_at_index (vnm->interface_main.hw_interfaces, hw_if_index); |
| 54 | return (NULL); |
| 55 | } |
| 56 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 57 | always_inline vnet_sw_interface_t * |
| 58 | vnet_get_sw_interface (vnet_main_t * vnm, u32 sw_if_index) |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 59 | { |
| 60 | return pool_elt_at_index (vnm->interface_main.sw_interfaces, sw_if_index); |
| 61 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 62 | |
| 63 | always_inline vnet_sw_interface_t * |
Dave Barach | 3940de3 | 2019-07-23 16:28:36 -0400 | [diff] [blame] | 64 | vnet_get_sw_interface_or_null (vnet_main_t * vnm, u32 sw_if_index) |
Neale Ranns | 7515228 | 2017-01-09 01:00:45 -0800 | [diff] [blame] | 65 | { |
| 66 | if (!pool_is_free_index (vnm->interface_main.sw_interfaces, sw_if_index)) |
| 67 | return pool_elt_at_index (vnm->interface_main.sw_interfaces, sw_if_index); |
| 68 | return (NULL); |
| 69 | } |
| 70 | |
| 71 | always_inline vnet_sw_interface_t * |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 72 | vnet_get_hw_sw_interface (vnet_main_t * vnm, u32 hw_if_index) |
| 73 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 74 | vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index); |
| 75 | vnet_sw_interface_t *sw = vnet_get_sw_interface (vnm, hw->sw_if_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 76 | ASSERT (sw->type == VNET_SW_INTERFACE_TYPE_HARDWARE); |
| 77 | return sw; |
| 78 | } |
| 79 | |
| 80 | always_inline vnet_sw_interface_t * |
| 81 | vnet_get_sup_sw_interface (vnet_main_t * vnm, u32 sw_if_index) |
| 82 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 83 | vnet_sw_interface_t *sw = vnet_get_sw_interface (vnm, sw_if_index); |
Pavel Kotucek | 15ac81c | 2017-06-20 14:00:26 +0200 | [diff] [blame] | 84 | if (sw->type == VNET_SW_INTERFACE_TYPE_SUB || |
Neale Ranns | 17ff3c1 | 2018-07-04 10:24:24 -0700 | [diff] [blame] | 85 | sw->type == VNET_SW_INTERFACE_TYPE_PIPE || |
Pavel Kotucek | 15ac81c | 2017-06-20 14:00:26 +0200 | [diff] [blame] | 86 | sw->type == VNET_SW_INTERFACE_TYPE_P2P) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 87 | sw = vnet_get_sw_interface (vnm, sw->sup_sw_if_index); |
| 88 | return sw; |
| 89 | } |
| 90 | |
| 91 | always_inline vnet_hw_interface_t * |
| 92 | vnet_get_sup_hw_interface (vnet_main_t * vnm, u32 sw_if_index) |
| 93 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 94 | vnet_sw_interface_t *sw = vnet_get_sup_sw_interface (vnm, sw_if_index); |
Neale Ranns | 17ff3c1 | 2018-07-04 10:24:24 -0700 | [diff] [blame] | 95 | ASSERT ((sw->type == VNET_SW_INTERFACE_TYPE_HARDWARE) || |
| 96 | (sw->type == VNET_SW_INTERFACE_TYPE_PIPE)); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 97 | return vnet_get_hw_interface (vnm, sw->hw_if_index); |
| 98 | } |
| 99 | |
Dave Barach | 3940de3 | 2019-07-23 16:28:36 -0400 | [diff] [blame] | 100 | always_inline vnet_hw_interface_t * |
| 101 | vnet_get_sup_hw_interface_api_visible_or_null (vnet_main_t * vnm, |
| 102 | u32 sw_if_index) |
| 103 | { |
| 104 | vnet_sw_interface_t *si; |
| 105 | if (PREDICT_FALSE (pool_is_free_index (vnm->interface_main.sw_interfaces, |
| 106 | sw_if_index))) |
| 107 | return NULL; |
| 108 | si = vnet_get_sup_sw_interface (vnm, sw_if_index); |
| 109 | if (PREDICT_FALSE (si->flags & VNET_SW_INTERFACE_FLAG_HIDDEN)) |
| 110 | return NULL; |
| 111 | ASSERT ((si->type == VNET_SW_INTERFACE_TYPE_HARDWARE) || |
| 112 | (si->type == VNET_SW_INTERFACE_TYPE_PIPE)); |
| 113 | return vnet_get_hw_interface (vnm, si->hw_if_index); |
| 114 | } |
| 115 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 116 | always_inline vnet_hw_interface_class_t * |
| 117 | vnet_get_hw_interface_class (vnet_main_t * vnm, u32 hw_class_index) |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 118 | { |
| 119 | return vec_elt_at_index (vnm->interface_main.hw_interface_classes, |
| 120 | hw_class_index); |
| 121 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 122 | |
| 123 | always_inline vnet_device_class_t * |
| 124 | vnet_get_device_class (vnet_main_t * vnm, u32 dev_class_index) |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 125 | { |
| 126 | return vec_elt_at_index (vnm->interface_main.device_classes, |
| 127 | dev_class_index); |
| 128 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 129 | |
Dave Barach | 7be864a | 2016-11-28 11:41:35 -0500 | [diff] [blame] | 130 | static inline u8 * |
| 131 | vnet_get_sw_interface_tag (vnet_main_t * vnm, u32 sw_if_index) |
| 132 | { |
| 133 | uword *p; |
| 134 | p = hash_get (vnm->interface_tag_by_sw_if_index, sw_if_index); |
| 135 | if (p) |
| 136 | return ((u8 *) p[0]); |
| 137 | return 0; |
| 138 | } |
| 139 | |
| 140 | static inline void |
| 141 | vnet_set_sw_interface_tag (vnet_main_t * vnm, u8 * tag, u32 sw_if_index) |
| 142 | { |
| 143 | uword *p; |
| 144 | p = hash_get (vnm->interface_tag_by_sw_if_index, sw_if_index); |
| 145 | if (p) |
| 146 | { |
| 147 | u8 *oldtag = (u8 *) p[0]; |
| 148 | hash_unset (vnm->interface_tag_by_sw_if_index, sw_if_index); |
| 149 | vec_free (oldtag); |
| 150 | } |
| 151 | |
| 152 | hash_set (vnm->interface_tag_by_sw_if_index, sw_if_index, tag); |
| 153 | } |
| 154 | |
| 155 | static inline void |
| 156 | vnet_clear_sw_interface_tag (vnet_main_t * vnm, u32 sw_if_index) |
| 157 | { |
| 158 | uword *p; |
| 159 | p = hash_get (vnm->interface_tag_by_sw_if_index, sw_if_index); |
| 160 | if (p) |
| 161 | { |
| 162 | u8 *oldtag = (u8 *) p[0]; |
| 163 | hash_unset (vnm->interface_tag_by_sw_if_index, sw_if_index); |
| 164 | vec_free (oldtag); |
| 165 | } |
| 166 | } |
| 167 | |
Neale Ranns | 8b37b87 | 2016-11-21 12:25:22 +0000 | [diff] [blame] | 168 | /** |
Neale Ranns | 0053de6 | 2018-05-22 08:40:52 -0700 | [diff] [blame] | 169 | * Walk return code |
| 170 | */ |
| 171 | typedef enum walk_rc_t_ |
| 172 | { |
| 173 | WALK_STOP, |
| 174 | WALK_CONTINUE, |
| 175 | } walk_rc_t; |
| 176 | |
| 177 | /** |
Neale Ranns | 8b37b87 | 2016-11-21 12:25:22 +0000 | [diff] [blame] | 178 | * Call back walk type for walking SW indices on a HW interface |
| 179 | */ |
Neale Ranns | 0053de6 | 2018-05-22 08:40:52 -0700 | [diff] [blame] | 180 | typedef walk_rc_t (*vnet_hw_sw_interface_walk_t) (vnet_main_t * vnm, |
| 181 | u32 sw_if_index, void *ctx); |
Neale Ranns | 8b37b87 | 2016-11-21 12:25:22 +0000 | [diff] [blame] | 182 | |
| 183 | /** |
| 184 | * @brief |
| 185 | * Walk the SW interfaces on a HW interface - this is the super |
| 186 | * interface and any sub-interfaces. |
| 187 | */ |
| 188 | void vnet_hw_interface_walk_sw (vnet_main_t * vnm, |
| 189 | u32 hw_if_index, |
| 190 | vnet_hw_sw_interface_walk_t fn, void *ctx); |
| 191 | |
Neale Ranns | 0053de6 | 2018-05-22 08:40:52 -0700 | [diff] [blame] | 192 | /** |
| 193 | * Call back walk type for walking SW indices on a HW interface |
| 194 | */ |
| 195 | typedef walk_rc_t (*vnet_sw_interface_walk_t) (vnet_main_t * vnm, |
| 196 | vnet_sw_interface_t * si, |
| 197 | void *ctx); |
| 198 | |
| 199 | /** |
| 200 | * @brief |
| 201 | * Walk all the SW interfaces in the system. |
| 202 | */ |
| 203 | void vnet_sw_interface_walk (vnet_main_t * vnm, |
| 204 | vnet_sw_interface_walk_t fn, void *ctx); |
| 205 | |
Neale Ranns | 17ff3c1 | 2018-07-04 10:24:24 -0700 | [diff] [blame] | 206 | |
| 207 | /** |
| 208 | * Call back walk type for walking all HW indices |
| 209 | */ |
| 210 | typedef walk_rc_t (*vnet_hw_interface_walk_t) (vnet_main_t * vnm, |
| 211 | u32 hw_if_index, void *ctx); |
| 212 | |
| 213 | /** |
| 214 | * @brief |
| 215 | * Walk all the HW interface |
| 216 | */ |
| 217 | void vnet_hw_interface_walk (vnet_main_t * vnm, |
| 218 | vnet_hw_interface_walk_t fn, void *ctx); |
| 219 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 220 | /* Register a hardware interface instance. */ |
| 221 | u32 vnet_register_interface (vnet_main_t * vnm, |
| 222 | u32 dev_class_index, |
| 223 | u32 dev_instance, |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 224 | u32 hw_class_index, u32 hw_instance); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 225 | |
John Lo | e5453d0 | 2018-01-23 19:21:34 -0500 | [diff] [blame] | 226 | /** |
| 227 | * Set interface output node - for interface registered without its output/tx |
| 228 | * nodes created because its VNET_DEVICE_CLASS did not specify any tx_function. |
| 229 | * This is typically the case for tunnel interfaces. |
| 230 | */ |
| 231 | void vnet_set_interface_output_node (vnet_main_t * vnm, |
| 232 | u32 hw_if_index, u32 node_index); |
| 233 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 234 | /* Creates a software interface given template. */ |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 235 | clib_error_t *vnet_create_sw_interface (vnet_main_t * vnm, |
| 236 | vnet_sw_interface_t * template, |
| 237 | u32 * sw_if_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 238 | |
| 239 | void vnet_delete_hw_interface (vnet_main_t * vnm, u32 hw_if_index); |
| 240 | void vnet_delete_sw_interface (vnet_main_t * vnm, u32 sw_if_index); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 241 | int vnet_sw_interface_is_p2p (vnet_main_t * vnm, u32 sw_if_index); |
Neale Ranns | 5f8f617 | 2019-04-18 10:23:56 +0000 | [diff] [blame] | 242 | int vnet_sw_interface_is_nbma (vnet_main_t * vnm, u32 sw_if_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 243 | |
Neale Ranns | 1855b8e | 2018-07-11 10:31:26 -0700 | [diff] [blame] | 244 | always_inline vnet_sw_interface_flags_t |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 245 | vnet_sw_interface_get_flags (vnet_main_t * vnm, u32 sw_if_index) |
| 246 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 247 | vnet_sw_interface_t *sw = vnet_get_sw_interface (vnm, sw_if_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 248 | return sw->flags; |
| 249 | } |
| 250 | |
| 251 | always_inline uword |
Damjan Marion | a35cc14 | 2018-03-16 01:25:27 +0100 | [diff] [blame] | 252 | vnet_sw_interface_is_valid (vnet_main_t * vnm, u32 sw_if_index) |
| 253 | { |
| 254 | return !pool_is_free_index (vnm->interface_main.sw_interfaces, sw_if_index); |
| 255 | } |
| 256 | |
| 257 | always_inline uword |
| 258 | vnet_hw_interface_is_valid (vnet_main_t * vnm, u32 hw_if_index) |
| 259 | { |
| 260 | return !pool_is_free_index (vnm->interface_main.hw_interfaces, hw_if_index); |
| 261 | } |
| 262 | |
| 263 | |
| 264 | always_inline uword |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 265 | vnet_sw_interface_is_admin_up (vnet_main_t * vnm, u32 sw_if_index) |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 266 | { |
| 267 | return (vnet_sw_interface_get_flags (vnm, sw_if_index) & |
| 268 | VNET_SW_INTERFACE_FLAG_ADMIN_UP) != 0; |
| 269 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 270 | |
| 271 | always_inline uword |
Eyal Bari | 3212c57 | 2017-03-06 11:47:50 +0200 | [diff] [blame] | 272 | vnet_swif_is_api_visible (vnet_sw_interface_t * si) |
| 273 | { |
| 274 | return !(si->flags & VNET_SW_INTERFACE_FLAG_HIDDEN); |
| 275 | } |
| 276 | |
| 277 | always_inline uword |
| 278 | vnet_sw_interface_is_api_visible (vnet_main_t * vnm, u32 sw_if_index) |
| 279 | { |
| 280 | vnet_sw_interface_t *si = vnet_get_sw_interface (vnm, sw_if_index); |
| 281 | return vnet_swif_is_api_visible (si); |
| 282 | } |
| 283 | |
| 284 | always_inline uword |
| 285 | vnet_sw_interface_is_api_valid (vnet_main_t * vnm, u32 sw_if_index) |
| 286 | { |
| 287 | return !pool_is_free_index (vnm->interface_main.sw_interfaces, sw_if_index) |
| 288 | && vnet_sw_interface_is_api_visible (vnm, sw_if_index); |
| 289 | } |
| 290 | |
Neale Ranns | 93cc3ee | 2018-10-10 07:22:51 -0700 | [diff] [blame] | 291 | always_inline const u8 * |
| 292 | vnet_sw_interface_get_hw_address (vnet_main_t * vnm, u32 sw_if_index) |
| 293 | { |
| 294 | vnet_hw_interface_t *hw = vnet_get_sup_hw_interface (vnm, sw_if_index); |
| 295 | return hw->hw_address; |
| 296 | } |
| 297 | |
Eyal Bari | 3212c57 | 2017-03-06 11:47:50 +0200 | [diff] [blame] | 298 | always_inline uword |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 299 | vnet_hw_interface_get_flags (vnet_main_t * vnm, u32 hw_if_index) |
| 300 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 301 | vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 302 | return hw->flags; |
| 303 | } |
| 304 | |
Ole Troan | d723161 | 2018-06-07 10:17:57 +0200 | [diff] [blame] | 305 | always_inline u32 |
| 306 | vnet_hw_interface_get_mtu (vnet_main_t * vnm, u32 hw_if_index) |
Damjan Marion | fe7d4a2 | 2018-04-13 19:43:39 +0200 | [diff] [blame] | 307 | { |
| 308 | vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index); |
Ole Troan | d723161 | 2018-06-07 10:17:57 +0200 | [diff] [blame] | 309 | return hw->max_packet_bytes; |
Damjan Marion | fe7d4a2 | 2018-04-13 19:43:39 +0200 | [diff] [blame] | 310 | } |
| 311 | |
Ole Troan | d723161 | 2018-06-07 10:17:57 +0200 | [diff] [blame] | 312 | always_inline u32 |
| 313 | vnet_sw_interface_get_mtu (vnet_main_t * vnm, u32 sw_if_index, vnet_mtu_t af) |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 314 | { |
Ole Troan | d723161 | 2018-06-07 10:17:57 +0200 | [diff] [blame] | 315 | vnet_sw_interface_t *sw = vnet_get_sw_interface (vnm, sw_if_index); |
| 316 | u32 mtu; |
| 317 | mtu = sw->mtu[af] > 0 ? sw->mtu[af] : sw->mtu[VNET_MTU_L3]; |
| 318 | if (mtu == 0) |
| 319 | return 9000; /* $$$ Deal with interface-types not setting MTU */ |
| 320 | return mtu; |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 321 | } |
| 322 | |
| 323 | always_inline uword |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 324 | vnet_hw_interface_is_link_up (vnet_main_t * vnm, u32 hw_if_index) |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 325 | { |
Neale Ranns | 3e2e190 | 2019-03-14 09:21:02 -0700 | [diff] [blame] | 326 | return ((vnet_hw_interface_get_flags (vnm, hw_if_index) & |
| 327 | VNET_HW_INTERFACE_FLAG_LINK_UP) != 0); |
| 328 | } |
| 329 | |
| 330 | always_inline uword |
| 331 | vnet_sw_interface_is_link_up (vnet_main_t * vnm, u32 sw_if_index) |
| 332 | { |
| 333 | vnet_sw_interface_t *sw = vnet_get_sup_sw_interface (vnm, sw_if_index); |
| 334 | |
| 335 | return (vnet_hw_interface_is_link_up (vnm, sw->hw_if_index)); |
| 336 | } |
| 337 | |
| 338 | always_inline uword |
| 339 | vnet_sw_interface_is_up (vnet_main_t * vnm, u32 sw_if_index) |
| 340 | { |
| 341 | return (vnet_sw_interface_is_admin_up (vnm, sw_if_index) && |
| 342 | vnet_sw_interface_is_link_up (vnm, sw_if_index)); |
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 | |
Neale Ranns | 44db1ca | 2020-12-24 09:16:09 +0000 | [diff] [blame] | 345 | always_inline uword |
| 346 | vnet_sw_interface_is_sub (vnet_main_t *vnm, u32 sw_if_index) |
| 347 | { |
| 348 | vnet_sw_interface_t *sw = vnet_get_sw_interface (vnm, sw_if_index); |
| 349 | |
| 350 | return (sw->sw_if_index != sw->sup_sw_if_index); |
| 351 | } |
| 352 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 353 | always_inline vlib_frame_t * |
| 354 | vnet_get_frame_to_sw_interface (vnet_main_t * vnm, u32 sw_if_index) |
| 355 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 356 | vnet_hw_interface_t *hw = vnet_get_sup_hw_interface (vnm, sw_if_index); |
Steven | ac0932d | 2018-02-27 14:43:40 -0800 | [diff] [blame] | 357 | return vlib_get_frame_to_node (vlib_get_main (), hw->output_node_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 358 | } |
| 359 | |
| 360 | always_inline void |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 361 | vnet_put_frame_to_sw_interface (vnet_main_t * vnm, u32 sw_if_index, |
| 362 | vlib_frame_t * f) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 363 | { |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 364 | vnet_hw_interface_t *hw = vnet_get_sup_hw_interface (vnm, sw_if_index); |
Steven | ac0932d | 2018-02-27 14:43:40 -0800 | [diff] [blame] | 365 | return vlib_put_frame_to_node (vlib_get_main (), hw->output_node_index, f); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 366 | } |
| 367 | |
Damjan Marion | 5100aa9 | 2018-11-08 15:30:16 +0100 | [diff] [blame] | 368 | always_inline void |
| 369 | vnet_hw_interface_set_link_speed (vnet_main_t * vnm, u32 hw_if_index, |
| 370 | u32 link_speed) |
| 371 | { |
| 372 | vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index); |
| 373 | hw->link_speed = link_speed; |
| 374 | } |
| 375 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 376 | /* Change interface flags (e.g. up, down, enable, disable). */ |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 377 | clib_error_t *vnet_hw_interface_set_flags (vnet_main_t * vnm, u32 hw_if_index, |
Neale Ranns | 6e43e06 | 2018-10-26 05:17:03 -0700 | [diff] [blame] | 378 | vnet_hw_interface_flags_t flags); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 379 | |
| 380 | /* Change interface flags (e.g. up, down, enable, disable). */ |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 381 | clib_error_t *vnet_sw_interface_set_flags (vnet_main_t * vnm, u32 sw_if_index, |
Neale Ranns | 6e43e06 | 2018-10-26 05:17:03 -0700 | [diff] [blame] | 382 | vnet_sw_interface_flags_t flags); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 383 | |
Neale Ranns | c87b66c | 2019-02-07 07:26:12 -0800 | [diff] [blame] | 384 | void vnet_sw_interface_admin_up (vnet_main_t * vnm, u32 sw_if_index); |
| 385 | void vnet_sw_interface_admin_down (vnet_main_t * vnm, u32 sw_if_index); |
| 386 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 387 | /* Change interface class. */ |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 388 | clib_error_t *vnet_hw_interface_set_class (vnet_main_t * vnm, u32 hw_if_index, |
| 389 | u32 new_hw_class_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 390 | |
| 391 | /* Redirect rx pkts to node */ |
| 392 | int vnet_hw_interface_rx_redirect_to_node (vnet_main_t * vnm, u32 hw_if_index, |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 393 | u32 node_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 394 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 395 | void vnet_hw_interface_init_for_class (vnet_main_t * vnm, u32 hw_if_index, |
| 396 | u32 hw_class_index, u32 hw_instance); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 397 | |
Sean Hope | 608d1ed | 2016-03-09 00:35:21 -0500 | [diff] [blame] | 398 | /* Rename interface */ |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 399 | clib_error_t *vnet_rename_interface (vnet_main_t * vnm, u32 hw_if_index, |
| 400 | char *new_name); |
Sean Hope | 608d1ed | 2016-03-09 00:35:21 -0500 | [diff] [blame] | 401 | |
Matthew Smith | e0792fd | 2019-07-12 11:48:24 -0500 | [diff] [blame] | 402 | /* Add/delete secondary interface mac address*/ |
| 403 | clib_error_t *vnet_hw_interface_add_del_mac_address (vnet_main_t * vnm, |
| 404 | u32 hw_if_index, |
| 405 | const u8 * mac_address, |
| 406 | u8 is_add); |
| 407 | |
Pavel Kotucek | c631f2d | 2016-09-26 10:40:02 +0200 | [diff] [blame] | 408 | /* Change interface mac address*/ |
| 409 | clib_error_t *vnet_hw_interface_change_mac_address (vnet_main_t * vnm, |
| 410 | u32 hw_if_index, |
Neale Ranns | 8f8994a | 2018-10-30 03:47:20 -0700 | [diff] [blame] | 411 | const u8 * mac_address); |
Pavel Kotucek | c631f2d | 2016-09-26 10:40:02 +0200 | [diff] [blame] | 412 | |
Steven | ad8015b | 2017-10-29 22:10:46 -0700 | [diff] [blame] | 413 | /* Change rx-mode */ |
| 414 | clib_error_t *set_hw_interface_change_rx_mode (vnet_main_t * vnm, |
| 415 | u32 hw_if_index, |
| 416 | u8 queue_id_valid, |
| 417 | u32 queue_id, |
Damjan Marion | eabd424 | 2020-10-07 20:59:07 +0200 | [diff] [blame] | 418 | vnet_hw_if_rx_mode mode); |
Steven | ad8015b | 2017-10-29 22:10:46 -0700 | [diff] [blame] | 419 | |
Mohsin Kazmi | 54f7c51 | 2018-08-23 18:28:11 +0200 | [diff] [blame] | 420 | /* Set rx-placement on the interface */ |
| 421 | clib_error_t *set_hw_interface_rx_placement (u32 hw_if_index, u32 queue_id, |
| 422 | u32 thread_index, u8 is_main); |
| 423 | |
Damjan Marion | fe7d4a2 | 2018-04-13 19:43:39 +0200 | [diff] [blame] | 424 | /* Set the MTU on the HW interface */ |
| 425 | void vnet_hw_interface_set_mtu (vnet_main_t * vnm, u32 hw_if_index, u32 mtu); |
Neale Ranns | ffd78d1 | 2018-02-09 06:05:16 -0800 | [diff] [blame] | 426 | |
Ole Troan | d723161 | 2018-06-07 10:17:57 +0200 | [diff] [blame] | 427 | /* Set the MTU on the SW interface */ |
| 428 | void vnet_sw_interface_set_mtu (vnet_main_t * vnm, u32 sw_if_index, u32 mtu); |
| 429 | void vnet_sw_interface_set_protocol_mtu (vnet_main_t * vnm, u32 sw_if_index, |
| 430 | u32 mtu[]); |
| 431 | |
Neale Ranns | 2ae2bc5 | 2018-03-16 03:22:39 -0700 | [diff] [blame] | 432 | /* update the unnumbered state of an interface */ |
| 433 | void vnet_sw_interface_update_unnumbered (u32 sw_if_index, |
| 434 | u32 ip_sw_if_index, u8 enable); |
| 435 | |
Neale Ranns | 871dc42 | 2018-03-29 01:28:09 -0700 | [diff] [blame] | 436 | int vnet_sw_interface_stats_collect_enable_disable (u32 sw_if_index, |
| 437 | u8 enable); |
Neale Ranns | 1855b8e | 2018-07-11 10:31:26 -0700 | [diff] [blame] | 438 | void vnet_sw_interface_ip_directed_broadcast (vnet_main_t * vnm, |
| 439 | u32 sw_if_index, u8 enable); |
Neale Ranns | 871dc42 | 2018-03-29 01:28:09 -0700 | [diff] [blame] | 440 | |
Chenmin Sun | c466509 | 2020-07-06 08:20:39 +0800 | [diff] [blame] | 441 | /* set interface rss queues */ |
| 442 | clib_error_t *vnet_hw_interface_set_rss_queues (vnet_main_t * vnm, |
| 443 | vnet_hw_interface_t * hi, |
| 444 | clib_bitmap_t * bitmap); |
| 445 | |
Damjan Marion | 1bd6cbb | 2021-04-15 13:12:51 +0200 | [diff] [blame] | 446 | void vnet_hw_if_update_runtime_data (vnet_main_t *vnm, u32 hw_if_index); |
| 447 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 448 | /* Formats sw/hw interface. */ |
| 449 | format_function_t format_vnet_hw_interface; |
Damjan Marion | eabd424 | 2020-10-07 20:59:07 +0200 | [diff] [blame] | 450 | format_function_t format_vnet_hw_if_rx_mode; |
Damjan Marion | a35cc14 | 2018-03-16 01:25:27 +0100 | [diff] [blame] | 451 | format_function_t format_vnet_hw_if_index_name; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 452 | format_function_t format_vnet_sw_interface; |
| 453 | format_function_t format_vnet_sw_interface_name; |
Sean Hope | 679ea79 | 2016-02-22 15:12:01 -0500 | [diff] [blame] | 454 | format_function_t format_vnet_sw_interface_name_override; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 455 | format_function_t format_vnet_sw_if_index_name; |
| 456 | format_function_t format_vnet_sw_interface_flags; |
| 457 | |
| 458 | /* Parses sw/hw interface name -> index. */ |
| 459 | unformat_function_t unformat_vnet_sw_interface; |
| 460 | unformat_function_t unformat_vnet_hw_interface; |
Dave Barach | 08eb2bb | 2020-04-15 09:34:43 -0400 | [diff] [blame] | 461 | unformat_function_t unformat_vnet_buffer_flags; |
Mohsin Kazmi | 6809538 | 2021-02-10 11:26:24 +0100 | [diff] [blame] | 462 | unformat_function_t unformat_vnet_buffer_offload_flags; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 463 | |
| 464 | /* Parses interface flags (up, down, enable, disable, etc.) */ |
| 465 | unformat_function_t unformat_vnet_hw_interface_flags; |
| 466 | unformat_function_t unformat_vnet_sw_interface_flags; |
| 467 | |
Jon Loeliger | 9485d99 | 2019-11-08 15:05:23 -0600 | [diff] [blame] | 468 | /* VLAN tag-rewrite */ |
| 469 | format_function_t format_vtr; |
| 470 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 471 | /* Node runtime for interface output function. */ |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 472 | typedef struct |
| 473 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 474 | u32 hw_if_index; |
| 475 | u32 sw_if_index; |
| 476 | u32 dev_instance; |
| 477 | u32 is_deleted; |
| 478 | } vnet_interface_output_runtime_t; |
| 479 | |
Damjan Marion | 10ae766 | 2017-06-30 19:53:03 +0200 | [diff] [blame] | 480 | /* Interface output function. */ |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 481 | word vnet_sw_interface_compare (vnet_main_t * vnm, uword sw_if_index0, |
| 482 | uword sw_if_index1); |
| 483 | word vnet_hw_interface_compare (vnet_main_t * vnm, uword hw_if_index0, |
| 484 | uword hw_if_index1); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 485 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 486 | typedef enum |
| 487 | { |
Damjan Marion | 9c6ae5f | 2016-11-15 23:20:01 +0100 | [diff] [blame] | 488 | VNET_INTERFACE_OUTPUT_NEXT_DROP, |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 489 | VNET_INTERFACE_OUTPUT_NEXT_TX, |
| 490 | } vnet_interface_output_next_t; |
| 491 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 492 | typedef enum |
| 493 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 494 | VNET_INTERFACE_TX_NEXT_DROP, |
| 495 | VNET_INTERFACE_TX_N_NEXT, |
| 496 | } vnet_interface_tx_next_t; |
| 497 | |
John Lo | 405e41b | 2016-04-23 15:14:12 -0400 | [diff] [blame] | 498 | #define VNET_SIMULATED_ETHERNET_TX_NEXT_ETHERNET_INPUT VNET_INTERFACE_TX_N_NEXT |
Dave Barach | 635ec3b | 2018-07-13 20:12:45 -0400 | [diff] [blame] | 499 | #define VNET_SIMULATED_ETHERNET_TX_NEXT_L2_INPUT (VNET_SIMULATED_ETHERNET_TX_NEXT_ETHERNET_INPUT + 1) |
John Lo | 405e41b | 2016-04-23 15:14:12 -0400 | [diff] [blame] | 500 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 501 | typedef enum |
| 502 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 503 | VNET_INTERFACE_OUTPUT_ERROR_INTERFACE_DOWN, |
| 504 | VNET_INTERFACE_OUTPUT_ERROR_INTERFACE_DELETED, |
Andrew Yourtchenko | 6a7cff7 | 2018-10-12 16:09:22 +0200 | [diff] [blame] | 505 | VNET_INTERFACE_OUTPUT_ERROR_NO_BUFFERS_FOR_GSO, |
| 506 | VNET_INTERFACE_OUTPUT_ERROR_UNHANDLED_GSO_TYPE, |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 507 | } vnet_interface_output_error_t; |
| 508 | |
| 509 | /* Format for interface output traces. */ |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 510 | u8 *format_vnet_interface_output_trace (u8 * s, va_list * va); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 511 | |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 512 | serialize_function_t serialize_vnet_interface_state, |
| 513 | unserialize_vnet_interface_state; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 514 | |
Damjan Marion | 25ab6c5 | 2021-03-05 14:41:25 +0100 | [diff] [blame] | 515 | /** |
| 516 | * @brief Add buffer (vlib_buffer_t) to the trace |
| 517 | * |
| 518 | * @param *pm - pcap_main_t |
| 519 | * @param *vm - vlib_main_t |
| 520 | * @param buffer_index - u32 |
| 521 | * @param n_bytes_in_trace - u32 |
| 522 | * |
| 523 | */ |
| 524 | static inline void |
| 525 | pcap_add_buffer (pcap_main_t *pm, struct vlib_main_t *vm, u32 buffer_index, |
| 526 | u32 n_bytes_in_trace) |
| 527 | { |
| 528 | vlib_buffer_t *b = vlib_get_buffer (vm, buffer_index); |
| 529 | u32 n = vlib_buffer_length_in_chain (vm, b); |
| 530 | i32 n_left = clib_min (n_bytes_in_trace, n); |
| 531 | f64 time_now = vlib_time_now (vm); |
| 532 | void *d; |
| 533 | |
| 534 | if (PREDICT_TRUE (pm->n_packets_captured < pm->n_packets_to_capture)) |
| 535 | { |
| 536 | clib_spinlock_lock_if_init (&pm->lock); |
| 537 | d = pcap_add_packet (pm, time_now, n_left, n); |
| 538 | while (1) |
| 539 | { |
| 540 | u32 copy_length = clib_min ((u32) n_left, b->current_length); |
| 541 | clib_memcpy_fast (d, b->data + b->current_data, copy_length); |
| 542 | n_left -= b->current_length; |
| 543 | if (n_left <= 0) |
| 544 | break; |
| 545 | d += b->current_length; |
| 546 | ASSERT (b->flags & VLIB_BUFFER_NEXT_PRESENT); |
| 547 | b = vlib_get_buffer (vm, b->next_buffer); |
| 548 | } |
| 549 | clib_spinlock_unlock_if_init (&pm->lock); |
| 550 | } |
| 551 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 552 | #endif /* included_vnet_interface_funcs_h */ |
Dave Barach | ba868bb | 2016-08-08 09:51:21 -0400 | [diff] [blame] | 553 | |
| 554 | /* |
| 555 | * fd.io coding-style-patch-verification: ON |
| 556 | * |
| 557 | * Local Variables: |
| 558 | * eval: (c-set-style "gnu") |
| 559 | * End: |
| 560 | */ |