#include <linux/kernel.h>
#include <linux/spinlock.h>
#include <linux/stddef.h>
#include <linux/scatterlist.h>

Data Structures
struct	__kfifo

Macros
#define	__STRUCT_KFIFO_COMMON(datatype, recsize, ptrtype)

#define	__STRUCT_KFIFO(type, size, recsize, ptrtype)

#define	STRUCT_KFIFO(type, size) struct __STRUCT_KFIFO(type, size, 0, type)

#define	__STRUCT_KFIFO_PTR(type, recsize, ptrtype)

#define	STRUCT_KFIFO_PTR(type) struct __STRUCT_KFIFO_PTR(type, 0, type)

#define	STRUCT_KFIFO_REC_1(size) struct __STRUCT_KFIFO(unsigned char, size, 1, void)

#define	STRUCT_KFIFO_REC_2(size) struct __STRUCT_KFIFO(unsigned char, size, 2, void)

#define	__is_kfifo_ptr(fifo) (sizeof(*fifo) == sizeof(struct __kfifo))

#define	DECLARE_KFIFO_PTR(fifo, type) STRUCT_KFIFO_PTR(type) fifo

#define	DECLARE_KFIFO(fifo, type, size) STRUCT_KFIFO(type, size) fifo

#define	INIT_KFIFO(fifo)

#define	DEFINE_KFIFO(fifo, type, size)

#define	kfifo_initialized(fifo) ((fifo)->kfifo.mask)

#define	kfifo_esize(fifo) ((fifo)->kfifo.esize)

#define	kfifo_recsize(fifo) (sizeof(*(fifo)->rectype))

#define	kfifo_size(fifo) ((fifo)->kfifo.mask + 1)

#define	kfifo_reset(fifo)

#define	kfifo_reset_out(fifo)

#define	kfifo_len(fifo)

#define	kfifo_is_empty(fifo)

#define	kfifo_is_full(fifo)

#define	kfifo_avail(fifo)

#define	kfifo_skip(fifo)

#define	kfifo_peek_len(fifo)

#define	kfifo_alloc(fifo, size, gfp_mask)

#define	kfifo_free(fifo)

#define	kfifo_init(fifo, buffer, size)

#define	kfifo_put(fifo, val)

#define	kfifo_get(fifo, val)

#define	kfifo_peek(fifo, val)

#define	kfifo_in(fifo, buf, n)

#define	kfifo_in_spinlocked(fifo, buf, n, lock)

#define	kfifo_in_locked(fifo, buf, n, lock) kfifo_in_spinlocked(fifo, buf, n, lock)

#define	kfifo_out(fifo, buf, n)

#define	kfifo_out_spinlocked(fifo, buf, n, lock)

#define	kfifo_out_locked(fifo, buf, n, lock) kfifo_out_spinlocked(fifo, buf, n, lock)

#define	kfifo_from_user(fifo, from, len, copied)

#define	kfifo_to_user(fifo, to, len, copied)

#define	kfifo_dma_in_prepare(fifo, sgl, nents, len)

#define	kfifo_dma_in_finish(fifo, len)

#define	kfifo_dma_out_prepare(fifo, sgl, nents, len)

#define	kfifo_dma_out_finish(fifo, len)

#define	kfifo_out_peek(fifo, buf, n)

Functions
struct kfifo	__STRUCT_KFIFO_PTR (unsigned char, 0, void)

struct kfifo_rec_ptr_1	__STRUCT_KFIFO_PTR (unsigned char, 1, void)

struct kfifo_rec_ptr_2	__STRUCT_KFIFO_PTR (unsigned char, 2, void)

int	__kfifo_alloc (struct __kfifo *fifo, unsigned int size, size_t esize, gfp_t gfp_mask)

void	__kfifo_free (struct __kfifo *fifo)

int	__kfifo_init (struct __kfifo fifo, void buffer, unsigned int size, size_t esize)

unsigned int	__kfifo_in (struct __kfifo fifo, const void buf, unsigned int len)

unsigned int	__kfifo_out (struct __kfifo fifo, void buf, unsigned int len)

int	__kfifo_from_user (struct __kfifo fifo, const void __user from, unsigned long len, unsigned int *copied)

int	__kfifo_to_user (struct __kfifo fifo, void __user to, unsigned long len, unsigned int *copied)

unsigned int	__kfifo_dma_in_prepare (struct __kfifo fifo, struct scatterlist sgl, int nents, unsigned int len)

unsigned int	__kfifo_dma_out_prepare (struct __kfifo fifo, struct scatterlist sgl, int nents, unsigned int len)

