X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=libust%2Ftracectl.c;h=47ca740781ebb0528c80d62c9e397702b8e415dc;hb=803a4f584bbc64ff44173ced627636f9e6db6618;hp=cf2b89ef1dcdd4f8e1f97974715801e625828712;hpb=4440ebcb325d648c77d238380763943807c06d64;p=ust.git diff --git a/libust/tracectl.c b/libust/tracectl.c index cf2b89e..47ca740 100644 --- a/libust/tracectl.c +++ b/libust/tracectl.c @@ -25,6 +25,7 @@ #include #include #include +#include #include @@ -54,6 +55,9 @@ struct tracecmd { /* no padding */ uint16_t command; }; +/* volatile because shared between the listener and the main thread */ +volatile sig_atomic_t buffers_to_export = 0; + //struct listener_arg { // int pipe_fd; //}; @@ -137,10 +141,39 @@ void notif_cb(void) } } -static void inform_consumer_daemon(void) +/* Ask the daemon to collect a trace called trace_name and being + * produced by this pid. + * + * The trace must be at least allocated. (It can also be started.) + * This is because _ltt_trace_find is used. + */ + +static void inform_consumer_daemon(const char *trace_name) { - ustcomm_request_consumer(getpid(), "metadata"); - ustcomm_request_consumer(getpid(), "ust"); + int i; + struct ltt_trace_struct *trace; + pid_t pid = getpid(); + int result; + + ltt_lock_traces(); + + trace = _ltt_trace_find(trace_name); + if(trace == NULL) { + WARN("inform_consumer_daemon: could not find trace \"%s\"; it is probably already destroyed", trace_name); + goto finish; + } + + for(i=0; i < trace->nr_channels; i++) { + result = ustcomm_request_consumer(pid, trace->channels[i].channel_name); + if(result == -1) { + WARN("Failed to request collection for channel %s. Is the daemon available?", trace->channels[i].channel_name); + /* continue even if fail */ + } + buffers_to_export++; + } + + finish: + ltt_unlock_traces(); } void process_blocked_consumers(void) @@ -252,7 +285,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")) { @@ -291,7 +324,7 @@ void *listener_main(void *p) return (void *)1; } - inform_consumer_daemon(); + inform_consumer_daemon(trace_name); result = ltt_trace_start(trace_name); if(result < 0) { @@ -397,6 +430,8 @@ void *listener_main(void *p) break; } } + + buffers_to_export--; } else if(nth_token_is(recvbuf, "get_n_subbufs", 0) == 1) { struct ltt_trace_struct *trace; @@ -758,23 +793,6 @@ static int init_socket(void) return ustcomm_init_app(getpid(), &ustcomm_app); } -/* FIXME: reenable this to delete socket file. */ - -#if 0 -static void destroy_socket(void) -{ - int result; - - if(mysocketfile[0] == '\0') - return; - - result = unlink(mysocketfile); - if(result == -1) { - PERROR("unlink"); - } -} -#endif - static int init_signal_handler(void) { /* Attempt to handler SIGIO. If the main program wants to @@ -806,25 +824,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 +873,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 +888,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 +903,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); } @@ -911,12 +971,13 @@ static void __attribute__((constructor(1000))) init() return; } + inform_consumer_daemon(trace_name); + result = ltt_trace_start(trace_name); if(result < 0) { ERR("ltt_trace_start failed"); return; } - inform_consumer_daemon(); } @@ -933,26 +994,96 @@ static void __attribute__((constructor(1000))) init() #if 0 static void __attribute__((destructor)) fini() { - int result; +// int result; /* if trace running, finish it */ - DBG("destructor stopping traces"); +// DBG("destructor stopping traces"); - result = ltt_trace_stop("auto"); - if(result == -1) { - ERR("ltt_trace_stop error"); - } +// result = ltt_trace_stop("auto"); +// if(result == -1) { +// ERR("ltt_trace_stop error"); +// } +// +// result = ltt_trace_destroy("auto"); +// if(result == -1) { +// ERR("ltt_trace_destroy error"); +// } +// +// destroy_socket(); +} +#endif - result = ltt_trace_destroy("auto"); - if(result == -1) { - ERR("ltt_trace_destroy error"); +static int trace_recording(void) +{ + int retval = 0; + struct ltt_trace_struct *trace; + + ltt_lock_traces(); + + list_for_each_entry(trace, <t_traces.head, list) { + if(trace->active) { + retval = 1; + break; + } } - destroy_socket(); + ltt_unlock_traces(); + + return retval; +} + +#if 0 +static int have_consumer(void) +{ + return !list_empty(&blocked_consumers); } #endif +int restarting_usleep(useconds_t usecs) +{ + struct timespec tv; + int result; + + tv.tv_sec = 0; + tv.tv_nsec = usecs * 1000; + + do { + result = nanosleep(&tv, &tv); + } while(result == -1 && errno == EINTR); + + return result; +} + +/* This destructor keeps the process alive for a few seconds in order + * to leave time to ustd to connect to its buffers. This is necessary + * for programs whose execution is very short. It is also useful in all + * programs when tracing is started close to the end of the program + * execution. + * + * FIXME: For now, this only works for the first trace created in a + * process. + */ + +static void __attribute__((destructor)) keepalive() +{ + if(trace_recording() && buffers_to_export) { + int total = 0; + DBG("Keeping process alive for consumer daemon..."); + while(buffers_to_export) { + const int interv = 200000; + restarting_usleep(interv); + total += interv; + + if(total >= 3000000) { + WARN("non-consumed buffers remaining after wait limit; not waiting anymore"); + break; + } + } + DBG("Finally dying..."); + } +} + /* 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 @@ -961,15 +1092,35 @@ static void __attribute__((destructor)) fini() void ust_fork(void) { + struct blocked_consumer *bc; + struct blocked_consumer *deletable_bc = NULL; + int result; + DBG("ust: forking"); ltt_trace_stop("auto"); ltt_trace_destroy("auto"); - ltt_trace_alloc("auto"); - ltt_trace_start("auto"); - init_socket(); + /* Delete all active connections */ + ustcomm_close_all_connections(&ustcomm_app.server); + + /* Delete all blocked consumers */ + list_for_each_entry(bc, &blocked_consumers, list) { + free(deletable_bc); + deletable_bc = bc; + list_del(&bc->list); + } + have_listener = 0; create_listener(); - ustcomm_request_consumer(getpid(), "metadata"); - ustcomm_request_consumer(getpid(), "ust"); + init_socket(); + ltt_trace_setup("auto"); + result = ltt_trace_set_type("auto", "ustrelay"); + if(result < 0) { + ERR("ltt_trace_set_type failed"); + return (void *)1; + } + + ltt_trace_alloc("auto"); + ltt_trace_start("auto"); + inform_consumer_daemon("auto"); }