}
-#ifdef SIGSETXID
static void
setxid_mark_thread (struct xid_command *cmdp, struct pthread *t)
{
lll_unlock (stack_cache_lock, LLL_PRIVATE);
return result;
}
-#endif /* SIGSETXID. */
-
static inline void __attribute__((always_inline))
init_one_static_tls (struct pthread *curp, struct link_map *map)
.ptr_nthreads = &__nptl_nthreads,
.ptr___pthread_unwind = &__pthread_unwind,
.ptr__nptl_deallocate_tsd = __nptl_deallocate_tsd,
-# ifdef SIGSETXID
.ptr__nptl_setxid = __nptl_setxid,
-# endif
.ptr_set_robust = __nptl_set_robust
};
# define ptr_pthread_functions &pthread_functions
}
-#ifdef SIGCANCEL
/* For asynchronous cancellation we use a signal. This is the handler. */
static void
sigcancel_handler (int sig, siginfo_t *si, void *ctx)
oldval = curval;
}
}
-#endif
-#ifdef SIGSETXID
struct xid_command *__xidcmd attribute_hidden;
/* We use the SIGSETXID signal in the setuid, setgid, etc. implementations to
if (atomic_decrement_val (&__xidcmd->cntr) == 0)
futex_wake ((unsigned int *) &__xidcmd->cntr, 1, FUTEX_PRIVATE);
}
-#endif
/* When using __thread for this, we do it in libc so as not
had to set __nptl_initial_report_events. Propagate its setting. */
THREAD_SETMEM (pd, report_events, __nptl_initial_report_events);
-#if defined SIGCANCEL || defined SIGSETXID
struct sigaction sa;
__sigemptyset (&sa.sa_mask);
-# ifdef SIGCANCEL
/* Install the cancellation signal handler. If for some reason we
cannot install the handler we do not abort. Maybe we should, but
it is only asynchronous cancellation which is affected. */
sa.sa_sigaction = sigcancel_handler;
sa.sa_flags = SA_SIGINFO;
(void) __libc_sigaction (SIGCANCEL, &sa, NULL);
-# endif
-# ifdef SIGSETXID
/* Install the handle to change the threads' uid/gid. */
sa.sa_sigaction = sighandler_setxid;
sa.sa_flags = SA_SIGINFO | SA_RESTART;
(void) __libc_sigaction (SIGSETXID, &sa, NULL);
-# endif
/* The parent process might have left the signals blocked. Just in
case, unblock it. We reuse the signal mask in the sigaction
structure. It is already cleared. */
-# ifdef SIGCANCEL
__sigaddset (&sa.sa_mask, SIGCANCEL);
-# endif
-# ifdef SIGSETXID
__sigaddset (&sa.sa_mask, SIGSETXID);
-# endif
{
INTERNAL_SYSCALL_DECL (err);
(void) INTERNAL_SYSCALL (rt_sigprocmask, err, 4, SIG_UNBLOCK, &sa.sa_mask,
NULL, _NSIG / 8);
}
-#endif
/* Get the size of the static and alignment requirements for the TLS
block. */
oldval))
goto again;
-#ifdef SIGCANCEL
/* The cancellation handler will take care of marking the
thread as canceled. */
pid_t pid = __getpid ();
SIGCANCEL);
if (INTERNAL_SYSCALL_ERROR_P (val, err))
result = INTERNAL_SYSCALL_ERRNO (val, err);
-#else
- /* It should be impossible to get here at all, since
- pthread_setcanceltype should never have allowed
- PTHREAD_CANCEL_ASYNCHRONOUS to be set. */
- abort ();
-#endif
break;
}
}
#endif
-#ifdef SIGCANCEL
/* If the parent was running cancellation handlers while creating
the thread the new thread inherited the signal mask. Reset the
cancellation signal mask. */
(void) INTERNAL_SYSCALL (rt_sigprocmask, err, 4, SIG_UNBLOCK, &mask,
NULL, _NSIG / 8);
}
-#endif
/* This is where the try/finally block should be created. For
compilers without that support we do use setjmp. */
if (type < PTHREAD_CANCEL_DEFERRED || type > PTHREAD_CANCEL_ASYNCHRONOUS)
return EINVAL;
-#ifndef SIGCANCEL
- if (type == PTHREAD_CANCEL_ASYNCHRONOUS)
- return ENOTSUP;
-#endif
-
volatile struct pthread *self = THREAD_SELF;
int oldval = THREAD_GETMEM (self, cancelhandling);
-/* Examine and change blocked signals for a thread. Generic POSIX version.
- Copyright (C) 2014-2019 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2019 Free Software Foundation, Inc.
This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
#include <errno.h>
#include <signal.h>
#include <pthreadP.h>
+#include <sysdep.h>
-#if defined SIGCANCEL || defined SIGTIMER || defined SIGSETXID
-# error "This implementation assumes no internal-only signal numbers."
-#endif
int
pthread_sigmask (int how, const sigset_t *newmask, sigset_t *oldmask)
{
- /* Here we assume that sigprocmask actually does everything right.
- The only difference is the return value protocol. */
- int result = sigprocmask (how, newmask, oldmask);
- if (result < 0)
- result = errno;
- return result;
+ sigset_t local_newmask;
+
+ /* The only thing we have to make sure here is that SIGCANCEL and
+ SIGSETXID is not blocked. */
+ if (newmask != NULL
+ && (__builtin_expect (__sigismember (newmask, SIGCANCEL), 0)
+ || __builtin_expect (__sigismember (newmask, SIGSETXID), 0)))
+ {
+ local_newmask = *newmask;
+ __sigdelset (&local_newmask, SIGCANCEL);
+ __sigdelset (&local_newmask, SIGSETXID);
+ newmask = &local_newmask;
+ }
+
+#ifdef INTERNAL_SYSCALL
+ /* We know that realtime signals are available if NPTL is used. */
+ INTERNAL_SYSCALL_DECL (err);
+ int result = INTERNAL_SYSCALL (rt_sigprocmask, err, 4, how, newmask,
+ oldmask, _NSIG / 8);
+
+ return (INTERNAL_SYSCALL_ERROR_P (result, err)
+ ? INTERNAL_SYSCALL_ERRNO (result, err)
+ : 0);
+#else
+ return sigprocmask (how, newmask, oldmask) == -1 ? errno : 0;
+#endif
}
static void *
tf2 (void *arg)
{
-#ifdef SIGCANCEL
sigset_t mask;
if (pthread_sigmask (SIG_SETMASK, NULL, &mask) != 0)
{
puts ("SIGCANCEL blocked in new thread");
exit (1);
}
-#endif
/* Sync with the main thread so that we do not test anything else. */
int e = pthread_barrier_wait (&b);
{
int result = 0;
-#ifdef SIGCANCEL
errno = 0;
if (sigaction (SIGCANCEL, NULL, NULL) == 0)
{
puts ("sigaction(SIGCANCEL) did not set errno to EINVAL");
result = 1;
}
-#endif
-#ifdef SIGSETXID
errno = 0;
if (sigaction (SIGSETXID, NULL, NULL) == 0)
{
puts ("sigaction(SIGSETXID) did not set errno to EINVAL");
result = 1;
}
-#endif
return result;
}
#include <signal.h>
#include <nptl/pthreadP.h>
-/* Up to three special signals might be used privately by libpthread.
- Figure out how many unique ones are actually used. */
-
-#ifdef SIGCANCEL
-# define SIGCANCEL_CONSUMES 1
-#else
-# define SIGCANCEL_CONSUMES 0
-#endif
-
-#if defined SIGTIMER && (!defined SIGCANCEL || SIGTIMER != SIGCANCEL)
-# define SIGTIMER_CONSUMES 1
-#else
-# define SIGTIMER_CONSUMES 0
-#endif
-
-#if (defined SIGSETXID \
- && (!defined SIGCANCEL || SIGSETXID != SIGCANCEL) \
- && (!defined SIGTIMER || SIGSETXID != SIGTIMER))
-# define SIGSETXID_CONSUMES 1
-#else
-# define SIGSETXID_CONSUMES 0
+#if SIGTIMER != SIGCANCEL
+# error "SIGTIMER and SIGCANCEL must be the same"
#endif
/* This tells the generic code (included below) how many signal
- numbers need to be reserved for libpthread's private uses. */
-#define RESERVED_SIGRT \
- (SIGCANCEL_CONSUMES + SIGTIMER_CONSUMES + SIGSETXID_CONSUMES)
+ numbers need to be reserved for libpthread's private uses
+ (SIGCANCEL and SIGSETXID). */
+#define RESERVED_SIGRT 2
#include <signal/allocrtsig.c>
+++ /dev/null
-/* Copyright (C) 2002-2019 Free Software Foundation, Inc.
- This file is part of the GNU C Library.
- Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
-
- 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, see
- <https://www.gnu.org/licenses/>. */
-
-#include <errno.h>
-#include <signal.h>
-#include <pthreadP.h>
-#include <sysdep.h>
-
-
-int
-pthread_sigmask (int how, const sigset_t *newmask, sigset_t *oldmask)
-{
- sigset_t local_newmask;
-
- /* The only thing we have to make sure here is that SIGCANCEL and
- SIGSETXID is not blocked. */
- if (newmask != NULL
- && (__builtin_expect (__sigismember (newmask, SIGCANCEL), 0)
- || __builtin_expect (__sigismember (newmask, SIGSETXID), 0)))
- {
- local_newmask = *newmask;
- __sigdelset (&local_newmask, SIGCANCEL);
- __sigdelset (&local_newmask, SIGSETXID);
- newmask = &local_newmask;
- }
-
-#ifdef INTERNAL_SYSCALL
- /* We know that realtime signals are available if NPTL is used. */
- INTERNAL_SYSCALL_DECL (err);
- int result = INTERNAL_SYSCALL (rt_sigprocmask, err, 4, how, newmask,
- oldmask, _NSIG / 8);
-
- return (INTERNAL_SYSCALL_ERROR_P (result, err)
- ? INTERNAL_SYSCALL_ERRNO (result, err)
- : 0);
-#else
- return sigprocmask (how, newmask, oldmask) == -1 ? errno : 0;
-#endif
-}
projects / thirdparty / glibc.git / commitdiff
