fd-io-styleify pass

Change-Id: I72d0dff064162d11321257c858f68da1ba79ea48
Signed-off-by: Dave Barach <dave@barachs.net>

1 files changed, 956 insertions, 802 deletions

diff --git a/vlib-api/vlibapi/api_shared.c b/vlib-api/vlibapi/api_shared.c
index 0600e621a4e..18b189e1837 100644
--- a/vlib-api/vlibapi/api_shared.c
+++ b/vlib-api/vlibapi/api_shared.c
@@ -1,8 +1,8 @@
-/* 
+/*
  *------------------------------------------------------------------
  * api_shared.c - API message handling, common code for both clients
  * and the vlib process itself.
- * 
+ *
  *
  * Copyright (c) 2009 Cisco and/or its affiliates.
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -37,349 +37,394 @@
 
 api_main_t api_main;
 
-void vl_msg_api_barrier_sync(void) __attribute__((weak));
-void vl_msg_api_barrier_sync(void) { }
+void vl_msg_api_barrier_sync (void) __attribute__ ((weak));
+void
+vl_msg_api_barrier_sync (void)
+{
+}
 
-void vl_msg_api_barrier_release(void) __attribute__((weak));
-void vl_msg_api_barrier_release(void) { }
+void vl_msg_api_barrier_release (void) __attribute__ ((weak));
+void
+vl_msg_api_barrier_release (void)
+{
+}
 
-void vl_msg_api_increment_missing_client_counter(void)
+void
+vl_msg_api_increment_missing_client_counter (void)
 {
-    api_main_t * am = &api_main;
-    am->missing_clients++;
+  api_main_t *am = &api_main;
+  am->missing_clients++;
 }
 
-typedef enum {
-    DUMP, 
-    CUSTOM_DUMP,
-    REPLAY,
-    INITIALIZERS,
+typedef enum
+{
+  DUMP,
+  CUSTOM_DUMP,
+  REPLAY,
+  INITIALIZERS,
 } vl_api_replay_t;
 
-int vl_msg_api_rx_trace_enabled(api_main_t *am)
+int
+vl_msg_api_rx_trace_enabled (api_main_t * am)
 {
-    return (am->rx_trace && am->rx_trace->enabled);
+  return (am->rx_trace && am->rx_trace->enabled);
 }
 
-int vl_msg_api_tx_trace_enabled(api_main_t *am)
+int
+vl_msg_api_tx_trace_enabled (api_main_t * am)
 {
-    return (am->tx_trace && am->tx_trace->enabled);
+  return (am->tx_trace && am->tx_trace->enabled);
 }
 
 /*
  * vl_msg_api_trace
  */
