ss->blocked = intarray[INIT_SIGPENDING];
ss->pending = intarray[INIT_SIGPENDING];
_hurdsig_init (const int *intarray, size_t intarraysize){  error_t err;  vm_size_t stacksize;  struct hurd_sigstate *ss;  __mutex_init (&_hurd_siglock);  err = __mach_port_allocate (__mach_task_self (),			      MACH_PORT_RIGHT_RECEIVE,			      &_hurd_msgport);  assert_perror (err);  /* Make a send right to the signal port.  */  err = __mach_port_insert_right (__mach_task_self (),				  _hurd_msgport,				  _hurd_msgport,				  MACH_MSG_TYPE_MAKE_SEND);  assert_perror (err);  /* Initialize the main thread's signal state.  */  ss = _hurd_self_sigstate ();  /* Copy inherited values from our parent (or pre-exec process state)     into the signal settings of the main thread.  */  if (intarraysize > INIT_SIGMASK)    ss->blocked = intarray[INIT_SIGMASK];  if (intarraysize > INIT_SIGPENDING)    ss->blocked = intarray[INIT_SIGPENDING];  if (intarraysize > INIT_SIGIGN && intarray[INIT_SIGIGN] != 0)    {      int signo;      for (signo = 1; signo < NSIG; ++signo)	if (intarray[INIT_SIGIGN] & __sigmask(signo))	  ss->actions[signo].sa_handler = SIG_IGN;    }  /* Set the default thread to receive task-global signals     to this one, the main (first) user thread.  */  _hurd_sigthread = ss->thread;  /* Start the signal thread listening on the message port.  */  if (__hurd_threadvar_stack_mask == 0)    {      err = __thread_create (__mach_task_self (), &_hurd_msgport_thread);      assert_perror (err);      stacksize = __vm_page_size * 8; /* Small stack for signal thread.  */      err = __mach_setup_thread (__mach_task_self (), _hurd_msgport_thread,				 _hurd_msgport_receive,				 (vm_address_t *) &__hurd_sigthread_stack_base,				 &stacksize);      assert_perror (err);      __hurd_sigthread_stack_end = __hurd_sigthread_stack_base + stacksize;      __hurd_sigthread_variables =	malloc (__hurd_threadvar_max * sizeof (unsigned long int));      if (__hurd_sigthread_variables == NULL)	__libc_fatal ("hurd: Can't allocate threadvars for signal thread\n");      /* Reinitialize the MiG support routines so they will use a per-thread	 variable for the cached reply port.  */      __mig_init ((void *) __hurd_sigthread_stack_base);      err = __thread_resume (_hurd_msgport_thread);      assert_perror (err);    }  else    {      /* When cthreads is being used, we need to make the signal thread a         proper cthread.  Otherwise it cannot use mutex_lock et al, which         will be the cthreads versions.  Various of the message port RPC         handlers need to take locks, so we need to be able to call into         cthreads code and meet its assumptions about how our thread and         its stack are arranged.  Since cthreads puts it there anyway,         we'll let the signal thread's per-thread variables be found as for         any normal cthread, and just leave the magic __hurd_sigthread_*         values all zero so they'll be ignored.  */#pragma weak cthread_fork#pragma weak cthread_detach      cthread_detach (cthread_fork ((cthread_fn_t) &_hurd_msgport_receive, 0));      /* XXX We need the thread port for the signal thread further on         in this thread (see hurdfault.c:_hurdsigfault_init).         Therefore we block until _hurd_msgport_thread is initialized         by the newly created thread.  This really shouldn't be         necessary; we should be able to fetch the thread port for a         cthread from here.  */      while (_hurd_msgport_thread == 0)	__swtch_pri (0);    }  /* Receive exceptions on the signal port.  */  __task_set_special_port (__mach_task_self (),			   TASK_EXCEPTION_PORT, _hurd_msgport);  /* Sanity check.  Any pending, unblocked signals should have been     taken by our predecessor incarnation (i.e. parent or pre-exec state)     before packing up our init ints.  This assert is last (not above)     so that signal handling is all set up to handle the abort.  */  assert ((ss->pending &~ ss->blocked) == 0);}