unsigned int	__kfifo_out_peek (struct __kfifo fifo, void buf, unsigned int len)

unsigned int	__kfifo_in_r (struct __kfifo fifo, const void buf, unsigned int len, size_t recsize)

unsigned int	__kfifo_out_r (struct __kfifo fifo, void buf, unsigned int len, size_t recsize)

int	__kfifo_from_user_r (struct __kfifo fifo, const void __user from, unsigned long len, unsigned int *copied, size_t recsize)

int	__kfifo_to_user_r (struct __kfifo fifo, void __user to, unsigned long len, unsigned int *copied, size_t recsize)

unsigned int	__kfifo_dma_in_prepare_r (struct __kfifo fifo, struct scatterlist sgl, int nents, unsigned int len, size_t recsize)

void	__kfifo_dma_in_finish_r (struct __kfifo *fifo, unsigned int len, size_t recsize)

unsigned int	__kfifo_dma_out_prepare_r (struct __kfifo fifo, struct scatterlist sgl, int nents, unsigned int len, size_t recsize)

void	__kfifo_dma_out_finish_r (struct __kfifo *fifo, size_t recsize)

unsigned int	__kfifo_len_r (struct __kfifo *fifo, size_t recsize)

void	__kfifo_skip_r (struct __kfifo *fifo, size_t recsize)

unsigned int	__kfifo_out_peek_r (struct __kfifo fifo, void buf, unsigned int len, size_t recsize)

unsigned int	__kfifo_max_r (unsigned int len, size_t recsize)

Macro Definition Documentation

#define __is_kfifo_ptr ( fifo ) (sizeof(*fifo) == sizeof(struct __kfifo))

Definition at line 115 of file kfifo.h.

#define __STRUCT_KFIFO	(	type,
		size,
		recsize,
		ptrtype
	)

Value:

{ \
    __STRUCT_KFIFO_COMMON(type, recsize, ptrtype); \
	type       buf[((size < 2) || (size & (size - 1))) ? -1 : size]; \
}

Definition at line 75 of file kfifo.h.

#define __STRUCT_KFIFO_COMMON	(	datatype,
		recsize,
		ptrtype
	)

Value:

union { \
		struct __kfifo    kfifo; \
        datatype    *type; \
        char        (*rectype)[recsize]; \
        ptrtype     *ptr; \
        const ptrtype   *ptr_const; \
    }

Definition at line 66 of file kfifo.h.

#define __STRUCT_KFIFO_PTR	(	type,
		recsize,
		ptrtype
	)

Value:

{ \
    __STRUCT_KFIFO_COMMON(type, recsize, ptrtype); \
	type       buf[0]; \
}

Definition at line 84 of file kfifo.h.

#define DECLARE_KFIFO	(	fifo,
		type,
		size
	)	STRUCT_KFIFO(type, size) fifo

DECLARE_KFIFO - macro to declare a fifo object : name of the declared fifo : type of the fifo elements : the number of elements in the fifo, this must be a power of 2

Definition at line 130 of file kfifo.h.

#define DECLARE_KFIFO_PTR	(	fifo,
		type
	)	STRUCT_KFIFO_PTR(type) fifo

DECLARE_KFIFO_PTR - macro to declare a fifo pointer object : name of the declared fifo : type of the fifo elements

Definition at line 122 of file kfifo.h.

#define DEFINE_KFIFO	(	fifo,
		type,
		size
	)

Value:

DECLARE_KFIFO(fifo, type, size) = \
    (typeof(fifo)) { \
        { \
            { \
            .in = 0, \
            .out    = 0, \
            .mask   = __is_kfifo_ptr(&(fifo)) ? \
                  0 : \
                  ARRAY_SIZE((fifo).buf) - 1, \
            .esize  = sizeof(*(fifo).buf), \
            .data   = __is_kfifo_ptr(&(fifo)) ? \
                NULL : \
                (fifo).buf, \
            } \
        } \
    }

DEFINE_KFIFO - macro to define and initialize a fifo : name of the declared fifo datatype : type of the fifo elements : the number of elements in the fifo, this must be a power of 2

Note: the macro can be used for global and local fifo data type variables.

Definition at line 155 of file kfifo.h.

#define INIT_KFIFO ( fifo )

Value:

(void)({ \
    typeof(&(fifo)) __tmp = &(fifo); \
    struct __kfifo *__kfifo = &__tmp->kfifo; \
    __kfifo->in = 0; \
    __kfifo->out = 0; \
    __kfifo->mask = __is_kfifo_ptr(__tmp) ? 0 : ARRAY_SIZE(__tmp->buf) - 1;\
    __kfifo->esize = sizeof(*__tmp->buf); \
    __kfifo->data = __is_kfifo_ptr(__tmp) ?  NULL : __tmp->buf; \
})

