LXR linux/include/linux/skb

   1/*
   2 *      Definitions for the 'struct skb_array' datastructure.
   3 *
   4 *      Author:
   5 *              Michael S. Tsirkin <mst@redhat.com>
   6 *
   7 *      Copyright (C) 2016 Red Hat, Inc.
   8 *
   9 *      This program is free software; you can redistribute it and/or modify it
  10 *      under the terms of the GNU General Public License as published by the
  11 *      Free Software Foundation; either version 2 of the License, or (at your
  12 *      option) any later version.
  13 *
  14 *      Limited-size FIFO of skbs. Can be used more or less whenever
  15 *      sk_buff_head can be used, except you need to know the queue size in
  16 *      advance.
  17 *      Implemented as a type-safe wrapper around ptr_ring.
  18 */
  19
  20#ifndef _LINUX_SKB_ARRAY_H
  21#define _LINUX_SKB_ARRAY_H 1
  22
  23#ifdef __KERNEL__
  24#include <linux/ptr_ring.h>
  25#include <linux/skbuff.h>
  26#include <linux/if_vlan.h>
  27#endif
  28
  29struct skb_array {
  30        struct ptr_ring ring;
  31};
  32
  33/* Might be slightly faster than skb_array_full below, but callers invoking
  34 * this in a loop must use a compiler barrier, for example cpu_relax().
  35 */
  36static inline bool __skb_array_full(struct skb_array *a)
  37{
  38        return __ptr_ring_full(&a->ring);
  39}
  40
  41static inline bool skb_array_full(struct skb_array *a)
  42{
  43        return ptr_ring_full(&a->ring);
  44}
  45
  46static inline int skb_array_produce(struct skb_array *a, struct sk_buff *skb)
  47{
  48        return ptr_ring_produce(&a->ring, skb);
  49}
  50
  51static inline int skb_array_produce_irq(struct skb_array *a, struct sk_buff *skb)
  52{
  53        return ptr_ring_produce_irq(&a->ring, skb);
  54}
  55
  56static inline int skb_array_produce_bh(struct skb_array *a, struct sk_buff *skb)
  57{
  58        return ptr_ring_produce_bh(&a->ring, skb);
  59}
  60
  61static inline int skb_array_produce_any(struct skb_array *a, struct sk_buff *skb)
  62{
  63        return ptr_ring_produce_any(&a->ring, skb);
  64}
  65
  66/* Might be slightly faster than skb_array_empty below, but only safe if the
  67 * array is never resized. Also, callers invoking this in a loop must take care
  68 * to use a compiler barrier, for example cpu_relax().
  69 */
  70static inline bool __skb_array_empty(struct skb_array *a)
  71{
  72        return !__ptr_ring_peek(&a->ring);
  73}
  74
  75static inline bool skb_array_empty(struct skb_array *a)
  76{
  77        return ptr_ring_empty(&a->ring);
  78}
  79
  80static inline bool skb_array_empty_bh(struct skb_array *a)
  81{
  82        return ptr_ring_empty_bh(&a->ring);
  83}
  84
  85static inline bool skb_array_empty_irq(struct skb_array *a)
  86{
  87        return ptr_ring_empty_irq(&a->ring);
  88}
  89
  90static inline bool skb_array_empty_any(struct skb_array *a)
  91{
  92        return ptr_ring_empty_any(&a->ring);
  93}
  94
  95static inline struct sk_buff *skb_array_consume(struct skb_array *a)
  96{
  97        return ptr_ring_consume(&a->ring);
  98}
  99
 100static inline struct sk_buff *skb_array_consume_irq(struct skb_array *a)
 101{
 102        return ptr_ring_consume_irq(&a->ring);
 103}
 104
 105static inline struct sk_buff *skb_array_consume_any(struct skb_array *a)
 106{
 107        return ptr_ring_consume_any(&a->ring);
 108}
 109
 110static inline struct sk_buff *skb_array_consume_bh(struct skb_array *a)
 111{
 112        return ptr_ring_consume_bh(&a->ring);
 113}
 114
 115static inline int __skb_array_len_with_tag(struct sk_buff *skb)
 116{
 117        if (likely(skb)) {
 118                int len = skb->len;
 119
 120                if (skb_vlan_tag_present(skb))
 121                        len += VLAN_HLEN;
 122
 123                return len;
 124        } else {
 125                return 0;
 126        }
 127}
 128
 129static inline int skb_array_peek_len(struct skb_array *a)
 130{
 131        return PTR_RING_PEEK_CALL(&a->ring, __skb_array_len_with_tag);
 132}
 133
 134static inline int skb_array_peek_len_irq(struct skb_array *a)
 135{
 136        return PTR_RING_PEEK_CALL_IRQ(&a->ring, __skb_array_len_with_tag);
 137}
 138
 139static inline int skb_array_peek_len_bh(struct skb_array *a)
 140{
 141        return PTR_RING_PEEK_CALL_BH(&a->ring, __skb_array_len_with_tag);
 142}
 143
 144static inline int skb_array_peek_len_any(struct skb_array *a)
 145{
 146        return PTR_RING_PEEK_CALL_ANY(&a->ring, __skb_array_len_with_tag);
 147}
 148
 149static inline int skb_array_init(struct skb_array *a, int size, gfp_t gfp)
 150{
 151        return ptr_ring_init(&a->ring, size, gfp);
 152}
 153
 154static void __skb_array_destroy_skb(void *ptr)
 155{
 156        kfree_skb(ptr);
 157}
 158
 159static inline int skb_array_resize(struct skb_array *a, int size, gfp_t gfp)
 160{
 161        return ptr_ring_resize(&a->ring, size, gfp, __skb_array_destroy_skb);
 162}
 163
 164static inline int skb_array_resize_multiple(struct skb_array **rings,
 165                                            int nrings, int size, gfp_t gfp)
 166{
 167        BUILD_BUG_ON(offsetof(struct skb_array, ring));
 168        return ptr_ring_resize_multiple((struct ptr_ring **)rings,
 169                                        nrings, size, gfp,
 170                                        __skb_array_destroy_skb);
 171}
 172
 173static inline void skb_array_cleanup(struct skb_array *a)
 174{
 175        ptr_ring_cleanup(&a->ring, __skb_array_destroy_skb);
 176}
 177
 178#endif /* _LINUX_SKB_ARRAY_H  */
 179