diff mbox

[11/15] mm, dax, pmem: introduce __pfn_t

Message ID 20150923044211.36490.18084.stgit@dwillia2-desk3.jf.intel.com (mailing list archive)
State New, archived
Headers show

Commit Message

Dan Williams Sept. 23, 2015, 4:42 a.m. UTC 
In preparation for enabling get_user_pages() operations on dax mappings,
introduce a type that encapsulates a page-frame-number that can also be
used to encode other information.  This other information is the
historical "page_link" encoding in a scatterlist, but can also denote
"device memory".  Where "device memory" is a set of pfns that are not
part of the kernel's linear mapping by default, but are accessed via the
same memory controller as ram.  The motivation for this new type is
large capacity persistent memory that optionally has struct page entries
in the 'memmap'.

When a driver, like pmem, has established a devm_memremap_pages()
mapping it needs to communicate to upper layers that the pfn has a page
backing.  This property will be leveraged in a later patch to enable
dax-gup.  For now, update all the ->direct_access() implementations to
communicate whether the returned pfn range is mapped.

Cc: Christoph Hellwig <hch@lst.de>
Cc: Dave Hansen <dave@sr71.net>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Ross Zwisler <ross.zwisler@linux.intel.com>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
---
 arch/powerpc/sysdev/axonram.c |    8 ++---
 drivers/block/brd.c           |    4 +-
 drivers/nvdimm/pmem.c         |   27 ++++++++-------
 drivers/s390/block/dcssblk.c  |   10 ++----
 fs/block_dev.c                |    2 +
 fs/dax.c                      |   23 +++++++------
 include/linux/blkdev.h        |    4 +-
 include/linux/mm.h            |   72 +++++++++++++++++++++++++++++++++++++++++
 8 files changed, 110 insertions(+), 40 deletions(-)


--
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Comments

Dave Hansen Sept. 23, 2015, 4:02 p.m. UTC | #1 
On 09/22/2015 09:42 PM, Dan Williams wrote:
>  /*
> + * __pfn_t: encapsulates a page-frame number that is optionally backed
> + * by memmap (struct page).  Whether a __pfn_t has a 'struct page'
> + * backing is indicated by flags in the low bits of the value;
> + */
> +typedef struct {
> +	unsigned long val;
> +} __pfn_t;
> +
> +/*
> + * PFN_SG_CHAIN - pfn is a pointer to the next scatterlist entry
> + * PFN_SG_LAST - pfn references a page and is the last scatterlist entry
> + * PFN_DEV - pfn is not covered by system memmap by default
> + * PFN_MAP - pfn has a dynamic page mapping established by a device driver
> + */
> +enum {
> +	PFN_SHIFT = 4,
> +	PFN_MASK = (1UL << PFN_SHIFT) - 1,
> +	PFN_SG_CHAIN = (1UL << 0),
> +	PFN_SG_LAST = (1UL << 1),
> +	PFN_DEV = (1UL << 2),
> +	PFN_MAP = (1UL << 3),
> +};

Please forgive a little bikeshedding here...

Why __pfn_t?  Because the KVM code has a pfn_t?  If so, I think we
should rescue pfn_t from KVM and give them a kvm_pfn_t.

I think you should do one of two things:  Make PFN_SHIFT 12 so that a
physical addr can be stored in a __pfn_t with no work.  Or, use the
*high* 12 bits of __pfn_t.val.

If you use the high bits, *and* make it store a plain pfn when all the
bits are 0, then you get a zero-cost pfn<->__pfn_t conversion which will
hopefully generate the exact same code which is there today.

The one disadvantage here is that it makes it more likely that somebody
that's just setting __pfn_t.val=foo will get things subtly wrong
somehow, but that it will work most of the time.

Also, about naming...  PFN_SHIFT is pretty awful name for this.  It
probably needs to be __PFN_T_SOMETHING.  We don't want folks doing
craziness like:

	unsigned long phys_addr = pfn << PFN_SHIFT.

Which *looks* OK.
--
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Dan Williams Sept. 23, 2015, 11:36 p.m. UTC | #2 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--
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
diff mbox

Patch

