signal.c File Reference

#include <assert.h>
#include <signal.h>
#include "uv.h"
#include "internal.h"
#include "handle-inl.h"
#include "req-inl.h"

Go to the source code of this file.

Functions
	RB_HEAD (uv_signal_tree_s, uv_signal_s)
static BOOL WINAPI	uv__signal_control_handler (DWORD type)
int	uv__signal_start (uv_signal_t *handle, uv_signal_cb signal_cb, int signum, int oneshot)
void	uv_signals_init (void)
void	uv__signal_cleanup (void)
static int	uv__signal_compare (uv_signal_t *w1, uv_signal_t *w2)
int	uv__signal_dispatch (int signum)
int	uv_signal_init (uv_loop_t *loop, uv_signal_t *handle)
int	uv_signal_stop (uv_signal_t *handle)
int	uv_signal_start (uv_signal_t *handle, uv_signal_cb signal_cb, int signum)
int	uv_signal_start_oneshot (uv_signal_t *handle, uv_signal_cb signal_cb, int signum)
void	uv_process_signal_req (uv_loop_t *loop, uv_signal_t *handle, uv_req_t *req)
void	uv_signal_close (uv_loop_t *loop, uv_signal_t *handle)
void	uv_signal_endgame (uv_loop_t *loop, uv_signal_t *handle)

Variables
static struct uv_signal_tree_s	uv__signal_tree = RB_INITIALIZER(uv__signal_tree)
static CRITICAL_SECTION	uv__signal_lock

Function Documentation

RB_HEAD()

RB_HEAD	(	uv_signal_tree_s	,
		uv_signal_s
	)

uv__signal_cleanup()

void uv__signal_cleanup

(

void

)

Definition at line 49 of file signal.c.

                              {
  /* TODO(bnoordhuis) Undo effects of uv_signal_init()? */
}

uv__signal_compare()

static int uv__signal_compare ( uv_signal_t *  w1, uv_signal_t *  w2  )

static

Definition at line 54 of file signal.c.

                                                                {
  /* Compare signums first so all watchers with the same signnum end up
   * adjacent. */
  if (w1->signum < w2->signum) return -1;
  if (w1->signum > w2->signum) return 1;
 
  /* Sort by loop pointer, so we can easily look up the first item after
   * { .signum = x, .loop = NULL }. */
  if ((uintptr_t) w1->loop < (uintptr_t) w2->loop) return -1;
  if ((uintptr_t) w1->loop > (uintptr_t) w2->loop) return 1;
 
  if ((uintptr_t) w1 < (uintptr_t) w2) return -1;
  if ((uintptr_t) w1 > (uintptr_t) w2) return 1;
 
  return 0;
}

References w1, and w2.

uv__signal_control_handler()

static BOOL WINAPI uv__signal_control_handler ( DWORD  type )

static

Definition at line 116 of file signal.c.

                                                          {
  switch (type) {
    case CTRL_C_EVENT:
      return uv__signal_dispatch(SIGINT);
 
    case CTRL_BREAK_EVENT:
      return uv__signal_dispatch(SIGBREAK);
 
    case CTRL_CLOSE_EVENT:
      if (uv__signal_dispatch(SIGHUP)) {
        /* Windows will terminate the process after the control handler
         * returns. After that it will just terminate our process. Therefore
         * block the signal handler so the main loop has some time to pick up
         * the signal and do something for a few seconds. */
        Sleep(INFINITE);
        return TRUE;
      }
      return FALSE;
 
    case CTRL_LOGOFF_EVENT:
    case CTRL_SHUTDOWN_EVENT:
      /* These signals are only sent to services. Services have their own
       * notification mechanism, so there's no point in handling these. */
 
    default:
      /* We don't handle these. */
      return FALSE;
  }
}

References FALSE, SIGHUP, TRUE, type, and uv__signal_dispatch().

Referenced by uv_signals_init().

uv__signal_dispatch()

int uv__signal_dispatch

(

int

signum

)

