[Buildroot] [PATCH v2 1/3] package/libtirpc: bump to version 0.3.2

[Buildroot] [PATCH v2 1/3] package/libtirpc: bump to version 0.3.2

[Jörg Krause]

Bump version, update hash and update patch.

Signed-off-by: J?rg Krause <joerg.krause@embedded.rocks>
---
Changes v1 -> v2:
  - None
---
 ...sable-parts-of-TIRPC-requiring-NIS-support.patch | 21 +++++++++++++--------
 package/libtirpc/libtirpc.hash                      |  4 ++--
 package/libtirpc/libtirpc.mk                        |  2 +-
 3 files changed, 16 insertions(+), 11 deletions(-)

diff --git a/package/libtirpc/0001-Disable-parts-of-TIRPC-requiring-NIS-support.patch b/package/libtirpc/0001-Disable-parts-of-TIRPC-requiring-NIS-support.patch
index 2835ee1..12771f3 100644
--- a/package/libtirpc/0001-Disable-parts-of-TIRPC-requiring-NIS-support.patch
+++ b/package/libtirpc/0001-Disable-parts-of-TIRPC-requiring-NIS-support.patch
@@ -1,28 +1,33 @@
-From 9ab72f908af734b5a940fb459394072cfa9fc3a8 Mon Sep 17 00:00:00 2001
-From: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
-Date: Sat, 23 Jun 2012 21:57:39 +0200
-Subject: [PATCH] Disable parts of TIRPC requiring NIS support
+From fc53290b7f2be918856883cd174cf18f06a085cf Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?J=C3=B6rg=20Krause?= <joerg.krause@embedded.rocks>
+Date: Mon, 20 Jul 2015 20:30:11 +0200
+Subject: [PATCH 1/1] Disable parts of TIRPC requiring NIS support
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
 
 Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
 [yann.morin.1998 at free.fr: update for 0.3.1]
 Signed-off-by: "Yann E. MORIN" <yann.morin.1998@free.fr>
+[joerg.krause at embedded.rocks: update for 0.3.2]
+Signed-off-by: J?rg Krause <joerg.krause@embedded.rocks>
 ---
  src/Makefile.am | 2 +-
  1 file changed, 1 insertion(+), 1 deletion(-)
 
 diff --git a/src/Makefile.am b/src/Makefile.am
-index 75bd4bf..7428e92 100644
+index 6cc567a..cf8a8ca 100644
 --- a/src/Makefile.am
 +++ b/src/Makefile.am
-@@ -52,7 +52,7 @@ libtirpc_la_SOURCES = auth_none.c auth_unix.c authunix_prot.c bindresvport.c cln
+@@ -51,7 +51,7 @@ libtirpc_la_SOURCES = auth_none.c auth_unix.c authunix_prot.c bindresvport.c cln
          rpc_callmsg.c rpc_generic.c rpc_soc.c rpcb_clnt.c rpcb_prot.c \
          rpcb_st_xdr.c svc.c svc_auth.c svc_dg.c svc_auth_unix.c svc_auth_none.c \
          svc_generic.c svc_raw.c svc_run.c svc_simple.c svc_vc.c getpeereid.c \
--        auth_time.c debug.c
+-        auth_time.c auth_des.c authdes_prot.c debug.c
 +        debug.c
  
  ## XDR
  libtirpc_la_SOURCES += xdr.c xdr_rec.c xdr_array.c xdr_float.c xdr_mem.c xdr_reference.c xdr_stdio.c
 -- 
-1.9.1
+2.4.6
 
diff --git a/package/libtirpc/libtirpc.hash b/package/libtirpc/libtirpc.hash
index 0a1cc98..f171870 100644
--- a/package/libtirpc/libtirpc.hash
+++ b/package/libtirpc/libtirpc.hash
@@ -1,4 +1,4 @@
 # From sourceforge's info on download page:
-sha1   0e0ef9123cf28cd0940148fabd23952476a8fcd6  libtirpc-0.3.1.tar.bz2
+sha1   af9b74d0c4d1499a7b1a43e396e5b7d62180ea65  libtirpc-0.3.2.tar.bz2
 # Locally computed
-sha256 a8838fe180deb8a6f6e491ee665325a28dee4100ec6b1f0b86d611dbfe3a2bb8  libtirpc-0.3.1.tar.bz2
+sha256 2008a379f37f2c5d5a87a568b06707422cc3e4f5da305f7fb71f3f4c6d473ffc  libtirpc-0.3.2.tar.bz2
diff --git a/package/libtirpc/libtirpc.mk b/package/libtirpc/libtirpc.mk
index 494650c..8f49356 100644
--- a/package/libtirpc/libtirpc.mk
+++ b/package/libtirpc/libtirpc.mk
@@ -4,7 +4,7 @@
 #
 ################################################################################
 
-LIBTIRPC_VERSION = 0.3.1
+LIBTIRPC_VERSION = 0.3.2
 LIBTIRPC_SOURCE = libtirpc-$(LIBTIRPC_VERSION).tar.bz2
 LIBTIRPC_SITE = http://downloads.sourceforge.net/project/libtirpc/libtirpc/$(LIBTIRPC_VERSION)
 LIBTIRPC_LICENSE = BSD-3c
-- 
2.4.6

[Buildroot] [PATCH v2 2/3] package/libtirpc: fix musl build

[Jörg Krause]

The fix includes:
  1) Defining rpcent for non-Glibc's
  2) Using a local queue implementation

1) Defining rpcent for non-Glibc's
musl does not define rpcent. Since musl does not provide a __MUSL__ macro we
add a check for non-Glibc's to the existing uClibc patch.

2) Using a local queue implementation
musl does not provide sys/queue.h. We borrow a compatible queue implementation
from the NetBSD project.

Fixes:
http://autobuild.buildroot.net/results/f93/f93f0be26b5a25b953ea7f909037c1f45a83f686/
http://autobuild.buildroot.net/results/c53/c537a76d17012821ed5a6f4170f759efd4d269b0/
http://autobuild.buildroot.net/results/e3c/e3c5be7dca753f7494e8680894f516a8cdc89843/
http://autobuild.buildroot.net/results/2bb/2bb2e314f23b5ba48bb6e0c4fc7e52032fa5d76b/

and many more.

Signed-off-by: J?rg Krause <joerg.krause@embedded.rocks>
---
Changes v1 -> v2:
  - None
---
 ...able-parts-of-TIRPC-requiring-NIS-support.patch |   2 +-
 ...pport-and-musl-does-not-install-rpcent.h.patch} |   6 +-
 package/libtirpc/0006-Use-local-bsdqueue.h.patch   | 903 +++++++++++++++++++++
 3 files changed, 908 insertions(+), 3 deletions(-)
 rename package/libtirpc/{0002-uClibc-without-RPC-support-does-not-install-rpcent.h.patch => 0002-uClibc-without-RPC-support-and-musl-does-not-install-rpcent.h.patch} (78%)
 create mode 100644 package/libtirpc/0006-Use-local-bsdqueue.h.patch

diff --git a/package/libtirpc/0001-Disable-parts-of-TIRPC-requiring-NIS-support.patch b/package/libtirpc/0001-Disable-parts-of-TIRPC-requiring-NIS-support.patch
index 12771f3..71d4420 100644
--- a/package/libtirpc/0001-Disable-parts-of-TIRPC-requiring-NIS-support.patch
+++ b/package/libtirpc/0001-Disable-parts-of-TIRPC-requiring-NIS-support.patch
@@ -1,4 +1,4 @@
-From fc53290b7f2be918856883cd174cf18f06a085cf Mon Sep 17 00:00:00 2001
+From 583ad557faf86c5532e16dafff19bfdcc349752d Mon Sep 17 00:00:00 2001
 From: =?UTF-8?q?J=C3=B6rg=20Krause?= <joerg.krause@embedded.rocks>
 Date: Mon, 20 Jul 2015 20:30:11 +0200
 Subject: [PATCH 1/1] Disable parts of TIRPC requiring NIS support
