|
160
|
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, 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 }
|
