rculist.h

Go to the documentation of this file.

#ifndef _LINUX_RCULIST_H
#define _LINUX_RCULIST_H

#ifdef __KERNEL__

/*
 * RCU-protected list version
 */
#include <linux/list.h>
#include <linux/rcupdate.h>

/*
 * Why is there no list_empty_rcu()?  Because list_empty() serves this
 * purpose.  The list_empty() function fetches the RCU-protected pointer
 * and compares it to the address of the list head, but neither dereferences
 * this pointer itself nor provides this pointer to the caller.  Therefore,
 * it is not necessary to use rcu_dereference(), so that list_empty() can
 * be used anywhere you would want to use a list_empty_rcu().
 */

/*
 * return the ->next pointer of a list_head in an rcu safe
 * way, we must not access it directly
 */
#define list_next_rcu(list) (*((struct list_head __rcu **)(&(list)->next)))

/*
 * Insert a new entry between two known consecutive entries.
 *
 * This is only for internal list manipulation where we know
 * the prev/next entries already!
 */
#ifndef CONFIG_DEBUG_LIST
static inline void __list_add_rcu(struct list_head *new,
        struct list_head *prev, struct list_head *next)
{
    new->next = next;
    new->prev = prev;
    rcu_assign_pointer(list_next_rcu(prev), new);
    next->prev = new;
}
#else
extern void __list_add_rcu(struct list_head *new,
        struct list_head *prev, struct list_head *next);
#endif

static inline void list_add_rcu(struct list_head *new, struct list_head *head)
{
    __list_add_rcu(new, head, head->next);
}

static inline void list_add_tail_rcu(struct list_head *new,
                    struct list_head *head)
{
    __list_add_rcu(new, head->prev, head);
}

static inline void list_del_rcu(struct list_head *entry)
{
    __list_del_entry(entry);
    entry->prev = LIST_POISON2;
}

static inline void hlist_del_init_rcu(struct hlist_node *n)
{
    if (!hlist_unhashed(n)) {
        __hlist_del(n);
        n->pprev = NULL;
    }
}

static inline void list_replace_rcu(struct list_head *old,
                struct list_head *new)
{
    new->next = old->next;
    new->prev = old->prev;
    rcu_assign_pointer(list_next_rcu(new->prev), new);
    new->next->prev = new;
    old->prev = LIST_POISON2;
}

static inline void list_splice_init_rcu(struct list_head *list,
                    struct list_head *head,
                    void (*sync)(void))
{
    struct list_head *first = list->next;
    struct list_head *last = list->prev;
    struct list_head *at = head->next;

    if (list_empty(list))
        return;

    /* "first" and "last" tracking list, so initialize it. */

    INIT_LIST_HEAD(list);

    /*
     * At this point, the list body still points to the source list.
     * Wait for any readers to finish using the list before splicing
     * the list body into the new list.  Any new readers will see
     * an empty list.
     */

    sync();

    /*
     * Readers are finished with the source list, so perform splice.
     * The order is important if the new list is global and accessible
     * to concurrent RCU readers.  Note that RCU readers are not
     * permitted to traverse the prev pointers without excluding
     * this function.
     */

    last->next = at;
    rcu_assign_pointer(list_next_rcu(head), first);
    first->prev = head;
    at->prev = last;
}

#define list_entry_rcu(ptr, type, member) \
    ({typeof (*ptr) __rcu *__ptr = (typeof (*ptr) __rcu __force *)ptr; \
     container_of((typeof(ptr))rcu_dereference_raw(__ptr), type, member); \
    })

#define list_first_or_null_rcu(ptr, type, member) \
    ({struct list_head *__ptr = (ptr); \
      struct list_head __rcu *__next = list_next_rcu(__ptr); \
      likely(__ptr != __next) ? container_of(__next, type, member) : NULL; \
    })

#define list_for_each_entry_rcu(pos, head, member) \
    for (pos = list_entry_rcu((head)->next, typeof(*pos), member); \
        &pos->member != (head); \
        pos = list_entry_rcu(pos->member.next, typeof(*pos), member))


#define list_for_each_continue_rcu(pos, head) \
    for ((pos) = rcu_dereference_raw(list_next_rcu(pos)); \
        (pos) != (head); \
        (pos) = rcu_dereference_raw(list_next_rcu(pos)))

#define list_for_each_entry_continue_rcu(pos, head, member)         \
    for (pos = list_entry_rcu(pos->member.next, typeof(*pos), member); \
         &pos->member != (head);    \
         pos = list_entry_rcu(pos->member.next, typeof(*pos), member))

static inline void hlist_del_rcu(struct hlist_node *n)
{
    __hlist_del(n);
    n->pprev = LIST_POISON2;
}

static inline void hlist_replace_rcu(struct hlist_node *old,
                    struct hlist_node *new)
{
    struct hlist_node *next = old->next;

    new->next = next;
    new->pprev = old->pprev;
    rcu_assign_pointer(*(struct hlist_node __rcu **)new->pprev, new);
    if (next)
        new->next->pprev = &new->next;
    old->pprev = LIST_POISON2;
}

/*
 * return the first or the next element in an RCU protected hlist
 */
#define hlist_first_rcu(head)   (*((struct hlist_node __rcu **)(&(head)->first)))
#define hlist_next_rcu(node)    (*((struct hlist_node __rcu **)(&(node)->next)))
#define hlist_pprev_rcu(node)   (*((struct hlist_node __rcu **)((node)->pprev)))

static inline void hlist_add_head_rcu(struct hlist_node *n,
                    struct hlist_head *h)
{
    struct hlist_node *first = h->first;

    n->next = first;
    n->pprev = &h->first;
    rcu_assign_pointer(hlist_first_rcu(h), n);
    if (first)
        first->pprev = &n->next;
}

static inline void hlist_add_before_rcu(struct hlist_node *n,
                    struct hlist_node *next)
{
    n->pprev = next->pprev;
    n->next = next;
    rcu_assign_pointer(hlist_pprev_rcu(n), n);
    next->pprev = &n->next;
}

static inline void hlist_add_after_rcu(struct hlist_node *prev,
                       struct hlist_node *n)
{
    n->next = prev->next;
    n->pprev = &prev->next;
    rcu_assign_pointer(hlist_next_rcu(prev), n);
    if (n->next)
        n->next->pprev = &n->next;
}

#define __hlist_for_each_rcu(pos, head)             \
    for (pos = rcu_dereference(hlist_first_rcu(head));  \
         pos;                       \
         pos = rcu_dereference(hlist_next_rcu(pos)))

#define hlist_for_each_entry_rcu(tpos, pos, head, member)       \
    for (pos = rcu_dereference_raw(hlist_first_rcu(head));      \
        pos &&                           \
        ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1; }); \
        pos = rcu_dereference_raw(hlist_next_rcu(pos)))

#define hlist_for_each_entry_rcu_bh(tpos, pos, head, member)         \
    for (pos = rcu_dereference_bh((head)->first);            \
        pos &&                           \
        ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1; }); \
        pos = rcu_dereference_bh(pos->next))

#define hlist_for_each_entry_continue_rcu(tpos, pos, member)        \
    for (pos = rcu_dereference((pos)->next);            \
         pos &&                         \
         ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1; });  \
         pos = rcu_dereference(pos->next))

#define hlist_for_each_entry_continue_rcu_bh(tpos, pos, member)     \
    for (pos = rcu_dereference_bh((pos)->next);         \
         pos &&                         \
         ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1; });  \
         pos = rcu_dereference_bh(pos->next))


#endif  /* __KERNEL__ */
#endif