[lttng-ust.git] / src / lib / lttng-ust / lttng-context.c

/*
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (C) 2011 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * LTTng UST trace/channel/event context management.
 */

#define _LGPL_SOURCE
#include <lttng/ust-events.h>
#include <lttng/ust-tracer.h>
#include <common/ust-context-provider.h>
#include <lttng/urcu/pointer.h>
#include <lttng/urcu/urcu-ust.h>
#include "common/logging.h"
#include "common/macros.h"
#include <stddef.h>
#include <string.h>
#include <assert.h>
#include <limits.h>
#include "common/tracepoint.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_ust_ctx *ctx, const char *name)
{
	unsigned int i;
	const char *subname;

	if (!ctx)
		return 0;
	if (strncmp(name, "$ctx.", strlen("$ctx.")) == 0) {
		subname = name + strlen("$ctx.");
	} else {
		subname = name;
	}
	for (i = 0; i < ctx->nr_fields; i++) {
		/* Skip allocated (but non-initialized) contexts */
		if (!ctx->fields[i].event_field->name)
			continue;
		if (!strcmp(ctx->fields[i].event_field->name, subname))
			return 1;
	}
	return 0;
}

int lttng_get_context_index(struct lttng_ust_ctx *ctx, const char *name)
{
	unsigned int i;
	const char *subname;

	if (!ctx)
		return -1;
	if (strncmp(name, "$ctx.", strlen("$ctx.")) == 0) {
		subname = name + strlen("$ctx.");
	} else {
		subname = name;
	}
	for (i = 0; i < ctx->nr_fields; i++) {
		/* Skip allocated (but non-initialized) contexts */
		if (!ctx->fields[i].event_field->name)
			continue;
		if (!strcmp(ctx->fields[i].event_field->name, subname))
			return i;
	}
	return -1;
}

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)
			continue;
		if (!strncmp(ctx->fields[i].event_field->name, name,
				strlen(name)))
			return 1;
	}
	return 0;
}

/*
 * Note: as we append context information, the pointer location may change.
 * lttng_ust_context_add_field leaves the new last context initialized to NULL.
 */
static
int lttng_ust_context_add_field(struct lttng_ust_ctx **ctx_p)
{
	struct lttng_ust_ctx *ctx;

	if (!*ctx_p) {
		*ctx_p = zmalloc(sizeof(struct lttng_ust_ctx));
		if (!*ctx_p)
			return -ENOMEM;
		(*ctx_p)->largest_align = 1;
	}
	ctx = *ctx_p;
	if (ctx->nr_fields + 1 > ctx->allocated_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(*new_fields));
		if (!new_fields)
			return -ENOMEM;
		/* Copy elements */
		if (ctx->fields)
			memcpy(new_fields, ctx->fields, sizeof(*ctx->fields) * ctx->nr_fields);
		free(ctx->fields);
		ctx->fields = new_fields;
	}
	ctx->nr_fields++;
	return 0;
}

static size_t get_type_max_align(const 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;
		const 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.
 */
static
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++) {
		size_t field_align = 8;

		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 */
}

int lttng_ust_context_append_rcu(struct lttng_ust_ctx **ctx_p,
		const struct lttng_ust_ctx_field *f)
{
	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_ust_ctx));
		if (!new_ctx)
			return -ENOMEM;
		*new_ctx = *old_ctx;
		new_fields = zmalloc(new_ctx->allocated_fields * sizeof(*new_fields));
		if (!new_fields) {
			free(new_ctx);
			return -ENOMEM;
		}
		/* Copy elements */
		memcpy(new_fields, old_ctx->fields,
				sizeof(*old_ctx->fields) * old_ctx->nr_fields);
		new_ctx->fields = new_fields;
	}
	ret = lttng_ust_context_add_field(&new_ctx);
	if (ret) {
		free(new_fields);
		free(new_ctx);
		return ret;
	}
	new_ctx->fields[new_ctx->nr_fields - 1] = *f;
	lttng_context_update(new_ctx);
	lttng_ust_rcu_assign_pointer(*ctx_p, new_ctx);
	lttng_ust_urcu_synchronize_rcu();
	if (old_ctx) {
		free(old_ctx->fields);
		free(old_ctx);
	}
	return 0;
}

