../plugins/ocp/ocp-telemetry-decode.c

Bug Summary

File:	.build-ci/../plugins/ocp/ocp-telemetry-decode.c
Warning:	line 1325, column 3 Potential leak of memory pointed to by 'description'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-redhat-linux-gnu -O3 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name ocp-telemetry-decode.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/__w/nvme-cli/nvme-cli/.build-ci -fcoverage-compilation-dir=/__w/nvme-cli/nvme-cli/.build-ci -resource-dir /usr/bin/../lib/clang/22 -include /__w/nvme-cli/nvme-cli/.build-ci/nvme-config.h -I nvme.p -I . -I .. -I src -I ../src -I ccan -I ../ccan -I libnvme/src -I ../libnvme/src -I /usr/include/json-c -D _FILE_OFFSET_BITS=64 -D _GNU_SOURCE -U NDEBUG -internal-isystem /usr/bin/../lib/clang/22/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/16/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -std=gnu11 -ferror-limit 19 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-opt-analyze-headers -analyzer-output=html -faddrsig -fdwarf2-cfi-asm -o /__w/nvme-cli/nvme-cli/.build-ci/scan-results/2026-10-24-125112-639-1 -x c ../plugins/ocp/ocp-telemetry-decode.c
1// SPDX-License-Identifier: GPL-2.0-or-later
2/* Copyright (c) 2024 Western Digital Corporation or its affiliates.
*
* Authors: Jeff Lien <jeff.lien@wdc.com>,
*/
6#include <libnvme.h>

8#include <ccan/array_size/array_size.h>
9#include <ccan/endian/endian.h>
10#include <shared/hex-util.h>
11#include <shared/string-util.h>

13#include "nvme-print.h"
14#include "ocp-telemetry-decode.h"

16struct statistic_entry statistic_identifiers_map[] = {
{ 0x00, "Error, this entry does not exist." },
{ 0x01, "Outstanding Admin Commands" },
{ 0x02, "Host Write Bandwidth"},
{ 0x03, "GC Write Bandwidth"},
{ 0x04, "Active Namespaces"},
{ 0x05, "Internal Write Workload"},
{ 0x06, "Internal Read Workload"},
{ 0x07, "Internal Write Queue Depth"},
{ 0x08, "Internal Read Queue Depth"},
{ 0x09, "Pending Trim LBA Count"},
{ 0x0A, "Host Trim LBA Request Count"},
{ 0x0B, "Current NVMe Power State"},
{ 0x0C, "Current DSSD Power State"},
{ 0x0D, "Program Fail Count"},
{ 0x0E, "Erase Fail Count"},
{ 0x0F, "Read Disturb Writes"},
{ 0x10, "Retention Writes"},
{ 0x11, "Wear Leveling Writes"},
{ 0x12, "Read Recovery Writes"},
{ 0x13, "GC Writes"},
{ 0x14, "SRAM Correctable Count"},
{ 0x15, "DRAM Correctable Count"},
{ 0x16, "SRAM Uncorrectable Count"},
{ 0x17, "DRAM Uncorrectable Count"},
{ 0x18, "Data Integrity Error Count"},
{ 0x19, "Read Retry Error Count"},
{ 0x1A, "PERST Events Count"},
{ 0x1B, "Max Die Bad Block"},
{ 0x1C, "Max NAND Channel Bad Block"},
{ 0x1D, "Minimum NAND Channel Bad Block"},
{ 0x1E, "Physical Media Units Written"},
{ 0x1F, "Physical Media Units Read"},
{ 0x20, "Bad User NAND Blocks"},
{ 0x21, "Bad System NAND Blocks"},
{ 0x22, "XOR Recovery Count"},
{ 0x23, "Uncorrectable Read Error Count"},
{ 0x24, "Soft ECC Error Count"},
{ 0x25, "End to End Correction Counts"},
{ 0x26, "System Data % Used"},
{ 0x27, "Refresh Counts"},
{ 0x28, "User Data Erase Counts"},
{ 0x29, "Thermal Throttling Status and Count"},
{ 0x2A, "DSSD Specification Version"},
{ 0x2B, "PCIe Correctable Error Count"},
{ 0x2C, "Incomplete Shutdowns"},
{ 0x2D, "% Free Blocks"},
{ 0x2E, "Capacitor Health"},
{ 0x2F, "NVM Express Base Errata Version"},
{ 0x30, "NVM Command Set Errata Version"},
{ 0x31, "NVM Express Management Interface Errata Version"},
{ 0x32, "Unaligned I/O"},
{ 0x33, "Security Version Number"},
{ 0x34, "Total NUSE"},
{ 0x35, "PLP Start Count"},
{ 0x36, "Endurance Estimate"},
{ 0x37, "PCIe Link Retraining Count"},
{ 0x38, "Power State Change Count"},
{ 0x39, "Lowest Permitted Firmware Revision"},
{ 0x3A, "Log Page Version"},
{ 0x3B, "Media Dies Offline"},
{ 0x3C, "Max Temperature Recorded"},
{ 0x3D, "NAND Avg. Erase Count"},
{ 0x3E, "Command Timeouts"},
{ 0x3F, "System Area Program Fail Count"},
{ 0x40, "System Area Read Fail Count"},
{ 0x41, "System Area Erase Fail Count"},
{ 0x42, "Max Peak Power Capability"},
{ 0x43, "Current Average Power"},
{ 0x44, "Lifetime Power Consumed"},
{ 0x45, "Error / Assert Count"},
{ 0x46, "Device Busy Time"},
{ 0x47, "Critical Warning"},
{ 0x48, "Composite Temperature"},
{ 0x49, "Available Spare"},
{ 0x4A, "Available Spare Threshold"},
{ 0x4B, "Percentage Used"},
{ 0x4C, "Endurance Group Critical Warning Summary"},
{ 0x4D, "Data Units Read"},
{ 0x4E, "Data Units Written"},
{ 0x4F, "Host Read Commands"},
{ 0x50, "Host Write Commands"},
{ 0x51, "Controller Busy Time"},
{ 0x52, "Power Cycles"},
{ 0x53, "Power On Hours"},
{ 0x54, "Unsafe Shutdowns"},
{ 0x55, "Media and Data Integrity Errors"},
{ 0x56, "Number of Error Information Log Entries"},
{ 0x57, "Warning Composite Temperature Time"},
{ 0x58, "Critical Composite Temperature Time"},
{ 0x59, "Temperature Sensor 1"},
{ 0x5A, "Temperature Sensor 2"},
{ 0x5B, "Temperature Sensor 3"},
{ 0x5C, "Temperature Sensor 4"},
{ 0x5D, "Temperature Sensor 5"},
{ 0x5E, "Temperature Sensor 6"},
{ 0x5F, "Temperature Sensor 7"},
{ 0x60, "Temperature Sensor 8"},
{ 0x61, "Thermal Management Temperature 1 Transition Count"},
{ 0x62, "Thermal Management Temperature 2 Transition Count"},
{ 0x63, "Total Time For Thermal Management Temperature 1"},
{ 0x64, "Total Time For Thermal Management Temperature 2"},
{ 0x65, "Endurance Estimate"},
{ 0x66, "Data Units Read"},
{ 0x67, "Data Units Written"},
{ 0x68, "Media Units Written"},
{ 0x69, "Number of Error Information Log Entries"},
{ 0x6A, "Form Factor"},
{ 0x6B, "Dies In Use Bad NAND Blocks"},
{ 0x6C, "Proactive Bad Die Retirement"},
{ 0x6D, "Namespace ID Context Statistic Descriptor"},
{ 0x6E, "Controller ID Context Statistic Descriptor"},
{ 0x6F, "Queue ID Context Statistic Descriptor"}
129};

131/* OCP 2.7 Section 4.9.15.2 Event IDs; reserved and obsolete IDs are NULL. */
132static const char * const timestamp_event_id_str[] = {
[0x0000] = "Host issued a Timestamp Set Feature Command (Feature ID Eh)",
[0x0001] = "Firmware initiated Timestamp Snapshot",
135};

137static const char * const pcie_event_id_str[] = {
[0x0000] = "Link Up",
[0x0001] = "Link Down",
[0x0002] = "PCIe Error Detected",
[0x0003] = "PERST# Asserted",
[0x0004] = "PERST# De-asserted",
[0x0005] = "Refclk Stable",
[0x0006] = "Vmain Stable",
[0x0007] = "Link Speed and Width Negotiated",
146};

148static const char * const nvme_event_id_str[] = {
[0x0000] = "CC.EN transitions from 0b to 1b",
[0x0001] = "CC.EN transitions from 1b to 0b",
[0x0002] = "CSTS.RDY transitions from 0b to 1b",
[0x0003] = "CSTS.RDY transitions from 1b to 0b",
[0x0005] = "Create I/O Submission Queue Command or Create I/O Completion Queue Command Processed successfully",
[0x0006] = "In-band Admin Command Processed other than Create I/O Submission Queue Command or Create I/O Completion Queue Command Processed successfully",
[0x0007] = "An Admin command returned a non-zero Status Code",
[0x0008] = "An I/O Command Returned a Non-zero Status Code",
[0x0009] = "CSTS.CFS transitioned from 0b to 1b",
[0x000A] = "Admin Submission Queue Base Address Written (AQA) or Admin Completion Queue Based Address (ACQ) written",
[0x000B] = "Controller Configuration Register (CC) Changed except for the cases that are covered in 0000h and 0001h",
[0x000C] = "Controller Status Register (CSTS) Changed except for the cases that are covered in 0002h, 0003h, and 0009h",
[0x000D] = "Delete I/O Completion Queue Command or Delete I/O Submission Queue Command Processed",
[0x000E] = "Out-of-band Command Processed",
[0x000F] = "Out-of-band Asynchronous Event Message Transmitted",
[0x0010] = "Error Reporting AEN was sent (see EREC-5)",
165};

167static const char * const reset_event_id_str[] = {
[0x0000] = "PCIe Conventional Hot Reset",
[0x0001] = "Main Power Cycle",
[0x0002] = "PERST#",
[0x0003] = "PCIe Function Level Reset",
[0x0004] = "NVM Subsystem Reset",
173};

175static const char * const boot_sequence_event_id_str[] = {
[0x0000] = "Main Firmware Boot Complete",
[0x0001] = "FTL Load from NVM Complete",
[0x0002] = "FTL Rebuild Started",
[0x0003] = "FTL Rebuild Complete",
180};

182static const char * const firmware_assert_event_id_str[] = {
[0x0000] = "Assert in NVMe Processing Code",
[0x0001] = "Assert in Media Code",
[0x0002] = "Assert in Security Code",
[0x0003] = "Assert in Background Services Code",
[0x0004] = "FTL Rebuild Failed",
[0x0005] = "FTL Data Mismatch",
[0x0006] = "Assert in Other Code",
190};

192static const char * const temperature_event_id_str[] = {
[0x0000] = "Composite Temperature decreases to (WCTEMP - 2)",
[0x0001] = "Composite Temperature increases to WCTEMP",
[0x0002] = "Composite Temperature increases to reach CCTEMP",
196};

198static const char * const media_event_id_str[] = {
[0x0000] = "XOR (or equivalent) Recovery Invoked",
[0x0001] = "Uncorrectable Media Error",
[0x0002] = "Block Marked Bad Due to Program Error",
[0x0003] = "Block Marked Bad Due to Erase Error",
[0x0004] = "Block Marked Bad Due to Read Error",
[0x0005] = "Plane Failure Event",
205};

207static const char * const media_wear_event_id_str[] = {
[0x0000] = "Media Wear",
209};

211static const char * const virtual_fifo_event_id_str[] = {
[0x0000] = "Virtual FIFO Start",
[0x0001] = "Virtual FIFO End",
214};

216static const char * const smbus_event_id_str[] = {
[0x0000] = "Timeout Errors",
[0x0001] = "PEC Errors",
[0x0002] = "Arbitration loss",
[0x0003] = "NACK error",
221};

223static const char * const mctp_event_id_str[] = {
[0x0000] = "Dropped Packet",
[0x0001] = "Dropped Message",
[0x0002] = "Discovery and addressing errors",
[0x0003] = "Error Status",
228};

230#define EVENT_IDS(t){ t, (sizeof(t) / sizeof((t)[0]) + 0) } { t, ARRAY_SIZE(t)(sizeof(t) / sizeof((t)[0]) + 0) }

232static const struct {
const char * const *str;
size_t count;
235} spec_event_id_str[] = {
[TIME_STAMP_CLASS_TYPE] = EVENT_IDS(timestamp_event_id_str){ timestamp_event_id_str, (sizeof(timestamp_event_id_str) / sizeof
((timestamp_event_id_str)[0]) + 0) },
[PCIE_CLASS_TYPE] = EVENT_IDS(pcie_event_id_str){ pcie_event_id_str, (sizeof(pcie_event_id_str) / sizeof((pcie_event_id_str
)[0]) + 0) },
[NVME_CLASS_TYPE] = EVENT_IDS(nvme_event_id_str){ nvme_event_id_str, (sizeof(nvme_event_id_str) / sizeof((nvme_event_id_str
)[0]) + 0) },
[RESET_CLASS_TYPE] = EVENT_IDS(reset_event_id_str){ reset_event_id_str, (sizeof(reset_event_id_str) / sizeof((reset_event_id_str
)[0]) + 0) },
[BOOT_SEQUENCE_CLASS_TYPE] = EVENT_IDS(boot_sequence_event_id_str){ boot_sequence_event_id_str, (sizeof(boot_sequence_event_id_str
) / sizeof((boot_sequence_event_id_str)[0]) + 0) },
[FIRMWARE_ASSERT_CLASS_TYPE] = EVENT_IDS(firmware_assert_event_id_str){ firmware_assert_event_id_str, (sizeof(firmware_assert_event_id_str
) / sizeof((firmware_assert_event_id_str)[0]) + 0) },
[TEMPERATURE_CLASS_TYPE] = EVENT_IDS(temperature_event_id_str){ temperature_event_id_str, (sizeof(temperature_event_id_str)
 / sizeof((temperature_event_id_str)[0]) + 0) },
[MEDIA_CLASS_TYPE] = EVENT_IDS(media_event_id_str){ media_event_id_str, (sizeof(media_event_id_str) / sizeof((media_event_id_str
)[0]) + 0) },
[MEDIA_WEAR_CLASS_TYPE] = EVENT_IDS(media_wear_event_id_str){ media_wear_event_id_str, (sizeof(media_wear_event_id_str) /
 sizeof((media_wear_event_id_str)[0]) + 0) },
[VIRTUAL_FIFO_EVENT_CLASS_TYPE] = EVENT_IDS(virtual_fifo_event_id_str){ virtual_fifo_event_id_str, (sizeof(virtual_fifo_event_id_str
) / sizeof((virtual_fifo_event_id_str)[0]) + 0) },
[SMBUS_I2C_I3C_EVENT_CLASS_TYPE] = EVENT_IDS(smbus_event_id_str){ smbus_event_id_str, (sizeof(smbus_event_id_str) / sizeof((smbus_event_id_str
)[0]) + 0) },
[MCTP_EVENT_CLASS_TYPE] = EVENT_IDS(mctp_event_id_str){ mctp_event_id_str, (sizeof(mctp_event_id_str) / sizeof((mctp_event_id_str
)[0]) + 0) },
248};

250struct request_data host_log_page_header[] = {
{ "LogIdentifier", 1 },
{ "Reserved1", 4 },
{ "IEEE OUI Identifier", 3 },
{ "Telemetry Host-Initiated Data Area 1 Last Block", 2 },
{ "Telemetry Host-Initiated Data Area 2 Last Block", 2 },
{ "Telemetry Host-Initiated Data Area 3 Last Block", 2 },
{ "Reserved2", 2 },
{ "Telemetry Host-Initiated Data Area 4 Last Block", 4 },
{ "Reserved3", 360 },
{ "Telemetry Host-Initiated Scope", 1 },
{ "Telemetry Host-Initiated Data Generation Number", 1 },
{ "Telemetry Controller-Initiated Data Available", 1 },
{ "Telemetry Controller-Initiated Data Generation Number", 1 }
264};

