Main Page | Class List | Directories | File List | Class Members | File Members
cmdlang

cmd_sensor.c File Reference

#include <errno.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <OpenIPMI/ipmiif.h>
#include <OpenIPMI/ipmi_cmdlang.h>
#include <OpenIPMI/internal/ipmi_malloc.h>

Go to the source code of this file.

Defines

#define CMDS_SENSOR_LEN   (sizeof(cmds_sensor)/sizeof(ipmi_cmdlang_init_t))

Enumerations

enum  ev_en_kind { ev_en_set, ev_en_enable, ev_en_disable }

Functions

static void sensor_list_handler (ipmi_entity_t *entity, ipmi_sensor_t *sensor, void *cb_data)
static void sensor_list (ipmi_entity_t *entity, void *cb_data)
static void sensor_dump (ipmi_sensor_t *sensor, ipmi_cmd_info_t *cmd_info)
static void sensor_info (ipmi_sensor_t *sensor, void *cb_data)
static void read_sensor (ipmi_sensor_t *sensor, int err, enum ipmi_value_present_e value_present, unsigned int raw_val, double val, ipmi_states_t *states, void *cb_data)
static void read_sensor_states (ipmi_sensor_t *sensor, int err, ipmi_states_t *states, void *cb_data)
static void sensor_get (ipmi_sensor_t *sensor, void *cb_data)
static void sensor_rearm_done (ipmi_sensor_t *sensor, int err, void *cb_data)
static void sensor_rearm (ipmi_sensor_t *sensor, void *cb_data)
static void sensor_get_thresholds_done (ipmi_sensor_t *sensor, int err, ipmi_thresholds_t *th, void *cb_data)
static void sensor_get_thresholds (ipmi_sensor_t *sensor, void *cb_data)
static void sensor_set_thresholds_done (ipmi_sensor_t *sensor, int err, void *cb_data)
static void sensor_set_thresholds (ipmi_sensor_t *sensor, void *cb_data)
static void sensor_get_hysteresis_done (ipmi_sensor_t *sensor, int err, unsigned int positive_hysteresis, unsigned int negative_hysteresis, void *cb_data)
static void sensor_get_hysteresis (ipmi_sensor_t *sensor, void *cb_data)
static void sensor_set_hysteresis_done (ipmi_sensor_t *sensor, int err, void *cb_data)
static void sensor_set_hysteresis (ipmi_sensor_t *sensor, void *cb_data)
static void sensor_get_event_enables_done (ipmi_sensor_t *sensor, int err, ipmi_event_state_t *states, void *cb_data)
static void sensor_get_event_enables (ipmi_sensor_t *sensor, void *cb_data)
static void sensor_set_event_enables_done (ipmi_sensor_t *sensor, int err, void *cb_data)
static void mod_event_enables (ipmi_sensor_t *sensor, void *cb_data, enum ev_en_kind kind)
static void sensor_set_event_enables (ipmi_sensor_t *sensor, void *cb_data)
static void sensor_enable_events (ipmi_sensor_t *sensor, void *cb_data)
static void sensor_disable_events (ipmi_sensor_t *sensor, void *cb_data)
static int sensor_discrete_event_handler (ipmi_sensor_t *sensor, enum ipmi_event_dir_e dir, int offset, int severity, int prev_severity, void *cb_data, ipmi_event_t *event)
static int sensor_threshold_event_handler (ipmi_sensor_t *sensor, enum ipmi_event_dir_e dir, enum ipmi_thresh_e threshold, enum ipmi_event_value_dir_e high_low, enum ipmi_value_present_e value_present, unsigned int raw_value, double value, void *cb_data, ipmi_event_t *event)
void ipmi_cmdlang_sensor_change (enum ipmi_update_e op, ipmi_entity_t *entity, ipmi_sensor_t *sensor, void *cb_data)
int ipmi_cmdlang_sensor_init (os_handler_t *os_hnd)

Variables

static ipmi_cmdlang_cmd_t * sensor_cmds
static ipmi_cmdlang_init_t cmds_sensor []

Define Documentation

#define CMDS_SENSOR_LEN   (sizeof(cmds_sensor)/sizeof(ipmi_cmdlang_init_t))
 

Definition at line 1462 of file cmd_sensor.c.

Referenced by ipmi_cmdlang_sensor_init().

Enumeration Type Documentation

enum ev_en_kind
 

Enumerator:
ev_en_set 
ev_en_enable 
ev_en_disable 

Definition at line 1070 of file cmd_sensor.c.

01070 { ev_en_set, ev_en_enable, ev_en_disable };

Function Documentation

void ipmi_cmdlang_sensor_change (  enum ipmi_update_e  op,
ipmi_entity_t *  entity,
ipmi_sensor_t *  sensor,
void *  cb_data
) 
 

Definition at line 1316 of file cmd_sensor.c.

