Merge branch 'bpf-veth-xdp-support'

Toshiaki Makita says:

====================
This patch set introduces driver XDP for veth.
Basically this is used in conjunction with redirect action of another XDP
program.

  NIC -----------> veth===veth
 (XDP) (redirect)        (XDP)

In this case xdp_frame can be forwarded to the peer veth without
modification, so we can expect far better performance than generic XDP.

Envisioned use-cases
--------------------

* Container managed XDP program
Container host redirects frames to containers by XDP redirect action, and
privileged containers can deploy their own XDP programs.

* XDP program cascading
Two or more XDP programs can be called for each packet by redirecting
xdp frames to veth.

* Internal interface for an XDP bridge
When using XDP redirection to create a virtual bridge, veth can be used
to create an internal interface for the bridge.

Implementation
--------------

This changeset is making use of NAPI to implement ndo_xdp_xmit and
XDP_TX/REDIRECT. This is mainly because XDP heavily relies on NAPI
context.
 - patch 1: Export a function needed for veth XDP.
 - patch 2-3: Basic implementation of veth XDP.
 - patch 4-6: Add ndo_xdp_xmit.
 - patch 7-9: Add XDP_TX and XDP_REDIRECT.
 - patch 10: Performance optimization for multi-queue env.

Tests and performance numbers
-----------------------------

Tested with a simple XDP program which only redirects packets between
NIC and veth. I used i40e 25G NIC (XXV710) for the physical NIC. The
server has 20 of Xeon Silver 2.20 GHz cores.

  pktgen --(wire)--> XXV710 (i40e) <--(XDP redirect)--> veth===veth (XDP)

The rightmost veth loads XDP progs and just does DROP or TX. The number
of packets is measured in the XDP progs. The leftmost pktgen sends
packets at 37.1 Mpps (almost 25G wire speed).

veth XDP action    Flows    Mpps
================================
DROP                   1    10.6
DROP                   2    21.2
DROP                 100    36.0
TX                     1     5.0
TX                     2    10.0
TX                   100    31.0

I also measured netperf TCP_STREAM but was not so great performance due
to lack of tx/rx checksum offload and TSO, etc.

  netperf <--(wire)--> XXV710 (i40e) <--(XDP redirect)--> veth===veth (XDP PASS)

Direction         Flows   Gbps
==============================
external->veth        1   20.8
external->veth        2   23.5
external->veth      100   23.6
veth->external        1    9.0
veth->external        2   17.8
veth->external      100   22.9

Also tested doing ifup/down or load/unload a XDP program repeatedly
during processing XDP packets in order to check if enabling/disabling
NAPI is working as expected, and found no problems.

v8:
- Don't use xdp_frame pointer address to calculate skb->head, headroom,
  and xdp_buff.data_hard_start.

v7:
- Introduce xdp_scrub_frame() to clear kernel pointers in xdp_frame and
  use it instead of memset().

v6:
- Check skb->len only if reallocation is needed.
- Add __GFP_NOWARN to alloc_page() since it can be triggered by external
  events.
- Fix sparse warning around EXPORT_SYMBOL.

v5:
- Fix broken SOBs.

v4:
- Don't adjust MTU automatically.
- Skip peer IFF_UP check on .ndo_xdp_xmit() because it is unnecessary.
  Add comments to explain that.
- Use redirect_info instead of xdp_mem_info for storing no_direct flag
  to avoid per packet copy cost.

v3:
- Drop skb bulk xmit patch since it makes little performance
  difference. The hotspot in TCP skb xmit at this point is checksum
  computation in skb_segment and packet copy on XDP_REDIRECT due to
  cloned/nonlinear skb.
- Fix race on closing device.
- Add extack messages in ndo_bpf.

v2:
- Squash NAPI patch with "Add driver XDP" patch.
- Remove conversion from xdp_frame to skb when NAPI is not enabled.
- Introduce per-queue XDP ring (patch 8).
- Introduce bulk skb xmit when XDP is enabled on the peer (patch 9).
====================

Signed-off-by: Toshiaki Makita <makita.toshiaki@lab.ntt.co.jp>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>

7 files changed, 801 insertions, 30 deletions

diff --git a/drivers/net/veth.c b/drivers/net/veth.c
index a69ad39ee57e..e3202af72df5 100644
--- a/drivers/net/veth.c
+++ b/drivers/net/veth.c
@@ -17,22 +17,47 @@
 #include <net/rtnetlink.h>
 #include <net/dst.h>
 #include <net/xfrm.h>
+#include <net/xdp.h>
 #include <linux/veth.h>
 #include <linux/module.h>
+#include <linux/bpf.h>
+#include <linux/filter.h>
+#include <linux/ptr_ring.h>
+#include <linux/bpf_trace.h>
 
 #define DRV_NAME        "veth"
 #define DRV_VERSION     "1.0"
 
+#define VETH_XDP_FLAG           BIT(0)
+#define VETH_RING_SIZE          256
+#define VETH_XDP_HEADROOM       (XDP_PACKET_HEADROOM + NET_IP_ALIGN)
+
+/* Separating two types of XDP xmit */
+#define VETH_XDP_TX             BIT(0)
+#define VETH_XDP_REDIR          BIT(1)
+
 struct pcpu_vstats {
         u64                     packets;
         u64                     bytes;
         struct u64_stats_sync   syncp;
 };
 
