* sysdeps/unix/sysv/linux/ia64/system.c: New file.
* sysdeps/unix/sysv/linux/kernel-features.h
(__ASSUME_CLONE_THREAD_FLAGS): Define for IA-64 and s390* with
kernel >= 2.5.64.
2003-03-11 Jakub Jelinek <jakub@redhat.com>
* sysdeps/unix/sysv/linux/powerpc/powerpc64/clone.S: Don't clobber R7.
+2003-03-11 Jakub Jelinek <jakub@redhat.com>
+
+ * sysdeps/unix/sysv/linux/ia64/system.c: New file.
+ * sysdeps/unix/sysv/linux/kernel-features.h
+ (__ASSUME_CLONE_THREAD_FLAGS): Define for IA-64 and s390* with
+ kernel >= 2.5.64.
+
2003-03-11 Jakub Jelinek <jakub@redhat.com>
* sysdeps/generic/dl-sysdep.c (_dl_important_hwcaps): If CNT == 1,
2003-03-10 Steven Munroe <sjmunroe@us.ibm.com>
- * sysdeps/unix/sysv/linux/powerpc/powerpc64/clone.S: Don't clobber R7.
+ * sysdeps/unix/sysv/linux/powerpc/powerpc64/clone.S: Don't clobber R7.
Copy extra params for NPTL to registers used in clone syscall.
2003-03-10 Martin Schwidefsky <schwidefsky@de.ibm.com>
(void) __libc_sigaction (SIGCANCEL, &sa, NULL);
+ /* The parent process might have left the signal blocked. Just in
+ case, unblock it. We reuse the signal mask in the sigaction
+ structure. It is already cleared. */
+ __sigaddset (&sa.sa_mask, SIGCANCEL);
+ (void) INTERNAL_SYSCALL (rt_sigprocmask, err, 4, SIG_UNBLOCK, &sa.sa_mask,
+ NULL, _NSIG / 8);
+
/* Determine the default allowed stack size. This is the size used
in case the user does not specify one. */
do \
__oldval = __val; \
while ((__val \
- = __arch_compare_and_exchange_32_val_acq (__memp, __oldval, \
- __oldval + __value)) \
+ = __arch_compare_and_exchange_32_val_acq (__memp, \
+ __oldval + __value, \
+ __oldval)) \
!= __oldval); \
else if (sizeof (*mem) == 8) \
do \
__oldval = __val; \
while ((__val \
- = __arch_compare_and_exchange_64_val_acq (__memp, __oldval, \
- __oldval + __value)) \
+ = __arch_compare_and_exchange_64_val_acq (__memp, \
+ __oldval + __value, \
+ __oldval)) \
!= __oldval); \
else \
abort (); \
{
struct _pthread_cleanup_buffer buffer;
struct _condvar_cleanup_buffer cbuffer;
- int result = 0, err;
+ int result = 0;
/* Catch invalid parameters. */
if (abstime->tv_nsec >= 1000000000)
lll_mutex_lock (cond->__data.__lock);
/* Now we can release the mutex. */
- err = __pthread_mutex_unlock_internal (mutex);
+ int err = __pthread_mutex_unlock_internal (mutex);
if (err)
{
lll_mutex_unlock (cond->__data.__lock);
while (1)
{
- int err;
-
/* Get the current time. So far we support only one clock. */
struct timeval tv;
(void) gettimeofday (&tv, NULL);
__pthread_cleanup_pop (&buffer, 0);
/* Get the mutex before returning. */
- __pthread_mutex_lock_internal (mutex);
+ err = __pthread_mutex_lock_internal (mutex);
- return result;
+ return err ?: result;
}
versioned_symbol (libpthread, __pthread_cond_timedwait, pthread_cond_timedwait,
__pthread_cleanup_pop (&buffer, 0);
/* Get the mutex before returning. */
- __pthread_mutex_lock_internal (mutex);
-
- return 0;
+ return __pthread_mutex_lock_internal (mutex);
}
versioned_symbol (libpthread, __pthread_cond_wait, pthread_cond_wait,
#include <sysdep.h>
#include <lowlevellock.h>
#include <internaltypes.h>
+#include <semaphore.h>
#include <shlib-compat.h>
#include <sysdep.h>
#include <lowlevellock.h>
#include <internaltypes.h>
+#include <semaphore.h>
#include <shlib-compat.h>
#include <sysdep.h>
#include <lowlevellock.h>
#include <internaltypes.h>
+#include <semaphore.h>
#include <shlib-compat.h>
#include <sysdep.h>
#include <lowlevellock.h>
#include <internaltypes.h>
+#include <semaphore.h>
#include <shlib-compat.h>
#include <sysdep.h>
#include <lowlevellock.h>
#include <internaltypes.h>
+#include <semaphore.h>
#include <shlib-compat.h>
#include <sysdep.h>
#include <lowlevellock.h>
#include <internaltypes.h>
+#include <semaphore.h>
#include <shlib-compat.h>
#include <sysdep.h>
#include <lowlevellock.h>
#include <internaltypes.h>
+#include <semaphore.h>
#include <shlib-compat.h>
#include <sysdep.h>
#include <lowlevellock.h>
#include <internaltypes.h>
+#include <semaphore.h>
#include <shlib-compat.h>
__nptl_main (void)
{
INTERNAL_SYSCALL_DECL (err);
- INTERNAL_SYSCALL (write, err, 3, STDOUT_FILENO, banner, sizeof banner - 1);
+ INTERNAL_SYSCALL (write, err, 3, STDOUT_FILENO, (const char *) banner,
+ sizeof banner - 1);
_exit (0);
}
--- /dev/null
+/* Copyright (C) 2002, 2003 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; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#include <sched.h>
+#include <signal.h>
+#include <sysdep.h>
+#include <unistd.h>
+#include <sys/wait.h>
+#include <bits/libc-lock.h>
+#include <kernel-features.h>
+
+/* We have to and actually can handle cancelable system(). The big
+ problem: we have to kill the child process if necessary. To do
+ this a cleanup handler has to be registered and is has to be able
+ to find the PID of the child. The main problem is to reliable have
+ the PID when needed. It is not necessary for the parent thread to
+ return. It might still be in the kernel when the cancellation
+ request comes. Therefore we have to use the clone() calls ability
+ to have the kernel write the PID into the user-level variable. */
+#ifdef __ASSUME_CLONE_THREAD_FLAGS
+# define FORK() \
+ INLINE_SYSCALL (clone2, 6, CLONE_PARENT_SETTID | SIGCHLD, NULL, 0, \
+ NULL, &pid, NULL)
+#endif
+
+static void cancel_handler (void *arg);
+
+#define CLEANUP_HANDLER \
+ __libc_cleanup_region_start (1, cancel_handler, &pid)
+
+#define CLEANUP_RESET \
+ __libc_cleanup_region_end (0)
+
+
+/* Linux has waitpid(), so override the generic unix version. */
+#include <sysdeps/posix/system.c>
+
+
+/* The cancellation handler. */
+static void
+cancel_handler (void *arg)
+{
+ pid_t child = *(pid_t *) arg;
+
+ INTERNAL_SYSCALL_DECL (err);
+ INTERNAL_SYSCALL (kill, err, 2, child, SIGKILL);
+
+ TEMP_FAILURE_RETRY (__waitpid (child, NULL, 0));
+
+ DO_LOCK ();
+
+ if (SUB_REF () == 0)
+ {
+ (void) __sigaction (SIGQUIT, &quit, (struct sigaction *) NULL);
+ (void) __sigaction (SIGINT, &intr, (struct sigaction *) NULL);
+ }
+
+ DO_UNLOCK ();
+}
#if __LINUX_KERNEL_VERSION >= 132415
# define __ASSUME_POSIX_TIMERS 1
#endif
+
+/* The late 2.5 kernels saw a lot of new CLONE_* flags. Summarize
+ their availability with one define. The changes were made first
+ for i386 and the have to be done separately for the other archs.
+ For ia64 and s390* we pick 2.5.64 as the first version with support. */
+#if __LINUX_KERNEL_VERSION >= 132416 \
+ && (defined __ia64__ || defined __s390__)
+# define __ASSUME_CLONE_THREAD_FLAGS 1
+#endif
git://sourceware.org / glibc.git / commitdiff