From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 85B5DA00C5; Mon, 6 Jul 2020 22:38:15 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id EBACB1DD1D; Mon, 6 Jul 2020 22:38:00 +0200 (CEST) Received: from mailout2.w1.samsung.com (mailout2.w1.samsung.com [210.118.77.12]) by dpdk.org (Postfix) with ESMTP id 6CD861DD01 for ; Mon, 6 Jul 2020 22:37:59 +0200 (CEST) Received: from eucas1p2.samsung.com (unknown [182.198.249.207]) by mailout2.w1.samsung.com (KnoxPortal) with ESMTP id 20200706203758euoutp026455cce955f1005a4cc058111853b604~fREpDn8o21760817608euoutp02W; Mon, 6 Jul 2020 20:37:58 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 mailout2.w1.samsung.com 20200706203758euoutp026455cce955f1005a4cc058111853b604~fREpDn8o21760817608euoutp02W DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=samsung.com; s=mail20170921; t=1594067878; bh=vMec8EIsQzAulmX4sPhJTJM/231q/aaNJYVNXJvukBs=; h=From:To:Subject:Date:In-Reply-To:Reply-To:References:From; b=pivY/YD2dkYt9isW9P8GYgDD6XVJn/eueI8lfmkwy2YVTjVzZeZFVcd4UaSyBf4nT rTVgwblwzIFoTS/6CC/KVnwLy+NX80weE7KD2/xt8tmijCFlukF5ObIlzdqKlutCzb /zfma2aUpEwO1UQ93L6zBoeXANgHWZKwzRhXnmfM= Received: from eusmges3new.samsung.com (unknown [203.254.199.245]) by eucas1p1.samsung.com (KnoxPortal) with ESMTP id 20200706203757eucas1p1e18af4b01670a92025ed1ed161de5ea2~fREoJyHMF2452524525eucas1p18; Mon, 6 Jul 2020 20:37:57 +0000 (GMT) Received: from eucas1p2.samsung.com ( [182.198.249.207]) by eusmges3new.samsung.com (EUCPMTA) with SMTP id 2E.B6.06318.5AB830F5; Mon, 6 Jul 2020 21:37:57 +0100 (BST) Received: from eusmtrp1.samsung.com (unknown [182.198.249.138]) by eucas1p2.samsung.com (KnoxPortal) with ESMTPA id 20200706203757eucas1p2f59654f60db48ec7164aad3d29ad6dff~fREnxFSpt2126421264eucas1p2p; Mon, 6 Jul 2020 20:37:57 +0000 (GMT) Received: from eusmgms1.samsung.com (unknown [182.198.249.179]) by eusmtrp1.samsung.com (KnoxPortal) with ESMTP id 20200706203757eusmtrp1bf933607d0fb02c1354191515ed08272~fREnwCuf32965829658eusmtrp1l; Mon, 6 Jul 2020 20:37:57 +0000 (GMT) X-AuditID: cbfec7f5-371ff700000018ae-0e-5f038ba5a927 Received: from eusmtip1.samsung.com ( [203.254.199.221]) by eusmgms1.samsung.com (EUCPMTA) with SMTP id 7D.CF.06314.5AB830F5; Mon, 6 Jul 2020 21:37:57 +0100 (BST) Received: from idyukov.rnd.samsung.ru (unknown [106.109.129.29]) by eusmtip1.samsung.com (KnoxPortal) with ESMTPA id 20200706203755eusmtip1873f504ce548404fbb6eea689eb09010~fREl9Ed5S1560515605eusmtip18; Mon, 6 Jul 2020 20:37:55 +0000 (GMT) From: Ivan Dyukov To: dev@dpdk.org, i.dyukov@samsung.com, v.kuramshin@samsung.com, thomas@monjalon.net, david.marchand@redhat.com, ferruh.yigit@intel.com, arybchenko@solarflare.com, wei.zhao1@intel.com, jia.guo@intel.com, beilei.xing@intel.com, qiming.yang@intel.com, wenzhuo.lu@intel.com, mb@smartsharesystems.com, stephen@networkplumber.org, nicolas.chautru@intel.com, bruce.richardson@intel.com, konstantin.ananyev@intel.com, cristian.dumitrescu@intel.com, radu.nicolau@intel.com, akhil.goyal@nxp.com, declan.doherty@intel.com, skori@marvell.com, pbhagavatula@marvell.com, jerinj@marvell.com, kirankumark@marvell.com, david.hunt@intel.com, anatoly.burakov@intel.com, xiaoyun.li@intel.com, jingjing.wu@intel.com, john.mcnamara@intel.com, jasvinder.singh@intel.com, byron.marohn@intel.com, yipeng1.wang@intel.com Date: Mon, 6 Jul 2020 23:37:16 +0300 Message-Id: <20200706203743.29416-3-i.dyukov@samsung.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200706203743.29416-1-i.dyukov@samsung.com> X-Brightmail-Tracker: H4sIAAAAAAAAA0WSbUxTdxTG/d93Kl2u1cQTML50M0ODqNOYw2Z0TpPdxJn4YckSN8WqN0Ck YHrBgcQEnDRd2zEtxQ6cyCCKlClQUSoBg6ggVERhBpugdkQloENexA2tYy0Xs2+/85yX5/lw BFrn4KKE5NR02ZRqSNFzGuZy62TXijM2OmHV1J+rsPp2CcH+R+U0BpwPObSNHKXwgXsjNtb/ yqLjcQ6F+Y5RCuvPWTl8ETjC4PBYPYV9TT4ei7uP8DjWMsDjT10nCQ4Eh2gsKh0n2FVyicXJ aw0cvgyWMZj/5j7Bn+tuEWyzjzLovOIlaLaKOFJZwWN530IcC9xi0Oe/yOPvE/dovHT7HcHj bdUEO81T7OdLpDelZ1ipvHGQkgp+u0dLrf4TvGRvL6Gk2mEvJb28ep+T8uvcROrot9FS1ZN/ uO2aHZr1++SU5IOyaeWG3ZqkH50u9kCri2RWFx5jc0h3ppVECCCuhbGzV6gw68RzBCpdyVai CfErAjWBTlotxgkMF46T9xtlRV5ebVQQyLVYOLWYCBVP7Wx4ihNjwGcpocKNeWItB/XB3mmT ueKXYG9wMGFmxKWQO+mcPqsV48FV4GNVi0VQVdMc8haECPFTOHUzSs23EHpPv5q+CeJdAfKe Hp+JtAWGi2tolefCUFsdr/IC8BXYGZWz4W9PL68uWwg8KsubGdoIdc/v8GEzWlwG1Q0rVXkT XDgfnM4A4gfw4K85YZkOoeOya0bWgsWsU6f10NzePSMDvHsbqaIEvsHVavgmAm5b7DGyqPh/ p1JC3GS+nKEYE2VlTar8fZxiMCoZqYlxe9OMHhL6VN+/bRNecjW4p4WIAtFHagMCnaBjDQeV LGMLAYHWz9N+0enbpdPuM2Qdkk1pCaaMFFlpIdECo5+vXVM2uFMnJhrS5f2yfEA2ve9SQkRU DunxR67VHs62GTN6thVFx+7qi58y1LbTnqb0bz57nTy+7qMbz/JGF7tHC2e99vc//zDO25P2 wyff3nBGmga+/uro7OvN8UNO63dU6YbDVQkvLibtN271mswpStHpj/8YyZrjSfLMmqj45Xy0 ee/SpnjKr2nMvNOxOXdx110PHROb3WHbpGeUJMPq5bRJMfwHkHAJZqUDAAA= X-Brightmail-Tracker: H4sIAAAAAAAAAzWSa0hTYRjHe89tR2lxmlZvRmaDLhTNjqY+62JixE4fgiDrQ7c19KSWc7mz SdnNJMw2M10rs8uyRCoNzbQ0MdGBWi0TNbuaiRlRmbeUctjFJX37w+/3XOB5WFIxSvmx8Ykm 0ZioS1Ay3pTrd9O7ZYVWUru8vQtD6VMHgp6uAhK67e8YsA6eIOBV0VqoqbxMg+19KgFZtiEC Km9aGOjrTqOgf7iSgM6HLhlcbEuTwbDzkwxOt1xC8Gn8Cwl5+d8RtDju0TBWX83AwPh1CrLc HQjOVDxC0JQ5RIH9QRWCdAsHg7duyKCg0x+Gux9R4HpdLoPbo60k3Hv6C0FOUymC5vQ/dMR8 wZ1fSAsFNZ8J4ey1VlJofH1eJmQ+dhBCWX8VIQzUdjBCVkUREp70WEmhuPcns8l7m2q10WA2 iQFxBsm0RrmdhyAVrwZV0Aq1ig8O27kyKEQZGL46RkyITxaNgeG7VXGn7Ln0/sZcdKD0XDad itoOWJAXi7kV+HpelcyCvFkFV4iw44kbWRA7ATD+2ktOOj54/IWFmXS+I3zDnUl5AMMtxq4M B+EBvtxbBrefPP4P+HAanFlt+5cpbgE+PmZHnizn1Dj3rIue7DoPF9+pIz3DvLiV+EqDnycq uHj8ZkTmMRScP355dYTIRtPy0ZQi5CuaJX2sXuJVkk4vmRNjVdEG/V00cfL7jWPlVaitbLMT cSxSTpVnMKRWQeuSpYN6J8IsqfSVRza7dinkMbqDKaLRoDWaE0TJiUIm1ssh/WZEGyYeKNGk 5UP4MFDzYcFhwaGgnCXP4Op3KLhYnUncJ4r7ReP/OoL18ktF5y+7rCeSLxyu+zi9WBP+LTIn nR95PD1pfVTSOm0fO7tuzu/IVb9Co/ZE5Zk3Pj9kod0hgR+2rK/mfmxriFlkK6tn915S19gj skp6Rwe6A7D4Y+vCk0kpFefIF21HOkP7muc2zteod858WfJxYMN2a0TZ0c3jJQH6m9HPptYe W5rm1CgpKU7HLyGNku4vLeipCggDAAA= X-CMS-MailID: 20200706203757eucas1p2f59654f60db48ec7164aad3d29ad6dff X-Msg-Generator: CA Content-Type: text/plain; charset="utf-8" X-RootMTR: 20200706203757eucas1p2f59654f60db48ec7164aad3d29ad6dff X-EPHeader: CA CMS-TYPE: 201P X-CMS-RootMailID: 20200706203757eucas1p2f59654f60db48ec7164aad3d29ad6dff References: <20200427095737.11082-1-i.dyukov@samsung.com> <20200706203743.29416-1-i.dyukov@samsung.com> Subject: [dpdk-dev] [PATCH v6 02/25] ethdev: add a link status text representation X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list Reply-To: i.dyukov@samsung.com List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" This commit add function which treat link status structure and format it to text representation. Signed-off-by: Ivan Dyukov --- MAINTAINERS | 1 + app/test/Makefile | 3 + app/test/meson.build | 2 + app/test/test_ethdev_link.c | 278 +++++++++++++++++++++++ lib/librte_ethdev/rte_ethdev.c | 169 ++++++++++++++ lib/librte_ethdev/rte_ethdev.h | 54 +++++ lib/librte_ethdev/rte_ethdev_version.map | 4 + 7 files changed, 511 insertions(+) create mode 100644 app/test/test_ethdev_link.c diff --git a/MAINTAINERS b/MAINTAINERS index 5e706cd7e..f4fb31ea2 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -393,6 +393,7 @@ T: git://dpdk.org/next/dpdk-next-net F: lib/librte_ethdev/ F: devtools/test-null.sh F: doc/guides/prog_guide/switch_representation.rst +F: app/test/test_ethdev* Flow API M: Ori Kam diff --git a/app/test/Makefile b/app/test/Makefile index e5440774b..9f43b8c3c 100644 --- a/app/test/Makefile +++ b/app/test/Makefile @@ -251,6 +251,9 @@ SRCS-$(CONFIG_RTE_LIBRTE_SECURITY) += test_security.c SRCS-$(CONFIG_RTE_LIBRTE_IPSEC) += test_ipsec.c test_ipsec_perf.c SRCS-$(CONFIG_RTE_LIBRTE_IPSEC) += test_ipsec_sad.c + +SRCS-$(CONFIG_RTE_LIBRTE_ETHER) += test_ethdev_link.c + ifeq ($(CONFIG_RTE_LIBRTE_IPSEC),y) LDLIBS += -lrte_ipsec endif diff --git a/app/test/meson.build b/app/test/meson.build index 56591db4e..6df31a4dc 100644 --- a/app/test/meson.build +++ b/app/test/meson.build @@ -39,6 +39,7 @@ test_sources = files('commands.c', 'test_efd.c', 'test_efd_perf.c', 'test_errno.c', + 'test_ethdev_link.c', 'test_event_crypto_adapter.c', 'test_event_eth_rx_adapter.c', 'test_event_ring.c', @@ -199,6 +200,7 @@ fast_tests = [ ['eal_flags_misc_autotest', false], ['eal_fs_autotest', true], ['errno_autotest', true], + ['ethdev_link_status' true], ['event_ring_autotest', true], ['fib_autotest', true], ['fib6_autotest', true], diff --git a/app/test/test_ethdev_link.c b/app/test/test_ethdev_link.c new file mode 100644 index 000000000..6709323ef --- /dev/null +++ b/app/test/test_ethdev_link.c @@ -0,0 +1,278 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved + */ + +#include +#include + +#include +#include "test.h" + + +static int32_t +test_link_status_up_default(void) +{ + int ret = 0; + struct rte_eth_link link_status = { + .link_speed = ETH_SPEED_NUM_2_5G, + .link_status = ETH_LINK_UP, + .link_autoneg = ETH_LINK_AUTONEG, + .link_duplex = ETH_LINK_FULL_DUPLEX + }; + char text[128]; + ret = rte_eth_link_strf(text, 128, NULL, &link_status); + RTE_TEST_ASSERT(ret > 0, "Failed to format default string\n"); + printf("Default link up #1: %s\n", text); + TEST_ASSERT_BUFFERS_ARE_EQUAL("Link up at 2.5 Gbit/s FDX Autoneg\n", + text, strlen(text), "Invalid default link status string"); + + link_status.link_duplex = ETH_LINK_HALF_DUPLEX; + link_status.link_autoneg = ETH_LINK_FIXED; + link_status.link_speed = ETH_SPEED_NUM_10M, + ret = rte_eth_link_strf(text, 128, NULL, &link_status); + printf("Default link up #2: %s\n", text); + RTE_TEST_ASSERT(ret > 0, "Failed to format default string\n"); + TEST_ASSERT_BUFFERS_ARE_EQUAL("Link up at 10 Mbit/s HDX Fixed\n", + text, strlen(text), "Invalid default link status " + "string with HDX"); + + link_status.link_speed = ETH_SPEED_NUM_UNKNOWN, + ret = rte_eth_link_strf(text, 128, NULL, &link_status); + printf("Default link up #3: %s\n", text); + RTE_TEST_ASSERT(ret > 0, "Failed to format default string\n"); + TEST_ASSERT_BUFFERS_ARE_EQUAL("Link up at Unknown speed HDX Fixed\n", + text, strlen(text), "Invalid default link status " + "string with HDX"); + return TEST_SUCCESS; +} + +static int32_t +test_link_status_down_default(void) +{ + int ret = 0; + struct rte_eth_link link_status = { + .link_speed = ETH_SPEED_NUM_2_5G, + .link_status = ETH_LINK_DOWN, + .link_autoneg = ETH_LINK_AUTONEG, + .link_duplex = ETH_LINK_FULL_DUPLEX + }; + char text[128]; + ret = rte_eth_link_strf(text, 128, NULL, &link_status); + RTE_TEST_ASSERT(ret > 0, "Failed to format default string\n"); + TEST_ASSERT_BUFFERS_ARE_EQUAL("Link down\n", + text, strlen(text), "Invalid default link status string"); + + return TEST_SUCCESS; +} + +static int32_t +test_link_status_string_overflow(void) +{ + int ret = 0; + struct rte_eth_link link_status = { + .link_speed = ETH_SPEED_NUM_2_5G, + .link_status = ETH_LINK_UP, + .link_autoneg = ETH_LINK_AUTONEG, + .link_duplex = ETH_LINK_FULL_DUPLEX + }; + char text[128]; + int i = 0; + for (i = 0; i < 128; i++) + text[i] = 'Y'; + text[127] = '\0'; + + ret = rte_eth_link_strf(NULL, 2, "status %S, %G Gbits/s", + &link_status); + RTE_TEST_ASSERT(ret < 0, "Format string should fail, but it's ok\n"); + + ret = rte_eth_link_strf(text, 2, "status %S, %G Gbits/s", + &link_status); + RTE_TEST_ASSERT(ret < 0, "Format string should fail, but it's ok\n"); + RTE_TEST_ASSERT(text[2] == 'Y', "String1 overflow\n"); + + ret = rte_eth_link_strf(text, 8, NULL, + &link_status); + RTE_TEST_ASSERT(ret < 0, "Default format string should fail," + " but it's ok\n"); + RTE_TEST_ASSERT(text[8] == 'Y', "String1 overflow\n"); + + ret = rte_eth_link_strf(text, 10, NULL, + &link_status); + RTE_TEST_ASSERT(ret < 0, "Default format string should fail," + " but it's ok\n"); + RTE_TEST_ASSERT(text[10] == 'Y', "String1 overflow\n"); + + text[1] = 'Y'; + ret = rte_eth_link_strf(text, 1, "%S", + &link_status); + RTE_TEST_ASSERT(ret < 0, "Status string should fail, but it's ok\n"); + RTE_TEST_ASSERT(text[1] == 'Y', "String1 overflow\n"); + + return TEST_SUCCESS; +} + +static int32_t +test_link_status_format(void) +{ + int ret = 0; + struct rte_eth_link link_status = { + .link_speed = ETH_SPEED_NUM_40G, + .link_status = ETH_LINK_UP, + .link_autoneg = ETH_LINK_AUTONEG, + .link_duplex = ETH_LINK_FULL_DUPLEX + }; + char text[128]; + int i = 0; + for (i = 0; i < 128; i++) + text[i] = 'Y'; + text[127] = '\0'; + printf("status format #1: %s\n", text); + ret = rte_eth_link_strf(text, 128, "status = %S, duplex = %D\n", + &link_status); + printf("status format #2: %s\n", text); + RTE_TEST_ASSERT(ret > 0, "Failed to format string\n"); + TEST_ASSERT_BUFFERS_ARE_EQUAL("status = Up, duplex = FDX\n", + text, strlen(text), "Invalid status string1."); + + ret = rte_eth_link_strf(text, 128, "%A", &link_status); + printf("status format #3: %s\n", text); + RTE_TEST_ASSERT(ret > 0, "Failed to format string\n"); + TEST_ASSERT_BUFFERS_ARE_EQUAL("Autoneg", + text, strlen(text), "Invalid status string2."); + + ret = rte_eth_link_strf(text, 128, + "%G", + &link_status); + printf("status format #4: %s\n", text); + RTE_TEST_ASSERT(ret > 0, "Failed to format string\n"); + TEST_ASSERT_BUFFERS_ARE_EQUAL("40.0", + text, strlen(text), "Invalid status string3."); + + ret = rte_eth_link_strf(text, 128, + "%M", + &link_status); + printf("status format #5: %s\n", text); + RTE_TEST_ASSERT(ret > 0, "Failed to format string\n"); + TEST_ASSERT_BUFFERS_ARE_EQUAL("40000", + text, strlen(text), "Invalid status string4."); + return TEST_SUCCESS; +} + +static int32_t +test_link_status_return_value(void) +{ + int ret = 0; + struct rte_eth_link link_status = { + .link_speed = ETH_SPEED_NUM_40G, + .link_status = ETH_LINK_UP, + .link_autoneg = ETH_LINK_AUTONEG, + .link_duplex = ETH_LINK_FULL_DUPLEX + }; + char text[128]; + int i = 0; + for (i = 0; i < 128; i++) + text[i] = 'Y'; + text[127] = '\0'; + ret = rte_eth_link_strf(text, 128, "status = %S, ", + &link_status); + printf("return value #1:ret=%u, text=%s\n", ret, text); + ret += rte_eth_link_strf(text + ret, 128 - ret, + "%A", + &link_status); + printf("return value #2:ret=%u, text=%s\n", ret, text); + ret += rte_eth_link_strf(text + ret, 128 - ret, + ", duplex = %D\n", + &link_status); + printf("return value #3:ret=%u, text=%s\n", ret, text); + ret += rte_eth_link_strf(text + ret, 128 - ret, + "%M Mbits/s\n", + &link_status); + printf("return value #4:ret=%u, text=%s\n", ret, text); + RTE_TEST_ASSERT(ret > 0, "Failed to format string\n"); + TEST_ASSERT_BUFFERS_ARE_EQUAL("status = Up, Autoneg, duplex = FDX\n" + "40000 Mbits/s\n", + text, strlen(text), "Invalid status string"); + + return TEST_SUCCESS; +} + +static int32_t +test_link_status_invalid_fmt(void) +{ + int ret = 0; + struct rte_eth_link link_status = { + .link_speed = ETH_SPEED_NUM_40G, + .link_status = ETH_LINK_UP, + .link_autoneg = ETH_LINK_AUTONEG, + .link_duplex = ETH_LINK_FULL_DUPLEX + }; + char text[128]; + ret = rte_eth_link_strf(text, 128, "status = %", + &link_status); + RTE_TEST_ASSERT(ret < 0, "Status string1 should fail, but it's ok\n"); + ret = rte_eth_link_strf(text, 128, + ", duplex = %d\n", + &link_status); + RTE_TEST_ASSERT(ret < 0, "Status string2 should fail, but it's ok\n"); + ret = rte_eth_link_strf(text, 128, + "% Mbits/s\n", + &link_status); + RTE_TEST_ASSERT(ret < 0, "Status string3 should fail, but it's ok\n"); + + return TEST_SUCCESS; +} + +static int32_t +test_link_status_format_edges(void) +{ + int ret = 0; + struct rte_eth_link link_status = { + .link_speed = ETH_SPEED_NUM_UNKNOWN, + .link_status = ETH_LINK_DOWN, + .link_autoneg = ETH_LINK_AUTONEG, + .link_duplex = ETH_LINK_HALF_DUPLEX + }; + char text[128]; + ret = rte_eth_link_strf(text, 4, "%S", &link_status); + printf("format edges #1: %s\n", text); + RTE_TEST_ASSERT(ret < 0, "It should fail. No space for " + "zero terminator\n"); + ret = rte_eth_link_strf(text, 6, "123%D", &link_status); + printf("format edges #2: %s\n", text); + RTE_TEST_ASSERT(ret < 0, "It should fail. No space for " + "zero terminator\n"); + ret = rte_eth_link_strf(text, 7, "%A", &link_status); + printf("format edges #3: %s\n", text); + RTE_TEST_ASSERT(ret < 0, "It should fail. No space for " + "zero terminator\n"); + ret = rte_eth_link_strf(text, 8, "%A", &link_status); + printf("format edges #4: %s\n", text); + RTE_TEST_ASSERT(ret > 0, "It should ok, but it fails\n"); + return TEST_SUCCESS; +} +static struct unit_test_suite link_status_testsuite = { + .suite_name = "link status formatting", + .setup = NULL, + .teardown = NULL, + .unit_test_cases = { + TEST_CASE(test_link_status_up_default), + TEST_CASE(test_link_status_down_default), + TEST_CASE(test_link_status_string_overflow), + TEST_CASE(test_link_status_format), + TEST_CASE(test_link_status_format_edges), + TEST_CASE(test_link_status_invalid_fmt), + TEST_CASE(test_link_status_return_value), + TEST_CASES_END() /**< NULL terminate unit test array */ + } +}; + +static int +test_link_status(void) +{ + rte_log_set_global_level(RTE_LOG_DEBUG); + rte_log_set_level(RTE_LOGTYPE_EAL, RTE_LOG_DEBUG); + + return unit_test_suite_runner(&link_status_testsuite); +} + +REGISTER_TEST_COMMAND(ethdev_link_status, test_link_status); diff --git a/lib/librte_ethdev/rte_ethdev.c b/lib/librte_ethdev/rte_ethdev.c index d06b7f9b1..2234af175 100644 --- a/lib/librte_ethdev/rte_ethdev.c +++ b/lib/librte_ethdev/rte_ethdev.c @@ -2383,6 +2383,175 @@ rte_eth_link_get_nowait(uint16_t port_id, struct rte_eth_link *eth_link) return 0; } +static int +rte_eth_link_strf_parser(char *str, size_t len, const char *const fmt, + struct rte_eth_link *link) +{ + size_t offset = 0; + const char *fmt_cur = fmt; + char *str_cur = str; + double gbits = (double)link->link_speed / 1000.; + static const char AUTONEG_STR[] = "Autoneg"; + static const char FIXED_STR[] = "Fixed"; + static const char FDX_STR[] = "FDX"; + static const char HDX_STR[] = "HDX"; + static const char UNKNOWN_STR[] = "Unknown"; + static const char UP_STR[] = "Up"; + static const char DOWN_STR[] = "Down"; + + char gbits_str[20]; + char mbits_str[20]; + /* preformat complex formatting to easily concatinate it further */ + snprintf(mbits_str, 20, "%u", link->link_speed); + snprintf(gbits_str, 20, "%.1f", gbits); + /* init str before formatting */ + str[0] = 0; + while (*fmt_cur) { + /* check str bounds */ + if (offset > (len - 1)) { + str[len - 1] = '\0'; + return -1; + } + if (*fmt_cur == '%') { + /* set null terminator to current position, + * it's required for strlcat + */ + *str_cur = '\0'; + switch (*++fmt_cur) { + /* Speed in Mbits/s */ + case 'M': + if (link->link_speed == + ETH_SPEED_NUM_UNKNOWN) + offset = strlcat(str, UNKNOWN_STR, + len); + else + offset = strlcat(str, mbits_str, len); + break; + /* Speed in Gbits/s */ + case 'G': + if (link->link_speed == + ETH_SPEED_NUM_UNKNOWN) + offset = strlcat(str, UNKNOWN_STR, + len); + else + offset = strlcat(str, gbits_str, len); + break; + /* Link status */ + case 'S': + offset = strlcat(str, link->link_status ? + UP_STR : DOWN_STR, len); + break; + /* Link autoneg */ + case 'A': + offset = strlcat(str, link->link_autoneg ? + AUTONEG_STR : FIXED_STR, len); + break; + /* Link duplex */ + case 'D': + offset = strlcat(str, link->link_duplex ? + FDX_STR : HDX_STR, len); + break; + /* Error cases */ + default: + return -1; + + } + if (offset > (len - 1)) + return -1; + + str_cur = str + offset; + } else { + *str_cur++ = *fmt_cur; + offset++; + } + fmt_cur++; + } + *str_cur = '\0'; + return offset; +} + +int +rte_eth_link_printf(const char *const fmt, + struct rte_eth_link *link) +{ + char text[200]; + int ret; + ret = rte_eth_link_strf(text, 200, fmt, link); + if (ret > 0) + printf("%s", text); + return ret; +} + +int +rte_eth_link_strf(char *str, size_t len, const char *const fmt, + struct rte_eth_link *link) +{ + size_t offset = 0; + double gbits = (double)link->link_speed / 1000.; + char gbits_str[20]; + char mbits_str[20]; + /* TBD: make it international? */ + static const char LINK_DOWN_STR[] = "Link down\n"; + static const char LINK_UP_STR[] = "Link up at "; + static const char UNKNOWN_SPEED_STR[] = "Unknown speed "; + static const char MBITS_STR[] = "Mbit/s"; + static const char GBITS_STR[] = "Gbit/s"; + static const char FDX_STR[] = "FDX "; + static const char HDX_STR[] = "HDX "; + /* autoneg is latest param in default string, so add '\n' */ + static const char AUTONEG_STR[] = "Autoneg\n"; + static const char FIXED_STR[] = "Fixed\n"; + if (str == NULL || len == 0) + return -1; + /* default format string, if no fmt is specified */ + if (fmt == NULL) { + if (link->link_status == ETH_LINK_DOWN) { + if (sizeof(LINK_DOWN_STR) > len) + return -1; + return strlcpy(str, LINK_DOWN_STR, len); + } + + /* preformat complex strings to easily concatinate it further */ + snprintf(mbits_str, 20, "%u %s ", link->link_speed, MBITS_STR); + snprintf(gbits_str, 20, "%.1f %s ", gbits, GBITS_STR); + + offset = strlcpy(str, LINK_UP_STR, len); + /* reserve one byte to null terminator */ + if (offset > (len - 1)) + return -1; + /* link speed */ + if (link->link_speed == ETH_SPEED_NUM_UNKNOWN) { + offset = strlcat(str, UNKNOWN_SPEED_STR, len); + if (offset > (len - 1)) + return -1; + } else { + if (link->link_speed < ETH_SPEED_NUM_1G) { + offset = strlcat(str, mbits_str, len); + if (offset > (len - 1)) + return -1; + } else { + offset = strlcat(str, gbits_str, len); + if (offset > (len - 1)) + return -1; + } + } + /* link duplex */ + offset = strlcat(str, link->link_duplex ? + FDX_STR : HDX_STR, len); + if (offset > (len - 1)) + return -1; + /* link autonegotiation */ + offset = strlcat(str, link->link_autoneg ? + AUTONEG_STR : FIXED_STR, len); + if (offset > (len - 1)) + return -1; + /* Formatted status */ + } else + offset = rte_eth_link_strf_parser(str, len, fmt, link); + + return offset; +} + int rte_eth_stats_get(uint16_t port_id, struct rte_eth_stats *stats) { diff --git a/lib/librte_ethdev/rte_ethdev.h b/lib/librte_ethdev/rte_ethdev.h index 2090af501..974fee591 100644 --- a/lib/librte_ethdev/rte_ethdev.h +++ b/lib/librte_ethdev/rte_ethdev.h @@ -2295,6 +2295,60 @@ int rte_eth_link_get(uint16_t port_id, struct rte_eth_link *link); */ int rte_eth_link_get_nowait(uint16_t port_id, struct rte_eth_link *link); + +/** + * print formatted link status to stdout. This function threats all + * special values like ETH_SPEED_NUM_UNKNOWN, ETH_LINK_DOWN etc. and convert + * them to textual representation. + * + * @param fmt + * Format string which allow to format link status. If NULL is provided + * , default formatting will be applied. + * Following specifiers are available: + * - '%M' link speed in Mbits/s + * - '%G' link speed in Gbits/s + * - '%S' link status. e.g. Up or Down + * - '%A' link autonegotiation state + * - '%D' link duplex state + * @param link + * Link status provided by rte_eth_link_get function + * @return + * - Number of bytes written to stdout. In case of error, -1 is returned. + * + */ +__rte_experimental +int rte_eth_link_printf(const char *const fmt, + struct rte_eth_link *link); + +/** + * Format link status to textual representation. This function threats all + * special values like ETH_SPEED_NUM_UNKNOWN, ETH_LINK_DOWN etc. and convert + * them to textual representation. + * + * @param str + * A pointer to a string to be filled with textual representation of + * device status. + * @param len + * Length of available memory at 'str' string. + * @param fmt + * Format string which allow to format link status. If NULL is provided + * , default formatting will be applied. + * Following specifiers are available: + * - '%M' link speed in Mbits/s + * - '%G' link speed in Gbits/s + * - '%S' link status. e.g. Up or Down + * - '%A' link autonegotiation state + * - '%D' link duplex state + * @param link + * Link status provided by rte_eth_link_get function + * @return + * - Number of bytes written to str array. In case of error, -1 is returned. + * + */ +__rte_experimental +int rte_eth_link_strf(char *str, size_t len, const char *const fmt, + struct rte_eth_link *eth_link); + /** * Retrieve the general I/O statistics of an Ethernet device. * diff --git a/lib/librte_ethdev/rte_ethdev_version.map b/lib/librte_ethdev/rte_ethdev_version.map index 715505604..6c80597d1 100644 --- a/lib/librte_ethdev/rte_ethdev_version.map +++ b/lib/librte_ethdev/rte_ethdev_version.map @@ -241,4 +241,8 @@ EXPERIMENTAL { __rte_ethdev_trace_rx_burst; __rte_ethdev_trace_tx_burst; rte_flow_get_aged_flows; + + # added in 20.08 + rte_eth_link_strf; + rte_eth_link_printf; }; -- 2.17.1