[Glibc-bsd-commits] r2375 - trunk/glibc-ports/patches
aurel32 at alioth.debian.org
aurel32 at alioth.debian.org
Fri Feb 27 15:02:49 UTC 2009
Author: aurel32
Date: 2009-02-27 15:02:48 +0000 (Fri, 27 Feb 2009)
New Revision: 2375
Added:
trunk/glibc-ports/patches/linuxthreads29.patch
Removed:
trunk/glibc-ports/patches/linuxthreads26.patch
Modified:
trunk/glibc-ports/patches/ftw.patch
trunk/glibc-ports/patches/memusage_no_mremap.patch
trunk/glibc-ports/patches/pthread_at_fork.patch
trunk/glibc-ports/patches/readdir_r.patch
trunk/glibc-ports/patches/scripts.patch
trunk/glibc-ports/patches/sys_queue_h.patch
trunk/glibc-ports/patches/undef-glibc.patch
Log:
Update glibc patches from the glibc SVN
Modified: trunk/glibc-ports/patches/ftw.patch
===================================================================
--- trunk/glibc-ports/patches/ftw.patch 2009-02-22 03:13:34 UTC (rev 2374)
+++ trunk/glibc-ports/patches/ftw.patch 2009-02-27 15:02:48 UTC (rev 2375)
@@ -1,12 +1,18 @@
disable usage of unimplemented *at functions
-revert to previous behaviour, inspired by
+revert to previous behaviour, inspired by
http://sourceware.org/ml/glibc-cvs/2006-q1/msg00636.html
http://sources.redhat.com/cgi-bin/cvsweb.cgi/libc/io/ftw.c.diff?cvsroot=glibc&r1=1.50&r2=1.51
+ http://sourceware.org/cgi-bin/cvsweb.cgi/libc/posix/glob.c.diff?cvsroot=glibc&r1=1.77&r2=1.78
---- io/ftw.c~ 2006-06-26 19:35:23.000000000 +0200
-+++ io/ftw.c 2006-06-26 19:35:23.000000000 +0200
+---
+ io/ftw.c | 6 ++++++
+ posix/glob.c | 31 +++----------------------------
+ 2 files changed, 9 insertions(+), 28 deletions(-)
+
+--- a/io/ftw.c
++++ b/io/ftw.c
@@ -338,6 +338,7 @@
{
assert (data->dirstreams[data->actdir] == NULL);
@@ -21,9 +27,9 @@
else
+#endif
{
- const char *name = ((data->flags & FTW_CHDIR)
- ? data->dirbuf + data->ftw.base: data->dirbuf);
-@@ -401,10 +403,12 @@
+ const char *name;
+
+@@ -410,10 +412,12 @@
*((char *) __mempcpy (data->dirbuf + data->ftw.base, name, namlen)) = '\0';
int statres;
@@ -36,7 +42,7 @@
{
if ((data->flags & FTW_CHDIR) == 0)
name = data->dirbuf;
-@@ -424,10 +428,12 @@
+@@ -433,10 +437,12 @@
flag = FTW_SLN;
else
{
@@ -49,3 +55,70 @@
statres = LXSTAT (_STAT_VER, name, &st);
if (statres == 0 && S_ISLNK (st.st_mode))
flag = FTW_SLN;
+--- a/posix/glob.c
++++ b/posix/glob.c
+@@ -1222,42 +1222,21 @@
+ allocated with alloca to be recycled. */
+ #if !defined _LIBC || !defined GLOB_ONLY_P
+ static int
+-__attribute_noinline__
+-link_exists2_p (const char *dir, size_t dirlen, const char *fname,
+- glob_t *pglob
+-# ifndef _LIBC
+- , int flags
+-# endif
+- )
++link_exists_p (const char *dir, size_t dirlen, const char *fname,
++ glob_t *pglob, int flags)
+ {
+ size_t fnamelen = strlen (fname);
+ char *fullname = (char *) __alloca (dirlen + 1 + fnamelen + 1);
+ struct stat st;
+-# ifndef _LIBC
+ struct_stat64 st64;
+-# endif
+
+ mempcpy (mempcpy (mempcpy (fullname, dir, dirlen), "/", 1),
+ fname, fnamelen + 1);
+
+-# ifdef _LIBC
+- return (*pglob->gl_stat) (fullname, &st) == 0;
+-# else
+ return ((__builtin_expect (flags & GLOB_ALTDIRFUNC, 0)
+ ? (*pglob->gl_stat) (fullname, &st)
+ : __stat64 (fullname, &st64)) == 0);
+-# endif
+ }
+-# ifdef _LIBC
+-# define link_exists_p(dfd, dirname, dirnamelen, fname, pglob, flags) \
+- (__builtin_expect (flags & GLOB_ALTDIRFUNC, 0) \
+- ? link_exists2_p (dirname, dirnamelen, fname, pglob) \
+- : ({ struct stat64 st64; \
+- __fxstatat64 (_STAT_VER, dfd, fname, &st64, 0) == 0; }))
+-# else
+-# define link_exists_p(dfd, dirname, dirnamelen, fname, pglob, flags) \
+- link_exists2_p (dirname, dirnamelen, fname, pglob, flags)
+-# endif
+ #endif
+
+
+@@ -1332,10 +1311,6 @@
+ }
+ else
+ {
+-#ifdef _LIBC
+- int dfd = (__builtin_expect (flags & GLOB_ALTDIRFUNC, 0)
+- ? -1 : dirfd ((DIR *) stream));
+-#endif
+ int fnm_flags = ((!(flags & GLOB_PERIOD) ? FNM_PERIOD : 0)
+ | ((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0)
+ #if defined _AMIGA || defined VMS
+@@ -1394,7 +1369,7 @@
+ /* If the file we found is a symlink we have to
+ make sure the target file exists. */
+ if (!DIRENT_MIGHT_BE_SYMLINK (d)
+- || link_exists_p (dfd, directory, dirlen, name, pglob,
++ || link_exists_p (directory, dirlen, name, pglob,
+ flags))
+ {
+ if (cur == names->count)
Deleted: trunk/glibc-ports/patches/linuxthreads26.patch
===================================================================
--- trunk/glibc-ports/patches/linuxthreads26.patch 2009-02-22 03:13:34 UTC (rev 2374)
+++ trunk/glibc-ports/patches/linuxthreads26.patch 2009-02-27 15:02:48 UTC (rev 2375)
@@ -1,18 +0,0 @@
-
- linuxthreads still uses these defines
- apply only for glibc 2.6 and above
-
---- config.make.in 2007-05-26 01:36:34.000000000 +0200
-+++ config.make.in 2007-05-26 01:36:34.000000000 +0200
-@@ -38,6 +38,11 @@
- all-warnings = @all_warnings@
-
- elf = @elf@
-+have-protected = yes
-+have-z-nodelete = yes
-+have-z-nodlopen = yes
-+have-z-initfirst = yes
-+have-z-relro = yes
- have-z-combreloc = @libc_cv_z_combreloc@
- have-z-execstack = @libc_cv_z_execstack@
- have-initfini = @libc_cv_have_initfini@
Added: trunk/glibc-ports/patches/linuxthreads29.patch
===================================================================
--- trunk/glibc-ports/patches/linuxthreads29.patch (rev 0)
+++ trunk/glibc-ports/patches/linuxthreads29.patch 2009-02-27 15:02:48 UTC (rev 2375)
@@ -0,0 +1,68 @@
+
+some of these hacks should be solved properly by upstream ...
+
+--- glibc-2.9.orig/nscd/connections.c
++++ glibc-2.9/nscd/connections.c
+@@ -873,6 +873,7 @@
+ #endif
+ }
+
++#if defined(SOCK_CLOEXEC) && defined(SOCK_NONBLOCK)
+ /* Create the socket. */
+ #ifndef __ASSUME_SOCK_CLOEXEC
+ sock = -1;
+@@ -885,6 +886,7 @@
+ have_sock_cloexec = sock != -1 || errno != EINVAL ? 1 : -1;
+ #endif
+ }
++#endif
+ #ifndef __ASSUME_SOCK_CLOEXEC
+ if (have_sock_cloexec < 0)
+ sock = socket (AF_UNIX, SOCK_STREAM, 0);
+--- glibc-2.9.orig/sysdeps/i386/tlsdesc.sym
++++ glibc-2.9/sysdeps/i386/tlsdesc.sym
+@@ -8,7 +8,11 @@
+
+ -- Abuse tls.h macros to derive offsets relative to the thread register.
+
++#if 0
+ DTV_OFFSET offsetof(struct pthread, header.dtv)
++#else
++DTV_OFFSET offsetof(struct _pthread_descr_struct, p_header.data.dtvp)
++#endif
+
+ TLSDESC_ARG offsetof(struct tlsdesc, arg)
+
+--- glibc-2.9.orig/sysdeps/x86_64/tlsdesc.sym
++++ glibc-2.9/sysdeps/x86_64/tlsdesc.sym
+@@ -5,10 +5,13 @@
+ #include <dl-tlsdesc.h>
+
+ --
++#if 0
++ DTV_OFFSET offsetof(struct pthread, header.dtv) */
++#endif
+
+ -- Abuse tls.h macros to derive offsets relative to the thread register.
+
+-DTV_OFFSET offsetof(struct pthread, header.dtv)
++DTV_OFFSET offsetof(struct _pthread_descr_struct, p_header.data.dtvp)
+
+ TLSDESC_ARG offsetof(struct tlsdesc, arg)
+
+--- glibc-2.9.orig/linuxthreads/sysdeps/pthread/malloc-machine.h
++++ glibc-2.9/linuxthreads/sysdeps/pthread/malloc-machine.h
+@@ -57,10 +57,10 @@
+ #include <bits/libc-tsd.h>
+
+ typedef int tsd_key_t[1]; /* no key data structure, libc magic does it */
+-__libc_tsd_define (static, MALLOC) /* declaration/common definition */
++__libc_tsd_define (static, void *, MALLOC) /* declaration/common definition */
+ #define tsd_key_create(key, destr) ((void) (key))
+-#define tsd_setspecific(key, data) __libc_tsd_set (MALLOC, (data))
+-#define tsd_getspecific(key, vptr) ((vptr) = __libc_tsd_get (MALLOC))
++#define tsd_setspecific(key, data) __libc_tsd_set (void *, MALLOC, (data))
++#define tsd_getspecific(key, vptr) ((vptr) = __libc_tsd_get (void *, MALLOC))
+
+ #include <sysdeps/generic/malloc-machine.h>
+
Modified: trunk/glibc-ports/patches/memusage_no_mremap.patch
===================================================================
--- trunk/glibc-ports/patches/memusage_no_mremap.patch 2009-02-22 03:13:34 UTC (rev 2374)
+++ trunk/glibc-ports/patches/memusage_no_mremap.patch 2009-02-27 15:02:48 UTC (rev 2375)
@@ -1,6 +1,10 @@
---- malloc/memusage.c~ 2006-06-12 15:45:13.000000000 +0200
-+++ malloc/memusage.c 2006-06-12 15:45:13.000000000 +0200
-@@ -650,6 +650,8 @@
+---
+ malloc/memusage.c | 3 +++
+ 1 file changed, 3 insertions(+)
+
+--- a/malloc/memusage.c
++++ b/malloc/memusage.c
+@@ -665,6 +665,8 @@
return result;
}
@@ -9,7 +13,7 @@
/* `mmap' replacement. We do not have to keep track of the sizesince
`munmap' will get it as a parameter. */
-@@ -715,6 +717,7 @@
+@@ -730,6 +732,7 @@
/* Return the pointer to the user buffer. */
return result;
}
Modified: trunk/glibc-ports/patches/pthread_at_fork.patch
===================================================================
--- trunk/glibc-ports/patches/pthread_at_fork.patch 2009-02-22 03:13:34 UTC (rev 2374)
+++ trunk/glibc-ports/patches/pthread_at_fork.patch 2009-02-27 15:02:48 UTC (rev 2375)
@@ -1,5 +1,9 @@
---- linuxthreads/old_pthread_atfork.c~ 2005-12-22 13:26:01.000000000 +0000
-+++ linuxthreads/old_pthread_atfork.c 2005-12-22 13:26:01.000000000 +0000
+---
+ linuxthreads/old_pthread_atfork.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+--- a/linuxthreads/old_pthread_atfork.c
++++ b/linuxthreads/old_pthread_atfork.c
@@ -19,7 +19,7 @@
#include <shlib-compat.h>
Modified: trunk/glibc-ports/patches/readdir_r.patch
===================================================================
--- trunk/glibc-ports/patches/readdir_r.patch 2009-02-22 03:13:34 UTC (rev 2374)
+++ trunk/glibc-ports/patches/readdir_r.patch 2009-02-27 15:02:48 UTC (rev 2375)
@@ -1,5 +1,9 @@
---- sysdeps/unix/readdir_r.c.orig 2002-08-28 07:52:06.000000000 +0200
-+++ sysdeps/unix/readdir_r.c 2003-07-03 16:43:05.000000000 +0200
+---
+ sysdeps/unix/readdir_r.c | 30 +++++++++++++++++++++++++++++-
+ 1 file changed, 29 insertions(+), 1 deletion(-)
+
+--- a/sysdeps/unix/readdir_r.c
++++ b/sysdeps/unix/readdir_r.c
@@ -113,7 +113,35 @@
while (dp->d_ino == 0);
Modified: trunk/glibc-ports/patches/scripts.patch
===================================================================
--- trunk/glibc-ports/patches/scripts.patch 2009-02-22 03:13:34 UTC (rev 2374)
+++ trunk/glibc-ports/patches/scripts.patch 2009-02-27 15:02:48 UTC (rev 2375)
@@ -1,6 +1,13 @@
-diff -urN glibc-2.3.2.orig/abi-tags glibc-2.3.2/abi-tags
---- abi-tags 2002-09-21 02:28:19.000000000 +0200
-+++ abi-tags 2005-06-12 17:58:26.000000000 +0200
+---
+ abi-tags | 2 +-
+ configure | 6 +++---
+ configure.in | 6 +++---
+ linuxthreads/shlib-versions | 3 ++-
+ shlib-versions | 4 ++++
+ 5 files changed, 13 insertions(+), 8 deletions(-)
+
+--- a/abi-tags
++++ b/abi-tags
@@ -22,7 +22,7 @@
.*-sun-solaris2.* 2 2.0.0 # just an arbitrary value
@@ -8,12 +15,11 @@
-.*-.*-freebsd.*-gnu.* 3 4.0.0 # earliest compatible kernel version
+.*-.*-kfreebsd.* 3 5.4.0 # earliest compatible kernel version
- # There is no catch-all default here because every supported OS that uses
- # ELF must have its own unique ABI tag.
-diff -urN glibc-2.3.2.orig/configure glibc-2.3.2/configure
---- configure 2005-06-12 17:39:18.000000000 +0200
-+++ configure 2005-06-12 18:02:40.000000000 +0200
-@@ -1742,7 +1742,7 @@
+ .*-.*-knetbsd.*-gnu.* 4 1.6.0 # earliest compatible kernel version
+
+--- a/configure
++++ b/configure
+@@ -2282,7 +2282,7 @@
# i586-linuxaout is mangled into i586-pc-linux-gnuaout
linux*ecoff* | linux*aout* | gnu*aout* | gnu*ecoff*)
;;
@@ -22,17 +28,17 @@
# These systems (almost) always use the ELF format.
elf=yes
;;
-@@ -1785,7 +1785,7 @@
+@@ -2489,7 +2489,7 @@
###
- if test -z "$enable_hacker_mode"; then
+ if test -z "$enable_hacker_mode" && test x"$libc_config_ok" != xyes; then
case "$machine-$host_os" in
- *-linux* | *-gnu* | arm*-none* | powerpc-aix4.3.*)
+ *-linux* | *-gnu* | *-kfreebsd* | arm*-none* | powerpc-aix4.3.*)
;;
*)
echo "*** The GNU C library is currently not available for this platform."
-@@ -1883,7 +1883,7 @@
- case "$os" in
+@@ -2563,7 +2563,7 @@
+ test "x$base_os" != x || case "$os" in
gnu*)
base_os=mach/hurd ;;
-netbsd* | 386bsd* | freebsd* | bsdi*)
@@ -40,10 +46,9 @@
base_os=unix/bsd/bsd4.4 ;;
osf* | sunos* | ultrix* | newsos* | dynix* | *bsd*)
base_os=unix/bsd ;;
-diff -urN glibc-2.3.2.orig/configure.in glibc-2.3.2/configure.in
---- configure.in 2005-06-12 17:39:21.000000000 +0200
-+++ configure.in 2005-06-12 18:01:28.000000000 +0200
-@@ -316,7 +316,7 @@
+--- a/configure.in
++++ b/configure.in
+@@ -283,7 +283,7 @@
# i586-linuxaout is mangled into i586-pc-linux-gnuaout
linux*ecoff* | linux*aout* | gnu*aout* | gnu*ecoff*)
;;
@@ -52,17 +57,17 @@
# These systems (almost) always use the ELF format.
elf=yes
;;
-@@ -359,7 +359,7 @@
+@@ -469,7 +469,7 @@
###
- if test -z "$enable_hacker_mode"; then
+ if test -z "$enable_hacker_mode" && test x"$libc_config_ok" != xyes; then
case "$machine-$host_os" in
- *-linux* | *-gnu* | arm*-none* | powerpc-aix4.3.*)
+ *-linux* | *-gnu* | *-kfreebsd* | arm*-none* | powerpc-aix4.3.*)
;;
*)
echo "*** The GNU C library is currently not available for this platform."
-@@ -458,7 +458,7 @@
- case "$os" in
+@@ -544,7 +544,7 @@
+ test "x$base_os" != x || case "$os" in
gnu*)
base_os=mach/hurd ;;
-netbsd* | 386bsd* | freebsd* | bsdi*)
@@ -70,34 +75,33 @@
base_os=unix/bsd/bsd4.4 ;;
osf* | sunos* | ultrix* | newsos* | dynix* | *bsd*)
base_os=unix/bsd ;;
-diff -urN glibc-2.3.2.orig/shlib-versions glibc-2.3.2/shlib-versions
---- shlib-versions 2002-09-05 11:31:49.000000000 +0200
-+++ shlib-versions 2005-06-12 18:06:19.000000000 +0200
-@@ -26,6 +26,7 @@
+--- a/shlib-versions
++++ b/shlib-versions
+@@ -31,6 +31,7 @@
x86_64-.*-linux.* DEFAULT GLIBC_2.2.5
powerpc64-.*-linux.* DEFAULT GLIBC_2.3
.*-.*-gnu-gnu.* DEFAULT GLIBC_2.2.6
+.*-.*-kfreebsd.* DEFAULT GLIBC_2.3
- # Configuration Library=version Earliest symbol set (optional)
- # ------------- --------------- ------------------------------
-@@ -39,6 +40,7 @@
- hppa.*-.*-.* libm=6 GLIBC_2.2
+ # Configuration WORDSIZE[32|64] Alternate configuration
+ # ------------- ---------- -----------------------
+@@ -53,6 +54,7 @@
+ sh.*-.*-linux.* libm=6 GLIBC_2.2
.*-.*-linux.* libm=6
.*-.*-gnu-gnu.* libm=6
+.*-.*-kfreebsd.* libm=1
# We provide libc.so.6 for Linux kernel versions 2.0 and later.
alpha.*-.*-linux.* libc=6.1
-@@ -49,6 +51,7 @@
- sparc64-.*-linux.* libc=6 GLIBC_2.2
- hppa.*-.*-.* libc=6 GLIBC_2.2
+@@ -60,6 +62,7 @@
+ sh.*-.*-linux.* libc=6 GLIBC_2.2
+ sparc64.*-.*-linux.* libc=6 GLIBC_2.2
.*-.*-linux.* libc=6
+.*-.*-kfreebsd.* libc=0.1
# libmachuser.so.1 corresponds to mach/*.defs as of Utah's UK22 release.
.*-.*-gnu-gnu.* libmachuser=1
-@@ -73,6 +73,7 @@
+@@ -81,6 +84,7 @@
powerpc64.*-.*-linux.* ld=ld64.so.1 GLIBC_2.3
cris-.*-linux.* ld=ld.so.1 GLIBC_2.2
x86_64-.*-linux.* ld=ld-linux-x86-64.so.2 GLIBC_2.2.5
@@ -105,9 +109,8 @@
# We use the ELF ABI standard name for the default.
.*-.*-.* ld=ld.so.1
-diff -urN glibc-2.3.2.orig/linuxthreads/shlib-versions glibc-2.3.2/linuxthreads/shlib-versions
---- linuxthreads/shlib-versions 2002-09-05 12:14:21.000000000 +0200
-+++ linuxthreads/shlib-versions 2005-06-15 01:40:37.000000000 +0200
+--- a/linuxthreads/shlib-versions
++++ b/linuxthreads/shlib-versions
@@ -8,4 +8,5 @@
cris-.*-linux.* libpthread=0 GLIBC_2.2
x86_64-.*-linux.* libpthread=0 GLIBC_2.2.5
@@ -115,3 +118,9 @@
-.*-.*-linux.* libpthread=0
+.*-.*-kfreebsd.* libpthread=0 GLIBC_2.3
+.*-.*-.* libpthread=0
+--- a/linuxthreads_db/shlib-versions
++++ b/linuxthreads_db/shlib-versions
+@@ -1,2 +1,3 @@
+ # The thread debug library
+ .*-.*-linux.* libthread_db=1
++.*-.*-kfreebsd.* libthread_db=1
Modified: trunk/glibc-ports/patches/sys_queue_h.patch
===================================================================
--- trunk/glibc-ports/patches/sys_queue_h.patch 2009-02-22 03:13:34 UTC (rev 2374)
+++ trunk/glibc-ports/patches/sys_queue_h.patch 2009-02-27 15:02:48 UTC (rev 2375)
@@ -1,252 +1,34 @@
-Roland McGrath wrote:
-> Bruno Haible wrote:
-> > Other than that, FreeBSD has a <sys/queue.h> with some more macros than
-> > glibc's. It seems that glibc's <sys/queue.h> is simply an older version
-> > of the same thing. How about upgrading it?
->
-> Ok. I notice that the NetBSD and FreeBSD versions of this file differ,
-> though both claim to be the "8.5 (Berkeley)" version. I don't even know
-> off hand that we need this file in libc or if anything ever used it,
-> but since we have had it we should make sure we don't break compatibility.
-> If there is a later version of this file from UCB, that is probably what
-> we should use. Despite the lack of additional copyright notices, if the
-> FreeBSD and NetBSD versions of this file have had additions made by people
-> other than UCB, there may be a copyright issue with using those versions.
+---
+ misc/sys/queue.h | 37 +++++++++++++++++++++++++++++++++++++
+ 1 file changed, 37 insertions(+)
-(extract from discussion between Bruno and Roland, see
-http://sources.redhat.com/ml/libc-alpha/2002-09/msg00153.html)
-
-I (rmh) don't think there's a copyright issue, but it's a picky decision for
-upstream wether taking the improvements from NetBSD or FreeBSD, since they're
-allegedly very different.
-
-Also, since it's a big change, it could break something. I would suggest
-waiting untill it's been applied in debian for some time, just in case.
-
---- misc/sys/queue.h.orig 2006-05-10 16:53:51.000000000 +0200
-+++ misc/sys/queue.h 2006-10-13 13:05:17.000000000 +0200
-@@ -27,24 +27,38 @@
- * SUCH DAMAGE.
- *
- * @(#)queue.h 8.5 (Berkeley) 8/20/94
-+ * $FreeBSD: src/sys/sys/queue.h,v 1.58 2004/04/07 04:19:49 imp Exp $
- */
-
--#ifndef _SYS_QUEUE_H_
-+#ifndef _SYS_QUEUE_H_
+--- a/misc/sys/queue.h
++++ b/misc/sys/queue.h
+@@ -32,6 +32,8 @@
+ #ifndef _SYS_QUEUE_H_
#define _SYS_QUEUE_H_
+#include <sys/cdefs.h>
+
/*
-- * This file defines five types of data structures: singly-linked lists,
-- * lists, simple queues, tail queues, and circular queues.
-+ * This file defines four types of data structures: singly-linked lists,
-+ * singly-linked tail queues, lists and tail 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 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 singly-linked 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
-+ * 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, at the head of the list, or at the
-+ * end of the list. Elements being removed from the head of the tail queue
-+ * should use the explicit macro for this purpose for optimum efficiency.
-+ * A singly-linked tail queue may only be traversed in the forward direction.
-+ * Singly-linked tail queues are ideal for applications with large datasets
-+ * and few or no removals or for implementing a FIFO 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
-@@ -53,13 +67,6 @@
- * 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
-@@ -67,85 +74,68 @@
- * 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.
-+ *
-+ *
-+ * SLIST LIST STAILQ TAILQ
-+ * _HEAD + + + +
-+ * _HEAD_INITIALIZER + + + +
-+ * _ENTRY + + + +
-+ * _INIT + + + +
-+ * _EMPTY + + + +
-+ * _FIRST + + + +
-+ * _NEXT + + + +
-+ * _PREV - - - +
-+ * _LAST - - + +
-+ * _FOREACH + + + +
-+ * _FOREACH_SAFE + + + +
-+ * _FOREACH_REVERSE - - - +
-+ * _FOREACH_REVERSE_SAFE - - - +
-+ * _INSERT_HEAD + + + +
-+ * _INSERT_BEFORE - + - +
-+ * _INSERT_AFTER + + + +
-+ * _INSERT_TAIL - - + +
-+ * _CONCAT - - + +
-+ * _REMOVE_HEAD + - + -
-+ * _REMOVE + + + +
-+ *
- */
-+#define QUEUE_MACRO_DEBUG 0
-+#if QUEUE_MACRO_DEBUG
-+/* Store the last 2 places the queue element or head was altered */
-+struct qm_trace {
-+ char * lastfile;
-+ int lastline;
-+ char * prevfile;
-+ int prevline;
-+};
-+
-+#define TRACEBUF struct qm_trace trace;
-+#define TRASHIT(x) do {(x) = (void *)-1;} while (0)
-+
-+#define QMD_TRACE_HEAD(head) do { \
-+ (head)->trace.prevline = (head)->trace.lastline; \
-+ (head)->trace.prevfile = (head)->trace.lastfile; \
-+ (head)->trace.lastline = __LINE__; \
-+ (head)->trace.lastfile = __FILE__; \
-+} while (0)
-+
-+#define QMD_TRACE_ELEM(elem) do { \
-+ (elem)->trace.prevline = (elem)->trace.lastline; \
-+ (elem)->trace.prevfile = (elem)->trace.lastfile; \
-+ (elem)->trace.lastline = __LINE__; \
-+ (elem)->trace.lastfile = __FILE__; \
-+} while (0)
-+
-+#else
-+#define QMD_TRACE_ELEM(elem)
-+#define QMD_TRACE_HEAD(head)
-+#define TRACEBUF
-+#define TRASHIT(x)
-+#endif /* QUEUE_MACRO_DEBUG */
+ * This file defines five types of data structures: singly-linked lists,
+ * lists, simple queues, tail queues, and circular queues.
+@@ -136,6 +138,11 @@
+ (var); \
+ (var) = ((var)->field.le_next))
++#define LIST_FOREACH_SAFE(var, head, field, tvar) \
++ for (((var) = ((head)->lh_first); \
++ (var) && ((tvar) = ((var)->field.le_next), 1); \
++ (var) = (tvar))
++
/*
-- * 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 functions.
-- */
--#define LIST_INIT(head) do { \
-- (head)->lh_first = NULL; \
--} while (/*CONSTCOND*/0)
--
--#define LIST_INSERT_AFTER(listelm, elm, field) do { \
-- if (((elm)->field.le_next = (listelm)->field.le_next) != NULL) \
-- (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 { \
-- (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 { \
-- if (((elm)->field.le_next = (head)->lh_first) != NULL) \
-- (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 { \
-- 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; \
--} while (/*CONSTCOND*/0)
--
--#define LIST_FOREACH(var, head, field) \
-- for ((var) = ((head)->lh_first); \
-- (var); \
-- (var) = ((var)->field.le_next))
--
--/*
-- * List access methods.
-- */
--#define LIST_EMPTY(head) ((head)->lh_first == NULL)
--#define LIST_FIRST(head) ((head)->lh_first)
--#define LIST_NEXT(elm, field) ((elm)->field.le_next)
--
--
--/*
-- * Singly-linked List definitions.
-+ * Singly-linked List declarations.
+ * List access methods.
*/
- #define SLIST_HEAD(name, type) \
- struct name { \
-@@ -163,55 +153,65 @@
- /*
- * Singly-linked List functions.
- */
-+#define SLIST_EMPTY(head) ((head)->slh_first == NULL)
-+
-+#define SLIST_FIRST(head) ((head)->slh_first)
-+
-+#define SLIST_FOREACH(var, head, field) \
-+ for ((var) = SLIST_FIRST((head)); \
-+ (var); \
-+ (var) = SLIST_NEXT((var), field))
-+
+@@ -197,6 +204,16 @@
+ #define SLIST_FOREACH(var, head, field) \
+ for((var) = (head)->slh_first; (var); (var) = (var)->field.sle_next)
+
+#define SLIST_FOREACH_SAFE(var, head, field, tvar) \
+ for ((var) = SLIST_FIRST((head)); \
+ (var) && ((tvar) = SLIST_NEXT((var), field), 1); \
@@ -257,665 +39,52 @@
+ ((var) = *(varp)) != NULL; \
+ (varp) = &SLIST_NEXT((var), field))
+
- #define SLIST_INIT(head) do { \
-- (head)->slh_first = NULL; \
--} while (/*CONSTCOND*/0)
-+ SLIST_FIRST((head)) = NULL; \
-+} while (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)
-+ SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field); \
-+ SLIST_NEXT((slistelm), field) = (elm); \
-+} while (0)
-
- #define SLIST_INSERT_HEAD(head, elm, field) do { \
-- (elm)->field.sle_next = (head)->slh_first; \
-- (head)->slh_first = (elm); \
--} while (/*CONSTCOND*/0)
-+ SLIST_NEXT((elm), field) = SLIST_FIRST((head)); \
-+ SLIST_FIRST((head)) = (elm); \
-+} while (0)
-
--#define SLIST_REMOVE_HEAD(head, field) do { \
-- (head)->slh_first = (head)->slh_first->field.sle_next; \
--} while (/*CONSTCOND*/0)
-+#define SLIST_NEXT(elm, field) ((elm)->field.sle_next)
-
- #define SLIST_REMOVE(head, elm, type, field) do { \
-- if ((head)->slh_first == (elm)) { \
-+ if (SLIST_FIRST((head)) == (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; \
-+ struct type *curelm = SLIST_FIRST((head)); \
-+ while (SLIST_NEXT(curelm, field) != (elm)) \
-+ curelm = SLIST_NEXT(curelm, field); \
-+ SLIST_NEXT(curelm, field) = \
-+ SLIST_NEXT(SLIST_NEXT(curelm, field), field); \
- } \
--} while (/*CONSTCOND*/0)
--
--#define SLIST_FOREACH(var, head, field) \
-- for((var) = (head)->slh_first; (var); (var) = (var)->field.sle_next)
--
--/*
-- * Singly-linked List access methods.
-- */
--#define SLIST_EMPTY(head) ((head)->slh_first == NULL)
--#define SLIST_FIRST(head) ((head)->slh_first)
--#define SLIST_NEXT(elm, field) ((elm)->field.sle_next)
-+} while (0)
-
-+#define SLIST_REMOVE_HEAD(head, field) do { \
-+ SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field); \
-+} while (0)
-
/*
- * Singly-linked Tail queue declarations.
+ * Singly-linked List access methods.
*/
--#define STAILQ_HEAD(name, type) \
-+#define STAILQ_HEAD(name, type) \
- struct name { \
-- struct type *stqh_first; /* first element */ \
-- struct type **stqh_last; /* addr of last next element */ \
-+ struct type *stqh_first;/* first element */ \
-+ struct type **stqh_last;/* addr of last next element */ \
- }
+@@ -253,6 +270,11 @@
+ (head)->stqh_last = &(head)->stqh_first; \
+ } while (/*CONSTCOND*/0)
- #define STAILQ_HEAD_INITIALIZER(head) \
-@@ -225,333 +225,329 @@
- /*
- * Singly-linked Tail queue functions.
- */
-+#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)
++#define STAILQ_REMOVE_HEAD_UNTIL(head, elm, field) do { \
++ if (((head)->stqh_first = ((elm)->field.stqe_next)) == NULL) \
++ (head)->stqh_last = &((head)->stqh_first); \
++} while (/*CONSTCOND*/0)
+
-+#define STAILQ_EMPTY(head) ((head)->stqh_first == NULL)
-+
-+#define STAILQ_FIRST(head) ((head)->stqh_first)
-+
-+#define STAILQ_FOREACH(var, head, field) \
-+ for((var) = STAILQ_FIRST((head)); \
-+ (var); \
-+ (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))
-+
- #define STAILQ_INIT(head) do { \
-- (head)->stqh_first = NULL; \
-- (head)->stqh_last = &(head)->stqh_first; \
--} while (/*CONSTCOND*/0)
-+ STAILQ_FIRST((head)) = NULL; \
-+ (head)->stqh_last = &STAILQ_FIRST((head)); \
-+} while (0)
-+
-+#define STAILQ_INSERT_AFTER(head, tqelm, elm, field) do { \
-+ if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\
-+ (head)->stqh_last = &STAILQ_NEXT((elm), field); \
-+ STAILQ_NEXT((tqelm), field) = (elm); \
-+} while (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)
-+ if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) \
-+ (head)->stqh_last = &STAILQ_NEXT((elm), field); \
-+ STAILQ_FIRST((head)) = (elm); \
-+} while (0)
-
- #define STAILQ_INSERT_TAIL(head, elm, field) do { \
-- (elm)->field.stqe_next = NULL; \
-+ STAILQ_NEXT((elm), field) = NULL; \
- *(head)->stqh_last = (elm); \
-- (head)->stqh_last = &(elm)->field.stqe_next; \
--} while (/*CONSTCOND*/0)
-+ (head)->stqh_last = &STAILQ_NEXT((elm), field); \
-+} while (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_LAST(head, type, field) \
-+ (STAILQ_EMPTY((head)) ? \
-+ NULL : \
-+ ((struct type *)(void *) \
-+ ((char *)((head)->stqh_last) - __offsetof(struct type, field))))
-
--#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_NEXT(elm, field) ((elm)->field.stqe_next)
-
#define STAILQ_REMOVE(head, elm, type, field) do { \
-- if ((head)->stqh_first == (elm)) { \
-+ if (STAILQ_FIRST((head)) == (elm)) { \
+ 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))
--
--/*
-- * Singly-linked Tail queue access methods.
-- */
--#define STAILQ_EMPTY(head) ((head)->stqh_first == NULL)
--#define STAILQ_FIRST(head) ((head)->stqh_first)
--#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next)
-+ else { \
-+ struct type *curelm = STAILQ_FIRST((head)); \
-+ while (STAILQ_NEXT(curelm, field) != (elm)) \
-+ curelm = STAILQ_NEXT(curelm, field); \
-+ if ((STAILQ_NEXT(curelm, field) = \
-+ STAILQ_NEXT(STAILQ_NEXT(curelm, field), field)) == NULL)\
-+ (head)->stqh_last = &STAILQ_NEXT((curelm), field);\
-+ } \
-+} while (0)
+@@ -271,6 +293,11 @@
+ (var); \
+ (var) = ((var)->field.stqe_next))
-+#define STAILQ_REMOVE_HEAD(head, field) do { \
-+ if ((STAILQ_FIRST((head)) = \
-+ STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL) \
-+ (head)->stqh_last = &STAILQ_FIRST((head)); \
-+} while (0)
-+
-+#define STAILQ_REMOVE_HEAD_UNTIL(head, elm, field) do { \
-+ if ((STAILQ_FIRST((head)) = STAILQ_NEXT((elm), field)) == NULL) \
-+ (head)->stqh_last = &STAILQ_FIRST((head)); \
-+} while (0)
-
- /*
-- * Simple queue definitions.
-+ * List declarations.
- */
--#define SIMPLEQ_HEAD(name, type) \
-+#define LIST_HEAD(name, type) \
- struct name { \
-- struct type *sqh_first; /* first element */ \
-- struct type **sqh_last; /* addr of last next element */ \
-+ struct type *lh_first; /* first element */ \
- }
-
--#define SIMPLEQ_HEAD_INITIALIZER(head) \
-- { NULL, &(head).sqh_first }
-+#define LIST_HEAD_INITIALIZER(head) \
-+ { NULL }
-
--#define SIMPLEQ_ENTRY(type) \
-+#define LIST_ENTRY(type) \
- struct { \
-- struct type *sqe_next; /* next element */ \
-+ struct type *le_next; /* next element */ \
-+ struct type **le_prev; /* address of previous next element */ \
- }
-
- /*
-- * Simple queue functions.
-+ * List 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(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_FOREACH(var, head, field) \
-- for ((var) = ((head)->sqh_first); \
-- (var); \
-- (var) = ((var)->field.sqe_next))
-+#define LIST_EMPTY(head) ((head)->lh_first == NULL)
-
--/*
-- * Simple queue access methods.
-- */
--#define SIMPLEQ_EMPTY(head) ((head)->sqh_first == NULL)
--#define SIMPLEQ_FIRST(head) ((head)->sqh_first)
--#define SIMPLEQ_NEXT(elm, field) ((elm)->field.sqe_next)
-+#define LIST_FIRST(head) ((head)->lh_first)
-+
-+#define LIST_FOREACH(var, head, field) \
-+ for ((var) = LIST_FIRST((head)); \
-+ (var); \
-+ (var) = LIST_NEXT((var), field))
-+
-+#define LIST_FOREACH_SAFE(var, head, field, tvar) \
-+ for ((var) = LIST_FIRST((head)); \
-+ (var) && ((tvar) = LIST_NEXT((var), field), 1); \
++#define STAILQ_FOREACH_SAFE(var, head, field, tvar) \
++ for ((var) = ((elm)->field.stqe_next); \
++ (var) && ((tvar) = ((var)->field.stqe_next), 1); \
+ (var) = (tvar))
+
-+#define LIST_INIT(head) do { \
-+ LIST_FIRST((head)) = NULL; \
-+} while (0)
-+
-+#define LIST_INSERT_AFTER(listelm, elm, field) do { \
-+ if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\
-+ LIST_NEXT((listelm), field)->field.le_prev = \
-+ &LIST_NEXT((elm), field); \
-+ LIST_NEXT((listelm), field) = (elm); \
-+ (elm)->field.le_prev = &LIST_NEXT((listelm), field); \
-+} while (0)
-+
-+#define LIST_INSERT_BEFORE(listelm, elm, field) do { \
-+ (elm)->field.le_prev = (listelm)->field.le_prev; \
-+ LIST_NEXT((elm), field) = (listelm); \
-+ *(listelm)->field.le_prev = (elm); \
-+ (listelm)->field.le_prev = &LIST_NEXT((elm), field); \
-+} while (0)
-+
-+#define LIST_INSERT_HEAD(head, elm, field) do { \
-+ if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL) \
-+ LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\
-+ LIST_FIRST((head)) = (elm); \
-+ (elm)->field.le_prev = &LIST_FIRST((head)); \
-+} while (0)
-+
-+#define LIST_NEXT(elm, field) ((elm)->field.le_next)
+ #define STAILQ_CONCAT(head1, head2) do { \
+ if (!STAILQ_EMPTY((head2))) { \
+ *(head1)->stqh_last = (head2)->stqh_first; \
+@@ -437,11 +464,21 @@
+ (var); \
+ (var) = ((var)->field.tqe_next))
-+#define LIST_REMOVE(elm, field) do { \
-+ if (LIST_NEXT((elm), field) != NULL) \
-+ LIST_NEXT((elm), field)->field.le_prev = \
-+ (elm)->field.le_prev; \
-+ *(elm)->field.le_prev = LIST_NEXT((elm), field); \
-+} while (0)
-
- /*
-- * Tail queue definitions.
-+ * Tail queue declarations.
- */
--#define _TAILQ_HEAD(name, type, qual) \
-+#define TAILQ_HEAD(name, type) \
- struct name { \
-- qual type *tqh_first; /* first element */ \
-- qual type *qual *tqh_last; /* addr of last next element */ \
-+ struct type *tqh_first; /* first element */ \
-+ struct type **tqh_last; /* addr of last next element */ \
-+ TRACEBUF \
- }
--#define TAILQ_HEAD(name, type) _TAILQ_HEAD(name, struct type,)
-
- #define TAILQ_HEAD_INITIALIZER(head) \
- { NULL, &(head).tqh_first }
-
--#define _TAILQ_ENTRY(type, qual) \
-+#define TAILQ_ENTRY(type) \
- struct { \
-- qual type *tqe_next; /* next element */ \
-- qual type *qual *tqe_prev; /* address of previous next element */\
-+ struct type *tqe_next; /* next element */ \
-+ struct type **tqe_prev; /* address of previous next element */ \
-+ TRACEBUF \
- }
--#define TAILQ_ENTRY(type) _TAILQ_ENTRY(struct type,)
-
- /*
- * Tail queue functions.
- */
-+#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)); \
-+ QMD_TRACE_HEAD(head1); \
-+ QMD_TRACE_HEAD(head2); \
-+ } \
-+} while (0)
-+
-+#define TAILQ_EMPTY(head) ((head)->tqh_first == NULL)
-+
-+#define TAILQ_FIRST(head) ((head)->tqh_first)
-+
-+#define TAILQ_FOREACH(var, head, field) \
-+ for ((var) = TAILQ_FIRST((head)); \
-+ (var); \
-+ (var) = TAILQ_NEXT((var), field))
-+
+#define TAILQ_FOREACH_SAFE(var, head, field, tvar) \
-+ for ((var) = TAILQ_FIRST((head)); \
-+ (var) && ((tvar) = TAILQ_NEXT((var), field), 1); \
++ for ((var) = ((head)->tqh_first); \
++ (var) && ((tvar) = ((var)->field.tqe_next), 1); \
+ (var) = (tvar))
+
-+#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \
-+ for ((var) = TAILQ_LAST((head), headname); \
-+ (var); \
-+ (var) = TAILQ_PREV((var), headname, field))
-+
+ #define TAILQ_FOREACH_REVERSE(var, head, headname, field) \
+ for ((var) = (*(((struct headname *)((head)->tqh_last))->tqh_last)); \
+ (var); \
+ (var) = (*(((struct headname *)((var)->field.tqe_prev))->tqh_last)))
+
+#define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \
-+ for ((var) = TAILQ_LAST((head), headname); \
-+ (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1); \
++ for ((var) = (*(((struct headname *)((head)->tqh_last))->tqh_last)); \
++ (var) && ((tvar) = (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last)), 1); \
+ (var) = (tvar))
+
- #define TAILQ_INIT(head) do { \
-- (head)->tqh_first = NULL; \
-- (head)->tqh_last = &(head)->tqh_first; \
--} while (/*CONSTCOND*/0)
-+ TAILQ_FIRST((head)) = NULL; \
-+ (head)->tqh_last = &TAILQ_FIRST((head)); \
-+ QMD_TRACE_HEAD(head); \
-+} while (0)
-+
-+#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \
-+ if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\
-+ TAILQ_NEXT((elm), field)->field.tqe_prev = \
-+ &TAILQ_NEXT((elm), field); \
-+ else { \
-+ (head)->tqh_last = &TAILQ_NEXT((elm), field); \
-+ QMD_TRACE_HEAD(head); \
-+ } \
-+ TAILQ_NEXT((listelm), field) = (elm); \
-+ (elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field); \
-+ QMD_TRACE_ELEM(&(elm)->field); \
-+ QMD_TRACE_ELEM(&listelm->field); \
-+} while (0)
-+
-+#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \
-+ (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \
-+ TAILQ_NEXT((elm), field) = (listelm); \
-+ *(listelm)->field.tqe_prev = (elm); \
-+ (listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field); \
-+ QMD_TRACE_ELEM(&(elm)->field); \
-+ QMD_TRACE_ELEM(&listelm->field); \
-+} while (0)
-
- #define TAILQ_INSERT_HEAD(head, elm, field) do { \
-- if (((elm)->field.tqe_next = (head)->tqh_first) != NULL) \
-- (head)->tqh_first->field.tqe_prev = \
-- &(elm)->field.tqe_next; \
-+ if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL) \
-+ TAILQ_FIRST((head))->field.tqe_prev = \
-+ &TAILQ_NEXT((elm), field); \
- else \
-- (head)->tqh_last = &(elm)->field.tqe_next; \
-- (head)->tqh_first = (elm); \
-- (elm)->field.tqe_prev = &(head)->tqh_first; \
--} while (/*CONSTCOND*/0)
-+ (head)->tqh_last = &TAILQ_NEXT((elm), field); \
-+ TAILQ_FIRST((head)) = (elm); \
-+ (elm)->field.tqe_prev = &TAILQ_FIRST((head)); \
-+ QMD_TRACE_HEAD(head); \
-+ QMD_TRACE_ELEM(&(elm)->field); \
-+} while (0)
-
- #define TAILQ_INSERT_TAIL(head, elm, field) do { \
-- (elm)->field.tqe_next = NULL; \
-+ TAILQ_NEXT((elm), field) = NULL; \
- (elm)->field.tqe_prev = (head)->tqh_last; \
- *(head)->tqh_last = (elm); \
-- (head)->tqh_last = &(elm)->field.tqe_next; \
--} while (/*CONSTCOND*/0)
-+ (head)->tqh_last = &TAILQ_NEXT((elm), field); \
-+ QMD_TRACE_HEAD(head); \
-+ QMD_TRACE_ELEM(&(elm)->field); \
-+} while (0)
-
--#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \
-- if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\
-- (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_LAST(head, headname) \
-+ (*(((struct headname *)((head)->tqh_last))->tqh_last))
-
--#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); \
-- (listelm)->field.tqe_prev = &(elm)->field.tqe_next; \
--} while (/*CONSTCOND*/0)
-+#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
-+
-+#define TAILQ_PREV(elm, headname, field) \
-+ (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
-
- #define TAILQ_REMOVE(head, elm, field) do { \
-- if (((elm)->field.tqe_next) != NULL) \
-- (elm)->field.tqe_next->field.tqe_prev = \
-+ if ((TAILQ_NEXT((elm), field)) != NULL) \
-+ TAILQ_NEXT((elm), field)->field.tqe_prev = \
- (elm)->field.tqe_prev; \
-- else \
-+ else { \
- (head)->tqh_last = (elm)->field.tqe_prev; \
-- *(elm)->field.tqe_prev = (elm)->field.tqe_next; \
--} while (/*CONSTCOND*/0)
-+ QMD_TRACE_HEAD(head); \
-+ } \
-+ *(elm)->field.tqe_prev = TAILQ_NEXT((elm), field); \
-+ TRASHIT((elm)->field.tqe_next); \
-+ TRASHIT((elm)->field.tqe_prev); \
-+ QMD_TRACE_ELEM(&(elm)->field); \
-+} while (0)
-
--#define TAILQ_FOREACH(var, head, field) \
-- for ((var) = ((head)->tqh_first); \
-- (var); \
-- (var) = ((var)->field.tqe_next))
-
--#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \
-- for ((var) = (*(((struct headname *)((head)->tqh_last))->tqh_last)); \
-- (var); \
-- (var) = (*(((struct headname *)((var)->field.tqe_prev))->tqh_last)))
-+#ifdef _KERNEL
-
- /*
-- * Tail queue access methods.
-+ * XXX insque() and remque() are an old way of handling certain queues.
-+ * They bogusly assumes that all queue heads look alike.
- */
--#define TAILQ_EMPTY(head) ((head)->tqh_first == NULL)
--#define TAILQ_FIRST(head) ((head)->tqh_first)
--#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))
-+struct quehead {
-+ struct quehead *qh_link;
-+ struct quehead *qh_rlink;
-+};
-
-+#if defined(__GNUC__) || defined(__INTEL_COMPILER)
-
--/*
-- * Circular queue definitions.
-- */
--#define CIRCLEQ_HEAD(name, type) \
--struct name { \
-- struct type *cqh_first; /* first element */ \
-- struct type *cqh_last; /* last element */ \
-+static __inline void
-+insque(void *a, void *b)
-+{
-+ struct quehead *element = (struct quehead *)a,
-+ *head = (struct quehead *)b;
-+
-+ element->qh_link = head->qh_link;
-+ element->qh_rlink = head;
-+ head->qh_link = element;
-+ element->qh_link->qh_rlink = element;
- }
-
--#define CIRCLEQ_HEAD_INITIALIZER(head) \
-- { (void *)&head, (void *)&head }
-+static __inline void
-+remque(void *a)
-+{
-+ struct quehead *element = (struct quehead *)a;
-
--#define CIRCLEQ_ENTRY(type) \
--struct { \
-- struct type *cqe_next; /* next element */ \
-- struct type *cqe_prev; /* previous element */ \
-+ element->qh_link->qh_rlink = element->qh_rlink;
-+ element->qh_rlink->qh_link = element->qh_link;
-+ element->qh_rlink = 0;
- }
-
--/*
-- * Circular queue functions.
-- */
--#define CIRCLEQ_INIT(head) do { \
-- (head)->cqh_first = (void *)(head); \
-- (head)->cqh_last = (void *)(head); \
--} while (/*CONSTCOND*/0)
--
--#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \
-- (elm)->field.cqe_next = (listelm)->field.cqe_next; \
-- (elm)->field.cqe_prev = (listelm); \
-- if ((listelm)->field.cqe_next == (void *)(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 { \
-- (elm)->field.cqe_next = (listelm); \
-- (elm)->field.cqe_prev = (listelm)->field.cqe_prev; \
-- if ((listelm)->field.cqe_prev == (void *)(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 { \
-- (elm)->field.cqe_next = (head)->cqh_first; \
-- (elm)->field.cqe_prev = (void *)(head); \
-- if ((head)->cqh_last == (void *)(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 { \
-- (elm)->field.cqe_next = (void *)(head); \
-- (elm)->field.cqe_prev = (head)->cqh_last; \
-- if ((head)->cqh_first == (void *)(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 { \
-- if ((elm)->field.cqe_next == (void *)(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 == (void *)(head)) \
-- (head)->cqh_first = (elm)->field.cqe_next; \
-- else \
-- (elm)->field.cqe_prev->field.cqe_next = \
-- (elm)->field.cqe_next; \
--} while (/*CONSTCOND*/0)
--
--#define CIRCLEQ_FOREACH(var, head, field) \
-- for ((var) = ((head)->cqh_first); \
-- (var) != (const void *)(head); \
-- (var) = ((var)->field.cqe_next))
--
--#define CIRCLEQ_FOREACH_REVERSE(var, head, field) \
-- for ((var) = ((head)->cqh_last); \
-- (var) != (const void *)(head); \
-- (var) = ((var)->field.cqe_prev))
-+#else /* !(__GNUC__ || __INTEL_COMPILER) */
-
--/*
-- * Circular queue access methods.
-- */
--#define CIRCLEQ_EMPTY(head) ((head)->cqh_first == (void *)(head))
--#define CIRCLEQ_FIRST(head) ((head)->cqh_first)
--#define CIRCLEQ_LAST(head) ((head)->cqh_last)
--#define CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next)
--#define CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev)
--
--#define CIRCLEQ_LOOP_NEXT(head, elm, field) \
-- (((elm)->field.cqe_next == (void *)(head)) \
-- ? ((head)->cqh_first) \
-- : (elm->field.cqe_next))
--#define CIRCLEQ_LOOP_PREV(head, elm, field) \
-- (((elm)->field.cqe_prev == (void *)(head)) \
-- ? ((head)->cqh_last) \
-- : (elm->field.cqe_prev))
-+void insque(void *a, void *b);
-+void remque(void *a);
-+
-+#endif /* __GNUC__ || __INTEL_COMPILER */
-+
-+#endif /* _KERNEL */
-
--#endif /* sys/queue.h */
-+#endif /* !_SYS_QUEUE_H_ */
+ #define TAILQ_CONCAT(head1, head2, field) do { \
+ if (!TAILQ_EMPTY(head2)) { \
+ *(head1)->tqh_last = (head2)->tqh_first; \
Modified: trunk/glibc-ports/patches/undef-glibc.patch
===================================================================
--- trunk/glibc-ports/patches/undef-glibc.patch 2009-02-22 03:13:34 UTC (rev 2374)
+++ trunk/glibc-ports/patches/undef-glibc.patch 2009-02-27 15:02:48 UTC (rev 2375)
@@ -2,13 +2,17 @@
Author: rmh
Upstream status: REJECTED. DO NOT SUBMIT. (send to debian instead)
---- include/features.h.orig 2005-02-18 01:08:56.000000000 +0100
-+++ include/features.h 2005-07-17 22:18:23.000000000 +0200
-@@ -288,6 +288,7 @@
+---
+ include/features.h | 1 +
+ 1 file changed, 1 insertion(+)
+
+--- a/include/features.h
++++ b/include/features.h
+@@ -310,6 +310,7 @@
/* Major and minor version number of the GNU C library package. Use
these macros to test for features in specific releases. */
+#undef __GLIBC__
#define __GLIBC__ 2
- #define __GLIBC_MINOR__ 3
+ #define __GLIBC_MINOR__ 8
More information about the Glibc-bsd-commits
mailing list