diff --git a/arch/powerpc/sysdev/axonram.c b/arch/powerpc/sysdev/axonram.c
index 24ffab2572e8..35eff52c0a38 100644
--- a/arch/powerpc/sysdev/axonram.c
+++ b/arch/powerpc/sysdev/axonram.c
@@ -141,15 +141,13 @@  axon_ram_make_request(struct request_queue *queue, struct bio *bio)
  */
 static long
 axon_ram_direct_access(struct block_device *device, sector_t sector,
-		       void __pmem **kaddr, unsigned long *pfn)
+		       void __pmem **kaddr, __pfn_t *pfn)
 {
 	struct axon_ram_bank *bank = device->bd_disk->private_data;
 	loff_t offset = (loff_t)sector << AXON_RAM_SECTOR_SHIFT;
-	void *addr = (void *)(bank->ph_addr + offset);
-
-	*kaddr = (void __pmem *)addr;
-	*pfn = virt_to_phys(addr) >> PAGE_SHIFT;
 
+	*kaddr = (void __pmem __force *) bank->io_addr + offset;
+	*pfn = phys_to_pfn_t(bank->ph_addr + offset, PFN_DEV);
 	return bank->size - offset;
 }
 
diff --git a/drivers/block/brd.c b/drivers/block/brd.c
index f645a71ae827..50e78b1ea26c 100644
--- a/drivers/block/brd.c
+++ b/drivers/block/brd.c
@@ -374,7 +374,7 @@  static int brd_rw_page(struct block_device *bdev, sector_t sector,
 
 #ifdef CONFIG_BLK_DEV_RAM_DAX
 static long brd_direct_access(struct block_device *bdev, sector_t sector,
-			void __pmem **kaddr, unsigned long *pfn)
+			void __pmem **kaddr, __pfn_t *pfn)
 {
 	struct brd_device *brd = bdev->bd_disk->private_data;
 	struct page *page;
@@ -385,7 +385,7 @@  static long brd_direct_access(struct block_device *bdev, sector_t sector,
 	if (!page)
 		return -ENOSPC;
 	*kaddr = (void __pmem *)page_address(page);
-	*pfn = page_to_pfn(page);
+	*pfn = page_to_pfn_t(page);
 
 	return PAGE_SIZE;
 }
diff --git a/drivers/nvdimm/pmem.c b/drivers/nvdimm/pmem.c
index 3ee02af73ad0..1c670775129b 100644
--- a/drivers/nvdimm/pmem.c
+++ b/drivers/nvdimm/pmem.c
@@ -39,6 +39,7 @@  struct pmem_device {
 	phys_addr_t		phys_addr;
 	/* when non-zero this device is hosting a 'pfn' instance */
 	phys_addr_t		data_offset;
+	unsigned long		pfn_flags;
 	void __pmem		*virt_addr;
 	size_t			size;
 };
@@ -108,25 +109,22 @@  static int pmem_rw_page(struct block_device *bdev, sector_t sector,
 }
 
 static long pmem_direct_access(struct block_device *bdev, sector_t sector,
-		      void __pmem **kaddr, unsigned long *pfn)
+		      void __pmem **kaddr, __pfn_t *pfn)
 {
 	struct pmem_device *pmem = bdev->bd_disk->private_data;
 	resource_size_t offset = sector * 512 + pmem->data_offset;
-	resource_size_t size;
+	resource_size_t size = pmem->size - offset;
 
-	if (pmem->data_offset) {
+	*kaddr = pmem->virt_addr + offset;
+	*pfn = phys_to_pfn_t(pmem->phys_addr + offset, pmem->pfn_flags);
+
+	if (__pfn_t_has_page(*pfn)) {
 		/*
 		 * Limit the direct_access() size to what is covered by
 		 * the memmap
 		 */
-		size = (pmem->size - offset) & ~ND_PFN_MASK;
-	} else
-		size = pmem->size - offset;
-
-	/* FIXME convert DAX to comprehend that this mapping has a lifetime */
-	*kaddr = pmem->virt_addr + offset;
-	*pfn = (pmem->phys_addr + offset) >> PAGE_SHIFT;
-
+		size &= ~ND_PFN_MASK;
+	}
 	return size;
 }
 