References IPMI_ADDED, IPMI_CHANGED, ipmi_cmdlang_alloc_event_info(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_get_evinfo(), ipmi_cmdlang_global_err(), ipmi_cmdlang_out(), IPMI_DELETED, IPMI_EVENT_READING_TYPE_THRESHOLD, ipmi_sensor_add_discrete_event_handler(), ipmi_sensor_add_threshold_event_handler(), ipmi_sensor_get_event_reading_type(), ipmi_sensor_get_name(), IPMI_SENSOR_NAME_LEN, sensor_discrete_event_handler(), sensor_dump(), and sensor_threshold_event_handler().

Referenced by ipmi_cmdlang_entity_change().

01320 {
01321     char            *errstr;
01322     int             rv;
01323     ipmi_cmd_info_t *evi;
01324     char            sensor_name[IPMI_SENSOR_NAME_LEN];
01325 
01326     ipmi_sensor_get_name(sensor, sensor_name, sizeof(sensor_name));
01327 
01328     evi = ipmi_cmdlang_alloc_event_info();
01329     if (!evi) {
01330         rv = ENOMEM;
01331         errstr = "Out of memory";
01332         goto out_err;
01333     }
01334 
01335     ipmi_cmdlang_out(evi, "Object Type", "Sensor");
01336     ipmi_cmdlang_out(evi, "Name", sensor_name);
01337 
01338     switch (op) {
01339     case IPMI_ADDED:
01340         ipmi_cmdlang_out(evi, "Operation", "Add");
01341         if (ipmi_cmdlang_get_evinfo())
01342             sensor_dump(sensor, evi);
01343 
01344         if (ipmi_sensor_get_event_reading_type(sensor)
01345             == IPMI_EVENT_READING_TYPE_THRESHOLD)
01346         {
01347             rv = ipmi_sensor_add_threshold_event_handler
01348                 (sensor,
01349                  sensor_threshold_event_handler,
01350                  NULL);
01351         } else {
01352             rv = ipmi_sensor_add_discrete_event_handler
01353                 (sensor,
01354                  sensor_discrete_event_handler,
01355                  NULL);
01356         }
01357         if (rv) {
01358             ipmi_cmdlang_global_err(sensor_name,
01359                                     "cmd_sensor.c(ipmi_cmdlang_sensor_change)",
01360                                     "Unable to set event handler for sensor",
01361                                     rv);
01362         }
01363         break;
01364 
01365         case IPMI_DELETED:
01366             ipmi_cmdlang_out(evi, "Operation", "Delete");
01367             break;
01368 
01369         case IPMI_CHANGED:
01370             ipmi_cmdlang_out(evi, "Operation", "Change");
01371             if (ipmi_cmdlang_get_evinfo())
01372                 sensor_dump(sensor, evi);
01373             break;
01374     }
01375 
01376     ipmi_cmdlang_cmd_info_put(evi);
01377     return;
01378 
01379  out_err:
01380     ipmi_cmdlang_global_err(sensor_name,
01381                             "cmd_sensor.c(ipmi_cmdlang_sensor_change)",
01382                             errstr, rv);
01383     if (evi)
01384         ipmi_cmdlang_cmd_info_put(evi);
01385 }

int ipmi_cmdlang_sensor_init (  os_handler_t *  os_hnd  ) 
 

Definition at line 1465 of file cmd_sensor.c.

References CMDS_SENSOR_LEN, and ipmi_cmdlang_reg_table().

Referenced by ipmi_cmdlang_init().

01466 {
01467     return ipmi_cmdlang_reg_table(cmds_sensor, CMDS_SENSOR_LEN);
01468 }

static void mod_event_enables (  ipmi_sensor_t *  sensor,
void *  cb_data,
enum ev_en_kind  kind
)  [static]
 

Definition at line 1073 of file cmd_sensor.c.

References cmdlang, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, ev_en_disable, ev_en_enable, ev_en_set, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_cmd_info_get(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_get_argc(), ipmi_cmdlang_get_argv(), ipmi_cmdlang_get_curr_arg(), ipmi_cmdlang_get_discrete_ev(), ipmi_cmdlang_get_threshold_ev(), ipmi_discrete_event_set(), IPMI_EVENT_READING_TYPE_THRESHOLD, ipmi_event_state_init(), ipmi_event_state_set_events_enabled(), ipmi_event_state_set_scanning_enabled(), ipmi_mem_alloc(), ipmi_mem_free(), ipmi_sensor_disable_events(), ipmi_sensor_enable_events(), ipmi_sensor_get_event_reading_type(), ipmi_sensor_get_name(), ipmi_sensor_set_event_enables(), ipmi_states_size(), ipmi_threshold_event_set(), ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, ipmi_cmdlang_s::objstr_len, s, and sensor_set_event_enables_done().

Referenced by sensor_disable_events(), sensor_enable_events(), and sensor_set_event_enables().

01074 {
01075     ipmi_cmd_info_t    *cmd_info = cb_data;
01076     ipmi_cmdlang_t     *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
01077     int                rv;
01078     int                curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
01079     int                argc = ipmi_cmdlang_get_argc(cmd_info);
01080     char               **argv = ipmi_cmdlang_get_argv(cmd_info);
01081     ipmi_event_state_t *s = NULL;
01082 
01083     if ((argc - curr_arg) < 2) {
01084         /* Not enough parameters */
01085         cmdlang->errstr = "Not enough parameters";
01086         cmdlang->err = EINVAL;
01087         goto out_err;
01088     }
01089 
01090     s = ipmi_mem_alloc(ipmi_states_size());
01091     if (!s) {
01092         cmdlang->errstr = "Out of memory";
01093         cmdlang->err = ENOMEM;
01094         goto out_err;
01095     }
01096     ipmi_event_state_init(s);
01097 
01098     if (strcmp(argv[curr_arg], "msg") == 0)
01099         ipmi_event_state_set_events_enabled(s, 1);
01100     else if (strcmp(argv[curr_arg], "nomsg") == 0)
01101         ipmi_event_state_set_events_enabled(s, 0);
01102     else {
01103         cmdlang->errstr = "Invalid message enable setting";
01104         cmdlang->err = EINVAL;
01105         goto out_err;
01106     }
01107     curr_arg++;
01108 
01109     if (strcmp(argv[curr_arg], "scan") == 0)
01110         ipmi_event_state_set_scanning_enabled(s, 1);
01111     else if (strcmp(argv[curr_arg], "noscan") == 0)
01112         ipmi_event_state_set_scanning_enabled(s, 0);
01113     else {
01114         cmdlang->errstr = "Invalid scanning enable setting";
01115         cmdlang->err = EINVAL;
01116         goto out_err;
01117     }
01118     curr_arg++;
01119 
01120     if (ipmi_sensor_get_event_reading_type(sensor)
01121         == IPMI_EVENT_READING_TYPE_THRESHOLD)
01122     {
01123         while (curr_arg < argc) {
01124             enum ipmi_thresh_e          thresh;
01125             enum ipmi_event_value_dir_e value_dir;
01126             enum ipmi_event_dir_e       dir;
01127 
01128             ipmi_cmdlang_get_threshold_ev(argv[curr_arg], &thresh,
01129                                           &value_dir, &dir, cmd_info);
01130             if (cmdlang->err) {
01131                 goto out_err;
01132             }
01133             ipmi_threshold_event_set(s, thresh, value_dir, dir);
01134             curr_arg++;
01135         }
01136     } else {
01137         while (curr_arg < argc) {
01138             int                   offset;
01139             enum ipmi_event_dir_e dir;
01140 
01141             ipmi_cmdlang_get_discrete_ev(argv[curr_arg], &offset,
01142                                          &dir, cmd_info);
01143             if (cmdlang->err) {
01144                 goto out_err;
01145             }
01146             ipmi_discrete_event_set(s, offset, dir);
01147             curr_arg++;
01148         }
01149     }
01150 
01151     ipmi_cmdlang_cmd_info_get(cmd_info);
01152     switch (kind) {
01153     case ev_en_set:
01154         rv = ipmi_sensor_set_event_enables(sensor, s,
01155                                            sensor_set_event_enables_done,
01156                                            cmd_info);
01157         break;
01158     case ev_en_enable:
01159         rv = ipmi_sensor_enable_events(sensor, s,
01160                                        sensor_set_event_enables_done,
01161                                        cmd_info);
01162         break;
01163     case ev_en_disable:
01164         rv = ipmi_sensor_disable_events(sensor, s,
01165                                         sensor_set_event_enables_done,
01166                                         cmd_info);
01167         break;
01168     default:
01169         rv = EINVAL;
01170     }
01171 
01172     if (rv) {
01173         ipmi_cmdlang_cmd_info_put(cmd_info);
01174         cmdlang->err = rv;
01175         cmdlang->errstr = "Error setting event enables";
01176         goto out_err;
01177     }
01178     ipmi_mem_free(s);
01179     return;
01180 
01181  out_err:
01182     ipmi_sensor_get_name(sensor, cmdlang->objstr,
01183                          cmdlang->objstr_len);
01184     cmdlang->location = "cmd_sensor.c(sensor_set_event_enables)";
01185     if (s)
01186         ipmi_mem_free(s);
01187 }

static void read_sensor (  ipmi_sensor_t *  sensor,
int  err,
enum ipmi_value_present_e  value_present,
unsigned int  raw_val,
double  val,
ipmi_states_t *  states,
void *  cb_data
)  [static]
 

Definition at line 331 of file cmd_sensor.c.

References cmdlang, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, IPMI_BOTH_VALUES_PRESENT, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_down(), ipmi_cmdlang_lock(), ipmi_cmdlang_out(), ipmi_cmdlang_out_bool(), ipmi_cmdlang_out_double(), ipmi_cmdlang_out_hex(), ipmi_cmdlang_unlock(), ipmi_cmdlang_up(), ipmi_get_threshold_string(), ipmi_is_event_messages_enabled(), ipmi_is_initial_update_in_progress(), ipmi_is_sensor_scanning_enabled(), ipmi_is_threshold_out_of_range(), IPMI_LOWER_NON_CRITICAL, IPMI_RAW_VALUE_PRESENT, ipmi_sensor_get_name(), IPMI_SENSOR_NAME_LEN, ipmi_sensor_threshold_reading_supported(), IPMI_UPPER_NON_RECOVERABLE, ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, and ipmi_cmdlang_s::objstr_len.

Referenced by redisplay_sensor(), sensor_get(), and sensor_handler().

00338 {
00339     ipmi_cmd_info_t    *cmd_info = cb_data;
00340     ipmi_cmdlang_t     *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
00341     enum ipmi_thresh_e thresh;
00342     char               sensor_name[IPMI_SENSOR_NAME_LEN];
00343     int                rv;
00344 
00345     ipmi_cmdlang_lock(cmd_info);
00346     if (err) {
00347         cmdlang->errstr = "Error reading sensor";
00348         cmdlang->err = err;
00349         ipmi_sensor_get_name(sensor, cmdlang->objstr,
00350                              cmdlang->objstr_len);
00351         cmdlang->location = "cmd_sensor.c(read_sensor)";
00352         goto out;
00353     }
00354 
00355     ipmi_sensor_get_name(sensor, sensor_name, sizeof(sensor_name));
00356 
00357     ipmi_cmdlang_out(cmd_info, "Sensor", NULL);
00358     ipmi_cmdlang_down(cmd_info);
00359     ipmi_cmdlang_out(cmd_info, "Name", sensor_name);
00360 
00361     ipmi_cmdlang_out_bool(cmd_info, "Event Messages Enabled",
00362                           ipmi_is_event_messages_enabled(states));
00363     ipmi_cmdlang_out_bool(cmd_info, "Sensor Scanning Enabled",
00364                           ipmi_is_sensor_scanning_enabled(states));
00365     ipmi_cmdlang_out_bool(cmd_info, "Initial Update In Progress",
00366                           ipmi_is_initial_update_in_progress(states));
00367 
00368     switch (value_present) {
00369     case IPMI_BOTH_VALUES_PRESENT:
00370         ipmi_cmdlang_out_double(cmd_info, "Value", val);
00371         /* FALLTHRU */
00372     case IPMI_RAW_VALUE_PRESENT:
00373         ipmi_cmdlang_out_hex(cmd_info, "Raw Value", raw_val);
00374     default:
00375         break;
00376     }   
00377 
00378     for (thresh = IPMI_LOWER_NON_CRITICAL;
00379          thresh <= IPMI_UPPER_NON_RECOVERABLE; 
00380          thresh++)
00381     {
00382         int ival;
00383 
00384         rv = ipmi_sensor_threshold_reading_supported(sensor, thresh, &ival);
00385         if ((rv) || !ival)
00386             continue;
00387 
00388         ipmi_cmdlang_out(cmd_info, "Threshold", NULL);
00389         ipmi_cmdlang_down(cmd_info);
00390         ipmi_cmdlang_out(cmd_info, "Name",
00391                          ipmi_get_threshold_string(thresh));
00392         ipmi_cmdlang_out_bool(cmd_info, "Out Of Range",
00393                               ipmi_is_threshold_out_of_range(states, thresh));
00394         ipmi_cmdlang_up(cmd_info);
00395     }
00396     ipmi_cmdlang_up(cmd_info);
00397 
00398  out:
00399     ipmi_cmdlang_unlock(cmd_info);
00400     ipmi_cmdlang_cmd_info_put(cmd_info);
00401 }

static void read_sensor_states (  ipmi_sensor_t *  sensor,
int  err,
ipmi_states_t *  states,
void *  cb_data
)  [static]
 

Definition at line 404 of file cmd_sensor.c.

References cmdlang, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, i, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_down(), ipmi_cmdlang_lock(), ipmi_cmdlang_out(), ipmi_cmdlang_out_bool(), ipmi_cmdlang_out_int(), ipmi_cmdlang_unlock(), ipmi_cmdlang_up(), ipmi_is_event_messages_enabled(), ipmi_is_initial_update_in_progress(), ipmi_is_sensor_scanning_enabled(), ipmi_is_state_set(), ipmi_sensor_discrete_event_readable(), ipmi_sensor_get_name(), IPMI_SENSOR_NAME_LEN, ipmi_sensor_reading_name_string(), ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, and ipmi_cmdlang_s::objstr_len.

Referenced by sensor_get().

00408 {
00409     ipmi_cmd_info_t *cmd_info = cb_data;
00410     ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
00411     int             i;
00412     char            sensor_name[IPMI_SENSOR_NAME_LEN];
00413     int             rv;
00414 
00415     ipmi_cmdlang_lock(cmd_info);
00416     if (err) {
00417         cmdlang->errstr = "Error reading sensor";
00418         cmdlang->err = err;
00419         ipmi_sensor_get_name(sensor, cmdlang->objstr,
00420                              cmdlang->objstr_len);
00421         cmdlang->location = "cmd_sensor.c(read_sensor_states)";
00422         goto out;
00423     }
00424 
00425     ipmi_sensor_get_name(sensor, sensor_name, sizeof(sensor_name));
00426 
00427     ipmi_cmdlang_out(cmd_info, "Sensor", NULL);
00428     ipmi_cmdlang_down(cmd_info);
00429     ipmi_cmdlang_out(cmd_info, "Name", sensor_name);
00430 
00431     ipmi_cmdlang_out_bool(cmd_info, "Event Messages Enabled",
00432                           ipmi_is_event_messages_enabled(states));
00433     ipmi_cmdlang_out_bool(cmd_info, "Sensor Scanning Enabled",
00434                           ipmi_is_sensor_scanning_enabled(states));
00435     ipmi_cmdlang_out_bool(cmd_info, "Initial Update In Progress",
00436                           ipmi_is_initial_update_in_progress(states));
00437     for (i=0; i<15; i++) {
00438         int        ival;
00439         const char *str;
00440 
00441         rv = ipmi_sensor_discrete_event_readable(sensor, i, &ival);
00442         if ((rv) || !ival)
00443             continue;
00444 
00445         ipmi_cmdlang_out(cmd_info, "Event", NULL);
00446         ipmi_cmdlang_down(cmd_info);
00447         ipmi_cmdlang_out_int(cmd_info, "Offset", i);
00448         str = ipmi_sensor_reading_name_string(sensor, i);
00449         if (strcmp(str, "unknown") != 0)
00450             ipmi_cmdlang_out(cmd_info, "Name", str);
00451         ipmi_cmdlang_out_bool(cmd_info, "Set", ipmi_is_state_set(states, i));
00452         ipmi_cmdlang_up(cmd_info);
00453     }
00454     ipmi_cmdlang_up(cmd_info);
00455 
00456  out:
00457     ipmi_cmdlang_unlock(cmd_info);
00458     ipmi_cmdlang_cmd_info_put(cmd_info);
00459 }

static void sensor_disable_events (  ipmi_sensor_t *  sensor,
void *  cb_data
)  [static]
 

Definition at line 1202 of file cmd_sensor.c.

References ev_en_disable, and mod_event_enables().

01203 {
01204     mod_event_enables(sensor, cb_data, ev_en_disable);
01205 }

static int sensor_discrete_event_handler (  ipmi_sensor_t *  sensor,
enum ipmi_event_dir_e  dir,
int  offset,
int  severity,
int  prev_severity,
void *  cb_data,
ipmi_event_t *  event
)  [static]
 

Definition at line 1208 of file cmd_sensor.c.

References ipmi_cmdlang_alloc_event_info(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_down(), ipmi_cmdlang_event_out(), ipmi_cmdlang_global_err(), ipmi_cmdlang_out(), ipmi_cmdlang_out_int(), ipmi_cmdlang_up(), IPMI_EVENT_NOT_HANDLED, ipmi_get_event_dir_string(), ipmi_sensor_get_name(), and IPMI_SENSOR_NAME_LEN.

Referenced by ipmi_cmdlang_sensor_change(), and sensor_change().

01215 {
01216     ipmi_cmd_info_t *evi;
01217     char            sensor_name[IPMI_SENSOR_NAME_LEN];
01218     int             rv;
01219     char            *errstr;
01220 
01221     ipmi_sensor_get_name(sensor, sensor_name, sizeof(sensor_name));
01222 
01223     evi = ipmi_cmdlang_alloc_event_info();
01224     if (!evi) {
01225         rv = ENOMEM;
01226         errstr = "Out of memory";
01227         goto out_err;
01228     }
01229 
01230     ipmi_cmdlang_out(evi, "Object Type", "Sensor");
01231     ipmi_cmdlang_out(evi, "Name", sensor_name);
01232     ipmi_cmdlang_out(evi, "Operation", "Event");
01233     ipmi_cmdlang_out_int(evi, "Offset", offset);
01234     ipmi_cmdlang_out(evi, "Direction", ipmi_get_event_dir_string(dir));
01235     ipmi_cmdlang_out_int(evi, "Severity", severity);
01236     ipmi_cmdlang_out_int(evi, "Previous Severity", prev_severity);
01237     if (event) {
01238         ipmi_cmdlang_out(evi, "Event", NULL);
01239         ipmi_cmdlang_down(evi);
01240         ipmi_cmdlang_event_out(event, evi);
01241         ipmi_cmdlang_up(evi);
01242     }
01243     ipmi_cmdlang_cmd_info_put(evi);
01244     return IPMI_EVENT_NOT_HANDLED;
01245 
01246  out_err:
01247     ipmi_cmdlang_global_err(sensor_name,
01248                             "cmd_sensor.c(sensor_discrete_event_handler)",
01249                             errstr, rv);
01250     if (evi)
01251         ipmi_cmdlang_cmd_info_put(evi);
01252     return IPMI_EVENT_NOT_HANDLED;
01253 }

static void sensor_dump (  ipmi_sensor_t *  sensor,
ipmi_cmd_info_t *  cmd_info
)  [static]
 

Definition at line 79 of file cmd_sensor.c.

References cmdlang, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, IPMI_ASSERTION, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_down(), ipmi_cmdlang_out(), ipmi_cmdlang_out_bool(), ipmi_cmdlang_out_double(), ipmi_cmdlang_out_int(), ipmi_cmdlang_out_type(), ipmi_cmdlang_up(), IPMI_DEASSERTION, IPMI_EVENT_READING_TYPE_THRESHOLD, IPMI_EVENT_SUPPORT_ENTIRE_SENSOR, IPMI_EVENT_SUPPORT_GLOBAL_ENABLE, IPMI_EVENT_SUPPORT_PER_STATE, ipmi_get_event_dir_string(), ipmi_get_hysteresis_support_string(), ipmi_get_sensor_direction_string(), ipmi_get_threshold_access_support_string(), ipmi_get_threshold_string(), ipmi_get_value_dir_string(), IPMI_GOING_HIGH, IPMI_GOING_LOW, IPMI_LOWER_NON_CRITICAL, ipmi_mem_alloc(), ipmi_mem_free(), IPMI_MODIFIER_UNIT_BASE_DIV_MOD, IPMI_MODIFIER_UNIT_BASE_MULT_MOD, IPMI_SENSOR_DIRECTION_UNSPECIFIED, ipmi_sensor_discrete_event_readable(), ipmi_sensor_discrete_event_supported(), ipmi_sensor_get_accuracy(), ipmi_sensor_get_base_unit(), ipmi_sensor_get_base_unit_string(), ipmi_sensor_get_event_reading_type(), ipmi_sensor_get_event_reading_type_string(), ipmi_sensor_get_event_support(), ipmi_sensor_get_hysteresis_support(), ipmi_sensor_get_id(), ipmi_sensor_get_id_length(), ipmi_sensor_get_id_type(), ipmi_sensor_get_ignore_if_no_entity(), ipmi_sensor_get_modifier_unit(), ipmi_sensor_get_modifier_unit_string(), ipmi_sensor_get_modifier_unit_use(), ipmi_sensor_get_name(), ipmi_sensor_get_nominal_reading(), ipmi_sensor_get_normal_max(), ipmi_sensor_get_normal_min(), ipmi_sensor_get_num(), ipmi_sensor_get_oem1(), ipmi_sensor_get_percentage(), ipmi_sensor_get_rate_unit(), ipmi_sensor_get_rate_unit_string(), ipmi_sensor_get_sensor_direction(), ipmi_sensor_get_sensor_init_events(), ipmi_sensor_get_sensor_init_hysteresis(), ipmi_sensor_get_sensor_init_pu_events(), ipmi_sensor_get_sensor_init_pu_scanning(), ipmi_sensor_get_sensor_init_scanning(), ipmi_sensor_get_sensor_init_thresholds(), ipmi_sensor_get_sensor_init_type(), ipmi_sensor_get_sensor_max(), ipmi_sensor_get_sensor_min(), ipmi_sensor_get_sensor_type(), ipmi_sensor_get_sensor_type_string(), ipmi_sensor_get_supports_auto_rearm(), ipmi_sensor_get_threshold_access(), ipmi_sensor_reading_name_string(), ipmi_sensor_threshold_event_supported(), ipmi_sensor_threshold_readable(), ipmi_sensor_threshold_reading_supported(), ipmi_sensor_threshold_settable(), IPMI_UPPER_NON_RECOVERABLE, ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, and ipmi_cmdlang_s::objstr_len.

Referenced by ipmi_cmdlang_sensor_change(), and sensor_info().

00080 {
00081     ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
00082     int             num, lun;
00083     char            *str;
00084     const char      *cstr;
00085     int             event_support;
00086     int             event_reading_type;
00087     int             len;
00088     int             rv;
00089     int             val;
00090 
00091     event_reading_type = ipmi_sensor_get_event_reading_type(sensor);
00092 
00093     ipmi_sensor_get_num(sensor, &lun, &num);
00094     ipmi_cmdlang_out_int(cmd_info, "LUN", lun);
00095     ipmi_cmdlang_out_int(cmd_info, "Number", num);
00096     ipmi_cmdlang_out_int(cmd_info, "Event Reading Type",
00097                      ipmi_sensor_get_event_reading_type(sensor));
00098     ipmi_cmdlang_out(cmd_info, "Event Reading Type Name",
00099                      ipmi_sensor_get_event_reading_type_string(sensor));
00100     ipmi_cmdlang_out_int(cmd_info, "Type",
00101                          ipmi_sensor_get_sensor_type(sensor));
00102     ipmi_cmdlang_out(cmd_info, "Type Name",
00103                      ipmi_sensor_get_sensor_type_string(sensor));
00104     val = ipmi_sensor_get_sensor_direction(sensor);
00105     if (val != IPMI_SENSOR_DIRECTION_UNSPECIFIED)
00106         ipmi_cmdlang_out(cmd_info, "Direction",
00107                          ipmi_get_sensor_direction_string(val));
00108     
00109     event_support = ipmi_sensor_get_event_support(sensor);
00110     switch (event_support) {
00111     case IPMI_EVENT_SUPPORT_PER_STATE:
00112         ipmi_cmdlang_out(cmd_info, "Event Support", "per state");
00113         break;
00114     case IPMI_EVENT_SUPPORT_ENTIRE_SENSOR:
00115         ipmi_cmdlang_out(cmd_info, "Event Support", "entire sensor");
00116         break;
00117     case IPMI_EVENT_SUPPORT_GLOBAL_ENABLE:
00118         ipmi_cmdlang_out(cmd_info, "Event Support", "global");
00119         break;
00120     default:
00121         break;
00122     }
00123 
00124     ipmi_cmdlang_out_bool(cmd_info, "Init Scanning",
00125                          ipmi_sensor_get_sensor_init_scanning(sensor));
00126     ipmi_cmdlang_out_bool(cmd_info, "Init Events",
00127                          ipmi_sensor_get_sensor_init_events(sensor));
00128     ipmi_cmdlang_out_bool(cmd_info, "Init Thresholds",
00129                          ipmi_sensor_get_sensor_init_thresholds(sensor));
00130     ipmi_cmdlang_out_bool(cmd_info, "Init Hysteresis",
00131                          ipmi_sensor_get_sensor_init_hysteresis(sensor));
00132     ipmi_cmdlang_out_bool(cmd_info, "Init Type",
00133                          ipmi_sensor_get_sensor_init_type(sensor));
00134     ipmi_cmdlang_out_bool(cmd_info, "Init Power Up Events",
00135                          ipmi_sensor_get_sensor_init_pu_events(sensor));
00136     ipmi_cmdlang_out_bool(cmd_info, "Init Power Up Scanning",
00137                          ipmi_sensor_get_sensor_init_pu_scanning(sensor));
00138 
00139     ipmi_cmdlang_out_bool(cmd_info, "Ignore If No Entity",
00140                          ipmi_sensor_get_ignore_if_no_entity(sensor));
00141     ipmi_cmdlang_out_bool(cmd_info, "Auto Rearm",
00142                          ipmi_sensor_get_supports_auto_rearm(sensor));
00143     ipmi_cmdlang_out_int(cmd_info, "OEM1",
00144                          ipmi_sensor_get_oem1(sensor));
00145 
00146     len = ipmi_sensor_get_id_length(sensor);
00147     if (len) {
00148         str = ipmi_mem_alloc(len);
00149         if (!str) {
00150             cmdlang->err = ENOMEM;
00151             cmdlang->errstr = "Out of memory";
00152             goto out_err;
00153         }
00154         len = ipmi_sensor_get_id(sensor, str, len);
00155         ipmi_cmdlang_out_type(cmd_info, "Id",
00156                               ipmi_sensor_get_id_type(sensor),
00157                               str, len);
00158         ipmi_mem_free(str);
00159     }
00160 
00161     if (event_reading_type == IPMI_EVENT_READING_TYPE_THRESHOLD) {
00162         int access = ipmi_sensor_get_threshold_access(sensor);
00163         enum ipmi_thresh_e          thresh;
00164         enum ipmi_event_value_dir_e value_dir;
00165         enum ipmi_event_dir_e       dir;
00166         int                         rv;
00167         char                        th_name[50];
00168         double                      dval;
00169 
00170         ipmi_cmdlang_out(cmd_info, "Threshold Access",
00171                          ipmi_get_threshold_access_support_string(access));
00172 
00173         for (thresh = IPMI_LOWER_NON_CRITICAL;
00174              thresh <= IPMI_UPPER_NON_RECOVERABLE; 
00175              thresh++)
00176         {
00177             rv = ipmi_sensor_threshold_reading_supported(sensor, thresh, &val);
00178             if ((rv) || !val)
00179                 continue;
00180 
00181             ipmi_cmdlang_out(cmd_info, "Threshold", NULL);
00182             ipmi_cmdlang_down(cmd_info);
00183             ipmi_cmdlang_out(cmd_info, "Name",
00184                              ipmi_get_threshold_string(thresh));
00185             rv = ipmi_sensor_threshold_readable(sensor, thresh, &val);
00186             if (rv)
00187                 val = 0;
00188             ipmi_cmdlang_out_bool(cmd_info, "Readable", val);
00189             rv = ipmi_sensor_threshold_settable(sensor, thresh, &val);
00190             if (rv)
00191                 val = 0;
00192             ipmi_cmdlang_out_bool(cmd_info, "Settable", val);
00193 
00194             for (value_dir = IPMI_GOING_LOW;
00195                  value_dir <= IPMI_GOING_HIGH;
00196                  value_dir++)
00197             {
00198                 for (dir = IPMI_ASSERTION;
00199                      dir <= IPMI_DEASSERTION;
00200                      dir++)
00201                 {
00202                     rv = ipmi_sensor_threshold_event_supported(sensor,
00203                                                                thresh,
00204                                                                value_dir,
00205                                                                dir,
00206                                                                &val);
00207                     if (rv || !val) continue;
00208 
00209                     snprintf(th_name, sizeof(th_name), "%s %s",
00210                              ipmi_get_value_dir_string(value_dir),
00211                              ipmi_get_event_dir_string(dir));
00212                     ipmi_cmdlang_out(cmd_info, "Supports", th_name);
00213                 }
00214             }
00215             ipmi_cmdlang_up(cmd_info);
00216         }
00217 
00218         val = ipmi_sensor_get_hysteresis_support(sensor);
00219         ipmi_cmdlang_out(cmd_info, "Hysteresis Support",
00220                          ipmi_get_hysteresis_support_string(val));
00221 
00222 #if 0
00223         /* FIXME - no accuracy handling */
00224         int ipmi_sensor_get_accuracy(ipmi_sensor_t *sensor, int val,
00225                                      double *accuracy);
00226 #endif
00227 
00228         rv = ipmi_sensor_get_nominal_reading(sensor, &dval);
00229         if (!rv)
00230             ipmi_cmdlang_out_double(cmd_info, "Nominal Reading", dval);
00231         rv = ipmi_sensor_get_normal_max(sensor, &dval);
00232         if (!rv)
00233             ipmi_cmdlang_out_double(cmd_info, "Normal Max", dval);
00234         rv = ipmi_sensor_get_normal_min(sensor, &dval);
00235         if (!rv)
00236             ipmi_cmdlang_out_double(cmd_info, "Normal Min", dval);
00237         rv = ipmi_sensor_get_sensor_max(sensor, &dval);
00238         if (!rv)
00239             ipmi_cmdlang_out_double(cmd_info, "Sensor Max", dval);
00240         rv = ipmi_sensor_get_sensor_min(sensor, &dval);
00241         if (!rv)
00242             ipmi_cmdlang_out_double(cmd_info, "Sensor Min", dval);
00243 
00244         ipmi_cmdlang_out_int(cmd_info, "Base Unit",
00245                              ipmi_sensor_get_base_unit(sensor));
00246         ipmi_cmdlang_out(cmd_info, "Base Unit Name",
00247                          ipmi_sensor_get_base_unit_string(sensor));
00248         cstr = ipmi_sensor_get_rate_unit_string(sensor);
00249         if (strlen(cstr)) {
00250             ipmi_cmdlang_out_int(cmd_info, "Rate Unit",
00251                                  ipmi_sensor_get_rate_unit(sensor));
00252             ipmi_cmdlang_out(cmd_info, "Rate Unit Name", cstr);
00253         }
00254         switch (ipmi_sensor_get_modifier_unit_use(sensor)) {
00255         case IPMI_MODIFIER_UNIT_BASE_DIV_MOD:
00256             ipmi_cmdlang_out(cmd_info, "Modifier Use", "/");
00257             ipmi_cmdlang_out_int(cmd_info, "Modifier Unit",
00258                                  ipmi_sensor_get_modifier_unit(sensor));
00259             ipmi_cmdlang_out(cmd_info, "Modifier Unit Name",
00260                              ipmi_sensor_get_modifier_unit_string(sensor));
00261             break;
00262                 
00263         case IPMI_MODIFIER_UNIT_BASE_MULT_MOD:
00264             ipmi_cmdlang_out(cmd_info, "Modifier Use", "*");
00265             ipmi_cmdlang_out_int(cmd_info, "Modifier Unit",
00266                                  ipmi_sensor_get_modifier_unit(sensor));
00267             ipmi_cmdlang_out(cmd_info, "Modifier Unit Name",
00268                              ipmi_sensor_get_modifier_unit_string(sensor));
00269             break;
00270 
00271         default:
00272             break;
00273         }
00274         if (ipmi_sensor_get_percentage(sensor))
00275             ipmi_cmdlang_out(cmd_info, "Percentage", "%");
00276     } else {
00277         int                   event;
00278         enum ipmi_event_dir_e dir;
00279 
00280         for (event=0; event<15; event++) {
00281             rv = ipmi_sensor_discrete_event_readable(sensor, event, &val);
00282             if (rv || !val)
00283                 continue;
00284             ipmi_cmdlang_out(cmd_info, "Event", NULL);
00285             ipmi_cmdlang_down(cmd_info);
00286             ipmi_cmdlang_out_int(cmd_info, "Offset", event);
00287             cstr = ipmi_sensor_reading_name_string(sensor, event);
00288             if (strcmp(cstr, "unknown") != 0)
00289                 ipmi_cmdlang_out(cmd_info, "Name", cstr);
00290             
00291             for (dir = IPMI_ASSERTION;
00292                  dir <= IPMI_DEASSERTION;
00293                  dir++)
00294             {
00295                 rv = ipmi_sensor_discrete_event_supported(sensor,
00296                                                           event,
00297                                                           dir,
00298                                                           &val);
00299                 if (rv || !val) continue;
00300 
00301                 ipmi_cmdlang_out(cmd_info, "Supports",
00302                                  ipmi_get_event_dir_string(dir));
00303             }
00304             ipmi_cmdlang_up(cmd_info);
00305         }
00306     }
00307     return;
00308 
00309  out_err:
00310     ipmi_sensor_get_name(sensor, cmdlang->objstr,
00311                          cmdlang->objstr_len);
00312     cmdlang->location = "cmd_sensor.c(sensor_dump)";
00313 }

static void sensor_enable_events (  ipmi_sensor_t *  sensor,
void *  cb_data
)  [static]
 

Definition at line 1196 of file cmd_sensor.c.

References ev_en_enable, and mod_event_enables().

01197 {
01198     mod_event_enables(sensor, cb_data, ev_en_enable);
01199 }

static void sensor_get (  ipmi_sensor_t *  sensor,
void *  cb_data
)  [static]
 

Definition at line 462 of file cmd_sensor.c.

References cmdlang, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_cmd_info_get(), ipmi_cmdlang_cmd_info_put(), IPMI_EVENT_READING_TYPE_THRESHOLD, ipmi_sensor_get_event_reading_type(), ipmi_sensor_get_name(), ipmi_sensor_get_reading(), ipmi_sensor_get_states(), ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, ipmi_cmdlang_s::objstr_len, read_sensor(), and read_sensor_states().

00463 {
00464     ipmi_cmd_info_t *cmd_info = cb_data;
00465     ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
00466     int             rv;
00467 
00468     ipmi_cmdlang_cmd_info_get(cmd_info);
00469     if (ipmi_sensor_get_event_reading_type(sensor)
00470         == IPMI_EVENT_READING_TYPE_THRESHOLD)
00471     {
00472         rv = ipmi_sensor_get_reading(sensor, read_sensor, cmd_info);
00473     } else {
00474         rv = ipmi_sensor_get_states(sensor, read_sensor_states, cmd_info);
00475     }
00476     if (rv) {
00477         ipmi_cmdlang_cmd_info_put(cmd_info);
00478         cmdlang->err = rv;
00479         cmdlang->errstr = "Error reading sensor";
00480         ipmi_sensor_get_name(sensor, cmdlang->objstr,
00481                              cmdlang->objstr_len);
00482         cmdlang->location = "cmd_sensor.c(sensor_get)";
00483     }
00484 }

static void sensor_get_event_enables (  ipmi_sensor_t *  sensor,
void *  cb_data
)  [static]
 

Definition at line 1024 of file cmd_sensor.c.

References cmdlang, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_cmd_info_get(), ipmi_cmdlang_cmd_info_put(), ipmi_sensor_get_event_enables(), ipmi_sensor_get_name(), ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, ipmi_cmdlang_s::objstr_len, and sensor_get_event_enables_done().

01025 {
01026     ipmi_cmd_info_t    *cmd_info = cb_data;
01027     ipmi_cmdlang_t     *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
01028     int                rv;
01029 
01030     ipmi_cmdlang_cmd_info_get(cmd_info);
01031     rv = ipmi_sensor_get_event_enables(sensor, sensor_get_event_enables_done,
01032                                        cmd_info);
01033     if (rv) {
01034         ipmi_cmdlang_cmd_info_put(cmd_info);
01035         cmdlang->err = rv;
01036         cmdlang->errstr = "Error getting event enables";
01037         ipmi_sensor_get_name(sensor, cmdlang->objstr,
01038                              cmdlang->objstr_len);
01039         cmdlang->location = "cmd_sensor.c(sensor_get_event_enables)";
01040     }
01041 }

static void sensor_get_event_enables_done (  ipmi_sensor_t *  sensor,
int  err,
ipmi_event_state_t *  states,
void *  cb_data
)  [static]
 

Definition at line 903 of file cmd_sensor.c.

References cmdlang, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, IPMI_ASSERTION, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_down(), ipmi_cmdlang_lock(), ipmi_cmdlang_out(), ipmi_cmdlang_out_bool(), ipmi_cmdlang_out_int(), ipmi_cmdlang_unlock(), ipmi_cmdlang_up(), IPMI_DEASSERTION, IPMI_EVENT_READING_TYPE_THRESHOLD, ipmi_event_state_get_busy(), ipmi_event_state_get_events_enabled(), ipmi_event_state_get_scanning_enabled(), ipmi_get_event_dir_string(), ipmi_get_threshold_string(), ipmi_get_value_dir_string(), IPMI_GOING_HIGH, IPMI_GOING_LOW, ipmi_is_discrete_event_set(), ipmi_is_threshold_event_set(), IPMI_LOWER_NON_CRITICAL, ipmi_sensor_discrete_event_readable(), ipmi_sensor_discrete_event_supported(), ipmi_sensor_get_event_reading_type(), ipmi_sensor_get_name(), IPMI_SENSOR_NAME_LEN, ipmi_sensor_reading_name_string(), ipmi_sensor_threshold_event_supported(), IPMI_UPPER_NON_RECOVERABLE, ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, and ipmi_cmdlang_s::objstr_len.

Referenced by sensor_get_event_enables().

00907 {
00908     ipmi_cmd_info_t    *cmd_info = cb_data;
00909     ipmi_cmdlang_t     *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
00910     char               sensor_name[IPMI_SENSOR_NAME_LEN];
00911     int                rv;
00912     int                val;
00913 
00914     ipmi_cmdlang_lock(cmd_info);
00915     if (err) {
00916         cmdlang->errstr = "Error reading sensor event enables";
00917         cmdlang->err = err;
00918         ipmi_sensor_get_name(sensor, cmdlang->objstr,
00919                              cmdlang->objstr_len);
00920         cmdlang->location = "cmd_sensor.c(sensor_get_event_enables_done)";
00921