INIT_KFIFO - Initialize a fifo declared by DECLARE_KFIFO : name of the declared fifo datatype

Definition at line 136 of file kfifo.h.

#define kfifo_alloc	(	fifo,
		size,
		gfp_mask
	)

Value:

__kfifo_int_must_check_helper( \
({ \
    typeof((fifo) + 1) __tmp = (fifo); \
    struct __kfifo *__kfifo = &__tmp->kfifo; \
    __is_kfifo_ptr(__tmp) ? \
    __kfifo_alloc(__kfifo, size, sizeof(*__tmp->type), gfp_mask) : \
    -EINVAL; \
}) \
)

kfifo_alloc - dynamically allocates a new fifo buffer : pointer to the fifo : the number of elements in the fifo, this must be a power of 2 : get_free_pages mask, passed to kmalloc()

This macro dynamically allocates a new fifo buffer.

The numer of elements will be rounded-up to a power of 2. The fifo will be release with kfifo_free(). Return 0 if no error, otherwise an error code.

Definition at line 331 of file kfifo.h.

#define kfifo_avail ( fifo )

Value:

__kfifo_uint_must_check_helper( \
({ \
    typeof((fifo) + 1) __tmpq = (fifo); \
    const size_t __recsize = sizeof(*__tmpq->rectype); \
    unsigned int __avail = kfifo_size(__tmpq) - kfifo_len(__tmpq); \
    (__recsize) ? ((__avail <= __recsize) ? 0 : \
    __kfifo_max_r(__avail - __recsize, __recsize)) : \
    __avail; \
}) \
)

kfifo_avail - returns the number of unused elements in the fifo : address of the fifo to be used

Definition at line 275 of file kfifo.h.

#define kfifo_dma_in_finish	(	fifo,
		len
	)

Value:

(void)({ \
    typeof((fifo) + 1) __tmp = (fifo); \
    unsigned int __len = (len); \
    const size_t __recsize = sizeof(*__tmp->rectype); \
    struct __kfifo *__kfifo = &__tmp->kfifo; \
    if (__recsize) \
        __kfifo_dma_in_finish_r(__kfifo, __len, __recsize); \
    else \
        __kfifo->in += __len / sizeof(*__tmp->type); \
})

kfifo_dma_in_finish - finish a DMA IN operation : address of the fifo to be used : number of bytes to received

This macro finish a DMA IN operation. The in counter will be updated by the len parameter. No error checking will be done.

Note that with only one concurrent reader and one concurrent writer, you don't need extra locking to use these macros.

Definition at line 697 of file kfifo.h.

#define kfifo_dma_in_prepare	(	fifo,
		sgl,
		nents,
		len
	)

Value:

({ \
    typeof((fifo) + 1) __tmp = (fifo); \
    struct scatterlist *__sgl = (sgl); \
    int __nents = (nents); \
    unsigned int __len = (len); \
    const size_t __recsize = sizeof(*__tmp->rectype); \
    struct __kfifo *__kfifo = &__tmp->kfifo; \
    (__recsize) ? \
    __kfifo_dma_in_prepare_r(__kfifo, __sgl, __nents, __len, __recsize) : \
    __kfifo_dma_in_prepare(__kfifo, __sgl, __nents, __len); \
})

kfifo_dma_in_prepare - setup a scatterlist for DMA input : address of the fifo to be used : pointer to the scatterlist array : number of entries in the scatterlist array : number of elements to transfer

This macro fills a scatterlist for DMA input. It returns the number entries in the scatterlist array.

Note that with only one concurrent reader and one concurrent writer, you don't need extra locking to use these macros.

Definition at line 673 of file kfifo.h.

#define kfifo_dma_out_finish	(	fifo,
		len
	)

Value:

(void)({ \
    typeof((fifo) + 1) __tmp = (fifo); \
    unsigned int __len = (len); \
    const size_t __recsize = sizeof(*__tmp->rectype); \
    struct __kfifo *__kfifo = &__tmp->kfifo; \
    if (__recsize) \
        __kfifo_dma_out_finish_r(__kfifo, __recsize); \
    else \
        __kfifo->out += __len / sizeof(*__tmp->type); \
})

kfifo_dma_out_finish - finish a DMA OUT operation : address of the fifo to be used : number of bytes transferd

This macro finish a DMA OUT operation. The out counter will be updated by the len parameter. No error checking will be done.

Note that with only one concurrent reader and one concurrent writer, you don't need extra locking to use these macros.

Definition at line 748 of file kfifo.h.

