Init vNVDIMM LSA if applicable
PATCH 1/2 NVDIMM: rename NVDIMM::label_size to NVDIMM::lsa_size
In reply to Robert HooPer recent spec[1], change struct NVDIMMDevice::label_size semanteme to describe the label's size in LSA (Label Storage Area). Instead, use new 'lsa_size' for the total size of LSA.
[1]: UEFI spec v2.9, "Label Storage Area Description" in section 13.19.
--- docs/nvdimm.txt | 4 ++-- hw/acpi/nvdimm.c | 14 +++++++------- hw/mem/nvdimm.c | 22 +++++++++++----------- include/hw/mem/nvdimm.h | 4 ++-- 4 files changed, 22 insertions(+), 22 deletions(-)
docs/nvdimm.txt +2 -2
@@ -90,9 +90,9 @@ Label QEMU v2.7.0 and later implement the label support for vNVDIMM devices. To enable label on vNVDIMM devices, users can simply add -"label-size=$SZ" option to "-device nvdimm", e.g. +"lsa-size=$SZ" option to "-device nvdimm", e.g. - -device nvdimm,id=nvdimm1,memdev=mem1,label-size=128K + -device nvdimm,id=nvdimm1,memdev=mem1,lsa-size=128K Note:
hw/acpi/nvdimm.c +7 -7
@@ -655,7 +655,7 @@ static void nvdimm_dsm_label_size(NVDIMMDevice *nvdimm, hwaddr dsm_mem_addr) };uint32_t label_size, mxfer; - label_size = nvdimm->label_size; + label_size = nvdimm->lsa_size; mxfer =nvdimm_get_max_xfer_label_size ();nvdimm_debug ("label_size 0x%x, max_xfer 0x%x.\n" , label_size, mxfer);
@@ -679,9 +679,9 @@ static uint32_t nvdimm_rw_label_data_check(NVDIMMDevice *nvdimm,return ret; } -if (nvdimm->label_size < offset + length) { +if (nvdimm->lsa_size < offset + length) {nvdimm_debug ("position 0x%x is beyond label data (len = %" PRIx64").\n" , - offset + length, nvdimm->label_size); + offset + length, nvdimm->lsa_size);return ret; }
@@ -775,7 +775,7 @@ static void nvdimm_dsm_device(NvdimmDsmIn *in, hwaddr dsm_mem_addr)if (!in->function) {uint32_t supported_func =0 ; -if (nvdimm && nvdimm->label_size) { +if (nvdimm && nvdimm->lsa_size) { supported_func |=0x1 /* Bit 0 indicates whether there is support for any functions other than function 0. */ |
@@ -796,19 +796,19 @@ static void nvdimm_dsm_device(NvdimmDsmIn *in, hwaddr dsm_mem_addr)/* Encode DSM function according to DSM Spec Rev1. */ switch (in->function) {case 4 /* Get Namespace Label Size */ : -if (nvdimm->label_size) { +if (nvdimm->lsa_size) {nvdimm_dsm_label_size (nvdimm, dsm_mem_addr);return ; }break ;case 5 /* Get Namespace Label Data */ : -if (nvdimm->label_size) { +if (nvdimm->lsa_size) {nvdimm_dsm_get_label_data (nvdimm, in, dsm_mem_addr);return ; }break ;case 0x6 /* Set Namespace Label Data */ : -if (nvdimm->label_size) { +if (nvdimm->lsa_size) {nvdimm_dsm_set_label_data (nvdimm, in, dsm_mem_addr);return ; }
hw/mem/nvdimm.c +11 -11
@@ -32,16 +32,16 @@#include "hw/mem/memory-device.h" #include "sysemu/hostmem.h" -static void nvdimm_get_label_size (Object *obj,Visitor *v,const char *name, +static void nvdimm_get_lsa_size (Object *obj,Visitor *v,const char *name,void *opaque,Error **errp) {NVDIMMDevice *nvdimm =NVDIMM (obj); -uint64_t value = nvdimm->label_size; +uint64_t value = nvdimm->lsa_size;visit_type_size (v, name, &value, errp); } -static void nvdimm_set_label_size (Object *obj,Visitor *v,const char *name, +static void nvdimm_set_lsa_size (Object *obj,Visitor *v,const char *name,void *opaque,Error **errp) {NVDIMMDevice *nvdimm =NVDIMM (obj);
@@ -62,7 +62,7 @@ static void nvdimm_set_label_size(Object *obj, Visitor *v, const char *name,return ; } - nvdimm->label_size = value; + nvdimm->lsa_size = value; } static void nvdimm_get_uuid(Object *obj, Visitor *v, const char *name,
@@ -99,8 +99,8 @@ static void nvdimm_set_uuid(Object *obj, Visitor *v, const char *name,static void nvdimm_init (Object *obj) { -object_property_add (obj,NVDIMM_LABEL_SIZE_PROP ,"int" , - nvdimm_get_label_size, nvdimm_set_label_size,NULL , +object_property_add (obj,NVDIMM_LSA_SIZE_PROP ,"int" , + nvdimm_get_lsa_size, nvdimm_set_lsa_size,NULL ,NULL ); object_property_add(obj, NVDIMM_UUID_PROP, "QemuUUID", nvdimm_get_uuid,
@@ -131,18 +131,18 @@ static void nvdimm_prepare_memory_region(NVDIMMDevice *nvdimm, Error **errp) align =memory_region_get_alignment (mr); size =memory_region_size (mr); - pmem_size = size - nvdimm->label_size; + pmem_size = size - nvdimm->lsa_size; nvdimm->label_data =memory_region_get_ram_ptr (mr) + pmem_size; pmem_size =QEMU_ALIGN_DOWN (pmem_size, align); -if (size <= nvdimm->label_size || !pmem_size) { +if (size <= nvdimm->lsa_size || !pmem_size) {HostMemoryBackend *hostmem = dimm->hostmem;error_setg (errp,"the size of memdev %s (0x%" PRIx64") is too " "small to contain nvdimm label (0x%" PRIx64") and " "aligned PMEM (0x%" PRIx64")" ,object_get_canonical_path_component (OBJECT (hostmem)), -memory_region_size (mr), nvdimm->label_size, align); +memory_region_size (mr), nvdimm->lsa_size, align);return ; }
@@ -209,7 +209,7 @@ static void nvdimm_unrealize(PCDIMMDevice *dimm)static void nvdimm_validate_rw_label_data (NVDIMMDevice *nvdimm,uint64_t size,uint64_t offset) { -assert ((nvdimm->label_size >= size + offset) && (offset + size > offset)); +assert ((nvdimm->lsa_size >= size + offset) && (offset + size > offset)); } static void nvdimm_read_label_data(NVDIMMDevice *nvdimm, void *buf,
@@ -238,7 +238,7 @@ static void nvdimm_write_label_data(NVDIMMDevice *nvdimm, const void *buf, } mr =host_memory_backend_get_memory (dimm->hostmem); - backend_offset =memory_region_size (mr) - nvdimm->label_size + offset; + backend_offset =memory_region_size (mr) - nvdimm->lsa_size + offset;memory_region_set_dirty (mr, backend_offset, size); }
include/hw/mem/nvdimm.h +2 -2
@@ -48,7 +48,7 @@#define TYPE_NVDIMM "nvdimm" OBJECT_DECLARE_TYPE(NVDIMMDevice, NVDIMMClass, NVDIMM) -#define NVDIMM_LABEL_SIZE_PROP "label-size" +#define NVDIMM_LSA_SIZE_PROP "lsa-size"#define NVDIMM_UUID_PROP "uuid"#define NVDIMM_UNARMED_PROP "unarmed"
@@ -62,7 +62,7 @@ struct NVDIMMDevice {* the size of label data in NVDIMM device which is presented to * guest via __DSM "Get Namespace Label Size" function. */ -uint64_t label_size; +uint64_t lsa_size;/* * the address of label data which is read by __DSM "Get Namespace
Signature · 1 line
2.31.1
cover Init vNVDIMM LSA if applicable
QEMU option "-device nvdimm,...,label-size=" designates a vNVDIMM with Label Storage Area (LSA), where stores the namespace labels and conforms to some format and rules defined by NVDIMM label protocol[1].
Recent guest Kernel, will by validating LSA to determine if the NVDIMM is label-capable. So without initialization, guest Kernel will judge it label-less, though it actually support label.
This patch set, is to init vNVDIMM's LSA, so that guest Kernel can correctly identify and use it.
[1]:
https://uefi.org/sites/default/files/resources/ACPI_Spec_6_4_Jan22.pdf,
Section 13.19.
Robert Hoo (2):
NVDIMM: rename NVDIMM::label_size to NVDIMM::lsa_size
NVDIMM: Init vNVDIMM's LSA index block if it hasn't been
docs/nvdimm.txt | 4 +- hw/acpi/nvdimm.c | 14 +- hw/mem/nvdimm.c | 381 ++++++++++++++++++++++++++++++++++++++-- include/hw/mem/nvdimm.h | 108 +++++++++++- 4 files changed, 485 insertions(+), 22 deletions(-)
base-commit: 27fc9f365d6f60ff86c2e2be57289bb47a2be882
Signature · 1 line
2.31.1
PATCH 2/2 NVDIMM: Init vNVDIMM's LSA index block if it hasn't been
Since v2.7, QEMU has supported the emulation of NVDIMM's labels. With -device nvdimm,...,lsa-size=, the vNVDIMM to guest has this capability. But if the emulated LSA area isn't initialized, guest Kernel can't enumerate it correctly.
This patch is to initialize/format the vNVDIMM's LSA, if it has been designated the Label capability. The index block format will be v1.1 initially, in order to obtain maximum compatibility. VM user can later ndctl init-label to make it v1.2 if necessary. [1]
[1] https://uefi.org/sites/default/files/resources/ACPI_Spec_6_4_Jan22.pdf,
Initial Label Storage Area Configuration:
"for Label Storage Areas of 128KB and 256KB, the corresponding Index Block size is 256 or 512 bytes."
In driver and ndctl code, they refer to these 2 cases as v1.1 and v1.2.
---
Note: most functions in this patch are ported from ndctl and nvdimm driver code.
--- hw/mem/nvdimm.c | 359 ++++++++++++++++++++++++++++++++++++++++ include/hw/mem/nvdimm.h | 104 ++++++++++++ 2 files changed, 463 insertions(+)
hw/mem/nvdimm.c +359 -0
@@ -25,6 +25,9 @@#include "qemu/osdep.h" #include "qemu/module.h" #include "qemu/pmem.h" +#include "qemu/cutils.h" +#include "qemu/bswap.h" +#include "qemu/error-report.h" #include "qapi/error.h" #include "qapi/visitor.h" #include "hw/mem/nvdimm.h"
@@ -178,6 +181,348 @@ static MemoryRegion *nvdimm_md_get_memory_region(MemoryDeviceState *md,return nvdimm->nvdimm_mr; } +static const char NSINDEX_SIGNATURE [] ="NAMESPACE_INDEX\0" ; + +static unsigned inc_seq (unsigned seq) +{ +static const unsigned next[] = {0 ,2 ,3 ,1 }; + +return next[seq &3 ]; +} + +static u32 best_seq (u32 a,u32 b) +{ + a &=NSINDEX_SEQ_MASK ; + b &=NSINDEX_SEQ_MASK ; + +if (a ==0 || a == b) { +return b; + }else if (b ==0 ) { +return a; + }else if (inc_seq (a) == b) { +return b; + }else { +return a; + } +} + +static size_t __sizeof_namespace_index (u32 nslot) +{ +return ALIGN (sizeof (struct namespace_index ) +DIV_ROUND_UP (nslot,8 ), +NSINDEX_ALIGN ); +} + +static unsigned sizeof_namespace_label (struct NVDIMMDevice *nvdimm) +{ +if (nvdimm->label_size ==0 ) { +warn_report ("NVDIMM label size is 0, default it to 128." ); + nvdimm->label_size =128 ; + } +return nvdimm->label_size; +} + +static int __nvdimm_num_label_slots (struct NVDIMMDevice *nvdimm, +size_t index_size) +{ +return (nvdimm->lsa_size - index_size *2 ) / +sizeof_namespace_label (nvdimm); +} + +static int nvdimm_num_label_slots (struct NVDIMMDevice *nvdimm) +{ +u32 tmp_nslot, n; + + tmp_nslot = nvdimm->lsa_size / nvdimm->label_size; + n =__sizeof_namespace_index (tmp_nslot) /NSINDEX_ALIGN ; + +return __nvdimm_num_label_slots (nvdimm,NSINDEX_ALIGN * n); +} + +static unsigned int sizeof_namespace_index (struct NVDIMMDevice *nvdimm) +{ +u32 nslot, space, size; + +/* +* Per UEFI 2.7, the minimum size of the Label Storage Area is +* large enough to hold 2 index blocks and 2 labels. The +* minimum index block size is 256 bytes, and the minimum label +* size is 256 bytes. +*/ + nslot =nvdimm_num_label_slots (nvdimm); + space = nvdimm->lsa_size - nslot *sizeof_namespace_label (nvdimm); + size =__sizeof_namespace_index (nslot) *2 ; +if (size <= space && nslot >=2 ) { +return size /2 ; + } + +error_report ("label area (%ld) too small to host (%d byte) labels" , + nvdimm->lsa_size,sizeof_namespace_label (nvdimm)); +return 0 ; +} + +static struct namespace_index *to_namespace_index (struct NVDIMMDevice *nvdimm, +int i) +{ +if (i <0 ) { +return NULL ; + } + +return nvdimm->label_data +sizeof_namespace_index (nvdimm) * i; +} + +/* Validate NVDIMM index blocks. Generally refer to driver and ndctl code */ +static int __nvdimm_label_validate (struct NVDIMMDevice *nvdimm) +{ +/* +* On media label format consists of two index blocks followed +* by an array of labels. None of these structures are ever +* updated in place. A sequence number tracks the current +* active index and the next one to write, while labels are +* written to free slots. +* +* +------------+ +* | | +* | nsindex0 | +* | | +* +------------+ +* | | +* | nsindex1 | +* | | +* +------------+ +* | label0 | +* +------------+ +* | label1 | +* +------------+ +* | | +* ....nslot... +* | | +* +------------+ +* | labelN | +* +------------+ +*/ +struct namespace_index *nsindex[] = { +to_namespace_index (nvdimm,0 ), +to_namespace_index (nvdimm,1 ), + }; +const int num_index =ARRAY_SIZE (nsindex); +bool valid[2 ] = {0 }; +int i, num_valid =0 ; +u32 seq; + +for (i =0 ; i < num_index; i++) { +u32 nslot; +u8 sig[NSINDEX_SIG_LEN ]; +u64 sum_save, sum, size; +unsigned int version, labelsize; + +memcpy (sig, nsindex[i]->sig,NSINDEX_SIG_LEN ); +if (memcmp (sig,NSINDEX_SIGNATURE ,NSINDEX_SIG_LEN ) !=0 ) { +nvdimm_debug ("nsindex%d signature invalid\n" , i); +continue ; + } + +/* label sizes larger than 128 arrived with v1.2 */ + version =le16_to_cpu (nsindex[i]->major) *100 + +le16_to_cpu (nsindex[i]->minor); +if (version >=102 ) { + labelsize =1 << (7 + nsindex[i]->labelsize); + }else { + labelsize =128 ; + } + +if (labelsize !=sizeof_namespace_label (nvdimm)) { +nvdimm_debug ("nsindex%d labelsize %d invalid\n" , + i, nsindex[i]->labelsize); +continue ; + } + + sum_save =le64_to_cpu (nsindex[i]->checksum); + nsindex[i]->checksum =cpu_to_le64 (0 ); + sum =fletcher64 (nsindex[i],sizeof_namespace_index (nvdimm),1 ); + nsindex[i]->checksum =cpu_to_le64 (sum_save); +if (sum != sum_save) { +nvdimm_debug ("nsindex%d checksum invalid\n" , i); +continue ; + } + + seq =le32_to_cpu (nsindex[i]->seq); +if ((seq &NSINDEX_SEQ_MASK ) ==0 ) { +nvdimm_debug ("nsindex%d sequence: 0x%x invalid\n" , i, seq); +continue ; + } + +/* sanity check the index against expected values */ +if (le64_to_cpu (nsindex[i]->myoff) != + i *sizeof_namespace_index (nvdimm)) { +nvdimm_debug ("nsindex%d myoff: 0x%llx invalid\n" , + i, (unsigned long long ) +le64_to_cpu (nsindex[i]->myoff)); +continue ; + } +if (le64_to_cpu (nsindex[i]->otheroff) + != (!i) *sizeof_namespace_index (nvdimm)) { +nvdimm_debug ("nsindex%d otheroff: 0x%llx invalid\n" , + i, (unsigned long long ) +le64_to_cpu (nsindex[i]->otheroff)); +continue ; + } + + size =le64_to_cpu (nsindex[i]->mysize); +if (size >sizeof_namespace_index (nvdimm) || + size <sizeof (struct namespace_index )) { +nvdimm_debug ("nsindex%d mysize: 0x%zx invalid\n" , i, size); +continue ; + } + + nslot =le32_to_cpu (nsindex[i]->nslot); +if (nslot *sizeof_namespace_label (nvdimm) + +2 *sizeof_namespace_index (nvdimm) > nvdimm->lsa_size) { +nvdimm_debug ("nsindex%d nslot: %u invalid, config_size: 0x%zx\n" , + i, nslot, nvdimm->lsa_size); +continue ; + } + valid[i] = true; + num_valid++; + } + +switch (num_valid) { +case 0 : +break ; +case 1 : +for (i =0 ; i < num_index; i++) +if (valid[i]) { +return i; + } +/* can't have num_valid > 0 but valid[] = { false, false } */ +error_report ("unexpected index-block parse error" ); +break ; +default : +/* pick the best index... */ + seq =best_seq (le32_to_cpu (nsindex[0 ]->seq), +le32_to_cpu (nsindex[1 ]->seq)); +if (seq == (le32_to_cpu (nsindex[1 ]->seq) &NSINDEX_SEQ_MASK )) { +return 1 ; + }else { +return 0 ; + } +break ; + } + +return -1 ; +} + +static int nvdimm_label_validate (struct NVDIMMDevice *nvdimm) +{ +int label_size[] = {128 ,256 }; +int i, rc; + +for (i =0 ; i <ARRAY_SIZE (label_size); i++) { + nvdimm->label_size = label_size[i]; + rc =__nvdimm_label_validate (nvdimm); +if (rc >=0 ) { +return rc; + } + } + +return -1 ; +} + +static int label_next_nsindex (int index) +{ +if (index <0 ) { +return -1 ; + } + +return (index +1 ) %2 ; +} + +static void *label_base (struct NVDIMMDevice *nvdimm) +{ +void *base =to_namespace_index (nvdimm,0 ); + +return base +2 *sizeof_namespace_index (nvdimm); +} + +static int write_label_index (struct NVDIMMDevice *nvdimm, +enum ndctl_namespace_version ver,unsigned index,unsigned seq) +{ +struct namespace_index *nsindex; +unsigned long offset; +u64 checksum; +u32 nslot; + +/* +* We may have initialized ndd to whatever labelsize is +* currently on the dimm during label_validate(), so we reset it +* to the desired version here. +*/ +switch (ver) { +case NDCTL_NS_VERSION_1_1 : + nvdimm->label_size =128 ; +break ; +case NDCTL_NS_VERSION_1_2 : + nvdimm->label_size =256 ; +break ; +default : +return -1 ; + } + + nsindex =to_namespace_index (nvdimm, index); + nslot =nvdimm_num_label_slots (nvdimm); + +memcpy (nsindex->sig,NSINDEX_SIGNATURE ,NSINDEX_SIG_LEN ); +memset (nsindex->flags,0 ,3 ); + nsindex->labelsize =sizeof_namespace_label (nvdimm) >>8 ; + nsindex->seq =cpu_to_le32 (seq); + offset = (unsigned long ) nsindex + - (unsigned long )to_namespace_index (nvdimm,0 ); + nsindex->myoff =cpu_to_le64 (offset); + nsindex->mysize =cpu_to_le64 (sizeof_namespace_index (nvdimm)); + offset = (unsigned long )to_namespace_index (nvdimm, +label_next_nsindex (index)) + - (unsigned long )to_namespace_index (nvdimm,0 ); + nsindex->otheroff =cpu_to_le64 (offset); + offset = (unsigned long )label_base (nvdimm) + - (unsigned long )to_namespace_index (nvdimm,0 ); + nsindex->labeloff =cpu_to_le64 (offset); + nsindex->nslot =cpu_to_le32 (nslot); + nsindex->major =cpu_to_le16 (1 ); +if (sizeof_namespace_label (nvdimm) <256 ) { + nsindex->minor =cpu_to_le16 (1 ); + }else { + nsindex->minor =cpu_to_le16 (2 ); + } + nsindex->checksum =cpu_to_le64 (0 ); +/* init label bitmap */ +memset (nsindex->free,0xff ,ALIGN (nslot,BITS_PER_LONG ) /8 ); + checksum =fletcher64 (nsindex,sizeof_namespace_index (nvdimm),1 ); + nsindex->checksum =cpu_to_le64 (checksum); + +return 0 ; +} + +static int nvdimm_init_label (struct NVDIMMDevice *nvdimm) +{ +int i; + +for (i =0 ; i <2 ; i++) { +int rc; + +/* To have most compatibility, we init index block with v1.1 */ + rc =write_label_index (nvdimm,NDCTL_NS_VERSION_1_1 , i,3 - i); + +if (rc <0 ) { +error_report ("init No.%d index block failed" , i); +return rc; + }else { +nvdimm_debug ("%s: dump No.%d index block\n" , __func__, i); +dump_index_block (to_namespace_index (nvdimm, i)); + } + } + +return 0 ; +} +static void nvdimm_realize (PCDIMMDevice *dimm,Error **errp) {NVDIMMDevice *nvdimm =NVDIMM (dimm);
@@ -187,6 +532,20 @@ static void nvdimm_realize(PCDIMMDevice *dimm, Error **errp)nvdimm_prepare_memory_region (nvdimm, errp); } +/* When LSA is designaged, validate it. */ +if (nvdimm->lsa_size !=0 ) { +if (buffer_is_zero (nvdimm->label_data, nvdimm->lsa_size) || +nvdimm_label_validate (nvdimm) <0 ) { +int rc; + +info_report ("NVDIMM LSA is invalid, needs to be initialized" ); + rc =nvdimm_init_label (nvdimm); +if (rc <0 ) { +error_report ("NVDIMM lsa init failed, rc = %d" , rc); + } + } + } +if (ndc->realize) { ndc->realize (nvdimm, errp); }
include/hw/mem/nvdimm.h +104 -0
124 lines not on this page · raw message
Signature · 1 line
2.31.1
Re: [PATCH 2/2] NVDIMM: Init vNVDIMM's LSA index block if it hasn't been
Quoted 9 lines · On Tue, 29 Mar 2022 15:07:43 +0800 Robert Hoo <[email protected]> wrote:
Since v2.7, QEMU has supported the emulation of NVDIMM's labels. With -device nvdimm,...,lsa-size=, the vNVDIMM to guest has this capability. But if the emulated LSA area isn't initialized, guest Kernel can't enumerate it correctly.
This patch is to initialize/format the vNVDIMM's LSA, if it has been designated the Label capability. The index block format will be v1.1 initially, in order to obtain maximum compatibility. VM user can later
ndctl init-labelto make it v1.2 if necessary. [1]
Can user initialize/format LSA from guest using ndctl/some other tool?
Quoted 4 lines
[1] https://uefi.org/sites/default/files/resources/ACPI_Spec_6_4_Jan22.pdf,
Initial Label Storage Area Configuration:
"for Label Storage Areas of 128KB and 256KB, the corresponding Index Block size is 256 or 512 bytes."
Quick search in above spec says such text doesn't exists.
above needs grep-able reference + chapter "x.x name" so one could easily find it.
Quoted 526 lines
In driver and ndctl code, they refer to these 2 cases as v1.1 and v1.2.
Signed-off-by Robert Hoo <[email protected]>Reviewed-by Liu, Jingqi <[email protected]>---
Note: most functions in this patch are ported from ndctl and nvdimm driver code.--- hw/mem/nvdimm.c | 359 ++++++++++++++++++++++++++++++++++++++++ include/hw/mem/nvdimm.h | 104 ++++++++++++ 2 files changed, 463 insertions(+)hw/mem/nvdimm.c +359
-0@@ -25,6 +25,9 @@#include "qemu/osdep.h" #include "qemu/module.h" #include "qemu/pmem.h" +#include "qemu/cutils.h" +#include "qemu/bswap.h" +#include "qemu/error-report.h" #include "qapi/error.h" #include "qapi/visitor.h" #include "hw/mem/nvdimm.h" @@ -178,6 +181,348 @@ static MemoryRegion *nvdimm_md_get_memory_region(MemoryDeviceState *md,return nvdimm->nvdimm_mr; } +static const char NSINDEX_SIGNATURE [] ="NAMESPACE_INDEX\0" ; + +static unsigned inc_seq (unsigned seq) +{ +static const unsigned next[] = {0 ,2 ,3 ,1 }; + +return next[seq &3 ]; +} + +static u32 best_seq (u32 a,u32 b) +{ + a &=NSINDEX_SEQ_MASK ; + b &=NSINDEX_SEQ_MASK ; + +if (a ==0 || a == b) { +return b; + }else if (b ==0 ) { +return a; + }else if (inc_seq (a) == b) { +return b; + }else { +return a; + } +} + +static size_t __sizeof_namespace_index (u32 nslot) +{ +return ALIGN (sizeof (struct namespace_index ) +DIV_ROUND_UP (nslot,8 ), +NSINDEX_ALIGN ); +} + +static unsigned sizeof_namespace_label (struct NVDIMMDevice *nvdimm) +{ +if (nvdimm->label_size ==0 ) { +warn_report ("NVDIMM label size is 0, default it to 128." ); + nvdimm->label_size =128 ; + } +return nvdimm->label_size; +} + +static int __nvdimm_num_label_slots (struct NVDIMMDevice *nvdimm, +size_t index_size) +{ +return (nvdimm->lsa_size - index_size *2 ) / +sizeof_namespace_label (nvdimm); +} + +static int nvdimm_num_label_slots (struct NVDIMMDevice *nvdimm) +{ +u32 tmp_nslot, n; + + tmp_nslot = nvdimm->lsa_size / nvdimm->label_size; + n =__sizeof_namespace_index (tmp_nslot) /NSINDEX_ALIGN ; + +return __nvdimm_num_label_slots (nvdimm,NSINDEX_ALIGN * n); +} + +static unsigned int sizeof_namespace_index (struct NVDIMMDevice *nvdimm) +{ +u32 nslot, space, size; + +/* +* Per UEFI 2.7, the minimum size of the Label Storage Area is +* large enough to hold 2 index blocks and 2 labels. The +* minimum index block size is 256 bytes, and the minimum label +* size is 256 bytes. +*/ + nslot =nvdimm_num_label_slots (nvdimm); + space = nvdimm->lsa_size - nslot *sizeof_namespace_label (nvdimm); + size =__sizeof_namespace_index (nslot) *2 ; +if (size <= space && nslot >=2 ) { +return size /2 ; + } + +error_report ("label area (%ld) too small to host (%d byte) labels" , + nvdimm->lsa_size,sizeof_namespace_label (nvdimm)); +return 0 ; +} + +static struct namespace_index *to_namespace_index (struct NVDIMMDevice *nvdimm, +int i) +{ +if (i <0 ) { +return NULL ; + } + +return nvdimm->label_data +sizeof_namespace_index (nvdimm) * i; +} + +/* Validate NVDIMM index blocks. Generally refer to driver and ndctl code */ +static int __nvdimm_label_validate (struct NVDIMMDevice *nvdimm) +{ +/* +* On media label format consists of two index blocks followed +* by an array of labels. None of these structures are ever +* updated in place. A sequence number tracks the current +* active index and the next one to write, while labels are +* written to free slots. +* +* +------------+ +* | | +* | nsindex0 | +* | | +* +------------+ +* | | +* | nsindex1 | +* | | +* +------------+ +* | label0 | +* +------------+ +* | label1 | +* +------------+ +* | | +* ....nslot... +* | | +* +------------+ +* | labelN | +* +------------+ +*/ +struct namespace_index *nsindex[] = { +to_namespace_index (nvdimm,0 ), +to_namespace_index (nvdimm,1 ), + }; +const int num_index =ARRAY_SIZE (nsindex); +bool valid[2 ] = {0 }; +int i, num_valid =0 ; +u32 seq; + +for (i =0 ; i < num_index; i++) { +u32 nslot; +u8 sig[NSINDEX_SIG_LEN ]; +u64 sum_save, sum, size; +unsigned int version, labelsize; + +memcpy (sig, nsindex[i]->sig,NSINDEX_SIG_LEN ); +if (memcmp (sig,NSINDEX_SIGNATURE ,NSINDEX_SIG_LEN ) !=0 ) { +nvdimm_debug ("nsindex%d signature invalid\n" , i); +continue ; + } + +/* label sizes larger than 128 arrived with v1.2 */ + version =le16_to_cpu (nsindex[i]->major) *100 + +le16_to_cpu (nsindex[i]->minor); +if (version >=102 ) { + labelsize =1 << (7 + nsindex[i]->labelsize); + }else { + labelsize =128 ; + } + +if (labelsize !=sizeof_namespace_label (nvdimm)) { +nvdimm_debug ("nsindex%d labelsize %d invalid\n" , + i, nsindex[i]->labelsize); +continue ; + } + + sum_save =le64_to_cpu (nsindex[i]->checksum); + nsindex[i]->checksum =cpu_to_le64 (0 ); + sum =fletcher64 (nsindex[i],sizeof_namespace_index (nvdimm),1 ); + nsindex[i]->checksum =cpu_to_le64 (sum_save); +if (sum != sum_save) { +nvdimm_debug ("nsindex%d checksum invalid\n" , i); +continue ; + } + + seq =le32_to_cpu (nsindex[i]->seq); +if ((seq &NSINDEX_SEQ_MASK ) ==0 ) { +nvdimm_debug ("nsindex%d sequence: 0x%x invalid\n" , i, seq); +continue ; + } + +/* sanity check the index against expected values */ +if (le64_to_cpu (nsindex[i]->myoff) != + i *sizeof_namespace_index (nvdimm)) { +nvdimm_debug ("nsindex%d myoff: 0x%llx invalid\n" , + i, (unsigned long long ) +le64_to_cpu (nsindex[i]->myoff)); +continue ; + } +if (le64_to_cpu (nsindex[i]->otheroff) + != (!i) *sizeof_namespace_index (nvdimm)) { +nvdimm_debug ("nsindex%d otheroff: 0x%llx invalid\n" , + i, (unsigned long long ) +le64_to_cpu (nsindex[i]->otheroff)); +continue ; + } + + size =le64_to_cpu (nsindex[i]->mysize); +if (size >sizeof_namespace_index (nvdimm) || + size <sizeof (struct namespace_index )) { +nvdimm_debug ("nsindex%d mysize: 0x%zx invalid\n" , i, size); +continue ; + } + + nslot =le32_to_cpu (nsindex[i]->nslot); +if (nslot *sizeof_namespace_label (nvdimm) + +2 *sizeof_namespace_index (nvdimm) > nvdimm->lsa_size) { +nvdimm_debug ("nsindex%d nslot: %u invalid, config_size: 0x%zx\n" , + i, nslot, nvdimm->lsa_size); +continue ; + } + valid[i] = true; + num_valid++; + } + +switch (num_valid) { +case 0 : +break ; +case 1 : +for (i =0 ; i < num_index; i++) +if (valid[i]) { +return i; + } +/* can't have num_valid > 0 but valid[] = { false, false } */ +error_report ("unexpected index-block parse error" ); +break ; +default : +/* pick the best index... */ + seq =best_seq (le32_to_cpu (nsindex[0 ]->seq), +le32_to_cpu (nsindex[1 ]->seq)); +if (seq == (le32_to_cpu (nsindex[1 ]->seq) &NSINDEX_SEQ_MASK )) { +return 1 ; + }else { +return 0 ; + } +break ; + } + +return -1 ; +} + +static int nvdimm_label_validate (struct NVDIMMDevice *nvdimm) +{ +int label_size[] = {128 ,256 }; +int i, rc; + +for (i =0 ; i <ARRAY_SIZE (label_size); i++) { + nvdimm->label_size = label_size[i]; + rc =__nvdimm_label_validate (nvdimm); +if (rc >=0 ) { +return rc; + } + } + +return -1 ; +} + +static int label_next_nsindex (int index) +{ +if (index <0 ) { +return -1 ; + } + +return (index +1 ) %2 ; +} + +static void *label_base (struct NVDIMMDevice *nvdimm) +{ +void *base =to_namespace_index (nvdimm,0 ); + +return base +2 *sizeof_namespace_index (nvdimm); +} + +static int write_label_index (struct NVDIMMDevice *nvdimm, +enum ndctl_namespace_version ver,unsigned index,unsigned seq) +{ +struct namespace_index *nsindex; +unsigned long offset; +u64 checksum; +u32 nslot; + +/* +* We may have initialized ndd to whatever labelsize is +* currently on the dimm during label_validate(), so we reset it +* to the desired version here. +*/ +switch (ver) { +case NDCTL_NS_VERSION_1_1 : + nvdimm->label_size =128 ; +break ; +case NDCTL_NS_VERSION_1_2 : + nvdimm->label_size =256 ; +break ; +default : +return -1 ; + } + + nsindex =to_namespace_index (nvdimm, index); + nslot =nvdimm_num_label_slots (nvdimm); + +memcpy (nsindex->sig,NSINDEX_SIGNATURE ,NSINDEX_SIG_LEN ); +memset (nsindex->flags,0 ,3 ); + nsindex->labelsize =sizeof_namespace_label (nvdimm) >>8 ; + nsindex->seq =cpu_to_le32 (seq); + offset = (unsigned long ) nsindex + - (unsigned long )to_namespace_index (nvdimm,0 ); + nsindex->myoff =cpu_to_le64 (offset); + nsindex->mysize =cpu_to_le64 (sizeof_namespace_index (nvdimm)); + offset = (unsigned long )to_namespace_index (nvdimm, +label_next_nsindex (index)) + - (unsigned long )to_namespace_index (nvdimm,0 ); + nsindex->otheroff =cpu_to_le64 (offset); + offset = (unsigned long )label_base (nvdimm) + - (unsigned long )to_namespace_index (nvdimm,0 ); + nsindex->labeloff =cpu_to_le64 (offset); + nsindex->nslot =cpu_to_le32 (nslot); + nsindex->major =cpu_to_le16 (1 ); +if (sizeof_namespace_label (nvdimm) <256 ) { + nsindex->minor =cpu_to_le16 (1 ); + }else { + nsindex->minor =cpu_to_le16 (2 ); + } + nsindex->checksum =cpu_to_le64 (0 ); +/* init label bitmap */ +memset (nsindex->free,0xff ,ALIGN (nslot,BITS_PER_LONG ) /8 ); + checksum =fletcher64 (nsindex,sizeof_namespace_index (nvdimm),1 ); + nsindex->checksum =cpu_to_le64 (checksum); + +return 0 ; +} + +static int nvdimm_init_label (struct NVDIMMDevice *nvdimm) +{ +int i; + +for (i =0 ; i <2 ; i++) { +int rc; + +/* To have most compatibility, we init index block with v1.1 */ + rc =write_label_index (nvdimm,NDCTL_NS_VERSION_1_1 , i,3 - i); + +if (rc <0 ) { +error_report ("init No.%d index block failed" , i); +return rc; + }else { +nvdimm_debug ("%s: dump No.%d index block\n" , __func__, i); +dump_index_block (to_namespace_index (nvdimm, i)); + } + } + +return 0 ; +} +static void nvdimm_realize (PCDIMMDevice *dimm,Error **errp) {NVDIMMDevice *nvdimm =NVDIMM (dimm);@@ -187,6 +532,20 @@ static void nvdimm_realize(PCDIMMDevice *dimm, Error **errp)nvdimm_prepare_memory_region (nvdimm, errp); } +/* When LSA is designaged, validate it. */ +if (nvdimm->lsa_size !=0 ) { +if (buffer_is_zero (nvdimm->label_data, nvdimm->lsa_size) || +nvdimm_label_validate (nvdimm) <0 ) { +int rc; + +info_report ("NVDIMM LSA is invalid, needs to be initialized" ); + rc =nvdimm_init_label (nvdimm); +if (rc <0 ) { +error_report ("NVDIMM lsa init failed, rc = %d" , rc); + } + } + } +if (ndc->realize) { ndc->realize (nvdimm, errp); }include/hw/mem/nvdimm.h +104
-0@@ -48,14 +48,76 @@#define TYPE_NVDIMM "nvdimm" OBJECT_DECLARE_TYPE(NVDIMMDevice, NVDIMMClass, NVDIMM) +typedef uint32_t u32 ; +typedef uint64_t u64 ; +typedef uint8_t u8 ; +typedef uint32_t u32 ; + +#define ALIGN (x, y) (((x) + (y) - 1) & ~((y) - 1)) +#define NVDIMM_LSA_SIZE_PROP "lsa-size"#define NVDIMM_UUID_PROP "uuid"#define NVDIMM_UNARMED_PROP "unarmed" +enum ndctl_namespace_version { +NDCTL_NS_VERSION_1_1 , +NDCTL_NS_VERSION_1_2 , +}; + +enum { +NSINDEX_SIG_LEN =16 , +NSINDEX_ALIGN =256 , +NSINDEX_SEQ_MASK =0x3 , +NSLABEL_UUID_LEN =16 , +NSLABEL_NAME_LEN =64 , +}; + +/** +* struct namespace_index - label set superblock +* @sig: NAMESPACE_INDEX\0 +* @flags: placeholder +* @labelsize: log2 size (v1 labels 128 bytes v2 labels 256 bytes) +* @seq: sequence number for this index +* @myoff: offset of this index in label area +* @mysize: size of this index struct +* @otheroff: offset of other index +* @labeloff: offset of first label slot +* @nslot: total number of label slots +* @major: label area major version +* @minor: label area minor version +* @checksum: fletcher64 of all fields +* @free: bitmap, nlabel bits +* +* The size of free[] is rounded up so the total struct size is a +* multiple of NSINDEX_ALIGN bytes. Any bits this allocates beyond +* nlabel bits must be zero. +*/ +struct namespace_index { +uint8_t sig[NSINDEX_SIG_LEN ]; +uint8_t flags[3 ]; +uint8_t labelsize; +uint32_t seq; +uint64_t myoff; +uint64_t mysize; +uint64_t otheroff; +uint64_t labeloff; +uint32_t nslot; +uint16_t major; +uint16_t minor; +uint64_t checksum; +uint8_t free[0 ]; +}; +struct NVDIMMDevice {/* private */ PCDIMMDevice parent_obj; +/* +* Label's size in LSA. Determined by Label version. 128 for v1.1, 256 +* for v1.2 +*/ +unsigned int label_size; +/* public */ /* @@ -150,6 +212,48 @@ struct NVDIMMState { };typedef struct NVDIMMState NVDIMMState ; +#if (NVDIMM_DEBUG ==1 ) +static inline void dump_index_block (struct namespace_index *nsindex) +{ +printf ("sig %s\n" , nsindex->sig); +printf ("flags 0x%x 0x%x 0x%x\n" , nsindex->flags[0 ], + nsindex->flags[1 ], nsindex->flags[2 ]); +printf ("labelsize %d\n" , nsindex->labelsize); +printf ("seq 0x%0x\n" , nsindex->seq); +printf ("myoff 0x%" PRIx64"\n" , nsindex->myoff); +printf ("mysize 0x%" PRIx64"\n" , nsindex->mysize); +printf ("otheroff 0x%" PRIx64"\n" , nsindex->otheroff); +printf ("labeloff 0x%" PRIx64"\n" , nsindex->labeloff); +printf ("nslot %d\n" , nsindex->nslot); +printf ("major %d\n" , nsindex->major); +printf ("minor %d\n" , nsindex->minor); +printf ("checksum 0x%" PRIx64"\n" , nsindex->checksum); +printf ("-------------------------------\n" ); +} +#else +static inline void dump_index_block (struct namespace_index *nsindex) +{ +} +#endif + +/* +* Note, fletcher64() is copied from drivers/nvdimm/label.c in the Linux kernel +*/ +static inline u64 fletcher64 (void *addr,size_t len,bool le) +{ +u32 *buf = addr; +u32 lo32 =0 ; +u64 hi32 =0 ; +size_t i; + +for (i =0 ; i < len /sizeof (u32); i++) { + lo32 += le ?le32_to_cpu ((u32 ) buf[i]) : buf[i]; + hi32 += lo32; + } + +return hi32 <<32 | lo32; +} +void nvdimm_init_acpi_state (NVDIMMState *state,MemoryRegion *io,struct AcpiGenericAddress dsm_io,FWCfgState *fw_cfg,Object *owner);
Quoted 8 lines · On Tue, 29 Mar 2022 15:07:41 +0800 Robert Hoo <[email protected]> wrote:
QEMU option "-device nvdimm,...,label-size=" designates a vNVDIMM with Label Storage Area (LSA), where stores the namespace labels and conforms to some format and rules defined by NVDIMM label protocol[1].
Recent guest Kernel, will by validating LSA to determine if the NVDIMM is label-capable. So without initialization, guest Kernel will judge it label-less, though it actually support label.
Quoted 7 lines
This patch set, is to init vNVDIMM's LSA, so that guest Kernel can correctly identify and use it.
[1]:
https://uefi.org/sites/default/files/resources/ACPI_Spec_6_4_Jan22.pdf,
Section 13.19.
perhaps there is a typo here,
In above spec, chapter 13 is "ACPI SYSTEM MANAGEMENT BUS INTERFACE SPECIFICATION" and there is only 13.1-13.3 there.
Quoted 13 lines
Robert Hoo (2):
NVDIMM: renameNVDIMM::label_sizetoNVDIMM::lsa_size
NVDIMM: Init vNVDIMM's LSA index block if it hasn't beendocs/nvdimm.txt | 4 +- hw/acpi/nvdimm.c | 14 +- hw/mem/nvdimm.c | 381 ++++++++++++++++++++++++++++++++++++++-- include/hw/mem/nvdimm.h | 108 +++++++++++- 4 files changed, 485 insertions(+), 22 deletions(-)base-commit:
27fc9f365d6f60ff86c2e2be57289bb47a2be882
Quoted 18 lines · Igor Mammedov
Quoted 15 lines · On Tue, 29 Mar 2022 15:07:41 +0800 Robert Hoo <[email protected]> wrote:
QEMU option "-device nvdimm,...,label-size=" designates a vNVDIMM with
Label Storage Area (LSA), where stores the namespace labels and conforms to
some format and rules defined by NVDIMM label protocol[1].Recent guest Kernel, will by validating LSA to determine if the NVDIMM is
label-capable. So without initialization, guest Kernel will judge it
label-less, though it actually support label.This patch set, is to init vNVDIMM's LSA, so that guest Kernel can correctly identify and use it.
Quoted 8 lines
Quoted 3 lines
[1]:
https://uefi.org/sites/default/files/resources/ACPI_Spec_6_4_Jan22.pdf,
Section 13.19.perhaps there is a typo here,
In above spec, chapter 13 is "ACPI SYSTEM MANAGEMENT BUS INTERFACE SPECIFICATION"
and there is only 13.1-13.3 there.
Right, thanks Igor.
It should be UEFI spec, section 13.19 "NVDIMM Label Protocol"
https://uefi.org/sites/default/files/resources/UEFI_Spec_2_9_2021_03_18.pdf
Quoted 17 lines
Quoted 15 lines
Robert Hoo (2):
NVDIMM: renameNVDIMM::label_sizetoNVDIMM::lsa_size
NVDIMM: Init vNVDIMM's LSA index block if it hasn't beendocs/nvdimm.txt | 4 +- hw/acpi/nvdimm.c | 14 +- hw/mem/nvdimm.c | 381 ++++++++++++++++++++++++++++++++++++++-- include/hw/mem/nvdimm.h | 108 +++++++++++- 4 files changed, 485 insertions(+), 22 deletions(-)base-commit:
27fc9f365d6f60ff86c2e2be57289bb47a2be882
Re: [PATCH 2/2] NVDIMM: Init vNVDIMM's LSA index block if it hasn't been
In reply to Igor MammedovQuoted 17 lines · Igor Mammedov
Quoted 6 lines · On Tue, 29 Mar 2022 15:07:43 +0800 Robert Hoo <[email protected]> wrote:
Since v2.7, QEMU has supported the emulation of NVDIMM's labels. With -device nvdimm,...,lsa-size=, the vNVDIMM to guest has this capability. But if the emulated LSA area isn't initialized, guest Kernel
can't enumerate it correctly.Quoted 7 lines
This patch is to initialize/format the vNVDIMM's LSA, if it has been
designated the Label capability. The index block format will be v1.1
initially, in order to obtain maximum compatibility. VM user can laterndctl init-labelto make it v1.2 if necessary. [1]
Quoted 3 lines
Can user initialize/format LSA from guest using ndctl/some other tool?
Yes, he can. But when guest Kernel already told him this is a dimm without label capability, dare/should he take this dangerous action?;-)
Quoted 10 lines
Quoted 8 lines
[1]
https://uefi.org/sites/default/files/resources/ACPI_Spec_6_4_Jan22.pdf
,
Initial Label Storage Area Configuration:
"for Label Storage Areas of 128KB and 256KB, the corresponding Index
Block size is 256 or 512 bytes."Quick search in above spec says such text doesn't exists.
Sorry, my carelessness, typo with the ACPI spec link.
Quoted 4 lines
above needs grep-able reference + chapter "x.x name" so one could easily
find it.
Right, accept this.
Quoted 566 lines
Quoted 564 lines
In driver and ndctl code, they refer to these 2 cases as v1.1 and v1.2.
Signed-off-by Robert Hoo <[email protected]>Reviewed-by Liu, Jingqi <[email protected]>---
Note: most functions in this patch are ported from ndctl and nvdimm driver
code.--- hw/mem/nvdimm.c | 359 ++++++++++++++++++++++++++++++++++++++++ include/hw/mem/nvdimm.h | 104 ++++++++++++ 2 files changed, 463 insertions(+)hw/mem/nvdimm.c +61
-0@@ -25,6 +25,9 @@#include "qemu/osdep.h" #include "qemu/module.h" #include "qemu/pmem.h" +#include "qemu/cutils.h" +#include "qemu/bswap.h" +#include "qemu/error-report.h" #include "qapi/error.h" #include "qapi/visitor.h" #include "hw/mem/nvdimm.h" @@ -178,6 +181,348 @@ static MemoryRegion *nvdimm_md_get_memory_region (MemoryDeviceState *md, return nvdimm->nvdimm_mr; } +static const char NSINDEX_SIGNATURE [] ="NAMESPACE_INDEX\0" ; + +static unsigned inc_seq (unsigned seq) +{ +static const unsigned next[] = {0 ,2 ,3 ,1 }; + +return next[seq &3 ]; +} + +static u32 best_seq (u32 a,u32 b) +{ + a &=NSINDEX_SEQ_MASK ; + b &=NSINDEX_SEQ_MASK ; + +if (a ==0 || a == b) { +return b; + }else if (b ==0 ) { +return a; + }else if (inc_seq (a) == b) { +return b; + }else { +return a; + } +} + +static size_t __sizeof_namespace_index (u32 nslot) +{ +return ALIGN (sizeof (struct namespace_index ) +DIV_ROUND_UP (nslot,8 ), +NSINDEX_ALIGN ); +} + +static unsigned sizeof_namespace_label (struct NVDIMMDevice *nvdimm) +{ +if (nvdimm->label_size ==0 ) { +warn_report ("NVDIMM label size is 0, default it to 128." ); + nvdimm->label_size =128 ; + } +return nvdimm->label_size; +} + +static int __nvdimm_num_label_slots (struct NVDIMMDevice *nvdimm, +size_t index_size) +{ +return (nvdimm->lsa_size - index_size *2 ) / +sizeof_namespace_label (nvdimm); +} + +static int nvdimm_num_label_slots (struct NVDIMMDevice *nvdimm) +{ +u32 tmp_nslot, n; + + tmp_nslot = nvdimm->lsa_size / nvdimm->label_size; + n =__sizeof_namespace_index (tmp_nslot) /NSINDEX_ALIGN ; + +return __nvdimm_num_label_slots (nvdimm,NSINDEX_ALIGN * n); +} + +static unsigned int sizeof_namespace_index(struct NVDIMMDevice*nvdimm)
hw/mem/nvdimm.c +7
-0+{ +u32 nslot, space, size; + +/* +* Per UEFI 2.7, the minimum size of the Label Storage Area is +* large enough to hold 2 index blocks and 2 labels. The +* minimum index block size is 256 bytes, and the minimum label
hw/mem/nvdimm.c +4
-0+* size is 256 bytes. +*/ + nslot =nvdimm_num_label_slots (nvdimm); + space = nvdimm->lsa_size - nslot *
sizeof_namespace_label(nvdimm);hw/mem/nvdimm.c +6
-0+ size =__sizeof_namespace_index (nslot) *2 ; +if (size <= space && nslot >=2 ) { +return size /2 ; + } + + error_report("label area (%ld) too small to host (%d byte)labels",
hw/mem/nvdimm.c +5
-0+ nvdimm->lsa_size, sizeof_namespace_label(nvdimm)); +return 0 ; +} + +static struct namespace_index *to_namespace_index(structNVDIMMDevice *nvdimm,
hw/mem/nvdimm.c +7
-0+ int i) +{ +if (i <0 ) { +return NULL ; + } + + return nvdimm->label_data + sizeof_namespace_index(nvdimm) *i;
hw/mem/nvdimm.c +3
-0+} + +/* Validate NVDIMM index blocks. Generally refer to driver and ndctl code */
hw/mem/nvdimm.c +46
-0+static int __nvdimm_label_validate (struct NVDIMMDevice *nvdimm) +{ +/* +* On media label format consists of two index blocks followed +* by an array of labels. None of these structures are ever +* updated in place. A sequence number tracks the current +* active index and the next one to write, while labels are +* written to free slots. +* +* +------------+ +* | | +* | nsindex0 | +* | | +* +------------+ +* | | +* | nsindex1 | +* | | +* +------------+ +* | label0 | +* +------------+ +* | label1 | +* +------------+ +* | | +* ....nslot... +* | | +* +------------+ +* | labelN | +* +------------+ +*/ +struct namespace_index *nsindex[] = { +to_namespace_index (nvdimm,0 ), +to_namespace_index (nvdimm,1 ), + }; +const int num_index =ARRAY_SIZE (nsindex); +bool valid[2 ] = {0 }; +int i, num_valid =0 ; +u32 seq; + +for (i =0 ; i < num_index; i++) { +u32 nslot; +u8 sig[NSINDEX_SIG_LEN ]; +u64 sum_save, sum, size; +unsigned int version, labelsize; + +memcpy (sig, nsindex[i]->sig,NSINDEX_SIG_LEN ); +if (memcmp (sig,NSINDEX_SIGNATURE ,NSINDEX_SIG_LEN ) !=0 ){
hw/mem/nvdimm.c +22
-0+nvdimm_debug ("nsindex%d signature invalid\n" , i); +continue ; + } + +/* label sizes larger than 128 arrived with v1.2 */ + version =le16_to_cpu (nsindex[i]->major) *100 + +le16_to_cpu (nsindex[i]->minor); +if (version >=102 ) { + labelsize =1 << (7 + nsindex[i]->labelsize); + }else { + labelsize =128 ; + } + +if (labelsize !=sizeof_namespace_label (nvdimm)) { +nvdimm_debug ("nsindex%d labelsize %d invalid\n" , + i, nsindex[i]->labelsize); +continue ; + } + + sum_save =le64_to_cpu (nsindex[i]->checksum); + nsindex[i]->checksum =cpu_to_le64 (0 ); + sum = fletcher64(nsindex[i],
sizeof_namespace_index(nvdimm), 1);hw/mem/nvdimm.c +9
-0+ nsindex[i]->checksum =cpu_to_le64 (sum_save); +if (sum != sum_save) { +nvdimm_debug ("nsindex%d checksum invalid\n" , i); +continue ; + } + + seq =le32_to_cpu (nsindex[i]->seq); +if ((seq &NSINDEX_SEQ_MASK ) ==0 ) { + nvdimm_debug("nsindex%d sequence: 0x%x invalid\n", i,seq);
hw/mem/nvdimm.c +23
-0+continue ; + } + +/* sanity check the index against expected values */ +if (le64_to_cpu (nsindex[i]->myoff) != + i *sizeof_namespace_index (nvdimm)) { +nvdimm_debug ("nsindex%d myoff: 0x%llx invalid\n" , + i, (unsigned long long ) +le64_to_cpu (nsindex[i]->myoff)); +continue ; + } +if (le64_to_cpu (nsindex[i]->otheroff) + != (!i) *sizeof_namespace_index (nvdimm)) { +nvdimm_debug ("nsindex%d otheroff: 0x%llx invalid\n" , + i, (unsigned long long ) +le64_to_cpu (nsindex[i]->otheroff)); +continue ; + } + + size =le64_to_cpu (nsindex[i]->mysize); +if (size >sizeof_namespace_index (nvdimm) || + size <sizeof (struct namespace_index )) { + nvdimm_debug("nsindex%d mysize: 0x%zx invalid\n", i,size);
hw/mem/nvdimm.c +6
-0+continue ; + } + + nslot =le32_to_cpu (nsindex[i]->nslot); +if (nslot *sizeof_namespace_label (nvdimm) + +2 *sizeof_namespace_index (nvdimm) > nvdimm->lsa_size){
+ nvdimm_debug("nsindex%d nslot: %u invalid,config_size: 0x%zx\n",hw/mem/nvdimm.c +16
-0+ i, nslot, nvdimm->lsa_size); +continue ; + } + valid[i] = true; + num_valid++; + } + +switch (num_valid) { +case 0 : +break ; +case 1 : +for (i =0 ; i < num_index; i++) +if (valid[i]) { +return i; + } +/* can't have num_valid > 0 but valid[] = { false, false } */
hw/mem/nvdimm.c +7
-0+error_report ("unexpected index-block parse error" ); +break ; +default : +/* pick the best index... */ + seq =best_seq (le32_to_cpu (nsindex[0 ]->seq), +le32_to_cpu (nsindex[1 ]->seq)); + if (seq == (le32_to_cpu(nsindex[1]->seq) &
NSINDEX_SEQ_MASK)) {hw/mem/nvdimm.c +44
-0+return 1 ; + }else { +return 0 ; + } +break ; + } + +return -1 ; +} + +static int nvdimm_label_validate (struct NVDIMMDevice *nvdimm) +{ +int label_size[] = {128 ,256 }; +int i, rc; + +for (i =0 ; i <ARRAY_SIZE (label_size); i++) { + nvdimm->label_size = label_size[i]; + rc =__nvdimm_label_validate (nvdimm); +if (rc >=0 ) { +return rc; + } + } + +return -1 ; +} + +static int label_next_nsindex (int index) +{ +if (index <0 ) { +return -1 ; + } + +return (index +1 ) %2 ; +} + +static void *label_base (struct NVDIMMDevice *nvdimm) +{ +void *base =to_namespace_index (nvdimm,0 ); + +return base +2 *sizeof_namespace_index (nvdimm); +} + +static int write_label_index (struct NVDIMMDevice *nvdimm, + enum ndctl_namespace_version ver, unsigned index, unsignedseq)
hw/mem/nvdimm.c +9
-0+{ +struct namespace_index *nsindex; +unsigned long offset; +u64 checksum; +u32 nslot; + +/* +* We may have initialized ndd to whatever labelsize is +* currently on the dimm during label_validate(), so we reset it
hw/mem/nvdimm.c +42
-0+* to the desired version here. +*/ +switch (ver) { +case NDCTL_NS_VERSION_1_1 : + nvdimm->label_size =128 ; +break ; +case NDCTL_NS_VERSION_1_2 : + nvdimm->label_size =256 ; +break ; +default : +return -1 ; + } + + nsindex =to_namespace_index (nvdimm, index); + nslot =nvdimm_num_label_slots (nvdimm); + +memcpy (nsindex->sig,NSINDEX_SIGNATURE ,NSINDEX_SIG_LEN ); +memset (nsindex->flags,0 ,3 ); + nsindex->labelsize =sizeof_namespace_label (nvdimm) >>8 ; + nsindex->seq =cpu_to_le32 (seq); + offset = (unsigned long ) nsindex + - (unsigned long )to_namespace_index (nvdimm,0 ); + nsindex->myoff =cpu_to_le64 (offset); + nsindex->mysize =cpu_to_le64 (sizeof_namespace_index (nvdimm)); + offset = (unsigned long )to_namespace_index (nvdimm, +label_next_nsindex (index)) + - (unsigned long )to_namespace_index (nvdimm,0 ); + nsindex->otheroff =cpu_to_le64 (offset); + offset = (unsigned long )label_base (nvdimm) + - (unsigned long )to_namespace_index (nvdimm,0 ); + nsindex->labeloff =cpu_to_le64 (offset); + nsindex->nslot =cpu_to_le32 (nslot); + nsindex->major =cpu_to_le16 (1 ); +if (sizeof_namespace_label (nvdimm) <256 ) { + nsindex->minor =cpu_to_le16 (1 ); + }else { + nsindex->minor =cpu_to_le16 (2 ); + } + nsindex->checksum =cpu_to_le64 (0 ); +/* init label bitmap */ +memset (nsindex->free,0xff ,ALIGN (nslot,BITS_PER_LONG ) /8 ); + checksum = fletcher64(nsindex, sizeof_namespace_index(nvdimm),1);
hw/mem/nvdimm.c +13
-0+ nsindex->checksum =cpu_to_le64 (checksum); + +return 0 ; +} + +static int nvdimm_init_label (struct NVDIMMDevice *nvdimm) +{ +int i; + +for (i =0 ; i <2 ; i++) { +int rc; + +/* To have most compatibility, we init index block with v1.1 */
hw/mem/nvdimm.c +7
-1+ rc = write_label_index(nvdimm, NDCTL_NS_VERSION_1_1, i, 3 - i); + + if (rc < 0) { + error_report("init No.%d index block failed", i); + return rc; + } else { + nvdimm_debug("%s: dump No.%d index block\n", __func__,i);
hw/mem/nvdimm.c +10
-0+dump_index_block (to_namespace_index (nvdimm, i)); + } + } + +return 0 ; +} +static void nvdimm_realize (PCDIMMDevice *dimm,Error **errp) {NVDIMMDevice *nvdimm =NVDIMM (dimm);@@ -187,6 +532,20 @@ static void nvdimm_realize(PCDIMMDevice *dimm, Error **errp)nvdimm_prepare_memory_region (nvdimm ,errp ); } +/* When LSA is designaged, validate it. */ +if (nvdimm->lsa_size !=0 ) { + if (buffer_is_zero(nvdimm->label_data, nvdimm->lsa_size)||
hw/mem/nvdimm.c +4
-0+ nvdimm_label_validate(nvdimm) < 0) { +int rc; + + info_report("NVDIMM LSA is invalid, needs to beinitialized");
hw/mem/nvdimm.c +3
-0+ rc =nvdimm_init_label (nvdimm); +if (rc <0 ) { + error_report("NVDIMM lsa init failed, rc = %d",rc);
hw/mem/nvdimm.c +4
-0+ } + } + } +if (ndc->realize) { ndc->realize (nvdimm, errp); }include/hw/mem/nvdimm.h +38
-0@@ -48,14 +48,76 @@#define TYPE_NVDIMM "nvdimm" OBJECT_DECLARE_TYPE(NVDIMMDevice, NVDIMMClass, NVDIMM) +typedef uint32_t u32 ; +typedef uint64_t u64 ; +typedef uint8_t u8 ; +typedef uint32_t u32 ; + +#define ALIGN (x, y) (((x) + (y) - 1) & ~((y) - 1)) +#define NVDIMM_LSA_SIZE_PROP "lsa-size"#define NVDIMM_UUID_PROP "uuid"#define NVDIMM_UNARMED_PROP "unarmed" +enum ndctl_namespace_version { +NDCTL_NS_VERSION_1_1 , +NDCTL_NS_VERSION_1_2 , +}; + +enum { +NSINDEX_SIG_LEN =16 , +NSINDEX_ALIGN =256 , +NSINDEX_SEQ_MASK =0x3 , +NSLABEL_UUID_LEN =16 , +NSLABEL_NAME_LEN =64 , +}; + +/** +* struct namespace_index - label set superblock +* @sig: NAMESPACE_INDEX\0 +* @flags: placeholder +* @labelsize: log2 size (v1 labels 128 bytes v2 labels 256 bytes) +* @seq: sequence number for this index +* @myoff: offset of this index in label area +* @mysize: size of this index struct +* @otheroff: offset of other index +* @labeloff: offset of first label slot +* @nslot: total number of label slots +* @major: label area major version +* @minor: label area minor version +* @checksum: fletcher64 of all fields +* @free: bitmap, nlabel bits +* +* The size of free[] is rounded up so the total struct size is a +* multiple of NSINDEX_ALIGN bytes. Any bits this allocates beyond
+ * nlabel bits must be zero.
+ */include/hw/mem/nvdimm.h +18
-0+struct namespace_index { +uint8_t sig[NSINDEX_SIG_LEN ]; +uint8_t flags[3 ]; +uint8_t labelsize; +uint32_t seq; +uint64_t myoff; +uint64_t mysize; +uint64_t otheroff; +uint64_t labeloff; +uint32_t nslot; +uint16_t major; +uint16_t minor; +uint64_t checksum; +uint8_t free[0 ]; +}; +struct NVDIMMDevice {/* private */ PCDIMMDevice parent_obj; +/* +* Label's size in LSA. Determined by Label version. 128 for v1.1, 256
include/hw/mem/nvdimm.h +30
-0+* for v1.2 +*/ +unsigned int label_size; +/* public */ /* @@ -150,6 +212,48 @@ struct NVDIMMState { };typedef struct NVDIMMState NVDIMMState ; +#if (NVDIMM_DEBUG ==1 ) +static inline void dump_index_block (struct namespace_index *nsindex) +{ +printf ("sig %s\n" , nsindex->sig); +printf ("flags 0x%x 0x%x 0x%x\n" , nsindex->flags[0 ], + nsindex->flags[1 ], nsindex->flags[2 ]); +printf ("labelsize %d\n" , nsindex->labelsize); +printf ("seq 0x%0x\n" , nsindex->seq); +printf ("myoff 0x%" PRIx64"\n" , nsindex->myoff); +printf ("mysize 0x%" PRIx64"\n" , nsindex->mysize); +printf ("otheroff 0x%" PRIx64"\n" , nsindex->otheroff); +printf ("labeloff 0x%" PRIx64"\n" , nsindex->labeloff); +printf ("nslot %d\n" , nsindex->nslot); +printf ("major %d\n" , nsindex->major); +printf ("minor %d\n" , nsindex->minor); +printf ("checksum 0x%" PRIx64"\n" , nsindex->checksum); +printf ("-------------------------------\n" ); +} +#else +static inline void dump_index_block (struct namespace_index *nsindex) +{ +} +#endif + +/* +* Note, fletcher64() is copied from drivers/nvdimm/label.c in the Linux kernel
+ */include/hw/mem/nvdimm.h +15
-0+static inline u64 fletcher64 (void *addr,size_t len,bool le) +{ +u32 *buf = addr; +u32 lo32 =0 ; +u64 hi32 =0 ; +size_t i; + +for (i =0 ; i < len /sizeof (u32); i++) { + lo32 += le ?le32_to_cpu ((u32 ) buf[i]) : buf[i]; + hi32 += lo32; + } + +return hi32 <<32 | lo32; +} +void nvdimm_init_acpi_state (NVDIMMState *state,MemoryRegion *io,struct AcpiGenericAddress dsm_io,FWCfgState *fw_cfg,Object *owner);
Re: [PATCH 2/2] NVDIMM: Init vNVDIMM's LSA index block if it hasn't been
Quoted 18 lines · On Thu, 31 Mar 2022 21:08:12 +0800 Robert Hoo <[email protected]> wrote:
Quoted 17 lines · Igor Mammedov
Quoted 13 lines · On Tue, 29 Mar 2022 15:07:43 +0800 Robert Hoo <[email protected]> wrote:
Since v2.7, QEMU has supported the emulation of NVDIMM's labels. With -device nvdimm,...,lsa-size=, the vNVDIMM to guest has this capability. But if the emulated LSA area isn't initialized, guest Kernel
can't enumerate it correctly.This patch is to initialize/format the vNVDIMM's LSA, if it has been
designated the Label capability. The index block format will be v1.1
initially, in order to obtain maximum compatibility. VM user can laterndctl init-labelto make it v1.2 if necessary. [1]
Quoted 5 lines
Quoted 3 lines
Can user initialize/format LSA from guest using ndctl/some other tool?
Yes, he can. But when guest Kernel already told him this is a dimm without label capability, dare/should he take this dangerous action?;-)
I don't think this feature belongs to QEMU (i.e. hw emulation). It's task that is usually accomplished by firmware or OS (in context of QEMU its guest's responsibility).
PS:
It's true that QEMU caries some 'firmware' code, like composing ACPI tables but we do it only to reduce QEMU<->firmware ABI necessary for hardware description and that's pretty much it. Unfortunately this series doesn't fit the bill.
Quoted 583 lines
Quoted 9 lines
Quoted 7 lines
[1]
https://uefi.org/sites/default/files/resources/ACPI_Spec_6_4_Jan22.pdf
,
Initial Label Storage Area Configuration:
"for Label Storage Areas of 128KB and 256KB, the corresponding Index
Block size is 256 or 512 bytes."Quick search in above spec says such text doesn't exists.
Sorry, my carelessness, typo with the ACPI spec link.
Quoted 4 lines
above needs grep-able reference + chapter "x.x name" so one could easily
find it.Right, accept this.
Quoted 566 lines
Quoted 564 lines
In driver and ndctl code, they refer to these 2 cases as v1.1 and v1.2.
Signed-off-by Robert Hoo <[email protected]>Reviewed-by Liu, Jingqi <[email protected]>---
Note: most functions in this patch are ported from ndctl and nvdimm driver
code.--- hw/mem/nvdimm.c | 359 ++++++++++++++++++++++++++++++++++++++++ include/hw/mem/nvdimm.h | 104 ++++++++++++ 2 files changed, 463 insertions(+)hw/mem/nvdimm.c +61
-0@@ -25,6 +25,9 @@#include "qemu/osdep.h" #include "qemu/module.h" #include "qemu/pmem.h" +#include "qemu/cutils.h" +#include "qemu/bswap.h" +#include "qemu/error-report.h" #include "qapi/error.h" #include "qapi/visitor.h" #include "hw/mem/nvdimm.h" @@ -178,6 +181,348 @@ static MemoryRegion *nvdimm_md_get_memory_region (MemoryDeviceState *md, return nvdimm->nvdimm_mr; } +static const char NSINDEX_SIGNATURE [] ="NAMESPACE_INDEX\0" ; + +static unsigned inc_seq (unsigned seq) +{ +static const unsigned next[] = {0 ,2 ,3 ,1 }; + +return next[seq &3 ]; +} + +static u32 best_seq (u32 a,u32 b) +{ + a &=NSINDEX_SEQ_MASK ; + b &=NSINDEX_SEQ_MASK ; + +if (a ==0 || a == b) { +return b; + }else if (b ==0 ) { +return a; + }else if (inc_seq (a) == b) { +return b; + }else { +return a; + } +} + +static size_t __sizeof_namespace_index (u32 nslot) +{ +return ALIGN (sizeof (struct namespace_index ) +DIV_ROUND_UP (nslot,8 ), +NSINDEX_ALIGN ); +} + +static unsigned sizeof_namespace_label (struct NVDIMMDevice *nvdimm) +{ +if (nvdimm->label_size ==0 ) { +warn_report ("NVDIMM label size is 0, default it to 128." ); + nvdimm->label_size =128 ; + } +return nvdimm->label_size; +} + +static int __nvdimm_num_label_slots (struct NVDIMMDevice *nvdimm, +size_t index_size) +{ +return (nvdimm->lsa_size - index_size *2 ) / +sizeof_namespace_label (nvdimm); +} + +static int nvdimm_num_label_slots (struct NVDIMMDevice *nvdimm) +{ +u32 tmp_nslot, n; + + tmp_nslot = nvdimm->lsa_size / nvdimm->label_size; + n =__sizeof_namespace_index (tmp_nslot) /NSINDEX_ALIGN ; + +return __nvdimm_num_label_slots (nvdimm,NSINDEX_ALIGN * n); +} + +static unsigned int sizeof_namespace_index(struct NVDIMMDevice*nvdimm)
hw/mem/nvdimm.c +7
-0+{ +u32 nslot, space, size; + +/* +* Per UEFI 2.7, the minimum size of the Label Storage Area is +* large enough to hold 2 index blocks and 2 labels. The +* minimum index block size is 256 bytes, and the minimum label
hw/mem/nvdimm.c +4
-0+* size is 256 bytes. +*/ + nslot =nvdimm_num_label_slots (nvdimm); + space = nvdimm->lsa_size - nslot *
sizeof_namespace_label(nvdimm);hw/mem/nvdimm.c +6
-0+ size =__sizeof_namespace_index (nslot) *2 ; +if (size <= space && nslot >=2 ) { +return size /2 ; + } + + error_report("label area (%ld) too small to host (%d byte)labels",
hw/mem/nvdimm.c +5
-0+ nvdimm->lsa_size, sizeof_namespace_label(nvdimm)); +return 0 ; +} + +static struct namespace_index *to_namespace_index(structNVDIMMDevice *nvdimm,
hw/mem/nvdimm.c +7
-0+ int i) +{ +if (i <0 ) { +return NULL ; + } + + return nvdimm->label_data + sizeof_namespace_index(nvdimm) *i;
hw/mem/nvdimm.c +3
-0+} + +/* Validate NVDIMM index blocks. Generally refer to driver and ndctl code */
hw/mem/nvdimm.c +46
-0+static int __nvdimm_label_validate (struct NVDIMMDevice *nvdimm) +{ +/* +* On media label format consists of two index blocks followed +* by an array of labels. None of these structures are ever +* updated in place. A sequence number tracks the current +* active index and the next one to write, while labels are +* written to free slots. +* +* +------------+ +* | | +* | nsindex0 | +* | | +* +------------+ +* | | +* | nsindex1 | +* | | +* +------------+ +* | label0 | +* +------------+ +* | label1 | +* +------------+ +* | | +* ....nslot... +* | | +* +------------+ +* | labelN | +* +------------+ +*/ +struct namespace_index *nsindex[] = { +to_namespace_index (nvdimm,0 ), +to_namespace_index (nvdimm,1 ), + }; +const int num_index =ARRAY_SIZE (nsindex); +bool valid[2 ] = {0 }; +int i, num_valid =0 ; +u32 seq; + +for (i =0 ; i < num_index; i++) { +u32 nslot; +u8 sig[NSINDEX_SIG_LEN ]; +u64 sum_save, sum, size; +unsigned int version, labelsize; + +memcpy (sig, nsindex[i]->sig,NSINDEX_SIG_LEN ); +if (memcmp (sig,NSINDEX_SIGNATURE ,NSINDEX_SIG_LEN ) !=0 ){
hw/mem/nvdimm.c +22
-0+nvdimm_debug ("nsindex%d signature invalid\n" , i); +continue ; + } + +/* label sizes larger than 128 arrived with v1.2 */ + version =le16_to_cpu (nsindex[i]->major) *100 + +le16_to_cpu (nsindex[i]->minor); +if (version >=102 ) { + labelsize =1 << (7 + nsindex[i]->labelsize); + }else { + labelsize =128 ; + } + +if (labelsize !=sizeof_namespace_label (nvdimm)) { +nvdimm_debug ("nsindex%d labelsize %d invalid\n" , + i, nsindex[i]->labelsize); +continue ; + } + + sum_save =le64_to_cpu (nsindex[i]->checksum); + nsindex[i]->checksum =cpu_to_le64 (0 ); + sum = fletcher64(nsindex[i],
sizeof_namespace_index(nvdimm), 1);hw/mem/nvdimm.c +9
-0+ nsindex[i]->checksum =cpu_to_le64 (sum_save); +if (sum != sum_save) { +nvdimm_debug ("nsindex%d checksum invalid\n" , i); +continue ; + } + + seq =le32_to_cpu (nsindex[i]->seq); +if ((seq &NSINDEX_SEQ_MASK ) ==0 ) { + nvdimm_debug("nsindex%d sequence: 0x%x invalid\n", i,seq);
hw/mem/nvdimm.c +23
-0+continue ; + } + +/* sanity check the index against expected values */ +if (le64_to_cpu (nsindex[i]->myoff) != + i *sizeof_namespace_index (nvdimm)) { +nvdimm_debug ("nsindex%d myoff: 0x%llx invalid\n" , + i, (unsigned long long ) +le64_to_cpu (nsindex[i]->myoff)); +continue ; + } +if (le64_to_cpu (nsindex[i]->otheroff) + != (!i) *sizeof_namespace_index (nvdimm)) { +nvdimm_debug ("nsindex%d otheroff: 0x%llx invalid\n" , + i, (unsigned long long ) +le64_to_cpu (nsindex[i]->otheroff)); +continue ; + } + + size =le64_to_cpu (nsindex[i]->mysize); +if (size >sizeof_namespace_index (nvdimm) || + size <sizeof (struct namespace_index )) { + nvdimm_debug("nsindex%d mysize: 0x%zx invalid\n", i,size);
hw/mem/nvdimm.c +6
-0+continue ; + } + + nslot =le32_to_cpu (nsindex[i]->nslot); +if (nslot *sizeof_namespace_label (nvdimm) + +2 *sizeof_namespace_index (nvdimm) > nvdimm->lsa_size){
+ nvdimm_debug("nsindex%d nslot: %u invalid,config_size: 0x%zx\n",hw/mem/nvdimm.c +16
-0+ i, nslot, nvdimm->lsa_size); +continue ; + } + valid[i] = true; + num_valid++; + } + +switch (num_valid) { +case 0 : +break ; +case 1 : +for (i =0 ; i < num_index; i++) +if (valid[i]) { +return i; + } +/* can't have num_valid > 0 but valid[] = { false, false } */
hw/mem/nvdimm.c +7
-0+error_report ("unexpected index-block parse error" ); +break ; +default : +/* pick the best index... */ + seq =best_seq (le32_to_cpu (nsindex[0 ]->seq), +le32_to_cpu (nsindex[1 ]->seq)); + if (seq == (le32_to_cpu(nsindex[1]->seq) &
NSINDEX_SEQ_MASK)) {hw/mem/nvdimm.c +44
-0+return 1 ; + }else { +return 0 ; + } +break ; + } + +return -1 ; +} + +static int nvdimm_label_validate (struct NVDIMMDevice *nvdimm) +{ +int label_size[] = {128 ,256 }; +int i, rc; + +for (i =0 ; i <ARRAY_SIZE (label_size); i++) { + nvdimm->label_size = label_size[i]; + rc =__nvdimm_label_validate (nvdimm); +if (rc >=0 ) { +return rc; + } + } + +return -1 ; +} + +static int label_next_nsindex (int index) +{ +if (index <0 ) { +return -1 ; + } + +return (index +1 ) %2 ; +} + +static void *label_base (struct NVDIMMDevice *nvdimm) +{ +void *base =to_namespace_index (nvdimm,0 ); + +return base +2 *sizeof_namespace_index (nvdimm); +} + +static int write_label_index (struct NVDIMMDevice *nvdimm, + enum ndctl_namespace_version ver, unsigned index, unsignedseq)
hw/mem/nvdimm.c +9
-0+{ +struct namespace_index *nsindex; +unsigned long offset; +u64 checksum; +u32 nslot; + +/* +* We may have initialized ndd to whatever labelsize is +* currently on the dimm during label_validate(), so we reset it
hw/mem/nvdimm.c +42
-0+* to the desired version here. +*/ +switch (ver) { +case NDCTL_NS_VERSION_1_1 : + nvdimm->label_size =128 ; +break ; +case NDCTL_NS_VERSION_1_2 : + nvdimm->label_size =256 ; +break ; +default : +return -1 ; + } + + nsindex =to_namespace_index (nvdimm, index); + nslot =nvdimm_num_label_slots (nvdimm); + +memcpy (nsindex->sig,NSINDEX_SIGNATURE ,NSINDEX_SIG_LEN ); +memset (nsindex->flags,0 ,3 ); + nsindex->labelsize =sizeof_namespace_label (nvdimm) >>8 ; + nsindex->seq =cpu_to_le32 (seq); + offset = (unsigned long ) nsindex + - (unsigned long )to_namespace_index (nvdimm,0 ); + nsindex->myoff =cpu_to_le64 (offset); + nsindex->mysize =cpu_to_le64 (sizeof_namespace_index (nvdimm)); + offset = (unsigned long )to_namespace_index (nvdimm, +label_next_nsindex (index)) + - (unsigned long )to_namespace_index (nvdimm,0 ); + nsindex->otheroff =cpu_to_le64 (offset); + offset = (unsigned long )label_base (nvdimm) + - (unsigned long )to_namespace_index (nvdimm,0 ); + nsindex->labeloff =cpu_to_le64 (offset); + nsindex->nslot =cpu_to_le32 (nslot); + nsindex->major =cpu_to_le16 (1 ); +if (sizeof_namespace_label (nvdimm) <256 ) { + nsindex->minor =cpu_to_le16 (1 ); + }else { + nsindex->minor =cpu_to_le16 (2 ); + } + nsindex->checksum =cpu_to_le64 (0 ); +/* init label bitmap */ +memset (nsindex->free,0xff ,ALIGN (nslot,BITS_PER_LONG ) /8 ); + checksum = fletcher64(nsindex, sizeof_namespace_index(nvdimm),1);
hw/mem/nvdimm.c +13
-0+ nsindex->checksum =cpu_to_le64 (checksum); + +return 0 ; +} + +static int nvdimm_init_label (struct NVDIMMDevice *nvdimm) +{ +int i; + +for (i =0 ; i <2 ; i++) { +int rc; + +/* To have most compatibility, we init index block with v1.1 */
hw/mem/nvdimm.c +7
-1+ rc = write_label_index(nvdimm, NDCTL_NS_VERSION_1_1, i, 3 - i); + + if (rc < 0) { + error_report("init No.%d index block failed", i); + return rc; + } else { + nvdimm_debug("%s: dump No.%d index block\n", __func__,i);
hw/mem/nvdimm.c +10
-0+dump_index_block (to_namespace_index (nvdimm, i)); + } + } + +return 0 ; +} +static void nvdimm_realize (PCDIMMDevice *dimm,Error **errp) {NVDIMMDevice *nvdimm =NVDIMM (dimm);@@ -187,6 +532,20 @@ static void nvdimm_realize(PCDIMMDevice *dimm, Error **errp)nvdimm_prepare_memory_region (nvdimm ,errp ); } +/* When LSA is designaged, validate it. */ +if (nvdimm->lsa_size !=0 ) { + if (buffer_is_zero(nvdimm->label_data, nvdimm->lsa_size)||
hw/mem/nvdimm.c +4
-0+ nvdimm_label_validate(nvdimm) < 0) { +int rc; + + info_report("NVDIMM LSA is invalid, needs to beinitialized");
hw/mem/nvdimm.c +3
-0+ rc =nvdimm_init_label (nvdimm); +if (rc <0 ) { + error_report("NVDIMM lsa init failed, rc = %d",rc);
hw/mem/nvdimm.c +4
-0+ } + } + } +if (ndc->realize) { ndc->realize (nvdimm, errp); }include/hw/mem/nvdimm.h +38
-0@@ -48,14 +48,76 @@#define TYPE_NVDIMM "nvdimm" OBJECT_DECLARE_TYPE(NVDIMMDevice, NVDIMMClass, NVDIMM) +typedef uint32_t u32 ; +typedef uint64_t u64 ; +typedef uint8_t u8 ; +typedef uint32_t u32 ; + +#define ALIGN (x, y) (((x) + (y) - 1) & ~((y) - 1)) +#define NVDIMM_LSA_SIZE_PROP "lsa-size"#define NVDIMM_UUID_PROP "uuid"#define NVDIMM_UNARMED_PROP "unarmed" +enum ndctl_namespace_version { +NDCTL_NS_VERSION_1_1 , +NDCTL_NS_VERSION_1_2 , +}; + +enum { +NSINDEX_SIG_LEN =16 , +NSINDEX_ALIGN =256 , +NSINDEX_SEQ_MASK =0x3 , +NSLABEL_UUID_LEN =16 , +NSLABEL_NAME_LEN =64 , +}; + +/** +* struct namespace_index - label set superblock +* @sig: NAMESPACE_INDEX\0 +* @flags: placeholder +* @labelsize: log2 size (v1 labels 128 bytes v2 labels 256 bytes) +* @seq: sequence number for this index +* @myoff: offset of this index in label area +* @mysize: size of this index struct +* @otheroff: offset of other index +* @labeloff: offset of first label slot +* @nslot: total number of label slots +* @major: label area major version +* @minor: label area minor version +* @checksum: fletcher64 of all fields +* @free: bitmap, nlabel bits +* +* The size of free[] is rounded up so the total struct size is a +* multiple of NSINDEX_ALIGN bytes. Any bits this allocates beyond
+ * nlabel bits must be zero.
+ */include/hw/mem/nvdimm.h +18
-0+struct namespace_index { +uint8_t sig[NSINDEX_SIG_LEN ]; +uint8_t flags[3 ]; +uint8_t labelsize; +uint32_t seq; +uint64_t myoff; +uint64_t mysize; +uint64_t otheroff; +uint64_t labeloff; +uint32_t nslot; +uint16_t major; +uint16_t minor; +uint64_t checksum; +uint8_t free[0 ]; +}; +struct NVDIMMDevice {/* private */ PCDIMMDevice parent_obj; +/* +* Label's size in LSA. Determined by Label version. 128 for v1.1, 256
include/hw/mem/nvdimm.h +30
-0+* for v1.2 +*/ +unsigned int label_size; +/* public */ /* @@ -150,6 +212,48 @@ struct NVDIMMState { };typedef struct NVDIMMState NVDIMMState ; +#if (NVDIMM_DEBUG ==1 ) +static inline void dump_index_block (struct namespace_index *nsindex) +{ +printf ("sig %s\n" , nsindex->sig); +printf ("flags 0x%x 0x%x 0x%x\n" , nsindex->flags[0 ], + nsindex->flags[1 ], nsindex->flags[2 ]); +printf ("labelsize %d\n" , nsindex->labelsize); +printf ("seq 0x%0x\n" , nsindex->seq); +printf ("myoff 0x%" PRIx64"\n" , nsindex->myoff); +printf ("mysize 0x%" PRIx64"\n" , nsindex->mysize); +printf ("otheroff 0x%" PRIx64"\n" , nsindex->otheroff); +printf ("labeloff 0x%" PRIx64"\n" , nsindex->labeloff); +printf ("nslot %d\n" , nsindex->nslot); +printf ("major %d\n" , nsindex->major); +printf ("minor %d\n" , nsindex->minor); +printf ("checksum 0x%" PRIx64"\n" , nsindex->checksum); +printf ("-------------------------------\n" ); +} +#else +static inline void dump_index_block (struct namespace_index *nsindex) +{ +} +#endif + +/* +* Note, fletcher64() is copied from drivers/nvdimm/label.c in the Linux kernel
+ */include/hw/mem/nvdimm.h +15
-0+static inline u64 fletcher64 (void *addr,size_t len,bool le) +{ +u32 *buf = addr; +u32 lo32 =0 ; +u64 hi32 =0 ; +size_t i; + +for (i =0 ; i < len /sizeof (u32); i++) { + lo32 += le ?le32_to_cpu ((u32 ) buf[i]) : buf[i]; + hi32 += lo32; + } + +return hi32 <<32 | lo32; +} +void nvdimm_init_acpi_state (NVDIMMState *state,MemoryRegion *io,struct AcpiGenericAddress dsm_io,FWCfgState *fw_cfg,Object *owner);
Re: [PATCH 2/2] NVDIMM: Init vNVDIMM's LSA index block if it hasn't been
Quoted 8 lines · Igor Mammedov
Quoted 5 lines · On Thu, 31 Mar 2022 21:08:12 +0800 Robert Hoo <[email protected]> wrote:
Quoted 4 lines
Can user initialize/format LSA from guest using ndctl/some other tool?
Quoted 8 lines
Quoted 3 lines
Yes, he can. But when guest Kernel already told him this is a dimm without label capability, dare/should he take this dangerous action?;-)
I don't think this feature belongs to QEMU (i.e. hw emulation). It's task that is usually accomplished by firmware or OS (in context of QEMU its guest's responsibility).
Thanks Igor.
Actually before I compose this patch, I was pondering on this as well:
whose obligation to fulfill this function, i.e. initialize the LSA.
So I asked around (and still asking), knowing these about native usage, (correct me if I'm wrong), which we virtualization should mimic in principle:
a) before user start to use NVDIMM, he's supposed to ipmctl[0] create goal firstly, to determine 2LM mode or app direct mode, which usually initializes the LSA. So user doesn't necessarily to explicit 'ndctl init-label' although he can do this to init LSA again.
b) I heard that, perhaps, even when DIMMs are sent out from factory, it has LSA initialized (not quite certain about this, I'm still confirming).
What specs say
---
In NVDIMM Namespace spec[1], Chap 2 "Namespaces":
"NVDIMM vendors define the size of their label storage area and, therefor, the number of labels it holds."
I think: In QEMU context, it's QEMU who's the vNVDIMM's vendor.
In UEFI spec [2], "13.19 NVDIMM Label Protocol", page 640:
"Before Index Blocks and labels can be utilized, the software managing the Label Storage Area must determine the total number of labels that will be supported and utilizing the description above, calculate the size of the Index Blocks required."
I think: In QEMU context, it's QEMU who emulates LSA and therefore the management software of it.
What's real limitation on QEMU vNVDIMM implementation
---
In VM:
ipmctl isn't supported.
Only app direct mode is supported. (i.e. no bother to ipmctl create goal first).
vNVDIMM is actually presented to user in a ready-to-use initial state. We never tell user you must 'ndctl init-label' then can use it. Nor tell user that you should 'ipmctl create-goal' first, because in fact ipmctl isn't available at all.
That's all the story and thoughts before I compose this patch:)
[0] https://docs.pmem.io/ipmctl-user-guide/ (and, ipmctl is for Intel Optane PMEM only)
[1] https://pmem.io/documents/NVDIMM_Namespace_Spec.pdf
[2]
https://uefi.org/sites/default/files/resources/UEFI_Spec_2_9_2021_03_18.pdf
Quoted 7 lines
PS:
It's true that QEMU caries some 'firmware' code, like composing ACPI tables but we do it only to reduce QEMU<->firmware ABI necessary for hardware description and that's pretty much it. Unfortunately this series doesn't fit the bill.
Yeah, I've seen this part of code, but a little difficult to comprehend them, especially for me a stranger to ACPI. Where can I find related design document?
I now only find a valuable doc: docs/specs/acpi_nvdimm.rst.
Quoted 1 line
Re: [PATCH 2/2] NVDIMM: Init vNVDIMM's LSA index block if it hasn't been
Quoted 26 lines · On Fri, 01 Apr 2022 12:07:56 +0800 Robert Hoo <[email protected]> wrote:
Quoted 8 lines · Igor Mammedov
Quoted 5 lines · On Thu, 31 Mar 2022 21:08:12 +0800 Robert Hoo <[email protected]> wrote:
Quoted 4 lines
Can user initialize/format LSA from guest using ndctl/some other tool?
Quoted 8 lines
Quoted 3 lines
Yes, he can. But when guest Kernel already told him this is a dimm without label capability, dare/should he take this dangerous action?;-)
I don't think this feature belongs to QEMU (i.e. hw emulation). It's task that is usually accomplished by firmware or OS (in context of QEMU its guest's responsibility).
Thanks Igor.
Actually before I compose this patch, I was pondering on this as well:
whose obligation to fulfill this function, i.e. initialize the LSA.So I asked around (and still asking), knowing these about native usage, (correct me if I'm wrong), which we virtualization should mimic in principle:
Quoted 8 lines
a) before user start to use NVDIMM, he's supposed to ipmctl[0] create goal firstly, to determine 2LM mode or app direct mode, which usually initializes the LSA. So user doesn't necessarily to explicit 'ndctl init-label' although he can do this to init LSA again.
b) I heard that, perhaps, even when DIMMs are sent out from factory, it has LSA initialized (not quite certain about this, I'm still confirming).
if you find a NVDIMM that implements initialization in hardware, then it could be considered. But QEMU isn't a factory, it's rather a component within factory that perform specific task while other components manage it (including storage it consumes, see libguestfs project which is similar to what you are trying to do, but deals with conventional storage).
Quoted 5 lines
What specs say
---
In NVDIMM Namespace spec[1], Chap 2 "Namespaces":
"NVDIMM vendors define the size of their label storage area and, therefor, the number of labels it holds."
one does define size and lsa size on QEMU command line, how it will be consumed is the business of firmware/operating system that runs within VM though.
Quoted 11 lines
I think: In QEMU context, it's QEMU who's the vNVDIMM's vendor.
In UEFI spec [2], "13.19 NVDIMM Label Protocol", page 640:
"Before Index Blocks and labels can be utilized, the software managing the Label Storage Area must determine the total number of labels that will be supported and utilizing the description above, calculate the size of the Index Blocks required."I think: In QEMU context, it's QEMU who emulates LSA and therefore the management software of it.
Quoted 10 lines
What's real limitation on QEMU vNVDIMM implementation
---
In VM:
ipmctl isn't supported.
Only app direct mode is supported. (i.e. no bother to ipmctl create goal first).
vNVDIMM is actually presented to user in a ready-to-use initial state. We never tell user you must 'ndctl init-label' then can use it. Nor tell user that you should 'ipmctl create-goal' first, because in fact ipmctl isn't available at all.
ipmictl isn't hardware, it's tool to connect to firmware running on BMC. In virt world it corresponds to guest code running within VM or some mgmt app outside QEMU that can implement IPMI interface. You can try to generalize this utility and extend EDKII to support it, which would benefit not only QEMU but other consumers of EDKII.
wrt IPMI, I'm not familiar with BMC support in QEMU, but looks there are at least some (see hw/ipmi folder) implementations.
As for [b] point, QEMU is not software managing NVDIMM, it's hardware emulator. Duplicating irrelevant features in QEMU will just bloat it and make project unmanageable.
Point [b] to me looks more like a separate utility that could initialize vNVDIMM for further consumption (I'd ask libguestfs or ndctl folks if they would like to add support for 'out of band' vNVDIMM management, but likely outcome to this would be what libguestfs is doing currently with disks, start VM appliance and run ndctl within it to initialize vNVDIMM).
Quoted 21 lines
That's all the story and thoughts before I compose this patch:)
[0] https://docs.pmem.io/ipmctl-user-guide/ (and, ipmctl is for Intel Optane PMEM only)
[1] https://pmem.io/documents/NVDIMM_Namespace_Spec.pdf
[2]
https://uefi.org/sites/default/files/resources/UEFI_Spec_2_9_2021_03_18.pdfQuoted 7 lines
PS:
It's true that QEMU caries some 'firmware' code, like composing ACPI tables but we do it only to reduce QEMU<->firmware ABI necessary for hardware description and that's pretty much it. Unfortunately this series doesn't fit the bill.Yeah, I've seen this part of code, but a little difficult to comprehend them, especially for me a stranger to ACPI. Where can I find related design document?
I now only find a valuable doc:docs/specs/acpi_nvdimm.rst.Quoted 1 line