X-Git-Url: http://git.efficios.com/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fkernel.c;h=e13925e27c715d2dc796184f105bdef759df3257;hp=ccf315d8901efdcb2e04e50a4de9e85e1073bca2;hb=410b78a0be5045a1e0d85bdf3b3e0f2288825f0d;hpb=5c408ad8ef08a226c018702aca969536f36ac4e5

diff --git a/src/bin/lttng-sessiond/kernel.c b/src/bin/lttng-sessiond/kernel.c
index ccf315d89..e13925e27 100644
--- a/src/bin/lttng-sessiond/kernel.c
+++ b/src/bin/lttng-sessiond/kernel.c
@@ -41,6 +41,8 @@
  */
 static uint64_t next_kernel_channel_key;
 
+#include <lttng/userspace-probe.h>
+#include <lttng/userspace-probe-internal.h>
 /*
  * Add context on a kernel channel.
  *
@@ -191,6 +193,237 @@ error:
 	return -1;
 }
 
+/*
+ * Compute the offset of the instrumentation byte in the binary based on the
+ * function probe location using the ELF lookup method.
+ *
+ * Returns 0 on success and set the offset out parameter to the offset of the
+ * elf symbol
+ * Returns -1 on error
+ */
+static
+int extract_userspace_probe_offset_function_elf(
+		struct lttng_userspace_probe_location *probe_location,
+		struct ltt_kernel_session *session, uint64_t *offset)
+{
+	int fd;
+	int ret = 0;
+	const char *symbol = NULL;
+	struct lttng_userspace_probe_location_lookup_method *lookup = NULL;
+	enum lttng_userspace_probe_location_lookup_method_type lookup_method_type;
+
+
+	assert(lttng_userspace_probe_location_get_type(probe_location) ==
+			LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION);
+
+	lookup = lttng_userspace_probe_location_get_lookup_method(
+			probe_location);
+	if (!lookup) {
+		ret = -1;
+		goto end;
+	}
+
+	lookup_method_type =
+			lttng_userspace_probe_location_lookup_method_get_type(lookup);
+
+	assert(lookup_method_type ==
+			LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF);
+
+	symbol = lttng_userspace_probe_location_function_get_function_name(
+			probe_location);
+	if (!symbol) {
+		ret = -1;
+		goto end;
+	}
+
+	fd = lttng_userspace_probe_location_function_get_binary_fd(probe_location);
+	if (fd < 0) {
+		ret = -1;
+		goto end;
+	}
+
+	ret = run_as_extract_elf_symbol_offset(fd, symbol, session->uid,
+			session->gid, offset);
+	if (ret < 0) {
+		DBG("userspace probe offset calculation failed for "
+				"function %s", symbol);
+		goto end;
+	}
+
+	DBG("userspace probe elf offset for %s is 0x%jd", symbol, (intmax_t)(*offset));
+end:
+	return ret;
+}
+
+/*
+ * Compute the offsets of the instrumentation bytes in the binary based on the
+ * tracepoint probe location using the SDT lookup method. This function
+ * allocates the offsets buffer, the caller must free it.
+ *
+ * Returns 0 on success and set the offset out parameter to the offsets of the
+ * SDT tracepoint.
+ * Returns -1 on error.
+ */
+static
+int extract_userspace_probe_offset_tracepoint_sdt(
+		struct lttng_userspace_probe_location *probe_location,
+		struct ltt_kernel_session *session, uint64_t **offsets,
+		uint32_t *offsets_count)
+{
+	enum lttng_userspace_probe_location_lookup_method_type lookup_method_type;
+	struct lttng_userspace_probe_location_lookup_method *lookup = NULL;
+	const char *probe_name = NULL, *provider_name = NULL;
+	int ret = 0;
+	int fd, i;
+
+	assert(lttng_userspace_probe_location_get_type(probe_location) ==
+			LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT);
+
+	lookup = lttng_userspace_probe_location_get_lookup_method(probe_location);
+	if (!lookup) {
+		ret = -1;
+		goto end;
+	}
+
+	lookup_method_type =
+			lttng_userspace_probe_location_lookup_method_get_type(lookup);
+
+	assert(lookup_method_type ==
+			LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT);
+
+
+	probe_name = lttng_userspace_probe_location_tracepoint_get_probe_name(
+			probe_location);
+	if (!probe_name) {
+		ret = -1;
+		goto end;
+	}
+
+	provider_name = lttng_userspace_probe_location_tracepoint_get_provider_name(
+			probe_location);
+	if (!provider_name) {
+		ret = -1;
+		goto end;
+	}
+
+	fd = lttng_userspace_probe_location_tracepoint_get_binary_fd(probe_location);
+	if (fd < 0) {
+		ret = -1;
+		goto end;
+	}
+
+	ret = run_as_extract_sdt_probe_offsets(fd, provider_name, probe_name,
+			session->uid, session->gid, offsets, offsets_count);
+	if (ret < 0) {
+		DBG("userspace probe offset calculation failed for sdt "
+				"probe %s:%s", provider_name, probe_name);
+		goto end;
+	}
+
+	if (*offsets_count == 0) {
+		DBG("no userspace probe offset found");
+		goto end;
+	}
+
+	DBG("%u userspace probe SDT offsets found for %s:%s at:",
+			*offsets_count, provider_name, probe_name);
+	for (i = 0; i < *offsets_count; i++) {
+		DBG("\t0x%jd", (intmax_t)((*offsets)[i]));
+	}
+end:
+	return ret;
+}
+
+/*
+ * Extract the offsets of the instrumentation point for the different lookup
+ * methods.
+ */
+static
+int userspace_probe_add_callsites(struct lttng_event *ev,
+			struct ltt_kernel_session *session, int fd)
+{
+	struct lttng_userspace_probe_location_lookup_method *lookup_method = NULL;
+	enum lttng_userspace_probe_location_lookup_method_type type;
+	struct lttng_userspace_probe_location *location = NULL;
+	int ret;
+
+	assert(ev);
+	assert(ev->type == LTTNG_EVENT_USERSPACE_PROBE);
+
+	location = lttng_event_get_userspace_probe_location(ev);
+	if (!location) {
+		ret = -1;
+		goto end;
+	}
+	lookup_method =
+			lttng_userspace_probe_location_get_lookup_method(location);
+	if (!lookup_method) {
+		ret = -1;
+		goto end;
+	}
+
+	type = lttng_userspace_probe_location_lookup_method_get_type(lookup_method);
+	switch (type) {
+	case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF:
+	{
+		struct lttng_kernel_event_callsite callsite;
+		uint64_t offset;
+
+		ret = extract_userspace_probe_offset_function_elf(location, session, &offset);
+		if (ret) {
+			ret = LTTNG_ERR_PROBE_LOCATION_INVAL;
+			goto end;
+		}
+
+		callsite.u.uprobe.offset = offset;
+		ret = kernctl_add_callsite(fd, &callsite);
+		if (ret) {
+			WARN("Adding callsite to userspace probe "
+					"event %s failed.", ev->name);
+			ret = LTTNG_ERR_KERN_ENABLE_FAIL;
+			goto end;
+		}
+		break;
+	}
+	case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT:
+	{
+		int i;
+		uint64_t *offsets = NULL;
+		uint32_t offsets_count;
+		struct lttng_kernel_event_callsite callsite;
+
+		/*
+		 * This call allocates the offsets buffer. This buffer must be freed
+		 * by the caller
+		 */
+		ret = extract_userspace_probe_offset_tracepoint_sdt(location, session,
+				&offsets, &offsets_count);
+		if (ret) {
+			ret = LTTNG_ERR_PROBE_LOCATION_INVAL;
+			goto end;
+		}
+		for (i = 0; i < offsets_count; i++) {
+			callsite.u.uprobe.offset = offsets[i];
+			ret = kernctl_add_callsite(fd, &callsite);
+			if (ret) {
+				WARN("Adding callsite to userspace probe "
+						"event %s failed.", ev->name);
+				ret = LTTNG_ERR_KERN_ENABLE_FAIL;
+				free(offsets);
+				goto end;
+			}
+		}
+		free(offsets);
+		break;
+	}
+	default:
+		ret = LTTNG_ERR_PROBE_LOCATION_INVAL;
+		goto end;
+	}
+end:
+	return ret;
+}
+
 /*
  * Create a kernel event, enable it to the kernel tracer and add it to the
  * channel event list of the kernel session.
@@ -201,60 +434,73 @@ int kernel_create_event(struct lttng_event *ev,
 		char *filter_expression,
 		struct lttng_filter_bytecode *filter)
 {
-	int ret;
+	int err, fd;
+	enum lttng_error_code ret;
 	struct ltt_kernel_event *event;
 
 	assert(ev);
 	assert(channel);
 
 	/* We pass ownership of filter_expression and filter */
