xref: /linux-6.15/include/linux/skb_array.h (revision cf4a7207) 
1 /*
2  *	Definitions for the 'struct skb_array' datastructure.
3  *
4  *	Author:
5  *		Michael S. Tsirkin <[email protected]>
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_peek(&a->ring);
73 }
74 
75 static inline bool skb_array_empty(struct skb_array *a)
76 {
77 	return ptr_ring_empty(&a->ring);
78 }
79 
80 static inline bool skb_array_empty_bh(struct skb_array *a)
81 {
82 	return ptr_ring_empty_bh(&a->ring);
83 }
84 
85 static inline bool skb_array_empty_irq(struct skb_array *a)
86 {
87 	return ptr_ring_empty_irq(&a->ring);
88 }
89 
90 static inline bool skb_array_empty_any(struct skb_array *a)
91 {
92 	return ptr_ring_empty_any(&a->ring);
93 }
94 
95 static inline struct sk_buff *skb_array_consume(struct skb_array *a)
96 {
97 	return ptr_ring_consume(&a->ring);
98 }
99 
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 
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 
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 
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 
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 
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 
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 
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 
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 
154 static void __skb_array_destroy_skb(void *ptr)
155 {
156 	kfree_skb(ptr);
157 }
158 
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 
164 static 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 
173 static 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