+struct veth_rq {
+        struct napi_struct      xdp_napi;
+        struct net_device       *dev;
+        struct bpf_prog __rcu   *xdp_prog;
+        struct xdp_mem_info     xdp_mem;
+        bool                    rx_notify_masked;
+        struct ptr_ring         xdp_ring;
+        struct xdp_rxq_info     xdp_rxq;
+};
+
 struct veth_priv {
         struct net_device __rcu *peer;
         atomic64_t              dropped;
-        unsigned                requested_headroom;
+        struct bpf_prog         *_xdp_prog;
+        struct veth_rq          *rq;
+        unsigned int            requested_headroom;
 };
 
 /*
@@ -98,11 +123,67 @@ static const struct ethtool_ops veth_ethtool_ops = {
         .get_link_ksettings     = veth_get_link_ksettings,
 };
 
+/* general routines */
+
+static bool veth_is_xdp_frame(void *ptr)
+{
+        return (unsigned long)ptr & VETH_XDP_FLAG;
+}
+
+static void *veth_ptr_to_xdp(void *ptr)
+{
+        return (void *)((unsigned long)ptr & ~VETH_XDP_FLAG);
+}
+
+static void *veth_xdp_to_ptr(void *ptr)
+{
+        return (void *)((unsigned long)ptr | VETH_XDP_FLAG);
+}
+
+static void veth_ptr_free(void *ptr)
+{
+        if (veth_is_xdp_frame(ptr))
+                xdp_return_frame(veth_ptr_to_xdp(ptr));
+        else
+                kfree_skb(ptr);
+}
+
+static void __veth_xdp_flush(struct veth_rq *rq)
+{
+        /* Write ptr_ring before reading rx_notify_masked */
+        smp_mb();
+        if (!rq->rx_notify_masked) {
+                rq->rx_notify_masked = true;
+                napi_schedule(&rq->xdp_napi);
+        }
+}
+
+static int veth_xdp_rx(struct veth_rq *rq, struct sk_buff *skb)
+{
+        if (unlikely(ptr_ring_produce(&rq->xdp_ring, skb))) {
+                dev_kfree_skb_any(skb);
+                return NET_RX_DROP;
+        }
+
+        return NET_RX_SUCCESS;
+}
+
+static int veth_forward_skb(struct net_device *dev, struct sk_buff *skb,
+                            struct veth_rq *rq, bool xdp)
+{
+        return __dev_forward_skb(dev, skb) ?: xdp ?
+                veth_xdp_rx(rq, skb) :
+                netif_rx(skb);
+}
+
 static netdev_tx_t veth_xmit(struct sk_buff *skb, struct net_device *dev)
 {
-        struct veth_priv *priv = netdev_priv(dev);
+        struct veth_priv *rcv_priv, *priv = netdev_priv(dev);
+        struct veth_rq *rq = NULL;
         struct net_device *rcv;
         int length = skb->len;
+        bool rcv_xdp = false;
+        int rxq;
 
         rcu_read_lock();
         rcv = rcu_dereference(priv->peer);
@@ -111,7 +192,16 @@ static netdev_tx_t veth_xmit(struct sk_buff *skb, struct net_device *dev)
                 goto drop;
         }
 
-        if (likely(dev_forward_skb(rcv, skb) == NET_RX_SUCCESS)) {
+        rcv_priv = netdev_priv(rcv);
+        rxq = skb_get_queue_mapping(skb);
+        if (rxq < rcv->real_num_rx_queues) {
+                rq = &rcv_priv->rq[rxq];
+                rcv_xdp = rcu_access_pointer(rq->xdp_prog);
+                if (rcv_xdp)
+                        skb_record_rx_queue(skb, rxq);
+        }
+
+        if (likely(veth_forward_skb(rcv, skb, rq, rcv_xdp) == NET_RX_SUCCESS)) {
                 struct pcpu_vstats *stats = this_cpu_ptr(dev->vstats);
 
                 u64_stats_update_begin(&stats->syncp);
@@ -122,14 +212,15 @@ static netdev_tx_t veth_xmit(struct sk_buff *skb, struct net_device *dev)
 drop:
                 atomic64_inc(&priv->dropped);
         }
+
+        if (rcv_xdp)
+                __veth_xdp_flush(rq);
+
         rcu_read_unlock();
+
         return NETDEV_TX_OK;
 }
 
