mpi@ reminded me I had this diff cooking.
This diff renames SIMPLEQ_* to STAILQ_* in /usr/src/sys/sys to unify with
FreeBSD and Linux.
I added aliases at the end of queue.h to avoid breaking base too much. they will
be removed as soon as diff 2,3,4,5,6,7 are commited.
net/sniproxy has a patch to define STAILQ_*, it may be removed later.
Index: buf.h
===================================================================
RCS file: /cvs/src/sys/sys/buf.h,v
retrieving revision 1.112
diff -u -p -r1.112 buf.h
--- buf.h 29 Nov 2019 01:04:08 -0000 1.112
+++ buf.h 25 Dec 2020 14:24:08 -0000
@@ -105,15 +105,15 @@ void bufq_quiesce(void);
void bufq_restart(void);
/* fifo */
-SIMPLEQ_HEAD(bufq_fifo_head, buf);
+STAILQ_HEAD(bufq_fifo_head, buf);
struct bufq_fifo {
- SIMPLEQ_ENTRY(buf) bqf_entries;
+ STAILQ_ENTRY(buf) bqf_entries;
};
/* nscan */
-SIMPLEQ_HEAD(bufq_nscan_head, buf);
+STAILQ_HEAD(bufq_nscan_head, buf);
struct bufq_nscan {
- SIMPLEQ_ENTRY(buf) bqf_entries;
+ STAILQ_ENTRY(buf) bqf_entries;
};
/* bufq link in struct buf */
Index: fusebuf.h
===================================================================
RCS file: /cvs/src/sys/sys/fusebuf.h,v
retrieving revision 1.13
diff -u -p -r1.13 fusebuf.h
--- fusebuf.h 19 Jun 2018 11:27:54 -0000 1.13
+++ fusebuf.h 25 Dec 2020 14:24:08 -0000
@@ -27,7 +27,7 @@
/* header at beginning of each fusebuf: */
struct fb_hdr {
- SIMPLEQ_ENTRY(fusebuf) fh_next; /* next buffer in chain */
+ STAILQ_ENTRY(fusebuf) fh_next; /* next buffer in chain */
size_t fh_len; /* Amount of data */
int fh_err; /* errno to pass back */
int fh_type; /* type of data */
Index: pool.h
===================================================================
RCS file: /cvs/src/sys/sys/pool.h,v
retrieving revision 1.77
diff -u -p -r1.77 pool.h
--- pool.h 19 Jul 2019 09:03:03 -0000 1.77
+++ pool.h 25 Dec 2020 14:24:08 -0000
@@ -152,7 +152,7 @@ struct pool {
union pool_lock pr_lock;
const struct pool_lock_ops *
pr_lock_ops;
- SIMPLEQ_ENTRY(pool)
+ STAILQ_ENTRY(pool)
pr_poollist;
struct pool_pagelist
pr_emptypages; /* Empty pages */
Index: queue.h
===================================================================
RCS file: /cvs/src/sys/sys/queue.h,v
retrieving revision 1.45
diff -u -p -r1.45 queue.h
--- queue.h 12 Jul 2018 14:22:54 -0000 1.45
+++ queue.h 25 Dec 2020 14:24:08 -0000
@@ -96,7 +96,7 @@ struct name {
\
struct type *slh_first; /* first element */ \
}
-#define SLIST_HEAD_INITIALIZER(head)
\
+#define SLIST_HEAD_INITIALIZER(head) \
{ NULL }
#define SLIST_ENTRY(type) \
@@ -107,43 +107,43 @@ struct {
\
/*
* Singly-linked List access methods.
*/
-#define SLIST_FIRST(head) ((head)->slh_first)
-#define SLIST_END(head) NULL
-#define SLIST_EMPTY(head) (SLIST_FIRST(head) == SLIST_END(head))
-#define SLIST_NEXT(elm, field) ((elm)->field.sle_next)
+#define SLIST_FIRST(head) ((head)->slh_first)
+#define SLIST_END(head) NULL
+#define SLIST_EMPTY(head) (SLIST_FIRST(head) == SLIST_END(head))
+#define SLIST_NEXT(elm, field) ((elm)->field.sle_next)
-#define SLIST_FOREACH(var, head, field)
\
+#define SLIST_FOREACH(var, head, field)
\
for((var) = SLIST_FIRST(head); \
(var) != SLIST_END(head); \
(var) = SLIST_NEXT(var, field))
-#define SLIST_FOREACH_SAFE(var, head, field, tvar)
\
- for ((var) = SLIST_FIRST(head); \
+#define SLIST_FOREACH_SAFE(var, head, field, tvar) \
+ for ((var) = SLIST_FIRST(head); \
(var) && ((tvar) = SLIST_NEXT(var, field), 1); \
(var) = (tvar))
/*
* Singly-linked List functions.
*/
-#define SLIST_INIT(head) {
\
+#define SLIST_INIT(head) { \
SLIST_FIRST(head) = SLIST_END(head); \
}
-#define SLIST_INSERT_AFTER(slistelm, elm, field) do {
\
+#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \
(elm)->field.sle_next = (slistelm)->field.sle_next; \
(slistelm)->field.sle_next = (elm); \
} while (0)
-#define SLIST_INSERT_HEAD(head, elm, field) do {
\
+#define SLIST_INSERT_HEAD(head, elm, field) do { \
(elm)->field.sle_next = (head)->slh_first; \
(head)->slh_first = (elm); \
} while (0)
-#define SLIST_REMOVE_AFTER(elm, field) do {
\
+#define SLIST_REMOVE_AFTER(elm, field) do { \
(elm)->field.sle_next = (elm)->field.sle_next->field.sle_next; \
} while (0)
-#define SLIST_REMOVE_HEAD(head, field) do {
\
+#define SLIST_REMOVE_HEAD(head, field) do { \
(head)->slh_first = (head)->slh_first->field.sle_next; \
} while (0)
@@ -181,25 +181,25 @@ struct {
\
/*
* List access methods.
*/
-#define LIST_FIRST(head) ((head)->lh_first)
-#define LIST_END(head) NULL
-#define LIST_EMPTY(head) (LIST_FIRST(head) ==
LIST_END(head))
-#define LIST_NEXT(elm, field) ((elm)->field.le_next)
+#define LIST_FIRST(head) ((head)->lh_first)
+#define LIST_END(head) NULL
+#define LIST_EMPTY(head) (LIST_FIRST(head) == LIST_END(head))
+#define LIST_NEXT(elm, field) ((elm)->field.le_next)
#define LIST_FOREACH(var, head, field) \
for((var) = LIST_FIRST(head); \
(var)!= LIST_END(head); \
(var) = LIST_NEXT(var, field))
-#define LIST_FOREACH_SAFE(var, head, field, tvar)
\
- for ((var) = LIST_FIRST(head); \
+#define LIST_FOREACH_SAFE(var, head, field, tvar) \
+ for ((var) = LIST_FIRST(head); \
(var) && ((tvar) = LIST_NEXT(var, field), 1); \
(var) = (tvar))
/*
* List functions.
*/
-#define LIST_INIT(head) do {
\
+#define LIST_INIT(head) do { \
LIST_FIRST(head) = LIST_END(head); \
} while (0)
@@ -211,7 +211,7 @@ struct {
\
(elm)->field.le_prev = &(listelm)->field.le_next; \
} while (0)
-#define LIST_INSERT_BEFORE(listelm, elm, field) do {
\
+#define LIST_INSERT_BEFORE(listelm, elm, field) do { \
(elm)->field.le_prev = (listelm)->field.le_prev; \
(elm)->field.le_next = (listelm); \
*(listelm)->field.le_prev = (elm); \
@@ -245,82 +245,84 @@ struct {
\
} while (0)
/*
- * Simple queue definitions.
+ * Singly-linked tail queue definitions.
*/
-#define SIMPLEQ_HEAD(name, type) \
+#define STAILQ_HEAD(name, type)
\
struct name { \
- struct type *sqh_first; /* first element */ \
- struct type **sqh_last; /* addr of last next element */ \
+ struct type *stqh_first; /* first element */ \
+ struct type **stqh_last; /* addr of last next element */ \
}
-#define SIMPLEQ_HEAD_INITIALIZER(head) \
- { NULL, &(head).sqh_first }
+#define STAILQ_HEAD_INITIALIZER(head) \
+ { NULL, &(head).stqh_first }
-#define SIMPLEQ_ENTRY(type) \
+#define STAILQ_ENTRY(type) \
struct { \
- struct type *sqe_next; /* next element */ \
+ struct type *stqe_next; /* next element */ \
}
/*
- * Simple queue access methods.
+ * Singly-linked tail queue access methods.
*/
-#define SIMPLEQ_FIRST(head) ((head)->sqh_first)
-#define SIMPLEQ_END(head) NULL
-#define SIMPLEQ_EMPTY(head) (SIMPLEQ_FIRST(head) ==
SIMPLEQ_END(head))
-#define SIMPLEQ_NEXT(elm, field) ((elm)->field.sqe_next)
-
-#define SIMPLEQ_FOREACH(var, head, field) \
- for((var) = SIMPLEQ_FIRST(head); \
- (var) != SIMPLEQ_END(head); \
- (var) = SIMPLEQ_NEXT(var, field))
-
-#define SIMPLEQ_FOREACH_SAFE(var, head, field, tvar)
\
- for ((var) = SIMPLEQ_FIRST(head); \
- (var) && ((tvar) = SIMPLEQ_NEXT(var, field), 1); \
+#define STAILQ_FIRST(head) ((head)->stqh_first)
+#define STAILQ_END(head) NULL
+#define STAILQ_EMPTY(head) (STAILQ_FIRST(head) == STAILQ_END(head))
+#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next)
+
+#define STAILQ_FOREACH(var, head, field) \
+ for((var) = STAILQ_FIRST(head); \
+ (var) != STAILQ_END(head); \
+ (var) = STAILQ_NEXT(var, field))
+
+#define STAILQ_FOREACH_SAFE(var, head, field, tvar) \
+ for ((var) = STAILQ_FIRST(head); \
+ (var) && ((tvar) = STAILQ_NEXT(var, field), 1); \
(var) = (tvar))
/*
- * Simple queue functions.
+ * Singly-linked tail queue functions.
*/
-#define SIMPLEQ_INIT(head) do {
\
- (head)->sqh_first = NULL; \
- (head)->sqh_last = &(head)->sqh_first; \
+#define STAILQ_INIT(head) do { \
+ (head)->stqh_first = NULL; \
+ (head)->stqh_last = &(head)->stqh_first; \
} while (0)
-#define SIMPLEQ_INSERT_HEAD(head, elm, field) do { \
- if (((elm)->field.sqe_next = (head)->sqh_first) == NULL) \
- (head)->sqh_last = &(elm)->field.sqe_next; \
- (head)->sqh_first = (elm); \
+#define STAILQ_INSERT_HEAD(head, elm, field) do { \
+ if (((elm)->field.stqe_next = (head)->stqh_first) == NULL) \
+ (head)->stqh_last = &(elm)->field.stqe_next; \
+ (head)->stqh_first = (elm); \
} while (0)
-#define SIMPLEQ_INSERT_TAIL(head, elm, field) do { \
- (elm)->field.sqe_next = NULL; \
- *(head)->sqh_last = (elm); \
- (head)->sqh_last = &(elm)->field.sqe_next; \
+#define STAILQ_INSERT_TAIL(head, elm, field) do { \
+ (elm)->field.stqe_next = NULL; \
+ *(head)->stqh_last = (elm); \
+ (head)->stqh_last = &(elm)->field.stqe_next; \
} while (0)
-#define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do { \
- if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\
- (head)->sqh_last = &(elm)->field.sqe_next; \
- (listelm)->field.sqe_next = (elm); \
+#define STAILQ_INSERT_AFTER(head, listelm, elm, field) do { \
+ if (((elm)->field.stqe_next = \
+ (listelm)->field.stqe_next) == NULL) \
+ (head)->stqh_last = &(elm)->field.stqe_next; \
+ (listelm)->field.stqe_next = (elm); \
} while (0)
-#define SIMPLEQ_REMOVE_HEAD(head, field) do { \
- if (((head)->sqh_first = (head)->sqh_first->field.sqe_next) == NULL) \
- (head)->sqh_last = &(head)->sqh_first; \
+#define STAILQ_REMOVE_HEAD(head, field) do { \
+ if (((head)->stqh_first = \
+ (head)->stqh_first->field.stqe_next) == NULL) \
+ (head)->stqh_last = &(head)->stqh_first; \
} while (0)
-#define SIMPLEQ_REMOVE_AFTER(head, elm, field) do { \
- if (((elm)->field.sqe_next = (elm)->field.sqe_next->field.sqe_next) \
- == NULL) \
- (head)->sqh_last = &(elm)->field.sqe_next; \
+#define STAILQ_REMOVE_AFTER(head, elm, field) do { \
+ if (((elm)->field.stqe_next = \
+ (elm)->field.stqe_next->field.stqe_next) == NULL) \
+ (head)->stqh_last = &(elm)->field.stqe_next; \
} while (0)
-#define SIMPLEQ_CONCAT(head1, head2) do { \
- if (!SIMPLEQ_EMPTY((head2))) { \
- *(head1)->sqh_last = (head2)->sqh_first; \
- (head1)->sqh_last = (head2)->sqh_last; \
- SIMPLEQ_INIT((head2)); \
+#define STAILQ_CONCAT(head1, head2) do { \
+ if (!STAILQ_EMPTY((head2))) { \
+ *(head1)->stqh_last = (head2)->stqh_first; \
+ (head1)->stqh_last = (head2)->stqh_last; \
+ STAILQ_INIT((head2)); \
} \
} while (0)
@@ -344,18 +346,17 @@ struct {
\
*/
#define XSIMPLEQ_XOR(head, ptr) ((__typeof(ptr))((head)->sqx_cookie
^ \
(unsigned long)(ptr)))
-#define XSIMPLEQ_FIRST(head) XSIMPLEQ_XOR(head,
((head)->sqx_first))
-#define XSIMPLEQ_END(head) NULL
-#define XSIMPLEQ_EMPTY(head) (XSIMPLEQ_FIRST(head) ==
XSIMPLEQ_END(head))
-#define XSIMPLEQ_NEXT(head, elm, field) XSIMPLEQ_XOR(head,
((elm)->field.sqx_next))
-
+#define XSIMPLEQ_FIRST(head) XSIMPLEQ_XOR(head, ((head)->sqx_first))
+#define XSIMPLEQ_END(head) NULL
+#define XSIMPLEQ_EMPTY(head) (XSIMPLEQ_FIRST(head) == XSIMPLEQ_END(head))
+#define XSIMPLEQ_NEXT(head, elm, field) XSIMPLEQ_XOR(head,
((elm)->field.sqx_next))
#define XSIMPLEQ_FOREACH(var, head, field) \
for ((var) = XSIMPLEQ_FIRST(head); \
(var) != XSIMPLEQ_END(head); \
(var) = XSIMPLEQ_NEXT(head, var, field))
-#define XSIMPLEQ_FOREACH_SAFE(var, head, field, tvar)
\
+#define XSIMPLEQ_FOREACH_SAFE(var, head, field, tvar) \
for ((var) = XSIMPLEQ_FIRST(head); \
(var) && ((tvar) = XSIMPLEQ_NEXT(head, var, field), 1); \
(var) = (tvar))
@@ -363,7 +364,7 @@ struct {
\
/*
* XOR Simple queue functions.
*/
-#define XSIMPLEQ_INIT(head) do {
\
+#define XSIMPLEQ_INIT(head) do { \
arc4random_buf(&(head)->sqx_cookie, sizeof((head)->sqx_cookie)); \
(head)->sqx_first = XSIMPLEQ_XOR(head, NULL); \
(head)->sqx_last = XSIMPLEQ_XOR(head, &(head)->sqx_first); \
@@ -403,7 +404,6 @@ struct {
\
XSIMPLEQ_XOR(head, &(elm)->field.sqx_next); \
} while (0)
-
/*
* Tail queue definitions.
*/
@@ -425,15 +425,15 @@ struct {
\
/*
* Tail queue access methods.
*/
-#define TAILQ_FIRST(head) ((head)->tqh_first)
-#define TAILQ_END(head) NULL
-#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
+#define TAILQ_FIRST(head) ((head)->tqh_first)
+#define TAILQ_END(head) NULL
+#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
#define TAILQ_LAST(head, headname) \
(*(((struct headname *)((head)->tqh_last))->tqh_last))
/* XXX */
#define TAILQ_PREV(elm, headname, field) \
(*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
-#define TAILQ_EMPTY(head)
\
+#define TAILQ_EMPTY(head) \
(TAILQ_FIRST(head) == TAILQ_END(head))
#define TAILQ_FOREACH(var, head, field)
\
@@ -441,7 +441,7 @@ struct {
\
(var) != TAILQ_END(head); \
(var) = TAILQ_NEXT(var, field))
-#define TAILQ_FOREACH_SAFE(var, head, field, tvar)
\
+#define TAILQ_FOREACH_SAFE(var, head, field, tvar) \
for ((var) = TAILQ_FIRST(head); \
(var) != TAILQ_END(head) && \
((tvar) = TAILQ_NEXT(var, field), 1); \
@@ -453,7 +453,7 @@ struct {
\
(var) != TAILQ_END(head); \
(var) = TAILQ_PREV(var, headname, field))
-#define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar)
\
+#define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \
for ((var) = TAILQ_LAST(head, headname); \
(var) != TAILQ_END(head) && \
((tvar) = TAILQ_PREV(var, headname, field), 1); \
@@ -462,7 +462,7 @@ struct {
\
/*
* Tail queue functions.
*/
-#define TAILQ_INIT(head) do {
\
+#define TAILQ_INIT(head) do { \
(head)->tqh_first = NULL; \
(head)->tqh_last = &(head)->tqh_first; \
} while (0)
@@ -494,7 +494,7 @@ struct {
\
(elm)->field.tqe_prev = &(listelm)->field.tqe_next; \
} while (0)
-#define TAILQ_INSERT_BEFORE(listelm, elm, field) do {
\
+#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \
(elm)->field.tqe_prev = (listelm)->field.tqe_prev; \
(elm)->field.tqe_next = (listelm); \
*(listelm)->field.tqe_prev = (elm); \
@@ -532,5 +532,33 @@ struct {
\
TAILQ_INIT((head2)); \
} \
} while (0)
+
+/*
+ * XXX
+ * Temporarily aliases SIMPLEQ_* to STAILQ_*.
+ * To be removed as soon as all programs have switched to the new name.
+ */
+#define SIMPLEQ_HEAD(name, type) STAILQ_HEAD(name, type)
+#define SIMPLEQ_HEAD_INITIALIZER(head) STAILQ_HEAD_INITIALIZER(head)
+#define SIMPLEQ_ENTRY(type) STAILQ_ENTRY(type)
+#define SIMPLEQ_FIRST(head) STAILQ_FIRST(head)
+#define SIMPLEQ_END(head) STAILQ_END(head)
+#define SIMPLEQ_EMPTY(head) STAILQ_EMPTY(head)
+#define SIMPLEQ_NEXT(elm, field) STAILQ_NEXT(elm, field)
+#define SIMPLEQ_FOREACH(var, head, field) \
+ STAILQ_FOREACH(var, head, field)
+#define SIMPLEQ_FOREACH_SAFE(var, head, field, tvar) \
+ STAILQ_FOREACH_SAFE(var, head, field, tvar)
+#define SIMPLEQ_INIT(head) STAILQ_INIT(head)
+#define SIMPLEQ_INSERT_HEAD(head, elm, field) \
+ STAILQ_INSERT_HEAD(head, elm, field)
+#define SIMPLEQ_INSERT_TAIL(head, elm, field) \
+ STAILQ_INSERT_TAIL(head, elm, field)
+#define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) \
+ STAILQ_INSERT_AFTER(head, listelm, elm, field)
+#define SIMPLEQ_REMOVE_HEAD(head, field) STAILQ_REMOVE_HEAD(head, field)
+#define SIMPLEQ_REMOVE_AFTER(head, elm, field) \
+ STAILQ_REMOVE_AFTER(head, elm, field)
+#define SIMPLEQ_CONCAT(head1, head2) STAILQ_CONCAT(head1, head2)
#endif /* !_SYS_QUEUE_H_ */
Index: sched.h
===================================================================
RCS file: /cvs/src/sys/sys/sched.h,v
retrieving revision 1.56
diff -u -p -r1.56 sched.h
--- sched.h 21 Oct 2019 10:24:01 -0000 1.56
+++ sched.h 25 Dec 2020 14:24:08 -0000
@@ -114,7 +114,7 @@ struct schedstate_percpu {
volatile uint32_t spc_whichqs;
volatile u_int spc_spinning; /* this cpu is currently spinning */
- SIMPLEQ_HEAD(, smr_entry) spc_deferred; /* deferred smr calls */
+ STAILQ_HEAD(, smr_entry) spc_deferred; /* deferred smr calls */
u_int spc_ndeferred; /* number of deferred smr calls */
u_int spc_smrdepth; /* level of smr nesting */
u_char spc_smrexpedite; /* if set, dispatch smr entries
Index: smr.h
===================================================================
RCS file: /cvs/src/sys/sys/smr.h,v
retrieving revision 1.8
diff -u -p -r1.8 smr.h
--- smr.h 29 Sep 2020 16:40:33 -0000 1.8
+++ smr.h 25 Dec 2020 14:24:08 -0000
@@ -22,12 +22,12 @@
#include <sys/queue.h>
struct smr_entry {
- SIMPLEQ_ENTRY(smr_entry) smr_list;
+ STAILQ_ENTRY(smr_entry) smr_list;
void (*smr_func)(void *);
void *smr_arg;
};
-SIMPLEQ_HEAD(smr_entry_list, smr_entry);
+STAILQ_HEAD(smr_entry_list, smr_entry);
#ifdef _KERNEL
