« back to all changes in this revision
Viewing changes to cmdlang/cmd_sensor.c
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: Bazaar Package Importer
- Author(s): Noèl Köthe
- Date: 2005-07-04 21:29:17 UTC
- Revision ID: james.westby@ubuntu.com-20050704212917-igddk5jawjmhrlay
Tags: upstream-2.0.1
Import upstream version 2.0.1
- files added:
- cmdlang
- doc
- glib
- include
- include/OpenIPMI
- include/OpenIPMI/internal
- include/linux
- include/net
- lanserv
- lib
- man
- sample
- swig
- swig/perl
- swig/python
- ui
- unix
- utils
added
removed
cmdlang/cmd_sensor.c
1
/*
2
* cmd_sensor.c
3
*
4
* A command interpreter for OpenIPMI
5
*
6
* Author: MontaVista Software, Inc.
7
* Corey Minyard <minyard@mvista.com>
8
* source@mvista.com
9
*
10
* Copyright 2004 MontaVista Software Inc.
11
*
12
* This program is free software; you can redistribute it and/or
13
* modify it under the terms of the GNU Lesser General Public License
14
* as published by the Free Software Foundation; either version 2 of
15
* the License, or (at your option) any later version.
16
*
17
*
18
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
19
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
20
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
23
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
24
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
26
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
27
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
*
29
* You should have received a copy of the GNU Lesser General Public
30
* License along with this program; if not, write to the Free
31
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
32
*/
33
34
#include <errno.h>
35
#include <string.h>
36
#include <ctype.h>
37
#include <stdlib.h>
38
#include <stdio.h>
39
#include <OpenIPMI/ipmiif.h>
40
#include <OpenIPMI/ipmi_cmdlang.h>
41
42
/* Internal includes, do not use in your programs */
43
#include <OpenIPMI/internal/ipmi_malloc.h>
44
45
static void
46
sensor_list_handler(ipmi_entity_t *entity, ipmi_sensor_t *sensor,
47
void *cb_data)
48
{
49
ipmi_cmd_info_t *cmd_info = cb_data;
50
ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
51
char sensor_name[IPMI_SENSOR_NAME_LEN];
52
53
if (cmdlang->err)
54
return;
55
56
ipmi_sensor_get_name(sensor, sensor_name, sizeof(sensor_name));
57
58
ipmi_cmdlang_out(cmd_info, "Name", sensor_name);
59
}
60
61
static void
62
sensor_list(ipmi_entity_t *entity, void *cb_data)
63
{
64
ipmi_cmd_info_t *cmd_info = cb_data;
65
char entity_name[IPMI_ENTITY_NAME_LEN];
66
67
ipmi_entity_get_name(entity, entity_name, sizeof(entity_name));
68
ipmi_cmdlang_out(cmd_info, "Entity", NULL);
69
ipmi_cmdlang_down(cmd_info);
70
ipmi_cmdlang_out(cmd_info, "Name", entity_name);
71
ipmi_cmdlang_out(cmd_info, "Sensors", NULL);
72
ipmi_cmdlang_down(cmd_info);
73
ipmi_entity_iterate_sensors(entity, sensor_list_handler, cmd_info);
74
ipmi_cmdlang_up(cmd_info);
75
ipmi_cmdlang_up(cmd_info);
76
}
77
78
static void
79
sensor_dump(ipmi_sensor_t *sensor, ipmi_cmd_info_t *cmd_info)
80
{
81
ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
82
int num, lun;
83
char *str;
84
const char *cstr;
85
int event_support;
86
int event_reading_type;
87
int len;
88
int rv;
89
int val;
90
91
event_reading_type = ipmi_sensor_get_event_reading_type(sensor);
92
93
ipmi_sensor_get_num(sensor, &lun, &num);
94
ipmi_cmdlang_out_int(cmd_info, "LUN", lun);
95
ipmi_cmdlang_out_int(cmd_info, "Number", num);
96
ipmi_cmdlang_out_int(cmd_info, "Event Reading Type",
97
ipmi_sensor_get_event_reading_type(sensor));
98
ipmi_cmdlang_out(cmd_info, "Event Reading Type Name",
99
ipmi_sensor_get_event_reading_type_string(sensor));
100
ipmi_cmdlang_out_int(cmd_info, "Type",
101
ipmi_sensor_get_sensor_type(sensor));
102
ipmi_cmdlang_out(cmd_info, "Type Name",
103
ipmi_sensor_get_sensor_type_string(sensor));
104
val = ipmi_sensor_get_sensor_direction(sensor);
105
if (val != IPMI_SENSOR_DIRECTION_UNSPECIFIED)
106
ipmi_cmdlang_out(cmd_info, "Direction",
107
ipmi_get_sensor_direction_string(val));
108
109
event_support = ipmi_sensor_get_event_support(sensor);
110
switch (event_support) {
111
case IPMI_EVENT_SUPPORT_PER_STATE:
112
ipmi_cmdlang_out(cmd_info, "Event Support", "per state");
113
break;
114
case IPMI_EVENT_SUPPORT_ENTIRE_SENSOR:
115
ipmi_cmdlang_out(cmd_info, "Event Support", "entire sensor");
116
break;
117
case IPMI_EVENT_SUPPORT_GLOBAL_ENABLE:
118
ipmi_cmdlang_out(cmd_info, "Event Support", "global");
119
break;
120
default:
121
break;
122
}
123
124
ipmi_cmdlang_out_bool(cmd_info, "Init Scanning",
125
ipmi_sensor_get_sensor_init_scanning(sensor));
126
ipmi_cmdlang_out_bool(cmd_info, "Init Events",
127
ipmi_sensor_get_sensor_init_events(sensor));
128
ipmi_cmdlang_out_bool(cmd_info, "Init Thresholds",
129
ipmi_sensor_get_sensor_init_thresholds(sensor));
130
ipmi_cmdlang_out_bool(cmd_info, "Init Hysteresis",
131
ipmi_sensor_get_sensor_init_hysteresis(sensor));
132
ipmi_cmdlang_out_bool(cmd_info, "Init Type",
133
ipmi_sensor_get_sensor_init_type(sensor));
134
ipmi_cmdlang_out_bool(cmd_info, "Init Power Up Events",
135
ipmi_sensor_get_sensor_init_pu_events(sensor));
136
ipmi_cmdlang_out_bool(cmd_info, "Init Power Up Scanning",
137
ipmi_sensor_get_sensor_init_pu_scanning(sensor));
138
139
ipmi_cmdlang_out_bool(cmd_info, "Ignore If No Entity",
140
ipmi_sensor_get_ignore_if_no_entity(sensor));
141
ipmi_cmdlang_out_bool(cmd_info, "Auto Rearm",
142
ipmi_sensor_get_supports_auto_rearm(sensor));
143
ipmi_cmdlang_out_int(cmd_info, "OEM1",
144
ipmi_sensor_get_oem1(sensor));
145
146
len = ipmi_sensor_get_id_length(sensor);
147
if (len) {
148
str = ipmi_mem_alloc(len);
149
if (!str) {
150
cmdlang->err = ENOMEM;
151
cmdlang->errstr = "Out of memory";
152
goto out_err;
153
}
154
len = ipmi_sensor_get_id(sensor, str, len);
155
ipmi_cmdlang_out_type(cmd_info, "Id",
156
ipmi_sensor_get_id_type(sensor),
157
str, len);
158
ipmi_mem_free(str);
159
}
160
161
if (event_reading_type == IPMI_EVENT_READING_TYPE_THRESHOLD) {
162
int access = ipmi_sensor_get_threshold_access(sensor);
163
enum ipmi_thresh_e thresh;
164
enum ipmi_event_value_dir_e value_dir;
165
enum ipmi_event_dir_e dir;
166
int rv;
167
char th_name[50];
168
double dval;
169
170
ipmi_cmdlang_out(cmd_info, "Threshold Access",
171
ipmi_get_threshold_access_support_string(access));
172
173
for (thresh = IPMI_LOWER_NON_CRITICAL;
174
thresh <= IPMI_UPPER_NON_RECOVERABLE;
175
thresh++)
176
{
177
rv = ipmi_sensor_threshold_reading_supported(sensor, thresh, &val);
178
if ((rv) || !val)
179
continue;
180
181
ipmi_cmdlang_out(cmd_info, "Threshold", NULL);
182
ipmi_cmdlang_down(cmd_info);
183
ipmi_cmdlang_out(cmd_info, "Name",
184
ipmi_get_threshold_string(thresh));
185
rv = ipmi_sensor_threshold_readable(sensor, thresh, &val);
186
if (rv)
187
val = 0;
188
ipmi_cmdlang_out_bool(cmd_info, "Readable", val);
189
rv = ipmi_sensor_threshold_settable(sensor, thresh, &val);
190
if (rv)
191
val = 0;
192
ipmi_cmdlang_out_bool(cmd_info, "Settable", val);
193
194
for (value_dir = IPMI_GOING_LOW;
195
value_dir <= IPMI_GOING_HIGH;
196
value_dir++)
197
{
198
for (dir = IPMI_ASSERTION;
199
dir <= IPMI_DEASSERTION;
200
dir++)
201
{
202
rv = ipmi_sensor_threshold_event_supported(sensor,
203
thresh,
204
value_dir,
205
dir,
206
&val);
207
if (rv || !val) continue;
208
209
snprintf(th_name, sizeof(th_name), "%s %s",
210
ipmi_get_value_dir_string(value_dir),
211
ipmi_get_event_dir_string(dir));
212
ipmi_cmdlang_out(cmd_info, "Supports", th_name);
213
}
214
}
215
ipmi_cmdlang_up(cmd_info);
216
}
217
218
val = ipmi_sensor_get_hysteresis_support(sensor);
219
ipmi_cmdlang_out(cmd_info, "Hysteresis Support",
220
ipmi_get_hysteresis_support_string(val));
221
222
#if 0
223
/* FIXME - no accuracy handling */
224
int ipmi_sensor_get_accuracy(ipmi_sensor_t *sensor, int val,
225
double *accuracy);
226
#endif
227
228
rv = ipmi_sensor_get_nominal_reading(sensor, &dval);
229
if (!rv)
230
ipmi_cmdlang_out_double(cmd_info, "Nominal Reading", dval);
231
rv = ipmi_sensor_get_normal_max(sensor, &dval);
232
if (!rv)
233
ipmi_cmdlang_out_double(cmd_info, "Normal Max", dval);
234
rv = ipmi_sensor_get_normal_min(sensor, &dval);
235
if (!rv)
236
ipmi_cmdlang_out_double(cmd_info, "Normal Min", dval);
237
rv = ipmi_sensor_get_sensor_max(sensor, &dval);
238
if (!rv)
239
ipmi_cmdlang_out_double(cmd_info, "Sensor Max", dval);
240
rv = ipmi_sensor_get_sensor_min(sensor, &dval);
241
if (!rv)
242
ipmi_cmdlang_out_double(cmd_info, "Sensor Min", dval);
243
244
ipmi_cmdlang_out_int(cmd_info, "Base Unit",
245
ipmi_sensor_get_base_unit(sensor));
246
ipmi_cmdlang_out(cmd_info, "Base Unit Name",
247
ipmi_sensor_get_base_unit_string(sensor));
248
cstr = ipmi_sensor_get_rate_unit_string(sensor);
249
if (strlen(cstr)) {
250
ipmi_cmdlang_out_int(cmd_info, "Rate Unit",
251
ipmi_sensor_get_rate_unit(sensor));
252
ipmi_cmdlang_out(cmd_info, "Rate Unit Name", cstr);
253
}
254
switch (ipmi_sensor_get_modifier_unit_use(sensor)) {
255
case IPMI_MODIFIER_UNIT_BASE_DIV_MOD:
256
ipmi_cmdlang_out(cmd_info, "Modifier Use", "/");
257
ipmi_cmdlang_out_int(cmd_info, "Modifier Unit",
258
ipmi_sensor_get_modifier_unit(sensor));
259
ipmi_cmdlang_out(cmd_info, "Modifier Unit Name",
260
ipmi_sensor_get_modifier_unit_string(sensor));
261
break;
262
263
case IPMI_MODIFIER_UNIT_BASE_MULT_MOD:
264
ipmi_cmdlang_out(cmd_info, "Modifier Use", "*");
265
ipmi_cmdlang_out_int(cmd_info, "Modifier Unit",
266
ipmi_sensor_get_modifier_unit(sensor));
267
ipmi_cmdlang_out(cmd_info, "Modifier Unit Name",
268
ipmi_sensor_get_modifier_unit_string(sensor));
269
break;
270
271
default:
272
break;
273
}
274
if (ipmi_sensor_get_percentage(sensor))
275
ipmi_cmdlang_out(cmd_info, "Percentage", "%");
276
} else {
277
int event;
278
enum ipmi_event_dir_e dir;
279
280
for (event=0; event<15; event++) {
281
rv = ipmi_sensor_discrete_event_readable(sensor, event, &val);
282
if (rv || !val)
283
continue;
284
ipmi_cmdlang_out(cmd_info, "Event", NULL);
285
ipmi_cmdlang_down(cmd_info);
286
ipmi_cmdlang_out_int(cmd_info, "Offset", event);
287
cstr = ipmi_sensor_reading_name_string(sensor, event);
288
if (strcmp(cstr, "unknown") != 0)
289
ipmi_cmdlang_out(cmd_info, "Name", cstr);
290
291
for (dir = IPMI_ASSERTION;
292
dir <= IPMI_DEASSERTION;
293
dir++)
294
{
295
rv = ipmi_sensor_discrete_event_supported(sensor,
296
event,
297
dir,
298
&val);
299
if (rv || !val) continue;
300
301
ipmi_cmdlang_out(cmd_info, "Supports",
302
ipmi_get_event_dir_string(dir));
303
}
304
ipmi_cmdlang_up(cmd_info);
305
}
306
}
307
return;
308
309
out_err:
310
ipmi_sensor_get_name(sensor, cmdlang->objstr,
311
cmdlang->objstr_len);
312
cmdlang->location = "cmd_sensor.c(sensor_info)";
313
}
314
315
static void
316
sensor_info(ipmi_sensor_t *sensor, void *cb_data)
317
{
318
ipmi_cmd_info_t *cmd_info = cb_data;
319
char sensor_name[IPMI_SENSOR_NAME_LEN];
320
321
ipmi_sensor_get_name(sensor, sensor_name, sizeof(sensor_name));
322
323
ipmi_cmdlang_out(cmd_info, "Sensor", NULL);
324
ipmi_cmdlang_down(cmd_info);
325
ipmi_cmdlang_out(cmd_info, "Name", sensor_name);
326
sensor_dump(sensor, cmd_info);
327
ipmi_cmdlang_up(cmd_info);
328
}
329
330
static void
331
read_sensor(ipmi_sensor_t *sensor,
332
int err,
333
enum ipmi_value_present_e value_present,
334
unsigned int raw_val,
335
double val,
336
ipmi_states_t *states,
337
void *cb_data)
338
{
339
ipmi_cmd_info_t *cmd_info = cb_data;
340
ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
341
enum ipmi_thresh_e thresh;
342
char sensor_name[IPMI_SENSOR_NAME_LEN];
343
int rv;
344
345
ipmi_cmdlang_lock(cmd_info);
346
if (err) {
347
cmdlang->errstr = "Error reading sensor";
348
cmdlang->err = err;
349
ipmi_sensor_get_name(sensor, cmdlang->objstr,
350
cmdlang->objstr_len);
351
cmdlang->location = "cmd_sensor.c(read_sensor)";
352
goto out;
353
}
354
355
ipmi_sensor_get_name(sensor, sensor_name, sizeof(sensor_name));
356
357
ipmi_cmdlang_out(cmd_info, "Sensor", NULL);
358
ipmi_cmdlang_down(cmd_info);
359
ipmi_cmdlang_out(cmd_info, "Name", sensor_name);
360
361
ipmi_cmdlang_out_bool(cmd_info, "Event Messages Enabled",
362
ipmi_is_event_messages_enabled(states));
363
ipmi_cmdlang_out_bool(cmd_info, "Sensor Scanning Enabled",
364
ipmi_is_sensor_scanning_enabled(states));
365
ipmi_cmdlang_out_bool(cmd_info, "Initial Update In Progress",
366
ipmi_is_initial_update_in_progress(states));
367
368
switch (value_present) {
369
case IPMI_BOTH_VALUES_PRESENT:
370
ipmi_cmdlang_out_double(cmd_info, "Value", val);
371
/* FALLTHRU */
372
case IPMI_RAW_VALUE_PRESENT:
373
ipmi_cmdlang_out_hex(cmd_info, "Raw Value", raw_val);
374
default:
375
break;
376
}
377
378
for (thresh = IPMI_LOWER_NON_CRITICAL;
379
thresh <= IPMI_UPPER_NON_RECOVERABLE;
380
thresh++)
381
{
382
int ival;
383
384
rv = ipmi_sensor_threshold_reading_supported(sensor, thresh, &ival);
385
if ((rv) || !ival)
386
continue;
387
388
ipmi_cmdlang_out(cmd_info, "Threshold", NULL);
389
ipmi_cmdlang_down(cmd_info);
390
ipmi_cmdlang_out(cmd_info, "Name",
391
ipmi_get_threshold_string(thresh));
392
ipmi_cmdlang_out_bool(cmd_info, "Out Of Range",
393
ipmi_is_threshold_out_of_range(states, thresh));
394
ipmi_cmdlang_up(cmd_info);
395
}
396
ipmi_cmdlang_up(cmd_info);
397
398
out:
399
ipmi_cmdlang_unlock(cmd_info);
400
ipmi_cmdlang_cmd_info_put(cmd_info);
401
}
402
403
static void
404
read_sensor_states(ipmi_sensor_t *sensor,
405
int err,
406
ipmi_states_t *states,
407
void *cb_data)
408
{
409
ipmi_cmd_info_t *cmd_info = cb_data;
410
ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
411
int i;
412
char sensor_name[IPMI_SENSOR_NAME_LEN];
413
int rv;
414
415
ipmi_cmdlang_lock(cmd_info);
416
if (err) {
417
cmdlang->errstr = "Error reading sensor";
418
cmdlang->err = err;
419
ipmi_sensor_get_name(sensor, cmdlang->objstr,
420
cmdlang->objstr_len);
421
cmdlang->location = "cmd_sensor.c(read_sensor_states)";
422
goto out;
423
}
424
425
ipmi_sensor_get_name(sensor, sensor_name, sizeof(sensor_name));
426
427
ipmi_cmdlang_out(cmd_info, "Sensor", NULL);
428
ipmi_cmdlang_down(cmd_info);
429
ipmi_cmdlang_out(cmd_info, "Name", sensor_name);
430
431
ipmi_cmdlang_out_bool(cmd_info, "Event Messages Enabled",
432
ipmi_is_event_messages_enabled(states));
433
ipmi_cmdlang_out_bool(cmd_info, "Sensor Scanning Enabled",
434
ipmi_is_sensor_scanning_enabled(states));
435
ipmi_cmdlang_out_bool(cmd_info, "Initial Update In Progress",
436
ipmi_is_initial_update_in_progress(states));
437
for (i=0; i<15; i++) {
438
int ival;
439
const char *str;
440
441
rv = ipmi_sensor_discrete_event_readable(sensor, i, &ival);
442
if ((rv) || !ival)
443
continue;
444
445
ipmi_cmdlang_out(cmd_info, "Event", NULL);
446
ipmi_cmdlang_down(cmd_info);
447
ipmi_cmdlang_out_int(cmd_info, "Offset", i);
448
str = ipmi_sensor_reading_name_string(sensor, i);
449
if (strcmp(str, "unknown") != 0)
450
ipmi_cmdlang_out(cmd_info, "Name", str);
451
ipmi_cmdlang_out_bool(cmd_info, "Set", ipmi_is_state_set(states, i));
452
ipmi_cmdlang_up(cmd_info);
453
}
454
ipmi_cmdlang_up(cmd_info);
455
456
out:
457
ipmi_cmdlang_unlock(cmd_info);
458
ipmi_cmdlang_cmd_info_put(cmd_info);
459
}
460
461
static void
462
sensor_get(ipmi_sensor_t *sensor, void *cb_data)
463
{
464
ipmi_cmd_info_t *cmd_info = cb_data;
465
ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
466
int rv;
467
468
ipmi_cmdlang_cmd_info_get(cmd_info);
469
if (ipmi_sensor_get_event_reading_type(sensor)
470
== IPMI_EVENT_READING_TYPE_THRESHOLD)
471
{
472
rv = ipmi_sensor_get_reading(sensor, read_sensor, cmd_info);
473
} else {
474
rv = ipmi_sensor_get_states(sensor, read_sensor_states, cmd_info);
475
}
476
if (rv) {
477
ipmi_cmdlang_cmd_info_put(cmd_info);
478
cmdlang->err = rv;
479
cmdlang->errstr = "Error reading sensor";
480
ipmi_sensor_get_name(sensor, cmdlang->objstr,
481
cmdlang->objstr_len);
482
cmdlang->location = "cmd_sensor.c(sensor_get)";
483
}
484
}
485
486
static void
487
sensor_rearm_done(ipmi_sensor_t *sensor,
488
int err,
489
void *cb_data)
490
{
491
ipmi_cmd_info_t *cmd_info = cb_data;
492
ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
493
char sensor_name[IPMI_SENSOR_NAME_LEN];
494
495
ipmi_cmdlang_lock(cmd_info);
496
if (err) {
497
cmdlang->errstr = "Error rearming sensor";
498
cmdlang->err = err;
499
ipmi_sensor_get_name(sensor, cmdlang->objstr,
500
cmdlang->objstr_len);
501
cmdlang->location = "cmd_sensor.c(sensor_rearm_done)";
502
goto out;
503
}
504
505
ipmi_sensor_get_name(sensor, sensor_name, sizeof(sensor_name));
506
ipmi_cmdlang_out(cmd_info, "Rearm done", sensor_name);
507
508
out:
509
ipmi_cmdlang_unlock(cmd_info);
510
ipmi_cmdlang_cmd_info_put(cmd_info);
511
}
512
513
static void
514
sensor_rearm(ipmi_sensor_t *sensor, void *cb_data)
515
{
516
ipmi_cmd_info_t *cmd_info = cb_data;
517
ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
518
int rv;
519
int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
520
int argc = ipmi_cmdlang_get_argc(cmd_info);
521
char **argv = ipmi_cmdlang_get_argv(cmd_info);
522
int global;
523
ipmi_event_state_t *s = NULL;
524
525
if ((argc - curr_arg) < 1) {
526
cmdlang->errstr = "Not enough parameters";
527
cmdlang->err = EINVAL;
528
goto out_err;
529
}
530
531
if (strcmp(argv[curr_arg], "global") == 0) {
532
global = 1;
533
} else {
534
global = 0;
535
s = ipmi_mem_alloc(ipmi_event_state_size());
536
if (!s) {
537
cmdlang->errstr = "Out of memory";
538
cmdlang->err = ENOMEM;
539
goto out_err;
540
}
541
ipmi_event_state_init(s);
542
543
if (ipmi_sensor_get_event_reading_type(sensor)
544
== IPMI_EVENT_READING_TYPE_THRESHOLD)
545
{
546
enum ipmi_thresh_e thresh;
547
enum ipmi_event_value_dir_e value_dir;
548
enum ipmi_event_dir_e dir;
549
550
while (curr_arg < argc) {
551
ipmi_cmdlang_get_threshold_ev(argv[curr_arg], &thresh,
552
&value_dir, &dir, cmd_info);
553
if (cmdlang->err) {
554
goto out_err;
555
}
556
ipmi_threshold_event_set(s, thresh, value_dir, dir);
557
curr_arg++;
558
}
559
} else {
560
int offset;
561
enum ipmi_event_dir_e dir;
562
563
while (curr_arg < argc) {
564
ipmi_cmdlang_get_discrete_ev(argv[curr_arg], &offset,
565
&dir, cmd_info);
566
if (cmdlang->err) {
567
goto out_err;
568
}
569
ipmi_discrete_event_set(s, offset, dir);
570
curr_arg++;
571
}
572
}
573
}
574
575
ipmi_cmdlang_cmd_info_get(cmd_info);
576
rv = ipmi_sensor_rearm(sensor, global, s, sensor_rearm_done, cmd_info);
577
if (rv) {
578
ipmi_cmdlang_cmd_info_put(cmd_info);
579
cmdlang->err = rv;
580
cmdlang->errstr = "Error rearming sensor";
581
goto out_err;
582
}
583
584
if (s)
585
ipmi_mem_free(s);
586
return;
587
588
out_err:
589
ipmi_sensor_get_name(sensor, cmdlang->objstr,
590
cmdlang->objstr_len);
591
cmdlang->location = "cmd_sensor.c(sensor_rearm)";
592
if (s)
593
ipmi_mem_free(s);
594
}
595
596
static void
597
sensor_get_thresholds_done(ipmi_sensor_t *sensor,
598
int err,
599
ipmi_thresholds_t *th,
600
void *cb_data)
601
{
602
ipmi_cmd_info_t *cmd_info = cb_data;
603
ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
604
char sensor_name[IPMI_SENSOR_NAME_LEN];
605
enum ipmi_thresh_e thresh;
606
int rv;
607
608
ipmi_cmdlang_lock(cmd_info);
609
if (err) {
610
cmdlang->errstr = "Error reading sensor thresholds";
611
cmdlang->err = err;
612
ipmi_sensor_get_name(sensor, cmdlang->objstr,
613
cmdlang->objstr_len);
614
cmdlang->location = "cmd_sensor.c(sensor_get_thresholds_done)";
615
goto out;
616
}
617
618
ipmi_sensor_get_name(sensor, sensor_name, sizeof(sensor_name));
619
ipmi_cmdlang_out(cmd_info, "Sensor", NULL);
620
ipmi_cmdlang_down(cmd_info);
621
ipmi_cmdlang_out(cmd_info, "Name", sensor_name);
622
623
for (thresh = IPMI_LOWER_NON_CRITICAL;
624
thresh <= IPMI_UPPER_NON_RECOVERABLE;
625
thresh++)
626
{
627
int ival;
628
double dval;
629
630
rv = ipmi_sensor_threshold_reading_supported(sensor, thresh, &ival);
631
if ((rv) || !ival)
632
continue;
633
634
ipmi_cmdlang_out(cmd_info, "Threshold", NULL);
635
ipmi_cmdlang_down(cmd_info);
636
ipmi_cmdlang_out(cmd_info, "Name",
637
ipmi_get_threshold_string(thresh));
638
rv = ipmi_threshold_get(th, thresh, &dval);
639
if (rv)
640
continue;
641
ipmi_cmdlang_out_double(cmd_info, "Value", dval);
642
ipmi_cmdlang_up(cmd_info);
643
}
644
ipmi_cmdlang_up(cmd_info);
645
646
out:
647
ipmi_cmdlang_unlock(cmd_info);
648
ipmi_cmdlang_cmd_info_put(cmd_info);
649
}
650
651
static void
652
sensor_get_thresholds(ipmi_sensor_t *sensor, void *cb_data)
653
{
654
ipmi_cmd_info_t *cmd_info = cb_data;
655
ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
656
int rv;
657
658
ipmi_cmdlang_cmd_info_get(cmd_info);
659
rv = ipmi_sensor_get_thresholds(sensor, sensor_get_thresholds_done,
660
cmd_info);
661
if (rv) {
662
ipmi_cmdlang_cmd_info_put(cmd_info);
663
cmdlang->err = rv;
664
cmdlang->errstr = "Error getting thresholds";
665
ipmi_sensor_get_name(sensor, cmdlang->objstr,
666
cmdlang->objstr_len);
667
cmdlang->location = "cmd_sensor.c(sensor_get_thresholds)";
668
}
669
}
670
671
static void
672
sensor_set_thresholds_done(ipmi_sensor_t *sensor,
673
int err,
674
void *cb_data)
675
{
676
ipmi_cmd_info_t *cmd_info = cb_data;
677
ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
678
char sensor_name[IPMI_SENSOR_NAME_LEN];
679
680
ipmi_cmdlang_lock(cmd_info);
681
if (err) {
682
cmdlang->errstr = "Error setting sensor thresholds";
683
cmdlang->err = err;
684
ipmi_sensor_get_name(sensor, cmdlang->objstr,
685
cmdlang->objstr_len);
686
cmdlang->location = "cmd_sensor.c(sensor_set_thresholds_done)";
687
goto out;
688
}
689
690
ipmi_sensor_get_name(sensor, sensor_name, sizeof(sensor_name));
691
ipmi_cmdlang_out(cmd_info, "Thresholds set", sensor_name);
692
693
out:
694
ipmi_cmdlang_unlock(cmd_info);
695
ipmi_cmdlang_cmd_info_put(cmd_info);
696
}
697
698
static void
699
sensor_set_thresholds(ipmi_sensor_t *sensor, void *cb_data)
700
{
701
ipmi_cmd_info_t *cmd_info = cb_data;
702
ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
703
int rv;
704
int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
705
int argc = ipmi_cmdlang_get_argc(cmd_info);
706
char **argv = ipmi_cmdlang_get_argv(cmd_info);
707
ipmi_thresholds_t *th = NULL;
708
enum ipmi_thresh_e thresh;
709
double val;
710
711
if ((argc - curr_arg) < 1) {
712
/* Not enough parameters */
713
cmdlang->errstr = "Not enough parameters";
714
cmdlang->err = EINVAL;
715
goto out_err;
716
}
717
718
th = ipmi_mem_alloc(ipmi_thresholds_size());
719
if (!th) {
720
cmdlang->errstr = "Out of memory";
721
cmdlang->err = ENOMEM;
722
goto out_err;
723
}
724
ipmi_thresholds_init(th);
725
while (curr_arg < argc) {
726
ipmi_cmdlang_get_threshold(argv[curr_arg], &thresh, cmd_info);
727
if (cmdlang->err) {
728
cmdlang->errstr = "Invalid threshold";
729
goto out_err;
730
}
731
curr_arg++;
732
733
ipmi_cmdlang_get_double(argv[curr_arg], &val, cmd_info);
734
if (cmdlang->err) {
735
cmdlang->errstr = "Invalid threshold value";
736
goto out_err;
737
}
738
curr_arg++;
739
740
rv = ipmi_threshold_set(th, sensor, thresh, val);
741
if (rv) {
742
cmdlang->errstr = "Error setting value";
743
cmdlang->err = rv;
744
goto out_err;
745
}
746
}
747
748
ipmi_cmdlang_cmd_info_get(cmd_info);
749
rv = ipmi_sensor_set_thresholds(sensor, th, sensor_set_thresholds_done,
750
cmd_info);
751
if (rv) {
752
ipmi_cmdlang_cmd_info_put(cmd_info);
753
cmdlang->err = rv;
754
cmdlang->errstr = "Error setting thresholds";
755
goto out_err;
756
}
757
ipmi_mem_free(th);
758
return;
759
760
out_err:
761
ipmi_sensor_get_name(sensor, cmdlang->objstr,
762
cmdlang->objstr_len);
763
cmdlang->location = "cmd_sensor.c(sensor_set_thresholds)";
764
if (th)
765
ipmi_mem_free(th);
766
}
767
768
static void
769
sensor_get_hysteresis_done(ipmi_sensor_t *sensor,
770
int err,
771
unsigned int positive_hysteresis,
772
unsigned int negative_hysteresis,
773
void *cb_data)
774
{
775
ipmi_cmd_info_t *cmd_info = cb_data;
776
ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
777
char sensor_name[IPMI_SENSOR_NAME_LEN];
778
779
ipmi_cmdlang_lock(cmd_info);
780
if (err) {
781
cmdlang->errstr = "Error reading sensor hysteresis";
782
cmdlang->err = err;
783
ipmi_sensor_get_name(sensor, cmdlang->objstr,
784
cmdlang->objstr_len);
785
cmdlang->location = "cmd_sensor.c(sensor_get_hysteresis_done)";
786
goto out;
787
}
788
789
ipmi_sensor_get_name(sensor, sensor_name, sizeof(sensor_name));
790
ipmi_cmdlang_out(cmd_info, "Sensor", NULL);
791
ipmi_cmdlang_down(cmd_info);
792
ipmi_cmdlang_out(cmd_info, "Name", sensor_name);
793
794
ipmi_cmdlang_out_int(cmd_info, "Positive Hysteresis",
795
positive_hysteresis);
796
ipmi_cmdlang_out_int(cmd_info, "Negative Hysteresis",
797
negative_hysteresis);
798
799
ipmi_cmdlang_up(cmd_info);
800
801
802
out:
803
ipmi_cmdlang_unlock(cmd_info);
804
ipmi_cmdlang_cmd_info_put(cmd_info);
805
}
806
807
static void
808
sensor_get_hysteresis(ipmi_sensor_t *sensor, void *cb_data)
809
{
810
ipmi_cmd_info_t *cmd_info = cb_data;
811
ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
812
int rv;
813
814
ipmi_cmdlang_cmd_info_get(cmd_info);
815
rv = ipmi_sensor_get_hysteresis(sensor, sensor_get_hysteresis_done,
816
cmd_info);
817
if (rv) {
818
ipmi_cmdlang_cmd_info_put(cmd_info);
819
cmdlang->err = rv;
820
cmdlang->errstr = "Error getting hysteresis";
821
ipmi_sensor_get_name(sensor, cmdlang->objstr,
822
cmdlang->objstr_len);
823
cmdlang->location = "cmd_sensor.c(sensor_get_hysteresis)";
824
}
825
}
826
827
static void
828
sensor_set_hysteresis_done(ipmi_sensor_t *sensor,
829
int err,
830
void *cb_data)
831
{
832
ipmi_cmd_info_t *cmd_info = cb_data;
833
ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
834
char sensor_name[IPMI_SENSOR_NAME_LEN];
835
836
ipmi_cmdlang_lock(cmd_info);
837
if (err) {
838
cmdlang->errstr = "Error setting sensor hysteresis";
839
cmdlang->err = err;
840
ipmi_sensor_get_name(sensor, cmdlang->objstr,
841
cmdlang->objstr_len);
842
cmdlang->location = "cmd_sensor.c(sensor_set_hysteresis_done)";
843
goto out;
844
}
845
846
ipmi_sensor_get_name(sensor, sensor_name, sizeof(sensor_name));
847
ipmi_cmdlang_out(cmd_info, "Hysteresis set", sensor_name);
848
849
out:
850
ipmi_cmdlang_unlock(cmd_info);
851
ipmi_cmdlang_cmd_info_put(cmd_info);
852
}
853
854
static void
855
sensor_set_hysteresis(ipmi_sensor_t *sensor, void *cb_data)
856
{
857
ipmi_cmd_info_t *cmd_info = cb_data;
858
ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
859
int rv;
860
int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
861
int argc = ipmi_cmdlang_get_argc(cmd_info);
862
char **argv = ipmi_cmdlang_get_argv(cmd_info);
863
int pos, neg;
864
865
if ((argc - curr_arg) < 2) {
866
/* Not enough parameters */
867
cmdlang->errstr = "Not enough parameters";
868
cmdlang->err = EINVAL;
869
goto out_err;
870
}
871
872
ipmi_cmdlang_get_int(argv[curr_arg], &pos, cmd_info);
873
if (cmdlang->err) {
874
cmdlang->errstr = "Invalid positive hysteresis";
875
goto out_err;
876
}
877
curr_arg++;
878
879
ipmi_cmdlang_get_int(argv[curr_arg], &neg, cmd_info);
880
if (cmdlang->err) {
881
cmdlang->errstr = "Invalid negative hysteresis";
882
goto out_err;
883
}
884
curr_arg++;
885
886
ipmi_cmdlang_cmd_info_get(cmd_info);
887
rv = ipmi_sensor_set_hysteresis(sensor, pos, neg,
888
sensor_set_hysteresis_done, cmd_info);
889
if (rv) {
890
ipmi_cmdlang_cmd_info_put(cmd_info);
891
cmdlang->err = rv;
892
cmdlang->errstr = "Error setting hysteresis";
893
goto out_err;
894
}
895
896
out_err:
897
ipmi_sensor_get_name(sensor, cmdlang->objstr,
898
cmdlang->objstr_len);
899
cmdlang->location = "cmd_sensor.c(sensor_set_hysteresis)";
900
}
901
902
static void
903
sensor_get_event_enables_done(ipmi_sensor_t *sensor,
904
int err,
905
ipmi_event_state_t *states,
906
void *cb_data)
907
{
908
ipmi_cmd_info_t *cmd_info = cb_data;
909
ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
910
char sensor_name[IPMI_SENSOR_NAME_LEN];
911
int rv;
912
int val;
913
914
ipmi_cmdlang_lock(cmd_info);
915
if (err) {
916
cmdlang->errstr = "Error reading sensor event enables";
917
cmdlang->err = err;
918
ipmi_sensor_get_name(sensor, cmdlang->objstr,
919
cmdlang->objstr_len);
920
cmdlang->location = "cmd_sensor.c(sensor_get_event_enables_done)";
921
goto out;
922
}
923
924
ipmi_sensor_get_name(sensor, sensor_name, sizeof(sensor_name));
925
ipmi_cmdlang_out(cmd_info, "Sensor", NULL);
926
ipmi_cmdlang_down(cmd_info);
927
ipmi_cmdlang_out(cmd_info, "Name", sensor_name);
928
929
ipmi_cmdlang_out_bool(cmd_info, "Event Messages Enabled",
930
ipmi_event_state_get_events_enabled(states));
931
ipmi_cmdlang_out_bool(cmd_info, "Sensor Scanning Enabled",
932
ipmi_event_state_get_scanning_enabled(states));
933
ipmi_cmdlang_out_bool(cmd_info, "Busy",
934
ipmi_event_state_get_busy(states));
935
936
if (ipmi_sensor_get_event_reading_type(sensor)
937
== IPMI_EVENT_READING_TYPE_THRESHOLD)
938
{
939
enum ipmi_thresh_e thresh;
940
enum ipmi_event_value_dir_e value_dir;
941
enum ipmi_event_dir_e dir;
942
943
for (thresh = IPMI_LOWER_NON_CRITICAL;
944
thresh <= IPMI_UPPER_NON_RECOVERABLE;
945
thresh++)
946
{
947
for (value_dir = IPMI_GOING_LOW;
948
value_dir <= IPMI_GOING_HIGH;
949
value_dir++)
950
{
951
for (dir = IPMI_ASSERTION;
952
dir <= IPMI_DEASSERTION;
953
dir++)
954
{
955
char th_name[50];
956
957
rv = ipmi_sensor_threshold_event_supported(sensor,
958
thresh,
959
value_dir,
960
dir,
961
&val);
962
if (rv || !val) continue;
963
964
ipmi_cmdlang_out(cmd_info, "Threshold", NULL);
965
ipmi_cmdlang_down(cmd_info);
966
snprintf(th_name, sizeof(th_name), "%s %s %s",
967
ipmi_get_threshold_string(thresh),
968
ipmi_get_value_dir_string(value_dir),
969
ipmi_get_event_dir_string(dir));
970
ipmi_cmdlang_out(cmd_info, "Name", th_name);
971
ipmi_cmdlang_out_bool(cmd_info, "Enabled",
972
ipmi_is_threshold_event_set
973
(states, thresh, value_dir, dir));
974
ipmi_cmdlang_up(cmd_info);
975
}
976
}
977
}
978
} else {
979
int offset;
980
const char *str;
981
982
for (offset=0; offset<15; offset++) {
983
rv = ipmi_sensor_discrete_event_readable(sensor, offset, &val);
984
if (rv || !val)
985
continue;
986
ipmi_cmdlang_out(cmd_info, "Event", NULL);
987
ipmi_cmdlang_down(cmd_info);
988
ipmi_cmdlang_out_int(cmd_info, "Offset", offset);
989
str = ipmi_sensor_reading_name_string(sensor, offset);
990
if (strcmp(str, "unknown") != 0)
991
ipmi_cmdlang_out(cmd_info, "Name", str);
992
993
rv = ipmi_sensor_discrete_event_supported(sensor,
994
offset,
995
IPMI_ASSERTION,
996
&val);
997
if (!rv && val) {
998
ipmi_cmdlang_out_bool(cmd_info, "Assertion Enabled",
999
ipmi_is_discrete_event_set
1000
(states, offset, IPMI_ASSERTION));
1001
}
1002
rv = ipmi_sensor_discrete_event_supported(sensor,
1003
offset,
1004
IPMI_DEASSERTION,
1005
&val);
1006
if (!rv && val) {
1007
ipmi_cmdlang_out_bool(cmd_info, "Deassertion Enabled",
1008
ipmi_is_discrete_event_set
1009
(states, offset, IPMI_DEASSERTION));
1010
}
1011
ipmi_cmdlang_up(cmd_info);
1012
}
1013
}
1014
1015
ipmi_cmdlang_up(cmd_info);
1016
1017
1018
out:
1019
ipmi_cmdlang_unlock(cmd_info);
1020
ipmi_cmdlang_cmd_info_put(cmd_info);
1021
}
1022
1023
static void
1024
sensor_get_event_enables(ipmi_sensor_t *sensor, void *cb_data)
1025
{
1026
ipmi_cmd_info_t *cmd_info = cb_data;
1027
ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
1028
int rv;
1029
1030
ipmi_cmdlang_cmd_info_get(cmd_info);
1031
rv = ipmi_sensor_get_event_enables(sensor, sensor_get_event_enables_done,
1032
cmd_info);
1033
if (rv) {
1034
ipmi_cmdlang_cmd_info_put(cmd_info);
1035
cmdlang->err = rv;
1036
cmdlang->errstr = "Error getting event enables";
1037
ipmi_sensor_get_name(sensor, cmdlang->objstr,
1038
cmdlang->objstr_len);
1039
cmdlang->location = "cmd_sensor.c(sensor_get_event_enables)";
1040
}
1041
}
1042
1043
static void
1044
sensor_set_event_enables_done(ipmi_sensor_t *sensor,
1045
int err,
1046
void *cb_data)
1047
{
1048
ipmi_cmd_info_t *cmd_info = cb_data;
1049
ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
1050
char sensor_name[IPMI_SENSOR_NAME_LEN];
1051
1052
ipmi_cmdlang_lock(cmd_info);
1053
if (err) {
1054
cmdlang->errstr = "Error setting event enables";
1055
cmdlang->err = err;
1056
ipmi_sensor_get_name(sensor, cmdlang->objstr,
1057
cmdlang->objstr_len);
1058
cmdlang->location = "cmd_sensor.c(sensor_set_event_enables_done)";
1059
goto out;
1060
}
1061
1062
ipmi_sensor_get_name(sensor, sensor_name, sizeof(sensor_name));
1063
ipmi_cmdlang_out(cmd_info, "Event enables set", sensor_name);
1064
1065
out:
1066
ipmi_cmdlang_unlock(cmd_info);
1067
ipmi_cmdlang_cmd_info_put(cmd_info);
1068
}
1069
1070
enum ev_en_kind { ev_en_set, ev_en_enable, ev_en_disable };
1071
1072
static void
1073
mod_event_enables(ipmi_sensor_t *sensor, void *cb_data, enum ev_en_kind kind)
1074
{
1075
ipmi_cmd_info_t *cmd_info = cb_data;
1076
ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
1077
int rv;
1078
int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
1079
int argc = ipmi_cmdlang_get_argc(cmd_info);
1080
char **argv = ipmi_cmdlang_get_argv(cmd_info);
1081
ipmi_event_state_t *s = NULL;
1082
1083
if ((argc - curr_arg) < 2) {
1084
/* Not enough parameters */
1085
cmdlang->errstr = "Not enough parameters";
1086
cmdlang->err = EINVAL;
1087
goto out_err;
1088
}
1089
1090
s = ipmi_mem_alloc(ipmi_states_size());
1091
if (!s) {
1092
cmdlang->errstr = "Out of memory";
1093
cmdlang->err = ENOMEM;
1094
goto out_err;
1095
}
1096
ipmi_event_state_init(s);
1097
1098
if (strcmp(argv[curr_arg], "msg") == 0)
1099
ipmi_event_state_set_events_enabled(s, 1);
1100
else if (strcmp(argv[curr_arg], "nomsg") == 0)
1101
ipmi_event_state_set_events_enabled(s, 0);
1102
else {
1103
cmdlang->errstr = "Invalid message enable setting";
1104
cmdlang->err = EINVAL;
1105
goto out_err;
1106
}
1107
curr_arg++;
1108
1109
if (strcmp(argv[curr_arg], "scan") == 0)
1110
ipmi_event_state_set_scanning_enabled(s, 1);
1111
else if (strcmp(argv[curr_arg], "noscan") == 0)
1112
ipmi_event_state_set_scanning_enabled(s, 0);
1113
else {
1114
cmdlang->errstr = "Invalid scanning enable setting";
1115
cmdlang->err = EINVAL;
1116
goto out_err;
1117
}
1118
curr_arg++;
1119
1120
if (ipmi_sensor_get_event_reading_type(sensor)
1121
== IPMI_EVENT_READING_TYPE_THRESHOLD)
1122
{
1123
while (curr_arg < argc) {
1124
enum ipmi_thresh_e thresh;
1125
enum ipmi_event_value_dir_e value_dir;
1126
enum ipmi_event_dir_e dir;
1127
1128
ipmi_cmdlang_get_threshold_ev(argv[curr_arg], &thresh,
1129
&value_dir, &dir, cmd_info);
1130
if (cmdlang->err) {
1131
goto out_err;
1132
}
1133
ipmi_threshold_event_set(s, thresh, value_dir, dir);
1134
curr_arg++;
1135
}
1136
} else {
1137
while (curr_arg < argc) {
1138
int offset;
1139
enum ipmi_event_dir_e dir;
1140
1141
ipmi_cmdlang_get_discrete_ev(argv[curr_arg], &offset,
1142
&dir, cmd_info);
1143
if (cmdlang->err) {
1144
goto out_err;
1145
}
1146
ipmi_discrete_event_set(s, offset, dir);
1147
curr_arg++;
1148
}
1149
}
1150
1151
ipmi_cmdlang_cmd_info_get(cmd_info);
1152
switch (kind) {
1153
case ev_en_set:
1154
rv = ipmi_sensor_set_event_enables(sensor, s,
1155
sensor_set_event_enables_done,
1156
cmd_info);
1157
break;
1158
case ev_en_enable:
1159
rv = ipmi_sensor_enable_events(sensor, s,
1160
sensor_set_event_enables_done,
1161
cmd_info);
1162
break;
1163
case ev_en_disable:
1164
rv = ipmi_sensor_disable_events(sensor, s,
1165
sensor_set_event_enables_done,
1166
cmd_info);
1167
break;
1168
default:
1169
rv = EINVAL;
1170
}
1171
1172
if (rv) {
1173
ipmi_cmdlang_cmd_info_put(cmd_info);
1174
cmdlang->err = rv;
1175
cmdlang->errstr = "Error setting event enables";
1176
goto out_err;
1177
}
1178
ipmi_mem_free(s);
1179
return;
1180
1181
out_err:
1182
ipmi_sensor_get_name(sensor, cmdlang->objstr,
1183
cmdlang->objstr_len);
1184
cmdlang->location = "cmd_sensor.c(sensor_set_event_enables)";
1185
if (s)
1186
ipmi_mem_free(s);
1187
}
1188
1189
static void
1190
sensor_set_event_enables(ipmi_sensor_t *sensor, void *cb_data)
1191
{
1192
mod_event_enables(sensor, cb_data, ev_en_set);
1193
}
1194
1195
static void
1196
sensor_enable_events(ipmi_sensor_t *sensor, void *cb_data)
1197
{
1198
mod_event_enables(sensor, cb_data, ev_en_enable);
1199
}
1200
1201
static void
1202
sensor_disable_events(ipmi_sensor_t *sensor, void *cb_data)
1203
{
1204
mod_event_enables(sensor, cb_data, ev_en_disable);
1205
}
1206
1207
static int
1208
sensor_discrete_event_handler(ipmi_sensor_t *sensor,
1209
enum ipmi_event_dir_e dir,
1210
int offset,
1211
int severity,
1212
int prev_severity,
1213
void *cb_data,
1214
ipmi_event_t *event)
1215
{
1216
ipmi_cmd_info_t *evi;
1217
char sensor_name[IPMI_SENSOR_NAME_LEN];
1218
int rv;
1219
char *errstr;
1220
1221
ipmi_sensor_get_name(sensor, sensor_name, sizeof(sensor_name));
1222
1223
evi = ipmi_cmdlang_alloc_event_info();
1224
if (!evi) {
1225
rv = ENOMEM;
1226
errstr = "Out of memory";
1227
goto out_err;
1228
}
1229
1230
ipmi_cmdlang_out(evi, "Object Type", "Sensor");
1231
ipmi_cmdlang_out(evi, "Name", sensor_name);
1232
ipmi_cmdlang_out(evi, "Operation", "Event");
1233
ipmi_cmdlang_out_int(evi, "Offset", offset);
1234
ipmi_cmdlang_out(evi, "Direction", ipmi_get_event_dir_string(dir));
1235
ipmi_cmdlang_out_int(evi, "Severity", severity);
1236
ipmi_cmdlang_out_int(evi, "Previous Severity", prev_severity);
1237
if (event) {
1238
ipmi_cmdlang_out(evi, "Event", NULL);
1239
ipmi_cmdlang_down(evi);
1240
ipmi_cmdlang_event_out(event, evi);
1241
ipmi_cmdlang_up(evi);
1242
}
1243
ipmi_cmdlang_cmd_info_put(evi);
1244
return IPMI_EVENT_HANDLED;
1245
1246
out_err:
1247
ipmi_cmdlang_global_err(sensor_name,
1248
"cmd_sensor.c(ipmi_cmdlang_sensor_change)",
1249
errstr, rv);
1250
if (evi)
1251
ipmi_cmdlang_cmd_info_put(evi);
1252
return IPMI_EVENT_NOT_HANDLED;
1253
}
1254
1255
static int
1256
sensor_threshold_event_handler(ipmi_sensor_t *sensor,
1257
enum ipmi_event_dir_e dir,
1258
enum ipmi_thresh_e threshold,
1259
enum ipmi_event_value_dir_e high_low,
1260
enum ipmi_value_present_e value_present,
1261
unsigned int raw_value,
1262
double value,
1263
void *cb_data,
1264
ipmi_event_t *event)
1265
{
1266
ipmi_cmd_info_t *evi;
1267
char sensor_name[IPMI_SENSOR_NAME_LEN];
1268
int rv;
1269
char *errstr;
1270
1271
ipmi_sensor_get_name(sensor, sensor_name, sizeof(sensor_name));
1272
1273
evi = ipmi_cmdlang_alloc_event_info();
1274
if (!evi) {
1275
rv = ENOMEM;
1276
errstr = "Out of memory";
1277
goto out_err;
1278
}
1279
1280
ipmi_cmdlang_out(evi, "Object Type", "Sensor");
1281
ipmi_cmdlang_out(evi, "Name", sensor_name);
1282
ipmi_cmdlang_out(evi, "Operation", "Event");
1283
ipmi_cmdlang_out(evi, "Threshold", ipmi_get_threshold_string(threshold));
1284
ipmi_cmdlang_out(evi, "High/Low", ipmi_get_value_dir_string(high_low));
1285
ipmi_cmdlang_out(evi, "Direction", ipmi_get_event_dir_string(dir));
1286
switch (value_present) {
1287
case IPMI_BOTH_VALUES_PRESENT:
1288
ipmi_cmdlang_out_double(evi, "Value", value);
1289
/* FALLTHRU */
1290
case IPMI_RAW_VALUE_PRESENT:
1291
ipmi_cmdlang_out_int(evi, "Raw Value", raw_value);
1292
break;
1293
1294
default:
1295
break;
1296
}
1297
if (event) {
1298
ipmi_cmdlang_out(evi, "Event", NULL);
1299
ipmi_cmdlang_down(evi);
1300
ipmi_cmdlang_event_out(event, evi);
1301
ipmi_cmdlang_up(evi);
1302
}
1303
ipmi_cmdlang_cmd_info_put(evi);
1304
return IPMI_EVENT_HANDLED;
1305
1306
out_err:
1307
ipmi_cmdlang_global_err(sensor_name,
1308
"cmd_sensor.c(ipmi_cmdlang_sensor_change)",
1309
errstr, rv);
1310
if (evi)
1311
ipmi_cmdlang_cmd_info_put(evi);
1312
return IPMI_EVENT_NOT_HANDLED;
1313
}
1314
1315
void
1316
ipmi_cmdlang_sensor_change(enum ipmi_update_e op,
1317
ipmi_entity_t *entity,
1318
ipmi_sensor_t *sensor,
1319
void *cb_data)
1320
{
1321
char *errstr;
1322
int rv;
1323
ipmi_cmd_info_t *evi;
1324
char sensor_name[IPMI_SENSOR_NAME_LEN];
1325
1326
ipmi_sensor_get_name(sensor, sensor_name, sizeof(sensor_name));
1327
1328
evi = ipmi_cmdlang_alloc_event_info();
1329
if (!evi) {
1330
rv = ENOMEM;
1331
errstr = "Out of memory";
1332
goto out_err;
1333
}
1334
1335
ipmi_cmdlang_out(evi, "Object Type", "Sensor");
1336
ipmi_cmdlang_out(evi, "Name", sensor_name);
1337
1338
switch (op) {
1339
case IPMI_ADDED:
1340
ipmi_cmdlang_out(evi, "Operation", "Add");
1341
if (ipmi_cmdlang_get_evinfo())
1342
sensor_dump(sensor, evi);
1343
1344
if (ipmi_sensor_get_event_reading_type(sensor)
1345
== IPMI_EVENT_READING_TYPE_THRESHOLD)
1346
{
1347
rv = ipmi_sensor_add_threshold_event_handler
1348
(sensor,
1349
sensor_threshold_event_handler,
1350
NULL);
1351
} else {
1352
rv = ipmi_sensor_add_discrete_event_handler
1353
(sensor,
1354
sensor_discrete_event_handler,
1355
NULL);
1356
}
1357
if (rv) {
1358
ipmi_cmdlang_global_err(sensor_name,
1359
"cmd_sensor.c(ipmi_cmdlang_sensor_change)",
1360
"Unable to set event handler for sensor",
1361
rv);
1362
}
1363
break;
1364
1365
case IPMI_DELETED:
1366
ipmi_cmdlang_out(evi, "Operation", "Delete");
1367
break;
1368
1369
case IPMI_CHANGED:
1370
ipmi_cmdlang_out(evi, "Operation", "Change");
1371
if (ipmi_cmdlang_get_evinfo())
1372
sensor_dump(sensor, evi);
1373
break;
1374
}
1375
1376
ipmi_cmdlang_cmd_info_put(evi);
1377
return;
1378
1379
out_err:
1380
ipmi_cmdlang_global_err(sensor_name,
1381
"cmd_sensor.c(ipmi_cmdlang_sensor_change)",
1382
errstr, rv);
1383
if (evi)
1384
ipmi_cmdlang_cmd_info_put(evi);
1385
}
1386
1387
static ipmi_cmdlang_cmd_t *sensor_cmds;
1388
1389
static ipmi_cmdlang_init_t cmds_sensor[] =
1390
{
1391
{ "sensor", NULL,
1392
"- Commands dealing with sensors",
1393
NULL, NULL, &sensor_cmds },
1394
{ "list", &sensor_cmds,
1395
"- List all the entities in the system",
1396
ipmi_cmdlang_entity_handler, sensor_list, NULL },
1397
{ "info", &sensor_cmds,
1398
"<sensor> - Dump information about an sensor",
1399
ipmi_cmdlang_sensor_handler, sensor_info, NULL },
1400
{ "get", &sensor_cmds,
1401
"<sensor> - Get the sensor's current reading",
1402
ipmi_cmdlang_sensor_handler, sensor_get, NULL },
1403
{ "rearm", &sensor_cmds,
1404
"<sensor> global | <thresholds> | <discrete states> - "
1405
" Rearm the sensor. If global is specified, then rearm"
1406
" all events in the sensor. If it is a threshold sensor, then"
1407
" put in a list of thresholds of the form '[ul][ncr][hl][ad]"
1408
" where [ul] means upper or lower, [ncr] means non-critical,"
1409
" critical, or non-recoverable, [hl] means going high or going"
1410
" low, and [ad] means assertion or deassertion. If it is a"
1411
" discrete sensor, then the form is <num>[ad] where the number"
1412
" is the offset and [ad] means assertion or deassertion",
1413
ipmi_cmdlang_sensor_handler, sensor_rearm, NULL },
1414
{ "get_thresholds", &sensor_cmds,
1415
"<sensor> - Get the sensor's thresholds",
1416
ipmi_cmdlang_sensor_handler, sensor_get_thresholds, NULL },
1417
{ "set_thresholds", &sensor_cmds,
1418
"<sensor> <threshold> <value> ... - Set the sensor's thresholds to"
1419
" the given values. If a threshold is not specified, it will not"
1420
" be modified. Thresholds are unc, uc, unr, lnr, lc. The u stands"
1421
" for upper, l for lower, nc for non-critical, c for critical, and"
1422
" nr for non-recoverable. The value is floating point.",
1423
ipmi_cmdlang_sensor_handler, sensor_set_thresholds, NULL },
1424
{ "get_hysteresis", &sensor_cmds,
1425
"<sensor> - Get the sensor's hysteresis values",
1426
ipmi_cmdlang_sensor_handler, sensor_get_hysteresis, NULL },
1427
{ "set_hysteresis", &sensor_cmds,
1428
"<sensor> <pos hyst> <neg hyst> - Set the sensor's"
1429
" hysteresis to the given values. These are raw integer"
1430
" value; hystersis is specified as a raw value and it cannot be"
1431
" converted to floating point because the function may be"
1432
" non-linear.",
1433
ipmi_cmdlang_sensor_handler, sensor_set_hysteresis, NULL },
1434
{ "get_event_enables", &sensor_cmds,
1435
"<sensor> - Get the sensor's event enable values",
1436
ipmi_cmdlang_sensor_handler, sensor_get_event_enables, NULL },
1437
{ "set_event_enables", &sensor_cmds,
1438
"<sensor> msg|nomsg scan|noscan [<event> [<event> ...]]- Set the"
1439
" sensor's event enable values. This turns sensor messages and"
1440
" scanning on and off and will enable all the listed events and"
1441
" disable all over events. The"
1442
" events are in the same format as the rearm subcommand and depend"
1443
" on the sensor type. See the rearm command for details.",
1444
ipmi_cmdlang_sensor_handler, sensor_set_event_enables, NULL },
1445
{ "enable_events", &sensor_cmds,
1446
"<sensor> msg|nomsg scan|noscan [<event> [<event> ...]]- Enable"
1447
" event enable values. This turns sensor messages and"
1448
" scanning on and off and will enable all the listed events. The"
1449
" events are in the same format as the rearm subcommand and depend"
1450
" on the sensor type. See the rearm command for details. This will"
1451
" only enable the given events, the other events will be left alone.",
1452
ipmi_cmdlang_sensor_handler, sensor_enable_events, NULL },
1453
{ "disable_events", &sensor_cmds,
1454
"<sensor> msg|nomsg scan|noscan [<event> [<event> ...]]- Disable"
1455
" event enable values. This turns sensor messages and"
1456
" scanning on and off and will disable all the listed events. The"
1457
" events are in the same format as the rearm subcommand and depend"
1458
" on the sensor type. See the rearm command for details. This will"
1459
" only disable the given events, the other events will be left alone.",
1460
ipmi_cmdlang_sensor_handler, sensor_disable_events, NULL },
1461
};
1462
#define CMDS_SENSOR_LEN (sizeof(cmds_sensor)/sizeof(ipmi_cmdlang_init_t))
1463
1464
int
1465
ipmi_cmdlang_sensor_init(os_handler_t *os_hnd)
1466
{
1467
return ipmi_cmdlang_reg_table(cmds_sensor, CMDS_SENSOR_LEN);
1468
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1