Skip to contentSkip to conversation

Fix kernel panic in dma-coherent

PATCH Superseded Brian Starkey 5 participants 16 messages Feb 8, 2016 – Feb 17, 2016 Driver core

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore
#0 lore raw

cover Fix kernel panic in dma-coherent

Hi,

I'm resending these again to try and garner some interest. Without this series, dma-coherent cannot be used on arm64 platforms. The decision to add MEMREMAP_WC came out of a previous discussion with Dan Williams and Catalin Marinas about the same problem[1].

These patches implement a MEMREMAP_WC flag for memremap(), which can be used to obtain writecombine mappings. This is then used for setting up dma_coherent_mem regions which use the DMA_MEMORY_MAP flag. They apply cleanly on 4.5-rc3.

Patch 3 makes sure that the appropriate memset function is used when zeroing coherent allocations, which fixes an alignment fault on arm64.

Best Regards,
Brian

[1] http://lists.infradead.org/pipermail/linux-arm-kernel/2015-December/390857.html

Brian Starkey (3):
memremap: add MEMREMAP_WC flag
drivers: dma-coherent: use MEMREMAP_WC for DMA_MEMORY_MAP
drivers: dma-coherent: use memset_io for DMA_MEMORY_IO

 drivers/base/dma-coherent.c |   25 ++++++++++++++++++++-----
 include/linux/io.h          |    1 +
 kernel/memremap.c           |   15 +++++++++++++--
 3 files changed, 34 insertions(+), 7 deletions(-)
Signature · 1 line
1.7.9.5
#1 lore raw

PATCH 1/3 memremap: add MEMREMAP_WC flag

Add a flag to memremap() for writecombine mappings. Mappings satisfied by this flag will not be cached, however writes may be delayed or combined into more efficient bursts. This is most suitable for buffers written sequentially by the CPU for use by other DMA devices.

---
 include/linux/io.h |    1 +
 kernel/memremap.c  |   15 +++++++++++++--
 2 files changed, 14 insertions(+), 2 deletions(-)
include/linux/io.h +1 -0
index 32403b5..e2c8419 100644
@@ -135,6 +135,7 @@ enum {
 	/* See memremap() kernel-doc for usage description... */
 	MEMREMAP_WB = 1 << 0,
 	MEMREMAP_WT = 1 << 1,
+	MEMREMAP_WC = 1 << 2,
 };
 
 void *memremap(resource_size_t offset, size_t size, unsigned long flags);
kernel/memremap.c +13 -2
index e517a16..3849987 100644
@@ -41,11 +41,13 @@ static void *try_ram_remap(resource_size_t offset, size_t size)
  * memremap() - remap an iomem_resource as cacheable memory
  * @offset: iomem resource start address
  * @size: size of remap
- * @flags: either MEMREMAP_WB or MEMREMAP_WT
+ * @flags: any of MEMREMAP_WB, MEMREMAP_WT and MEMREMAP_WC
  *
  * memremap() is "ioremap" for cases where it is known that the resource
  * being mapped does not have i/o side effects and the __iomem
- * annotation is not applicable.
+ * annotation is not applicable. In the case of multiple flags, the different
+ * mapping types will be attempted in the order listed below until one of
+ * them succeeds.
  *
  * MEMREMAP_WB - matches the default mapping for "System RAM" on
  * the architecture.  This is usually a read-allocate write-back cache.
@@ -57,6 +59,10 @@ static void *try_ram_remap(resource_size_t offset, size_t size)
  * cache or are written through to memory and never exist in a
  * cache-dirty state with respect to program visibility.  Attempts to
  * map "System RAM" with this mapping type will fail.
+ *
+ * MEMREMAP_WC - establish a writecombine mapping, whereby writes may
+ * be coalesced together (e.g. in the CPU's write buffers), but is otherwise
+ * uncached. Attempts to map "System RAM" with this mapping type will fail.
  */
 void *memremap(resource_size_t offset, size_t size, unsigned long flags)
 {
@@ -101,6 +107,11 @@ void *memremap(resource_size_t offset, size_t size, unsigned long flags)
 		addr = ioremap_wt(offset, size);
 	}
 
+	if (!addr && (flags & MEMREMAP_WC)) {
+		flags &= ~MEMREMAP_WC;
+		addr = ioremap_wc(offset, size);
+	}
+
 	return addr;
 }
 EXPORT_SYMBOL(memremap);
