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 "qapi/error.h" 26 #include "hw/ppc/spapr_drc.h" 27 #include "hw/ppc/spapr_nvdimm.h" 28 #include "hw/mem/nvdimm.h" 29 #include "qemu/nvdimm-utils.h" 30 #include "qemu/option.h" 31 #include "hw/ppc/fdt.h" 32 #include "qemu/range.h" 33 #include "sysemu/sysemu.h" 34 35 void spapr_nvdimm_validate(HotplugHandler *hotplug_dev, NVDIMMDevice *nvdimm, 36 uint64_t size, Error **errp) 37 { 38 const MachineClass *mc = MACHINE_GET_CLASS(hotplug_dev); 39 const MachineState *ms = MACHINE(hotplug_dev); 40 const char *nvdimm_opt = qemu_opt_get(qemu_get_machine_opts(), "nvdimm"); 41 g_autofree char *uuidstr = NULL; 42 QemuUUID uuid; 43 int ret; 44 45 if (!mc->nvdimm_supported) { 46 error_setg(errp, "NVDIMM hotplug not supported for this machine"); 47 return; 48 } 49 50 /* 51 * NVDIMM support went live in 5.1 without considering that, in 52 * other archs, the user needs to enable NVDIMM support with the 53 * 'nvdimm' machine option and the default behavior is NVDIMM 54 * support disabled. It is too late to roll back to the standard 55 * behavior without breaking 5.1 guests. What we can do is to 56 * ensure that, if the user sets nvdimm=off, we error out 57 * regardless of being 5.1 or newer. 58 */ 59 if (!ms->nvdimms_state->is_enabled && nvdimm_opt) { 60 error_setg(errp, "nvdimm device found but 'nvdimm=off' was set"); 61 return; 62 } 63 64 if (object_property_get_int(OBJECT(nvdimm), NVDIMM_LABEL_SIZE_PROP, 65 &error_abort) == 0) { 66 error_setg(errp, "PAPR requires NVDIMM devices to have label-size set"); 67 return; 68 } 69 70 if (size % SPAPR_MINIMUM_SCM_BLOCK_SIZE) { 71 error_setg(errp, "PAPR requires NVDIMM memory size (excluding label)" 72 " to be a multiple of %" PRIu64 "MB", 73 SPAPR_MINIMUM_SCM_BLOCK_SIZE / MiB); 74 return; 75 } 76 77 uuidstr = object_property_get_str(OBJECT(nvdimm), NVDIMM_UUID_PROP, 78 &error_abort); 79 ret = qemu_uuid_parse(uuidstr, &uuid); 80 g_assert(!ret); 81 82 if (qemu_uuid_is_null(&uuid)) { 83 error_setg(errp, "NVDIMM device requires the uuid to be set"); 84 return; 85 } 86 } 87 88 89 void spapr_add_nvdimm(DeviceState *dev, uint64_t slot, Error **errp) 90 { 91 SpaprDrc *drc; 92 bool hotplugged = spapr_drc_hotplugged(dev); 93 Error *local_err = NULL; 94 95 drc = spapr_drc_by_id(TYPE_SPAPR_DRC_PMEM, slot); 96 g_assert(drc); 97 98 spapr_drc_attach(drc, dev, &local_err); 99 if (local_err) { 100 error_propagate(errp, local_err); 101 return; 102 } 103 104 if (hotplugged) { 105 spapr_hotplug_req_add_by_index(drc); 106 } 107 } 108 109 void spapr_create_nvdimm_dr_connectors(SpaprMachineState *spapr) 110 { 111 MachineState *machine = MACHINE(spapr); 112 int i; 113 114 for (i = 0; i < machine->ram_slots; i++) { 115 spapr_dr_connector_new(OBJECT(spapr), TYPE_SPAPR_DRC_PMEM, i); 116 } 117 } 118 119 120 static int spapr_dt_nvdimm(void *fdt, int parent_offset, 121 NVDIMMDevice *nvdimm) 122 { 123 int child_offset; 124 char *buf; 125 SpaprDrc *drc; 126 uint32_t drc_idx; 127 uint32_t node = object_property_get_uint(OBJECT(nvdimm), PC_DIMM_NODE_PROP, 128 &error_abort); 129 uint64_t slot = object_property_get_uint(OBJECT(nvdimm), PC_DIMM_SLOT_PROP, 130 &error_abort); 131 uint32_t associativity[] = { 132 cpu_to_be32(0x4), /* length */ 133 cpu_to_be32(0x0), cpu_to_be32(0x0), 134 cpu_to_be32(0x0), cpu_to_be32(node) 135 }; 136 uint64_t lsize = nvdimm->label_size; 137 uint64_t size = object_property_get_int(OBJECT(nvdimm), PC_DIMM_SIZE_PROP, 138 NULL); 139 140 drc = spapr_drc_by_id(TYPE_SPAPR_DRC_PMEM, slot); 141 g_assert(drc); 142 143 drc_idx = spapr_drc_index(drc); 144 145 buf = g_strdup_printf("ibm,pmemory@%x", drc_idx); 146 child_offset = fdt_add_subnode(fdt, parent_offset, buf); 147 g_free(buf); 148 149 _FDT(child_offset); 150 151 _FDT((fdt_setprop_cell(fdt, child_offset, "reg", drc_idx))); 152 _FDT((fdt_setprop_string(fdt, child_offset, "compatible", "ibm,pmemory"))); 153 _FDT((fdt_setprop_string(fdt, child_offset, "device_type", "ibm,pmemory"))); 154 155 _FDT((fdt_setprop(fdt, child_offset, "ibm,associativity", associativity, 156 sizeof(associativity)))); 157 158 buf = qemu_uuid_unparse_strdup(&nvdimm->uuid); 159 _FDT((fdt_setprop_string(fdt, child_offset, "ibm,unit-guid", buf))); 160 g_free(buf); 161 162 _FDT((fdt_setprop_cell(fdt, child_offset, "ibm,my-drc-index", drc_idx))); 163 164 _FDT((fdt_setprop_u64(fdt, child_offset, "ibm,block-size", 165 SPAPR_MINIMUM_SCM_BLOCK_SIZE))); 166 _FDT((fdt_setprop_u64(fdt, child_offset, "ibm,number-of-blocks", 167 size / SPAPR_MINIMUM_SCM_BLOCK_SIZE))); 168 _FDT((fdt_setprop_cell(fdt, child_offset, "ibm,metadata-size", lsize))); 169 170 _FDT((fdt_setprop_string(fdt, child_offset, "ibm,pmem-application", 171 "operating-system"))); 172 _FDT(fdt_setprop(fdt, child_offset, "ibm,cache-flush-required", NULL, 0)); 173 174 return child_offset; 175 } 176 177 int spapr_pmem_dt_populate(SpaprDrc *drc, SpaprMachineState *spapr, 178 void *fdt, int *fdt_start_offset, Error **errp) 179 { 180 NVDIMMDevice *nvdimm = NVDIMM(drc->dev); 181 182 *fdt_start_offset = spapr_dt_nvdimm(fdt, 0, nvdimm); 183 184 return 0; 185 } 186 187 void spapr_dt_persistent_memory(void *fdt) 188 { 189 int offset = fdt_subnode_offset(fdt, 0, "persistent-memory"); 190 GSList *iter, *nvdimms = nvdimm_get_device_list(); 191 192 if (offset < 0) { 193 offset = fdt_add_subnode(fdt, 0, "persistent-memory"); 194 _FDT(offset); 195 _FDT((fdt_setprop_cell(fdt, offset, "#address-cells", 0x1))); 196 _FDT((fdt_setprop_cell(fdt, offset, "#size-cells", 0x0))); 197 _FDT((fdt_setprop_string(fdt, offset, "device_type", 198 "ibm,persistent-memory"))); 199 } 200 201 /* Create DT entries for cold plugged NVDIMM devices */ 202 for (iter = nvdimms; iter; iter = iter->next) { 203 NVDIMMDevice *nvdimm = iter->data; 204 205 spapr_dt_nvdimm(fdt, offset, nvdimm); 206 } 207 g_slist_free(nvdimms); 208 209 return; 210 } 211 212 static target_ulong h_scm_read_metadata(PowerPCCPU *cpu, 213 SpaprMachineState *spapr, 214 target_ulong opcode, 215 target_ulong *args) 216 { 217 uint32_t drc_index = args[0]; 218 uint64_t offset = args[1]; 219 uint64_t len = args[2]; 220 SpaprDrc *drc = spapr_drc_by_index(drc_index); 221 NVDIMMDevice *nvdimm; 222 NVDIMMClass *ddc; 223 uint64_t data = 0; 224 uint8_t buf[8] = { 0 }; 225 226 if (!drc || !drc->dev || 227 spapr_drc_type(drc) != SPAPR_DR_CONNECTOR_TYPE_PMEM) { 228 return H_PARAMETER; 229 } 230 231 if (len != 1 && len != 2 && 232 len != 4 && len != 8) { 233 return H_P3; 234 } 235 236 nvdimm = NVDIMM(drc->dev); 237 if ((offset + len < offset) || 238 (nvdimm->label_size < len + offset)) { 239 return H_P2; 240 } 241 242 ddc = NVDIMM_GET_CLASS(nvdimm); 243 ddc->read_label_data(nvdimm, buf, len, offset); 244 245 switch (len) { 246 case 1: 247 data = ldub_p(buf); 248 break; 249 case 2: 250 data = lduw_be_p(buf); 251 break; 252 case 4: 253 data = ldl_be_p(buf); 254 break; 255 case 8: 256 data = ldq_be_p(buf); 257 break; 258 default: 259 g_assert_not_reached(); 260 } 261 262 args[0] = data; 263 264 return H_SUCCESS; 265 } 266 267 static target_ulong h_scm_write_metadata(PowerPCCPU *cpu, 268 SpaprMachineState *spapr, 269 target_ulong opcode, 270 target_ulong *args) 271 { 272 uint32_t drc_index = args[0]; 273 uint64_t offset = args[1]; 274 uint64_t data = args[2]; 275 uint64_t len = args[3]; 276 SpaprDrc *drc = spapr_drc_by_index(drc_index); 277 NVDIMMDevice *nvdimm; 278 NVDIMMClass *ddc; 279 uint8_t buf[8] = { 0 }; 280 281 if (!drc || !drc->dev || 282 spapr_drc_type(drc) != SPAPR_DR_CONNECTOR_TYPE_PMEM) { 283 return H_PARAMETER; 284 } 285 286 if (len != 1 && len != 2 && 287 len != 4 && len != 8) { 288 return H_P4; 289 } 290 291 nvdimm = NVDIMM(drc->dev); 292 if ((offset + len < offset) || 293 (nvdimm->label_size < len + offset)) { 294 return H_P2; 295 } 296 297 switch (len) { 298 case 1: 299 if (data & 0xffffffffffffff00) { 300 return H_P2; 301 } 302 stb_p(buf, data); 303 break; 304 case 2: 305 if (data & 0xffffffffffff0000) { 306 return H_P2; 307 } 308 stw_be_p(buf, data); 309 break; 310 case 4: 311 if (data & 0xffffffff00000000) { 312 return H_P2; 313 } 314 stl_be_p(buf, data); 315 break; 316 case 8: 317 stq_be_p(buf, data); 318 break; 319 default: 320 g_assert_not_reached(); 321 } 322 323 ddc = NVDIMM_GET_CLASS(nvdimm); 324 ddc->write_label_data(nvdimm, buf, len, offset); 325 326 return H_SUCCESS; 327 } 328 329 static target_ulong h_scm_bind_mem(PowerPCCPU *cpu, SpaprMachineState *spapr, 330 target_ulong opcode, target_ulong *args) 331 { 332 uint32_t drc_index = args[0]; 333 uint64_t starting_idx = args[1]; 334 uint64_t no_of_scm_blocks_to_bind = args[2]; 335 uint64_t target_logical_mem_addr = args[3]; 336 uint64_t continue_token = args[4]; 337 uint64_t size; 338 uint64_t total_no_of_scm_blocks; 339 SpaprDrc *drc = spapr_drc_by_index(drc_index); 340 hwaddr addr; 341 NVDIMMDevice *nvdimm; 342 343 if (!drc || !drc->dev || 344 spapr_drc_type(drc) != SPAPR_DR_CONNECTOR_TYPE_PMEM) { 345 return H_PARAMETER; 346 } 347 348 /* 349 * Currently continue token should be zero qemu has already bound 350 * everything and this hcall doesnt return H_BUSY. 351 */ 352 if (continue_token > 0) { 353 return H_P5; 354 } 355 356 /* Currently qemu assigns the address. */ 357 if (target_logical_mem_addr != 0xffffffffffffffff) { 358 return H_OVERLAP; 359 } 360 361 nvdimm = NVDIMM(drc->dev); 362 363 size = object_property_get_uint(OBJECT(nvdimm), 364 PC_DIMM_SIZE_PROP, &error_abort); 365 366 total_no_of_scm_blocks = size / SPAPR_MINIMUM_SCM_BLOCK_SIZE; 367 368 if (starting_idx > total_no_of_scm_blocks) { 369 return H_P2; 370 } 371 372 if (((starting_idx + no_of_scm_blocks_to_bind) < starting_idx) || 373 ((starting_idx + no_of_scm_blocks_to_bind) > total_no_of_scm_blocks)) { 374 return H_P3; 375 } 376 377 addr = object_property_get_uint(OBJECT(nvdimm), 378 PC_DIMM_ADDR_PROP, &error_abort); 379 380 addr += starting_idx * SPAPR_MINIMUM_SCM_BLOCK_SIZE; 381 382 /* Already bound, Return target logical address in R5 */ 383 args[1] = addr; 384 args[2] = no_of_scm_blocks_to_bind; 385 386 return H_SUCCESS; 387 } 388 389 static target_ulong h_scm_unbind_mem(PowerPCCPU *cpu, SpaprMachineState *spapr, 390 target_ulong opcode, target_ulong *args) 391 { 392 uint32_t drc_index = args[0]; 393 uint64_t starting_scm_logical_addr = args[1]; 394 uint64_t no_of_scm_blocks_to_unbind = args[2]; 395 uint64_t continue_token = args[3]; 396 uint64_t size_to_unbind; 397 Range blockrange = range_empty; 398 Range nvdimmrange = range_empty; 399 SpaprDrc *drc = spapr_drc_by_index(drc_index); 400 NVDIMMDevice *nvdimm; 401 uint64_t size, addr; 402 403 if (!drc || !drc->dev || 404 spapr_drc_type(drc) != SPAPR_DR_CONNECTOR_TYPE_PMEM) { 405 return H_PARAMETER; 406 } 407 408 /* continue_token should be zero as this hcall doesn't return H_BUSY. */ 409 if (continue_token > 0) { 410 return H_P4; 411 } 412 413 /* Check if starting_scm_logical_addr is block aligned */ 414 if (!QEMU_IS_ALIGNED(starting_scm_logical_addr, 415 SPAPR_MINIMUM_SCM_BLOCK_SIZE)) { 416 return H_P2; 417 } 418 419 size_to_unbind = no_of_scm_blocks_to_unbind * SPAPR_MINIMUM_SCM_BLOCK_SIZE; 420 if (no_of_scm_blocks_to_unbind == 0 || no_of_scm_blocks_to_unbind != 421 size_to_unbind / SPAPR_MINIMUM_SCM_BLOCK_SIZE) { 422 return H_P3; 423 } 424 425 nvdimm = NVDIMM(drc->dev); 426 size = object_property_get_int(OBJECT(nvdimm), PC_DIMM_SIZE_PROP, 427 &error_abort); 428 addr = object_property_get_int(OBJECT(nvdimm), PC_DIMM_ADDR_PROP, 429 &error_abort); 430 431 range_init_nofail(&nvdimmrange, addr, size); 432 range_init_nofail(&blockrange, starting_scm_logical_addr, size_to_unbind); 433 434 if (!range_contains_range(&nvdimmrange, &blockrange)) { 435 return H_P3; 436 } 437 438 args[1] = no_of_scm_blocks_to_unbind; 439 440 /* let unplug take care of actual unbind */ 441 return H_SUCCESS; 442 } 443 444 #define H_UNBIND_SCOPE_ALL 0x1 445 #define H_UNBIND_SCOPE_DRC 0x2 446 447 static target_ulong h_scm_unbind_all(PowerPCCPU *cpu, SpaprMachineState *spapr, 448 target_ulong opcode, target_ulong *args) 449 { 450 uint64_t target_scope = args[0]; 451 uint32_t drc_index = args[1]; 452 uint64_t continue_token = args[2]; 453 NVDIMMDevice *nvdimm; 454 uint64_t size; 455 uint64_t no_of_scm_blocks_unbound = 0; 456 457 /* continue_token should be zero as this hcall doesn't return H_BUSY. */ 458 if (continue_token > 0) { 459 return H_P4; 460 } 461 462 if (target_scope == H_UNBIND_SCOPE_DRC) { 463 SpaprDrc *drc = spapr_drc_by_index(drc_index); 464 465 if (!drc || !drc->dev || 466 spapr_drc_type(drc) != SPAPR_DR_CONNECTOR_TYPE_PMEM) { 467 return H_P2; 468 } 469 470 nvdimm = NVDIMM(drc->dev); 471 size = object_property_get_int(OBJECT(nvdimm), PC_DIMM_SIZE_PROP, 472 &error_abort); 473 474 no_of_scm_blocks_unbound = size / SPAPR_MINIMUM_SCM_BLOCK_SIZE; 475 } else if (target_scope == H_UNBIND_SCOPE_ALL) { 476 GSList *list, *nvdimms; 477 478 nvdimms = nvdimm_get_device_list(); 479 for (list = nvdimms; list; list = list->next) { 480 nvdimm = list->data; 481 size = object_property_get_int(OBJECT(nvdimm), PC_DIMM_SIZE_PROP, 482 &error_abort); 483 484 no_of_scm_blocks_unbound += size / SPAPR_MINIMUM_SCM_BLOCK_SIZE; 485 } 486 g_slist_free(nvdimms); 487 } else { 488 return H_PARAMETER; 489 } 490 491 args[1] = no_of_scm_blocks_unbound; 492 493 /* let unplug take care of actual unbind */ 494 return H_SUCCESS; 495 } 496 497 static void spapr_scm_register_types(void) 498 { 499 /* qemu/scm specific hcalls */ 500 spapr_register_hypercall(H_SCM_READ_METADATA, h_scm_read_metadata); 501 spapr_register_hypercall(H_SCM_WRITE_METADATA, h_scm_write_metadata); 502 spapr_register_hypercall(H_SCM_BIND_MEM, h_scm_bind_mem); 503 spapr_register_hypercall(H_SCM_UNBIND_MEM, h_scm_unbind_mem); 504 spapr_register_hypercall(H_SCM_UNBIND_ALL, h_scm_unbind_all); 505 } 506 507 type_init(spapr_scm_register_types) 508