hw/ipmi/ipmi_bmc_extern.c

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