On Fri, Apr 17, 2015 at 6:35 PM, Dan Williams <dan.j.williams(a)intel.com&gt; wrote: Looks reasonable. Time to ask my vendor if they can give me ACPI 6.0-compliant firmware. --Andy -- Andy Lutomirski AMA Capital Management, LLC

On Sun, Apr 19, 2015 at 12:46 AM, Boaz Harrosh <boaz(a)plexistor.com&gt; wrote: [..] It still describes how the memory is used which is "reserved" for a driver, I don't see how increasing the verbosity here improves debug given the alternatives, see below... /proc/iomem has these details to differentiate PRAM and PMEM as well as show which driver(s)/device(s) have claimed the range(s). Here is where you can see undefined/unknown types. You're free to submit a standalone patch to change this policy... see the new "OEM-reserved" memory types in ACPI 6. That said, I think we're better off with the current policy. If unknown memory types were treated as permanently-busy back when we initially started experimenting with NVDIMM support (2010) then I doubt the e820-type-12 prototype would ever have escaped the lab. We could have avoided a good amount of confusion.

On Tue, Apr 28, 2015 at 5:46 AM, Christoph Hellwig <hch(a)infradead.org&gt; wrote: Ok, I was able to incorporate all these into v2.

* Dan Williams <dan.j.williams(a)intel.com&gt; wrote: Ok, I'll bite. So why on earth is this whole concept and the naming itself ('drivers/block/nd/' stands for 'NFIT Defined', apparently) revolving around a specific 'firmware' mindset and revolving around specific, weirdly named, overly complicated looking firmware interfaces that come with their own new weird glossary?? Firmware might be a discovery method - or not. A non-volatile device might be e820 enumerated, or PCI discovered - potentially with all discovery handled by the driver. Why do you restrict this driver to a naming and design that is so firmware centric? Discovery matters, but what matters _most_ to devices is actually its runtime properties and runtime implementation - and I sure hope firmware has no active role in that! I really think this is backwards from the get go, it gives me a feeling of someone having spent way too much time in committee and too little time spent thinking about simple, proper kernel design and reusing existing terminology ... Also: + nd - kernel abi / device-model & ndctl - userspace helper library WTF is a 'kernel ABI'?? Thanks, Ingo

1/ Autodetect an NFIT table for the ACPI namespace device with _HID of "ACPI0012" 2/ Skeleton implementation to register an NFIT bus. The NFIT provided by ACPI is the primary method by which platforms will discover NVDIMM resources. However, the intent of the nfit_bus_descriptor abstraction is to contain "provider" specific details, leaving the nd core to be NFIT-provider agnostic. This flexibility is exploited in later patches to implement special purpose providers of test and custom-defined NFITs. Cc: <linux-acpi(a)vger.kernel.org&gt; Cc: Robert Moore <robert.moore(a)intel.com&gt; Cc: Rafael J. Wysocki <rafael.j.wysocki(a)intel.com&gt; Signed-off-by: Dan Williams <dan.j.williams(a)intel.com&gt; --- drivers/block/Kconfig | 2 drivers/block/Makefile | 1 drivers/block/nd/Kconfig | 44 ++++++++++ drivers/block/nd/Makefile | 6 + drivers/block/nd/acpi.c | 112 +++++++++++++++++++++++++ drivers/block/nd/core.c | 48 +++++++++++ drivers/block/nd/nfit.h | 201 +++++++++++++++++++++++++++++++++++++++++++++ 7 files changed, 414 insertions(+) create mode 100644 drivers/block/nd/Kconfig create mode 100644 drivers/block/nd/Makefile create mode 100644 drivers/block/nd/acpi.c create mode 100644 drivers/block/nd/core.c create mode 100644 drivers/block/nd/nfit.h diff --git a/drivers/block/Kconfig b/drivers/block/Kconfig index eb1fed5bd516..dfe40e5ca9bd 100644 --- a/drivers/block/Kconfig +++ b/drivers/block/Kconfig @@ -321,6 +321,8 @@ config BLK_DEV_NVME To compile this driver as a module, choose M here: the module will be called nvme. +source "drivers/block/nd/Kconfig" + config BLK_DEV_SKD tristate "STEC S1120 Block Driver" depends on PCI diff --git a/drivers/block/Makefile b/drivers/block/Makefile index 9cc6c18a1c7e..18b27bb9cd2d 100644 --- a/drivers/block/Makefile +++ b/drivers/block/Makefile @@ -24,6 +24,7 @@ obj-$(CONFIG_CDROM_PKTCDVD) += pktcdvd.o obj-$(CONFIG_MG_DISK) += mg_disk.o obj-$(CONFIG_SUNVDC) += sunvdc.o obj-$(CONFIG_BLK_DEV_NVME) += nvme.o +obj-$(CONFIG_NFIT_DEVICES) += nd/ obj-$(CONFIG_BLK_DEV_SKD) += skd.o obj-$(CONFIG_BLK_DEV_OSD) += osdblk.o diff --git a/drivers/block/nd/Kconfig b/drivers/block/nd/Kconfig new file mode 100644 index 000000000000..5fa74f124b3e --- /dev/null +++ b/drivers/block/nd/Kconfig @@ -0,0 +1,44 @@ +config ND_ARCH_HAS_IOREMAP_CACHE + depends on (X86 || IA64 || ARM || ARM64 || SH || XTENSA) + def_bool y + +menuconfig NFIT_DEVICES + bool "NVDIMM (NFIT) Support" + depends on ND_ARCH_HAS_IOREMAP_CACHE + depends on PHYS_ADDR_T_64BIT + help + Support for non-volatile memory devices defined by the NVDIMM + Firmware Interface Table. (NFIT) On platforms that define an + NFIT, via ACPI, or other means, a "nd_bus" is registered to + advertise PM (persistent memory) namespaces (/dev/pmemX) and + BLOCK (sliding block data window) namespaces (/dev/ndX). A PM + namespace refers to a system-physical-address-range than may + span multiple DIMMs and support DAX (see CONFIG_DAX). A BLOCK + namespace refers to a NVDIMM control region which exposes a + register-based windowed access mode to non-volatile memory. + See the NVDIMM Firmware Interface Table specification for more + details. + +if NFIT_DEVICES + +config ND_CORE + tristate "Core: Generic 'nd' Device Model" + help + Platform agnostic device model for an NFIT-defined bus. + Publishes resources for a NFIT-persistent-memory driver and/or + NFIT-block-data-window driver to attach. Exposes a device + topology under a "ndX" bus device and a "/dev/ndctl<N>" + dimm-ioctl message passing interface per registered NFIT + instance. A userspace library "ndctl" provides an API to + enumerate/manage this subsystem. + +config NFIT_ACPI + tristate "NFIT ACPI: Discover ACPI-Namespace NFIT Devices" + select ND_CORE + depends on ACPI + help + Infrastructure to probe the ACPI namespace for NVDIMMs and + register the platform-global NFIT blob with the core. Also + enables the core to craft ACPI._DSM messages for platform/dimm + configuration. +endif diff --git a/drivers/block/nd/Makefile b/drivers/block/nd/Makefile new file mode 100644 index 000000000000..22701ab7dcae --- /dev/null +++ b/drivers/block/nd/Makefile @@ -0,0 +1,6 @@ +obj-$(CONFIG_ND_CORE) += nd.o +obj-$(CONFIG_NFIT_ACPI) += nd_acpi.o + +nd_acpi-y := acpi.o + +nd-y := core.o diff --git a/drivers/block/nd/acpi.c b/drivers/block/nd/acpi.c new file mode 100644 index 000000000000..48db723d7a90 --- /dev/null +++ b/drivers/block/nd/acpi.c @@ -0,0 +1,112 @@ +/* + * Copyright(c) 2013-2015 Intel Corporation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + */ +#include <linux/list.h> +#include <linux/acpi.h> +#include <linux/mutex.h> +#include <linux/module.h> +#include "nfit.h" + +enum { + NFIT_ACPI_NOTIFY_TABLE = 0x80, +}; + +struct acpi_nfit { + struct nfit_bus_descriptor nfit_desc; + struct acpi_device *dev; + struct nd_bus *nd_bus; +}; + +static int nd_acpi_ctl(struct nfit_bus_descriptor *nfit_desc, + struct nd_dimm *nd_dimm, unsigned int cmd, void *buf, + unsigned int buf_len) +{ + return -ENOTTY; +} + +static int nd_acpi_add(struct acpi_device *dev) +{ + struct nfit_bus_descriptor *nfit_desc; + struct acpi_table_header *tbl; + acpi_status status = AE_OK; + struct acpi_nfit *nfit; + acpi_size sz; + + status = acpi_get_table_with_size("NFIT", 0, &tbl, &sz); + if (ACPI_FAILURE(status)) { + dev_err(&dev->dev, "failed to find NFIT\n"); + return -ENXIO; + } + + nfit = devm_kzalloc(&dev->dev, sizeof(*nfit), GFP_KERNEL); + if (!nfit) + return -ENOMEM; + nfit->dev = dev; + nfit_desc = &nfit->nfit_desc; + nfit_desc->nfit_base = (void __iomem *) tbl; + nfit_desc->nfit_size = sz; + nfit_desc->provider_name = "ACPI.NFIT"; + nfit_desc->nfit_ctl = nd_acpi_ctl; + + nfit->nd_bus = nfit_bus_register(&dev->dev, nfit_desc); + if (!nfit->nd_bus) + return -ENXIO; + + dev_set_drvdata(&dev->dev, nfit); + return 0; +} + +static int nd_acpi_remove(struct acpi_device *dev) +{ + struct acpi_nfit *nfit = dev_get_drvdata(&dev->dev); + + nfit_bus_unregister(nfit->nd_bus); + return 0; +} + +static void nd_acpi_notify(struct acpi_device *dev, u32 event) +{ + /* TODO: handle ACPI_NOTIFY_BUS_CHECK notification */ + dev_dbg(&dev->dev, "%s: event: %d\n", __func__, event); +} + +static const struct acpi_device_id nd_acpi_ids[] = { + { "ACPI0012", 0 }, + { "", 0 }, +}; +MODULE_DEVICE_TABLE(acpi, nd_acpi_ids); + +static struct acpi_driver nd_acpi_driver = { + .name = KBUILD_MODNAME, + .ids = nd_acpi_ids, + .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS, + .ops = { + .add = nd_acpi_add, + .remove = nd_acpi_remove, + .notify = nd_acpi_notify + }, +}; + +static __init int nd_acpi_init(void) +{ + return acpi_bus_register_driver(&nd_acpi_driver); +} + +static __exit void nd_acpi_exit(void) +{ + acpi_bus_unregister_driver(&nd_acpi_driver); +} + +module_init(nd_acpi_init); +module_exit(nd_acpi_exit); +MODULE_LICENSE("GPL v2"); +MODULE_AUTHOR("Intel Corporation"); diff --git a/drivers/block/nd/core.c b/drivers/block/nd/core.c new file mode 100644 index 000000000000..8df8d315b726 --- /dev/null +++ b/drivers/block/nd/core.c @@ -0,0 +1,48 @@ +/* + * Copyright(c) 2013-2015 Intel Corporation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + */ +#include <linux/export.h> +#include <linux/module.h> +#include "nfit.h" + +struct nd_bus *nfit_bus_register(struct device *parent, + struct nfit_bus_descriptor *nfit_desc) +{ + return NULL; +} +EXPORT_SYMBOL(nfit_bus_register); + +void nfit_bus_unregister(struct nd_bus *nd_bus) +{ +} +EXPORT_SYMBOL(nfit_bus_unregister); + +static __init int nd_core_init(void) +{ + BUILD_BUG_ON(sizeof(struct nfit) != 40); + BUILD_BUG_ON(sizeof(struct nfit_spa) != 56); + BUILD_BUG_ON(sizeof(struct nfit_mem) != 48); + BUILD_BUG_ON(sizeof(struct nfit_idt) != 16); + BUILD_BUG_ON(sizeof(struct nfit_smbios) != 8); + BUILD_BUG_ON(sizeof(struct nfit_dcr) != 80); + BUILD_BUG_ON(sizeof(struct nfit_bdw) != 40); + + return 0; +} + +static __exit void nd_core_exit(void) +{ +} +MODULE_LICENSE("GPL v2"); +MODULE_AUTHOR("Intel Corporation"); +module_init(nd_core_init); +module_exit(nd_core_exit); diff --git a/drivers/block/nd/nfit.h b/drivers/block/nd/nfit.h new file mode 100644 index 000000000000..56a3b2dad124 --- /dev/null +++ b/drivers/block/nd/nfit.h @@ -0,0 +1,201 @@ +/* + * NVDIMM Firmware Interface Table - NFIT + * + * Copyright(c) 2013-2015 Intel Corporation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + */ +#ifndef __NFIT_H__ +#define __NFIT_H__ + +#include <linux/types.h> + +enum { + NFIT_TABLE_SPA = 0, + NFIT_TABLE_MEM = 1, + NFIT_TABLE_IDT = 2, + NFIT_TABLE_SMBIOS = 3, + NFIT_TABLE_DCR = 4, + NFIT_TABLE_BDW = 5, + NFIT_TABLE_FLUSH = 6, + NFIT_SPA_VOLATILE = 0, + NFIT_SPA_PM = 1, + NFIT_SPA_DCR = 2, + NFIT_SPA_BDW = 3, + NFIT_SPA_VDISK = 4, + NFIT_SPA_VCD = 5, + NFIT_SPA_PDISK = 6, + NFIT_SPA_PCD = 7, + NFIT_SPAF_DCR_HOT_ADD = 1 << 0, + NFIT_SPAF_PDVALID = 1 << 1, + NFIT_MEMF_SAVE_FAIL = 1 << 0, + NFIT_MEMF_RESTORE_FAIL = 1 << 1, + NFIT_MEMF_FLUSH_FAIL = 1 << 2, + NFIT_MEMF_UNARMED = 1 << 3, + NFIT_MEMF_NOTIFY_SMART = 1 << 4, + NFIT_MEMF_SMART_READY = 1 << 5, + NFIT_DCRF_BUFFERED = 1 << 0, +}; + +/** + * struct nfit - Nvdimm Firmware Interface Table + * @signature: "NFIT" + * @length: sum of size of this table plus all appended subtables + */ +struct nfit { + __u8 signature[4]; + __le32 length; + __u8 revision; + __u8 checksum; + __u8 oemid[6]; + __le64 oem_tbl_id; + __le32 oem_revision; + __le32 creator_id; + __le32 creator_revision; + __le32 reserved; +} __packed; + +/** + * struct nfit_spa - System Physical Address Range Descriptor Table + */ +struct nfit_spa { + __le16 type; + __le16 length; + __le16 spa_index; + __le16 flags; + __le32 reserved; + __le32 proximity_domain; + __u8 type_uuid[16]; + __le64 spa_base; + __le64 spa_length; + __le64 mem_attr; +} __packed; + +/** + * struct nfit_mem - Memory Device to SPA Mapping Table + */ +struct nfit_mem { + __le16 type; + __le16 length; + __le32 nfit_handle; + __le16 phys_id; + __le16 region_id; + __le16 spa_index; + __le16 dcr_index; + __le64 region_len; + __le64 region_spa_offset; + __le64 region_dpa; + __le16 idt_index; + __le16 interleave_ways; + __le16 flags; + __le16 reserved; +} __packed; + +/** + * struct nfit_idt - Interleave description Table + */ +struct nfit_idt { + __le16 type; + __le16 length; + __le16 idt_index; + __le16 reserved; + __le32 num_lines; + __le32 line_size; + __le32 line_offset[0]; +} __packed; + +/** + * struct nfit_smbios - SMBIOS Management Information Table + */ +struct nfit_smbios { + __le16 type; + __le16 length; + __le32 reserved; + __u8 data[0]; +} __packed; + +/** + * struct nfit_dcr - NVDIMM Control Region Table + * @fic: Format Interface Code + * @cmd_offset: command registers relative to block control window + * @status_offset: status registers relative to block control window + */ +struct nfit_dcr { + __le16 type; + __le16 length; + __le16 dcr_index; + __le16 vendor_id; + __le16 device_id; + __le16 revision_id; + __le16 sub_vendor_id; + __le16 sub_device_id; + __le16 sub_revision_id; + __u8 reserved[6]; + __le32 serial_number; + __le16 fic; + __le16 num_bcw; + __le64 bcw_size; + __le64 cmd_offset; + __le64 cmd_size; + __le64 status_offset; + __le64 status_size; + __le16 flags; + __u8 reserved2[6]; +} __packed; + +/** + * struct nfit_bdw - NVDIMM Block Data Window Region Table + */ +struct nfit_bdw { + __le16 type; + __le16 length; + __le16 dcr_index; + __le16 num_bdw; + __le64 bdw_offset; + __le64 bdw_size; + __le64 blk_capacity; + __le64 blk_offset; +} __packed; + +/** + * struct nfit_flush - Flush Hint Address Structure + */ +struct nfit_flush { + __le16 type; + __le16 length; + __le32 nfit_handle; + __le16 num_hints; + __u8 reserved[6]; + __le64 hint_addr[0]; +}; + +struct nd_dimm; +struct nfit_bus_descriptor; +typedef int (*nfit_ctl_fn)(struct nfit_bus_descriptor *nfit_desc, + struct nd_dimm *nd_dimm, unsigned int cmd, void *buf, + unsigned int buf_len); + +typedef int (*nfit_add_dimm_fn)(struct nfit_bus_descriptor *nfit_desc, + struct nd_dimm *nd_dimm); + +struct nfit_bus_descriptor { + unsigned long dsm_mask; + void __iomem *nfit_base; + size_t nfit_size; + char *provider_name; + nfit_ctl_fn nfit_ctl; + nfit_add_dimm_fn add_dimm; +}; + +struct nd_bus; +struct nd_bus *nfit_bus_register(struct device *parent, + struct nfit_bus_descriptor *nfit_desc); +void nfit_bus_unregister(struct nd_bus *nd_bus); +#endif /* __NFIT_H__ */

On Tue, Apr 28, 2015 at 5:53 AM, Christoph Hellwig <hch(a)infradead.org&gt; wrote: Done in v2.

On 4/17/2015 9:35 PM, Dan Williams wrote: : It seems to actually be wanting >= 584MB. -- ljk

On 4/24/2015 5:50 PM, Dan Williams wrote: Thanks. One more question... Since the kernel takes a cma= boot parameter, it would be nice if this check is against what the kernel is using rather than the config option. Is that possible? -- ljk

This is the position (device topology) independent method to find all the NFIT-defined buses in the system. The expectation is that there will only ever be one "nd" bus discovered via /sys/class/nd/ndctl0. However, we allow for the possibility of multiple buses and they will listed in discovery order as ndctl0...ndctlN. This character device hosts the ioctl for passing control messages (as defined by the NFIT spec). The "format" and "revision" attributes of this device identify the format of the messages. In the event an NFIT is registered with an unknown/unsupported control message format then the "format" attribute will not be visible. Cc: Greg KH <gregkh(a)linuxfoundation.org&gt; Cc: Neil Brown <neilb(a)suse.de&gt; Signed-off-by: Dan Williams <dan.j.williams(a)intel.com&gt; --- drivers/block/nd/Makefile | 1 drivers/block/nd/bus.c | 84 +++++++++++++++++++++++++++++++++++++++++ drivers/block/nd/core.c | 71 ++++++++++++++++++++++++++++++++++- drivers/block/nd/nd-private.h | 5 ++ 4 files changed, 160 insertions(+), 1 deletion(-) create mode 100644 drivers/block/nd/bus.c diff --git a/drivers/block/nd/Makefile b/drivers/block/nd/Makefile index c6bec0c185c5..7772fb599809 100644 --- a/drivers/block/nd/Makefile +++ b/drivers/block/nd/Makefile @@ -20,3 +20,4 @@ obj-$(CONFIG_NFIT_ACPI) += nd_acpi.o nd_acpi-y := acpi.o nd-y := core.o +nd-y += bus.o diff --git a/drivers/block/nd/bus.c b/drivers/block/nd/bus.c new file mode 100644 index 000000000000..c27db50511f2 --- /dev/null +++ b/drivers/block/nd/bus.c @@ -0,0 +1,84 @@ +/* + * Copyright(c) 2013-2015 Intel Corporation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + */ +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt +#include <linux/uaccess.h> +#include <linux/fcntl.h> +#include <linux/slab.h> +#include <linux/fs.h> +#include <linux/io.h> +#include "nd-private.h" +#include "nfit.h" + +static int nd_major; +static struct class *nd_class; + +int nd_bus_create_ndctl(struct nd_bus *nd_bus) +{ + dev_t devt = MKDEV(nd_major, nd_bus->id); + struct device *dev; + + dev = device_create(nd_class, &nd_bus->dev, devt, nd_bus, "ndctl%d", + nd_bus->id); + + if (IS_ERR(dev)) { + dev_dbg(&nd_bus->dev, "failed to register ndctl%d: %ld\n", + nd_bus->id, PTR_ERR(dev)); + return PTR_ERR(dev); + } + return 0; +} + +void nd_bus_destroy_ndctl(struct nd_bus *nd_bus) +{ + device_destroy(nd_class, MKDEV(nd_major, nd_bus->id)); +} + +static long nd_ioctl(struct file *file, unsigned int cmd, unsigned long arg) +{ + return -ENXIO; +} + +static const struct file_operations nd_bus_fops = { + .owner = THIS_MODULE, + .open = nonseekable_open, + .unlocked_ioctl = nd_ioctl, + .compat_ioctl = nd_ioctl, + .llseek = noop_llseek, +}; + +int __init nd_bus_init(void) +{ + int rc; + + rc = register_chrdev(0, "ndctl", &nd_bus_fops); + if (rc < 0) + return rc; + nd_major = rc; + + nd_class = class_create(THIS_MODULE, "nd"); + if (IS_ERR(nd_class)) + goto err_class; + + return 0; + + err_class: + unregister_chrdev(nd_major, "ndctl"); + + return rc; +} + +void __exit nd_bus_exit(void) +{ + class_destroy(nd_class); + unregister_chrdev(nd_major, "ndctl"); +} diff --git a/drivers/block/nd/core.c b/drivers/block/nd/core.c index d126799e7ff7..d6a666b9228b 100644 --- a/drivers/block/nd/core.c +++ b/drivers/block/nd/core.c @@ -14,12 +14,15 @@ #include <linux/export.h> #include <linux/module.h> #include <linux/device.h> +#include <linux/mutex.h> #include <linux/slab.h> #include <linux/uuid.h> #include <linux/io.h> #include "nd-private.h" #include "nfit.h" +LIST_HEAD(nd_bus_list); +DEFINE_MUTEX(nd_bus_list_mutex); static DEFINE_IDA(nd_ida); static bool warn_checksum; @@ -68,6 +71,53 @@ struct nd_bus *to_nd_bus(struct device *dev) return nd_bus; } +static const char *nd_bus_provider(struct nd_bus *nd_bus) +{ + struct nfit_bus_descriptor *nfit_desc = nd_bus->nfit_desc; + struct device *parent = nd_bus->dev.parent; + + if (nfit_desc->provider_name) + return nfit_desc->provider_name; + else if (parent) + return dev_name(parent); + else + return "unknown"; +} + +static ssize_t provider_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct nd_bus *nd_bus = to_nd_bus(dev); + + return sprintf(buf, "%s\n", nd_bus_provider(nd_bus)); +} +static DEVICE_ATTR_RO(provider); + +static ssize_t revision_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct nd_bus *nd_bus = to_nd_bus(dev); + struct nfit __iomem *nfit = nd_bus->nfit_desc->nfit_base; + + return sprintf(buf, "%d\n", readb(&nfit->revision)); +} +static DEVICE_ATTR_RO(revision); + +static struct attribute *nd_bus_attributes[] = { + &dev_attr_provider.attr, + &dev_attr_revision.attr, + NULL, +}; + +static struct attribute_group nd_bus_attribute_group = { + .attrs = nd_bus_attributes, +}; + +static const struct attribute_group *nd_bus_attribute_groups[] = { + &nd_bus_attribute_group, + NULL, +}; + static void *nd_bus_new(struct device *parent, struct nfit_bus_descriptor *nfit_desc) { @@ -81,6 +131,7 @@ static void *nd_bus_new(struct device *parent, INIT_LIST_HEAD(&nd_bus->bdws); INIT_LIST_HEAD(&nd_bus->memdevs); INIT_LIST_HEAD(&nd_bus->dimms); + INIT_LIST_HEAD(&nd_bus->list); nd_bus->id = ida_simple_get(&nd_ida, 0, 0, GFP_KERNEL); if (nd_bus->id < 0) { kfree(nd_bus); @@ -89,6 +140,7 @@ static void *nd_bus_new(struct device *parent, nd_bus->nfit_desc = nfit_desc; nd_bus->dev.parent = parent; nd_bus->dev.release = nd_bus_release; + nd_bus->dev.groups = nd_bus_attribute_groups; dev_set_name(&nd_bus->dev, "ndbus%d", nd_bus->id); rc = device_register(&nd_bus->dev); if (rc) { @@ -428,6 +480,14 @@ static struct nd_bus *nd_bus_probe(struct nd_bus *nd_bus) if (rc) goto err; + rc = nd_bus_create_ndctl(nd_bus); + if (rc) + goto err; + + mutex_lock(&nd_bus_list_mutex); + list_add_tail(&nd_bus->list, &nd_bus_list); + mutex_unlock(&nd_bus_list_mutex); + return nd_bus; err: put_device(&nd_bus->dev); @@ -458,6 +518,13 @@ void nfit_bus_unregister(struct nd_bus *nd_bus) { if (!nd_bus) return; + + mutex_lock(&nd_bus_list_mutex); + list_del_init(&nd_bus->list); + mutex_unlock(&nd_bus_list_mutex); + + nd_bus_destroy_ndctl(nd_bus); + device_unregister(&nd_bus->dev); } EXPORT_SYMBOL(nfit_bus_unregister); @@ -472,11 +539,13 @@ static __init int nd_core_init(void) BUILD_BUG_ON(sizeof(struct nfit_dcr) != 80); BUILD_BUG_ON(sizeof(struct nfit_bdw) != 40); - return 0; + return nd_bus_init(); } static __exit void nd_core_exit(void) { + WARN_ON(!list_empty(&nd_bus_list)); + nd_bus_exit(); } MODULE_LICENSE("GPL v2"); MODULE_AUTHOR("Intel Corporation"); diff --git a/drivers/block/nd/nd-private.h b/drivers/block/nd/nd-private.h index 0ede8818f320..4bcc9c96cb4d 100644 --- a/drivers/block/nd/nd-private.h +++ b/drivers/block/nd/nd-private.h @@ -57,5 +57,10 @@ struct nd_mem { struct nfit_spa __iomem *nfit_spa_bdw; struct list_head list; }; + struct nd_bus *to_nd_bus(struct device *dev); +int __init nd_bus_init(void); +void __exit nd_bus_exit(void); +int nd_bus_create_ndctl(struct nd_bus *nd_bus); +void nd_bus_destroy_ndctl(struct nd_bus *nd_bus); #endif /* __ND_PRIVATE_H__ */

On Sat, Apr 18, 2015 at 1:07 AM, Greg KH <gregkh(a)linuxfoundation.org&gt; wrote: Our management library finds nd buses by /sys/class/nd. The nd_ioctl() gets filled out in "[PATCH 08/21] nd: ndctl.h, the nd ioctl abi".

On Fri, Apr 17, 2015 at 09:35:52PM -0400, Dan Williams wrote: Call it nd_bus_major in the previous patch, and avoid the unneeded churn in this patch. thanks, greg k-h

