用户态list.h-凯发app官方网站

凯发app官方网站-凯发k8官网下载客户端中心 | | 凯发app官方网站-凯发k8官网下载客户端中心

苦海澜石

凯发app官方网站首页　| 　博文目录　| 　关于我

khls27

  • 博客访问： 752962
  • 博文数量： 144
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 1150
  • 用 户 组： 普通用户
  • 注册时间： 2014-03-17 14:32
个人简介

小公司研发总监，既当司令也当兵！

文章分类

全部博文（144）

推荐博文
相关博文
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
用户态list.h

分类： linux

2018-08-25 22:54:52

list.rar

点击(此处)折叠或打开

  1. #ifndef _user_list_h
  2. #define _user_list_h

  4. struct list_head {
  5.     struct list_head *next, *prev;
  6. };

  8. /*
  9.  * architectures might want to move the poison pointer offset
  10.  * into some well-recognized area such as 0xdead000000000000,
  11.  * that is also not mappable by user-space exploits:
  12.  */
  13. #define poison_pointer_delta 0

  15. /*
  16.  * these are non-null pointers that will result in page faults
  17.  * under normal circumstances, used to verify that nobody uses
  18.  * non-initialized list entries.
  19.  */
  20. #define list_poison1 ((void *) 0x00100100 poison_pointer_delta)
  21. #define list_poison2 ((void *) 0x00200200 poison_pointer_delta)


  24. #ifndef offsetof
  25. #define offsetof(type, member) ((size_t) &((type *)0)->member)
  26. #endif


  29. /**
  30.  * container_of - cast a member of a structure out to the containing structure
  31.  * @ptr:    the pointer to the member.
  32.  * @type:    the type of the container struct this is embedded in.
  33.  * @member:    the name of the member within the struct.
  34.  *
  35.  */
  36. #define container_of(ptr, type, member) ({            \
  37.     const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
  38.     (type *)( (char *)__mptr - offsetof(type,member) );})


  41. /*
  42.  * simple doubly linked list implementation.
  43.  *
  44.  * some of the internal functions ("__xxx") are useful when
  45.  * manipulating whole lists rather than single entries, as
  46.  * sometimes we already know the next/prev entries and we can
  47.  * generate better code by using them directly rather than
  48.  * using the generic single-entry routines.
  49.  */

  51. #define list_head_init(name) { &(name), &(name) }

  53. #define list_head(name) \
  54.     struct list_head name = list_head_init(name)

  56. static inline void init_list_head(struct list_head *list)
  57. {
  58.     list->next = list;
  59.     list->prev = list;
  60. }

  62. static inline void __list_add(struct list_head *new,
  63.                             struct list_head *prev,
  64.                             struct list_head *next)
  65. {
  66.     next->prev = new;
  67.     new->next = next;
  68.     new->prev = prev;
  69.     prev->next = new;
  70. }


  73. /**
  74.  * list_add - add a new entry
  75.  * @new: new entry to be added
  76.  * @head: list head to add it after
  77.  *
  78.  * insert a new entry after the specified head.
  79.  * this is good for implementing stacks.
  80.  */
  81. static inline void list_add(struct list_head *new, struct list_head *head)
  82. {
  83.     __list_add(new, head, head->next);
  84. }


  87. /**
  88.  * list_add_tail - add a new entry
  89.  * @new: new entry to be added
  90.  * @head: list head to add it before
  91.  *
  92.  * insert a new entry before the specified head.
  93.  * this is useful for implementing queues.
  94.  */
  95. static inline void list_add_tail(struct list_head *new, struct list_head *head)
  96. {
  97.     __list_add(new, head->prev, head);
  98. }

  100. /*
  101.  * delete a list entry by making the prev/next entries
  102.  * point to each other.
  103.  *
  104.  * this is only for internal list manipulation where we know
  105.  * the prev/next entries
  106.  */
  107. static inline void __list_del(struct list_head * prev, struct list_head * next)
  108. {
  109.     next->prev = prev;
  110.     prev->next = next;
  111. }

  113. /**
  114.  * list_del - deletes entry from list.
  115.  * @entry: the element to delete from the list.
  116.  * note: list_empty() on entry does not return true after this, the entry is
  117.  * in an undefined state.
  118.  */

  120. static inline void __list_del_entry(struct list_head *entry)
  121. {
  122.     __list_del(entry->prev, entry->next);
  123. }

  125. static inline void list_del(struct list_head *entry)
  126. {
  127.     __list_del(entry->prev, entry->next);
  128.     entry->next = list_poison1;
  129.     entry->prev = list_poison2;
  130. }

  132. /**
  133.  * list_replace - replace old entry by new one
  134.  * @old : the element to be replaced
  135.  * @new : the new element to insert
  136.  *
  137.  * if @old was empty, it will be overwritten.
  138.  */
  139. static inline void list_replace(struct list_head *old,
  140.                 struct list_head *new)
  141. {
  142.     new->next = old->next;
  143.     new->next->prev = new;
  144.     new->prev = old->prev;
  145.     new->prev->next = new;
  146. }

  148. static inline void list_replace_init(struct list_head *old,
  149.                     struct list_head *new)
  150. {
  151.     list_replace(old, new);
  152.     init_list_head(old);
  153. }

  155. /**
  156.  * list_del_init - deletes entry from list and reinitialize it.
  157.  * @entry: the element to delete from the list.
  158.  */
  159. static inline void list_del_init(struct list_head *entry)
  160. {
  161.     __list_del_entry(entry);
  162.     init_list_head(entry);
  163. }

  165. /**
  166.  * list_move - delete from one list and add as another's head
  167.  * @list: the entry to move
  168.  * @head: the head that will precede our entry
  169.  */
  170. static inline void list_move(struct list_head *list, struct list_head *head)
  171. {
  172.     __list_del_entry(list);
  173.     list_add(list, head);
  174. }

  176. /**
  177.  * list_move_tail - delete from one list and add as another's tail
  178.  * @list: the entry to move
  179.  * @head: the head that will follow our entry
  180.  */
  181. static inline void list_move_tail(struct list_head *list,
  182.                  struct list_head *head)
  183. {
  184.     __list_del_entry(list);
  185.     list_add_tail(list, head);
  186. }

  188. /**
  189.  * list_is_last - tests whether @list is the last entry in list @head
  190.  * @list: the entry to test
  191.  * @head: the head of the list
  192.  */
  193. static inline int list_is_last(const struct list_head *list,
  194.                 const struct list_head *head)
  195. {
  196.     return list->next == head;
  197. }

  199. /**
  200.  * list_empty - tests whether a list is empty
  201.  * @head: the list to test.
  202.  */
  203. static inline int list_empty(const struct list_head *head)
  204. {
  205.     return head->next == head;
  206. }

  208. /**
  209.  * list_empty_careful - tests whether a list is empty and not being modified
  210.  * @head: the list to test
  211.  *
  212.  * description:
  213.  * tests whether a list is empty _and_ checks that no other cpu might be
  214.  * in the process of modifying either member (next or prev)
  215.  *
  216.  * note: using list_empty_careful() without synchronization
  217.  * can only be safe if the only activity that can happen
  218.  * to the list entry is list_del_init(). eg. it cannot be used
  219.  * if another cpu could re-list_add() it.
  220.  */
  221. static inline int list_empty_careful(const struct list_head *head)
  222. {
  223.     struct list_head *next = head->next;
  224.     return (next == head) && (next == head->prev);
  225. }

  227. /**
  228.  * list_rotate_left - rotate the list to the left
  229.  * @head: the head of the list
  230.  */
  231. static inline void list_rotate_left(struct list_head *head)
  232. {
  233.     struct list_head *first;

  235.     if (!list_empty(head)) {
  236.         first = head->next;
  237.         list_move_tail(first, head);
  238.     }
  239. }

  241. /**
  242.  * list_is_singular - tests whether a list has just one entry.
  243.  * @head: the list to test.
  244.  */
  245. static inline int list_is_singular(const struct list_head *head)
  246. {
  247.     return !list_empty(head) && (head->next == head->prev);
  248. }

  250. static inline void __list_cut_position(struct list_head *list,
  251.         struct list_head *head, struct list_head *entry)
  252. {
  253.     struct list_head *new_first = entry->next;
  254.     list->next = head->next;
  255.     list->next->prev = list;
  256.     list->prev = entry;
  257.     entry->next = list;
  258.     head->next = new_first;
  259.     new_first->prev = head;
  260. }

  262. /**
  263.  * list_cut_position - cut a list into two
  264.  * @list: a new list to add all removed entries
  265.  * @head: a list with entries
  266.  * @entry: an entry within head, could be the head itself
  267.  *    and if so we won't cut the list
  268.  *
  269.  * this helper moves the initial part of @head, up to and
  270.  * including @entry, from @head to @list. you should
  271.  * pass on @entry an element you know is on @head. @list
  272.  * should be an empty list or a list you do not care about
  273.  * losing its data.
  274.  *
  275.  */
  276. static inline void list_cut_position(struct list_head *list,
  277.         struct list_head *head, struct list_head *entry)
  278. {
  279.     if (list_empty(head))
  280.         return;
  281.     if (list_is_singular(head) &&
  282.         (head->next != entry && head != entry))
  283.         return;
  284.     if (entry == head)
  285.         init_list_head(list);
  286.     else
  287.         __list_cut_position(list, head, entry);
  288. }

  290. static inline void __list_splice(const struct list_head *list,
  291.                  struct list_head *prev,
  292.                  struct list_head *next)
  293. {
  294.     struct list_head *first = list->next;
  295.     struct list_head *last = list->prev;

  297.     first->prev = prev;
  298.     prev->next = first;

  300.     last->next = next;
  301.     next->prev = last;
  302. }

  304. /**
  305.  * list_splice - join two lists, this is designed for stacks
  306.  * @list: the new list to add.
  307.  * @head: the place to add it in the first list.
  308.  */
  309. static inline void list_splice(const struct list_head *list,
  310.                 struct list_head *head)
  311. {
  312.     if (!list_empty(list))
  313.         __list_splice(list, head, head->next);
  314. }

  316. /**
  317.  * list_splice_tail - join two lists, each list being a queue
  318.  * @list: the new list to add.
  319.  * @head: the place to add it in the first list.
  320.  */
  321. static inline void list_splice_tail(struct list_head *list,
  322.                 struct list_head *head)
  323. {
  324.     if (!list_empty(list))
  325.         __list_splice(list, head->prev, head);
  326. }

  328. /**
  329.  * list_splice_init - join two lists and reinitialise the emptied list.
  330.  * @list: the new list to add.
  331.  * @head: the place to add it in the first list.
  332.  *
  333.  * the list at @list is reinitialised
  334.  */
  335. static inline void list_splice_init(struct list_head *list,
  336.                  struct list_head *head)
  337. {
  338.     if (!list_empty(list)) {
  339.         __list_splice(list, head, head->next);
  340.         init_list_head(list);
  341.     }
  342. }

  344. /**
  345.  * list_splice_tail_init - join two lists and reinitialise the emptied list
  346.  * @list: the new list to add.
  347.  * @head: the place to add it in the first list.
  348.  *
  349.  * each of the lists is a queue.
  350.  * the list at @list is reinitialised
  351.  */
  352. static inline void list_splice_tail_init(struct list_head *list,
  353.                      struct list_head *head)
  354. {
  355.     if (!list_empty(list)) {
  356.         __list_splice(list, head->prev, head);
  357.         init_list_head(list);
  358.     }
  359. }

  361. /**
  362.  * list_entry - get the struct for this entry
  363.  * @ptr:    the &struct list_head pointer.
  364.  * @type:    the type of the struct this is embedded in.
  365.  * @member:    the name of the list_struct within the struct.
  366.  */
  367. #define list_entry(ptr, type, member) \
  368.     container_of(ptr, type, member)

  370. /**
  371.  * list_first_entry - get the first element from a list
  372.  * @ptr:    the list head to take the element from.
  373.  * @type:    the type of the struct this is embedded in.
  374.  * @member:    the name of the list_struct within the struct.
  375.  *
  376.  * note, that list is expected to be not empty.
  377.  */
  378. #define list_first_entry(ptr, type, member) \
  379.     list_entry((ptr)->next, type, member)

  381. /**
  382.  * list_for_each    -    iterate over a list
  383.  * @pos:    the &struct list_head to use as a loop cursor.
  384.  * @head:    the head for your list.
  385.  */
  386. #define list_for_each(pos, head) \
  387.     for (pos = (head)->next; pos != (head); pos = pos->next)

  389. /**
  390.  * __list_for_each    -    iterate over a list
  391.  * @pos:    the &struct list_head to use as a loop cursor.
  392.  * @head:    the head for your list.
  393.  *
  394.  * this variant doesn't differ from list_for_each() any more.
  395.  * we don't do prefetching in either case.
  396.  */
  397. #define __list_for_each(pos, head) \
  398.     for (pos = (head)->next; pos != (head); pos = pos->next)

  400. /**
  401.  * list_for_each_prev    -    iterate over a list backwards
  402.  * @pos:    the &struct list_head to use as a loop cursor.
  403.  * @head:    the head for your list.
  404.  */
  405. #define list_for_each_prev(pos, head) \
  406.     for (pos = (head)->prev; pos != (head); pos = pos->prev)

  408. /**
  409.  * list_for_each_safe - iterate over a list safe against removal of list entry
  410.  * @pos:    the &struct list_head to use as a loop cursor.
  411.  * @n:        another &struct list_head to use as temporary storage
  412.  * @head:    the head for your list.
  413.  */
  414. #define list_for_each_safe(pos, n, head) \
  415.     for (pos = (head)->next, n = pos->next; pos != (head); \
  416.         pos = n, n = pos->next)

  418. /**
  419.  * list_for_each_prev_safe - iterate over a list backwards safe against removal of list entry
  420.  * @pos:    the &struct list_head to use as a loop cursor.
  421.  * @n:        another &struct list_head to use as temporary storage
  422.  * @head:    the head for your list.
  423.  */
  424. #define list_for_each_prev_safe(pos, n, head) \
  425.     for (pos = (head)->prev, n = pos->prev; \
  426.      pos != (head); \
  427.      pos = n, n = pos->prev)

  429. /**
  430.  * list_for_each_entry    -    iterate over list of given type
  431.  * @pos:    the type * to use as a loop cursor.
  432.  * @head:    the head for your list.
  433.  * @member:    the name of the list_struct within the struct.
  434.  */
  435. #define list_for_each_entry(pos, head, member)                \
  436.     for (pos = list_entry((head)->next, typeof(*pos), member);    \
  437.      &pos->member != (head);     \
  438.      pos = list_entry(pos->member.next, typeof(*pos), member))

  440. /**
  441.  * list_for_each_entry_reverse - iterate backwards over list of given type.
  442.  * @pos:    the type * to use as a loop cursor.
  443.  * @head:    the head for your list.
  444.  * @member:    the name of the list_struct within the struct.
  445.  */
  446. #define list_for_each_entry_reverse(pos, head, member)            \
  447.     for (pos = list_entry((head)->prev, typeof(*pos), member);    \
  448.      &pos->member != (head);     \
  449.      pos = list_entry(pos->member.prev, typeof(*pos), member))

  451. /**
  452.  * list_prepare_entry - prepare a pos entry for use in list_for_each_entry_continue()
  453.  * @pos:    the type * to use as a start point
  454.  * @head:    the head of the list
  455.  * @member:    the name of the list_struct within the struct.
  456.  *
  457.  * prepares a pos entry for use as a start point in list_for_each_entry_continue().
  458.  */
  459. #define list_prepare_entry(pos, head, member) \
  460.     ((pos) ? : list_entry(head, typeof(*pos), member))

  462. /**
  463.  * list_for_each_entry_continue - continue iteration over list of given type
  464.  * @pos:    the type * to use as a loop cursor.
  465.  * @head:    the head for your list.
  466.  * @member:    the name of the list_struct within the struct.
  467.  *
  468.  * continue to iterate over list of given type, continuing after
  469.  * the current position.
  470.  */
  471. #define list_for_each_entry_continue(pos, head, member)         \
  472.     for (pos = list_entry(pos->member.next, typeof(*pos), member);    \
  473.      &pos->member != (head);    \
  474.      pos = list_entry(pos->member.next, typeof(*pos), member))

  476. /**
  477.  * list_for_each_entry_continue_reverse - iterate backwards from the given point
  478.  * @pos:    the type * to use as a loop cursor.
  479.  * @head:    the head for your list.
  480.  * @member:    the name of the list_struct within the struct.
  481.  *
  482.  * start to iterate over list of given type backwards, continuing after
  483.  * the current position.
  484.  */
  485. #define list_for_each_entry_continue_reverse(pos, head, member)        \
  486.     for (pos = list_entry(pos->member.prev, typeof(*pos), member);    \
  487.      &pos->member != (head);    \
  488.      pos = list_entry(pos->member.prev, typeof(*pos), member))

  490. /**
  491.  * list_for_each_entry_from - iterate over list of given type from the current point
  492.  * @pos:    the type * to use as a loop cursor.
  493.  * @head:    the head for your list.
  494.  * @member:    the name of the list_struct within the struct.
  495.  *
  496.  * iterate over list of given type, continuing from current position.
  497.  */
  498. #define list_for_each_entry_from(pos, head, member)             \
  499.     for (; &pos->member != (head);    \
  500.      pos = list_entry(pos->member.next, typeof(*pos), member))

  502. /**
  503.  * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
  504.  * @pos:    the type * to use as a loop cursor.
  505.  * @n:        another type * to use as temporary storage
  506.  * @head:    the head for your list.
  507.  * @member:    the name of the list_struct within the struct.
  508.  */
  509. #define list_for_each_entry_safe(pos, n, head, member)            \
  510.     for (pos = list_entry((head)->next, typeof(*pos), member),    \
  511.         n = list_entry(pos->member.next, typeof(*pos), member);    \
  512.      &pos->member != (head);                     \
  513.      pos = n, n = list_entry(n->member.next, typeof(*n), member))

  515. /**
  516.  * list_for_each_entry_safe_continue - continue list iteration safe against removal
  517.  * @pos:    the type * to use as a loop cursor.
  518.  * @n:        another type * to use as temporary storage
  519.  * @head:    the head for your list.
  520.  * @member:    the name of the list_struct within the struct.
  521.  *
  522.  * iterate over list of given type, continuing after current point,
  523.  * safe against removal of list entry.
  524.  */
  525. #define list_for_each_entry_safe_continue(pos, n, head, member)         \
  526.     for (pos = list_entry(pos->member.next, typeof(*pos), member),         \
  527.         n = list_entry(pos->member.next, typeof(*pos), member);        \
  528.      &pos->member != (head);                        \
  529.      pos = n, n = list_entry(n->member.next, typeof(*n), member))

  531. /**
  532.  * list_for_each_entry_safe_from - iterate over list from current point safe against removal
  533.  * @pos:    the type * to use as a loop cursor.
  534.  * @n:        another type * to use as temporary storage
  535.  * @head:    the head for your list.
  536.  * @member:    the name of the list_struct within the struct.
  537.  *
  538.  * iterate over list of given type from current point, safe against
  539.  * removal of list entry.
  540.  */
  541. #define list_for_each_entry_safe_from(pos, n, head, member)             \
  542.     for (n = list_entry(pos->member.next, typeof(*pos), member);        \
  543.      &pos->member != (head);                        \
  544.      pos = n, n = list_entry(n->member.next, typeof(*n), member))

  546. /**
  547.  * list_for_each_entry_safe_reverse - iterate backwards over list safe against removal
  548.  * @pos:    the type * to use as a loop cursor.
  549.  * @n:        another type * to use as temporary storage
  550.  * @head:    the head for your list.
  551.  * @member:    the name of the list_struct within the struct.
  552.  *
  553.  * iterate backwards over list of given type, safe against removal
  554.  * of list entry.
  555.  */
  556. #define list_for_each_entry_safe_reverse(pos, n, head, member)        \
  557.     for (pos = list_entry((head)->prev, typeof(*pos), member),    \
  558.         n = list_entry(pos->member.prev, typeof(*pos), member);    \
  559.      &pos->member != (head);                     \
  560.      pos = n, n = list_entry(n->member.prev, typeof(*n), member))

  562. /**
  563.  * list_safe_reset_next - reset a stale list_for_each_entry_safe loop
  564.  * @pos:    the loop cursor used in the list_for_each_entry_safe loop
  565.  * @n:        temporary storage used in list_for_each_entry_safe
  566.  * @member:    the name of the list_struct within the struct.
  567.  *
  568.  * list_safe_reset_next is not safe to use in general if the list may be
  569.  * modified concurrently (eg. the lock is dropped in the loop body). an
  570.  * exception to this is if the cursor element (pos) is pinned in the list,
  571.  * and list_safe_reset_next is called after re-taking the lock and before
  572.  * completing the current iteration of the loop body.
  573.  */
  574. #define list_safe_reset_next(pos, n, member)                \
  575.     n = list_entry(pos->member.next, typeof(*pos), member)

  577. #endif


阅读(3295) | 评论(0) | 转发(0) |
0

上一篇：ubuntu虚拟机安装和配置纪要

下一篇：【openwrt】时间同步

给主人留下些什么吧！~~
| | | | |

凯发app官方网站 copyright 2001-2010 chinaunix.net all rights reserved 北京皓辰网域网络信息技术有限公司. 凯发k8官网下载客户端中心的版权所有

感谢所有关心和支持过chinaunix的朋友们
")); function link(t){ var href= $(t).attr('href'); href ="?url=" encodeuricomponent(location.href); $(t).attr('href',href); //setcookie("returnouturl", location.href, 60, "/"); }
网站地图