Definition at line 80 of file signal.c.

                                    {
  uv_signal_t lookup;
  uv_signal_t* handle;
  int dispatched;
 
  dispatched = 0;
 
  EnterCriticalSection(&uv__signal_lock);
 
  lookup.signum = signum;
  lookup.loop = NULL;
 
  for (handle = RB_NFIND(uv_signal_tree_s, &uv__signal_tree, &lookup);
       handle != NULL && handle->signum == signum;
       handle = RB_NEXT(uv_signal_tree_s, &uv__signal_tree, handle)) {
    unsigned long previous = InterlockedExchange(
            (volatile LONG*) &handle->pending_signum, signum);
 
    if (handle->flags & UV_SIGNAL_ONE_SHOT_DISPATCHED)
      continue;
 
    if (!previous) {
      POST_COMPLETION_FOR_REQ(handle->loop, &handle->signal_req);
    }
 
    dispatched = 1;
    if (handle->flags & UV_SIGNAL_ONE_SHOT)
      handle->flags |= UV_SIGNAL_ONE_SHOT_DISPATCHED;
  }
 
  LeaveCriticalSection(&uv__signal_lock);
 
  return dispatched;
}

References handle, InterlockedExchange, LONG, NULL, POST_COMPLETION_FOR_REQ, RB_NEXT, RB_NFIND, signum, uv_signal_s::signum, uv__signal_lock, uv__signal_tree, UV_SIGNAL_ONE_SHOT, and UV_SIGNAL_ONE_SHOT_DISPATCHED.

Referenced by uv__signal_control_handler(), and uv__tty_console_signal_resize().

uv__signal_start()

int uv__signal_start	(	uv_signal_t *	handle,
		uv_signal_cb	signal_cb,
		int	signum,
		int	oneshot
	)

Definition at line 193 of file signal.c.

                                         {
  /* Test for invalid signal values. */
  if (signum <= 0 || signum >= NSIG)
    return UV_EINVAL;
 
  /* Short circuit: if the signal watcher is already watching {signum} don't go
   * through the process of deregistering and registering the handler.
   * Additionally, this avoids pending signals getting lost in the (small) time
   * frame that handle->signum == 0. */
  if (signum == handle->signum) {
    handle->signal_cb = signal_cb;
    return 0;
  }
 
  /* If the signal handler was already active, stop it first. */
  if (handle->signum != 0) {
    int r = uv_signal_stop(handle);
    /* uv_signal_stop is infallible. */
    assert(r == 0);
  }
 
  EnterCriticalSection(&uv__signal_lock);
 
  handle->signum = signum;
  if (oneshot)
    handle->flags |= UV_SIGNAL_ONE_SHOT;
 
  RB_INSERT(uv_signal_tree_s, &uv__signal_tree, handle);
 
  LeaveCriticalSection(&uv__signal_lock);
 
  handle->signal_cb = signal_cb;
  uv__handle_start(handle);
 
  return 0;
}

References assert(), handle, NSIG, oneshot(), r, RB_INSERT, signum, uv__handle_start, uv__signal_lock, uv__signal_tree, UV_SIGNAL_ONE_SHOT, and uv_signal_stop().

Referenced by uv_signal_start(), and uv_signal_start_oneshot().

uv_process_signal_req()

void uv_process_signal_req	(	uv_loop_t *	loop,
		uv_signal_t *	handle,
		uv_req_t *	req
	)

Definition at line 234 of file signal.c.

                   {
  long dispatched_signum;
 
  assert(handle->type == UV_SIGNAL);
  assert(req->type == UV_SIGNAL_REQ);
 
  dispatched_signum = InterlockedExchange(
          (volatile LONG*) &handle->pending_signum, 0);
  assert(dispatched_signum != 0);
 
  /* Check if the pending signal equals the signum that we are watching for.
   * These can get out of sync when the handler is stopped and restarted while
   * the signal_req is pending. */
  if (dispatched_signum == handle->signum)
    handle->signal_cb(handle, dispatched_signum);
 
  if (handle->flags & UV_SIGNAL_ONE_SHOT)
    uv_signal_stop(handle);
 
  if (handle->flags & UV_HANDLE_CLOSING) {
    /* When it is closing, it must be stopped at this point. */
    assert(handle->signum == 0);
    uv_want_endgame(loop, (uv_handle_t*) handle);
  }
}

References assert(), handle, InterlockedExchange, LONG, loop, req, UV_HANDLE_CLOSING, UV_SIGNAL_ONE_SHOT, uv_signal_stop(), and uv_want_endgame().

Referenced by uv_process_reqs().

uv_signal_close()

void uv_signal_close	(	uv_loop_t *	loop,
		uv_signal_t *	handle
	)

