memremap: replace the altmap_valid field with a PGMAP_ALTMAP_VALID flag

Add a flags field to struct dev_pagemap to replace the altmap_valid boolean to be a little more extensible. Also add a pgmap_altmap() helper to find the optional altmap and clean up the code using the altmap using it.

Christoph Hellwig committed 7 years ago

Commit 514caf21 parent 80a72d09 files · +29 −43Browse files

Unified · Split

9 files

arch/powerpc/mm/mem.c +1 −9
arch/x86/mm/init_64.c +2 −6
drivers/nvdimm/pfn_devs.c +1 −2
drivers/nvdimm/pmem.c +0 −1
include/linux/memremap.h +11 −1
kernel/memremap.c +10 −16
mm/hmm.c +0 −1
mm/memory_hotplug.c +2 −4
mm/page_alloc.c +2 −3

arch/powerpc/mm/mem.c+1−9

 {
 	unsigned long start_pfn = start >> PAGE_SHIFT;
 	unsigned long nr_pages = size >> PAGE_SHIFT;
-	struct page *page;
+	struct page *page = pfn_to_page(start_pfn) + vmem_altmap_offset(altmap);
 	int ret;
-	/*
-	 * If we have an altmap then we need to skip over any reserved PFNs
-	 * when querying the zone.
-	 */
-	page = pfn_to_page(start_pfn);
-	if (altmap)
-		page += vmem_altmap_offset(altmap);
 	__remove_pages(page_zone(page), start_pfn, nr_pages, altmap);
 	/* Remove htab bolted mappings for this section of memory */

arch/x86/mm/init_64.c+2−6

 {
 	unsigned long start_pfn = start >> PAGE_SHIFT;
 	unsigned long nr_pages = size >> PAGE_SHIFT;
-	struct page *page = pfn_to_page(start_pfn);
+	struct page *page = pfn_to_page(start_pfn) + vmem_altmap_offset(altmap);
-	struct zone *zone;
+	struct zone *zone = page_zone(page);
-	/* With altmap the first mapped page is offset from @start */
-	if (altmap)
-		page += vmem_altmap_offset(altmap);
-	zone = page_zone(page);
 	__remove_pages(zone, start_pfn, nr_pages, altmap);
 	kernel_physical_mapping_remove(start, start + size);
 }

drivers/nvdimm/pfn_devs.c+1−2

 		if (offset < reserve)
 			return -EINVAL;
 		nd_pfn->npfns = le64_to_cpu(pfn_sb->npfns);
-		pgmap->altmap_valid = false;
 	} else if (nd_pfn->mode == PFN_MODE_PMEM) {
 		nd_pfn->npfns = PFN_SECTION_ALIGN_UP((resource_size(res)
 					- offset) / PAGE_SIZE);
 		memcpy(altmap, &__altmap, sizeof(*altmap));
 		altmap->free = PHYS_PFN(offset - reserve);
 		altmap->alloc = 0;
-		pgmap->altmap_valid = true;
+		pgmap->flags |= PGMAP_ALTMAP_VALID;
 	} else
 		return -ENXIO;

drivers/nvdimm/pmem.c+0−1

@@ -412,7 +412,6 @@ static int pmem_attach_disk(struct device *dev, · 411 unmodified lines
412	bb_res.start += pmem->data_offset;	412	bb_res.start += pmem->data_offset;
413	} else if (pmem_should_map_pages(dev)) {	413	} else if (pmem_should_map_pages(dev)) {
414	memcpy(&pmem->pgmap.res, &nsio->res, sizeof(pmem->pgmap.res));	414	memcpy(&pmem->pgmap.res, &nsio->res, sizeof(pmem->pgmap.res));
415	pmem->pgmap.altmap_valid = false;
416	pmem->pgmap.type = MEMORY_DEVICE_FS_DAX;	415	pmem->pgmap.type = MEMORY_DEVICE_FS_DAX;
417	pmem->pgmap.ops = &fsdax_pagemap_ops;	416	pmem->pgmap.ops = &fsdax_pagemap_ops;
418	addr = devm_memremap_pages(dev, &pmem->pgmap);	417	addr = devm_memremap_pages(dev, &pmem->pgmap);

include/linux/memremap.h+11−1

 	vm_fault_t (*migrate_to_ram)(struct vm_fault *vmf);
 };
+#define PGMAP_ALTMAP_VALID	(1 << 0)
 /**
  * struct dev_pagemap - metadata for ZONE_DEVICE mappings
  * @altmap: pre-allocated/reserved memory for vmemmap allocations
  * @dev: host device of the mapping for debug
  * @data: private data pointer for page_free()
  * @type: memory type: see MEMORY_* in memory_hotplug.h
+ * @flags: PGMAP_* flags to specify defailed behavior
  * @ops: method table
  */
 struct dev_pagemap {
 	struct vmem_altmap altmap;
-	bool altmap_valid;
 	struct resource res;
 	struct percpu_ref *ref;
 	struct device *dev;
 	enum memory_type type;
+	unsigned int flags;
 	u64 pci_p2pdma_bus_offset;
 	const struct dev_pagemap_ops *ops;
 };
+static inline struct vmem_altmap *pgmap_altmap(struct dev_pagemap *pgmap)
+{
+	if (pgmap->flags & PGMAP_ALTMAP_VALID)
+		return &pgmap->altmap;
+	return NULL;
+}
 #ifdef CONFIG_ZONE_DEVICE
 void *devm_memremap_pages(struct device *dev, struct dev_pagemap *pgmap);
 void devm_memunmap_pages(struct device *dev, struct dev_pagemap *pgmap);

