~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/skb_array.h

Version: ~ [ linux-5.5-rc7 ] ~ [ linux-5.4.13 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.97 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.166 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.210 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.210 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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  */
221 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp