[ceph.git] / ceph / src / spdk / dpdk / lib / librte_telemetry / telemetry.c

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2020 Intel Corporation
 */

#include <unistd.h>
#include <pthread.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <dlfcn.h>

/* we won't link against libbsd, so just always use DPDKs-specific strlcpy */
#undef RTE_USE_LIBBSD
#include <rte_string_fns.h>
#include <rte_common.h>
#include <rte_spinlock.h>
#include <rte_version.h>

#include "rte_telemetry.h"
#include "telemetry_json.h"
#include "telemetry_data.h"
#include "rte_telemetry_legacy.h"

#define MAX_CMD_LEN 56
#define MAX_HELP_LEN 64
#define MAX_OUTPUT_LEN (1024 * 16)

static void *
client_handler(void *socket);

struct cmd_callback {
	char cmd[MAX_CMD_LEN];
	telemetry_cb fn;
	char help[MAX_HELP_LEN];
};

struct socket {
	int sock;
	char path[sizeof(((struct sockaddr_un *)0)->sun_path)];
	handler fn;
};
static struct socket v2_socket; /* socket for v2 telemetry */
static struct socket v1_socket; /* socket for v1 telemetry */
static char telemetry_log_error[1024]; /* Will contain error on init failure */
/* list of command callbacks, with one command registered by default */
static struct cmd_callback callbacks[TELEMETRY_MAX_CALLBACKS];
static int num_callbacks; /* How many commands are registered */
/* Used when accessing or modifying list of command callbacks */
static rte_spinlock_t callback_sl = RTE_SPINLOCK_INITIALIZER;

int
rte_telemetry_register_cmd(const char *cmd, telemetry_cb fn, const char *help)
{
	int i = 0;

	if (strlen(cmd) >= MAX_CMD_LEN || fn == NULL || cmd[0] != '/'
			|| strlen(help) >= MAX_HELP_LEN)
		return -EINVAL;
	if (num_callbacks >= TELEMETRY_MAX_CALLBACKS)
		return -ENOENT;

	rte_spinlock_lock(&callback_sl);
	while (i < num_callbacks && strcmp(cmd, callbacks[i].cmd) > 0)
		i++;
	if (i != num_callbacks)
		/* Move elements to keep the list alphabetical */
		memmove(callbacks + i + 1, callbacks + i,
			sizeof(struct cmd_callback) * (num_callbacks - i));

	strlcpy(callbacks[i].cmd, cmd, MAX_CMD_LEN);
	callbacks[i].fn = fn;
	strlcpy(callbacks[i].help, help, MAX_HELP_LEN);
	num_callbacks++;
	rte_spinlock_unlock(&callback_sl);

	return 0;
}

static int
list_commands(const char *cmd __rte_unused, const char *params __rte_unused,
		struct rte_tel_data *d)
{
	int i;

	rte_tel_data_start_array(d, RTE_TEL_STRING_VAL);
	for (i = 0; i < num_callbacks; i++)
		rte_tel_data_add_array_string(d, callbacks[i].cmd);
	return 0;
}

static int
json_info(const char *cmd __rte_unused, const char *params __rte_unused,
		struct rte_tel_data *d)
{
	rte_tel_data_start_dict(d);
	rte_tel_data_add_dict_string(d, "version", rte_version());
	rte_tel_data_add_dict_int(d, "pid", getpid());
	rte_tel_data_add_dict_int(d, "max_output_len", MAX_OUTPUT_LEN);
	return 0;
}

static int
command_help(const char *cmd __rte_unused, const char *params,
		struct rte_tel_data *d)
{
	int i;

	if (!params)
		return -1;
	rte_tel_data_start_dict(d);
	rte_spinlock_lock(&callback_sl);
	for (i = 0; i < num_callbacks; i++)
		if (strcmp(params, callbacks[i].cmd) == 0) {
			rte_tel_data_add_dict_string(d, params,
					callbacks[i].help);
			break;
		}
	rte_spinlock_unlock(&callback_sl);
	if (i == num_callbacks)
		return -1;
	return 0;
}

