src/vnet/qos/qos_mark.c

   1 /*
   2  * Copyright (c) 2018 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/feature/feature.h>
  18 #include <vnet/qos/qos_egress_map.h>
  19 #include <vnet/qos/qos_mark.h>
  20
  21 /**
  22  * per-interface vector of which MAP is used by which interface
  23  * for each output source
  24  */
  25 index_t *qos_mark_configs[QOS_N_SOURCES];
  26
  27 void
  28 qos_mark_ip_enable_disable (u32 sw_if_index, u8 enable)
  29 {
  30   vnet_feature_enable_disable ("ip6-output", "ip6-qos-mark",
  31                                sw_if_index, enable, NULL, 0);
  32   vnet_feature_enable_disable ("ip4-output", "ip4-qos-mark",
  33                                sw_if_index, enable, NULL, 0);
  34 }
  35
  36 void
  37 qos_mark_vlan_enable_disable (u32 sw_if_index, u8 enable)
  38 {
  39   vnet_feature_enable_disable ("interface-output", "vlan-qos-mark",
  40                                sw_if_index, enable, NULL, 0);
  41 }
  42
  43 void
  44 qos_mark_mpls_enable_disable (u32 sw_if_index, u8 enable)
  45 {
  46   vnet_feature_enable_disable ("mpls-output", "mpls-qos-mark",
  47                                sw_if_index, enable, NULL, 0);
  48 }
  49
  50 static void
  51 qos_egress_map_feature_config (u32 sw_if_index, qos_source_t qs, u8 enable)
  52 {
  53   switch (qs)
  54     {
  55     case QOS_SOURCE_EXT:
  56       ASSERT (0);
  57       break;
  58     case QOS_SOURCE_VLAN:
  59       qos_mark_vlan_enable_disable (sw_if_index, enable);
  60       break;
  61     case QOS_SOURCE_MPLS:
  62       qos_mark_mpls_enable_disable (sw_if_index, enable);
  63       break;
  64     case QOS_SOURCE_IP:
  65       qos_mark_ip_enable_disable (sw_if_index, enable);
  66       break;
  67     }
  68 }
  69
  70 always_inline qos_egress_map_t *
  71 qos_egress_map_interface (u32 sw_if_index, qos_source_t output_source)
  72 {
  73   ASSERT (vec_len (qos_mark_configs[output_source]) > sw_if_index);
  74
  75   return pool_elt_at_index (qem_pool,
  76                             qos_mark_configs[output_source][sw_if_index]);
  77 }
  78
  79 /**
  80  * per-packet trace data
  81  */
  82 typedef struct qos_mark_trace_t_
  83 {
  84   /* per-pkt trace data */
  85   qos_bits_t bits;
  86   qos_source_t input;
  87   u32 used;
  88 } qos_mark_trace_t;
  89
  90 static inline uword
  91 qos_mark_inline (vlib_main_t * vm,
  92                  vlib_node_runtime_t * node,
  93                  vlib_frame_t * frame, qos_source_t output_source, int is_ip6)
  94 {
  95   u32 n_left_from, *from, *to_next, next_index;
  96
  97   next_index = 0;
  98   n_left_from = frame->n_vectors;
  99   from = vlib_frame_vector_args (frame);
 100
 101   while (n_left_from > 0)
 102     {
 103       u32 n_left_to_next;
 104
 105       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 106
 107       while (n_left_from > 0 && n_left_to_next > 0)
 108         {
 109           qos_source_t input_source0;
 110           ethernet_vlan_header_t *vlan0;
 111           u32 sw_if_index0, next0, bi0;
 112           qos_egress_map_t *qem0;
 113           ip4_header_t *ip4_0;
 114           ip6_header_t *ip6_0;
 115           vlib_buffer_t *b0;
 116           qos_bits_t qos0;
 117           u8 *mpls_bytes_0;
 118           u8 eos0;
 119
 120           next0 = 0;
 121           bi0 = from[0];
 122           to_next[0] = bi0;
 123           from += 1;
 124           to_next += 1;
 125           n_left_from -= 1;
 126           n_left_to_next -= 1;
 127
 128           b0 = vlib_get_buffer (vm, bi0);
 129           sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_TX];
 130           input_source0 = vnet_buffer2 (b0)->qos.source;
 131
 132           qem0 = qos_egress_map_interface (sw_if_index0, output_source);
 133           qos0 = qem0->qem_output[input_source0][vnet_buffer2 (b0)->qos.bits];
 134
 135           if (PREDICT_TRUE (b0->flags & VNET_BUFFER_F_QOS_DATA_VALID))
 136             {
 137               /* there is a source of QoS recording for this packet */
 138               if (QOS_SOURCE_IP == output_source)
 139                 {
 140                   if (is_ip6)
 141                     {
 142                       ip6_0 = (vlib_buffer_get_current (b0) +
 143                                vnet_buffer (b0)->ip.save_rewrite_length);
 144
 145                       ip6_set_traffic_class_network_order (ip6_0, qos0);
 146                     }
 147                   else
 148                     {
 149                       ip4_0 = (vlib_buffer_get_current (b0) +
 150                                vnet_buffer (b0)->ip.save_rewrite_length);
 151                       if (PREDICT_FALSE (qos0 != ip4_0->tos))
 152                         {
 153                           ip4_0->tos = qos0;
 154                           ip4_0->checksum = ip4_header_checksum (ip4_0);
 155                         }
 156                     }
 157                 }
 158               else if (QOS_SOURCE_MPLS == output_source)
 159                 {
 160                   mpls_bytes_0 = (vlib_buffer_get_current (b0) +
 161                                   vnet_buffer (b0)->mpls.save_rewrite_length);
 162
 163                   /* apply to all the labels in the stack */
 164                   do
 165                     {
 166                       /* clear out the old COS bts */
 167                       mpls_bytes_0[2] &= 0xf1;
 168                       /* OR in 3 bits of the mapped value */
 169                       mpls_bytes_0[2] |= (qos0 & 0x7) << 1;
 170                       eos0 = mpls_bytes_0[2] & 0x1;
 171                       mpls_bytes_0 += 4;
 172                     }
 173                   while (!eos0);
 174                 }
 175               else if (QOS_SOURCE_VLAN == output_source)
 176                 {
 177                   vlan0 = (vlib_buffer_get_current (b0) +
 178                            sizeof (ethernet_header_t));
 179
 180                   ethernet_vlan_header_set_priority_net_order (vlan0, qos0);
 181                 }
 182             }
 183           vnet_feature_next (sw_if_index0, &next0, b0);
 184
 185           if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
 186             {
 187               qos_mark_trace_t *t =
 188                 vlib_add_trace (vm, node, b0, sizeof (*t));
 189               t->bits = qos0;
 190               t->input = input_source0;
 191               t->used = (b0->flags & VNET_BUFFER_F_QOS_DATA_VALID);
 192             }
 193
 194           /* verify speculative enqueue, maybe switch current next frame */
 195           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 196                                            to_next, n_left_to_next,
 197                                            bi0, next0);
 198         }
 199
 200       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 201     }
 202
 203   return frame->n_vectors;
 204 }
 205
 206 /* packet trace format function */
 207 static u8 *
 208 format_qos_mark_trace (u8 * s, va_list * args)
 209 {
 210   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
 211   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
 212   qos_mark_trace_t *t = va_arg (*args, qos_mark_trace_t *);
 213
 214   s = format (s, "source:%U qos:%d used:%s",
 215               format_qos_source, t->input, t->bits, (t->used ? "yes" : "no"));
 216
 217   return s;
 218 }
 219
 220 static inline uword
 221 ip4_qos_mark (vlib_main_t * vm, vlib_node_runtime_t * node,
 222               vlib_frame_t * frame)
 223 {
 224   return (qos_mark_inline (vm, node, frame, QOS_SOURCE_IP, 0));
 225 }
 226
 227 static inline uword
 228 ip6_qos_mark (vlib_main_t * vm, vlib_node_runtime_t * node,
 229               vlib_frame_t * frame)
 230 {
 231   return (qos_mark_inline (vm, node, frame, QOS_SOURCE_IP, 1));
 232 }
 233
 234 static inline uword
 235 mpls_qos_mark (vlib_main_t * vm, vlib_node_runtime_t * node,
 236                vlib_frame_t * frame)
 237 {
 238   return (qos_mark_inline (vm, node, frame, QOS_SOURCE_MPLS, 0));
 239 }
 240
 241 static inline uword
 242 vlan_qos_mark (vlib_main_t * vm, vlib_node_runtime_t * node,
 243                vlib_frame_t * frame)
 244 {
 245   return (qos_mark_inline (vm, node, frame, QOS_SOURCE_VLAN, 0));
 246 }
 247
 248 /* *INDENT-OFF* */
 249 VLIB_REGISTER_NODE (ip4_qos_mark_node) = {
 250   .function = ip4_qos_mark,
 251   .name = "ip4-qos-mark",
 252   .vector_size = sizeof (u32),
 253   .format_trace = format_qos_mark_trace,
 254   .type = VLIB_NODE_TYPE_INTERNAL,
 255
 256   .n_errors = 0,
 257   .n_next_nodes = 1,
 258
 259   .next_nodes = {
 260     [0] = "ip4-drop",
 261   },
 262 };
 263
 264 VLIB_NODE_FUNCTION_MULTIARCH (ip4_qos_mark_node, ip4_qos_mark);
 265
 266 VNET_FEATURE_INIT (ip4_qos_mark_node, static) = {
 267     .arc_name = "ip4-output",
 268     .node_name = "ip4-qos-mark",
 269 };
 270
 271 VLIB_REGISTER_NODE (ip6_qos_mark_node) = {
 272   .function = ip6_qos_mark,
 273   .name = "ip6-qos-mark",
 274   .vector_size = sizeof (u32),
 275   .format_trace = format_qos_mark_trace,
 276   .type = VLIB_NODE_TYPE_INTERNAL,
 277
 278   .n_errors = 0,
 279   .n_next_nodes = 1,
 280
 281   .next_nodes = {
 282     [0] = "ip6-drop",
 283   },
 284 };
 285
 286 VLIB_NODE_FUNCTION_MULTIARCH (ip6_qos_mark_node, ip6_qos_mark);
 287
 288 VNET_FEATURE_INIT (ip6_qos_mark_node, static) = {
 289     .arc_name = "ip6-output",
 290     .node_name = "ip6-qos-mark",
 291 };
 292
 293 VLIB_REGISTER_NODE (mpls_qos_mark_node) = {
 294   .function = mpls_qos_mark,
 295   .name = "mpls-qos-mark",
 296   .vector_size = sizeof (u32),
 297   .format_trace = format_qos_mark_trace,
 298   .type = VLIB_NODE_TYPE_INTERNAL,
 299
 300   .n_errors = 0,
 301   .n_next_nodes = 1,
 302
 303   .next_nodes = {
 304     [0] = "mpls-drop",
 305   },
 306 };
 307
 308 VLIB_NODE_FUNCTION_MULTIARCH (mpls_qos_mark_node, mpls_qos_mark);
 309
 310 VNET_FEATURE_INIT (mpls_qos_mark_node, static) = {
 311     .arc_name = "mpls-output",
 312     .node_name = "mpls-qos-mark",
 313 };
 314 VLIB_REGISTER_NODE (vlan_qos_mark_node) = {
 315   .function = vlan_qos_mark,
 316   .name = "vlan-qos-mark",
 317   .vector_size = sizeof (u32),
 318   .format_trace = format_qos_mark_trace,
 319   .type = VLIB_NODE_TYPE_INTERNAL,
 320
 321   .n_errors = 0,
 322   .n_next_nodes = 1,
 323
 324   .next_nodes = {
 325     [0] = "error-drop",
 326   },
 327 };
 328
 329 VLIB_NODE_FUNCTION_MULTIARCH (vlan_qos_mark_node, vlan_qos_mark);
 330
 331 VNET_FEATURE_INIT (vlan_qos_mark_node, static) = {
 332     .arc_name = "interface-output",
 333     .node_name = "vlan-qos-mark",
 334 };
 335 /* *INDENT-ON* */
 336
 337 int
 338 qos_mark_enable (u32 sw_if_index,
 339                  qos_source_t output_source, qos_egress_map_id_t mid)
 340 {
 341   index_t qemi;
 342
 343   vec_validate_init_empty (qos_mark_configs[output_source],
 344                            sw_if_index, INDEX_INVALID);
 345
 346   qemi = qos_egress_map_find (mid);
 347
 348   if (INDEX_INVALID == qemi)
 349     return VNET_API_ERROR_NO_SUCH_TABLE;
 350
 351   if (INDEX_INVALID == qos_mark_configs[output_source][sw_if_index])
 352     {
 353       qos_egress_map_feature_config (sw_if_index, output_source, 1);
 354     }
 355
 356   qos_mark_configs[output_source][sw_if_index] = qemi;
 357
 358   return (0);
 359 }
 360
 361 int
 362 qos_mark_disable (u32 sw_if_index, qos_source_t output_source)
 363 {
 364   if (vec_len (qos_mark_configs[output_source]) < sw_if_index)
 365     return VNET_API_ERROR_NO_MATCHING_INTERFACE;
 366   if (INDEX_INVALID == qos_mark_configs[output_source][sw_if_index])
 367     return VNET_API_ERROR_VALUE_EXIST;
 368
 369   if (INDEX_INVALID != qos_mark_configs[output_source][sw_if_index])
 370     {
 371       qos_egress_map_feature_config (sw_if_index, output_source, 0);
 372     }
 373
 374   qos_mark_configs[output_source][sw_if_index] = INDEX_INVALID;
 375
 376   return (0);
 377 }
 378
 379 static clib_error_t *
 380 qos_mark_cli (vlib_main_t * vm,
 381               unformat_input_t * input, vlib_cli_command_t * cmd)
 382 {
 383   qos_egress_map_id_t map_id;
 384   u32 sw_if_index, qs;
 385   vnet_main_t *vnm;
 386   int rv, enable;
 387
 388   vnm = vnet_get_main ();
 389   map_id = ~0;
 390   qs = 0xff;
 391   enable = 1;
 392
 393   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 394     {
 395       if (unformat (input, "id %d", &map_id))
 396         ;
 397       else if (unformat (input, "disable"))
 398         enable = 0;
 399       else if (unformat (input, "%U", unformat_qos_source, &qs))
 400         ;
 401       else if (unformat (input, "%U",
 402                          unformat_vnet_sw_interface, vnm, &sw_if_index))
 403         ;
 404       else
 405         break;
 406     }
 407
 408   if (~0 == sw_if_index)
 409     return clib_error_return (0, "interface must be specified");
 410   if (0xff == qs)
 411     return clib_error_return (0, "output location must be specified");
 412
 413   if (enable)
 414     rv = qos_mark_enable (sw_if_index, qs, map_id);
 415   else
 416     rv = qos_mark_disable (sw_if_index, qs);
 417
 418   if (0 == rv)
 419     return (NULL);
 420
 421   return clib_error_return (0, "Failed to map interface");
 422 }
 423
 424 /*?
 425  * Apply a QoS egress mapping table to an interface for QoS marking packets
 426  * at the given output protocol.
 427  *
 428  * @cliexpar
 429  * @cliexcmd{qos egress interface GigEthernet0/9/0 id 0 output ip}
 430  ?*/
 431 /* *INDENT-OFF* */
 432 VLIB_CLI_COMMAND (qos_egress_map_interface_command, static) = {
 433   .path = "qos mark",
 434   .short_help = "qos mark <SOURCE> <INTERFACE> id <MAP>",
 435   .function = qos_mark_cli,
 436   .is_mp_safe = 1,
 437 };
 438 /* *INDENT-ON* */
 439
 440 /*
 441  * fd.io coding-style-patch-verification: ON
 442  *
 443 * Local Variables:
 444 * eval: (c-set-style "gnu")
 445 * End:
 446 *
 447 */