src/plugins/mdata/mdata.c

   1 /*
   2  * mdata.c - Buffer metadata change tracker
   3  *
   4  * Copyright (c) 2019 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/plugin/plugin.h>
  20 #include <mdata/mdata.h>
  21
  22 #include <vlibapi/api.h>
  23 #include <vlibmemory/api.h>
  24 #include <vppinfra/callback_data.h>
  25 #include <vpp/app/version.h>
  26 #include <stdbool.h>
  27
  28 #include <mdata/mdata.api_enum.h>
  29 #include <mdata/mdata.api_types.h>
  30
  31 #define REPLY_MSG_ID_BASE mmp->msg_id_base
  32 #include <vlibapi/api_helper_macros.h>
  33
  34 mdata_main_t mdata_main;
  35
  36 /** @file mdata.c
  37  * buffer metadata change tracker
  38  */
  39
  40 static mdata_t mdata_none;
  41
  42 /** Metadata tracking callback
  43     before_or_after: 0 => before, 1=> after
  44 */
  45 static void
  46 mdata_trace_callback (vlib_node_runtime_perf_callback_data_t * data,
  47                       vlib_node_runtime_perf_callback_args_t * args)
  48 {
  49   int i;
  50   mdata_main_t *mm = &mdata_main;
  51   vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
  52   u32 *from;
  53   u32 n_left_from;
  54   mdata_t *before, *modifies;
  55   u8 *after;
  56   vlib_main_t *vm = args->vm;
  57   vlib_frame_t *frame = args->frame;
  58   vlib_node_runtime_t *node = args->node;
  59
  60   if (PREDICT_FALSE (args->call_type == VLIB_NODE_RUNTIME_PERF_RESET))
  61     return;
  62
  63   /* Input nodes don't have frames, etc. */
  64   if (frame == 0)
  65     return;
  66
  67   n_left_from = frame->n_vectors;
  68
  69   if (n_left_from == 0)
  70     return;
  71
  72   from = vlib_frame_vector_args (frame);
  73
  74   vlib_get_buffers (vm, from, bufs, n_left_from);
  75   b = bufs;
  76
  77   if (args->call_type == VLIB_NODE_RUNTIME_PERF_AFTER)
  78     goto after_pass;
  79
  80   /* Resize the per-thread "before" vector to cover the current frame */
  81   vec_reset_length (mm->before_per_thread[vm->thread_index]);
  82   vec_validate (mm->before_per_thread[vm->thread_index], n_left_from - 1);
  83   before = mm->before_per_thread[vm->thread_index];
  84   before->node_index = ~0;
  85
  86   /* Before we call the dispatch fn, copy metadata. */
  87   while (n_left_from > 0)
  88     {
  89       clib_memcpy_fast (before->mdata, b[0], sizeof (before->mdata));
  90       b++;
  91       before++;
  92       n_left_from--;
  93     }
  94   return;
  95
  96 after_pass:
  97
  98   /* Recover the metadata copy we saved a moment ago */
  99   before = mm->before_per_thread[vm->thread_index];
 100
 101   /* We'd better have the same number of buffers... */
 102   ASSERT (n_left_from == vec_len (before));
 103   ASSERT (node->node_index);
 104
 105   clib_spinlock_lock_if_init (&mm->modify_lock);
 106
 107   /*
 108    * Resize the per-node accumulator vector as needed
 109    * Paint the "no data" patter across any nodes we haven't seen yet
 110    */
 111   vec_validate_init_empty (mm->modifies, node->node_index, mdata_none);
 112   modifies = vec_elt_at_index (mm->modifies, node->node_index);
 113   modifies->node_index = node->node_index;
 114   before = mm->before_per_thread[vm->thread_index];
 115
 116   /* Walk the frame */
 117   while (n_left_from > 0)
 118     {
 119       after = (u8 *) b[0];
 120
 121       /* Compare metadata before and after node dispatch fn */
 122       for (i = 0; i < ARRAY_LEN (before->mdata); i++)
 123         {
 124           /* Mark mdata octet changed */
 125           if (before->mdata[i] != after[i])
 126             modifies->mdata[i] = 0xff;
 127         }
 128
 129       b++;
 130       before++;
 131       n_left_from--;
 132     }
 133
 134   clib_spinlock_unlock_if_init (&mm->modify_lock);
 135 }
 136
 137 int
 138 mdata_enable_disable (mdata_main_t * mmp, int enable_disable)
 139 {
 140   int rv = 0;
 141   vlib_thread_main_t *thread_main = vlib_get_thread_main ();
 142   int i;
 143
 144   if (mmp->modify_lock == 0 && thread_main->n_vlib_mains > 1)
 145     clib_spinlock_init (&mmp->modify_lock);
 146
 147   if (vec_len (mmp->before_per_thread) == 0)
 148     {
 149       mdata_none.node_index = ~0;
 150       vec_validate (mmp->before_per_thread, vec_len (vlib_mains) - 1);
 151     }
 152
 153   /* Reset the per-node accumulator, see vec_validate_init_empty above */
 154   vec_reset_length (mmp->modifies);
 155
 156   for (i = 0; i < vec_len (vlib_mains); i++)
 157     {
 158       if (vlib_mains[i] == 0)
 159         continue;
 160
 161       clib_callback_data_enable_disable
 162         (&vlib_mains[i]->vlib_node_runtime_perf_callbacks,
 163          mdata_trace_callback, enable_disable);
 164     }
 165
 166   return rv;
 167 }
 168
 169 static clib_error_t *
 170 mdata_enable_disable_command_fn (vlib_main_t * vm,
 171                                  unformat_input_t * input,
 172                                  vlib_cli_command_t * cmd)
 173 {
 174   mdata_main_t *mmp = &mdata_main;
 175   int enable_disable = 1;
 176
 177   int rv;
 178
 179   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 180     {
 181       if (unformat (input, "disable") || unformat (input, "off"))
 182         enable_disable = 0;
 183       if (unformat (input, "enable") || unformat (input, "on"))
 184         enable_disable = 1;
 185       else
 186         break;
 187     }
 188
 189   rv = mdata_enable_disable (mmp, enable_disable);
 190
 191   switch (rv)
 192     {
 193     case 0:
 194       break;
 195
 196     default:
 197       return clib_error_return (0, "mdata_enable_disable returned %d", rv);
 198     }
 199   return 0;
 200 }
 201
 202 /*?
 203  * This command enables or disables buffer metadata change tracking
 204  *
 205  *@cliexpar
 206  * To enable buffer metadata change tracking:
 207  *@cliexstart{buffer metadata tracking on}
 208  * Tracking enabled
 209  *@cliexend
 210  *
 211  *@cliexstart{buffer metadata tracking off}
 212  * Tracking disabled
 213  *@cliexend
 214 ?*/
 215
 216 /* *INDENT-OFF* */
 217 VLIB_CLI_COMMAND (mdata_enable_disable_command, static) =
 218 {
 219   .path = "buffer metadata tracking",
 220   .short_help = "buffer metadata tracking [on][off]",
 221   .function = mdata_enable_disable_command_fn,
 222 };
 223 /* *INDENT-ON* */
 224
 225 /* API message handler */
 226 static void vl_api_mdata_enable_disable_t_handler
 227   (vl_api_mdata_enable_disable_t * mp)
 228 {
 229   vl_api_mdata_enable_disable_reply_t *rmp;
 230   mdata_main_t *mmp = &mdata_main;
 231   int rv;
 232
 233   rv = mdata_enable_disable (mmp, (int) (mp->enable_disable));
 234
 235   REPLY_MACRO (VL_API_MDATA_ENABLE_DISABLE_REPLY);
 236 }
 237
 238 /* API definitions */
 239 #include <mdata/mdata.api.c>
 240
 241 static clib_error_t *
 242 mdata_init (vlib_main_t * vm)
 243 {
 244   mdata_main_t *mmp = &mdata_main;
 245   clib_error_t *error = 0;
 246
 247   mmp->vlib_main = vm;
 248   mmp->vnet_main = vnet_get_main ();
 249
 250   /* Add our API messages to the global name_crc hash table */
 251   mmp->msg_id_base = setup_message_id_table ();
 252
 253   return error;
 254 }
 255
 256 VLIB_INIT_FUNCTION (mdata_init);
 257
 258 /* *INDENT-OFF* */
 259 VLIB_PLUGIN_REGISTER () =
 260 {
 261   .version = VPP_BUILD_VER,
 262   .description = "Buffer metadata change tracker."
 263 };
 264 /* *INDENT-ON* */
 265
 266
 267 #define foreach_primary_metadata_field          \
 268 _(current_data)                                 \
 269 _(current_length)                               \
 270 _(flags)                                        \
 271 _(flow_id)                                      \
 272 _(ref_count)                                    \
 273 _(buffer_pool_index)                            \
 274 _(error)                                        \
 275 _(next_buffer)                                  \
 276 _(current_config_index)                         \
 277 _(punt_reason)
 278
 279 #define foreach_opaque_metadata_field           \
 280 _(sw_if_index[0])                               \
 281 _(sw_if_index[1])                               \
 282 _(l2_hdr_offset)                                \
 283 _(l3_hdr_offset)                                \
 284 _(l4_hdr_offset)                                \
 285 _(feature_arc_index)                            \
 286 _(ip.adj_index[0])                              \
 287 _(ip.adj_index[1])                              \
 288 _(ip.flow_hash)                                 \
 289 _(ip.save_protocol)                             \
 290 _(ip.fib_index)                                 \
 291 _(ip.icmp.type)                                 \
 292 _(ip.icmp.code)                                 \
 293 _(ip.icmp.data)                                 \
 294 _(ip.reass.next_index)                          \
 295 _(ip.reass.error_next_index)                    \
 296 _(ip.reass.owner_thread_index)                  \
 297 _(ip.reass.ip_proto)                            \
 298 _(ip.reass.l4_src_port)                         \
 299 _(ip.reass.l4_dst_port)                         \
 300 _(ip.reass.estimated_mtu)                       \
 301 _(ip.reass.fragment_first)                      \
 302 _(ip.reass.fragment_last)                       \
 303 _(ip.reass.range_first)                         \
 304 _(ip.reass.range_last)                          \
 305 _(ip.reass.next_range_bi)                       \
 306 _(ip.reass.ip6_frag_hdr_offset)                 \
 307 _(mpls.ttl)                                     \
 308 _(mpls.exp)                                     \
 309 _(mpls.first)                                   \
 310 _(mpls.save_rewrite_length)                     \
 311 _(mpls.mpls_hdr_length)                         \
 312 _(mpls.bier.n_bytes)                            \
 313 _(l2.feature_bitmap)                            \
 314 _(l2.bd_index)                                  \
 315 _(l2.l2fib_sn)                                  \
 316 _(l2.l2_len)                                    \
 317 _(l2.shg)                                       \
 318 _(l2.bd_age)                                    \
 319 _(l2t.next_index)                               \
 320 _(l2t.session_index)                            \
 321 _(l2_classify.table_index)                      \
 322 _(l2_classify.opaque_index)                     \
 323 _(l2_classify.hash)                             \
 324 _(policer.index)                                \
 325 _(ipsec.sad_index)                              \
 326 _(ipsec.protect_index)                          \
 327 _(map.mtu)                                      \
 328 _(map_t.map_domain_index)                       \
 329 _(map_t.v6.saddr)                               \
 330 _(map_t.v6.daddr)                               \
 331 _(map_t.v6.frag_offset)                         \
 332 _(map_t.v6.l4_offset)                           \
 333 _(map_t.v6.l4_protocol)                         \
 334 _(map_t.checksum_offset)                        \
 335 _(map_t.mtu)                                    \
 336 _(ip_frag.mtu)                                  \
 337 _(ip_frag.next_index)                           \
 338 _(ip_frag.flags)                                \
 339 _(cop.current_config_index)                     \
 340 _(lisp.overlay_afi)                             \
 341 _(tcp.connection_index)                         \
 342 _(tcp.seq_number)                               \
 343 _(tcp.next_node_opaque)                         \
 344 _(tcp.seq_end)                                  \
 345 _(tcp.ack_number)                               \
 346 _(tcp.hdr_offset)                               \
 347 _(tcp.data_offset)                              \
 348 _(tcp.data_len)                                 \
 349 _(tcp.flags)                                    \
 350 _(snat.flags)
 351
 352 #define foreach_opaque2_metadata_field          \
 353 _(qos.bits)                                     \
 354 _(qos.source)                                   \
 355 _(loop_counter)                                 \
 356 _(gbp.flags)                                    \
 357 _(gbp.sclass)                                   \
 358 _(gso_size)                                     \
 359 _(gso_l4_hdr_sz)                                \
 360 _(pg_replay_timestamp)
 361
 362 static u8 *
 363 format_buffer_metadata_changes (u8 * s, va_list * args)
 364 {
 365   mdata_main_t *mm = va_arg (*args, mdata_main_t *);
 366   int verbose = va_arg (*args, int);
 367   mdata_t *modifies;
 368   vlib_buffer_t *b;
 369   vnet_buffer_opaque_t *o;
 370   vnet_buffer_opaque2_t *o2;
 371   vlib_node_t *node;
 372   int i, j;
 373   int printed;
 374
 375   clib_spinlock_lock_if_init (&mm->modify_lock);
 376
 377   for (i = 0; i < vec_len (mm->modifies); i++)
 378     {
 379       modifies = vec_elt_at_index (mm->modifies, i);
 380       node = vlib_get_node (mm->vlib_main, i);
 381
 382       /* No data for this node? */
 383       if (modifies->node_index == ~0)
 384         {
 385           if (verbose)
 386             s = format (s, "\n%v: no data\n", node->name);
 387           continue;
 388         }
 389
 390       /* We visited the node, but it may not have changed any metadata... */
 391       for (j = 0; j < ARRAY_LEN (modifies->mdata); j++)
 392         {
 393           if (modifies->mdata[j])
 394             goto found;
 395         }
 396       s = format (s, "\n%v: no metadata changes\n", node->name);
 397       continue;
 398
 399     found:
 400       /* Fields which the node modifies will be non-zero */
 401       b = (vlib_buffer_t *) (modifies->mdata);
 402
 403       /* Dump primary metadata changes */
 404       s = format (s, "\n%v: ", node->name);
 405
 406       printed = 0;
 407 #define _(n) if (b->n) {s = format (s, "%s ", #n); printed = 1;}
 408       foreach_primary_metadata_field;
 409 #undef _
 410
 411       if (printed == 0)
 412         s = format (s, "no vlib_buffer_t metadata changes");
 413
 414       vec_add1 (s, '\n');
 415
 416       /*
 417        * Dump opaque union changes.
 418        * Hopefully this will give folks a clue about opaque
 419        * union data conflicts. That's the point of the exercise...
 420        */
 421       o = vnet_buffer (b);
 422       printed = 0;
 423       s = format (s, "  vnet_buffer_t: ");
 424
 425 #define _(n) if (o->n) {s = format (s, "%s ", #n); printed = 1;}
 426       foreach_opaque_metadata_field;
 427 #undef _
 428
 429       if (printed == 0)
 430         s = format (s, "no changes");
 431
 432       vec_add1 (s, '\n');
 433
 434       o2 = vnet_buffer2 (b);
 435       printed = 0;
 436       s = format (s, "  vnet_buffer2_t: ");
 437
 438 #define _(n) if (o2->n) {s = format (s, "%s ", #n); printed = 1;}
 439       foreach_opaque2_metadata_field;
 440 #undef _
 441       if (printed == 0)
 442         s = format (s, "no changes");
 443
 444       vec_add1 (s, '\n');
 445
 446     }
 447
 448   clib_spinlock_unlock_if_init (&mm->modify_lock);
 449
 450   return s;
 451 }
 452
 453 static clib_error_t *
 454 show_metadata_command_fn (vlib_main_t * vm,
 455                           unformat_input_t * input, vlib_cli_command_t * cmd)
 456 {
 457   int verbose = 0;
 458
 459   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 460     {
 461       if (unformat (input, "verbose %=", &verbose, 1))
 462         ;
 463       else
 464         break;
 465     }
 466
 467   vlib_cli_output (vm, "%U", format_buffer_metadata_changes, &mdata_main,
 468                    verbose);
 469   return 0;
 470 }
 471
 472 /*?
 473  * This command displays buffer metadata change information
 474  *@cliexpar
 475  * How to display buffer metadata change information
 476  *@cliexstart{show buffer metadata}
 477  * ethernet-input: current_data current_length flags error
 478  * vnet_buffer_t: l2_hdr_offset l3_hdr_offset
 479  * vnet_buffer2_t: no changes
 480  *@cliexend
 481 ?*/
 482
 483 /* *INDENT-OFF* */
 484 VLIB_CLI_COMMAND (show_metadata_command, static) =
 485 {
 486   .path = "show buffer metadata",
 487   .short_help = "show buffer metadata",
 488   .function = show_metadata_command_fn,
 489 };
 490 /* *INDENT-OFF* */
 491
 492 /*
 493  * fd.io coding-style-patch-verification: ON
 494  *
 495  * Local Variables:
 496  * eval: (c-set-style "gnu")
 497  * End:
 498  */