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 #ifndef UV_WIN_REQ_INL_H_ 23 #define UV_WIN_REQ_INL_H_ 24 25 #include <assert.h> 26 27 #include "uv.h" 28 #include "internal.h" 29 30 31 #define SET_REQ_STATUS(req, status) \ 32 (req)->u.io.overlapped.Internal = (ULONG_PTR) (status) 33 34 #define SET_REQ_ERROR(req, error) \ 35 SET_REQ_STATUS((req), NTSTATUS_FROM_WIN32((error))) 36 37 /* Note: used open-coded in UV_REQ_INIT() because of a circular dependency 38 * between src/uv-common.h and src/win/internal.h. 39 */ 40 #define SET_REQ_SUCCESS(req) \ 41 SET_REQ_STATUS((req), STATUS_SUCCESS) 42 43 #define GET_REQ_STATUS(req) \ 44 ((NTSTATUS) (req)->u.io.overlapped.Internal) 45 46 #define REQ_SUCCESS(req) \ 47 (NT_SUCCESS(GET_REQ_STATUS((req)))) 48 49 #define GET_REQ_ERROR(req) \ 50 (pRtlNtStatusToDosError(GET_REQ_STATUS((req)))) 51 52 #define GET_REQ_SOCK_ERROR(req) \ 53 (uv__ntstatus_to_winsock_error(GET_REQ_STATUS((req)))) 54 55 56 #define REGISTER_HANDLE_REQ(loop, handle) \ 57 do { \ 58 INCREASE_ACTIVE_COUNT((loop), (handle)); \ 59 uv__req_register((loop)); \ 60 } while (0) 61 62 #define UNREGISTER_HANDLE_REQ(loop, handle) \ 63 do { \ 64 DECREASE_ACTIVE_COUNT((loop), (handle)); \ 65 uv__req_unregister((loop)); \ 66 } while (0) 67 68 69 #define UV_SUCCEEDED_WITHOUT_IOCP(result) \ 70 ((result) && (handle->flags & UV_HANDLE_SYNC_BYPASS_IOCP)) 71 72 #define UV_SUCCEEDED_WITH_IOCP(result) \ 73 ((result) || (GetLastError() == ERROR_IO_PENDING)) 74 75 76 #define POST_COMPLETION_FOR_REQ(loop, req) \ 77 if (!PostQueuedCompletionStatus((loop)->iocp, \ 78 0, \ 79 0, \ 80 &((req)->u.io.overlapped))) { \ 81 uv_fatal_error(GetLastError(), "PostQueuedCompletionStatus"); \ 82 } 83 84 85 INLINE static uv_req_t* uv__overlapped_to_req(OVERLAPPED* overlapped) { 86 return container_of(overlapped, uv_req_t, u.io.overlapped); 87 } 88 89 90 INLINE static void uv__insert_pending_req(uv_loop_t* loop, uv_req_t* req) { 91 req->next_req = NULL; 92 if (loop->pending_reqs_tail) { 93 #ifdef _DEBUG 94 /* Ensure the request is not already in the queue, or the queue 95 * will get corrupted. 96 */ 97 uv_req_t* current = loop->pending_reqs_tail; 98 do { 99 assert(req != current); 100 current = current->next_req; 101 } while(current != loop->pending_reqs_tail); 102 #endif 103 104 req->next_req = loop->pending_reqs_tail->next_req; 105 loop->pending_reqs_tail->next_req = req; 106 loop->pending_reqs_tail = req; 107 } else { 108 req->next_req = req; 109 loop->pending_reqs_tail = req; 110 } 111 } 112 113 114 #define DELEGATE_STREAM_REQ(loop, req, method, handle_at) \ 115 do { \ 116 switch (((uv_handle_t*) (req)->handle_at)->type) { \ 117 case UV_TCP: \ 118 uv__process_tcp_##method##_req(loop, \ 119 (uv_tcp_t*) ((req)->handle_at), \ 120 req); \ 121 break; \ 122 \ 123 case UV_NAMED_PIPE: \ 124 uv__process_pipe_##method##_req(loop, \ 125 (uv_pipe_t*) ((req)->handle_at), \ 126 req); \ 127 break; \ 128 \ 129 case UV_TTY: \ 130 uv__process_tty_##method##_req(loop, \ 131 (uv_tty_t*) ((req)->handle_at), \ 132 req); \ 133 break; \ 134 \ 135 default: \ 136 assert(0); \ 137 } \ 138 } while (0) 139 140 141 INLINE static void uv__process_reqs(uv_loop_t* loop) { 142 uv_req_t* req; 143 uv_req_t* first; 144 uv_req_t* next; 145 146 if (loop->pending_reqs_tail == NULL) 147 return; 148 149 first = loop->pending_reqs_tail->next_req; 150 next = first; 151 loop->pending_reqs_tail = NULL; 152 153 while (next != NULL) { 154 req = next; 155 next = req->next_req != first ? req->next_req : NULL; 156 157 switch (req->type) { 158 case UV_READ: 159 DELEGATE_STREAM_REQ(loop, req, read, data); 160 break; 161 162 case UV_WRITE: 163 DELEGATE_STREAM_REQ(loop, (uv_write_t*) req, write, handle); 164 break; 165 166 case UV_ACCEPT: 167 DELEGATE_STREAM_REQ(loop, req, accept, data); 168 break; 169 170 case UV_CONNECT: 171 DELEGATE_STREAM_REQ(loop, (uv_connect_t*) req, connect, handle); 172 break; 173 174 case UV_SHUTDOWN: 175 DELEGATE_STREAM_REQ(loop, (uv_shutdown_t*) req, shutdown, handle); 176 break; 177 178 case UV_UDP_RECV: 179 uv__process_udp_recv_req(loop, (uv_udp_t*) req->data, req); 180 break; 181 182 case UV_UDP_SEND: 183 uv__process_udp_send_req(loop, 184 ((uv_udp_send_t*) req)->handle, 185 (uv_udp_send_t*) req); 186 break; 187 188 case UV_WAKEUP: 189 uv__process_async_wakeup_req(loop, (uv_async_t*) req->data, req); 190 break; 191 192 case UV_SIGNAL_REQ: 193 uv__process_signal_req(loop, (uv_signal_t*) req->data, req); 194 break; 195 196 case UV_POLL_REQ: 197 uv__process_poll_req(loop, (uv_poll_t*) req->data, req); 198 break; 199 200 case UV_PROCESS_EXIT: 201 uv__process_proc_exit(loop, (uv_process_t*) req->data); 202 break; 203 204 case UV_FS_EVENT_REQ: 205 uv__process_fs_event_req(loop, req, (uv_fs_event_t*) req->data); 206 break; 207 208 default: 209 assert(0); 210 } 211 } 212 } 213 214 #endif /* UV_WIN_REQ_INL_H_ */ 215
Indexes created Fri Jun 26 00:24:39 UTC 2026