summaryrefslogtreecommitdiff
path: root/lib/ipmi_sensor.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib/ipmi_sensor.c')
-rw-r--r--lib/ipmi_sensor.c964
1 files changed, 964 insertions, 0 deletions
diff --git a/lib/ipmi_sensor.c b/lib/ipmi_sensor.c
new file mode 100644
index 0000000..4ef5138
--- /dev/null
+++ b/lib/ipmi_sensor.c
@@ -0,0 +1,964 @@
+/*
+ * 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 <ipmitool/ipmi.h>
+#include <ipmitool/helper.h>
+#include <ipmitool/log.h>
+#include <ipmitool/ipmi_intf.h>
+#include <ipmitool/ipmi_sdr.h>
+#include <ipmitool/ipmi_sel.h>
+#include <ipmitool/ipmi_sensor.h>
+
+extern int verbose;
+void printf_sensor_get_usage();
+
+// Macro's for Reading the current sensor Data.
+#define SCANNING_DISABLED 0x40
+#define READING_UNAVAILABLE 0x20
+#define INVALID_THRESHOLD "Invalid Threshold data values. Cannot Set Threshold Data."
+// static
+int
+ipmi_sensor_get_sensor_reading_factors(
+ struct ipmi_intf * intf,
+ struct sdr_record_full_sensor * sensor,
+ uint8_t reading)
+{
+ struct ipmi_rq req;
+ struct ipmi_rs * rsp;
+ uint8_t req_data[2];
+
+ char id[17];
+
+ if (intf == NULL || sensor == NULL)
+ return -1;
+
+ memset(id, 0, sizeof(id));
+ memcpy(id, sensor->id_string, 16);
+
+ req_data[0] = sensor->cmn.keys.sensor_num;
+ req_data[1] = reading;
+
+ memset(&req, 0, sizeof(req));
+ req.msg.netfn = IPMI_NETFN_SE;
+ req.msg.lun = sensor->cmn.keys.lun;
+ req.msg.cmd = GET_SENSOR_FACTORS;
+ req.msg.data = req_data;
+ req.msg.data_len = sizeof(req_data);
+
+ rsp = intf->sendrecv(intf, &req);
+
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error updating reading factor for sensor %s (#%02x)",
+ id, sensor->cmn.keys.sensor_num);
+ return -1;
+ } else if (rsp->ccode) {
+ return -1;
+ } else {
+ /* Update SDR copy with updated Reading Factors for this reading */
+ /* Note:
+ * The Format of the returned data is exactly as in the SDR definition (Little Endian Format),
+ * therefore we can use raw copy operation here.
+ * Note: rsp->data[0] would point to the next valid entry in the sampling table
+ */
+ // BUGBUG: uses 'hardcoded' length information from SDR Definition
+ memcpy(&sensor->mtol, &rsp->data[1], sizeof(sensor->mtol));
+ memcpy(&sensor->bacc, &rsp->data[3], sizeof(sensor->bacc));
+ return 0;
+ }
+
+}
+
+static
+struct ipmi_rs *
+ipmi_sensor_set_sensor_thresholds(struct ipmi_intf *intf,
+ uint8_t sensor,
+ uint8_t threshold, uint8_t setting,
+ uint8_t target, uint8_t lun, uint8_t channel)
+{
+ struct ipmi_rq req;
+ static struct sensor_set_thresh_rq set_thresh_rq;
+ struct ipmi_rs *rsp;
+ uint8_t bridged_request = 0;
+ uint32_t save_addr;
+ uint32_t save_channel;
+
+ memset(&set_thresh_rq, 0, sizeof (set_thresh_rq));
+ set_thresh_rq.sensor_num = sensor;
+ set_thresh_rq.set_mask = threshold;
+ if (threshold == UPPER_NON_RECOV_SPECIFIED)
+ set_thresh_rq.upper_non_recov = setting;
+ else if (threshold == UPPER_CRIT_SPECIFIED)
+ set_thresh_rq.upper_crit = setting;
+ else if (threshold == UPPER_NON_CRIT_SPECIFIED)
+ set_thresh_rq.upper_non_crit = setting;
+ else if (threshold == LOWER_NON_CRIT_SPECIFIED)
+ set_thresh_rq.lower_non_crit = setting;
+ else if (threshold == LOWER_CRIT_SPECIFIED)
+ set_thresh_rq.lower_crit = setting;
+ else if (threshold == LOWER_NON_RECOV_SPECIFIED)
+ set_thresh_rq.lower_non_recov = setting;
+ else
+ return NULL;
+
+ 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 = SET_SENSOR_THRESHOLDS;
+ req.msg.data = (uint8_t *) & set_thresh_rq;
+ req.msg.data_len = sizeof (set_thresh_rq);
+
+ rsp = intf->sendrecv(intf, &req);
+ if (bridged_request) {
+ intf->target_addr = save_addr;
+ intf->target_channel = save_channel;
+ }
+ return rsp;
+}
+
+static int
+ipmi_sensor_print_fc_discrete(struct ipmi_intf *intf,
+ struct sdr_record_common_sensor *sensor,
+ uint8_t sdr_record_type)
+{
+ const char *id;
+ struct sensor_reading *sr;
+
+ sr = ipmi_sdr_read_sensor_value(intf, sensor, sdr_record_type, 3);
+
+ if (sr == NULL) {
+ return -1;
+ }
+
+ if (csv_output) {
+ /* NOT IMPLEMENTED */
+ } else {
+ if (verbose == 0) {
+ /* output format
+ * id value units status thresholds....
+ */
+ printf("%-16s ", sr->s_id);
+ if (sr->s_reading_valid) {
+ if (sr->s_has_analog_value) {
+ /* don't show discrete component */
+ printf("| %-10s | %-10s | %-6s",
+ sr->s_a_str, sr->s_a_units, "ok");
+ } else {
+ printf("| 0x%-8x | %-10s | 0x%02x%02x",
+ sr->s_reading, "discrete",
+ sr->s_data2, sr->s_data3);
+ }
+ } else {
+ printf("| %-10s | %-10s | %-6s",
+ "na", "discrete", "na");
+ }
+ printf("| %-10s| %-10s| %-10s| %-10s| %-10s| %-10s",
+ "na", "na", "na", "na", "na", "na");
+
+ printf("\n");
+ } else {
+ printf("Sensor ID : %s (0x%x)\n",
+ sr->s_id, sensor->keys.sensor_num);
+ printf(" Entity ID : %d.%d\n",
+ sensor->entity.id, sensor->entity.instance);
+ printf(" Sensor Type (Discrete): %s\n",
+ ipmi_sdr_get_sensor_type_desc(sensor->sensor.
+ type));
+ if( sr->s_reading_valid )
+ {
+ if (sr->s_has_analog_value) {
+ printf(" Sensor Reading : %s %s\n", sr->s_a_str, sr->s_a_units);
+ }
+ ipmi_sdr_print_discrete_state("States Asserted",
+ sensor->sensor.type,
+ sensor->event_type,
+ sr->s_data2,
+ sr->s_data3);
+ printf("\n");
+ } else {
+ printf(" Unable to read sensor: Device Not Present\n\n");
+ }
+ }
+ }
+
+ return (sr->s_reading_valid ? 0 : -1 );
+}
+
+static void
+print_thresh_setting(struct sdr_record_full_sensor *full,
+ uint8_t thresh_is_avail, uint8_t setting,
+ const char *field_sep,
+ const char *analog_fmt,
+ const char *discrete_fmt,
+ const char *na_fmt)
+{
+ printf("%s", field_sep);
+ if (!thresh_is_avail) {
+ printf(na_fmt, "na");
+ return;
+ }
+ if (full && !UNITS_ARE_DISCRETE(&full->cmn)) {
+ printf(analog_fmt, sdr_convert_sensor_reading (full, setting));
+ } else {
+ printf(discrete_fmt, setting);
+ }
+}
+
+static int
+ipmi_sensor_print_fc_threshold(struct ipmi_intf *intf,
+ struct sdr_record_common_sensor *sensor,
+ uint8_t sdr_record_type)
+{
+ int thresh_available = 1;
+ struct ipmi_rs *rsp;
+ struct sensor_reading *sr;
+
+ sr = ipmi_sdr_read_sensor_value(intf, sensor, sdr_record_type, 3);
+
+ if (sr == NULL) {
+ return -1;
+ }
+
+ const char *thresh_status = ipmi_sdr_get_thresh_status(sr, "ns");
+
+ /*
+ * Get sensor thresholds
+ */
+ rsp = ipmi_sdr_get_sensor_thresholds(intf,
+ sensor->keys.sensor_num, sensor->keys.owner_id,
+ sensor->keys.lun, sensor->keys.channel);
+
+ if ((rsp == NULL) || (rsp->ccode > 0) || (rsp->data_len == 0))
+ thresh_available = 0;
+
+ if (csv_output) {
+ /* NOT IMPLEMENTED */
+ } else {
+ if (verbose == 0) {
+ /* output format
+ * id value units status thresholds....
+ */
+ printf("%-16s ", sr->s_id);
+ if (sr->s_reading_valid) {
+ if (sr->s_has_analog_value)
+ printf("| %-10.3f | %-10s | %-6s",
+ sr->s_a_val, sr->s_a_units, thresh_status);
+ else
+ printf("| 0x%-8x | %-10s | %-6s",
+ sr->s_reading, sr->s_a_units, thresh_status);
+ } else {
+ printf("| %-10s | %-10s | %-6s",
+ "na", sr->s_a_units, "na");
+ }
+ if (thresh_available && sr->full) {
+#define PTS(bit, dataidx) { \
+ print_thresh_setting(sr->full, rsp->data[0] & (bit), \
+ rsp->data[(dataidx)], "| ", "%-10.3f", "0x-8x", "%-10s"); \
+}
+ PTS(LOWER_NON_RECOV_SPECIFIED, 3);
+ PTS(LOWER_CRIT_SPECIFIED, 2);
+ PTS(LOWER_NON_CRIT_SPECIFIED, 1);
+ PTS(UPPER_NON_CRIT_SPECIFIED, 4);
+ PTS(UPPER_CRIT_SPECIFIED, 5);
+ PTS(UPPER_NON_RECOV_SPECIFIED, 6);
+#undef PTS
+ } else {
+ printf
+ ("| %-10s| %-10s| %-10s| %-10s| %-10s| %-10s",
+ "na", "na", "na", "na", "na", "na");
+ }
+
+ printf("\n");
+ } else {
+ printf("Sensor ID : %s (0x%x)\n",
+ sr->s_id, sensor->keys.sensor_num);
+
+ printf(" Entity ID : %d.%d\n",
+ sensor->entity.id, sensor->entity.instance);
+
+ printf(" Sensor Type (Threshold) : %s\n",
+ ipmi_sdr_get_sensor_type_desc(sensor->sensor.
+ type));
+
+ printf(" Sensor Reading : ");
+ if (sr->s_reading_valid) {
+ if (sr->full) {
+ uint16_t raw_tol = __TO_TOL(sr->full->mtol);
+ if (sr->s_has_analog_value) {
+ 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%x (+/- 0x%x) %s\n",
+ sr->s_reading,
+ raw_tol,
+ sr->s_a_units);
+ }
+ } else {
+ printf("0x%x %s\n", sr->s_reading,
+ sr->s_a_units);
+ }
+ printf(" Status : %s\n", thresh_status);
+
+ if (thresh_available) {
+ if (sr->full) {
+#define PTS(bit, dataidx, str) { \
+print_thresh_setting(sr->full, rsp->data[0] & (bit), \
+ rsp->data[(dataidx)], \
+ (str), "%.3f\n", "0x%x\n", "%s\n"); \
+}
+
+ PTS(LOWER_NON_RECOV_SPECIFIED, 3, " Lower Non-Recoverable : ");
+ PTS(LOWER_CRIT_SPECIFIED, 2, " Lower Critical : ");
+ PTS(LOWER_NON_CRIT_SPECIFIED, 1, " Lower Non-Critical : ");
+ PTS(UPPER_NON_CRIT_SPECIFIED, 4, " Upper Non-Critical : ");
+ PTS(UPPER_CRIT_SPECIFIED, 5, " Upper Critical : ");
+ PTS(UPPER_NON_RECOV_SPECIFIED, 6, " Upper Non-Recoverable : ");
+#undef PTS
+
+ }
+ 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");
+ } else {
+ printf(" Sensor Threshold Settings not available\n");
+ }
+ } else {
+ printf(" Unable to read sensor: Device Not Present\n\n");
+ }
+
+ ipmi_sdr_print_sensor_event_status(intf,
+ sensor->keys.
+ sensor_num,
+ sensor->sensor.type,
+ sensor->event_type,
+ ANALOG_SENSOR,
+ sensor->keys.owner_id,
+ sensor->keys.lun,
+ sensor->keys.channel);
+ ipmi_sdr_print_sensor_event_enable(intf,
+ sensor->keys.
+ sensor_num,
+ sensor->sensor.type,
+ sensor->event_type,
+ ANALOG_SENSOR,
+ sensor->keys.owner_id,
+ sensor->keys.lun,
+ sensor->keys.channel);
+
+ printf("\n");
+ }
+ }
+
+ return (sr->s_reading_valid ? 0 : -1 );
+}
+
+int
+ipmi_sensor_print_fc(struct ipmi_intf *intf,
+ struct sdr_record_common_sensor *sensor,
+ uint8_t sdr_record_type)
+{
+ if (IS_THRESHOLD_SENSOR(sensor))
+ return ipmi_sensor_print_fc_threshold(intf, sensor, sdr_record_type);
+ else
+ return ipmi_sensor_print_fc_discrete(intf, sensor, sdr_record_type);
+}
+
+static int
+ipmi_sensor_list(struct ipmi_intf *intf)
+{
+ struct sdr_get_rs *header;
+ struct ipmi_sdr_iterator *itr;
+ int rc = 0;
+
+ lprintf(LOG_DEBUG, "Querying SDR for sensor list");
+
+ itr = ipmi_sdr_start(intf, 0);
+ if (itr == NULL) {
+ lprintf(LOG_ERR, "Unable to open SDR for reading");
+ return -1;
+ }
+
+ while ((header = ipmi_sdr_get_next_header(intf, itr)) != NULL) {
+ uint8_t *rec;
+
+ rec = ipmi_sdr_get_record(intf, header, itr);
+ if (rec == NULL) {
+ lprintf(LOG_DEBUG, "rec == NULL");
+ continue;
+ }
+
+ switch (header->type) {
+ case SDR_RECORD_TYPE_FULL_SENSOR:
+ case SDR_RECORD_TYPE_COMPACT_SENSOR:
+ ipmi_sensor_print_fc(intf,
+ (struct
+ sdr_record_common_sensor *)
+ rec,
+ header->type);
+ break;
+ }
+ free(rec);
+ rec = NULL;
+
+ /* fix for CR6604909: */
+ /* mask failure of individual reads in sensor list command */
+ /* rc = (r == 0) ? rc : r; */
+ }
+
+ ipmi_sdr_end(intf, itr);
+
+ return rc;
+}
+
+static const struct valstr threshold_vals[] = {
+ {UPPER_NON_RECOV_SPECIFIED, "Upper Non-Recoverable"},
+ {UPPER_CRIT_SPECIFIED, "Upper Critical"},
+ {UPPER_NON_CRIT_SPECIFIED, "Upper Non-Critical"},
+ {LOWER_NON_RECOV_SPECIFIED, "Lower Non-Recoverable"},
+ {LOWER_CRIT_SPECIFIED, "Lower Critical"},
+ {LOWER_NON_CRIT_SPECIFIED, "Lower Non-Critical"},
+ {0x00, NULL},
+};
+
+static int
+__ipmi_sensor_set_threshold(struct ipmi_intf *intf,
+ uint8_t num, uint8_t mask, uint8_t setting,
+ uint8_t target, uint8_t lun, uint8_t channel)
+{
+ struct ipmi_rs *rsp;
+
+ rsp = ipmi_sensor_set_sensor_thresholds(intf, num, mask, setting,
+ target, lun, channel);
+
+ if (rsp == NULL) {
+ lprintf(LOG_ERR, "Error setting threshold");
+ return -1;
+ }
+ if (rsp->ccode > 0) {
+ lprintf(LOG_ERR, "Error setting threshold: %s",
+ val2str(rsp->ccode, completion_code_vals));
+ return -1;
+ }
+
+ return 0;
+}
+
+static uint8_t
+__ipmi_sensor_threshold_value_to_raw(struct sdr_record_full_sensor *full, double value)
+{
+ if (!UNITS_ARE_DISCRETE(&full->cmn)) { /* Has an analog reading */
+ /* Has an analog reading and supports mx+b */
+ return sdr_convert_sensor_value_to_raw(full, value);
+ }
+ else {
+ /* Does not have an analog reading and/or does not support mx+b */
+ if (value > 255) {
+ return 255;
+ }
+ else if (value < 0) {
+ return 0;
+ }
+ else {
+ return (uint8_t )value;
+ }
+ }
+}
+
+
+static int
+ipmi_sensor_set_threshold(struct ipmi_intf *intf, int argc, char **argv)
+{
+ char *id, *thresh;
+ uint8_t settingMask = 0;
+ double setting1 = 0.0, setting2 = 0.0, setting3 = 0.0;
+ int allUpper = 0, allLower = 0;
+ int ret = 0;
+ struct ipmi_rs *rsp;
+ int i =0;
+ double val[10] = {0};
+
+ struct sdr_record_list *sdr;
+
+ if (argc < 3 || strncmp(argv[0], "help", 4) == 0) {
+ lprintf(LOG_NOTICE, "sensor thresh <id> <threshold> <setting>");
+ lprintf(LOG_NOTICE,
+ " id : name of the sensor for which threshold is to be set");
+ lprintf(LOG_NOTICE, " threshold : which threshold to set");
+ lprintf(LOG_NOTICE,
+ " unr = upper non-recoverable");
+ lprintf(LOG_NOTICE, " ucr = upper critical");
+ lprintf(LOG_NOTICE,
+ " unc = upper non-critical");
+ lprintf(LOG_NOTICE,
+ " lnc = lower non-critical");
+ lprintf(LOG_NOTICE, " lcr = lower critical");
+ lprintf(LOG_NOTICE,
+ " lnr = lower non-recoverable");
+ lprintf(LOG_NOTICE,
+ " setting : the value to set the threshold to");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE,
+ "sensor thresh <id> lower <lnr> <lcr> <lnc>");
+ lprintf(LOG_NOTICE,
+ " Set all lower thresholds at the same time");
+ lprintf(LOG_NOTICE, "");
+ lprintf(LOG_NOTICE,
+ "sensor thresh <id> upper <unc> <ucr> <unr>");
+ lprintf(LOG_NOTICE,
+ " Set all upper thresholds at the same time");
+ lprintf(LOG_NOTICE, "");
+ return 0;
+ }
+
+ id = argv[0];
+ thresh = argv[1];
+
+ if (strncmp(thresh, "upper", 5) == 0) {
+ if (argc < 5) {
+ lprintf(LOG_ERR,
+ "usage: sensor thresh <id> upper <unc> <ucr> <unr>");
+ return -1;
+ }
+ allUpper = 1;
+ if (str2double(argv[2], &setting1) != 0) {
+ lprintf(LOG_ERR, "Given unc '%s' is invalid.",
+ argv[2]);
+ return (-1);
+ }
+ if (str2double(argv[3], &setting2) != 0) {
+ lprintf(LOG_ERR, "Given ucr '%s' is invalid.",
+ argv[3]);
+ return (-1);
+ }
+ if (str2double(argv[4], &setting3) != 0) {
+ lprintf(LOG_ERR, "Given unr '%s' is invalid.",
+ argv[4]);
+ return (-1);
+ }
+ } else if (strncmp(thresh, "lower", 5) == 0) {
+ if (argc < 5) {
+ lprintf(LOG_ERR,
+ "usage: sensor thresh <id> lower <unc> <ucr> <unr>");
+ return -1;
+ }
+ allLower = 1;
+ if (str2double(argv[2], &setting1) != 0) {
+ lprintf(LOG_ERR, "Given lnc '%s' is invalid.",
+ argv[2]);
+ return (-1);
+ }
+ if (str2double(argv[3], &setting2) != 0) {
+ lprintf(LOG_ERR, "Given lcr '%s' is invalid.",
+ argv[3]);
+ return (-1);
+ }
+ if (str2double(argv[4], &setting3) != 0) {
+ lprintf(LOG_ERR, "Given lnr '%s' is invalid.",
+ argv[4]);
+ return (-1);
+ }
+ } else {
+ if (strncmp(thresh, "unr", 3) == 0)
+ settingMask = UPPER_NON_RECOV_SPECIFIED;
+ else if (strncmp(thresh, "ucr", 3) == 0)
+ settingMask = UPPER_CRIT_SPECIFIED;
+ else if (strncmp(thresh, "unc", 3) == 0)
+ settingMask = UPPER_NON_CRIT_SPECIFIED;
+ else if (strncmp(thresh, "lnc", 3) == 0)
+ settingMask = LOWER_NON_CRIT_SPECIFIED;
+ else if (strncmp(thresh, "lcr", 3) == 0)
+ settingMask = LOWER_CRIT_SPECIFIED;
+ else if (strncmp(thresh, "lnr", 3) == 0)
+ settingMask = LOWER_NON_RECOV_SPECIFIED;
+ else {
+ lprintf(LOG_ERR,
+ "Valid threshold '%s' for sensor '%s' not specified!",
+ thresh, id);
+ return -1;
+ }
+ if (str2double(argv[2], &setting1) != 0) {
+ lprintf(LOG_ERR,
+ "Given %s threshold value '%s' is invalid.",
+ thresh, argv[2]);
+ return (-1);
+ }
+ }
+
+ printf("Locating sensor record '%s'...\n", id);
+
+ /* lookup by sensor name */
+ sdr = ipmi_sdr_find_sdr_byid(intf, id);
+ if (sdr == NULL) {
+ lprintf(LOG_ERR, "Sensor data record not found!");
+ return -1;
+ }
+
+ if (sdr->type != SDR_RECORD_TYPE_FULL_SENSOR) {
+ lprintf(LOG_ERR, "Invalid sensor type %02x", sdr->type);
+ return -1;
+ }
+
+ if (!IS_THRESHOLD_SENSOR(sdr->record.common)) {
+ lprintf(LOG_ERR, "Invalid sensor event type %02x", sdr->record.common->event_type);
+ return -1;
+ }
+
+
+ if (allUpper) {
+ settingMask = UPPER_NON_CRIT_SPECIFIED;
+ printf("Setting sensor \"%s\" %s threshold to %.3f\n",
+ sdr->record.full->id_string,
+ val2str(settingMask, threshold_vals), setting1);
+ ret = __ipmi_sensor_set_threshold(intf,
+ sdr->record.common->keys.
+ sensor_num, settingMask,
+ __ipmi_sensor_threshold_value_to_raw(sdr->record.full, setting1),
+ sdr->record.common->keys.owner_id,
+ sdr->record.common->keys.lun,
+ sdr->record.common->keys.channel);
+
+ settingMask = UPPER_CRIT_SPECIFIED;
+ printf("Setting sensor \"%s\" %s threshold to %.3f\n",
+ sdr->record.full->id_string,
+ val2str(settingMask, threshold_vals), setting2);
+ ret = __ipmi_sensor_set_threshold(intf,
+ sdr->record.common->keys.
+ sensor_num, settingMask,
+ __ipmi_sensor_threshold_value_to_raw(sdr->record.full, setting2),
+ sdr->record.common->keys.owner_id,
+ sdr->record.common->keys.lun,
+ sdr->record.common->keys.channel);
+
+ settingMask = UPPER_NON_RECOV_SPECIFIED;
+ printf("Setting sensor \"%s\" %s threshold to %.3f\n",
+ sdr->record.full->id_string,
+ val2str(settingMask, threshold_vals), setting3);
+ ret = __ipmi_sensor_set_threshold(intf,
+ sdr->record.common->keys.
+ sensor_num, settingMask,
+ __ipmi_sensor_threshold_value_to_raw(sdr->record.full, setting3),
+ sdr->record.common->keys.owner_id,
+ sdr->record.common->keys.lun,
+ sdr->record.common->keys.channel);
+ } else if (allLower) {
+ settingMask = LOWER_NON_RECOV_SPECIFIED;
+ printf("Setting sensor \"%s\" %s threshold to %.3f\n",
+ sdr->record.full->id_string,
+ val2str(settingMask, threshold_vals), setting1);
+ ret = __ipmi_sensor_set_threshold(intf,
+ sdr->record.common->keys.
+ sensor_num, settingMask,
+ __ipmi_sensor_threshold_value_to_raw(sdr->record.full, setting1),
+ sdr->record.common->keys.owner_id,
+ sdr->record.common->keys.lun,
+ sdr->record.common->keys.channel);
+
+ settingMask = LOWER_CRIT_SPECIFIED;
+ printf("Setting sensor \"%s\" %s threshold to %.3f\n",
+ sdr->record.full->id_string,
+ val2str(settingMask, threshold_vals), setting2);
+ ret = __ipmi_sensor_set_threshold(intf,
+ sdr->record.common->keys.
+ sensor_num, settingMask,
+ __ipmi_sensor_threshold_value_to_raw(sdr->record.full, setting2),
+ sdr->record.common->keys.owner_id,
+ sdr->record.common->keys.lun,
+ sdr->record.common->keys.channel);
+
+ settingMask = LOWER_NON_CRIT_SPECIFIED;
+ printf("Setting sensor \"%s\" %s threshold to %.3f\n",
+ sdr->record.full->id_string,
+ val2str(settingMask, threshold_vals), setting3);
+ ret = __ipmi_sensor_set_threshold(intf,
+ sdr->record.common->keys.
+ sensor_num, settingMask,
+ __ipmi_sensor_threshold_value_to_raw(sdr->record.full, setting3),
+ sdr->record.common->keys.owner_id,
+ sdr->record.common->keys.lun,
+ sdr->record.common->keys.channel);
+ } else {
+
+ /*
+ * Current implementation doesn't check for the valid setting of upper non critical and other thresholds.
+ * In the below logic:
+ * Get all the current reading of the sensor i.e. unc, uc, lc,lnc.
+ * Validate the values given by the user.
+ * If the values are not correct, then popup with the Error message and return.
+ */
+ /*
+ * Get current reading
+ */
+ rsp = ipmi_sdr_get_sensor_reading_ipmb(intf,
+ sdr->record.common->keys.sensor_num,
+ sdr->record.common->keys.owner_id,
+ sdr->record.common->keys.lun,sdr->record.common->keys.channel);
+ rsp = ipmi_sdr_get_sensor_thresholds(intf,
+ sdr->record.common->keys.sensor_num,
+ sdr->record.common->keys.owner_id,
+ sdr->record.common->keys.lun,
+ sdr->record.common->keys.channel);
+ if ((rsp == NULL) || (rsp->ccode > 0)) {
+ lprintf(LOG_ERR, "Sensor data record not found!");
+ return -1;
+ }
+ for(i=1;i<=6;i++) {
+ val[i] = sdr_convert_sensor_reading(sdr->record.full, rsp->data[i]);
+ if(val[i] < 0)
+ val[i] = 0;
+ }
+ /* Check for the valid Upper non recovarable Value.*/
+ if( (settingMask & UPPER_NON_RECOV_SPECIFIED) ) {
+
+ if( (rsp->data[0] & UPPER_NON_RECOV_SPECIFIED) &&
+ (( (rsp->data[0] & UPPER_CRIT_SPECIFIED) && ( setting1 <= val[5])) ||
+ ( (rsp->data[0] & UPPER_NON_CRIT_SPECIFIED) && ( setting1 <= val[4]))) )
+ {
+ lprintf(LOG_ERR, INVALID_THRESHOLD);
+ return -1;
+ }
+ } else if( (settingMask & UPPER_CRIT_SPECIFIED) ) { /* Check for the valid Upper critical Value.*/
+ if( (rsp->data[0] & UPPER_CRIT_SPECIFIED) &&
+ (((rsp->data[0] & UPPER_NON_RECOV_SPECIFIED)&& ( setting1 >= val[6])) ||
+ ((rsp->data[0] & UPPER_NON_CRIT_SPECIFIED)&&( setting1 <= val[4]))) )
+ {
+ lprintf(LOG_ERR, INVALID_THRESHOLD);
+ return -1;
+ }
+ } else if( (settingMask & UPPER_NON_CRIT_SPECIFIED) ) { /* Check for the valid Upper non critical Value.*/
+ if( (rsp->data[0] & UPPER_NON_CRIT_SPECIFIED) &&
+ (((rsp->data[0] & UPPER_NON_RECOV_SPECIFIED)&&( setting1 >= val[6])) ||
+ ((rsp->data[0] & UPPER_CRIT_SPECIFIED)&&( setting1 >= val[5])) ||
+ ((rsp->data[0] & LOWER_NON_CRIT_SPECIFIED)&&( setting1 <= val[1]))) )
+ {
+ lprintf(LOG_ERR, INVALID_THRESHOLD);
+ return -1;
+ }
+ } else if( (settingMask & LOWER_NON_CRIT_SPECIFIED) ) { /* Check for the valid lower non critical Value.*/
+ if( (rsp->data[0] & LOWER_NON_CRIT_SPECIFIED) &&
+ (((rsp->data[0] & LOWER_CRIT_SPECIFIED)&&( setting1 <= val[2])) ||
+ ((rsp->data[0] & LOWER_NON_RECOV_SPECIFIED)&&( setting1 <= val[3]))||
+ ((rsp->data[0] & UPPER_NON_CRIT_SPECIFIED)&&( setting1 >= val[4]))) )
+ {
+ lprintf(LOG_ERR, INVALID_THRESHOLD);
+ return -1;
+ }
+ } else if( (settingMask & LOWER_CRIT_SPECIFIED) ) { /* Check for the valid lower critical Value.*/
+ if( (rsp->data[0] & LOWER_CRIT_SPECIFIED) &&
+ (((rsp->data[0] & LOWER_NON_CRIT_SPECIFIED)&&( setting1 >= val[1])) ||
+ ((rsp->data[0] & LOWER_NON_RECOV_SPECIFIED)&&( setting1 <= val[3]))) )
+ {
+ lprintf(LOG_ERR, INVALID_THRESHOLD);
+ return -1;
+ }
+ } else if( (settingMask & LOWER_NON_RECOV_SPECIFIED) ) { /* Check for the valid lower non recovarable Value.*/
+ if( (rsp->data[0] & LOWER_NON_RECOV_SPECIFIED) &&
+ (((rsp->data[0] & LOWER_NON_CRIT_SPECIFIED)&&( setting1 >= val[1])) ||
+ ((rsp->data[0] & LOWER_CRIT_SPECIFIED)&&( setting1 >= val[2]))) )
+ {
+ lprintf(LOG_ERR, INVALID_THRESHOLD);
+ return -1;
+ }
+ } else { /* None of this Then Return with error messages.*/
+ lprintf(LOG_ERR, INVALID_THRESHOLD);
+ return -1;
+ }
+
+
+ printf("Setting sensor \"%s\" %s threshold to %.3f\n",
+ sdr->record.full->id_string,
+ val2str(settingMask, threshold_vals), setting1);
+
+ ret = __ipmi_sensor_set_threshold(intf,
+ sdr->record.common->keys.
+ sensor_num, settingMask,
+ __ipmi_sensor_threshold_value_to_raw(sdr->record.full, setting1),
+ sdr->record.common->keys.owner_id,
+ sdr->record.common->keys.lun,
+ sdr->record.common->keys.channel);
+ }
+
+ return ret;
+}
+
+static int
+ipmi_sensor_get_reading(struct ipmi_intf *intf, int argc, char **argv)
+{
+ struct sdr_record_list *sdr;
+ int i, rc=0;
+
+ if (argc < 1 || strncmp(argv[0], "help", 4) == 0) {
+ lprintf(LOG_NOTICE, "sensor reading <id> ... [id]");
+ lprintf(LOG_NOTICE, " id : name of desired sensor");
+ return -1;
+ }
+
+ for (i = 0; i < argc; i++) {
+ sdr = ipmi_sdr_find_sdr_byid(intf, argv[i]);
+ if (sdr == NULL) {
+ lprintf(LOG_ERR, "Sensor \"%s\" not found!",
+ argv[i]);
+ rc = -1;
+ continue;
+ }
+
+ switch (sdr->type) {
+ case SDR_RECORD_TYPE_FULL_SENSOR:
+ case SDR_RECORD_TYPE_COMPACT_SENSOR:
+ {
+ struct sensor_reading *sr;
+ struct sdr_record_common_sensor *sensor = sdr->record.common;
+ sr = ipmi_sdr_read_sensor_value(intf, sensor, sdr->type, 3);
+
+ if (sr == NULL) {
+ rc = -1;
+ continue;
+ }
+
+ if (!sr->full)
+ continue;
+
+ if (!sr->s_reading_valid)
+ continue;
+
+ if (!sr->s_has_analog_value) {
+ lprintf(LOG_ERR, "Sensor \"%s\" is a discrete sensor!", argv[i]);
+ continue;
+ }
+ if (csv_output)
+ printf("%s,%s\n", argv[i], sr->s_a_str);
+ else
+ printf("%-16s | %s\n", argv[i], sr->s_a_str);
+
+ break;
+ }
+ default:
+ continue;
+ }
+ }
+
+ return rc;
+}
+
+static int
+ipmi_sensor_get(struct ipmi_intf *intf, int argc, char **argv)
+{
+ int i, v;
+ int rc = 0;
+ struct sdr_record_list *sdr;
+
+ if (argc < 1) {
+ lprintf(LOG_ERR, "Not enough parameters given.");
+ printf_sensor_get_usage();
+ return (-1);
+ } else if (strcmp(argv[0], "help") == 0) {
+ printf_sensor_get_usage();
+ return 0;
+ }
+ printf("Locating sensor record...\n");
+ /* lookup by sensor name */
+ for (i = 0; i < argc; i++) {
+ sdr = ipmi_sdr_find_sdr_byid(intf, argv[i]);
+ if (sdr == NULL) {
+ lprintf(LOG_ERR, "Sensor data record \"%s\" not found!",
+ argv[i]);
+ rc = -1;
+ continue;
+ }
+ /* need to set verbose level to 1 */
+ v = verbose;
+ verbose = 1;
+ if (ipmi_sdr_print_listentry(intf, sdr) < 0) {
+ rc = (-1);
+ }
+ verbose = v;
+ sdr = NULL;
+ }
+ return rc;
+}
+
+int
+ipmi_sensor_main(struct ipmi_intf *intf, int argc, char **argv)
+{
+ int rc = 0;
+
+ if (argc == 0) {
+ rc = ipmi_sensor_list(intf);
+ } else if (strncmp(argv[0], "help", 4) == 0) {
+ lprintf(LOG_NOTICE, "Sensor Commands: list thresh get reading");
+ } else if (strncmp(argv[0], "list", 4) == 0) {
+ rc = ipmi_sensor_list(intf);
+ } else if (strncmp(argv[0], "thresh", 5) == 0) {
+ rc = ipmi_sensor_set_threshold(intf, argc - 1, &argv[1]);
+ } else if (strncmp(argv[0], "get", 3) == 0) {
+ rc = ipmi_sensor_get(intf, argc - 1, &argv[1]);
+ } else if (strncmp(argv[0], "reading", 7) == 0) {
+ rc = ipmi_sensor_get_reading(intf, argc - 1, &argv[1]);
+ } else {
+ lprintf(LOG_ERR, "Invalid sensor command: %s", argv[0]);
+ rc = -1;
+ }
+
+ return rc;
+}
+
+/* printf_sensor_get_usage - print usage for # ipmitool sensor get NAC;
+ *
+ * @returns: void
+ */
+void
+printf_sensor_get_usage()
+{
+ lprintf(LOG_NOTICE, "sensor get <id> ... [id]");
+ lprintf(LOG_NOTICE, " id : name of desired sensor");
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-15 16:20:01 +0000