-/*
- * general routines
- */
-
 static u64 veth_stats_one(struct pcpu_vstats *result, struct net_device *dev)
 {
         struct veth_priv *priv = netdev_priv(dev);
@@ -179,18 +270,502 @@ static void veth_set_multicast_list(struct net_device *dev)
 {
 }
 
+static struct sk_buff *veth_build_skb(void *head, int headroom, int len,
+                                      int buflen)
+{
+        struct sk_buff *skb;
+
+        if (!buflen) {
+                buflen = SKB_DATA_ALIGN(headroom + len) +
+                         SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
+        }
+        skb = build_skb(head, buflen);
+        if (!skb)
+                return NULL;
+
+        skb_reserve(skb, headroom);
+        skb_put(skb, len);
+
+        return skb;
+}
+
+static int veth_select_rxq(struct net_device *dev)
+{
+        return smp_processor_id() % dev->real_num_rx_queues;
+}
+
+static int veth_xdp_xmit(struct net_device *dev, int n,
+                         struct xdp_frame **frames, u32 flags)
+{
+        struct veth_priv *rcv_priv, *priv = netdev_priv(dev);
+        struct net_device *rcv;
+        unsigned int max_len;
+        struct veth_rq *rq;
+        int i, drops = 0;
+
+        if (unlikely(flags & ~XDP_XMIT_FLAGS_MASK))
+                return -EINVAL;
+
+        rcv = rcu_dereference(priv->peer);
+        if (unlikely(!rcv))
+                return -ENXIO;
+
+        rcv_priv = netdev_priv(rcv);
+        rq = &rcv_priv->rq[veth_select_rxq(rcv)];
+        /* Non-NULL xdp_prog ensures that xdp_ring is initialized on receive
+         * side. This means an XDP program is loaded on the peer and the peer
+         * device is up.
+         */
+        if (!rcu_access_pointer(rq->xdp_prog))
+                return -ENXIO;
+
+        max_len = rcv->mtu + rcv->hard_header_len + VLAN_HLEN;
+
+        spin_lock(&rq->xdp_ring.producer_lock);
+        for (i = 0; i < n; i++) {
+                struct xdp_frame *frame = frames[i];
+                void *ptr = veth_xdp_to_ptr(frame);
+
+                if (unlikely(frame->len > max_len ||
+                             __ptr_ring_produce(&rq->xdp_ring, ptr))) {
+                        xdp_return_frame_rx_napi(frame);
+                        drops++;
+                }
+        }
+        spin_unlock(&rq->xdp_ring.producer_lock);
+
+        if (flags & XDP_XMIT_FLUSH)
+                __veth_xdp_flush(rq);
+
+        return n - drops;
+}
+
+static void veth_xdp_flush(struct net_device *dev)
+{
+        struct veth_priv *rcv_priv, *priv = netdev_priv(dev);
+        struct net_device *rcv;
+        struct veth_rq *rq;
+
+        rcu_read_lock();
+        rcv = rcu_dereference(priv->peer);
+        if (unlikely(!rcv))
+                goto out;
+
+        rcv_priv = netdev_priv(rcv);
+        rq = &rcv_priv->rq[veth_select_rxq(rcv)];
+        /* xdp_ring is initialized on receive side? */
+        if (unlikely(!rcu_access_pointer(rq->xdp_prog)))
+                goto out;
+
+        __veth_xdp_flush(rq);
+out:
+        rcu_read_unlock();
+}
+
+static int veth_xdp_tx(struct net_device *dev, struct xdp_buff *xdp)
+{
+        struct xdp_frame *frame = convert_to_xdp_frame(xdp);
+
+        if (unlikely(!frame))
+                return -EOVERFLOW;
+
+        return veth_xdp_xmit(dev, 1, &frame, 0);
+}
+
+static struct sk_buff *veth_xdp_rcv_one(struct veth_rq *rq,
+                                        struct xdp_frame *frame,
+                                        unsigned int *xdp_xmit)
+{
+        void *hard_start = frame->data - frame->headroom;
+        void *head = hard_start - sizeof(struct xdp_frame);
+        int len = frame->len, delta = 0;
+        struct xdp_frame orig_frame;
+        struct bpf_prog *xdp_prog;
+        unsigned int headroom;
+        struct sk_buff *skb;
+
+        rcu_read_lock();
+        xdp_prog = rcu_dereference(rq->xdp_prog);
+        if (likely(xdp_prog)) {
+                struct xdp_buff xdp;
+                u32 act;
+
+                xdp.data_hard_start = hard_start;
+                xdp.data = frame->data;
+                xdp.data_end = frame->data + frame->len;
+                xdp.data_meta = frame->data - frame->metasize;
+                xdp.rxq = &rq->xdp_rxq;
+
+                act = bpf_prog_run_xdp(xdp_prog, &xdp);
+
+                switch (act) {
+                case XDP_PASS:
+                        delta = frame->data - xdp.data;
+                        len = xdp.data_end - xdp.data;
+                        break;
+                case XDP_TX:
+                        orig_frame = *frame;
+                        xdp.data_hard_start = head;
+                        xdp.rxq->mem = frame->mem;
+                        if (unlikely(veth_xdp_tx(rq->dev, &xdp) < 0)) {
+                                trace_xdp_exception(rq->dev, xdp_prog, act);
+                                frame = &orig_frame;
+                                goto err_xdp;
+                        }
+                        *xdp_xmit |= VETH_XDP_TX;
+                        rcu_read_unlock();
+                        goto xdp_xmit;
+                case XDP_REDIRECT:
+                        orig_frame = *frame;
+                        xdp.data_hard_start = head;
+                        xdp.rxq->mem = frame->mem;
+                        if (xdp_do_redirect(rq->dev, &xdp, xdp_prog)) {
+                                frame = &orig_frame;
+                                goto err_xdp;
+                        }
+                        *xdp_xmit |= VETH_XDP_REDIR;
+                        rcu_read_unlock();
+                        goto xdp_xmit;
+                default:
+                        bpf_warn_invalid_xdp_action(act);
+                case XDP_ABORTED:
+                        trace_xdp_exception(rq->dev, xdp_prog, act);
+                case XDP_DROP:
+                        goto err_xdp;
+                }
+        }
+        rcu_read_unlock();
+
+        headroom = sizeof(struct xdp_frame) + frame->headroom - delta;
+        skb = veth_build_skb(head, headroom, len, 0);
+        if (!skb) {
+                xdp_return_frame(frame);
+                goto err;
+        }
+
+        xdp_scrub_frame(frame);
+        skb->protocol = eth_type_trans(skb, rq->dev);
+err:
+        return skb;
+err_xdp:
+        rcu_read_unlock();
+        xdp_return_frame(frame);
+xdp_xmit:
+        return NULL;
+}
+
+static struct sk_buff *veth_xdp_rcv_skb(struct veth_rq *rq, struct sk_buff *skb,
+                                        unsigned int *xdp_xmit)
+{
+        u32 pktlen, headroom, act, metalen;
+        void *orig_data, *orig_data_end;
+        struct bpf_prog *xdp_prog;
+        int mac_len, delta, off;
+        struct xdp_buff xdp;
+
+        rcu_read_lock();
+        xdp_prog = rcu_dereference(rq->xdp_prog);
+        if (unlikely(!xdp_prog)) {
+                rcu_read_unlock();
+                goto out;
+        }
+
+        mac_len = skb->data - skb_mac_header(skb);
+        pktlen = skb->len + mac_len;
+        headroom = skb_headroom(skb) - mac_len;
+
+        if (skb_shared(skb) || skb_head_is_locked(skb) ||
+            skb_is_nonlinear(skb) || headroom < XDP_PACKET_HEADROOM) {
+                struct sk_buff *nskb;
+                int size, head_off;
+                void *head, *start;
+                struct page *page;
+
+                size = SKB_DATA_ALIGN(VETH_XDP_HEADROOM + pktlen) +
+                       SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
+                if (size > PAGE_SIZE)
+                        goto drop;
+
+                page = alloc_page(GFP_ATOMIC | __GFP_NOWARN);
+                if (!page)
+                        goto drop;
+
+                head = page_address(page);
+                start = head + VETH_XDP_HEADROOM;
+                if (skb_copy_bits(skb, -mac_len, start, pktlen)) {
+                        page_frag_free(head);
+                        goto drop;
+                }
+
+                nskb = veth_build_skb(head,
+                                      VETH_XDP_HEADROOM + mac_len, skb->len,
+                                      PAGE_SIZE);
+                if (!nskb) {
+                        page_frag_free(head);
+                        goto drop;
+                }
+
+                skb_copy_header(nskb, skb);
+                head_off = skb_headroom(nskb) - skb_headroom(skb);
+                skb_headers_offset_update(nskb, head_off);
+                if (skb->sk)
+                        skb_set_owner_w(nskb, skb->sk);
+                consume_skb(skb);
+                skb = nskb;
+        }
+
+        xdp.data_hard_start = skb->head;
+        xdp.data = skb_mac_header(skb);
+        xdp.data_end = xdp.data + pktlen;
+        xdp.data_meta = xdp.data;
+        xdp.rxq = &rq->xdp_rxq;
+        orig_data = xdp.data;
+        orig_data_end = xdp.data_end;
+
+        act = bpf_prog_run_xdp(xdp_prog, &xdp);
+
+        switch (act) {
+        case XDP_PASS:
+                break;
+        case XDP_TX:
+                get_page(virt_to_page(xdp.data));
+                consume_skb(skb);
+                xdp.rxq->mem = rq->xdp_mem;
+                if (unlikely(veth_xdp_tx(rq->dev, &xdp) < 0)) {
+                        trace_xdp_exception(rq->dev, xdp_prog, act);
+                        goto err_xdp;
+                }
+                *xdp_xmit |= VETH_XDP_TX;
+                rcu_read_unlock();
+                goto xdp_xmit;
+        case XDP_REDIRECT:
+                get_page(virt_to_page(xdp.data));
+                consume_skb(skb);
+                xdp.rxq->mem = rq->xdp_mem;
+                if (xdp_do_redirect(rq->dev, &xdp, xdp_prog))
+                        goto err_xdp;
+                *xdp_xmit |= VETH_XDP_REDIR;
+                rcu_read_unlock();
+                goto xdp_xmit;
+        default:
+                bpf_warn_invalid_xdp_action(act);
+        case XDP_ABORTED:
+                trace_xdp_exception(rq->dev, xdp_prog, act);
+        case XDP_DROP:
+                goto drop;
+        }
+        rcu_read_unlock();
+
+        delta = orig_data - xdp.data;
+        off = mac_len + delta;
+        if (off > 0)
+                __skb_push(skb, off);
+        else if (off < 0)
+                __skb_pull(skb, -off);
+        skb->mac_header -= delta;
+        off = xdp.data_end - orig_data_end;
+        if (off != 0)
+                __skb_put(skb, off);
+        skb->protocol = eth_type_trans(skb, rq->dev);
+
+        metalen = xdp.data - xdp.data_meta;
+        if (metalen)
+                skb_metadata_set(skb, metalen);
+out:
+        return skb;
+drop:
+        rcu_read_unlock();
+        kfree_skb(skb);
+        return NULL;
+err_xdp:
+        rcu_read_unlock();
+        page_frag_free(xdp.data);
+xdp_xmit:
+        return NULL;
+}
+
+static int veth_xdp_rcv(struct veth_rq *rq, int budget, unsigned int *xdp_xmit)
+{
+        int i, done = 0;
+
+        for (i = 0; i < budget; i++) {
+                void *ptr = __ptr_ring_consume(&rq->xdp_ring);
+                struct sk_buff *skb;
+
+                if (!ptr)
+                        break;
+
+                if (veth_is_xdp_frame(ptr)) {
+                        skb = veth_xdp_rcv_one(rq, veth_ptr_to_xdp(ptr),
+                                               xdp_xmit);
+                } else {
+                        skb = veth_xdp_rcv_skb(rq, ptr, xdp_xmit);
+                }
+
+                if (skb)
+                        napi_gro_receive(&rq->xdp_napi, skb);
+
+                done++;
+        }
+
+        return done;
+}
+
+static int veth_poll(struct napi_struct *napi, int budget)
+{
+        struct veth_rq *rq =
+                container_of(napi, struct veth_rq, xdp_napi);
+        unsigned int xdp_xmit = 0;
+        int done;
+
+        xdp_set_return_frame_no_direct();
+        done = veth_xdp_rcv(rq, budget, &xdp_xmit);
+
+        if (done < budget && napi_complete_done(napi, done)) {
+                /* Write rx_notify_masked before reading ptr_ring */
+                smp_store_mb(rq->rx_notify_masked, false);
+                if (unlikely(!__ptr_ring_empty(&rq->xdp_ring))) {
+                        rq->rx_notify_masked = true;
+                        napi_schedule(&rq->xdp_napi);
+                }
+        }
+
+        if (xdp_xmit & VETH_XDP_TX)
+                veth_xdp_flush(rq->dev);
+        if (xdp_xmit & VETH_XDP_REDIR)
+                xdp_do_flush_map();
+        xdp_clear_return_frame_no_direct();
+
+        return done;
+}
+
+static int veth_napi_add(struct net_device *dev)
+{
+        struct veth_priv *priv = netdev_priv(dev);
+        int err, i;
+
+        for (i = 0; i < dev->real_num_rx_queues; i++) {
+                struct veth_rq *rq = &priv->rq[i];
+
+                err = ptr_ring_init(&rq->xdp_ring, VETH_RING_SIZE, GFP_KERNEL);
+                if (err)
+                        goto err_xdp_ring;
+        }
+
+        for (i = 0; i < dev->real_num_rx_queues; i++) {
+                struct veth_rq *rq = &priv->rq[i];
+
+                netif_napi_add(dev, &rq->xdp_napi, veth_poll, NAPI_POLL_WEIGHT);
+                napi_enable(&rq->xdp_napi);
+        }
+
+        return 0;
+err_xdp_ring:
+        for (i--; i >= 0; i--)
+                ptr_ring_cleanup(&priv->rq[i].xdp_ring, veth_ptr_free);
+
+        return err;
+}
+
+static void veth_napi_del(struct net_device *dev)
+{
+        struct veth_priv *priv = netdev_priv(dev);
+        int i;
+
+        for (i = 0; i < dev->real_num_rx_queues; i++) {
+                struct veth_rq *rq = &priv->rq[i];
+
+                napi_disable(&rq->xdp_napi);
+                napi_hash_del(&rq->xdp_napi);
+        }
+        synchronize_net();
+
+        for (i = 0; i < dev->real_num_rx_queues; i++) {
+                struct veth_rq *rq = &priv->rq[i];
+
+                netif_napi_del(&rq->xdp_napi);
+                rq->rx_notify_masked = false;
+                ptr_ring_cleanup(&rq->xdp_ring, veth_ptr_free);
+        }
+}
+
+static int veth_enable_xdp(struct net_device *dev)
+{
+        struct veth_priv *priv = netdev_priv(dev);
+        int err, i;
+
+        if (!xdp_rxq_info_is_reg(&priv->rq[0].xdp_rxq)) {
+                for (i = 0; i < dev->real_num_rx_queues; i++) {
+                        struct veth_rq *rq = &priv->rq[i];
+
+                        err = xdp_rxq_info_reg(&rq->xdp_rxq, dev, i);
+                        if (err < 0)
+                                goto err_rxq_reg;
+
+                        err = xdp_rxq_info_reg_mem_model(&rq->xdp_rxq,
+                                                         MEM_TYPE_PAGE_SHARED,
+                                                         NULL);
+                        if (err < 0)
+                                goto err_reg_mem;
+
+                        /* Save original mem info as it can be overwritten */
+                        rq->xdp_mem = rq->xdp_rxq.mem;
+                }
+
+                err = veth_napi_add(dev);
+                if (err)
+                        goto err_rxq_reg;
+        }
+
+        for (i = 0; i < dev->real_num_rx_queues; i++)
+                rcu_assign_pointer(priv->rq[i].xdp_prog, priv->_xdp_prog);
+
+        return 0;
+err_reg_mem:
+        xdp_rxq_info_unreg(&priv->rq[i].xdp_rxq);
+err_rxq_reg:
+        for (i--; i >= 0; i--)
+                xdp_rxq_info_unreg(&priv->rq[i].xdp_rxq);
+
+        return err;
+}
+
+static void veth_disable_xdp(struct net_device *dev)
+{
+        struct veth_priv *priv = netdev_priv(dev);
+        int i;
+
+        for (i = 0; i < dev->real_num_rx_queues; i++)
+                rcu_assign_pointer(priv->rq[i].xdp_prog, NULL);
+        veth_napi_del(dev);
+        for (i = 0; i < dev->real_num_rx_queues; i++) {
+                struct veth_rq *rq = &priv->rq[i];
+
+                rq->xdp_rxq.mem = rq->xdp_mem;
+                xdp_rxq_info_unreg(&rq->xdp_rxq);
+        }
+}
+
 static int veth_open(struct net_device *dev)
 {
         struct veth_priv *priv = netdev_priv(dev);
         struct net_device *peer = rtnl_dereference(priv->peer);
+        int err;
 
         if (!peer)
                 return -ENOTCONN;
 
+        if (priv->_xdp_prog) {
+                err = veth_enable_xdp(dev);
+                if (err)
+                        return err;
+        }
+
         if (peer->flags & IFF_UP) {
                 netif_carrier_on(dev);
                 netif_carrier_on(peer);
         }
+
         return 0;
 }
 
@@ -203,6 +778,9 @@ static int veth_close(struct net_device *dev)
         if (peer)
                 netif_carrier_off(peer);
 
+        if (priv->_xdp_prog)
+                veth_disable_xdp(dev);
+
         return 0;
 }
 
@@ -228,7 +806,7 @@ static void veth_dev_free(struct net_device *dev)
 static void veth_poll_controller(struct net_device *dev)
 {
         /* veth only receives frames when its peer sends one
-         * Since it's a synchronous operation, we are guaranteed
+         * Since it has nothing to do with disabling irqs, we are guaranteed
          * never to have pending data when we poll for it so
          * there is nothing to do here.
          *
@@ -253,6 +831,23 @@ static int veth_get_iflink(const struct net_device *dev)
         return iflink;
 }
 
+static netdev_features_t veth_fix_features(struct net_device *dev,
+                                           netdev_features_t features)
+{
+        struct veth_priv *priv = netdev_priv(dev);
+        struct net_device *peer;
+
+        peer = rtnl_dereference(priv->peer);
+        if (peer) {
+                struct veth_priv *peer_priv = netdev_priv(peer);
+
+                if (peer_priv->_xdp_prog)
+                        features &= ~NETIF_F_GSO_SOFTWARE;
+        }
+
+        return features;
+}
+
 static void veth_set_rx_headroom(struct net_device *dev, int new_hr)
 {
         struct veth_priv *peer_priv, *priv = netdev_priv(dev);
@@ -276,6 +871,103 @@ out:
         rcu_read_unlock();
 }
 
+static int veth_xdp_set(struct net_device *dev, struct bpf_prog *prog,
+                        struct netlink_ext_ack *extack)
+{
+        struct veth_priv *priv = netdev_priv(dev);
+        struct bpf_prog *old_prog;
+        struct net_device *peer;
+        unsigned int max_mtu;
+        int err;
+
+        old_prog = priv->_xdp_prog;
+        priv->_xdp_prog = prog;
+        peer = rtnl_dereference(priv->peer);
+
+        if (prog) {
+                if (!peer) {
+                        NL_SET_ERR_MSG_MOD(extack, "Cannot set XDP when peer is detached");
+                        err = -ENOTCONN;
+                        goto err;
+                }
+
+                max_mtu = PAGE_SIZE - VETH_XDP_HEADROOM -
+                          peer->hard_header_len -
+                          SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
+                if (peer->mtu > max_mtu) {
+                        NL_SET_ERR_MSG_MOD(extack, "Peer MTU is too large to set XDP");
+                        err = -ERANGE;
+                        goto err;
+                }
+
+                if (dev->real_num_rx_queues < peer->real_num_tx_queues) {
+                        NL_SET_ERR_MSG_MOD(extack, "XDP expects number of rx queues not less than peer tx queues");
+                        err = -ENOSPC;
+                        goto err;
+                }
+
+                if (dev->flags & IFF_UP) {
+                        err = veth_enable_xdp(dev);
+                        if (err) {
+                                NL_SET_ERR_MSG_MOD(extack, "Setup for XDP failed");
+                                goto err;
+                        }
+                }
+
+                if (!old_prog) {
+                        peer->hw_features &= ~NETIF_F_GSO_SOFTWARE;
+                        peer->max_mtu = max_mtu;
+                }
+        }
+
+        if (old_prog) {
+                if (!prog) {
+                        if (dev->flags & IFF_UP)
+                                veth_disable_xdp(dev);
+
+                        if (peer) {
+                                peer->hw_features |= NETIF_F_GSO_SOFTWARE;
+                                peer->max_mtu = ETH_MAX_MTU;
+                        }
+                }
+                bpf_prog_put(old_prog);
+        }
+
+        if ((!!old_prog ^ !!prog) && peer)
+                netdev_update_features(peer);
+
+        return 0;
+err:
+        priv->_xdp_prog = old_prog;
+
+        return err;
+}
+
+static u32 veth_xdp_query(struct net_device *dev)
+{
+        struct veth_priv *priv = netdev_priv(dev);
+        const struct bpf_prog *xdp_prog;
+
+        xdp_prog = priv->_xdp_prog;
+        if (xdp_prog)
+                return xdp_prog->aux->id;
+
+        return 0;
+}
+
+static int veth_xdp(struct net_device *dev, struct netdev_bpf *xdp)
+{
+        switch (xdp->command) {
+        case XDP_SETUP_PROG:
+                return veth_xdp_set(dev, xdp->prog, xdp->extack);
+        case XDP_QUERY_PROG:
+                xdp->prog_id = veth_xdp_query(dev);
+                return 0;
+        default:
+                return -EINVAL;
+        }
+}
+
 static const struct net_device_ops veth_netdev_ops = {
         .ndo_init            = veth_dev_init,
         .ndo_open            = veth_open,
@@ -288,8 +980,11 @@ static const struct net_device_ops veth_netdev_ops = {
         .ndo_poll_controller    = veth_poll_controller,
 #endif
         .ndo_get_iflink         = veth_get_iflink,
+        .ndo_fix_features       = veth_fix_features,
         .ndo_features_check     = passthru_features_check,
         .ndo_set_rx_headroom    = veth_set_rx_headroom,
+        .ndo_bpf                = veth_xdp,
+        .ndo_xdp_xmit           = veth_xdp_xmit,
 };
 
 #define VETH_FEATURES (NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_HW_CSUM | \
@@ -345,13 +1040,31 @@ static int veth_validate(struct nlattr *tb[], struct nlattr *data[],
         return 0;
 }
 
+static int veth_alloc_queues(struct net_device *dev)
+{
+        struct veth_priv *priv = netdev_priv(dev);
+
+        priv->rq = kcalloc(dev->num_rx_queues, sizeof(*priv->rq), GFP_KERNEL);
+        if (!priv->rq)
+                return -ENOMEM;
+
+        return 0;
+}
+
+static void veth_free_queues(struct net_device *dev)
+{
+        struct veth_priv *priv = netdev_priv(dev);
+
+        kfree(priv->rq);
+}
+
 static struct rtnl_link_ops veth_link_ops;
 
 static int veth_newlink(struct net *src_net, struct net_device *dev,
                         struct nlattr *tb[], struct nlattr *data[],
                         struct netlink_ext_ack *extack)
 {
-        int err;
+        int err, i;
         struct net_device *peer;
         struct veth_priv *priv;
         char ifname[IFNAMSIZ];
@@ -404,6 +1117,12 @@ static int veth_newlink(struct net *src_net, struct net_device *dev,
                 return PTR_ERR(peer);
         }
 
+        err = veth_alloc_queues(peer);
+        if (err) {
+                put_net(net);
+                goto err_peer_alloc_queues;
+        }
+
         if (!ifmp || !tbp[IFLA_ADDRESS])
                 eth_hw_addr_random(peer);
 
@@ -432,6 +1151,10 @@ static int veth_newlink(struct net *src_net, struct net_device *dev,
          * should be re-allocated
          */
 
+        err = veth_alloc_queues(dev);
+        if (err)
+                goto err_alloc_queues;
+
         if (tb[IFLA_ADDRESS] == NULL)
                 eth_hw_addr_random(dev);
 
@@ -451,19 +1174,28 @@ static int veth_newlink(struct net *src_net, struct net_device *dev,
          */
 
         priv = netdev_priv(dev);
+        for (i = 0; i < dev->real_num_rx_queues; i++)
+                priv->rq[i].dev = dev;
         rcu_assign_pointer(priv->peer, peer);
 
         priv = netdev_priv(peer);
+        for (i = 0; i < peer->real_num_rx_queues; i++)
+                priv->rq[i].dev = peer;
         rcu_assign_pointer(priv->peer, dev);
+
         return 0;
 
 err_register_dev:
+        veth_free_queues(dev);
+err_alloc_queues:
         /* nothing to do */
 err_configure_peer:
         unregister_netdevice(peer);
         return err;
 
 err_register_peer:
+        veth_free_queues(peer);
+err_peer_alloc_queues:
         free_netdev(peer);
         return err;
 }
diff --git a/include/linux/filter.h b/include/linux/filter.h
index c73dd7396886..2b072dab32c0 100644
--- a/include/linux/filter.h
+++ b/include/linux/filter.h
@@ -537,6 +537,20 @@ struct sk_msg_buff {
         struct list_head list;
 };
 
+struct bpf_redirect_info {
+        u32 ifindex;
+        u32 flags;
+        struct bpf_map *map;
+        struct bpf_map *map_to_flush;
+        unsigned long   map_owner;
+        u32 kern_flags;
+};
+
+DECLARE_PER_CPU(struct bpf_redirect_info, bpf_redirect_info);
+
+/* flags for bpf_redirect_info kern_flags */
+#define BPF_RI_F_RF_NO_DIRECT   BIT(0)  /* no napi_direct on return_frame */
+
 /* Compute the linear packet data range [data, data_end) which
  * will be accessed by various program types (cls_bpf, act_bpf,
  * lwt, ...). Subsystems allowing direct data access must (!)
@@ -765,6 +779,27 @@ static inline bool bpf_dump_raw_ok(void)
 struct bpf_prog *bpf_patch_insn_single(struct bpf_prog *prog, u32 off,
                                        const struct bpf_insn *patch, u32 len);
 
+static inline bool xdp_return_frame_no_direct(void)
+{
+        struct bpf_redirect_info *ri = this_cpu_ptr(&bpf_redirect_info);
+
+        return ri->kern_flags & BPF_RI_F_RF_NO_DIRECT;
+}
+
+static inline void xdp_set_return_frame_no_direct(void)
+{
+        struct bpf_redirect_info *ri = this_cpu_ptr(&bpf_redirect_info);
+
+        ri->kern_flags |= BPF_RI_F_RF_NO_DIRECT;
+}
+
+static inline void xdp_clear_return_frame_no_direct(void)
+{
+        struct bpf_redirect_info *ri = this_cpu_ptr(&bpf_redirect_info);
+
+        ri->kern_flags &= ~BPF_RI_F_RF_NO_DIRECT;
+}
+
 static inline int xdp_ok_fwd_dev(const struct net_device *fwd,
                                  unsigned int pktlen)
 {
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 7ebdf158a795..e93b157f526c 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -1038,6 +1038,7 @@ static inline struct sk_buff *alloc_skb_fclone(unsigned int size,
 }
 
 struct sk_buff *skb_morph(struct sk_buff *dst, struct sk_buff *src);
+void skb_headers_offset_update(struct sk_buff *skb, int off);
 int skb_copy_ubufs(struct sk_buff *skb, gfp_t gfp_mask);
 struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t priority);
 void skb_copy_header(struct sk_buff *new, const struct sk_buff *old);
diff --git a/include/net/xdp.h b/include/net/xdp.h
index fcb033f51d8c..76b95256c266 100644
--- a/include/net/xdp.h
+++ b/include/net/xdp.h
@@ -84,6 +84,13 @@ struct xdp_frame {
         struct net_device *dev_rx; /* used by cpumap */
 };
 
+/* Clear kernel pointers in xdp_frame */
+static inline void xdp_scrub_frame(struct xdp_frame *frame)
+{
+        frame->data = NULL;
+        frame->dev_rx = NULL;
+}
+
 /* Convert xdp_buff to xdp_frame */
 static inline
 struct xdp_frame *convert_to_xdp_frame(struct xdp_buff *xdp)
diff --git a/net/core/filter.c b/net/core/filter.c
index 587bbfbd7db3..2de7dd9f2a57 100644
--- a/net/core/filter.c
+++ b/net/core/filter.c
@@ -2082,19 +2082,12 @@ static const struct bpf_func_proto bpf_clone_redirect_proto = {
         .arg3_type      = ARG_ANYTHING,
 };
 
-struct redirect_info {
-        u32 ifindex;
-        u32 flags;
-        struct bpf_map *map;
-        struct bpf_map *map_to_flush;
-        unsigned long   map_owner;
-};
-
-static DEFINE_PER_CPU(struct redirect_info, redirect_info);
+DEFINE_PER_CPU(struct bpf_redirect_info, bpf_redirect_info);
+EXPORT_PER_CPU_SYMBOL_GPL(bpf_redirect_info);
 
 BPF_CALL_2(bpf_redirect, u32, ifindex, u64, flags)
 {
-        struct redirect_info *ri = this_cpu_ptr(&redirect_info);
+        struct bpf_redirect_info *ri = this_cpu_ptr(&bpf_redirect_info);
 
         if (unlikely(flags & ~(BPF_F_INGRESS)))
                 return TC_ACT_SHOT;
@@ -2107,7 +2100,7 @@ BPF_CALL_2(bpf_redirect, u32, ifindex, u64, flags)
 
 int skb_do_redirect(struct sk_buff *skb)
 {
-        struct redirect_info *ri = this_cpu_ptr(&redirect_info);
+        struct bpf_redirect_info *ri = this_cpu_ptr(&bpf_redirect_info);
         struct net_device *dev;
 
         dev = dev_get_by_index_rcu(dev_net(skb->dev), ri->ifindex);
@@ -3200,7 +3193,7 @@ static int __bpf_tx_xdp_map(struct net_device *dev_rx, void *fwd,
 
 void xdp_do_flush_map(void)
 {
-        struct redirect_info *ri = this_cpu_ptr(&redirect_info);
+        struct bpf_redirect_info *ri = this_cpu_ptr(&bpf_redirect_info);
         struct bpf_map *map = ri->map_to_flush;
 
         ri->map_to_flush = NULL;
@@ -3245,7 +3238,7 @@ static inline bool xdp_map_invalid(const struct bpf_prog *xdp_prog,
 static int xdp_do_redirect_map(struct net_device *dev, struct xdp_buff *xdp,
                                struct bpf_prog *xdp_prog)
 {
-        struct redirect_info *ri = this_cpu_ptr(&redirect_info);
+        struct bpf_redirect_info *ri = this_cpu_ptr(&bpf_redirect_info);
         unsigned long map_owner = ri->map_owner;
         struct bpf_map *map = ri->map;
         u32 index = ri->ifindex;
@@ -3285,7 +3278,7 @@ err:
 int xdp_do_redirect(struct net_device *dev, struct xdp_buff *xdp,
                     struct bpf_prog *xdp_prog)
 {
-        struct redirect_info *ri = this_cpu_ptr(&redirect_info);
+        struct bpf_redirect_info *ri = this_cpu_ptr(&bpf_redirect_info);
         struct net_device *fwd;
         u32 index = ri->ifindex;
         int err;
@@ -3317,7 +3310,7 @@ static int xdp_do_generic_redirect_map(struct net_device *dev,
                                        struct xdp_buff *xdp,
                                        struct bpf_prog *xdp_prog)
 {
-        struct redirect_info *ri = this_cpu_ptr(&redirect_info);
+        struct bpf_redirect_info *ri = this_cpu_ptr(&bpf_redirect_info);
         unsigned long map_owner = ri->map_owner;
         struct bpf_map *map = ri->map;
         u32 index = ri->ifindex;
@@ -3368,7 +3361,7 @@ err:
 int xdp_do_generic_redirect(struct net_device *dev, struct sk_buff *skb,
                             struct xdp_buff *xdp, struct bpf_prog *xdp_prog)
 {
-        struct redirect_info *ri = this_cpu_ptr(&redirect_info);
+        struct bpf_redirect_info *ri = this_cpu_ptr(&bpf_redirect_info);
         u32 index = ri->ifindex;
         struct net_device *fwd;
         int err = 0;
@@ -3399,7 +3392,7 @@ EXPORT_SYMBOL_GPL(xdp_do_generic_redirect);
 
 BPF_CALL_2(bpf_xdp_redirect, u32, ifindex, u64, flags)
 {
-        struct redirect_info *ri = this_cpu_ptr(&redirect_info);
+        struct bpf_redirect_info *ri = this_cpu_ptr(&bpf_redirect_info);
 
         if (unlikely(flags))
                 return XDP_ABORTED;
@@ -3423,7 +3416,7 @@ static const struct bpf_func_proto bpf_xdp_redirect_proto = {
 BPF_CALL_4(bpf_xdp_redirect_map, struct bpf_map *, map, u32, ifindex, u64, flags,
            unsigned long, map_owner)
 {
-        struct redirect_info *ri = this_cpu_ptr(&redirect_info);
+        struct bpf_redirect_info *ri = this_cpu_ptr(&bpf_redirect_info);
 
         if (unlikely(flags))
                 return XDP_ABORTED;
diff --git a/net/core/skbuff.c b/net/core/skbuff.c
index 8d574a88125d..c996c09d095f 100644
--- a/net/core/skbuff.c
+++ b/net/core/skbuff.c
@@ -1291,7 +1291,7 @@ struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t gfp_mask)
 }
 EXPORT_SYMBOL(skb_clone);
 
-static void skb_headers_offset_update(struct sk_buff *skb, int off)
+void skb_headers_offset_update(struct sk_buff *skb, int off)
 {
         /* Only adjust this if it actually is csum_start rather than csum */
         if (skb->ip_summed == CHECKSUM_PARTIAL)
@@ -1305,6 +1305,7 @@ static void skb_headers_offset_update(struct sk_buff *skb, int off)
         skb->inner_network_header += off;
         skb->inner_mac_header += off;
 }
+EXPORT_SYMBOL(skb_headers_offset_update);
 
 void skb_copy_header(struct sk_buff *new, const struct sk_buff *old)
 {
diff --git a/net/core/xdp.c b/net/core/xdp.c
index 57285383ed00..3dd99e1c04f5 100644
--- a/net/core/xdp.c
+++ b/net/core/xdp.c
@@ -330,10 +330,12 @@ static void __xdp_return(void *data, struct xdp_mem_info *mem, bool napi_direct,
                 /* mem->id is valid, checked in xdp_rxq_info_reg_mem_model() */
                 xa = rhashtable_lookup(mem_id_ht, &mem->id, mem_id_rht_params);
                 page = virt_to_head_page(data);
-                if (xa)
+                if (xa) {
+                        napi_direct &= !xdp_return_frame_no_direct();
                         page_pool_put_page(xa->page_pool, page, napi_direct);
-                else
+                } else {
                         put_page(page);
+                }
                 rcu_read_unlock();
                 break;
         case MEM_TYPE_PAGE_SHARED: