Merge tag 'libnvdimm-fixes-4.20-rc6' of git://git.kernel.org/pub/scm/linux/kernel/git/nvdimm/nvdimm

Pull libnvdimm fixes from Dan Williams: "A regression fix for the Address Range Scrub implementation, yes another one, and support for platforms that misalign persistent memory relative to the Linux memory hotplug section constraint. Longer term, support for sub-section memory hotplug would alleviate alignment waste, but until then this hack allows a 'struct page' memmap to be established for these misaligned memory regions. These have all appeared in a -next release, and thanks to Patrick for reporting and testing the alignment padding fix. Summary: - Unless and until the core mm handles memory hotplug units smaller than a section (128M), persistent memory namespaces must be padded to section alignment. The libnvdimm core already handled section collision with "System RAM", but some configurations overlap independent "Persistent Memory" ranges within a section, so additional padding injection is added for that case. - The recent reworks of the ARS (address range scrub) state machine to reduce the number of state flags inadvertantly missed a conversion of acpi_nfit_ars_rescan() call sites. Fix the regression whereby user-requested ARS results in a "short" scrub rather than a "long" scrub. - Fixup the unit tests to handle / test the 128M section alignment of mocked test resources. * tag 'libnvdimm-fixes-4.20-rc6' of git://git.kernel.org/pub/scm/linux/kernel/git/nvdimm/nvdimm: acpi/nfit: Fix user-initiated ARS to be "ARS-long" rather than "ARS-short" libnvdimm, pfn: Pad pfn namespaces relative to other regions tools/testing/nvdimm: Align test resources to 128M

Linus Torvalds committed 7 years ago

Commit bd799eb2 parents 6ec067e b5fd2e05 files · +114 −30Browse files

Unified · Split

5 files

drivers/acpi/nfit/core.c +1 −1
drivers/nvdimm/nd-core.h +2 −0
drivers/nvdimm/pfn_devs.c +37 −27
drivers/nvdimm/region_devs.c +41 −0
tools/testing/nvdimm/test/nfit.c +33 −2

drivers/acpi/nfit/core.c+1−1

@@ -1308,7 +1308,7 @@ static ssize_t scrub_store(struct device *dev, · 1307 unmodified lines
1308	if (nd_desc) {	1308	if (nd_desc) {
1309	struct acpi_nfit_desc *acpi_desc = to_acpi_desc(nd_desc);	1309	struct acpi_nfit_desc *acpi_desc = to_acpi_desc(nd_desc);
1310		1310
1311	rc = acpi_nfit_ars_rescan(acpi_desc, 0);	1311	rc = acpi_nfit_ars_rescan(acpi_desc, ARS_REQ_LONG);
1312	}	1312	}
1313	device_unlock(dev);	1313	device_unlock(dev);
1314	if (rc)	1314	if (rc)

drivers/nvdimm/nd-core.h+2−0

 		struct nd_mapping *nd_mapping, resource_size_t *overlap);
 resource_size_t nd_blk_available_dpa(struct nd_region *nd_region);
 resource_size_t nd_region_available_dpa(struct nd_region *nd_region);
+int nd_region_conflict(struct nd_region *nd_region, resource_size_t start,
+		resource_size_t size);
 resource_size_t nvdimm_allocated_dpa(struct nvdimm_drvdata *ndd,
 		struct nd_label_id *label_id);
 int alias_dpa_busy(struct device *dev, void *data);

drivers/nvdimm/pfn_devs.c+37−27

 			ALIGN_DOWN(phys, nd_pfn->align));
 }
