include/linux/skb_array.h

   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
  29 struct 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  */
  36 static inline bool __skb_array_full(struct skb_array *a)
  37 {
  38         return __ptr_ring_full(&a->ring);
  39 }
  40
  41 static inline bool skb_array_full(struct skb_array *a)
  42 {
  43         return ptr_ring_full(&a->ring);
  44 }
  45
  46 static inline int skb_array_produce(struct skb_array *a, struct sk_buff *skb)
  47 {
  48         return ptr_ring_produce(&a->ring, skb);
  49 }
  50
  51 static 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
  56 static 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
  61 static 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  */
  70 static inline bool __skb_array_empty(struct skb_array *a)
  71 {
  72         return __ptr_ring_empty(&a->ring);
  73 }
  74
  75 static inline struct sk_buff *__skb_array_peek(struct skb_array *a)
  76 {
  77         return __ptr_ring_peek(&a->ring);
  78 }
  79
  80 static inline bool skb_array_empty(struct skb_array *a)
  81 {
  82         return ptr_ring_empty(&a->ring);
  83 }
  84
  85 static inline bool skb_array_empty_bh(struct skb_array *a)
  86 {
  87         return ptr_ring_empty_bh(&a->ring);
  88 }
  89
  90 static inline bool skb_array_empty_irq(struct skb_array *a)
  91 {
  92         return ptr_ring_empty_irq(&a->ring);
  93 }
  94
  95 static inline bool skb_array_empty_any(struct skb_array *a)
  96 {
  97         return ptr_ring_empty_any(&a->ring);
  98 }
  99
 100 static inline struct sk_buff *__skb_array_consume(struct skb_array *a)
 101 {
 102         return __ptr_ring_consume(&a->ring);
 103 }
 104
 105 static inline struct sk_buff *skb_array_consume(struct skb_array *a)
 106 {
 107         return ptr_ring_consume(&a->ring);
 108 }
 109
 110 static inline int skb_array_consume_batched(struct skb_array *a,
 111                                             struct sk_buff **array, int n)
 112 {
 113         return ptr_ring_consume_batched(&a->ring, (void **)array, n);
 114 }
 115
 116 static inline struct sk_buff *skb_array_consume_irq(struct skb_array *a)
 117 {
 118         return ptr_ring_consume_irq(&a->ring);
 119 }
 120
 121 static inline int skb_array_consume_batched_irq(struct skb_array *a,
 122                                                 struct sk_buff **array, int n)
 123 {
 124         return ptr_ring_consume_batched_irq(&a->ring, (void **)array, n);
 125 }
 126
 127 static inline struct sk_buff *skb_array_consume_any(struct skb_array *a)
 128 {
 129         return ptr_ring_consume_any(&a->ring);
 130 }
 131
 132 static inline int skb_array_consume_batched_any(struct skb_array *a,
 133                                                 struct sk_buff **array, int n)
 134 {
 135         return ptr_ring_consume_batched_any(&a->ring, (void **)array, n);
 136 }
 137
 138
 139 static inline struct sk_buff *skb_array_consume_bh(struct skb_array *a)
 140 {
 141         return ptr_ring_consume_bh(&a->ring);
 142 }
 143
 144 static inline int skb_array_consume_batched_bh(struct skb_array *a,
 145                                                struct sk_buff **array, int n)
 146 {
 147         return ptr_ring_consume_batched_bh(&a->ring, (void **)array, n);
 148 }
 149
 150 static inline int __skb_array_len_with_tag(struct sk_buff *skb)
 151 {
 152         if (likely(skb)) {
 153                 int len = skb->len;
 154
 155                 if (skb_vlan_tag_present(skb))
 156                         len += VLAN_HLEN;
 157
 158                 return len;
 159         } else {
 160                 return 0;
 161         }
 162 }
 163
 164 static inline int skb_array_peek_len(struct skb_array *a)
 165 {
 166         return PTR_RING_PEEK_CALL(&a->ring, __skb_array_len_with_tag);
 167 }
 168
 169 static inline int skb_array_peek_len_irq(struct skb_array *a)
 170 {
 171         return PTR_RING_PEEK_CALL_IRQ(&a->ring, __skb_array_len_with_tag);
 172 }
 173
 174 static inline int skb_array_peek_len_bh(struct skb_array *a)
 175 {
 176         return PTR_RING_PEEK_CALL_BH(&a->ring, __skb_array_len_with_tag);
 177 }
 178
 179 static inline int skb_array_peek_len_any(struct skb_array *a)
 180 {
 181         return PTR_RING_PEEK_CALL_ANY(&a->ring, __skb_array_len_with_tag);
 182 }
 183
 184 static inline int skb_array_init(struct skb_array *a, int size, gfp_t gfp)
 185 {
 186         return ptr_ring_init(&a->ring, size, gfp);
 187 }
 188
 189 static void __skb_array_destroy_skb(void *ptr)
 190 {
 191         kfree_skb(ptr);
 192 }
 193
 194 static inline void skb_array_unconsume(struct skb_array *a,
 195                                        struct sk_buff **skbs, int n)
 196 {
 197         ptr_ring_unconsume(&a->ring, (void **)skbs, n, __skb_array_destroy_skb);
 198 }
 199
 200 static inline int skb_array_resize(struct skb_array *a, int size, gfp_t gfp)
 201 {
 202         return ptr_ring_resize(&a->ring, size, gfp, __skb_array_destroy_skb);
 203 }
 204
 205 static inline int skb_array_resize_multiple(struct skb_array **rings,
 206                                             int nrings, unsigned int size,
 207                                             gfp_t gfp)
 208 {
 209         BUILD_BUG_ON(offsetof(struct skb_array, ring));
 210         return ptr_ring_resize_multiple((struct ptr_ring **)rings,
 211                                         nrings, size, gfp,
 212                                         __skb_array_destroy_skb);
 213 }
 214
 215 static inline void skb_array_cleanup(struct skb_array *a)
 216 {
 217         ptr_ring_cleanup(&a->ring, __skb_array_destroy_skb);
 218 }
 219
 220 #endif /* _LINUX_SKB_ARRAY_H  */