Most configuration of the nd-subsystem is done via nd-sysfs. However, the NFIT specification defines a small set of messages that can be passed to the subsystem via platform-firmware-defined methods. The command set (as of the current version of the NFIT-DSM spec) is: NFIT_CMD_SMART: media health and diagnostics NFIT_CMD_GET_CONFIG_SIZE: size of the label space NFIT_CMD_GET_CONFIG_DATA: read label NFIT_CMD_SET_CONFIG_DATA: write label NFIT_CMD_VENDOR: vendor-specific command passthrough NFIT_CMD_ARS_CAP: report address-range-scrubbing capabilities NFIT_CMD_START_ARS: initiate scrubbing NFIT_CMD_QUERY_ARS: report on scrubbing state NFIT_CMD_SMART_THRESHOLD: configure alarm thresholds for smart events Most of the commands target a specific dimm. However, the address-range-scrubbing commands target the entire NFIT-bus / platform. The 'commands' attribute of an nd-bus, or an nd-dimm enumerate the supported commands for that object. Cc: <linux-acpi(a)vger.kernel.org&gt; Cc: Robert Moore <robert.moore(a)intel.com&gt; Cc: Rafael J. Wysocki <rafael.j.wysocki(a)intel.com&gt; Reported-by: Nicholas Moulin <nicholas.w.moulin(a)linux.intel.com&gt; Signed-off-by: Dan Williams <dan.j.williams(a)intel.com&gt; --- drivers/block/nd/Kconfig | 11 + drivers/block/nd/acpi.c | 333 +++++++++++++++++++++++++++++++++++++++++ drivers/block/nd/bus.c | 230 ++++++++++++++++++++++++++++ drivers/block/nd/core.c | 17 ++ drivers/block/nd/dimm_devs.c | 69 ++++++++ drivers/block/nd/nd-private.h | 11 + drivers/block/nd/nd.h | 21 +++ drivers/block/nd/test/nfit.c | 89 +++++++++++ include/uapi/linux/Kbuild | 1 include/uapi/linux/ndctl.h | 178 ++++++++++++++++++++++ 10 files changed, 950 insertions(+), 10 deletions(-) create mode 100644 drivers/block/nd/nd.h create mode 100644 include/uapi/linux/ndctl.h diff --git a/drivers/block/nd/Kconfig b/drivers/block/nd/Kconfig index 0106b3807202..6c15d10bf4e0 100644 --- a/drivers/block/nd/Kconfig +++ b/drivers/block/nd/Kconfig @@ -42,6 +42,17 @@ config NFIT_ACPI enables the core to craft ACPI._DSM messages for platform/dimm configuration. +config NFIT_ACPI_DEBUG + bool "NFIT ACPI: Turn on extra debugging" + depends on NFIT_ACPI + depends on DYNAMIC_DEBUG + default n + help + Enabling this option causes the nd_acpi driver to dump the + input and output buffers of _DSM operations on the ACPI0012 + device, which can be very verbose. Leave it disabled unless + you are debugging a hardware / firmware issue. + config NFIT_TEST tristate "NFIT TEST: Manufactured NFIT for interface testing" depends on DMA_CMA diff --git a/drivers/block/nd/acpi.c b/drivers/block/nd/acpi.c index 48db723d7a90..073ff28fdbfe 100644 --- a/drivers/block/nd/acpi.c +++ b/drivers/block/nd/acpi.c @@ -13,8 +13,10 @@ #include <linux/list.h> #include <linux/acpi.h> #include <linux/mutex.h> +#include <linux/ndctl.h> #include <linux/module.h> #include "nfit.h" +#include "nd.h" enum { NFIT_ACPI_NOTIFY_TABLE = 0x80, @@ -26,20 +28,330 @@ struct acpi_nfit { struct nd_bus *nd_bus; }; +static struct acpi_nfit *to_acpi_nfit(struct nfit_bus_descriptor *nfit_desc) +{ + return container_of(nfit_desc, struct acpi_nfit, nfit_desc); +} + +#define NFIT_ACPI_MAX_ELEM 4 +struct nfit_cmd_desc { + int in_num; + int out_num; + u32 in_sizes[NFIT_ACPI_MAX_ELEM]; + int out_sizes[NFIT_ACPI_MAX_ELEM]; +}; + +static const struct nfit_cmd_desc nfit_dimm_descs[] = { + [NFIT_CMD_IMPLEMENTED] = { }, + [NFIT_CMD_SMART] = { + .out_num = 2, + .out_sizes = { 4, 8, }, + }, + [NFIT_CMD_SMART_THRESHOLD] = { + .out_num = 2, + .out_sizes = { 4, 8, }, + }, + [NFIT_CMD_DIMM_FLAGS] = { + .out_num = 2, + .out_sizes = { 4, 4 }, + }, + [NFIT_CMD_GET_CONFIG_SIZE] = { + .out_num = 3, + .out_sizes = { 4, 4, 4, }, + }, + [NFIT_CMD_GET_CONFIG_DATA] = { + .in_num = 2, + .in_sizes = { 4, 4, }, + .out_num = 2, + .out_sizes = { 4, UINT_MAX, }, + }, + [NFIT_CMD_SET_CONFIG_DATA] = { + .in_num = 3, + .in_sizes = { 4, 4, UINT_MAX, }, + .out_num = 1, + .out_sizes = { 4, }, + }, + [NFIT_CMD_VENDOR] = { + .in_num = 3, + .in_sizes = { 4, 4, UINT_MAX, }, + .out_num = 3, + .out_sizes = { 4, 4, UINT_MAX, }, + }, +}; + +static const struct nfit_cmd_desc nfit_acpi_descs[] = { + [NFIT_CMD_IMPLEMENTED] = { }, + [NFIT_CMD_ARS_CAP] = { + .in_num = 2, + .in_sizes = { 8, 8, }, + .out_num = 2, + .out_sizes = { 4, 4, }, + }, + [NFIT_CMD_ARS_START] = { + .in_num = 4, + .in_sizes = { 8, 8, 2, 6, }, + .out_num = 1, + .out_sizes = { 4, }, + }, + [NFIT_CMD_ARS_QUERY] = { + .out_num = 2, + .out_sizes = { 4, UINT_MAX, }, + }, +}; + +static u32 to_cmd_in_size(struct nd_dimm *nd_dimm, int cmd, + const struct nfit_cmd_desc *desc, int idx, void *buf) +{ + if (idx >= desc->in_num) + return UINT_MAX; + + if (desc->in_sizes[idx] < UINT_MAX) + return desc->in_sizes[idx]; + + if (nd_dimm && cmd == NFIT_CMD_SET_CONFIG_DATA && idx == 2) { + struct nfit_cmd_set_config_hdr *hdr = buf; + + return hdr->in_length; + } else if (nd_dimm && cmd == NFIT_CMD_VENDOR && idx == 2) { + struct nfit_cmd_vendor_hdr *hdr = buf; + + return hdr->in_length; + } + + return UINT_MAX; +} + +static u32 to_cmd_out_size(struct nd_dimm *nd_dimm, int cmd, + const struct nfit_cmd_desc *desc, int idx, + void *buf, u32 out_length, u32 offset) +{ + if (idx >= desc->out_num) + return UINT_MAX; + + if (desc->out_sizes[idx] < UINT_MAX) + return desc->out_sizes[idx]; + + if (offset >= out_length) + return UINT_MAX; + + if (nd_dimm && cmd == NFIT_CMD_GET_CONFIG_DATA && idx == 1) + return out_length - offset; + else if (nd_dimm && cmd == NFIT_CMD_VENDOR && idx == 2) + return out_length - offset; + else if (!nd_dimm && cmd == NFIT_CMD_ARS_QUERY && idx == 1) + return out_length - offset; + + return UINT_MAX; +} + +static u8 nd_acpi_uuids[2][16]; /* initialized at nd_acpi_init */ + +static u8 *nd_acpi_bus_uuid(void) +{ + return nd_acpi_uuids[0]; +} + +static u8 *nd_acpi_dimm_uuid(void) +{ + return nd_acpi_uuids[1]; +} + static int nd_acpi_ctl(struct nfit_bus_descriptor *nfit_desc, struct nd_dimm *nd_dimm, unsigned int cmd, void *buf, unsigned int buf_len) { - return -ENOTTY; + struct acpi_nfit *nfit = to_acpi_nfit(nfit_desc); + union acpi_object in_obj, in_buf, *out_obj; + const struct nfit_cmd_desc *desc = NULL; + struct device *dev = &nfit->dev->dev; + const char *cmd_name, *dimm_name; + unsigned long dsm_mask; + acpi_handle handle; + u32 offset; + int rc, i; + u8 *uuid; + + if (nd_dimm) { + struct acpi_device *adev = nd_dimm_get_pdata(nd_dimm); + + if (cmd < ARRAY_SIZE(nfit_dimm_descs)) + desc = &nfit_dimm_descs[cmd]; + cmd_name = nfit_dimm_cmd_name(cmd); + dsm_mask = nd_dimm_get_dsm_mask(nd_dimm); + handle = adev->handle; + uuid = nd_acpi_dimm_uuid(); + dimm_name = dev_name(&adev->dev); + } else { + if (cmd < ARRAY_SIZE(nfit_acpi_descs)) + desc = &nfit_acpi_descs[cmd]; + cmd_name = nfit_bus_cmd_name(cmd); + dsm_mask = nfit_desc->dsm_mask; + handle = nfit->dev->handle; + uuid = nd_acpi_bus_uuid(); + dimm_name = "bus"; + } + + if (!desc || (cmd && (desc->out_num + desc->in_num == 0))) + return -ENOTTY; + + if (!test_bit(cmd, &dsm_mask)) + return -ENOTTY; + + in_obj.type = ACPI_TYPE_PACKAGE; + in_obj.package.count = 1; + in_obj.package.elements = &in_buf; + in_buf.type = ACPI_TYPE_BUFFER; + in_buf.buffer.pointer = buf; + in_buf.buffer.length = 0; + + /* double check that the nfit_acpi_cmd_descs table is self consistent */ + if (desc->in_num > NFIT_ACPI_MAX_ELEM) { + WARN_ON_ONCE(1); + return -ENXIO; + } + + for (i = 0; i < desc->in_num; i++) { + u32 in_size; + + in_size = to_cmd_in_size(nd_dimm, cmd, desc, i, buf); + if (in_size == UINT_MAX) { + dev_err(dev, "%s:%s unknown input size cmd: %s field: %d\n", + __func__, dimm_name, cmd_name, i); + return -ENXIO; + } + in_buf.buffer.length += in_size; + if (in_buf.buffer.length > buf_len) { + dev_err(dev, "%s:%s input underrun cmd: %s field: %d\n", + __func__, dimm_name, cmd_name, i); + return -ENXIO; + } + } + + dev_dbg(dev, "%s:%s cmd: %s input length: %d\n", __func__, dimm_name, + cmd_name, in_buf.buffer.length); + if (IS_ENABLED(CONFIG_NFIT_ACPI_DEBUG)) + print_hex_dump_debug(cmd_name, DUMP_PREFIX_OFFSET, 4, + 4, in_buf.buffer.pointer, min_t(u32, 128, + in_buf.buffer.length), true); + + out_obj = acpi_evaluate_dsm(handle, uuid, 1, cmd, &in_obj); + if (!out_obj) { + dev_dbg(dev, "%s:%s _DSM failed cmd: %s\n", __func__, dimm_name, + cmd_name); + return -EINVAL; + } + + if (out_obj->package.type != ACPI_TYPE_BUFFER) { + dev_dbg(dev, "%s:%s unexpected output object type cmd: %s type: %d\n", + __func__, dimm_name, cmd_name, out_obj->type); + rc = -EINVAL; + goto out; + } + + dev_dbg(dev, "%s:%s cmd: %s output length: %d\n", __func__, dimm_name, + cmd_name, out_obj->buffer.length); + if (IS_ENABLED(CONFIG_NFIT_ACPI_DEBUG)) + print_hex_dump_debug(cmd_name, DUMP_PREFIX_OFFSET, 4, + 4, out_obj->buffer.pointer, min_t(u32, 128, + out_obj->buffer.length), true); + + for (i = 0, offset = 0; i < desc->out_num; i++) { + u32 out_size = to_cmd_out_size(nd_dimm, cmd, desc, i, buf, + out_obj->buffer.length, offset); + + if (out_size == UINT_MAX) { + dev_dbg(dev, "%s:%s unknown output size cmd: %s field: %d\n", + __func__, dimm_name, cmd_name, i); + break; + } + + if (offset + out_size > out_obj->buffer.length) { + dev_dbg(dev, "%s:%s output object underflow cmd: %s field: %d\n", + __func__, dimm_name, cmd_name, i); + break; + } + + if (in_buf.buffer.length + offset + out_size > buf_len) { + dev_dbg(dev, "%s:%s output overrun cmd: %s field: %d\n", + __func__, dimm_name, cmd_name, i); + rc = -ENXIO; + goto out; + } + memcpy(buf + in_buf.buffer.length + offset, + out_obj->buffer.pointer + offset, out_size); + offset += out_size; + } + if (offset + in_buf.buffer.length < buf_len) { + if (i >= 1) { + /* + * status valid, return the number of bytes left + * unfilled in the output buffer + */ + rc = buf_len - offset - in_buf.buffer.length; + } else { + dev_err(dev, "%s:%s underrun cmd: %s buf_len: %d out_len: %d\n", + __func__, dimm_name, cmd_name, buf_len, offset); + rc = -ENXIO; + } + } else + rc = 0; + + out: + ACPI_FREE(out_obj); + + return rc; +} + +static int nd_acpi_add_dimm(struct nfit_bus_descriptor *nfit_desc, + struct nd_dimm *nd_dimm) +{ + struct acpi_nfit *nfit = to_acpi_nfit(nfit_desc); + u32 nfit_handle = to_nfit_handle(nd_dimm); + struct device *dev = &nfit->dev->dev; + struct acpi_device *acpi_dimm; + unsigned long dsm_mask = 0; + u8 *uuid = nd_acpi_dimm_uuid(); + unsigned long long sta; + int i, rc = -ENODEV; + acpi_status status; + + acpi_dimm = acpi_find_child_device(nfit->dev, nfit_handle, false); + if (!acpi_dimm) { + dev_err(dev, "no ACPI.NFIT device with _ADR %#x, disabling...\n", + nfit_handle); + return -ENODEV; + } + + status = acpi_evaluate_integer(acpi_dimm->handle, "_STA", NULL, &sta); + if (status == AE_NOT_FOUND) + dev_err(dev, "%s missing _STA, disabling...\n", + dev_name(&acpi_dimm->dev)); + else if (ACPI_FAILURE(status)) + dev_err(dev, "%s failed to retrieve_STA, disabling...\n", + dev_name(&acpi_dimm->dev)); + else if ((sta & ACPI_STA_DEVICE_ENABLED) == 0) + dev_info(dev, "%s disabled by firmware\n", + dev_name(&acpi_dimm->dev)); + else + rc = 0; + + for (i = NFIT_CMD_SMART; i <= NFIT_CMD_VENDOR; i++) + if (acpi_check_dsm(acpi_dimm->handle, uuid, 1, 1ULL << i)) + set_bit(i, &dsm_mask); + nd_dimm_set_dsm_mask(nd_dimm, dsm_mask); + nd_dimm_set_pdata(nd_dimm, acpi_dimm); + return rc; } static int nd_acpi_add(struct acpi_device *dev) { struct nfit_bus_descriptor *nfit_desc; struct acpi_table_header *tbl; + u8 *uuid = nd_acpi_bus_uuid(); acpi_status status = AE_OK; struct acpi_nfit *nfit; acpi_size sz; + int i; status = acpi_get_table_with_size("NFIT", 0, &tbl, &sz); if (ACPI_FAILURE(status)) { @@ -56,6 +368,11 @@ static int nd_acpi_add(struct acpi_device *dev) nfit_desc->nfit_size = sz; nfit_desc->provider_name = "ACPI.NFIT"; nfit_desc->nfit_ctl = nd_acpi_ctl; + nfit_desc->add_dimm = nd_acpi_add_dimm; + + for (i = NFIT_CMD_ARS_CAP; i <= NFIT_CMD_ARS_QUERY; i++) + if (acpi_check_dsm(dev->handle, uuid, 1, 1ULL << i)) + set_bit(i, &nfit_desc->dsm_mask); nfit->nd_bus = nfit_bus_register(&dev->dev, nfit_desc); if (!nfit->nd_bus) @@ -98,6 +415,20 @@ static struct acpi_driver nd_acpi_driver = { static __init int nd_acpi_init(void) { + char *uuids[] = { + /* bus interface */ + "2f10e7a4-9e91-11e4-89d3-123b93f75cba", + /* per-dimm interface */ + "4309ac30-0d11-11e4-9191-0800200c9a66", + }; + int i; + + for (i = 0; i < ARRAY_SIZE(uuids); i++) + if (acpi_str_to_uuid(uuids[i], nd_acpi_uuids[i]) != AE_OK) { + WARN_ON_ONCE(1); + return -ENXIO; + } + return acpi_bus_register_driver(&nd_acpi_driver); } diff --git a/drivers/block/nd/bus.c b/drivers/block/nd/bus.c index e24db67001d0..67a0624c265b 100644 --- a/drivers/block/nd/bus.c +++ b/drivers/block/nd/bus.c @@ -11,15 +11,20 @@ * General Public License for more details. */ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt +#include <linux/vmalloc.h> #include <linux/uaccess.h> #include <linux/fcntl.h> #include <linux/async.h> +#include <linux/ndctl.h> #include <linux/slab.h> #include <linux/fs.h> #include <linux/io.h> +#include <linux/mm.h> #include "nd-private.h" #include "nfit.h" +#include "nd.h" +int nd_dimm_major; static int nd_bus_major; static struct class *nd_class; @@ -84,19 +89,228 @@ void nd_bus_destroy_ndctl(struct nd_bus *nd_bus) device_destroy(nd_class, MKDEV(nd_bus_major, nd_bus->id)); } +static int __nd_ioctl(struct nd_bus *nd_bus, struct nd_dimm *nd_dimm, + int read_only, unsigned int cmd, unsigned long arg) +{ + struct nfit_bus_descriptor *nfit_desc = nd_bus->nfit_desc; + void __user *p = (void __user *) arg; + unsigned long dsm_mask; + size_t buf_len = 0; + void *buf = NULL; + int rc; + + /* check if the command is supported */ + dsm_mask = nd_dimm ? nd_dimm->dsm_mask : nfit_desc->dsm_mask; + if (!test_bit(_IOC_NR(cmd), &dsm_mask)) + return -ENXIO; + + /* fail write commands (when read-only), or unknown commands */ + switch (cmd) { + case NFIT_IOCTL_VENDOR: + case NFIT_IOCTL_SET_CONFIG_DATA: + case NFIT_IOCTL_ARS_START: + if (read_only) + return -EPERM; + /* fallthrough */ + case NFIT_IOCTL_SMART: + case NFIT_IOCTL_DIMM_FLAGS: + case NFIT_IOCTL_GET_CONFIG_SIZE: + case NFIT_IOCTL_GET_CONFIG_DATA: + case NFIT_IOCTL_ARS_CAP: + case NFIT_IOCTL_ARS_QUERY: + case NFIT_IOCTL_SMART_THRESHOLD: + break; + default: + pr_debug("%s: unknown cmd: %d\n", __func__, _IOC_NR(cmd)); + return -ENOTTY; + } + + /* validate input buffer / determine size */ + switch (cmd) { + case NFIT_IOCTL_SMART: + buf_len = sizeof(struct nfit_cmd_smart); + break; + case NFIT_IOCTL_DIMM_FLAGS: + buf_len = sizeof(struct nfit_cmd_dimm_flags); + break; + case NFIT_IOCTL_VENDOR: { + struct nfit_cmd_vendor_hdr nfit_cmd_v; + struct nfit_cmd_vendor_tail nfit_cmd_vt; + + if (!access_ok(VERIFY_WRITE, p, sizeof(nfit_cmd_v))) + return -EFAULT; + if (copy_from_user(&nfit_cmd_v, p, sizeof(nfit_cmd_v))) + return -EFAULT; + buf_len = sizeof(nfit_cmd_v) + nfit_cmd_v.in_length; + if (!access_ok(VERIFY_WRITE, p + buf_len, sizeof(nfit_cmd_vt))) + return -EFAULT; + if (copy_from_user(&nfit_cmd_vt, p + buf_len, + sizeof(nfit_cmd_vt))) + return -EFAULT; + buf_len += sizeof(nfit_cmd_vt) + nfit_cmd_vt.out_length; + break; + } + case NFIT_IOCTL_SET_CONFIG_DATA: { + struct nfit_cmd_set_config_hdr nfit_cmd_set; + + if (!access_ok(VERIFY_WRITE, p, sizeof(nfit_cmd_set))) + return -EFAULT; + if (copy_from_user(&nfit_cmd_set, p, sizeof(nfit_cmd_set))) + return -EFAULT; + /* include input buffer size and trailing status */ + buf_len = sizeof(nfit_cmd_set) + nfit_cmd_set.in_length + 4; + break; + } + case NFIT_IOCTL_ARS_START: + buf_len = sizeof(struct nfit_cmd_ars_start); + break; + case NFIT_IOCTL_GET_CONFIG_SIZE: + buf_len = sizeof(struct nfit_cmd_get_config_size); + break; + case NFIT_IOCTL_GET_CONFIG_DATA: { + struct nfit_cmd_get_config_data_hdr nfit_cmd_get; + + if (!access_ok(VERIFY_WRITE, p, sizeof(nfit_cmd_get))) + return -EFAULT; + if (copy_from_user(&nfit_cmd_get, p, sizeof(nfit_cmd_get))) + return -EFAULT; + buf_len = sizeof(nfit_cmd_get) + nfit_cmd_get.in_length; + break; + } + case NFIT_IOCTL_ARS_CAP: + buf_len = sizeof(struct nfit_cmd_ars_cap); + break; + case NFIT_IOCTL_ARS_QUERY: { + struct nfit_cmd_ars_query nfit_cmd_query; + + if (!access_ok(VERIFY_WRITE, p, sizeof(nfit_cmd_query))) + return -EFAULT; + if (copy_from_user(&nfit_cmd_query, p, sizeof(nfit_cmd_query))) + return -EFAULT; + buf_len = sizeof(nfit_cmd_query) + nfit_cmd_query.out_length + - offsetof(struct nfit_cmd_ars_query, out_length); + break; + } + case NFIT_IOCTL_SMART_THRESHOLD: + buf_len = sizeof(struct nfit_cmd_smart_threshold); + break; + } + + if (!access_ok(VERIFY_WRITE, p, sizeof(buf_len))) + return -EFAULT; + + if (buf_len > ND_IOCTL_MAX_BUFLEN) { + pr_debug("%s: buf_len: %zd > %d\n", + __func__, buf_len, ND_IOCTL_MAX_BUFLEN); + return -EINVAL; + } + + if (buf_len < KMALLOC_MAX_SIZE) + buf = kmalloc(buf_len, GFP_KERNEL); + + if (!buf) + buf = vmalloc(buf_len); + + if (!buf) + return -ENOMEM; + + if (copy_from_user(buf, p, buf_len)) { + rc = -EFAULT; + goto out; + } + + rc = nfit_desc->nfit_ctl(nfit_desc, nd_dimm, _IOC_NR(cmd), buf, buf_len); + if (rc < 0) + goto out; + if (copy_to_user(p, buf, buf_len)) + rc = -EFAULT; + out: + if (is_vmalloc_addr(buf)) + vfree(buf); + else + kfree(buf); + return rc; +} + static long nd_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - return -ENXIO; + long id = (long) file->private_data; + int rc = -ENXIO, read_only; + struct nd_bus *nd_bus; + + read_only = (O_RDWR != (file->f_flags & O_ACCMODE)); + mutex_lock(&nd_bus_list_mutex); + list_for_each_entry(nd_bus, &nd_bus_list, list) { + if (nd_bus->id == id) { + rc = __nd_ioctl(nd_bus, NULL, read_only, cmd, arg); + break; + } + } + mutex_unlock(&nd_bus_list_mutex); + + return rc; +} + +static int match_dimm(struct device *dev, void *data) +{ + long id = (long) data; + + if (is_nd_dimm(dev)) { + struct nd_dimm *nd_dimm = to_nd_dimm(dev); + + return nd_dimm->id == id; + } + + return 0; +} + +static long nd_dimm_ioctl(struct file *file, unsigned int cmd, unsigned long arg) +{ + int rc = -ENXIO, read_only; + struct nd_bus *nd_bus; + + read_only = (O_RDWR != (file->f_flags & O_ACCMODE)); + mutex_lock(&nd_bus_list_mutex); + list_for_each_entry(nd_bus, &nd_bus_list, list) { + struct device *dev = device_find_child(&nd_bus->dev, + file->private_data, match_dimm); + + if (!dev) + continue; + + rc = __nd_ioctl(nd_bus, to_nd_dimm(dev), read_only, cmd, arg); + put_device(dev); + break; + } + mutex_unlock(&nd_bus_list_mutex); + + return rc; +} + +static int nd_open(struct inode *inode, struct file *file) +{ + long minor = iminor(inode); + + file->private_data = (void *) minor; + return 0; } static const struct file_operations nd_bus_fops = { .owner = THIS_MODULE, - .open = nonseekable_open, + .open = nd_open, .unlocked_ioctl = nd_ioctl, .compat_ioctl = nd_ioctl, .llseek = noop_llseek, }; +static const struct file_operations nd_dimm_fops = { + .owner = THIS_MODULE, + .open = nd_open, + .unlocked_ioctl = nd_dimm_ioctl, + .compat_ioctl = nd_dimm_ioctl, + .llseek = noop_llseek, +}; + int __init nd_bus_init(void) { int rc; @@ -107,9 +321,14 @@ int __init nd_bus_init(void) rc = register_chrdev(0, "ndctl", &nd_bus_fops); if (rc < 0) - goto err_chrdev; + goto err_bus_chrdev; nd_bus_major = rc; + rc = register_chrdev(0, "dimmctl", &nd_dimm_fops); + if (rc < 0) + goto err_dimm_chrdev; + nd_dimm_major = rc; + nd_class = class_create(THIS_MODULE, "nd"); if (IS_ERR(nd_class)) goto err_class; @@ -117,8 +336,10 @@ int __init nd_bus_init(void) return 0; err_class: + unregister_chrdev(nd_dimm_major, "dimmctl"); + err_dimm_chrdev: unregister_chrdev(nd_bus_major, "ndctl"); - err_chrdev: + err_bus_chrdev: bus_unregister(&nd_bus_type); return rc; @@ -128,5 +349,6 @@ void __exit nd_bus_exit(void) { class_destroy(nd_class); unregister_chrdev(nd_bus_major, "ndctl"); + unregister_chrdev(nd_dimm_major, "dimmctl"); bus_unregister(&nd_bus_type); } diff --git a/drivers/block/nd/core.c b/drivers/block/nd/core.c index a0d1623b3641..0df1e82fcb18 100644 --- a/drivers/block/nd/core.c +++ b/drivers/block/nd/core.c @@ -14,12 +14,14 @@ #include <linux/export.h> #include <linux/module.h> #include <linux/device.h> +#include <linux/ndctl.h> #include <linux/mutex.h> #include <linux/slab.h> #include <linux/uuid.h> #include <linux/io.h> #include "nd-private.h" #include "nfit.h" +#include "nd.h" LIST_HEAD(nd_bus_list); DEFINE_MUTEX(nd_bus_list_mutex); @@ -102,6 +104,20 @@ struct nd_bus *walk_to_nd_bus(struct device *nd_dev) return NULL; } +static ssize_t commands_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + int cmd, len = 0; + struct nd_bus *nd_bus = to_nd_bus(dev); + struct nfit_bus_descriptor *nfit_desc = nd_bus->nfit_desc; + + for_each_set_bit(cmd, &nfit_desc->dsm_mask, BITS_PER_LONG) + len += sprintf(buf + len, "%s ", nfit_bus_cmd_name(cmd)); + len += sprintf(buf + len, "\n"); + return len; +} +static DEVICE_ATTR_RO(commands); + static const char *nd_bus_provider(struct nd_bus *nd_bus) { struct nfit_bus_descriptor *nfit_desc = nd_bus->nfit_desc; @@ -135,6 +151,7 @@ static ssize_t revision_show(struct device *dev, static DEVICE_ATTR_RO(revision); static struct attribute *nd_bus_attributes[] = { + &dev_attr_commands.attr, &dev_attr_provider.attr, &dev_attr_revision.attr, NULL, diff --git a/drivers/block/nd/dimm_devs.c b/drivers/block/nd/dimm_devs.c index b74b23c297fb..b73006cfbf66 100644 --- a/drivers/block/nd/dimm_devs.c +++ b/drivers/block/nd/dimm_devs.c @@ -12,12 +12,14 @@ */ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #include <linux/device.h> +#include <linux/ndctl.h> #include <linux/slab.h> #include <linux/io.h> #include <linux/fs.h> #include <linux/mm.h> #include "nd-private.h" #include "nfit.h" +#include "nd.h" static DEFINE_IDA(dimm_ida); @@ -35,7 +37,7 @@ static struct device_type nd_dimm_device_type = { .release = nd_dimm_release, }; -static bool is_nd_dimm(struct device *dev) +bool is_nd_dimm(struct device *dev) { return dev->type == &nd_dimm_device_type; } @@ -66,12 +68,48 @@ static struct nfit_dcr __iomem *to_nfit_dcr(struct device *dev) return nfit_dcr; } +u32 to_nfit_handle(struct nd_dimm *nd_dimm) +{ + struct nfit_mem __iomem *nfit_mem = nd_dimm->nd_mem->nfit_mem_dcr; + + return readl(&nfit_mem->nfit_handle); +} +EXPORT_SYMBOL(to_nfit_handle); + +void *nd_dimm_get_pdata(struct nd_dimm *nd_dimm) +{ + if (nd_dimm) + return nd_dimm->provider_data; + return NULL; +} +EXPORT_SYMBOL(nd_dimm_get_pdata); + +void nd_dimm_set_pdata(struct nd_dimm *nd_dimm, void *data) +{ + if (nd_dimm) + nd_dimm->provider_data = data; +} +EXPORT_SYMBOL(nd_dimm_set_pdata); + +unsigned long nd_dimm_get_dsm_mask(struct nd_dimm *nd_dimm) +{ + if (nd_dimm) + return nd_dimm->dsm_mask; + return 0; +} +EXPORT_SYMBOL(nd_dimm_get_dsm_mask); + +void nd_dimm_set_dsm_mask(struct nd_dimm *nd_dimm, unsigned long dsm_mask) +{ + if (nd_dimm) + nd_dimm->dsm_mask = dsm_mask; +} +EXPORT_SYMBOL(nd_dimm_set_dsm_mask); + static ssize_t handle_show(struct device *dev, struct device_attribute *attr, char *buf) { - struct nfit_mem __iomem *nfit_mem = to_nfit_mem(dev); - - return sprintf(buf, "%#x\n", readl(&nfit_mem->nfit_handle)); + return sprintf(buf, "%#x\n", to_nfit_handle(to_nd_dimm(dev))); } static DEVICE_ATTR_RO(handle); @@ -129,6 +167,19 @@ static ssize_t serial_show(struct device *dev, } static DEVICE_ATTR_RO(serial); +static ssize_t commands_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct nd_dimm *nd_dimm = to_nd_dimm(dev); + int cmd, len = 0; + + for_each_set_bit(cmd, &nd_dimm->dsm_mask, BITS_PER_LONG) + len += sprintf(buf + len, "%s ", nfit_dimm_cmd_name(cmd)); + len += sprintf(buf + len, "\n"); + return len; +} +static DEVICE_ATTR_RO(commands); + static struct attribute *nd_dimm_attributes[] = { &dev_attr_handle.attr, &dev_attr_phys_id.attr, @@ -137,6 +188,7 @@ static struct attribute *nd_dimm_attributes[] = { &dev_attr_format.attr, &dev_attr_serial.attr, &dev_attr_revision.attr, + &dev_attr_commands.attr, NULL, }; @@ -166,6 +218,7 @@ static struct nd_dimm *nd_dimm_create(struct nd_bus *nd_bus, struct nd_mem *nd_mem) { struct nd_dimm *nd_dimm = kzalloc(sizeof(*nd_dimm), GFP_KERNEL); + struct nfit_bus_descriptor *nfit_desc = nd_bus->nfit_desc; struct device *dev; u32 nfit_handle; @@ -193,6 +246,14 @@ static struct nd_dimm *nd_dimm_create(struct nd_bus *nd_bus, dev->type = &nd_dimm_device_type; dev->bus = &nd_bus_type; dev->groups = nd_dimm_attribute_groups; + dev->devt = MKDEV(nd_dimm_major, nd_dimm->id); + if (nfit_desc->add_dimm) + if (nfit_desc->add_dimm(nfit_desc, nd_dimm) != 0) { + device_initialize(dev); + put_device(dev); + return NULL; + } + if (device_register(dev) != 0) { put_device(dev); return NULL; diff --git a/drivers/block/nd/nd-private.h b/drivers/block/nd/nd-private.h index 58a52c03f5ee..31239942b724 100644 --- a/drivers/block/nd/nd-private.h +++ b/drivers/block/nd/nd-private.h @@ -14,9 +14,17 @@ #define __ND_PRIVATE_H__ #include <linux/radix-tree.h> #include <linux/device.h> +#include <linux/sizes.h> + extern struct list_head nd_bus_list; extern struct mutex nd_bus_list_mutex; extern struct bus_type nd_bus_type; +extern int nd_dimm_major; + +enum { + /* need to set a limit somewhere, but yes, this is likely overkill */ + ND_IOCTL_MAX_BUFLEN = SZ_4M, +}; struct nd_bus { struct nfit_bus_descriptor *nfit_desc; @@ -32,8 +40,10 @@ struct nd_bus { }; struct nd_dimm { + unsigned long dsm_mask; struct nd_mem *nd_mem; struct device dev; + void *provider_data; int id; struct nd_dimm_delete { struct nd_bus *nd_bus; @@ -72,6 +82,7 @@ struct nd_mem { }; struct nd_dimm *nd_dimm_by_handle(struct nd_bus *nd_bus, u32 nfit_handle); +bool is_nd_dimm(struct device *dev); struct nd_bus *to_nd_bus(struct device *dev); struct nd_dimm *to_nd_dimm(struct device *dev); struct nd_bus *walk_to_nd_bus(struct device *nd_dev); diff --git a/drivers/block/nd/nd.h b/drivers/block/nd/nd.h new file mode 100644 index 000000000000..bf6313fffd4c --- /dev/null +++ b/drivers/block/nd/nd.h @@ -0,0 +1,21 @@ +/* + * Copyright(c) 2013-2015 Intel Corporation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + */ +#ifndef __ND_H__ +#define __ND_H__ +struct nd_dimm; +u32 to_nfit_handle(struct nd_dimm *nd_dimm); +void *nd_dimm_get_pdata(struct nd_dimm *nd_dimm); +void nd_dimm_set_pdata(struct nd_dimm *nd_dimm, void *data); +unsigned long nd_dimm_get_dsm_mask(struct nd_dimm *nd_dimm); +void nd_dimm_set_dsm_mask(struct nd_dimm *nd_dimm, unsigned long dsm_mask); +#endif /* __ND_H__ */ diff --git a/drivers/block/nd/test/nfit.c b/drivers/block/nd/test/nfit.c index 61227dec111a..e9fb9da765b9 100644 --- a/drivers/block/nd/test/nfit.c +++ b/drivers/block/nd/test/nfit.c @@ -14,10 +14,12 @@ #include <linux/platform_device.h> #include <linux/dma-mapping.h> #include <linux/module.h> +#include <linux/ndctl.h> #include <linux/sizes.h> #include <linux/slab.h> #include "nfit_test.h" #include "../nfit.h" +#include "../nd.h" #include <asm-generic/io-64-nonatomic-lo-hi.h> @@ -138,11 +140,94 @@ static struct nfit_test *to_nfit_test(struct device *dev) return container_of(pdev, struct nfit_test, pdev); } +static int nfit_test_add_dimm(struct nfit_bus_descriptor *nfit_desc, + struct nd_dimm *nd_dimm) +{ + u32 nfit_handle = to_nfit_handle(nd_dimm); + unsigned long dsm_mask = 0; + long i; + + for (i = 0; i < ARRAY_SIZE(handle); i++) + if (nfit_handle == handle[i]) + break; + if (i >= ARRAY_SIZE(handle)) + return -EINVAL; + + set_bit(NFIT_CMD_GET_CONFIG_SIZE, &dsm_mask); + set_bit(NFIT_CMD_GET_CONFIG_DATA, &dsm_mask); + set_bit(NFIT_CMD_SET_CONFIG_DATA, &dsm_mask); + nd_dimm_set_dsm_mask(nd_dimm, dsm_mask); + nd_dimm_set_pdata(nd_dimm, (void *) i); + return 0; +} + static int nfit_test_ctl(struct nfit_bus_descriptor *nfit_desc, struct nd_dimm *nd_dimm, unsigned int cmd, void *buf, unsigned int buf_len) { - return -ENOTTY; + struct nfit_test *t = container_of(nfit_desc, typeof(*t), nfit_desc); + unsigned long dsm_mask = nd_dimm_get_dsm_mask(nd_dimm); + int i, rc; + + if (!nd_dimm || !test_bit(cmd, &dsm_mask)) + return -ENXIO; + + /* lookup label space for the given dimm */ + i = (long) nd_dimm_get_pdata(nd_dimm); + + switch (cmd) { + case NFIT_CMD_GET_CONFIG_SIZE: { + struct nfit_cmd_get_config_size *nfit_cmd = buf; + + if (buf_len < sizeof(*nfit_cmd)) + return -EINVAL; + nfit_cmd->status = 0; + nfit_cmd->config_size = LABEL_SIZE; + nfit_cmd->max_xfer = SZ_4K; + rc = 0; + break; + } + case NFIT_CMD_GET_CONFIG_DATA: { + struct nfit_cmd_get_config_data_hdr *nfit_cmd = buf; + unsigned int len, offset = nfit_cmd->in_offset; + + if (buf_len < sizeof(*nfit_cmd)) + return -EINVAL; + if (offset >= LABEL_SIZE) + return -EINVAL; + if (nfit_cmd->in_length + sizeof(*nfit_cmd) > buf_len) + return -EINVAL; + + nfit_cmd->status = 0; + len = min(nfit_cmd->in_length, LABEL_SIZE - offset); + memcpy(nfit_cmd->out_buf, t->label[i] + offset, len); + rc = buf_len - sizeof(*nfit_cmd) - len; + break; + } + case NFIT_CMD_SET_CONFIG_DATA: { + struct nfit_cmd_set_config_hdr *nfit_cmd = buf; + unsigned int len, offset = nfit_cmd->in_offset; + u32 *status; + + if (buf_len < sizeof(*nfit_cmd)) + return -EINVAL; + if (offset >= LABEL_SIZE) + return -EINVAL; + if (nfit_cmd->in_length + sizeof(*nfit_cmd) + 4 > buf_len) + return -EINVAL; + + status = buf + nfit_cmd->in_length + sizeof(*nfit_cmd); + *status = 0; + len = min(nfit_cmd->in_length, LABEL_SIZE - offset); + memcpy(t->label[i] + offset, nfit_cmd->in_buf, len); + rc = buf_len - sizeof(*nfit_cmd) - (len + 4); + break; + } + default: + return -ENOTTY; + } + + return rc; } static DEFINE_SPINLOCK(nfit_test_lock); @@ -234,6 +319,7 @@ static int nfit_test0_alloc(struct nfit_test *t) t->label[i] = alloc_coherent(t, LABEL_SIZE, &t->label_dma[i]); if (!t->label[i]) return -ENOMEM; + sprintf(t->label[i], "label%d", i); } for (i = 0; i < NUM_DCR; i++) { @@ -726,6 +812,7 @@ static void nfit_test0_setup(struct nfit_test *t) nfit_desc = &t->nfit_desc; nfit_desc->nfit_ctl = nfit_test_ctl; + nfit_desc->add_dimm = nfit_test_add_dimm; } static void nfit_test1_setup(struct nfit_test *t) diff --git a/include/uapi/linux/Kbuild b/include/uapi/linux/Kbuild index 68ceb97c458c..384e8d212b04 100644 --- a/include/uapi/linux/Kbuild +++ b/include/uapi/linux/Kbuild @@ -270,6 +270,7 @@ header-y += ncp_fs.h header-y += ncp.h header-y += ncp_mount.h header-y += ncp_no.h +header-y += ndctl.h header-y += neighbour.h header-y += netconf.h header-y += netdevice.h diff --git a/include/uapi/linux/ndctl.h b/include/uapi/linux/ndctl.h new file mode 100644 index 000000000000..6cc8c91a0058 --- /dev/null +++ b/include/uapi/linux/ndctl.h @@ -0,0 +1,178 @@ +/* + * Copyright (c) 2014-2015, Intel Corporation. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU Lesser General Public License, + * version 2.1, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for + * more details. + */ +#ifndef __NDCTL_H__ +#define __NDCTL_H__ + +#include <linux/types.h> + +struct nfit_cmd_smart { + __u32 status; + __u8 data[128]; +} __packed; + +struct nfit_cmd_smart_threshold { + __u32 status; + __u8 data[8]; +} __packed; + +struct nfit_cmd_dimm_flags { + __u32 status; + __u32 flags; +} __packed; + +struct nfit_cmd_get_config_size { + __u32 status; + __u32 config_size; + __u32 max_xfer; +} __packed; + +struct nfit_cmd_get_config_data_hdr { + __u32 in_offset; + __u32 in_length; + __u32 status; + __u8 out_buf[0]; +} __packed; + +struct nfit_cmd_set_config_hdr { + __u32 in_offset; + __u32 in_length; + __u8 in_buf[0]; +} __packed; + +struct nfit_cmd_vendor_hdr { + __u32 opcode; + __u32 in_length; + __u8 in_buf[0]; +} __packed; + +struct nfit_cmd_vendor_tail { + __u32 status; + __u32 out_length; + __u8 out_buf[0]; +} __packed; + +struct nfit_cmd_ars_cap { + __u64 address; + __u64 length; + __u32 status; + __u32 max_ars_out; +} __packed; + +struct nfit_cmd_ars_start { + __u64 address; + __u64 length; + __u16 type; + __u8 reserved[6]; + __u32 status; +} __packed; + +struct nfit_cmd_ars_query { + __u32 status; + __u16 out_length; + __u64 address; + __u64 length; + __u16 type; + __u32 num_records; + struct nfit_ars_record { + __u32 nfit_handle; + __u32 flags; + __u64 err_address; + __u64 mask; + } __packed records[0]; +} __packed; + +enum { + NFIT_CMD_IMPLEMENTED = 0, + + /* bus commands */ + NFIT_CMD_ARS_CAP = 1, + NFIT_CMD_ARS_START = 2, + NFIT_CMD_ARS_QUERY = 3, + + /* per-dimm commands */ + NFIT_CMD_SMART = 1, + NFIT_CMD_SMART_THRESHOLD = 2, + NFIT_CMD_DIMM_FLAGS = 3, + NFIT_CMD_GET_CONFIG_SIZE = 4, + NFIT_CMD_GET_CONFIG_DATA = 5, + NFIT_CMD_SET_CONFIG_DATA = 6, + NFIT_CMD_VENDOR_EFFECT_LOG_SIZE = 7, + NFIT_CMD_VENDOR_EFFECT_LOG = 8, + NFIT_CMD_VENDOR = 9, +}; + +static inline const char *nfit_bus_cmd_name(unsigned cmd) +{ + static const char * const names[] = { + [NFIT_CMD_ARS_CAP] = "ars_cap", + [NFIT_CMD_ARS_START] = "ars_start", + [NFIT_CMD_ARS_QUERY] = "ars_query", + }; + + if (cmd < ARRAY_SIZE(names) && names[cmd]) + return names[cmd]; + return "unknown"; +} + +static inline const char *nfit_dimm_cmd_name(unsigned cmd) +{ + static const char * const names[] = { + [NFIT_CMD_SMART] = "smart", + [NFIT_CMD_SMART_THRESHOLD] = "smart_thresh", + [NFIT_CMD_DIMM_FLAGS] = "flags", + [NFIT_CMD_GET_CONFIG_SIZE] = "get_size", + [NFIT_CMD_GET_CONFIG_DATA] = "get_data", + [NFIT_CMD_SET_CONFIG_DATA] = "set_data", + [NFIT_CMD_VENDOR_EFFECT_LOG_SIZE] = "effect_size", + [NFIT_CMD_VENDOR_EFFECT_LOG] = "effect_log", + [NFIT_CMD_VENDOR] = "vendor", + }; + + if (cmd < ARRAY_SIZE(names) && names[cmd]) + return names[cmd]; + return "unknown"; +} + +#define ND_IOCTL 'N' + +#define NFIT_IOCTL_SMART _IOWR(ND_IOCTL, NFIT_CMD_SMART,\ + struct nfit_cmd_smart) + +#define NFIT_IOCTL_SMART_THRESHOLD _IOWR(ND_IOCTL, NFIT_CMD_SMART_THRESHOLD,\ + struct nfit_cmd_smart_threshold) + +#define NFIT_IOCTL_DIMM_FLAGS _IOWR(ND_IOCTL, NFIT_CMD_DIMM_FLAGS,\ + struct nfit_cmd_dimm_flags) + +#define NFIT_IOCTL_GET_CONFIG_SIZE _IOWR(ND_IOCTL, NFIT_CMD_GET_CONFIG_SIZE,\ + struct nfit_cmd_get_config_size) + +#define NFIT_IOCTL_GET_CONFIG_DATA _IOWR(ND_IOCTL, NFIT_CMD_GET_CONFIG_DATA,\ + struct nfit_cmd_get_config_data_hdr) + +#define NFIT_IOCTL_SET_CONFIG_DATA _IOWR(ND_IOCTL, NFIT_CMD_SET_CONFIG_DATA,\ + struct nfit_cmd_set_config_hdr) + +#define NFIT_IOCTL_VENDOR _IOWR(ND_IOCTL, NFIT_CMD_VENDOR,\ + struct nfit_cmd_vendor_hdr) + +#define NFIT_IOCTL_ARS_CAP _IOWR(ND_IOCTL, NFIT_CMD_ARS_CAP,\ + struct nfit_cmd_ars_cap) + +#define NFIT_IOCTL_ARS_START _IOWR(ND_IOCTL, NFIT_CMD_ARS_START,\ + struct nfit_cmd_ars_start) + +#define NFIT_IOCTL_ARS_QUERY _IOWR(ND_IOCTL, NFIT_CMD_ARS_QUERY,\ + struct nfit_cmd_ars_query) + +#endif /* __NDCTL_H__ */