266struct request_data controller_log_page_header[] = {
{ "LogIdentifier", 1 },
{ "Reserved1", 4 },
{ "IEEE OUI Identifier", 3 },
{ "Telemetry Controller-Initiated Data Area 1 Last Block", 2 },
{ "Telemetry Controller-Initiated Data Area 2 Last Block", 2 },
{ "Telemetry Controller-Initiated Data Area 3 Last Block", 2 },
{ "Reserved2", 2 },
{ "Telemetry Controller-Initiated Data Area 4 Last Block", 4 },
{ "Reserved3", 361 },
{ "Telemetry Controller-Initiated Scope", 1 },
{ "Telemetry Controller-Initiated Data Available", 1 },
{ "Telemetry Controller-Initiated Data Generation Number", 1 }
279};

281struct request_data reason_identifier[] = {
{ "Error ID", 64 },
{ "File ID", 8 },
{ "Line Number", 2 },
{ "Valid Flags", 1 },
{ "Reserved", 21 },
{ "VU Reason Extension", 32 }
288};

290struct request_data ocp_header_in_da1[] = {
{ "Major Version", 2 },
{ "Minor Version", 2 },
{ "Reserved1", 4 },
{ "Timestamp", 8 },
{ "Log page GUID", GUID_LEN16 },
{ "Number Telemetry Profiles Supported", 1 },
{ "Telemetry Profile Selected", 1 },
{ "Reserved2", 6 },
{ "Telemetry String Log Size", 8 },
{ "Reserved3", 8 },
{ "Firmware Revision", 8 },
{ "Reserved4", 32 },
{ "Data Area 1 Statistic Start", 8 },
{ "Data Area 1 Statistic Size", 8 },
{ "Data Area 2 Statistic Start", 8 },
{ "Data Area 2 Statistic Size", 8 },
{ "Reserved5", 32 },
{ "Event FIFO 1 Data Area", 1 },
{ "Event FIFO 2 Data Area", 1 },
{ "Event FIFO 3 Data Area", 1 },
{ "Event FIFO 4 Data Area", 1 },
{ "Event FIFO 5 Data Area", 1 },
{ "Event FIFO 6 Data Area", 1 },
{ "Event FIFO 7 Data Area", 1 },
{ "Event FIFO 8 Data Area", 1 },
{ "Event FIFO 9 Data Area", 1 },
{ "Event FIFO 10 Data Area", 1 },
{ "Event FIFO 11 Data Area", 1 },
{ "Event FIFO 12 Data Area", 1 },
{ "Event FIFO 13 Data Area", 1 },
{ "Event FIFO 14 Data Area", 1 },
{ "Event FIFO 15 Data Area", 1 },
{ "Event FIFO 16 Data Area", 1 },
{ "Event FIFO 1 Start", 8 },
{ "Event FIFO 1 Size", 8 },
{ "Event FIFO 2 Start", 8 },
{ "Event FIFO 2 Size", 8 },
{ "Event FIFO 3 Start", 8 },
{ "Event FIFO 3 Size", 8 },
{ "Event FIFO 4 Start", 8 },
{ "Event FIFO 4 Size", 8 },
{ "Event FIFO 5 Start", 8 },
{ "Event FIFO 5 Size", 8 },
{ "Event FIFO 6 Start", 8 },
{ "Event FIFO 6 Size", 8 },
{ "Event FIFO 7 Start", 8 },
{ "Event FIFO 7 Size", 8 },
{ "Event FIFO 8 Start", 8 },
{ "Event FIFO 8 Size", 8 },
{ "Event FIFO 9 Start", 8 },
{ "Event FIFO 9 Size", 8 },
{ "Event FIFO 10 Start", 8 },
{ "Event FIFO 10 Size", 8 },
{ "Event FIFO 11 Start", 8 },
{ "Event FIFO 11 Size", 8 },
{ "Event FIFO 12 Start", 8 },
{ "Event FIFO 12 Size", 8 },
{ "Event FIFO 13 Start", 8 },
{ "Event FIFO 13 Size", 8 },
{ "Event FIFO 14 Start", 8 },
{ "Event FIFO 14 Size", 8 },
{ "Event FIFO 15 Start", 8 },
{ "Event FIFO 15 Size", 8 },
{ "Event FIFO 16 Start", 8 },
{ "Event FIFO 16 Size", 8 },
{ "Reserved6", 80 }
357};

359struct request_data smart[] = {
{ "Critical Warning", 1 },
{ "Composite Temperature", 2 },
{ "Available Spare", 1 },
{ "Available Spare Threshold", 1 },
{ "Percentage Used", 1 },
{ "Reserved1", 26 },
{ "Data Units Read", 16 },
{ "Data Units Written", 16 },
{ "Host Read Commands", 16 },
{ "Host Write Commands", 16 },
{ "Controller Busy Time", 16 },
{ "Power Cycles", 16 },
{ "Power On Hours", 16 },
{ "Unsafe Shutdowns", 16 },
{ "Media and Data Integrity Errors", 16 },
{ "Number of Error Information Log Entries", 16 },
{ "Warning Composite Temperature Time", 4 },
{ "Critical Composite Temperature Time", 4 },
{ "Temperature Sensor 1", 2 },
{ "Temperature Sensor 2", 2 },
{ "Temperature Sensor 3", 2 },
{ "Temperature Sensor 4", 2 },
{ "Temperature Sensor 5", 2 },
{ "Temperature Sensor 6", 2 },
{ "Temperature Sensor 7", 2 },
{ "Temperature Sensor 8", 2 },
{ "Thermal Management Temperature 1 Transition Count", 4 },
{ "Thermal Management Temperature 2 Transition Count", 4 },
{ "Total Time for Thermal Management Temperature 1", 4 },
{ "Total Time for Thermal Management Temperature 2", 4 },
{ "Reserved2", 280 }
391};

393struct request_data smart_extended[] = {
{ "Physical Media Units Written", 16 },
{ "Physical Media Units Read", 16 },
{ "Bad User NAND Blocks Raw Count", 6 },
{ "Bad User NAND Blocks Normalized Value", 2 },
{ "Bad System NAND Blocks Raw Count", 6 },
{ "Bad System NAND Blocks Normalized Value", 2 },
{ "XOR Recovery Count", 8 },
{ "Uncorrectable Read Error Count", 8 },
{ "Soft ECC Error Count", 8 },
{ "End to End Correction Counts Detected Errors", 4 },
{ "End to End Correction Counts Corrected Errors", 4 },
{ "System Data Percent Used", 1 },
{ "Refresh Counts", 7 },
{ "Maximum User Data Erase Count", 4 },
{ "Minimum User Data Erase Count", 4 },
{ "Number of thermal throttling events", 1 },
{ "Current Throttling Status", 1 },
{ "Errata Version Field", 1 },
{ "Point Version Field", 2 },
{ "Minor Version Field", 2 },
{ "Major Version Field", 1 },
{ "PCIe Correctable Error Count", 8 },
{ "Incomplete Shutdowns", 4 },
{ "Reserved1", 4 },
{ "Percent Free Blocks", 1 },
{ "Reserved2", 7 },
{ "Capacitor Health", 2 },
{ "NVMe Base Errata Version", 1 },
{ "NVMe Command Set Errata Version", 1 },
{ "Reserved3", 4 },
{ "Unaligned IO", 8 },
{ "Security Version Number", 8 },
{ "Total NUSE", 8 },
{ "PLP Start Count", 16 },
{ "Endurance Estimate", 16 },
{ "PCIe Link Retraining Count", 8 },
{ "Power State Change Count", 8 },
{ "Lowest Permitted Firmware Revision", 8 },
{ "Reserved4", 278 },
{ "Log Page Version", 2 },
{ "Log page GUID", GUID_LEN16 }
435};

437void json_add_formatted_u32_str(struct json_object *pobject, const char *msg, unsigned int pdata)
438{
char data_str[70] = { 0 };

snprintf(data_str, sizeof(data_str), "0x%x", pdata);
json_object_add_value_string(pobject, msg, data_str);
443}

445void json_add_formatted_var_size_str(struct json_object *pobject, const char *msg, __u8 *pdata,
unsigned int data_size)
447{
char *description_str = NULL((void*)0);
size_t size = data_size * 2 + 1;

/* 2 chars for each value in the data and the null terminator */
description_str = (char *) calloc(1, size);
if (!description_str) {
nvme_show_error("Failed to allocate description buffer")nvme_show_message(1, "Failed to allocate description buffer");
return;
}

shr_bin_to_hex(description_str, size, pdata, data_size, SHR_HEX_UPPER(1 << 0));

json_object_add_value_string(pobject, msg, description_str);
free(description_str);
462}

464/*
* A log can hold fewer data areas than its header describes, so each data
* area is cut to the bytes actually read.
*/
468static __u64 telemetry_da_size(__u64 start, __u64 end, size_t buf_len)
469{
if (end > buf_len)
end = buf_len;

return end > start ? end - start : 0;
474}

476int get_telemetry_das_offset_and_size(
struct nvme_ocp_telemetry_common_header *ptelemetry_common_header,
size_t buf_len, struct nvme_ocp_telemetry_offsets *ptelemetry_das_offset)
479{
if (NULL((void*)0) == ptelemetry_common_header || NULL((void*)0) == ptelemetry_das_offset) {
nvme_show_error("Invalid input arguments.")nvme_show_message(1, "Invalid input arguments.");
return -1;
}

if (ptelemetry_common_header->log_id == NVME_LOG_LID_TELEMETRY_HOST)
ptelemetry_das_offset->header_size =
sizeof(struct nvme_ocp_telemetry_host_initiated_header);
else if (ptelemetry_common_header->log_id == NVME_LOG_LID_TELEMETRY_CTRL)
ptelemetry_das_offset->header_size =
sizeof(struct nvme_ocp_telemetry_controller_initiated_header);
else
return -1;

__u64 header_size = ptelemetry_das_offset->header_size;
__u64 da1_end = header_size + (__u64)le16_to_cpu(ptelemetry_common_header->da1_last_block) *
OCP_TELEMETRY_DATA_BLOCK_SIZE512;
__u64 da2_end = header_size + (__u64)le16_to_cpu(ptelemetry_common_header->da2_last_block) *
OCP_TELEMETRY_DATA_BLOCK_SIZE512;
__u64 da3_end = header_size + (__u64)le16_to_cpu(ptelemetry_common_header->da3_last_block) *
OCP_TELEMETRY_DATA_BLOCK_SIZE512;
__u64 da4_end = header_size + (__u64)le32_to_cpu(ptelemetry_common_header->da4_last_block) *
OCP_TELEMETRY_DATA_BLOCK_SIZE512;

ptelemetry_das_offset->da1_start_offset = header_size;
ptelemetry_das_offset->da1_size =
telemetry_da_size(ptelemetry_das_offset->da1_start_offset, da1_end, buf_len);

ptelemetry_das_offset->da2_start_offset = ptelemetry_das_offset->da1_start_offset +
ptelemetry_das_offset->da1_size;
ptelemetry_das_offset->da2_size =
telemetry_da_size(ptelemetry_das_offset->da2_start_offset, da2_end, buf_len);

ptelemetry_das_offset->da3_start_offset = ptelemetry_das_offset->da2_start_offset +
ptelemetry_das_offset->da2_size;
ptelemetry_das_offset->da3_size =
telemetry_da_size(ptelemetry_das_offset->da3_start_offset, da3_end, buf_len);

ptelemetry_das_offset->da4_start_offset = ptelemetry_das_offset->da3_start_offset +
ptelemetry_das_offset->da3_size;
ptelemetry_das_offset->da4_size =
telemetry_da_size(ptelemetry_das_offset->da4_start_offset, da4_end, buf_len);

return 0;
524}

526/*
* Device tables store ascii_id_length as the zero-based index of the last
* character, so the byte count is length + 1. Keep the copy bounded to the
* fixed caller buffers used throughout the telemetry parser.
*/
531static size_t ocp_ascii_id_copy_len(__u8 ascii_id_length)
532{
size_t copy_len = (size_t)ascii_id_length + 1;

if (copy_len >= OCP_TELEMETRY_DESCRIPTION_MAX256)
copy_len = OCP_TELEMETRY_DESCRIPTION_MAX256 - 1;

return copy_len;
539}

541static int ocp_copy_ascii_id(__le64 ascii_id_offset, __u8 ascii_id_length, char *description)
542{
struct nvme_ocp_telemetry_string_header *pocp_ts_header =
(struct nvme_ocp_telemetry_string_header *)pstring_buffer;
__u64 ascts = le64_to_cpu(pocp_ts_header->ascts);
__u64 asctsz = le64_to_cpu(pocp_ts_header->asctsz);
__u64 offset = le64_to_cpu(ascii_id_offset);
size_t copy_len = ocp_ascii_id_copy_len(ascii_id_length);

/* With the ASCII table inside the log, neither product can overflow. */
if (!ocp_c9_table_fits(ascts, asctsz, pstring_buffer_size) || offset > asctsz ||
   copy_len > (asctsz - offset) * SIZE_OF_DWORD4)
return -1;

memcpy(description, pstring_buffer + (ascts + offset) * SIZE_OF_DWORD4, copy_len);
description[copy_len] = '\0';

return 0;
559}

561int get_statistic_id_ascii_string(int identifier, char *description)
562{
struct nvme_ocp_telemetry_string_header *pocp_ts_header;
struct nvme_ocp_statistics_identifier_string_table *entry;
__u64 entries = 0, i;
__u8 *table;

if (!pstring_buffer || !description)
return -1;

pocp_ts_header = (struct nvme_ocp_telemetry_string_header *)pstring_buffer;
table = ocp_string_table(pstring_buffer, pstring_buffer_size,
		 le64_to_cpu(pocp_ts_header->sits),
		 le64_to_cpu(pocp_ts_header->sitsz), sizeof(*entry), &entries);

for (i = 0; table && i < entries; i++) {
entry = (struct nvme_ocp_statistics_identifier_string_table *)
	(table + i * sizeof(*entry));

if (identifier == (int)le16_to_cpu(entry->vs_statistic_identifier) &&
    !ocp_copy_ascii_id(entry->ascii_id_offset, entry->ascii_id_length,
		       description))
	return 0;
}

// If ASCII string isn't found, see in our internal Map
// for 2.5 Spec defined strings
if (identifier <= 0x6F) {
shr_strscpy(description,
	    statistic_identifiers_map[identifier].description,
	    OCP_TELEMETRY_DESCRIPTION_MAX256);
return 0;
}

return -1;
596}

598/* Event and VU event string table entries share one layout. */
599static int ocp_event_ascii_string(__le64 start, __le64 size, int identifier,
		  int debug_event_class, char *description)
601{
struct nvme_ocp_event_string_table *entry;
__u64 entries = 0, i;
__u8 *table;

table = ocp_string_table(pstring_buffer, pstring_buffer_size, le64_to_cpu(start),
		 le64_to_cpu(size), sizeof(*entry), &entries);

for (i = 0; table && i < entries; i++) {
entry = (struct nvme_ocp_event_string_table *)(table + i * sizeof(*entry));

if (identifier == (int)le16_to_cpu(entry->event_identifier) &&
    debug_event_class == (int)entry->debug_event_class &&
    !ocp_copy_ascii_id(entry->ascii_id_offset, entry->ascii_id_length,
		       description))
	return 0;
}

return -1;
620}

622static int ocp_spec_event_id_string(int identifier, int debug_event_class,
		    char *description)
624{
const char *str;

if (debug_event_class < 0 ||
   debug_event_class >= (int)ARRAY_SIZE(spec_event_id_str)(sizeof(spec_event_id_str) / sizeof((spec_event_id_str)[0]) +
 0) ||
   identifier < 0 ||
   identifier >= (int)spec_event_id_str[debug_event_class].count)
return -1;

str = spec_event_id_str[debug_event_class].str[identifier];
if (!str)
return -1;

shr_strscpy(description, str, OCP_TELEMETRY_DESCRIPTION_MAX256);
return 0;
639}