+/*
+ * Check if pmem collides with 'System RAM', or other regions when
+ * section aligned.  Trim it accordingly.
+ */
+static void trim_pfn_device(struct nd_pfn *nd_pfn, u32 *start_pad, u32 *end_trunc)
+{
+	struct nd_namespace_common *ndns = nd_pfn->ndns;
+	struct nd_namespace_io *nsio = to_nd_namespace_io(&ndns->dev);
+	struct nd_region *nd_region = to_nd_region(nd_pfn->dev.parent);
+	const resource_size_t start = nsio->res.start;
+	const resource_size_t end = start + resource_size(&nsio->res);
+	resource_size_t adjust, size;
+	*start_pad = 0;
+	*end_trunc = 0;
+	adjust = start - PHYS_SECTION_ALIGN_DOWN(start);
+	size = resource_size(&nsio->res) + adjust;
+	if (region_intersects(start - adjust, size, IORESOURCE_SYSTEM_RAM,
+				IORES_DESC_NONE) == REGION_MIXED
+			|| nd_region_conflict(nd_region, start - adjust, size))
+		*start_pad = PHYS_SECTION_ALIGN_UP(start) - start;
+	/* Now check that end of the range does not collide. */
+	adjust = PHYS_SECTION_ALIGN_UP(end) - end;
+	size = resource_size(&nsio->res) + adjust;
+	if (region_intersects(start, size, IORESOURCE_SYSTEM_RAM,
+				IORES_DESC_NONE) == REGION_MIXED
+			|| !IS_ALIGNED(end, nd_pfn->align)
+			|| nd_region_conflict(nd_region, start, size + adjust))
+		*end_trunc = end - phys_pmem_align_down(nd_pfn, end);
+}
 static int nd_pfn_init(struct nd_pfn *nd_pfn)
 {
 	u32 dax_label_reserve = is_nd_dax(&nd_pfn->dev) ? SZ_128K : 0;
 	struct nd_namespace_common *ndns = nd_pfn->ndns;
-	u32 start_pad = 0, end_trunc = 0;
+	struct nd_namespace_io *nsio = to_nd_namespace_io(&ndns->dev);
 	resource_size_t start, size;
-	struct nd_namespace_io *nsio;
 	struct nd_region *nd_region;
+	u32 start_pad, end_trunc;
 	struct nd_pfn_sb *pfn_sb;
 	unsigned long npfns;
 	phys_addr_t offset;
 	memset(pfn_sb, 0, sizeof(*pfn_sb));
-	/*
+	trim_pfn_device(nd_pfn, &start_pad, &end_trunc);
-	 * Check if pmem collides with 'System RAM' when section aligned and
-	 * trim it accordingly
-	 */
-	nsio = to_nd_namespace_io(&ndns->dev);
-	start = PHYS_SECTION_ALIGN_DOWN(nsio->res.start);
-	size = resource_size(&nsio->res);
-	if (region_intersects(start, size, IORESOURCE_SYSTEM_RAM,
-				IORES_DESC_NONE) == REGION_MIXED) {
-		start = nsio->res.start;
-		start_pad = PHYS_SECTION_ALIGN_UP(start) - start;
-	}
-	start = nsio->res.start;
-	size = PHYS_SECTION_ALIGN_UP(start + size) - start;
-	if (region_intersects(start, size, IORESOURCE_SYSTEM_RAM,
-				IORES_DESC_NONE) == REGION_MIXED
-			|| !IS_ALIGNED(start + resource_size(&nsio->res),
-				nd_pfn->align)) {
-		size = resource_size(&nsio->res);
-		end_trunc = start + size - phys_pmem_align_down(nd_pfn,
-				start + size);
-	}
 	if (start_pad + end_trunc)
 		dev_info(&nd_pfn->dev, "%s alignment collision, truncate %d bytes\n",
 				dev_name(&ndns->dev), start_pad + end_trunc);
 	 * implementation will limit the pfns advertised through
 	 * ->direct_access() to those that are included in the memmap.
 	 */
-	start += start_pad;
+	start = nsio->res.start + start_pad;
 	size = resource_size(&nsio->res);
 	npfns = PFN_SECTION_ALIGN_UP((size - start_pad - end_trunc - SZ_8K)
 			/ PAGE_SIZE);

drivers/nvdimm/region_devs.c+41−0

@@ -1184,6 +1184,47 @@ int nvdimm_has_cache(struct nd_region *nd_region) · 1183 unmodified lines
1184	}	1184	}
1185	EXPORT_SYMBOL_GPL(nvdimm_has_cache);	1185	EXPORT_SYMBOL_GPL(nvdimm_has_cache);
1186		1186
		1187	struct conflict_context {
		1188	struct nd_region *nd_region;
		1189	resource_size_t start, size;
		1190	};
		1191
		1192	static int region_conflict(struct device dev, void data)
		1193	{
		1194	struct nd_region *nd_region;
		1195	struct conflict_context *ctx = data;
		1196	resource_size_t res_end, region_end, region_start;
		1197
		1198	if (!is_memory(dev))
		1199	return 0;
		1200
		1201	nd_region = to_nd_region(dev);
		1202	if (nd_region == ctx->nd_region)
		1203	return 0;
		1204
		1205	res_end = ctx->start + ctx->size;
		1206	region_start = nd_region->ndr_start;
		1207	region_end = region_start + nd_region->ndr_size;
		1208	if (ctx->start >= region_start && ctx->start < region_end)
		1209	return -EBUSY;
		1210	if (res_end > region_start && res_end <= region_end)
		1211	return -EBUSY;
		1212	return 0;
		1213	}
		1214
		1215	int nd_region_conflict(struct nd_region *nd_region, resource_size_t start,
		1216	resource_size_t size)
		1217	{
		1218	struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(&nd_region->dev);
		1219	struct conflict_context ctx = {
		1220	.nd_region = nd_region,
		1221	.start = start,
		1222	.size = size,
		1223	};
		1224
		1225	return device_for_each_child(&nvdimm_bus->dev, &ctx, region_conflict);
		1226	}
		1227
