From 96876bb061009fa300b635db1e8a5a749f01d076 Mon Sep 17 00:00:00 2001 From: Francois Isabelle Date: Tue, 12 Jul 2005 12:21:13 +0000 Subject: [PATCH] added support for built-in sdrs --- ipmitool/include/ipmitool/ipmi_sdr.h | 881 +++++++------ ipmitool/lib/ipmi_sdr.c | 1788 ++++++++++++++------------ ipmitool/lib/ipmi_sensor.c | 510 ++++---- 3 files changed, 1723 insertions(+), 1456 deletions(-) diff --git a/ipmitool/include/ipmitool/ipmi_sdr.h b/ipmitool/include/ipmitool/ipmi_sdr.h index f946e0e..975220e 100644 --- a/ipmitool/include/ipmitool/ipmi_sdr.h +++ b/ipmitool/include/ipmitool/ipmi_sdr.h @@ -92,6 +92,8 @@ enum { #define SDR_SENSOR_STAT_HI_CR (1<<4) #define SDR_SENSOR_STAT_HI_NR (1<<5) +#define GET_DEVICE_SDR_INFO 0x20 +#define GET_DEVICE_SDR 0x21 #define GET_SENSOR_FACTORS 0x23 #define GET_SENSOR_FACTORS 0x23 #define SET_SENSOR_HYSTERESIS 0x24 @@ -107,32 +109,39 @@ enum { #define GET_SENSOR_TYPE 0x2f struct sdr_repo_info_rs { - uint8_t version; /* SDR version (51h) */ - uint16_t count; /* number of records */ - uint16_t free; /* free space in SDR */ - uint32_t add_stamp; /* last add timestamp */ - uint32_t erase_stamp; /* last del timestamp */ - uint8_t op_support; /* supported operations */ + uint8_t version; /* SDR version (51h) */ + uint16_t count; /* number of records */ + uint16_t free; /* free space in SDR */ + uint32_t add_stamp; /* last add timestamp */ + uint32_t erase_stamp; /* last del timestamp */ + uint8_t op_support; /* supported operations */ +} __attribute__ ((packed)); + +/* builtin (device) sdrs support */ +struct sdr_device_info_rs { + unsigned char count; /* number of records */ + unsigned char flags; /* flags */ + unsigned char popChangeInd[3]; /* free space in SDR */ } __attribute__ ((packed)); #define GET_SDR_RESERVE_REPO 0x22 struct sdr_reserve_repo_rs { - uint16_t reserve_id; /* reservation ID */ + uint16_t reserve_id; /* reservation ID */ } __attribute__ ((packed)); #define GET_SDR 0x23 struct sdr_get_rq { - uint16_t reserve_id; /* reservation ID */ - uint16_t id; /* record ID */ - uint8_t offset; /* offset into SDR */ + uint16_t reserve_id; /* reservation ID */ + uint16_t id; /* record ID */ + uint8_t offset; /* offset into SDR */ #define GET_SDR_ENTIRE_RECORD 0xff - uint8_t length; /* length to read */ + uint8_t length; /* length to read */ } __attribute__ ((packed)); struct sdr_get_rs { - uint16_t next; /* next record id */ - uint16_t id; /* record ID */ - uint8_t version; /* SDR version (51h) */ + uint16_t next; /* next record id */ + uint16_t id; /* record ID */ + uint8_t version; /* SDR version (51h) */ #define SDR_RECORD_TYPE_FULL_SENSOR 0x01 #define SDR_RECORD_TYPE_COMPACT_SENSOR 0x02 #define SDR_RECORD_TYPE_EVENTONLY_SENSOR 0x03 @@ -144,145 +153,143 @@ struct sdr_get_rs { #define SDR_RECORD_TYPE_MC_CONFIRMATION 0x13 #define SDR_RECORD_TYPE_BMC_MSG_CHANNEL_INFO 0x14 #define SDR_RECORD_TYPE_OEM 0xc0 - uint8_t type; /* record type */ - uint8_t length; /* remaining record bytes */ + uint8_t type; /* record type */ + uint8_t length; /* remaining record bytes */ } __attribute__ ((packed)); - struct sdr_record_mask { union { struct { - uint16_t assert_event; /* assertion event mask */ - uint16_t deassert_event; /* de-assertion event mask */ - uint16_t read; /* discrete reaading mask */ + uint16_t assert_event; /* assertion event mask */ + uint16_t deassert_event; /* de-assertion event mask */ + uint16_t read; /* discrete reaading mask */ } discrete; struct { #if WORDS_BIGENDIAN - uint16_t reserved : 1; - uint16_t status_lnr : 1; - uint16_t status_lcr : 1; - uint16_t status_lnc : 1; - uint16_t assert_unr_high : 1; - uint16_t assert_unr_low : 1; - uint16_t assert_ucr_high : 1; - uint16_t assert_ucr_low : 1; - uint16_t assert_unc_high : 1; - uint16_t assert_unc_low : 1; - uint16_t assert_lnr_high : 1; - uint16_t assert_lnr_low : 1; - uint16_t assert_lcr_high : 1; - uint16_t assert_lcr_low : 1; - uint16_t assert_lnc_high : 1; - uint16_t assert_lnc_low : 1; + uint16_t reserved:1; + uint16_t status_lnr:1; + uint16_t status_lcr:1; + uint16_t status_lnc:1; + uint16_t assert_unr_high:1; + uint16_t assert_unr_low:1; + uint16_t assert_ucr_high:1; + uint16_t assert_ucr_low:1; + uint16_t assert_unc_high:1; + uint16_t assert_unc_low:1; + uint16_t assert_lnr_high:1; + uint16_t assert_lnr_low:1; + uint16_t assert_lcr_high:1; + uint16_t assert_lcr_low:1; + uint16_t assert_lnc_high:1; + uint16_t assert_lnc_low:1; #else - uint16_t assert_lnc_low : 1; - uint16_t assert_lnc_high : 1; - uint16_t assert_lcr_low : 1; - uint16_t assert_lcr_high : 1; - uint16_t assert_lnr_low : 1; - uint16_t assert_lnr_high : 1; - uint16_t assert_unc_low : 1; - uint16_t assert_unc_high : 1; - uint16_t assert_ucr_low : 1; - uint16_t assert_ucr_high : 1; - uint16_t assert_unr_low : 1; - uint16_t assert_unr_high : 1; - uint16_t status_lnc : 1; - uint16_t status_lcr : 1; - uint16_t status_lnr : 1; - uint16_t reserved : 1; + uint16_t assert_lnc_low:1; + uint16_t assert_lnc_high:1; + uint16_t assert_lcr_low:1; + uint16_t assert_lcr_high:1; + uint16_t assert_lnr_low:1; + uint16_t assert_lnr_high:1; + uint16_t assert_unc_low:1; + uint16_t assert_unc_high:1; + uint16_t assert_ucr_low:1; + uint16_t assert_ucr_high:1; + uint16_t assert_unr_low:1; + uint16_t assert_unr_high:1; + uint16_t status_lnc:1; + uint16_t status_lcr:1; + uint16_t status_lnr:1; + uint16_t reserved:1; #endif #if WORDS_BIGENDIAN - uint16_t reserved_2 : 1; - uint16_t status_unr : 1; - uint16_t status_ucr : 1; - uint16_t status_unc : 1; - uint16_t deassert_unr_high : 1; - uint16_t deassert_unr_low : 1; - uint16_t deassert_ucr_high : 1; - uint16_t deassert_ucr_low : 1; - uint16_t deassert_unc_high : 1; - uint16_t deassert_unc_low : 1; - uint16_t deassert_lnr_high : 1; - uint16_t deassert_lnr_low : 1; - uint16_t deassert_lcr_high : 1; - uint16_t deassert_lcr_low : 1; - uint16_t deassert_lnc_high : 1; - uint16_t deassert_lnc_low : 1; + uint16_t reserved_2:1; + uint16_t status_unr:1; + uint16_t status_ucr:1; + uint16_t status_unc:1; + uint16_t deassert_unr_high:1; + uint16_t deassert_unr_low:1; + uint16_t deassert_ucr_high:1; + uint16_t deassert_ucr_low:1; + uint16_t deassert_unc_high:1; + uint16_t deassert_unc_low:1; + uint16_t deassert_lnr_high:1; + uint16_t deassert_lnr_low:1; + uint16_t deassert_lcr_high:1; + uint16_t deassert_lcr_low:1; + uint16_t deassert_lnc_high:1; + uint16_t deassert_lnc_low:1; #else - uint16_t deassert_lnc_low : 1; - uint16_t deassert_lnc_high : 1; - uint16_t deassert_lcr_low : 1; - uint16_t deassert_lcr_high : 1; - uint16_t deassert_lnr_low : 1; - uint16_t deassert_lnr_high : 1; - uint16_t deassert_unc_low : 1; - uint16_t deassert_unc_high : 1; - uint16_t deassert_ucr_low : 1; - uint16_t deassert_ucr_high : 1; - uint16_t deassert_unr_low : 1; - uint16_t deassert_unr_high : 1; - uint16_t status_unc : 1; - uint16_t status_ucr : 1; - uint16_t status_unr : 1; - uint16_t reserved_2 : 1; + uint16_t deassert_lnc_low:1; + uint16_t deassert_lnc_high:1; + uint16_t deassert_lcr_low:1; + uint16_t deassert_lcr_high:1; + uint16_t deassert_lnr_low:1; + uint16_t deassert_lnr_high:1; + uint16_t deassert_unc_low:1; + uint16_t deassert_unc_high:1; + uint16_t deassert_ucr_low:1; + uint16_t deassert_ucr_high:1; + uint16_t deassert_unr_low:1; + uint16_t deassert_unr_high:1; + uint16_t status_unc:1; + uint16_t status_ucr:1; + uint16_t status_unr:1; + uint16_t reserved_2:1; #endif struct { -#if WORDS_BIGENDIAN /* settable threshold mask */ - uint8_t reserved : 2; - uint8_t unr : 1; - uint8_t ucr : 1; - uint8_t unc : 1; - uint8_t lnr : 1; - uint8_t lcr : 1; - uint8_t lnc : 1; +#if WORDS_BIGENDIAN /* settable threshold mask */ + uint8_t reserved:2; + uint8_t unr:1; + uint8_t ucr:1; + uint8_t unc:1; + uint8_t lnr:1; + uint8_t lcr:1; + uint8_t lnc:1; #else - uint8_t lnc : 1; - uint8_t lcr : 1; - uint8_t lnr : 1; - uint8_t unc : 1; - uint8_t ucr : 1; - uint8_t unr : 1; - uint8_t reserved : 2; + uint8_t lnc:1; + uint8_t lcr:1; + uint8_t lnr:1; + uint8_t unc:1; + uint8_t ucr:1; + uint8_t unr:1; + uint8_t reserved:2; #endif } set; struct { -#if WORDS_BIGENDIAN /* readable threshold mask */ - uint8_t reserved : 2; - uint8_t unr : 1; - uint8_t ucr : 1; - uint8_t unc : 1; - uint8_t lnr : 1; - uint8_t lcr : 1; - uint8_t lnc : 1; +#if WORDS_BIGENDIAN /* readable threshold mask */ + uint8_t reserved:2; + uint8_t unr:1; + uint8_t ucr:1; + uint8_t unc:1; + uint8_t lnr:1; + uint8_t lcr:1; + uint8_t lnc:1; #else - uint8_t lnc : 1; - uint8_t lcr : 1; - uint8_t lnr : 1; - uint8_t unc : 1; - uint8_t ucr : 1; - uint8_t unr : 1; - uint8_t reserved : 2; + uint8_t lnc:1; + uint8_t lcr:1; + uint8_t lnr:1; + uint8_t unc:1; + uint8_t ucr:1; + uint8_t unr:1; + uint8_t reserved:2; #endif } read; } threshold; } type; } __attribute__ ((packed)); - struct sdr_record_compact_sensor { struct { - uint8_t owner_id; + uint8_t owner_id; #if WORDS_BIGENDIAN - uint8_t channel : 4; /* channel number */ - uint8_t __reserved : 2; - uint8_t lun : 2; /* sensor owner lun */ + uint8_t channel:4; /* channel number */ + uint8_t __reserved:2; + uint8_t lun:2; /* sensor owner lun */ #else - uint8_t lun : 2; /* sensor owner lun */ - uint8_t __reserved : 2; - uint8_t channel : 4; /* channel number */ + uint8_t lun:2; /* sensor owner lun */ + uint8_t __reserved:2; + uint8_t channel:4; /* channel number */ #endif - uint8_t sensor_num; /* unique sensor number */ + uint8_t sensor_num; /* unique sensor number */ } keys; struct entity_id entity; @@ -290,156 +297,156 @@ struct sdr_record_compact_sensor { struct { struct { #if WORDS_BIGENDIAN - uint8_t __reserved : 1; - uint8_t scanning : 1; - uint8_t events : 1; - uint8_t thresholds : 1; - uint8_t hysteresis : 1; - uint8_t type : 1; - uint8_t event_gen : 1; - uint8_t sensor_scan : 1; + uint8_t __reserved:1; + uint8_t scanning:1; + uint8_t events:1; + uint8_t thresholds:1; + uint8_t hysteresis:1; + uint8_t type:1; + uint8_t event_gen:1; + uint8_t sensor_scan:1; #else - uint8_t sensor_scan : 1; - uint8_t event_gen : 1; - uint8_t type : 1; - uint8_t hysteresis : 1; - uint8_t thresholds : 1; - uint8_t events : 1; - uint8_t scanning : 1; - uint8_t __reserved : 1; + uint8_t sensor_scan:1; + uint8_t event_gen:1; + uint8_t type:1; + uint8_t hysteresis:1; + uint8_t thresholds:1; + uint8_t events:1; + uint8_t scanning:1; + uint8_t __reserved:1; #endif } init; struct { #if WORDS_BIGENDIAN - uint8_t ignore : 1; - uint8_t rearm : 1; - uint8_t hysteresis : 2; - uint8_t threshold : 2; - uint8_t event_msg : 2; + uint8_t ignore:1; + uint8_t rearm:1; + uint8_t hysteresis:2; + uint8_t threshold:2; + uint8_t event_msg:2; #else - uint8_t event_msg : 2; - uint8_t threshold : 2; - uint8_t hysteresis : 2; - uint8_t rearm : 1; - uint8_t ignore : 1; + uint8_t event_msg:2; + uint8_t threshold:2; + uint8_t hysteresis:2; + uint8_t rearm:1; + uint8_t ignore:1; #endif } capabilities; - uint8_t type; /* sensor type */ + uint8_t type; /* sensor type */ } sensor; - uint8_t event_type; /* event/reading type code */ + uint8_t event_type; /* event/reading type code */ struct sdr_record_mask mask; struct { #if WORDS_BIGENDIAN - uint8_t analog : 2; - uint8_t rate : 3; - uint8_t modifier : 2; - uint8_t pct : 1; + uint8_t analog:2; + uint8_t rate:3; + uint8_t modifier:2; + uint8_t pct:1; #else - uint8_t pct : 1; - uint8_t modifier : 2; - uint8_t rate : 3; - uint8_t analog : 2; + uint8_t pct:1; + uint8_t modifier:2; + uint8_t rate:3; + uint8_t analog:2; #endif struct { - uint8_t base; - uint8_t modifier; + uint8_t base; + uint8_t modifier; } type; } unit; struct { #if WORDS_BIGENDIAN - uint8_t __reserved : 2; - uint8_t mod_type : 2; - uint8_t count : 4; + uint8_t __reserved:2; + uint8_t mod_type:2; + uint8_t count:4; #else - uint8_t count : 4; - uint8_t mod_type : 2; - uint8_t __reserved : 2; + uint8_t count:4; + uint8_t mod_type:2; + uint8_t __reserved:2; #endif #if WORDS_BIGENDIAN - uint8_t entity_inst : 1; - uint8_t mod_offset : 7; + uint8_t entity_inst:1; + uint8_t mod_offset:7; #else - uint8_t mod_offset : 7; - uint8_t entity_inst : 1; + uint8_t mod_offset:7; + uint8_t entity_inst:1; #endif } share; struct { struct { - uint8_t positive; - uint8_t negative; + uint8_t positive; + uint8_t negative; } hysteresis; } threshold; - uint8_t __reserved[3]; - uint8_t oem; /* reserved for OEM use */ - uint8_t id_code; /* sensor ID string type/length code */ - uint8_t id_string[16]; /* sensor ID string bytes, only if id_code != 0 */ + uint8_t __reserved[3]; + uint8_t oem; /* reserved for OEM use */ + uint8_t id_code; /* sensor ID string type/length code */ + uint8_t id_string[16]; /* sensor ID string bytes, only if id_code != 0 */ } __attribute__ ((packed)); struct sdr_record_eventonly_sensor { struct { - uint8_t owner_id; + uint8_t owner_id; #if WORDS_BIGENDIAN - uint8_t channel : 4; /* channel number */ - uint8_t fru_owner : 2; /* fru device owner lun */ - uint8_t lun : 2; /* sensor owner lun */ + uint8_t channel:4; /* channel number */ + uint8_t fru_owner:2; /* fru device owner lun */ + uint8_t lun:2; /* sensor owner lun */ #else - uint8_t lun : 2; /* sensor owner lun */ - uint8_t fru_owner : 2; /* fru device owner lun */ - uint8_t channel : 4; /* channel number */ + uint8_t lun:2; /* sensor owner lun */ + uint8_t fru_owner:2; /* fru device owner lun */ + uint8_t channel:4; /* channel number */ #endif - uint8_t sensor_num; /* unique sensor number */ + uint8_t sensor_num; /* unique sensor number */ } keys; struct entity_id entity; - uint8_t sensor_type; /* sensor type */ - uint8_t event_type; /* event/reading type code */ + uint8_t sensor_type; /* sensor type */ + uint8_t event_type; /* event/reading type code */ struct { #if WORDS_BIGENDIAN - uint8_t __reserved : 2; - uint8_t mod_type : 2; - uint8_t count : 4; + uint8_t __reserved:2; + uint8_t mod_type:2; + uint8_t count:4; #else - uint8_t count : 4; - uint8_t mod_type : 2; - uint8_t __reserved : 2; + uint8_t count:4; + uint8_t mod_type:2; + uint8_t __reserved:2; #endif #if WORDS_BIGENDIAN - uint8_t entity_inst : 1; - uint8_t mod_offset : 7; + uint8_t entity_inst:1; + uint8_t mod_offset:7; #else - uint8_t mod_offset : 7; - uint8_t entity_inst : 1; + uint8_t mod_offset:7; + uint8_t entity_inst:1; #endif } share; - uint8_t __reserved; - uint8_t oem; /* reserved for OEM use */ - uint8_t id_code; /* sensor ID string type/length code */ - uint8_t id_string[16]; /* sensor ID string bytes, only if id_code != 0 */ + uint8_t __reserved; + uint8_t oem; /* reserved for OEM use */ + uint8_t id_code; /* sensor ID string type/length code */ + uint8_t id_string[16]; /* sensor ID string bytes, only if id_code != 0 */ } __attribute__ ((packed)); struct sdr_record_full_sensor { struct { - uint8_t owner_id; + uint8_t owner_id; #if WORDS_BIGENDIAN - uint8_t channel : 4; /* channel number */ - uint8_t __reserved : 2; - uint8_t lun : 2; /* sensor owner lun */ + uint8_t channel:4; /* channel number */ + uint8_t __reserved:2; + uint8_t lun:2; /* sensor owner lun */ #else - uint8_t lun : 2; /* sensor owner lun */ - uint8_t __reserved : 2; - uint8_t channel : 4; /* channel number */ + uint8_t lun:2; /* sensor owner lun */ + uint8_t __reserved:2; + uint8_t channel:4; /* channel number */ #endif - uint8_t sensor_num; /* unique sensor number */ + uint8_t sensor_num; /* unique sensor number */ } keys; struct entity_id entity; @@ -447,62 +454,62 @@ struct sdr_record_full_sensor { struct { struct { #if WORDS_BIGENDIAN - uint8_t __reserved : 1; - uint8_t scanning : 1; - uint8_t events : 1; - uint8_t thresholds : 1; - uint8_t hysteresis : 1; - uint8_t type : 1; - uint8_t event_gen : 1; - uint8_t sensor_scan : 1; + uint8_t __reserved:1; + uint8_t scanning:1; + uint8_t events:1; + uint8_t thresholds:1; + uint8_t hysteresis:1; + uint8_t type:1; + uint8_t event_gen:1; + uint8_t sensor_scan:1; #else - uint8_t sensor_scan : 1; - uint8_t event_gen : 1; - uint8_t type : 1; - uint8_t hysteresis : 1; - uint8_t thresholds : 1; - uint8_t events : 1; - uint8_t scanning : 1; - uint8_t __reserved : 1; + uint8_t sensor_scan:1; + uint8_t event_gen:1; + uint8_t type:1; + uint8_t hysteresis:1; + uint8_t thresholds:1; + uint8_t events:1; + uint8_t scanning:1; + uint8_t __reserved:1; #endif } init; struct { #if WORDS_BIGENDIAN - uint8_t ignore : 1; - uint8_t rearm : 1; - uint8_t hysteresis : 2; - uint8_t threshold : 2; - uint8_t event_msg : 2; + uint8_t ignore:1; + uint8_t rearm:1; + uint8_t hysteresis:2; + uint8_t threshold:2; + uint8_t event_msg:2; #else - uint8_t event_msg : 2; - uint8_t threshold : 2; - uint8_t hysteresis : 2; - uint8_t rearm : 1; - uint8_t ignore : 1; + uint8_t event_msg:2; + uint8_t threshold:2; + uint8_t hysteresis:2; + uint8_t rearm:1; + uint8_t ignore:1; #endif } capabilities; - uint8_t type; + uint8_t type; } sensor; - uint8_t event_type; /* event/reading type code */ + uint8_t event_type; /* event/reading type code */ struct sdr_record_mask mask; struct { #if WORDS_BIGENDIAN - uint8_t analog : 2; - uint8_t rate : 3; - uint8_t modifier : 2; - uint8_t pct : 1; + uint8_t analog:2; + uint8_t rate:3; + uint8_t modifier:2; + uint8_t pct:1; #else - uint8_t pct : 1; - uint8_t modifier : 2; - uint8_t rate : 3; - uint8_t analog : 2; + uint8_t pct:1; + uint8_t modifier:2; + uint8_t rate:3; + uint8_t analog:2; #endif struct { - uint8_t base; - uint8_t modifier; + uint8_t base; + uint8_t modifier; } type; } unit; @@ -520,69 +527,69 @@ struct sdr_record_full_sensor { #define SDR_SENSOR_L_CUBERT 0x0b #define SDR_SENSOR_L_NONLINEAR 0x70 - uint8_t linearization; /* 70h=non linear, 71h-7Fh=non linear, OEM */ - uint16_t mtol; /* M, tolerance */ - uint32_t bacc; /* accuracy, B, Bexp, Rexp */ + uint8_t linearization; /* 70h=non linear, 71h-7Fh=non linear, OEM */ + uint16_t mtol; /* M, tolerance */ + uint32_t bacc; /* accuracy, B, Bexp, Rexp */ struct { #if WORDS_BIGENDIAN - uint8_t __reserved : 5; - uint8_t normal_min : 1; /* normal min field specified */ - uint8_t normal_max : 1; /* normal max field specified */ - uint8_t nominal_read : 1; /* nominal reading field specified */ + uint8_t __reserved:5; + uint8_t normal_min:1; /* normal min field specified */ + uint8_t normal_max:1; /* normal max field specified */ + uint8_t nominal_read:1; /* nominal reading field specified */ #else - uint8_t nominal_read : 1; /* nominal reading field specified */ - uint8_t normal_max : 1; /* normal max field specified */ - uint8_t normal_min : 1; /* normal min field specified */ - uint8_t __reserved : 5; + uint8_t nominal_read:1; /* nominal reading field specified */ + uint8_t normal_max:1; /* normal max field specified */ + uint8_t normal_min:1; /* normal min field specified */ + uint8_t __reserved:5; #endif } analog_flag; - uint8_t nominal_read; /* nominal reading, raw value */ - uint8_t normal_max; /* normal maximum, raw value */ - uint8_t normal_min; /* normal minimum, raw value */ - uint8_t sensor_max; /* sensor maximum, raw value */ - uint8_t sensor_min; /* sensor minimum, raw value */ + uint8_t nominal_read; /* nominal reading, raw value */ + uint8_t normal_max; /* normal maximum, raw value */ + uint8_t normal_min; /* normal minimum, raw value */ + uint8_t sensor_max; /* sensor maximum, raw value */ + uint8_t sensor_min; /* sensor minimum, raw value */ struct { struct { - uint8_t non_recover; - uint8_t critical; - uint8_t non_critical; + uint8_t non_recover; + uint8_t critical; + uint8_t non_critical; } upper; struct { - uint8_t non_recover; - uint8_t critical; - uint8_t non_critical; + uint8_t non_recover; + uint8_t critical; + uint8_t non_critical; } lower; struct { - uint8_t positive; - uint8_t negative; + uint8_t positive; + uint8_t negative; } hysteresis; } threshold; - uint8_t __reserved[2]; - uint8_t oem; /* reserved for OEM use */ - uint8_t id_code; /* sensor ID string type/length code */ - uint8_t id_string[16]; /* sensor ID string bytes, only if id_code != 0 */ + uint8_t __reserved[2]; + uint8_t oem; /* reserved for OEM use */ + uint8_t id_code; /* sensor ID string type/length code */ + uint8_t id_string[16]; /* sensor ID string bytes, only if id_code != 0 */ } __attribute__ ((packed)); struct sdr_record_mc_locator { uint8_t dev_slave_addr; #if WORDS_BIGENDIAN - uint8_t __reserved2 : 4; - uint8_t channel_num : 4; + uint8_t __reserved2:4; + uint8_t channel_num:4; #else - uint8_t channel_num : 4; - uint8_t __reserved2 : 4; + uint8_t channel_num:4; + uint8_t __reserved2:4; #endif #if WORDS_BIGENDIAN - uint8_t pwr_state_notif : 3; - uint8_t __reserved3 : 1; - uint8_t global_init : 4; + uint8_t pwr_state_notif:3; + uint8_t __reserved3:1; + uint8_t global_init:4; #else - uint8_t global_init : 4; - uint8_t __reserved3 : 1; - uint8_t pwr_state_notif : 3; + uint8_t global_init:4; + uint8_t __reserved3:1; + uint8_t pwr_state_notif:3; #endif uint8_t dev_support; uint8_t __reserved4[3]; @@ -596,22 +603,22 @@ struct sdr_record_fru_locator { uint8_t dev_slave_addr; uint8_t device_id; #if WORDS_BIGENDIAN - uint8_t logical : 1; - uint8_t __reserved2 : 2; - uint8_t lun : 2; - uint8_t bus : 3; + uint8_t logical:1; + uint8_t __reserved2:2; + uint8_t lun:2; + uint8_t bus:3; #else - uint8_t bus : 3; - uint8_t lun : 2; - uint8_t __reserved2 : 2; - uint8_t logical : 1; + uint8_t bus:3; + uint8_t lun:2; + uint8_t __reserved2:2; + uint8_t logical:1; #endif #if WORDS_BIGENDIAN - uint8_t channel_num : 4; - uint8_t __reserved3 : 4; + uint8_t channel_num:4; + uint8_t __reserved3:4; #else - uint8_t __reserved3 : 4; - uint8_t channel_num : 4; + uint8_t __reserved3:4; + uint8_t channel_num:4; #endif uint8_t __reserved4; uint8_t dev_type; @@ -626,20 +633,20 @@ struct sdr_record_generic_locator { uint8_t dev_access_addr; uint8_t dev_slave_addr; #if WORDS_BIGENDIAN - uint8_t channel_num : 3; - uint8_t lun : 2; - uint8_t bus : 3; + uint8_t channel_num:3; + uint8_t lun:2; + uint8_t bus:3; #else - uint8_t bus : 3; - uint8_t lun : 2; - uint8_t channel_num : 3; + uint8_t bus:3; + uint8_t lun:2; + uint8_t channel_num:3; #endif #if WORDS_BIGENDIAN - uint8_t addr_span : 3; - uint8_t __reserved1 : 5; + uint8_t addr_span:3; + uint8_t __reserved1:5; #else - uint8_t __reserved1 : 5; - uint8_t addr_span : 3; + uint8_t __reserved1:5; + uint8_t addr_span:3; #endif uint8_t __reserved2; uint8_t dev_type; @@ -648,21 +655,21 @@ struct sdr_record_generic_locator { uint8_t oem; uint8_t id_code; uint8_t id_string[16]; -} __attribute__ ((packed)); +} __attribute__ ((packed)); struct sdr_record_entity_assoc { - struct entity_id entity; /* container entity ID and instance */ + struct entity_id entity; /* container entity ID and instance */ struct { #if WORDS_BIGENDIAN - uint8_t isrange : 1; - uint8_t islinked : 1; - uint8_t isaccessable : 1; - uint8_t __reserved : 5; + uint8_t isrange:1; + uint8_t islinked:1; + uint8_t isaccessable:1; + uint8_t __reserved:5; #else - uint8_t __reserved : 5; - uint8_t isaccessable : 1; - uint8_t islinked : 1; - uint8_t isrange : 1; + uint8_t __reserved:5; + uint8_t isaccessable:1; + uint8_t islinked:1; + uint8_t isrange:1; #endif } flags; uint8_t entity_id_1; /* entity ID 1 | range 1 entity */ @@ -676,11 +683,10 @@ struct sdr_record_entity_assoc { } __attribute__ ((packed)); struct sdr_record_oem { - uint8_t * data; + uint8_t *data; int data_len; }; - /* * The Get SDR Repository Info response structure * From table 33-3 of the IPMI v2.0 spec @@ -692,30 +698,26 @@ struct get_sdr_repository_info_rsp { uint8_t free_space[2]; uint8_t most_recent_addition_timestamp[4]; uint8_t most_recent_erase_timestamp[4]; -#if WORDS_BIGENDIAN - uint8_t overflow_flag : 1; - uint8_t modal_update_support : 2; - uint8_t __reserved1 : 1; - uint8_t delete_sdr_supported : 1; - uint8_t partial_add_sdr_supported : 1; - uint8_t reserve_sdr_repository_supported : 1; - uint8_t get_sdr_repository_allo_info_supported : 1; +#if WORDS_BIGENDIAN + uint8_t overflow_flag:1; + uint8_t modal_update_support:2; + uint8_t __reserved1:1; + uint8_t delete_sdr_supported:1; + uint8_t partial_add_sdr_supported:1; + uint8_t reserve_sdr_repository_supported:1; + uint8_t get_sdr_repository_allo_info_supported:1; #else - uint8_t get_sdr_repository_allo_info_supported : 1; - uint8_t reserve_sdr_repository_supported : 1; - uint8_t partial_add_sdr_supported : 1; - uint8_t delete_sdr_supported : 1; - uint8_t __reserved1 : 1; - uint8_t modal_update_support : 2; - uint8_t overflow_flag : 1; + uint8_t get_sdr_repository_allo_info_supported:1; + uint8_t reserve_sdr_repository_supported:1; + uint8_t partial_add_sdr_supported:1; + uint8_t delete_sdr_supported:1; + uint8_t __reserved1:1; + uint8_t modal_update_support:2; + uint8_t overflow_flag:1; #endif } __attribute__ ((packed)); - - - -struct ipmi_sdr_iterator -{ +struct ipmi_sdr_iterator { uint16_t reservation; int total; int next; @@ -724,101 +726,132 @@ struct ipmi_sdr_iterator struct sdr_record_list { uint16_t id; uint8_t type; - struct sdr_record_list * next; + struct sdr_record_list *next; union { - struct sdr_record_full_sensor * full; - struct sdr_record_compact_sensor * compact; - struct sdr_record_eventonly_sensor * eventonly; - struct sdr_record_generic_locator * genloc; - struct sdr_record_fru_locator * fruloc; - struct sdr_record_mc_locator * mcloc; - struct sdr_record_entity_assoc * entassoc; - struct sdr_record_oem * oem; + struct sdr_record_full_sensor *full; + struct sdr_record_compact_sensor *compact; + struct sdr_record_eventonly_sensor *eventonly; + struct sdr_record_generic_locator *genloc; + struct sdr_record_fru_locator *fruloc; + struct sdr_record_mc_locator *mcloc; + struct sdr_record_entity_assoc *entassoc; + struct sdr_record_oem *oem; } record; }; /* unit description codes (IPMI v1.5 section 37.16) */ #define UNIT_MAX 0x90 -static const char * unit_desc[] __attribute__((unused)) = { - "unspecified", - "degrees C", "degrees F", "degrees K", - "Volts", "Amps", "Watts", "Joules", - "Coulombs", "VA", "Nits", - "lumen", "lux", "Candela", - "kPa", "PSI", "Newton", - "CFM", "RPM", "Hz", - "microsecond", "millisecond", "second", "minute", "hour", "day", "week", - "mil", "inches", "feet", "cu in", "cu feet", "mm", "cm", "m", "cu cm", "cu m", - "liters", "fluid ounce", - "radians", "steradians", "revolutions", "cycles", "gravities", - "ounce", "pound", "ft-lb", "oz-in", - "gauss", "gilberts", "henry", "millihenry", - "farad", "microfarad", "ohms", "siemens", "mole", "becquerel", - "PPM", "reserved", - "Decibels", "DbA", "DbC", - "gray", "sievert", "color temp deg K", - "bit", "kilobit", "megabit", "gigabit", - "byte", "kilobyte", "megabyte", "gigabyte", - "word", "dword", "qword", "line", - "hit", "miss", "retry", "reset", - "overflow", "underrun", - "collision", "packets", - "messages", "characters", - "error", "correctable error", "uncorrectable error", -}; +static const char *unit_desc[] __attribute__ ((unused)) = { +"unspecified", + "degrees C", "degrees F", "degrees K", + "Volts", "Amps", "Watts", "Joules", + "Coulombs", "VA", "Nits", + "lumen", "lux", "Candela", + "kPa", "PSI", "Newton", + "CFM", "RPM", "Hz", + "microsecond", "millisecond", "second", "minute", "hour", + "day", "week", "mil", "inches", "feet", "cu in", "cu feet", + "mm", "cm", "m", "cu cm", "cu m", "liters", "fluid ounce", + "radians", "steradians", "revolutions", "cycles", + "gravities", "ounce", "pound", "ft-lb", "oz-in", "gauss", + "gilberts", "henry", "millihenry", "farad", "microfarad", + "ohms", "siemens", "mole", "becquerel", "PPM", "reserved", + "Decibels", "DbA", "DbC", "gray", "sievert", + "color temp deg K", "bit", "kilobit", "megabit", "gigabit", + "byte", "kilobyte", "megabyte", "gigabyte", "word", "dword", + "qword", "line", "hit", "miss", "retry", "reset", + "overflow", "underrun", "collision", "packets", "messages", + "characters", "error", "correctable error", "uncorrectable error",}; /* sensor type codes (IPMI v1.5 table 36.3) */ #define SENSOR_TYPE_MAX 0x29 -static const char * sensor_type_desc[] __attribute__((unused)) = { - "reserved", - "Temperature", "Voltage", "Current", "Fan", "Physical Security", "Platform Security", - "Processor", "Power Supply", "Power Unit", "Cooling Device", "Other", "Memory", "Drive Slot / Bay", - "POST Memory Resize", "System Firmwares", "Event Logging Disabled", "Watchdog", "System Event", - "Critical Interrupt", "Button", "Module / Board", "Microcontroller", "Add-in Card", - "Chassis", "Chip Set", "Other FRU", "Cable / Interconnect", "Terminator", "System Boot Initiated", - "Boot Error", "OS Boot", "OS Critical Stop", "Slot / Connector", "System ACPI Power State", "Watchdog", - "Platform Alert", "Entity Presence", "Monitor ASIC", "LAN", "Management Subsystem Health", "Battery" -}; +static const char *sensor_type_desc[] __attribute__ ((unused)) = { +"reserved", + "Temperature", "Voltage", "Current", "Fan", + "Physical Security", "Platform Security", "Processor", + "Power Supply", "Power Unit", "Cooling Device", "Other", + "Memory", "Drive Slot / Bay", "POST Memory Resize", + "System Firmwares", "Event Logging Disabled", "Watchdog", + "System Event", "Critical Interrupt", "Button", + "Module / Board", "Microcontroller", "Add-in Card", + "Chassis", "Chip Set", "Other FRU", "Cable / Interconnect", + "Terminator", "System Boot Initiated", "Boot Error", + "OS Boot", "OS Critical Stop", "Slot / Connector", + "System ACPI Power State", "Watchdog", "Platform Alert", + "Entity Presence", "Monitor ASIC", "LAN", + "Management Subsystem Health", "Battery"}; -struct ipmi_sdr_iterator * ipmi_sdr_start(struct ipmi_intf * intf); -struct sdr_get_rs * ipmi_sdr_get_next_header(struct ipmi_intf * intf, struct ipmi_sdr_iterator * i); -uint8_t * ipmi_sdr_get_record(struct ipmi_intf * intf, struct sdr_get_rs * header, struct ipmi_sdr_iterator * i); -void ipmi_sdr_end(struct ipmi_intf * intf, struct ipmi_sdr_iterator * i); -int ipmi_sdr_print_sdr(struct ipmi_intf * intf, uint8_t type); -int ipmi_sdr_print_rawentry(struct ipmi_intf * intf, uint8_t type, uint8_t * raw, int len); -int ipmi_sdr_print_listentry(struct ipmi_intf * intf, struct sdr_record_list * entry); -char * ipmi_sdr_get_unit_string(uint8_t type, uint8_t base, uint8_t modifier); -const char * ipmi_sdr_get_status(struct sdr_record_full_sensor * sensor, uint8_t stat); -double sdr_convert_sensor_reading(struct sdr_record_full_sensor * sensor, uint8_t val); -uint8_t sdr_convert_sensor_value_to_raw(struct sdr_record_full_sensor * sensor, double val); -struct ipmi_rs * ipmi_sdr_get_sensor_reading(struct ipmi_intf * intf, uint8_t sensor); -struct ipmi_rs * ipmi_sdr_get_sensor_reading_ipmb(struct ipmi_intf * intf, uint8_t sensor, uint8_t target); -struct ipmi_rs * ipmi_sdr_get_sensor_thresholds(struct ipmi_intf * intf, uint8_t sensor); -struct ipmi_rs * ipmi_sdr_get_sensor_hysteresis(struct ipmi_intf * intf, uint8_t sensor); -const char * ipmi_sdr_get_sensor_type_desc(const uint8_t type); -int ipmi_sdr_get_reservation(struct ipmi_intf * intf, uint16_t *reserve_id); +struct ipmi_sdr_iterator *ipmi_sdr_start(struct ipmi_intf *intf); +struct sdr_get_rs *ipmi_sdr_get_next_header(struct ipmi_intf *intf, + struct ipmi_sdr_iterator *i); +uint8_t *ipmi_sdr_get_record(struct ipmi_intf *intf, struct sdr_get_rs *header, + struct ipmi_sdr_iterator *i); +void ipmi_sdr_end(struct ipmi_intf *intf, struct ipmi_sdr_iterator *i); +int ipmi_sdr_print_sdr(struct ipmi_intf *intf, uint8_t type); +int ipmi_sdr_print_rawentry(struct ipmi_intf *intf, uint8_t type, uint8_t * raw, + int len); +int ipmi_sdr_print_listentry(struct ipmi_intf *intf, + struct sdr_record_list *entry); +char *ipmi_sdr_get_unit_string(uint8_t type, uint8_t base, uint8_t modifier); +const char *ipmi_sdr_get_status(struct sdr_record_full_sensor *sensor, + uint8_t stat); +double sdr_convert_sensor_reading(struct sdr_record_full_sensor *sensor, + uint8_t val); +uint8_t sdr_convert_sensor_value_to_raw(struct sdr_record_full_sensor *sensor, + double val); +struct ipmi_rs *ipmi_sdr_get_sensor_reading(struct ipmi_intf *intf, + uint8_t sensor); +struct ipmi_rs *ipmi_sdr_get_sensor_reading_ipmb(struct ipmi_intf *intf, + uint8_t sensor, + uint8_t target); +struct ipmi_rs *ipmi_sdr_get_sensor_thresholds(struct ipmi_intf *intf, + uint8_t sensor); +struct ipmi_rs *ipmi_sdr_get_sensor_hysteresis(struct ipmi_intf *intf, + uint8_t sensor); +const char *ipmi_sdr_get_sensor_type_desc(const uint8_t type); +int ipmi_sdr_get_reservation(struct ipmi_intf *intf, uint16_t * reserve_id); +int ipmi_sdr_print_sensor_full(struct ipmi_intf *intf, + struct sdr_record_full_sensor *sensor); +int ipmi_sdr_print_sensor_compact(struct ipmi_intf *intf, + struct sdr_record_compact_sensor *sensor); +int ipmi_sdr_print_sensor_eventonly(struct ipmi_intf *intf, + struct sdr_record_eventonly_sensor *sensor); +int ipmi_sdr_print_sensor_generic_locator(struct ipmi_intf *intf, + struct sdr_record_generic_locator + *fru); +int ipmi_sdr_print_sensor_fru_locator(struct ipmi_intf *intf, + struct sdr_record_fru_locator *fru); +int ipmi_sdr_print_sensor_mc_locator(struct ipmi_intf *intf, + struct sdr_record_mc_locator *mc); +int ipmi_sdr_print_sensor_entity_assoc(struct ipmi_intf *intf, + struct sdr_record_entity_assoc *assoc); -int ipmi_sdr_print_sensor_full(struct ipmi_intf * intf, struct sdr_record_full_sensor * sensor); -int ipmi_sdr_print_sensor_compact(struct ipmi_intf * intf, struct sdr_record_compact_sensor * sensor); -int ipmi_sdr_print_sensor_eventonly(struct ipmi_intf * intf, struct sdr_record_eventonly_sensor * sensor); -int ipmi_sdr_print_sensor_generic_locator(struct ipmi_intf * intf, struct sdr_record_generic_locator * fru); -int ipmi_sdr_print_sensor_fru_locator(struct ipmi_intf * intf, struct sdr_record_fru_locator * fru); -int ipmi_sdr_print_sensor_mc_locator(struct ipmi_intf * intf, struct sdr_record_mc_locator * mc); -int ipmi_sdr_print_sensor_entity_assoc(struct ipmi_intf * intf, struct sdr_record_entity_assoc * assoc); +struct sdr_record_list *ipmi_sdr_find_sdr_byentity(struct ipmi_intf *intf, + struct entity_id *entity); +struct sdr_record_list *ipmi_sdr_find_sdr_bynumtype(struct ipmi_intf *intf, + uint8_t num, uint8_t type); +struct sdr_record_list *ipmi_sdr_find_sdr_bysensortype(struct ipmi_intf *intf, + uint8_t type); +struct sdr_record_list *ipmi_sdr_find_sdr_byid(struct ipmi_intf *intf, + char *id); +struct sdr_record_list *ipmi_sdr_find_sdr_bytype(struct ipmi_intf *intf, + uint8_t type); +int ipmi_sdr_list_cache(struct ipmi_intf *intf); +int ipmi_sdr_list_cache_fromfile(struct ipmi_intf *intf, const char *ifile); +void ipmi_sdr_list_empty(struct ipmi_intf *intf); +int ipmi_sdr_print_info(struct ipmi_intf *intf); +void ipmi_sdr_print_discrete_state(const char *desc, uint8_t sensor_type, + uint8_t event_type, uint8_t state1, + uint8_t state2); +void ipmi_sdr_print_discrete_state_mini(const char *separator, + uint8_t sensor_type, uint8_t event_type, + uint8_t state1, uint8_t state2); +int ipmi_sdr_print_sensor_event_status(struct ipmi_intf *intf, + uint8_t sensor_num, uint8_t sensor_type, + uint8_t event_type, int numeric_fmt); +int ipmi_sdr_print_sensor_event_enable(struct ipmi_intf *intf, + uint8_t sensor_num, uint8_t sensor_type, + uint8_t event_type, int numeric_fmt); -struct sdr_record_list * ipmi_sdr_find_sdr_byentity(struct ipmi_intf * intf, struct entity_id * entity); -struct sdr_record_list * ipmi_sdr_find_sdr_bynumtype(struct ipmi_intf * intf, uint8_t num, uint8_t type); -struct sdr_record_list * ipmi_sdr_find_sdr_bysensortype(struct ipmi_intf * intf, uint8_t type); -struct sdr_record_list * ipmi_sdr_find_sdr_byid(struct ipmi_intf * intf, char * id); -struct sdr_record_list * ipmi_sdr_find_sdr_bytype(struct ipmi_intf * intf, uint8_t type); -int ipmi_sdr_list_cache(struct ipmi_intf * intf); -int ipmi_sdr_list_cache_fromfile(struct ipmi_intf * intf, const char * ifile); -void ipmi_sdr_list_empty(struct ipmi_intf * intf); -int ipmi_sdr_print_info(struct ipmi_intf * intf); -void ipmi_sdr_print_discrete_state(const char * desc, uint8_t sensor_type, uint8_t event_type, uint8_t state1, uint8_t state2); -void ipmi_sdr_print_discrete_state_mini(const char * separator, uint8_t sensor_type, uint8_t event_type, uint8_t state1, uint8_t state2); -int ipmi_sdr_print_sensor_event_status(struct ipmi_intf * intf, uint8_t sensor_num, uint8_t sensor_type, uint8_t event_type, int numeric_fmt); -int ipmi_sdr_print_sensor_event_enable(struct ipmi_intf * intf, uint8_t sensor_num, uint8_t sensor_type, uint8_t event_type, int numeric_fmt); - -#endif /* IPMI_SDR_H */ +#endif /* IPMI_SDR_H */ diff --git a/ipmitool/lib/ipmi_sdr.c b/ipmitool/lib/ipmi_sdr.c index 99c4c82..60cf095 100644 --- a/ipmitool/lib/ipmi_sdr.c +++ b/ipmitool/lib/ipmi_sdr.c @@ -44,6 +44,7 @@ #include #include +#include #include #include #include @@ -56,12 +57,13 @@ #endif extern int verbose; +static int use_built_in; /* Uses DeviceSDRs instead of SDRR */ static int sdr_max_read_len = GET_SDR_ENTIRE_RECORD; static int sdr_extended = 0; -static struct sdr_record_list * sdr_list_head = NULL; -static struct sdr_record_list * sdr_list_tail = NULL; -static struct ipmi_sdr_iterator * sdr_list_itr = NULL; +static struct sdr_record_list *sdr_list_head = NULL; +static struct sdr_record_list *sdr_list_tail = NULL; +static struct ipmi_sdr_iterator *sdr_list_itr = NULL; /* utos - convert unsigned 32bit value to 2's complement signed * @@ -73,10 +75,10 @@ static struct ipmi_sdr_iterator * sdr_list_itr = NULL; int32_t utos(uint32_t val, int bits) { - int x = pow(10, bits-1); + int x = pow(10, bits - 1); if (val & x) { - x = pow(2, bits-1); - return -((~val & (x-1))+1); + x = pow(2, bits - 1); + return -((~val & (x - 1)) + 1); } return val; } @@ -94,22 +96,19 @@ ipmi_sdr_get_unit_string(uint8_t type, uint8_t base, uint8_t modifier) { static char unitstr[16]; - memset(unitstr, 0, sizeof(unitstr)); + memset(unitstr, 0, sizeof (unitstr)); switch (type) { case 2: - snprintf(unitstr, sizeof(unitstr), "%s * %s", - unit_desc[base], - unit_desc[modifier]); + snprintf(unitstr, sizeof (unitstr), "%s * %s", + unit_desc[base], unit_desc[modifier]); break; case 1: - snprintf(unitstr, sizeof(unitstr), "%s/%s", - unit_desc[base], - unit_desc[modifier]); + snprintf(unitstr, sizeof (unitstr), "%s/%s", + unit_desc[base], unit_desc[modifier]); break; case 0: default: - snprintf(unitstr, sizeof(unitstr), "%s", - unit_desc[base]); + snprintf(unitstr, sizeof (unitstr), "%s", unit_desc[base]); break; } @@ -124,29 +123,28 @@ ipmi_sdr_get_unit_string(uint8_t type, uint8_t base, uint8_t modifier) * returns floating-point sensor reading */ double -sdr_convert_sensor_reading(struct sdr_record_full_sensor * sensor, - uint8_t val) +sdr_convert_sensor_reading(struct sdr_record_full_sensor *sensor, uint8_t val) { int m, b, k1, k2; double result; - m = __TO_M(sensor->mtol); - b = __TO_B(sensor->bacc); + m = __TO_M(sensor->mtol); + b = __TO_B(sensor->bacc); k1 = __TO_B_EXP(sensor->bacc); k2 = __TO_R_EXP(sensor->bacc); - switch (sensor->unit.analog) - { + switch (sensor->unit.analog) { case 0: - result = (double)(((m * val) + - (b * pow(10, k1))) * pow(10, k2)); + result = (double) (((m * val) + + (b * pow(10, k1))) * pow(10, k2)); break; case 1: - if (val & 0x80) val ++; + if (val & 0x80) + val++; /* Deliberately fall through to case 2. */ case 2: - result = (double)(((m * (int8_t)val) + - (b * pow(10, k1))) * pow(10, k2)); + result = (double) (((m * (int8_t) val) + + (b * pow(10, k1))) * pow(10, k2)); break; default: /* Oops! This isn't an analog sensor. */ @@ -161,7 +159,7 @@ sdr_convert_sensor_reading(struct sdr_record_full_sensor * sensor, result = log10(result); break; case SDR_SENSOR_L_LOG2: - result = (double)(log(result) / log(2.0)); + result = (double) (log(result) / log(2.0)); break; case SDR_SENSOR_L_E: result = exp(result); @@ -173,7 +171,7 @@ sdr_convert_sensor_reading(struct sdr_record_full_sensor * sensor, result = pow(2.0, result); break; case SDR_SENSOR_L_1_X: - result = pow(result, -1.0); /*1/x w/o exception*/ + result = pow(result, -1.0); /*1/x w/o exception */ break; case SDR_SENSOR_L_SQR: result = pow(result, 2.0); @@ -190,7 +188,7 @@ sdr_convert_sensor_reading(struct sdr_record_full_sensor * sensor, case SDR_SENSOR_L_LINEAR: default: break; - } + } return result; } @@ -207,10 +205,10 @@ sdr_convert_sensor_value_to_raw(struct sdr_record_full_sensor * sensor, double val) { int m, b, k1, k2; - double result; + double result; - m = __TO_M(sensor->mtol); - b = __TO_B(sensor->bacc); + m = __TO_M(sensor->mtol); + b = __TO_B(sensor->bacc); k1 = __TO_B_EXP(sensor->bacc); k2 = __TO_R_EXP(sensor->bacc); @@ -219,18 +217,17 @@ sdr_convert_sensor_value_to_raw(struct sdr_record_full_sensor * sensor, return 0; /* don't divide by zero */ - if (m == 0) + if (m == 0) return 0; - result = (((val / pow(10, k2)) - (b * pow(10, k1))) / m); + result = (((val / pow(10, k2)) - (b * pow(10, k1))) / m); - if ((result -(int)result) >= .5) - return (uint8_t)ceil(result); - else - return (uint8_t)result; + if ((result - (int) result) >= .5) + return (uint8_t) ceil(result); + else + return (uint8_t) result; } - /* ipmi_sdr_get_sensor_thresholds - return thresholds for sensor * * @intf: ipmi interface @@ -239,15 +236,15 @@ sdr_convert_sensor_value_to_raw(struct sdr_record_full_sensor * sensor, * returns pointer to ipmi response */ struct ipmi_rs * -ipmi_sdr_get_sensor_thresholds(struct ipmi_intf * intf, uint8_t sensor) +ipmi_sdr_get_sensor_thresholds(struct ipmi_intf *intf, uint8_t sensor) { struct ipmi_rq req; - memset(&req, 0, sizeof(req)); + memset(&req, 0, sizeof (req)); req.msg.netfn = IPMI_NETFN_SE; req.msg.cmd = GET_SENSOR_THRESHOLDS; req.msg.data = &sensor; - req.msg.data_len = sizeof(sensor); + req.msg.data_len = sizeof (sensor); return intf->sendrecv(intf, &req); } @@ -260,7 +257,7 @@ ipmi_sdr_get_sensor_thresholds(struct ipmi_intf * intf, uint8_t sensor) * returns pointer to ipmi response */ struct ipmi_rs * -ipmi_sdr_get_sensor_hysteresis(struct ipmi_intf * intf, uint8_t sensor) +ipmi_sdr_get_sensor_hysteresis(struct ipmi_intf *intf, uint8_t sensor) { struct ipmi_rq req; uint8_t rqdata[2]; @@ -268,7 +265,7 @@ ipmi_sdr_get_sensor_hysteresis(struct ipmi_intf * intf, uint8_t sensor) rqdata[0] = sensor; rqdata[1] = 0xff; /* reserved */ - memset(&req, 0, sizeof(req)); + memset(&req, 0, sizeof (req)); req.msg.netfn = IPMI_NETFN_SE; req.msg.cmd = GET_SENSOR_HYSTERESIS; req.msg.data = rqdata; @@ -285,11 +282,11 @@ ipmi_sdr_get_sensor_hysteresis(struct ipmi_intf * intf, uint8_t sensor) * returns ipmi response structure */ struct ipmi_rs * -ipmi_sdr_get_sensor_reading(struct ipmi_intf * intf, uint8_t sensor) +ipmi_sdr_get_sensor_reading(struct ipmi_intf *intf, uint8_t sensor) { struct ipmi_rq req; - memset(&req, 0, sizeof(req)); + memset(&req, 0, sizeof (req)); req.msg.netfn = IPMI_NETFN_SE; req.msg.cmd = GET_SENSOR_READING; req.msg.data = &sensor; @@ -307,16 +304,17 @@ ipmi_sdr_get_sensor_reading(struct ipmi_intf * intf, uint8_t sensor) * returns ipmi response structure */ struct ipmi_rs * -ipmi_sdr_get_sensor_reading_ipmb(struct ipmi_intf * intf, uint8_t sensor, uint8_t target) +ipmi_sdr_get_sensor_reading_ipmb(struct ipmi_intf *intf, uint8_t sensor, + uint8_t target) { struct ipmi_rq req; - struct ipmi_rs * rsp; + struct ipmi_rs *rsp; uint8_t save_addr; save_addr = intf->target_addr; intf->target_addr = target; - memset(&req, 0, sizeof(req)); + memset(&req, 0, sizeof (req)); req.msg.netfn = IPMI_NETFN_SE; req.msg.cmd = GET_SENSOR_READING; req.msg.data = &sensor; @@ -335,11 +333,11 @@ ipmi_sdr_get_sensor_reading_ipmb(struct ipmi_intf * intf, uint8_t sensor, uint8_ * returns ipmi response structure */ struct ipmi_rs * -ipmi_sdr_get_sensor_event_status(struct ipmi_intf * intf, uint8_t sensor) +ipmi_sdr_get_sensor_event_status(struct ipmi_intf *intf, uint8_t sensor) { struct ipmi_rq req; - memset(&req, 0, sizeof(req)); + memset(&req, 0, sizeof (req)); req.msg.netfn = IPMI_NETFN_SE; req.msg.cmd = GET_SENSOR_EVENT_STATUS; req.msg.data = &sensor; @@ -356,11 +354,11 @@ ipmi_sdr_get_sensor_event_status(struct ipmi_intf * intf, uint8_t sensor) * returns ipmi response structure */ struct ipmi_rs * -ipmi_sdr_get_sensor_event_enable(struct ipmi_intf * intf, uint8_t sensor) +ipmi_sdr_get_sensor_event_enable(struct ipmi_intf *intf, uint8_t sensor) { struct ipmi_rq req; - memset(&req, 0, sizeof(req)); + memset(&req, 0, sizeof (req)); req.msg.netfn = IPMI_NETFN_SE; req.msg.cmd = GET_SENSOR_EVENT_ENABLE; req.msg.data = &sensor; @@ -404,8 +402,7 @@ ipmi_sdr_get_sensor_type_desc(const uint8_t type) * us = unspecified (not used) */ const char * -ipmi_sdr_get_status(struct sdr_record_full_sensor * sensor, - uint8_t stat) +ipmi_sdr_get_status(struct sdr_record_full_sensor *sensor, uint8_t stat) { if (stat & SDR_SENSOR_STAT_LO_NR) { if (verbose) @@ -414,40 +411,35 @@ ipmi_sdr_get_status(struct sdr_record_full_sensor * sensor, return "lnr"; else return "nr"; - } - else if (stat & SDR_SENSOR_STAT_HI_NR) { + } else if (stat & SDR_SENSOR_STAT_HI_NR) { if (verbose) return "Upper Non-Recoverable"; else if (sdr_extended) return "unr"; else return "nr"; - } - else if (stat & SDR_SENSOR_STAT_LO_CR) { + } else if (stat & SDR_SENSOR_STAT_LO_CR) { if (verbose) return "Lower Critical"; else if (sdr_extended) return "lcr"; else return "cr"; - } - else if (stat & SDR_SENSOR_STAT_HI_CR) { + } else if (stat & SDR_SENSOR_STAT_HI_CR) { if (verbose) return "Upper Critical"; else if (sdr_extended) return "ucr"; else return "cr"; - } - else if (stat & SDR_SENSOR_STAT_LO_NC) { + } else if (stat & SDR_SENSOR_STAT_LO_NC) { if (verbose) return "Lower Non-Critical"; else if (sdr_extended) return "lnc"; else return "nc"; - } - else if (stat & SDR_SENSOR_STAT_HI_NC) { + } else if (stat & SDR_SENSOR_STAT_HI_NC) { if (verbose) return "Upper Non-Critical"; else if (sdr_extended) @@ -467,58 +459,65 @@ ipmi_sdr_get_status(struct sdr_record_full_sensor * sensor, * returns NULL on error */ static struct sdr_get_rs * -ipmi_sdr_get_header(struct ipmi_intf * intf, struct ipmi_sdr_iterator * itr) +ipmi_sdr_get_header(struct ipmi_intf *intf, struct ipmi_sdr_iterator *itr) { struct ipmi_rq req; - struct ipmi_rs * rsp; + struct ipmi_rs *rsp; struct sdr_get_rq sdr_rq; static struct sdr_get_rs sdr_rs; int try = 0; - memset(&sdr_rq, 0, sizeof(sdr_rq)); + memset(&sdr_rq, 0, sizeof (sdr_rq)); sdr_rq.reserve_id = itr->reservation; sdr_rq.id = itr->next; sdr_rq.offset = 0; sdr_rq.length = 5; /* only get the header */ - memset(&req, 0, sizeof(req)); - req.msg.netfn = IPMI_NETFN_STORAGE; - req.msg.cmd = GET_SDR; - req.msg.data = (uint8_t *)&sdr_rq; - req.msg.data_len = sizeof(sdr_rq); + memset(&req, 0, sizeof (req)); + if (use_built_in == 0) { + req.msg.netfn = IPMI_NETFN_STORAGE; + req.msg.cmd = GET_SDR; + } else { + req.msg.netfn = IPMI_NETFN_SE; + req.msg.cmd = GET_DEVICE_SDR; + } + req.msg.data = (uint8_t *) & sdr_rq; + req.msg.data_len = sizeof (sdr_rq); - for (try=0; try<5; try++) { + for (try = 0; try < 5; try++) { sdr_rq.reserve_id = itr->reservation; rsp = intf->sendrecv(intf, &req); if (rsp == NULL) { - lprintf(LOG_ERR, "Get SDR %04x command failed", itr->next); + lprintf(LOG_ERR, "Get SDR %04x command failed", + itr->next); continue; - } - else if (rsp->ccode == 0xc5) { + } else if (rsp->ccode == 0xc5) { /* lost reservation */ lprintf(LOG_DEBUG, "SDR reserveration %04x cancelled. " - "Sleeping a bit and retrying...", itr->reservation); + "Sleeping a bit and retrying...", + itr->reservation); sleep(rand() & 3); - if (ipmi_sdr_get_reservation(intf, &(itr->reservation)) < 0) { - lprintf(LOG_ERR, "Unable to renew SDR reservation"); + if (ipmi_sdr_get_reservation(intf, &(itr->reservation)) + < 0) { + lprintf(LOG_ERR, + "Unable to renew SDR reservation"); return NULL; } - } - else if (rsp->ccode > 0) { + } else if (rsp->ccode > 0) { lprintf(LOG_ERR, "Get SDR %04x command failed: %s", - itr->next, val2str(rsp->ccode, completion_code_vals)); + itr->next, val2str(rsp->ccode, + completion_code_vals)); continue; - } - else { + } else { break; } } lprintf(LOG_DEBUG, "SDR record ID : 0x%04x", itr->next); - memcpy(&sdr_rs, rsp->data, sizeof(sdr_rs)); + memcpy(&sdr_rs, rsp->data, sizeof (sdr_rs)); if (sdr_rs.length == 0) { lprintf(LOG_ERR, "SDR record id 0x%04x: invalid length %d", @@ -535,8 +534,7 @@ ipmi_sdr_get_header(struct ipmi_intf * intf, struct ipmi_sdr_iterator * itr) * not present" */ if (sdr_rs.id != itr->next) { - lprintf(LOG_DEBUG, "SDR record id mismatch: 0x%04x", - sdr_rs.id); + lprintf(LOG_DEBUG, "SDR record id mismatch: 0x%04x", sdr_rs.id); sdr_rs.id = itr->next; } @@ -556,8 +554,7 @@ ipmi_sdr_get_header(struct ipmi_intf * intf, struct ipmi_sdr_iterator * itr) * returns NULL on error */ struct sdr_get_rs * -ipmi_sdr_get_next_header(struct ipmi_intf * intf, - struct ipmi_sdr_iterator * itr) +ipmi_sdr_get_next_header(struct ipmi_intf *intf, struct ipmi_sdr_iterator *itr) { struct sdr_get_rs *header; @@ -599,44 +596,44 @@ ipmi_sdr_get_next_header(struct ipmi_intf * intf, sensor, sensor->threshold.READ)); \ } - int -ipmi_sdr_print_sensor_event_status(struct ipmi_intf * intf, +ipmi_sdr_print_sensor_event_status(struct ipmi_intf *intf, uint8_t sensor_num, uint8_t sensor_type, - uint8_t event_type, - int numeric_fmt) + uint8_t event_type, int numeric_fmt) { - struct ipmi_rs * rsp; + struct ipmi_rs *rsp; int i; const struct valstr assert_cond_1[] = { - { 0x80, "unc+" }, - { 0x40, "unc-" }, - { 0x20, "lnr+" }, - { 0x10, "lnr-" }, - { 0x08, "lcr+" }, - { 0x04, "lcr-" }, - { 0x02, "lnc+" }, - { 0x01, "lnc-" }, - { 0x00, NULL }, + {0x80, "unc+"}, + {0x40, "unc-"}, + {0x20, "lnr+"}, + {0x10, "lnr-"}, + {0x08, "lcr+"}, + {0x04, "lcr-"}, + {0x02, "lnc+"}, + {0x01, "lnc-"}, + {0x00, NULL}, }; const struct valstr assert_cond_2[] = { - { 0x08, "unr+" }, - { 0x04, "unr-" }, - { 0x02, "ucr+" }, - { 0x01, "ucr-" }, - { 0x00, NULL }, + {0x08, "unr+"}, + {0x04, "unr-"}, + {0x02, "ucr+"}, + {0x01, "ucr-"}, + {0x00, NULL}, }; rsp = ipmi_sdr_get_sensor_event_status(intf, sensor_num); if (rsp == NULL) { - lprintf(LOG_DEBUG, "Error reading event status for sensor #%02x", + lprintf(LOG_DEBUG, + "Error reading event status for sensor #%02x", sensor_num); return -1; } if (rsp->ccode > 0) { - lprintf(LOG_DEBUG, "Error reading event status for sensor #%02x: %s", + lprintf(LOG_DEBUG, + "Error reading event status for sensor #%02x: %s", sensor_num, val2str(rsp->ccode, completion_code_vals)); return -1; } @@ -657,46 +654,56 @@ ipmi_sdr_print_sensor_event_status(struct ipmi_intf * intf, switch (numeric_fmt) { case DISCRETE_SENSOR: if (rsp->data_len == 2) { - ipmi_sdr_print_discrete_state("Assertion Events", sensor_type, - event_type, rsp->data[1], 0); - } - else if (rsp->data_len > 2) { - ipmi_sdr_print_discrete_state("Assertion Events", sensor_type, - event_type, rsp->data[1], rsp->data[2]); + ipmi_sdr_print_discrete_state("Assertion Events", + sensor_type, event_type, + rsp->data[1], 0); + } else if (rsp->data_len > 2) { + ipmi_sdr_print_discrete_state("Assertion Events", + sensor_type, event_type, + rsp->data[1], + rsp->data[2]); } if (rsp->data_len == 4) { - ipmi_sdr_print_discrete_state("Deassertion Events", sensor_type, - event_type, rsp->data[3], 0); - } - else if (rsp->data_len > 4) { - ipmi_sdr_print_discrete_state("Deassertion Events", sensor_type, - event_type, rsp->data[3], rsp->data[4]); + ipmi_sdr_print_discrete_state("Deassertion Events", + sensor_type, event_type, + rsp->data[3], 0); + } else if (rsp->data_len > 4) { + ipmi_sdr_print_discrete_state("Deassertion Events", + sensor_type, event_type, + rsp->data[3], + rsp->data[4]); } break; case ANALOG_SENSOR: printf(" Assertion Events : "); for (i = 0; i < 8; i++) { - if (rsp->data[1] & (1<data[1] & (1 << i)) + printf("%s ", val2str(1 << i, assert_cond_1)); } if (rsp->data_len > 2) { for (i = 0; i < 4; i++) { - if (rsp->data[2] & (1<data[2] & (1 << i)) + printf("%s ", + val2str(1 << i, assert_cond_2)); } printf("\n"); if ((rsp->data_len == 4 && rsp->data[3] != 0) || - (rsp->data_len > 4 && (rsp->data[3] != 0 && rsp->data[4] != 0))) { + (rsp->data_len > 4 + && (rsp->data[3] != 0 && rsp->data[4] != 0))) { printf(" Deassertion Events : "); for (i = 0; i < 8; i++) { - if (rsp->data[3] & (1<data[3] & (1 << i)) + printf("%s ", + val2str(1 << i, + assert_cond_1)); } if (rsp->data_len > 4) { for (i = 0; i < 4; i++) { - if (rsp->data[4] & (1<data[4] & (1 << i)) + printf("%s ", + val2str(1 << i, + assert_cond_2)); } } printf("\n"); @@ -714,24 +721,26 @@ ipmi_sdr_print_sensor_event_status(struct ipmi_intf * intf, } static int -ipmi_sdr_print_sensor_mask(struct sdr_record_mask * mask, +ipmi_sdr_print_sensor_mask(struct sdr_record_mask *mask, uint8_t sensor_type, - uint8_t event_type, - int numeric_fmt) + uint8_t event_type, int numeric_fmt) { return 0; - switch (numeric_fmt) - { + switch (numeric_fmt) { case DISCRETE_SENSOR: ipmi_sdr_print_discrete_state("Assert Event Mask", sensor_type, event_type, - mask->type.discrete.assert_event & 0xff, - (mask->type.discrete.assert_event & 0xff00) >> 8); - ipmi_sdr_print_discrete_state("Deassert Event Mask", sensor_type, - event_type, - mask->type.discrete.deassert_event & 0xff, - (mask->type.discrete.deassert_event & 0xff00) >> 8); + mask->type.discrete. + assert_event & 0xff, + (mask->type.discrete. + assert_event & 0xff00) >> 8); + ipmi_sdr_print_discrete_state("Deassert Event Mask", + sensor_type, event_type, + mask->type.discrete. + deassert_event & 0xff, + (mask->type.discrete. + deassert_event & 0xff00) >> 8); break; case ANALOG_SENSOR: @@ -798,42 +807,43 @@ ipmi_sdr_print_sensor_mask(struct sdr_record_mask * mask, } int -ipmi_sdr_print_sensor_event_enable(struct ipmi_intf * intf, +ipmi_sdr_print_sensor_event_enable(struct ipmi_intf *intf, uint8_t sensor_num, uint8_t sensor_type, - uint8_t event_type, - int numeric_fmt) + uint8_t event_type, int numeric_fmt) { - struct ipmi_rs * rsp; + struct ipmi_rs *rsp; int i; const struct valstr assert_cond_1[] = { - { 0x80, "unc+" }, - { 0x40, "unc-" }, - { 0x20, "lnr+" }, - { 0x10, "lnr-" }, - { 0x08, "lcr+" }, - { 0x04, "lcr-" }, - { 0x02, "lnc+" }, - { 0x01, "lnc-" }, - { 0x00, NULL }, + {0x80, "unc+"}, + {0x40, "unc-"}, + {0x20, "lnr+"}, + {0x10, "lnr-"}, + {0x08, "lcr+"}, + {0x04, "lcr-"}, + {0x02, "lnc+"}, + {0x01, "lnc-"}, + {0x00, NULL}, }; const struct valstr assert_cond_2[] = { - { 0x08, "unr+" }, - { 0x04, "unr-" }, - { 0x02, "ucr+" }, - { 0x01, "ucr-" }, - { 0x00, NULL }, + {0x08, "unr+"}, + {0x04, "unr-"}, + {0x02, "ucr+"}, + {0x01, "ucr-"}, + {0x00, NULL}, }; rsp = ipmi_sdr_get_sensor_event_enable(intf, sensor_num); if (rsp == NULL) { - lprintf(LOG_DEBUG, "Error reading event enable for sensor #%02x", + lprintf(LOG_DEBUG, + "Error reading event enable for sensor #%02x", sensor_num); return -1; } if (rsp->ccode > 0) { - lprintf(LOG_DEBUG, "Error reading event enable for sensor #%02x: %s", + lprintf(LOG_DEBUG, + "Error reading event enable for sensor #%02x: %s", sensor_num, val2str(rsp->ccode, completion_code_vals)); return -1; } @@ -847,25 +857,28 @@ ipmi_sdr_print_sensor_event_enable(struct ipmi_intf * intf, //return 0; } - switch (numeric_fmt) - { + switch (numeric_fmt) { case DISCRETE_SENSOR: /* discrete */ if (rsp->data_len == 2) { - ipmi_sdr_print_discrete_state("Assertions Enabled", sensor_type, - event_type, rsp->data[1], 0); - } - else if (rsp->data_len > 2) { - ipmi_sdr_print_discrete_state("Assertions Enabled", sensor_type, - event_type, rsp->data[1], rsp->data[2]); + ipmi_sdr_print_discrete_state("Assertions Enabled", + sensor_type, event_type, + rsp->data[1], 0); + } else if (rsp->data_len > 2) { + ipmi_sdr_print_discrete_state("Assertions Enabled", + sensor_type, event_type, + rsp->data[1], + rsp->data[2]); } if (rsp->data_len == 4) { - ipmi_sdr_print_discrete_state("Deassertions Enabled", sensor_type, - event_type, rsp->data[3], 0); - } - else if (rsp->data_len > 4) { - ipmi_sdr_print_discrete_state("Deassertions Enabled", sensor_type, - event_type, rsp->data[3], rsp->data[4]); + ipmi_sdr_print_discrete_state("Deassertions Enabled", + sensor_type, event_type, + rsp->data[3], 0); + } else if (rsp->data_len > 4) { + ipmi_sdr_print_discrete_state("Deassertions Enabled", + sensor_type, event_type, + rsp->data[3], + rsp->data[4]); } break; @@ -873,26 +886,32 @@ ipmi_sdr_print_sensor_event_enable(struct ipmi_intf * intf, /* analog */ printf(" Assertions Enabled : "); for (i = 0; i < 8; i++) { - if (rsp->data[1] & (1<data[1] & (1 << i)) + printf("%s ", val2str(1 << i, assert_cond_1)); } if (rsp->data_len > 2) { for (i = 0; i < 4; i++) { - if (rsp->data[2] & (1<data[2] & (1 << i)) + printf("%s ", + val2str(1 << i, assert_cond_2)); } printf("\n"); if ((rsp->data_len == 4 && rsp->data[3] != 0) || - (rsp->data_len > 4 && (rsp->data[3] != 0 || rsp->data[4] != 0))) { + (rsp->data_len > 4 + && (rsp->data[3] != 0 || rsp->data[4] != 0))) { printf(" Deassertions Enabled : "); for (i = 0; i < 8; i++) { - if (rsp->data[3] & (1<data[3] & (1 << i)) + printf("%s ", + val2str(1 << i, + assert_cond_1)); } if (rsp->data_len > 4) { for (i = 0; i < 4; i++) { - if (rsp->data[4] & (1<data[4] & (1 << i)) + printf("%s ", + val2str(1 << i, + assert_cond_2)); } } printf("\n"); @@ -918,26 +937,26 @@ ipmi_sdr_print_sensor_event_enable(struct ipmi_intf * intf, * returns -1 on error */ int -ipmi_sdr_print_sensor_full(struct ipmi_intf * intf, - struct sdr_record_full_sensor * sensor) +ipmi_sdr_print_sensor_full(struct ipmi_intf *intf, + struct sdr_record_full_sensor *sensor) { char sval[16], unitstr[16], desc[17]; - int i=0, validread=1, do_unit=1; + int i = 0, validread = 1, do_unit = 1; double val = 0.0, creading = 0.0; - struct ipmi_rs * rsp; - uint8_t min_reading, max_reading; + struct ipmi_rs *rsp; + uint8_t min_reading, max_reading; if (sensor == NULL) return -1; - memset(desc, 0, sizeof(desc)); + memset(desc, 0, sizeof (desc)); snprintf(desc, (sensor->id_code & 0x1f) + 1, "%s", sensor->id_string); - /* only handle linear sensors and linearized sensors (for now) */ - if (sensor->linearization>=SDR_SENSOR_L_NONLINEAR) { - printf("sensor %s non-linear!\n", desc); - return -1; - } + /* only handle linear sensors and linearized sensors (for now) */ + if (sensor->linearization >= SDR_SENSOR_L_NONLINEAR) { + printf("sensor %s non-linear!\n", desc); + return -1; + } /* get sensor reading */ rsp = ipmi_sdr_get_sensor_reading(intf, sensor->keys.sensor_num); @@ -952,27 +971,28 @@ ipmi_sdr_print_sensor_full(struct ipmi_intf * intf, /* sensor not found */ validread = 0; } else { - lprintf(LOG_DEBUG, "Error reading sensor %s (#%02x): %s", - desc, sensor->keys.sensor_num, - val2str(rsp->ccode, completion_code_vals)); + lprintf(LOG_DEBUG, + "Error reading sensor %s (#%02x): %s", desc, + sensor->keys.sensor_num, val2str(rsp->ccode, + completion_code_vals)); validread = 0; } } else { if (IS_READING_UNAVAILABLE(rsp->data[1])) { /* sensor reading unavailable */ validread = 0; - } - else if (IS_SCANNING_DISABLED(rsp->data[1])) { + } else if (IS_SCANNING_DISABLED(rsp->data[1])) { /* Sensor Scanning Disabled */ validread = 0; if (rsp->data[0] != 0) { /* we might still get a valid reading */ - val = sdr_convert_sensor_reading(sensor, rsp->data[0]); + val = + sdr_convert_sensor_reading(sensor, + rsp->data[0]); if (val != 0.0) validread = 1; } - } - else if (rsp->data[0] != 0) { + } else if (rsp->data[0] != 0) { /* convert RAW reading into units */ val = sdr_convert_sensor_reading(sensor, rsp->data[0]); } @@ -980,21 +1000,21 @@ ipmi_sdr_print_sensor_full(struct ipmi_intf * intf, /* determine units with possible modifiers */ if (do_unit && validread) { - memset(unitstr, 0, sizeof(unitstr)); + memset(unitstr, 0, sizeof (unitstr)); switch (sensor->unit.modifier) { case 2: - i += snprintf(unitstr, sizeof(unitstr), "%s * %s", + i += snprintf(unitstr, sizeof (unitstr), "%s * %s", unit_desc[sensor->unit.type.base], unit_desc[sensor->unit.type.modifier]); break; case 1: - i += snprintf(unitstr, sizeof(unitstr), "%s/%s", + i += snprintf(unitstr, sizeof (unitstr), "%s/%s", unit_desc[sensor->unit.type.base], unit_desc[sensor->unit.type.modifier]); break; case 0: default: - i += snprintf(unitstr, sizeof(unitstr), "%s", + i += snprintf(unitstr, sizeof (unitstr), "%s", unit_desc[sensor->unit.type.base]); break; } @@ -1011,19 +1031,19 @@ ipmi_sdr_print_sensor_full(struct ipmi_intf * intf, printf("%s,", sensor->id_code ? desc : ""); if (validread) { - printf("%.*f,", (val==(int)val) ? 0 : 3, val); + printf("%.*f,", (val == (int) val) ? 0 : 3, val); printf("%s,%s", do_unit ? unitstr : "", ipmi_sdr_get_status(sensor, rsp->data[2])); } else { printf(",,ns"); } - if (verbose) - { + if (verbose) { printf(",%d.%d,%s,%s,", sensor->entity.id, sensor->entity.instance, val2str(sensor->entity.id, entity_id_vals), - ipmi_sdr_get_sensor_type_desc(sensor->sensor.type)); + ipmi_sdr_get_sensor_type_desc(sensor->sensor. + type)); SENSOR_PRINT_CSV(sensor->analog_flag.nominal_read, sensor->nominal_read); @@ -1044,11 +1064,11 @@ ipmi_sdr_print_sensor_full(struct ipmi_intf * intf, SENSOR_PRINT_CSV(sensor->mask.type.threshold.read.lnc, sensor->threshold.lower.non_critical); - printf ("%.3f,%.3f", - sdr_convert_sensor_reading(sensor, - sensor->sensor_min), - sdr_convert_sensor_reading(sensor, - sensor->sensor_max)); + printf("%.3f,%.3f", + sdr_convert_sensor_reading(sensor, + sensor->sensor_min), + sdr_convert_sensor_reading(sensor, + sensor->sensor_max)); } printf("\n"); @@ -1066,21 +1086,21 @@ ipmi_sdr_print_sensor_full(struct ipmi_intf * intf, printf("%-16s | ", sensor->id_code ? desc : ""); i = 0; - memset(sval, 0, sizeof(sval)); + memset(sval, 0, sizeof (sval)); if (validread) - i += snprintf(sval, sizeof(sval), "%.*f %s", - (val==(int)val) ? 0 : 2, val, + i += snprintf(sval, sizeof (sval), "%.*f %s", + (val == (int) val) ? 0 : 2, val, do_unit ? unitstr : ""); else if (IS_SCANNING_DISABLED(rsp->data[1])) - i += snprintf(sval, sizeof(sval), "disabled "); + i += snprintf(sval, sizeof (sval), "disabled "); else - i += snprintf(sval, sizeof(sval), "no reading "); + i += snprintf(sval, sizeof (sval), "no reading "); printf("%s", sval); i--; - for (; iid_code ? desc : "", sensor->keys.sensor_num, - validread ? ipmi_sdr_get_status(sensor, rsp->data[2]) : "ns", + validread ? ipmi_sdr_get_status(sensor, + rsp->data[2]) : "ns", sensor->entity.id, sensor->entity.instance); i = 0; - memset(sval, 0, sizeof(sval)); + memset(sval, 0, sizeof (sval)); if (validread) - i += snprintf(sval, sizeof(sval), "%.*f %s", - (val==(int)val) ? 0 : 2, val, + i += snprintf(sval, sizeof (sval), "%.*f %s", + (val == (int) val) ? 0 : 2, val, do_unit ? unitstr : ""); else if (IS_SCANNING_DISABLED(rsp->data[1])) - i += snprintf(sval, sizeof(sval), "Disabled"); + i += snprintf(sval, sizeof (sval), "Disabled"); else - i += snprintf(sval, sizeof(sval), "No Reading"); + i += snprintf(sval, sizeof (sval), "No Reading"); printf("%s\n", sval); return 0; /* done */ @@ -1120,19 +1140,18 @@ ipmi_sdr_print_sensor_full(struct ipmi_intf * intf, */ printf("Sensor ID : %s (0x%x)\n", - sensor->id_code ? desc : "", - sensor->keys.sensor_num); + sensor->id_code ? desc : "", sensor->keys.sensor_num); printf(" Entity ID : %d.%d (%s)\n", sensor->entity.id, sensor->entity.instance, val2str(sensor->entity.id, entity_id_vals)); if (sensor->unit.analog == 3) { /* discrete sensor */ - printf(" Sensor Type (Discrete): %s\n", + printf(" Sensor Type (Discrete): %s\n", ipmi_sdr_get_sensor_type_desc(sensor->sensor.type)); printf(" Sensor Reading : "); if (validread) - printf("%xh\n", (uint32_t)val); + printf("%xh\n", (uint32_t) val); else if (IS_SCANNING_DISABLED(rsp->data[1])) printf("Disabled\n"); else @@ -1151,15 +1170,15 @@ ipmi_sdr_print_sensor_full(struct ipmi_intf * intf, break; case 3: printf("No Events From Sensor\n"); - break; + break; } - ipmi_sdr_print_discrete_state("States Asserted", sensor->sensor.type, - sensor->event_type, rsp->data[2], rsp->data[3]); - ipmi_sdr_print_sensor_mask(&sensor->mask, - sensor->sensor.type, - sensor->event_type, - DISCRETE_SENSOR); + ipmi_sdr_print_discrete_state("States Asserted", + sensor->sensor.type, + sensor->event_type, rsp->data[2], + rsp->data[3]); + ipmi_sdr_print_sensor_mask(&sensor->mask, sensor->sensor.type, + sensor->event_type, DISCRETE_SENSOR); ipmi_sdr_print_sensor_event_status(intf, sensor->keys.sensor_num, sensor->sensor.type, @@ -1176,7 +1195,7 @@ ipmi_sdr_print_sensor_full(struct ipmi_intf * intf, } /* analog sensor */ - printf(" Sensor Type (Analog) : %s\n", + printf(" Sensor Type (Analog) : %s\n", ipmi_sdr_get_sensor_type_desc(sensor->sensor.type)); printf(" Sensor Reading : "); @@ -1184,23 +1203,21 @@ ipmi_sdr_print_sensor_full(struct ipmi_intf * intf, uint16_t raw_tol = __TO_TOL(sensor->mtol); double tol = sdr_convert_sensor_reading(sensor, raw_tol * 2); printf("%.*f (+/- %.*f) %s\n", - (val==(int)val) ? 0 : 3, - val, - (tol==(int)tol) ? 0 : 3, - tol, - unitstr); + (val == (int) val) ? 0 : 3, + val, (tol == (int) tol) ? 0 : 3, tol, unitstr); } else if (IS_SCANNING_DISABLED(rsp->data[1])) printf("Disabled\n"); else printf("No Reading\n"); printf(" Status : %s\n", - validread ? ipmi_sdr_get_status(sensor, rsp->data[2]) : "Disabled"); + validread ? ipmi_sdr_get_status(sensor, + rsp->data[2]) : "Disabled"); SENSOR_PRINT_NORMAL("Nominal Reading", nominal_read); SENSOR_PRINT_NORMAL("Normal Minimum", normal_min); SENSOR_PRINT_NORMAL("Normal Maximum", normal_max); - + SENSOR_PRINT_THRESH("Upper non-recoverable", upper.non_recover, unr); SENSOR_PRINT_THRESH("Upper critical", upper.critical, ucr); SENSOR_PRINT_THRESH("Upper non-critical", upper.non_critical, unc); @@ -1208,18 +1225,20 @@ ipmi_sdr_print_sensor_full(struct ipmi_intf * intf, SENSOR_PRINT_THRESH("Lower critical", lower.critical, lcr); SENSOR_PRINT_THRESH("Lower non-critical", lower.non_critical, lnc); - creading = sdr_convert_sensor_reading(sensor, sensor->threshold.hysteresis.positive); - if (sensor->threshold.hysteresis.positive == 0x00 || - sensor->threshold.hysteresis.positive == 0xff || - creading == 0) + creading = + sdr_convert_sensor_reading(sensor, + sensor->threshold.hysteresis.positive); + if (sensor->threshold.hysteresis.positive == 0x00 + || sensor->threshold.hysteresis.positive == 0xff || creading == 0) printf(" Positive Hysteresis : Unspecified\n"); else printf(" Positive Hysteresis : %.3f\n", creading); - creading = sdr_convert_sensor_reading(sensor, sensor->threshold.hysteresis.negative); - if (sensor->threshold.hysteresis.negative == 0x00 || - sensor->threshold.hysteresis.negative == 0xff || - creading == 0.0) + creading = + sdr_convert_sensor_reading(sensor, + sensor->threshold.hysteresis.negative); + if (sensor->threshold.hysteresis.negative == 0x00 + || sensor->threshold.hysteresis.negative == 0xff || creading == 0.0) printf(" Negative Hysteresis : Unspecified\n"); else printf(" Negative Hysteresis : %.3f\n", creading); @@ -1263,8 +1282,8 @@ ipmi_sdr_print_sensor_full(struct ipmi_intf * intf, case 0: printf("No Thresholds\n"); break; - case 1: /* readable according to mask */ - case 2: /* readable and settable according to mask */ + case 1: /* readable according to mask */ + case 2: /* readable and settable according to mask */ if (sensor->mask.type.threshold.read.lnr) printf("lnr "); if (sensor->mask.type.threshold.read.lcr) @@ -1289,8 +1308,8 @@ ipmi_sdr_print_sensor_full(struct ipmi_intf * intf, case 0: printf("No Thresholds\n"); break; - case 1: /* readable according to mask */ - case 2: /* readable and settable according to mask */ + case 1: /* readable according to mask */ + case 2: /* readable and settable according to mask */ if (sensor->mask.type.threshold.set.lnr) printf("lnr "); if (sensor->mask.type.threshold.set.lcr) @@ -1334,31 +1353,27 @@ ipmi_sdr_print_sensor_full(struct ipmi_intf * intf, ipmi_sdr_print_sensor_mask(&sensor->mask, sensor->sensor.type, - sensor->event_type, - ANALOG_SENSOR); + sensor->event_type, ANALOG_SENSOR); ipmi_sdr_print_sensor_event_status(intf, sensor->keys.sensor_num, sensor->sensor.type, - sensor->event_type, - ANALOG_SENSOR); + sensor->event_type, ANALOG_SENSOR); ipmi_sdr_print_sensor_event_enable(intf, sensor->keys.sensor_num, sensor->sensor.type, - sensor->event_type, - ANALOG_SENSOR); + sensor->event_type, ANALOG_SENSOR); printf("\n"); return 0; } - static inline int get_offset(uint8_t x) { int i; - for (i=0; i<8; i++) - if (x>>i == 1) + for (i = 0; i < 8; i++) + if (x >> i == 1) return i; return 0; } @@ -1372,58 +1387,8 @@ get_offset(uint8_t x) * * no meaningful return value */ -void ipmi_sdr_print_discrete_state_mini( - const char * separator, - uint8_t sensor_type, uint8_t event_type, - uint8_t state1, uint8_t state2) -{ - uint8_t typ; - struct ipmi_event_sensor_types *evt; - int pre = 0, c = 0; - - if (state1 == 0) - return; - - if (event_type == 0x6f) { - evt = sensor_specific_types; - typ = sensor_type; - } else { - evt = generic_event_types; - typ = event_type; - } - - for (; evt->type != NULL; evt++) { - if (evt->code != typ) - continue; - - if (evt->offset > 7) { - if ((1<<(evt->offset-8)) & state2) { - if (pre++ != 0) - printf("%s", separator); - printf("%s", evt->desc); - } - } else { - if ((1<offset) & state1) { - if (pre++ != 0) - printf("%s", separator); - printf("%s", evt->desc); - } - } - c++; - } -} - -/* ipmi_sdr_print_discrete_state - print list of asserted states - * for a discrete sensor - * - * @desc : description for this line - * @sensor_type : sensor type code - * @event_type : event type code - * @state : mask of asserted states - * - * no meaningful return value - */ -void ipmi_sdr_print_discrete_state(const char * desc, +void +ipmi_sdr_print_discrete_state_mini(const char *separator, uint8_t sensor_type, uint8_t event_type, uint8_t state1, uint8_t state2) { @@ -1445,18 +1410,71 @@ void ipmi_sdr_print_discrete_state(const char * desc, for (; evt->type != NULL; evt++) { if (evt->code != typ) continue; - + + if (evt->offset > 7) { + if ((1 << (evt->offset - 8)) & state2) { + if (pre++ != 0) + printf("%s", separator); + printf("%s", evt->desc); + } + } else { + if ((1 << evt->offset) & state1) { + if (pre++ != 0) + printf("%s", separator); + printf("%s", evt->desc); + } + } + c++; + } +} + +/* ipmi_sdr_print_discrete_state - print list of asserted states + * for a discrete sensor + * + * @desc : description for this line + * @sensor_type : sensor type code + * @event_type : event type code + * @state : mask of asserted states + * + * no meaningful return value + */ +void +ipmi_sdr_print_discrete_state(const char *desc, + uint8_t sensor_type, uint8_t event_type, + uint8_t state1, uint8_t state2) +{ + uint8_t typ; + struct ipmi_event_sensor_types *evt; + int pre = 0, c = 0; + + if (state1 == 0) + return; + + if (event_type == 0x6f) { + evt = sensor_specific_types; + typ = sensor_type; + } else { + evt = generic_event_types; + typ = event_type; + } + + for (; evt->type != NULL; evt++) { + if (evt->code != typ) + continue; + if (pre == 0) { printf(" %-21s : %s\n", desc, evt->type); pre = 1; } if (evt->offset > 7) { - if ((1<<(evt->offset-8)) & state2) - printf(" [%s]\n", evt->desc); + if ((1 << (evt->offset - 8)) & state2) + printf(" [%s]\n", + evt->desc); } else { - if ((1<offset) & state1) - printf(" [%s]\n", evt->desc); + if ((1 << evt->offset) & state1) + printf(" [%s]\n", + evt->desc); } c++; } @@ -1471,17 +1489,17 @@ void ipmi_sdr_print_discrete_state(const char * desc, * returns -1 on error */ int -ipmi_sdr_print_sensor_compact(struct ipmi_intf * intf, - struct sdr_record_compact_sensor * sensor) +ipmi_sdr_print_sensor_compact(struct ipmi_intf *intf, + struct sdr_record_compact_sensor *sensor) { - struct ipmi_rs * rsp; + struct ipmi_rs *rsp; char desc[17]; int validread = 1; if (sensor == NULL) return -1; - memset(desc, 0, sizeof(desc)); + memset(desc, 0, sizeof (desc)); snprintf(desc, (sensor->id_code & 0x1f) + 1, "%s", sensor->id_string); /* get sensor reading */ @@ -1494,8 +1512,8 @@ ipmi_sdr_print_sensor_compact(struct ipmi_intf * intf, if (rsp->ccode > 0 && rsp->ccode != 0xcd) { /* completion code 0xcd is special case */ lprintf(LOG_DEBUG, "Error reading sensor %s (#%02x): %s", - desc, sensor->keys.sensor_num, - val2str(rsp->ccode, completion_code_vals)); + desc, sensor->keys.sensor_num, + val2str(rsp->ccode, completion_code_vals)); validread = 0; } @@ -1508,8 +1526,7 @@ ipmi_sdr_print_sensor_compact(struct ipmi_intf * intf, if (verbose) { printf("Sensor ID : %s (0x%x)\n", - (sensor->id_code) ? desc : "", - sensor->keys.sensor_num); + (sensor->id_code) ? desc : "", sensor->keys.sensor_num); printf(" Entity ID : %d.%d (%s)\n", sensor->entity.id, sensor->entity.instance, val2str(sensor->entity.id, entity_id_vals)); @@ -1530,10 +1547,9 @@ ipmi_sdr_print_sensor_compact(struct ipmi_intf * intf, rsp->data[3]); ipmi_sdr_print_sensor_mask(&sensor->mask, sensor->sensor.type, - sensor->event_type, - DISCRETE_SENSOR); + sensor->event_type, DISCRETE_SENSOR); ipmi_sdr_print_sensor_event_status(intf, - sensor->keys.sensor_num, + sensor->keys.sensor_num, sensor->sensor.type, sensor->event_type, DISCRETE_SENSOR); @@ -1543,8 +1559,7 @@ ipmi_sdr_print_sensor_compact(struct ipmi_intf * intf, sensor->event_type, DISCRETE_SENSOR); printf("\n"); - } - else { + } else { int dostate = 1; if (csv_output) { @@ -1556,58 +1571,53 @@ ipmi_sdr_print_sensor_compact(struct ipmi_intf * intf, sensor->entity.id, sensor->entity.instance); dostate = 0; - } - else if (rsp->ccode == 0) { + } else if (rsp->ccode == 0) { if (IS_READING_UNAVAILABLE(rsp->data[1])) { printf("ns,%d.%d,No Reading", sensor->entity.id, sensor->entity.instance); dostate = 0; - } - else + } else printf("ok,%d.%d,", sensor->entity.id, sensor->entity.instance); } - } - else if (sdr_extended) { + } else if (sdr_extended) { printf("%-16s | %02Xh | ", sensor->id_code ? desc : "", sensor->keys.sensor_num); if (validread == 0 || rsp->ccode != 0) { printf("ns | %2d.%1d | ", - sensor->entity.id, sensor->entity.instance); + sensor->entity.id, + sensor->entity.instance); if (IS_SCANNING_DISABLED(rsp->data[1])) printf("Disabled"); else printf("No Reading"); dostate = 0; - } - else { + } else { if (IS_READING_UNAVAILABLE(rsp->data[1])) { printf("ns | %2d.%1d | No Reading", - sensor->entity.id, sensor->entity.instance); + sensor->entity.id, + sensor->entity.instance); dostate = 0; - } - else + } else printf("ok | %2d.%1d | ", - sensor->entity.id, sensor->entity.instance); + sensor->entity.id, + sensor->entity.instance); } - } - else { - char * state; + } else { + char *state; char temp[18]; if (validread == 0) { state = csv_output ? - "Not Readable" : - "Not Readable "; + "Not Readable" : "Not Readable "; } else if (rsp->data_len > 1 && IS_READING_UNAVAILABLE(rsp->data[1])) { state = csv_output ? - "Not Readable" : - "Not Readable "; + "Not Readable" : "Not Readable "; } else { sprintf(temp, "0x%02x", rsp->data[2]); state = temp; @@ -1627,7 +1637,7 @@ ipmi_sdr_print_sensor_compact(struct ipmi_intf * intf, dostate = 0; } - if (dostate) + if (dostate) ipmi_sdr_print_discrete_state_mini(", ", sensor->sensor.type, sensor->event_type, @@ -1649,31 +1659,29 @@ ipmi_sdr_print_sensor_compact(struct ipmi_intf * intf, * returns -1 on error */ int -ipmi_sdr_print_sensor_eventonly(struct ipmi_intf * intf, - struct sdr_record_eventonly_sensor * sensor) +ipmi_sdr_print_sensor_eventonly(struct ipmi_intf *intf, + struct sdr_record_eventonly_sensor *sensor) { char desc[17]; if (sensor == NULL) return -1; - memset(desc, 0, sizeof(desc)); + memset(desc, 0, sizeof (desc)); snprintf(desc, (sensor->id_code & 0x1f) + 1, "%s", sensor->id_string); if (verbose) { printf("Sensor ID : %s (0x%x)\n", - sensor->id_code ? desc : "", - sensor->keys.sensor_num); + sensor->id_code ? desc : "", sensor->keys.sensor_num); printf("Entity ID : %d.%d (%s)\n", sensor->entity.id, sensor->entity.instance, val2str(sensor->entity.id, entity_id_vals)); - printf("Sensor Type : %s\n", - ipmi_sdr_get_sensor_type_desc(sensor->sensor_type)); + printf("Sensor Type : %s\n", + ipmi_sdr_get_sensor_type_desc(sensor->sensor_type)); lprintf(LOG_DEBUG, "Event Type Code : 0x%02x", sensor->event_type); printf("\n"); - } - else { + } else { if (csv_output) printf("%s,%02Xh,ns,%d.%d,Event-Only\n", sensor->id_code ? desc : "", @@ -1701,15 +1709,15 @@ ipmi_sdr_print_sensor_eventonly(struct ipmi_intf * intf, * returns -1 on error */ int -ipmi_sdr_print_sensor_mc_locator(struct ipmi_intf * intf, - struct sdr_record_mc_locator * mc) +ipmi_sdr_print_sensor_mc_locator(struct ipmi_intf *intf, + struct sdr_record_mc_locator *mc) { char desc[17]; if (mc == NULL) return -1; - memset(desc, 0, sizeof(desc)); + memset(desc, 0, sizeof (desc)); snprintf(desc, (mc->id_code & 0x1f) + 1, "%s", mc->id_string); if (verbose == 0) { @@ -1723,19 +1731,20 @@ ipmi_sdr_print_sensor_mc_locator(struct ipmi_intf * intf, mc->entity.id, mc->entity.instance); printf("%s MC @ %02Xh\n", - (mc->pwr_state_notif & 0x1) ? "Static" : "Dynamic", + (mc-> + pwr_state_notif & 0x1) ? "Static" : "Dynamic", mc->dev_slave_addr); - } - else { + } else { printf("%-16s | %s MC @ %02Xh %s | ok\n", mc->id_code ? desc : "", - (mc->pwr_state_notif & 0x1) ? "Static" : "Dynamic", + (mc-> + pwr_state_notif & 0x1) ? "Static" : "Dynamic", mc->dev_slave_addr, (mc->pwr_state_notif & 0x1) ? " " : ""); } return 0; /* done */ - } + } printf("Device ID : %s\n", mc->id_string); printf("Entity ID : %d.%d (%s)\n", @@ -1796,12 +1805,12 @@ ipmi_sdr_print_sensor_mc_locator(struct ipmi_intf * intf, * returns -1 on error */ int -ipmi_sdr_print_sensor_generic_locator(struct ipmi_intf * intf, - struct sdr_record_generic_locator * dev) +ipmi_sdr_print_sensor_generic_locator(struct ipmi_intf *intf, + struct sdr_record_generic_locator *dev) { char desc[17]; - memset(desc, 0, sizeof(desc)); + memset(desc, 0, sizeof (desc)); snprintf(desc, (dev->id_code & 0x1f) + 1, "%s", dev->id_string); if (!verbose) { @@ -1810,18 +1819,16 @@ ipmi_sdr_print_sensor_generic_locator(struct ipmi_intf * intf, dev->id_code ? desc : "", dev->entity.id, dev->entity.instance); else if (sdr_extended) - printf("%-16s | 00h | ns | %2d.%1d | Generic Device @%02Xh:%02Xh.%1d\n", - dev->id_code ? desc : "", - dev->entity.id, dev->entity.instance, - dev->dev_access_addr, - dev->dev_slave_addr, - dev->oem); + printf + ("%-16s | 00h | ns | %2d.%1d | Generic Device @%02Xh:%02Xh.%1d\n", + dev->id_code ? desc : "", dev->entity.id, + dev->entity.instance, dev->dev_access_addr, + dev->dev_slave_addr, dev->oem); else printf("%-16s | Generic @%02X:%02X.%-2d | ok\n", dev->id_code ? desc : "", dev->dev_access_addr, - dev->dev_slave_addr, - dev->oem); + dev->dev_slave_addr, dev->oem); return 0; } @@ -1837,7 +1844,7 @@ ipmi_sdr_print_sensor_generic_locator(struct ipmi_intf * intf, printf("Channel Number : %01Xh\n", dev->channel_num); printf("LUN.Bus : %01Xh.%01Xh\n", dev->lun, dev->bus); printf("Device Type.Modifier : %01Xh.%01Xh (%s)\n", - dev->dev_type, dev->dev_type_modifier, + dev->dev_type, dev->dev_type_modifier, val2str(dev->dev_type << 8 | dev->dev_type_modifier, entity_device_type_vals)); printf("OEM : %02Xh\n", dev->oem); @@ -1855,12 +1862,12 @@ ipmi_sdr_print_sensor_generic_locator(struct ipmi_intf * intf, * returns -1 on error */ int -ipmi_sdr_print_sensor_fru_locator(struct ipmi_intf * intf, - struct sdr_record_fru_locator * fru) +ipmi_sdr_print_sensor_fru_locator(struct ipmi_intf *intf, + struct sdr_record_fru_locator *fru) { char desc[17]; - memset(desc, 0, sizeof(desc)); + memset(desc, 0, sizeof (desc)); snprintf(desc, (fru->id_code & 0x1f) + 1, "%s", fru->id_string); if (!verbose) { @@ -1890,14 +1897,13 @@ ipmi_sdr_print_sensor_fru_locator(struct ipmi_intf * intf, val2str(fru->entity.id, entity_id_vals)); printf("Device Access Address : %02Xh\n", fru->dev_slave_addr); - printf("%s: %02Xh\n", - fru->logical ? "Logical FRU Device " : - "Slave Address ", - fru->device_id); + printf("%s: %02Xh\n", + fru->logical ? "Logical FRU Device " : + "Slave Address ", fru->device_id); printf("Channel Number : %01Xh\n", fru->channel_num); printf("LUN.Bus : %01Xh.%01Xh\n", fru->lun, fru->bus); printf("Device Type.Modifier : %01Xh.%01Xh (%s)\n", - fru->dev_type, fru->dev_type_modifier, + fru->dev_type, fru->dev_type_modifier, val2str(fru->dev_type << 8 | fru->dev_type_modifier, entity_device_type_vals)); printf("OEM : %02Xh\n", fru->oem); @@ -1915,8 +1921,8 @@ ipmi_sdr_print_sensor_fru_locator(struct ipmi_intf * intf, * returns -1 on error */ int -ipmi_sdr_print_sensor_entity_assoc(struct ipmi_intf * intf, - struct sdr_record_entity_assoc * assoc) +ipmi_sdr_print_sensor_entity_assoc(struct ipmi_intf *intf, + struct sdr_record_entity_assoc *assoc) { return 0; } @@ -1930,16 +1936,17 @@ ipmi_sdr_print_sensor_entity_assoc(struct ipmi_intf * intf, * returns -1 on error */ static int -ipmi_sdr_print_sensor_oem_intel(struct ipmi_intf * intf, - struct sdr_record_oem * oem) +ipmi_sdr_print_sensor_oem_intel(struct ipmi_intf *intf, + struct sdr_record_oem *oem) { - switch (oem->data[3]) /* record sub-type */ - { - case 0x02: /* Power Unit Map */ + switch (oem->data[3]) { /* record sub-type */ + case 0x02: /* Power Unit Map */ if (verbose) { - printf("Sensor ID : Power Unit Redundancy (0x%x)\n", - oem->data[4]); - printf("Sensor Type : Intel OEM - Power Unit Map\n"); + printf + ("Sensor ID : Power Unit Redundancy (0x%x)\n", + oem->data[4]); + printf + ("Sensor Type : Intel OEM - Power Unit Map\n"); printf("Redundant Supplies : %d", oem->data[6]); if (oem->data[5]) printf(" (flags %xh)", oem->data[5]); @@ -1953,40 +1960,48 @@ ipmi_sdr_print_sensor_oem_intel(struct ipmi_intf * intf, else if (csv_output) printf("Power Redundancy,Not Available,nr\n"); else - printf("Power Redundancy | Not Available | nr\n"); + printf + ("Power Redundancy | Not Available | nr\n"); break; - case 8: /* SR2300, redundant, PS1 & PS2 present */ + case 8: /* SR2300, redundant, PS1 & PS2 present */ if (verbose) { printf("Power Redundancy : No\n"); - printf("Power Supply 2 Sensor : %x\n", oem->data[8]); - } else if (csv_output) { - printf("Power Redundancy,PS@%02xh,nr\n", oem->data[8]); - } else { - printf("Power Redundancy | PS@%02xh | nr\n", + printf("Power Supply 2 Sensor : %x\n", oem->data[8]); + } else if (csv_output) { + printf("Power Redundancy,PS@%02xh,nr\n", + oem->data[8]); + } else { + printf + ("Power Redundancy | PS@%02xh | nr\n", + oem->data[8]); } - case 9: /* SR2300, non-redundant, PSx present */ + case 9: /* SR2300, non-redundant, PSx present */ if (verbose) { printf("Power Redundancy : Yes\n"); - printf("Power Supply Sensor : %x\n", oem->data[7]); - printf("Power Supply Sensor : %x\n", oem->data[8]); + printf("Power Supply Sensor : %x\n", + oem->data[7]); + printf("Power Supply Sensor : %x\n", + oem->data[8]); } else if (csv_output) { - printf("Power Redundancy,PS@%02xh + PS@%02xh,ok\n", - oem->data[7], oem->data[8]); + printf + ("Power Redundancy,PS@%02xh + PS@%02xh,ok\n", + oem->data[7], oem->data[8]); } else { - printf("Power Redundancy | PS@%02xh + PS@%02xh | ok\n", - oem->data[7], oem->data[8]); + printf + ("Power Redundancy | PS@%02xh + PS@%02xh | ok\n", + oem->data[7], oem->data[8]); } break; } if (verbose) printf("\n"); break; - case 0x03: /* Fan Speed Control */ + case 0x03: /* Fan Speed Control */ break; - case 0x06: /* System Information */ + case 0x06: /* System Information */ break; - case 0x07: /* Ambient Temperature Fan Speed Control */ + case 0x07: /* Ambient Temperature Fan Speed Control */ break; default: lprintf(LOG_DEBUG, "Unknown Intel OEM SDR Record type %02x", @@ -2009,8 +2024,7 @@ ipmi_sdr_print_sensor_oem_intel(struct ipmi_intf * intf, * returns -1 on error */ static int -ipmi_sdr_print_sensor_oem(struct ipmi_intf * intf, - struct sdr_record_oem * oem) +ipmi_sdr_print_sensor_oem(struct ipmi_intf *intf, struct sdr_record_oem *oem) { int rc = 0; @@ -2024,8 +2038,7 @@ ipmi_sdr_print_sensor_oem(struct ipmi_intf * intf, /* intel manufacturer id */ if (oem->data[0] == 0x57 && - oem->data[1] == 0x01 && - oem->data[2] == 0x00) { + oem->data[1] == 0x01 && oem->data[2] == 0x00) { rc = ipmi_sdr_print_sensor_oem_intel(intf, oem); } @@ -2043,7 +2056,7 @@ ipmi_sdr_print_sensor_oem(struct ipmi_intf * intf, * returns -1 on error */ int -ipmi_sdr_print_rawentry(struct ipmi_intf * intf, uint8_t type, +ipmi_sdr_print_rawentry(struct ipmi_intf *intf, uint8_t type, uint8_t * raw, int len) { int rc = 0; @@ -2051,39 +2064,54 @@ ipmi_sdr_print_rawentry(struct ipmi_intf * intf, uint8_t type, switch (type) { case SDR_RECORD_TYPE_FULL_SENSOR: rc = ipmi_sdr_print_sensor_full(intf, - (struct sdr_record_full_sensor *) raw); + (struct sdr_record_full_sensor + *) raw); break; case SDR_RECORD_TYPE_COMPACT_SENSOR: rc = ipmi_sdr_print_sensor_compact(intf, - (struct sdr_record_compact_sensor *) raw); + (struct + sdr_record_compact_sensor *) + raw); break; case SDR_RECORD_TYPE_EVENTONLY_SENSOR: rc = ipmi_sdr_print_sensor_eventonly(intf, - (struct sdr_record_eventonly_sensor *) raw); + (struct + sdr_record_eventonly_sensor + *) raw); break; case SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR: rc = ipmi_sdr_print_sensor_generic_locator(intf, - (struct sdr_record_generic_locator *) raw); + (struct + sdr_record_generic_locator + *) raw); break; case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: rc = ipmi_sdr_print_sensor_fru_locator(intf, - (struct sdr_record_fru_locator *) raw); + (struct + sdr_record_fru_locator + *) raw); break; case SDR_RECORD_TYPE_MC_DEVICE_LOCATOR: rc = ipmi_sdr_print_sensor_mc_locator(intf, - (struct sdr_record_mc_locator *) raw); + (struct + sdr_record_mc_locator *) + raw); break; case SDR_RECORD_TYPE_ENTITY_ASSOC: rc = ipmi_sdr_print_sensor_entity_assoc(intf, - (struct sdr_record_entity_assoc *) raw); + (struct + sdr_record_entity_assoc + *) raw); break; - case SDR_RECORD_TYPE_OEM: { - struct sdr_record_oem oem; - oem.data = raw; - oem.data_len = len; - rc = ipmi_sdr_print_sensor_oem(intf, (struct sdr_record_oem *)&oem); - break; - } + case SDR_RECORD_TYPE_OEM:{ + struct sdr_record_oem oem; + oem.data = raw; + oem.data_len = len; + rc = ipmi_sdr_print_sensor_oem(intf, + (struct sdr_record_oem *) + &oem); + break; + } case SDR_RECORD_TYPE_DEVICE_ENTITY_ASSOC: case SDR_RECORD_TYPE_MC_CONFIRMATION: case SDR_RECORD_TYPE_BMC_MSG_CHANNEL_INFO: @@ -2103,8 +2131,7 @@ ipmi_sdr_print_rawentry(struct ipmi_intf * intf, uint8_t type, * returns -1 on error */ int -ipmi_sdr_print_listentry(struct ipmi_intf * intf, - struct sdr_record_list * entry) +ipmi_sdr_print_listentry(struct ipmi_intf *intf, struct sdr_record_list *entry) { int rc = 0; @@ -2116,19 +2143,25 @@ ipmi_sdr_print_listentry(struct ipmi_intf * intf, rc = ipmi_sdr_print_sensor_compact(intf, entry->record.compact); break; case SDR_RECORD_TYPE_EVENTONLY_SENSOR: - rc = ipmi_sdr_print_sensor_eventonly(intf, entry->record.eventonly); + rc = ipmi_sdr_print_sensor_eventonly(intf, + entry->record.eventonly); break; case SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR: - rc = ipmi_sdr_print_sensor_generic_locator(intf, entry->record.genloc); + rc = ipmi_sdr_print_sensor_generic_locator(intf, + entry->record. + genloc); break; case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: - rc = ipmi_sdr_print_sensor_fru_locator(intf, entry->record.fruloc); + rc = ipmi_sdr_print_sensor_fru_locator(intf, + entry->record.fruloc); break; case SDR_RECORD_TYPE_MC_DEVICE_LOCATOR: - rc = ipmi_sdr_print_sensor_mc_locator(intf, entry->record.mcloc); + rc = ipmi_sdr_print_sensor_mc_locator(intf, + entry->record.mcloc); break; case SDR_RECORD_TYPE_ENTITY_ASSOC: - rc = ipmi_sdr_print_sensor_entity_assoc(intf, entry->record.entassoc); + rc = ipmi_sdr_print_sensor_entity_assoc(intf, + entry->record.entassoc); break; case SDR_RECORD_TYPE_OEM: rc = ipmi_sdr_print_sensor_oem(intf, entry->record.oem); @@ -2152,10 +2185,10 @@ ipmi_sdr_print_listentry(struct ipmi_intf * intf, * returns -1 on error */ int -ipmi_sdr_print_sdr(struct ipmi_intf * intf, uint8_t type) +ipmi_sdr_print_sdr(struct ipmi_intf *intf, uint8_t type) { - struct sdr_get_rs * header; - struct sdr_record_list * e; + struct sdr_get_rs *header; + struct sdr_record_list *e; int rc = 0; lprintf(LOG_DEBUG, "Querying SDR for sensor list"); @@ -2178,10 +2211,10 @@ ipmi_sdr_print_sdr(struct ipmi_intf * intf, uint8_t type) if (ipmi_sdr_print_listentry(intf, e) < 0) rc = -1; } - + while ((header = ipmi_sdr_get_next_header(intf, sdr_list_itr)) != NULL) { - uint8_t * rec; - struct sdr_record_list * sdrr; + uint8_t *rec; + struct sdr_record_list *sdrr; rec = ipmi_sdr_get_record(intf, header, sdr_list_itr); if (rec == NULL) { @@ -2189,36 +2222,43 @@ ipmi_sdr_print_sdr(struct ipmi_intf * intf, uint8_t type) continue; } - sdrr = malloc(sizeof(struct sdr_record_list)); + sdrr = malloc(sizeof (struct sdr_record_list)); if (sdrr == NULL) { lprintf(LOG_ERR, "ipmitool: malloc failure"); break; } - memset(sdrr, 0, sizeof(struct sdr_record_list)); + memset(sdrr, 0, sizeof (struct sdr_record_list)); sdrr->id = header->id; sdrr->type = header->type; - + switch (header->type) { case SDR_RECORD_TYPE_FULL_SENSOR: - sdrr->record.full = (struct sdr_record_full_sensor *)rec; + sdrr->record.full = + (struct sdr_record_full_sensor *) rec; break; case SDR_RECORD_TYPE_COMPACT_SENSOR: - sdrr->record.compact = (struct sdr_record_compact_sensor *)rec; + sdrr->record.compact = + (struct sdr_record_compact_sensor *) rec; break; case SDR_RECORD_TYPE_EVENTONLY_SENSOR: - sdrr->record.eventonly = (struct sdr_record_eventonly_sensor *)rec; + sdrr->record.eventonly = + (struct sdr_record_eventonly_sensor *) rec; break; case SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR: - sdrr->record.genloc = (struct sdr_record_generic_locator *)rec; + sdrr->record.genloc = + (struct sdr_record_generic_locator *) rec; break; case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: - sdrr->record.fruloc = (struct sdr_record_fru_locator *)rec; + sdrr->record.fruloc = + (struct sdr_record_fru_locator *) rec; break; case SDR_RECORD_TYPE_MC_DEVICE_LOCATOR: - sdrr->record.mcloc = (struct sdr_record_mc_locator *)rec; + sdrr->record.mcloc = + (struct sdr_record_mc_locator *) rec; break; case SDR_RECORD_TYPE_ENTITY_ASSOC: - sdrr->record.entassoc = (struct sdr_record_entity_assoc *)rec; + sdrr->record.entassoc = + (struct sdr_record_entity_assoc *) rec; break; default: free(rec); @@ -2255,15 +2295,20 @@ ipmi_sdr_print_sdr(struct ipmi_intf * intf, uint8_t type) * returns -1 on error */ int -ipmi_sdr_get_reservation(struct ipmi_intf * intf, - uint16_t *reserve_id) +ipmi_sdr_get_reservation(struct ipmi_intf *intf, uint16_t * reserve_id) { struct ipmi_rs *rsp; struct ipmi_rq req; /* obtain reservation ID */ - memset(&req, 0, sizeof(req)); - req.msg.netfn = IPMI_NETFN_STORAGE; + memset(&req, 0, sizeof (req)); + + if (use_built_in == 0) { + req.msg.netfn = IPMI_NETFN_STORAGE; + } else { + req.msg.netfn = IPMI_NETFN_SE; + } + req.msg.cmd = GET_SDR_RESERVE_REPO; rsp = intf->sendrecv(intf, &req); @@ -2273,7 +2318,7 @@ ipmi_sdr_get_reservation(struct ipmi_intf * intf, if (rsp->ccode > 0) return -1; - *reserve_id = ((struct sdr_reserve_repo_rs *)&(rsp->data))->reserve_id; + *reserve_id = ((struct sdr_reserve_repo_rs *) &(rsp->data))->reserve_id; lprintf(LOG_DEBUG, "SDR reserveration ID %04x", *reserve_id); return 0; @@ -2287,56 +2332,106 @@ ipmi_sdr_get_reservation(struct ipmi_intf * intf, * returns NULL on error */ struct ipmi_sdr_iterator * -ipmi_sdr_start(struct ipmi_intf * intf) +ipmi_sdr_start(struct ipmi_intf *intf) { - struct ipmi_sdr_iterator * itr; - struct ipmi_rs * rsp; + struct ipmi_sdr_iterator *itr; + struct ipmi_rs *rsp; struct ipmi_rq req; - struct sdr_repo_info_rs sdr_info; - itr = malloc(sizeof(struct ipmi_sdr_iterator)); + struct ipm_devid_rsp *devid; + + itr = malloc(sizeof (struct ipmi_sdr_iterator)); if (itr == NULL) { lprintf(LOG_ERR, "ipmitool: malloc failure"); return NULL; } - /* get sdr repository info */ - memset(&req, 0, sizeof(req)); - req.msg.netfn = IPMI_NETFN_STORAGE; - req.msg.cmd = GET_SDR_REPO_INFO; + /* check SDRR capability */ + memset(&req, 0, sizeof (req)); + req.msg.netfn = IPMI_NETFN_APP; + req.msg.cmd = BMC_GET_DEVICE_ID; + req.msg.data_len = 0; rsp = intf->sendrecv(intf, &req); + if (rsp == NULL) { - lprintf(LOG_ERR, "Error obtaining SDR info"); + lprintf(LOG_ERR, "Get Device ID command failed"); free(itr); return NULL; } - if (rsp->ccode > 0) { - lprintf(LOG_ERR, "Error obtaining SDR info: %s", - val2str(rsp->ccode, completion_code_vals)); - free(itr); - return NULL; + devid = (struct ipm_devid_rsp *) rsp->data; + + if (devid->device_revision & IPM_DEV_DEVICE_ID_SDR_MASK) { + if ((devid->adtl_device_support & 0x02) == 0) { + if ((devid->adtl_device_support & 0x01)) { + lprintf(LOG_DEBUG, "Using Device SDRs\n"); + use_built_in = 1; + } else { + lprintf(LOG_ERR, "Error obtaining SDR info"); + free(itr); + return NULL; + } + } else { + lprintf(LOG_DEBUG, "Using SDR from Repository \n"); + } } + /***********************/ + if (use_built_in == 0) { + struct sdr_repo_info_rs sdr_info; + /* get sdr repository info */ + memset(&req, 0, sizeof (req)); + req.msg.netfn = IPMI_NETFN_STORAGE; + req.msg.cmd = GET_SDR_REPO_INFO; - memcpy(&sdr_info, rsp->data, sizeof(sdr_info)); + rsp = intf->sendrecv(intf, &req); + if (rsp == NULL) { + lprintf(LOG_ERR, "Error obtaining SDR info"); + free(itr); + return NULL; + } + if (rsp->ccode > 0) { + lprintf(LOG_ERR, "Error obtaining SDR info: %s", + val2str(rsp->ccode, completion_code_vals)); + free(itr); + return NULL; + } - /* IPMIv1.0 == 0x01 - * IPMIv1.5 == 0x51 - * IPMIv2.0 == 0x02 - */ - if ((sdr_info.version != 0x51) && - (sdr_info.version != 0x01) && - (sdr_info.version != 0x02)) { - lprintf(LOG_WARN, "WARNING: Unknown SDR repository " - "version 0x%02x", sdr_info.version); + memcpy(&sdr_info, rsp->data, sizeof (sdr_info)); + /* IPMIv1.0 == 0x01 + * IPMIv1.5 == 0x51 + * IPMIv2.0 == 0x02 + */ + if ((sdr_info.version != 0x51) && + (sdr_info.version != 0x01) && (sdr_info.version != 0x02)) { + lprintf(LOG_WARN, "WARNING: Unknown SDR repository " + "version 0x%02x", sdr_info.version); + } + + itr->total = sdr_info.count; + itr->next = 0; + + lprintf(LOG_DEBUG, "SDR free space: %d", sdr_info.free); + lprintf(LOG_DEBUG, "SDR records : %d", sdr_info.count); + } else { + struct sdr_device_info_rs sdr_info; + /* get device sdr info */ + memset(&req, 0, sizeof (req)); + req.msg.netfn = IPMI_NETFN_SE; + req.msg.cmd = GET_DEVICE_SDR_INFO; + + rsp = intf->sendrecv(intf, &req); + if (!rsp || !rsp->data_len || rsp->ccode) { + printf("Err in cmd get sensor sdr info\n"); + free(itr); + return NULL; + } + memcpy(&sdr_info, rsp->data, sizeof (sdr_info)); + + itr->total = sdr_info.count; + itr->next = 0; + lprintf(LOG_DEBUG, "SDR records : %d", sdr_info.count); } - itr->total = sdr_info.count; - itr->next = 0; - - lprintf(LOG_DEBUG, "SDR free space: %d", sdr_info.free); - lprintf(LOG_DEBUG, "SDR records : %d", sdr_info.count); - if (ipmi_sdr_get_reservation(intf, &(itr->reservation)) < 0) { lprintf(LOG_ERR, "Unable to obtain SDR reservation"); free(itr); @@ -2360,40 +2455,45 @@ ipmi_sdr_get_record(struct ipmi_intf * intf, struct sdr_get_rs * header, struct ipmi_sdr_iterator * itr) { struct ipmi_rq req; - struct ipmi_rs * rsp; + struct ipmi_rs *rsp; struct sdr_get_rq sdr_rq; - uint8_t * data; + uint8_t *data; int i = 0, len = header->length; if (len < 1) return NULL; - data = malloc(len+1); + data = malloc(len + 1); if (data == NULL) { lprintf(LOG_ERR, "ipmitool: malloc failure"); return NULL; } - memset(data, 0, len+1); + memset(data, 0, len + 1); - memset(&sdr_rq, 0, sizeof(sdr_rq)); + memset(&sdr_rq, 0, sizeof (sdr_rq)); sdr_rq.reserve_id = itr->reservation; sdr_rq.id = header->id; sdr_rq.offset = 0; - memset(&req, 0, sizeof(req)); - req.msg.netfn = IPMI_NETFN_STORAGE; - req.msg.cmd = GET_SDR; - req.msg.data = (uint8_t *)&sdr_rq; - req.msg.data_len = sizeof(sdr_rq); + memset(&req, 0, sizeof (req)); + if (use_built_in == 0) { + req.msg.netfn = IPMI_NETFN_STORAGE; + req.msg.cmd = GET_SDR; + } else { + req.msg.netfn = IPMI_NETFN_SE; + req.msg.cmd = GET_DEVICE_SDR; + } + req.msg.data = (uint8_t *) & sdr_rq; + req.msg.data_len = sizeof (sdr_rq); /* read SDR record with partial reads * because a full read usually exceeds the maximum * transport buffer size. (completion code 0xca) */ while (i < len) { - sdr_rq.length = (len-i < sdr_max_read_len) ? - len-i : sdr_max_read_len; - sdr_rq.offset = i+5; /* 5 header bytes */ + sdr_rq.length = (len - i < sdr_max_read_len) ? + len - i : sdr_max_read_len; + sdr_rq.offset = i + 5; /* 5 header bytes */ lprintf(LOG_DEBUG, "Getting %d bytes from SDR at offset %d", sdr_rq.length, sdr_rq.offset); @@ -2416,7 +2516,8 @@ ipmi_sdr_get_record(struct ipmi_intf * intf, struct sdr_get_rs * header, sleep(rand() & 3); - if (ipmi_sdr_get_reservation(intf, &(itr->reservation)) < 0) { + if (ipmi_sdr_get_reservation(intf, &(itr->reservation)) + < 0) { free(data); return NULL; } @@ -2430,7 +2531,7 @@ ipmi_sdr_get_record(struct ipmi_intf * intf, struct sdr_get_rs * header, return NULL; } - memcpy(data+i, rsp->data+2, sdr_rq.length); + memcpy(data + i, rsp->data + 2, sdr_rq.length); i += sdr_max_read_len; } @@ -2445,7 +2546,7 @@ ipmi_sdr_get_record(struct ipmi_intf * intf, struct sdr_get_rs * header, * no meaningful return code */ void -ipmi_sdr_end(struct ipmi_intf * intf, struct ipmi_sdr_iterator * itr) +ipmi_sdr_end(struct ipmi_intf *intf, struct ipmi_sdr_iterator *itr) { if (itr) free(itr); @@ -2460,21 +2561,20 @@ ipmi_sdr_end(struct ipmi_intf * intf, struct ipmi_sdr_iterator * itr) * returns -1 on error */ static int -__sdr_list_add(struct sdr_record_list * head, - struct sdr_record_list * entry) +__sdr_list_add(struct sdr_record_list *head, struct sdr_record_list *entry) { - struct sdr_record_list * e; - struct sdr_record_list * new; + struct sdr_record_list *e; + struct sdr_record_list *new; if (head == NULL) return -1; - new = malloc(sizeof(struct sdr_record_list)); + new = malloc(sizeof (struct sdr_record_list)); if (new == NULL) { lprintf(LOG_ERR, "ipmitool: malloc failure"); return -1; } - memcpy(new, entry, sizeof(struct sdr_record_list)); + memcpy(new, entry, sizeof (struct sdr_record_list)); e = head; while (e->next) @@ -2492,9 +2592,9 @@ __sdr_list_add(struct sdr_record_list * head, * no meaningful return code */ static void -__sdr_list_empty(struct sdr_record_list * head) +__sdr_list_empty(struct sdr_record_list *head) { - struct sdr_record_list * e, * f; + struct sdr_record_list *e, *f; for (e = head; e != NULL; e = f) { f = e->next; free(e); @@ -2509,7 +2609,7 @@ __sdr_list_empty(struct sdr_record_list * head) * no meaningful return code */ void -ipmi_sdr_list_empty(struct ipmi_intf * intf) +ipmi_sdr_list_empty(struct ipmi_intf *intf) { struct sdr_record_list *list, *next; @@ -2565,11 +2665,10 @@ ipmi_sdr_list_empty(struct ipmi_intf * intf) * returns NULL on error */ struct sdr_record_list * -ipmi_sdr_find_sdr_bynumtype(struct ipmi_intf * intf, uint8_t num, - uint8_t type) +ipmi_sdr_find_sdr_bynumtype(struct ipmi_intf *intf, uint8_t num, uint8_t type) { - struct sdr_get_rs * header; - struct sdr_record_list * e; + struct sdr_get_rs *header; + struct sdr_record_list *e; int found = 0; if (sdr_list_itr == NULL) { @@ -2603,15 +2702,15 @@ ipmi_sdr_find_sdr_bynumtype(struct ipmi_intf * intf, uint8_t num, /* now keep looking */ while ((header = ipmi_sdr_get_next_header(intf, sdr_list_itr)) != NULL) { - uint8_t * rec; - struct sdr_record_list * sdrr; + uint8_t *rec; + struct sdr_record_list *sdrr; - sdrr = malloc(sizeof(struct sdr_record_list)); + sdrr = malloc(sizeof (struct sdr_record_list)); if (sdrr == NULL) { lprintf(LOG_ERR, "ipmitool: malloc failure"); break; } - memset(sdrr, 0, sizeof(struct sdr_record_list)); + memset(sdrr, 0, sizeof (struct sdr_record_list)); sdrr->id = header->id; sdrr->type = header->type; @@ -2621,34 +2720,41 @@ ipmi_sdr_find_sdr_bynumtype(struct ipmi_intf * intf, uint8_t num, switch (header->type) { case SDR_RECORD_TYPE_FULL_SENSOR: - sdrr->record.full = (struct sdr_record_full_sensor *)rec; - if (sdrr->record.full->keys.sensor_num == num && - sdrr->record.full->sensor.type == type) + sdrr->record.full = + (struct sdr_record_full_sensor *) rec; + if (sdrr->record.full->keys.sensor_num == num + && sdrr->record.full->sensor.type == type) found = 1; break; case SDR_RECORD_TYPE_COMPACT_SENSOR: - sdrr->record.compact = (struct sdr_record_compact_sensor *)rec; - if (sdrr->record.compact->keys.sensor_num == num && - sdrr->record.compact->sensor.type == type) + sdrr->record.compact = + (struct sdr_record_compact_sensor *) rec; + if (sdrr->record.compact->keys.sensor_num == num + && sdrr->record.compact->sensor.type == type) found = 1; break; case SDR_RECORD_TYPE_EVENTONLY_SENSOR: - sdrr->record.eventonly = (struct sdr_record_eventonly_sensor *)rec; - if (sdrr->record.eventonly->keys.sensor_num == num && - sdrr->record.eventonly->sensor_type == type) + sdrr->record.eventonly = + (struct sdr_record_eventonly_sensor *) rec; + if (sdrr->record.eventonly->keys.sensor_num == num + && sdrr->record.eventonly->sensor_type == type) found = 1; break; case SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR: - sdrr->record.genloc = (struct sdr_record_generic_locator *)rec; + sdrr->record.genloc = + (struct sdr_record_generic_locator *) rec; break; case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: - sdrr->record.fruloc = (struct sdr_record_fru_locator *)rec; + sdrr->record.fruloc = + (struct sdr_record_fru_locator *) rec; break; case SDR_RECORD_TYPE_MC_DEVICE_LOCATOR: - sdrr->record.mcloc = (struct sdr_record_mc_locator *)rec; + sdrr->record.mcloc = + (struct sdr_record_mc_locator *) rec; break; case SDR_RECORD_TYPE_ENTITY_ASSOC: - sdrr->record.entassoc = (struct sdr_record_entity_assoc *)rec; + sdrr->record.entassoc = + (struct sdr_record_entity_assoc *) rec; break; default: free(rec); @@ -2679,18 +2785,18 @@ ipmi_sdr_find_sdr_bynumtype(struct ipmi_intf * intf, uint8_t num, * returns NULL on error */ struct sdr_record_list * -ipmi_sdr_find_sdr_bysensortype(struct ipmi_intf * intf, uint8_t type) +ipmi_sdr_find_sdr_bysensortype(struct ipmi_intf *intf, uint8_t type) { - struct sdr_record_list * head; - struct sdr_get_rs * header; - struct sdr_record_list * e; + struct sdr_record_list *head; + struct sdr_get_rs *header; + struct sdr_record_list *e; - head = malloc(sizeof(struct sdr_record_list)); + head = malloc(sizeof (struct sdr_record_list)); if (head == NULL) { lprintf(LOG_ERR, "ipmitool: malloc failure"); return NULL; } - memset(head, 0, sizeof(struct sdr_record_list)); + memset(head, 0, sizeof (struct sdr_record_list)); if (sdr_list_itr == NULL) { sdr_list_itr = ipmi_sdr_start(intf); @@ -2720,15 +2826,15 @@ ipmi_sdr_find_sdr_bysensortype(struct ipmi_intf * intf, uint8_t type) /* now keep looking */ while ((header = ipmi_sdr_get_next_header(intf, sdr_list_itr)) != NULL) { - uint8_t * rec; - struct sdr_record_list * sdrr; + uint8_t *rec; + struct sdr_record_list *sdrr; - sdrr = malloc(sizeof(struct sdr_record_list)); + sdrr = malloc(sizeof (struct sdr_record_list)); if (sdrr == NULL) { lprintf(LOG_ERR, "ipmitool: malloc failure"); break; } - memset(sdrr, 0, sizeof(struct sdr_record_list)); + memset(sdrr, 0, sizeof (struct sdr_record_list)); sdrr->id = header->id; sdrr->type = header->type; @@ -2738,31 +2844,38 @@ ipmi_sdr_find_sdr_bysensortype(struct ipmi_intf * intf, uint8_t type) switch (header->type) { case SDR_RECORD_TYPE_FULL_SENSOR: - sdrr->record.full = (struct sdr_record_full_sensor *)rec; + sdrr->record.full = + (struct sdr_record_full_sensor *) rec; if (sdrr->record.full->sensor.type == type) __sdr_list_add(head, sdrr); break; case SDR_RECORD_TYPE_COMPACT_SENSOR: - sdrr->record.compact = (struct sdr_record_compact_sensor *)rec; + sdrr->record.compact = + (struct sdr_record_compact_sensor *) rec; if (sdrr->record.compact->sensor.type == type) __sdr_list_add(head, sdrr); break; case SDR_RECORD_TYPE_EVENTONLY_SENSOR: - sdrr->record.eventonly = (struct sdr_record_eventonly_sensor *)rec; + sdrr->record.eventonly = + (struct sdr_record_eventonly_sensor *) rec; if (sdrr->record.eventonly->sensor_type == type) __sdr_list_add(head, sdrr); break; case SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR: - sdrr->record.genloc = (struct sdr_record_generic_locator *)rec; + sdrr->record.genloc = + (struct sdr_record_generic_locator *) rec; break; case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: - sdrr->record.fruloc = (struct sdr_record_fru_locator *)rec; + sdrr->record.fruloc = + (struct sdr_record_fru_locator *) rec; break; case SDR_RECORD_TYPE_MC_DEVICE_LOCATOR: - sdrr->record.mcloc = (struct sdr_record_mc_locator *)rec; + sdrr->record.mcloc = + (struct sdr_record_mc_locator *) rec; break; case SDR_RECORD_TYPE_ENTITY_ASSOC: - sdrr->record.entassoc = (struct sdr_record_entity_assoc *)rec; + sdrr->record.entassoc = + (struct sdr_record_entity_assoc *) rec; break; default: free(rec); @@ -2790,18 +2903,18 @@ ipmi_sdr_find_sdr_bysensortype(struct ipmi_intf * intf, uint8_t type) * returns NULL on error */ struct sdr_record_list * -ipmi_sdr_find_sdr_byentity(struct ipmi_intf * intf, struct entity_id * entity) +ipmi_sdr_find_sdr_byentity(struct ipmi_intf *intf, struct entity_id *entity) { - struct sdr_get_rs * header; - struct sdr_record_list * e; - struct sdr_record_list * head; + struct sdr_get_rs *header; + struct sdr_record_list *e; + struct sdr_record_list *head; - head = malloc(sizeof(struct sdr_record_list)); + head = malloc(sizeof (struct sdr_record_list)); if (head == NULL) { lprintf(LOG_ERR, "ipmitool: malloc failure"); return NULL; } - memset(head, 0, sizeof(struct sdr_record_list)); + memset(head, 0, sizeof (struct sdr_record_list)); if (sdr_list_itr == NULL) { sdr_list_itr = ipmi_sdr_start(intf); @@ -2817,43 +2930,50 @@ ipmi_sdr_find_sdr_byentity(struct ipmi_intf * intf, struct entity_id * entity) case SDR_RECORD_TYPE_FULL_SENSOR: if (e->record.full->entity.id == entity->id && (entity->instance == 0x7f || - e->record.full->entity.instance == entity->instance)) + e->record.full->entity.instance == + entity->instance)) __sdr_list_add(head, e); break; case SDR_RECORD_TYPE_COMPACT_SENSOR: if (e->record.compact->entity.id == entity->id && (entity->instance == 0x7f || - e->record.compact->entity.instance == entity->instance)) + e->record.compact->entity.instance == + entity->instance)) __sdr_list_add(head, e); break; case SDR_RECORD_TYPE_EVENTONLY_SENSOR: if (e->record.eventonly->entity.id == entity->id && (entity->instance == 0x7f || - e->record.eventonly->entity.instance == entity->instance)) + e->record.eventonly->entity.instance == + entity->instance)) __sdr_list_add(head, e); break; case SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR: if (e->record.genloc->entity.id == entity->id && (entity->instance == 0x7f || - e->record.genloc->entity.instance == entity->instance)) + e->record.genloc->entity.instance == + entity->instance)) __sdr_list_add(head, e); break; case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: if (e->record.fruloc->entity.id == entity->id && (entity->instance == 0x7f || - e->record.fruloc->entity.instance == entity->instance)) + e->record.fruloc->entity.instance == + entity->instance)) __sdr_list_add(head, e); break; case SDR_RECORD_TYPE_MC_DEVICE_LOCATOR: if (e->record.mcloc->entity.id == entity->id && (entity->instance == 0x7f || - e->record.mcloc->entity.instance == entity->instance)) + e->record.mcloc->entity.instance == + entity->instance)) __sdr_list_add(head, e); break; case SDR_RECORD_TYPE_ENTITY_ASSOC: if (e->record.entassoc->entity.id == entity->id && (entity->instance == 0x7f || - e->record.entassoc->entity.instance == entity->instance)) + e->record.entassoc->entity.instance == + entity->instance)) __sdr_list_add(head, e); break; } @@ -2861,15 +2981,15 @@ ipmi_sdr_find_sdr_byentity(struct ipmi_intf * intf, struct entity_id * entity) /* now keep looking */ while ((header = ipmi_sdr_get_next_header(intf, sdr_list_itr)) != NULL) { - uint8_t * rec; - struct sdr_record_list * sdrr; + uint8_t *rec; + struct sdr_record_list *sdrr; - sdrr = malloc(sizeof(struct sdr_record_list)); + sdrr = malloc(sizeof (struct sdr_record_list)); if (sdrr == NULL) { lprintf(LOG_ERR, "ipmitool: malloc failure"); break; } - memset(sdrr, 0, sizeof(struct sdr_record_list)); + memset(sdrr, 0, sizeof (struct sdr_record_list)); sdrr->id = header->id; sdrr->type = header->type; @@ -2879,52 +2999,66 @@ ipmi_sdr_find_sdr_byentity(struct ipmi_intf * intf, struct entity_id * entity) switch (header->type) { case SDR_RECORD_TYPE_FULL_SENSOR: - sdrr->record.full = (struct sdr_record_full_sensor *)rec; - if (sdrr->record.full->entity.id == entity->id && - (entity->instance == 0x7f || - sdrr->record.full->entity.instance == entity->instance)) + sdrr->record.full = + (struct sdr_record_full_sensor *) rec; + if (sdrr->record.full->entity.id == entity->id + && (entity->instance == 0x7f + || sdrr->record.full->entity.instance == + entity->instance)) __sdr_list_add(head, sdrr); break; case SDR_RECORD_TYPE_COMPACT_SENSOR: - sdrr->record.compact = (struct sdr_record_compact_sensor *)rec; - if (sdrr->record.compact->entity.id == entity->id && - (entity->instance == 0x7f || - sdrr->record.compact->entity.instance == entity->instance)) + sdrr->record.compact = + (struct sdr_record_compact_sensor *) rec; + if (sdrr->record.compact->entity.id == entity->id + && (entity->instance == 0x7f + || sdrr->record.compact->entity.instance == + entity->instance)) __sdr_list_add(head, sdrr); break; case SDR_RECORD_TYPE_EVENTONLY_SENSOR: - sdrr->record.eventonly = (struct sdr_record_eventonly_sensor *)rec; - if (sdrr->record.eventonly->entity.id == entity->id && - (entity->instance == 0x7f || - sdrr->record.eventonly->entity.instance == entity->instance)) + sdrr->record.eventonly = + (struct sdr_record_eventonly_sensor *) rec; + if (sdrr->record.eventonly->entity.id == entity->id + && (entity->instance == 0x7f + || sdrr->record.eventonly->entity.instance == + entity->instance)) __sdr_list_add(head, sdrr); break; case SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR: - sdrr->record.genloc = (struct sdr_record_generic_locator *)rec; - if (sdrr->record.genloc->entity.id == entity->id && - (entity->instance == 0x7f || - sdrr->record.genloc->entity.instance == entity->instance)) + sdrr->record.genloc = + (struct sdr_record_generic_locator *) rec; + if (sdrr->record.genloc->entity.id == entity->id + && (entity->instance == 0x7f + || sdrr->record.genloc->entity.instance == + entity->instance)) __sdr_list_add(head, sdrr); break; case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: - sdrr->record.fruloc = (struct sdr_record_fru_locator *)rec; - if (sdrr->record.fruloc->entity.id == entity->id && - (entity->instance == 0x7f || - sdrr->record.fruloc->entity.instance == entity->instance)) + sdrr->record.fruloc = + (struct sdr_record_fru_locator *) rec; + if (sdrr->record.fruloc->entity.id == entity->id + && (entity->instance == 0x7f + || sdrr->record.fruloc->entity.instance == + entity->instance)) __sdr_list_add(head, sdrr); break; case SDR_RECORD_TYPE_MC_DEVICE_LOCATOR: - sdrr->record.mcloc = (struct sdr_record_mc_locator *)rec; - if (sdrr->record.mcloc->entity.id == entity->id && - (entity->instance == 0x7f || - sdrr->record.mcloc->entity.instance == entity->instance)) + sdrr->record.mcloc = + (struct sdr_record_mc_locator *) rec; + if (sdrr->record.mcloc->entity.id == entity->id + && (entity->instance == 0x7f + || sdrr->record.mcloc->entity.instance == + entity->instance)) __sdr_list_add(head, sdrr); break; case SDR_RECORD_TYPE_ENTITY_ASSOC: - sdrr->record.entassoc = (struct sdr_record_entity_assoc *)rec; - if (sdrr->record.entassoc->entity.id == entity->id && - (entity->instance == 0x7f || - sdrr->record.entassoc->entity.instance == entity->instance)) + sdrr->record.entassoc = + (struct sdr_record_entity_assoc *) rec; + if (sdrr->record.entassoc->entity.id == entity->id + && (entity->instance == 0x7f + || sdrr->record.entassoc->entity.instance == + entity->instance)) __sdr_list_add(head, sdrr); break; default: @@ -2953,18 +3087,18 @@ ipmi_sdr_find_sdr_byentity(struct ipmi_intf * intf, struct entity_id * entity) * returns NULL on error */ struct sdr_record_list * -ipmi_sdr_find_sdr_bytype(struct ipmi_intf * intf, uint8_t type) +ipmi_sdr_find_sdr_bytype(struct ipmi_intf *intf, uint8_t type) { - struct sdr_get_rs * header; - struct sdr_record_list * e; - struct sdr_record_list * head; + struct sdr_get_rs *header; + struct sdr_record_list *e; + struct sdr_record_list *head; - head = malloc(sizeof(struct sdr_record_list)); + head = malloc(sizeof (struct sdr_record_list)); if (head == NULL) { lprintf(LOG_ERR, "ipmitool: malloc failure"); return NULL; } - memset(head, 0, sizeof(struct sdr_record_list)); + memset(head, 0, sizeof (struct sdr_record_list)); if (sdr_list_itr == NULL) { sdr_list_itr = ipmi_sdr_start(intf); @@ -2978,18 +3112,18 @@ ipmi_sdr_find_sdr_bytype(struct ipmi_intf * intf, uint8_t type) for (e = sdr_list_head; e != NULL; e = e->next) if (e->type == type) __sdr_list_add(head, e); - + /* now keep looking */ while ((header = ipmi_sdr_get_next_header(intf, sdr_list_itr)) != NULL) { - uint8_t * rec; - struct sdr_record_list * sdrr; + uint8_t *rec; + struct sdr_record_list *sdrr; - sdrr = malloc(sizeof(struct sdr_record_list)); + sdrr = malloc(sizeof (struct sdr_record_list)); if (sdrr == NULL) { lprintf(LOG_ERR, "ipmitool: malloc failure"); break; } - memset(sdrr, 0, sizeof(struct sdr_record_list)); + memset(sdrr, 0, sizeof (struct sdr_record_list)); sdrr->id = header->id; sdrr->type = header->type; @@ -2999,25 +3133,32 @@ ipmi_sdr_find_sdr_bytype(struct ipmi_intf * intf, uint8_t type) switch (header->type) { case SDR_RECORD_TYPE_FULL_SENSOR: - sdrr->record.full = (struct sdr_record_full_sensor *)rec; + sdrr->record.full = + (struct sdr_record_full_sensor *) rec; break; case SDR_RECORD_TYPE_COMPACT_SENSOR: - sdrr->record.compact = (struct sdr_record_compact_sensor *)rec; + sdrr->record.compact = + (struct sdr_record_compact_sensor *) rec; break; case SDR_RECORD_TYPE_EVENTONLY_SENSOR: - sdrr->record.eventonly = (struct sdr_record_eventonly_sensor *)rec; + sdrr->record.eventonly = + (struct sdr_record_eventonly_sensor *) rec; break; case SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR: - sdrr->record.genloc = (struct sdr_record_generic_locator *)rec; + sdrr->record.genloc = + (struct sdr_record_generic_locator *) rec; break; case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: - sdrr->record.fruloc = (struct sdr_record_fru_locator *)rec; + sdrr->record.fruloc = + (struct sdr_record_fru_locator *) rec; break; case SDR_RECORD_TYPE_MC_DEVICE_LOCATOR: - sdrr->record.mcloc = (struct sdr_record_mc_locator *)rec; + sdrr->record.mcloc = + (struct sdr_record_mc_locator *) rec; break; case SDR_RECORD_TYPE_ENTITY_ASSOC: - sdrr->record.entassoc = (struct sdr_record_entity_assoc *)rec; + sdrr->record.entassoc = + (struct sdr_record_entity_assoc *) rec; break; default: free(rec); @@ -3048,10 +3189,10 @@ ipmi_sdr_find_sdr_bytype(struct ipmi_intf * intf, uint8_t type) * returns NULL on error */ struct sdr_record_list * -ipmi_sdr_find_sdr_byid(struct ipmi_intf * intf, char * id) +ipmi_sdr_find_sdr_byid(struct ipmi_intf *intf, char *id) { - struct sdr_get_rs * header; - struct sdr_record_list * e; + struct sdr_get_rs *header; + struct sdr_record_list *e; int found = 0; int idlen; @@ -3073,32 +3214,38 @@ ipmi_sdr_find_sdr_byid(struct ipmi_intf * intf, char * id) switch (e->type) { case SDR_RECORD_TYPE_FULL_SENSOR: if (!strncmp(e->record.full->id_string, id, - __max(e->record.full->id_code & 0x1f, idlen))) + __max(e->record.full->id_code & 0x1f, + idlen))) return e; break; case SDR_RECORD_TYPE_COMPACT_SENSOR: if (!strncmp(e->record.compact->id_string, id, - __max(e->record.compact->id_code & 0x1f, idlen))) + __max(e->record.compact->id_code & 0x1f, + idlen))) return e; break; case SDR_RECORD_TYPE_EVENTONLY_SENSOR: if (!strncmp(e->record.eventonly->id_string, id, - __max(e->record.eventonly->id_code & 0x1f, idlen))) + __max(e->record.eventonly->id_code & 0x1f, + idlen))) return e; break; case SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR: if (!strncmp(e->record.genloc->id_string, id, - __max(e->record.genloc->id_code & 0x1f, idlen))) + __max(e->record.genloc->id_code & 0x1f, + idlen))) return e; break; case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: if (!strncmp(e->record.fruloc->id_string, id, - __max(e->record.fruloc->id_code & 0x1f, idlen))) + __max(e->record.fruloc->id_code & 0x1f, + idlen))) return e; break; case SDR_RECORD_TYPE_MC_DEVICE_LOCATOR: if (!strncmp(e->record.mcloc->id_string, id, - __max(e->record.mcloc->id_code & 0x1f, idlen))) + __max(e->record.mcloc->id_code & 0x1f, + idlen))) return e; break; } @@ -3106,15 +3253,15 @@ ipmi_sdr_find_sdr_byid(struct ipmi_intf * intf, char * id) /* now keep looking */ while ((header = ipmi_sdr_get_next_header(intf, sdr_list_itr)) != NULL) { - uint8_t * rec; - struct sdr_record_list * sdrr; + uint8_t *rec; + struct sdr_record_list *sdrr; - sdrr = malloc(sizeof(struct sdr_record_list)); + sdrr = malloc(sizeof (struct sdr_record_list)); if (sdrr == NULL) { lprintf(LOG_ERR, "ipmitool: malloc failure"); break; } - memset(sdrr, 0, sizeof(struct sdr_record_list)); + memset(sdrr, 0, sizeof (struct sdr_record_list)); sdrr->id = header->id; sdrr->type = header->type; @@ -3124,43 +3271,58 @@ ipmi_sdr_find_sdr_byid(struct ipmi_intf * intf, char * id) switch (header->type) { case SDR_RECORD_TYPE_FULL_SENSOR: - sdrr->record.full = (struct sdr_record_full_sensor *)rec; - if (!strncmp(sdrr->record.full->id_string, id, - __max(sdrr->record.full->id_code & 0x1f, idlen))) + sdrr->record.full = + (struct sdr_record_full_sensor *) rec; + if (!strncmp + (sdrr->record.full->id_string, id, + __max(sdrr->record.full->id_code & 0x1f, idlen))) found = 1; break; case SDR_RECORD_TYPE_COMPACT_SENSOR: - sdrr->record.compact = (struct sdr_record_compact_sensor *)rec; - if (!strncmp(sdrr->record.compact->id_string, id, - __max(sdrr->record.compact->id_code & 0x1f, idlen))) + sdrr->record.compact = + (struct sdr_record_compact_sensor *) rec; + if (!strncmp + (sdrr->record.compact->id_string, id, + __max(sdrr->record.compact->id_code & 0x1f, + idlen))) found = 1; break; case SDR_RECORD_TYPE_EVENTONLY_SENSOR: - sdrr->record.eventonly = (struct sdr_record_eventonly_sensor *)rec; - if (!strncmp(sdrr->record.eventonly->id_string, id, - __max(sdrr->record.eventonly->id_code & 0x1f, idlen))) + sdrr->record.eventonly = + (struct sdr_record_eventonly_sensor *) rec; + if (!strncmp + (sdrr->record.eventonly->id_string, id, + __max(sdrr->record.eventonly->id_code & 0x1f, + idlen))) found = 1; break; case SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR: - sdrr->record.genloc = (struct sdr_record_generic_locator *)rec; - if (!strncmp(sdrr->record.genloc->id_string, id, - __max(sdrr->record.genloc->id_code & 0x1f, idlen))) + sdrr->record.genloc = + (struct sdr_record_generic_locator *) rec; + if (!strncmp + (sdrr->record.genloc->id_string, id, + __max(sdrr->record.genloc->id_code & 0x1f, idlen))) found = 1; break; case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: - sdrr->record.fruloc = (struct sdr_record_fru_locator *)rec; - if (!strncmp(sdrr->record.fruloc->id_string, id, - __max(sdrr->record.fruloc->id_code & 0x1f, idlen))) + sdrr->record.fruloc = + (struct sdr_record_fru_locator *) rec; + if (!strncmp + (sdrr->record.fruloc->id_string, id, + __max(sdrr->record.fruloc->id_code & 0x1f, idlen))) found = 1; break; case SDR_RECORD_TYPE_MC_DEVICE_LOCATOR: - sdrr->record.mcloc = (struct sdr_record_mc_locator *)rec; - if (!strncmp(sdrr->record.mcloc->id_string, id, - __max(sdrr->record.mcloc->id_code & 0x1f, idlen))) + sdrr->record.mcloc = + (struct sdr_record_mc_locator *) rec; + if (!strncmp + (sdrr->record.mcloc->id_string, id, + __max(sdrr->record.mcloc->id_code & 0x1f, idlen))) found = 1; break; case SDR_RECORD_TYPE_ENTITY_ASSOC: - sdrr->record.entassoc = (struct sdr_record_entity_assoc *)rec; + sdrr->record.entassoc = + (struct sdr_record_entity_assoc *) rec; break; default: free(rec); @@ -3191,17 +3353,17 @@ ipmi_sdr_find_sdr_byid(struct ipmi_intf * intf, char * id) * returns NULL on error */ int -ipmi_sdr_list_cache_fromfile(struct ipmi_intf * intf, const char * ifile) +ipmi_sdr_list_cache_fromfile(struct ipmi_intf *intf, const char *ifile) { - FILE * fp; + FILE *fp; struct __sdr_header { uint16_t id; uint8_t version; uint8_t type; uint8_t length; } header; - struct sdr_record_list * sdrr; - uint8_t * rec; + struct sdr_record_list *sdrr; + uint8_t *rec; int ret = 0, count = 0, bc = 0; if (ifile == NULL) { @@ -3211,7 +3373,8 @@ ipmi_sdr_list_cache_fromfile(struct ipmi_intf * intf, const char * ifile) fp = ipmi_open_file_read(ifile); if (fp == NULL) { - lprintf(LOG_ERR, "Unable to open SDR cache %s for reading", ifile); + lprintf(LOG_ERR, "Unable to open SDR cache %s for reading", + ifile); return -1; } @@ -3222,7 +3385,8 @@ ipmi_sdr_list_cache_fromfile(struct ipmi_intf * intf, const char * ifile) break; if (bc != 5) { - lprintf(LOG_ERR, "header read %d bytes, expected 5", bc); + lprintf(LOG_ERR, "header read %d bytes, expected 5", + bc); ret = -1; break; } @@ -3231,17 +3395,18 @@ ipmi_sdr_list_cache_fromfile(struct ipmi_intf * intf, const char * ifile) continue; if (header.version != 0x51) { - lprintf(LOG_WARN, "invalid sdr header version %02x", header.version); + lprintf(LOG_WARN, "invalid sdr header version %02x", + header.version); continue; } - sdrr = malloc(sizeof(struct sdr_record_list)); + sdrr = malloc(sizeof (struct sdr_record_list)); if (sdrr == NULL) { lprintf(LOG_ERR, "ipmitool: malloc failure"); ret = -1; break; } - memset(sdrr, 0, sizeof(struct sdr_record_list)); + memset(sdrr, 0, sizeof (struct sdr_record_list)); sdrr->id = header.id; sdrr->type = header.type; @@ -3256,7 +3421,8 @@ ipmi_sdr_list_cache_fromfile(struct ipmi_intf * intf, const char * ifile) bc = fread(rec, 1, header.length, fp); if (bc != header.length) { - lprintf(LOG_ERR, "record %04x read %d bytes, expected %d", + lprintf(LOG_ERR, + "record %04x read %d bytes, expected %d", header.id, bc, header.length); ret = -1; break; @@ -3264,31 +3430,38 @@ ipmi_sdr_list_cache_fromfile(struct ipmi_intf * intf, const char * ifile) switch (header.type) { case SDR_RECORD_TYPE_FULL_SENSOR: - sdrr->record.full = (struct sdr_record_full_sensor *)rec; + sdrr->record.full = + (struct sdr_record_full_sensor *) rec; break; case SDR_RECORD_TYPE_COMPACT_SENSOR: - sdrr->record.compact = (struct sdr_record_compact_sensor *)rec; + sdrr->record.compact = + (struct sdr_record_compact_sensor *) rec; break; case SDR_RECORD_TYPE_EVENTONLY_SENSOR: - sdrr->record.eventonly = (struct sdr_record_eventonly_sensor *)rec; + sdrr->record.eventonly = + (struct sdr_record_eventonly_sensor *) rec; break; case SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR: - sdrr->record.genloc = (struct sdr_record_generic_locator *)rec; + sdrr->record.genloc = + (struct sdr_record_generic_locator *) rec; break; case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: - sdrr->record.fruloc = (struct sdr_record_fru_locator *)rec; + sdrr->record.fruloc = + (struct sdr_record_fru_locator *) rec; break; case SDR_RECORD_TYPE_MC_DEVICE_LOCATOR: - sdrr->record.mcloc = (struct sdr_record_mc_locator *)rec; + sdrr->record.mcloc = + (struct sdr_record_mc_locator *) rec; break; case SDR_RECORD_TYPE_ENTITY_ASSOC: - sdrr->record.entassoc = (struct sdr_record_entity_assoc *)rec; + sdrr->record.entassoc = + (struct sdr_record_entity_assoc *) rec; break; default: free(rec); continue; } - + /* add to global record liset */ if (sdr_list_head == NULL) sdr_list_head = sdrr; @@ -3299,11 +3472,12 @@ ipmi_sdr_list_cache_fromfile(struct ipmi_intf * intf, const char * ifile) count++; - lprintf(LOG_DEBUG, "Read record %04x from file into cache", sdrr->id); + lprintf(LOG_DEBUG, "Read record %04x from file into cache", + sdrr->id); } if (sdr_list_itr == NULL) { - sdr_list_itr = malloc(sizeof(struct ipmi_sdr_iterator)); + sdr_list_itr = malloc(sizeof (struct ipmi_sdr_iterator)); if (sdr_list_itr != NULL) { sdr_list_itr->reservation = 0; sdr_list_itr->total = count; @@ -3323,9 +3497,9 @@ ipmi_sdr_list_cache_fromfile(struct ipmi_intf * intf, const char * ifile) * returns NULL on error */ int -ipmi_sdr_list_cache(struct ipmi_intf * intf) +ipmi_sdr_list_cache(struct ipmi_intf *intf) { - struct sdr_get_rs * header; + struct sdr_get_rs *header; if (sdr_list_itr == NULL) { sdr_list_itr = ipmi_sdr_start(intf); @@ -3336,15 +3510,15 @@ ipmi_sdr_list_cache(struct ipmi_intf * intf) } while ((header = ipmi_sdr_get_next_header(intf, sdr_list_itr)) != NULL) { - uint8_t * rec; - struct sdr_record_list * sdrr; + uint8_t *rec; + struct sdr_record_list *sdrr; - sdrr = malloc(sizeof(struct sdr_record_list)); + sdrr = malloc(sizeof (struct sdr_record_list)); if (sdrr == NULL) { lprintf(LOG_ERR, "ipmitool: malloc failure"); break; } - memset(sdrr, 0, sizeof(struct sdr_record_list)); + memset(sdrr, 0, sizeof (struct sdr_record_list)); sdrr->id = header->id; sdrr->type = header->type; @@ -3354,25 +3528,32 @@ ipmi_sdr_list_cache(struct ipmi_intf * intf) switch (header->type) { case SDR_RECORD_TYPE_FULL_SENSOR: - sdrr->record.full = (struct sdr_record_full_sensor *)rec; + sdrr->record.full = + (struct sdr_record_full_sensor *) rec; break; case SDR_RECORD_TYPE_COMPACT_SENSOR: - sdrr->record.compact = (struct sdr_record_compact_sensor *)rec; + sdrr->record.compact = + (struct sdr_record_compact_sensor *) rec; break; case SDR_RECORD_TYPE_EVENTONLY_SENSOR: - sdrr->record.eventonly = (struct sdr_record_eventonly_sensor *)rec; + sdrr->record.eventonly = + (struct sdr_record_eventonly_sensor *) rec; break; case SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR: - sdrr->record.genloc = (struct sdr_record_generic_locator *)rec; + sdrr->record.genloc = + (struct sdr_record_generic_locator *) rec; break; case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: - sdrr->record.fruloc = (struct sdr_record_fru_locator *)rec; + sdrr->record.fruloc = + (struct sdr_record_fru_locator *) rec; break; case SDR_RECORD_TYPE_MC_DEVICE_LOCATOR: - sdrr->record.mcloc = (struct sdr_record_mc_locator *)rec; + sdrr->record.mcloc = + (struct sdr_record_mc_locator *) rec; break; case SDR_RECORD_TYPE_ENTITY_ASSOC: - sdrr->record.entassoc = (struct sdr_record_entity_assoc *)rec; + sdrr->record.entassoc = + (struct sdr_record_entity_assoc *) rec; break; default: free(rec); @@ -3403,17 +3584,17 @@ ipmi_sdr_list_cache(struct ipmi_intf * intf) * > 0 for other errors */ int -ipmi_sdr_get_info(struct ipmi_intf * intf, - struct get_sdr_repository_info_rsp * sdr_repository_info) +ipmi_sdr_get_info(struct ipmi_intf *intf, + struct get_sdr_repository_info_rsp *sdr_repository_info) { - struct ipmi_rs * rsp; + struct ipmi_rs *rsp; struct ipmi_rq req; - memset(&req, 0, sizeof(req)); + memset(&req, 0, sizeof (req)); - req.msg.netfn = IPMI_NETFN_STORAGE; // 0x0A - req.msg.cmd = IPMI_GET_SDR_REPOSITORY_INFO; // 0x20 - req.msg.data = 0; + req.msg.netfn = IPMI_NETFN_STORAGE; // 0x0A + req.msg.cmd = IPMI_GET_SDR_REPOSITORY_INFO; // 0x20 + req.msg.data = 0; req.msg.data_len = 0; rsp = intf->sendrecv(intf, &req); @@ -3430,7 +3611,8 @@ ipmi_sdr_get_info(struct ipmi_intf * intf, memcpy(sdr_repository_info, rsp->data, - __min(sizeof(struct get_sdr_repository_info_rsp),rsp->data_len)); + __min(sizeof (struct get_sdr_repository_info_rsp), + rsp->data_len)); return 0; } @@ -3445,14 +3627,14 @@ static char * ipmi_sdr_timestamp(uint32_t stamp) { static char tbuf[40]; - time_t s = (time_t)stamp; + time_t s = (time_t) stamp; memset(tbuf, 0, 40); if (stamp) - strftime(tbuf, sizeof(tbuf), "%m/%d/%Y %H:%M:%S", localtime(&s)); + strftime(tbuf, sizeof (tbuf), "%m/%d/%Y %H:%M:%S", + localtime(&s)); return tbuf; } - /* * ipmi_sdr_print_info * @@ -3463,29 +3645,28 @@ ipmi_sdr_timestamp(uint32_t stamp) * -1 on error */ int -ipmi_sdr_print_info(struct ipmi_intf * intf) +ipmi_sdr_print_info(struct ipmi_intf *intf) { uint32_t timestamp; uint16_t free_space; struct get_sdr_repository_info_rsp sdr_repository_info; - + if (ipmi_sdr_get_info(intf, &sdr_repository_info) != 0) return -1; printf("SDR Version : 0x%x\n", - sdr_repository_info.sdr_version); + sdr_repository_info.sdr_version); printf("Record Count : %d\n", - (sdr_repository_info.record_count_msb << 8) | - sdr_repository_info.record_count_lsb); - + (sdr_repository_info.record_count_msb << 8) | + sdr_repository_info.record_count_lsb); + free_space = - (sdr_repository_info.free_space[0] << 8) | - sdr_repository_info.free_space[1]; - + (sdr_repository_info.free_space[0] << 8) | + sdr_repository_info.free_space[1]; + printf("Free Space : "); - switch (free_space) - { + switch (free_space) { case 0x0000: printf("none (full)\n"); break; @@ -3501,26 +3682,26 @@ ipmi_sdr_print_info(struct ipmi_intf * intf) } timestamp = - (sdr_repository_info.most_recent_addition_timestamp[3] << 24) | - (sdr_repository_info.most_recent_addition_timestamp[2] << 16) | - (sdr_repository_info.most_recent_addition_timestamp[1] << 8) | - sdr_repository_info.most_recent_addition_timestamp[0]; + (sdr_repository_info.most_recent_addition_timestamp[3] << 24) | + (sdr_repository_info.most_recent_addition_timestamp[2] << 16) | + (sdr_repository_info.most_recent_addition_timestamp[1] << 8) | + sdr_repository_info.most_recent_addition_timestamp[0]; printf("Most recent Addition : %s\n", - ipmi_sdr_timestamp(timestamp)); + ipmi_sdr_timestamp(timestamp)); timestamp = - (sdr_repository_info.most_recent_erase_timestamp[3] << 24) | - (sdr_repository_info.most_recent_erase_timestamp[2] << 16) | - (sdr_repository_info.most_recent_erase_timestamp[1] << 8) | - sdr_repository_info.most_recent_erase_timestamp[0]; - printf("Most recent Erase : %s\n", ipmi_sdr_timestamp(timestamp)); + (sdr_repository_info.most_recent_erase_timestamp[3] << 24) | + (sdr_repository_info.most_recent_erase_timestamp[2] << 16) | + (sdr_repository_info.most_recent_erase_timestamp[1] << 8) | + sdr_repository_info.most_recent_erase_timestamp[0]; + printf("Most recent Erase : %s\n", + ipmi_sdr_timestamp(timestamp)); printf("SDR overflow : %s\n", - (sdr_repository_info.overflow_flag? "yes": "no")); + (sdr_repository_info.overflow_flag ? "yes" : "no")); printf("SDR Repository Update Support : "); - switch (sdr_repository_info.modal_update_support) - { + switch (sdr_repository_info.modal_update_support) { case 0: printf("unspecified\n"); break; @@ -3539,13 +3720,14 @@ ipmi_sdr_print_info(struct ipmi_intf * intf) } printf("Delete SDR supported : %s\n", - sdr_repository_info.delete_sdr_supported? "yes" : "no"); + sdr_repository_info.delete_sdr_supported ? "yes" : "no"); printf("Partial Add SDR supported : %s\n", - sdr_repository_info.partial_add_sdr_supported? "yes" : "no"); + sdr_repository_info.partial_add_sdr_supported ? "yes" : "no"); printf("Reserve SDR repository supported : %s\n", - sdr_repository_info.reserve_sdr_repository_supported? "yes" : "no"); + sdr_repository_info. + reserve_sdr_repository_supported ? "yes" : "no"); printf("SDR Repository Alloc info supported : %s\n", - sdr_repository_info.delete_sdr_supported? "yes" : "no"); + sdr_repository_info.delete_sdr_supported ? "yes" : "no"); return 0; } @@ -3561,17 +3743,17 @@ ipmi_sdr_print_info(struct ipmi_intf * intf) * returns -1 on error */ static int -ipmi_sdr_dump_bin(struct ipmi_intf * intf, const char * ofile) -{ - struct sdr_get_rs * header; - struct ipmi_sdr_iterator * itr; - FILE * fp; +ipmi_sdr_dump_bin(struct ipmi_intf *intf, const char *ofile) +{ + struct sdr_get_rs *header; + struct ipmi_sdr_iterator *itr; + FILE *fp; int rc = 0; fp = ipmi_open_file_write(ofile); if (fp == NULL) return -1; - + /* open connection to SDR */ itr = ipmi_sdr_start(intf); if (itr == NULL) { @@ -3586,7 +3768,7 @@ ipmi_sdr_dump_bin(struct ipmi_intf * intf, const char * ofile) while ((header = ipmi_sdr_get_next_header(intf, itr)) != NULL) { int r; uint8_t h[5]; - uint8_t * rec; + uint8_t *rec; lprintf(LOG_INFO, "Record ID %04x (%d bytes)", header->id, header->length); @@ -3626,8 +3808,6 @@ ipmi_sdr_dump_bin(struct ipmi_intf * intf, const char * ofile) return rc; } - - /* ipmi_sdr_print_type - print all sensors of specified type * * @intf: ipmi interface @@ -3637,9 +3817,9 @@ ipmi_sdr_dump_bin(struct ipmi_intf * intf, const char * ofile) * returns -1 on error */ int -ipmi_sdr_print_type(struct ipmi_intf * intf, char * type) +ipmi_sdr_print_type(struct ipmi_intf *intf, char *type) { - struct sdr_record_list * list, * entry; + struct sdr_record_list *list, *entry; int rc = 0; int x; uint8_t sensor_type = 0; @@ -3648,30 +3828,31 @@ ipmi_sdr_print_type(struct ipmi_intf * intf, char * type) strncasecmp(type, "help", 4) == 0 || strncasecmp(type, "list", 4) == 0) { printf("Sensor Types:\n"); - for (x = 1; x < SENSOR_TYPE_MAX; x+=2) { + for (x = 1; x < SENSOR_TYPE_MAX; x += 2) { printf("\t%-25s %-25s\n", - sensor_type_desc[x], sensor_type_desc[x+1]); + sensor_type_desc[x], sensor_type_desc[x + 1]); } return 0; } if (strncmp(type, "0x", 2) == 0) { /* begins with 0x so let it be entered as raw hex value */ - sensor_type = (uint8_t)strtol(type, NULL, 0); - } - else { + sensor_type = (uint8_t) strtol(type, NULL, 0); + } else { for (x = 1; x < SENSOR_TYPE_MAX; x++) { if (strncasecmp(sensor_type_desc[x], type, - __maxlen(type, sensor_type_desc[x])) == 0) { + __maxlen(type, + sensor_type_desc[x])) == 0) { sensor_type = x; break; } } if (sensor_type != x) { printf("Sensor Types:\n"); - for (x = 1; x < SENSOR_TYPE_MAX; x+=2) { + for (x = 1; x < SENSOR_TYPE_MAX; x += 2) { printf("\t%-25s %-25s\n", - sensor_type_desc[x], sensor_type_desc[x+1]); + sensor_type_desc[x], + sensor_type_desc[x + 1]); } return 0; } @@ -3688,7 +3869,6 @@ ipmi_sdr_print_type(struct ipmi_intf * intf, char * type) return rc; } - /* ipmi_sdr_print_entity - print entity's for an id/instance * * @intf: ipmi interface @@ -3698,9 +3878,9 @@ ipmi_sdr_print_type(struct ipmi_intf * intf, char * type) * returns -1 on error */ int -ipmi_sdr_print_entity(struct ipmi_intf * intf, char * entitystr) +ipmi_sdr_print_entity(struct ipmi_intf *intf, char *entitystr) { - struct sdr_record_list * list, * entry; + struct sdr_record_list *list, *entry; struct entity_id entity; unsigned id = 0; unsigned instance = 0; @@ -3739,7 +3919,6 @@ ipmi_sdr_print_entity(struct ipmi_intf * intf, char * entitystr) return rc; } - /* ipmi_sdr_print_entry_byid - print sdr entries identified by sensor id * * @intf: ipmi interface @@ -3750,9 +3929,9 @@ ipmi_sdr_print_entity(struct ipmi_intf * intf, char * entitystr) * returns -1 on error */ static int -ipmi_sdr_print_entry_byid(struct ipmi_intf * intf, int argc, char ** argv) +ipmi_sdr_print_entry_byid(struct ipmi_intf *intf, int argc, char **argv) { - struct sdr_record_list * sdr; + struct sdr_record_list *sdr; int rc = 0; int v, i; @@ -3764,10 +3943,11 @@ ipmi_sdr_print_entry_byid(struct ipmi_intf * intf, int argc, char ** argv) v = verbose; verbose = 1; - for (i=0; i[.]"); - lprintf(LOG_ERR, " Display all sensors associated with an entity"); + lprintf(LOG_ERR, + " Display all sensors associated with an entity"); lprintf(LOG_ERR, " dump "); - lprintf(LOG_ERR, " Dump raw SDR data to a file"); - } - else if (strncmp(argv[0], "list", 4) == 0 || - strncmp(argv[0], "elist", 5) == 0) { + lprintf(LOG_ERR, + " Dump raw SDR data to a file"); + } else if (strncmp(argv[0], "list", 4) == 0 + || strncmp(argv[0], "elist", 5) == 0) { if (strncmp(argv[0], "elist", 5) == 0) sdr_extended = 1; @@ -3829,41 +4020,42 @@ ipmi_sdr_main(struct ipmi_intf * intf, int argc, char ** argv) else if (strncmp(argv[1], "all", 3) == 0) rc = ipmi_sdr_print_sdr(intf, 0xff); else if (strncmp(argv[1], "full", 4) == 0) - rc = ipmi_sdr_print_sdr(intf, SDR_RECORD_TYPE_FULL_SENSOR); + rc = ipmi_sdr_print_sdr(intf, + SDR_RECORD_TYPE_FULL_SENSOR); else if (strncmp(argv[1], "compact", 7) == 0) - rc = ipmi_sdr_print_sdr(intf, SDR_RECORD_TYPE_COMPACT_SENSOR); + rc = ipmi_sdr_print_sdr(intf, + SDR_RECORD_TYPE_COMPACT_SENSOR); else if (strncmp(argv[1], "event", 5) == 0) - rc = ipmi_sdr_print_sdr(intf, SDR_RECORD_TYPE_EVENTONLY_SENSOR); + rc = ipmi_sdr_print_sdr(intf, + SDR_RECORD_TYPE_EVENTONLY_SENSOR); else if (strncmp(argv[1], "mcloc", 5) == 0) - rc = ipmi_sdr_print_sdr(intf, SDR_RECORD_TYPE_MC_DEVICE_LOCATOR); + rc = ipmi_sdr_print_sdr(intf, + SDR_RECORD_TYPE_MC_DEVICE_LOCATOR); else if (strncmp(argv[1], "fru", 3) == 0) - rc = ipmi_sdr_print_sdr(intf, SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR); + rc = ipmi_sdr_print_sdr(intf, + SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR); else if (strncmp(argv[1], "generic", 7) == 0) - rc = ipmi_sdr_print_sdr(intf, SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR); + rc = ipmi_sdr_print_sdr(intf, + SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR); else - lprintf(LOG_ERR, "usage: sdr list [all|full|compact|event|mcloc|fru|generic]"); - } - else if (strncmp(argv[0], "type", 4) == 0) { + lprintf(LOG_ERR, + "usage: sdr list [all|full|compact|event|mcloc|fru|generic]"); + } else if (strncmp(argv[0], "type", 4) == 0) { sdr_extended = 1; rc = ipmi_sdr_print_type(intf, argv[1]); - } - else if (strncmp(argv[0], "entity", 6) == 0) { + } else if (strncmp(argv[0], "entity", 6) == 0) { sdr_extended = 1; rc = ipmi_sdr_print_entity(intf, argv[1]); - } - else if (strncmp(argv[0], "info", 4) == 0) { + } else if (strncmp(argv[0], "info", 4) == 0) { rc = ipmi_sdr_print_info(intf); - } - else if (strncmp(argv[0], "get", 4) == 0) { - rc = ipmi_sdr_print_entry_byid(intf, argc-1, &argv[1]); - } - else if (strncmp(argv[0], "dump", 4) == 0) { + } else if (strncmp(argv[0], "get", 4) == 0) { + rc = ipmi_sdr_print_entry_byid(intf, argc - 1, &argv[1]); + } else if (strncmp(argv[0], "dump", 4) == 0) { if (argc < 2) lprintf(LOG_ERR, "usage: sdr dump "); else rc = ipmi_sdr_dump_bin(intf, argv[1]); - } - else { + } else { lprintf(LOG_ERR, "Invalid SDR command: %s", argv[0]); rc = -1; } diff --git a/ipmitool/lib/ipmi_sensor.c b/ipmitool/lib/ipmi_sensor.c index 1d3dcac..c814503 100644 --- a/ipmitool/lib/ipmi_sensor.c +++ b/ipmitool/lib/ipmi_sensor.c @@ -51,17 +51,16 @@ extern int verbose; static struct ipmi_rs * -ipmi_sensor_set_sensor_thresholds(struct ipmi_intf * intf, - uint8_t sensor, - uint8_t threshold, - uint8_t setting) +ipmi_sensor_set_sensor_thresholds(struct ipmi_intf *intf, + uint8_t sensor, + uint8_t threshold, uint8_t setting) { struct ipmi_rq req; static struct sensor_set_thresh_rq set_thresh_rq; - memset(&set_thresh_rq, 0, sizeof(set_thresh_rq)); + memset(&set_thresh_rq, 0, sizeof (set_thresh_rq)); set_thresh_rq.sensor_num = sensor; - set_thresh_rq.set_mask = threshold; + set_thresh_rq.set_mask = threshold; if (threshold == UPPER_NON_RECOV_SPECIFIED) set_thresh_rq.upper_non_recov = setting; else if (threshold == UPPER_CRIT_SPECIFIED) @@ -77,37 +76,37 @@ ipmi_sensor_set_sensor_thresholds(struct ipmi_intf * intf, else return NULL; - memset(&req, 0, sizeof(req)); + memset(&req, 0, sizeof (req)); req.msg.netfn = IPMI_NETFN_SE; req.msg.cmd = SET_SENSOR_THRESHOLDS; - req.msg.data = (uint8_t *)&set_thresh_rq; - req.msg.data_len = sizeof(set_thresh_rq); + req.msg.data = (uint8_t *) & set_thresh_rq; + req.msg.data_len = sizeof (set_thresh_rq); return intf->sendrecv(intf, &req); } static int -ipmi_sensor_print_full_discrete(struct ipmi_intf * intf, - struct sdr_record_full_sensor * sensor) +ipmi_sensor_print_full_discrete(struct ipmi_intf *intf, + struct sdr_record_full_sensor *sensor) { char id[17]; - char * unitstr = "discrete"; - int validread=1; + char *unitstr = "discrete"; + int validread = 1; uint8_t val = 0; - struct ipmi_rs * rsp; + struct ipmi_rs *rsp; if (sensor == NULL) return -1; - memset(id, 0, sizeof(id)); + memset(id, 0, sizeof (id)); memcpy(id, sensor->id_string, 16); /* * Get current reading */ rsp = ipmi_sdr_get_sensor_reading_ipmb(intf, - sensor->keys.sensor_num, - sensor->keys.owner_id); + sensor->keys.sensor_num, + sensor->keys.owner_id); if (rsp == NULL) { lprintf(LOG_ERR, "Error reading sensor %s (#%02x)", id, sensor->keys.sensor_num); @@ -119,12 +118,9 @@ ipmi_sensor_print_full_discrete(struct ipmi_intf * intf, val = rsp->data[0]; } - if (csv_output) - { + if (csv_output) { /* NOT IMPLEMENTED */ - } - else - { + } else { if (verbose == 0) { /* output format * id value units status thresholds.... @@ -133,16 +129,12 @@ ipmi_sensor_print_full_discrete(struct ipmi_intf * intf, if (validread) { printf("| 0x%-8x | %-10s | 0x%02x%02x", val, - unitstr, - rsp->data[2], - rsp->data[3]); + unitstr, rsp->data[2], rsp->data[3]); } else { printf("| %-10s | %-10s | %-6s", - "na", - unitstr, - "na"); + "na", unitstr, "na"); } - printf("| %-10s| %-10s| %-10s| %-10s| %-10s| %-10s", + printf("| %-10s| %-10s| %-10s| %-10s| %-10s| %-10s", "na", "na", "na", "na", "na", "na"); printf("\n"); @@ -151,8 +143,9 @@ ipmi_sensor_print_full_discrete(struct ipmi_intf * intf, id, sensor->keys.sensor_num); printf(" Entity ID : %d.%d\n", sensor->entity.id, sensor->entity.instance); - printf(" Sensor Type (Discrete): %s\n", - ipmi_sdr_get_sensor_type_desc(sensor->sensor.type)); + printf(" Sensor Type (Discrete): %s\n", + ipmi_sdr_get_sensor_type_desc(sensor->sensor. + type)); ipmi_sdr_print_discrete_state("States Asserted", sensor->sensor.type, sensor->event_type, @@ -166,23 +159,23 @@ ipmi_sensor_print_full_discrete(struct ipmi_intf * intf, } static int -ipmi_sensor_print_full_analog(struct ipmi_intf * intf, - struct sdr_record_full_sensor * sensor) +ipmi_sensor_print_full_analog(struct ipmi_intf *intf, + struct sdr_record_full_sensor *sensor) { char unitstr[16], id[17]; - int i=0, validread=1, thresh_available = 1; + int i = 0, validread = 1, thresh_available = 1; double val = 0.0; - struct ipmi_rs * rsp; - char * status = NULL; + struct ipmi_rs *rsp; + char *status = NULL; if (sensor == NULL) return -1; - memset(id, 0, sizeof(id)); + memset(id, 0, sizeof (id)); memcpy(id, sensor->id_string, 16); /* only handle linear and linearized sensors (for now) */ - if (sensor->linearization>=SDR_SENSOR_L_NONLINEAR) { + if (sensor->linearization >= SDR_SENSOR_L_NONLINEAR) { printf("sensor %s non-linear!\n", id); return -1; } @@ -202,30 +195,29 @@ ipmi_sensor_print_full_analog(struct ipmi_intf * intf, } else { /* convert RAW reading into units */ val = (rsp->data[0] > 0) - ? sdr_convert_sensor_reading(sensor, rsp->data[0]) - : 0; - status = (char*)ipmi_sdr_get_status(sensor, rsp->data[2]); + ? sdr_convert_sensor_reading(sensor, rsp->data[0]) + : 0; + status = (char *) ipmi_sdr_get_status(sensor, rsp->data[2]); } /* * Figure out units */ - memset(unitstr, 0, sizeof(unitstr)); - switch (sensor->unit.modifier) - { - case 2: - i += snprintf(unitstr, sizeof(unitstr), "%s * %s", + memset(unitstr, 0, sizeof (unitstr)); + switch (sensor->unit.modifier) { + case 2: + i += snprintf(unitstr, sizeof (unitstr), "%s * %s", unit_desc[sensor->unit.type.base], unit_desc[sensor->unit.type.modifier]); break; - case 1: - i += snprintf(unitstr, sizeof(unitstr), "%s/%s", + case 1: + i += snprintf(unitstr, sizeof (unitstr), "%s/%s", unit_desc[sensor->unit.type.base], unit_desc[sensor->unit.type.modifier]); break; - case 0: - default: - i += snprintf(unitstr, sizeof(unitstr), "%s", + case 0: + default: + i += snprintf(unitstr, sizeof (unitstr), "%s", unit_desc[sensor->unit.type.base]); break; } @@ -237,14 +229,10 @@ ipmi_sensor_print_full_analog(struct ipmi_intf * intf, if (rsp == NULL) thresh_available = 0; - if (csv_output) - { + if (csv_output) { /* NOT IPMLEMENTED */ - } - else - { - if (verbose == 0) - { + } else { + if (verbose == 0) { /* output format * id value units status thresholds.... */ @@ -256,110 +244,141 @@ ipmi_sensor_print_full_analog(struct ipmi_intf * intf, printf("| %-10s | %-10s | %-6s", "na", unitstr, "na"); } - if (thresh_available) - { - if (rsp->data[0] & LOWER_NON_RECOV_SPECIFIED) - printf("| %-10.3f", sdr_convert_sensor_reading(sensor, rsp->data[3])); + if (thresh_available) { + if (rsp->data[0] & LOWER_NON_RECOV_SPECIFIED) + printf("| %-10.3f", + sdr_convert_sensor_reading + (sensor, rsp->data[3])); else printf("| %-10s", "na"); - if (rsp->data[0] & LOWER_CRIT_SPECIFIED) - printf("| %-10.3f", sdr_convert_sensor_reading(sensor, rsp->data[2])); + if (rsp->data[0] & LOWER_CRIT_SPECIFIED) + printf("| %-10.3f", + sdr_convert_sensor_reading + (sensor, rsp->data[2])); else printf("| %-10s", "na"); - if (rsp->data[0] & LOWER_NON_CRIT_SPECIFIED) - printf("| %-10.3f", sdr_convert_sensor_reading(sensor, rsp->data[1])); + if (rsp->data[0] & LOWER_NON_CRIT_SPECIFIED) + printf("| %-10.3f", + sdr_convert_sensor_reading + (sensor, rsp->data[1])); else printf("| %-10s", "na"); - if (rsp->data[0] & UPPER_NON_CRIT_SPECIFIED) - printf("| %-10.3f", sdr_convert_sensor_reading(sensor, rsp->data[4])); + if (rsp->data[0] & UPPER_NON_CRIT_SPECIFIED) + printf("| %-10.3f", + sdr_convert_sensor_reading + (sensor, rsp->data[4])); else printf("| %-10s", "na"); - if (rsp->data[0] & UPPER_CRIT_SPECIFIED) - printf("| %-10.3f", sdr_convert_sensor_reading(sensor, rsp->data[5])); + if (rsp->data[0] & UPPER_CRIT_SPECIFIED) + printf("| %-10.3f", + sdr_convert_sensor_reading + (sensor, rsp->data[5])); else printf("| %-10s", "na"); - if (rsp->data[0] & UPPER_NON_RECOV_SPECIFIED) - printf("| %-10.3f", sdr_convert_sensor_reading(sensor, rsp->data[6])); + if (rsp->data[0] & UPPER_NON_RECOV_SPECIFIED) + printf("| %-10.3f", + sdr_convert_sensor_reading + (sensor, rsp->data[6])); else printf("| %-10s", "na"); - } - else - { - printf("| %-10s| %-10s| %-10s| %-10s| %-10s| %-10s", - "na", "na", "na", "na", "na", "na"); + } else { + printf + ("| %-10s| %-10s| %-10s| %-10s| %-10s| %-10s", + "na", "na", "na", "na", "na", "na"); } printf("\n"); - } - else - { + } else { printf("Sensor ID : %s (0x%x)\n", id, sensor->keys.sensor_num); printf(" Entity ID : %d.%d\n", sensor->entity.id, sensor->entity.instance); - printf(" Sensor Type (Analog) : %s\n", - ipmi_sdr_get_sensor_type_desc(sensor->sensor.type)); + printf(" Sensor Type (Analog) : %s\n", + ipmi_sdr_get_sensor_type_desc(sensor->sensor. + type)); printf(" Sensor Reading : "); if (validread) { uint16_t raw_tol = __TO_TOL(sensor->mtol); - double tol = sdr_convert_sensor_reading(sensor, raw_tol * 2); + double tol = + sdr_convert_sensor_reading(sensor, + raw_tol * 2); printf("%.*f (+/- %.*f) %s\n", - (val==(int)val) ? 0 : 3, - val, - (tol==(int)tol) ? 0 : 3, - tol, + (val == (int) val) ? 0 : 3, val, + (tol == (int) tol) ? 0 : 3, tol, unitstr); - printf(" Status : %s\n", status ? : ""); + printf(" Status : %s\n", + status ? : ""); - if (thresh_available) - { - if (rsp->data[0] & LOWER_NON_RECOV_SPECIFIED) - printf(" Lower Non-Recoverable : %.3f\n", - sdr_convert_sensor_reading(sensor, rsp->data[3])); + if (thresh_available) { + if (rsp-> + data[0] & LOWER_NON_RECOV_SPECIFIED) + printf + (" Lower Non-Recoverable : %.3f\n", + sdr_convert_sensor_reading + (sensor, rsp->data[3])); else - printf(" Lower Non-Recoverable : na\n"); - if (rsp->data[0] & LOWER_CRIT_SPECIFIED) - printf(" Lower Critical : %.3f\n", - sdr_convert_sensor_reading(sensor, rsp->data[2])); + printf + (" Lower Non-Recoverable : na\n"); + if (rsp->data[0] & LOWER_CRIT_SPECIFIED) + printf + (" Lower Critical : %.3f\n", + sdr_convert_sensor_reading + (sensor, rsp->data[2])); else - printf(" Lower Critical : na\n"); - if (rsp->data[0] & LOWER_NON_CRIT_SPECIFIED) - printf(" Lower Non-Critical : %.3f\n", - sdr_convert_sensor_reading(sensor, rsp->data[1])); + printf + (" Lower Critical : na\n"); + if (rsp-> + data[0] & LOWER_NON_CRIT_SPECIFIED) + printf + (" Lower Non-Critical : %.3f\n", + sdr_convert_sensor_reading + (sensor, rsp->data[1])); else - printf(" Lower Non-Critical : na\n"); - if (rsp->data[0] & UPPER_NON_CRIT_SPECIFIED) - printf(" Upper Non-Critical : %.3f\n", - sdr_convert_sensor_reading(sensor, rsp->data[4])); + printf + (" Lower Non-Critical : na\n"); + if (rsp-> + data[0] & UPPER_NON_CRIT_SPECIFIED) + printf + (" Upper Non-Critical : %.3f\n", + sdr_convert_sensor_reading + (sensor, rsp->data[4])); else - printf(" Upper Non-Critical : na\n"); - if (rsp->data[0] & UPPER_CRIT_SPECIFIED) - printf(" Upper Critical : %.3f\n", - sdr_convert_sensor_reading(sensor, rsp->data[5])); + printf + (" Upper Non-Critical : na\n"); + if (rsp->data[0] & UPPER_CRIT_SPECIFIED) + printf + (" Upper Critical : %.3f\n", + sdr_convert_sensor_reading + (sensor, rsp->data[5])); else - printf(" Upper Critical : na\n"); - if (rsp->data[0] & UPPER_NON_RECOV_SPECIFIED) - printf(" Upper Non-Recoverable : %.3f\n", - sdr_convert_sensor_reading(sensor, rsp->data[6])); + printf + (" Upper Critical : na\n"); + if (rsp-> + data[0] & UPPER_NON_RECOV_SPECIFIED) + printf + (" Upper Non-Recoverable : %.3f\n", + sdr_convert_sensor_reading + (sensor, rsp->data[6])); else - printf(" Upper Non-Recoverable : na\n"); + printf + (" Upper Non-Recoverable : na\n"); } - } - else - { + } else { printf("Not Present\n"); } ipmi_sdr_print_sensor_event_status(intf, - sensor->keys.sensor_num, + sensor->keys. + sensor_num, sensor->sensor.type, sensor->event_type, ANALOG_SENSOR); ipmi_sdr_print_sensor_event_enable(intf, - sensor->keys.sensor_num, + sensor->keys. + sensor_num, sensor->sensor.type, sensor->event_type, ANALOG_SENSOR); @@ -372,8 +391,8 @@ ipmi_sensor_print_full_analog(struct ipmi_intf * intf, } int -ipmi_sensor_print_full(struct ipmi_intf * intf, - struct sdr_record_full_sensor * sensor) +ipmi_sensor_print_full(struct ipmi_intf *intf, + struct sdr_record_full_sensor *sensor) { if (sensor->unit.analog != 3) return ipmi_sensor_print_full_analog(intf, sensor); @@ -382,19 +401,19 @@ ipmi_sensor_print_full(struct ipmi_intf * intf, } int -ipmi_sensor_print_compact(struct ipmi_intf * intf, - struct sdr_record_compact_sensor * sensor) +ipmi_sensor_print_compact(struct ipmi_intf *intf, + struct sdr_record_compact_sensor *sensor) { char id[17]; - char * unitstr = "discrete"; + char *unitstr = "discrete"; int validread = 1; uint8_t val = 0; - struct ipmi_rs * rsp; + struct ipmi_rs *rsp; if (sensor == NULL) return -1; - memset(id, 0, sizeof(id)); + memset(id, 0, sizeof (id)); memcpy(id, sensor->id_string, 16); /* @@ -414,14 +433,10 @@ ipmi_sensor_print_compact(struct ipmi_intf * intf, val = rsp->data[0]; } - if (csv_output) - { + if (csv_output) { /* NOT IMPLEMENTED */ - } - else - { - if (!verbose) - { + } else { + if (!verbose) { /* output format * id value units status thresholds.... */ @@ -436,20 +451,22 @@ ipmi_sensor_print_compact(struct ipmi_intf * intf, "na", unitstr, "na"); } - printf("| %-10s| %-10s| %-10s| %-10s| %-10s| %-10s", + printf("| %-10s| %-10s| %-10s| %-10s| %-10s| %-10s", "na", "na", "na", "na", "na", "na"); printf("\n"); - } - else - { + } else { printf("Sensor ID : %s (0x%x)\n", id, sensor->keys.sensor_num); printf(" Entity ID : %d.%d\n", sensor->entity.id, sensor->entity.instance); - printf(" Sensor Type (Discrete): %s\n", - ipmi_sdr_get_sensor_type_desc(sensor->sensor.type)); - ipmi_sdr_print_discrete_state("States Asserted", sensor->sensor.type, - sensor->event_type, rsp->data[2], rsp->data[3]); + printf(" Sensor Type (Discrete): %s\n", + ipmi_sdr_get_sensor_type_desc(sensor->sensor. + type)); + ipmi_sdr_print_discrete_state("States Asserted", + sensor->sensor.type, + sensor->event_type, + rsp->data[2], + rsp->data[3]); printf("\n"); } } @@ -458,10 +475,10 @@ ipmi_sensor_print_compact(struct ipmi_intf * intf, } static int -ipmi_sensor_list(struct ipmi_intf * intf) +ipmi_sensor_list(struct ipmi_intf *intf) { - struct sdr_get_rs * header; - struct ipmi_sdr_iterator * itr; + struct sdr_get_rs *header; + struct ipmi_sdr_iterator *itr; int rc = 0; lprintf(LOG_DEBUG, "Querying SDR for sensor list"); @@ -472,30 +489,34 @@ ipmi_sensor_list(struct ipmi_intf * intf) return -1; } - while ((header = ipmi_sdr_get_next_header(intf, itr)) != NULL) - { + while ((header = ipmi_sdr_get_next_header(intf, itr)) != NULL) { int r = 0; - uint8_t * rec; + uint8_t *rec; rec = ipmi_sdr_get_record(intf, header, itr); - if (rec == NULL) + if (rec == NULL) { + lprintf(LOG_DEBUG, "rec == NULL"); continue; + } - switch(header->type) - { + switch (header->type) { case SDR_RECORD_TYPE_FULL_SENSOR: r = ipmi_sensor_print_full(intf, - (struct sdr_record_full_sensor *)rec); + (struct + sdr_record_full_sensor *) + rec); break; case SDR_RECORD_TYPE_COMPACT_SENSOR: r = ipmi_sensor_print_compact(intf, - (struct sdr_record_compact_sensor *)rec); + (struct + sdr_record_compact_sensor + *) rec); break; } free(rec); /* save any errors */ - rc = (r == 0) ? rc : r; + rc = (r == 0) ? rc : r; } ipmi_sdr_end(intf, itr); @@ -504,21 +525,20 @@ ipmi_sensor_list(struct ipmi_intf * intf) } static const struct valstr threshold_vals[] = { - { UPPER_NON_RECOV_SPECIFIED, "Upper Non-Recoverable" }, - { UPPER_CRIT_SPECIFIED, "Upper Critical" }, - { UPPER_NON_CRIT_SPECIFIED, "Upper Non-Critical" }, - { LOWER_NON_RECOV_SPECIFIED, "Lower Non-Recoverable" }, - { LOWER_CRIT_SPECIFIED, "Lower Critical" }, - { LOWER_NON_CRIT_SPECIFIED, "Lower Non-Critical" }, - { 0x00, NULL }, + {UPPER_NON_RECOV_SPECIFIED, "Upper Non-Recoverable"}, + {UPPER_CRIT_SPECIFIED, "Upper Critical"}, + {UPPER_NON_CRIT_SPECIFIED, "Upper Non-Critical"}, + {LOWER_NON_RECOV_SPECIFIED, "Lower Non-Recoverable"}, + {LOWER_CRIT_SPECIFIED, "Lower Critical"}, + {LOWER_NON_CRIT_SPECIFIED, "Lower Non-Critical"}, + {0x00, NULL}, }; - static int -__ipmi_sensor_set_threshold(struct ipmi_intf * intf, +__ipmi_sensor_set_threshold(struct ipmi_intf *intf, uint8_t num, uint8_t mask, uint8_t setting) { - struct ipmi_rs * rsp; + struct ipmi_rs *rsp; rsp = ipmi_sensor_set_sensor_thresholds(intf, num, mask, setting); @@ -535,36 +555,44 @@ __ipmi_sensor_set_threshold(struct ipmi_intf * intf, return 0; } - static int -ipmi_sensor_set_threshold(struct ipmi_intf * intf, int argc, char ** argv) +ipmi_sensor_set_threshold(struct ipmi_intf *intf, int argc, char **argv) { - char * id, * thresh; + char *id, *thresh; uint8_t settingMask = 0; double setting1 = 0.0, setting2 = 0.0, setting3 = 0.0; int allUpper = 0, allLower = 0; int ret = 0; - - struct sdr_record_list * sdr; - if (argc < 3 || strncmp(argv[0], "help", 4) == 0) - { + struct sdr_record_list *sdr; + + if (argc < 3 || strncmp(argv[0], "help", 4) == 0) { lprintf(LOG_NOTICE, "sensor thresh "); - lprintf(LOG_NOTICE, " id : name of the sensor for which threshold is to be set"); + lprintf(LOG_NOTICE, + " id : name of the sensor for which threshold is to be set"); lprintf(LOG_NOTICE, " threshold : which threshold to set"); - lprintf(LOG_NOTICE, " unr = upper non-recoverable"); + lprintf(LOG_NOTICE, + " unr = upper non-recoverable"); lprintf(LOG_NOTICE, " ucr = upper critical"); - lprintf(LOG_NOTICE, " unc = upper non-critical"); - lprintf(LOG_NOTICE, " lnc = lower non-critical"); + lprintf(LOG_NOTICE, + " unc = upper non-critical"); + lprintf(LOG_NOTICE, + " lnc = lower non-critical"); lprintf(LOG_NOTICE, " lcr = lower critical"); - lprintf(LOG_NOTICE, " lnr = lower non-recoverable"); - lprintf(LOG_NOTICE, " setting : the value to set the threshold to"); + lprintf(LOG_NOTICE, + " lnr = lower non-recoverable"); + lprintf(LOG_NOTICE, + " setting : the value to set the threshold to"); lprintf(LOG_NOTICE, ""); - lprintf(LOG_NOTICE, "sensor thresh lower "); - lprintf(LOG_NOTICE, " Set all lower thresholds at the same time"); + lprintf(LOG_NOTICE, + "sensor thresh lower "); + lprintf(LOG_NOTICE, + " Set all lower thresholds at the same time"); lprintf(LOG_NOTICE, ""); - lprintf(LOG_NOTICE, "sensor thresh upper "); - lprintf(LOG_NOTICE, " Set all upper thresholds at the same time"); + lprintf(LOG_NOTICE, + "sensor thresh upper "); + lprintf(LOG_NOTICE, + " Set all upper thresholds at the same time"); lprintf(LOG_NOTICE, ""); return 0; } @@ -574,26 +602,26 @@ ipmi_sensor_set_threshold(struct ipmi_intf * intf, int argc, char ** argv) if (strncmp(thresh, "upper", 5) == 0) { if (argc < 5) { - lprintf(LOG_ERR, "usage: sensor thresh upper "); + lprintf(LOG_ERR, + "usage: sensor thresh upper "); return -1; } allUpper = 1; - setting1 = (double)strtod(argv[2], NULL); - setting2 = (double)strtod(argv[3], NULL); - setting3 = (double)strtod(argv[4], NULL); - } - else if (strncmp(thresh, "lower", 5) == 0) { + setting1 = (double) strtod(argv[2], NULL); + setting2 = (double) strtod(argv[3], NULL); + setting3 = (double) strtod(argv[4], NULL); + } else if (strncmp(thresh, "lower", 5) == 0) { if (argc < 5) { - lprintf(LOG_ERR, "usage: sensor thresh lower "); + lprintf(LOG_ERR, + "usage: sensor thresh lower "); return -1; } allLower = 1; - setting1 = (double)strtod(argv[2], NULL); - setting2 = (double)strtod(argv[3], NULL); - setting3 = (double)strtod(argv[4], NULL); - } - else { - setting1 = (double)atof(argv[2]); + setting1 = (double) strtod(argv[2], NULL); + setting2 = (double) strtod(argv[3], NULL); + setting3 = (double) strtod(argv[4], NULL); + } else { + setting1 = (double) atof(argv[2]); if (strncmp(thresh, "unr", 3) == 0) settingMask = UPPER_NON_RECOV_SPECIFIED; else if (strncmp(thresh, "ucr", 3) == 0) @@ -607,7 +635,9 @@ ipmi_sensor_set_threshold(struct ipmi_intf * intf, int argc, char ** argv) else if (strncmp(thresh, "lnr", 3) == 0) settingMask = LOWER_NON_RECOV_SPECIFIED; else { - lprintf(LOG_ERR, "Valid threshold '%s' for sensor '%s' not specified!", thresh, id); + lprintf(LOG_ERR, + "Valid threshold '%s' for sensor '%s' not specified!", + thresh, id); return -1; } } @@ -632,67 +662,79 @@ ipmi_sensor_set_threshold(struct ipmi_intf * intf, int argc, char ** argv) sdr->record.full->id_string, val2str(settingMask, threshold_vals), setting1); ret = __ipmi_sensor_set_threshold(intf, - sdr->record.full->keys.sensor_num, settingMask, - sdr_convert_sensor_value_to_raw(sdr->record.full, setting1)); + sdr->record.full->keys. + sensor_num, settingMask, + sdr_convert_sensor_value_to_raw + (sdr->record.full, setting1)); settingMask = UPPER_CRIT_SPECIFIED; printf("Setting sensor \"%s\" %s threshold to %.3f\n", sdr->record.full->id_string, val2str(settingMask, threshold_vals), setting2); ret = __ipmi_sensor_set_threshold(intf, - sdr->record.full->keys.sensor_num, settingMask, - sdr_convert_sensor_value_to_raw(sdr->record.full, setting2)); + sdr->record.full->keys. + sensor_num, settingMask, + sdr_convert_sensor_value_to_raw + (sdr->record.full, setting2)); settingMask = UPPER_NON_RECOV_SPECIFIED; printf("Setting sensor \"%s\" %s threshold to %.3f\n", sdr->record.full->id_string, val2str(settingMask, threshold_vals), setting3); ret = __ipmi_sensor_set_threshold(intf, - sdr->record.full->keys.sensor_num, settingMask, - sdr_convert_sensor_value_to_raw(sdr->record.full, setting3)); - } - else if (allLower) { + sdr->record.full->keys. + sensor_num, settingMask, + sdr_convert_sensor_value_to_raw + (sdr->record.full, setting3)); + } else if (allLower) { settingMask = LOWER_NON_RECOV_SPECIFIED; printf("Setting sensor \"%s\" %s threshold to %.3f\n", sdr->record.full->id_string, val2str(settingMask, threshold_vals), setting1); ret = __ipmi_sensor_set_threshold(intf, - sdr->record.full->keys.sensor_num, settingMask, - sdr_convert_sensor_value_to_raw(sdr->record.full, setting1)); + sdr->record.full->keys. + sensor_num, settingMask, + sdr_convert_sensor_value_to_raw + (sdr->record.full, setting1)); settingMask = LOWER_CRIT_SPECIFIED; printf("Setting sensor \"%s\" %s threshold to %.3f\n", sdr->record.full->id_string, val2str(settingMask, threshold_vals), setting2); ret = __ipmi_sensor_set_threshold(intf, - sdr->record.full->keys.sensor_num, settingMask, - sdr_convert_sensor_value_to_raw(sdr->record.full, setting2)); + sdr->record.full->keys. + sensor_num, settingMask, + sdr_convert_sensor_value_to_raw + (sdr->record.full, setting2)); settingMask = LOWER_NON_CRIT_SPECIFIED; printf("Setting sensor \"%s\" %s threshold to %.3f\n", sdr->record.full->id_string, val2str(settingMask, threshold_vals), setting3); ret = __ipmi_sensor_set_threshold(intf, - sdr->record.full->keys.sensor_num, settingMask, - sdr_convert_sensor_value_to_raw(sdr->record.full, setting3)); - } - else { + sdr->record.full->keys. + sensor_num, settingMask, + sdr_convert_sensor_value_to_raw + (sdr->record.full, setting3)); + } else { printf("Setting sensor \"%s\" %s threshold to %.3f\n", sdr->record.full->id_string, val2str(settingMask, threshold_vals), setting1); ret = __ipmi_sensor_set_threshold(intf, - sdr->record.full->keys.sensor_num, settingMask, - sdr_convert_sensor_value_to_raw(sdr->record.full, setting1)); + sdr->record.full->keys. + sensor_num, settingMask, + sdr_convert_sensor_value_to_raw + (sdr->record.full, setting1)); } return ret; } static int -ipmi_sensor_get(struct ipmi_intf * intf, int argc, char ** argv) +ipmi_sensor_get(struct ipmi_intf *intf, int argc, char **argv) { - struct sdr_record_list * sdr; + struct sdr_record_list *sdr; int i, v; int rc = 0; @@ -704,7 +746,7 @@ ipmi_sensor_get(struct ipmi_intf * intf, int argc, char ** argv) printf("Locating sensor record...\n"); /* lookup by sensor name */ - for (i=0; irecord.full); break; case SDR_RECORD_TYPE_COMPACT_SENSOR: - r = ipmi_sensor_print_compact(intf, sdr->record.compact); + r = ipmi_sensor_print_compact(intf, + sdr->record.compact); break; case SDR_RECORD_TYPE_EVENTONLY_SENSOR: - r = ipmi_sdr_print_sensor_eventonly(intf, sdr->record.eventonly); + r = ipmi_sdr_print_sensor_eventonly(intf, + sdr->record. + eventonly); break; case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: - r = ipmi_sdr_print_sensor_fru_locator(intf, sdr->record.fruloc); + r = ipmi_sdr_print_sensor_fru_locator(intf, + sdr->record. + fruloc); break; case SDR_RECORD_TYPE_MC_DEVICE_LOCATOR: - r = ipmi_sdr_print_sensor_mc_locator(intf, sdr->record.mcloc); + r = ipmi_sdr_print_sensor_mc_locator(intf, + sdr->record.mcloc); break; } verbose = v; @@ -745,28 +793,22 @@ ipmi_sensor_get(struct ipmi_intf * intf, int argc, char ** argv) } int -ipmi_sensor_main(struct ipmi_intf * intf, int argc, char ** argv) +ipmi_sensor_main(struct ipmi_intf *intf, int argc, char **argv) { int rc = 0; if (argc == 0) { rc = ipmi_sensor_list(intf); - } - else if (strncmp(argv[0], "help", 4) == 0) { + } else if (strncmp(argv[0], "help", 4) == 0) { lprintf(LOG_NOTICE, "Sensor Commands: list thresh get"); - } - else if (strncmp(argv[0], "list", 4) == 0) { + } else if (strncmp(argv[0], "list", 4) == 0) { rc = ipmi_sensor_list(intf); - } - else if (strncmp(argv[0], "thresh", 5) == 0) { - rc = ipmi_sensor_set_threshold(intf, argc-1, &argv[1]); - } - else if (strncmp(argv[0], "get", 3) == 0) { - rc = ipmi_sensor_get(intf, argc-1, &argv[1]); - } - else { - lprintf(LOG_ERR, "Invalid sensor command: %s", - argv[0]); + } else if (strncmp(argv[0], "thresh", 5) == 0) { + rc = ipmi_sensor_set_threshold(intf, argc - 1, &argv[1]); + } else if (strncmp(argv[0], "get", 3) == 0) { + rc = ipmi_sensor_get(intf, argc - 1, &argv[1]); + } else { + lprintf(LOG_ERR, "Invalid sensor command: %s", argv[0]); rc = -1; }