diff options
Diffstat (limited to 'lib/ipmi_sdr.c')
| -rw-r--r-- | lib/ipmi_sdr.c | 4835 |
1 files changed, 4835 insertions, 0 deletions
diff --git a/lib/ipmi_sdr.c b/lib/ipmi_sdr.c new file mode 100644 index 0000000..fa7b082 --- /dev/null +++ b/lib/ipmi_sdr.c @@ -0,0 +1,4835 @@ +/* + * Copyright (c) 2012 Hewlett-Packard Development Company, L.P. + * + * Based on code from + * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * Redistribution of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * Redistribution in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * Neither the name of Sun Microsystems, Inc. or the names of + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * This software is provided "AS IS," without a warranty of any kind. + * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, + * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A + * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. + * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE + * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING + * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL + * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, + * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR + * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF + * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, + * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + */ + +#include <string.h> + +#include <math.h> +#include <stdio.h> +#include <unistd.h> +#include <sys/types.h> +#include <time.h> + +#include <ipmitool/ipmi.h> +#include <ipmitool/log.h> +#include <ipmitool/ipmi_mc.h> +#include <ipmitool/ipmi_sdr.h> +#include <ipmitool/ipmi_sdradd.h> +#include <ipmitool/ipmi_sensor.h> +#include <ipmitool/ipmi_intf.h> +#include <ipmitool/ipmi_sel.h> +#include <ipmitool/ipmi_entity.h> +#include <ipmitool/ipmi_constants.h> +#include <ipmitool/ipmi_strings.h> + +#if HAVE_CONFIG_H +# include <config.h> +#endif + +extern int verbose; +static int use_built_in; /* Uses DeviceSDRs instead of SDRR */ +static int sdr_max_read_len = 0; +static int sdr_extended = 0; +static long sdriana = 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; + +void printf_sdr_usage(); + +/* ipmi_sdr_get_unit_string - return units for base/modifier + * + * @pct: units are a percentage + * @type: unit type + * @base: base + * @modifier: modifier + * + * returns pointer to static string + */ +const char * +ipmi_sdr_get_unit_string(uint8_t pct, uint8_t type, uint8_t base, uint8_t modifier) +{ + static char unitstr[16]; + /* + * By default, if units are supposed to be percent, we will pre-pend + * the percent string to the textual representation of the units. + */ + char *pctstr = pct ? "% " : ""; + memset(unitstr, 0, sizeof (unitstr)); + switch (type) { + case 2: + snprintf(unitstr, sizeof (unitstr), "%s%s * %s", + pctstr, unit_desc[base], unit_desc[modifier]); + break; + case 1: + snprintf(unitstr, sizeof (unitstr), "%s%s/%s", + pctstr, unit_desc[base], unit_desc[modifier]); + break; + case 0: + default: + /* + * Display the text "percent" only when the Base unit is + * "unspecified" and the caller specified to print percent. + */ + if (base == 0 && pct) { + snprintf(unitstr, sizeof(unitstr), "percent"); + } else { + snprintf(unitstr, sizeof (unitstr), "%s%s", + pctstr, unit_desc[base]); + } + break; + } + return unitstr; +} + +/* sdr_sensor_has_analog_reading - Determine if sensor has an analog reading + * + */ +static int +sdr_sensor_has_analog_reading(struct ipmi_intf *intf, + struct sensor_reading *sr) +{ + /* Compact sensors can't return analog values so we false */ + if (!sr->full) { + return 0; + } + /* + * Per the IPMI Specification: + * Only Full Threshold sensors are identified as providing + * analog readings. + * + * But... HP didn't interpret this as meaning that "Only Threshold + * Sensors" can provide analog readings. So, HP packed analog + * readings into some of their non-Threshold Sensor. There is + * nothing that explictly prohibits this in the spec, so if + * an Analog reading is available in a Non-Threshod sensor and + * there are units specified for identifying the reading then + * we do an analog conversion even though the sensor is + * non-Threshold. To be safe, we provide this extension for + * HP. + * + */ + if ( UNITS_ARE_DISCRETE(&sr->full->cmn) ) { + return 0;/* Sensor specified as not having Analog Units */ + } + if ( !IS_THRESHOLD_SENSOR(&sr->full->cmn) ) { + /* Non-Threshold Sensors are not defined as having analog */ + /* But.. We have one with defined with Analog Units */ + if ( (sr->full->cmn.unit.pct | sr->full->cmn.unit.modifier | + sr->full->cmn.unit.type.base | + sr->full->cmn.unit.type.modifier)) { + /* And it does have the necessary units specs */ + if ( !(intf->manufacturer_id == IPMI_OEM_HP) ) { + /* But to be safe we only do this for HP */ + return 0; + } + } else { + return 0; + } + } + /* + * If sensor has linearization, then we should be able to update the + * reading factors and if we cannot fail the conversion. + */ + if (sr->full->linearization >= SDR_SENSOR_L_NONLINEAR && + sr->full->linearization <= 0x7F) { + if (ipmi_sensor_get_sensor_reading_factors(intf, sr->full, sr->s_reading) < 0){ + sr->s_reading_valid = 0; + return 0; + } + } + + return 1; +} + +/* sdr_convert_sensor_reading - convert raw sensor reading + * + * @sensor: sensor record + * @val: raw sensor reading + * + * returns floating-point sensor reading + */ +double +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); + k1 = __TO_B_EXP(sensor->bacc); + k2 = __TO_R_EXP(sensor->bacc); + + switch (sensor->cmn.unit.analog) { + case 0: + result = (double) (((m * val) + + (b * pow(10, k1))) * pow(10, k2)); + break; + case 1: + 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)); + break; + default: + /* Oops! This isn't an analog sensor. */ + return 0.0; + } + + switch (sensor->linearization & 0x7f) { + case SDR_SENSOR_L_LN: + result = log(result); + break; + case SDR_SENSOR_L_LOG10: + result = log10(result); + break; + case SDR_SENSOR_L_LOG2: + result = (double) (log(result) / log(2.0)); + break; + case SDR_SENSOR_L_E: + result = exp(result); + break; + case SDR_SENSOR_L_EXP10: + result = pow(10.0, result); + break; + case SDR_SENSOR_L_EXP2: + result = pow(2.0, result); + break; + case SDR_SENSOR_L_1_X: + result = pow(result, -1.0); /*1/x w/o exception */ + break; + case SDR_SENSOR_L_SQR: + result = pow(result, 2.0); + break; + case SDR_SENSOR_L_CUBE: + result = pow(result, 3.0); + break; + case SDR_SENSOR_L_SQRT: + result = sqrt(result); + break; + case SDR_SENSOR_L_CUBERT: + result = cbrt(result); + break; + case SDR_SENSOR_L_LINEAR: + default: + break; + } + return result; +} +/* sdr_convert_sensor_hysterisis - convert raw sensor hysterisis + * + * Even though spec says histerisis should be computed using Mx+B + * formula, B is irrelevant when doing raw comparison + * + * threshold rearm point is computed using threshold +/- hysterisis + * with the full formula however B can't be applied in raw comparisons + * + * @sensor: sensor record + * @val: raw sensor reading + * + * returns floating-point sensor reading + */ +double +sdr_convert_sensor_hysterisis(struct sdr_record_full_sensor *sensor, uint8_t val) +{ + int m, k2; + double result; + + m = __TO_M(sensor->mtol); + + k2 = __TO_R_EXP(sensor->bacc); + + switch (sensor->cmn.unit.analog) { + case 0: + result = (double) (((m * val)) * pow(10, k2)); + break; + case 1: + if (val & 0x80) + val++; + /* Deliberately fall through to case 2. */ + case 2: + result = (double) (((m * (int8_t) val) ) * pow(10, k2)); + break; + default: + /* Oops! This isn't an analog sensor. */ + return 0.0; + } + + switch (sensor->linearization & 0x7f) { + case SDR_SENSOR_L_LN: + result = log(result); + break; + case SDR_SENSOR_L_LOG10: + result = log10(result); + break; + case SDR_SENSOR_L_LOG2: + result = (double) (log(result) / log(2.0)); + break; + case SDR_SENSOR_L_E: + result = exp(result); + break; + case SDR_SENSOR_L_EXP10: + result = pow(10.0, result); + break; + case SDR_SENSOR_L_EXP2: + result = pow(2.0, result); + break; + case SDR_SENSOR_L_1_X: + result = pow(result, -1.0); /*1/x w/o exception */ + break; + case SDR_SENSOR_L_SQR: + result = pow(result, 2.0); + break; + case SDR_SENSOR_L_CUBE: + result = pow(result, 3.0); + break; + case SDR_SENSOR_L_SQRT: + result = sqrt(result); + break; + case SDR_SENSOR_L_CUBERT: + result = cbrt(result); + break; + case SDR_SENSOR_L_LINEAR: + default: + break; + } + return result; +} + + +/* sdr_convert_sensor_tolerance - convert raw sensor reading + * + * @sensor: sensor record + * @val: raw sensor reading + * + * returns floating-point sensor tolerance(interpreted) + */ +double +sdr_convert_sensor_tolerance(struct sdr_record_full_sensor *sensor, uint8_t val) +{ + int m, k2; + double result; + + m = __TO_M(sensor->mtol); + k2 = __TO_R_EXP(sensor->bacc); + + switch (sensor->cmn.unit.analog) { + case 0: + /* as suggested in section 30.4.1 of IPMI 1.5 spec */ + result = (double) ((((m * (double)val/2)) ) * pow(10, k2)); + break; + case 1: + if (val & 0x80) + val++; + /* Deliberately fall through to case 2. */ + case 2: + result = (double) (((m * ((double)((int8_t) val)/2))) * pow(10, k2)); + break; + default: + /* Oops! This isn't an analog sensor. */ + return 0.0; + } + + switch (sensor->linearization & 0x7f) { + case SDR_SENSOR_L_LN: + result = log(result); + break; + case SDR_SENSOR_L_LOG10: + result = log10(result); + break; + case SDR_SENSOR_L_LOG2: + result = (double) (log(result) / log(2.0)); + break; + case SDR_SENSOR_L_E: + result = exp(result); + break; + case SDR_SENSOR_L_EXP10: + result = pow(10.0, result); + break; + case SDR_SENSOR_L_EXP2: + result = pow(2.0, result); + break; + case SDR_SENSOR_L_1_X: + result = pow(result, -1.0); /*1/x w/o exception */ + break; + case SDR_SENSOR_L_SQR: + result = pow(result, 2.0); + break; + case SDR_SENSOR_L_CUBE: + result = pow(result, 3.0); + break; + case SDR_SENSOR_L_SQRT: + result = sqrt(result); + break; + case SDR_SENSOR_L_CUBERT: + result = cbrt(result); + break; + case SDR_SENSOR_L_LINEAR: + default: + break; + } + return result; +} + +/* sdr_convert_sensor_value_to_raw - convert sensor reading back to raw + * + * @sensor: sensor record + * @val: converted sensor reading + * + * returns raw sensor reading + */ +uint8_t +sdr_convert_sensor_value_to_raw(struct sdr_record_full_sensor * sensor, + double val) +{ + int m, b, k1, k2; + double result; + + /* only works for analog sensors */ + if (UNITS_ARE_DISCRETE((&sensor->cmn))) + return 0; + + m = __TO_M(sensor->mtol); + b = __TO_B(sensor->bacc); + k1 = __TO_B_EXP(sensor->bacc); + k2 = __TO_R_EXP(sensor->bacc); + + /* don't divide by zero */ + if (m == 0) + return 0; + + 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; +} + +/* ipmi_sdr_get_sensor_thresholds - return thresholds for sensor + * + * @intf: ipmi interface + * @sensor: sensor number + * @target: sensor owner ID + * @lun: sensor lun + * @channel: channel number + * + * returns pointer to ipmi response + */ +struct ipmi_rs * +ipmi_sdr_get_sensor_thresholds(struct ipmi_intf *intf, uint8_t sensor, + uint8_t target, uint8_t lun, uint8_t channel) +{ + struct ipmi_rq req; + struct ipmi_rs *rsp; + uint8_t bridged_request = 0; + uint32_t save_addr; + uint32_t save_channel; + + if ( BRIDGE_TO_SENSOR(intf, target, channel) ) { + bridged_request = 1; + save_addr = intf->target_addr; + intf->target_addr = target; + save_channel = intf->target_channel; + intf->target_channel = channel; + } + + memset(&req, 0, sizeof (req)); + req.msg.netfn = IPMI_NETFN_SE; + req.msg.lun = lun; + req.msg.cmd = GET_SENSOR_THRESHOLDS; + req.msg.data = &sensor; + req.msg.data_len = sizeof (sensor); + + rsp = intf->sendrecv(intf, &req); + if (bridged_request) { + intf->target_addr = save_addr; + intf->target_channel = save_channel; + } + return rsp; +} + +/* ipmi_sdr_get_sensor_hysteresis - return hysteresis for sensor + * + * @intf: ipmi interface + * @sensor: sensor number + * @target: sensor owner ID + * @lun: sensor lun + * @channel: channel number + * + * returns pointer to ipmi response + */ +struct ipmi_rs * +ipmi_sdr_get_sensor_hysteresis(struct ipmi_intf *intf, uint8_t sensor, + uint8_t target, uint8_t lun, uint8_t channel) +{ + struct ipmi_rq req; + uint8_t rqdata[2]; + struct ipmi_rs *rsp; + uint8_t bridged_request = 0; + uint32_t save_addr; + uint32_t save_channel; + + if ( BRIDGE_TO_SENSOR(intf, target, channel) ) { + bridged_request = 1; + save_addr = intf->target_addr; + intf->target_addr = target; + save_channel = intf->target_channel; + intf->target_channel = channel; + } + + rqdata[0] = sensor; + rqdata[1] = 0xff; /* reserved */ + + memset(&req, 0, sizeof (req)); + req.msg.netfn = IPMI_NETFN_SE; + req.msg.lun = lun; + req.msg.cmd = GET_SENSOR_HYSTERESIS; + req.msg.data = rqdata; + req.msg.data_len = 2; + + rsp = intf->sendrecv(intf, &req); + if (bridged_request) { + intf->target_addr = save_addr; + intf->target_channel = save_channel; + } + return rsp; +} + +/* ipmi_sdr_get_sensor_reading - retrieve a raw sensor reading + * + * @intf: ipmi interface + * @sensor: sensor id + * + * returns ipmi response structure + */ +struct ipmi_rs * +ipmi_sdr_get_sensor_reading(struct ipmi_intf *intf, uint8_t sensor) +{ + struct ipmi_rq req; + + memset(&req, 0, sizeof (req)); + req.msg.netfn = IPMI_NETFN_SE; + req.msg.cmd = GET_SENSOR_READING; + req.msg.data = &sensor; + req.msg.data_len = 1; + + return intf->sendrecv(intf, &req); +} + + +/* ipmi_sdr_get_sensor_reading_ipmb - retrieve a raw sensor reading from ipmb + * + * @intf: ipmi interface + * @sensor: sensor id + * @target: IPMB target address + * @lun: sensor lun + * @channel: channel number + * + * returns ipmi response structure + */ +struct ipmi_rs * +ipmi_sdr_get_sensor_reading_ipmb(struct ipmi_intf *intf, uint8_t sensor, + uint8_t target, uint8_t lun, uint8_t channel) +{ + struct ipmi_rq req; + struct ipmi_rs *rsp; + uint8_t bridged_request = 0; + uint32_t save_addr; + uint32_t save_channel; + + if ( BRIDGE_TO_SENSOR(intf, target, channel) ) { + lprintf(LOG_DEBUG, + "Bridge to Sensor " + "Intf my/%#x tgt/%#x:%#x Sdr tgt/%#x:%#x\n", + intf->my_addr, intf->target_addr, intf->target_channel, + target, channel); + bridged_request = 1; + save_addr = intf->target_addr; + intf->target_addr = target; + save_channel = intf->target_channel; + intf->target_channel = channel; + } + memset(&req, 0, sizeof (req)); + req.msg.netfn = IPMI_NETFN_SE; + req.msg.lun = lun; + req.msg.cmd = GET_SENSOR_READING; + req.msg.data = &sensor; + req.msg.data_len = 1; + + rsp = intf->sendrecv(intf, &req); + if (bridged_request) { + intf->target_addr = save_addr; + intf->target_channel = save_channel; + } + return rsp; +} + +/* ipmi_sdr_get_sensor_event_status - retrieve sensor event status + * + * @intf: ipmi interface + * @sensor: sensor id + * @target: sensor owner ID + * @lun: sensor lun + * @channel: channel number + * + * returns ipmi response structure + */ +struct ipmi_rs * +ipmi_sdr_get_sensor_event_status(struct ipmi_intf *intf, uint8_t sensor, + uint8_t target, uint8_t lun, uint8_t channel) +{ + struct ipmi_rq req; + struct ipmi_rs *rsp; + uint8_t bridged_request = 0; + uint32_t save_addr; + uint32_t save_channel; + + if ( BRIDGE_TO_SENSOR(intf, target, channel) ) { + bridged_request = 1; + save_addr = intf->target_addr; + intf->target_addr = target; + save_channel = intf->target_channel; + intf->target_channel = channel; + } + memset(&req, 0, sizeof (req)); + req.msg.netfn = IPMI_NETFN_SE; + req.msg.lun = lun; + req.msg.cmd = GET_SENSOR_EVENT_STATUS; + req.msg.data = &sensor; + req.msg.data_len = 1; + + rsp = intf->sendrecv(intf, &req); + if (bridged_request) { + intf->target_addr = save_addr; + intf->target_channel = save_channel; + } + return rsp; +} + +/* ipmi_sdr_get_sensor_event_enable - retrieve sensor event enables + * + * @intf: ipmi interface + * @sensor: sensor id + * @target: sensor owner ID + * @lun: sensor lun + * @channel: channel number + * + * returns ipmi response structure + */ +struct ipmi_rs * +ipmi_sdr_get_sensor_event_enable(struct ipmi_intf *intf, uint8_t sensor, + uint8_t target, uint8_t lun, uint8_t channel) +{ + struct ipmi_rq req; + struct ipmi_rs *rsp; + uint8_t bridged_request = 0; + uint32_t save_addr; + uint32_t save_channel; + + if ( BRIDGE_TO_SENSOR(intf, target, channel) ) { + bridged_request = 1; + save_addr = intf->target_addr; + intf->target_addr = target; + save_channel = intf->target_channel; + intf->target_channel = channel; + } + + memset(&req, 0, sizeof (req)); + req.msg.netfn = IPMI_NETFN_SE; + req.msg.lun = lun; + req.msg.cmd = GET_SENSOR_EVENT_ENABLE; + req.msg.data = &sensor; + req.msg.data_len = 1; + + rsp = intf->sendrecv(intf, &req); + if (bridged_request) { + intf->target_addr = save_addr; + intf->target_channel = save_channel; + } + return rsp; +} + +/* ipmi_sdr_get_sensor_type_desc - Get sensor type descriptor + * + * @type: ipmi sensor type + * + * returns + * string from sensor_type_desc + * or "reserved" + * or "OEM reserved" + */ +const char * +ipmi_sdr_get_sensor_type_desc(const uint8_t type) +{ + static char desc[32]; + memset(desc, 0, 32); + if (type <= SENSOR_TYPE_MAX) + return sensor_type_desc[type]; + if (type < 0xc0) + snprintf(desc, 32, "reserved #%02x", type); + else + { + snprintf(desc, 32, oemval2str(sdriana,type,ipmi_oem_sdr_type_vals), + type); + } + return desc; +} + +/* ipmi_sdr_get_thresh_status - threshold status indicator + * + * @rsp: response from Get Sensor Reading comand + * @validread: validity of the status field argument + * @invalidstr: string to return if status field is not valid + * + * returns + * cr = critical + * nc = non-critical + * nr = non-recoverable + * ok = ok + * ns = not specified + */ +const char * +ipmi_sdr_get_thresh_status(struct sensor_reading *sr, const char *invalidstr) +{ + uint8_t stat; + if (!sr->s_reading_valid) { + return invalidstr; + } + stat = sr->s_data2; + if (stat & SDR_SENSOR_STAT_LO_NR) { + if (verbose) + return "Lower Non-Recoverable"; + else if (sdr_extended) + return "lnr"; + else + return "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) { + if (verbose) + return "Lower Critical"; + else if (sdr_extended) + return "lcr"; + else + return "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) { + if (verbose) + return "Lower Non-Critical"; + else if (sdr_extended) + return "lnc"; + else + return "nc"; + } else if (stat & SDR_SENSOR_STAT_HI_NC) { + if (verbose) + return "Upper Non-Critical"; + else if (sdr_extended) + return "unc"; + else + return "nc"; + } + return "ok"; +} + +/* ipmi_sdr_get_header - retreive SDR record header + * + * @intf: ipmi interface + * @itr: sdr iterator + * + * returns pointer to static sensor retrieval struct + * returns NULL on error + */ +static struct sdr_get_rs * +ipmi_sdr_get_header(struct ipmi_intf *intf, struct ipmi_sdr_iterator *itr) +{ + struct ipmi_rq req; + 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)); + 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)); + if (itr->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++) { + sdr_rq.reserve_id = itr->reservation; + rsp = intf->sendrecv(intf, &req); + if (rsp == NULL) { + lprintf(LOG_ERR, "Get SDR %04x command failed", + itr->next); + continue; + } else if (rsp->ccode == 0xc5) { + /* lost reservation */ + lprintf(LOG_DEBUG, "SDR reservation %04x cancelled. " + "Sleeping a bit and retrying...", + itr->reservation); + + sleep(rand() & 3); + + if (ipmi_sdr_get_reservation(intf, itr->use_built_in, + &(itr->reservation)) < 0) { + lprintf(LOG_ERR, + "Unable to renew SDR reservation"); + return NULL; + } + } else if (rsp->ccode > 0) { + lprintf(LOG_ERR, "Get SDR %04x command failed: %s", + itr->next, val2str(rsp->ccode, + completion_code_vals)); + continue; + } else { + break; + } + } + + if (try == 5) + return NULL; + + if (!rsp) + return NULL; + + lprintf(LOG_DEBUG, "SDR record ID : 0x%04x", itr->next); + + memcpy(&sdr_rs, rsp->data, sizeof (sdr_rs)); + + if (sdr_rs.length == 0) { + lprintf(LOG_ERR, "SDR record id 0x%04x: invalid length %d", + itr->next, sdr_rs.length); + return NULL; + } + + /* achu (chu11 at llnl dot gov): - Some boards are stupid and + * return a record id from the Get SDR Record command + * different than the record id passed in. If we find this + * situation, we cheat and put the original record id back in. + * Otherwise, a later Get SDR Record command will fail with + * completion code CBh = "Requested Sensor, data, or record + * not present" + */ + if (sdr_rs.id != itr->next) { + lprintf(LOG_DEBUG, "SDR record id mismatch: 0x%04x", sdr_rs.id); + sdr_rs.id = itr->next; + } + + lprintf(LOG_DEBUG, "SDR record type : 0x%02x", sdr_rs.type); + lprintf(LOG_DEBUG, "SDR record next : 0x%04x", sdr_rs.next); + lprintf(LOG_DEBUG, "SDR record bytes: %d", sdr_rs.length); + + return &sdr_rs; +} + +/* ipmi_sdr_get_next_header - retreive next SDR header + * + * @intf: ipmi interface + * @itr: sdr iterator + * + * returns pointer to sensor retrieval struct + * returns NULL on error + */ +struct sdr_get_rs * +ipmi_sdr_get_next_header(struct ipmi_intf *intf, struct ipmi_sdr_iterator *itr) +{ + struct sdr_get_rs *header; + + if (itr->next == 0xffff) + return NULL; + + header = ipmi_sdr_get_header(intf, itr); + if (header == NULL) + return NULL; + + itr->next = header->next; + + return header; +} + +/* + * This macro is used to print nominal, normal and threshold settings, + * but it is not compatible with PRINT_NORMAL/PRINT_THRESH since it does + * not have the sensor.init.thresholds setting qualifier as is done in + * PRINT_THRESH. This means CSV output can be different than non CSV + * output if sensor.init.thresholds is ever zero + */ +/* helper macro for printing CSV output for Full SDR Threshold reading */ +#define SENSOR_PRINT_CSV(FULLSENS, FLAG, READ) \ + if ((FLAG)) { \ + if (UNITS_ARE_DISCRETE((&FULLSENS->cmn))) \ + printf("0x%02X,", READ); \ + else \ + printf("%.3f,", sdr_convert_sensor_reading( \ + (FULLSENS), READ)); \ + } else { \ + printf(","); \ + } + +/* helper macro for printing analog values for Full SDR Threshold readings */ +#define SENSOR_PRINT_NORMAL(FULLSENS, NAME, READ) \ + if ((FULLSENS)->analog_flag.READ != 0) { \ + printf(" %-21s : ", NAME); \ + if (UNITS_ARE_DISCRETE((&FULLSENS->cmn))) \ + printf("0x%02X\n", \ + (FULLSENS)->READ); \ + else \ + printf("%.3f\n", sdr_convert_sensor_reading( \ + (FULLSENS), (FULLSENS)->READ));\ + } + +/* helper macro for printing Full SDR sensor Thresholds */ +#define SENSOR_PRINT_THRESH(FULLSENS, NAME, READ, FLAG) \ + if ((FULLSENS)->cmn.sensor.init.thresholds && \ + (FULLSENS)->cmn.mask.type.threshold.read.FLAG != 0) { \ + printf(" %-21s : ", NAME); \ + if (UNITS_ARE_DISCRETE((&FULLSENS->cmn))) \ + printf("0x%02X\n", \ + (FULLSENS)->threshold.READ); \ + else \ + printf("%.3f\n", sdr_convert_sensor_reading( \ + (FULLSENS), (FULLSENS)->threshold.READ)); \ + } + +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, + uint8_t target, uint8_t lun, uint8_t channel) +{ + 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}, + }; + const struct valstr assert_cond_2[] = { + {0x08, "unr+"}, + {0x04, "unr-"}, + {0x02, "ucr+"}, + {0x01, "ucr-"}, + {0x00, NULL}, + }; + + rsp = ipmi_sdr_get_sensor_event_status(intf, sensor_num, + target, lun, channel); + + if (rsp == NULL) { + 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", + sensor_num, val2str(rsp->ccode, completion_code_vals)); + return -1; + } + /* There is an assumption here that data_len >= 1 */ + if (IS_READING_UNAVAILABLE(rsp->data[0])) { + printf(" Event Status : Unavailable\n"); + return 0; + } + if (IS_SCANNING_DISABLED(rsp->data[0])) { + //printf(" Event Status : Scanning Disabled\n"); + //return 0; + } + if (IS_EVENT_MSG_DISABLED(rsp->data[0])) { + printf(" Event Status : Event Messages Disabled\n"); + //return 0; + } + + 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]); + } + 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]); + } + break; + + case ANALOG_SENSOR: + printf(" Assertion Events : "); + for (i = 0; i < 8; i++) { + if (rsp->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 << 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))) { + printf(" Deassertion Events : "); + for (i = 0; i < 8; i++) { + if (rsp->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 << i)) + printf("%s ", + val2str(1 << i, + assert_cond_2)); + } + } + printf("\n"); + } + } else { + printf("\n"); + } + break; + + default: + break; + } + + return 0; +} + +static int +ipmi_sdr_print_sensor_mask(struct sdr_record_mask *mask, + uint8_t sensor_type, + uint8_t event_type, int numeric_fmt) +{ + /* iceblink - don't print some event status fields - CVS rev1.53 */ + return 0; + + 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); + break; + + case ANALOG_SENSOR: + printf(" Assert Event Mask : "); + if (mask->type.threshold.assert_lnr_high) + printf("lnr+ "); + if (mask->type.threshold.assert_lnr_low) + printf("lnr- "); + if (mask->type.threshold.assert_lcr_high) + printf("lcr+ "); + if (mask->type.threshold.assert_lcr_low) + printf("lcr- "); + if (mask->type.threshold.assert_lnc_high) + printf("lnc+ "); + if (mask->type.threshold.assert_lnc_low) + printf("lnc- "); + if (mask->type.threshold.assert_unc_high) + printf("unc+ "); + if (mask->type.threshold.assert_unc_low) + printf("unc- "); + if (mask->type.threshold.assert_ucr_high) + printf("ucr+ "); + if (mask->type.threshold.assert_ucr_low) + printf("ucr- "); + if (mask->type.threshold.assert_unr_high) + printf("unr+ "); + if (mask->type.threshold.assert_unr_low) + printf("unr- "); + printf("\n"); + + printf(" Deassert Event Mask : "); + if (mask->type.threshold.deassert_lnr_high) + printf("lnr+ "); + if (mask->type.threshold.deassert_lnr_low) + printf("lnr- "); + if (mask->type.threshold.deassert_lcr_high) + printf("lcr+ "); + if (mask->type.threshold.deassert_lcr_low) + printf("lcr- "); + if (mask->type.threshold.deassert_lnc_high) + printf("lnc+ "); + if (mask->type.threshold.deassert_lnc_low) + printf("lnc- "); + if (mask->type.threshold.deassert_unc_high) + printf("unc+ "); + if (mask->type.threshold.deassert_unc_low) + printf("unc- "); + if (mask->type.threshold.deassert_ucr_high) + printf("ucr+ "); + if (mask->type.threshold.deassert_ucr_low) + printf("ucr- "); + if (mask->type.threshold.deassert_unr_high) + printf("unr+ "); + if (mask->type.threshold.deassert_unr_low) + printf("unr- "); + printf("\n"); + break; + + default: + break; + } + + return 0; +} + +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, + uint8_t target, uint8_t lun, uint8_t channel) +{ + 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}, + }; + const struct valstr assert_cond_2[] = { + {0x08, "unr+"}, + {0x04, "unr-"}, + {0x02, "ucr+"}, + {0x01, "ucr-"}, + {0x00, NULL}, + }; + + rsp = ipmi_sdr_get_sensor_event_enable(intf, sensor_num, + target, lun, channel); + + if (rsp == NULL) { + 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", + sensor_num, val2str(rsp->ccode, completion_code_vals)); + return -1; + } + + if (IS_SCANNING_DISABLED(rsp->data[0])) { + //printf(" Event Enable : Scanning Disabled\n"); + //return 0; + } + if (IS_EVENT_MSG_DISABLED(rsp->data[0])) { + printf(" Event Enable : Event Messages Disabled\n"); + //return 0; + } + + 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]); + } + 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]); + } + break; + + case ANALOG_SENSOR: + /* analog */ + printf(" Assertions Enabled : "); + for (i = 0; i < 8; i++) { + if (rsp->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 << 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))) { + printf(" Deassertions Enabled : "); + for (i = 0; i < 8; i++) { + if (rsp->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 << i)) + printf("%s ", + val2str(1 << i, + assert_cond_2)); + } + } + printf("\n"); + } + } else { + printf("\n"); + } + break; + + default: + break; + } + + return 0; +} + +/* ipmi_sdr_print_sensor_hysteresis - print hysteresis for Discrete & Analog + * + * @sensor: Common Sensor Record SDR pointer + * @full: Full Sensor Record SDR pointer (if applicable) + * @hysteresis_value: Actual hysteresis value + * @hvstr: hysteresis value Identifier String + * + * returns void + */ +void +ipmi_sdr_print_sensor_hysteresis(struct sdr_record_common_sensor *sensor, + struct sdr_record_full_sensor *full, + uint8_t hysteresis_value, + const char *hvstr) +{ + /* + * compact can have pos/neg hysteresis, but they cannot be analog! + * We use not full in addition to our discrete units check just in + * case a compact sensor is incorrectly identified as analog. + */ + if (!full || UNITS_ARE_DISCRETE(sensor)) { + if ( hysteresis_value == 0x00 || hysteresis_value == 0xff ) { + printf(" %s : Unspecified\n", hvstr); + } else { + printf(" %s : 0x%02X\n", hvstr, hysteresis_value); + } + return; + } + /* A Full analog sensor */ + double creading = sdr_convert_sensor_hysterisis(full, hysteresis_value); + if ( hysteresis_value == 0x00 || hysteresis_value == 0xff || + creading == 0.0 ) { + printf(" %s : Unspecified\n", hvstr); + } else { + printf(" %s : %.3f\n", hvstr, creading); + } +} + +/* print_sensor_min_max - print Discrete & Analog Minimum/Maximum Sensor Range + * + * @full: Full Sensor Record SDR pointer + * + * returns void + */ +static void +print_sensor_min_max(struct sdr_record_full_sensor *full) +{ + if (!full) { /* No min/max for compact SDR record */ + return; + } + + double creading = 0.0; + uint8_t is_analog = !UNITS_ARE_DISCRETE(&full->cmn); + if (is_analog) + creading = sdr_convert_sensor_reading(full, full->sensor_min); + if ((full->cmn.unit.analog == 0 && full->sensor_min == 0x00) || + (full->cmn.unit.analog == 1 && full->sensor_min == 0xff) || + (full->cmn.unit.analog == 2 && full->sensor_min == 0x80) || + (is_analog && (creading == 0.0))) + printf(" Minimum sensor range : Unspecified\n"); + else { + if (is_analog) + printf(" Minimum sensor range : %.3f\n", creading); + else + printf(" Minimum sensor range : 0x%02X\n", full->sensor_min); + + } + if (is_analog) + creading = sdr_convert_sensor_reading(full, full->sensor_max); + if ((full->cmn.unit.analog == 0 && full->sensor_max == 0xff) || + (full->cmn.unit.analog == 1 && full->sensor_max == 0x00) || + (full->cmn.unit.analog == 2 && full->sensor_max == 0x7f) || + (is_analog && (creading == 0.0))) + printf(" Maximum sensor range : Unspecified\n"); + else { + if (is_analog) + printf(" Maximum sensor range : %.3f\n", creading); + else + printf(" Maximum sensor range : 0x%02X\n", full->sensor_max); + } +} + +/* print_csv_discrete - print csv formatted discrete sensor + * + * @sensor: common sensor structure + * @sr: sensor reading + * + * returns void + */ +static void +print_csv_discrete(struct sdr_record_common_sensor *sensor, + const struct sensor_reading *sr) +{ + if (!sr->s_reading_valid || sr->s_reading_unavailable) { + printf("%02Xh,ns,%d.%d,No Reading", + sensor->keys.sensor_num, + sensor->entity.id, + sensor->entity.instance); + return; + } + + if (sr->s_has_analog_value) { /* Sensor has an analog value */ + printf("%s,%s,", sr->s_a_str, sr->s_a_units); + } else { /* Sensor has a discrete value */ + printf("%02Xh,", sensor->keys.sensor_num); + } + printf("ok,%d.%d,", + sensor->entity.id, + sensor->entity.instance); + ipmi_sdr_print_discrete_state_mini(NULL, ", ", + sensor->sensor.type, + sensor->event_type, + sr->s_data2, + sr->s_data3); +} + +/* ipmi_sdr_read_sensor_value - read sensor value + * + * @intf Interface pointer + * @sensor Common sensor component pointer + * @sdr_record_type Type of sdr sensor record + * @precision decimal precision for analog format conversion + * + * returns a pointer to sensor value reading data structure + */ +struct sensor_reading * +ipmi_sdr_read_sensor_value(struct ipmi_intf *intf, + struct sdr_record_common_sensor *sensor, + uint8_t sdr_record_type, int precision) +{ + static struct sensor_reading sr; + + if (sensor == NULL) + return NULL; + + /* Initialize to reading valid value of zero */ + memset(&sr, 0, sizeof(sr)); + + switch (sdr_record_type) { + int idlen; + case (SDR_RECORD_TYPE_FULL_SENSOR): + sr.full = (struct sdr_record_full_sensor *)sensor; + idlen = sr.full->id_code & 0x1f; + idlen = idlen < sizeof(sr.s_id) ? + idlen : sizeof(sr.s_id) - 1; + memcpy(sr.s_id, sr.full->id_string, idlen); + break; + case SDR_RECORD_TYPE_COMPACT_SENSOR: + sr.compact = (struct sdr_record_compact_sensor *)sensor; + idlen = sr.compact->id_code & 0x1f; + idlen = idlen < sizeof(sr.s_id) ? + idlen : sizeof(sr.s_id) - 1; + memcpy(sr.s_id, sr.compact->id_string, idlen); + break; + default: + return NULL; + } + + /* + * Get current reading via IPMI interface + */ + struct ipmi_rs *rsp; + rsp = ipmi_sdr_get_sensor_reading_ipmb(intf, + sensor->keys.sensor_num, + sensor->keys.owner_id, + sensor->keys.lun, + sensor->keys.channel); + sr.s_a_val = 0.0; /* init analog value to a floating point 0 */ + sr.s_a_str[0] = '\0'; /* no converted analog value string */ + sr.s_a_units = ""; /* no converted analog units units */ + + + if (rsp == NULL) { + lprintf(LOG_DEBUG, "Error reading sensor %s (#%02x)", + sr.s_id, sensor->keys.sensor_num); + return &sr; + } + + if (rsp->ccode) { + if ( !((sr.full && rsp->ccode == 0xcb) || + (sr.compact && rsp->ccode == 0xcd)) ) { + lprintf(LOG_DEBUG, + "Error reading sensor %s (#%02x): %s", sr.s_id, + sensor->keys.sensor_num, + val2str(rsp->ccode, completion_code_vals)); + } + return &sr; + } + + if (rsp->data_len < 2) { + /* + * We must be returned both a value (data[0]), and the validity + * of the value (data[1]), in order to correctly interpret + * the reading. If we don't have both of these we can't have + * a valid sensor reading. + */ + lprintf(LOG_DEBUG, "Error reading sensor %s invalid len %d", + sr.s_id, rsp->data_len); + return &sr; + } + + + if (IS_READING_UNAVAILABLE(rsp->data[1])) + sr.s_reading_unavailable = 1; + + if (IS_SCANNING_DISABLED(rsp->data[1])) { + sr.s_scanning_disabled = 1; + lprintf(LOG_DEBUG, "Sensor %s (#%02x) scanning disabled", + sr.s_id, sensor->keys.sensor_num); + return &sr; + } + if ( !sr.s_reading_unavailable ) { + sr.s_reading_valid = 1; + sr.s_reading = rsp->data[0]; + } + if (rsp->data_len > 2) + sr.s_data2 = rsp->data[2]; + if (rsp->data_len > 3) + sr.s_data3 = rsp->data[3]; + if (sdr_sensor_has_analog_reading(intf, &sr)) { + sr.s_has_analog_value = 1; + if (sr.s_reading_valid) { + sr.s_a_val = sdr_convert_sensor_reading(sr.full, sr.s_reading); + } + /* determine units string with possible modifiers */ + sr.s_a_units = ipmi_sdr_get_unit_string(sr.full->cmn.unit.pct, + sr.full->cmn.unit.modifier, + sr.full->cmn.unit.type.base, + sr.full->cmn.unit.type.modifier); + snprintf(sr.s_a_str, sizeof(sr.s_a_str), "%.*f", + (sr.s_a_val == (int) sr.s_a_val) ? 0 : + precision, sr.s_a_val); + } + return &sr; +} + +/* ipmi_sdr_print_sensor_fc - print full & compact SDR records + * + * @intf: ipmi interface + * @sensor: common sensor structure + * @sdr_record_type: type of sdr record, either full or compact + * + * returns 0 on success + * returns -1 on error + */ +int +ipmi_sdr_print_sensor_fc(struct ipmi_intf *intf, + struct sdr_record_common_sensor *sensor, + uint8_t sdr_record_type) +{ + char sval[16]; + int i = 0; + uint8_t target, lun, channel; + struct sensor_reading *sr; + + + sr = ipmi_sdr_read_sensor_value(intf, sensor, sdr_record_type, 2); + + if (sr == NULL) + return -1; + + target = sensor->keys.owner_id; + lun = sensor->keys.lun; + channel = sensor->keys.channel; + + /* + * CSV OUTPUT + */ + + if (csv_output) { + /* + * print sensor name, reading, unit, state + */ + printf("%s,", sr->s_id); + if (!IS_THRESHOLD_SENSOR(sensor)) { + /* Discrete/Non-Threshold */ + print_csv_discrete(sensor, sr); + printf("\n"); + } + else { + /* Threshold Analog & Discrete*/ + if (sr->s_reading_valid) { + if (sr->s_has_analog_value) { + /* Analog/Threshold */ + printf("%.*f,", (sr->s_a_val == + (int) sr->s_a_val) ? 0 : 3, + sr->s_a_val); + printf("%s,%s", sr->s_a_units, + ipmi_sdr_get_thresh_status(sr, "ns")); + } else { /* Discrete/Threshold */ + print_csv_discrete(sensor, sr); + } + } else { + printf(",,ns"); + } + + 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)); + + if (sr->full) { + SENSOR_PRINT_CSV(sr->full, sr->full->analog_flag.nominal_read, + sr->full->nominal_read); + SENSOR_PRINT_CSV(sr->full, sr->full->analog_flag.normal_min, + sr->full->normal_min); + SENSOR_PRINT_CSV(sr->full, sr->full->analog_flag.normal_max, + sr->full->normal_max); + SENSOR_PRINT_CSV(sr->full, sensor->mask.type.threshold.read.unr, + sr->full->threshold.upper.non_recover); + SENSOR_PRINT_CSV(sr->full, sensor->mask.type.threshold.read.ucr, + sr->full->threshold.upper.critical); + SENSOR_PRINT_CSV(sr->full, sensor->mask.type.threshold.read.unc, + sr->full->threshold.upper.non_critical); + SENSOR_PRINT_CSV(sr->full, sensor->mask.type.threshold.read.lnr, + sr->full->threshold.lower.non_recover); + SENSOR_PRINT_CSV(sr->full, sensor->mask.type.threshold.read.lcr, + sr->full->threshold.lower.critical); + SENSOR_PRINT_CSV(sr->full, sensor->mask.type.threshold.read.lnc, + sr->full->threshold.lower.non_critical); + + if (UNITS_ARE_DISCRETE(sensor)) { + printf("0x%02X,0x%02X", sr->full->sensor_min, sr->full->sensor_max); + } + else { + printf("%.3f,%.3f", + sdr_convert_sensor_reading(sr->full, + sr->full->sensor_min), + sdr_convert_sensor_reading(sr->full, + sr->full->sensor_max)); + } + } else { + printf(",,,,,,,,,,"); + } + } + printf("\n"); + } + + return 0; /* done */ + } + + /* + * NORMAL OUTPUT + */ + + if (verbose == 0 && sdr_extended == 0) { + /* + * print sensor name, reading, state + */ + printf("%-16s | ", sr->s_id); + + memset(sval, 0, sizeof (sval)); + + if (sr->s_reading_valid) { + if( sr->s_has_analog_value ) { + snprintf(sval, sizeof (sval), "%s %s", + sr->s_a_str, + sr->s_a_units); + } else /* Discrete */ + snprintf(sval, sizeof(sval), + "0x%02x", sr->s_reading); + } + else if (sr->s_scanning_disabled) + snprintf(sval, sizeof (sval), sr->full ? "disabled" : "Not Readable"); + else + snprintf(sval, sizeof (sval), sr->full ? "no reading" : "Not Readable"); + + printf("%s", sval); + + for (i = strlen(sval); i <= sizeof (sval); i++) + printf(" "); + printf(" | "); + + if (IS_THRESHOLD_SENSOR(sensor)) { + printf("%s", ipmi_sdr_get_thresh_status(sr, "ns")); + } + else { + printf("%s", sr->s_reading_valid ? "ok" : "ns"); + } + + printf("\n"); + + return 0; /* done */ + } else if (verbose == 0 && sdr_extended == 1) { + /* + * print sensor name, number, state, entity, reading + */ + printf("%-16s | %02Xh | ", + sr->s_id, sensor->keys.sensor_num); + + if (IS_THRESHOLD_SENSOR(sensor)) { + /* Threshold Analog & Discrete */ + printf("%-3s | %2d.%1d | ", + ipmi_sdr_get_thresh_status(sr, "ns"), + sensor->entity.id, sensor->entity.instance); + } + else { + /* Non Threshold Analog & Discrete */ + printf("%-3s | %2d.%1d | ", + (sr->s_reading_valid ? "ok" : "ns"), + sensor->entity.id, sensor->entity.instance); + } + + memset(sval, 0, sizeof (sval)); + + if (sr->s_reading_valid) { + if (IS_THRESHOLD_SENSOR(sensor) && + sr->s_has_analog_value ) { + /* Threshold Analog */ + snprintf(sval, sizeof (sval), "%s %s", + sr->s_a_str, + sr->s_a_units); + } else { + /* Analog & Discrete & Threshold/Discrete */ + char *header = NULL; + if (sr->s_has_analog_value) { /* Sensor has an analog value */ + printf("%s %s", sr->s_a_str, sr->s_a_units); + header = ", "; + } + ipmi_sdr_print_discrete_state_mini(header, ", ", + sensor->sensor.type, + sensor->event_type, + sr->s_data2, + sr->s_data3); + } + } + else if (sr->s_scanning_disabled) + snprintf(sval, sizeof (sval), "Disabled"); + else + snprintf(sval, sizeof (sval), "No Reading"); + + printf("%s\n", sval); + return 0; /* done */ + } + /* + * VERBOSE OUTPUT + */ + + printf("Sensor ID : %s (0x%x)\n", + sr->s_id, 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 (!IS_THRESHOLD_SENSOR(sensor)) { + /* Discrete */ + printf(" Sensor Type (Discrete): %s (0x%02x)\n", + ipmi_sdr_get_sensor_type_desc(sensor->sensor.type), + sensor->sensor.type); + lprintf(LOG_DEBUG, " Event Type Code : 0x%02x", + sensor->event_type); + + printf(" Sensor Reading : "); + if (sr->s_reading_valid) { + if (sr->s_has_analog_value) { /* Sensor has an analog value */ + printf("%s %s\n", sr->s_a_str, sr->s_a_units); + } else { + printf("%xh\n", sr->s_reading); + } + } + else if (sr->s_scanning_disabled) + printf("Disabled\n"); + else { + /* Used to be 'Not Reading' */ + printf("No Reading\n"); + } + + printf(" Event Message Control : "); + switch (sensor->sensor.capabilities.event_msg) { + case 0: + printf("Per-threshold\n"); + break; + case 1: + printf("Entire Sensor Only\n"); + break; + case 2: + printf("Global Disable Only\n"); + break; + case 3: + printf("No Events From Sensor\n"); + break; + } + + ipmi_sdr_print_discrete_state("States Asserted", + sensor->sensor.type, + sensor->event_type, + sr->s_data2, + sr->s_data3); + 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, + sensor->event_type, + DISCRETE_SENSOR, + target, + lun, channel); + ipmi_sdr_print_sensor_event_enable(intf, + sensor->keys.sensor_num, + sensor->sensor.type, + sensor->event_type, + DISCRETE_SENSOR, + target, + lun, channel); + printf(" OEM : %X\n", + sr->full ? sr->full->oem : sr->compact->oem); + printf("\n"); + + return 0; /* done */ + } + printf(" Sensor Type (Threshold) : %s (0x%02x)\n", + ipmi_sdr_get_sensor_type_desc(sensor->sensor.type), + sensor->sensor.type); + + printf(" Sensor Reading : "); + if (sr->s_reading_valid) { + if (sr->full) { + uint16_t raw_tol = __TO_TOL(sr->full->mtol); + if (UNITS_ARE_DISCRETE(sensor)) { + printf("0x%02X (+/- 0x%02X) %s\n", + sr->s_reading, raw_tol, sr->s_a_units); + } + else { + double tol = sdr_convert_sensor_tolerance(sr->full, raw_tol); + printf("%.*f (+/- %.*f) %s\n", + (sr->s_a_val == (int) sr->s_a_val) ? 0 : 3, + sr->s_a_val, (tol == (int) tol) ? 0 : + 3, tol, sr->s_a_units); + } + } else { + printf("0x%02X %s\n", sr->s_reading, sr->s_a_units); + } + } else if (sr->s_scanning_disabled) + printf("Disabled\n"); + else + printf("No Reading\n"); + + printf(" Status : %s\n", + ipmi_sdr_get_thresh_status(sr, "Not Available")); + + if(sr->full) { + SENSOR_PRINT_NORMAL(sr->full, "Nominal Reading", nominal_read); + SENSOR_PRINT_NORMAL(sr->full, "Normal Minimum", normal_min); + SENSOR_PRINT_NORMAL(sr->full, "Normal Maximum", normal_max); + + SENSOR_PRINT_THRESH(sr->full, "Upper non-recoverable", upper.non_recover, unr); + SENSOR_PRINT_THRESH(sr->full, "Upper critical", upper.critical, ucr); + SENSOR_PRINT_THRESH(sr->full, "Upper non-critical", upper.non_critical, unc); + SENSOR_PRINT_THRESH(sr->full, "Lower non-recoverable", lower.non_recover, lnr); + SENSOR_PRINT_THRESH(sr->full, "Lower critical", lower.critical, lcr); + SENSOR_PRINT_THRESH(sr->full, "Lower non-critical", lower.non_critical, lnc); + } + ipmi_sdr_print_sensor_hysteresis(sensor, sr->full, + sr->full ? sr->full->threshold.hysteresis.positive : + sr->compact->threshold.hysteresis.positive, "Positive Hysteresis"); + + ipmi_sdr_print_sensor_hysteresis(sensor, sr->full, + sr->full ? sr->full->threshold.hysteresis.negative : + sr->compact->threshold.hysteresis.negative, "Negative Hysteresis"); + + print_sensor_min_max(sr->full); + + printf(" Event Message Control : "); + switch (sensor->sensor.capabilities.event_msg) { + case 0: + printf("Per-threshold\n"); + break; + case 1: + printf("Entire Sensor Only\n"); + break; + case 2: + printf("Global Disable Only\n"); + break; + case 3: + printf("No Events From Sensor\n"); + break; + } + + printf(" Readable Thresholds : "); + switch (sensor->sensor.capabilities.threshold) { + case 0: + printf("No Thresholds\n"); + break; + 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) + printf("lcr "); + if (sensor->mask.type.threshold.read.lnc) + printf("lnc "); + if (sensor->mask.type.threshold.read.unc) + printf("unc "); + if (sensor->mask.type.threshold.read.ucr) + printf("ucr "); + if (sensor->mask.type.threshold.read.unr) + printf("unr "); + printf("\n"); + break; + case 3: + printf("Thresholds Fixed\n"); + break; + } + + printf(" Settable Thresholds : "); + switch (sensor->sensor.capabilities.threshold) { + case 0: + printf("No Thresholds\n"); + break; + 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) + printf("lcr "); + if (sensor->mask.type.threshold.set.lnc) + printf("lnc "); + if (sensor->mask.type.threshold.set.unc) + printf("unc "); + if (sensor->mask.type.threshold.set.ucr) + printf("ucr "); + if (sensor->mask.type.threshold.set.unr) + printf("unr "); + printf("\n"); + break; + case 3: + printf("Thresholds Fixed\n"); + break; + } + + if (sensor->mask.type.threshold.status_lnr || + sensor->mask.type.threshold.status_lcr || + sensor->mask.type.threshold.status_lnc || + sensor->mask.type.threshold.status_unc || + sensor->mask.type.threshold.status_ucr || + sensor->mask.type.threshold.status_unr) { + printf(" Threshold Read Mask : "); + if (sensor->mask.type.threshold.status_lnr) + printf("lnr "); + if (sensor->mask.type.threshold.status_lcr) + printf("lcr "); + if (sensor->mask.type.threshold.status_lnc) + printf("lnc "); + if (sensor->mask.type.threshold.status_unc) + printf("unc "); + if (sensor->mask.type.threshold.status_ucr) + printf("ucr "); + if (sensor->mask.type.threshold.status_unr) + printf("unr "); + printf("\n"); + } + + ipmi_sdr_print_sensor_mask(&sensor->mask, + sensor->sensor.type, + sensor->event_type, ANALOG_SENSOR); + ipmi_sdr_print_sensor_event_status(intf, + sensor->keys.sensor_num, + sensor->sensor.type, + sensor->event_type, ANALOG_SENSOR, + target, + lun, channel); + + ipmi_sdr_print_sensor_event_enable(intf, + sensor->keys.sensor_num, + sensor->sensor.type, + sensor->event_type, ANALOG_SENSOR, + target, + lun, channel); + + printf("\n"); + return 0; +} + +static inline int +get_offset(uint8_t x) +{ + int i; + for (i = 0; i < 8; i++) + if (x >> i == 1) + return i; + return 0; +} + +/* ipmi_sdr_print_discrete_state_mini - print list of asserted states + * for a discrete sensor + * + * @header : header string if necessary + * @separator : field separator string + * @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_mini(const char *header, 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 && (state2 & 0x7f) == 0) + return; + + if (event_type == 0x6f) { + evt = sensor_specific_types; + typ = sensor_type; + } else { + evt = generic_event_types; + typ = event_type; + } + + if (header) + printf("%s", header); + + for (; evt->type != NULL; evt++) { + if ((evt->code != typ) || + (evt->data != 0xFF)) + continue; + + if (evt->offset > 7) { + if ((1 << (evt->offset - 8)) & (state2 & 0x7f)) { + if (pre++ != 0) + printf("%s", separator); + if (evt->desc) + printf("%s", evt->desc); + } + } else { + if ((1 << evt->offset) & state1) { + if (pre++ != 0) + printf("%s", separator); + if (evt->desc) + 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 && (state2 & 0x7f) == 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) || + (evt->data != 0xFF)) + continue; + + if (pre == 0) { + printf(" %-21s : %s\n", desc, evt->type); + pre = 1; + } + + if (evt->offset > 7) { + if ((1 << (evt->offset - 8)) & (state2 & 0x7f)) { + if (evt->desc) { + printf(" " + "[%s]\n", + evt->desc); + } else { + printf(" " + "[no description]\n"); + } + } + } else { + if ((1 << evt->offset) & state1) { + if (evt->desc) { + printf(" " + "[%s]\n", + evt->desc); + } else { + printf(" " + "[no description]\n"); + } + } + } + c++; + } +} + + +/* ipmi_sdr_print_sensor_eventonly - print SDR event only record + * + * @intf: ipmi interface + * @sensor: event only sdr record + * + * returns 0 on success + * returns -1 on error + */ +int +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)); + 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); + printf("Entity ID : %d.%d (%s)\n", + sensor->entity.id, sensor->entity.instance, + val2str(sensor->entity.id, entity_id_vals)); + printf("Sensor Type : %s (0x%02x)\n", + ipmi_sdr_get_sensor_type_desc(sensor->sensor_type), + sensor->sensor_type); + lprintf(LOG_DEBUG, "Event Type Code : 0x%02x", + sensor->event_type); + printf("\n"); + } else { + if (csv_output) + printf("%s,%02Xh,ns,%d.%d,Event-Only\n", + sensor->id_code ? desc : "", + sensor->keys.sensor_num, + sensor->entity.id, sensor->entity.instance); + else if (sdr_extended) + printf("%-16s | %02Xh | ns | %2d.%1d | Event-Only\n", + sensor->id_code ? desc : "", + sensor->keys.sensor_num, + sensor->entity.id, sensor->entity.instance); + else + printf("%-16s | Event-Only | ns\n", + sensor->id_code ? desc : ""); + } + + return 0; +} + +/* ipmi_sdr_print_sensor_mc_locator - print SDR MC locator record + * + * @intf: ipmi interface + * @mc: mc locator sdr record + * + * returns 0 on success + * returns -1 on error + */ +int +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)); + snprintf(desc, (mc->id_code & 0x1f) + 1, "%s", mc->id_string); + + if (verbose == 0) { + if (csv_output) + printf("%s,00h,ok,%d.%d\n", + mc->id_code ? desc : "", + mc->entity.id, mc->entity.instance); + else if (sdr_extended) { + printf("%-16s | 00h | ok | %2d.%1d | ", + mc->id_code ? desc : "", + mc->entity.id, mc->entity.instance); + + printf("%s MC @ %02Xh\n", + (mc-> + pwr_state_notif & 0x1) ? "Static" : "Dynamic", + mc->dev_slave_addr); + } else { + printf("%-16s | %s MC @ %02Xh %s | ok\n", + mc->id_code ? desc : "", + (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", + mc->entity.id, mc->entity.instance, + val2str(mc->entity.id, entity_id_vals)); + + printf("Device Slave Address : %02Xh\n", mc->dev_slave_addr); + printf("Channel Number : %01Xh\n", mc->channel_num); + + printf("ACPI System P/S Notif : %sRequired\n", + (mc->pwr_state_notif & 0x4) ? "" : "Not "); + printf("ACPI Device P/S Notif : %sRequired\n", + (mc->pwr_state_notif & 0x2) ? "" : "Not "); + printf("Controller Presence : %s\n", + (mc->pwr_state_notif & 0x1) ? "Static" : "Dynamic"); + printf("Logs Init Agent Errors : %s\n", + (mc->global_init & 0x8) ? "Yes" : "No"); + + printf("Event Message Gen : "); + if (!(mc->global_init & 0x3)) + printf("Enable\n"); + else if ((mc->global_init & 0x3) == 0x1) + printf("Disable\n"); + else if ((mc->global_init & 0x3) == 0x2) + printf("Do Not Init Controller\n"); + else + printf("Reserved\n"); + + printf("Device Capabilities\n"); + printf(" Chassis Device : %s\n", + (mc->dev_support & 0x80) ? "Yes" : "No"); + printf(" Bridge : %s\n", + (mc->dev_support & 0x40) ? "Yes" : "No"); + printf(" IPMB Event Generator : %s\n", + (mc->dev_support & 0x20) ? "Yes" : "No"); + printf(" IPMB Event Receiver : %s\n", + (mc->dev_support & 0x10) ? "Yes" : "No"); + printf(" FRU Inventory Device : %s\n", + (mc->dev_support & 0x08) ? "Yes" : "No"); + printf(" SEL Device : %s\n", + (mc->dev_support & 0x04) ? "Yes" : "No"); + printf(" SDR Repository : %s\n", + (mc->dev_support & 0x02) ? "Yes" : "No"); + printf(" Sensor Device : %s\n", + (mc->dev_support & 0x01) ? "Yes" : "No"); + + printf("\n"); + + return 0; +} + +/* ipmi_sdr_print_sensor_generic_locator - print generic device locator record + * + * @intf: ipmi interface + * @gen: generic device locator sdr record + * + * returns 0 on success + * returns -1 on error + */ +int +ipmi_sdr_print_sensor_generic_locator(struct ipmi_intf *intf, + struct sdr_record_generic_locator *dev) +{ + char desc[17]; + + memset(desc, 0, sizeof (desc)); + snprintf(desc, (dev->id_code & 0x1f) + 1, "%s", dev->id_string); + + if (!verbose) { + if (csv_output) + printf("%s,00h,ns,%d.%d\n", + 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); + else + printf("%-16s | Generic @%02X:%02X.%-2d | ok\n", + dev->id_code ? desc : "", + dev->dev_access_addr, + dev->dev_slave_addr, dev->oem); + + return 0; + } + + printf("Device ID : %s\n", dev->id_string); + printf("Entity ID : %d.%d (%s)\n", + dev->entity.id, dev->entity.instance, + val2str(dev->entity.id, entity_id_vals)); + + printf("Device Access Address : %02Xh\n", dev->dev_access_addr); + printf("Device Slave Address : %02Xh\n", dev->dev_slave_addr); + printf("Address Span : %02Xh\n", dev->addr_span); + 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, + val2str(dev->dev_type << 8 | dev->dev_type_modifier, + entity_device_type_vals)); + printf("OEM : %02Xh\n", dev->oem); + printf("\n"); + + return 0; +} + +/* ipmi_sdr_print_sensor_fru_locator - print FRU locator record + * + * @intf: ipmi interface + * @fru: fru locator sdr record + * + * returns 0 on success + * returns -1 on error + */ +int +ipmi_sdr_print_sensor_fru_locator(struct ipmi_intf *intf, + struct sdr_record_fru_locator *fru) +{ + char desc[17]; + + memset(desc, 0, sizeof (desc)); + snprintf(desc, (fru->id_code & 0x1f) + 1, "%s", fru->id_string); + + if (!verbose) { + if (csv_output) + printf("%s,00h,ns,%d.%d\n", + fru->id_code ? desc : "", + fru->entity.id, fru->entity.instance); + else if (sdr_extended) + printf("%-16s | 00h | ns | %2d.%1d | %s FRU @%02Xh\n", + fru->id_code ? desc : "", + fru->entity.id, fru->entity.instance, + (fru->logical) ? "Logical" : "Physical", + fru->device_id); + else + printf("%-16s | %s FRU @%02Xh %02x.%x | ok\n", + fru->id_code ? desc : "", + (fru->logical) ? "Log" : "Phy", + fru->device_id, + fru->entity.id, fru->entity.instance); + + return 0; + } + + printf("Device ID : %s\n", fru->id_string); + printf("Entity ID : %d.%d (%s)\n", + fru->entity.id, fru->entity.instance, + 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("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, + val2str(fru->dev_type << 8 | fru->dev_type_modifier, + entity_device_type_vals)); + printf("OEM : %02Xh\n", fru->oem); + printf("\n"); + + return 0; +} + +/* ipmi_sdr_print_sensor_entity_assoc - print SDR entity association record + * + * @intf: ipmi interface + * @mc: entity association sdr record + * + * returns 0 on success + * returns -1 on error + */ +int +ipmi_sdr_print_sensor_entity_assoc(struct ipmi_intf *intf, + struct sdr_record_entity_assoc *assoc) +{ + return 0; +} + +/* ipmi_sdr_print_sensor_oem_intel - print Intel OEM sensors + * + * @intf: ipmi interface + * @oem: oem sdr record + * + * returns 0 on success + * returns -1 on error + */ +static int +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 */ + if (verbose) { + 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]); + printf("\n"); + } + + switch (oem->data_len) { + case 7: /* SR1300, non-redundant */ + if (verbose) + printf("Power Redundancy : No\n"); + else if (csv_output) + printf("Power Redundancy,Not Available,nr\n"); + else + printf + ("Power Redundancy | Not Available | nr\n"); + break; + 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", + oem->data[8]); + } + break; + 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]); + } else if (csv_output) { + 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]); + } + break; + } + if (verbose) + printf("\n"); + break; + case 0x03: /* Fan Speed Control */ + break; + case 0x06: /* System Information */ + break; + case 0x07: /* Ambient Temperature Fan Speed Control */ + break; + default: + lprintf(LOG_DEBUG, "Unknown Intel OEM SDR Record type %02x", + oem->data[3]); + } + + return 0; +} + +/* ipmi_sdr_print_sensor_oem - print OEM sensors + * + * This function is generally only filled out by decoding what + * a particular BMC might stuff into its OEM records. The + * records are keyed off manufacturer ID and record subtypes. + * + * @intf: ipmi interface + * @oem: oem sdr record + * + * returns 0 on success + * returns -1 on error + */ +static int +ipmi_sdr_print_sensor_oem(struct ipmi_intf *intf, struct sdr_record_oem *oem) +{ + int rc = 0; + + if (oem == NULL) + return -1; + if (oem->data_len == 0 || oem->data == NULL) + return -1; + + if (verbose > 2) + printbuf(oem->data, oem->data_len, "OEM Record"); + + /* intel manufacturer id */ + if (oem->data[0] == 0x57 && + oem->data[1] == 0x01 && oem->data[2] == 0x00) { + rc = ipmi_sdr_print_sensor_oem_intel(intf, oem); + } + + return rc; +} + +/* ipmi_sdr_print_name_from_rawentry - Print SDR name from raw data + * + * @intf: ipmi interface + * @type: sensor type + * @raw: raw sensor data + * + * returns 0 on success + * returns -1 on error + */ +int +ipmi_sdr_print_name_from_rawentry(struct ipmi_intf *intf,uint16_t id, + uint8_t type,uint8_t * raw) +{ + 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; + } record; + + int rc =0; + char desc[17]; + memset(desc, ' ', sizeof (desc)); + + switch ( type) { + case SDR_RECORD_TYPE_FULL_SENSOR: + record.full = (struct sdr_record_full_sensor *) raw; + snprintf(desc, (record.full->id_code & 0x1f) +1, "%s", + (const char *)record.full->id_string); + break; + case SDR_RECORD_TYPE_COMPACT_SENSOR: + record.compact = (struct sdr_record_compact_sensor *) raw ; + snprintf(desc, (record.compact->id_code & 0x1f) +1, "%s", + (const char *)record.compact->id_string); + break; + case SDR_RECORD_TYPE_EVENTONLY_SENSOR: + record.eventonly = (struct sdr_record_eventonly_sensor *) raw ; + snprintf(desc, (record.eventonly->id_code & 0x1f) +1, "%s", + (const char *)record.eventonly->id_string); + break; + case SDR_RECORD_TYPE_MC_DEVICE_LOCATOR: + record.mcloc = (struct sdr_record_mc_locator *) raw ; + snprintf(desc, (record.mcloc->id_code & 0x1f) +1, "%s", + (const char *)record.mcloc->id_string); + break; + default: + rc = -1; + break; + } + + lprintf(LOG_INFO, "ID: 0x%04x , NAME: %-16s", id, desc); + return rc; +} + +/* ipmi_sdr_print_rawentry - Print SDR entry from raw data + * + * @intf: ipmi interface + * @type: sensor type + * @raw: raw sensor data + * @len: length of raw sensor data + * + * returns 0 on success + * returns -1 on error + */ +int +ipmi_sdr_print_rawentry(struct ipmi_intf *intf, uint8_t type, + uint8_t * raw, int len) +{ + int rc = 0; + + switch (type) { + case SDR_RECORD_TYPE_FULL_SENSOR: + case SDR_RECORD_TYPE_COMPACT_SENSOR: + rc = ipmi_sdr_print_sensor_fc(intf, + (struct sdr_record_common_sensor *) raw, + type); + break; + case SDR_RECORD_TYPE_EVENTONLY_SENSOR: + rc = ipmi_sdr_print_sensor_eventonly(intf, + (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); + break; + case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: + rc = ipmi_sdr_print_sensor_fru_locator(intf, + (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); + break; + case SDR_RECORD_TYPE_ENTITY_ASSOC: + rc = ipmi_sdr_print_sensor_entity_assoc(intf, + (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_DEVICE_ENTITY_ASSOC: + case SDR_RECORD_TYPE_MC_CONFIRMATION: + case SDR_RECORD_TYPE_BMC_MSG_CHANNEL_INFO: + /* not implemented */ + break; + } + + return rc; +} + +/* ipmi_sdr_print_listentry - Print SDR entry from list + * + * @intf: ipmi interface + * @entry: sdr record list entry + * + * returns 0 on success + * returns -1 on error + */ +int +ipmi_sdr_print_listentry(struct ipmi_intf *intf, struct sdr_record_list *entry) +{ + int rc = 0; + + switch (entry->type) { + case SDR_RECORD_TYPE_FULL_SENSOR: + case SDR_RECORD_TYPE_COMPACT_SENSOR: + rc = ipmi_sdr_print_sensor_fc(intf, entry->record.common, entry->type); + break; + case SDR_RECORD_TYPE_EVENTONLY_SENSOR: + 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); + break; + case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: + 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); + break; + case SDR_RECORD_TYPE_ENTITY_ASSOC: + 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); + break; + case SDR_RECORD_TYPE_DEVICE_ENTITY_ASSOC: + case SDR_RECORD_TYPE_MC_CONFIRMATION: + case SDR_RECORD_TYPE_BMC_MSG_CHANNEL_INFO: + /* not implemented yet */ + break; + } + + return rc; +} + +/* ipmi_sdr_print_sdr - iterate through SDR printing records + * + * intf: ipmi interface + * type: record type to print + * + * returns 0 on success + * returns -1 on error + */ +int +ipmi_sdr_print_sdr(struct ipmi_intf *intf, uint8_t type) +{ + struct sdr_get_rs *header; + struct sdr_record_list *e; + int rc = 0; + + lprintf(LOG_DEBUG, "Querying SDR for sensor list"); + + if (sdr_list_itr == NULL) { + sdr_list_itr = ipmi_sdr_start(intf, 0); + if (sdr_list_itr == NULL) { + lprintf(LOG_ERR, "Unable to open SDR for reading"); + return -1; + } + } + + for (e = sdr_list_head; e != NULL; e = e->next) { + if (type != e->type && type != 0xff && type != 0xfe) + continue; + if (type == 0xfe && + e->type != SDR_RECORD_TYPE_FULL_SENSOR && + e->type != SDR_RECORD_TYPE_COMPACT_SENSOR) + continue; + 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; + + rec = ipmi_sdr_get_record(intf, header, sdr_list_itr); + if (rec == NULL) { + lprintf(LOG_ERR, "ipmitool: ipmi_sdr_get_record() failed"); + rc = -1; + continue; + } + + sdrr = malloc(sizeof (struct sdr_record_list)); + if (sdrr == NULL) { + lprintf(LOG_ERR, "ipmitool: malloc failure"); + if (rec != NULL) { + free(rec); + rec = NULL; + } + break; + } + 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: + case SDR_RECORD_TYPE_COMPACT_SENSOR: + sdrr->record.common = + (struct sdr_record_common_sensor *) rec; + break; + case SDR_RECORD_TYPE_EVENTONLY_SENSOR: + 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; + break; + case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: + 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; + break; + case SDR_RECORD_TYPE_ENTITY_ASSOC: + sdrr->record.entassoc = + (struct sdr_record_entity_assoc *) rec; + break; + default: + free(rec); + rec = NULL; + if (sdrr != NULL) { + free(sdrr); + sdrr = NULL; + } + continue; + } + + lprintf(LOG_DEBUG, "SDR record ID : 0x%04x", sdrr->id); + + if (type == header->type || type == 0xff || + (type == 0xfe && + (header->type == SDR_RECORD_TYPE_FULL_SENSOR || + header->type == SDR_RECORD_TYPE_COMPACT_SENSOR))) { + if (ipmi_sdr_print_rawentry(intf, header->type, + rec, header->length) < 0) + rc = -1; + } + + /* add to global record liset */ + if (sdr_list_head == NULL) + sdr_list_head = sdrr; + else + sdr_list_tail->next = sdrr; + + sdr_list_tail = sdrr; + } + + return rc; +} + +/* ipmi_sdr_get_reservation - Obtain SDR reservation ID + * + * @intf: ipmi interface + * @reserve_id: pointer to short int for storing the id + * + * returns 0 on success + * returns -1 on error + */ +int +ipmi_sdr_get_reservation(struct ipmi_intf *intf, int use_builtin, + uint16_t * reserve_id) +{ + struct ipmi_rs *rsp; + struct ipmi_rq req; + + /* obtain reservation ID */ + memset(&req, 0, sizeof (req)); + + if (use_builtin == 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); + + /* be slient for errors, they are handled by calling function */ + if (rsp == NULL) + return -1; + if (rsp->ccode > 0) + return -1; + + *reserve_id = ((struct sdr_reserve_repo_rs *) &(rsp->data))->reserve_id; + lprintf(LOG_DEBUG, "SDR reservation ID %04x", *reserve_id); + + return 0; +} + +/* ipmi_sdr_start - setup sdr iterator + * + * @intf: ipmi interface + * + * returns sdr iterator structure pointer + * returns NULL on error + */ +struct ipmi_sdr_iterator * +ipmi_sdr_start(struct ipmi_intf *intf, int use_builtin) +{ + struct ipmi_sdr_iterator *itr; + struct ipmi_rs *rsp; + struct ipmi_rq req; + + struct ipm_devid_rsp *devid; + + itr = malloc(sizeof (struct ipmi_sdr_iterator)); + if (itr == NULL) { + lprintf(LOG_ERR, "ipmitool: malloc failure"); + return NULL; + } + + /* 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, "Get Device ID command failed"); + free(itr); + itr = NULL; + return NULL; + } + if (rsp->ccode > 0) { + lprintf(LOG_ERR, "Get Device ID command failed: %#x %s", + rsp->ccode, val2str(rsp->ccode, completion_code_vals)); + free(itr); + itr = NULL; + return NULL; + } + devid = (struct ipm_devid_rsp *) rsp->data; + + sdriana = (long)IPM_DEV_MANUFACTURER_ID(devid->manufacturer_id); + + if (!use_builtin && (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); + itr = NULL; + return NULL; + } + } else { + lprintf(LOG_DEBUG, "Using SDR from Repository \n"); + } + } + itr->use_built_in = use_builtin ? 1 : use_built_in; + /***********************/ + if (itr->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; + + rsp = intf->sendrecv(intf, &req); + if (rsp == NULL) { + lprintf(LOG_ERR, "Error obtaining SDR info"); + free(itr); + itr = NULL; + return NULL; + } + if (rsp->ccode > 0) { + lprintf(LOG_ERR, "Error obtaining SDR info: %s", + val2str(rsp->ccode, completion_code_vals)); + free(itr); + itr = NULL; + return NULL; + } + + 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); + + /* Build SDRR if there is no record in repository */ + if( sdr_info.count == 0 ) { + lprintf(LOG_DEBUG, "Rebuilding SDRR..."); + + if( ipmi_sdr_add_from_sensors( intf, 0 ) != 0 ) { + lprintf(LOG_ERR, "Could not build SDRR!"); + free(itr); + itr = NULL; + return NULL; + } + } + } 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); + itr = NULL; + 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); + } + + if (ipmi_sdr_get_reservation(intf, itr->use_built_in, + &(itr->reservation)) < 0) { + lprintf(LOG_ERR, "Unable to obtain SDR reservation"); + free(itr); + itr = NULL; + return NULL; + } + + return itr; +} + +/* ipmi_sdr_get_record - return RAW SDR record + * + * @intf: ipmi interface + * @header: SDR header + * @itr: SDR iterator + * + * returns raw SDR data + * returns NULL on error + */ +uint8_t * +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 sdr_get_rq sdr_rq; + uint8_t *data; + int i = 0, len = header->length; + + if (len < 1) + return NULL; + + data = malloc(len + 1); + if (data == NULL) { + lprintf(LOG_ERR, "ipmitool: malloc failure"); + return NULL; + } + memset(data, 0, len + 1); + + 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)); + if (itr->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); + + /* check if max length is null */ + if ( sdr_max_read_len == 0 ) { + /* get maximum response size */ + sdr_max_read_len = ipmi_intf_get_max_response_data_size(intf) - 2; + + /* cap the number of bytes to read */ + if (sdr_max_read_len > 0xFE) { + sdr_max_read_len = 0xFE; + } + } + + /* 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 */ + + lprintf(LOG_DEBUG, "Getting %d bytes from SDR at offset %d", + sdr_rq.length, sdr_rq.offset); + + rsp = intf->sendrecv(intf, &req); + if (rsp == NULL) { + sdr_max_read_len = sdr_rq.length - 1; + if (sdr_max_read_len > 0) { + /* no response may happen if requests are bridged + and too many bytes are requested */ + continue; + } else { + free(data); + data = NULL; + return NULL; + } + } + + switch (rsp->ccode) { + case 0xca: + /* read too many bytes at once */ + sdr_max_read_len = sdr_rq.length - 1; + continue; + case 0xc5: + /* lost reservation */ + lprintf(LOG_DEBUG, "SDR reservation cancelled. " + "Sleeping a bit and retrying..."); + + sleep(rand() & 3); + + if (ipmi_sdr_get_reservation(intf, itr->use_built_in, + &(itr->reservation)) < 0) { + free(data); + data = NULL; + return NULL; + } + sdr_rq.reserve_id = itr->reservation; + continue; + } + + /* special completion codes handled above */ + if (rsp->ccode > 0 || rsp->data_len == 0) { + free(data); + data = NULL; + return NULL; + } + + memcpy(data + i, rsp->data + 2, sdr_rq.length); + i += sdr_max_read_len; + } + + return data; +} + +/* ipmi_sdr_end - cleanup SDR iterator + * + * @intf: ipmi interface + * @itr: SDR iterator + * + * no meaningful return code + */ +void +ipmi_sdr_end(struct ipmi_intf *intf, struct ipmi_sdr_iterator *itr) +{ + if (itr) { + free(itr); + itr = NULL; + } +} + +/* __sdr_list_add - helper function to add SDR record to list + * + * @head: list head + * @entry: new entry to add to end of list + * + * returns 0 on success + * returns -1 on error + */ +static int +__sdr_list_add(struct sdr_record_list *head, struct sdr_record_list *entry) +{ + struct sdr_record_list *e; + struct sdr_record_list *new; + + if (head == NULL) + return -1; + + 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)); + + e = head; + while (e->next) + e = e->next; + e->next = new; + new->next = NULL; + + return 0; +} + +/* __sdr_list_empty - low-level handler to clean up record list + * + * @head: list head to clean + * + * no meaningful return code + */ +static void +__sdr_list_empty(struct sdr_record_list *head) +{ + struct sdr_record_list *e, *f; + for (e = head; e != NULL; e = f) { + f = e->next; + free(e); + e = NULL; + } + head = NULL; +} + +/* ipmi_sdr_list_empty - clean global SDR list + * + * @intf: ipmi interface + * + * no meaningful return code + */ +void +ipmi_sdr_list_empty(struct ipmi_intf *intf) +{ + struct sdr_record_list *list, *next; + + ipmi_sdr_end(intf, sdr_list_itr); + + for (list = sdr_list_head; list != NULL; list = next) { + switch (list->type) { + case SDR_RECORD_TYPE_FULL_SENSOR: + case SDR_RECORD_TYPE_COMPACT_SENSOR: + if (list->record.common) { + free(list->record.common); + list->record.common = NULL; + } + break; + case SDR_RECORD_TYPE_EVENTONLY_SENSOR: + if (list->record.eventonly) { + free(list->record.eventonly); + list->record.eventonly = NULL; + } + break; + case SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR: + if (list->record.genloc) { + free(list->record.genloc); + list->record.genloc = NULL; + } + break; + case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: + if (list->record.fruloc) { + free(list->record.fruloc); + list->record.fruloc = NULL; + } + break; + case SDR_RECORD_TYPE_MC_DEVICE_LOCATOR: + if (list->record.mcloc) { + free(list->record.mcloc); + list->record.mcloc = NULL; + } + break; + case SDR_RECORD_TYPE_ENTITY_ASSOC: + if (list->record.entassoc) { + free(list->record.entassoc); + list->record.entassoc = NULL; + } + break; + } + next = list->next; + free(list); + list = NULL; + } + + sdr_list_head = NULL; + sdr_list_tail = NULL; + sdr_list_itr = NULL; +} + +/* ipmi_sdr_find_sdr_bynumtype - lookup SDR entry by number/type + * + * @intf: ipmi interface + * @gen_id: sensor owner ID/LUN - SEL generator ID + * @num: sensor number to search for + * @type: sensor type to search for + * + * returns pointer to SDR list + * returns NULL on error + */ +struct sdr_record_list * +ipmi_sdr_find_sdr_bynumtype(struct ipmi_intf *intf, uint16_t gen_id, uint8_t num, uint8_t type) +{ + struct sdr_get_rs *header; + struct sdr_record_list *e; + int found = 0; + + if (sdr_list_itr == NULL) { + sdr_list_itr = ipmi_sdr_start(intf, 0); + if (sdr_list_itr == NULL) { + lprintf(LOG_ERR, "Unable to open SDR for reading"); + return NULL; + } + } + + /* check what we've already read */ + for (e = sdr_list_head; e != NULL; e = e->next) { + switch (e->type) { + case SDR_RECORD_TYPE_FULL_SENSOR: + case SDR_RECORD_TYPE_COMPACT_SENSOR: + if (e->record.common->keys.sensor_num == num && + e->record.common->keys.owner_id == (gen_id & 0x00ff) && + e->record.common->sensor.type == type) + return e; + break; + case SDR_RECORD_TYPE_EVENTONLY_SENSOR: + if (e->record.eventonly->keys.sensor_num == num && + e->record.eventonly->keys.owner_id == (gen_id & 0x00ff) && + e->record.eventonly->sensor_type == type) + return e; + break; + } + } + + /* now keep looking */ + while ((header = ipmi_sdr_get_next_header(intf, sdr_list_itr)) != NULL) { + uint8_t *rec; + struct sdr_record_list *sdrr; + + 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)); + sdrr->id = header->id; + sdrr->type = header->type; + + rec = ipmi_sdr_get_record(intf, header, sdr_list_itr); + if (rec == NULL) { + if (sdrr != NULL) { + free(sdrr); + sdrr = NULL; + } + continue; + } + + switch (header->type) { + case SDR_RECORD_TYPE_FULL_SENSOR: + case SDR_RECORD_TYPE_COMPACT_SENSOR: + sdrr->record.common = + (struct sdr_record_common_sensor *) rec; + if (sdrr->record.common->keys.sensor_num == num + && sdrr->record.common->keys.owner_id == (gen_id & 0x00ff) + && sdrr->record.common->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->keys.owner_id == (gen_id & 0x00ff) + && 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; + break; + case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: + 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; + break; + case SDR_RECORD_TYPE_ENTITY_ASSOC: + sdrr->record.entassoc = + (struct sdr_record_entity_assoc *) rec; + break; + default: + free(rec); + rec = NULL; + if (sdrr != NULL) { + free(sdrr); + sdrr = NULL; + } + continue; + } + + /* put in the global record list */ + if (sdr_list_head == NULL) + sdr_list_head = sdrr; + else + sdr_list_tail->next = sdrr; + + sdr_list_tail = sdrr; + + if (found) + return sdrr; + } + + return NULL; +} + +/* ipmi_sdr_find_sdr_bysensortype - lookup SDR entry by sensor type + * + * @intf: ipmi interface + * @type: sensor type to search for + * + * returns pointer to SDR list + * returns NULL on error + */ +struct sdr_record_list * +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; + + if (sdr_list_itr == NULL) { + sdr_list_itr = ipmi_sdr_start(intf, 0); + if (sdr_list_itr == NULL) { + lprintf(LOG_ERR, "Unable to open SDR for reading"); + return NULL; + } + } + + /* check what we've already read */ + 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)); + + for (e = sdr_list_head; e != NULL; e = e->next) { + switch (e->type) { + case SDR_RECORD_TYPE_FULL_SENSOR: + case SDR_RECORD_TYPE_COMPACT_SENSOR: + if (e->record.common->sensor.type == type) + __sdr_list_add(head, e); + break; + case SDR_RECORD_TYPE_EVENTONLY_SENSOR: + if (e->record.eventonly->sensor_type == type) + __sdr_list_add(head, e); + break; + } + } + + /* now keep looking */ + while ((header = ipmi_sdr_get_next_header(intf, sdr_list_itr)) != NULL) { + uint8_t *rec; + struct sdr_record_list *sdrr; + + 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)); + sdrr->id = header->id; + sdrr->type = header->type; + + rec = ipmi_sdr_get_record(intf, header, sdr_list_itr); + if (rec == NULL) { + if (sdrr != NULL) { + free(sdrr); + sdrr = NULL; + } + continue; + } + + switch (header->type) { + case SDR_RECORD_TYPE_FULL_SENSOR: + case SDR_RECORD_TYPE_COMPACT_SENSOR: + sdrr->record.common = + (struct sdr_record_common_sensor *) rec; + if (sdrr->record.common->sensor.type == type) + __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->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; + break; + case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: + 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; + break; + case SDR_RECORD_TYPE_ENTITY_ASSOC: + sdrr->record.entassoc = + (struct sdr_record_entity_assoc *) rec; + break; + default: + free(rec); + rec = NULL; + if (sdrr != NULL) { + free(sdrr); + sdrr = NULL; + } + continue; + } + + /* put in the global record list */ + if (sdr_list_head == NULL) + sdr_list_head = sdrr; + else + sdr_list_tail->next = sdrr; + + sdr_list_tail = sdrr; + } + + return head; +} + +/* ipmi_sdr_find_sdr_byentity - lookup SDR entry by entity association + * + * @intf: ipmi interface + * @entity: entity id/instance to search for + * + * returns pointer to SDR list + * returns NULL on error + */ +struct sdr_record_list * +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; + + if (sdr_list_itr == NULL) { + sdr_list_itr = ipmi_sdr_start(intf, 0); + if (sdr_list_itr == NULL) { + lprintf(LOG_ERR, "Unable to open SDR for reading"); + return NULL; + } + } + + 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)); + + /* check what we've already read */ + for (e = sdr_list_head; e != NULL; e = e->next) { + switch (e->type) { + case SDR_RECORD_TYPE_FULL_SENSOR: + case SDR_RECORD_TYPE_COMPACT_SENSOR: + if (e->record.common->entity.id == entity->id && + (entity->instance == 0x7f || + e->record.common->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)) + __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)) + __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)) + __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)) + __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)) + __sdr_list_add(head, e); + break; + } + } + + /* now keep looking */ + while ((header = ipmi_sdr_get_next_header(intf, sdr_list_itr)) != NULL) { + uint8_t *rec; + struct sdr_record_list *sdrr; + + 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)); + sdrr->id = header->id; + sdrr->type = header->type; + + rec = ipmi_sdr_get_record(intf, header, sdr_list_itr); + if (rec == NULL) { + if (sdrr != NULL) { + free(sdrr); + sdrr = NULL; + } + continue; + } + + switch (header->type) { + case SDR_RECORD_TYPE_FULL_SENSOR: + case SDR_RECORD_TYPE_COMPACT_SENSOR: + sdrr->record.common = + (struct sdr_record_common_sensor *) rec; + if (sdrr->record.common->entity.id == entity->id + && (entity->instance == 0x7f + || sdrr->record.common->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)) + __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)) + __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)) + __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)) + __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)) + __sdr_list_add(head, sdrr); + break; + default: + free(rec); + rec = NULL; + if (sdrr != NULL) { + free(sdrr); + sdrr = NULL; + } + continue; + } + + /* add to global record list */ + if (sdr_list_head == NULL) + sdr_list_head = sdrr; + else + sdr_list_tail->next = sdrr; + + sdr_list_tail = sdrr; + } + + return head; +} + +/* ipmi_sdr_find_sdr_bytype - lookup SDR entries by type + * + * @intf: ipmi interface + * @type: type of sensor record to search for + * + * returns pointer to SDR list with all matching entities + * returns NULL on error + */ +struct sdr_record_list * +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; + + if (sdr_list_itr == NULL) { + sdr_list_itr = ipmi_sdr_start(intf, 0); + if (sdr_list_itr == NULL) { + lprintf(LOG_ERR, "Unable to open SDR for reading"); + return NULL; + } + } + + 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)); + + /* check what we've already read */ + 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; + + 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)); + sdrr->id = header->id; + sdrr->type = header->type; + + rec = ipmi_sdr_get_record(intf, header, sdr_list_itr); + if (rec == NULL) { + if (sdrr != NULL) { + free(sdrr); + sdrr = NULL; + } + continue; + } + + switch (header->type) { + case SDR_RECORD_TYPE_FULL_SENSOR: + case SDR_RECORD_TYPE_COMPACT_SENSOR: + sdrr->record.common = + (struct sdr_record_common_sensor *) rec; + break; + case SDR_RECORD_TYPE_EVENTONLY_SENSOR: + 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; + break; + case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: + 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; + break; + case SDR_RECORD_TYPE_ENTITY_ASSOC: + sdrr->record.entassoc = + (struct sdr_record_entity_assoc *) rec; + break; + default: + free(rec); + rec = NULL; + if (sdrr != NULL) { + free(sdrr); + sdrr = NULL; + } + continue; + } + + if (header->type == type) + __sdr_list_add(head, sdrr); + + /* add to global record list */ + if (sdr_list_head == NULL) + sdr_list_head = sdrr; + else + sdr_list_tail->next = sdrr; + + sdr_list_tail = sdrr; + } + + return head; +} + +/* ipmi_sdr_find_sdr_byid - lookup SDR entry by ID string + * + * @intf: ipmi interface + * @id: string to match for sensor name + * + * returns pointer to SDR list + * returns NULL on error + */ +struct sdr_record_list * +ipmi_sdr_find_sdr_byid(struct ipmi_intf *intf, char *id) +{ + struct sdr_get_rs *header; + struct sdr_record_list *e; + int found = 0; + int idlen; + + if (id == NULL) + return NULL; + + idlen = strlen(id); + + if (sdr_list_itr == NULL) { + sdr_list_itr = ipmi_sdr_start(intf, 0); + if (sdr_list_itr == NULL) { + lprintf(LOG_ERR, "Unable to open SDR for reading"); + return NULL; + } + } + + /* check what we've already read */ + for (e = sdr_list_head; e != NULL; e = e->next) { + switch (e->type) { + case SDR_RECORD_TYPE_FULL_SENSOR: + if (!strncmp((const char *)e->record.full->id_string, + (const char *)id, + __max(e->record.full->id_code & 0x1f, idlen))) + return e; + break; + case SDR_RECORD_TYPE_COMPACT_SENSOR: + if (!strncmp((const char *)e->record.compact->id_string, + (const char *)id, + __max(e->record.compact->id_code & 0x1f, idlen))) + return e; + break; + case SDR_RECORD_TYPE_EVENTONLY_SENSOR: + if (!strncmp((const char *)e->record.eventonly->id_string, + (const char *)id, + __max(e->record.eventonly->id_code & 0x1f, idlen))) + return e; + break; + case SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR: + if (!strncmp((const char *)e->record.genloc->id_string, + (const char *)id, + __max(e->record.genloc->id_code & 0x1f, idlen))) + return e; + break; + case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: + if (!strncmp((const char *)e->record.fruloc->id_string, + (const char *)id, + __max(e->record.fruloc->id_code & 0x1f, idlen))) + return e; + break; + case SDR_RECORD_TYPE_MC_DEVICE_LOCATOR: + if (!strncmp((const char *)e->record.mcloc->id_string, + (const char *)id, + __max(e->record.mcloc->id_code & 0x1f, idlen))) + return e; + break; + } + } + + /* now keep looking */ + while ((header = ipmi_sdr_get_next_header(intf, sdr_list_itr)) != NULL) { + uint8_t *rec; + struct sdr_record_list *sdrr; + + 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)); + sdrr->id = header->id; + sdrr->type = header->type; + + rec = ipmi_sdr_get_record(intf, header, sdr_list_itr); + if (rec == NULL) { + if (sdrr != NULL) { + free(sdrr); + sdrr = NULL; + } + continue; + } + + switch (header->type) { + case SDR_RECORD_TYPE_FULL_SENSOR: + sdrr->record.full = + (struct sdr_record_full_sensor *) rec; + if (!strncmp( + (const char *)sdrr->record.full->id_string, + (const char *)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( + (const char *)sdrr->record.compact->id_string, + (const char *)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( + (const char *)sdrr->record.eventonly->id_string, + (const char *)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( + (const char *)sdrr->record.genloc->id_string, + (const char *)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( + (const char *)sdrr->record.fruloc->id_string, + (const char *)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( + (const char *)sdrr->record.mcloc->id_string, + (const char *)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; + break; + default: + free(rec); + rec = NULL; + if (sdrr != NULL) { + free(sdrr); + sdrr = NULL; + } + continue; + } + + /* add to global record liset */ + if (sdr_list_head == NULL) + sdr_list_head = sdrr; + else + sdr_list_tail->next = sdrr; + + sdr_list_tail = sdrr; + + if (found) + return sdrr; + } + + return NULL; +} + +/* ipmi_sdr_list_cache_fromfile - generate SDR cache for fast lookup from local file + * + * @intf: ipmi interface + * @ifile: input filename + * + * returns pointer to SDR list + * returns NULL on error + */ +int +ipmi_sdr_list_cache_fromfile(struct ipmi_intf *intf, const char *ifile) +{ + 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; + int ret = 0, count = 0, bc = 0; + + if (ifile == NULL) { + lprintf(LOG_ERR, "No SDR cache filename given"); + return -1; + } + + fp = ipmi_open_file_read(ifile); + if (fp == NULL) { + lprintf(LOG_ERR, "Unable to open SDR cache %s for reading", + ifile); + return -1; + } + + while (feof(fp) == 0) { + memset(&header, 0, 5); + bc = fread(&header, 1, 5, fp); + if (bc <= 0) + break; + + if (bc != 5) { + lprintf(LOG_ERR, "header read %d bytes, expected 5", + bc); + ret = -1; + break; + } + + if (header.length == 0) + continue; + + if (header.version != 0x51 && + header.version != 0x01 && + header.version != 0x02) { + lprintf(LOG_WARN, "invalid sdr header version %02x", + header.version); + ret = -1; + break; + } + + 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)); + + sdrr->id = header.id; + sdrr->type = header.type; + + rec = malloc(header.length + 1); + if (rec == NULL) { + lprintf(LOG_ERR, "ipmitool: malloc failure"); + ret = -1; + if (sdrr != NULL) { + free(sdrr); + sdrr = NULL; + } + break; + } + memset(rec, 0, header.length + 1); + + bc = fread(rec, 1, header.length, fp); + if (bc != header.length) { + lprintf(LOG_ERR, + "record %04x read %d bytes, expected %d", + header.id, bc, header.length); + ret = -1; + if (sdrr != NULL) { + free(sdrr); + sdrr = NULL; + } + if (rec != NULL) { + free(rec); + rec = NULL; + } + break; + } + + switch (header.type) { + case SDR_RECORD_TYPE_FULL_SENSOR: + case SDR_RECORD_TYPE_COMPACT_SENSOR: + sdrr->record.common = + (struct sdr_record_common_sensor *) rec; + break; + case SDR_RECORD_TYPE_EVENTONLY_SENSOR: + 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; + break; + case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: + 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; + break; + case SDR_RECORD_TYPE_ENTITY_ASSOC: + sdrr->record.entassoc = + (struct sdr_record_entity_assoc *) rec; + break; + default: + free(rec); + rec = NULL; + if (sdrr != NULL) { + free(sdrr); + sdrr = NULL; + } + continue; + } + + /* add to global record liset */ + if (sdr_list_head == NULL) + sdr_list_head = sdrr; + else + sdr_list_tail->next = sdrr; + + sdr_list_tail = sdrr; + + count++; + + 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)); + if (sdr_list_itr != NULL) { + sdr_list_itr->reservation = 0; + sdr_list_itr->total = count; + sdr_list_itr->next = 0xffff; + } + } + + fclose(fp); + return ret; +} + +/* ipmi_sdr_list_cache - generate SDR cache for fast lookup + * + * @intf: ipmi interface + * + * returns pointer to SDR list + * returns NULL on error + */ +int +ipmi_sdr_list_cache(struct ipmi_intf *intf) +{ + struct sdr_get_rs *header; + + if (sdr_list_itr == NULL) { + sdr_list_itr = ipmi_sdr_start(intf, 0); + if (sdr_list_itr == NULL) { + lprintf(LOG_ERR, "Unable to open SDR for reading"); + return -1; + } + } + + while ((header = ipmi_sdr_get_next_header(intf, sdr_list_itr)) != NULL) { + uint8_t *rec; + struct sdr_record_list *sdrr; + + 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)); + sdrr->id = header->id; + sdrr->type = header->type; + + rec = ipmi_sdr_get_record(intf, header, sdr_list_itr); + if (rec == NULL) { + if (sdrr != NULL) { + free(sdrr); + sdrr = NULL; + } + continue; + } + + switch (header->type) { + case SDR_RECORD_TYPE_FULL_SENSOR: + case SDR_RECORD_TYPE_COMPACT_SENSOR: + sdrr->record.common = + (struct sdr_record_common_sensor *) rec; + break; + case SDR_RECORD_TYPE_EVENTONLY_SENSOR: + 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; + break; + case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: + 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; + break; + case SDR_RECORD_TYPE_ENTITY_ASSOC: + sdrr->record.entassoc = + (struct sdr_record_entity_assoc *) rec; + break; + default: + free(rec); + rec = NULL; + if (sdrr != NULL) { + free(sdrr); + sdrr = NULL; + } + continue; + } + + /* add to global record liset */ + if (sdr_list_head == NULL) + sdr_list_head = sdrr; + else + sdr_list_tail->next = sdrr; + + sdr_list_tail = sdrr; + } + + return 0; +} + +/* + * ipmi_sdr_get_info + * + * Execute the GET SDR REPOSITORY INFO command, and populate the sdr_info + * structure. + * See section 33.9 of the IPMI v2 specification for details + * + * returns 0 on success + * -1 on transport error + * > 0 for other errors + */ +int +ipmi_sdr_get_info(struct ipmi_intf *intf, + struct get_sdr_repository_info_rsp *sdr_repository_info) +{ + struct ipmi_rs *rsp; + struct ipmi_rq 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.data_len = 0; + + rsp = intf->sendrecv(intf, &req); + + if (rsp == NULL) { + lprintf(LOG_ERR, "Get SDR Repository Info command failed"); + return -1; + } + if (rsp->ccode > 0) { + lprintf(LOG_ERR, "Get SDR Repository Info command failed: %s", + val2str(rsp->ccode, completion_code_vals)); + return -1; + } + + memcpy(sdr_repository_info, + rsp->data, + __min(sizeof (struct get_sdr_repository_info_rsp), + rsp->data_len)); + + return 0; +} + +/* ipmi_sdr_timestamp - return string from timestamp value + * + * @stamp: 32bit timestamp + * + * returns pointer to static buffer + */ +static char * +ipmi_sdr_timestamp(uint32_t stamp) +{ + static char tbuf[40]; + time_t s = (time_t) stamp; + memset(tbuf, 0, 40); + if (stamp) + strftime(tbuf, sizeof (tbuf), "%m/%d/%Y %H:%M:%S", + gmtime(&s)); + return tbuf; +} + +/* + * ipmi_sdr_print_info + * + * Display the return data of the GET SDR REPOSITORY INFO command + * See section 33.9 of the IPMI v2 specification for details + * + * returns 0 on success + * -1 on error + */ +int +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); + printf("Record Count : %d\n", + (sdr_repository_info.record_count_msb << 8) | + sdr_repository_info.record_count_lsb); + + free_space = + (sdr_repository_info.free_space[1] << 8) | + sdr_repository_info.free_space[0]; + + printf("Free Space : "); + switch (free_space) { + case 0x0000: + printf("none (full)\n"); + break; + case 0xFFFF: + printf("unspecified\n"); + break; + case 0xFFFE: + printf("> 64Kb - 2 bytes\n"); + break; + default: + printf("%d bytes\n", free_space); + break; + } + + 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]; + printf("Most recent Addition : %s\n", + 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)); + + printf("SDR overflow : %s\n", + (sdr_repository_info.overflow_flag ? "yes" : "no")); + + printf("SDR Repository Update Support : "); + switch (sdr_repository_info.modal_update_support) { + case 0: + printf("unspecified\n"); + break; + case 1: + printf("non-modal\n"); + break; + case 2: + printf("modal\n"); + break; + case 3: + printf("modal and non-modal\n"); + break; + default: + printf("error in response\n"); + break; + } + + printf("Delete SDR supported : %s\n", + sdr_repository_info.delete_sdr_supported ? "yes" : "no"); + printf("Partial Add SDR supported : %s\n", + 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"); + printf("SDR Repository Alloc info supported : %s\n", + sdr_repository_info. + get_sdr_repository_allo_info_supported ? "yes" : "no"); + + return 0; +} + +/* ipmi_sdr_dump_bin - Write raw SDR to binary file + * + * used for post-processing by other utilities + * + * @intf: ipmi interface + * @ofile: output filename + * + * returns 0 on success + * 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; + struct sdr_record_list *sdrr; + FILE *fp; + int rc = 0; + + /* open connection to SDR */ + itr = ipmi_sdr_start(intf, 0); + if (itr == NULL) { + lprintf(LOG_ERR, "Unable to open SDR for reading"); + return -1; + } + + printf("Dumping Sensor Data Repository to '%s'\n", ofile); + + /* generate list of records */ + while ((header = ipmi_sdr_get_next_header(intf, itr)) != NULL) { + sdrr = malloc(sizeof(struct sdr_record_list)); + if (sdrr == NULL) { + lprintf(LOG_ERR, "ipmitool: malloc failure"); + return -1; + } + memset(sdrr, 0, sizeof(struct sdr_record_list)); + + lprintf(LOG_INFO, "Record ID %04x (%d bytes)", + header->id, header->length); + + sdrr->id = header->id; + sdrr->version = header->version; + sdrr->type = header->type; + sdrr->length = header->length; + sdrr->raw = ipmi_sdr_get_record(intf, header, itr); + + if (sdrr->raw == NULL) { + lprintf(LOG_ERR, "ipmitool: cannot obtain SDR record %04x", header->id); + if (sdrr != NULL) { + free(sdrr); + sdrr = NULL; + } + return -1; + } + + if (sdr_list_head == NULL) + sdr_list_head = sdrr; + else + sdr_list_tail->next = sdrr; + + sdr_list_tail = sdrr; + } + + ipmi_sdr_end(intf, itr); + + /* now write to file */ + fp = ipmi_open_file_write(ofile); + if (fp == NULL) + return -1; + + for (sdrr = sdr_list_head; sdrr != NULL; sdrr = sdrr->next) { + int r; + uint8_t h[5]; + + /* build and write sdr header */ + h[0] = sdrr->id & 0xff; // LS Byte first + h[1] = (sdrr->id >> 8) & 0xff; + h[2] = sdrr->version; + h[3] = sdrr->type; + h[4] = sdrr->length; + + r = fwrite(h, 1, 5, fp); + if (r != 5) { + lprintf(LOG_ERR, "Error writing header " + "to output file %s", ofile); + rc = -1; + break; + } + + /* write sdr entry */ + if (!sdrr->raw) { + lprintf(LOG_ERR, "Error: raw data is null (length=%d)", + sdrr->length); + rc = -1; + break; + } + r = fwrite(sdrr->raw, 1, sdrr->length, fp); + if (r != sdrr->length) { + lprintf(LOG_ERR, "Error writing %d record bytes " + "to output file %s", sdrr->length, ofile); + rc = -1; + break; + } + } + fclose(fp); + + return rc; +} + +/* ipmi_sdr_print_type - print all sensors of specified type + * + * @intf: ipmi interface + * @type: sensor type + * + * returns 0 on success + * returns -1 on error + */ +int +ipmi_sdr_print_type(struct ipmi_intf *intf, char *type) +{ + struct sdr_record_list *list, *entry; + int rc = 0; + int x; + uint8_t sensor_type = 0; + + if (type == NULL || + strncasecmp(type, "help", 4) == 0 || + strncasecmp(type, "list", 4) == 0) { + printf("Sensor Types:\n"); + for (x = 1; x < SENSOR_TYPE_MAX; x += 2) { + printf("\t%-25s (0x%02x) %-25s (0x%02x)\n", + sensor_type_desc[x], x, + sensor_type_desc[x + 1], x + 1); + } + return 0; + } + + if (strncmp(type, "0x", 2) == 0) { + /* begins with 0x so let it be entered as raw hex value */ + if (str2uchar(type, &sensor_type) != 0) { + lprintf(LOG_ERR, + "Given type of sensor \"%s\" is either invalid or out of range.", + type); + return (-1); + } + } else { + for (x = 1; x < SENSOR_TYPE_MAX; x++) { + if (strncasecmp(sensor_type_desc[x], type, + __maxlen(type, + sensor_type_desc[x])) == 0) { + sensor_type = x; + break; + } + } + if (sensor_type != x) { + lprintf(LOG_ERR, "Sensor Type \"%s\" not found.", + type); + printf("Sensor Types:\n"); + for (x = 1; x < SENSOR_TYPE_MAX; x += 2) { + printf("\t%-25s (0x%02x) %-25s (0x%02x)\n", + sensor_type_desc[x], x, + sensor_type_desc[x + 1], x + 1); + } + return 0; + } + } + + list = ipmi_sdr_find_sdr_bysensortype(intf, sensor_type); + + for (entry = list; entry != NULL; entry = entry->next) { + rc = ipmi_sdr_print_listentry(intf, entry); + } + + __sdr_list_empty(list); + + return rc; +} + +/* ipmi_sdr_print_entity - print entity's for an id/instance + * + * @intf: ipmi interface + * @entitystr: entity id/instance string, i.e. "1.1" + * + * returns 0 on success + * returns -1 on error + */ +int +ipmi_sdr_print_entity(struct ipmi_intf *intf, char *entitystr) +{ + struct sdr_record_list *list, *entry; + struct entity_id entity; + unsigned id = 0; + unsigned instance = 0; + int rc = 0; + + if (entitystr == NULL || + strncasecmp(entitystr, "help", 4) == 0 || + strncasecmp(entitystr, "list", 4) == 0) { + print_valstr_2col(entity_id_vals, "Entity IDs", -1); + return 0; + } + + if (sscanf(entitystr, "%u.%u", &id, &instance) != 2) { + /* perhaps no instance was passed + * in which case we want all instances for this entity + * so set entity.instance = 0x7f to indicate this + */ + if (sscanf(entitystr, "%u", &id) != 1) { + int i, j=0; + + /* now try string input */ + for (i = 0; entity_id_vals[i].str != NULL; i++) { + if (strncasecmp(entitystr, entity_id_vals[i].str, + __maxlen(entitystr, entity_id_vals[i].str)) == 0) { + entity.id = entity_id_vals[i].val; + entity.instance = 0x7f; + j=1; + } + } + if (j == 0) { + lprintf(LOG_ERR, "Invalid entity: %s", entitystr); + return -1; + } + } else { + entity.id = id; + entity.instance = 0x7f; + } + } else { + entity.id = id; + entity.instance = instance; + } + + list = ipmi_sdr_find_sdr_byentity(intf, &entity); + + for (entry = list; entry != NULL; entry = entry->next) { + rc = ipmi_sdr_print_listentry(intf, entry); + } + + __sdr_list_empty(list); + + return rc; +} + +/* ipmi_sdr_print_entry_byid - print sdr entries identified by sensor id + * + * @intf: ipmi interface + * @argc: number of entries to print + * @argv: list of sensor ids + * + * returns 0 on success + * returns -1 on error + */ +static int +ipmi_sdr_print_entry_byid(struct ipmi_intf *intf, int argc, char **argv) +{ + struct sdr_record_list *sdr; + int rc = 0; + int v, i; + + if (argc < 1) { + lprintf(LOG_ERR, "No Sensor ID supplied"); + return -1; + } + + v = verbose; + verbose = 1; + + for (i = 0; i < argc; i++) { + sdr = ipmi_sdr_find_sdr_byid(intf, argv[i]); + if (sdr == NULL) { + lprintf(LOG_ERR, "Unable to find sensor id '%s'", + argv[i]); + } else { + if (ipmi_sdr_print_listentry(intf, sdr) < 0) + rc = -1; + } + } + + verbose = v; + + return rc; +} + +/* ipmi_sdr_main - top-level handler for SDR subsystem + * + * @intf: ipmi interface + * @argc: number of arguments + * @argv: argument list + * + * returns 0 on success + * returns -1 on error + */ +int +ipmi_sdr_main(struct ipmi_intf *intf, int argc, char **argv) +{ + int rc = 0; + + /* initialize random numbers used later */ + srand(time(NULL)); + + if (argc == 0) + return ipmi_sdr_print_sdr(intf, 0xfe); + else if (strncmp(argv[0], "help", 4) == 0) { + printf_sdr_usage(); + } else if (strncmp(argv[0], "list", 4) == 0 + || strncmp(argv[0], "elist", 5) == 0) { + + if (strncmp(argv[0], "elist", 5) == 0) + sdr_extended = 1; + else + sdr_extended = 0; + + if (argc <= 1) + rc = ipmi_sdr_print_sdr(intf, 0xfe); + 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); + else if (strncmp(argv[1], "compact", 7) == 0) + 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); + else if (strncmp(argv[1], "mcloc", 5) == 0) + 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); + else if (strncmp(argv[1], "generic", 7) == 0) + rc = ipmi_sdr_print_sdr(intf, + SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR); + else if (strcmp(argv[1], "help") == 0) { + lprintf(LOG_NOTICE, + "usage: sdr %s [all|full|compact|event|mcloc|fru|generic]", + argv[0]); + return 0; + } + else { + lprintf(LOG_ERR, + "Invalid SDR %s command: %s", + argv[0], argv[1]); + lprintf(LOG_NOTICE, + "usage: sdr %s [all|full|compact|event|mcloc|fru|generic]", + argv[0]); + return (-1); + } + } 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) { + sdr_extended = 1; + rc = ipmi_sdr_print_entity(intf, argv[1]); + } else if (strncmp(argv[0], "info", 4) == 0) { + rc = ipmi_sdr_print_info(intf); + } else if (strncmp(argv[0], "get", 3) == 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, "Not enough parameters given."); + lprintf(LOG_NOTICE, "usage: sdr dump <file>"); + return (-1); + } + rc = ipmi_sdr_dump_bin(intf, argv[1]); + } else if (strncmp(argv[0], "fill", 4) == 0) { + if (argc <= 1) { + lprintf(LOG_ERR, "Not enough parameters given."); + lprintf(LOG_NOTICE, "usage: sdr fill sensors"); + lprintf(LOG_NOTICE, "usage: sdr fill file <file>"); + lprintf(LOG_NOTICE, "usage: sdr fill range <range>"); + return (-1); + } else if (strncmp(argv[1], "sensors", 7) == 0) { + rc = ipmi_sdr_add_from_sensors(intf, 21); + } else if (strncmp(argv[1], "nosat", 5) == 0) { + rc = ipmi_sdr_add_from_sensors(intf, 0); + } else if (strncmp(argv[1], "file", 4) == 0) { + if (argc < 3) { + lprintf(LOG_ERR, + "Not enough parameters given."); + lprintf(LOG_NOTICE, + "usage: sdr fill file <file>"); + return (-1); + } + rc = ipmi_sdr_add_from_file(intf, argv[2]); + } else if (strncmp(argv[1], "range", 4) == 0) { + if (argc < 3) { + lprintf(LOG_ERR, + "Not enough parameters given."); + lprintf(LOG_NOTICE, + "usage: sdr fill range <range>"); + return (-1); + } + rc = ipmi_sdr_add_from_list(intf, argv[2]); + } else { + lprintf(LOG_ERR, + "Invalid SDR %s command: %s", + argv[0], argv[1]); + lprintf(LOG_NOTICE, + "usage: sdr %s <sensors|nosat|file|range> [options]", + argv[0]); + return (-1); + } + } else { + lprintf(LOG_ERR, "Invalid SDR command: %s", argv[0]); + rc = -1; + } + + return rc; +} + +void +printf_sdr_usage() +{ + lprintf(LOG_NOTICE, +"usage: sdr <command> [options]"); + lprintf(LOG_NOTICE, +" list | elist [option]"); + lprintf(LOG_NOTICE, +" all All SDR Records"); + lprintf(LOG_NOTICE, +" full Full Sensor Record"); + lprintf(LOG_NOTICE, +" compact Compact Sensor Record"); + lprintf(LOG_NOTICE, +" event Event-Only Sensor Record"); + lprintf(LOG_NOTICE, +" mcloc Management Controller Locator Record"); + lprintf(LOG_NOTICE, +" fru FRU Locator Record"); + lprintf(LOG_NOTICE, +" generic Generic Device Locator Record\n"); + lprintf(LOG_NOTICE, +" type [option]"); + lprintf(LOG_NOTICE, +" <Sensor_Type> Retrieve the state of specified sensor."); + lprintf(LOG_NOTICE, +" Sensor_Type can be specified either as"); + lprintf(LOG_NOTICE, +" a string or a hex value."); + lprintf(LOG_NOTICE, +" list Get a list of available sensor types\n"); + lprintf(LOG_NOTICE, +" get <Sensor_ID>"); + lprintf(LOG_NOTICE, +" Retrieve state of the first sensor matched by Sensor_ID\n"); + lprintf(LOG_NOTICE, +" info"); + lprintf(LOG_NOTICE, +" Display information about the repository itself\n"); + lprintf(LOG_NOTICE, +" entity <Entity_ID>[.<Instance_ID>]"); + lprintf(LOG_NOTICE, +" Display all sensors associated with an entity\n"); + lprintf(LOG_NOTICE, +" dump <file>"); + lprintf(LOG_NOTICE, +" Dump raw SDR data to a file\n"); + lprintf(LOG_NOTICE, +" fill <option>"); + lprintf(LOG_NOTICE, +" sensors Creates the SDR repository for the current"); + lprintf(LOG_NOTICE, +" configuration"); + lprintf(LOG_NOTICE, +" nosat Creates the SDR repository for the current"); + lprintf(LOG_NOTICE, +" configuration, without satellite scan"); + lprintf(LOG_NOTICE, +" file <file> Load SDR repository from a file"); + lprintf(LOG_NOTICE, +" range <range> Load SDR repository from a provided list"); + lprintf(LOG_NOTICE, +" or range. Use ',' for list or '-' for"); + lprintf(LOG_NOTICE, +" range, eg. 0x28,0x32,0x40-0x44"); +} |