1 /*
2 * Copyright (C) 2007-2015 FreeIPMI Core Team
3 *
4 * This program is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation, either version 3 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program. If not, see <http://www.gnu.org/licenses/>.
16 *
17 */
18
19 #if HAVE_CONFIG_H
20 #include "config.h"
21 #endif /* HAVE_CONFIG_H */
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #if STDC_HEADERS
26 #include <string.h>
27 #endif /* STDC_HEADERS */
28 #include <assert.h>
29
30 #include <freeipmi/freeipmi.h>
31
32 #include "ipmi-chassis.h"
33 #include "ipmi-chassis-argp.h"
34
35 #include "freeipmi-portability.h"
36 #include "pstdout.h"
37 #include "tool-common.h"
38 #include "tool-cmdline-common.h"
39 #include "tool-hostrange-common.h"
40 #include "tool-util-common.h"
41
42 static int
get_chassis_capabilities(ipmi_chassis_state_data_t * state_data)43 get_chassis_capabilities (ipmi_chassis_state_data_t *state_data)
44 {
45 fiid_obj_t obj_cmd_rs = NULL;
46 uint8_t fru_info_device_address;
47 uint8_t sdr_device_address;
48 uint8_t sel_device_address;
49 uint8_t system_management_device_address;
50 uint8_t bridge_device_address;
51 int flag;
52 uint64_t val = 0;
53 int rv = -1;
54
55 if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_get_chassis_capabilities_rs)))
56 {
57 pstdout_fprintf (state_data->pstate,
58 stderr,
59 "fiid_obj_create: %s\n",
60 strerror (errno));
61 goto cleanup;
62 }
63
64 if (ipmi_cmd_get_chassis_capabilities (state_data->ipmi_ctx, obj_cmd_rs) < 0)
65 {
66 pstdout_fprintf (state_data->pstate,
67 stderr,
68 "ipmi_cmd_get_chassis_capabilities: %s\n",
69 ipmi_ctx_errormsg (state_data->ipmi_ctx));
70 goto cleanup;
71 }
72
73 if (FIID_OBJ_GET (obj_cmd_rs,
74 "capabilities_flags.provides_intrusion_sensor",
75 &val) < 0)
76 {
77 pstdout_fprintf (state_data->pstate,
78 stderr,
79 "FIID_OBJ_GET: 'capabilities_flags.provides_intrusion_sensor': %s\n",
80 fiid_obj_errormsg (obj_cmd_rs));
81 goto cleanup;
82 }
83
84 pstdout_printf (state_data->pstate,
85 "Intrusion sensor : %s\n",
86 (val ? "provided" : "not provided"));
87
88 if (FIID_OBJ_GET (obj_cmd_rs,
89 "capabilities_flags.provides_front_panel_lockout",
90 &val) < 0)
91 {
92 pstdout_fprintf (state_data->pstate,
93 stderr,
94 "FIID_OBJ_GET: 'capabilities_flags.provides_front_panel_lockout': %s\n",
95 fiid_obj_errormsg (obj_cmd_rs));
96 goto cleanup;
97 }
98
99 pstdout_printf (state_data->pstate,
100 "Front Panel Lockout : %s\n",
101 (val ? "provided" : "not provided"));
102
103 if (FIID_OBJ_GET (obj_cmd_rs,
104 "capabilities_flags.provides_diagnostic_interrupt",
105 &val) < 0)
106 {
107 pstdout_fprintf (state_data->pstate,
108 stderr,
109 "FIID_OBJ_GET: 'capabilities_flags.provides_diagnostic_interrupt': %s\n",
110 fiid_obj_errormsg (obj_cmd_rs));
111 goto cleanup;
112 }
113
114 pstdout_printf (state_data->pstate,
115 "Diagnostic Interrupt : %s\n",
116 (val ? "provided" : "not provided"));
117
118 if (FIID_OBJ_GET (obj_cmd_rs,
119 "capabilities_flags.provides_power_interlock",
120 &val) < 0)
121 {
122 pstdout_fprintf (state_data->pstate,
123 stderr,
124 "FIID_OBJ_GET: 'capabilities_flags.provides_power_interlock': %s\n",
125 fiid_obj_errormsg (obj_cmd_rs));
126 goto cleanup;
127 }
128
129 pstdout_printf (state_data->pstate,
130 "Power interlock : %s\n",
131 (val ? "provided" : "not provided"));
132
133 if (FIID_OBJ_GET (obj_cmd_rs,
134 "fru_info_device_address",
135 &val) < 0)
136 {
137 pstdout_fprintf (state_data->pstate,
138 stderr,
139 "FIID_OBJ_GET: 'fru_info_device_address': %s\n",
140 fiid_obj_errormsg (obj_cmd_rs));
141 goto cleanup;
142 }
143 fru_info_device_address = val;
144
145 pstdout_printf (state_data->pstate,
146 "FRU Info Device Address : %Xh %s\n",
147 fru_info_device_address,
148 (val ? "" : "(Unspecified)"));
149
150 if (FIID_OBJ_GET (obj_cmd_rs,
151 "sdr_device_address",
152 &val) < 0)
153 {
154 pstdout_fprintf (state_data->pstate,
155 stderr,
156 "FIID_OBJ_GET: 'sdr_device_address': %s\n",
157 fiid_obj_errormsg (obj_cmd_rs));
158 goto cleanup;
159 }
160 sdr_device_address = val;
161
162 pstdout_printf (state_data->pstate,
163 "SDR Device Address : %Xh\n",
164 sdr_device_address);
165
166 if (FIID_OBJ_GET (obj_cmd_rs,
167 "sel_device_address",
168 &val) < 0)
169 {
170 pstdout_fprintf (state_data->pstate,
171 stderr,
172 "FIID_OBJ_GET: 'sel_device_address': %s\n",
173 fiid_obj_errormsg (obj_cmd_rs));
174 goto cleanup;
175 }
176 sel_device_address = val;
177
178 pstdout_printf (state_data->pstate,
179 "SEL Device Address : %Xh\n",
180 sel_device_address);
181
182 if (FIID_OBJ_GET (obj_cmd_rs,
183 "system_management_device_address",
184 &val) < 0)
185 {
186 pstdout_fprintf (state_data->pstate,
187 stderr,
188 "FIID_OBJ_GET: 'system_management_device_address': %s\n",
189 fiid_obj_errormsg (obj_cmd_rs));
190 goto cleanup;
191 }
192 system_management_device_address = val;
193
194 pstdout_printf (state_data->pstate,
195 "Sys Mgmt Device Address : %Xh\n",
196 system_management_device_address);
197
198 if ((flag = fiid_obj_get (obj_cmd_rs, "bridge_device_address", &val)) < 0)
199 {
200 pstdout_fprintf (state_data->pstate,
201 stderr,
202 "fiid_obj_get: 'system_management_device_address': %s\n",
203 fiid_obj_errormsg (obj_cmd_rs));
204 goto cleanup;
205 }
206 bridge_device_address = val;
207
208 if (flag)
209 pstdout_printf (state_data->pstate,
210 "Bridge Device Address : %Xh\n",
211 bridge_device_address);
212 else
213 pstdout_printf (state_data->pstate,
214 "Bridge Device Address : 20h (assuming default)\n");
215
216 rv = 0;
217 cleanup:
218 fiid_obj_destroy (obj_cmd_rs);
219 return (rv);
220 }
221
222 static int
get_chassis_status(ipmi_chassis_state_data_t * state_data)223 get_chassis_status (ipmi_chassis_state_data_t *state_data)
224 {
225 fiid_obj_t obj_cmd_rs = NULL;
226 uint64_t val = 0, temp_val;
227 char *str;
228 int rv = -1;
229 int flag;
230
231 if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_get_chassis_status_rs)))
232 {
233 pstdout_fprintf (state_data->pstate,
234 stderr,
235 "fiid_obj_create: %s\n",
236 strerror (errno));
237 goto cleanup;
238 }
239
240 if (ipmi_cmd_get_chassis_status (state_data->ipmi_ctx, obj_cmd_rs) < 0)
241 {
242 pstdout_fprintf (state_data->pstate,
243 stderr,
244 "ipmi_cmd_get_chassis_status: %s\n",
245 ipmi_ctx_errormsg (state_data->ipmi_ctx));
246 goto cleanup;
247 }
248
249 if (FIID_OBJ_GET (obj_cmd_rs, "current_power_state.power_is_on", &val) < 0)
250 {
251 pstdout_fprintf (state_data->pstate,
252 stderr,
253 "FIID_OBJ_GET: 'current_power_state.power_is_on': %s\n",
254 fiid_obj_errormsg (obj_cmd_rs));
255 goto cleanup;
256 }
257
258 pstdout_printf (state_data->pstate,
259 "System Power : %s\n",
260 val ? "on" : "off");
261
262 if (FIID_OBJ_GET (obj_cmd_rs, "current_power_state.power_overload", &val) < 0)
263 {
264 pstdout_fprintf (state_data->pstate,
265 stderr,
266 "FIID_OBJ_GET: 'current_power_state.power_overload': %s\n",
267 fiid_obj_errormsg (obj_cmd_rs));
268 goto cleanup;
269 }
270
271 pstdout_printf (state_data->pstate,
272 "Power overload : %s\n",
273 val ? "true" : "false");
274
275 if (FIID_OBJ_GET (obj_cmd_rs, "current_power_state.interlock", &val) < 0)
276 {
277 pstdout_fprintf (state_data->pstate,
278 stderr,
279 "FIID_OBJ_GET: 'current_power_state.interlock': %s\n",
280 fiid_obj_errormsg (obj_cmd_rs));
281 goto cleanup;
282 }
283
284 pstdout_printf (state_data->pstate,
285 "Interlock : %s\n",
286 val ? "active" : "inactive");
287
288 if (FIID_OBJ_GET (obj_cmd_rs, "current_power_state.power_fault", &val) < 0)
289 {
290 pstdout_fprintf (state_data->pstate,
291 stderr,
292 "FIID_OBJ_GET: 'current_power_state.power_fault': %s\n",
293 fiid_obj_errormsg (obj_cmd_rs));
294 goto cleanup;
295 }
296
297 pstdout_printf (state_data->pstate,
298 "Power fault : %s\n",
299 val ? "true" : "false");
300
301 if (FIID_OBJ_GET (obj_cmd_rs, "current_power_state.power_control_fault", &val) < 0)
302 {
303 pstdout_fprintf (state_data->pstate,
304 stderr,
305 "FIID_OBJ_GET: 'current_power_state.power_control_fault': %s\n",
306 fiid_obj_errormsg (obj_cmd_rs));
307 goto cleanup;
308 }
309
310 pstdout_printf (state_data->pstate,
311 "Power control fault : %s\n",
312 val ? "true" : "false");
313
314 if (FIID_OBJ_GET (obj_cmd_rs, "current_power_state.power_restore_policy", &val) < 0)
315 {
316 pstdout_fprintf (state_data->pstate,
317 stderr,
318 "FIID_OBJ_GET: 'current_power_state.power_restore_policy': %s\n",
319 fiid_obj_errormsg (obj_cmd_rs));
320 goto cleanup;
321 }
322
323 switch (val)
324 {
325 case IPMI_POWER_RESTORE_POLICY_POWERED_OFF_AFTER_AC_RETURNS:
326 str = "Always off";
327 break;
328
329 case IPMI_POWER_RESTORE_POLICY_POWER_RESTORED_TO_STATE:
330 str = "Restore";
331 break;
332
333 case IPMI_POWER_RESTORE_POLICY_POWERS_UP_AFTER_AC_RETURNS:
334 str = "Always on";
335 break;
336
337 case IPMI_POWER_RESTORE_POLICY_UNKNOWN:
338 default:
339 str = "unknown";
340 break;
341 }
342
343 pstdout_printf (state_data->pstate,
344 "Power restore policy : %s\n",
345 str);
346
347 temp_val = IPMI_LAST_POWER_EVENT_UNKNOWN;
348
349 if (FIID_OBJ_GET (obj_cmd_rs, "last_power_event.ac_failed", &val) < 0)
350 {
351 pstdout_fprintf (state_data->pstate,
352 stderr,
353 "FIID_OBJ_GET: 'last_power_event.ac_failed': %s\n",
354 fiid_obj_errormsg (obj_cmd_rs));
355 goto cleanup;
356 }
357
358 if (val)
359 {
360 temp_val = IPMI_LAST_POWER_EVENT_AC_FAILED;
361 goto print;
362 }
363
364 if (FIID_OBJ_GET (obj_cmd_rs, "last_power_event.power_down_caused_by_power_overload", &val) < 0)
365 {
366 pstdout_fprintf (state_data->pstate,
367 stderr,
368 "FIID_OBJ_GET: 'last_power_event.power_down_caused_by_power_overload': %s\n",
369 fiid_obj_errormsg (obj_cmd_rs));
370 goto cleanup;
371 }
372
373 if (val)
374 {
375 temp_val = IPMI_LAST_POWER_EVENT_POWER_DOWN_POWER_OVERLOAD;
376 goto print;
377 }
378
379 if (FIID_OBJ_GET (obj_cmd_rs, "last_power_event.power_down_caused_by_power_interlock_being_activated", &val) < 0)
380 {
381 pstdout_fprintf (state_data->pstate,
382 stderr,
383 "FIID_OBJ_GET: 'last_power_event.power_down_caused_by_power_interlock_being_activated': %s\n",
384 fiid_obj_errormsg (obj_cmd_rs));
385 goto cleanup;
386 }
387
388 if (val)
389 {
390 temp_val = IPMI_LAST_POWER_EVENT_POWER_DOWN_INTERLOCK_ACTIVATED;
391 goto print;
392 }
393
394 if (FIID_OBJ_GET (obj_cmd_rs, "last_power_event.power_down_caused_by_power_fault", &val) < 0)
395 {
396 pstdout_fprintf (state_data->pstate,
397 stderr,
398 "FIID_OBJ_GET: 'last_power_event.power_down_caused_by_power_fault': %s\n",
399 fiid_obj_errormsg (obj_cmd_rs));
400 goto cleanup;
401 }
402
403 if (val)
404 {
405 temp_val = IPMI_LAST_POWER_EVENT_POWER_DOWN_POWER_FAULT;
406 goto print;
407 }
408
409 if (FIID_OBJ_GET (obj_cmd_rs, "last_power_event.power_on_entered_via_ipmi", &val) < 0)
410 {
411 pstdout_fprintf (state_data->pstate,
412 stderr,
413 "FIID_OBJ_GET: 'last_power_event.power_on_entered_via_ipmi': %s\n",
414 fiid_obj_errormsg (obj_cmd_rs));
415 goto cleanup;
416 }
417
418 if (val)
419 temp_val = IPMI_LAST_POWER_EVENT_POWER_ON_VIA_IPMI;
420
421 print:
422
423 switch (temp_val)
424 {
425 case IPMI_LAST_POWER_EVENT_AC_FAILED:
426 str = "ac failed";
427 break;
428 case IPMI_LAST_POWER_EVENT_POWER_DOWN_POWER_OVERLOAD:
429 str = "power down due to power overload";
430 break;
431 case IPMI_LAST_POWER_EVENT_POWER_DOWN_INTERLOCK_ACTIVATED:
432 str = "power down due to Activation of interlock switch";
433 break;
434 case IPMI_LAST_POWER_EVENT_POWER_DOWN_POWER_FAULT:
435 str = "power down due to power fault";
436 break;
437 case IPMI_LAST_POWER_EVENT_POWER_ON_VIA_IPMI:
438 str = "power on via ipmi command";
439 break;
440 default:
441 str = "unknown";
442 break;
443 }
444
445 pstdout_printf (state_data->pstate,
446 "Last Power Event : %s\n",
447 str);
448
449 if (FIID_OBJ_GET (obj_cmd_rs, "misc_chassis_state.chassis_intrusion_active", &val) < 0)
450 {
451 pstdout_fprintf (state_data->pstate,
452 stderr,
453 "FIID_OBJ_GET: 'misc_chassis_state.chassis_intrusion_active': %s\n",
454 fiid_obj_errormsg (obj_cmd_rs));
455 goto cleanup;
456 }
457
458 pstdout_printf (state_data->pstate,
459 "Chassis intrusion : %s\n",
460 val ? "active" : "inactive");
461
462 if (FIID_OBJ_GET (obj_cmd_rs, "misc_chassis_state.front_panel_lockout_active", &val) < 0)
463 {
464 pstdout_fprintf (state_data->pstate,
465 stderr,
466 "FIID_OBJ_GET: 'misc_chassis_state.front_panel_lockout_active': %s\n",
467 fiid_obj_errormsg (obj_cmd_rs));
468 goto cleanup;
469 }
470
471 pstdout_printf (state_data->pstate,
472 "Front panel lockout : %s\n",
473 val ? "active" : "inactive");
474
475 if (FIID_OBJ_GET (obj_cmd_rs, "misc_chassis_state.drive_fault", &val) < 0)
476 {
477 pstdout_fprintf (state_data->pstate,
478 stderr,
479 "FIID_OBJ_GET: 'misc_chassis_state.drive_fault': %s\n",
480 fiid_obj_errormsg (obj_cmd_rs));
481 goto cleanup;
482 }
483
484 pstdout_printf (state_data->pstate,
485 "Drive Fault : %s\n",
486 val ? "true" : "false");
487
488 if (FIID_OBJ_GET (obj_cmd_rs, "misc_chassis_state.cooling_fan_fault_detected", &val) < 0)
489 {
490 pstdout_fprintf (state_data->pstate,
491 stderr,
492 "FIID_OBJ_GET: 'misc_chassis_state.cooling_fan_fault_detected': %s\n",
493 fiid_obj_errormsg (obj_cmd_rs));
494 goto cleanup;
495 }
496
497 pstdout_printf (state_data->pstate,
498 "Cooling/fan fault : %s\n",
499 val ? "true" : "false");
500
501 if (FIID_OBJ_GET (obj_cmd_rs, "misc_chassis_state.chassis_identify_command_and_state_info_supported", &val) < 0)
502 {
503 pstdout_fprintf (state_data->pstate,
504 stderr,
505 "FIID_OBJ_GET: 'misc_chassis_state.chassis_identify_command_and_state_info_supported': %s\n",
506 fiid_obj_errormsg (obj_cmd_rs));
507 goto cleanup;
508 }
509
510 if (val)
511 {
512 if (FIID_OBJ_GET (obj_cmd_rs, "misc_chassis_state.chassis_identify_state", &val) < 0)
513 {
514 pstdout_fprintf (state_data->pstate,
515 stderr,
516 "FIID_OBJ_GET: 'misc_chassis_state.chassis_identify_state': %s\n",
517 fiid_obj_errormsg (obj_cmd_rs));
518 goto cleanup;
519 }
520
521 switch (val)
522 {
523 case IPMI_CHASSIS_IDENTIFY_STATE_OFF:
524 str = "off";
525 break;
526
527 case IPMI_CHASSIS_IDENTIFY_STATE_TEMPORARY_ON:
528 str = "Timed on";
529 break;
530
531 case IPMI_CHASSIS_IDENTIFY_STATE_INDEFINITE_ON:
532 str = "Indefinite on";
533 break;
534
535 default:
536 str = "unknown";
537 break;
538 }
539
540 pstdout_printf (state_data->pstate,
541 "Chassis Identify state : %s\n",
542 str);
543
544 }
545
546 if ((flag = fiid_obj_get (obj_cmd_rs,
547 "front_panel.power_off_button_disabled",
548 &val)) < 0)
549 {
550 pstdout_fprintf (state_data->pstate,
551 stderr,
552 "fiid_obj_get: 'front_panel.power_off_button_disabled': %s\n",
553 fiid_obj_errormsg (obj_cmd_rs));
554 goto cleanup;
555 }
556
557 if (flag)
558 {
559 pstdout_printf (state_data->pstate,
560 "Power off button : %s\n",
561 val ? "disabled" : "enabled");
562
563 if (FIID_OBJ_GET (obj_cmd_rs, "front_panel.reset_button_disabled", &val) < 0)
564 {
565 pstdout_fprintf (state_data->pstate,
566 stderr,
567 "FIID_OBJ_GET: 'front_panel.reset_button_disabled': %s\n",
568 fiid_obj_errormsg (obj_cmd_rs));
569 goto cleanup;
570 }
571
572 pstdout_printf (state_data->pstate,
573 "Reset button : %s\n",
574 val ? "disabled" : "enabled");
575
576 if (FIID_OBJ_GET (obj_cmd_rs, "front_panel.diagnostic_interrupt_button_disabled", &val) < 0)
577 {
578 pstdout_fprintf (state_data->pstate,
579 stderr,
580 "FIID_OBJ_GET: 'front_panel.diagnostic_interrupt_button_disabled': %s\n",
581 fiid_obj_errormsg (obj_cmd_rs));
582 goto cleanup;
583 }
584
585 pstdout_printf (state_data->pstate,
586 "Diagnostic Interrupt button : %s\n",
587 val ? "disabled" : "enabled");
588
589 if (FIID_OBJ_GET (obj_cmd_rs, "front_panel.standby_button_disabled", &val) < 0)
590 {
591 pstdout_fprintf (state_data->pstate,
592 stderr,
593 "FIID_OBJ_GET: 'front_panel.standby_button_disabled': %s\n",
594 fiid_obj_errormsg (obj_cmd_rs));
595 goto cleanup;
596 }
597
598 pstdout_printf (state_data->pstate,
599 "Standby button : %s\n",
600 val ? "disabled" : "enabled");
601
602 if (FIID_OBJ_GET (obj_cmd_rs, "front_panel.power_off_button_disable_allowed", &val) < 0)
603 {
604 pstdout_fprintf (state_data->pstate,
605 stderr,
606 "FIID_OBJ_GET: 'front_panel.power_off_button_disable_allowed': %s\n",
607 fiid_obj_errormsg (obj_cmd_rs));
608 goto cleanup;
609 }
610
611 pstdout_printf (state_data->pstate,
612 "Power off button disable : %s\n",
613 val ? "allowed" : "unallowed");
614
615 if (FIID_OBJ_GET (obj_cmd_rs, "front_panel.reset_button_disable_allowed", &val) < 0)
616 {
617 pstdout_fprintf (state_data->pstate,
618 stderr,
619 "FIID_OBJ_GET: 'front_panel.reset_button_disable_allowed': %s\n",
620 fiid_obj_errormsg (obj_cmd_rs));
621 goto cleanup;
622 }
623
624 pstdout_printf (state_data->pstate,
625 "Reset button disable : %s\n",
626 val ? "allowed" : "unallowed");
627
628 if (FIID_OBJ_GET (obj_cmd_rs, "front_panel.diagnostic_interrupt_button_disable_allowed", &val) < 0)
629 {
630 pstdout_fprintf (state_data->pstate,
631 stderr,
632 "FIID_OBJ_GET: 'front_panel.diagnostic_interrupt_button_disable_allowed': %s\n",
633 fiid_obj_errormsg (obj_cmd_rs));
634 goto cleanup;
635 }
636
637 pstdout_printf (state_data->pstate,
638 "Diagnostic interrupt button disable : %s\n",
639 val ? "allowed" : "unallowed");
640
641 if (FIID_OBJ_GET (obj_cmd_rs, "front_panel.standby_button_disable_allowed", &val) < 0)
642 {
643 pstdout_fprintf (state_data->pstate,
644 stderr,
645 "FIID_OBJ_GET: 'front_panel.standby_button_disable_allowed': %s\n",
646 fiid_obj_errormsg (obj_cmd_rs));
647 goto cleanup;
648 }
649
650 pstdout_printf (state_data->pstate,
651 "Standby button disable : %s\n",
652 val ? "allowed" : "unallowed");
653 }
654
655 pstdout_printf (state_data->pstate, "\n");
656
657 rv = 0;
658 cleanup:
659 fiid_obj_destroy (obj_cmd_rs);
660 return (rv);
661 }
662
663 static int
chassis_control(ipmi_chassis_state_data_t * state_data)664 chassis_control (ipmi_chassis_state_data_t *state_data)
665 {
666 fiid_obj_t obj_cmd_rs = NULL;
667 int rv = -1;
668 struct ipmi_chassis_arguments *args;
669
670 args = state_data->prog_data->args;
671
672 if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_chassis_control_rs)))
673 {
674 pstdout_fprintf (state_data->pstate,
675 stderr,
676 "fiid_obj_create: %s\n",
677 strerror (errno));
678 goto cleanup;
679 }
680
681 if (ipmi_cmd_chassis_control (state_data->ipmi_ctx,
682 args->chassis_control_arg,
683 obj_cmd_rs) < 0)
684 {
685 pstdout_fprintf (state_data->pstate,
686 stderr,
687 "ipmi_cmd_chassis_control: %s\n",
688 ipmi_ctx_errormsg (state_data->ipmi_ctx));
689 goto cleanup;
690 }
691
692 rv = 0;
693 cleanup:
694 fiid_obj_destroy (obj_cmd_rs);
695 return (rv);
696 }
697
698 static int
chassis_identify(ipmi_chassis_state_data_t * state_data)699 chassis_identify (ipmi_chassis_state_data_t *state_data)
700 {
701 fiid_obj_t obj_cmd_rs = NULL;
702 int rv = -1;
703 struct ipmi_chassis_arguments *args;
704
705 args = state_data->prog_data->args;
706
707 if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_chassis_identify_rs)))
708 {
709 pstdout_fprintf (state_data->pstate,
710 stderr,
711 "fiid_obj_create: %s\n",
712 strerror (errno));
713 goto cleanup;
714 }
715
716 if (ipmi_cmd_chassis_identify (state_data->ipmi_ctx,
717 (args->chassis_identify_args.identify_interval) ? &args->chassis_identify_args.identify_interval_arg : NULL,
718 (args->chassis_identify_args.force_identify) ? &args->chassis_identify_args.force_identify_arg : NULL,
719 obj_cmd_rs) < 0)
720 {
721 pstdout_fprintf (state_data->pstate,
722 stderr,
723 "ipmi_cmd_chassis_identify: %s\n",
724 ipmi_ctx_errormsg (state_data->ipmi_ctx));
725 goto cleanup;
726 }
727
728 rv = 0;
729 cleanup:
730 fiid_obj_destroy (obj_cmd_rs);
731 return (rv);
732 }
733
734 static int
set_power_restore_policy(ipmi_chassis_state_data_t * state_data)735 set_power_restore_policy (ipmi_chassis_state_data_t *state_data)
736 {
737 fiid_obj_t obj_cmd_rs = NULL;
738 uint64_t val = 0;
739 int rv = -1;
740 struct ipmi_chassis_arguments *args;
741
742 args = state_data->prog_data->args;
743
744 if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_set_power_restore_policy_rs)))
745 {
746 pstdout_fprintf (state_data->pstate,
747 stderr,
748 "fiid_obj_create: %s\n",
749 strerror (errno));
750 goto cleanup;
751 }
752
753 if (ipmi_cmd_set_power_restore_policy (state_data->ipmi_ctx,
754 args->set_power_restore_policy_arg,
755 obj_cmd_rs) < 0)
756 {
757 pstdout_fprintf (state_data->pstate,
758 stderr,
759 "ipmi_cmd_set_power_restore_policy: %s\n",
760 ipmi_ctx_errormsg (state_data->ipmi_ctx));
761 goto cleanup;
762 }
763
764 if (args->set_power_restore_policy_arg == IPMI_POWER_RESTORE_POLICY_NO_CHANGE)
765 {
766 char policy_supported[100];
767
768 memset (policy_supported, '\0', sizeof (policy_supported));
769
770 if (FIID_OBJ_GET (obj_cmd_rs, "powered_off_after_ac_mains_returns", &val) < 0)
771 {
772 pstdout_fprintf (state_data->pstate,
773 stderr,
774 "FIID_OBJ_GET: 'powered_off_after_ac_mains_returns': %s\n",
775 fiid_obj_errormsg (obj_cmd_rs));
776 goto cleanup;
777 }
778
779 if (val)
780 strcat (policy_supported, "always-off ");
781
782 if (FIID_OBJ_GET (obj_cmd_rs, "always_powering_up_after_ac_mains_returns", &val) < 0)
783 {
784 pstdout_fprintf (state_data->pstate,
785 stderr,
786 "FIID_OBJ_GET: 'always_powering_up_after_ac_mains_returns': %s\n",
787 fiid_obj_errormsg (obj_cmd_rs));
788 goto cleanup;
789 }
790
791 if (val)
792 strcat (policy_supported, "always-on ");
793
794 if (FIID_OBJ_GET (obj_cmd_rs, "restoring_power_to_state_when_ac_mains_was_lost", &val) < 0)
795 {
796 pstdout_fprintf (state_data->pstate,
797 stderr,
798 "FIID_OBJ_GET: 'restoring_power_to_state_when_ac_mains_was_lost': %s\n",
799 fiid_obj_errormsg (obj_cmd_rs));
800 goto cleanup;
801 }
802
803 if (val)
804 strcat (policy_supported, "Restore");
805
806 pstdout_printf (state_data->pstate,
807 "Policies supported : %s\n",
808 policy_supported);
809 }
810
811 rv = 0;
812 cleanup:
813 fiid_obj_destroy (obj_cmd_rs);
814 return (rv);
815 }
816
817 static int
set_power_cycle_interval(ipmi_chassis_state_data_t * state_data)818 set_power_cycle_interval (ipmi_chassis_state_data_t *state_data)
819 {
820 fiid_obj_t obj_cmd_rs = NULL;
821 int rv = -1;
822 struct ipmi_chassis_arguments *args;
823
824 args = state_data->prog_data->args;
825
826 if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_set_power_cycle_interval_rs)))
827 {
828 pstdout_fprintf (state_data->pstate,
829 stderr,
830 "fiid_obj_create: %s\n",
831 strerror (errno));
832 goto cleanup;
833 }
834
835 if (ipmi_cmd_set_power_cycle_interval (state_data->ipmi_ctx,
836 args->set_power_cycle_interval_arg,
837 obj_cmd_rs) < 0)
838 {
839 pstdout_fprintf (state_data->pstate,
840 stderr,
841 "ipmi_cmd_set_power_cycle_interval: %s\n",
842 ipmi_ctx_errormsg (state_data->ipmi_ctx));
843 goto cleanup;
844 }
845
846 rv = 0;
847 cleanup:
848 fiid_obj_destroy (obj_cmd_rs);
849 return (rv);
850 }
851
852 static int
get_system_restart_cause(ipmi_chassis_state_data_t * state_data)853 get_system_restart_cause (ipmi_chassis_state_data_t *state_data)
854 {
855 fiid_obj_t obj_cmd_rs = NULL;
856 uint64_t val = 0;
857 char *restart_cause_str;
858 int rv = -1;
859
860 if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_get_system_restart_cause_rs)))
861 {
862 pstdout_fprintf (state_data->pstate,
863 stderr,
864 "fiid_obj_create: %s\n",
865 strerror (errno));
866 goto cleanup;
867 }
868
869 if (ipmi_cmd_get_system_restart_cause (state_data->ipmi_ctx, obj_cmd_rs) < 0)
870 {
871 pstdout_fprintf (state_data->pstate,
872 stderr,
873 "ipmi_cmd_get_system_restart_cause: %s\n",
874 ipmi_ctx_errormsg (state_data->ipmi_ctx));
875 goto cleanup;
876 }
877
878 if (FIID_OBJ_GET (obj_cmd_rs, "restart_cause", &val) < 0)
879 {
880 pstdout_fprintf (state_data->pstate,
881 stderr,
882 "FIID_OBJ_GET: 'restart_cause': %s\n",
883 fiid_obj_errormsg (obj_cmd_rs));
884 goto cleanup;
885 }
886
887 switch (val)
888 {
889 case IPMI_CHASSIS_SYSTEM_RESTART_CAUSE_UNKNOWN:
890 restart_cause_str = "unknown";
891 break;
892 case IPMI_CHASSIS_SYSTEM_RESTART_CAUSE_CHASSIS_CONTROL_COMMAND:
893 restart_cause_str = "Chassis control command";
894 break;
895 case IPMI_CHASSIS_SYSTEM_RESTART_CAUSE_RESET_VIA_PUSHBUTTON:
896 restart_cause_str = "Reset via pushbutton";
897 break;
898 case IPMI_CHASSIS_SYSTEM_RESTART_CAUSE_POWER_UP_VIA_POWER_PUSHBUTTON:
899 restart_cause_str = "Power up via power pushbutton";
900 break;
901 case IPMI_CHASSIS_SYSTEM_RESTART_CAUSE_WATCHDOG_EXPIRATION:
902 restart_cause_str = "Watchdog expiration";
903 break;
904 case IPMI_CHASSIS_SYSTEM_RESTART_CAUSE_OEM:
905 restart_cause_str = "OEM";
906 break;
907 case IPMI_CHASSIS_SYSTEM_RESTART_CAUSE_AUTOMATIC_POWER_UP_ALWAYS_RESTORE:
908 restart_cause_str = "Automatic power-up on AC being applied due to \"always restore\" power restore policy";
909 break;
910 case IPMI_CHASSIS_SYSTEM_RESTART_CAUSE_AUTOMATIC_POWER_UP_RESTORE_PREVIOUS:
911 restart_cause_str = "Automatic power-up on AC being applied due to \"restore previous power state\" power restore policy";
912 break;
913 case IPMI_CHASSIS_SYSTEM_RESTART_CAUSE_RESET_VIA_PEF:
914 restart_cause_str = "Reset via PEF";
915 break;
916 case IPMI_CHASSIS_SYSTEM_RESTART_CAUSE_POWER_CYCLE_VIA_PEF:
917 restart_cause_str = "Power cycle via PEF";
918 break;
919 case IPMI_CHASSIS_SYSTEM_RESTART_CAUSE_SOFT_RESET:
920 restart_cause_str = "Soft reset";
921 break;
922 case IPMI_CHASSIS_SYSTEM_RESTART_CAUSE_POWER_UP_VIA_RTC:
923 restart_cause_str = "Power up via RTC";
924 break;
925 default:
926 restart_cause_str = "unknown";
927 }
928
929 pstdout_printf (state_data->pstate,
930 "Restart cause : %s\n",
931 restart_cause_str);
932
933 rv = 0;
934 cleanup:
935 fiid_obj_destroy (obj_cmd_rs);
936 return (rv);
937 }
938
939 static int
get_power_on_hours_counter(ipmi_chassis_state_data_t * state_data)940 get_power_on_hours_counter (ipmi_chassis_state_data_t *state_data)
941 {
942 fiid_obj_t obj_cmd_rs = NULL;
943 uint64_t val = 0;
944 uint8_t minutes_per_counter;
945 uint32_t counter_reading, min, hrs;
946 int rv = -1;
947
948 if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_get_power_on_hours_counter_rs)))
949 {
950 pstdout_fprintf (state_data->pstate,
951 stderr,
952 "fiid_obj_create: %s\n",
953 strerror (errno));
954 goto cleanup;
955 }
956
957 if (ipmi_cmd_get_power_on_hours_counter (state_data->ipmi_ctx, obj_cmd_rs) < 0)
958 {
959 pstdout_fprintf (state_data->pstate,
960 stderr,
961 "ipmi_cmd_get_power_on_hours_counter: %s\n",
962 ipmi_ctx_errormsg (state_data->ipmi_ctx));
963 goto cleanup;
964 }
965
966 if (FIID_OBJ_GET (obj_cmd_rs, "minutes_per_counter", &val) < 0)
967 {
968 pstdout_fprintf (state_data->pstate,
969 stderr,
970 "FIID_OBJ_GET: 'minutes_per_counter': %s\n",
971 fiid_obj_errormsg (obj_cmd_rs));
972 goto cleanup;
973 }
974
975 minutes_per_counter = val;
976
977 if (FIID_OBJ_GET (obj_cmd_rs, "counter_reading", &val) < 0)
978 {
979 pstdout_fprintf (state_data->pstate,
980 stderr,
981 "FIID_OBJ_GET: 'counter_reading': %s\n",
982 fiid_obj_errormsg (obj_cmd_rs));
983 goto cleanup;
984 }
985
986 counter_reading = val;
987
988 min = counter_reading / minutes_per_counter;
989
990 hrs = min / 60;
991
992 min = min % 60;
993
994 pstdout_printf (state_data->pstate,
995 "Power on hours : %u Hours %u Minutes\n",
996 hrs,
997 min);
998 rv = 0;
999
1000 cleanup:
1001 fiid_obj_destroy (obj_cmd_rs);
1002 return (rv);
1003 }
1004
1005 static int
get_boot_flags(ipmi_chassis_state_data_t * state_data)1006 get_boot_flags (ipmi_chassis_state_data_t *state_data)
1007 {
1008 fiid_obj_t obj_cmd_rs = NULL;
1009 uint64_t val = 0;
1010 int rv = -1;
1011 char *str;
1012
1013 if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_get_system_boot_options_boot_flags_rs)))
1014 {
1015 pstdout_fprintf (state_data->pstate,
1016 stderr,
1017 "fiid_obj_create: %s\n",
1018 strerror (errno));
1019 goto cleanup;
1020 }
1021
1022 if (ipmi_cmd_get_system_boot_options_boot_flags (state_data->ipmi_ctx,
1023 IPMI_SYSTEM_BOOT_OPTIONS_NO_SET_SELECTOR,
1024 IPMI_SYSTEM_BOOT_OPTIONS_NO_BLOCK_SELECTOR,
1025 obj_cmd_rs) < 0)
1026 {
1027 pstdout_fprintf (state_data->pstate,
1028 stderr,
1029 "ipmi_cmd_get_system_boot_options_boot_flags failed: %s\n",
1030 ipmi_ctx_errormsg (state_data->ipmi_ctx));
1031 goto cleanup;
1032 }
1033
1034 if (FIID_OBJ_GET (obj_cmd_rs, "bios_boot_type", &val) < 0)
1035 {
1036 pstdout_fprintf (state_data->pstate,
1037 stderr,
1038 "FIID_OBJ_GET: 'bios_boot_type': %s\n",
1039 fiid_obj_errormsg (obj_cmd_rs));
1040 goto cleanup;
1041 }
1042
1043 if (val == IPMI_SYSTEM_BOOT_OPTION_BOOT_FLAG_BOOT_TYPE_PC_COMPATIBLE)
1044 str = "PC compatible boot";
1045 else
1046 str = "Extensible firmware Interface boot";
1047
1048 pstdout_printf (state_data->pstate,
1049 "BIOS boot type : %s\n",
1050 str);
1051
1052 if (FIID_OBJ_GET (obj_cmd_rs, "lock_out_reset_button", &val) < 0)
1053 {
1054 pstdout_fprintf (state_data->pstate,
1055 stderr,
1056 "FIID_OBJ_GET: 'lock_out_reset_button': %s\n",
1057 fiid_obj_errormsg (obj_cmd_rs));
1058 goto cleanup;
1059 }
1060
1061 if (val == IPMI_SYSTEM_BOOT_OPTION_ENABLE)
1062 str = "Enabled";
1063 else
1064 str = "Disabled";
1065
1066 pstdout_printf (state_data->pstate,
1067 "Lock out reset buttons : %s\n",
1068 str);
1069
1070 if (FIID_OBJ_GET (obj_cmd_rs, "screen_blank", &val) < 0)
1071 {
1072 pstdout_fprintf (state_data->pstate,
1073 stderr,
1074 "FIID_OBJ_GET: 'screen_blank': %s\n",
1075 fiid_obj_errormsg (obj_cmd_rs));
1076 goto cleanup;
1077 }
1078
1079 if (val == IPMI_SYSTEM_BOOT_OPTION_ENABLE)
1080 str = "Enabled";
1081 else
1082 str = "Disabled";
1083
1084 pstdout_printf (state_data->pstate,
1085 "Screen blank : %s\n",
1086 str);
1087
1088 if (FIID_OBJ_GET (obj_cmd_rs, "boot_device", &val) < 0)
1089 {
1090 pstdout_fprintf (state_data->pstate,
1091 stderr,
1092 "FIID_OBJ_GET: 'boot_device': %s\n",
1093 fiid_obj_errormsg (obj_cmd_rs));
1094 goto cleanup;
1095 }
1096
1097 if (val == IPMI_SYSTEM_BOOT_OPTION_BOOT_FLAG_BOOT_DEVICE_NO_OVERRIDE)
1098 str = "No override";
1099 else if (val == IPMI_SYSTEM_BOOT_OPTION_BOOT_FLAG_BOOT_DEVICE_FORCE_PXE)
1100 str = "Force PXE";
1101 else if (val == IPMI_SYSTEM_BOOT_OPTION_BOOT_FLAG_BOOT_DEVICE_FORCE_HARD_DRIVE)
1102 str = "Force boot from default Hard drive";
1103 else if (val == IPMI_SYSTEM_BOOT_OPTION_BOOT_FLAG_BOOT_DEVICE_FORCE_HARD_DRIVE_SAFE_MODE)
1104 str = "Force boot from default Hard drive, request safe mode";
1105 else if (val == IPMI_SYSTEM_BOOT_OPTION_BOOT_FLAG_BOOT_DEVICE_FORCE_DIAGNOSTIC_PARTITION)
1106 str = "Force boot from default Diagnostic partition";
1107 else if (val == IPMI_SYSTEM_BOOT_OPTION_BOOT_FLAG_BOOT_DEVICE_FORCE_CD_DVD)
1108 str = "Force boot from default CD/DVD";
1109 else if (val == IPMI_SYSTEM_BOOT_OPTION_BOOT_FLAG_BOOT_DEVICE_FORCE_BIOS_SETUP)
1110 str = "Force boot into BIOS setup";
1111 else if (val == IPMI_SYSTEM_BOOT_OPTION_BOOT_FLAG_BOOT_DEVICE_FORCE_FLOPPY_REMOVEABLE_MEDIA)
1112 str = "Force boot from default Floppy/primary removable media";
1113 else
1114 str = "unknown";
1115
1116 pstdout_printf (state_data->pstate,
1117 "Boot device selector : %s\n",
1118 str);
1119
1120 if (FIID_OBJ_GET (obj_cmd_rs, "lock_keyboard", &val) < 0)
1121 {
1122 pstdout_fprintf (state_data->pstate,
1123 stderr,
1124 "FIID_OBJ_GET: 'lock_keyboard': %s\n",
1125 fiid_obj_errormsg (obj_cmd_rs));
1126 goto cleanup;
1127 }
1128
1129 if (val == IPMI_SYSTEM_BOOT_OPTION_ENABLE)
1130 str = "Enabled";
1131 else
1132 str = "Disabled";
1133
1134 pstdout_printf (state_data->pstate,
1135 "Lock keyboard : %s\n",
1136 str);
1137
1138 if (FIID_OBJ_GET (obj_cmd_rs, "cmos_clear", &val) < 0)
1139 {
1140 pstdout_fprintf (state_data->pstate,
1141 stderr,
1142 "FIID_OBJ_GET: 'cmos_clear': %s\n",
1143 fiid_obj_errormsg (obj_cmd_rs));
1144 goto cleanup;
1145 }
1146
1147 if (val == IPMI_SYSTEM_BOOT_OPTION_ENABLE)
1148 str = "Enabled";
1149 else
1150 str = "Disabled";
1151
1152 pstdout_printf (state_data->pstate,
1153 "Clear CMOS : %s\n",
1154 str);
1155
1156 if (FIID_OBJ_GET (obj_cmd_rs, "console_redirection", &val) < 0)
1157 {
1158 pstdout_fprintf (state_data->pstate,
1159 stderr,
1160 "FIID_OBJ_GET: 'console_redirection': %s\n",
1161 fiid_obj_errormsg (obj_cmd_rs));
1162 goto cleanup;
1163 }
1164
1165 if (val == IPMI_SYSTEM_BOOT_OPTION_BOOT_FLAG_CONSOLE_REDIRECTION_DEFAULT)
1166 str = "System default";
1167 else if (val == IPMI_SYSTEM_BOOT_OPTION_BOOT_FLAG_CONSOLE_REDIRECTION_SUPPRESS)
1168 str = "Suppressed";
1169 else if (val == IPMI_SYSTEM_BOOT_OPTION_BOOT_FLAG_CONSOLE_REDIRECTION_ENABLE)
1170 str = "Enabled";
1171 else
1172 str = "unknown";
1173
1174 pstdout_printf (state_data->pstate,
1175 "Console redirection control : %s\n",
1176 str);
1177
1178 if (FIID_OBJ_GET (obj_cmd_rs, "lock_out_sleep_button", &val) < 0)
1179 {
1180 pstdout_fprintf (state_data->pstate,
1181 stderr,
1182 "FIID_OBJ_GET: 'lock_out_sleep_button': %s\n",
1183 fiid_obj_errormsg (obj_cmd_rs));
1184 goto cleanup;
1185 }
1186
1187 if (val == IPMI_SYSTEM_BOOT_OPTION_ENABLE)
1188 str = "Enabled";
1189 else
1190 str = "Disabled";
1191
1192 pstdout_printf (state_data->pstate,
1193 "Lock out sleep button : %s\n",
1194 str);
1195
1196 if (FIID_OBJ_GET (obj_cmd_rs, "user_password_bypass", &val) < 0)
1197 {
1198 pstdout_fprintf (state_data->pstate,
1199 stderr,
1200 "FIID_OBJ_GET: 'user_password_bypass': %s\n",
1201 fiid_obj_errormsg (obj_cmd_rs));
1202 goto cleanup;
1203 }
1204
1205 if (val == IPMI_SYSTEM_BOOT_OPTION_ENABLE)
1206 str = "Enabled";
1207 else
1208 str = "Disabled";
1209
1210 pstdout_printf (state_data->pstate,
1211 "User password bypass : %s\n",
1212 str);
1213
1214 if (FIID_OBJ_GET (obj_cmd_rs, "lock_out_reset_button", &val) < 0)
1215 {
1216 pstdout_fprintf (state_data->pstate,
1217 stderr,
1218 "FIID_OBJ_GET: 'lock_out_reset_button': %s\n",
1219 fiid_obj_errormsg (obj_cmd_rs));
1220 goto cleanup;
1221 }
1222
1223 if (val == IPMI_SYSTEM_BOOT_OPTION_ENABLE)
1224 str = "Enabled";
1225 else
1226 str = "Disabled";
1227
1228 pstdout_printf (state_data->pstate,
1229 "Lock out reset button : %s\n",
1230 str);
1231
1232 if (FIID_OBJ_GET (obj_cmd_rs, "force_progress_event_traps", &val) < 0)
1233 {
1234 pstdout_fprintf (state_data->pstate,
1235 stderr,
1236 "FIID_OBJ_GET: 'force_progress_event_traps': %s\n",
1237 fiid_obj_errormsg (obj_cmd_rs));
1238 goto cleanup;
1239 }
1240
1241 if (val == IPMI_SYSTEM_BOOT_OPTION_ENABLE)
1242 str = "Enabled";
1243 else
1244 str = "Disabled";
1245
1246 pstdout_printf (state_data->pstate,
1247 "Force progress event traps : %s\n",
1248 str);
1249
1250 if (FIID_OBJ_GET (obj_cmd_rs, "firmware_bios_verbosity", &val) < 0)
1251 {
1252 pstdout_fprintf (state_data->pstate,
1253 stderr,
1254 "FIID_OBJ_GET: 'firmware_bios_verbosity': %s\n",
1255 fiid_obj_errormsg (obj_cmd_rs));
1256 goto cleanup;
1257 }
1258
1259 if (val == IPMI_SYSTEM_BOOT_OPTION_BOOT_FLAG_FIRMWARE_BIOS_VERBOSITY_QUIET)
1260 str = "Quiet";
1261 else if (val == IPMI_SYSTEM_BOOT_OPTION_BOOT_FLAG_FIRMWARE_BIOS_VERBOSITY_VERBOSE)
1262 str = "Verbose";
1263 else if (val == IPMI_SYSTEM_BOOT_OPTION_BOOT_FLAG_FIRMWARE_BIOS_VERBOSITY_DEFAULT)
1264 str = "Default";
1265 else
1266 str = "unknown";
1267
1268 pstdout_printf (state_data->pstate,
1269 "Firmware BIOS verbosity level : %s\n",
1270 str);
1271
1272 if (FIID_OBJ_GET (obj_cmd_rs, "lock_out_via_power_button", &val) < 0)
1273 {
1274 pstdout_fprintf (state_data->pstate,
1275 stderr,
1276 "FIID_OBJ_GET: 'lock_out_via_power_button': %s\n",
1277 fiid_obj_errormsg (obj_cmd_rs));
1278 goto cleanup;
1279 }
1280
1281 if (val == IPMI_SYSTEM_BOOT_OPTION_ENABLE)
1282 str = "Enabled";
1283 else
1284 str = "Disabled";
1285
1286 pstdout_printf (state_data->pstate,
1287 "Lock out via power button : %s\n",
1288 str);
1289
1290 rv = 0;
1291 cleanup:
1292 fiid_obj_destroy (obj_cmd_rs);
1293 return (rv);
1294 }
1295
1296 static int
set_boot_flags(ipmi_chassis_state_data_t * state_data)1297 set_boot_flags (ipmi_chassis_state_data_t *state_data)
1298 {
1299 fiid_obj_t obj_cmd_rs = NULL;
1300 fiid_obj_t boot_info_ack_obj_cmd_rs = NULL;
1301 fiid_obj_t get_boot_flags_rs = NULL;
1302 uint8_t boot_info_acknowledge = IPMI_SYSTEM_BOOT_OPTION_BOOT_INFO_UNACKNOWLEDGE;
1303 uint8_t bios_boot_type, boot_flags_persistent, boot_flags_valid,
1304 lock_out_reset_button, screen_blank, boot_device,
1305 lock_keyboard, cmos_clear, console_redirection, lock_out_sleep_button,
1306 user_password_bypass, force_progress_event_traps, firmware_bios_verbosity,
1307 lock_out_via_power_button, bios_mux_control_override, bios_shared_mode_override;
1308 uint64_t val =0;
1309 int rv = -1;
1310 struct ipmi_chassis_arguments *args;
1311
1312 args = state_data->prog_data->args;
1313
1314 if (!(get_boot_flags_rs = fiid_obj_create (tmpl_cmd_get_system_boot_options_boot_flags_rs)))
1315 {
1316 pstdout_fprintf (state_data->pstate,
1317 stderr,
1318 "fiid_obj_create: %s\n",
1319 strerror (errno));
1320 goto cleanup;
1321 }
1322
1323 if (!(boot_info_ack_obj_cmd_rs = fiid_obj_create (tmpl_cmd_set_system_boot_options_rs)))
1324 {
1325 pstdout_fprintf (state_data->pstate,
1326 stderr,
1327 "fiid_obj_create: %s\n",
1328 strerror (errno));
1329 goto cleanup;
1330 }
1331
1332 if (!(obj_cmd_rs = fiid_obj_create (tmpl_cmd_set_system_boot_options_rs)))
1333 {
1334 pstdout_fprintf (state_data->pstate,
1335 stderr,
1336 "fiid_obj_create: %s\n",
1337 strerror (errno));
1338 goto cleanup;
1339 }
1340
1341 if (ipmi_cmd_get_system_boot_options_boot_flags (state_data->ipmi_ctx,
1342 IPMI_SYSTEM_BOOT_OPTIONS_NO_SET_SELECTOR,
1343 IPMI_SYSTEM_BOOT_OPTIONS_NO_BLOCK_SELECTOR,
1344 get_boot_flags_rs) < 0)
1345 {
1346 pstdout_fprintf (state_data->pstate,
1347 stderr,
1348 "ipmi_cmd_get_system_boot_options_boot_flags: %s\n",
1349 ipmi_ctx_errormsg (state_data->ipmi_ctx));
1350 goto cleanup;
1351 }
1352
1353 if (args->set_system_boot_options_args.bios_boot_type)
1354 {
1355 if (FIID_OBJ_GET (get_boot_flags_rs, "bios_boot_type", &val) < 0)
1356 {
1357 pstdout_fprintf (state_data->pstate,
1358 stderr,
1359 "FIID_OBJ_GET: 'bios_boot_type': %s\n",
1360 fiid_obj_errormsg (obj_cmd_rs));
1361 goto cleanup;
1362 }
1363 bios_boot_type = val;
1364 }
1365 else
1366 bios_boot_type = args->set_system_boot_options_args.bios_boot_type_arg;
1367
1368 boot_flags_persistent = IPMI_SYSTEM_BOOT_OPTION_BOOT_FLAG_VALID_FOR_NEXT_BOOT;
1369 boot_flags_valid = IPMI_SYSTEM_BOOT_OPTION_BOOT_FLAG_VALID;
1370
1371 if (args->set_system_boot_options_args.lock_out_reset_button)
1372 {
1373 if (FIID_OBJ_GET (get_boot_flags_rs, "lock_out_reset_button", &val) < 0)
1374 {
1375 pstdout_fprintf (state_data->pstate,
1376 stderr,
1377 "FIID_OBJ_GET: 'lock_out_reset_button': %s\n",
1378 fiid_obj_errormsg (obj_cmd_rs));
1379 goto cleanup;
1380 }
1381 lock_out_reset_button = val;
1382 }
1383 else
1384 lock_out_reset_button = args->set_system_boot_options_args.lock_out_reset_button_arg;
1385
1386 if (args->set_system_boot_options_args.screen_blank)
1387 {
1388 if (FIID_OBJ_GET (get_boot_flags_rs, "screen_blank", &val) < 0)
1389 {
1390 pstdout_fprintf (state_data->pstate,
1391 stderr,
1392 "FIID_OBJ_GET: 'screen_blank': %s\n",
1393 fiid_obj_errormsg (obj_cmd_rs));
1394 goto cleanup;
1395 }
1396 screen_blank = val;
1397 }
1398 else
1399 screen_blank = args->set_system_boot_options_args.screen_blank_arg;
1400
1401 if (args->set_system_boot_options_args.boot_device)
1402 {
1403 if (FIID_OBJ_GET (get_boot_flags_rs, "boot_device", &val) < 0)
1404 {
1405 pstdout_fprintf (state_data->pstate,
1406 stderr,
1407 "FIID_OBJ_GET: 'boot_device': %s\n",
1408 fiid_obj_errormsg (obj_cmd_rs));
1409 goto cleanup;
1410 }
1411 boot_device = val;
1412 }
1413 else
1414 boot_device = args->set_system_boot_options_args.boot_device_arg;
1415
1416 if (args->set_system_boot_options_args.lock_keyboard)
1417 {
1418 if (FIID_OBJ_GET (get_boot_flags_rs, "lock_keyboard", &val) < 0)
1419 {
1420 pstdout_fprintf (state_data->pstate,
1421 stderr,
1422 "FIID_OBJ_GET: 'lock_keyboard': %s\n",
1423 fiid_obj_errormsg (obj_cmd_rs));
1424 goto cleanup;
1425 }
1426 lock_keyboard = val;
1427 }
1428 else
1429 lock_keyboard = args->set_system_boot_options_args.lock_keyboard_arg;
1430
1431 if (args->set_system_boot_options_args.cmos_clear)
1432 {
1433 if (FIID_OBJ_GET (get_boot_flags_rs, "cmos_clear", &val) < 0)
1434 {
1435 pstdout_fprintf (state_data->pstate,
1436 stderr,
1437 "FIID_OBJ_GET: 'cmos_clear': %s\n",
1438 fiid_obj_errormsg (obj_cmd_rs));
1439 goto cleanup;
1440 }
1441 cmos_clear = val;
1442 }
1443 else
1444 cmos_clear = args->set_system_boot_options_args.cmos_clear_arg;
1445
1446 if (args->set_system_boot_options_args.console_redirection)
1447 {
1448 if (FIID_OBJ_GET (get_boot_flags_rs, "console_redirection", &val) < 0)
1449 {
1450 pstdout_fprintf (state_data->pstate,
1451 stderr,
1452 "FIID_OBJ_GET: 'console_redirection': %s\n",
1453 fiid_obj_errormsg (obj_cmd_rs));
1454 goto cleanup;
1455 }
1456 console_redirection = val;
1457 }
1458 else
1459 console_redirection = args->set_system_boot_options_args.console_redirection_arg;
1460
1461 if (FIID_OBJ_GET (get_boot_flags_rs, "lock_out_sleep_button", &val) < 0)
1462 {
1463 pstdout_fprintf (state_data->pstate,
1464 stderr,
1465 "FIID_OBJ_GET: 'lock_out_sleep_button': %s\n",
1466 fiid_obj_errormsg (obj_cmd_rs));
1467 goto cleanup;
1468 }
1469 lock_out_sleep_button = val;
1470
1471 if (args->set_system_boot_options_args.user_password_bypass)
1472 {
1473 if (FIID_OBJ_GET (get_boot_flags_rs, "user_password_bypass", &val) < 0)
1474 {
1475 pstdout_fprintf (state_data->pstate,
1476 stderr,
1477 "FIID_OBJ_GET: 'user_password_bypass': %s\n",
1478 fiid_obj_errormsg (obj_cmd_rs));
1479 goto cleanup;
1480 }
1481 user_password_bypass = val;
1482 }
1483 else
1484 user_password_bypass = args->set_system_boot_options_args.user_password_bypass_arg;
1485
1486 if (args->set_system_boot_options_args.force_progress_event_traps)
1487 {
1488 if (FIID_OBJ_GET (get_boot_flags_rs, "force_progress_event_traps", &val) < 0)
1489 {
1490 pstdout_fprintf (state_data->pstate,
1491 stderr,
1492 "FIID_OBJ_GET: 'force_progress_event_traps': %s\n",
1493 fiid_obj_errormsg (obj_cmd_rs));
1494 goto cleanup;
1495 }
1496 force_progress_event_traps = val;
1497 }
1498 else
1499 force_progress_event_traps = args->set_system_boot_options_args.force_progress_event_traps_arg;
1500
1501 if (args->set_system_boot_options_args.firmware_bios_verbosity)
1502 {
1503 if (FIID_OBJ_GET (get_boot_flags_rs, "firmware_bios_verbosity", &val) < 0)
1504 {
1505 pstdout_fprintf (state_data->pstate,
1506 stderr,
1507 "FIID_OBJ_GET: 'firmware_bios_verbosity': %s\n",
1508 fiid_obj_errormsg (obj_cmd_rs));
1509 goto cleanup;
1510 }
1511 firmware_bios_verbosity = val;
1512 }
1513 else
1514 firmware_bios_verbosity = args->set_system_boot_options_args.firmware_bios_verbosity_arg;
1515
1516 if (FIID_OBJ_GET (get_boot_flags_rs, "lock_out_via_power_button", &val) < 0)
1517 {
1518 pstdout_fprintf (state_data->pstate,
1519 stderr,
1520 "FIID_OBJ_GET: 'lock_out_via_power_button': %s\n",
1521 fiid_obj_errormsg (obj_cmd_rs));
1522 goto cleanup;
1523 }
1524 lock_out_via_power_button = val;
1525
1526 if (FIID_OBJ_GET (get_boot_flags_rs, "bios_mux_control_override", &val) < 0)
1527 {
1528 pstdout_fprintf (state_data->pstate,
1529 stderr,
1530 "FIID_OBJ_GET: 'bios_mux_control_override': %s\n",
1531 fiid_obj_errormsg (obj_cmd_rs));
1532 goto cleanup;
1533 }
1534 bios_mux_control_override = val;
1535
1536 if (FIID_OBJ_GET (get_boot_flags_rs, "bios_shared_mode_override", &val) < 0)
1537 {
1538 pstdout_fprintf (state_data->pstate,
1539 stderr,
1540 "FIID_OBJ_GET: 'bios_shared_mode_override': %s\n",
1541 fiid_obj_errormsg (obj_cmd_rs));
1542 goto cleanup;
1543 }
1544 bios_shared_mode_override = val;
1545
1546 if (ipmi_cmd_set_system_boot_options_boot_flags (state_data->ipmi_ctx,
1547 IPMI_SYSTEM_BOOT_OPTIONS_PARAMETER_VALID_UNLOCKED,
1548 bios_boot_type,
1549 boot_flags_persistent,
1550 boot_flags_valid,
1551 lock_out_reset_button,
1552 screen_blank,
1553 boot_device,
1554 lock_keyboard,
1555 cmos_clear,
1556 console_redirection,
1557 lock_out_sleep_button,
1558 user_password_bypass,
1559 force_progress_event_traps,
1560 firmware_bios_verbosity,
1561 lock_out_via_power_button,
1562 bios_mux_control_override,
1563 bios_shared_mode_override,
1564 0, /* no device instance, legacy input */
1565 obj_cmd_rs) < 0)
1566 {
1567 pstdout_fprintf (state_data->pstate,
1568 stderr,
1569 "ipmi_cmd_set_sytem_boot_option_boot_flags failed: %s\n",
1570 ipmi_ctx_errormsg (state_data->ipmi_ctx));
1571 goto cleanup;
1572 }
1573
1574 if (ipmi_cmd_set_system_boot_options_boot_info_acknowledge (state_data->ipmi_ctx,
1575 IPMI_SYSTEM_BOOT_OPTIONS_PARAMETER_VALID_UNLOCKED,
1576 &boot_info_acknowledge,
1577 &boot_info_acknowledge,
1578 &boot_info_acknowledge,
1579 &boot_info_acknowledge,
1580 &boot_info_acknowledge,
1581 boot_info_ack_obj_cmd_rs) < 0)
1582 {
1583 pstdout_fprintf (state_data->pstate,
1584 stderr,
1585 "ipmi_cmd_set_system_boot_options_boot_info_acknowledge: %s\n",
1586 ipmi_ctx_errormsg (state_data->ipmi_ctx));
1587 goto cleanup;
1588 }
1589
1590 rv = 0;
1591 cleanup:
1592 fiid_obj_destroy (get_boot_flags_rs);
1593 fiid_obj_destroy (boot_info_ack_obj_cmd_rs);
1594 fiid_obj_destroy (obj_cmd_rs);
1595 return (rv);
1596 }
1597
1598 static int
run_cmd_args(ipmi_chassis_state_data_t * state_data)1599 run_cmd_args (ipmi_chassis_state_data_t *state_data)
1600 {
1601 struct ipmi_chassis_arguments *args;
1602 int rv = -1;
1603
1604 assert (state_data);
1605
1606 args = state_data->prog_data->args;
1607
1608 if (args->get_chassis_capabilities)
1609 return (get_chassis_capabilities (state_data));
1610
1611 if (args->get_chassis_status)
1612 return (get_chassis_status (state_data));
1613
1614 if (args->chassis_control)
1615 return (chassis_control (state_data));
1616
1617 if (args->chassis_identify)
1618 return (chassis_identify (state_data));
1619
1620 /* All chassis "set" operations are legacy, see ipmi-config for chassis configuration */
1621 if (args->set_power_restore_policy)
1622 return (set_power_restore_policy (state_data));
1623
1624 /* All chassis "set" operations are legacy, see ipmi-config for chassis configuration */
1625 if (args->set_power_cycle_interval)
1626 return (set_power_cycle_interval (state_data));
1627
1628 if (args->get_system_restart_cause)
1629 return (get_system_restart_cause (state_data));
1630
1631 /* All chassis "set" operations are legacy, see ipmi-config for chassis configuration */
1632 if (args->set_system_boot_options)
1633 return (set_boot_flags (state_data));
1634
1635 if (args->get_system_boot_options)
1636 return (get_boot_flags (state_data));
1637
1638 if (args->get_power_on_hours_counter)
1639 return (get_power_on_hours_counter (state_data));
1640
1641 rv = 0;
1642 return (rv);
1643 }
1644
1645 static int
_ipmi_chassis(pstdout_state_t pstate,const char * hostname,void * arg)1646 _ipmi_chassis (pstdout_state_t pstate,
1647 const char *hostname,
1648 void *arg)
1649 {
1650 ipmi_chassis_state_data_t state_data;
1651 ipmi_chassis_prog_data_t *prog_data;
1652 int exit_code = EXIT_FAILURE;
1653
1654 assert (pstate);
1655 assert (arg);
1656
1657 prog_data = (ipmi_chassis_prog_data_t *)arg;
1658 memset (&state_data, '\0', sizeof (ipmi_chassis_state_data_t));
1659
1660 state_data.prog_data = prog_data;
1661 state_data.pstate = pstate;
1662
1663 if (!(state_data.ipmi_ctx = ipmi_open (prog_data->progname,
1664 hostname,
1665 &(prog_data->args->common_args),
1666 state_data.pstate,
1667 0)))
1668 goto cleanup;
1669
1670 if (run_cmd_args (&state_data) < 0)
1671 goto cleanup;
1672
1673 exit_code = EXIT_SUCCESS;
1674 cleanup:
1675 ipmi_ctx_close (state_data.ipmi_ctx);
1676 ipmi_ctx_destroy (state_data.ipmi_ctx);
1677 return (exit_code);
1678 }
1679
1680 int
main(int argc,char ** argv)1681 main (int argc, char **argv)
1682 {
1683 ipmi_chassis_prog_data_t prog_data;
1684 struct ipmi_chassis_arguments cmd_args;
1685 int hosts_count;
1686 int rv;
1687
1688 ipmi_disable_coredump ();
1689
1690 prog_data.progname = argv[0];
1691 ipmi_chassis_argp_parse (argc, argv, &cmd_args);
1692 prog_data.args = &cmd_args;
1693
1694 if ((hosts_count = pstdout_setup (&(prog_data.args->common_args.hostname),
1695 &(prog_data.args->common_args))) < 0)
1696 return (EXIT_FAILURE);
1697
1698 if (!hosts_count)
1699 return (EXIT_SUCCESS);
1700
1701 if ((rv = pstdout_launch (prog_data.args->common_args.hostname,
1702 _ipmi_chassis,
1703 &prog_data)) < 0)
1704 {
1705 fprintf (stderr,
1706 "pstdout_launch: %s\n",
1707 pstdout_strerror (pstdout_errnum));
1708 return (EXIT_FAILURE);
1709 }
1710
1711 return (rv);
1712 }
1713