lib/librte_telemetry/telemetry.c

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