git: 508c4fb4c34b - stable/13 - LinuxKPI: add a work-in-progress skbuff implementation

From: Bjoern A. Zeeb <bz_at_FreeBSD.org>
Date: Thu, 30 Dec 2021 19:22:43 UTC
The branch stable/13 has been updated by bz:

URL: https://cgit.FreeBSD.org/src/commit/?id=508c4fb4c34b0d3045a6ed9b5eb2d42a591fb6f4

commit 508c4fb4c34b0d3045a6ed9b5eb2d42a591fb6f4
Author:     Bjoern A. Zeeb <bz@FreeBSD.org>
AuthorDate: 2021-12-26 18:26:26 +0000
Commit:     Bjoern A. Zeeb <bz@FreeBSD.org>
CommitDate: 2021-12-30 18:27:19 +0000

    LinuxKPI: add a work-in-progress skbuff implementation
    
    This is a work-in-progress implementation of sk_buff compat code
    used for wireless drivers only currently.
    Bring in this version of the code as it has proven to be good enough
    to have packets going for a few months.
    
    The current implementation has several drawbacks including the need
    for us to copy data between sk_buffs and mbufs.
    Do not rely on the internals of this implementation.  They are highly
    likely to change as we will improve the integration to FreeBSD mbufs.
    
    Sponsored by:   The FreeBSD Foundation
    
    (cherry picked from commit 49ed6e979c3b327ae466a559884802d901aa5792)
---
 sys/compat/linuxkpi/common/include/linux/skbuff.h | 826 ++++++++++++++++++++++
 sys/compat/linuxkpi/common/src/linux_skbuff.c     | 113 +++
 sys/conf/files                                    |   2 +
 sys/modules/linuxkpi/Makefile                     |   1 +
 4 files changed, 942 insertions(+)

diff --git a/sys/compat/linuxkpi/common/include/linux/skbuff.h b/sys/compat/linuxkpi/common/include/linux/skbuff.h
new file mode 100644
index 000000000000..37fb6109c784
--- /dev/null
+++ b/sys/compat/linuxkpi/common/include/linux/skbuff.h
@@ -0,0 +1,826 @@
+/*-
+ * Copyright (c) 2020-2021 The FreeBSD Foundation
+ * Copyright (c) 2021 Bjoern A. Zeeb
+ *
+ * This software was developed by Björn Zeeb under sponsorship from
+ * the FreeBSD Foundation.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/*
+ * NOTE: this socket buffer compatibility code is highly EXPERIMENTAL.
+ *       Do not rely on the internals of this implementation.  They are highly
+ *       likely to change as we will improve the integration to FreeBSD mbufs.
+ */
+
+#ifndef	_LINUXKPI_LINUX_SKBUFF_H
+#define	_LINUXKPI_LINUX_SKBUFF_H
+
+#include <linux/page.h>
+#include <linux/dma-mapping.h>
+#include <linux/netdev_features.h>
+#include <linux/list.h>
+#include <linux/gfp.h>
+
+/* #define	SKB_DEBUG */
+#ifdef SKB_DEBUG
+
+#define	DSKB_TODO	0x01
+#define	DSKB_TRACE	0x02
+#define	DSKB_TRACEX	0x04
+extern int debug_skb;
+
+#define	SKB_TRACE(_s)		if (debug_skb & DSKB_TRACE)		\
+    printf("SKB_TRACE %s:%d %p\n", __func__, __LINE__, _s)
+#define	SKB_TRACE2(_s, _p)	if (debug_skb & DSKB_TRACE)		\
+    printf("SKB_TRACE %s:%d %p, %p\n", __func__, __LINE__, _s, _p)
+#define	SKB_TRACE_FMT(_s, _fmt, ...)	if (debug_skb & DSKB_TRACE)	\
+    printf("SKB_TRACE %s:%d %p" _fmt "\n", __func__, __LINE__, _s, __VA_ARGS__)
+#define	SKB_TODO()		if (debug_skb & DSKB_TODO)		\
+    printf("SKB_TODO %s:%d\n", __func__, __LINE__)
+#else
+#define	SKB_TRACE(_s)		do { } while(0)
+#define	SKB_TRACE2(_s, _p)	do { } while(0)
+#define	SKB_TRACE_FMT(_s, ...)	do { } while(0)
+#define	SKB_TODO()		do { } while(0)
+#endif
+
+enum sk_buff_pkt_type {
+	PACKET_BROADCAST,
+	PACKET_MULTICAST,
+	PACKET_OTHERHOST,
+};
+
+#define	NET_SKB_PAD		CACHE_LINE_SIZE		/* ? */
+
+struct sk_buff_head {
+		/* XXX TODO */
+	struct sk_buff		*next;
+	struct sk_buff		*prev;
+	size_t			qlen;
+	int			lock;	/* XXX TYPE */
+};
+
+enum sk_checksum_flags {
+	CHECKSUM_NONE			= 0x00,
+	CHECKSUM_UNNECESSARY		= 0x01,
+	CHECKSUM_PARTIAL		= 0x02,
+	CHECKSUM_COMPLETE		= 0x04,
+};
+
+struct skb_frag {
+		/* XXX TODO */
+	struct page		*page;		/* XXX-BZ These three are a wild guess so far! */
+	off_t			offset;
+	size_t			size;
+};
+typedef	struct skb_frag	skb_frag_t;
+
+enum skb_shared_info_gso_type {
+	SKB_GSO_TCPV4,
+	SKB_GSO_TCPV6,
+};
+
+struct skb_shared_info {
+	enum skb_shared_info_gso_type	gso_type;
+	uint16_t			gso_size;
+	uint16_t			nr_frags;
+	skb_frag_t			frags[64];	/* XXX TODO, 16xpage? */
+};
+
+struct sk_buff {
+		/* XXX TODO */
+	/* struct sk_buff_head */
+	struct sk_buff		*next;
+	struct sk_buff		*prev;
+	int			list;		/* XXX TYPE */
+	uint32_t		_alloc_len;	/* Length of alloc data-buf. XXX-BZ give up for truesize? */
+	uint32_t		len;		/* ? */
+	uint32_t		data_len;	/* ? If we have frags? */
+	uint32_t		truesize;	/* The total size of all buffers, incl. frags. */
+	uint16_t		mac_len;	/* Link-layer header length. */
+	__sum16			csum;
+	uint16_t		l3hdroff;	/* network header offset from *head */
+	uint16_t		l4hdroff;	/* transport header offset from *head */
+	uint32_t		priority;
+	uint16_t		qmap;		/* queue mapping */
+	uint16_t		_spareu16_0;
+	enum sk_buff_pkt_type	pkt_type;
+
+	/* "Scratch" area for layers to store metadata. */
+	/* ??? I see sizeof() operations so probably an array. */
+	uint8_t			cb[64] __aligned(CACHE_LINE_SIZE);
+
+	struct net_device	*dev;
+	void			*sk;		/* XXX net/sock.h? */
+
+	int		csum_offset, csum_start, ip_summed, protocol;
+
+	uint8_t			*head;			/* Head of buffer. */
+	uint8_t			*data;			/* Head of data. */
+	uint8_t			*tail;			/* End of data. */
+	uint8_t			*end;			/* End of buffer. */
+
+	struct skb_shared_info	*shinfo;
+
+	/* FreeBSD specific bandaid (see linuxkpi_kfree_skb). */
+	void			*m;
+	void(*m_free_func)(void *);
+
+	/* Force padding to CACHE_LINE_SIZE. */
+	uint8_t			__scratch[0] __aligned(CACHE_LINE_SIZE);
+};
+
+/* -------------------------------------------------------------------------- */
+
+struct sk_buff *linuxkpi_alloc_skb(size_t, gfp_t);
+void linuxkpi_kfree_skb(struct sk_buff *);
+
+/* -------------------------------------------------------------------------- */
+
+static inline struct sk_buff *
+alloc_skb(size_t size, gfp_t gfp)
+{
+	struct sk_buff *skb;
+
+	skb = linuxkpi_alloc_skb(size, gfp);
+	SKB_TRACE(skb);
+	return (skb);
+}
+
+static inline struct sk_buff *
+dev_alloc_skb(size_t len)
+{
+	struct sk_buff *skb;
+
+	skb = alloc_skb(len, GFP_KERNEL);
+	/* XXX TODO */
+	SKB_TRACE(skb);
+	return (skb);
+}
+
+static inline void
+kfree_skb(struct sk_buff *skb)
+{
+	SKB_TRACE(skb);
+	linuxkpi_kfree_skb(skb);
+}
+
+static inline void
+dev_kfree_skb(struct sk_buff *skb)
+{
+	SKB_TRACE(skb);
+	kfree_skb(skb);
+}
+
+static inline void
+dev_kfree_skb_any(struct sk_buff *skb)
+{
+	SKB_TRACE(skb);
+	dev_kfree_skb(skb);
+}
+
+static inline void
+dev_kfree_skb_irq(struct sk_buff *skb)
+{
+	SKB_TRACE(skb);
+	SKB_TODO();
+}
+
+/* -------------------------------------------------------------------------- */
+
+/* XXX BZ review this one for terminal condition as Linux "queues" are special. */
+#define	skb_list_walk_safe(_q, skb, tmp)				\
+	for ((skb) = (_q)->next; (skb) != NULL && ((tmp) = (skb)->next); (skb) = (tmp))
+
+/* Add headroom; cannot do once there is data in there. */
+static inline void
+skb_reserve(struct sk_buff *skb, size_t len)
+{
+	SKB_TRACE(skb);
+	KASSERT(skb->data == skb->head, ("%s: skb %p not empty head %p data %p "
+	    "tail %p\n", __func__, skb, skb->head, skb->data, skb->tail));
+	skb->data += len;
+	skb->tail += len;
+}
+
+/*
+ * Remove headroom; return new data pointer; basically make space at the
+ * front to copy data in (manually).
+ */
+static inline void *
+skb_push(struct sk_buff *skb, size_t len)
+{
+	SKB_TRACE(skb);
+	KASSERT(((skb->data - len) >= skb->head), ("%s: skb %p (data %p - "
+	    "len %zu) < head %p\n", __func__, skb, skb->data, len, skb->data));
+	skb->len  += len;
+	skb->data -= len;
+	return (skb->data);
+}
+
+/*
+ * Length of the data on the skb (without any frags)???
+ */
+static inline size_t
+skb_headlen(struct sk_buff *skb)
+{
+
+	SKB_TRACE(skb);
+	return (skb->len - skb->data_len);
+}
+
+
+/* Return the end of data (tail pointer). */
+static inline uint8_t *
+skb_tail_pointer(struct sk_buff *skb)
+{
+
+	SKB_TRACE(skb);
+	return (skb->tail);
+}
+
+/* Return number of bytes available at end of buffer. */
+static inline unsigned int
+skb_tailroom(struct sk_buff *skb)
+{
+
+	SKB_TRACE(skb);
+	KASSERT((skb->end - skb->tail) >= 0, ("%s: skb %p tailroom < 0, "
+	    "end %p tail %p\n", __func__, skb, skb->end, skb->tail));
+	return (skb->end - skb->tail);
+}
+
+/* Return numer of bytes available at the beginning of buffer. */
+static inline unsigned int
+skb_headroom(struct sk_buff *skb)
+{
+	SKB_TRACE(skb);
+	KASSERT((skb->data - skb->head) >= 0, ("%s: skb %p headroom < 0, "
+	    "data %p head %p\n", __func__, skb, skb->data, skb->head));
+	return (skb->data - skb->head);
+}
+
+
+/*
+ * Remove tailroom; return the old tail pointer; basically make space at
+ * the end to copy data in (manually).  See also skb_put_data() below.
+ */
+static inline void *
+skb_put(struct sk_buff *skb, size_t len)
+{
+	void *s;
+
+	SKB_TRACE(skb);
+	KASSERT(((skb->tail + len) <= skb->end), ("%s: skb %p (tail %p + "
+	    "len %zu) > end %p, head %p data %p len %u\n", __func__,
+	    skb, skb->tail, len, skb->end, skb->head, skb->data, skb->len));
+
+	s = skb_tail_pointer(skb);
+	skb->tail += len;
+	skb->len += len;
+#ifdef SKB_DEBUG
+	if (debug_skb & DSKB_TRACEX)
+	printf("%s: skb %p (%u) head %p data %p tail %p end %p, s %p len %zu\n",
+	    __func__, skb,skb->len, skb->head, skb->data, skb->tail, skb->end,
+	    s, len);
+#endif
+	return (s);
+}
+
+/* skb_put() + copying data in. */
+static inline void *
+skb_put_data(struct sk_buff *skb, const void *buf, size_t len)
+{
+	void *s;
+
+	SKB_TRACE2(skb, buf);
+	s = skb_put(skb, len);
+	memcpy(s, buf, len);
+	return (s);
+}
+
+/* skb_put() + filling with zeros. */
+static inline void *
+skb_put_zero(struct sk_buff *skb, size_t len)
+{
+	void *s;
+
+	SKB_TRACE(skb);
+	s = skb_put(skb, len);
+	memset(s, '\0', len);
+	return (s);
+}
+
+/*
+ * Remove len bytes from beginning of data.
+ *
+ * XXX-BZ ath10k checks for !NULL conditions so I assume this doesn't panic;
+ * we return the advanced data pointer so we don't have to keep a temp, correct?
+ */
+static inline void *
+skb_pull(struct sk_buff *skb, size_t len)
+{
+
+	SKB_TRACE(skb);
+#if 0	/* Apparently this doesn't barf... */
+	KASSERT(skb->len >= len, ("%s: skb %p skb->len %u < len %u, data %p\n",
+	    __func__, skb, skb->len, len, skb->data));
+#endif
+	if (skb->len < len)
+		return (NULL);
+	skb->len -= len;
+	skb->data += len;
+	return (skb->data);
+}
+
+/* Reduce skb data to given length or do nothing if smaller already. */
+static inline void
+__skb_trim(struct sk_buff *skb, unsigned int len)
+{
+
+	SKB_TRACE(skb);
+	if (skb->len < len)
+		return;
+
+	skb->len = len;
+	skb->tail = skb->data + skb->len;
+}
+
+static inline void
+skb_trim(struct sk_buff *skb, unsigned int len)
+{
+
+	return (__skb_trim(skb, len));
+}
+
+static inline struct skb_shared_info *
+skb_shinfo(struct sk_buff *skb)
+{
+
+	SKB_TRACE(skb);
+	return (skb->shinfo);
+}
+
+static inline void
+skb_add_rx_frag(struct sk_buff *skb, int fragno, struct page *page,
+    off_t offset, size_t size, unsigned int truesize)
+{
+	struct skb_shared_info *shinfo;
+
+	SKB_TRACE(skb);
+#ifdef SKB_DEBUG
+	if (debug_skb & DSKB_TRACEX)
+	printf("%s: skb %p head %p data %p tail %p end %p len %u fragno %d "
+	    "page %#jx offset %ju size %zu truesize %u\n", __func__,
+	    skb, skb->head, skb->data, skb->tail, skb->end, skb->len, fragno,
+	    (uintmax_t)(uintptr_t)linux_page_address(page), (uintmax_t)offset,
+	    size, truesize);
+#endif
+
+	shinfo = skb_shinfo(skb);
+	KASSERT(fragno >= 0 && fragno < nitems(shinfo->frags), ("%s: skb %p "
+	    "fragno %d too big\n", __func__, skb, fragno));
+	shinfo->frags[fragno].page = page;
+	shinfo->frags[fragno].offset = offset;
+	shinfo->frags[fragno].size = size;
+	shinfo->nr_frags = fragno + 1;
+        skb->len += size;
+        skb->truesize += truesize;
+
+	/* XXX TODO EXTEND truesize? */
+}
+
+/* -------------------------------------------------------------------------- */
+
+/* XXX BZ review this one for terminal condition as Linux "queues" are special. */
+#define	skb_queue_walk(_q, skb)						\
+	for ((skb) = (_q)->next; (skb) != (struct sk_buff *)(_q);	\
+	    (skb) = (skb)->next)
+
+#define	skb_queue_walk_safe(_q, skb, tmp)				\
+	for ((skb) = (_q)->next, (tmp) = (skb)->next;			\
+	    (skb) != (struct sk_buff *)(_q); (skb) = (tmp), (tmp) = (skb)->next)
+
+static inline bool
+skb_queue_empty(struct sk_buff_head *q)
+{
+
+	SKB_TRACE(q);
+	return (q->qlen == 0);
+}
+
+static inline void
+__skb_queue_head_init(struct sk_buff_head *q)
+{
+	SKB_TRACE(q);
+	q->prev = q->next = (struct sk_buff *)q;
+	q->qlen = 0;
+}
+
+static inline void
+skb_queue_head_init(struct sk_buff_head *q)
+{
+	SKB_TRACE(q);
+	return (__skb_queue_head_init(q));
+}
+
+static inline void
+__skb_insert(struct sk_buff *new, struct sk_buff *prev, struct sk_buff *next,
+    struct sk_buff_head *q)
+{
+
+	SKB_TRACE_FMT(new, "prev %p next %p q %p", prev, next, q);
+	new->prev = prev;
+	new->next = next;
+	next->prev = new;
+	prev->next = new;
+	q->qlen++;
+}
+
+static inline void
+__skb_queue_after(struct sk_buff_head *q, struct sk_buff *skb,
+    struct sk_buff *new)
+{
+
+	SKB_TRACE_FMT(q, "skb %p new %p", skb, new);
+	__skb_insert(new, skb, skb->next, q);
+}
+
+static inline void
+__skb_queue_before(struct sk_buff_head *q, struct sk_buff *skb,
+    struct sk_buff *new)
+{
+
+	SKB_TRACE_FMT(q, "skb %p new %p", skb, new);
+	__skb_insert(new, skb->prev, skb, q);
+}
+
+static inline void
+__skb_queue_tail(struct sk_buff_head *q, struct sk_buff *skb)
+{
+	struct sk_buff *s;
+
+	SKB_TRACE2(q, skb);
+	q->qlen++;
+	s = (struct sk_buff *)q;
+	s->prev->next = skb;
+	skb->prev = s->prev;
+	skb->next = s;
+	s->prev = skb;
+}
+
+static inline void
+skb_queue_tail(struct sk_buff_head *q, struct sk_buff *skb)
+{
+	SKB_TRACE2(q, skb);
+	return (__skb_queue_tail(q, skb));
+}
+
+static inline struct sk_buff *
+skb_peek_tail(struct sk_buff_head *q)
+{
+	struct sk_buff *skb;
+
+	skb = q->prev;
+	SKB_TRACE2(q, skb);
+	if (skb == (struct sk_buff *)q)
+		return (NULL);
+	return (skb);
+}
+
+static inline void
+__skb_unlink(struct sk_buff *skb, struct sk_buff_head *head)
+{
+	SKB_TRACE2(skb, head);
+	struct sk_buff *p, *n;;
+
+	head->qlen--;
+	p = skb->prev;
+	n = skb->next;
+	p->next = n;
+	n->prev = p;
+	skb->prev = skb->next = NULL;
+}
+
+static inline void
+skb_unlink(struct sk_buff *skb, struct sk_buff_head *head)
+{
+	SKB_TRACE2(skb, head);
+	return (__skb_unlink(skb, head));
+}
+
+static inline struct sk_buff *
+__skb_dequeue(struct sk_buff_head *q)
+{
+	struct sk_buff *skb;
+
+	SKB_TRACE(q);
+	skb = q->next;
+	if (skb == (struct sk_buff *)q)
+		return (NULL);
+	if (skb != NULL)
+		__skb_unlink(skb, q);
+	SKB_TRACE(skb);
+	return (skb);
+}
+
+static inline struct sk_buff *
+skb_dequeue(struct sk_buff_head *q)
+{
+	SKB_TRACE(q);
+	return (__skb_dequeue(q));
+}
+
+static inline struct sk_buff *
+skb_dequeue_tail(struct sk_buff_head *q)
+{
+	struct sk_buff *skb;
+
+	skb = skb_peek_tail(q);
+	if (skb != NULL)
+		__skb_unlink(skb, q);
+
+	SKB_TRACE2(q, skb);
+	return (skb);
+}
+
+static inline void
+skb_queue_head(struct sk_buff_head *q, struct sk_buff *skb)
+{
+
+	SKB_TRACE2(q, skb);
+	__skb_queue_after(q, (struct sk_buff *)q, skb);
+}
+
+static inline uint32_t
+skb_queue_len(struct sk_buff_head *head)
+{
+	SKB_TRACE(head);
+	return (head->qlen);
+}
+
+static inline void
+__skb_queue_purge(struct sk_buff_head *q)
+{
+	struct sk_buff *skb;
+
+	SKB_TRACE(q);
+        while ((skb = __skb_dequeue(q)) != NULL)
+		kfree_skb(skb);
+}
+
+static inline void
+skb_queue_purge(struct sk_buff_head *q)
+{
+	SKB_TRACE(q);
+	return (__skb_queue_purge(q));
+}
+
+static inline struct sk_buff *
+skb_queue_prev(struct sk_buff_head *q, struct sk_buff *skb)
+{
+
+	SKB_TRACE2(q, skb);
+	/* XXX what is the q argument good for? */
+	return (skb->prev);
+}
+
+/* -------------------------------------------------------------------------- */
+
+static inline struct sk_buff *
+skb_copy(struct sk_buff *skb, gfp_t gfp)
+{
+	SKB_TRACE(skb);
+	SKB_TODO();
+	return (NULL);
+}
+
+static inline void
+consume_skb(struct sk_buff *skb)
+{
+	SKB_TRACE(skb);
+	SKB_TODO();
+}
+
+static inline uint16_t
+skb_checksum(struct sk_buff *skb, int offs, size_t len, int x)
+{
+	SKB_TRACE(skb);
+	SKB_TODO();
+	return (0xffff);
+}
+
+static inline int
+skb_checksum_start_offset(struct sk_buff *skb)
+{
+	SKB_TRACE(skb);
+	SKB_TODO();
+	return (-1);
+}
+
+static inline dma_addr_t
+skb_frag_dma_map(struct device *dev, const skb_frag_t *frag, int x,
+    size_t fragsz, enum dma_data_direction dir)
+{
+	SKB_TRACE2(frag, dev);
+	SKB_TODO();
+	return (-1);
+}
+
+static inline size_t
+skb_frag_size(const skb_frag_t *frag)
+{
+	SKB_TRACE(frag);
+	SKB_TODO();
+	return (-1);
+}
+
+static inline bool
+skb_is_nonlinear(struct sk_buff *skb)
+{
+	SKB_TRACE(skb);
+	return ((skb->data_len > 0) ? true : false);
+}
+
+#define	skb_walk_frags(_skb, _frag)					\
+	for ((_frag) = (_skb); false; (_frag)++)
+
+static inline void
+skb_checksum_help(struct sk_buff *skb)
+{
+	SKB_TRACE(skb);
+	SKB_TODO();
+}
+
+static inline bool
+skb_ensure_writable(struct sk_buff *skb, size_t off)
+{
+	SKB_TRACE(skb);
+	SKB_TODO();
+	return (false);
+}
+
+static inline void *
+skb_frag_address(const skb_frag_t *frag)
+{
+	SKB_TRACE(frag);
+	SKB_TODO();
+	return (NULL);
+}
+
+static inline struct sk_buff *
+skb_gso_segment(struct sk_buff *skb, netdev_features_t netdev_flags)
+{
+	SKB_TRACE(skb);
+	SKB_TODO();
+	return (NULL);
+}
+
+static inline bool
+skb_is_gso(struct sk_buff *skb)
+{
+	SKB_TRACE(skb);
+	SKB_TODO();
+	return (false);
+}
+
+static inline void
+skb_mark_not_on_list(struct sk_buff *skb)
+{
+	SKB_TRACE(skb);
+	SKB_TODO();
+}
+
+static inline void
+skb_queue_splice_init(struct sk_buff_head *qa, struct sk_buff_head *qb)
+{
+	SKB_TRACE2(qa, qb);
+	SKB_TODO();
+}
+
+static inline void
+skb_reset_transport_header(struct sk_buff *skb)
+{
+
+	SKB_TRACE(skb);
+	skb->l4hdroff = skb->data - skb->head;
+}
+
+static inline uint8_t *
+skb_transport_header(struct sk_buff *skb)
+{
+
+	SKB_TRACE(skb);
+        return (skb->head + skb->l4hdroff);
+}
+
+static inline uint8_t *
+skb_network_header(struct sk_buff *skb)
+{
+
+	SKB_TRACE(skb);
+        return (skb->head + skb->l3hdroff);
+}
+
+static inline int
+__skb_linearize(struct sk_buff *skb)
+{
+	SKB_TRACE(skb);
+	SKB_TODO();
+	return (ENXIO);
+}
+
+static inline bool
+pskb_expand_head(struct sk_buff *skb, int x, int len, gfp_t gfp)
+{
+	SKB_TRACE(skb);
+	SKB_TODO();
+	return (false);
+}
+
+/* Not really seen this one but need it as symmetric accessor function. */
+static inline void
+skb_set_queue_mapping(struct sk_buff *skb, uint16_t qmap)
+{
+
+	SKB_TRACE_FMT(skb, "qmap %u", qmap);
+	skb->qmap = qmap;
+}
+
+static inline uint16_t
+skb_get_queue_mapping(struct sk_buff *skb)
+{
+
+	SKB_TRACE_FMT(skb, "qmap %u", skb->qmap);
+	return (skb->qmap);
+}
+
+static inline bool
+skb_header_cloned(struct sk_buff *skb)
+{
+	SKB_TRACE(skb);
+	SKB_TODO();
+	return (false);
+}
+
+static inline uint8_t *
+skb_mac_header(struct sk_buff *skb)
+{
+	SKB_TRACE(skb);
+	SKB_TODO();
+	return (NULL);
+}
+
+static inline void
+skb_orphan(struct sk_buff *skb)
+{
+	SKB_TRACE(skb);
+	SKB_TODO();
+}
+
+static inline void
+skb_reset_mac_header(struct sk_buff *skb)
+{
+	SKB_TRACE(skb);
+	SKB_TODO();
+}
+
+static inline struct sk_buff *
+skb_peek(struct sk_buff_head *q)
+{
+	SKB_TRACE(q);
+	SKB_TODO();
+	return (NULL);
+}
+
+static inline __sum16
+csum_unfold(__sum16 sum)
+{
+	SKB_TODO();
+	return (sum);
+}
+
+#endif	/* _LINUXKPI_LINUX_SKBUFF_H */
diff --git a/sys/compat/linuxkpi/common/src/linux_skbuff.c b/sys/compat/linuxkpi/common/src/linux_skbuff.c
new file mode 100644
index 000000000000..e9935e65b466
--- /dev/null
+++ b/sys/compat/linuxkpi/common/src/linux_skbuff.c
@@ -0,0 +1,113 @@
+/*-
+ * Copyright (c) 2020-2021 The FreeBSD Foundation
+ * Copyright (c) 2021 Bjoern A. Zeeb
+ *
+ * This software was developed by Björn Zeeb under sponsorship from
+ * the FreeBSD Foundation.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/*
+ * NOTE: this socket buffer compatibility code is highly EXPERIMENTAL.
+ *       Do not rely on the internals of this implementation.  They are highly
+ *       likely to change as we will improve the integration to FreeBSD mbufs.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/kernel.h>
+#include <sys/malloc.h>
+
+#include <linux/skbuff.h>
+#include <linux/slab.h>
+
+static MALLOC_DEFINE(M_LKPISKB, "lkpiskb", "Linux KPI skbuff compat");
+
+struct sk_buff *
+linuxkpi_alloc_skb(size_t size, gfp_t gfp)
+{
+	struct sk_buff *skb;
+	size_t len;
+
+	len = sizeof(*skb) + size + sizeof(struct skb_shared_info);
+	/*
+	 * Using or own type here not backing my kmalloc.
+	 * We assume no one calls kfree directly on the skb.
+	 */
+	skb = malloc(len, M_LKPISKB, linux_check_m_flags(gfp) | M_ZERO);
+	if (skb == NULL)
+		return (skb);
+	skb->_alloc_len = size;
+	skb->truesize = size;
+
+	skb->head = skb->data = skb->tail = (uint8_t *)(skb+1);
+	skb->end = skb->head + size;
+
+	skb->shinfo = (struct skb_shared_info *)(skb->end);
+
+	SKB_TRACE_FMT(skb, "data %p size %zu", skb->data, size);
+	return (skb);
+}
+
+void
+linuxkpi_kfree_skb(struct sk_buff *skb)
+{
+	struct skb_shared_info *shinfo;
+	uint16_t fragno;
+
+	SKB_TRACE(skb);
+	if (skb == NULL)
+		return;
+
+	/*
+	 * XXX TODO this will go away once we have skb backed by mbuf.
+	 * currently we allow the mbuf to stay around and use a private
+	 * free function to allow secondary resources to be freed along.
+	 */
+	if (skb->m != NULL) {
+		void *m;
+
+		m = skb->m;
+		skb->m = NULL;
+
+		KASSERT(skb->m_free_func != NULL, ("%s: skb %p has m %p but no "
+		    "m_free_func %p\n", __func__, skb, m, skb->m_free_func));
+		skb->m_free_func(m);
+	}
+	KASSERT(skb->m == NULL,
+	    ("%s: skb %p m %p != NULL\n", __func__, skb, skb->m));
+
+	shinfo = skb->shinfo;
+	for (fragno = 0; fragno < nitems(shinfo->frags); fragno++) {
+
+		if (shinfo->frags[fragno].page != NULL)
+			__free_page(shinfo->frags[fragno].page);
+	}
+
+	free(skb, M_LKPISKB);
+}
diff --git a/sys/conf/files b/sys/conf/files
index 0d0fbaf10170..00ae10cf0e6e 100644
--- a/sys/conf/files
+++ b/sys/conf/files
*** 21 LINES SKIPPED ***