[lttng-tools.git] / src / common / tracker.cpp

/*
 * Copyright (C) 2019 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
 * Copyright (C) 2020 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 */

#include <lttng/domain.h>
#include <lttng/lttng-error.h>
#include <lttng/tracker.h>

#include <common/dynamic-array.hpp>
#include <common/error.hpp>
#include <common/hashtable/hashtable.hpp>
#include <common/hashtable/utils.hpp>
#include <common/tracker.hpp>

#include <stdbool.h>

#include <type_traits>

namespace {
struct process_attr_tracker_values_comm_header {
	uint32_t count;
} LTTNG_PACKED;

struct process_attr_tracker_value_comm {
	/* enum lttng_process_attr_value_type */
	int32_t type;
	union {
		struct process_attr_integral_value_comm integral;
		/* Includes the '\0' terminator. */
		uint32_t name_len;
	} value;
} LTTNG_PACKED;
} /* namespace */

#define GET_INTEGRAL_COMM_VALUE(value_ptr, as_type)              \
	((as_type)(std::is_signed<as_type>::value ? (value_ptr)->u._signed : \
					(value_ptr)->u._unsigned))

#define SET_INTEGRAL_COMM_VALUE(comm_value, val)                         \
	if (std::is_signed<typeof(val)>::value) {                                    \
		(comm_value)->u._signed =                                  \
				(typeof((comm_value)->u._signed)) val;   \
	} else {                                                           \
		(comm_value)->u._unsigned =                                \
				(typeof((comm_value)->u._unsigned)) val; \
	}

static inline bool is_virtual_process_attr(enum lttng_process_attr process_attr)
{
	return process_attr == LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID ||
	       process_attr == LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID ||
	       process_attr == LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID;
}

static inline bool is_value_type_name(
		enum lttng_process_attr_value_type value_type)
{
	return value_type == LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME ||
	       value_type == LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME;
}

enum lttng_error_code process_attr_value_from_comm(
		enum lttng_domain_type domain,
		enum lttng_process_attr process_attr,
		enum lttng_process_attr_value_type value_type,
		const struct process_attr_integral_value_comm *integral_value,
		const struct lttng_buffer_view *value_view,
		struct process_attr_value **_value)
{
	char *name = NULL;
	enum lttng_error_code ret = LTTNG_OK;
	struct process_attr_value *value = zmalloc<process_attr_value>();

	if (!value) {
		ret = LTTNG_ERR_NOMEM;
		goto error;
	}

	if (value_view && value_view->size > 0) {
		if (value_view->data[value_view->size - 1] != '\0') {
			ret = LTTNG_ERR_INVALID;
			goto error;
		}
		name = strdup(value_view->data);
		if (!name) {
			ret = LTTNG_ERR_NOMEM;
			goto error;
		}
	}

	if (domain != LTTNG_DOMAIN_UST && domain != LTTNG_DOMAIN_KERNEL) {
		ERR("Only the user space and kernel space domains may be specified to configure process attribute trackers");
		ret = LTTNG_ERR_UNSUPPORTED_DOMAIN;
		goto error;
	}

	if (!is_virtual_process_attr(process_attr) &&
			domain != LTTNG_DOMAIN_KERNEL) {
		ERR("Non-virtual process attributes can only be used in the kernel domain");
		ret = LTTNG_ERR_UNSUPPORTED_DOMAIN;
		goto error;
	}

	/* Only expect a payload for name value types. */
	if (is_value_type_name(value_type) &&
			(!value_view || value_view->size == 0)) {
		ret = LTTNG_ERR_INVALID_PROTOCOL;
		goto error;
	} else if (!is_value_type_name(value_type) && value_view &&
			value_view->size != 0) {
		ret = LTTNG_ERR_INVALID_PROTOCOL;
		goto error;
	}

