include/ring.h

Go to the documentation of this file.

#ifndef RING_H_INCLUDED
#define RING_H_INCLUDED

#include <stdbool.h>

struct ring_head {
        unsigned long head;
        unsigned long tail;
};

#ifdef CONFIG_RING_DEBUG
#include <util.h>

/*
 * Undefined to force a link error when the ring size is constant and
 * not a power of two.
 */
extern void __bad_constant_ring_size(unsigned long size);

/* Implement this to catch bad non-constant ring sizes */
extern void bad_ring_size(unsigned long size);

static inline void ring_check_size(unsigned long size)
{
        if (!is_power_of_two(size)) {
                if (__builtin_constant_p(size))
                        __bad_constant_ring_size(size);
                else
                        bad_ring_size(size);
        }
}
#else
static inline void ring_check_size(unsigned long size)
{

}
#endif

static inline unsigned long ring_get_head(struct ring_head *ring,
                unsigned long ring_size)
{
        ring_check_size(ring_size);

        return ring->head & (ring_size - 1);
}

static inline unsigned long ring_get_tail(struct ring_head *ring,
                unsigned long ring_size)
{
        ring_check_size(ring_size);

        return ring->tail & (ring_size - 1);
}

static inline unsigned long ring_entries_used(struct ring_head *ring,
                unsigned long ring_size)
{
        ring_check_size(ring_size);

        return ring->head - ring->tail;
}

static inline unsigned long ring_entries_used_before_end(struct ring_head *ring,
                unsigned long ring_size)
{
        unsigned long head = ring->head;
        unsigned long tail = ring->tail;

        ring_check_size(ring_size);

        if ((head ^ tail) & ring_size)
                return ring_size - (tail & (ring_size - 1));
        else
                return head - tail;
}

static inline unsigned long ring_entries_unused(struct ring_head *ring,
                unsigned long ring_size)
{
        return ring_size - ring_entries_used(ring, ring_size);
}

static inline unsigned long ring_entries_unused_before_end(
                struct ring_head *ring, unsigned long ring_size)
{
        unsigned long head = ring->head;
        unsigned long tail = ring->tail;

        ring_check_size(ring_size);

        if ((head ^ tail) & ring_size)
                return ring_size + tail - head;
        else
                return ring_size - (head & (ring_size - 1));
}

static inline bool ring_is_empty(struct ring_head *ring,
                unsigned long ring_size)
{
        return ring->head == ring->tail;
}

static inline void ring_insert_entries(struct ring_head *ring,
                unsigned long nr_entries)
{
        barrier();
        ring->head += nr_entries;
}

static inline void ring_extract_entries(struct ring_head *ring,
                unsigned long nr_entries)
{
        barrier();
        ring->tail += nr_entries;
}

static inline void ring_reset(struct ring_head *ring)
{
        ring->head = ring->tail = 0;
}

#endif /* RING_H_INCLUDED */

---