[lttng-tools.git] / src / bin / lttng-sessiond / tracker.cpp

/*
 * Copyright (C) 2018 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 * Copyright (C) 2020 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * SPDX-License-Identifier: GPL-2.0-only
 *
 */

#include "common/dynamic-array.hpp"
#include "common/macros.hpp"
#include "lttng/tracker.h"
#define _LGPL_SOURCE
#include "tracker.hpp"

#include <common/defaults.hpp>
#include <common/error.hpp>
#include <common/hashtable/hashtable.hpp>
#include <common/hashtable/utils.hpp>
#include <common/tracker.hpp>

#include <lttng/lttng-error.h>

#include <grp.h>
#include <pwd.h>
#include <sys/types.h>
#include <unistd.h>
#include <urcu.h>
#include <urcu/list.h>
#include <urcu/rculfhash.h>

struct process_attr_tracker {
	enum lttng_tracking_policy policy;
	struct cds_lfht *inclusion_set_ht;
};

namespace {
struct process_attr_tracker_value_node {
	struct process_attr_value *value;
	struct cds_lfht_node inclusion_set_ht_node;
	struct rcu_head rcu_head;
};
} /* namespace */

static void process_attr_tracker_value_node_rcu_free(struct rcu_head *rcu_head)
{
	struct process_attr_tracker_value_node *node =
		lttng::utils::container_of(rcu_head, &process_attr_tracker_value_node::rcu_head);

	free(node);
}

struct process_attr_tracker *process_attr_tracker_create()
{
	struct process_attr_tracker *tracker;

	tracker = zmalloc<process_attr_tracker>();
	if (!tracker) {
		return nullptr;
	}

	(void) process_attr_tracker_set_tracking_policy(tracker, LTTNG_TRACKING_POLICY_INCLUDE_ALL);

	tracker->inclusion_set_ht = cds_lfht_new(
		DEFAULT_HT_SIZE, 1, 0, CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, nullptr);
	if (!tracker->inclusion_set_ht) {
		goto error;
	}

	return tracker;
error:
	process_attr_tracker_destroy(tracker);
	return nullptr;
}

static void
process_attr_tracker_remove_value_node(struct process_attr_tracker *tracker,
				       struct process_attr_tracker_value_node *value_node)
{
	cds_lfht_del(tracker->inclusion_set_ht, &value_node->inclusion_set_ht_node);
	process_attr_value_destroy(value_node->value);
	call_rcu(&value_node->rcu_head, process_attr_tracker_value_node_rcu_free);
}

static void process_attr_tracker_clear_inclusion_set(struct process_attr_tracker *tracker)
{
	int ret;
	struct lttng_ht_iter iter;
	struct process_attr_tracker_value_node *value_node;

	if (!tracker->inclusion_set_ht) {
		return;
	}

	rcu_read_lock();
	cds_lfht_for_each_entry (
		tracker->inclusion_set_ht, &iter.iter, value_node, inclusion_set_ht_node) {
		process_attr_tracker_remove_value_node(tracker, value_node);
	}
	rcu_read_unlock();
	ret = cds_lfht_destroy(tracker->inclusion_set_ht, nullptr);
	LTTNG_ASSERT(ret == 0);
	tracker->inclusion_set_ht = nullptr;
}

static int process_attr_tracker_create_inclusion_set(struct process_attr_tracker *tracker)
{
	LTTNG_ASSERT(!tracker->inclusion_set_ht);
	tracker->inclusion_set_ht = cds_lfht_new(
		DEFAULT_HT_SIZE, 1, 0, CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, nullptr);
	return tracker->inclusion_set_ht ? 0 : -1;
}

void process_attr_tracker_destroy(struct process_attr_tracker *tracker)
{
	if (!tracker) {
		return;
	}

	process_attr_tracker_clear_inclusion_set(tracker);
	free(tracker);
}

enum lttng_tracking_policy
process_attr_tracker_get_tracking_policy(const struct process_attr_tracker *tracker)
{
	return tracker->policy;
}

int process_attr_tracker_set_tracking_policy(struct process_attr_tracker *tracker,
					     enum lttng_tracking_policy tracking_policy)
{
	int ret = 0;

	if (tracker->policy == tracking_policy) {
		goto end;
	}

	process_attr_tracker_clear_inclusion_set(tracker);
	ret = process_attr_tracker_create_inclusion_set(tracker);
	if (ret) {
		goto end;
	}
	tracker->policy = tracking_policy;
end:
	return ret;
}

