git: 508c4fb4c34b - stable/13 - LinuxKPI: add a work-in-progress skbuff implementation
- Go to: [ bottom of page ] [ top of archives ] [ this month ]
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 ***