-/* Copyright (C) 1991,92,93,94,95,96,97,98,99,2000,01
+/* Copyright (C) 1991,92,93,94,95,96,97,98,99,2000,2001,2002,2005,2008
Free Software Foundation, Inc.
This file is part of the GNU C Library.
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. */
+ License along with the GNU C Library; if not, see
+ <http://www.gnu.org/licenses/>. */
#include <stdio.h>
#include <stdlib.h>
#include "hurdfault.h"
#include "hurdmalloc.h" /* XXX */
+#include "../locale/localeinfo.h"
const char *_hurdsig_getenv (const char *);
#include <setjmp.h>
#include <fcntl.h>
#include <sys/wait.h>
-#include "thread_state.h"
+#include <thread_state.h>
#include <hurd/msg_server.h>
#include <hurd/msg_reply.h> /* For __msg_sig_post_reply. */
#include <hurd/interrupt.h>
if (! err && file != MACH_PORT_NULL)
/* The core dump into FILE succeeded, so now link it into the
directory. */
- err = __dir_link (file, coredir, name, 1);
+ err = __dir_link (coredir, file, name, 1);
__mach_port_deallocate (__mach_task_self (), file);
__mach_port_deallocate (__mach_task_self (), coredir);
return !err && file != MACH_PORT_NULL;
}
\f
#include <hurd/sigpreempt.h>
-#include "intr-msg.h"
+#include <intr-msg.h>
/* Timeout on interrupt_operation calls. */
mach_msg_timeout_t _hurdsig_interrupt_timeout = 1000;
handler = ss->preemptors ? try_preemptor (ss->preemptors) : SIG_ERR;
/* If no thread-specific preemptor, check for a global one. */
- if (handler == SIG_ERR && (__sigmask (signo) & _hurdsig_preempted_set))
+ if (handler == SIG_ERR && __sigismember (&_hurdsig_preempted_set, signo))
{
__mutex_lock (&_hurd_siglock);
handler = try_preemptor (_hurdsig_preemptors);
if (__sigmask (signo) & STOPSIGS)
/* Stop signals clear a pending SIGCONT even if they
are handled or ignored (but not if preempted). */
- ss->pending &= ~sigmask (SIGCONT);
+ __sigdelset (&ss->pending, SIGCONT);
else
{
if (signo == SIGCONT)
break;
case ignore:
+ if (detail->exc)
+ /* Blocking or ignoring a machine exception is fatal.
+ Otherwise we could just spin on the faulting instruction. */
+ goto fatal;
+
/* Nobody cares about this signal. If there was a call to resume
above in SIGCONT processing and we've left a thread suspended,
now's the time to set it going. */
Nothing to do but die; BSD gets SIGILL in this case. */
detail->code = signo; /* XXX ? */
signo = SIGILL;
+
+ fatal:
act = core;
/* FALLTHROUGH */
/* Block requested signals while running the handler. */
scp->sc_mask = ss->blocked;
- ss->blocked |= ss->actions[signo].sa_mask;
+ __sigorset (&ss->blocked, &ss->blocked, &ss->actions[signo].sa_mask);
/* Also block SIGNO unless we're asked not to. */
if (! (ss->actions[signo].sa_flags & (SA_RESETHAND | SA_NODEFER)))
- ss->blocked |= __sigmask (signo);
+ __sigaddset (&ss->blocked, signo);
/* Reset to SIG_DFL if requested. SIGILL and SIGTRAP cannot
be automatically reset when delivered; the system silently
msg.msgh_local_port = MACH_PORT_NULL;
/* These values do not matter. */
msg.msgh_id = 8675309; /* Jenny, Jenny. */
- msg.msgh_seqno = 17; /* Random. */
ss->suspended = MACH_PORT_NULL;
err = __mach_msg (&msg, MACH_SEND_MSG, sizeof msg, 0,
MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE,
}
_hurd_port_free (&_hurd_dtable[d]->port, &ulink, port);
}
+ __mutex_unlock (&_hurd_dtable_lock);
/* If we found a lucky winner, we've set D to -1 in the loop. */
if (lucky)
goto win;
malloc (__hurd_threadvar_max * sizeof (unsigned long int));
if (__hurd_sigthread_variables == NULL)
__libc_fatal ("hurd: Can't allocate threadvars for signal thread\n");
+ memset (__hurd_sigthread_variables, 0,
+ __hurd_threadvar_max * sizeof (unsigned long int));
+ __hurd_sigthread_variables[_HURD_THREADVAR_LOCALE]
+ = (unsigned long int) &_nl_global_locale;
/* Reinitialize the MiG support routines so they will use a per-thread
variable for the cached reply port. */
}
/* Receive exceptions on the signal port. */
+#ifdef TASK_EXCEPTION_PORT
__task_set_special_port (__mach_task_self (),
TASK_EXCEPTION_PORT, _hurd_msgport);
+#elif defined (EXC_MASK_ALL)
+ __task_set_exception_ports (__mach_task_self (),
+ EXC_MASK_ALL & ~(EXC_MASK_SYSCALL
+ | EXC_MASK_MACH_SYSCALL
+ | EXC_MASK_RPC_ALERT),
+ _hurd_msgport,
+ EXCEPTION_DEFAULT, MACHINE_THREAD_STATE);
+#else
+# error task_set_exception_port?
+#endif
/* Sanity check. Any pending, unblocked signals should have been
taken by our predecessor incarnation (i.e. parent or pre-exec state)
const char *
_hurdsig_getenv (const char *variable)
{
+ if (__libc_enable_secure)
+ return NULL;
+
if (_hurdsig_catch_memory_fault (__environ))
/* We bombed in getenv. */
return NULL;