[Glibc-bsd-commits] r1686 - in trunk/glibc-ports: . kfreebsd
kfreebsd/bits kfreebsd/i386 kfreebsd/i386/linuxthreads
kfreebsd/linuxthreads kfreebsd/utmp-compat patches
Petr Salinger
ps-guest at costa.debian.org
Mon Oct 16 09:16:39 UTC 2006
Author: ps-guest
Date: 2006-10-16 09:16:38 +0000 (Mon, 16 Oct 2006)
New Revision: 1686
Added:
trunk/glibc-ports/gen_sysdep_patch.sh
trunk/glibc-ports/kfreebsd/check_fds.c
trunk/glibc-ports/kfreebsd/check_pf.c
trunk/glibc-ports/kfreebsd/kernel-posix-cpu-timers.h
trunk/glibc-ports/kfreebsd/sbrk.c
trunk/glibc-ports/patches/
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/sys_queue_h.patch
trunk/glibc-ports/patches/undef-glibc.patch
Modified:
trunk/glibc-ports/kfreebsd/bits/fcntl.h
trunk/glibc-ports/kfreebsd/dl-osinfo.h
trunk/glibc-ports/kfreebsd/glob.c
trunk/glibc-ports/kfreebsd/i386/linuxthreads/sysdep-cancel.h
trunk/glibc-ports/kfreebsd/i386/rfork.S
trunk/glibc-ports/kfreebsd/i386/start_thread.S
trunk/glibc-ports/kfreebsd/i386/syscall.S
trunk/glibc-ports/kfreebsd/i386/sysdep.h
trunk/glibc-ports/kfreebsd/i386/vfork.S
trunk/glibc-ports/kfreebsd/linuxthreads/allocrtsig.c
trunk/glibc-ports/kfreebsd/linuxthreads/pt-sigsuspend.S
trunk/glibc-ports/kfreebsd/not-cancel.h
trunk/glibc-ports/kfreebsd/sigreturn.c
trunk/glibc-ports/kfreebsd/syscalls-inline.h
trunk/glibc-ports/kfreebsd/syscalls.list
trunk/glibc-ports/kfreebsd/utmp-compat/utmp_file.c
Log:
* update for glibc 2.5
Copied: trunk/glibc-ports/gen_sysdep_patch.sh (from rev 1685, trunk/glibc-2.3-head/gen_sysdep_patch.sh)
===================================================================
--- trunk/glibc-ports/gen_sysdep_patch.sh (rev 0)
+++ trunk/glibc-ports/gen_sysdep_patch.sh 2006-10-16 09:16:38 UTC (rev 1686)
@@ -0,0 +1,11 @@
+#!/bin/sh
+set -ex
+LANG=C
+
+# sysdeps dir
+tmp=`mktemp -d`
+mkdir -p ${tmp}/ports/sysdeps/unix/bsd/bsd4.4
+cp -a kfreebsd ${tmp}/ports/sysdeps/unix/bsd/bsd4.4/
+(cd ${tmp} && diff -x .svn -Nurd null ports/ ) > sysdeps.diff
+rm -rf ${tmp}
+
Modified: trunk/glibc-ports/kfreebsd/bits/fcntl.h
===================================================================
--- trunk/glibc-ports/kfreebsd/bits/fcntl.h 2006-10-16 08:50:05 UTC (rev 1685)
+++ trunk/glibc-ports/kfreebsd/bits/fcntl.h 2006-10-16 09:16:38 UTC (rev 1686)
@@ -44,6 +44,8 @@
#define O_DIRECT 0x00010000 /* Attempt to bypass buffer cache */
#endif
+enum { O_DIRECTORY = 0 };
+
/* File status flags for `open' and `fcntl'. */
#define O_APPEND 0x0008 /* Writes append to the file. */
#define O_NONBLOCK 0x0004 /* Non-blocking I/O. */
Added: trunk/glibc-ports/kfreebsd/check_fds.c
===================================================================
--- trunk/glibc-ports/kfreebsd/check_fds.c (rev 0)
+++ trunk/glibc-ports/kfreebsd/check_fds.c 2006-10-16 09:16:38 UTC (rev 1686)
@@ -0,0 +1 @@
+void __libc_check_standard_fds (void) {;}
Added: trunk/glibc-ports/kfreebsd/check_pf.c
===================================================================
--- trunk/glibc-ports/kfreebsd/check_pf.c (rev 0)
+++ trunk/glibc-ports/kfreebsd/check_pf.c 2006-10-16 09:16:38 UTC (rev 1686)
@@ -0,0 +1 @@
+#include <inet/check_pf.c>
Modified: trunk/glibc-ports/kfreebsd/dl-osinfo.h
===================================================================
--- trunk/glibc-ports/kfreebsd/dl-osinfo.h 2006-10-16 08:50:05 UTC (rev 1685)
+++ trunk/glibc-ports/kfreebsd/dl-osinfo.h 2006-10-16 09:16:38 UTC (rev 1686)
@@ -97,3 +97,24 @@
} \
} \
} while (0)
+
+static inline uintptr_t __attribute__ ((always_inline))
+_dl_setup_stack_chk_guard (void)
+{
+ uintptr_t ret;
+#ifdef ENABLE_STACKGUARD_RANDOMIZE
+ int fd = __open ("/dev/urandom", O_RDONLY);
+ if (fd >= 0)
+ {
+ ssize_t reslen = __read (fd, &ret, sizeof (ret));
+ __close (fd);
+ if (reslen == (ssize_t) sizeof (ret))
+ return ret;
+ }
+#endif
+ ret = 0;
+ unsigned char *p = (unsigned char *) &ret;
+ p[sizeof (ret) - 1] = 255;
+ p[sizeof (ret) - 2] = '\n';
+ return ret;
+}
Modified: trunk/glibc-ports/kfreebsd/glob.c
===================================================================
--- trunk/glibc-ports/kfreebsd/glob.c 2006-10-16 08:50:05 UTC (rev 1685)
+++ trunk/glibc-ports/kfreebsd/glob.c 2006-10-16 09:16:38 UTC (rev 1686)
@@ -1,3 +1,3 @@
/* 'glob64' is different from 'glob', because
'struct stat64' != 'struct stat'. */
-#include <sysdeps/generic/glob.c>
+#include <posix/glob.c>
Modified: trunk/glibc-ports/kfreebsd/i386/linuxthreads/sysdep-cancel.h
===================================================================
--- trunk/glibc-ports/kfreebsd/i386/linuxthreads/sysdep-cancel.h 2006-10-16 08:50:05 UTC (rev 1685)
+++ trunk/glibc-ports/kfreebsd/i386/linuxthreads/sysdep-cancel.h 2006-10-16 09:16:38 UTC (rev 1686)
@@ -61,12 +61,13 @@
fork()
vfork()
rfork()
+ pipe()
none of them is cancelable, therefore
*/
-# define PUSHRESULT pushl %eax; pushfl
-# define POPRESULT popfl; popl %eax
+# define PUSHRESULT pushl %eax; cfi_adjust_cfa_offset (4); pushfl; cfi_adjust_cfa_offset (4)
+# define POPRESULT popfl; cfi_adjust_cfa_offset (-4); popl %eax; cfi_adjust_cfa_offset (-4)
# ifdef IS_IN_libpthread
# define CENABLE call __pthread_enable_asynccancel;
@@ -74,15 +75,23 @@
# elif defined IS_IN_librt
# ifdef PIC
# define CENABLE pushl %ebx; \
+ cfi_adjust_cfa_offset (4); \
+ cfi_rel_offset (ebx, 0); \
call __i686.get_pc_thunk.bx; \
addl $_GLOBAL_OFFSET_TABLE_, %ebx; \
call __librt_enable_asynccancel at PLT; \
- popl %ebx;
+ popl %ebx; \
+ cfi_adjust_cfa_offset (-4); \
+ cfi_restore (ebx);
# define CDISABLE pushl %ebx; \
+ cfi_adjust_cfa_offset (4); \
+ cfi_rel_offset (ebx, 0); \
call __i686.get_pc_thunk.bx; \
addl $_GLOBAL_OFFSET_TABLE_, %ebx; \
call __librt_disable_asynccancel at PLT; \
- popl %ebx;
+ popl %ebx; \
+ cfi_adjust_cfa_offset (-4); \
+ cfi_restore (ebx);
# else
# define CENABLE call __librt_enable_asynccancel;
# define CDISABLE call __librt_disable_asynccancel
Modified: trunk/glibc-ports/kfreebsd/i386/rfork.S
===================================================================
--- trunk/glibc-ports/kfreebsd/i386/rfork.S 2006-10-16 08:50:05 UTC (rev 1685)
+++ trunk/glibc-ports/kfreebsd/i386/rfork.S 2006-10-16 09:16:38 UTC (rev 1686)
@@ -33,6 +33,7 @@
andl %edx, %eax
popl %edx
+ cfi_adjust_cfa_offset(-4)
jmp *%ecx
L(pseudo_end):
Modified: trunk/glibc-ports/kfreebsd/i386/start_thread.S
===================================================================
--- trunk/glibc-ports/kfreebsd/i386/start_thread.S 2006-10-16 08:50:05 UTC (rev 1685)
+++ trunk/glibc-ports/kfreebsd/i386/start_thread.S 2006-10-16 09:16:38 UTC (rev 1686)
@@ -28,6 +28,10 @@
.text
ENTRY (__start_thread)
+ /* End FDE now, because in the child the unwind info will be
+ wrong. */
+ cfi_endproc
+
/* There is a window of a few instructions, right after the rfork
system call, where the handling of a signal would write garbage
into the stack shared by the parent and the child (assuming
@@ -199,4 +203,5 @@
popl %ebx
popl %ebp
jmp SYSCALL_ERROR_LABEL
+ cfi_startproc
PSEUDO_END (__start_thread)
Modified: trunk/glibc-ports/kfreebsd/i386/syscall.S
===================================================================
--- trunk/glibc-ports/kfreebsd/i386/syscall.S 2006-10-16 08:50:05 UTC (rev 1685)
+++ trunk/glibc-ports/kfreebsd/i386/syscall.S 2006-10-16 09:16:38 UTC (rev 1686)
@@ -21,9 +21,11 @@
.text;
ENTRY (syscall)
popl %ecx /* Pop return address into %ecx. */
+ cfi_adjust_cfa_offset (-4)
movl 0(%esp), %eax /* Load syscall number into %eax. */
int $0x80 /* Do the system call. */
pushl %ecx /* Push back return address. */
+ cfi_adjust_cfa_offset (4)
jb SYSCALL_ERROR_LABEL; /* Jump to error handler if error. */
L(pseudo_end):
Modified: trunk/glibc-ports/kfreebsd/i386/sysdep.h
===================================================================
--- trunk/glibc-ports/kfreebsd/i386/sysdep.h 2006-10-16 08:50:05 UTC (rev 1685)
+++ trunk/glibc-ports/kfreebsd/i386/sysdep.h 2006-10-16 09:16:38 UTC (rev 1686)
@@ -81,27 +81,6 @@
# define SYSCALL_ERROR_HANDLER /* Nothing here; code in sysdep.S is used. */
#else
-# ifndef HAVE_HIDDEN
-# define SETUP_PIC_REG(reg) \
- call 1f; \
- .subsection 1; \
-1:movl (%esp), %e##reg; \
- ret; \
- .previous
-# else
-# define SETUP_PIC_REG(reg) \
- .section .gnu.linkonce.t.__i686.get_pc_thunk.reg,"ax", at progbits; \
- .globl __i686.get_pc_thunk.reg; \
- .hidden __i686.get_pc_thunk.reg; \
- .type __i686.get_pc_thunk.reg, at function; \
-__i686.get_pc_thunk.reg: \
- movl (%esp), %e##reg; \
- ret; \
- .size __i686.get_pc_thunk.reg, . - __i686.get_pc_thunk.reg; \
- .previous; \
- call __i686.get_pc_thunk.reg
-# endif
-
# if RTLD_PRIVATE_ERRNO
# define SYSCALL_ERROR_HANDLER \
0:SETUP_PIC_REG(cx); \
@@ -136,14 +115,20 @@
# else
# define SYSCALL_ERROR_HANDLER \
0:pushl %ebx; \
+ cfi_adjust_cfa_offset (4); \
+ cfi_rel_offset (ebx, 0); \
SETUP_PIC_REG (bx); \
addl $_GLOBAL_OFFSET_TABLE_, %ebx; \
pushl %eax; \
+ cfi_adjust_cfa_offset (4); \
PUSH_ERRNO_LOCATION_RETURN; \
call BP_SYM (__errno_location)@PLT; \
POP_ERRNO_LOCATION_RETURN; \
popl %ecx; \
+ cfi_adjust_cfa_offset (-4); \
popl %ebx; \
+ cfi_adjust_cfa_offset (-4); \
+ cfi_restore (ebx); \
movl %ecx, (%eax); \
orl $-1, %eax; \
jmp L(pseudo_end);
Modified: trunk/glibc-ports/kfreebsd/i386/vfork.S
===================================================================
--- trunk/glibc-ports/kfreebsd/i386/vfork.S 2006-10-16 08:50:05 UTC (rev 1685)
+++ trunk/glibc-ports/kfreebsd/i386/vfork.S 2006-10-16 09:16:38 UTC (rev 1686)
@@ -27,6 +27,7 @@
/* Pop the return PC value into ECX. */
popl %ecx
+ cfi_adjust_cfa_offset(-4)
/* Perform the system call. */
DO_CALL (vfork, 0)
@@ -45,6 +46,7 @@
L(error):
/* Push back the return PC. */
pushl %ecx
+ cfi_adjust_cfa_offset(4)
/* Branch to the error handler, hidden in PSEUDO_END. */
jmp SYSCALL_ERROR_LABEL
Added: trunk/glibc-ports/kfreebsd/kernel-posix-cpu-timers.h
===================================================================
--- trunk/glibc-ports/kfreebsd/kernel-posix-cpu-timers.h (rev 0)
+++ trunk/glibc-ports/kfreebsd/kernel-posix-cpu-timers.h 2006-10-16 09:16:38 UTC (rev 1686)
@@ -0,0 +1 @@
+/* placeholder */
Modified: trunk/glibc-ports/kfreebsd/linuxthreads/allocrtsig.c
===================================================================
--- trunk/glibc-ports/kfreebsd/linuxthreads/allocrtsig.c 2006-10-16 08:50:05 UTC (rev 1685)
+++ trunk/glibc-ports/kfreebsd/linuxthreads/allocrtsig.c 2006-10-16 09:16:38 UTC (rev 1686)
@@ -1,4 +1,4 @@
-#include <sysdeps/generic/allocrtsig.c>
+#include <signal/allocrtsig.c>
strong_alias (__libc_current_sigrtmin, __libc_current_sigrtmin_private);
strong_alias (__libc_current_sigrtmax, __libc_current_sigrtmax_private);
strong_alias (__libc_allocate_rtsig, __libc_allocate_rtsig_private);
Modified: trunk/glibc-ports/kfreebsd/linuxthreads/pt-sigsuspend.S
===================================================================
--- trunk/glibc-ports/kfreebsd/linuxthreads/pt-sigsuspend.S 2006-10-16 08:50:05 UTC (rev 1685)
+++ trunk/glibc-ports/kfreebsd/linuxthreads/pt-sigsuspend.S 2006-10-16 09:16:38 UTC (rev 1686)
@@ -23,3 +23,7 @@
PSEUDO_NOERRNO(__pthread_sigsuspend, sigsuspend, 1)
ret_NOERRNO
PSEUDO_END_NOERRNO(__pthread_sigsuspend)
+
+PSEUDO(__syscall_sigsuspend, sigsuspend, 1)
+ ret
+PSEUDO_END(__syscall_sigsuspend)
Modified: trunk/glibc-ports/kfreebsd/not-cancel.h
===================================================================
--- trunk/glibc-ports/kfreebsd/not-cancel.h 2006-10-16 08:50:05 UTC (rev 1685)
+++ trunk/glibc-ports/kfreebsd/not-cancel.h 2006-10-16 09:16:38 UTC (rev 1686)
@@ -74,3 +74,15 @@
/* Uncancelable waitpid. */
# define waitpid_not_cancel(pid, stat_loc, options) \
INLINE_SYSCALL (wait4, 4, pid, stat_loc, options, NULL)
+
+/* Uncancelable pause. */
+# define pause_not_cancel() \
+ __pause_nocancel ()
+
+/* Uncancelable nanosleep. */
+# define nanosleep_not_cancel(requested_time, remaining) \
+ INLINE_SYSCALL (nanosleep, 2, requested_time, remaining)
+
+/* Uncancelable sigsuspend. */
+#define sigsuspend_not_cancel(set) \
+ INLINE_SYSCALL (sigsuspend, 1, set)
Added: trunk/glibc-ports/kfreebsd/sbrk.c
===================================================================
--- trunk/glibc-ports/kfreebsd/sbrk.c (rev 0)
+++ trunk/glibc-ports/kfreebsd/sbrk.c 2006-10-16 09:16:38 UTC (rev 1686)
@@ -0,0 +1 @@
+#include <misc/sbrk.c>
Modified: trunk/glibc-ports/kfreebsd/sigreturn.c
===================================================================
--- trunk/glibc-ports/kfreebsd/sigreturn.c 2006-10-16 08:50:05 UTC (rev 1685)
+++ trunk/glibc-ports/kfreebsd/sigreturn.c 2006-10-16 09:16:38 UTC (rev 1686)
@@ -1,3 +1,3 @@
/* The sigreturn syscall cannot be explicitly called on FreeBSD, only
implicitly by returning from a signal handler. */
-#include <sysdeps/generic/sigreturn.c>
+#include <signal/sigreturn.c>
Modified: trunk/glibc-ports/kfreebsd/syscalls-inline.h
===================================================================
--- trunk/glibc-ports/kfreebsd/syscalls-inline.h 2006-10-16 08:50:05 UTC (rev 1685)
+++ trunk/glibc-ports/kfreebsd/syscalls-inline.h 2006-10-16 09:16:38 UTC (rev 1686)
@@ -21,9 +21,12 @@
#define KFREEBSD_INLINE_SYSCALLS_H
#include <sys/types.h>
+#define __need_sigset_t
+#include <signal.h>
struct iovec;
struct rusage;
+struct timespec;
int __syscall_open(const char *path, int flags, ...);
int __syscall_close(int fd);
@@ -35,5 +38,7 @@
int __syscall_fcntl(int fd, int cmd, ...);
int __syscall_fork(void);
int __syscall_wait4(int pid, int *status, int options, struct rusage *rusage);
+int __syscall_sigsuspend (const sigset_t *set);
+int __syscall_nanosleep (const struct timespec *requested_time, struct timespec *remaining);
#endif
Modified: trunk/glibc-ports/kfreebsd/syscalls.list
===================================================================
--- trunk/glibc-ports/kfreebsd/syscalls.list 2006-10-16 08:50:05 UTC (rev 1685)
+++ trunk/glibc-ports/kfreebsd/syscalls.list 2006-10-16 09:16:38 UTC (rev 1686)
@@ -144,6 +144,8 @@
sys_connect - connect i:ipi __syscall_connect
sys_bind - bind i:ipi __syscall_bind
sys_sendto - sendto i:ibnibn __syscall_sendto
+sys_nanosleep EXTRA nanosleep i:pp __syscall_nanosleep
+sys_sigsuspend EXTRA sigsuspend i:p __syscall_sigsuspend
swapcontext - swapcontext i:pp __swapcontext swapcontext
swapon - swapon i:s swapon
swapoff - swapoff i:s swapoff
Modified: trunk/glibc-ports/kfreebsd/utmp-compat/utmp_file.c
===================================================================
--- trunk/glibc-ports/kfreebsd/utmp-compat/utmp_file.c 2006-10-16 08:50:05 UTC (rev 1685)
+++ trunk/glibc-ports/kfreebsd/utmp-compat/utmp_file.c 2006-10-16 09:16:38 UTC (rev 1686)
@@ -1 +1 @@
-#include <sysdeps/generic/utmp_file.c>
+#include <login/utmp_file.c>
Copied: trunk/glibc-ports/patches/ftw.patch (from rev 1685, trunk/glibc-2.3-head/glibc24-ftw.diff)
===================================================================
--- trunk/glibc-ports/patches/ftw.patch (rev 0)
+++ trunk/glibc-ports/patches/ftw.patch 2006-10-16 09:16:38 UTC (rev 1686)
@@ -0,0 +1,51 @@
+
+disable usage of unimplemented *at functions
+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
+
+
+--- io/ftw.c~ 2006-06-26 19:35:23.000000000 +0200
++++ io/ftw.c 2006-06-26 19:35:23.000000000 +0200
+@@ -338,6 +338,7 @@
+ {
+ assert (data->dirstreams[data->actdir] == NULL);
+
++#if 0
+ if (dfdp != NULL && *dfdp != -1)
+ {
+ int fd = openat64_not_cancel_3 (*dfdp, data->dirbuf + data->ftw.base,
+@@ -347,6 +348,7 @@
+ close_not_cancel_no_status (fd);
+ }
+ else
++#endif
+ {
+ const char *name = ((data->flags & FTW_CHDIR)
+ ? data->dirbuf + data->ftw.base: data->dirbuf);
+@@ -401,10 +403,12 @@
+ *((char *) __mempcpy (data->dirbuf + data->ftw.base, name, namlen)) = '\0';
+
+ int statres;
++#if 0
+ if (dir->streamfd != -1)
+ statres = FXSTATAT (_STAT_VER, dir->streamfd, name, &st,
+ (data->flags & FTW_PHYS) ? AT_SYMLINK_NOFOLLOW : 0);
+ else
++#endif
+ {
+ if ((data->flags & FTW_CHDIR) == 0)
+ name = data->dirbuf;
+@@ -424,10 +428,12 @@
+ flag = FTW_SLN;
+ else
+ {
++#if 0
+ if (dir->streamfd != -1)
+ statres = FXSTATAT (_STAT_VER, dir->streamfd, name, &st,
+ AT_SYMLINK_NOFOLLOW);
+ else
++#endif
+ statres = LXSTAT (_STAT_VER, name, &st);
+ if (statres == 0 && S_ISLNK (st.st_mode))
+ flag = FTW_SLN;
Copied: trunk/glibc-ports/patches/memusage_no_mremap.patch (from rev 1685, trunk/glibc-2.3-head/glibc24-memusage_no_mremap.diff)
===================================================================
--- trunk/glibc-ports/patches/memusage_no_mremap.patch (rev 0)
+++ trunk/glibc-ports/patches/memusage_no_mremap.patch 2006-10-16 09:16:38 UTC (rev 1686)
@@ -0,0 +1,19 @@
+--- 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 @@
+ return result;
+ }
+
++#include <_G_config.h>
++#ifdef _G_HAVE_MREMAP
+
+ /* `mmap' replacement. We do not have to keep track of the sizesince
+ `munmap' will get it as a parameter. */
+@@ -715,6 +717,7 @@
+ /* Return the pointer to the user buffer. */
+ return result;
+ }
++#endif
+
+
+ /* `munmap' replacement. */
Copied: trunk/glibc-ports/patches/pthread_at_fork.patch (from rev 1685, trunk/glibc-2.3-head/patches/pthread_at_fork.patch)
===================================================================
--- trunk/glibc-ports/patches/pthread_at_fork.patch (rev 0)
+++ trunk/glibc-ports/patches/pthread_at_fork.patch 2006-10-16 09:16:38 UTC (rev 1686)
@@ -0,0 +1,11 @@
+--- 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
+@@ -19,7 +19,7 @@
+
+ #include <shlib-compat.h>
+
+-#if SHLIB_COMPAT (libpthread, GLIBC_2_0, GLIBC_2_3)
++#if SHLIB_COMPAT (libpthread, GLIBC_2_0, GLIBC_2_3_2)
+ # define __pthread_atfork __dyn_pthread_atfork
+ # include "pthread_atfork.c"
+ # undef __pthread_atfork
Copied: trunk/glibc-ports/patches/readdir_r.patch (from rev 1685, trunk/glibc-2.3-head/patches/readdir_r.patch)
===================================================================
--- trunk/glibc-ports/patches/readdir_r.patch (rev 0)
+++ trunk/glibc-ports/patches/readdir_r.patch 2006-10-16 09:16:38 UTC (rev 1686)
@@ -0,0 +1,39 @@
+--- 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
+@@ -113,7 +113,35 @@
+ while (dp->d_ino == 0);
+
+ if (dp != NULL)
+- *result = memcpy (entry, dp, reclen);
++ {
++ /* The required size of *entry, according to POSIX, is
++ offsetof (DIRENT_TYPE, d_name[0]) + NAME_MAX + 1.
++ We must not write beyond the end of *entry. On some operating
++ systems, dp->d_reclen may be larger; in this case, copy only as
++ many bytes as needed. Also give an error if d_name is too long. */
++#ifdef _DIRENT_HAVE_D_RECLEN
++ /* DIRENT_TYPE is of variable size, with d_name as its last entry. */
++ size_t namelen;
++# ifdef _DIRENT_HAVE_D_NAMLEN
++ namelen = dp->d_namlen;
++# else
++ namelen = strlen (dp->d_name);
++# endif
++
++ if (namelen <= NAME_MAX)
++ *result = memcpy (entry, dp,
++ offsetof (DIRENT_TYPE, d_name[0]) + namelen + 1);
++ else
++ {
++ errno = EOVERFLOW;
++ dp = NULL;
++ *result = NULL;
++ }
++#else
++ /* DIRENT_TYPE is of fixed size. */
++ *result = memcpy (entry, dp, reclen);
++#endif
++ }
+ else
+ *result = NULL;
+
Copied: trunk/glibc-ports/patches/sys_queue_h.patch (from rev 1685, trunk/glibc-2.3-head/patches/sys_queue_h.patch)
===================================================================
--- trunk/glibc-ports/patches/sys_queue_h.patch (rev 0)
+++ trunk/glibc-ports/patches/sys_queue_h.patch 2006-10-16 09:16:38 UTC (rev 1686)
@@ -0,0 +1,921 @@
+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.
+
+(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_
+ #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 */
+
+ /*
+- * 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.
+ */
+ #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))
++
++#define SLIST_FOREACH_SAFE(var, head, field, tvar) \
++ for ((var) = SLIST_FIRST((head)); \
++ (var) && ((tvar) = SLIST_NEXT((var), field), 1); \
++ (var) = (tvar))
++
++#define SLIST_FOREACH_PREVPTR(var, varp, head, field) \
++ for ((varp) = &SLIST_FIRST((head)); \
++ ((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.
+ */
+-#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 */ \
+ }
+
+ #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_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)) { \
+ 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)
+
++#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); \
++ (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 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); \
++ (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_SAFE(var, head, headname, field, tvar) \
++ for ((var) = TAILQ_LAST((head), headname); \
++ (var) && ((tvar) = TAILQ_PREV((var), headname, field), 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_ */
Copied: trunk/glibc-ports/patches/undef-glibc.patch (from rev 1685, trunk/glibc-2.3-head/patches/undef-glibc.patch)
===================================================================
--- trunk/glibc-ports/patches/undef-glibc.patch (rev 0)
+++ trunk/glibc-ports/patches/undef-glibc.patch 2006-10-16 09:16:38 UTC (rev 1686)
@@ -0,0 +1,14 @@
+Description: #undef __GLIBC__ before defining it
+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 @@
+
+ /* 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
+
More information about the Glibc-bsd-commits
mailing list