X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=libust%2Ftracectl.c;h=1b0af3a0fe99e43b913a4ed2b37834f2b80c4938;hb=97d9b88b86c42088bddcb81511cfaebd7e1b24b7;hp=1ee3e45ad8bec3830567f4540022ca4a7568f727;hpb=9160b4e4541d3a6010e4e671ee5deb3ea89f4211;p=ust.git diff --git a/libust/tracectl.c b/libust/tracectl.c index 1ee3e45..1b0af3a 100644 --- a/libust/tracectl.c +++ b/libust/tracectl.c @@ -1,3 +1,20 @@ +/* Copyright (C) 2009 Pierre-Marc Fournier + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + #define _GNU_SOURCE #include #include @@ -9,6 +26,8 @@ #include #include +#include + #include "marker.h" #include "tracer.h" #include "localerr.h" @@ -85,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; @@ -147,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; @@ -206,6 +229,8 @@ void *listener_main(void *p) { int result; + ust_register_thread(); + DBG("LISTENER"); for(;;) { @@ -680,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 @@ -777,8 +811,8 @@ static void auto_probe_connect(struct marker *m) int result; result = ltt_marker_connect(m->channel, m->name, "default"); - if(result) - ERR("ltt_marker_connect"); + 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); } @@ -786,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. @@ -810,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"; @@ -887,3 +952,113 @@ static void __attribute__((destructor)) fini() destroy_socket(); } #endif + +#if 0 +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; + } + } + + ltt_unlock_traces(); + + return retval; +} + +static int have_consumer(void) +{ + return !list_empty(&blocked_consumers); +} + +/* This destructor keeps the process alive for a few seconds in order + * to leave time to ustd to consume its buffers. + */ + +int restarting_sleep(int secs) +{ + struct timespec tv; + int result; + + tv.tv_sec = secs; + tv.tv_nsec = 0; + + do { + result = nanosleep(&tv, &tv); + } while(result == -1 && errno == EINTR); + + return result; +} + +static void __attribute__((destructor)) keepalive() +{ +// struct ustcomm_ustd ustd; +// int result; +// sigset_t sigset; +// +// result = sigemptyset(&sigset); +// if(result == -1) { +// perror("sigemptyset"); +// return; +// } +// result = sigaddset(&sigset, SIGIO); +// if(result == -1) { +// perror("sigaddset"); +// return; +// } +// result = sigprocmask(SIG_BLOCK, &sigset, NULL); +// if(result == -1) { +// perror("sigprocmask"); +// return; +// } +// +// if(trace_recording()) { +// if(!have_consumer()) { +// /* Request listener creation. We've blocked SIGIO's in +// * order to not interrupt sleep(), so we will miss the +// * one sent by the daemon and therefore won't create +// * the listener automatically. +// */ +// create_listener(); +// + printf("Keeping process alive for consumer daemon...\n"); + restarting_sleep(3); + printf("Finally dying...\n"); +// } +// } +// +// result = sigprocmask(SIG_UNBLOCK, &sigset, NULL); +// if(result == -1) { +// perror("sigprocmask"); +// return; +// } +} +#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"); +} +