cleanups

[ust.git] / libust / tracectl.c

diff --git a/libust/tracectl.c b/libust/tracectl.c
index 1b0af3a0fe99e43b913a4ed2b37834f2b80c4938..7c65e3f82119496c6a608283c78c27ab1cc8eff4 100644 (file)
--- a/libust/tracectl.c
+++ b/libust/tracectl.c
@@ -25,6 +25,7 @@
 #include <sched.h>
 #include <fcntl.h>
 #include <poll.h>
+#include <regex.h>
 
 #include <urcu.h>
 
@@ -252,7 +253,7 @@ void *listener_main(void *p)
                        continue;
                }
 
-               DBG("received a message! it's: %s\n", recvbuf);
+               DBG("received a message! it's: %s", recvbuf);
                len = strlen(recvbuf);
 
                if(!strcmp(recvbuf, "print_markers")) {
@@ -806,25 +807,48 @@ static int init_signal_handler(void)
        return 0;
 }
 
+#define AUTOPROBE_DISABLED      0
+#define AUTOPROBE_ENABLE_ALL    1
+#define AUTOPROBE_ENABLE_REGEX  2
+static int autoprobe_method = AUTOPROBE_DISABLED;
+static regex_t autoprobe_regex;
+
 static void auto_probe_connect(struct marker *m)
 {
        int result;
 
-       result = ltt_marker_connect(m->channel, m->name, "default");
+       char* concat_name = NULL;
+       const char *probe_name = "default";
+
+       if(autoprobe_method == AUTOPROBE_DISABLED) {
+               return;
+       }
+       else if(autoprobe_method == AUTOPROBE_ENABLE_REGEX) {
+               result = asprintf(&concat_name, "%s/%s", m->channel, m->name);
+               if(result == -1) {
+                       ERR("auto_probe_connect: asprintf failed (marker %s/%s)",
+                               m->channel, m->name);
+                       return;
+               }
+               if (regexec(&autoprobe_regex, concat_name, 0, NULL, 0)) {
+                       free(concat_name);
+                       return;
+               }
+               free(concat_name);
+       }
+
+       result = ltt_marker_connect(m->channel, m->name, probe_name);
        if(result && result != -EEXIST)
                ERR("ltt_marker_connect (marker = %s/%s, errno = %d)", m->channel, m->name, -result);
 
-       DBG("just auto connected marker %s %s to probe default", m->channel, m->name);
-}
+       DBG("auto connected marker %s %s to probe default", m->channel, m->name);
 
-static void __attribute__((constructor(101))) init0()
-{
-       DBG("UST_AUTOPROBE constructor");
 }
 
 static void __attribute__((constructor(1000))) init()
 {
        int result;
+       char* autoprobe_val = NULL;
 
        /* Initialize RCU in case the constructor order is not good. */
        urcu_init();
@@ -832,7 +856,7 @@ static void __attribute__((constructor(1000))) init()
        /* It is important to do this before events start to be generated. */
        ust_register_thread();
 
-       DBG("UST_TRACE constructor");
+       DBG("Tracectl constructor");
 
        /* Must create socket before signal handler to prevent races.
          */
@@ -847,10 +871,11 @@ static void __attribute__((constructor(1000))) init()
                return;
        }
 
-       if(getenv("UST_AUTOPROBE")) {
+       autoprobe_val = getenv("UST_AUTOPROBE");
+       if(autoprobe_val) {
                struct marker_iter iter;
 
-               DBG("IN AUTOPROBE\n");
+               DBG("Autoprobe enabled.");
 
                /* Ensure markers are initialized */
                //init_markers();
@@ -861,15 +886,33 @@ static void __attribute__((constructor(1000))) init()
                /* first, set the callback that will connect the
                 * probe on new markers
                 */
+               if(autoprobe_val[0] == '/') {
+                       result = regcomp(&autoprobe_regex, autoprobe_val+1, 0);
+                       if (result) {
+                               char regexerr[150];
+
+                               regerror(result, &autoprobe_regex, regexerr, sizeof(regexerr));
+                               ERR("cannot parse regex %s (%s), will ignore UST_AUTOPROBE", autoprobe_val, regexerr);
+                               /* don't crash the application just for this */
+                       }
+                       else {
+                               autoprobe_method = AUTOPROBE_ENABLE_REGEX;
+                       }
+               }
+               else {
+                       /* just enable all instrumentation */
+                       autoprobe_method = AUTOPROBE_ENABLE_ALL;
+               }
+
                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");
+               DBG("now iterating on markers already registered");
                while(iter.marker) {
-                       DBG("now iterating on marker %s\n", iter.marker->name);
+                       DBG("now iterating on marker %s", iter.marker->name);
                        auto_probe_connect(iter.marker);
                        marker_iter_next(&iter);
                }