1 /*
2 * IPMI BMC external connection
3 *
4 * Copyright (c) 2015 Corey Minyard, MontaVista Software, LLC
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
25 /*
26 * This is designed to connect with OpenIPMI's lanserv serial interface
27 * using the "VM" connection type. See that for details.
28 */
29
30 #include "qemu/osdep.h"
31 #include "qemu/error-report.h"
32 #include "qemu/module.h"
33 #include "qapi/error.h"
34 #include "qemu/timer.h"
35 #include "chardev/char-fe.h"
36 #include "hw/ipmi/ipmi.h"
37 #include "hw/qdev-properties.h"
38 #include "hw/qdev-properties-system.h"
39 #include "migration/vmstate.h"
40 #include "qom/object.h"
41
42 #define VM_MSG_CHAR 0xA0 /* Marks end of message */
43 #define VM_CMD_CHAR 0xA1 /* Marks end of a command */
44 #define VM_ESCAPE_CHAR 0xAA /* Set bit 4 from the next byte to 0 */
45
46 #define VM_PROTOCOL_VERSION 1
47 #define VM_CMD_VERSION 0xff /* A version number byte follows */
48 #define VM_CMD_NOATTN 0x00
49 #define VM_CMD_ATTN 0x01
50 #define VM_CMD_ATTN_IRQ 0x02
51 #define VM_CMD_POWEROFF 0x03
52 #define VM_CMD_RESET 0x04
53 #define VM_CMD_ENABLE_IRQ 0x05 /* Enable/disable the messaging irq */
54 #define VM_CMD_DISABLE_IRQ 0x06
55 #define VM_CMD_SEND_NMI 0x07
56 #define VM_CMD_CAPABILITIES 0x08
57 #define VM_CAPABILITIES_POWER 0x01
58 #define VM_CAPABILITIES_RESET 0x02
59 #define VM_CAPABILITIES_IRQ 0x04
60 #define VM_CAPABILITIES_NMI 0x08
61 #define VM_CAPABILITIES_ATTN 0x10
62 #define VM_CAPABILITIES_GRACEFUL_SHUTDOWN 0x20
63 #define VM_CMD_GRACEFUL_SHUTDOWN 0x09
64
65 #define TYPE_IPMI_BMC_EXTERN "ipmi-bmc-extern"
66 OBJECT_DECLARE_SIMPLE_TYPE(IPMIBmcExtern, IPMI_BMC_EXTERN)
67 struct IPMIBmcExtern {
68 IPMIBmc parent;
69
70 CharBackend chr;
71
72 bool connected;
73
74 unsigned char inbuf[MAX_IPMI_MSG_SIZE + 2];
75 unsigned int inpos;
76 bool in_escape;
77 bool in_too_many;
78 bool waiting_rsp;
79 bool sending_cmd;
80
81 unsigned char outbuf[(MAX_IPMI_MSG_SIZE + 2) * 2 + 1];
82 unsigned int outpos;
83 unsigned int outlen;
84
85 struct QEMUTimer *extern_timer;
86
87 /* A reset event is pending to be sent upstream. */
88 bool send_reset;
89 };
90
91 static unsigned char
ipmb_checksum(const unsigned char * data,int size,unsigned char start)92 ipmb_checksum(const unsigned char *data, int size, unsigned char start)
93 {
94 unsigned char csum = start;
95
96 for (; size > 0; size--, data++) {
97 csum += *data;
98 }
99 return csum;
100 }
101
continue_send(IPMIBmcExtern * ibe)102 static void continue_send(IPMIBmcExtern *ibe)
103 {
104 int ret;
105 if (ibe->outlen == 0) {
106 goto check_reset;
107 }
108 send:
109 ret = qemu_chr_fe_write(&ibe->chr, ibe->outbuf + ibe->outpos,
110 ibe->outlen - ibe->outpos);
111 if (ret > 0) {
112 ibe->outpos += ret;
113 }
114 if (ibe->outpos < ibe->outlen) {
115 /* Not fully transmitted, try again in a 10ms */
116 timer_mod_ns(ibe->extern_timer,
117 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + 10000000);
118 } else {
119 /* Sent */
120 ibe->outlen = 0;
121 ibe->outpos = 0;
122 if (!ibe->sending_cmd) {
123 ibe->waiting_rsp = true;
124 } else {
125 ibe->sending_cmd = false;
126 }
127 check_reset:
128 if (ibe->connected && ibe->send_reset) {
129 /* Send the reset */
130 ibe->outbuf[0] = VM_CMD_RESET;
131 ibe->outbuf[1] = VM_CMD_CHAR;
132 ibe->outlen = 2;
133 ibe->outpos = 0;
134 ibe->send_reset = false;
135 ibe->sending_cmd = true;
136 goto send;
137 }
138
139 if (ibe->waiting_rsp) {
140 /* Make sure we get a response within 4 seconds. */
141 timer_mod_ns(ibe->extern_timer,
142 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + 4000000000ULL);
143 }
144 }
145 }
146
extern_timeout(void * opaque)147 static void extern_timeout(void *opaque)
148 {
149 IPMIBmcExtern *ibe = opaque;
150 IPMIInterface *s = ibe->parent.intf;
151
152 if (ibe->connected) {
153 if (ibe->waiting_rsp && (ibe->outlen == 0)) {
154 IPMIInterfaceClass *k = IPMI_INTERFACE_GET_CLASS(s);
155 /* The message response timed out, return an error. */
156 ibe->waiting_rsp = false;
157 ibe->inbuf[1] = ibe->outbuf[1] | 0x04;
158 ibe->inbuf[2] = ibe->outbuf[2];
159 ibe->inbuf[3] = IPMI_CC_TIMEOUT;
160 k->handle_rsp(s, ibe->outbuf[0], ibe->inbuf + 1, 3);
161 } else {
162 continue_send(ibe);
163 }
164 }
165 }
166
addchar(IPMIBmcExtern * ibe,unsigned char ch)167 static void addchar(IPMIBmcExtern *ibe, unsigned char ch)
168 {
169 switch (ch) {
170 case VM_MSG_CHAR:
171 case VM_CMD_CHAR:
172 case VM_ESCAPE_CHAR:
173 ibe->outbuf[ibe->outlen] = VM_ESCAPE_CHAR;
174 ibe->outlen++;
175 ch |= 0x10;
176 /* fall through */
177 default:
178 ibe->outbuf[ibe->outlen] = ch;
179 ibe->outlen++;
180 }
181 }
182
ipmi_bmc_extern_handle_command(IPMIBmc * b,uint8_t * cmd,unsigned int cmd_len,unsigned int max_cmd_len,uint8_t msg_id)183 static void ipmi_bmc_extern_handle_command(IPMIBmc *b,
184 uint8_t *cmd, unsigned int cmd_len,
185 unsigned int max_cmd_len,
186 uint8_t msg_id)
187 {
188 IPMIBmcExtern *ibe = IPMI_BMC_EXTERN(b);
189 IPMIInterface *s = ibe->parent.intf;
190 uint8_t err = 0, csum;
191 unsigned int i;
192
193 if (ibe->outlen) {
194 /* We already have a command queued. Shouldn't ever happen. */
195 error_report("IPMI KCS: Got command when not finished with the"
196 " previous command");
197 abort();
198 }
199
200 /* If it's too short or it was truncated, return an error. */
201 if (cmd_len < 2) {
202 err = IPMI_CC_REQUEST_DATA_LENGTH_INVALID;
203 } else if ((cmd_len > max_cmd_len) || (cmd_len > MAX_IPMI_MSG_SIZE)) {
204 err = IPMI_CC_REQUEST_DATA_TRUNCATED;
205 } else if (!ibe->connected) {
206 err = IPMI_CC_BMC_INIT_IN_PROGRESS;
207 }
208 if (err) {
209 IPMIInterfaceClass *k = IPMI_INTERFACE_GET_CLASS(s);
210 unsigned char rsp[3];
211 rsp[0] = cmd[0] | 0x04;
212 rsp[1] = cmd[1];
213 rsp[2] = err;
214 ibe->waiting_rsp = false;
215 k->handle_rsp(s, msg_id, rsp, 3);
216 return;
217 }
218
219 addchar(ibe, msg_id);
220 for (i = 0; i < cmd_len; i++) {
221 addchar(ibe, cmd[i]);
222 }
223 csum = ipmb_checksum(&msg_id, 1, 0);
224 addchar(ibe, -ipmb_checksum(cmd, cmd_len, csum));
225
226 ibe->outbuf[ibe->outlen] = VM_MSG_CHAR;
227 ibe->outlen++;
228
229 /* Start the transmit */
230 continue_send(ibe);
231 }
232
handle_hw_op(IPMIBmcExtern * ibe,unsigned char hw_op)233 static void handle_hw_op(IPMIBmcExtern *ibe, unsigned char hw_op)
234 {
235 IPMIInterface *s = ibe->parent.intf;
236 IPMIInterfaceClass *k = IPMI_INTERFACE_GET_CLASS(s);
237
238 switch (hw_op) {
239 case VM_CMD_VERSION:
240 /* We only support one version at this time. */
241 break;
242
243 case VM_CMD_NOATTN:
244 k->set_atn(s, 0, 0);
245 break;
246
247 case VM_CMD_ATTN:
248 k->set_atn(s, 1, 0);
249 break;
250
251 case VM_CMD_ATTN_IRQ:
252 k->set_atn(s, 1, 1);
253 break;
254
255 case VM_CMD_POWEROFF:
256 k->do_hw_op(s, IPMI_POWEROFF_CHASSIS, 0);
257 break;
258
259 case VM_CMD_RESET:
260 k->do_hw_op(s, IPMI_RESET_CHASSIS, 0);
261 break;
262
263 case VM_CMD_ENABLE_IRQ:
264 k->set_irq_enable(s, 1);
265 break;
266
267 case VM_CMD_DISABLE_IRQ:
268 k->set_irq_enable(s, 0);
269 break;
270
271 case VM_CMD_SEND_NMI:
272 k->do_hw_op(s, IPMI_SEND_NMI, 0);
273 break;
274
275 case VM_CMD_GRACEFUL_SHUTDOWN:
276 k->do_hw_op(s, IPMI_SHUTDOWN_VIA_ACPI_OVERTEMP, 0);
277 break;
278 }
279 }
280
handle_msg(IPMIBmcExtern * ibe)281 static void handle_msg(IPMIBmcExtern *ibe)
282 {
283 IPMIInterfaceClass *k = IPMI_INTERFACE_GET_CLASS(ibe->parent.intf);
284
285 if (ibe->in_escape) {
286 ipmi_debug("msg escape not ended\n");
287 return;
288 }
289 if (ibe->inpos < 5) {
290 ipmi_debug("msg too short\n");
291 return;
292 }
293 if (ibe->in_too_many) {
294 ibe->inbuf[3] = IPMI_CC_REQUEST_DATA_TRUNCATED;
295 ibe->inpos = 4;
296 } else if (ipmb_checksum(ibe->inbuf, ibe->inpos, 0) != 0) {
297 ipmi_debug("msg checksum failure\n");
298 return;
299 } else {
300 ibe->inpos--; /* Remove checksum */
301 }
302
303 timer_del(ibe->extern_timer);
304 ibe->waiting_rsp = false;
305 k->handle_rsp(ibe->parent.intf, ibe->inbuf[0], ibe->inbuf + 1, ibe->inpos - 1);
306 }
307
can_receive(void * opaque)308 static int can_receive(void *opaque)
309 {
310 return 1;
311 }
312
receive(void * opaque,const uint8_t * buf,int size)313 static void receive(void *opaque, const uint8_t *buf, int size)
314 {
315 IPMIBmcExtern *ibe = opaque;
316 int i;
317 unsigned char hw_op;
318
319 for (i = 0; i < size; i++) {
320 unsigned char ch = buf[i];
321
322 switch (ch) {
323 case VM_MSG_CHAR:
324 handle_msg(ibe);
325 ibe->in_too_many = false;
326 ibe->inpos = 0;
327 break;
328
329 case VM_CMD_CHAR:
330 if (ibe->in_too_many) {
331 ipmi_debug("cmd in too many\n");
332 ibe->in_too_many = false;
333 ibe->inpos = 0;
334 break;
335 }
336 if (ibe->in_escape) {
337 ipmi_debug("cmd in escape\n");
338 ibe->in_too_many = false;
339 ibe->inpos = 0;
340 ibe->in_escape = false;
341 break;
342 }
343 ibe->in_too_many = false;
344 if (ibe->inpos < 1) {
345 break;
346 }
347 hw_op = ibe->inbuf[0];
348 ibe->inpos = 0;
349 goto out_hw_op;
350 break;
351
352 case VM_ESCAPE_CHAR:
353 ibe->in_escape = true;
354 break;
355
356 default:
357 if (ibe->in_escape) {
358 ch &= ~0x10;
359 ibe->in_escape = false;
360 }
361 if (ibe->in_too_many) {
362 break;
363 }
364 if (ibe->inpos >= sizeof(ibe->inbuf)) {
365 ibe->in_too_many = true;
366 break;
367 }
368 ibe->inbuf[ibe->inpos] = ch;
369 ibe->inpos++;
370 break;
371 }
372 }
373 return;
374
375 out_hw_op:
376 handle_hw_op(ibe, hw_op);
377 }
378
chr_event(void * opaque,QEMUChrEvent event)379 static void chr_event(void *opaque, QEMUChrEvent event)
380 {
381 IPMIBmcExtern *ibe = opaque;
382 IPMIInterface *s = ibe->parent.intf;
383 IPMIInterfaceClass *k = IPMI_INTERFACE_GET_CLASS(s);
384 unsigned char v;
385
386 switch (event) {
387 case CHR_EVENT_OPENED:
388 ibe->connected = true;
389 ibe->outpos = 0;
390 ibe->outlen = 0;
391 addchar(ibe, VM_CMD_VERSION);
392 addchar(ibe, VM_PROTOCOL_VERSION);
393 ibe->outbuf[ibe->outlen] = VM_CMD_CHAR;
394 ibe->outlen++;
395 addchar(ibe, VM_CMD_CAPABILITIES);
396 v = VM_CAPABILITIES_IRQ | VM_CAPABILITIES_ATTN;
397 if (k->do_hw_op(ibe->parent.intf, IPMI_POWEROFF_CHASSIS, 1) == 0) {
398 v |= VM_CAPABILITIES_POWER;
399 }
400 if (k->do_hw_op(ibe->parent.intf, IPMI_SHUTDOWN_VIA_ACPI_OVERTEMP, 1)
401 == 0) {
402 v |= VM_CAPABILITIES_GRACEFUL_SHUTDOWN;
403 }
404 if (k->do_hw_op(ibe->parent.intf, IPMI_RESET_CHASSIS, 1) == 0) {
405 v |= VM_CAPABILITIES_RESET;
406 }
407 if (k->do_hw_op(ibe->parent.intf, IPMI_SEND_NMI, 1) == 0) {
408 v |= VM_CAPABILITIES_NMI;
409 }
410 addchar(ibe, v);
411 ibe->outbuf[ibe->outlen] = VM_CMD_CHAR;
412 ibe->outlen++;
413 ibe->sending_cmd = false;
414 continue_send(ibe);
415 break;
416
417 case CHR_EVENT_CLOSED:
418 if (!ibe->connected) {
419 return;
420 }
421 ibe->connected = false;
422 /*
423 * Don't hang the OS trying to handle the ATN bit, other end will
424 * resend on a reconnect.
425 */
426 k->set_atn(s, 0, 0);
427 if (ibe->waiting_rsp) {
428 ibe->waiting_rsp = false;
429 ibe->inbuf[1] = ibe->outbuf[1] | 0x04;
430 ibe->inbuf[2] = ibe->outbuf[2];
431 ibe->inbuf[3] = IPMI_CC_BMC_INIT_IN_PROGRESS;
432 k->handle_rsp(s, ibe->outbuf[0], ibe->inbuf + 1, 3);
433 }
434 break;
435
436 case CHR_EVENT_BREAK:
437 case CHR_EVENT_MUX_IN:
438 case CHR_EVENT_MUX_OUT:
439 /* Ignore */
440 break;
441 }
442 }
443
ipmi_bmc_extern_handle_reset(IPMIBmc * b)444 static void ipmi_bmc_extern_handle_reset(IPMIBmc *b)
445 {
446 IPMIBmcExtern *ibe = IPMI_BMC_EXTERN(b);
447
448 ibe->send_reset = true;
449 continue_send(ibe);
450 }
451
ipmi_bmc_extern_post_migrate(void * opaque,int version_id)452 static int ipmi_bmc_extern_post_migrate(void *opaque, int version_id)
453 {
454 IPMIBmcExtern *ibe = opaque;
455
456 /*
457 * We don't directly restore waiting_rsp, Instead, we return an
458 * error on the interface if a response was being waited for.
459 */
460 if (ibe->waiting_rsp) {
461 IPMIInterface *ii = ibe->parent.intf;
462 IPMIInterfaceClass *iic = IPMI_INTERFACE_GET_CLASS(ii);
463
464 ibe->waiting_rsp = false;
465 ibe->inbuf[1] = ibe->outbuf[1] | 0x04;
466 ibe->inbuf[2] = ibe->outbuf[2];
467 ibe->inbuf[3] = IPMI_CC_BMC_INIT_IN_PROGRESS;
468 iic->handle_rsp(ii, ibe->outbuf[0], ibe->inbuf + 1, 3);
469 }
470 return 0;
471 }
472
473 static const VMStateDescription vmstate_ipmi_bmc_extern = {
474 .name = TYPE_IPMI_BMC_EXTERN,
475 .version_id = 1,
476 .minimum_version_id = 1,
477 .post_load = ipmi_bmc_extern_post_migrate,
478 .fields = (const VMStateField[]) {
479 VMSTATE_BOOL(send_reset, IPMIBmcExtern),
480 VMSTATE_BOOL(waiting_rsp, IPMIBmcExtern),
481 VMSTATE_END_OF_LIST()
482 }
483 };
484
ipmi_bmc_extern_realize(DeviceState * dev,Error ** errp)485 static void ipmi_bmc_extern_realize(DeviceState *dev, Error **errp)
486 {
487 IPMIBmcExtern *ibe = IPMI_BMC_EXTERN(dev);
488
489 if (!qemu_chr_fe_backend_connected(&ibe->chr)) {
490 error_setg(errp, "IPMI external bmc requires chardev attribute");
491 return;
492 }
493
494 qemu_chr_fe_set_handlers(&ibe->chr, can_receive, receive,
495 chr_event, NULL, ibe, NULL, true);
496 }
497
ipmi_bmc_extern_init(Object * obj)498 static void ipmi_bmc_extern_init(Object *obj)
499 {
500 IPMIBmcExtern *ibe = IPMI_BMC_EXTERN(obj);
501
502 ibe->extern_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, extern_timeout, ibe);
503 }
504
ipmi_bmc_extern_finalize(Object * obj)505 static void ipmi_bmc_extern_finalize(Object *obj)
506 {
507 IPMIBmcExtern *ibe = IPMI_BMC_EXTERN(obj);
508
509 timer_free(ibe->extern_timer);
510 }
511
512 static const Property ipmi_bmc_extern_properties[] = {
513 DEFINE_PROP_CHR("chardev", IPMIBmcExtern, chr),
514 };
515
ipmi_bmc_extern_class_init(ObjectClass * oc,const void * data)516 static void ipmi_bmc_extern_class_init(ObjectClass *oc, const void *data)
517 {
518 DeviceClass *dc = DEVICE_CLASS(oc);
519 IPMIBmcClass *bk = IPMI_BMC_CLASS(oc);
520
521 bk->handle_command = ipmi_bmc_extern_handle_command;
522 bk->handle_reset = ipmi_bmc_extern_handle_reset;
523 dc->hotpluggable = false;
524 dc->realize = ipmi_bmc_extern_realize;
525 dc->vmsd = &vmstate_ipmi_bmc_extern;
526 device_class_set_props(dc, ipmi_bmc_extern_properties);
527 }
528
529 static const TypeInfo ipmi_bmc_extern_type = {
530 .name = TYPE_IPMI_BMC_EXTERN,
531 .parent = TYPE_IPMI_BMC,
532 .instance_size = sizeof(IPMIBmcExtern),
533 .instance_init = ipmi_bmc_extern_init,
534 .instance_finalize = ipmi_bmc_extern_finalize,
535 .class_init = ipmi_bmc_extern_class_init,
536 };
537
ipmi_bmc_extern_register_types(void)538 static void ipmi_bmc_extern_register_types(void)
539 {
540 type_register_static(&ipmi_bmc_extern_type);
541 }
542
543 type_init(ipmi_bmc_extern_register_types)
544