X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=lttng-events.c;h=c86a7565d0e3349d0a0ba6b25f365dbd419bb661;hb=8f89e22da25c7cc8b82d4b6574631b0632fc37f3;hp=0c72015fd1a56edc79f4ef9e4106c8aa3745c48c;hpb=65c85aa61984217039857513bbe988036f371693;p=lttng-modules.git

diff --git a/lttng-events.c b/lttng-events.c
index 0c72015f..c86a7565 100644
--- a/lttng-events.c
+++ b/lttng-events.c
@@ -52,6 +52,8 @@
 #include <lttng-abi-old.h>
 #include <lttng-endian.h>
 #include <wrapper/vzalloc.h>
+#include <wrapper/ringbuffer/backend.h>
+#include <wrapper/ringbuffer/frontend.h>
 
 #define METADATA_CACHE_DEFAULT_SIZE 4096
 
@@ -211,6 +213,16 @@ void lttng_session_destroy(struct lttng_session *session)
 	kfree(session);
 }
 
+int lttng_session_statedump(struct lttng_session *session)
+{
+	int ret;
+
+	mutex_lock(&sessions_mutex);
+	ret = lttng_statedump_start(session);
+	mutex_unlock(&sessions_mutex);
+	return ret;
+}
+
 int lttng_session_enable(struct lttng_session *session)
 {
 	int ret = 0;
@@ -241,6 +253,12 @@ int lttng_session_enable(struct lttng_session *session)
 	/* We need to sync enablers with session before activation. */
 	lttng_session_sync_enablers(session);
 
+	/* Clear each stream's quiescent state. */
+	list_for_each_entry(chan, &session->chan, list) {
+		if (chan->channel_type != METADATA_CHANNEL)
+			lib_ring_buffer_clear_quiescent_channel(chan->chan);
+	}
+
 	ACCESS_ONCE(session->active) = 1;
 	ACCESS_ONCE(session->been_active) = 1;
 	ret = _lttng_session_metadata_statedump(session);
@@ -259,6 +277,7 @@ end:
 int lttng_session_disable(struct lttng_session *session)
 {
 	int ret = 0;
+	struct lttng_channel *chan;
 
 	mutex_lock(&sessions_mutex);
 	if (!session->active) {
@@ -270,6 +289,12 @@ int lttng_session_disable(struct lttng_session *session)
 	/* Set transient enabler state to "disabled" */
 	session->tstate = 0;
 	lttng_session_sync_enablers(session);
+
+	/* Set each stream's quiescent state. */
+	list_for_each_entry(chan, &session->chan, list) {
+		if (chan->channel_type != METADATA_CHANNEL)
+			lib_ring_buffer_set_quiescent_channel(chan->chan);
+	}
 end:
 	mutex_unlock(&sessions_mutex);
 	return ret;
@@ -1863,6 +1888,129 @@ int _lttng_sequence_compound_statedump(struct lttng_session *session,
 	return ret;
 }
 
+/*
+ * Must be called with sessions_mutex held.
+ */
+static
+int _lttng_enum_statedump(struct lttng_session *session,
+		const struct lttng_event_field *field,
+		size_t nesting)
+{
+	const struct lttng_enum_desc *enum_desc;
+	const struct lttng_integer_type *container_type;
+	int ret;
+	unsigned int i, nr_entries;
+
+	enum_desc = field->type.u.basic.enumeration.desc;
+	container_type = &field->type.u.basic.enumeration.container_type;
+	nr_entries = enum_desc->nr_entries;
+
+	ret = print_tabs(session, nesting);
+	if (ret)
+		goto end;
+	ret = lttng_metadata_printf(session,
+		"enum : integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } {\n",
+		container_type->size,
+		container_type->alignment,
+		container_type->signedness,
+		(container_type->encoding == lttng_encode_none)
+			? "none"
+			: (container_type->encoding == lttng_encode_UTF8)
+				? "UTF8"
+				: "ASCII",
+		container_type->base,
+#if __BYTE_ORDER == __BIG_ENDIAN
+		container_type->reverse_byte_order ? " byte_order = le;" : ""
+#else
+		container_type->reverse_byte_order ? " byte_order = be;" : ""
+#endif
+		);
+	if (ret)
+	        goto end;
+	/* Dump all entries */
+	for (i = 0; i < nr_entries; i++) {
+		const struct lttng_enum_entry *entry = &enum_desc->entries[i];
+		int j, len;
+
+		ret = print_tabs(session, nesting + 1);
+		if (ret)
+			goto end;
+		ret = lttng_metadata_printf(session,
+				"\"");
+		if (ret)
+			goto end;
+		len = strlen(entry->string);
+		/* Escape the character '"' */
+		for (j = 0; j < len; j++) {
+			char c = entry->string[j];
+
+			switch (c) {
+			case '"':
+				ret = lttng_metadata_printf(session,
+						"\\\"");
+				break;
+			case '\\':
+				ret = lttng_metadata_printf(session,
+						"\\\\");
+				break;
+			default:
+				ret = lttng_metadata_printf(session,
+						"%c", c);
+				break;
+			}
+			if (ret)
+				goto end;
+		}
+		ret = lttng_metadata_printf(session, "\"");
+		if (ret)
+			goto end;
+
+		if (entry->options.is_auto) {
+			ret = lttng_metadata_printf(session, ",\n");
+			if (ret)
+				goto end;
+		} else {
+			ret = lttng_metadata_printf(session,
+					" = ");
+			if (ret)
+				goto end;
+			if (entry->start.signedness)
+				ret = lttng_metadata_printf(session,
+					"%lld", (long long) entry->start.value);
+			else
+				ret = lttng_metadata_printf(session,
+					"%llu", entry->start.value);
+			if (ret)
+				goto end;
+			if (entry->start.signedness == entry->end.signedness &&
+					entry->start.value
+						== entry->end.value) {
+				ret = lttng_metadata_printf(session,
+					",\n");
+			} else {
+				if (entry->end.signedness) {
+					ret = lttng_metadata_printf(session,
+						" ... %lld,\n",
+						(long long) entry->end.value);
+				} else {
+					ret = lttng_metadata_printf(session,
+						" ... %llu,\n",
+						entry->end.value);
+				}
+			}
+			if (ret)
+				goto end;
+		}
+	}
+	ret = print_tabs(session, nesting);
+	if (ret)
+		goto end;
+	ret = lttng_metadata_printf(session, "} _%s;\n",
+			field->name);
+end:
+	return ret;
+}
+
 /*
  * Must be called with sessions_mutex held.
  */
@@ -1897,13 +2045,7 @@ int _lttng_field_statedump(struct lttng_session *session,
 			field->name);
 		break;
 	case atype_enum:
-		ret = print_tabs(session, nesting);
-		if (ret)
-			return ret;
-		ret = lttng_metadata_printf(session,
-			"%s _%s;\n",
-			field->type.u.basic.enumeration.name,
-			field->name);
+		ret = _lttng_enum_statedump(session, field, nesting);
 		break;
 	case atype_array:
 	{
@@ -2279,7 +2421,7 @@ int64_t measure_clock_offset(void)
 	/* Disable interrupts to increase correlation precision. */
 	local_irq_save(flags);
 	monotonic[0] = trace_clock_read64();
-	getnstimeofday(&rts);      
+	getnstimeofday(&rts);
 	monotonic[1] = trace_clock_read64();
 	local_irq_restore(flags);
 
@@ -2502,6 +2644,133 @@ void lttng_transport_unregister(struct lttng_transport *transport)
 }
 EXPORT_SYMBOL_GPL(lttng_transport_unregister);
 
+#if (defined(CONFIG_HOTPLUG_CPU) && (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)))
+
+enum cpuhp_state lttng_hp_prepare;
+enum cpuhp_state lttng_hp_online;
+
+static int lttng_hotplug_prepare(unsigned int cpu, struct hlist_node *node)
+{
+	struct lttng_cpuhp_node *lttng_node;
+
+	lttng_node = container_of(node, struct lttng_cpuhp_node, node);
+	switch (lttng_node->component) {
+	case LTTNG_RING_BUFFER_FRONTEND:
+		return 0;
+	case LTTNG_RING_BUFFER_BACKEND:
+		return lttng_cpuhp_rb_backend_prepare(cpu, lttng_node);
+	case LTTNG_RING_BUFFER_ITER:
+		return 0;
+	case LTTNG_CONTEXT_PERF_COUNTERS:
+		return 0;
+	default:
+		return -EINVAL;
+	}
+}
+
+static int lttng_hotplug_dead(unsigned int cpu, struct hlist_node *node)
+{
+	struct lttng_cpuhp_node *lttng_node;
+
+	lttng_node = container_of(node, struct lttng_cpuhp_node, node);
+	switch (lttng_node->component) {
+	case LTTNG_RING_BUFFER_FRONTEND:
+		return lttng_cpuhp_rb_frontend_dead(cpu, lttng_node);
+	case LTTNG_RING_BUFFER_BACKEND:
+		return 0;
+	case LTTNG_RING_BUFFER_ITER:
+		return 0;
+	case LTTNG_CONTEXT_PERF_COUNTERS:
+		return lttng_cpuhp_perf_counter_dead(cpu, lttng_node);
+	default:
+		return -EINVAL;
+	}
+}
+
+static int lttng_hotplug_online(unsigned int cpu, struct hlist_node *node)
+{
+	struct lttng_cpuhp_node *lttng_node;
+
+	lttng_node = container_of(node, struct lttng_cpuhp_node, node);
+	switch (lttng_node->component) {
+	case LTTNG_RING_BUFFER_FRONTEND:
+		return lttng_cpuhp_rb_frontend_online(cpu, lttng_node);
+	case LTTNG_RING_BUFFER_BACKEND:
+		return 0;
+	case LTTNG_RING_BUFFER_ITER:
+		return lttng_cpuhp_rb_iter_online(cpu, lttng_node);
+	case LTTNG_CONTEXT_PERF_COUNTERS:
+		return lttng_cpuhp_perf_counter_online(cpu, lttng_node);
+	default:
+		return -EINVAL;
+	}
+}
+
+static int lttng_hotplug_offline(unsigned int cpu, struct hlist_node *node)
+{
+	struct lttng_cpuhp_node *lttng_node;
+
+	lttng_node = container_of(node, struct lttng_cpuhp_node, node);
+	switch (lttng_node->component) {
+	case LTTNG_RING_BUFFER_FRONTEND:
+		return lttng_cpuhp_rb_frontend_offline(cpu, lttng_node);
+	case LTTNG_RING_BUFFER_BACKEND:
+		return 0;
+	case LTTNG_RING_BUFFER_ITER:
+		return 0;
+	case LTTNG_CONTEXT_PERF_COUNTERS:
+		return 0;
+	default:
+		return -EINVAL;
+	}
+}
+
+static int __init lttng_init_cpu_hotplug(void)
+{
+	int ret;
+
+	ret = cpuhp_setup_state_multi(CPUHP_BP_PREPARE_DYN, "lttng:prepare",
+			lttng_hotplug_prepare,
+			lttng_hotplug_dead);
+	if (ret < 0) {
+		return ret;
+	}
+	lttng_hp_prepare = ret;
+	lttng_rb_set_hp_prepare(ret);
+
+	ret = cpuhp_setup_state_multi(CPUHP_AP_ONLINE_DYN, "lttng:online",
+			lttng_hotplug_online,
+			lttng_hotplug_offline);
+	if (ret < 0) {
+		cpuhp_remove_multi_state(lttng_hp_prepare);
+		lttng_hp_prepare = 0;
+		return ret;
+	}
+	lttng_hp_online = ret;
+	lttng_rb_set_hp_online(ret);
+
+	return 0;
+}
+
+static void __exit lttng_exit_cpu_hotplug(void)
+{
+	lttng_rb_set_hp_online(0);
+	cpuhp_remove_multi_state(lttng_hp_online);
+	lttng_rb_set_hp_prepare(0);
+	cpuhp_remove_multi_state(lttng_hp_prepare);
+}
+
+#else /* #if (CONFIG_HOTPLUG_CPU && (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))) */
+static int lttng_init_cpu_hotplug(void)
+{
+	return 0;
+}
+static void lttng_exit_cpu_hotplug(void)
+{
+}
+#endif /* #else #if (CONFIG_HOTPLUG_CPU && (LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0))) */
+
+
 static int __init lttng_events_init(void)
 {
 	int ret;
@@ -2535,8 +2804,13 @@ static int __init lttng_events_init(void)
 	ret = lttng_logger_init();
 	if (ret)
 		goto error_logger;
+	ret = lttng_init_cpu_hotplug();
+	if (ret)
+		goto error_hotplug;
 	return 0;
 
+error_hotplug:
+	lttng_logger_exit();
 error_logger:
 	lttng_abi_exit();
 error_abi:
@@ -2554,6 +2828,7 @@ static void __exit lttng_events_exit(void)
 {
 	struct lttng_session *session, *tmpsession;
 
+	lttng_exit_cpu_hotplug();
 	lttng_logger_exit();
 	lttng_abi_exit();
 	list_for_each_entry_safe(session, tmpsession, &sessions, list)