int lttng_ust_context_append(struct lttng_ust_ctx **ctx_p,
		const struct lttng_ust_ctx_field *f)
{
	int ret;

	ret = lttng_ust_context_add_field(ctx_p);
	if (ret)
		return ret;
	(*ctx_p)->fields[(*ctx_p)->nr_fields - 1] = *f;
	lttng_context_update(*ctx_p);
	return 0;
}

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].priv);
	}
	free(ctx->fields);
	free(ctx);
}

/*
 * Can be safely performed concurrently with tracing using the struct
 * lttng_ctx. Using RCU update. Needs to match RCU read-side handling of
 * contexts.
 *
 * This does not allow adding, removing, or changing typing of the
 * contexts, since this needs to stay invariant for metadata. However,
 * it allows updating the handlers associated with all contexts matching
 * a provider (by name) while tracing is using it, in a way that ensures
 * a single RCU read-side critical section see either all old, or all
 * new handlers.
 */
int lttng_ust_context_set_provider_rcu(struct lttng_ust_ctx **_ctx,
		const char *name,
		size_t (*get_size)(void *priv, struct lttng_ust_probe_ctx *probe_ctx,
			size_t offset),
		void (*record)(void *priv, struct lttng_ust_probe_ctx *probe_ctx,
			struct lttng_ust_ring_buffer_ctx *ctx,
			struct lttng_ust_channel_buffer *chan),
		void (*get_value)(void *priv, struct lttng_ust_probe_ctx *probe_ctx,
			struct lttng_ust_ctx_value *value),
		void *priv)
{
	int i, ret;
	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;
	/*
	 * We have at least one instance of context for the provider.
	 */
	new_ctx = zmalloc(sizeof(*new_ctx));
	if (!new_ctx)
		return -ENOMEM;
	*new_ctx = *ctx;
	new_fields = zmalloc(sizeof(*new_fields) * ctx->allocated_fields);
	if (!new_fields) {
		ret = -ENOMEM;
		goto field_error;
	}
	/* Copy elements */
	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,
				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].priv = priv;
	}
	new_ctx->fields = new_fields;
	lttng_ust_rcu_assign_pointer(*_ctx, new_ctx);
	lttng_ust_urcu_synchronize_rcu();
	free(ctx->fields);
	free(ctx);
	return 0;

field_error:
	free(new_ctx);
	return ret;
}