641int get_event_id_ascii_string(int identifier, int debug_event_class, char *description)
642{
struct nvme_ocp_telemetry_string_header *pocp_ts_header =
(struct nvme_ocp_telemetry_string_header *)pstring_buffer;

if (!pstring_buffer)
return -1;

if (!ocp_event_ascii_string(pocp_ts_header->ests, pocp_ts_header->estsz,
		    identifier, debug_event_class, description))
return 0;

/* TELSLG-14: the String Log may omit Event IDs the spec defines. */
return ocp_spec_event_id_string(identifier, debug_event_class,
			description);
656}

658int get_vu_event_id_ascii_string(int identifier, int debug_event_class, char *description)
659{
struct nvme_ocp_telemetry_string_header *pocp_ts_header =
(struct nvme_ocp_telemetry_string_header *)pstring_buffer;

if (!pstring_buffer)
return -1;

return ocp_event_ascii_string(pocp_ts_header->vu_ests, pocp_ts_header->vu_estsz,
		      identifier, debug_event_class, description);
668}

670int parse_ocp_telemetry_string_log(int event_fifo_num, int identifier, int debug_event_class,
enum ocp_telemetry_string_tables string_table, char *description)
672{
if (pstring_buffer == NULL((void*)0))
return -1;

if (event_fifo_num < 0 || event_fifo_num > MAX_NUM_FIFOS16)
return -1;

if (event_fifo_num != 0) {
struct nvme_ocp_telemetry_string_header *pocp_ts_header =
	(struct nvme_ocp_telemetry_string_header *)pstring_buffer;

/* A name that fills all 16 bytes carries no terminator. */
memcpy(description, pocp_ts_header->fifo_ascii_string[event_fifo_num - 1],
       sizeof(pocp_ts_header->fifo_ascii_string[0]));
description[sizeof(pocp_ts_header->fifo_ascii_string[0])] = '\0';

return 0;
}

if (string_table == STATISTICS_IDENTIFIER_STRING)
get_statistic_id_ascii_string(identifier, description);
else if (string_table == EVENT_STRING && debug_event_class < 0x80)
get_event_id_ascii_string(identifier, debug_event_class, description);
else if (string_table == VU_EVENT_STRING || debug_event_class >= 0x80)
get_vu_event_id_ascii_string(identifier, debug_event_class, description);

return 0;
699}

701int parse_time_stamp_event(
struct nvme_ocp_telemetry_event_descriptor *pevent_descriptor,
struct json_object *pevent_descriptor_obj,
__u8 *pevent_specific_data,
struct json_object *pevent_fifos_object,
FILE *fp)
707{
struct nvme_ocp_time_stamp_dbg_evt_class_format *ptime_stamp_event =
(struct nvme_ocp_time_stamp_dbg_evt_class_format *) pevent_specific_data;
struct nvme_ocp_common_dbg_evt_class_vu_data *ptime_stamp_event_vu_data = NULL((void*)0);
__u16 vu_event_id = 0;
__u8 *pdata = NULL((void*)0);
char description_str[OCP_TELEMETRY_DESCRIPTION_MAX256] = "";
unsigned int vu_data_size = 0;
bool_Bool vu_data_present = false0;

if ((pevent_descriptor->event_data_size * SIZE_OF_DWORD4) >
 sizeof(struct nvme_ocp_time_stamp_dbg_evt_class_format)) {
vu_data_present = true1;
vu_data_size =
	((pevent_descriptor->event_data_size * SIZE_OF_DWORD4) -
	 (sizeof(struct nvme_ocp_time_stamp_dbg_evt_class_format) +
	 SIZE_OF_VU_EVENT_ID2));

ptime_stamp_event_vu_data =
	(struct nvme_ocp_common_dbg_evt_class_vu_data *)((char *)ptime_stamp_event +
	sizeof(struct nvme_ocp_time_stamp_dbg_evt_class_format));
vu_event_id = le16_to_cpu(ptime_stamp_event_vu_data->vu_event_identifier);
pdata = (__u8 *)&(ptime_stamp_event_vu_data->data);

parse_ocp_telemetry_string_log(0, vu_event_id,
	pevent_descriptor->debug_event_class_type,
	VU_EVENT_STRING, description_str);
}  else if (pevent_descriptor->event_data_size < 2)
return -1;

if (pevent_fifos_object != NULL((void*)0)) {
json_add_formatted_var_size_str(pevent_descriptor_obj, STR_CLASS_SPECIFIC_DATA"Class Specific Data",
				ptime_stamp_event->time_stamp, DATA_SIZE_88);
if (vu_data_present) {
	json_add_formatted_u32_str(pevent_descriptor_obj, STR_VU_EVENT_ID_STRING"VU Event Identifier",
				   vu_event_id);
	json_object_add_value_string(pevent_descriptor_obj, STR_VU_EVENT_STRING"VU Event String",
					 description_str);
	json_add_formatted_var_size_str(pevent_descriptor_obj, STR_VU_DATA"VU Data", pdata,
					vu_data_size);
}
} else {
if (fp) {
	print_formatted_var_size_str(STR_CLASS_SPECIFIC_DATA"Class Specific Data",
			     ptime_stamp_event->time_stamp, DATA_SIZE_88, fp);
	if (vu_data_present) {
		fprintf(fp, "%s: 0x%x\n", STR_VU_EVENT_ID_STRING"VU Event Identifier", vu_event_id);
		fprintf(fp, "%s: %s\n", STR_VU_EVENT_STRING"VU Event String", description_str);
		print_formatted_var_size_str(STR_VU_DATA"VU Data", pdata, vu_data_size, fp);
	}
} else {
	print_formatted_var_size_str(STR_CLASS_SPECIFIC_DATA"Class Specific Data",
		ptime_stamp_event->time_stamp, DATA_SIZE_88, fp);
	if (vu_data_present) {
		printf("%s: 0x%x\n", STR_VU_EVENT_ID_STRING"VU Event Identifier", vu_event_id);
		printf("%s: %s\n", STR_VU_EVENT_STRING"VU Event String", description_str);
		print_formatted_var_size_str(STR_VU_DATA"VU Data", pdata, vu_data_size, fp);
	}
}
}

return 0;
769}

771int parse_pcie_event(
struct nvme_ocp_telemetry_event_descriptor *pevent_descriptor,
struct json_object *pevent_descriptor_obj,
__u8 *pevent_specific_data,
struct json_object *pevent_fifos_object,
FILE *fp)
777{
struct nvme_ocp_pcie_dbg_evt_class_format *ppcie_event =
		(struct nvme_ocp_pcie_dbg_evt_class_format *) pevent_specific_data;
struct nvme_ocp_common_dbg_evt_class_vu_data *ppcie_event_vu_data = NULL((void*)0);
__u16 vu_event_id = 0;
__u8 *pdata = NULL((void*)0);
char description_str[OCP_TELEMETRY_DESCRIPTION_MAX256] = "";
unsigned int vu_data_size = 0;
bool_Bool vu_data_present = false0;

if ((pevent_descriptor->event_data_size * SIZE_OF_DWORD4) >
 sizeof(struct nvme_ocp_pcie_dbg_evt_class_format)) {
vu_data_present = true1;
vu_data_size =
	((pevent_descriptor->event_data_size * SIZE_OF_DWORD4) -
	(sizeof(struct nvme_ocp_pcie_dbg_evt_class_format) +
	SIZE_OF_VU_EVENT_ID2));

ppcie_event_vu_data =
	(struct nvme_ocp_common_dbg_evt_class_vu_data *)((char *)ppcie_event +
	sizeof(struct nvme_ocp_pcie_dbg_evt_class_format));
vu_event_id = le16_to_cpu(ppcie_event_vu_data->vu_event_identifier);
pdata = (__u8 *)&(ppcie_event_vu_data->data);

parse_ocp_telemetry_string_log(0, vu_event_id,
	pevent_descriptor->debug_event_class_type,
	VU_EVENT_STRING, description_str);
}  else if (pevent_descriptor->event_data_size < 1)
return -1;

if (pevent_fifos_object != NULL((void*)0)) {
json_add_formatted_var_size_str(pevent_descriptor_obj, STR_CLASS_SPECIFIC_DATA"Class Specific Data",
				ppcie_event->pCIeDebugEventData, DATA_SIZE_44);
if (vu_data_present) {
	json_add_formatted_u32_str(pevent_descriptor_obj, STR_VU_EVENT_ID_STRING"VU Event Identifier",
			vu_event_id);
	json_object_add_value_string(pevent_descriptor_obj, STR_VU_EVENT_STRING"VU Event String",
			description_str);
	json_add_formatted_var_size_str(pevent_descriptor_obj, STR_VU_DATA"VU Data", pdata,
			vu_data_size);
}
} else {
if (fp) {
	print_formatted_var_size_str(STR_CLASS_SPECIFIC_DATA"Class Specific Data",
			     ppcie_event->pCIeDebugEventData, DATA_SIZE_44, fp);
	if (vu_data_present) {
		fprintf(fp, "%s: 0x%x\n", STR_VU_EVENT_ID_STRING"VU Event Identifier", vu_event_id);
		fprintf(fp, "%s: %s\n", STR_VU_EVENT_STRING"VU Event String", description_str);
		print_formatted_var_size_str(STR_VU_DATA"VU Data", pdata, vu_data_size, fp);
	}
} else {
	print_formatted_var_size_str(STR_CLASS_SPECIFIC_DATA"Class Specific Data",
			     ppcie_event->pCIeDebugEventData, DATA_SIZE_44, fp);
	if (vu_data_present) {
		printf("%s: 0x%x\n", STR_VU_EVENT_ID_STRING"VU Event Identifier", vu_event_id);
		printf("%s: %s\n", STR_VU_EVENT_STRING"VU Event String", description_str);
		print_formatted_var_size_str(STR_VU_DATA"VU Data", pdata, vu_data_size, fp);
	}
}
}

return 0;
839}

841int parse_nvme_event(
struct nvme_ocp_telemetry_event_descriptor *pevent_descriptor,
struct json_object *pevent_descriptor_obj,
__u8 *pevent_specific_data,
struct json_object *pevent_fifos_object,
FILE *fp)
847{
struct nvme_ocp_nvme_dbg_evt_class_format *pnvme_event =
		(struct nvme_ocp_nvme_dbg_evt_class_format *) pevent_specific_data;
struct nvme_ocp_common_dbg_evt_class_vu_data *pnvme_event_vu_data = NULL((void*)0);
__u16 vu_event_id = 0;
__u8 *pdata = NULL((void*)0);
char description_str[OCP_TELEMETRY_DESCRIPTION_MAX256] = "";
unsigned int vu_data_size = 0;
bool_Bool vu_data_present = false0;

if ((pevent_descriptor->event_data_size * SIZE_OF_DWORD4) >
 sizeof(struct nvme_ocp_nvme_dbg_evt_class_format)) {
vu_data_present = true1;
vu_data_size =
	((pevent_descriptor->event_data_size * SIZE_OF_DWORD4) -
	(sizeof(struct nvme_ocp_nvme_dbg_evt_class_format) +
	SIZE_OF_VU_EVENT_ID2));
pnvme_event_vu_data =
	(struct nvme_ocp_common_dbg_evt_class_vu_data *)((char *)pnvme_event +
	sizeof(struct nvme_ocp_nvme_dbg_evt_class_format));

vu_event_id = le16_to_cpu(pnvme_event_vu_data->vu_event_identifier);
pdata = (__u8 *)&(pnvme_event_vu_data->data);

parse_ocp_telemetry_string_log(0, vu_event_id,
	pevent_descriptor->debug_event_class_type,
	VU_EVENT_STRING,
	description_str);
} else if (pevent_descriptor->event_data_size < 2)
return -1;

if (pevent_fifos_object != NULL((void*)0)) {
json_add_formatted_var_size_str(pevent_descriptor_obj, STR_CLASS_SPECIFIC_DATA"Class Specific Data",
	pnvme_event->nvmeDebugEventData, DATA_SIZE_88);
if (vu_data_present) {
	json_add_formatted_u32_str(pevent_descriptor_obj, STR_VU_EVENT_ID_STRING"VU Event Identifier",
				   vu_event_id);
	json_object_add_value_string(pevent_descriptor_obj, STR_VU_EVENT_STRING"VU Event String",
					 description_str);
	json_add_formatted_var_size_str(pevent_descriptor_obj, STR_VU_DATA"VU Data", pdata,
					vu_data_size);
}
} else {
if (fp) {
	print_formatted_var_size_str(STR_CLASS_SPECIFIC_DATA"Class Specific Data",
			     pnvme_event->nvmeDebugEventData, DATA_SIZE_88, fp);
	if (vu_data_present) {
		fprintf(fp, "%s: 0x%x\n", STR_VU_EVENT_ID_STRING"VU Event Identifier", vu_event_id);
		fprintf(fp, "%s: %s\n", STR_VU_EVENT_STRING"VU Event String", description_str);
		print_formatted_var_size_str(STR_VU_DATA"VU Data", pdata, vu_data_size, fp);
	}
} else {
	print_formatted_var_size_str(STR_CLASS_SPECIFIC_DATA"Class Specific Data",
			      pnvme_event->nvmeDebugEventData, DATA_SIZE_88, fp);
	if (vu_data_present) {
		printf("%s: 0x%x\n", STR_VU_EVENT_ID_STRING"VU Event Identifier", vu_event_id);
		printf("%s: %s\n", STR_VU_EVENT_STRING"VU Event String", description_str);
		print_formatted_var_size_str(STR_VU_DATA"VU Data", pdata, vu_data_size, fp);
	}
}
}

return 0;
910}

912void parse_common_event(struct nvme_ocp_telemetry_event_descriptor *pevent_descriptor,
	    struct json_object *pevent_descriptor_obj, __u8 *pevent_specific_data,
	    struct json_object *pevent_fifos_object, FILE *fp)
915{
if (pevent_specific_data) {
struct nvme_ocp_common_dbg_evt_class_vu_data *pcommon_debug_event_vu_data =
	(struct nvme_ocp_common_dbg_evt_class_vu_data *) pevent_specific_data;

__u16 vu_event_id = le16_to_cpu(pcommon_debug_event_vu_data->vu_event_identifier);
char description_str[OCP_TELEMETRY_DESCRIPTION_MAX256] = "";
__u8 *pdata = (__u8 *)&(pcommon_debug_event_vu_data->data);

unsigned int vu_data_size = ((pevent_descriptor->event_data_size *
	SIZE_OF_DWORD4) - SIZE_OF_VU_EVENT_ID2);

parse_ocp_telemetry_string_log(0, vu_event_id,
	pevent_descriptor->debug_event_class_type,
	VU_EVENT_STRING, description_str);

if (pevent_fifos_object != NULL((void*)0)) {
	json_add_formatted_u32_str(pevent_descriptor_obj, STR_VU_EVENT_ID_STRING"VU Event Identifier",
				   vu_event_id);
	json_object_add_value_string(pevent_descriptor_obj, STR_VU_EVENT_STRING"VU Event String",
					 description_str);
	json_add_formatted_var_size_str(pevent_descriptor_obj, STR_VU_DATA"VU Data", pdata,
					vu_data_size);
} else {
	if (fp) {
		fprintf(fp, "%s: 0x%x\n", STR_VU_EVENT_ID_STRING"VU Event Identifier", vu_event_id);
		fprintf(fp, "%s: %s\n", STR_VU_EVENT_STRING"VU Event String", description_str);
		print_formatted_var_size_str(STR_VU_DATA"VU Data", pdata, vu_data_size, fp);
	} else {
		printf("%s: 0x%x\n", STR_VU_EVENT_ID_STRING"VU Event Identifier", vu_event_id);
		printf("%s: %s\n", STR_VU_EVENT_STRING"VU Event String", description_str);
		print_formatted_var_size_str(STR_VU_DATA"VU Data", pdata, vu_data_size, fp);
	}
}
}
950}

