#include <sched.h>
#include <fcntl.h>
#include <poll.h>
+#include <regex.h>
+
+#include <urcu.h>
#include "marker.h"
#include "tracer.h"
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;
{
int result;
+ ust_register_thread();
+
DBG("LISTENER");
for(;;) {
}
}
+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
return 0;
}
+static regex_t preg;
+static int regex_is_ok = -1;
+
static void auto_probe_connect(struct marker *m)
{
int result;
+ char* comp_name = NULL;
+ char* regex;
+
+ if (regex_is_ok != 0) {
+ goto end;
+ }
+
+ if (asprintf(&comp_name, "%s/%s", m->channel, m->name) == -1) {
+ ERR("auto_probe_connect: `asprintf' failed (marker %s/%s)",
+ m->channel, m->name);
+ return;
+ }
+ if (regexec(&preg, comp_name, 0, NULL, 0) != 0) {
+ goto end; /* Not matching */
+ }
+
+// connect:
+
result = ltt_marker_connect(m->channel, m->name, "default");
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);
+
+ end:
+ if (comp_name != NULL) {
+ free(comp_name);
+ }
}
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;
+ char* regex = NULL;
+
+ /* 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");
return;
}
+ regex = getenv("UST_AUTOPROBE");
+ if(regex) {
+ char* regex = NULL;
+ 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);
+ regex_is_ok = regcomp(&preg, regex, 0);
+ if (regex_is_ok) {
+ ERR("cannot parse regex %s", regex);
+ }
+ /* 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";
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");
+}
+
projects / ust.git / blobdiff