static void
output_json(const char *cmd, const struct rte_tel_data *d, int s)
{
	char out_buf[MAX_OUTPUT_LEN];

	char *cb_data_buf;
	size_t buf_len, prefix_used, used = 0;
	unsigned int i;

	RTE_BUILD_BUG_ON(sizeof(out_buf) < MAX_CMD_LEN +
			RTE_TEL_MAX_SINGLE_STRING_LEN + 10);
	switch (d->type) {
	case RTE_TEL_NULL:
		used = snprintf(out_buf, sizeof(out_buf), "{\"%.*s\":null}",
				MAX_CMD_LEN, cmd ? cmd : "none");
		break;
	case RTE_TEL_STRING:
		used = snprintf(out_buf, sizeof(out_buf), "{\"%.*s\":\"%.*s\"}",
				MAX_CMD_LEN, cmd,
				RTE_TEL_MAX_SINGLE_STRING_LEN, d->data.str);
		break;
	case RTE_TEL_DICT:
		prefix_used = snprintf(out_buf, sizeof(out_buf), "{\"%.*s\":",
				MAX_CMD_LEN, cmd);
		cb_data_buf = &out_buf[prefix_used];
		buf_len = sizeof(out_buf) - prefix_used - 1; /* space for '}' */

		used = rte_tel_json_empty_obj(cb_data_buf, buf_len, 0);
		for (i = 0; i < d->data_len; i++) {
			const struct tel_dict_entry *v = &d->data.dict[i];
			switch (v->type) {
			case RTE_TEL_STRING_VAL:
				used = rte_tel_json_add_obj_str(cb_data_buf,
						buf_len, used,
						v->name, v->value.sval);
				break;
			case RTE_TEL_INT_VAL:
				used = rte_tel_json_add_obj_int(cb_data_buf,
						buf_len, used,
						v->name, v->value.ival);
				break;
			case RTE_TEL_U64_VAL:
				used = rte_tel_json_add_obj_u64(cb_data_buf,
						buf_len, used,
						v->name, v->value.u64val);
				break;
			}
		}
		used += prefix_used;
		used += strlcat(out_buf + used, "}", sizeof(out_buf) - used);
		break;
	case RTE_TEL_ARRAY_STRING:
	case RTE_TEL_ARRAY_INT:
	case RTE_TEL_ARRAY_U64:
		prefix_used = snprintf(out_buf, sizeof(out_buf), "{\"%.*s\":",
				MAX_CMD_LEN, cmd);
		cb_data_buf = &out_buf[prefix_used];
		buf_len = sizeof(out_buf) - prefix_used - 1; /* space for '}' */

		used = rte_tel_json_empty_array(cb_data_buf, buf_len, 0);
		for (i = 0; i < d->data_len; i++)
			if (d->type == RTE_TEL_ARRAY_STRING)
				used = rte_tel_json_add_array_string(
						cb_data_buf,
						buf_len, used,
						d->data.array[i].sval);
			else if (d->type == RTE_TEL_ARRAY_INT)
				used = rte_tel_json_add_array_int(cb_data_buf,
						buf_len, used,
						d->data.array[i].ival);
			else if (d->type == RTE_TEL_ARRAY_U64)
				used = rte_tel_json_add_array_u64(cb_data_buf,
						buf_len, used,
						d->data.array[i].u64val);
		used += prefix_used;
		used += strlcat(out_buf + used, "}", sizeof(out_buf) - used);
		break;
	}
	if (write(s, out_buf, used) < 0)
		perror("Error writing to socket");
}

static void
perform_command(telemetry_cb fn, const char *cmd, const char *param, int s)
{
	struct rte_tel_data data;

	int ret = fn(cmd, param, &data);
	if (ret < 0) {
		char out_buf[MAX_CMD_LEN + 10];
		int used = snprintf(out_buf, sizeof(out_buf), "{\"%.*s\":null}",
				MAX_CMD_LEN, cmd ? cmd : "none");
		if (write(s, out_buf, used) < 0)
			perror("Error writing to socket");
		return;
	}
	output_json(cmd, &data, s);
}

static int
unknown_command(const char *cmd __rte_unused, const char *params __rte_unused,
		struct rte_tel_data *d)
{
	return d->type = RTE_TEL_NULL;
}

