VPP-327 Coding standards cleanup for vppinfra

Fix additional a few additional deviations reported elsewhere by
checkstyle

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

1 files changed, 97 insertions, 83 deletions

diff --git a/vppinfra/vppinfra/elog.h b/vppinfra/vppinfra/elog.h
index afa677338e5..9756fb83a8d 100644
--- a/vppinfra/vppinfra/elog.h
+++ b/vppinfra/vppinfra/elog.h
@@ -41,13 +41,15 @@
 #define included_clib_elog_h
 
 #include <vppinfra/cache.h>
-#include <vppinfra/error.h>		/* for ASSERT */
+#include <vppinfra/error.h>	/* for ASSERT */
 #include <vppinfra/serialize.h>
-#include <vppinfra/time.h>		/* for clib_cpu_time_now */
+#include <vppinfra/time.h>	/* for clib_cpu_time_now */
 #include <vppinfra/mhash.h>
 
-typedef struct{
-  union {
+typedef struct
+{
+  union
+  {
     /* Absolute time stamp in CPU clock cycles. */
     u64 time_cycles;
 
@@ -60,23 +62,24 @@ typedef struct{
 
   /* Track for this event.  Tracks allow events to be sorted and
      displayed by track.  Think of 2 dimensional display with time and
-     track being the x and y axes.*/
+     track being the x and y axes. */
   u16 track;
 
   /* 20-bytes of data follows and pads to 32 bytes. */
   u8 data[20];
 } elog_event_t;
 
-typedef struct {
+typedef struct
+{
   /* Type index plus one assigned to this type.
      This is used to mark type as seen. */
   u32 type_index_plus_one;
 
   /* String table as a vector constructed when type is registered. */
-  char ** enum_strings_vector;
+  char **enum_strings_vector;
 
   /* Format string. (example: "my-event (%d,%d)"). */
-  char * format;
+  char *format;
 
   /* Specifies how arguments to format are parsed from event data.
      String of characters '0' '1' or '2' '3' to specify log2 size of data
@@ -85,28 +88,30 @@ typedef struct {
      't' means argument is an index into enum string table for this type.
      'e' is a float,
      'f' is a double. */
-  char * format_args;
+  char *format_args;
 
   /* Function name generating event. */
-  char * function;
+  char *function;
 
   /* Number of elements in string enum table. */
   u32 n_enum_strings;
 
   /* String table for enum/number to string formatting. */
-  char * enum_strings[];
+  char *enum_strings[];
 } elog_event_type_t;
 
-typedef struct {
+typedef struct
+{
   /* Track name vector. */
-  char * name;
+  char *name;
 
   /* Set to one when track has been added to
      main structure. */
   u32 track_index_plus_one;
 } elog_track_t;
 
-typedef struct {
+typedef struct
+{
   /* CPU cycle counter. */
   u64 cpu;
 
@@ -114,7 +119,8 @@ typedef struct {
   u64 os_nsec;
 } elog_time_stamp_t;
 
-typedef struct {
+typedef struct
+{
   /* Total number of events in buffer. */
   u32 n_total_events;
 
@@ -130,19 +136,19 @@ typedef struct {
 
   /* Vector of events (circular buffer).  Power of 2 size.
      Used when events are being collected. */
-  elog_event_t * event_ring;
+  elog_event_t *event_ring;
 
   /* Vector of event types. */
-  elog_event_type_t * event_types;
+  elog_event_type_t *event_types;
 
   /* Hash table mapping type format to type index. */
-  uword * event_type_by_format;
+  uword *event_type_by_format;
 
   /* Events may refer to strings in string table. */
-  char * string_table;
+  char *string_table;
 
   /* Vector of tracks. */
-  elog_track_t * tracks;
+  elog_track_t *tracks;
 
   /* Default track. */
   elog_track_t default_track;
@@ -153,23 +159,27 @@ typedef struct {
   elog_time_stamp_t init_time, serialize_time;
 
   /* SMP lock, non-zero means locking required */
-  uword * lock;
+  uword *lock;
 
   /* Use serialize_time and init_time to give estimate for
      cpu clock frequency. */
   f64 nsec_per_cpu_clock;
 
   /* Vector of events converted to generic form after collection. */
-  elog_event_t * events;
+  elog_event_t *events;
 } elog_main_t;
 
 always_inline uword
 elog_n_events_in_buffer (elog_main_t * em)
-{ return clib_min (em->n_total_events, em->event_ring_size); }
+{
+  return clib_min (em->n_total_events, em->event_ring_size);
+}
 
 always_inline uword
 elog_buffer_capacity (elog_main_t * em)
-{ return em->event_ring_size; }
+{
+  return em->event_ring_size;
+}
 
 always_inline void
 elog_reset_buffer (elog_main_t * em)
@@ -191,13 +201,18 @@ elog_enable_disable (elog_main_t * em, int is_enabled)
    event will not be lost as long as N < RING_SIZE. */
 always_inline void
 elog_disable_after_events (elog_main_t * em, uword n)
-{ em->n_total_events_disable_limit = em->n_total_events + n; }
+{
+  em->n_total_events_disable_limit = em->n_total_events + n;
+}
 
 /* Signal a trigger.  We do this when we encounter an event that we want to save
    context around (before and after). */
 always_inline void
 elog_disable_trigger (elog_main_t * em)
-{ em->n_total_events_disable_limit = em->n_total_events + vec_len (em->event_ring) / 2; }
+{
+  em->n_total_events_disable_limit =
+    em->n_total_events + vec_len (em->event_ring) / 2;
+}
 
 /* External function to register types/tracks. */
 word elog_event_type_register (elog_main_t * em, elog_event_type_t * t);
@@ -205,22 +220,23 @@ word elog_track_register (elog_main_t * em, elog_track_t * t);
 
 always_inline uword
 elog_is_enabled (elog_main_t * em)
-{ return em->n_total_events < em->n_total_events_disable_limit; }
+{
+  return em->n_total_events < em->n_total_events_disable_limit;
+}
 
 /* Add an event to the log.  Returns a pointer to the
    data for caller to write into. */
 always_inline void *
 elog_event_data_inline (elog_main_t * em,
 			elog_event_type_t * type,
-			elog_track_t * track,
-			u64 cpu_time)
+			elog_track_t * track, u64 cpu_time)
 {
-  elog_event_t * e;
+  elog_event_t *e;
   uword ei;
   word type_index, track_index;
 
   /* Return the user dummy memory to scribble data into. */
-  if (PREDICT_FALSE (! elog_is_enabled (em)))
+  if (PREDICT_FALSE (!elog_is_enabled (em)))
     return em->dummy_event.data;
 
   type_index = (word) type->type_index_plus_one - 1;
@@ -254,21 +270,18 @@ elog_event_data_inline (elog_main_t * em,
 }
 
 /* External version of inline. */
-void *
-elog_event_data (elog_main_t * em,
-		 elog_event_type_t * type,
-		 elog_track_t * track,
-		 u64 cpu_time);
+void *elog_event_data (elog_main_t * em,
+		       elog_event_type_t * type,
+		       elog_track_t * track, u64 cpu_time);
 
 /* Non-inline version. */
 always_inline void *
 elog_event_data_not_inline (elog_main_t * em,
 			    elog_event_type_t * type,
-			    elog_track_t * track,
-			    u64 cpu_time)
+			    elog_track_t * track, u64 cpu_time)
 {
   /* Return the user dummy memory to scribble data into. */
-  if (PREDICT_FALSE (! elog_is_enabled (em)))
+  if (PREDICT_FALSE (!elog_is_enabled (em)))
     return em->dummy_event.data;
   return elog_event_data (em, type, track, cpu_time);
 }
@@ -277,11 +290,10 @@ elog_event_data_not_inline (elog_main_t * em,
 always_inline void
 elog (elog_main_t * em, elog_event_type_t * type, u32 data)
 {
-  u32 * d = elog_event_data_not_inline
-    (em,
-     type,
-     &em->default_track,
-     clib_cpu_time_now ());
+  u32 *d = elog_event_data_not_inline (em,
+				       type,
+				       &em->default_track,
+				       clib_cpu_time_now ());
   d[0] = data;
 }
 
@@ -289,52 +301,46 @@ elog (elog_main_t * em, elog_event_type_t * type, u32 data)
 always_inline void
 elog_inline (elog_main_t * em, elog_event_type_t * type, u32 data)
 {
-  u32 * d = elog_event_data_inline
-    (em,
-     type,
-     &em->default_track,
-     clib_cpu_time_now ());
+  u32 *d = elog_event_data_inline (em,
+				   type,
+				   &em->default_track,
+				   clib_cpu_time_now ());
   d[0] = data;
 }
 
 always_inline void
-elog_track (elog_main_t * em, elog_event_type_t * type, elog_track_t *track, 
-            u32 data)
+elog_track (elog_main_t * em, elog_event_type_t * type, elog_track_t * track,
+	    u32 data)
 {
-  u32 * d = elog_event_data_not_inline
-    (em,
-     type,
-     track,
-     clib_cpu_time_now ());
+  u32 *d = elog_event_data_not_inline (em,
+				       type,
+				       track,
+				       clib_cpu_time_now ());
   d[0] = data;
 }
 
 always_inline void
-elog_track_inline (elog_main_t * em, elog_event_type_t * type, 
-                   elog_track_t *track, u32 data)
+elog_track_inline (elog_main_t * em, elog_event_type_t * type,
+		   elog_track_t * track, u32 data)
 {
-  u32 * d = elog_event_data_inline
-    (em,
-     type,
-     track,
-     clib_cpu_time_now ());
+  u32 *d = elog_event_data_inline (em,
+				   type,
+				   track,
+				   clib_cpu_time_now ());
   d[0] = data;
 }
 
 always_inline void *
 elog_data (elog_main_t * em, elog_event_type_t * type, elog_track_t * track)
 {
-  return elog_event_data_not_inline
-    (em, type, track,
-     clib_cpu_time_now ());
+  return elog_event_data_not_inline (em, type, track, clib_cpu_time_now ());
 }
 
 always_inline void *
-elog_data_inline (elog_main_t * em, elog_event_type_t * type, elog_track_t * track)
+elog_data_inline (elog_main_t * em, elog_event_type_t * type,
+		  elog_track_t * track)
 {
-  return elog_event_data_inline
-    (em, type, track,
-     clib_cpu_time_now ());
+  return elog_event_data_inline (em, type, track, clib_cpu_time_now ());
 }
 
 /* Macro shorthands for generating/declaring events. */
@@ -386,23 +392,23 @@ elog_data_inline (elog_main_t * em, elog_event_type_t * type, elog_track_t * tra
 #define ELOG_DATA(em,f) elog_data ((em), &__ELOG_TYPE_VAR (f), &(em)->default_track)
 #define ELOG_DATA_INLINE(em,f) elog_data_inline ((em), &__ELOG_TYPE_VAR (f), &(em)->default_track)
 
-u32 elog_string (elog_main_t * em, char * format, ...);
+u32 elog_string (elog_main_t * em, char *format, ...);
 void elog_time_now (elog_time_stamp_t * et);
 
 /* Convert ievents to events and return them as a vector.
    Sets em->events to resulting vector. */
-elog_event_t * elog_get_events (elog_main_t * em);
+elog_event_t *elog_get_events (elog_main_t * em);
 
 /* Convert ievents to events and return them as a vector with no side effects. */
-elog_event_t * elog_peek_events (elog_main_t * em);
+elog_event_t *elog_peek_events (elog_main_t * em);
 
 /* Merge two logs, add supplied track tags. */
-void elog_merge (elog_main_t * dst, u8 * dst_tag, 
-                 elog_main_t * src, u8 * src_tag);
+void elog_merge (elog_main_t * dst, u8 * dst_tag,
+		 elog_main_t * src, u8 * src_tag);
 
 /* 2 arguments elog_main_t and elog_event_t to format event or track name. */
-u8 * format_elog_event (u8 * s, va_list * va);
-u8 * format_elog_track (u8 * s, va_list * va);
+u8 *format_elog_event (u8 * s, va_list * va);
+u8 *format_elog_track (u8 * s, va_list * va);
 
 void serialize_elog_main (serialize_main_t * m, va_list * va);
 void unserialize_elog_main (serialize_main_t * m, va_list * va);
@@ -412,31 +418,31 @@ void elog_alloc (elog_main_t * em, u32 n_events);
 
 #ifdef CLIB_UNIX
 always_inline clib_error_t *
-elog_write_file (elog_main_t * em, char * unix_file)
+elog_write_file (elog_main_t * em, char *unix_file)
 {
   serialize_main_t m;
-  clib_error_t * error;
+  clib_error_t *error;
 
   error = serialize_open_unix_file (&m, unix_file);
   if (error)
     return error;
   error = serialize (&m, serialize_elog_main, em);
-  if (! error)
+  if (!error)
     serialize_close (&m);
   return error;
 }
 
 always_inline clib_error_t *
-elog_read_file (elog_main_t * em, char * unix_file)
+elog_read_file (elog_main_t * em, char *unix_file)
 {
   serialize_main_t m;
-  clib_error_t * error;
+  clib_error_t *error;
 
   error = unserialize_open_unix_file (&m, unix_file);
   if (error)
     return error;
   error = unserialize (&m, unserialize_elog_main, em);
-  if (! error)
+  if (!error)
     unserialize_close (&m);
   return error;
 }
@@ -444,3 +450,11 @@ elog_read_file (elog_main_t * em, char * unix_file)
 #endif /* CLIB_UNIX */
 
 #endif /* included_clib_elog_h */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */