X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=liblttng-ust%2Flttng-context.c;h=e97b688ad8f74d282ae41a0031d64a62d524ba7c;hb=a084756d092167324ee09d3f819cc45407b58233;hp=e2032162e514c8e1aac85e6ee88a13c559cc0cb8;hpb=53569322d40ed45abe0368ddb08eb4a2738afc37;p=lttng-ust.git

diff --git a/liblttng-ust/lttng-context.c b/liblttng-ust/lttng-context.c
index e2032162..e97b688a 100644
--- a/liblttng-ust/lttng-context.c
+++ b/liblttng-ust/lttng-context.c
@@ -1,41 +1,32 @@
 /*
- * lttng-context.c
- *
- * LTTng UST trace/channel/event context management.
+ * SPDX-License-Identifier: LGPL-2.1-only
  *
  * Copyright (C) 2011 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
  *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; only
- * version 2.1 of the License.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * LTTng UST trace/channel/event context management.
  */
 
-
+#define _LGPL_SOURCE
 #include <lttng/ust-events.h>
 #include <lttng/ust-tracer.h>
-#include <lttng/ust-context-provider.h>
-#include <urcu-pointer.h>
+#include <ust-context-provider.h>
+#include <lttng/urcu/pointer.h>
+#include <lttng/urcu/urcu-ust.h>
 #include <usterr-signal-safe.h>
-#include <helper.h>
+#include <ust-helper.h>
+#include <stddef.h>
 #include <string.h>
 #include <assert.h>
+#include "tracepoint-internal.h"
+
+#include "context-internal.h"
 
 /*
  * The filter implementation requires that two consecutive "get" for the
  * same context performed by the same thread return the same result.
  */
 
-int lttng_find_context(struct lttng_ctx *ctx, const char *name)
+int lttng_find_context(struct lttng_ust_ctx *ctx, const char *name)
 {
 	unsigned int i;
 	const char *subname;
@@ -47,23 +38,15 @@ int lttng_find_context(struct lttng_ctx *ctx, const char *name)
 	}
 	for (i = 0; i < ctx->nr_fields; i++) {
 		/* Skip allocated (but non-initialized) contexts */
-		if (!ctx->fields[i].event_field.name)
+		if (!ctx->fields[i]->event_field->name)
 			continue;
-		if (!strcmp(ctx->fields[i].event_field.name, subname))
+		if (!strcmp(ctx->fields[i]->event_field->name, subname))
 			return 1;
 	}
 	return 0;
 }
 
-int lttng_context_is_app(const char *name)
-{
-	if (strncmp(name, "$app.", strlen("$app.")) != 0) {
-		return 0;
-	}
-	return 1;
-}
-
-int lttng_get_context_index(struct lttng_ctx *ctx, const char *name)
+int lttng_get_context_index(struct lttng_ust_ctx *ctx, const char *name)
 {
 	unsigned int i;
 	const char *subname;
@@ -77,23 +60,23 @@ int lttng_get_context_index(struct lttng_ctx *ctx, const char *name)
 	}
 	for (i = 0; i < ctx->nr_fields; i++) {
 		/* Skip allocated (but non-initialized) contexts */
-		if (!ctx->fields[i].event_field.name)
+		if (!ctx->fields[i]->event_field->name)
 			continue;
-		if (!strcmp(ctx->fields[i].event_field.name, subname))
+		if (!strcmp(ctx->fields[i]->event_field->name, subname))
 			return i;
 	}
 	return -1;
 }
 
-static int lttng_find_context_provider(struct lttng_ctx *ctx, const char *name)
+static int lttng_find_context_provider(struct lttng_ust_ctx *ctx, const char *name)
 {
 	unsigned int i;
 
 	for (i = 0; i < ctx->nr_fields; i++) {
 		/* Skip allocated (but non-initialized) contexts */
-		if (!ctx->fields[i].event_field.name)
+		if (!ctx->fields[i]->event_field->name)
 			continue;
-		if (!strncmp(ctx->fields[i].event_field.name, name,
+		if (!strncmp(ctx->fields[i]->event_field->name, name,
 				strlen(name)))
 			return 1;
 	}
@@ -102,68 +85,103 @@ static int lttng_find_context_provider(struct lttng_ctx *ctx, const char *name)
 
 /*
  * Note: as we append context information, the pointer location may change.
+ * lttng_add_context leaves the new last context initialized to NULL.
  */
-struct lttng_ctx_field *lttng_append_context(struct lttng_ctx **ctx_p)
+static
+int lttng_add_context(struct lttng_ust_ctx **ctx_p)
 {
-	struct lttng_ctx_field *field;
-	struct lttng_ctx *ctx;
+	struct lttng_ust_ctx *ctx;
 
 	if (!*ctx_p) {
-		*ctx_p = zmalloc(sizeof(struct lttng_ctx));
+		*ctx_p = zmalloc(sizeof(struct lttng_ust_ctx));
 		if (!*ctx_p)
-			return NULL;
+			return -ENOMEM;
+		(*ctx_p)->struct_size = sizeof(struct lttng_ust_ctx);
 		(*ctx_p)->largest_align = 1;
 	}
 	ctx = *ctx_p;
 	if (ctx->nr_fields + 1 > ctx->allocated_fields) {
-		struct lttng_ctx_field *new_fields;
+		struct lttng_ust_ctx_field **new_fields;
 
 		ctx->allocated_fields = max_t(size_t, 1, 2 * ctx->allocated_fields);
-		new_fields = zmalloc(ctx->allocated_fields * sizeof(struct lttng_ctx_field));
+		new_fields = zmalloc(ctx->allocated_fields * sizeof(*new_fields));
 		if (!new_fields)
-			return NULL;
+			return -ENOMEM;
+		/* Copy pointers */
 		if (ctx->fields)
 			memcpy(new_fields, ctx->fields, sizeof(*ctx->fields) * ctx->nr_fields);
 		free(ctx->fields);
 		ctx->fields = new_fields;
 	}
-	field = &ctx->fields[ctx->nr_fields];
 	ctx->nr_fields++;
+	return 0;
+}
+
+struct lttng_ust_ctx_field *lttng_append_context(struct lttng_ust_ctx **ctx_p)
+{
+	struct lttng_ust_ctx_field *field;
+	int ret;
+
+	field = zmalloc(sizeof(struct lttng_ust_ctx_field));
+	if (!field)
+		goto error_alloc_field;
+	field->struct_size = sizeof(struct lttng_ust_ctx_field);
+	field->event_field = zmalloc(sizeof(struct lttng_ust_event_field));
+	if (!field->event_field)
+		goto error_alloc_event_field;
+	field->event_field->struct_size = sizeof(struct lttng_ust_event_field);
+
+	ret = lttng_add_context(ctx_p);
+	if (ret)
+		goto error_add_context;
+	(*ctx_p)->fields[(*ctx_p)->nr_fields - 1] = field;
 	return field;
+
+error_add_context:
+	free(field->event_field);
+error_alloc_event_field:
+	free(field);
+error_alloc_field:
+	return NULL;
 }
 
-int lttng_context_add_rcu(struct lttng_ctx **ctx_p,
-		const struct lttng_ctx_field *f)
+/*
+ * Takes ownership of @f on success.
+ */
+int lttng_context_add_rcu(struct lttng_ust_ctx **ctx_p,
+		struct lttng_ust_ctx_field *f)
 {
-	struct lttng_ctx *old_ctx = *ctx_p, *new_ctx = NULL;
-	struct lttng_ctx_field *new_fields = NULL;
-	struct lttng_ctx_field *nf;
+	struct lttng_ust_ctx *old_ctx = *ctx_p, *new_ctx = NULL;
+	struct lttng_ust_ctx_field **new_fields = NULL;
+	int ret;
 
 	if (old_ctx) {
-		new_ctx = zmalloc(sizeof(struct lttng_ctx));
+		new_ctx = zmalloc(sizeof(struct lttng_ust_ctx));
 		if (!new_ctx)
 			return -ENOMEM;
+		new_ctx->struct_size = sizeof(struct lttng_ust_ctx);
 		*new_ctx = *old_ctx;
-		new_fields = zmalloc(new_ctx->allocated_fields
-				* sizeof(struct lttng_ctx_field));
+		new_fields = zmalloc(new_ctx->allocated_fields * sizeof(*new_fields));
 		if (!new_fields) {
 			free(new_ctx);
 			return -ENOMEM;
 		}
+		/* Copy pointers */
 		memcpy(new_fields, old_ctx->fields,
 				sizeof(*old_ctx->fields) * old_ctx->nr_fields);
 		new_ctx->fields = new_fields;
 	}
-	nf = lttng_append_context(&new_ctx);
-	if (!nf) {
+	ret = lttng_add_context(&new_ctx);
+	if (ret) {
 		free(new_fields);
 		free(new_ctx);
-		return -ENOMEM;
+		return ret;
 	}
-	*nf = *f;
+	/* Taking ownership of f. */
+	(*ctx_p)->fields[(*ctx_p)->nr_fields - 1] = f;
 	lttng_context_update(new_ctx);
-	rcu_assign_pointer(*ctx_p, new_ctx);
-	synchronize_trace();
+	lttng_ust_rcu_assign_pointer(*ctx_p, new_ctx);
+	lttng_ust_urcu_synchronize_rcu();
 	if (old_ctx) {
 		free(old_ctx->fields);
 		free(old_ctx);
@@ -171,90 +189,55 @@ int lttng_context_add_rcu(struct lttng_ctx **ctx_p,
 	return 0;
 }
 
+static size_t get_type_max_align(struct lttng_ust_type_common *type)
+{
+	switch (type->type) {
+	case lttng_ust_type_integer:
+		return lttng_ust_get_type_integer(type)->alignment;
+	case lttng_ust_type_string:
+		return CHAR_BIT;
+	case lttng_ust_type_dynamic:
+		return 0;
+	case lttng_ust_type_enum:
+		return get_type_max_align(lttng_ust_get_type_enum(type)->container_type);
+	case lttng_ust_type_array:
+		return max_t(size_t, get_type_max_align(lttng_ust_get_type_array(type)->elem_type),
+				lttng_ust_get_type_array(type)->alignment);
+	case lttng_ust_type_sequence:
+		return max_t(size_t, get_type_max_align(lttng_ust_get_type_sequence(type)->elem_type),
+				lttng_ust_get_type_sequence(type)->alignment);
+	case lttng_ust_type_struct:
+	{
+		unsigned int i;
+		size_t field_align = 0;
+		struct lttng_ust_type_struct *struct_type = lttng_ust_get_type_struct(type);
+
+		for (i = 0; i < struct_type->nr_fields; i++) {
+			field_align = max_t(size_t,
+				get_type_max_align(struct_type->fields[i]->type),
+				field_align);
+		}
+		return field_align;
+	}
+	default:
+		WARN_ON_ONCE(1);
+		return 0;
+	}
+}
+
 /*
  * lttng_context_update() should be called at least once between context
  * modification and trace start.
  */
-void lttng_context_update(struct lttng_ctx *ctx)
+void lttng_context_update(struct lttng_ust_ctx *ctx)
 {
 	int i;
 	size_t largest_align = 8;	/* in bits */
 
 	for (i = 0; i < ctx->nr_fields; i++) {
-		struct lttng_type *type;
 		size_t field_align = 8;
 
-		type = &ctx->fields[i].event_field.type;
-		switch (type->atype) {
-		case atype_integer:
-			field_align = type->u.basic.integer.alignment;
-			break;
-		case atype_array:
-		{
-			struct lttng_basic_type *btype;
-
-			btype = &type->u.array.elem_type;
-			switch (btype->atype) {
-			case atype_integer:
-				field_align = btype->u.basic.integer.alignment;
-				break;
-			case atype_string:
-				break;
-
-			case atype_array:
-			case atype_sequence:
-			default:
-				WARN_ON_ONCE(1);
-				break;
-			}
-			break;
-		}
-		case atype_sequence:
-		{
-			struct lttng_basic_type *btype;
-
-			btype = &type->u.sequence.length_type;
-			switch (btype->atype) {
-			case atype_integer:
-				field_align = btype->u.basic.integer.alignment;
-				break;
-
-			case atype_string:
-			case atype_array:
-			case atype_sequence:
-			default:
-				WARN_ON_ONCE(1);
-				break;
-			}
-
-			btype = &type->u.sequence.elem_type;
-			switch (btype->atype) {
-			case atype_integer:
-				field_align = max_t(size_t,
-					field_align,
-					btype->u.basic.integer.alignment);
-				break;
-
-			case atype_string:
-				break;
-
-			case atype_array:
-			case atype_sequence:
-			default:
-				WARN_ON_ONCE(1);
-				break;
-			}
-			break;
-		}
-		case atype_string:
-			break;
-		case atype_dynamic:
-			break;
-		case atype_enum:
-		default:
-			WARN_ON_ONCE(1);
-			break;
-		}
+		field_align = get_type_max_align(ctx->fields[i]->event_field->type);
 		largest_align = max_t(size_t, largest_align, field_align);
 	}
 	ctx->largest_align = largest_align >> 3;	/* bits to bytes */
@@ -263,28 +246,34 @@ void lttng_context_update(struct lttng_ctx *ctx)
 /*
  * Remove last context field.
  */
-void lttng_remove_context_field(struct lttng_ctx **ctx_p,
-				struct lttng_ctx_field *field)
+void lttng_remove_context_field(struct lttng_ust_ctx **ctx_p,
+				struct lttng_ust_ctx_field *field)
 {
-	struct lttng_ctx *ctx;
+	struct lttng_ust_ctx *ctx;
 
 	ctx = *ctx_p;
 	ctx->nr_fields--;
-	assert(&ctx->fields[ctx->nr_fields] == field);
-	assert(field->field_name == NULL);
-	memset(&ctx->fields[ctx->nr_fields], 0, sizeof(struct lttng_ctx_field));
+	assert(ctx->fields[ctx->nr_fields] == field);
+	lttng_ust_destroy_type(field->event_field->type);
+	free((char *) field->event_field->name);
+	free(field->event_field);
+	free(field);
+	ctx->fields[ctx->nr_fields] = NULL;
 }
 
-void lttng_destroy_context(struct lttng_ctx *ctx)
+void lttng_destroy_context(struct lttng_ust_ctx *ctx)
 {
 	int i;
 
 	if (!ctx)
 		return;
 	for (i = 0; i < ctx->nr_fields; i++) {
-		if (ctx->fields[i].destroy)
-			ctx->fields[i].destroy(&ctx->fields[i]);
-		free(ctx->fields[i].field_name);
+		if (ctx->fields[i]->destroy)
+			ctx->fields[i]->destroy(ctx->fields[i]);
+		lttng_ust_destroy_type(ctx->fields[i]->event_field->type);
+		free((char *) ctx->fields[i]->event_field->name);
+		free(ctx->fields[i]->event_field);
+		free(ctx->fields[i]);
 	}
 	free(ctx->fields);
 	free(ctx);
@@ -302,18 +291,18 @@ void lttng_destroy_context(struct lttng_ctx *ctx)
  * a single RCU read-side critical section see either all old, or all
  * new handlers.
  */
-int lttng_ust_context_set_provider_rcu(struct lttng_ctx **_ctx,
+int lttng_ust_context_set_provider_rcu(struct lttng_ust_ctx **_ctx,
 		const char *name,
-		size_t (*get_size)(struct lttng_ctx_field *field, size_t offset),
-		void (*record)(struct lttng_ctx_field *field,
+		size_t (*get_size)(struct lttng_ust_ctx_field *field, size_t offset),
+		void (*record)(struct lttng_ust_ctx_field *field,
 			struct lttng_ust_lib_ring_buffer_ctx *ctx,
 			struct lttng_channel *chan),
-		void (*get_value)(struct lttng_ctx_field *field,
-			struct lttng_ctx_value *value))
+		void (*get_value)(struct lttng_ust_ctx_field *field,
+			struct lttng_ust_ctx_value *value))
 {
 	int i, ret;
-	struct lttng_ctx *ctx = *_ctx, *new_ctx;
-	struct lttng_ctx_field *new_fields;
+	struct lttng_ust_ctx *ctx = *_ctx, *new_ctx;
+	struct lttng_ust_ctx_field **new_fields;
 
 	if (!ctx || !lttng_find_context_provider(ctx, name))
 		return 0;
@@ -323,25 +312,27 @@ int lttng_ust_context_set_provider_rcu(struct lttng_ctx **_ctx,
 	new_ctx = zmalloc(sizeof(*new_ctx));
 	if (!new_ctx)
 		return -ENOMEM;
+	new_ctx->struct_size = sizeof(*new_ctx);
 	*new_ctx = *ctx;
 	new_fields = zmalloc(sizeof(*new_fields) * ctx->allocated_fields);
 	if (!new_fields) {
 		ret = -ENOMEM;
 		goto field_error;
 	}
+	/* Copy pointers */
 	memcpy(new_fields, ctx->fields,
 		sizeof(*new_fields) * ctx->allocated_fields);
 	for (i = 0; i < ctx->nr_fields; i++) {
-		if (strncmp(new_fields[i].event_field.name,
+		if (strncmp(new_fields[i]->event_field->name,
 				name, strlen(name)) != 0)
 			continue;
-		new_fields[i].get_size = get_size;
-		new_fields[i].record = record;
-		new_fields[i].get_value = get_value;
+		new_fields[i]->get_size = get_size;
+		new_fields[i]->record = record;
+		new_fields[i]->get_value = get_value;
 	}
 	new_ctx->fields = new_fields;
-	rcu_assign_pointer(*_ctx, new_ctx);
-	synchronize_trace();
+	lttng_ust_rcu_assign_pointer(*_ctx, new_ctx);
+	lttng_ust_urcu_synchronize_rcu();
 	free(ctx->fields);
 	free(ctx);
 	return 0;
@@ -351,7 +342,7 @@ field_error:
 	return ret;
 }
 
-int lttng_session_context_init(struct lttng_ctx **ctx)
+int lttng_context_init_all(struct lttng_ust_ctx **ctx)
 {
 	int ret;
 
@@ -380,6 +371,76 @@ int lttng_session_context_init(struct lttng_ctx **ctx)
 		WARN("Cannot add context lttng_add_cpu_id_to_ctx");
 		goto error;
 	}
+	ret = lttng_add_cgroup_ns_to_ctx(ctx);
+	if (ret) {
+		WARN("Cannot add context lttng_add_cgroup_ns_to_ctx");
+		goto error;
+	}
+	ret = lttng_add_ipc_ns_to_ctx(ctx);
+	if (ret) {
+		WARN("Cannot add context lttng_add_ipc_ns_to_ctx");
+		goto error;
+	}
+	ret = lttng_add_mnt_ns_to_ctx(ctx);
+	if (ret) {
+		WARN("Cannot add context lttng_add_mnt_ns_to_ctx");
+		goto error;
+	}
+	ret = lttng_add_net_ns_to_ctx(ctx);
+	if (ret) {
+		WARN("Cannot add context lttng_add_net_ns_to_ctx");
+		goto error;
+	}
+	ret = lttng_add_pid_ns_to_ctx(ctx);
+	if (ret) {
+		WARN("Cannot add context lttng_add_pid_ns_to_ctx");
+		goto error;
+	}
+	ret = lttng_add_time_ns_to_ctx(ctx);
+	if (ret) {
+		WARN("Cannot add context lttng_add_time_ns_to_ctx");
+		goto error;
+	}
+	ret = lttng_add_user_ns_to_ctx(ctx);
+	if (ret) {
+		WARN("Cannot add context lttng_add_user_ns_to_ctx");
+		goto error;
+	}
+	ret = lttng_add_uts_ns_to_ctx(ctx);
+	if (ret) {
+		WARN("Cannot add context lttng_add_uts_ns_to_ctx");
+		goto error;
+	}
+	ret = lttng_add_vuid_to_ctx(ctx);
+	if (ret) {
+		WARN("Cannot add context lttng_add_vuid_to_ctx");
+		goto error;
+	}
+	ret = lttng_add_veuid_to_ctx(ctx);
+	if (ret) {
+		WARN("Cannot add context lttng_add_veuid_to_ctx");
+		goto error;
+	}
+	ret = lttng_add_vsuid_to_ctx(ctx);
+	if (ret) {
+		WARN("Cannot add context lttng_add_vsuid_to_ctx");
+		goto error;
+	}
+	ret = lttng_add_vgid_to_ctx(ctx);
+	if (ret) {
+		WARN("Cannot add context lttng_add_vgid_to_ctx");
+		goto error;
+	}
+	ret = lttng_add_vegid_to_ctx(ctx);
+	if (ret) {
+		WARN("Cannot add context lttng_add_vegid_to_ctx");
+		goto error;
+	}
+	ret = lttng_add_vsgid_to_ctx(ctx);
+	if (ret) {
+		WARN("Cannot add context lttng_add_vsgid_to_ctx");
+		goto error;
+	}
 	lttng_context_update(*ctx);
 	return 0;