diff --git a/package/libtirpc/0002-uClibc-without-RPC-support-does-not-install-rpcent.h.patch b/package/libtirpc/0002-uClibc-without-RPC-support-and-musl-does-not-install-rpcent.h.patch
similarity index 78%
rename from package/libtirpc/0002-uClibc-without-RPC-support-does-not-install-rpcent.h.patch
rename to package/libtirpc/0002-uClibc-without-RPC-support-and-musl-does-not-install-rpcent.h.patch
index 44b5f99..643a57e 100644
--- a/package/libtirpc/0002-uClibc-without-RPC-support-does-not-install-rpcent.h.patch
+++ b/package/libtirpc/0002-uClibc-without-RPC-support-and-musl-does-not-install-rpcent.h.patch
@@ -1,11 +1,13 @@
 From 7aa1fe6a0f9280571117c30c03c2cc521cd86ec3 Mon Sep 17 00:00:00 2001
 From: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
 Date: Sat, 23 Jun 2012 21:58:07 +0200
-Subject: [PATCH] uClibc without RPC support does not install rpcent.h
+Subject: [PATCH] uClibc without RPC support and musl does not install rpcent.h
 
 Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
 [yann.morin.1998 at free.fr: update for 0.3.1]
 Signed-off-by: "Yann E. MORIN" <yann.morin.1998@free.fr>
+[joerg.krause at embedded.rocks: musl fix]
+Signed-off-by: J?rg Krause <joerg.krause@embedded.rocks>
 ---
  tirpc/rpc/rpcent.h | 5 +++--
  1 file changed, 3 insertions(+), 2 deletions(-)
@@ -22,7 +24,7 @@ index 147f909..4a58180 100644
 -#if !defined(__GLIBC__)
 +/* These are defined in /usr/include/rpc/netdb.h, unless we are using
 +   the C library without RPC support. */
