Skip to contentSkip to conversation

net: fs_enet: sync rx dma buffer before reading

PATCH In review Mans Rullgard 3 participants 8 messages May 19, 2022 – May 23, 2022

Subsystems (3)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 net: fs_enet: sync rx dma buffer before reading

The dma_sync_single_for_cpu() call must precede reading the received data. Fix this.

Fixes 070e1f01827c ("net: fs_enet: don't unmap DMA when packet len is below copybreak")
---
 drivers/net/ethernet/freescale/fs_enet/fs_enet-main.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)
drivers/net/ethernet/freescale/fs_enet/fs_enet-main.c +4 -4
index b3dae17e067e..432ce10cbfd0 100644
@@ -240,14 +240,14 @@ static int fs_enet_napi(struct napi_struct *napi, int budget)
 				/* +2 to make IP header L1 cache aligned */
 				skbn = netdev_alloc_skb(dev, pkt_len + 2);
 				if (skbn != NULL) {
+					dma_sync_single_for_cpu(fep->dev,
+						CBDR_BUFADDR(bdp),
+						L1_CACHE_ALIGN(pkt_len),
+						DMA_FROM_DEVICE);
 					skb_reserve(skbn, 2);	/* align IP header */
 					skb_copy_from_linear_data(skb,
 						      skbn->data, pkt_len);
 					swap(skb, skbn);
-					dma_sync_single_for_cpu(fep->dev,
-						CBDR_BUFADDR(bdp),
-						L1_CACHE_ALIGN(pkt_len),
-						DMA_FROM_DEVICE);
 				}
 			} else {
 				skbn = netdev_alloc_skb(dev, ENET_RX_FRSIZE);
Signature · 1 line
2.35.1
#1 lore raw

Le 19/05/2022 à 21:24, Mans Rullgard a écrit :

Quoted 2 lines

The dma_sync_single_for_cpu() call must precede reading the received data. Fix this.

See original commit 070e1f01827c. It explicitely says that the cache must be invalidate _AFTER_ the copy.

The cache is initialy invalidated by dma_map_single(), so before the copy the cache is already clean.

After the copy, data is in the cache. In order to allow re-use of the skb, it must be put back in the same condition as before, in extenso the cache must be invalidated in order to be in the same situation as after dma_map_single().

So I think your change is wrong.

Quoted 33 lines
Fixes 070e1f01827c ("net: fs_enet: don't unmap DMA when packet len is below copybreak")
---
  drivers/net/ethernet/freescale/fs_enet/fs_enet-main.c | 8 ++++----
  1 file changed, 4 insertions(+), 4 deletions(-)
drivers/net/ethernet/freescale/fs_enet/fs_enet-main.c +4 -5
index b3dae17e067e..432ce10cbfd0 100644
@@ -240,14 +240,14 @@ static int fs_enet_napi(struct napi_struct *napi, int budget)
                                 /* +2 to make IP header L1 cache aligned */
                                 skbn = netdev_alloc_skb(dev, pkt_len + 2);
                                 if (skbn != NULL) {
+                                       dma_sync_single_for_cpu(fep->dev,
+                                               CBDR_BUFADDR(bdp),
+                                               L1_CACHE_ALIGN(pkt_len),
+                                               DMA_FROM_DEVICE);
                                         skb_reserve(skbn, 2);   /* align IP header */
                                         skb_copy_from_linear_data(skb,
                                                       skbn->data, pkt_len);
                                         swap(skb, skbn);
-                                       dma_sync_single_for_cpu(fep->dev,
-                                               CBDR_BUFADDR(bdp),
-                                               L1_CACHE_ALIGN(pkt_len),
-                                               DMA_FROM_DEVICE);
                                 }
                         } else {
                                 skbn = netdev_alloc_skb(dev, ENET_RX_FRSIZE);
--

2.35.1

#2 lore raw
Quoted 10 lines · Christophe Leroy

Le 19/05/2022 à 21:24, Mans Rullgard a écrit :

Quoted 2 lines

The dma_sync_single_for_cpu() call must precede reading the received data. Fix this.

See original commit 070e1f01827c. It explicitely says that the cache must be invalidate _AFTER_ the copy.

The cache is initialy invalidated by dma_map_single(), so before the copy the cache is already clean.

Quoted 6 lines

After the copy, data is in the cache. In order to allow re-use of the skb, it must be put back in the same condition as before, in extenso the cache must be invalidated in order to be in the same situation as after dma_map_single().

So I think your change is wrong.

OK, looking at it more closely, the change is at least unnecessary since there will be a cache invalidation between each use of the buffer either way. Please disregard the patch. Sorry for the noise.

Quoted 33 lines
Quoted 33 lines
Fixes 070e1f01827c ("net: fs_enet: don't unmap DMA when packet len is below copybreak")
---
  drivers/net/ethernet/freescale/fs_enet/fs_enet-main.c | 8 ++++----
  1 file changed, 4 insertions(+), 4 deletions(-)
drivers/net/ethernet/freescale/fs_enet/fs_enet-main.c +4 -5
index b3dae17e067e..432ce10cbfd0 100644
@@ -240,14 +240,14 @@ static int fs_enet_napi(struct napi_struct *napi, int budget)
                                 /* +2 to make IP header L1 cache aligned */
                                 skbn = netdev_alloc_skb(dev, pkt_len + 2);
                                 if (skbn != NULL) {
+                                       dma_sync_single_for_cpu(fep->dev,
+                                               CBDR_BUFADDR(bdp),
+                                               L1_CACHE_ALIGN(pkt_len),
+                                               DMA_FROM_DEVICE);
                                         skb_reserve(skbn, 2);   /* align IP header */
                                         skb_copy_from_linear_data(skb,
                                                       skbn->data, pkt_len);
                                         swap(skb, skbn);
-                                       dma_sync_single_for_cpu(fep->dev,
-                                               CBDR_BUFADDR(bdp),
-                                               L1_CACHE_ALIGN(pkt_len),
-                                               DMA_FROM_DEVICE);
                                 }
                         } else {
                                 skbn = netdev_alloc_skb(dev, ENET_RX_FRSIZE);
--

2.35.1

Signature · 1 line
Måns Rullgård
#3 lore raw

Le 20/05/2022 à 14:35, Måns Rullgård a écrit :

Quoted 17 lines
Quoted 15 lines · Christophe Leroy

Le 19/05/2022 à 21:24, Mans Rullgard a écrit :

Quoted 2 lines

The dma_sync_single_for_cpu() call must precede reading the received data. Fix this.

See original commit 070e1f01827c. It explicitely says that the cache must be invalidate _AFTER_ the copy.

The cache is initialy invalidated by dma_map_single(), so before the copy the cache is already clean.

After the copy, data is in the cache. In order to allow re-use of the skb, it must be put back in the same condition as before, in extenso the cache must be invalidated in order to be in the same situation as after dma_map_single().

Quoted 6 lines
Quoted 1 line

So I think your change is wrong.

OK, looking at it more closely, the change is at least unnecessary since there will be a cache invalidation between each use of the buffer either way. Please disregard the patch. Sorry for the noise.

I also looked deeper.

Indeed it was implemented in kernel 4.9 or 4.8. At that time dma_unmap_single() was a no-op, it was not doing any sync/invalidation at all, invalidation was done only at mapping, so when we were reusing the skb it was necessary to clean the cache _AFTER_ the copy as if it was a new mapping.

Today a sync is done at both map and unmap, so it doesn't really matter whether we do the invalidation before or after the copy when we re-use the skb.

Christophe

maintainer
#4 lore raw
Quoted 28 lines · On Fri, 20 May 2022 12:54:56 +0000 Christophe Leroy wrote:

Le 20/05/2022 à 14:35, Måns Rullgård a écrit :

Quoted 12 lines
Quoted 11 lines · Christophe Leroy

See original commit 070e1f01827c. It explicitely says that the cache must be invalidate _AFTER_ the copy.

The cache is initialy invalidated by dma_map_single(), so before the copy the cache is already clean.

After the copy, data is in the cache. In order to allow re-use of the skb, it must be put back in the same condition as before, in extenso the cache must be invalidated in order to be in the same situation as after dma_map_single().

Quoted 6 lines
Quoted 1 line

So I think your change is wrong.

OK, looking at it more closely, the change is at least unnecessary since there will be a cache invalidation between each use of the buffer either way. Please disregard the patch. Sorry for the noise.

I also looked deeper.

Indeed it was implemented in kernel 4.9 or 4.8. At that time dma_unmap_single() was a no-op, it was not doing any sync/invalidation at all, invalidation was done only at mapping, so when we were reusing the skb it was necessary to clean the cache _AFTER_ the copy as if it was a new mapping.

Quoted 3 lines

Today a sync is done at both map and unmap, so it doesn't really matter whether we do the invalidation before or after the copy when we re-use the skb.

Hm, I think the patch is necessary, sorry if you're also saying that and I'm misinterpreting.

Without the dma_sync_single_for_cpu() if swiotlb is used the data will not be copied back into the original buffer if there is no sync.

#5 lore raw

Le 20/05/2022 à 19:43, Jakub Kicinski a écrit :

Quoted 29 lines · On Fri, 20 May 2022 12:54:56 +0000 Christophe Leroy wrote:
Quoted 28 lines

Le 20/05/2022 à 14:35, Måns Rullgård a écrit :

Quoted 12 lines
Quoted 11 lines · Christophe Leroy

See original commit 070e1f01827c. It explicitely says that the cache must be invalidate _AFTER_ the copy.

The cache is initialy invalidated by dma_map_single(), so before the copy the cache is already clean.

After the copy, data is in the cache. In order to allow re-use of the skb, it must be put back in the same condition as before, in extenso the cache must be invalidated in order to be in the same situation as after dma_map_single().

Quoted 6 lines
Quoted 1 line

So I think your change is wrong.

OK, looking at it more closely, the change is at least unnecessary since there will be a cache invalidation between each use of the buffer either way. Please disregard the patch. Sorry for the noise.

I also looked deeper.

Indeed it was implemented in kernel 4.9 or 4.8. At that time dma_unmap_single() was a no-op, it was not doing any sync/invalidation at all, invalidation was done only at mapping, so when we were reusing the skb it was necessary to clean the cache _AFTER_ the copy as if it was a new mapping.

Quoted 6 lines
Quoted 3 lines

Today a sync is done at both map and unmap, so it doesn't really matter whether we do the invalidation before or after the copy when we re-use the skb.

Hm, I think the patch is necessary, sorry if you're also saying that and I'm misinterpreting.

Well, I say the contrary.

On the mainline the patch may be applied as is, it won't harm.

However, it is gets applied to kernel 4.9 (based on the fixes: tag), it will break the driver for at least powerpc 8xx.

In 4.9, dma_direct_map_page() invalidates the cache, but dma_direct_unmap_page() is a no-op. It means that when we re-use a skb as we do in fs_enet when the received packet is small, the cache must be invalidated _AFTER_ reading the received data.

The driver works like this:

allocate an SKB with the largest possible packet size dma_direct_map_page() ==> cache invalidation
loop forever
wait for some received data in DMA
if (received packet is small)
allocate a new SKB with the size of the received packet copy received data into the new SKB
hand new SKB to network layer
invalidate the cache
else
dma_direct_unmap_page() ==> no-op
hand SKB to network layer
allocate a new SKB with the largest possible packet size dma_direct_map_page() ==> cache invalidation
endif
endloop

If you don't invalidate the cache _AFTER_ the copy, you have stale data in the cache when you later hand a non-small received packet to the network stack.

Invalidating _BEFORE_ the copy is useless as it has already been invalidated at mapping time.

In mainline, the DMA handling has been make generic, and cache invalidation is performed at both mapping at unmapping (Which is by the way sub-optimal) so by change it would still work after the patch.

Quoted 3 lines

Without the dma_sync_single_for_cpu() if swiotlb is used the data will not be copied back into the original buffer if there is no sync.

I don't know how SWIOTLB works or even what it is, does any of the microcontrollers embedding freescale ethernet uses that at all ?

Christophe

maintainer
#6 lore raw
Quoted 9 lines · On Sat, 21 May 2022 06:44:41 +0000 Christophe Leroy wrote:
Quoted 2 lines

Hm, I think the patch is necessary, sorry if you're also saying that and I'm misinterpreting.

Well, I say the contrary.

On the mainline the patch may be applied as is, it won't harm.

However, it is gets applied to kernel 4.9 (based on the fixes: tag), it will break the driver for at least powerpc 8xx.

I see, we should make a note of that in the commit message so it doesn't get sucked into stable.

Quoted 5 lines
Quoted 2 lines

Without the dma_sync_single_for_cpu() if swiotlb is used the data will not be copied back into the original buffer if there is no sync.

I don't know how SWIOTLB works or even what it is, does any of the microcontrollers embedding freescale ethernet uses that at all ?

AFAIU SWIOTLB basically forces the use of bounce buffers even if the device can reach the entire DRAM. I think some people also use it for added security? IDK. I mostly use it to check if I'm using the DMA API "right" :)

maintainer
#7 lore raw
Quoted 10 lines · On Sat, 21 May 2022 10:44:30 -0700 Jakub Kicinski wrote:
Quoted 6 lines

Well, I say the contrary.

On the mainline the patch may be applied as is, it won't harm.

However, it is gets applied to kernel 4.9 (based on the fixes: tag), it will break the driver for at least powerpc 8xx.

I see, we should make a note of that in the commit message so it doesn't get sucked into stable.

Quoted 7 lines
Quoted 2 lines

I don't know how SWIOTLB works or even what it is, does any of the microcontrollers embedding freescale ethernet uses that at all ?

AFAIU SWIOTLB basically forces the use of bounce buffers even if the device can reach the entire DRAM. I think some people also use it for added security? IDK. I mostly use it to check if I'm using the DMA API "right" :)

If what I said makes sense please repost the patch, the current version has been dropped from patchwork already.