LIBNVDIMM: Non-Volatile Devices
  	      libnvdimm - kernel / libndctl - userspace helper library
  			   linux-nvdimm@lists.01.org
  				      v13
  
  
  	Glossary
  	Overview
  	    Supporting Documents
  	    Git Trees
  	LIBNVDIMM PMEM and BLK
  	Why BLK?
  	    PMEM vs BLK
  	        BLK-REGIONs, PMEM-REGIONs, Atomic Sectors, and DAX
  	Example NVDIMM Platform
  	LIBNVDIMM Kernel Device Model and LIBNDCTL Userspace API
  	    LIBNDCTL: Context
  	        libndctl: instantiate a new library context example
  	    LIBNVDIMM/LIBNDCTL: Bus
  	        libnvdimm: control class device in /sys/class
  	        libnvdimm: bus
  	        libndctl: bus enumeration example
  	    LIBNVDIMM/LIBNDCTL: DIMM (NMEM)
  	        libnvdimm: DIMM (NMEM)
  	        libndctl: DIMM enumeration example
  	    LIBNVDIMM/LIBNDCTL: Region
  	        libnvdimm: region
  	        libndctl: region enumeration example
  	        Why Not Encode the Region Type into the Region Name?
  	        How Do I Determine the Major Type of a Region?
  	    LIBNVDIMM/LIBNDCTL: Namespace
  	        libnvdimm: namespace
  	        libndctl: namespace enumeration example
  	        libndctl: namespace creation example
  	        Why the Term "namespace"?
  	    LIBNVDIMM/LIBNDCTL: Block Translation Table "btt"
  	        libnvdimm: btt layout
  	        libndctl: btt creation example
  	Summary LIBNDCTL Diagram
  
  
  Glossary
  --------
  
  PMEM: A system-physical-address range where writes are persistent.  A
  block device composed of PMEM is capable of DAX.  A PMEM address range
  may span an interleave of several DIMMs.
  
  BLK: A set of one or more programmable memory mapped apertures provided
  by a DIMM to access its media.  This indirection precludes the
  performance benefit of interleaving, but enables DIMM-bounded failure
  modes.
  
  DPA: DIMM Physical Address, is a DIMM-relative offset.  With one DIMM in
  the system there would be a 1:1 system-physical-address:DPA association.
  Once more DIMMs are added a memory controller interleave must be
  decoded to determine the DPA associated with a given
  system-physical-address.  BLK capacity always has a 1:1 relationship
  with a single-DIMM's DPA range.
  
  DAX: File system extensions to bypass the page cache and block layer to
  mmap persistent memory, from a PMEM block device, directly into a
  process address space.

  DSM: Device Specific Method: ACPI method to to control specific
  device - in this case the firmware.
  
  DCR: NVDIMM Control Region Structure defined in ACPI 6 Section 5.2.25.5.
  It defines a vendor-id, device-id, and interface format for a given DIMM.

  BTT: Block Translation Table: Persistent memory is byte addressable.
  Existing software may have an expectation that the power-fail-atomicity
  of writes is at least one sector, 512 bytes.  The BTT is an indirection
  table with atomic update semantics to front a PMEM/BLK block device
  driver and present arbitrary atomic sector sizes.
  
  LABEL: Metadata stored on a DIMM device that partitions and identifies
  (persistently names) storage between PMEM and BLK.  It also partitions
  BLK storage to host BTTs with different parameters per BLK-partition.
  Note that traditional partition tables, GPT/MBR, are layered on top of a
  BLK or PMEM device.
  
  
  Overview
  --------
  
  The LIBNVDIMM subsystem provides support for three types of NVDIMMs, namely,
  PMEM, BLK, and NVDIMM devices that can simultaneously support both PMEM
  and BLK mode access.  These three modes of operation are described by
  the "NVDIMM Firmware Interface Table" (NFIT) in ACPI 6.  While the LIBNVDIMM
  implementation is generic and supports pre-NFIT platforms, it was guided
  by the superset of capabilities need to support this ACPI 6 definition
  for NVDIMM resources.  The bulk of the kernel implementation is in place
  to handle the case where DPA accessible via PMEM is aliased with DPA
  accessible via BLK.  When that occurs a LABEL is needed to reserve DPA
  for exclusive access via one mode a time.
  
  Supporting Documents
  ACPI 6: http://www.uefi.org/sites/default/files/resources/ACPI_6.0.pdf
  NVDIMM Namespace: http://pmem.io/documents/NVDIMM_Namespace_Spec.pdf
  DSM Interface Example: http://pmem.io/documents/NVDIMM_DSM_Interface_Example.pdf
  Driver Writer's Guide: http://pmem.io/documents/NVDIMM_Driver_Writers_Guide.pdf
  
  Git Trees
  LIBNVDIMM: https://git.kernel.org/cgit/linux/kernel/git/djbw/nvdimm.git
  LIBNDCTL: https://github.com/pmem/ndctl.git
  PMEM: https://github.com/01org/prd
  
  
  LIBNVDIMM PMEM and BLK
  ------------------
  
  Prior to the arrival of the NFIT, non-volatile memory was described to a
  system in various ad-hoc ways.  Usually only the bare minimum was
  provided, namely, a single system-physical-address range where writes
  are expected to be durable after a system power loss.  Now, the NFIT
  specification standardizes not only the description of PMEM, but also
  BLK and platform message-passing entry points for control and
  configuration.
  
  For each NVDIMM access method (PMEM, BLK), LIBNVDIMM provides a block
  device driver:
  
      1. PMEM (nd_pmem.ko): Drives a system-physical-address range.  This
      range is contiguous in system memory and may be interleaved (hardware
      memory controller striped) across multiple DIMMs.  When interleaved the
      platform may optionally provide details of which DIMMs are participating
      in the interleave.
  
      Note that while LIBNVDIMM describes system-physical-address ranges that may
      alias with BLK access as ND_NAMESPACE_PMEM ranges and those without
      alias as ND_NAMESPACE_IO ranges, to the nd_pmem driver there is no
      distinction.  The different device-types are an implementation detail
      that userspace can exploit to implement policies like "only interface
      with address ranges from certain DIMMs".  It is worth noting that when
      aliasing is present and a DIMM lacks a label, then no block device can
      be created by default as userspace needs to do at least one allocation
      of DPA to the PMEM range.  In contrast ND_NAMESPACE_IO ranges, once
      registered, can be immediately attached to nd_pmem.
  
      2. BLK (nd_blk.ko): This driver performs I/O using a set of platform

      defined apertures.  A set of apertures will access just one DIMM.
      Multiple windows (apertures) allow multiple concurrent accesses, much like

      tagged-command-queuing, and would likely be used by different threads or
      different CPUs.
  
      The NFIT specification defines a standard format for a BLK-aperture, but
      the spec also allows for vendor specific layouts, and non-NFIT BLK

      implementations may have other designs for BLK I/O.  For this reason
      "nd_blk" calls back into platform-specific code to perform the I/O.
      One such implementation is defined in the "Driver Writer's Guide" and "DSM

      Interface Example".
  
  
  Why BLK?
  --------
  
  While PMEM provides direct byte-addressable CPU-load/store access to
  NVDIMM storage, it does not provide the best system RAS (recovery,
  availability, and serviceability) model.  An access to a corrupted

  system-physical-address address causes a CPU exception while an access

  to a corrupted address through an BLK-aperture causes that block window
  to raise an error status in a register.  The latter is more aligned with
  the standard error model that host-bus-adapter attached disks present.
  Also, if an administrator ever wants to replace a memory it is easier to
  service a system at DIMM module boundaries.  Compare this to PMEM where
  data could be interleaved in an opaque hardware specific manner across
  several DIMMs.
  
  PMEM vs BLK

  BLK-apertures solve these RAS problems, but their presence is also the

  major contributing factor to the complexity of the ND subsystem.  They
  complicate the implementation because PMEM and BLK alias in DPA space.
  Any given DIMM's DPA-range may contribute to one or more
  system-physical-address sets of interleaved DIMMs, *and* may also be
  accessed in its entirety through its BLK-aperture.  Accessing a DPA
  through a system-physical-address while simultaneously accessing the
  same DPA through a BLK-aperture has undefined results.  For this reason,
  DIMMs with this dual interface configuration include a DSM function to
  store/retrieve a LABEL.  The LABEL effectively partitions the DPA-space
  into exclusive system-physical-address and BLK-aperture accessible
  regions.  For simplicity a DIMM is allowed a PMEM "region" per each
  interleave set in which it is a member.  The remaining DPA space can be
  carved into an arbitrary number of BLK devices with discontiguous
  extents.
  
  BLK-REGIONs, PMEM-REGIONs, Atomic Sectors, and DAX
  --------------------------------------------------
  
  One of the few
  reasons to allow multiple BLK namespaces per REGION is so that each
  BLK-namespace can be configured with a BTT with unique atomic sector
  sizes.  While a PMEM device can host a BTT the LABEL specification does
  not provide for a sector size to be specified for a PMEM namespace.
  This is due to the expectation that the primary usage model for PMEM is
  via DAX, and the BTT is incompatible with DAX.  However, for the cases
  where an application or filesystem still needs atomic sector update
  guarantees it can register a BTT on a PMEM device or partition.  See
  LIBNVDIMM/NDCTL: Block Translation Table "btt"
  
  
  Example NVDIMM Platform
  -----------------------
  
  For the remainder of this document the following diagram will be
  referenced for any example sysfs layouts.
  
  
                               (a)               (b)           DIMM   BLK-REGION
            +-------------------+--------+--------+--------+
  +------+  |       pm0.0       | blk2.0 | pm1.0  | blk2.1 |    0      region2
  | imc0 +--+- - - region0- - - +--------+        +--------+
  +--+---+  |       pm0.0       | blk3.0 | pm1.0  | blk3.1 |    1      region3
     |      +-------------------+--------v        v--------+
  +--+---+                               |                 |
  | cpu0 |                                     region1
  +--+---+                               |                 |
     |      +----------------------------^        ^--------+
  +--+---+  |           blk4.0           | pm1.0  | blk4.0 |    2      region4
  | imc1 +--+----------------------------|        +--------+
  +------+  |           blk5.0           | pm1.0  | blk5.0 |    3      region5
            +----------------------------+--------+--------+
  
  In this platform we have four DIMMs and two memory controllers in one
  socket.  Each unique interface (BLK or PMEM) to DPA space is identified
  by a region device with a dynamically assigned id (REGION0 - REGION5).
  
      1. The first portion of DIMM0 and DIMM1 are interleaved as REGION0. A

      single PMEM namespace is created in the REGION0-SPA-range that spans most
      of DIMM0 and DIMM1 with a user-specified name of "pm0.0". Some of that

      interleaved system-physical-address range is reclaimed as BLK-aperture
      accessed space starting at DPA-offset (a) into each DIMM.  In that
      reclaimed space we create two BLK-aperture "namespaces" from REGION2 and
      REGION3 where "blk2.0" and "blk3.0" are just human readable names that
      could be set to any user-desired name in the LABEL.
  
      2. In the last portion of DIMM0 and DIMM1 we have an interleaved
      system-physical-address range, REGION1, that spans those two DIMMs as

      well as DIMM2 and DIMM3.  Some of REGION1 is allocated to a PMEM namespace
      named "pm1.0", the rest is reclaimed in 4 BLK-aperture namespaces (for

      each DIMM in the interleave set), "blk2.1", "blk3.1", "blk4.0", and
      "blk5.0".
  
      3. The portion of DIMM2 and DIMM3 that do not participate in the REGION1

      interleaved system-physical-address range (i.e. the DPA address past

      offset (b) are also included in the "blk4.0" and "blk5.0" namespaces.
      Note, that this example shows that BLK-aperture namespaces don't need to
      be contiguous in DPA-space.
  
      This bus is provided by the kernel under the device
      /sys/devices/platform/nfit_test.0 when CONFIG_NFIT_TEST is enabled and
      the nfit_test.ko module is loaded.  This not only test LIBNVDIMM but the
      acpi_nfit.ko driver as well.
  
  
  LIBNVDIMM Kernel Device Model and LIBNDCTL Userspace API
  ----------------------------------------------------
  
  What follows is a description of the LIBNVDIMM sysfs layout and a
  corresponding object hierarchy diagram as viewed through the LIBNDCTL

  API.  The example sysfs paths and diagrams are relative to the Example

  NVDIMM Platform which is also the LIBNVDIMM bus used in the LIBNDCTL unit
  test.
  
  LIBNDCTL: Context

  Every API call in the LIBNDCTL library requires a context that holds the

  logging parameters and other library instance state.  The library is
  based on the libabc template:

  https://git.kernel.org/cgit/linux/kernel/git/kay/libabc.git

  
  LIBNDCTL: instantiate a new library context example
  
  	struct ndctl_ctx *ctx;
  
  	if (ndctl_new(&ctx) == 0)
  		return ctx;
  	else
  		return NULL;
  
  LIBNVDIMM/LIBNDCTL: Bus
  -------------------
  
  A bus has a 1:1 relationship with an NFIT.  The current expectation for
  ACPI based systems is that there is only ever one platform-global NFIT.
  That said, it is trivial to register multiple NFITs, the specification
  does not preclude it.  The infrastructure supports multiple busses and
  we we use this capability to test multiple NFIT configurations in the
  unit test.
  
  LIBNVDIMM: control class device in /sys/class
  
  This character device accepts DSM messages to be passed to DIMM
  identified by its NFIT handle.
  
  	/sys/class/nd/ndctl0
  	|-- dev
  	|-- device -> ../../../ndbus0
  	|-- subsystem -> ../../../../../../../class/nd
  
  
  
  LIBNVDIMM: bus
  
  	struct nvdimm_bus *nvdimm_bus_register(struct device *parent,
  	       struct nvdimm_bus_descriptor *nfit_desc);
  
  	/sys/devices/platform/nfit_test.0/ndbus0
  	|-- commands
  	|-- nd
  	|-- nfit
  	|-- nmem0
  	|-- nmem1
  	|-- nmem2
  	|-- nmem3
  	|-- power
  	|-- provider
  	|-- region0
  	|-- region1
  	|-- region2
  	|-- region3
  	|-- region4
  	|-- region5
  	|-- uevent
  	`-- wait_probe
  
  LIBNDCTL: bus enumeration example
  Find the bus handle that describes the bus from Example NVDIMM Platform
  
  	static struct ndctl_bus *get_bus_by_provider(struct ndctl_ctx *ctx,
  			const char *provider)
  	{
  		struct ndctl_bus *bus;
  
  		ndctl_bus_foreach(ctx, bus)
  			if (strcmp(provider, ndctl_bus_get_provider(bus)) == 0)
  				return bus;
  
  		return NULL;
  	}
  
  	bus = get_bus_by_provider(ctx, "nfit_test.0");
  
  
  LIBNVDIMM/LIBNDCTL: DIMM (NMEM)
  ---------------------------
  
  The DIMM device provides a character device for sending commands to
  hardware, and it is a container for LABELs.  If the DIMM is defined by
  NFIT then an optional 'nfit' attribute sub-directory is available to add
  NFIT-specifics.
  
  Note that the kernel device name for "DIMMs" is "nmemX".  The NFIT
  describes these devices via "Memory Device to System Physical Address
  Range Mapping Structure", and there is no requirement that they actually
  be physical DIMMs, so we use a more generic name.
  
  LIBNVDIMM: DIMM (NMEM)
  
  	struct nvdimm *nvdimm_create(struct nvdimm_bus *nvdimm_bus, void *provider_data,
  			const struct attribute_group **groups, unsigned long flags,
  			unsigned long *dsm_mask);
  
  	/sys/devices/platform/nfit_test.0/ndbus0
  	|-- nmem0
  	|   |-- available_slots
  	|   |-- commands
  	|   |-- dev
  	|   |-- devtype
  	|   |-- driver -> ../../../../../bus/nd/drivers/nvdimm
  	|   |-- modalias
  	|   |-- nfit
  	|   |   |-- device
  	|   |   |-- format
  	|   |   |-- handle
  	|   |   |-- phys_id
  	|   |   |-- rev_id
  	|   |   |-- serial
  	|   |   `-- vendor
  	|   |-- state
  	|   |-- subsystem -> ../../../../../bus/nd
  	|   `-- uevent
  	|-- nmem1
  	[..]
  
  
  LIBNDCTL: DIMM enumeration example
  
  Note, in this example we are assuming NFIT-defined DIMMs which are
  identified by an "nfit_handle" a 32-bit value where:
  Bit 3:0 DIMM number within the memory channel
  Bit 7:4 memory channel number
  Bit 11:8 memory controller ID
  Bit 15:12 socket ID (within scope of a Node controller if node controller is present)
  Bit 27:16 Node Controller ID
  Bit 31:28 Reserved
  
  	static struct ndctl_dimm *get_dimm_by_handle(struct ndctl_bus *bus,
  	       unsigned int handle)
  	{
  		struct ndctl_dimm *dimm;
  
  		ndctl_dimm_foreach(bus, dimm)
  			if (ndctl_dimm_get_handle(dimm) == handle)
  				return dimm;
  
  		return NULL;
  	}
  
  	#define DIMM_HANDLE(n, s, i, c, d) \
  		(((n & 0xfff) << 16) | ((s & 0xf) << 12) | ((i & 0xf) << 8) \
  		 | ((c & 0xf) << 4) | (d & 0xf))
  
  	dimm = get_dimm_by_handle(bus, DIMM_HANDLE(0, 0, 0, 0, 0));
  
  LIBNVDIMM/LIBNDCTL: Region
  ----------------------

  A generic REGION device is registered for each PMEM range or BLK-aperture

  set.  Per the example there are 6 regions: 2 PMEM and 4 BLK-aperture
  sets on the "nfit_test.0" bus.  The primary role of regions are to be a
  container of "mappings".  A mapping is a tuple of <DIMM,
  DPA-start-offset, length>.
  
  LIBNVDIMM provides a built-in driver for these REGION devices.  This driver
  is responsible for reconciling the aliased DPA mappings across all
  regions, parsing the LABEL, if present, and then emitting NAMESPACE
  devices with the resolved/exclusive DPA-boundaries for the nd_pmem or
  nd_blk device driver to consume.
  
  In addition to the generic attributes of "mapping"s, "interleave_ways"
  and "size" the REGION device also exports some convenience attributes.
  "nstype" indicates the integer type of namespace-device this region
  emits, "devtype" duplicates the DEVTYPE variable stored by udev at the
  'add' event, "modalias" duplicates the MODALIAS variable stored by udev
  at the 'add' event, and finally, the optional "spa_index" is provided in
  the case where the region is defined by a SPA.
  
  LIBNVDIMM: region
  
  	struct nd_region *nvdimm_pmem_region_create(struct nvdimm_bus *nvdimm_bus,
  			struct nd_region_desc *ndr_desc);
  	struct nd_region *nvdimm_blk_region_create(struct nvdimm_bus *nvdimm_bus,
  			struct nd_region_desc *ndr_desc);
  
  	/sys/devices/platform/nfit_test.0/ndbus0
  	|-- region0
  	|   |-- available_size
  	|   |-- btt0
  	|   |-- btt_seed
  	|   |-- devtype
  	|   |-- driver -> ../../../../../bus/nd/drivers/nd_region
  	|   |-- init_namespaces
  	|   |-- mapping0
  	|   |-- mapping1
  	|   |-- mappings
  	|   |-- modalias
  	|   |-- namespace0.0
  	|   |-- namespace_seed
  	|   |-- numa_node
  	|   |-- nfit
  	|   |   `-- spa_index
  	|   |-- nstype
  	|   |-- set_cookie
  	|   |-- size
  	|   |-- subsystem -> ../../../../../bus/nd
  	|   `-- uevent
  	|-- region1
  	[..]
  
  LIBNDCTL: region enumeration example
  
  Sample region retrieval routines based on NFIT-unique data like
  "spa_index" (interleave set id) for PMEM and "nfit_handle" (dimm id) for
  BLK.
  
  	static struct ndctl_region *get_pmem_region_by_spa_index(struct ndctl_bus *bus,
  			unsigned int spa_index)
  	{
  		struct ndctl_region *region;
  
  		ndctl_region_foreach(bus, region) {
  			if (ndctl_region_get_type(region) != ND_DEVICE_REGION_PMEM)
  				continue;
  			if (ndctl_region_get_spa_index(region) == spa_index)
  				return region;
  		}
  		return NULL;
  	}
  
  	static struct ndctl_region *get_blk_region_by_dimm_handle(struct ndctl_bus *bus,
  			unsigned int handle)
  	{
  		struct ndctl_region *region;
  
  		ndctl_region_foreach(bus, region) {
  			struct ndctl_mapping *map;
  
  			if (ndctl_region_get_type(region) != ND_DEVICE_REGION_BLOCK)
  				continue;
  			ndctl_mapping_foreach(region, map) {
  				struct ndctl_dimm *dimm = ndctl_mapping_get_dimm(map);
  
  				if (ndctl_dimm_get_handle(dimm) == handle)
  					return region;
  			}
  		}
  		return NULL;
  	}
  
  
  Why Not Encode the Region Type into the Region Name?
  ----------------------------------------------------
  
  At first glance it seems since NFIT defines just PMEM and BLK interface
  types that we should simply name REGION devices with something derived
  from those type names.  However, the ND subsystem explicitly keeps the
  REGION name generic and expects userspace to always consider the

  region-attributes for four reasons:

  
      1. There are already more than two REGION and "namespace" types.  For
      PMEM there are two subtypes.  As mentioned previously we have PMEM where
      the constituent DIMM devices are known and anonymous PMEM.  For BLK
      regions the NFIT specification already anticipates vendor specific
      implementations.  The exact distinction of what a region contains is in
      the region-attributes not the region-name or the region-devtype.
  
      2. A region with zero child-namespaces is a possible configuration.  For
      example, the NFIT allows for a DCR to be published without a
      corresponding BLK-aperture.  This equates to a DIMM that can only accept
      control/configuration messages, but no i/o through a descendant block
      device.  Again, this "type" is advertised in the attributes ('mappings'
      == 0) and the name does not tell you much.
  
      3. What if a third major interface type arises in the future?  Outside
      of vendor specific implementations, it's not difficult to envision a
      third class of interface type beyond BLK and PMEM.  With a generic name
      for the REGION level of the device-hierarchy old userspace
      implementations can still make sense of new kernel advertised
      region-types.  Userspace can always rely on the generic region
      attributes like "mappings", "size", etc and the expected child devices
      named "namespace".  This generic format of the device-model hierarchy
      allows the LIBNVDIMM and LIBNDCTL implementations to be more uniform and
      future-proof.
  
      4. There are more robust mechanisms for determining the major type of a
      region than a device name.  See the next section, How Do I Determine the
      Major Type of a Region?
  
  How Do I Determine the Major Type of a Region?
  ----------------------------------------------
  
  Outside of the blanket recommendation of "use libndctl", or simply
  looking at the kernel header (/usr/include/linux/ndctl.h) to decode the
  "nstype" integer attribute, here are some other options.
  
      1. module alias lookup:
  
      The whole point of region/namespace device type differentiation is to
      decide which block-device driver will attach to a given LIBNVDIMM namespace.
      One can simply use the modalias to lookup the resulting module.  It's
      important to note that this method is robust in the presence of a
      vendor-specific driver down the road.  If a vendor-specific
      implementation wants to supplant the standard nd_blk driver it can with
      minimal impact to the rest of LIBNVDIMM.
  
      In fact, a vendor may also want to have a vendor-specific region-driver
      (outside of nd_region).  For example, if a vendor defined its own LABEL
      format it would need its own region driver to parse that LABEL and emit
      the resulting namespaces.  The output from module resolution is more
      accurate than a region-name or region-devtype.
  
      2. udev:
  
      The kernel "devtype" is registered in the udev database
      # udevadm info --path=/devices/platform/nfit_test.0/ndbus0/region0
      P: /devices/platform/nfit_test.0/ndbus0/region0
      E: DEVPATH=/devices/platform/nfit_test.0/ndbus0/region0
      E: DEVTYPE=nd_pmem
      E: MODALIAS=nd:t2
      E: SUBSYSTEM=nd
  
      # udevadm info --path=/devices/platform/nfit_test.0/ndbus0/region4
      P: /devices/platform/nfit_test.0/ndbus0/region4
      E: DEVPATH=/devices/platform/nfit_test.0/ndbus0/region4
      E: DEVTYPE=nd_blk
      E: MODALIAS=nd:t3
      E: SUBSYSTEM=nd
  
      ...and is available as a region attribute, but keep in mind that the
      "devtype" does not indicate sub-type variations and scripts should
      really be understanding the other attributes.
  
      3. type specific attributes:
  
      As it currently stands a BLK-aperture region will never have a
      "nfit/spa_index" attribute, but neither will a non-NFIT PMEM region.  A
      BLK region with a "mappings" value of 0 is, as mentioned above, a DIMM
      that does not allow I/O.  A PMEM region with a "mappings" value of zero
      is a simple system-physical-address range.
  
  
  LIBNVDIMM/LIBNDCTL: Namespace
  -------------------------
  
  A REGION, after resolving DPA aliasing and LABEL specified boundaries,
  surfaces one or more "namespace" devices.  The arrival of a "namespace"
  device currently triggers either the nd_blk or nd_pmem driver to load
  and register a disk/block device.
  
  LIBNVDIMM: namespace
  Here is a sample layout from the three major types of NAMESPACE where
  namespace0.0 represents DIMM-info-backed PMEM (note that it has a 'uuid'
  attribute), namespace2.0 represents a BLK namespace (note it has a
  'sector_size' attribute) that, and namespace6.0 represents an anonymous
  PMEM namespace (note that has no 'uuid' attribute due to not support a
  LABEL).
  
  	/sys/devices/platform/nfit_test.0/ndbus0/region0/namespace0.0
  	|-- alt_name
  	|-- devtype
  	|-- dpa_extents
  	|-- force_raw
  	|-- modalias
  	|-- numa_node
  	|-- resource
  	|-- size
  	|-- subsystem -> ../../../../../../bus/nd
  	|-- type
  	|-- uevent
  	`-- uuid
  	/sys/devices/platform/nfit_test.0/ndbus0/region2/namespace2.0
  	|-- alt_name
  	|-- devtype
  	|-- dpa_extents
  	|-- force_raw
  	|-- modalias
  	|-- numa_node
  	|-- sector_size
  	|-- size
  	|-- subsystem -> ../../../../../../bus/nd
  	|-- type
  	|-- uevent
  	`-- uuid
  	/sys/devices/platform/nfit_test.1/ndbus1/region6/namespace6.0
  	|-- block
  	|   `-- pmem0
  	|-- devtype
  	|-- driver -> ../../../../../../bus/nd/drivers/pmem
  	|-- force_raw
  	|-- modalias
  	|-- numa_node
  	|-- resource
  	|-- size
  	|-- subsystem -> ../../../../../../bus/nd
  	|-- type
  	`-- uevent
  
  LIBNDCTL: namespace enumeration example
  Namespaces are indexed relative to their parent region, example below.
  These indexes are mostly static from boot to boot, but subsystem makes
  no guarantees in this regard.  For a static namespace identifier use its
  'uuid' attribute.
  
  static struct ndctl_namespace *get_namespace_by_id(struct ndctl_region *region,
                  unsigned int id)
  {
          struct ndctl_namespace *ndns;
  
          ndctl_namespace_foreach(region, ndns)
                  if (ndctl_namespace_get_id(ndns) == id)
                          return ndns;
  
          return NULL;
  }
  
  LIBNDCTL: namespace creation example
  Idle namespaces are automatically created by the kernel if a given
  region has enough available capacity to create a new namespace.
  Namespace instantiation involves finding an idle namespace and
  configuring it.  For the most part the setting of namespace attributes
  can occur in any order, the only constraint is that 'uuid' must be set
  before 'size'.  This enables the kernel to track DPA allocations
  internally with a static identifier.
  
  static int configure_namespace(struct ndctl_region *region,
                  struct ndctl_namespace *ndns,
                  struct namespace_parameters *parameters)
  {
          char devname[50];
  
          snprintf(devname, sizeof(devname), "namespace%d.%d",
                          ndctl_region_get_id(region), paramaters->id);
  
          ndctl_namespace_set_alt_name(ndns, devname);
          /* 'uuid' must be set prior to setting size! */
          ndctl_namespace_set_uuid(ndns, paramaters->uuid);
          ndctl_namespace_set_size(ndns, paramaters->size);
          /* unlike pmem namespaces, blk namespaces have a sector size */
          if (parameters->lbasize)
                  ndctl_namespace_set_sector_size(ndns, parameters->lbasize);
          ndctl_namespace_enable(ndns);
  }
  
  
  Why the Term "namespace"?

      1. Why not "volume" for instance?  "volume" ran the risk of confusing
      ND (libnvdimm subsystem) to a volume manager like device-mapper.

  
      2. The term originated to describe the sub-devices that can be created
      within a NVME controller (see the nvme specification:
      http://www.nvmexpress.org/specifications/), and NFIT namespaces are
      meant to parallel the capabilities and configurability of
      NVME-namespaces.
  
  
  LIBNVDIMM/LIBNDCTL: Block Translation Table "btt"
  ---------------------------------------------
  
  A BTT (design document: http://pmem.io/2014/09/23/btt.html) is a stacked
  block device driver that fronts either the whole block device or a
  partition of a block device emitted by either a PMEM or BLK NAMESPACE.
  
  LIBNVDIMM: btt layout
  Every region will start out with at least one BTT device which is the
  seed device.  To activate it set the "namespace", "uuid", and
  "sector_size" attributes and then bind the device to the nd_pmem or
  nd_blk driver depending on the region type.
  
  	/sys/devices/platform/nfit_test.1/ndbus0/region0/btt0/
  	|-- namespace
  	|-- delete
  	|-- devtype
  	|-- modalias
  	|-- numa_node
  	|-- sector_size
  	|-- subsystem -> ../../../../../bus/nd
  	|-- uevent
  	`-- uuid
  
  LIBNDCTL: btt creation example
  Similar to namespaces an idle BTT device is automatically created per
  region.  Each time this "seed" btt device is configured and enabled a new
  seed is created.  Creating a BTT configuration involves two steps of
  finding and idle BTT and assigning it to consume a PMEM or BLK namespace.
  
  	static struct ndctl_btt *get_idle_btt(struct ndctl_region *region)
  	{
  		struct ndctl_btt *btt;
  
  		ndctl_btt_foreach(region, btt)
  			if (!ndctl_btt_is_enabled(btt)
  					&& !ndctl_btt_is_configured(btt))
  				return btt;
  
  		return NULL;
  	}
  
  	static int configure_btt(struct ndctl_region *region,
  			struct btt_parameters *parameters)
  	{
  		btt = get_idle_btt(region);
  
  		ndctl_btt_set_uuid(btt, parameters->uuid);
  		ndctl_btt_set_sector_size(btt, parameters->sector_size);
  		ndctl_btt_set_namespace(btt, parameters->ndns);
  		/* turn off raw mode device */
  		ndctl_namespace_disable(parameters->ndns);
  		/* turn on btt access */
  		ndctl_btt_enable(btt);
  	}
  
  Once instantiated a new inactive btt seed device will appear underneath
  the region.
  
  Once a "namespace" is removed from a BTT that instance of the BTT device
  will be deleted or otherwise reset to default values.  This deletion is
  only at the device model level.  In order to destroy a BTT the "info
  block" needs to be destroyed.  Note, that to destroy a BTT the media
  needs to be written in raw mode.  By default, the kernel will autodetect
  the presence of a BTT and disable raw mode.  This autodetect behavior
  can be suppressed by enabling raw mode for the namespace via the

  ndctl_namespace_set_raw_mode() API.

  
  
  Summary LIBNDCTL Diagram
  ------------------------

  For the given example above, here is the view of the objects as seen by the
  LIBNDCTL API:

              +---+
              |CTX|    +---------+   +--------------+  +---------------+
              +-+-+  +-> REGION0 +---> NAMESPACE0.0 +--> PMEM8 "pm0.0" |
                |    | +---------+   +--------------+  +---------------+
  +-------+     |    | +---------+   +--------------+  +---------------+
  | DIMM0 <-+   |    +-> REGION1 +---> NAMESPACE1.0 +--> PMEM6 "pm1.0" |
  +-------+ |   |    | +---------+   +--------------+  +---------------+
  | DIMM1 <-+ +-v--+ | +---------+   +--------------+  +---------------+
  +-------+ +-+BUS0+---> REGION2 +-+-> NAMESPACE2.0 +--> ND6  "blk2.0" |
  | DIMM2 <-+ +----+ | +---------+ | +--------------+  +----------------------+
  +-------+ |        |             +-> NAMESPACE2.1 +--> ND5  "blk2.1" | BTT2 |
  | DIMM3 <-+        |               +--------------+  +----------------------+
  +-------+          | +---------+   +--------------+  +---------------+
                     +-> REGION3 +-+-> NAMESPACE3.0 +--> ND4  "blk3.0" |
                     | +---------+ | +--------------+  +----------------------+
                     |             +-> NAMESPACE3.1 +--> ND3  "blk3.1" | BTT1 |
                     |               +--------------+  +----------------------+
                     | +---------+   +--------------+  +---------------+
                     +-> REGION4 +---> NAMESPACE4.0 +--> ND2  "blk4.0" |
                     | +---------+   +--------------+  +---------------+
                     | +---------+   +--------------+  +----------------------+
                     +-> REGION5 +---> NAMESPACE5.0 +--> ND1  "blk5.0" | BTT0 |
                       +---------+   +--------------+  +---------------+------+