-+#if defined(__UCLIBC__) && !defined(__UCLIBC_HAS_RPC__)
++#if defined(__UCLIBC__) && !defined(__UCLIBC_HAS_RPC__) || !defined(__GLIBC__)
  struct rpcent {
  	char	*r_name;	/* name of server for this rpc program */
  	char	**r_aliases;	/* alias list */
diff --git a/package/libtirpc/0006-Use-local-bsdqueue.h.patch b/package/libtirpc/0006-Use-local-bsdqueue.h.patch
new file mode 100644
index 0000000..0c9aecf
--- /dev/null
+++ b/package/libtirpc/0006-Use-local-bsdqueue.h.patch
@@ -0,0 +1,903 @@
+From 7c337ac4f6fa260e3c25820f780d24329d85e027 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?J=C3=B6rg=20Krause?= <joerg.krause@embedded.rocks>
+Date: Tue, 5 May 2015 17:06:03 +0200
+Subject: [PATCH 12/16] Use local bsdqueue.h
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Not all systems provide a sys/queue.h implementation. For example the the musl
+C library does not and will not have it [1].
+
+sys/queue.h first appeared in 4.4BSD and is used in all 4.4BSD variants. Note
+that glibc' sys/queue.h is a patched version of this 4.4BDS header (adds
+STAILQ_CONCAT and TAILQ_CONCAT).
+
+There exists several implementations of sys/queue.h. Lets use the version from
+the NetBSD project [2] and provide it as a local header file "bsdqueue.h"
+
+[1] http://wiki.musl-libc.org/wiki/FAQ#Q:_why_is_sys.2Fqueue.h_not_included_.3F
+[2] http://cvsweb.netbsd.org/bsdweb.cgi/src/sys/sys/queue.h?rev=1.68
+
+Signed-off-by: J?rg Krause <joerg.krause@embedded.rocks>
+---
+ src/clnt_bcast.c |   2 +-
+ tirpc/bsdqueue.h | 846 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ 2 files changed, 847 insertions(+), 1 deletion(-)
+ create mode 100644 tirpc/bsdqueue.h
+
+diff --git a/src/clnt_bcast.c b/src/clnt_bcast.c
+index 262b2ab..3ed8457 100644
+--- a/src/clnt_bcast.c
++++ b/src/clnt_bcast.c
+@@ -40,7 +40,6 @@
+  */
+ #include <sys/socket.h>
+ #include <sys/types.h>
+-#include <sys/queue.h>
+ 
+ #include <net/if.h>
+ #include <netinet/in.h>
+@@ -64,6 +63,7 @@
+ #include <err.h>
+ #include <string.h>
+ 
++#include "bsdqueue.h"
+ #include "rpc_com.h"
+ 
+ #define	MAXBCAST 20	/* Max no of broadcasting transports */
+diff --git a/tirpc/bsdqueue.h b/tirpc/bsdqueue.h
+new file mode 100644
+index 0000000..99d01a5
+--- /dev/null
++++ b/tirpc/bsdqueue.h
+@@ -0,0 +1,846 @@
++/*	$NetBSD: queue.h,v 1.68 2014/11/19 08:10:01 uebayasi Exp $	*/
++
++/*
++ * Copyright (c) 1991, 1993
++ *	The Regents of the University of California.  All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ *    notice, this list of conditions and the following disclaimer.
++ * 2. Redistributions in binary form must reproduce the above copyright
++ *    notice, this list of conditions and the following disclaimer in the
++ *    documentation and/or other materials provided with the distribution.
++ * 3. Neither the name of the University nor the names of its contributors
++ *    may be used to endorse or promote products derived from this software
++ *    without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ *
++ *	@(#)queue.h	8.5 (Berkeley) 8/20/94
++ */
++
++#ifndef	_SYS_QUEUE_H_
++#define	_SYS_QUEUE_H_
++
++/*
++ * This file defines five types of data structures: singly-linked lists,
++ * lists, simple queues, tail queues, and circular queues.
++ *
++ * A singly-linked list is headed by a single forward pointer. The
++ * elements are singly linked for minimum space and pointer manipulation
++ * overhead at the expense of O(n) removal for arbitrary elements. New
++ * elements can be added to the list after an existing element or at the
++ * head of the list.  Elements being removed from the head of the list
++ * should use the explicit macro for this purpose for optimum
++ * efficiency. A singly-linked list may only be traversed in the forward
++ * direction.  Singly-linked lists are ideal for applications with large
++ * datasets and few or no removals or for implementing a LIFO queue.
++ *
++ * A list is headed by a single forward pointer (or an array of forward
++ * pointers for a hash table header). The elements are doubly linked
++ * so that an arbitrary element can be removed without a need to
++ * traverse the list. New elements can be added to the list before
++ * or after an existing element or at the head of the list. A list
++ * may only be traversed in the forward direction.
++ *
++ * A simple queue is headed by a pair of pointers, one the head of the
++ * list and the other to the tail of the list. The elements are singly
++ * linked to save space, so elements can only be removed from the
++ * head of the list. New elements can be added to the list after
++ * an existing element, at the head of the list, or at the end of the
++ * list. A simple queue may only be traversed in the forward direction.
++ *
++ * A tail queue is headed by a pair of pointers, one to the head of the
++ * list and the other to the tail of the list. The elements are doubly
++ * linked so that an arbitrary element can be removed without a need to
++ * traverse the list. New elements can be added to the list before or
++ * after an existing element, at the head of the list, or at the end of
++ * the list. A tail queue may be traversed in either direction.
++ *
++ * A circle queue is headed by a pair of pointers, one to the head of the
++ * list and the other to the tail of the list. The elements are doubly
++ * linked so that an arbitrary element can be removed without a need to
++ * traverse the list. New elements can be added to the list before or after
++ * an existing element, at the head of the list, or at the end of the list.
++ * A circle queue may be traversed in either direction, but has a more
++ * complex end of list detection.
++ *
++ * For details on the use of these macros, see the queue(3) manual page.
++ */
++
++/*
++ * Include the definition of NULL only on NetBSD because sys/null.h
++ * is not available elsewhere.  This conditional makes the header
++ * portable and it can simply be dropped verbatim into any system.
++ * The caveat is that on other systems some other header
++ * must provide NULL before the macros can be used.
++ */
++#ifdef __NetBSD__
++#include <sys/null.h>
++#endif
++
++#if defined(QUEUEDEBUG)
++# if defined(_KERNEL)
++#  define QUEUEDEBUG_ABORT(...) panic(__VA_ARGS__)
++# else
++#  include <err.h>
++#  define QUEUEDEBUG_ABORT(...) err(1, __VA_ARGS__)
++# endif
++#endif
++
++/*
++ * Singly-linked List definitions.
++ */
++#define	SLIST_HEAD(name, type)						\
++struct name {								\
++	struct type *slh_first;	/* first element */			\
++}
++
++#define	SLIST_HEAD_INITIALIZER(head)					\
++	{ NULL }
++
++#define	SLIST_ENTRY(type)						\
++struct {								\
++	struct type *sle_next;	/* next element */			\
++}
++
++/*
++ * Singly-linked List access methods.
++ */
++#define	SLIST_FIRST(head)	((head)->slh_first)
++#define	SLIST_END(head)		NULL
++#define	SLIST_EMPTY(head)	((head)->slh_first == NULL)
++#define	SLIST_NEXT(elm, field)	((elm)->field.sle_next)
++
++#define	SLIST_FOREACH(var, head, field)					\
++	for((var) = (head)->slh_first;					\
++	    (var) != SLIST_END(head);					\
++	    (var) = (var)->field.sle_next)
++
++#define	SLIST_FOREACH_SAFE(var, head, field, tvar)			\
++	for ((var) = SLIST_FIRST((head));				\
++	    (var) != SLIST_END(head) &&					\
++	    ((tvar) = SLIST_NEXT((var), field), 1);			\
++	    (var) = (tvar))
++
++/*
++ * Singly-linked List functions.
++ */
++#define	SLIST_INIT(head) do {						\
++	(head)->slh_first = SLIST_END(head);				\
++} while (/*CONSTCOND*/0)
++
++#define	SLIST_INSERT_AFTER(slistelm, elm, field) do {			\
++	(elm)->field.sle_next = (slistelm)->field.sle_next;		\
++	(slistelm)->field.sle_next = (elm);				\
++} while (/*CONSTCOND*/0)
++
++#define	SLIST_INSERT_HEAD(head, elm, field) do {			\
++	(elm)->field.sle_next = (head)->slh_first;			\
++	(head)->slh_first = (elm);					\
++} while (/*CONSTCOND*/0)
++
++#define	SLIST_REMOVE_AFTER(slistelm, field) do {			\
++	(slistelm)->field.sle_next =					\
++	    SLIST_NEXT(SLIST_NEXT((slistelm), field), field);		\
++} while (/*CONSTCOND*/0)
++
++#define	SLIST_REMOVE_HEAD(head, field) do {				\
++	(head)->slh_first = (head)->slh_first->field.sle_next;		\
++} while (/*CONSTCOND*/0)
++
++#define	SLIST_REMOVE(head, elm, type, field) do {			\
++	if ((head)->slh_first == (elm)) {				\
++		SLIST_REMOVE_HEAD((head), field);			\
++	}								\
++	else {								\
++		struct type *curelm = (head)->slh_first;		\
++		while(curelm->field.sle_next != (elm))			\
++			curelm = curelm->field.sle_next;		\
++		curelm->field.sle_next =				\
++		    curelm->field.sle_next->field.sle_next;		\
++	}								\
++} while (/*CONSTCOND*/0)
++
++
++/*
++ * List definitions.
++ */
++#define	LIST_HEAD(name, type)						\
++struct name {								\
++	struct type *lh_first;	/* first element */			\
++}
++
++#define	LIST_HEAD_INITIALIZER(head)					\
++	{ NULL }
++
++#define	LIST_ENTRY(type)						\
++struct {								\
++	struct type *le_next;	/* next element */			\
++	struct type **le_prev;	/* address of previous next element */	\
++}
++
++/*
++ * List access methods.
++ */
++#define	LIST_FIRST(head)		((head)->lh_first)
++#define	LIST_END(head)			NULL
++#define	LIST_EMPTY(head)		((head)->lh_first == LIST_END(head))
++#define	LIST_NEXT(elm, field)		((elm)->field.le_next)
++
++#define	LIST_FOREACH(var, head, field)					\
++	for ((var) = ((head)->lh_first);				\
++	    (var) != LIST_END(head);					\
++	    (var) = ((var)->field.le_next))
++
++#define	LIST_FOREACH_SAFE(var, head, field, tvar)			\
++	for ((var) = LIST_FIRST((head));				\
++	    (var) != LIST_END(head) &&					\
++	    ((tvar) = LIST_NEXT((var), field), 1);			\
++	    (var) = (tvar))
++
++#define	LIST_MOVE(head1, head2) do {					\
++	LIST_INIT((head2));						\
++	if (!LIST_EMPTY((head1))) {					\
++		(head2)->lh_first = (head1)->lh_first;			\
++		LIST_INIT((head1));					\
++	}								\
++} while (/*CONSTCOND*/0)
++
++/*
++ * List functions.
++ */
++#if defined(QUEUEDEBUG)
++#define	QUEUEDEBUG_LIST_INSERT_HEAD(head, elm, field)			\
++	if ((head)->lh_first &&						\
++	    (head)->lh_first->field.le_prev != &(head)->lh_first)	\
++		QUEUEDEBUG_ABORT("LIST_INSERT_HEAD %p %s:%d", (head),	\
++		    __FILE__, __LINE__);
++#define	QUEUEDEBUG_LIST_OP(elm, field)					\
++	if ((elm)->field.le_next &&					\
++	    (elm)->field.le_next->field.le_prev !=			\
++	    &(elm)->field.le_next)					\
++		QUEUEDEBUG_ABORT("LIST_* forw %p %s:%d", (elm),		\
++		    __FILE__, __LINE__);				\
++	if (*(elm)->field.le_prev != (elm))				\
++		QUEUEDEBUG_ABORT("LIST_* back %p %s:%d", (elm),		\
++		    __FILE__, __LINE__);
++#define	QUEUEDEBUG_LIST_POSTREMOVE(elm, field)				\
++	(elm)->field.le_next = (void *)1L;				\
++	(elm)->field.le_prev = (void *)1L;
++#else
++#define	QUEUEDEBUG_LIST_INSERT_HEAD(head, elm, field)
++#define	QUEUEDEBUG_LIST_OP(elm, field)
++#define	QUEUEDEBUG_LIST_POSTREMOVE(elm, field)
++#endif
++
++#define	LIST_INIT(head) do {						\
++	(head)->lh_first = LIST_END(head);				\
++} while (/*CONSTCOND*/0)
++
++#define	LIST_INSERT_AFTER(listelm, elm, field) do {			\
++	QUEUEDEBUG_LIST_OP((listelm), field)				\
++	if (((elm)->field.le_next = (listelm)->field.le_next) != 	\
++	    LIST_END(head))						\
++		(listelm)->field.le_next->field.le_prev =		\
++		    &(elm)->field.le_next;				\
++	(listelm)->field.le_next = (elm);				\
++	(elm)->field.le_prev = &(listelm)->field.le_next;		\
++} while (/*CONSTCOND*/0)
++
++#define	LIST_INSERT_BEFORE(listelm, elm, field) do {			\
++	QUEUEDEBUG_LIST_OP((listelm), field)				\
++	(elm)->field.le_prev = (listelm)->field.le_prev;		\
++	(elm)->field.le_next = (listelm);				\
++	*(listelm)->field.le_prev = (elm);				\
++	(listelm)->field.le_prev = &(elm)->field.le_next;		\
++} while (/*CONSTCOND*/0)
++
++#define	LIST_INSERT_HEAD(head, elm, field) do {				\
++	QUEUEDEBUG_LIST_INSERT_HEAD((head), (elm), field)		\
++	if (((elm)->field.le_next = (head)->lh_first) != LIST_END(head))\
++		(head)->lh_first->field.le_prev = &(elm)->field.le_next;\
++	(head)->lh_first = (elm);					\
++	(elm)->field.le_prev = &(head)->lh_first;			\
++} while (/*CONSTCOND*/0)
++
++#define	LIST_REMOVE(elm, field) do {					\
++	QUEUEDEBUG_LIST_OP((elm), field)				\
++	if ((elm)->field.le_next != NULL)				\
++		(elm)->field.le_next->field.le_prev = 			\
++		    (elm)->field.le_prev;				\
++	*(elm)->field.le_prev = (elm)->field.le_next;			\
++	QUEUEDEBUG_LIST_POSTREMOVE((elm), field)			\
++} while (/*CONSTCOND*/0)
++
++#define LIST_REPLACE(elm, elm2, field) do {				\
++	if (((elm2)->field.le_next = (elm)->field.le_next) != NULL)	\
++		(elm2)->field.le_next->field.le_prev =			\
++		    &(elm2)->field.le_next;				\
++	(elm2)->field.le_prev = (elm)->field.le_prev;			\
++	*(elm2)->field.le_prev = (elm2);				\
++	QUEUEDEBUG_LIST_POSTREMOVE((elm), field)			\
++} while (/*CONSTCOND*/0)
++
++/*
++ * Simple queue definitions.
++ */
++#define	SIMPLEQ_HEAD(name, type)					\
++struct name {								\
++	struct type *sqh_first;	/* first element */			\
++	struct type **sqh_last;	/* addr of last next element */		\
++}
++
++#define	SIMPLEQ_HEAD_INITIALIZER(head)					\
++	{ NULL, &(head).sqh_first }
++
++#define	SIMPLEQ_ENTRY(type)						\
++struct {								\
++	struct type *sqe_next;	/* next element */			\
++}
++
++/*
++ * Simple queue access methods.
++ */
++#define	SIMPLEQ_FIRST(head)		((head)->sqh_first)
++#define	SIMPLEQ_END(head)		NULL
++#define	SIMPLEQ_EMPTY(head)		((head)->sqh_first == SIMPLEQ_END(head))
++#define	SIMPLEQ_NEXT(elm, field)	((elm)->field.sqe_next)
++
++#define	SIMPLEQ_FOREACH(var, head, field)				\
++	for ((var) = ((head)->sqh_first);				\
++	    (var) != SIMPLEQ_END(head);					\
++	    (var) = ((var)->field.sqe_next))
++
++#define	SIMPLEQ_FOREACH_SAFE(var, head, field, next)			\
++	for ((var) = ((head)->sqh_first);				\
++	    (var) != SIMPLEQ_END(head) &&				\
++	    ((next = ((var)->field.sqe_next)), 1);			\
++	    (var) = (next))
++
++/*
++ * Simple queue functions.
++ */
++#define	SIMPLEQ_INIT(head) do {						\
++	(head)->sqh_first = NULL;					\
++	(head)->sqh_last = &(head)->sqh_first;				\
++} while (/*CONSTCOND*/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);					\
++} while (/*CONSTCOND*/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;			\
++} while (/*CONSTCOND*/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);				\
++} while (/*CONSTCOND*/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;			\
++} while (/*CONSTCOND*/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;		\
++} while (/*CONSTCOND*/0)
++
++#define	SIMPLEQ_REMOVE(head, elm, type, field) do {			\
++	if ((head)->sqh_first == (elm)) {				\
++		SIMPLEQ_REMOVE_HEAD((head), field);			\
++	} else {							\
++		struct type *curelm = (head)->sqh_first;		\
++		while (curelm->field.sqe_next != (elm))			\
++			curelm = curelm->field.sqe_next;		\
++		if ((curelm->field.sqe_next =				\
++			curelm->field.sqe_next->field.sqe_next) == NULL) \
++			    (head)->sqh_last = &(curelm)->field.sqe_next; \
++	}								\
++} while (/*CONSTCOND*/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));					\
++	}								\
++} while (/*CONSTCOND*/0)
++
++#define	SIMPLEQ_LAST(head, type, field)					\
++	(SIMPLEQ_EMPTY((head)) ?						\
++		NULL :							\
++	        ((struct type *)(void *)				\
++		((char *)((head)->sqh_last) - offsetof(struct type, field))))
++
++/*
++ * Tail queue definitions.
++ */
++#define	_TAILQ_HEAD(name, type, qual)					\
++struct name {								\
++	qual type *tqh_first;		/* first element */		\
++	qual type *qual *tqh_last;	/* addr of last next element */	\
++}
++#define TAILQ_HEAD(name, type)	_TAILQ_HEAD(name, struct type,)
++
++#define	TAILQ_HEAD_INITIALIZER(head)					\
++	{ TAILQ_END(head), &(head).tqh_first }
++
++#define	_TAILQ_ENTRY(type, qual)					\
++struct {								\
++	qual type *tqe_next;		/* next element */		\
++	qual type *qual *tqe_prev;	/* address of previous next element */\
++}
++#define TAILQ_ENTRY(type)	_TAILQ_ENTRY(struct type,)
++
++/*
++ * 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_LAST(head, headname) \
++	(*(((struct headname *)((head)->tqh_last))->tqh_last))
++#define	TAILQ_PREV(elm, headname, field) \
++	(*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
++#define	TAILQ_EMPTY(head)		(TAILQ_FIRST(head) == TAILQ_END(head))
++
++
++#define	TAILQ_FOREACH(var, head, field)					\
++	for ((var) = ((head)->tqh_first);				\
++	    (var) != TAILQ_END(head);					\
++	    (var) = ((var)->field.tqe_next))
++
++#define	TAILQ_FOREACH_SAFE(var, head, field, next)			\
++	for ((var) = ((head)->tqh_first);				\
++	    (var) != TAILQ_END(head) &&					\
++	    ((next) = TAILQ_NEXT(var, field), 1); (var) = (next))
++
++#define	TAILQ_FOREACH_REVERSE(var, head, headname, field)		\
++	for ((var) = (*(((struct headname *)((head)->tqh_last))->tqh_last));\
++	    (var) != TAILQ_END(head);					\
++	    (var) = (*(((struct headname *)((var)->field.tqe_prev))->tqh_last)))
++
++#define	TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, prev)	\
++	for ((var) = TAILQ_LAST((head), headname);			\
++	    (var) != TAILQ_END(head) && 				\
++	    ((prev) = TAILQ_PREV((var), headname, field), 1); (var) = (prev))
++
++/*
++ * Tail queue functions.
++ */
++#if defined(QUEUEDEBUG)
++#define	QUEUEDEBUG_TAILQ_INSERT_HEAD(head, elm, field)			\
++	if ((head)->tqh_first &&					\
++	    (head)->tqh_first->field.tqe_prev != &(head)->tqh_first)	\
++		QUEUEDEBUG_ABORT("TAILQ_INSERT_HEAD %p %s:%d", (head),	\
++		    __FILE__, __LINE__);
++#define	QUEUEDEBUG_TAILQ_INSERT_TAIL(head, elm, field)			\
++	if (*(head)->tqh_last != NULL)					\
++		QUEUEDEBUG_ABORT("TAILQ_INSERT_TAIL %p %s:%d", (head),	\
++		    __FILE__, __LINE__);
++#define	QUEUEDEBUG_TAILQ_OP(elm, field)					\
++	if ((elm)->field.tqe_next &&					\
++	    (elm)->field.tqe_next->field.tqe_prev !=			\
++	    &(elm)->field.tqe_next)					\
++		QUEUEDEBUG_ABORT("TAILQ_* forw %p %s:%d", (elm),	\
++		    __FILE__, __LINE__);				\
++	if (*(elm)->field.tqe_prev != (elm))				\
++		QUEUEDEBUG_ABORT("TAILQ_* back %p %s:%d", (elm),	\
++		    __FILE__, __LINE__);
++#define	QUEUEDEBUG_TAILQ_PREREMOVE(head, elm, field)			\
++	if ((elm)->field.tqe_next == NULL &&				\
++	    (head)->tqh_last != &(elm)->field.tqe_next)			\
++		QUEUEDEBUG_ABORT("TAILQ_PREREMOVE head %p elm %p %s:%d",\
++		    (head), (elm), __FILE__, __LINE__);
++#define	QUEUEDEBUG_TAILQ_POSTREMOVE(elm, field)				\
++	(elm)->field.tqe_next = (void *)1L;				\
++	(elm)->field.tqe_prev = (void *)1L;
++#else
++#define	QUEUEDEBUG_TAILQ_INSERT_HEAD(head, elm, field)
++#define	QUEUEDEBUG_TAILQ_INSERT_TAIL(head, elm, field)
++#define	QUEUEDEBUG_TAILQ_OP(elm, field)
++#define	QUEUEDEBUG_TAILQ_PREREMOVE(head, elm, field)
++#define	QUEUEDEBUG_TAILQ_POSTREMOVE(elm, field)
++#endif
++
++#define	TAILQ_INIT(head) do {						\
++	(head)->tqh_first = TAILQ_END(head);				\
++	(head)->tqh_last = &(head)->tqh_first;				\
++} while (/*CONSTCOND*/0)
++
++#define	TAILQ_INSERT_HEAD(head, elm, field) do {			\
++	QUEUEDEBUG_TAILQ_INSERT_HEAD((head), (elm), field)		\
++	if (((elm)->field.tqe_next = (head)->tqh_first) != TAILQ_END(head))\
++		(head)->tqh_first->field.tqe_prev =			\
++		    &(elm)->field.tqe_next;				\
++	else								\
++		(head)->tqh_last = &(elm)->field.tqe_next;		\
++	(head)->tqh_first = (elm);					\
++	(elm)->field.tqe_prev = &(head)->tqh_first;			\
++} while (/*CONSTCOND*/0)
++
++#define	TAILQ_INSERT_TAIL(head, elm, field) do {			\
++	QUEUEDEBUG_TAILQ_INSERT_TAIL((head), (elm), field)		\
++	(elm)->field.tqe_next = TAILQ_END(head);			\
++	(elm)->field.tqe_prev = (head)->tqh_last;			\
++	*(head)->tqh_last = (elm);					\
++	(head)->tqh_last = &(elm)->field.tqe_next;			\
++} while (/*CONSTCOND*/0)
++
++#define	TAILQ_INSERT_AFTER(head, listelm, elm, field) do {		\
++	QUEUEDEBUG_TAILQ_OP((listelm), field)				\
++	if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != 	\
++	    TAILQ_END(head))						\
++		(elm)->field.tqe_next->field.tqe_prev = 		\
++		    &(elm)->field.tqe_next;				\
++	else								\
++		(head)->tqh_last = &(elm)->field.tqe_next;		\
++	(listelm)->field.tqe_next = (elm);				\
++	(elm)->field.tqe_prev = &(listelm)->field.tqe_next;		\
++} while (/*CONSTCOND*/0)
++
++#define	TAILQ_INSERT_BEFORE(listelm, elm, field) do {			\
++	QUEUEDEBUG_TAILQ_OP((listelm), field)				\
++	(elm)->field.tqe_prev = (listelm)->field.tqe_prev;		\
++	(elm)->field.tqe_next = (listelm);				\
++	*(listelm)->field.tqe_prev = (elm);				\
++	(listelm)->field.tqe_prev = &(elm)->field.tqe_next;		\
++} while (/*CONSTCOND*/0)
++
++#define	TAILQ_REMOVE(head, elm, field) do {				\
++	QUEUEDEBUG_TAILQ_PREREMOVE((head), (elm), field)		\
++	QUEUEDEBUG_TAILQ_OP((elm), field)				\
++	if (((elm)->field.tqe_next) != TAILQ_END(head))			\
++		(elm)->field.tqe_next->field.tqe_prev = 		\
++		    (elm)->field.tqe_prev;				\
++	else								\
++		(head)->tqh_last = (elm)->field.tqe_prev;		\
++	*(elm)->field.tqe_prev = (elm)->field.tqe_next;			\
++	QUEUEDEBUG_TAILQ_POSTREMOVE((elm), field);			\
++} while (/*CONSTCOND*/0)
++
++#define TAILQ_REPLACE(head, elm, elm2, field) do {			\
++        if (((elm2)->field.tqe_next = (elm)->field.tqe_next) != 	\
++	    TAILQ_END(head))   						\
++                (elm2)->field.tqe_next->field.tqe_prev =		\
++                    &(elm2)->field.tqe_next;				\
++        else								\
++                (head)->tqh_last = &(elm2)->field.tqe_next;		\
++        (elm2)->field.tqe_prev = (elm)->field.tqe_prev;			\
++        *(elm2)->field.tqe_prev = (elm2);				\
++	QUEUEDEBUG_TAILQ_POSTREMOVE((elm), field);			\
++} while (/*CONSTCOND*/0)
++
++#define	TAILQ_CONCAT(head1, head2, field) do {				\
++	if (!TAILQ_EMPTY(head2)) {					\
++		*(head1)->tqh_last = (head2)->tqh_first;		\
++		(head2)->tqh_first->field.tqe_prev = (head1)->tqh_last;	\
++		(head1)->tqh_last = (head2)->tqh_last;			\
++		TAILQ_INIT((head2));					\
++	}								\
++} while (/*CONSTCOND*/0)
++
++/*
++ * Singly-linked Tail queue declarations.
++ */
++#define	STAILQ_HEAD(name, type)						\
++struct name {								\
++	struct type *stqh_first;	/* first element */		\
++	struct type **stqh_last;	/* addr of last next element */	\
++}
++
++#define	STAILQ_HEAD_INITIALIZER(head)					\
++	{ NULL, &(head).stqh_first }
++
++#define	STAILQ_ENTRY(type)						\
++struct {								\
++	struct type *stqe_next;	/* next element */			\
++}
++
++/*
++ * Singly-linked Tail queue access methods.
++ */
++#define	STAILQ_FIRST(head)	((head)->stqh_first)
++#define	STAILQ_END(head)	NULL
++#define	STAILQ_NEXT(elm, field)	((elm)->field.stqe_next)
++#define	STAILQ_EMPTY(head)	(STAILQ_FIRST(head) == STAILQ_END(head))
++
++/*
++ * Singly-linked Tail queue functions.
++ */
++#define	STAILQ_INIT(head) do {						\
++	(head)->stqh_first = NULL;					\
++	(head)->stqh_last = &(head)->stqh_first;				\
++} while (/*CONSTCOND*/0)
++
++#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 (/*CONSTCOND*/0)
++
++#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 (/*CONSTCOND*/0)
++
++#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 (/*CONSTCOND*/0)
++
++#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 (/*CONSTCOND*/0)
++
++#define	STAILQ_REMOVE(head, elm, type, field) do {			\
++	if ((head)->stqh_first == (elm)) {				\
++		STAILQ_REMOVE_HEAD((head), field);			\
++	} else {							\
++		struct type *curelm = (head)->stqh_first;		\
++		while (curelm->field.stqe_next != (elm))			\
++			curelm = curelm->field.stqe_next;		\
++		if ((curelm->field.stqe_next =				\
++			curelm->field.stqe_next->field.stqe_next) == NULL) \
++			    (head)->stqh_last = &(curelm)->field.stqe_next; \
++	}								\
++} while (/*CONSTCOND*/0)
++
++#define	STAILQ_FOREACH(var, head, field)				\
++	for ((var) = ((head)->stqh_first);				\
++		(var);							\
++		(var) = ((var)->field.stqe_next))
++
++#define	STAILQ_FOREACH_SAFE(var, head, field, tvar)			\
++	for ((var) = STAILQ_FIRST((head));				\
++	    (var) && ((tvar) = STAILQ_NEXT((var), field), 1);		\
++	    (var) = (tvar))
++
++#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 (/*CONSTCOND*/0)
++
++#define	STAILQ_LAST(head, type, field)					\
++	(STAILQ_EMPTY((head)) ?						\
++		NULL :							\
++	        ((struct type *)(void *)				\
++		((char *)((head)->stqh_last) - offsetof(struct type, field))))
++
++
++#ifndef _KERNEL
++/*
++ * Circular queue definitions. Do not use. We still keep the macros
++ * for compatibility but because of pointer aliasing issues their use
++ * is discouraged!
++ */
++
++/*
++ * __launder_type():  We use this ugly hack to work around the the compiler
++ * noticing that two types may not alias each other and elide tests in code.
++ * We hit this in the CIRCLEQ macros when comparing 'struct name *' and
++ * 'struct type *' (see CIRCLEQ_HEAD()).  Modern compilers (such as GCC
++ * 4.8) declare these comparisons as always false, causing the code to
++ * not run as designed.
++ *
++ * This hack is only to be used for comparisons and thus can be fully const.
++ * Do not use for assignment.
++ *
++ * If we ever choose to change the ABI of the CIRCLEQ macros, we could fix
++ * this by changing the head/tail sentinal values, but see the note above
++ * this one.
++ */
++static __inline const void * __launder_type(const void *);
++static __inline const void *
++__launder_type(const void *__x)
++{
++	__asm __volatile("" : "+r" (__x));
++	return __x;
++}
++
++#if defined(QUEUEDEBUG)
++#define QUEUEDEBUG_CIRCLEQ_HEAD(head, field)				\
++	if ((head)->cqh_first != CIRCLEQ_ENDC(head) &&			\
++	    (head)->cqh_first->field.cqe_prev != CIRCLEQ_ENDC(head))	\
++		QUEUEDEBUG_ABORT("CIRCLEQ head forw %p %s:%d", (head),	\
++		      __FILE__, __LINE__);				\
++	if ((head)->cqh_last != CIRCLEQ_ENDC(head) &&			\
++	    (head)->cqh_last->field.cqe_next != CIRCLEQ_ENDC(head))	\
++		QUEUEDEBUG_ABORT("CIRCLEQ head back %p %s:%d", (head),	\
++		      __FILE__, __LINE__);
++#define QUEUEDEBUG_CIRCLEQ_ELM(head, elm, field)			\
++	if ((elm)->field.cqe_next == CIRCLEQ_ENDC(head)) {		\
++		if ((head)->cqh_last != (elm))				\
++			QUEUEDEBUG_ABORT("CIRCLEQ elm last %p %s:%d",	\
++			    (elm), __FILE__, __LINE__);			\
++	} else {							\
++		if ((elm)->field.cqe_next->field.cqe_prev != (elm))	\
++			QUEUEDEBUG_ABORT("CIRCLEQ elm forw %p %s:%d",	\
++			    (elm), __FILE__, __LINE__);			\
++	}								\
++	if ((elm)->field.cqe_prev == CIRCLEQ_ENDC(head)) {		\
++		if ((head)->cqh_first != (elm))				\
++			QUEUEDEBUG_ABORT("CIRCLEQ elm first %p %s:%d",	\
++			    (elm), __FILE__, __LINE__);			\
++	} else {							\
++		if ((elm)->field.cqe_prev->field.cqe_next != (elm))	\
++			QUEUEDEBUG_ABORT("CIRCLEQ elm prev %p %s:%d",	\
++			    (elm), __FILE__, __LINE__);			\
++	}
++#define QUEUEDEBUG_CIRCLEQ_POSTREMOVE(elm, field)			\
++	(elm)->field.cqe_next = (void *)1L;				\
++	(elm)->field.cqe_prev = (void *)1L;
++#else
++#define QUEUEDEBUG_CIRCLEQ_HEAD(head, field)
++#define QUEUEDEBUG_CIRCLEQ_ELM(head, elm, field)
++#define QUEUEDEBUG_CIRCLEQ_POSTREMOVE(elm, field)
++#endif
++
++#define	CIRCLEQ_HEAD(name, type)					\
++struct name {								\
++	struct type *cqh_first;		/* first element */		\
++	struct type *cqh_last;		/* last element */		\
++}
++
++#define	CIRCLEQ_HEAD_INITIALIZER(head)					\
++	{ CIRCLEQ_END(&head), CIRCLEQ_END(&head) }
++
++#define	CIRCLEQ_ENTRY(type)						\
++struct {								\
++	struct type *cqe_next;		/* next element */		\
++	struct type *cqe_prev;		/* previous element */		\
++}
++
++/*
++ * Circular queue functions.
++ */
++#define	CIRCLEQ_INIT(head) do {						\
++	(head)->cqh_first = CIRCLEQ_END(head);				\
++	(head)->cqh_last = CIRCLEQ_END(head);				\
++} while (/*CONSTCOND*/0)
++
++#define	CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do {		\
++	QUEUEDEBUG_CIRCLEQ_HEAD((head), field)				\
++	QUEUEDEBUG_CIRCLEQ_ELM((head), (listelm), field)		\
++	(elm)->field.cqe_next = (listelm)->field.cqe_next;		\
++	(elm)->field.cqe_prev = (listelm);				\
++	if ((listelm)->field.cqe_next == CIRCLEQ_ENDC(head))		\
++		(head)->cqh_last = (elm);				\
++	else								\
++		(listelm)->field.cqe_next->field.cqe_prev = (elm);	\
++	(listelm)->field.cqe_next = (elm);				\
++} while (/*CONSTCOND*/0)
++
++#define	CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do {		\
++	QUEUEDEBUG_CIRCLEQ_HEAD((head), field)				\
++	QUEUEDEBUG_CIRCLEQ_ELM((head), (listelm), field)		\
++	(elm)->field.cqe_next = (listelm);				\
++	(elm)->field.cqe_prev = (listelm)->field.cqe_prev;		\
++	if ((listelm)->field.cqe_prev == CIRCLEQ_ENDC(head))		\
++		(head)->cqh_first = (elm);				\
++	else								\
++		(listelm)->field.cqe_prev->field.cqe_next = (elm);	\
++	(listelm)->field.cqe_prev = (elm);				\
++} while (/*CONSTCOND*/0)
++
++#define	CIRCLEQ_INSERT_HEAD(head, elm, field) do {			\
++	QUEUEDEBUG_CIRCLEQ_HEAD((head), field)				\
++	(elm)->field.cqe_next = (head)->cqh_first;			\
++	(elm)->field.cqe_prev = CIRCLEQ_END(head);			\
++	if ((head)->cqh_last == CIRCLEQ_ENDC(head))			\
++		(head)->cqh_last = (elm);				\
++	else								\
++		(head)->cqh_first->field.cqe_prev = (elm);		\
++	(head)->cqh_first = (elm);					\
++} while (/*CONSTCOND*/0)
++
++#define	CIRCLEQ_INSERT_TAIL(head, elm, field) do {			\
++	QUEUEDEBUG_CIRCLEQ_HEAD((head), field)				\
++	(elm)->field.cqe_next = CIRCLEQ_END(head);			\
++	(elm)->field.cqe_prev = (head)->cqh_last;			\
++	if ((head)->cqh_first == CIRCLEQ_ENDC(head))			\
++		(head)->cqh_first = (elm);				\
++	else								\
++		(head)->cqh_last->field.cqe_next = (elm);		\
++	(head)->cqh_last = (elm);					\
++} while (/*CONSTCOND*/0)
++
++#define	CIRCLEQ_REMOVE(head, elm, field) do {				\
++	QUEUEDEBUG_CIRCLEQ_HEAD((head), field)				\
++	QUEUEDEBUG_CIRCLEQ_ELM((head), (elm), field)			\
++	if ((elm)->field.cqe_next == CIRCLEQ_ENDC(head))		\
++		(head)->cqh_last = (elm)->field.cqe_prev;		\
++	else								\
++		(elm)->field.cqe_next->field.cqe_prev =			\
++		    (elm)->field.cqe_prev;				\
++	if ((elm)->field.cqe_prev == CIRCLEQ_ENDC(head))		\
++		(head)->cqh_first = (elm)->field.cqe_next;		\
++	else								\
++		(elm)->field.cqe_prev->field.cqe_next =			\
++		    (elm)->field.cqe_next;				\
++	QUEUEDEBUG_CIRCLEQ_POSTREMOVE((elm), field)			\
++} while (/*CONSTCOND*/0)
++
++#define	CIRCLEQ_FOREACH(var, head, field)				\
++	for ((var) = ((head)->cqh_first);				\
++		(var) != CIRCLEQ_ENDC(head);				\
++		(var) = ((var)->field.cqe_next))
++
++#define	CIRCLEQ_FOREACH_REVERSE(var, head, field)			\
++	for ((var) = ((head)->cqh_last);				\
++		(var) != CIRCLEQ_ENDC(head);				\
++		(var) = ((var)->field.cqe_prev))
++
++/*
++ * Circular queue access methods.
++ */
++#define	CIRCLEQ_FIRST(head)		((head)->cqh_first)
++#define	CIRCLEQ_LAST(head)		((head)->cqh_last)
++/* For comparisons */
++#define	CIRCLEQ_ENDC(head)		(__launder_type(head))
++/* For assignments */
++#define	CIRCLEQ_END(head)		((void *)(head))
++#define	CIRCLEQ_NEXT(elm, field)	((elm)->field.cqe_next)
++#define	CIRCLEQ_PREV(elm, field)	((elm)->field.cqe_prev)
++#define	CIRCLEQ_EMPTY(head)						\
++    (CIRCLEQ_FIRST(head) == CIRCLEQ_ENDC(head))
++
++#define CIRCLEQ_LOOP_NEXT(head, elm, field)				\
++	(((elm)->field.cqe_next == CIRCLEQ_ENDC(head))			\
++	    ? ((head)->cqh_first)					\
++	    : (elm->field.cqe_next))
++#define CIRCLEQ_LOOP_PREV(head, elm, field)				\
++	(((elm)->field.cqe_prev == CIRCLEQ_ENDC(head))			\
++	    ? ((head)->cqh_last)					\
++	    : (elm->field.cqe_prev))
++#endif /* !_KERNEL */
++
++#endif	/* !_SYS_QUEUE_H_ */
+-- 
+2.3.7
+
-- 
2.4.6

