#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;
/* 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
'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;
u64 os_nsec;
} elog_time_stamp_t;
-typedef struct {
+typedef struct
+{
/* Total number of events in buffer. */
u32 n_total_events;
/* 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;
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)
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);
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;
}
/* 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);
}
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;
}
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. */
#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);
#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;
}
#endif /* CLIB_UNIX */
#endif /* included_clib_elog_h */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
Code Review / vpp.git / blobdiff