代码示例_网络编程_select_内核链表

 1 #pragma once
 2 
 3 #include <stdio.h>
 4 #include <stdlib.h>
 5 #include <sys/types.h>
 6 #include <sys/select.h>
 7 #include <sys/time.h>
 8 #include <sys/socket.h>
 9 #include <strings.h>
10 #include <string.h>
11 #include <arpa/inet.h>
12 #include "list.h"
13 
14 #define IP "192.168.2.150"
15 #define PORT 9999
16 #define SIZE 128
17 
18 struct cli_info
19 {
20     struct list_head list;
21     int cli_fd;
22 };

 1 #include "net.h"
 2 
 3 int main(void)
 4 {
 5     //1.创建套接字
 6     int fd = socket(AF_INET,SOCK_STREAM,0);
 7     if(fd<0){
 8         perror("socket failed");
 9         exit(1);
10     }
11 
12 
13     //2.初始服务器地址
14     struct sockaddr_in cli;
15     cli.sin_family = AF_INET;
16     cli.sin_port = htons(PORT);
17     cli.sin_addr.s_addr=inet_addr(IP);
18 
19 
20     //3.发送连接请求
21     if(  connect(fd,(struct sockaddr*)&cli,sizeof(cli))<0  ){
22         perror("connect failed");
23         exit(1);
24     }
25 
26 
27     //4.写
28     char buf[SIZE];
29     while(1){
30     bzero(buf,SIZE);
31     printf("please input:\t");
32     fgets(buf,SIZE,stdin);
33     write(fd,buf,strlen(buf));
34         if(!strncmp(buf,"quit",4))
35             break;
36     }
37 
38 
39     //5.关闭
40     close(fd);
41 
42 
43     return 0 ;
44 }

  1 #include "net.h"
  2 
  3 int main(void)
  4 {
  5     char buf[SIZE];
  6     int newfd = -1;
  7 
  8 
  9     //*****定义初始头结点
 10     struct cli_info head;
 11     INIT_LIST_HEAD(&head.list);
 12 
 13 
 14     //1.创建套接字
 15     int fd = socket(AF_INET,SOCK_STREAM,0);
 16     if(fd<0){
 17         perror("socket failed");
 18         exit(1);
 19     }
 20 
 21 
 22     //2.初始本地地址
 23     struct sockaddr_in ser;
 24     bzero(&ser,sizeof(ser));
 25     ser.sin_family = AF_INET;
 26     ser.sin_port = htons(PORT);
 27     ser.sin_addr.s_addr=htonl(INADDR_ANY);
 28 
 29 
 30     //3.绑定
 31     if(  bind(fd,(struct sockaddr*)&ser,sizeof(ser))<0  ){
 32         perror("bind failed");
 33         exit(1);
 34     }
 35 
 36 
 37     //4.监听
 38     if(  listen(fd,5)<0  ){
 39         perror("listen failed");
 40         exit(1);
 41     }
 42 
 43     int len = sizeof(ser);
 44     int maxfd = -1;
 45 
 46     //5.多路复用
 47     fd_set read_fds;    //定义读集合
 48     FD_ZERO(&read_fds); //清空读集合
 49     maxfd = fd;            //最大描述符
 50 
 51 
 52     //*****
 53     struct cli_info *cur=NULL;
 54     struct list_head *ptr,*q;
 55 
 56 
 57     //6.加入监听处理 读集合
 58     while(1){
 59     FD_SET(0,&read_fds);  //将标准输入加入读集合
 60     FD_SET(fd,&read_fds); //将fd加入读集合
 61     maxfd = fd;              //表示最大读集合
 62 
 63 #if 0
 64     if(maxfd < newfd){
 65         FD_SET(newfd,&read_fds);
 66         maxfd=newfd;
 67     }
 68 #endif
 69     
 70     //*****将文件描述符加入到读集合
 71     list_for_each(ptr,&head.list){
 72         cur = list_entry(ptr,struct cli_info,list);
 73         FD_SET(cur->cli_fd,&read_fds);
 74         if(maxfd<cur->cli_fd)
 75         maxfd = cur->cli_fd;
 76     }
 77 
 78 
 79     int ret = select(maxfd+1,&read_fds,NULL,NULL,NULL);
 80     if(ret<0){
 81         perror("select failed");
 82         exit(1);
 83     }
 84     else if(ret==0){
 85         perror("time out");
 86         exit(1);
 87     }
 88     else{
 89         //6.1 判断输入端是否有相应
 90         if(FD_ISSET(0,&read_fds)){
 91             bzero(buf,SIZE);
 92             fgets(buf,SIZE,stdin);
 93             printf("shell :%s",buf);
 94         }
 95 
 96 
 97         //6.2 判断客户端是否有相应
 98         if(FD_ISSET(fd,&read_fds)){
 99             //*****给新节点申请空间
100             struct cli_info *temp=(struct cli_info*)malloc(sizeof(struct cli_info));
101             if(temp==NULL){
102                 perror("malloc failed");
103                 exit(1);
104             }
105             //接收
106             newfd=accept(fd,(struct sockaddr*)&ser,&len);
107             if(newfd<0){
108                 perror("accept failed");
109                 exit(1);
110             }
111             printf("client connect succsee :  ip=%s   port=%d  用户上线啦 ^.^ ...\n",inet_ntoa(ser.sin_addr),ntohs(ser.sin_port));
112             //*****将连接的新客户文件描述符加入到新节点
113             temp->cli_fd=newfd;
114             //*****把新节点插入到链表
115             list_add(&temp->list,&head.list);
116             }
117 
118 
119         //6.3 判断客户端是否有数据
120         list_for_each_safe(ptr,q,&head.list){
121             cur = list_entry(ptr,struct cli_info,list);
122             if(FD_ISSET(cur->cli_fd,&read_fds)){
123                 bzero(buf,SIZE);
124                 int val = read(cur->cli_fd,buf,SIZE);
125                 if(val<0){
126                     perror("read failed");
127                     exit(1);
128                 }
129                 else if(val==0){
130                 FD_CLR(cur->cli_fd,&read_fds);
131                 list_del(&cur->list);
132                 close(cur->cli_fd);
133                 free(cur);
134                 cur->cli_fd = -1;
135                 }
136                 else{
137                     printf("client info :\nip=%s  port=%d\ndata=%s\n",inet_ntoa(ser.sin_addr),ntohs(ser.sin_port),buf);
138                     if(!strncmp(buf,"quit",4))
139                         printf("client info :\nip=%s  port=%d  用户下线啦 ^.^ ...\n",inet_ntoa(ser.sin_addr),ntohs(ser.sin_port));
140 
141 }   
142             }
143             }    
144         }
145         }
146 
147 
148     return 0 ;
149 }

  1 #ifndef _LINUX_LIST_H
  2 #define _LINUX_LIST_H
  3 
  4 /*
  5  * Simple doubly linked list implementation.
  6  *
  7  * Some of the internal functions ("__xxx") are useful when
  8  * manipulating whole lists rather than single entries, as
  9  * sometimes we already know the next/prev entries and we can
 10  * generate better code by using them directly rather than
 11  * using the generic single-entry routines.
 12  */
 13 
 14 struct list_head{
 15     struct list_head *next,*prev;
 16 };
 17 
 18 #define LIST_POISON1  ((void *) 0x00100100 + 0)
 19 #define LIST_POISON2  ((void *) 0x00200200 + 0)
 20 
 21 #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
 22 #define container_of(ptr, type, member) ({             23         const typeof( ((type *)0)->member ) *__mptr = (ptr);     24         (type *)( (char *)__mptr - offsetof(type,member) );})
 25 #define LIST_HEAD_INIT(name) { &(name), &(name) }
 26 
 27 #define LIST_HEAD(name)  28     struct list_head name = LIST_HEAD_INIT(name)
 29 
 30 static inline void INIT_LIST_HEAD(struct list_head *list)
 31 {
 32     list->next = list;
 33     list->prev = list;
 34 }
 35 
 36 /*
 37  * Insert a new entry between two known consecutive entries.
 38  *
 39  * This is only for internal list manipulation where we know
 40  * the prev/next entries already!
 41  */
 42 #ifndef CONFIG_DEBUG_LIST
 43 static inline void __list_add(struct list_head *new,
 44         struct list_head *prev,
 45         struct list_head *next)
 46 {
 47     next->prev = new;
 48     new->next = next;
 49     new->prev = prev;
 50     prev->next = new;
 51 }
 52 #else
 53 extern void __list_add(struct list_head *new,
 54         struct list_head *prev,
 55         struct list_head *next);
 56 #endif
 57 
 58 /**
 59  * list_add - add a new entry
 60  * @new: new entry to be added
 61  * @head: list head to add it after
 62  *
 63  * Insert a new entry after the specified head.
 64  * This is good for implementing stacks.
 65  */
 66 static inline void list_add(struct list_head *new, struct list_head *head)
 67 {
 68     __list_add(new, head, head->next);
 69 }
 70 
 71 
 72 /**
 73  * list_add_tail - add a new entry
 74  * @new: new entry to be added
 75  * @head: list head to add it before
 76  *
 77  * Insert a new entry before the specified head.
 78  * This is useful for implementing queues.
 79  */
 80 static inline void list_add_tail(struct list_head *new, struct list_head *head)
 81 {
 82     __list_add(new, head->prev, head);
 83 }
 84 
 85 /*
 86  * Delete a list entry by making the prev/next entries
 87  * point to each other.
 88  *
 89  * This is only for internal list manipulation where we know
 90  * the prev/next entries already!
 91  */
 92 static inline void __list_del(struct list_head * prev, struct list_head * next)
 93 {
 94     next->prev = prev;
 95     prev->next = next;
 96 }
 97 
 98 /**
 99  * list_del - deletes entry from list.
100  * @entry: the element to delete from the list.
101  * Note: list_empty() on entry does not return true after this, the entry is
102  * in an undefined state.
103  */
104 #ifndef CONFIG_DEBUG_LIST
105 static inline void __list_del_entry(struct list_head *entry)
106 {
107     __list_del(entry->prev, entry->next);
108 }
109 
110 static inline void list_del(struct list_head *entry)
111 {
112     __list_del(entry->prev, entry->next);
113     entry->next = LIST_POISON1;
114     entry->prev = LIST_POISON2;
115 }
116 #else
117 extern void __list_del_entry(struct list_head *entry);
118 extern void list_del(struct list_head *entry);
119 #endif
120 
121 /**
122  * list_replace - replace old entry by new one
123  * @old : the element to be replaced
124  * @new : the new element to insert
125  *
126  * If @old was empty, it will be overwritten.
127  */
128 static inline void list_replace(struct list_head *old,
129         struct list_head *new)
130 {
131     new->next = old->next;
132     new->next->prev = new;
133     new->prev = old->prev;
134     new->prev->next = new;
135 }
136 
137 static inline void list_replace_init(struct list_head *old,
138         struct list_head *new)
139 {
140     list_replace(old, new);
141     INIT_LIST_HEAD(old);
142 }
143 
144 /**
145  * list_del_init - deletes entry from list and reinitialize it.
146  * @entry: the element to delete from the list.
147  */
148 static inline void list_del_init(struct list_head *entry)
149 {
150     __list_del_entry(entry);
151     INIT_LIST_HEAD(entry);
152 }
153 
154 /**
155  * list_move - delete from one list and add as another‘s head
156  * @list: the entry to move
157  * @head: the head that will precede our entry
158  */
159 static inline void list_move(struct list_head *list, struct list_head *head)
160 {
161     __list_del_entry(list);
162     list_add(list, head);
163 }
164 
165 /**
166  * list_move_tail - delete from one list and add as another‘s tail
167  * @list: the entry to move
168  * @head: the head that will follow our entry
169  */
170 static inline void list_move_tail(struct list_head *list,
171         struct list_head *head)
172 {
173     __list_del_entry(list);
174     list_add_tail(list, head);
175 }
176 
177 /**
178  * list_is_last - tests whether @list is the last entry in list @head
179  * @list: the entry to test
180  * @head: the head of the list
181  */
182 static inline int list_is_last(const struct list_head *list,
183         const struct list_head *head)
184 {
185     return list->next == head;
186 }
187 
188 /**
189  * list_empty - tests whether a list is empty
190  * @head: the list to test.
191  */
192 static inline int list_empty(const struct list_head *head)
193 {
194     return head->next == head;
195 }
196 
197 /**
198  * list_empty_careful - tests whether a list is empty and not being modified
199  * @head: the list to test
200  *
201  * Description:
202  * tests whether a list is empty _and_ checks that no other CPU might be
203  * in the process of modifying either member (next or prev)
204  *
205  * NOTE: using list_empty_careful() without synchronization
206  * can only be safe if the only activity that can happen
207  * to the list entry is list_del_init(). Eg. it cannot be used
208  * if another CPU could re-list_add() it.
209  */
210 static inline int list_empty_careful(const struct list_head *head)
211 {
212     struct list_head *next = head->next;
213     return (next == head) && (next == head->prev);
214 }
215 
216 /**
217  * list_rotate_left - rotate the list to the left
218  * @head: the head of the list
219  */
220 static inline void list_rotate_left(struct list_head *head)
221 {
222     struct list_head *first;
223 
224     if (!list_empty(head)) {
225         first = head->next;
226         list_move_tail(first, head);
227     }
228 }
229 
230 /**
231  * list_is_singular - tests whether a list has just one entry.
232  * @head: the list to test.
233  */
234 static inline int list_is_singular(const struct list_head *head)
235 {
236     return !list_empty(head) && (head->next == head->prev);
237 }
238 
239 static inline void __list_cut_position(struct list_head *list,
240         struct list_head *head, struct list_head *entry)
241 {
242     struct list_head *new_first = entry->next;
243     list->next = head->next;
244     list->next->prev = list;
245     list->prev = entry;
246     entry->next = list;
247     head->next = new_first;
248     new_first->prev = head;
249 }
250 
251 /**
252  * list_cut_position - cut a list into two
253  * @list: a new list to add all removed entries
254  * @head: a list with entries
255  * @entry: an entry within head, could be the head itself
256  *    and if so we won‘t cut the list
257  *
258  * This helper moves the initial part of @head, up to and
259  * including @entry, from @head to @list. You should
260  * pass on @entry an element you know is on @head. @list
261  * should be an empty list or a list you do not care about
262  * losing its data.
263  *
264  */
265 static inline void list_cut_position(struct list_head *list,
266         struct list_head *head, struct list_head *entry)
267 {
268     if (list_empty(head))
269         return;
270     if (list_is_singular(head) &&
271             (head->next != entry && head != entry))
272         return;
273     if (entry == head)
274         INIT_LIST_HEAD(list);
275     else
276         __list_cut_position(list, head, entry);
277 }
278 
279 static inline void __list_splice(const struct list_head *list,
280         struct list_head *prev,
281         struct list_head *next)
282 {
283     struct list_head *first = list->next;
284     struct list_head *last = list->prev;
285 
286     first->prev = prev;
287     prev->next = first;
288 
289     last->next = next;
290     next->prev = last;
291 }
292 
293 /**
294  * list_splice - join two lists, this is designed for stacks
295  * @list: the new list to add.
296  * @head: the place to add it in the first list.
297  */
298 static inline void list_splice(const struct list_head *list,
299         struct list_head *head)
300 {
301     if (!list_empty(list))
302         __list_splice(list, head, head->next);
303 }
304 
305 /**
306  * list_splice_tail - join two lists, each list being a queue
307  * @list: the new list to add.
308  * @head: the place to add it in the first list.
309  */
310 static inline void list_splice_tail(struct list_head *list,
311         struct list_head *head)
312 {
313     if (!list_empty(list))
314         __list_splice(list, head->prev, head);
315 }
316 
317 /**
318  * list_splice_init - join two lists and reinitialise the emptied list.
319  * @list: the new list to add.
320  * @head: the place to add it in the first list.
321  *
322  * The list at @list is reinitialised
323  */
324 static inline void list_splice_init(struct list_head *list,
325         struct list_head *head)
326 {
327     if (!list_empty(list)) {
328         __list_splice(list, head, head->next);
329         INIT_LIST_HEAD(list);
330     }
331 }
332 
333 /**
334  * list_splice_tail_init - join two lists and reinitialise the emptied list
335  * @list: the new list to add.
336  * @head: the place to add it in the first list.
337  *
338  * Each of the lists is a queue.
339  * The list at @list is reinitialised
340  */
341 static inline void list_splice_tail_init(struct list_head *list,
342         struct list_head *head)
343 {
344     if (!list_empty(list)) {
345         __list_splice(list, head->prev, head);
346         INIT_LIST_HEAD(list);
347     }
348 }
349 
350 /**
351  * list_entry - get the struct for this entry
352  * @ptr:    the &struct list_head pointer.
353  * @type:    the type of the struct this is embedded in.
354  * @member:    the name of the list_struct within the struct.
355  */
356 #define list_entry(ptr, type, member) 357     container_of(ptr, type, member)
358 
359 /**
360  * list_first_entry - get the first element from a list
361  * @ptr:    the list head to take the element from.
362  * @type:    the type of the struct this is embedded in.
363  * @member:    the name of the list_struct within the struct.
364  *
365  * Note, that list is expected to be not empty.
366  */
367 #define list_first_entry(ptr, type, member) 368     list_entry((ptr)->next, type, member)
369 
370 /**
371  * list_for_each    -    iterate over a list
372  * @pos:    the &struct list_head to use as a loop cursor.
373  * @head:    the head for your list.
374  */
375 #define list_for_each(pos, head) 376     for (pos = (head)->next; pos != (head); pos = pos->next)
377 
378 /**
379  * __list_for_each    -    iterate over a list
380  * @pos:    the &struct list_head to use as a loop cursor.
381  * @head:    the head for your list.
382  *
383  * This variant doesn‘t differ from list_for_each() any more.
384  * We don‘t do prefetching in either case.
385  */
386 #define __list_for_each(pos, head) 387     for (pos = (head)->next; pos != (head); pos = pos->next)
388 
389 /**
390  * list_for_each_prev    -    iterate over a list backwards
391  * @pos:    the &struct list_head to use as a loop cursor.
392  * @head:    the head for your list.
393  */
394 #define list_for_each_prev(pos, head) 395     for (pos = (head)->prev; pos != (head); pos = pos->prev)
396 
397 /**
398  * list_for_each_safe - iterate over a list safe against removal of list entry
399  * @pos:    the &struct list_head to use as a loop cursor.
400  * @n:        another &struct list_head to use as temporary storage
401  * @head:    the head for your list.
402  */
403 #define list_for_each_safe(pos, n, head) 404     for (pos = (head)->next, n = pos->next; pos != (head); 405             pos = n, n = pos->next)
406 
407 /**
408  * list_for_each_prev_safe - iterate over a list backwards safe against removal of list entry
409  * @pos:    the &struct list_head to use as a loop cursor.
410  * @n:        another &struct list_head to use as temporary storage
411  * @head:    the head for your list.
412  */
413 #define list_for_each_prev_safe(pos, n, head) 414     for (pos = (head)->prev, n = pos->prev; 415             pos != (head); 416             pos = n, n = pos->prev)
417 
418 /**
419  * list_for_each_entry    -    iterate over list of given type
420  * @pos:    the type * to use as a loop cursor.
421  * @head:    the head for your list.
422  * @member:    the name of the list_struct within the struct.
423  */
424 #define list_for_each_entry(pos, head, member)                425     for (pos = list_entry((head)->next, typeof(*pos), member);    426             &pos->member != (head);     427             pos = list_entry(pos->member.next, typeof(*pos), member))
428 
429 /**
430  * list_for_each_entry_reverse - iterate backwards 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_reverse(pos, head, member)            436     for (pos = list_entry((head)->prev, typeof(*pos), member);    437             &pos->member != (head);     438             pos = list_entry(pos->member.prev, typeof(*pos), member))
439 
440 /**
441  * list_prepare_entry - prepare a pos entry for use in list_for_each_entry_continue()
442  * @pos:    the type * to use as a start point
443  * @head:    the head of the list
444  * @member:    the name of the list_struct within the struct.
445  *
446  * Prepares a pos entry for use as a start point in list_for_each_entry_continue().
447  */
448 #define list_prepare_entry(pos, head, member) 449     ((pos) ? : list_entry(head, typeof(*pos), member))
450 
451 /**
452  * list_for_each_entry_continue - continue iteration over list of given type
453  * @pos:    the type * to use as a loop cursor.
454  * @head:    the head for your list.
455  * @member:    the name of the list_struct within the struct.
456  *
457  * Continue to iterate over list of given type, continuing after
458  * the current position.
459  */
460 #define list_for_each_entry_continue(pos, head, member)         461     for (pos = list_entry(pos->member.next, typeof(*pos), member);    462             &pos->member != (head);    463             pos = list_entry(pos->member.next, typeof(*pos), member))
464 
465 /**
466  * list_for_each_entry_continue_reverse - iterate backwards from the given point
467  * @pos:    the type * to use as a loop cursor.
468  * @head:    the head for your list.
469  * @member:    the name of the list_struct within the struct.
470  *
471  * Start to iterate over list of given type backwards, continuing after
472  * the current position.
473  */
474 #define list_for_each_entry_continue_reverse(pos, head, member)        475     for (pos = list_entry(pos->member.prev, typeof(*pos), member);    476             &pos->member != (head);    477             pos = list_entry(pos->member.prev, typeof(*pos), member))
478 
479 /**
480  * list_for_each_entry_from - iterate over list of given type from the current point
481  * @pos:    the type * to use as a loop cursor.
482  * @head:    the head for your list.
483  * @member:    the name of the list_struct within the struct.
484  *
485  * Iterate over list of given type, continuing from current position.
486  */
487 #define list_for_each_entry_from(pos, head, member)             488     for (; &pos->member != (head);    489             pos = list_entry(pos->member.next, typeof(*pos), member))
490 
491 /**
492  * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
493  * @pos:    the type * to use as a loop cursor.
494  * @n:        another type * to use as temporary storage
495  * @head:    the head for your list.
496  * @member:    the name of the list_struct within the struct.
497  */
498 #define list_for_each_entry_safe(pos, n, head, member)            499     for (pos = list_entry((head)->next, typeof(*pos), member),    500             n = list_entry(pos->member.next, typeof(*pos), member);    501             &pos->member != (head);                     502             pos = n, n = list_entry(n->member.next, typeof(*n), member))
503 
504 /**
505  * list_for_each_entry_safe_continue - continue list iteration safe against removal
506  * @pos:    the type * to use as a loop cursor.
507  * @n:        another type * to use as temporary storage
508  * @head:    the head for your list.
509  * @member:    the name of the list_struct within the struct.
510  *
511  * Iterate over list of given type, continuing after current point,
512  * safe against removal of list entry.
513  */
514 #define list_for_each_entry_safe_continue(pos, n, head, member)         515     for (pos = list_entry(pos->member.next, typeof(*pos), member),         516             n = list_entry(pos->member.next, typeof(*pos), member);        517             &pos->member != (head);                        518             pos = n, n = list_entry(n->member.next, typeof(*n), member))
519 
520 /**
521  * list_for_each_entry_safe_from - iterate over list from current point safe against removal
522  * @pos:    the type * to use as a loop cursor.
523  * @n:        another type * to use as temporary storage
524  * @head:    the head for your list.
525  * @member:    the name of the list_struct within the struct.
526  *
527  * Iterate over list of given type from current point, safe against
528  * removal of list entry.
529  */
530 #define list_for_each_entry_safe_from(pos, n, head, member)             531     for (n = list_entry(pos->member.next, typeof(*pos), member);        532             &pos->member != (head);                        533             pos = n, n = list_entry(n->member.next, typeof(*n), member))
534 
535 /**
536  * list_for_each_entry_safe_reverse - iterate backwards over list safe against removal
537  * @pos:    the type * to use as a loop cursor.
538  * @n:        another type * to use as temporary storage
539  * @head:    the head for your list.
540  * @member:    the name of the list_struct within the struct.
541  *
542  * Iterate backwards over list of given type, safe against removal
543  * of list entry.
544  */
545 #define list_for_each_entry_safe_reverse(pos, n, head, member)        546     for (pos = list_entry((head)->prev, typeof(*pos), member),    547             n = list_entry(pos->member.prev, typeof(*pos), member);    548             &pos->member != (head);                     549             pos = n, n = list_entry(n->member.prev, typeof(*n), member))
550 
551 /**
552  * list_safe_reset_next - reset a stale list_for_each_entry_safe loop
553  * @pos:    the loop cursor used in the list_for_each_entry_safe loop
554  * @n:        temporary storage used in list_for_each_entry_safe
555  * @member:    the name of the list_struct within the struct.
556  *
557  * list_safe_reset_next is not safe to use in general if the list may be
558  * modified concurrently (eg. the lock is dropped in the loop body). An
559  * exception to this is if the cursor element (pos) is pinned in the list,
560  * and list_safe_reset_next is called after re-taking the lock and before
561  * completing the current iteration of the loop body.
562  */
563 #define list_safe_reset_next(pos, n, member)                564     n = list_entry(pos->member.next, typeof(*pos), member)
565 
566 /*
567  * Double linked lists with a single pointer list head.
568  * Mostly useful for hash tables where the two pointer list head is
569  * too wasteful.
570  * You lose the ability to access the tail in O(1).
571  */
572 #endif