	value->type = value_type;
	switch (process_attr) {
	case LTTNG_PROCESS_ATTR_PROCESS_ID:
	case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID:
		if (value_type != LTTNG_PROCESS_ATTR_VALUE_TYPE_PID) {
			ERR("Invalid value type used for process ID process attribute");
			ret = LTTNG_ERR_INVALID;
			goto error;
		}
		value->value.pid =
				GET_INTEGRAL_COMM_VALUE(integral_value, pid_t);
		break;
	case LTTNG_PROCESS_ATTR_USER_ID:
	case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID:
		switch (value_type) {
		case LTTNG_PROCESS_ATTR_VALUE_TYPE_UID:
			value->value.uid = GET_INTEGRAL_COMM_VALUE(
					integral_value, uid_t);
			break;
		case LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME:
			if (!name) {
				ret = LTTNG_ERR_INVALID;
				goto error;
			}

			value->value.user_name = name;
			name = NULL;
			break;
		default:
			ERR("Invalid value type used for user ID process attribute");
			ret = LTTNG_ERR_INVALID;
			goto error;
		}
		break;
	case LTTNG_PROCESS_ATTR_GROUP_ID:
	case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID:
		switch (value_type) {
		case LTTNG_PROCESS_ATTR_VALUE_TYPE_GID:
			value->value.gid = GET_INTEGRAL_COMM_VALUE(
					integral_value, gid_t);
			break;
		case LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME:
			if (!name) {
				ret = LTTNG_ERR_INVALID;
				goto error;
			}

			value->value.group_name = name;
			name = NULL;
			break;
		default:
			ERR("Invalid value type used for group ID process attribute");
			ret = LTTNG_ERR_INVALID;
			goto error;
		}
		break;
	default:
		ret = LTTNG_ERR_INVALID_PROTOCOL;
		goto error;
	}

	*_value = value;
	value = NULL;
	free(name);
	return LTTNG_OK;
error:
	free(name);
	process_attr_value_destroy(value);
	return ret;
}

const char *lttng_process_attr_to_string(enum lttng_process_attr process_attr)
{
	switch (process_attr) {
	case LTTNG_PROCESS_ATTR_PROCESS_ID:
		return "process ID";
	case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID:
		return "virtual process ID";
	case LTTNG_PROCESS_ATTR_USER_ID:
		return "user ID";
	case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID:
		return "virtual user ID";
	case LTTNG_PROCESS_ATTR_GROUP_ID:
		return "group ID";
	case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID:
		return "virtual group ID";
	default:
		return "unknown process attribute";
	}
}

static void process_attr_tracker_value_destructor(void *ptr)
{
	struct process_attr_value *value = (typeof(value)) ptr;

	process_attr_value_destroy(value);
}

struct lttng_process_attr_values *lttng_process_attr_values_create(void)
{
	struct lttng_process_attr_values *values = zmalloc<lttng_process_attr_values>();

	if (!values) {
		goto end;
	}

	lttng_dynamic_pointer_array_init(
			&values->array, process_attr_tracker_value_destructor);
end:
	return values;
}

unsigned int _lttng_process_attr_values_get_count(
		const struct lttng_process_attr_values *values)
{
	return (unsigned int) lttng_dynamic_pointer_array_get_count(
			&values->array);
}

const struct process_attr_value *lttng_process_attr_tracker_values_get_at_index(
		const struct lttng_process_attr_values *values,
		unsigned int index)
{
	return (process_attr_value *) lttng_dynamic_pointer_array_get_pointer(&values->array, index);
}

static
int process_attr_tracker_value_serialize(const struct process_attr_value *value,
		struct lttng_dynamic_buffer *buffer)
{
	int ret;
	struct process_attr_tracker_value_comm value_comm = {
			.type = (int32_t) value->type,
			.value = {},
	};
	const char *name = NULL;

	switch (value->type) {
	case LTTNG_PROCESS_ATTR_VALUE_TYPE_PID:
		SET_INTEGRAL_COMM_VALUE(
				&value_comm.value.integral, value->value.pid);
		break;
	case LTTNG_PROCESS_ATTR_VALUE_TYPE_UID:
		SET_INTEGRAL_COMM_VALUE(
				&value_comm.value.integral, value->value.uid);
		break;
	case LTTNG_PROCESS_ATTR_VALUE_TYPE_GID:
		SET_INTEGRAL_COMM_VALUE(
				&value_comm.value.integral, value->value.gid);
		break;
	case LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME:
		name = value->value.user_name;
		break;
	case LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME:
		name = value->value.group_name;
		break;
	default:
		abort();
	}

	if (name) {
		value_comm.value.name_len = strlen(name) + 1;
	}

	ret = lttng_dynamic_buffer_append(
			buffer, &value_comm, sizeof(value_comm));
	if (ret) {
		goto end;
	}

	if (name) {
		ret = lttng_dynamic_buffer_append(
				buffer, name, value_comm.value.name_len);
	}
end:
	return ret;
}

int lttng_process_attr_values_serialize(
		const struct lttng_process_attr_values *values,
		struct lttng_dynamic_buffer *buffer)
{
	int ret;
	unsigned int count, i;
	struct process_attr_tracker_values_comm_header header = {};

	count = _lttng_process_attr_values_get_count(values);
	header.count = (uint32_t) count;

	ret = lttng_dynamic_buffer_append(buffer, &header, sizeof(header));
	if (ret) {
		goto end;
	}

