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

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

Version: ~ [ linux-5.10-rc6 ] ~ [ linux-5.9.12 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.81 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.161 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.210 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.247 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.247 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * 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 

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

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

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

osdn.jp