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