	for (i = 0; i < count; i++) {
		const struct process_attr_value *value =
				lttng_process_attr_tracker_values_get_at_index(
						values, i);

		ret = process_attr_tracker_value_serialize(value, buffer);
		if (ret) {
			goto end;
		}
	}
end:
	return ret;
}

ssize_t lttng_process_attr_values_create_from_buffer(
		enum lttng_domain_type domain,
		enum lttng_process_attr process_attr,
		const struct lttng_buffer_view *buffer_view,
		struct lttng_process_attr_values **_values)
{
	ssize_t offset;
	unsigned int i;
	struct lttng_process_attr_values *values;
	struct lttng_buffer_view header_view;
	const struct process_attr_tracker_values_comm_header *header;

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

	header_view = lttng_buffer_view_from_view(
			buffer_view, 0, sizeof(*header));
	if (!lttng_buffer_view_is_valid(&header_view)) {
		goto error;
	}

	offset = header_view.size;
	header = (typeof(header)) header_view.data;

	/*
	 * Check that the number of values is not absurdly large with respect to
	 * the received buffer's size.
	 */
	if (buffer_view->size <
			header->count * sizeof(struct process_attr_tracker_value_comm)) {
		goto error;
	}
	for (i = 0; i < (unsigned int) header->count; i++) {
		int ret;
		enum lttng_error_code ret_code;
		const struct process_attr_tracker_value_comm *value_comm;
		struct process_attr_value *value;
		enum lttng_process_attr_value_type type;
		struct lttng_buffer_view value_view;
		struct lttng_buffer_view value_name_view = {};

		value_view = lttng_buffer_view_from_view(
				buffer_view, offset, sizeof(*value_comm));
		if (!lttng_buffer_view_is_valid(&value_view)) {
			goto error;
		}

		offset += value_view.size;
		value_comm = (typeof(value_comm)) value_view.data;
		type = (typeof(type)) value_comm->type;

		if (is_value_type_name(type)) {
			value_name_view = lttng_buffer_view_from_view(
					buffer_view, offset,
					value_comm->value.name_len);
			if (!lttng_buffer_view_is_valid(&value_name_view)) {
				goto error;
			}

			offset += value_name_view.size;
		}

		ret_code = process_attr_value_from_comm(domain, process_attr,
				type, &value_comm->value.integral,
				&value_name_view, &value);
		if (ret_code != LTTNG_OK) {
			goto error;
		}

		ret = lttng_dynamic_pointer_array_add_pointer(
				&values->array, value);
		if (ret) {
			process_attr_value_destroy(value);
			goto error;
		}
	}

	*_values = values;
	return offset;
error:
	lttng_process_attr_values_destroy(values);
	return -1;
}

void lttng_process_attr_values_destroy(struct lttng_process_attr_values *values)
{
	if (!values) {
		return;
	}
	lttng_dynamic_pointer_array_reset(&values->array);
	free(values);
}

struct process_attr_value *process_attr_value_copy(
		const struct process_attr_value *value)
{
	struct process_attr_value *new_value = NULL;

	if (!value) {
		goto end;
	}

	new_value = zmalloc<process_attr_value>();
	if (!new_value) {
		goto end;
	}
	if (is_value_type_name(value->type)) {
		const char *src =
				value->type == LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME ?
						value->value.user_name :
						value->value.group_name;
		char **dst = value->type == LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME ?
					     &new_value->value.user_name :
					     &new_value->value.group_name;

		new_value->type = value->type;
		*dst = strdup(src);
		if (!*dst) {
			goto error;
		}
	} else {
		*new_value = *value;
	}
end:
	return new_value;
error:
	free(new_value);
	return NULL;
}

unsigned long process_attr_value_hash(const struct process_attr_value *a)
{
	unsigned long hash = hash_key_ulong((void *) a->type, lttng_ht_seed);

	switch (a->type) {
	case LTTNG_PROCESS_ATTR_VALUE_TYPE_PID:
		hash ^= hash_key_ulong((void *) (unsigned long) a->value.pid,
				lttng_ht_seed);
		break;
	case LTTNG_PROCESS_ATTR_VALUE_TYPE_UID:
		hash ^= hash_key_ulong((void *) (unsigned long) a->value.uid,
				lttng_ht_seed);
		break;
	case LTTNG_PROCESS_ATTR_VALUE_TYPE_GID:
		hash ^= hash_key_ulong((void *) (unsigned long) a->value.gid,
				lttng_ht_seed);
		break;
	case LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME:
		hash ^= hash_key_str(a->value.user_name, lttng_ht_seed);
		break;
	case LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME:
		hash ^= hash_key_str(a->value.group_name, lttng_ht_seed);
		break;
	default:
		abort();
	}

	return hash;
}