static void *
client_handler(void *sock_id)
{
	int s = (int)(uintptr_t)sock_id;
	char buffer[1024];
	char info_str[1024];
	snprintf(info_str, sizeof(info_str),
			"{\"version\":\"%s\",\"pid\":%d,\"max_output_len\":%d}",
			rte_version(), getpid(), MAX_OUTPUT_LEN);
	if (write(s, info_str, strlen(info_str)) < 0) {
		close(s);
		return NULL;
	}

	/* receive data is not null terminated */
	int bytes = read(s, buffer, sizeof(buffer) - 1);
	while (bytes > 0) {
		buffer[bytes] = 0;
		const char *cmd = strtok(buffer, ",");
		const char *param = strtok(NULL, ",");
		telemetry_cb fn = unknown_command;
		int i;

		if (cmd && strlen(cmd) < MAX_CMD_LEN) {
			rte_spinlock_lock(&callback_sl);
			for (i = 0; i < num_callbacks; i++)
				if (strcmp(cmd, callbacks[i].cmd) == 0) {
					fn = callbacks[i].fn;
					break;
				}
			rte_spinlock_unlock(&callback_sl);
		}
		perform_command(fn, cmd, param, s);

		bytes = read(s, buffer, sizeof(buffer) - 1);
	}
	close(s);
	return NULL;
}

static void *
socket_listener(void *socket)
{
	while (1) {
		pthread_t th;
		struct socket *s = (struct socket *)socket;
		int s_accepted = accept(s->sock, NULL, NULL);
		if (s_accepted < 0) {
			snprintf(telemetry_log_error,
				sizeof(telemetry_log_error),
				"Error with accept, telemetry thread quitting");
			return NULL;
		}
		pthread_create(&th, NULL, s->fn, (void *)(uintptr_t)s_accepted);
		pthread_detach(th);
	}
	return NULL;
}

static inline char *
get_socket_path(const char *runtime_dir, const int version)
{
	static char path[PATH_MAX];
	snprintf(path, sizeof(path), "%s/dpdk_telemetry.v%d",
			strlen(runtime_dir) ? runtime_dir : "/tmp", version);
	return path;
}

static void
unlink_sockets(void)
{
	if (v2_socket.path[0])
		unlink(v2_socket.path);
	if (v1_socket.path[0])
		unlink(v1_socket.path);
}

static int
create_socket(char *path)
{
	int sock = socket(AF_UNIX, SOCK_SEQPACKET, 0);
	if (sock < 0) {
		snprintf(telemetry_log_error, sizeof(telemetry_log_error),
				"Error with socket creation, %s",
				strerror(errno));
		return -1;
	}

	struct sockaddr_un sun = {.sun_family = AF_UNIX};
	strlcpy(sun.sun_path, path, sizeof(sun.sun_path));
	unlink(sun.sun_path);
	if (bind(sock, (void *) &sun, sizeof(sun)) < 0) {
		snprintf(telemetry_log_error, sizeof(telemetry_log_error),
				"Error binding socket: %s",
				strerror(errno));
		sun.sun_path[0] = 0;
		goto error;
	}

	if (listen(sock, 1) < 0) {
		snprintf(telemetry_log_error, sizeof(telemetry_log_error),
				"Error calling listen for socket: %s",
				strerror(errno));
		goto error;
	}

	return sock;

error:
	close(sock);
	unlink_sockets();
	return -1;
}

static int
telemetry_legacy_init(const char *runtime_dir, rte_cpuset_t *cpuset)
{
	pthread_t t_old;

	if (num_legacy_callbacks == 1) {
		snprintf(telemetry_log_error, sizeof(telemetry_log_error),
			 "No legacy callbacks, legacy socket not created");
		return -1;
	}

	v1_socket.fn = legacy_client_handler;
	if ((size_t) snprintf(v1_socket.path, sizeof(v1_socket.path),
			"%s/telemetry", runtime_dir)
			>= sizeof(v1_socket.path)) {
		snprintf(telemetry_log_error, sizeof(telemetry_log_error),
				"Error with socket binding, path too long");
		return -1;
	}
	v1_socket.sock = create_socket(v1_socket.path);
	if (v1_socket.sock < 0)
		return -1;
	pthread_create(&t_old, NULL, socket_listener, &v1_socket);
	pthread_setaffinity_np(t_old, sizeof(*cpuset), cpuset);

	return 0;
}

