? sys/o
Index: kern/kern_exec.c
===================================================================
RCS file: /cvsroot/src/sys/kern/kern_exec.c,v
retrieving revision 1.365
diff -u -p -u -r1.365 kern_exec.c
--- kern/kern_exec.c	14 Nov 2013 16:53:51 -0000	1.365
+++ kern/kern_exec.c	22 Nov 2013 20:43:04 -0000
@@ -2226,7 +2226,7 @@ do_posix_spawn(struct lwp *l1, pid_t *pi
 	    (unsigned) ((char *)&p2->p_endcopy - (char *)&p2->p_startcopy));
 	p2->p_vmspace = proc0.p_vmspace;
 
-	CIRCLEQ_INIT(&p2->p_sigpend.sp_info);
+	TAILQ_INIT(&p2->p_sigpend.sp_info);
 
 	LIST_INIT(&p2->p_lwps);
 	LIST_INIT(&p2->p_sigwaiters);
Index: kern/kern_fork.c
===================================================================
RCS file: /cvsroot/src/sys/kern/kern_fork.c,v
retrieving revision 1.192
diff -u -p -u -r1.192 kern_fork.c
--- kern/kern_fork.c	9 Jun 2013 01:13:47 -0000	1.192
+++ kern/kern_fork.c	22 Nov 2013 20:43:05 -0000
@@ -291,7 +291,7 @@ fork1(struct lwp *l1, int flags, int exi
 	memcpy(&p2->p_startcopy, &p1->p_startcopy,
 	    (unsigned) ((char *)&p2->p_endcopy - (char *)&p2->p_startcopy));
 
-	CIRCLEQ_INIT(&p2->p_sigpend.sp_info);
+	TAILQ_INIT(&p2->p_sigpend.sp_info);
 
 	LIST_INIT(&p2->p_lwps);
 	LIST_INIT(&p2->p_sigwaiters);
Index: kern/kern_hook.c
===================================================================
RCS file: /cvsroot/src/sys/kern/kern_hook.c,v
retrieving revision 1.5
diff -u -p -u -r1.5 kern_hook.c
--- kern/kern_hook.c	27 Oct 2012 17:18:39 -0000	1.5
+++ kern/kern_hook.c	22 Nov 2013 20:43:05 -0000
@@ -314,14 +314,14 @@ docritpollhooks(void)
  * registration order, when powering up in registration order.
  */
 struct powerhook_desc {
-	CIRCLEQ_ENTRY(powerhook_desc) sfd_list;
+	TAILQ_ENTRY(powerhook_desc) sfd_list;
 	void	(*sfd_fn)(int, void *);
 	void	*sfd_arg;
 	char	sfd_name[16];
 };
 
-static CIRCLEQ_HEAD(, powerhook_desc) powerhook_list =
-    CIRCLEQ_HEAD_INITIALIZER(powerhook_list);
+static TAILQ_HEAD(powerhook_head, powerhook_desc) powerhook_list =
+    TAILQ_HEAD_INITIALIZER(powerhook_list);
 
 void *
 powerhook_establish(const char *name, void (*fn)(int, void *), void *arg)
@@ -336,7 +336,7 @@ powerhook_establish(const char *name, vo
 	ndp->sfd_fn = fn;
 	ndp->sfd_arg = arg;
 	strlcpy(ndp->sfd_name, name, sizeof(ndp->sfd_name));
-	CIRCLEQ_INSERT_HEAD(&powerhook_list, ndp, sfd_list);
+	TAILQ_INSERT_HEAD(&powerhook_list, ndp, sfd_list);
 
 	aprint_error("%s: WARNING: powerhook_establish is deprecated\n", name);
 	return (ndp);
@@ -348,14 +348,14 @@ powerhook_disestablish(void *vhook)
 #ifdef DIAGNOSTIC
 	struct powerhook_desc *dp;
 
-	CIRCLEQ_FOREACH(dp, &powerhook_list, sfd_list)
+	TAILQ_FOREACH(dp, &powerhook_list, sfd_list)
                 if (dp == vhook)
 			goto found;
 	panic("powerhook_disestablish: hook %p not established", vhook);
  found:
 #endif
 
-	CIRCLEQ_REMOVE(&powerhook_list, (struct powerhook_desc *)vhook,
+	TAILQ_REMOVE(&powerhook_list, (struct powerhook_desc *)vhook,
 	    sfd_list);
 	free(vhook, M_DEVBUF);
 }
@@ -372,14 +372,16 @@ dopowerhooks(int why)
 	why_name = why < __arraycount(pwr_names) ? pwr_names[why] : "???";
 
 	if (why == PWR_RESUME || why == PWR_SOFTRESUME) {
-		CIRCLEQ_FOREACH_REVERSE(dp, &powerhook_list, sfd_list) {
+		TAILQ_FOREACH_REVERSE(dp, &powerhook_list, powerhook_head,
+		    sfd_list)
+		{
 			if (powerhook_debug)
 				printf("dopowerhooks %s: %s (%p)\n",
 				    why_name, dp->sfd_name, dp);
 			(*dp->sfd_fn)(why, dp->sfd_arg);
 		}
 	} else {
-		CIRCLEQ_FOREACH(dp, &powerhook_list, sfd_list) {
+		TAILQ_FOREACH(dp, &powerhook_list, sfd_list) {
 			if (powerhook_debug)
 				printf("dopowerhooks %s: %s (%p)\n",
 				    why_name, dp->sfd_name, dp);
Index: kern/kern_lwp.c
===================================================================
RCS file: /cvsroot/src/sys/kern/kern_lwp.c,v
retrieving revision 1.175
diff -u -p -u -r1.175 kern_lwp.c
--- kern/kern_lwp.c	9 Jun 2013 01:13:47 -0000	1.175
+++ kern/kern_lwp.c	22 Nov 2013 20:43:05 -0000
@@ -911,7 +911,7 @@ lwp_create(lwp_t *l1, proc_t *p2, vaddr_
 
 	l2->l_sigstk = l1->l_sigstk;
 	l2->l_sigmask = l1->l_sigmask;
-	CIRCLEQ_INIT(&l2->l_sigpend.sp_info);
+	TAILQ_INIT(&l2->l_sigpend.sp_info);
 	sigemptyset(&l2->l_sigpend.sp_set);
 
 	if (__predict_true(lid == 0)) {
Index: kern/kern_sig.c
===================================================================
RCS file: /cvsroot/src/sys/kern/kern_sig.c,v
retrieving revision 1.318
diff -u -p -u -r1.318 kern_sig.c
--- kern/kern_sig.c	9 Jun 2013 01:13:47 -0000	1.318
+++ kern/kern_sig.c	22 Nov 2013 20:43:05 -0000
@@ -519,11 +519,11 @@ ksiginfo_queue_drain0(ksiginfoq_t *kq)
 {
 	ksiginfo_t *ksi;
 
-	KASSERT(!CIRCLEQ_EMPTY(kq));
+	KASSERT(!TAILQ_EMPTY(kq));
 
-	while (!CIRCLEQ_EMPTY(kq)) {
-		ksi = CIRCLEQ_FIRST(kq);
-		CIRCLEQ_REMOVE(kq, ksi, ksi_list);
+	while (!TAILQ_EMPTY(kq)) {
+		ksi = TAILQ_FIRST(kq);
+		TAILQ_REMOVE(kq, ksi, ksi_list);
 		pool_cache_put(ksiginfo_cache, ksi);
 	}
 }
@@ -537,10 +537,10 @@ siggetinfo(sigpend_t *sp, ksiginfo_t *ou
 		goto out;
 
 	/* Find siginfo and copy it out. */
-	CIRCLEQ_FOREACH(ksi, &sp->sp_info, ksi_list) {
+	TAILQ_FOREACH(ksi, &sp->sp_info, ksi_list) {
 		if (ksi->ksi_signo != signo)
 			continue;
-		CIRCLEQ_REMOVE(&sp->sp_info, ksi, ksi_list);
+		TAILQ_REMOVE(&sp->sp_info, ksi, ksi_list);
 		KASSERT((ksi->ksi_flags & KSI_FROMPOOL) != 0);
 		KASSERT((ksi->ksi_flags & KSI_QUEUED) != 0);
 		ksi->ksi_flags &= ~KSI_QUEUED;
@@ -626,7 +626,7 @@ sigput(sigpend_t *sp, struct proc *p, ks
 	if (ksi->ksi_signo < SIGRTMIN)
 #endif
 	{
-		CIRCLEQ_FOREACH(kp, &sp->sp_info, ksi_list) {
+		TAILQ_FOREACH(kp, &sp->sp_info, ksi_list) {
 			if (kp->ksi_signo == ksi->ksi_signo) {
 				KSI_COPY(ksi, kp);
 				kp->ksi_flags |= KSI_QUEUED;
@@ -636,7 +636,7 @@ sigput(sigpend_t *sp, struct proc *p, ks
 	}
 
 	ksi->ksi_flags |= KSI_QUEUED;
-	CIRCLEQ_INSERT_TAIL(&sp->sp_info, ksi, ksi_list);
+	TAILQ_INSERT_TAIL(&sp->sp_info, ksi, ksi_list);
 }
 
 /*
@@ -654,14 +654,12 @@ sigclear(sigpend_t *sp, const sigset_t *
 	else
 		sigminusset(mask, &sp->sp_set);
 
-	ksi = CIRCLEQ_FIRST(&sp->sp_info);
-	for (; ksi != (void *)&sp->sp_info; ksi = next) {
-		next = CIRCLEQ_NEXT(ksi, ksi_list);
+	TAILQ_FOREACH_SAFE(ksi, &sp->sp_info, ksi_list, next) {
 		if (mask == NULL || sigismember(mask, ksi->ksi_signo)) {
-			CIRCLEQ_REMOVE(&sp->sp_info, ksi, ksi_list);
+			TAILQ_REMOVE(&sp->sp_info, ksi, ksi_list);
 			KASSERT((ksi->ksi_flags & KSI_FROMPOOL) != 0);
 			KASSERT((ksi->ksi_flags & KSI_QUEUED) != 0);
-			CIRCLEQ_INSERT_TAIL(kq, ksi, ksi_list);
+			TAILQ_INSERT_TAIL(kq, ksi, ksi_list);
 		}
 	}
 }
Index: kern/subr_vmem.c
===================================================================
RCS file: /cvsroot/src/sys/kern/subr_vmem.c,v
retrieving revision 1.86
diff -u -p -u -r1.86 subr_vmem.c
--- kern/subr_vmem.c	25 Oct 2013 11:35:55 -0000	1.86
+++ kern/subr_vmem.c	22 Nov 2013 20:43:05 -0000
@@ -426,21 +426,21 @@ static void
 bt_remseg(vmem_t *vm, bt_t *bt)
 {
 
-	CIRCLEQ_REMOVE(&vm->vm_seglist, bt, bt_seglist);
+	TAILQ_REMOVE(&vm->vm_seglist, bt, bt_seglist);
 }
 
 static void
 bt_insseg(vmem_t *vm, bt_t *bt, bt_t *prev)
 {
 
-	CIRCLEQ_INSERT_AFTER(&vm->vm_seglist, prev, bt, bt_seglist);
+	TAILQ_INSERT_AFTER(&vm->vm_seglist, prev, bt, bt_seglist);
 }
 
 static void
 bt_insseg_tail(vmem_t *vm, bt_t *bt)
 {
 
-	CIRCLEQ_INSERT_TAIL(&vm->vm_seglist, bt, bt_seglist);
+	TAILQ_INSERT_TAIL(&vm->vm_seglist, bt, bt_seglist);
 }
 
 static void
@@ -900,7 +900,7 @@ vmem_init(vmem_t *vm, const char *name,
 	qc_init(vm, qcache_max, ipl);
 #endif /* defined(QCACHE) */
 
-	CIRCLEQ_INIT(&vm->vm_seglist);
+	TAILQ_INIT(&vm->vm_seglist);
 	for (i = 0; i < VMEM_MAXORDER; i++) {
 		LIST_INIT(&vm->vm_freelist[i]);
 	}
@@ -1181,7 +1181,7 @@ gotit:
 		bt->bt_start = start;
 		bt->bt_size -= btnew2->bt_size;
 		bt_insfree(vm, btnew2);
-		bt_insseg(vm, btnew2, CIRCLEQ_PREV(bt, bt_seglist));
+		bt_insseg(vm, btnew2, TAILQ_PREV(bt, vmem_seglist, bt_seglist));
 		btnew2 = NULL;
 		vmem_check(vm);
 	}
@@ -1194,7 +1194,7 @@ gotit:
 		bt->bt_start = bt->bt_start + size;
 		bt->bt_size -= size;
 		bt_insfree(vm, bt);
-		bt_insseg(vm, btnew, CIRCLEQ_PREV(bt, bt_seglist));
+		bt_insseg(vm, btnew, TAILQ_PREV(bt, vmem_seglist, bt_seglist));
 		bt_insbusy(vm, btnew);
 		vmem_check(vm);
 		VMEM_UNLOCK(vm);
@@ -1263,7 +1263,7 @@ vmem_xfree(vmem_t *vm, vmem_addr_t addr,
 	bt->bt_type = BT_TYPE_FREE;
 
 	/* coalesce */
-	t = CIRCLEQ_NEXT(bt, bt_seglist);
+	t = TAILQ_NEXT(bt, bt_seglist);
 	if (t != NULL && t->bt_type == BT_TYPE_FREE) {
 		KASSERT(BT_END(bt) < t->bt_start);	/* YYY */
 		bt_remfree(vm, t);
@@ -1271,7 +1271,7 @@ vmem_xfree(vmem_t *vm, vmem_addr_t addr,
 		bt->bt_size += t->bt_size;
 		LIST_INSERT_HEAD(&tofree, t, bt_freelist);
 	}
-	t = CIRCLEQ_PREV(bt, bt_seglist);
+	t = TAILQ_PREV(bt, vmem_seglist, bt_seglist);
 	if (t != NULL && t->bt_type == BT_TYPE_FREE) {
 		KASSERT(BT_END(t) < bt->bt_start);	/* YYY */
 		bt_remfree(vm, t);
@@ -1281,7 +1281,7 @@ vmem_xfree(vmem_t *vm, vmem_addr_t addr,
 		LIST_INSERT_HEAD(&tofree, t, bt_freelist);
 	}
 
-	t = CIRCLEQ_PREV(bt, bt_seglist);
+	t = TAILQ_PREV(bt, vmem_seglist, bt_seglist);
 	KASSERT(t != NULL);
 	KASSERT(BT_ISSPAN_P(t) || t->bt_type == BT_TYPE_BUSY);
 	if (vm->vm_releasefn != NULL && t->bt_type == BT_TYPE_SPAN &&
@@ -1452,7 +1452,7 @@ vmem_dump(const vmem_t *vm , void (*pr)(
 	int i;
 
 	(*pr)("vmem %p '%s'\n", vm, vm->vm_name);
-	CIRCLEQ_FOREACH(bt, &vm->vm_seglist, bt_seglist) {
+	TAILQ_FOREACH(bt, &vm->vm_seglist, bt_seglist) {
 		bt_dump(bt, pr);
 	}
 
@@ -1478,7 +1478,7 @@ vmem_whatis_lookup(vmem_t *vm, uintptr_t
 {
 	bt_t *bt;
 
-	CIRCLEQ_FOREACH(bt, &vm->vm_seglist, bt_seglist) {
+	TAILQ_FOREACH(bt, &vm->vm_seglist, bt_seglist) {
 		if (BT_ISSPAN_P(bt)) {
 			continue;
 		}
@@ -1553,15 +1553,15 @@ vmem_check_sanity(vmem_t *vm)
 
 	KASSERT(vm != NULL);
 
-	CIRCLEQ_FOREACH(bt, &vm->vm_seglist, bt_seglist) {
+	TAILQ_FOREACH(bt, &vm->vm_seglist, bt_seglist) {
 		if (bt->bt_start > BT_END(bt)) {
 			printf("corrupted tag\n");
 			bt_dump(bt, vmem_printf);
 			return false;
 		}
 	}
-	CIRCLEQ_FOREACH(bt, &vm->vm_seglist, bt_seglist) {
-		CIRCLEQ_FOREACH(bt2, &vm->vm_seglist, bt_seglist) {
+	TAILQ_FOREACH(bt, &vm->vm_seglist, bt_seglist) {
+		TAILQ_FOREACH(bt2, &vm->vm_seglist, bt_seglist) {
 			if (bt == bt2) {
 				continue;
 			}
Index: sys/siginfo.h
===================================================================
RCS file: /cvsroot/src/sys/sys/siginfo.h,v
retrieving revision 1.24
diff -u -p -u -r1.24 siginfo.h
--- sys/siginfo.h	27 Apr 2013 21:35:24 -0000	1.24
+++ sys/siginfo.h	22 Nov 2013 20:43:05 -0000
@@ -83,7 +83,7 @@ struct _ksiginfo {
 #ifdef _KERNEL
 typedef struct ksiginfo {
 	u_long			ksi_flags;	/* 4 or 8 bytes (LP64) */
-	CIRCLEQ_ENTRY(ksiginfo) ksi_list;
+	TAILQ_ENTRY(ksiginfo)	ksi_list;
 	struct _ksiginfo	ksi_info;
 	lwpid_t			ksi_lid;	/* 0, or directed to LWP */
 } ksiginfo_t;
Index: sys/signalvar.h
===================================================================
RCS file: /cvsroot/src/sys/sys/signalvar.h,v
retrieving revision 1.83
diff -u -p -u -r1.83 signalvar.h
--- sys/signalvar.h	19 Feb 2012 21:07:00 -0000	1.83
+++ sys/signalvar.h	22 Nov 2013 20:43:07 -0000
@@ -46,7 +46,7 @@
 /*
  * Queue of signals.
  */
-typedef CIRCLEQ_HEAD(ksiginfoq, ksiginfo) ksiginfoq_t;
+typedef TAILQ_HEAD(ksiginfoq, ksiginfo) ksiginfoq_t;
 
 /*
  * Process signal actions, possibly shared between processes.
@@ -222,13 +222,13 @@ firstsig(const sigset_t *ss)
 static inline void
 ksiginfo_queue_init(ksiginfoq_t *kq)
 {
-	CIRCLEQ_INIT(kq);
+	TAILQ_INIT(kq);
 }
 
 static inline void
 ksiginfo_queue_drain(ksiginfoq_t *kq)
 {
-	if (!CIRCLEQ_EMPTY(kq))
+	if (!TAILQ_EMPTY(kq))
 		ksiginfo_queue_drain0(kq);
 }
 
Index: sys/vmem_impl.h
===================================================================
RCS file: /cvsroot/src/sys/sys/vmem_impl.h,v
retrieving revision 1.2
diff -u -p -u -r1.2 vmem_impl.h
--- sys/vmem_impl.h	29 Jan 2013 21:26:24 -0000	1.2
+++ sys/vmem_impl.h	22 Nov 2013 20:43:07 -0000
@@ -62,7 +62,7 @@
 
 typedef struct vmem_btag bt_t;
 
-CIRCLEQ_HEAD(vmem_seglist, vmem_btag);
+TAILQ_HEAD(vmem_seglist, vmem_btag);
 LIST_HEAD(vmem_freelist, vmem_btag);
 LIST_HEAD(vmem_hashlist, vmem_btag);
 
@@ -116,7 +116,7 @@ struct vmem {
 
 /* boundary tag */
 struct vmem_btag {
-	CIRCLEQ_ENTRY(vmem_btag) bt_seglist;
+	TAILQ_ENTRY(vmem_btag) bt_seglist;
 	union {
 		LIST_ENTRY(vmem_btag) u_freelist; /* BT_TYPE_FREE */
 		LIST_ENTRY(vmem_btag) u_hashlist; /* BT_TYPE_BUSY */