src/vnet/ip/ip4_punt_drop.c

   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 #include <vnet/ip/ip.h>
  17 #include <vnet/ip/ip_punt_drop.h>
  18 #include <vnet/policer/policer.h>
  19 #include <vnet/policer/police_inlines.h>
  20
  21 /* *INDENT-OFF* */
  22 VNET_FEATURE_ARC_INIT (ip4_punt) =
  23 {
  24   .arc_name  = "ip4-punt",
  25   .start_nodes = VNET_FEATURES ("ip4-punt"),
  26 };
  27
  28 VNET_FEATURE_ARC_INIT (ip4_drop) =
  29 {
  30   .arc_name  = "ip4-drop",
  31   .start_nodes = VNET_FEATURES ("ip4-drop", "ip4-not-enabled"),
  32 };
  33 /* *INDENT-ON* */
  34
  35 extern ip_punt_policer_t ip4_punt_policer_cfg;
  36
  37 #ifndef CLIB_MARCH_VARIANT
  38 u8 *
  39 format_ip_punt_policer_trace (u8 * s, va_list * args)
  40 {
  41   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  42   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  43   ip_punt_policer_trace_t *t = va_arg (*args, ip_punt_policer_trace_t *);
  44
  45   s = format (s, "policer_index %d next %d", t->policer_index, t->next);
  46   return s;
  47 }
  48
  49 ip_punt_policer_t ip4_punt_policer_cfg = {
  50   .policer_index = ~0,
  51 };
  52 #endif /* CLIB_MARCH_VARIANT */
  53
  54 static char *ip4_punt_policer_handoff_error_strings[] = { "congestion drop" };
  55
  56 VLIB_NODE_FN (ip4_punt_policer_handoff_node)
  57 (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
  58 {
  59   return policer_handoff (vm, node, frame, ip4_punt_policer_cfg.fq_index,
  60                           ip4_punt_policer_cfg.policer_index);
  61 }
  62
  63 VLIB_REGISTER_NODE (ip4_punt_policer_handoff_node) = {
  64   .name = "ip4-punt-policer-handoff",
  65   .vector_size = sizeof (u32),
  66   .format_trace = format_policer_handoff_trace,
  67   .type = VLIB_NODE_TYPE_INTERNAL,
  68   .n_errors = ARRAY_LEN(ip4_punt_policer_handoff_error_strings),
  69   .error_strings = ip4_punt_policer_handoff_error_strings,
  70
  71   .n_next_nodes = 1,
  72   .next_nodes = {
  73     [0] = "error-drop",
  74   },
  75 };
  76
  77 static char *ip4_punt_policer_error_strings[] = {
  78 #define _(sym,string) string,
  79   foreach_ip_punt_policer_error
  80 #undef _
  81 };
  82
  83 VLIB_NODE_FN (ip4_punt_policer_node) (vlib_main_t * vm,
  84                                       vlib_node_runtime_t * node,
  85                                       vlib_frame_t * frame)
  86 {
  87   return (ip_punt_policer (vm, node, frame,
  88                            vnet_feat_arc_ip4_punt.feature_arc_index,
  89                            ip4_punt_policer_cfg.policer_index));
  90 }
  91
  92 /* *INDENT-OFF* */
  93 VLIB_REGISTER_NODE (ip4_punt_policer_node) = {
  94   .name = "ip4-punt-policer",
  95   .vector_size = sizeof (u32),
  96   .n_next_nodes = IP_PUNT_POLICER_N_NEXT,
  97   .format_trace = format_ip_punt_policer_trace,
  98   .n_errors = ARRAY_LEN(ip4_punt_policer_error_strings),
  99   .error_strings = ip4_punt_policer_error_strings,
 100
 101   .next_nodes = {
 102     [IP_PUNT_POLICER_NEXT_DROP] = "ip4-drop",
 103     [IP_PUNT_POLICER_NEXT_HANDOFF] = "ip4-punt-policer-handoff",
 104   },
 105 };
 106
 107 VNET_FEATURE_INIT (ip4_punt_policer_node) = {
 108   .arc_name = "ip4-punt",
 109   .node_name = "ip4-punt-policer",
 110   .runs_before = VNET_FEATURES("ip4-punt-redirect"),
 111 };
 112 /* *INDENT-ON* */
 113
 114
 115 #define foreach_ip4_punt_redirect_error         \
 116 _(DROP, "ip4 punt redirect drop")
 117
 118 typedef enum
 119 {
 120 #define _(sym,str) IP4_PUNT_REDIRECT_ERROR_##sym,
 121   foreach_ip4_punt_redirect_error
 122 #undef _
 123     IP4_PUNT_REDIRECT_N_ERROR,
 124 } ip4_punt_redirect_error_t;
 125
 126 static char *ip4_punt_redirect_error_strings[] = {
 127 #define _(sym,string) string,
 128   foreach_ip4_punt_redirect_error
 129 #undef _
 130 };
 131
 132 VLIB_NODE_FN (ip4_punt_redirect_node) (vlib_main_t * vm,
 133                                        vlib_node_runtime_t * node,
 134                                        vlib_frame_t * frame)
 135 {
 136   return (ip_punt_redirect (vm, node, frame,
 137                             vnet_feat_arc_ip4_punt.feature_arc_index,
 138                             FIB_PROTOCOL_IP4));
 139 }
 140
 141 /* *INDENT-OFF* */
 142 VLIB_REGISTER_NODE (ip4_punt_redirect_node) = {
 143   .name = "ip4-punt-redirect",
 144   .vector_size = sizeof (u32),
 145   .n_next_nodes = IP_PUNT_REDIRECT_N_NEXT,
 146   .format_trace = format_ip_punt_redirect_trace,
 147   .n_errors = ARRAY_LEN(ip4_punt_redirect_error_strings),
 148   .error_strings = ip4_punt_redirect_error_strings,
 149
 150   /* edit / add dispositions here */
 151   .next_nodes = {
 152     [IP_PUNT_REDIRECT_NEXT_DROP] = "ip4-drop",
 153     [IP_PUNT_REDIRECT_NEXT_TX] = "ip4-rewrite",
 154     [IP_PUNT_REDIRECT_NEXT_ARP] = "ip4-arp",
 155   },
 156 };
 157
 158 VNET_FEATURE_INIT (ip4_punt_redirect_node, static) = {
 159   .arc_name = "ip4-punt",
 160   .node_name = "ip4-punt-redirect",
 161   .runs_before = VNET_FEATURES("error-punt"),
 162 };
 163 /* *INDENT-ON* */
 164
 165 VLIB_NODE_FN (ip4_drop_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
 166                               vlib_frame_t * frame)
 167 {
 168   if (node->flags & VLIB_NODE_FLAG_TRACE)
 169     ip4_forward_next_trace (vm, node, frame, VLIB_TX);
 170
 171   return ip_drop_or_punt (vm, node, frame,
 172                           vnet_feat_arc_ip4_drop.feature_arc_index);
 173
 174 }
 175
 176 VLIB_NODE_FN (ip4_not_enabled_node) (vlib_main_t * vm,
 177                                      vlib_node_runtime_t * node,
 178                                      vlib_frame_t * frame)
 179 {
 180   if (node->flags & VLIB_NODE_FLAG_TRACE)
 181     ip4_forward_next_trace (vm, node, frame, VLIB_TX);
 182
 183   return ip_drop_or_punt (vm, node, frame,
 184                           vnet_feat_arc_ip4_drop.feature_arc_index);
 185 }
 186
 187 static uword
 188 ip4_punt (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
 189 {
 190   if (node->flags & VLIB_NODE_FLAG_TRACE)
 191     ip4_forward_next_trace (vm, node, frame, VLIB_TX);
 192
 193   return ip_drop_or_punt (vm, node, frame,
 194                           vnet_feat_arc_ip4_punt.feature_arc_index);
 195 }
 196
 197 /* *INDENT-OFF* */
 198 VLIB_REGISTER_NODE (ip4_drop_node) =
 199 {
 200   .name = "ip4-drop",
 201   .vector_size = sizeof (u32),
 202   .format_trace = format_ip4_forward_next_trace,
 203   .n_next_nodes = 1,
 204   .next_nodes = {
 205     [0] = "error-drop",
 206   },
 207 };
 208
 209 VLIB_REGISTER_NODE (ip4_not_enabled_node) =
 210 {
 211   .name = "ip4-not-enabled",
 212   .vector_size = sizeof (u32),
 213   .format_trace = format_ip4_forward_next_trace,
 214   .sibling_of = "ip4-drop",
 215 };
 216
 217 VLIB_REGISTER_NODE (ip4_punt_node) =
 218 {
 219   .function = ip4_punt,
 220   .name = "ip4-punt",
 221   .vector_size = sizeof (u32),
 222   .format_trace = format_ip4_forward_next_trace,
 223   .n_next_nodes = 1,
 224   .next_nodes = {
 225     [0] = "error-punt",
 226   },
 227 };
 228
 229 VNET_FEATURE_INIT (ip4_punt_end_of_arc, static) = {
 230   .arc_name = "ip4-punt",
 231   .node_name = "error-punt",
 232   .runs_before = 0, /* not before any other features */
 233 };
 234
 235 VNET_FEATURE_INIT (ip4_drop_end_of_arc, static) = {
 236   .arc_name = "ip4-drop",
 237   .node_name = "error-drop",
 238   .runs_before = 0, /* not before any other features */
 239 };
 240 /* *INDENT-ON */
 241
 242 #ifndef CLIB_MARCH_VARIANT
 243 void
 244 ip4_punt_policer_add_del (u8 is_add, u32 policer_index)
 245 {
 246   ip4_punt_policer_cfg.policer_index = policer_index;
 247
 248   vnet_feature_enable_disable ("ip4-punt", "ip4-punt-policer",
 249                                0, is_add, 0, 0);
 250 }
 251 #endif /* CLIB_MARCH_VARIANT */
 252
 253 static clib_error_t *
 254 ip4_punt_police_cmd (vlib_main_t * vm,
 255                      unformat_input_t * main_input,
 256                      vlib_cli_command_t * cmd)
 257 {
 258   unformat_input_t _line_input, *line_input = &_line_input;
 259   clib_error_t *error = 0;
 260   u32 policer_index;
 261   u8 is_add = 1;
 262
 263   policer_index = ~0;
 264
 265   if (!unformat_user (main_input, unformat_line_input, line_input))
 266     return 0;
 267
 268   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 269     {
 270       if (unformat (line_input, "%d", &policer_index))
 271         ;
 272       else if (unformat (line_input, "del"))
 273         is_add = 0;
 274       else if (unformat (line_input, "add"))
 275         is_add = 1;
 276       else
 277         {
 278           error = unformat_parse_error (line_input);
 279           goto done;
 280         }
 281     }
 282
 283   if (is_add && ~0 == policer_index)
 284   {
 285       error = clib_error_return (0, "expected policer index `%U'",
 286                                  format_unformat_error, line_input);
 287       goto done;
 288   }
 289   if (!is_add)
 290       policer_index = ~0;
 291
 292   ip4_punt_policer_add_del(is_add, policer_index);
 293
 294 done:
 295   unformat_free (line_input);
 296   return (error);
 297 }
 298
 299 /*?
 300  *
 301  * @cliexpar
 302  * @cliexcmd{set ip punt policer <INDEX>}
 303  ?*/
 304 /* *INDENT-OFF* */
 305 VLIB_CLI_COMMAND (ip4_punt_policer_command, static) =
 306 {
 307   .path = "ip punt policer",
 308   .function = ip4_punt_police_cmd,
 309   .short_help = "ip punt policer [add|del] <index>",
 310 };
 311 /* *INDENT-ON* */
 312
 313 #ifndef CLIB_MARCH_VARIANT
 314
 315 void
 316 ip4_punt_redirect_add_paths (u32 rx_sw_if_index,
 317                              const fib_route_path_t *rpaths)
 318 {
 319   ip_punt_redirect_add (FIB_PROTOCOL_IP4,
 320                         rx_sw_if_index,
 321                         FIB_FORW_CHAIN_TYPE_UNICAST_IP4, rpaths);
 322
 323   vnet_feature_enable_disable ("ip4-punt", "ip4-punt-redirect", 0, 1, 0, 0);
 324 }
 325
 326 void
 327 ip4_punt_redirect_del (u32 rx_sw_if_index)
 328 {
 329   vnet_feature_enable_disable ("ip4-punt", "ip4-punt-redirect", 0, 0, 0, 0);
 330
 331   ip_punt_redirect_del (FIB_PROTOCOL_IP4, rx_sw_if_index);
 332 }
 333 #endif /* CLIB_MARCH_VARIANT */
 334
 335 static clib_error_t *
 336 ip4_punt_redirect_cmd (vlib_main_t * vm,
 337                        unformat_input_t * main_input,
 338                        vlib_cli_command_t * cmd)
 339 {
 340   unformat_input_t _line_input, *line_input = &_line_input;
 341   fib_route_path_t *rpaths = NULL, rpath;
 342   dpo_proto_t payload_proto = DPO_PROTO_IP4;
 343   clib_error_t *error = 0;
 344   u32 rx_sw_if_index = ~0;
 345   vnet_main_t *vnm;
 346   u8 is_add;
 347
 348   is_add = 1;
 349   vnm = vnet_get_main ();
 350
 351   if (!unformat_user (main_input, unformat_line_input, line_input))
 352     return 0;
 353
 354   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 355     {
 356       if (unformat (line_input, "del"))
 357         is_add = 0;
 358       else if (unformat (line_input, "add"))
 359         is_add = 1;
 360       else if (unformat (line_input, "rx all"))
 361         rx_sw_if_index = 0;
 362       else if (unformat (line_input, "rx %U",
 363                          unformat_vnet_sw_interface, vnm, &rx_sw_if_index))
 364         ;
 365       else if (unformat (line_input, "via %U", unformat_fib_route_path, &rpath,
 366                          &payload_proto))
 367         vec_add1 (rpaths, rpath);
 368       else
 369         {
 370           error = unformat_parse_error (line_input);
 371           goto done;
 372         }
 373     }
 374
 375   if (~0 == rx_sw_if_index)
 376     {
 377       error = unformat_parse_error (line_input);
 378       goto done;
 379     }
 380
 381   if (is_add)
 382     {
 383       if (vec_len (rpaths))
 384         ip4_punt_redirect_add_paths (rx_sw_if_index, rpaths);
 385     }
 386   else
 387     {
 388       ip4_punt_redirect_del (rx_sw_if_index);
 389     }
 390
 391 done:
 392   vec_free (rpaths);
 393   unformat_free (line_input);
 394   return (error);
 395 }
 396
 397 /*?
 398  *
 399  * @cliexpar
 400  * @cliexcmd{set ip punt policer}
 401  ?*/
 402 /* *INDENT-OFF* */
 403 VLIB_CLI_COMMAND (ip4_punt_redirect_command, static) =
 404 {
 405   .path = "ip punt redirect",
 406   .function = ip4_punt_redirect_cmd,
 407   .short_help = "ip punt redirect [add|del] rx [<interface>|all] via [<nh>] <tx_interface>",
 408 };
 409 /* *INDENT-ON* */
 410
 411 static clib_error_t *
 412 ip4_punt_redirect_show_cmd (vlib_main_t * vm,
 413                             unformat_input_t * main_input,
 414                             vlib_cli_command_t * cmd)
 415 {
 416   vlib_cli_output (vm, "%U", format_ip_punt_redirect, FIB_PROTOCOL_IP4);
 417
 418   return (NULL);
 419 }
 420
 421 /*?
 422  *
 423  * @cliexpar
 424  * @cliexcmd{set ip punt redierect}
 425  ?*/
 426 /* *INDENT-OFF* */
 427 VLIB_CLI_COMMAND (show_ip4_punt_redirect_command, static) =
 428 {
 429   .path = "show ip punt redirect",
 430   .function = ip4_punt_redirect_show_cmd,
 431   .short_help = "show ip punt redirect",
 432   .is_mp_safe = 1,
 433 };
 434 /* *INDENT-ON* */
 435
 436 /*
 437  * fd.io coding-style-patch-verification: ON
 438  *
 439  * Local Variables:
 440  * eval: (c-set-style "gnu")
 441  * End:
 442  */