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 #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 }