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