From 447c2c03c137123ed1cbc5fa931a276bfb082f38 Mon Sep 17 00:00:00 2001 From: chenjiji09 Date: Fri, 10 Mar 2023 09:25:52 +0800 Subject: [PATCH] Fix telemetry data function for some lib. And support displaying integer as hexadecimal. Patchs are as follow: - telemetry: move include after guard - ethdev: fix telemetry data truncation - mempool: fix telemetry data truncation - cryptodev: fix telemetry data truncation - mem: fix telemetry data truncation - test/telemetry_data: refactor for maintainability - test/telemetry_data: add test cases for character escaping - telemetry: support adding integer as hexadecimal - ethdev: get capabilities from telemetry in hexadecimal --- 0239-telemetry-move-include-after-guard.patch | 50 ++ ...ethdev-fix-telemetry-data-truncation.patch | 59 +++ ...empool-fix-telemetry-data-truncation.patch | 70 +++ ...ptodev-fix-telemetry-data-truncation.patch | 39 ++ 0243-mem-fix-telemetry-data-truncation.patch | 65 +++ ...ry_data-refactor-for-maintainability.patch | 369 +++++++++++++++ ...ata-add-test-cases-for-character-esc.patch | 74 +++ ...upport-adding-integer-as-hexadecimal.patch | 428 ++++++++++++++++++ ...ilities-from-telemetry-in-hexadecima.patch | 62 +++ dpdk.spec | 25 +- 10 files changed, 1240 insertions(+), 1 deletion(-) create mode 100644 0239-telemetry-move-include-after-guard.patch create mode 100644 0240-ethdev-fix-telemetry-data-truncation.patch create mode 100644 0241-mempool-fix-telemetry-data-truncation.patch create mode 100644 0242-cryptodev-fix-telemetry-data-truncation.patch create mode 100644 0243-mem-fix-telemetry-data-truncation.patch create mode 100644 0244-test-telemetry_data-refactor-for-maintainability.patch create mode 100644 0245-test-telemetry_data-add-test-cases-for-character-esc.patch create mode 100644 0246-telemetry-support-adding-integer-as-hexadecimal.patch create mode 100644 0247-ethdev-get-capabilities-from-telemetry-in-hexadecima.patch diff --git a/0239-telemetry-move-include-after-guard.patch b/0239-telemetry-move-include-after-guard.patch new file mode 100644 index 0000000..7541d2c --- /dev/null +++ b/0239-telemetry-move-include-after-guard.patch @@ -0,0 +1,50 @@ +From 4e4bbf868e59eef4f660de712a4375092fa34c1c Mon Sep 17 00:00:00 2001 +From: Huisong Li +Date: Mon, 19 Dec 2022 15:06:41 +0800 +Subject: telemetry: move include after guard +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +[ upstream commit f7b74387be1de6803716262d7988794accd6d39f ] + +The "stdint.h" header is outside '_RTE_TELEMETRY_H_' macro, which cause +this header is unconditional. So this patch moves this header to inside +'_RTE_TELEMETRY_H_'. + +Fixes: 99a2dd955fba ("lib: remove librte_ prefix from directory names") +Cc: stable@dpdk.org + +Signed-off-by: Huisong Li +Acked-by: Morten Brørup +Acked-by: Chengwen Feng +Acked-by: Bruce Richardson +--- + lib/telemetry/rte_telemetry.h | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/lib/telemetry/rte_telemetry.h b/lib/telemetry/rte_telemetry.h +index fadea48cb9..98870ab76b 100644 +--- a/lib/telemetry/rte_telemetry.h ++++ b/lib/telemetry/rte_telemetry.h +@@ -2,8 +2,6 @@ + * Copyright(c) 2018 Intel Corporation + */ + +-#include +- + #include + + #ifndef _RTE_TELEMETRY_H_ +@@ -13,6 +11,8 @@ + extern "C" { + #endif + ++#include ++ + /** Maximum length for string used in object. */ + #define RTE_TEL_MAX_STRING_LEN 128 + /** Maximum length of string. */ +-- +2.23.0 + diff --git a/0240-ethdev-fix-telemetry-data-truncation.patch b/0240-ethdev-fix-telemetry-data-truncation.patch new file mode 100644 index 0000000..c858180 --- /dev/null +++ b/0240-ethdev-fix-telemetry-data-truncation.patch @@ -0,0 +1,59 @@ +From 5ef1876c1d33b0ec17a364f8818d8718f93b9339 Mon Sep 17 00:00:00 2001 +From: Huisong Li +Date: Mon, 19 Dec 2022 15:06:42 +0800 +Subject: ethdev: fix telemetry data truncation +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +[ upstream commit 7db3f2af573287abb9201d46a92b4ca3ebc5d9ad ] + +The 'u32' and 'u64' data can not assigned to 'int' type variable. +They need to use the 'u64' APIs to add. + +Fixes: 58b43c1ddfd1 ("ethdev: add telemetry endpoint for device info") +Cc: stable@dpdk.org + +Signed-off-by: Huisong Li +Acked-by: Morten Brørup +Acked-by: Chengwen Feng +--- + lib/ethdev/rte_ethdev.c | 12 ++++++------ + 1 file changed, 6 insertions(+), 6 deletions(-) + +diff --git a/lib/ethdev/rte_ethdev.c b/lib/ethdev/rte_ethdev.c +index df5a627cbe..5b15a85fba 100644 +--- a/lib/ethdev/rte_ethdev.c ++++ b/lib/ethdev/rte_ethdev.c +@@ -6395,9 +6395,9 @@ eth_dev_handle_port_info(const char *cmd __rte_unused, + eth_dev->data->nb_tx_queues); + rte_tel_data_add_dict_int(d, "port_id", eth_dev->data->port_id); + rte_tel_data_add_dict_int(d, "mtu", eth_dev->data->mtu); +- rte_tel_data_add_dict_int(d, "rx_mbuf_size_min", ++ rte_tel_data_add_dict_u64(d, "rx_mbuf_size_min", + eth_dev->data->min_rx_buf_size); +- rte_tel_data_add_dict_int(d, "rx_mbuf_alloc_fail", ++ rte_tel_data_add_dict_u64(d, "rx_mbuf_alloc_fail", + eth_dev->data->rx_mbuf_alloc_failed); + snprintf(mac_addr, RTE_ETHER_ADDR_LEN, "%02x:%02x:%02x:%02x:%02x:%02x", + eth_dev->data->mac_addrs->addr_bytes[0], +@@ -6431,12 +6431,12 @@ eth_dev_handle_port_info(const char *cmd __rte_unused, + rte_tel_data_add_dict_container(d, "rxq_state", rxq_state, 0); + rte_tel_data_add_dict_container(d, "txq_state", txq_state, 0); + rte_tel_data_add_dict_int(d, "numa_node", eth_dev->data->numa_node); +- rte_tel_data_add_dict_int(d, "dev_flags", eth_dev->data->dev_flags); +- rte_tel_data_add_dict_int(d, "rx_offloads", ++ rte_tel_data_add_dict_u64(d, "dev_flags", eth_dev->data->dev_flags); ++ rte_tel_data_add_dict_u64(d, "rx_offloads", + eth_dev->data->dev_conf.rxmode.offloads); +- rte_tel_data_add_dict_int(d, "tx_offloads", ++ rte_tel_data_add_dict_u64(d, "tx_offloads", + eth_dev->data->dev_conf.txmode.offloads); +- rte_tel_data_add_dict_int(d, "ethdev_rss_hf", ++ rte_tel_data_add_dict_u64(d, "ethdev_rss_hf", + eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf); + + return 0; +-- +2.23.0 + diff --git a/0241-mempool-fix-telemetry-data-truncation.patch b/0241-mempool-fix-telemetry-data-truncation.patch new file mode 100644 index 0000000..92d4dda --- /dev/null +++ b/0241-mempool-fix-telemetry-data-truncation.patch @@ -0,0 +1,70 @@ +From b9cff9dae822b94854d9d3f5f4e23d13a3c8de36 Mon Sep 17 00:00:00 2001 +From: Huisong Li +Date: Mon, 19 Dec 2022 15:06:43 +0800 +Subject: mempool: fix telemetry data truncation +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +[ upstream commit 4eebfcf70a21b2b608e3bb9f20b5ee23338172ec ] + +The 'u32' and 'u64' data can not assigned to 'int' type variable. +They need to use the 'u64' APIs to add. + +Fixes: 2f5c4025abb3 ("mempool: add telemetry endpoint") +Cc: stable@dpdk.org + +Signed-off-by: Huisong Li +Acked-by: Morten Brørup +Acked-by: Chengwen Feng +--- + lib/mempool/rte_mempool.c | 24 ++++++++++++------------ + 1 file changed, 12 insertions(+), 12 deletions(-) + +diff --git a/lib/mempool/rte_mempool.c b/lib/mempool/rte_mempool.c +index c5a699b1d6..871f4d1fe3 100644 +--- a/lib/mempool/rte_mempool.c ++++ b/lib/mempool/rte_mempool.c +@@ -1517,27 +1517,27 @@ mempool_info_cb(struct rte_mempool *mp, void *arg) + return; + + rte_tel_data_add_dict_string(info->d, "name", mp->name); +- rte_tel_data_add_dict_int(info->d, "pool_id", mp->pool_id); +- rte_tel_data_add_dict_int(info->d, "flags", mp->flags); ++ rte_tel_data_add_dict_u64(info->d, "pool_id", mp->pool_id); ++ rte_tel_data_add_dict_u64(info->d, "flags", mp->flags); + rte_tel_data_add_dict_int(info->d, "socket_id", mp->socket_id); +- rte_tel_data_add_dict_int(info->d, "size", mp->size); +- rte_tel_data_add_dict_int(info->d, "cache_size", mp->cache_size); +- rte_tel_data_add_dict_int(info->d, "elt_size", mp->elt_size); +- rte_tel_data_add_dict_int(info->d, "header_size", mp->header_size); +- rte_tel_data_add_dict_int(info->d, "trailer_size", mp->trailer_size); +- rte_tel_data_add_dict_int(info->d, "private_data_size", ++ rte_tel_data_add_dict_u64(info->d, "size", mp->size); ++ rte_tel_data_add_dict_u64(info->d, "cache_size", mp->cache_size); ++ rte_tel_data_add_dict_u64(info->d, "elt_size", mp->elt_size); ++ rte_tel_data_add_dict_u64(info->d, "header_size", mp->header_size); ++ rte_tel_data_add_dict_u64(info->d, "trailer_size", mp->trailer_size); ++ rte_tel_data_add_dict_u64(info->d, "private_data_size", + mp->private_data_size); + rte_tel_data_add_dict_int(info->d, "ops_index", mp->ops_index); +- rte_tel_data_add_dict_int(info->d, "populated_size", ++ rte_tel_data_add_dict_u64(info->d, "populated_size", + mp->populated_size); + + mz = mp->mz; + rte_tel_data_add_dict_string(info->d, "mz_name", mz->name); +- rte_tel_data_add_dict_int(info->d, "mz_len", mz->len); +- rte_tel_data_add_dict_int(info->d, "mz_hugepage_sz", ++ rte_tel_data_add_dict_u64(info->d, "mz_len", mz->len); ++ rte_tel_data_add_dict_u64(info->d, "mz_hugepage_sz", + mz->hugepage_sz); + rte_tel_data_add_dict_int(info->d, "mz_socket_id", mz->socket_id); +- rte_tel_data_add_dict_int(info->d, "mz_flags", mz->flags); ++ rte_tel_data_add_dict_u64(info->d, "mz_flags", mz->flags); + } + + static int +-- +2.23.0 + diff --git a/0242-cryptodev-fix-telemetry-data-truncation.patch b/0242-cryptodev-fix-telemetry-data-truncation.patch new file mode 100644 index 0000000..1c39894 --- /dev/null +++ b/0242-cryptodev-fix-telemetry-data-truncation.patch @@ -0,0 +1,39 @@ +From 510ec674f5d132460045b79aa0602e519a66cd54 Mon Sep 17 00:00:00 2001 +From: Huisong Li +Date: Mon, 19 Dec 2022 15:06:44 +0800 +Subject: cryptodev: fix telemetry data truncation +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +[ upstream commit 45038f04ab577db8844ef54d7f523119be6c205f ] + +The 'u32' data can not assigned to 'int' type variable. The 'u32' data +needs to use the 'u64' APIs to add. + +Fixes: d3d98f5ce9d0 ("cryptodev: support telemetry") +Cc: stable@dpdk.org + +Signed-off-by: Huisong Li +Acked-by: Morten Brørup +Acked-by: Chengwen Feng +--- + lib/cryptodev/rte_cryptodev.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/lib/cryptodev/rte_cryptodev.c b/lib/cryptodev/rte_cryptodev.c +index a40536c5ea..23e079d639 100644 +--- a/lib/cryptodev/rte_cryptodev.c ++++ b/lib/cryptodev/rte_cryptodev.c +@@ -2472,7 +2472,7 @@ cryptodev_handle_dev_info(const char *cmd __rte_unused, + rte_tel_data_start_dict(d); + rte_tel_data_add_dict_string(d, "device_name", + cryptodev_info.device->name); +- rte_tel_data_add_dict_int(d, "max_nb_queue_pairs", ++ rte_tel_data_add_dict_u64(d, "max_nb_queue_pairs", + cryptodev_info.max_nb_queue_pairs); + + return 0; +-- +2.23.0 + diff --git a/0243-mem-fix-telemetry-data-truncation.patch b/0243-mem-fix-telemetry-data-truncation.patch new file mode 100644 index 0000000..700dea4 --- /dev/null +++ b/0243-mem-fix-telemetry-data-truncation.patch @@ -0,0 +1,65 @@ +From b208a81818041df0ce00744aa20ab83bbfd1159f Mon Sep 17 00:00:00 2001 +From: Huisong Li +Date: Mon, 19 Dec 2022 15:06:45 +0800 +Subject: mem: fix telemetry data truncation +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +[ upstream commit 6243e36b837b754c33017718cf79f7574a52b09c ] + +The 'u32' and 'u64' data can not assigned to 'int' type variable. +They need to use the 'u64' APIs to add. + +Fixes: e6732d0d6e26 ("mem: add telemetry infos") +Cc: stable@dpdk.org + +Signed-off-by: Huisong Li +Acked-by: Morten Brørup +Acked-by: Chengwen Feng +--- + lib/eal/common/eal_common_memory.c | 10 +++++----- + 1 file changed, 5 insertions(+), 5 deletions(-) + +diff --git a/lib/eal/common/eal_common_memory.c b/lib/eal/common/eal_common_memory.c +index 69dea8f72b..f2f8858e22 100644 +--- a/lib/eal/common/eal_common_memory.c ++++ b/lib/eal/common/eal_common_memory.c +@@ -1191,7 +1191,7 @@ handle_eal_heap_info_request(const char *cmd __rte_unused, const char *params, + malloc_heap_get_stats(heap, &sock_stats); + + rte_tel_data_start_dict(d); +- rte_tel_data_add_dict_int(d, "Head id", heap_id); ++ rte_tel_data_add_dict_u64(d, "Head id", heap_id); + rte_tel_data_add_dict_string(d, "Name", heap->name); + rte_tel_data_add_dict_u64(d, "Heap_size", + sock_stats.heap_totalsz_bytes); +@@ -1253,13 +1253,13 @@ handle_eal_memzone_info_request(const char *cmd __rte_unused, + mz = rte_fbarray_get(&mcfg->memzones, mz_idx); + + rte_tel_data_start_dict(d); +- rte_tel_data_add_dict_int(d, "Zone", mz_idx); ++ rte_tel_data_add_dict_u64(d, "Zone", mz_idx); + rte_tel_data_add_dict_string(d, "Name", mz->name); +- rte_tel_data_add_dict_int(d, "Length", mz->len); ++ rte_tel_data_add_dict_u64(d, "Length", mz->len); + snprintf(addr, ADDR_STR, "%p", mz->addr); + rte_tel_data_add_dict_string(d, "Address", addr); + rte_tel_data_add_dict_int(d, "Socket", mz->socket_id); +- rte_tel_data_add_dict_int(d, "Flags", mz->flags); ++ rte_tel_data_add_dict_u64(d, "Flags", mz->flags); + + /* go through each page occupied by this memzone */ + msl = rte_mem_virt2memseg_list(mz->addr); +@@ -1274,7 +1274,7 @@ handle_eal_memzone_info_request(const char *cmd __rte_unused, + ms_idx = RTE_PTR_DIFF(mz->addr, msl->base_va) / page_sz; + ms = rte_fbarray_get(&msl->memseg_arr, ms_idx); + +- rte_tel_data_add_dict_int(d, "Hugepage_size", page_sz); ++ rte_tel_data_add_dict_u64(d, "Hugepage_size", page_sz); + snprintf(addr, ADDR_STR, "%p", ms->addr); + rte_tel_data_add_dict_string(d, "Hugepage_base", addr); + +-- +2.23.0 + diff --git a/0244-test-telemetry_data-refactor-for-maintainability.patch b/0244-test-telemetry_data-refactor-for-maintainability.patch new file mode 100644 index 0000000..58c0534 --- /dev/null +++ b/0244-test-telemetry_data-refactor-for-maintainability.patch @@ -0,0 +1,369 @@ +From 1c245e6c95afb505d284df2f39bb4f0437854f52 Mon Sep 17 00:00:00 2001 +From: Bruce Richardson +Date: Fri, 9 Sep 2022 10:35:20 +0100 +Subject: test/telemetry_data: refactor for maintainability +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +[ upstream commit 1306df2cd1d9ae654c2e5b3b0f40ca19ab440006 ] + +To help with the writing and maintaining of test cases in this file we +can make the following changes to it: + +- rename non-test-case functions i.e. the infrastructure functions, to + not start with "test_", so that each sub-test case can be identified + by starting with that prefix. +- add a comment at the start of the file explaining how tests are to be + written and managed, so as to keep consistency. +- add a trivial test-case for returning a simple string value to use as + a reference example for those wanting to add test cases. +- improve the key macro used for validating the output from each + function, so that the standard json preamble can be skipped for each + function. This hides more of the infrastructure implementation from + the user i.e. they don't need to worry what the actual command used is + called, and also shortens the output strings so we can avoid line + splitting in most cases. +- add clearing the "response_data" structure to the loop calling each + test to avoid each test function having to do so individually. + +Signed-off-by: Bruce Richardson +Acked-by: Ciara Power +Acked-by: Morten Brørup +Acked-by: Chengwen Feng +--- + app/test/test_telemetry_data.c | 101 ++++++++++++++++++++------------- + 1 file changed, 60 insertions(+), 41 deletions(-) + +diff --git a/app/test/test_telemetry_data.c b/app/test/test_telemetry_data.c +index 18b93db8ef..75aca8791f 100644 +--- a/app/test/test_telemetry_data.c ++++ b/app/test/test_telemetry_data.c +@@ -19,18 +19,45 @@ + #define TELEMETRY_VERSION "v2" + #define REQUEST_CMD "/test" + #define BUF_SIZE 1024 +-#define TEST_OUTPUT(exp) test_output(__func__, exp) ++#define CHECK_OUTPUT(exp) check_output(__func__, "{\"" REQUEST_CMD "\":" exp "}") ++ ++/* ++ * Runs a series of test cases, checking the output of telemetry for various different types of ++ * responses. On init, a single connection to DPDK telemetry is made, and a single telemetry ++ * callback "/test" is registered. That callback always returns the value of the static global ++ * variable "response_data", so each test case builds up that structure, and then calls the ++ * "check_output" function to ensure the response received over the socket for "/test" matches ++ * that expected for the response_data value populated. ++ * ++ * NOTE: ++ * - each test case function in this file should be added to the "test_cases" array in ++ * test_telemetry_data function at the bottom of the file. ++ * - each test case function should populate the "response_data" global variable (below) ++ * with the appropriate values which would be returned from a simulated telemetry function. ++ * Then the test case function should have "return CHECK_OUTPUT();" as it's ++ * last line. The test infrastructure will then validate that the output when returning ++ * "response_data" structure matches that in "". ++ * - the response_data structure will be zeroed on entry to each test function, so each function ++ * can begin with a call to "rte_tel_data_string/start_array/start_dict" as so desired. ++ * - the expected_output for each function can be just the actual json data from the ++ * "response_data" value. The CHECK_OUTPUT macro will include the appropriate "{\"/test\": ... }" ++ * structure around the json output. ++ * ++ * See test_simple_string(), or test_case_array_int() for a basic examples of test cases. ++ */ ++ + + static struct rte_tel_data response_data; + static int sock; + ++ + /* + * This function is the callback registered with Telemetry to be used when + * the /test command is requested. This callback returns the global data built + * up by the individual test cases. + */ + static int +-test_cb(const char *cmd __rte_unused, const char *params __rte_unused, ++telemetry_test_cb(const char *cmd __rte_unused, const char *params __rte_unused, + struct rte_tel_data *d) + { + *d = response_data; +@@ -44,7 +71,7 @@ test_cb(const char *cmd __rte_unused, const char *params __rte_unused, + * and is compared to the actual response received from Telemetry. + */ + static int +-test_output(const char *func_name, const char *expected) ++check_output(const char *func_name, const char *expected) + { + int bytes; + char buf[BUF_SIZE * 16]; +@@ -64,6 +91,14 @@ test_output(const char *func_name, const char *expected) + return strncmp(expected, buf, sizeof(buf)); + } + ++static int ++test_simple_string(void) ++{ ++ rte_tel_data_string(&response_data, "Simple string"); ++ ++ return CHECK_OUTPUT("\"Simple string\""); ++} ++ + static int + test_dict_with_array_int_values(void) + { +@@ -75,7 +110,6 @@ test_dict_with_array_int_values(void) + struct rte_tel_data *child_data2 = rte_tel_data_alloc(); + rte_tel_data_start_array(child_data2, RTE_TEL_INT_VAL); + +- memset(&response_data, 0, sizeof(response_data)); + rte_tel_data_start_dict(&response_data); + + for (i = 0; i < 5; i++) { +@@ -88,8 +122,7 @@ test_dict_with_array_int_values(void) + rte_tel_data_add_dict_container(&response_data, "dict_1", + child_data2, 0); + +- return TEST_OUTPUT("{\"/test\":{\"dict_0\":[0,1,2,3,4]," +- "\"dict_1\":[0,1,2,3,4]}}"); ++ return CHECK_OUTPUT("{\"dict_0\":[0,1,2,3,4],\"dict_1\":[0,1,2,3,4]}"); + } + + static int +@@ -103,7 +136,6 @@ test_array_with_array_int_values(void) + struct rte_tel_data *child_data2 = rte_tel_data_alloc(); + rte_tel_data_start_array(child_data2, RTE_TEL_INT_VAL); + +- memset(&response_data, 0, sizeof(response_data)); + rte_tel_data_start_array(&response_data, RTE_TEL_CONTAINER); + + for (i = 0; i < 5; i++) { +@@ -113,18 +145,18 @@ test_array_with_array_int_values(void) + rte_tel_data_add_array_container(&response_data, child_data, 0); + rte_tel_data_add_array_container(&response_data, child_data2, 0); + +- return TEST_OUTPUT("{\"/test\":[[0,1,2,3,4],[0,1,2,3,4]]}"); ++ return CHECK_OUTPUT("[[0,1,2,3,4],[0,1,2,3,4]]"); + } + + static int + test_case_array_int(void) + { + int i; +- memset(&response_data, 0, sizeof(response_data)); ++ + rte_tel_data_start_array(&response_data, RTE_TEL_INT_VAL); + for (i = 0; i < 5; i++) + rte_tel_data_add_array_int(&response_data, i); +- return TEST_OUTPUT("{\"/test\":[0,1,2,3,4]}"); ++ return CHECK_OUTPUT("[0,1,2,3,4]"); + } + + static int +@@ -133,7 +165,6 @@ test_case_add_dict_int(void) + int i = 0; + char name_of_value[8]; + +- memset(&response_data, 0, sizeof(response_data)); + rte_tel_data_start_dict(&response_data); + + for (i = 0; i < 5; i++) { +@@ -141,14 +172,12 @@ test_case_add_dict_int(void) + rte_tel_data_add_dict_int(&response_data, name_of_value, i); + } + +- return TEST_OUTPUT("{\"/test\":{\"dict_0\":0,\"dict_1\":1,\"dict_2\":2," +- "\"dict_3\":3,\"dict_4\":4}}"); ++ return CHECK_OUTPUT("{\"dict_0\":0,\"dict_1\":1,\"dict_2\":2,\"dict_3\":3,\"dict_4\":4}"); + } + + static int + test_case_array_string(void) + { +- memset(&response_data, 0, sizeof(response_data)); + rte_tel_data_start_array(&response_data, RTE_TEL_STRING_VAL); + rte_tel_data_add_array_string(&response_data, "aaaa"); + rte_tel_data_add_array_string(&response_data, "bbbb"); +@@ -156,14 +185,12 @@ test_case_array_string(void) + rte_tel_data_add_array_string(&response_data, "dddd"); + rte_tel_data_add_array_string(&response_data, "eeee"); + +- return TEST_OUTPUT("{\"/test\":[\"aaaa\",\"bbbb\",\"cccc\",\"dddd\"," +- "\"eeee\"]}"); ++ return CHECK_OUTPUT("[\"aaaa\",\"bbbb\",\"cccc\",\"dddd\",\"eeee\"]"); + } + + static int + test_case_add_dict_string(void) + { +- memset(&response_data, 0, sizeof(response_data)); + rte_tel_data_start_dict(&response_data); + + rte_tel_data_add_dict_string(&response_data, "dict_0", "aaaa"); +@@ -171,8 +198,7 @@ test_case_add_dict_string(void) + rte_tel_data_add_dict_string(&response_data, "dict_2", "cccc"); + rte_tel_data_add_dict_string(&response_data, "dict_3", "dddd"); + +- return TEST_OUTPUT("{\"/test\":{\"dict_0\":\"aaaa\",\"dict_1\":" +- "\"bbbb\",\"dict_2\":\"cccc\",\"dict_3\":\"dddd\"}}"); ++ return CHECK_OUTPUT("{\"dict_0\":\"aaaa\",\"dict_1\":\"bbbb\",\"dict_2\":\"cccc\",\"dict_3\":\"dddd\"}"); + } + + +@@ -185,7 +211,6 @@ test_dict_with_array_string_values(void) + struct rte_tel_data *child_data2 = rte_tel_data_alloc(); + rte_tel_data_start_array(child_data2, RTE_TEL_STRING_VAL); + +- memset(&response_data, 0, sizeof(response_data)); + rte_tel_data_start_dict(&response_data); + + rte_tel_data_add_array_string(child_data, "aaaa"); +@@ -196,8 +221,7 @@ test_dict_with_array_string_values(void) + rte_tel_data_add_dict_container(&response_data, "dict_1", + child_data2, 0); + +- return TEST_OUTPUT("{\"/test\":{\"dict_0\":[\"aaaa\"],\"dict_1\":" +- "[\"bbbb\"]}}"); ++ return CHECK_OUTPUT("{\"dict_0\":[\"aaaa\"],\"dict_1\":[\"bbbb\"]}"); + } + + static int +@@ -212,7 +236,6 @@ test_dict_with_dict_values(void) + struct rte_tel_data *child_data2 = rte_tel_data_alloc(); + rte_tel_data_start_array(child_data2, RTE_TEL_STRING_VAL); + +- memset(&response_data, 0, sizeof(response_data)); + rte_tel_data_start_dict(&response_data); + + rte_tel_data_add_array_string(child_data, "aaaa"); +@@ -224,8 +247,7 @@ test_dict_with_dict_values(void) + rte_tel_data_add_dict_container(&response_data, "dict_of_dicts", + dict_of_dicts, 0); + +- return TEST_OUTPUT("{\"/test\":{\"dict_of_dicts\":{\"dict_0\":" +- "[\"aaaa\"],\"dict_1\":[\"bbbb\"]}}}"); ++ return CHECK_OUTPUT("{\"dict_of_dicts\":{\"dict_0\":[\"aaaa\"],\"dict_1\":[\"bbbb\"]}}"); + } + + static int +@@ -237,7 +259,6 @@ test_array_with_array_string_values(void) + struct rte_tel_data *child_data2 = rte_tel_data_alloc(); + rte_tel_data_start_array(child_data2, RTE_TEL_STRING_VAL); + +- memset(&response_data, 0, sizeof(response_data)); + rte_tel_data_start_array(&response_data, RTE_TEL_CONTAINER); + + rte_tel_data_add_array_string(child_data, "aaaa"); +@@ -246,18 +267,18 @@ test_array_with_array_string_values(void) + rte_tel_data_add_array_container(&response_data, child_data, 0); + rte_tel_data_add_array_container(&response_data, child_data2, 0); + +- return TEST_OUTPUT("{\"/test\":[[\"aaaa\"],[\"bbbb\"]]}"); ++ return CHECK_OUTPUT("[[\"aaaa\"],[\"bbbb\"]]"); + } + + static int + test_case_array_u64(void) + { + int i; +- memset(&response_data, 0, sizeof(response_data)); ++ + rte_tel_data_start_array(&response_data, RTE_TEL_U64_VAL); + for (i = 0; i < 5; i++) + rte_tel_data_add_array_u64(&response_data, i); +- return TEST_OUTPUT("{\"/test\":[0,1,2,3,4]}"); ++ return CHECK_OUTPUT("[0,1,2,3,4]"); + } + + static int +@@ -266,15 +287,13 @@ test_case_add_dict_u64(void) + int i = 0; + char name_of_value[8]; + +- memset(&response_data, 0, sizeof(response_data)); + 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_u64(&response_data, name_of_value, i); + } +- return TEST_OUTPUT("{\"/test\":{\"dict_0\":0,\"dict_1\":1,\"dict_2\":2," +- "\"dict_3\":3,\"dict_4\":4}}"); ++ return CHECK_OUTPUT("{\"dict_0\":0,\"dict_1\":1,\"dict_2\":2,\"dict_3\":3,\"dict_4\":4}"); + } + + static int +@@ -288,7 +307,6 @@ test_dict_with_array_u64_values(void) + struct rte_tel_data *child_data2 = rte_tel_data_alloc(); + rte_tel_data_start_array(child_data2, RTE_TEL_U64_VAL); + +- memset(&response_data, 0, sizeof(response_data)); + rte_tel_data_start_dict(&response_data); + + for (i = 0; i < 10; i++) { +@@ -301,8 +319,7 @@ test_dict_with_array_u64_values(void) + rte_tel_data_add_dict_container(&response_data, "dict_1", + child_data2, 0); + +- return TEST_OUTPUT("{\"/test\":{\"dict_0\":[0,1,2,3,4,5,6,7,8,9]," +- "\"dict_1\":[0,1,2,3,4,5,6,7,8,9]}}"); ++ return CHECK_OUTPUT("{\"dict_0\":[0,1,2,3,4,5,6,7,8,9],\"dict_1\":[0,1,2,3,4,5,6,7,8,9]}"); + } + + static int +@@ -316,7 +333,6 @@ test_array_with_array_u64_values(void) + struct rte_tel_data *child_data2 = rte_tel_data_alloc(); + rte_tel_data_start_array(child_data2, RTE_TEL_U64_VAL); + +- memset(&response_data, 0, sizeof(response_data)); + rte_tel_data_start_array(&response_data, RTE_TEL_CONTAINER); + + for (i = 0; i < 5; i++) { +@@ -326,7 +342,7 @@ test_array_with_array_u64_values(void) + rte_tel_data_add_array_container(&response_data, child_data, 0); + rte_tel_data_add_array_container(&response_data, child_data2, 0); + +- return TEST_OUTPUT("{\"/test\":[[0,1,2,3,4],[0,1,2,3,4]]}"); ++ return CHECK_OUTPUT("[[0,1,2,3,4],[0,1,2,3,4]]"); + } + + static int +@@ -367,7 +383,7 @@ connect_to_socket(void) + } + + static int +-test_telemetry_data(void) ++telemetry_data_autotest(void) + { + typedef int (*test_case)(void); + unsigned int i = 0; +@@ -376,7 +392,9 @@ test_telemetry_data(void) + if (sock <= 0) + return -1; + +- test_case test_cases[] = {test_case_array_string, ++ test_case test_cases[] = { ++ 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_add_dict_string, +@@ -388,8 +406,9 @@ test_telemetry_data(void) + test_array_with_array_u64_values, + test_array_with_array_string_values }; + +- rte_telemetry_register_cmd(REQUEST_CMD, test_cb, "Test"); ++ rte_telemetry_register_cmd(REQUEST_CMD, telemetry_test_cb, "Test"); + for (i = 0; i < RTE_DIM(test_cases); i++) { ++ memset(&response_data, 0, sizeof(response_data)); + if (test_cases[i]() != 0) { + close(sock); + return -1; +@@ -399,4 +418,4 @@ test_telemetry_data(void) + return 0; + } + +-REGISTER_TEST_COMMAND(telemetry_data_autotest, test_telemetry_data); ++REGISTER_TEST_COMMAND(telemetry_data_autotest, telemetry_data_autotest); +-- +2.23.0 + diff --git a/0245-test-telemetry_data-add-test-cases-for-character-esc.patch b/0245-test-telemetry_data-add-test-cases-for-character-esc.patch new file mode 100644 index 0000000..55a6d0e --- /dev/null +++ b/0245-test-telemetry_data-add-test-cases-for-character-esc.patch @@ -0,0 +1,74 @@ +From 2109f94d49b566309ace9de4fa7a5deaf42461b1 Mon Sep 17 00:00:00 2001 +From: Bruce Richardson +Date: Fri, 9 Sep 2022 10:35:21 +0100 +Subject: test/telemetry_data: add test cases for character escaping +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +[ upstream commit d0049f7a2c1654ffe704d7c1803db0402e49a2a7 ] + +Add in some basic unit tests to validate the character escaping being +done on string data values, which tests end-to-end processing of those +values beyond just the json-encoding steps tested by the +"telemetry_json_autotest". + +Signed-off-by: Bruce Richardson +Acked-by: Ciara Power +Acked-by: Morten Brørup +Acked-by: Chengwen Feng +--- + app/test/test_telemetry_data.c | 30 +++++++++++++++++++++++++++++- + 1 file changed, 29 insertions(+), 1 deletion(-) + +diff --git a/app/test/test_telemetry_data.c b/app/test/test_telemetry_data.c +index 75aca8791f..79ec48063f 100644 +--- a/app/test/test_telemetry_data.c ++++ b/app/test/test_telemetry_data.c +@@ -345,6 +345,30 @@ test_array_with_array_u64_values(void) + return CHECK_OUTPUT("[[0,1,2,3,4],[0,1,2,3,4]]"); + } + ++static int ++test_string_char_escaping(void) ++{ ++ rte_tel_data_string(&response_data, "hello,\nworld\n"); ++ return CHECK_OUTPUT("\"hello,\\nworld\\n\""); ++} ++ ++static int ++test_array_char_escaping(void) ++{ ++ rte_tel_data_start_array(&response_data, RTE_TEL_STRING_VAL); ++ rte_tel_data_add_array_string(&response_data, "\\escape\r"); ++ rte_tel_data_add_array_string(&response_data, "characters\n"); ++ return CHECK_OUTPUT("[\"\\\\escape\\r\",\"characters\\n\"]"); ++} ++ ++static int ++test_dict_char_escaping(void) ++{ ++ rte_tel_data_start_dict(&response_data); ++ rte_tel_data_add_dict_string(&response_data, "name", "escaped\n\tvalue"); ++ return CHECK_OUTPUT("{\"name\":\"escaped\\n\\tvalue\"}"); ++} ++ + static int + connect_to_socket(void) + { +@@ -404,7 +428,11 @@ telemetry_data_autotest(void) + test_dict_with_dict_values, + test_array_with_array_int_values, + test_array_with_array_u64_values, +- test_array_with_array_string_values }; ++ test_array_with_array_string_values, ++ test_string_char_escaping, ++ test_array_char_escaping, ++ test_dict_char_escaping, ++ }; + + rte_telemetry_register_cmd(REQUEST_CMD, telemetry_test_cb, "Test"); + for (i = 0; i < RTE_DIM(test_cases); i++) { +-- +2.23.0 + diff --git a/0246-telemetry-support-adding-integer-as-hexadecimal.patch b/0246-telemetry-support-adding-integer-as-hexadecimal.patch new file mode 100644 index 0000000..fd71a79 --- /dev/null +++ b/0246-telemetry-support-adding-integer-as-hexadecimal.patch @@ -0,0 +1,428 @@ +From 5ddac6457da2c3627871962f566098aa4d4862d9 Mon Sep 17 00:00:00 2001 +From: Huisong Li +Date: Mon, 19 Dec 2022 15:06:46 +0800 +Subject: telemetry: support adding integer as hexadecimal +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +[ upstream commit 82c33481c6abdec2fc58f1199ca6202e7400c08d ] + +Sometimes displaying an unsigned integer value as hexadecimal encoded style +is more expected for human consumption, such as, offload capability and +device flag. This patch introduces two APIs to add unsigned integer value +as hexadecimal encoded string to array or dictionary. And user can choose +whether the stored value is padded to the specified width. + +Signed-off-by: Huisong Li +Acked-by: Morten Brørup +Acked-by: Chengwen Feng +Acked-by: Bruce Richardson +--- + app/test/test_telemetry_data.c | 150 +++++++++++++++++++++++++++++++++ + lib/telemetry/rte_telemetry.h | 47 +++++++++++ + lib/telemetry/telemetry_data.c | 76 +++++++++++++++++ + lib/telemetry/version.map | 10 +++ + 4 files changed, 283 insertions(+) + +diff --git a/app/test/test_telemetry_data.c b/app/test/test_telemetry_data.c +index 79ec48063f..7d9be376a6 100644 +--- a/app/test/test_telemetry_data.c ++++ b/app/test/test_telemetry_data.c +@@ -201,6 +201,39 @@ test_case_add_dict_string(void) + return CHECK_OUTPUT("{\"dict_0\":\"aaaa\",\"dict_1\":\"bbbb\",\"dict_2\":\"cccc\",\"dict_3\":\"dddd\"}"); + } + ++static int ++test_case_add_dict_uint_hex_padding(void) ++{ ++ rte_tel_data_start_dict(&response_data); ++ ++ rte_tel_data_add_dict_uint_hex(&response_data, "dict_0", ++ (uint8_t)0x8, 8); ++ rte_tel_data_add_dict_uint_hex(&response_data, "dict_1", ++ (uint16_t)0x88, 16); ++ rte_tel_data_add_dict_uint_hex(&response_data, "dict_2", ++ (uint32_t)0x888, 32); ++ rte_tel_data_add_dict_uint_hex(&response_data, "dict_3", ++ (uint64_t)0x8888, 64); ++ ++ return CHECK_OUTPUT("{\"dict_0\":\"0x08\",\"dict_1\":\"0x0088\",\"dict_2\":\"0x00000888\",\"dict_3\":\"0x0000000000008888\"}"); ++} ++ ++static int ++test_case_add_dict_uint_hex_nopadding(void) ++{ ++ rte_tel_data_start_dict(&response_data); ++ ++ rte_tel_data_add_dict_uint_hex(&response_data, "dict_0", ++ (uint8_t)0x8, 0); ++ rte_tel_data_add_dict_uint_hex(&response_data, "dict_1", ++ (uint16_t)0x88, 0); ++ rte_tel_data_add_dict_uint_hex(&response_data, "dict_2", ++ (uint32_t)0x888, 0); ++ rte_tel_data_add_dict_uint_hex(&response_data, "dict_3", ++ (uint64_t)0x8888, 0); ++ ++ return CHECK_OUTPUT("{\"dict_0\":\"0x8\",\"dict_1\":\"0x88\",\"dict_2\":\"0x888\",\"dict_3\":\"0x8888\"}"); ++} + + static int + test_dict_with_array_string_values(void) +@@ -224,6 +257,50 @@ test_dict_with_array_string_values(void) + return CHECK_OUTPUT("{\"dict_0\":[\"aaaa\"],\"dict_1\":[\"bbbb\"]}"); + } + ++static int ++test_dict_with_array_uint_hex_values_padding(void) ++{ ++ struct rte_tel_data *child_data = rte_tel_data_alloc(); ++ rte_tel_data_start_array(child_data, RTE_TEL_STRING_VAL); ++ ++ struct rte_tel_data *child_data2 = rte_tel_data_alloc(); ++ rte_tel_data_start_array(child_data2, RTE_TEL_STRING_VAL); ++ ++ rte_tel_data_start_dict(&response_data); ++ ++ rte_tel_data_add_array_uint_hex(child_data, (uint32_t)0x888, 32); ++ rte_tel_data_add_array_uint_hex(child_data2, (uint64_t)0x8888, 64); ++ ++ 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\":[\"0x00000888\"],\"dict_1\":[\"0x0000000000008888\"]}"); ++} ++ ++static int ++test_dict_with_array_uint_hex_values_nopadding(void) ++{ ++ struct rte_tel_data *child_data = rte_tel_data_alloc(); ++ rte_tel_data_start_array(child_data, RTE_TEL_STRING_VAL); ++ ++ struct rte_tel_data *child_data2 = rte_tel_data_alloc(); ++ rte_tel_data_start_array(child_data2, RTE_TEL_STRING_VAL); ++ ++ rte_tel_data_start_dict(&response_data); ++ ++ rte_tel_data_add_array_uint_hex(child_data, (uint32_t)0x888, 0); ++ rte_tel_data_add_array_uint_hex(child_data2, (uint64_t)0x8888, 0); ++ ++ 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\":[\"0x888\"],\"dict_1\":[\"0x8888\"]}"); ++} ++ + static int + test_dict_with_dict_values(void) + { +@@ -270,6 +347,47 @@ test_array_with_array_string_values(void) + return CHECK_OUTPUT("[[\"aaaa\"],[\"bbbb\"]]"); + } + ++static int ++test_array_with_array_uint_hex_values_padding(void) ++{ ++ struct rte_tel_data *child_data = rte_tel_data_alloc(); ++ rte_tel_data_start_array(child_data, RTE_TEL_STRING_VAL); ++ ++ struct rte_tel_data *child_data2 = rte_tel_data_alloc(); ++ rte_tel_data_start_array(child_data2, RTE_TEL_STRING_VAL); ++ ++ rte_tel_data_start_array(&response_data, RTE_TEL_CONTAINER); ++ ++ rte_tel_data_add_array_uint_hex(child_data, (uint32_t)0x888, 32); ++ rte_tel_data_add_array_uint_hex(child_data2, (uint64_t)0x8888, 64); ++ ++ 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("[[\"0x00000888\"],[\"0x0000000000008888\"]]"); ++} ++ ++ ++static int ++test_array_with_array_uint_hex_values_nopadding(void) ++{ ++ struct rte_tel_data *child_data = rte_tel_data_alloc(); ++ rte_tel_data_start_array(child_data, RTE_TEL_STRING_VAL); ++ ++ struct rte_tel_data *child_data2 = rte_tel_data_alloc(); ++ rte_tel_data_start_array(child_data2, RTE_TEL_STRING_VAL); ++ ++ rte_tel_data_start_array(&response_data, RTE_TEL_CONTAINER); ++ ++ rte_tel_data_add_array_uint_hex(child_data, (uint32_t)0x888, 0); ++ rte_tel_data_add_array_uint_hex(child_data2, (uint64_t)0x8888, 0); ++ ++ 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("[[\"0x888\"],[\"0x8888\"]]"); ++} ++ + static int + test_case_array_u64(void) + { +@@ -281,6 +399,30 @@ test_case_array_u64(void) + return CHECK_OUTPUT("[0,1,2,3,4]"); + } + ++static int ++test_case_array_uint_hex_padding(void) ++{ ++ rte_tel_data_start_array(&response_data, RTE_TEL_STRING_VAL); ++ rte_tel_data_add_array_uint_hex(&response_data, (uint8_t)0x8, 8); ++ rte_tel_data_add_array_uint_hex(&response_data, (uint16_t)0x88, 16); ++ rte_tel_data_add_array_uint_hex(&response_data, (uint32_t)0x888, 32); ++ rte_tel_data_add_array_uint_hex(&response_data, (uint64_t)0x8888, 64); ++ ++ return CHECK_OUTPUT("[\"0x08\",\"0x0088\",\"0x00000888\",\"0x0000000000008888\"]"); ++} ++ ++static int ++test_case_array_uint_hex_nopadding(void) ++{ ++ rte_tel_data_start_array(&response_data, RTE_TEL_STRING_VAL); ++ rte_tel_data_add_array_uint_hex(&response_data, (uint8_t)0x8, 0); ++ rte_tel_data_add_array_uint_hex(&response_data, (uint16_t)0x88, 0); ++ rte_tel_data_add_array_uint_hex(&response_data, (uint32_t)0x888, 0); ++ rte_tel_data_add_array_uint_hex(&response_data, (uint64_t)0x8888, 0); ++ ++ return CHECK_OUTPUT("[\"0x8\",\"0x88\",\"0x888\",\"0x8888\"]"); ++} ++ + static int + test_case_add_dict_u64(void) + { +@@ -420,15 +562,23 @@ telemetry_data_autotest(void) + test_simple_string, + test_case_array_string, + test_case_array_int, test_case_array_u64, ++ test_case_array_uint_hex_padding, ++ test_case_array_uint_hex_nopadding, + test_case_add_dict_int, test_case_add_dict_u64, + test_case_add_dict_string, ++ test_case_add_dict_uint_hex_padding, ++ test_case_add_dict_uint_hex_nopadding, + test_dict_with_array_int_values, + test_dict_with_array_u64_values, + test_dict_with_array_string_values, ++ test_dict_with_array_uint_hex_values_padding, ++ test_dict_with_array_uint_hex_values_nopadding, + test_dict_with_dict_values, + test_array_with_array_int_values, + test_array_with_array_u64_values, + test_array_with_array_string_values, ++ test_array_with_array_uint_hex_values_padding, ++ test_array_with_array_uint_hex_values_nopadding, + test_string_char_escaping, + test_array_char_escaping, + test_dict_char_escaping, +diff --git a/lib/telemetry/rte_telemetry.h b/lib/telemetry/rte_telemetry.h +index 98870ab76b..cfca4a5cbf 100644 +--- a/lib/telemetry/rte_telemetry.h ++++ b/lib/telemetry/rte_telemetry.h +@@ -12,6 +12,7 @@ extern "C" { + #endif + + #include ++#include + + /** Maximum length for string used in object. */ + #define RTE_TEL_MAX_STRING_LEN 128 +@@ -155,6 +156,28 @@ int + rte_tel_data_add_array_container(struct rte_tel_data *d, + struct rte_tel_data *val, int keep); + ++/** ++ * Convert an unsigned integer to hexadecimal encoded strings ++ * and add this string to an array. ++ * The array must have been started by rte_tel_data_start_array() ++ * with RTE_TEL_STRING_VAL as the type parameter. ++ * ++ * @param d ++ * The data structure passed to the callback. ++ * @param val ++ * The number to be returned in the array as a hexadecimal encoded strings. ++ * @param display_bitwidth ++ * The display bit width of the 'val'. If 'display_bitwidth' is zero, the ++ * value is stored in the array as no-padding zero hexadecimal encoded string, ++ * or the value is stored as padding zero to specified hexadecimal width. ++ * @return ++ * 0 on success, negative errno on error. ++ */ ++__rte_experimental ++int ++rte_tel_data_add_array_uint_hex(struct rte_tel_data *d, uint64_t val, ++ uint8_t display_bitwidth); ++ + /** + * Add a string value to a dictionary. + * The dict must have been started by rte_tel_data_start_dict(). +@@ -233,6 +256,30 @@ int + rte_tel_data_add_dict_container(struct rte_tel_data *d, const char *name, + struct rte_tel_data *val, int keep); + ++/** ++ * Convert an unsigned integer to hexadecimal encoded strings ++ * and add this string to an 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 of the value is to be stored in the dict. ++ * Must contain only alphanumeric characters or the symbols: '_' or '/'. ++ * @param val ++ * The number to be stored in the dict as a hexadecimal encoded strings. ++ * @param display_bitwidth ++ * The display bit width of the 'val'. If 'display_bitwidth' is zero, the ++ * value is stored in the array as no-padding zero hexadecimal encoded string, ++ * or the value is stored as padding zero to specified hexadecimal width. ++ * @return ++ * 0 on success, negative errno on error. ++ */ ++__rte_experimental ++int ++rte_tel_data_add_dict_uint_hex(struct rte_tel_data *d, const char *name, ++ uint64_t val, uint8_t display_bitwidth); ++ + /** + * This telemetry callback is used when registering a telemetry command. + * It handles getting and formatting information to be returned to telemetry +diff --git a/lib/telemetry/telemetry_data.c b/lib/telemetry/telemetry_data.c +index be46054c29..7eec93ee75 100644 +--- a/lib/telemetry/telemetry_data.c ++++ b/lib/telemetry/telemetry_data.c +@@ -2,12 +2,18 @@ + * Copyright(c) 2020 Intel Corporation + */ + ++#include ++#include ++#include ++ + #undef RTE_USE_LIBBSD + #include + #include + + #include "telemetry_data.h" + ++#define RTE_TEL_UINT_HEX_STR_BUF_LEN 64 ++ + int + rte_tel_data_start_array(struct rte_tel_data *d, enum rte_tel_value_type type) + { +@@ -93,6 +99,60 @@ rte_tel_data_add_array_container(struct rte_tel_data *d, + return 0; + } + ++/* To suppress compiler warning about format string. */ ++#if defined(RTE_TOOLCHAIN_GCC) ++#pragma GCC diagnostic push ++#pragma GCC diagnostic ignored "-Wformat-nonliteral" ++#elif defined(RTE_TOOLCHAIN_CLANG) ++#pragma clang diagnostic push ++#pragma clang diagnostic ignored "-Wformat-nonliteral" ++#endif ++ ++static int ++rte_tel_uint_to_hex_encoded_str(char *buf, size_t buf_len, uint64_t val, ++ uint8_t display_bitwidth) ++{ ++#define RTE_TEL_HEX_FORMAT_LEN 16 ++ ++ uint8_t spec_hex_width = (display_bitwidth + 3) / 4; ++ char format[RTE_TEL_HEX_FORMAT_LEN]; ++ ++ if (display_bitwidth != 0) { ++ if (snprintf(format, RTE_TEL_HEX_FORMAT_LEN, "0x%%0%u" PRIx64, ++ spec_hex_width) >= RTE_TEL_HEX_FORMAT_LEN) ++ return -EINVAL; ++ ++ if (snprintf(buf, buf_len, format, val) >= (int)buf_len) ++ return -EINVAL; ++ } else { ++ if (snprintf(buf, buf_len, "0x%" PRIx64, val) >= (int)buf_len) ++ return -EINVAL; ++ } ++ ++ return 0; ++} ++ ++#if defined(RTE_TOOLCHAIN_GCC) ++#pragma GCC diagnostic pop ++#elif defined(RTE_TOOLCHAIN_CLANG) ++#pragma clang diagnostic pop ++#endif ++ ++int ++rte_tel_data_add_array_uint_hex(struct rte_tel_data *d, uint64_t val, ++ uint8_t display_bitwidth) ++{ ++ char hex_str[RTE_TEL_UINT_HEX_STR_BUF_LEN]; ++ int ret; ++ ++ ret = rte_tel_uint_to_hex_encoded_str(hex_str, ++ RTE_TEL_UINT_HEX_STR_BUF_LEN, val, display_bitwidth); ++ if (ret != 0) ++ return ret; ++ ++ return rte_tel_data_add_array_string(d, hex_str); ++} ++ + static bool + valid_name(const char *name) + { +@@ -200,6 +260,22 @@ rte_tel_data_add_dict_container(struct rte_tel_data *d, const char *name, + return bytes < RTE_TEL_MAX_STRING_LEN ? 0 : E2BIG; + } + ++int ++rte_tel_data_add_dict_uint_hex(struct rte_tel_data *d, const char *name, ++ uint64_t val, uint8_t display_bitwidth) ++{ ++ char hex_str[RTE_TEL_UINT_HEX_STR_BUF_LEN]; ++ int ret; ++ ++ ret = rte_tel_uint_to_hex_encoded_str(hex_str, ++ RTE_TEL_UINT_HEX_STR_BUF_LEN, val, display_bitwidth); ++ if (ret != 0) ++ return ret; ++ ++ ++ return rte_tel_data_add_dict_string(d, name, hex_str); ++} ++ + struct rte_tel_data * + rte_tel_data_alloc(void) + { +diff --git a/lib/telemetry/version.map b/lib/telemetry/version.map +index 77528bb1fe..576ac55297 100644 +--- a/lib/telemetry/version.map ++++ b/lib/telemetry/version.map +@@ -19,6 +19,16 @@ DPDK_22 { + local: *; + }; + ++EXPERIMENTAL { ++ global: ++ ++ # added in 23.03 ++ rte_tel_data_add_array_uint_hex; ++ rte_tel_data_add_dict_uint_hex; ++ ++ local: *; ++}; ++ + INTERNAL { + rte_telemetry_legacy_register; + rte_telemetry_init; +-- +2.23.0 + diff --git a/0247-ethdev-get-capabilities-from-telemetry-in-hexadecima.patch b/0247-ethdev-get-capabilities-from-telemetry-in-hexadecima.patch new file mode 100644 index 0000000..bdc0a63 --- /dev/null +++ b/0247-ethdev-get-capabilities-from-telemetry-in-hexadecima.patch @@ -0,0 +1,62 @@ +From 08021d1d91ae6c2dfbd817eeed2c3f43adc0447f Mon Sep 17 00:00:00 2001 +From: Huisong Li +Date: Mon, 19 Dec 2022 15:06:48 +0800 +Subject: ethdev: get capabilities from telemetry in hexadecimal +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +[ upstream commit 796b031608d8d52e040f83304c676d3cda5af617 ] + +The 'dev_flags', 'rx_offloads', 'tx_offloads' and 'rss_hf' are better +displayed in hexadecimal format. + +Like: + --> old display by input /ethdev/info,0 + "dev_flags": 3, + "rx_offloads": 524288, + "tx_offloads": 65536, + "ethdev_rss_hf": 9100 + + --> new display + "dev_flags": "0x3", + "rx_offloads": "0x80000", + "tx_offloads": "0x10000", + "ethdev_rss_hf": "0x238c" + +Signed-off-by: Huisong Li +Acked-by: Morten Brørup +Acked-by: Chengwen Feng +--- + lib/ethdev/rte_ethdev.c | 15 ++++++++------- + 1 file changed, 8 insertions(+), 7 deletions(-) + +diff --git a/lib/ethdev/rte_ethdev.c b/lib/ethdev/rte_ethdev.c +index 5b15a85fba..9dbaabc482 100644 +--- a/lib/ethdev/rte_ethdev.c ++++ b/lib/ethdev/rte_ethdev.c +@@ -6431,13 +6431,14 @@ eth_dev_handle_port_info(const char *cmd __rte_unused, + rte_tel_data_add_dict_container(d, "rxq_state", rxq_state, 0); + rte_tel_data_add_dict_container(d, "txq_state", txq_state, 0); + rte_tel_data_add_dict_int(d, "numa_node", eth_dev->data->numa_node); +- rte_tel_data_add_dict_u64(d, "dev_flags", eth_dev->data->dev_flags); +- rte_tel_data_add_dict_u64(d, "rx_offloads", +- eth_dev->data->dev_conf.rxmode.offloads); +- rte_tel_data_add_dict_u64(d, "tx_offloads", +- eth_dev->data->dev_conf.txmode.offloads); +- rte_tel_data_add_dict_u64(d, "ethdev_rss_hf", +- eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf); ++ rte_tel_data_add_dict_uint_hex(d, "dev_flags", ++ eth_dev->data->dev_flags, 0); ++ rte_tel_data_add_dict_uint_hex(d, "rx_offloads", ++ eth_dev->data->dev_conf.rxmode.offloads, 0); ++ rte_tel_data_add_dict_uint_hex(d, "tx_offloads", ++ eth_dev->data->dev_conf.txmode.offloads, 0); ++ rte_tel_data_add_dict_uint_hex(d, "ethdev_rss_hf", ++ eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf, 0); + + return 0; + } +-- +2.23.0 + diff --git a/dpdk.spec b/dpdk.spec index 45664e0..bac450c 100644 --- a/dpdk.spec +++ b/dpdk.spec @@ -1,6 +1,6 @@ Name: dpdk Version: 21.11 -Release: 34 +Release: 35 Packager: packaging@6wind.com URL: http://dpdk.org %global source_version 21.11 @@ -256,6 +256,15 @@ Patch9235: 0235-net-hns3-make-getting-Tx-function-static.patch Patch9236: 0236-net-hns3-extract-common-functions-to-set-Rx-Tx.patch Patch9237: 0237-net-hns3-declare-flow-rule-keeping-capability.patch Patch9238: 0238-app-testpmd-add-disable-flow-flush-option.patch +Patch9239: 0239-telemetry-move-include-after-guard.patch +Patch9240: 0240-ethdev-fix-telemetry-data-truncation.patch +Patch9241: 0241-mempool-fix-telemetry-data-truncation.patch +patch9242: 0242-cryptodev-fix-telemetry-data-truncation.patch +Patch9243: 0243-mem-fix-telemetry-data-truncation.patch +Patch9244: 0244-test-telemetry_data-refactor-for-maintainability.patch +Patch9245: 0245-test-telemetry_data-add-test-cases-for-character-esc.patch +Patch9246: 0246-telemetry-support-adding-integer-as-hexadecimal.patch +Patch9247: 0247-ethdev-get-capabilities-from-telemetry-in-hexadecima.patch Summary: Data Plane Development Kit core Group: System Environment/Libraries @@ -398,6 +407,20 @@ strip -g $RPM_BUILD_ROOT/lib/modules/%{kern_devel_ver}/extra/dpdk/igb_uio.ko /usr/sbin/depmod %changelog +* Fri Mar 10 2023 chenjiji - 21.11-35 + Fix telemetry data function for some lib. And support + displaying integer as hexadecimal. + Patchs are as follow: + - telemetry: move include after guard + - ethdev: fix telemetry data truncation + - mempool: fix telemetry data truncation + - cryptodev: fix telemetry data truncation + - mem: fix telemetry data truncation + - test/telemetry_data: refactor for maintainability + - test/telemetry_data: add test cases for character escaping + - telemetry: support adding integer as hexadecimal + - ethdev: get capabilities from telemetry in hexadecimal + * Fri Mar 03 2023 chenjiji - 21.11-34 Support flow rule keeping capability for hns3 PMD and testpmd. Patchs are as follow: -- Gitee