@@ -158,9 +156,11 @@  static struct pmem_device *pmem_alloc(struct device *dev,
 		return ERR_PTR(-EBUSY);
 	}
 
-	if (pmem_should_map_pages(dev))
+	pmem->pfn_flags = PFN_DEV;
+	if (pmem_should_map_pages(dev)) {
 		pmem->virt_addr = (void __pmem *) devm_memremap_pages(dev, res);
-	else
+		pmem->pfn_flags |= PFN_MAP;
+	} else
 		pmem->virt_addr = (void __pmem *) devm_memremap(dev,
 				pmem->phys_addr, pmem->size,
 				ARCH_MEMREMAP_PMEM);
@@ -371,6 +371,7 @@  static int nvdimm_namespace_attach_pfn(struct nd_namespace_common *ndns)
 	pmem = dev_get_drvdata(dev);
 	devm_memunmap(dev, (void __force *) pmem->virt_addr);
 	pmem->virt_addr = (void __pmem *) devm_memremap_pages(dev, &nsio->res);
+	pmem->pfn_flags |= PFN_MAP;
 	if (IS_ERR(pmem->virt_addr)) {
 		rc = PTR_ERR(pmem->virt_addr);
 		goto err;
diff --git a/drivers/s390/block/dcssblk.c b/drivers/s390/block/dcssblk.c
index c212ce925ee6..4dfa8cfbdd9a 100644
--- a/drivers/s390/block/dcssblk.c
+++ b/drivers/s390/block/dcssblk.c
@@ -29,7 +29,7 @@  static int dcssblk_open(struct block_device *bdev, fmode_t mode);
 static void dcssblk_release(struct gendisk *disk, fmode_t mode);
 static void dcssblk_make_request(struct request_queue *q, struct bio *bio);
 static long dcssblk_direct_access(struct block_device *bdev, sector_t secnum,
-			 void __pmem **kaddr, unsigned long *pfn);
+			 void __pmem **kaddr, __pfn_t *pfn);
 
 static char dcssblk_segments[DCSSBLK_PARM_LEN] = "\0";
 
@@ -881,20 +881,18 @@  fail:
 
 static long
 dcssblk_direct_access (struct block_device *bdev, sector_t secnum,
-			void __pmem **kaddr, unsigned long *pfn)
+			void __pmem **kaddr, __pfn_t *pfn)
 {
 	struct dcssblk_dev_info *dev_info;
 	unsigned long offset, dev_sz;
-	void *addr;
 
 	dev_info = bdev->bd_disk->private_data;
 	if (!dev_info)
 		return -ENODEV;
 	dev_sz = dev_info->end - dev_info->start;
 	offset = secnum * 512;
-	addr = (void *) (dev_info->start + offset);
-	*pfn = virt_to_phys(addr) >> PAGE_SHIFT;
-	*kaddr = (void __pmem *) addr;
+	*kaddr = (void __pmem *) (dev_info->start + offset);
+	*pfn = phys_to_pfn_t(dev_info->start + offset, PFN_DEV);
 
 	return dev_sz - offset;
 }
