Skip to contentSkip to conversation

trace: take live traces via telemetry

PATCH In review David Marchand 7 participants 23 messages Oct 13, 2022 – Oct 2, 2024

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 trace: take live traces via telemetry

Register telemetry commands to list and configure trace points and later save traces for a running DPDK application.

Note: trace point names contain a '.', so the list of valid characters used in telemetry commands and dictionary keys has been extended.

Example with testpmd running with two net/null ports (startup command from devtools/test-null.sh):

--> /trace/list,lib.ethdev.*
{"/trace/list": {"lib.ethdev.configure": "Disabled",

    "lib.ethdev.rxq.setup": "Disabled",
    "lib.ethdev.txq.setup": "Disabled",
    "lib.ethdev.start": "Disabled",
    "lib.ethdev.stop": "Disabled",
    "lib.ethdev.close": "Disabled",
    "lib.ethdev.rx.burst": "Disabled",
    "lib.ethdev.tx.burst": "Disabled"}}

--> /trace/enable,lib.ethdev.st*
{"/trace/enable": {"Count": 2}}
--> /trace/enable,lib.ethdev.st*
{"/trace/enable": {"Count": 0}}

--> /trace/list,lib.ethdev.*
{"/trace/list": {"lib.ethdev.configure": "Disabled",

    "lib.ethdev.rxq.setup": "Disabled",
    "lib.ethdev.txq.setup": "Disabled",
    "lib.ethdev.start": "Enabled",
    "lib.ethdev.stop": "Enabled",
    "lib.ethdev.close": "Disabled",
    "lib.ethdev.rx.burst": "Disabled",
    "lib.ethdev.tx.burst": "Disabled"}}

testpmd> stop
...
testpmd> port stop all
...
testpmd> port start all
...
testpmd> start
...

--> /trace/save
{"/trace/save": {"Status": "OK",

    "Path": ".../dpdk-traces/rte-2022-10-12-AM-10-51-48"}}
$ babeltrace .../dpdk-traces/rte-2022-10-12-AM-10-51-48
[10:51:36.229878723] (+?.?????????) lib.ethdev.stop:
    { cpu_id = 0x0, name = "dpdk-testpmd" }, { port_id = 0x0, ret = 0 }
[10:51:36.229880251] (+0.000001528) lib.ethdev.stop:
    { cpu_id = 0x0, name = "dpdk-testpmd" }, { port_id = 0x1, ret = 0 }
[10:51:40.449359774] (+4.219479523) lib.ethdev.start:
    { cpu_id = 0x0, name = "dpdk-testpmd" }, { port_id = 0x0 }
[10:51:40.449377877] (+0.000018103) lib.ethdev.start:
    { cpu_id = 0x0, name = "dpdk-testpmd" }, { port_id = 0x1 }

--> /trace/disable,*
{"/trace/disable": {"Count": 2}}

---
For runtime testing, please use this patch in addition with series 25183.
Depends-on: series-25183 ("Trace subsystem fixes")

---
 lib/eal/common/eal_common_trace.c | 78 +++++++++++++++++++++++++++++++
 lib/telemetry/telemetry_data.c    |  1 +
 2 files changed, 79 insertions(+)
lib/eal/common/eal_common_trace.c +78 -0
index f9b187d15f..9a54987b42 100644
@@ -12,6 +12,7 @@
 #include <rte_lcore.h>
 #include <rte_per_lcore.h>
 #include <rte_string_fns.h>
+#include <rte_telemetry.h>
 
 #include "eal_trace.h"
 
@@ -530,3 +531,80 @@ __rte_trace_point_register(rte_trace_point_t *handle, const char *name,
 
 	return -rte_errno;
 }
+
+static int
+trace_telemetry_enable(const char *cmd __rte_unused,
+	const char *params, struct rte_tel_data *d)
+{
+	unsigned int count;
+
+	if (params == NULL || strlen(params) == 0)
+		return -1;
+	rte_tel_data_start_dict(d);
+	count = __atomic_load_n(&trace.status, __ATOMIC_RELAXED);
+	rte_trace_pattern(params, true);
+	rte_tel_data_add_dict_int(d, "Count",
+		__atomic_load_n(&trace.status, __ATOMIC_RELAXED) - count);
+	return 0;
+
+}
+
+static int
+trace_telemetry_disable(const char *cmd __rte_unused,
+	const char *params, struct rte_tel_data *d)
+{
+	unsigned int count;
+
+	if (params == NULL || strlen(params) == 0)
+		return -1;
+	rte_tel_data_start_dict(d);
+	count = __atomic_load_n(&trace.status, __ATOMIC_RELAXED);
+	rte_trace_pattern(params, false);
+	rte_tel_data_add_dict_int(d, "Count",
+		count - __atomic_load_n(&trace.status, __ATOMIC_RELAXED));
+	return 0;
+
+}
+
+static int
+trace_telemetry_list(const char *cmd __rte_unused,
+	const char *params, struct rte_tel_data *d)
+{
+	struct trace_point *tp;
+
+	rte_tel_data_start_dict(d);
+	STAILQ_FOREACH(tp, &tp_list, next) {
+		if (params != NULL && fnmatch(params, tp->name, 0) != 0)
+			continue;
+
+		rte_tel_data_add_dict_string(d, tp->name,
+			rte_trace_point_is_enabled(tp->handle) ?  "Enabled" : "Disabled");
+	}
+
+	return 0;
+}
+
+static int
+trace_telemetry_save(const char *cmd __rte_unused,
+	const char *params __rte_unused, struct rte_tel_data *d)
+{
+	struct trace *trace = trace_obj_get();
+
+	rte_tel_data_start_dict(d);
+	rte_tel_data_add_dict_string(d, "Status", rte_trace_save() == 0 ? "OK" : "KO");
+	rte_tel_data_add_dict_string(d, "Path", trace->dir);
+
+	return 0;
+}
+
+RTE_INIT(trace_telemetry)
+{
+	rte_telemetry_register_cmd("/trace/enable", trace_telemetry_enable,
+		"Enable trace points matching the provided pattern. Parameters: string pattern.");
+	rte_telemetry_register_cmd("/trace/disable", trace_telemetry_disable,
+		"Disable trace points matching the provided pattern. Parameters: string pattern.");
+	rte_telemetry_register_cmd("/trace/list", trace_telemetry_list,
+		"List trace points. Parameters: string pattern.");
+	rte_telemetry_register_cmd("/trace/save", trace_telemetry_save,
+		"Save current traces. Takes no parameter.");
+}
lib/telemetry/telemetry_data.c +1 -0
index 34366ecee3..5b319c18fb 100644
@@ -106,6 +106,7 @@ valid_name(const char *name)
 			['a' ... 'z'] = 1,
 			['_'] = 1,
 			['/'] = 1,
+			['.'] = 1,
 	};
 	while (*name != '\0') {
 		if ((size_t)*name >= RTE_DIM(allowed) || allowed[(int)*name] == 0)
Signature · 1 line
2.37.3
Acked-by on v1 1/1
#1 lore raw
Quoted 1 line · David Marchand

I would suggest to change the subject as "trace: enable trace operations via telemetry" or so

Quoted 19 lines

Register telemetry commands to list and configure trace points and later save traces for a running DPDK application.

Note: trace point names contain a '.', so the list of valid characters used in telemetry commands and dictionary keys has been extended.

Example with testpmd running with two net/null ports (startup command from devtools/test-null.sh):

--> /trace/disable,*
{"/trace/disable": {"Count": 2}}

lib/eal/common/eal_common_trace.c +5 -0
+}
+
+static int
+trace_telemetry_list(const char *cmd __rte_unused,
+       const char *params, struct rte_tel_data *d)

lib/eal/common/eal_common_trace.c __rte_trace_point_register(rte_trace_point_t *handle, const char *name, · line 581

Quoted 10 lines
lib/eal/common/eal_common_trace.c +10 -0
+{
+       struct trace_point *tp;
+
+       rte_tel_data_start_dict(d);
+       STAILQ_FOREACH(tp, &tp_list, next) {
+               if (params != NULL && fnmatch(params, tp->name, 0) != 0)
+                       continue;
+
+               rte_tel_data_add_dict_string(d, tp->name,
+                       rte_trace_point_is_enabled(tp->handle) ?  "Enabled" : "Disabled");

Could be changed to "Ena" and "Dis" or similar to reduce traffic on wire.

Also, it may be good to add a few text in doc/guides/prog_guide/trace_lib.rst to tell this feature.

Acked-by on v1 1/1
#2 lore raw
In reply to David Marchand
Quoted 168 lines · David Marchand

Register telemetry commands to list and configure trace points and later save traces for a running DPDK application.

Note: trace point names contain a '.', so the list of valid characters used in telemetry commands and dictionary keys has been extended.

Example with testpmd running with two net/null ports (startup command from devtools/test-null.sh):

--> /trace/list,lib.ethdev.*
{"/trace/list": {"lib.ethdev.configure": "Disabled",

    "lib.ethdev.rxq.setup": "Disabled",
    "lib.ethdev.txq.setup": "Disabled",
    "lib.ethdev.start": "Disabled",
    "lib.ethdev.stop": "Disabled",
    "lib.ethdev.close": "Disabled",
    "lib.ethdev.rx.burst": "Disabled",
    "lib.ethdev.tx.burst": "Disabled"}}

--> /trace/enable,lib.ethdev.st*
{"/trace/enable": {"Count": 2}}
--> /trace/enable,lib.ethdev.st*
{"/trace/enable": {"Count": 0}}

--> /trace/list,lib.ethdev.*
{"/trace/list": {"lib.ethdev.configure": "Disabled",

    "lib.ethdev.rxq.setup": "Disabled",
    "lib.ethdev.txq.setup": "Disabled",
    "lib.ethdev.start": "Enabled",
    "lib.ethdev.stop": "Enabled",
    "lib.ethdev.close": "Disabled",
    "lib.ethdev.rx.burst": "Disabled",
    "lib.ethdev.tx.burst": "Disabled"}}

testpmd> stop
...
testpmd> port stop all
...
testpmd> port start all
...
testpmd> start
...

--> /trace/save
{"/trace/save": {"Status": "OK",

    "Path": ".../dpdk-traces/rte-2022-10-12-AM-10-51-48"}}
$ babeltrace .../dpdk-traces/rte-2022-10-12-AM-10-51-48
[10:51:36.229878723] (+?.?????????) lib.ethdev.stop:
    { cpu_id = 0x0, name = "dpdk-testpmd" }, { port_id = 0x0, ret = 0 }
[10:51:36.229880251] (+0.000001528) lib.ethdev.stop:
    { cpu_id = 0x0, name = "dpdk-testpmd" }, { port_id = 0x1, ret = 0 }
[10:51:40.449359774] (+4.219479523) lib.ethdev.start:
    { cpu_id = 0x0, name = "dpdk-testpmd" }, { port_id = 0x0 }
[10:51:40.449377877] (+0.000018103) lib.ethdev.start:
    { cpu_id = 0x0, name = "dpdk-testpmd" }, { port_id = 0x1 }

--> /trace/disable,*
{"/trace/disable": {"Count": 2}}

---
For runtime testing, please use this patch in addition with series 25183.
Depends-on: series-25183 ("Trace subsystem fixes")

---
 lib/eal/common/eal_common_trace.c | 78 +++++++++++++++++++++++++++++++
 lib/telemetry/telemetry_data.c    |  1 +
 2 files changed, 79 insertions(+)
lib/eal/common/eal_common_trace.c +78 -0
index f9b187d15f..9a54987b42 100644
@@ -12,6 +12,7 @@
 #include <rte_lcore.h>
 #include <rte_per_lcore.h>
 #include <rte_string_fns.h>
+#include <rte_telemetry.h>
 
 #include "eal_trace.h"
 
@@ -530,3 +531,80 @@ __rte_trace_point_register(rte_trace_point_t *handle, const char *name,
 
 	return -rte_errno;
 }
+
+static int
+trace_telemetry_enable(const char *cmd __rte_unused,
+	const char *params, struct rte_tel_data *d)
+{
+	unsigned int count;
+
+	if (params == NULL || strlen(params) == 0)
+		return -1;
+	rte_tel_data_start_dict(d);
+	count = __atomic_load_n(&trace.status, __ATOMIC_RELAXED);
+	rte_trace_pattern(params, true);
+	rte_tel_data_add_dict_int(d, "Count",
+		__atomic_load_n(&trace.status, __ATOMIC_RELAXED) - count);
+	return 0;
+
+}
+
+static int
+trace_telemetry_disable(const char *cmd __rte_unused,
+	const char *params, struct rte_tel_data *d)
+{
+	unsigned int count;
+
+	if (params == NULL || strlen(params) == 0)
+		return -1;
+	rte_tel_data_start_dict(d);
+	count = __atomic_load_n(&trace.status, __ATOMIC_RELAXED);
+	rte_trace_pattern(params, false);
+	rte_tel_data_add_dict_int(d, "Count",
+		count - __atomic_load_n(&trace.status, __ATOMIC_RELAXED));
+	return 0;
+
+}
+
+static int
+trace_telemetry_list(const char *cmd __rte_unused,
+	const char *params, struct rte_tel_data *d)
+{
+	struct trace_point *tp;
+
+	rte_tel_data_start_dict(d);
+	STAILQ_FOREACH(tp, &tp_list, next) {
+		if (params != NULL && fnmatch(params, tp->name, 0) != 0)
+			continue;
+
+		rte_tel_data_add_dict_string(d, tp->name,
+			rte_trace_point_is_enabled(tp->handle) ?  "Enabled" : "Disabled");
+	}
+
+	return 0;
+}
+
+static int
+trace_telemetry_save(const char *cmd __rte_unused,
+	const char *params __rte_unused, struct rte_tel_data *d)
+{
+	struct trace *trace = trace_obj_get();
+
+	rte_tel_data_start_dict(d);
+	rte_tel_data_add_dict_string(d, "Status", rte_trace_save() == 0 ? "OK" : "KO");
+	rte_tel_data_add_dict_string(d, "Path", trace->dir);
+
+	return 0;
+}
+
+RTE_INIT(trace_telemetry)
+{
+	rte_telemetry_register_cmd("/trace/enable", trace_telemetry_enable,
+		"Enable trace points matching the provided pattern. Parameters: string pattern.");
+	rte_telemetry_register_cmd("/trace/disable", trace_telemetry_disable,
+		"Disable trace points matching the provided pattern. Parameters: string pattern.");
+	rte_telemetry_register_cmd("/trace/list", trace_telemetry_list,
+		"List trace points. Parameters: string pattern.");
+	rte_telemetry_register_cmd("/trace/save", trace_telemetry_save,
+		"Save current traces. Takes no parameter.");
+}
lib/telemetry/telemetry_data.c +0 -0
index 34366ecee3..5b319c18fb 100644

lib/telemetry/telemetry_data.c valid_name(const char *name) · line 112

Quoted 7 lines
lib/telemetry/telemetry_data.c +1 -0
@@ -106,6 +106,7 @@ valid_name(const char *name)
 			['a' ... 'z'] = 1,
 			['_'] = 1,
 			['/'] = 1,
+			['.'] = 1,
 	};
 	while (*name != '\0') {
 		if ((size_t)*name >= RTE_DIM(allowed) || allowed[(int)*name] == 0)

I don't see an issue with allowing "." characters in dictionary names, so for this part:

#3 lore raw
Quoted 7 lines · Bruce Richardson
Quoted 6 lines · David Marchand

Register telemetry commands to list and configure trace points and later save traces for a running DPDK application.

Note: trace point names contain a '.', so the list of valid characters used in telemetry commands and dictionary keys has been extended.

<snip>

Quoted 16 lines

lib/telemetry/telemetry_data.c valid_name(const char *name) · line 112

Quoted 12 lines
lib/telemetry/telemetry_data.c +1 -0
index 34366ecee3..5b319c18fb 100644
@@ -106,6 +106,7 @@ valid_name(const char *name)
 			['a' ... 'z'] = 1,
 			['_'] = 1,
 			['/'] = 1,
+			['.'] = 1,
 	};
 	while (*name != '\0') {
 		if ((size_t)*name >= RTE_DIM(allowed) || allowed[(int)*name] == 0)

I don't see an issue with allowing "." characters in dictionary names, so for this part:

Quoted 1 line

By way of additional minor follow-up:
* I think the addition of "." to the list of allowed characters should be a separate patch, rather than just added as part of this larger patch. If doing a separate commit to add boolean type, this could be a change in that set.
* There are a couple of API doxygen comments for the dictionary functions, rte_tel_add_dict_*, where the allowed characters in the name are called out. You probably should add "." to those comments too.

Regards,
/Bruce

#4 lore raw
Quoted 29 lines · Bruce Richardson
Quoted 7 lines · Bruce Richardson
Quoted 6 lines · David Marchand

Register telemetry commands to list and configure trace points and later save traces for a running DPDK application.

Note: trace point names contain a '.', so the list of valid characters used in telemetry commands and dictionary keys has been extended.

<snip>

Quoted 16 lines

lib/telemetry/telemetry_data.c valid_name(const char *name) · line 112

Quoted 12 lines
lib/telemetry/telemetry_data.c +1 -0
index 34366ecee3..5b319c18fb 100644
@@ -106,6 +106,7 @@ valid_name(const char *name)
                    ['a' ... 'z'] = 1,
                    ['_'] = 1,
                    ['/'] = 1,
+                   ['.'] = 1,
    };
    while (*name != '\0') {
            if ((size_t)*name >= RTE_DIM(allowed) || allowed[(int)*name] == 0)

I don't see an issue with allowing "." characters in dictionary names, so for this part:

Quoted 1 line
Quoted 8 lines

By way of additional minor follow-up:
* I think the addition of "." to the list of allowed characters should be a separate patch, rather than just added as part of this larger patch. If doing a separate commit to add boolean type, this could be a change in that set.
* There are a couple of API doxygen comments for the dictionary functions, rte_tel_add_dict_*, where the allowed characters in the name are called out. You probably should add "." to those comments too.

Oh indeed, so ok let's go with a separate patch.

Previously, I thought the telemetry additions for traces were fine to go with the fixes series.
But seeing how it evolved, I'll merge the traces fixes (who got acked) now and respin a separate series for the rest.

Signature · 1 line
David Marchand
#5 lore raw
In reply to David Marchand
Quoted 9 lines

From: David Marchand [mailto:[email protected]]
Sent: Thursday, 13 October 2022 09.49

Register telemetry commands to list and configure trace points and later
save traces for a running DPDK application.

Note: trace point names contain a '.', so the list of valid characters used in telemetry commands and dictionary keys has been extended.

Regarding '.' in telemetry commands and dictionary keys, I agree with Bruce to allow it.

Quoted 6 lines

Example with testpmd running with two net/null ports (startup command from devtools/test-null.sh):

--> /trace/list,lib.ethdev.*
{"/trace/list": {"lib.ethdev.configure": "Disabled",

Quoted 7 lines
    "lib.ethdev.rxq.setup": "Disabled",
    "lib.ethdev.txq.setup": "Disabled",
    "lib.ethdev.start": "Disabled",
    "lib.ethdev.stop": "Disabled",
    "lib.ethdev.close": "Disabled",
    "lib.ethdev.rx.burst": "Disabled",
    "lib.ethdev.tx.burst": "Disabled"}}

Jerin commented that "Disabled"/"Enabled" are a bit verbose, and suggested shortening them.

It seems to me that these values are Boolean, and should be true or false (not surrounded by quotation marks), instead of some string representing a Boolean value. Note: This would require expanding the telemetry library with a Boolean type.

Alternatively, use integer values 0 or 1.

If we want to represent Boolean values as strings, I vote for "TRUE" and "FALSE", using all upper case to indicate that they are magic strings - and also to help avoid confusion with the JSON true/false Boolean values, which are all lower case.

Quoted 44 lines

--> /trace/enable,lib.ethdev.st*
{"/trace/enable": {"Count": 2}}
--> /trace/enable,lib.ethdev.st*
{"/trace/enable": {"Count": 0}}

--> /trace/list,lib.ethdev.*
{"/trace/list": {"lib.ethdev.configure": "Disabled",

    "lib.ethdev.rxq.setup": "Disabled",
    "lib.ethdev.txq.setup": "Disabled",
    "lib.ethdev.start": "Enabled",
    "lib.ethdev.stop": "Enabled",
    "lib.ethdev.close": "Disabled",
    "lib.ethdev.rx.burst": "Disabled",
    "lib.ethdev.tx.burst": "Disabled"}}

testpmd> stop
...
testpmd> port stop all
...
testpmd> port start all
...
testpmd> start
...

--> /trace/save
{"/trace/save": {"Status": "OK",

    "Path": ".../dpdk-traces/rte-2022-10-12-AM-10-51-48"}}
$ babeltrace .../dpdk-traces/rte-2022-10-12-AM-10-51-48
[10:51:36.229878723] (+?.?????????) lib.ethdev.stop:
    { cpu_id = 0x0, name = "dpdk-testpmd" }, { port_id = 0x0, ret = 0 }
[10:51:36.229880251] (+0.000001528) lib.ethdev.stop:
    { cpu_id = 0x0, name = "dpdk-testpmd" }, { port_id = 0x1, ret = 0 }
[10:51:40.449359774] (+4.219479523) lib.ethdev.start:
    { cpu_id = 0x0, name = "dpdk-testpmd" }, { port_id = 0x0 }
[10:51:40.449377877] (+0.000018103) lib.ethdev.start:
    { cpu_id = 0x0, name = "dpdk-testpmd" }, { port_id = 0x1 }

--> /trace/disable,*
{"/trace/disable": {"Count": 2}}

---

#6 lore raw
Quoted 26 lines · Morten Brørup
Quoted 9 lines

From: David Marchand [mailto:[email protected]]
Sent: Thursday, 13 October 2022 09.49

Register telemetry commands to list and configure trace points and later
save traces for a running DPDK application.

Note: trace point names contain a '.', so the list of valid characters used in telemetry commands and dictionary keys has been extended.

Regarding '.' in telemetry commands and dictionary keys, I agree with Bruce to allow it.

Quoted 6 lines

Example with testpmd running with two net/null ports (startup command from devtools/test-null.sh):

--> /trace/list,lib.ethdev.*
{"/trace/list": {"lib.ethdev.configure": "Disabled",

Quoted 7 lines
    "lib.ethdev.rxq.setup": "Disabled",
    "lib.ethdev.txq.setup": "Disabled",
    "lib.ethdev.start": "Disabled",
    "lib.ethdev.stop": "Disabled",
    "lib.ethdev.close": "Disabled",
    "lib.ethdev.rx.burst": "Disabled",
    "lib.ethdev.tx.burst": "Disabled"}}
Quoted 7 lines

Jerin commented that "Disabled"/"Enabled" are a bit verbose, and suggested shortening them.

It seems to me that these values are Boolean, and should be true or false (not surrounded by quotation marks), instead of some string representing a Boolean value. Note: This would require expanding the telemetry library with a Boolean type.

Alternatively, use integer values 0 or 1.

If we want to represent Boolean values as strings, I vote for "TRUE" and "FALSE", using all upper case to indicate that they are magic strings - and also to help avoid confusion with the JSON true/false Boolean values, which are all lower case.

+1 for integer values (at least in the short term). I don't think we want these as strings.

/Bruce

#7 lore raw
In reply to Morten Brørup

Hello Morten, Bruce,

Quoted 11 lines · Morten Brørup
Quoted 9 lines

--> /trace/list,lib.ethdev.*
{"/trace/list": {"lib.ethdev.configure": "Disabled",

    "lib.ethdev.rxq.setup": "Disabled",
    "lib.ethdev.txq.setup": "Disabled",
    "lib.ethdev.start": "Disabled",
    "lib.ethdev.stop": "Disabled",
    "lib.ethdev.close": "Disabled",
    "lib.ethdev.rx.burst": "Disabled",
    "lib.ethdev.tx.burst": "Disabled"}}

Jerin commented that "Disabled"/"Enabled" are a bit verbose, and suggested shortening them.

I forgot to handle this part (EINTR...), thanks for reminding.

Quoted 1 line

It seems to me that these values are Boolean, and should be true or false (not surrounded by quotation marks), instead of some string representing a Boolean value. Note: This would require expanding the telemetry library with a Boolean type.

Indeed.

Quoted 4 lines

Alternatively, use integer values 0 or 1.

If we want to represent Boolean values as strings, I vote for "TRUE" and "FALSE", using all upper case to indicate that they are magic strings - and also to help avoid confusion with the JSON true/false Boolean values, which are all lower case.

Introducing those strings is confusing, especially if we later introduce the boolean type.
I had a quick try and adding the boolean type is relatively easy (I just posted a patch, see
https://patchwork.dpdk.org/project/dpdk/patch/[email protected]/).

I would either go with adding this new type (though we are past rc1, this addition is self contained and low risk), or use simple integers.

Signature · 1 line
David Marchand
#8 lore raw
Quoted 45 lines

From: David Marchand [mailto:[email protected]]
Sent: Wednesday, 19 October 2022 09.39

Hello Morten, Bruce,

Quoted 11 lines · Morten Brørup
Quoted 9 lines

--> /trace/list,lib.ethdev.*
{"/trace/list": {"lib.ethdev.configure": "Disabled",

    "lib.ethdev.rxq.setup": "Disabled",
    "lib.ethdev.txq.setup": "Disabled",
    "lib.ethdev.start": "Disabled",
    "lib.ethdev.stop": "Disabled",
    "lib.ethdev.close": "Disabled",
    "lib.ethdev.rx.burst": "Disabled",
    "lib.ethdev.tx.burst": "Disabled"}}

Jerin commented that "Disabled"/"Enabled" are a bit verbose, and

suggested shortening them.

I forgot to handle this part (EINTR...), thanks for reminding.

Quoted 1 line

It seems to me that these values are Boolean, and should be true or

false (not surrounded by quotation marks), instead of some string representing a Boolean value. Note: This would require expanding the telemetry library with a Boolean type.

Indeed.

Quoted 4 lines

Alternatively, use integer values 0 or 1.

If we want to represent Boolean values as strings, I vote for "TRUE"

and "FALSE", using all upper case to indicate that they are magic strings - and also to help avoid confusion with the JSON true/false Boolean values, which are all lower case.

Introducing those strings is confusing, especially if we later introduce the boolean type.
I had a quick try and adding the boolean type is relatively easy (I just posted a patch, see
https://patchwork.dpdk.org/project/dpdk/patch/20221019073702.3948624-1-
[email protected]/).

Quoted 2 lines

I would either go with adding this new type (though we are past rc1, this addition is self contained and low risk), or use simple integers.

+1 to adding this new type.

It might be wider ranging, though:

Are other existing telemetry data in fact Boolean, but currently using some other type, and should switch to using the new Boolean type too?

Quoted 5 lines

--
David Marchand

#9 lore raw
Quoted 22 lines · Morten Brørup
Quoted 22 lines
Quoted 1 line

It seems to me that these values are Boolean, and should be true or

false (not surrounded by quotation marks), instead of some string representing a Boolean value. Note: This would require expanding the telemetry library with a Boolean type.

Indeed.

Quoted 4 lines

Alternatively, use integer values 0 or 1.

If we want to represent Boolean values as strings, I vote for "TRUE"

and "FALSE", using all upper case to indicate that they are magic strings - and also to help avoid confusion with the JSON true/false Boolean values, which are all lower case.

Introducing those strings is confusing, especially if we later introduce the boolean type.
I had a quick try and adding the boolean type is relatively easy (I just posted a patch, see
https://patchwork.dpdk.org/project/dpdk/patch/20221019073702.3948624-1-
[email protected]/).

Quoted 8 lines
Quoted 2 lines

I would either go with adding this new type (though we are past rc1, this addition is self contained and low risk), or use simple integers.

+1 to adding this new type.

It might be wider ranging, though:

Are other existing telemetry data in fact Boolean, but currently using some other type, and should switch to using the new Boolean type too?

I wondered about the same :-) but I did not check, for now.

Signature · 1 line
David marchand
#10 lore raw

v3 cover Telemetry support for traces

In reply to David Marchand

This series is a continuation of the traces fixes series that is now merged.

Signature · 28 lines
David Marchand

Changes since v1/v2:
- after some back and forth, the original patch has been split so that
  telemetry changes are separate and to introduce the new rte_trace_save()
  behavior,

David Marchand (4):
  telemetry: support boolean type
  telemetry: extend valid command characters
  trace: enable trace operations via telemetry
  trace: create new directory for each trace dump

 app/test/test_telemetry_data.c          | 88 +++++++++++++++++++++++-
 doc/guides/prog_guide/trace_lib.rst     | 39 +++++++++++
 lib/eal/common/eal_common_trace.c       | 82 +++++++++++++++++++++++
 lib/eal/common/eal_common_trace_utils.c | 89 +++++++++++--------------
 lib/eal/common/eal_trace.h              |  1 +
 lib/telemetry/rte_telemetry.h           | 46 +++++++++++--
 lib/telemetry/telemetry.c               | 24 ++++++-
 lib/telemetry/telemetry_data.c          | 45 +++++++++++--
 lib/telemetry/telemetry_data.h          |  5 ++
 lib/telemetry/telemetry_json.h          | 34 ++++++++++
 lib/telemetry/version.map               | 10 +++
 11 files changed, 401 insertions(+), 62 deletions(-)

-- 
2.37.3
#11 lore raw

PATCH v3 1/4 telemetry: support boolean type

Add the boolean type RTE_TEL_BOOL_VAL for values in arrays and dicts.

---
Changes since v1:
- fixed doxygen description,

---
 app/test/test_telemetry_data.c | 88 +++++++++++++++++++++++++++++++++-
 lib/telemetry/rte_telemetry.h  | 36 ++++++++++++++
 lib/telemetry/telemetry.c      | 24 +++++++++-
 lib/telemetry/telemetry_data.c | 44 +++++++++++++++--
 lib/telemetry/telemetry_data.h |  5 ++
 lib/telemetry/telemetry_json.h | 34 +++++++++++++
 lib/telemetry/version.map      | 10 ++++
 7 files changed, 233 insertions(+), 8 deletions(-)
app/test/test_telemetry_data.c +86 -2
index d92667a527..134e018fde 100644
@@ -353,6 +353,84 @@ test_array_with_array_u64_values(void)
 	return CHECK_OUTPUT("[[0,1,2,3,4],[0,1,2,3,4]]");
 }
 
+static int
+test_case_array_bool(void)
+{
+	int i;
+
+	rte_tel_data_start_array(&response_data, RTE_TEL_BOOL_VAL);
+	for (i = 0; i < 5; i++)
+		rte_tel_data_add_array_bool(&response_data, (i % 2) == 0);
+	return CHECK_OUTPUT("[true,false,true,false,true]");
+}
+
+static int
+test_case_add_dict_bool(void)
+{
+	int i = 0;
+	char name_of_value[8];
+
+	rte_tel_data_start_dict(&response_data);
+
+	for (i = 0; i < 5; i++) {
+		sprintf(name_of_value, "dict_%d", i);
+		rte_tel_data_add_dict_bool(&response_data, name_of_value,
+			(i % 2) == 0);
+	}
+	return CHECK_OUTPUT("{\"dict_0\":true,\"dict_1\":false,\"dict_2\":true,"
+		"\"dict_3\":false,\"dict_4\":true}");
+}
+
+static int
+test_dict_with_array_bool_values(void)
+{
+	int i;
+
+	struct rte_tel_data *child_data = rte_tel_data_alloc();
+	rte_tel_data_start_array(child_data, RTE_TEL_BOOL_VAL);
+
+	struct rte_tel_data *child_data2 = rte_tel_data_alloc();
+	rte_tel_data_start_array(child_data2, RTE_TEL_BOOL_VAL);
+
+	rte_tel_data_start_dict(&response_data);
+
+	for (i = 0; i < 10; i++) {
+		rte_tel_data_add_array_bool(child_data, (i % 2) == 0);
+		rte_tel_data_add_array_bool(child_data2, (i % 2) == 1);
+	}
+
+	rte_tel_data_add_dict_container(&response_data, "dict_0",
+	 child_data, 0);
+	rte_tel_data_add_dict_container(&response_data, "dict_1",
+	 child_data2, 0);
+
+	return CHECK_OUTPUT("{\"dict_0\":[true,false,true,false,true,false,true,false,true,false],"
+		"\"dict_1\":[false,true,false,true,false,true,false,true,false,true]}");
+}
+
+static int
+test_array_with_array_bool_values(void)
+{
+	int i;
+
+	struct rte_tel_data *child_data = rte_tel_data_alloc();
+	rte_tel_data_start_array(child_data, RTE_TEL_BOOL_VAL);
+
+	struct rte_tel_data *child_data2 = rte_tel_data_alloc();
+	rte_tel_data_start_array(child_data2, RTE_TEL_BOOL_VAL);
+
+	rte_tel_data_start_array(&response_data, RTE_TEL_CONTAINER);
+
+	for (i = 0; i < 5; i++) {
+		rte_tel_data_add_array_bool(child_data, (i % 2) == 0);
+		rte_tel_data_add_array_bool(child_data2, (i % 2) == 1);
+	}
+	rte_tel_data_add_array_container(&response_data, child_data, 0);
+	rte_tel_data_add_array_container(&response_data, child_data2, 0);
+
+	return CHECK_OUTPUT("[[true,false,true,false,true],[false,true,false,true,false]]");
+}
+
 static int
 test_string_char_escaping(void)
 {
@@ -428,15 +506,21 @@ telemetry_data_autotest(void)
 			test_null_return,
 			test_simple_string,
 			test_case_array_string,
-			test_case_array_int, test_case_array_u64,
-			test_case_add_dict_int, test_case_add_dict_u64,
+			test_case_array_int,
+			test_case_array_u64,
+			test_case_array_bool,
+			test_case_add_dict_int,
+			test_case_add_dict_u64,
+			test_case_add_dict_bool,
 			test_case_add_dict_string,
 			test_dict_with_array_int_values,
 			test_dict_with_array_u64_values,
+			test_dict_with_array_bool_values,
 			test_dict_with_array_string_values,
 			test_dict_with_dict_values,
 			test_array_with_array_int_values,
 			test_array_with_array_u64_values,
+			test_array_with_array_bool_values,
 			test_array_with_array_string_values,
 			test_string_char_escaping,
 			test_array_char_escaping,
lib/telemetry/rte_telemetry.h +36 -0
index a0d21d6b7f..e7f6c2ae43 100644
@@ -2,6 +2,7 @@
  * Copyright(c) 2018 Intel Corporation
  */
 
+#include <stdbool.h>
 #include <stdint.h>
 
 #include <rte_compat.h>
@@ -46,6 +47,7 @@ enum rte_tel_value_type {
 	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 */
+	RTE_TEL_BOOL_VAL,   /** a boolean value */
 };
 
 /**
@@ -155,6 +157,22 @@ int
 rte_tel_data_add_array_container(struct rte_tel_data *d,
 		struct rte_tel_data *val, int keep);
 
+/**
+ * Add a boolean to an array.
+ * The array must have been started by rte_tel_data_start_array() with
+ * RTE_TEL_BOOL_VAL as the type parameter.
+ *
+ * @param d
+ *   The data structure passed to the callback
+ * @param x
+ *   The boolean value to be returned in the array
+ * @return
+ *   0 on success, negative errno on error
+ */
+__rte_experimental
+int
+rte_tel_data_add_array_bool(struct rte_tel_data *d, bool x);
+
 /**
  * Add a string value to a dictionary.
  * The dict must have been started by rte_tel_data_start_dict().
@@ -233,6 +251,24 @@ int
 rte_tel_data_add_dict_container(struct rte_tel_data *d, const char *name,
 		struct rte_tel_data *val, int keep);
 
+/**
+ * Add a boolean value to a dictionary.
+ * The dict must have been started by rte_tel_data_start_dict().
+ *
+ * @param d
+ *   The data structure passed to the callback
+ * @param name
+ *   The name the value is to be stored under in the dict
+ *   Must contain only alphanumeric characters or the symbols: '_' or '/'
+ * @param val
+ *   The boolean value to be stored in the dict
+ * @return
+ *   0 on success, negative errno on error, E2BIG on string truncation of name.
+ */
+__rte_experimental
+int
+rte_tel_data_add_dict_bool(struct rte_tel_data *d, const char *name, bool val);
+
 /**
  * This telemetry callback is used when registering a telemetry command.
  * It handles getting and formatting information to be returned to telemetry
lib/telemetry/telemetry.c +23 -1
index 8fbb4f3060..276d0f337d 100644
@@ -168,7 +168,9 @@ container_to_json(const struct rte_tel_data *d, char *out_buf, size_t buf_len)
 	unsigned int i;
 
 	if (d->type != RTE_TEL_DICT && d->type != RTE_TEL_ARRAY_U64 &&
-		d->type != RTE_TEL_ARRAY_INT && d->type != RTE_TEL_ARRAY_STRING)
+			d->type != RTE_TEL_ARRAY_INT &&
+			d->type != RTE_TEL_ARRAY_STRING &&
+			d->type != RTE_TEL_ARRAY_BOOL)
 		return snprintf(out_buf, buf_len, "null");
 
 	used = rte_tel_json_empty_array(out_buf, buf_len, 0);
@@ -187,6 +189,11 @@ container_to_json(const struct rte_tel_data *d, char *out_buf, size_t buf_len)
 			used = rte_tel_json_add_array_string(out_buf,
 				buf_len, used,
 				d->data.array[i].sval);
+	if (d->type == RTE_TEL_ARRAY_BOOL)
+		for (i = 0; i < d->data_len; i++)
+			used = rte_tel_json_add_array_bool(out_buf,
+				buf_len, used,
+				d->data.array[i].boolval);
 	if (d->type == RTE_TEL_DICT)
 		for (i = 0; i < d->data_len; i++) {
 			const struct tel_dict_entry *v = &d->data.dict[i];
@@ -206,6 +213,11 @@ container_to_json(const struct rte_tel_data *d, char *out_buf, size_t buf_len)
 						buf_len, used,
 						v->name, v->value.u64val);
 				break;
+			case RTE_TEL_BOOL_VAL:
+				used = rte_tel_json_add_obj_bool(out_buf,
+						buf_len, used,
+						v->name, v->value.boolval);
+				break;
 			case RTE_TEL_CONTAINER:
 			{
 				char temp[buf_len];
@@ -273,6 +285,11 @@ 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_BOOL_VAL:
+				used = rte_tel_json_add_obj_bool(cb_data_buf,
+						buf_len, used,
+						v->name, v->value.boolval);
+				break;
 			case RTE_TEL_CONTAINER:
 			{
 				char temp[buf_len];
@@ -294,6 +311,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_BOOL:
 	case RTE_TEL_ARRAY_CONTAINER:
 		used = rte_tel_json_empty_array(cb_data_buf, buf_len, 0);
 		for (i = 0; i < d->data_len; i++)
@@ -310,6 +328,10 @@ 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_BOOL)
+				used = rte_tel_json_add_array_bool(cb_data_buf,
+						buf_len, used,
+						d->data.array[i].boolval);
 			else if (d->type == RTE_TEL_ARRAY_CONTAINER) {
 				char temp[buf_len];
 				const struct container *rec_data =
lib/telemetry/telemetry_data.c +39 -5

74 lines not on this page · raw message

lib/telemetry/telemetry_data.h +5 -0
index 26aa28e72c..c840486b18 100644
@@ -5,6 +5,9 @@
 #ifndef _TELEMETRY_DATA_H_
 #define _TELEMETRY_DATA_H_
 
+#include <stdbool.h>
+#include <stdint.h>
+
 #include "rte_telemetry.h"
 
 enum tel_container_types {
@@ -15,6 +18,7 @@ enum tel_container_types {
 	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 */
+	RTE_TEL_ARRAY_BOOL,   /** array of boolean values */
 };
 
 struct container {
@@ -30,6 +34,7 @@ union tel_value {
 	char sval[RTE_TEL_MAX_STRING_LEN];
 	int ival;
 	uint64_t u64val;
+	bool boolval;
 	struct container container;
 };
 
lib/telemetry/telemetry_json.h +34 -0
index e3fae7c30d..c97da97366 100644
@@ -7,6 +7,7 @@
 
 #include <inttypes.h>
 #include <stdarg.h>
+#include <stdbool.h>
 #include <stdio.h>
 #include <rte_common.h>
 #include <rte_telemetry.h>
@@ -159,6 +160,21 @@ rte_tel_json_add_array_u64(char *buf, const int len, const int used,
 	return ret == 0 ? used : end + ret;
 }
 
+/* Appends a boolean into the JSON array in the provided buffer. */
+static inline int
+rte_tel_json_add_array_bool(char *buf, const int len, const int used,
+		bool val)
+{
+	int ret, end = used - 1; /* strip off final delimiter */
+	if (used <= 2) /* assume empty, since minimum is '[]' */
+		return __json_snprintf(buf, len, "[%s]",
+				val ? "true" : "false");
+
+	ret = __json_snprintf(buf + end, len - end, ",%s]",
+			val ? "true" : "false");
+	return ret == 0 ? used : end + ret;
+}
+
 /*
  * Add a new element with raw JSON value to the JSON array stored in the
  * provided buffer.
@@ -193,6 +209,24 @@ rte_tel_json_add_obj_u64(char *buf, const int len, const int used,
 	return ret == 0 ? used : end + ret;
 }
 
+/**
+ * Add a new element with boolean value to the JSON object stored in the
+ * provided buffer.
+ */
+static inline int
+rte_tel_json_add_obj_bool(char *buf, const int len, const int used,
+		const char *name, bool val)
+{
+	int ret, end = used - 1;
+	if (used <= 2) /* assume empty, since minimum is '{}' */
+		return __json_snprintf(buf, len, "{\"%s\":%s}", name,
+				val ? "true" : "false");
+
+	ret = __json_snprintf(buf + end, len - end, ",\"%s\":%s}",
+			name, val ? "true" : "false");
+	return ret == 0 ? used : end + ret;
+}
+
 /**
  * Add a new element with int value to the JSON object stored in the
  * provided buffer.
lib/telemetry/version.map +10 -0
index 9794f9ea20..88f58d4d89 100644
@@ -19,7 +19,17 @@ DPDK_23 {
 	local: *;
 };
 
+EXPERIMENTAL {
+	global:
+
+	# added in 22.11
+	rte_tel_data_add_array_bool;
+	rte_tel_data_add_dict_bool;
+};
+
 INTERNAL {
+	global:
+
 	rte_telemetry_legacy_register;
 	rte_telemetry_init;
 };
Signature · 1 line
2.37.3
#12 lore raw

Re: [PATCH v3 1/4] telemetry: support boolean type

Quoted 177 lines · David Marchand

Add the boolean type RTE_TEL_BOOL_VAL for values in arrays and dicts.

---
Changes since v1:
- fixed doxygen description,

---
  app/test/test_telemetry_data.c | 88 +++++++++++++++++++++++++++++++++-
  lib/telemetry/rte_telemetry.h  | 36 ++++++++++++++
  lib/telemetry/telemetry.c      | 24 +++++++++-
  lib/telemetry/telemetry_data.c | 44 +++++++++++++++--
  lib/telemetry/telemetry_data.h |  5 ++
  lib/telemetry/telemetry_json.h | 34 +++++++++++++
  lib/telemetry/version.map      | 10 ++++
  7 files changed, 233 insertions(+), 8 deletions(-)
app/test/test_telemetry_data.c +86 -2
index d92667a527..134e018fde 100644
@@ -353,6 +353,84 @@ test_array_with_array_u64_values(void)
  	return CHECK_OUTPUT("[[0,1,2,3,4],[0,1,2,3,4]]");
  }
 
+static int
+test_case_array_bool(void)
+{
+	int i;
+
+	rte_tel_data_start_array(&response_data, RTE_TEL_BOOL_VAL);
+	for (i = 0; i < 5; i++)
+		rte_tel_data_add_array_bool(&response_data, (i % 2) == 0);
+	return CHECK_OUTPUT("[true,false,true,false,true]");
+}
+
+static int
+test_case_add_dict_bool(void)
+{
+	int i = 0;
+	char name_of_value[8];
+
+	rte_tel_data_start_dict(&response_data);
+
+	for (i = 0; i < 5; i++) {
+		sprintf(name_of_value, "dict_%d", i);
+		rte_tel_data_add_dict_bool(&response_data, name_of_value,
+			(i % 2) == 0);
+	}
+	return CHECK_OUTPUT("{\"dict_0\":true,\"dict_1\":false,\"dict_2\":true,"
+		"\"dict_3\":false,\"dict_4\":true}");
+}
+
+static int
+test_dict_with_array_bool_values(void)
+{
+	int i;
+
+	struct rte_tel_data *child_data = rte_tel_data_alloc();
+	rte_tel_data_start_array(child_data, RTE_TEL_BOOL_VAL);
+
+	struct rte_tel_data *child_data2 = rte_tel_data_alloc();
+	rte_tel_data_start_array(child_data2, RTE_TEL_BOOL_VAL);
+
+	rte_tel_data_start_dict(&response_data);
+
+	for (i = 0; i < 10; i++) {
+		rte_tel_data_add_array_bool(child_data, (i % 2) == 0);
+		rte_tel_data_add_array_bool(child_data2, (i % 2) == 1);
+	}
+
+	rte_tel_data_add_dict_container(&response_data, "dict_0",
+	 child_data, 0);
+	rte_tel_data_add_dict_container(&response_data, "dict_1",
+	 child_data2, 0);
+
+	return CHECK_OUTPUT("{\"dict_0\":[true,false,true,false,true,false,true,false,true,false],"
+		"\"dict_1\":[false,true,false,true,false,true,false,true,false,true]}");
+}
+
+static int
+test_array_with_array_bool_values(void)
+{
+	int i;
+
+	struct rte_tel_data *child_data = rte_tel_data_alloc();
+	rte_tel_data_start_array(child_data, RTE_TEL_BOOL_VAL);
+
+	struct rte_tel_data *child_data2 = rte_tel_data_alloc();
+	rte_tel_data_start_array(child_data2, RTE_TEL_BOOL_VAL);
+
+	rte_tel_data_start_array(&response_data, RTE_TEL_CONTAINER);
+
+	for (i = 0; i < 5; i++) {
+		rte_tel_data_add_array_bool(child_data, (i % 2) == 0);
+		rte_tel_data_add_array_bool(child_data2, (i % 2) == 1);
+	}
+	rte_tel_data_add_array_container(&response_data, child_data, 0);
+	rte_tel_data_add_array_container(&response_data, child_data2, 0);
+
+	return CHECK_OUTPUT("[[true,false,true,false,true],[false,true,false,true,false]]");
+}
+
  static int
  test_string_char_escaping(void)
  {
@@ -428,15 +506,21 @@ telemetry_data_autotest(void)
  			test_null_return,
  			test_simple_string,
  			test_case_array_string,
-			test_case_array_int, test_case_array_u64,
-			test_case_add_dict_int, test_case_add_dict_u64,
+			test_case_array_int,
+			test_case_array_u64,
+			test_case_array_bool,
+			test_case_add_dict_int,
+			test_case_add_dict_u64,
+			test_case_add_dict_bool,
  			test_case_add_dict_string,
  			test_dict_with_array_int_values,
  			test_dict_with_array_u64_values,
+			test_dict_with_array_bool_values,
  			test_dict_with_array_string_values,
  			test_dict_with_dict_values,
  			test_array_with_array_int_values,
  			test_array_with_array_u64_values,
+			test_array_with_array_bool_values,
  			test_array_with_array_string_values,
  			test_string_char_escaping,
  			test_array_char_escaping,
lib/telemetry/rte_telemetry.h +18 -0
index a0d21d6b7f..e7f6c2ae43 100644
@@ -2,6 +2,7 @@
   * Copyright(c) 2018 Intel Corporation
   */
 
+#include <stdbool.h>
  #include <stdint.h>
 
  #include <rte_compat.h>
@@ -46,6 +47,7 @@ enum rte_tel_value_type {
  	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 */
+	RTE_TEL_BOOL_VAL,   /** a boolean value */
  };
 
  /**
@@ -155,6 +157,22 @@ int
  rte_tel_data_add_array_container(struct rte_tel_data *d,
  		struct rte_tel_data *val, int keep);
 
+/**
+ * Add a boolean to an array.
+ * The array must have been started by rte_tel_data_start_array() with
+ * RTE_TEL_BOOL_VAL as the type parameter.
+ *
+ * @param d
+ *   The data structure passed to the callback
+ * @param x
+ *   The boolean value to be returned in the array
+ * @return
+ *   0 on success, negative errno on error
+ */
+__rte_experimental
+int
+rte_tel_data_add_array_bool(struct rte_tel_data *d, bool x);
+
  /**
   * Add a string value to a dictionary.
   * The dict must have been started by rte_tel_data_start_dict().

lib/telemetry/rte_telemetry.h int · line 256

Quoted 6 lines
lib/telemetry/rte_telemetry.h +3 -0
@@ -233,6 +251,24 @@ int
  rte_tel_data_add_dict_container(struct rte_tel_data *d, const char *name,
  		struct rte_tel_data *val, int keep);
 
+/**
+ * Add a boolean value to a dictionary.
+ * The dict must have been started by rte_tel_data_start_dict().

...as RTE_TEL_BOOL_VAL as the type parameter?

Quoted 23 lines
lib/telemetry/rte_telemetry.h +15 -0
+ *
+ * @param d
+ *   The data structure passed to the callback
+ * @param name
+ *   The name the value is to be stored under in the dict
+ *   Must contain only alphanumeric characters or the symbols: '_' or '/'
+ * @param val
+ *   The boolean value to be stored in the dict
+ * @return
+ *   0 on success, negative errno on error, E2BIG on string truncation of name.
+ */
+__rte_experimental
+int
+rte_tel_data_add_dict_bool(struct rte_tel_data *d, const char *name, bool val);
+
  /**
   * This telemetry callback is used when registering a telemetry command.
   * It handles getting and formatting information to be returned to telemetry
lib/telemetry/telemetry.c +0 -0
index 8fbb4f3060..276d0f337d 100644

lib/telemetry/telemetry.c container_to_json(const struct rte_tel_data *d, char *out_buf, size_t buf_len) · line 173

Quoted 7 lines
lib/telemetry/telemetry.c +3 -1
@@ -168,7 +168,9 @@ container_to_json(const struct rte_tel_data *d, char *out_buf, size_t buf_len)
  	unsigned int i;
 
  	if (d->type != RTE_TEL_DICT && d->type != RTE_TEL_ARRAY_U64 &&
-		d->type != RTE_TEL_ARRAY_INT && d->type != RTE_TEL_ARRAY_STRING)
+			d->type != RTE_TEL_ARRAY_INT &&
+			d->type != RTE_TEL_ARRAY_STRING &&
+			d->type != RTE_TEL_ARRAY_BOOL)

Use a switch for improved readability.

lib/telemetry/telemetry.c container_to_json(const struct rte_tel_data *d, char *out_buf, size_t buf_len) · line 192

Quoted 8 lines
lib/telemetry/telemetry.c +1 -0
  		return snprintf(out_buf, buf_len, "null");
 
  	used = rte_tel_json_empty_array(out_buf, buf_len, 0);
@@ -187,6 +189,11 @@ container_to_json(const struct rte_tel_data *d, char *out_buf, size_t buf_len)
  			used = rte_tel_json_add_array_string(out_buf,
  				buf_len, used,
  				d->data.array[i].sval);
+	if (d->type == RTE_TEL_ARRAY_BOOL)

This whole section should be refactor to use a switch statement, imo.

Quoted 57 lines
lib/telemetry/telemetry.c +19 -0
+		for (i = 0; i < d->data_len; i++)
+			used = rte_tel_json_add_array_bool(out_buf,
+				buf_len, used,
+				d->data.array[i].boolval);
  	if (d->type == RTE_TEL_DICT)
  		for (i = 0; i < d->data_len; i++) {
  			const struct tel_dict_entry *v = &d->data.dict[i];
@@ -206,6 +213,11 @@ container_to_json(const struct rte_tel_data *d, char *out_buf, size_t buf_len)
  						buf_len, used,
  						v->name, v->value.u64val);
  				break;
+			case RTE_TEL_BOOL_VAL:
+				used = rte_tel_json_add_obj_bool(out_buf,
+						buf_len, used,
+						v->name, v->value.boolval);
+				break;
  			case RTE_TEL_CONTAINER:
  			{
  				char temp[buf_len];
@@ -273,6 +285,11 @@ 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_BOOL_VAL:
+				used = rte_tel_json_add_obj_bool(cb_data_buf,
+						buf_len, used,
+						v->name, v->value.boolval);
+				break;
  			case RTE_TEL_CONTAINER:
  			{
  				char temp[buf_len];
@@ -294,6 +311,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_BOOL:
  	case RTE_TEL_ARRAY_CONTAINER:
  		used = rte_tel_json_empty_array(cb_data_buf, buf_len, 0);
  		for (i = 0; i < d->data_len; i++)
@@ -310,6 +328,10 @@ 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_BOOL)
+				used = rte_tel_json_add_array_bool(cb_data_buf,
+						buf_len, used,
+						d->data.array[i].boolval);
  			else if (d->type == RTE_TEL_ARRAY_CONTAINER) {
  				char temp[buf_len];
  				const struct container *rec_data =
lib/telemetry/telemetry_data.c +0 -0
index 34366ecee3..13a7ce7034 100644
@@ -16,10 +16,11 @@ int
  rte_tel_data_start_array(struct rte_tel_data *d, enum rte_tel_value_type type)
  {

lib/telemetry/telemetry_data.c int · line 23

Quoted 10 lines
lib/telemetry/telemetry_data.c +5 -4
  	enum tel_container_types array_types[] = {
-			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 */
+		[RTE_TEL_STRING_VAL] = RTE_TEL_ARRAY_STRING,
+		[RTE_TEL_INT_VAL] = RTE_TEL_ARRAY_INT,
+		[RTE_TEL_U64_VAL] = RTE_TEL_ARRAY_U64,
+		[RTE_TEL_CONTAINER] = RTE_TEL_ARRAY_CONTAINER,
+		[RTE_TEL_BOOL_VAL] = RTE_TEL_ARRAY_BOOL,

Seems like a brittle construct to me. Replace this with a switch statement.

Quoted 22 lines
lib/telemetry/telemetry_data.c +11 -0
  	};
  	d->type = array_types[type];
  	d->data_len = 0;
@@ -80,6 +81,17 @@ rte_tel_data_add_array_u64(struct rte_tel_data *d, uint64_t x)
  	return 0;
  }
 
+int
+rte_tel_data_add_array_bool(struct rte_tel_data *d, bool x)
+{
+	if (d->type != RTE_TEL_ARRAY_BOOL)
+		return -EINVAL;
+	if (d->data_len >= RTE_TEL_MAX_ARRAY_ENTRIES)
+		return -ENOSPC;
+	d->data.array[d->data_len++].boolval = x;
+	return 0;
+}
+
  int
  rte_tel_data_add_array_container(struct rte_tel_data *d,
  		struct rte_tel_data *val, int keep)

lib/telemetry/telemetry_data.c rte_tel_data_add_array_container(struct rte_tel_data *d, · line 103

Quoted 6 lines
lib/telemetry/telemetry_data.c +2 -1
@@ -87,7 +99,8 @@ rte_tel_data_add_array_container(struct rte_tel_data *d,
  	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))
+			&& val->type != RTE_TEL_ARRAY_STRING
+			&& val->type != RTE_TEL_ARRAY_BOOL))

