Utilities/cmlibuv/src/win/signal.c

   1 /* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
   2  * Permission is hereby granted, free of charge, to any person obtaining a copy
   3  * of this software and associated documentation files (the "Software"), to
   4  * deal in the Software without restriction, including without limitation the
   5  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
   6  * sell copies of the Software, and to permit persons to whom the Software is
   7  * furnished to do so, subject to the following conditions:
   8  *
   9  * The above copyright notice and this permission notice shall be included in
  10  * all copies or substantial portions of the Software.
  11  *
  12  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  13  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  14  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  15  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  16  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  17  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  18  * IN THE SOFTWARE.
  19  */
  20
  21 #include <assert.h>
  22 #include <signal.h>
  23
  24 #include "uv.h"
  25 #include "internal.h"
  26 #include "handle-inl.h"
  27 #include "req-inl.h"
  28
  29
  30 RB_HEAD(uv_signal_tree_s, uv_signal_s);
  31
  32 static struct uv_signal_tree_s uv__signal_tree = RB_INITIALIZER(uv__signal_tree);
  33 static CRITICAL_SECTION uv__signal_lock;
  34
  35 static BOOL WINAPI uv__signal_control_handler(DWORD type);
  36
  37 int uv__signal_start(uv_signal_t* handle,
  38                      uv_signal_cb signal_cb,
  39                      int signum,
  40                      int oneshot);
  41
  42 void uv__signals_init(void) {
  43   InitializeCriticalSection(&uv__signal_lock);
  44   if (!SetConsoleCtrlHandler(uv__signal_control_handler, TRUE))
  45     abort();
  46 }
  47
  48
  49 void uv__signal_cleanup(void) {
  50   /* TODO(bnoordhuis) Undo effects of uv_signal_init()? */
  51 }
  52
  53
  54 static int uv__signal_compare(uv_signal_t* w1, uv_signal_t* w2) {
  55   /* Compare signums first so all watchers with the same signnum end up
  56    * adjacent. */
  57   if (w1->signum < w2->signum) return -1;
  58   if (w1->signum > w2->signum) return 1;
  59
  60   /* Sort by loop pointer, so we can easily look up the first item after
  61    * { .signum = x, .loop = NULL }. */
  62   if ((uintptr_t) w1->loop < (uintptr_t) w2->loop) return -1;
  63   if ((uintptr_t) w1->loop > (uintptr_t) w2->loop) return 1;
  64
  65   if ((uintptr_t) w1 < (uintptr_t) w2) return -1;
  66   if ((uintptr_t) w1 > (uintptr_t) w2) return 1;
  67
  68   return 0;
  69 }
  70
  71
  72 RB_GENERATE_STATIC(uv_signal_tree_s, uv_signal_s, tree_entry, uv__signal_compare)
  73
  74
  75 /*
  76  * Dispatches signal {signum} to all active uv_signal_t watchers in all loops.
  77  * Returns 1 if the signal was dispatched to any watcher, or 0 if there were
  78  * no active signal watchers observing this signal.
  79  */
  80 int uv__signal_dispatch(int signum) {
  81   uv_signal_t lookup;
  82   uv_signal_t* handle;
  83   int dispatched;
  84
  85   dispatched = 0;
  86
  87   EnterCriticalSection(&uv__signal_lock);
  88
  89   lookup.signum = signum;
  90   lookup.loop = NULL;
  91
  92   for (handle = RB_NFIND(uv_signal_tree_s, &uv__signal_tree, &lookup);
  93        handle != NULL && handle->signum == signum;
  94        handle = RB_NEXT(uv_signal_tree_s, &uv__signal_tree, handle)) {
  95     unsigned long previous = InterlockedExchange(
  96             (volatile LONG*) &handle->pending_signum, signum);
  97
  98     if (handle->flags & UV_SIGNAL_ONE_SHOT_DISPATCHED)
  99       continue;
 100
 101     if (!previous) {
 102       POST_COMPLETION_FOR_REQ(handle->loop, &handle->signal_req);
 103     }
 104
 105     dispatched = 1;
 106     if (handle->flags & UV_SIGNAL_ONE_SHOT)
 107       handle->flags |= UV_SIGNAL_ONE_SHOT_DISPATCHED;
 108   }
 109
 110   LeaveCriticalSection(&uv__signal_lock);
 111
 112   return dispatched;
 113 }
 114
 115
 116 static BOOL WINAPI uv__signal_control_handler(DWORD type) {
 117   switch (type) {
 118     case CTRL_C_EVENT:
 119       return uv__signal_dispatch(SIGINT);
 120
 121     case CTRL_BREAK_EVENT:
 122       return uv__signal_dispatch(SIGBREAK);
 123
 124     case CTRL_CLOSE_EVENT:
 125       if (uv__signal_dispatch(SIGHUP)) {
 126         /* Windows will terminate the process after the control handler
 127          * returns. After that it will just terminate our process. Therefore
 128          * block the signal handler so the main loop has some time to pick up
 129          * the signal and do something for a few seconds. */
 130         Sleep(INFINITE);
 131         return TRUE;
 132       }
 133       return FALSE;
 134
 135     case CTRL_LOGOFF_EVENT:
 136     case CTRL_SHUTDOWN_EVENT:
 137       /* These signals are only sent to services. Services have their own
 138        * notification mechanism, so there's no point in handling these. */
 139
 140     default:
 141       /* We don't handle these. */
 142       return FALSE;
 143   }
 144 }
 145
 146
 147 int uv_signal_init(uv_loop_t* loop, uv_signal_t* handle) {
 148   uv__handle_init(loop, (uv_handle_t*) handle, UV_SIGNAL);
 149   handle->pending_signum = 0;
 150   handle->signum = 0;
 151   handle->signal_cb = NULL;
 152
 153   UV_REQ_INIT(&handle->signal_req, UV_SIGNAL_REQ);
 154   handle->signal_req.data = handle;
 155
 156   return 0;
 157 }
 158
 159
 160 int uv_signal_stop(uv_signal_t* handle) {
 161   uv_signal_t* removed_handle;
 162
 163   /* If the watcher wasn't started, this is a no-op. */
 164   if (handle->signum == 0)
 165     return 0;
 166
 167   EnterCriticalSection(&uv__signal_lock);
 168
 169   removed_handle = RB_REMOVE(uv_signal_tree_s, &uv__signal_tree, handle);
 170   assert(removed_handle == handle);
 171
 172   LeaveCriticalSection(&uv__signal_lock);
 173
 174   handle->signum = 0;
 175   uv__handle_stop(handle);
 176
 177   return 0;
 178 }
 179
 180
 181 int uv_signal_start(uv_signal_t* handle, uv_signal_cb signal_cb, int signum) {
 182   return uv__signal_start(handle, signal_cb, signum, 0);
 183 }
 184
 185
 186 int uv_signal_start_oneshot(uv_signal_t* handle,
 187                             uv_signal_cb signal_cb,
 188                             int signum) {
 189   return uv__signal_start(handle, signal_cb, signum, 1);
 190 }
 191
 192
 193 int uv__signal_start(uv_signal_t* handle,
 194                             uv_signal_cb signal_cb,
 195                             int signum,
 196                             int oneshot) {
 197   /* Test for invalid signal values. */
 198   if (signum <= 0 || signum >= NSIG)
 199     return UV_EINVAL;
 200
 201   /* Short circuit: if the signal watcher is already watching {signum} don't go
 202    * through the process of deregistering and registering the handler.
 203    * Additionally, this avoids pending signals getting lost in the (small) time
 204    * frame that handle->signum == 0. */
 205   if (signum == handle->signum) {
 206     handle->signal_cb = signal_cb;
 207     return 0;
 208   }
 209
 210   /* If the signal handler was already active, stop it first. */
 211   if (handle->signum != 0) {
 212     int r = uv_signal_stop(handle);
 213     /* uv_signal_stop is infallible. */
 214     assert(r == 0);
 215   }
 216
 217   EnterCriticalSection(&uv__signal_lock);
 218
 219   handle->signum = signum;
 220   if (oneshot)
 221     handle->flags |= UV_SIGNAL_ONE_SHOT;
 222
 223   RB_INSERT(uv_signal_tree_s, &uv__signal_tree, handle);
 224
 225   LeaveCriticalSection(&uv__signal_lock);
 226
 227   handle->signal_cb = signal_cb;
 228   uv__handle_start(handle);
 229
 230   return 0;
 231 }
 232
 233
 234 void uv__process_signal_req(uv_loop_t* loop, uv_signal_t* handle,
 235     uv_req_t* req) {
 236   long dispatched_signum;
 237
 238   assert(handle->type == UV_SIGNAL);
 239   assert(req->type == UV_SIGNAL_REQ);
 240
 241   dispatched_signum = InterlockedExchange(
 242           (volatile LONG*) &handle->pending_signum, 0);
 243   assert(dispatched_signum != 0);
 244
 245   /* Check if the pending signal equals the signum that we are watching for.
 246    * These can get out of sync when the handler is stopped and restarted while
 247    * the signal_req is pending. */
 248   if (dispatched_signum == handle->signum)
 249     handle->signal_cb(handle, dispatched_signum);
 250
 251   if (handle->flags & UV_SIGNAL_ONE_SHOT)
 252     uv_signal_stop(handle);
 253
 254   if (handle->flags & UV_HANDLE_CLOSING) {
 255     /* When it is closing, it must be stopped at this point. */
 256     assert(handle->signum == 0);
 257     uv__want_endgame(loop, (uv_handle_t*) handle);
 258   }
 259 }
 260
 261
 262 void uv__signal_close(uv_loop_t* loop, uv_signal_t* handle) {
 263   uv_signal_stop(handle);
 264   uv__handle_closing(handle);
 265
 266   if (handle->pending_signum == 0) {
 267     uv__want_endgame(loop, (uv_handle_t*) handle);
 268   }
 269 }
 270
 271
 272 void uv__signal_endgame(uv_loop_t* loop, uv_signal_t* handle) {
 273   assert(handle->flags & UV_HANDLE_CLOSING);
 274   assert(!(handle->flags & UV_HANDLE_CLOSED));
 275
 276   assert(handle->signum == 0);
 277   assert(handle->pending_signum == 0);
 278
 279   handle->flags |= UV_HANDLE_CLOSED;
 280
 281   uv__handle_close(handle);
 282 }