952int parse_media_wear_event(
struct nvme_ocp_telemetry_event_descriptor *pevent_descriptor,
struct json_object *pevent_descriptor_obj,
__u8 *pevent_specific_data,
struct json_object *pevent_fifos_object,
FILE *fp)
958{
struct nvme_ocp_media_wear_dbg_evt_class_format *pmedia_wear_event =
	(struct nvme_ocp_media_wear_dbg_evt_class_format *) pevent_specific_data;
struct nvme_ocp_common_dbg_evt_class_vu_data *pmedia_wear_event_vu_data = NULL((void*)0);

__u16 vu_event_id = 0;
__u8 *pdata = NULL((void*)0);
char description_str[OCP_TELEMETRY_DESCRIPTION_MAX256] = "";
unsigned int vu_data_size = 0;
bool_Bool vu_data_present = false0;

if ((pevent_descriptor->event_data_size * SIZE_OF_DWORD4) >
 sizeof(struct nvme_ocp_media_wear_dbg_evt_class_format)) {
vu_data_present = true1;
vu_data_size =
	((pevent_descriptor->event_data_size * SIZE_OF_DWORD4) -
	(sizeof(struct nvme_ocp_media_wear_dbg_evt_class_format) +
	SIZE_OF_VU_EVENT_ID2));

pmedia_wear_event_vu_data =
	(struct nvme_ocp_common_dbg_evt_class_vu_data *)((char *)pmedia_wear_event +
	sizeof(struct nvme_ocp_media_wear_dbg_evt_class_format));
vu_event_id = le16_to_cpu(pmedia_wear_event_vu_data->vu_event_identifier);
pdata = (__u8 *)&(pmedia_wear_event_vu_data->data);

parse_ocp_telemetry_string_log(0, vu_event_id,
	pevent_descriptor->debug_event_class_type,
	VU_EVENT_STRING,
	description_str);
}  else if (pevent_descriptor->event_data_size < 3)
return -1;

if (pevent_fifos_object != NULL((void*)0)) {
json_add_formatted_var_size_str(pevent_descriptor_obj, STR_CLASS_SPECIFIC_DATA"Class Specific Data",
				pmedia_wear_event->currentMediaWear, DATA_SIZE_1212);
if (vu_data_present) {
	json_add_formatted_u32_str(pevent_descriptor_obj, STR_VU_EVENT_ID_STRING"VU Event Identifier",
			vu_event_id);
	json_object_add_value_string(pevent_descriptor_obj, STR_VU_EVENT_STRING"VU Event String",
			description_str);
	json_add_formatted_var_size_str(pevent_descriptor_obj, STR_VU_DATA"VU Data", pdata,
			vu_data_size);
}
} else {
if (fp) {
	print_formatted_var_size_str(STR_CLASS_SPECIFIC_DATA"Class Specific Data",
		      pmedia_wear_event->currentMediaWear, DATA_SIZE_1212, fp);
	if (vu_data_present) {
		fprintf(fp, "%s: 0x%x\n", STR_VU_EVENT_ID_STRING"VU Event Identifier", vu_event_id);
		fprintf(fp, "%s: %s\n", STR_VU_EVENT_STRING"VU Event String", description_str);
		print_formatted_var_size_str(STR_VU_DATA"VU Data", pdata, vu_data_size, fp);
	}
} else {
	print_formatted_var_size_str(STR_CLASS_SPECIFIC_DATA"Class Specific Data",
		     pmedia_wear_event->currentMediaWear, DATA_SIZE_1212, NULL((void*)0));
	if (vu_data_present) {
		printf("%s: 0x%x\n", STR_VU_EVENT_ID_STRING"VU Event Identifier", vu_event_id);
		printf("%s: %s\n", STR_VU_EVENT_STRING"VU Event String", description_str);
		print_formatted_var_size_str(STR_VU_DATA"VU Data", pdata, vu_data_size, fp);
	}
}
}

return 0;
1022}

1024/*
* The Virtual FIFO Event class (0Bh) carries a single Dword of class specific
* data and no VU data: a VU Virtual FIFO Identifier and a reserved half-word.
* The identifier names a virtual FIFO in the String Log's VU event table, and
* splits into the enclosing physical Event FIFO number and the virtual FIFO
* number within that physical FIFO.
*/
1031int parse_virtual_fifo_event(
struct nvme_ocp_telemetry_event_descriptor *pevent_descriptor,
struct json_object *pevent_descriptor_obj,
__u8 *pevent_specific_data,
struct json_object *pevent_fifos_object,
FILE *fp)
1037{
struct nvme_ocp_virtual_fifo_dbg_evt_class_format *pvirtual_fifo_event =
(struct nvme_ocp_virtual_fifo_dbg_evt_class_format *)
pevent_specific_data;
char description_str[OCP_TELEMETRY_DESCRIPTION_MAX256] = "";
char fifo_name_str[OCP_TELEMETRY_DESCRIPTION_MAX256] = "";
__u16 vu_virtual_fifo_id = 0;
__u8 physical_fifo_num = 0;
__u16 virtual_fifo_num = 0;

if ((pevent_descriptor->event_data_size * SIZE_OF_DWORD4) <
	sizeof(*pvirtual_fifo_event))
return -1;

vu_virtual_fifo_id =
le16_to_cpu(pvirtual_fifo_event->vu_virtual_fifo_identifier);
physical_fifo_num = vu_virtual_fifo_id >> VU_VIRTUAL_FIFO_PHY_NUM_SHIFT11;
virtual_fifo_num = vu_virtual_fifo_id & VU_VIRTUAL_FIFO_NUM_MASK0x07ff;

parse_ocp_telemetry_string_log(0, vu_virtual_fifo_id,
pevent_descriptor->debug_event_class_type,
VU_EVENT_STRING, description_str);

/*
* A physical FIFO number of 0h is invalid and the field is wide enough
* to hold values past the 10h maximum, so range-check it before using
* it to index the string log's FIFO name array.
*/
if (physical_fifo_num >= 1 && physical_fifo_num <= MAX_NUM_FIFOS16)
parse_ocp_telemetry_string_log(physical_fifo_num, 0, 0,
	EVENT_STRING, fifo_name_str);

if (pevent_fifos_object != NULL((void*)0)) {
json_add_formatted_u32_str(pevent_descriptor_obj,
			   STR_VU_VIRTUAL_FIFO_ID"VU Virtual FIFO Identifier",
			   vu_virtual_fifo_id);
json_object_add_value_string(pevent_descriptor_obj,
			      STR_VU_VIRTUAL_FIFO_STRING"VU Virtual FIFO String",
			      description_str);
json_add_formatted_u32_str(pevent_descriptor_obj,
			   STR_PHYSICAL_EVENT_FIFO_NUM"Physical Event FIFO Number",
			   physical_fifo_num);
json_object_add_value_string(pevent_descriptor_obj,
			      STR_PHYSICAL_EVENT_FIFO_STRING"Physical Event FIFO String",
			      fifo_name_str);
json_add_formatted_u32_str(pevent_descriptor_obj,
			   STR_VIRTUAL_FIFO_NUM"Virtual FIFO Number",
			   virtual_fifo_num);
} else if (fp) {
fprintf(fp, "%s: 0x%x\n", STR_VU_VIRTUAL_FIFO_ID"VU Virtual FIFO Identifier",
	vu_virtual_fifo_id);
fprintf(fp, "%s: %s\n", STR_VU_VIRTUAL_FIFO_STRING"VU Virtual FIFO String",
	description_str);
fprintf(fp, "%s: 0x%x\n", STR_PHYSICAL_EVENT_FIFO_NUM"Physical Event FIFO Number",
	physical_fifo_num);
fprintf(fp, "%s: %s\n", STR_PHYSICAL_EVENT_FIFO_STRING"Physical Event FIFO String",
	fifo_name_str);
fprintf(fp, "%s: 0x%x\n", STR_VIRTUAL_FIFO_NUM"Virtual FIFO Number",
	virtual_fifo_num);
} else {
printf("%s: 0x%x\n", STR_VU_VIRTUAL_FIFO_ID"VU Virtual FIFO Identifier",
       vu_virtual_fifo_id);
printf("%s: %s\n", STR_VU_VIRTUAL_FIFO_STRING"VU Virtual FIFO String",
       description_str);
printf("%s: 0x%x\n", STR_PHYSICAL_EVENT_FIFO_NUM"Physical Event FIFO Number",
       physical_fifo_num);
printf("%s: %s\n", STR_PHYSICAL_EVENT_FIFO_STRING"Physical Event FIFO String",
       fifo_name_str);
printf("%s: 0x%x\n", STR_VIRTUAL_FIFO_NUM"Virtual FIFO Number",
       virtual_fifo_num);
}

return 0;
1110}

1112/*
* A VU Event Identifier and VU Data follow a class's fixed record when its
* Event Data Size reaches past it. @vu_data_size excludes the identifier.
*/
1116static void parse_class_vu_fields(
struct nvme_ocp_telemetry_event_descriptor *pevent_descriptor,
struct json_object *pevent_descriptor_obj,
__u8 *pvu_fields, unsigned int vu_data_size,
struct json_object *pevent_fifos_object,
FILE *fp)
1122{
struct nvme_ocp_common_dbg_evt_class_vu_data *pvu_data =
(struct nvme_ocp_common_dbg_evt_class_vu_data *)pvu_fields;
char description_str[OCP_TELEMETRY_DESCRIPTION_MAX256] = "";
__u16 vu_event_id = le16_to_cpu(pvu_data->vu_event_identifier);

parse_ocp_telemetry_string_log(0, vu_event_id,
pevent_descriptor->debug_event_class_type,
VU_EVENT_STRING, description_str);

if (pevent_fifos_object != NULL((void*)0)) {
json_add_formatted_u32_str(pevent_descriptor_obj,
			   STR_VU_EVENT_ID_STRING"VU Event Identifier", vu_event_id);
json_object_add_value_string(pevent_descriptor_obj,
			      STR_VU_EVENT_STRING"VU Event String",
			      description_str);
json_add_formatted_var_size_str(pevent_descriptor_obj,
				STR_VU_DATA"VU Data", pvu_data->data,
				vu_data_size);
} else if (fp) {
fprintf(fp, "%s: 0x%x\n", STR_VU_EVENT_ID_STRING"VU Event Identifier", vu_event_id);
fprintf(fp, "%s: %s\n", STR_VU_EVENT_STRING"VU Event String", description_str);
print_formatted_var_size_str(STR_VU_DATA"VU Data", pvu_data->data,
			     vu_data_size, fp);
} else {
printf("%s: 0x%x\n", STR_VU_EVENT_ID_STRING"VU Event Identifier", vu_event_id);
printf("%s: %s\n", STR_VU_EVENT_STRING"VU Event String", description_str);
print_formatted_var_size_str(STR_VU_DATA"VU Data", pvu_data->data,
			     vu_data_size, NULL((void*)0));
}
1152}

1154/*
* The SMBUS/I2C/I3C Debug Event class (0Ch) carries one Dword of class
* specific data: the SMBUS Debug Event Data and a reserved half-word. The
* Event Data values are defined only for the NACK error Event ID.
*/
1159int parse_smbus_event(
struct nvme_ocp_telemetry_event_descriptor *pevent_descriptor,
struct json_object *pevent_descriptor_obj,
__u8 *pevent_specific_data,
struct json_object *pevent_fifos_object,
FILE *fp)
1165{
struct nvme_ocp_smbus_dbg_evt_class_format *psmbus_event =
(struct nvme_ocp_smbus_dbg_evt_class_format *)
pevent_specific_data;
unsigned int event_size =
pevent_descriptor->event_data_size * SIZE_OF_DWORD4;
__u16 event_id = le16_to_cpu(pevent_descriptor->event_id);
const char *event_data_str = NULL((void*)0);
__u16 event_data = 0;

if (event_size < sizeof(*psmbus_event))
return -1;

event_data = le16_to_cpu(psmbus_event->smbus_debug_event_data);
event_data_str = telemetry_smbus_event_data_to_string(event_id,
					      event_data);

if (pevent_fifos_object != NULL((void*)0)) {
json_add_formatted_u32_str(pevent_descriptor_obj,
			   STR_SMBUS_DEBUG_EVENT_DATA"SMBUS Debug Event Data",
			   event_data);
json_object_add_value_string(pevent_descriptor_obj,
			      STR_SMBUS_DEBUG_EVENT_DATA_STRING"SMBUS Debug Event Data String",
			      event_data_str);
} else if (fp) {
fprintf(fp, "%s: 0x%x\n", STR_SMBUS_DEBUG_EVENT_DATA"SMBUS Debug Event Data",
	event_data);
fprintf(fp, "%s: %s\n", STR_SMBUS_DEBUG_EVENT_DATA_STRING"SMBUS Debug Event Data String",
	event_data_str);
} else {
printf("%s: 0x%x\n", STR_SMBUS_DEBUG_EVENT_DATA"SMBUS Debug Event Data", event_data);
printf("%s: %s\n", STR_SMBUS_DEBUG_EVENT_DATA_STRING"SMBUS Debug Event Data String",
       event_data_str);
}

if (event_size > sizeof(*psmbus_event))
parse_class_vu_fields(pevent_descriptor, pevent_descriptor_obj,
	pevent_specific_data + sizeof(*psmbus_event),
	event_size - sizeof(*psmbus_event) - SIZE_OF_VU_EVENT_ID2,
	pevent_fifos_object, fp);

return 0;
1207}

1209/*
* The MCTP Debug Event class (0Dh) carries two Dwords of class specific
* data: the MCTP Debug Event Data, whose values depend on the Event ID, the
* Transport Protocol Information, the Event Flags and the MCTP Transport
* Header. The header holds captured packet bytes only when the Transport
* Header Valid flag is set, so it is left out otherwise.
*/
1216int parse_mctp_event(
struct nvme_ocp_telemetry_event_descriptor *pevent_descriptor,
struct json_object *pevent_descriptor_obj,
__u8 *pevent_specific_data,
struct json_object *pevent_fifos_object,
FILE *fp)
1222{
struct nvme_ocp_mctp_dbg_evt_class_format *pmctp_event =
(struct nvme_ocp_mctp_dbg_evt_class_format *)
pevent_specific_data;
unsigned int event_size =
pevent_descriptor->event_data_size * SIZE_OF_DWORD4;
__u16 event_id = le16_to_cpu(pevent_descriptor->event_id);
const char *event_data_str = NULL((void*)0);
const char *protocol_str = NULL((void*)0);
bool_Bool header_valid = false0;
__u16 event_data = 0;

if (event_size < sizeof(*pmctp_event))
return -1;

event_data = le16_to_cpu(pmctp_event->mctp_debug_event_data);
event_data_str = telemetry_mctp_event_data_to_string(event_id,
					     event_data);
protocol_str = telemetry_mctp_transport_protocol_to_string(
pmctp_event->transport_protocol);
header_valid = pmctp_event->event_flags &
MCTP_EVENT_FLAG_TRANSPORT_HEADER_VALID0x80;

if (pevent_fifos_object != NULL((void*)0)) {
json_add_formatted_u32_str(pevent_descriptor_obj,
			   STR_MCTP_DEBUG_EVENT_DATA"MCTP Debug Event Data",
			   event_data);
json_object_add_value_string(pevent_descriptor_obj,
			      STR_MCTP_DEBUG_EVENT_DATA_STRING"MCTP Debug Event Data String",
			      event_data_str);
json_add_formatted_u32_str(pevent_descriptor_obj,
			   STR_MCTP_TRANSPORT_PROTOCOL"MCTP Transport Protocol Information",
			   pmctp_event->transport_protocol);
json_object_add_value_string(pevent_descriptor_obj,
			      STR_MCTP_TRANSPORT_PROTOCOL_STRING"MCTP Transport Protocol String",
			      protocol_str);
json_add_formatted_u32_str(pevent_descriptor_obj,
			   STR_MCTP_TRANSPORT_HEADER_VALID"MCTP Transport Header Valid",
			   header_valid);
if (header_valid)
	json_add_formatted_var_size_str(pevent_descriptor_obj,
		STR_MCTP_TRANSPORT_HEADER"MCTP Transport Header",
		pmctp_event->transport_header, DATA_SIZE_44);
} else if (fp) {
fprintf(fp, "%s: 0x%x\n", STR_MCTP_DEBUG_EVENT_DATA"MCTP Debug Event Data",
	event_data);
fprintf(fp, "%s: %s\n", STR_MCTP_DEBUG_EVENT_DATA_STRING"MCTP Debug Event Data String",
	event_data_str);
fprintf(fp, "%s: 0x%x\n", STR_MCTP_TRANSPORT_PROTOCOL"MCTP Transport Protocol Information",
	pmctp_event->transport_protocol);
fprintf(fp, "%s: %s\n", STR_MCTP_TRANSPORT_PROTOCOL_STRING"MCTP Transport Protocol String",
	protocol_str);
fprintf(fp, "%s: 0x%x\n", STR_MCTP_TRANSPORT_HEADER_VALID"MCTP Transport Header Valid",
	header_valid);
if (header_valid)
	print_formatted_var_size_str(STR_MCTP_TRANSPORT_HEADER"MCTP Transport Header",
		pmctp_event->transport_header, DATA_SIZE_44, fp);
} else {
printf("%s: 0x%x\n", STR_MCTP_DEBUG_EVENT_DATA"MCTP Debug Event Data", event_data);
printf("%s: %s\n", STR_MCTP_DEBUG_EVENT_DATA_STRING"MCTP Debug Event Data String",
       event_data_str);
printf("%s: 0x%x\n", STR_MCTP_TRANSPORT_PROTOCOL"MCTP Transport Protocol Information",
       pmctp_event->transport_protocol);
printf("%s: %s\n", STR_MCTP_TRANSPORT_PROTOCOL_STRING"MCTP Transport Protocol String",
       protocol_str);
printf("%s: 0x%x\n", STR_MCTP_TRANSPORT_HEADER_VALID"MCTP Transport Header Valid",
       header_valid);
if (header_valid)
	print_formatted_var_size_str(STR_MCTP_TRANSPORT_HEADER"MCTP Transport Header",
		pmctp_event->transport_header, DATA_SIZE_44, NULL((void*)0));
}

if (event_size > sizeof(*pmctp_event))
parse_class_vu_fields(pevent_descriptor, pevent_descriptor_obj,
	pevent_specific_data + sizeof(*pmctp_event),
	event_size - sizeof(*pmctp_event) - SIZE_OF_VU_EVENT_ID2,
	pevent_fifos_object, fp);

return 0;
1301}