Signature · 1 line
1.7.9.5
#2 lore raw

Re: [RESEND2 PATCH 1/3] memremap: add MEMREMAP_WC flag

Quoted 17 lines · Brian Starkey

Add a flag to memremap() for writecombine mappings. Mappings satisfied by this flag will not be cached, however writes may be delayed or combined into more efficient bursts. This is most suitable for buffers written sequentially by the CPU for use by other DMA devices.

---
 include/linux/io.h |    1 +
 kernel/memremap.c  |   15 +++++++++++++--
 2 files changed, 14 insertions(+), 2 deletions(-)
include/linux/io.h +0 -0
index 32403b5..e2c8419 100644

include/linux/io.h enum { · line 138

Quoted 4 lines
include/linux/io.h +1 -0
@@ -135,6 +135,7 @@ enum {
 	/* See memremap() kernel-doc for usage description... */
 	MEMREMAP_WB = 1 << 0,
 	MEMREMAP_WT = 1 << 1,
+	MEMREMAP_WC = 1 << 2,

You didn't update the documentation :(

#3 lore raw

Re: [RESEND2 PATCH 1/3] memremap: add MEMREMAP_WC flag

Hi Greg,

Quoted 13 lines · Greg KH

include/linux/io.h enum { · line 138

Quoted 9 lines · Brian Starkey
include/linux/io.h +1 -0
index 32403b5..e2c8419 100644
@@ -135,6 +135,7 @@ enum {
 	/* See memremap() kernel-doc for usage description... */
 	MEMREMAP_WB = 1 << 0,
 	MEMREMAP_WT = 1 << 1,
+	MEMREMAP_WC = 1 << 2,

You didn't update the documentation :(

Maybe I missed something, but I don't think there's anything to update here? Like the comment says, the flags are documented in the memremap() kernel-doc (which I did update - see the next two hunks of this patch).

Thanks,

Brian

#4 lore raw

Re: [RESEND2 PATCH 1/3] memremap: add MEMREMAP_WC flag

Hi Greg,

Is the documentation OK? Is there any chance of you picking up this series?

I can rebase onto -next if that's the right place, but they still apply on 4.5-rc4 and fix a panic, so I thought perhaps they could make 4.5.

Thanks,
Brian

Quoted 24 lines · Brian Starkey

Hi Greg,

Quoted 13 lines · Greg KH

include/linux/io.h enum { · line 138

Quoted 9 lines · Brian Starkey
include/linux/io.h +1 -0
index 32403b5..e2c8419 100644
@@ -135,6 +135,7 @@ enum {
 	/* See memremap() kernel-doc for usage description... */
 	MEMREMAP_WB = 1 << 0,
 	MEMREMAP_WT = 1 << 1,
+	MEMREMAP_WC = 1 << 2,

You didn't update the documentation :(

Maybe I missed something, but I don't think there's anything to update here? Like the comment says, the flags are documented in the memremap() kernel-doc (which I did update - see the next two hunks of this patch).

Thanks,

Brian

#5 lore raw

Re: [RESEND2 PATCH 1/3] memremap: add MEMREMAP_WC flag

Quoted 7 lines · Brian Starkey

Hi Greg,

Is the documentation OK? Is there any chance of you picking up this series?

I can rebase onto -next if that's the right place, but they still apply on 4.5-rc4 and fix a panic, so I thought perhaps they could make 4.5.

I think memory stuff like this goes through Andrew's tree, not mine...

thanks,

greg k-h

#6 lore raw

Re: [RESEND2 PATCH 1/3] memremap: add MEMREMAP_WC flag

Quoted 10 lines · Greg Kroah-Hartman
Quoted 7 lines · Brian Starkey

Hi Greg,

Is the documentation OK? Is there any chance of you picking up this series?

I can rebase onto -next if that's the right place, but they still apply on 4.5-rc4 and fix a panic, so I thought perhaps they could make 4.5.

I think memory stuff like this goes through Andrew's tree, not mine...

Right, fair enough. I was just blindly working off get_maintainer.pl

Cheers,

Brian

Quoted 5 lines

thanks,

greg k-h

#7 lore raw

Re: [RESEND2 PATCH 1/3] memremap: add MEMREMAP_WC flag

In reply to Brian Starkey
Quoted 6 lines · On Mon, 8 Feb 2016 17:30:50 +0000 Brian Starkey <[email protected]> wrote:

Add a flag to memremap() for writecombine mappings. Mappings satisfied by this flag will not be cached, however writes may be delayed or combined into more efficient bursts. This is most suitable for buffers written sequentially by the CPU for use by other DMA devices.

...

The patch generally looks OK to me. It generates rejects against linux-next because of some janitorial changes in memremap.c.

kernel/memremap.c void *memremap(resource_size_t offset, size_t size, unsigned long flags) · line 116

Quoted 11 lines
kernel/memremap.c +5 -0
@@ -101,6 +107,11 @@ void *memremap(resource_size_t offset, size_t size, unsigned long flags)
 		addr = ioremap_wt(offset, size);
 	}
 
+	if (!addr && (flags & MEMREMAP_WC)) {
+		flags &= ~MEMREMAP_WC;
+		addr = ioremap_wc(offset, size);
+	}
+
 	return addr;
 }

The modifications of `flags' is unneeded (and the compiler will remove it). And generally the modification of incoming args is a bit nasty IMO - I find it's better to treat them as const - part of the calling environment which can be relied upon to be unaltered as the code evolves.

#8 lore raw

Re: [RESEND2 PATCH 1/3] memremap: add MEMREMAP_WC flag

Hi Andrew,

Thanks for taking a look,

Quoted 4 lines · Andrew Morton

On Mon, 8 Feb 2016 17:30:50 +0000 Brian Starkey <[email protected]> wrote:
The patch generally looks OK to me. It generates rejects against linux-next because of some janitorial changes in memremap.c.

Ah yeah, so it does - sorry. I was hoping this could make it into 4.5, but I can rebase onto linux-next if that's better. Annoyingly it only conflicts because of a couple of quotation marks.

Quoted 5 lines
Quoted 5 lines
kernel/memremap.c +0 -0
@@ -101,6 +107,11 @@ void *memremap(resource_size_t offset, size_t size, unsigned long flags)
 		addr = ioremap_wt(offset, size);
 	}
 
Quoted 14 lines

kernel/memremap.c void *memremap(resource_size_t offset, size_t size, unsigned long flags) · line 116

Quoted 7 lines
kernel/memremap.c +5 -0
+	if (!addr && (flags & MEMREMAP_WC)) {
+		flags &= ~MEMREMAP_WC;
+		addr = ioremap_wc(offset, size);
+	}
+
 	return addr;
 }

The modifications of `flags' is unneeded (and the compiler will remove it). And generally the modification of incoming args is a bit nasty IMO - I find it's better to treat them as const - part of the calling environment which can be relied upon to be unaltered as the code evolves.

To be honest I was just mirroring the rest of the function. I guess the idea was filtering the different mapping types in case one of the 'mappers' can handle multiple flags or something. I'll remove it if you like, I just thought that extending the functionality in-keeping with the current semantics was a better evolution - let me know.

Thanks,
Brian

#9 lore raw

Re: [RESEND2 PATCH 1/3] memremap: add MEMREMAP_WC flag

Hi Andrew,

Would you pick these up if I rebase onto linux-next?

How strongly do you feel about the input argument modification vs. staying in-line with the rest of the function?

Thanks,

Brian

Quoted 42 lines · Brian Starkey

Hi Andrew,

Thanks for taking a look,

Quoted 4 lines · Andrew Morton

On Mon, 8 Feb 2016 17:30:50 +0000 Brian Starkey <[email protected]> wrote:
The patch generally looks OK to me. It generates rejects against linux-next because of some janitorial changes in memremap.c.

Ah yeah, so it does - sorry. I was hoping this could make it into 4.5, but I can rebase onto linux-next if that's better. Annoyingly it only conflicts because of a couple of quotation marks.

Quoted 5 lines
Quoted 5 lines
kernel/memremap.c +0 -0
@@ -101,6 +107,11 @@ void *memremap(resource_size_t offset, size_t size, unsigned long flags)
 		addr = ioremap_wt(offset, size);
 	}
 
Quoted 14 lines

kernel/memremap.c void *memremap(resource_size_t offset, size_t size, unsigned long flags) · line 116

Quoted 7 lines
kernel/memremap.c +5 -0
+	if (!addr && (flags & MEMREMAP_WC)) {
+		flags &= ~MEMREMAP_WC;
+		addr = ioremap_wc(offset, size);
+	}
+
 	return addr;
 }

The modifications of `flags' is unneeded (and the compiler will remove it). And generally the modification of incoming args is a bit nasty IMO - I find it's better to treat them as const - part of the calling environment which can be relied upon to be unaltered as the code evolves.

To be honest I was just mirroring the rest of the function. I guess the idea was filtering the different mapping types in case one of the 'mappers' can handle multiple flags or something. I'll remove it if you like, I just thought that extending the functionality in-keeping with the current semantics was a better evolution - let me know.

Thanks,
Brian

#10 lore raw

Re: [RESEND2 PATCH 1/3] memremap: add MEMREMAP_WC flag

Quoted 3 lines · On Wed, 17 Feb 2016 11:53:48 +0000 Brian Starkey <[email protected]> wrote:

Hi Andrew,

Would you pick these up if I rebase onto linux-next?

Sure.

Quoted 2 lines

How strongly do you feel about the input argument modification vs. staying in-line with the rest of the function?

I see no reason why memremap() is modifying `flags' as it proceeds - these flags are all disjoint so it's pointless. I suggest you simply take all that out in a preparatory patch.

#11 lore raw

PATCH 2/3 drivers: dma-coherent: use MEMREMAP_WC for DMA_MEMORY_MAP

In reply to Brian Starkey

When the DMA_MEMORY_MAP flag is used, memory which can be accessed directly should be returned, so use memremap(..., MEMREMAP_WC) to provide a writecombine mapping.

---
 drivers/base/dma-coherent.c |   20 ++++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)
drivers/base/dma-coherent.c +16 -4
index 55b8398..f98359a 100644
@@ -2,6 +2,7 @@
  * Coherent per-device memory handling.
  * Borrowed from i386
  */
+#include <linux/io.h>
 #include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
@@ -31,7 +32,10 @@ static int dma_init_coherent_memory(phys_addr_t phys_addr, dma_addr_t device_add
 	if (!size)
 		goto out;
 
-	mem_base = ioremap(phys_addr, size);
+	if (flags & DMA_MEMORY_MAP)
+		mem_base = memremap(phys_addr, size, MEMREMAP_WC);
+	else
+		mem_base = ioremap(phys_addr, size);
 	if (!mem_base)
 		goto out;
 
@@ -58,8 +62,12 @@ static int dma_init_coherent_memory(phys_addr_t phys_addr, dma_addr_t device_add
 
 out:
 	kfree(dma_mem);
-	if (mem_base)
-		iounmap(mem_base);
+	if (mem_base) {
+		if (flags & DMA_MEMORY_MAP)
+			memunmap(mem_base);
+		else
+			iounmap(mem_base);
+	}
 	return 0;
 }
 
@@ -67,7 +75,11 @@ static void dma_release_coherent_memory(struct dma_coherent_mem *mem)
 {
 	if (!mem)
 		return;
-	iounmap(mem->virt_base);
+
+	if (mem->flags & DMA_MEMORY_MAP)
+		memunmap(mem->virt_base);
+	else
+		iounmap(mem->virt_base);
 	kfree(mem->bitmap);
 	kfree(mem);
 }
Signature · 1 line
1.7.9.5
#12 lore raw

PATCH 3/3 drivers: dma-coherent: use memset_io for DMA_MEMORY_IO mappings

In reply to Brian Starkey

Use memset_io() for DMA_MEMORY_IO mappings which are mapped as I/O memory, and regular memset() for DMA_MEMORY_MAP mappings.

This fixes the below alignment fault on arm64 for DMA_MEMORY_IO mappings, where memset() uses the DC ZVA instruction which is invalid on device memory.

Unhandled fault: alignment fault (0x96000061) at 0xffffff8000380000

   Internal error: : 96000061 [#1] PREEMPT SMP
   Modules linked in: hdlcd(+) clk_scpi
   CPU: 4 PID: 1355 Comm: systemd-udevd Not tainted 4.4.0-rc1+ #5
   Hardware name: ARM Juno development board (r0) (DT)
   task: ffffffc9763eee00 ti: ffffffc9758c4000 task.ti: ffffffc9758c4000
   PC is at __efistub_memset+0x1ac/0x200
   LR is at dma_alloc_from_coherent+0xb0/0x120
   pc : [<ffffffc00030ff2c>] lr : [<ffffffc00042a918>] pstate: 400001c5
   sp : ffffffc9758c79a0
   x29: ffffffc9758c79a0 x28: ffffffc000635cd0
   x27: 0000000000000124 x26: ffffffc000119ef4
   x25: 0000000000010000 x24: 0000000000000140
   x23: ffffffc07e9ac3a8 x22: ffffffc9758c7a58
   x21: ffffffc9758c7a68 x20: 0000000000000004
   x19: ffffffc07e9ac380 x18: 0000000000000001
   x17: 0000007fae1bbba8 x16: ffffffc0001b2d1c
   x15: ffffffffffffffff x14: 0ffffffffffffffe
   x13: 0000000000000010 x12: ffffff800837ffff
   x11: ffffff800837ffff x10: 0000000040000000
   x9 : 0000000000000000 x8 : ffffff8000380000
   x7 : 0000000000000000 x6 : 000000000000003f
   x5 : 0000000000000040 x4 : 0000000000000000
   x3 : 0000000000000004 x2 : 000000000000ffc0
   x1 : 0000000000000000 x0 : ffffff8000380000
---
 drivers/base/dma-coherent.c |    5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
drivers/base/dma-coherent.c +4 -1
index f98359a..4e4ad30 100644
@@ -193,7 +193,10 @@ int dma_alloc_from_coherent(struct device *dev, ssize_t size,
 	 */
 	*dma_handle = mem->device_base + (pageno << PAGE_SHIFT);
 	*ret = mem->virt_base + (pageno << PAGE_SHIFT);
-	memset(*ret, 0, size);
+	if (mem->flags & DMA_MEMORY_MAP)
+		memset(*ret, 0, size);
+	else
+		memset_io(*ret, 0, size);
 	spin_unlock_irqrestore(&mem->spinlock, flags);
 
 	return 1;
Signature · 1 line
1.7.9.5
#13 lore raw
In reply to Brian Starkey
Quoted 4 lines · Brian Starkey

Hi,

I'm resending these again to try and garner some interest. Without this series, dma-coherent cannot be used on arm64 platforms.

I think you need to characterize that a bit better. I see plenty of instances of 'dma-coherent' in dts files, assuming you mean the DT dma-coehrent property.

If not, feel free to stop reading now.

Currently dma-coherent isn't well-defined, but it's de-facto semantics are that a device makes accesses which are coherent with data accesses made by CPUs with Normal, Inner Shareable, Inner Write-Back Cacheable, Outer Write-Back Cacheable attributes.

Quoted 2 lines

The decision to add MEMREMAP_WC came out of a previous discussion with Dan Williams and Catalin Marinas about the same problem[1].

As pgprot_writecombine is Normal Non-Cacheable, this is a completely different idea of coherency to that described by the DT dma-coherent property.

We should not overload that to mean different things.

Thanks,
Mark.

Quoted 33 lines

These patches implement a MEMREMAP_WC flag for memremap(), which can be used to obtain writecombine mappings. This is then used for setting up dma_coherent_mem regions which use the DMA_MEMORY_MAP flag. They apply cleanly on 4.5-rc3.

Patch 3 makes sure that the appropriate memset function is used when zeroing coherent allocations, which fixes an alignment fault on arm64.

Best Regards,
Brian

[1] http://lists.infradead.org/pipermail/linux-arm-kernel/2015-December/390857.html

Brian Starkey (3):
memremap: add MEMREMAP_WC flag
drivers: dma-coherent: use MEMREMAP_WC for DMA_MEMORY_MAP
drivers: dma-coherent: use memset_io for DMA_MEMORY_IO

 drivers/base/dma-coherent.c |   25 ++++++++++++++++++++-----
 include/linux/io.h          |    1 +
 kernel/memremap.c           |   15 +++++++++++++--
 3 files changed, 34 insertions(+), 7 deletions(-)
Signature · 7 lines
1.7.9.5


_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel at lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
#14 lore raw

Hi Mark,

Quoted 11 lines · Mark Rutland
Quoted 4 lines · Brian Starkey

Hi,

I'm resending these again to try and garner some interest. Without this series, dma-coherent cannot be used on arm64 platforms.

I think you need to characterize that a bit better. I see plenty of instances of 'dma-coherent' in dts files, assuming you mean the DT dma-coehrent property.

If not, feel free to stop reading now.

Terminology overload: the dma-coherent DT property is about devices having cache-coherent access to system memory within the linear map. The dma-coherent thing here is pretty much the precise opposite of that - namely creating CPU mappings for memory which belongs to the device itself and may be behind an I/O bus (e.g. a framebuffer on a video card).

Quoted 1 line

Currently dma-coherent isn't well-defined,

True dat.

Robin.

Quoted 56 lines

but it's de-facto semantics
are that a device makes accesses which are coherent with data accesses made by CPUs with Normal, Inner Shareable, Inner Write-Back Cacheable, Outer Write-Back Cacheable attributes.

Quoted 2 lines

The decision to add MEMREMAP_WC came out of a previous discussion with Dan Williams and Catalin Marinas about the same problem[1].

As pgprot_writecombine is Normal Non-Cacheable, this is a completely different idea of coherency to that described by the DT dma-coherent property.

We should not overload that to mean different things.

Thanks,
Mark.

Quoted 24 lines

These patches implement a MEMREMAP_WC flag for memremap(), which can be used to obtain writecombine mappings. This is then used for setting up dma_coherent_mem regions which use the DMA_MEMORY_MAP flag. They apply cleanly on 4.5-rc3.

Patch 3 makes sure that the appropriate memset function is used when zeroing coherent allocations, which fixes an alignment fault on arm64.

Best Regards,
Brian

[1] http://lists.infradead.org/pipermail/linux-arm-kernel/2015-December/390857.html

Brian Starkey (3):
memremap: add MEMREMAP_WC flag
drivers: dma-coherent: use MEMREMAP_WC for DMA_MEMORY_MAP
drivers: dma-coherent: use memset_io for DMA_MEMORY_IO

  drivers/base/dma-coherent.c |   25 ++++++++++++++++++++-----
  include/linux/io.h          |    1 +
  kernel/memremap.c           |   15 +++++++++++++--
  3 files changed, 34 insertions(+), 7 deletions(-)
Quoted 9 lines

--
1.7.9.5

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel at lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel at lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel

#15 lore raw
Quoted 13 lines · Robin Murphy

Hi Mark,

Quoted 10 lines · Mark Rutland
Quoted 4 lines · Brian Starkey

Hi,

I'm resending these again to try and garner some interest. Without this series, dma-coherent cannot be used on arm64 platforms.

I think you need to characterize that a bit better. I see plenty of instances of 'dma-coherent' in dts files, assuming you mean the DT dma-coehrent property.

Quoted 8 lines
Quoted 1 line

If not, feel free to stop reading now.

Terminology overload: the dma-coherent DT property is about devices having cache-coherent access to system memory within the linear map. The dma-coherent thing here is pretty much the precise opposite of that - namely creating CPU mappings for memory which belongs to the device itself and may be behind an I/O bus (e.g. a framebuffer on a video card).

Phew.

Sorry for the noise, and thanks for setting me straight!

Mark.