static int match_inclusion_set_value(struct cds_lfht_node *node, const void *key)
{
	const struct process_attr_value *value_key = (process_attr_value *) key;
	const struct process_attr_tracker_value_node *value_node = caa_container_of(
		node, struct process_attr_tracker_value_node, inclusion_set_ht_node);

	return process_attr_tracker_value_equal(value_node->value, value_key);
}

static struct process_attr_tracker_value_node *
process_attr_tracker_lookup(const struct process_attr_tracker *tracker,
			    const struct process_attr_value *value)
{
	struct cds_lfht_iter iter;
	struct cds_lfht_node *node;

	LTTNG_ASSERT(tracker->policy == LTTNG_TRACKING_POLICY_INCLUDE_SET);

	rcu_read_lock();
	cds_lfht_lookup(tracker->inclusion_set_ht,
			process_attr_value_hash(value),
			match_inclusion_set_value,
			value,
			&iter);
	node = cds_lfht_iter_get_node(&iter);
	rcu_read_unlock();

	return node ? lttng::utils::container_of(
			      node, &process_attr_tracker_value_node::inclusion_set_ht_node) :
		      nullptr;
}

/* Protected by session mutex held by caller. */
enum process_attr_tracker_status
process_attr_tracker_inclusion_set_add_value(struct process_attr_tracker *tracker,
					     const struct process_attr_value *value)
{
	enum process_attr_tracker_status status = PROCESS_ATTR_TRACKER_STATUS_OK;
	struct process_attr_value *value_copy = nullptr;
	struct process_attr_tracker_value_node *value_node = nullptr;

	rcu_read_lock();
	if (tracker->policy != LTTNG_TRACKING_POLICY_INCLUDE_SET) {
		status = PROCESS_ATTR_TRACKER_STATUS_INVALID_TRACKING_POLICY;
		goto end;
	}

	if (process_attr_tracker_lookup(tracker, value)) {
		status = PROCESS_ATTR_TRACKER_STATUS_EXISTS;
		goto end;
	}

	value_node = zmalloc<process_attr_tracker_value_node>();
	if (!value_node) {
		status = PROCESS_ATTR_TRACKER_STATUS_ERROR;
		goto end;
	}

	value_copy = process_attr_value_copy(value);
	if (!value_copy) {
		status = PROCESS_ATTR_TRACKER_STATUS_ERROR;
		goto end;
	}

	value_node->value = value_copy;
	cds_lfht_add(tracker->inclusion_set_ht,
		     process_attr_value_hash(value_copy),
		     &value_node->inclusion_set_ht_node);
	value_copy = nullptr;
	value_node = nullptr;
end:
	if (value_copy) {
		process_attr_value_destroy(value_copy);
	}
	if (value_node) {
		free(value_node);
	}
	rcu_read_unlock();
	return status;
}

/* Protected by session mutex held by caller. */
enum process_attr_tracker_status
process_attr_tracker_inclusion_set_remove_value(struct process_attr_tracker *tracker,
						const struct process_attr_value *value)
{
	struct process_attr_tracker_value_node *value_node;
	enum process_attr_tracker_status status = PROCESS_ATTR_TRACKER_STATUS_OK;

	rcu_read_lock();
	if (tracker->policy != LTTNG_TRACKING_POLICY_INCLUDE_SET) {
		status = PROCESS_ATTR_TRACKER_STATUS_INVALID_TRACKING_POLICY;
		goto end;
	}

	value_node = process_attr_tracker_lookup(tracker, value);
	if (!value_node) {
		status = PROCESS_ATTR_TRACKER_STATUS_MISSING;
		goto end;
	}

	process_attr_tracker_remove_value_node(tracker, value_node);
end:
	rcu_read_unlock();
	return status;
}

enum process_attr_tracker_status
process_attr_tracker_get_inclusion_set(const struct process_attr_tracker *tracker,
				       struct lttng_process_attr_values **_values)
{
	struct lttng_ht_iter iter;
	struct process_attr_tracker_value_node *value_node;
	enum process_attr_tracker_status status = PROCESS_ATTR_TRACKER_STATUS_OK;
	struct lttng_process_attr_values *values;
	struct process_attr_value *new_value = nullptr;

	values = lttng_process_attr_values_create();
	if (!values) {
		status = PROCESS_ATTR_TRACKER_STATUS_ERROR;
		goto error;
	}

	if (tracker->policy != LTTNG_TRACKING_POLICY_INCLUDE_SET) {
		status = PROCESS_ATTR_TRACKER_STATUS_INVALID_TRACKING_POLICY;
		goto error;
	}

	rcu_read_lock();
	cds_lfht_for_each_entry (
		tracker->inclusion_set_ht, &iter.iter, value_node, inclusion_set_ht_node) {
		int ret;

		new_value = process_attr_value_copy(value_node->value);
		if (!new_value) {
			status = PROCESS_ATTR_TRACKER_STATUS_ERROR;
			goto error_unlock;
		}

		ret = lttng_dynamic_pointer_array_add_pointer(&values->array, new_value);
		if (ret) {
			status = PROCESS_ATTR_TRACKER_STATUS_ERROR;
			goto error_unlock;
		}

		new_value = nullptr;
	}
	rcu_read_unlock();
	*_values = values;
	return status;
error_unlock:
	rcu_read_unlock();
error:
	lttng_process_attr_values_destroy(values);
	process_attr_value_destroy(new_value);
	return status;
}
Commit	Line	Data
	1	/*
	2	* Copyright (C) 2018 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	3	* Copyright (C) 2020 Jérémie Galarneau <jeremie.galarneau@efficios.com>
	4	*
	5	* SPDX-License-Identifier: GPL-2.0-only
	6	*
	7	*/
	8
	9	#include "common/dynamic-array.hpp"
	10	#include "common/macros.hpp"
	11	#include "lttng/tracker.h"
	12	#define _LGPL_SOURCE
	13	#include "tracker.hpp"
	14
	15	#include <common/defaults.hpp>
	16	#include <common/error.hpp>
	17	#include <common/hashtable/hashtable.hpp>
	18	#include <common/hashtable/utils.hpp>
	19	#include <common/tracker.hpp>
	20
	21	#include <lttng/lttng-error.h>
	22
	23	#include <grp.h>
	24	#include <pwd.h>
	25	#include <sys/types.h>
	26	#include <unistd.h>
	27	#include <urcu.h>
	28	#include <urcu/list.h>
	29	#include <urcu/rculfhash.h>
	30
	31	struct process_attr_tracker {
	32	enum lttng_tracking_policy policy;
	33	struct cds_lfht *inclusion_set_ht;
	34	};
	35
	36	namespace {
	37	struct process_attr_tracker_value_node {
	38	struct process_attr_value *value;
	39	struct cds_lfht_node inclusion_set_ht_node;
	40	struct rcu_head rcu_head;
	41	};
	42	} /* namespace */
	43
	44	static void process_attr_tracker_value_node_rcu_free(struct rcu_head *rcu_head)
	45	{
	46	struct process_attr_tracker_value_node *node =
	47	lttng::utils::container_of(rcu_head, &process_attr_tracker_value_node::rcu_head);
	48
	49	free(node);
	50	}
	51
	52	struct process_attr_tracker *process_attr_tracker_create()
	53	{
	54	struct process_attr_tracker *tracker;
	55
	56	tracker = zmalloc<process_attr_tracker>();
	57	if (!tracker) {
	58	return nullptr;
	59	}
	60
	61	(void) process_attr_tracker_set_tracking_policy(tracker, LTTNG_TRACKING_POLICY_INCLUDE_ALL);
	62
	63	tracker->inclusion_set_ht = cds_lfht_new(
	64	DEFAULT_HT_SIZE, 1, 0, CDS_LFHT_AUTO_RESIZE \| CDS_LFHT_ACCOUNTING, nullptr);
	65	if (!tracker->inclusion_set_ht) {
	66	goto error;
	67	}
	68
	69	return tracker;
	70	error:
	71	process_attr_tracker_destroy(tracker);
	72	return nullptr;
	73	}
	74
	75	static void
	76	process_attr_tracker_remove_value_node(struct process_attr_tracker *tracker,
	77	struct process_attr_tracker_value_node *value_node)
	78	{
	79	cds_lfht_del(tracker->inclusion_set_ht, &value_node->inclusion_set_ht_node);
	80	process_attr_value_destroy(value_node->value);
	81	call_rcu(&value_node->rcu_head, process_attr_tracker_value_node_rcu_free);
	82	}
	83
	84	static void process_attr_tracker_clear_inclusion_set(struct process_attr_tracker *tracker)
	85	{
	86	int ret;
	87	struct lttng_ht_iter iter;
	88	struct process_attr_tracker_value_node *value_node;
	89
	90	if (!tracker->inclusion_set_ht) {
	91	return;
	92	}
	93
	94	rcu_read_lock();
	95	cds_lfht_for_each_entry (
	96	tracker->inclusion_set_ht, &iter.iter, value_node, inclusion_set_ht_node) {
	97	process_attr_tracker_remove_value_node(tracker, value_node);
	98	}
	99	rcu_read_unlock();
	100	ret = cds_lfht_destroy(tracker->inclusion_set_ht, nullptr);
	101	LTTNG_ASSERT(ret == 0);
	102	tracker->inclusion_set_ht = nullptr;
	103	}
	104
	105	static int process_attr_tracker_create_inclusion_set(struct process_attr_tracker *tracker)
	106	{
	107	LTTNG_ASSERT(!tracker->inclusion_set_ht);
	108	tracker->inclusion_set_ht = cds_lfht_new(
	109	DEFAULT_HT_SIZE, 1, 0, CDS_LFHT_AUTO_RESIZE \| CDS_LFHT_ACCOUNTING, nullptr);
	110	return tracker->inclusion_set_ht ? 0 : -1;
	111	}
	112
	113	void process_attr_tracker_destroy(struct process_attr_tracker *tracker)
	114	{
	115	if (!tracker) {
	116	return;
	117	}
	118
	119	process_attr_tracker_clear_inclusion_set(tracker);
	120	free(tracker);
	121	}
	122
	123	enum lttng_tracking_policy
	124	process_attr_tracker_get_tracking_policy(const struct process_attr_tracker *tracker)
	125	{
	126	return tracker->policy;
	127	}
	128
	129	int process_attr_tracker_set_tracking_policy(struct process_attr_tracker *tracker,
	130	enum lttng_tracking_policy tracking_policy)
	131	{
	132	int ret = 0;
	133
	134	if (tracker->policy == tracking_policy) {
	135	goto end;
	136	}
	137
	138	process_attr_tracker_clear_inclusion_set(tracker);
	139	ret = process_attr_tracker_create_inclusion_set(tracker);
	140	if (ret) {
	141	goto end;
	142	}
	143	tracker->policy = tracking_policy;
	144	end:
	145	return ret;
	146	}
	147
	148	static int match_inclusion_set_value(struct cds_lfht_node node, const void key)
	149	{
	150	const struct process_attr_value value_key = (process_attr_value ) key;
	151	const struct process_attr_tracker_value_node *value_node = caa_container_of(
	152	node, struct process_attr_tracker_value_node, inclusion_set_ht_node);
	153
	154	return process_attr_tracker_value_equal(value_node->value, value_key);
	155	}
	156
	157	static struct process_attr_tracker_value_node *
	158	process_attr_tracker_lookup(const struct process_attr_tracker *tracker,
	159	const struct process_attr_value *value)
	160	{
	161	struct cds_lfht_iter iter;
	162	struct cds_lfht_node *node;
	163
	164	LTTNG_ASSERT(tracker->policy == LTTNG_TRACKING_POLICY_INCLUDE_SET);
	165
	166	rcu_read_lock();
	167	cds_lfht_lookup(tracker->inclusion_set_ht,
	168	process_attr_value_hash(value),
	169	match_inclusion_set_value,
	170	value,
	171	&iter);
	172	node = cds_lfht_iter_get_node(&iter);
	173	rcu_read_unlock();
	174
	175	return node ? lttng::utils::container_of(
	176	node, &process_attr_tracker_value_node::inclusion_set_ht_node) :
	177	nullptr;
	178	}
	179
	180	/* Protected by session mutex held by caller. */
	181	enum process_attr_tracker_status
	182	process_attr_tracker_inclusion_set_add_value(struct process_attr_tracker *tracker,
	183	const struct process_attr_value *value)
	184	{
	185	enum process_attr_tracker_status status = PROCESS_ATTR_TRACKER_STATUS_OK;
	186	struct process_attr_value *value_copy = nullptr;
	187	struct process_attr_tracker_value_node *value_node = nullptr;
	188
	189	rcu_read_lock();
	190	if (tracker->policy != LTTNG_TRACKING_POLICY_INCLUDE_SET) {
	191	status = PROCESS_ATTR_TRACKER_STATUS_INVALID_TRACKING_POLICY;
	192	goto end;
	193	}
	194
	195	if (process_attr_tracker_lookup(tracker, value)) {
	196	status = PROCESS_ATTR_TRACKER_STATUS_EXISTS;
	197	goto end;
	198	}
	199
	200	value_node = zmalloc<process_attr_tracker_value_node>();
	201	if (!value_node) {
	202	status = PROCESS_ATTR_TRACKER_STATUS_ERROR;
	203	goto end;
	204	}
	205
	206	value_copy = process_attr_value_copy(value);
	207	if (!value_copy) {
	208	status = PROCESS_ATTR_TRACKER_STATUS_ERROR;
	209	goto end;
	210	}
	211
	212	value_node->value = value_copy;
	213	cds_lfht_add(tracker->inclusion_set_ht,
	214	process_attr_value_hash(value_copy),
	215	&value_node->inclusion_set_ht_node);
	216	value_copy = nullptr;
	217	value_node = nullptr;
	218	end:
	219	if (value_copy) {
	220	process_attr_value_destroy(value_copy);
	221	}
	222	if (value_node) {
	223	free(value_node);
	224	}
	225	rcu_read_unlock();
	226	return status;
	227	}
	228
	229	/* Protected by session mutex held by caller. */
	230	enum process_attr_tracker_status
	231	process_attr_tracker_inclusion_set_remove_value(struct process_attr_tracker *tracker,
	232	const struct process_attr_value *value)
	233	{
	234	struct process_attr_tracker_value_node *value_node;
	235	enum process_attr_tracker_status status = PROCESS_ATTR_TRACKER_STATUS_OK;
	236
	237	rcu_read_lock();
	238	if (tracker->policy != LTTNG_TRACKING_POLICY_INCLUDE_SET) {
	239	status = PROCESS_ATTR_TRACKER_STATUS_INVALID_TRACKING_POLICY;
	240	goto end;
	241	}
	242
	243	value_node = process_attr_tracker_lookup(tracker, value);
	244	if (!value_node) {
	245	status = PROCESS_ATTR_TRACKER_STATUS_MISSING;
	246	goto end;
	247	}
	248
	249	process_attr_tracker_remove_value_node(tracker, value_node);
	250	end:
	251	rcu_read_unlock();
	252	return status;
	253	}
	254
	255	enum process_attr_tracker_status
	256	process_attr_tracker_get_inclusion_set(const struct process_attr_tracker *tracker,
	257	struct lttng_process_attr_values **_values)
	258	{
	259	struct lttng_ht_iter iter;
	260	struct process_attr_tracker_value_node *value_node;
	261	enum process_attr_tracker_status status = PROCESS_ATTR_TRACKER_STATUS_OK;
	262	struct lttng_process_attr_values *values;
	263	struct process_attr_value *new_value = nullptr;
	264
	265	values = lttng_process_attr_values_create();
	266	if (!values) {
	267	status = PROCESS_ATTR_TRACKER_STATUS_ERROR;
	268	goto error;
	269	}
	270
	271	if (tracker->policy != LTTNG_TRACKING_POLICY_INCLUDE_SET) {
	272	status = PROCESS_ATTR_TRACKER_STATUS_INVALID_TRACKING_POLICY;
	273	goto error;
	274	}
	275
	276	rcu_read_lock();
	277	cds_lfht_for_each_entry (
	278	tracker->inclusion_set_ht, &iter.iter, value_node, inclusion_set_ht_node) {
	279	int ret;
	280
	281	new_value = process_attr_value_copy(value_node->value);
	282	if (!new_value) {
	283	status = PROCESS_ATTR_TRACKER_STATUS_ERROR;
	284	goto error_unlock;
	285	}
	286
	287	ret = lttng_dynamic_pointer_array_add_pointer(&values->array, new_value);
	288	if (ret) {
	289	status = PROCESS_ATTR_TRACKER_STATUS_ERROR;
	290	goto error_unlock;
	291	}
	292
	293	new_value = nullptr;
	294	}
	295	rcu_read_unlock();
	296	*_values = values;
	297	return status;
	298	error_unlock:
	299	rcu_read_unlock();
	300	error:
	301	lttng_process_attr_values_destroy(values);
	302	process_attr_value_destroy(new_value);
	303	return status;
	304	}