uproctrace

@@ -5,6 +5,6 @@ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Werror -fPIC")

 enable_testing()

+add_subdirectory(liblwptev)

 add_subdirectory(liblwptpl)

-add_subdirectory(liblwpttr)

 add_subdirectory(tests)

@@ -3,18 +3,18 @@ add_custom_command(

   ${CMAKE_CURRENT_BINARY_DIR}/src/lwproctrace.pb-c.c

   ${CMAKE_CURRENT_BINARY_DIR}/src/lwproctrace.pb-c.h

   DEPENDS

-  ${CMAKE_CURRENT_SOURCE_DIR}/lwproctrace.proto

+  ${CMAKE_SOURCE_DIR}/lwproctrace.proto

   COMMAND

-  protoc-c --proto_path ${CMAKE_CURRENT_SOURCE_DIR}

+  protoc-c --proto_path ${CMAKE_SOURCE_DIR}

            --c_out ${CMAKE_CURRENT_BINARY_DIR}/src

            lwproctrace.proto

 )

 add_library(

-  lwpttr

+  lwptev

   STATIC

-  include/liblwpttr/proc_begin.h

-  include/liblwpttr/proc_end.h

+  include/liblwptev/proc_begin.h

+  include/liblwptev/proc_end.h

   src/cleaner.c

   src/cleaner.h

   src/event.c

@@ -33,7 +33,7 @@ add_library(

 )

 target_include_directories(

-  lwpttr

+  lwptev

   PUBLIC

   include

   PRIVATE

@@ -41,7 +41,7 @@ target_include_directories(

 )

 target_link_libraries(

-  lwpttr

+  lwptev

   PUBLIC

   -lprotobuf-c

 )

@@ -10,6 +10,6 @@

  * @return 0 on success (*data, *size set),

  *         -1 on error (*data = NULL, *size = 0)

  */

-int lwpttr_proc_begin(void **data, size_t *size);

+int lwptev_proc_begin(void **data, size_t *size);

 #endif /* #ifndef LWPTTR_PROC_BEGIN_H */

@@ -10,6 +10,6 @@

  * @return 0 on success (*data, *size set),

  *         -1 on error (*data = NULL, *size = 0)

  */

-int lwpttr_proc_end(void **data, size_t *size);

+int lwptev_proc_end(void **data, size_t *size);

 #endif /* #ifndef LWPTTR_PROC_END_H */

@@ -3,14 +3,14 @@

 #include <stdlib.h>

-struct lwpttr_cleaner_s {

+struct lwptev_cleaner_s {

   unsigned int free_ptr_cnt; /**< number of pointer to be freed */

   void * free_ptrs[64]; /**< pointers to be freed */

-  lwpttr_cleaner_t *next; /**< next cleaner object, linked list */

+  lwptev_cleaner_t *next; /**< next cleaner object, linked list */

 };

-lwpttr_cleaner_t * lwpttr_cleaner_new(void) {

-  lwpttr_cleaner_t *cleaner = malloc(sizeof(lwpttr_cleaner_t));

+lwptev_cleaner_t * lwptev_cleaner_new(void) {

+  lwptev_cleaner_t *cleaner = malloc(sizeof(lwptev_cleaner_t));

   if (! cleaner) {

     return NULL;

   }

@@ -19,20 +19,20 @@ lwpttr_cleaner_t * lwpttr_cleaner_new(void) {

   return cleaner;

 }

-int lwpttr_cleaner_add_ptr(lwpttr_cleaner_t *cleaner, void *ptr) {

+int lwptev_cleaner_add_ptr(lwptev_cleaner_t *cleaner, void *ptr) {

   /* find last cleaner in chain */

-  lwpttr_cleaner_t *cl = cleaner;

+  lwptev_cleaner_t *cl = cleaner;

   while (cl->next != NULL) {

     cl = cl->next;

   }

   /* last cleaner full? */

   if (cl->free_ptr_cnt >= countof(cl->free_ptrs)) {

     /* create new one */

-    cl->next = lwpttr_cleaner_new();

+    cl->next = lwptev_cleaner_new();

     /* error ? */

     if (! cl->next) {

       /* cleanup everything and reutrn error */

-      lwpttr_cleaner_cleanup(cleaner);

+      lwptev_cleaner_cleanup(cleaner);

       return -1;

     }

     /* go to new cleaner */

@@ -43,8 +43,8 @@ int lwpttr_cleaner_add_ptr(lwpttr_cleaner_t *cleaner, void *ptr) {

   return 0;

 }

-void lwpttr_cleaner_cleanup(lwpttr_cleaner_t *cleaner) {

-  lwpttr_cleaner_t *cl = cleaner;

+void lwptev_cleaner_cleanup(lwptev_cleaner_t *cleaner) {

+  lwptev_cleaner_t *cl = cleaner;

   while (cl) {

     /* free all pointers in cleaner */

     for (unsigned int i = 0; i < cl->free_ptr_cnt; ++i) {

@@ -6,13 +6,13 @@

  *

  * collects pointers to be freed and frees them on request

  */

-typedef struct lwpttr_cleaner_s lwpttr_cleaner_t;

+typedef struct lwptev_cleaner_s lwptev_cleaner_t;

 /**

  * @brief creater cleaner object

  * @return pointer to cleaner object or NULL on error

  */

-lwpttr_cleaner_t * lwpttr_cleaner_new(void);

+lwptev_cleaner_t * lwptev_cleaner_new(void);

 /**

  * @brief add pointer to be freed to cleaner object

@@ -21,12 +21,12 @@ lwpttr_cleaner_t * lwpttr_cleaner_new(void);

  * @return 0 on success, -1 on error

  *         (on error, cleanup is done and cleaner is deallocated)

  */

-int lwpttr_cleaner_add_ptr(lwpttr_cleaner_t *cleaner, void *ptr);

+int lwptev_cleaner_add_ptr(lwptev_cleaner_t *cleaner, void *ptr);

 /**

  * @brief cleanup all pointers in cleaner and free cleaner itself

  * @param[in] cleaner cleaner object

  */

-void lwpttr_cleaner_cleanup(lwpttr_cleaner_t *cleaner);

+void lwptev_cleaner_cleanup(lwptev_cleaner_t *cleaner);

 #endif /* #ifndef LWPTTR_CLEANER_H */

@@ -14,17 +14,17 @@

  * @return 0 on success (*data, *size set),

  *         -1 on error (*data = NULL, *size = 0)

  */

-int lwpttr_event_pack(struct _Lwproctrace__Event *event,

+int lwptev_event_pack(struct _Lwproctrace__Event *event,

                       void **data, size_t *size,

-                      lwpttr_cleaner_t *cleaner) {

+                      lwptev_cleaner_t *cleaner) {

   *size = lwproctrace__event__get_packed_size(event);

   *data = malloc(*size);

   if (! data) {

-    lwpttr_cleaner_cleanup(cleaner);

+    lwptev_cleaner_cleanup(cleaner);

     *size = 0;

     return -1;

   }

   *size = lwproctrace__event__pack(event, *data);

-  lwpttr_cleaner_cleanup(cleaner);

+  lwptev_cleaner_cleanup(cleaner);

   return 0;

 }

@@ -16,8 +16,8 @@

  * @return 0 on success (*data, *size set),

  *         -1 on error (*data = NULL, *size = 0)

  */

-int lwpttr_event_pack(struct _Lwproctrace__Event *event,

+int lwptev_event_pack(struct _Lwproctrace__Event *event,

                       void **data, size_t *size,

-                      lwpttr_cleaner_t *cleaner);

+                      lwptev_cleaner_t *cleaner);

 #endif /* #ifndef LWPTTR_EVENT_H */

@@ -1,4 +1,4 @@

-#include <liblwpttr/proc_begin.h>

+#include <liblwptev/proc_begin.h>

 #include "cleaner.h"

 #include "event.h"

 #include "stringlist.h"

@@ -11,17 +11,17 @@

 #include <sys/types.h>

 #include <unistd.h>

-int lwpttr_proc_begin(void **data, size_t *size) {

+int lwptev_proc_begin(void **data, size_t *size) {

   *data = NULL;

   *size = 0;

-  lwpttr_cleaner_t *cleaner = lwpttr_cleaner_new();

+  lwptev_cleaner_t *cleaner = lwptev_cleaner_new();

   if (! cleaner) {

     return -1;

   }

   struct _Lwproctrace__Timespec timestamp = LWPROCTRACE__TIMESPEC__INIT;

-  timing_get_timestamp(&timestamp);

+  lwptev_timing_get_timestamp(&timestamp);

   struct _Lwproctrace__ProcBegin proc_begin = LWPROCTRACE__PROC_BEGIN__INIT;

   proc_begin.pid = getpid();

@@ -46,5 +46,5 @@ int lwpttr_proc_begin(void **data, size_t *size) {

   event.timestamp = &timestamp;

   event.proc_begin = &proc_begin;

-  return lwpttr_event_pack(&event, data, size, cleaner);

+  return lwptev_event_pack(&event, data, size, cleaner);

 }

@@ -1,4 +1,4 @@

-#include <liblwpttr/proc_end.h>

+#include <liblwptev/proc_end.h>

 #include "cleaner.h"

 #include "event.h"

 #include "timing.h"

@@ -9,20 +9,20 @@

 #include <sys/types.h>

 #include <unistd.h>

-int lwpttr_proc_end(void **data, size_t *size) {

+int lwptev_proc_end(void **data, size_t *size) {

   *data = NULL;

   *size = 0;

-  lwpttr_cleaner_t *cleaner = lwpttr_cleaner_new();

+  lwptev_cleaner_t *cleaner = lwptev_cleaner_new();

   if (! cleaner) {

     return -1;

   }

   struct _Lwproctrace__Timespec timestamp = LWPROCTRACE__TIMESPEC__INIT;

-  timing_get_timestamp(&timestamp);

+  lwptev_timing_get_timestamp(&timestamp);

   struct _Lwproctrace__Timespec proc_cpu_time = LWPROCTRACE__TIMESPEC__INIT;

-  timing_get_proc_cpu_time(&proc_cpu_time);

+  lwptev_timing_get_proc_cpu_time(&proc_cpu_time);

   struct _Lwproctrace__ProcEnd proc_end = LWPROCTRACE__PROC_END__INIT;

   proc_end.pid = getpid();

@@ -32,5 +32,5 @@ int lwpttr_proc_end(void **data, size_t *size) {

   event.timestamp = &timestamp;

   event.proc_end = &proc_end;

-  return lwpttr_event_pack(&event, data, size, cleaner);

+  return lwptev_event_pack(&event, data, size, cleaner);

 }

@@ -95,25 +95,25 @@ static char ** stringlist_make_ptrs(char *data, size_t sz, size_t *cnt) {

 }

 int stringlist_read(char const *pathname, size_t *n, char ***strs,

-                    lwpttr_cleaner_t *cleaner) {

+                    lwptev_cleaner_t *cleaner) {

   *n = 0;

   *strs = NULL;

   /* read file contents */

   size_t sz;

   char *data = stringlist_read_file(pathname, &sz);

   if (! data) {

-    lwpttr_cleaner_cleanup(cleaner);

+    lwptev_cleaner_cleanup(cleaner);

     return -1;

   }

-  lwpttr_cleaner_add_ptr(cleaner, data);

+  lwptev_cleaner_add_ptr(cleaner, data);

   /* create pointer array */

   size_t cnt;

   char **ptrs = stringlist_make_ptrs(data, sz, &cnt);

   if (! ptrs) {

-    lwpttr_cleaner_cleanup(cleaner);

+    lwptev_cleaner_cleanup(cleaner);

     return -1;

   }

-  lwpttr_cleaner_add_ptr(cleaner, ptrs);

+  lwptev_cleaner_add_ptr(cleaner, ptrs);

   *n = cnt;

   *strs = ptrs;

   return 0;

@@ -15,6 +15,6 @@

  *         (on error, cleanup is done and cleaner is deallocated)

  */

 int stringlist_read(char const *pathname, size_t *n, char ***strs,

-                    lwpttr_cleaner_t *cleaner);

+                    lwptev_cleaner_t *cleaner);

 #endif /* #ifndef LWPTTR_STRINGLIST_H */

@@ -36,12 +36,12 @@ static char * symlink_read_target(char const *pathname) {

 }

 int symlink_read(char const *pathname, char **target,

-                 lwpttr_cleaner_t *cleaner) {

+                 lwptev_cleaner_t *cleaner) {

   *target = symlink_read_target(pathname);

   if (! *target) {

-    lwpttr_cleaner_cleanup(cleaner);

+    lwptev_cleaner_cleanup(cleaner);

     return -1;

   }

-  lwpttr_cleaner_add_ptr(cleaner, *target);

+  lwptev_cleaner_add_ptr(cleaner, *target);

   return 0;

 }

@@ -12,6 +12,6 @@

  *         (on error, cleanup is done and cleaner is deallocated)

  */

 int symlink_read(char const *pathname, char **target,

-                 lwpttr_cleaner_t *cleaner);

+                 lwptev_cleaner_t *cleaner);

 #endif /* #ifndef LWPTTR_SYMLINK_H */

@@ -0,0 +1,23 @@

+#include "timing.h"

+

+#include <lwproctrace.pb-c.h>

+

+#include <time.h>

+

+static void lwptev_timing_clock_gettime(clockid_t clockid,

+                                        struct _Lwproctrace__Timespec *tsp) {

+  struct timespec ts;

+  clock_gettime(clockid, &ts);

+  tsp->sec = ts.tv_sec;

+  tsp->has_nsec = 1;

+  tsp->nsec = ts.tv_nsec;

+}

+

+void lwptev_timing_get_timestamp(struct _Lwproctrace__Timespec *timestamp) {

+  lwptev_timing_clock_gettime(CLOCK_REALTIME, timestamp);

+}

+

+void lwptev_timing_get_proc_cpu_time(struct _Lwproctrace__Timespec

+                                     *proc_cpu_time) {

+  lwptev_timing_clock_gettime(CLOCK_PROCESS_CPUTIME_ID, proc_cpu_time);

+}

@@ -7,12 +7,13 @@

  * @brief fill timestamp with current time

  * @param[in,out] timestamp initialized structure to set to current time

  */

-void timing_get_timestamp(struct _Lwproctrace__Timespec *timestamp);

+void lwptev_timing_get_timestamp(struct _Lwproctrace__Timespec *timestamp);

 /**

  * @brief fill timestamp with total CPU time used by process

  * @param[in,out] timestamp initialized structure to set to proccess CPU time

  */

-void timing_get_proc_cpu_time(struct _Lwproctrace__Timespec *proc_cpu_time);

+void lwptev_timing_get_proc_cpu_time(struct _Lwproctrace__Timespec

+                                     *proc_cpu_time);

 #endif /* #ifndef LWPTTR_TIMING_H */

@@ -7,5 +7,5 @@ add_library(

   src/write.h

 )

-target_link_libraries(lwptpl lwpttr)

+target_link_libraries(lwptpl lwptev)

@@ -1,4 +1,4 @@

-#include <liblwpttr/proc_begin.h>

+#include <liblwptev/proc_begin.h>

 #include "write.h"

@@ -7,6 +7,6 @@

 __attribute__((constructor)) static void constructor(void) {

   void *data = NULL;

   size_t size = 0;

-  lwpttr_proc_begin(&data, &size);

+  lwptev_proc_begin(&data, &size);

   lwptpl_write(data, size);

 }

@@ -1,4 +1,4 @@

-#include <liblwpttr/proc_end.h>

+#include <liblwptev/proc_end.h>

 #include "write.h"

@@ -7,6 +7,6 @@

 __attribute__((destructor)) static void destructor(void) {

   void *data = NULL;

   size_t size = 0;

-  lwpttr_proc_end(&data, &size);

+  lwptev_proc_end(&data, &size);

   lwptpl_write(data, size);

 }

@@ -1,22 +0,0 @@

-#include "timing.h"

-

-#include <lwproctrace.pb-c.h>

-

-#include <time.h>

-

-static void timing_clock_gettime(clockid_t clockid,

-                                 struct _Lwproctrace__Timespec *tsp) {

-  struct timespec ts;

-  clock_gettime(clockid, &ts);

-  tsp->sec = ts.tv_sec;

-  tsp->has_nsec = 1;

-  tsp->nsec = ts.tv_nsec;

-}

-

-void timing_get_timestamp(struct _Lwproctrace__Timespec *timestamp) {

-  timing_clock_gettime(CLOCK_REALTIME, timestamp);

-}

-

-void timing_get_proc_cpu_time(struct _Lwproctrace__Timespec *proc_cpu_time) {

-  timing_clock_gettime(CLOCK_PROCESS_CPUTIME_ID, proc_cpu_time);

-}

@@ -12,7 +12,7 @@ add_test(

       /bin/false e f 'g h'

     )

     ls -l out.proto

-    protoc --proto_path ${CMAKE_SOURCE_DIR}/liblwpttr lwproctrace.proto \

+    protoc --proto_path ${CMAKE_SOURCE_DIR} lwproctrace.proto \

            --decode lwproctrace.event < out.proto

   "

 )