bool process_attr_tracker_value_equal(const struct process_attr_value *a,
		const struct process_attr_value *b)
{
	if (a->type != b->type) {
		return false;
	}
	switch (a->type) {
	case LTTNG_PROCESS_ATTR_VALUE_TYPE_PID:
		return a->value.pid == b->value.pid;
	case LTTNG_PROCESS_ATTR_VALUE_TYPE_UID:
		return a->value.uid == b->value.uid;
	case LTTNG_PROCESS_ATTR_VALUE_TYPE_GID:
		return a->value.gid == b->value.gid;
	case LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME:
		return !strcmp(a->value.user_name, b->value.user_name);
	case LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME:
		return !strcmp(a->value.group_name, b->value.group_name);
	default:
		abort();
	}
}

void process_attr_value_destroy(struct process_attr_value *value)
{
	if (!value) {
		return;
	}
	if (is_value_type_name(value->type)) {
		free(value->type == LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME ?
						value->value.user_name :
						value->value.group_name);
	}
	free(value);
}
Commit	Line	Data
2d97a006	1	/*
4942c256	2	* Copyright (C) 2019 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
159b042f	3	* Copyright (C) 2020 Jérémie Galarneau <jeremie.galarneau@efficios.com>
2d97a006	4	*
ab5be9fa	5	* SPDX-License-Identifier: LGPL-2.1-only
2d97a006	6	*
2d97a006 JR	7	*/
2d97a006 JR	8
159b042f JG	9	#include <lttng/domain.h>
	10	#include <lttng/lttng-error.h>
	11	#include <lttng/tracker.h>
2d97a006	12
c9e313bc SM	13	#include <common/dynamic-array.hpp>
	14	#include <common/error.hpp>
	15	#include <common/hashtable/hashtable.hpp>
	16	#include <common/hashtable/utils.hpp>
	17	#include <common/tracker.hpp>
159b042f JG	18
	19	#include <stdbool.h>
	20
c10f9cdd MJ	21	#include <type_traits>
c10f9cdd MJ	22
f1494934	23	namespace {
159b042f JG	24	struct process_attr_tracker_values_comm_header {
159b042f JG	25	uint32_t count;
2d7da303	26	} LTTNG_PACKED;
159b042f JG	27
	28	struct process_attr_tracker_value_comm {
	29	/* enum lttng_process_attr_value_type */
	30	int32_t type;
	31	union {
	32	struct process_attr_integral_value_comm integral;
	33	/* Includes the '\0' terminator. */
	34	uint32_t name_len;
	35	} value;
2d7da303	36	} LTTNG_PACKED;
f1494934	37	} /* namespace */
159b042f JG	38
159b042f JG	39	#define GET_INTEGRAL_COMM_VALUE(value_ptr, as_type) \
c10f9cdd	40	((as_type)(std::is_signed<as_type>::value ? (value_ptr)->u._signed : \
159b042f JG	41	(value_ptr)->u._unsigned))
159b042f JG	42
c10f9cdd MJ	43	#define SET_INTEGRAL_COMM_VALUE(comm_value, val) \
c10f9cdd MJ	44	if (std::is_signed<typeof(val)>::value) { \
159b042f	45	(comm_value)->u._signed = \
c10f9cdd	46	(typeof((comm_value)->u._signed)) val; \
159b042f JG	47	} else { \
159b042f JG	48	(comm_value)->u._unsigned = \
c10f9cdd	49	(typeof((comm_value)->u._unsigned)) val; \
2d97a006 JR	50	}
2d97a006 JR	51
159b042f JG	52	static inline bool is_virtual_process_attr(enum lttng_process_attr process_attr)
	53	{
	54	return process_attr == LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID \|\|
	55	process_attr == LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID \|\|
	56	process_attr == LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID;
2d97a006 JR	57	}
2d97a006 JR	58
159b042f JG	59	static inline bool is_value_type_name(
159b042f JG	60	enum lttng_process_attr_value_type value_type)
2d97a006	61	{
159b042f JG	62	return value_type == LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME \|\|
159b042f JG	63	value_type == LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME;
2d97a006 JR	64	}
2d97a006 JR	65
159b042f JG	66	enum lttng_error_code process_attr_value_from_comm(
	67	enum lttng_domain_type domain,
	68	enum lttng_process_attr process_attr,
	69	enum lttng_process_attr_value_type value_type,
	70	const struct process_attr_integral_value_comm *integral_value,
	71	const struct lttng_buffer_view *value_view,
	72	struct process_attr_value **_value)
