hw/acpi/memory_hotplug.c

   1 #include "qemu/osdep.h"
   2 #include "hw/acpi/memory_hotplug.h"
   3 #include "hw/acpi/pc-hotplug.h"
   4 #include "hw/mem/pc-dimm.h"
   5 #include "hw/mem/nvdimm.h"
   6 #include "hw/boards.h"
   7 #include "hw/qdev-core.h"
   8 #include "trace.h"
   9 #include "qapi-event.h"
  10
  11 static ACPIOSTInfo *acpi_memory_device_status(int slot, MemStatus *mdev)
  12 {
  13     ACPIOSTInfo *info = g_new0(ACPIOSTInfo, 1);
  14
  15     info->slot_type = ACPI_SLOT_TYPE_DIMM;
  16     info->slot = g_strdup_printf("%d", slot);
  17     info->source = mdev->ost_event;
  18     info->status = mdev->ost_status;
  19     if (mdev->dimm) {
  20         DeviceState *dev = DEVICE(mdev->dimm);
  21         if (dev->id) {
  22             info->device = g_strdup(dev->id);
  23             info->has_device = true;
  24         }
  25     }
  26     return info;
  27 }
  28
  29 void acpi_memory_ospm_status(MemHotplugState *mem_st, ACPIOSTInfoList ***list)
  30 {
  31     int i;
  32
  33     for (i = 0; i < mem_st->dev_count; i++) {
  34         ACPIOSTInfoList *elem = g_new0(ACPIOSTInfoList, 1);
  35         elem->value = acpi_memory_device_status(i, &mem_st->devs[i]);
  36         elem->next = NULL;
  37         **list = elem;
  38         *list = &elem->next;
  39     }
  40 }
  41
  42 static uint64_t acpi_memory_hotplug_read(void *opaque, hwaddr addr,
  43                                          unsigned int size)
  44 {
  45     uint32_t val = 0;
  46     MemHotplugState *mem_st = opaque;
  47     MemStatus *mdev;
  48     Object *o;
  49
  50     if (mem_st->selector >= mem_st->dev_count) {
  51         trace_mhp_acpi_invalid_slot_selected(mem_st->selector);
  52         return 0;
  53     }
  54
  55     mdev = &mem_st->devs[mem_st->selector];
  56     o = OBJECT(mdev->dimm);
  57     switch (addr) {
  58     case 0x0: /* Lo part of phys address where DIMM is mapped */
  59         val = o ? object_property_get_int(o, PC_DIMM_ADDR_PROP, NULL) : 0;
  60         trace_mhp_acpi_read_addr_lo(mem_st->selector, val);
  61         break;
  62     case 0x4: /* Hi part of phys address where DIMM is mapped */
  63         val = o ? object_property_get_int(o, PC_DIMM_ADDR_PROP, NULL) >> 32 : 0;
  64         trace_mhp_acpi_read_addr_hi(mem_st->selector, val);
  65         break;
  66     case 0x8: /* Lo part of DIMM size */
  67         val = o ? object_property_get_int(o, PC_DIMM_SIZE_PROP, NULL) : 0;
  68         trace_mhp_acpi_read_size_lo(mem_st->selector, val);
  69         break;
  70     case 0xc: /* Hi part of DIMM size */
  71         val = o ? object_property_get_int(o, PC_DIMM_SIZE_PROP, NULL) >> 32 : 0;
  72         trace_mhp_acpi_read_size_hi(mem_st->selector, val);
  73         break;
  74     case 0x10: /* node proximity for _PXM method */
  75         val = o ? object_property_get_int(o, PC_DIMM_NODE_PROP, NULL) : 0;
  76         trace_mhp_acpi_read_pxm(mem_st->selector, val);
  77         break;
  78     case 0x14: /* pack and return is_* fields */
  79         val |= mdev->is_enabled   ? 1 : 0;
  80         val |= mdev->is_inserting ? 2 : 0;
  81         val |= mdev->is_removing  ? 4 : 0;
  82         trace_mhp_acpi_read_flags(mem_st->selector, val);
  83         break;
  84     default:
  85         val = ~0;
  86         break;
  87     }
  88     return val;
  89 }
  90
  91 static void acpi_memory_hotplug_write(void *opaque, hwaddr addr, uint64_t data,
  92                                       unsigned int size)
  93 {
  94     MemHotplugState *mem_st = opaque;
  95     MemStatus *mdev;
  96     ACPIOSTInfo *info;
  97     DeviceState *dev = NULL;
  98     HotplugHandler *hotplug_ctrl = NULL;
  99     Error *local_err = NULL;
 100
 101     if (!mem_st->dev_count) {
 102         return;
 103     }
 104
 105     if (addr) {
 106         if (mem_st->selector >= mem_st->dev_count) {
 107             trace_mhp_acpi_invalid_slot_selected(mem_st->selector);
 108             return;
 109         }
 110     }
 111
 112     switch (addr) {
 113     case 0x0: /* DIMM slot selector */
 114         mem_st->selector = data;
 115         trace_mhp_acpi_write_slot(mem_st->selector);
 116         break;
 117     case 0x4: /* _OST event  */
 118         mdev = &mem_st->devs[mem_st->selector];
 119         if (data == 1) {
 120             /* TODO: handle device insert OST event */
 121         } else if (data == 3) {
 122             /* TODO: handle device remove OST event */
 123         }
 124         mdev->ost_event = data;
 125         trace_mhp_acpi_write_ost_ev(mem_st->selector, mdev->ost_event);
 126         break;
 127     case 0x8: /* _OST status */
 128         mdev = &mem_st->devs[mem_st->selector];
 129         mdev->ost_status = data;
 130         trace_mhp_acpi_write_ost_status(mem_st->selector, mdev->ost_status);
 131         /* TODO: implement memory removal on guest signal */
 132
 133         info = acpi_memory_device_status(mem_st->selector, mdev);
 134         qapi_event_send_acpi_device_ost(info, &error_abort);
 135         qapi_free_ACPIOSTInfo(info);
 136         break;
 137     case 0x14: /* set is_* fields  */
 138         mdev = &mem_st->devs[mem_st->selector];
 139         if (data & 2) { /* clear insert event */
 140             mdev->is_inserting  = false;
 141             trace_mhp_acpi_clear_insert_evt(mem_st->selector);
 142         } else if (data & 4) {
 143             mdev->is_removing = false;
 144             trace_mhp_acpi_clear_remove_evt(mem_st->selector);
 145         } else if (data & 8) {
 146             if (!mdev->is_enabled) {
 147                 trace_mhp_acpi_ejecting_invalid_slot(mem_st->selector);
 148                 break;
 149             }
 150
 151             dev = DEVICE(mdev->dimm);
 152             hotplug_ctrl = qdev_get_hotplug_handler(dev);
 153             /* call pc-dimm unplug cb */
 154             hotplug_handler_unplug(hotplug_ctrl, dev, &local_err);
 155             if (local_err) {
 156                 trace_mhp_acpi_pc_dimm_delete_failed(mem_st->selector);
 157                 qapi_event_send_mem_unplug_error(dev->id,
 158                                                  error_get_pretty(local_err),
 159                                                  &error_abort);
 160                 error_free(local_err);
 161                 break;
 162             }
 163             trace_mhp_acpi_pc_dimm_deleted(mem_st->selector);
 164         }
 165         break;
 166     default:
 167         break;
 168     }
 169
 170 }
 171 static const MemoryRegionOps acpi_memory_hotplug_ops = {
 172     .read = acpi_memory_hotplug_read,
 173     .write = acpi_memory_hotplug_write,
 174     .endianness = DEVICE_LITTLE_ENDIAN,
 175     .valid = {
 176         .min_access_size = 1,
 177         .max_access_size = 4,
 178     },
 179 };
 180
 181 void acpi_memory_hotplug_init(MemoryRegion *as, Object *owner,
 182                               MemHotplugState *state)
 183 {
 184     MachineState *machine = MACHINE(qdev_get_machine());
 185
 186     state->dev_count = machine->ram_slots;
 187     if (!state->dev_count) {
 188         return;
 189     }
 190
 191     state->devs = g_malloc0(sizeof(*state->devs) * state->dev_count);
 192     memory_region_init_io(&state->io, owner, &acpi_memory_hotplug_ops, state,
 193                           "acpi-mem-hotplug", ACPI_MEMORY_HOTPLUG_IO_LEN);
 194     memory_region_add_subregion(as, ACPI_MEMORY_HOTPLUG_BASE, &state->io);
 195 }
 196
 197 /**
 198  * acpi_memory_slot_status:
 199  * @mem_st: memory hotplug state
 200  * @dev: device
 201  * @errp: set in case of an error
 202  *
 203  * Obtain a single memory slot status.
 204  *
 205  * This function will be called by memory unplug request cb and unplug cb.
 206  */
 207 static MemStatus *
 208 acpi_memory_slot_status(MemHotplugState *mem_st,
 209                         DeviceState *dev, Error **errp)
 210 {
 211     Error *local_err = NULL;
 212     int slot = object_property_get_int(OBJECT(dev), PC_DIMM_SLOT_PROP,
 213                                        &local_err);
 214
 215     if (local_err) {
 216         error_propagate(errp, local_err);
 217         return NULL;
 218     }
 219
 220     if (slot >= mem_st->dev_count) {
 221         char *dev_path = object_get_canonical_path(OBJECT(dev));
 222         error_setg(errp, "acpi_memory_slot_status: "
 223                    "device [%s] returned invalid memory slot[%d]",
 224                     dev_path, slot);
 225         g_free(dev_path);
 226         return NULL;
 227     }
 228
 229     return &mem_st->devs[slot];
 230 }
 231
 232 void acpi_memory_plug_cb(HotplugHandler *hotplug_dev, MemHotplugState *mem_st,
 233                          DeviceState *dev, Error **errp)
 234 {
 235     MemStatus *mdev;
 236     AcpiEventStatusBits event;
 237     bool is_nvdimm = object_dynamic_cast(OBJECT(dev), TYPE_NVDIMM);
 238
 239     mdev = acpi_memory_slot_status(mem_st, dev, errp);
 240     if (!mdev) {
 241         return;
 242     }
 243
 244     mdev->dimm = dev;
 245
 246     /*
 247      * do not set is_enabled and is_inserting if the slot is plugged with
 248      * a nvdimm device to stop OSPM inquires memory region from the slot.
 249      */
 250     if (is_nvdimm) {
 251         event = ACPI_NVDIMM_HOTPLUG_STATUS;
 252     } else {
 253         mdev->is_enabled = true;
 254         event = ACPI_MEMORY_HOTPLUG_STATUS;
 255     }
 256
 257     if (dev->hotplugged) {
 258         if (!is_nvdimm) {
 259             mdev->is_inserting = true;
 260         }
 261         acpi_send_event(DEVICE(hotplug_dev), event);
 262     }
 263 }
 264
 265 void acpi_memory_unplug_request_cb(HotplugHandler *hotplug_dev,
 266                                    MemHotplugState *mem_st,
 267                                    DeviceState *dev, Error **errp)
 268 {
 269     MemStatus *mdev;
 270
 271     mdev = acpi_memory_slot_status(mem_st, dev, errp);
 272     if (!mdev) {
 273         return;
 274     }
 275
 276     /* nvdimm device hot unplug is not supported yet. */
 277     assert(!object_dynamic_cast(OBJECT(dev), TYPE_NVDIMM));
 278     mdev->is_removing = true;
 279     acpi_send_event(DEVICE(hotplug_dev), ACPI_MEMORY_HOTPLUG_STATUS);
 280 }
 281
 282 void acpi_memory_unplug_cb(MemHotplugState *mem_st,
 283                            DeviceState *dev, Error **errp)
 284 {
 285     MemStatus *mdev;
 286
 287     mdev = acpi_memory_slot_status(mem_st, dev, errp);
 288     if (!mdev) {
 289         return;
 290     }
 291
 292     /* nvdimm device hot unplug is not supported yet. */
 293     assert(!object_dynamic_cast(OBJECT(dev), TYPE_NVDIMM));
 294     mdev->is_enabled = false;
 295     mdev->dimm = NULL;
 296 }
 297
 298 static const VMStateDescription vmstate_memhp_sts = {
 299     .name = "memory hotplug device state",
 300     .version_id = 1,
 301     .minimum_version_id = 1,
 302     .minimum_version_id_old = 1,
 303     .fields      = (VMStateField[]) {
 304         VMSTATE_BOOL(is_enabled, MemStatus),
 305         VMSTATE_BOOL(is_inserting, MemStatus),
 306         VMSTATE_UINT32(ost_event, MemStatus),
 307         VMSTATE_UINT32(ost_status, MemStatus),
 308         VMSTATE_END_OF_LIST()
 309     }
 310 };
 311
 312 const VMStateDescription vmstate_memory_hotplug = {
 313     .name = "memory hotplug state",
 314     .version_id = 1,
 315     .minimum_version_id = 1,
 316     .minimum_version_id_old = 1,
 317     .fields      = (VMStateField[]) {
 318         VMSTATE_UINT32(selector, MemHotplugState),
 319         VMSTATE_STRUCT_VARRAY_POINTER_UINT32(devs, MemHotplugState, dev_count,
 320                                              vmstate_memhp_sts, MemStatus),
 321         VMSTATE_END_OF_LIST()
 322     }
 323 };