X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=libust%2Ftracectl.c;h=1b0af3a0fe99e43b913a4ed2b37834f2b80c4938;hb=c8b4275ed4a63a4bc374a9f3dc864725882c750e;hp=9dfc8af6f6ad6ccb3b611cbb1136c552238046f0;hpb=1e2944cb1e15d658b5991026e5604c56f551e2ab;p=lttng-ust.git

diff --git a/libust/tracectl.c b/libust/tracectl.c
index 9dfc8af6..1b0af3a0 100644
--- a/libust/tracectl.c
+++ b/libust/tracectl.c
@@ -104,9 +104,7 @@ 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.
@@ -707,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
@@ -812,22 +819,19 @@ static void auto_probe_connect(struct marker *m)
 
 static void __attribute__((constructor(101))) init0()
 {
-	/* 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_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.
@@ -843,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";
@@ -921,6 +953,95 @@ static void __attribute__((destructor)) fini()
 }
 #endif
 
+#if 0
+static int trace_recording(void)
+{
+	int retval = 0;
+	struct ltt_trace_struct *trace;
+
+	ltt_lock_traces();
+
+	list_for_each_entry(trace, &ltt_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