1 | /* |
2 | * A generic kernel FIFO implementation |
3 | * |
4 | * Copyright (C) 2013 Stefani Seibold <stefani@seibold.net> |
5 | * |
6 | * This program is free software; you can redistribute it and/or modify |
7 | * it under the terms of the GNU General Public License as published by |
8 | * the Free Software Foundation; either version 2 of the License, or |
9 | * (at your option) any later version. |
10 | * |
11 | * This program is distributed in the hope that it will be useful, |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
14 | * GNU General Public License for more details. |
15 | * |
16 | * You should have received a copy of the GNU General Public License |
17 | * along with this program; if not, write to the Free Software |
18 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
19 | * |
20 | */ |
21 | |
22 | #ifndef _LINUX_KFIFO_H |
23 | #define _LINUX_KFIFO_H |
24 | |
25 | /* |
26 | * How to porting drivers to the new generic FIFO API: |
27 | * |
28 | * - Modify the declaration of the "struct kfifo *" object into a |
29 | * in-place "struct kfifo" object |
30 | * - Init the in-place object with kfifo_alloc() or kfifo_init() |
31 | * Note: The address of the in-place "struct kfifo" object must be |
32 | * passed as the first argument to this functions |
33 | * - Replace the use of __kfifo_put into kfifo_in and __kfifo_get |
34 | * into kfifo_out |
35 | * - Replace the use of kfifo_put into kfifo_in_spinlocked and kfifo_get |
36 | * into kfifo_out_spinlocked |
37 | * Note: the spinlock pointer formerly passed to kfifo_init/kfifo_alloc |
38 | * must be passed now to the kfifo_in_spinlocked and kfifo_out_spinlocked |
39 | * as the last parameter |
40 | * - The formerly __kfifo_* functions are renamed into kfifo_* |
41 | */ |
42 | |
43 | /* |
44 | * Note about locking: There is no locking required until only one reader |
45 | * and one writer is using the fifo and no kfifo_reset() will be called. |
46 | * kfifo_reset_out() can be safely used, until it will be only called |
47 | * in the reader thread. |
48 | * For multiple writer and one reader there is only a need to lock the writer. |
49 | * And vice versa for only one writer and multiple reader there is only a need |
50 | * to lock the reader. |
51 | */ |
52 | |
53 | #include <linux/kernel.h> |
54 | #include <linux/spinlock.h> |
55 | #include <linux/stddef.h> |
56 | #include <linux/scatterlist.h> |
57 | |
58 | struct __kfifo { |
59 | unsigned int in; |
60 | unsigned int out; |
61 | unsigned int mask; |
62 | unsigned int esize; |
63 | void *data; |
64 | }; |
65 | |
66 | #define __STRUCT_KFIFO_COMMON(datatype, recsize, ptrtype) \ |
67 | union { \ |
68 | struct __kfifo kfifo; \ |
69 | datatype *type; \ |
70 | const datatype *const_type; \ |
71 | char (*rectype)[recsize]; \ |
72 | ptrtype *ptr; \ |
73 | ptrtype const *ptr_const; \ |
74 | } |
75 | |
76 | #define __STRUCT_KFIFO(type, size, recsize, ptrtype) \ |
77 | { \ |
78 | __STRUCT_KFIFO_COMMON(type, recsize, ptrtype); \ |
79 | type buf[((size < 2) || (size & (size - 1))) ? -1 : size]; \ |
80 | } |
81 | |
82 | #define STRUCT_KFIFO(type, size) \ |
83 | struct __STRUCT_KFIFO(type, size, 0, type) |
84 | |
85 | #define __STRUCT_KFIFO_PTR(type, recsize, ptrtype) \ |
86 | { \ |
87 | __STRUCT_KFIFO_COMMON(type, recsize, ptrtype); \ |
88 | type buf[0]; \ |
89 | } |
90 | |
91 | #define STRUCT_KFIFO_PTR(type) \ |
92 | struct __STRUCT_KFIFO_PTR(type, 0, type) |
93 | |
94 | /* |
95 | * define compatibility "struct kfifo" for dynamic allocated fifos |
96 | */ |
97 | struct kfifo __STRUCT_KFIFO_PTR(unsigned char, 0, void); |
98 | |
99 | #define STRUCT_KFIFO_REC_1(size) \ |
100 | struct __STRUCT_KFIFO(unsigned char, size, 1, void) |
101 | |
102 | #define STRUCT_KFIFO_REC_2(size) \ |
103 | struct __STRUCT_KFIFO(unsigned char, size, 2, void) |
104 | |
105 | /* |
106 | * define kfifo_rec types |
107 | */ |
108 | struct kfifo_rec_ptr_1 __STRUCT_KFIFO_PTR(unsigned char, 1, void); |
109 | struct kfifo_rec_ptr_2 __STRUCT_KFIFO_PTR(unsigned char, 2, void); |
110 | |
111 | /* |
112 | * helper macro to distinguish between real in place fifo where the fifo |
113 | * array is a part of the structure and the fifo type where the array is |
114 | * outside of the fifo structure. |
115 | */ |
116 | #define __is_kfifo_ptr(fifo) \ |
117 | (sizeof(*fifo) == sizeof(STRUCT_KFIFO_PTR(typeof(*(fifo)->type)))) |
118 | |
119 | /** |
120 | * DECLARE_KFIFO_PTR - macro to declare a fifo pointer object |
121 | * @fifo: name of the declared fifo |
122 | * @type: type of the fifo elements |
123 | */ |
124 | #define DECLARE_KFIFO_PTR(fifo, type) STRUCT_KFIFO_PTR(type) fifo |
125 | |
126 | /** |
127 | * DECLARE_KFIFO - macro to declare a fifo object |
128 | * @fifo: name of the declared fifo |
129 | * @type: type of the fifo elements |
130 | * @size: the number of elements in the fifo, this must be a power of 2 |
131 | */ |
132 | #define DECLARE_KFIFO(fifo, type, size) STRUCT_KFIFO(type, size) fifo |
133 | |
134 | /** |
135 | * INIT_KFIFO - Initialize a fifo declared by DECLARE_KFIFO |
136 | * @fifo: name of the declared fifo datatype |
137 | */ |
138 | #define INIT_KFIFO(fifo) \ |
139 | (void)({ \ |
140 | typeof(&(fifo)) __tmp = &(fifo); \ |
141 | struct __kfifo *__kfifo = &__tmp->kfifo; \ |
142 | __kfifo->in = 0; \ |
143 | __kfifo->out = 0; \ |
144 | __kfifo->mask = __is_kfifo_ptr(__tmp) ? 0 : ARRAY_SIZE(__tmp->buf) - 1;\ |
145 | __kfifo->esize = sizeof(*__tmp->buf); \ |
146 | __kfifo->data = __is_kfifo_ptr(__tmp) ? NULL : __tmp->buf; \ |
147 | }) |
148 | |
149 | /** |
150 | * DEFINE_KFIFO - macro to define and initialize a fifo |
151 | * @fifo: name of the declared fifo datatype |
152 | * @type: type of the fifo elements |
153 | * @size: the number of elements in the fifo, this must be a power of 2 |
154 | * |
155 | * Note: the macro can be used for global and local fifo data type variables. |
156 | */ |
157 | #define DEFINE_KFIFO(fifo, type, size) \ |
158 | DECLARE_KFIFO(fifo, type, size) = \ |
159 | (typeof(fifo)) { \ |
160 | { \ |
161 | { \ |
162 | .in = 0, \ |
163 | .out = 0, \ |
164 | .mask = __is_kfifo_ptr(&(fifo)) ? \ |
165 | 0 : \ |
166 | ARRAY_SIZE((fifo).buf) - 1, \ |
167 | .esize = sizeof(*(fifo).buf), \ |
168 | .data = __is_kfifo_ptr(&(fifo)) ? \ |
169 | NULL : \ |
170 | (fifo).buf, \ |
171 | } \ |
172 | } \ |
173 | } |
174 | |
175 | |
176 | static inline unsigned int __must_check |
177 | __kfifo_uint_must_check_helper(unsigned int val) |
178 | { |
179 | return val; |
180 | } |
181 | |
182 | static inline int __must_check |
183 | __kfifo_int_must_check_helper(int val) |
184 | { |
185 | return val; |
186 | } |
187 | |
188 | /** |
189 | * kfifo_initialized - Check if the fifo is initialized |
190 | * @fifo: address of the fifo to check |
191 | * |
192 | * Return %true if fifo is initialized, otherwise %false. |
193 | * Assumes the fifo was 0 before. |
194 | */ |
195 | #define kfifo_initialized(fifo) ((fifo)->kfifo.mask) |
196 | |
197 | /** |
198 | * kfifo_esize - returns the size of the element managed by the fifo |
199 | * @fifo: address of the fifo to be used |
200 | */ |
201 | #define kfifo_esize(fifo) ((fifo)->kfifo.esize) |
202 | |
203 | /** |
204 | * kfifo_recsize - returns the size of the record length field |
205 | * @fifo: address of the fifo to be used |
206 | */ |
207 | #define kfifo_recsize(fifo) (sizeof(*(fifo)->rectype)) |
208 | |
209 | /** |
210 | * kfifo_size - returns the size of the fifo in elements |
211 | * @fifo: address of the fifo to be used |
212 | */ |
213 | #define kfifo_size(fifo) ((fifo)->kfifo.mask + 1) |
214 | |
215 | /** |
216 | * kfifo_reset - removes the entire fifo content |
217 | * @fifo: address of the fifo to be used |
218 | * |
219 | * Note: usage of kfifo_reset() is dangerous. It should be only called when the |
220 | * fifo is exclusived locked or when it is secured that no other thread is |
221 | * accessing the fifo. |
222 | */ |
223 | #define kfifo_reset(fifo) \ |
224 | (void)({ \ |
225 | typeof((fifo) + 1) __tmp = (fifo); \ |
226 | __tmp->kfifo.in = __tmp->kfifo.out = 0; \ |
227 | }) |
228 | |
229 | /** |
230 | * kfifo_reset_out - skip fifo content |
231 | * @fifo: address of the fifo to be used |
232 | * |
233 | * Note: The usage of kfifo_reset_out() is safe until it will be only called |
234 | * from the reader thread and there is only one concurrent reader. Otherwise |
235 | * it is dangerous and must be handled in the same way as kfifo_reset(). |
236 | */ |
237 | #define kfifo_reset_out(fifo) \ |
238 | (void)({ \ |
239 | typeof((fifo) + 1) __tmp = (fifo); \ |
240 | __tmp->kfifo.out = __tmp->kfifo.in; \ |
241 | }) |
242 | |
243 | /** |
244 | * kfifo_len - returns the number of used elements in the fifo |
245 | * @fifo: address of the fifo to be used |
246 | */ |
247 | #define kfifo_len(fifo) \ |
248 | ({ \ |
249 | typeof((fifo) + 1) __tmpl = (fifo); \ |
250 | __tmpl->kfifo.in - __tmpl->kfifo.out; \ |
251 | }) |
252 | |
253 | /** |
254 | * kfifo_is_empty - returns true if the fifo is empty |
255 | * @fifo: address of the fifo to be used |
256 | */ |
257 | #define kfifo_is_empty(fifo) \ |
258 | ({ \ |
259 | typeof((fifo) + 1) __tmpq = (fifo); \ |
260 | __tmpq->kfifo.in == __tmpq->kfifo.out; \ |
261 | }) |
262 | |
263 | /** |
264 | * kfifo_is_full - returns true if the fifo is full |
265 | * @fifo: address of the fifo to be used |
266 | */ |
267 | #define kfifo_is_full(fifo) \ |
268 | ({ \ |
269 | typeof((fifo) + 1) __tmpq = (fifo); \ |
270 | kfifo_len(__tmpq) > __tmpq->kfifo.mask; \ |
271 | }) |
272 | |
273 | /** |
274 | * kfifo_avail - returns the number of unused elements in the fifo |
275 | * @fifo: address of the fifo to be used |
276 | */ |
277 | #define kfifo_avail(fifo) \ |
278 | __kfifo_uint_must_check_helper( \ |
279 | ({ \ |
280 | typeof((fifo) + 1) __tmpq = (fifo); \ |
281 | const size_t __recsize = sizeof(*__tmpq->rectype); \ |
282 | unsigned int __avail = kfifo_size(__tmpq) - kfifo_len(__tmpq); \ |
283 | (__recsize) ? ((__avail <= __recsize) ? 0 : \ |
284 | __kfifo_max_r(__avail - __recsize, __recsize)) : \ |
285 | __avail; \ |
286 | }) \ |
287 | ) |
288 | |
289 | /** |
290 | * kfifo_skip - skip output data |
291 | * @fifo: address of the fifo to be used |
292 | */ |
293 | #define kfifo_skip(fifo) \ |
294 | (void)({ \ |
295 | typeof((fifo) + 1) __tmp = (fifo); \ |
296 | const size_t __recsize = sizeof(*__tmp->rectype); \ |
297 | struct __kfifo *__kfifo = &__tmp->kfifo; \ |
298 | if (__recsize) \ |
299 | __kfifo_skip_r(__kfifo, __recsize); \ |
300 | else \ |
301 | __kfifo->out++; \ |
302 | }) |
303 | |
304 | /** |
305 | * kfifo_peek_len - gets the size of the next fifo record |
306 | * @fifo: address of the fifo to be used |
307 | * |
308 | * This function returns the size of the next fifo record in number of bytes. |
309 | */ |
310 | #define kfifo_peek_len(fifo) \ |
311 | __kfifo_uint_must_check_helper( \ |
312 | ({ \ |
313 | typeof((fifo) + 1) __tmp = (fifo); \ |
314 | const size_t __recsize = sizeof(*__tmp->rectype); \ |
315 | struct __kfifo *__kfifo = &__tmp->kfifo; \ |
316 | (!__recsize) ? kfifo_len(__tmp) * sizeof(*__tmp->type) : \ |
317 | __kfifo_len_r(__kfifo, __recsize); \ |
318 | }) \ |
319 | ) |
320 | |
321 | /** |
322 | * kfifo_alloc - dynamically allocates a new fifo buffer |
323 | * @fifo: pointer to the fifo |
324 | * @size: the number of elements in the fifo, this must be a power of 2 |
325 | * @gfp_mask: get_free_pages mask, passed to kmalloc() |
326 | * |
327 | * This macro dynamically allocates a new fifo buffer. |
328 | * |
329 | * The number of elements will be rounded-up to a power of 2. |
330 | * The fifo will be release with kfifo_free(). |
331 | * Return 0 if no error, otherwise an error code. |
332 | */ |
333 | #define kfifo_alloc(fifo, size, gfp_mask) \ |
334 | __kfifo_int_must_check_helper( \ |
335 | ({ \ |
336 | typeof((fifo) + 1) __tmp = (fifo); \ |
337 | struct __kfifo *__kfifo = &__tmp->kfifo; \ |
338 | __is_kfifo_ptr(__tmp) ? \ |
339 | __kfifo_alloc(__kfifo, size, sizeof(*__tmp->type), gfp_mask) : \ |
340 | -EINVAL; \ |
341 | }) \ |
342 | ) |
343 | |
344 | /** |
345 | * kfifo_free - frees the fifo |
346 | * @fifo: the fifo to be freed |
347 | */ |
348 | #define kfifo_free(fifo) \ |
349 | ({ \ |
350 | typeof((fifo) + 1) __tmp = (fifo); \ |
351 | struct __kfifo *__kfifo = &__tmp->kfifo; \ |
352 | if (__is_kfifo_ptr(__tmp)) \ |
353 | __kfifo_free(__kfifo); \ |
354 | }) |
355 | |
356 | /** |
357 | * kfifo_init - initialize a fifo using a preallocated buffer |
358 | * @fifo: the fifo to assign the buffer |
359 | * @buffer: the preallocated buffer to be used |
360 | * @size: the size of the internal buffer, this have to be a power of 2 |
361 | * |
362 | * This macro initializes a fifo using a preallocated buffer. |
363 | * |
364 | * The number of elements will be rounded-up to a power of 2. |
365 | * Return 0 if no error, otherwise an error code. |
366 | */ |
367 | #define kfifo_init(fifo, buffer, size) \ |
368 | ({ \ |
369 | typeof((fifo) + 1) __tmp = (fifo); \ |
370 | struct __kfifo *__kfifo = &__tmp->kfifo; \ |
371 | __is_kfifo_ptr(__tmp) ? \ |
372 | __kfifo_init(__kfifo, buffer, size, sizeof(*__tmp->type)) : \ |
373 | -EINVAL; \ |
374 | }) |
375 | |
376 | /** |
377 | * kfifo_put - put data into the fifo |
378 | * @fifo: address of the fifo to be used |
379 | * @val: the data to be added |
380 | * |
381 | * This macro copies the given value into the fifo. |
382 | * It returns 0 if the fifo was full. Otherwise it returns the number |
383 | * processed elements. |
384 | * |
385 | * Note that with only one concurrent reader and one concurrent |
386 | * writer, you don't need extra locking to use these macro. |
387 | */ |
388 | #define kfifo_put(fifo, val) \ |
389 | ({ \ |
390 | typeof((fifo) + 1) __tmp = (fifo); \ |
391 | typeof(*__tmp->const_type) __val = (val); \ |
392 | unsigned int __ret; \ |
393 | size_t __recsize = sizeof(*__tmp->rectype); \ |
394 | struct __kfifo *__kfifo = &__tmp->kfifo; \ |
395 | if (__recsize) \ |
396 | __ret = __kfifo_in_r(__kfifo, &__val, sizeof(__val), \ |
397 | __recsize); \ |
398 | else { \ |
399 | __ret = !kfifo_is_full(__tmp); \ |
400 | if (__ret) { \ |
401 | (__is_kfifo_ptr(__tmp) ? \ |
402 | ((typeof(__tmp->type))__kfifo->data) : \ |
403 | (__tmp->buf) \ |
404 | )[__kfifo->in & __tmp->kfifo.mask] = \ |
405 | *(typeof(__tmp->type))&__val; \ |
406 | smp_wmb(); \ |
407 | __kfifo->in++; \ |
408 | } \ |
409 | } \ |
410 | __ret; \ |
411 | }) |
412 | |
413 | /** |
414 | * kfifo_get - get data from the fifo |
415 | * @fifo: address of the fifo to be used |
416 | * @val: address where to store the data |
417 | * |
418 | * This macro reads the data from the fifo. |
419 | * It returns 0 if the fifo was empty. Otherwise it returns the number |
420 | * processed elements. |
421 | * |
422 | * Note that with only one concurrent reader and one concurrent |
423 | * writer, you don't need extra locking to use these macro. |
424 | */ |
425 | #define kfifo_get(fifo, val) \ |
426 | __kfifo_uint_must_check_helper( \ |
427 | ({ \ |
428 | typeof((fifo) + 1) __tmp = (fifo); \ |
429 | typeof(__tmp->ptr) __val = (val); \ |
430 | unsigned int __ret; \ |
431 | const size_t __recsize = sizeof(*__tmp->rectype); \ |
432 | struct __kfifo *__kfifo = &__tmp->kfifo; \ |
433 | if (__recsize) \ |
434 | __ret = __kfifo_out_r(__kfifo, __val, sizeof(*__val), \ |
435 | __recsize); \ |
436 | else { \ |
437 | __ret = !kfifo_is_empty(__tmp); \ |
438 | if (__ret) { \ |
439 | *(typeof(__tmp->type))__val = \ |
440 | (__is_kfifo_ptr(__tmp) ? \ |
441 | ((typeof(__tmp->type))__kfifo->data) : \ |
442 | (__tmp->buf) \ |
443 | )[__kfifo->out & __tmp->kfifo.mask]; \ |
444 | smp_wmb(); \ |
445 | __kfifo->out++; \ |
446 | } \ |
447 | } \ |
448 | __ret; \ |
449 | }) \ |
450 | ) |
451 | |
452 | /** |
453 | * kfifo_peek - get data from the fifo without removing |
454 | * @fifo: address of the fifo to be used |
455 | * @val: address where to store the data |
456 | * |
457 | * This reads the data from the fifo without removing it from the fifo. |
458 | * It returns 0 if the fifo was empty. Otherwise it returns the number |
459 | * processed elements. |
460 | * |
461 | * Note that with only one concurrent reader and one concurrent |
462 | * writer, you don't need extra locking to use these macro. |
463 | */ |
464 | #define kfifo_peek(fifo, val) \ |
465 | __kfifo_uint_must_check_helper( \ |
466 | ({ \ |
467 | typeof((fifo) + 1) __tmp = (fifo); \ |
468 | typeof(__tmp->ptr) __val = (val); \ |
469 | unsigned int __ret; \ |
470 | const size_t __recsize = sizeof(*__tmp->rectype); \ |
471 | struct __kfifo *__kfifo = &__tmp->kfifo; \ |
472 | if (__recsize) \ |
473 | __ret = __kfifo_out_peek_r(__kfifo, __val, sizeof(*__val), \ |
474 | __recsize); \ |
475 | else { \ |
476 | __ret = !kfifo_is_empty(__tmp); \ |
477 | if (__ret) { \ |
478 | *(typeof(__tmp->type))__val = \ |
479 | (__is_kfifo_ptr(__tmp) ? \ |
480 | ((typeof(__tmp->type))__kfifo->data) : \ |
481 | (__tmp->buf) \ |
482 | )[__kfifo->out & __tmp->kfifo.mask]; \ |
483 | smp_wmb(); \ |
484 | } \ |
485 | } \ |
486 | __ret; \ |
487 | }) \ |
488 | ) |
489 | |
490 | /** |
491 | * kfifo_in - put data into the fifo |
492 | * @fifo: address of the fifo to be used |
493 | * @buf: the data to be added |
494 | * @n: number of elements to be added |
495 | * |
496 | * This macro copies the given buffer into the fifo and returns the |
497 | * number of copied elements. |
498 | * |
499 | * Note that with only one concurrent reader and one concurrent |
500 | * writer, you don't need extra locking to use these macro. |
501 | */ |
502 | #define kfifo_in(fifo, buf, n) \ |
503 | ({ \ |
504 | typeof((fifo) + 1) __tmp = (fifo); \ |
505 | typeof(__tmp->ptr_const) __buf = (buf); \ |
506 | unsigned long __n = (n); \ |
507 | const size_t __recsize = sizeof(*__tmp->rectype); \ |
508 | struct __kfifo *__kfifo = &__tmp->kfifo; \ |
509 | (__recsize) ?\ |
510 | __kfifo_in_r(__kfifo, __buf, __n, __recsize) : \ |
511 | __kfifo_in(__kfifo, __buf, __n); \ |
512 | }) |
513 | |
514 | /** |
515 | * kfifo_in_spinlocked - put data into the fifo using a spinlock for locking |
516 | * @fifo: address of the fifo to be used |
517 | * @buf: the data to be added |
518 | * @n: number of elements to be added |
519 | * @lock: pointer to the spinlock to use for locking |
520 | * |
521 | * This macro copies the given values buffer into the fifo and returns the |
522 | * number of copied elements. |
523 | */ |
524 | #define kfifo_in_spinlocked(fifo, buf, n, lock) \ |
525 | ({ \ |
526 | unsigned long __flags; \ |
527 | unsigned int __ret; \ |
528 | spin_lock_irqsave(lock, __flags); \ |
529 | __ret = kfifo_in(fifo, buf, n); \ |
530 | spin_unlock_irqrestore(lock, __flags); \ |
531 | __ret; \ |
532 | }) |
533 | |
534 | /* alias for kfifo_in_spinlocked, will be removed in a future release */ |
535 | #define kfifo_in_locked(fifo, buf, n, lock) \ |
536 | kfifo_in_spinlocked(fifo, buf, n, lock) |
537 | |
538 | /** |
539 | * kfifo_out - get data from the fifo |
540 | * @fifo: address of the fifo to be used |
541 | * @buf: pointer to the storage buffer |
542 | * @n: max. number of elements to get |
543 | * |
544 | * This macro get some data from the fifo and return the numbers of elements |
545 | * copied. |
546 | * |
547 | * Note that with only one concurrent reader and one concurrent |
548 | * writer, you don't need extra locking to use these macro. |
549 | */ |
550 | #define kfifo_out(fifo, buf, n) \ |
551 | __kfifo_uint_must_check_helper( \ |
552 | ({ \ |
553 | typeof((fifo) + 1) __tmp = (fifo); \ |
554 | typeof(__tmp->ptr) __buf = (buf); \ |
555 | unsigned long __n = (n); \ |
556 | const size_t __recsize = sizeof(*__tmp->rectype); \ |
557 | struct __kfifo *__kfifo = &__tmp->kfifo; \ |
558 | (__recsize) ?\ |
559 | __kfifo_out_r(__kfifo, __buf, __n, __recsize) : \ |
560 | __kfifo_out(__kfifo, __buf, __n); \ |
561 | }) \ |
562 | ) |
563 | |
564 | /** |
565 | * kfifo_out_spinlocked - get data from the fifo using a spinlock for locking |
566 | * @fifo: address of the fifo to be used |
567 | * @buf: pointer to the storage buffer |
568 | * @n: max. number of elements to get |
569 | * @lock: pointer to the spinlock to use for locking |
570 | * |
571 | * This macro get the data from the fifo and return the numbers of elements |
572 | * copied. |
573 | */ |
574 | #define kfifo_out_spinlocked(fifo, buf, n, lock) \ |
575 | __kfifo_uint_must_check_helper( \ |
576 | ({ \ |
577 | unsigned long __flags; \ |
578 | unsigned int __ret; \ |
579 | spin_lock_irqsave(lock, __flags); \ |
580 | __ret = kfifo_out(fifo, buf, n); \ |
581 | spin_unlock_irqrestore(lock, __flags); \ |
582 | __ret; \ |
583 | }) \ |
584 | ) |
585 | |
586 | /* alias for kfifo_out_spinlocked, will be removed in a future release */ |
587 | #define kfifo_out_locked(fifo, buf, n, lock) \ |
588 | kfifo_out_spinlocked(fifo, buf, n, lock) |
589 | |
590 | /** |
591 | * kfifo_from_user - puts some data from user space into the fifo |
592 | * @fifo: address of the fifo to be used |
593 | * @from: pointer to the data to be added |
594 | * @len: the length of the data to be added |
595 | * @copied: pointer to output variable to store the number of copied bytes |
596 | * |
597 | * This macro copies at most @len bytes from the @from into the |
598 | * fifo, depending of the available space and returns -EFAULT/0. |
599 | * |
600 | * Note that with only one concurrent reader and one concurrent |
601 | * writer, you don't need extra locking to use these macro. |
602 | */ |
603 | #define kfifo_from_user(fifo, from, len, copied) \ |
604 | __kfifo_uint_must_check_helper( \ |
605 | ({ \ |
606 | typeof((fifo) + 1) __tmp = (fifo); \ |
607 | const void __user *__from = (from); \ |
608 | unsigned int __len = (len); \ |
609 | unsigned int *__copied = (copied); \ |
610 | const size_t __recsize = sizeof(*__tmp->rectype); \ |
611 | struct __kfifo *__kfifo = &__tmp->kfifo; \ |
612 | (__recsize) ? \ |
613 | __kfifo_from_user_r(__kfifo, __from, __len, __copied, __recsize) : \ |
614 | __kfifo_from_user(__kfifo, __from, __len, __copied); \ |
615 | }) \ |
616 | ) |
617 | |
618 | /** |
619 | * kfifo_to_user - copies data from the fifo into user space |
620 | * @fifo: address of the fifo to be used |
621 | * @to: where the data must be copied |
622 | * @len: the size of the destination buffer |
623 | * @copied: pointer to output variable to store the number of copied bytes |
624 | * |
625 | * This macro copies at most @len bytes from the fifo into the |
626 | * @to buffer and returns -EFAULT/0. |
627 | * |
628 | * Note that with only one concurrent reader and one concurrent |
629 | * writer, you don't need extra locking to use these macro. |
630 | */ |
631 | #define kfifo_to_user(fifo, to, len, copied) \ |
632 | __kfifo_uint_must_check_helper( \ |
633 | ({ \ |
634 | typeof((fifo) + 1) __tmp = (fifo); \ |
635 | void __user *__to = (to); \ |
636 | unsigned int __len = (len); \ |
637 | unsigned int *__copied = (copied); \ |
638 | const size_t __recsize = sizeof(*__tmp->rectype); \ |
639 | struct __kfifo *__kfifo = &__tmp->kfifo; \ |
640 | (__recsize) ? \ |
641 | __kfifo_to_user_r(__kfifo, __to, __len, __copied, __recsize) : \ |
642 | __kfifo_to_user(__kfifo, __to, __len, __copied); \ |
643 | }) \ |
644 | ) |
645 | |
646 | /** |
647 | * kfifo_dma_in_prepare - setup a scatterlist for DMA input |
648 | * @fifo: address of the fifo to be used |
649 | * @sgl: pointer to the scatterlist array |
650 | * @nents: number of entries in the scatterlist array |
651 | * @len: number of elements to transfer |
652 | * |
653 | * This macro fills a scatterlist for DMA input. |
654 | * It returns the number entries in the scatterlist array. |
655 | * |
656 | * Note that with only one concurrent reader and one concurrent |
657 | * writer, you don't need extra locking to use these macros. |
658 | */ |
659 | #define kfifo_dma_in_prepare(fifo, sgl, nents, len) \ |
660 | ({ \ |
661 | typeof((fifo) + 1) __tmp = (fifo); \ |
662 | struct scatterlist *__sgl = (sgl); \ |
663 | int __nents = (nents); \ |
664 | unsigned int __len = (len); \ |
665 | const size_t __recsize = sizeof(*__tmp->rectype); \ |
666 | struct __kfifo *__kfifo = &__tmp->kfifo; \ |
667 | (__recsize) ? \ |
668 | __kfifo_dma_in_prepare_r(__kfifo, __sgl, __nents, __len, __recsize) : \ |
669 | __kfifo_dma_in_prepare(__kfifo, __sgl, __nents, __len); \ |
670 | }) |
671 | |
672 | /** |
673 | * kfifo_dma_in_finish - finish a DMA IN operation |
674 | * @fifo: address of the fifo to be used |
675 | * @len: number of bytes to received |
676 | * |
677 | * This macro finish a DMA IN operation. The in counter will be updated by |
678 | * the len parameter. No error checking will be done. |
679 | * |
680 | * Note that with only one concurrent reader and one concurrent |
681 | * writer, you don't need extra locking to use these macros. |
682 | */ |
683 | #define kfifo_dma_in_finish(fifo, len) \ |
684 | (void)({ \ |
685 | typeof((fifo) + 1) __tmp = (fifo); \ |
686 | unsigned int __len = (len); \ |
687 | const size_t __recsize = sizeof(*__tmp->rectype); \ |
688 | struct __kfifo *__kfifo = &__tmp->kfifo; \ |
689 | if (__recsize) \ |
690 | __kfifo_dma_in_finish_r(__kfifo, __len, __recsize); \ |
691 | else \ |
692 | __kfifo->in += __len / sizeof(*__tmp->type); \ |
693 | }) |
694 | |
695 | /** |
696 | * kfifo_dma_out_prepare - setup a scatterlist for DMA output |
697 | * @fifo: address of the fifo to be used |
698 | * @sgl: pointer to the scatterlist array |
699 | * @nents: number of entries in the scatterlist array |
700 | * @len: number of elements to transfer |
701 | * |
702 | * This macro fills a scatterlist for DMA output which at most @len bytes |
703 | * to transfer. |
704 | * It returns the number entries in the scatterlist array. |
705 | * A zero means there is no space available and the scatterlist is not filled. |
706 | * |
707 | * Note that with only one concurrent reader and one concurrent |
708 | * writer, you don't need extra locking to use these macros. |
709 | */ |
710 | #define kfifo_dma_out_prepare(fifo, sgl, nents, len) \ |
711 | ({ \ |
712 | typeof((fifo) + 1) __tmp = (fifo); \ |
713 | struct scatterlist *__sgl = (sgl); \ |
714 | int __nents = (nents); \ |
715 | unsigned int __len = (len); \ |
716 | const size_t __recsize = sizeof(*__tmp->rectype); \ |
717 | struct __kfifo *__kfifo = &__tmp->kfifo; \ |
718 | (__recsize) ? \ |
719 | __kfifo_dma_out_prepare_r(__kfifo, __sgl, __nents, __len, __recsize) : \ |
720 | __kfifo_dma_out_prepare(__kfifo, __sgl, __nents, __len); \ |
721 | }) |
722 | |
723 | /** |
724 | * kfifo_dma_out_finish - finish a DMA OUT operation |
725 | * @fifo: address of the fifo to be used |
726 | * @len: number of bytes transferred |
727 | * |
728 | * This macro finish a DMA OUT operation. The out counter will be updated by |
729 | * the len parameter. No error checking will be done. |
730 | * |
731 | * Note that with only one concurrent reader and one concurrent |
732 | * writer, you don't need extra locking to use these macros. |
733 | */ |
734 | #define kfifo_dma_out_finish(fifo, len) \ |
735 | (void)({ \ |
736 | typeof((fifo) + 1) __tmp = (fifo); \ |
737 | unsigned int __len = (len); \ |
738 | const size_t __recsize = sizeof(*__tmp->rectype); \ |
739 | struct __kfifo *__kfifo = &__tmp->kfifo; \ |
740 | if (__recsize) \ |
741 | __kfifo_dma_out_finish_r(__kfifo, __recsize); \ |
742 | else \ |
743 | __kfifo->out += __len / sizeof(*__tmp->type); \ |
744 | }) |
745 | |
746 | /** |
747 | * kfifo_out_peek - gets some data from the fifo |
748 | * @fifo: address of the fifo to be used |
749 | * @buf: pointer to the storage buffer |
750 | * @n: max. number of elements to get |
751 | * |
752 | * This macro get the data from the fifo and return the numbers of elements |
753 | * copied. The data is not removed from the fifo. |
754 | * |
755 | * Note that with only one concurrent reader and one concurrent |
756 | * writer, you don't need extra locking to use these macro. |
757 | */ |
758 | #define kfifo_out_peek(fifo, buf, n) \ |
759 | __kfifo_uint_must_check_helper( \ |
760 | ({ \ |
761 | typeof((fifo) + 1) __tmp = (fifo); \ |
762 | typeof(__tmp->ptr) __buf = (buf); \ |
763 | unsigned long __n = (n); \ |
764 | const size_t __recsize = sizeof(*__tmp->rectype); \ |
765 | struct __kfifo *__kfifo = &__tmp->kfifo; \ |
766 | (__recsize) ? \ |
767 | __kfifo_out_peek_r(__kfifo, __buf, __n, __recsize) : \ |
768 | __kfifo_out_peek(__kfifo, __buf, __n); \ |
769 | }) \ |
770 | ) |
771 | |
772 | extern int __kfifo_alloc(struct __kfifo *fifo, unsigned int size, |
773 | size_t esize, gfp_t gfp_mask); |
774 | |
775 | extern void __kfifo_free(struct __kfifo *fifo); |
776 | |
777 | extern int __kfifo_init(struct __kfifo *fifo, void *buffer, |
778 | unsigned int size, size_t esize); |
779 | |
780 | extern unsigned int __kfifo_in(struct __kfifo *fifo, |
781 | const void *buf, unsigned int len); |
782 | |
783 | extern unsigned int __kfifo_out(struct __kfifo *fifo, |
784 | void *buf, unsigned int len); |
785 | |
786 | extern int __kfifo_from_user(struct __kfifo *fifo, |
787 | const void __user *from, unsigned long len, unsigned int *copied); |
788 | |
789 | extern int __kfifo_to_user(struct __kfifo *fifo, |
790 | void __user *to, unsigned long len, unsigned int *copied); |
791 | |
792 | extern unsigned int __kfifo_dma_in_prepare(struct __kfifo *fifo, |
793 | struct scatterlist *sgl, int nents, unsigned int len); |
794 | |
795 | extern unsigned int __kfifo_dma_out_prepare(struct __kfifo *fifo, |
796 | struct scatterlist *sgl, int nents, unsigned int len); |
797 | |
798 | extern unsigned int __kfifo_out_peek(struct __kfifo *fifo, |
799 | void *buf, unsigned int len); |
800 | |
801 | extern unsigned int __kfifo_in_r(struct __kfifo *fifo, |
802 | const void *buf, unsigned int len, size_t recsize); |
803 | |
804 | extern unsigned int __kfifo_out_r(struct __kfifo *fifo, |
805 | void *buf, unsigned int len, size_t recsize); |
806 | |
807 | extern int __kfifo_from_user_r(struct __kfifo *fifo, |
808 | const void __user *from, unsigned long len, unsigned int *copied, |
809 | size_t recsize); |
810 | |
811 | extern int __kfifo_to_user_r(struct __kfifo *fifo, void __user *to, |
812 | unsigned long len, unsigned int *copied, size_t recsize); |
813 | |
814 | extern unsigned int __kfifo_dma_in_prepare_r(struct __kfifo *fifo, |
815 | struct scatterlist *sgl, int nents, unsigned int len, size_t recsize); |
816 | |
817 | extern void __kfifo_dma_in_finish_r(struct __kfifo *fifo, |
818 | unsigned int len, size_t recsize); |
819 | |
820 | extern unsigned int __kfifo_dma_out_prepare_r(struct __kfifo *fifo, |
821 | struct scatterlist *sgl, int nents, unsigned int len, size_t recsize); |
822 | |
823 | extern void __kfifo_dma_out_finish_r(struct __kfifo *fifo, size_t recsize); |
824 | |
825 | extern unsigned int __kfifo_len_r(struct __kfifo *fifo, size_t recsize); |
826 | |
827 | extern void __kfifo_skip_r(struct __kfifo *fifo, size_t recsize); |
828 | |
829 | extern unsigned int __kfifo_out_peek_r(struct __kfifo *fifo, |
830 | void *buf, unsigned int len, size_t recsize); |
831 | |
832 | extern unsigned int __kfifo_max_r(unsigned int len, size_t recsize); |
833 | |
834 | #endif |
835 | |