static int
telemetry_v2_init(const char *runtime_dir, rte_cpuset_t *cpuset)
{
	pthread_t t_new;

	rte_telemetry_register_cmd("/", list_commands,
			"Returns list of available commands, Takes no parameters");
	rte_telemetry_register_cmd("/info", json_info,
			"Returns DPDK Telemetry information. Takes no parameters");
	rte_telemetry_register_cmd("/help", command_help,
			"Returns help text for a command. Parameters: string command");
	v2_socket.fn = client_handler;
	if (strlcpy(v2_socket.path, get_socket_path(runtime_dir, 2),
			sizeof(v2_socket.path)) >= sizeof(v2_socket.path)) {
		snprintf(telemetry_log_error, sizeof(telemetry_log_error),
				"Error with socket binding, path too long");
		return -1;
	}

	v2_socket.sock = create_socket(v2_socket.path);
	if (v2_socket.sock < 0)
		return -1;
	pthread_create(&t_new, NULL, socket_listener, &v2_socket);
	pthread_setaffinity_np(t_new, sizeof(*cpuset), cpuset);
	atexit(unlink_sockets);

	return 0;
}

int32_t
rte_telemetry_init(const char *runtime_dir, rte_cpuset_t *cpuset,
		const char **err_str)
{
	if (telemetry_v2_init(runtime_dir, cpuset) != 0) {
		*err_str = telemetry_log_error;
		return -1;
	}
	if (telemetry_legacy_init(runtime_dir, cpuset) != 0) {
		*err_str = telemetry_log_error;
	}
	return 0;
}
Commit	Line	Data
f67539c2 TL	1	/* SPDX-License-Identifier: BSD-3-Clause
	2	* Copyright(c) 2020 Intel Corporation
	3	*/
	4
	5	#include <unistd.h>
	6	#include <pthread.h>
	7	#include <sys/socket.h>
	8	#include <sys/un.h>
	9	#include <dlfcn.h>
	10
	11	/* we won't link against libbsd, so just always use DPDKs-specific strlcpy */
	12	#undef RTE_USE_LIBBSD
	13	#include <rte_string_fns.h>
	14	#include <rte_common.h>
	15	#include <rte_spinlock.h>
	16	#include <rte_version.h>
	17
	18	#include "rte_telemetry.h"
	19	#include "telemetry_json.h"
	20	#include "telemetry_data.h"
	21	#include "rte_telemetry_legacy.h"
	22
	23	#define MAX_CMD_LEN 56
	24	#define MAX_HELP_LEN 64
	25	#define MAX_OUTPUT_LEN (1024 * 16)
	26
	27	static void *
	28	client_handler(void *socket);
	29
	30	struct cmd_callback {
	31	char cmd[MAX_CMD_LEN];
	32	telemetry_cb fn;
	33	char help[MAX_HELP_LEN];
	34	};
	35
	36	struct socket {
	37	int sock;
	38	char path[sizeof(((struct sockaddr_un *)0)->sun_path)];
	39	handler fn;
	40	};
	41	static struct socket v2_socket; /* socket for v2 telemetry */
	42	static struct socket v1_socket; /* socket for v1 telemetry */
	43	static char telemetry_log_error[1024]; /* Will contain error on init failure */
	44	/* list of command callbacks, with one command registered by default */
	45	static struct cmd_callback callbacks[TELEMETRY_MAX_CALLBACKS];
	46	static int num_callbacks; /* How many commands are registered */
	47	/* Used when accessing or modifying list of command callbacks */
	48	static rte_spinlock_t callback_sl = RTE_SPINLOCK_INITIALIZER;
	49
	50	int
	51	rte_telemetry_register_cmd(const char cmd, telemetry_cb fn, const char help)
	52	{
	53	int i = 0;
	54
	55	if (strlen(cmd) >= MAX_CMD_LEN \|\| fn == NULL \|\| cmd[0] != '/'
	56	\|\| strlen(help) >= MAX_HELP_LEN)
	57	return -EINVAL;
	58	if (num_callbacks >= TELEMETRY_MAX_CALLBACKS)
	59	return -ENOENT;
	60
	61	rte_spinlock_lock(&callback_sl);
	62	while (i < num_callbacks && strcmp(cmd, callbacks[i].cmd) > 0)
	63	i++;
	64	if (i != num_callbacks)
65	/* Move elements to keep the list alphabetical */
66	memmove(callbacks + i + 1, callbacks + i,
67	sizeof(struct cmd_callback) * (num_callbacks - i));
68
69	strlcpy(callbacks[i].cmd, cmd, MAX_CMD_LEN);
70	callbacks[i].fn = fn;
71	strlcpy(callbacks[i].help, help, MAX_HELP_LEN);
72	num_callbacks++;
73	rte_spinlock_unlock(&callback_sl);
74
75	return 0;
76	}
77
78	static int
79	list_commands(const char cmd __rte_unused, const char params __rte_unused,
80	struct rte_tel_data *d)
81	{
82	int i;
83
84	rte_tel_data_start_array(d, RTE_TEL_STRING_VAL);
85	for (i = 0; i < num_callbacks; i++)
86	rte_tel_data_add_array_string(d, callbacks[i].cmd);
87	return 0;
88	}
89
90	static int
91	json_info(const char cmd __rte_unused, const char params __rte_unused,
92	struct rte_tel_data *d)
93	{
94	rte_tel_data_start_dict(d);
95	rte_tel_data_add_dict_string(d, "version", rte_version());
96	rte_tel_data_add_dict_int(d, "pid", getpid());
97	rte_tel_data_add_dict_int(d, "max_output_len", MAX_OUTPUT_LEN);
98	return 0;
99	}
100
101	static int
102	command_help(const char cmd __rte_unused, const char params,
103	struct rte_tel_data *d)
104	{
105	int i;
106
107	if (!params)
108	return -1;
109	rte_tel_data_start_dict(d);
110	rte_spinlock_lock(&callback_sl);
111	for (i = 0; i < num_callbacks; i++)
112	if (strcmp(params, callbacks[i].cmd) == 0) {
113	rte_tel_data_add_dict_string(d, params,
114	callbacks[i].help);
115	break;
116	}
117	rte_spinlock_unlock(&callback_sl);
118	if (i == num_callbacks)
119	return -1;
120	return 0;
121	}
122
123	static void
124	output_json(const char cmd, const struct rte_tel_data d, int s)
125	{
126	char out_buf[MAX_OUTPUT_LEN];
127
128	char *cb_data_buf;
129	size_t buf_len, prefix_used, used = 0;
130	unsigned int i;
131
132	RTE_BUILD_BUG_ON(sizeof(out_buf) < MAX_CMD_LEN +
133	RTE_TEL_MAX_SINGLE_STRING_LEN + 10);
134	switch (d->type) {
135	case RTE_TEL_NULL:
136	used = snprintf(out_buf, sizeof(out_buf), "{\"%.*s\":null}",
137	MAX_CMD_LEN, cmd ? cmd : "none");
138	break;
139	case RTE_TEL_STRING:
140	used = snprintf(out_buf, sizeof(out_buf), "{\"%.s\":\"%.s\"}",
141	MAX_CMD_LEN, cmd,
142	RTE_TEL_MAX_SINGLE_STRING_LEN, d->data.str);
143	break;
144	case RTE_TEL_DICT:
145	prefix_used = snprintf(out_buf, sizeof(out_buf), "{\"%.*s\":",
146	MAX_CMD_LEN, cmd);
147	cb_data_buf = &out_buf[prefix_used];
148	buf_len = sizeof(out_buf) - prefix_used - 1; /* space for '}' */
149
150	used = rte_tel_json_empty_obj(cb_data_buf, buf_len, 0);
151	for (i = 0; i < d->data_len; i++) {
152	const struct tel_dict_entry *v = &d->data.dict[i];
153	switch (v->type) {
154	case RTE_TEL_STRING_VAL:
155	used = rte_tel_json_add_obj_str(cb_data_buf,
156	buf_len, used,
157	v->name, v->value.sval);
158	break;
159	case RTE_TEL_INT_VAL:
160	used = rte_tel_json_add_obj_int(cb_data_buf,
161	buf_len, used,
162	v->name, v->value.ival);
163	break;
164	case RTE_TEL_U64_VAL:
165	used = rte_tel_json_add_obj_u64(cb_data_buf,
166	buf_len, used,
167	v->name, v->value.u64val);
168	break;
169	}
170	}
171	used += prefix_used;
172	used += strlcat(out_buf + used, "}", sizeof(out_buf) - used);
173	break;
174	case RTE_TEL_ARRAY_STRING:
175	case RTE_TEL_ARRAY_INT:
176	case RTE_TEL_ARRAY_U64:
177	prefix_used = snprintf(out_buf, sizeof(out_buf), "{\"%.*s\":",
178	MAX_CMD_LEN, cmd);
179	cb_data_buf = &out_buf[prefix_used];
180	buf_len = sizeof(out_buf) - prefix_used - 1; /* space for '}' */
181
182	used = rte_tel_json_empty_array(cb_data_buf, buf_len, 0);
183	for (i = 0; i < d->data_len; i++)
184	if (d->type == RTE_TEL_ARRAY_STRING)
185	used = rte_tel_json_add_array_string(
186	cb_data_buf,
187	buf_len, used,
188	d->data.array[i].sval);
189	else if (d->type == RTE_TEL_ARRAY_INT)
190	used = rte_tel_json_add_array_int(cb_data_buf,
191	buf_len, used,
192	d->data.array[i].ival);
193	else if (d->type == RTE_TEL_ARRAY_U64)
194	used = rte_tel_json_add_array_u64(cb_data_buf,
195	buf_len, used,
196	d->data.array[i].u64val);
197	used += prefix_used;
198	used += strlcat(out_buf + used, "}", sizeof(out_buf) - used);
199	break;
200	}
201	if (write(s, out_buf, used) < 0)
202	perror("Error writing to socket");
203	}
204
205	static void
206	perform_command(telemetry_cb fn, const char cmd, const char param, int s)
207	{
208	struct rte_tel_data data;
209
210	int ret = fn(cmd, param, &data);
211	if (ret < 0) {
212	char out_buf[MAX_CMD_LEN + 10];
213	int used = snprintf(out_buf, sizeof(out_buf), "{\"%.*s\":null}",
214	MAX_CMD_LEN, cmd ? cmd : "none");
215	if (write(s, out_buf, used) < 0)
216	perror("Error writing to socket");
217	return;
218	}
219	output_json(cmd, &data, s);
220	}
221
222	static int
223	unknown_command(const char cmd __rte_unused, const char params __rte_unused,
224	struct rte_tel_data *d)
225	{
226	return d->type = RTE_TEL_NULL;
227	}
228
229	static void *
230	client_handler(void *sock_id)
231	{
232	int s = (int)(uintptr_t)sock_id;
233	char buffer[1024];
234	char info_str[1024];
235	snprintf(info_str, sizeof(info_str),
236	"{\"version\":\"%s\",\"pid\":%d,\"max_output_len\":%d}",
237	rte_version(), getpid(), MAX_OUTPUT_LEN);
238	if (write(s, info_str, strlen(info_str)) < 0) {
239	close(s);
240	return NULL;
241	}
242
243	/* receive data is not null terminated */
244	int bytes = read(s, buffer, sizeof(buffer) - 1);
245	while (bytes > 0) {
246	buffer[bytes] = 0;
247	const char *cmd = strtok(buffer, ",");
248	const char *param = strtok(NULL, ",");
249	telemetry_cb fn = unknown_command;
250	int i;
251
252	if (cmd && strlen(cmd) < MAX_CMD_LEN) {
253	rte_spinlock_lock(&callback_sl);
254	for (i = 0; i < num_callbacks; i++)
255	if (strcmp(cmd, callbacks[i].cmd) == 0) {
256	fn = callbacks[i].fn;
257	break;
258	}
259	rte_spinlock_unlock(&callback_sl);
260	}
261	perform_command(fn, cmd, param, s);
262
263	bytes = read(s, buffer, sizeof(buffer) - 1);
264	}
265	close(s);
266	return NULL;
267	}
268
269	static void *
270	socket_listener(void *socket)
271	{
272	while (1) {
273	pthread_t th;
274	struct socket s = (struct socket )socket;
275	int s_accepted = accept(s->sock, NULL, NULL);
276	if (s_accepted < 0) {
277	snprintf(telemetry_log_error,
278	sizeof(telemetry_log_error),
279	"Error with accept, telemetry thread quitting");
280	return NULL;
281	}
282	pthread_create(&th, NULL, s->fn, (void *)(uintptr_t)s_accepted);
283	pthread_detach(th);
284	}
285	return NULL;
286	}
287
288	static inline char *
289	get_socket_path(const char *runtime_dir, const int version)
290	{
291	static char path[PATH_MAX];
292	snprintf(path, sizeof(path), "%s/dpdk_telemetry.v%d",
293	strlen(runtime_dir) ? runtime_dir : "/tmp", version);
294	return path;
295	}
296
297	static void
298	unlink_sockets(void)
299	{
300	if (v2_socket.path[0])
301	unlink(v2_socket.path);
302	if (v1_socket.path[0])
303	unlink(v1_socket.path);
304	}
305
306	static int
307	create_socket(char *path)
308	{
309	int sock = socket(AF_UNIX, SOCK_SEQPACKET, 0);
310	if (sock < 0) {
311	snprintf(telemetry_log_error, sizeof(telemetry_log_error),
312	"Error with socket creation, %s",
313	strerror(errno));
314	return -1;
315	}
316
317	struct sockaddr_un sun = {.sun_family = AF_UNIX};
318	strlcpy(sun.sun_path, path, sizeof(sun.sun_path));
319	unlink(sun.sun_path);
320	if (bind(sock, (void *) &sun, sizeof(sun)) < 0) {
321	snprintf(telemetry_log_error, sizeof(telemetry_log_error),
322	"Error binding socket: %s",
323	strerror(errno));
324	sun.sun_path[0] = 0;
325	goto error;
326	}
327
328	if (listen(sock, 1) < 0) {
329	snprintf(telemetry_log_error, sizeof(telemetry_log_error),
330	"Error calling listen for socket: %s",
331	strerror(errno));
332	goto error;
333	}
334
335	return sock;
336
337	error:
338	close(sock);
339	unlink_sockets();
340	return -1;
341	}
342
343	static int
344	telemetry_legacy_init(const char runtime_dir, rte_cpuset_t cpuset)
345	{
346	pthread_t t_old;
347
348	if (num_legacy_callbacks == 1) {
349	snprintf(telemetry_log_error, sizeof(telemetry_log_error),
350	"No legacy callbacks, legacy socket not created");
351	return -1;
352	}
353
354	v1_socket.fn = legacy_client_handler;
355	if ((size_t) snprintf(v1_socket.path, sizeof(v1_socket.path),
356	"%s/telemetry", runtime_dir)
357	>= sizeof(v1_socket.path)) {
358	snprintf(telemetry_log_error, sizeof(telemetry_log_error),
359	"Error with socket binding, path too long");
360	return -1;
361	}
362	v1_socket.sock = create_socket(v1_socket.path);
363	if (v1_socket.sock < 0)
364	return -1;
365	pthread_create(&t_old, NULL, socket_listener, &v1_socket);
366	pthread_setaffinity_np(t_old, sizeof(*cpuset), cpuset);
367
368	return 0;
369	}
370
371	static int
372	telemetry_v2_init(const char runtime_dir, rte_cpuset_t cpuset)
373	{
374	pthread_t t_new;
375
376	rte_telemetry_register_cmd("/", list_commands,
377	"Returns list of available commands, Takes no parameters");
378	rte_telemetry_register_cmd("/info", json_info,
379	"Returns DPDK Telemetry information. Takes no parameters");
380	rte_telemetry_register_cmd("/help", command_help,
381	"Returns help text for a command. Parameters: string command");
382	v2_socket.fn = client_handler;
383	if (strlcpy(v2_socket.path, get_socket_path(runtime_dir, 2),
384	sizeof(v2_socket.path)) >= sizeof(v2_socket.path)) {
385	snprintf(telemetry_log_error, sizeof(telemetry_log_error),
386	"Error with socket binding, path too long");
387	return -1;
388	}
389
390	v2_socket.sock = create_socket(v2_socket.path);
391	if (v2_socket.sock < 0)
392	return -1;
393	pthread_create(&t_new, NULL, socket_listener, &v2_socket);
394	pthread_setaffinity_np(t_new, sizeof(*cpuset), cpuset);
395	atexit(unlink_sockets);
396
397	return 0;
398	}
399
400	int32_t
401	rte_telemetry_init(const char runtime_dir, rte_cpuset_t cpuset,
402	const char **err_str)
403	{
404	if (telemetry_v2_init(runtime_dir, cpuset) != 0) {
405	*err_str = telemetry_log_error;
406	return -1;
407	}
408	if (telemetry_legacy_init(runtime_dir, cpuset) != 0) {
409	*err_str = telemetry_log_error;
410	}
411	return 0;
412	}