src/vlibapi/node_serialize.c

   1 /*
   2  * Copyright (c) 2016 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 #include <vlib/vlib.h>
  16
  17 #include <vppinfra/serialize.h>
  18
  19 /* serialized representation of state strings */
  20
  21 #define foreach_state_string_code               \
  22 _(STATE_DONE, "done")                           \
  23 _(STATE_DISABLED, "disabled")                   \
  24 _(STATE_TIME_WAIT, "time wait")                 \
  25 _(STATE_EVENT_WAIT, "event wait")               \
  26 _(STATE_ANY_WAIT, "any wait")                   \
  27 _(STATE_POLLING, "polling")                     \
  28 _(STATE_INTERRUPT_WAIT, "interrupt wait")       \
  29 _(STATE_INTERNAL, "internal")
  30
  31 typedef enum
  32 {
  33 #define _(a,b) a,
  34   foreach_state_string_code
  35 #undef _
  36 } state_string_enum_t;
  37
  38 static char *state_strings[] = {
  39 #define _(a,b) b,
  40   foreach_state_string_code
  41 #undef _
  42 };
  43
  44 /*
  45  * Serialize a vlib_node_main_t. Appends the result to vector.
  46  * Pass 0 to create a new vector, use vec_reset_length(vector)
  47  * to recycle a vector / avoid memory allocation, etc.
  48  * Switch heaps before/after to serialize into API client shared memory.
  49  */
  50 u8 *
  51 vlib_node_serialize (vlib_main_t * vm, vlib_node_t *** node_dups, u8 * vector,
  52                      int include_nexts, int include_stats)
  53 {
  54   serialize_main_t _sm, *sm = &_sm;
  55   vlib_node_t *n;
  56   vlib_node_t **nodes;
  57   u8 *namep;
  58   u32 name_bytes;
  59   uword i, j, k;
  60   u64 l, v, c, d, pmc;
  61   state_string_enum_t state_code;
  62
  63   serialize_open_vector (sm, vector);
  64   serialize_likely_small_unsigned_integer (sm, vec_len (node_dups));
  65
  66   for (j = 0; j < vec_len (node_dups); j++)
  67     {
  68       nodes = node_dups[j];
  69
  70       serialize_likely_small_unsigned_integer (sm, vec_len (nodes));
  71
  72       for (i = 0; i < vec_len (nodes); i++)
  73         {
  74           n = nodes[i];
  75
  76           l = n->stats_total.clocks - n->stats_last_clear.clocks;
  77           v = n->stats_total.vectors - n->stats_last_clear.vectors;
  78           c = n->stats_total.calls - n->stats_last_clear.calls;
  79           d = n->stats_total.suspends - n->stats_last_clear.suspends;
  80           pmc = n->stats_total.perf_counter_ticks
  81             - n->stats_last_clear.perf_counter_ticks;
  82
  83           state_code = STATE_INTERNAL;
  84
  85           if (n->type == VLIB_NODE_TYPE_PROCESS)
  86             {
  87               vlib_process_t *p = vlib_get_process_from_node (vm, n);
  88
  89               switch (p->flags
  90                       & (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK
  91                          | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT))
  92                 {
  93                 default:
  94                   if (!(p->flags & VLIB_PROCESS_IS_RUNNING))
  95                     state_code = STATE_DONE;
  96                   break;
  97
  98                 case VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK:
  99                   state_code = STATE_TIME_WAIT;
 100                   break;
 101
 102                 case VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT:
 103                   state_code = STATE_EVENT_WAIT;
 104                   break;
 105
 106                 case (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK):
 107                   state_code =
 108                     STATE_ANY_WAIT;
 109                   break;
 110                 }
 111             }
 112           else if (n->type != VLIB_NODE_TYPE_INTERNAL)
 113             {
 114               state_code = STATE_POLLING;
 115               if (n->state == VLIB_NODE_STATE_DISABLED)
 116                 state_code = STATE_DISABLED;
 117               else if (n->state == VLIB_NODE_STATE_INTERRUPT)
 118                 state_code = STATE_INTERRUPT_WAIT;
 119             }
 120
 121           /* See unserialize_cstring */
 122           name_bytes = vec_len (n->name);
 123           serialize_likely_small_unsigned_integer (sm, name_bytes);
 124           namep = serialize_get (sm, name_bytes);
 125           memcpy (namep, n->name, name_bytes);
 126
 127           serialize_likely_small_unsigned_integer (sm, (u64) state_code);
 128           serialize_likely_small_unsigned_integer (sm, n->type);
 129           serialize_likely_small_unsigned_integer (sm, n->flags);
 130
 131           if (include_nexts)
 132             {
 133               serialize_likely_small_unsigned_integer
 134                 (sm, vec_len (n->next_nodes));
 135               for (k = 0; k < vec_len (n->next_nodes); k++)
 136                 serialize_likely_small_unsigned_integer (sm,
 137                                                          n->next_nodes[k]);
 138             }
 139           else
 140             serialize_likely_small_unsigned_integer (sm, 0);
 141
 142           if (include_stats)
 143             {
 144               /* stats present */
 145               serialize_likely_small_unsigned_integer (sm, 1);
 146               /* total clocks */
 147               serialize_integer (sm, l, 8);
 148               /* Total calls */
 149               serialize_integer (sm, c, 8);
 150               /* Total vectors */
 151               serialize_integer (sm, v, 8);
 152               /* Total suspends */
 153               serialize_integer (sm, d, 8);
 154               /* PMC counter */
 155               serialize_integer (sm, pmc, 8);
 156             }
 157           else                  /* no stats */
 158             serialize_likely_small_unsigned_integer (sm, 0);
 159         }
 160     }
 161   return (serialize_close_vector (sm));
 162 }
 163
 164 vlib_node_t ***
 165 vlib_node_unserialize (u8 * vector)
 166 {
 167   serialize_main_t _sm, *sm = &_sm;
 168   u32 nnodes, nnexts;
 169   u32 nstat_vms;
 170   vlib_node_t *node;
 171   vlib_node_t **nodes;
 172   vlib_node_t ***nodes_by_thread = 0;
 173   int i, j, k;
 174   u64 l, v, c, d, pmc;
 175   state_string_enum_t state_code;
 176   int stats_present;
 177
 178   serialize_open_vector (sm, vector);
 179
 180   nstat_vms = unserialize_likely_small_unsigned_integer (sm);
 181
 182   vec_validate (nodes_by_thread, nstat_vms - 1);
 183   _vec_len (nodes_by_thread) = 0;
 184
 185   for (i = 0; i < nstat_vms; i++)
 186     {
 187       nnodes = unserialize_likely_small_unsigned_integer (sm);
 188
 189       nodes = 0;
 190       vec_validate (nodes, nnodes - 1);
 191       vec_add1 (nodes_by_thread, nodes);
 192
 193       for (j = 0; j < nnodes; j++)
 194         {
 195           node = 0;
 196           vec_validate (node, 0);
 197           nodes[j] = node;
 198
 199           unserialize_cstring (sm, (char **) &(node->name));
 200           state_code = unserialize_likely_small_unsigned_integer (sm);
 201           node->state_string = (u8 *) state_strings[state_code];
 202
 203           node->type = unserialize_likely_small_unsigned_integer (sm);
 204           node->flags = unserialize_likely_small_unsigned_integer (sm);
 205           nnexts = unserialize_likely_small_unsigned_integer (sm);
 206           if (nnexts > 0)
 207             vec_validate (node->next_nodes, nnexts - 1);
 208           for (k = 0; k < nnexts; k++)
 209             node->next_nodes[k] =
 210               unserialize_likely_small_unsigned_integer (sm);
 211
 212           stats_present = unserialize_likely_small_unsigned_integer (sm);
 213
 214           if (stats_present)
 215             {
 216               /* total clocks */
 217               unserialize_integer (sm, &l, 8);
 218               node->stats_total.clocks = l;
 219               node->stats_last_clear.clocks = 0;
 220
 221               /* Total calls */
 222               unserialize_integer (sm, &c, 8);
 223               node->stats_total.calls = c;
 224
 225               /* Total vectors */
 226               unserialize_integer (sm, &v, 8);
 227               node->stats_total.vectors = v;
 228
 229               /* Total suspends */
 230               unserialize_integer (sm, &d, 8);
 231               node->stats_total.suspends = d;
 232               /* PMC counter */
 233               unserialize_integer (sm, &pmc, 8);
 234               node->stats_total.perf_counter_ticks = pmc;
 235             }
 236         }
 237     }
 238   return nodes_by_thread;
 239 }
 240
 241 #if TEST_CODE
 242
 243 static clib_error_t *
 244 test_node_serialize_command_fn (vlib_main_t * vm,
 245                                 unformat_input_t * input,
 246                                 vlib_cli_command_t * cmd)
 247 {
 248   vlib_node_main_t *nm = &vm->node_main;
 249   u8 *vector = 0;
 250   vlib_node_t ***nodes_by_thread;
 251   vlib_node_t **nodes;
 252   vlib_node_t *node;
 253   vlib_node_t *next_node;
 254   int i, j, k;
 255   u32 max_threads = (u32) ~ 0;
 256   int include_nexts = 0;
 257   int include_stats = 0;
 258
 259   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 260     {
 261       if (unformat (input, "max-threads %d", &max_threads))
 262         ;
 263       else if (unformat (input, "stats"))
 264         include_stats = 1;
 265       else if (unformat (input, "nexts"))
 266         include_nexts = 1;
 267       else
 268         break;
 269     }
 270
 271   /*
 272    * Keep the number of memcpy ops to a minimum (e.g. 1).
 273    * The current size of the serialized vector is
 274    * slightly under 4K.
 275    */
 276   vec_validate (vector, 16383);
 277   vec_reset_length (vector);
 278
 279   vector = vlib_node_serialize (nm, vector, max_threads,
 280                                 include_nexts, include_stats);
 281
 282   vlib_cli_output (vm, "result vector %d bytes", vec_len (vector));
 283
 284   nodes_by_thread = vlib_node_unserialize (vector);
 285
 286   vec_free (vector);
 287
 288   for (i = 0; i < vec_len (nodes_by_thread); i++)
 289     {
 290       nodes = nodes_by_thread[i];
 291
 292       vlib_cli_output (vm, "thread %d", i);
 293
 294       for (j = 0; j < vec_len (nodes); j++)
 295         {
 296           node = nodes[j];
 297
 298           vlib_cli_output (vm, "[%d] %s state %s", j, node->name,
 299                            node->state_string);
 300
 301           vlib_cli_output
 302             (vm, "    clocks %lld calls %lld suspends"
 303              " %lld vectors %lld",
 304              node->stats_total.clocks,
 305              node->stats_total.calls,
 306              node->stats_total.suspends, node->stats_total.vectors);
 307
 308           for (k = 0; k < vec_len (node->next_nodes); k++)
 309             {
 310               if (node->next_nodes[k] != ~0)
 311                 {
 312                   next_node = nodes[node->next_nodes[k]];
 313                   vlib_cli_output (vm, "  [%d] %s", k, next_node->name);
 314                 }
 315             }
 316         }
 317     }
 318
 319   for (j = 0; j < vec_len (nodes_by_thread); j++)
 320     {
 321       nodes = nodes_by_thread[j];
 322
 323       for (i = 0; i < vec_len (nodes); i++)
 324         {
 325           vec_free (nodes[i]->name);
 326           vec_free (nodes[i]->next_nodes);
 327           vec_free (nodes[i]);
 328         }
 329       vec_free (nodes);
 330     }
 331   vec_free (nodes_by_thread);
 332
 333   return 0;
 334 }
 335
 336 /* *INDENT-OFF* */
 337 VLIB_CLI_COMMAND (test_node_serialize_node, static) = {
 338     .path = "test node serialize",
 339     .short_help = "test node serialize [max-threads NN] nexts stats",
 340     .function = test_node_serialize_command_fn,
 341 };
 342 /* *INDENT-ON* */
 343 #endif
 344
 345 /*
 346  * fd.io coding-style-patch-verification: ON
 347  *
 348  * Local Variables:
 349  * eval: (c-set-style "gnu")
 350  * End:
 351  */