From ba96005bcd8fada2852fc1d0d0499094b8c14a8b Mon Sep 17 00:00:00 2001 From: Arshad Hussain Date: Sun, 8 Sep 2024 12:31:57 -0400 Subject: [PATCH] LU-6142 lnet: Fix style issues for list.h This patch fixes issues reported by checkpatch for both files libcfs/include/libcfs/util/list.h Update inline doc to kernel-doc style Test-Parameters: trivial Signed-off-by: Arshad Hussain Change-Id: Ic8bef64aa24d079b2242ec9ac63ee7b38726f714 Reviewed-on: https://review.whamcloud.com/c/fs/lustre-release/+/56306 Tested-by: jenkins Tested-by: Maloo Reviewed-by: Andreas Dilger Reviewed-by: Petros Koutoupis Reviewed-by: Oleg Drokin --- libcfs/include/libcfs/util/list.h | 397 ++++++++++++++++++++++---------------- 1 file changed, 226 insertions(+), 171 deletions(-) diff --git a/libcfs/include/libcfs/util/list.h b/libcfs/include/libcfs/util/list.h index c054925..fd6412c 100644 --- a/libcfs/include/libcfs/util/list.h +++ b/libcfs/include/libcfs/util/list.h @@ -23,8 +23,8 @@ #ifndef __LIBCFS_UTIL_LIST_H__ #define __LIBCFS_UTIL_LIST_H__ -/* - * Simple doubly linked list implementation. +/** + * DOC: Simple doubly linked list implementation. * * Some of the internal functions ("__xxx") are useful when * manipulating whole lists rather than single entries, as @@ -32,7 +32,6 @@ * generate better code by using them directly rather than * using the generic single-entry routines. */ - #define prefetch(a) ((void)a) struct list_head { @@ -45,15 +44,14 @@ struct list_head { (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) +static inline void __list_add(struct list_head *new, struct list_head *prev, + struct list_head *next) { next->prev = new; new->next = next; @@ -62,29 +60,33 @@ static inline void __list_add(struct list_head * new, } /** - * Insert an entry at the start of a list. - * \param new new entry to be inserted - * \param head list to add it to + * list_add() - Insert an entry at the start of a list. + * @new: new entry to be inserted + * @head: list to add it to * * Insert a new entry after the specified head. * This is good for implementing stacks. + * + * Return: + * * %void - Does not return any value */ -static inline void list_add(struct list_head *new, - struct list_head *head) +static inline void list_add(struct list_head *new, struct list_head *head) { __list_add(new, head, head->next); } /** - * Insert an entry at the end of a list. - * \param new new entry to be inserted - * \param head list to add it to + * list_add_tail() - Insert an entry at the end of a list. + * @new: new entry to be inserted + * @head: list to add it to * * Insert a new entry before the specified head. * This is useful for implementing queues. + * + * Return: + * * %void - Does not return any value */ -static inline void list_add_tail(struct list_head *new, - struct list_head *head) +static inline void list_add_tail(struct list_head *new, struct list_head *head) { __list_add(new, head->prev, head); } @@ -96,18 +98,21 @@ static inline void list_add_tail(struct list_head *new, * 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) +static inline void __list_del(struct list_head *prev, struct list_head *next) { next->prev = prev; prev->next = next; } /** - * Remove an entry from the list it is currently in. - * \param entry the entry to remove - * Note: list_empty(entry) does not return true after this, the entry is in an - * undefined state. + * list_del() - Remove an entry from the list it is currently in. + * @entry: the entry to remove + * + * Note: list_empty(entry) does not return true after this, + * the entry is in an undefined state. + * + * Return: + * * %void - Does not return any value */ static inline void list_del(struct list_head *entry) { @@ -115,8 +120,13 @@ static inline void list_del(struct list_head *entry) } /** + * list_del_init() - Remove entry from the list and reinitialize it. + * @entry: the entry to remove. + * * Remove an entry from the list it is currently in and reinitialize it. - * \param entry the entry to remove. + * + * Return: + * * %void - Does not return any value */ static inline void list_del_init(struct list_head *entry) { @@ -125,34 +135,46 @@ static inline void list_del_init(struct list_head *entry) } /** - * Remove an entry from the list it is currently in and insert it at the start - * of another list. - * \param list the entry to move - * \param head the list to move it to + * list_move() - Remove entry and insert it at the start of another list + * @list: the entry to move + * @head: the list to move it to + * + * Remove an entry from the list it is currently in and insert + * it at the start + * + * Return: + * * %void - Does not return any value */ -static inline void list_move(struct list_head *list, - struct list_head *head) +static inline void list_move(struct list_head *list, struct list_head *head) { __list_del(list->prev, list->next); list_add(list, head); } /** - * Remove an entry from the list it is currently in and insert it at the end of - * another list. - * \param list the entry to move - * \param head the list to move it to + * list_move_tail() - Remove entry and insert it at the end of another list. + * @list: the entry to move + * @head: the list to move it to + * + * Remove an entry from the list it is currently in and insert + * it at the end of + * + * Return: + * * %void - Does not return any value */ static inline void list_move_tail(struct list_head *list, - struct list_head *head) + struct list_head *head) { __list_del(list->prev, list->next); list_add_tail(list, head); } /** - * Test whether a list is empty - * \param head the list to test. + * list_empty() - Test whether a list is empty + * @head: the list to test. + * + * Return: + * * %void - Does not return any value */ static inline int list_empty(struct list_head *head) { @@ -160,8 +182,8 @@ static inline int list_empty(struct list_head *head) } /** - * Test whether a list is empty and not being modified - * \param head the list to test + * list_empty_careful() - Test whether a list is empty and not being modified + * @head: the list to test * * Tests whether a list is empty _and_ checks that no other CPU might be * in the process of modifying either member (next or prev) @@ -170,15 +192,18 @@ static inline int list_empty(struct list_head *head) * can only be safe if the only activity that can happen * to the list entry is list_del_init(). Eg. it cannot be used * if another CPU could re-list_add() it. + * + * Return: + * * %void - Does not return any value */ static inline int list_empty_careful(const struct list_head *head) { struct list_head *next = head->next; + return (next == head) && (next == head->prev); } -static inline void __list_splice(struct list_head *list, - struct list_head *head) +static inline void __list_splice(struct list_head *list, struct list_head *head) { struct list_head *first = list->next; struct list_head *last = list->prev; @@ -192,33 +217,50 @@ static inline void __list_splice(struct list_head *list, } /** - * Join two lists - * \param list the new list to add. - * \param head the place to add it in the first list. + * list_splice() - Join two lists + * @list: the new list to add. + * @head: the place to add it in the first list. + * + * The contents of @list are added at the start of @head. + * @list is in an undefined state on return. * - * The contents of \a list are added at the start of \a head. \a list is in an - * undefined state on return. + * Return: + * * %void - Does not return any value */ -static inline void list_splice(struct list_head *list, - struct list_head *head) +static inline void list_splice(struct list_head *list, struct list_head *head) { if (!list_empty(list)) __list_splice(list, head); } -static inline void list_splice_tail(struct list_head *list, struct list_head *head) +/** + * list_splice_tail() - Join two lists at the tail + * @list: the new list to add. + * @head: the place to add it in the first list. + * + * The contents of @list are added at the tail + * @list is in an undefined state on return. + * + * Return: + * * %void - Does not return any value + */ +static inline void list_splice_tail(struct list_head *list, + struct list_head *head) { if (!list_empty(list)) __list_splice(list, head->prev); } /** - * Join two lists and reinitialise the emptied list. - * \param list the new list to add. - * \param head the place to add it in the first list. + * list_splice_init() - Join two lists and reinitialise the emptied list. + * @list: the new list to add. + * @head: the place to add it in the first list. + * + * The contents of @list are added at the start of @head. + * @list is empty on return. * - * The contents of \a list are added at the start of \a head. \a list is empty - * on return. + * Return: + * * %void - Does not return any value */ static inline void list_splice_init(struct list_head *list, struct list_head *head) @@ -230,19 +272,19 @@ static inline void list_splice_init(struct list_head *list, } /** - * Get the container of a list - * \param ptr the embedded list. - * \param type the type of the struct this is embedded in. - * \param member the member name of the list within the struct. + * define list_entry - Get the container of a list + * @ptr: the embedded list. + * @type: the type of the struct this is embedded in. + * @member: the member name of the list within the struct. */ #define list_entry(ptr, type, member) \ ((type *)((char *)(ptr)-(char *)(&((type *)0)->member))) /** - * list_first_entry - get the first element from a list - * \param ptr the list head to take the element from. - * \param type the type of the struct this is embedded in. - * \param member the name of the list_head within the struct. + * define list_first_entry - get the first element from a list + * @ptr: the list head to take the element from. + * @type: the type of the struct this is embedded in. + * @member: the name of the list_head within the struct. * * Note, that list is expected to be not empty. */ @@ -250,10 +292,10 @@ static inline void list_splice_init(struct list_head *list, list_entry((ptr)->next, type, member) /** - * list_last_entry - get the last element from a list - * \param ptr the list head to take the element from. - * \param type the type of the struct this is embedded in. - * \param member the name of the list_head within the struct. + * define list_last_entry - get the last element from a list + * @ptr: the list head to take the element from. + * @type: the type of the struct this is embedded in. + * @member: the name of the list_head within the struct. * * Note, that list is expected to be not empty. */ @@ -261,59 +303,67 @@ static inline void list_splice_init(struct list_head *list, list_entry((ptr)->prev, type, member) /** - * Iterate over a list - * \param pos the iterator - * \param head the list to iterate over + * define list_for_each - Iterate over a list + * @pos: the iterator + * @head: the list to iterate over * - * Behaviour is undefined if \a pos is removed from the list in the body of the + * Behaviour is undefined if @pos is removed from the list in the body of the * loop. */ -#define list_for_each(pos, head) \ - for (pos = (head)->next, prefetch(pos->next); pos != (head); \ +#define list_for_each(pos, head) \ + for (pos = (head)->next, prefetch(pos->next); pos != (head); \ pos = pos->next, prefetch(pos->next)) /** - * Iterate over a list safely - * \param pos the iterator - * \param n temporary storage - * \param head the list to iterate over + * define list_for_each_safe - Iterate over a list safely + * @pos: the iterator + * @n: temporary storage + * @head: the list to iterate over * - * This is safe to use if \a pos could be removed from the list in the body of + * This is safe to use if @pos could be removed from the list in the body of * the loop. */ -#define list_for_each_safe(pos, n, head) \ - for (pos = (head)->next, n = pos->next; pos != (head); \ +#define list_for_each_safe(pos, n, head) \ + for (pos = (head)->next, n = pos->next; pos != (head); \ pos = n, n = pos->next) /** + * define list_for_each_entry_continue - Iterate continuing after existing point + * @pos: the type * to use as a loop counter + * @head: the list head + * @member: the name of the list_struct within the struct + * * Iterate over a list continuing after existing point - * \param pos the type * to use as a loop counter - * \param head the list head - * \param member the name of the list_struct within the struct */ -#define list_for_each_entry_continue(pos, head, member) \ - for (pos = list_entry(pos->member.next, typeof(*pos), member); \ - prefetch(pos->member.next), &pos->member != (head); \ +#define list_for_each_entry_continue(pos, head, member) \ + for (pos = list_entry(pos->member.next, typeof(*pos), member); \ + prefetch(pos->member.next), &pos->member != (head); i \ pos = list_entry(pos->member.next, typeof(*pos), member)) /** - * \defgroup hlist Hash List + * DOC: hlist Hash List * Double linked lists with a single pointer list head. * Mostly useful for hash tables where the two pointer list head is too * wasteful. You lose the ability to access the tail in O(1). - * @{ */ +/** + * struct hlist_node - node for hlist + * @next: next item + * @pprev: previous item + */ struct hlist_node { struct hlist_node *next, **pprev; }; +/** + * struct hlist_head - Head of list + * @first: head item + */ struct hlist_head { struct hlist_node *first; }; -/* @} */ - /* * "NULL" might not be defined at this point */ @@ -323,11 +373,6 @@ struct hlist_head { #define NULL_P ((void *)0) #endif -/** - * \addtogroup hlist - * @{ - */ - #define HLIST_HEAD_INIT { NULL_P } #define HLIST_HEAD(name) struct hlist_head name = { NULL_P } #define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL_P) @@ -369,6 +414,7 @@ static inline void hlist_add_head(struct hlist_node *n, struct hlist_head *h) { struct hlist_node *first = h->first; + n->next = first; if (first) first->pprev = &n->next; @@ -393,124 +439,133 @@ static inline void hlist_add_after(struct hlist_node *n, n->next = next; next->pprev = &n->next; - if(next->next) + if (next->next) next->next->pprev = &next->next; } -#define hlist_entry(ptr, type, member) container_of(ptr,type,member) +#define hlist_entry(ptr, type, member) container_of(ptr, type, member) -#define hlist_for_each(pos, head) \ - for (pos = (head)->first; pos && (prefetch(pos->next), 1); \ +#define hlist_for_each(pos, head) \ + for (pos = (head)->first; pos && (prefetch(pos->next), 1); \ pos = pos->next) -#define hlist_for_each_safe(pos, n, head) \ - for (pos = (head)->first; pos && (n = pos->next, 1); \ +#define hlist_for_each_safe(pos, n, head) \ + for (pos = (head)->first; pos && (n = pos->next, 1); \ pos = n) /** - * Iterate over an hlist of given type - * \param tpos the type * to use as a loop counter. - * \param pos the &struct hlist_node to use as a loop counter. - * \param head the head for your list. - * \param member the name of the hlist_node within the struct. - */ -#define hlist_for_each_entry(tpos, pos, head, member) \ - for (pos = (head)->first; \ - pos && ({ prefetch(pos->next); 1;}) && \ - ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \ + * define hlist_for_each_entry - Iterate over an hlist of given type + * @tpos: the type * to use as a loop counter. + * @pos: the &struct hlist_node to use as a loop counter. + * @head: the head for your list. + * @member: the name of the hlist_node within the struct. + */ +#define hlist_for_each_entry(tpos, pos, head, member) \ + for (pos = (head)->first; \ + pos && ({ prefetch(pos->next); 1; }) && \ + ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1; }); \ pos = pos->next) /** + * define hlist_for_each_entry_continue - Iterate continuing after existing point + * @tpos: the type * to use as a loop counter. + * @pos: the &struct hlist_node to use as a loop counter. + * @member: the name of the hlist_node within the struct. + * * Iterate over an hlist continuing after existing point - * \param tpos the type * to use as a loop counter. - * \param pos the &struct hlist_node to use as a loop counter. - * \param member the name of the hlist_node within the struct. - */ -#define hlist_for_each_entry_continue(tpos, pos, member) \ - for (pos = (pos)->next; \ - pos && ({ prefetch(pos->next); 1;}) && \ - ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \ + */ +#define hlist_for_each_entry_continue(tpos, pos, member) \ + for (pos = (pos)->next; \ + pos && ({ prefetch(pos->next); 1; }) && \ + ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1; }); \ pos = pos->next) /** + * define hlist_for_each_entry_from - Iterate continuing from an existing point + * @tpos: the type * to use as a loop counter. + * @pos: the &struct hlist_node to use as a loop counter. + * @member: the name of the hlist_node within the struct. + * * Iterate over an hlist continuing from an existing point - * \param tpos the type * to use as a loop counter. - * \param pos the &struct hlist_node to use as a loop counter. - * \param member the name of the hlist_node within the struct. */ #define hlist_for_each_entry_from(tpos, pos, member) \ - for (; pos && ({ prefetch(pos->next); 1;}) && \ - ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \ + for (; pos && ({ prefetch(pos->next); 1; }) && \ + ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1; });\ pos = pos->next) /** + * define hlist_for_each_entry_safe - Iterate an hlist safely + * @tpos: the type * to use as a loop counter. + * @pos: the &struct hlist_node to use as a loop counter. + * @n: another &struct hlist_node to use as temporary storage + * @head: the head for your list. + * @member: the name of the hlist_node within the struct. + * * Iterate over an hlist of given type safe against removal of list entry - * \param tpos the type * to use as a loop counter. - * \param pos the &struct hlist_node to use as a loop counter. - * \param n another &struct hlist_node to use as temporary storage - * \param head the head for your list. - * \param member the name of the hlist_node within the struct. - */ -#define hlist_for_each_entry_safe(tpos, pos, n, head, member) \ - for (pos = (head)->first; \ - pos && ({ n = pos->next; 1; }) && \ - ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \ + */ +#define hlist_for_each_entry_safe(tpos, pos, n, head, member) \ + for (pos = (head)->first; \ + pos && ({ n = pos->next; 1; }) && \ + ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1; }); \ pos = n) -/* @} */ - /** - * Iterate over a list in reverse order - * \param pos the &struct list_head to use as a loop counter. - * \param head the head for your list. + * define list_for_each_prev - Iterate over a list in reverse order + * @pos: the &struct list_head to use as a loop counter. + * @head: the head for your list. */ -#define list_for_each_prev(pos, head) \ - for (pos = (head)->prev, prefetch(pos->prev); pos != (head); \ +#define list_for_each_prev(pos, head) \ + for (pos = (head)->prev, prefetch(pos->prev); pos != (head); \ pos = pos->prev, prefetch(pos->prev)) /** - * Iterate over a list of given type - * \param pos the type * to use as a loop counter. - * \param head the head for your list. - * \param member the name of the list_struct within the struct. - */ -#define list_for_each_entry(pos, head, member) \ - for (pos = list_first_entry((head), typeof(*pos), member), \ - prefetch(pos->member.next); \ - &pos->member != (head); \ - pos = list_entry(pos->member.next, typeof(*pos), member), \ + * define list_for_each_entry - Iterate over a 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_first_entry((head), typeof(*pos), member), \ + prefetch(pos->member.next); \ + &pos->member != (head); \ + pos = list_entry(pos->member.next, typeof(*pos), member), \ prefetch(pos->member.next)) /** + * define list_for_each_entry_reverse - Iterate backwards over a list + * @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. + * * Iterate backwards over a list of given type. - * \param pos the type * to use as a loop counter. - * \param head the head for your list. - * \param member the name of the list_struct within the struct. */ -#define list_for_each_entry_reverse(pos, head, member) \ - for (pos = list_entry((head)->prev, typeof(*pos), member); \ - prefetch(pos->member.prev), &pos->member != (head); \ +#define list_for_each_entry_reverse(pos, head, member) \ + for (pos = list_entry((head)->prev, typeof(*pos), member); \ + prefetch(pos->member.prev), &pos->member != (head); \ pos = list_entry(pos->member.prev, typeof(*pos), member)) /** - * Iterate over a list of given type safe against removal of list entry - * \param pos the type * to use as a loop counter. - * \param n another type * to use as temporary storage - * \param head the head for your list. - * \param member the name of the list_struct within the struct. - */ -#define list_for_each_entry_safe(pos, n, head, member) \ - for (pos = list_first_entry((head), typeof(*pos), member), \ - n = list_entry(pos->member.next, typeof(*pos), member); \ - &pos->member != (head); \ + * define list_for_each_entry_safe - Iterate over a list of given type safe + * against removal of list entry + * @pos: the type * to use as a loop counter. + * @n: another type * to use as temporary storage + * @head: the head for your list. + * @member: the name of the list_struct within the struct. + */ +#define list_for_each_entry_safe(pos, n, head, member) \ + for (pos = list_first_entry((head), typeof(*pos), member), \ + n = list_entry(pos->member.next, typeof(*pos), member); \ + &pos->member != (head); \ pos = n, n = list_entry(n->member.next, typeof(*n), member)) /** - * Iterate backwards over a list of given type safely against removal of entry - * \param pos the type * to use as a loop counter. - * \param n another type * to use as temporary storage - * \param head the head for your list. - * \param member the name of the list_struct within the struct. + * define list_for_each_entry_safe_reverse - Iterate backwards over a list of + * given type safely against removal + * of entry + * @pos: the type * to use as a loop counter. + * @n: another type * to use as temporary storage + * @head: the head for your list. + * @member: the name of the list_struct within the struct. */ #define list_for_each_entry_safe_reverse(pos, n, head, member) \ for (pos = list_entry((head)->prev, typeof(*pos), member), \ -- 1.8.3.1