1303int parse_event_fifo(unsigned int fifo_num, unsigned char *pfifo_start,
struct json_object *pevent_fifos_object, unsigned char *pstring_buffer,
struct nvme_ocp_telemetry_offsets *poffsets, __u64 fifo_size, FILE *fp)
1306{
if (NULL((void*)0) == pfifo_start || NULL((void*)0) == poffsets) {
1
Assuming 'pfifo_start' is not equal to NULL→
2
←
Assuming 'poffsets' is not equal to NULL→
3
←
Taking false branch→
nvme_show_error("Input buffer was NULL")nvme_show_message(1, "Input buffer was NULL");
return -1;
}

int status = 0, ret = 0;
unsigned int event_fifo_number = fifo_num + 1;
__cleanup_free__attribute__((cleanup(shr_freep))) char *description = calloc(1, 40 + 1);
4
←
Memory is allocated→

if (!description) {
5
←
Assuming 'description' is non-null→
6
←
Taking false branch→
nvme_show_error("Failed to allocate description buffer")nvme_show_message(1, "Failed to allocate description buffer");
return -1;
}

status =
parse_ocp_telemetry_string_log(event_fifo_number, 0, 0, EVENT_STRING, description);

if (status6.1
'status' is not equal to 0
 != 0) {
7
←
Taking true branch→
nvme_show_error("Failed to get C9 String. status: %d", status)nvme_show_message(1, "Failed to get C9 String. status: %d", status
);
8
←
Potential leak of memory pointed to by 'description'
return -1;
}

char event_fifo_name[100] = {0};

snprintf(event_fifo_name, sizeof(event_fifo_name), "%s%d%s%s", "EVENT FIFO ",
 event_fifo_number, " - ", description);

__cleanup_json_object__attribute__((cleanup(json_free_objectp))) struct json_object *pevent_fifo_array = NULL((void*)0);

if (pevent_fifos_object != NULL((void*)0))
pevent_fifo_array = json_create_array()json_object_new_array();
else {
char buffer[1024] = {0};

snprintf(buffer, sizeof(buffer), "%s%s\n%s", STR_LINE"==============================================================================\n",
	 event_fifo_name, STR_LINE"==============================================================================\n");
if (fp)
	fprintf(fp, "%s", buffer);
else
	printf("%s", buffer);
}

int offset_to_move = 0;
unsigned int event_des_size = sizeof(struct nvme_ocp_telemetry_event_descriptor);

while ((fifo_size > 0) && (offset_to_move < fifo_size)) {
struct nvme_ocp_telemetry_event_descriptor *pevent_descriptor =
	(struct nvme_ocp_telemetry_event_descriptor *)
	(pfifo_start + offset_to_move);

/* check if at the end of the list */
if (pevent_descriptor->debug_event_class_type == RESERVED_CLASS_TYPE)
	break;

__u8 *pevent_specific_data = NULL((void*)0);
__u16 event_id = 0;
char description_str[OCP_TELEMETRY_DESCRIPTION_MAX256] = "";
unsigned int data_size = 0;
__u64 remaining = fifo_size - offset_to_move;
bool_Bool is_snapshot = pevent_descriptor->debug_event_class_type ==
		STATISTIC_SNAPSHOT_CLASS_TYPE;
struct nvme_ocp_statistic_snapshot_evt_class_format *psnapshot =
	(struct nvme_ocp_statistic_snapshot_evt_class_format *)
	pevent_descriptor;

/*
 * Bound the whole entry by what is left of the FIFO before its
 * size field or any class specific data is read. A snapshot's
 * Event ID and Event Data Size bytes are reserved, so its
 * statistic's identifier and size are reported instead.
 */
event_des_size = is_snapshot ? sizeof(*psnapshot) :
	sizeof(struct nvme_ocp_telemetry_event_descriptor);
if (remaining < event_des_size) {
	nvme_show_error(nvme_show_message(1, "Invalid entry at offset 0x%x of Event FIFO %u: "
 "class 0x%x needs a %u-byte header, %llu bytes left in FIFO"
, offset_to_move, event_fifo_number, pevent_descriptor->debug_event_class_type
, event_des_size, (unsigned long long)remaining)
		"Invalid entry at offset 0x%x of Event FIFO %u: "nvme_show_message(1, "Invalid entry at offset 0x%x of Event FIFO %u: "
 "class 0x%x needs a %u-byte header, %llu bytes left in FIFO"
, offset_to_move, event_fifo_number, pevent_descriptor->debug_event_class_type
, event_des_size, (unsigned long long)remaining)
		"class 0x%x needs a %u-byte header, %llu bytes left in FIFO",nvme_show_message(1, "Invalid entry at offset 0x%x of Event FIFO %u: "
 "class 0x%x needs a %u-byte header, %llu bytes left in FIFO"
, offset_to_move, event_fifo_number, pevent_descriptor->debug_event_class_type
, event_des_size, (unsigned long long)remaining)
		offset_to_move, event_fifo_number,nvme_show_message(1, "Invalid entry at offset 0x%x of Event FIFO %u: "
 "class 0x%x needs a %u-byte header, %llu bytes left in FIFO"
, offset_to_move, event_fifo_number, pevent_descriptor->debug_event_class_type
, event_des_size, (unsigned long long)remaining)
		pevent_descriptor->debug_event_class_type,nvme_show_message(1, "Invalid entry at offset 0x%x of Event FIFO %u: "
 "class 0x%x needs a %u-byte header, %llu bytes left in FIFO"
, offset_to_move, event_fifo_number, pevent_descriptor->debug_event_class_type
, event_des_size, (unsigned long long)remaining)
		event_des_size, (unsigned long long)remaining)nvme_show_message(1, "Invalid entry at offset 0x%x of Event FIFO %u: "
 "class 0x%x needs a %u-byte header, %llu bytes left in FIFO"
, offset_to_move, event_fifo_number, pevent_descriptor->debug_event_class_type
, event_des_size, (unsigned long long)remaining);
	return -1;
}

/* Data sizes are in Dwords */
if (is_snapshot)
	data_size = le16_to_cpu(psnapshot->stat_data_size) *
		SIZE_OF_DWORD4;
else
	data_size = pevent_descriptor->event_data_size *
		SIZE_OF_DWORD4;
if (remaining - event_des_size < data_size) {
	nvme_show_error(nvme_show_message(1, "Invalid entry at offset 0x%x of Event FIFO %u: "
 "class 0x%x, %s 0x%x declares %u data bytes, %llu left in FIFO"
, offset_to_move, event_fifo_number, pevent_descriptor->debug_event_class_type
, is_snapshot ? "Statistic ID" : "Event ID", le16_to_cpu(is_snapshot
 ? psnapshot->stat_id : pevent_descriptor->event_id), data_size
, (unsigned long long)(remaining - event_des_size))
		"Invalid entry at offset 0x%x of Event FIFO %u: "nvme_show_message(1, "Invalid entry at offset 0x%x of Event FIFO %u: "
 "class 0x%x, %s 0x%x declares %u data bytes, %llu left in FIFO"
, offset_to_move, event_fifo_number, pevent_descriptor->debug_event_class_type
, is_snapshot ? "Statistic ID" : "Event ID", le16_to_cpu(is_snapshot
 ? psnapshot->stat_id : pevent_descriptor->event_id), data_size
, (unsigned long long)(remaining - event_des_size))
		"class 0x%x, %s 0x%x declares %u data bytes, %llu left in FIFO",nvme_show_message(1, "Invalid entry at offset 0x%x of Event FIFO %u: "
 "class 0x%x, %s 0x%x declares %u data bytes, %llu left in FIFO"
, offset_to_move, event_fifo_number, pevent_descriptor->debug_event_class_type
, is_snapshot ? "Statistic ID" : "Event ID", le16_to_cpu(is_snapshot
 ? psnapshot->stat_id : pevent_descriptor->event_id), data_size
, (unsigned long long)(remaining - event_des_size))
		offset_to_move, event_fifo_number,nvme_show_message(1, "Invalid entry at offset 0x%x of Event FIFO %u: "
 "class 0x%x, %s 0x%x declares %u data bytes, %llu left in FIFO"
, offset_to_move, event_fifo_number, pevent_descriptor->debug_event_class_type
, is_snapshot ? "Statistic ID" : "Event ID", le16_to_cpu(is_snapshot
 ? psnapshot->stat_id : pevent_descriptor->event_id), data_size
, (unsigned long long)(remaining - event_des_size))
		pevent_descriptor->debug_event_class_type,nvme_show_message(1, "Invalid entry at offset 0x%x of Event FIFO %u: "
 "class 0x%x, %s 0x%x declares %u data bytes, %llu left in FIFO"
, offset_to_move, event_fifo_number, pevent_descriptor->debug_event_class_type
, is_snapshot ? "Statistic ID" : "Event ID", le16_to_cpu(is_snapshot
 ? psnapshot->stat_id : pevent_descriptor->event_id), data_size
, (unsigned long long)(remaining - event_des_size))
		is_snapshot ? "Statistic ID" : "Event ID",nvme_show_message(1, "Invalid entry at offset 0x%x of Event FIFO %u: "
 "class 0x%x, %s 0x%x declares %u data bytes, %llu left in FIFO"
, offset_to_move, event_fifo_number, pevent_descriptor->debug_event_class_type
, is_snapshot ? "Statistic ID" : "Event ID", le16_to_cpu(is_snapshot
 ? psnapshot->stat_id : pevent_descriptor->event_id), data_size
, (unsigned long long)(remaining - event_des_size))
		le16_to_cpu(is_snapshot ? psnapshot->stat_id :nvme_show_message(1, "Invalid entry at offset 0x%x of Event FIFO %u: "
 "class 0x%x, %s 0x%x declares %u data bytes, %llu left in FIFO"
, offset_to_move, event_fifo_number, pevent_descriptor->debug_event_class_type
, is_snapshot ? "Statistic ID" : "Event ID", le16_to_cpu(is_snapshot
 ? psnapshot->stat_id : pevent_descriptor->event_id), data_size
, (unsigned long long)(remaining - event_des_size))
			    pevent_descriptor->event_id),nvme_show_message(1, "Invalid entry at offset 0x%x of Event FIFO %u: "
 "class 0x%x, %s 0x%x declares %u data bytes, %llu left in FIFO"
, offset_to_move, event_fifo_number, pevent_descriptor->debug_event_class_type
, is_snapshot ? "Statistic ID" : "Event ID", le16_to_cpu(is_snapshot
 ? psnapshot->stat_id : pevent_descriptor->event_id), data_size
, (unsigned long long)(remaining - event_des_size))
		data_size,nvme_show_message(1, "Invalid entry at offset 0x%x of Event FIFO %u: "
 "class 0x%x, %s 0x%x declares %u data bytes, %llu left in FIFO"
, offset_to_move, event_fifo_number, pevent_descriptor->debug_event_class_type
, is_snapshot ? "Statistic ID" : "Event ID", le16_to_cpu(is_snapshot
 ? psnapshot->stat_id : pevent_descriptor->event_id), data_size
, (unsigned long long)(remaining - event_des_size))
		(unsigned long long)(remaining - event_des_size))nvme_show_message(1, "Invalid entry at offset 0x%x of Event FIFO %u: "
 "class 0x%x, %s 0x%x declares %u data bytes, %llu left in FIFO"
, offset_to_move, event_fifo_number, pevent_descriptor->debug_event_class_type
, is_snapshot ? "Statistic ID" : "Event ID", le16_to_cpu(is_snapshot
 ? psnapshot->stat_id : pevent_descriptor->event_id), data_size
, (unsigned long long)(remaining - event_des_size));
	return -1;
}

if (!is_snapshot) {
	if (pevent_descriptor->event_data_size > 0)
		pevent_specific_data = (__u8 *)pevent_descriptor + event_des_size;

	event_id = le16_to_cpu(pevent_descriptor->event_id);

	parse_ocp_telemetry_string_log(0, event_id,
		pevent_descriptor->debug_event_class_type, EVENT_STRING,
		description_str);

	__cleanup_json_object__attribute__((cleanup(json_free_objectp)))
	struct json_object *pevent_descriptor_obj =
		((pevent_fifos_object != NULL((void*)0))?json_create_object()json_object_new_object():NULL((void*)0));

	if (pevent_descriptor_obj != NULL((void*)0)) {
		json_add_formatted_u32_str(pevent_descriptor_obj,
			STR_DBG_EVENT_CLASS_TYPE"Debug Event Class type",
			pevent_descriptor->debug_event_class_type);
		json_add_formatted_u32_str(pevent_descriptor_obj,
			STR_EVENT_IDENTIFIER"Event Identifier", event_id);
		json_object_add_value_string(pevent_descriptor_obj,
			STR_EVENT_STRING"Event String", description_str);
		json_add_formatted_u32_str(pevent_descriptor_obj,
			STR_EVENT_DATA_SIZE"Event Data Size", pevent_descriptor->event_data_size);

		if (pevent_descriptor->debug_event_class_type >= 0x80)
			json_add_formatted_var_size_str(pevent_descriptor_obj,
				STR_VU_DATA"VU Data", pevent_specific_data, data_size);
	} else {
		if (fp) {
			fprintf(fp, "%s: 0x%x\n", STR_DBG_EVENT_CLASS_TYPE"Debug Event Class type",
				pevent_descriptor->debug_event_class_type);
			fprintf(fp, "%s: 0x%x\n", STR_EVENT_IDENTIFIER"Event Identifier",
				event_id);
			fprintf(fp, "%s: %s\n", STR_EVENT_STRING"Event String", description_str);
			fprintf(fp, "%s: 0x%x\n", STR_EVENT_DATA_SIZE"Event Data Size",
				pevent_descriptor->event_data_size);
		} else {
			printf("%s: 0x%x\n", STR_DBG_EVENT_CLASS_TYPE"Debug Event Class type",
			   pevent_descriptor->debug_event_class_type);
			printf("%s: 0x%x\n", STR_EVENT_IDENTIFIER"Event Identifier",
			   event_id);
			printf("%s: %s\n", STR_EVENT_STRING"Event String", description_str);
			printf("%s: 0x%x\n", STR_EVENT_DATA_SIZE"Event Data Size",
			   pevent_descriptor->event_data_size);
		}

		if (pevent_descriptor->debug_event_class_type >= 0x80)
			print_formatted_var_size_str(STR_VU_DATA"VU Data",
				pevent_specific_data, data_size, fp);
	}

	switch (pevent_descriptor->debug_event_class_type) {
	case TIME_STAMP_CLASS_TYPE:
		ret = parse_time_stamp_event(pevent_descriptor,
			pevent_descriptor_obj,
			pevent_specific_data,
			pevent_fifos_object,
			fp);
		break;
	case PCIE_CLASS_TYPE:
		ret = parse_pcie_event(pevent_descriptor,
			pevent_descriptor_obj,
			pevent_specific_data,
			pevent_fifos_object,
			fp);
		break;
	case NVME_CLASS_TYPE:
		ret = parse_nvme_event(pevent_descriptor,
			pevent_descriptor_obj,
			pevent_specific_data,
			pevent_fifos_object,
			fp);
		break;
	case RESET_CLASS_TYPE:
	case BOOT_SEQUENCE_CLASS_TYPE:
	case FIRMWARE_ASSERT_CLASS_TYPE:
	case TEMPERATURE_CLASS_TYPE:
	case MEDIA_CLASS_TYPE:
		parse_common_event(pevent_descriptor,
			pevent_descriptor_obj,
			pevent_specific_data,
			pevent_fifos_object,
			fp);
		ret = 0;
		break;
	case MEDIA_WEAR_CLASS_TYPE:
		ret = parse_media_wear_event(pevent_descriptor,
			pevent_descriptor_obj,
			pevent_specific_data,
			pevent_fifos_object,
			fp);
		break;
	case VIRTUAL_FIFO_EVENT_CLASS_TYPE:
		ret = parse_virtual_fifo_event(
			pevent_descriptor,
			pevent_descriptor_obj,
			pevent_specific_data,
			pevent_fifos_object,
			fp);
		break;
	case SMBUS_I2C_I3C_EVENT_CLASS_TYPE:
		ret = parse_smbus_event(pevent_descriptor,
			pevent_descriptor_obj,
			pevent_specific_data,
			pevent_fifos_object,
			fp);
		break;
	case MCTP_EVENT_CLASS_TYPE:
		ret = parse_mctp_event(pevent_descriptor,
			pevent_descriptor_obj,
			pevent_specific_data,
			pevent_fifos_object,
			fp);
		break;
	case RESERVED_CLASS_TYPE:
		break;
	default:
		/*
		 * Keep the payload of a class with no decoder
		 * visible; vendor unique classes already print
		 * theirs as VU Data.
		 */
		if (pevent_descriptor->debug_event_class_type >= 0x80)
			break;
		if (pevent_descriptor_obj != NULL((void*)0))
			json_add_formatted_var_size_str(
				pevent_descriptor_obj,
				STR_CLASS_SPECIFIC_DATA"Class Specific Data",
				pevent_specific_data, data_size);
		else
			print_formatted_var_size_str(
				STR_CLASS_SPECIFIC_DATA"Class Specific Data",
				pevent_specific_data, data_size,
				fp);
		break;
	}

	if (ret) {
		nvme_show_error(nvme_show_message(1, "ERROR : OCP : Invalid NVMe Event FIFO entry\n"
)
			"ERROR : OCP : Invalid NVMe Event FIFO entry\n")nvme_show_message(1, "ERROR : OCP : Invalid NVMe Event FIFO entry\n"
);
		nvme_show_error(nvme_show_message(1, "FIFO: %d, offset: 0x%x\n", event_fifo_number
, offset_to_move)
			"FIFO: %d, offset: 0x%x\n",nvme_show_message(1, "FIFO: %d, offset: 0x%x\n", event_fifo_number
, offset_to_move)
			event_fifo_number, offset_to_move)nvme_show_message(1, "FIFO: %d, offset: 0x%x\n", event_fifo_number
, offset_to_move);
		nvme_show_error(nvme_show_message(1, "Type: 0x%x, ID: 0x%x, Size: 0x%x\n", pevent_descriptor
->debug_event_class_type, event_id, pevent_descriptor->
event_data_size)
			"Type: 0x%x, ID: 0x%x, Size: 0x%x\n",nvme_show_message(1, "Type: 0x%x, ID: 0x%x, Size: 0x%x\n", pevent_descriptor
->debug_event_class_type, event_id, pevent_descriptor->
event_data_size)
			pevent_descriptor->debug_event_class_type,nvme_show_message(1, "Type: 0x%x, ID: 0x%x, Size: 0x%x\n", pevent_descriptor
->debug_event_class_type, event_id, pevent_descriptor->
event_data_size)
			event_id,nvme_show_message(1, "Type: 0x%x, ID: 0x%x, Size: 0x%x\n", pevent_descriptor
->debug_event_class_type, event_id, pevent_descriptor->
event_data_size)
			pevent_descriptor->event_data_size)nvme_show_message(1, "Type: 0x%x, ID: 0x%x, Size: 0x%x\n", pevent_descriptor
->debug_event_class_type, event_id, pevent_descriptor->
event_data_size);
		return ret;
	}

	if (pevent_descriptor_obj != NULL((void*)0) &&
	    pevent_fifo_array != NULL((void*)0)) {
		json_array_add_value_object(pevent_fifo_array,json_object_array_add(pevent_fifo_array, pevent_descriptor_obj
)
			pevent_descriptor_obj)json_object_array_add(pevent_fifo_array, pevent_descriptor_obj
);
		pevent_descriptor_obj = NULL((void*)0);
	} else {
		if (fp)
			fprintf(fp, STR_LINE2"-----------------------------------------------------------------------------\n");
		else
			printf(STR_LINE2"-----------------------------------------------------------------------------\n");
	}
} else {
	parse_ocp_telemetry_string_log(0, event_id,
		pevent_descriptor->debug_event_class_type, EVENT_STRING,
		description_str);

	__cleanup_json_object__attribute__((cleanup(json_free_objectp)))
	struct json_object *pevent_descriptor_obj =
		((pevent_fifos_object != NULL((void*)0)) ? json_create_object()json_object_new_object() : NULL((void*)0));

	if (pevent_descriptor_obj != NULL((void*)0)) {
		json_add_formatted_u32_str(pevent_descriptor_obj,
			STR_DBG_EVENT_CLASS_TYPE"Debug Event Class type",
			pevent_descriptor->debug_event_class_type);
		json_object_add_value_string(pevent_descriptor_obj,
			STR_EVENT_STRING"Event String", description_str);
	} else {
		if (fp) {
			fprintf(fp, "%s: 0x%x\n", STR_DBG_EVENT_CLASS_TYPE"Debug Event Class type",
				pevent_descriptor->debug_event_class_type);
			fprintf(fp, "%s: %s\n", STR_EVENT_STRING"Event String", description_str);
		} else {
			printf("%s: 0x%x\n", STR_DBG_EVENT_CLASS_TYPE"Debug Event Class type",
			   pevent_descriptor->debug_event_class_type);
			printf("%s: %s\n", STR_EVENT_STRING"Event String", description_str);
		}
	}

	struct nvme_ocp_statistic_snapshot_evt_class_format
		*pStaticSnapshotEvent =
			(struct nvme_ocp_statistic_snapshot_evt_class_format *)
			pevent_descriptor;

	if (pStaticSnapshotEvent != NULL((void*)0) &&
		pStaticSnapshotEvent->stat_data_size > 0) {
		__u8 *pstatistic_entry;

		pstatistic_entry =
			(__u8 *)pStaticSnapshotEvent +
			sizeof(struct nvme_ocp_telemetry_event_descriptor);

		parse_statistic(
			(struct nvme_ocp_telemetry_statistic_descriptor *)
				pstatistic_entry,
			pevent_descriptor_obj,
			fp);
	}

	if (pevent_descriptor_obj != NULL((void*)0) &&
	    pevent_fifo_array != NULL((void*)0)) {
		json_array_add_value_object(pevent_fifo_array,json_object_array_add(pevent_fifo_array, pevent_descriptor_obj
)
			pevent_descriptor_obj)json_object_array_add(pevent_fifo_array, pevent_descriptor_obj
);
		pevent_descriptor_obj = NULL((void*)0);
	}
}
offset_to_move += (data_size + event_des_size);
}

if (pevent_fifos_object != NULL((void*)0) && pevent_fifo_array != NULL((void*)0)) {
json_object_add_value_array(pevent_fifos_object, event_fifo_name,json_object_object_add(pevent_fifos_object, event_fifo_name, pevent_fifo_array
)
	pevent_fifo_array)json_object_object_add(pevent_fifos_object, event_fifo_name, pevent_fifo_array
);
pevent_fifo_array = NULL((void*)0);
}

return ret;
1638}

