This is the most commonly used unified linked table structure below Linux. Linux uses this structure to put all Driver and Device. I feel very well, everyone will take a look.
-------------------------------------------------- -------------------------------------------------- -
#ifndef _linux_list_h # define _linux_list_h
#ifdef __kernel__
Struct List_head {structure list_head * next, * prev;};
#define list_head_init (name) {& (Name), & (name)}
#define list_head (name) / struct list_Head name = list_head_init (name)
#define init_list_head (ptr) DO {/ (PTR) -> Next = (PTR); (PTR) -> prev = (PTR); /} while (0)
/ * * Insert a new entry between two known consecutive entries. * This is only for internal list manipulation where we know the prev / next entries already! * / Static __inline__ void __list_add (struct list_head * new, struct list_head * prev, struct list_head * Next) {next-> prev = new; new-> next = next; new-> prev = prev; prev-> next = new;}
/ * * List_add -.. Add a new entry * Insert a new entry after the specified head * This is good for implementing stacks * / static __inline__ void list_add (struct list_head * new, struct list_head * head) {__list_add (new, head Head-> next);
/ * * List_add_tail -.. Add a new entry * Insert a new entry before the specified head * This is useful for implementing queues * / static __inline__ void list_add_tail (struct list_head * new, struct list_head * head) {__list_add (new, head -> prev, head);
/ * * Delete a list entry by making the prev / next entries point to each other. * This is only for internal list manipulation where we know the prev / next entries already! * / Static __inline__ void __list_del (struct list_head * prev, struct List_head * next) {next-> prev = prev; prev-> next = next;}
/ * * List_del - deletes entry from list * Note:. List_empty on entry does not return true after this, the entry is in an undefined state * / static __inline__ void list_del (struct list_head * entry) {__list_del (entry-> prev. , entry-> next);.} / ** * list_del_init - deletes entry from list and reinitialize it * / static __inline__ void list_del_init (struct list_head * entry) {__list_del (entry-> prev, entry-> next); INIT_LIST_HEAD ( Entry);
/ * * List_empty - tests WHETHER A LIST IS EMPTY * / static __inline__ int list_empty (struct list_head * head) {return head-> next == head;}
/ ** * list_splice - join two lists * @list: the new list to add * @head: the place to add it in the first list * / static __inline__ void list_splice (struct list_head * list, struct list_head * head).. {Struct list_head * first = list-> next;
IF (first! = list) {struct list_head * last = list-> prev; struct list_head * at = head-> next; first-> prep = head; head-> next = first; las-> next = at; -> prev = last;}}}
/ ** * list_entry - get the struct for this entry * @ptr:. The & struct list_head pointer * @type: the type of the struct this is embedded in * @member: the name of the list_struct within the struct * /.. #define list_entry (PTR, TYPE, MEMBER) / ((TYPE *) ((CHAR *) (PTR) - (& ((Type * 0) -> MEMBER))))
/ ** * list_for_each - iterate over a list * @pos: The & struct list_head to use as a loop counter. * @Head: the head for your list. * / # Define list_for_each (pos, head) / for (POS = HEAD -> Next; POS! = (head); POS = POS-> Next)
#ENDIF / * __KERNEL__ * /
#ENDIF
Supplement - giving comrades who don't understand.
It is a two-way circular list, which can be used in any structure, such as: struct kk {type1 data1; type2 data2; ... struct list_head list; type datan;}
There is a linked watch: list_head (kk_list)
Then call the linked list function, for example, add a new node KK_Node to the tail
List_add_tail (& (KK_Node.list), & KK_LIST);
Just add the List member in the knot, get a struct pointer containing a list_head node.
Struct KK * P = List_ENTRY (P, KK, LIST);
When the DELETE is operated, it is only to remove the node from the linked list, and the space occupied by the node is not truly released, because this is a universal structure, allocation release is managed by the user.