On Tue, Apr 21, 2015 at 2:20 PM, Toshi Kani <toshi.kani(a)hp.com&gt; wrote: Ok, I'll take a look. [..] At this point we've already determined that a dimm device is present because nd_acpi_add_dimm() is called for each dimm found in the NFIT. Does that count as "enumerable" and require an _STA?

A "region" device represents the maximum capacity of a block-data-window, or an interleaved spa range (direct-access persistent memory or volatile memory), without regard for aliasing. Aliasing is resolved by the label data on the dimm to designate which exclusive interface will access the aliased data. Enabling for the label-designated sub-device is in a subsequent patch. The "region" types are defined in the NFIT System Physical Address (spa) table. In the case of persistent memory the spa-range describes the direct memory address range of the storage (NFIT_SPA_PM). A block "region" region (NFIT_SPA_DCR) points to a DIMM Control Region (DCR) or an interleaved group of DCRs. Those DCRs are (optionally) referenced by a block-data-window (BDW) set to describe the access mechanism and capacity of the BLK-accessible storage. If the related BDW is not published then the dimm is only available for control/configuration commands. Finally, a volatile "region" (NFIT_SPA_VOLATILE) indicates the portions of NVDIMMs that have been re-assigned as normal volatile system memory by platform firmware. The name format of "region" devices is "regionN" where, like dimms, N is a global ida index assigned at discovery time. This id is not reliable across reboots nor in the presence of hotplug. Look to attributes of the region or static id-data of the sub-namespace to generate a persistent name. "region"s have 2 generic attributes "size", and "mapping"s where: - size: the block-data-window accessible capacity or the span of the spa-range in the case of pm. - mappingN: a tuple describing a dimm's contribution to the region's capacity in the format (<nfit-dimm-handle>,<dpa>,<size>). For a pm-region there will be at least one mapping per dimm in the interleave set. For a block-region there is only "mapping0" listing the starting dimm offset of the block-data-window and the available capacity of that window (matches "size" above). The max number of mappings per "region" is hard coded per the constraints of sysfs attribute groups. That said the number of mappings per region should never exceed the maximum number of possible dimms in the system. If the current number turns out to not be enough then the "mappings" attribute clarifies how many there are supposed to be. "32 should be enough for anybody...". Cc: Greg KH <gregkh(a)linuxfoundation.org&gt; Cc: Neil Brown <neilb(a)suse.de&gt; Signed-off-by: Dan Williams <dan.j.williams(a)intel.com&gt; --- drivers/block/nd/Makefile | 1 drivers/block/nd/core.c | 8 + drivers/block/nd/nd-private.h | 5 drivers/block/nd/nd.h | 17 ++ drivers/block/nd/region_devs.c | 426 ++++++++++++++++++++++++++++++++++++++++ 5 files changed, 455 insertions(+), 2 deletions(-) create mode 100644 drivers/block/nd/region_devs.c diff --git a/drivers/block/nd/Makefile b/drivers/block/nd/Makefile index 9f1b69c86fba..6698acbe7b44 100644 --- a/drivers/block/nd/Makefile +++ b/drivers/block/nd/Makefile @@ -23,3 +23,4 @@ nd-y := core.o nd-y += bus.o nd-y += dimm_devs.o nd-y += dimm.o +nd-y += region_devs.o diff --git a/drivers/block/nd/core.c b/drivers/block/nd/core.c index 426f96b02594..32ecd6f05c90 100644 --- a/drivers/block/nd/core.c +++ b/drivers/block/nd/core.c @@ -230,7 +230,7 @@ struct nfit_table_header { __le16 length; }; -static const char *spa_type_name(u16 type) +const char *spa_type_name(u16 type) { switch (type) { case NFIT_SPA_VOLATILE: return "volatile"; @@ -241,7 +241,7 @@ static const char *spa_type_name(u16 type) } } -static int nfit_spa_type(struct nfit_spa __iomem *nfit_spa) +int nfit_spa_type(struct nfit_spa __iomem *nfit_spa) { __u8 uuid[16]; @@ -577,6 +577,10 @@ static struct nd_bus *nd_bus_probe(struct nd_bus *nd_bus) if (rc) goto err_child; + rc = nd_bus_register_regions(nd_bus); + if (rc) + goto err_child; + mutex_lock(&nd_bus_list_mutex); list_add_tail(&nd_bus->list, &nd_bus_list); mutex_unlock(&nd_bus_list_mutex); diff --git a/drivers/block/nd/nd-private.h b/drivers/block/nd/nd-private.h index 72197992e386..d254ff688ad6 100644 --- a/drivers/block/nd/nd-private.h +++ b/drivers/block/nd/nd-private.h @@ -85,6 +85,8 @@ struct nd_mem { struct list_head list; }; +const char *spa_type_name(u16 type); +int nfit_spa_type(struct nfit_spa __iomem *nfit_spa); struct nd_dimm *nd_dimm_by_handle(struct nd_bus *nd_bus, u32 nfit_handle); bool is_nd_dimm(struct device *dev); struct nd_bus *to_nd_bus(struct device *dev); @@ -99,4 +101,7 @@ void __exit nd_dimm_exit(void); int nd_bus_create_ndctl(struct nd_bus *nd_bus); void nd_bus_destroy_ndctl(struct nd_bus *nd_bus); int nd_bus_register_dimms(struct nd_bus *nd_bus); +int nd_bus_register_regions(struct nd_bus *nd_bus); +int nd_match_dimm(struct device *dev, void *data); +bool is_nd_dimm(struct device *dev); #endif /* __ND_PRIVATE_H__ */ diff --git a/drivers/block/nd/nd.h b/drivers/block/nd/nd.h index f277440c72b4..13eba9bd74c7 100644 --- a/drivers/block/nd/nd.h +++ b/drivers/block/nd/nd.h @@ -22,6 +22,22 @@ struct nd_dimm_drvdata { void *data; }; +struct nd_mapping { + struct nd_dimm *nd_dimm; + u64 start; + u64 size; +}; + +struct nd_region { + struct device dev; + struct nd_spa *nd_spa; + u16 ndr_mappings; + u64 ndr_size; + u64 ndr_start; + int id; + struct nd_mapping mapping[0]; +}; + enum nd_async_mode { ND_SYNC, ND_ASYNC, @@ -39,4 +55,5 @@ void nd_dimm_set_dsm_mask(struct nd_dimm *nd_dimm, unsigned long dsm_mask); int nd_dimm_init_nsarea(struct nd_dimm_drvdata *ndd); int nd_dimm_init_config_data(struct nd_dimm_drvdata *ndd); int nd_dimm_firmware_status(struct device *dev); +struct nd_region *to_nd_region(struct device *dev); #endif /* __ND_H__ */ diff --git a/drivers/block/nd/region_devs.c b/drivers/block/nd/region_devs.c new file mode 100644 index 000000000000..f474c32d6dad --- /dev/null +++ b/drivers/block/nd/region_devs.c @@ -0,0 +1,426 @@ +/* + * Copyright(c) 2013-2015 Intel Corporation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + */ +#include <linux/slab.h> +#include <linux/io.h> +#include "nd-private.h" +#include "nfit.h" +#include "nd.h" + +#include <asm-generic/io-64-nonatomic-lo-hi.h> + +static DEFINE_IDA(region_ida); + +static void nd_region_release(struct device *dev) +{ + struct nd_region *nd_region = to_nd_region(dev); + u16 i; + + for (i = 0; i < nd_region->ndr_mappings; i++) { + struct nd_mapping *nd_mapping = &nd_region->mapping[i]; + struct nd_dimm *nd_dimm = nd_mapping->nd_dimm; + + put_device(&nd_dimm->dev); + } + ida_simple_remove(&region_ida, nd_region->id); + kfree(nd_region); +} + +static struct device_type nd_block_device_type = { + .name = "nd_blk", + .release = nd_region_release, +}; + +static struct device_type nd_pmem_device_type = { + .name = "nd_pmem", + .release = nd_region_release, +}; + +static struct device_type nd_volatile_device_type = { + .name = "nd_volatile", + .release = nd_region_release, +}; + +static bool is_nd_pmem(struct device *dev) +{ + return dev ? dev->type == &nd_pmem_device_type : false; +} + +struct nd_region *to_nd_region(struct device *dev) +{ + struct nd_region *nd_region = container_of(dev, struct nd_region, dev); + + WARN_ON(dev->type->release != nd_region_release); + return nd_region; +} + +static ssize_t size_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct nd_region *nd_region = to_nd_region(dev); + unsigned long long size = 0; + + if (is_nd_pmem(dev)) { + size = nd_region->ndr_size; + } else if (nd_region->ndr_mappings == 1) { + struct nd_mapping *nd_mapping = &nd_region->mapping[0]; + + size = nd_mapping->size; + } + + return sprintf(buf, "%llu\n", size); +} +static DEVICE_ATTR_RO(size); + +static ssize_t mappings_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct nd_region *nd_region = to_nd_region(dev); + + return sprintf(buf, "%d\n", nd_region->ndr_mappings); +} +static DEVICE_ATTR_RO(mappings); + +static struct attribute *nd_region_attributes[] = { + &dev_attr_size.attr, + &dev_attr_mappings.attr, + NULL, +}; + +static struct attribute_group nd_region_attribute_group = { + .attrs = nd_region_attributes, +}; + +/* + * Retrieve the nth entry referencing this spa, for pm there may be not only + * multiple per device in the interleave, but multiple per-dimm for each region + * of the dimm that maps into the interleave. + */ +static struct nd_memdev *nd_memdev_from_spa(struct nd_bus *nd_bus, + u16 spa_index, int n) +{ + struct nd_memdev *nd_memdev; + + list_for_each_entry(nd_memdev, &nd_bus->memdevs, list) + if (readw(&nd_memdev->nfit_mem->spa_index) == spa_index) + if (n-- == 0) + return nd_memdev; + return NULL; +} + +static int num_nd_mem(struct nd_bus *nd_bus, u16 spa_index) +{ + struct nd_memdev *nd_memdev; + int count = 0; + + list_for_each_entry(nd_memdev, &nd_bus->memdevs, list) + if (readw(&nd_memdev->nfit_mem->spa_index) == spa_index) + count++; + return count; +} + +/* convert and anoymous MEMDEV to its set of associated tables */ +static struct nd_mem *nd_memdev_to_mem(struct nd_bus *nd_bus, + struct nd_memdev *nd_memdev) +{ + u32 nfit_handle = readl(&nd_memdev->nfit_mem->nfit_handle); + struct nd_mem *nd_mem; + + list_for_each_entry(nd_mem, &nd_bus->dimms, list) + if (readl(&nd_mem->nfit_mem_dcr->nfit_handle) == nfit_handle) + return nd_mem; + return NULL; +} + +static ssize_t mappingN(struct device *dev, char *buf, int n) +{ + struct nd_region *nd_region = to_nd_region(dev); + struct nfit_mem __iomem *nfit_mem; + struct nd_mapping *nd_mapping; + struct nd_dimm *nd_dimm; + + if (n >= nd_region->ndr_mappings) + return -ENXIO; + nd_mapping = &nd_region->mapping[n]; + nd_dimm = nd_mapping->nd_dimm; + nfit_mem = nd_dimm->nd_mem->nfit_mem_dcr; + + return sprintf(buf, "%#x,%llu,%llu\n", readl(&nfit_mem->nfit_handle), + nd_mapping->start, nd_mapping->size); +} + +#define REGION_MAPPING(idx) \ +static ssize_t mapping##idx##_show(struct device *dev, \ + struct device_attribute *attr, char *buf) \ +{ \ + return mappingN(dev, buf, idx); \ +} \ +static DEVICE_ATTR_RO(mapping##idx) + +/* + * 32 should be enough for a while, even in the presence of socket + * interleave a 32-way interleave set is a degenerate case. + */ +REGION_MAPPING(0); +REGION_MAPPING(1); +REGION_MAPPING(2); +REGION_MAPPING(3); +REGION_MAPPING(4); +REGION_MAPPING(5); +REGION_MAPPING(6); +REGION_MAPPING(7); +REGION_MAPPING(8); +REGION_MAPPING(9); +REGION_MAPPING(10); +REGION_MAPPING(11); +REGION_MAPPING(12); +REGION_MAPPING(13); +REGION_MAPPING(14); +REGION_MAPPING(15); +REGION_MAPPING(16); +REGION_MAPPING(17); +REGION_MAPPING(18); +REGION_MAPPING(19); +REGION_MAPPING(20); +REGION_MAPPING(21); +REGION_MAPPING(22); +REGION_MAPPING(23); +REGION_MAPPING(24); +REGION_MAPPING(25); +REGION_MAPPING(26); +REGION_MAPPING(27); +REGION_MAPPING(28); +REGION_MAPPING(29); +REGION_MAPPING(30); +REGION_MAPPING(31); + +static umode_t nd_mapping_visible(struct kobject *kobj, struct attribute *a, int n) +{ + struct device *dev = container_of(kobj, struct device, kobj); + struct nd_region *nd_region = to_nd_region(dev); + + if (n < nd_region->ndr_mappings) + return a->mode; + return 0; +} + +static struct attribute *nd_mapping_attributes[] = { + &dev_attr_mapping0.attr, + &dev_attr_mapping1.attr, + &dev_attr_mapping2.attr, + &dev_attr_mapping3.attr, + &dev_attr_mapping4.attr, + &dev_attr_mapping5.attr, + &dev_attr_mapping6.attr, + &dev_attr_mapping7.attr, + &dev_attr_mapping8.attr, + &dev_attr_mapping9.attr, + &dev_attr_mapping10.attr, + &dev_attr_mapping11.attr, + &dev_attr_mapping12.attr, + &dev_attr_mapping13.attr, + &dev_attr_mapping14.attr, + &dev_attr_mapping15.attr, + &dev_attr_mapping16.attr, + &dev_attr_mapping17.attr, + &dev_attr_mapping18.attr, + &dev_attr_mapping19.attr, + &dev_attr_mapping20.attr, + &dev_attr_mapping21.attr, + &dev_attr_mapping22.attr, + &dev_attr_mapping23.attr, + &dev_attr_mapping24.attr, + &dev_attr_mapping25.attr, + &dev_attr_mapping26.attr, + &dev_attr_mapping27.attr, + &dev_attr_mapping28.attr, + &dev_attr_mapping29.attr, + &dev_attr_mapping30.attr, + &dev_attr_mapping31.attr, + NULL, +}; + +static struct attribute_group nd_mapping_attribute_group = { + .is_visible = nd_mapping_visible, + .attrs = nd_mapping_attributes, +}; + +static const struct attribute_group *nd_region_attribute_groups[] = { + &nd_region_attribute_group, + &nd_mapping_attribute_group, + NULL, +}; + +static void nd_blk_init(struct nd_bus *nd_bus, struct nd_region *nd_region, + struct nd_mem *nd_mem) +{ + struct nd_mapping *nd_mapping; + struct nd_dimm *nd_dimm; + u32 nfit_handle; + + nd_region->dev.type = &nd_block_device_type; + nfit_handle = readl(&nd_mem->nfit_mem_dcr->nfit_handle); + nd_dimm = nd_dimm_by_handle(nd_bus, nfit_handle); + + /* mark this region invalid unless we find a BDW */ + nd_region->ndr_mappings = 0; + + if (!nd_mem->nfit_bdw) { + dev_dbg(&nd_region->dev, + "%s: %s no block-data-window descriptor\n", + __func__, dev_name(&nd_dimm->dev)); + put_device(&nd_dimm->dev); + return; + } + if (readq(&nd_mem->nfit_bdw->blk_offset) % SZ_4K) { + dev_err(&nd_region->dev, "%s: %s block-capacity is not 4K aligned\n", + __func__, dev_name(&nd_dimm->dev)); + put_device(&nd_dimm->dev); + return; + } + + nd_region->ndr_mappings = 1; + nd_mapping = &nd_region->mapping[0]; + nd_mapping->nd_dimm = nd_dimm; + nd_mapping->size = readq(&nd_mem->nfit_bdw->blk_capacity); + nd_mapping->start = readq(&nd_mem->nfit_bdw->blk_offset); +} + +static void nd_spa_range_init(struct nd_bus *nd_bus, struct nd_region *nd_region, + struct device_type *type) +{ + u16 i; + struct nd_spa *nd_spa = nd_region->nd_spa; + u16 spa_index = readw(&nd_spa->nfit_spa->spa_index); + + nd_region->dev.type = type; + for (i = 0; i < nd_region->ndr_mappings; i++) { + struct nd_memdev *nd_memdev = nd_memdev_from_spa(nd_bus, + spa_index, i); + struct nd_mem *nd_mem = nd_memdev_to_mem(nd_bus, nd_memdev); + u32 nfit_handle = readl(&nd_mem->nfit_mem_dcr->nfit_handle); + struct nd_mapping *nd_mapping = &nd_region->mapping[i]; + struct nd_dimm *nd_dimm; + + nd_dimm = nd_dimm_by_handle(nd_bus, nfit_handle); + nd_mapping->nd_dimm = nd_dimm; + nd_mapping->start = readq(&nd_memdev->nfit_mem->region_dpa); + nd_mapping->size = readq(&nd_memdev->nfit_mem->region_len); + + if ((nd_mapping->start | nd_mapping->size) % SZ_4K) { + dev_err(&nd_region->dev, "%s: %s mapping is not 4K aligned\n", + __func__, dev_name(&nd_dimm->dev)); + nd_region->ndr_mappings = 0; + return; + } + } +} + +static struct nd_region *nd_region_create(struct nd_bus *nd_bus, + struct nd_spa *nd_spa, struct nd_mem *nd_mem) +{ + u16 spa_index = readw(&nd_spa->nfit_spa->spa_index); + int spa_type = nfit_spa_type(nd_spa->nfit_spa); + struct nd_region *nd_region; + struct device *dev; + u16 num_mappings; + + if (nd_mem) + num_mappings = 1; + else + num_mappings = num_nd_mem(nd_bus, spa_index); + nd_region = kzalloc(sizeof(struct nd_region) + + sizeof(struct nd_mapping) * num_mappings, GFP_KERNEL); + if (!nd_region) + return NULL; + nd_region->id = ida_simple_get(&region_ida, 0, 0, GFP_KERNEL); + if (nd_region->id < 0) { + kfree(nd_region); + return NULL; + } + nd_region->nd_spa = nd_spa; + nd_region->ndr_mappings = num_mappings; + dev = &nd_region->dev; + dev_set_name(dev, "region%d", nd_region->id); + dev->parent = &nd_bus->dev; + dev->groups = nd_region_attribute_groups; + nd_region->ndr_size = readq(&nd_spa->nfit_spa->spa_length); + nd_region->ndr_start = readq(&nd_spa->nfit_spa->spa_base); + switch (spa_type) { + case NFIT_SPA_PM: + nd_spa_range_init(nd_bus, nd_region, &nd_pmem_device_type); + break; + case NFIT_SPA_VOLATILE: + nd_spa_range_init(nd_bus, nd_region, &nd_volatile_device_type); + break; + case NFIT_SPA_DCR: + nd_blk_init(nd_bus, nd_region, nd_mem); + break; + default: + break; + } + nd_device_register(dev); + + return nd_region; +} + +int nd_bus_register_regions(struct nd_bus *nd_bus) +{ + struct nd_spa *nd_spa; + int rc = 0; + + mutex_lock(&nd_bus_list_mutex); + list_for_each_entry(nd_spa, &nd_bus->spas, list) { + int spa_type; + u16 spa_index; + struct nd_mem *nd_mem; + struct nd_region *nd_region; + + spa_type = nfit_spa_type(nd_spa->nfit_spa); + spa_index = readw(&nd_spa->nfit_spa->spa_index); + if (spa_index == 0) { + dev_dbg(&nd_bus->dev, "detected invalid spa index\n"); + continue; + } + switch (spa_type) { + case NFIT_SPA_PM: + case NFIT_SPA_VOLATILE: + nd_region = nd_region_create(nd_bus, nd_spa, NULL); + if (!nd_region) + rc = -ENOMEM; + break; + case NFIT_SPA_DCR: + list_for_each_entry(nd_mem, &nd_bus->dimms, list) { + if (readw(&nd_mem->nfit_spa_dcr->spa_index) + != spa_index) + continue; + nd_region = nd_region_create(nd_bus, nd_spa, + nd_mem); + if (!nd_region) + rc = -ENOMEM; + } + break; + case NFIT_SPA_BDW: + /* we'll consume this in nd_blk_register for the DCR */ + break; + default: + dev_info(&nd_bus->dev, "spa[%d] unhandled type: %s\n", + spa_index, spa_type_name(spa_type)); + break; + } + } + mutex_unlock(&nd_bus_list_mutex); + + nd_synchronize(); + + return rc; +}

nd_pmem attaches to persistent memory regions and namespaces emitted by the nd subsystem, and, same as the original pmem driver, presents the system-physical-address range as a block device. Cc: Andy Lutomirski <luto(a)amacapital.net&gt; Cc: Boaz Harrosh <boaz(a)plexistor.com&gt; Cc: H. Peter Anvin <hpa(a)zytor.com&gt; Cc: Jens Axboe <axboe(a)fb.com&gt; Cc: Ingo Molnar <mingo(a)kernel.org&gt; Cc: Christoph Hellwig <hch(a)lst.de&gt; Signed-off-by: Dan Williams <dan.j.williams(a)intel.com&gt; --- drivers/block/Kconfig | 11 ------- drivers/block/Makefile | 1 - drivers/block/nd/Kconfig | 17 +++++++++++ drivers/block/nd/Makefile | 3 ++ drivers/block/nd/pmem.c | 72 +++++++++++++++++++++++++++++++++++++++------ 5 files changed, 83 insertions(+), 21 deletions(-) rename drivers/block/{pmem.c => nd/pmem.c} (81%) diff --git a/drivers/block/Kconfig b/drivers/block/Kconfig index dfe40e5ca9bd..1cef4ffb16c5 100644 --- a/drivers/block/Kconfig +++ b/drivers/block/Kconfig @@ -406,17 +406,6 @@ config BLK_DEV_RAM_DAX and will prevent RAM block device backing store memory from being allocated from highmem (only a problem for highmem systems). -config BLK_DEV_PMEM - tristate "Persistent memory block device support" - help - Saying Y here will allow you to use a contiguous range of reserved - memory as one or more persistent block devices. - - To compile this driver as a module, choose M here: the module will be - called 'pmem'. - - If unsure, say N. - config CDROM_PKTCDVD tristate "Packet writing on CD/DVD media" depends on !UML diff --git a/drivers/block/Makefile b/drivers/block/Makefile index 18b27bb9cd2d..3a2f15be66a3 100644 --- a/drivers/block/Makefile +++ b/drivers/block/Makefile @@ -14,7 +14,6 @@ obj-$(CONFIG_PS3_VRAM) += ps3vram.o obj-$(CONFIG_ATARI_FLOPPY) += ataflop.o obj-$(CONFIG_AMIGA_Z2RAM) += z2ram.o obj-$(CONFIG_BLK_DEV_RAM) += brd.o -obj-$(CONFIG_BLK_DEV_PMEM) += pmem.o obj-$(CONFIG_BLK_DEV_LOOP) += loop.o obj-$(CONFIG_BLK_CPQ_DA) += cpqarray.o obj-$(CONFIG_BLK_CPQ_CISS_DA) += cciss.o diff --git a/drivers/block/nd/Kconfig b/drivers/block/nd/Kconfig index 6c15d10bf4e0..38eae5f0ae4b 100644 --- a/drivers/block/nd/Kconfig +++ b/drivers/block/nd/Kconfig @@ -72,4 +72,21 @@ config NFIT_TEST Say N unless you are doing development of the 'nd' subsystem. +config BLK_DEV_PMEM + tristate "PMEM: Persistent memory block device support" + depends on ND_CORE || X86_PMEM_LEGACY + default ND_CORE + help + Memory ranges for PMEM are described by either an NFIT + (NVDIMM Firmware Interface Table, see CONFIG_NFIT_ACPI), a + non-standard OEM-specific E820 memory type (type-12, see + CONFIG_X86_PMEM_LEGACY), or it is manually specified by the + 'memmap=nn[KMG]!ss[KMG]' kernel command line (see + Documentation/kernel-parameters.txt). This driver converts + these persistent memory ranges into block devices that are + capable of DAX (direct-access) file system mappings. See + Documentation/blockdev/nd.txt for more details. + + Say Y if you want to use a NVDIMM described by NFIT + endif diff --git a/drivers/block/nd/Makefile b/drivers/block/nd/Makefile index 769ddc34f974..c0194d52e5ad 100644 --- a/drivers/block/nd/Makefile +++ b/drivers/block/nd/Makefile @@ -16,6 +16,7 @@ endif obj-$(CONFIG_ND_CORE) += nd.o obj-$(CONFIG_NFIT_ACPI) += nd_acpi.o +obj-$(CONFIG_BLK_DEV_PMEM) += nd_pmem.o nd_acpi-y := acpi.o @@ -26,3 +27,5 @@ nd-y += dimm.o nd-y += region_devs.o nd-y += region.o nd-y += namespace_devs.o + +nd_pmem-y := pmem.o diff --git a/drivers/block/pmem.c b/drivers/block/nd/pmem.c similarity index 81% rename from drivers/block/pmem.c rename to drivers/block/nd/pmem.c index eabf4a8d0085..cd83a9a98d89 100644 --- a/drivers/block/pmem.c +++ b/drivers/block/nd/pmem.c @@ -1,7 +1,7 @@ /* * Persistent Memory Driver * - * Copyright (c) 2014, Intel Corporation. + * Copyright (c) 2014-2015, Intel Corporation. * Copyright (c) 2015, Christoph Hellwig <hch(a)lst.de&gt;. * Copyright (c) 2015, Boaz Harrosh <boaz(a)plexistor.com&gt;. * @@ -23,6 +23,7 @@ #include <linux/module.h> #include <linux/moduleparam.h> #include <linux/slab.h> +#include <linux/nd.h> #define PMEM_MINORS 16 @@ -34,10 +35,11 @@ struct pmem_device { phys_addr_t phys_addr; void *virt_addr; size_t size; + int id; }; static int pmem_major; -static atomic_t pmem_index; +static DEFINE_IDA(pmem_ida); static void pmem_do_bvec(struct pmem_device *pmem, struct page *page, unsigned int len, unsigned int off, int rw, @@ -122,20 +124,26 @@ static struct pmem_device *pmem_alloc(struct device *dev, struct resource *res) { struct pmem_device *pmem; struct gendisk *disk; - int idx, err; + int err; err = -ENOMEM; pmem = kzalloc(sizeof(*pmem), GFP_KERNEL); if (!pmem) goto out; + pmem->id = ida_simple_get(&pmem_ida, 0, 0, GFP_KERNEL); + if (pmem->id < 0) { + err = pmem->id; + goto out_free_dev; + } + pmem->phys_addr = res->start; pmem->size = resource_size(res); err = -EINVAL; if (!request_mem_region(pmem->phys_addr, pmem->size, "pmem")) { dev_warn(dev, "could not reserve region [0x%pa:0x%zx]\n", &pmem->phys_addr, pmem->size); - goto out_free_dev; + goto out_free_ida; } /* @@ -159,15 +167,13 @@ static struct pmem_device *pmem_alloc(struct device *dev, struct resource *res) if (!disk) goto out_free_queue; - idx = atomic_inc_return(&pmem_index) - 1; - disk->major = pmem_major; - disk->first_minor = PMEM_MINORS * idx; + disk->first_minor = PMEM_MINORS * pmem->id; disk->fops = &pmem_fops; disk->private_data = pmem; disk->queue = pmem->pmem_queue; disk->flags = GENHD_FL_EXT_DEVT; - sprintf(disk->disk_name, "pmem%d", idx); + sprintf(disk->disk_name, "pmem%d", pmem->id); disk->driverfs_dev = dev; set_capacity(disk, pmem->size >> 9); pmem->pmem_disk = disk; @@ -182,6 +188,8 @@ out_unmap: iounmap(pmem->virt_addr); out_release_region: release_mem_region(pmem->phys_addr, pmem->size); +out_free_ida: + ida_simple_remove(&pmem_ida, pmem->id); out_free_dev: kfree(pmem); out: @@ -195,6 +203,7 @@ static void pmem_free(struct pmem_device *pmem) blk_cleanup_queue(pmem->pmem_queue); iounmap(pmem->virt_addr); release_mem_region(pmem->phys_addr, pmem->size); + ida_simple_remove(&pmem_ida, pmem->id); kfree(pmem); } @@ -236,6 +245,39 @@ static struct platform_driver pmem_driver = { }, }; +static int nd_pmem_probe(struct device *dev) +{ + struct nd_namespace_io *nsio = to_nd_namespace_io(dev); + struct pmem_device *pmem; + + pmem = pmem_alloc(dev, &nsio->res); + if (IS_ERR(pmem)) + return PTR_ERR(pmem); + + dev_set_drvdata(dev, pmem); + + return 0; +} + +static int nd_pmem_remove(struct device *dev) +{ + struct pmem_device *pmem = dev_get_drvdata(dev); + + pmem_free(pmem); + return 0; +} + +MODULE_ALIAS("pmem"); +MODULE_ALIAS_ND_DEVICE(ND_DEVICE_NAMESPACE_IO); +static struct nd_device_driver nd_pmem_driver = { + .probe = nd_pmem_probe, + .remove = nd_pmem_remove, + .drv = { + .name = "pmem", + }, + .type = ND_DRIVER_NAMESPACE_IO, +}; + static int __init pmem_init(void) { int error; @@ -244,9 +286,20 @@ static int __init pmem_init(void) if (pmem_major < 0) return pmem_major; + error = nd_driver_register(&nd_pmem_driver); + if (error) + goto out_unregister_blkdev; + error = platform_driver_register(&pmem_driver); if (error) - unregister_blkdev(pmem_major, "pmem"); + goto out_unregister_nd; + + return 0; + + out_unregister_nd: + driver_unregister(&nd_pmem_driver.drv); + out_unregister_blkdev: + unregister_blkdev(pmem_major, "pmem"); return error; } module_init(pmem_init); @@ -254,6 +307,7 @@ module_init(pmem_init); static void pmem_exit(void) { platform_driver_unregister(&pmem_driver); + driver_unregister(&nd_pmem_driver.drv); unregister_blkdev(pmem_major, "pmem"); } module_exit(pmem_exit);

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 | +------------+ After reading valid labels, store the dpa ranges they claim into per-dimm resource trees. Signed-off-by: Dan Williams <dan.j.williams(a)intel.com&gt; --- drivers/block/nd/Makefile | 1 drivers/block/nd/dimm.c | 25 +++- drivers/block/nd/dimm_devs.c | 6 + drivers/block/nd/label.c | 291 ++++++++++++++++++++++++++++++++++++++++++ drivers/block/nd/label.h | 129 +++++++++++++++++++ drivers/block/nd/nd.h | 45 ++++++ include/uapi/linux/ndctl.h | 1 7 files changed, 495 insertions(+), 3 deletions(-) create mode 100644 drivers/block/nd/label.c create mode 100644 drivers/block/nd/label.h diff --git a/drivers/block/nd/Makefile b/drivers/block/nd/Makefile index c0194d52e5ad..93856f1c9dbd 100644 --- a/drivers/block/nd/Makefile +++ b/drivers/block/nd/Makefile @@ -27,5 +27,6 @@ nd-y += dimm.o nd-y += region_devs.o nd-y += region.o nd-y += namespace_devs.o +nd-y += label.o nd_pmem-y := pmem.o diff --git a/drivers/block/nd/dimm.c b/drivers/block/nd/dimm.c index 7e043c0c1bf5..ccc96d8fe2e7 100644 --- a/drivers/block/nd/dimm.c +++ b/drivers/block/nd/dimm.c @@ -18,6 +18,7 @@ #include <linux/slab.h> #include <linux/mm.h> #include <linux/nd.h> +#include "label.h" #include "nd.h" static bool force_enable_dimms; @@ -53,6 +54,12 @@ static int nd_dimm_probe(struct device *dev) return -ENOMEM; dev_set_drvdata(dev, ndd); + ndd->dpa.name = dev_name(dev); + ndd->ns_current = -1; + ndd->ns_next = -1; + ndd->dpa.start = 0; + ndd->dpa.end = -1; + ndd->dev = dev; rc = nd_dimm_init_nsarea(ndd); if (rc) @@ -64,18 +71,34 @@ static int nd_dimm_probe(struct device *dev) dev_dbg(dev, "config data size: %d\n", ndd->nsarea.config_size); + nd_bus_lock(dev); + ndd->ns_current = nd_label_validate(ndd); + ndd->ns_next = nd_label_next_nsindex(ndd->ns_current); + nd_label_copy(ndd, to_next_namespace_index(ndd), + to_current_namespace_index(ndd)); + rc = nd_label_reserve_dpa(ndd); + nd_bus_unlock(dev); + + if (rc) + goto err; + return 0; err: free_data(ndd); return rc; - } static int nd_dimm_remove(struct device *dev) { struct nd_dimm_drvdata *ndd = dev_get_drvdata(dev); + struct resource *res, *_r; + nd_bus_lock(dev); + dev_set_drvdata(dev, NULL); + for_each_dpa_resource_safe(ndd, res, _r) + __release_region(&ndd->dpa, res->start, resource_size(res)); + nd_bus_unlock(dev); free_data(ndd); return 0; diff --git a/drivers/block/nd/dimm_devs.c b/drivers/block/nd/dimm_devs.c index 6192d9c82b9b..652dee210fe8 100644 --- a/drivers/block/nd/dimm_devs.c +++ b/drivers/block/nd/dimm_devs.c @@ -94,8 +94,12 @@ int nd_dimm_init_config_data(struct nd_dimm_drvdata *ndd) if (ndd->data) return 0; - if (ndd->nsarea.status || ndd->nsarea.max_xfer == 0) + if (ndd->nsarea.status || ndd->nsarea.max_xfer == 0 + || ndd->nsarea.config_size < ND_LABEL_MIN_SIZE) { + dev_dbg(ndd->dev, "failed to init config data area: (%d:%d)\n", + ndd->nsarea.max_xfer, ndd->nsarea.config_size); return -ENXIO; + } ndd->data = kmalloc(ndd->nsarea.config_size, GFP_KERNEL); if (!ndd->data) diff --git a/drivers/block/nd/label.c b/drivers/block/nd/label.c new file mode 100644 index 000000000000..e791ea8bbdde --- /dev/null +++ b/drivers/block/nd/label.c @@ -0,0 +1,291 @@ +/* + * Copyright(c) 2013-2015 Intel Corporation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + */ +#include <linux/device.h> +#include <linux/ndctl.h> +#include <linux/io.h> +#include <linux/nd.h> +#include "nd-private.h" +#include "label.h" +#include "nd.h" + +#include <asm-generic/io-64-nonatomic-lo-hi.h> + +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 (nd_inc_seq(a) == b) + return b; + else + return a; +} + +size_t sizeof_namespace_index(struct nd_dimm_drvdata *ndd) +{ + u32 index_span; + + if (ndd->nsindex_size) + return ndd->nsindex_size; + + /* + * The minimum index space is 512 bytes, with that amount of + * index we can describe ~1400 labels which is less than a byte + * of overhead per label. Round up to a byte of overhead per + * label and determine the size of the index region. Yes, this + * starts to waste space at larger config_sizes, but it's + * unlikely we'll ever see anything but 128K. + */ + index_span = ndd->nsarea.config_size / 129; + index_span /= NSINDEX_ALIGN * 2; + ndd->nsindex_size = index_span * NSINDEX_ALIGN; + + return ndd->nsindex_size; +} + +int nd_label_validate(struct nd_dimm_drvdata *ndd) +{ + /* + * 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 nd_namespace_index __iomem *nsindex[] = { + to_namespace_index(ndd, 0), + to_namespace_index(ndd, 1), + }; + const int num_index = ARRAY_SIZE(nsindex); + struct device *dev = ndd->dev; + bool valid[] = { false, false }; + int i, num_valid = 0; + u32 seq; + + for (i = 0; i < num_index; i++) { + u64 sum_save, sum; + u8 sig[NSINDEX_SIG_LEN]; + + memcpy_fromio(sig, nsindex[i]->sig, NSINDEX_SIG_LEN); + if (memcmp(sig, NSINDEX_SIGNATURE, NSINDEX_SIG_LEN) != 0) { + dev_dbg(dev, "%s: nsindex%d signature invalid\n", + __func__, i); + continue; + } + sum_save = readq(&nsindex[i]->checksum); + writeq(0, &nsindex[i]->checksum); + sum = nd_fletcher64(nsindex[i], sizeof_namespace_index(ndd)); + writeq(sum_save, &nsindex[i]->checksum); + if (sum != sum_save) { + dev_dbg(dev, "%s: nsindex%d checksum invalid\n", + __func__, i); + continue; + } + if ((readl(&nsindex[i]->seq) & NSINDEX_SEQ_MASK) == 0) { + dev_dbg(dev, "%s: nsindex%d sequence: %#x invalid\n", + __func__, i, readl(&nsindex[i]->seq)); + continue; + } + + /* sanity check the index against expected values */ + if (readq(&nsindex[i]->myoff) + != i * sizeof_namespace_index(ndd)) { + dev_dbg(dev, "%s: nsindex%d myoff: %#llx invalid\n", + __func__, i, (unsigned long long) + readq(&nsindex[i]->myoff)); + continue; + } + if (readq(&nsindex[i]->otheroff) + != (!i) * sizeof_namespace_index(ndd)) { + dev_dbg(dev, "%s: nsindex%d otheroff: %#llx invalid\n", + __func__, i, (unsigned long long) + readq(&nsindex[i]->otheroff)); + continue; + } + if (readq(&nsindex[i]->mysize) > sizeof_namespace_index(ndd) + || readq(&nsindex[i]->mysize) + < sizeof(struct nd_namespace_index)) { + dev_dbg(dev, "%s: nsindex%d mysize: %#llx invalid\n", + __func__, i, (unsigned long long) + readq(&nsindex[i]->mysize)); + continue; + } + if (readl(&nsindex[i]->nslot) * sizeof(struct nd_namespace_label) + + 2 * sizeof_namespace_index(ndd) + > ndd->nsarea.config_size) { + dev_dbg(dev, "%s: nsindex%d nslot: %u invalid, config_size: %#x\n", + __func__, i, readl(&nsindex[i]->nslot), + ndd->nsarea.config_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 } */ + WARN_ON(1); + break; + default: + /* pick the best index... */ + seq = best_seq(readl(&nsindex[0]->seq), readl(&nsindex[1]->seq)); + if (seq == (readl(&nsindex[1]->seq) & NSINDEX_SEQ_MASK)) + return 1; + else + return 0; + break; + } + + return -1; +} + +void nd_label_copy(struct nd_dimm_drvdata *ndd, + struct nd_namespace_index __iomem *dst, + struct nd_namespace_index __iomem *src) +{ + void *s, *d; + + if (dst && src) + /* pass */; + else + return; + + d = (void * __force) dst; + s = (void * __force) src; + memcpy(d, s, sizeof_namespace_index(ndd)); +} + +static struct nd_namespace_label __iomem *nd_label_base(struct nd_dimm_drvdata *ndd) +{ + void *base = to_namespace_index(ndd, 0); + + return base + 2 * sizeof_namespace_index(ndd); +} + +#define for_each_clear_bit_le(bit, addr, size) \ + for ((bit) = find_next_zero_bit_le((addr), (size), 0); \ + (bit) < (size); \ + (bit) = find_next_zero_bit_le((addr), (size), (bit) + 1)) + +/** + * preamble_current - common variable initialization for nd_label_* routines + * @nd_dimm: dimm container for the relevant label set + * @nsindex: on return set to the currently active namespace index + * @free: on return set to the free label bitmap in the index + * @nslot: on return set to the number of slots in the label space + */ +static bool preamble_current(struct nd_dimm_drvdata *ndd, + struct nd_namespace_index **nsindex, + unsigned long **free, u32 *nslot) +{ + *nsindex = to_current_namespace_index(ndd); + if (*nsindex == NULL) + return false; + + *free = (unsigned long __force *) (*nsindex)->free; + *nslot = readl(&(*nsindex)->nslot); + + return true; +} + +static char *nd_label_gen_id(struct nd_label_id *label_id, u8 *uuid, u32 flags) +{ + if (!label_id || !uuid) + return NULL; + snprintf(label_id->id, ND_LABEL_ID_SIZE, "%s-%pUb", + flags & NSLABEL_FLAG_LOCAL ? "blk" : "pmem", uuid); + return label_id->id; +} + +static bool slot_valid(struct nd_namespace_label __iomem *nd_label, u32 slot) +{ + /* check that we are written where we expect to be written */ + if (slot != readl(&nd_label->slot)) + return false; + + /* check that DPA allocations are page aligned */ + if ((readq(&nd_label->dpa) | readq(&nd_label->rawsize)) % SZ_4K) + return false; + + return true; +} + +int nd_label_reserve_dpa(struct nd_dimm_drvdata *ndd) +{ + struct nd_namespace_index __iomem *nsindex; + unsigned long *free; + u32 nslot, slot; + + if (!preamble_current(ndd, &nsindex, &free, &nslot)) + return 0; /* no label, nothing to reserve */ + + for_each_clear_bit_le(slot, free, nslot) { + struct nd_namespace_label __iomem *nd_label; + struct nd_region *nd_region = NULL; + u8 label_uuid[NSLABEL_UUID_LEN]; + struct nd_label_id *label_id; + struct resource *res; + u32 flags; + + nd_label = nd_label_base(ndd) + slot; + + if (!slot_valid(nd_label, slot)) + continue; + + label_id = devm_kzalloc(ndd->dev, sizeof(*label_id), + GFP_KERNEL); + if (!label_id) + return -ENOMEM; + memcpy_fromio(label_uuid, nd_label->uuid, + NSLABEL_UUID_LEN); + flags = readl(&nd_label->flags); + res = __request_region(&ndd->dpa, readq(&nd_label->dpa), + readq(&nd_label->rawsize), + nd_label_gen_id(label_id, label_uuid, flags), 0); + nd_dbg_dpa(nd_region, ndd, res, "reserve\n"); + if (!res) + return -EBUSY; + } + + return 0; +} diff --git a/drivers/block/nd/label.h b/drivers/block/nd/label.h new file mode 100644 index 000000000000..79ed885a43c0 --- /dev/null +++ b/drivers/block/nd/label.h @@ -0,0 +1,129 @@ +/* + * Copyright(c) 2013-2015 Intel Corporation. All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + */ +#ifndef __LABEL_H__ +#define __LABEL_H__ + +#include <linux/ndctl.h> +#include <linux/sizes.h> +#include <linux/io.h> + +enum { + NSINDEX_SIG_LEN = 16, + NSINDEX_ALIGN = 256, + NSINDEX_SEQ_MASK = 0x3, + NSLABEL_UUID_LEN = 16, + NSLABEL_NAME_LEN = 64, + NSLABEL_FLAG_ROLABEL = 0x1, /* read-only label */ + NSLABEL_FLAG_LOCAL = 0x2, /* DIMM-local namespace */ + NSLABEL_FLAG_BTT = 0x4, /* namespace contains a BTT */ + NSLABEL_FLAG_UPDATING = 0x8, /* label being updated */ + BTT_ALIGN = 4096, /* all btt structures */ + BTTINFO_SIG_LEN = 16, + BTTINFO_UUID_LEN = 16, + BTTINFO_FLAG_ERROR = 0x1, /* error state (read-only) */ + BTTINFO_MAJOR_VERSION = 1, + ND_LABEL_MIN_SIZE = 512 * 129, /* see sizeof_namespace_index() */ + ND_LABEL_ID_SIZE = 50, +}; + +static const char NSINDEX_SIGNATURE[] = "NAMESPACE_INDEX\0"; + +/** + * struct nd_namespace_index - label set superblock + * @sig: NAMESPACE_INDEX\0 + * @flags: placeholder + * @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[0]: 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 nd_namespace_index { + u8 sig[NSINDEX_SIG_LEN]; + __le32 flags; + __le32 seq; + __le64 myoff; + __le64 mysize; + __le64 otheroff; + __le64 labeloff; + __le32 nslot; + __le16 major; + __le16 minor; + __le64 checksum; + u8 free[0]; +}; + +/** + * struct nd_namespace_label - namespace superblock + * @uuid: UUID per RFC 4122 + * @name: optional name (NULL-terminated) + * @flags: see NSLABEL_FLAG_* + * @nlabel: num labels to describe this ns + * @position: labels position in set + * @isetcookie: interleave set cookie + * @lbasize: LBA size in bytes or 0 for pmem + * @dpa: DPA of NVM range on this DIMM + * @rawsize: size of namespace + * @slot: slot of this label in label area + * @unused: must be zero + */ +struct nd_namespace_label { + u8 uuid[NSLABEL_UUID_LEN]; + u8 name[NSLABEL_NAME_LEN]; + __le32 flags; + __le16 nlabel; + __le16 position; + __le64 isetcookie; + __le64 lbasize; + __le64 dpa; + __le64 rawsize; + __le32 slot; + __le32 unused; +}; + +/** + * struct nd_label_id - identifier string for dpa allocation + * @id: "{blk|pmem}-<namespace uuid>" + */ +struct nd_label_id { + char id[ND_LABEL_ID_SIZE]; +}; + +/* + * If the 'best' index is invalid, so is the 'next' index. Otherwise, + * the next index is MOD(index+1, 2) + */ +static inline int nd_label_next_nsindex(int index) +{ + if (index < 0) + return -1; + + return (index + 1) % 2; +} + +struct nd_dimm_drvdata; +int nd_label_validate(struct nd_dimm_drvdata *ndd); +void nd_label_copy(struct nd_dimm_drvdata *ndd, + struct nd_namespace_index *dst, + struct nd_namespace_index *src); +size_t sizeof_namespace_index(struct nd_dimm_drvdata *ndd); +#endif /* __LABEL_H__ */ diff --git a/drivers/block/nd/nd.h b/drivers/block/nd/nd.h index 4deed46884c1..f8dee1df5e6a 100644 --- a/drivers/block/nd/nd.h +++ b/drivers/block/nd/nd.h @@ -15,11 +15,15 @@ #include <linux/device.h> #include <linux/mutex.h> #include <linux/ndctl.h> +#include "label.h" struct nd_dimm_drvdata { struct device *dev; + int nsindex_size; struct nfit_cmd_get_config_size nsarea; void *data; + int ns_current, ns_next; + struct resource dpa; }; struct nd_region_namespaces { @@ -27,12 +31,43 @@ struct nd_region_namespaces { int active; }; +static inline struct nd_namespace_index __iomem *to_namespace_index( + struct nd_dimm_drvdata *ndd, int i) +{ + if (i < 0) + return NULL; + + return ((void __iomem *) ndd->data + sizeof_namespace_index(ndd) * i); +} + +static inline struct nd_namespace_index __iomem *to_current_namespace_index( + struct nd_dimm_drvdata *ndd) +{ + return to_namespace_index(ndd, ndd->ns_current); +} + +static inline struct nd_namespace_index __iomem *to_next_namespace_index( + struct nd_dimm_drvdata *ndd) +{ + return to_namespace_index(ndd, ndd->ns_next); +} + struct nd_mapping { struct nd_dimm *nd_dimm; u64 start; u64 size; }; +#define nd_dbg_dpa(r, d, res, fmt, arg...) \ + dev_dbg((r) ? &(r)->dev : (d)->dev, "%s: %.13s: %#llx @ %#llx " fmt, \ + (r) ? dev_name((d)->dev) : "", res ? res->name : "null", \ + (unsigned long long) (res ? resource_size(res) : 0), \ + (unsigned long long) (res ? res->start : 0), ##arg) + +#define for_each_dpa_resource_safe(ndd, res, next) \ + for (res = (ndd)->dpa.child, next = res ? res->sibling : NULL; \ + res; res = next, next = next ? next->sibling : NULL) + struct nd_region { struct device dev; struct nd_spa *nd_spa; @@ -43,6 +78,15 @@ struct nd_region { struct nd_mapping mapping[0]; }; +/* + * Lookup next in the repeating sequence of 01, 10, and 11. + */ +static inline unsigned nd_inc_seq(unsigned seq) +{ + static const unsigned next[] = { 0, 2, 3, 1 }; + + return next[seq & 3]; +} enum nd_async_mode { ND_SYNC, ND_ASYNC, @@ -67,4 +111,5 @@ int nd_region_register_namespaces(struct nd_region *nd_region, int *err); void nd_bus_lock(struct device *dev); void nd_bus_unlock(struct device *dev); bool is_nd_bus_locked(struct device *dev); +int nd_label_reserve_dpa(struct nd_dimm_drvdata *ndd); #endif /* __ND_H__ */ diff --git a/include/uapi/linux/ndctl.h b/include/uapi/linux/ndctl.h index 0ccc0f2e5765..097e67a8d477 100644 --- a/include/uapi/linux/ndctl.h +++ b/include/uapi/linux/ndctl.h @@ -175,7 +175,6 @@ static inline const char *nfit_dimm_cmd_name(unsigned cmd) #define NFIT_IOCTL_ARS_QUERY _IOWR(ND_IOCTL, NFIT_CMD_ARS_QUERY,\ struct nfit_cmd_ars_query) - #define ND_DEVICE_DIMM 1 /* nd_dimm: container for "config data" */ #define ND_DEVICE_REGION_PMEM 2 /* nd_region: (parent of pmem namespaces) */ #define ND_DEVICE_REGION_BLOCK 3 /* nd_region: (parent of block namespaces) */

A blk label set describes a namespace comprised of one or more discontiguous dpa ranges on a single dimm. They may alias with one or more pmem interleave sets that include the given dimm. This is the runtime/volatile configuration infrastructure for sysfs manipulation of 'alt_name', 'uuid', 'size', and 'sector_size'. A later patch will make these settings persistent by writing back the label(s). Unlike pmem namespaces, multiple blk namespaces can be created per region. Once a blk namespace has been created a new seed device (unconfigured child of a parent blk region) is instantiated. As long as a region has 'available_size' != 0 new child namespaces may be created. Cc: Greg KH <gregkh(a)linuxfoundation.org&gt; Cc: Neil Brown <neilb(a)suse.de&gt; Signed-off-by: Dan Williams <dan.j.williams(a)intel.com&gt; --- drivers/block/nd/core.c | 40 +++ drivers/block/nd/dimm_devs.c | 35 +++ drivers/block/nd/namespace_devs.c | 502 ++++++++++++++++++++++++++++++++++--- drivers/block/nd/nd-private.h | 10 + drivers/block/nd/nd.h | 5 drivers/block/nd/region_devs.c | 15 + include/linux/nd.h | 25 ++ 7 files changed, 588 insertions(+), 44 deletions(-) diff --git a/drivers/block/nd/core.c b/drivers/block/nd/core.c index 560ed5555496..880aef08f919 100644 --- a/drivers/block/nd/core.c +++ b/drivers/block/nd/core.c @@ -213,6 +213,46 @@ int nd_uuid_store(struct device *dev, u8 **uuid_out, const char *buf, return 0; } +ssize_t nd_sector_size_show(unsigned long current_lbasize, + const unsigned long *supported, char *buf) +{ + ssize_t len = 0; + int i; + + for (i = 0; supported[i]; i++) + if (current_lbasize == supported[i]) + len += sprintf(buf + len, "[%ld] ", supported[i]); + else + len += sprintf(buf + len, "%ld ", supported[i]); + len += sprintf(buf + len, "\n"); + return len; +} + +ssize_t nd_sector_size_store(struct device *dev, const char *buf, + unsigned long *current_lbasize, const unsigned long *supported) +{ + unsigned long lbasize; + int rc, i; + + if (dev->driver) + return -EBUSY; + + rc = kstrtoul(buf, 0, &lbasize); + if (rc) + return rc; + + for (i = 0; supported[i]; i++) + if (lbasize == supported[i]) + break; + + if (supported[i]) { + *current_lbasize = lbasize; + return 0; + } else { + return -EINVAL; + } +} + static ssize_t commands_show(struct device *dev, struct device_attribute *attr, char *buf) { diff --git a/drivers/block/nd/dimm_devs.c b/drivers/block/nd/dimm_devs.c index caa51d3ea6af..ae77bf4a5188 100644 --- a/drivers/block/nd/dimm_devs.c +++ b/drivers/block/nd/dimm_devs.c @@ -417,6 +417,41 @@ static struct nd_dimm *nd_dimm_create(struct nd_bus *nd_bus, } /** + * nd_blk_available_dpa - account the unused dpa of BLK region + * @nd_mapping: container of dpa-resource-root + labels + * + * Unlike PMEM, BLK namespaces can occupy discontiguous DPA ranges. + */ +resource_size_t nd_blk_available_dpa(struct nd_mapping *nd_mapping) +{ + struct nd_dimm_drvdata *ndd = to_ndd(nd_mapping); + resource_size_t map_end, busy = 0, available; + struct resource *res; + + if (!ndd) + return 0; + + map_end = nd_mapping->start + nd_mapping->size - 1; + for_each_dpa_resource(ndd, res) + if (res->start >= nd_mapping->start && res->start < map_end) { + resource_size_t end = min(map_end, res->end); + + busy += end - res->start + 1; + } else if (res->end >= nd_mapping->start && res->end <= map_end) { + busy += res->end - nd_mapping->start; + } else if (nd_mapping->start > res->start + && nd_mapping->start < res->end) { + /* total eclipse of the BLK region mapping */ + busy += nd_mapping->size; + } + + available = map_end - nd_mapping->start + 1; + if (busy < available) + return available - busy; + return 0; +} + +/** * nd_pmem_available_dpa - for the given dimm+region account unallocated dpa * @nd_mapping: container of dpa-resource-root + labels * @nd_region: constrain available space check to this reference region diff --git a/drivers/block/nd/namespace_devs.c b/drivers/block/nd/namespace_devs.c index 386776845830..de36f3891284 100644 --- a/drivers/block/nd/namespace_devs.c +++ b/drivers/block/nd/namespace_devs.c @@ -37,7 +37,15 @@ static void namespace_pmem_release(struct device *dev) static void namespace_blk_release(struct device *dev) { - /* TODO: blk namespace support */ + struct nd_namespace_blk *nsblk = to_nd_namespace_blk(dev); + struct nd_region *nd_region = to_nd_region(dev->parent); + + if (nsblk->id >= 0) + ida_simple_remove(&nd_region->ns_ida, nsblk->id); + kfree(nsblk->alt_name); + kfree(nsblk->uuid); + kfree(nsblk->res); + kfree(nsblk); } static struct device_type namespace_io_device_type = { @@ -90,8 +98,9 @@ static ssize_t __alt_name_store(struct device *dev, const char *buf, ns_altname = &nspm->alt_name; } else if (is_namespace_blk(dev)) { - /* TODO: blk namespace support */ - return -ENXIO; + struct nd_namespace_blk *nsblk = to_nd_namespace_blk(dev); + + ns_altname = &nsblk->alt_name; } else return -ENXIO; @@ -124,6 +133,24 @@ out: return rc; } +static resource_size_t nd_namespace_blk_size(struct nd_namespace_blk *nsblk) +{ + struct nd_region *nd_region = to_nd_region(nsblk->dev.parent); + struct nd_mapping *nd_mapping = &nd_region->mapping[0]; + struct nd_dimm_drvdata *ndd = to_ndd(nd_mapping); + struct nd_label_id label_id; + resource_size_t size = 0; + struct resource *res; + + if (!nsblk->uuid) + return 0; + nd_label_gen_id(&label_id, nsblk->uuid, NSLABEL_FLAG_LOCAL); + for_each_dpa_resource(ndd, res) + if (strcmp(res->name, label_id.id) == 0) + size += resource_size(res); + return size; +} + static ssize_t alt_name_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { @@ -150,8 +177,9 @@ static ssize_t alt_name_show(struct device *dev, ns_altname = nspm->alt_name; } else if (is_namespace_blk(dev)) { - /* TODO: blk namespace support */ - return -ENXIO; + struct nd_namespace_blk *nsblk = to_nd_namespace_blk(dev); + + ns_altname = nsblk->alt_name; } else return -ENXIO; @@ -197,6 +225,8 @@ static int scan_free(struct nd_region *nd_region, new_start = res->start; rc = adjust_resource(res, new_start, resource_size(res) - n); + if (rc == 0) + res->flags |= DPA_RESOURCE_ADJUSTED; nd_dbg_dpa(nd_region, ndd, res, "shrink %d\n", rc); break; } @@ -257,14 +287,15 @@ static resource_size_t init_dpa_allocation(struct nd_label_id *label_id, return rc ? n : 0; } -static bool space_valid(bool is_pmem, struct nd_label_id *label_id, - struct resource *res) +static bool space_valid(bool is_pmem, bool is_reserve, + struct nd_label_id *label_id, struct resource *res) { /* * For BLK-space any space is valid, for PMEM-space, it must be - * contiguous with an existing allocation. + * contiguous with an existing allocation unless we are + * reserving pmem. */ - if (!is_pmem) + if (is_reserve || !is_pmem) return true; if (!res || strcmp(res->name, label_id->id) == 0) return true; @@ -280,6 +311,7 @@ static resource_size_t scan_allocate(struct nd_region *nd_region, resource_size_t n) { resource_size_t mapping_end = nd_mapping->start + nd_mapping->size - 1; + bool is_reserve = strcmp(label_id->id, "pmem-reserve") == 0; bool is_pmem = strncmp(label_id->id, "pmem", 4) == 0; struct nd_dimm_drvdata *ndd = to_ndd(nd_mapping); const resource_size_t to_allocate = n; @@ -305,7 +337,7 @@ static resource_size_t scan_allocate(struct nd_region *nd_region, if (!first++ && res->start > nd_mapping->start) { free_start = nd_mapping->start; available = res->start - free_start; - if (space_valid(is_pmem, label_id, NULL)) + if (space_valid(is_pmem, is_reserve, label_id, NULL)) loc = ALLOC_BEFORE; } @@ -313,7 +345,7 @@ static resource_size_t scan_allocate(struct nd_region *nd_region, if (!loc && next) { free_start = res->start + resource_size(res); free_end = min(mapping_end, next->start - 1); - if (space_valid(is_pmem, label_id, res) + if (space_valid(is_pmem, is_reserve, label_id, res) && free_start < free_end) { available = free_end + 1 - free_start; loc = ALLOC_MID; @@ -324,7 +356,7 @@ static resource_size_t scan_allocate(struct nd_region *nd_region, if (!loc && !next) { free_start = res->start + resource_size(res); free_end = mapping_end; - if (space_valid(is_pmem, label_id, res) + if (space_valid(is_pmem, is_reserve, label_id, res) && free_start < free_end) { available = free_end + 1 - free_start; loc = ALLOC_AFTER; @@ -338,7 +370,7 @@ static resource_size_t scan_allocate(struct nd_region *nd_region, case ALLOC_BEFORE: if (strcmp(res->name, label_id->id) == 0) { /* adjust current resource up */ - if (is_pmem) + if (is_pmem && !is_reserve) return n; rc = adjust_resource(res, res->start - allocate, resource_size(res) + allocate); @@ -349,7 +381,7 @@ static resource_size_t scan_allocate(struct nd_region *nd_region, case ALLOC_MID: if (strcmp(next->name, label_id->id) == 0) { /* adjust next resource up */ - if (is_pmem) + if (is_pmem && !is_reserve) return n; rc = adjust_resource(next, next->start - allocate, resource_size(next) @@ -375,7 +407,7 @@ static resource_size_t scan_allocate(struct nd_region *nd_region, /* BLK allocate bottom up */ if (!is_pmem) free_start += available - allocate; - else if (free_start != nd_mapping->start) + else if (!is_reserve && free_start != nd_mapping->start) return n; new_res = nd_dimm_allocate_dpa(ndd, label_id, @@ -386,6 +418,8 @@ static resource_size_t scan_allocate(struct nd_region *nd_region, /* adjust current resource down */ rc = adjust_resource(res, res->start, resource_size(res) + allocate); + if (rc == 0) + res->flags |= DPA_RESOURCE_ADJUSTED; } if (!new_res) @@ -411,11 +445,106 @@ static resource_size_t scan_allocate(struct nd_region *nd_region, return 0; } - if (is_pmem && n == to_allocate) + /* + * If we allocated nothing in the BLK case it may be because we are in + * an initial "pmem-reserve pass". Only do an initial BLK allocation + * when none of the DPA space is reserved. + */ + if ((is_pmem || !ndd->dpa.child) && n == to_allocate) return init_dpa_allocation(label_id, nd_region, nd_mapping, n); return n; } +static int merge_dpa(struct nd_region *nd_region, + struct nd_mapping *nd_mapping, struct nd_label_id *label_id) +{ + struct nd_dimm_drvdata *ndd = to_ndd(nd_mapping); + struct resource *res; + + if (strncmp("pmem", label_id->id, 4) == 0) + return 0; + retry: + for_each_dpa_resource(ndd, res) { + int rc; + struct resource *next = res->sibling; + resource_size_t end = res->start + resource_size(res); + + if (!next || strcmp(res->name, label_id->id) != 0 + || strcmp(next->name, label_id->id) != 0 + || end != next->start) + continue; + end += resource_size(next); + nd_dimm_free_dpa(ndd, next); + rc = adjust_resource(res, res->start, end - res->start); + nd_dbg_dpa(nd_region, ndd, res, "merge %d\n", rc); + if (rc) + return rc; + res->flags |= DPA_RESOURCE_ADJUSTED; + goto retry; + } + + return 0; +} + +static int __reserve_free_pmem(struct device *dev, void *data) +{ + struct nd_dimm *nd_dimm = data; + struct nd_region *nd_region; + struct nd_label_id label_id; + int i; + + if (!is_nd_pmem(dev)) + return 0; + + nd_region = to_nd_region(dev); + if (nd_region->ndr_mappings == 0) + return 0; + + memset(&label_id, 0, sizeof(label_id)); + strcat(label_id.id, "pmem-reserve"); + for (i = 0; i < nd_region->ndr_mappings; i++) { + struct nd_mapping *nd_mapping = &nd_region->mapping[i]; + resource_size_t n, rem = 0; + + if (nd_mapping->nd_dimm != nd_dimm) + continue; + + n = nd_pmem_available_dpa(nd_region, nd_mapping, &rem); + if (n == 0) + return 0; + rem = scan_allocate(nd_region, nd_mapping, &label_id, n); + dev_WARN_ONCE(&nd_region->dev, rem, + "pmem reserve underrun: %#llx of %#llx bytes\n", + (unsigned long long) n - rem, + (unsigned long long) n); + return rem ? -ENXIO : 0; + } + + return 0; +} + +static void release_free_pmem(struct nd_bus *nd_bus, struct nd_mapping *nd_mapping) +{ + struct nd_dimm_drvdata *ndd = to_ndd(nd_mapping); + struct resource *res, *_res; + + for_each_dpa_resource_safe(ndd, res, _res) + if (strcmp(res->name, "pmem-reserve") == 0) + nd_dimm_free_dpa(ndd, res); +} + +static int reserve_free_pmem(struct nd_bus *nd_bus, + struct nd_mapping *nd_mapping) +{ + struct nd_dimm *nd_dimm = nd_mapping->nd_dimm; + int rc; + + rc = device_for_each_child(&nd_bus->dev, nd_dimm, __reserve_free_pmem); + if (rc) + release_free_pmem(nd_bus, nd_mapping); + return rc; +} + /** * grow_dpa_allocation - for each dimm allocate n bytes for @label_id * @nd_region: the set of dimms to allocate @n more bytes from @@ -432,13 +561,44 @@ static resource_size_t scan_allocate(struct nd_region *nd_region, static int grow_dpa_allocation(struct nd_region *nd_region, struct nd_label_id *label_id, resource_size_t n) { + struct nd_bus *nd_bus = walk_to_nd_bus(&nd_region->dev); + bool is_pmem = strncmp(label_id->id, "pmem", 4) == 0; int i; for (i = 0; i < nd_region->ndr_mappings; i++) { struct nd_mapping *nd_mapping = &nd_region->mapping[i]; - int rc; + resource_size_t rem = n; + int rc, j; - rc = scan_allocate(nd_region, nd_mapping, label_id, n); + /* + * In the BLK case try once with all unallocated PMEM + * reserved, and once without + */ + for (j = is_pmem; j < 2; j++) { + bool blk_only = j == 0; + + if (blk_only) { + rc = reserve_free_pmem(nd_bus, nd_mapping); + if (rc) + return rc; + } + rem = scan_allocate(nd_region, nd_mapping, label_id, rem); + if (blk_only) + release_free_pmem(nd_bus, nd_mapping); + + /* try again and allow encroachments into PMEM */ + if (rem == 0) + break; + } + + dev_WARN_ONCE(&nd_region->dev, rem, + "allocation underrun: %#llx of %#llx bytes\n", + (unsigned long long) n - rem, + (unsigned long long) n); + if (rem) + return -ENXIO; + + rc = merge_dpa(nd_region, nd_mapping, label_id); if (rc) return rc; } @@ -474,8 +634,10 @@ static ssize_t __size_store(struct device *dev, unsigned long long val) uuid = nspm->uuid; } else if (is_namespace_blk(dev)) { - /* TODO: blk namespace support */ - return -ENXIO; + struct nd_namespace_blk *nsblk = to_nd_namespace_blk(dev); + + uuid = nsblk->uuid; + flags = NSLABEL_FLAG_LOCAL; } /* @@ -529,6 +691,14 @@ static ssize_t __size_store(struct device *dev, unsigned long long val) nd_namespace_pmem_set_size(nd_region, nspm, val * nd_region->ndr_mappings); + } else if (is_namespace_blk(dev)) { + /* + * Try to delete the namespace if we deleted all of its + * allocation and this is not the seed device for the + * region. + */ + if (val == 0 && nd_region->ns_seed != dev) + nd_device_unregister(dev, ND_ASYNC); } return rc; @@ -555,8 +725,9 @@ static ssize_t size_store(struct device *dev, uuid = &nspm->uuid; } else if (is_namespace_blk(dev)) { - /* TODO: blk namespace support */ - rc = -ENXIO; + struct nd_namespace_blk *nsblk = to_nd_namespace_blk(dev); + + uuid = &nsblk->uuid; } if (rc == 0 && val == 0 && uuid) { @@ -577,21 +748,23 @@ static ssize_t size_store(struct device *dev, static ssize_t size_show(struct device *dev, struct device_attribute *attr, char *buf) { + unsigned long long size = 0; + + nd_bus_lock(dev); if (is_namespace_pmem(dev)) { struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev); - return sprintf(buf, "%llu\n", (unsigned long long) - resource_size(&nspm->nsio.res)); + size = resource_size(&nspm->nsio.res); } else if (is_namespace_blk(dev)) { - /* TODO: blk namespace support */ - return -ENXIO; + size = nd_namespace_blk_size(to_nd_namespace_blk(dev)); } else if (is_namespace_io(dev)) { struct nd_namespace_io *nsio = to_nd_namespace_io(dev); - return sprintf(buf, "%llu\n", (unsigned long long) - resource_size(&nsio->res)); - } else - return -ENXIO; + size = resource_size(&nsio->res); + } + nd_bus_unlock(dev); + + return sprintf(buf, "%llu\n", size); } static DEVICE_ATTR(size, S_IRUGO, size_show, size_store); @@ -605,8 +778,9 @@ static ssize_t uuid_show(struct device *dev, uuid = nspm->uuid; } else if (is_namespace_blk(dev)) { - /* TODO: blk namespace support */ - return -ENXIO; + struct nd_namespace_blk *nsblk = to_nd_namespace_blk(dev); + + uuid = nsblk->uuid; } else return -ENXIO; @@ -670,8 +844,9 @@ static ssize_t uuid_store(struct device *dev, ns_uuid = &nspm->uuid; } else if (is_namespace_blk(dev)) { - /* TODO: blk namespace support */ - return -ENXIO; + struct nd_namespace_blk *nsblk = to_nd_namespace_blk(dev); + + ns_uuid = &nsblk->uuid; } else return -ENXIO; @@ -713,12 +888,48 @@ static ssize_t resource_show(struct device *dev, } static DEVICE_ATTR_RO(resource); +static const unsigned long ns_lbasize_supported[] = { 512, 0 }; + +static ssize_t sector_size_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct nd_namespace_blk *nsblk = to_nd_namespace_blk(dev); + + if (!is_namespace_blk(dev)) + return -ENXIO; + + return nd_sector_size_show(nsblk->lbasize, ns_lbasize_supported, buf); +} + +static ssize_t sector_size_store(struct device *dev, + struct device_attribute *attr, const char *buf, size_t len) +{ + struct nd_namespace_blk *nsblk = to_nd_namespace_blk(dev); + ssize_t rc; + + if (!is_namespace_blk(dev)) + return -ENXIO; + + device_lock(dev); + nd_bus_lock(dev); + rc = nd_sector_size_store(dev, buf, &nsblk->lbasize, + ns_lbasize_supported); + dev_dbg(dev, "%s: result: %zd wrote: %s%s", __func__, + rc, buf, buf[len - 1] == '\n' ? "" : "\n"); + nd_bus_unlock(dev); + device_unlock(dev); + + return rc ? rc : len; +} +static DEVICE_ATTR_RW(sector_size); + static struct attribute *nd_namespace_attributes[] = { &dev_attr_type.attr, &dev_attr_size.attr, &dev_attr_uuid.attr, &dev_attr_resource.attr, &dev_attr_alt_name.attr, + &dev_attr_sector_size.attr, NULL, }; @@ -735,6 +946,10 @@ static umode_t nd_namespace_attr_visible(struct kobject *kobj, struct attribute if (is_namespace_pmem(dev) || is_namespace_blk(dev)) { if (a == &dev_attr_size.attr) return S_IWUSR; + + if (is_namespace_pmem(dev) && a == &dev_attr_sector_size.attr) + return 0; + return a->mode; } @@ -1029,6 +1244,173 @@ static struct device **create_namespace_pmem(struct nd_region *nd_region) return NULL; } +struct resource *nsblk_add_resource(struct nd_region *nd_region, + struct nd_dimm_drvdata *ndd, struct nd_namespace_blk *nsblk, + resource_size_t start) +{ + struct nd_label_id label_id; + struct resource *res; + + nd_label_gen_id(&label_id, nsblk->uuid, NSLABEL_FLAG_LOCAL); + nsblk->res = krealloc(nsblk->res, + sizeof(void *) * (nsblk->num_resources + 1), + GFP_KERNEL); + if (!nsblk->res) + return NULL; + for_each_dpa_resource(ndd, res) + if (strcmp(res->name, label_id.id) == 0 && res->start == start) { + nsblk->res[nsblk->num_resources++] = res; + return res; + } + return NULL; +} + +static struct device *nd_namespace_blk_create(struct nd_region *nd_region) +{ + struct nd_namespace_blk *nsblk; + struct device *dev; + + if (!is_nd_blk(&nd_region->dev)) + return NULL; + + nsblk = kzalloc(sizeof(*nsblk), GFP_KERNEL); + if (!nsblk) + return NULL; + + dev = &nsblk->dev; + dev->type = &namespace_blk_device_type; + nsblk->id = ida_simple_get(&nd_region->ns_ida, 0, 0, GFP_KERNEL); + if (nsblk->id < 0) { + kfree(nsblk); + return NULL; + } + dev_set_name(dev, "namespace%d.%d", nd_region->id, nsblk->id); + dev->parent = &nd_region->dev; + dev->groups = nd_namespace_attribute_groups; + + return &nsblk->dev; +} + +void nd_region_create_blk_seed(struct nd_region *nd_region) +{ + WARN_ON(!is_nd_bus_locked(&nd_region->dev)); + nd_region->ns_seed = nd_namespace_blk_create(nd_region); + /* + * Seed creation failures are not fatal, provisioning is simply + * disabled until memory becomes available + */ + if (!nd_region->ns_seed) + dev_err(&nd_region->dev, "failed to create blk namespace\n"); + else + nd_device_register(nd_region->ns_seed); +} + +static struct device **create_namespace_blk(struct nd_region *nd_region) +{ + struct nd_mapping *nd_mapping = &nd_region->mapping[0]; + struct nd_namespace_label __iomem *nd_label; + struct device *dev, **devs = NULL; + u8 label_uuid[NSLABEL_UUID_LEN]; + struct nd_namespace_blk *nsblk; + struct nd_dimm_drvdata *ndd; + int i, l, count = 0; + struct resource *res; + + if (nd_region->ndr_mappings == 0) + return NULL; + + ndd = to_ndd(nd_mapping); + for_each_label(l, nd_label, nd_mapping->labels) { + u32 flags = readl(&nd_label->flags); + char *name[NSLABEL_NAME_LEN]; + struct device **__devs; + + if (flags & NSLABEL_FLAG_LOCAL) + /* pass */; + else + continue; + + memcpy_fromio(label_uuid, nd_label->uuid, NSLABEL_UUID_LEN); + for (i = 0; i < count; i++) { + nsblk = to_nd_namespace_blk(devs[i]); + if (memcmp(nsblk->uuid, label_uuid, + NSLABEL_UUID_LEN) == 0) { + res = nsblk_add_resource(nd_region, ndd, nsblk, + readq(&nd_label->dpa)); + if (!res) + goto err; + nd_dbg_dpa(nd_region, ndd, res, "%s assign\n", + dev_name(&nsblk->dev)); + break; + } + } + if (i < count) + continue; + __devs = kcalloc(count + 2, sizeof(dev), GFP_KERNEL); + if (!__devs) + goto err; + memcpy(__devs, devs, sizeof(dev) * count); + kfree(devs); + devs = __devs; + + nsblk = kzalloc(sizeof(*nsblk), GFP_KERNEL); + if (!nsblk) + goto err; + dev = &nsblk->dev; + dev->type = &namespace_blk_device_type; + dev_set_name(dev, "namespace%d.%d", nd_region->id, count); + devs[count++] = dev; + nsblk->id = -1; + nsblk->lbasize = readq(&nd_label->lbasize); + nsblk->uuid = kmemdup(label_uuid, NSLABEL_UUID_LEN, GFP_KERNEL); + if (!nsblk->uuid) + goto err; + memcpy_fromio(name, nd_label->name, NSLABEL_NAME_LEN); + if (name[0]) + nsblk->alt_name = kmemdup(name, NSLABEL_NAME_LEN, + GFP_KERNEL); + res = nsblk_add_resource(nd_region, ndd, nsblk, + readq(&nd_label->dpa)); + if (!res) + goto err; + nd_dbg_dpa(nd_region, ndd, res, "%s assign\n", + dev_name(&nsblk->dev)); + } + + dev_dbg(&nd_region->dev, "%s: discovered %d blk namespace%s\n", + __func__, count, count == 1 ? "" : "s"); + + if (count == 0) { + /* Publish a zero-sized namespace for userspace to configure. */ + for (i = 0; i < nd_region->ndr_mappings; i++) { + struct nd_mapping *nd_mapping = &nd_region->mapping[i]; + + kfree(nd_mapping->labels); + nd_mapping->labels = NULL; + } + + devs = kcalloc(2, sizeof(dev), GFP_KERNEL); + if (!devs) + goto err; + nsblk = kzalloc(sizeof(*nsblk), GFP_KERNEL); + if (!nsblk) + goto err; + dev = &nsblk->dev; + dev->type = &namespace_blk_device_type; + devs[count++] = dev; + } + + return devs; + +err: + for (i = 0; i < count; i++) { + nsblk = to_nd_namespace_blk(devs[i]); + namespace_blk_release(&nsblk->dev); + } + kfree(devs); + return NULL; +} + static int init_active_labels(struct nd_region *nd_region) { int i; @@ -1088,6 +1470,9 @@ int nd_region_register_namespaces(struct nd_region *nd_region, int *err) case ND_DEVICE_NAMESPACE_PMEM: devs = create_namespace_pmem(nd_region); break; + case ND_DEVICE_NAMESPACE_BLOCK: + devs = create_namespace_blk(nd_region); + break; default: break; } @@ -1101,23 +1486,56 @@ int nd_region_register_namespaces(struct nd_region *nd_region, int *err) nd_region->ns_seed = devs[0]; for (i = 0; devs[i]; i++) { struct device *dev = devs[i]; + int id; + + if (type == ND_DEVICE_NAMESPACE_BLOCK) { + struct nd_namespace_blk *nsblk; - dev_set_name(dev, "namespace%d.%d", nd_region->id, i); + nsblk = to_nd_namespace_blk(dev); + id = ida_simple_get(&nd_region->ns_ida, 0, 0, + GFP_KERNEL); + nsblk->id = id; + } else + id = i; + + if (id < 0) + break; + dev_set_name(dev, "namespace%d.%d", nd_region->id, id); dev->parent = &nd_region->dev; dev->groups = nd_namespace_attribute_groups; nd_device_register(dev); } - kfree(devs); - return i; + if (devs[i]) { + int j; + + for (j = i; devs[j]; j++) { + struct device *dev = devs[j]; + + device_initialize(dev); + put_device(dev); + } + *err = j - i; + /* + * All of the namespaces we tried to register failed, so + * fail region activation. + */ + if (*err == 0) + rc = -ENODEV; + } + kfree(devs); err: - for (i = 0; i < nd_region->ndr_mappings; i++) { - struct nd_mapping *nd_mapping = &nd_region->mapping[i]; + if (rc == -ENODEV) { + nd_region->ns_seed = NULL; + for (i = 0; i < nd_region->ndr_mappings; i++) { + struct nd_mapping *nd_mapping = &nd_region->mapping[i]; - kfree(nd_mapping->labels); - nd_mapping->labels = NULL; + kfree(nd_mapping->labels); + nd_mapping->labels = NULL; + } + return rc; } - return rc; + return i; } diff --git a/drivers/block/nd/nd-private.h b/drivers/block/nd/nd-private.h index 03b14ab8fc7d..1a14ebb40a1a 100644 --- a/drivers/block/nd/nd-private.h +++ b/drivers/block/nd/nd-private.h @@ -17,6 +17,7 @@ #include <linux/sizes.h> #include <linux/mutex.h> #include <linux/io.h> +#include <linux/nd.h> #include "nfit.h" extern struct list_head nd_bus_list; @@ -26,6 +27,8 @@ extern int nd_dimm_major; enum { /* need to set a limit somewhere, but yes, this is likely overkill */ ND_IOCTL_MAX_BUFLEN = SZ_4M, + /* mark newly adjusted resources as requiring a label update */ + DPA_RESOURCE_ADJUSTED = 1 << 0, }; /* @@ -116,6 +119,8 @@ void nd_dimm_exit(void); int nd_region_exit(void); void nd_region_probe_start(struct nd_bus *nd_bus, struct device *dev); void nd_region_probe_end(struct nd_bus *nd_bus, struct device *dev, int rc); +struct nd_region; +void nd_region_create_blk_seed(struct nd_region *nd_region); void nd_region_notify_remove(struct nd_bus *nd_bus, struct device *dev, int rc); int nd_bus_create_ndctl(struct nd_bus *nd_bus); void nd_bus_destroy_ndctl(struct nd_bus *nd_bus); @@ -131,10 +136,15 @@ struct nd_dimm_drvdata; struct nd_mapping; resource_size_t nd_pmem_available_dpa(struct nd_region *nd_region, struct nd_mapping *nd_mapping, resource_size_t *overlap); +resource_size_t nd_blk_available_dpa(struct nd_mapping *nd_mapping); resource_size_t nd_region_available_dpa(struct nd_region *nd_region); struct resource *nd_dimm_allocate_dpa(struct nd_dimm_drvdata *ndd, struct nd_label_id *label_id, resource_size_t start, resource_size_t n); resource_size_t nd_dimm_allocated_dpa(struct nd_dimm_drvdata *ndd, struct nd_label_id *label_id); +struct nd_mapping; +struct resource *nsblk_add_resource(struct nd_region *nd_region, + struct nd_dimm_drvdata *ndd, struct nd_namespace_blk *nsblk, + resource_size_t start); #endif /* __ND_PRIVATE_H__ */ diff --git a/drivers/block/nd/nd.h b/drivers/block/nd/nd.h index 386e17056d3c..5adb55e76b33 100644 --- a/drivers/block/nd/nd.h +++ b/drivers/block/nd/nd.h @@ -97,6 +97,7 @@ static inline struct nd_namespace_label __iomem *nd_get_label( struct nd_region { struct device dev; struct nd_spa *nd_spa; + struct ida ns_ida; struct device *ns_seed; u16 ndr_mappings; u64 ndr_size; @@ -125,6 +126,10 @@ void nd_device_unregister(struct device *dev, enum nd_async_mode mode); u64 nd_fletcher64(void __iomem *addr, size_t len); int nd_uuid_store(struct device *dev, u8 **uuid_out, const char *buf, size_t len); +ssize_t nd_sector_size_show(unsigned long current_lbasize, + const unsigned long *supported, char *buf); +ssize_t nd_sector_size_store(struct device *dev, const char *buf, + unsigned long *current_lbasize, const unsigned long *supported); extern struct attribute_group nd_device_attribute_group; struct nd_dimm; struct nd_dimm_drvdata *to_ndd(struct nd_mapping *nd_mapping); diff --git a/drivers/block/nd/region_devs.c b/drivers/block/nd/region_devs.c index 8bcfd9b91a71..1b2c81e0eb0f 100644 --- a/drivers/block/nd/region_devs.c +++ b/drivers/block/nd/region_devs.c @@ -112,7 +112,12 @@ static int is_uuid_busy(struct device *dev, void *data) break; } case ND_DEVICE_NAMESPACE_BLOCK: { - /* TODO: blk namespace support */ + struct nd_namespace_blk *nsblk = to_nd_namespace_blk(dev); + + if (!nsblk->uuid) + break; + if (memcmp(uuid, nsblk->uuid, NSLABEL_UUID_LEN) == 0) + return -EBUSY; break; } default: @@ -235,7 +240,7 @@ resource_size_t nd_region_available_dpa(struct nd_region *nd_region) goto retry; } } else if (is_nd_blk(&nd_region->dev)) { - /* TODO: BLK Namespace support */ + available += nd_blk_available_dpa(nd_mapping); } } @@ -494,6 +499,11 @@ static void nd_region_notify_driver_action(struct nd_bus *nd_bus, else atomic_dec(&nd_dimm->busy); } + } else if (dev->parent && is_nd_blk(dev->parent) && probe && rc == 0) { + struct nd_region *nd_region = to_nd_region(dev->parent); + + if (nd_region->ns_seed == dev) + nd_region_create_blk_seed(nd_region); } } @@ -735,6 +745,7 @@ static struct nd_region *nd_region_create(struct nd_bus *nd_bus, dev->groups = nd_region_attribute_groups; nd_region->ndr_size = readq(&nd_spa->nfit_spa->spa_length); nd_region->ndr_start = readq(&nd_spa->nfit_spa->spa_base); + ida_init(&nd_region->ns_ida); switch (spa_type) { case NFIT_SPA_PM: nd_spa_range_init(nd_bus, nd_region, &nd_pmem_device_type); diff --git a/include/linux/nd.h b/include/linux/nd.h index 255c38a83083..23276ea91690 100644 --- a/include/linux/nd.h +++ b/include/linux/nd.h @@ -50,6 +50,26 @@ struct nd_namespace_pmem { u8 *uuid; }; +/** + * struct nd_namespace_blk - namespace for dimm-bounded persistent memory + * @dev: namespace device creation by the nd region driver + * @alt_name: namespace name supplied in the dimm label + * @uuid: namespace name supplied in the dimm label + * @id: ida allocated id + * @lbasize: blk namespaces have a native sector size when btt not present + * @num_resources: number of dpa extents to claim + * @res: discontiguous dpa extents for given dimm + */ +struct nd_namespace_blk { + struct device dev; + char *alt_name; + u8 *uuid; + int id; + unsigned long lbasize; + int num_resources; + struct resource **res; +}; + static inline struct nd_namespace_io *to_nd_namespace_io(struct device *dev) { return container_of(dev, struct nd_namespace_io, dev); @@ -62,6 +82,11 @@ static inline struct nd_namespace_pmem *to_nd_namespace_pmem(struct device *dev) return container_of(nsio, struct nd_namespace_pmem, nsio); } +static inline struct nd_namespace_blk *to_nd_namespace_blk(struct device *dev) +{ + return container_of(dev, struct nd_namespace_blk, dev); +} + #define MODULE_ALIAS_ND_DEVICE(type) \ MODULE_ALIAS("nd:t" __stringify(type) "*") #define ND_DEVICE_MODALIAS_FMT "nd:t%d"

After 'uuid', 'size', 'sector_size', and optionally 'alt_name' have been set to valid values the labels on the dimm can be updated. The difference with the pmem case is that blk namespaces are limited to one dimm and can cover discontiguous ranges in dpa space. Also, after allocating label slots, it is useful for userspace to know how many slots are left. Export this information in sysfs. Signed-off-by: Dan Williams <dan.j.williams(a)intel.com&gt; --- drivers/block/nd/bus.c | 4 drivers/block/nd/dimm_devs.c | 25 +++ drivers/block/nd/label.c | 297 +++++++++++++++++++++++++++++++++++-- drivers/block/nd/label.h | 5 + drivers/block/nd/namespace_devs.c | 57 +++++++ drivers/block/nd/nd-private.h | 1 6 files changed, 367 insertions(+), 22 deletions(-) diff --git a/drivers/block/nd/bus.c b/drivers/block/nd/bus.c index 8e70098b6cb0..cb619d70166d 100644 --- a/drivers/block/nd/bus.c +++ b/drivers/block/nd/bus.c @@ -165,6 +165,10 @@ static void nd_async_device_unregister(void *d, async_cookie_t cookie) { struct device *dev = d; + /* flush bus operations before delete */ + nd_bus_lock(dev); + nd_bus_unlock(dev); + device_unregister(dev); put_device(dev); } diff --git a/drivers/block/nd/dimm_devs.c b/drivers/block/nd/dimm_devs.c index a1685c01a2bb..eead15c98196 100644 --- a/drivers/block/nd/dimm_devs.c +++ b/drivers/block/nd/dimm_devs.c @@ -19,6 +19,7 @@ #include <linux/fs.h> #include <linux/mm.h> #include "nd-private.h" +#include "label.h" #include "nfit.h" #include "nd.h" @@ -364,6 +365,29 @@ static ssize_t state_show(struct device *dev, struct device_attribute *attr, } static DEVICE_ATTR_RO(state); +static ssize_t available_slots_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct nd_dimm_drvdata *ndd = dev_get_drvdata(dev); + ssize_t rc; + u32 nfree; + + if (!ndd) + return -ENXIO; + + nd_bus_lock(dev); + nfree = nd_label_nfree(ndd); + if (nfree - 1 > nfree) { + dev_WARN_ONCE(dev, 1, "we ate our last label?\n"); + nfree = 0; + } else + nfree--; + rc = sprintf(buf, "%d\n", nfree); + nd_bus_unlock(dev); + return rc; +} +static DEVICE_ATTR_RO(available_slots); + static struct attribute *nd_dimm_attributes[] = { &dev_attr_handle.attr, &dev_attr_phys_id.attr, @@ -374,6 +398,7 @@ static struct attribute *nd_dimm_attributes[] = { &dev_attr_state.attr, &dev_attr_revision.attr, &dev_attr_commands.attr, + &dev_attr_available_slots.attr, NULL, }; diff --git a/drivers/block/nd/label.c b/drivers/block/nd/label.c index 78898b642191..069c26d50ed1 100644 --- a/drivers/block/nd/label.c +++ b/drivers/block/nd/label.c @@ -58,7 +58,7 @@ size_t sizeof_namespace_index(struct nd_dimm_drvdata *ndd) return ndd->nsindex_size; } -static int nd_dimm_num_label_slots(struct nd_dimm_drvdata *ndd) +int nd_dimm_num_label_slots(struct nd_dimm_drvdata *ndd) { return ndd->nsarea.config_size / 129; } @@ -416,7 +416,7 @@ u32 nd_label_nfree(struct nd_dimm_drvdata *ndd) WARN_ON(!is_nd_bus_locked(ndd->dev)); if (!preamble_next(ndd, &nsindex, &free, &nslot)) - return 0; + return nd_dimm_num_label_slots(ndd); return bitmap_weight(free, nslot); } @@ -553,22 +553,270 @@ static int __pmem_label_update(struct nd_region *nd_region, return 0; } -static int init_labels(struct nd_mapping *nd_mapping) +static void del_label(struct nd_mapping *nd_mapping, int l) +{ + struct nd_namespace_label __iomem *next_label, __iomem *nd_label; + struct nd_dimm_drvdata *ndd = to_ndd(nd_mapping); + unsigned int slot; + int j; + + nd_label = nd_get_label(nd_mapping->labels, l); + slot = to_slot(ndd, nd_label); + dev_vdbg(ndd->dev, "%s: clear: %d\n", __func__, slot); + + for (j = l; (next_label = nd_get_label(nd_mapping->labels, j + 1)); j++) + nd_set_label(nd_mapping->labels, next_label, j); + nd_set_label(nd_mapping->labels, NULL, j); +} + +static bool is_old_resource(struct resource *res, struct resource **list, int n) { int i; + + if (res->flags & DPA_RESOURCE_ADJUSTED) + return false; + for (i = 0; i < n; i++) + if (res == list[i]) + return true; + return false; +} + +static struct resource *to_resource(struct nd_dimm_drvdata *ndd, + struct nd_namespace_label __iomem *nd_label) +{ + struct resource *res; + + for_each_dpa_resource(ndd, res) { + if (res->start != readq(&nd_label->dpa)) + continue; + if (resource_size(res) != readq(&nd_label->rawsize)) + continue; + return res; + } + + return NULL; +} + +/* + * 1/ Account all the labels that can be freed after this update + * 2/ Allocate and write the label to the staging (next) index + * 3/ Record the resources in the namespace device + */ +static int __blk_label_update(struct nd_region *nd_region, + struct nd_mapping *nd_mapping, struct nd_namespace_blk *nsblk, + int num_labels) +{ + int i, l, alloc, victims, nfree, old_num_resources, nlabel, rc = -ENXIO; + struct nd_dimm_drvdata *ndd = to_ndd(nd_mapping); + struct nd_namespace_label __iomem *nd_label; + struct nd_namespace_index __iomem *nsindex; + unsigned long *free, *victim_map = NULL; + struct resource *res, **old_res_list; + struct nd_label_id label_id; + u8 uuid[NSLABEL_UUID_LEN]; + u32 nslot, slot; + + if (!preamble_next(ndd, &nsindex, &free, &nslot)) + return -ENXIO; + + old_res_list = nsblk->res; + nfree = nd_label_nfree(ndd); + old_num_resources = nsblk->num_resources; + nd_label_gen_id(&label_id, nsblk->uuid, NSLABEL_FLAG_LOCAL); + + /* + * We need to loop over the old resources a few times, which seems a + * bit inefficient, but we need to know that we have the label + * space before we start mutating the tracking structures. + * Otherwise the recovery method of last resort for userspace is + * disable and re-enable the parent region. + */ + alloc = 0; + for_each_dpa_resource(ndd, res) { + if (strcmp(res->name, label_id.id) != 0) + continue; + if (!is_old_resource(res, old_res_list, old_num_resources)) + alloc++; + } + + victims = 0; + if (old_num_resources) { + /* convert old local-label-map to dimm-slot victim-map */ + victim_map = kcalloc(BITS_TO_LONGS(nslot), sizeof(long), + GFP_KERNEL); + if (!victim_map) + return -ENOMEM; + + /* mark unused labels for garbage collection */ + for_each_clear_bit_le(slot, free, nslot) { + nd_label = nd_label_base(ndd) + slot; + memcpy_fromio(uuid, nd_label->uuid, NSLABEL_UUID_LEN); + if (memcmp(uuid, nsblk->uuid, NSLABEL_UUID_LEN) != 0) + continue; + res = to_resource(ndd, nd_label); + if (res && is_old_resource(res, old_res_list, + old_num_resources)) + continue; + slot = to_slot(ndd, nd_label); + set_bit(slot, victim_map); + victims++; + } + } + + /* don't allow updates that consume the last label */ + if (nfree - alloc < 0 || nfree - alloc + victims < 1) { + dev_info(&nsblk->dev, "insufficient label space\n"); + kfree(victim_map); + return -ENOSPC; + } + /* from here on we need to abort on error */ + + + /* assign all resources to the namespace before writing the labels */ + nsblk->res = NULL; + nsblk->num_resources = 0; + for_each_dpa_resource(ndd, res) { + if (strcmp(res->name, label_id.id) != 0) + continue; + if (!nsblk_add_resource(nd_region, ndd, nsblk, res->start)) { + rc = -ENOMEM; + goto abort; + } + } + + for (i = 0; i < nsblk->num_resources; i++) { + size_t offset; + + res = nsblk->res[i]; + if (is_old_resource(res, old_res_list, old_num_resources)) + continue; /* carry-over */ + slot = nd_label_alloc_slot(ndd); + if (slot == UINT_MAX) + goto abort; + dev_dbg(ndd->dev, "%s: allocated: %d\n", __func__, slot); + + nd_label = nd_label_base(ndd) + slot; + memset_io(nd_label, 0, sizeof(struct nd_namespace_label)); + memcpy_toio(nd_label->uuid, nsblk->uuid, NSLABEL_UUID_LEN); + if (nsblk->alt_name) + memcpy_toio(nd_label->name, nsblk->alt_name, + NSLABEL_NAME_LEN); + writel(NSLABEL_FLAG_LOCAL, &nd_label->flags); + writew(0, &nd_label->nlabel); /* N/A */ + writew(0, &nd_label->position); /* N/A */ + writeq(0, &nd_label->isetcookie); /* N/A */ + writeq(res->start, &nd_label->dpa); + writeq(resource_size(res), &nd_label->rawsize); + writeq(nsblk->lbasize, &nd_label->lbasize); + writel(slot, &nd_label->slot); + + /* update label */ + offset = nd_label_offset(ndd, nd_label); + rc = nd_dimm_set_config_data(ndd, offset, nd_label, + sizeof(struct nd_namespace_label)); + if (rc < 0) + goto abort; + } + + /* free up now unused slots in the new index */ + for_each_set_bit(slot, victim_map, victim_map ? nslot : 0) { + dev_dbg(ndd->dev, "%s: free: %d\n", __func__, slot); + nd_label_free_slot(ndd, slot); + } + + /* update index */ + rc = nd_label_write_index(ndd, ndd->ns_next, + nd_inc_seq(readl(&nsindex->seq)), 0); + if (rc) + goto abort; + + /* + * Now that the on-dimm labels are up to date, fix up the tracking + * entries in nd_mapping->labels + */ + nlabel = 0; + for_each_label(l, nd_label, nd_mapping->labels) { + nlabel++; + memcpy_fromio(uuid, nd_label->uuid, NSLABEL_UUID_LEN); + if (memcmp(uuid, nsblk->uuid, NSLABEL_UUID_LEN) != 0) + continue; + nlabel--; + del_label(nd_mapping, l); + l--; /* retry with the new label at this index */ + } + if (nlabel + nsblk->num_resources > num_labels) { + /* + * Bug, we can't end up with more resources than + * available labels + */ + WARN_ON_ONCE(1); + rc = -ENXIO; + goto out; + } + + for_each_clear_bit_le(slot, free, nslot) { + nd_label = nd_label_base(ndd) + slot; + memcpy_fromio(uuid, nd_label->uuid, NSLABEL_UUID_LEN); + if (memcmp(uuid, nsblk->uuid, NSLABEL_UUID_LEN) != 0) + continue; + res = to_resource(ndd, nd_label); + res->flags &= ~DPA_RESOURCE_ADJUSTED; + dev_vdbg(&nsblk->dev, "assign label[%d] slot: %d\n", l, slot); + nd_set_label(nd_mapping->labels, nd_label, l++); + } + nd_set_label(nd_mapping->labels, NULL, l); + + out: + kfree(old_res_list); + kfree(victim_map); + return rc; + + abort: + /* + * 1/ repair the allocated label bitmap in the index + * 2/ restore the resource list + */ + nd_label_copy(ndd, nsindex, to_current_namespace_index(ndd)); + kfree(nsblk->res); + nsblk->res = old_res_list; + nsblk->num_resources = old_num_resources; + old_res_list = NULL; + goto out; +} + +static int init_labels(struct nd_mapping *nd_mapping, int num_labels) +{ + int i, l, old_num_labels = 0; struct nd_namespace_index __iomem *nsindex; + struct nd_namespace_label __iomem *nd_label; struct nd_dimm_drvdata *ndd = to_ndd(nd_mapping); + size_t size = (num_labels + 1) * sizeof(struct nd_namespace_label *); - if (!nd_mapping->labels) - nd_mapping->labels = kcalloc(2, sizeof(void *), GFP_KERNEL); + for_each_label(l, nd_label, nd_mapping->labels) + old_num_labels++; + + /* + * We need to preserve all the old labels for the mapping so + * they can be garbage collected after writing the new labels. + */ + if (num_labels > old_num_labels) { + struct nd_namespace_label **labels; + labels = krealloc(nd_mapping->labels, size, GFP_KERNEL); + if (!labels) + return -ENOMEM; + nd_mapping->labels = labels; + } if (!nd_mapping->labels) return -ENOMEM; + for (i = old_num_labels; i <= num_labels; i++) + nd_set_label(nd_mapping->labels, NULL, i); + if (ndd->ns_current == -1 || ndd->ns_next == -1) /* pass */; else - return 0; + return max(num_labels, old_num_labels); nsindex = to_namespace_index(ndd, 0); memset_io(nsindex, 0, ndd->nsarea.config_size); @@ -581,7 +829,7 @@ static int init_labels(struct nd_mapping *nd_mapping) ndd->ns_next = 1; ndd->ns_current = 0; - return 0; + return max(num_labels, old_num_labels); } static int del_labels(struct nd_mapping *nd_mapping, u8 *uuid) @@ -603,22 +851,15 @@ static int del_labels(struct nd_mapping *nd_mapping, u8 *uuid) return 0; for_each_label(l, nd_label, nd_mapping->labels) { - int j; - memcpy_fromio(label_uuid, nd_label->uuid, NSLABEL_UUID_LEN); if (memcmp(label_uuid, uuid, NSLABEL_UUID_LEN) != 0) continue; slot = to_slot(ndd, nd_label); nd_label_free_slot(ndd, slot); dev_dbg(ndd->dev, "%s: free: %d\n", __func__, slot); - for (j = l; nd_get_label(nd_mapping->labels, j + 1); j++) { - struct nd_namespace_label __iomem *next_label; - - next_label = nd_get_label(nd_mapping->labels, j + 1); - nd_set_label(nd_mapping->labels, next_label, j); - } - nd_set_label(nd_mapping->labels, NULL, j); + del_label(nd_mapping, l); num_freed++; + l--; /* retry with new label at this index */ } if (num_freed > l) { @@ -651,8 +892,8 @@ int nd_pmem_namespace_label_update(struct nd_region *nd_region, continue; } - rc = init_labels(nd_mapping); - if (rc) + rc = init_labels(nd_mapping, 1); + if (rc < 0) return rc; rc = __pmem_label_update(nd_region, nd_mapping, nspm, i); @@ -662,3 +903,23 @@ int nd_pmem_namespace_label_update(struct nd_region *nd_region, return 0; } + +int nd_blk_namespace_label_update(struct nd_region *nd_region, + struct nd_namespace_blk *nsblk, resource_size_t size) +{ + struct nd_mapping *nd_mapping = &nd_region->mapping[0]; + struct resource *res; + int count = 0; + + if (size == 0) + return del_labels(nd_mapping, nsblk->uuid); + + for_each_dpa_resource(to_ndd(nd_mapping), res) + count++; + + count = init_labels(nd_mapping, count); + if (count < 0) + return count; + + return __blk_label_update(nd_region, nd_mapping, nsblk, count); +} diff --git a/drivers/block/nd/label.h b/drivers/block/nd/label.h index e17958941e34..a26cebc9f389 100644 --- a/drivers/block/nd/label.h +++ b/drivers/block/nd/label.h @@ -130,9 +130,14 @@ size_t sizeof_namespace_index(struct nd_dimm_drvdata *ndd); int nd_label_active_count(struct nd_dimm_drvdata *ndd); struct nd_namespace_label __iomem *nd_label_active( struct nd_dimm_drvdata *ndd, int n); +u32 nd_label_alloc_slot(struct nd_dimm_drvdata *ndd); +bool nd_label_free_slot(struct nd_dimm_drvdata *ndd, u32 slot); u32 nd_label_nfree(struct nd_dimm_drvdata *ndd); struct nd_region; struct nd_namespace_pmem; +struct nd_namespace_blk; int nd_pmem_namespace_label_update(struct nd_region *nd_region, struct nd_namespace_pmem *nspm, resource_size_t size); +int nd_blk_namespace_label_update(struct nd_region *nd_region, + struct nd_namespace_blk *nsblk, resource_size_t size); #endif /* __LABEL_H__ */ diff --git a/drivers/block/nd/namespace_devs.c b/drivers/block/nd/namespace_devs.c index d63a71a5e711..8414ca21917d 100644 --- a/drivers/block/nd/namespace_devs.c +++ b/drivers/block/nd/namespace_devs.c @@ -164,8 +164,7 @@ static int nd_namespace_label_update(struct nd_region *nd_region, struct device */ if (is_namespace_pmem(dev)) { struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev); - struct resource *res = &nspm->nsio.res; - resource_size_t size = resource_size(res); + resource_size_t size = resource_size(&nspm->nsio.res); if (size == 0 && nspm->uuid) /* delete allocation */; @@ -174,8 +173,15 @@ static int nd_namespace_label_update(struct nd_region *nd_region, struct device return nd_pmem_namespace_label_update(nd_region, nspm, size); } else if (is_namespace_blk(dev)) { - /* TODO: implement blk labels */ - return 0; + struct nd_namespace_blk *nsblk = to_nd_namespace_blk(dev); + resource_size_t size = nd_namespace_blk_size(nsblk); + + if (size == 0 && nsblk->uuid) + /* delete allocation */; + else if (!nsblk->uuid || !nsblk->lbasize) + return 0; + + return nd_blk_namespace_label_update(nd_region, nsblk, size); } else return -ENXIO; } @@ -983,6 +989,48 @@ static ssize_t sector_size_store(struct device *dev, } static DEVICE_ATTR_RW(sector_size); +static ssize_t dpa_extents_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct nd_region *nd_region = to_nd_region(dev->parent); + struct nd_label_id label_id; + int count = 0, i; + u8 *uuid = NULL; + u32 flags = 0; + + nd_bus_lock(dev); + if (is_namespace_pmem(dev)) { + struct nd_namespace_pmem *nspm = to_nd_namespace_pmem(dev); + + uuid = nspm->uuid; + flags = 0; + } else if (is_namespace_blk(dev)) { + struct nd_namespace_blk *nsblk = to_nd_namespace_blk(dev); + + uuid = nsblk->uuid; + flags = NSLABEL_FLAG_LOCAL; + } + + if (!uuid) + goto out; + + nd_label_gen_id(&label_id, uuid, flags); + for (i = 0; i < nd_region->ndr_mappings; i++) { + struct nd_mapping *nd_mapping = &nd_region->mapping[i]; + struct nd_dimm_drvdata *ndd = to_ndd(nd_mapping); + struct resource *res; + + for_each_dpa_resource(ndd, res) + if (strcmp(res->name, label_id.id) == 0) + count++; + } + out: + nd_bus_unlock(dev); + + return sprintf(buf, "%d\n", count); +} +static DEVICE_ATTR_RO(dpa_extents); + static struct attribute *nd_namespace_attributes[] = { &dev_attr_type.attr, &dev_attr_size.attr, @@ -990,6 +1038,7 @@ static struct attribute *nd_namespace_attributes[] = { &dev_attr_resource.attr, &dev_attr_alt_name.attr, &dev_attr_sector_size.attr, + &dev_attr_dpa_extents.attr, NULL, }; diff --git a/drivers/block/nd/nd-private.h b/drivers/block/nd/nd-private.h index 1a14ebb40a1a..f88140dceea7 100644 --- a/drivers/block/nd/nd-private.h +++ b/drivers/block/nd/nd-private.h @@ -147,4 +147,5 @@ struct nd_mapping; struct resource *nsblk_add_resource(struct nd_region *nd_region, struct nd_dimm_drvdata *ndd, struct nd_namespace_blk *nsblk, resource_size_t start); +int nd_dimm_num_label_slots(struct nd_dimm_drvdata *ndd); #endif /* __ND_PRIVATE_H__ */

From: Vishal Verma <vishal.l.verma(a)linux.intel.com&gt; BTT stands for Block Translation Table, and is a way to provide power fail sector atomicity semantics for block devices that have the ability to perform byte granularity IO. It relies on the ->rw_bytes() capability of provided nd namespace devices. The BTT works as a stacked blocked device, and reserves a chunk of space from the backing device for its accounting metadata. BLK namespaces may mandate use of a BTT and expect the bus to initialize a BTT if not already present. Otherwise if a BTT is desired for other namespaces (or partitions of a namespace) a BTT may be manually configured. Cc: Andy Lutomirski <luto(a)amacapital.net&gt; Cc: Boaz Harrosh <boaz(a)plexistor.com&gt; Cc: H. Peter Anvin <hpa(a)zytor.com&gt; Cc: Jens Axboe <axboe(a)fb.com&gt; Cc: Ingo Molnar <mingo(a)kernel.org&gt; Cc: Christoph Hellwig <hch(a)lst.de&gt; Cc: Neil Brown <neilb(a)suse.de&gt; Cc: Jeff Moyer <jmoyer(a)redhat.com&gt; Cc: Dave Chinner <david(a)fromorbit.com&gt; Cc: Greg KH <gregkh(a)linuxfoundation.org&gt; [jmoyer: fix nmi watchdog timeout in btt_map_init] [jmoyer: move btt initialization to module load path] [jmoyer: fix memory leak in the btt initialization path] [jmoyer: Don't overwrite corrupted arenas] Signed-off-by: Vishal Verma <vishal.l.verma(a)linux.intel.com&gt; Signed-off-by: Dan Williams <dan.j.williams(a)intel.com&gt; --- Documentation/blockdev/btt.txt | 273 ++++++++ drivers/block/nd/Kconfig | 18 - drivers/block/nd/Makefile | 2 drivers/block/nd/btt.c | 1423 ++++++++++++++++++++++++++++++++++++++++ drivers/block/nd/btt.h | 140 ++++ drivers/block/nd/btt_devs.c | 3 drivers/block/nd/core.c | 1 drivers/block/nd/nd.h | 9 drivers/block/nd/region_devs.c | 77 ++ 9 files changed, 1944 insertions(+), 2 deletions(-) create mode 100644 Documentation/blockdev/btt.txt create mode 100644 drivers/block/nd/btt.c diff --git a/Documentation/blockdev/btt.txt b/Documentation/blockdev/btt.txt new file mode 100644 index 000000000000..95134d5ec4a0 --- /dev/null +++ b/Documentation/blockdev/btt.txt @@ -0,0 +1,273 @@ +BTT - Block Translation Table +============================= + + +1. Introduction +--------------- + +Persistent memory based storage is able to perform IO at byte (or more +accurately, cache line) granularity. However, we often want to expose such +storage as traditional block devices. The block drivers for persistent memory +will do exactly this. However, they do not provide any atomicity guarantees. +Traditional SSDs typically provide protection against torn sectors in hardware, +using stored energy in capacitors to complete in-flight block writes, or perhaps +in firmware. We don't have this luxury with persistent memory - if a write is in +progress, and we experience a power failure, the block will contain a mix of old +and new data. Applications may not be prepared to handle such a scenario. + +The Block Translation Table (BTT) provides atomic sector update semantics for +persistent memory devices, so that applications that rely on sector writes not +being torn can continue to do so. The BTT manifests itself as a stacked block +device, and reserves a portion of the underlying storage for its metadata. At +the heart of it, is an indirection table that re-maps all the blocks on the +volume. It can be thought of as an extremely simple file system that only +provides atomic sector updates. + + +2. Static Layout +---------------- + +The underlying storage on which a BTT can be laid out is not limited in any way. +The BTT, however, splits the available space into chunks of up to 512 GiB, +called "Arenas". + +Each arena follows the same layout for its metadata, and all references in an +arena are internal to it (with the exception of one field that points to the +next arena). The following depicts the "On-disk" metadata layout: + + + Backing Store +-------> Arena ++---------------+ | +------------------+ +| | | | Arena info block | +| Arena 0 +---+ | 4K | +| 512G | +------------------+ +| | | | ++---------------+ | | +| | | | +| Arena 1 | | Data Blocks | +| 512G | | | +| | | | ++---------------+ | | +| . | | | +| . | | | +| . | | | +| | | | +| | | | ++---------------+ +------------------+ + | | + | BTT Map | + | | + | | + +------------------+ + | | + | BTT Flog | + | | + +------------------+ + | Info block copy | + | 4K | + +------------------+ + + +3. Theory of Operation +---------------------- + + +a. The BTT Map +-------------- + +The map is a simple lookup/indirection table that maps an LBA to an internal +block. Each map entry is 32 bits. The two most significant bits are special +flags, and the remaining form the internal block number. + +Bit Description +31 : TRIM flag - marks if the block was trimmed or discarded +30 : ERROR flag - marks an error block. Cleared on write. +29 - 0 : Mappings to internal 'postmap' blocks + + +Some of the terminology that will be subsequently used: + +External LBA : LBA as made visible to upper layers. +ABA : Arena Block Address - Block offset/number within an arena +Premap ABA : The block offset into an arena, which was decided upon by range + checking the External LBA +Postmap ABA : The block number in the "Data Blocks" area obtained after + indirection from the map +nfree : The number of free blocks that are maintained at any given time. + This is the number of concurrent writes that can happen to the + arena. + + +For example, after adding a BTT, we surface a disk of 1024G. We get a read for +the external LBA at 768G. This falls into the second arena, and of the 512G +worth of blocks that this arena contributes, this block is at 256G. Thus, the +premap ABA is 256G. We now refer to the map, and find out the mapping for block +'X' (256G) points to block 'Y', say '64'. Thus the postmap ABA is 64. + + +b. The BTT Flog +--------------- + +The BTT provides sector atomicity by making every write an "allocating write", +i.e. Every write goes to a "free" block. A running list of free blocks is +maintained in the form of the BTT flog. 'Flog' is a combination of the words +"free list" and "log". The flog contains 'nfree' entries, and an entry contains: + +lba : The premap ABA that is being written to +old_map : The old postmap ABA - after 'this' write completes, this will be a + free block. +new_map : The new postmap ABA. The map will up updated to reflect this + lba->postmap_aba mapping, but we log it here in case we have to + recover. +seq : Sequence number to mark which of the 2 sections of this flog entry is + valid/newest. It cycles between 01->10->11->01 (binary) under normal + operation, with 00 indicating an uninitialized state. +lba' : alternate lba entry +old_map': alternate old postmap entry +new_map': alternate new postmap entry +seq' : alternate sequence number. + +Each of the above fields is 32-bit, making one entry 16 bytes. Flog updates are +done such that for any entry being written, it: +a. overwrites the 'old' section in the entry based on sequence numbers +b. writes the new entry such that the sequence number is written last. + + +c. The concept of lanes +----------------------- + +While 'nfree' describes the number of concurrent IOs an arena can process +concurrently, 'nlanes' is the number of IOs the BTT device as a whole can +process. + nlanes = min(nfree, num_cpus) +A lane number is obtained at the start of any IO, and is used for indexing into +all the on-disk and in-memory data structures for the duration of the IO. It is +protected by a spinlock. + + +d. In-memory data structure: Read Tracking Table (RTT) +------------------------------------------------------ + +Consider a case where we have two threads, one doing reads and the other, +writes. We can hit a condition where the writer thread grabs a free block to do +a new IO, but the (slow) reader thread is still reading from it. In other words, +the reader consulted a map entry, and started reading the corresponding block. A +writer started writing to the same external LBA, and finished the write updating +the map for that external LBA to point to its new postmap ABA. At this point the +internal, postmap block that the reader is (still) reading has been inserted +into the list of free blocks. If another write comes in for the same LBA, it can +grab this free block, and start writing to it, causing the reader to read +incorrect data. To prevent this, we introduce the RTT. + +The RTT is a simple, per arena table with 'nfree' entries. Every reader inserts +into rtt[lane_number], the postmap ABA it is reading, and clears it after the +read is complete. Every writer thread, after grabbing a free block, checks the +RTT for its presence. If the postmap free block is in the RTT, it waits till the +reader clears the RTT entry, and only then starts writing to it. + + +e. In-memory data structure: map locks +-------------------------------------- + +Consider a case where two writer threads are writing to the same LBA. There can +be a race in the following sequence of steps: + +free[lane] = map[premap_aba] +map[premap_aba] = postmap_aba + +Both threads can update their respective free[lane] with the same old, freed +postmap_aba. This has made the layout inconsistent by losing a free entry, and +at the same time, duplicating another free entry for two lanes. + +To solve this, we could have a single map lock (per arena) that has to be taken +before performing the above sequence, but we feel that could be too contentious. +Instead we use an array of (nfree) map_locks that is indexed by +(premap_aba modulo nfree). + + +f. Reconstruction from the Flog +------------------------------- + +On startup, we analyze the BTT flog to create our list of free blocks. We walk +through all the entries, and for each lane, of the set of two possible +'sections', we always look at the most recent one only (based on the sequence +number). The reconstruction rules/steps are simple: +- Read map[log_entry.lba]. +- If log_entry.new matches the map entry, then log_entry.old is free. +- If log_entry.new does not match the map entry, then log_entry.new is free. + (This case can only be caused by power-fails/unsafe shutdowns) + + +g. Summarizing - Read and Write flows +------------------------------------- + +Read: + +1. Convert external LBA to arena number + pre-map ABA +2. Get a lane (and take lane_lock) +3. Read map to get the entry for this pre-map ABA +4. Enter post-map ABA into RTT[lane] +5. If TRIM flag set in map, return zeroes, and end IO (go to step 8) +6. If ERROR flag set in map, end IO with EIO (go to step 8) +7. Read data from this block +8. Remove post-map ABA entry from RTT[lane] +9. Release lane (and lane_lock) + +Write: + +1. Convert external LBA to Arena number + pre-map ABA +2. Get a lane (and take lane_lock) +3. Use lane to index into in-memory free list and obtain a new block, next flog + index, next sequence number +4. Scan the RTT to check if free block is present, and spin/wait if it is. +5. Write data to this free block +6. Read map to get the existing post-map ABA entry for this pre-map ABA +7. Write flog entry: [premap_aba / old postmap_aba / new postmap_aba / seq_num] +8. Write new post-map ABA into map. +9. Write old post-map entry into the free list +10. Calculate next sequence number and write into the free list entry +11. Release lane (and lane_lock) + + +4. Error Handling +================= + +An arena would be in an error state if any of the metadata is corrupted +irrecoverably, either due to a bug or a media error. The following conditions +indicate an error: +- Info block checksum does not match (and recovering from the copy also fails) +- All internal available blocks are not uniquely and entirely addressed by the + sum of mapped blocks and free blocks (from the BTT flog). +- Rebuilding free list from the flog reveals missing/duplicate/impossible + entries +- A map entry is out of bounds + +If any of these error conditions are encountered, the arena is put into a read +only state using a flag in the info block. + + +5. In-kernel usage +================== + +Any block driver that supports byte granularity IO to the storage may register +with the BTT. It will have to provide the rw_bytes interface in its +block_device_operations struct: + + int (*rw_bytes)(struct gendisk *, void *, size_t, off_t, int rw); + +It may register with the BTT after it adds its own gendisk, using btt_init: + + struct btt *btt_init(struct gendisk *disk, unsigned long long rawsize, + u32 lbasize, u8 uuid[], int maxlane); + +note that maxlane is the maximum amount of concurrency the driver wishes to +allow the BTT to use. + +The BTT 'disk' appears as a stacked block device that grabs the underlying block +device in the O_EXCL mode. + +When the driver wishes to remove the backing disk, it should similarly call +btt_fini using the same struct btt* handle that was provided to it by btt_init. + + void btt_fini(struct btt *btt); + diff --git a/drivers/block/nd/Kconfig b/drivers/block/nd/Kconfig index faa756841773..29d9f8e4eedb 100644 --- a/drivers/block/nd/Kconfig +++ b/drivers/block/nd/Kconfig @@ -90,6 +90,22 @@ config BLK_DEV_PMEM Say Y if you want to use a NVDIMM described by NFIT config ND_BTT_DEVS - def_bool y + bool + +config ND_BTT + tristate "BTT: Block Translation Table (atomic sector updates)" + depends on ND_CORE + default ND_CORE + select ND_BTT_DEVS + +config ND_MAX_REGIONS + int "Maximum number of regions supported by the sub-system" + default 64 + ---help--- + A 'region' corresponds to an individual DIMM or an interleave + set of DIMMs. A typical maximally configured system may have + up to 32 DIMMs. + + Leave the default of 64 if you are unsure. endif diff --git a/drivers/block/nd/Makefile b/drivers/block/nd/Makefile index 3e4878e0fe1d..2dc1ab6fdef2 100644 --- a/drivers/block/nd/Makefile +++ b/drivers/block/nd/Makefile @@ -17,6 +17,7 @@ endif obj-$(CONFIG_ND_CORE) += nd.o obj-$(CONFIG_NFIT_ACPI) += nd_acpi.o obj-$(CONFIG_BLK_DEV_PMEM) += nd_pmem.o +obj-$(CONFIG_ND_BTT) += nd_btt.o nd_acpi-y := acpi.o @@ -32,3 +33,4 @@ nd-y += label.o nd-$(CONFIG_ND_BTT_DEVS) += btt_devs.o nd_pmem-y := pmem.o +nd_btt-y := btt.o diff --git a/drivers/block/nd/btt.c b/drivers/block/nd/btt.c new file mode 100644 index 000000000000..1075012d13c0 --- /dev/null +++ b/drivers/block/nd/btt.c @@ -0,0 +1,1423 @@ +/* + * Block Translation Table + * Copyright (c) 2014-2015, Intel Corporation. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + */ +#include <linux/highmem.h> +#include <linux/debugfs.h> +#include <linux/blkdev.h> +#include <linux/module.h> +#include <linux/device.h> +#include <linux/mutex.h> +#include <linux/hdreg.h> +#include <linux/genhd.h> +#include <linux/sizes.h> +#include <linux/ndctl.h> +#include <linux/fs.h> +#include <linux/nd.h> +#include "btt.h" +#include "nd.h" + +enum log_ent_request { + LOG_NEW_ENT = 0, + LOG_OLD_ENT +}; + +static int btt_major; + +static int nd_btt_rw_bytes(struct nd_btt *nd_btt, void *buf, size_t offset, + size_t n, unsigned long flags) +{ + struct nd_io *ndio = nd_btt->ndio; + + if (unlikely(nd_data_dir(flags) == WRITE) + && bdev_read_only(nd_btt->backing_dev)) + return -EACCES; + + return ndio->rw_bytes(ndio, buf, offset + nd_btt->offset, n, flags); +} + +static int arena_rw_bytes(struct arena_info *arena, void *buf, size_t n, + size_t offset, unsigned long flags) +{ + /* yes, FIXME, 'offset' and 'n' are swapped */ + return nd_btt_rw_bytes(arena->nd_btt, buf, offset, n, flags); +} + +static int btt_info_write(struct arena_info *arena, struct btt_sb *super) +{ + int ret; + + ret = arena_rw_bytes(arena, super, sizeof(struct btt_sb), + arena->info2off, WRITE); + if (ret) + return ret; + + return arena_rw_bytes(arena, super, sizeof(struct btt_sb), + arena->infooff, WRITE); +} + +static int btt_info_read(struct arena_info *arena, struct btt_sb *super) +{ + WARN_ON(!super); + return arena_rw_bytes(arena, super, sizeof(struct btt_sb), + arena->infooff, READ); + +} + +/* + * 'raw' version of btt_map write + * Assumptions: + * mapping is in little-endian + * mapping contains 'E' and 'Z' flags as desired + */ +static int __btt_map_write(struct arena_info *arena, u32 lba, __le32 mapping) +{ + u64 ns_off = arena->mapoff + (lba * MAP_ENT_SIZE); + + WARN_ON(lba >= arena->external_nlba); + return arena_rw_bytes(arena, &mapping, MAP_ENT_SIZE, ns_off, WRITE); +} + +static int btt_map_write(struct arena_info *arena, u32 lba, u32 mapping, + u32 z_flag, u32 e_flag) +{ + u32 ze; + __le32 mapping_le; + + /* + * This 'mapping' is supposed to be just the LBA mapping, without + * any flags set, so strip the flag bits. + */ + mapping &= MAP_LBA_MASK; + + ze = (z_flag << 1) + e_flag; + switch (ze) { + case 0: + /* + * We want to set neither of the Z or E flags, and + * in the actual layout, this means setting the bit + * positions of both to '1' to indicate a 'normal' + * map entry + */ + mapping |= MAP_ENT_NORMAL; + break; + case 1: + mapping |= (1 << MAP_ERR_SHIFT); + break; + case 2: + mapping |= (1 << MAP_TRIM_SHIFT); + break; + default: + /* + * The case where Z and E are both sent in as '1' could be + * construed as a valid 'normal' case, but we decide not to, + * to avoid confusion + */ + WARN_ONCE(1, "Invalid use of Z and E flags\n"); + return -EIO; + } + + mapping_le = cpu_to_le32(mapping); + return __btt_map_write(arena, lba, mapping_le); +} + +static int btt_map_read(struct arena_info *arena, u32 lba, u32 *mapping, + int *trim, int *error) +{ + int ret; + __le32 in; + u32 raw_mapping, postmap, ze, z_flag, e_flag; + u64 ns_off = arena->mapoff + (lba * MAP_ENT_SIZE); + + WARN_ON(lba >= arena->external_nlba); + + ret = arena_rw_bytes(arena, &in, MAP_ENT_SIZE, ns_off, READ); + if (ret) + return ret; + + raw_mapping = le32_to_cpu(in); + + z_flag = (raw_mapping & MAP_TRIM_MASK) >> MAP_TRIM_SHIFT; + e_flag = (raw_mapping & MAP_ERR_MASK) >> MAP_ERR_SHIFT; + ze = (z_flag << 1) + e_flag; + postmap = raw_mapping & MAP_LBA_MASK; + + /* Reuse the {z,e}_flag variables for *trim and *error */ + z_flag = 0; + e_flag = 0; + + switch (ze) { + case 0: + /* Initial state. Return postmap = premap */ + *mapping = lba; + break; + case 1: + *mapping = postmap; + e_flag = 1; + break; + case 2: + *mapping = postmap; + z_flag = 1; + break; + case 3: + *mapping = postmap; + break; + default: + return -EIO; + } + + if (trim) + *trim = z_flag; + if (error) + *error = e_flag; + + return ret; +} + +static int btt_log_read_pair(struct arena_info *arena, u32 lane, + struct log_entry *ent) +{ + WARN_ON(!ent); + return arena_rw_bytes(arena, ent, 2 * LOG_ENT_SIZE, + arena->logoff + (2 * lane * LOG_ENT_SIZE), READ); +} + +static struct dentry *debugfs_root; + +static void arena_debugfs_init(struct arena_info *a, struct dentry *parent, + int idx) +{ + char dirname[32]; + struct dentry *d; + + /* If for some reason, parent bttN was not created, exit */ + if (!parent) + return; + + snprintf(dirname, 32, "arena%d", idx); + d = debugfs_create_dir(dirname, parent); + if (IS_ERR_OR_NULL(d)) + return; + a->debugfs_dir = d; + + debugfs_create_x64("size", S_IRUGO, d, &a->size); + debugfs_create_x64("external_lba_start", S_IRUGO, d, + &a->external_lba_start); + debugfs_create_x32("internal_nlba", S_IRUGO, d, &a->internal_nlba); + debugfs_create_u32("internal_lbasize", S_IRUGO, d, + &a->internal_lbasize); + debugfs_create_x32("external_nlba", S_IRUGO, d, &a->external_nlba); + debugfs_create_u32("external_lbasize", S_IRUGO, d, + &a->external_lbasize); + debugfs_create_u32("nfree", S_IRUGO, d, &a->nfree); + debugfs_create_u16("version_major", S_IRUGO, d, &a->version_major); + debugfs_create_u16("version_minor", S_IRUGO, d, &a->version_minor); + debugfs_create_x64("nextoff", S_IRUGO, d, &a->nextoff); + debugfs_create_x64("infooff", S_IRUGO, d, &a->infooff); + debugfs_create_x64("dataoff", S_IRUGO, d, &a->dataoff); + debugfs_create_x64("mapoff", S_IRUGO, d, &a->mapoff); + debugfs_create_x64("logoff", S_IRUGO, d, &a->logoff); + debugfs_create_x64("info2off", S_IRUGO, d, &a->info2off); + debugfs_create_x32("flags", S_IRUGO, d, &a->flags); +} + +static void btt_debugfs_init(struct btt *btt) +{ + int i = 0; + struct arena_info *arena; + + btt->debugfs_dir = debugfs_create_dir(dev_name(&btt->nd_btt->dev), + debugfs_root); + if (IS_ERR_OR_NULL(btt->debugfs_dir)) + return; + + list_for_each_entry(arena, &btt->arena_list, list) { + arena_debugfs_init(arena, btt->debugfs_dir, i); + i++; + } +} + +/* + * This function accepts two log entries, and uses the + * sequence number to find the 'older' entry. + * It also updates the sequence number in this old entry to + * make it the 'new' one if the mark_flag is set. + * Finally, it returns which of the entries was the older one. + * + * TODO The logic feels a bit kludge-y. make it better.. + */ +static int btt_log_get_old(struct log_entry *ent) +{ + int old; + + /* + * the first ever time this is seen, the entry goes into [0] + * the next time, the following logic works out to put this + * (next) entry into [1] + */ + if (ent[0].seq == 0) { + ent[0].seq = cpu_to_le32(1); + return 0; + } + + if (ent[0].seq == ent[1].seq) + return -EINVAL; + if (le32_to_cpu(ent[0].seq) + le32_to_cpu(ent[1].seq) > 5) + return -EINVAL; + + if (le32_to_cpu(ent[0].seq) < le32_to_cpu(ent[1].seq)) { + if (le32_to_cpu(ent[1].seq) - le32_to_cpu(ent[0].seq) == 1) + old = 0; + else + old = 1; + } else { + if (le32_to_cpu(ent[0].seq) - le32_to_cpu(ent[1].seq) == 1) + old = 1; + else + old = 0; + } + + return old; +} + +static struct device *to_dev(struct arena_info *arena) +{ + return &arena->nd_btt->dev; +} + +/* + * This function copies the desired (old/new) log entry into ent if + * it is not NULL. It returns the sub-slot number (0 or 1) + * where the desired log entry was found. Negative return values + * indicate errors. + */ +static int btt_log_read(struct arena_info *arena, u32 lane, + struct log_entry *ent, int old_flag) +{ + int ret; + int old_ent, ret_ent; + struct log_entry log[2]; + + ret = btt_log_read_pair(arena, lane, log); + if (ret) + return -EIO; + + old_ent = btt_log_get_old(log); + if (old_ent < 0 || old_ent > 1) { + dev_info(to_dev(arena), + "log corruption (%d): lane %d seq [%d, %d]\n", + old_ent, lane, log[0].seq, log[1].seq); + /* TODO set error state? */ + return -EIO; + } + + ret_ent = (old_flag ? old_ent : (1 - old_ent)); + + if (ent != NULL) + memcpy(ent, &log[ret_ent], LOG_ENT_SIZE); + + return ret_ent; +} + +/* + * This function commits a log entry to media + * It does _not_ prepare the freelist entry for the next write + * btt_flog_write is the wrapper for updating the freelist elements + */ +static int __btt_log_write(struct arena_info *arena, u32 lane, + u32 sub, struct log_entry *ent) +{ + int ret; + /* + * Ignore the padding in log_entry for calculating log_half. + * The entry is 'committed' when we write the sequence number, + * and we want to ensure that that is the last thing written. + * We don't bother writing the padding as that would be extra + * media wear and write amplification + */ + unsigned int log_half = (LOG_ENT_SIZE - 2 * sizeof(u64)) / 2; + u64 ns_off = arena->logoff + (((2 * lane) + sub) * LOG_ENT_SIZE); + void *src = ent; + + /* split the 16B write into atomic, durable halves */ + ret = arena_rw_bytes(arena, src, log_half, ns_off, WRITE); + if (ret) + return ret; + + ns_off += log_half; + src += log_half; + return arena_rw_bytes(arena, src, log_half, ns_off, WRITE); +} + +static int btt_flog_write(struct arena_info *arena, u32 lane, u32 sub, + struct log_entry *ent) +{ + int ret; + + ret = __btt_log_write(arena, lane, sub, ent); + if (ret) + return ret; + + /* prepare the next free entry */ + arena->freelist[lane].sub = 1 - arena->freelist[lane].sub; + if (++(arena->freelist[lane].seq) == 4) + arena->freelist[lane].seq = 1; + arena->freelist[lane].block = le32_to_cpu(ent->old_map); + + return ret; +} + +/* + * This function initializes the BTT map to a state with all externally + * exposed blocks having an identity mapping, and the TRIM flag set + */ +static int btt_map_init(struct arena_info *arena) +{ + int ret = -EINVAL; + void *zerobuf; + size_t offset = 0; + size_t chunk_size = SZ_2M; + size_t mapsize = arena->logoff - arena->mapoff; + + zerobuf = kzalloc(chunk_size, GFP_KERNEL); + if (!zerobuf) + return -ENOMEM; + + while (mapsize) { + size_t size = min(mapsize, chunk_size); + + ret = arena_rw_bytes(arena, zerobuf, size, + arena->mapoff + offset, WRITE); + if (ret) + goto free; + + offset += size; + mapsize -= size; + cond_resched(); + } + + free: + kfree(zerobuf); + return ret; +} + +/* + * This function initializes the BTT log with 'fake' entries pointing + * to the initial reserved set of blocks as being free + */ +static int btt_log_init(struct arena_info *arena) +{ + int ret; + u32 i; + struct log_entry log, zerolog; + + memset(&zerolog, 0, sizeof(zerolog)); + + for (i = 0; i < arena->nfree; i++) { + log.lba = cpu_to_le32(i); + log.old_map = cpu_to_le32(arena->external_nlba + i); + log.new_map = cpu_to_le32(arena->external_nlba + i); + log.seq = cpu_to_le32(LOG_SEQ_INIT); + ret = __btt_log_write(arena, i, 0, &log); + if (ret) + return ret; + ret = __btt_log_write(arena, i, 1, &zerolog); + if (ret) + return ret; + } + + return 0; +} + +static int btt_freelist_init(struct arena_info *arena) +{ + int old, new, ret; + u32 i, map_entry; + struct log_entry log_new, log_old; + + arena->freelist = kcalloc(arena->nfree, sizeof(struct free_entry), + GFP_KERNEL); + if (!arena->freelist) + return -ENOMEM; + + for (i = 0; i < arena->nfree; i++) { + old = btt_log_read(arena, i, &log_old, LOG_OLD_ENT); + if (old < 0) + return old; + + new = btt_log_read(arena, i, &log_new, LOG_NEW_ENT); + if (new < 0) + return new; + + /* sub points to the next one to be overwritten */ + arena->freelist[i].sub = 1 - new; + arena->freelist[i].seq = nd_inc_seq(le32_to_cpu(log_new.seq)); + arena->freelist[i].block = le32_to_cpu(log_new.old_map); + + /* This implies a newly created or untouched flog entry */ + if (log_new.old_map == log_new.new_map) + continue; + + /* Check if map recovery is needed */ + ret = btt_map_read(arena, le32_to_cpu(log_new.lba), &map_entry, + NULL, NULL); + if (ret) + return ret; + if ((le32_to_cpu(log_new.new_map) != map_entry) && + (le32_to_cpu(log_new.old_map) == map_entry)) { + /* + * Last transaction wrote the flog, but wasn't able + * to complete the map write. So fix up the map. + */ + ret = btt_map_write(arena, le32_to_cpu(log_new.lba), + le32_to_cpu(log_new.new_map), 0, 0); + if (ret) + return ret; + } + + } + + return 0; +} + +static int btt_rtt_init(struct arena_info *arena) +{ + arena->rtt = kcalloc(arena->nfree, sizeof(u32), GFP_KERNEL); + if (arena->rtt == NULL) + return -ENOMEM; + + return 0; +} + +static int btt_maplocks_init(struct arena_info *arena) +{ + u32 i; + + arena->map_locks = kcalloc(arena->nfree, sizeof(struct aligned_lock), + GFP_KERNEL); + if (!arena->map_locks) + return -ENOMEM; + + for (i = 0; i < arena->nfree; i++) + spin_lock_init(&arena->map_locks[i].lock); + + return 0; +} + +static struct arena_info *alloc_arena(struct btt *btt, size_t size, + size_t start, size_t arena_off) +{ + struct arena_info *arena; + u64 logsize, mapsize, datasize; + u64 available = size; + + arena = kzalloc(sizeof(struct arena_info), GFP_KERNEL); + if (!arena) + return NULL; + arena->nd_btt = btt->nd_btt; + + if (!size) + return arena; + + arena->size = size; + arena->external_lba_start = start; + arena->external_lbasize = btt->lbasize; + arena->internal_lbasize = roundup(arena->external_lbasize, + INT_LBASIZE_ALIGNMENT); + arena->nfree = BTT_DEFAULT_NFREE; + arena->version_major = 1; + arena->version_minor = 1; + + if (available % BTT_PG_SIZE) + available -= (available % BTT_PG_SIZE); + + /* Two pages are reserved for the super block and its copy */ + available -= 2 * BTT_PG_SIZE; + + /* The log takes a fixed amount of space based on nfree */ + logsize = roundup(2 * arena->nfree * sizeof(struct log_entry), + BTT_PG_SIZE); + available -= logsize; + + /* Calculate optimal split between map and data area */ + arena->internal_nlba = div_u64(available - BTT_PG_SIZE, + arena->internal_lbasize + MAP_ENT_SIZE); + arena->external_nlba = arena->internal_nlba - arena->nfree; + + mapsize = roundup((arena->external_nlba * MAP_ENT_SIZE), BTT_PG_SIZE); + datasize = available - mapsize; + + /* 'Absolute' values, relative to start of storage space */ + arena->infooff = arena_off; + arena->dataoff = arena->infooff + BTT_PG_SIZE; + arena->mapoff = arena->dataoff + datasize; + arena->logoff = arena->mapoff + mapsize; + arena->info2off = arena->logoff + logsize; + return arena; +} + +static void free_arenas(struct btt *btt) +{ + struct arena_info *arena, *next; + + list_for_each_entry_safe(arena, next, &btt->arena_list, list) { + list_del(&arena->list); + kfree(arena->rtt); + kfree(arena->map_locks); + kfree(arena->freelist); + debugfs_remove_recursive(arena->debugfs_dir); + kfree(arena); + } +} + +/* + * This function checks if the metadata layout is valid and error free + */ +static int arena_is_valid(struct arena_info *arena, struct btt_sb *super, + u8 *uuid) +{ + u64 checksum; + + if (memcmp(super->uuid, uuid, 16)) + return 0; + + checksum = le64_to_cpu(super->checksum); + super->checksum = 0; + if (checksum != btt_sb_checksum(super)) + return 0; + super->checksum = cpu_to_le64(checksum); + + /* TODO: figure out action for this */ + if ((le32_to_cpu(super->flags) & IB_FLAG_ERROR_MASK) != 0) + dev_info(to_dev(arena), "Found arena with an error flag\n"); + + return 1; +} + +/* + * This function reads an existing valid btt superblock and + * populates the corresponding arena_info struct + */ +static void parse_arena_meta(struct arena_info *arena, struct btt_sb *super, + u64 arena_off) +{ + arena->internal_nlba = le32_to_cpu(super->internal_nlba); + arena->internal_lbasize = le32_to_cpu(super->internal_lbasize); + arena->external_nlba = le32_to_cpu(super->external_nlba); + arena->external_lbasize = le32_to_cpu(super->external_lbasize); + arena->nfree = le32_to_cpu(super->nfree); + arena->version_major = le16_to_cpu(super->version_major); + arena->version_minor = le16_to_cpu(super->version_minor); + + arena->nextoff = (super->nextoff == 0) ? 0 : (arena_off + + le64_to_cpu(super->nextoff)); + arena->infooff = arena_off; + arena->dataoff = arena_off + le64_to_cpu(super->dataoff); + arena->mapoff = arena_off + le64_to_cpu(super->mapoff); + arena->logoff = arena_off + le64_to_cpu(super->logoff); + arena->info2off = arena_off + le64_to_cpu(super->info2off); + + arena->size = (super->nextoff > 0) ? (le64_to_cpu(super->nextoff)) : + (arena->info2off - arena->infooff + BTT_PG_SIZE); + + arena->flags = le32_to_cpu(super->flags); +} + +static int discover_arenas(struct btt *btt) +{ + int ret = 0; + struct arena_info *arena; + struct btt_sb *super; + size_t remaining = btt->rawsize; + u64 cur_nlba = 0; + size_t cur_off = 0; + int num_arenas = 0; + + super = kzalloc(sizeof(*super), GFP_KERNEL); + if (!super) + return -ENOMEM; + + while (remaining) { + /* Alloc memory for arena */ + arena = alloc_arena(btt, 0, 0, 0); + if (!arena) { + ret = -ENOMEM; + goto out_super; + } + + arena->infooff = cur_off; + ret = btt_info_read(arena, super); + if (ret) + goto out; + + if (!arena_is_valid(arena, super, btt->nd_btt->uuid)) { + if (remaining == btt->rawsize) { + btt->init_state = INIT_NOTFOUND; + dev_info(to_dev(arena), "No existing arenas\n"); + goto out; + } else { + dev_info(to_dev(arena), + "Found corrupted metadata!\n"); + ret = -ENODEV; + goto out; + } + } + + arena->external_lba_start = cur_nlba; + parse_arena_meta(arena, super, cur_off); + + ret = btt_freelist_init(arena); + if (ret) + goto out; + + ret = btt_rtt_init(arena); + if (ret) + goto out; + + ret = btt_maplocks_init(arena); + if (ret) + goto out; + + list_add_tail(&arena->list, &btt->arena_list); + + remaining -= arena->size; + cur_off += arena->size; + cur_nlba += arena->external_nlba; + num_arenas++; + + if (arena->nextoff == 0) + break; + } + btt->num_arenas = num_arenas; + btt->nlba = cur_nlba; + btt->init_state = INIT_READY; + + kfree(super); + return ret; + + out: + kfree(arena); + free_arenas(btt); + out_super: + kfree(super); + return ret; +} + +static int create_arenas(struct btt *btt) +{ + size_t remaining = btt->rawsize; + size_t cur_off = 0; + + while (remaining) { + struct arena_info *arena; + size_t arena_size = min_t(u64, ARENA_MAX_SIZE, remaining); + + remaining -= arena_size; + if (arena_size < ARENA_MIN_SIZE) + break; + + arena = alloc_arena(btt, arena_size, btt->nlba, cur_off); + if (!arena) { + free_arenas(btt); + return -ENOMEM; + } + btt->nlba += arena->external_nlba; + if (remaining >= ARENA_MIN_SIZE) + arena->nextoff = arena->size; + else + arena->nextoff = 0; + cur_off += arena_size; + list_add_tail(&arena->list, &btt->arena_list); + } + + return 0; +} + +/* + * This function completes arena initialization by writing + * all the metadata. + * It is only called for an uninitialized arena when a write + * to that arena occurs for the first time. + */ +static int btt_arena_write_layout(struct arena_info *arena, u8 *uuid) +{ + int ret; + struct btt_sb *super; + + ret = btt_map_init(arena); + if (ret) + return ret; + + ret = btt_log_init(arena); + if (ret) + return ret; + + super = kzalloc(sizeof(struct btt_sb), GFP_NOIO); + if (!super) + return -ENOMEM; + + strncpy(super->signature, BTT_SIG, BTT_SIG_LEN); + memcpy(super->uuid, uuid, 16); + super->flags = cpu_to_le32(arena->flags); + super->version_major = cpu_to_le16(arena->version_major); + super->version_minor = cpu_to_le16(arena->version_minor); + super->external_lbasize = cpu_to_le32(arena->external_lbasize); + super->external_nlba = cpu_to_le32(arena->external_nlba); + super->internal_lbasize = cpu_to_le32(arena->internal_lbasize); + super->internal_nlba = cpu_to_le32(arena->internal_nlba); + super->nfree = cpu_to_le32(arena->nfree); + super->infosize = cpu_to_le32(sizeof(struct btt_sb)); + + /* TODO: make these relative to arena start. For now we get this + * since each file = 1 arena = 1 dimm, but will change */ + super->nextoff = cpu_to_le64(arena->nextoff); + /* + * Subtract arena->infooff (arena start) so numbers are relative + * to 'this' arena + */ + super->dataoff = cpu_to_le64(arena->dataoff - arena->infooff); + super->mapoff = cpu_to_le64(arena->mapoff - arena->infooff); + super->logoff = cpu_to_le64(arena->logoff - arena->infooff); + super->info2off = cpu_to_le64(arena->info2off - arena->infooff); + + super->flags = 0; + super->checksum = cpu_to_le64(btt_sb_checksum(super)); + + ret = btt_info_write(arena, super); + + kfree(super); + return ret; +} + +/* + * This function completes the initialization for the BTT namespace + * such that it is ready to accept IOs + */ +static int btt_meta_init(struct btt *btt) +{ + int ret = 0; + struct arena_info *arena; + + mutex_lock(&btt->init_lock); + list_for_each_entry(arena, &btt->arena_list, list) { + ret = btt_arena_write_layout(arena, btt->nd_btt->uuid); + if (ret) + goto unlock; + + ret = btt_freelist_init(arena); + if (ret) + goto unlock; + + ret = btt_rtt_init(arena); + if (ret) + goto unlock; + + ret = btt_maplocks_init(arena); + if (ret) + goto unlock; + } + + btt->init_state = INIT_READY; + + unlock: + mutex_unlock(&btt->init_lock); + return ret; +} + +/* + * This function calculates the arena in which the given LBA lies + * by doing a linear walk. This is acceptable since we expect only + * a few arenas. If we have backing devices that get much larger, + * we can construct a balanced binary tree of arenas at init time + * so that this range search becomes faster. + */ +static int lba_to_arena(struct btt *btt, sector_t sector, __u32 *premap, + struct arena_info **arena) +{ + struct arena_info *arena_list; + __u64 lba = div_u64(sector << SECTOR_SHIFT, btt->lbasize); + + list_for_each_entry(arena_list, &btt->arena_list, list) { + if (lba < arena_list->external_nlba) { + *arena = arena_list; + *premap = lba; + return 0; + } + lba -= arena_list->external_nlba; + } + + return -EIO; +} + +/* + * The following (lock_map, unlock_map) are mostly just to improve + * readability, since they index into an array of locks + */ +static void lock_map(struct arena_info *arena, u32 premap) +{ + u32 idx = (premap * MAP_ENT_SIZE / L1_CACHE_BYTES) % arena->nfree; + + spin_lock(&arena->map_locks[idx].lock); +} + +static void unlock_map(struct arena_info *arena, u32 premap) +{ + u32 idx = (premap * MAP_ENT_SIZE / L1_CACHE_BYTES) % arena->nfree; + + spin_unlock(&arena->map_locks[idx].lock); +} + +static u64 to_namespace_offset(struct arena_info *arena, u64 lba) +{ + return arena->dataoff + ((u64)lba * arena->internal_lbasize); +} + +static int btt_data_read(struct arena_info *arena, struct page *page, + unsigned int off, u32 lba, u32 len) +{ + int ret; + u64 nsoff = to_namespace_offset(arena, lba); + void *mem = kmap_atomic(page); + + ret = arena_rw_bytes(arena, mem + off, len, nsoff, READ); + kunmap_atomic(mem); + + return ret; +} + +static int btt_data_write(struct arena_info *arena, u32 lba, + struct page *page, unsigned int off, u32 len) +{ + int ret; + u64 nsoff = to_namespace_offset(arena, lba); + void *mem = kmap_atomic(page); + + ret = arena_rw_bytes(arena, mem + off, len, nsoff, WRITE); + kunmap_atomic(mem); + + return ret; +} + +static void zero_fill_data(struct page *page, unsigned int off, u32 len) +{ + void *mem = kmap_atomic(page); + + memset(mem + off, 0, len); + kunmap_atomic(mem); +} + +static int btt_read_pg(struct btt *btt, struct page *page, unsigned int off, + sector_t sector, unsigned int len) +{ + int ret = 0; + int t_flag, e_flag; + struct arena_info *arena = NULL; + u32 lane = 0, premap, postmap; + + while (len) { + u32 cur_len; + + lane = nd_region_acquire_lane(btt->nd_region); + + ret = lba_to_arena(btt, sector, &premap, &arena); + if (ret) + goto out_lane; + + cur_len = min(arena->external_lbasize, len); + + ret = btt_map_read(arena, premap, &postmap, &t_flag, &e_flag); + if (ret) + goto out_lane; + + /* + * We loop to make sure that the post map LBA didn't change + * from under us between writing the RTT and doing the actual + * read. + */ + while (1) { + u32 new_map; + + if (t_flag) { + zero_fill_data(page, off, cur_len); + goto out_lane; + } + + if (e_flag) { + ret = -EIO; + goto out_lane; + } + + arena->rtt[lane] = RTT_VALID | postmap; + /* + * Barrier to make sure this write is not reordered + * to do the verification map_read before the RTT store + */ + barrier(); + + ret = btt_map_read(arena, premap, &new_map, &t_flag, + &e_flag); + if (ret) + goto out_rtt; + + if (postmap == new_map) + break; + + postmap = new_map; + } + + ret = btt_data_read(arena, page, off, postmap, cur_len); + if (ret) + goto out_rtt; + + arena->rtt[lane] = RTT_INVALID; + nd_region_release_lane(btt->nd_region, lane); + + len -= cur_len; + off += cur_len; + sector += arena->external_lbasize >> SECTOR_SHIFT; + } + + return 0; + + out_rtt: + arena->rtt[lane] = RTT_INVALID; + out_lane: + nd_region_release_lane(btt->nd_region, lane); + return ret; +} + +static int btt_write_pg(struct btt *btt, sector_t sector, struct page *page, + unsigned int off, unsigned int len) +{ + int ret = 0; + struct arena_info *arena = NULL; + u32 premap = 0, old_postmap, new_postmap, lane = 0, i; + struct log_entry log; + int sub; + + while (len) { + u32 cur_len; + + lane = nd_region_acquire_lane(btt->nd_region); + + ret = lba_to_arena(btt, sector, &premap, &arena); + if (ret) + goto out_lane; + cur_len = min(arena->external_lbasize, len); + + if ((arena->flags & IB_FLAG_ERROR_MASK) != 0) { + ret = -EIO; + goto out_lane; + } + + new_postmap = arena->freelist[lane].block; + + /* Wait if the new block is being read from */ + for (i = 0; i < arena->nfree; i++) + while (arena->rtt[i] == (RTT_VALID | new_postmap)) + cpu_relax(); + + + if (new_postmap >= arena->internal_nlba) { + ret = -EIO; + goto out_lane; + } else + ret = btt_data_write(arena, new_postmap, page, + off, cur_len); + if (ret) + goto out_lane; + + lock_map(arena, premap); + ret = btt_map_read(arena, premap, &old_postmap, NULL, NULL); + if (ret) + goto out_map; + if (old_postmap >= arena->internal_nlba) { + ret = -EIO; + goto out_map; + } + + log.lba = cpu_to_le32(premap); + log.old_map = cpu_to_le32(old_postmap); + log.new_map = cpu_to_le32(new_postmap); + log.seq = cpu_to_le32(arena->freelist[lane].seq); + sub = arena->freelist[lane].sub; + ret = btt_flog_write(arena, lane, sub, &log); + if (ret) + goto out_map; + + ret = btt_map_write(arena, premap, new_postmap, 0, 0); + if (ret) + goto out_map; + + unlock_map(arena, premap); + nd_region_release_lane(btt->nd_region, lane); + + len -= cur_len; + off += cur_len; + sector += arena->external_lbasize >> SECTOR_SHIFT; + } + + return 0; + + out_map: + unlock_map(arena, premap); + out_lane: + nd_region_release_lane(btt->nd_region, lane); + return ret; +} + +static int btt_do_bvec(struct btt *btt, struct page *page, + unsigned int len, unsigned int off, int rw, + sector_t sector) +{ + int ret; + + if (rw == READ) { + ret = btt_read_pg(btt, page, off, sector, len); + flush_dcache_page(page); + } else { + flush_dcache_page(page); + ret = btt_write_pg(btt, sector, page, off, len); + } + + return ret; +} + +static void btt_make_request(struct request_queue *q, struct bio *bio) +{ + struct block_device *bdev = bio->bi_bdev; + struct btt *btt = q->queuedata; + int rw; + struct bio_vec bvec; + sector_t sector; + struct bvec_iter iter; + int err = 0; + + sector = bio->bi_iter.bi_sector; + if (bio_end_sector(bio) > get_capacity(bdev->bd_disk)) { + err = -EIO; + goto out; + } + + BUG_ON(bio->bi_rw & REQ_DISCARD); + + rw = bio_rw(bio); + if (rw == READA) + rw = READ; + + bio_for_each_segment(bvec, bio, iter) { + unsigned int len = bvec.bv_len; + + BUG_ON(len > PAGE_SIZE); + /* Make sure len is in multiples of lbasize. */ + /* XXX is this right? */ + BUG_ON(len < btt->lbasize); + BUG_ON(len % btt->lbasize); + + err = btt_do_bvec(btt, bvec.bv_page, len, bvec.bv_offset, + rw, sector); + if (err) { + dev_info(&btt->nd_btt->dev, + "io error in %s sector %lld, len %d,\n", + (rw == READ) ? "READ" : "WRITE", + (unsigned long long) sector, len); + goto out; + } + sector += len >> SECTOR_SHIFT; + } + +out: + bio_endio(bio, err); +} + +static int btt_getgeo(struct block_device *bd, struct hd_geometry *geo) +{ + /* some standard values */ + geo->heads = 1 << 6; + geo->sectors = 1 << 5; + geo->cylinders = get_capacity(bd->bd_disk) >> 11; + return 0; +} + +static const struct block_device_operations btt_fops = { + .owner = THIS_MODULE, + /* TODO: Disable rw_page till lazy init is reworked */ + /*.rw_page = btt_rw_page, */ + .getgeo = btt_getgeo, +}; + +static int btt_blk_init(struct btt *btt) +{ + int ret; + + /* create a new disk and request queue for btt */ + btt->btt_queue = blk_alloc_queue(GFP_KERNEL); + if (!btt->btt_queue) + return -ENOMEM; + + btt->btt_disk = alloc_disk(0); + if (!btt->btt_disk) { + ret = -ENOMEM; + goto out_free_queue; + } + + sprintf(btt->btt_disk->disk_name, "%s", dev_name(&btt->nd_btt->dev)); + btt->btt_disk->driverfs_dev = &btt->nd_btt->dev; + btt->btt_disk->major = btt_major; + btt->btt_disk->first_minor = 0; + btt->btt_disk->fops = &btt_fops; + btt->btt_disk->private_data = btt; + btt->btt_disk->queue = btt->btt_queue; + btt->btt_disk->flags = GENHD_FL_EXT_DEVT; + + blk_queue_make_request(btt->btt_queue, btt_make_request); + blk_queue_max_hw_sectors(btt->btt_queue, 1024); + blk_queue_bounce_limit(btt->btt_queue, BLK_BOUNCE_ANY); + blk_queue_logical_block_size(btt->btt_queue, btt->lbasize); + btt->btt_queue->queuedata = btt; + + set_capacity(btt->btt_disk, btt->nlba * btt->lbasize >> SECTOR_SHIFT); + add_disk(btt->btt_disk); + + return 0; + +out_free_queue: + blk_cleanup_queue(btt->btt_queue); + return ret; +} + +static void btt_blk_cleanup(struct btt *btt) +{ + del_gendisk(btt->btt_disk); + put_disk(btt->btt_disk); + blk_cleanup_queue(btt->btt_queue); +} + +/** + * btt_init - initialize a block translation table for the given device + * @nd_btt: device with BTT geometry and backing device info + * @rawsize: raw size in bytes of the backing device + * @lbasize: lba size of the backing device + * @uuid: A uuid for the backing device - this is stored on media + * @maxlane: maximum number of parallel requests the device can handle + * + * Initialize a Block Translation Table on a backing device to provide + * single sector power fail atomicity. + * + * Context: + * Might sleep. + * + * Returns: + * Pointer to a new struct btt on success, NULL on failure. + */ +static struct btt *btt_init(struct nd_btt *nd_btt, unsigned long long rawsize, + u32 lbasize, u8 *uuid, struct nd_region *nd_region) +{ + int ret; + struct btt *btt; + struct device *dev = &nd_btt->dev; + + btt = kzalloc(sizeof(struct btt), GFP_KERNEL); + if (!btt) + return NULL; + + btt->nd_btt = nd_btt; + btt->rawsize = rawsize; + btt->lbasize = lbasize; + INIT_LIST_HEAD(&btt->arena_list); + mutex_init(&btt->init_lock); + btt->nd_region = nd_region; + + ret = discover_arenas(btt); + if (ret) { + dev_err(dev, "init: error in arena_discover: %d\n", ret); + goto out_free; + } + + if (btt->init_state != INIT_READY) { + btt->num_arenas = (rawsize / ARENA_MAX_SIZE) + + ((rawsize % ARENA_MAX_SIZE) ? 1 : 0); + dev_dbg(dev, "init: %d arenas for %llu rawsize\n", + btt->num_arenas, rawsize); + + ret = create_arenas(btt); + if (ret) { + dev_info(dev, "init: create_arenas: %d\n", ret); + goto out_free; + } + + ret = btt_meta_init(btt); + if (ret) { + dev_err(dev, "init: error in meta_init: %d\n", ret); + return NULL; + } + } + + ret = btt_blk_init(btt); + if (ret) { + dev_err(dev, "init: error in blk_init: %d\n", ret); + goto out_free; + } + + btt_debugfs_init(btt); + + return btt; + + out_free: + kfree(btt); + return NULL; +} + +/** + * btt_fini - de-initialize a BTT + * @btt: the BTT handle that was generated by btt_init + * + * De-initialize a Block Translation Table on device removal + * + * Context: + * Might sleep. + */ +static void btt_fini(struct btt *btt) +{ + if (btt) { + btt_blk_cleanup(btt); + free_arenas(btt); + debugfs_remove_recursive(btt->debugfs_dir); + kfree(btt); + } +} + +static int link_btt(struct nd_btt *nd_btt) +{ + struct block_device *bdev = nd_btt->backing_dev; + struct kobject *dir = &part_to_dev(bdev->bd_part)->kobj; + + return sysfs_create_link(dir, &nd_btt->dev.kobj, "nd_btt"); +} + +static void unlink_btt(struct nd_btt *nd_btt) +{ + struct block_device *bdev = nd_btt->backing_dev; + struct kobject *dir; + + /* if backing_dev was deleted first we may have nothing to unlink */ + if (!nd_btt->backing_dev) + return; + + dir = &part_to_dev(bdev->bd_part)->kobj; + sysfs_remove_link(dir, "nd_btt"); +} + +static int nd_btt_probe(struct device *dev) +{ + struct nd_btt *nd_btt = to_nd_btt(dev); + struct nd_io_claim *ndio_claim = nd_btt->ndio_claim; + struct nd_region *nd_region; + struct block_device *bdev; + struct btt *btt; + size_t rawsize; + int rc; + + if (!ndio_claim || !nd_btt->uuid || !nd_btt->backing_dev + || !nd_btt->lbasize) + return -ENODEV; + + rc = link_btt(nd_btt); + if (rc) + return rc; + + bdev = nd_btt->backing_dev; + /* the first 4K of a device is padding */ + nd_btt->offset = nd_partition_offset(bdev) + SZ_4K; + rawsize = (bdev->bd_part->nr_sects << SECTOR_SHIFT) - SZ_4K; + if (rawsize < ARENA_MIN_SIZE) { + rc = -ENXIO; + goto err_btt; + } + nd_btt->ndio = nd_btt->ndio_claim->parent; + nd_region = to_nd_region(nd_btt->ndio->dev->parent); + btt = btt_init(nd_btt, rawsize, nd_btt->lbasize, nd_btt->uuid, + nd_region); + if (!btt) { + rc = -ENOMEM; + goto err_btt; + } + btt->backing_dev = bdev; + dev_set_drvdata(dev, btt); + + return 0; + err_btt: + unlink_btt(nd_btt); + return rc; +} + +static int nd_btt_remove(struct device *dev) +{ + struct nd_btt *nd_btt = to_nd_btt(dev); + struct btt *btt = dev_get_drvdata(dev); + + btt_fini(btt); + unlink_btt(nd_btt); + + return 0; +} + +static struct nd_device_driver nd_btt_driver = { + .probe = nd_btt_probe, + .remove = nd_btt_remove, + .drv = { + .name = "nd_btt", + }, + .type = ND_DRIVER_BTT, +}; + +static int __init nd_btt_init(void) +{ + int rc; + + BUILD_BUG_ON(sizeof(struct btt_sb) != SZ_4K); + + btt_major = register_blkdev(0, "btt"); + if (btt_major < 0) + return btt_major; + + debugfs_root = debugfs_create_dir("btt", NULL); + if (IS_ERR_OR_NULL(debugfs_root)) { + rc = -ENXIO; + goto err_debugfs; + } + + rc = nd_driver_register(&nd_btt_driver); + if (rc < 0) + goto err_driver; + return 0; + + err_driver: + debugfs_remove_recursive(debugfs_root); + err_debugfs: + unregister_blkdev(btt_major, "btt"); + + return rc; +} + +static void __exit nd_btt_exit(void) +{ + driver_unregister(&nd_btt_driver.drv); + debugfs_remove_recursive(debugfs_root); + unregister_blkdev(btt_major, "btt"); +} + +MODULE_ALIAS_ND_DEVICE(ND_DEVICE_BTT); +MODULE_AUTHOR("Vishal Verma <vishal.l.verma(a)linux.intel.com&gt;&quot;); +MODULE_LICENSE("GPL v2"); +module_init(nd_btt_init); +module_exit(nd_btt_exit); diff --git a/drivers/block/nd/btt.h b/drivers/block/nd/btt.h index e8f6d8e0ddd3..d4e67c75c91f 100644 --- a/drivers/block/nd/btt.h +++ b/drivers/block/nd/btt.h @@ -19,6 +19,39 @@ #define BTT_SIG_LEN 16 #define BTT_SIG "BTT_ARENA_INFO\0" +#define MAP_ENT_SIZE 4 +#define MAP_TRIM_SHIFT 31 +#define MAP_TRIM_MASK (1 << MAP_TRIM_SHIFT) +#define MAP_ERR_SHIFT 30 +#define MAP_ERR_MASK (1 << MAP_ERR_SHIFT) +#define MAP_LBA_MASK (~((1 << MAP_TRIM_SHIFT) | (1 << MAP_ERR_SHIFT))) +#define MAP_ENT_NORMAL 0xC0000000 +#define LOG_ENT_SIZE sizeof(struct log_entry) +#define ARENA_MIN_SIZE (1UL << 24) /* 16 MB */ +#define ARENA_MAX_SIZE (1ULL << 39) /* 512 GB */ +#define RTT_VALID (1UL << 31) +#define RTT_INVALID 0 +#define INT_LBASIZE_ALIGNMENT 256 +#define BTT_PG_SIZE 4096 +#define BTT_DEFAULT_NFREE ND_MAX_LANES +#define LOG_SEQ_INIT 1 + +#define IB_FLAG_ERROR 0x00000001 +#define IB_FLAG_ERROR_MASK 0x00000001 + +enum btt_init_state { + INIT_UNCHECKED = 0, + INIT_NOTFOUND, + INIT_READY +}; + +struct log_entry { + __le32 lba; + __le32 old_map; + __le32 new_map; + __le32 seq; + __le64 padding[2]; +}; struct btt_sb { u8 signature[BTT_SIG_LEN]; @@ -42,4 +75,111 @@ struct btt_sb { __le64 checksum; }; +struct free_entry { + u32 block; + u8 sub; + u8 seq; +}; + +struct aligned_lock { + union { + spinlock_t lock; + u8 cacheline_padding[L1_CACHE_BYTES]; + }; +}; + +/** + * struct arena_info - handle for an arena + * @size: Size in bytes this arena occupies on the raw device. + * This includes arena metadata. + * @external_lba_start: The first external LBA in this arena. + * @internal_nlba: Number of internal blocks available in the arena + * including nfree reserved blocks + * @internal_lbasize: Internal and external lba sizes may be different as + * we can round up 'odd' external lbasizes such as 520B + * to be aligned. + * @external_nlba: Number of blocks contributed by the arena to the number + * reported to upper layers. (internal_nlba - nfree) + * @external_lbasize: LBA size as exposed to upper layers. + * @nfree: A reserve number of 'free' blocks that is used to + * handle incoming writes. + * @version_major: Metadata layout version major. + * @version_minor: Metadata layout version minor. + * @nextoff: Offset in bytes to the start of the next arena. + * @infooff: Offset in bytes to the info block of this arena. + * @dataoff: Offset in bytes to the data area of this arena. + * @mapoff: Offset in bytes to the map area of this arena. + * @logoff: Offset in bytes to the log area of this arena. + * @info2off: Offset in bytes to the backup info block of this arena. + * @freelist: Pointer to in-memory list of free blocks + * @rtt: Pointer to in-memory "Read Tracking Table" + * @map_locks: Spinlocks protecting concurrent map writes + * @nd_btt: Pointer to parent nd_btt structure. + * @list: List head for list of arenas + * @debugfs_dir: Debugfs dentry + * @flags: Arena flags - may signify error states. + * + * arena_info is a per-arena handle. Once an arena is narrowed down for an + * IO, this struct is passed around for the duration of the IO. + */ +struct arena_info { + u64 size; /* Total bytes for this arena */ + u64 external_lba_start; + u32 internal_nlba; + u32 internal_lbasize; + u32 external_nlba; + u32 external_lbasize; + u32 nfree; + u16 version_major; + u16 version_minor; + /* Byte offsets to the different on-media structures */ + u64 nextoff; + u64 infooff; + u64 dataoff; + u64 mapoff; + u64 logoff; + u64 info2off; + /* Pointers to other in-memory structures for this arena */ + struct free_entry *freelist; + u32 *rtt; + struct aligned_lock *map_locks; + struct nd_btt *nd_btt; + struct list_head list; + struct dentry *debugfs_dir; + /* Arena flags */ + u32 flags; +}; + +/** + * struct btt - handle for a BTT instance + * @btt_disk: Pointer to the gendisk for BTT device + * @btt_queue: Pointer to the request queue for the BTT device + * @arena_list: Head of the list of arenas + * @debugfs_dir: Debugfs dentry + * @backing_dev: Backing block device for the BTT + * @nd_btt: Parent nd_btt struct + * @nlba: Number of logical blocks exposed to the upper layers + * after removing the amount of space needed by metadata + * @rawsize: Total size in bytes of the available backing device + * @lbasize: LBA size as requested and presented to upper layers + * @lanes: Per-lane spinlocks + * @init_lock: Mutex used for the BTT initialization + * @init_state: Flag describing the initialization state for the BTT + * @num_arenas: Number of arenas in the BTT instance + */ +struct btt { + struct gendisk *btt_disk; + struct request_queue *btt_queue; + struct list_head arena_list; + struct dentry *debugfs_dir; + struct block_device *backing_dev; + struct nd_btt *nd_btt; + u64 nlba; + unsigned long long rawsize; + u32 lbasize; + struct nd_region *nd_region; + struct mutex init_lock; + int init_state; + int num_arenas; +}; #endif diff --git a/drivers/block/nd/btt_devs.c b/drivers/block/nd/btt_devs.c index 746d582910b6..6db50443cb2f 100644 --- a/drivers/block/nd/btt_devs.c +++ b/drivers/block/nd/btt_devs.c @@ -342,7 +342,8 @@ struct nd_btt *nd_btt_create(struct nd_bus *nd_bus) */ u64 btt_sb_checksum(struct btt_sb *btt_sb) { - u64 sum, sum_save; + u64 sum; + __le64 sum_save; sum_save = btt_sb->checksum; btt_sb->checksum = 0; diff --git a/drivers/block/nd/core.c b/drivers/block/nd/core.c index a093c6468a53..065ab9b5ec61 100644 --- a/drivers/block/nd/core.c +++ b/drivers/block/nd/core.c @@ -149,6 +149,7 @@ u64 nd_fletcher64(void __iomem *addr, size_t len) return hi32 << 32 | lo32; } +EXPORT_SYMBOL(nd_fletcher64); static void nd_bus_release(struct device *dev) { diff --git a/drivers/block/nd/nd.h b/drivers/block/nd/nd.h index b4f95ccc0252..ef77b5893628 100644 --- a/drivers/block/nd/nd.h +++ b/drivers/block/nd/nd.h @@ -21,6 +21,12 @@ #include "label.h" enum { + /* + * Limits the maximum number of block apertures a dimm can + * support and is an input to the geometry/on-disk-format of a + * BTT instance + */ + ND_MAX_LANES = 256, SECTOR_SHIFT = 9, }; @@ -109,6 +115,7 @@ struct nd_region { u64 ndr_size; u64 ndr_start; int id; + int num_lanes; struct nd_mapping mapping[0]; }; @@ -239,6 +246,8 @@ struct nd_btt *to_nd_btt(struct device *dev); struct btt_sb; u64 btt_sb_checksum(struct btt_sb *btt_sb); struct nd_region *to_nd_region(struct device *dev); +unsigned int nd_region_acquire_lane(struct nd_region *nd_region); +void nd_region_release_lane(struct nd_region *nd_region, unsigned int lane); int nd_region_to_namespace_type(struct nd_region *nd_region); int nd_region_register_namespaces(struct nd_region *nd_region, int *err); u64 nd_region_interleave_set_cookie(struct nd_region *nd_region); diff --git a/drivers/block/nd/region_devs.c b/drivers/block/nd/region_devs.c index 1b2c81e0eb0f..0aab8bb0a982 100644 --- a/drivers/block/nd/region_devs.c +++ b/drivers/block/nd/region_devs.c @@ -22,6 +22,72 @@ #include <asm-generic/io-64-nonatomic-lo-hi.h> +static struct { + struct { + int count[CONFIG_ND_MAX_REGIONS]; + spinlock_t lock[CONFIG_ND_MAX_REGIONS]; + } lane[NR_CPUS]; +} nd_percpu_lane; + +static void nd_region_init_locks(void) +{ + int i, j; + + for (i = 0; i < NR_CPUS; i++) + for (j = 0; j < CONFIG_ND_MAX_REGIONS; j++) + spin_lock_init(&nd_percpu_lane.lane[i].lock[j]); +} + +/** + * nd_region_acquire_lane - allocate and lock a lane + * @nd_region: region id and number of lanes possible + * + * A lane correlates to a BLK-data-window and/or a log slot in the BTT. + * We optimize for the common case where there are 256 lanes, one + * per-cpu. For larger systems we need to lock to share lanes. For now + * this implementation assumes the cost of maintaining an allocator for + * free lanes is on the order of the lock hold time, so it implements a + * static lane = cpu % num_lanes mapping. + * + * In the case of a BTT instance on top of a BLK namespace a lane may be + * acquired recursively. We lock on the first instance. + * + * In the case of a BTT instance on top of PMEM, we only acquire a lane + * for the BTT metadata updates. + */ +unsigned int nd_region_acquire_lane(struct nd_region *nd_region) +{ + unsigned int cpu, lane; + + cpu = get_cpu(); + + if (nd_region->num_lanes < NR_CPUS) { + unsigned int id = nd_region->id; + + lane = cpu % nd_region->num_lanes; + if (nd_percpu_lane.lane[cpu].count[id]++ == 0) + spin_lock(&nd_percpu_lane.lane[lane].lock[id]); + } else + lane = cpu; + + return lane; +} +EXPORT_SYMBOL(nd_region_acquire_lane); + +void nd_region_release_lane(struct nd_region *nd_region, unsigned int lane) +{ + if (nd_region->num_lanes < NR_CPUS) { + unsigned int cpu = get_cpu(); + unsigned int id = nd_region->id; + + if (--nd_percpu_lane.lane[cpu].count[id] == 0) + spin_unlock(&nd_percpu_lane.lane[lane].lock[id]); + put_cpu(); + } + put_cpu(); +} +EXPORT_SYMBOL(nd_region_release_lane); + static DEFINE_IDA(region_ida); static void nd_region_release(struct device *dev) @@ -679,6 +745,8 @@ static void nd_blk_init(struct nd_bus *nd_bus, struct nd_region *nd_region, } nd_region->ndr_mappings = 1; + nd_region->num_lanes = min_t(unsigned short, + readw(&nd_mem->nfit_bdw->num_bdw), ND_MAX_LANES); nd_mapping = &nd_region->mapping[0]; nd_mapping->nd_dimm = nd_dimm; nd_mapping->size = readq(&nd_mem->nfit_bdw->blk_capacity); @@ -692,6 +760,7 @@ static void nd_spa_range_init(struct nd_bus *nd_bus, struct nd_region *nd_region struct nd_spa *nd_spa = nd_region->nd_spa; u16 spa_index = readw(&nd_spa->nfit_spa->spa_index); + nd_region->num_lanes = ND_MAX_LANES; nd_region->dev.type = type; for (i = 0; i < nd_region->ndr_mappings; i++) { struct nd_memdev *nd_memdev = nd_memdev_from_spa(nd_bus, @@ -736,6 +805,12 @@ static struct nd_region *nd_region_create(struct nd_bus *nd_bus, if (nd_region->id < 0) { kfree(nd_region); return NULL; + } else if (nd_region->id >= CONFIG_ND_MAX_REGIONS) { + dev_err(&nd_bus->dev, "max region limit %d reached\n", + CONFIG_ND_MAX_REGIONS); + ida_simple_remove(&region_ida, nd_region->id); + kfree(nd_region); + return NULL; } nd_region->nd_spa = nd_spa; nd_region->ndr_mappings = num_mappings; @@ -769,6 +844,8 @@ int nd_bus_register_regions(struct nd_bus *nd_bus) struct nd_spa *nd_spa; int rc = 0; + nd_region_init_locks(); + mutex_lock(&nd_bus_list_mutex); list_for_each_entry(nd_spa, &nd_bus->spas, list) { int spa_type;