#define kfifo_dma_out_prepare	(	fifo,
		sgl,
		nents,
		len
	)

Value:

({ \
    typeof((fifo) + 1) __tmp = (fifo);  \
    struct scatterlist *__sgl = (sgl); \
    int __nents = (nents); \
    unsigned int __len = (len); \
    const size_t __recsize = sizeof(*__tmp->rectype); \
    struct __kfifo *__kfifo = &__tmp->kfifo; \
    (__recsize) ? \
    __kfifo_dma_out_prepare_r(__kfifo, __sgl, __nents, __len, __recsize) : \
    __kfifo_dma_out_prepare(__kfifo, __sgl, __nents, __len); \
})

kfifo_dma_out_prepare - setup a scatterlist for DMA output : address of the fifo to be used : pointer to the scatterlist array : number of entries in the scatterlist array : number of elements to transfer

This macro fills a scatterlist for DMA output which at most bytes to transfer. It returns the number entries in the scatterlist array. A zero means there is no space available and the scatterlist is not filled.

Note that with only one concurrent reader and one concurrent writer, you don't need extra locking to use these macros.

Definition at line 724 of file kfifo.h.

#define kfifo_esize ( fifo ) ((fifo)->kfifo.esize)

kfifo_esize - returns the size of the element managed by the fifo : address of the fifo to be used

Definition at line 199 of file kfifo.h.

#define kfifo_free ( fifo )

Value:

({ \
    typeof((fifo) + 1) __tmp = (fifo); \
    struct __kfifo *__kfifo = &__tmp->kfifo; \
    if (__is_kfifo_ptr(__tmp)) \
        __kfifo_free(__kfifo); \
})

kfifo_free - frees the fifo : the fifo to be freed

Definition at line 346 of file kfifo.h.

#define kfifo_from_user	(	fifo,
		from,
		len,
		copied
	)

Value:

__kfifo_uint_must_check_helper( \
({ \
    typeof((fifo) + 1) __tmp = (fifo); \
    const void __user *__from = (from); \
    unsigned int __len = (len); \
    unsigned int *__copied = (copied); \
    const size_t __recsize = sizeof(*__tmp->rectype); \
    struct __kfifo *__kfifo = &__tmp->kfifo; \
    (__recsize) ? \
    __kfifo_from_user_r(__kfifo, __from, __len,  __copied, __recsize) : \
    __kfifo_from_user(__kfifo, __from, __len, __copied); \
}) \
)

kfifo_from_user - puts some data from user space into the fifo : address of the fifo to be used : pointer to the data to be added : the length of the data to be added : pointer to output variable to store the number of copied bytes

This macro copies at most bytes from the into the fifo, depending of the available space and returns -EFAULT/0.

Note that with only one concurrent reader and one concurrent writer, you don't need extra locking to use these macro.

Definition at line 617 of file kfifo.h.

#define kfifo_get	(	fifo,
		val
	)

Value:

__kfifo_uint_must_check_helper( \
({ \
    typeof((fifo) + 1) __tmp = (fifo); \
    typeof((val) + 1) __val = (val); \
    unsigned int __ret; \
    const size_t __recsize = sizeof(*__tmp->rectype); \
    struct __kfifo *__kfifo = &__tmp->kfifo; \
    if (0) \
        __val = (typeof(__tmp->ptr))0; \
    if (__recsize) \
        __ret = __kfifo_out_r(__kfifo, __val, sizeof(*__val), \
            __recsize); \
    else { \
        __ret = !kfifo_is_empty(__tmp); \
        if (__ret) { \
            *(typeof(__tmp->type))__val = \
                (__is_kfifo_ptr(__tmp) ? \
                ((typeof(__tmp->type))__kfifo->data) : \
                (__tmp->buf) \
                )[__kfifo->out & __tmp->kfifo.mask]; \
            smp_wmb(); \
			__kfifo->out++; \
        } \
    } \
    __ret; \
}) \
)

kfifo_get - get data from the fifo : address of the fifo to be used : the var where to store the data to be added

This macro reads the data from the fifo. It returns 0 if the fifo was empty. Otherwise it returns the number processed elements.

Note that with only one concurrent reader and one concurrent writer, you don't need extra locking to use these macro.

Definition at line 427 of file kfifo.h.

#define kfifo_in	(	fifo,
		buf,
		n
	)

Value:

({ \
    typeof((fifo) + 1) __tmp = (fifo); \
    typeof((buf) + 1) __buf = (buf); \
    unsigned long __n = (n); \
    const size_t __recsize = sizeof(*__tmp->rectype); \
    struct __kfifo *__kfifo = &__tmp->kfifo; \
    if (0) { \
        typeof(__tmp->ptr_const) __dummy __attribute__ ((unused)); \
        __dummy = (typeof(__buf))NULL; \
    } \
    (__recsize) ?\
    __kfifo_in_r(__kfifo, __buf, __n, __recsize) : \
    __kfifo_in(__kfifo, __buf, __n); \
})

kfifo_in - put data into the fifo : address of the fifo to be used : the data to be added
: number of elements to be added

This macro copies the given buffer into the fifo and returns the number of copied elements.

Note that with only one concurrent reader and one concurrent writer, you don't need extra locking to use these macro.

Definition at line 508 of file kfifo.h.

#define kfifo_in_locked	(	fifo,
		buf,
		n,
		lock
	)	kfifo_in_spinlocked(fifo, buf, n, lock)

Definition at line 545 of file kfifo.h.

#define kfifo_in_spinlocked	(	fifo,
		buf,
		n,
		lock
	)

Value:

({ \
    unsigned long __flags; \
    unsigned int __ret; \
    spin_lock_irqsave(lock, __flags); \
    __ret = kfifo_in(fifo, buf, n); \
    spin_unlock_irqrestore(lock, __flags); \
    __ret; \
})

kfifo_in_spinlocked - put data into the fifo using a spinlock for locking : address of the fifo to be used : the data to be added
: number of elements to be added : pointer to the spinlock to use for locking

This macro copies the given values buffer into the fifo and returns the number of copied elements.

Definition at line 534 of file kfifo.h.

#define kfifo_init	(	fifo,
		buffer,
		size
	)

Value:

({ \
    typeof((fifo) + 1) __tmp = (fifo); \
    struct __kfifo *__kfifo = &__tmp->kfifo; \
    __is_kfifo_ptr(__tmp) ? \
    __kfifo_init(__kfifo, buffer, size, sizeof(*__tmp->type)) : \
    -EINVAL; \
})

kfifo_init - initialize a fifo using a preallocated buffer : the fifo to assign the buffer : the preallocated buffer to be used : the size of the internal buffer, this have to be a power of 2

This macro initialize a fifo using a preallocated buffer.

The numer of elements will be rounded-up to a power of 2. Return 0 if no error, otherwise an error code.

Definition at line 365 of file kfifo.h.

#define kfifo_initialized ( fifo ) ((fifo)->kfifo.mask)

kfifo_initialized - Check if the fifo is initialized : address of the fifo to check

Return true if fifo is initialized, otherwise false. Assumes the fifo was 0 before.

Definition at line 193 of file kfifo.h.

#define kfifo_is_empty ( fifo )

Value:

({ \
    typeof((fifo) + 1) __tmpq = (fifo); \
    __tmpq->kfifo.in == __tmpq->kfifo.out; \
})

kfifo_is_empty - returns true if the fifo is empty : address of the fifo to be used

Definition at line 255 of file kfifo.h.

#define kfifo_is_full ( fifo )

Value:

({ \
    typeof((fifo) + 1) __tmpq = (fifo); \
    kfifo_len(__tmpq) > __tmpq->kfifo.mask; \
})

kfifo_is_full - returns true if the fifo is full : address of the fifo to be used

Definition at line 265 of file kfifo.h.

#define kfifo_len ( fifo )

Value:

({ \
    typeof((fifo) + 1) __tmpl = (fifo); \
    __tmpl->kfifo.in - __tmpl->kfifo.out; \
})

kfifo_len - returns the number of used elements in the fifo : address of the fifo to be used

Definition at line 245 of file kfifo.h.

#define kfifo_out	(	fifo,
		buf,
		n
	)

Value:

__kfifo_uint_must_check_helper( \
({ \
    typeof((fifo) + 1) __tmp = (fifo); \
    typeof((buf) + 1) __buf = (buf); \
    unsigned long __n = (n); \
    const size_t __recsize = sizeof(*__tmp->rectype); \
    struct __kfifo *__kfifo = &__tmp->kfifo; \
    if (0) { \
        typeof(__tmp->ptr) __dummy = NULL; \
        __buf = __dummy; \
    } \
    (__recsize) ?\
    __kfifo_out_r(__kfifo, __buf, __n, __recsize) : \
    __kfifo_out(__kfifo, __buf, __n); \
}) \
)

kfifo_out - get data from the fifo : address of the fifo to be used : pointer to the storage buffer
: max. number of elements to get

This macro get some data from the fifo and return the numbers of elements copied.

Note that with only one concurrent reader and one concurrent writer, you don't need extra locking to use these macro.

Definition at line 560 of file kfifo.h.

#define kfifo_out_locked	(	fifo,
		buf,
		n,
		lock
	)	kfifo_out_spinlocked(fifo, buf, n, lock)

Definition at line 601 of file kfifo.h.

#define kfifo_out_peek	(	fifo,
		buf,
		n
	)

Value:

__kfifo_uint_must_check_helper( \
({ \
    typeof((fifo) + 1) __tmp = (fifo); \
    typeof((buf) + 1) __buf = (buf); \
    unsigned long __n = (n); \
    const size_t __recsize = sizeof(*__tmp->rectype); \
    struct __kfifo *__kfifo = &__tmp->kfifo; \
    if (0) { \
        typeof(__tmp->ptr) __dummy __attribute__ ((unused)) = NULL; \
        __buf = __dummy; \
    } \
    (__recsize) ? \
    __kfifo_out_peek_r(__kfifo, __buf, __n, __recsize) : \
    __kfifo_out_peek(__kfifo, __buf, __n); \
}) \
)

kfifo_out_peek - gets some data from the fifo : address of the fifo to be used : pointer to the storage buffer
: max. number of elements to get

This macro get the data from the fifo and return the numbers of elements copied. The data is not removed from the fifo.

Note that with only one concurrent reader and one concurrent writer, you don't need extra locking to use these macro.

Definition at line 772 of file kfifo.h.

#define kfifo_out_spinlocked	(	fifo,
		buf,
		n,
		lock
	)

Value:

__kfifo_uint_must_check_helper( \
({ \
    unsigned long __flags; \
    unsigned int __ret; \
    spin_lock_irqsave(lock, __flags); \
    __ret = kfifo_out(fifo, buf, n); \
    spin_unlock_irqrestore(lock, __flags); \
    __ret; \
}) \
)

kfifo_out_spinlocked - get data from the fifo using a spinlock for locking : address of the fifo to be used : pointer to the storage buffer
: max. number of elements to get : pointer to the spinlock to use for locking

This macro get the data from the fifo and return the numbers of elements copied.

Definition at line 588 of file kfifo.h.

#define kfifo_peek	(	fifo,
		val
	)

Value:

__kfifo_uint_must_check_helper( \
({ \
    typeof((fifo) + 1) __tmp = (fifo); \
    typeof((val) + 1) __val = (val); \
    unsigned int __ret; \
    const size_t __recsize = sizeof(*__tmp->rectype); \
    struct __kfifo *__kfifo = &__tmp->kfifo; \
    if (0) \
        __val = (typeof(__tmp->ptr))NULL; \
    if (__recsize) \
        __ret = __kfifo_out_peek_r(__kfifo, __val, sizeof(*__val), \
            __recsize); \
    else { \
        __ret = !kfifo_is_empty(__tmp); \
        if (__ret) { \
            *(typeof(__tmp->type))__val = \
                (__is_kfifo_ptr(__tmp) ? \
                ((typeof(__tmp->type))__kfifo->data) : \
                (__tmp->buf) \
                )[__kfifo->out & __tmp->kfifo.mask]; \
            smp_wmb(); \
        } \
    } \
    __ret; \
}) \
)

kfifo_peek - get data from the fifo without removing : address of the fifo to be used : the var where to store the data to be added

This reads the data from the fifo without removing it from the fifo. It returns 0 if the fifo was empty. Otherwise it returns the number processed elements.

Note that with only one concurrent reader and one concurrent writer, you don't need extra locking to use these macro.

Definition at line 468 of file kfifo.h.

#define kfifo_peek_len ( fifo )

Value:

__kfifo_uint_must_check_helper( \
({ \
    typeof((fifo) + 1) __tmp = (fifo); \
    const size_t __recsize = sizeof(*__tmp->rectype); \
    struct __kfifo *__kfifo = &__tmp->kfifo; \
    (!__recsize) ? kfifo_len(__tmp) * sizeof(*__tmp->type) : \
    __kfifo_len_r(__kfifo, __recsize); \
}) \
)

kfifo_peek_len - gets the size of the next fifo record : address of the fifo to be used

This function returns the size of the next fifo record in number of bytes.

Definition at line 308 of file kfifo.h.

#define kfifo_put	(	fifo,
		val
	)

Value:

({ \
    typeof((fifo) + 1) __tmp = (fifo); \
    typeof((val) + 1) __val = (val); \
    unsigned int __ret; \
    const size_t __recsize = sizeof(*__tmp->rectype); \
    struct __kfifo *__kfifo = &__tmp->kfifo; \
    if (0) { \
        typeof(__tmp->ptr_const) __dummy __attribute__ ((unused)); \
        __dummy = (typeof(__val))NULL; \
    } \
    if (__recsize) \
        __ret = __kfifo_in_r(__kfifo, __val, sizeof(*__val), \
            __recsize); \
    else { \
        __ret = !kfifo_is_full(__tmp); \
        if (__ret) { \
            (__is_kfifo_ptr(__tmp) ? \
            ((typeof(__tmp->type))__kfifo->data) : \
            (__tmp->buf) \
            )[__kfifo->in & __tmp->kfifo.mask] = \
                *(typeof(__tmp->type))__val; \
            smp_wmb(); \
			__kfifo->in++; \
        } \
    } \
    __ret; \
})

kfifo_put - put data into the fifo : address of the fifo to be used : the data to be added

This macro copies the given value into the fifo. It returns 0 if the fifo was full. Otherwise it returns the number processed elements.

Note that with only one concurrent reader and one concurrent writer, you don't need extra locking to use these macro.

Definition at line 386 of file kfifo.h.

#define kfifo_recsize ( fifo ) (sizeof(*(fifo)->rectype))

kfifo_recsize - returns the size of the record length field : address of the fifo to be used

Definition at line 205 of file kfifo.h.

#define kfifo_reset ( fifo )

Value:

(void)({ \
    typeof((fifo) + 1) __tmp = (fifo); \
    __tmp->kfifo.in = __tmp->kfifo.out = 0; \
})

kfifo_reset - removes the entire fifo content : address of the fifo to be used

Note: usage of kfifo_reset() is dangerous. It should be only called when the fifo is exclusived locked or when it is secured that no other thread is accessing the fifo.

Definition at line 221 of file kfifo.h.

#define kfifo_reset_out ( fifo )

Value:

(void)({ \
    typeof((fifo) + 1) __tmp = (fifo); \
    __tmp->kfifo.out = __tmp->kfifo.in; \
})

kfifo_reset_out - skip fifo content : address of the fifo to be used

Note: The usage of kfifo_reset_out() is safe until it will be only called from the reader thread and there is only one concurrent reader. Otherwise it is dangerous and must be handled in the same way as kfifo_reset().

Definition at line 235 of file kfifo.h.

#define kfifo_size ( fifo ) ((fifo)->kfifo.mask + 1)

kfifo_size - returns the size of the fifo in elements : address of the fifo to be used

Definition at line 211 of file kfifo.h.

#define kfifo_skip ( fifo )

Value:

(void)({ \
    typeof((fifo) + 1) __tmp = (fifo); \
    const size_t __recsize = sizeof(*__tmp->rectype); \
    struct __kfifo *__kfifo = &__tmp->kfifo; \
    if (__recsize) \
        __kfifo_skip_r(__kfifo, __recsize); \
    else \
        __kfifo->out++; \
})

kfifo_skip - skip output data : address of the fifo to be used

Definition at line 291 of file kfifo.h.

#define kfifo_to_user	(	fifo,
		to,
		len,
		copied
	)

Value:

__kfifo_uint_must_check_helper( \
({ \
    typeof((fifo) + 1) __tmp = (fifo); \
    void __user *__to = (to); \
    unsigned int __len = (len); \
    unsigned int *__copied = (copied); \
    const size_t __recsize = sizeof(*__tmp->rectype); \
    struct __kfifo *__kfifo = &__tmp->kfifo; \
    (__recsize) ? \
    __kfifo_to_user_r(__kfifo, __to, __len, __copied, __recsize) : \
    __kfifo_to_user(__kfifo, __to, __len, __copied); \
}) \
)

kfifo_to_user - copies data from the fifo into user space : address of the fifo to be used : where the data must be copied : the size of the destination buffer : pointer to output variable to store the number of copied bytes

This macro copies at most bytes from the fifo into the buffer and returns -EFAULT/0.

Note that with only one concurrent reader and one concurrent writer, you don't need extra locking to use these macro.

Definition at line 645 of file kfifo.h.

#define STRUCT_KFIFO	(	type,
		size
	)	struct __STRUCT_KFIFO(type, size, 0, type)

Definition at line 81 of file kfifo.h.

#define STRUCT_KFIFO_PTR ( type ) struct __STRUCT_KFIFO_PTR(type, 0, type)

Definition at line 90 of file kfifo.h.

#define STRUCT_KFIFO_REC_1 ( size ) struct __STRUCT_KFIFO(unsigned char, size, 1, void)

Definition at line 98 of file kfifo.h.

#define STRUCT_KFIFO_REC_2 ( size ) struct __STRUCT_KFIFO(unsigned char, size, 2, void)

Definition at line 101 of file kfifo.h.

Function Documentation

int __kfifo_alloc	(	struct __kfifo *	fifo,
		unsigned int	size,
		size_t	esize,
		gfp_t	gfp_mask
	)

Definition at line 38 of file kfifo.c.

void __kfifo_dma_in_finish_r	(	struct __kfifo *	fifo,
		unsigned int	len,
		size_t	recsize
	)

Definition at line 578 of file kfifo.c.

unsigned int __kfifo_dma_in_prepare	(	struct __kfifo *	fifo,
		struct scatterlist *	sgl,
		int	nents,
		unsigned int	len
	)

Definition at line 371 of file kfifo.c.

unsigned int __kfifo_dma_in_prepare_r	(	struct __kfifo *	fifo,
		struct scatterlist *	sgl,
		int	nents,
		unsigned int	len,
		size_t	recsize
	)

Definition at line 563 of file kfifo.c.

void __kfifo_dma_out_finish_r	(	struct __kfifo *	fifo,
		size_t	recsize
	)

Definition at line 602 of file kfifo.c.

unsigned int __kfifo_dma_out_prepare	(	struct __kfifo *	fifo,
		struct scatterlist *	sgl,
		int	nents,
		unsigned int	len
	)

Definition at line 384 of file kfifo.c.

unsigned int __kfifo_dma_out_prepare_r	(	struct __kfifo *	fifo,
		struct scatterlist *	sgl,
		int	nents,
		unsigned int	len,
		size_t	recsize
	)

Definition at line 587 of file kfifo.c.

void __kfifo_free ( struct __kfifo * fifo )

Definition at line 70 of file kfifo.c.

int __kfifo_from_user	(	struct __kfifo *	fifo,
		const void __user *	from,
		unsigned long	len,
		unsigned int *	copied
	)

Definition at line 225 of file kfifo.c.

int __kfifo_from_user_r	(	struct __kfifo *	fifo,
		const void __user *	from,
		unsigned long	len,
		unsigned int *	copied,
		size_t	recsize
	)

Definition at line 514 of file kfifo.c.

unsigned int __kfifo_in	(	struct __kfifo *	fifo,
		const void *	buf,
		unsigned int	len
	)

Definition at line 128 of file kfifo.c.

unsigned int __kfifo_in_r	(	struct __kfifo *	fifo,
		const void *	buf,
		unsigned int	len,
		size_t	recsize
	)

Definition at line 453 of file kfifo.c.

int __kfifo_init	(	struct __kfifo *	fifo,
		void *	buffer,
		unsigned int	size,
		size_t	esize
	)

Definition at line 81 of file kfifo.c.

unsigned int __kfifo_len_r	(	struct __kfifo *	fifo,
		size_t	recsize
	)

Definition at line 447 of file kfifo.c.

unsigned int __kfifo_max_r	(	unsigned int	len,
		size_t	recsize
	)

Definition at line 397 of file kfifo.c.

unsigned int __kfifo_out	(	struct __kfifo *	fifo,
		void *	buf,
		unsigned int	len
	)

Definition at line 181 of file kfifo.c.

unsigned int __kfifo_out_peek	(	struct __kfifo *	fifo,
		void *	buf,
		unsigned int	len
	)

Definition at line 167 of file kfifo.c.

unsigned int __kfifo_out_peek_r	(	struct __kfifo *	fifo,
		void *	buf,
		unsigned int	len,
		size_t	recsize
	)

Definition at line 479 of file kfifo.c.

unsigned int __kfifo_out_r	(	struct __kfifo *	fifo,
		void *	buf,
		unsigned int	len,
		size_t	recsize
	)

Definition at line 491 of file kfifo.c.

void __kfifo_skip_r	(	struct __kfifo *	fifo,
		size_t	recsize
	)

Definition at line 505 of file kfifo.c.

int __kfifo_to_user	(	struct __kfifo *	fifo,
		void __user *	to,
		unsigned long	len,
		unsigned int *	copied
	)

Definition at line 285 of file kfifo.c.

int __kfifo_to_user_r	(	struct __kfifo *	fifo,
		void __user *	to,
		unsigned long	len,
		unsigned int *	copied,
		size_t	recsize
	)

Definition at line 538 of file kfifo.c.

struct kfifo __STRUCT_KFIFO_PTR	(	unsigned	char,
		0	,
		void
	)

read

struct kfifo_rec_ptr_1 __STRUCT_KFIFO_PTR	(	unsigned	char,
		1	,
		void
	)

read

struct kfifo_rec_ptr_2 __STRUCT_KFIFO_PTR	(	unsigned	char,
		2	,
		void
	)

read

Data Structures

Macros

Functions

Macro Definition Documentation

Function Documentation