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