1640/*
* Data Area 1 always begins with the mandatory OCP DA1 header (which in
* turn carries the DA1/DA2 statistics and event FIFO offsets/sizes). A
* controller that has never captured a telemetry log for this type
* reports Data Area 1 as empty (da1_size == 0); reading the DA1 header,
* SMART blocks, statistics, or event FIFOs out of the telemetry buffer in
* that case would run past the end of what was actually fetched/read.
*/
1648static bool_Bool telemetry_da1_header_present(
struct nvme_ocp_telemetry_offsets *poffsets)
1650{
return poffsets->da1_size >= sizeof(struct nvme_ocp_header_in_da1);
1652}

1654int parse_event_fifos(struct json_object *root, struct nvme_ocp_telemetry_offsets *poffsets,
FILE *fp)
1656{
if (poffsets == NULL((void*)0)) {
nvme_show_error("Input buffer was NULL")nvme_show_message(1, "Input buffer was NULL");
return -1;
}

if (!telemetry_da1_header_present(poffsets))
return 0;

__cleanup_json_object__attribute__((cleanup(json_free_objectp))) struct json_object *pevent_fifos_object = NULL((void*)0);

if (root != NULL((void*)0))
pevent_fifos_object = json_create_object()json_object_new_object();

__u8 *pda1_header_offset = ptelemetry_buffer + poffsets->da1_start_offset;//512
__u8 *pda2_offset = ptelemetry_buffer + poffsets->da2_start_offset;
struct nvme_ocp_header_in_da1 *pda1_header = (struct nvme_ocp_header_in_da1 *)
pda1_header_offset;
struct nvme_ocp_event_fifo_data event_fifo[MAX_NUM_FIFOS16];

for (int fifo_num = 0; fifo_num < MAX_NUM_FIFOS16; fifo_num++) {
event_fifo[fifo_num].event_fifo_num = fifo_num;
event_fifo[fifo_num].event_fifo_da = pda1_header->event_fifo_da[fifo_num];
event_fifo[fifo_num].event_fifo_start =
	le64_to_cpu(pda1_header->fifo_offsets[fifo_num].event_fifo_start);
event_fifo[fifo_num].event_fifo_size =
	le64_to_cpu(pda1_header->fifo_offsets[fifo_num].event_fifo_size);
}

//Parse all the FIFOs DA wise
for (int fifo_no = 0; fifo_no < MAX_NUM_FIFOS16; fifo_no++) {
if (event_fifo[fifo_no].event_fifo_da == poffsets->data_area) {
	__u64 start_dw = event_fifo[fifo_no].event_fifo_start;
	__u64 size_dw = event_fifo[fifo_no].event_fifo_size;
	__u64 da_dw = ((poffsets->data_area == 1) ?
		poffsets->da1_size : poffsets->da2_size) / SIZE_OF_DWORD4;
	__u64 fifo_offset, fifo_size;
	__u8 *pfifo_start = NULL((void*)0);

	if (!size_dw || start_dw > da_dw || size_dw > da_dw - start_dw) {
		nvme_show_error(nvme_show_message(1, "Invalid FIFO bounds for FIFO %d", fifo_no
)
			"Invalid FIFO bounds for FIFO %d",nvme_show_message(1, "Invalid FIFO bounds for FIFO %d", fifo_no
)
			fifo_no)nvme_show_message(1, "Invalid FIFO bounds for FIFO %d", fifo_no
);
		return -1;
	}
	fifo_offset = start_dw * SIZE_OF_DWORD4;
	fifo_size = size_dw * SIZE_OF_DWORD4;

	if (event_fifo[fifo_no].event_fifo_da == 1)
		pfifo_start = pda1_header_offset + fifo_offset;
	else if (event_fifo[fifo_no].event_fifo_da == 2)
		pfifo_start = pda2_offset + fifo_offset;
	else {
		nvme_show_error("Unsupported Data Area:[%d]", poffsets->data_area)nvme_show_message(1, "Unsupported Data Area:[%d]", poffsets->
data_area);
		return -1;
	}

	int status = parse_event_fifo(fifo_no, pfifo_start, pevent_fifos_object,
				      pstring_buffer, poffsets, fifo_size, fp);

	if (status != 0) {
		nvme_show_error("Failed to parse Event FIFO. status:%d", status)nvme_show_message(1, "Failed to parse Event FIFO. status:%d",
 status);
		return -1;
	}
}
}

if (pevent_fifos_object != NULL((void*)0) && root != NULL((void*)0)) {
json_object_add_value_array(root,json_object_object_add(root, poffsets->data_area == 1 ? "Data Area 1 Event FIFO info"
 : "Data Area 2 Event FIFO info", pevent_fifos_object)
	poffsets->data_area == 1 ? STR_DA_1_EVENT_FIFO_INFO :json_object_object_add(root, poffsets->data_area == 1 ? "Data Area 1 Event FIFO info"
 : "Data Area 2 Event FIFO info", pevent_fifos_object)
				   STR_DA_2_EVENT_FIFO_INFO,json_object_object_add(root, poffsets->data_area == 1 ? "Data Area 1 Event FIFO info"
 : "Data Area 2 Event FIFO info", pevent_fifos_object)
	pevent_fifos_object)json_object_object_add(root, poffsets->data_area == 1 ? "Data Area 1 Event FIFO info"
 : "Data Area 2 Event FIFO info", pevent_fifos_object);
pevent_fifos_object = NULL((void*)0);
}

return 0;
1732}

1734#define STAT_NESTED_INDENT"    " "    "

1736/* Where a statistic is printed: a JSON object, or text lines to fp */
1737struct stat_sink {
struct json_object *obj;
FILE *fp;
const char *indent;
1741};

1743static FILE *stat_stream(struct stat_sink *s)
1744{
return s->fp ? s->fp : stdoutstdout;
1746}

1748static void stat_add_hex(struct stat_sink *s, const char *key, __u32 value, int width)
1749{
if (s->obj)
json_add_formatted_u32_str(s->obj, key, value);
else
fprintf(stat_stream(s), "%s%s: 0x%0*x\n", s->indent, key, width, value);
1754}

1756static void stat_add_str(struct stat_sink *s, const char *key, const char *value)
1757{
if (s->obj)
json_object_add_value_string(s->obj, key, value);
else
fprintf(stat_stream(s), "%s%s: %s\n", s->indent, key, value);
1762}

1764static void stat_add_data(struct stat_sink *s, const char *key, __u8 *data, unsigned int size)
1765{
if (s->obj) {
json_add_formatted_var_size_str(s->obj, key, data, size);
} else {
fputs(s->indent, stat_stream(s));
print_formatted_var_size_str(key, data, size, stat_stream(s));
}
1772}

