[openwrt/staging/ldir.git] /

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)) {