spapr_nvdimm.c (30182B)
1 /* 2 * QEMU PAPR Storage Class Memory Interfaces 3 * 4 * Copyright (c) 2019-2020, IBM Corporation. 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 #include "qemu/osdep.h" 25 #include "qemu/cutils.h" 26 #include "qapi/error.h" 27 #include "hw/ppc/spapr_drc.h" 28 #include "hw/ppc/spapr_nvdimm.h" 29 #include "hw/mem/nvdimm.h" 30 #include "qemu/nvdimm-utils.h" 31 #include "hw/ppc/fdt.h" 32 #include "qemu/range.h" 33 #include "hw/ppc/spapr_numa.h" 34 #include "block/thread-pool.h" 35 #include "migration/vmstate.h" 36 #include "qemu/pmem.h" 37 #include "hw/qdev-properties.h" 38 39 /* DIMM health bitmap bitmap indicators. Taken from kernel's papr_scm.c */ 40 /* SCM device is unable to persist memory contents */ 41 #define PAPR_PMEM_UNARMED PPC_BIT(0) 42 43 /* 44 * The nvdimm size should be aligned to SCM block size. 45 * The SCM block size should be aligned to SPAPR_MEMORY_BLOCK_SIZE 46 * in order to have SCM regions not to overlap with dimm memory regions. 47 * The SCM devices can have variable block sizes. For now, fixing the 48 * block size to the minimum value. 49 */ 50 #define SPAPR_MINIMUM_SCM_BLOCK_SIZE SPAPR_MEMORY_BLOCK_SIZE 51 52 /* Have an explicit check for alignment */ 53 QEMU_BUILD_BUG_ON(SPAPR_MINIMUM_SCM_BLOCK_SIZE % SPAPR_MEMORY_BLOCK_SIZE); 54 55 #define TYPE_SPAPR_NVDIMM "spapr-nvdimm" 56 OBJECT_DECLARE_TYPE(SpaprNVDIMMDevice, SPAPRNVDIMMClass, SPAPR_NVDIMM) 57 58 struct SPAPRNVDIMMClass { 59 /* private */ 60 NVDIMMClass parent_class; 61 62 /* public */ 63 void (*realize)(NVDIMMDevice *dimm, Error **errp); 64 void (*unrealize)(NVDIMMDevice *dimm, Error **errp); 65 }; 66 67 bool spapr_nvdimm_validate(HotplugHandler *hotplug_dev, NVDIMMDevice *nvdimm, 68 uint64_t size, Error **errp) 69 { 70 const MachineClass *mc = MACHINE_GET_CLASS(hotplug_dev); 71 const MachineState *ms = MACHINE(hotplug_dev); 72 PCDIMMDevice *dimm = PC_DIMM(nvdimm); 73 MemoryRegion *mr = host_memory_backend_get_memory(dimm->hostmem); 74 g_autofree char *uuidstr = NULL; 75 QemuUUID uuid; 76 int ret; 77 78 if (!mc->nvdimm_supported) { 79 error_setg(errp, "NVDIMM hotplug not supported for this machine"); 80 return false; 81 } 82 83 if (!ms->nvdimms_state->is_enabled) { 84 error_setg(errp, "nvdimm device found but 'nvdimm=off' was set"); 85 return false; 86 } 87 88 if (object_property_get_int(OBJECT(nvdimm), NVDIMM_LABEL_SIZE_PROP, 89 &error_abort) == 0) { 90 error_setg(errp, "PAPR requires NVDIMM devices to have label-size set"); 91 return false; 92 } 93 94 if (size % SPAPR_MINIMUM_SCM_BLOCK_SIZE) { 95 error_setg(errp, "PAPR requires NVDIMM memory size (excluding label)" 96 " to be a multiple of %" PRIu64 "MB", 97 SPAPR_MINIMUM_SCM_BLOCK_SIZE / MiB); 98 return false; 99 } 100 101 uuidstr = object_property_get_str(OBJECT(nvdimm), NVDIMM_UUID_PROP, 102 &error_abort); 103 ret = qemu_uuid_parse(uuidstr, &uuid); 104 g_assert(!ret); 105 106 if (qemu_uuid_is_null(&uuid)) { 107 error_setg(errp, "NVDIMM device requires the uuid to be set"); 108 return false; 109 } 110 111 if (object_dynamic_cast(OBJECT(nvdimm), TYPE_SPAPR_NVDIMM) && 112 (memory_region_get_fd(mr) < 0)) { 113 error_setg(errp, "spapr-nvdimm device requires the " 114 "memdev %s to be of memory-backend-file type", 115 object_get_canonical_path_component(OBJECT(dimm->hostmem))); 116 return false; 117 } 118 119 return true; 120 } 121 122 123 void spapr_add_nvdimm(DeviceState *dev, uint64_t slot) 124 { 125 SpaprDrc *drc; 126 bool hotplugged = spapr_drc_hotplugged(dev); 127 128 drc = spapr_drc_by_id(TYPE_SPAPR_DRC_PMEM, slot); 129 g_assert(drc); 130 131 /* 132 * pc_dimm_get_free_slot() provided a free slot at pre-plug. The 133 * corresponding DRC is thus assumed to be attachable. 134 */ 135 spapr_drc_attach(drc, dev); 136 137 if (hotplugged) { 138 spapr_hotplug_req_add_by_index(drc); 139 } 140 } 141 142 static int spapr_dt_nvdimm(SpaprMachineState *spapr, void *fdt, 143 int parent_offset, NVDIMMDevice *nvdimm) 144 { 145 int child_offset; 146 char *buf; 147 SpaprDrc *drc; 148 uint32_t drc_idx; 149 uint32_t node = object_property_get_uint(OBJECT(nvdimm), PC_DIMM_NODE_PROP, 150 &error_abort); 151 uint64_t slot = object_property_get_uint(OBJECT(nvdimm), PC_DIMM_SLOT_PROP, 152 &error_abort); 153 uint64_t lsize = nvdimm->label_size; 154 uint64_t size = object_property_get_int(OBJECT(nvdimm), PC_DIMM_SIZE_PROP, 155 NULL); 156 157 drc = spapr_drc_by_id(TYPE_SPAPR_DRC_PMEM, slot); 158 g_assert(drc); 159 160 drc_idx = spapr_drc_index(drc); 161 162 buf = g_strdup_printf("ibm,pmemory@%x", drc_idx); 163 child_offset = fdt_add_subnode(fdt, parent_offset, buf); 164 g_free(buf); 165 166 _FDT(child_offset); 167 168 _FDT((fdt_setprop_cell(fdt, child_offset, "reg", drc_idx))); 169 _FDT((fdt_setprop_string(fdt, child_offset, "compatible", "ibm,pmemory"))); 170 _FDT((fdt_setprop_string(fdt, child_offset, "device_type", "ibm,pmemory"))); 171 172 spapr_numa_write_associativity_dt(spapr, fdt, child_offset, node); 173 174 buf = qemu_uuid_unparse_strdup(&nvdimm->uuid); 175 _FDT((fdt_setprop_string(fdt, child_offset, "ibm,unit-guid", buf))); 176 g_free(buf); 177 178 _FDT((fdt_setprop_cell(fdt, child_offset, "ibm,my-drc-index", drc_idx))); 179 180 _FDT((fdt_setprop_u64(fdt, child_offset, "ibm,block-size", 181 SPAPR_MINIMUM_SCM_BLOCK_SIZE))); 182 _FDT((fdt_setprop_u64(fdt, child_offset, "ibm,number-of-blocks", 183 size / SPAPR_MINIMUM_SCM_BLOCK_SIZE))); 184 _FDT((fdt_setprop_cell(fdt, child_offset, "ibm,metadata-size", lsize))); 185 186 _FDT((fdt_setprop_string(fdt, child_offset, "ibm,pmem-application", 187 "operating-system"))); 188 _FDT(fdt_setprop(fdt, child_offset, "ibm,cache-flush-required", NULL, 0)); 189 190 if (object_dynamic_cast(OBJECT(nvdimm), TYPE_SPAPR_NVDIMM)) { 191 bool is_pmem = false, pmem_override = false; 192 PCDIMMDevice *dimm = PC_DIMM(nvdimm); 193 HostMemoryBackend *hostmem = dimm->hostmem; 194 195 is_pmem = object_property_get_bool(OBJECT(hostmem), "pmem", NULL); 196 pmem_override = object_property_get_bool(OBJECT(nvdimm), 197 "pmem-override", NULL); 198 if (!is_pmem || pmem_override) { 199 _FDT(fdt_setprop(fdt, child_offset, "ibm,hcall-flush-required", 200 NULL, 0)); 201 } 202 } 203 204 return child_offset; 205 } 206 207 int spapr_pmem_dt_populate(SpaprDrc *drc, SpaprMachineState *spapr, 208 void *fdt, int *fdt_start_offset, Error **errp) 209 { 210 NVDIMMDevice *nvdimm = NVDIMM(drc->dev); 211 212 *fdt_start_offset = spapr_dt_nvdimm(spapr, fdt, 0, nvdimm); 213 214 return 0; 215 } 216 217 void spapr_dt_persistent_memory(SpaprMachineState *spapr, void *fdt) 218 { 219 int offset = fdt_subnode_offset(fdt, 0, "ibm,persistent-memory"); 220 GSList *iter, *nvdimms = nvdimm_get_device_list(); 221 222 if (offset < 0) { 223 offset = fdt_add_subnode(fdt, 0, "ibm,persistent-memory"); 224 _FDT(offset); 225 _FDT((fdt_setprop_cell(fdt, offset, "#address-cells", 0x1))); 226 _FDT((fdt_setprop_cell(fdt, offset, "#size-cells", 0x0))); 227 _FDT((fdt_setprop_string(fdt, offset, "device_type", 228 "ibm,persistent-memory"))); 229 } 230 231 /* Create DT entries for cold plugged NVDIMM devices */ 232 for (iter = nvdimms; iter; iter = iter->next) { 233 NVDIMMDevice *nvdimm = iter->data; 234 235 spapr_dt_nvdimm(spapr, fdt, offset, nvdimm); 236 } 237 g_slist_free(nvdimms); 238 239 return; 240 } 241 242 static target_ulong h_scm_read_metadata(PowerPCCPU *cpu, 243 SpaprMachineState *spapr, 244 target_ulong opcode, 245 target_ulong *args) 246 { 247 uint32_t drc_index = args[0]; 248 uint64_t offset = args[1]; 249 uint64_t len = args[2]; 250 SpaprDrc *drc = spapr_drc_by_index(drc_index); 251 NVDIMMDevice *nvdimm; 252 NVDIMMClass *ddc; 253 uint64_t data = 0; 254 uint8_t buf[8] = { 0 }; 255 256 if (!drc || !drc->dev || 257 spapr_drc_type(drc) != SPAPR_DR_CONNECTOR_TYPE_PMEM) { 258 return H_PARAMETER; 259 } 260 261 if (len != 1 && len != 2 && 262 len != 4 && len != 8) { 263 return H_P3; 264 } 265 266 nvdimm = NVDIMM(drc->dev); 267 if ((offset + len < offset) || 268 (nvdimm->label_size < len + offset)) { 269 return H_P2; 270 } 271 272 ddc = NVDIMM_GET_CLASS(nvdimm); 273 ddc->read_label_data(nvdimm, buf, len, offset); 274 275 switch (len) { 276 case 1: 277 data = ldub_p(buf); 278 break; 279 case 2: 280 data = lduw_be_p(buf); 281 break; 282 case 4: 283 data = ldl_be_p(buf); 284 break; 285 case 8: 286 data = ldq_be_p(buf); 287 break; 288 default: 289 g_assert_not_reached(); 290 } 291 292 args[0] = data; 293 294 return H_SUCCESS; 295 } 296 297 static target_ulong h_scm_write_metadata(PowerPCCPU *cpu, 298 SpaprMachineState *spapr, 299 target_ulong opcode, 300 target_ulong *args) 301 { 302 uint32_t drc_index = args[0]; 303 uint64_t offset = args[1]; 304 uint64_t data = args[2]; 305 uint64_t len = args[3]; 306 SpaprDrc *drc = spapr_drc_by_index(drc_index); 307 NVDIMMDevice *nvdimm; 308 NVDIMMClass *ddc; 309 uint8_t buf[8] = { 0 }; 310 311 if (!drc || !drc->dev || 312 spapr_drc_type(drc) != SPAPR_DR_CONNECTOR_TYPE_PMEM) { 313 return H_PARAMETER; 314 } 315 316 if (len != 1 && len != 2 && 317 len != 4 && len != 8) { 318 return H_P4; 319 } 320 321 nvdimm = NVDIMM(drc->dev); 322 if ((offset + len < offset) || 323 (nvdimm->label_size < len + offset)) { 324 return H_P2; 325 } 326 327 switch (len) { 328 case 1: 329 if (data & 0xffffffffffffff00) { 330 return H_P2; 331 } 332 stb_p(buf, data); 333 break; 334 case 2: 335 if (data & 0xffffffffffff0000) { 336 return H_P2; 337 } 338 stw_be_p(buf, data); 339 break; 340 case 4: 341 if (data & 0xffffffff00000000) { 342 return H_P2; 343 } 344 stl_be_p(buf, data); 345 break; 346 case 8: 347 stq_be_p(buf, data); 348 break; 349 default: 350 g_assert_not_reached(); 351 } 352 353 ddc = NVDIMM_GET_CLASS(nvdimm); 354 ddc->write_label_data(nvdimm, buf, len, offset); 355 356 return H_SUCCESS; 357 } 358 359 static target_ulong h_scm_bind_mem(PowerPCCPU *cpu, SpaprMachineState *spapr, 360 target_ulong opcode, target_ulong *args) 361 { 362 uint32_t drc_index = args[0]; 363 uint64_t starting_idx = args[1]; 364 uint64_t no_of_scm_blocks_to_bind = args[2]; 365 uint64_t target_logical_mem_addr = args[3]; 366 uint64_t continue_token = args[4]; 367 uint64_t size; 368 uint64_t total_no_of_scm_blocks; 369 SpaprDrc *drc = spapr_drc_by_index(drc_index); 370 hwaddr addr; 371 NVDIMMDevice *nvdimm; 372 373 if (!drc || !drc->dev || 374 spapr_drc_type(drc) != SPAPR_DR_CONNECTOR_TYPE_PMEM) { 375 return H_PARAMETER; 376 } 377 378 /* 379 * Currently continue token should be zero qemu has already bound 380 * everything and this hcall doesnt return H_BUSY. 381 */ 382 if (continue_token > 0) { 383 return H_P5; 384 } 385 386 /* Currently qemu assigns the address. */ 387 if (target_logical_mem_addr != 0xffffffffffffffff) { 388 return H_OVERLAP; 389 } 390 391 nvdimm = NVDIMM(drc->dev); 392 393 size = object_property_get_uint(OBJECT(nvdimm), 394 PC_DIMM_SIZE_PROP, &error_abort); 395 396 total_no_of_scm_blocks = size / SPAPR_MINIMUM_SCM_BLOCK_SIZE; 397 398 if (starting_idx > total_no_of_scm_blocks) { 399 return H_P2; 400 } 401 402 if (((starting_idx + no_of_scm_blocks_to_bind) < starting_idx) || 403 ((starting_idx + no_of_scm_blocks_to_bind) > total_no_of_scm_blocks)) { 404 return H_P3; 405 } 406 407 addr = object_property_get_uint(OBJECT(nvdimm), 408 PC_DIMM_ADDR_PROP, &error_abort); 409 410 addr += starting_idx * SPAPR_MINIMUM_SCM_BLOCK_SIZE; 411 412 /* Already bound, Return target logical address in R5 */ 413 args[1] = addr; 414 args[2] = no_of_scm_blocks_to_bind; 415 416 return H_SUCCESS; 417 } 418 419 typedef struct SpaprNVDIMMDeviceFlushState { 420 uint64_t continue_token; 421 int64_t hcall_ret; 422 uint32_t drcidx; 423 424 QLIST_ENTRY(SpaprNVDIMMDeviceFlushState) node; 425 } SpaprNVDIMMDeviceFlushState; 426 427 typedef struct SpaprNVDIMMDevice SpaprNVDIMMDevice; 428 struct SpaprNVDIMMDevice { 429 /* private */ 430 NVDIMMDevice parent_obj; 431 432 bool hcall_flush_required; 433 uint64_t nvdimm_flush_token; 434 QLIST_HEAD(, SpaprNVDIMMDeviceFlushState) pending_nvdimm_flush_states; 435 QLIST_HEAD(, SpaprNVDIMMDeviceFlushState) completed_nvdimm_flush_states; 436 437 /* public */ 438 439 /* 440 * The 'on' value for this property forced the qemu to enable the hcall 441 * flush for the nvdimm device even if the backend is a pmem 442 */ 443 bool pmem_override; 444 }; 445 446 static int flush_worker_cb(void *opaque) 447 { 448 SpaprNVDIMMDeviceFlushState *state = opaque; 449 SpaprDrc *drc = spapr_drc_by_index(state->drcidx); 450 PCDIMMDevice *dimm; 451 HostMemoryBackend *backend; 452 int backend_fd; 453 454 g_assert(drc != NULL); 455 456 dimm = PC_DIMM(drc->dev); 457 backend = MEMORY_BACKEND(dimm->hostmem); 458 backend_fd = memory_region_get_fd(&backend->mr); 459 460 if (object_property_get_bool(OBJECT(backend), "pmem", NULL)) { 461 MemoryRegion *mr = host_memory_backend_get_memory(dimm->hostmem); 462 void *ptr = memory_region_get_ram_ptr(mr); 463 size_t size = object_property_get_uint(OBJECT(dimm), PC_DIMM_SIZE_PROP, 464 NULL); 465 466 /* flush pmem backend */ 467 pmem_persist(ptr, size); 468 } else { 469 /* flush raw backing image */ 470 if (qemu_fdatasync(backend_fd) < 0) { 471 error_report("papr_scm: Could not sync nvdimm to backend file: %s", 472 strerror(errno)); 473 return H_HARDWARE; 474 } 475 } 476 477 return H_SUCCESS; 478 } 479 480 static void spapr_nvdimm_flush_completion_cb(void *opaque, int hcall_ret) 481 { 482 SpaprNVDIMMDeviceFlushState *state = opaque; 483 SpaprDrc *drc = spapr_drc_by_index(state->drcidx); 484 SpaprNVDIMMDevice *s_nvdimm; 485 486 g_assert(drc != NULL); 487 488 s_nvdimm = SPAPR_NVDIMM(drc->dev); 489 490 state->hcall_ret = hcall_ret; 491 QLIST_REMOVE(state, node); 492 QLIST_INSERT_HEAD(&s_nvdimm->completed_nvdimm_flush_states, state, node); 493 } 494 495 static int spapr_nvdimm_flush_post_load(void *opaque, int version_id) 496 { 497 SpaprNVDIMMDevice *s_nvdimm = (SpaprNVDIMMDevice *)opaque; 498 SpaprNVDIMMDeviceFlushState *state; 499 ThreadPool *pool = aio_get_thread_pool(qemu_get_aio_context()); 500 HostMemoryBackend *backend = MEMORY_BACKEND(PC_DIMM(s_nvdimm)->hostmem); 501 bool is_pmem = object_property_get_bool(OBJECT(backend), "pmem", NULL); 502 bool pmem_override = object_property_get_bool(OBJECT(s_nvdimm), 503 "pmem-override", NULL); 504 bool dest_hcall_flush_required = pmem_override || !is_pmem; 505 506 if (!s_nvdimm->hcall_flush_required && dest_hcall_flush_required) { 507 error_report("The file backend for the spapr-nvdimm device %s at " 508 "source is a pmem, use pmem=on and pmem-override=off to " 509 "continue.", DEVICE(s_nvdimm)->id); 510 return -EINVAL; 511 } 512 if (s_nvdimm->hcall_flush_required && !dest_hcall_flush_required) { 513 error_report("The guest expects hcall-flush support for the " 514 "spapr-nvdimm device %s, use pmem_override=on to " 515 "continue.", DEVICE(s_nvdimm)->id); 516 return -EINVAL; 517 } 518 519 QLIST_FOREACH(state, &s_nvdimm->pending_nvdimm_flush_states, node) { 520 thread_pool_submit_aio(pool, flush_worker_cb, state, 521 spapr_nvdimm_flush_completion_cb, state); 522 } 523 524 return 0; 525 } 526 527 static const VMStateDescription vmstate_spapr_nvdimm_flush_state = { 528 .name = "spapr_nvdimm_flush_state", 529 .version_id = 1, 530 .minimum_version_id = 1, 531 .fields = (VMStateField[]) { 532 VMSTATE_UINT64(continue_token, SpaprNVDIMMDeviceFlushState), 533 VMSTATE_INT64(hcall_ret, SpaprNVDIMMDeviceFlushState), 534 VMSTATE_UINT32(drcidx, SpaprNVDIMMDeviceFlushState), 535 VMSTATE_END_OF_LIST() 536 }, 537 }; 538 539 const VMStateDescription vmstate_spapr_nvdimm_states = { 540 .name = "spapr_nvdimm_states", 541 .version_id = 1, 542 .minimum_version_id = 1, 543 .post_load = spapr_nvdimm_flush_post_load, 544 .fields = (VMStateField[]) { 545 VMSTATE_BOOL(hcall_flush_required, SpaprNVDIMMDevice), 546 VMSTATE_UINT64(nvdimm_flush_token, SpaprNVDIMMDevice), 547 VMSTATE_QLIST_V(completed_nvdimm_flush_states, SpaprNVDIMMDevice, 1, 548 vmstate_spapr_nvdimm_flush_state, 549 SpaprNVDIMMDeviceFlushState, node), 550 VMSTATE_QLIST_V(pending_nvdimm_flush_states, SpaprNVDIMMDevice, 1, 551 vmstate_spapr_nvdimm_flush_state, 552 SpaprNVDIMMDeviceFlushState, node), 553 VMSTATE_END_OF_LIST() 554 }, 555 }; 556 557 /* 558 * Assign a token and reserve it for the new flush state. 559 */ 560 static SpaprNVDIMMDeviceFlushState *spapr_nvdimm_init_new_flush_state( 561 SpaprNVDIMMDevice *spapr_nvdimm) 562 { 563 SpaprNVDIMMDeviceFlushState *state; 564 565 state = g_malloc0(sizeof(*state)); 566 567 spapr_nvdimm->nvdimm_flush_token++; 568 /* Token zero is presumed as no job pending. Assert on overflow to zero */ 569 g_assert(spapr_nvdimm->nvdimm_flush_token != 0); 570 571 state->continue_token = spapr_nvdimm->nvdimm_flush_token; 572 573 QLIST_INSERT_HEAD(&spapr_nvdimm->pending_nvdimm_flush_states, state, node); 574 575 return state; 576 } 577 578 /* 579 * spapr_nvdimm_finish_flushes 580 * Waits for all pending flush requests to complete 581 * their execution and free the states 582 */ 583 void spapr_nvdimm_finish_flushes(void) 584 { 585 SpaprNVDIMMDeviceFlushState *state, *next; 586 GSList *list, *nvdimms; 587 588 /* 589 * Called on reset path, the main loop thread which calls 590 * the pending BHs has gotten out running in the reset path, 591 * finally reaching here. Other code path being guest 592 * h_client_architecture_support, thats early boot up. 593 */ 594 nvdimms = nvdimm_get_device_list(); 595 for (list = nvdimms; list; list = list->next) { 596 NVDIMMDevice *nvdimm = list->data; 597 if (object_dynamic_cast(OBJECT(nvdimm), TYPE_SPAPR_NVDIMM)) { 598 SpaprNVDIMMDevice *s_nvdimm = SPAPR_NVDIMM(nvdimm); 599 while (!QLIST_EMPTY(&s_nvdimm->pending_nvdimm_flush_states)) { 600 aio_poll(qemu_get_aio_context(), true); 601 } 602 603 QLIST_FOREACH_SAFE(state, &s_nvdimm->completed_nvdimm_flush_states, 604 node, next) { 605 QLIST_REMOVE(state, node); 606 g_free(state); 607 } 608 } 609 } 610 g_slist_free(nvdimms); 611 } 612 613 /* 614 * spapr_nvdimm_get_flush_status 615 * Fetches the status of the hcall worker and returns 616 * H_LONG_BUSY_ORDER_10_MSEC if the worker is still running. 617 */ 618 static int spapr_nvdimm_get_flush_status(SpaprNVDIMMDevice *s_nvdimm, 619 uint64_t token) 620 { 621 SpaprNVDIMMDeviceFlushState *state, *node; 622 623 QLIST_FOREACH(state, &s_nvdimm->pending_nvdimm_flush_states, node) { 624 if (state->continue_token == token) { 625 return H_LONG_BUSY_ORDER_10_MSEC; 626 } 627 } 628 629 QLIST_FOREACH_SAFE(state, &s_nvdimm->completed_nvdimm_flush_states, 630 node, node) { 631 if (state->continue_token == token) { 632 int ret = state->hcall_ret; 633 QLIST_REMOVE(state, node); 634 g_free(state); 635 return ret; 636 } 637 } 638 639 /* If not found in complete list too, invalid token */ 640 return H_P2; 641 } 642 643 /* 644 * H_SCM_FLUSH 645 * Input: drc_index, continue-token 646 * Out: continue-token 647 * Return Value: H_SUCCESS, H_Parameter, H_P2, H_LONG_BUSY_ORDER_10_MSEC, 648 * H_UNSUPPORTED 649 * 650 * Given a DRC Index Flush the data to backend NVDIMM device. The hcall returns 651 * H_LONG_BUSY_ORDER_10_MSEC when the flush takes longer time and the hcall 652 * needs to be issued multiple times in order to be completely serviced. The 653 * continue-token from the output to be passed in the argument list of 654 * subsequent hcalls until the hcall is completely serviced at which point 655 * H_SUCCESS or other error is returned. 656 */ 657 static target_ulong h_scm_flush(PowerPCCPU *cpu, SpaprMachineState *spapr, 658 target_ulong opcode, target_ulong *args) 659 { 660 int ret; 661 uint32_t drc_index = args[0]; 662 uint64_t continue_token = args[1]; 663 SpaprDrc *drc = spapr_drc_by_index(drc_index); 664 PCDIMMDevice *dimm; 665 HostMemoryBackend *backend = NULL; 666 SpaprNVDIMMDeviceFlushState *state; 667 ThreadPool *pool = aio_get_thread_pool(qemu_get_aio_context()); 668 int fd; 669 670 if (!drc || !drc->dev || 671 spapr_drc_type(drc) != SPAPR_DR_CONNECTOR_TYPE_PMEM) { 672 return H_PARAMETER; 673 } 674 675 dimm = PC_DIMM(drc->dev); 676 if (!object_dynamic_cast(OBJECT(dimm), TYPE_SPAPR_NVDIMM)) { 677 return H_PARAMETER; 678 } 679 if (continue_token == 0) { 680 bool is_pmem = false, pmem_override = false; 681 backend = MEMORY_BACKEND(dimm->hostmem); 682 fd = memory_region_get_fd(&backend->mr); 683 684 if (fd < 0) { 685 return H_UNSUPPORTED; 686 } 687 688 is_pmem = object_property_get_bool(OBJECT(backend), "pmem", NULL); 689 pmem_override = object_property_get_bool(OBJECT(dimm), 690 "pmem-override", NULL); 691 if (is_pmem && !pmem_override) { 692 return H_UNSUPPORTED; 693 } 694 695 state = spapr_nvdimm_init_new_flush_state(SPAPR_NVDIMM(dimm)); 696 if (!state) { 697 return H_HARDWARE; 698 } 699 700 state->drcidx = drc_index; 701 702 thread_pool_submit_aio(pool, flush_worker_cb, state, 703 spapr_nvdimm_flush_completion_cb, state); 704 705 continue_token = state->continue_token; 706 } 707 708 ret = spapr_nvdimm_get_flush_status(SPAPR_NVDIMM(dimm), continue_token); 709 if (H_IS_LONG_BUSY(ret)) { 710 args[0] = continue_token; 711 } 712 713 return ret; 714 } 715 716 static target_ulong h_scm_unbind_mem(PowerPCCPU *cpu, SpaprMachineState *spapr, 717 target_ulong opcode, target_ulong *args) 718 { 719 uint32_t drc_index = args[0]; 720 uint64_t starting_scm_logical_addr = args[1]; 721 uint64_t no_of_scm_blocks_to_unbind = args[2]; 722 uint64_t continue_token = args[3]; 723 uint64_t size_to_unbind; 724 Range blockrange = range_empty; 725 Range nvdimmrange = range_empty; 726 SpaprDrc *drc = spapr_drc_by_index(drc_index); 727 NVDIMMDevice *nvdimm; 728 uint64_t size, addr; 729 730 if (!drc || !drc->dev || 731 spapr_drc_type(drc) != SPAPR_DR_CONNECTOR_TYPE_PMEM) { 732 return H_PARAMETER; 733 } 734 735 /* continue_token should be zero as this hcall doesn't return H_BUSY. */ 736 if (continue_token > 0) { 737 return H_P4; 738 } 739 740 /* Check if starting_scm_logical_addr is block aligned */ 741 if (!QEMU_IS_ALIGNED(starting_scm_logical_addr, 742 SPAPR_MINIMUM_SCM_BLOCK_SIZE)) { 743 return H_P2; 744 } 745 746 size_to_unbind = no_of_scm_blocks_to_unbind * SPAPR_MINIMUM_SCM_BLOCK_SIZE; 747 if (no_of_scm_blocks_to_unbind == 0 || no_of_scm_blocks_to_unbind != 748 size_to_unbind / SPAPR_MINIMUM_SCM_BLOCK_SIZE) { 749 return H_P3; 750 } 751 752 nvdimm = NVDIMM(drc->dev); 753 size = object_property_get_int(OBJECT(nvdimm), PC_DIMM_SIZE_PROP, 754 &error_abort); 755 addr = object_property_get_int(OBJECT(nvdimm), PC_DIMM_ADDR_PROP, 756 &error_abort); 757 758 range_init_nofail(&nvdimmrange, addr, size); 759 range_init_nofail(&blockrange, starting_scm_logical_addr, size_to_unbind); 760 761 if (!range_contains_range(&nvdimmrange, &blockrange)) { 762 return H_P3; 763 } 764 765 args[1] = no_of_scm_blocks_to_unbind; 766 767 /* let unplug take care of actual unbind */ 768 return H_SUCCESS; 769 } 770 771 #define H_UNBIND_SCOPE_ALL 0x1 772 #define H_UNBIND_SCOPE_DRC 0x2 773 774 static target_ulong h_scm_unbind_all(PowerPCCPU *cpu, SpaprMachineState *spapr, 775 target_ulong opcode, target_ulong *args) 776 { 777 uint64_t target_scope = args[0]; 778 uint32_t drc_index = args[1]; 779 uint64_t continue_token = args[2]; 780 NVDIMMDevice *nvdimm; 781 uint64_t size; 782 uint64_t no_of_scm_blocks_unbound = 0; 783 784 /* continue_token should be zero as this hcall doesn't return H_BUSY. */ 785 if (continue_token > 0) { 786 return H_P4; 787 } 788 789 if (target_scope == H_UNBIND_SCOPE_DRC) { 790 SpaprDrc *drc = spapr_drc_by_index(drc_index); 791 792 if (!drc || !drc->dev || 793 spapr_drc_type(drc) != SPAPR_DR_CONNECTOR_TYPE_PMEM) { 794 return H_P2; 795 } 796 797 nvdimm = NVDIMM(drc->dev); 798 size = object_property_get_int(OBJECT(nvdimm), PC_DIMM_SIZE_PROP, 799 &error_abort); 800 801 no_of_scm_blocks_unbound = size / SPAPR_MINIMUM_SCM_BLOCK_SIZE; 802 } else if (target_scope == H_UNBIND_SCOPE_ALL) { 803 GSList *list, *nvdimms; 804 805 nvdimms = nvdimm_get_device_list(); 806 for (list = nvdimms; list; list = list->next) { 807 nvdimm = list->data; 808 size = object_property_get_int(OBJECT(nvdimm), PC_DIMM_SIZE_PROP, 809 &error_abort); 810 811 no_of_scm_blocks_unbound += size / SPAPR_MINIMUM_SCM_BLOCK_SIZE; 812 } 813 g_slist_free(nvdimms); 814 } else { 815 return H_PARAMETER; 816 } 817 818 args[1] = no_of_scm_blocks_unbound; 819 820 /* let unplug take care of actual unbind */ 821 return H_SUCCESS; 822 } 823 824 static target_ulong h_scm_health(PowerPCCPU *cpu, SpaprMachineState *spapr, 825 target_ulong opcode, target_ulong *args) 826 { 827 828 NVDIMMDevice *nvdimm; 829 uint64_t hbitmap = 0; 830 uint32_t drc_index = args[0]; 831 SpaprDrc *drc = spapr_drc_by_index(drc_index); 832 const uint64_t hbitmap_mask = PAPR_PMEM_UNARMED; 833 834 835 /* Ensure that the drc is valid & is valid PMEM dimm and is plugged in */ 836 if (!drc || !drc->dev || 837 spapr_drc_type(drc) != SPAPR_DR_CONNECTOR_TYPE_PMEM) { 838 return H_PARAMETER; 839 } 840 841 nvdimm = NVDIMM(drc->dev); 842 843 /* Update if the nvdimm is unarmed and send its status via health bitmaps */ 844 if (object_property_get_bool(OBJECT(nvdimm), NVDIMM_UNARMED_PROP, NULL)) { 845 hbitmap |= PAPR_PMEM_UNARMED; 846 } 847 848 /* Update the out args with health bitmap/mask */ 849 args[0] = hbitmap; 850 args[1] = hbitmap_mask; 851 852 return H_SUCCESS; 853 } 854 855 static void spapr_scm_register_types(void) 856 { 857 /* qemu/scm specific hcalls */ 858 spapr_register_hypercall(H_SCM_READ_METADATA, h_scm_read_metadata); 859 spapr_register_hypercall(H_SCM_WRITE_METADATA, h_scm_write_metadata); 860 spapr_register_hypercall(H_SCM_BIND_MEM, h_scm_bind_mem); 861 spapr_register_hypercall(H_SCM_UNBIND_MEM, h_scm_unbind_mem); 862 spapr_register_hypercall(H_SCM_UNBIND_ALL, h_scm_unbind_all); 863 spapr_register_hypercall(H_SCM_HEALTH, h_scm_health); 864 spapr_register_hypercall(H_SCM_FLUSH, h_scm_flush); 865 } 866 867 type_init(spapr_scm_register_types) 868 869 static void spapr_nvdimm_realize(NVDIMMDevice *dimm, Error **errp) 870 { 871 SpaprNVDIMMDevice *s_nvdimm = SPAPR_NVDIMM(dimm); 872 HostMemoryBackend *backend = MEMORY_BACKEND(PC_DIMM(dimm)->hostmem); 873 bool is_pmem = object_property_get_bool(OBJECT(backend), "pmem", NULL); 874 bool pmem_override = object_property_get_bool(OBJECT(dimm), "pmem-override", 875 NULL); 876 if (!is_pmem || pmem_override) { 877 s_nvdimm->hcall_flush_required = true; 878 } 879 880 vmstate_register(NULL, VMSTATE_INSTANCE_ID_ANY, 881 &vmstate_spapr_nvdimm_states, dimm); 882 } 883 884 static void spapr_nvdimm_unrealize(NVDIMMDevice *dimm) 885 { 886 vmstate_unregister(NULL, &vmstate_spapr_nvdimm_states, dimm); 887 } 888 889 static Property spapr_nvdimm_properties[] = { 890 #ifdef CONFIG_LIBPMEM 891 DEFINE_PROP_BOOL("pmem-override", SpaprNVDIMMDevice, pmem_override, false), 892 #endif 893 DEFINE_PROP_END_OF_LIST(), 894 }; 895 896 static void spapr_nvdimm_class_init(ObjectClass *oc, void *data) 897 { 898 DeviceClass *dc = DEVICE_CLASS(oc); 899 NVDIMMClass *nvc = NVDIMM_CLASS(oc); 900 901 nvc->realize = spapr_nvdimm_realize; 902 nvc->unrealize = spapr_nvdimm_unrealize; 903 904 device_class_set_props(dc, spapr_nvdimm_properties); 905 } 906 907 static void spapr_nvdimm_init(Object *obj) 908 { 909 SpaprNVDIMMDevice *s_nvdimm = SPAPR_NVDIMM(obj); 910 911 s_nvdimm->hcall_flush_required = false; 912 QLIST_INIT(&s_nvdimm->pending_nvdimm_flush_states); 913 QLIST_INIT(&s_nvdimm->completed_nvdimm_flush_states); 914 } 915 916 static TypeInfo spapr_nvdimm_info = { 917 .name = TYPE_SPAPR_NVDIMM, 918 .parent = TYPE_NVDIMM, 919 .class_init = spapr_nvdimm_class_init, 920 .class_size = sizeof(SPAPRNVDIMMClass), 921 .instance_size = sizeof(SpaprNVDIMMDevice), 922 .instance_init = spapr_nvdimm_init, 923 }; 924 925 static void spapr_nvdimm_register_types(void) 926 { 927 type_register_static(&spapr_nvdimm_info); 928 } 929 930 type_init(spapr_nvdimm_register_types)