[Buildroot] [PATCH v2 3/3] package/libtirpc: Do not build unsupported API files

[Jörg Krause]

Version 0.3.2 re-enables some APIs for backward compatibility with
glibc's SunRPC:
  - key_prot
  - netname
  - rtime

Unfortunalty, this breaks building libtirpc with uClibc and musl:
  getpublickey.c:41:28: fatal error: rpcsvc/yp_prot.h: No such file or directory

We disable those API files as at least yp_prot.h is also NIS related to support
building libtirpc with these two libc's.

Signed-off-by: J?rg Krause <joerg.krause@embedded.rocks>
---
Changes v1 -> v2:
  - fixup 0007-Do-not-build-unsupported-API-files.patch into existing
    0001-Disable-parts-of-TIRPC-requiring-NIS-support.patch as yp_prot.h
    is NIS related (suggested by Thomas Petazzoni)
---
 ...Disable-parts-of-TIRPC-requiring-NIS-support.patch | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/package/libtirpc/0001-Disable-parts-of-TIRPC-requiring-NIS-support.patch b/package/libtirpc/0001-Disable-parts-of-TIRPC-requiring-NIS-support.patch
index 71d4420..ea30fb2 100644
--- a/package/libtirpc/0001-Disable-parts-of-TIRPC-requiring-NIS-support.patch
+++ b/package/libtirpc/0001-Disable-parts-of-TIRPC-requiring-NIS-support.patch
@@ -1,4 +1,4 @@
-From 583ad557faf86c5532e16dafff19bfdcc349752d Mon Sep 17 00:00:00 2001
+From cb2f393afdb444bf97a7327991f8f5a2c2f64082 Mon Sep 17 00:00:00 2001
 From: =?UTF-8?q?J=C3=B6rg=20Krause?= <joerg.krause@embedded.rocks>
 Date: Mon, 20 Jul 2015 20:30:11 +0200
 Subject: [PATCH 1/1] Disable parts of TIRPC requiring NIS support
@@ -12,11 +12,11 @@ Signed-off-by: "Yann E. MORIN" <yann.morin.1998@free.fr>
 [joerg.krause at embedded.rocks: update for 0.3.2]
 Signed-off-by: J?rg Krause <joerg.krause@embedded.rocks>
 ---
- src/Makefile.am | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
+ src/Makefile.am | 6 +++---
+ 1 file changed, 3 insertions(+), 3 deletions(-)
 
 diff --git a/src/Makefile.am b/src/Makefile.am
-index 6cc567a..cf8a8ca 100644
+index 6cc567a..2b26a29 100644
 --- a/src/Makefile.am
 +++ b/src/Makefile.am
 @@ -51,7 +51,7 @@ libtirpc_la_SOURCES = auth_none.c auth_unix.c authunix_prot.c bindresvport.c cln
@@ -28,6 +28,17 @@ index 6cc567a..cf8a8ca 100644
  
  ## XDR
  libtirpc_la_SOURCES += xdr.c xdr_rec.c xdr_array.c xdr_float.c xdr_mem.c xdr_reference.c xdr_stdio.c
+@@ -68,8 +68,8 @@ if GSS
+     libtirpc_la_CFLAGS = -DHAVE_RPCSEC_GSS $(GSSAPI_CFLAGS)
+ endif
+ 
+-libtirpc_la_SOURCES += key_call.c key_prot_xdr.c getpublickey.c
+-libtirpc_la_SOURCES += netname.c netnamer.c rtime.c
++#libtirpc_la_SOURCES += key_call.c key_prot_xdr.c getpublickey.c
++#libtirpc_la_SOURCES += netname.c netnamer.c rtime.c
+ 
+ CLEANFILES	       = cscope.* *~
+ DISTCLEANFILES	       = Makefile.in
 -- 
 2.4.6
 
