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_ */ 475
Indexes created Mon May 25 00:24:39 UTC 2026