nvme: Use correct json serializing for long doubles

Fixup all places which use json_object_add_value_float() to serialize
long double types with json_object_add_value_double(). The float
version cuts off the upper 64 bits of the 128 bit long double type.

Signed-off-by: Daniel Wagner <dwagner@suse.de>

diff --git a/nvme-print.c b/nvme-print.c
index 8e09fed75cee7c612b232389af81072659c62d6c..2398bfe5346d302ded751361742658c388c1e0a9 100644 (file)
--- a/nvme-print.c
+++ b/nvme-print.c
@@ -186,7 +186,7 @@ static void json_nvme_id_ns(struct nvme_id_ns *ns, bool cap_only)
                json_object_add_value_int(root, "nabo", le16_to_cpu(ns->nabo));
                json_object_add_value_int(root, "nabspf", le16_to_cpu(ns->nabspf));
                json_object_add_value_int(root, "noiob", le16_to_cpu(ns->noiob));
-               json_object_add_value_float(root, "nvmcap", nvmcap);
+               json_object_add_value_double(root, "nvmcap", nvmcap);
                json_object_add_value_int(root, "nsattr", ns->nsattr);
                json_object_add_value_int(root, "nvmsetid", le16_to_cpu(ns->nvmsetid));
 
@@ -299,8 +299,8 @@ static void json_nvme_id_ctrl(struct nvme_id_ctrl *ctrl,
        json_object_add_value_int(root, "mtfa", le16_to_cpu(ctrl->mtfa));
        json_object_add_value_uint(root, "hmpre", le32_to_cpu(ctrl->hmpre));
        json_object_add_value_uint(root, "hmmin", le32_to_cpu(ctrl->hmmin));
-       json_object_add_value_float(root, "tnvmcap", tnvmcap);
-       json_object_add_value_float(root, "unvmcap", unvmcap);
+       json_object_add_value_double(root, "tnvmcap", tnvmcap);
+       json_object_add_value_double(root, "unvmcap", unvmcap);
        json_object_add_value_uint(root, "rpmbs", le32_to_cpu(ctrl->rpmbs));
        json_object_add_value_int(root, "edstt", le16_to_cpu(ctrl->edstt));
        json_object_add_value_int(root, "dsto", ctrl->dsto);
@@ -322,7 +322,7 @@ static void json_nvme_id_ctrl(struct nvme_id_ctrl *ctrl,
        json_object_add_value_int(root, "nanagrpid",
                le32_to_cpu(ctrl->nanagrpid));
        json_object_add_value_int(root, "domainid", le16_to_cpu(ctrl->domainid));
-       json_object_add_value_float(root, "megcap", megcap);
+       json_object_add_value_double(root, "megcap", megcap);
        json_object_add_value_int(root, "sqes", ctrl->sqes);
        json_object_add_value_int(root, "cqes", ctrl->cqes);
        json_object_add_value_int(root, "maxcmd", le16_to_cpu(ctrl->maxcmd));
@@ -338,7 +338,7 @@ static void json_nvme_id_ctrl(struct nvme_id_ctrl *ctrl,
        json_object_add_value_int(root, "acwu", le16_to_cpu(ctrl->acwu));
        json_object_add_value_int(root, "ocfs", le16_to_cpu(ctrl->ocfs));
        json_object_add_value_int(root, "sgls", le32_to_cpu(ctrl->sgls));
-       json_object_add_value_float(root, "maxdna", maxdna);
+       json_object_add_value_double(root, "maxdna", maxdna);
        json_object_add_value_int(root, "maxcna", le32_to_cpu(ctrl->maxcna));
 
        if (strlen(subnqn))
@@ -612,18 +612,18 @@ static void json_endurance_log(struct nvme_endurance_group_log *endurance_group,
                endurance_group->avl_spare_threshold);
        json_object_add_value_int(root, "percent_used",
                endurance_group->percent_used);
-       json_object_add_value_float(root, "endurance_estimate",
+       json_object_add_value_double(root, "endurance_estimate",
                endurance_estimate);
-       json_object_add_value_float(root, "data_units_read", data_units_read);
-       json_object_add_value_float(root, "data_units_written",
+       json_object_add_value_double(root, "data_units_read", data_units_read);
+       json_object_add_value_double(root, "data_units_written",
                data_units_written);
-       json_object_add_value_float(root, "mediate_write_commands",
+       json_object_add_value_double(root, "mediate_write_commands",
                media_units_written);
-       json_object_add_value_float(root, "host_read_cmds", host_read_cmds);
-       json_object_add_value_float(root, "host_write_cmds", host_write_cmds);
-       json_object_add_value_float(root, "media_data_integrity_err",
+       json_object_add_value_double(root, "host_read_cmds", host_read_cmds);
+       json_object_add_value_double(root, "host_write_cmds", host_write_cmds);
+       json_object_add_value_double(root, "media_data_integrity_err",
                media_data_integrity_err);
-       json_object_add_value_float(root, "num_err_info_log_entries",
+       json_object_add_value_double(root, "num_err_info_log_entries",
                num_err_info_log_entries);
 
        json_print_object(root, NULL);
@@ -676,20 +676,20 @@ static void json_smart_log(struct nvme_smart_log *smart, unsigned int nsid,
        json_object_add_value_int(root, "percent_used", smart->percent_used);
        json_object_add_value_int(root, "endurance_grp_critical_warning_summary",
                smart->endu_grp_crit_warn_sumry);
-       json_object_add_value_float(root, "data_units_read", data_units_read);
-       json_object_add_value_float(root, "data_units_written",
+       json_object_add_value_double(root, "data_units_read", data_units_read);
+       json_object_add_value_double(root, "data_units_written",
                data_units_written);
-       json_object_add_value_float(root, "host_read_commands",
+       json_object_add_value_double(root, "host_read_commands",
                host_read_commands);
-       json_object_add_value_float(root, "host_write_commands",
+       json_object_add_value_double(root, "host_write_commands",
                host_write_commands);
-       json_object_add_value_float(root, "controller_busy_time",
+       json_object_add_value_double(root, "controller_busy_time",
                controller_busy_time);
-       json_object_add_value_float(root, "power_cycles", power_cycles);
-       json_object_add_value_float(root, "power_on_hours", power_on_hours);
-       json_object_add_value_float(root, "unsafe_shutdowns", unsafe_shutdowns);
-       json_object_add_value_float(root, "media_errors", media_errors);
-       json_object_add_value_float(root, "num_err_log_entries",
+       json_object_add_value_double(root, "power_cycles", power_cycles);
+       json_object_add_value_double(root, "power_on_hours", power_on_hours);
+       json_object_add_value_double(root, "unsafe_shutdowns", unsafe_shutdowns);
+       json_object_add_value_double(root, "media_errors", media_errors);
+       json_object_add_value_double(root, "num_err_log_entries",
                num_err_log_entries);
        json_object_add_value_uint(root, "warning_temp_time",
                        le32_to_cpu(smart->warning_temp_time));
@@ -1191,7 +1191,7 @@ static void json_persistent_event_log(void *pevent_log_info, __u32 size)
                        le16_to_cpu(pevent_log_head->lhl));
                json_object_add_value_uint64(root, "timestamp",
                        le64_to_cpu(pevent_log_head->ts));
-               json_object_add_value_float(root, "power_on_hours",
+               json_object_add_value_double(root, "power_on_hours",
                        int128_to_double(pevent_log_head->poh));
                json_object_add_value_uint64(root, "power_cycle_count",
                        le64_to_cpu(pevent_log_head->pcc));
@@ -1280,25 +1280,25 @@ static void json_persistent_event_log(void *pevent_log_info, __u32 size)
                        json_object_add_value_int(valid_attrs,
                                "endurance_grp_critical_warning_summary",
                                smart_event->endu_grp_crit_warn_sumry);
-                       json_object_add_value_float(valid_attrs, "data_units_read",
+                       json_object_add_value_double(valid_attrs, "data_units_read",
                                data_units_read);
-                       json_object_add_value_float(valid_attrs, "data_units_written",
+                       json_object_add_value_double(valid_attrs, "data_units_written",
                                data_units_written);
-                       json_object_add_value_float(valid_attrs, "host_read_commands",
+                       json_object_add_value_double(valid_attrs, "host_read_commands",
                                host_read_commands);
-                       json_object_add_value_float(valid_attrs, "host_write_commands",
+                       json_object_add_value_double(valid_attrs, "host_write_commands",
                                host_write_commands);
-                       json_object_add_value_float(valid_attrs, "controller_busy_time",
+                       json_object_add_value_double(valid_attrs, "controller_busy_time",
                                controller_busy_time);
-                       json_object_add_value_float(valid_attrs, "power_cycles",
+                       json_object_add_value_double(valid_attrs, "power_cycles",
                                power_cycles);
-                       json_object_add_value_float(valid_attrs, "power_on_hours",
+                       json_object_add_value_double(valid_attrs, "power_on_hours",
                                power_on_hours);
-                       json_object_add_value_float(valid_attrs, "unsafe_shutdowns",
+                       json_object_add_value_double(valid_attrs, "unsafe_shutdowns",
                                unsafe_shutdowns);
-                       json_object_add_value_float(valid_attrs, "media_errors",
+                       json_object_add_value_double(valid_attrs, "media_errors",
                                media_errors);
-                       json_object_add_value_float(valid_attrs, "num_err_log_entries",
+                       json_object_add_value_double(valid_attrs, "num_err_log_entries",
                                num_err_log_entries);
                        json_object_add_value_uint(valid_attrs, "warning_temp_time",
                                        le32_to_cpu(smart_event->warning_temp_time));
@@ -2263,9 +2263,9 @@ static void json_supported_cap_config_log(
                                le16_to_cpu(cap_log->cap_config_desc[i].egcd[j].endgid));
                        json_object_add_value_uint(endurance, "cap_adj_factor",
                                le16_to_cpu(cap_log->cap_config_desc[i].egcd[j].cap_adj_factor));
-                       json_object_add_value_float(endurance, "tegcap",
+                       json_object_add_value_double(endurance, "tegcap",
                                int128_to_double(cap_log->cap_config_desc[i].egcd[j].tegcap));
-                       json_object_add_value_float(endurance, "segcap",
+                       json_object_add_value_double(endurance, "segcap",
                                int128_to_double(cap_log->cap_config_desc[i].egcd[j].segcap));
                        json_object_add_value_uint(endurance, "egsets",
                                le16_to_cpu(cap_log->cap_config_desc[i].egcd[j].egsets));
@@ -5366,9 +5366,9 @@ static void json_nvme_id_nvmset(struct nvme_id_nvmset_list *nvmset)
                          le32_to_cpu(nvmset->ent[i].rr4kt));
                json_object_add_value_int(entry, "optimal_write_size",
                          le32_to_cpu(nvmset->ent[i].ows));
-               json_object_add_value_float(entry, "total_nvmset_cap",
+               json_object_add_value_double(entry, "total_nvmset_cap",
                            int128_to_double(nvmset->ent[i].tnvmsetcap));
-               json_object_add_value_float(entry, "unalloc_nvmset_cap",
+               json_object_add_value_double(entry, "unalloc_nvmset_cap",
                            int128_to_double(nvmset->ent[i].unvmsetcap));
                json_array_add_value_object(entries, entry);
        }
@@ -5716,9 +5716,9 @@ static void json_id_domain_list(struct nvme_id_domain_list *id_dom)
                max_egrp_dom_cap = int128_to_double(id_dom->domain_attr[i].max_egrp_dom_cap);
 
                json_object_add_value_uint(entry, "dom_id", le16_to_cpu(id_dom->domain_attr[i].dom_id));
-               json_object_add_value_float(entry, "dom_cap", dom_cap);
-               json_object_add_value_float(entry, "unalloc_dom_cap", unalloc_dom_cap);
-               json_object_add_value_float(entry, "max_egrp_dom_cap", max_egrp_dom_cap);
+               json_object_add_value_double(entry, "dom_cap", dom_cap);
+               json_object_add_value_double(entry, "unalloc_dom_cap", unalloc_dom_cap);
+               json_object_add_value_double(entry, "max_egrp_dom_cap", max_egrp_dom_cap);
 
                json_array_add_value_object(entries, entry);
        }

diff --git a/plugins/intel/intel-nvme.c b/plugins/intel/intel-nvme.c
index 6a5ccbc1becd7161c0329019cb52709dcac4f961..1bf662735e643a34a570f9fb16f256c6e45b4c14 100644 (file)
--- a/plugins/intel/intel-nvme.c
+++ b/plugins/intel/intel-nvme.c
@@ -180,7 +180,7 @@ static void show_intel_smart_log_jsn(struct nvme_additional_smart_log *smart,
 
        entry_stats = json_create_object();
        json_object_add_value_int(entry_stats, "normalized", smart->timed_workload_media_wear.norm);
-       json_object_add_value_float(entry_stats, "raw", ((long double)int48_to_long(smart->timed_workload_media_wear.raw)) / 1024);
+       json_object_add_value_double(entry_stats, "raw", ((long double)int48_to_long(smart->timed_workload_media_wear.raw)) / 1024);
        json_object_add_value_object(dev_stats, "timed_workload_media_wear", entry_stats);
 
        entry_stats = json_create_object();

diff --git a/plugins/wdc/wdc-nvme.c b/plugins/wdc/wdc-nvme.c
index ea29fdcebf149d8b8056fc663b31c756a9eaf1dc..3052aeb1eb9c2cfac3d0ba73309bbfdc9ee0e2fe 100644 (file)
--- a/plugins/wdc/wdc-nvme.c
+++ b/plugins/wdc/wdc-nvme.c
@@ -4650,7 +4650,7 @@ static void wdc_print_bd_ca_log_json(void *data)
                raw = (__u64*)&bd_data->raw_value[0];
                json_object_add_value_int(root, "timed_workload_media_wear normalized",
                                bd_data->normalized_value);
-               json_object_add_value_float(root, "timed_workload_media_wear raw",
+               json_object_add_value_double(root, "timed_workload_media_wear raw",
                                safe_div_fp((*raw & 0x00FFFFFFFFFFFFFF), 1024.0));
        } else {
                goto invalid_id;
@@ -4711,7 +4711,7 @@ static void wdc_print_bd_ca_log_json(void *data)
                raw = (__u64*)&bd_data->raw_value[0];
                json_object_add_value_int(root, "nand_bytes_written normalized",
                                bd_data->normalized_value);
-               json_object_add_value_float(root, "nand_bytes_written raw",
+               json_object_add_value_double(root, "nand_bytes_written raw",
                                safe_div_fp((*raw & 0x00FFFFFFFFFFFFFF), 0xFFFF));
        } else {
                goto invalid_id;
@@ -4721,7 +4721,7 @@ static void wdc_print_bd_ca_log_json(void *data)
                raw = (__u64*)&bd_data->raw_value[0];
                json_object_add_value_int(root, "host_bytes_written normalized",
                                bd_data->normalized_value);
-               json_object_add_value_float(root, "host_bytes_written raw",
+               json_object_add_value_double(root, "host_bytes_written raw",
                                safe_div_fp((*raw & 0x00FFFFFFFFFFFFFF), 0xFFFF));
        } else {
                goto invalid_id;
@@ -5756,9 +5756,9 @@ static void wdc_print_ext_smart_cloud_log_json(void *data, int mask)
        struct json_object *root;
 
        root = json_create_object();
-       json_object_add_value_float(root, "physical_media_units_bytes_tlc",
+       json_object_add_value_double(root, "physical_media_units_bytes_tlc",
                int128_to_double(ext_smart_log_ptr->ext_smart_pmuwt));
-       json_object_add_value_float(root, "physical_media_units_bytes_slc",
+       json_object_add_value_double(root, "physical_media_units_bytes_slc",
                int128_to_double(ext_smart_log_ptr->ext_smart_pmuws));
        json_object_add_value_uint(root, "bad_user_blocks_normalized",
                le16_to_cpu(*(uint16_t *)ext_smart_log_ptr->ext_smart_bunbc));
@@ -5807,7 +5807,7 @@ static void wdc_print_ext_smart_cloud_log_json(void *data, int mask)
                        le64_to_cpu(ext_smart_log_ptr->ext_smart_svn));
                json_object_add_value_uint(root, "pct_free_blocks_system",
                        (__u8)ext_smart_log_ptr->ext_smart_pfbs);
-               json_object_add_value_float(root, "num_of_trim_commands",
+               json_object_add_value_double(root, "num_of_trim_commands",
                        int128_to_double(ext_smart_log_ptr->ext_smart_dcc));
                json_object_add_value_uint64(root, "total_nuse_bytes",
                        le64_to_cpu(ext_smart_log_ptr->ext_smart_tnu));
@@ -5826,7 +5826,7 @@ static void wdc_print_ext_smart_cloud_log_json(void *data, int mask)
                le16_to_cpu(*(uint16_t *)ext_smart_log_ptr->ext_smart_bsnbc));
        json_object_add_value_uint64(root, "bad_system_block_raw",
                le64_to_cpu(*(uint64_t *)ext_smart_log_ptr->ext_smart_bsnbc & 0xFFFFFFFFFFFF0000));
-       json_object_add_value_float(root, "endurance_est_bytes",
+       json_object_add_value_double(root, "endurance_est_bytes",
                int128_to_double(ext_smart_log_ptr->ext_smart_eest));
        if (mask == WDC_SCA_V1_ALL) {
                json_object_add_value_uint(root, "num_throttling_events",
@@ -5834,7 +5834,7 @@ static void wdc_print_ext_smart_cloud_log_json(void *data, int mask)
                json_object_add_value_uint64(root, "total_unaligned_io",
                        le64_to_cpu(ext_smart_log_ptr->ext_smart_uio));
        }
-       json_object_add_value_float(root, "physical_media_units_read_bytes",
+       json_object_add_value_double(root, "physical_media_units_read_bytes",
                        int128_to_double(ext_smart_log_ptr->ext_smart_pmur));
        if (mask == WDC_SCA_V1_ALL) {
                json_object_add_value_uint(root, "num_read_timeouts",
@@ -5961,9 +5961,9 @@ static void wdc_print_smart_cloud_attr_C0_json(void *data)
        uint16_t smart_log_ver = 0;
 
        root = json_create_object();
-       json_object_add_value_float(root, "Physical media units written",
+       json_object_add_value_double(root, "Physical media units written",
                        int128_to_double(&log_data[SCAO_PMUW]));
-       json_object_add_value_float(root, "Physical media units read",
+       json_object_add_value_double(root, "Physical media units read",
                        int128_to_double(&log_data[SCAO_PMUR]));
        json_object_add_value_uint64(root, "Bad user nand blocks - Raw",
                        (uint64_t)le64_to_cpu(*(uint64_t *)&log_data[SCAO_BUNBR] & 0x0000FFFFFFFFFFFF));
@@ -6009,9 +6009,9 @@ static void wdc_print_smart_cloud_attr_C0_json(void *data)
                        (uint64_t)le64_to_cpu(*(uint64_t *)&log_data[SCAO_SVN]));
        json_object_add_value_uint64(root, "NUSE - Namespace utilization",
                        (uint64_t)le64_to_cpu(*(uint64_t *)&log_data[SCAO_NUSE]));
-       json_object_add_value_float(root, "PLP start count",
+       json_object_add_value_double(root, "PLP start count",
                        int128_to_double(&log_data[SCAO_PSC]));
-       json_object_add_value_float(root, "Endurance estimate",
+       json_object_add_value_double(root, "Endurance estimate",
                        int128_to_double(&log_data[SCAO_EEST]));
        smart_log_ver = (uint16_t)le16_to_cpu(*(uint16_t *)&log_data[SCAO_LPV]);
        json_object_add_value_uint(root, "Log page version", smart_log_ver);
@@ -9732,9 +9732,9 @@ static void wdc_print_nand_stats_json(__u16 version, void *data)
 
        case 0:
 
-               json_object_add_value_float(root, "NAND Writes TLC (Bytes)",
+               json_object_add_value_double(root, "NAND Writes TLC (Bytes)",
                                int128_to_double(nand_stats->nand_write_tlc));
-               json_object_add_value_float(root, "NAND Writes SLC (Bytes)",
+               json_object_add_value_double(root, "NAND Writes SLC (Bytes)",
                                int128_to_double(nand_stats->nand_write_slc));
                json_object_add_value_uint(root, "NAND Program Failures",
                                le32_to_cpu(nand_stats->nand_prog_failure));
@@ -9755,9 +9755,9 @@ static void wdc_print_nand_stats_json(__u16 version, void *data)
 
        case 3:
 
-               json_object_add_value_float(root, "NAND Writes TLC (Bytes)",
+               json_object_add_value_double(root, "NAND Writes TLC (Bytes)",
                                int128_to_double(nand_stats_v3->nand_write_tlc));
-               json_object_add_value_float(root, "NAND Writes SLC (Bytes)",
+               json_object_add_value_double(root, "NAND Writes SLC (Bytes)",
                                int128_to_double(nand_stats_v3->nand_write_slc));
                temp_ptr = (__u64 *)nand_stats_v3->bad_nand_block_count;
                temp_norm = (__u16)(*temp_ptr & 0x000000000000FFFF);
@@ -9808,7 +9808,7 @@ static void wdc_print_nand_stats_json(__u16 version, void *data)
                                le64_to_cpu(nand_stats_v3->security_version_number));
                json_object_add_value_uint(root, "% Free Blocks (System)",
                                nand_stats_v3->percent_free_blocks_system);
-               json_object_add_value_float(root, "Data Set Management Commands",
+               json_object_add_value_double(root, "Data Set Management Commands",
                                int128_to_double(nand_stats_v3->trim_completions));
                json_object_add_value_uint64(root, "Estimate of Incomplete Trim Data",
                                le64_to_cpu(nand_stats_v3->trim_completions[16]));
@@ -9827,7 +9827,7 @@ static void wdc_print_nand_stats_json(__u16 version, void *data)
                                le16_to_cpu(temp_norm));
                json_object_add_value_uint64(root, "Bad System Nand Block Count - Raw",
                                le64_to_cpu(temp_raw));
-               json_object_add_value_float(root, "Endurance Estimate",
+               json_object_add_value_double(root, "Endurance Estimate",
                                int128_to_double(nand_stats_v3->endurance_estimate));
                json_object_add_value_uint(root, "Thermal Throttling Status",
                                nand_stats_v3->thermal_throttling_st_ct[0]);
@@ -9835,7 +9835,7 @@ static void wdc_print_nand_stats_json(__u16 version, void *data)
                                nand_stats_v3->thermal_throttling_st_ct[1]);
                json_object_add_value_uint64(root, "Unaligned I/O",
                                le64_to_cpu(nand_stats_v3->unaligned_IO));
-               json_object_add_value_float(root, "Physical Media Units Read",
+               json_object_add_value_double(root, "Physical Media Units Read",
                                int128_to_double(nand_stats_v3->physical_media_units));
                json_object_add_value_uint(root, "log page version",
                                le16_to_cpu(nand_stats_v3->log_page_version));