Addressing comments for Eth Port Counters Support ``` Changes : - Updated decode/encode resp functions to handle data of different types - Updated decode/encode req functions : change portNumber data size - added size checks to mockupResponder response creation ``` Fixes JIRA https://jirasw.nvidia.com/browse/DGXOPENBMC-15778
diff --git a/libnsm/network-ports.c b/libnsm/network-ports.c index ec2f7d4..b4a4312 100644 --- a/libnsm/network-ports.c +++ b/libnsm/network-ports.c
@@ -1670,7 +1670,7 @@ } int encode_get_eth_port_telemetry_counter_req(uint8_t instance_id, - uint8_t port_number, + uint16_t port_number, struct nsm_msg *msg) { if (msg == NULL) { @@ -1687,74 +1687,148 @@ return rc; } - nsm_get_port_telemetry_counter_req *request = - (nsm_get_port_telemetry_counter_req *)msg->payload; + struct nsm_get_ethernet_port_telemetry_counter_req *request = + (struct nsm_get_ethernet_port_telemetry_counter_req *)msg->payload; request->hdr.command = NSM_GET_ETH_PORT_TELEMETRY_COUNTER; request->hdr.data_size = sizeof(port_number); - request->port_number = port_number; + request->port_number = htole16(port_number); return NSM_SW_SUCCESS; } int decode_get_eth_port_telemetry_counter_req(const struct nsm_msg *msg, size_t msg_len, - uint8_t *port_number) + uint16_t *port_number) { if (msg == NULL || port_number == NULL) { return NSM_SW_ERROR_NULL; } - if (msg_len < sizeof(struct nsm_msg_hdr) + - sizeof(nsm_get_port_telemetry_counter_req)) { + if (msg_len < + sizeof(struct nsm_msg_hdr) + + sizeof(struct nsm_get_ethernet_port_telemetry_counter_req)) { return NSM_SW_ERROR_LENGTH; } - nsm_get_port_telemetry_counter_req *request = - (nsm_get_port_telemetry_counter_req *)msg->payload; + struct nsm_get_ethernet_port_telemetry_counter_req *request = + (struct nsm_get_ethernet_port_telemetry_counter_req *)msg->payload; if (request->hdr.data_size < sizeof(request->port_number)) { return NSM_SW_ERROR_DATA; } - *port_number = request->port_number; + *port_number = le16toh(request->port_number); return NSM_SW_SUCCESS; } -int decode_aggregate_eth_port_telemetry_data(const uint8_t *data, - size_t *data_len, - uint32_t *counter_reading) +int decode_aggregate_eth_port_telemetry_data( + const uint8_t *data, size_t *data_len, uint8_t tag, + nsm_ethernet_port_counter_data *counter_reading) { if (data == NULL || data_len == NULL || counter_reading == NULL) { return NSM_SW_ERROR_NULL; } - if (*data_len != sizeof(uint32_t)) { - return NSM_SW_ERROR_LENGTH; + switch (tag) { + case ETHERNET_PORT_COUNTER_TAG_RX_BYTES: + case ETHERNET_PORT_COUNTER_TAG_TX_BYTES: + case ETHERNET_PORT_COUNTER_TAG_RX_UNICAST_BYTES: + case ETHERNET_PORT_COUNTER_TAG_RX_MULTICAST_BYTES: + case ETHERNET_PORT_COUNTER_TAG_RX_BROADCAST_BYTES: + case ETHERNET_PORT_COUNTER_TAG_TX_UNICAST_BYTES: + case ETHERNET_PORT_COUNTER_TAG_TX_MULTICAST_BYTES: + case ETHERNET_PORT_COUNTER_TAG_TX_BROADCAST_BYTES: { + if (*data_len != sizeof(uint64_t)) { + return NSM_SW_ERROR_LENGTH; + } + uint64_t le_reading; + memcpy(&le_reading, data, sizeof(uint64_t)); + counter_reading->ethernet_port_counter_data_64bit = + le64toh(le_reading); + break; } - - uint32_t le_reading; - memcpy(&le_reading, data, sizeof(uint32_t)); - *counter_reading = le32toh(le_reading); + case ETHERNET_PORT_COUNTER_TAG_RX_FCS_ERRORS: + case ETHERNET_PORT_COUNTER_TAG_RX_ALIGNMENT_ERRORS: + case ETHERNET_PORT_COUNTER_TAG_RX_FALSE_CARRIER_DETECTIONS: + case ETHERNET_PORT_COUNTER_TAG_RX_RUNT_BYTES: + case ETHERNET_PORT_COUNTER_TAG_RX_JABBER_BYTES: + case ETHERNET_PORT_COUNTER_TAG_RX_XON_FRAMES: + case ETHERNET_PORT_COUNTER_TAG_RX_XOFF_FRAMES: + case ETHERNET_PORT_COUNTER_TAG_TX_XON_FRAMES: + case ETHERNET_PORT_COUNTER_TAG_TX_XOFF_FRAMES: + case ETHERNET_PORT_COUNTER_TAG_RX_SINGLE_COLLISION_FRAMES: + case ETHERNET_PORT_COUNTER_TAG_RX_MULTIPLE_COLLISION_FRAMES: + case ETHERNET_PORT_COUNTER_TAG_RX_LATE_COLLISION_FRAMES: + case ETHERNET_PORT_COUNTER_TAG_RX_EXCESSIVE_COLLISION_FRAMES: { + if (*data_len != sizeof(uint32_t)) { + return NSM_SW_ERROR_LENGTH; + } + uint32_t le_reading32; + memcpy(&le_reading32, data, sizeof(uint32_t)); + counter_reading->ethernet_port_counter_data_32bit = + le32toh(le_reading32); + break; + } + default: + return NSM_SW_ERROR_DATA; + } return NSM_SW_SUCCESS; } -int encode_aggregate_eth_port_telemetry_data(uint32_t *counter_reading, - uint8_t *data, size_t *data_len) +int encode_aggregate_eth_port_telemetry_data( + uint8_t tag, nsm_ethernet_port_counter_data *counter_reading, uint8_t *data, + size_t *data_len) { if (data == NULL || data_len == NULL || counter_reading == NULL) { return NSM_SW_ERROR_NULL; } - if (*data_len < sizeof(uint32_t)) { - return NSM_SW_ERROR_LENGTH; + switch (tag) { + case ETHERNET_PORT_COUNTER_TAG_RX_BYTES: + case ETHERNET_PORT_COUNTER_TAG_TX_BYTES: + case ETHERNET_PORT_COUNTER_TAG_RX_UNICAST_BYTES: + case ETHERNET_PORT_COUNTER_TAG_RX_MULTICAST_BYTES: + case ETHERNET_PORT_COUNTER_TAG_RX_BROADCAST_BYTES: + case ETHERNET_PORT_COUNTER_TAG_TX_UNICAST_BYTES: + case ETHERNET_PORT_COUNTER_TAG_TX_MULTICAST_BYTES: + case ETHERNET_PORT_COUNTER_TAG_TX_BROADCAST_BYTES: { + if (*data_len != sizeof(uint64_t)) { + return NSM_SW_ERROR_LENGTH; + } + uint64_t le_reading = + htole64(counter_reading->ethernet_port_counter_data_64bit); + memcpy(data, &le_reading, sizeof(uint64_t)); + *data_len = sizeof(uint64_t); + break; } - - uint32_t le_reading = htole32(*counter_reading); - memcpy(data, &le_reading, sizeof(uint32_t)); - *data_len = sizeof(uint32_t); + case ETHERNET_PORT_COUNTER_TAG_RX_FCS_ERRORS: + case ETHERNET_PORT_COUNTER_TAG_RX_ALIGNMENT_ERRORS: + case ETHERNET_PORT_COUNTER_TAG_RX_FALSE_CARRIER_DETECTIONS: + case ETHERNET_PORT_COUNTER_TAG_RX_RUNT_BYTES: + case ETHERNET_PORT_COUNTER_TAG_RX_JABBER_BYTES: + case ETHERNET_PORT_COUNTER_TAG_RX_XON_FRAMES: + case ETHERNET_PORT_COUNTER_TAG_RX_XOFF_FRAMES: + case ETHERNET_PORT_COUNTER_TAG_TX_XON_FRAMES: + case ETHERNET_PORT_COUNTER_TAG_TX_XOFF_FRAMES: + case ETHERNET_PORT_COUNTER_TAG_RX_SINGLE_COLLISION_FRAMES: + case ETHERNET_PORT_COUNTER_TAG_RX_MULTIPLE_COLLISION_FRAMES: + case ETHERNET_PORT_COUNTER_TAG_RX_LATE_COLLISION_FRAMES: + case ETHERNET_PORT_COUNTER_TAG_RX_EXCESSIVE_COLLISION_FRAMES: { + if (*data_len != sizeof(uint32_t)) { + return NSM_SW_ERROR_LENGTH; + } + uint32_t le_reading32 = + htole32(counter_reading->ethernet_port_counter_data_32bit); + memcpy(data, &le_reading32, sizeof(uint32_t)); + *data_len = sizeof(uint32_t); + break; + } + default: + return NSM_SW_ERROR_DATA; + } return NSM_SW_SUCCESS; } \ No newline at end of file
diff --git a/libnsm/network-ports.h b/libnsm/network-ports.h index 3db88e1..a66b594 100644 --- a/libnsm/network-ports.h +++ b/libnsm/network-ports.h
@@ -237,6 +237,44 @@ uint64_t intentional_link_down_count; } __attribute__((packed)); +enum ethernet_port_counter_data_tag { + ETHERNET_PORT_COUNTER_TAG_RX_BYTES = 0, + ETHERNET_PORT_COUNTER_TAG_TX_BYTES = 1, + ETHERNET_PORT_COUNTER_TAG_RX_UNICAST_BYTES = 2, + ETHERNET_PORT_COUNTER_TAG_RX_MULTICAST_BYTES = 3, + ETHERNET_PORT_COUNTER_TAG_RX_BROADCAST_BYTES = 4, + ETHERNET_PORT_COUNTER_TAG_TX_UNICAST_BYTES = 5, + ETHERNET_PORT_COUNTER_TAG_TX_MULTICAST_BYTES = 6, + ETHERNET_PORT_COUNTER_TAG_TX_BROADCAST_BYTES = 7, + ETHERNET_PORT_COUNTER_TAG_RX_FCS_ERRORS = 8, + ETHERNET_PORT_COUNTER_TAG_RX_ALIGNMENT_ERRORS = 9, + ETHERNET_PORT_COUNTER_TAG_RX_FALSE_CARRIER_DETECTIONS = 10, + ETHERNET_PORT_COUNTER_TAG_RX_RUNT_BYTES = 11, + ETHERNET_PORT_COUNTER_TAG_RX_JABBER_BYTES = 12, + ETHERNET_PORT_COUNTER_TAG_RX_XON_FRAMES = 13, + ETHERNET_PORT_COUNTER_TAG_RX_XOFF_FRAMES = 14, + ETHERNET_PORT_COUNTER_TAG_TX_XON_FRAMES = 15, + ETHERNET_PORT_COUNTER_TAG_TX_XOFF_FRAMES = 16, + ETHERNET_PORT_COUNTER_TAG_RX_SINGLE_COLLISION_FRAMES = 17, + ETHERNET_PORT_COUNTER_TAG_RX_MULTIPLE_COLLISION_FRAMES = 18, + ETHERNET_PORT_COUNTER_TAG_RX_LATE_COLLISION_FRAMES = 19, + ETHERNET_PORT_COUNTER_TAG_RX_EXCESSIVE_COLLISION_FRAMES = 20, +}; + +typedef union { + uint64_t ethernet_port_counter_data_64bit; + uint32_t ethernet_port_counter_data_32bit; +} nsm_ethernet_port_counter_data; + +/** @struct nsm_get_port_telemetry_counter_req + * + * Structure representing NSM get port telemetry counter request. + */ +struct nsm_get_ethernet_port_telemetry_counter_req { + struct nsm_common_req hdr; + uint16_t port_number; +} __attribute__((packed)); + struct status { uint32_t link_state : 3; uint32_t sub_link_state : 5; @@ -1170,7 +1208,7 @@ * @return nsm_completion_codes */ int encode_get_eth_port_telemetry_counter_req(uint8_t instance_id, - uint8_t port_number, + uint16_t port_number, struct nsm_msg *msg); /** @brief Decode a get Ethernet port telemetry counter request message @@ -1182,7 +1220,7 @@ */ int decode_get_eth_port_telemetry_counter_req(const struct nsm_msg *msg, size_t msg_len, - uint8_t *port_number); + uint16_t *port_number); /** @brief Decode aggregate Ethernet port telemetry data * @@ -1191,9 +1229,9 @@ * @param[out] counter_reading - Decoded counter_reading * @return nsm_completion_codes */ -int decode_aggregate_eth_port_telemetry_data(const uint8_t *data, - size_t *data_len, - uint32_t *counter_reading); +int decode_aggregate_eth_port_telemetry_data( + const uint8_t *data, size_t *data_len, uint8_t tag, + nsm_ethernet_port_counter_data *counter_reading); /** @brief Encode aggregate Ethernet port telemetry data * @@ -1202,8 +1240,9 @@ * @param[out] data_len - Length of data buffer * @return nsm_completion_codes */ -int encode_aggregate_eth_port_telemetry_data(uint32_t *counter_reading, - uint8_t *data, size_t *data_len); +int encode_aggregate_eth_port_telemetry_data( + uint8_t tag, nsm_ethernet_port_counter_data *counter_reading, uint8_t *data, + size_t *data_len); #ifdef __cplusplus }
diff --git a/libnsm/test/libnsm_network_ports_test.cpp b/libnsm/test/libnsm_network_ports_test.cpp index 8d342a8..5324861 100644 --- a/libnsm/test/libnsm_network_ports_test.cpp +++ b/libnsm/test/libnsm_network_ports_test.cpp
@@ -3481,16 +3481,17 @@ TEST(encodeEthPortTelemetryCounterReq, testGoodEncodeRequest) { std::vector<uint8_t> request_msg( - sizeof(nsm_msg_hdr) + sizeof(nsm_get_port_telemetry_counter_req)); + sizeof(nsm_msg_hdr) + + sizeof(nsm_get_ethernet_port_telemetry_counter_req)); - uint8_t port_number = 1; + uint16_t port_number = 1; auto request = reinterpret_cast<nsm_msg *>(request_msg.data()); auto rc = encode_get_eth_port_telemetry_counter_req(0, port_number, request); - nsm_get_port_telemetry_counter_req *req = - reinterpret_cast<nsm_get_port_telemetry_counter_req *>( + struct nsm_get_ethernet_port_telemetry_counter_req *req = + reinterpret_cast<nsm_get_ethernet_port_telemetry_counter_req *>( request->payload); EXPECT_EQ(rc, NSM_SW_SUCCESS); @@ -3522,7 +3523,7 @@ auto request = reinterpret_cast<nsm_msg *>(request_msg.data()); size_t msg_len = request_msg.size(); - uint8_t port_number = 0; + uint16_t port_number = 0; auto rc = decode_get_eth_port_telemetry_counter_req(request, msg_len, &port_number); @@ -3542,9 +3543,9 @@ 1}; auto request = reinterpret_cast<nsm_msg *>(request_msg.data()); - uint8_t port_number = 0; - size_t msg_len = - sizeof(nsm_msg_hdr) + sizeof(nsm_get_port_telemetry_counter_req); + uint16_t port_number = 0; + size_t msg_len = sizeof(nsm_msg_hdr) + + sizeof(nsm_get_ethernet_port_telemetry_counter_req); auto rc = decode_get_eth_port_telemetry_counter_req(nullptr, 0, &port_number); @@ -3564,17 +3565,20 @@ TEST(EncodeAggregateEthPortTelemetryData, TestGoodEncode) { - uint32_t counter_reading = 12345678; + nsm_ethernet_port_counter_data counter_reading{ + .ethernet_port_counter_data_32bit = 12345678}; std::vector<uint8_t> data(sizeof(uint32_t), 0); size_t data_len = data.size(); auto rc = encode_aggregate_eth_port_telemetry_data( - &counter_reading, data.data(), &data_len); + ETHERNET_PORT_COUNTER_TAG_RX_FCS_ERRORS, &counter_reading, + data.data(), &data_len); EXPECT_EQ(rc, NSM_SW_SUCCESS); EXPECT_EQ(data_len, sizeof(uint32_t)); - uint32_t expected_le_reading = htole32(counter_reading); + uint32_t expected_le_reading = + htole32(counter_reading.ethernet_port_counter_data_32bit); uint32_t actual_le_reading; std::memcpy(&actual_le_reading, data.data(), sizeof(uint32_t)); EXPECT_EQ(actual_le_reading, expected_le_reading); @@ -3582,67 +3586,82 @@ TEST(EncodeAggregateEthPortTelemetryData, TestBadEncode) { - uint32_t counter_reading = 12345678; + nsm_ethernet_port_counter_data counter_reading{ + .ethernet_port_counter_data_32bit = 12345678}; std::vector<uint8_t> data(sizeof(uint32_t) - 1, 0); // Intentionally small buffer size_t data_len = data.size(); auto rc = encode_aggregate_eth_port_telemetry_data( - &counter_reading, data.data(), &data_len); + ETHERNET_PORT_COUNTER_TAG_RX_FCS_ERRORS, &counter_reading, + data.data(), &data_len); EXPECT_EQ(rc, NSM_SW_ERROR_LENGTH); - rc = encode_aggregate_eth_port_telemetry_data(nullptr, data.data(), - &data_len); + rc = encode_aggregate_eth_port_telemetry_data( + ETHERNET_PORT_COUNTER_TAG_RX_FCS_ERRORS, nullptr, data.data(), + &data_len); EXPECT_EQ(rc, NSM_SW_ERROR_NULL); - rc = encode_aggregate_eth_port_telemetry_data(&counter_reading, nullptr, - &data_len); + rc = encode_aggregate_eth_port_telemetry_data( + ETHERNET_PORT_COUNTER_TAG_RX_FCS_ERRORS, &counter_reading, nullptr, + &data_len); EXPECT_EQ(rc, NSM_SW_ERROR_NULL); - rc = encode_aggregate_eth_port_telemetry_data(&counter_reading, - data.data(), nullptr); + rc = encode_aggregate_eth_port_telemetry_data( + ETHERNET_PORT_COUNTER_TAG_RX_FCS_ERRORS, &counter_reading, + data.data(), nullptr); EXPECT_EQ(rc, NSM_SW_ERROR_NULL); } TEST(DecodeAggregateEthPortTelemetryData, TestGoodDecode) { - uint32_t counter_reading = 12345678; - uint32_t le_reading = htole32(counter_reading); + nsm_ethernet_port_counter_data counter_reading{ + .ethernet_port_counter_data_32bit = 12345678}; + uint32_t le_reading = + htole32(counter_reading.ethernet_port_counter_data_32bit); std::vector<uint8_t> data(sizeof(uint32_t), 0); std::memcpy(data.data(), &le_reading, sizeof(uint32_t)); size_t data_len = data.size(); - uint32_t decoded_counter_reading = 0; + nsm_ethernet_port_counter_data decoded_counter_reading; auto rc = decode_aggregate_eth_port_telemetry_data( - data.data(), &data_len, &decoded_counter_reading); + data.data(), &data_len, ETHERNET_PORT_COUNTER_TAG_RX_FCS_ERRORS, + &decoded_counter_reading); EXPECT_EQ(rc, NSM_SW_SUCCESS); - EXPECT_EQ(decoded_counter_reading, counter_reading); + EXPECT_EQ(decoded_counter_reading.ethernet_port_counter_data_32bit, + counter_reading.ethernet_port_counter_data_32bit); } TEST(DecodeAggregateEthPortTelemetryData, TestBadDecode) { - uint32_t counter_reading = 12345678; - uint32_t le_reading = htole32(counter_reading); + nsm_ethernet_port_counter_data counter_reading{ + .ethernet_port_counter_data_32bit = 12345678}; + uint32_t le_reading = + htole32(counter_reading.ethernet_port_counter_data_32bit); std::vector<uint8_t> data(sizeof(uint32_t) - 1, 0); // Intentionally small buffer std::memcpy(data.data(), &le_reading, data.size()); size_t data_len = data.size(); - uint32_t decoded_counter_reading = 0; + nsm_ethernet_port_counter_data decoded_counter_reading; auto rc = decode_aggregate_eth_port_telemetry_data( - data.data(), &data_len, &decoded_counter_reading); + data.data(), &data_len, ETHERNET_PORT_COUNTER_TAG_RX_BYTES, + &decoded_counter_reading); EXPECT_EQ(rc, NSM_SW_ERROR_LENGTH); - rc = decode_aggregate_eth_port_telemetry_data(nullptr, &data_len, - &decoded_counter_reading); + rc = decode_aggregate_eth_port_telemetry_data( + nullptr, &data_len, ETHERNET_PORT_COUNTER_TAG_RX_FCS_ERRORS, + &decoded_counter_reading); EXPECT_EQ(rc, NSM_SW_ERROR_NULL); - rc = decode_aggregate_eth_port_telemetry_data(data.data(), nullptr, - &decoded_counter_reading); + rc = decode_aggregate_eth_port_telemetry_data( + data.data(), nullptr, ETHERNET_PORT_COUNTER_TAG_RX_FCS_ERRORS, + &decoded_counter_reading); EXPECT_EQ(rc, NSM_SW_ERROR_NULL); - rc = decode_aggregate_eth_port_telemetry_data(data.data(), &data_len, - nullptr); + rc = decode_aggregate_eth_port_telemetry_data( + data.data(), &data_len, ETHERNET_PORT_COUNTER_TAG_RX_FCS_ERRORS, + nullptr); EXPECT_EQ(rc, NSM_SW_ERROR_NULL); } \ No newline at end of file
diff --git a/mockupResponder/mockupResponder.cpp b/mockupResponder/mockupResponder.cpp index a15a8f5..9773375 100644 --- a/mockupResponder/mockupResponder.cpp +++ b/mockupResponder/mockupResponder.cpp
@@ -6285,7 +6285,7 @@ "LEN", requestLen); } - uint8_t portNumber = 0; + uint16_t portNumber = 0; auto rc = decode_get_eth_port_telemetry_counter_req(requestMsg, requestLen, &portNumber); if (rc != NSM_SW_SUCCESS) @@ -6295,35 +6295,97 @@ return std::nullopt; } - std::vector<uint8_t> response( + const size_t maxResponseSize = + ETH_PORT_TELEMETRY_COUNTER_ENABLED_COUNT * sizeof(uint64_t) + + sizeof(nsm_msg_hdr) + sizeof(nsm_aggregate_resp); + static std::vector<uint8_t> ethPortTelemetryCounterResponse( sizeof(nsm_msg_hdr) + sizeof(nsm_aggregate_resp), 0); - response.reserve(256); + ethPortTelemetryCounterResponse.reserve(maxResponseSize); + ethPortTelemetryCounterResponse.clear(); + if (((ethPortTelemetryCounterResponse.capacity() - sizeof(nsm_msg_hdr) - + sizeof(nsm_aggregate_resp)) > + ETH_PORT_TELEMETRY_COUNTER_ENABLED_COUNT * sizeof(uint64_t))) + { + lg2::error( + "Response capacity more than maximum aggregate response size"); + return std::nullopt; + } uint16_t samplesCount = 0; for (uint8_t tag = 0; tag < ETH_PORT_TELEMETRY_COUNTER_ENABLED_COUNT; ++tag) { ++samplesCount; - uint32_t mockValue = tag * 10; // Mock value for each counter - uint8_t reading[sizeof(uint32_t)] = {}; - size_t sample_len = sizeof(reading); - - rc = encode_aggregate_eth_port_telemetry_data(&mockValue, reading, - &sample_len); - if (rc != NSM_SW_SUCCESS) - { - lg2::error( - "encode_aggregate_eth_port_telemetry_data failed: rc={RC}", - "RC", rc); - return std::nullopt; - } - std::array<uint8_t, 256> sample; auto nsm_sample = reinterpret_cast<nsm_aggregate_resp_sample*>(sample.data()); + size_t sample_len = 0; - rc = encode_aggregate_resp_sample(tag, true, reading, sample_len, - nsm_sample, &sample_len); + switch (tag) + { + case ETHERNET_PORT_COUNTER_TAG_RX_BYTES: + case ETHERNET_PORT_COUNTER_TAG_TX_BYTES: + case ETHERNET_PORT_COUNTER_TAG_RX_UNICAST_BYTES: + case ETHERNET_PORT_COUNTER_TAG_RX_MULTICAST_BYTES: + case ETHERNET_PORT_COUNTER_TAG_RX_BROADCAST_BYTES: + case ETHERNET_PORT_COUNTER_TAG_TX_UNICAST_BYTES: + case ETHERNET_PORT_COUNTER_TAG_TX_MULTICAST_BYTES: + case ETHERNET_PORT_COUNTER_TAG_TX_BROADCAST_BYTES: + { + nsm_ethernet_port_counter_data mockValue{ + .ethernet_port_counter_data_64bit = static_cast<uint64_t>( + 2000000 + tag * 10)}; // Mock value for 64 bit counter + uint8_t reading[sizeof(uint64_t)] = {}; + sample_len = sizeof(reading); + + rc = encode_aggregate_eth_port_telemetry_data( + tag, &mockValue, reading, &sample_len); + if (rc != NSM_SW_SUCCESS) + { + lg2::error( + "encode_aggregate_eth_port_telemetry_data failed: rc={RC}", + "RC", rc); + return std::nullopt; + } + rc = encode_aggregate_resp_sample( + tag, true, reading, sample_len, nsm_sample, &sample_len); + break; + } + case ETHERNET_PORT_COUNTER_TAG_RX_FCS_ERRORS: + case ETHERNET_PORT_COUNTER_TAG_RX_ALIGNMENT_ERRORS: + case ETHERNET_PORT_COUNTER_TAG_RX_FALSE_CARRIER_DETECTIONS: + case ETHERNET_PORT_COUNTER_TAG_RX_RUNT_BYTES: + case ETHERNET_PORT_COUNTER_TAG_RX_JABBER_BYTES: + case ETHERNET_PORT_COUNTER_TAG_RX_XON_FRAMES: + case ETHERNET_PORT_COUNTER_TAG_RX_XOFF_FRAMES: + case ETHERNET_PORT_COUNTER_TAG_TX_XON_FRAMES: + case ETHERNET_PORT_COUNTER_TAG_TX_XOFF_FRAMES: + case ETHERNET_PORT_COUNTER_TAG_RX_SINGLE_COLLISION_FRAMES: + case ETHERNET_PORT_COUNTER_TAG_RX_MULTIPLE_COLLISION_FRAMES: + case ETHERNET_PORT_COUNTER_TAG_RX_LATE_COLLISION_FRAMES: + case ETHERNET_PORT_COUNTER_TAG_RX_EXCESSIVE_COLLISION_FRAMES: + { + nsm_ethernet_port_counter_data mockValue{ + .ethernet_port_counter_data_32bit = static_cast<uint32_t>( + 2000000 + tag * 10)}; // Mock value for 32 bit counter + uint8_t reading[sizeof(uint32_t)] = {}; + sample_len = sizeof(reading); + + rc = encode_aggregate_eth_port_telemetry_data( + tag, &mockValue, reading, &sample_len); + if (rc != NSM_SW_SUCCESS) + { + lg2::error( + "encode_aggregate_eth_port_telemetry_data failed: rc={RC}", + "RC", rc); + return std::nullopt; + } + rc = encode_aggregate_resp_sample( + tag, true, reading, sample_len, nsm_sample, &sample_len); + break; + } + } + if (rc != NSM_SW_SUCCESS) { lg2::error("encode_aggregate_resp_sample failed: rc={RC}", "RC", @@ -6331,11 +6393,23 @@ return std::nullopt; } - response.insert(response.end(), sample.begin(), - std::next(sample.begin(), sample_len)); + if ((ethPortTelemetryCounterResponse.size() + sample_len) <= + ethPortTelemetryCounterResponse.capacity()) + { + ethPortTelemetryCounterResponse.insert( + ethPortTelemetryCounterResponse.end(), sample.begin(), + std::next(sample.begin(), sample_len)); + } + else + { + lg2::debug( + "Not enough capacity in ethPortTelemetryCounterResponse to insert sample"); + return std::nullopt; + } } - auto responseMsg = reinterpret_cast<nsm_msg*>(response.data()); + auto responseMsg = + reinterpret_cast<nsm_msg*>(ethPortTelemetryCounterResponse.data()); rc = encode_aggregate_resp(requestMsg->hdr.instance_id, NSM_GET_ETH_PORT_TELEMETRY_COUNTER, NSM_SUCCESS, samplesCount, responseMsg); @@ -6345,7 +6419,7 @@ return std::nullopt; } - return response; + return ethPortTelemetryCounterResponse; } } // namespace MockupResponder
diff --git a/nsmd/nsmPort/nsmPort.cpp b/nsmd/nsmPort/nsmPort.cpp index ea9e838..3ae4add 100644 --- a/nsmd/nsmPort/nsmPort.cpp +++ b/nsmd/nsmPort/nsmPort.cpp
@@ -1111,15 +1111,37 @@ } EthPortTelemetryAggregator::EthPortTelemetryAggregator( - sdbusplus::bus::bus& bus, std::string& portName, const std::string& type, - std::string& inventoryObjPath, + sdbusplus::bus::bus& bus, std::string& portName, uint16_t portNumber, + const std::string& type, std::string& inventoryObjPath, std::shared_ptr<PortMetricsOem2Intf> portMetricsOem2Intf, std::shared_ptr<PortPacketCountersIntf> portPacketCountersIntf) : NsmSensorAggregator(portName, type), - portName(portName), objPath(inventoryObjPath), + portName(portName), portNumber(portNumber), objPath(inventoryObjPath), portMetricsOem2Intf(portMetricsOem2Intf), portPacketCountersIntf(portPacketCountersIntf), - tagToPropertyMap(initPropertyTagToNameMap()) + tagToPropertyMap({ + {0, "RXBytes"}, // Total Bytes Received + {1, "TXBytes"}, // Total Bytes Transmitted + {2, "RXUnicastPkts"}, // Total Unicast Packets Received + {3, "RXMulticastPkts"}, // Total Multicast Packets Received + {4, "RXBroadcastPkts"}, // Total Broadcast Packets Received + {5, "TXUnicastPkts"}, // Total Unicast Packets Transmitted + {6, "TXMulticastPkts"}, // Total Multicast Packets Transmitted + {7, "TXBroadcastPkts"}, // Total Broadcast Packets Transmitted + {8, "RXFCSErrors"}, // FCS Receive Errors + {9, "RXAlignmentErrors"}, // Alignment Errors + {10, "RXFalseCarrierDetections"}, // False Carrier Detections + {11, "RXRuntPkts"}, // Runt Packets Received + {12, "RXJabberPkts"}, // Jabber Packets Received + {13, "RXXONFrames"}, // Pause XON Frames Received + {14, "RXXOFFFrames"}, // Pause XOFF Frames Received + {15, "TXXONFrames"}, // Pause XON Frames Transmitted + {16, "TXXOFFFrames"}, // Pause XOFF Frames Transmitted + {17, "TXSingleCollisionFrames"}, // Single Collision Transmit Frames + {18, "TXMultipleCollisionFrames"}, // Multiple Collision Transmit Frames + {19, "TXLateCollisionFrames"}, // Late Collision Frames + {20, "TXExcessCollisionFrames"}, // Excessive Collision Frames + }) { lg2::debug("EthPortTelemetryAggregator: {NAME}", "NAME", portName.c_str()); @@ -1131,8 +1153,9 @@ std::optional<std::vector<uint8_t>> EthPortTelemetryAggregator::genRequestMsg(eid_t eid, uint8_t instanceId) { - std::vector<uint8_t> request(sizeof(nsm_msg_hdr) + - sizeof(nsm_get_port_telemetry_counter_req)); + std::vector<uint8_t> request( + sizeof(nsm_msg_hdr) + + sizeof(nsm_get_ethernet_port_telemetry_counter_req)); auto requestPtr = reinterpret_cast<struct nsm_msg*>(request.data()); // Use the eth port telemetry counter command @@ -1166,22 +1189,22 @@ continue; } - uint32_t counterValue = 0; + nsm_ethernet_port_counter_data counterValue = {}; size_t dataLen = sample.data_len; - int rc = decode_aggregate_eth_port_telemetry_data(sample.data, &dataLen, - &counterValue); + int rc = decode_aggregate_eth_port_telemetry_data( + sample.data, &dataLen, sample.tag, &counterValue); if (rc != NSM_SW_SUCCESS) { - lg2::error( + lg2::debug( "Failed to decode Ethernet port telemetry data for tag {TAG} : rc = {RC}", "TAG", sample.tag, "RC", rc); result = false; continue; } - updateCounterValues(sample.tag, counterValue); + updateCounterValues(sample.tag, &counterValue); } updateMetricOnSharedMemory(); @@ -1189,8 +1212,8 @@ return result; } -void EthPortTelemetryAggregator::updateCounterValues(uint8_t tag, - uint32_t counterValue) +void EthPortTelemetryAggregator::updateCounterValues( + uint8_t tag, nsm_ethernet_port_counter_data* counterValue) { auto it = tagToPropertyMap.find(tag); if (it != tagToPropertyMap.end()) @@ -1200,159 +1223,186 @@ try { if (propName == "RXBytes") - portMetricsOem2Intf->rxBytes(counterValue); + portMetricsOem2Intf->rxBytes( + counterValue->ethernet_port_counter_data_64bit); else if (propName == "TXBytes") - portMetricsOem2Intf->txBytes(counterValue); + portMetricsOem2Intf->txBytes( + counterValue->ethernet_port_counter_data_64bit); else if (propName == "RXUnicastPkts") - portPacketCountersIntf->rxUnicastPkts(counterValue); + portPacketCountersIntf->rxUnicastPkts( + counterValue->ethernet_port_counter_data_64bit); else if (propName == "RXMulticastPkts") - portPacketCountersIntf->rxMulticastPkts(counterValue); + portPacketCountersIntf->rxMulticastPkts( + counterValue->ethernet_port_counter_data_64bit); else if (propName == "RXBroadcastPkts") - portPacketCountersIntf->rxBroadcastPkts(counterValue); + portPacketCountersIntf->rxBroadcastPkts( + counterValue->ethernet_port_counter_data_64bit); else if (propName == "TXUnicastPkts") - portPacketCountersIntf->txUnicastPkts(counterValue); + portPacketCountersIntf->txUnicastPkts( + counterValue->ethernet_port_counter_data_64bit); else if (propName == "TXMulticastPkts") - portPacketCountersIntf->txMulticastPkts(counterValue); + portPacketCountersIntf->txMulticastPkts( + counterValue->ethernet_port_counter_data_64bit); else if (propName == "TXBroadcastPkts") - portPacketCountersIntf->txBroadcastPkts(counterValue); + portPacketCountersIntf->txBroadcastPkts( + counterValue->ethernet_port_counter_data_64bit); else if (propName == "RXFCSErrors") - ethPortIntf->rxfcsErrors(counterValue); + ethPortIntf->rxfcsErrors( + counterValue->ethernet_port_counter_data_32bit); else if (propName == "RXAlignmentErrors") - ethPortIntf->rxAlignmentErrors(counterValue); + ethPortIntf->rxAlignmentErrors( + counterValue->ethernet_port_counter_data_32bit); else if (propName == "RXFalseCarrierDetections") - ethPortIntf->rxFalseCarrierDetections(counterValue); + ethPortIntf->rxFalseCarrierDetections( + counterValue->ethernet_port_counter_data_32bit); else if (propName == "RXRuntPkts") - ethPortIntf->rxRuntPkts(counterValue); + ethPortIntf->rxRuntPkts( + counterValue->ethernet_port_counter_data_32bit); else if (propName == "RXJabberPkts") - ethPortIntf->rxJabberPkts(counterValue); + ethPortIntf->rxJabberPkts( + counterValue->ethernet_port_counter_data_32bit); else if (propName == "RXXONFrames") - ethPortIntf->rxxonFrames(counterValue); + ethPortIntf->rxxonFrames( + counterValue->ethernet_port_counter_data_32bit); else if (propName == "RXXOFFFrames") - ethPortIntf->rxxoffFrames(counterValue); + ethPortIntf->rxxoffFrames( + counterValue->ethernet_port_counter_data_32bit); else if (propName == "TXXONFrames") - ethPortIntf->txxonFrames(counterValue); + ethPortIntf->txxonFrames( + counterValue->ethernet_port_counter_data_32bit); else if (propName == "TXXOFFFrames") - ethPortIntf->txxoffFrames(counterValue); + ethPortIntf->txxoffFrames( + counterValue->ethernet_port_counter_data_32bit); else if (propName == "TXSingleCollisionFrames") - ethPortIntf->txSingleCollisionFrames(counterValue); + ethPortIntf->txSingleCollisionFrames( + counterValue->ethernet_port_counter_data_32bit); else if (propName == "TXMultipleCollisionFrames") - ethPortIntf->txMultipleCollisionFrames(counterValue); + ethPortIntf->txMultipleCollisionFrames( + counterValue->ethernet_port_counter_data_32bit); else if (propName == "TXLateCollisionFrames") - ethPortIntf->txLateCollisionFrames(counterValue); - else if (propName == "TXExcessiveCollisionFrames") - ethPortIntf->txExcessCollisionFrames(counterValue); + ethPortIntf->txLateCollisionFrames( + counterValue->ethernet_port_counter_data_32bit); + else if (propName == "TXExcessCollisionFrames") + ethPortIntf->txExcessCollisionFrames( + counterValue->ethernet_port_counter_data_32bit); } catch (const std::exception& e) { + lg2::error( + "Failed to update property {PROP} with value {VALUE}: {ERR}", + "PROP", propName, "VALUE", counterValue, "ERR", e.what()); return; } } } -void EthPortTelemetryAggregator::getCounterValue(const std::string propName, - uint32_t& value, - std::string& ifaceName) +void EthPortTelemetryAggregator::getCounterValue( + const std::string propName, nsm_ethernet_port_counter_data& value, + std::string& ifaceName) { - try + if (propName == "RXBytes") { - if (propName == "RXBytes") - { - value = portMetricsOem2Intf->rxBytes(); - ifaceName = std::string(portMetricsOem2Intf->interface); - } - else if (propName == "TXBytes") - { - value = portMetricsOem2Intf->txBytes(); - ifaceName = std::string(portMetricsOem2Intf->interface); - } - else if (propName == "RXUnicastPkts") - { - value = portPacketCountersIntf->rxUnicastPkts(); - ifaceName = std::string(portPacketCountersIntf->interface); - } - else if (propName == "RXMulticastPkts") - { - value = portPacketCountersIntf->rxMulticastPkts(); - ifaceName = std::string(portPacketCountersIntf->interface); - } - else if (propName == "RXBroadcastPkts") - { - value = portPacketCountersIntf->rxBroadcastPkts(); - ifaceName = std::string(portPacketCountersIntf->interface); - } - else if (propName == "TXUnicastPkts") - { - value = portPacketCountersIntf->txUnicastPkts(); - ifaceName = std::string(portPacketCountersIntf->interface); - } - else if (propName == "TXMulticastPkts") - { - value = portPacketCountersIntf->txMulticastPkts(); - ifaceName = std::string(portPacketCountersIntf->interface); - } - else if (propName == "TXBroadcastPkts") - { - value = portPacketCountersIntf->txBroadcastPkts(); - ifaceName = std::string(portPacketCountersIntf->interface); - } - else if (propName == "RXFCSErrors") - { - value = ethPortIntf->rxfcsErrors(); - } - else if (propName == "RXAlignmentErrors") - { - value = ethPortIntf->rxAlignmentErrors(); - } - else if (propName == "RXFalseCarrierDetections") - { - value = ethPortIntf->rxFalseCarrierDetections(); - } - else if (propName == "RXRuntPkts") - { - value = ethPortIntf->rxRuntPkts(); - } - else if (propName == "RXJabberPkts") - { - value = ethPortIntf->rxJabberPkts(); - } - else if (propName == "RXXONFrames") - { - value = ethPortIntf->rxxonFrames(); - } - else if (propName == "RXXOFFFrames") - { - value = ethPortIntf->rxxoffFrames(); - } - else if (propName == "TXXONFrames") - { - value = ethPortIntf->txxonFrames(); - } - else if (propName == "TXXOFFFrames") - { - value = ethPortIntf->txxoffFrames(); - } - else if (propName == "TXSingleCollisionFrames") - { - value = ethPortIntf->txSingleCollisionFrames(); - } - else if (propName == "TXMultipleCollisionFrames") - { - value = ethPortIntf->txMultipleCollisionFrames(); - } - else if (propName == "TXLateCollisionFrames") - { - value = ethPortIntf->txLateCollisionFrames(); - } - else if (propName == "TXExcessiveCollisionFrames") - { - value = ethPortIntf->txExcessCollisionFrames(); - } + value.ethernet_port_counter_data_64bit = portMetricsOem2Intf->rxBytes(); + ifaceName = std::string(portMetricsOem2Intf->interface); } - catch (const std::exception& e) + else if (propName == "TXBytes") { - lg2::error("Failed to get counter value for property {PROP}: {ERR}", - "PROP", propName, "ERR", e.what()); - return; + value.ethernet_port_counter_data_64bit = portMetricsOem2Intf->txBytes(); + ifaceName = std::string(portMetricsOem2Intf->interface); + } + else if (propName == "RXUnicastPkts") + { + value.ethernet_port_counter_data_64bit = + portPacketCountersIntf->rxUnicastPkts(); + ifaceName = std::string(portPacketCountersIntf->interface); + } + else if (propName == "RXMulticastPkts") + { + value.ethernet_port_counter_data_64bit = + portPacketCountersIntf->rxMulticastPkts(); + ifaceName = std::string(portPacketCountersIntf->interface); + } + else if (propName == "RXBroadcastPkts") + { + value.ethernet_port_counter_data_64bit = + portPacketCountersIntf->rxBroadcastPkts(); + ifaceName = std::string(portPacketCountersIntf->interface); + } + else if (propName == "TXUnicastPkts") + { + value.ethernet_port_counter_data_64bit = + portPacketCountersIntf->txUnicastPkts(); + ifaceName = std::string(portPacketCountersIntf->interface); + } + else if (propName == "TXMulticastPkts") + { + value.ethernet_port_counter_data_64bit = + portPacketCountersIntf->txMulticastPkts(); + ifaceName = std::string(portPacketCountersIntf->interface); + } + else if (propName == "TXBroadcastPkts") + { + value.ethernet_port_counter_data_64bit = + portPacketCountersIntf->txBroadcastPkts(); + ifaceName = std::string(portPacketCountersIntf->interface); + } + else if (propName == "RXFCSErrors") + { + value.ethernet_port_counter_data_32bit = ethPortIntf->rxfcsErrors(); + } + else if (propName == "RXAlignmentErrors") + { + value.ethernet_port_counter_data_32bit = + ethPortIntf->rxAlignmentErrors(); + } + else if (propName == "RXFalseCarrierDetections") + { + value.ethernet_port_counter_data_32bit = + ethPortIntf->rxFalseCarrierDetections(); + } + else if (propName == "RXRuntPkts") + { + value.ethernet_port_counter_data_32bit = ethPortIntf->rxRuntPkts(); + } + else if (propName == "RXJabberPkts") + { + value.ethernet_port_counter_data_32bit = ethPortIntf->rxJabberPkts(); + } + else if (propName == "RXXONFrames") + { + value.ethernet_port_counter_data_32bit = ethPortIntf->rxxonFrames(); + } + else if (propName == "RXXOFFFrames") + { + value.ethernet_port_counter_data_32bit = ethPortIntf->rxxoffFrames(); + } + else if (propName == "TXXONFrames") + { + value.ethernet_port_counter_data_32bit = ethPortIntf->txxonFrames(); + } + else if (propName == "TXXOFFFrames") + { + value.ethernet_port_counter_data_32bit = ethPortIntf->txxoffFrames(); + } + else if (propName == "TXSingleCollisionFrames") + { + value.ethernet_port_counter_data_32bit = + ethPortIntf->txSingleCollisionFrames(); + } + else if (propName == "TXMultipleCollisionFrames") + { + value.ethernet_port_counter_data_32bit = + ethPortIntf->txMultipleCollisionFrames(); + } + else if (propName == "TXLateCollisionFrames") + { + value.ethernet_port_counter_data_32bit = + ethPortIntf->txLateCollisionFrames(); + } + else if (propName == "TXExcessCollisionFrames") + { + value.ethernet_port_counter_data_32bit = + ethPortIntf->txExcessCollisionFrames(); } } @@ -1363,49 +1413,19 @@ for (const auto& [tag, propName] : tagToPropertyMap) { - uint32_t value = 0; + nsm_ethernet_port_counter_data value = {}; std::string ifaceName = std::string(ethPortIntf->interface); getCounterValue(propName, value, ifaceName); - nv::sensor_aggregation::DbusVariantType dbusValue{value}; + nv::sensor_aggregation::DbusVariantType dbusValue{ + value.ethernet_port_counter_data_64bit}; nsm_shmem_utils::updateSharedMemoryOnSuccess( objPath, ifaceName, propName, smbusData, dbusValue); } #endif } -std::unordered_map<uint8_t, std::string> - EthPortTelemetryAggregator::initPropertyTagToNameMap() -{ - std::unordered_map<uint8_t, std::string> map; - - // Map each tag to its corresponding property name - map[0] = "RXBytes"; // Total Bytes Received - map[1] = "TXBytes"; // Total Bytes Transmitted - map[2] = "RXUnicastPkts"; // Total Unicast Packets Received - map[3] = "RXMulticastPkts"; // Total Multicast Packets Received - map[4] = "RXBroadcastPkts"; // Total Broadcast Packets Received - map[5] = "TXUnicastPkts"; // Total Unicast Packets Transmitted - map[6] = "TXMulticastPkts"; // Total Multicast Packets Transmitted - map[7] = "TXBroadcastPkts"; // Total Broadcast Packets Transmitted - map[8] = "RXFCSErrors"; // FCS Receive Errors - map[9] = "RXAlignmentErrors"; // Alignment Errors - map[10] = "RXFalseCarrierDetections"; // False Carrier Detections - map[11] = "RXRuntPkts"; // Runt Packets Received - map[12] = "RXJabberPkts"; // Jabber Packets Received - map[13] = "RXXONFrames"; // Pause XON Frames Received - map[14] = "RXXOFFFrames"; // Pause XOFF Frames Received - map[15] = "TXXONFrames"; // Pause XON Frames Transmitted - map[16] = "TXXOFFFrames"; // Pause XOFF Frames Transmitted - map[17] = "TXSingleCollisionFrames"; // Single Collision Transmit Frames - map[18] = "TXMultipleCollisionFrames"; // Multiple Collision Transmit Frames - map[19] = "TXLateCollisionFrames"; // Late Collision Frames - map[20] = "TXExcessiveCollisionFrames"; // Excessive Collision Frames - - return map; -} - static requester::Coroutine createNsmPortSensor(SensorManager& manager, const std::string& interface, const std::string& objPath) @@ -1545,18 +1565,14 @@ } } - auto ethPortMetricsSensor = - std::make_shared<EthPortTelemetryAggregator>( - bus, portName, type, objPath, portMetricsOem2Intf, - portPacketCountersIntf); - nsmDevice->deviceSensors.emplace_back(ethPortMetricsSensor); - if (priority) + if (nsmDevice->getDeviceType() == NSM_DEV_ID_PCIE_BRIDGE && + nsmDevice->getDeviceRole() == NSM_PCIE_BRIDGE_DEV_ROLE_CX8) { - nsmDevice->prioritySensors.emplace_back(ethPortMetricsSensor); - } - else - { - nsmDevice->roundRobinSensors.emplace_back(ethPortMetricsSensor); + auto ethPortMetricsSensor = + std::make_shared<EthPortTelemetryAggregator>( + bus, portName, static_cast<uint16_t>(logicalPortNum), type, + objPath, portMetricsOem2Intf, portPacketCountersIntf); + nsmDevice->addSensor(ethPortMetricsSensor, priority); } manager.deviceToPortMap[nsmDevice][logicalPortNum] = portName;
diff --git a/nsmd/nsmPort/nsmPort.hpp b/nsmd/nsmPort/nsmPort.hpp index 1fce5b9..fc58957 100644 --- a/nsmd/nsmPort/nsmPort.hpp +++ b/nsmd/nsmPort/nsmPort.hpp
@@ -146,7 +146,7 @@ { public: EthPortTelemetryAggregator( - sdbusplus::bus::bus& bus, std::string& portName, + sdbusplus::bus::bus& bus, std::string& portName, uint16_t portNumber, const std::string& type, std::string& inventoryObjPath, std::shared_ptr<PortMetricsOem2Intf> portMetricsOem2Intf, std::shared_ptr<PortPacketCountersIntf> portPacketCountersIntf); @@ -161,18 +161,18 @@ std::string portName; private: - void updateCounterValues(uint8_t tag, uint32_t counterValue); - void getCounterValue(const std::string propName, uint32_t& value, + void updateCounterValues(uint8_t tag, + nsm_ethernet_port_counter_data* counterValue); + void getCounterValue(const std::string propName, + nsm_ethernet_port_counter_data& value, std::string& ifaceName); - uint8_t portNumber; + uint16_t portNumber; std::string objPath; std::shared_ptr<PortMetricsOem2Intf> portMetricsOem2Intf = nullptr; std::shared_ptr<PortPacketCountersIntf> portPacketCountersIntf = nullptr; std::unique_ptr<EthPortIntf> ethPortIntf = nullptr; std::unordered_map<uint8_t, std::string> tagToPropertyMap; - - static std::unordered_map<uint8_t, std::string> initPropertyTagToNameMap(); }; } // namespace nsm
diff --git a/nsmtool/nsm_telemetry_cmd.cpp b/nsmtool/nsm_telemetry_cmd.cpp index 6d12b7b..1aae060 100644 --- a/nsmtool/nsm_telemetry_cmd.cpp +++ b/nsmtool/nsm_telemetry_cmd.cpp
@@ -4788,7 +4788,8 @@ std::pair<int, std::vector<uint8_t>> createRequestMsg() override { std::vector<uint8_t> requestMsg( - sizeof(nsm_msg_hdr) + sizeof(nsm_get_port_telemetry_counter_req)); + sizeof(nsm_msg_hdr) + + sizeof(nsm_get_ethernet_port_telemetry_counter_req)); auto request = reinterpret_cast<nsm_msg*>(requestMsg.data()); auto rc = encode_get_eth_port_telemetry_counter_req( instanceId, portNumber, request); @@ -4809,19 +4810,20 @@ int handleSampleData(uint8_t tag, const uint8_t* data, size_t data_len, ordered_json& sample_json) final { - uint32_t counter_reading; - int rc = decode_aggregate_eth_port_telemetry_data(data, &data_len, - &counter_reading); + nsm_ethernet_port_counter_data counter_reading; + int rc = decode_aggregate_eth_port_telemetry_data( + data, &data_len, tag, &counter_reading); if (rc != NSM_SW_SUCCESS) { return rc; } - sample_json[ethPortTelemetryCounterList[tag]] = counter_reading; + sample_json[ethPortTelemetryCounterList[tag]] = + counter_reading.ethernet_port_counter_data_64bit; return NSM_SW_SUCCESS; } }; - uint8_t portNumber; + uint16_t portNumber; static constexpr const char* ethPortTelemetryCounterList[21] = { "RXBytes", // 0 "TXBytes", // 1