Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1 | /* |
| 2 | * gre_interface.c: gre interfaces |
| 3 | * |
| 4 | * Copyright (c) 2012 Cisco and/or its affiliates. |
| 5 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | * you may not use this file except in compliance with the License. |
| 7 | * You may obtain a copy of the License at: |
| 8 | * |
| 9 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 10 | * |
| 11 | * Unless required by applicable law or agreed to in writing, software |
| 12 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | * See the License for the specific language governing permissions and |
| 15 | * limitations under the License. |
| 16 | */ |
| 17 | |
| 18 | #include <vnet/vnet.h> |
| 19 | #include <vnet/pg/pg.h> |
| 20 | #include <vnet/gre/gre.h> |
Chris Luke | 27fe48f | 2016-04-28 13:44:38 -0400 | [diff] [blame] | 21 | #include <vnet/ip/format.h> |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 22 | #include <vnet/fib/ip4_fib.h> |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 23 | #include <vnet/fib/ip6_fib.h> |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 24 | #include <vnet/adj/adj_midchain.h> |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 25 | #include <vnet/adj/adj_nbr.h> |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 26 | #include <vnet/mpls/mpls.h> |
Neale Ranns | 3b81a1e | 2018-09-06 09:50:26 -0700 | [diff] [blame] | 27 | #include <vnet/l2/l2_input.h> |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 28 | |
Neale Ranns | 177bbdc | 2016-11-15 09:46:51 +0000 | [diff] [blame] | 29 | static const char *gre_tunnel_type_names[] = GRE_TUNNEL_TYPE_NAMES; |
| 30 | |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 31 | static u8 * |
| 32 | format_gre_tunnel (u8 * s, va_list * args) |
Chris Luke | 27fe48f | 2016-04-28 13:44:38 -0400 | [diff] [blame] | 33 | { |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 34 | gre_tunnel_t *t = va_arg (*args, gre_tunnel_t *); |
Chris Luke | 27fe48f | 2016-04-28 13:44:38 -0400 | [diff] [blame] | 35 | |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 36 | s = format (s, "[%d] instance %d src %U dst %U fib-idx %d sw-if-idx %d ", |
| 37 | t->dev_instance, t->user_instance, |
John Lo | 4478d8e | 2018-01-12 17:15:25 -0500 | [diff] [blame] | 38 | format_ip46_address, &t->tunnel_src, IP46_TYPE_ANY, |
| 39 | format_ip46_address, &t->tunnel_dst.fp_addr, IP46_TYPE_ANY, |
| 40 | t->outer_fib_index, t->sw_if_index); |
| 41 | |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 42 | s = format (s, "payload %s ", gre_tunnel_type_names[t->type]); |
| 43 | |
| 44 | if (t->type == GRE_TUNNEL_TYPE_ERSPAN) |
| 45 | s = format (s, "session %d ", t->session_id); |
| 46 | |
| 47 | if (t->type != GRE_TUNNEL_TYPE_L3) |
| 48 | s = format (s, "l2-adj-idx %d ", t->l2_adj_index); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 49 | |
Chris Luke | 27fe48f | 2016-04-28 13:44:38 -0400 | [diff] [blame] | 50 | return s; |
| 51 | } |
| 52 | |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 53 | static gre_tunnel_t * |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 54 | gre_tunnel_db_find (const vnet_gre_add_del_tunnel_args_t * a, |
| 55 | u32 outer_fib_index, gre_tunnel_key_t * key) |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 56 | { |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 57 | gre_main_t *gm = &gre_main; |
| 58 | uword *p; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 59 | |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 60 | if (!a->is_ipv6) |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 61 | { |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 62 | gre_mk_key4 (a->src.ip4, a->dst.ip4, outer_fib_index, |
| 63 | a->tunnel_type, a->session_id, &key->gtk_v4); |
Neale Ranns | 33ce60d | 2017-12-14 08:51:32 -0800 | [diff] [blame] | 64 | p = hash_get_mem (gm->tunnel_by_key4, &key->gtk_v4); |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 65 | } |
| 66 | else |
| 67 | { |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 68 | gre_mk_key6 (&a->src.ip6, &a->dst.ip6, outer_fib_index, |
| 69 | a->tunnel_type, a->session_id, &key->gtk_v6); |
Neale Ranns | 33ce60d | 2017-12-14 08:51:32 -0800 | [diff] [blame] | 70 | p = hash_get_mem (gm->tunnel_by_key6, &key->gtk_v6); |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 71 | } |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 72 | |
| 73 | if (NULL == p) |
| 74 | return (NULL); |
| 75 | |
| 76 | return (pool_elt_at_index (gm->tunnels, p[0])); |
| 77 | } |
| 78 | |
| 79 | static void |
Neale Ranns | 33ce60d | 2017-12-14 08:51:32 -0800 | [diff] [blame] | 80 | gre_tunnel_db_add (gre_tunnel_t * t, gre_tunnel_key_t * key) |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 81 | { |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 82 | gre_main_t *gm = &gre_main; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 83 | |
Neale Ranns | 33ce60d | 2017-12-14 08:51:32 -0800 | [diff] [blame] | 84 | t->key = clib_mem_alloc (sizeof (*t->key)); |
| 85 | clib_memcpy (t->key, key, sizeof (*key)); |
| 86 | |
| 87 | if (t->tunnel_dst.fp_proto == FIB_PROTOCOL_IP6) |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 88 | { |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 89 | hash_set_mem (gm->tunnel_by_key6, &t->key->gtk_v6, t->dev_instance); |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 90 | } |
| 91 | else |
| 92 | { |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 93 | hash_set_mem (gm->tunnel_by_key4, &t->key->gtk_v4, t->dev_instance); |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 94 | } |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 95 | } |
| 96 | |
| 97 | static void |
Neale Ranns | 33ce60d | 2017-12-14 08:51:32 -0800 | [diff] [blame] | 98 | gre_tunnel_db_remove (gre_tunnel_t * t) |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 99 | { |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 100 | gre_main_t *gm = &gre_main; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 101 | |
Neale Ranns | 33ce60d | 2017-12-14 08:51:32 -0800 | [diff] [blame] | 102 | if (t->tunnel_dst.fp_proto == FIB_PROTOCOL_IP6) |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 103 | { |
Neale Ranns | 33ce60d | 2017-12-14 08:51:32 -0800 | [diff] [blame] | 104 | hash_unset_mem (gm->tunnel_by_key6, &t->key->gtk_v6); |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 105 | } |
| 106 | else |
| 107 | { |
Neale Ranns | 33ce60d | 2017-12-14 08:51:32 -0800 | [diff] [blame] | 108 | hash_unset_mem (gm->tunnel_by_key4, &t->key->gtk_v4); |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 109 | } |
| 110 | |
Neale Ranns | 33ce60d | 2017-12-14 08:51:32 -0800 | [diff] [blame] | 111 | clib_mem_free (t->key); |
| 112 | t->key = NULL; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 113 | } |
| 114 | |
| 115 | static gre_tunnel_t * |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 116 | gre_tunnel_from_fib_node (fib_node_t * node) |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 117 | { |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 118 | ASSERT (FIB_NODE_TYPE_GRE_TUNNEL == node->fn_type); |
| 119 | return ((gre_tunnel_t *) (((char *) node) - |
| 120 | STRUCT_OFFSET_OF (gre_tunnel_t, node))); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 121 | } |
| 122 | |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 123 | /** |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 124 | * gre_tunnel_stack |
| 125 | * |
| 126 | * 'stack' (resolve the recursion for) the tunnel's midchain adjacency |
| 127 | */ |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 128 | void |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 129 | gre_tunnel_stack (adj_index_t ai) |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 130 | { |
Neale Ranns | 2646c80 | 2018-09-19 04:55:32 -0700 | [diff] [blame^] | 131 | fib_forward_chain_type_t fib_fwd; |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 132 | gre_main_t *gm = &gre_main; |
Neale Ranns | 2646c80 | 2018-09-19 04:55:32 -0700 | [diff] [blame^] | 133 | dpo_id_t tmp = DPO_INVALID; |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 134 | ip_adjacency_t *adj; |
| 135 | gre_tunnel_t *gt; |
| 136 | u32 sw_if_index; |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 137 | |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 138 | adj = adj_get (ai); |
| 139 | sw_if_index = adj->rewrite_header.sw_if_index; |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 140 | |
Eyal Bari | cd30774 | 2018-07-22 12:45:15 +0300 | [diff] [blame] | 141 | if ((vec_len (gm->tunnel_index_by_sw_if_index) <= sw_if_index) || |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 142 | (~0 == gm->tunnel_index_by_sw_if_index[sw_if_index])) |
| 143 | return; |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 144 | |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 145 | gt = pool_elt_at_index (gm->tunnels, |
| 146 | gm->tunnel_index_by_sw_if_index[sw_if_index]); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 147 | |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 148 | if ((vnet_hw_interface_get_flags (vnet_get_main (), gt->hw_if_index) & |
| 149 | VNET_HW_INTERFACE_FLAG_LINK_UP) == 0) |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 150 | { |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 151 | adj_nbr_midchain_unstack (ai); |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 152 | return; |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 153 | } |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 154 | |
Neale Ranns | 2646c80 | 2018-09-19 04:55:32 -0700 | [diff] [blame^] | 155 | fib_fwd = fib_forw_chain_type_from_fib_proto (gt->tunnel_dst.fp_proto); |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 156 | |
| 157 | fib_entry_contribute_forwarding (gt->fib_entry_index, fib_fwd, &tmp); |
| 158 | if (DPO_LOAD_BALANCE == tmp.dpoi_type) |
| 159 | { |
| 160 | /* |
| 161 | * post GRE rewrite we will load-balance. However, the GRE encap |
| 162 | * is always the same for this adjacency/tunnel and hence the IP/GRE |
| 163 | * src,dst hash is always the same result too. So we do that hash now and |
| 164 | * stack on the choice. |
| 165 | * If the choice is an incomplete adj then we will need a poke when |
| 166 | * it becomes complete. This happens since the adj update walk propagates |
| 167 | * as far a recursive paths. |
| 168 | */ |
| 169 | const dpo_id_t *choice; |
| 170 | load_balance_t *lb; |
| 171 | int hash; |
| 172 | |
| 173 | lb = load_balance_get (tmp.dpoi_index); |
| 174 | |
| 175 | if (fib_fwd == FIB_FORW_CHAIN_TYPE_UNICAST_IP4) |
| 176 | hash = ip4_compute_flow_hash ((ip4_header_t *) adj_get_rewrite (ai), |
| 177 | lb->lb_hash_config); |
| 178 | else |
| 179 | hash = ip6_compute_flow_hash ((ip6_header_t *) adj_get_rewrite (ai), |
| 180 | lb->lb_hash_config); |
| 181 | choice = |
| 182 | load_balance_get_bucket_i (lb, hash & lb->lb_n_buckets_minus_1); |
| 183 | dpo_copy (&tmp, choice); |
| 184 | } |
| 185 | |
| 186 | adj_nbr_midchain_stack (ai, &tmp); |
| 187 | dpo_reset (&tmp); |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 188 | } |
| 189 | |
| 190 | /** |
| 191 | * @brief Call back when restacking all adjacencies on a GRE interface |
| 192 | */ |
| 193 | static adj_walk_rc_t |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 194 | gre_adj_walk_cb (adj_index_t ai, void *ctx) |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 195 | { |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 196 | gre_tunnel_stack (ai); |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 197 | |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 198 | return (ADJ_WALK_RC_CONTINUE); |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 199 | } |
| 200 | |
| 201 | static void |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 202 | gre_tunnel_restack (gre_tunnel_t * gt) |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 203 | { |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 204 | fib_protocol_t proto; |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 205 | |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 206 | /* |
| 207 | * walk all the adjacencies on th GRE interface and restack them |
| 208 | */ |
| 209 | FOR_EACH_FIB_IP_PROTOCOL (proto) |
| 210 | { |
| 211 | adj_nbr_walk (gt->sw_if_index, proto, gre_adj_walk_cb, NULL); |
| 212 | } |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 213 | } |
| 214 | |
| 215 | /** |
| 216 | * Function definition to backwalk a FIB node |
| 217 | */ |
| 218 | static fib_node_back_walk_rc_t |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 219 | gre_tunnel_back_walk (fib_node_t * node, fib_node_back_walk_ctx_t * ctx) |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 220 | { |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 221 | gre_tunnel_restack (gre_tunnel_from_fib_node (node)); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 222 | |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 223 | return (FIB_NODE_BACK_WALK_CONTINUE); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 224 | } |
| 225 | |
| 226 | /** |
| 227 | * Function definition to get a FIB node from its index |
| 228 | */ |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 229 | static fib_node_t * |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 230 | gre_tunnel_fib_node_get (fib_node_index_t index) |
| 231 | { |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 232 | gre_tunnel_t *gt; |
| 233 | gre_main_t *gm; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 234 | |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 235 | gm = &gre_main; |
| 236 | gt = pool_elt_at_index (gm->tunnels, index); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 237 | |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 238 | return (>->node); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 239 | } |
| 240 | |
| 241 | /** |
| 242 | * Function definition to inform the FIB node that its last lock has gone. |
| 243 | */ |
| 244 | static void |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 245 | gre_tunnel_last_lock_gone (fib_node_t * node) |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 246 | { |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 247 | /* |
| 248 | * The MPLS GRE tunnel is a root of the graph. As such |
| 249 | * it never has children and thus is never locked. |
| 250 | */ |
| 251 | ASSERT (0); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 252 | } |
| 253 | |
| 254 | /* |
| 255 | * Virtual function table registered by MPLS GRE tunnels |
| 256 | * for participation in the FIB object graph. |
| 257 | */ |
| 258 | const static fib_node_vft_t gre_vft = { |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 259 | .fnv_get = gre_tunnel_fib_node_get, |
| 260 | .fnv_last_lock = gre_tunnel_last_lock_gone, |
| 261 | .fnv_back_walk = gre_tunnel_back_walk, |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 262 | }; |
| 263 | |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 264 | static int |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 265 | vnet_gre_tunnel_add (vnet_gre_add_del_tunnel_args_t * a, |
| 266 | u32 outer_fib_index, u32 * sw_if_indexp) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 267 | { |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 268 | gre_main_t *gm = &gre_main; |
| 269 | vnet_main_t *vnm = gm->vnet_main; |
| 270 | ip4_main_t *im4 = &ip4_main; |
| 271 | ip6_main_t *im6 = &ip6_main; |
| 272 | gre_tunnel_t *t; |
| 273 | vnet_hw_interface_t *hi; |
Chris Luke | 27fe48f | 2016-04-28 13:44:38 -0400 | [diff] [blame] | 274 | u32 hw_if_index, sw_if_index; |
David Hotham | a8cd309 | 2016-09-19 09:55:07 -0700 | [diff] [blame] | 275 | clib_error_t *error; |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 276 | u8 is_ipv6 = a->is_ipv6; |
Neale Ranns | 33ce60d | 2017-12-14 08:51:32 -0800 | [diff] [blame] | 277 | gre_tunnel_key_t key; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 278 | |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 279 | t = gre_tunnel_db_find (a, outer_fib_index, &key); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 280 | if (NULL != t) |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 281 | return VNET_API_ERROR_IF_ALREADY_EXISTS; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 282 | |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 283 | pool_get_aligned (gm->tunnels, t, CLIB_CACHE_LINE_BYTES); |
| 284 | memset (t, 0, sizeof (*t)); |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 285 | |
| 286 | /* Reconcile the real dev_instance and a possible requested instance */ |
| 287 | u32 t_idx = t - gm->tunnels; /* tunnel index (or instance) */ |
| 288 | u32 u_idx = a->instance; /* user specified instance */ |
| 289 | if (u_idx == ~0) |
| 290 | u_idx = t_idx; |
| 291 | if (hash_get (gm->instance_used, u_idx)) |
| 292 | { |
| 293 | pool_put (gm->tunnels, t); |
| 294 | return VNET_API_ERROR_INSTANCE_IN_USE; |
| 295 | } |
| 296 | hash_set (gm->instance_used, u_idx, 1); |
| 297 | |
| 298 | t->dev_instance = t_idx; /* actual */ |
| 299 | t->user_instance = u_idx; /* name */ |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 300 | fib_node_init (&t->node, FIB_NODE_TYPE_GRE_TUNNEL); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 301 | |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 302 | t->type = a->tunnel_type; |
| 303 | if (t->type == GRE_TUNNEL_TYPE_ERSPAN) |
| 304 | t->session_id = a->session_id; |
Neale Ranns | 177bbdc | 2016-11-15 09:46:51 +0000 | [diff] [blame] | 305 | |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 306 | if (t->type == GRE_TUNNEL_TYPE_L3) |
| 307 | hw_if_index = vnet_register_interface (vnm, gre_device_class.index, t_idx, |
| 308 | gre_hw_interface_class.index, |
| 309 | t_idx); |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 310 | else |
| 311 | { |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 312 | /* Default MAC address (d00b:eed0:0000 + sw_if_index) */ |
John Lo | 25d417f | 2018-02-15 15:47:53 -0500 | [diff] [blame] | 313 | u8 address[6] = |
| 314 | { 0xd0, 0x0b, 0xee, 0xd0, (u8) (t_idx >> 8), (u8) t_idx }; |
| 315 | error = |
| 316 | ethernet_register_interface (vnm, gre_device_class.index, t_idx, |
| 317 | address, &hw_if_index, 0); |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 318 | if (error) |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 319 | { |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 320 | clib_error_report (error); |
| 321 | return VNET_API_ERROR_INVALID_REGISTRATION; |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 322 | } |
Chris Luke | 27fe48f | 2016-04-28 13:44:38 -0400 | [diff] [blame] | 323 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 324 | |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 325 | /* Set GRE tunnel interface output node (not used for L3 payload) */ |
| 326 | vnet_set_interface_output_node (vnm, hw_if_index, gre_encap_node.index); |
| 327 | |
| 328 | hi = vnet_get_hw_interface (vnm, hw_if_index); |
| 329 | sw_if_index = hi->sw_if_index; |
| 330 | |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 331 | t->hw_if_index = hw_if_index; |
| 332 | t->outer_fib_index = outer_fib_index; |
| 333 | t->sw_if_index = sw_if_index; |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 334 | t->l2_adj_index = ADJ_INDEX_INVALID; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 335 | |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 336 | vec_validate_init_empty (gm->tunnel_index_by_sw_if_index, sw_if_index, ~0); |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 337 | gm->tunnel_index_by_sw_if_index[sw_if_index] = t_idx; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 338 | |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 339 | if (!is_ipv6) |
| 340 | { |
| 341 | vec_validate (im4->fib_index_by_sw_if_index, sw_if_index); |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 342 | hi->min_packet_bytes = |
| 343 | 64 + sizeof (gre_header_t) + sizeof (ip4_header_t); |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 344 | } |
| 345 | else |
| 346 | { |
| 347 | vec_validate (im6->fib_index_by_sw_if_index, sw_if_index); |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 348 | hi->min_packet_bytes = |
| 349 | 64 + sizeof (gre_header_t) + sizeof (ip6_header_t); |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 350 | } |
Chris Luke | 7164900 | 2016-05-06 11:51:54 -0400 | [diff] [blame] | 351 | |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 352 | /* Standard default gre MTU. */ |
Ole Troan | d723161 | 2018-06-07 10:17:57 +0200 | [diff] [blame] | 353 | vnet_sw_interface_set_mtu (vnm, sw_if_index, 9000); |
Damjan Marion | fe7d4a2 | 2018-04-13 19:43:39 +0200 | [diff] [blame] | 354 | |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 355 | /* |
| 356 | * source the FIB entry for the tunnel's destination |
| 357 | * and become a child thereof. The tunnel will then get poked |
| 358 | * when the forwarding for the entry updates, and the tunnel can |
| 359 | * re-stack accordingly |
| 360 | */ |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 361 | |
| 362 | clib_memcpy (&t->tunnel_src, &a->src, sizeof (t->tunnel_src)); |
| 363 | t->tunnel_dst.fp_len = !is_ipv6 ? 32 : 128; |
| 364 | t->tunnel_dst.fp_proto = !is_ipv6 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6; |
| 365 | t->tunnel_dst.fp_addr = a->dst; |
| 366 | |
Neale Ranns | 33ce60d | 2017-12-14 08:51:32 -0800 | [diff] [blame] | 367 | gre_tunnel_db_add (t, &key); |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 368 | if (t->type == GRE_TUNNEL_TYPE_ERSPAN) |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 369 | { |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 370 | gre_sn_key_t skey; |
| 371 | gre_sn_t *gre_sn; |
| 372 | |
| 373 | gre_mk_sn_key (t, &skey); |
| 374 | gre_sn = (gre_sn_t *) hash_get_mem (gm->seq_num_by_key, &skey); |
| 375 | if (gre_sn != NULL) |
| 376 | { |
| 377 | gre_sn->ref_count++; |
| 378 | t->gre_sn = gre_sn; |
| 379 | } |
| 380 | else |
| 381 | { |
| 382 | gre_sn = clib_mem_alloc (sizeof (gre_sn_t)); |
| 383 | gre_sn->seq_num = 0; |
| 384 | gre_sn->ref_count = 1; |
| 385 | t->gre_sn = gre_sn; |
| 386 | hash_set_mem_alloc (&gm->seq_num_by_key, &skey, (uword) gre_sn); |
| 387 | } |
| 388 | } |
| 389 | |
| 390 | t->fib_entry_index = fib_table_entry_special_add |
| 391 | (outer_fib_index, &t->tunnel_dst, FIB_SOURCE_RR, FIB_ENTRY_FLAG_NONE); |
| 392 | t->sibling_index = fib_entry_child_add |
| 393 | (t->fib_entry_index, FIB_NODE_TYPE_GRE_TUNNEL, t_idx); |
| 394 | |
| 395 | if (t->type != GRE_TUNNEL_TYPE_L3) |
| 396 | { |
| 397 | t->l2_adj_index = adj_nbr_add_or_lock |
| 398 | (t->tunnel_dst.fp_proto, VNET_LINK_ETHERNET, &zero_addr, sw_if_index); |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 399 | gre_update_adj (vnm, t->sw_if_index, t->l2_adj_index); |
| 400 | } |
Chris Luke | 27fe48f | 2016-04-28 13:44:38 -0400 | [diff] [blame] | 401 | |
| 402 | if (sw_if_indexp) |
| 403 | *sw_if_indexp = sw_if_index; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 404 | |
| 405 | return 0; |
| 406 | } |
| 407 | |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 408 | static int |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 409 | vnet_gre_tunnel_delete (vnet_gre_add_del_tunnel_args_t * a, |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 410 | u32 outer_fib_index, u32 * sw_if_indexp) |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 411 | { |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 412 | gre_main_t *gm = &gre_main; |
| 413 | vnet_main_t *vnm = gm->vnet_main; |
| 414 | gre_tunnel_t *t; |
Neale Ranns | 33ce60d | 2017-12-14 08:51:32 -0800 | [diff] [blame] | 415 | gre_tunnel_key_t key; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 416 | u32 sw_if_index; |
John Lo | 101e005 | 2018-01-06 00:22:54 -0500 | [diff] [blame] | 417 | |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 418 | t = gre_tunnel_db_find (a, outer_fib_index, &key); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 419 | if (NULL == t) |
| 420 | return VNET_API_ERROR_NO_SUCH_ENTRY; |
| 421 | |
| 422 | sw_if_index = t->sw_if_index; |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 423 | vnet_sw_interface_set_flags (vnm, sw_if_index, 0 /* down */ ); |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 424 | |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 425 | /* make sure tunnel is removed from l2 bd or xconnect */ |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 426 | set_int_l2_mode (gm->vlib_main, vnm, MODE_L3, sw_if_index, 0, 0, 0, 0); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 427 | gm->tunnel_index_by_sw_if_index[sw_if_index] = ~0; |
Neale Ranns | 177bbdc | 2016-11-15 09:46:51 +0000 | [diff] [blame] | 428 | |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 429 | if (t->type == GRE_TUNNEL_TYPE_L3) |
| 430 | vnet_delete_hw_interface (vnm, t->hw_if_index); |
| 431 | else |
| 432 | ethernet_delete_interface (vnm, t->hw_if_index); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 433 | |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 434 | if (t->l2_adj_index != ADJ_INDEX_INVALID) |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 435 | adj_unlock (t->l2_adj_index); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 436 | |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 437 | fib_entry_child_remove (t->fib_entry_index, t->sibling_index); |
| 438 | fib_table_entry_delete_index (t->fib_entry_index, FIB_SOURCE_RR); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 439 | |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 440 | ASSERT ((t->type != GRE_TUNNEL_TYPE_ERSPAN) || (t->gre_sn != NULL)); |
| 441 | if ((t->type == GRE_TUNNEL_TYPE_ERSPAN) && (t->gre_sn->ref_count-- == 1)) |
| 442 | { |
| 443 | gre_sn_key_t skey; |
| 444 | gre_mk_sn_key (t, &skey); |
| 445 | hash_unset_mem_free (&gm->seq_num_by_key, &skey); |
| 446 | clib_mem_free (t->gre_sn); |
| 447 | } |
| 448 | |
| 449 | hash_unset (gm->instance_used, t->user_instance); |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 450 | gre_tunnel_db_remove (t); |
| 451 | fib_node_deinit (&t->node); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 452 | pool_put (gm->tunnels, t); |
| 453 | |
| 454 | if (sw_if_indexp) |
| 455 | *sw_if_indexp = sw_if_index; |
| 456 | |
| 457 | return 0; |
| 458 | } |
| 459 | |
| 460 | int |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 461 | vnet_gre_add_del_tunnel (vnet_gre_add_del_tunnel_args_t * a, |
| 462 | u32 * sw_if_indexp) |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 463 | { |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 464 | u32 outer_fib_index; |
| 465 | |
| 466 | if (!a->is_ipv6) |
| 467 | outer_fib_index = ip4_fib_index_from_table_id (a->outer_fib_id); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 468 | else |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 469 | outer_fib_index = ip6_fib_index_from_table_id (a->outer_fib_id); |
| 470 | |
| 471 | if (~0 == outer_fib_index) |
| 472 | return VNET_API_ERROR_NO_SUCH_FIB; |
| 473 | |
| 474 | if (a->session_id > GTK_SESSION_ID_MAX) |
| 475 | return VNET_API_ERROR_INVALID_SESSION_ID; |
| 476 | |
| 477 | if (a->is_add) |
| 478 | return (vnet_gre_tunnel_add (a, outer_fib_index, sw_if_indexp)); |
| 479 | else |
| 480 | return (vnet_gre_tunnel_delete (a, outer_fib_index, sw_if_indexp)); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 481 | } |
| 482 | |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 483 | clib_error_t * |
| 484 | gre_interface_admin_up_down (vnet_main_t * vnm, u32 hw_if_index, u32 flags) |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 485 | { |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 486 | gre_main_t *gm = &gre_main; |
| 487 | vnet_hw_interface_t *hi; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 488 | gre_tunnel_t *t; |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 489 | u32 ti; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 490 | |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 491 | hi = vnet_get_hw_interface (vnm, hw_if_index); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 492 | |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 493 | if (NULL == gm->tunnel_index_by_sw_if_index || |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 494 | hi->sw_if_index >= vec_len (gm->tunnel_index_by_sw_if_index)) |
| 495 | return (NULL); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 496 | |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 497 | ti = gm->tunnel_index_by_sw_if_index[hi->sw_if_index]; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 498 | |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 499 | if (~0 == ti) |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 500 | /* not one of ours */ |
| 501 | return (NULL); |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 502 | |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 503 | t = pool_elt_at_index (gm->tunnels, ti); |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 504 | |
| 505 | if (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 506 | vnet_hw_interface_set_flags (vnm, hw_if_index, |
| 507 | VNET_HW_INTERFACE_FLAG_LINK_UP); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 508 | else |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 509 | vnet_hw_interface_set_flags (vnm, hw_if_index, 0 /* down */ ); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 510 | |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 511 | gre_tunnel_restack (t); |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 512 | |
| 513 | return /* no error */ 0; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 514 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 515 | |
| 516 | static clib_error_t * |
| 517 | create_gre_tunnel_command_fn (vlib_main_t * vm, |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 518 | unformat_input_t * input, |
| 519 | vlib_cli_command_t * cmd) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 520 | { |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 521 | unformat_input_t _line_input, *line_input = &_line_input; |
| 522 | vnet_gre_add_del_tunnel_args_t _a, *a = &_a; |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 523 | ip46_address_t src, dst; |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 524 | u32 instance = ~0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 525 | u32 outer_fib_id = 0; |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 526 | gre_tunnel_type_t t_type = GRE_TUNNEL_TYPE_L3; |
| 527 | u32 session_id = 0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 528 | int rv; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 529 | u32 num_m_args = 0; |
Chris Luke | 27fe48f | 2016-04-28 13:44:38 -0400 | [diff] [blame] | 530 | u8 is_add = 1; |
Pierre Pfister | 78ea9c2 | 2016-05-23 12:51:54 +0100 | [diff] [blame] | 531 | u32 sw_if_index; |
Billy McFall | a9a20e7 | 2017-02-15 11:39:12 -0500 | [diff] [blame] | 532 | clib_error_t *error = NULL; |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 533 | u8 ipv4_set = 0; |
| 534 | u8 ipv6_set = 0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 535 | |
| 536 | /* Get a line of input. */ |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 537 | if (!unformat_user (input, unformat_line_input, line_input)) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 538 | return 0; |
| 539 | |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 540 | while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) |
| 541 | { |
| 542 | if (unformat (line_input, "del")) |
| 543 | is_add = 0; |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 544 | else if (unformat (line_input, "instance %d", &instance)) |
| 545 | ; |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 546 | else |
| 547 | if (unformat (line_input, "src %U", unformat_ip4_address, &src.ip4)) |
| 548 | { |
| 549 | num_m_args++; |
| 550 | ipv4_set = 1; |
| 551 | } |
| 552 | else |
| 553 | if (unformat (line_input, "dst %U", unformat_ip4_address, &dst.ip4)) |
| 554 | { |
| 555 | num_m_args++; |
| 556 | ipv4_set = 1; |
| 557 | } |
| 558 | else |
| 559 | if (unformat (line_input, "src %U", unformat_ip6_address, &src.ip6)) |
| 560 | { |
| 561 | num_m_args++; |
| 562 | ipv6_set = 1; |
| 563 | } |
| 564 | else |
| 565 | if (unformat (line_input, "dst %U", unformat_ip6_address, &dst.ip6)) |
| 566 | { |
| 567 | num_m_args++; |
| 568 | ipv6_set = 1; |
| 569 | } |
| 570 | else if (unformat (line_input, "outer-fib-id %d", &outer_fib_id)) |
| 571 | ; |
| 572 | else if (unformat (line_input, "teb")) |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 573 | t_type = GRE_TUNNEL_TYPE_TEB; |
| 574 | else if (unformat (line_input, "erspan %d", &session_id)) |
| 575 | t_type = GRE_TUNNEL_TYPE_ERSPAN; |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 576 | else |
| 577 | { |
| 578 | error = clib_error_return (0, "unknown input `%U'", |
| 579 | format_unformat_error, line_input); |
| 580 | goto done; |
| 581 | } |
| 582 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 583 | |
| 584 | if (num_m_args < 2) |
Billy McFall | a9a20e7 | 2017-02-15 11:39:12 -0500 | [diff] [blame] | 585 | { |
| 586 | error = clib_error_return (0, "mandatory argument(s) missing"); |
| 587 | goto done; |
| 588 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 589 | |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 590 | if ((ipv4_set && memcmp (&src.ip4, &dst.ip4, sizeof (src.ip4)) == 0) || |
| 591 | (ipv6_set && memcmp (&src.ip6, &dst.ip6, sizeof (src.ip6)) == 0)) |
Billy McFall | a9a20e7 | 2017-02-15 11:39:12 -0500 | [diff] [blame] | 592 | { |
| 593 | error = clib_error_return (0, "src and dst are identical"); |
| 594 | goto done; |
| 595 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 596 | |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 597 | if (ipv4_set && ipv6_set) |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 598 | return clib_error_return (0, "both IPv4 and IPv6 addresses specified"); |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 599 | |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 600 | if ((ipv4_set && memcmp (&dst.ip4, &zero_addr.ip4, sizeof (dst.ip4)) == 0) |
| 601 | || (ipv6_set |
| 602 | && memcmp (&dst.ip6, &zero_addr.ip6, sizeof (dst.ip6)) == 0)) |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 603 | { |
| 604 | error = clib_error_return (0, "dst address cannot be zero"); |
| 605 | goto done; |
| 606 | } |
| 607 | |
Chris Luke | 27fe48f | 2016-04-28 13:44:38 -0400 | [diff] [blame] | 608 | memset (a, 0, sizeof (*a)); |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 609 | a->is_add = is_add; |
Hongjun Ni | 11bfc2f | 2016-07-22 18:19:19 +0800 | [diff] [blame] | 610 | a->outer_fib_id = outer_fib_id; |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 611 | a->tunnel_type = t_type; |
| 612 | a->session_id = session_id; |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 613 | a->is_ipv6 = ipv6_set; |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 614 | a->instance = instance; |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 615 | if (!ipv6_set) |
| 616 | { |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 617 | clib_memcpy (&a->src.ip4, &src.ip4, sizeof (src.ip4)); |
| 618 | clib_memcpy (&a->dst.ip4, &dst.ip4, sizeof (dst.ip4)); |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 619 | } |
| 620 | else |
| 621 | { |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 622 | clib_memcpy (&a->src.ip6, &src.ip6, sizeof (src.ip6)); |
| 623 | clib_memcpy (&a->dst.ip6, &dst.ip6, sizeof (dst.ip6)); |
Ciara Loftus | 7eac916 | 2016-09-30 15:47:03 +0100 | [diff] [blame] | 624 | } |
Chris Luke | 27fe48f | 2016-04-28 13:44:38 -0400 | [diff] [blame] | 625 | |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 626 | rv = vnet_gre_add_del_tunnel (a, &sw_if_index); |
Chris Luke | 27fe48f | 2016-04-28 13:44:38 -0400 | [diff] [blame] | 627 | |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 628 | switch (rv) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 629 | { |
| 630 | case 0: |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 631 | vlib_cli_output (vm, "%U\n", format_vnet_sw_if_index_name, |
| 632 | vnet_get_main (), sw_if_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 633 | break; |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 634 | case VNET_API_ERROR_IF_ALREADY_EXISTS: |
Billy McFall | a9a20e7 | 2017-02-15 11:39:12 -0500 | [diff] [blame] | 635 | error = clib_error_return (0, "GRE tunnel already exists..."); |
| 636 | goto done; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 637 | case VNET_API_ERROR_NO_SUCH_FIB: |
Billy McFall | a9a20e7 | 2017-02-15 11:39:12 -0500 | [diff] [blame] | 638 | error = clib_error_return (0, "outer fib ID %d doesn't exist\n", |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 639 | outer_fib_id); |
Billy McFall | a9a20e7 | 2017-02-15 11:39:12 -0500 | [diff] [blame] | 640 | goto done; |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 641 | case VNET_API_ERROR_NO_SUCH_ENTRY: |
| 642 | error = clib_error_return (0, "GRE tunnel doesn't exist"); |
| 643 | goto done; |
| 644 | case VNET_API_ERROR_INVALID_SESSION_ID: |
| 645 | error = clib_error_return (0, "session ID %d out of range\n", |
| 646 | session_id); |
| 647 | goto done; |
| 648 | case VNET_API_ERROR_INSTANCE_IN_USE: |
| 649 | error = clib_error_return (0, "Instance is in use"); |
| 650 | goto done; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 651 | default: |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 652 | error = |
| 653 | clib_error_return (0, "vnet_gre_add_del_tunnel returned %d", rv); |
Billy McFall | a9a20e7 | 2017-02-15 11:39:12 -0500 | [diff] [blame] | 654 | goto done; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 655 | } |
| 656 | |
Billy McFall | a9a20e7 | 2017-02-15 11:39:12 -0500 | [diff] [blame] | 657 | done: |
| 658 | unformat_free (line_input); |
| 659 | |
| 660 | return error; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 661 | } |
| 662 | |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 663 | /* *INDENT-OFF* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 664 | VLIB_CLI_COMMAND (create_gre_tunnel_command, static) = { |
| 665 | .path = "create gre tunnel", |
John Lo | a43ccae | 2018-02-13 17:15:23 -0500 | [diff] [blame] | 666 | .short_help = "create gre tunnel src <addr> dst <addr> [instance <n>] " |
| 667 | "[outer-fib-id <fib>] [teb | erspan <session-id>] [del]", |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 668 | .function = create_gre_tunnel_command_fn, |
| 669 | }; |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 670 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 671 | |
Chris Luke | 27fe48f | 2016-04-28 13:44:38 -0400 | [diff] [blame] | 672 | static clib_error_t * |
| 673 | show_gre_tunnel_command_fn (vlib_main_t * vm, |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 674 | unformat_input_t * input, |
| 675 | vlib_cli_command_t * cmd) |
Chris Luke | 27fe48f | 2016-04-28 13:44:38 -0400 | [diff] [blame] | 676 | { |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 677 | gre_main_t *gm = &gre_main; |
| 678 | gre_tunnel_t *t; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 679 | u32 ti = ~0; |
Chris Luke | 27fe48f | 2016-04-28 13:44:38 -0400 | [diff] [blame] | 680 | |
| 681 | if (pool_elts (gm->tunnels) == 0) |
| 682 | vlib_cli_output (vm, "No GRE tunnels configured..."); |
| 683 | |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 684 | while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) |
| 685 | { |
| 686 | if (unformat (input, "%d", &ti)) |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 687 | ; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 688 | else |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 689 | break; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 690 | } |
| 691 | |
| 692 | if (~0 == ti) |
| 693 | { |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 694 | /* *INDENT-OFF* */ |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 695 | pool_foreach (t, gm->tunnels, |
| 696 | ({ |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 697 | vlib_cli_output (vm, "%U", format_gre_tunnel, t); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 698 | })); |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 699 | /* *INDENT-ON* */ |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 700 | } |
| 701 | else |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 702 | { |
| 703 | t = pool_elt_at_index (gm->tunnels, ti); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 704 | |
Neale Ranns | b80c536 | 2016-10-08 13:03:40 +0100 | [diff] [blame] | 705 | vlib_cli_output (vm, "%U", format_gre_tunnel, t); |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 706 | } |
Chris Luke | 27fe48f | 2016-04-28 13:44:38 -0400 | [diff] [blame] | 707 | |
| 708 | return 0; |
| 709 | } |
| 710 | |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 711 | /* *INDENT-OFF* */ |
Chris Luke | 27fe48f | 2016-04-28 13:44:38 -0400 | [diff] [blame] | 712 | VLIB_CLI_COMMAND (show_gre_tunnel_command, static) = { |
| 713 | .path = "show gre tunnel", |
| 714 | .function = show_gre_tunnel_command_fn, |
| 715 | }; |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 716 | /* *INDENT-ON* */ |
Chris Luke | 27fe48f | 2016-04-28 13:44:38 -0400 | [diff] [blame] | 717 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 718 | /* force inclusion from application's main.c */ |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 719 | clib_error_t * |
| 720 | gre_interface_init (vlib_main_t * vm) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 721 | { |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 722 | fib_node_register_type (FIB_NODE_TYPE_GRE_TUNNEL, &gre_vft); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 723 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 724 | return 0; |
| 725 | } |
Swarup Nayak | 9ff647a | 2017-11-27 10:27:43 +0530 | [diff] [blame] | 726 | |
| 727 | VLIB_INIT_FUNCTION (gre_interface_init); |
| 728 | |
| 729 | /* |
| 730 | * fd.io coding-style-patch-verification: ON |
| 731 | * |
| 732 | * Local Variables: |
| 733 | * eval: (c-set-style "gnu") |
| 734 | * End: |
| 735 | */ |