|
160
|
1 /* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
|
|
|
2 *
|
|
|
3 * Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
4 * of this software and associated documentation files (the "Software"), to
|
|
|
5 * deal in the Software without restriction, including without limitation the
|
|
|
6 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
|
7 * sell copies of the Software, and to permit persons to whom the Software is
|
|
|
8 * furnished to do so, subject to the following conditions:
|
|
|
9 *
|
|
|
10 * The above copyright notice and this permission notice shall be included in
|
|
|
11 * all copies or substantial portions of the Software.
|
|
|
12 *
|
|
|
13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
14 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
15 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
16 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
17 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
18 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
|
19 * IN THE SOFTWARE.
|
|
|
20 */
|
|
|
21
|
|
|
22 #include "uv.h"
|
|
|
23 #include "task.h"
|
|
|
24
|
|
|
25 #ifdef _WIN32
|
|
|
26 # define putenv _putenv
|
|
|
27 #endif
|
|
|
28
|
|
|
29 #define INIT_CANCEL_INFO(ci, what) \
|
|
|
30 do { \
|
|
|
31 (ci)->reqs = (what); \
|
|
|
32 (ci)->nreqs = ARRAY_SIZE(what); \
|
|
|
33 (ci)->stride = sizeof((what)[0]); \
|
|
|
34 } \
|
|
|
35 while (0)
|
|
|
36
|
|
|
37 struct cancel_info {
|
|
|
38 void* reqs;
|
|
|
39 unsigned nreqs;
|
|
|
40 unsigned stride;
|
|
|
41 uv_timer_t timer_handle;
|
|
|
42 };
|
|
|
43
|
|
|
44 struct random_info {
|
|
|
45 uv_random_t random_req;
|
|
|
46 char buf[1];
|
|
|
47 };
|
|
|
48
|
|
|
49 static unsigned fs_cb_called;
|
|
|
50 static unsigned done_cb_called;
|
|
|
51 static unsigned done2_cb_called;
|
|
|
52 static unsigned timer_cb_called;
|
|
|
53 static uv_work_t pause_reqs[4];
|
|
|
54 static uv_sem_t pause_sems[ARRAY_SIZE(pause_reqs)];
|
|
|
55
|
|
|
56
|
|
|
57 static void work_cb(uv_work_t* req) {
|
|
|
58 uv_sem_wait(pause_sems + (req - pause_reqs));
|
|
|
59 }
|
|
|
60
|
|
|
61
|
|
|
62 static void done_cb(uv_work_t* req, int status) {
|
|
|
63 uv_sem_destroy(pause_sems + (req - pause_reqs));
|
|
|
64 }
|
|
|
65
|
|
|
66
|
|
|
67 static void saturate_threadpool(void) {
|
|
|
68 uv_loop_t* loop;
|
|
|
69 char buf[64];
|
|
|
70 size_t i;
|
|
|
71
|
|
|
72 snprintf(buf,
|
|
|
73 sizeof(buf),
|
|
|
74 "UV_THREADPOOL_SIZE=%lu",
|
|
|
75 (unsigned long)ARRAY_SIZE(pause_reqs));
|
|
|
76 putenv(buf);
|
|
|
77
|
|
|
78 loop = uv_default_loop();
|
|
|
79 for (i = 0; i < ARRAY_SIZE(pause_reqs); i += 1) {
|
|
|
80 ASSERT_OK(uv_sem_init(pause_sems + i, 0));
|
|
|
81 ASSERT_OK(uv_queue_work(loop, pause_reqs + i, work_cb, done_cb));
|
|
|
82 }
|
|
|
83 }
|
|
|
84
|
|
|
85
|
|
|
86 static void unblock_threadpool(void) {
|
|
|
87 size_t i;
|
|
|
88
|
|
|
89 for (i = 0; i < ARRAY_SIZE(pause_reqs); i += 1)
|
|
|
90 uv_sem_post(pause_sems + i);
|
|
|
91 }
|
|
|
92
|
|
|
93
|
|
|
94 static int known_broken(uv_req_t* req) {
|
|
|
95 if (req->type != UV_FS)
|
|
|
96 return 0;
|
|
|
97
|
|
|
98 #ifdef __linux__
|
|
|
99 /* TODO(bnoordhuis) make cancellation work with io_uring */
|
|
|
100 switch (((uv_fs_t*) req)->fs_type) {
|
|
|
101 case UV_FS_CLOSE:
|
|
|
102 case UV_FS_FDATASYNC:
|
|
|
103 case UV_FS_FSTAT:
|
|
|
104 case UV_FS_FSYNC:
|
|
|
105 case UV_FS_LINK:
|
|
|
106 case UV_FS_LSTAT:
|
|
|
107 case UV_FS_MKDIR:
|
|
|
108 case UV_FS_OPEN:
|
|
|
109 case UV_FS_READ:
|
|
|
110 case UV_FS_RENAME:
|
|
|
111 case UV_FS_STAT:
|
|
|
112 case UV_FS_SYMLINK:
|
|
|
113 case UV_FS_WRITE:
|
|
|
114 case UV_FS_UNLINK:
|
|
|
115 return 1;
|
|
|
116 default: /* Squelch -Wswitch warnings. */
|
|
|
117 break;
|
|
|
118 }
|
|
|
119 #endif
|
|
|
120
|
|
|
121 return 0;
|
|
|
122 }
|
|
|
123
|
|
|
124
|
|
|
125 static void fs_cb(uv_fs_t* req) {
|
|
|
126 ASSERT_NE(known_broken((uv_req_t*) req) || \
|
|
|
127 req->result == UV_ECANCELED, 0);
|
|
|
128 uv_fs_req_cleanup(req);
|
|
|
129 fs_cb_called++;
|
|
|
130 }
|
|
|
131
|
|
|
132
|
|
|
133 static void getaddrinfo_cb(uv_getaddrinfo_t* req,
|
|
|
134 int status,
|
|
|
135 struct addrinfo* res) {
|
|
|
136 ASSERT_EQ(status, UV_EAI_CANCELED);
|
|
|
137 ASSERT_NULL(res);
|
|
|
138 uv_freeaddrinfo(res); /* Should not crash. */
|
|
|
139 }
|
|
|
140
|
|
|
141
|
|
|
142 static void getnameinfo_cb(uv_getnameinfo_t* handle,
|
|
|
143 int status,
|
|
|
144 const char* hostname,
|
|
|
145 const char* service) {
|
|
|
146 ASSERT_EQ(status, UV_EAI_CANCELED);
|
|
|
147 ASSERT_NULL(hostname);
|
|
|
148 ASSERT_NULL(service);
|
|
|
149 }
|
|
|
150
|
|
|
151
|
|
|
152 static void work2_cb(uv_work_t* req) {
|
|
|
153 ASSERT(0 && "work2_cb called");
|
|
|
154 }
|
|
|
155
|
|
|
156
|
|
|
157 static void done2_cb(uv_work_t* req, int status) {
|
|
|
158 ASSERT_EQ(status, UV_ECANCELED);
|
|
|
159 done2_cb_called++;
|
|
|
160 }
|
|
|
161
|
|
|
162
|
|
|
163 static void timer_cb(uv_timer_t* handle) {
|
|
|
164 struct cancel_info* ci;
|
|
|
165 uv_req_t* req;
|
|
|
166 unsigned i;
|
|
|
167
|
|
|
168 ci = container_of(handle, struct cancel_info, timer_handle);
|
|
|
169
|
|
|
170 for (i = 0; i < ci->nreqs; i++) {
|
|
|
171 req = (uv_req_t*) ((char*) ci->reqs + i * ci->stride);
|
|
|
172 ASSERT(known_broken(req) || 0 == uv_cancel(req));
|
|
|
173 }
|
|
|
174
|
|
|
175 uv_close((uv_handle_t*) &ci->timer_handle, NULL);
|
|
|
176 unblock_threadpool();
|
|
|
177 timer_cb_called++;
|
|
|
178 }
|
|
|
179
|
|
|
180
|
|
|
181 static void nop_done_cb(uv_work_t* req, int status) {
|
|
|
182 ASSERT_EQ(status, UV_ECANCELED);
|
|
|
183 done_cb_called++;
|
|
|
184 }
|
|
|
185
|
|
|
186
|
|
|
187 static void nop_random_cb(uv_random_t* req, int status, void* buf, size_t len) {
|
|
|
188 struct random_info* ri;
|
|
|
189
|
|
|
190 ri = container_of(req, struct random_info, random_req);
|
|
|
191
|
|
|
192 ASSERT_EQ(status, UV_ECANCELED);
|
|
|
193 ASSERT_PTR_EQ(buf, (void*) ri->buf);
|
|
|
194 ASSERT_EQ(len, sizeof(ri->buf));
|
|
|
195
|
|
|
196 done_cb_called++;
|
|
|
197 }
|
|
|
198
|
|
|
199
|
|
|
200 TEST_IMPL(threadpool_cancel_getaddrinfo) {
|
|
|
201 uv_getaddrinfo_t reqs[4];
|
|
|
202 struct cancel_info ci;
|
|
|
203 struct addrinfo hints;
|
|
|
204 uv_loop_t* loop;
|
|
|
205 int r;
|
|
|
206
|
|
|
207 INIT_CANCEL_INFO(&ci, reqs);
|
|
|
208 loop = uv_default_loop();
|
|
|
209 saturate_threadpool();
|
|
|
210
|
|
|
211 r = uv_getaddrinfo(loop, reqs + 0, getaddrinfo_cb, "fail", NULL, NULL);
|
|
|
212 ASSERT_OK(r);
|
|
|
213
|
|
|
214 r = uv_getaddrinfo(loop, reqs + 1, getaddrinfo_cb, NULL, "fail", NULL);
|
|
|
215 ASSERT_OK(r);
|
|
|
216
|
|
|
217 r = uv_getaddrinfo(loop, reqs + 2, getaddrinfo_cb, "fail", "fail", NULL);
|
|
|
218 ASSERT_OK(r);
|
|
|
219
|
|
|
220 r = uv_getaddrinfo(loop, reqs + 3, getaddrinfo_cb, "fail", NULL, &hints);
|
|
|
221 ASSERT_OK(r);
|
|
|
222
|
|
|
223 ASSERT_OK(uv_timer_init(loop, &ci.timer_handle));
|
|
|
224 ASSERT_OK(uv_timer_start(&ci.timer_handle, timer_cb, 10, 0));
|
|
|
225 ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
|
|
|
226 ASSERT_EQ(1, timer_cb_called);
|
|
|
227
|
|
|
228 MAKE_VALGRIND_HAPPY(loop);
|
|
|
229 return 0;
|
|
|
230 }
|
|
|
231
|
|
|
232
|
|
|
233 TEST_IMPL(threadpool_cancel_getnameinfo) {
|
|
|
234 uv_getnameinfo_t reqs[4];
|
|
|
235 struct sockaddr_in addr4;
|
|
|
236 struct cancel_info ci;
|
|
|
237 uv_loop_t* loop;
|
|
|
238 int r;
|
|
|
239
|
|
|
240 r = uv_ip4_addr("127.0.0.1", 80, &addr4);
|
|
|
241 ASSERT_OK(r);
|
|
|
242
|
|
|
243 INIT_CANCEL_INFO(&ci, reqs);
|
|
|
244 loop = uv_default_loop();
|
|
|
245 saturate_threadpool();
|
|
|
246
|
|
|
247 r = uv_getnameinfo(loop, reqs + 0, getnameinfo_cb, (const struct sockaddr*)&addr4, 0);
|
|
|
248 ASSERT_OK(r);
|
|
|
249
|
|
|
250 r = uv_getnameinfo(loop, reqs + 1, getnameinfo_cb, (const struct sockaddr*)&addr4, 0);
|
|
|
251 ASSERT_OK(r);
|
|
|
252
|
|
|
253 r = uv_getnameinfo(loop, reqs + 2, getnameinfo_cb, (const struct sockaddr*)&addr4, 0);
|
|
|
254 ASSERT_OK(r);
|
|
|
255
|
|
|
256 r = uv_getnameinfo(loop, reqs + 3, getnameinfo_cb, (const struct sockaddr*)&addr4, 0);
|
|
|
257 ASSERT_OK(r);
|
|
|
258
|
|
|
259 ASSERT_OK(uv_timer_init(loop, &ci.timer_handle));
|
|
|
260 ASSERT_OK(uv_timer_start(&ci.timer_handle, timer_cb, 10, 0));
|
|
|
261 ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
|
|
|
262 ASSERT_EQ(1, timer_cb_called);
|
|
|
263
|
|
|
264 MAKE_VALGRIND_HAPPY(loop);
|
|
|
265 return 0;
|
|
|
266 }
|
|
|
267
|
|
|
268
|
|
|
269 TEST_IMPL(threadpool_cancel_random) {
|
|
|
270 struct random_info req;
|
|
|
271 uv_loop_t* loop;
|
|
|
272
|
|
|
273 saturate_threadpool();
|
|
|
274 loop = uv_default_loop();
|
|
|
275 ASSERT_OK(uv_random(loop,
|
|
|
276 &req.random_req,
|
|
|
277 &req.buf,
|
|
|
278 sizeof(req.buf),
|
|
|
279 0,
|
|
|
280 nop_random_cb));
|
|
|
281 ASSERT_OK(uv_cancel((uv_req_t*) &req));
|
|
|
282 ASSERT_OK(done_cb_called);
|
|
|
283 unblock_threadpool();
|
|
|
284 ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
|
|
|
285 ASSERT_EQ(1, done_cb_called);
|
|
|
286
|
|
|
287 MAKE_VALGRIND_HAPPY(loop);
|
|
|
288 return 0;
|
|
|
289 }
|
|
|
290
|
|
|
291
|
|
|
292 TEST_IMPL(threadpool_cancel_work) {
|
|
|
293 struct cancel_info ci;
|
|
|
294 uv_work_t reqs[16];
|
|
|
295 uv_loop_t* loop;
|
|
|
296 unsigned i;
|
|
|
297
|
|
|
298 INIT_CANCEL_INFO(&ci, reqs);
|
|
|
299 loop = uv_default_loop();
|
|
|
300 saturate_threadpool();
|
|
|
301
|
|
|
302 for (i = 0; i < ARRAY_SIZE(reqs); i++)
|
|
|
303 ASSERT_OK(uv_queue_work(loop, reqs + i, work2_cb, done2_cb));
|
|
|
304
|
|
|
305 ASSERT_OK(uv_timer_init(loop, &ci.timer_handle));
|
|
|
306 ASSERT_OK(uv_timer_start(&ci.timer_handle, timer_cb, 10, 0));
|
|
|
307 ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
|
|
|
308 ASSERT_EQ(1, timer_cb_called);
|
|
|
309 ASSERT_EQ(ARRAY_SIZE(reqs), done2_cb_called);
|
|
|
310
|
|
|
311 MAKE_VALGRIND_HAPPY(loop);
|
|
|
312 return 0;
|
|
|
313 }
|
|
|
314
|
|
|
315
|
|
|
316 TEST_IMPL(threadpool_cancel_fs) {
|
|
|
317 struct cancel_info ci;
|
|
|
318 uv_fs_t reqs[26];
|
|
|
319 uv_loop_t* loop;
|
|
|
320 unsigned n;
|
|
|
321 uv_buf_t iov;
|
|
|
322
|
|
|
323 INIT_CANCEL_INFO(&ci, reqs);
|
|
|
324 loop = uv_default_loop();
|
|
|
325 saturate_threadpool();
|
|
|
326 iov = uv_buf_init(NULL, 0);
|
|
|
327
|
|
|
328 /* Needs to match ARRAY_SIZE(fs_reqs). */
|
|
|
329 n = 0;
|
|
|
330 ASSERT_OK(uv_fs_chmod(loop, reqs + n++, "/", 0, fs_cb));
|
|
|
331 ASSERT_OK(uv_fs_chown(loop, reqs + n++, "/", 0, 0, fs_cb));
|
|
|
332 ASSERT_OK(uv_fs_close(loop, reqs + n++, 0, fs_cb));
|
|
|
333 ASSERT_OK(uv_fs_fchmod(loop, reqs + n++, 0, 0, fs_cb));
|
|
|
334 ASSERT_OK(uv_fs_fchown(loop, reqs + n++, 0, 0, 0, fs_cb));
|
|
|
335 ASSERT_OK(uv_fs_fdatasync(loop, reqs + n++, 0, fs_cb));
|
|
|
336 ASSERT_OK(uv_fs_fstat(loop, reqs + n++, 0, fs_cb));
|
|
|
337 ASSERT_OK(uv_fs_fsync(loop, reqs + n++, 0, fs_cb));
|
|
|
338 ASSERT_OK(uv_fs_ftruncate(loop, reqs + n++, 0, 0, fs_cb));
|
|
|
339 ASSERT_OK(uv_fs_futime(loop, reqs + n++, 0, 0, 0, fs_cb));
|
|
|
340 ASSERT_OK(uv_fs_link(loop, reqs + n++, "/", "/", fs_cb));
|
|
|
341 ASSERT_OK(uv_fs_lstat(loop, reqs + n++, "/", fs_cb));
|
|
|
342 ASSERT_OK(uv_fs_mkdir(loop, reqs + n++, "/", 0, fs_cb));
|
|
|
343 ASSERT_OK(uv_fs_open(loop, reqs + n++, "/", 0, 0, fs_cb));
|
|
|
344 ASSERT_OK(uv_fs_read(loop, reqs + n++, -1, &iov, 1, 0, fs_cb));
|
|
|
345 ASSERT_OK(uv_fs_scandir(loop, reqs + n++, "/", 0, fs_cb));
|
|
|
346 ASSERT_OK(uv_fs_readlink(loop, reqs + n++, "/", fs_cb));
|
|
|
347 ASSERT_OK(uv_fs_realpath(loop, reqs + n++, "/", fs_cb));
|
|
|
348 ASSERT_OK(uv_fs_rename(loop, reqs + n++, "/", "/", fs_cb));
|
|
|
349 ASSERT_OK(uv_fs_mkdir(loop, reqs + n++, "/", 0, fs_cb));
|
|
|
350 ASSERT_OK(uv_fs_sendfile(loop, reqs + n++, 0, 0, 0, 0, fs_cb));
|
|
|
351 ASSERT_OK(uv_fs_stat(loop, reqs + n++, "/", fs_cb));
|
|
|
352 ASSERT_OK(uv_fs_symlink(loop, reqs + n++, "/", "/", 0, fs_cb));
|
|
|
353 ASSERT_OK(uv_fs_unlink(loop, reqs + n++, "/", fs_cb));
|
|
|
354 ASSERT_OK(uv_fs_utime(loop, reqs + n++, "/", 0, 0, fs_cb));
|
|
|
355 ASSERT_OK(uv_fs_write(loop, reqs + n++, -1, &iov, 1, 0, fs_cb));
|
|
|
356 ASSERT_EQ(n, ARRAY_SIZE(reqs));
|
|
|
357
|
|
|
358 ASSERT_OK(uv_timer_init(loop, &ci.timer_handle));
|
|
|
359 ASSERT_OK(uv_timer_start(&ci.timer_handle, timer_cb, 10, 0));
|
|
|
360 ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
|
|
|
361 ASSERT_EQ(n, fs_cb_called);
|
|
|
362 ASSERT_EQ(1, timer_cb_called);
|
|
|
363
|
|
|
364
|
|
|
365 MAKE_VALGRIND_HAPPY(loop);
|
|
|
366 return 0;
|
|
|
367 }
|
|
|
368
|
|
|
369
|
|
|
370 TEST_IMPL(threadpool_cancel_single) {
|
|
|
371 uv_loop_t* loop;
|
|
|
372 uv_work_t req;
|
|
|
373
|
|
|
374 saturate_threadpool();
|
|
|
375 loop = uv_default_loop();
|
|
|
376 ASSERT_OK(uv_queue_work(loop, &req, (uv_work_cb) abort, nop_done_cb));
|
|
|
377 ASSERT_OK(uv_cancel((uv_req_t*) &req));
|
|
|
378 ASSERT_OK(done_cb_called);
|
|
|
379 unblock_threadpool();
|
|
|
380 ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT));
|
|
|
381 ASSERT_EQ(1, done_cb_called);
|
|
|
382
|
|
|
383 MAKE_VALGRIND_HAPPY(loop);
|
|
|
384 return 0;
|
|
|
385 }
|
|
|
386
|
|
|
387
|
|
|
388 static void after_busy_cb(uv_work_t* req, int status) {
|
|
|
389 ASSERT_OK(status);
|
|
|
390 done_cb_called++;
|
|
|
391 }
|
|
|
392
|
|
|
393 static void busy_cb(uv_work_t* req) {
|
|
|
394 uv_sem_post((uv_sem_t*) req->data);
|
|
|
395 /* Assume that calling uv_cancel() takes less than 10ms. */
|
|
|
396 uv_sleep(10);
|
|
|
397 }
|
|
|
398
|
|
|
399 TEST_IMPL(threadpool_cancel_when_busy) {
|
|
|
400 uv_sem_t sem_lock;
|
|
|
401 uv_work_t req;
|
|
|
402
|
|
|
403 req.data = &sem_lock;
|
|
|
404
|
|
|
405 ASSERT_OK(uv_sem_init(&sem_lock, 0));
|
|
|
406 ASSERT_OK(uv_queue_work(uv_default_loop(), &req, busy_cb, after_busy_cb));
|
|
|
407
|
|
|
408 uv_sem_wait(&sem_lock);
|
|
|
409
|
|
|
410 ASSERT_EQ(uv_cancel((uv_req_t*) &req), UV_EBUSY);
|
|
|
411 ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT));
|
|
|
412 ASSERT_EQ(1, done_cb_called);
|
|
|
413
|
|
|
414 uv_sem_destroy(&sem_lock);
|
|
|
415
|
|
|
416 MAKE_VALGRIND_HAPPY(uv_default_loop());
|
|
|
417 return 0;
|
|
|
418 }
|
