uproctrace

@@ -1,11 +1,11 @@

 cmake_minimum_required(VERSION 3.10)

-project(lwproctrace)

+project(uproctrace)

 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Werror -fPIC")

 enable_testing()

 add_subdirectory(dump)

-add_subdirectory(liblwptev)

-add_subdirectory(liblwptpl)

+add_subdirectory(libuptev)

+add_subdirectory(libuptpl)

 add_subdirectory(tests)

@@ -1,12 +1,12 @@

 add_custom_command(

   OUTPUT

-  ${CMAKE_CURRENT_BINARY_DIR}/lwproctrace_pb2.py

+  ${CMAKE_CURRENT_BINARY_DIR}/uproctrace_pb2.py

   DEPENDS

-  ${CMAKE_SOURCE_DIR}/lwproctrace.proto

+  ${CMAKE_SOURCE_DIR}/uproctrace.proto

   COMMAND

   protoc --proto_path ${CMAKE_SOURCE_DIR}

          --python_out ${CMAKE_CURRENT_BINARY_DIR}

-         lwproctrace.proto

+         uproctrace.proto

 )

 add_custom_command(

@@ -22,6 +22,6 @@ add_custom_target(

   dump

   ALL

   DEPENDS

-  ${CMAKE_CURRENT_BINARY_DIR}/lwproctrace_pb2.py

+  ${CMAKE_CURRENT_BINARY_DIR}/uproctrace_pb2.py

   ${CMAKE_CURRENT_BINARY_DIR}/dump.py

 )

@@ -1,12 +1,12 @@

 #! /usr/bin/env python3

 import argparse

-import lwproctrace_pb2

+import uproctrace_pb2

 import struct

 def parse_args():

-    parser = argparse.ArgumentParser(description='dump lwproctrace trace')

+    parser = argparse.ArgumentParser(description='dump uproctrace trace')

     parser.add_argument('trace', help='trace file')

     args = parser.parse_args()

     return args

@@ -15,7 +15,7 @@ def parse_args():

 def dump_event(f):

     # skip till after magic

     magic = f.read(4)

-    while magic != b'lwpt':

+    while magic != b'upt0':

         if len(magic) < 4:

             return False  # EOF

         magic = magic[1:] + f.read(1)  # search for magic byte for byte

@@ -29,7 +29,7 @@ def dump_event(f):

     if len(data) < size:

         return False  # EOF

     # unpack event

-    event = lwproctrace_pb2.event.FromString(data)

+    event = uproctrace_pb2.event.FromString(data)

     # dump event

     print('event {')

     for line in repr(event).split('\n'):

@@ -1,6 +0,0 @@

-#ifndef LWPTEV_MACROS_H

-#define LWPTEV_MACROS_H

-

-#define countof(arr) (sizeof(arr) / sizeof((arr)[0]))

-

-#endif /* #ifndef LWPTEV_MACROS_H */

@@ -1,50 +0,0 @@

-#include <liblwptev/proc_begin.h>

-#include "cleaner.h"

-#include "event.h"

-#include "stringlist.h"

-#include "symlink.h"

-#include "timing.h"

-

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

-

-#include <stdlib.h>

-#include <sys/types.h>

-#include <unistd.h>

-

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

-  *data = NULL;

-  *size = 0;

-

-  lwptev_cleaner_t *cleaner = lwptev_cleaner_new();

-  if (! cleaner) {

-    return -1;

-  }

-

-  struct _Lwproctrace__Timespec timestamp = LWPROCTRACE__TIMESPEC__INIT;

-  lwptev_timing_get_timestamp(&timestamp);

-

-  struct _Lwproctrace__ProcBegin proc_begin = LWPROCTRACE__PROC_BEGIN__INIT;

-  proc_begin.pid = getpid();

-  proc_begin.has_ppid = 1;

-  proc_begin.ppid = getppid();

-  if (lwptev_symlink_read("/proc/self/exe", &proc_begin.exe, cleaner) != 0) {

-    return -1;

-  }

-  if (lwptev_symlink_read("/proc/self/cwd", &proc_begin.cwd, cleaner) != 0) {

-    return -1;

-  }

-  if (lwptev_stringlist_read("/proc/self/cmdline", &proc_begin.n_cmdline,

-                             &proc_begin.cmdline, cleaner) != 0) {

-    return -1;

-  }

-  if (lwptev_stringlist_read("/proc/self/environ", &proc_begin.n_environ,

-                             &proc_begin.environ, cleaner) != 0) {

-    return -1;

-  }

-

-  struct _Lwproctrace__Event event = LWPROCTRACE__EVENT__INIT;

-  event.timestamp = &timestamp;

-  event.proc_begin = &proc_begin;

-

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

-}

@@ -1,36 +0,0 @@

-#include <liblwptev/proc_end.h>

-#include "cleaner.h"

-#include "event.h"

-#include "timing.h"

-

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

-

-#include <stdlib.h>

-#include <sys/types.h>

-#include <unistd.h>

-

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

-  *data = NULL;

-  *size = 0;

-

-  lwptev_cleaner_t *cleaner = lwptev_cleaner_new();

-  if (! cleaner) {

-    return -1;

-  }

-

-  struct _Lwproctrace__Timespec timestamp = LWPROCTRACE__TIMESPEC__INIT;

-  lwptev_timing_get_timestamp(&timestamp);

-

-  struct _Lwproctrace__Timespec proc_cpu_time = LWPROCTRACE__TIMESPEC__INIT;

-  lwptev_timing_get_proc_cpu_time(&proc_cpu_time);

-

-  struct _Lwproctrace__ProcEnd proc_end = LWPROCTRACE__PROC_END__INIT;

-  proc_end.pid = getpid();

-  proc_end.proc_cpu_time = &proc_cpu_time;

-

-  struct _Lwproctrace__Event event = LWPROCTRACE__EVENT__INIT;

-  event.timestamp = &timestamp;

-  event.proc_end = &proc_end;

-

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

-}

@@ -1,20 +0,0 @@

-#ifndef LWPTEV_STRINGLIST_H

-#define LWPTEV_STRINGLIST_H

-

-#include "cleaner.h"

-

-#include <stdlib.h>

-

-/**

- * @brief read string list file

- * @param[in] pathname path to file containing zero-terminated string list

- * @param[out] *n number of strings read

- * @param[out] *strs strings read

- * @param[in,out] cleaner object, malloc-ed string is added to it

- * @return 0 on success, -1 on error

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

- */

-int lwptev_stringlist_read(char const *pathname, size_t *n, char ***strs,

-                           lwptev_cleaner_t *cleaner);

-

-#endif /* #ifndef LWPTEV_STRINGLIST_H */

@@ -1,17 +0,0 @@

-#ifndef LWPTEV_SYMLINK_H

-#define LWPTEV_SYMLINK_H

-

-#include "cleaner.h"

-

-/**

- * @brief read symlink

- * @param[in] pathname path to symbolic link

- * @param[out] *target malloc-ed string object containing symlink target

- * @param[in,out] cleaner object, malloc-ed string is added to it

- * @return 0 on success, -1 on error

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

- */

-int lwptev_symlink_read(char const *pathname, char **target,

-                        lwptev_cleaner_t *cleaner);

-

-#endif /* #ifndef LWPTEV_SYMLINK_H */

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

-#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);

-}

@@ -1,8 +0,0 @@

-#ifndef LWPTPL_WRITE_H

-#define LWPTPL_WRITE_H

-

-#include <stdlib.h>

-

-void lwptpl_write(void const *data, size_t size);

-

-#endif /* #ifndef LWPTPL_WRITE_H */

@@ -1,20 +1,20 @@

 add_custom_command(

   OUTPUT

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

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

+  ${CMAKE_CURRENT_BINARY_DIR}/src/uproctrace.pb-c.c

+  ${CMAKE_CURRENT_BINARY_DIR}/src/uproctrace.pb-c.h

   DEPENDS

-  ${CMAKE_SOURCE_DIR}/lwproctrace.proto

+  ${CMAKE_SOURCE_DIR}/uproctrace.proto

   COMMAND

   protoc-c --proto_path ${CMAKE_SOURCE_DIR}

            --c_out ${CMAKE_CURRENT_BINARY_DIR}/src

-           lwproctrace.proto

+           uproctrace.proto

 )

 add_library(

-  lwptev

+  uptev

   STATIC

-  include/liblwptev/proc_begin.h

-  include/liblwptev/proc_end.h

+  include/uptev/proc_begin.h

+  include/uptev/proc_end.h

   src/cleaner.c

   src/cleaner.h

   src/event.c

@@ -30,12 +30,12 @@ add_library(

   src/symlink.h

   src/timing.c

   src/timing.h

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

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

+  ${CMAKE_CURRENT_BINARY_DIR}/src/uproctrace.pb-c.c

+  ${CMAKE_CURRENT_BINARY_DIR}/src/uproctrace.pb-c.h

 )

 target_include_directories(

-  lwptev

+  uptev

   PUBLIC

   include

   PRIVATE

@@ -43,7 +43,7 @@ target_include_directories(

 )

 target_link_libraries(

-  lwptev

+  uptev

   PUBLIC

   -lprotobuf-c

 )

@@ -1,5 +1,5 @@

-#ifndef LWPTEV_PROC_BEGIN_H

-#define LWPTEV_PROC_BEGIN_H

+#ifndef UPTEV_PROC_BEGIN_H

+#define UPTEV_PROC_BEGIN_H

 #include <stdlib.h>

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

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

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

  */

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

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

-#endif /* #ifndef LWPTEV_PROC_BEGIN_H */

+#endif /* #ifndef UPTEV_PROC_BEGIN_H */

@@ -1,5 +1,5 @@

-#ifndef LWPTEV_PROC_END_H

-#define LWPTEV_PROC_END_H

+#ifndef UPTEV_PROC_END_H

+#define UPTEV_PROC_END_H

 #include <stdlib.h>

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

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

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

  */

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

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

-#endif /* #ifndef LWPTEV_PROC_END_H */

+#endif /* #ifndef UPTEV_PROC_END_H */

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

 #include <stdlib.h>

-struct lwptev_cleaner_s {

+struct uptev_cleaner_s {

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

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

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

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

 };

-lwptev_cleaner_t * lwptev_cleaner_new(void) {

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

+uptev_cleaner_t * uptev_cleaner_new(void) {

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

   if (! cleaner) {

     return NULL;

   }

@@ -19,20 +19,20 @@ lwptev_cleaner_t * lwptev_cleaner_new(void) {

   return cleaner;

 }

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

+int uptev_cleaner_add_ptr(uptev_cleaner_t *cleaner, void *ptr) {

   /* find last cleaner in chain */

-  lwptev_cleaner_t *cl = cleaner;

+  uptev_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 = lwptev_cleaner_new();

+    cl->next = uptev_cleaner_new();

     /* error ? */

     if (! cl->next) {

       /* cleanup everything and reutrn error */

-      lwptev_cleaner_cleanup(cleaner);

+      uptev_cleaner_cleanup(cleaner);

       return -1;

     }

     /* go to new cleaner */

@@ -43,8 +43,8 @@ int lwptev_cleaner_add_ptr(lwptev_cleaner_t *cleaner, void *ptr) {

   return 0;

 }

-void lwptev_cleaner_cleanup(lwptev_cleaner_t *cleaner) {

-  lwptev_cleaner_t *cl = cleaner;

+void uptev_cleaner_cleanup(uptev_cleaner_t *cleaner) {

+  uptev_cleaner_t *cl = cleaner;

   while (cl) {

     /* free all pointers in cleaner */

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

@@ -1,18 +1,18 @@

-#ifndef LWPTEV_CLEANER_H

-#define LWPTEV_CLEANER_H

+#ifndef UPTEV_CLEANER_H

+#define UPTEV_CLEANER_H

 /**

  * @brief cleaner object

  *

  * collects pointers to be freed and frees them on request

  */

-typedef struct lwptev_cleaner_s lwptev_cleaner_t;

+typedef struct uptev_cleaner_s uptev_cleaner_t;

 /**

  * @brief creater cleaner object

  * @return pointer to cleaner object or NULL on error

  */

-lwptev_cleaner_t * lwptev_cleaner_new(void);

+uptev_cleaner_t * uptev_cleaner_new(void);

 /**

  * @brief add pointer to be freed to cleaner object

@@ -21,12 +21,12 @@ lwptev_cleaner_t * lwptev_cleaner_new(void);

  * @return 0 on success, -1 on error

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

  */

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

+int uptev_cleaner_add_ptr(uptev_cleaner_t *cleaner, void *ptr);

 /**

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

  * @param[in] cleaner cleaner object

  */

-void lwptev_cleaner_cleanup(lwptev_cleaner_t *cleaner);

+void uptev_cleaner_cleanup(uptev_cleaner_t *cleaner);

-#endif /* #ifndef LWPTEV_CLEANER_H */

+#endif /* #ifndef UPTEV_CLEANER_H */

@@ -1,7 +1,7 @@

 #include "event.h"

 #include "cleaner.h"

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

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

 #include <stdlib.h>

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

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

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

  */

-int lwptev_event_pack(struct _Lwproctrace__Event *event,

+int uptev_event_pack(struct _Uproctrace__Event *event,

                       void **data, size_t *size,

-                      lwptev_cleaner_t *cleaner) {

-  *size = lwproctrace__event__get_packed_size(event);

+                      uptev_cleaner_t *cleaner) {

+  *size = uproctrace__event__get_packed_size(event);

   *data = malloc(*size);

   if (! data) {

-    lwptev_cleaner_cleanup(cleaner);

+    uptev_cleaner_cleanup(cleaner);

     *size = 0;

     return -1;

   }

-  *size = lwproctrace__event__pack(event, *data);

-  lwptev_cleaner_cleanup(cleaner);

+  *size = uproctrace__event__pack(event, *data);

+  uptev_cleaner_cleanup(cleaner);

   return 0;

 }

@@ -1,9 +1,9 @@

-#ifndef LWPTEV_EVENT_H

-#define LWPTEV_EVENT_H

+#ifndef UPTEV_EVENT_H

+#define UPTEV_EVENT_H

 #include "cleaner.h"

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

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

 #include <stdlib.h>

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

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

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

  */

-int lwptev_event_pack(struct _Lwproctrace__Event *event,

+int uptev_event_pack(struct _Uproctrace__Event *event,

                       void **data, size_t *size,

-                      lwptev_cleaner_t *cleaner);

+                      uptev_cleaner_t *cleaner);

-#endif /* #ifndef LWPTEV_EVENT_H */

+#endif /* #ifndef UPTEV_EVENT_H */

@@ -0,0 +1,6 @@

+#ifndef UPTEV_MACROS_H

+#define UPTEV_MACROS_H

+

+#define countof(arr) (sizeof(arr) / sizeof((arr)[0]))

+

+#endif /* #ifndef UPTEV_MACROS_H */

@@ -0,0 +1,50 @@

+#include <uptev/proc_begin.h>

+#include "cleaner.h"

+#include "event.h"

+#include "stringlist.h"

+#include "symlink.h"

+#include "timing.h"

+

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

+

+#include <stdlib.h>

+#include <sys/types.h>

+#include <unistd.h>

+

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

+  *data = NULL;

+  *size = 0;

+

+  uptev_cleaner_t *cleaner = uptev_cleaner_new();

+  if (! cleaner) {

+    return -1;

+  }

+

+  struct _Uproctrace__Timespec timestamp = UPROCTRACE__TIMESPEC__INIT;

+  uptev_timing_get_timestamp(&timestamp);

+

+  struct _Uproctrace__ProcBegin proc_begin = UPROCTRACE__PROC_BEGIN__INIT;

+  proc_begin.pid = getpid();

+  proc_begin.has_ppid = 1;

+  proc_begin.ppid = getppid();

+  proc_begin.exe = uptev_symlink_read("/proc/self/exe", cleaner);

+  proc_begin.cwd = uptev_symlink_read("/proc/self/cwd", cleaner);

+

+  struct _Uproctrace__Stringlist cmdline = UPROCTRACE__STRINGLIST__INIT;

+  if (uptev_stringlist_read("/proc/self/cmdline", &cmdline.n_s, &cmdline.s,

+                            cleaner) == 0) {

+    proc_begin.cmdline = &cmdline;

+  }

+

+  struct _Uproctrace__Stringlist environ = UPROCTRACE__STRINGLIST__INIT;

+  if (uptev_stringlist_read("/proc/self/environ", &environ.n_s, &environ.s,

+                            cleaner) == 0) {

+    proc_begin.environ = &environ;

+  }

+

+  struct _Uproctrace__Event event = UPROCTRACE__EVENT__INIT;

+  event.timestamp = &timestamp;

+  event.proc_begin = &proc_begin;

+

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

+}

@@ -0,0 +1,36 @@

+#include <uptev/proc_end.h>

+#include "cleaner.h"

+#include "event.h"

+#include "timing.h"

+

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

+

+#include <stdlib.h>

+#include <sys/types.h>

+#include <unistd.h>

+

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

+  *data = NULL;

+  *size = 0;

+

+  uptev_cleaner_t *cleaner = uptev_cleaner_new();

+  if (! cleaner) {

+    return -1;

+  }

+

+  struct _Uproctrace__Timespec timestamp = UPROCTRACE__TIMESPEC__INIT;

+  uptev_timing_get_timestamp(&timestamp);

+

+  struct _Uproctrace__Timespec proc_cpu_time = UPROCTRACE__TIMESPEC__INIT;

+  uptev_timing_get_proc_cpu_time(&proc_cpu_time);

+

+  struct _Uproctrace__ProcEnd proc_end = UPROCTRACE__PROC_END__INIT;

+  proc_end.pid = getpid();

+  proc_end.proc_cpu_time = &proc_cpu_time;

+

+  struct _Uproctrace__Event event = UPROCTRACE__EVENT__INIT;

+  event.timestamp = &timestamp;

+  event.proc_end = &proc_end;

+

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

+}

@@ -8,7 +8,7 @@

 #include <sys/stat.h>

 #include <unistd.h>

-char * lwptev_read_file(char const *pathname, size_t *size) {

+char * uptev_read_file(char const *pathname, size_t *size) {

   /* it is not possible to get file size before, because this yields zero for

      files like /proc/self/cmdline */

   *size = 0;

@@ -1,5 +1,5 @@

-#ifndef LWPTEV_READ_FILE_H

-#define LWPTEV_READ_FILE_H

+#ifndef UPTEV_READ_FILE_H

+#define UPTEV_READ_FILE_H

 /**

  * @brief read file contents

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

  * @param[out] *size size of file contents

  * @return pointer to malloc-ed file contents or NULL

  */

-char * lwptev_read_file(char const *pathname, size_t *size);

+char * uptev_read_file(char const *pathname, size_t *size);

-#endif /* #ifndef LWPTEV_READ_FILE_H */

+#endif /* #ifndef UPTEV_READ_FILE_H */

@@ -9,14 +9,7 @@

 #include <sys/stat.h>

 #include <unistd.h>

-/**

- * @brief make array with pointers to strings

- * @param[in] data pointer to string list

- * @param[in] sz size of string list

- * @param[out] *cnt number of entries in array

- * @return pointer to malloc-ed array of NULL

- */

-static char ** lwptev_stringlist_make_ptrs(char *data, size_t sz,

+static char ** uptev_stringlist_make_ptrs(char *data, size_t sz,

                                           size_t *cnt) {

   /* count strings */

   size_t pos = 0;

@@ -40,26 +33,26 @@ static char ** lwptev_stringlist_make_ptrs(char *data, size_t sz,

   return ptrs;

 }

-int lwptev_stringlist_read(char const *pathname, size_t *n, char ***strs,

-                           lwptev_cleaner_t *cleaner) {

+int uptev_stringlist_read(char const *pathname, size_t *n, char ***strs,

+                          uptev_cleaner_t *cleaner) {

   *n = 0;

   *strs = NULL;

   /* read file contents */

   size_t sz;

-  char *data = lwptev_read_file(pathname, &sz);

+  char *data = uptev_read_file(pathname, &sz);

   if (! data) {

-    lwptev_cleaner_cleanup(cleaner);

     return -1;

   }

-  lwptev_cleaner_add_ptr(cleaner, data);

   /* create pointer array */

   size_t cnt;

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

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

   if (! ptrs) {

-    lwptev_cleaner_cleanup(cleaner);

+    free(data);

     return -1;

   }

-  lwptev_cleaner_add_ptr(cleaner, ptrs);

+  /* success: add malloc-ed object to cleaner and return string array */

+  uptev_cleaner_add_ptr(cleaner, data);

+  uptev_cleaner_add_ptr(cleaner, ptrs);

   *n = cnt;

   *strs = ptrs;

   return 0;

@@ -0,0 +1,19 @@

+#ifndef UPTEV_STRINGLIST_H

+#define UPTEV_STRINGLIST_H

+

+#include "cleaner.h"

+

+#include <stdlib.h>

+

+/**

+ * @brief read string list file

+ * @param[in] pathname path to file containing zero-terminated string list

+ * @param[out] *n number of strings read or zero on error

+ * @param[out] *strs malloc-ed array of malloc-ed strings read or NULL on error

+ * @param[in,out] cleaner object, malloc-ed object are added to it on success

+ * @return 0 on success, -1 on error

+ */

+int uptev_stringlist_read(char const *pathname, size_t *n, char ***strs,

+                          uptev_cleaner_t *cleaner);

+

+#endif /* #ifndef UPTEV_STRINGLIST_H */

@@ -9,7 +9,7 @@

  * @param[in] pathname path to symbolic link

  * @return malloc-ed string containting link target or NULL

  */

-static char * lwptev_symlink_read_target(char const *pathname) {

+static char * uptev_symlink_read_target(char const *pathname) {

   size_t sz = 256;

   char *target = NULL;

   while (1) {

@@ -35,13 +35,12 @@ static char * lwptev_symlink_read_target(char const *pathname) {

   }

 }

-int lwptev_symlink_read(char const *pathname, char **target,

-                        lwptev_cleaner_t *cleaner) {

-  *target = lwptev_symlink_read_target(pathname);

-  if (! *target) {

-    lwptev_cleaner_cleanup(cleaner);

-    return -1;

+char * uptev_symlink_read(char const *pathname, uptev_cleaner_t *cleaner) {

+  char *target = uptev_symlink_read_target(pathname);

+  if (! target) {

+    return NULL;

   }

-  lwptev_cleaner_add_ptr(cleaner, *target);

-  return 0;

+  /* success: add malloc-ed object to cleaner and return target string */

+  uptev_cleaner_add_ptr(cleaner, target);

+  return target;

 }

@@ -0,0 +1,14 @@

+#ifndef UPTEV_SYMLINK_H

+#define UPTEV_SYMLINK_H

+

+#include "cleaner.h"

+

+/**

+ * @brief read symlink

+ * @param[in] pathname path to symbolic link

+ * @param[in,out] cleaner object, malloc-ed string is added to it on success

+ * @return malloc-ed string object containing symlink target or NULL on error

+ */

+char * uptev_symlink_read(char const *pathname, uptev_cleaner_t *cleaner);

+

+#endif /* #ifndef UPTEV_SYMLINK_H */

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

+#include "timing.h"

+

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

+

+#include <time.h>

+

+static void uptev_timing_clock_gettime(clockid_t clockid,

+                                        struct _Uproctrace__Timespec *tsp) {

+  struct timespec ts;

+  clock_gettime(clockid, &ts);

+  tsp->sec = ts.tv_sec;

+  tsp->has_nsec = 1;

+  tsp->nsec = ts.tv_nsec;

+}

+

+void uptev_timing_get_timestamp(struct _Uproctrace__Timespec *timestamp) {

+  uptev_timing_clock_gettime(CLOCK_REALTIME, timestamp);

+}

+

+void uptev_timing_get_proc_cpu_time(struct _Uproctrace__Timespec

+                                     *proc_cpu_time) {

+  uptev_timing_clock_gettime(CLOCK_PROCESS_CPUTIME_ID, proc_cpu_time);

+}

@@ -1,19 +1,19 @@

-#ifndef LWPTEV_TIMING_H

-#define LWPTEV_TIMING_H

+#ifndef UPTEV_TIMING_H

+#define UPTEV_TIMING_H

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

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

 /**

  * @brief fill timestamp with current time

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

  */

-void lwptev_timing_get_timestamp(struct _Lwproctrace__Timespec *timestamp);

+void uptev_timing_get_timestamp(struct _Uproctrace__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 lwptev_timing_get_proc_cpu_time(struct _Lwproctrace__Timespec

+void uptev_timing_get_proc_cpu_time(struct _Uproctrace__Timespec

                                      *proc_cpu_time);

-#endif /* #ifndef LWPTEV_TIMING_H */

+#endif /* #ifndef UPTEV_TIMING_H */

@@ -1,5 +1,5 @@

 add_library(

-  lwptpl

+  uptpl

   SHARED

   src/constructor.c

   src/destructor.c

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

   src/write.h

 )

-target_link_libraries(lwptpl lwptev)

+target_link_libraries(uptpl uptev)

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

-#include <liblwptev/proc_begin.h>

+#include <uptev/proc_begin.h>

 #include "write.h"

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

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

   void *data = NULL;

   size_t size = 0;

-  lwptev_proc_begin(&data, &size);

-  lwptpl_write(data, size);

+  uptev_proc_begin(&data, &size);

+  uptpl_write(data, size);

 }

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

-#include <liblwptev/proc_end.h>

+#include <uptev/proc_end.h>

 #include "write.h"

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

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

   void *data = NULL;

   size_t size = 0;

-  lwptev_proc_end(&data, &size);

-  lwptpl_write(data, size);

+  uptev_proc_end(&data, &size);

+  uptpl_write(data, size);

 }

@@ -7,16 +7,16 @@

 #include <sys/file.h>

 #include <unistd.h>

-struct lwptpl_event_header_s {

-  uint8_t magic[4]; /**< l w p t */

+struct uptpl_event_header_s {

+  uint8_t magic[4]; /**< u p t 0 */

   uint8_t size[4]; /**< size of payload in network byte oder */

 } __attribute__((packed));

-void lwptpl_write(void const *data, size_t size) {

+void uptpl_write(void const *data, size_t size) {

   if (! data || ! size || size > 0xFFFFFFFF) {

     return;

   }

-  char const *filename = getenv("LWPTPL_OUTPUT");

+  char const *filename = getenv("UPTPL_OUTPUT");

   if (! filename) {

     return;

   }

@@ -28,8 +28,8 @@ void lwptpl_write(void const *data, size_t size) {

     close(fd);

     return;

   }

-  struct lwptpl_event_header_s lwptpl_event_header = {

-    .magic = { 'l', 'w', 'p', 't' },

+  struct uptpl_event_header_s uptpl_event_header = {

+    .magic = { 'u', 'p', 't', '0' },

     .size = {

       (size >> 24) & 0xFF,

       (size >> 16) & 0xFF,

@@ -37,7 +37,7 @@ void lwptpl_write(void const *data, size_t size) {

       size & 0xFF,

     }

   };

-  write(fd, &lwptpl_event_header, sizeof(lwptpl_event_header));

+  write(fd, &uptpl_event_header, sizeof(uptpl_event_header));

   write(fd, data, size);

   flock(fd, LOCK_UN);

   close(fd);

@@ -0,0 +1,8 @@

+#ifndef UPTPL_WRITE_H

+#define UPTPL_WRITE_H

+

+#include <stdlib.h>

+

+void uptpl_write(void const *data, size_t size);

+

+#endif /* #ifndef UPTPL_WRITE_H */

@@ -4,14 +4,16 @@ add_test(

   COMMAND

   bash -c

   "

+    set -eux -o pipefail

     > out.proto

     (

-      export LWPTPL_OUTPUT=out.proto

-      export LD_PRELOAD=${CMAKE_BINARY_DIR}/liblwptpl/liblwptpl.so

+      export UPTPL_OUTPUT=out.proto

+      export LD_PRELOAD=${CMAKE_BINARY_DIR}/libuptpl/libuptpl.so

       /bin/true a b 'c d'

-      /bin/false e f 'g h'

+      /usr/bin/printf '' e f 'g h'

     )

     ls -l out.proto

-    ${CMAKE_BINARY_DIR}/dump/dump.py out.proto

+    ${CMAKE_BINARY_DIR}/dump/dump.py out.proto | tee out.dump

+    grep '^ *event *{ *$' out.dump | wc -l | grep '^4$'

   "

 )

@@ -1,19 +1,23 @@

 syntax = "proto2";

-package lwproctrace;

+package uproctrace;

 message timespec {

   required int64 sec = 1;

   optional int32 nsec = 2;

 }

+message stringlist {

+  repeated string s = 1;

+}

+

 message proc_begin {

   required int32 pid = 1;

   optional int32 ppid = 2;

   optional string exe = 3;

   optional string cwd = 4;

-  repeated string cmdline = 5;

-  repeated string environ = 6;

+  optional stringlist cmdline = 5;

+  optional stringlist environ = 6;

 }

 message proc_end {