Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > linux.kernel > #1213486 > unrolled thread

[PATCH v2 5/9] x86, pmem: push fallback handling to arch code

Started byDan Williams <dan.j.williams@intel.com>
First post2015-08-26 03:40 +0200
Last post2015-08-28 23:50 +0200
Articles 10 — 6 participants

Back to article view | Back to linux.kernel

This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by below is the oldest one visible, not the original post.

Contents

  [PATCH v2 5/9] x86, pmem: push fallback handling to arch code Dan Williams <dan.j.williams@intel.com> - 2015-08-26 03:40 +0200
    Re: [PATCH v2 5/9] x86, pmem: push fallback handling to arch code Christoph Hellwig <hch@lst.de> - 2015-08-26 14:50 +0200
      Re: [PATCH v2 5/9] x86, pmem: push fallback handling to arch code "Williams, Dan J" <dan.j.williams@intel.com> - 2015-08-26 23:40 +0200
        Re: [PATCH v2 5/9] x86, pmem: push fallback handling to arch code "hch@lst.de" <hch@lst.de> - 2015-08-27 09:40 +0200
        Re: [PATCH v2 5/9] x86, pmem: push fallback handling to arch code Ross Zwisler <ross.zwisler@linux.intel.com> - 2015-08-28 22:30 +0200
        Re: [PATCH v2 5/9] x86, pmem: push fallback handling to arch code Dan Williams <dan.j.williams@intel.com> - 2015-08-28 23:50 +0200
          Re: [PATCH v2 5/9] x86, pmem: push fallback handling to arch code Toshi Kani <toshi.kani@hp.com> - 2015-08-29 00:00 +0200
            Re: [PATCH v2 5/9] x86, pmem: push fallback handling to arch code "Williams, Dan J" <dan.j.williams@intel.com> - 2015-08-29 06:10 +0200
              Re: [PATCH v2 5/9] x86, pmem: push fallback handling to arch code "hch@lst.de" <hch@lst.de> - 2015-08-29 16:00 +0200
        Re: [PATCH v2 5/9] x86, pmem: push fallback handling to arch code Toshi Kani <toshi.kani@hp.com> - 2015-08-28 23:50 +0200

#1213486 — [PATCH v2 5/9] x86, pmem: push fallback handling to arch code

FromDan Williams <dan.j.williams@intel.com>
Date2015-08-26 03:40 +0200
Subject[PATCH v2 5/9] x86, pmem: push fallback handling to arch code
Message-ID<q1xR1-7IF-23@gated-at.bofh.it>
The decision of when to fallback to the default pmem apis is currently
done at too high of a level.  In particular the test for
arch_has_pmem_api() in memcpy_to_pmem() really wants to decide whether
the arch_memcpy_to_pmem() implementation is placing data in a location
that a subsequent wmb_pmem() can flush.

For x86 this equates to an arch_memcpy_to_pmem() implementation that
guarantees that write data is at most sitting in the local cpu write
buffer.  The current usage of __copy_from_user_inatomic_nocache()
guarantees this property on all 64-bit x86 implementations (at least
according to the Intel SDM that says Pentium M implementations may leave
dirty-data in the cache after a non-temporal store).  In the 32-bit case
waiting until memcpy_to_pmem() time to perform a fallback is too late.
Instead 32-bit x86 is converted to use write-through mappings for pmem.

arch_has_pmem_api() is updated to only indicate whether the arch
provides the proper helpers.  Code that cares whether wmb_pmem()
actually flushes writes to pmem must now call arch_has_wmb_pmem()
directly.

Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Toshi Kani <toshi.kani@hp.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Ross Zwisler <ross.zwisler@linux.intel.com>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
---
 arch/x86/include/asm/io.h   |    2 -
 arch/x86/include/asm/pmem.h |   41 ++++++++++++++++++++++--
 drivers/acpi/nfit.c         |    2 +
 drivers/nvdimm/pmem.c       |    2 +
 include/asm-generic/pmem.h  |   72 ++++++++++++++++++++++++++++++++++++++++++
 include/linux/pmem.h        |   73 +++++++------------------------------------
 6 files changed, 123 insertions(+), 69 deletions(-)
 create mode 100644 include/asm-generic/pmem.h