-- 
2.4.6

[Buildroot] [PATCH v2 1/3] package/libtirpc: bump to version 0.3.2

[Thomas Petazzoni]

Dear J?rg Krause,

On Thu, 23 Jul 2015 08:38:24 +0200, J?rg Krause wrote:
> Bump version, update hash and update patch.
> 
> Signed-off-by: J?rg Krause <joerg.krause@embedded.rocks>
> ---
> Changes v1 -> v2:
>   - None
> ---
>  ...sable-parts-of-TIRPC-requiring-NIS-support.patch | 21 +++++++++++++--------
>  package/libtirpc/libtirpc.hash                      |  4 ++--
>  package/libtirpc/libtirpc.mk                        |  2 +-
>  3 files changed, 16 insertions(+), 11 deletions(-)

All three applied. In the last patch, I'm not too happy with the
removed lines being commented instead of just being removed, but OK.

Our stack of patches on libtirpc is still huge though :-/

Thanks,

Thomas
-- 
Thomas Petazzoni, CTO, Free Electrons
Embedded Linux, Kernel and Android engineering
http://free-electrons.com

[Buildroot] [PATCH v2 1/3] package/libtirpc: bump to version 0.3.2

[Thomas Petazzoni]

Dear J?rg Krause,

On Thu, 23 Jul 2015 08:38:24 +0200, J?rg Krause wrote:
> Bump version, update hash and update patch.
> 
> Signed-off-by: J?rg Krause <joerg.krause@embedded.rocks>

