enhancements to the constructor system

[ust.git] / libust / tracectl.c

diff --git a/libust/tracectl.c b/libust/tracectl.c
index a68dc7bd7e9e4a1684d753b6be5ce9da24d4f2a5..cf2b89ef1dcdd4f8e1f97974715801e625828712 100644 (file)
--- a/libust/tracectl.c
+++ b/libust/tracectl.c
@@ -26,6 +26,8 @@
 #include <fcntl.h>
 #include <poll.h>
 
+#include <urcu.h>
+
 #include "marker.h"
 #include "tracer.h"
 #include "localerr.h"
@@ -102,12 +104,15 @@ static void print_markers(FILE *fp)
        unlock_markers();
 }
 
-void do_command(struct tracecmd *cmd)
-{
-}
+static int init_socket(void);
+
+/* This needs to be called whenever a new thread is created. It notifies
+ * liburcu of the new thread.
+ */
 
-void receive_commands()
+void ust_register_thread(void)
 {
+       rcu_register_thread();
 }
 
 int fd_notif = -1;
@@ -164,7 +169,8 @@ void process_blocked_consumers(void)
                idx++;
        }
 
-       result = poll(fds, n_fds, 0);
+       while((result = poll(fds, n_fds, 0)) == -1 && errno == EINTR)
+               /* nothing */;
        if(result == -1) {
                PERROR("poll");
                return;
@@ -223,6 +229,8 @@ void *listener_main(void *p)
 {
        int result;
 
+       ust_register_thread();
+
        DBG("LISTENER");
 
        for(;;) {
@@ -697,22 +705,31 @@ void *listener_main(void *p)
        }
 }
 
+int have_listener = 0;
+
 void create_listener(void)
 {
 #ifdef USE_CLONE
        static char listener_stack[16384];
+#else
+       pthread_t thread;
 #endif
 
+       if(have_listener)
+               return;
+
 #ifdef USE_CLONE
        result = clone(listener_main, listener_stack+sizeof(listener_stack)-1, CLONE_FS | CLONE_FILES | CLONE_VM | CLONE_SIGHAND | CLONE_THREAD, NULL);
        if(result == -1) {
                perror("clone");
+               return;
        }
 #else
-       pthread_t thread;
 
        pthread_create(&thread, NULL, listener_main, NULL);
 #endif
+
+       have_listener = 1;
 }
 
 /* The signal handler itself. Signals must be setup so there cannot be
@@ -803,15 +820,18 @@ static void auto_probe_connect(struct marker *m)
 static void __attribute__((constructor(101))) init0()
 {
        DBG("UST_AUTOPROBE constructor");
-       if(getenv("UST_AUTOPROBE")) {
-               marker_set_new_marker_cb(auto_probe_connect);
-       }
 }
 
 static void __attribute__((constructor(1000))) init()
 {
        int result;
 
+       /* Initialize RCU in case the constructor order is not good. */
+       urcu_init();
+
+       /* It is important to do this before events start to be generated. */
+       ust_register_thread();
+
        DBG("UST_TRACE constructor");
 
        /* Must create socket before signal handler to prevent races.
@@ -827,6 +847,34 @@ static void __attribute__((constructor(1000))) init()
                return;
        }
 
+       if(getenv("UST_AUTOPROBE")) {
+               struct marker_iter iter;
+
+               DBG("IN AUTOPROBE\n");
+
+               /* Ensure markers are initialized */
+               //init_markers();
+
+               /* Ensure marker control is initialized, for the probe */
+               init_marker_control();
+
+               /* first, set the callback that will connect the
+                * probe on new markers
+                */
+               marker_set_new_marker_cb(auto_probe_connect);
+
+               /* Now, connect the probes that were already registered. */
+               marker_iter_reset(&iter);
+               marker_iter_start(&iter);
+
+               DBG("now iterating on markers already registered\n");
+               while(iter.marker) {
+                       DBG("now iterating on marker %s\n", iter.marker->name);
+                       auto_probe_connect(iter.marker);
+                       marker_iter_next(&iter);
+               }
+       }
+
        if(getenv("UST_TRACE")) {
                char trace_name[] = "auto";
                char trace_type[] = "ustrelay";
@@ -904,3 +952,24 @@ static void __attribute__((destructor)) fini()
        destroy_socket();
 }
 #endif
+
+/* Notify ust that there was a fork. This needs to be called inside
+ * the new process, anytime a process whose memory is not shared with
+ * the parent is created. If this function is not called, the events
+ * of the new process will not be collected.
+ */
+
+void ust_fork(void)
+{
+       DBG("ust: forking");
+       ltt_trace_stop("auto");
+       ltt_trace_destroy("auto");
+       ltt_trace_alloc("auto");
+       ltt_trace_start("auto");
+       init_socket();
+       have_listener = 0;
+       create_listener();
+       ustcomm_request_consumer(getpid(), "metadata");
+       ustcomm_request_consumer(getpid(), "ust");
+}
+