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 */
__skb_array_full(struct skb_array * a)36 static inline bool __skb_array_full(struct skb_array *a)
37 {
38 return __ptr_ring_full(&a->ring);
39 }
40
skb_array_full(struct skb_array * a)41 static inline bool skb_array_full(struct skb_array *a)
42 {
43 return ptr_ring_full(&a->ring);
44 }
45
skb_array_produce(struct skb_array * a,struct sk_buff * skb)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
skb_array_produce_irq(struct skb_array * a,struct sk_buff * skb)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
skb_array_produce_bh(struct skb_array * a,struct sk_buff * skb)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
skb_array_produce_any(struct skb_array * a,struct sk_buff * skb)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 */
__skb_array_empty(struct skb_array * a)70 static inline bool __skb_array_empty(struct skb_array *a)
71 {
72 return !__ptr_ring_peek(&a->ring);
73 }
74
skb_array_empty(struct skb_array * a)75 static inline bool skb_array_empty(struct skb_array *a)
76 {
77 return ptr_ring_empty(&a->ring);
78 }
79
skb_array_empty_bh(struct skb_array * a)80 static inline bool skb_array_empty_bh(struct skb_array *a)
81 {
82 return ptr_ring_empty_bh(&a->ring);
83 }
84
skb_array_empty_irq(struct skb_array * a)85 static inline bool skb_array_empty_irq(struct skb_array *a)
86 {
87 return ptr_ring_empty_irq(&a->ring);
88 }
89
skb_array_empty_any(struct skb_array * a)90 static inline bool skb_array_empty_any(struct skb_array *a)
91 {
92 return ptr_ring_empty_any(&a->ring);
93 }
94
skb_array_consume(struct skb_array * a)95 static inline struct sk_buff *skb_array_consume(struct skb_array *a)
96 {
97 return ptr_ring_consume(&a->ring);
98 }
99
skb_array_consume_irq(struct skb_array * a)100 static inline struct sk_buff *skb_array_consume_irq(struct skb_array *a)
101 {
102 return ptr_ring_consume_irq(&a->ring);
103 }
104
skb_array_consume_any(struct skb_array * a)105 static inline struct sk_buff *skb_array_consume_any(struct skb_array *a)
106 {
107 return ptr_ring_consume_any(&a->ring);
108 }
109
skb_array_consume_bh(struct skb_array * a)110 static inline struct sk_buff *skb_array_consume_bh(struct skb_array *a)
111 {
112 return ptr_ring_consume_bh(&a->ring);
113 }
114
__skb_array_len_with_tag(struct sk_buff * skb)115 static 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
skb_array_peek_len(struct skb_array * a)129 static 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
skb_array_peek_len_irq(struct skb_array * a)134 static 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
skb_array_peek_len_bh(struct skb_array * a)139 static 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
skb_array_peek_len_any(struct skb_array * a)144 static 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
skb_array_init(struct skb_array * a,int size,gfp_t gfp)149 static 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
__skb_array_destroy_skb(void * ptr)154 static void __skb_array_destroy_skb(void *ptr)
155 {
156 kfree_skb(ptr);
157 }
158
skb_array_resize(struct skb_array * a,int size,gfp_t gfp)159 static 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
skb_array_resize_multiple(struct skb_array ** rings,int nrings,unsigned int size,gfp_t gfp)164 static inline int skb_array_resize_multiple(struct skb_array **rings,
165 int nrings, unsigned int size,
166 gfp_t gfp)
167 {
168 BUILD_BUG_ON(offsetof(struct skb_array, ring));
169 return ptr_ring_resize_multiple((struct ptr_ring **)rings,
170 nrings, size, gfp,
171 __skb_array_destroy_skb);
172 }
173
skb_array_cleanup(struct skb_array * a)174 static inline void skb_array_cleanup(struct skb_array *a)
175 {
176 ptr_ring_cleanup(&a->ring, __skb_array_destroy_skb);
177 }
178
179 #endif /* _LINUX_SKB_ARRAY_H */
180