1774/* Returns the JSON array to add items to, NULL in text mode */
1775static struct json_object *stat_list_begin(struct stat_sink *s, const char *key)
1776{
struct json_object *array = NULL((void*)0);

if (s->obj) {
array = json_create_array()json_object_new_array();
json_object_add_value_array(s->obj, key, array)json_object_object_add(s->obj, key, array);
} else {
fprintf(stat_stream(s), "%s%s:\n", s->indent, key);
}
return array;
1786}

1788static void stat_item_begin(struct stat_sink *item, struct json_object *array, FILE *fp,
	    const char *indent)
1790{
item->obj = array ? json_create_object()json_object_new_object() : NULL((void*)0);
item->fp = fp;
item->indent = indent;
1794}

1796static void stat_item_end(struct stat_sink *item, struct json_object *array)
1797{
if (array)
json_array_add_value_object(array, item->obj)json_object_array_add(array, item->obj);
else
fprintf(stat_stream(item), "%s%s", item->indent, STR_LINE2"-----------------------------------------------------------------------------\n");
1802}

1804static __u32 get_le_field(const __u8 *p, unsigned int size)
1805{
__u32 value = 0;

while (size--)
value = (value << 8) | p[size];
return value;
1811}

1813/* Scope fields by offset into the context data (OCP 2.7 section 4.9.12) */
1814static const struct {
__u16 stat_id;
const char *name;
__u8 offset;
__u8 size;
1819} context_scope_fields[] = {
{ NAMESPACE_ID_CONTEXT_ID,  STR_CONTEXT_NAMESPACE_ID"Namespace ID",  4, 4 },
{ CONTROLLER_ID_CONTEXT_ID, STR_CONTEXT_CONTROLLER_ID"Controller ID", 6, 2 },
{ QUEUE_ID_CONTEXT_ID,      STR_CONTEXT_CONTROLLER_ID"Controller ID", 4, 2 },
{ QUEUE_ID_CONTEXT_ID,      STR_CONTEXT_QUEUE_ID"Queue ID",      6, 2 },
1824};

1826static const struct {
__u16 stat_id;
const char *percent;
const char *raw;
1830} bad_block_statistics[] = {
{ MAX_DIE_BAD_BLOCK_ID, STR_STATISTICS_WORST_DIE_PERCENT"Worst die % of bad blocks",
 STR_STATISTICS_WORST_DIE_RAW"Worst die raw number of bad blocks" },
{ MAX_NAND_CHANNEL_BAD_BLOCK_ID, STR_STATISTICS_WORST_NAND_CHANNEL_PERCENT"Worst NAND channel % of bad blocks",
 STR_STATISTICS_WORST_NAND_CHANNEL_RAW"Worst NAND channel number of bad blocks" },
{ MIN_NAND_CHANNEL_BAD_BLOCK_ID, STR_STATISTICS_BEST_NAND_CHANNEL_PERCENT"Best NAND channel % of bad blocks",
 STR_STATISTICS_BEST_NAND_CHANNEL_RAW"Best NAND channel number of bad blocks" },
1837};

1839static bool_Bool is_context_scope_id(__u16 id)
1840{
return id >= NAMESPACE_ID_CONTEXT_ID && id <= QUEUE_ID_CONTEXT_ID;
1842}

1844static bool_Bool is_context_statistic(struct nvme_ocp_telemetry_statistic_descriptor *d)
1845{
return d->statistic_info_context_index ||
is_context_scope_id(le16_to_cpu(d->statistic_id));
1848}

1850static void print_statistics(__u8 *pstats, unsigned int size, struct json_object *array,
	     FILE *fp, bool_Bool encapsulated, const char *where);

1853static void parse_context_statistic(__u16 id, __u8 *pdata, unsigned int data_size,
		    struct stat_sink *s)
1855{
struct nvme_ocp_statistic_context_data *context =
(struct nvme_ocp_statistic_context_data *)pdata;
__u16 context_size = le16_to_cpu(context->context_data_size);
char where[64];
struct json_object *array;
struct stat_sink item;
size_t i;

/*
* The encapsulated descriptors follow the context data whatever its
* declared size, so an invalid Context Data Size is only reported.
*/
if (!context_size || context_size > data_size / SIZE_OF_DWORD4)
nvme_show_error("Context Statistic 0x%x: "nvme_show_message(1, "Context Statistic 0x%x: " "Context Data Size 0x%x is outside 1 to 0x%x"
, id, context_size, data_size / 4)
		"Context Data Size 0x%x is outside 1 to 0x%x",nvme_show_message(1, "Context Statistic 0x%x: " "Context Data Size 0x%x is outside 1 to 0x%x"
, id, context_size, data_size / 4)
		id, context_size, data_size / SIZE_OF_DWORD)nvme_show_message(1, "Context Statistic 0x%x: " "Context Data Size 0x%x is outside 1 to 0x%x"
, id, context_size, data_size / 4);

stat_add_hex(s, STR_CONTEXT_DATA_SIZE"Context Data Size", context_size, 0);
stat_add_hex(s, STR_CONTEXT_DATA_RESERVED"Context Data Reserved", le16_to_cpu(context->reserved), 0);
stat_add_data(s, STR_CONTEXT_SCOPE"Context Scope", context->scope, sizeof(context->scope));

if (is_context_scope_id(id)) {
array = stat_list_begin(s, STR_CONTEXT_SCOPE_FIELDS"Context Scope Fields");
for (i = 0; i < ARRAY_SIZE(context_scope_fields)(sizeof(context_scope_fields) / sizeof((context_scope_fields)
[0]) + 0); i++) {
	__u8 offset = context_scope_fields[i].offset;
	__u8 size = context_scope_fields[i].size;

	if (context_scope_fields[i].stat_id != id)
		continue;
	stat_item_begin(&item, array, s->fp, STAT_NESTED_INDENT"    ");
	stat_add_str(&item, STR_SCOPE_FIELD_STRING"Scope Field String", context_scope_fields[i].name);
	stat_add_hex(&item, STR_SCOPE_FIELD_OFFSET"Scope Field Offset", offset, 0);
	stat_add_hex(&item, STR_SCOPE_FIELD_SIZE"Scope Field Size", size, 0);
	stat_add_hex(&item, STR_SCOPE_FIELD_VALUE"Scope Field Value",
		     get_le_field(pdata + offset, size), 0);
	stat_item_end(&item, array);
}
}

snprintf(where, sizeof(where),
 "Encapsulated Statistic Descriptors of Context Statistic 0x%x", id);
array = stat_list_begin(s, STR_ENCAPSULATED_STATISTICS"Encapsulated Statistic Descriptors");
print_statistics(pdata + sizeof(*context), data_size - sizeof(*context), array, s->fp,
	 true1, where);
1900}

1902/*
* Prints a statistic as a new object of @pstats_array, into the existing
* object @pstat_obj, or as text.
*/
1906static void print_statistic(struct nvme_ocp_telemetry_statistic_descriptor *pstatistic_entry,
	    struct json_object *pstats_array,
	    struct json_object *pstat_obj, FILE *fp,
	    bool_Bool encapsulated)
1910{
__u16 id = le16_to_cpu(pstatistic_entry->statistic_id);
__u16 data_dwords = le16_to_cpu(pstatistic_entry->statistic_data_size);
unsigned int data_size = data_dwords * SIZE_OF_DWORD4;
__u8 *pdata = (__u8 *)pstatistic_entry + sizeof(*pstatistic_entry);
char description_str[OCP_TELEMETRY_DESCRIPTION_MAX256] = "";
bool_Bool context = is_context_statistic(pstatistic_entry);
struct stat_sink s;
size_t i;

parse_ocp_telemetry_string_log(0, id, 0, STATISTICS_IDENTIFIER_STRING, description_str);

stat_item_begin(&s, pstats_array, fp, encapsulated ? STAT_NESTED_INDENT"    " : "");
if (pstat_obj)
s.obj = pstat_obj;
stat_add_hex(&s, STR_STATISTICS_IDENTIFIER"Statistics Identifier", id, 0);
stat_add_str(&s, STR_STATISTICS_IDENTIFIER_STR"Statistic Identifier String", description_str);
stat_add_hex(&s, STR_STATISTICS_INFO_BEHAVIOUR_TYPE"Statistics Info Behavior Type",
     pstatistic_entry->statistic_info_behaviour_type, 0);
stat_add_hex(&s, STR_STATISTICS_INFO_CONTEXT_INDEX"Statistics Info Context Index",
     pstatistic_entry->statistic_info_context_index, 0);
stat_add_hex(&s, STR_STATISTICS_INFO_HOST_HINT_TYPE"Statistics Info Host Hint Type",
     pstatistic_entry->statistic_info_host_hint_type, 0);
stat_add_hex(&s, STR_STATISTICS_INFO_RESERVED"Statistics Info Reserved",
     pstatistic_entry->statistic_info_reserved, 0);
stat_add_hex(&s, STR_NAMESPACE_IDENTIFIER"Namespace Identifier", pstatistic_entry->ns_info_nsid, 0);
stat_add_hex(&s, STR_NAMESPACE_INFO_VALID"Namespace Information Valid", pstatistic_entry->ns_info_ns_info_valid, 0);
stat_add_hex(&s, STR_STATISTICS_DATA_SIZE"Statistic Data Size", data_dwords, 0);
stat_add_hex(&s, STR_NAMESPACE_IDENTIFIER_15_0"Namespace Identifier[15:0]",
     le16_to_cpu(pstatistic_entry->ns_identifier_15_0), 0);

/* Context Statistic Descriptors do not nest; the walk reports one that does */
if (context && !encapsulated) {
if (data_dwords >= CONTEXT_DATA_DWORDS2) {
	parse_context_statistic(id, pdata, data_size, &s);
	goto out;
}
nvme_show_error("Context Statistic 0x%x: %u data bytes cannot hold "nvme_show_message(1, "Context Statistic 0x%x: %u data bytes cannot hold "
 "its context data", id, data_size)
		"its context data", id, data_size)nvme_show_message(1, "Context Statistic 0x%x: %u data bytes cannot hold "
 "its context data", id, data_size);
}

for (i = 0; !context && data_size >= 4 && i < ARRAY_SIZE(bad_block_statistics)(sizeof(bad_block_statistics) / sizeof((bad_block_statistics)
[0]) + 0); i++) {
if (bad_block_statistics[i].stat_id != id)
	continue;
stat_add_hex(&s, bad_block_statistics[i].percent, pdata[0], 2);
stat_add_hex(&s, bad_block_statistics[i].raw, get_le_field(pdata + 2, 2), 4);
goto out;
}

stat_add_data(&s, STR_STATISTICS_SPECIFIC_DATA"Statistic Specific Data", pdata, data_size);
1960out:
if (!pstat_obj)
stat_item_end(&s, pstats_array);
1963}

1965/*
* Prints the statistic descriptors in the @size bytes at @pstats, up to the
* first reserved identifier or the first descriptor that does not fit.
*/
1969static void print_statistics(__u8 *pstats, unsigned int size, struct json_object *array,
	     FILE *fp, bool_Bool encapsulated, const char *where)
1971{
struct nvme_ocp_telemetry_statistic_descriptor *pstatistic_entry;
unsigned int offset = 0, left, data_size;
__u16 id;

/* Sizes are in Dwords, so the identifier always fits */
while (offset < size) {
pstatistic_entry = (struct nvme_ocp_telemetry_statistic_descriptor *)
	(pstats + offset);
id = le16_to_cpu(pstatistic_entry->statistic_id);
left = size - offset;

if (id == STATISTICS_RESERVED_ID)
	break;
if (left < sizeof(*pstatistic_entry)) {
	nvme_show_error("Invalid statistic at offset 0x%x of %s: "nvme_show_message(1, "Invalid statistic at offset 0x%x of %s: "
 "descriptor needs %zu bytes, %u left", offset, where, sizeof
(*pstatistic_entry), left)
			"descriptor needs %zu bytes, %u left",nvme_show_message(1, "Invalid statistic at offset 0x%x of %s: "
 "descriptor needs %zu bytes, %u left", offset, where, sizeof
(*pstatistic_entry), left)
			offset, where, sizeof(*pstatistic_entry), left)nvme_show_message(1, "Invalid statistic at offset 0x%x of %s: "
 "descriptor needs %zu bytes, %u left", offset, where, sizeof
(*pstatistic_entry), left);
	break;
}
data_size = le16_to_cpu(pstatistic_entry->statistic_data_size) * SIZE_OF_DWORD4;
if (left - sizeof(*pstatistic_entry) < data_size) {
	nvme_show_error("Invalid statistic at offset 0x%x of %s: "nvme_show_message(1, "Invalid statistic at offset 0x%x of %s: "
 "Statistic ID 0x%x declares %u data bytes, %zu left", offset
, where, id, data_size, left - sizeof(*pstatistic_entry))
			"Statistic ID 0x%x declares %u data bytes, %zu left",nvme_show_message(1, "Invalid statistic at offset 0x%x of %s: "
 "Statistic ID 0x%x declares %u data bytes, %zu left", offset
, where, id, data_size, left - sizeof(*pstatistic_entry))
			offset, where, id, data_size,nvme_show_message(1, "Invalid statistic at offset 0x%x of %s: "
 "Statistic ID 0x%x declares %u data bytes, %zu left", offset
, where, id, data_size, left - sizeof(*pstatistic_entry))
			left - sizeof(*pstatistic_entry))nvme_show_message(1, "Invalid statistic at offset 0x%x of %s: "
 "Statistic ID 0x%x declares %u data bytes, %zu left", offset
, where, id, data_size, left - sizeof(*pstatistic_entry));
	break;
}
if (encapsulated && is_context_statistic(pstatistic_entry))
	nvme_show_error("Invalid statistic at offset 0x%x of %s: "nvme_show_message(1, "Invalid statistic at offset 0x%x of %s: "
 "Context Statistic Descriptor 0x%x does not nest", offset, where
, id)
			"Context Statistic Descriptor 0x%x does not nest",nvme_show_message(1, "Invalid statistic at offset 0x%x of %s: "
 "Context Statistic Descriptor 0x%x does not nest", offset, where
, id)
			offset, where, id)nvme_show_message(1, "Invalid statistic at offset 0x%x of %s: "
 "Context Statistic Descriptor 0x%x does not nest", offset, where
, id);

print_statistic(pstatistic_entry, array, NULL((void*)0), fp,
		encapsulated);

/*
 * A Context Statistic Descriptor's data size spans its context
 * data and its encapsulated descriptors.
 */
offset += sizeof(*pstatistic_entry) + data_size;
}
2013}

2015int parse_statistic(struct nvme_ocp_telemetry_statistic_descriptor *pstatistic_entry,
    struct json_object *pstat_obj, FILE *fp)
2017{
if (pstatistic_entry == NULL((void*)0)) {
nvme_show_error("Statistics Input buffer was NULL")nvme_show_message(1, "Statistics Input buffer was NULL");
return -1;
}

if (le16_to_cpu(pstatistic_entry->statistic_id) == STATISTICS_RESERVED_ID)
/* End of statistics entries, return -1 to stop processing the buffer */
return -1;

print_statistic(pstatistic_entry, NULL((void*)0), pstat_obj, fp, false0);
return 0;
2029}

2031int parse_statistics(struct json_object *root, struct nvme_ocp_telemetry_offsets *poffsets,
     FILE *fp)
