vpp/vlib-api/vlibapi/node_serialize.c

/*
 * Copyright (c) 2016 Cisco and/or its affiliates.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#include <vlib/vlib.h>

#include <vppinfra/serialize.h>

extern void vl_msg_api_barrier_sync(void);
extern void vl_msg_api_barrier_release(void);

/* serialized representation of state strings */

#define foreach_state_string_code               \
_(STATE_DONE, "done")                           \
_(STATE_DISABLED, "disabled")                   \
_(STATE_TIME_WAIT, "time wait")                 \
_(STATE_EVENT_WAIT, "event wait")               \
_(STATE_ANY_WAIT, "any wait")                   \
_(STATE_POLLING, "polling")                     \
_(STATE_INTERRUPT_WAIT, "interrupt wait")       \
_(STATE_INTERNAL, "internal")

typedef enum {
#define _(a,b) a,
  foreach_state_string_code
#undef _
} state_string_enum_t;

static char *state_strings[] = 
  {
#define _(a,b) b,
    foreach_state_string_code
#undef _
  };

/* 
 * Serialize a vlib_node_main_t. Appends the result to vector.
 * Pass 0 to create a new vector, use vec_reset_length(vector)
 * to recycle a vector / avoid memory allocation, etc.
 * Switch heaps before/after to serialize into API client shared memory.
 */

u8 * vlib_node_serialize (vlib_node_main_t *nm, u8 * vector,
                          u32 max_threads, int include_nexts, 
                          int include_stats)
{
  serialize_main_t _sm, *sm=&_sm;
  vlib_main_t * vm = vlib_get_main();
  vlib_node_t * n;
  static vlib_node_t *** node_dups;
  vlib_node_t ** nodes;
  static vlib_main_t ** stat_vms;
  vlib_main_t *stat_vm;
  u8 * namep;
  u32 name_bytes;
  uword i, j, k;
  u64 l, v, c, d;
  state_string_enum_t state_code;
  u32 threads_to_serialize;
  
  vec_reset_length(node_dups);

  if (vec_len(stat_vms) == 0)
    {
      if (vec_len(vlib_mains) == 0)
        vec_add1 (stat_vms, vm);
      else
        {
          for (i = 0; i < vec_len (vlib_mains); i++)
            {
              stat_vm = vlib_mains[i];
              if (stat_vm)
                vec_add1 (stat_vms, stat_vm);
            }
        }
    }

  threads_to_serialize = clib_min (max_threads, vec_len (stat_vms));

  /* 
   * Barrier sync across stats scraping.
   * Otherwise, the counts will be grossly inaccurate.
   */
  vl_msg_api_barrier_sync();

  for (j = 0; j < threads_to_serialize; j++)
    {
      stat_vm = stat_vms[j];
      nm = &stat_vm->node_main;

      if (include_stats)
      {
          for (i = 0; i < vec_len (nm->nodes); i++)
          {
              n = nm->nodes[i];
              vlib_node_sync_stats (stat_vm, n);
          }
      }

      nodes = vec_dup (nm->nodes);
      
      vec_add1(node_dups, nodes);
    }
  vl_msg_api_barrier_release();
  
  serialize_open_vector (sm, vector);

  serialize_likely_small_unsigned_integer (sm, vec_len(stat_vms));
  
  for (j = 0; j < vec_len (stat_vms); j++)
    {
      stat_vm = stat_vms[j];
      nodes = node_dups[j];

      serialize_likely_small_unsigned_integer (sm, vec_len(nodes));

      for (i = 0; i < vec_len (nodes); i++)
        {
          n = nodes[i];

          l = n->stats_total.clocks - n->stats_last_clear.clocks;
          v = n->stats_total.vectors - n->stats_last_clear.vectors;
          c = n->stats_total.calls - n->stats_last_clear.calls;
          d = n->stats_total.suspends 
            - n->stats_last_clear.suspends;

          state_code = STATE_INTERNAL;

          if (n->type == VLIB_NODE_TYPE_PROCESS)
            {
              vlib_process_t * p = vlib_get_process_from_node (vm, n);

              switch (p->flags 
                      & (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK
                         | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT))
                {
                default:
                  if (! (p->flags & VLIB_PROCESS_IS_RUNNING))
                    state_code = STATE_DONE;
                  break;
                      
                case VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK:
                  state_code = STATE_TIME_WAIT;
                  break;

                case VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT:
                  state_code = STATE_EVENT_WAIT;
                  break;
                      
                case (VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_EVENT
                      | VLIB_PROCESS_IS_SUSPENDED_WAITING_FOR_CLOCK):
                  state_code = STATE_ANY_WAIT;
                  break;
                }
            }      
          else if (n->type != VLIB_NODE_TYPE_INTERNAL)
            {
              state_code = STATE_POLLING;
              if (n->state == VLIB_NODE_STATE_DISABLED)
                state_code = STATE_DISABLED;
              else if (n->state == VLIB_NODE_STATE_INTERRUPT)
                state_code = STATE_INTERRUPT_WAIT;
            }

          /* See unserialize_cstring */
          name_bytes = vec_len (n->name);
          serialize_likely_small_unsigned_integer(sm, name_bytes);
          namep = serialize_get (sm, name_bytes);
          memcpy (namep, n->name, name_bytes);

          serialize_likely_small_unsigned_integer (sm, (u64)state_code);
          serialize_likely_small_unsigned_integer (sm, n->type);

          if (include_nexts)
            {
              serialize_likely_small_unsigned_integer 
                (sm, vec_len(n->next_nodes));
              for (k = 0; k < vec_len (n->next_nodes); k++)
                serialize_likely_small_unsigned_integer (sm, n->next_nodes[k]);
            }
          else
            serialize_likely_small_unsigned_integer (sm, 0);
  
          if (include_stats)
            {
              /* stats present */
              serialize_likely_small_unsigned_integer (sm, 1);
              /* total clocks */
              serialize_integer(sm, l, 8);
              /* Total calls */
              serialize_integer(sm, c, 8);
              /* Total vectors */
              serialize_integer(sm, v, 8);
              /* Total suspends */
              serialize_integer(sm, d, 8);
            }
          else /* no stats */
            serialize_likely_small_unsigned_integer (sm, 0);
        }
      vec_free (nodes);
    }
  return (serialize_close_vector (sm));
}

