2 * A generic kernel FIFO implementation.
4 * Copyright (C) 2009 Stefani Seibold <stefani@seibold.net>
5 * Copyright (C) 2004 Stelian Pop <stelian@popies.net>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 * Howto porting drivers to the new generic fifo API:
26 * - Modify the declaration of the "struct kfifo *" object into a
27 * in-place "struct kfifo" object
28 * - Init the in-place object with kfifo_alloc() or kfifo_init()
29 * Note: The address of the in-place "struct kfifo" object must be
30 * passed as the first argument to this functions
31 * - Replace the use of __kfifo_put into kfifo_in and __kfifo_get
33 * - Replace the use of kfifo_put into kfifo_in_locked and kfifo_get
34 * into kfifo_out_locked
35 * Note: the spinlock pointer formerly passed to kfifo_init/kfifo_alloc
36 * must be passed now to the kfifo_in_locked and kfifo_out_locked
37 * as the last parameter.
38 * - All formerly name __kfifo_* functions has been renamed into kfifo_*
41 #ifndef _LINUX_KFIFO_H
42 #define _LINUX_KFIFO_H
44 #include <linux/kernel.h>
45 #include <linux/spinlock.h>
48 unsigned char *buffer
; /* the buffer holding the data */
49 unsigned int size
; /* the size of the allocated buffer */
50 unsigned int in
; /* data is added at offset (in % size) */
51 unsigned int out
; /* data is extracted from off. (out % size) */
55 * Macros for declaration and initialization of the kfifo datatype
59 #define __kfifo_initializer(s, b) \
68 * DECLARE_KFIFO - macro to declare a kfifo and the associated buffer
69 * @name: name of the declared kfifo datatype
70 * @size: size of the fifo buffer. Must be a power of two.
72 * Note1: the macro can be used inside struct or union declaration
73 * Note2: the macro creates two objects:
74 * A kfifo object with the given name and a buffer for the kfifo
75 * object named name##kfifo_buffer
77 #define DECLARE_KFIFO(name, size) \
80 unsigned char name##kfifo_buffer[size + sizeof(struct kfifo)]; \
84 * INIT_KFIFO - Initialize a kfifo declared by DECLARE_KFIFO
85 * @name: name of the declared kfifo datatype
87 #define INIT_KFIFO(name) \
88 name = __kfifo_initializer(sizeof(name##kfifo_buffer) - \
89 sizeof(struct kfifo), name##kfifo_buffer)
92 * DEFINE_KFIFO - macro to define and initialize a kfifo
93 * @name: name of the declared kfifo datatype
94 * @size: size of the fifo buffer. Must be a power of two.
96 * Note1: the macro can be used for global and local kfifo data type variables
97 * Note2: the macro creates two objects:
98 * A kfifo object with the given name and a buffer for the kfifo
99 * object named name##kfifo_buffer
101 #define DEFINE_KFIFO(name, size) \
102 unsigned char name##kfifo_buffer[size]; \
103 struct kfifo name = __kfifo_initializer(size, name##kfifo_buffer)
105 #undef __kfifo_initializer
107 extern void kfifo_init(struct kfifo
*fifo
, void *buffer
,
109 extern __must_check
int kfifo_alloc(struct kfifo
*fifo
, unsigned int size
,
111 extern void kfifo_free(struct kfifo
*fifo
);
112 extern unsigned int kfifo_in(struct kfifo
*fifo
,
113 const void *from
, unsigned int len
);
114 extern __must_check
unsigned int kfifo_out(struct kfifo
*fifo
,
115 void *to
, unsigned int len
);
116 extern __must_check
unsigned int kfifo_out_peek(struct kfifo
*fifo
,
117 void *to
, unsigned int len
, unsigned offset
);
120 * kfifo_initialized - Check if kfifo is initialized.
121 * @fifo: fifo to check
122 * Return %true if FIFO is initialized, otherwise %false.
123 * Assumes the fifo was 0 before.
125 static inline bool kfifo_initialized(struct kfifo
*fifo
)
127 return fifo
->buffer
!= NULL
;
131 * kfifo_reset - removes the entire FIFO contents
132 * @fifo: the fifo to be emptied.
134 static inline void kfifo_reset(struct kfifo
*fifo
)
136 fifo
->in
= fifo
->out
= 0;
140 * kfifo_reset_out - skip FIFO contents
141 * @fifo: the fifo to be emptied.
143 static inline void kfifo_reset_out(struct kfifo
*fifo
)
146 fifo
->out
= fifo
->in
;
150 * kfifo_size - returns the size of the fifo in bytes
151 * @fifo: the fifo to be used.
153 static inline __must_check
unsigned int kfifo_size(struct kfifo
*fifo
)
159 * kfifo_len - returns the number of used bytes in the FIFO
160 * @fifo: the fifo to be used.
162 static inline unsigned int kfifo_len(struct kfifo
*fifo
)
164 register unsigned int out
;
168 return fifo
->in
- out
;
172 * kfifo_is_empty - returns true if the fifo is empty
173 * @fifo: the fifo to be used.
175 static inline __must_check
int kfifo_is_empty(struct kfifo
*fifo
)
177 return fifo
->in
== fifo
->out
;
181 * kfifo_is_full - returns true if the fifo is full
182 * @fifo: the fifo to be used.
184 static inline __must_check
int kfifo_is_full(struct kfifo
*fifo
)
186 return kfifo_len(fifo
) == kfifo_size(fifo
);
190 * kfifo_avail - returns the number of bytes available in the FIFO
191 * @fifo: the fifo to be used.
193 static inline __must_check
unsigned int kfifo_avail(struct kfifo
*fifo
)
195 return kfifo_size(fifo
) - kfifo_len(fifo
);
199 * kfifo_in_locked - puts some data into the FIFO using a spinlock for locking
200 * @fifo: the fifo to be used.
201 * @from: the data to be added.
202 * @n: the length of the data to be added.
203 * @lock: pointer to the spinlock to use for locking.
205 * This function copies at most @len bytes from the @from buffer into
206 * the FIFO depending on the free space, and returns the number of
209 static inline unsigned int kfifo_in_locked(struct kfifo
*fifo
,
210 const void *from
, unsigned int n
, spinlock_t
*lock
)
215 spin_lock_irqsave(lock
, flags
);
217 ret
= kfifo_in(fifo
, from
, n
);
219 spin_unlock_irqrestore(lock
, flags
);
225 * kfifo_out_locked - gets some data from the FIFO using a spinlock for locking
226 * @fifo: the fifo to be used.
227 * @to: where the data must be copied.
228 * @n: the size of the destination buffer.
229 * @lock: pointer to the spinlock to use for locking.
231 * This function copies at most @len bytes from the FIFO into the
232 * @to buffer and returns the number of copied bytes.
234 static inline __must_check
unsigned int kfifo_out_locked(struct kfifo
*fifo
,
235 void *to
, unsigned int n
, spinlock_t
*lock
)
240 spin_lock_irqsave(lock
, flags
);
242 ret
= kfifo_out(fifo
, to
, n
);
244 spin_unlock_irqrestore(lock
, flags
);
249 extern void kfifo_skip(struct kfifo
*fifo
, unsigned int len
);
251 extern __must_check
int kfifo_from_user(struct kfifo
*fifo
,
252 const void __user
*from
, unsigned int n
, unsigned *lenout
);
254 extern __must_check
int kfifo_to_user(struct kfifo
*fifo
,
255 void __user
*to
, unsigned int n
, unsigned *lenout
);
258 * __kfifo_add_out internal helper function for updating the out offset
260 static inline void __kfifo_add_out(struct kfifo
*fifo
,
268 * __kfifo_add_in internal helper function for updating the in offset
270 static inline void __kfifo_add_in(struct kfifo
*fifo
,
278 * __kfifo_off internal helper function for calculating the index of a
281 static inline unsigned int __kfifo_off(struct kfifo
*fifo
, unsigned int off
)
283 return off
& (fifo
->size
- 1);
287 * __kfifo_peek_n internal helper function for determinate the length of
288 * the next record in the fifo
290 static inline unsigned int __kfifo_peek_n(struct kfifo
*fifo
,
291 unsigned int recsize
)
293 #define __KFIFO_GET(fifo, off, shift) \
294 ((fifo)->buffer[__kfifo_off((fifo), (fifo)->out+(off))] << (shift))
298 l
= __KFIFO_GET(fifo
, 0, 0);
301 l
|= __KFIFO_GET(fifo
, 1, 8);
308 * __kfifo_poke_n internal helper function for storing the length of
309 * the next record into the fifo
311 static inline void __kfifo_poke_n(struct kfifo
*fifo
,
312 unsigned int recsize
, unsigned int n
)
314 #define __KFIFO_PUT(fifo, off, val, shift) \
316 (fifo)->buffer[__kfifo_off((fifo), (fifo)->in+(off))] = \
317 (unsigned char)((val) >> (shift)) \
320 __KFIFO_PUT(fifo
, 0, n
, 0);
323 __KFIFO_PUT(fifo
, 1, n
, 8);
328 * __kfifo_in_... internal functions for put date into the fifo
329 * do not call it directly, use kfifo_in_rec() instead
331 extern unsigned int __kfifo_in_n(struct kfifo
*fifo
,
332 const void *from
, unsigned int n
, unsigned int recsize
);
334 extern unsigned int __kfifo_in_generic(struct kfifo
*fifo
,
335 const void *from
, unsigned int n
, unsigned int recsize
);
337 static inline unsigned int __kfifo_in_rec(struct kfifo
*fifo
,
338 const void *from
, unsigned int n
, unsigned int recsize
)
342 ret
= __kfifo_in_n(fifo
, from
, n
, recsize
);
344 if (likely(ret
== 0)) {
346 __kfifo_poke_n(fifo
, recsize
, n
);
347 __kfifo_add_in(fifo
, n
+ recsize
);
353 * kfifo_in_rec - puts some record data into the FIFO
354 * @fifo: the fifo to be used.
355 * @from: the data to be added.
356 * @n: the length of the data to be added.
357 * @recsize: size of record field
359 * This function copies @n bytes from the @from into the FIFO and returns
360 * the number of bytes which cannot be copied.
361 * A returned value greater than the @n value means that the record doesn't
362 * fit into the buffer.
364 * Note that with only one concurrent reader and one concurrent
365 * writer, you don't need extra locking to use these functions.
367 static inline __must_check
unsigned int kfifo_in_rec(struct kfifo
*fifo
,
368 void *from
, unsigned int n
, unsigned int recsize
)
370 if (!__builtin_constant_p(recsize
))
371 return __kfifo_in_generic(fifo
, from
, n
, recsize
);
372 return __kfifo_in_rec(fifo
, from
, n
, recsize
);
376 * __kfifo_out_... internal functions for get date from the fifo
377 * do not call it directly, use kfifo_out_rec() instead
379 extern unsigned int __kfifo_out_n(struct kfifo
*fifo
,
380 void *to
, unsigned int reclen
, unsigned int recsize
);
382 extern unsigned int __kfifo_out_generic(struct kfifo
*fifo
,
383 void *to
, unsigned int n
,
384 unsigned int recsize
, unsigned int *total
);
386 static inline unsigned int __kfifo_out_rec(struct kfifo
*fifo
,
387 void *to
, unsigned int n
, unsigned int recsize
,
397 l
= __kfifo_peek_n(fifo
, recsize
);
404 return __kfifo_out_n(fifo
, to
, l
, recsize
);
408 * kfifo_out_rec - gets some record data from the FIFO
409 * @fifo: the fifo to be used.
410 * @to: where the data must be copied.
411 * @n: the size of the destination buffer.
412 * @recsize: size of record field
413 * @total: pointer where the total number of to copied bytes should stored
415 * This function copies at most @n bytes from the FIFO to @to and returns the
416 * number of bytes which cannot be copied.
417 * A returned value greater than the @n value means that the record doesn't
418 * fit into the @to buffer.
420 * Note that with only one concurrent reader and one concurrent
421 * writer, you don't need extra locking to use these functions.
423 static inline __must_check
unsigned int kfifo_out_rec(struct kfifo
*fifo
,
424 void *to
, unsigned int n
, unsigned int recsize
,
428 if (!__builtin_constant_p(recsize
))
429 return __kfifo_out_generic(fifo
, to
, n
, recsize
, total
);
430 return __kfifo_out_rec(fifo
, to
, n
, recsize
, total
);
434 * __kfifo_from_user_... internal functions for transfer from user space into
435 * the fifo. do not call it directly, use kfifo_from_user_rec() instead
437 extern unsigned int __kfifo_from_user_n(struct kfifo
*fifo
,
438 const void __user
*from
, unsigned int n
, unsigned int recsize
);
440 extern unsigned int __kfifo_from_user_generic(struct kfifo
*fifo
,
441 const void __user
*from
, unsigned int n
, unsigned int recsize
);
443 static inline unsigned int __kfifo_from_user_rec(struct kfifo
*fifo
,
444 const void __user
*from
, unsigned int n
, unsigned int recsize
)
448 ret
= __kfifo_from_user_n(fifo
, from
, n
, recsize
);
450 if (likely(ret
== 0)) {
452 __kfifo_poke_n(fifo
, recsize
, n
);
453 __kfifo_add_in(fifo
, n
+ recsize
);
459 * kfifo_from_user_rec - puts some data from user space into the FIFO
460 * @fifo: the fifo to be used.
461 * @from: pointer to the data to be added.
462 * @n: the length of the data to be added.
463 * @recsize: size of record field
465 * This function copies @n bytes from the @from into the
466 * FIFO and returns the number of bytes which cannot be copied.
468 * If the returned value is equal or less the @n value, the copy_from_user()
469 * functions has failed. Otherwise the record doesn't fit into the buffer.
471 * Note that with only one concurrent reader and one concurrent
472 * writer, you don't need extra locking to use these functions.
474 static inline __must_check
unsigned int kfifo_from_user_rec(struct kfifo
*fifo
,
475 const void __user
*from
, unsigned int n
, unsigned int recsize
)
477 if (!__builtin_constant_p(recsize
))
478 return __kfifo_from_user_generic(fifo
, from
, n
, recsize
);
479 return __kfifo_from_user_rec(fifo
, from
, n
, recsize
);
483 * __kfifo_to_user_... internal functions for transfer fifo data into user space
484 * do not call it directly, use kfifo_to_user_rec() instead
486 extern unsigned int __kfifo_to_user_n(struct kfifo
*fifo
,
487 void __user
*to
, unsigned int n
, unsigned int reclen
,
488 unsigned int recsize
);
490 extern unsigned int __kfifo_to_user_generic(struct kfifo
*fifo
,
491 void __user
*to
, unsigned int n
, unsigned int recsize
,
492 unsigned int *total
);
494 static inline unsigned int __kfifo_to_user_rec(struct kfifo
*fifo
,
495 void __user
*to
, unsigned int n
,
496 unsigned int recsize
, unsigned int *total
)
505 l
= __kfifo_peek_n(fifo
, recsize
);
512 return __kfifo_to_user_n(fifo
, to
, n
, l
, recsize
);
516 * kfifo_to_user_rec - gets data from the FIFO and write it to user space
517 * @fifo: the fifo to be used.
518 * @to: where the data must be copied.
519 * @n: the size of the destination buffer.
520 * @recsize: size of record field
521 * @total: pointer where the total number of to copied bytes should stored
523 * This function copies at most @n bytes from the FIFO to the @to.
524 * In case of an error, the function returns the number of bytes which cannot
526 * If the returned value is equal or less the @n value, the copy_to_user()
527 * functions has failed. Otherwise the record doesn't fit into the @to buffer.
529 * Note that with only one concurrent reader and one concurrent
530 * writer, you don't need extra locking to use these functions.
532 static inline __must_check
unsigned int kfifo_to_user_rec(struct kfifo
*fifo
,
533 void __user
*to
, unsigned int n
, unsigned int recsize
,
536 if (!__builtin_constant_p(recsize
))
537 return __kfifo_to_user_generic(fifo
, to
, n
, recsize
, total
);
538 return __kfifo_to_user_rec(fifo
, to
, n
, recsize
, total
);
542 * __kfifo_peek_... internal functions for peek into the next fifo record
543 * do not call it directly, use kfifo_peek_rec() instead
545 extern unsigned int __kfifo_peek_generic(struct kfifo
*fifo
,
546 unsigned int recsize
);
549 * kfifo_peek_rec - gets the size of the next FIFO record data
550 * @fifo: the fifo to be used.
551 * @recsize: size of record field
553 * This function returns the size of the next FIFO record in number of bytes
555 static inline __must_check
unsigned int kfifo_peek_rec(struct kfifo
*fifo
,
556 unsigned int recsize
)
558 if (!__builtin_constant_p(recsize
))
559 return __kfifo_peek_generic(fifo
, recsize
);
561 return kfifo_len(fifo
);
562 return __kfifo_peek_n(fifo
, recsize
);
566 * __kfifo_skip_... internal functions for skip the next fifo record
567 * do not call it directly, use kfifo_skip_rec() instead
569 extern void __kfifo_skip_generic(struct kfifo
*fifo
, unsigned int recsize
);
571 static inline void __kfifo_skip_rec(struct kfifo
*fifo
,
572 unsigned int recsize
)
577 l
= __kfifo_peek_n(fifo
, recsize
);
579 if (l
+ recsize
<= kfifo_len(fifo
)) {
580 __kfifo_add_out(fifo
, l
+ recsize
);
584 kfifo_reset_out(fifo
);
588 * kfifo_skip_rec - skip the next fifo out record
589 * @fifo: the fifo to be used.
590 * @recsize: size of record field
592 * This function skips the next FIFO record
594 static inline void kfifo_skip_rec(struct kfifo
*fifo
,
595 unsigned int recsize
)
597 if (!__builtin_constant_p(recsize
))
598 __kfifo_skip_generic(fifo
, recsize
);
600 __kfifo_skip_rec(fifo
, recsize
);
604 * kfifo_avail_rec - returns the number of bytes available in a record FIFO
605 * @fifo: the fifo to be used.
606 * @recsize: size of record field
608 static inline __must_check
unsigned int kfifo_avail_rec(struct kfifo
*fifo
,
609 unsigned int recsize
)
611 unsigned int l
= kfifo_size(fifo
) - kfifo_len(fifo
);
613 return (l
> recsize
) ? l
- recsize
: 0;
This page took 0.043104 seconds and 6 git commands to generate.