2033{
if (poffsets == NULL((void*)0)) {
nvme_show_error("Input buffer was NULL")nvme_show_message(1, "Input buffer was NULL");
return -1;
}

if (!telemetry_da1_header_present(poffsets))
return 0;

__u8 *pda1_ocp_header_offset = ptelemetry_buffer + poffsets->header_size;//512
struct nvme_ocp_header_in_da1 *pda1_header =
(struct nvme_ocp_header_in_da1 *)pda1_ocp_header_offset;
__u64 start_dw, size_dw, da_dw;
__u8 *pda_offset = NULL((void*)0);
char where[16];

//Data is present in the form of DWORDS, So multiplying with sizeof(DWORD)
if (poffsets->data_area == 1) {
start_dw = le64_to_cpu(pda1_header->da1_statistic_start);
size_dw = le64_to_cpu(pda1_header->da1_statistic_size);
da_dw = poffsets->da1_size / SIZE_OF_DWORD4;
pda_offset = pda1_ocp_header_offset;
} else if (poffsets->data_area == 2) {
start_dw = le64_to_cpu(pda1_header->da2_statistic_start);
size_dw = le64_to_cpu(pda1_header->da2_statistic_size);
da_dw = poffsets->da2_size / SIZE_OF_DWORD4;
pda_offset = ptelemetry_buffer + poffsets->da2_start_offset;
} else {
nvme_show_error("Unsupported Data Area:[%d]", poffsets->data_area)nvme_show_message(1, "Unsupported Data Area:[%d]", poffsets->
data_area);
return -1;
}

/* With no statistics, the start is never used */
if (!size_dw) {
start_dw = 0;
} else if (start_dw > da_dw || size_dw > da_dw - start_dw) {
nvme_show_error("Invalid statistics bounds for Data Area %d",nvme_show_message(1, "Invalid statistics bounds for Data Area %d"
, poffsets->data_area)
		poffsets->data_area)nvme_show_message(1, "Invalid statistics bounds for Data Area %d"
, poffsets->data_area);
return -1;
}

struct json_object *pstats_array = ((root != NULL((void*)0)) ? json_create_array()json_object_new_array() : NULL((void*)0));

snprintf(where, sizeof(where), "Data Area %d", poffsets->data_area);
print_statistics(pda_offset + start_dw * SIZE_OF_DWORD4, size_dw * SIZE_OF_DWORD4,
	 pstats_array, fp, false0, where);

if (root != NULL((void*)0) && pstats_array != NULL((void*)0))
json_object_add_value_array(root,json_object_object_add(root, poffsets->data_area == 1 ? "Data Area 1 Statistics"
 : "Data Area 2 Statistics", pstats_array)
	poffsets->data_area == 1 ? STR_DA_1_STATS : STR_DA_2_STATS,json_object_object_add(root, poffsets->data_area == 1 ? "Data Area 1 Statistics"
 : "Data Area 2 Statistics", pstats_array)
	pstats_array)json_object_object_add(root, poffsets->data_area == 1 ? "Data Area 1 Statistics"
 : "Data Area 2 Statistics", pstats_array);

return 0;
2086}

2088static void parse_log_page_header(struct json_object *pobject, FILE *fp)
2089{
if (ptelemetry_buffer[0] == NVME_LOG_LID_TELEMETRY_CTRL)
generic_structure_parser(ptelemetry_buffer,
	controller_log_page_header,
	ARRAY_SIZE(controller_log_page_header)(sizeof(controller_log_page_header) / sizeof((controller_log_page_header
)[0]) + 0), pobject, 0, fp);
else
generic_structure_parser(ptelemetry_buffer,
	host_log_page_header,
	ARRAY_SIZE(host_log_page_header)(sizeof(host_log_page_header) / sizeof((host_log_page_header)
[0]) + 0), pobject, 0, fp);
2098}

2100int print_ocp_telemetry_normal(struct ocp_telemetry_parse_options *options)
2101{
int status = 0;
char file_path[PATH_MAX4096];
FILE *fp = stdoutstdout;

if (ptelemetry_buffer == NULL((void*)0)) {
nvme_show_error("No telemetry data to parse.")nvme_show_message(1, "No telemetry data to parse.");
return -1;
}

if (options->output_file != NULL((void*)0)) {
snprintf(file_path, sizeof(file_path), "%s.%s",
	 options->output_file, "txt");
fp = fopen(file_path, "w");
if (!fp) {
	nvme_show_error("Failed to open %s file.", file_path)nvme_show_message(1, "Failed to open %s file.", file_path);
	return -1;
}
}

fprintf(fp, STR_LINE"==============================================================================\n");
fprintf(fp, "%s\n", STR_LOG_PAGE_HEADER"Log Page Header");
fprintf(fp, STR_LINE"==============================================================================\n");
parse_log_page_header(NULL((void*)0), fp);
fprintf(fp, STR_LINE"==============================================================================\n");
fprintf(fp, "%s\n", STR_REASON_IDENTIFIER"Reason Identifier");
fprintf(fp, STR_LINE"==============================================================================\n");
__u8 *preason_identifier_offset = ptelemetry_buffer +
offsetof(struct nvme_ocp_telemetry_host_initiated_header,__builtin_offsetof(struct nvme_ocp_telemetry_host_initiated_header
, reason_id)
	 reason_id)__builtin_offsetof(struct nvme_ocp_telemetry_host_initiated_header
, reason_id);

generic_structure_parser(preason_identifier_offset, reason_identifier,
ARRAY_SIZE(reason_identifier)(sizeof(reason_identifier) / sizeof((reason_identifier)[0]) +
 0), NULL((void*)0), 0, fp);

fprintf(fp, STR_LINE"==============================================================================\n");
fprintf(fp, "%s\n", STR_TELEMETRY_HOST_DATA_BLOCK_1"Telemetry Host-Initiated Data Block 1");
fprintf(fp, STR_LINE"==============================================================================\n");

//Set DA to 1 and get offsets
struct nvme_ocp_telemetry_offsets offsets = { 0 };

offsets.data_area = 1;// Default DA - DA1

struct nvme_ocp_telemetry_common_header *ptelemetry_common_header =
(struct nvme_ocp_telemetry_common_header *) ptelemetry_buffer;

get_telemetry_das_offset_and_size(ptelemetry_common_header, ptelemetry_buffer_size,
			  &offsets);

__u8 *pda1_header_offset = ptelemetry_buffer +
offsets.da1_start_offset;//512

if (telemetry_da1_header_present(&offsets)) {
generic_structure_parser(
	pda1_header_offset, ocp_header_in_da1,
	ARRAY_SIZE(ocp_header_in_da1)(sizeof(ocp_header_in_da1) / sizeof((ocp_header_in_da1)[0]) +
 0), NULL((void*)0), 0, fp);

fprintf(fp, STR_LINE"==============================================================================\n");
fprintf(fp, "%s\n", STR_SMART_HEALTH_INFO"SMART / Health Information Log(LID-02h)");
fprintf(fp, STR_LINE"==============================================================================\n");
__u8 *pda1_smart_offset = pda1_header_offset +
	offsetof(struct nvme_ocp_header_in_da1,__builtin_offsetof(struct nvme_ocp_header_in_da1, smart_health_info
)
		 smart_health_info)__builtin_offsetof(struct nvme_ocp_header_in_da1, smart_health_info
);
//512+512 =1024

generic_structure_parser(pda1_smart_offset, smart,
	ARRAY_SIZE(smart)(sizeof(smart) / sizeof((smart)[0]) + 0), NULL((void*)0), 0, fp);

fprintf(fp, STR_LINE"==============================================================================\n");
fprintf(fp, "%s\n", STR_SMART_HEALTH_INTO_EXTENDED"SMART / Health Information Extended(LID-C0h)");
fprintf(fp, STR_LINE"==============================================================================\n");
__u8 *pda1_smart_ext_offset = pda1_header_offset +
	offsetof(struct nvme_ocp_header_in_da1,__builtin_offsetof(struct nvme_ocp_header_in_da1, smart_health_info_extended
)
		 smart_health_info_extended)__builtin_offsetof(struct nvme_ocp_header_in_da1, smart_health_info_extended
);

generic_structure_parser(
	pda1_smart_ext_offset, smart_extended,
	ARRAY_SIZE(smart_extended)(sizeof(smart_extended) / sizeof((smart_extended)[0]) + 0), NULL((void*)0), 0, fp);
}

fprintf(fp, STR_LINE"==============================================================================\n");
fprintf(fp, "%s\n", STR_DA_1_STATS"Data Area 1 Statistics");
fprintf(fp, STR_LINE"==============================================================================\n");

status = parse_statistics(NULL((void*)0), &offsets, fp);
if (status != 0) {
nvme_show_error("status: %d", status)nvme_show_message(1, "status: %d", status);
status = -1;
goto out;
}

fprintf(fp, STR_LINE"==============================================================================\n");
fprintf(fp, "%s\n", STR_DA_1_EVENT_FIFO_INFO"Data Area 1 Event FIFO info");
fprintf(fp, STR_LINE"==============================================================================\n");
status = parse_event_fifos(NULL((void*)0), &offsets, fp);
if (status != 0) {
status = -1;
goto out;
}

//Set the DA to 2
if (options->data_area >= DATA_AREA_2) {
offsets.data_area = 2;
fprintf(fp, STR_LINE"==============================================================================\n");
fprintf(fp, "%s\n", STR_DA_2_STATS"Data Area 2 Statistics");
fprintf(fp, STR_LINE"==============================================================================\n");
status = parse_statistics(NULL((void*)0), &offsets, fp);
if (status != 0) {
	nvme_show_error("status: %d", status)nvme_show_message(1, "status: %d", status);
	status = -1;
	goto out;
}

fprintf(fp, STR_LINE"==============================================================================\n");
fprintf(fp, "%s\n", STR_DA_2_EVENT_FIFO_INFO"Data Area 2 Event FIFO info");
fprintf(fp, STR_LINE"==============================================================================\n");
status = parse_event_fifos(NULL((void*)0), &offsets, fp);
if (status != 0) {
	status = -1;
	goto out;
}
}

fprintf(fp, STR_LINE"==============================================================================\n");
2225out:
if (fp != stdoutstdout)
fclose(fp);

return status;
2230}

2232#ifdef CONFIG_JSONC
2233int print_ocp_telemetry_json(struct ocp_telemetry_parse_options *options)
2234{
int status = 0;
char file_path[PATH_MAX4096];

//create json objects
struct json_object *root, *pheader, *preason_identifier, *da1_header, *smart_obj,
*ext_smart_obj;

root = json_create_object()json_object_new_object();

//Add data to root json object

//"Log Page Header"
pheader = json_create_object()json_object_new_object();

parse_log_page_header(pheader, NULL((void*)0));
json_object_add_value_object(root, STR_LOG_PAGE_HEADER, pheader)json_object_object_add(root, "Log Page Header", pheader);

//"Reason Identifier"
preason_identifier = json_create_object()json_object_new_object();

__u8 *preason_identifier_offset = ptelemetry_buffer +
offsetof(struct nvme_ocp_telemetry_host_initiated_header, reason_id)__builtin_offsetof(struct nvme_ocp_telemetry_host_initiated_header
, reason_id);

generic_structure_parser(preason_identifier_offset, reason_identifier,
	     ARRAY_SIZE(reason_identifier)(sizeof(reason_identifier) / sizeof((reason_identifier)[0]) +
 0), preason_identifier, 0, NULL((void*)0));
json_object_add_value_object(pheader, STR_REASON_IDENTIFIER, preason_identifier)json_object_object_add(pheader, "Reason Identifier", preason_identifier
);

struct nvme_ocp_telemetry_offsets offsets = { 0 };

//Set DA to 1 and get offsets
offsets.data_area = 1;
struct nvme_ocp_telemetry_common_header *ptelemetry_common_header =
(struct nvme_ocp_telemetry_common_header *) ptelemetry_buffer;

get_telemetry_das_offset_and_size(ptelemetry_common_header, ptelemetry_buffer_size,
			  &offsets);

//"Telemetry Host-Initiated Data Block 1"
__u8 *pda1_header_offset = ptelemetry_buffer + offsets.da1_start_offset;//512

if (telemetry_da1_header_present(&offsets)) {
da1_header = json_create_object()json_object_new_object();

generic_structure_parser(
	pda1_header_offset, ocp_header_in_da1,
	ARRAY_SIZE(ocp_header_in_da1)(sizeof(ocp_header_in_da1) / sizeof((ocp_header_in_da1)[0]) +
 0), da1_header, 0, NULL((void*)0));
json_object_add_value_object(root,json_object_object_add(root, "Telemetry Host-Initiated Data Block 1"
, da1_header)
			      STR_TELEMETRY_HOST_DATA_BLOCK_1,json_object_object_add(root, "Telemetry Host-Initiated Data Block 1"
, da1_header)
			      da1_header)json_object_object_add(root, "Telemetry Host-Initiated Data Block 1"
, da1_header);

//"SMART / Health Information Log(LID-02h)"
__u8 *pda1_smart_offset = pda1_header_offset +
	offsetof(struct nvme_ocp_header_in_da1,__builtin_offsetof(struct nvme_ocp_header_in_da1, smart_health_info
)
		 smart_health_info)__builtin_offsetof(struct nvme_ocp_header_in_da1, smart_health_info
);
smart_obj = json_create_object()json_object_new_object();

generic_structure_parser(pda1_smart_offset, smart,
			  ARRAY_SIZE(smart)(sizeof(smart) / sizeof((smart)[0]) + 0), smart_obj, 0,
			  NULL((void*)0));
json_object_add_value_object(da1_header, STR_SMART_HEALTH_INFO,json_object_object_add(da1_header, "SMART / Health Information Log(LID-02h)"
, smart_obj)
			      smart_obj)json_object_object_add(da1_header, "SMART / Health Information Log(LID-02h)"
, smart_obj);

//"SMART / Health Information Extended(LID-C0h)"
__u8 *pda1_smart_ext_offset = pda1_header_offset +
	offsetof(struct nvme_ocp_header_in_da1,__builtin_offsetof(struct nvme_ocp_header_in_da1, smart_health_info_extended
)
		 smart_health_info_extended)__builtin_offsetof(struct nvme_ocp_header_in_da1, smart_health_info_extended
);
ext_smart_obj = json_create_object()json_object_new_object();

generic_structure_parser(
	pda1_smart_ext_offset, smart_extended,
	ARRAY_SIZE(smart_extended)(sizeof(smart_extended) / sizeof((smart_extended)[0]) + 0), ext_smart_obj, 0, NULL((void*)0));
json_object_add_value_object(da1_header,json_object_object_add(da1_header, "SMART / Health Information Extended(LID-C0h)"
, ext_smart_obj)
			      STR_SMART_HEALTH_INTO_EXTENDED,json_object_object_add(da1_header, "SMART / Health Information Extended(LID-C0h)"
, ext_smart_obj)
			      ext_smart_obj)json_object_object_add(da1_header, "SMART / Health Information Extended(LID-C0h)"
, ext_smart_obj);
}

//Data Area 1 Statistics
status = parse_statistics(root, &offsets, NULL((void*)0));
if (status != 0) {
nvme_show_error("status: %d", status)nvme_show_message(1, "status: %d", status);
status = -1;
goto out;
}

//Data Area 1 Event FIFOs
status = parse_event_fifos(root, &offsets, NULL((void*)0));
if (status != 0) {
status = -1;
goto out;
}

if (options->data_area >= DATA_AREA_2) {
//Set the DA to 2
offsets.data_area = 2;
//Data Area 2 Statistics
status = parse_statistics(root, &offsets, NULL((void*)0));
if (status != 0) {
	nvme_show_error("status: %d", status)nvme_show_message(1, "status: %d", status);
	status = -1;
	goto out;
}

//Data Area 2 Event FIFOs
status = parse_event_fifos(root, &offsets, NULL((void*)0));
if (status != 0) {
	status = -1;
	goto out;
}
}

if (options->output_file != NULL((void*)0)) {
const char *json_string = json_object_to_json_string(root);
snprintf(file_path, sizeof(file_path), "%s.%s",
	 options->output_file, "json");
FILE *fp = fopen(file_path, "w");

if (fp) {
	fputs(json_string, fp);
	fclose(fp);
} else {
	nvme_show_error("Failed to open %s file.", file_path)nvme_show_message(1, "Failed to open %s file.", file_path);
	status = -1;
}
} else {
//Print root json object
json_print_object(root, NULL)printf("%s", json_object_to_json_string_ext(root, (1 <<
 1) | (1 << 4)));
nvme_show_result("\n")nvme_show_message(0, "\n");
}

2364out:
json_free_object(root)json_object_put(root);

return status;
2368}
2369#endif /* CONFIG_JSONC */