vlib_node_t *** vlib_node_unserialize (u8 * vector)
{
  serialize_main_t _sm, *sm=&_sm;
  u32 nnodes, nnexts;
  u32 nstat_vms;
  vlib_node_t * node;
  vlib_node_t ** nodes;
  vlib_node_t *** nodes_by_thread = 0;
  int i, j, k;
  u64 l, v, c, d;
  state_string_enum_t state_code;
  int stats_present;

  serialize_open_vector (sm, vector);
  
  nstat_vms = unserialize_likely_small_unsigned_integer (sm);

  vec_validate (nodes_by_thread, nstat_vms - 1);
  _vec_len (nodes_by_thread) = 0;

  for (i = 0; i < nstat_vms; i++)
    {
      nnodes = unserialize_likely_small_unsigned_integer (sm);

      nodes = 0;
      vec_validate (nodes, nnodes-1);
      vec_add1 (nodes_by_thread, nodes);

      for (j = 0; j < nnodes; j++)
        {
          node = 0;
          vec_validate (node,0);
          nodes[j] = node;

          unserialize_cstring (sm, (char **)&(node->name));
          state_code = unserialize_likely_small_unsigned_integer (sm);
          node->state_string = (u8 *) state_strings[state_code];

          node->type = 
            unserialize_likely_small_unsigned_integer (sm);
          nnexts = unserialize_likely_small_unsigned_integer (sm);
          if (nnexts > 0)
            vec_validate (node->next_nodes, nnexts-1);
          for (k = 0; k < nnexts; k++)
            node->next_nodes[k] =
                unserialize_likely_small_unsigned_integer (sm);

          stats_present = unserialize_likely_small_unsigned_integer (sm);

          if (stats_present)
            {
              /* total clocks */
              unserialize_integer (sm, &l, 8);
              node->stats_total.clocks = l;
              node->stats_last_clear.clocks = 0;
              
              /* Total calls */
              unserialize_integer (sm, &c, 8);
              node->stats_total.calls = c;
              
              /* Total vectors */
              unserialize_integer (sm, &v, 8);
              node->stats_total.vectors = v;
              
              /* Total suspends */
              unserialize_integer (sm, &d, 8);
              node->stats_total.suspends = d;
            }
        }
    }
  return nodes_by_thread;    
}

#if CLIB_DEBUG > 0

static clib_error_t *
test_node_serialize_command_fn (vlib_main_t * vm,
		 unformat_input_t * input,
		 vlib_cli_command_t * cmd)
{
  vlib_node_main_t * nm = &vm->node_main;
  u8 * vector = 0;
  vlib_node_t *** nodes_by_thread;
  vlib_node_t ** nodes;
  vlib_node_t * node;
  vlib_node_t * next_node;
  int i, j, k;
  u32 max_threads = (u32) ~0;
  int include_nexts = 0;
  int include_stats = 0; 

  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) 
    {
      if (unformat (input, "max-threads %d", &max_threads))
        ;
      else if (unformat (input, "stats"))
        include_stats = 1;
      else if (unformat (input, "nexts"))
        include_nexts = 1;
      else
        break;
    }

  /* 
   * Keep the number of memcpy ops to a minimum (e.g. 1).
   * The current size of the serialized vector is
   * slightly under 4K.
   */
  vec_validate (vector, 16383);
  vec_reset_length (vector);

  vector = vlib_node_serialize (nm, vector, max_threads, 
                                include_nexts, include_stats);

  vlib_cli_output (vm, "result vector %d bytes", vec_len(vector));

  nodes_by_thread = vlib_node_unserialize (vector);

  vec_free (vector);
  
  for (i = 0; i < vec_len(nodes_by_thread); i++) 
    {
      nodes = nodes_by_thread[i];

      vlib_cli_output (vm, "thread %d", i);

      for (j = 0; j < vec_len(nodes); j++)
        {
          node = nodes[j];

          vlib_cli_output (vm, "[%d] %s state %s", j, node->name,
                           node->state_string);

          vlib_cli_output 
            (vm, "    clocks %lld calls %lld suspends"
             " %lld vectors %lld",
             node->stats_total.clocks,
             node->stats_total.calls,
             node->stats_total.suspends,
             node->stats_total.vectors);

          for (k = 0; k < vec_len (node->next_nodes); k++)
            {
              if (node->next_nodes[k] != ~0)
                next_node = nodes[node->next_nodes[k]];
              vlib_cli_output (vm, "  [%d] %s", k, next_node->name);
            }
        }
  }

  for (j = 0; j < vec_len(nodes_by_thread); j++)
    {
      nodes = nodes_by_thread[j];

      for (i = 0; i < vec_len(nodes); i++) 
        {
          vec_free (nodes[i]->name);
          vec_free (nodes[i]->next_nodes);
          vec_free (nodes[i]);
        }
      vec_free(nodes);
    }
  vec_free (nodes_by_thread);

  return 0;
}

VLIB_CLI_COMMAND (test_node_serialize_node, static) = {
    .path = "test node serialize",
    .short_help = "test node serialize [max-threads NN] nexts stats",
    .function = test_node_serialize_command_fn,
};
#endif