diff --git a/arch/x86/include/asm/io.h b/arch/x86/include/asm/io.h
index d241fbd5c87b..83ec9b1d77cc 100644
--- a/arch/x86/include/asm/io.h
+++ b/arch/x86/include/asm/io.h
@@ -248,8 +248,6 @@ static inline void flush_write_buffers(void)
 #endif
 }
 
-#define ARCH_MEMREMAP_PMEM MEMREMAP_WB
-
 #endif /* __KERNEL__ */
 
 extern void native_io_delay(void);
diff --git a/arch/x86/include/asm/pmem.h b/arch/x86/include/asm/pmem.h
index a3a0df6545ee..6eb3c1da5d57 100644
--- a/arch/x86/include/asm/pmem.h
+++ b/arch/x86/include/asm/pmem.h
@@ -16,9 +16,12 @@
 #include <linux/uaccess.h>
 #include <asm/cacheflush.h>
 #include <asm/cpufeature.h>
+#include <asm-generic/pmem.h>
 #include <asm/special_insns.h>
 
 #ifdef CONFIG_ARCH_HAS_PMEM_API
+#ifdef CONFIG_X86_64
+#define ARCH_MEMREMAP_PMEM MEMREMAP_WB
 /**
  * arch_memcpy_to_pmem - copy data to persistent memory
  * @dst: destination buffer for the copy
@@ -141,18 +144,48 @@ static inline void arch_clear_pmem(void __pmem *addr, size_t size)
 	__arch_wb_cache_pmem(vaddr, size);
 }
 
-static inline bool arch_has_wmb_pmem(void)
+static inline bool __arch_has_wmb_pmem(void)
 {
-#ifdef CONFIG_X86_64
 	/*
 	 * We require that wmb() be an 'sfence', that is only guaranteed on
 	 * 64-bit builds
 	 */
 	return static_cpu_has(X86_FEATURE_PCOMMIT);
+}
 #else
+/*
+ * Some 32-bit implementations may leave dirty-data in cache after a
+ * series of non-temporal stores, so set pmem ranges to write-through
+ * caching.
+ */
+#define ARCH_MEMREMAP_PMEM MEMREMAP_WT
+
+static inline void arch_memcpy_to_pmem(void __pmem *dst, const void *src,
+		size_t n)
+{
+	default_memcpy_pmem(dst, src, n);
+}
+
+static inline size_t arch_copy_from_iter_pmem(void __pmem *addr, size_t bytes,
+		struct iov_iter *i)
+{
+	return default_copy_from_iter_pmem(addr, bytes, i);
+}
+
+static inline void arch_clear_pmem(void __pmem *addr, size_t size)
+{
+	default_clear_pmem(addr, size);
+}
+
+static inline void arch_wmb_pmem(void)
+{
+	wmb();
+}
+
+static inline bool __arch_has_wmb_pmem(void)
+{
 	return false;
-#endif
 }
+#endif /* CONFIG_X86_64 */
 #endif /* CONFIG_ARCH_HAS_PMEM_API */
-
 #endif /* __ASM_X86_PMEM_H__ */
diff --git a/drivers/acpi/nfit.c b/drivers/acpi/nfit.c
index 7c2638f914a9..c3fe20635562 100644
--- a/drivers/acpi/nfit.c
+++ b/drivers/acpi/nfit.c
@@ -1364,7 +1364,7 @@ static int acpi_nfit_blk_region_enable(struct nvdimm_bus *nvdimm_bus,
 			return -ENOMEM;
 	}
 
-	if (!arch_has_pmem_api() && !nfit_blk->nvdimm_flush)
+	if (!arch_has_wmb_pmem() && !nfit_blk->nvdimm_flush)
 		dev_warn(dev, "unable to guarantee persistence of writes\n");
 
 	if (mmio->line_size == 0)