1187	void __exit nd_region_devs_exit(void)	1228	void __exit nd_region_devs_exit(void)
1188	{	1229	{
1189	ida_destroy(&region_ida);	1230	ida_destroy(&region_ida);

tools/testing/nvdimm/test/nfit.c+33−2

 #include <linux/dma-mapping.h>
 #include <linux/workqueue.h>
 #include <linux/libnvdimm.h>
+#include <linux/genalloc.h>
 #include <linux/vmalloc.h>
 #include <linux/device.h>
 #include <linux/module.h>
 static struct workqueue_struct *nfit_wq;
+static struct gen_pool *nfit_pool;
 static struct nfit_test *to_nfit_test(struct device *dev)
 {
 	struct platform_device *pdev = to_platform_device(dev);
 	list_del(&nfit_res->list);
 	spin_unlock(&nfit_test_lock);
+	if (resource_size(&nfit_res->res) >= DIMM_SIZE)
+		gen_pool_free(nfit_pool, nfit_res->res.start,
+				resource_size(&nfit_res->res));
 	vfree(nfit_res->buf);
 	kfree(nfit_res);
 }
 			GFP_KERNEL);
 	int rc;
-	if (!buf || !nfit_res)
+	if (!buf || !nfit_res || !*dma)
 		goto err;
 	rc = devm_add_action(dev, release_nfit_res, nfit_res);
 	if (rc)
 	return nfit_res->buf;
  err:
+	if (*dma && size >= DIMM_SIZE)
+		gen_pool_free(nfit_pool, *dma, size);
 	if (buf)
 		vfree(buf);
 	kfree(nfit_res);
 static void *test_alloc(struct nfit_test *t, size_t size, dma_addr_t *dma)
 {
+	struct genpool_data_align data = {
+		.align = SZ_128M,
+	};
 	void *buf = vmalloc(size);
-	*dma = (unsigned long) buf;
+	if (size >= DIMM_SIZE)
+		*dma = gen_pool_alloc_algo(nfit_pool, size,
+				gen_pool_first_fit_align, &data);
+	else
+		*dma = (unsigned long) buf;
 	return __test_alloc(t, size, dma, buf);
 }
 		goto err_register;
 	}
+	nfit_pool = gen_pool_create(ilog2(SZ_4M), NUMA_NO_NODE);
+	if (!nfit_pool) {
+		rc = -ENOMEM;
+		goto err_register;
+	}
+	if (gen_pool_add(nfit_pool, SZ_4G, SZ_4G, NUMA_NO_NODE)) {
+		rc = -ENOMEM;
+		goto err_register;
+	}
 	for (i = 0; i < NUM_NFITS; i++) {
 		struct nfit_test *nfit_test;
 		struct platform_device *pdev;
 	return 0;
  err_register:
+	if (nfit_pool)
+		gen_pool_destroy(nfit_pool);
 	destroy_workqueue(nfit_wq);
 	for (i = 0; i < NUM_NFITS; i++)
 		if (instances[i])
 	platform_driver_unregister(&nfit_test_driver);
 	nfit_test_teardown();
+	gen_pool_destroy(nfit_pool);
 	for (i = 0; i < NUM_NFITS; i++)
 		put_device(&instances[i]->pdev.dev);
 	class_destroy(nfit_test_dimm);