2d97a006	73	{
159b042f JG	74	char *name = NULL;
159b042f JG	75	enum lttng_error_code ret = LTTNG_OK;
64803277	76	struct process_attr_value *value = zmalloc<process_attr_value>();
2d97a006	77
159b042f JG	78	if (!value) {
159b042f JG	79	ret = LTTNG_ERR_NOMEM;
2d97a006 JR	80	goto error;
	81	}
	82
159b042f JG	83	if (value_view && value_view->size > 0) {
	84	if (value_view->data[value_view->size - 1] != '\0') {
	85	ret = LTTNG_ERR_INVALID;
	86	goto error;
	87	}
	88	name = strdup(value_view->data);
	89	if (!name) {
	90	ret = LTTNG_ERR_NOMEM;
74675e31	91	goto error;
159b042f JG	92	}
159b042f JG	93	}
2d97a006	94
159b042f JG	95	if (domain != LTTNG_DOMAIN_UST && domain != LTTNG_DOMAIN_KERNEL) {
	96	ERR("Only the user space and kernel space domains may be specified to configure process attribute trackers");
	97	ret = LTTNG_ERR_UNSUPPORTED_DOMAIN;
	98	goto error;
	99	}
2d97a006	100
159b042f JG	101	if (!is_virtual_process_attr(process_attr) &&
	102	domain != LTTNG_DOMAIN_KERNEL) {
	103	ERR("Non-virtual process attributes can only be used in the kernel domain");
	104	ret = LTTNG_ERR_UNSUPPORTED_DOMAIN;
	105	goto error;
	106	}
2d97a006	107
159b042f	108	/* Only expect a payload for name value types. */
b78dab17 JG	109	if (is_value_type_name(value_type) &&
b78dab17 JG	110	(!value_view \|\| value_view->size == 0)) {
159b042f JG	111	ret = LTTNG_ERR_INVALID_PROTOCOL;
159b042f JG	112	goto error;
1ad5cb59 JG	113	} else if (!is_value_type_name(value_type) && value_view &&
1ad5cb59 JG	114	value_view->size != 0) {
159b042f JG	115	ret = LTTNG_ERR_INVALID_PROTOCOL;
159b042f JG	116	goto error;
2d97a006 JR	117	}
2d97a006 JR	118
159b042f JG	119	value->type = value_type;
	120	switch (process_attr) {
	121	case LTTNG_PROCESS_ATTR_PROCESS_ID:
	122	case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID:
	123	if (value_type != LTTNG_PROCESS_ATTR_VALUE_TYPE_PID) {
	124	ERR("Invalid value type used for process ID process attribute");
	125	ret = LTTNG_ERR_INVALID;
	126	goto error;
	127	}
	128	value->value.pid =
	129	GET_INTEGRAL_COMM_VALUE(integral_value, pid_t);
	130	break;
	131	case LTTNG_PROCESS_ATTR_USER_ID:
	132	case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID:
	133	switch (value_type) {
	134	case LTTNG_PROCESS_ATTR_VALUE_TYPE_UID:
	135	value->value.uid = GET_INTEGRAL_COMM_VALUE(
	136	integral_value, uid_t);
	137	break;
	138	case LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME:
	139	if (!name) {
	140	ret = LTTNG_ERR_INVALID;
	141	goto error;
	142	}
	143
	144	value->value.user_name = name;
	145	name = NULL;
	146	break;
	147	default:
	148	ERR("Invalid value type used for user ID process attribute");
	149	ret = LTTNG_ERR_INVALID;
	150	goto error;
	151	}
	152	break;
	153	case LTTNG_PROCESS_ATTR_GROUP_ID:
	154	case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID:
	155	switch (value_type) {
	156	case LTTNG_PROCESS_ATTR_VALUE_TYPE_GID:
	157	value->value.gid = GET_INTEGRAL_COMM_VALUE(
	158	integral_value, gid_t);
	159	break;
	160	case LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME:
	161	if (!name) {
	162	ret = LTTNG_ERR_INVALID;
	163	goto error;
	164	}
	165
	166	value->value.group_name = name;
	167	name = NULL;
	168	break;
	169	default:
	170	ERR("Invalid value type used for group ID process attribute");
	171	ret = LTTNG_ERR_INVALID;
	172	goto error;
	173	}
	174	break;
	175	default:
	176	ret = LTTNG_ERR_INVALID_PROTOCOL;
	177	goto error;
2d97a006 JR	178	}
2d97a006 JR	179
159b042f JG	180	*_value = value;
159b042f JG	181	value = NULL;
d4e37173	182	free(name);
159b042f JG	183	return LTTNG_OK;
	184	error:
	185	free(name);
	186	process_attr_value_destroy(value);
	187	return ret;
2d97a006 JR	188	}
2d97a006 JR	189
159b042f	190	const char *lttng_process_attr_to_string(enum lttng_process_attr process_attr)
2d97a006	191	{
159b042f JG	192	switch (process_attr) {
	193	case LTTNG_PROCESS_ATTR_PROCESS_ID:
	194	return "process ID";
	195	case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID:
	196	return "virtual process ID";
	197	case LTTNG_PROCESS_ATTR_USER_ID:
	198	return "user ID";
	199	case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID:
	200	return "virtual user ID";
	201	case LTTNG_PROCESS_ATTR_GROUP_ID:
	202	return "group ID";
	203	case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID:
	204	return "virtual group ID";
	205	default:
	206	return "unknown process attribute";
2d97a006	207	}
2d97a006 JR	208	}
2d97a006 JR	209
159b042f	210	static void process_attr_tracker_value_destructor(void *ptr)
2d97a006	211	{
159b042f JG	212	struct process_attr_value *value = (typeof(value)) ptr;
	213
	214	process_attr_value_destroy(value);
2d97a006 JR	215	}
2d97a006 JR	216
159b042f	217	struct lttng_process_attr_values *lttng_process_attr_values_create(void)
2d97a006	218	{
64803277	219	struct lttng_process_attr_values *values = zmalloc<lttng_process_attr_values>();
2d97a006	220
159b042f JG	221	if (!values) {
159b042f JG	222	goto end;
2d97a006 JR	223	}
2d97a006 JR	224
159b042f JG	225	lttng_dynamic_pointer_array_init(
	226	&values->array, process_attr_tracker_value_destructor);
	227	end:
	228	return values;
2d97a006 JR	229	}
2d97a006 JR	230
159b042f JG	231	unsigned int _lttng_process_attr_values_get_count(
159b042f JG	232	const struct lttng_process_attr_values *values)
2d97a006	233	{
159b042f JG	234	return (unsigned int) lttng_dynamic_pointer_array_get_count(
159b042f JG	235	&values->array);
2d97a006 JR	236	}
2d97a006 JR	237
159b042f JG	238	const struct process_attr_value *lttng_process_attr_tracker_values_get_at_index(
	239	const struct lttng_process_attr_values *values,
	240	unsigned int index)