This patch series is causing a number of build failures, such as:

  http://autobuild.buildroot.org/results/33f/33f1849c6d1441d8565835872281e33a980aba6f/build-end.log

/home/peko/autobuild/instance-2/output/host/usr/bfin-buildroot-linux-uclibc/sysroot/usr/lib/libtirpc.so: undefined reference to `_authdes_seccreate'

Can you have a look?

Thomas
-- 
Thomas Petazzoni, CTO, Free Electrons
Embedded Linux, Kernel and Android engineering
http://free-electrons.com

[Buildroot] [PATCH v2 1/3] package/libtirpc: bump to version 0.3.2

[Jörg Krause]

On Fr, 2015-07-24 at 09:17 +0200, Thomas Petazzoni wrote:
> Dear J?rg Krause,
> 
> On Thu, 23 Jul 2015 08:38:24 +0200, J?rg Krause wrote:
> > Bump version, update hash and update patch.
> > 
> > Signed-off-by: J?rg Krause <joerg.krause@embedded.rocks>
> 
> This patch series is causing a number of build failures, such as:
> 
>   http://autobuild.buildroot.org/results/33f/33f1849c6d1441d856583587
> 2281e33a980aba6f/build-end.log
> 
> /home/peko/autobuild/instance-2/output/host/usr/bfin-buildroot-linux
> -uclibc/sysroot/usr/lib/libtirpc.so: undefined reference to 
> `_authdes_seccreate'
> 
> Can you have a look?

