Mercurial

comparison third_party/libuv/src/uv-common.h @ 160:948de3f54cea

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[ThirdParty] Added libuv
author June Park <parkjune1995@gmail.com>
date Wed, 14 Jan 2026 19:39:52 -0800
parents
children
comparison
equal deleted inserted replaced
159:05cf9467a1c3 160:948de3f54cea
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 /*
23 * This file is private to libuv. It provides common functionality to both
24 * Windows and Unix backends.
25 */
26
27 #ifndef UV_COMMON_H_
28 #define UV_COMMON_H_
29
30 #include <assert.h>
31 #include <stdarg.h>
32 #include <stddef.h>
33 #include <stdint.h>
34 #include <string.h>
35
36 #include "uv.h"
37 #include "uv/tree.h"
38 #include "queue.h"
39 #include "strscpy.h"
40
41 #ifndef _MSC_VER
42 # include <stdatomic.h>
43 #endif
44
45 #if EDOM > 0
46 # define UV__ERR(x) (-(x))
47 #else
48 # define UV__ERR(x) (x)
49 #endif
50
51 #if !defined(snprintf) && defined(_MSC_VER) && _MSC_VER < 1900
52 extern int snprintf(char*, size_t, const char*, ...);
53 #endif
54
55 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
56 #define ARRAY_END(a) ((a) + ARRAY_SIZE(a))
57
58 #define container_of(ptr, type, member) \
59 ((type *) ((char *) (ptr) - offsetof(type, member)))
60
61 /* C11 defines static_assert to be a macro which calls _Static_assert. */
62 #if defined(static_assert)
63 #define STATIC_ASSERT(expr) static_assert(expr, #expr)
64 #else
65 #define STATIC_ASSERT(expr) \
66 void uv__static_assert(int static_assert_failed[1 - 2 * !(expr)])
67 #endif
68
69 #ifdef _MSC_VER
70 #define uv__exchange_int_relaxed(p, v) \
71 InterlockedExchangeNoFence((LONG volatile*)(p), v)
72 #else
73 #define uv__exchange_int_relaxed(p, v) \
74 atomic_exchange_explicit((_Atomic int*)(p), v, memory_order_relaxed)
75 #endif
76
77 #define UV__UDP_DGRAM_MAXSIZE (64 * 1024)
78
79 /* Handle flags. Some flags are specific to Windows or UNIX. */
80 enum {
81 /* Used by all handles. */
82 UV_HANDLE_CLOSING = 0x00000001,
83 UV_HANDLE_CLOSED = 0x00000002,
84 UV_HANDLE_ACTIVE = 0x00000004,
85 UV_HANDLE_REF = 0x00000008,
86 UV_HANDLE_INTERNAL = 0x00000010,
87 UV_HANDLE_ENDGAME_QUEUED = 0x00000020,
88
89 /* Used by streams. */
90 UV_HANDLE_LISTENING = 0x00000040,
91 UV_HANDLE_CONNECTION = 0x00000080,
92 UV_HANDLE_SHUT = 0x00000200,
93 UV_HANDLE_READ_PARTIAL = 0x00000400,
94 UV_HANDLE_READ_EOF = 0x00000800,
95
96 /* Used by streams and UDP handles. */
97 UV_HANDLE_READING = 0x00001000,
98 UV_HANDLE_BOUND = 0x00002000,
99 UV_HANDLE_READABLE = 0x00004000,
100 UV_HANDLE_WRITABLE = 0x00008000,
101 UV_HANDLE_READ_PENDING = 0x00010000,
102 UV_HANDLE_SYNC_BYPASS_IOCP = 0x00020000,
103 UV_HANDLE_ZERO_READ = 0x00040000,
104 UV_HANDLE_EMULATE_IOCP = 0x00080000,
105 UV_HANDLE_BLOCKING_WRITES = 0x00100000,
106 UV_HANDLE_CANCELLATION_PENDING = 0x00200000,
107
108 /* Used by uv_tcp_t and uv_udp_t handles */
109 UV_HANDLE_IPV6 = 0x00400000,
110
111 /* Only used by uv_tcp_t handles. */
112 UV_HANDLE_TCP_NODELAY = 0x01000000,
113 UV_HANDLE_TCP_KEEPALIVE = 0x02000000,
114 UV_HANDLE_TCP_SINGLE_ACCEPT = 0x04000000,
115 UV_HANDLE_TCP_ACCEPT_STATE_CHANGING = 0x08000000,
116 UV_HANDLE_SHARED_TCP_SOCKET = 0x10000000,
117
118 /* Only used by uv_udp_t handles. */
119 UV_HANDLE_UDP_PROCESSING = 0x01000000,
120 UV_HANDLE_UDP_CONNECTED = 0x02000000,
121 UV_HANDLE_UDP_RECVMMSG = 0x04000000,
122
123 /* Only used by uv_pipe_t handles. */
124 UV_HANDLE_NON_OVERLAPPED_PIPE = 0x01000000,
125 UV_HANDLE_PIPESERVER = 0x02000000,
126
127 /* Only used by uv_tty_t handles. */
128 UV_HANDLE_TTY_READABLE = 0x01000000,
129 UV_HANDLE_UNUSED0 = 0x02000000,
130 UV_HANDLE_TTY_SAVED_POSITION = 0x04000000,
131 UV_HANDLE_TTY_SAVED_ATTRIBUTES = 0x08000000,
132
133 /* Only used by uv_signal_t handles. */
134 UV_SIGNAL_ONE_SHOT_DISPATCHED = 0x01000000,
135 UV_SIGNAL_ONE_SHOT = 0x02000000,
136
137 /* Only used by uv_poll_t handles. */
138 UV_HANDLE_POLL_SLOW = 0x01000000,
139
140 /* Only used by uv_process_t handles. */
141 UV_HANDLE_REAP = 0x10000000
142 };
143
144 static inline int uv__is_raw_tty_mode(uv_tty_mode_t m) {
145 return m == UV_TTY_MODE_RAW || m == UV_TTY_MODE_RAW_VT;
146 }
147
148 int uv__loop_configure(uv_loop_t* loop, uv_loop_option option, va_list ap);
149
150 void uv__loop_close(uv_loop_t* loop);
151
152 int uv__read_start(uv_stream_t* stream,
153 uv_alloc_cb alloc_cb,
154 uv_read_cb read_cb);
155
156 int uv__tcp_bind(uv_tcp_t* tcp,
157 const struct sockaddr* addr,
158 unsigned int addrlen,
159 unsigned int flags);
160
161 int uv__tcp_connect(uv_connect_t* req,
162 uv_tcp_t* handle,
163 const struct sockaddr* addr,
164 unsigned int addrlen,
165 uv_connect_cb cb);
166
167 int uv__udp_init_ex(uv_loop_t* loop,
168 uv_udp_t* handle,
169 unsigned flags,
170 int domain);
171
172 int uv__udp_bind(uv_udp_t* handle,
173 const struct sockaddr* addr,
174 unsigned int addrlen,
175 unsigned int flags);
176
177 int uv__udp_connect(uv_udp_t* handle,
178 const struct sockaddr* addr,
179 unsigned int addrlen);
180
181 int uv__udp_disconnect(uv_udp_t* handle);
182
183 int uv__udp_is_connected(uv_udp_t* handle);
184
185 int uv__udp_send(uv_udp_send_t* req,
186 uv_udp_t* handle,
187 const uv_buf_t bufs[],
188 unsigned int nbufs,
189 const struct sockaddr* addr,
190 unsigned int addrlen,
191 uv_udp_send_cb send_cb);
192
193 int uv__udp_try_send(uv_udp_t* handle,
194 const uv_buf_t bufs[],
195 unsigned int nbufs,
196 const struct sockaddr* addr,
197 unsigned int addrlen);
198
199 int uv__udp_try_send2(uv_udp_t* handle,
200 unsigned int count,
201 uv_buf_t* bufs[/*count*/],
202 unsigned int nbufs[/*count*/],
203 struct sockaddr* addrs[/*count*/]);
204
205 int uv__udp_recv_start(uv_udp_t* handle, uv_alloc_cb alloccb,
206 uv_udp_recv_cb recv_cb);
207
208 int uv__udp_recv_stop(uv_udp_t* handle);
209
210 void uv__fs_poll_close(uv_fs_poll_t* handle);
211
212 int uv__getaddrinfo_translate_error(int sys_err); /* EAI_* error. */
213
214 enum uv__work_kind {
215 UV__WORK_CPU,
216 UV__WORK_FAST_IO,
217 UV__WORK_SLOW_IO
218 };
219
220 void uv__work_submit(uv_loop_t* loop,
221 struct uv__work *w,
222 enum uv__work_kind kind,
223 void (*work)(struct uv__work *w),
224 void (*done)(struct uv__work *w, int status));
225
226 void uv__work_done(uv_async_t* handle);
227
228 size_t uv__count_bufs(const uv_buf_t bufs[], unsigned int nbufs);
229
230 int uv__socket_sockopt(uv_handle_t* handle, int optname, int* value);
231
232 void uv__fs_scandir_cleanup(uv_fs_t* req);
233 void uv__fs_readdir_cleanup(uv_fs_t* req);
234 uv_dirent_type_t uv__fs_get_dirent_type(uv__dirent_t* dent);
235
236 int uv__next_timeout(const uv_loop_t* loop);
237 void uv__run_timers(uv_loop_t* loop);
238 void uv__timer_close(uv_timer_t* handle);
239
240 void uv__process_title_cleanup(void);
241 void uv__signal_cleanup(void);
242 void uv__threadpool_cleanup(void);
243
244 #define uv__has_active_reqs(loop) \
245 ((loop)->active_reqs.count > 0)
246
247 #define uv__req_register(loop) \
248 do { \
249 (loop)->active_reqs.count++; \
250 } \
251 while (0)
252
253 #define uv__req_unregister(loop) \
254 do { \
255 assert(uv__has_active_reqs(loop)); \
256 (loop)->active_reqs.count--; \
257 } \
258 while (0)
259
260 #define uv__has_active_handles(loop) \
261 ((loop)->active_handles > 0)
262
263 #define uv__active_handle_add(h) \
264 do { \
265 (h)->loop->active_handles++; \
266 } \
267 while (0)
268
269 #define uv__active_handle_rm(h) \
270 do { \
271 (h)->loop->active_handles--; \
272 } \
273 while (0)
274
275 #define uv__is_active(h) \
276 (((h)->flags & UV_HANDLE_ACTIVE) != 0)
277
278 #define uv__is_closing(h) \
279 (((h)->flags & (UV_HANDLE_CLOSING | UV_HANDLE_CLOSED)) != 0)
280
281 #if defined(_WIN32)
282 # define uv__is_stream_shutting(h) \
283 (h->stream.conn.shutdown_req != NULL)
284 #else
285 # define uv__is_stream_shutting(h) \
286 (h->shutdown_req != NULL)
287 #endif
288
289 #define uv__handle_start(h) \
290 do { \
291 if (((h)->flags & UV_HANDLE_ACTIVE) != 0) break; \
292 (h)->flags |= UV_HANDLE_ACTIVE; \
293 if (((h)->flags & UV_HANDLE_REF) != 0) uv__active_handle_add(h); \
294 } \
295 while (0)
296
297 #define uv__handle_stop(h) \
298 do { \
299 if (((h)->flags & UV_HANDLE_ACTIVE) == 0) break; \
300 (h)->flags &= ~UV_HANDLE_ACTIVE; \
301 if (((h)->flags & UV_HANDLE_REF) != 0) uv__active_handle_rm(h); \
302 } \
303 while (0)
304
305 #define uv__handle_ref(h) \
306 do { \
307 if (((h)->flags & UV_HANDLE_REF) != 0) break; \
308 (h)->flags |= UV_HANDLE_REF; \
309 if (((h)->flags & UV_HANDLE_CLOSING) != 0) break; \
310 if (((h)->flags & UV_HANDLE_ACTIVE) != 0) uv__active_handle_add(h); \
311 } \
312 while (0)
313
314 #define uv__handle_unref(h) \
315 do { \
316 if (((h)->flags & UV_HANDLE_REF) == 0) break; \
317 (h)->flags &= ~UV_HANDLE_REF; \
318 if (((h)->flags & UV_HANDLE_CLOSING) != 0) break; \
319 if (((h)->flags & UV_HANDLE_ACTIVE) != 0) uv__active_handle_rm(h); \
320 } \
321 while (0)
322
323 #define uv__has_ref(h) \
324 (((h)->flags & UV_HANDLE_REF) != 0)
325
326 #if defined(_WIN32)
327 # define uv__handle_platform_init(h) ((h)->u.fd = -1)
328 #else
329 # define uv__handle_platform_init(h) ((h)->next_closing = NULL)
330 #endif
331
332 #define uv__handle_init(loop_, h, type_) \
333 do { \
334 (h)->loop = (loop_); \
335 (h)->type = (type_); \
336 (h)->flags = UV_HANDLE_REF; /* Ref the loop when active. */ \
337 uv__queue_insert_tail(&(loop_)->handle_queue, &(h)->handle_queue); \
338 uv__handle_platform_init(h); \
339 } \
340 while (0)
341
342 /* Note: uses an open-coded version of SET_REQ_SUCCESS() because of
343 * a circular dependency between src/uv-common.h and src/win/internal.h.
344 */
345 #if defined(_WIN32)
346 # define UV_REQ_INIT(req, typ) \
347 do { \
348 (req)->type = (typ); \
349 (req)->u.io.overlapped.Internal = 0; /* SET_REQ_SUCCESS() */ \
350 } \
351 while (0)
352 #else
353 # define UV_REQ_INIT(req, typ) \
354 do { \
355 (req)->type = (typ); \
356 } \
357 while (0)
358 #endif
359
360 #define uv__req_init(loop, req, typ) \
361 do { \
362 UV_REQ_INIT(req, typ); \
363 uv__req_register(loop); \
364 } \
365 while (0)
366
367 #define uv__get_internal_fields(loop) \
368 ((uv__loop_internal_fields_t*) loop->internal_fields)
369
370 #define uv__get_loop_metrics(loop) \
371 (&uv__get_internal_fields(loop)->loop_metrics)
372
373 #define uv__metrics_inc_loop_count(loop) \
374 do { \
375 uv__get_loop_metrics(loop)->metrics.loop_count++; \
376 } while (0)
377
378 #define uv__metrics_inc_events(loop, e) \
379 do { \
380 uv__get_loop_metrics(loop)->metrics.events += (e); \
381 } while (0)
382
383 #define uv__metrics_inc_events_waiting(loop, e) \
384 do { \
385 uv__get_loop_metrics(loop)->metrics.events_waiting += (e); \
386 } while (0)
387
388 /* Allocator prototypes */
389 void *uv__calloc(size_t count, size_t size);
390 char *uv__strdup(const char* s);
391 char *uv__strndup(const char* s, size_t n);
392 void* uv__malloc(size_t size);
393 void uv__free(void* ptr);
394 void* uv__realloc(void* ptr, size_t size);
395 void* uv__reallocf(void* ptr, size_t size);
396
397 typedef struct uv__loop_metrics_s uv__loop_metrics_t;
398 typedef struct uv__loop_internal_fields_s uv__loop_internal_fields_t;
399
400 struct uv__loop_metrics_s {
401 uv_metrics_t metrics;
402 uint64_t provider_entry_time;
403 uint64_t provider_idle_time;
404 uv_mutex_t lock;
405 };
406
407 void uv__metrics_update_idle_time(uv_loop_t* loop);
408 void uv__metrics_set_provider_entry_time(uv_loop_t* loop);
409
410 #ifdef __linux__
411 struct uv__iou {
412 uint32_t* sqhead;
413 uint32_t* sqtail;
414 uint32_t sqmask;
415 uint32_t* sqflags;
416 uint32_t* cqhead;
417 uint32_t* cqtail;
418 uint32_t cqmask;
419 void* sq; /* pointer to munmap() on event loop teardown */
420 void* cqe; /* pointer to array of struct uv__io_uring_cqe */
421 void* sqe; /* pointer to array of struct uv__io_uring_sqe */
422 size_t sqlen;
423 size_t cqlen;
424 size_t maxlen;
425 size_t sqelen;
426 int ringfd;
427 uint32_t in_flight;
428 };
429 #endif /* __linux__ */
430
431 struct uv__loop_internal_fields_s {
432 unsigned int flags;
433 uv__loop_metrics_t loop_metrics;
434 int current_timeout;
435 #ifdef __linux__
436 struct uv__iou ctl;
437 struct uv__iou iou;
438 void* inv; /* used by uv__platform_invalidate_fd() */
439 #endif /* __linux__ */
440 };
441
442 #if defined(_WIN32)
443 # define UV_PTHREAD_MAX_NAMELEN_NP 32767
444 #elif defined(__APPLE__)
445 # define UV_PTHREAD_MAX_NAMELEN_NP 64
446 #elif defined(__NetBSD__) || defined(__illumos__)
447 # define UV_PTHREAD_MAX_NAMELEN_NP PTHREAD_MAX_NAMELEN_NP
448 #elif defined (__linux__)
449 # define UV_PTHREAD_MAX_NAMELEN_NP 16
450 #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
451 # define UV_PTHREAD_MAX_NAMELEN_NP (MAXCOMLEN + 1)
452 #else
453 # define UV_PTHREAD_MAX_NAMELEN_NP 16
454 #endif
455
456 /* Open-coded so downstream users don't have to link libm. */
457 static inline int uv__isinf(double d) {
458 uint64_t v;
459
460 STATIC_ASSERT(sizeof(v) == sizeof(d));
461 memcpy(&v, &d, sizeof(v));
462 return (v << 1 >> 53) == 2047 && !(v << 12);
463 }
464
465 /* Open-coded so downstream users don't have to link libm. */
466 static inline int uv__isnan(double d) {
467 uint64_t v;
468
469 STATIC_ASSERT(sizeof(v) == sizeof(d));
470 memcpy(&v, &d, sizeof(v));
471 return (v << 1 >> 53) == 2047 && !!(v << 12);
472 }
473
474 #endif /* UV_COMMON_H_ */