2d97a006	241	{
a6bc4ca9	242	return (process_attr_value *) lttng_dynamic_pointer_array_get_pointer(&values->array, index);
159b042f	243	}
2d97a006	244
159b042f JG	245	static
	246	int process_attr_tracker_value_serialize(const struct process_attr_value *value,
	247	struct lttng_dynamic_buffer *buffer)
	248	{
	249	int ret;
	250	struct process_attr_tracker_value_comm value_comm = {
	251	.type = (int32_t) value->type,
1c9a0b0e	252	.value = {},
159b042f JG	253	};
	254	const char *name = NULL;
	255
	256	switch (value->type) {
	257	case LTTNG_PROCESS_ATTR_VALUE_TYPE_PID:
	258	SET_INTEGRAL_COMM_VALUE(
	259	&value_comm.value.integral, value->value.pid);
2d97a006	260	break;
159b042f JG	261	case LTTNG_PROCESS_ATTR_VALUE_TYPE_UID:
	262	SET_INTEGRAL_COMM_VALUE(
	263	&value_comm.value.integral, value->value.uid);
2d97a006	264	break;
159b042f JG	265	case LTTNG_PROCESS_ATTR_VALUE_TYPE_GID:
	266	SET_INTEGRAL_COMM_VALUE(
	267	&value_comm.value.integral, value->value.gid);
2d97a006	268	break;
159b042f JG	269	case LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME:
159b042f JG	270	name = value->value.user_name;
2d97a006	271	break;
159b042f JG	272	case LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME:
	273	name = value->value.group_name;
	274	break;
	275	default:
	276	abort();
2d97a006 JR	277	}
2d97a006 JR	278
159b042f JG	279	if (name) {
159b042f JG	280	value_comm.value.name_len = strlen(name) + 1;
a7a533cd	281	}
159b042f JG	282
	283	ret = lttng_dynamic_buffer_append(
	284	buffer, &value_comm, sizeof(value_comm));
	285	if (ret) {
	286	goto end;
	287	}
	288
	289	if (name) {
	290	ret = lttng_dynamic_buffer_append(
	291	buffer, name, value_comm.value.name_len);
	292	}
	293	end:
a7a533cd JR	294	return ret;
	295	}
	296
