graph_api.c

Go to the documentation of this file.

/* Hey Emacs use -*- mode: C -*- */
/*
 * Copyright 2020 Rubicon Communications, LLC.
 *
 * 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 <vnet/vnet.h>
#include <vlibmemory/api.h>

#include <tracedump/graph.api_enum.h>
#include <tracedump/graph.api_types.h>

#define REPLY_MSG_ID_BASE       gmp->msg_id_base
#include <vlibapi/api_helper_macros.h>

#include <tracedump/graph.h>


graph_main_t graph_main;


#define MIN(x,y)        (((x) < (y)) ? (x) : (y))


/*
 * If ever the graph or set of nodes changes, this cache of
 * nodes in sorted order should be invalidated.
 */
void
graph_node_invalid_cache (void)
{
  graph_main_t *gmp = &graph_main;

  vec_free (gmp->sorted_node_vec);
}


static clib_error_t *
graph_node_cache_reaper (u32 client_index)
{
  graph_node_invalid_cache ();
  return 0;
}

VL_MSG_API_REAPER_FUNCTION (graph_node_cache_reaper);


static void
send_graph_node_reply (vl_api_registration_t * rp,
                       u32 context, u32 retval, u32 cursor)
{
  graph_main_t *gmp = &graph_main;
  vl_api_graph_node_get_reply_t *rmp;

  rmp = vl_msg_api_alloc (sizeof (*rmp));
  rmp->_vl_msg_id = htons (VL_API_GRAPH_NODE_GET_REPLY + gmp->msg_id_base);
  rmp->context = context;
  rmp->retval = clib_host_to_net_u32 (retval);
  rmp->cursor = htonl (cursor);

  vl_api_send_msg (rp, (u8 *) rmp);
}


static void
send_graph_node_details (vlib_node_main_t * nm,
                         vl_api_registration_t * reg,
                         u32 context, vlib_node_t * n, bool want_arcs)
{
  graph_main_t *gmp = &graph_main;
  vl_api_graph_node_details_t *mp;
  u32 msg_size;

  msg_size = sizeof (*mp);
  if (want_arcs)
    msg_size += vec_len (n->next_nodes) * sizeof (*n->next_nodes);

  mp = vl_msg_api_alloc (msg_size);
  if (!mp)
    return;

  clib_memset (mp, 0, msg_size);

  mp->_vl_msg_id = htons (VL_API_GRAPH_NODE_DETAILS + gmp->msg_id_base);
  mp->context = context;
  mp->index = htonl (n->index);
  mp->flags = htonl (n->flags);

  clib_strncpy ((char *) mp->name, (char *) n->name,
                MIN (sizeof (mp->name) - 1, vec_len (n->name)));

  if (want_arcs)
    {
      int i;

      mp->n_arcs = htonl (vec_len (n->next_nodes));
      for (i = 0; i < vec_len (n->next_nodes); ++i)
        {
          mp->arcs_out[i] = htonl (n->next_nodes[i]);
        }
    }

  vl_api_send_msg (reg, (u8 *) mp);
}


static int
node_cmp (void *a1, void *a2)
{
  vlib_node_t **n1 = a1;
  vlib_node_t **n2 = a2;

  return vec_cmp (n1[0]->name, n2[0]->name);
}


/*
 * When cursor == ~0, it begins a request:
 *    if index != ~0, dump node with given index
 *    if index == ~0 and name[0] != 0, dump node with given name
 *    if index == ~0 and name[0] == 0, and flag != 0, dump flagged nodes
 *    else
 *        index == ~0 and name[0] == 0 and flag == 0, so dump all nodes.
 *
 * When cursor != ~0, it is the middle of a request:
 *    The same (index, name, and flag) parameters are assumed,
 *    The next results resume from cursor.
 */
static void
vl_api_graph_node_get_t_handler (vl_api_graph_node_get_t * mp)
{
  vl_api_registration_t *rp;

  rp = vl_api_client_index_to_registration (mp->client_index);
  if (!rp)
    return;

  vlib_main_t *vm = vlib_get_main ();
  vlib_node_main_t *nm = &vm->node_main;
  graph_main_t *gmp = &graph_main;
  vlib_node_t *n;
  u32 cursor;
  u32 node_index;
  bool want_arcs;

  want_arcs = ! !mp->want_arcs;
  cursor = ntohl (mp->cursor);
  n = 0;

  /*
   * Return details on a specific node by index?
   */
  node_index = ntohl (mp->index);
  if (cursor == ~0 && node_index != ~0)
    {
      if (node_index < vec_len (nm->nodes))
        n = vlib_get_node (vm, node_index);
      if (!n)
        {
          send_graph_node_reply (rp, mp->context,
                                 VNET_API_ERROR_NO_SUCH_ENTRY, ~0);
          return;
        }
      send_graph_node_details (nm, rp, mp->context, n, want_arcs);
      send_graph_node_reply (rp, mp->context, 0, ~0);
      return;
    }

  /*
   * Return details on a specific node by name?
   */
  if (cursor == ~0 && mp->name[0] != 0)
    {
      n = vlib_get_node_by_name (vm, (u8 *) mp->name);
      if (!n)
        {
          send_graph_node_reply (rp, mp->context,
                                 VNET_API_ERROR_NO_SUCH_ENTRY, ~0);
          return;
        }

      send_graph_node_details (nm, rp, mp->context, n, want_arcs);
      send_graph_node_reply (rp, mp->context, 0, ~0);
      return;
    }

  /*
   * Inspect all nodes, but potentially limit them by flag selection.
   * As iteration my need to occur over multiple streaming API calls,
   * determine the API client index and cache a sorted list of nodes.
   *
   * First time through, make a sorted node list and cache it.
   */
  vlib_node_t **nodes = gmp->sorted_node_vec;
  if (!nodes)
    {
      nodes = vec_dup (nm->nodes);
      vec_sort_with_function (nodes, node_cmp);
      gmp->sorted_node_vec = nodes;
    }

  u32 flags = ntohl (mp->flags);
  u32 first_index = (cursor == ~0) ? 0 : cursor;

  /* Don't overflow the existing queue space. */
  svm_queue_t *q = rp->vl_input_queue;
  u32 queue_slots_available = q->maxsize - q->cursize;
  int chunk = (queue_slots_available > 0) ? queue_slots_available - 1 : 0;
  u32 i;

  for (i = first_index; i < vec_len (nodes); ++i)
    {
      if (chunk-- == 0)
        {
          /*
           * Pick up again at cursor = i.
           */
          send_graph_node_reply (rp, mp->context, VNET_API_ERROR_EAGAIN, i);
          return;
        }

      n = nodes[i];
      if (flags == 0 || (n->flags & flags))
        {
          send_graph_node_details (nm, rp, mp->context, n, want_arcs);
        }
    }

  send_graph_node_reply (rp, mp->context, 0, ~0);
}


#include <vnet/format_fns.h>
#include <tracedump/graph.api.c>

static clib_error_t *
graph_api_hookup (vlib_main_t * vm)
{
  api_main_t *am = vlibapi_get_main ();
  graph_main_t *gmp = &graph_main;

  gmp->msg_id_base = setup_message_id_table ();

  am->is_mp_safe[gmp->msg_id_base + VL_API_GRAPH_NODE_GET] = 1;

  return 0;
}

VLIB_INIT_FUNCTION (graph_api_hookup);

/*
 * fd.io coding-style-patch-verification: ON
 *
 * Local Variables:
 * eval: (c-set-style "gnu")
 * End:
 */