1 /*
2 * cmd_entity.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 <OpenIPMI/ipmiif.h>
39 #include <OpenIPMI/ipmi_cmdlang.h>
40 #include <OpenIPMI/ipmi_fru.h>
41 #include <OpenIPMI/ipmi_err.h>
42
43 /* Internal includes, do not use in your programs */
44 #include <OpenIPMI/internal/ipmi_malloc.h>
45
46 /* Don't pollute the namespace iwth ipmi_fru_t. */
47 void ipmi_cmdlang_dump_fru_info(ipmi_cmd_info_t *cmd_info, ipmi_fru_t *fru);
48
49 void ipmi_cmdlang_sensor_change(enum ipmi_update_e op,
50 ipmi_entity_t *entity,
51 ipmi_sensor_t *sensor,
52 void *cb_data);
53 void ipmi_cmdlang_control_change(enum ipmi_update_e op,
54 ipmi_entity_t *entity,
55 ipmi_control_t *control,
56 void *cb_data);
57
58 static void
entity_iterate_handler(ipmi_entity_t * entity,ipmi_entity_t * parent,void * cb_data)59 entity_iterate_handler(ipmi_entity_t *entity, ipmi_entity_t *parent,
60 void *cb_data)
61 {
62 ipmi_cmd_info_t *cmd_info = cb_data;
63 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
64 char entity_name[IPMI_ENTITY_NAME_LEN];
65
66 if (cmdlang->err)
67 return;
68
69 ipmi_entity_get_name(parent, entity_name, sizeof(entity_name));
70
71 ipmi_cmdlang_out(cmd_info, "Name", entity_name);
72 }
73
74 static void
entity_child_handler(ipmi_entity_t * parent,ipmi_entity_t * entity,void * cb_data)75 entity_child_handler(ipmi_entity_t *parent, ipmi_entity_t *entity,
76 void *cb_data)
77 {
78 ipmi_cmd_info_t *cmd_info = cb_data;
79 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
80 char entity_name[IPMI_ENTITY_NAME_LEN];
81
82 if (cmdlang->err)
83 return;
84
85 ipmi_entity_get_name(entity, entity_name, sizeof(entity_name));
86
87 ipmi_cmdlang_out(cmd_info, "Name", entity_name);
88 if (ipmi_entity_get_is_parent(entity)) {
89 ipmi_cmdlang_down(cmd_info);
90 ipmi_entity_iterate_children(entity, entity_child_handler, cmd_info);
91 ipmi_cmdlang_up(cmd_info);
92 }
93 }
94
95 static void
entity_tree_handler(ipmi_entity_t * entity,void * cb_data)96 entity_tree_handler(ipmi_entity_t *entity, void *cb_data)
97 {
98 ipmi_cmd_info_t *cmd_info = cb_data;
99 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
100 char entity_name[IPMI_ENTITY_NAME_LEN];
101
102 if (cmdlang->err)
103 return;
104
105 if (ipmi_entity_get_is_child(entity))
106 return;
107
108 ipmi_entity_get_name(entity, entity_name, sizeof(entity_name));
109
110 ipmi_cmdlang_out(cmd_info, "Name", entity_name);
111 if (ipmi_entity_get_is_parent(entity)) {
112 ipmi_cmdlang_down(cmd_info);
113 ipmi_entity_iterate_children(entity, entity_child_handler, cmd_info);
114 ipmi_cmdlang_up(cmd_info);
115 }
116 }
117
118 static void
entity_tree(ipmi_domain_t * domain,void * cb_data)119 entity_tree(ipmi_domain_t *domain, void *cb_data)
120 {
121 ipmi_cmd_info_t *cmd_info = cb_data;
122 char domain_name[IPMI_DOMAIN_NAME_LEN];
123
124 ipmi_domain_get_name(domain, domain_name, sizeof(domain_name));
125 ipmi_cmdlang_out(cmd_info, "Domain", NULL);
126 ipmi_cmdlang_down(cmd_info);
127 ipmi_cmdlang_out(cmd_info, "Name", domain_name);
128 ipmi_cmdlang_out(cmd_info, "Entities", NULL);
129 ipmi_cmdlang_down(cmd_info);
130 ipmi_domain_iterate_entities(domain, entity_tree_handler, cmd_info);
131 ipmi_cmdlang_up(cmd_info);
132 ipmi_cmdlang_up(cmd_info);
133 }
134
135 static void
entity_list_handler(ipmi_entity_t * entity,void * cb_data)136 entity_list_handler(ipmi_entity_t *entity, void *cb_data)
137 {
138 ipmi_cmd_info_t *cmd_info = cb_data;
139 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
140 char entity_name[IPMI_ENTITY_NAME_LEN];
141
142 if (cmdlang->err)
143 return;
144
145 ipmi_entity_get_name(entity, entity_name, sizeof(entity_name));
146
147 ipmi_cmdlang_out(cmd_info, "Name", entity_name);
148 }
149
150 static void
entity_list(ipmi_domain_t * domain,void * cb_data)151 entity_list(ipmi_domain_t *domain, void *cb_data)
152 {
153 ipmi_cmd_info_t *cmd_info = cb_data;
154 char domain_name[IPMI_DOMAIN_NAME_LEN];
155
156 ipmi_domain_get_name(domain, domain_name, sizeof(domain_name));
157 ipmi_cmdlang_out(cmd_info, "Domain", NULL);
158 ipmi_cmdlang_down(cmd_info);
159 ipmi_cmdlang_out(cmd_info, "Name", domain_name);
160 ipmi_cmdlang_out(cmd_info, "Entities", NULL);
161 ipmi_cmdlang_down(cmd_info);
162 ipmi_domain_iterate_entities(domain, entity_list_handler, cmd_info);
163 ipmi_cmdlang_up(cmd_info);
164 ipmi_cmdlang_up(cmd_info);
165 }
166
167 static void
entity_dump(ipmi_entity_t * entity,ipmi_cmd_info_t * cmd_info)168 entity_dump(ipmi_entity_t *entity, ipmi_cmd_info_t *cmd_info)
169 {
170 enum ipmi_dlr_type_e type;
171 static char *ent_types[] = { "unknown", "mc", "fru",
172 "generic", "invalid" };
173 int length;
174 unsigned int val;
175
176 type = ipmi_entity_get_type(entity);
177 if (type > IPMI_ENTITY_GENERIC)
178 type = IPMI_ENTITY_GENERIC + 1;
179 ipmi_cmdlang_out(cmd_info, "Type", ent_types[type]);
180
181 ipmi_cmdlang_out_bool(cmd_info, "Present", ipmi_entity_is_present(entity));
182 ipmi_cmdlang_out_bool(cmd_info, "Presence sensor always there",
183 ipmi_entity_get_presence_sensor_always_there(entity));
184 ipmi_cmdlang_out_bool(cmd_info, "Hot swappable",
185 ipmi_entity_hot_swappable(entity));
186 if (ipmi_entity_hot_swappable(entity)) {
187 ipmi_cmdlang_out_bool(cmd_info, "Supports managed hot swap",
188 ipmi_entity_supports_managed_hot_swap(entity));
189 }
190
191 if (ipmi_entity_get_is_child(entity)) {
192 ipmi_cmdlang_out(cmd_info, "Parents", NULL);
193 ipmi_cmdlang_down(cmd_info);
194 ipmi_entity_iterate_parents(entity, entity_iterate_handler, cmd_info);
195 ipmi_cmdlang_up(cmd_info);
196 }
197 if (ipmi_entity_get_is_parent(entity)) {
198 ipmi_cmdlang_out(cmd_info, "Children", NULL);
199 ipmi_cmdlang_down(cmd_info);
200 ipmi_entity_iterate_children(entity, entity_iterate_handler, cmd_info);
201 ipmi_cmdlang_up(cmd_info);
202 }
203
204 if (ipmi_entity_get_physical_slot_num(entity, &val) == 0)
205 ipmi_cmdlang_out_int(cmd_info, "Physical Slot", val);
206
207 length = ipmi_entity_get_id_length(entity);
208 if (length &&
209 (ipmi_entity_get_id_type(entity) == IPMI_ASCII_STR && length > 1))
210 {
211 char *str = ipmi_mem_alloc(length);
212
213 if (str) {
214 length = ipmi_entity_get_id(entity, str, length);
215 ipmi_cmdlang_out_type(cmd_info, "Id",
216 ipmi_entity_get_id_type(entity),
217 str, length);
218 ipmi_mem_free(str);
219 }
220 }
221 ipmi_cmdlang_out(cmd_info, "Entity ID String",
222 ipmi_entity_get_entity_id_string(entity));
223
224 switch (type) {
225 case IPMI_ENTITY_MC:
226 ipmi_cmdlang_out_int(cmd_info, "Channel",
227 ipmi_entity_get_channel(entity));
228 ipmi_cmdlang_out_int(cmd_info, "LUN", ipmi_entity_get_lun(entity));
229 ipmi_cmdlang_out_hex(cmd_info, "OEM", ipmi_entity_get_oem(entity));
230 ipmi_cmdlang_out_hex(cmd_info, "Slave Address",
231 ipmi_entity_get_slave_address(entity));
232 ipmi_cmdlang_out_bool(cmd_info, "ACPI_system_power_notify_required",
233 ipmi_entity_get_ACPI_system_power_notify_required(entity));
234 ipmi_cmdlang_out_bool(cmd_info, "ACPI_device_power_notify_required",
235 ipmi_entity_get_ACPI_device_power_notify_required(entity));
236 ipmi_cmdlang_out_bool(cmd_info, "controller_logs_init_agent_errors",
237 ipmi_entity_get_controller_logs_init_agent_errors(entity));
238 ipmi_cmdlang_out_bool(cmd_info, "log_init_agent_errors_accessing",
239 ipmi_entity_get_log_init_agent_errors_accessing(entity));
240 ipmi_cmdlang_out_bool(cmd_info, "global_init",
241 ipmi_entity_get_global_init(entity));
242 ipmi_cmdlang_out_bool(cmd_info, "chassis_device",
243 ipmi_entity_get_chassis_device(entity));
244 ipmi_cmdlang_out_bool(cmd_info, "bridge",
245 ipmi_entity_get_bridge(entity));
246 ipmi_cmdlang_out_bool(cmd_info, "IPMB_event_generator",
247 ipmi_entity_get_IPMB_event_generator(entity));
248 ipmi_cmdlang_out_bool(cmd_info, "IPMB_event_receiver",
249 ipmi_entity_get_IPMB_event_receiver(entity));
250 ipmi_cmdlang_out_bool(cmd_info, "FRU_inventory_device",
251 ipmi_entity_get_FRU_inventory_device(entity));
252 ipmi_cmdlang_out_bool(cmd_info, "SEL_device",
253 ipmi_entity_get_SEL_device(entity));
254 ipmi_cmdlang_out_bool(cmd_info, "SDR_repository_device",
255 ipmi_entity_get_SDR_repository_device(entity));
256 ipmi_cmdlang_out_bool(cmd_info, "sensor_device",
257 ipmi_entity_get_sensor_device(entity));
258 break;
259
260 case IPMI_ENTITY_FRU:
261 ipmi_cmdlang_out_int(cmd_info, "Channel",
262 ipmi_entity_get_channel(entity));
263 ipmi_cmdlang_out_int(cmd_info, "LUN", ipmi_entity_get_lun(entity));
264 ipmi_cmdlang_out_hex(cmd_info, "OEM", ipmi_entity_get_oem(entity));
265 ipmi_cmdlang_out_hex(cmd_info, "access_address",
266 ipmi_entity_get_access_address(entity));
267 ipmi_cmdlang_out_hex(cmd_info, "private_bus_id",
268 ipmi_entity_get_private_bus_id(entity));
269 ipmi_cmdlang_out_int(cmd_info, "device_type",
270 ipmi_entity_get_device_type(entity));
271 ipmi_cmdlang_out_int(cmd_info, "device_modifier",
272 ipmi_entity_get_device_modifier(entity));
273 ipmi_cmdlang_out_bool(cmd_info, "is_logical_fru",
274 ipmi_entity_get_is_logical_fru(entity));
275 ipmi_cmdlang_out_hex(cmd_info, "fru_device_id",
276 ipmi_entity_get_fru_device_id(entity));
277 break;
278
279 case IPMI_ENTITY_GENERIC:
280 ipmi_cmdlang_out_int(cmd_info, "Channel",
281 ipmi_entity_get_channel(entity));
282 ipmi_cmdlang_out_int(cmd_info, "LUN", ipmi_entity_get_lun(entity));
283 ipmi_cmdlang_out_hex(cmd_info, "OEM", ipmi_entity_get_oem(entity));
284 ipmi_cmdlang_out_hex(cmd_info, "access_address",
285 ipmi_entity_get_access_address(entity));
286 ipmi_cmdlang_out_hex(cmd_info, "private_bus_id",
287 ipmi_entity_get_private_bus_id(entity));
288 ipmi_cmdlang_out_int(cmd_info, "device_type",
289 ipmi_entity_get_device_type(entity));
290 ipmi_cmdlang_out_int(cmd_info, "device_modifier",
291 ipmi_entity_get_device_modifier(entity));
292 ipmi_cmdlang_out_hex(cmd_info, "slave_address",
293 ipmi_entity_get_slave_address(entity));
294 ipmi_cmdlang_out_int(cmd_info, "address_span",
295 ipmi_entity_get_address_span(entity));
296 break;
297
298 default:
299 break;
300 }
301 }
302
303 static void
entity_info(ipmi_entity_t * entity,void * cb_data)304 entity_info(ipmi_entity_t *entity, void *cb_data)
305 {
306 ipmi_cmd_info_t *cmd_info = cb_data;
307 char entity_name[IPMI_ENTITY_NAME_LEN];
308
309 ipmi_entity_get_name(entity, entity_name, sizeof(entity_name));
310
311 ipmi_cmdlang_out(cmd_info, "Entity", NULL);
312 ipmi_cmdlang_down(cmd_info);
313 ipmi_cmdlang_out(cmd_info, "Name", entity_name);
314 entity_dump(entity, cmd_info);
315 ipmi_cmdlang_up(cmd_info);
316 }
317
318 static void
fru_info(ipmi_entity_t * entity,void * cb_data)319 fru_info(ipmi_entity_t *entity, void *cb_data)
320 {
321 ipmi_cmd_info_t *cmd_info = cb_data;
322 ipmi_fru_t *fru;
323 char entity_name[IPMI_ENTITY_NAME_LEN];
324
325 ipmi_entity_get_name(entity, entity_name, sizeof(entity_name));
326
327 ipmi_cmdlang_out(cmd_info, "Entity", NULL);
328 ipmi_cmdlang_down(cmd_info);
329 ipmi_cmdlang_out(cmd_info, "Name", entity_name);
330
331 /* We cheat here and don't call the entity functions, but that
332 allows us to reuse the FRU output functions. If you are
333 looking at this for an example DON'T DO THIS IN YOUR CODE. */
334 fru = ipmi_entity_get_fru(entity);
335 if (fru)
336 ipmi_cmdlang_dump_fru_info(cmd_info, fru);
337 ipmi_cmdlang_up(cmd_info);
338 }
339
340 static void
entity_hs_get_act_time_done(ipmi_entity_t * entity,int err,ipmi_timeout_t val,void * cb_data)341 entity_hs_get_act_time_done(ipmi_entity_t *entity,
342 int err,
343 ipmi_timeout_t val,
344 void *cb_data)
345 {
346 ipmi_cmd_info_t *cmd_info = cb_data;
347 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
348 char entity_name[IPMI_ENTITY_NAME_LEN];
349
350 ipmi_cmdlang_lock(cmd_info);
351 if (err) {
352 cmdlang->errstr = "Error reading entity hot-swap activate time";
353 cmdlang->err = err;
354 ipmi_entity_get_name(entity, cmdlang->objstr,
355 cmdlang->objstr_len);
356 cmdlang->location = "cmd_sensor.c(entity_hs_get_act_time_done)";
357 goto out;
358 }
359
360 ipmi_entity_get_name(entity, entity_name, sizeof(entity_name));
361 ipmi_cmdlang_out(cmd_info, "Entity", NULL);
362 ipmi_cmdlang_down(cmd_info);
363 ipmi_cmdlang_out(cmd_info, "Name", entity_name);
364 ipmi_cmdlang_out_timeout(cmd_info, "Auto-Activation Time", val);
365
366 out:
367 ipmi_cmdlang_unlock(cmd_info);
368 ipmi_cmdlang_cmd_info_put(cmd_info);
369 }
370
371 static void
entity_hs_get_act_time(ipmi_entity_t * entity,void * cb_data)372 entity_hs_get_act_time(ipmi_entity_t *entity, void *cb_data)
373 {
374 ipmi_cmd_info_t *cmd_info = cb_data;
375 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
376 int rv;
377
378 ipmi_cmdlang_cmd_info_get(cmd_info);
379 rv = ipmi_entity_get_auto_activate_time(entity,
380 entity_hs_get_act_time_done,
381 cmd_info);
382 if (rv) {
383 ipmi_cmdlang_cmd_info_put(cmd_info);
384 cmdlang->err = rv;
385 cmdlang->errstr = "Error getting auto activate time";
386 ipmi_entity_get_name(entity, cmdlang->objstr,
387 cmdlang->objstr_len);
388 cmdlang->location = "cmd_entity.c(entity_hs_get_act_time)";
389 }
390 }
391
392 static void
entity_hs_set_act_time_done(ipmi_entity_t * entity,int err,void * cb_data)393 entity_hs_set_act_time_done(ipmi_entity_t *entity,
394 int err,
395 void *cb_data)
396 {
397 ipmi_cmd_info_t *cmd_info = cb_data;
398 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
399 char entity_name[IPMI_ENTITY_NAME_LEN];
400
401 ipmi_cmdlang_lock(cmd_info);
402 if (err) {
403 cmdlang->errstr = "Error setting entity hot-swap activate time";
404 cmdlang->err = err;
405 ipmi_entity_get_name(entity, cmdlang->objstr,
406 cmdlang->objstr_len);
407 cmdlang->location = "cmd_sensor.c(entity_hs_set_act_time_done)";
408 goto out;
409 }
410
411 ipmi_entity_get_name(entity, entity_name, sizeof(entity_name));
412 ipmi_cmdlang_out(cmd_info, "Set act time", entity_name);
413
414 out:
415 ipmi_cmdlang_unlock(cmd_info);
416 ipmi_cmdlang_cmd_info_put(cmd_info);
417 }
418
419 static void
entity_hs_set_act_time(ipmi_entity_t * entity,void * cb_data)420 entity_hs_set_act_time(ipmi_entity_t *entity, void *cb_data)
421 {
422 ipmi_cmd_info_t *cmd_info = cb_data;
423 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
424 int rv;
425 ipmi_timeout_t val;
426 int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
427 int argc = ipmi_cmdlang_get_argc(cmd_info);
428 char **argv = ipmi_cmdlang_get_argv(cmd_info);
429
430 if ((argc - curr_arg) < 1) {
431 cmdlang->errstr = "Not enough parameters";
432 cmdlang->err = EINVAL;
433 goto out_err;
434 }
435
436 ipmi_cmdlang_get_timeout(argv[curr_arg], &val, cmd_info);
437 if (cmdlang->err) {
438 cmdlang->errstr = "time invalid";
439 goto out_err;
440 }
441 curr_arg++;
442
443 ipmi_cmdlang_cmd_info_get(cmd_info);
444 rv = ipmi_entity_set_auto_activate_time(entity,
445 val,
446 entity_hs_set_act_time_done,
447 cmd_info);
448 if (rv) {
449 ipmi_cmdlang_cmd_info_put(cmd_info);
450 cmdlang->err = rv;
451 cmdlang->errstr = "Error setting auto activate time";
452 goto out_err;
453 }
454 return;
455
456 out_err:
457 ipmi_entity_get_name(entity, cmdlang->objstr,
458 cmdlang->objstr_len);
459 cmdlang->location = "cmd_entity.c(entity_hs_set_act_time)";
460 }
461
462 static void
entity_hs_get_deact_time_done(ipmi_entity_t * entity,int err,ipmi_timeout_t val,void * cb_data)463 entity_hs_get_deact_time_done(ipmi_entity_t *entity,
464 int err,
465 ipmi_timeout_t val,
466 void *cb_data)
467 {
468 ipmi_cmd_info_t *cmd_info = cb_data;
469 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
470 char entity_name[IPMI_ENTITY_NAME_LEN];
471
472 ipmi_cmdlang_lock(cmd_info);
473 if (err) {
474 cmdlang->errstr = "Error reading entity hot-swap deactivate time";
475 cmdlang->err = err;
476 ipmi_entity_get_name(entity, cmdlang->objstr,
477 cmdlang->objstr_len);
478 cmdlang->location = "cmd_sensor.c(entity_hs_get_deact_time_done)";
479 goto out;
480 }
481
482 ipmi_entity_get_name(entity, entity_name, sizeof(entity_name));
483 ipmi_cmdlang_out(cmd_info, "Entity", NULL);
484 ipmi_cmdlang_down(cmd_info);
485 ipmi_cmdlang_out(cmd_info, "Name", entity_name);
486 ipmi_cmdlang_out_timeout(cmd_info, "Auto-Deactivation Time", val);
487
488 out:
489 ipmi_cmdlang_unlock(cmd_info);
490 ipmi_cmdlang_cmd_info_put(cmd_info);
491 }
492
493 static void
entity_hs_get_deact_time(ipmi_entity_t * entity,void * cb_data)494 entity_hs_get_deact_time(ipmi_entity_t *entity, void *cb_data)
495 {
496 ipmi_cmd_info_t *cmd_info = cb_data;
497 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
498 int rv;
499
500 ipmi_cmdlang_cmd_info_get(cmd_info);
501 rv = ipmi_entity_get_auto_deactivate_time(entity,
502 entity_hs_get_deact_time_done,
503 cmd_info);
504 if (rv) {
505 ipmi_cmdlang_cmd_info_put(cmd_info);
506 cmdlang->err = rv;
507 cmdlang->errstr = "Error getting auto deactivate time";
508 ipmi_entity_get_name(entity, cmdlang->objstr,
509 cmdlang->objstr_len);
510 cmdlang->location = "cmd_entity.c(entity_hs_get_deact_time)";
511 }
512 }
513
514 static void
entity_hs_set_deact_time_done(ipmi_entity_t * entity,int err,void * cb_data)515 entity_hs_set_deact_time_done(ipmi_entity_t *entity,
516 int err,
517 void *cb_data)
518 {
519 ipmi_cmd_info_t *cmd_info = cb_data;
520 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
521 char entity_name[IPMI_ENTITY_NAME_LEN];
522
523 ipmi_cmdlang_lock(cmd_info);
524 if (err) {
525 cmdlang->errstr = "Error setting entity hot-swap deactivate time";
526 cmdlang->err = err;
527 ipmi_entity_get_name(entity, cmdlang->objstr,
528 cmdlang->objstr_len);
529 cmdlang->location = "cmd_sensor.c(entity_hs_set_deact_time_done)";
530 goto out;
531 }
532
533 ipmi_entity_get_name(entity, entity_name, sizeof(entity_name));
534 ipmi_cmdlang_out(cmd_info, "Set deact time", entity_name);
535
536 out:
537 ipmi_cmdlang_unlock(cmd_info);
538 ipmi_cmdlang_cmd_info_put(cmd_info);
539 }
540
541 static void
entity_hs_set_deact_time(ipmi_entity_t * entity,void * cb_data)542 entity_hs_set_deact_time(ipmi_entity_t *entity, void *cb_data)
543 {
544 ipmi_cmd_info_t *cmd_info = cb_data;
545 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
546 int rv;
547 ipmi_timeout_t val;
548 int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
549 int argc = ipmi_cmdlang_get_argc(cmd_info);
550 char **argv = ipmi_cmdlang_get_argv(cmd_info);
551
552 if ((argc - curr_arg) < 1) {
553 cmdlang->errstr = "Not enough parameters";
554 cmdlang->err = EINVAL;
555 goto out_err;
556 }
557
558 ipmi_cmdlang_get_timeout(argv[curr_arg], &val, cmd_info);
559 if (cmdlang->err) {
560 cmdlang->errstr = "time invalid";
561 goto out_err;
562 }
563 curr_arg++;
564
565 ipmi_cmdlang_cmd_info_get(cmd_info);
566 rv = ipmi_entity_set_auto_deactivate_time(entity,
567 val,
568 entity_hs_set_deact_time_done,
569 cmd_info);
570 if (rv) {
571 ipmi_cmdlang_cmd_info_put(cmd_info);
572 cmdlang->err = rv;
573 cmdlang->errstr = "Error setting auto deactivate time";
574 goto out_err;
575 }
576 return;
577
578 out_err:
579 ipmi_entity_get_name(entity, cmdlang->objstr,
580 cmdlang->objstr_len);
581 cmdlang->location = "cmd_entity.c(entity_hs_set_deact_time)";
582 }
583
584 static void
entity_hs_activation_request_done(ipmi_entity_t * entity,int err,void * cb_data)585 entity_hs_activation_request_done(ipmi_entity_t *entity,
586 int err,
587 void *cb_data)
588 {
589 ipmi_cmd_info_t *cmd_info = cb_data;
590 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
591 char entity_name[IPMI_ENTITY_NAME_LEN];
592
593 ipmi_cmdlang_lock(cmd_info);
594 if (err) {
595 cmdlang->errstr = "Error from entity hot-swap activation request";
596 cmdlang->err = err;
597 ipmi_entity_get_name(entity, cmdlang->objstr,
598 cmdlang->objstr_len);
599 cmdlang->location = "cmd_sensor.c(entity_hs_activation_request_done)";
600 goto out;
601 }
602
603 ipmi_entity_get_name(entity, entity_name, sizeof(entity_name));
604 ipmi_cmdlang_out(cmd_info, "Activation requested", entity_name);
605
606 out:
607 ipmi_cmdlang_unlock(cmd_info);
608 ipmi_cmdlang_cmd_info_put(cmd_info);
609 }
610
611 static void
entity_hs_activation_request(ipmi_entity_t * entity,void * cb_data)612 entity_hs_activation_request(ipmi_entity_t *entity, void *cb_data)
613 {
614 ipmi_cmd_info_t *cmd_info = cb_data;
615 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
616 int rv;
617
618 ipmi_cmdlang_cmd_info_get(cmd_info);
619 rv = ipmi_entity_set_activation_requested
620 (entity,
621 entity_hs_activation_request_done,
622 cmd_info);
623 if (rv) {
624 ipmi_cmdlang_cmd_info_put(cmd_info);
625 cmdlang->err = rv;
626 cmdlang->errstr = "Error sending activation request";
627 ipmi_entity_get_name(entity, cmdlang->objstr,
628 cmdlang->objstr_len);
629 cmdlang->location = "cmd_entity.c(entity_hs_activation_request)";
630 }
631 }
632
633 static void
entity_hs_activate_done(ipmi_entity_t * entity,int err,void * cb_data)634 entity_hs_activate_done(ipmi_entity_t *entity,
635 int err,
636 void *cb_data)
637 {
638 ipmi_cmd_info_t *cmd_info = cb_data;
639 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
640 char entity_name[IPMI_ENTITY_NAME_LEN];
641
642 ipmi_cmdlang_lock(cmd_info);
643 if (err) {
644 cmdlang->errstr = "Error from entity hot-swap activate";
645 cmdlang->err = err;
646 ipmi_entity_get_name(entity, cmdlang->objstr,
647 cmdlang->objstr_len);
648 cmdlang->location = "cmd_sensor.c(entity_hs_activate_done)";
649 goto out;
650 }
651
652 ipmi_entity_get_name(entity, entity_name, sizeof(entity_name));
653 ipmi_cmdlang_out(cmd_info, "Activated", entity_name);
654
655 out:
656 ipmi_cmdlang_unlock(cmd_info);
657 ipmi_cmdlang_cmd_info_put(cmd_info);
658 }
659
660 static void
entity_hs_activate(ipmi_entity_t * entity,void * cb_data)661 entity_hs_activate(ipmi_entity_t *entity, void *cb_data)
662 {
663 ipmi_cmd_info_t *cmd_info = cb_data;
664 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
665 int rv;
666
667 ipmi_cmdlang_cmd_info_get(cmd_info);
668 rv = ipmi_entity_activate(entity,
669 entity_hs_activate_done,
670 cmd_info);
671 if (rv) {
672 ipmi_cmdlang_cmd_info_put(cmd_info);
673 cmdlang->err = rv;
674 cmdlang->errstr = "Error sending activate";
675 ipmi_entity_get_name(entity, cmdlang->objstr,
676 cmdlang->objstr_len);
677 cmdlang->location = "cmd_entity.c(entity_hs_activate)";
678 }
679 }
680
681 static void
entity_hs_deactivate_done(ipmi_entity_t * entity,int err,void * cb_data)682 entity_hs_deactivate_done(ipmi_entity_t *entity,
683 int err,
684 void *cb_data)
685 {
686 ipmi_cmd_info_t *cmd_info = cb_data;
687 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
688 char entity_name[IPMI_ENTITY_NAME_LEN];
689
690 ipmi_cmdlang_lock(cmd_info);
691 if (err) {
692 cmdlang->errstr = "Error from entity hot-swap deactivate";
693 cmdlang->err = err;
694 ipmi_entity_get_name(entity, cmdlang->objstr,
695 cmdlang->objstr_len);
696 cmdlang->location = "cmd_sensor.c(entity_hs_deactivate_done)";
697 goto out;
698 }
699
700 ipmi_entity_get_name(entity, entity_name, sizeof(entity_name));
701 ipmi_cmdlang_out(cmd_info, "Deactivated", entity_name);
702
703 out:
704 ipmi_cmdlang_unlock(cmd_info);
705 ipmi_cmdlang_cmd_info_put(cmd_info);
706 }
707
708 static void
entity_hs_deactivate(ipmi_entity_t * entity,void * cb_data)709 entity_hs_deactivate(ipmi_entity_t *entity, void *cb_data)
710 {
711 ipmi_cmd_info_t *cmd_info = cb_data;
712 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
713 int rv;
714
715 ipmi_cmdlang_cmd_info_get(cmd_info);
716 rv = ipmi_entity_deactivate(entity,
717 entity_hs_deactivate_done,
718 cmd_info);
719 if (rv) {
720 ipmi_cmdlang_cmd_info_put(cmd_info);
721 cmdlang->err = rv;
722 cmdlang->errstr = "Error sending deactivate";
723 ipmi_entity_get_name(entity, cmdlang->objstr,
724 cmdlang->objstr_len);
725 cmdlang->location = "cmd_entity.c(entity_hs_deactivate)";
726 }
727 }
728
729 static void
entity_hs_state_done(ipmi_entity_t * entity,int err,enum ipmi_hot_swap_states state,void * cb_data)730 entity_hs_state_done(ipmi_entity_t *entity,
731 int err,
732 enum ipmi_hot_swap_states state,
733 void *cb_data)
734 {
735 ipmi_cmd_info_t *cmd_info = cb_data;
736 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
737 char entity_name[IPMI_ENTITY_NAME_LEN];
738
739 ipmi_cmdlang_lock(cmd_info);
740 if (err) {
741 cmdlang->errstr = "Error reading hot-swap state";
742 cmdlang->err = err;
743 ipmi_entity_get_name(entity, cmdlang->objstr,
744 cmdlang->objstr_len);
745 cmdlang->location = "cmd_sensor.c(entity_hs_state_done)";
746 goto out;
747 }
748
749 ipmi_entity_get_name(entity, entity_name, sizeof(entity_name));
750 ipmi_cmdlang_out(cmd_info, "Entity", NULL);
751 ipmi_cmdlang_down(cmd_info);
752 ipmi_cmdlang_out(cmd_info, "Name", entity_name);
753 ipmi_cmdlang_out(cmd_info, "State", ipmi_hot_swap_state_name(state));
754
755 out:
756 ipmi_cmdlang_unlock(cmd_info);
757 ipmi_cmdlang_cmd_info_put(cmd_info);
758 }
759
760 static void
entity_hs_state(ipmi_entity_t * entity,void * cb_data)761 entity_hs_state(ipmi_entity_t *entity, void *cb_data)
762 {
763 ipmi_cmd_info_t *cmd_info = cb_data;
764 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
765 int rv;
766
767 ipmi_cmdlang_cmd_info_get(cmd_info);
768 rv = ipmi_entity_get_hot_swap_state(entity,
769 entity_hs_state_done,
770 cmd_info);
771 if (rv) {
772 ipmi_cmdlang_cmd_info_put(cmd_info);
773 cmdlang->err = rv;
774 cmdlang->errstr = "Error getting hot-swap state";
775 ipmi_entity_get_name(entity, cmdlang->objstr,
776 cmdlang->objstr_len);
777 cmdlang->location = "cmd_entity.c(entity_hs_get_state)";
778 }
779 }
780
781 static void
entity_hs_check(ipmi_entity_t * entity,void * cb_data)782 entity_hs_check(ipmi_entity_t *entity, void *cb_data)
783 {
784 ipmi_cmd_info_t *cmd_info = cb_data;
785 ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
786 int rv;
787 char entity_name[IPMI_ENTITY_NAME_LEN];
788
789 rv = ipmi_entity_check_hot_swap_state(entity);
790 if (rv) {
791 cmdlang->err = rv;
792 cmdlang->errstr = "Error checking hot-swap state";
793 ipmi_entity_get_name(entity, cmdlang->objstr,
794 cmdlang->objstr_len);
795 cmdlang->location = "cmd_entity.c(entity_hs_check)";
796 } else {
797 ipmi_entity_get_name(entity, entity_name, sizeof(entity_name));
798 ipmi_cmdlang_out(cmd_info, "Check started", entity_name);
799 }
800 }
801
802
fru_change(enum ipmi_update_werr_e op,int err,ipmi_entity_t * entity,void * cb_data)803 static void fru_change(enum ipmi_update_werr_e op,
804 int err,
805 ipmi_entity_t *entity,
806 void *cb_data)
807 {
808 char *errstr;
809 int rv;
810 ipmi_cmd_info_t *evi;
811 ipmi_fru_t *fru;
812 char entity_name[IPMI_ENTITY_NAME_LEN];
813 char errbuf[32];
814
815 ipmi_entity_get_name(entity, entity_name, sizeof(entity_name));
816
817 evi = ipmi_cmdlang_alloc_event_info();
818 if (!evi) {
819 rv = ENOMEM;
820 errstr = "Out of memory";
821 goto out_err;
822 }
823
824 ipmi_cmdlang_out(evi, "Object Type", "Entity FRU");
825 ipmi_cmdlang_out(evi, "Name", entity_name);
826
827 switch (op) {
828 case IPMIE_ADDED:
829 ipmi_cmdlang_out(evi, "Operation", "Add");
830 if (ipmi_cmdlang_get_evinfo()) {
831 ipmi_cmdlang_down(evi);
832 fru = ipmi_entity_get_fru(entity);
833 if (fru)
834 ipmi_cmdlang_dump_fru_info(evi, fru);
835 ipmi_cmdlang_up(evi);
836 }
837 break;
838
839 case IPMIE_DELETED:
840 ipmi_cmdlang_out(evi, "Operation", "Delete");
841 break;
842
843 case IPMIE_CHANGED:
844 ipmi_cmdlang_out(evi, "Operation", "Change");
845 if (ipmi_cmdlang_get_evinfo()) {
846 ipmi_cmdlang_down(evi);
847 fru = ipmi_entity_get_fru(entity);
848 if (fru)
849 ipmi_cmdlang_dump_fru_info(evi, fru);
850 ipmi_cmdlang_up(evi);
851 }
852 break;
853
854 case IPMIE_ERROR:
855 ipmi_cmdlang_out(evi, "Operation", "Error");
856 ipmi_cmdlang_global_err(entity_name,
857 "Error fetching FRU data",
858 ipmi_get_error_string(err, errbuf,
859 sizeof(errbuf)),
860 err);
861 break;
862 }
863
864 ipmi_cmdlang_cmd_info_put(evi);
865 return;
866
867 out_err:
868 ipmi_cmdlang_global_err(entity_name,
869 "cmd_entity.c(fru_change)",
870 errstr, rv);
871 if (evi)
872 ipmi_cmdlang_cmd_info_put(evi);
873 }
874
875 static int
presence_change(ipmi_entity_t * entity,int present,void * cb_data,ipmi_event_t * event)876 presence_change(ipmi_entity_t *entity,
877 int present,
878 void *cb_data,
879 ipmi_event_t *event)
880 {
881 char *errstr;
882 int rv;
883 ipmi_cmd_info_t *evi;
884 char entity_name[IPMI_ENTITY_NAME_LEN];
885
886 ipmi_entity_get_name(entity, entity_name, sizeof(entity_name));
887
888 evi = ipmi_cmdlang_alloc_event_info();
889 if (!evi) {
890 rv = ENOMEM;
891 errstr = "Out of memory";
892 goto out_err;
893 }
894
895 ipmi_cmdlang_out(evi, "Object Type", "Entity");
896 ipmi_cmdlang_out(evi, "Name", entity_name);
897 ipmi_cmdlang_out(evi, "Operation", "Presence Change");
898 ipmi_cmdlang_out_bool(evi, "Present", present);
899
900 if (event) {
901 ipmi_cmdlang_out(evi, "Event", NULL);
902 ipmi_cmdlang_down(evi);
903 ipmi_cmdlang_event_out(event, evi);
904 ipmi_cmdlang_up(evi);
905 }
906
907 ipmi_cmdlang_cmd_info_put(evi);
908 return IPMI_EVENT_NOT_HANDLED;
909
910 out_err:
911 ipmi_cmdlang_global_err(entity_name,
912 "cmd_entity.c(presence_change)",
913 errstr, rv);
914 if (evi)
915 ipmi_cmdlang_cmd_info_put(evi);
916
917 return IPMI_EVENT_NOT_HANDLED;
918 }
919
fully_up(ipmi_entity_t * entity,void * cb_data)920 static void fully_up(ipmi_entity_t *entity,
921 void *cb_data)
922 {
923 char *errstr;
924 int rv;
925 ipmi_cmd_info_t *evi;
926 char entity_name[IPMI_ENTITY_NAME_LEN];
927
928 ipmi_entity_get_name(entity, entity_name, sizeof(entity_name));
929
930 evi = ipmi_cmdlang_alloc_event_info();
931 if (!evi) {
932 rv = ENOMEM;
933 errstr = "Out of memory";
934 goto out_err;
935 }
936
937 ipmi_cmdlang_out(evi, "Object Type", "Entity");
938 ipmi_cmdlang_out(evi, "Name", entity_name);
939 ipmi_cmdlang_out(evi, "Operation", "Fully Up");
940 ipmi_cmdlang_cmd_info_put(evi);
941 return;
942
943 out_err:
944 ipmi_cmdlang_global_err(entity_name,
945 "cmd_entity.c(fully_up)",
946 errstr, rv);
947 if (evi)
948 ipmi_cmdlang_cmd_info_put(evi);
949 }
950
951 static int
entity_hot_swap(ipmi_entity_t * entity,enum ipmi_hot_swap_states last_state,enum ipmi_hot_swap_states curr_state,void * cb_data,ipmi_event_t * event)952 entity_hot_swap(ipmi_entity_t *entity,
953 enum ipmi_hot_swap_states last_state,
954 enum ipmi_hot_swap_states curr_state,
955 void *cb_data,
956 ipmi_event_t *event)
957 {
958 char *errstr;
959 int rv;
960 ipmi_cmd_info_t *evi;
961 char entity_name[IPMI_ENTITY_NAME_LEN];
962
963 ipmi_entity_get_name(entity, entity_name, sizeof(entity_name));
964
965 evi = ipmi_cmdlang_alloc_event_info();
966 if (!evi) {
967 rv = ENOMEM;
968 errstr = "Out of memory";
969 goto out_err;
970 }
971
972 ipmi_cmdlang_out(evi, "Object Type", "Entity");
973 ipmi_cmdlang_out(evi, "Name", entity_name);
974 ipmi_cmdlang_out(evi, "Operation", "Hot-Swap Change");
975 ipmi_cmdlang_out(evi, "Last State",
976 ipmi_hot_swap_state_name(last_state));
977 ipmi_cmdlang_out(evi, "State", ipmi_hot_swap_state_name(curr_state));
978
979 if (event) {
980 ipmi_cmdlang_out(evi, "Event", NULL);
981 ipmi_cmdlang_down(evi);
982 ipmi_cmdlang_event_out(event, evi);
983 ipmi_cmdlang_up(evi);
984 }
985
986 ipmi_cmdlang_cmd_info_put(evi);
987 return IPMI_EVENT_NOT_HANDLED;
988
989 out_err:
990 ipmi_cmdlang_global_err(entity_name,
991 "cmd_entity.c(entity_hot_swap)",
992 errstr, rv);
993 if (evi)
994 ipmi_cmdlang_cmd_info_put(evi);
995
996 return IPMI_EVENT_NOT_HANDLED;
997 }
998
999 void
ipmi_cmdlang_entity_change(enum ipmi_update_e op,ipmi_domain_t * domain,ipmi_entity_t * entity,void * cb_data)1000 ipmi_cmdlang_entity_change(enum ipmi_update_e op,
1001 ipmi_domain_t *domain,
1002 ipmi_entity_t *entity,
1003 void *cb_data)
1004 {
1005 char *errstr;
1006 int rv;
1007 ipmi_cmd_info_t *evi;
1008 char entity_name[IPMI_ENTITY_NAME_LEN];
1009
1010 ipmi_entity_get_name(entity, entity_name, sizeof(entity_name));
1011
1012 evi = ipmi_cmdlang_alloc_event_info();
1013 if (!evi) {
1014 rv = ENOMEM;
1015 errstr = "Out of memory";
1016 goto out_err;
1017 }
1018
1019 ipmi_cmdlang_out(evi, "Object Type", "Entity");
1020 ipmi_cmdlang_out(evi, "Name", entity_name);
1021
1022 switch (op) {
1023 case IPMI_ADDED:
1024 ipmi_cmdlang_out(evi, "Operation", "Add");
1025 if (ipmi_cmdlang_get_evinfo())
1026 entity_dump(entity, evi);
1027
1028 rv = ipmi_entity_add_sensor_update_handler(entity,
1029 ipmi_cmdlang_sensor_change,
1030 entity);
1031 if (rv) {
1032 errstr = "ipmi_entity_add_sensor_update_handler";
1033 goto out_err;
1034 }
1035 rv = ipmi_entity_add_fru_update_werr_handler(entity,
1036 fru_change,
1037 entity);
1038 if (rv) {
1039 errstr = "ipmi_entity_add_control_fru_handler";
1040 goto out_err;
1041 }
1042 rv = ipmi_entity_add_presence_handler(entity,
1043 presence_change,
1044 NULL);
1045 if (rv) {
1046 errstr = "ipmi_entity_add_presence_handler";
1047 goto out_err;
1048 }
1049 rv = ipmi_entity_add_fully_up_handler(entity,
1050 fully_up,
1051 NULL);
1052 if (rv) {
1053 errstr = "ipmi_entity_add_presence_handler";
1054 goto out_err;
1055 }
1056 rv = ipmi_entity_add_control_update_handler
1057 (entity,
1058 ipmi_cmdlang_control_change,
1059 entity);
1060 if (rv) {
1061 errstr = "ipmi_entity_add_control_update_handler";
1062 goto out_err;
1063 }
1064 rv = ipmi_entity_add_hot_swap_handler(entity,
1065 entity_hot_swap,
1066 NULL);
1067 if (rv) {
1068 errstr = "ipmi_entity_add_hot_swap_handler";
1069 goto out_err;
1070 }
1071 break;
1072
1073 case IPMI_DELETED:
1074 ipmi_cmdlang_out(evi, "Operation", "Delete");
1075 break;
1076
1077 case IPMI_CHANGED:
1078 ipmi_cmdlang_out(evi, "Operation", "Change");
1079 if (ipmi_cmdlang_get_evinfo())
1080 entity_dump(entity, evi);
1081 break;
1082 }
1083
1084 ipmi_cmdlang_cmd_info_put(evi);
1085 return;
1086
1087 out_err:
1088 ipmi_cmdlang_global_err(entity_name,
1089 "cmd_entity.c(ipmi_cmdlang_entity_change)",
1090 errstr, rv);
1091 if (evi)
1092 ipmi_cmdlang_cmd_info_put(evi);
1093 }
1094
1095 static ipmi_cmdlang_cmd_t *entity_cmds, *hs_cmds;
1096
1097 static ipmi_cmdlang_init_t cmds_entity[] =
1098 {
1099 { "entity", NULL,
1100 "- Commands dealing with entities",
1101 NULL, NULL, &entity_cmds },
1102 { "list", &entity_cmds,
1103 "- List all the entities in the system",
1104 ipmi_cmdlang_domain_handler, entity_list, NULL },
1105 { "tree", &entity_cmds,
1106 "- List all the entities in the system in their tree structure",
1107 ipmi_cmdlang_domain_handler, entity_tree, NULL },
1108 { "info", &entity_cmds,
1109 "<entity> - Dump information about an entity",
1110 ipmi_cmdlang_entity_handler, entity_info, NULL },
1111 { "fru", &entity_cmds,
1112 "<entity> - Dump FRU information about an entity",
1113 ipmi_cmdlang_entity_handler, fru_info, NULL },
1114 { "hs", &entity_cmds,
1115 "- Commands dealing with hot-swap",
1116 NULL, NULL, &hs_cmds },
1117 { "get_act_time", &hs_cmds,
1118 "<entity> - Get the hot-swap auto-activate time",
1119 ipmi_cmdlang_entity_handler, entity_hs_get_act_time, NULL },
1120 { "set_act_time", &hs_cmds,
1121 "<entity> - Set the hot-swap auto-activate time",
1122 ipmi_cmdlang_entity_handler, entity_hs_set_act_time, NULL },
1123 { "get_deact_time", &hs_cmds,
1124 "<entity> - Get the hot-swap auto-deactivate time",
1125 ipmi_cmdlang_entity_handler, entity_hs_get_deact_time, NULL },
1126 { "set_deact_time", &hs_cmds,
1127 "<entity> - Set the hot-swap auto-deactivate time",
1128 ipmi_cmdlang_entity_handler, entity_hs_set_deact_time, NULL },
1129 { "activation_request", &hs_cmds,
1130 "<entity> Act like a user requested an"
1131 " activation of the entity. This is generally equivalent to"
1132 " closing the handle latch or something like that.",
1133 ipmi_cmdlang_entity_handler, entity_hs_activation_request, NULL },
1134 { "activate", &hs_cmds,
1135 "<entity> - activate the given entity",
1136 ipmi_cmdlang_entity_handler, entity_hs_activate, NULL },
1137 { "deactivate", &hs_cmds,
1138 "<entity> - deactivate the given entity",
1139 ipmi_cmdlang_entity_handler, entity_hs_deactivate, NULL },
1140 { "state", &hs_cmds,
1141 "<entity> - Return the current hot-swap state of the given entity",
1142 ipmi_cmdlang_entity_handler, entity_hs_state, NULL },
1143 { "check", &hs_cmds,
1144 "<entity> - Check the hot-swap state of the entity. This will"
1145 " not return anything, but will generate an event if the state"
1146 " is wrong",
1147 ipmi_cmdlang_entity_handler, entity_hs_check, NULL },
1148 };
1149 #define CMDS_ENTITY_LEN (sizeof(cmds_entity)/sizeof(ipmi_cmdlang_init_t))
1150
1151 int
ipmi_cmdlang_entity_init(os_handler_t * os_hnd)1152 ipmi_cmdlang_entity_init(os_handler_t *os_hnd)
1153 {
1154 return ipmi_cmdlang_reg_table(cmds_entity, CMDS_ENTITY_LEN);
1155 }
1156