Maybe the introduction of a valid_type() static function would be in order? Implemented by means of a (surprise!) switch statement. :)

Could be is_valid_type() and rename valid_name() us_valid_name() in the process.

Use in rte_tel_data_add_dict_container() as well.

Quoted 83 lines
lib/telemetry/telemetry_data.c +21 -0
  		return -EINVAL;
  	if (d->data_len >= RTE_TEL_MAX_ARRAY_ENTRIES)
  		return -ENOSPC;
@@ -179,6 +192,26 @@ rte_tel_data_add_dict_u64(struct rte_tel_data *d,
  	return bytes < RTE_TEL_MAX_STRING_LEN ? 0 : E2BIG;
  }
 
+int
+rte_tel_data_add_dict_bool(struct rte_tel_data *d,
+		const char *name, bool val)
+{
+	struct tel_dict_entry *e = &d->data.dict[d->data_len];
+	if (d->type != RTE_TEL_DICT)
+		return -EINVAL;
+	if (d->data_len >= RTE_TEL_MAX_DICT_ENTRIES)
+		return -ENOSPC;
+
+	if (!valid_name(name))
+		return -EINVAL;
+
+	d->data_len++;
+	e->type = RTE_TEL_BOOL_VAL;
+	e->value.boolval = val;
+	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)
@@ -188,6 +221,7 @@ rte_tel_data_add_dict_container(struct rte_tel_data *d, const char *name,
  	if (d->type != RTE_TEL_DICT || (val->type != RTE_TEL_ARRAY_U64
  			&& val->type != RTE_TEL_ARRAY_INT
  			&& val->type != RTE_TEL_ARRAY_STRING
+			&& val->type != RTE_TEL_ARRAY_BOOL
  			&& val->type != RTE_TEL_DICT))
  		return -EINVAL;
  	if (d->data_len >= RTE_TEL_MAX_DICT_ENTRIES)
lib/telemetry/telemetry_data.h +5 -0
index 26aa28e72c..c840486b18 100644
@@ -5,6 +5,9 @@
  #ifndef _TELEMETRY_DATA_H_
  #define _TELEMETRY_DATA_H_
 
+#include <stdbool.h>
+#include <stdint.h>
+
  #include "rte_telemetry.h"
 
  enum tel_container_types {
@@ -15,6 +18,7 @@ enum tel_container_types {
  	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 */
+	RTE_TEL_ARRAY_BOOL,   /** array of boolean values */
  };
 
  struct container {
@@ -30,6 +34,7 @@ union tel_value {
  	char sval[RTE_TEL_MAX_STRING_LEN];
  	int ival;
  	uint64_t u64val;
+	bool boolval;
  	struct container container;
  };
 
lib/telemetry/telemetry_json.h +1 -0
index e3fae7c30d..c97da97366 100644
@@ -7,6 +7,7 @@
 
  #include <inttypes.h>
  #include <stdarg.h>
+#include <stdbool.h>
  #include <stdio.h>
  #include <rte_common.h>
  #include <rte_telemetry.h>
@@ -159,6 +160,21 @@ rte_tel_json_add_array_u64(char *buf, const int len, const int used,
  	return ret == 0 ? used : end + ret;
  }

lib/telemetry/telemetry_json.h rte_tel_json_add_array_u64(char *buf, const int len, const int used, · line 171

Quoted 10 lines
lib/telemetry/telemetry_json.h +9 -0
 
+/* Appends a boolean into the JSON array in the provided buffer. */
+static inline int
+rte_tel_json_add_array_bool(char *buf, const int len, const int used,
+		bool val)
+{
+	int ret, end = used - 1; /* strip off final delimiter */
+	if (used <= 2) /* assume empty, since minimum is '[]' */
+		return __json_snprintf(buf, len, "[%s]",
+				val ? "true" : "false");

Have "true" and "false" as #defines, and make a bool_str() helper, which returns the (constant) string form.

Quoted 10 lines
lib/telemetry/telemetry_json.h +6 -0
+
+	ret = __json_snprintf(buf + end, len - end, ",%s]",
+			val ? "true" : "false");
+	return ret == 0 ? used : end + ret;
+}
+
  /*
   * Add a new element with raw JSON value to the JSON array stored in the
   * provided buffer.

lib/telemetry/telemetry_json.h rte_tel_json_add_obj_u64(char *buf, const int len, const int used, · line 216

Quoted 8 lines
lib/telemetry/telemetry_json.h +5 -0
@@ -193,6 +209,24 @@ rte_tel_json_add_obj_u64(char *buf, const int len, const int used,
  	return ret == 0 ? used : end + ret;
  }
 
+/**
+ * Add a new element with boolean value to the JSON object stored in the
+ * provided buffer.
+ */
+static inline int

I know this pattern isn't introduced in this patch, but why is this function in the header file?

lib/telemetry/telemetry_json.h rte_tel_json_add_obj_u64(char *buf, const int len, const int used, · line 221

Quoted 5 lines
lib/telemetry/telemetry_json.h +5 -0
+rte_tel_json_add_obj_bool(char *buf, const int len, const int used,
+		const char *name, bool val)
+{
+	int ret, end = used - 1;
+	if (used <= 2) /* assume empty, since minimum is '{}' */

RTE_ASSERT() wouldn't be more helpful? The input buffer is malformed, correct?

Either way, the magic '2' should be a #define.

lib/telemetry/telemetry_json.h rte_tel_json_add_obj_u64(char *buf, const int len, const int used, · line 229

Quoted 8 lines
lib/telemetry/telemetry_json.h +8 -0
+		return __json_snprintf(buf, len, "{\"%s\":%s}", name,
+				val ? "true" : "false");
+
+	ret = __json_snprintf(buf + end, len - end, ",\"%s\":%s}",
+			name, val ? "true" : "false");
+	return ret == 0 ? used : end + ret;
+}
+

This looks like cut-and-paste. Merge into one function, parameterized by the start and end delimiter.

Quoted 25 lines
lib/telemetry/telemetry_json.h +0 -0
  /**
   * Add a new element with int value to the JSON object stored in the
   * provided buffer.
lib/telemetry/version.map +10 -0
index 9794f9ea20..88f58d4d89 100644
@@ -19,7 +19,17 @@ DPDK_23 {
  	local: *;
  };
 
+EXPERIMENTAL {
+	global:
+
+	# added in 22.11
+	rte_tel_data_add_array_bool;
+	rte_tel_data_add_dict_bool;
+};
+
  INTERNAL {
+	global:
+
  	rte_telemetry_legacy_register;
  	rte_telemetry_init;
  };
#13 lore raw

Re: [PATCH v3 1/4] telemetry: support boolean type

Quoted 492 lines · Mattias Rönnblom
Quoted 177 lines · David Marchand

Add the boolean type RTE_TEL_BOOL_VAL for values in arrays and dicts.

---
Changes since v1:
- fixed doxygen description,

---
  app/test/test_telemetry_data.c | 88 +++++++++++++++++++++++++++++++++-
  lib/telemetry/rte_telemetry.h  | 36 ++++++++++++++
  lib/telemetry/telemetry.c      | 24 +++++++++-
  lib/telemetry/telemetry_data.c | 44 +++++++++++++++--
  lib/telemetry/telemetry_data.h |  5 ++
  lib/telemetry/telemetry_json.h | 34 +++++++++++++
  lib/telemetry/version.map      | 10 ++++
  7 files changed, 233 insertions(+), 8 deletions(-)
app/test/test_telemetry_data.c +86 -2
index d92667a527..134e018fde 100644
@@ -353,6 +353,84 @@ test_array_with_array_u64_values(void)
      return CHECK_OUTPUT("[[0,1,2,3,4],[0,1,2,3,4]]");
  }
 
+static int
+test_case_array_bool(void)
+{
+     int i;
+
+     rte_tel_data_start_array(&response_data, RTE_TEL_BOOL_VAL);
+     for (i = 0; i < 5; i++)
+             rte_tel_data_add_array_bool(&response_data, (i % 2) == 0);
+     return CHECK_OUTPUT("[true,false,true,false,true]");
+}
+
+static int
+test_case_add_dict_bool(void)
+{
+     int i = 0;
+     char name_of_value[8];
+
+     rte_tel_data_start_dict(&response_data);
+
+     for (i = 0; i < 5; i++) {
+             sprintf(name_of_value, "dict_%d", i);
+             rte_tel_data_add_dict_bool(&response_data, name_of_value,
+                     (i % 2) == 0);
+     }
+     return CHECK_OUTPUT("{\"dict_0\":true,\"dict_1\":false,\"dict_2\":true,"
+             "\"dict_3\":false,\"dict_4\":true}");
+}
+
+static int
+test_dict_with_array_bool_values(void)
+{
+     int i;
+
+     struct rte_tel_data *child_data = rte_tel_data_alloc();
+     rte_tel_data_start_array(child_data, RTE_TEL_BOOL_VAL);
+
+     struct rte_tel_data *child_data2 = rte_tel_data_alloc();
+     rte_tel_data_start_array(child_data2, RTE_TEL_BOOL_VAL);
+
+     rte_tel_data_start_dict(&response_data);
+
+     for (i = 0; i < 10; i++) {
+             rte_tel_data_add_array_bool(child_data, (i % 2) == 0);
+             rte_tel_data_add_array_bool(child_data2, (i % 2) == 1);
+     }
+
+     rte_tel_data_add_dict_container(&response_data, "dict_0",
+      child_data, 0);
+     rte_tel_data_add_dict_container(&response_data, "dict_1",
+      child_data2, 0);
+
+     return CHECK_OUTPUT("{\"dict_0\":[true,false,true,false,true,false,true,false,true,false],"
+             "\"dict_1\":[false,true,false,true,false,true,false,true,false,true]}");
+}
+
+static int
+test_array_with_array_bool_values(void)
+{
+     int i;
+
+     struct rte_tel_data *child_data = rte_tel_data_alloc();
+     rte_tel_data_start_array(child_data, RTE_TEL_BOOL_VAL);
+
+     struct rte_tel_data *child_data2 = rte_tel_data_alloc();
+     rte_tel_data_start_array(child_data2, RTE_TEL_BOOL_VAL);
+
+     rte_tel_data_start_array(&response_data, RTE_TEL_CONTAINER);
+
+     for (i = 0; i < 5; i++) {
+             rte_tel_data_add_array_bool(child_data, (i % 2) == 0);
+             rte_tel_data_add_array_bool(child_data2, (i % 2) == 1);
+     }
+     rte_tel_data_add_array_container(&response_data, child_data, 0);
+     rte_tel_data_add_array_container(&response_data, child_data2, 0);
+
+     return CHECK_OUTPUT("[[true,false,true,false,true],[false,true,false,true,false]]");
+}
+
  static int
  test_string_char_escaping(void)
  {
@@ -428,15 +506,21 @@ telemetry_data_autotest(void)
                      test_null_return,
                      test_simple_string,
                      test_case_array_string,
-                     test_case_array_int, test_case_array_u64,
-                     test_case_add_dict_int, test_case_add_dict_u64,
+                     test_case_array_int,
+                     test_case_array_u64,
+                     test_case_array_bool,
+                     test_case_add_dict_int,
+                     test_case_add_dict_u64,
+                     test_case_add_dict_bool,
                      test_case_add_dict_string,
                      test_dict_with_array_int_values,
                      test_dict_with_array_u64_values,
+                     test_dict_with_array_bool_values,
                      test_dict_with_array_string_values,
                      test_dict_with_dict_values,
                      test_array_with_array_int_values,
                      test_array_with_array_u64_values,
+                     test_array_with_array_bool_values,
                      test_array_with_array_string_values,
                      test_string_char_escaping,
                      test_array_char_escaping,
lib/telemetry/rte_telemetry.h +18 -0
index a0d21d6b7f..e7f6c2ae43 100644
@@ -2,6 +2,7 @@
   * Copyright(c) 2018 Intel Corporation
   */
 
+#include <stdbool.h>
  #include <stdint.h>
 
  #include <rte_compat.h>
@@ -46,6 +47,7 @@ enum rte_tel_value_type {
      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 */
+     RTE_TEL_BOOL_VAL,   /** a boolean value */
  };
 
  /**
@@ -155,6 +157,22 @@ int
  rte_tel_data_add_array_container(struct rte_tel_data *d,
              struct rte_tel_data *val, int keep);
 
+/**
+ * Add a boolean to an array.
+ * The array must have been started by rte_tel_data_start_array() with
+ * RTE_TEL_BOOL_VAL as the type parameter.
+ *
+ * @param d
+ *   The data structure passed to the callback
+ * @param x
+ *   The boolean value to be returned in the array
+ * @return
+ *   0 on success, negative errno on error
+ */
+__rte_experimental
+int
+rte_tel_data_add_array_bool(struct rte_tel_data *d, bool x);
+
  /**
   * Add a string value to a dictionary.
   * The dict must have been started by rte_tel_data_start_dict().

lib/telemetry/rte_telemetry.h int · line 256

Quoted 6 lines
lib/telemetry/rte_telemetry.h +3 -0
@@ -233,6 +251,24 @@ int
  rte_tel_data_add_dict_container(struct rte_tel_data *d, const char *name,
              struct rte_tel_data *val, int keep);
 
+/**
+ * Add a boolean value to a dictionary.
+ * The dict must have been started by rte_tel_data_start_dict().

...as RTE_TEL_BOOL_VAL as the type parameter?

Quoted 23 lines
lib/telemetry/rte_telemetry.h +15 -0
+ *
+ * @param d
+ *   The data structure passed to the callback
+ * @param name
+ *   The name the value is to be stored under in the dict
+ *   Must contain only alphanumeric characters or the symbols: '_' or '/'
+ * @param val
+ *   The boolean value to be stored in the dict
+ * @return
+ *   0 on success, negative errno on error, E2BIG on string truncation of name.
+ */
+__rte_experimental
+int
+rte_tel_data_add_dict_bool(struct rte_tel_data *d, const char *name, bool val);
+
  /**
   * This telemetry callback is used when registering a telemetry command.
   * It handles getting and formatting information to be returned to telemetry
lib/telemetry/telemetry.c +0 -0
index 8fbb4f3060..276d0f337d 100644

lib/telemetry/telemetry.c container_to_json(const struct rte_tel_data *d, char *out_buf, size_t buf_len) · line 173

Quoted 7 lines
lib/telemetry/telemetry.c +3 -1
@@ -168,7 +168,9 @@ container_to_json(const struct rte_tel_data *d, char *out_buf, size_t buf_len)
      unsigned int i;
 
      if (d->type != RTE_TEL_DICT && d->type != RTE_TEL_ARRAY_U64 &&
-             d->type != RTE_TEL_ARRAY_INT && d->type != RTE_TEL_ARRAY_STRING)
+                     d->type != RTE_TEL_ARRAY_INT &&
+                     d->type != RTE_TEL_ARRAY_STRING &&
+                     d->type != RTE_TEL_ARRAY_BOOL)

Use a switch for improved readability.

lib/telemetry/telemetry.c container_to_json(const struct rte_tel_data *d, char *out_buf, size_t buf_len) · line 192

Quoted 8 lines
lib/telemetry/telemetry.c +1 -0
              return snprintf(out_buf, buf_len, "null");
 
      used = rte_tel_json_empty_array(out_buf, buf_len, 0);
@@ -187,6 +189,11 @@ container_to_json(const struct rte_tel_data *d, char *out_buf, size_t buf_len)
                      used = rte_tel_json_add_array_string(out_buf,
                              buf_len, used,
                              d->data.array[i].sval);
+     if (d->type == RTE_TEL_ARRAY_BOOL)

This whole section should be refactor to use a switch statement, imo.

Quoted 57 lines
lib/telemetry/telemetry.c +19 -0
+             for (i = 0; i < d->data_len; i++)
+                     used = rte_tel_json_add_array_bool(out_buf,
+                             buf_len, used,
+                             d->data.array[i].boolval);
      if (d->type == RTE_TEL_DICT)
              for (i = 0; i < d->data_len; i++) {
                      const struct tel_dict_entry *v = &d->data.dict[i];
@@ -206,6 +213,11 @@ container_to_json(const struct rte_tel_data *d, char *out_buf, size_t buf_len)
                                              buf_len, used,
                                              v->name, v->value.u64val);
                              break;
+                     case RTE_TEL_BOOL_VAL:
+                             used = rte_tel_json_add_obj_bool(out_buf,
+                                             buf_len, used,
+                                             v->name, v->value.boolval);
+                             break;
                      case RTE_TEL_CONTAINER:
                      {
                              char temp[buf_len];
@@ -273,6 +285,11 @@ 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_BOOL_VAL:
+                             used = rte_tel_json_add_obj_bool(cb_data_buf,
+                                             buf_len, used,
+                                             v->name, v->value.boolval);
+                             break;
                      case RTE_TEL_CONTAINER:
                      {
                              char temp[buf_len];
@@ -294,6 +311,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_BOOL:
      case RTE_TEL_ARRAY_CONTAINER:
              used = rte_tel_json_empty_array(cb_data_buf, buf_len, 0);
              for (i = 0; i < d->data_len; i++)
@@ -310,6 +328,10 @@ 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_BOOL)
+                             used = rte_tel_json_add_array_bool(cb_data_buf,
+                                             buf_len, used,
+                                             d->data.array[i].boolval);
                      else if (d->type == RTE_TEL_ARRAY_CONTAINER) {
                              char temp[buf_len];
                              const struct container *rec_data =
lib/telemetry/telemetry_data.c +0 -0
index 34366ecee3..13a7ce7034 100644
@@ -16,10 +16,11 @@ int
  rte_tel_data_start_array(struct rte_tel_data *d, enum rte_tel_value_type type)
  {

lib/telemetry/telemetry_data.c int · line 23

Quoted 10 lines
lib/telemetry/telemetry_data.c +5 -4
      enum tel_container_types array_types[] = {
-                     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 */
+             [RTE_TEL_STRING_VAL] = RTE_TEL_ARRAY_STRING,
+             [RTE_TEL_INT_VAL] = RTE_TEL_ARRAY_INT,
+             [RTE_TEL_U64_VAL] = RTE_TEL_ARRAY_U64,
+             [RTE_TEL_CONTAINER] = RTE_TEL_ARRAY_CONTAINER,
+             [RTE_TEL_BOOL_VAL] = RTE_TEL_ARRAY_BOOL,

Seems like a brittle construct to me. Replace this with a switch statement.

Quoted 22 lines
lib/telemetry/telemetry_data.c +11 -0
      };
      d->type = array_types[type];
      d->data_len = 0;
@@ -80,6 +81,17 @@ rte_tel_data_add_array_u64(struct rte_tel_data *d, uint64_t x)
      return 0;
  }
 
+int
+rte_tel_data_add_array_bool(struct rte_tel_data *d, bool x)
+{
+     if (d->type != RTE_TEL_ARRAY_BOOL)
+             return -EINVAL;
+     if (d->data_len >= RTE_TEL_MAX_ARRAY_ENTRIES)
+             return -ENOSPC;
+     d->data.array[d->data_len++].boolval = x;
+     return 0;
+}
+
  int
  rte_tel_data_add_array_container(struct rte_tel_data *d,
              struct rte_tel_data *val, int keep)

lib/telemetry/telemetry_data.c rte_tel_data_add_array_container(struct rte_tel_data *d, · line 103

Quoted 6 lines
lib/telemetry/telemetry_data.c +2 -1
@@ -87,7 +99,8 @@ rte_tel_data_add_array_container(struct rte_tel_data *d,
      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))
+                     && val->type != RTE_TEL_ARRAY_STRING
+                     && val->type != RTE_TEL_ARRAY_BOOL))

Maybe the introduction of a valid_type() static function would be in order? Implemented by means of a (surprise!) switch statement. :)

Could be is_valid_type() and rename valid_name() us_valid_name() in the process.

Use in rte_tel_data_add_dict_container() as well.

Quoted 83 lines
lib/telemetry/telemetry_data.c +21 -0
              return -EINVAL;
      if (d->data_len >= RTE_TEL_MAX_ARRAY_ENTRIES)
              return -ENOSPC;
@@ -179,6 +192,26 @@ rte_tel_data_add_dict_u64(struct rte_tel_data *d,
      return bytes < RTE_TEL_MAX_STRING_LEN ? 0 : E2BIG;
  }
 
+int
+rte_tel_data_add_dict_bool(struct rte_tel_data *d,
+             const char *name, bool val)
+{
+     struct tel_dict_entry *e = &d->data.dict[d->data_len];
+     if (d->type != RTE_TEL_DICT)
+             return -EINVAL;
+     if (d->data_len >= RTE_TEL_MAX_DICT_ENTRIES)
+             return -ENOSPC;
+
+     if (!valid_name(name))
+             return -EINVAL;
+
+     d->data_len++;
+     e->type = RTE_TEL_BOOL_VAL;
+     e->value.boolval = val;
+     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)
@@ -188,6 +221,7 @@ rte_tel_data_add_dict_container(struct rte_tel_data *d, const char *name,
      if (d->type != RTE_TEL_DICT || (val->type != RTE_TEL_ARRAY_U64
                      && val->type != RTE_TEL_ARRAY_INT
                      && val->type != RTE_TEL_ARRAY_STRING
+                     && val->type != RTE_TEL_ARRAY_BOOL
                      && val->type != RTE_TEL_DICT))
              return -EINVAL;
      if (d->data_len >= RTE_TEL_MAX_DICT_ENTRIES)
lib/telemetry/telemetry_data.h +5 -0
index 26aa28e72c..c840486b18 100644
@@ -5,6 +5,9 @@
  #ifndef _TELEMETRY_DATA_H_
  #define _TELEMETRY_DATA_H_
 
+#include <stdbool.h>
+#include <stdint.h>
+
  #include "rte_telemetry.h"
 
  enum tel_container_types {
@@ -15,6 +18,7 @@ enum tel_container_types {
      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 */
+     RTE_TEL_ARRAY_BOOL,   /** array of boolean values */
  };
 
  struct container {
@@ -30,6 +34,7 @@ union tel_value {
      char sval[RTE_TEL_MAX_STRING_LEN];
      int ival;
      uint64_t u64val;
+     bool boolval;
      struct container container;
  };
 
lib/telemetry/telemetry_json.h +1 -0
index e3fae7c30d..c97da97366 100644
@@ -7,6 +7,7 @@
 
  #include <inttypes.h>
  #include <stdarg.h>
+#include <stdbool.h>
  #include <stdio.h>
  #include <rte_common.h>
  #include <rte_telemetry.h>
@@ -159,6 +160,21 @@ rte_tel_json_add_array_u64(char *buf, const int len, const int used,
      return ret == 0 ? used : end + ret;
  }

lib/telemetry/telemetry_json.h rte_tel_json_add_array_u64(char *buf, const int len, const int used, · line 171

Quoted 10 lines
lib/telemetry/telemetry_json.h +9 -0
 
+/* Appends a boolean into the JSON array in the provided buffer. */
+static inline int
+rte_tel_json_add_array_bool(char *buf, const int len, const int used,
+             bool val)
+{
+     int ret, end = used - 1; /* strip off final delimiter */
+     if (used <= 2) /* assume empty, since minimum is '[]' */
+             return __json_snprintf(buf, len, "[%s]",
+                             val ? "true" : "false");

Have "true" and "false" as #defines, and make a bool_str() helper, which returns the (constant) string form.

Quoted 10 lines
lib/telemetry/telemetry_json.h +6 -0
+
+     ret = __json_snprintf(buf + end, len - end, ",%s]",
+                     val ? "true" : "false");
+     return ret == 0 ? used : end + ret;
+}
+
  /*
   * Add a new element with raw JSON value to the JSON array stored in the
   * provided buffer.

lib/telemetry/telemetry_json.h rte_tel_json_add_obj_u64(char *buf, const int len, const int used, · line 216

Quoted 8 lines
lib/telemetry/telemetry_json.h +5 -0
@@ -193,6 +209,24 @@ rte_tel_json_add_obj_u64(char *buf, const int len, const int used,
      return ret == 0 ? used : end + ret;
  }
 
+/**
+ * Add a new element with boolean value to the JSON object stored in the
+ * provided buffer.
+ */
+static inline int

I know this pattern isn't introduced in this patch, but why is this function in the header file?

lib/telemetry/telemetry_json.h rte_tel_json_add_obj_u64(char *buf, const int len, const int used, · line 221

Quoted 5 lines
lib/telemetry/telemetry_json.h +5 -0
+rte_tel_json_add_obj_bool(char *buf, const int len, const int used,
+             const char *name, bool val)
+{
+     int ret, end = used - 1;
+     if (used <= 2) /* assume empty, since minimum is '{}' */

RTE_ASSERT() wouldn't be more helpful? The input buffer is malformed, correct?

Either way, the magic '2' should be a #define.

lib/telemetry/telemetry_json.h rte_tel_json_add_obj_u64(char *buf, const int len, const int used, · line 229

Quoted 8 lines
lib/telemetry/telemetry_json.h +8 -0
+             return __json_snprintf(buf, len, "{\"%s\":%s}", name,
+                             val ? "true" : "false");
+
+     ret = __json_snprintf(buf + end, len - end, ",\"%s\":%s}",
+                     name, val ? "true" : "false");
+     return ret == 0 ? used : end + ret;
+}
+

This looks like cut-and-paste. Merge into one function, parameterized by the start and end delimiter.

Quoted 11 lines
lib/telemetry/telemetry_json.h +0 -0
  /**
   * Add a new element with int value to the JSON object stored in the
   * provided buffer.
lib/telemetry/version.map +0 -0
index 9794f9ea20..88f58d4d89 100644
@@ -19,7 +19,17 @@ DPDK_23 {
      local: *;
  };
 
Quoted 15 lines
Quoted 4 lines
lib/telemetry/version.map +4 -0
+EXPERIMENTAL {
+     global:
+
+     # added in 22.11

lib/telemetry/version.map DPDK_23 { · line 35

Quoted 10 lines
lib/telemetry/version.map +6 -0
+     rte_tel_data_add_array_bool;
+     rte_tel_data_add_dict_bool;
+};
+
  INTERNAL {
+     global:
+
      rte_telemetry_legacy_register;
      rte_telemetry_init;
  };

I agree with most of the comments.
I can follow up on those cleanups, but I don't have the time now.

I'll let the telemetry maintainers decide on the fate of those patches. Thanks.

Signature · 1 line
David Marchand
#14 lore raw

Re: [PATCH v3 1/4] telemetry: support boolean type

Quoted 509 lines · David Marchand
Quoted 492 lines · Mattias Rönnblom
Quoted 177 lines · David Marchand

Add the boolean type RTE_TEL_BOOL_VAL for values in arrays and dicts.

---
Changes since v1:
- fixed doxygen description,

---
  app/test/test_telemetry_data.c | 88 +++++++++++++++++++++++++++++++++-
  lib/telemetry/rte_telemetry.h  | 36 ++++++++++++++
  lib/telemetry/telemetry.c      | 24 +++++++++-
  lib/telemetry/telemetry_data.c | 44 +++++++++++++++--
  lib/telemetry/telemetry_data.h |  5 ++
  lib/telemetry/telemetry_json.h | 34 +++++++++++++
  lib/telemetry/version.map      | 10 ++++
  7 files changed, 233 insertions(+), 8 deletions(-)
app/test/test_telemetry_data.c +86 -2
index d92667a527..134e018fde 100644
@@ -353,6 +353,84 @@ test_array_with_array_u64_values(void)
      return CHECK_OUTPUT("[[0,1,2,3,4],[0,1,2,3,4]]");
  }
 
+static int
+test_case_array_bool(void)
+{
+     int i;
+
+     rte_tel_data_start_array(&response_data, RTE_TEL_BOOL_VAL);
+     for (i = 0; i < 5; i++)
+             rte_tel_data_add_array_bool(&response_data, (i % 2) == 0);
+     return CHECK_OUTPUT("[true,false,true,false,true]");
+}
+
+static int
+test_case_add_dict_bool(void)
+{
+     int i = 0;
+     char name_of_value[8];
+
+     rte_tel_data_start_dict(&response_data);
+
+     for (i = 0; i < 5; i++) {
+             sprintf(name_of_value, "dict_%d", i);
+             rte_tel_data_add_dict_bool(&response_data, name_of_value,
+                     (i % 2) == 0);
+     }
+     return CHECK_OUTPUT("{\"dict_0\":true,\"dict_1\":false,\"dict_2\":true,"
+             "\"dict_3\":false,\"dict_4\":true}");
+}
+
+static int
+test_dict_with_array_bool_values(void)
+{
+     int i;
+
+     struct rte_tel_data *child_data = rte_tel_data_alloc();
+     rte_tel_data_start_array(child_data, RTE_TEL_BOOL_VAL);
+
+     struct rte_tel_data *child_data2 = rte_tel_data_alloc();
+     rte_tel_data_start_array(child_data2, RTE_TEL_BOOL_VAL);
+
+     rte_tel_data_start_dict(&response_data);
+
+     for (i = 0; i < 10; i++) {
+             rte_tel_data_add_array_bool(child_data, (i % 2) == 0);
+             rte_tel_data_add_array_bool(child_data2, (i % 2) == 1);
+     }
+
+     rte_tel_data_add_dict_container(&response_data, "dict_0",
+      child_data, 0);
+     rte_tel_data_add_dict_container(&response_data, "dict_1",
+      child_data2, 0);
+
+     return CHECK_OUTPUT("{\"dict_0\":[true,false,true,false,true,false,true,false,true,false],"
+             "\"dict_1\":[false,true,false,true,false,true,false,true,false,true]}");
+}
+
+static int
+test_array_with_array_bool_values(void)
+{
+     int i;
+
+     struct rte_tel_data *child_data = rte_tel_data_alloc();
+     rte_tel_data_start_array(child_data, RTE_TEL_BOOL_VAL);
+
+     struct rte_tel_data *child_data2 = rte_tel_data_alloc();
+     rte_tel_data_start_array(child_data2, RTE_TEL_BOOL_VAL);
+
+     rte_tel_data_start_array(&response_data, RTE_TEL_CONTAINER);
+
+     for (i = 0; i < 5; i++) {
+             rte_tel_data_add_array_bool(child_data, (i % 2) == 0);
+             rte_tel_data_add_array_bool(child_data2, (i % 2) == 1);
+     }
+     rte_tel_data_add_array_container(&response_data, child_data, 0);
+     rte_tel_data_add_array_container(&response_data, child_data2, 0);
+
+     return CHECK_OUTPUT("[[true,false,true,false,true],[false,true,false,true,false]]");
+}
+
  static int
  test_string_char_escaping(void)
  {
@@ -428,15 +506,21 @@ telemetry_data_autotest(void)
                      test_null_return,
                      test_simple_string,
                      test_case_array_string,
-                     test_case_array_int, test_case_array_u64,
-                     test_case_add_dict_int, test_case_add_dict_u64,
+                     test_case_array_int,
+                     test_case_array_u64,
+                     test_case_array_bool,
+                     test_case_add_dict_int,
+                     test_case_add_dict_u64,
+                     test_case_add_dict_bool,
                      test_case_add_dict_string,
                      test_dict_with_array_int_values,
                      test_dict_with_array_u64_values,
+                     test_dict_with_array_bool_values,
                      test_dict_with_array_string_values,
                      test_dict_with_dict_values,
                      test_array_with_array_int_values,
                      test_array_with_array_u64_values,
+                     test_array_with_array_bool_values,
                      test_array_with_array_string_values,
                      test_string_char_escaping,
                      test_array_char_escaping,
lib/telemetry/rte_telemetry.h +18 -0
index a0d21d6b7f..e7f6c2ae43 100644
@@ -2,6 +2,7 @@
   * Copyright(c) 2018 Intel Corporation
   */
 
+#include <stdbool.h>
  #include <stdint.h>
 
  #include <rte_compat.h>
@@ -46,6 +47,7 @@ enum rte_tel_value_type {
      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 */
+     RTE_TEL_BOOL_VAL,   /** a boolean value */
  };
 
  /**
@@ -155,6 +157,22 @@ int
  rte_tel_data_add_array_container(struct rte_tel_data *d,
              struct rte_tel_data *val, int keep);
 
+/**
+ * Add a boolean to an array.
+ * The array must have been started by rte_tel_data_start_array() with
+ * RTE_TEL_BOOL_VAL as the type parameter.
+ *
+ * @param d
+ *   The data structure passed to the callback
+ * @param x
+ *   The boolean value to be returned in the array
+ * @return
+ *   0 on success, negative errno on error
+ */
+__rte_experimental
+int
+rte_tel_data_add_array_bool(struct rte_tel_data *d, bool x);
+
  /**
   * Add a string value to a dictionary.
   * The dict must have been started by rte_tel_data_start_dict().

lib/telemetry/rte_telemetry.h int · line 256

Quoted 6 lines
lib/telemetry/rte_telemetry.h +3 -0
@@ -233,6 +251,24 @@ int
  rte_tel_data_add_dict_container(struct rte_tel_data *d, const char *name,
              struct rte_tel_data *val, int keep);
 
+/**
+ * Add a boolean value to a dictionary.
+ * The dict must have been started by rte_tel_data_start_dict().

...as RTE_TEL_BOOL_VAL as the type parameter?

Quoted 23 lines
lib/telemetry/rte_telemetry.h +15 -0
+ *
+ * @param d
+ *   The data structure passed to the callback
+ * @param name
+ *   The name the value is to be stored under in the dict
+ *   Must contain only alphanumeric characters or the symbols: '_' or '/'
+ * @param val
+ *   The boolean value to be stored in the dict
+ * @return
+ *   0 on success, negative errno on error, E2BIG on string truncation of name.
+ */
+__rte_experimental
+int
+rte_tel_data_add_dict_bool(struct rte_tel_data *d, const char *name, bool val);
+
  /**
   * This telemetry callback is used when registering a telemetry command.
   * It handles getting and formatting information to be returned to telemetry
lib/telemetry/telemetry.c +0 -0
index 8fbb4f3060..276d0f337d 100644

lib/telemetry/telemetry.c container_to_json(const struct rte_tel_data *d, char *out_buf, size_t buf_len) · line 173

Quoted 7 lines
lib/telemetry/telemetry.c +3 -1
@@ -168,7 +168,9 @@ container_to_json(const struct rte_tel_data *d, char *out_buf, size_t buf_len)
      unsigned int i;
 
      if (d->type != RTE_TEL_DICT && d->type != RTE_TEL_ARRAY_U64 &&
-             d->type != RTE_TEL_ARRAY_INT && d->type != RTE_TEL_ARRAY_STRING)
+                     d->type != RTE_TEL_ARRAY_INT &&
+                     d->type != RTE_TEL_ARRAY_STRING &&
+                     d->type != RTE_TEL_ARRAY_BOOL)

Use a switch for improved readability.

lib/telemetry/telemetry.c container_to_json(const struct rte_tel_data *d, char *out_buf, size_t buf_len) · line 192

Quoted 8 lines
lib/telemetry/telemetry.c +1 -0
              return snprintf(out_buf, buf_len, "null");
 
      used = rte_tel_json_empty_array(out_buf, buf_len, 0);
@@ -187,6 +189,11 @@ container_to_json(const struct rte_tel_data *d, char *out_buf, size_t buf_len)
                      used = rte_tel_json_add_array_string(out_buf,
                              buf_len, used,
                              d->data.array[i].sval);
+     if (d->type == RTE_TEL_ARRAY_BOOL)

This whole section should be refactor to use a switch statement, imo.

Quoted 57 lines
lib/telemetry/telemetry.c +19 -0
+             for (i = 0; i < d->data_len; i++)
+                     used = rte_tel_json_add_array_bool(out_buf,
+                             buf_len, used,
+                             d->data.array[i].boolval);
      if (d->type == RTE_TEL_DICT)
              for (i = 0; i < d->data_len; i++) {
                      const struct tel_dict_entry *v = &d->data.dict[i];
@@ -206,6 +213,11 @@ container_to_json(const struct rte_tel_data *d, char *out_buf, size_t buf_len)
                                              buf_len, used,
                                              v->name, v->value.u64val);
                              break;
+                     case RTE_TEL_BOOL_VAL:
+                             used = rte_tel_json_add_obj_bool(out_buf,
+                                             buf_len, used,
+                                             v->name, v->value.boolval);
+                             break;
                      case RTE_TEL_CONTAINER:
                      {
                              char temp[buf_len];
@@ -273,6 +285,11 @@ 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_BOOL_VAL:
+                             used = rte_tel_json_add_obj_bool(cb_data_buf,
+                                             buf_len, used,
+                                             v->name, v->value.boolval);
+                             break;
                      case RTE_TEL_CONTAINER:
                      {
                              char temp[buf_len];
@@ -294,6 +311,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_BOOL:
      case RTE_TEL_ARRAY_CONTAINER:
              used = rte_tel_json_empty_array(cb_data_buf, buf_len, 0);
              for (i = 0; i < d->data_len; i++)
@@ -310,6 +328,10 @@ 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_BOOL)
+                             used = rte_tel_json_add_array_bool(cb_data_buf,
+                                             buf_len, used,
+                                             d->data.array[i].boolval);
                      else if (d->type == RTE_TEL_ARRAY_CONTAINER) {
                              char temp[buf_len];
                              const struct container *rec_data =
lib/telemetry/telemetry_data.c +0 -0
index 34366ecee3..13a7ce7034 100644
@@ -16,10 +16,11 @@ int
  rte_tel_data_start_array(struct rte_tel_data *d, enum rte_tel_value_type type)
  {

lib/telemetry/telemetry_data.c int · line 23

Quoted 10 lines
lib/telemetry/telemetry_data.c +5 -4
      enum tel_container_types array_types[] = {
-                     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 */
+             [RTE_TEL_STRING_VAL] = RTE_TEL_ARRAY_STRING,
+             [RTE_TEL_INT_VAL] = RTE_TEL_ARRAY_INT,
+             [RTE_TEL_U64_VAL] = RTE_TEL_ARRAY_U64,
+             [RTE_TEL_CONTAINER] = RTE_TEL_ARRAY_CONTAINER,
+             [RTE_TEL_BOOL_VAL] = RTE_TEL_ARRAY_BOOL,

Seems like a brittle construct to me. Replace this with a switch statement.

Quoted 22 lines
lib/telemetry/telemetry_data.c +11 -0
      };
      d->type = array_types[type];
      d->data_len = 0;
@@ -80,6 +81,17 @@ rte_tel_data_add_array_u64(struct rte_tel_data *d, uint64_t x)
      return 0;
  }
 
+int
+rte_tel_data_add_array_bool(struct rte_tel_data *d, bool x)
+{
+     if (d->type != RTE_TEL_ARRAY_BOOL)
+             return -EINVAL;
+     if (d->data_len >= RTE_TEL_MAX_ARRAY_ENTRIES)
+             return -ENOSPC;
+     d->data.array[d->data_len++].boolval = x;
+     return 0;
+}
+
  int
  rte_tel_data_add_array_container(struct rte_tel_data *d,
              struct rte_tel_data *val, int keep)

lib/telemetry/telemetry_data.c rte_tel_data_add_array_container(struct rte_tel_data *d, · line 103

Quoted 6 lines
lib/telemetry/telemetry_data.c +2 -1
@@ -87,7 +99,8 @@ rte_tel_data_add_array_container(struct rte_tel_data *d,
      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))
+                     && val->type != RTE_TEL_ARRAY_STRING
+                     && val->type != RTE_TEL_ARRAY_BOOL))

Maybe the introduction of a valid_type() static function would be in order? Implemented by means of a (surprise!) switch statement. :)

Could be is_valid_type() and rename valid_name() us_valid_name() in the process.

Use in rte_tel_data_add_dict_container() as well.

Quoted 83 lines
lib/telemetry/telemetry_data.c +21 -0
              return -EINVAL;
      if (d->data_len >= RTE_TEL_MAX_ARRAY_ENTRIES)
              return -ENOSPC;
@@ -179,6 +192,26 @@ rte_tel_data_add_dict_u64(struct rte_tel_data *d,
      return bytes < RTE_TEL_MAX_STRING_LEN ? 0 : E2BIG;
  }
 
+int
+rte_tel_data_add_dict_bool(struct rte_tel_data *d,
+             const char *name, bool val)
+{
+     struct tel_dict_entry *e = &d->data.dict[d->data_len];
+     if (d->type != RTE_TEL_DICT)
+             return -EINVAL;
+     if (d->data_len >= RTE_TEL_MAX_DICT_ENTRIES)
+             return -ENOSPC;
+
+     if (!valid_name(name))
+             return -EINVAL;
+
+     d->data_len++;
+     e->type = RTE_TEL_BOOL_VAL;
+     e->value.boolval = val;
+     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)
@@ -188,6 +221,7 @@ rte_tel_data_add_dict_container(struct rte_tel_data *d, const char *name,
      if (d->type != RTE_TEL_DICT || (val->type != RTE_TEL_ARRAY_U64
                      && val->type != RTE_TEL_ARRAY_INT
                      && val->type != RTE_TEL_ARRAY_STRING
+                     && val->type != RTE_TEL_ARRAY_BOOL
                      && val->type != RTE_TEL_DICT))
              return -EINVAL;
      if (d->data_len >= RTE_TEL_MAX_DICT_ENTRIES)
lib/telemetry/telemetry_data.h +5 -0
index 26aa28e72c..c840486b18 100644
@@ -5,6 +5,9 @@
  #ifndef _TELEMETRY_DATA_H_
  #define _TELEMETRY_DATA_H_
 
+#include <stdbool.h>
+#include <stdint.h>
+
  #include "rte_telemetry.h"
 
  enum tel_container_types {
@@ -15,6 +18,7 @@ enum tel_container_types {
      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 */
+     RTE_TEL_ARRAY_BOOL,   /** array of boolean values */
  };
 
  struct container {
@@ -30,6 +34,7 @@ union tel_value {
      char sval[RTE_TEL_MAX_STRING_LEN];
      int ival;
      uint64_t u64val;
+     bool boolval;
      struct container container;
  };
 
lib/telemetry/telemetry_json.h +1 -0
index e3fae7c30d..c97da97366 100644
@@ -7,6 +7,7 @@
 
  #include <inttypes.h>
  #include <stdarg.h>
+#include <stdbool.h>
  #include <stdio.h>
  #include <rte_common.h>
  #include <rte_telemetry.h>
@@ -159,6 +160,21 @@ rte_tel_json_add_array_u64(char *buf, const int len, const int used,
      return ret == 0 ? used : end + ret;
  }

lib/telemetry/telemetry_json.h rte_tel_json_add_array_u64(char *buf, const int len, const int used, · line 171

Quoted 10 lines
lib/telemetry/telemetry_json.h +9 -0
 
+/* Appends a boolean into the JSON array in the provided buffer. */
+static inline int
+rte_tel_json_add_array_bool(char *buf, const int len, const int used,
+             bool val)
+{
+     int ret, end = used - 1; /* strip off final delimiter */
+     if (used <= 2) /* assume empty, since minimum is '[]' */
+             return __json_snprintf(buf, len, "[%s]",
+                             val ? "true" : "false");

Have "true" and "false" as #defines, and make a bool_str() helper, which returns the (constant) string form.

Quoted 10 lines
lib/telemetry/telemetry_json.h +6 -0
+
+     ret = __json_snprintf(buf + end, len - end, ",%s]",
+                     val ? "true" : "false");
+     return ret == 0 ? used : end + ret;
+}
+
  /*
   * Add a new element with raw JSON value to the JSON array stored in the
   * provided buffer.

lib/telemetry/telemetry_json.h rte_tel_json_add_obj_u64(char *buf, const int len, const int used, · line 216

Quoted 8 lines
lib/telemetry/telemetry_json.h +5 -0
@@ -193,6 +209,24 @@ rte_tel_json_add_obj_u64(char *buf, const int len, const int used,
      return ret == 0 ? used : end + ret;
  }
 
+/**
+ * Add a new element with boolean value to the JSON object stored in the
+ * provided buffer.
+ */
+static inline int

I know this pattern isn't introduced in this patch, but why is this function in the header file?

lib/telemetry/telemetry_json.h rte_tel_json_add_obj_u64(char *buf, const int len, const int used, · line 221

Quoted 5 lines
lib/telemetry/telemetry_json.h +5 -0
+rte_tel_json_add_obj_bool(char *buf, const int len, const int used,
+             const char *name, bool val)
+{
+     int ret, end = used - 1;
+     if (used <= 2) /* assume empty, since minimum is '{}' */

RTE_ASSERT() wouldn't be more helpful? The input buffer is malformed, correct?

Either way, the magic '2' should be a #define.

lib/telemetry/telemetry_json.h rte_tel_json_add_obj_u64(char *buf, const int len, const int used, · line 229

Quoted 8 lines
lib/telemetry/telemetry_json.h +8 -0
+             return __json_snprintf(buf, len, "{\"%s\":%s}", name,
+                             val ? "true" : "false");
+
+     ret = __json_snprintf(buf + end, len - end, ",\"%s\":%s}",
+                     name, val ? "true" : "false");
+     return ret == 0 ? used : end + ret;
+}
+

This looks like cut-and-paste. Merge into one function, parameterized by the start and end delimiter.

Quoted 11 lines
lib/telemetry/telemetry_json.h +0 -0
  /**
   * Add a new element with int value to the JSON object stored in the
   * provided buffer.
lib/telemetry/version.map +0 -0
index 9794f9ea20..88f58d4d89 100644
@@ -19,7 +19,17 @@ DPDK_23 {
      local: *;
  };
 
Quoted 15 lines
Quoted 4 lines
lib/telemetry/version.map +4 -0
+EXPERIMENTAL {
+     global:
+
+     # added in 22.11

lib/telemetry/version.map DPDK_23 { · line 35

Quoted 10 lines
lib/telemetry/version.map +6 -0
+     rte_tel_data_add_array_bool;
+     rte_tel_data_add_dict_bool;
+};
+
  INTERNAL {
+     global:
+
      rte_telemetry_legacy_register;
      rte_telemetry_init;
  };
Quoted 6 lines

I agree with most of the comments.
I can follow up on those cleanups, but I don't have the time now.

I'll let the telemetry maintainers decide on the fate of those patches. Thanks.

Well, given the lateness in the release process, if it's a choice between getting the patches in as-is, vs not getting them in at all, I think having them in 22.11 is the better choice. While there is cleanup that can be done, I don't see this patch as making the overall code any worse.

My 2c.

/Bruce

#15 lore raw

RE: [PATCH v3 1/4] telemetry: support boolean type

Quoted 26 lines

-----Original Message-----
From: Richardson, Bruce <[email protected]>
Sent: Tuesday 25 October 2022 11:39
To: David Marchand <[email protected]>
Cc: Mattias Rönnblom <[email protected]>; [email protected]; Morten Brørup <[email protected]>; Power, Ciara <[email protected]>
Subject: Re: [PATCH v3 1/4] telemetry: support boolean type

Quoted 1 line · David Marchand

On Tue, Oct 25, 2022 at 11:34 AM Mattias Rönnblom

Quoted 3 lines · <[email protected]> wrote:
Quoted 3 lines · David Marchand
Quoted 1 line

Add the boolean type RTE_TEL_BOOL_VAL for values in arrays and

dicts.

Quoted 8 lines
Quoted 8 lines
Quoted 8 lines

---
Changes since v1:
- fixed doxygen description,

<snip>

Quoted 11 lines
Quoted 3 lines

I'll let the telemetry maintainers decide on the fate of those patches. Thanks.

Well, given the lateness in the release process, if it's a choice between getting the patches in as-is, vs not getting them in at all, I think having them in 22.11 is the better choice. While there is cleanup that can be done, I don't see this patch as making the overall code any worse.

My 2c.

/Bruce

Agreed, it's a good addition to the library, +1 to having it in 22.11

Thanks,
Ciara

#16 lore raw

PATCH v3 2/4 telemetry: extend valid command characters

In reply to David Marchand

The trace framework wants to reference trace point names as keys in dicts. Those names can contain '.', so add it to the list of valid characters in the telemetry library.

---
 lib/telemetry/rte_telemetry.h  | 10 +++++-----
 lib/telemetry/telemetry_data.c |  1 +
 2 files changed, 6 insertions(+), 5 deletions(-)
lib/telemetry/rte_telemetry.h +5 -5
index e7f6c2ae43..5bd0fc323e 100644
@@ -68,7 +68,7 @@ rte_tel_data_start_array(struct rte_tel_data *d, enum rte_tel_value_type type);
  *
  * Dictionaries consist of key-values pairs to be returned, where the keys,
  * or names, are strings and the values can be any of the types supported by telemetry.
- * Name strings may only contain alphanumeric characters as well as '_' or '/'
+ * Name strings may only contain alphanumeric characters as well as '_', '/' or '.'
  *
  * @param d
  *   The data structure passed to the callback
@@ -181,7 +181,7 @@ rte_tel_data_add_array_bool(struct rte_tel_data *d, bool x);
  *   The data structure passed to the callback
  * @param name
  *   The name the value is to be stored under in the dict
- *   Must contain only alphanumeric characters or the symbols: '_' or '/'
+ *   Must contain only alphanumeric characters or the symbols: '_', '/' or '.'
  * @param val
  *   The string to be stored in the dict
  * @return
@@ -200,7 +200,7 @@ rte_tel_data_add_dict_string(struct rte_tel_data *d, const char *name,
  *   The data structure passed to the callback
  * @param name
  *   The name the value is to be stored under in the dict
- *   Must contain only alphanumeric characters or the symbols: '_' or '/'
+ *   Must contain only alphanumeric characters or the symbols: '_', '/' or '.'
  * @param val
  *   The number to be stored in the dict
  * @return
@@ -217,7 +217,7 @@ rte_tel_data_add_dict_int(struct rte_tel_data *d, const char *name, int val);
  *   The data structure passed to the callback
  * @param name
  *   The name the value is to be stored under in the dict
- *   Must contain only alphanumeric characters or the symbols: '_' or '/'
+ *   Must contain only alphanumeric characters or the symbols: '_', '/' or '.'
  * @param val
  *   The number to be stored in the dict
  * @return
@@ -237,7 +237,7 @@ rte_tel_data_add_dict_u64(struct rte_tel_data *d,
  *   The data structure passed to the callback
  * @param name
  *   The name the value is to be stored under in the dict.
- *   Must contain only alphanumeric characters or the symbols: '_' or '/'
+ *   Must contain only alphanumeric characters or the symbols: '_', '/' or '.'
  * @param val
  *   The pointer to the container to be stored in the dict.
  * @param keep
lib/telemetry/telemetry_data.c +1 -0
index 13a7ce7034..4f81f71e03 100644
@@ -119,6 +119,7 @@ valid_name(const char *name)
 			['a' ... 'z'] = 1,
 			['_'] = 1,
 			['/'] = 1,
+			['.'] = 1,
 	};
 	while (*name != '\0') {
 		if ((size_t)*name >= RTE_DIM(allowed) || allowed[(int)*name] == 0)
Signature · 1 line
2.37.3
Acked-by on v3 2/4
#17 lore raw

RE: [PATCH v3 2/4] telemetry: extend valid command characters

Quoted 14 lines

-----Original Message-----
From: David Marchand <[email protected]>
Sent: Tuesday 25 October 2022 10:01
To: [email protected]
Cc: Richardson, Bruce <[email protected]>; Power, Ciara <[email protected]>
Subject: [PATCH v3 2/4] telemetry: extend valid command characters

The trace framework wants to reference trace point names as keys in dicts. Those names can contain '.', so add it to the list of valid characters in the telemetry library.

Quoted 6 lines

---
lib/telemetry/rte_telemetry.h | 10 +++++----- lib/telemetry/telemetry_data.c |
1 +

 2 files changed, 6 insertions(+), 5 deletions(-)
#18 lore raw

Re: [PATCH v3 2/4] telemetry: extend valid command characters

In reply to David Marchand
Quoted 6 lines · On Tue, 25 Oct 2022 11:00:50 +0200 David Marchand <[email protected]>…

The trace framework wants to reference trace point names as keys in dicts. Those names can contain '.', so add it to the list of valid characters in the telemetry library.

No longer applies to current code base, needs to be rebased.

#19 lore raw

PATCH v3 3/4 trace: enable trace operations via telemetry

In reply to David Marchand

Register telemetry commands to list and configure trace points and later save traces for a running DPDK application.

Example with testpmd running with two net/null ports (startup command from devtools/test-null.sh):

--> /trace/list,lib.ethdev.*
{"/trace/list": {"lib.ethdev.configure": false,

    "lib.ethdev.rxq.setup": false,
    "lib.ethdev.txq.setup": false,
    "lib.ethdev.start": false,
    "lib.ethdev.stop": false,
    "lib.ethdev.close": false,
    "lib.ethdev.rx.burst": false,
    "lib.ethdev.tx.burst": false}}

--> /trace/enable,lib.ethdev.st*
{"/trace/enable": {"Count": 2}}
--> /trace/enable,lib.ethdev.st*
{"/trace/enable": {"Count": 0}}

--> /trace/list,lib.ethdev.*
{"/trace/list": {"lib.ethdev.configure": false,

    "lib.ethdev.rxq.setup": false,
    "lib.ethdev.txq.setup": false,
    "lib.ethdev.start": true,
    "lib.ethdev.stop": true,
    "lib.ethdev.close": false,
    "lib.ethdev.rx.burst": false,
    "lib.ethdev.tx.burst": false}}

testpmd> stop
...
testpmd> port stop all
...
testpmd> port start all
...
testpmd> start
...

--> /trace/save
{"/trace/save": {"Status": "OK",

    "Path": ".../dpdk-traces/rte-2022-10-12-AM-10-51-48"}}
$ babeltrace .../dpdk-traces/rte-2022-10-12-AM-10-51-48
[10:51:36.229878723] (+?.?????????) lib.ethdev.stop:
    { cpu_id = 0x0, name = "dpdk-testpmd" }, { port_id = 0x0, ret = 0 }
[10:51:36.229880251] (+0.000001528) lib.ethdev.stop:
    { cpu_id = 0x0, name = "dpdk-testpmd" }, { port_id = 0x1, ret = 0 }
[10:51:40.449359774] (+4.219479523) lib.ethdev.start:
    { cpu_id = 0x0, name = "dpdk-testpmd" }, { port_id = 0x0 }
[10:51:40.449377877] (+0.000018103) lib.ethdev.start:
    { cpu_id = 0x0, name = "dpdk-testpmd" }, { port_id = 0x1 }

--> /trace/disable,*
{"/trace/disable": {"Count": 2}}

---
Changes since v2:
- separated telemetry change in a dedicated patch,
- switched to boolean types,

Changes since v1:
- added a note in the documentation,

---
 doc/guides/prog_guide/trace_lib.rst | 39 +++++++++++++++
 lib/eal/common/eal_common_trace.c   | 78 +++++++++++++++++++++++++++++
 2 files changed, 117 insertions(+)
doc/guides/prog_guide/trace_lib.rst +39 -0
index 9a8f38073d..d0a6bdae4c 100644
@@ -233,6 +233,45 @@ This section steps you through the details of generating trace and viewing it.
 
     babeltrace $HOME/dpdk-traces/rte-yyyy-mm-dd-[AP]M-hh-mm-ss/
 
+Configuring traces on a running DPDK application
+------------------------------------------------
+
+The DPDK trace library can be configured using the Telemetry interface.
+
+Examples::
+
+  --> /trace/list,lib.ethdev.*
+  {"/trace/list": {"lib.ethdev.configure": false,
+      "lib.ethdev.rxq.setup": false,
+      "lib.ethdev.txq.setup": false,
+      "lib.ethdev.start": false,
+      "lib.ethdev.stop": false,
+      "lib.ethdev.close": false,
+      "lib.ethdev.rx.burst": false,
+      "lib.ethdev.tx.burst": false}}
+
+  --> /trace/enable,lib.ethdev.st*
+  {"/trace/enable": {"Count": 2}}
+  --> /trace/enable,lib.ethdev.st*
+  {"/trace/enable": {"Count": 0}}
+
+  --> /trace/list,lib.ethdev.*
+  {"/trace/list": {"lib.ethdev.configure": false,
+      "lib.ethdev.rxq.setup": false,
+      "lib.ethdev.txq.setup": false,
+      "lib.ethdev.start": true,
+      "lib.ethdev.stop": true,
+      "lib.ethdev.close": false,
+      "lib.ethdev.rx.burst": false,
+      "lib.ethdev.tx.burst": false}}
+
+  --> /trace/save
+  {"/trace/save": {"Status": "OK",
+      "Path": ".../dpdk-traces/rte-2022-10-12-AM-10-51-48"}}
+
+For more information on how to use the Telemetry interface, see
+the :doc:`../howto/telemetry`.
+
 Implementation details
 ----------------------
 
lib/eal/common/eal_common_trace.c +78 -0

87 lines not on this page · raw message

Signature · 1 line
2.37.3
#20 lore raw

Re: [PATCH v3 3/4] trace: enable trace operations via telemetry

Quoted 135 lines · David Marchand

Register telemetry commands to list and configure trace points and later save traces for a running DPDK application.

Example with testpmd running with two net/null ports (startup command from devtools/test-null.sh):

--> /trace/list,lib.ethdev.*
{"/trace/list": {"lib.ethdev.configure": false,

     "lib.ethdev.rxq.setup": false,
     "lib.ethdev.txq.setup": false,
     "lib.ethdev.start": false,
     "lib.ethdev.stop": false,
     "lib.ethdev.close": false,
     "lib.ethdev.rx.burst": false,
     "lib.ethdev.tx.burst": false}}

--> /trace/enable,lib.ethdev.st*
{"/trace/enable": {"Count": 2}}
--> /trace/enable,lib.ethdev.st*
{"/trace/enable": {"Count": 0}}

--> /trace/list,lib.ethdev.*
{"/trace/list": {"lib.ethdev.configure": false,

     "lib.ethdev.rxq.setup": false,
     "lib.ethdev.txq.setup": false,
     "lib.ethdev.start": true,
     "lib.ethdev.stop": true,
     "lib.ethdev.close": false,
     "lib.ethdev.rx.burst": false,
     "lib.ethdev.tx.burst": false}}

testpmd> stop
...
testpmd> port stop all
...
testpmd> port start all
...
testpmd> start
...

--> /trace/save
{"/trace/save": {"Status": "OK",

     "Path": ".../dpdk-traces/rte-2022-10-12-AM-10-51-48"}}
$ babeltrace .../dpdk-traces/rte-2022-10-12-AM-10-51-48
[10:51:36.229878723] (+?.?????????) lib.ethdev.stop:
     { cpu_id = 0x0, name = "dpdk-testpmd" }, { port_id = 0x0, ret = 0 }
[10:51:36.229880251] (+0.000001528) lib.ethdev.stop:
     { cpu_id = 0x0, name = "dpdk-testpmd" }, { port_id = 0x1, ret = 0 }
[10:51:40.449359774] (+4.219479523) lib.ethdev.start:
     { cpu_id = 0x0, name = "dpdk-testpmd" }, { port_id = 0x0 }
[10:51:40.449377877] (+0.000018103) lib.ethdev.start:
     { cpu_id = 0x0, name = "dpdk-testpmd" }, { port_id = 0x1 }

--> /trace/disable,*
{"/trace/disable": {"Count": 2}}

---
Changes since v2:
- separated telemetry change in a dedicated patch,
- switched to boolean types,

Changes since v1:
- added a note in the documentation,

---
  doc/guides/prog_guide/trace_lib.rst | 39 +++++++++++++++
  lib/eal/common/eal_common_trace.c   | 78 +++++++++++++++++++++++++++++
  2 files changed, 117 insertions(+)
doc/guides/prog_guide/trace_lib.rst +39 -0
index 9a8f38073d..d0a6bdae4c 100644
@@ -233,6 +233,45 @@ This section steps you through the details of generating trace and viewing it.
 
      babeltrace $HOME/dpdk-traces/rte-yyyy-mm-dd-[AP]M-hh-mm-ss/
 
+Configuring traces on a running DPDK application
+------------------------------------------------
+
+The DPDK trace library can be configured using the Telemetry interface.
+
+Examples::
+
+  --> /trace/list,lib.ethdev.*
+  {"/trace/list": {"lib.ethdev.configure": false,
+      "lib.ethdev.rxq.setup": false,
+      "lib.ethdev.txq.setup": false,
+      "lib.ethdev.start": false,
+      "lib.ethdev.stop": false,
+      "lib.ethdev.close": false,
+      "lib.ethdev.rx.burst": false,
+      "lib.ethdev.tx.burst": false}}
+
+  --> /trace/enable,lib.ethdev.st*
+  {"/trace/enable": {"Count": 2}}
+  --> /trace/enable,lib.ethdev.st*
+  {"/trace/enable": {"Count": 0}}
+
+  --> /trace/list,lib.ethdev.*
+  {"/trace/list": {"lib.ethdev.configure": false,
+      "lib.ethdev.rxq.setup": false,
+      "lib.ethdev.txq.setup": false,
+      "lib.ethdev.start": true,
+      "lib.ethdev.stop": true,
+      "lib.ethdev.close": false,
+      "lib.ethdev.rx.burst": false,
+      "lib.ethdev.tx.burst": false}}
+
+  --> /trace/save
+  {"/trace/save": {"Status": "OK",
+      "Path": ".../dpdk-traces/rte-2022-10-12-AM-10-51-48"}}
+
+For more information on how to use the Telemetry interface, see
+the :doc:`../howto/telemetry`.
+
  Implementation details
  ----------------------
 
lib/eal/common/eal_common_trace.c +1 -0
index 5caaac8e59..bb26af618a 100644
@@ -12,6 +12,7 @@
  #include <rte_lcore.h>
  #include <rte_per_lcore.h>
  #include <rte_string_fns.h>
+#include <rte_telemetry.h>
 
  #include "eal_trace.h"
 

lib/eal/common/eal_common_trace.c __rte_trace_point_register(rte_trace_point_t *handle, const char *name, · line 530

Quoted 9 lines
lib/eal/common/eal_common_trace.c +6 -0
@@ -521,3 +522,80 @@ __rte_trace_point_register(rte_trace_point_t *handle, const char *name,
 
  	return -rte_errno;
  }
+
+static int
+trace_telemetry_enable(const char *cmd __rte_unused,
+	const char *params, struct rte_tel_data *d)
+{
+	unsigned int count;

status is uint32_t.

lib/eal/common/eal_common_trace.c __rte_trace_point_register(rte_trace_point_t *handle, const char *name, · line 538

Quoted 8 lines
lib/eal/common/eal_common_trace.c +8 -0
+
+	if (params == NULL || strlen(params) == 0)
+		return -1;
+	rte_tel_data_start_dict(d);
+	count = __atomic_load_n(&trace.status, __ATOMIC_RELAXED);
+	rte_trace_pattern(params, true);
+	rte_tel_data_add_dict_int(d, "Count",
+		__atomic_load_n(&trace.status, __ATOMIC_RELAXED) - count);

Why "Count"? From what I could tell, trace.status tells if tracing is enabled or not.

I also don't understand why &trace.status is loaded twice, especially in the light that future compilers, that more heavily optimize atomics, might merge those two loads into one, resulting in something equivalent to:

rte_tel_data_add_dict_int(d, "Count", 0);

Is one of the loads supposed to be a store (or, lock add, rather), enabling the tracing?

Might be worth to wrap all the atomics in functions, making the code more clear.

Quoted 63 lines
lib/eal/common/eal_common_trace.c +63 -0
+	return 0;
+
+}
+
+static int
+trace_telemetry_disable(const char *cmd __rte_unused,
+	const char *params, struct rte_tel_data *d)
+{
+	unsigned int count;
+
+	if (params == NULL || strlen(params) == 0)
+		return -1;
+	rte_tel_data_start_dict(d);
+	count = __atomic_load_n(&trace.status, __ATOMIC_RELAXED);
+	rte_trace_pattern(params, false);
+	rte_tel_data_add_dict_int(d, "Count",
+		count - __atomic_load_n(&trace.status, __ATOMIC_RELAXED));
+	return 0;
+
+}
+
+static int
+trace_telemetry_list(const char *cmd __rte_unused,
+	const char *params, struct rte_tel_data *d)
+{
+	struct trace_point *tp;
+
+	rte_tel_data_start_dict(d);
+	STAILQ_FOREACH(tp, &tp_list, next) {
+		if (params != NULL && fnmatch(params, tp->name, 0) != 0)
+			continue;
+
+		rte_tel_data_add_dict_bool(d, tp->name,
+			rte_trace_point_is_enabled(tp->handle));
+	}
+
+	return 0;
+}
+
+static int
+trace_telemetry_save(const char *cmd __rte_unused,
+	const char *params __rte_unused, struct rte_tel_data *d)
+{
+	struct trace *trace = trace_obj_get();
+
+	rte_tel_data_start_dict(d);
+	rte_tel_data_add_dict_string(d, "Status", rte_trace_save() == 0 ? "OK" : "KO");
+	rte_tel_data_add_dict_string(d, "Path", trace->dir);
+
+	return 0;
+}
+
+RTE_INIT(trace_telemetry)
+{
+	rte_telemetry_register_cmd("/trace/enable", trace_telemetry_enable,
+		"Enable trace points matching the provided pattern. Parameters: string pattern.");
+	rte_telemetry_register_cmd("/trace/disable", trace_telemetry_disable,
+		"Disable trace points matching the provided pattern. Parameters: string pattern.");
+	rte_telemetry_register_cmd("/trace/list", trace_telemetry_list,
+		"List trace points. Parameters: string pattern.");
+	rte_telemetry_register_cmd("/trace/save", trace_telemetry_save,
+		"Save current traces. Takes no parameter.");
+}
#21 lore raw

PATCH v3 4/4 trace: create new directory for each trace dump

In reply to David Marchand

Rather than always overwrite the content of the trace directory, create new directories for each call to rte_trace_save().

In the unlikely event that multiple rte_trace_save() gets called many times in a single second, try to suffix the name with a digit.

---
 lib/eal/common/eal_common_trace.c       |  4 ++
 lib/eal/common/eal_common_trace_utils.c | 89 +++++++++++--------------
 lib/eal/common/eal_trace.h              |  1 +
 3 files changed, 45 insertions(+), 49 deletions(-)
lib/eal/common/eal_common_trace.c +4 -0
index bb26af618a..7d411b336e 100644
@@ -92,6 +92,10 @@ eal_trace_fini(void)
 	trace_mem_free();
 	trace_metadata_destroy();
 	eal_trace_args_free();
+	free(trace.rootdir);
+	trace.rootdir = NULL;
+	free(trace.dir);
+	trace.dir = NULL;
 }
 
 bool
lib/eal/common/eal_common_trace_utils.c +40 -49

153 lines not on this page · raw message

lib/eal/common/eal_trace.h +1 -0
index d66bcfe198..8991088253 100644
@@ -48,6 +48,7 @@ struct trace_arg {
 };
 
 struct trace {
+	char *rootdir;
 	char *dir;
 	int register_errno;
 	uint32_t status;
Signature · 1 line
2.37.3
#22 lore raw

Re: [PATCH v3 4/4] trace: create new directory for each trace dump

Quoted 157 lines · David Marchand

Rather than always overwrite the content of the trace directory, create new directories for each call to rte_trace_save().

In the unlikely event that multiple rte_trace_save() gets called many times in a single second, try to suffix the name with a digit.

---
  lib/eal/common/eal_common_trace.c       |  4 ++
  lib/eal/common/eal_common_trace_utils.c | 89 +++++++++++--------------
  lib/eal/common/eal_trace.h              |  1 +
  3 files changed, 45 insertions(+), 49 deletions(-)
lib/eal/common/eal_common_trace.c +4 -0
index bb26af618a..7d411b336e 100644
@@ -92,6 +92,10 @@ eal_trace_fini(void)
  	trace_mem_free();
  	trace_metadata_destroy();
  	eal_trace_args_free();
+	free(trace.rootdir);
+	trace.rootdir = NULL;
+	free(trace.dir);
+	trace.dir = NULL;
  }
 
  bool
lib/eal/common/eal_common_trace_utils.c +17 -43
index 8561a0e198..6256ef6703 100644
@@ -87,9 +87,10 @@ trace_uuid_generate(void)
  }
 
  static int
-trace_session_name_generate(char **trace_dir)
+trace_dir_name_generate(char **trace_dir)
  {
  	char date[sizeof("YYYY-mm-dd-AM-HH-MM-SS")];
+	struct trace *trace = trace_obj_get();
  	struct tm *tm_result;
  	time_t tm;
 
@@ -106,7 +107,8 @@ trace_session_name_generate(char **trace_dir)
  		goto fail;
  	}
 
-	if (asprintf(trace_dir, "%s-%s", eal_get_hugefile_prefix(), date) == -1)
+	if (asprintf(trace_dir, "%s/%s-%s", trace->rootdir,
+			eal_get_hugefile_prefix(), date) == -1)
  		goto fail;
 
  	return 0;
@@ -115,21 +117,6 @@ trace_session_name_generate(char **trace_dir)
  	return -1;
  }
 
-static int
-trace_dir_update(const char *str)
-{
-	struct trace *trace = trace_obj_get();
-	char *dir;
-	int rc;
-
-	rc = asprintf(&dir, "%s%s", trace->dir != NULL ? trace->dir : "", str);
-	if (rc != -1) {
-		free(trace->dir);
-		trace->dir = dir;
-	}
-	return rc;
-}
-
  int
  eal_trace_args_save(const char *val)
  {
@@ -240,17 +227,16 @@ eal_trace_mode_args_save(const char *val)
  int
  eal_trace_dir_args_save(char const *val)
  {
-	char *dir_path;
-	int rc;
+	struct trace *trace = trace_obj_get();
 
-	if (asprintf(&dir_path, "%s/", val) == -1) {
+	free(trace->rootdir);
+	trace->rootdir = strdup(val);
+	if (trace->rootdir == NULL) {
  		trace_err("failed to copy directory: %s", strerror(errno));
  		return -ENOMEM;
  	}
 
-	rc = trace_dir_update(dir_path);
-	free(dir_path);
-	return rc;
+	return 0;
  }
 
  int
@@ -293,7 +279,7 @@ trace_dir_default_path_get(char **dir_path)
  	}
 
  	/* Append dpdk-traces to directory */
-	if (asprintf(dir_path, "%s/dpdk-traces/", home_dir) == -1)
+	if (asprintf(dir_path, "%s/dpdk-traces", home_dir) == -1)
  		return -ENOMEM;
 
  	return 0;
@@ -303,14 +289,11 @@ static int
  trace_mkdir(void)
  {
  	struct trace *trace = trace_obj_get();
-	static bool already_done;
-	char *session;
+	unsigned int try;
+	char *trace_dir;
  	int rc;
 
-	if (already_done)
-		return 0;
-
-	if (trace->dir == NULL) {
+	if (trace->rootdir == NULL) {
  		char *dir_path;
 
  		rc = trace_dir_default_path_get(&dir_path);
@@ -318,38 +301,46 @@ trace_mkdir(void)
  			trace_err("fail to get default path");
  			return rc;
  		}
-
-		rc = trace_dir_update(dir_path);
-		free(dir_path);
-		if (rc < 0)
-			return rc;
+		trace->rootdir = dir_path;
  	}
 
  	/* Create the path if it t exist, no "mkdir -p" available here */
-	rc = mkdir(trace->dir, 0700);
+	rc = mkdir(trace->rootdir, 0700);
  	if (rc < 0 && errno != EEXIST) {
-		trace_err("mkdir %s failed [%s]", trace->dir, strerror(errno));
+		trace_err("mkdir %s failed [%s]", trace->rootdir, strerror(errno));
  		rte_errno = errno;
  		return -rte_errno;
  	}
 
-	rc = trace_session_name_generate(&session);
-	if (rc < 0)
-		return rc;
-	rc = trace_dir_update(session);
-	free(session);
+	rc = trace_dir_name_generate(&trace_dir);
  	if (rc < 0)
  		return rc;
-

lib/eal/common/eal_common_trace_utils.c trace_mkdir(void) · line 322

Quoted 10 lines
lib/eal/common/eal_common_trace_utils.c +5 -5
-	rc = mkdir(trace->dir, 0700);
-	if (rc < 0) {
-		trace_err("mkdir %s failed [%s]", trace->dir, strerror(errno));
-		rte_errno = errno;
-		return -rte_errno;
+	rc = mkdir(trace_dir, 0700);
+	if (rc == 0)
+		goto out;
+
+	/* 1000 tries are definitely enough :-) */

Do you need an upper bound at all?

Is there a point in retrying for anything other than EEXIST?

Quoted 37 lines
lib/eal/common/eal_common_trace_utils.c +18 -1
+	for (try = 1; try < 1000; try++) {
+		char *trace_dir_suffix;
+
+		if (asprintf(&trace_dir_suffix, "%s.%u", trace_dir, try) == -1)
+			continue;
+		rc = mkdir(trace_dir_suffix, 0700);
+		if (rc == 0) {
+			free(trace_dir);
+			trace_dir = trace_dir_suffix;
+			goto out;
+		}
+		free(trace_dir_suffix);
  	}
 
+	trace_err("mkdir %s failed [%s]", trace->dir, strerror(errno));
+	rte_errno = errno;
+	return -rte_errno;
+out:
+	free(trace->dir);
+	trace->dir = trace_dir;
  	RTE_LOG(INFO, EAL, "Trace dir: %s\n", trace->dir);
-	already_done = true;
  	return 0;
  }
 
lib/eal/common/eal_trace.h +1 -0
index d66bcfe198..8991088253 100644
@@ -48,6 +48,7 @@ struct trace_arg {
  };
 
  struct trace {
+	char *rootdir;
  	char *dir;
  	int register_errno;
  	uint32_t status;