#include <jansson.h>
#include <rte_eal.h>
-#include <rte_ethdev.h>
#include <rte_metrics.h>
#include <rte_option.h>
#include <rte_string_fns.h>
+#include <rte_lcore.h>
#include "rte_telemetry.h"
#include "rte_telemetry_internal.h"
#include "rte_telemetry_parser.h"
-#include "rte_telemetry_parser_test.h"
#include "rte_telemetry_socket_tests.h"
#define BUF_SIZE 1024
static telemetry_impl *static_telemetry;
struct telemetry_message_test {
- char *test_name;
+ const char *test_name;
int (*test_func_ptr)(struct telemetry_impl *telemetry, int fd);
};
struct json_data {
char *status_code;
- char *data;
+ const char *data;
int port;
char *stat_name;
int stat_value;
};
-static void
-rte_telemetry_get_runtime_dir(char *socket_path, size_t size)
-{
- snprintf(socket_path, size, "%s/telemetry", rte_eal_get_runtime_dir());
-}
+/* global array of functions pointers to metrics library */
+const struct metrics_functions *metrics_fns;
-int32_t
-rte_telemetry_is_port_active(int port_id)
+void
+rte_telemetry_set_metrics_fns(const struct metrics_functions *fns)
{
- int ret;
-
- ret = rte_eth_find_next(port_id);
- if (ret == port_id)
- return 1;
-
- TELEMETRY_LOG_ERR("port_id: %d is invalid, not active",
- port_id);
-
- return 0;
+ metrics_fns = fns;
}
-static int32_t
-rte_telemetry_update_metrics_ethdev(struct telemetry_impl *telemetry,
- uint16_t port_id, int reg_start_index)
+static void
+rte_telemetry_get_runtime_dir(char *socket_path, size_t size)
{
- int ret, num_xstats, i;
- struct rte_eth_xstat *eth_xstats;
-
- if (!rte_eth_dev_is_valid_port(port_id)) {
- TELEMETRY_LOG_ERR("port_id: %d is invalid", port_id);
- ret = rte_telemetry_send_error_response(telemetry, -EINVAL);
- if (ret < 0)
- TELEMETRY_LOG_ERR("Could not send error");
- return -1;
- }
-
- ret = rte_telemetry_is_port_active(port_id);
- if (ret < 1) {
- ret = rte_telemetry_send_error_response(telemetry, -EINVAL);
- if (ret < 0)
- TELEMETRY_LOG_ERR("Could not send error");
- return -1;
- }
-
- num_xstats = rte_eth_xstats_get(port_id, NULL, 0);
- if (num_xstats < 0) {
- TELEMETRY_LOG_ERR("rte_eth_xstats_get(%u) failed: %d", port_id,
- num_xstats);
- ret = rte_telemetry_send_error_response(telemetry, -EPERM);
- if (ret < 0)
- TELEMETRY_LOG_ERR("Could not send error");
- return -1;
- }
-
- eth_xstats = malloc(sizeof(struct rte_eth_xstat) * num_xstats);
- if (eth_xstats == NULL) {
- TELEMETRY_LOG_ERR("Failed to malloc memory for xstats");
- ret = rte_telemetry_send_error_response(telemetry, -ENOMEM);
- if (ret < 0)
- TELEMETRY_LOG_ERR("Could not send error");
- return -1;
- }
-
- ret = rte_eth_xstats_get(port_id, eth_xstats, num_xstats);
- if (ret < 0 || ret > num_xstats) {
- free(eth_xstats);
- TELEMETRY_LOG_ERR("rte_eth_xstats_get(%u) len%i failed: %d",
- port_id, num_xstats, ret);
- ret = rte_telemetry_send_error_response(telemetry, -EPERM);
- if (ret < 0)
- TELEMETRY_LOG_ERR("Could not send error");
- return -1;
- }
-
- uint64_t xstats_values[num_xstats];
- for (i = 0; i < num_xstats; i++)
- xstats_values[i] = eth_xstats[i].value;
-
- ret = rte_metrics_update_values(port_id, reg_start_index, xstats_values,
- num_xstats);
- if (ret < 0) {
- TELEMETRY_LOG_ERR("Could not update metrics values");
- ret = rte_telemetry_send_error_response(telemetry, -EPERM);
- if (ret < 0)
- TELEMETRY_LOG_ERR("Could not send error");
- free(eth_xstats);
- return -1;
- }
-
- free(eth_xstats);
- return 0;
+ snprintf(socket_path, size, "%s/telemetry", rte_eal_get_runtime_dir());
}
-int32_t
+static int32_t
rte_telemetry_write_to_socket(struct telemetry_impl *telemetry,
const char *json_string)
{
return 0;
}
-static int
-rte_telemetry_get_metrics(struct telemetry_impl *telemetry, uint32_t port_id,
- struct rte_metric_value *metrics, struct rte_metric_name *names,
- int num_metrics)
-{
- int ret, num_values;
-
- if (num_metrics < 0) {
- TELEMETRY_LOG_ERR("Invalid metrics count");
- goto einval_fail;
- } else if (num_metrics == 0) {
- TELEMETRY_LOG_ERR("No metrics to display (none have been registered)");
- goto eperm_fail;
- }
-
- if (metrics == NULL) {
- TELEMETRY_LOG_ERR("Metrics must be initialised.");
- goto einval_fail;
- }
-
- if (names == NULL) {
- TELEMETRY_LOG_ERR("Names must be initialised.");
- goto einval_fail;
- }
-
- ret = rte_metrics_get_names(names, num_metrics);
- if (ret < 0 || ret > num_metrics) {
- TELEMETRY_LOG_ERR("Cannot get metrics names");
- goto eperm_fail;
- }
-
- num_values = rte_metrics_get_values(port_id, NULL, 0);
- ret = rte_metrics_get_values(port_id, metrics, num_values);
- if (ret < 0 || ret > num_values) {
- TELEMETRY_LOG_ERR("Cannot get metrics values");
- goto eperm_fail;
- }
-
- return 0;
-
-eperm_fail:
- ret = rte_telemetry_send_error_response(telemetry, -EPERM);
- if (ret < 0)
- TELEMETRY_LOG_ERR("Could not send error");
- return -1;
-
-einval_fail:
- ret = rte_telemetry_send_error_response(telemetry, -EINVAL);
- if (ret < 0)
- TELEMETRY_LOG_ERR("Could not send error");
- return -1;
-
-}
-
-static int32_t
-rte_telemetry_json_format_stat(struct telemetry_impl *telemetry, json_t *stats,
- const char *metric_name, uint64_t metric_value)
+int32_t
+rte_telemetry_send_global_stats_values(struct telemetry_encode_param *ep,
+ struct telemetry_impl *telemetry)
{
int ret;
- json_t *stat = json_object();
-
- if (stat == NULL) {
- TELEMETRY_LOG_ERR("Could not create stat JSON object");
- goto eperm_fail;
- }
-
- ret = json_object_set_new(stat, "name", json_string(metric_name));
- if (ret < 0) {
- TELEMETRY_LOG_ERR("Stat Name field cannot be set");
- goto eperm_fail;
- }
+ char *json_buffer = NULL;
- ret = json_object_set_new(stat, "value", json_integer(metric_value));
- if (ret < 0) {
- TELEMETRY_LOG_ERR("Stat Value field cannot be set");
- goto eperm_fail;
+ if (telemetry == NULL) {
+ TELEMETRY_LOG_ERR("Invalid telemetry argument");
+ return -1;
}
- ret = json_array_append_new(stats, stat);
+ ret = metrics_fns->encode_json_format(ep, &json_buffer);
if (ret < 0) {
- TELEMETRY_LOG_ERR("Stat cannot be added to stats json array");
- goto eperm_fail;
- }
-
- return 0;
-
-eperm_fail:
- ret = rte_telemetry_send_error_response(telemetry, -EPERM);
- if (ret < 0)
- TELEMETRY_LOG_ERR("Could not send error");
- return -1;
-
-}
-
-static int32_t
-rte_telemetry_json_format_port(struct telemetry_impl *telemetry,
- uint32_t port_id, json_t *ports, uint32_t *metric_ids,
- uint32_t num_metric_ids)
-{
- struct rte_metric_value *metrics = 0;
- struct rte_metric_name *names = 0;
- int num_metrics, ret, err_ret;
- json_t *port, *stats;
- uint32_t i;
-
- num_metrics = rte_metrics_get_names(NULL, 0);
- if (num_metrics < 0) {
- TELEMETRY_LOG_ERR("Cannot get metrics count");
- goto einval_fail;
- } else if (num_metrics == 0) {
- TELEMETRY_LOG_ERR("No metrics to display (none have been registered)");
- goto eperm_fail;
- }
-
- metrics = malloc(sizeof(struct rte_metric_value) * num_metrics);
- names = malloc(sizeof(struct rte_metric_name) * num_metrics);
- if (metrics == NULL || names == NULL) {
- TELEMETRY_LOG_ERR("Cannot allocate memory");
- free(metrics);
- free(names);
-
- err_ret = rte_telemetry_send_error_response(telemetry, -ENOMEM);
- if (err_ret < 0)
+ TELEMETRY_LOG_ERR("JSON encode function failed");
+ ret = rte_telemetry_send_error_response(telemetry, ret);
+ if (ret < 0)
TELEMETRY_LOG_ERR("Could not send error");
return -1;
}
- ret = rte_telemetry_get_metrics(telemetry, port_id, metrics, names,
- num_metrics);
+ ret = rte_telemetry_write_to_socket(telemetry, json_buffer);
if (ret < 0) {
- free(metrics);
- free(names);
- TELEMETRY_LOG_ERR("rte_telemetry_get_metrics failed");
+ TELEMETRY_LOG_ERR("Could not write to socket");
return -1;
}
- port = json_object();
- stats = json_array();
- if (port == NULL || stats == NULL) {
- TELEMETRY_LOG_ERR("Could not create port/stats JSON objects");
- goto eperm_fail;
- }
-
- ret = json_object_set_new(port, "port", json_integer(port_id));
- if (ret < 0) {
- TELEMETRY_LOG_ERR("Port field cannot be set");
- goto eperm_fail;
- }
-
- for (i = 0; i < num_metric_ids; i++) {
- int metric_id = metric_ids[i];
- int metric_index = -1;
- int metric_name_key = -1;
- int32_t j;
- uint64_t metric_value;
-
- if (metric_id >= num_metrics) {
- TELEMETRY_LOG_ERR("Metric_id: %d is not valid",
- metric_id);
- goto einval_fail;
- }
-
- for (j = 0; j < num_metrics; j++) {
- if (metrics[j].key == metric_id) {
- metric_name_key = metrics[j].key;
- metric_index = j;
- break;
- }
- }
-
- const char *metric_name = names[metric_name_key].name;
- metric_value = metrics[metric_index].value;
-
- if (metric_name_key < 0 || metric_index < 0) {
- TELEMETRY_LOG_ERR("Could not get metric name/index");
- goto eperm_fail;
- }
-
- ret = rte_telemetry_json_format_stat(telemetry, stats,
- metric_name, metric_value);
- if (ret < 0) {
- TELEMETRY_LOG_ERR("Format stat with id: %u failed",
- metric_id);
- free(metrics);
- free(names);
- return -1;
- }
- }
-
- if (json_array_size(stats) == 0)
- ret = json_object_set_new(port, "stats", json_null());
- else
- ret = json_object_set_new(port, "stats", stats);
-
- if (ret < 0) {
- TELEMETRY_LOG_ERR("Stats object cannot be set");
- goto eperm_fail;
- }
-
- ret = json_array_append_new(ports, port);
- if (ret < 0) {
- TELEMETRY_LOG_ERR("Port object cannot be added to ports array");
- goto eperm_fail;
- }
-
- free(metrics);
- free(names);
return 0;
-
-eperm_fail:
- free(metrics);
- free(names);
- ret = rte_telemetry_send_error_response(telemetry, -EPERM);
- if (ret < 0)
- TELEMETRY_LOG_ERR("Could not send error");
- return -1;
-
-einval_fail:
- free(metrics);
- free(names);
- ret = rte_telemetry_send_error_response(telemetry, -EINVAL);
- if (ret < 0)
- TELEMETRY_LOG_ERR("Could not send error");
- return -1;
-}
-
-static int32_t
-rte_telemetry_encode_json_format(struct telemetry_impl *telemetry,
- uint32_t *port_ids, uint32_t num_port_ids, uint32_t *metric_ids,
- uint32_t num_metric_ids, char **json_buffer)
-{
- int ret;
- json_t *root, *ports;
- uint32_t i;
-
- if (num_port_ids <= 0 || num_metric_ids <= 0) {
- TELEMETRY_LOG_ERR("Please provide port and metric ids to query");
- goto einval_fail;
- }
-
- ports = json_array();
- if (ports == NULL) {
- TELEMETRY_LOG_ERR("Could not create ports JSON array");
- goto eperm_fail;
- }
-
- for (i = 0; i < num_port_ids; i++) {
- if (!rte_eth_dev_is_valid_port(port_ids[i])) {
- TELEMETRY_LOG_ERR("Port: %d invalid", port_ids[i]);
- goto einval_fail;
- }
- }
-
- for (i = 0; i < num_port_ids; i++) {
- ret = rte_telemetry_json_format_port(telemetry, port_ids[i],
- ports, metric_ids, num_metric_ids);
- if (ret < 0) {
- TELEMETRY_LOG_ERR("Format port in JSON failed");
- return -1;
- }
- }
-
- root = json_object();
- if (root == NULL) {
- TELEMETRY_LOG_ERR("Could not create root JSON object");
- goto eperm_fail;
- }
-
- ret = json_object_set_new(root, "status_code",
- json_string("Status OK: 200"));
- if (ret < 0) {
- TELEMETRY_LOG_ERR("Status code field cannot be set");
- goto eperm_fail;
- }
-
- ret = json_object_set_new(root, "data", ports);
- if (ret < 0) {
- TELEMETRY_LOG_ERR("Data field cannot be set");
- goto eperm_fail;
- }
-
- *json_buffer = json_dumps(root, JSON_INDENT(2));
- json_decref(root);
- return 0;
-
-eperm_fail:
- ret = rte_telemetry_send_error_response(telemetry, -EPERM);
- if (ret < 0)
- TELEMETRY_LOG_ERR("Could not send error");
- return -1;
-
-einval_fail:
- ret = rte_telemetry_send_error_response(telemetry, -EINVAL);
- if (ret < 0)
- TELEMETRY_LOG_ERR("Could not send error");
- return -1;
}
int32_t
-rte_telemetry_send_ports_stats_values(uint32_t *metric_ids, int num_metric_ids,
- uint32_t *port_ids, int num_port_ids, struct telemetry_impl *telemetry)
+rte_telemetry_send_ports_stats_values(struct telemetry_encode_param *ep,
+ struct telemetry_impl *telemetry)
{
- int ret, i;
+ int ret;
char *json_buffer = NULL;
if (telemetry == NULL) {
return -1;
}
- if (metric_ids == NULL) {
- TELEMETRY_LOG_ERR("Invalid metric_ids array");
+ if (ep == NULL) {
+ TELEMETRY_LOG_ERR("Invalid encode param argument");
goto einval_fail;
}
- if (num_metric_ids < 0) {
+ if (ep->pp.num_metric_ids < 0) {
TELEMETRY_LOG_ERR("Invalid num_metric_ids, must be positive");
goto einval_fail;
}
- if (port_ids == NULL) {
- TELEMETRY_LOG_ERR("Invalid port_ids array");
- goto einval_fail;
- }
-
- if (num_port_ids < 0) {
+ if (ep->pp.num_port_ids < 0) {
TELEMETRY_LOG_ERR("Invalid num_port_ids, must be positive");
goto einval_fail;
}
- for (i = 0; i < num_port_ids; i++) {
- if (!rte_eth_dev_is_valid_port(port_ids[i])) {
- TELEMETRY_LOG_ERR("Port: %d invalid", port_ids[i]);
- goto einval_fail;
- }
-
- ret = rte_telemetry_update_metrics_ethdev(telemetry,
- port_ids[i], telemetry->reg_index);
- if (ret < 0) {
- TELEMETRY_LOG_ERR("Failed to update ethdev metrics");
- return -1;
- }
- }
-
- ret = rte_telemetry_encode_json_format(telemetry, port_ids,
- num_port_ids, metric_ids, num_metric_ids, &json_buffer);
+ ret = metrics_fns->get_ports_stats_json(ep, telemetry->reg_index,
+ &json_buffer);
if (ret < 0) {
- TELEMETRY_LOG_ERR("JSON encode function failed");
+ TELEMETRY_LOG_ERR("Function for get_ports_stats_json"
+ " failed");
+ ret = rte_telemetry_send_error_response(telemetry, ret);
+ if (ret < 0)
+ TELEMETRY_LOG_ERR("Could not send error");
return -1;
}
return -1;
}
-
-static int32_t
-rte_telemetry_reg_ethdev_to_metrics(uint16_t port_id)
-{
- int ret, num_xstats, ret_val, i;
- struct rte_eth_xstat *eth_xstats = NULL;
- struct rte_eth_xstat_name *eth_xstats_names = NULL;
-
- if (!rte_eth_dev_is_valid_port(port_id)) {
- TELEMETRY_LOG_ERR("port_id: %d is invalid", port_id);
- return -EINVAL;
- }
-
- num_xstats = rte_eth_xstats_get(port_id, NULL, 0);
- if (num_xstats < 0) {
- TELEMETRY_LOG_ERR("rte_eth_xstats_get(%u) failed: %d",
- port_id, num_xstats);
- return -EPERM;
- }
-
- eth_xstats = malloc(sizeof(struct rte_eth_xstat) * num_xstats);
- if (eth_xstats == NULL) {
- TELEMETRY_LOG_ERR("Failed to malloc memory for xstats");
- return -ENOMEM;
- }
-
- ret = rte_eth_xstats_get(port_id, eth_xstats, num_xstats);
- const char *xstats_names[num_xstats];
- eth_xstats_names = malloc(sizeof(struct rte_eth_xstat_name) * num_xstats);
- if (ret < 0 || ret > num_xstats) {
- TELEMETRY_LOG_ERR("rte_eth_xstats_get(%u) len%i failed: %d",
- port_id, num_xstats, ret);
- ret_val = -EPERM;
- goto free_xstats;
- }
-
- if (eth_xstats_names == NULL) {
- TELEMETRY_LOG_ERR("Failed to malloc memory for xstats_names");
- ret_val = -ENOMEM;
- goto free_xstats;
- }
-
- ret = rte_eth_xstats_get_names(port_id, eth_xstats_names, num_xstats);
- if (ret < 0 || ret > num_xstats) {
- TELEMETRY_LOG_ERR("rte_eth_xstats_get_names(%u) len%i failed: %d",
- port_id, num_xstats, ret);
- ret_val = -EPERM;
- goto free_xstats;
- }
-
- for (i = 0; i < num_xstats; i++)
- xstats_names[i] = eth_xstats_names[eth_xstats[i].id].name;
-
- ret_val = rte_metrics_reg_names(xstats_names, num_xstats);
- if (ret_val < 0) {
- TELEMETRY_LOG_ERR("rte_metrics_reg_names failed - metrics may already be registered");
- ret_val = -1;
- goto free_xstats;
- }
-
- goto free_xstats;
-
-free_xstats:
- free(eth_xstats);
- free(eth_xstats_names);
- return ret_val;
-}
-
static int32_t
rte_telemetry_initial_accept(struct telemetry_impl *telemetry)
{
- uint16_t pid;
int ret;
int selftest = 0;
- RTE_ETH_FOREACH_DEV(pid) {
- telemetry->reg_index = rte_telemetry_reg_ethdev_to_metrics(pid);
- break;
- }
-
- if (telemetry->reg_index < 0) {
+ ret = metrics_fns->reg_all_ethdev(&telemetry->metrics_register_done,
+ telemetry->reg_index);
+ if (ret < 0) {
TELEMETRY_LOG_ERR("Failed to register ethdev metrics");
+ ret = rte_telemetry_send_error_response(telemetry, ret);
+ if (ret < 0)
+ TELEMETRY_LOG_ERR("Could not send error");
return -1;
}
- telemetry->metrics_register_done = 1;
if (selftest) {
- ret = rte_telemetry_socket_messaging_testing(telemetry->reg_index,
+ ret = rte_telemetry_socket_messaging_testing(telemetry->reg_index[0],
telemetry->server_fd);
if (ret < 0)
return -1;
return -1;
}
-int32_t __rte_experimental
-rte_telemetry_init()
+int32_t
+rte_telemetry_init(void)
{
int ret;
pthread_attr_t attr;
}
static_telemetry->socket_id = rte_socket_id();
- rte_metrics_init(static_telemetry->socket_id);
ret = pthread_attr_init(&attr);
if (ret != 0) {
return 0;
}
-int32_t __rte_experimental
+int32_t
rte_telemetry_cleanup(void)
{
int ret;
return -1;
}
-int32_t
+static int32_t
rte_telemetry_dummy_client_socket(const char *valid_client_path)
{
int sockfd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
return sockfd;
}
-int32_t __rte_experimental
+int32_t
rte_telemetry_selftest(void)
{
const char *invalid_client_path = SELFTEST_INVALID_CLIENT;
}
telemetry->server_fd = socket;
- telemetry->reg_index = index;
+ telemetry->reg_index[0] = index;
TELEMETRY_LOG_INFO("Beginning Telemetry socket message Selftest");
rte_telemetry_socket_test_setup(telemetry, &send_fd, &recv_fd);
TELEMETRY_LOG_INFO("Register valid client test");
int ret;
char buf[BUF_SIZE];
int fail_count = 0;
- char *status = "Status Error: Invalid Argument 404";
- char *data = "null";
+ const char *status = "Status Error: Invalid Argument 404";
+ const char *data = "null";
struct json_data *data_struct;
const char *invalid_contents = "{\"action\":0,\"command\":"
"\"ports_stats_values_by_name\",\"data\":{\"ports\""
char buf[BUF_SIZE];
int fail_count = 0;
const char *status = "Status Error: Invalid Argument 404";
- char *data = "null";
+ const char *data = "null";
struct json_data *data_struct;
const char *empty_json = "{}";
int buffer_read = 0;
int telemetry_log_level;
static struct rte_option option = {
- .opt_str = "--telemetry",
+ .name = "telemetry",
+ .usage = "Enable telemetry backend",
.cb = &rte_telemetry_init,
.enabled = 0
};
git.droids-corp.org / dpdk.git / blobdiff