X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=libust%2Ftracectl.c;h=f59edd35902eacd94c7b8c52bbead9f397a753d5;hb=1a9dbd91d1714133deacf8e531cd3bfcd443eb39;hp=d5ca7d2b9655aa230b4b7d1fd029e2a4a7f05a1b;hpb=d89b81916428a3e7e5dfe1612e87218502a40a3b;p=ust.git

diff --git a/libust/tracectl.c b/libust/tracectl.c
index d5ca7d2..f59edd3 100644
--- a/libust/tracectl.c
+++ b/libust/tracectl.c
@@ -39,6 +39,7 @@
 #include <ust/marker.h>
 #include <ust/tracepoint.h>
 #include <ust/tracectl.h>
+#include <ust/clock.h>
 #include "tracer.h"
 #include "usterr.h"
 #include "ustcomm.h"
@@ -62,17 +63,29 @@ static char receive_buffer[USTCOMM_BUFFER_SIZE];
 static char send_buffer[USTCOMM_BUFFER_SIZE];
 
 static int epoll_fd;
+
+/*
+ * Listener thread data vs fork() protection mechanism. Ensures that no listener
+ * thread mutexes and data structures are being concurrently modified or held by
+ * other threads when fork() is executed.
+ */
+static pthread_mutex_t listener_thread_data_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+/* Mutex protecting listen_sock. Nests inside listener_thread_data_mutex. */
+static pthread_mutex_t listen_sock_mutex = PTHREAD_MUTEX_INITIALIZER;
 static struct ustcomm_sock *listen_sock;
 
 extern struct chan_info_struct chan_infos[];
 
-static struct list_head open_buffers_list = LIST_HEAD_INIT(open_buffers_list);
+static struct cds_list_head open_buffers_list = CDS_LIST_HEAD_INIT(open_buffers_list);
 
-static struct list_head ust_socks = LIST_HEAD_INIT(ust_socks);
+static struct cds_list_head ust_socks = CDS_LIST_HEAD_INIT(ust_socks);
 
 /* volatile because shared between the listener and the main thread */
 int buffers_to_export = 0;
 
+int ust_clock_source;
+
 static long long make_pidunique(void)
 {
 	s64 retval;
@@ -97,11 +110,11 @@ static void print_markers(FILE *fp)
 
 	while (iter.marker) {
 		fprintf(fp, "marker: %s/%s %d \"%s\" %p\n",
-			iter.marker->channel,
-			iter.marker->name,
-			(int)imv_read(iter.marker->state),
-			iter.marker->format,
-			iter.marker->location);
+			(*iter.marker)->channel,
+			(*iter.marker)->name,
+			(int)imv_read((*iter.marker)->state),
+			(*iter.marker)->format,
+			(*iter.marker)->location);
 		marker_iter_next(&iter);
 	}
 	unlock_markers();
@@ -116,16 +129,16 @@ static void print_trace_events(FILE *fp)
 	trace_event_iter_start(&iter);
 
 	while (iter.trace_event) {
-		fprintf(fp, "trace_event: %s\n", iter.trace_event->name);
+		fprintf(fp, "trace_event: %s\n", (*iter.trace_event)->name);
 		trace_event_iter_next(&iter);
 	}
 	unlock_trace_events();
 }
 
-static int connect_ustd(void)
+static int connect_ustconsumer(void)
 {
 	int result, fd;
-	char default_daemon_path[] = SOCK_DIR "/ustd";
+	char default_daemon_path[] = SOCK_DIR "/ustconsumer";
 	char *explicit_daemon_path, *daemon_path;
 
 	explicit_daemon_path = getenv("UST_DAEMON_SOCKET");
@@ -139,7 +152,7 @@ static int connect_ustd(void)
 
 	result = ustcomm_connect_path(daemon_path, &fd);
 	if (result < 0) {
-		WARN("connect_ustd failed, daemon_path: %s",
+		WARN("connect_ustconsumer failed, daemon_path: %s",
 		     daemon_path);
 		return result;
 	}
@@ -194,12 +207,12 @@ static void inform_consumer_daemon(const char *trace_name)
 	struct ust_trace *trace;
 	const char *ch_name;
 
-	sock = connect_ustd();
+	sock = connect_ustconsumer();
 	if (sock < 0) {
 		return;
 	}
 
-	DBG("Connected to ustd");
+	DBG("Connected to ustconsumer");
 
 	ltt_lock_traces();
 
@@ -216,8 +229,8 @@ static void inform_consumer_daemon(const char *trace_name)
 				ch_name = trace->channels[i].channel_name;
 				request_buffer_consumer(sock, trace_name,
 							ch_name, j);
-				STORE_SHARED(buffers_to_export,
-					     LOAD_SHARED(buffers_to_export)+1);
+				CMM_STORE_SHARED(buffers_to_export,
+					     CMM_LOAD_SHARED(buffers_to_export)+1);
 			}
 		}
 	}