kernel/memremap.c+10−16

 static unsigned long pfn_first(struct dev_pagemap *pgmap)
 {
-	const struct resource *res = &pgmap->res;
+	return (pgmap->res.start >> PAGE_SHIFT) +
-	struct vmem_altmap *altmap = &pgmap->altmap;
+		vmem_altmap_offset(pgmap_altmap(pgmap));
-	unsigned long pfn;
-	pfn = res->start >> PAGE_SHIFT;
-	if (pgmap->altmap_valid)
-		pfn += vmem_altmap_offset(altmap);
-	return pfn;
 }
 static unsigned long pfn_end(struct dev_pagemap *pgmap)
 				align_size >> PAGE_SHIFT, NULL);
 	} else {
 		arch_remove_memory(nid, align_start, align_size,
-				pgmap->altmap_valid ? &pgmap->altmap : NULL);
+				pgmap_altmap(pgmap));
 		kasan_remove_zero_shadow(__va(align_start), align_size);
 	}
 	mem_hotplug_done();
  * 1/ At a minimum the res, ref and type and ops members of @pgmap must be
  *    initialized by the caller before passing it to this function
  *
- * 2/ The altmap field may optionally be initialized, in which case altmap_valid
+ * 2/ The altmap field may optionally be initialized, in which case
- *    must be set to true
+ *    PGMAP_ALTMAP_VALID must be set in pgmap->flags.
  *
  * 3/ pgmap->ref must be 'live' on entry and will be killed and reaped
  *    at devm_memremap_pages_release() time, or if this routine fails.
 void *devm_memremap_pages(struct device *dev, struct dev_pagemap *pgmap)
 {
 	resource_size_t align_start, align_size, align_end;
-	struct vmem_altmap *altmap = pgmap->altmap_valid ?
-			&pgmap->altmap : NULL;
 	struct resource *res = &pgmap->res;
 	struct dev_pagemap *conflict_pgmap;
 	struct mhp_restrictions restrictions = {
 		/*
 		 * We do not want any optional features only our own memmap
 		*/
-		.altmap = altmap,
+		.altmap = pgmap_altmap(pgmap),
 	};
 	pgprot_t pgprot = PAGE_KERNEL;
 	int error, nid, is_ram;
 		zone = &NODE_DATA(nid)->node_zones[ZONE_DEVICE];
 		move_pfn_range_to_zone(zone, align_start >> PAGE_SHIFT,
-				align_size >> PAGE_SHIFT, altmap);
+				align_size >> PAGE_SHIFT, pgmap_altmap(pgmap));
 	}
 	mem_hotplug_done();
 unsigned long vmem_altmap_offset(struct vmem_altmap *altmap)
 {
 	/* number of pfns from base where pfn_to_page() is valid */
-	return altmap->reserve + altmap->free;
+	if (altmap)
+		return altmap->reserve + altmap->free;
+	return 0;
 }
 void vmem_altmap_free(struct vmem_altmap *altmap, unsigned long nr_pfns)

mm/hmm.c+0−1

@@ -1442,7 +1442,6 @@ struct hmm_devmem hmm_devmem_add(const struct hmm_devmem_ops ops, · 1441 unmodified lines
1442	devmem->pagemap.type = MEMORY_DEVICE_PRIVATE;	1442	devmem->pagemap.type = MEMORY_DEVICE_PRIVATE;
1443	devmem->pagemap.res = *devmem->resource;	1443	devmem->pagemap.res = *devmem->resource;
1444	devmem->pagemap.ops = &hmm_pagemap_ops;	1444	devmem->pagemap.ops = &hmm_pagemap_ops;
1445	devmem->pagemap.altmap_valid = false;
1446	devmem->pagemap.ref = &devmem->ref;	1445	devmem->pagemap.ref = &devmem->ref;
1447		1446
1448	result = devm_memremap_pages(devmem->device, &devmem->pagemap);	1447	result = devm_memremap_pages(devmem->device, &devmem->pagemap);

mm/memory_hotplug.c+2−4

@@ -557,10 +557,8 @@ void __remove_pages(struct zone *zone, unsigned long phys_start_pfn, · 556 unmodified lines
557	int sections_to_remove;	557	int sections_to_remove;
558		558
559	/* In the ZONE_DEVICE case device driver owns the memory region */	559	/* In the ZONE_DEVICE case device driver owns the memory region */
560	if (is_dev_zone(zone)) {	560	if (is_dev_zone(zone))
561	if (altmap)	561	map_offset = vmem_altmap_offset(altmap);
562	map_offset = vmem_altmap_offset(altmap);
563	}
564		562
565	clear_zone_contiguous(zone);	563	clear_zone_contiguous(zone);
566		564

mm/page_alloc.c+2−3

 {
 	unsigned long pfn, end_pfn = start_pfn + size;
 	struct pglist_data *pgdat = zone->zone_pgdat;
+	struct vmem_altmap *altmap = pgmap_altmap(pgmap);
 	unsigned long zone_idx = zone_idx(zone);
 	unsigned long start = jiffies;
 	int nid = pgdat->node_id;
 	 * of the pages reserved for the memmap, so we can just jump to
 	 * the end of that region and start processing the device pages.
 	 */
-	if (pgmap->altmap_valid) {
+	if (altmap) {
-		struct vmem_altmap *altmap = &pgmap->altmap;
 		start_pfn = altmap->base_pfn + vmem_altmap_offset(altmap);
 		size = end_pfn - start_pfn;
 	}

memremap: replace the altmap_valid field with a PGMAP_ALTMAP_VALID flag

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code