r6672 - in glibc-package/branches/glibc-2.21/debian: . patches/kfreebsd
Author: aurel32
Date: 2015-10-25 22:15:47 +0000 (Sun, 25 Oct 2015)
New Revision: 6672
Modified:
glibc-package/branches/glibc-2.21/debian/changelog
glibc-package/branches/glibc-2.21/debian/patches/kfreebsd/local-fbtl.diff
glibc-package/branches/glibc-2.21/debian/patches/kfreebsd/local-sysdeps.diff
Log:
patches/kfreebsd/local-sysdeps.diff, patches/kfreebsd/local-fbtl.diff: update to revision 5822 (from glibc-bsd).
Modified: glibc-package/branches/glibc-2.21/debian/changelog
===================================================================
--- glibc-package/branches/glibc-2.21/debian/changelog 2015-10-21 22:16:40 UTC (rev 6671)
+++ glibc-package/branches/glibc-2.21/debian/changelog 2015-10-25 22:15:47 UTC (rev 6672)
@@ -13,7 +13,7 @@
- testsuite-checking/expected-results-mips64el-linux-gnuabin32-mipsn32
- testsuite-checking/expected-results-mipsel-linux-gnu-mips32
* patches/kfreebsd/local-sysdeps.diff, patches/kfreebsd/local-fbtl.diff:
- update to revision 5819 (from glibc-bsd):
+ update to revision 5822 (from glibc-bsd):
- Update to glibc 2.21.
- Define F_DUP2FD_CLOEXEC. Closes: #712074.
- Define SOCK_CLOEXEC and SOCK_NONBLOCK.
Modified: glibc-package/branches/glibc-2.21/debian/patches/kfreebsd/local-fbtl.diff
===================================================================
--- glibc-package/branches/glibc-2.21/debian/patches/kfreebsd/local-fbtl.diff 2015-10-21 22:16:40 UTC (rev 6671)
+++ glibc-package/branches/glibc-2.21/debian/patches/kfreebsd/local-fbtl.diff 2015-10-25 22:15:47 UTC (rev 6672)
@@ -17550,7 +17550,7 @@
+ lll_futex_wake (&self->setxid_futex, 1, LLL_PRIVATE);
+
+ if (atomic_decrement_val (&__xidcmd->cntr) == 0)
-+ lll_futex_wake (&__xidcmd->cntr, 1, LLL_PRIVATE);
++ lll_futex_wake ((unsigned int *)&__xidcmd->cntr, 1, LLL_PRIVATE);
+}
+
+
@@ -31484,7 +31484,7 @@
+/* Initialize a recursive mutex. */
+#if defined _LIBC && (IS_IN (libc) || IS_IN (libpthread))
+# define __libc_lock_init_recursive(NAME) \
-+ ((NAME) = (__libc_lock_recursive_t) _LIBC_LOCK_RECURSIVE_INITIALIZER, 0)
++ ((void) ((NAME) = (__libc_lock_recursive_t) _LIBC_LOCK_RECURSIVE_INITIALIZER))
+#else
+# define __libc_lock_init_recursive(NAME) \
+ do { \
@@ -31608,221 +31608,6 @@
+
+#endif /* bits/libc-lock.h */
--- /dev/null
-+++ b/fbtl/sysdeps/pthread/bits/libc-lock.h.orig
-@@ -0,0 +1,192 @@
-+/* libc-internal interface for mutex locks. NPTL version.
-+ Copyright (C) 1996-2013 Free Software Foundation, Inc.
-+ This file is part of the GNU C Library.
-+
-+ The GNU C Library is free software; you can redistribute it and/or
-+ modify it under the terms of the GNU Lesser General Public License as
-+ published by the Free Software Foundation; either version 2.1 of the
-+ License, or (at your option) any later version.
-+
-+ The GNU C Library is distributed in the hope that it will be useful,
-+ but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-+ Lesser General Public License for more details.
-+
-+ You should have received a copy of the GNU Lesser General Public
-+ License along with the GNU C Library; see the file COPYING.LIB. If
-+ not, see <http://www.gnu.org/licenses/>. */
-+
-+#ifndef _BITS_LIBC_LOCK_H
-+#define _BITS_LIBC_LOCK_H 1
-+
-+#include <pthread.h>
-+#define __need_NULL
-+#include <stddef.h>
-+
-+
-+/* Mutex type. */
-+#if defined _LIBC || defined _IO_MTSAFE_IO
-+# if (!IS_IN (libc) && !IS_IN (libpthread)) || !defined _LIBC
-+typedef struct { pthread_mutex_t mutex; } __libc_lock_recursive_t;
-+# else
-+typedef struct { int lock; int cnt; void *owner; } __libc_lock_recursive_t;
-+# endif
-+#else
-+typedef struct __libc_lock_recursive_opaque__ __libc_lock_recursive_t;
-+#endif
-+
-+/* Define a lock variable NAME with storage class CLASS. The lock must be
-+ initialized with __libc_lock_init before it can be used (or define it
-+ with __libc_lock_define_initialized, below). Use `extern' for CLASS to
-+ declare a lock defined in another module. In public structure
-+ definitions you must use a pointer to the lock structure (i.e., NAME
-+ begins with a `*'), because its storage size will not be known outside
-+ of libc. */
-+#define __libc_lock_define_recursive(CLASS,NAME) \
-+ CLASS __libc_lock_recursive_t NAME;
-+
-+/* Define an initialized recursive lock variable NAME with storage
-+ class CLASS. */
-+#if defined _LIBC && (IS_IN (libc) || IS_IN (libpthread))
-+# if LLL_LOCK_INITIALIZER == 0
-+# define __libc_lock_define_initialized_recursive(CLASS,NAME) \
-+ CLASS __libc_lock_recursive_t NAME;
-+# else
-+# define __libc_lock_define_initialized_recursive(CLASS,NAME) \
-+ CLASS __libc_lock_recursive_t NAME = _LIBC_LOCK_RECURSIVE_INITIALIZER;
-+# endif
-+# define _LIBC_LOCK_RECURSIVE_INITIALIZER \
-+ { LLL_LOCK_INITIALIZER, 0, NULL }
-+#else
-+# define __libc_lock_define_initialized_recursive(CLASS,NAME) \
-+ CLASS __libc_lock_recursive_t NAME = _LIBC_LOCK_RECURSIVE_INITIALIZER;
-+# define _LIBC_LOCK_RECURSIVE_INITIALIZER \
-+ {PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP}
-+#endif
-+
-+/* Initialize a recursive mutex. */
-+#if defined _LIBC && (IS_IN (libc) || IS_IN (libpthread))
-+# define __libc_lock_init_recursive(NAME) \
-+ ((NAME) = (__libc_lock_recursive_t) _LIBC_LOCK_RECURSIVE_INITIALIZER, 0)
-+#else
-+# define __libc_lock_init_recursive(NAME) \
-+ do { \
-+ if (__pthread_mutex_init != NULL) \
-+ { \
-+ pthread_mutexattr_t __attr; \
-+ __pthread_mutexattr_init (&__attr); \
-+ __pthread_mutexattr_settype (&__attr, PTHREAD_MUTEX_RECURSIVE_NP); \
-+ __pthread_mutex_init (&(NAME).mutex, &__attr); \
-+ __pthread_mutexattr_destroy (&__attr); \
-+ } \
-+ } while (0)
-+#endif
-+
-+/* Finalize recursive named lock. */
-+#if defined _LIBC && (IS_IN (libc) || IS_IN (libpthread))
-+# define __libc_lock_fini_recursive(NAME) ((void) 0)
-+#else
-+# define __libc_lock_fini_recursive(NAME) \
-+ __libc_maybe_call (__pthread_mutex_destroy, (&(NAME)), 0)
-+#endif
-+
-+/* Lock the recursive named lock variable. */
-+#if defined _LIBC && (IS_IN (libc) || IS_IN (libpthread))
-+# define __libc_lock_lock_recursive(NAME) \
-+ do { \
-+ void *self = THREAD_SELF; \
-+ if ((NAME).owner != self) \
-+ { \
-+ lll_lock ((NAME).lock, LLL_PRIVATE); \
-+ (NAME).owner = self; \
-+ } \
-+ ++(NAME).cnt; \
-+ } while (0)
-+#else
-+# define __libc_lock_lock_recursive(NAME) \
-+ __libc_maybe_call (__pthread_mutex_lock, (&(NAME).mutex), 0)
-+#endif
-+
-+/* Try to lock the recursive named lock variable. */
-+#if defined _LIBC && (IS_IN (libc) || IS_IN (libpthread))
-+# define __libc_lock_trylock_recursive(NAME) \
-+ ({ \
-+ int result = 0; \
-+ void *self = THREAD_SELF; \
-+ if ((NAME).owner != self) \
-+ { \
-+ if (lll_trylock ((NAME).lock) == 0) \
-+ { \
-+ (NAME).owner = self; \
-+ (NAME).cnt = 1; \
-+ } \
-+ else \
-+ result = EBUSY; \
-+ } \
-+ else \
-+ ++(NAME).cnt; \
-+ result; \
-+ })
-+#else
-+# define __libc_lock_trylock_recursive(NAME) \
-+ __libc_maybe_call (__pthread_mutex_trylock, (&(NAME)), 0)
-+#endif
-+
-+/* Unlock the recursive named lock variable. */
-+#if defined _LIBC && (IS_IN (libc) || IS_IN (libpthread))
-+/* We do no error checking here. */
-+# define __libc_lock_unlock_recursive(NAME) \
-+ do { \
-+ if (--(NAME).cnt == 0) \
-+ { \
-+ (NAME).owner = NULL; \
-+ lll_unlock ((NAME).lock, LLL_PRIVATE); \
-+ } \
-+ } while (0)
-+#else
-+# define __libc_lock_unlock_recursive(NAME) \
-+ __libc_maybe_call (__pthread_mutex_unlock, (&(NAME)), 0)
-+#endif
-+
-+/* Note that for I/O cleanup handling we are using the old-style
-+ cancel handling. It does not have to be integrated with C++ since
-+ no C++ code is called in the middle. The old-style handling is
-+ faster and the support is not going away. */
-+extern void _pthread_cleanup_push_defer (struct _pthread_cleanup_buffer *buffer,
-+ void (*routine) (void *), void *arg);
-+extern void _pthread_cleanup_pop_restore (struct _pthread_cleanup_buffer *buffer,
-+ int execute);
-+
-+/* Start critical region with cleanup. */
-+#define __libc_cleanup_region_start(DOIT, FCT, ARG) \
-+ { struct _pthread_cleanup_buffer _buffer; \
-+ int _avail; \
-+ if (DOIT) { \
-+ _avail = PTFAVAIL (_pthread_cleanup_push_defer); \
-+ if (_avail) { \
-+ __libc_ptf_call_always (_pthread_cleanup_push_defer, (&_buffer, FCT, \
-+ ARG)); \
-+ } else { \
-+ _buffer.__routine = (FCT); \
-+ _buffer.__arg = (ARG); \
-+ } \
-+ } else { \
-+ _avail = 0; \
-+ }
-+
-+/* End critical region with cleanup. */
-+#define __libc_cleanup_region_end(DOIT) \
-+ if (_avail) { \
-+ __libc_ptf_call_always (_pthread_cleanup_pop_restore, (&_buffer, DOIT));\
-+ } else if (DOIT) \
-+ _buffer.__routine (_buffer.__arg); \
-+ }
-+
-+
-+/* Hide the definitions which are only supposed to be used inside libc in
-+ a separate file. This file is not present in the installation! */
-+#ifdef _LIBC
-+# include "libc-lockP.h"
-+#endif
-+
-+#endif /* bits/libc-lock.h */
---- /dev/null
-+++ b/fbtl/sysdeps/pthread/bits/libc-lock.h.rej
-@@ -0,0 +1,17 @@
-+--- sysdeps/pthread/bits/libc-lock.h
-++++ sysdeps/pthread/bits/libc-lock.h
-+@@ -48,13 +48,8 @@ typedef struct __libc_lock_recursive_opaque__ __libc_lock_recursive_t;
-+ /* Define an initialized recursive lock variable NAME with storage
-+ class CLASS. */
-+ #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
-+-# if LLL_LOCK_INITIALIZER == 0
-+-# define __libc_lock_define_initialized_recursive(CLASS,NAME) \
-+- CLASS __libc_lock_recursive_t NAME;
-+-# else
-+-# define __libc_lock_define_initialized_recursive(CLASS,NAME) \
-++# define __libc_lock_define_initialized_recursive(CLASS, NAME) \
-+ CLASS __libc_lock_recursive_t NAME = _LIBC_LOCK_RECURSIVE_INITIALIZER;
-+-# endif
-+ # define _LIBC_LOCK_RECURSIVE_INITIALIZER \
-+ { LLL_LOCK_INITIALIZER, 0, NULL }
-+ #else
---- /dev/null
+++ b/fbtl/sysdeps/pthread/bits/libc-lockP.h
@@ -0,0 +1,424 @@
+/* Private libc-internal interface for mutex locks. NPTL version.
@@ -31953,16 +31738,16 @@
+/* Initialize the named lock variable, leaving it in a consistent, unlocked
+ state. */
+#if IS_IN (libc) || IS_IN (libpthread)
-+# define __libc_lock_init(NAME) ((NAME) = LLL_LOCK_INITIALIZER, 0)
++# define __libc_lock_init(NAME) \
++ ((void) ((NAME) = LLL_LOCK_INITIALIZER))
+#else
+# define __libc_lock_init(NAME) \
+ __libc_maybe_call (__pthread_mutex_init, (&(NAME), NULL), 0)
+#endif
+#if defined SHARED && IS_IN (libc)
-+/* ((NAME) = (__libc_rwlock_t) PTHREAD_RWLOCK_INITIALIZER, 0) is
-+ inefficient. */
++/* ((NAME) = (__libc_rwlock_t) PTHREAD_RWLOCK_INITIALIZER) is inefficient. */
+# define __libc_rwlock_init(NAME) \
-+ (__builtin_memset (&(NAME), '\0', sizeof (NAME)), 0)
++ ((void) __builtin_memset (&(NAME), '\0', sizeof (NAME)))
+#else
+# define __libc_rwlock_init(NAME) \
+ __libc_maybe_call (__pthread_rwlock_init, (&(NAME), NULL), 0)
@@ -32331,7 +32116,7 @@
+#define _IO_lock_initializer { LLL_LOCK_INITIALIZER, 0, NULL }
+
+#define _IO_lock_init(_name) \
-+ ((_name) = (_IO_lock_t) _IO_lock_initializer , 0)
++ ((void) ((_name) = (_IO_lock_t) _IO_lock_initializer))
+
+#define _IO_lock_fini(_name) \
+ ((void) 0)
Modified: glibc-package/branches/glibc-2.21/debian/patches/kfreebsd/local-sysdeps.diff
===================================================================
--- glibc-package/branches/glibc-2.21/debian/patches/kfreebsd/local-sysdeps.diff 2015-10-21 22:16:40 UTC (rev 6671)
+++ glibc-package/branches/glibc-2.21/debian/patches/kfreebsd/local-sysdeps.diff 2015-10-25 22:15:47 UTC (rev 6672)
@@ -8521,7 +8521,7 @@
+#define GAI_MISC_NOTIFY(waitlist) \
+ do { \
+ if (*waitlist->counterp > 0 && --*waitlist->counterp == 0) \
-+ lll_futex_wake (waitlist->counterp, 1, LLL_PRIVATE); \
++ lll_futex_wake ((unsigned int *) waitlist->counterp, 1, LLL_PRIVATE); \
+ } while (0)
+
+#warning have to check sign of return values from futex wait calls
@@ -8542,8 +8542,8 @@
+ int status; \
+ do \
+ { \
-+ status = lll_futex_timed_wait (futexaddr, oldval, timeout, \
-+ LLL_PRIVATE); \
++ status = lll_futex_timed_wait ((unsigned int *) futexaddr, oldval,\
++ timeout, LLL_PRIVATE); \
+ if (status != EWOULDBLOCK) \
+ break; \
+ \
Reply to: