|
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 "uv.h"
|
|
|
22 #include "internal.h"
|
|
|
23 #include "strtok.h"
|
|
|
24
|
|
|
25 #include <stddef.h> /* NULL */
|
|
|
26 #include <stdio.h> /* printf */
|
|
|
27 #include <stdlib.h>
|
|
|
28 #include <string.h> /* strerror */
|
|
|
29 #include <errno.h>
|
|
|
30 #include <assert.h>
|
|
|
31 #include <unistd.h>
|
|
|
32 #include <sys/types.h>
|
|
|
33 #include <sys/stat.h>
|
|
|
34 #include <fcntl.h> /* O_CLOEXEC */
|
|
|
35 #include <sys/ioctl.h>
|
|
|
36 #include <sys/socket.h>
|
|
|
37 #include <sys/un.h>
|
|
|
38 #include <netinet/in.h>
|
|
|
39 #include <arpa/inet.h>
|
|
|
40 #include <limits.h> /* INT_MAX, PATH_MAX, IOV_MAX */
|
|
|
41 #include <sys/uio.h> /* writev */
|
|
|
42 #include <sys/resource.h> /* getrusage */
|
|
|
43 #include <pwd.h>
|
|
|
44 #include <grp.h>
|
|
|
45 #include <sys/utsname.h>
|
|
|
46 #include <sys/time.h>
|
|
|
47 #include <time.h> /* clock_gettime */
|
|
|
48
|
|
|
49 #ifdef __sun
|
|
|
50 # include <sys/filio.h>
|
|
|
51 # include <sys/wait.h>
|
|
|
52 #endif
|
|
|
53
|
|
|
54 #if defined(__APPLE__)
|
|
|
55 # include <mach/mach.h>
|
|
|
56 # include <mach/thread_info.h>
|
|
|
57 # include <sys/filio.h>
|
|
|
58 # include <sys/sysctl.h>
|
|
|
59 #endif /* defined(__APPLE__) */
|
|
|
60
|
|
|
61
|
|
|
62 #if defined(__APPLE__) && !TARGET_OS_IPHONE
|
|
|
63 # include <crt_externs.h>
|
|
|
64 # include <mach-o/dyld.h> /* _NSGetExecutablePath */
|
|
|
65 # define environ (*_NSGetEnviron())
|
|
|
66 #else /* defined(__APPLE__) && !TARGET_OS_IPHONE */
|
|
|
67 extern char** environ;
|
|
|
68 #endif /* !(defined(__APPLE__) && !TARGET_OS_IPHONE) */
|
|
|
69
|
|
|
70
|
|
|
71 #if defined(__DragonFly__) || \
|
|
|
72 defined(__FreeBSD__) || \
|
|
|
73 defined(__NetBSD__) || \
|
|
|
74 defined(__OpenBSD__)
|
|
|
75 # include <sys/sysctl.h>
|
|
|
76 # include <sys/filio.h>
|
|
|
77 # include <sys/wait.h>
|
|
|
78 # include <sys/param.h>
|
|
|
79 # if defined(__FreeBSD__)
|
|
|
80 # include <sys/cpuset.h>
|
|
|
81 # define uv__accept4 accept4
|
|
|
82 # endif
|
|
|
83 # if defined(__NetBSD__)
|
|
|
84 # define uv__accept4(a, b, c, d) paccept((a), (b), (c), NULL, (d))
|
|
|
85 # endif
|
|
|
86 #endif
|
|
|
87
|
|
|
88 #if defined(__MVS__)
|
|
|
89 # include <sys/ioctl.h>
|
|
|
90 # include "zos-sys-info.h"
|
|
|
91 #endif
|
|
|
92
|
|
|
93 #if defined(__linux__)
|
|
|
94 # include <sched.h>
|
|
|
95 # include <sys/syscall.h>
|
|
|
96 # define gettid() syscall(SYS_gettid)
|
|
|
97 # define uv__accept4 accept4
|
|
|
98 #endif
|
|
|
99
|
|
|
100 #if defined(__FreeBSD__)
|
|
|
101 # include <sys/param.h>
|
|
|
102 # include <sys/cpuset.h>
|
|
|
103 #endif
|
|
|
104
|
|
|
105 #if defined(__NetBSD__)
|
|
|
106 # include <sched.h>
|
|
|
107 #endif
|
|
|
108
|
|
|
109 #if defined(__linux__) && defined(__SANITIZE_THREAD__) && defined(__clang__)
|
|
|
110 # include <sanitizer/linux_syscall_hooks.h>
|
|
|
111 #endif
|
|
|
112
|
|
|
113 static void uv__run_pending(uv_loop_t* loop);
|
|
|
114
|
|
|
115 /* Verify that uv_buf_t is ABI-compatible with struct iovec. */
|
|
|
116 STATIC_ASSERT(sizeof(uv_buf_t) == sizeof(struct iovec));
|
|
|
117 STATIC_ASSERT(sizeof(((uv_buf_t*) 0)->base) ==
|
|
|
118 sizeof(((struct iovec*) 0)->iov_base));
|
|
|
119 STATIC_ASSERT(sizeof(((uv_buf_t*) 0)->len) ==
|
|
|
120 sizeof(((struct iovec*) 0)->iov_len));
|
|
|
121 STATIC_ASSERT(offsetof(uv_buf_t, base) == offsetof(struct iovec, iov_base));
|
|
|
122 STATIC_ASSERT(offsetof(uv_buf_t, len) == offsetof(struct iovec, iov_len));
|
|
|
123
|
|
|
124
|
|
|
125 /* https://github.com/libuv/libuv/issues/1674 */
|
|
|
126 int uv_clock_gettime(uv_clock_id clock_id, uv_timespec64_t* ts) {
|
|
|
127 struct timespec t;
|
|
|
128 int r;
|
|
|
129
|
|
|
130 if (ts == NULL)
|
|
|
131 return UV_EFAULT;
|
|
|
132
|
|
|
133 switch (clock_id) {
|
|
|
134 default:
|
|
|
135 return UV_EINVAL;
|
|
|
136 case UV_CLOCK_MONOTONIC:
|
|
|
137 r = clock_gettime(CLOCK_MONOTONIC, &t);
|
|
|
138 break;
|
|
|
139 case UV_CLOCK_REALTIME:
|
|
|
140 r = clock_gettime(CLOCK_REALTIME, &t);
|
|
|
141 break;
|
|
|
142 }
|
|
|
143
|
|
|
144 if (r)
|
|
|
145 return UV__ERR(errno);
|
|
|
146
|
|
|
147 ts->tv_sec = t.tv_sec;
|
|
|
148 ts->tv_nsec = t.tv_nsec;
|
|
|
149
|
|
|
150 return 0;
|
|
|
151 }
|
|
|
152
|
|
|
153
|
|
|
154 uint64_t uv_hrtime(void) {
|
|
|
155 return uv__hrtime(UV_CLOCK_PRECISE);
|
|
|
156 }
|
|
|
157
|
|
|
158
|
|
|
159 void uv_close(uv_handle_t* handle, uv_close_cb close_cb) {
|
|
|
160 assert(!uv__is_closing(handle));
|
|
|
161
|
|
|
162 handle->flags |= UV_HANDLE_CLOSING;
|
|
|
163 handle->close_cb = close_cb;
|
|
|
164
|
|
|
165 switch (handle->type) {
|
|
|
166 case UV_NAMED_PIPE:
|
|
|
167 uv__pipe_close((uv_pipe_t*)handle);
|
|
|
168 break;
|
|
|
169
|
|
|
170 case UV_TTY:
|
|
|
171 uv__tty_close((uv_tty_t*)handle);
|
|
|
172 break;
|
|
|
173
|
|
|
174 case UV_TCP:
|
|
|
175 uv__tcp_close((uv_tcp_t*)handle);
|
|
|
176 break;
|
|
|
177
|
|
|
178 case UV_UDP:
|
|
|
179 uv__udp_close((uv_udp_t*)handle);
|
|
|
180 break;
|
|
|
181
|
|
|
182 case UV_PREPARE:
|
|
|
183 uv__prepare_close((uv_prepare_t*)handle);
|
|
|
184 break;
|
|
|
185
|
|
|
186 case UV_CHECK:
|
|
|
187 uv__check_close((uv_check_t*)handle);
|
|
|
188 break;
|
|
|
189
|
|
|
190 case UV_IDLE:
|
|
|
191 uv__idle_close((uv_idle_t*)handle);
|
|
|
192 break;
|
|
|
193
|
|
|
194 case UV_ASYNC:
|
|
|
195 uv__async_close((uv_async_t*)handle);
|
|
|
196 break;
|
|
|
197
|
|
|
198 case UV_TIMER:
|
|
|
199 uv__timer_close((uv_timer_t*)handle);
|
|
|
200 break;
|
|
|
201
|
|
|
202 case UV_PROCESS:
|
|
|
203 uv__process_close((uv_process_t*)handle);
|
|
|
204 break;
|
|
|
205
|
|
|
206 case UV_FS_EVENT:
|
|
|
207 uv__fs_event_close((uv_fs_event_t*)handle);
|
|
|
208 #if defined(__sun) || defined(__MVS__)
|
|
|
209 /*
|
|
|
210 * On Solaris, illumos, and z/OS we will not be able to dissociate the
|
|
|
211 * watcher for an event which is pending delivery, so we cannot always call
|
|
|
212 * uv__make_close_pending() straight away. The backend will call the
|
|
|
213 * function once the event has cleared.
|
|
|
214 */
|
|
|
215 return;
|
|
|
216 #endif
|
|
|
217 break;
|
|
|
218
|
|
|
219 case UV_POLL:
|
|
|
220 uv__poll_close((uv_poll_t*)handle);
|
|
|
221 break;
|
|
|
222
|
|
|
223 case UV_FS_POLL:
|
|
|
224 uv__fs_poll_close((uv_fs_poll_t*)handle);
|
|
|
225 /* Poll handles use file system requests, and one of them may still be
|
|
|
226 * running. The poll code will call uv__make_close_pending() for us. */
|
|
|
227 return;
|
|
|
228
|
|
|
229 case UV_SIGNAL:
|
|
|
230 uv__signal_close((uv_signal_t*) handle);
|
|
|
231 break;
|
|
|
232
|
|
|
233 default:
|
|
|
234 assert(0);
|
|
|
235 }
|
|
|
236
|
|
|
237 uv__make_close_pending(handle);
|
|
|
238 }
|
|
|
239
|
|
|
240 int uv__socket_sockopt(uv_handle_t* handle, int optname, int* value) {
|
|
|
241 int r;
|
|
|
242 int fd;
|
|
|
243 socklen_t len;
|
|
|
244
|
|
|
245 if (handle == NULL || value == NULL)
|
|
|
246 return UV_EINVAL;
|
|
|
247
|
|
|
248 if (handle->type == UV_TCP || handle->type == UV_NAMED_PIPE)
|
|
|
249 fd = uv__stream_fd((uv_stream_t*) handle);
|
|
|
250 else if (handle->type == UV_UDP)
|
|
|
251 fd = ((uv_udp_t *) handle)->io_watcher.fd;
|
|
|
252 else
|
|
|
253 return UV_ENOTSUP;
|
|
|
254
|
|
|
255 len = sizeof(*value);
|
|
|
256
|
|
|
257 if (*value == 0)
|
|
|
258 r = getsockopt(fd, SOL_SOCKET, optname, value, &len);
|
|
|
259 else
|
|
|
260 r = setsockopt(fd, SOL_SOCKET, optname, (const void*) value, len);
|
|
|
261
|
|
|
262 if (r < 0)
|
|
|
263 return UV__ERR(errno);
|
|
|
264
|
|
|
265 return 0;
|
|
|
266 }
|
|
|
267
|
|
|
268 void uv__make_close_pending(uv_handle_t* handle) {
|
|
|
269 assert(handle->flags & UV_HANDLE_CLOSING);
|
|
|
270 assert(!(handle->flags & UV_HANDLE_CLOSED));
|
|
|
271 handle->next_closing = handle->loop->closing_handles;
|
|
|
272 handle->loop->closing_handles = handle;
|
|
|
273 }
|
|
|
274
|
|
|
275 int uv__getiovmax(void) {
|
|
|
276 #if defined(IOV_MAX)
|
|
|
277 return IOV_MAX;
|
|
|
278 #elif defined(_SC_IOV_MAX)
|
|
|
279 static _Atomic int iovmax_cached = -1;
|
|
|
280 int iovmax;
|
|
|
281
|
|
|
282 iovmax = atomic_load_explicit(&iovmax_cached, memory_order_relaxed);
|
|
|
283 if (iovmax != -1)
|
|
|
284 return iovmax;
|
|
|
285
|
|
|
286 /* On some embedded devices (arm-linux-uclibc based ip camera),
|
|
|
287 * sysconf(_SC_IOV_MAX) can not get the correct value. The return
|
|
|
288 * value is -1 and the errno is EINPROGRESS. Degrade the value to 1.
|
|
|
289 */
|
|
|
290 iovmax = sysconf(_SC_IOV_MAX);
|
|
|
291 if (iovmax == -1)
|
|
|
292 iovmax = 1;
|
|
|
293
|
|
|
294 atomic_store_explicit(&iovmax_cached, iovmax, memory_order_relaxed);
|
|
|
295
|
|
|
296 return iovmax;
|
|
|
297 #else
|
|
|
298 return 1024;
|
|
|
299 #endif
|
|
|
300 }
|
|
|
301
|
|
|
302
|
|
|
303 static void uv__finish_close(uv_handle_t* handle) {
|
|
|
304 uv_signal_t* sh;
|
|
|
305
|
|
|
306 /* Note: while the handle is in the UV_HANDLE_CLOSING state now, it's still
|
|
|
307 * possible for it to be active in the sense that uv__is_active() returns
|
|
|
308 * true.
|
|
|
309 *
|
|
|
310 * A good example is when the user calls uv_shutdown(), immediately followed
|
|
|
311 * by uv_close(). The handle is considered active at this point because the
|
|
|
312 * completion of the shutdown req is still pending.
|
|
|
313 */
|
|
|
314 assert(handle->flags & UV_HANDLE_CLOSING);
|
|
|
315 assert(!(handle->flags & UV_HANDLE_CLOSED));
|
|
|
316 handle->flags |= UV_HANDLE_CLOSED;
|
|
|
317
|
|
|
318 switch (handle->type) {
|
|
|
319 case UV_PREPARE:
|
|
|
320 case UV_CHECK:
|
|
|
321 case UV_IDLE:
|
|
|
322 case UV_ASYNC:
|
|
|
323 case UV_TIMER:
|
|
|
324 case UV_PROCESS:
|
|
|
325 case UV_FS_EVENT:
|
|
|
326 case UV_FS_POLL:
|
|
|
327 case UV_POLL:
|
|
|
328 break;
|
|
|
329
|
|
|
330 case UV_SIGNAL:
|
|
|
331 /* If there are any caught signals "trapped" in the signal pipe,
|
|
|
332 * we can't call the close callback yet. Reinserting the handle
|
|
|
333 * into the closing queue makes the event loop spin but that's
|
|
|
334 * okay because we only need to deliver the pending events.
|
|
|
335 */
|
|
|
336 sh = (uv_signal_t*) handle;
|
|
|
337 if (sh->caught_signals > sh->dispatched_signals) {
|
|
|
338 handle->flags ^= UV_HANDLE_CLOSED;
|
|
|
339 uv__make_close_pending(handle); /* Back into the queue. */
|
|
|
340 return;
|
|
|
341 }
|
|
|
342 break;
|
|
|
343
|
|
|
344 case UV_NAMED_PIPE:
|
|
|
345 case UV_TCP:
|
|
|
346 case UV_TTY:
|
|
|
347 uv__stream_destroy((uv_stream_t*)handle);
|
|
|
348 break;
|
|
|
349
|
|
|
350 case UV_UDP:
|
|
|
351 uv__udp_finish_close((uv_udp_t*)handle);
|
|
|
352 break;
|
|
|
353
|
|
|
354 default:
|
|
|
355 assert(0);
|
|
|
356 break;
|
|
|
357 }
|
|
|
358
|
|
|
359 uv__handle_unref(handle);
|
|
|
360 uv__queue_remove(&handle->handle_queue);
|
|
|
361
|
|
|
362 if (handle->close_cb) {
|
|
|
363 handle->close_cb(handle);
|
|
|
364 }
|
|
|
365 }
|
|
|
366
|
|
|
367
|
|
|
368 static void uv__run_closing_handles(uv_loop_t* loop) {
|
|
|
369 uv_handle_t* p;
|
|
|
370 uv_handle_t* q;
|
|
|
371
|
|
|
372 p = loop->closing_handles;
|
|
|
373 loop->closing_handles = NULL;
|
|
|
374
|
|
|
375 while (p) {
|
|
|
376 q = p->next_closing;
|
|
|
377 uv__finish_close(p);
|
|
|
378 p = q;
|
|
|
379 }
|
|
|
380 }
|
|
|
381
|
|
|
382
|
|
|
383 int uv_is_closing(const uv_handle_t* handle) {
|
|
|
384 return uv__is_closing(handle);
|
|
|
385 }
|
|
|
386
|
|
|
387
|
|
|
388 int uv_backend_fd(const uv_loop_t* loop) {
|
|
|
389 return loop->backend_fd;
|
|
|
390 }
|
|
|
391
|
|
|
392
|
|
|
393 static int uv__loop_alive(const uv_loop_t* loop) {
|
|
|
394 return uv__has_active_handles(loop) ||
|
|
|
395 uv__has_active_reqs(loop) ||
|
|
|
396 !uv__queue_empty(&loop->pending_queue) ||
|
|
|
397 loop->closing_handles != NULL;
|
|
|
398 }
|
|
|
399
|
|
|
400
|
|
|
401 static int uv__backend_timeout(const uv_loop_t* loop) {
|
|
|
402 if (loop->stop_flag == 0 &&
|
|
|
403 /* uv__loop_alive(loop) && */
|
|
|
404 (uv__has_active_handles(loop) || uv__has_active_reqs(loop)) &&
|
|
|
405 uv__queue_empty(&loop->pending_queue) &&
|
|
|
406 uv__queue_empty(&loop->idle_handles) &&
|
|
|
407 (loop->flags & UV_LOOP_REAP_CHILDREN) == 0 &&
|
|
|
408 loop->closing_handles == NULL)
|
|
|
409 return uv__next_timeout(loop);
|
|
|
410 return 0;
|
|
|
411 }
|
|
|
412
|
|
|
413
|
|
|
414 int uv_backend_timeout(const uv_loop_t* loop) {
|
|
|
415 if (uv__queue_empty(&loop->watcher_queue))
|
|
|
416 return uv__backend_timeout(loop);
|
|
|
417 /* Need to call uv_run to update the backend fd state. */
|
|
|
418 return 0;
|
|
|
419 }
|
|
|
420
|
|
|
421
|
|
|
422 int uv_loop_alive(const uv_loop_t* loop) {
|
|
|
423 return uv__loop_alive(loop);
|
|
|
424 }
|
|
|
425
|
|
|
426
|
|
|
427 int uv_run(uv_loop_t* loop, uv_run_mode mode) {
|
|
|
428 int timeout;
|
|
|
429 int r;
|
|
|
430 int can_sleep;
|
|
|
431
|
|
|
432 r = uv__loop_alive(loop);
|
|
|
433 if (!r)
|
|
|
434 uv__update_time(loop);
|
|
|
435
|
|
|
436 /* Maintain backwards compatibility by processing timers before entering the
|
|
|
437 * while loop for UV_RUN_DEFAULT. Otherwise timers only need to be executed
|
|
|
438 * once, which should be done after polling in order to maintain proper
|
|
|
439 * execution order of the conceptual event loop. */
|
|
|
440 if (mode == UV_RUN_DEFAULT && r != 0 && loop->stop_flag == 0) {
|
|
|
441 uv__update_time(loop);
|
|
|
442 uv__run_timers(loop);
|
|
|
443 }
|
|
|
444
|
|
|
445 while (r != 0 && loop->stop_flag == 0) {
|
|
|
446 can_sleep =
|
|
|
447 uv__queue_empty(&loop->pending_queue) &&
|
|
|
448 uv__queue_empty(&loop->idle_handles);
|
|
|
449
|
|
|
450 uv__run_pending(loop);
|
|
|
451 uv__run_idle(loop);
|
|
|
452 uv__run_prepare(loop);
|
|
|
453
|
|
|
454 timeout = 0;
|
|
|
455 if ((mode == UV_RUN_ONCE && can_sleep) || mode == UV_RUN_DEFAULT)
|
|
|
456 timeout = uv__backend_timeout(loop);
|
|
|
457
|
|
|
458 uv__metrics_inc_loop_count(loop);
|
|
|
459
|
|
|
460 uv__io_poll(loop, timeout);
|
|
|
461
|
|
|
462 /* Process immediate callbacks (e.g. write_cb) a small fixed number of
|
|
|
463 * times to avoid loop starvation.*/
|
|
|
464 for (r = 0; r < 8 && !uv__queue_empty(&loop->pending_queue); r++)
|
|
|
465 uv__run_pending(loop);
|
|
|
466
|
|
|
467 /* Run one final update on the provider_idle_time in case uv__io_poll
|
|
|
468 * returned because the timeout expired, but no events were received. This
|
|
|
469 * call will be ignored if the provider_entry_time was either never set (if
|
|
|
470 * the timeout == 0) or was already updated b/c an event was received.
|
|
|
471 */
|
|
|
472 uv__metrics_update_idle_time(loop);
|
|
|
473
|
|
|
474 uv__run_check(loop);
|
|
|
475 uv__run_closing_handles(loop);
|
|
|
476
|
|
|
477 uv__update_time(loop);
|
|
|
478 uv__run_timers(loop);
|
|
|
479
|
|
|
480 r = uv__loop_alive(loop);
|
|
|
481 if (mode == UV_RUN_ONCE || mode == UV_RUN_NOWAIT)
|
|
|
482 break;
|
|
|
483 }
|
|
|
484
|
|
|
485 /* The if statement lets gcc compile it to a conditional store. Avoids
|
|
|
486 * dirtying a cache line.
|
|
|
487 */
|
|
|
488 if (loop->stop_flag != 0)
|
|
|
489 loop->stop_flag = 0;
|
|
|
490
|
|
|
491 return r;
|
|
|
492 }
|
|
|
493
|
|
|
494
|
|
|
495 void uv_update_time(uv_loop_t* loop) {
|
|
|
496 uv__update_time(loop);
|
|
|
497 }
|
|
|
498
|
|
|
499
|
|
|
500 int uv_is_active(const uv_handle_t* handle) {
|
|
|
501 return uv__is_active(handle);
|
|
|
502 }
|
|
|
503
|
|
|
504
|
|
|
505 /* Open a socket in non-blocking close-on-exec mode, atomically if possible. */
|
|
|
506 int uv__socket(int domain, int type, int protocol) {
|
|
|
507 int sockfd;
|
|
|
508 int err;
|
|
|
509
|
|
|
510 #if defined(SOCK_NONBLOCK) && defined(SOCK_CLOEXEC)
|
|
|
511 sockfd = socket(domain, type | SOCK_NONBLOCK | SOCK_CLOEXEC, protocol);
|
|
|
512 if (sockfd != -1)
|
|
|
513 return sockfd;
|
|
|
514
|
|
|
515 if (errno != EINVAL)
|
|
|
516 return UV__ERR(errno);
|
|
|
517 #endif
|
|
|
518
|
|
|
519 sockfd = socket(domain, type, protocol);
|
|
|
520 if (sockfd == -1)
|
|
|
521 return UV__ERR(errno);
|
|
|
522
|
|
|
523 err = uv__nonblock(sockfd, 1);
|
|
|
524 if (err == 0)
|
|
|
525 err = uv__cloexec(sockfd, 1);
|
|
|
526
|
|
|
527 if (err) {
|
|
|
528 uv__close(sockfd);
|
|
|
529 return err;
|
|
|
530 }
|
|
|
531
|
|
|
532 #if defined(SO_NOSIGPIPE)
|
|
|
533 {
|
|
|
534 int on = 1;
|
|
|
535 setsockopt(sockfd, SOL_SOCKET, SO_NOSIGPIPE, &on, sizeof(on));
|
|
|
536 }
|
|
|
537 #endif
|
|
|
538
|
|
|
539 return sockfd;
|
|
|
540 }
|
|
|
541
|
|
|
542 /* get a file pointer to a file in read-only and close-on-exec mode */
|
|
|
543 FILE* uv__open_file(const char* path) {
|
|
|
544 int fd;
|
|
|
545 FILE* fp;
|
|
|
546
|
|
|
547 fd = uv__open_cloexec(path, O_RDONLY);
|
|
|
548 if (fd < 0)
|
|
|
549 return NULL;
|
|
|
550
|
|
|
551 fp = fdopen(fd, "r");
|
|
|
552 if (fp == NULL)
|
|
|
553 uv__close(fd);
|
|
|
554
|
|
|
555 return fp;
|
|
|
556 }
|
|
|
557
|
|
|
558
|
|
|
559 int uv__accept(int sockfd) {
|
|
|
560 int peerfd;
|
|
|
561 int err;
|
|
|
562
|
|
|
563 (void) &err;
|
|
|
564 assert(sockfd >= 0);
|
|
|
565
|
|
|
566 do
|
|
|
567 #ifdef uv__accept4
|
|
|
568 peerfd = uv__accept4(sockfd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC);
|
|
|
569 #else
|
|
|
570 peerfd = accept(sockfd, NULL, NULL);
|
|
|
571 #endif
|
|
|
572 while (peerfd == -1 && errno == EINTR);
|
|
|
573
|
|
|
574 if (peerfd == -1)
|
|
|
575 return UV__ERR(errno);
|
|
|
576
|
|
|
577 #ifndef uv__accept4
|
|
|
578 err = uv__cloexec(peerfd, 1);
|
|
|
579 if (err == 0)
|
|
|
580 err = uv__nonblock(peerfd, 1);
|
|
|
581
|
|
|
582 if (err != 0) {
|
|
|
583 uv__close(peerfd);
|
|
|
584 return err;
|
|
|
585 }
|
|
|
586 #endif
|
|
|
587
|
|
|
588 return peerfd;
|
|
|
589 }
|
|
|
590
|
|
|
591
|
|
|
592 /* close() on macos has the "interesting" quirk that it fails with EINTR
|
|
|
593 * without closing the file descriptor when a thread is in the cancel state.
|
|
|
594 * That's why libuv calls close$NOCANCEL() instead.
|
|
|
595 *
|
|
|
596 * glibc on linux has a similar issue: close() is a cancellation point and
|
|
|
597 * will unwind the thread when it's in the cancel state. Work around that
|
|
|
598 * by making the system call directly. Musl libc is unaffected.
|
|
|
599 */
|
|
|
600 int uv__close_nocancel(int fd) {
|
|
|
601 #if defined(__APPLE__)
|
|
|
602 #pragma GCC diagnostic push
|
|
|
603 #pragma GCC diagnostic ignored "-Wdollar-in-identifier-extension"
|
|
|
604 #if defined(__LP64__) || TARGET_OS_IPHONE
|
|
|
605 extern int close$NOCANCEL(int);
|
|
|
606 return close$NOCANCEL(fd);
|
|
|
607 #else
|
|
|
608 extern int close$NOCANCEL$UNIX2003(int);
|
|
|
609 return close$NOCANCEL$UNIX2003(fd);
|
|
|
610 #endif
|
|
|
611 #pragma GCC diagnostic pop
|
|
|
612 #elif defined(__linux__) && defined(__SANITIZE_THREAD__) && defined(__clang__)
|
|
|
613 long rc;
|
|
|
614 __sanitizer_syscall_pre_close(fd);
|
|
|
615 rc = syscall(SYS_close, fd);
|
|
|
616 __sanitizer_syscall_post_close(rc, fd);
|
|
|
617 return rc;
|
|
|
618 #elif defined(__linux__) && !defined(__SANITIZE_THREAD__)
|
|
|
619 return syscall(SYS_close, fd);
|
|
|
620 #else
|
|
|
621 return close(fd);
|
|
|
622 #endif
|
|
|
623 }
|
|
|
624
|
|
|
625
|
|
|
626 int uv__close_nocheckstdio(int fd) {
|
|
|
627 int saved_errno;
|
|
|
628 int rc;
|
|
|
629
|
|
|
630 assert(fd > -1); /* Catch uninitialized io_watcher.fd bugs. */
|
|
|
631
|
|
|
632 saved_errno = errno;
|
|
|
633 rc = uv__close_nocancel(fd);
|
|
|
634 if (rc == -1) {
|
|
|
635 rc = UV__ERR(errno);
|
|
|
636 if (rc == UV_EINTR || rc == UV__ERR(EINPROGRESS))
|
|
|
637 rc = 0; /* The close is in progress, not an error. */
|
|
|
638 errno = saved_errno;
|
|
|
639 }
|
|
|
640
|
|
|
641 return rc;
|
|
|
642 }
|
|
|
643
|
|
|
644
|
|
|
645 int uv__close(int fd) {
|
|
|
646 assert(fd > STDERR_FILENO); /* Catch stdio close bugs. */
|
|
|
647 #if defined(__MVS__)
|
|
|
648 SAVE_ERRNO(epoll_file_close(fd));
|
|
|
649 #endif
|
|
|
650 return uv__close_nocheckstdio(fd);
|
|
|
651 }
|
|
|
652
|
|
|
653 #if UV__NONBLOCK_IS_IOCTL
|
|
|
654 int uv__nonblock_ioctl(int fd, int set) {
|
|
|
655 int r;
|
|
|
656
|
|
|
657 do
|
|
|
658 r = ioctl(fd, FIONBIO, &set);
|
|
|
659 while (r == -1 && errno == EINTR);
|
|
|
660
|
|
|
661 if (r)
|
|
|
662 return UV__ERR(errno);
|
|
|
663
|
|
|
664 return 0;
|
|
|
665 }
|
|
|
666 #endif
|
|
|
667
|
|
|
668
|
|
|
669 int uv__nonblock_fcntl(int fd, int set) {
|
|
|
670 int flags;
|
|
|
671 int r;
|
|
|
672
|
|
|
673 do
|
|
|
674 r = fcntl(fd, F_GETFL);
|
|
|
675 while (r == -1 && errno == EINTR);
|
|
|
676
|
|
|
677 if (r == -1)
|
|
|
678 return UV__ERR(errno);
|
|
|
679
|
|
|
680 /* Bail out now if already set/clear. */
|
|
|
681 if (!!(r & O_NONBLOCK) == !!set)
|
|
|
682 return 0;
|
|
|
683
|
|
|
684 if (set)
|
|
|
685 flags = r | O_NONBLOCK;
|
|
|
686 else
|
|
|
687 flags = r & ~O_NONBLOCK;
|
|
|
688
|
|
|
689 do
|
|
|
690 r = fcntl(fd, F_SETFL, flags);
|
|
|
691 while (r == -1 && errno == EINTR);
|
|
|
692
|
|
|
693 if (r)
|
|
|
694 return UV__ERR(errno);
|
|
|
695
|
|
|
696 return 0;
|
|
|
697 }
|
|
|
698
|
|
|
699
|
|
|
700 int uv__cloexec(int fd, int set) {
|
|
|
701 int flags;
|
|
|
702 int r;
|
|
|
703
|
|
|
704 flags = 0;
|
|
|
705 if (set)
|
|
|
706 flags = FD_CLOEXEC;
|
|
|
707
|
|
|
708 do
|
|
|
709 r = fcntl(fd, F_SETFD, flags);
|
|
|
710 while (r == -1 && errno == EINTR);
|
|
|
711
|
|
|
712 if (r)
|
|
|
713 return UV__ERR(errno);
|
|
|
714
|
|
|
715 return 0;
|
|
|
716 }
|
|
|
717
|
|
|
718
|
|
|
719 ssize_t uv__recvmsg(int fd, struct msghdr* msg, int flags) {
|
|
|
720 #if defined(__ANDROID__) || \
|
|
|
721 defined(__DragonFly__) || \
|
|
|
722 defined(__FreeBSD__) || \
|
|
|
723 defined(__NetBSD__) || \
|
|
|
724 defined(__OpenBSD__) || \
|
|
|
725 defined(__linux__)
|
|
|
726 ssize_t rc;
|
|
|
727 rc = recvmsg(fd, msg, flags | MSG_CMSG_CLOEXEC);
|
|
|
728 if (rc == -1)
|
|
|
729 return UV__ERR(errno);
|
|
|
730 return rc;
|
|
|
731 #else
|
|
|
732 struct cmsghdr* cmsg;
|
|
|
733 int* pfd;
|
|
|
734 int* end;
|
|
|
735 ssize_t rc;
|
|
|
736 rc = recvmsg(fd, msg, flags);
|
|
|
737 if (rc == -1)
|
|
|
738 return UV__ERR(errno);
|
|
|
739 if (msg->msg_controllen == 0)
|
|
|
740 return rc;
|
|
|
741 for (cmsg = CMSG_FIRSTHDR(msg); cmsg != NULL; cmsg = CMSG_NXTHDR(msg, cmsg))
|
|
|
742 if (cmsg->cmsg_type == SCM_RIGHTS)
|
|
|
743 for (pfd = (int*) CMSG_DATA(cmsg),
|
|
|
744 end = (int*) ((char*) cmsg + cmsg->cmsg_len);
|
|
|
745 pfd < end;
|
|
|
746 pfd += 1)
|
|
|
747 uv__cloexec(*pfd, 1);
|
|
|
748 return rc;
|
|
|
749 #endif
|
|
|
750 }
|
|
|
751
|
|
|
752
|
|
|
753 int uv_cwd(char* buffer, size_t* size) {
|
|
|
754 char scratch[1 + UV__PATH_MAX];
|
|
|
755
|
|
|
756 if (buffer == NULL || size == NULL || *size == 0)
|
|
|
757 return UV_EINVAL;
|
|
|
758
|
|
|
759 /* Try to read directly into the user's buffer first... */
|
|
|
760 if (getcwd(buffer, *size) != NULL)
|
|
|
761 goto fixup;
|
|
|
762
|
|
|
763 if (errno != ERANGE)
|
|
|
764 return UV__ERR(errno);
|
|
|
765
|
|
|
766 /* ...or into scratch space if the user's buffer is too small
|
|
|
767 * so we can report how much space to provide on the next try.
|
|
|
768 */
|
|
|
769 if (getcwd(scratch, sizeof(scratch)) == NULL)
|
|
|
770 return UV__ERR(errno);
|
|
|
771
|
|
|
772 buffer = scratch;
|
|
|
773
|
|
|
774 fixup:
|
|
|
775
|
|
|
776 *size = strlen(buffer);
|
|
|
777
|
|
|
778 if (*size > 1 && buffer[*size - 1] == '/') {
|
|
|
779 *size -= 1;
|
|
|
780 buffer[*size] = '\0';
|
|
|
781 }
|
|
|
782
|
|
|
783 if (buffer == scratch) {
|
|
|
784 *size += 1;
|
|
|
785 return UV_ENOBUFS;
|
|
|
786 }
|
|
|
787
|
|
|
788 return 0;
|
|
|
789 }
|
|
|
790
|
|
|
791
|
|
|
792 int uv_chdir(const char* dir) {
|
|
|
793 if (chdir(dir))
|
|
|
794 return UV__ERR(errno);
|
|
|
795
|
|
|
796 return 0;
|
|
|
797 }
|
|
|
798
|
|
|
799
|
|
|
800 void uv_disable_stdio_inheritance(void) {
|
|
|
801 int fd;
|
|
|
802
|
|
|
803 /* Set the CLOEXEC flag on all open descriptors. Unconditionally try the
|
|
|
804 * first 16 file descriptors. After that, bail out after the first error.
|
|
|
805 */
|
|
|
806 for (fd = 0; ; fd++)
|
|
|
807 if (uv__cloexec(fd, 1) && fd > 15)
|
|
|
808 break;
|
|
|
809 }
|
|
|
810
|
|
|
811
|
|
|
812 int uv_fileno(const uv_handle_t* handle, uv_os_fd_t* fd) {
|
|
|
813 int fd_out;
|
|
|
814
|
|
|
815 switch (handle->type) {
|
|
|
816 case UV_TCP:
|
|
|
817 case UV_NAMED_PIPE:
|
|
|
818 case UV_TTY:
|
|
|
819 fd_out = uv__stream_fd((uv_stream_t*) handle);
|
|
|
820 break;
|
|
|
821
|
|
|
822 case UV_UDP:
|
|
|
823 fd_out = ((uv_udp_t *) handle)->io_watcher.fd;
|
|
|
824 break;
|
|
|
825
|
|
|
826 case UV_POLL:
|
|
|
827 fd_out = ((uv_poll_t *) handle)->io_watcher.fd;
|
|
|
828 break;
|
|
|
829
|
|
|
830 default:
|
|
|
831 return UV_EINVAL;
|
|
|
832 }
|
|
|
833
|
|
|
834 if (uv__is_closing(handle) || fd_out == -1)
|
|
|
835 return UV_EBADF;
|
|
|
836
|
|
|
837 *fd = fd_out;
|
|
|
838 return 0;
|
|
|
839 }
|
|
|
840
|
|
|
841
|
|
|
842 static void uv__run_pending(uv_loop_t* loop) {
|
|
|
843 struct uv__queue* q;
|
|
|
844 struct uv__queue pq;
|
|
|
845 uv__io_t* w;
|
|
|
846
|
|
|
847 uv__queue_move(&loop->pending_queue, &pq);
|
|
|
848
|
|
|
849 while (!uv__queue_empty(&pq)) {
|
|
|
850 q = uv__queue_head(&pq);
|
|
|
851 uv__queue_remove(q);
|
|
|
852 uv__queue_init(q);
|
|
|
853 w = uv__queue_data(q, uv__io_t, pending_queue);
|
|
|
854 w->cb(loop, w, POLLOUT);
|
|
|
855 }
|
|
|
856 }
|
|
|
857
|
|
|
858
|
|
|
859 static unsigned int next_power_of_two(unsigned int val) {
|
|
|
860 val -= 1;
|
|
|
861 val |= val >> 1;
|
|
|
862 val |= val >> 2;
|
|
|
863 val |= val >> 4;
|
|
|
864 val |= val >> 8;
|
|
|
865 val |= val >> 16;
|
|
|
866 val += 1;
|
|
|
867 return val;
|
|
|
868 }
|
|
|
869
|
|
|
870 static int maybe_resize(uv_loop_t* loop, unsigned int len) {
|
|
|
871 uv__io_t** watchers;
|
|
|
872 void* fake_watcher_list;
|
|
|
873 void* fake_watcher_count;
|
|
|
874 unsigned int nwatchers;
|
|
|
875 unsigned int i;
|
|
|
876
|
|
|
877 if (len <= loop->nwatchers)
|
|
|
878 return 0;
|
|
|
879
|
|
|
880 /* Preserve fake watcher list and count at the end of the watchers */
|
|
|
881 if (loop->watchers != NULL) {
|
|
|
882 fake_watcher_list = loop->watchers[loop->nwatchers];
|
|
|
883 fake_watcher_count = loop->watchers[loop->nwatchers + 1];
|
|
|
884 } else {
|
|
|
885 fake_watcher_list = NULL;
|
|
|
886 fake_watcher_count = NULL;
|
|
|
887 }
|
|
|
888
|
|
|
889 nwatchers = next_power_of_two(len + 2) - 2;
|
|
|
890 watchers = uv__reallocf(loop->watchers,
|
|
|
891 (nwatchers + 2) * sizeof(loop->watchers[0]));
|
|
|
892
|
|
|
893 if (watchers == NULL)
|
|
|
894 return UV_ENOMEM;
|
|
|
895 for (i = loop->nwatchers; i < nwatchers; i++)
|
|
|
896 watchers[i] = NULL;
|
|
|
897 watchers[nwatchers] = fake_watcher_list;
|
|
|
898 watchers[nwatchers + 1] = fake_watcher_count;
|
|
|
899
|
|
|
900 loop->watchers = watchers;
|
|
|
901 loop->nwatchers = nwatchers;
|
|
|
902 return 0;
|
|
|
903 }
|
|
|
904
|
|
|
905
|
|
|
906 void uv__io_init(uv__io_t* w, uv__io_cb cb, int fd) {
|
|
|
907 assert(fd >= -1);
|
|
|
908 uv__queue_init(&w->pending_queue);
|
|
|
909 uv__queue_init(&w->watcher_queue);
|
|
|
910 w->cb = cb;
|
|
|
911 w->fd = fd;
|
|
|
912 w->events = 0;
|
|
|
913 w->pevents = 0;
|
|
|
914 }
|
|
|
915
|
|
|
916
|
|
|
917 int uv__io_start(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
|
|
|
918 int err;
|
|
|
919
|
|
|
920 assert(0 == (events & ~(POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI)));
|
|
|
921 assert(0 != events);
|
|
|
922 assert(w->fd >= 0);
|
|
|
923 assert(w->fd < INT_MAX);
|
|
|
924
|
|
|
925 w->pevents |= events;
|
|
|
926 err = maybe_resize(loop, w->fd + 1);
|
|
|
927 if (err)
|
|
|
928 return err;
|
|
|
929
|
|
|
930 #if !defined(__sun)
|
|
|
931 /* The event ports backend needs to rearm all file descriptors on each and
|
|
|
932 * every tick of the event loop but the other backends allow us to
|
|
|
933 * short-circuit here if the event mask is unchanged.
|
|
|
934 */
|
|
|
935 if (w->events == w->pevents)
|
|
|
936 return 0;
|
|
|
937 #endif
|
|
|
938
|
|
|
939 if (uv__queue_empty(&w->watcher_queue))
|
|
|
940 uv__queue_insert_tail(&loop->watcher_queue, &w->watcher_queue);
|
|
|
941
|
|
|
942 if (loop->watchers[w->fd] == NULL) {
|
|
|
943 loop->watchers[w->fd] = w;
|
|
|
944 loop->nfds++;
|
|
|
945 }
|
|
|
946
|
|
|
947 return 0;
|
|
|
948 }
|
|
|
949
|
|
|
950
|
|
|
951 int uv__io_init_start(uv_loop_t* loop,
|
|
|
952 uv__io_t* w,
|
|
|
953 uv__io_cb cb,
|
|
|
954 int fd,
|
|
|
955 unsigned int events) {
|
|
|
956 int err;
|
|
|
957
|
|
|
958 assert(cb != NULL);
|
|
|
959 assert(fd > -1);
|
|
|
960 uv__io_init(w, cb, fd);
|
|
|
961 err = uv__io_start(loop, w, events);
|
|
|
962 if (err)
|
|
|
963 uv__io_init(w, NULL, -1);
|
|
|
964 return err;
|
|
|
965 }
|
|
|
966
|
|
|
967
|
|
|
968 void uv__io_stop(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
|
|
|
969 assert(0 == (events & ~(POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI)));
|
|
|
970 assert(0 != events);
|
|
|
971
|
|
|
972 if (w->fd == -1)
|
|
|
973 return;
|
|
|
974
|
|
|
975 assert(w->fd >= 0);
|
|
|
976
|
|
|
977 /* Happens when uv__io_stop() is called on a handle that was never started. */
|
|
|
978 if ((unsigned) w->fd >= loop->nwatchers)
|
|
|
979 return;
|
|
|
980
|
|
|
981 w->pevents &= ~events;
|
|
|
982
|
|
|
983 if (w->pevents == 0) {
|
|
|
984 uv__queue_remove(&w->watcher_queue);
|
|
|
985 uv__queue_init(&w->watcher_queue);
|
|
|
986 w->events = 0;
|
|
|
987
|
|
|
988 if (w == loop->watchers[w->fd]) {
|
|
|
989 assert(loop->nfds > 0);
|
|
|
990 loop->watchers[w->fd] = NULL;
|
|
|
991 loop->nfds--;
|
|
|
992 }
|
|
|
993 }
|
|
|
994 else if (uv__queue_empty(&w->watcher_queue))
|
|
|
995 uv__queue_insert_tail(&loop->watcher_queue, &w->watcher_queue);
|
|
|
996 }
|
|
|
997
|
|
|
998
|
|
|
999 void uv__io_close(uv_loop_t* loop, uv__io_t* w) {
|
|
|
1000 uv__io_stop(loop, w, POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI);
|
|
|
1001 uv__queue_remove(&w->pending_queue);
|
|
|
1002
|
|
|
1003 /* Remove stale events for this file descriptor */
|
|
|
1004 if (w->fd != -1)
|
|
|
1005 uv__platform_invalidate_fd(loop, w->fd);
|
|
|
1006 }
|
|
|
1007
|
|
|
1008
|
|
|
1009 void uv__io_feed(uv_loop_t* loop, uv__io_t* w) {
|
|
|
1010 if (uv__queue_empty(&w->pending_queue))
|
|
|
1011 uv__queue_insert_tail(&loop->pending_queue, &w->pending_queue);
|
|
|
1012 }
|
|
|
1013
|
|
|
1014
|
|
|
1015 int uv__io_active(const uv__io_t* w, unsigned int events) {
|
|
|
1016 assert(0 == (events & ~(POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI)));
|
|
|
1017 assert(0 != events);
|
|
|
1018 return 0 != (w->pevents & events);
|
|
|
1019 }
|
|
|
1020
|
|
|
1021
|
|
|
1022 int uv__fd_exists(uv_loop_t* loop, int fd) {
|
|
|
1023 return (unsigned) fd < loop->nwatchers && loop->watchers[fd] != NULL;
|
|
|
1024 }
|
|
|
1025
|
|
|
1026
|
|
|
1027 static int uv__getrusage(int who, uv_rusage_t* rusage) {
|
|
|
1028 struct rusage usage;
|
|
|
1029
|
|
|
1030 if (getrusage(who, &usage))
|
|
|
1031 return UV__ERR(errno);
|
|
|
1032
|
|
|
1033 rusage->ru_utime.tv_sec = usage.ru_utime.tv_sec;
|
|
|
1034 rusage->ru_utime.tv_usec = usage.ru_utime.tv_usec;
|
|
|
1035
|
|
|
1036 rusage->ru_stime.tv_sec = usage.ru_stime.tv_sec;
|
|
|
1037 rusage->ru_stime.tv_usec = usage.ru_stime.tv_usec;
|
|
|
1038
|
|
|
1039 #if !defined(__MVS__) && !defined(__HAIKU__)
|
|
|
1040 rusage->ru_maxrss = usage.ru_maxrss;
|
|
|
1041 rusage->ru_ixrss = usage.ru_ixrss;
|
|
|
1042 rusage->ru_idrss = usage.ru_idrss;
|
|
|
1043 rusage->ru_isrss = usage.ru_isrss;
|
|
|
1044 rusage->ru_minflt = usage.ru_minflt;
|
|
|
1045 rusage->ru_majflt = usage.ru_majflt;
|
|
|
1046 rusage->ru_nswap = usage.ru_nswap;
|
|
|
1047 rusage->ru_inblock = usage.ru_inblock;
|
|
|
1048 rusage->ru_oublock = usage.ru_oublock;
|
|
|
1049 rusage->ru_msgsnd = usage.ru_msgsnd;
|
|
|
1050 rusage->ru_msgrcv = usage.ru_msgrcv;
|
|
|
1051 rusage->ru_nsignals = usage.ru_nsignals;
|
|
|
1052 rusage->ru_nvcsw = usage.ru_nvcsw;
|
|
|
1053 rusage->ru_nivcsw = usage.ru_nivcsw;
|
|
|
1054 #endif
|
|
|
1055
|
|
|
1056 /* Most platforms report ru_maxrss in kilobytes; macOS and Solaris are
|
|
|
1057 * the outliers because of course they are.
|
|
|
1058 */
|
|
|
1059 #if defined(__APPLE__)
|
|
|
1060 rusage->ru_maxrss /= 1024; /* macOS and iOS report bytes. */
|
|
|
1061 #elif defined(__sun)
|
|
|
1062 rusage->ru_maxrss *= getpagesize() / 1024; /* Solaris reports pages. */
|
|
|
1063 #endif
|
|
|
1064
|
|
|
1065 return 0;
|
|
|
1066 }
|
|
|
1067
|
|
|
1068
|
|
|
1069 int uv_getrusage(uv_rusage_t* rusage) {
|
|
|
1070 return uv__getrusage(RUSAGE_SELF, rusage);
|
|
|
1071 }
|
|
|
1072
|
|
|
1073
|
|
|
1074 int uv_getrusage_thread(uv_rusage_t* rusage) {
|
|
|
1075 #if defined(__APPLE__)
|
|
|
1076 mach_msg_type_number_t count;
|
|
|
1077 thread_basic_info_data_t info;
|
|
|
1078 kern_return_t kr;
|
|
|
1079 thread_t thread;
|
|
|
1080
|
|
|
1081 thread = mach_thread_self();
|
|
|
1082 count = THREAD_BASIC_INFO_COUNT;
|
|
|
1083 kr = thread_info(thread,
|
|
|
1084 THREAD_BASIC_INFO,
|
|
|
1085 (thread_info_t)&info,
|
|
|
1086 &count);
|
|
|
1087
|
|
|
1088 if (kr != KERN_SUCCESS) {
|
|
|
1089 mach_port_deallocate(mach_task_self(), thread);
|
|
|
1090 return UV_EINVAL;
|
|
|
1091 }
|
|
|
1092
|
|
|
1093 memset(rusage, 0, sizeof(*rusage));
|
|
|
1094
|
|
|
1095 rusage->ru_utime.tv_sec = info.user_time.seconds;
|
|
|
1096 rusage->ru_utime.tv_usec = info.user_time.microseconds;
|
|
|
1097 rusage->ru_stime.tv_sec = info.system_time.seconds;
|
|
|
1098 rusage->ru_stime.tv_usec = info.system_time.microseconds;
|
|
|
1099
|
|
|
1100 mach_port_deallocate(mach_task_self(), thread);
|
|
|
1101
|
|
|
1102 return 0;
|
|
|
1103
|
|
|
1104 #elif defined(RUSAGE_LWP)
|
|
|
1105 return uv__getrusage(RUSAGE_LWP, rusage);
|
|
|
1106 #elif defined(RUSAGE_THREAD)
|
|
|
1107 return uv__getrusage(RUSAGE_THREAD, rusage);
|
|
|
1108 #endif /* defined(__APPLE__) */
|
|
|
1109 return UV_ENOTSUP;
|
|
|
1110 }
|
|
|
1111
|
|
|
1112
|
|
|
1113 int uv__open_cloexec(const char* path, int flags) {
|
|
|
1114 #if defined(O_CLOEXEC)
|
|
|
1115 int fd;
|
|
|
1116
|
|
|
1117 fd = open(path, flags | O_CLOEXEC);
|
|
|
1118 if (fd == -1)
|
|
|
1119 return UV__ERR(errno);
|
|
|
1120
|
|
|
1121 return fd;
|
|
|
1122 #else /* O_CLOEXEC */
|
|
|
1123 int err;
|
|
|
1124 int fd;
|
|
|
1125
|
|
|
1126 fd = open(path, flags);
|
|
|
1127 if (fd == -1)
|
|
|
1128 return UV__ERR(errno);
|
|
|
1129
|
|
|
1130 err = uv__cloexec(fd, 1);
|
|
|
1131 if (err) {
|
|
|
1132 uv__close(fd);
|
|
|
1133 return err;
|
|
|
1134 }
|
|
|
1135
|
|
|
1136 return fd;
|
|
|
1137 #endif /* O_CLOEXEC */
|
|
|
1138 }
|
|
|
1139
|
|
|
1140
|
|
|
1141 int uv__slurp(const char* filename, char* buf, size_t len) {
|
|
|
1142 ssize_t n;
|
|
|
1143 int fd;
|
|
|
1144
|
|
|
1145 assert(len > 0);
|
|
|
1146
|
|
|
1147 fd = uv__open_cloexec(filename, O_RDONLY);
|
|
|
1148 if (fd < 0)
|
|
|
1149 return fd;
|
|
|
1150
|
|
|
1151 do
|
|
|
1152 n = read(fd, buf, len - 1);
|
|
|
1153 while (n == -1 && errno == EINTR);
|
|
|
1154
|
|
|
1155 if (uv__close_nocheckstdio(fd))
|
|
|
1156 abort();
|
|
|
1157
|
|
|
1158 if (n < 0)
|
|
|
1159 return UV__ERR(errno);
|
|
|
1160
|
|
|
1161 buf[n] = '\0';
|
|
|
1162
|
|
|
1163 return 0;
|
|
|
1164 }
|
|
|
1165
|
|
|
1166
|
|
|
1167 int uv__dup2_cloexec(int oldfd, int newfd) {
|
|
|
1168 #if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__linux__)
|
|
|
1169 int r;
|
|
|
1170
|
|
|
1171 r = dup3(oldfd, newfd, O_CLOEXEC);
|
|
|
1172 if (r == -1)
|
|
|
1173 return UV__ERR(errno);
|
|
|
1174
|
|
|
1175 return r;
|
|
|
1176 #else
|
|
|
1177 int err;
|
|
|
1178 int r;
|
|
|
1179
|
|
|
1180 r = dup2(oldfd, newfd); /* Never retry. */
|
|
|
1181 if (r == -1)
|
|
|
1182 return UV__ERR(errno);
|
|
|
1183
|
|
|
1184 err = uv__cloexec(newfd, 1);
|
|
|
1185 if (err != 0) {
|
|
|
1186 uv__close(newfd);
|
|
|
1187 return err;
|
|
|
1188 }
|
|
|
1189
|
|
|
1190 return r;
|
|
|
1191 #endif
|
|
|
1192 }
|
|
|
1193
|
|
|
1194
|
|
|
1195 int uv_os_homedir(char* buffer, size_t* size) {
|
|
|
1196 uv_passwd_t pwd;
|
|
|
1197 size_t len;
|
|
|
1198 int r;
|
|
|
1199
|
|
|
1200 /* Check if the HOME environment variable is set first. The task of
|
|
|
1201 performing input validation on buffer and size is taken care of by
|
|
|
1202 uv_os_getenv(). */
|
|
|
1203 r = uv_os_getenv("HOME", buffer, size);
|
|
|
1204
|
|
|
1205 if (r != UV_ENOENT)
|
|
|
1206 return r;
|
|
|
1207
|
|
|
1208 /* HOME is not set, so call uv_os_get_passwd() */
|
|
|
1209 r = uv_os_get_passwd(&pwd);
|
|
|
1210
|
|
|
1211 if (r != 0) {
|
|
|
1212 return r;
|
|
|
1213 }
|
|
|
1214
|
|
|
1215 len = strlen(pwd.homedir);
|
|
|
1216
|
|
|
1217 if (len >= *size) {
|
|
|
1218 *size = len + 1;
|
|
|
1219 uv_os_free_passwd(&pwd);
|
|
|
1220 return UV_ENOBUFS;
|
|
|
1221 }
|
|
|
1222
|
|
|
1223 memcpy(buffer, pwd.homedir, len + 1);
|
|
|
1224 *size = len;
|
|
|
1225 uv_os_free_passwd(&pwd);
|
|
|
1226
|
|
|
1227 return 0;
|
|
|
1228 }
|
|
|
1229
|
|
|
1230
|
|
|
1231 int uv_os_tmpdir(char* buffer, size_t* size) {
|
|
|
1232 const char* buf;
|
|
|
1233 size_t len;
|
|
|
1234
|
|
|
1235 if (buffer == NULL || size == NULL || *size == 0)
|
|
|
1236 return UV_EINVAL;
|
|
|
1237
|
|
|
1238 #define CHECK_ENV_VAR(name) \
|
|
|
1239 do { \
|
|
|
1240 buf = getenv(name); \
|
|
|
1241 if (buf != NULL) \
|
|
|
1242 goto return_buffer; \
|
|
|
1243 } \
|
|
|
1244 while (0)
|
|
|
1245
|
|
|
1246 /* Check the TMPDIR, TMP, TEMP, and TEMPDIR environment variables in order */
|
|
|
1247 CHECK_ENV_VAR("TMPDIR");
|
|
|
1248 CHECK_ENV_VAR("TMP");
|
|
|
1249 CHECK_ENV_VAR("TEMP");
|
|
|
1250 CHECK_ENV_VAR("TEMPDIR");
|
|
|
1251
|
|
|
1252 #undef CHECK_ENV_VAR
|
|
|
1253
|
|
|
1254 /* No temp environment variables defined */
|
|
|
1255 #if defined(__ANDROID__)
|
|
|
1256 buf = "/data/local/tmp";
|
|
|
1257 #else
|
|
|
1258 buf = "/tmp";
|
|
|
1259 #endif
|
|
|
1260
|
|
|
1261 return_buffer:
|
|
|
1262 len = strlen(buf);
|
|
|
1263
|
|
|
1264 if (len >= *size) {
|
|
|
1265 *size = len + 1;
|
|
|
1266 return UV_ENOBUFS;
|
|
|
1267 }
|
|
|
1268
|
|
|
1269 /* The returned directory should not have a trailing slash. */
|
|
|
1270 if (len > 1 && buf[len - 1] == '/') {
|
|
|
1271 len--;
|
|
|
1272 }
|
|
|
1273
|
|
|
1274 memcpy(buffer, buf, len + 1);
|
|
|
1275 buffer[len] = '\0';
|
|
|
1276 *size = len;
|
|
|
1277
|
|
|
1278 return 0;
|
|
|
1279 }
|
|
|
1280
|
|
|
1281
|
|
|
1282 static int uv__getpwuid_r(uv_passwd_t *pwd, uid_t uid) {
|
|
|
1283 struct passwd pw;
|
|
|
1284 struct passwd* result;
|
|
|
1285 char* buf;
|
|
|
1286 size_t bufsize;
|
|
|
1287 size_t name_size;
|
|
|
1288 size_t homedir_size;
|
|
|
1289 size_t shell_size;
|
|
|
1290 int r;
|
|
|
1291
|
|
|
1292 if (pwd == NULL)
|
|
|
1293 return UV_EINVAL;
|
|
|
1294
|
|
|
1295 /* Calling sysconf(_SC_GETPW_R_SIZE_MAX) would get the suggested size, but it
|
|
|
1296 * is frequently 1024 or 4096, so we can just use that directly. The pwent
|
|
|
1297 * will not usually be large. */
|
|
|
1298 for (bufsize = 2000;; bufsize *= 2) {
|
|
|
1299 buf = uv__malloc(bufsize);
|
|
|
1300
|
|
|
1301 if (buf == NULL)
|
|
|
1302 return UV_ENOMEM;
|
|
|
1303
|
|
|
1304 do
|
|
|
1305 r = getpwuid_r(uid, &pw, buf, bufsize, &result);
|
|
|
1306 while (r == EINTR);
|
|
|
1307
|
|
|
1308 if (r != 0 || result == NULL)
|
|
|
1309 uv__free(buf);
|
|
|
1310
|
|
|
1311 if (r != ERANGE)
|
|
|
1312 break;
|
|
|
1313 }
|
|
|
1314
|
|
|
1315 if (r != 0)
|
|
|
1316 return UV__ERR(r);
|
|
|
1317
|
|
|
1318 if (result == NULL)
|
|
|
1319 return UV_ENOENT;
|
|
|
1320
|
|
|
1321 /* Allocate memory for the username, shell, and home directory */
|
|
|
1322 name_size = strlen(pw.pw_name) + 1;
|
|
|
1323 homedir_size = strlen(pw.pw_dir) + 1;
|
|
|
1324 shell_size = strlen(pw.pw_shell) + 1;
|
|
|
1325 pwd->username = uv__malloc(name_size + homedir_size + shell_size);
|
|
|
1326
|
|
|
1327 if (pwd->username == NULL) {
|
|
|
1328 uv__free(buf);
|
|
|
1329 return UV_ENOMEM;
|
|
|
1330 }
|
|
|
1331
|
|
|
1332 /* Copy the username */
|
|
|
1333 memcpy(pwd->username, pw.pw_name, name_size);
|
|
|
1334
|
|
|
1335 /* Copy the home directory */
|
|
|
1336 pwd->homedir = pwd->username + name_size;
|
|
|
1337 memcpy(pwd->homedir, pw.pw_dir, homedir_size);
|
|
|
1338
|
|
|
1339 /* Copy the shell */
|
|
|
1340 pwd->shell = pwd->homedir + homedir_size;
|
|
|
1341 memcpy(pwd->shell, pw.pw_shell, shell_size);
|
|
|
1342
|
|
|
1343 /* Copy the uid and gid */
|
|
|
1344 pwd->uid = pw.pw_uid;
|
|
|
1345 pwd->gid = pw.pw_gid;
|
|
|
1346
|
|
|
1347 uv__free(buf);
|
|
|
1348
|
|
|
1349 return 0;
|
|
|
1350 }
|
|
|
1351
|
|
|
1352
|
|
|
1353 int uv_os_get_group(uv_group_t* grp, uv_uid_t gid) {
|
|
|
1354 #if defined(__ANDROID__) && __ANDROID_API__ < 24
|
|
|
1355 /* This function getgrgid_r() was added in Android N (level 24) */
|
|
|
1356 return UV_ENOSYS;
|
|
|
1357 #else
|
|
|
1358 struct group gp;
|
|
|
1359 struct group* result;
|
|
|
1360 char* buf;
|
|
|
1361 char* gr_mem;
|
|
|
1362 size_t bufsize;
|
|
|
1363 size_t name_size;
|
|
|
1364 long members;
|
|
|
1365 size_t mem_size;
|
|
|
1366 int r;
|
|
|
1367
|
|
|
1368 if (grp == NULL)
|
|
|
1369 return UV_EINVAL;
|
|
|
1370
|
|
|
1371 /* Calling sysconf(_SC_GETGR_R_SIZE_MAX) would get the suggested size, but it
|
|
|
1372 * is frequently 1024 or 4096, so we can just use that directly. The pwent
|
|
|
1373 * will not usually be large. */
|
|
|
1374 for (bufsize = 2000;; bufsize *= 2) {
|
|
|
1375 buf = uv__malloc(bufsize);
|
|
|
1376
|
|
|
1377 if (buf == NULL)
|
|
|
1378 return UV_ENOMEM;
|
|
|
1379
|
|
|
1380 do
|
|
|
1381 r = getgrgid_r(gid, &gp, buf, bufsize, &result);
|
|
|
1382 while (r == EINTR);
|
|
|
1383
|
|
|
1384 if (r != 0 || result == NULL)
|
|
|
1385 uv__free(buf);
|
|
|
1386
|
|
|
1387 if (r != ERANGE)
|
|
|
1388 break;
|
|
|
1389 }
|
|
|
1390
|
|
|
1391 if (r != 0)
|
|
|
1392 return UV__ERR(r);
|
|
|
1393
|
|
|
1394 if (result == NULL)
|
|
|
1395 return UV_ENOENT;
|
|
|
1396
|
|
|
1397 /* Allocate memory for the groupname and members. */
|
|
|
1398 name_size = strlen(gp.gr_name) + 1;
|
|
|
1399 members = 0;
|
|
|
1400 mem_size = sizeof(char*);
|
|
|
1401 for (r = 0; gp.gr_mem[r] != NULL; r++) {
|
|
|
1402 mem_size += strlen(gp.gr_mem[r]) + 1 + sizeof(char*);
|
|
|
1403 members++;
|
|
|
1404 }
|
|
|
1405
|
|
|
1406 gr_mem = uv__malloc(name_size + mem_size);
|
|
|
1407 if (gr_mem == NULL) {
|
|
|
1408 uv__free(buf);
|
|
|
1409 return UV_ENOMEM;
|
|
|
1410 }
|
|
|
1411
|
|
|
1412 /* Copy the members */
|
|
|
1413 grp->members = (char**) gr_mem;
|
|
|
1414 grp->members[members] = NULL;
|
|
|
1415 gr_mem = (char*) &grp->members[members + 1];
|
|
|
1416 for (r = 0; r < members; r++) {
|
|
|
1417 grp->members[r] = gr_mem;
|
|
|
1418 strcpy(gr_mem, gp.gr_mem[r]);
|
|
|
1419 gr_mem += strlen(gr_mem) + 1;
|
|
|
1420 }
|
|
|
1421 assert(gr_mem == (char*)grp->members + mem_size);
|
|
|
1422
|
|
|
1423 /* Copy the groupname */
|
|
|
1424 grp->groupname = gr_mem;
|
|
|
1425 memcpy(grp->groupname, gp.gr_name, name_size);
|
|
|
1426 gr_mem += name_size;
|
|
|
1427
|
|
|
1428 /* Copy the gid */
|
|
|
1429 grp->gid = gp.gr_gid;
|
|
|
1430
|
|
|
1431 uv__free(buf);
|
|
|
1432
|
|
|
1433 return 0;
|
|
|
1434 #endif
|
|
|
1435 }
|
|
|
1436
|
|
|
1437
|
|
|
1438 int uv_os_get_passwd(uv_passwd_t* pwd) {
|
|
|
1439 return uv__getpwuid_r(pwd, geteuid());
|
|
|
1440 }
|
|
|
1441
|
|
|
1442
|
|
|
1443 int uv_os_get_passwd2(uv_passwd_t* pwd, uv_uid_t uid) {
|
|
|
1444 return uv__getpwuid_r(pwd, uid);
|
|
|
1445 }
|
|
|
1446
|
|
|
1447
|
|
|
1448 int uv_translate_sys_error(int sys_errno) {
|
|
|
1449 /* If < 0 then it's already a libuv error. */
|
|
|
1450 return sys_errno <= 0 ? sys_errno : -sys_errno;
|
|
|
1451 }
|
|
|
1452
|
|
|
1453
|
|
|
1454 int uv_os_environ(uv_env_item_t** envitems, int* count) {
|
|
|
1455 int i, j, cnt;
|
|
|
1456 uv_env_item_t* envitem;
|
|
|
1457
|
|
|
1458 *envitems = NULL;
|
|
|
1459 *count = 0;
|
|
|
1460
|
|
|
1461 for (i = 0; environ[i] != NULL; i++);
|
|
|
1462
|
|
|
1463 *envitems = uv__calloc(i, sizeof(**envitems));
|
|
|
1464
|
|
|
1465 if (*envitems == NULL)
|
|
|
1466 return UV_ENOMEM;
|
|
|
1467
|
|
|
1468 for (j = 0, cnt = 0; j < i; j++) {
|
|
|
1469 char* buf;
|
|
|
1470 char* ptr;
|
|
|
1471
|
|
|
1472 if (environ[j] == NULL)
|
|
|
1473 break;
|
|
|
1474
|
|
|
1475 buf = uv__strdup(environ[j]);
|
|
|
1476 if (buf == NULL)
|
|
|
1477 goto fail;
|
|
|
1478
|
|
|
1479 ptr = strchr(buf, '=');
|
|
|
1480 if (ptr == NULL) {
|
|
|
1481 uv__free(buf);
|
|
|
1482 continue;
|
|
|
1483 }
|
|
|
1484
|
|
|
1485 *ptr = '\0';
|
|
|
1486
|
|
|
1487 envitem = &(*envitems)[cnt];
|
|
|
1488 envitem->name = buf;
|
|
|
1489 envitem->value = ptr + 1;
|
|
|
1490
|
|
|
1491 cnt++;
|
|
|
1492 }
|
|
|
1493
|
|
|
1494 *count = cnt;
|
|
|
1495 return 0;
|
|
|
1496
|
|
|
1497 fail:
|
|
|
1498 for (i = 0; i < cnt; i++) {
|
|
|
1499 envitem = &(*envitems)[cnt];
|
|
|
1500 uv__free(envitem->name);
|
|
|
1501 }
|
|
|
1502 uv__free(*envitems);
|
|
|
1503
|
|
|
1504 *envitems = NULL;
|
|
|
1505 *count = 0;
|
|
|
1506 return UV_ENOMEM;
|
|
|
1507 }
|
|
|
1508
|
|
|
1509
|
|
|
1510 int uv_os_getenv(const char* name, char* buffer, size_t* size) {
|
|
|
1511 char* var;
|
|
|
1512 size_t len;
|
|
|
1513
|
|
|
1514 if (name == NULL || buffer == NULL || size == NULL || *size == 0)
|
|
|
1515 return UV_EINVAL;
|
|
|
1516
|
|
|
1517 var = getenv(name);
|
|
|
1518
|
|
|
1519 if (var == NULL)
|
|
|
1520 return UV_ENOENT;
|
|
|
1521
|
|
|
1522 len = strlen(var);
|
|
|
1523
|
|
|
1524 if (len >= *size) {
|
|
|
1525 *size = len + 1;
|
|
|
1526 return UV_ENOBUFS;
|
|
|
1527 }
|
|
|
1528
|
|
|
1529 memcpy(buffer, var, len + 1);
|
|
|
1530 *size = len;
|
|
|
1531
|
|
|
1532 return 0;
|
|
|
1533 }
|
|
|
1534
|
|
|
1535
|
|
|
1536 int uv_os_setenv(const char* name, const char* value) {
|
|
|
1537 if (name == NULL || value == NULL)
|
|
|
1538 return UV_EINVAL;
|
|
|
1539
|
|
|
1540 if (setenv(name, value, 1) != 0)
|
|
|
1541 return UV__ERR(errno);
|
|
|
1542
|
|
|
1543 return 0;
|
|
|
1544 }
|
|
|
1545
|
|
|
1546
|
|
|
1547 int uv_os_unsetenv(const char* name) {
|
|
|
1548 if (name == NULL)
|
|
|
1549 return UV_EINVAL;
|
|
|
1550
|
|
|
1551 if (unsetenv(name) != 0)
|
|
|
1552 return UV__ERR(errno);
|
|
|
1553
|
|
|
1554 return 0;
|
|
|
1555 }
|
|
|
1556
|
|
|
1557
|
|
|
1558 int uv_os_gethostname(char* buffer, size_t* size) {
|
|
|
1559 /*
|
|
|
1560 On some platforms, if the input buffer is not large enough, gethostname()
|
|
|
1561 succeeds, but truncates the result. libuv can detect this and return ENOBUFS
|
|
|
1562 instead by creating a large enough buffer and comparing the hostname length
|
|
|
1563 to the size input.
|
|
|
1564 */
|
|
|
1565 char buf[UV_MAXHOSTNAMESIZE];
|
|
|
1566 size_t len;
|
|
|
1567
|
|
|
1568 if (buffer == NULL || size == NULL || *size == 0)
|
|
|
1569 return UV_EINVAL;
|
|
|
1570
|
|
|
1571 if (gethostname(buf, sizeof(buf)) != 0)
|
|
|
1572 return UV__ERR(errno);
|
|
|
1573
|
|
|
1574 buf[sizeof(buf) - 1] = '\0'; /* Null terminate, just to be safe. */
|
|
|
1575 len = strlen(buf);
|
|
|
1576
|
|
|
1577 if (len >= *size) {
|
|
|
1578 *size = len + 1;
|
|
|
1579 return UV_ENOBUFS;
|
|
|
1580 }
|
|
|
1581
|
|
|
1582 memcpy(buffer, buf, len + 1);
|
|
|
1583 *size = len;
|
|
|
1584 return 0;
|
|
|
1585 }
|
|
|
1586
|
|
|
1587
|
|
|
1588 uv_os_fd_t uv_get_osfhandle(int fd) {
|
|
|
1589 return fd;
|
|
|
1590 }
|
|
|
1591
|
|
|
1592 int uv_open_osfhandle(uv_os_fd_t os_fd) {
|
|
|
1593 return os_fd;
|
|
|
1594 }
|
|
|
1595
|
|
|
1596 uv_pid_t uv_os_getpid(void) {
|
|
|
1597 return getpid();
|
|
|
1598 }
|
|
|
1599
|
|
|
1600
|
|
|
1601 uv_pid_t uv_os_getppid(void) {
|
|
|
1602 return getppid();
|
|
|
1603 }
|
|
|
1604
|
|
|
1605 int uv_cpumask_size(void) {
|
|
|
1606 #if UV__CPU_AFFINITY_SUPPORTED
|
|
|
1607 return CPU_SETSIZE;
|
|
|
1608 #else
|
|
|
1609 return UV_ENOTSUP;
|
|
|
1610 #endif
|
|
|
1611 }
|
|
|
1612
|
|
|
1613 int uv_os_getpriority(uv_pid_t pid, int* priority) {
|
|
|
1614 int r;
|
|
|
1615
|
|
|
1616 if (priority == NULL)
|
|
|
1617 return UV_EINVAL;
|
|
|
1618
|
|
|
1619 errno = 0;
|
|
|
1620 r = getpriority(PRIO_PROCESS, (int) pid);
|
|
|
1621
|
|
|
1622 if (r == -1 && errno != 0)
|
|
|
1623 return UV__ERR(errno);
|
|
|
1624
|
|
|
1625 *priority = r;
|
|
|
1626 return 0;
|
|
|
1627 }
|
|
|
1628
|
|
|
1629
|
|
|
1630 int uv_os_setpriority(uv_pid_t pid, int priority) {
|
|
|
1631 if (priority < UV_PRIORITY_HIGHEST || priority > UV_PRIORITY_LOW)
|
|
|
1632 return UV_EINVAL;
|
|
|
1633
|
|
|
1634 if (setpriority(PRIO_PROCESS, (int) pid, priority) != 0)
|
|
|
1635 return UV__ERR(errno);
|
|
|
1636
|
|
|
1637 return 0;
|
|
|
1638 }
|
|
|
1639
|
|
|
1640 /**
|
|
|
1641 * If the function succeeds, the return value is 0.
|
|
|
1642 * If the function fails, the return value is non-zero.
|
|
|
1643 * for Linux, when schedule policy is SCHED_OTHER (default), priority is 0.
|
|
|
1644 * So the output parameter priority is actually the nice value.
|
|
|
1645 */
|
|
|
1646 int uv_thread_getpriority(uv_thread_t tid, int* priority) {
|
|
|
1647 int r;
|
|
|
1648 int policy;
|
|
|
1649 struct sched_param param;
|
|
|
1650 #ifdef __linux__
|
|
|
1651 pid_t pid = gettid();
|
|
|
1652 #endif
|
|
|
1653
|
|
|
1654 if (priority == NULL)
|
|
|
1655 return UV_EINVAL;
|
|
|
1656
|
|
|
1657 r = pthread_getschedparam(tid, &policy, ¶m);
|
|
|
1658 if (r != 0)
|
|
|
1659 return UV__ERR(errno);
|
|
|
1660
|
|
|
1661 #ifdef __linux__
|
|
|
1662 if (SCHED_OTHER == policy && pthread_equal(tid, pthread_self())) {
|
|
|
1663 errno = 0;
|
|
|
1664 r = getpriority(PRIO_PROCESS, pid);
|
|
|
1665 if (r == -1 && errno != 0)
|
|
|
1666 return UV__ERR(errno);
|
|
|
1667 *priority = r;
|
|
|
1668 return 0;
|
|
|
1669 }
|
|
|
1670 #endif
|
|
|
1671
|
|
|
1672 *priority = param.sched_priority;
|
|
|
1673 return 0;
|
|
|
1674 }
|
|
|
1675
|
|
|
1676 #ifdef __linux__
|
|
|
1677 static int set_nice_for_calling_thread(int priority) {
|
|
|
1678 int r;
|
|
|
1679 int nice;
|
|
|
1680
|
|
|
1681 if (priority < UV_THREAD_PRIORITY_LOWEST || priority > UV_THREAD_PRIORITY_HIGHEST)
|
|
|
1682 return UV_EINVAL;
|
|
|
1683
|
|
|
1684 pid_t pid = gettid();
|
|
|
1685 nice = 0 - priority * 2;
|
|
|
1686 r = setpriority(PRIO_PROCESS, pid, nice);
|
|
|
1687 if (r != 0)
|
|
|
1688 return UV__ERR(errno);
|
|
|
1689 return 0;
|
|
|
1690 }
|
|
|
1691 #endif
|
|
|
1692
|
|
|
1693 /**
|
|
|
1694 * If the function succeeds, the return value is 0.
|
|
|
1695 * If the function fails, the return value is non-zero.
|
|
|
1696 */
|
|
|
1697 int uv_thread_setpriority(uv_thread_t tid, int priority) {
|
|
|
1698 #if !defined(__GNU__)
|
|
|
1699 int r;
|
|
|
1700 int min;
|
|
|
1701 int max;
|
|
|
1702 int range;
|
|
|
1703 int prio;
|
|
|
1704 int policy;
|
|
|
1705 struct sched_param param;
|
|
|
1706
|
|
|
1707 if (priority < UV_THREAD_PRIORITY_LOWEST || priority > UV_THREAD_PRIORITY_HIGHEST)
|
|
|
1708 return UV_EINVAL;
|
|
|
1709
|
|
|
1710 r = pthread_getschedparam(tid, &policy, ¶m);
|
|
|
1711 if (r != 0)
|
|
|
1712 return UV__ERR(errno);
|
|
|
1713
|
|
|
1714 #ifdef __linux__
|
|
|
1715 /**
|
|
|
1716 * for Linux, when schedule policy is SCHED_OTHER (default), priority must be 0,
|
|
|
1717 * we should set the nice value in this case.
|
|
|
1718 */
|
|
|
1719 if (SCHED_OTHER == policy && pthread_equal(tid, pthread_self()))
|
|
|
1720 return set_nice_for_calling_thread(priority);
|
|
|
1721 #endif
|
|
|
1722
|
|
|
1723 #ifdef __PASE__
|
|
|
1724 min = 1;
|
|
|
1725 max = 127;
|
|
|
1726 #else
|
|
|
1727 min = sched_get_priority_min(policy);
|
|
|
1728 max = sched_get_priority_max(policy);
|
|
|
1729 #endif
|
|
|
1730
|
|
|
1731 if (min == -1 || max == -1)
|
|
|
1732 return UV__ERR(errno);
|
|
|
1733
|
|
|
1734 range = max - min;
|
|
|
1735
|
|
|
1736 switch (priority) {
|
|
|
1737 case UV_THREAD_PRIORITY_HIGHEST:
|
|
|
1738 prio = max;
|
|
|
1739 break;
|
|
|
1740 case UV_THREAD_PRIORITY_ABOVE_NORMAL:
|
|
|
1741 prio = min + range * 3 / 4;
|
|
|
1742 break;
|
|
|
1743 case UV_THREAD_PRIORITY_NORMAL:
|
|
|
1744 prio = min + range / 2;
|
|
|
1745 break;
|
|
|
1746 case UV_THREAD_PRIORITY_BELOW_NORMAL:
|
|
|
1747 prio = min + range / 4;
|
|
|
1748 break;
|
|
|
1749 case UV_THREAD_PRIORITY_LOWEST:
|
|
|
1750 prio = min;
|
|
|
1751 break;
|
|
|
1752 default:
|
|
|
1753 return 0;
|
|
|
1754 }
|
|
|
1755
|
|
|
1756 if (param.sched_priority != prio) {
|
|
|
1757 param.sched_priority = prio;
|
|
|
1758 r = pthread_setschedparam(tid, policy, ¶m);
|
|
|
1759 if (r != 0)
|
|
|
1760 return UV__ERR(errno);
|
|
|
1761 }
|
|
|
1762
|
|
|
1763 return 0;
|
|
|
1764 #else /* !defined(__GNU__) */
|
|
|
1765 /* Simulate success on systems where thread priority is not implemented. */
|
|
|
1766 return 0;
|
|
|
1767 #endif /* !defined(__GNU__) */
|
|
|
1768 }
|
|
|
1769
|
|
|
1770 int uv_os_uname(uv_utsname_t* buffer) {
|
|
|
1771 struct utsname buf;
|
|
|
1772 int r;
|
|
|
1773
|
|
|
1774 if (buffer == NULL)
|
|
|
1775 return UV_EINVAL;
|
|
|
1776
|
|
|
1777 if (uname(&buf) == -1) {
|
|
|
1778 r = UV__ERR(errno);
|
|
|
1779 goto error;
|
|
|
1780 }
|
|
|
1781
|
|
|
1782 r = uv__strscpy(buffer->sysname, buf.sysname, sizeof(buffer->sysname));
|
|
|
1783 if (r == UV_E2BIG)
|
|
|
1784 goto error;
|
|
|
1785
|
|
|
1786 #ifdef _AIX
|
|
|
1787 r = snprintf(buffer->release,
|
|
|
1788 sizeof(buffer->release),
|
|
|
1789 "%s.%s",
|
|
|
1790 buf.version,
|
|
|
1791 buf.release);
|
|
|
1792 if (r >= sizeof(buffer->release)) {
|
|
|
1793 r = UV_E2BIG;
|
|
|
1794 goto error;
|
|
|
1795 }
|
|
|
1796 #else
|
|
|
1797 r = uv__strscpy(buffer->release, buf.release, sizeof(buffer->release));
|
|
|
1798 if (r == UV_E2BIG)
|
|
|
1799 goto error;
|
|
|
1800 #endif
|
|
|
1801
|
|
|
1802 r = uv__strscpy(buffer->version, buf.version, sizeof(buffer->version));
|
|
|
1803 if (r == UV_E2BIG)
|
|
|
1804 goto error;
|
|
|
1805
|
|
|
1806 #if defined(_AIX) || defined(__PASE__)
|
|
|
1807 r = uv__strscpy(buffer->machine, "ppc64", sizeof(buffer->machine));
|
|
|
1808 #else
|
|
|
1809 r = uv__strscpy(buffer->machine, buf.machine, sizeof(buffer->machine));
|
|
|
1810 #endif
|
|
|
1811
|
|
|
1812 if (r == UV_E2BIG)
|
|
|
1813 goto error;
|
|
|
1814
|
|
|
1815 return 0;
|
|
|
1816
|
|
|
1817 error:
|
|
|
1818 buffer->sysname[0] = '\0';
|
|
|
1819 buffer->release[0] = '\0';
|
|
|
1820 buffer->version[0] = '\0';
|
|
|
1821 buffer->machine[0] = '\0';
|
|
|
1822 return r;
|
|
|
1823 }
|
|
|
1824
|
|
|
1825 int uv__getsockpeername(const uv_handle_t* handle,
|
|
|
1826 uv__peersockfunc func,
|
|
|
1827 struct sockaddr* name,
|
|
|
1828 int* namelen) {
|
|
|
1829 socklen_t socklen;
|
|
|
1830 uv_os_fd_t fd;
|
|
|
1831 int r;
|
|
|
1832
|
|
|
1833 r = uv_fileno(handle, &fd);
|
|
|
1834 if (r < 0)
|
|
|
1835 return r;
|
|
|
1836
|
|
|
1837 /* sizeof(socklen_t) != sizeof(int) on some systems. */
|
|
|
1838 socklen = (socklen_t) *namelen;
|
|
|
1839
|
|
|
1840 if (func(fd, name, &socklen))
|
|
|
1841 return UV__ERR(errno);
|
|
|
1842
|
|
|
1843 *namelen = (int) socklen;
|
|
|
1844 return 0;
|
|
|
1845 }
|
|
|
1846
|
|
|
1847 int uv_gettimeofday(uv_timeval64_t* tv) {
|
|
|
1848 struct timeval time;
|
|
|
1849
|
|
|
1850 if (tv == NULL)
|
|
|
1851 return UV_EINVAL;
|
|
|
1852
|
|
|
1853 if (gettimeofday(&time, NULL) != 0)
|
|
|
1854 return UV__ERR(errno);
|
|
|
1855
|
|
|
1856 tv->tv_sec = (int64_t) time.tv_sec;
|
|
|
1857 tv->tv_usec = (int32_t) time.tv_usec;
|
|
|
1858 return 0;
|
|
|
1859 }
|
|
|
1860
|
|
|
1861 void uv_sleep(unsigned int msec) {
|
|
|
1862 struct timespec timeout;
|
|
|
1863 int rc;
|
|
|
1864
|
|
|
1865 timeout.tv_sec = msec / 1000;
|
|
|
1866 timeout.tv_nsec = (msec % 1000) * 1000 * 1000;
|
|
|
1867
|
|
|
1868 do
|
|
|
1869 rc = nanosleep(&timeout, &timeout);
|
|
|
1870 while (rc == -1 && errno == EINTR);
|
|
|
1871
|
|
|
1872 assert(rc == 0);
|
|
|
1873 }
|
|
|
1874
|
|
|
1875 int uv__search_path(const char* prog, char* buf, size_t* buflen) {
|
|
|
1876 char abspath[UV__PATH_MAX];
|
|
|
1877 size_t abspath_size;
|
|
|
1878 char trypath[UV__PATH_MAX];
|
|
|
1879 char* cloned_path;
|
|
|
1880 char* path_env;
|
|
|
1881 char* token;
|
|
|
1882 char* itr;
|
|
|
1883
|
|
|
1884 if (buf == NULL || buflen == NULL || *buflen == 0)
|
|
|
1885 return UV_EINVAL;
|
|
|
1886
|
|
|
1887 /*
|
|
|
1888 * Possibilities for prog:
|
|
|
1889 * i) an absolute path such as: /home/user/myprojects/nodejs/node
|
|
|
1890 * ii) a relative path such as: ./node or ../myprojects/nodejs/node
|
|
|
1891 * iii) a bare filename such as "node", after exporting PATH variable
|
|
|
1892 * to its location.
|
|
|
1893 */
|
|
|
1894
|
|
|
1895 /* Case i) and ii) absolute or relative paths */
|
|
|
1896 if (strchr(prog, '/') != NULL) {
|
|
|
1897 if (realpath(prog, abspath) != abspath)
|
|
|
1898 return UV__ERR(errno);
|
|
|
1899
|
|
|
1900 abspath_size = strlen(abspath);
|
|
|
1901
|
|
|
1902 *buflen -= 1;
|
|
|
1903 if (*buflen > abspath_size)
|
|
|
1904 *buflen = abspath_size;
|
|
|
1905
|
|
|
1906 memcpy(buf, abspath, *buflen);
|
|
|
1907 buf[*buflen] = '\0';
|
|
|
1908
|
|
|
1909 return 0;
|
|
|
1910 }
|
|
|
1911
|
|
|
1912 /* Case iii). Search PATH environment variable */
|
|
|
1913 cloned_path = NULL;
|
|
|
1914 token = NULL;
|
|
|
1915 path_env = getenv("PATH");
|
|
|
1916
|
|
|
1917 if (path_env == NULL)
|
|
|
1918 return UV_EINVAL;
|
|
|
1919
|
|
|
1920 cloned_path = uv__strdup(path_env);
|
|
|
1921 if (cloned_path == NULL)
|
|
|
1922 return UV_ENOMEM;
|
|
|
1923
|
|
|
1924 token = uv__strtok(cloned_path, ":", &itr);
|
|
|
1925 while (token != NULL) {
|
|
|
1926 snprintf(trypath, sizeof(trypath) - 1, "%s/%s", token, prog);
|
|
|
1927 if (realpath(trypath, abspath) == abspath) {
|
|
|
1928 /* Check the match is executable */
|
|
|
1929 if (access(abspath, X_OK) == 0) {
|
|
|
1930 abspath_size = strlen(abspath);
|
|
|
1931
|
|
|
1932 *buflen -= 1;
|
|
|
1933 if (*buflen > abspath_size)
|
|
|
1934 *buflen = abspath_size;
|
|
|
1935
|
|
|
1936 memcpy(buf, abspath, *buflen);
|
|
|
1937 buf[*buflen] = '\0';
|
|
|
1938
|
|
|
1939 uv__free(cloned_path);
|
|
|
1940 return 0;
|
|
|
1941 }
|
|
|
1942 }
|
|
|
1943 token = uv__strtok(NULL, ":", &itr);
|
|
|
1944 }
|
|
|
1945 uv__free(cloned_path);
|
|
|
1946
|
|
|
1947 /* Out of tokens (path entries), and no match found */
|
|
|
1948 return UV_EINVAL;
|
|
|
1949 }
|
|
|
1950
|
|
|
1951 #if defined(__linux__) || defined (__FreeBSD__)
|
|
|
1952 # define uv__cpu_count(cpuset) CPU_COUNT(cpuset)
|
|
|
1953 #elif defined(__NetBSD__)
|
|
|
1954 static int uv__cpu_count(cpuset_t* set) {
|
|
|
1955 int rc;
|
|
|
1956 cpuid_t i;
|
|
|
1957
|
|
|
1958 rc = 0;
|
|
|
1959 for (i = 0;; i++) {
|
|
|
1960 int r = cpuset_isset(i, set);
|
|
|
1961 if (r < 0)
|
|
|
1962 break;
|
|
|
1963 if (r)
|
|
|
1964 rc++;
|
|
|
1965 }
|
|
|
1966
|
|
|
1967 return rc;
|
|
|
1968 }
|
|
|
1969 #endif /* __NetBSD__ */
|
|
|
1970
|
|
|
1971 unsigned int uv_available_parallelism(void) {
|
|
|
1972 long rc = -1;
|
|
|
1973
|
|
|
1974 #ifdef __linux__
|
|
|
1975 cpu_set_t set;
|
|
|
1976
|
|
|
1977 memset(&set, 0, sizeof(set));
|
|
|
1978
|
|
|
1979 /* sysconf(_SC_NPROCESSORS_ONLN) in musl calls sched_getaffinity() but in
|
|
|
1980 * glibc it's... complicated... so for consistency try sched_getaffinity()
|
|
|
1981 * before falling back to sysconf(_SC_NPROCESSORS_ONLN).
|
|
|
1982 */
|
|
|
1983 if (0 == sched_getaffinity(0, sizeof(set), &set))
|
|
|
1984 rc = uv__cpu_count(&set);
|
|
|
1985 #elif defined(__MVS__)
|
|
|
1986 rc = __get_num_online_cpus();
|
|
|
1987 if (rc < 1)
|
|
|
1988 rc = 1;
|
|
|
1989
|
|
|
1990 return (unsigned) rc;
|
|
|
1991 #elif defined(__FreeBSD__)
|
|
|
1992 cpuset_t set;
|
|
|
1993
|
|
|
1994 memset(&set, 0, sizeof(set));
|
|
|
1995
|
|
|
1996 if (0 == cpuset_getaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, -1, sizeof(set), &set))
|
|
|
1997 rc = uv__cpu_count(&set);
|
|
|
1998 #elif defined(__NetBSD__)
|
|
|
1999 cpuset_t* set = cpuset_create();
|
|
|
2000 if (set != NULL) {
|
|
|
2001 if (0 == sched_getaffinity_np(getpid(), sizeof(set), &set))
|
|
|
2002 rc = uv__cpu_count(&set);
|
|
|
2003 cpuset_destroy(set);
|
|
|
2004 }
|
|
|
2005 #elif defined(__APPLE__)
|
|
|
2006 int nprocs;
|
|
|
2007 size_t i;
|
|
|
2008 size_t len = sizeof(nprocs);
|
|
|
2009 static const char *mib[] = {
|
|
|
2010 "hw.activecpu",
|
|
|
2011 "hw.logicalcpu",
|
|
|
2012 "hw.ncpu"
|
|
|
2013 };
|
|
|
2014
|
|
|
2015 for (i = 0; i < ARRAY_SIZE(mib); i++) {
|
|
|
2016 if (0 == sysctlbyname(mib[i], &nprocs, &len, NULL, 0) &&
|
|
|
2017 len == sizeof(nprocs) &&
|
|
|
2018 nprocs > 0) {
|
|
|
2019 rc = nprocs;
|
|
|
2020 break;
|
|
|
2021 }
|
|
|
2022 }
|
|
|
2023 #elif defined(__OpenBSD__)
|
|
|
2024 int nprocs;
|
|
|
2025 size_t i;
|
|
|
2026 size_t len = sizeof(nprocs);
|
|
|
2027 static int mib[][2] = {
|
|
|
2028 # ifdef HW_NCPUONLINE
|
|
|
2029 { CTL_HW, HW_NCPUONLINE },
|
|
|
2030 # endif
|
|
|
2031 { CTL_HW, HW_NCPU }
|
|
|
2032 };
|
|
|
2033
|
|
|
2034 for (i = 0; i < ARRAY_SIZE(mib); i++) {
|
|
|
2035 if (0 == sysctl(mib[i], ARRAY_SIZE(mib[i]), &nprocs, &len, NULL, 0) &&
|
|
|
2036 len == sizeof(nprocs) &&
|
|
|
2037 nprocs > 0) {
|
|
|
2038 rc = nprocs;
|
|
|
2039 break;
|
|
|
2040 }
|
|
|
2041 }
|
|
|
2042 #endif /* __linux__ */
|
|
|
2043
|
|
|
2044 if (rc < 0)
|
|
|
2045 rc = sysconf(_SC_NPROCESSORS_ONLN);
|
|
|
2046
|
|
|
2047 #ifdef __linux__
|
|
|
2048 {
|
|
|
2049 long long quota = 0;
|
|
|
2050
|
|
|
2051 if (uv__get_constrained_cpu("a) == 0)
|
|
|
2052 if (quota > 0 && quota < rc)
|
|
|
2053 rc = quota;
|
|
|
2054 }
|
|
|
2055 #endif /* __linux__ */
|
|
|
2056
|
|
|
2057 if (rc < 1)
|
|
|
2058 rc = 1;
|
|
|
2059
|
|
|
2060 return (unsigned) rc;
|
|
|
2061 }
|
|
|
2062
|
|
|
2063 int uv__sock_reuseport(int fd) {
|
|
|
2064 int on = 1;
|
|
|
2065 #if defined(__FreeBSD__) && __FreeBSD__ >= 12 && defined(SO_REUSEPORT_LB)
|
|
|
2066 /* FreeBSD 12 introduced a new socket option named SO_REUSEPORT_LB
|
|
|
2067 * with the capability of load balancing, it's the substitution of
|
|
|
2068 * the SO_REUSEPORTs on Linux and DragonFlyBSD. */
|
|
|
2069 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT_LB, &on, sizeof(on)))
|
|
|
2070 return UV__ERR(errno);
|
|
|
2071 #elif (defined(__linux__) || \
|
|
|
2072 defined(_AIX73) || \
|
|
|
2073 (defined(__DragonFly__) && __DragonFly_version >= 300600) || \
|
|
|
2074 (defined(UV__SOLARIS_11_4) && UV__SOLARIS_11_4)) && \
|
|
|
2075 defined(SO_REUSEPORT)
|
|
|
2076 /* On Linux 3.9+, the SO_REUSEPORT implementation distributes connections
|
|
|
2077 * evenly across all of the threads (or processes) that are blocked in
|
|
|
2078 * accept() on the same port. As with TCP, SO_REUSEPORT distributes datagrams
|
|
|
2079 * evenly across all of the receiving threads (or process).
|
|
|
2080 *
|
|
|
2081 * DragonFlyBSD 3.6.0 extended SO_REUSEPORT to distribute workload to
|
|
|
2082 * available sockets, which made it the equivalent of Linux's SO_REUSEPORT.
|
|
|
2083 *
|
|
|
2084 * AIX 7.2.5 added the feature that would add the capability to distribute
|
|
|
2085 * incoming connections or datagrams across all listening ports for SO_REUSEPORT.
|
|
|
2086 *
|
|
|
2087 * Solaris 11 supported SO_REUSEPORT, but it's implemented only for
|
|
|
2088 * binding to the same address and port, without load balancing.
|
|
|
2089 * Solaris 11.4 extended SO_REUSEPORT with the capability of load balancing.
|
|
|
2090 */
|
|
|
2091 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on)))
|
|
|
2092 return UV__ERR(errno);
|
|
|
2093 #else
|
|
|
2094 (void) (fd);
|
|
|
2095 (void) (on);
|
|
|
2096 /* SO_REUSEPORTs do not have the capability of load balancing on platforms
|
|
|
2097 * other than those mentioned above. The semantics are completely different,
|
|
|
2098 * therefore we shouldn't enable it, but fail this operation to indicate that
|
|
|
2099 * UV_[TCP/UDP]_REUSEPORT is not supported on these platforms. */
|
|
|
2100 return UV_ENOTSUP;
|
|
|
2101 #endif
|
|
|
2102
|
|
|
2103 return 0;
|
|
|
2104 }
|