@@ -352,7 +365,7 @@ static int set_subbuf_size(const char *trace_name, const char *ch_name,
 	}
 
 	channel->subbuf_size = power;
-	DBG("the set_subbuf_size for the requested channel is %u", channel->subbuf_size);
+	DBG("the set_subbuf_size for the requested channel is %zu", channel->subbuf_size);
 
 unlock_traces:
 	ltt_unlock_traces();
@@ -390,7 +403,7 @@ static int set_subbuf_num(const char *trace_name, const char *ch_name,
 	}
 
 	channel->subbuf_cnt = num;
-	DBG("the set_subbuf_cnt for the requested channel is %zd", channel->subbuf_cnt);
+	DBG("the set_subbuf_cnt for the requested channel is %u", channel->subbuf_cnt);
 
 unlock_traces:
 	ltt_unlock_traces();
@@ -473,13 +486,13 @@ static int notify_buffer_mapped(const char *trace_name,
 	 */
 	if (uatomic_read(&buf->consumed) == 0) {
 		DBG("decrementing buffers_to_export");
-		STORE_SHARED(buffers_to_export, LOAD_SHARED(buffers_to_export)-1);
+		CMM_STORE_SHARED(buffers_to_export, CMM_LOAD_SHARED(buffers_to_export)-1);
 	}
 
 	/* The buffer has been exported, ergo, we can add it to the
 	 * list of open buffers
 	 */
-	list_add(&buf->open_buffers_list, &open_buffers_list);
+	cds_list_add(&buf->open_buffers_list, &open_buffers_list);
 
 unlock_traces:
 	ltt_unlock_traces();
@@ -530,53 +543,46 @@ unlock_traces:
 	return retval;
 }
 
-static void listener_cleanup(void *ptr)
+static void release_listener_mutex(void *ptr)
 {
-	ustcomm_del_named_sock(listen_sock, 0);
+	pthread_mutex_unlock(&listener_thread_data_mutex);
 }
 
-static void force_subbuf_switch()
+static void listener_cleanup(void *ptr)
 {
-	struct ust_buffer *buf;
-
-	list_for_each_entry(buf, &open_buffers_list,
-			    open_buffers_list) {
-		ltt_force_switch(buf, FORCE_FLUSH);
+	pthread_mutex_lock(&listen_sock_mutex);
+	if (listen_sock) {
+		ustcomm_del_named_sock(listen_sock, 0);
+		listen_sock = NULL;
 	}
+	pthread_mutex_unlock(&listen_sock_mutex);
 }
 
-/* Simple commands are those which need only respond with a return value. */
-static int process_simple_client_cmd(int command, char *recv_buf)
+static int force_subbuf_switch(const char *trace_name)
 {
-	switch(command) {
-	case SET_SOCK_PATH:
-	{
-		struct ustcomm_sock_path *sock_msg;
-		sock_msg = (struct ustcomm_sock_path *)recv_buf;
-		sock_msg->sock_path =
-			ustcomm_restore_ptr(sock_msg->sock_path,
-					    sock_msg->data,
-					    sizeof(sock_msg->data));
-		if (!sock_msg->sock_path) {
-
-			return -EINVAL;
-		}
-		return setenv("UST_DAEMON_SOCKET", sock_msg->sock_path, 1);
-	}
-
-	case FORCE_SUBBUF_SWITCH:
-		/* FIXME: return codes? */
-		force_subbuf_switch();
+	struct ust_trace *trace;
+	int i, j, retval = 0;
 
-		break;
+	ltt_lock_traces();
+	trace = _ltt_trace_find(trace_name);
+	if (!trace) {
+                retval = -ENODATA;
+                DBG("Cannot find trace. It was likely destroyed by the user.");
+                goto unlock_traces;
+        }
 
-	default:
-		return -EINVAL;
+	for (i = 0; i < trace->nr_channels; i++) {
+		for (j = 0; j < trace->channels[i].n_cpus; j++) {
+			ltt_force_switch(trace->channels[i].buf[j],
+					 FORCE_FLUSH);
+		}
 	}
 
-	return 0;
-}
+unlock_traces:
+	ltt_unlock_traces();
 
+	return retval;
+}
 
 static int process_trace_cmd(int command, char *trace_name)
 {
@@ -695,6 +701,15 @@ static int process_trace_cmd(int command, char *trace_name)
 			return result;
 		}
 		return 0;
+	case FORCE_SUBBUF_SWITCH:
+		DBG("force switch");
+
+		result = force_subbuf_switch(trace_name);
+		if (result < 0) {
+			ERR("force_subbuf_switch failed");
+			return result;
+		}
+		return 0;
 	}
 
 	return 0;
@@ -827,7 +842,7 @@ static void process_marker_cmd(int sock, int command,
 {
 	struct ustcomm_header _reply_header;
 	struct ustcomm_header *reply_header = &_reply_header;
-	int result;
+	int result = 0;
 
 	memset(reply_header, 0, sizeof(*reply_header));
 
@@ -936,7 +951,7 @@ static void process_client_cmd(struct ustcomm_header *recv_header,
 		print_markers(fp);
 		fclose(fp);
 
-		reply_header->size = size;
+		reply_header->size = size + 1;	/* Include final \0 */
 
 		result = ustcomm_send(sock, reply_header, ptr);
 
@@ -962,7 +977,7 @@ static void process_client_cmd(struct ustcomm_header *recv_header,
 		print_trace_events(fp);
 		fclose(fp);
 
-		reply_header->size = size;
+		reply_header->size = size + 1;	/* Include final \0 */
 
 		result = ustcomm_send(sock, reply_header, ptr);
 
@@ -999,27 +1014,42 @@ static void process_client_cmd(struct ustcomm_header *recv_header,
 	}
 	case GET_SOCK_PATH:
 	{
-		struct ustcomm_sock_path *sock_msg;
+		struct ustcomm_single_field *sock_msg;
 		char *sock_path_env;
 
-		sock_msg = (struct ustcomm_sock_path *)send_buf;
+		sock_msg = (struct ustcomm_single_field *)send_buf;
 
 		sock_path_env = getenv("UST_DAEMON_SOCKET");
 
 		if (!sock_path_env) {
-			result = ustcomm_pack_sock_path(reply_header,
-							sock_msg,
-							SOCK_DIR "/ustd");
+			result = ustcomm_pack_single_field(reply_header,
+							   sock_msg,
+							   SOCK_DIR "/ustconsumer");
 
 		} else {
-			result = ustcomm_pack_sock_path(reply_header,
-							sock_msg,
-							sock_path_env);
+			result = ustcomm_pack_single_field(reply_header,
+							   sock_msg,
+							   sock_path_env);
 		}
 		reply_header->result = result;
 
 		goto send_response;
 	}
+	case SET_SOCK_PATH:
+	{
+		struct ustcomm_single_field *sock_msg;
+		sock_msg = (struct ustcomm_single_field *)recv_buf;
+		result = ustcomm_unpack_single_field(sock_msg);
+		if (result < 0) {
+			reply_header->result = -EINVAL;
+			goto send_response;
+		}
+
+		reply_header->result = setenv("UST_DAEMON_SOCKET",
+					      sock_msg->field, 1);
+
+		goto send_response;
+	}
 	case START:
 	case SETUP_TRACE:
 	case ALLOC_TRACE:
@@ -1027,11 +1057,12 @@ static void process_client_cmd(struct ustcomm_header *recv_header,
 	case START_TRACE:
 	case STOP_TRACE:
 	case DESTROY_TRACE:
+	case FORCE_SUBBUF_SWITCH:
 	{
-		struct ustcomm_trace_info *trace_inf =
-			(struct ustcomm_trace_info *)recv_buf;
+		struct ustcomm_single_field *trace_inf =
+			(struct ustcomm_single_field *)recv_buf;
 
-		result = ustcomm_unpack_trace_info(trace_inf);
+		result = ustcomm_unpack_single_field(trace_inf);
 		if (result < 0) {
 			ERR("couldn't unpack trace info");
 			reply_header->result = -EINVAL;
@@ -1040,16 +1071,14 @@ static void process_client_cmd(struct ustcomm_header *recv_header,
 
 		reply_header->result =
 			process_trace_cmd(recv_header->command,
-					  trace_inf->trace);
+					  trace_inf->field);
 		goto send_response;
 
 	}
 	default:
-		reply_header->result =
-			process_simple_client_cmd(recv_header->command,
-						  recv_buf);
-		goto send_response;
+		reply_header->result = -EINVAL;
 
+		goto send_response;
 	}
 
 	return;
@@ -1079,6 +1108,8 @@ void *listener_main(void *p)
 		}
 
 		for (i = 0; i < nfds; i++) {
+			pthread_mutex_lock(&listener_thread_data_mutex);
+			pthread_cleanup_push(release_listener_mutex, NULL);
 			epoll_sock = (struct ustcomm_sock *)events[i].data.ptr;
 			if (epoll_sock == listen_sock) {
 				addr_size = sizeof(struct sockaddr);
@@ -1107,6 +1138,7 @@ void *listener_main(void *p)
 							   epoll_sock->fd);
 				}
 			}
+			pthread_cleanup_pop(1);	/* release listener mutex */
 		}
 	}
 
@@ -1231,6 +1263,7 @@ free_name:
 
 static void __attribute__((constructor)) init()
 {
+	struct timespec ts;
 	int result;
 	char* autoprobe_val = NULL;
 	char* subbuffer_size_val = NULL;
@@ -1264,6 +1297,15 @@ static void __attribute__((constructor)) init()
 
 	create_listener();
 
+	/* Get clock the clock source type */
+
+	/* Default clock source */
+	ust_clock_source = CLOCK_TRACE;
+	if (clock_gettime(ust_clock_source, &ts) != 0) {
+		ust_clock_source = CLOCK_MONOTONIC;
+		DBG("UST traces will not be synchronized with LTTng traces");
+	}
+
 	autoprobe_val = getenv("UST_AUTOPROBE");
 	if (autoprobe_val) {
 		struct marker_iter iter;
@@ -1303,8 +1345,8 @@ static void __attribute__((constructor)) init()
 
 		DBG("now iterating on markers already registered");
 		while (iter.marker) {
-			DBG("now iterating on marker %s", iter.marker->name);
-			auto_probe_connect(iter.marker);
+			DBG("now iterating on marker %s", (*iter.marker)->name);
+			auto_probe_connect(*iter.marker);
 			marker_iter_next(&iter);
 		}
 	}
@@ -1312,7 +1354,7 @@ static void __attribute__((constructor)) init()
 	if (getenv("UST_OVERWRITE")) {
 		int val = atoi(getenv("UST_OVERWRITE"));
 		if (val == 0 || val == 1) {
-			STORE_SHARED(ust_channels_overwrite_by_default, val);
+			CMM_STORE_SHARED(ust_channels_overwrite_by_default, val);
 		} else {
 			WARN("invalid value for UST_OVERWRITE");
 		}
@@ -1321,7 +1363,7 @@ static void __attribute__((constructor)) init()
 	if (getenv("UST_AUTOCOLLECT")) {
 		int val = atoi(getenv("UST_AUTOCOLLECT"));
 		if (val == 0 || val == 1) {
-			STORE_SHARED(ust_channels_request_collection_by_default, val);
+			CMM_STORE_SHARED(ust_channels_request_collection_by_default, val);
 		} else {
 			WARN("invalid value for UST_AUTOCOLLECT");
 		}
@@ -1453,7 +1495,7 @@ static int trace_recording(void)
 
 	ltt_lock_traces();
 
-	list_for_each_entry(trace, &ltt_traces.head, list) {
+	cds_list_for_each_entry(trace, &ltt_traces.head, list) {
 		if (trace->active) {
 			retval = 1;
 			break;
@@ -1498,7 +1540,7 @@ static void stop_listener(void)
 }
 
 /* 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
+ * to leave time for ustconsumer 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.
@@ -1513,10 +1555,10 @@ static void __attribute__((destructor)) keepalive()
 		return;
 	}
 
-	if (trace_recording() && LOAD_SHARED(buffers_to_export)) {
+	if (trace_recording() && CMM_LOAD_SHARED(buffers_to_export)) {
 		int total = 0;
 		DBG("Keeping process alive for consumer daemon...");
-		while (LOAD_SHARED(buffers_to_export)) {
+		while (CMM_LOAD_SHARED(buffers_to_export)) {
 			const int interv = 200000;
 			restarting_usleep(interv);
 			total += interv;
@@ -1558,6 +1600,7 @@ static void ust_fork(void)
 {
 	struct ust_buffer *buf, *buf_tmp;
 	struct ustcomm_sock *sock, *sock_tmp;
+	struct ust_trace *trace, *trace_tmp;
 	int result;
 
 	/* FIXME: technically, the locks could have been taken before the fork */
@@ -1566,36 +1609,42 @@ static void ust_fork(void)
 	/* Get the pid of the new process */
 	processpid = getpid();
 
-	/* break lock if necessary */
-	ltt_unlock_traces();
+	/*
+	 * FIXME: This could be prettier, we loop over the list twice and
+	 * following good locking practice should lock around the loop
+	 */
+	cds_list_for_each_entry_safe(trace, trace_tmp, &ltt_traces.head, list) {
+		ltt_trace_stop(trace->trace_name);
+	}
 
-	ltt_trace_stop("auto");
-	ltt_trace_destroy("auto", 1);
 	/* Delete all active connections, but leave them in the epoll set */
-	list_for_each_entry_safe(sock, sock_tmp, &ust_socks, list) {
+	cds_list_for_each_entry_safe(sock, sock_tmp, &ust_socks, list) {
 		ustcomm_del_sock(sock, 1);
 	}
 
 	/* Delete all blocked consumers */
-	list_for_each_entry_safe(buf, buf_tmp, &open_buffers_list,
+	cds_list_for_each_entry_safe(buf, buf_tmp, &open_buffers_list,
 				 open_buffers_list) {
-		result = close(buf->data_ready_fd_read);
-		if (result == -1) {
-			PERROR("close");
-		}
-		result = close(buf->data_ready_fd_write);
-		if (result == -1) {
-			PERROR("close");
-		}
-		list_del(&buf->open_buffers_list);
+		cds_list_del(&buf->open_buffers_list);
 	}
 
-	/* Clean up the listener socket and epoll, keeping the scoket file */
-	ustcomm_del_named_sock(listen_sock, 1);
+	/*
+	 * FIXME: This could be prettier, we loop over the list twice and
+	 * following good locking practice should lock around the loop
+	 */
+	cds_list_for_each_entry_safe(trace, trace_tmp, &ltt_traces.head, list) {
+		ltt_trace_destroy(trace->trace_name, 1);
+	}
+
+	/* Clean up the listener socket and epoll, keeping the socket file */
+	if (listen_sock) {
+		ustcomm_del_named_sock(listen_sock, 1);
+		listen_sock = NULL;
+	}
 	close(epoll_fd);
 
 	/* Re-start the launch sequence */
-	STORE_SHARED(buffers_to_export, 0);
+	CMM_STORE_SHARED(buffers_to_export, 0);
 	have_listener = 0;
 
 	/* Set up epoll */
@@ -1646,6 +1695,17 @@ void ust_before_fork(ust_fork_info_t *fork_info)
                 PERROR("sigprocmask");
                 return;
         }
+
+	/*
+	 * Take the fork lock to make sure we are not in the middle of
+	 * something in the listener thread.
+	 */
+	pthread_mutex_lock(&listener_thread_data_mutex);
+	/*
+	 * Hold listen_sock_mutex to protect from listen_sock teardown.
+	 */
+	pthread_mutex_lock(&listen_sock_mutex);
+	rcu_bp_before_fork();
 }
 
 /* Don't call this function directly in a traced program */
@@ -1653,6 +1713,9 @@ static void ust_after_fork_common(ust_fork_info_t *fork_info)
 {
 	int result;
 
+	pthread_mutex_unlock(&listen_sock_mutex);
+	pthread_mutex_unlock(&listener_thread_data_mutex);
+
         /* Restore signals */
         result = sigprocmask(SIG_SETMASK, &fork_info->orig_sigs, NULL);
         if (result == -1) {
@@ -1663,16 +1726,20 @@ static void ust_after_fork_common(ust_fork_info_t *fork_info)
 
 void ust_after_fork_parent(ust_fork_info_t *fork_info)
 {
-	/* Reenable signals */
+	rcu_bp_after_fork_parent();
+	/* Release mutexes and reenable signals */
 	ust_after_fork_common(fork_info);
 }
 
 void ust_after_fork_child(ust_fork_info_t *fork_info)
 {
-	/* First sanitize the child */
+	/* Release urcu mutexes */
+	rcu_bp_after_fork_child();
+
+	/* Sanitize the child */
 	ust_fork();
 
-	/* Then reenable interrupts */
+	/* Then release mutexes and reenable signals */
 	ust_after_fork_common(fork_info);
 }