int lttng_context_init_all(struct lttng_ust_ctx **ctx)
{
	int ret;

	ret = lttng_add_pthread_id_to_ctx(ctx);
	if (ret) {
		WARN("Cannot add context lttng_add_pthread_id_to_ctx");
		goto error;
	}
	ret = lttng_add_vtid_to_ctx(ctx);
	if (ret) {
		WARN("Cannot add context lttng_add_vtid_to_ctx");
		goto error;
	}
	ret = lttng_add_vpid_to_ctx(ctx);
	if (ret) {
		WARN("Cannot add context lttng_add_vpid_to_ctx");
		goto error;
	}
	ret = lttng_add_procname_to_ctx(ctx);
	if (ret) {
		WARN("Cannot add context lttng_add_procname_to_ctx");
		goto error;
	}
	ret = lttng_add_cpu_id_to_ctx(ctx);
	if (ret) {
		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;

error:
	lttng_destroy_context(*ctx);
	return ret;
}
Commit	Line	Data
8020ceb5	1	/*
c0c0989a	2	* SPDX-License-Identifier: LGPL-2.1-only
8020ceb5	3	*
e92f3e28 MD	4	* Copyright (C) 2011 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
e92f3e28 MD	5	*
c0c0989a	6	* LTTng UST trace/channel/event context management.
8020ceb5 MD	7	*/
8020ceb5 MD	8
3fbec7dc	9	#define _LGPL_SOURCE
4318ae1b MD	10	#include <lttng/ust-events.h>
4318ae1b MD	11	#include <lttng/ust-tracer.h>
9d315d6d	12	#include <common/ust-context-provider.h>
10544ee8	13	#include <lttng/urcu/pointer.h>
b653ddc1	14	#include <lttng/urcu/urcu-ust.h>
9d315d6d MJ	15	#include "common/logging.h"
9d315d6d MJ	16	#include "common/macros.h"
b4051ad8	17	#include <stddef.h>
8d8a24c8	18	#include <string.h>
8173ec7c	19	#include <assert.h>
9af5d97a	20	#include <limits.h>
8f51c684	21	#include "common/tracepoint.h"
8173ec7c	22
51f804ec FD	23	#include "context-internal.h"
51f804ec FD	24
77aa5901 MD	25	/*
	26	* The filter implementation requires that two consecutive "get" for the
	27	* same context performed by the same thread return the same result.
	28	*/
	29
daacdbfc	30	int lttng_find_context(struct lttng_ust_ctx ctx, const char name)
8173ec7c MD	31	{
8173ec7c MD	32	unsigned int i;
53569322	33	const char *subname;
8173ec7c	34
4e48b5d2 MD	35	if (!ctx)
4e48b5d2 MD	36	return 0;
53569322 MD	37	if (strncmp(name, "$ctx.", strlen("$ctx.")) == 0) {
	38	subname = name + strlen("$ctx.");
	39	} else {
	40	subname = name;
	41	}
8173ec7c MD	42	for (i = 0; i < ctx->nr_fields; i++) {
8173ec7c MD	43	/* Skip allocated (but non-initialized) contexts */
4e48b5d2	44	if (!ctx->fields[i].event_field->name)
8173ec7c	45	continue;
4e48b5d2	46	if (!strcmp(ctx->fields[i].event_field->name, subname))
8173ec7c MD	47	return 1;
	48	}
	49	return 0;
	50	}
8020ceb5	51
daacdbfc	52	int lttng_get_context_index(struct lttng_ust_ctx ctx, const char name)
77aa5901 MD	53	{
77aa5901 MD	54	unsigned int i;
53569322	55	const char *subname;
77aa5901 MD	56
	57	if (!ctx)
	58	return -1;
53569322 MD	59	if (strncmp(name, "$ctx.", strlen("$ctx.")) == 0) {
	60	subname = name + strlen("$ctx.");
	61	} else {
	62	subname = name;
	63	}
77aa5901 MD	64	for (i = 0; i < ctx->nr_fields; i++) {
77aa5901 MD	65	/* Skip allocated (but non-initialized) contexts */
4e48b5d2	66	if (!ctx->fields[i].event_field->name)
77aa5901	67	continue;
4e48b5d2	68	if (!strcmp(ctx->fields[i].event_field->name, subname))
77aa5901 MD	69	return i;
	70	}
	71	return -1;
	72	}
	73
daacdbfc	74	static int lttng_find_context_provider(struct lttng_ust_ctx ctx, const char name)
53569322 MD	75	{
	76	unsigned int i;
	77
	78	for (i = 0; i < ctx->nr_fields; i++) {
	79	/* Skip allocated (but non-initialized) contexts */
4e48b5d2	80	if (!ctx->fields[i].event_field->name)
53569322	81	continue;
4e48b5d2	82	if (!strncmp(ctx->fields[i].event_field->name, name,
53569322 MD	83	strlen(name)))
	84	return 1;
	85	}
	86	return 0;
	87	}
	88
a0a748b8 MD	89	/*
a0a748b8 MD	90	* Note: as we append context information, the pointer location may change.
4e48b5d2	91	* lttng_ust_context_add_field leaves the new last context initialized to NULL.
a0a748b8	92	*/
daacdbfc	93	static
4e48b5d2	94	int lttng_ust_context_add_field(struct lttng_ust_ctx **ctx_p)
8020ceb5	95	{
daacdbfc	96	struct lttng_ust_ctx *ctx;
8020ceb5 MD	97
8020ceb5 MD	98	if (!*ctx_p) {
daacdbfc	99	*ctx_p = zmalloc(sizeof(struct lttng_ust_ctx));
8020ceb5	100	if (!*ctx_p)
daacdbfc	101	return -ENOMEM;
b2cc986a	102	(*ctx_p)->largest_align = 1;
8020ceb5 MD	103	}
	104	ctx = *ctx_p;
	105	if (ctx->nr_fields + 1 > ctx->allocated_fields) {
4e48b5d2	106	struct lttng_ust_ctx_field *new_fields;
8020ceb5 MD	107
8020ceb5 MD	108	ctx->allocated_fields = max_t(size_t, 1, 2 * ctx->allocated_fields);
daacdbfc	109	new_fields = zmalloc(ctx->allocated_fields * sizeof(*new_fields));
8020ceb5	110	if (!new_fields)
daacdbfc	111	return -ENOMEM;
4e48b5d2	112	/* Copy elements */
8020ceb5 MD	113	if (ctx->fields)
8020ceb5 MD	114	memcpy(new_fields, ctx->fields, sizeof(ctx->fields) ctx->nr_fields);
8d8a24c8	115	free(ctx->fields);
8020ceb5 MD	116	ctx->fields = new_fields;
8020ceb5 MD	117	}
8020ceb5	118	ctx->nr_fields++;
daacdbfc MD	119	return 0;
	120	}
	121
4e48b5d2	122	static size_t get_type_max_align(const struct lttng_ust_type_common *type)
a084756d MD	123	{
	124	switch (type->type) {
	125	case lttng_ust_type_integer:
	126	return lttng_ust_get_type_integer(type)->alignment;
	127	case lttng_ust_type_string:
	128	return CHAR_BIT;
	129	case lttng_ust_type_dynamic:
	130	return 0;
	131	case lttng_ust_type_enum:
	132	return get_type_max_align(lttng_ust_get_type_enum(type)->container_type);
	133	case lttng_ust_type_array:
	134	return max_t(size_t, get_type_max_align(lttng_ust_get_type_array(type)->elem_type),
	135	lttng_ust_get_type_array(type)->alignment);
	136	case lttng_ust_type_sequence:
	137	return max_t(size_t, get_type_max_align(lttng_ust_get_type_sequence(type)->elem_type),
	138	lttng_ust_get_type_sequence(type)->alignment);
	139	case lttng_ust_type_struct:
	140	{
	141	unsigned int i;
	142	size_t field_align = 0;
4e48b5d2	143	const struct lttng_ust_type_struct *struct_type = lttng_ust_get_type_struct(type);
a084756d MD	144
	145	for (i = 0; i < struct_type->nr_fields; i++) {
	146	field_align = max_t(size_t,
	147	get_type_max_align(struct_type->fields[i]->type),
	148	field_align);
	149	}
	150	return field_align;
	151	}
	152	default:
	153	WARN_ON_ONCE(1);
	154	return 0;
	155	}
	156	}
	157
b2cc986a MD	158	/*
	159	* lttng_context_update() should be called at least once between context
	160	* modification and trace start.
	161	*/
4e48b5d2	162	static
daacdbfc	163	void lttng_context_update(struct lttng_ust_ctx *ctx)
b2cc986a MD	164	{
	165	int i;
	166	size_t largest_align = 8; /* in bits */
	167
	168	for (i = 0; i < ctx->nr_fields; i++) {
b2cc986a MD	169	size_t field_align = 8;
b2cc986a MD	170
4e48b5d2	171	field_align = get_type_max_align(ctx->fields[i].event_field->type);
b2cc986a MD	172	largest_align = max_t(size_t, largest_align, field_align);
	173	}
	174	ctx->largest_align = largest_align >> 3; /* bits to bytes */
	175	}
	176
4e48b5d2 MD	177	int lttng_ust_context_append_rcu(struct lttng_ust_ctx **ctx_p,
4e48b5d2 MD	178	const struct lttng_ust_ctx_field *f)
8020ceb5	179	{
4e48b5d2 MD	180	struct lttng_ust_ctx old_ctx = ctx_p, *new_ctx = NULL;
	181	struct lttng_ust_ctx_field *new_fields = NULL;
	182	int ret;
8020ceb5	183
4e48b5d2 MD	184	if (old_ctx) {
	185	new_ctx = zmalloc(sizeof(struct lttng_ust_ctx));
	186	if (!new_ctx)
	187	return -ENOMEM;
	188	new_ctx = old_ctx;
	189	new_fields = zmalloc(new_ctx->allocated_fields * sizeof(*new_fields));
	190	if (!new_fields) {
	191	free(new_ctx);
	192	return -ENOMEM;
	193	}
	194	/* Copy elements */
	195	memcpy(new_fields, old_ctx->fields,
	196	sizeof(old_ctx->fields) old_ctx->nr_fields);
	197	new_ctx->fields = new_fields;
	198	}
	199	ret = lttng_ust_context_add_field(&new_ctx);
	200	if (ret) {
	201	free(new_fields);
	202	free(new_ctx);
	203	return ret;
	204	}
4e48b5d2 MD	205	new_ctx->fields[new_ctx->nr_fields - 1] = *f;
	206	lttng_context_update(new_ctx);
	207	lttng_ust_rcu_assign_pointer(*ctx_p, new_ctx);
	208	lttng_ust_urcu_synchronize_rcu();
	209	if (old_ctx) {
	210	free(old_ctx->fields);
	211	free(old_ctx);
	212	}
	213	return 0;
	214	}
	215
	216	int lttng_ust_context_append(struct lttng_ust_ctx **ctx_p,
	217	const struct lttng_ust_ctx_field *f)
	218	{
	219	int ret;
	220
	221	ret = lttng_ust_context_add_field(ctx_p);
	222	if (ret)
	223	return ret;
	224	(ctx_p)->fields[(ctx_p)->nr_fields - 1] = *f;
	225	lttng_context_update(*ctx_p);
	226	return 0;
8020ceb5	227	}
8020ceb5	228
daacdbfc	229	void lttng_destroy_context(struct lttng_ust_ctx *ctx)
8020ceb5 MD	230	{
	231	int i;
	232
	233	if (!ctx)
	234	return;
	235	for (i = 0; i < ctx->nr_fields; i++) {
4e48b5d2	236	if (ctx->fields[i].destroy)
6ba6fd60	237	ctx->fields[i].destroy(ctx->fields[i].priv);
8020ceb5	238	}
8d8a24c8 MD	239	free(ctx->fields);
8d8a24c8 MD	240	free(ctx);
8020ceb5	241	}
a0a3bef9	242
53569322 MD	243	/*
	244	* Can be safely performed concurrently with tracing using the struct
	245	* lttng_ctx. Using RCU update. Needs to match RCU read-side handling of
	246	* contexts.
	247	*
	248	* This does not allow adding, removing, or changing typing of the
	249	* contexts, since this needs to stay invariant for metadata. However,
	250	* it allows updating the handlers associated with all contexts matching
	251	* a provider (by name) while tracing is using it, in a way that ensures
	252	* a single RCU read-side critical section see either all old, or all
	253	* new handlers.
	254	*/
daacdbfc	255	int lttng_ust_context_set_provider_rcu(struct lttng_ust_ctx **_ctx,
53569322	256	const char *name,
b2e37d27 MD	257	size_t (get_size)(void priv, struct lttng_ust_probe_ctx *probe_ctx,
	258	size_t offset),
	259	void (record)(void priv, struct lttng_ust_probe_ctx *probe_ctx,
	260	struct lttng_ust_ring_buffer_ctx *ctx,
e7bc0ef6	261	struct lttng_ust_channel_buffer *chan),
b2e37d27 MD	262	void (get_value)(void priv, struct lttng_ust_probe_ctx *probe_ctx,
b2e37d27 MD	263	struct lttng_ust_ctx_value *value),
4e48b5d2	264	void *priv)
53569322 MD	265	{
53569322 MD	266	int i, ret;
daacdbfc	267	struct lttng_ust_ctx ctx = _ctx, *new_ctx;
4e48b5d2	268	struct lttng_ust_ctx_field *new_fields;
53569322 MD	269
	270	if (!ctx \|\| !lttng_find_context_provider(ctx, name))
	271	return 0;
	272	/*
	273	* We have at least one instance of context for the provider.
	274	*/
	275	new_ctx = zmalloc(sizeof(*new_ctx));
	276	if (!new_ctx)
	277	return -ENOMEM;
	278	new_ctx = ctx;
	279	new_fields = zmalloc(sizeof(new_fields) ctx->allocated_fields);
	280	if (!new_fields) {
	281	ret = -ENOMEM;
	282	goto field_error;
	283	}
4e48b5d2	284	/* Copy elements */
53569322 MD	285	memcpy(new_fields, ctx->fields,
	286	sizeof(new_fields) ctx->allocated_fields);
	287	for (i = 0; i < ctx->nr_fields; i++) {
4e48b5d2	288	if (strncmp(new_fields[i].event_field->name,
53569322 MD	289	name, strlen(name)) != 0)
53569322 MD	290	continue;
4e48b5d2 MD	291	new_fields[i].get_size = get_size;
	292	new_fields[i].record = record;
	293	new_fields[i].get_value = get_value;
	294	new_fields[i].priv = priv;
53569322 MD	295	}
53569322 MD	296	new_ctx->fields = new_fields;
10544ee8	297	lttng_ust_rcu_assign_pointer(*_ctx, new_ctx);
b653ddc1	298	lttng_ust_urcu_synchronize_rcu();
53569322 MD	299	free(ctx->fields);
	300	free(ctx);
	301	return 0;
	302
	303	field_error:
	304	free(new_ctx);
	305	return ret;
	306	}
	307
daacdbfc	308	int lttng_context_init_all(struct lttng_ust_ctx **ctx)
a0a3bef9 MD	309	{
	310	int ret;
	311
53569322	312	ret = lttng_add_pthread_id_to_ctx(ctx);
a0a3bef9 MD	313	if (ret) {
a0a3bef9 MD	314	WARN("Cannot add context lttng_add_pthread_id_to_ctx");
53569322	315	goto error;
a0a3bef9	316	}
53569322	317	ret = lttng_add_vtid_to_ctx(ctx);
a0a3bef9 MD	318	if (ret) {
a0a3bef9 MD	319	WARN("Cannot add context lttng_add_vtid_to_ctx");
53569322	320	goto error;
a0a3bef9	321	}
53569322	322	ret = lttng_add_vpid_to_ctx(ctx);
a0a3bef9 MD	323	if (ret) {
a0a3bef9 MD	324	WARN("Cannot add context lttng_add_vpid_to_ctx");
53569322	325	goto error;
a0a3bef9	326	}
53569322	327	ret = lttng_add_procname_to_ctx(ctx);
a0a3bef9 MD	328	if (ret) {
a0a3bef9 MD	329	WARN("Cannot add context lttng_add_procname_to_ctx");
53569322	330	goto error;
a0a3bef9	331	}
53569322	332	ret = lttng_add_cpu_id_to_ctx(ctx);
c7ea8487 MD	333	if (ret) {
c7ea8487 MD	334	WARN("Cannot add context lttng_add_cpu_id_to_ctx");
53569322	335	goto error;
c7ea8487	336	}
735bef47 MJ	337	ret = lttng_add_cgroup_ns_to_ctx(ctx);
	338	if (ret) {
	339	WARN("Cannot add context lttng_add_cgroup_ns_to_ctx");
	340	goto error;
	341	}
	342	ret = lttng_add_ipc_ns_to_ctx(ctx);
	343	if (ret) {
	344	WARN("Cannot add context lttng_add_ipc_ns_to_ctx");
	345	goto error;
	346	}
	347	ret = lttng_add_mnt_ns_to_ctx(ctx);
	348	if (ret) {
	349	WARN("Cannot add context lttng_add_mnt_ns_to_ctx");
	350	goto error;
	351	}
	352	ret = lttng_add_net_ns_to_ctx(ctx);
	353	if (ret) {
	354	WARN("Cannot add context lttng_add_net_ns_to_ctx");
	355	goto error;
	356	}
	357	ret = lttng_add_pid_ns_to_ctx(ctx);
	358	if (ret) {
	359	WARN("Cannot add context lttng_add_pid_ns_to_ctx");
	360	goto error;
	361	}
cefef7a7 MJ	362	ret = lttng_add_time_ns_to_ctx(ctx);
	363	if (ret) {
	364	WARN("Cannot add context lttng_add_time_ns_to_ctx");
	365	goto error;
	366	}
735bef47 MJ	367	ret = lttng_add_user_ns_to_ctx(ctx);
	368	if (ret) {
	369	WARN("Cannot add context lttng_add_user_ns_to_ctx");
	370	goto error;
	371	}
	372	ret = lttng_add_uts_ns_to_ctx(ctx);
	373	if (ret) {
	374	WARN("Cannot add context lttng_add_uts_ns_to_ctx");
	375	goto error;
	376	}
fca2f191 MJ	377	ret = lttng_add_vuid_to_ctx(ctx);
	378	if (ret) {
	379	WARN("Cannot add context lttng_add_vuid_to_ctx");
	380	goto error;
	381	}
	382	ret = lttng_add_veuid_to_ctx(ctx);
	383	if (ret) {
	384	WARN("Cannot add context lttng_add_veuid_to_ctx");
	385	goto error;
	386	}
	387	ret = lttng_add_vsuid_to_ctx(ctx);
	388	if (ret) {
	389	WARN("Cannot add context lttng_add_vsuid_to_ctx");
	390	goto error;
	391	}
	392	ret = lttng_add_vgid_to_ctx(ctx);
	393	if (ret) {
	394	WARN("Cannot add context lttng_add_vgid_to_ctx");
	395	goto error;
	396	}
	397	ret = lttng_add_vegid_to_ctx(ctx);
	398	if (ret) {
	399	WARN("Cannot add context lttng_add_vegid_to_ctx");
	400	goto error;
	401	}
	402	ret = lttng_add_vsgid_to_ctx(ctx);
	403	if (ret) {
	404	WARN("Cannot add context lttng_add_vsgid_to_ctx");
	405	goto error;
	406	}
53569322 MD	407	lttng_context_update(*ctx);
53569322 MD	408	return 0;
a0a3bef9	409
53569322 MD	410	error:
	411	lttng_destroy_context(*ctx);
	412	return ret;
a0a3bef9	413	}