-void vl_msg_api_trace(api_main_t *am, vl_api_trace_t *tp, void *msg)
+void
+vl_msg_api_trace (api_main_t * am, vl_api_trace_t * tp, void *msg)
 {
-    u8 **this_trace;
-    u8 **old_trace;
-    u8 *msg_copy;
-    trace_cfg_t *cfgp;
-    u16 msg_id = ntohs(*((u16 *)msg));
+  u8 **this_trace;
+  u8 **old_trace;
+  u8 *msg_copy;
+  trace_cfg_t *cfgp;
+  u16 msg_id = ntohs (*((u16 *) msg));
 
-    cfgp = am->api_trace_cfg + msg_id;
+  cfgp = am->api_trace_cfg + msg_id;
 
-    if (!cfgp || !cfgp->trace_enable)
-        return;
+  if (!cfgp || !cfgp->trace_enable)
+    return;
 
-    msg_copy = 0;
+  msg_copy = 0;
 
-    if (tp->nitems == 0) {
-        clib_warning ("tp->nitems is 0");
-        return;
+  if (tp->nitems == 0)
+    {
+      clib_warning ("tp->nitems is 0");
+      return;
     }
 
-    if (vec_len(tp->traces) < tp->nitems) {
-        vec_add1(tp->traces, 0);
-        this_trace = tp->traces + vec_len(tp->traces) - 1;
-    } else {
-        tp->wrapped = 1;
-        old_trace = tp->traces + tp->curindex++;
-        if (tp->curindex == tp->nitems)
-            tp->curindex = 0;
-        vec_free(*old_trace);
-        this_trace = old_trace;
+  if (vec_len (tp->traces) < tp->nitems)
+    {
+      vec_add1 (tp->traces, 0);
+      this_trace = tp->traces + vec_len (tp->traces) - 1;
+    }
+  else
+    {
+      tp->wrapped = 1;
+      old_trace = tp->traces + tp->curindex++;
+      if (tp->curindex == tp->nitems)
+	tp->curindex = 0;
+      vec_free (*old_trace);
+      this_trace = old_trace;
     }
 
-    vec_validate(msg_copy, cfgp->size - 1);
-    clib_memcpy(msg_copy, msg, cfgp->size);
-    *this_trace = msg_copy;
+  vec_validate (msg_copy, cfgp->size - 1);
+  clib_memcpy (msg_copy, msg, cfgp->size);
+  *this_trace = msg_copy;
 }
 
-int vl_msg_api_trace_onoff(api_main_t *am, vl_api_trace_which_t which, 
-                           int onoff)
+int
+vl_msg_api_trace_onoff (api_main_t * am, vl_api_trace_which_t which,
+			int onoff)
 {
-    vl_api_trace_t *tp;
-    int rv;
+  vl_api_trace_t *tp;
+  int rv;
 
-    switch(which)
+  switch (which)
     {
     case VL_API_TRACE_TX:
-        tp = am->tx_trace;
-        if (tp == 0) {
-            vl_msg_api_trace_configure (am, which, 1024);
-            tp = am->tx_trace;
-        }
-        break;
-        
+      tp = am->tx_trace;
+      if (tp == 0)
+	{
+	  vl_msg_api_trace_configure (am, which, 1024);
+	  tp = am->tx_trace;
+	}
+      break;
+
     case VL_API_TRACE_RX:
-        tp = am->rx_trace;
-        if (tp == 0) {
-            vl_msg_api_trace_configure (am, which, 1024);
-            tp = am->rx_trace;
-        }
-        break;
-        
+      tp = am->rx_trace;
+      if (tp == 0)
+	{
+	  vl_msg_api_trace_configure (am, which, 1024);
+	  tp = am->rx_trace;
+	}
+      break;
+
     default:
-        /* duh? */
-        return -1;
+      /* duh? */
+      return -1;
     }
 
-    /* Configured? */
-    if (tp == 0 || tp->nitems == 0)
-        return -1;
+  /* Configured? */
+  if (tp == 0 || tp->nitems == 0)
+    return -1;
 
-    rv = tp->enabled;
-    tp->enabled = onoff;
+  rv = tp->enabled;
+  tp->enabled = onoff;
 
-    return rv;
+  return rv;
 }
 
-int vl_msg_api_trace_free(api_main_t *am, vl_api_trace_which_t which)
+int
+vl_msg_api_trace_free (api_main_t * am, vl_api_trace_which_t which)
 {
-    vl_api_trace_t *tp;
-    int i;
+  vl_api_trace_t *tp;
+  int i;
 
-    switch(which)
+  switch (which)
     {
     case VL_API_TRACE_TX:
-        tp = am->tx_trace;
-        break;
-        
+      tp = am->tx_trace;
+      break;
+
     case VL_API_TRACE_RX:
-        tp = am->rx_trace;
-        break;
-        
+      tp = am->rx_trace;
+      break;
+
     default:
-        /* duh? */
-        return -1;
+      /* duh? */
+      return -1;
     }
 
-    /* Configured? */
-    if (!tp || tp->nitems == 0)
-        return -1;
+  /* Configured? */
+  if (!tp || tp->nitems == 0)
+    return -1;
 
-    tp->curindex = 0;
-    tp->wrapped = 0;
+  tp->curindex = 0;
+  tp->wrapped = 0;
 
-    for (i = 0; i < vec_len(tp->traces); i++) {
-        vec_free(tp->traces[i]);
+  for (i = 0; i < vec_len (tp->traces); i++)
+    {
+      vec_free (tp->traces[i]);
     }
-    vec_free(tp->traces);
+  vec_free (tp->traces);
 
-    return 0;
+  return 0;
 }
 
-int vl_msg_api_trace_save(api_main_t *am, 
-                          vl_api_trace_which_t which, FILE *fp)
+int
+vl_msg_api_trace_save (api_main_t * am, vl_api_trace_which_t which, FILE * fp)
 {
-    vl_api_trace_t *tp;
-    vl_api_trace_file_header_t fh;
-    int i;
-    u8 *msg;
+  vl_api_trace_t *tp;
+  vl_api_trace_file_header_t fh;
+  int i;
+  u8 *msg;
 
-    switch(which)
+  switch (which)
     {
     case VL_API_TRACE_TX:
-        tp = am->tx_trace;
-        break;
-        
+      tp = am->tx_trace;
+      break;
+
     case VL_API_TRACE_RX:
-        tp = am->rx_trace;
-        break;
-        
+      tp = am->rx_trace;
+      break;
+
     default:
-        /* duh? */
-        return -1;
+      /* duh? */
+      return -1;
     }
 
-    /* Configured, data present? */
-    if (tp == 0 || tp->nitems == 0 || vec_len(tp->traces) == 0)
-        return -1;
+  /* Configured, data present? */
+  if (tp == 0 || tp->nitems == 0 || vec_len (tp->traces) == 0)
+    return -1;
 
-    /* "Dare to be stupid" check */
-    if (fp == 0) {
-        return -2;
+  /* "Dare to be stupid" check */
+  if (fp == 0)
+    {
+      return -2;
     }
 
-    /* Write the file header */
-    fh.nitems = vec_len(tp->traces);
-    fh.endian = tp->endian;
-    fh.wrapped = tp->wrapped;
+  /* Write the file header */
+  fh.nitems = vec_len (tp->traces);
+  fh.endian = tp->endian;
+  fh.wrapped = tp->wrapped;
 
-    if (fwrite(&fh, sizeof(fh), 1, fp) != 1) {
-        return (-10);
+  if (fwrite (&fh, sizeof (fh), 1, fp) != 1)
+    {
+      return (-10);
     }
 
-    /* No-wrap case */
-    if (tp->wrapped == 0) {
-        /*
-         * Note: vec_len return 0 when fed a NULL pointer.
-         * Unfortunately, the static analysis tool doesn't
-         * figure it out, hence the suppressed warnings.
-         * What a great use of my time. 
-         */
-        for (i = 0; i < vec_len(tp->traces); i++) {
-            /*sa_ignore NO_NULL_CHK*/
-            msg = tp->traces[i];
-            /*
-             * This retarded check required to pass
-             * [sic] SA-checking. 
-             */
-            if (!msg)
-                continue;
-            if (fwrite(msg, 1, vec_len(msg), fp) != vec_len(msg)) {
-                return (-11);
-            }
-        }
-    } else {                    
-        /* Wrap case: write oldest -> end of buffer */
-        for (i = tp->curindex; i < vec_len(tp->traces); i++) {
-            msg = tp->traces[i];
-            /*
-             * This retarded check required to pass
-             * [sic] SA-checking 
-             */
-            if (!msg)
-                continue;
-
-            if (fwrite(msg, 1, vec_len(msg), fp) != vec_len(msg)) {
-                return (-12);
-            }
-        }
-        /* write beginning of buffer -> oldest-1 */
-        for (i = 0; i < tp->curindex; i++) {
-            /*sa_ignore NO_NULL_CHK*/
-            msg = tp->traces[i];
-            /*
-             * This retarded check required to pass
-             * [sic] SA-checking 
-             */
-            if (!msg)
-                continue;
-
-            if (fwrite(msg, 1, vec_len(msg), fp) != vec_len(msg)) {
-                return (-13);
-            }
-        }
+  /* No-wrap case */
+  if (tp->wrapped == 0)
+    {
+      /*
+       * Note: vec_len return 0 when fed a NULL pointer.
+       * Unfortunately, the static analysis tool doesn't
+       * figure it out, hence the suppressed warnings.
+       * What a great use of my time.
+       */
+      for (i = 0; i < vec_len (tp->traces); i++)
+	{
+	  /*sa_ignore NO_NULL_CHK */
+	  msg = tp->traces[i];
+	  /*
+	   * This retarded check required to pass
+	   * [sic] SA-checking.
+	   */
+	  if (!msg)
+	    continue;
+	  if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
+	    {
+	      return (-11);
+	    }
+	}
     }
-    return 0;
+  else
+    {
+      /* Wrap case: write oldest -> end of buffer */
+      for (i = tp->curindex; i < vec_len (tp->traces); i++)
+	{
+	  msg = tp->traces[i];
+	  /*
+	   * This retarded check required to pass
+	   * [sic] SA-checking
+	   */
+	  if (!msg)
+	    continue;
+
+	  if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
+	    {
+	      return (-12);
+	    }
+	}
+      /* write beginning of buffer -> oldest-1 */
+      for (i = 0; i < tp->curindex; i++)
+	{
+	  /*sa_ignore NO_NULL_CHK */
+	  msg = tp->traces[i];
+	  /*
+	   * This retarded check required to pass
+	   * [sic] SA-checking
+	   */
+	  if (!msg)
+	    continue;
+
+	  if (fwrite (msg, 1, vec_len (msg), fp) != vec_len (msg))
+	    {
+	      return (-13);
+	    }
+	}
+    }
+  return 0;
 }
 
-int vl_msg_api_trace_configure(api_main_t *am, vl_api_trace_which_t which, 
-                               u32 nitems)
+int
+vl_msg_api_trace_configure (api_main_t * am, vl_api_trace_which_t which,
+			    u32 nitems)
 {
-    vl_api_trace_t *tp;
-    int was_on = 0;
+  vl_api_trace_t *tp;
+  int was_on = 0;
 
-    switch(which)
+  switch (which)
     {
     case VL_API_TRACE_TX:
-        tp = am->tx_trace;
-        if (tp == 0) {
-            vec_validate(am->tx_trace, 0);
-            tp = am->tx_trace;
-        }
-        break;
-        
+      tp = am->tx_trace;
+      if (tp == 0)
+	{
+	  vec_validate (am->tx_trace, 0);
+	  tp = am->tx_trace;
+	}
+      break;
+
     case VL_API_TRACE_RX:
-        tp = am->rx_trace;
-        if (tp == 0) {
-            vec_validate(am->rx_trace, 0);
-            tp = am->rx_trace;
-        }
+      tp = am->rx_trace;
+      if (tp == 0)
+	{
+	  vec_validate (am->rx_trace, 0);
+	  tp = am->rx_trace;
+	}
 
-        break;
+      break;
 
     default:
-        return -1;
+      return -1;
 
     }
 
-    if (tp->enabled) {
-        was_on = vl_msg_api_trace_onoff(am, which, 0);
+  if (tp->enabled)
+    {
+      was_on = vl_msg_api_trace_onoff (am, which, 0);
     }
-    if (tp->traces) {
-        vl_msg_api_trace_free(am, which);
+  if (tp->traces)
+    {
+      vl_msg_api_trace_free (am, which);
     }
 
-    memset(tp, 0, sizeof(*tp));
+  memset (tp, 0, sizeof (*tp));
 
-    if (clib_arch_is_big_endian) {
-        tp->endian = VL_API_BIG_ENDIAN;
-    } else {
-        tp->endian = VL_API_LITTLE_ENDIAN;
+  if (clib_arch_is_big_endian)
+    {
+      tp->endian = VL_API_BIG_ENDIAN;
+    }
+  else
+    {
+      tp->endian = VL_API_LITTLE_ENDIAN;
     }
 
-    tp->nitems = nitems;
-    if (was_on) {
-        (void)vl_msg_api_trace_onoff(am, which, was_on);
+  tp->nitems = nitems;
+  if (was_on)
+    {
+      (void) vl_msg_api_trace_onoff (am, which, was_on);
     }
-    return 0;
+  return 0;
 }
 
-always_inline void msg_handler_internal (api_main_t *am, 
-					 void *the_msg, 
-					 int trace_it,
-					 int do_it, 
-					 int free_it)
+always_inline void
+msg_handler_internal (api_main_t * am,
+		      void *the_msg, int trace_it, int do_it, int free_it)
 {
-    u16 id = ntohs(*((u16 *)the_msg));
-    u8 *(*print_fp)(void *, void *);
-
-    if (id < vec_len(am->msg_handlers) && 
-        am->msg_handlers[id]) {
-        if (trace_it)
-            vl_msg_api_trace(am, am->rx_trace, the_msg);
-        
-        if (am->msg_print_flag) {
-            fformat (stdout, "[%d]: %s\n", id, 
-                     am->msg_names[id]);
-            print_fp = (void *)am->msg_print_handlers[id];
-            if (print_fp == 0) {
-                fformat(stdout, "  [no registered print fn]\n");
-            } else {
-                (*print_fp)(the_msg, stdout);
-            }
-        }
-
-        if (do_it) {
-            if (!am->is_mp_safe[id])
-                vl_msg_api_barrier_sync();
-            (*am->msg_handlers[id])(the_msg);
-            if (!am->is_mp_safe[id])
-                vl_msg_api_barrier_release();
-        }
-    } else {
-        clib_warning("no handler for msg id %d", id);
+  u16 id = ntohs (*((u16 *) the_msg));
+  u8 *(*print_fp) (void *, void *);
+
+  if (id < vec_len (am->msg_handlers) && am->msg_handlers[id])
+    {
+      if (trace_it)
+	vl_msg_api_trace (am, am->rx_trace, the_msg);
+
+      if (am->msg_print_flag)
+	{
+	  fformat (stdout, "[%d]: %s\n", id, am->msg_names[id]);
+	  print_fp = (void *) am->msg_print_handlers[id];
+	  if (print_fp == 0)
+	    {
+	      fformat (stdout, "  [no registered print fn]\n");
+	    }
+	  else
+	    {
+	      (*print_fp) (the_msg, stdout);
+	    }
+	}
+
+      if (do_it)
+	{
+	  if (!am->is_mp_safe[id])
+	    vl_msg_api_barrier_sync ();
+	  (*am->msg_handlers[id]) (the_msg);
+	  if (!am->is_mp_safe[id])
+	    vl_msg_api_barrier_release ();
+	}
+    }
+  else
+    {
+      clib_warning ("no handler for msg id %d", id);
     }
 
-    if (free_it) 
-        vl_msg_api_free(the_msg);
+  if (free_it)
+    vl_msg_api_free (the_msg);
 }
 
 /* set to 1 if you want before/after message handler event logging */
 #define ELOG_API_MESSAGE_HANDLERS 0
 
 #if ELOG_API_MESSAGE_HANDLERS > 0
-static u32 elog_id_for_msg_name (vlib_main_t * vm, char *msg_name)
+static u32
+elog_id_for_msg_name (vlib_main_t * vm, char *msg_name)
 {
-  uword * p, r;
-  static uword * h;
+  uword *p, r;
+  static uword *h;
   u8 *name_copy;
 
-  if (! h)
-      h = hash_create_string (0, sizeof (uword));
+  if (!h)
+    h = hash_create_string (0, sizeof (uword));
 
   p = hash_get_mem (h, msg_name);
   if (p)
@@ -395,155 +440,181 @@ static u32 elog_id_for_msg_name (vlib_main_t * vm, char *msg_name)
 #endif
 
 /* This is only to be called from a vlib/vnet app */
-void vl_msg_api_handler_with_vm_node (api_main_t *am, 
-                                      void *the_msg, vlib_main_t *vm, 
-                                      vlib_node_runtime_t *node)
+void
+vl_msg_api_handler_with_vm_node (api_main_t * am,
+				 void *the_msg, vlib_main_t * vm,
+				 vlib_node_runtime_t * node)
 {
-  u16 id = ntohs(*((u16 *)the_msg));
-  u8 *(*handler)(void *, void *, void *);
-    
+  u16 id = ntohs (*((u16 *) the_msg));
+  u8 *(*handler) (void *, void *, void *);
+
 #if ELOG_API_MESSAGE_HANDLERS > 0
-    {
-      ELOG_TYPE_DECLARE (e) = {
+  {
+    /* *INDENT-OFF* */
+    ELOG_TYPE_DECLARE (e) =
+      {
         .format = "api-msg: %s",
         .format_args = "T4",
       };
-      struct { u32 c; } * ed;
-      ed = ELOG_DATA (&vm->elog_main, e);
-      if (id < vec_len (am->msg_names))
-        ed->c = elog_id_for_msg_name (vm, am->msg_names[id]);
-      else
-        ed->c = elog_id_for_msg_name (vm, "BOGUS");
-    }
-#endif    
-
-  if (id < vec_len(am->msg_handlers) && 
-      am->msg_handlers[id]) {
-    handler = (void *)am->msg_handlers[id];
-
-    if (am->rx_trace && am->rx_trace->enabled)
-      vl_msg_api_trace(am, am->rx_trace, the_msg);
-
-    if (!am->is_mp_safe[id])
-      vl_msg_api_barrier_sync();
-    (*handler)(the_msg, vm, node);
-    if (!am->is_mp_safe[id])
-      vl_msg_api_barrier_release();
-  } else {
-    clib_warning("no hander for msg id %d", id);
+    /* *INDENT-ON* */
+    struct
+    {
+      u32 c;
+    } *ed;
+    ed = ELOG_DATA (&vm->elog_main, e);
+    if (id < vec_len (am->msg_names))
+      ed->c = elog_id_for_msg_name (vm, am->msg_names[id]);
+    else
+      ed->c = elog_id_for_msg_name (vm, "BOGUS");
   }
-  /* 
+#endif
+
+  if (id < vec_len (am->msg_handlers) && am->msg_handlers[id])
+    {
+      handler = (void *) am->msg_handlers[id];
+
+      if (am->rx_trace && am->rx_trace->enabled)
+	vl_msg_api_trace (am, am->rx_trace, the_msg);
+
+      if (!am->is_mp_safe[id])
+	vl_msg_api_barrier_sync ();
+      (*handler) (the_msg, vm, node);
+      if (!am->is_mp_safe[id])
+	vl_msg_api_barrier_release ();
+    }
+  else
+    {
+      clib_warning ("no hander for msg id %d", id);
+    }
+
+  /*
    * Special-case, so we can e.g. bounce messages off the vnet
    * main thread without copying them...
    */
   if (!(am->message_bounce[id]))
-    vl_msg_api_free(the_msg);
+    vl_msg_api_free (the_msg);
 
 #if ELOG_API_MESSAGE_HANDLERS > 0
+  {
+  /* *INDENT-OFF* */
+  ELOG_TYPE_DECLARE (e) = {
+    .format = "api-msg-done: %s",
+    .format_args = "T4",
+  };
+  /* *INDENT-ON* */
+
+    struct
     {
-      ELOG_TYPE_DECLARE (e) = {
-        .format = "api-msg-done: %s",
-        .format_args = "T4",
-      };
-      struct { u32 c; } * ed;
-      ed = ELOG_DATA (&vm->elog_main, e);
-      if (id < vec_len (am->msg_names))
-        ed->c = elog_id_for_msg_name (vm, am->msg_names[id]);
-      else
-        ed->c = elog_id_for_msg_name (vm, "BOGUS");
-    }
+      u32 c;
+    } *ed;
+    ed = ELOG_DATA (&vm->elog_main, e);
+    if (id < vec_len (am->msg_names))
+      ed->c = elog_id_for_msg_name (vm, am->msg_names[id]);
+    else
+      ed->c = elog_id_for_msg_name (vm, "BOGUS");
+  }
 #endif
 }
 
-void vl_msg_api_handler (void *the_msg)
+void
+vl_msg_api_handler (void *the_msg)
 {
-    api_main_t *am = &api_main;
+  api_main_t *am = &api_main;
 
-    msg_handler_internal (am, the_msg, 
-                          (am->rx_trace 
-                           && am->rx_trace->enabled) /* trace_it */, 
-                          1 /* do_it */, 1 /* free_it */);
+  msg_handler_internal (am, the_msg,
+			(am->rx_trace
+			 && am->rx_trace->enabled) /* trace_it */ ,
+			1 /* do_it */ , 1 /* free_it */ );
 }
 
-void vl_msg_api_handler_no_free (void *the_msg)
+void
+vl_msg_api_handler_no_free (void *the_msg)
 {
-    api_main_t *am = &api_main;
-    msg_handler_internal (am, the_msg, 
-                          (am->rx_trace 
-                           && am->rx_trace->enabled) /* trace_it */, 
-                          1 /* do_it */, 0 /* free_it */);
+  api_main_t *am = &api_main;
+  msg_handler_internal (am, the_msg,
+			(am->rx_trace
+			 && am->rx_trace->enabled) /* trace_it */ ,
+			1 /* do_it */ , 0 /* free_it */ );
 }
 
-void vl_msg_api_handler_no_trace_no_free (void *the_msg)
+void
+vl_msg_api_handler_no_trace_no_free (void *the_msg)
 {
-    api_main_t *am = &api_main;
-    msg_handler_internal (am, the_msg, 0/* trace_it */, 1 /* do_it */, 
-                          0 /* free_it */);
+  api_main_t *am = &api_main;
+  msg_handler_internal (am, the_msg, 0 /* trace_it */ , 1 /* do_it */ ,
+			0 /* free_it */ );
 }
 
 /*
  * Add a trace record to the API message trace buffer, if
  * API message tracing is enabled. Handy for adding sufficient
  * data to the trace to reproduce autonomous state, as opposed to
- * state downloaded via control-plane API messages. Example: the NAT 
+ * state downloaded via control-plane API messages. Example: the NAT
  * application creates database entries based on packet traffic, not
  * control-plane messages.
  *
  */
-void vl_msg_api_trace_only (void *the_msg)
+void
+vl_msg_api_trace_only (void *the_msg)
 {
-    api_main_t *am = &api_main;
+  api_main_t *am = &api_main;
 
-    msg_handler_internal (am, the_msg, 
-                          (am->rx_trace 
-                           && am->rx_trace->enabled) /* trace_it */,
-                          0 /* do_it */, 0 /* free_it */);
+  msg_handler_internal (am, the_msg,
+			(am->rx_trace
+			 && am->rx_trace->enabled) /* trace_it */ ,
+			0 /* do_it */ , 0 /* free_it */ );
 }
 
-void vl_msg_api_cleanup_handler (void *the_msg)
+void
+vl_msg_api_cleanup_handler (void *the_msg)
 {
-    api_main_t *am = &api_main;
-    u16 id = ntohs(*((u16 *)the_msg));
+  api_main_t *am = &api_main;
+  u16 id = ntohs (*((u16 *) the_msg));
 
-    if (PREDICT_FALSE(id >= vec_len(am->msg_cleanup_handlers))) {
-        clib_warning ("_vl_msg_id too large: %d\n", id);
-        return;
+  if (PREDICT_FALSE (id >= vec_len (am->msg_cleanup_handlers)))
+    {
+      clib_warning ("_vl_msg_id too large: %d\n", id);
+      return;
     }
-    if (am->msg_cleanup_handlers[id])
-        (*am->msg_cleanup_handlers[id])(the_msg);
+  if (am->msg_cleanup_handlers[id])
+    (*am->msg_cleanup_handlers[id]) (the_msg);
 
-    vl_msg_api_free(the_msg);
+  vl_msg_api_free (the_msg);
 }
 
 /*
  * vl_msg_api_replay_handler
  */
-void vl_msg_api_replay_handler(void *the_msg)
+void
+vl_msg_api_replay_handler (void *the_msg)
 {
-    api_main_t *am = &api_main;
+  api_main_t *am = &api_main;
 
-    u16 id = ntohs(*((u16 *)the_msg));
+  u16 id = ntohs (*((u16 *) the_msg));
 
-    if (PREDICT_FALSE(id >= vec_len(am->msg_handlers))) {
-        clib_warning ("_vl_msg_id too large: %d\n", id);
-        return;
+  if (PREDICT_FALSE (id >= vec_len (am->msg_handlers)))
+    {
+      clib_warning ("_vl_msg_id too large: %d\n", id);
+      return;
     }
-    /* do NOT trace the message... */
-    if (am->msg_handlers[id])
-        (*am->msg_handlers[id])(the_msg);
-    /* do NOT free the message buffer... */
+  /* do NOT trace the message... */
+  if (am->msg_handlers[id])
+    (*am->msg_handlers[id]) (the_msg);
+  /* do NOT free the message buffer... */
 }
+
 /*
  * vl_msg_api_socket_handler
  */
-void vl_msg_api_socket_handler(void *the_msg)
+void
+vl_msg_api_socket_handler (void *the_msg)
 {
-    api_main_t *am = &api_main;
+  api_main_t *am = &api_main;
 
-    msg_handler_internal (am, the_msg, 
-                          (am->rx_trace 
-                           && am->rx_trace->enabled) /* trace_it */,
-                          1 /* do_it */, 0 /* free_it */);
+  msg_handler_internal (am, the_msg,
+			(am->rx_trace
+			 && am->rx_trace->enabled) /* trace_it */ ,
+			1 /* do_it */ , 0 /* free_it */ );
 }
 
 #define foreach_msg_api_vector                  \
@@ -556,592 +627,675 @@ _(api_trace_cfg)				\
 _(message_bounce)				\
 _(is_mp_safe)
 
-void vl_msg_api_config (vl_msg_api_msg_config_t *c)
+void
+vl_msg_api_config (vl_msg_api_msg_config_t * c)
 {
-    api_main_t *am = &api_main;
+  api_main_t *am = &api_main;
 
-    ASSERT(c->id > 0);
+  ASSERT (c->id > 0);
 
 #define _(a) vec_validate (am->a, c->id);
-    foreach_msg_api_vector;
+  foreach_msg_api_vector;
 #undef _
 
-    am->msg_names[c->id] = c->name;
-    am->msg_handlers[c->id] = c->handler;
-    am->msg_cleanup_handlers[c->id] = c->cleanup;
-    am->msg_endian_handlers[c->id] = c->endian;
-    am->msg_print_handlers[c->id] = c->print;
-    am->message_bounce[c->id] = c->message_bounce;
-    am->is_mp_safe[c->id] = c->is_mp_safe;
-
-    am->api_trace_cfg[c->id].size = c->size;
-    am->api_trace_cfg[c->id].trace_enable = c->traced;
-    am->api_trace_cfg[c->id].replay_enable = c->replay;
+  am->msg_names[c->id] = c->name;
+  am->msg_handlers[c->id] = c->handler;
+  am->msg_cleanup_handlers[c->id] = c->cleanup;
+  am->msg_endian_handlers[c->id] = c->endian;
+  am->msg_print_handlers[c->id] = c->print;
+  am->message_bounce[c->id] = c->message_bounce;
+  am->is_mp_safe[c->id] = c->is_mp_safe;
+
+  am->api_trace_cfg[c->id].size = c->size;
+  am->api_trace_cfg[c->id].trace_enable = c->traced;
+  am->api_trace_cfg[c->id].replay_enable = c->replay;
 }
 
-/* 
+/*
  * vl_msg_api_set_handlers
  * preserve the old API for a while
  */
-void vl_msg_api_set_handlers(int id, char *name, void *handler, void *cleanup,
-                             void *endian, void *print, int size, int traced)
+void
+vl_msg_api_set_handlers (int id, char *name, void *handler, void *cleanup,
+			 void *endian, void *print, int size, int traced)
 {
-    vl_msg_api_msg_config_t cfg;
-    vl_msg_api_msg_config_t *c = &cfg;
-
-    c->id = id;
-    c->name = name;
-    c->handler = handler;
-    c->cleanup = cleanup;
-    c->endian = endian;
-    c->print = print;
-    c->size = size;
-    c->traced = traced;
-    c->replay = 1;
-    c->message_bounce = 0;
-    c->is_mp_safe = 0;
-    vl_msg_api_config (c);
+  vl_msg_api_msg_config_t cfg;
+  vl_msg_api_msg_config_t *c = &cfg;
+
+  c->id = id;
+  c->name = name;
+  c->handler = handler;
+  c->cleanup = cleanup;
+  c->endian = endian;
+  c->print = print;
+  c->size = size;
+  c->traced = traced;
+  c->replay = 1;
+  c->message_bounce = 0;
+  c->is_mp_safe = 0;
+  vl_msg_api_config (c);
 }
 
-void vl_msg_api_set_cleanup_handler(int msg_id, void *fp)
+void
+vl_msg_api_set_cleanup_handler (int msg_id, void *fp)
 {
-    api_main_t *am = &api_main;
-    ASSERT(msg_id > 0);
+  api_main_t *am = &api_main;
+  ASSERT (msg_id > 0);
 
-    vec_validate(am->msg_cleanup_handlers, msg_id);
-    am->msg_cleanup_handlers[msg_id] = fp;
+  vec_validate (am->msg_cleanup_handlers, msg_id);
+  am->msg_cleanup_handlers[msg_id] = fp;
 }
 
-void vl_msg_api_queue_handler(unix_shared_memory_queue_t *q)
+void
+vl_msg_api_queue_handler (unix_shared_memory_queue_t * q)
 {
-    uword msg;
+  uword msg;
 
-    while (!unix_shared_memory_queue_sub(q, (u8 *)&msg, 0))
-        vl_msg_api_handler((void *)msg);
+  while (!unix_shared_memory_queue_sub (q, (u8 *) & msg, 0))
+    vl_msg_api_handler ((void *) msg);
 }
 
-vl_api_trace_t *vl_msg_api_trace_get(api_main_t *am, vl_api_trace_which_t which)
+vl_api_trace_t *
+vl_msg_api_trace_get (api_main_t * am, vl_api_trace_which_t which)
 {
-    switch(which)
+  switch (which)
     {
     case VL_API_TRACE_RX:
-        return am->rx_trace;
+      return am->rx_trace;
     case VL_API_TRACE_TX:
-        return am->tx_trace;
+      return am->tx_trace;
     default:
-        return 0;
+      return 0;
     }
 }
 
-void vl_noop_handler (void *mp) { }
+void
+vl_noop_handler (void *mp)
+{
+}
 
 clib_error_t *
-vl_api_init (vlib_main_t *vm)
+vl_api_init (vlib_main_t * vm)
 {
-    static u8 once;
-    api_main_t *am = &api_main;
-
-    if (once)
-        return 0;
-    
-    once = 1;
-
-    am->region_name = "/unset";
-    /* 
-     * Eventually passed to fchown, -1 => "current user" 
-     * instead of 0 => "root". A very fine disctinction at best.
-     */
-    if (am->api_uid == 0)
-        am->api_uid = -1;
-    if (am->api_gid == 0)
-        am->api_gid = -1;
-
-    return (0);
+  static u8 once;
+  api_main_t *am = &api_main;
+
+  if (once)
+    return 0;
+
+  once = 1;
+
+  am->region_name = "/unset";
+  /*
+   * Eventually passed to fchown, -1 => "current user"
+   * instead of 0 => "root". A very fine disctinction at best.
+   */
+  if (am->api_uid == 0)
+    am->api_uid = -1;
+  if (am->api_gid == 0)
+    am->api_gid = -1;
+
+  return (0);
 }
 
-void vl_msg_api_custom_dump_configure (api_main_t *am) __attribute__((weak));
-void vl_msg_api_custom_dump_configure (api_main_t *am) { }
+void vl_msg_api_custom_dump_configure (api_main_t * am)
+  __attribute__ ((weak));
+void
+vl_msg_api_custom_dump_configure (api_main_t * am)
+{
+}
 
 VLIB_INIT_FUNCTION (vl_api_init);
 
-static void vl_msg_api_process_file (vlib_main_t *vm, u8 *filename, 
-                                     u32 first_index, u32 last_index, 
-                                     vl_api_replay_t which)
+static void
+vl_msg_api_process_file (vlib_main_t * vm, u8 * filename,
+			 u32 first_index, u32 last_index,
+			 vl_api_replay_t which)
 {
-    vl_api_trace_file_header_t * hp;
-    int i, fd;
-    struct stat statb;
-    size_t file_size;
-    u8 *msg;
-    u8 endian_swap_needed = 0;
-    api_main_t * am = &api_main;
-    static u8 *tmpbuf;
-    u32 nitems;
-    void **saved_print_handlers = 0;
-
-    fd = open ((char *) filename, O_RDONLY);
-
-    if (fd < 0) {
-        vlib_cli_output (vm, "Couldn't open %s\n", filename);
-        return;
+  vl_api_trace_file_header_t *hp;
+  int i, fd;
+  struct stat statb;
+  size_t file_size;
+  u8 *msg;
+  u8 endian_swap_needed = 0;
+  api_main_t *am = &api_main;
+  static u8 *tmpbuf;
+  u32 nitems;
+  void **saved_print_handlers = 0;
+
+  fd = open ((char *) filename, O_RDONLY);
+
+  if (fd < 0)
+    {
+      vlib_cli_output (vm, "Couldn't open %s\n", filename);
+      return;
     }
 
-    if (fstat(fd, &statb) < 0) {
-        vlib_cli_output (vm, "Couldn't stat %s\n", filename);
-        return;
+  if (fstat (fd, &statb) < 0)
+    {
+      vlib_cli_output (vm, "Couldn't stat %s\n", filename);
+      return;
     }
 
-    if (! (statb.st_mode & S_IFREG) || (statb.st_size < sizeof (*hp))) {
-        vlib_cli_output (vm, "File not plausible: %s\n", filename);
-        return;
+  if (!(statb.st_mode & S_IFREG) || (statb.st_size < sizeof (*hp)))
+    {
+      vlib_cli_output (vm, "File not plausible: %s\n", filename);
+      return;
     }
 
-    file_size = statb.st_size;
-    file_size = (file_size + 4095) & ~(4096);
+  file_size = statb.st_size;
+  file_size = (file_size + 4095) & ~(4096);
 
-    hp = mmap (0, file_size, PROT_READ, MAP_PRIVATE, fd, 0);
+  hp = mmap (0, file_size, PROT_READ, MAP_PRIVATE, fd, 0);
 
-    if (hp == (vl_api_trace_file_header_t *)MAP_FAILED) {
-        vlib_cli_output (vm, "mmap failed: %s\n", filename);
-        close(fd);
-        return;
+  if (hp == (vl_api_trace_file_header_t *) MAP_FAILED)
+    {
+      vlib_cli_output (vm, "mmap failed: %s\n", filename);
+      close (fd);
+      return;
     }
-    close(fd);
-
-    if ((clib_arch_is_little_endian && hp->endian == VL_API_BIG_ENDIAN)
-        || (clib_arch_is_big_endian && hp->endian == VL_API_LITTLE_ENDIAN))
-        endian_swap_needed = 1;
-    
-    if (endian_swap_needed)
-        nitems = ntohl(hp->nitems);
-    else
-        nitems = hp->nitems;
+  close (fd);
+
+  if ((clib_arch_is_little_endian && hp->endian == VL_API_BIG_ENDIAN)
+      || (clib_arch_is_big_endian && hp->endian == VL_API_LITTLE_ENDIAN))
+    endian_swap_needed = 1;
+
+  if (endian_swap_needed)
+    nitems = ntohl (hp->nitems);
+  else
+    nitems = hp->nitems;
 
-    if (last_index == (u32) ~0) {
-        last_index = nitems - 1;
+  if (last_index == (u32) ~ 0)
+    {
+      last_index = nitems - 1;
     }
-    
-    if (first_index >= nitems || last_index >= nitems) {
-        vlib_cli_output (vm, "Range (%d, %d) outside file range (0, %d)\n",
-                         first_index, last_index, nitems-1);
-        return;
+
+  if (first_index >= nitems || last_index >= nitems)
+    {
+      vlib_cli_output (vm, "Range (%d, %d) outside file range (0, %d)\n",
+		       first_index, last_index, nitems - 1);
+      return;
     }
-    if (hp->wrapped)
-        vlib_cli_output (vm, 
-                         "Note: wrapped/incomplete trace, results may vary\n");
-    
-    if (which == CUSTOM_DUMP) {
-        saved_print_handlers = (void **) vec_dup (am->msg_print_handlers);
-        vl_msg_api_custom_dump_configure (am);
+  if (hp->wrapped)
+    vlib_cli_output (vm,
+		     "Note: wrapped/incomplete trace, results may vary\n");
+
+  if (which == CUSTOM_DUMP)
+    {
+      saved_print_handlers = (void **) vec_dup (am->msg_print_handlers);
+      vl_msg_api_custom_dump_configure (am);
     }
 
 
-    msg = (u8 *)(hp+1);
-    
-    for (i = 0; i < first_index; i++) {
-        trace_cfg_t *cfgp;
-        int size;
-        u16 msg_id;
-        
-        if (clib_arch_is_little_endian)
-            msg_id = ntohs(*((u16 *)msg));
-        else
-            msg_id = *((u16 *)msg);
-        
-        cfgp = am->api_trace_cfg + msg_id;
-        if (!cfgp) {
-            vlib_cli_output (vm, "Ugh: msg id %d no trace config\n", msg_id);
-            return;
-        }
-        size = cfgp->size;
-        msg += size;
+  msg = (u8 *) (hp + 1);
+
+  for (i = 0; i < first_index; i++)
+    {
+      trace_cfg_t *cfgp;
+      int size;
+      u16 msg_id;
+
+      if (clib_arch_is_little_endian)
+	msg_id = ntohs (*((u16 *) msg));
+      else
+	msg_id = *((u16 *) msg);
+
+      cfgp = am->api_trace_cfg + msg_id;
+      if (!cfgp)
+	{
+	  vlib_cli_output (vm, "Ugh: msg id %d no trace config\n", msg_id);
+	  return;
+	}
+      size = cfgp->size;
+      msg += size;
     }
-    
-    for (; i <= last_index; i++) {
-        trace_cfg_t *cfgp;
-        u16 *msg_idp;
-        u16 msg_id;
-        int size;
-        
-        if (which == DUMP)
-            vlib_cli_output (vm, "---------- trace %d -----------\n", i);
-
-        if (clib_arch_is_little_endian)
-            msg_id = ntohs(*((u16 *)msg));
-        else
-            msg_id = *((u16 *)msg);
-        
-        cfgp = am->api_trace_cfg + msg_id;
-        if (!cfgp) {
-            vlib_cli_output (vm, "Ugh: msg id %d no trace config\n", msg_id);
-            return;
-        }
-        size = cfgp->size;
-
-        /* Copy the buffer (from the read-only mmap'ed file) */
-        vec_validate (tmpbuf, size-1 + sizeof(uword));
-        clib_memcpy (tmpbuf+sizeof(uword), msg, size);
-        memset (tmpbuf, 0xf, sizeof(uword));
-
-        /* 
-         * Endian swap if needed. All msg data is supposed to be 
-         * in network byte order. All msg handlers are supposed to
-         * know that. The generic message dumpers don't know that.
-         * One could fix apigen, I suppose.
-         */
-        if ((which == DUMP && clib_arch_is_little_endian) 
-            || endian_swap_needed) {
-            void (*endian_fp)(void *);
-            if (msg_id >= vec_len (am->msg_endian_handlers)
-                || (am->msg_endian_handlers[msg_id] == 0)) {
-                vlib_cli_output (vm, "Ugh: msg id %d no endian swap\n", msg_id);
-                return;
-            }
-            endian_fp = am->msg_endian_handlers[msg_id];
-            (*endian_fp)(tmpbuf+sizeof(uword));
-        }
-
-        /* msg_id always in network byte order */
-        if (clib_arch_is_little_endian) {
-            msg_idp = (u16 *)(tmpbuf+sizeof(uword));
-            *msg_idp = msg_id;
-        }
-
-        switch (which) {
-        case CUSTOM_DUMP:
-        case DUMP:
-            if (msg_id < vec_len(am->msg_print_handlers) &&
-                am->msg_print_handlers [msg_id]) {
-                u8 *(*print_fp)(void *, void *);
-                
-                print_fp = (void *)am->msg_print_handlers[msg_id];
-                (*print_fp)(tmpbuf+sizeof(uword), vm);
-            } else {
-                vlib_cli_output (vm, "Skipping msg id %d: no print fcn\n",
-                                 msg_id);
-                break;
-            }
-            break;
-
-        case INITIALIZERS:
-            if (msg_id < vec_len(am->msg_print_handlers) &&
-                am->msg_print_handlers [msg_id]) {
-                u8 * s;
-                int j;
-                u8 *(*print_fp)(void *, void *);
-
-                print_fp = (void *)am->msg_print_handlers[msg_id];
-                
-                vlib_cli_output (vm, "/*");
-                
-                (*print_fp)(tmpbuf+sizeof(uword), vm);
-                vlib_cli_output (vm, "*/\n");
-                
-                s = format (0, "static u8 * vl_api_%s_%d[%d] = {",
-                            am->msg_names[msg_id], i, 
-                            am->api_trace_cfg[msg_id].size);
-                
-                for (j = 0; j < am->api_trace_cfg[msg_id].size; j++) {
-                    if ((j & 7) == 0)
-                        s = format (s, "\n    ");    
-                    s = format (s, "0x%02x,", tmpbuf[sizeof(uword)+j]);
-                }
-                s = format (s, "\n};\n%c", 0);
-                vlib_cli_output (vm, (char *)s);
-                vec_free(s);
-            }
-            break;
-                
-        case REPLAY:
-            if (msg_id < vec_len(am->msg_print_handlers) &&
-                am->msg_print_handlers [msg_id] && cfgp->replay_enable) {
-                void (*handler)(void *);
-                
-                handler = (void *)am->msg_handlers[msg_id];
-
-                if (!am->is_mp_safe[msg_id])
-                    vl_msg_api_barrier_sync();
-                (*handler)(tmpbuf+sizeof(uword));
-                if (!am->is_mp_safe[msg_id])
-                    vl_msg_api_barrier_release();
-            } else {
-                if (cfgp->replay_enable)
-                    vlib_cli_output (vm, "Skipping msg id %d: no handler\n",
-                                     msg_id);
-                break;
-            }
-            break;
-        }
-
-        _vec_len(tmpbuf) = 0;
-        msg += size;
+
+  for (; i <= last_index; i++)
+    {
+      trace_cfg_t *cfgp;
+      u16 *msg_idp;
+      u16 msg_id;
+      int size;
+
+      if (which == DUMP)
+	vlib_cli_output (vm, "---------- trace %d -----------\n", i);
+
+      if (clib_arch_is_little_endian)
+	msg_id = ntohs (*((u16 *) msg));
+      else
+	msg_id = *((u16 *) msg);
+
+      cfgp = am->api_trace_cfg + msg_id;
+      if (!cfgp)
+	{
+	  vlib_cli_output (vm, "Ugh: msg id %d no trace config\n", msg_id);
+	  return;
+	}
+      size = cfgp->size;
+
+      /* Copy the buffer (from the read-only mmap'ed file) */
+      vec_validate (tmpbuf, size - 1 + sizeof (uword));
+      clib_memcpy (tmpbuf + sizeof (uword), msg, size);
+      memset (tmpbuf, 0xf, sizeof (uword));
+
+      /*
+       * Endian swap if needed. All msg data is supposed to be
+       * in network byte order. All msg handlers are supposed to
+       * know that. The generic message dumpers don't know that.
+       * One could fix apigen, I suppose.
+       */
+      if ((which == DUMP && clib_arch_is_little_endian) || endian_swap_needed)
+	{
+	  void (*endian_fp) (void *);
+	  if (msg_id >= vec_len (am->msg_endian_handlers)
+	      || (am->msg_endian_handlers[msg_id] == 0))
+	    {
+	      vlib_cli_output (vm, "Ugh: msg id %d no endian swap\n", msg_id);
+	      return;
+	    }
+	  endian_fp = am->msg_endian_handlers[msg_id];
+	  (*endian_fp) (tmpbuf + sizeof (uword));
+	}
+
+      /* msg_id always in network byte order */
+      if (clib_arch_is_little_endian)
+	{
+	  msg_idp = (u16 *) (tmpbuf + sizeof (uword));
+	  *msg_idp = msg_id;
+	}
+
+      switch (which)
+	{
+	case CUSTOM_DUMP:
+	case DUMP:
+	  if (msg_id < vec_len (am->msg_print_handlers) &&
+	      am->msg_print_handlers[msg_id])
+	    {
+	      u8 *(*print_fp) (void *, void *);
+
+	      print_fp = (void *) am->msg_print_handlers[msg_id];
+	      (*print_fp) (tmpbuf + sizeof (uword), vm);
+	    }
+	  else
+	    {
+	      vlib_cli_output (vm, "Skipping msg id %d: no print fcn\n",
+			       msg_id);
+	      break;
+	    }
+	  break;
+
+	case INITIALIZERS:
+	  if (msg_id < vec_len (am->msg_print_handlers) &&
+	      am->msg_print_handlers[msg_id])
+	    {
+	      u8 *s;
+	      int j;
+	      u8 *(*print_fp) (void *, void *);
+
+	      print_fp = (void *) am->msg_print_handlers[msg_id];
+
+	      vlib_cli_output (vm, "/*");
+
+	      (*print_fp) (tmpbuf + sizeof (uword), vm);
+	      vlib_cli_output (vm, "*/\n");
+
+	      s = format (0, "static u8 * vl_api_%s_%d[%d] = {",
+			  am->msg_names[msg_id], i,
+			  am->api_trace_cfg[msg_id].size);
+
+	      for (j = 0; j < am->api_trace_cfg[msg_id].size; j++)
+		{
+		  if ((j & 7) == 0)
+		    s = format (s, "\n    ");
+		  s = format (s, "0x%02x,", tmpbuf[sizeof (uword) + j]);
+		}
+	      s = format (s, "\n};\n%c", 0);
+	      vlib_cli_output (vm, (char *) s);
+	      vec_free (s);
+	    }
+	  break;
+
+	case REPLAY:
+	  if (msg_id < vec_len (am->msg_print_handlers) &&
+	      am->msg_print_handlers[msg_id] && cfgp->replay_enable)
+	    {
+	      void (*handler) (void *);
+
+	      handler = (void *) am->msg_handlers[msg_id];
+
+	      if (!am->is_mp_safe[msg_id])
+		vl_msg_api_barrier_sync ();
+	      (*handler) (tmpbuf + sizeof (uword));
+	      if (!am->is_mp_safe[msg_id])
+		vl_msg_api_barrier_release ();
+	    }
+	  else
+	    {
+	      if (cfgp->replay_enable)
+		vlib_cli_output (vm, "Skipping msg id %d: no handler\n",
+				 msg_id);
+	      break;
+	    }
+	  break;
+	}
+
+      _vec_len (tmpbuf) = 0;
+      msg += size;
     }
-    
-    if (saved_print_handlers) {
-        clib_memcpy (am->msg_print_handlers, saved_print_handlers, 
-                vec_len(am->msg_print_handlers) * sizeof (void *));
-        vec_free (saved_print_handlers);
+
+  if (saved_print_handlers)
+    {
+      clib_memcpy (am->msg_print_handlers, saved_print_handlers,
+		   vec_len (am->msg_print_handlers) * sizeof (void *));
+      vec_free (saved_print_handlers);
     }
 
-    munmap (hp, file_size);
+  munmap (hp, file_size);
 }
 
-u8 * format_vl_msg_api_trace_status (u8 * s, va_list * args)
+u8 *
+format_vl_msg_api_trace_status (u8 * s, va_list * args)
 {
-    api_main_t * am = va_arg (*args, api_main_t *);
-    vl_api_trace_which_t which = va_arg (*args, vl_api_trace_which_t);
-    vl_api_trace_t *tp;
-    char *trace_name;
+  api_main_t *am = va_arg (*args, api_main_t *);
+  vl_api_trace_which_t which = va_arg (*args, vl_api_trace_which_t);
+  vl_api_trace_t *tp;
+  char *trace_name;
 
-    switch(which)
+  switch (which)
     {
     case VL_API_TRACE_TX:
-        tp = am->tx_trace;
-        trace_name = "TX trace";
-        break;
-        
+      tp = am->tx_trace;
+      trace_name = "TX trace";
+      break;
+
     case VL_API_TRACE_RX:
-        tp = am->rx_trace;
-        trace_name = "RX trace";
-        break;
+      tp = am->rx_trace;
+      trace_name = "RX trace";
+      break;
 
     default:
-        abort();
+      abort ();
     }
 
-    if (tp == 0) {
-        s = format (s, "%s: not yet configured.\n", trace_name);
-        return s;
+  if (tp == 0)
+    {
+      s = format (s, "%s: not yet configured.\n", trace_name);
+      return s;
     }
 
-    s = format (s, "%s: used %d of %d items, %s enabled, %s wrapped\n",
-                trace_name, vec_len (tp->traces), tp->nitems, 
-                tp->enabled ? "is" : "is not",
-                tp->wrapped ? "has" : "has not");
-    return s;
+  s = format (s, "%s: used %d of %d items, %s enabled, %s wrapped\n",
+	      trace_name, vec_len (tp->traces), tp->nitems,
+	      tp->enabled ? "is" : "is not", tp->wrapped ? "has" : "has not");
+  return s;
 }
 
 static u8 post_mortem_dump_enabled;
 
 static clib_error_t *
 api_trace_command_fn (vlib_main_t * vm,
-		 unformat_input_t * input,
-		 vlib_cli_command_t * cmd)
+		      unformat_input_t * input, vlib_cli_command_t * cmd)
 {
-    u32 nitems = 256<<10;
-    api_main_t * am = &api_main;
-    vl_api_trace_which_t which = VL_API_TRACE_RX;
-    u8 *filename;
-    u32 first = 0;
-    u32 last = (u32)~0;
-    FILE *fp;
-    int rv;
-
-    while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
-        if (unformat (input, "on") || unformat (input, "enable")) {
-            if (unformat (input, "nitems %d", &nitems))
-                ;
-            vl_msg_api_trace_configure (am, which, nitems);
-            vl_msg_api_trace_onoff (am, which, 1 /* on */);
-        } else if (unformat (input, "off")) {
-            vl_msg_api_trace_onoff (am, which, 0);
-        } else if (unformat (input, "save %s", &filename)) {
-            u8 * chroot_filename;
-            if (strstr((char *)filename, "..") 
-                || index((char *)filename, '/'))
-            {
-                vlib_cli_output (vm, "illegal characters in filename '%s'", 
-                                 filename);
-                return 0;
-            }
-
-            chroot_filename = format (0, "/tmp/%s%c", filename, 0);
-
-            vec_free(filename);
-            
-            fp = fopen ((char *)chroot_filename, "w");
-            if (fp == NULL) {
-                vlib_cli_output (vm, "Couldn't create %s\n", chroot_filename);
-                return 0;
-            }
-            rv = vl_msg_api_trace_save (am, which, fp);
-            fclose (fp);
-            if (rv < 0)
-                vlib_cli_output (vm, "ERROR: %d", rv);
-            else
-                vlib_cli_output (vm, "API trace saved to %s\n", 
-                                 chroot_filename);
-            vec_free (chroot_filename);
-        } else if (unformat (input, "dump %s", &filename)) {
-            vl_msg_api_process_file (vm, filename, first, last, DUMP);
-        } else if (unformat (input, "custom-dump %s", &filename)) {
-            vl_msg_api_process_file (vm, filename, first, last, CUSTOM_DUMP);
-        } else if (unformat (input, "replay %s", &filename)) {
-            vl_msg_api_process_file (vm, filename, first, last, REPLAY);
-        } else if (unformat (input, "initializers %s", &filename)) {
-            vl_msg_api_process_file (vm, filename, first, last, INITIALIZERS);
-        } else if (unformat (input, "tx")) {
-            which = VL_API_TRACE_TX;
-        } else if (unformat (input, "first %d", &first)) {
-            ;
-        } else if (unformat (input, "last %d", &last)) {
-            ;
-        } else if (unformat (input, "status")) {
-            vlib_cli_output (vm, "%U", format_vl_msg_api_trace_status,
-                             am, which);
-        } else if (unformat (input, "free")) {
-            vl_msg_api_trace_onoff (am, which, 0);
-            vl_msg_api_trace_free (am, which);
-        } else if (unformat (input, "post-mortem-on"))
-            post_mortem_dump_enabled = 1;
-        else if (unformat (input, "post-mortem-off"))        
-            post_mortem_dump_enabled = 0;
-        else
-            return clib_error_return (0, "unknown input `%U'",
-                                      format_unformat_error, input);
+  u32 nitems = 256 << 10;
+  api_main_t *am = &api_main;
+  vl_api_trace_which_t which = VL_API_TRACE_RX;
+  u8 *filename;
+  u32 first = 0;
+  u32 last = (u32) ~ 0;
+  FILE *fp;
+  int rv;
+
+  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat (input, "on") || unformat (input, "enable"))
+	{
+	  if (unformat (input, "nitems %d", &nitems))
+	    ;
+	  vl_msg_api_trace_configure (am, which, nitems);
+	  vl_msg_api_trace_onoff (am, which, 1 /* on */ );
+	}
+      else if (unformat (input, "off"))
+	{
+	  vl_msg_api_trace_onoff (am, which, 0);
+	}
+      else if (unformat (input, "save %s", &filename))
+	{
+	  u8 *chroot_filename;
+	  if (strstr ((char *) filename, "..")
+	      || index ((char *) filename, '/'))
+	    {
+	      vlib_cli_output (vm, "illegal characters in filename '%s'",
+			       filename);
+	      return 0;
+	    }
+
+	  chroot_filename = format (0, "/tmp/%s%c", filename, 0);
+
+	  vec_free (filename);
+
+	  fp = fopen ((char *) chroot_filename, "w");
+	  if (fp == NULL)
+	    {
+	      vlib_cli_output (vm, "Couldn't create %s\n", chroot_filename);
+	      return 0;
+	    }
+	  rv = vl_msg_api_trace_save (am, which, fp);
+	  fclose (fp);
+	  if (rv < 0)
+	    vlib_cli_output (vm, "ERROR: %d", rv);
+	  else
+	    vlib_cli_output (vm, "API trace saved to %s\n", chroot_filename);
+	  vec_free (chroot_filename);
+	}
+      else if (unformat (input, "dump %s", &filename))
+	{
+	  vl_msg_api_process_file (vm, filename, first, last, DUMP);
+	}
+      else if (unformat (input, "custom-dump %s", &filename))
+	{
+	  vl_msg_api_process_file (vm, filename, first, last, CUSTOM_DUMP);
+	}
+      else if (unformat (input, "replay %s", &filename))
+	{
+	  vl_msg_api_process_file (vm, filename, first, last, REPLAY);
+	}
+      else if (unformat (input, "initializers %s", &filename))
+	{
+	  vl_msg_api_process_file (vm, filename, first, last, INITIALIZERS);
+	}
+      else if (unformat (input, "tx"))
+	{
+	  which = VL_API_TRACE_TX;
+	}
+      else if (unformat (input, "first %d", &first))
+	{
+	  ;
+	}
+      else if (unformat (input, "last %d", &last))
+	{
+	  ;
+	}
+      else if (unformat (input, "status"))
+	{
+	  vlib_cli_output (vm, "%U", format_vl_msg_api_trace_status,
+			   am, which);
+	}
+      else if (unformat (input, "free"))
+	{
+	  vl_msg_api_trace_onoff (am, which, 0);
+	  vl_msg_api_trace_free (am, which);
+	}
+      else if (unformat (input, "post-mortem-on"))
+	post_mortem_dump_enabled = 1;
+      else if (unformat (input, "post-mortem-off"))
+	post_mortem_dump_enabled = 0;
+      else
+	return clib_error_return (0, "unknown input `%U'",
+				  format_unformat_error, input);
     }
-    return 0;
+  return 0;
 }
 
+/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (api_trace_command, static) = {
     .path = "api trace",
-    .short_help = 
+    .short_help =
     "api trace [on|off][dump|save|replay <file>][status][free][post-mortem-on]",
     .function = api_trace_command_fn,
 };
+/* *INDENT-ON* */
 
 static clib_error_t *
 api_config_fn (vlib_main_t * vm, unformat_input_t * input)
 {
-    u32 nitems = 256<<10;
-    vl_api_trace_which_t which = VL_API_TRACE_RX;
-    api_main_t * am = &api_main;
-
-    while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
-        if (unformat (input, "on") || unformat (input, "enable")) {
-            if (unformat (input, "nitems %d", &nitems))
-                ;
-            vl_msg_api_trace_configure (am, which, nitems);
-            vl_msg_api_trace_onoff (am, which, 1 /* on */);
-            post_mortem_dump_enabled = 1;
-        } else
-            return clib_error_return (0, "unknown input `%U'",
-                                      format_unformat_error, input);
+  u32 nitems = 256 << 10;
+  vl_api_trace_which_t which = VL_API_TRACE_RX;
+  api_main_t *am = &api_main;
+
+  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+    {
+      if (unformat (input, "on") || unformat (input, "enable"))
+	{
+	  if (unformat (input, "nitems %d", &nitems))
+	    ;
+	  vl_msg_api_trace_configure (am, which, nitems);
+	  vl_msg_api_trace_onoff (am, which, 1 /* on */ );
+	  post_mortem_dump_enabled = 1;
+	}
+      else
+	return clib_error_return (0, "unknown input `%U'",
+				  format_unformat_error, input);
     }
-    return 0;
+  return 0;
 }
 
 VLIB_CONFIG_FUNCTION (api_config_fn, "api-trace");
 
-void vl_msg_api_post_mortem_dump (void)
+void
+vl_msg_api_post_mortem_dump (void)
 {
-    api_main_t * am = &api_main;
-    FILE *fp;
-    char filename[64];
-    int rv;
-
-    if (post_mortem_dump_enabled == 0)
-        return;
-
-    snprintf (filename, sizeof(filename), "/tmp/api_post_mortem.%d",
-              getpid());
-
-    fp = fopen (filename, "w");
-    if (fp == NULL) {
-        rv = write (2, "Couldn't create ", 16);
-        rv = write (2, filename, strlen(filename));
-        rv = write (2, "\n", 1);
-        return;
+  api_main_t *am = &api_main;
+  FILE *fp;
+  char filename[64];
+  int rv;
+
+  if (post_mortem_dump_enabled == 0)
+    return;
+
+  snprintf (filename, sizeof (filename), "/tmp/api_post_mortem.%d",
+	    getpid ());
+
+  fp = fopen (filename, "w");
+  if (fp == NULL)
+    {
+      rv = write (2, "Couldn't create ", 16);
+      rv = write (2, filename, strlen (filename));
+      rv = write (2, "\n", 1);
+      return;
     }
-    rv = vl_msg_api_trace_save (am, VL_API_TRACE_RX, fp);
-    fclose (fp);
-    if (rv < 0) {
-        rv = write (2, "Failed to save post-mortem API trace to ", 40);
-        rv = write (2, filename, strlen(filename));
-        rv = write (2, "\n", 1);
+  rv = vl_msg_api_trace_save (am, VL_API_TRACE_RX, fp);
+  fclose (fp);
+  if (rv < 0)
+    {
+      rv = write (2, "Failed to save post-mortem API trace to ", 40);
+      rv = write (2, filename, strlen (filename));
+      rv = write (2, "\n", 1);
     }
-    
+
 }
 
 /* Layered message handling support */
 
-void vl_msg_api_register_pd_handler (void *fp, u16 msg_id_host_byte_order)
+void
+vl_msg_api_register_pd_handler (void *fp, u16 msg_id_host_byte_order)
 {
-    api_main_t * am = &api_main;
-
-    /* Mild idiot proofing */
-    if (msg_id_host_byte_order > 10000)
-        clib_warning ("msg_id_host_byte_order endian issue? %d arg vs %d",
-                      msg_id_host_byte_order, 
-                      clib_net_to_host_u16 (msg_id_host_byte_order));
-    vec_validate (am->pd_msg_handlers, msg_id_host_byte_order);
-    am->pd_msg_handlers[msg_id_host_byte_order] = fp;
+  api_main_t *am = &api_main;
+
+  /* Mild idiot proofing */
+  if (msg_id_host_byte_order > 10000)
+    clib_warning ("msg_id_host_byte_order endian issue? %d arg vs %d",
+		  msg_id_host_byte_order,
+		  clib_net_to_host_u16 (msg_id_host_byte_order));
+  vec_validate (am->pd_msg_handlers, msg_id_host_byte_order);
+  am->pd_msg_handlers[msg_id_host_byte_order] = fp;
 }
 
-int vl_msg_api_pd_handler (void *mp, int rv)
+int
+vl_msg_api_pd_handler (void *mp, int rv)
 {
-    api_main_t * am = &api_main;
-    int (*fp)(void *, int);
-    u16 msg_id;
+  api_main_t *am = &api_main;
+  int (*fp) (void *, int);
+  u16 msg_id;
 
-    if (clib_arch_is_little_endian)
-        msg_id = clib_net_to_host_u16(*((u16 *)mp));
-    else
-        msg_id = *((u16 *)mp);
-    
-    if (msg_id >= vec_len (am->pd_msg_handlers)
-        || am->pd_msg_handlers[msg_id] == 0)
-        return rv;
-
-    fp = am->pd_msg_handlers [msg_id];
-    rv = (*fp)(mp, rv);
+  if (clib_arch_is_little_endian)
+    msg_id = clib_net_to_host_u16 (*((u16 *) mp));
+  else
+    msg_id = *((u16 *) mp);
+
+  if (msg_id >= vec_len (am->pd_msg_handlers)
+      || am->pd_msg_handlers[msg_id] == 0)
     return rv;
+
+  fp = am->pd_msg_handlers[msg_id];
+  rv = (*fp) (mp, rv);
+  return rv;
 }
 
-void vl_msg_api_set_first_available_msg_id (u16 first_avail)
+void
+vl_msg_api_set_first_available_msg_id (u16 first_avail)
 {
-    api_main_t * am = &api_main;
-    
-    am->first_available_msg_id = first_avail;
+  api_main_t *am = &api_main;
+
+  am->first_available_msg_id = first_avail;
 }
 
-u16 vl_msg_api_get_msg_ids (char * name, int n)
+u16
+vl_msg_api_get_msg_ids (char *name, int n)
 {
-    api_main_t * am = &api_main;
-    u8 * name_copy;
-    vl_api_msg_range_t * rp;
-    uword * p;
-    u16 rv;
-
-    if (am->msg_range_by_name == 0)
-        am->msg_range_by_name = hash_create_string (0, sizeof(uword));
-
-    name_copy = format (0, "%s%c", name, 0);
-    
-    p = hash_get_mem (am->msg_range_by_name, name_copy);
-    if (p) {
-        clib_warning ("WARNING: duplicate message range registration for '%s'",
-                      name_copy);
-        vec_free(name_copy);
-        return ((u16) ~0);
+  api_main_t *am = &api_main;
+  u8 *name_copy;
+  vl_api_msg_range_t *rp;
+  uword *p;
+  u16 rv;
+
+  if (am->msg_range_by_name == 0)
+    am->msg_range_by_name = hash_create_string (0, sizeof (uword));
+
+  name_copy = format (0, "%s%c", name, 0);
+
+  p = hash_get_mem (am->msg_range_by_name, name_copy);
+  if (p)
+    {
+      clib_warning ("WARNING: duplicate message range registration for '%s'",
+		    name_copy);
+      vec_free (name_copy);
+      return ((u16) ~ 0);
     }
 
-    if (n < 0 || n > 1024) {
-        clib_warning 
-            ("WARNING: bad number of message-IDs (%d) requested by '%s'",
-             n, name_copy);
-        vec_free(name_copy);
-        return ((u16) ~0);
+  if (n < 0 || n > 1024)
+    {
+      clib_warning
+	("WARNING: bad number of message-IDs (%d) requested by '%s'",
+	 n, name_copy);
+      vec_free (name_copy);
+      return ((u16) ~ 0);
     }
 
-    vec_add2 (am->msg_ranges, rp, 1);
+  vec_add2 (am->msg_ranges, rp, 1);
 
-    rv = rp->first_msg_id = am->first_available_msg_id;
-    am->first_available_msg_id += n;
-    rp->last_msg_id = am->first_available_msg_id - 1;
-    rp->name = name_copy;
+  rv = rp->first_msg_id = am->first_available_msg_id;
+  am->first_available_msg_id += n;
+  rp->last_msg_id = am->first_available_msg_id - 1;
+  rp->name = name_copy;
 
-    hash_set_mem (am->msg_range_by_name, name_copy, rp - am->msg_ranges);
+  hash_set_mem (am->msg_range_by_name, name_copy, rp - am->msg_ranges);
 
-    return rv;
+  return rv;
 }
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */