list.h

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    1 /*      $NetBSD: list.h,v 1.5 2014/08/20 15:26:52 riastradh Exp $       */
    2 
    3 /*-
    4  * Copyright (c) 2013 The NetBSD Foundation, Inc.
    5  * All rights reserved.
    6  *
    7  * This code is derived from software contributed to The NetBSD Foundation
    8  * by Taylor R. Campbell.
    9  *
   10  * Redistribution and use in source and binary forms, with or without
   11  * modification, are permitted provided that the following conditions
   12  * are met:
   13  * 1. Redistributions of source code must retain the above copyright
   14  *    notice, this list of conditions and the following disclaimer.
   15  * 2. Redistributions in binary form must reproduce the above copyright
   16  *    notice, this list of conditions and the following disclaimer in the
   17  *    documentation and/or other materials provided with the distribution.
   18  *
   19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   29  * POSSIBILITY OF SUCH DAMAGE.
   30  */
   31 
   32 /*
   33  * Notes on porting:
   34  *
   35  * - LIST_HEAD(x) means a declaration `struct list_head x =
   36  *   LIST_HEAD_INIT(x)' in Linux, but something else in NetBSD.
   37  *   Replace by the expansion.
   38  *
   39  * - The `_rcu' routines here are not actually pserialize(9)-safe.
   40  *   They need dependent read memory barriers added.  Please fix this
   41  *   if you need to use them with pserialize(9).
   42  */
   43 
   44 #ifndef _LINUX_LIST_H_
   45 #define _LINUX_LIST_H_
   46 
   47 #include <sys/queue.h>
   48 
   49 #define container_of(ptr, type, member)                         \
   50 ({                                                              \
   51         __typeof(((type *)0)->member) *_p = (ptr);              \
   52         (type *)((char *)_p - offsetof(type, member));          \
   53 })
   54 
   55 /*
   56  * Doubly-linked lists.
   57  */
   58 
   59 struct list_head {
   60         struct list_head *prev;
   61         struct list_head *next;
   62 };
   63 
   64 #define LIST_HEAD_INIT(name)    { .prev = &(name), .next = &(name) }
   65 
   66 static inline void
   67 INIT_LIST_HEAD(struct list_head *head)
   68 {
   69         head->prev = head;
   70         head->next = head;
   71 }
   72 
   73 static inline struct list_head *
   74 list_first(const struct list_head *head)
   75 {
   76         return head->next;
   77 }
   78 
   79 static inline struct list_head *
   80 list_last(const struct list_head *head)
   81 {
   82         return head->prev;
   83 }
   84 
   85 static inline struct list_head *
   86 list_next(const struct list_head *node)
   87 {
   88         return node->next;
   89 }
   90 
   91 static inline struct list_head *
   92 list_prev(const struct list_head *node)
   93 {
   94         return node->prev;
   95 }
   96 
   97 static inline int
   98 list_empty(const struct list_head *head)
   99 {
  100         return (head->next == head);
  101 }
  102 
  103 static inline int
  104 list_is_singular(const struct list_head *head)
  105 {
  106 
  107         if (list_empty(head))
  108                 return false;
  109         if (head->next != head->prev)
  110                 return false;
  111         return true;
  112 }
  113 
  114 static inline void
  115 __list_add_between(struct list_head *prev, struct list_head *node,
  116     struct list_head *next)
  117 {
  118         prev->next = node;
  119         node->prev = prev;
  120         node->next = next;
  121         next->prev = node;
  122 }
  123 
  124 static inline void
  125 list_add(struct list_head *node, struct list_head *head)
  126 {
  127         __list_add_between(head, node, head->next);
  128 }
  129 
  130 static inline void
  131 list_add_tail(struct list_head *node, struct list_head *head)
  132 {
  133         __list_add_between(head->prev, node, head);
  134 }
  135 
  136 static inline void
  137 list_del(struct list_head *entry)
  138 {
  139         entry->prev->next = entry->next;
  140         entry->next->prev = entry->prev;
  141 }
  142 
  143 static inline void
  144 __list_splice_between(struct list_head *prev, const struct list_head *list,
  145     struct list_head *next)
  146 {
  147         struct list_head *first = list->next;
  148         struct list_head *last = list->prev;
  149 
  150         first->prev = prev;
  151         prev->next = first;
  152 
  153         last->next = next;
  154         next->prev = last;
  155 }
  156 
  157 static inline void
  158 list_splice(const struct list_head *list, struct list_head *head)
  159 {
  160         if (!list_empty(list))
  161                 __list_splice_between(head, list, head->next);
  162 }
  163 
  164 static inline void
  165 list_splice_tail(const struct list_head *list, struct list_head *head)
  166 {
  167         if (!list_empty(list))
  168                 __list_splice_between(head->prev, list, head);
  169 }
  170 
  171 static inline void
  172 list_move(struct list_head *node, struct list_head *head)
  173 {
  174         list_del(node);
  175         list_add(node, head);
  176 }
  177 
  178 static inline void
  179 list_move_tail(struct list_head *node, struct list_head *head)
  180 {
  181         list_del(node);
  182         list_add_tail(node, head);
  183 }
  184 
  185 static inline void
  186 list_replace(struct list_head *old, struct list_head *new)
  187 {
  188         new->prev = old->prev;
  189         old->prev->next = new;
  190         new->next = old->next;
  191         old->next->prev = new;
  192 }
  193 
  194 static inline void
  195 list_del_init(struct list_head *node)
  196 {
  197         list_del(node);
  198         INIT_LIST_HEAD(node);
  199 }
  200 
  201 #define list_entry(PTR, TYPE, FIELD)    container_of(PTR, TYPE, FIELD)
  202 #define list_first_entry(PTR, TYPE, FIELD)                              \
  203         list_entry(list_first((PTR)), TYPE, FIELD)
  204 #define list_last_entry(PTR, TYPE, FIELD)                               \
  205         list_entry(list_last((PTR)), TYPE, FIELD)
  206 #define list_next_entry(ENTRY, FIELD)                                   \
  207         list_entry(list_next(&(ENTRY)->FIELD), typeof(*(ENTRY)), FIELD)
  208 #define list_prev_entry(ENTRY, FIELD)                                   \
  209         list_entry(list_prev(&(ENTRY)->FIELD), typeof(*(ENTRY)), FIELD)
  210 
  211 #define list_for_each(VAR, HEAD)                                        \
  212         for ((VAR) = list_first((HEAD));                                \
  213                 (VAR) != (HEAD);                                        \
  214                 (VAR) = list_next((VAR)))
  215 
  216 #define list_for_each_safe(VAR, NEXT, HEAD)                             \
  217         for ((VAR) = list_first((HEAD));                                \
  218                 ((VAR) != (HEAD)) && ((NEXT) = list_next((VAR)), 1);    \
  219                 (VAR) = (NEXT))
  220 
  221 #define list_for_each_entry(VAR, HEAD, FIELD)                           \
  222         for ((VAR) = list_entry(list_first((HEAD)), typeof(*(VAR)), FIELD); \
  223                 &(VAR)->FIELD != (HEAD);                                \
  224                 (VAR) = list_entry(list_next(&(VAR)->FIELD), typeof(*(VAR)), \
  225                     FIELD))
  226 
  227 #define list_for_each_entry_reverse(VAR, HEAD, FIELD)                   \
  228         for ((VAR) = list_entry(list_last((HEAD)), typeof(*(VAR)), FIELD); \
  229                 &(VAR)->FIELD != (HEAD);                                \
  230                 (VAR) = list_entry(list_prev(&(VAR)->FIELD), typeof(*(VAR)), \
  231                     FIELD))
  232 
  233 #define list_for_each_entry_safe(VAR, NEXT, HEAD, FIELD)                \
  234         for ((VAR) = list_entry(list_first((HEAD)), typeof(*(VAR)), FIELD); \
  235                 (&(VAR)->FIELD != (HEAD)) &&                            \
  236                     ((NEXT) = list_entry(list_next(&(VAR)->FIELD),      \
  237                         typeof(*(VAR)), FIELD), 1);                     \
  238                 (VAR) = (NEXT))
  239 
  240 #define list_for_each_entry_continue(VAR, HEAD, FIELD)                  \
  241         for ((VAR) = list_next_entry((VAR), FIELD);                     \
  242                 &(VAR)->FIELD != (HEAD);                                \
  243                 (VAR) = list_next_entry((VAR), FIELD))
  244 
  245 #define list_for_each_entry_continue_reverse(VAR, HEAD, FIELD)          \
  246         for ((VAR) = list_prev_entry((VAR), FIELD);                     \
  247                 &(VAR)->FIELD != (HEAD);                                \
  248                 (VAR) = list_prev_entry((VAR), FIELD))
  249 
  250 #define list_for_each_entry_safe_from(VAR, NEXT, HEAD, FIELD)           \
  251         for (;                                                          \
  252                 (&(VAR)->FIELD != (HEAD)) &&                            \
  253                     ((NEXT) = list_next_entry((VAR), FIELD));           \
  254                 (VAR) = (NEXT))
  255 
  256 #endif  /* _LINUX_LIST_H_ */

Cache object: 41579ef75f73d2399fdf2a6680d28d5e

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/contrib/vchiq/interface/compat/list.h

FreeBSD/Linux Kernel Cross Reference
sys/contrib/vchiq/interface/compat/list.h