159b042f JG	297	int lttng_process_attr_values_serialize(
	298	const struct lttng_process_attr_values *values,
	299	struct lttng_dynamic_buffer *buffer)
a7a533cd JR	300	{
a7a533cd JR	301	int ret;
159b042f JG	302	unsigned int count, i;
159b042f JG	303	struct process_attr_tracker_values_comm_header header = {};
a7a533cd	304
159b042f JG	305	count = _lttng_process_attr_values_get_count(values);
159b042f JG	306	header.count = (uint32_t) count;
a7a533cd	307
159b042f	308	ret = lttng_dynamic_buffer_append(buffer, &header, sizeof(header));
a7a533cd	309	if (ret) {
159b042f	310	goto end;
2d97a006 JR	311	}
2d97a006 JR	312
159b042f JG	313	for (i = 0; i < count; i++) {
	314	const struct process_attr_value *value =
	315	lttng_process_attr_tracker_values_get_at_index(
	316	values, i);
2d97a006	317
159b042f JG	318	ret = process_attr_tracker_value_serialize(value, buffer);
	319	if (ret) {
	320	goto end;
	321	}
2d97a006	322	}
159b042f JG	323	end:
159b042f JG	324	return ret;
2d97a006	325	}
a7a533cd	326
159b042f JG	327	ssize_t lttng_process_attr_values_create_from_buffer(
	328	enum lttng_domain_type domain,
	329	enum lttng_process_attr process_attr,
	330	const struct lttng_buffer_view *buffer_view,
	331	struct lttng_process_attr_values **_values)
a7a533cd	332	{
159b042f JG	333	ssize_t offset;
	334	unsigned int i;
	335	struct lttng_process_attr_values *values;
	336	struct lttng_buffer_view header_view;
	337	const struct process_attr_tracker_values_comm_header *header;
a7a533cd	338
159b042f JG	339	values = lttng_process_attr_values_create();
159b042f JG	340	if (!values) {
a7a533cd JR	341	goto error;
	342	}
	343
159b042f JG	344	header_view = lttng_buffer_view_from_view(
159b042f JG	345	buffer_view, 0, sizeof(*header));
3e6e0df2	346	if (!lttng_buffer_view_is_valid(&header_view)) {
a7a533cd JR	347	goto error;
a7a533cd JR	348	}
3e6e0df2	349
159b042f JG	350	offset = header_view.size;
	351	header = (typeof(header)) header_view.data;
	352
	353	/*
	354	* Check that the number of values is not absurdly large with respect to
	355	* the received buffer's size.
	356	*/
	357	if (buffer_view->size <
	358	header->count * sizeof(struct process_attr_tracker_value_comm)) {
	359	goto error;
	360	}
	361	for (i = 0; i < (unsigned int) header->count; i++) {
	362	int ret;
	363	enum lttng_error_code ret_code;
	364	const struct process_attr_tracker_value_comm *value_comm;
	365	struct process_attr_value *value;
	366	enum lttng_process_attr_value_type type;
	367	struct lttng_buffer_view value_view;
	368	struct lttng_buffer_view value_name_view = {};
	369
	370	value_view = lttng_buffer_view_from_view(
	371	buffer_view, offset, sizeof(*value_comm));
3e6e0df2	372	if (!lttng_buffer_view_is_valid(&value_view)) {
159b042f JG	373	goto error;
159b042f JG	374	}
a7a533cd	375
159b042f JG	376	offset += value_view.size;
	377	value_comm = (typeof(value_comm)) value_view.data;
	378	type = (typeof(type)) value_comm->type;
a7a533cd	379
159b042f JG	380	if (is_value_type_name(type)) {
	381	value_name_view = lttng_buffer_view_from_view(
	382	buffer_view, offset,
	383	value_comm->value.name_len);
3e6e0df2 JG	384	if (!lttng_buffer_view_is_valid(&value_name_view)) {
	385	goto error;
	386	}
	387
159b042f JG	388	offset += value_name_view.size;
159b042f JG	389	}
3e6e0df2	390
159b042f JG	391	ret_code = process_attr_value_from_comm(domain, process_attr,
	392	type, &value_comm->value.integral,
	393	&value_name_view, &value);
	394	if (ret_code != LTTNG_OK) {
	395	goto error;
	396	}
a7a533cd	397
159b042f JG	398	ret = lttng_dynamic_pointer_array_add_pointer(
	399	&values->array, value);
	400	if (ret) {
	401	process_attr_value_destroy(value);
	402	goto error;
	403	}
a7a533cd JR	404	}
a7a533cd JR	405
159b042f JG	406	*_values = values;
	407	return offset;
	408	error:
	409	lttng_process_attr_values_destroy(values);
	410	return -1;
a7a533cd JR	411	}
a7a533cd JR	412
159b042f	413	void lttng_process_attr_values_destroy(struct lttng_process_attr_values *values)
a7a533cd	414	{
159b042f JG	415	if (!values) {
	416	return;
	417	}
	418	lttng_dynamic_pointer_array_reset(&values->array);
	419	free(values);
a7a533cd JR	420	}
a7a533cd JR	421
159b042f JG	422	struct process_attr_value *process_attr_value_copy(
159b042f JG	423	const struct process_attr_value *value)
a7a533cd	424	{
159b042f	425	struct process_attr_value *new_value = NULL;
e283e4a0	426
159b042f	427	if (!value) {
e283e4a0 JR	428	goto end;
	429	}
	430
64803277	431	new_value = zmalloc<process_attr_value>();
159b042f JG	432	if (!new_value) {
	433	goto end;
	434	}
	435	if (is_value_type_name(value->type)) {
	436	const char *src =
	437	value->type == LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME ?
	438	value->value.user_name :
	439	value->value.group_name;
	440	char **dst = value->type == LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME ?
	441	&new_value->value.user_name :
	442	&new_value->value.group_name;
	443
	444	new_value->type = value->type;
	445	*dst = strdup(src);
	446	if (!*dst) {
	447	goto error;
	448	}
	449	} else {
	450	new_value = value;
	451	}
e283e4a0	452	end:
159b042f JG	453	return new_value;
	454	error:
	455	free(new_value);
	456	return NULL;
a7a533cd JR	457	}
a7a533cd JR	458
159b042f	459	unsigned long process_attr_value_hash(const struct process_attr_value *a)
a7a533cd	460	{
159b042f	461	unsigned long hash = hash_key_ulong((void *) a->type, lttng_ht_seed);
9df6c82a	462
159b042f JG	463	switch (a->type) {
	464	case LTTNG_PROCESS_ATTR_VALUE_TYPE_PID:
	465	hash ^= hash_key_ulong((void *) (unsigned long) a->value.pid,
	466	lttng_ht_seed);
	467	break;
	468	case LTTNG_PROCESS_ATTR_VALUE_TYPE_UID:
	469	hash ^= hash_key_ulong((void *) (unsigned long) a->value.uid,
	470	lttng_ht_seed);
	471	break;
	472	case LTTNG_PROCESS_ATTR_VALUE_TYPE_GID:
	473	hash ^= hash_key_ulong((void *) (unsigned long) a->value.gid,
	474	lttng_ht_seed);
	475	break;
	476	case LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME:
	477	hash ^= hash_key_str(a->value.user_name, lttng_ht_seed);
	478	break;
	479	case LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME:
	480	hash ^= hash_key_str(a->value.group_name, lttng_ht_seed);
	481	break;
	482	default:
	483	abort();
a7a533cd JR	484	}
a7a533cd JR	485
159b042f	486	return hash;
a7a533cd	487	}
f19f5c96	488
159b042f JG	489	bool process_attr_tracker_value_equal(const struct process_attr_value *a,
159b042f JG	490	const struct process_attr_value *b)
f19f5c96	491	{
159b042f JG	492	if (a->type != b->type) {
159b042f JG	493	return false;
f19f5c96	494	}
159b042f JG	495	switch (a->type) {
	496	case LTTNG_PROCESS_ATTR_VALUE_TYPE_PID:
	497	return a->value.pid == b->value.pid;
	498	case LTTNG_PROCESS_ATTR_VALUE_TYPE_UID:
	499	return a->value.uid == b->value.uid;
	500	case LTTNG_PROCESS_ATTR_VALUE_TYPE_GID:
	501	return a->value.gid == b->value.gid;
	502	case LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME:
	503	return !strcmp(a->value.user_name, b->value.user_name);
	504	case LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME:
	505	return !strcmp(a->value.group_name, b->value.group_name);
	506	default:
	507	abort();
	508	}
	509	}
f19f5c96	510
159b042f JG	511	void process_attr_value_destroy(struct process_attr_value *value)
	512	{
	513	if (!value) {
	514	return;
f19f5c96	515	}
159b042f JG	516	if (is_value_type_name(value->type)) {
	517	free(value->type == LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME ?
	518	value->value.user_name :
	519	value->value.group_name);
	520	}
	521	free(value);
f19f5c96	522	}