-	event = trace_kernel_create_event(ev, filter_expression,
-			filter);
-	if (event == NULL) {
-		ret = -1;
+	ret = trace_kernel_create_event(ev, filter_expression,
+			filter, &event);
+	if (ret != LTTNG_OK) {
 		goto error;
 	}
 
-	ret = kernctl_create_event(channel->fd, event->event);
-	if (ret < 0) {
-		switch (-ret) {
+	fd = kernctl_create_event(channel->fd, event->event);
+	if (fd < 0) {
+		switch (-fd) {
 		case EEXIST:
+			ret = LTTNG_ERR_KERN_EVENT_EXIST;
 			break;
 		case ENOSYS:
 			WARN("Event type not implemented");
+			ret = LTTNG_ERR_KERN_EVENT_ENOSYS;
 			break;
 		case ENOENT:
 			WARN("Event %s not found!", ev->name);
+			ret = LTTNG_ERR_KERN_ENABLE_FAIL;
 			break;
 		default:
+			ret = LTTNG_ERR_KERN_ENABLE_FAIL;
 			PERROR("create event ioctl");
 		}
 		goto free_event;
 	}
 
 	event->type = ev->type;
-	event->fd = ret;
+	event->fd = fd;
 	/* Prevent fd duplication after execlp() */
-	ret = fcntl(event->fd, F_SETFD, FD_CLOEXEC);
-	if (ret < 0) {
+	err = fcntl(event->fd, F_SETFD, FD_CLOEXEC);
+	if (err < 0) {
 		PERROR("fcntl session fd");
 	}
 
 	if (filter) {
-		ret = kernctl_filter(event->fd, filter);
-		if (ret) {
+		err = kernctl_filter(event->fd, filter);
+		if (err < 0) {
+			switch (-err) {
+			case ENOMEM:
+				ret = LTTNG_ERR_FILTER_NOMEM;
+				break;
+			default:
+				ret = LTTNG_ERR_FILTER_INVAL;
+				break;
+			}
 			goto filter_error;
 		}
 	}
 
-	ret = kernctl_enable(event->fd);
-	if (ret < 0) {
-		switch (-ret) {
+	err = kernctl_enable(event->fd);
+	if (err < 0) {
+		switch (-err) {
 		case EEXIST:
 			ret = LTTNG_ERR_KERN_EVENT_EXIST;
 			break;
 		default:
 			PERROR("enable kernel event");
+			ret = LTTNG_ERR_KERN_ENABLE_FAIL;
 			break;
 		}
 		goto enable_error;
@@ -990,6 +1236,8 @@ int kernel_snapshot_record(struct ltt_kernel_session *ksess,
 	struct consumer_socket *socket;
 	struct lttng_ht_iter iter;
 	struct ltt_kernel_metadata *saved_metadata;
+	struct ltt_session *session;
+	uint64_t trace_archive_id;
 
 	assert(ksess);
 	assert(ksess->consumer);
@@ -997,6 +1245,12 @@ int kernel_snapshot_record(struct ltt_kernel_session *ksess,
 
 	DBG("Kernel snapshot record started");
 
+	session = session_find_by_id(ksess->id);
+	assert(session);
+	assert(pthread_mutex_trylock(&session->lock));
+	assert(session_trylock_list());
+	trace_archive_id = session->current_archive_id;
+
 	/* Save current metadata since the following calls will change it. */
 	saved_metadata = ksess->metadata;
 	saved_metadata_fd = ksess->metadata_stream_fd;
@@ -1044,7 +1298,8 @@ int kernel_snapshot_record(struct ltt_kernel_session *ksess,
 			ret = consumer_snapshot_channel(socket, chan->key, output, 0,
 					ksess->uid, ksess->gid,
 					DEFAULT_KERNEL_TRACE_DIR, wait,
-					nb_packets_per_stream);
+					nb_packets_per_stream,
+					trace_archive_id);
 			if (ret < 0) {
 				ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
 				(void) kernel_consumer_destroy_metadata(socket,
@@ -1056,7 +1311,8 @@ int kernel_snapshot_record(struct ltt_kernel_session *ksess,
 		/* Snapshot metadata, */
 		ret = consumer_snapshot_channel(socket, ksess->metadata->key, output,
 				1, ksess->uid, ksess->gid,
-				DEFAULT_KERNEL_TRACE_DIR, wait, 0);
+				DEFAULT_KERNEL_TRACE_DIR, wait, 0,
+				trace_archive_id);
 		if (ret < 0) {
 			ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
 			goto error_consumer;
@@ -1169,7 +1425,7 @@ int kernel_rotate_session(struct ltt_session *session)
 		 * reach 0 before we complete the iteration over all
 		 * the channels.
 		 */
-		ret = rotate_add_channel_pending(ksess->metadata->fd,
+		ret = rotate_add_channel_pending(ksess->metadata->key,
 				LTTNG_DOMAIN_KERNEL, session);
 		if (ret < 0) {
 			ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
@@ -1190,7 +1446,7 @@ int kernel_rotate_session(struct ltt_session *session)
 					ksess->uid, ksess->gid, ksess->consumer,
 					ksess->consumer->subdir,
 					/* is_metadata_channel */ false,
-					session->rotate_count,
+					session->current_archive_id,
 					&session->rotate_pending_relay);
 			if (ret < 0) {
 				ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
@@ -1201,11 +1457,11 @@ int kernel_rotate_session(struct ltt_session *session)
 		/*
 		 * Rotate the metadata channel.
 		 */
-		ret = consumer_rotate_channel(socket, ksess->metadata->fd,
+		ret = consumer_rotate_channel(socket, ksess->metadata->key,
 				ksess->uid, ksess->gid, ksess->consumer,
 				ksess->consumer->subdir,
 				/* is_metadata_channel */ true,
-				session->rotate_count,
+				session->current_archive_id,
 				&session->rotate_pending_relay);
 		if (ret < 0) {
 			ret = LTTNG_ERR_KERN_CONSUMER_FAIL;