diff --git a/fs/block_dev.c b/fs/block_dev.c
index 073bb57adab1..74c507059f8d 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -442,7 +442,7 @@  EXPORT_SYMBOL_GPL(bdev_write_page);
  * accessible at this address.
  */
 long bdev_direct_access(struct block_device *bdev, sector_t sector,
-			void __pmem **addr, unsigned long *pfn, long size)
+			void __pmem **addr, __pfn_t *pfn, long size)
 {
 	long avail;
 	const struct block_device_operations *ops = bdev->bd_disk->fops;
diff --git a/fs/dax.c b/fs/dax.c
index 358eea39e982..41d4f76e93ef 100644
--- a/fs/dax.c
+++ b/fs/dax.c
@@ -37,7 +37,7 @@  int dax_clear_blocks(struct inode *inode, sector_t block, long size)
 	might_sleep();
 	do {
 		void __pmem *addr;
-		unsigned long pfn;
+		__pfn_t pfn;
 		long count;
 
 		count = bdev_direct_access(bdev, sector, &addr, &pfn, size);
@@ -64,7 +64,7 @@  int dax_clear_blocks(struct inode *inode, sector_t block, long size)
 EXPORT_SYMBOL_GPL(dax_clear_blocks);
 
 static void __pmem *__dax_map_bh(const struct buffer_head *bh, unsigned blkbits,
-		unsigned long *pfn, long *len)
+		__pfn_t *pfn, long *len)
 {
 	long rc;
 	void __pmem *addr;
@@ -87,7 +87,7 @@  static void __pmem *__dax_map_bh(const struct buffer_head *bh, unsigned blkbits,
 
 static void __pmem *dax_map_bh(const struct buffer_head *bh, unsigned blkbits)
 {
-	unsigned long pfn;
+	__pfn_t pfn;
 
 	return __dax_map_bh(bh, blkbits, &pfn, NULL);
 }
@@ -138,7 +138,7 @@  static ssize_t dax_io(struct inode *inode, struct iov_iter *iter,
 	loff_t pos = start, max = start, bh_max = start;
 	int rw = iov_iter_rw(iter), rc;
 	long map_len = 0;
-	unsigned long pfn;
+	__pfn_t pfn;
 	void __pmem *addr = NULL;
 	void __pmem *kmap = (void __pmem *) ERR_PTR(-EIO);
 	bool hole = false;
@@ -324,9 +324,9 @@  static int dax_insert_mapping(struct inode *inode, struct buffer_head *bh,
 			struct vm_area_struct *vma, struct vm_fault *vmf)
 {
 	unsigned long vaddr = (unsigned long)vmf->virtual_address;
-	unsigned long pfn;
 	void __pmem *addr;
 	pgoff_t size;
+	__pfn_t pfn;
 	int error;
 
 	/*
@@ -354,7 +354,7 @@  static int dax_insert_mapping(struct inode *inode, struct buffer_head *bh,
 	}
 	dax_unmap_bh(bh, addr);
 
-	error = vm_insert_mixed(vma, vaddr, pfn);
+	error = vm_insert_mixed(vma, vaddr, __pfn_t_to_pfn(pfn));
 
  out:
 	return error;
@@ -604,7 +604,7 @@  int __dax_pmd_fault(struct vm_area_struct *vma, unsigned long address,
 	if (buffer_unwritten(&bh) || buffer_new(&bh)) {
 		int i;
 		long length;
-		unsigned long pfn;
+		__pfn_t pfn;
 		void __pmem *kaddr = __dax_map_bh(&bh, blkbits, &pfn, &length);
 
 		if (IS_ERR(kaddr)) {
@@ -612,7 +612,7 @@  int __dax_pmd_fault(struct vm_area_struct *vma, unsigned long address,
 			goto out;
 		}
 
-		if ((length < PMD_SIZE) || (pfn & PG_PMD_COLOUR))
+		if ((length < PMD_SIZE) || (__pfn_t_to_pfn(pfn) & PG_PMD_COLOUR))
 			goto fallback;
 
 		for (i = 0; i < PTRS_PER_PMD; i++)
@@ -668,8 +668,8 @@  int __dax_pmd_fault(struct vm_area_struct *vma, unsigned long address,
 		result = VM_FAULT_NOPAGE;
 		spin_unlock(ptl);
 	} else {
+		__pfn_t pfn;
 		long length;
-		unsigned long pfn;
 		void __pmem *kaddr = __dax_map_bh(&bh, blkbits, &pfn, &length);
 
 		if (IS_ERR(kaddr)) {
@@ -677,10 +677,11 @@  int __dax_pmd_fault(struct vm_area_struct *vma, unsigned long address,
 			goto out;
 		}
 		dax_unmap_bh(&bh, kaddr);
-		if ((length < PMD_SIZE) || (pfn & PG_PMD_COLOUR))
+		if ((length < PMD_SIZE) || (__pfn_t_to_pfn(pfn) & PG_PMD_COLOUR))
 			goto fallback;
 
-		result |= vmf_insert_pfn_pmd(vma, address, pmd, pfn, write);
+		result |= vmf_insert_pfn_pmd(vma, address, pmd,
+				__pfn_t_to_pfn(pfn), write);
 	}
 
  out:
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 363d7df8d65c..e893f30ad520 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -1634,7 +1634,7 @@  struct block_device_operations {
 	int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
 	int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
 	long (*direct_access)(struct block_device *, sector_t, void __pmem **,
-			unsigned long *pfn);
+			__pfn_t *);
 	unsigned int (*check_events) (struct gendisk *disk,
 				      unsigned int clearing);
 	/* ->media_changed() is DEPRECATED, use ->check_events() instead */
@@ -1653,7 +1653,7 @@  extern int bdev_read_page(struct block_device *, sector_t, struct page *);
 extern int bdev_write_page(struct block_device *, sector_t, struct page *,
 						struct writeback_control *);
 extern long bdev_direct_access(struct block_device *, sector_t,
-		void __pmem **addr, unsigned long *pfn, long size);
+		void __pmem **addr, __pfn_t *pfn, long size);
 #else /* CONFIG_BLOCK */
 
 struct block_device;
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 91c08f6f0dc9..6ea922de6870 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -906,6 +906,78 @@  static inline void set_page_links(struct page *page, enum zone_type zone,
 }
 
 /*
+ * __pfn_t: encapsulates a page-frame number that is optionally backed
+ * by memmap (struct page).  Whether a __pfn_t has a 'struct page'
+ * backing is indicated by flags in the low bits of the value;
+ */
+typedef struct {
+	unsigned long val;
+} __pfn_t;
+
+/*
+ * PFN_SG_CHAIN - pfn is a pointer to the next scatterlist entry
+ * PFN_SG_LAST - pfn references a page and is the last scatterlist entry
+ * PFN_DEV - pfn is not covered by system memmap by default
+ * PFN_MAP - pfn has a dynamic page mapping established by a device driver
+ */
+enum {
+	PFN_SHIFT = 4,
+	PFN_MASK = (1UL << PFN_SHIFT) - 1,
+	PFN_SG_CHAIN = (1UL << 0),
+	PFN_SG_LAST = (1UL << 1),
+	PFN_DEV = (1UL << 2),
+	PFN_MAP = (1UL << 3),
+};
+
+static inline __pfn_t pfn_to_pfn_t(unsigned long pfn, unsigned long flags)
+{
+	__pfn_t pfn_t = { .val = (pfn << PFN_SHIFT) | (flags & PFN_MASK), };
+
+	return pfn_t;
+}
+
+static inline __pfn_t phys_to_pfn_t(dma_addr_t addr, unsigned long flags)
+{
+	return pfn_to_pfn_t(addr >> PAGE_SHIFT, flags);
+}
+
+static inline bool __pfn_t_has_page(__pfn_t pfn)
+{
+	return (pfn.val & PFN_MAP) == PFN_MAP || (pfn.val & PFN_DEV) == 0;
+}
+
+static inline unsigned long __pfn_t_to_pfn(__pfn_t pfn)
+{
+	return pfn.val >> PFN_SHIFT;
+}
+
+static inline struct page *__pfn_t_to_page(__pfn_t pfn)
+{
+	if (__pfn_t_has_page(pfn))
+		return pfn_to_page(__pfn_t_to_pfn(pfn));
+	return NULL;
+}
+
+static inline dma_addr_t __pfn_t_to_phys(__pfn_t pfn)
+{
+	return PFN_PHYS(__pfn_t_to_pfn(pfn));
+}
+
+static inline void *__pfn_t_to_virt(__pfn_t pfn)
+{
+	if (__pfn_t_has_page(pfn))
+		return __va(__pfn_t_to_phys(pfn));
+	return NULL;
+}
+
+static inline __pfn_t page_to_pfn_t(struct page *page)
+{
+	__pfn_t pfn = { .val = page_to_pfn(page) << PFN_SHIFT, };
+
+	return pfn;
+}
+
+/*
  * Some inline functions in vmstat.h depend on page_zone()
  */
 #include <linux/vmstat.h>