From 11f2b50a8e18da72937677fe6cd472421d1c2d26 Mon Sep 17 00:00:00 2001 From: Xie Han <63350856@qq.com> Date: Fri, 17 Nov 2023 01:56:37 +0800 Subject: [PATCH] Update list.h --- list.h | 165 ++++++++++++++++++++++++++++++--------------------------- 1 file changed, 87 insertions(+), 78 deletions(-) diff --git a/list.h b/list.h index 1e42a16..02f69d7 100644 --- a/list.h +++ b/list.h @@ -2,7 +2,7 @@ #define _LINUX_LIST_H /* - * Simple doubly linked list implementation. + * Circular doubly linked list implementation. * * Some of the internal functions ("__xxx") are useful when * manipulating whole lists rather than single entries, as @@ -20,6 +20,13 @@ struct list_head { #define LIST_HEAD(name) \ struct list_head name = LIST_HEAD_INIT(name) +/** + * INIT_LIST_HEAD - Initialize a list_head structure + * @list: list_head structure to be initialized. + * + * Initializes the list_head to point to itself. If it is a list header, + * the result is an empty list. + */ static inline void INIT_LIST_HEAD(struct list_head *list) { list->next = list; @@ -32,41 +39,41 @@ static inline void INIT_LIST_HEAD(struct list_head *list) * This is only for internal list manipulation where we know * the prev/next entries already! */ -static inline void __list_add(struct list_head *node, - struct list_head *prev, - struct list_head *next) +static inline void __list_add(struct list_head *entry, + struct list_head *prev, + struct list_head *next) { - next->prev = node; - node->next = next; - node->prev = prev; - prev->next = node; + next->prev = entry; + entry->next = next; + entry->prev = prev; + prev->next = entry; } /** * list_add - add a new entry - * @new: new entry to be added + * @entry: new entry to be added * @head: list head to add it after * * Insert a new entry after the specified head. * This is good for implementing stacks. */ -static inline void list_add(struct list_head *node, struct list_head *head) +static inline void list_add(struct list_head *entry, struct list_head *head) { - __list_add(node, head, head->next); + __list_add(entry, head, head->next); } /** * list_add_tail - add a new entry - * @new: new entry to be added + * @entry: new entry to be added * @head: list head to add it before * * Insert a new entry before the specified head. * This is useful for implementing queues. */ -static inline void list_add_tail(struct list_head *node, - struct list_head *head) +static inline void list_add_tail(struct list_head *entry, + struct list_head *head) { - __list_add(node, head->prev, head); + __list_add(entry, head->prev, head); } /* @@ -85,7 +92,8 @@ static inline void __list_del(struct list_head *prev, struct list_head *next) /** * list_del - deletes entry from list. * @entry: the element to delete from the list. - * Note: list_empty on entry does not return true after this, the entry is in an undefined state. + * 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) { @@ -94,25 +102,25 @@ static inline void list_del(struct list_head *entry) /** * list_move - delete from one list and add as another's head - * @list: the entry to move + * @entry: the entry to move * @head: the head that will precede our entry */ -static inline void list_move(struct list_head *list, struct list_head *head) +static inline void list_move(struct list_head *entry, struct list_head *head) { - __list_del(list->prev, list->next); - list_add(list, head); + __list_del(entry->prev, entry->next); + list_add(entry, head); } /** * list_move_tail - delete from one list and add as another's tail - * @list: the entry to move + * @entry: the entry to move * @head: the head that will follow our entry */ -static inline void list_move_tail(struct list_head *list, - struct list_head *head) +static inline void list_move_tail(struct list_head *entry, + struct list_head *head) { - __list_del(list->prev, list->next); - list_add_tail(list, head); + __list_del(entry->prev, entry->next); + list_add_tail(entry, head); } /** @@ -124,18 +132,18 @@ static inline int list_empty(const struct list_head *head) return head->next == head; } -static inline void __list_splice(struct list_head *list, - struct list_head *head) +static inline void __list_splice(const struct list_head *list, + struct list_head *prev, + struct list_head *next) { struct list_head *first = list->next; struct list_head *last = list->prev; - struct list_head *at = head->next; - first->prev = head; - head->next = first; + first->prev = prev; + prev->next = first; - last->next = at; - at->prev = last; + last->next = next; + next->prev = last; } /** @@ -143,10 +151,11 @@ static inline void __list_splice(struct list_head *list, * @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) +static inline void list_splice(const struct list_head *list, + struct list_head *head) { if (!list_empty(list)) - __list_splice(list, head); + __list_splice(list, head, head->next); } /** @@ -157,10 +166,10 @@ static inline void list_splice(struct list_head *list, struct list_head *head) * The list at @list is reinitialised */ static inline void list_splice_init(struct list_head *list, - struct list_head *head) + struct list_head *head) { if (!list_empty(list)) { - __list_splice(list, head); + __list_splice(list, head, head->next); INIT_LIST_HEAD(list); } } @@ -175,7 +184,7 @@ static inline void list_splice_init(struct list_head *list, ((type *)((char *)(ptr)-(size_t)(&((type *)0)->member))) /** - * list_for_each - iterate over a list + * list_for_each - iterate over a list * @pos: the &struct list_head to use as a loop counter. * @head: the head for your list. */ @@ -183,7 +192,7 @@ static inline void list_splice_init(struct list_head *list, for (pos = (head)->next; pos != (head); pos = pos->next) /** - * list_for_each_prev - iterate over a list backwards + * list_for_each_prev - iterate over a list backwards * @pos: the &struct list_head to use as a loop counter. * @head: the head for your list. */ @@ -191,28 +200,28 @@ static inline void list_splice_init(struct list_head *list, for (pos = (head)->prev; pos != (head); pos = pos->prev) /** - * list_for_each_safe - iterate over a list safe against removal of list entry + * list_for_each_safe - iterate over a list safe against removal of list entry * @pos: the &struct list_head to use as a loop counter. * @n: another &struct list_head to use as temporary storage * @head: the head for your list. */ #define list_for_each_safe(pos, n, head) \ for (pos = (head)->next, n = pos->next; pos != (head); \ - pos = n, n = pos->next) + pos = n, n = pos->next) /** - * list_for_each_entry - iterate over list of given type + * list_for_each_entry - iterate over list of given type * @pos: the type * to use as a loop counter. * @head: the head for your list. * @member: the name of the list_struct within the struct. */ #define list_for_each_entry(pos, head, member) \ for (pos = list_entry((head)->next, typeof (*pos), member); \ - &pos->member != (head); \ - pos = list_entry(pos->member.next, typeof (*pos), member)) + &pos->member != (head); \ + pos = list_entry(pos->member.next, typeof (*pos), member)) -/** - * Single-linked list. Added by Xie Han . +/* + * Singly linked list implementation. */ struct slist_node { @@ -223,7 +232,7 @@ struct slist_head { struct slist_node first, *last; }; -#define SLIST_HEAD_INIT(name) { { (struct slist_node *)0 }, &(name).first } +#define SLIST_HEAD_INIT(name) { { (struct slist_node *)0 }, &(name).first } #define SLIST_HEAD(name) \ struct slist_head name = SLIST_HEAD_INIT(name) @@ -234,32 +243,32 @@ static inline void INIT_SLIST_HEAD(struct slist_head *list) list->last = &list->first; } -static inline void slist_add_after(struct slist_node *node, - struct slist_node *prev, - struct slist_head *list) +static inline void slist_add_after(struct slist_node *entry, + struct slist_node *prev, + struct slist_head *list) { - node->next = prev->next; - prev->next = node; - if (!node->next) - list->last = node; + entry->next = prev->next; + prev->next = entry; + if (!entry->next) + list->last = entry; } -static inline void slist_add_head(struct slist_node *node, - struct slist_head *list) +static inline void slist_add_head(struct slist_node *entry, + struct slist_head *list) { - slist_add_after(node, &list->first, list); + slist_add_after(entry, &list->first, list); } -static inline void slist_add_tail(struct slist_node *node, - struct slist_head *list) +static inline void slist_add_tail(struct slist_node *entry, + struct slist_head *list) { - node->next = (struct slist_node *)0; - list->last->next = node; - list->last = node; + entry->next = (struct slist_node *)0; + list->last->next = entry; + list->last = entry; } static inline void slist_del_after(struct slist_node *prev, - struct slist_head *list) + struct slist_head *list) { prev->next = prev->next->next; if (!prev->next) @@ -271,35 +280,35 @@ static inline void slist_del_head(struct slist_head *list) slist_del_after(&list->first, list); } -static inline int slist_empty(struct slist_head *list) +static inline int slist_empty(const struct slist_head *list) { return !list->first.next; } -static inline void __slist_splice(struct slist_head *list, - struct slist_node *at, - struct slist_head *head) +static inline void __slist_splice(const struct slist_head *list, + struct slist_node *prev, + struct slist_head *head) { - list->last->next = at->next; - at->next = list->first.next; + list->last->next = prev->next; + prev->next = list->first.next; if (!list->last->next) head->last = list->last; } -static inline void slist_splice(struct slist_head *list, - struct slist_node *at, - struct slist_head *head) +static inline void slist_splice(const struct slist_head *list, + struct slist_node *prev, + struct slist_head *head) { if (!slist_empty(list)) - __slist_splice(list, at, head); + __slist_splice(list, prev, head); } static inline void slist_splice_init(struct slist_head *list, - struct slist_node *at, - struct slist_head *head) + struct slist_node *prev, + struct slist_head *head) { if (!slist_empty(list)) { - __slist_splice(list, at, head); + __slist_splice(list, prev, head); INIT_SLIST_HEAD(list); } } @@ -312,11 +321,11 @@ static inline void slist_splice_init(struct slist_head *list, #define slist_for_each_safe(pos, prev, head) \ for (prev = &(head)->first, pos = prev->next; pos; \ - prev = prev->next == pos ? pos : prev, pos = prev->next) + prev = prev->next == pos ? pos : prev, pos = prev->next) #define slist_for_each_entry(pos, head, member) \ for (pos = slist_entry((head)->first.next, typeof (*pos), member); \ - &pos->member != (struct slist_node *)0; \ - pos = slist_entry(pos->member.next, typeof (*pos), member)) + &pos->member != (struct slist_node *)0; \ + pos = slist_entry(pos->member.next, typeof (*pos), member)) #endif