Sure. The problem is that with version 0.3.0 it was possible to disable
auth DES optionally [1]. This was reverted in version 0.3.2 for
backward compatibility with older glibc's. With commit
060b63865c58c716dc94c5987ab19b90899aa340 authdes_create() is defined by
default in rpc_soc.c, which in return calls the undefined
authdes_seccreate().

My suggestion would be to remove authdes_create() in rpc_soc.c.

Best regards
J?rg Krause


[1] Add configure option to disable DES authentication
http://www.spinics.net/lists/linux-nfs/msg48357.html

[Buildroot] [PATCH v2 1/3] package/libtirpc: bump to version 0.3.2

[Thomas Petazzoni]

Dear J?rg Krause,

On Fri, 24 Jul 2015 11:21:35 +0200, J?rg Krause wrote:

> Sure. The problem is that with version 0.3.0 it was possible to disable
> auth DES optionally [1]. This was reverted in version 0.3.2 for
> backward compatibility with older glibc's. With commit
> 060b63865c58c716dc94c5987ab19b90899aa340 authdes_create() is defined by
> default in rpc_soc.c, which in return calls the undefined
> authdes_seccreate().
> 
> My suggestion would be to remove authdes_create() in rpc_soc.c.

Where would authdes_seccreate() be normally implemented? For sure the
libtirpc developers didn't simply call an undefined function, no?

Thanks!

Thomas
-- 
Thomas Petazzoni, CTO, Free Electrons
Embedded Linux, Kernel and Android engineering
http://free-electrons.com

[Buildroot] [PATCH v2 1/3] package/libtirpc: bump to version 0.3.2

[Jörg Krause]

On Fr, 2015-07-24 at 11:31 +0200, Thomas Petazzoni wrote:
> Dear J?rg Krause,
> 
> On Fri, 24 Jul 2015 11:21:35 +0200, J?rg Krause wrote:
> 
> > Sure. The problem is that with version 0.3.0 it was possible to 
> > disable
> > auth DES optionally [1]. This was reverted in version 0.3.2 for
> > backward compatibility with older glibc's. With commit
> > 060b63865c58c716dc94c5987ab19b90899aa340 authdes_create() is 
> > defined by
> > default in rpc_soc.c, which in return calls the undefined
> > authdes_seccreate().
> > 
> > My suggestion would be to remove authdes_create() in rpc_soc.c.
> 
> Where would authdes_seccreate() be normally implemented? For sure the
> libtirpc developers didn't simply call an undefined function, no?

It's implemented in auth_des.c which we removed from building with
patch #1.

gentoo has a patch removing authdes_create(), too [1].

[1]
https://gitweb.gentoo.org/proj/hardened-dev.git/diff/net
-libs/libtirpc/files/0007-no-des.patch?id=74727efe

Best regards
J?rg Krause

[Buildroot] [PATCH v2 1/3] package/libtirpc: bump to version 0.3.2

[Thomas Petazzoni]

Dear J?rg Krause,

On Fri, 24 Jul 2015 13:26:26 +0200, J?rg Krause wrote:

> It's implemented in auth_des.c which we removed from building with
> patch #1.
> 
> gentoo has a patch removing authdes_create(), too [1].
> 
> [1]
> https://gitweb.gentoo.org/proj/hardened-dev.git/diff/net
> -libs/libtirpc/files/0007-no-des.patch?id=74727efe

Ok, so I guess you will submit a patch to fix this issue?

Thakns!

Thomas
-- 
Thomas Petazzoni, CTO, Free Electrons
Embedded Linux, Kernel and Android engineering
http://free-electrons.com

[Buildroot] [PATCH v2 1/3] package/libtirpc: bump to version 0.3.2

[Jörg Krause]

On Fr, 2015-07-24 at 13:43 +0200, Thomas Petazzoni wrote:
> Dear J?rg Krause,
> 
> On Fri, 24 Jul 2015 13:26:26 +0200, J?rg Krause wrote:
> 
> > It's implemented in auth_des.c which we removed from building with
> > patch #1.
> > 
> > gentoo has a patch removing authdes_create(), too [1].
> > 
> > [1]
> > https://gitweb.gentoo.org/proj/hardened-dev.git/diff/net
> > -libs/libtirpc/files/0007-no-des.patch?id=74727efe
> 
> Ok, so I guess you will submit a patch to fix this issue?

Right, I'll prepare a patch which disables auth DES.

Best regards
J?rg Krause