diff --git a/drivers/nvdimm/pmem.c b/drivers/nvdimm/pmem.c
index 3b5b9cb758b6..20bf122328da 100644
--- a/drivers/nvdimm/pmem.c
+++ b/drivers/nvdimm/pmem.c
@@ -125,7 +125,7 @@ static struct pmem_device *pmem_alloc(struct device *dev,
 
 	pmem->phys_addr = res->start;
 	pmem->size = resource_size(res);
-	if (!arch_has_pmem_api())
+	if (!arch_has_wmb_pmem())
 		dev_warn(dev, "unable to guarantee persistence of writes\n");
 
 	if (!devm_request_mem_region(dev, pmem->phys_addr, pmem->size,
diff --git a/include/asm-generic/pmem.h b/include/asm-generic/pmem.h
new file mode 100644
index 000000000000..95d1a6ac0df7
--- /dev/null
+++ b/include/asm-generic/pmem.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright(c) 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 __ASM_GENERIC_PMEM_H__
+#define __ASM_GENERIC_PMEM_H__
+/*
+ * These defaults seek to offer decent performance and minimize the
+ * window between i/o completion and writes being durable on media.
+ * However, it is undefined / architecture specific whether
+ * default_memremap_pmem + default_memcpy_to_pmem is sufficient for
+ * making data durable relative to i/o completion.
+ */
+static inline void default_memcpy_to_pmem(void __pmem *dst, const void *src,
+		size_t size)
+{
+	memcpy((void __force *) dst, src, size);
+}
+
+static inline size_t default_copy_from_iter_pmem(void __pmem *addr,
+		size_t bytes, struct iov_iter *i)
+{
+	return copy_from_iter_nocache((void __force *)addr, bytes, i);
+}
+
+static inline void default_clear_pmem(void __pmem *addr, size_t size)
+{
+	if (size == PAGE_SIZE && ((unsigned long)addr & ~PAGE_MASK) == 0)
+		clear_page((void __force *)addr);
+	else
+		memset((void __force *)addr, 0, size);
+}
+
+#ifndef CONFIG_ARCH_HAS_PMEM_API
+/*
+ * These are simply here to enable compilation, all call sites gate
+ * calling these symbols with arch_has_pmem_api() and redirect to the
+ * implementation in asm/pmem.h.
+ */
+
+static inline bool __arch_has_wmb_pmem(void)
+{
+	return false;
+}
+
+static inline void arch_memcpy_to_pmem(void __pmem *dst, const void *src,
+		size_t n)
+{
+	BUG();
+}
+
+static inline size_t arch_copy_from_iter_pmem(void __pmem *addr, size_t bytes,
+		struct iov_iter *i)
+{
+	BUG();
+	return 0;
+}
+
+static inline void arch_clear_pmem(void __pmem *addr, size_t size)
+{
+	BUG();
+}
+#endif /* CONFIG_ARCH_HAS_PMEM_API */
+#endif /* __ASM_GENERIC_PMEM_H__ */
diff --git a/include/linux/pmem.h b/include/linux/pmem.h
index a9d84bf335ee..f7f5a713a860 100644
--- a/include/linux/pmem.h
+++ b/include/linux/pmem.h
@@ -15,37 +15,9 @@
 
 #include <linux/io.h>
 #include <linux/uio.h>
-
+#include <asm-generic/pmem.h>
 #ifdef CONFIG_ARCH_HAS_PMEM_API
 #include <asm/pmem.h>
-#else
-static inline void arch_wmb_pmem(void)
-{
-	BUG();
-}
-
-static inline bool arch_has_wmb_pmem(void)
-{
-	return false;
-}
-
-static inline void arch_memcpy_to_pmem(void __pmem *dst, const void *src,
-		size_t n)
-{
-	BUG();
-}
-
-static inline size_t arch_copy_from_iter_pmem(void __pmem *addr, size_t bytes,
-		struct iov_iter *i)
-{
-	BUG();
-	return 0;
-}
-
-static inline void arch_clear_pmem(void __pmem *addr, size_t size)
-{
-	BUG();
-}
 #endif
 
 /*
@@ -53,7 +25,6 @@ static inline void arch_clear_pmem(void __pmem *addr, size_t size)
  * implementations for arch_memcpy_to_pmem(), arch_wmb_pmem(),
  * arch_copy_from_iter_pmem(), arch_clear_pmem() and arch_has_wmb_pmem().
  */
-
 static inline void memcpy_from_pmem(void *dst, void __pmem const *src, size_t size)
 {
 	memcpy(dst, (void __force const *) src, size);
@@ -64,8 +35,13 @@ static inline void memunmap_pmem(struct device *dev, void __pmem *addr)
 	devm_memunmap(dev, (void __force *) addr);
 }
 
+static inline bool arch_has_pmem_api(void)
+{
+	return IS_ENABLED(CONFIG_ARCH_HAS_PMEM_API);
+}
+
 /**
- * arch_has_pmem_api - true if wmb_pmem() ensures durability
+ * arch_has_wmb_pmem - true if wmb_pmem() ensures durability
  *
  * For a given cpu implementation within an architecture it is possible
  * that wmb_pmem() resolves to a nop.  In the case this returns
@@ -73,36 +49,9 @@ static inline void memunmap_pmem(struct device *dev, void __pmem *addr)
  * fall back to a different data consistency model, or otherwise notify
  * the user.
  */
-static inline bool arch_has_pmem_api(void)
-{
-	return IS_ENABLED(CONFIG_ARCH_HAS_PMEM_API) && arch_has_wmb_pmem();
-}
-
-/*
- * These defaults seek to offer decent performance and minimize the
- * window between i/o completion and writes being durable on media.
- * However, it is undefined / architecture specific whether
- * default_memremap_pmem + default_memcpy_to_pmem is sufficient for
- * making data durable relative to i/o completion.
- */
-static inline void default_memcpy_to_pmem(void __pmem *dst, const void *src,
-		size_t size)
-{
-	memcpy((void __force *) dst, src, size);
-}
-
-static inline size_t default_copy_from_iter_pmem(void __pmem *addr,
-		size_t bytes, struct iov_iter *i)
-{
-	return copy_from_iter_nocache((void __force *)addr, bytes, i);
-}
-
-static inline void default_clear_pmem(void __pmem *addr, size_t size)
+static inline bool arch_has_wmb_pmem(void)
 {
-	if (size == PAGE_SIZE && ((unsigned long)addr & ~PAGE_MASK) == 0)
-		clear_page((void __force *)addr);
-	else
-		memset((void __force *)addr, 0, size);
+	return arch_has_pmem_api() && __arch_has_wmb_pmem();
 }
 
 /**
@@ -158,8 +107,10 @@ static inline void memcpy_to_pmem(void __pmem *dst, const void *src, size_t n)
  */
 static inline void wmb_pmem(void)
 {
-	if (arch_has_pmem_api())
+	if (arch_has_wmb_pmem())
 		arch_wmb_pmem();
+	else
+		wmb();
 }
 
 /**

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

[toc] | [next] | [standalone]

#1213825

FromChristoph Hellwig <hch@lst.de>
Date2015-08-26 14:50 +0200
Message-ID<q1Ijo-602-29@gated-at.bofh.it>
In reply to#1213486
I like the intent behind this, but not the implementation.

I think the right approach is to keep the defaults in linux/pmem.h
and simply not set CONFIG_ARCH_HAS_PMEM_API for x86-32.
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1214205

From"Williams, Dan J" <dan.j.williams@intel.com>
Date2015-08-26 23:40 +0200
Message-ID<q1QAi-12Y-11@gated-at.bofh.it>
In reply to#1213825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--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1214368

From"hch@lst.de" <hch@lst.de>
Date2015-08-27 09:40 +0200
Message-ID<q1ZWW-6e9-11@gated-at.bofh.it>
In reply to#1214205
This looks fine to me,

Reviewed-by: Christoph Hellwig <hch@lst.de>
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1215546

FromRoss Zwisler <ross.zwisler@linux.intel.com>
Date2015-08-28 22:30 +0200
Message-ID<q2yrE-5vE-7@gated-at.bofh.it>
In reply to#1214205
On Wed, Aug 26, 2015 at 09:34:20PM +0000, Williams, Dan J wrote:
> On Wed, 2015-08-26 at 14:41 +0200, Christoph Hellwig wrote:
> > I like the intent behind this, but not the implementation.
> > 
> > I think the right approach is to keep the defaults in linux/pmem.h
> > and simply not set CONFIG_ARCH_HAS_PMEM_API for x86-32.
> 
> Yes, that makes things much cleaner.  Revised patch and changelog below:
> 
> 8<----
> Subject: x86, pmem: clarify that ARCH_HAS_PMEM_API implies PMEM mapped WB
> 
> From: Dan Williams <dan.j.williams@intel.com>
> 
> Given that a write-back (WB) mapping plus non-temporal stores is
> expected to be the most efficient way to access PMEM, update the
> definition of ARCH_HAS_PMEM_API to imply arch support for
> WB-mapped-PMEM.  This is needed as a pre-requisite for adding PMEM to
> the direct map and mapping it with struct page.
> 
> The above clarification for X86_64 means that memcpy_to_pmem() is
> permitted to use the non-temporal arch_memcpy_to_pmem() rather than
> needlessly fall back to default_memcpy_to_pmem() when the pcommit
> instruction is not available.  When arch_memcpy_to_pmem() is not
> guaranteed to flush writes out of cache, i.e. on older X86_32
> implementations where non-temporal stores may just dirty cache,
> ARCH_HAS_PMEM_API is simply disabled.
> 
> The default fall back for persistent memory handling remains.  Namely,
> map it with the WT (write-through) cache-type and hope for the best.
> 
> arch_has_pmem_api() is updated to only indicate whether the arch
> provides the proper helpers to meet the minimum "writes are visible
> outside the cache hierarchy after memcpy_to_pmem() + wmb_pmem()".  Code
> that cares whether wmb_pmem() actually flushes writes to pmem must now
> call arch_has_wmb_pmem() directly.
> 
> Cc: Thomas Gleixner <tglx@linutronix.de>
> Cc: Ingo Molnar <mingo@redhat.com>
> Cc: "H. Peter Anvin" <hpa@zytor.com>
> Cc: Toshi Kani <toshi.kani@hp.com>
> Cc: Ross Zwisler <ross.zwisler@linux.intel.com>
> Cc: Christoph Hellwig <hch@lst.de>
> [hch: set ARCH_HAS_PMEM_API=n on X86_32]
> Signed-off-by: Dan Williams <dan.j.williams@intel.com>

Yep, this seems like a good change.

Reviewed-by: Ross Zwisler <ross.zwisler@linux.intel.com>
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1215577

FromDan Williams <dan.j.williams@intel.com>
Date2015-08-28 23:50 +0200
Message-ID<q2zH4-7az-21@gated-at.bofh.it>
In reply to#1214205
On Fri, Aug 28, 2015 at 2:41 PM, Toshi Kani <toshi.kani@hp.com> wrote:
> On Wed, 2015-08-26 at 21:34 +0000, Williams, Dan J wrote:
[..]
>> -#define ARCH_MEMREMAP_PMEM MEMREMAP_WB
>
> Should it be better to do:
>
> #else   /* !CONFIG_ARCH_HAS_PMEM_API */
> #define ARCH_MEMREMAP_PMEM MEMREMAP_WT
>
> so that you can remove all '#ifdef ARCH_MEMREMAP_PMEM' stuff?

Yeah, that seems like a nice incremental cleanup for memremap_pmem()
to just unconditionally use ARCH_MEMREMAP_PMEM, feel free to send it
along.
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1215585

FromToshi Kani <toshi.kani@hp.com>
Date2015-08-29 00:00 +0200
Message-ID<q2zQK-7lW-21@gated-at.bofh.it>
In reply to#1215577
On Fri, 2015-08-28 at 14:47 -0700, Dan Williams wrote:
> On Fri, Aug 28, 2015 at 2:41 PM, Toshi Kani <toshi.kani@hp.com> wrote:
> > On Wed, 2015-08-26 at 21:34 +0000, Williams, Dan J wrote:
> [..]
> > > -#define ARCH_MEMREMAP_PMEM MEMREMAP_WB
> > 
> > Should it be better to do:
> > 
> > #else   /* !CONFIG_ARCH_HAS_PMEM_API */
> > #define ARCH_MEMREMAP_PMEM MEMREMAP_WT
> > 
> > so that you can remove all '#ifdef ARCH_MEMREMAP_PMEM' stuff?
> 
> Yeah, that seems like a nice incremental cleanup for memremap_pmem()
> to just unconditionally use ARCH_MEMREMAP_PMEM, feel free to send it
> along.

OK. Will do.

Thanks,
-Toshi
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1215682

From"Williams, Dan J" <dan.j.williams@intel.com>
Date2015-08-29 06:10 +0200
Message-ID<q2FCN-7rY-5@gated-at.bofh.it>
In reply to#1215585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==
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1215774

From"hch@lst.de" <hch@lst.de>
Date2015-08-29 16:00 +0200
Message-ID<q2OPL-3Bw-1@gated-at.bofh.it>
In reply to#1215682
On Sat, Aug 29, 2015 at 04:04:58AM +0000, Williams, Dan J wrote:
> On Fri, 2015-08-28 at 15:48 -0600, Toshi Kani wrote:
> > On Fri, 2015-08-28 at 14:47 -0700, Dan Williams wrote:
> > > On Fri, Aug 28, 2015 at 2:41 PM, Toshi Kani <toshi.kani@hp.com> wrote:
> > > > On Wed, 2015-08-26 at 21:34 +0000, Williams, Dan J wrote:
> > > [..]
> > > > > -#define ARCH_MEMREMAP_PMEM MEMREMAP_WB
> > > > 
> > > > Should it be better to do:
> > > > 
> > > > #else   /* !CONFIG_ARCH_HAS_PMEM_API */
> > > > #define ARCH_MEMREMAP_PMEM MEMREMAP_WT
> > > > 
> > > > so that you can remove all '#ifdef ARCH_MEMREMAP_PMEM' stuff?
> > > 
> > > Yeah, that seems like a nice incremental cleanup for memremap_pmem()
> > > to just unconditionally use ARCH_MEMREMAP_PMEM, feel free to send it
> > > along.
> > 
> > OK. Will do.
> > 
> 
> Here's the re-worked patch with Toshi's fixes folded in:

I like this in principle, but we'll have to be carefull now if we
want to drop the fallbacks in mremap, as we will have to shift it into
the pmem driver then.
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [next] | [standalone]

#1215580

FromToshi Kani <toshi.kani@hp.com>
Date2015-08-28 23:50 +0200
Message-ID<q2zH4-7az-23@gated-at.bofh.it>
In reply to#1214205
On Wed, 2015-08-26 at 21:34 +0000, Williams, Dan J wrote:
> On Wed, 2015-08-26 at 14:41 +0200, Christoph Hellwig wrote:
> > I like the intent behind this, but not the implementation.
> > 
> > I think the right approach is to keep the defaults in linux/pmem.h
> > and simply not set CONFIG_ARCH_HAS_PMEM_API for x86-32.
> 
> Yes, that makes things much cleaner.  Revised patch and changelog below:
> 
> 8<----
> Subject: x86, pmem: clarify that ARCH_HAS_PMEM_API implies PMEM mapped WB
> 
> From: Dan Williams <dan.j.williams@intel.com>
> 
> Given that a write-back (WB) mapping plus non-temporal stores is
> expected to be the most efficient way to access PMEM, update the
> definition of ARCH_HAS_PMEM_API to imply arch support for
> WB-mapped-PMEM.  This is needed as a pre-requisite for adding PMEM to
> the direct map and mapping it with struct page.
> 
> The above clarification for X86_64 means that memcpy_to_pmem() is
> permitted to use the non-temporal arch_memcpy_to_pmem() rather than
> needlessly fall back to default_memcpy_to_pmem() when the pcommit
> instruction is not available.  When arch_memcpy_to_pmem() is not
> guaranteed to flush writes out of cache, i.e. on older X86_32
> implementations where non-temporal stores may just dirty cache,
> ARCH_HAS_PMEM_API is simply disabled.
> 
> The default fall back for persistent memory handling remains.  Namely,
> map it with the WT (write-through) cache-type and hope for the best.
> 
> arch_has_pmem_api() is updated to only indicate whether the arch
> provides the proper helpers to meet the minimum "writes are visible
> outside the cache hierarchy after memcpy_to_pmem() + wmb_pmem()".  Code
> that cares whether wmb_pmem() actually flushes writes to pmem must now
> call arch_has_wmb_pmem() directly.
> 
> Cc: Thomas Gleixner <tglx@linutronix.de>
> Cc: Ingo Molnar <mingo@redhat.com>
> Cc: "H. Peter Anvin" <hpa@zytor.com>
> Cc: Toshi Kani <toshi.kani@hp.com>
> Cc: Ross Zwisler <ross.zwisler@linux.intel.com>
> Cc: Christoph Hellwig <hch@lst.de>
> [hch: set ARCH_HAS_PMEM_API=n on X86_32]
> Signed-off-by: Dan Williams <dan.j.williams@intel.com>

Thanks for making this change!  It looks good.

Reviewed-by: Toshi Kani <toshi.kani@hp.com>

I have one minor comment below:

> ---
>  arch/x86/Kconfig            |    2 +-
>  arch/x86/include/asm/io.h   |    2 --
>  arch/x86/include/asm/pmem.h |    8 ++------
>  drivers/acpi/nfit.c         |    2 +-
>  drivers/nvdimm/pmem.c       |    2 +-
>  include/linux/pmem.h        |   28 +++++++++++++++++-----------
>  6 files changed, 22 insertions(+), 22 deletions(-)
> 
> diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
> index 76c61154ed50..5912859df533 100644
> --- a/arch/x86/Kconfig
> +++ b/arch/x86/Kconfig
> @@ -27,7 +27,7 @@ config X86
>  	select ARCH_HAS_ELF_RANDOMIZE
>  	select ARCH_HAS_FAST_MULTIPLIER
>  	select ARCH_HAS_GCOV_PROFILE_ALL
> -	select ARCH_HAS_PMEM_API
> +	select ARCH_HAS_PMEM_API		if X86_64
>  	select ARCH_HAS_SG_CHAIN
>  	select ARCH_HAVE_NMI_SAFE_CMPXCHG
>  	select ARCH_MIGHT_HAVE_ACPI_PDC		if ACPI
> diff --git a/arch/x86/include/asm/io.h b/arch/x86/include/asm/io.h
> index d241fbd5c87b..83ec9b1d77cc 100644
> --- a/arch/x86/include/asm/io.h
> +++ b/arch/x86/include/asm/io.h
> @@ -248,8 +248,6 @@ static inline void flush_write_buffers(void)
>  #endif
>  }
>  
> -#define ARCH_MEMREMAP_PMEM MEMREMAP_WB

Should it be better to do:

#else	/* !CONFIG_ARCH_HAS_PMEM_API */
#define ARCH_MEMREMAP_PMEM MEMREMAP_WT

so that you can remove all '#ifdef ARCH_MEMREMAP_PMEM' stuff?

Thanks,
-Toshi
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [standalone]

Back to top | Article view | linux.kernel

csiph-web