target/linux/layerscape/patches-5.4/701-net-0022-sdk_dpaa-ls1043a-errata-realign-and-linearize-egress.patch

From 9821d27a36704d19c57d4b6c52585b9868703633 Mon Sep 17 00:00:00 2001
From: Camelia Groza <camelia.groza@nxp.com>
Date: Mon, 4 Sep 2017 13:41:17 +0300
Subject: [PATCH] sdk_dpaa: ls1043a errata: realign and linearize egress skbs

Allocate a new page and copy the skb's contents to it in order to
guarantee that 4k boundary crossings do not occur.

Signed-off-by: Camelia Groza <camelia.groza@nxp.com>
---
 .../net/ethernet/freescale/sdk_dpaa/dpaa_eth_sg.c  | 159 +++++++++++----------
 1 file changed, 84 insertions(+), 75 deletions(-)

--- a/drivers/net/ethernet/freescale/sdk_dpaa/dpaa_eth_sg.c
+++ b/drivers/net/ethernet/freescale/sdk_dpaa/dpaa_eth_sg.c
@@ -742,86 +742,94 @@ int __hot skb_to_contig_fd(struct dpa_pr
 EXPORT_SYMBOL(skb_to_contig_fd);
 
 #ifndef CONFIG_PPC
-struct sk_buff *split_skb_at_4k_boundaries(struct sk_buff *skb)
+/* Verify the conditions that trigger the A010022 errata: 4K memory address
+ * crossings.
+ */
+bool a010022_check_skb(struct sk_buff *skb)
 {
-	unsigned int length, nr_frags, moved_len = 0;
-	u64 page_start;
-	struct page *page;
+	int nr_frags, i = 0;
 	skb_frag_t *frag;
-	int i = 0, j = 0;
 
-	/* make sure skb is not shared */
-	skb = skb_share_check(skb, GFP_ATOMIC);
-	if (!skb)
-		return NULL;
+	/* Check if the headroom crosses a boundary */
+	if (HAS_DMA_ISSUE(skb->head, skb_headroom(skb)))
+		return true;
+
+	/* Check if the non-paged data crosses a boundary */
+	if (HAS_DMA_ISSUE(skb->data, skb_headlen(skb)))
+		return true;
+
+	/* Check if the entire linear skb crosses a boundary */
+	if (HAS_DMA_ISSUE(skb->head, skb_end_offset(skb)))
+		return true;
 
 	nr_frags = skb_shinfo(skb)->nr_frags;
-	page_start = (u64)skb->data;
 
-	/* split the linear part at the first 4k boundary and create one (big)
-	 * fragment with the rest
-	 */
-	if (HAS_DMA_ISSUE(skb->data, skb_headlen(skb))) {
-		/* we'll add one more frag, make sure there's room */
-		if (nr_frags + 1 > DPA_SGT_MAX_ENTRIES)
-			return NULL;
-
-		/* next page boundary */
-		page_start = (page_start + 0x1000) & ~0xFFF;
-		page = virt_to_page(page_start);
-
-		/* move the rest of fragments to make room for a new one at j */
-		for (i = nr_frags - 1; i >= j;  i--)
-			skb_shinfo(skb)->frags[i + 1] = skb_shinfo(skb)->frags[i];
-
-		/* move length bytes to a paged fragment at j */
-		length = min((u64)0x1000,
-			     (u64)skb->data + skb_headlen(skb) - page_start);
-		skb->data_len += length;
-		moved_len += length;
-		skb_fill_page_desc(skb, j++, page, 0, length);
-		get_page(page);
-		skb_shinfo(skb)->nr_frags = ++nr_frags;
+	while (i < nr_frags) {
+		frag = &skb_shinfo(skb)->frags[i];
+
+		/* Check if the paged fragment crosses a boundary from its
+		 * offset to its end.
+		 */
+		if (HAS_DMA_ISSUE(frag->page_offset, frag->size))
+			return true;
+
+		i++;
 	}
-	/* adjust the tail pointer */
-	skb->tail -= moved_len;
-	j = 0;
-
-	/* split any paged fragment that crosses a 4K boundary */
-	while (j < nr_frags) {
-		frag = &skb_shinfo(skb)->frags[j];
-
-		/* if there is a 4K boundary between the fragment's offset and end */
-		if (HAS_DMA_ISSUE(frag->page_offset, frag->size)) {
-			/* we'll add one more frag, make sure there's room */
-			if (nr_frags + 1 > DPA_SGT_MAX_ENTRIES)
-				return NULL;
-
-			/* new page boundary */
-			page_start = (u64)page_address(skb_frag_page(frag)) +
-						  frag->page_offset + 0x1000;
-			page_start = (u64)page_start & ~0xFFF;
-			page = virt_to_page(page_start);
-
-			/* move the rest of fragments to make room for a new one at j+1 */
-			for (i = nr_frags - 1; i > j;  i--)
-				skb_shinfo(skb)->frags[i + 1] =
-						skb_shinfo(skb)->frags[i];
-
-			/* move length bytes to a new paged fragment at j+1 */
-			length = (u64)page_address(skb_frag_page(frag)) +
-				 frag->page_offset + frag->size - page_start;
-			frag->size -= length;
-			skb_fill_page_desc(skb, j + 1, page, 0, length);
-			get_page(page);
-			skb_shinfo(skb)->nr_frags = ++nr_frags;
-		}
 
-		/* move to next frag */
-		j++;
+	return false;
+}
+
+/* Realign the skb by copying its contents at the start of a newly allocated
+ * page. Build a new skb around the new buffer and release the old one.
+ * A performance drop should be expected.
+ */
+struct sk_buff *a010022_realign_skb(struct sk_buff *skb)
+{
+	int headroom = skb_headroom(skb);
+	struct sk_buff *nskb = NULL;
+	struct page *npage;
+	void *npage_addr;
+	int nsize;
+
+	npage = alloc_page(GFP_ATOMIC);
+	if (unlikely(!npage)) {
+		WARN_ONCE(1, "Memory allocation failure\n");
+		return NULL;
+	}
+	npage_addr = page_address(npage);
+
+	/* For the new skb we only need the old one's data (both non-paged and
+	 * paged) and a headroom large enough to fit our private info. We can
+	 * skip the old tailroom.
+	 *
+	 * Make sure the new linearized buffer will not exceed a page's size.
+	 */
+	nsize = headroom + skb->len +
+		SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
+	if (unlikely(nsize > 4096))
+		goto err;
+
+	nskb = build_skb(npage_addr, nsize);
+	if (unlikely(!nskb))
+		goto err;
+
+	/* Code borrowed and adapted from skb_copy() */
+	skb_reserve(nskb, headroom);
+	skb_put(nskb, skb->len);
+	if (skb_copy_bits(skb, 0, nskb->data, skb->len)) {
+		WARN_ONCE(1, "skb parsing failure\n");
+		goto err;
 	}
+	copy_skb_header(nskb, skb);
+
+	dev_kfree_skb(skb);
+	return nskb;
 
-	return skb;
+err:
+	if (nskb)
+		dev_kfree_skb(nskb);
+	put_page(npage);
+	return NULL;
 }
 #endif
 
@@ -1016,9 +1024,9 @@ int __hot dpa_tx_extended(struct sk_buff
 #endif /* CONFIG_FSL_DPAA_TS */
 
 #ifndef CONFIG_PPC
-resplit_4k:
-	if (unlikely(dpaa_errata_a010022)) {
-		skb = split_skb_at_4k_boundaries(skb);
+realign_4k:
+	if (unlikely(dpaa_errata_a010022) && a010022_check_skb(skb)) {
+		skb = a010022_realign_skb(skb);
 		if (!skb)
 			goto skb_to_fd_failed;
 	}
@@ -1064,8 +1072,9 @@ resplit_4k:
 			kfree_skb(skb);
 			skb = nskb;
 #ifndef CONFIG_PPC
-			if (unlikely(dpaa_errata_a010022))
-				goto resplit_4k;
+			if (unlikely(dpaa_errata_a010022) &&
+			    a010022_check_skb(skb))
+				goto realign_4k;
 #endif
 			/* skb_copy() has now linearized the skbuff. */
 		} else if (unlikely(nonlinear)) {