Definition at line 262 of file signal.c.

                                                           {
  uv_signal_stop(handle);
  uv__handle_closing(handle);
 
  if (handle->pending_signum == 0) {
    uv_want_endgame(loop, (uv_handle_t*) handle);
  }
}

References handle, loop, uv__handle_closing, uv_signal_stop(), and uv_want_endgame().

Referenced by uv_close().

uv_signal_endgame()

void uv_signal_endgame	(	uv_loop_t *	loop,
		uv_signal_t *	handle
	)

Definition at line 272 of file signal.c.

                                                             {
  assert(handle->flags & UV_HANDLE_CLOSING);
  assert(!(handle->flags & UV_HANDLE_CLOSED));
 
  assert(handle->signum == 0);
  assert(handle->pending_signum == 0);
 
  handle->flags |= UV_HANDLE_CLOSED;
 
  uv__handle_close(handle);
}

References assert(), handle, uv__handle_close, UV_HANDLE_CLOSED, and UV_HANDLE_CLOSING.

Referenced by uv_process_endgames().

uv_signal_init()

int uv_signal_init	(	uv_loop_t *	loop,
		uv_signal_t *	handle
	)

Definition at line 147 of file signal.c.

                                                         {
  uv__handle_init(loop, (uv_handle_t*) handle, UV_SIGNAL);
  handle->pending_signum = 0;
  handle->signum = 0;
  handle->signal_cb = NULL;
 
  UV_REQ_INIT(&handle->signal_req, UV_SIGNAL_REQ);
  handle->signal_req.data = handle;
 
  return 0;
}

References err, handle, loop, NULL, uv__handle_init, uv__signal_loop_once_init(), and UV_REQ_INIT.

Referenced by main(), thread1_worker(), thread2_worker(), and uv_loop_init().

uv_signal_start()

int uv_signal_start	(	uv_signal_t *	handle,
		uv_signal_cb	signal_cb,
		int	signum
	)

Definition at line 181 of file signal.c.

                                                                             {
  return uv__signal_start(handle, signal_cb, signum, 0);
}

References handle, signum, and uv__signal_start().

Referenced by main(), thread1_worker(), thread2_worker(), and uv_spawn().

uv_signal_start_oneshot()

int uv_signal_start_oneshot	(	uv_signal_t *	handle,
		uv_signal_cb	signal_cb,
		int	signum
	)

Definition at line 186 of file signal.c.

                                        {
  return uv__signal_start(handle, signal_cb, signum, 1);
}

References handle, signum, and uv__signal_start().

uv_signal_stop()

int uv_signal_stop

(

uv_signal_t *

handle

)

Definition at line 160 of file signal.c.

                                        {
  uv_signal_t* removed_handle;
 
  /* If the watcher wasn't started, this is a no-op. */
  if (handle->signum == 0)
    return 0;
 
  EnterCriticalSection(&uv__signal_lock);
 
  removed_handle = RB_REMOVE(uv_signal_tree_s, &uv__signal_tree, handle);
  assert(removed_handle == handle);
 
  LeaveCriticalSection(&uv__signal_lock);
 
  handle->signum = 0;
  uv__handle_stop(handle);
 
  return 0;
}

References assert(), handle, RB_REMOVE, uv__handle_stop, uv__is_closing, uv__signal_lock, uv__signal_stop(), and uv__signal_tree.

Referenced by signal_handler(), and uv__process_close().

uv_signals_init()

void uv_signals_init

(

void

)

Definition at line 42 of file signal.c.

                           {
  InitializeCriticalSection(&uv__signal_lock);
  if (!SetConsoleCtrlHandler(uv__signal_control_handler, TRUE))
    abort();
}

References TRUE, uv__signal_control_handler(), and uv__signal_lock.

Referenced by uv_init().

Variable Documentation

uv__signal_lock

CRITICAL_SECTION uv__signal_lock ( void  )

static

Definition at line 33 of file signal.c.

Referenced by uv__signal_dispatch(), uv__signal_start(), uv_signal_stop(), and uv_signals_init().

uv__signal_tree

struct uv_signal_tree_s uv__signal_tree = RB_INITIALIZER(uv__signal_tree)

static

Definition at line 30 of file signal.c.

Referenced by uv__signal_dispatch(), uv__signal_start(), and uv_signal_stop().