d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

telemetry: support array values in data object

Browse Source 
Arrays of type uint64_t/int/string can now be included within an array
or dict. One level of embedded containers is supported. This is
necessary to allow for instances such as the ethdev queue stats to be
reported as a list of uint64_t values, rather than having multiple dict
entries with one uint64_t value for each queue stat.

The memory management APIs provided by telemetry simplify the memory
allocation/free aspect of the embedded container. The rte_tel_data_alloc
function is called in the library/app callback to return a pointer to a
container that has been allocated memory. When adding this container
to an array/dict, a parameter is passed to indicate if the memory
should be freed by telemetry after use. This will allow reuse of the
allocated memory if the library/app wishes to do so.

Signed-off-by: Ciara Power <ciara.power@intel.com>
Acked-by: Bruce Richardson <bruce.richardson@intel.com>
This commit is contained in:
Ciara Power 2020-09-23 12:12:26 +01:00 committed by Thomas Monjalon
parent 5514319e7b
commit c933bb5177
6 changed files with 221 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
lib/librte_telemetry/rte_telemetry.h
View File

@ -47,6 +47,7 @@ enum rte_tel_value_type {
RTE_TEL_STRING_VAL, /** a string value */
RTE_TEL_INT_VAL, /** a signed 32-bit int value */
RTE_TEL_U64_VAL, /** an unsigned 64-bit int value */
RTE_TEL_CONTAINER, /** a container struct */
};
/**
@ -137,6 +138,28 @@ __rte_experimental
int
rte_tel_data_add_array_u64(struct rte_tel_data *d, uint64_t x);
/**
* Add a container to an array. A container is an existing telemetry data
* array. The array the container is to be added to must have been started by
* rte_tel_data_start_array() with RTE_TEL_CONTAINER as the type parameter.
* The container type must be an array of type uint64_t/int/string.
*
* @param d
* The data structure passed to the callback
* @param val
* The pointer to the container to be stored in the array.
* @param keep
* Flag to indicate that the container memory should not be automatically
* freed by the telemetry library once it has finished with the data.
* 1 = keep, 0 = free.
* @return
* 0 on success, negative errno on error
*/
__rte_experimental
int
rte_tel_data_add_array_container(struct rte_tel_data *d,
struct rte_tel_data *val, int keep);
/**
* Add a string value to a dictionary.
* The dict must have been started by rte_tel_data_start_dict().
@ -191,6 +214,30 @@ int
rte_tel_data_add_dict_u64(struct rte_tel_data *d,
const char *name, uint64_t val);
/**
* Add a container to a dictionary. A container is an existing telemetry data
* array. The dict the container is to be added to must have been started by
* rte_tel_data_start_dict(). The container must be an array of type
* uint64_t/int/string.
*
* @param d
* The data structure passed to the callback
* @param name
* The name the value is to be stored under in the dict.
* @param val
* The pointer to the container to be stored in the dict.
* @param keep
* Flag to indicate that the container memory should not be automatically
* freed by the telemetry library once it has finished with the data.
* 1 = keep, 0 = free.
* @return
* 0 on success, negative errno on error
*/
__rte_experimental
int
rte_tel_data_add_dict_container(struct rte_tel_data *d, const char *name,
struct rte_tel_data *val, int keep);
/**
* This telemetry callback is used when registering a telemetry command.
* It handles getting and formatting information to be returned to telemetry
@ -265,4 +312,27 @@ int
rte_telemetry_init(const char *runtime_dir, rte_cpuset_t *cpuset,
const char **err_str);
/**
* Get a pointer to a container with memory allocated. The container is to be
* used embedded within an existing telemetry dict/array.
*
* @return
* Pointer to a container.
*/
__rte_experimental
struct rte_tel_data *
rte_tel_data_alloc(void);
/**
* @internal
* Free a container that has memory allocated.
*
* @param data
* Pointer to container.
*.
*/
__rte_experimental
void
rte_tel_data_free(struct rte_tel_data *data);
#endif

4
lib/librte_telemetry/rte_telemetry_version.map
View File

@ -1,12 +1,16 @@
EXPERIMENTAL {
global:
rte_tel_data_add_array_container;
rte_tel_data_add_array_int;
rte_tel_data_add_array_string;
rte_tel_data_add_array_u64;
rte_tel_data_add_dict_container;
rte_tel_data_add_dict_int;
rte_tel_data_add_dict_string;
rte_tel_data_add_dict_u64;
rte_tel_data_alloc;
rte_tel_data_free;
rte_tel_data_start_array;
rte_tel_data_start_dict;
rte_tel_data_string;

56
lib/librte_telemetry/telemetry.c
View File

@ -133,6 +133,35 @@ command_help(const char *cmd __rte_unused, const char *params,
return 0;
}
static int
container_to_json(const struct rte_tel_data *d, char *out_buf, size_t buf_len)
{
size_t used = 0;
unsigned int i;
if (d->type != RTE_TEL_ARRAY_U64 && d->type != RTE_TEL_ARRAY_INT
&& d->type != RTE_TEL_ARRAY_STRING)
return snprintf(out_buf, buf_len, "null");
used = rte_tel_json_empty_array(out_buf, buf_len, 0);
if (d->type == RTE_TEL_ARRAY_U64)
for (i = 0; i < d->data_len; i++)
used = rte_tel_json_add_array_u64(out_buf,
buf_len, used,
d->data.array[i].u64val);
if (d->type == RTE_TEL_ARRAY_INT)
for (i = 0; i < d->data_len; i++)
used = rte_tel_json_add_array_int(out_buf,
buf_len, used,
d->data.array[i].ival);
if (d->type == RTE_TEL_ARRAY_STRING)
for (i = 0; i < d->data_len; i++)
used = rte_tel_json_add_array_string(out_buf,
buf_len, used,
d->data.array[i].sval);
return used;
}
static void
output_json(const char *cmd, const struct rte_tel_data *d, int s)
{
@ -179,6 +208,20 @@ output_json(const char *cmd, const struct rte_tel_data *d, int s)
buf_len, used,
v->name, v->value.u64val);
break;
case RTE_TEL_CONTAINER:
{
char temp[buf_len];
const struct container *cont =
&v->value.container;
if (container_to_json(cont->data,
temp, buf_len) != 0)
used = rte_tel_json_add_obj_json(
cb_data_buf,
buf_len, used,
v->name, temp);
if (!cont->keep)
rte_tel_data_free(cont->data);
}
}
}
used += prefix_used;
@ -187,6 +230,7 @@ output_json(const char *cmd, const struct rte_tel_data *d, int s)
case RTE_TEL_ARRAY_STRING:
case RTE_TEL_ARRAY_INT:
case RTE_TEL_ARRAY_U64:
case RTE_TEL_ARRAY_CONTAINER:
prefix_used = snprintf(out_buf, sizeof(out_buf), "{\"%.*s\":",
MAX_CMD_LEN, cmd);
cb_data_buf = &out_buf[prefix_used];
@ -207,6 +251,18 @@ output_json(const char *cmd, const struct rte_tel_data *d, int s)
used = rte_tel_json_add_array_u64(cb_data_buf,
buf_len, used,
d->data.array[i].u64val);
else if (d->type == RTE_TEL_ARRAY_CONTAINER) {
char temp[buf_len];
const struct container *rec_data =
&d->data.array[i].container;
if (container_to_json(rec_data->data,
temp, buf_len) != 0)
used = rte_tel_json_add_array_json(
cb_data_buf,
buf_len, used, temp);
if (!rec_data->keep)
rte_tel_data_free(rec_data->data);
}
used += prefix_used;
used += strlcat(out_buf + used, "}", sizeof(out_buf) - used);
break;

51
lib/librte_telemetry/telemetry_data.c
View File

@ -14,6 +14,7 @@ rte_tel_data_start_array(struct rte_tel_data *d, enum rte_tel_value_type type)
RTE_TEL_ARRAY_STRING, /* RTE_TEL_STRING_VAL = 0 */
RTE_TEL_ARRAY_INT, /* RTE_TEL_INT_VAL = 1 */
RTE_TEL_ARRAY_U64, /* RTE_TEL_u64_VAL = 2 */
RTE_TEL_ARRAY_CONTAINER, /* RTE_TEL_CONTAINER = 3 */
};
d->type = array_types[type];
d->data_len = 0;
@ -74,6 +75,23 @@ rte_tel_data_add_array_u64(struct rte_tel_data *d, uint64_t x)
return 0;
}
int
rte_tel_data_add_array_container(struct rte_tel_data *d,
struct rte_tel_data *val, int keep)
{
if (d->type != RTE_TEL_ARRAY_CONTAINER ||
(val->type != RTE_TEL_ARRAY_U64
&& val->type != RTE_TEL_ARRAY_INT
&& val->type != RTE_TEL_ARRAY_STRING))
return -EINVAL;
if (d->data_len >= RTE_TEL_MAX_ARRAY_ENTRIES)
return -ENOSPC;
d->data.array[d->data_len].container.data = val;
d->data.array[d->data_len++].container.keep = !!keep;
return 0;
}
int
rte_tel_data_add_dict_string(struct rte_tel_data *d, const char *name,
const char *val)
@ -128,3 +146,36 @@ rte_tel_data_add_dict_u64(struct rte_tel_data *d,
const size_t bytes = strlcpy(e->name, name, RTE_TEL_MAX_STRING_LEN);
return bytes < RTE_TEL_MAX_STRING_LEN ? 0 : E2BIG;
}
int
rte_tel_data_add_dict_container(struct rte_tel_data *d, const char *name,
struct rte_tel_data *val, int keep)
{
struct tel_dict_entry *e = &d->data.dict[d->data_len];
if (d->type != RTE_TEL_DICT || (val->type != RTE_TEL_ARRAY_U64
&& val->type != RTE_TEL_ARRAY_INT
&& val->type != RTE_TEL_ARRAY_STRING))
return -EINVAL;
if (d->data_len >= RTE_TEL_MAX_DICT_ENTRIES)
return -ENOSPC;
d->data_len++;
e->type = RTE_TEL_CONTAINER;
e->value.container.data = val;
e->value.container.keep = !!keep;
const size_t bytes = strlcpy(e->name, name, RTE_TEL_MAX_STRING_LEN);
return bytes < RTE_TEL_MAX_STRING_LEN ? 0 : E2BIG;
}
struct rte_tel_data *
rte_tel_data_alloc(void)
{
return malloc(sizeof(struct rte_tel_data));
}
void
rte_tel_data_free(struct rte_tel_data *data)
{
free(data);
}

7
lib/librte_telemetry/telemetry_data.h
View File

@ -15,6 +15,12 @@ enum tel_container_types {
RTE_TEL_ARRAY_STRING, /** array of string values only */
RTE_TEL_ARRAY_INT, /** array of signed, 32-bit int values */
RTE_TEL_ARRAY_U64, /** array of unsigned 64-bit int values */
RTE_TEL_ARRAY_CONTAINER, /** array of container structs */
};
struct container {
struct rte_tel_data *data;
int keep;
};
/* each type here must have an equivalent enum in the value types enum in
@ -25,6 +31,7 @@ union tel_value {
char sval[RTE_TEL_MAX_STRING_LEN];
int ival;
uint64_t u64val;
struct container container;
};
struct tel_dict_entry {

33
lib/librte_telemetry/telemetry_json.h
View File

@ -102,6 +102,22 @@ rte_tel_json_add_array_u64(char *buf, const int len, const int used,
return ret == 0 ? used : end + ret;
}
/*
* Add a new element with raw JSON value to the JSON array stored in the
* provided buffer.
*/
static inline int
rte_tel_json_add_array_json(char *buf, const int len, const int used,
const char *str)
{
int ret, end = used - 1; /* strip off final delimiter */
if (used <= 2) /* assume empty, since minimum is '[]' */
return __json_snprintf(buf, len, "[%s]", str);
ret = __json_snprintf(buf + end, len - end, ",%s]", str);
return ret == 0 ? used : end + ret;
}
/**
* Add a new element with uint64_t value to the JSON object stored in the
* provided buffer.
@ -155,4 +171,21 @@ rte_tel_json_add_obj_str(char *buf, const int len, const int used,
return ret == 0 ? used : end + ret;
}
/**
* Add a new element with raw JSON value to the JSON object stored in the
* provided buffer.
*/
static inline int
rte_tel_json_add_obj_json(char *buf, const int len, const int used,
const char *name, const char *val)
{
int ret, end = used - 1;
if (used <= 2) /* assume empty, since minimum is '{}' */
return __json_snprintf(buf, len, "{\"%s\":%s}", name, val);
ret = __json_snprintf(buf + end, len - end, ",\"%s\":%s}",
name, val);
return ret == 0 ? used : end + ret;
}
#endif /*_RTE_TELEMETRY_JSON_H_*/