buffer_iocp.c revision 1.1.1.2
1 /* $NetBSD: buffer_iocp.c,v 1.1.1.2 2017/01/31 21:14:52 christos Exp $ */ 2 /* 3 * Copyright (c) 2009-2012 Niels Provos and Nick Mathewson 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 /** 29 @file buffer_iocp.c 30 31 This module implements overlapped read and write functions for evbuffer 32 objects on Windows. 33 */ 34 #include "event2/event-config.h" 35 #include <sys/cdefs.h> 36 __RCSID("$NetBSD: buffer_iocp.c,v 1.1.1.2 2017/01/31 21:14:52 christos Exp $"); 37 #include "evconfig-private.h" 38 39 #include "event2/buffer.h" 40 #include "event2/buffer_compat.h" 41 #include "event2/util.h" 42 #include "event2/thread.h" 43 #include "util-internal.h" 44 #include "evthread-internal.h" 45 #include "evbuffer-internal.h" 46 #include "iocp-internal.h" 47 #include "mm-internal.h" 48 49 #include <winsock2.h> 50 #include <windows.h> 51 #include <stdio.h> 52 53 #define MAX_WSABUFS 16 54 55 /** An evbuffer that can handle overlapped IO. */ 56 struct evbuffer_overlapped { 57 struct evbuffer buffer; 58 /** The socket that we're doing overlapped IO on. */ 59 evutil_socket_t fd; 60 61 /** pending I/O type */ 62 unsigned read_in_progress : 1; 63 unsigned write_in_progress : 1; 64 65 /** The first pinned chain in the buffer. */ 66 struct evbuffer_chain *first_pinned; 67 68 /** How many chains are pinned; how many of the fields in buffers 69 * are we using. */ 70 int n_buffers; 71 WSABUF buffers[MAX_WSABUFS]; 72 }; 73 74 /** Given an evbuffer, return the correponding evbuffer structure, or NULL if 75 * the evbuffer isn't overlapped. */ 76 static inline struct evbuffer_overlapped * 77 upcast_evbuffer(struct evbuffer *buf) 78 { 79 if (!buf || !buf->is_overlapped) 80 return NULL; 81 return EVUTIL_UPCAST(buf, struct evbuffer_overlapped, buffer); 82 } 83 84 /** Unpin all the chains noted as pinned in 'eo'. */ 85 static void 86 pin_release(struct evbuffer_overlapped *eo, unsigned flag) 87 { 88 int i; 89 struct evbuffer_chain *next, *chain = eo->first_pinned; 90 91 for (i = 0; i < eo->n_buffers; ++i) { 92 EVUTIL_ASSERT(chain); 93 next = chain->next; 94 evbuffer_chain_unpin_(chain, flag); 95 chain = next; 96 } 97 } 98 99 void 100 evbuffer_commit_read_(struct evbuffer *evbuf, ev_ssize_t nBytes) 101 { 102 struct evbuffer_overlapped *buf = upcast_evbuffer(evbuf); 103 struct evbuffer_chain **chainp; 104 size_t remaining, len; 105 unsigned i; 106 107 EVBUFFER_LOCK(evbuf); 108 EVUTIL_ASSERT(buf->read_in_progress && !buf->write_in_progress); 109 EVUTIL_ASSERT(nBytes >= 0); /* XXXX Can this be false? */ 110 111 evbuffer_unfreeze(evbuf, 0); 112 113 chainp = evbuf->last_with_datap; 114 if (!((*chainp)->flags & EVBUFFER_MEM_PINNED_R)) 115 chainp = &(*chainp)->next; 116 remaining = nBytes; 117 for (i = 0; remaining > 0 && i < (unsigned)buf->n_buffers; ++i) { 118 EVUTIL_ASSERT(*chainp); 119 len = buf->buffers[i].len; 120 if (remaining < len) 121 len = remaining; 122 (*chainp)->off += len; 123 evbuf->last_with_datap = chainp; 124 remaining -= len; 125 chainp = &(*chainp)->next; 126 } 127 128 pin_release(buf, EVBUFFER_MEM_PINNED_R); 129 130 buf->read_in_progress = 0; 131 132 evbuf->total_len += nBytes; 133 evbuf->n_add_for_cb += nBytes; 134 135 evbuffer_invoke_callbacks_(evbuf); 136 137 evbuffer_decref_and_unlock_(evbuf); 138 } 139 140 void 141 evbuffer_commit_write_(struct evbuffer *evbuf, ev_ssize_t nBytes) 142 { 143 struct evbuffer_overlapped *buf = upcast_evbuffer(evbuf); 144 145 EVBUFFER_LOCK(evbuf); 146 EVUTIL_ASSERT(buf->write_in_progress && !buf->read_in_progress); 147 evbuffer_unfreeze(evbuf, 1); 148 evbuffer_drain(evbuf, nBytes); 149 pin_release(buf,EVBUFFER_MEM_PINNED_W); 150 buf->write_in_progress = 0; 151 evbuffer_decref_and_unlock_(evbuf); 152 } 153 154 struct evbuffer * 155 evbuffer_overlapped_new_(evutil_socket_t fd) 156 { 157 struct evbuffer_overlapped *evo; 158 159 evo = mm_calloc(1, sizeof(struct evbuffer_overlapped)); 160 if (!evo) 161 return NULL; 162 163 LIST_INIT(&evo->buffer.callbacks); 164 evo->buffer.refcnt = 1; 165 evo->buffer.last_with_datap = &evo->buffer.first; 166 167 evo->buffer.is_overlapped = 1; 168 evo->fd = fd; 169 170 return &evo->buffer; 171 } 172 173 int 174 evbuffer_launch_write_(struct evbuffer *buf, ev_ssize_t at_most, 175 struct event_overlapped *ol) 176 { 177 struct evbuffer_overlapped *buf_o = upcast_evbuffer(buf); 178 int r = -1; 179 int i; 180 struct evbuffer_chain *chain; 181 DWORD bytesSent; 182 183 if (!buf) { 184 /* No buffer, or it isn't overlapped */ 185 return -1; 186 } 187 188 EVBUFFER_LOCK(buf); 189 EVUTIL_ASSERT(!buf_o->read_in_progress); 190 if (buf->freeze_start || buf_o->write_in_progress) 191 goto done; 192 if (!buf->total_len) { 193 /* Nothing to write */ 194 r = 0; 195 goto done; 196 } else if (at_most < 0 || (size_t)at_most > buf->total_len) { 197 at_most = buf->total_len; 198 } 199 evbuffer_freeze(buf, 1); 200 201 buf_o->first_pinned = NULL; 202 buf_o->n_buffers = 0; 203 memset(buf_o->buffers, 0, sizeof(buf_o->buffers)); 204 205 chain = buf_o->first_pinned = buf->first; 206 207 for (i=0; i < MAX_WSABUFS && chain; ++i, chain=chain->next) { 208 WSABUF *b = &buf_o->buffers[i]; 209 b->buf = (char*)( chain->buffer + chain->misalign ); 210 evbuffer_chain_pin_(chain, EVBUFFER_MEM_PINNED_W); 211 212 if ((size_t)at_most > chain->off) { 213 /* XXXX Cast is safe for now, since win32 has no 214 mmaped chains. But later, we need to have this 215 add more WSAbufs if chain->off is greater than 216 ULONG_MAX */ 217 b->len = (unsigned long)chain->off; 218 at_most -= chain->off; 219 } else { 220 b->len = (unsigned long)at_most; 221 ++i; 222 break; 223 } 224 } 225 226 buf_o->n_buffers = i; 227 evbuffer_incref_(buf); 228 if (WSASend(buf_o->fd, buf_o->buffers, i, &bytesSent, 0, 229 &ol->overlapped, NULL)) { 230 int error = WSAGetLastError(); 231 if (error != WSA_IO_PENDING) { 232 /* An actual error. */ 233 pin_release(buf_o, EVBUFFER_MEM_PINNED_W); 234 evbuffer_unfreeze(buf, 1); 235 evbuffer_free(buf); /* decref */ 236 goto done; 237 } 238 } 239 240 buf_o->write_in_progress = 1; 241 r = 0; 242 done: 243 EVBUFFER_UNLOCK(buf); 244 return r; 245 } 246 247 int 248 evbuffer_launch_read_(struct evbuffer *buf, size_t at_most, 249 struct event_overlapped *ol) 250 { 251 struct evbuffer_overlapped *buf_o = upcast_evbuffer(buf); 252 int r = -1, i; 253 int nvecs; 254 int npin=0; 255 struct evbuffer_chain *chain=NULL, **chainp; 256 DWORD bytesRead; 257 DWORD flags = 0; 258 struct evbuffer_iovec vecs[MAX_WSABUFS]; 259 260 if (!buf_o) 261 return -1; 262 EVBUFFER_LOCK(buf); 263 EVUTIL_ASSERT(!buf_o->write_in_progress); 264 if (buf->freeze_end || buf_o->read_in_progress) 265 goto done; 266 267 buf_o->first_pinned = NULL; 268 buf_o->n_buffers = 0; 269 memset(buf_o->buffers, 0, sizeof(buf_o->buffers)); 270 271 if (evbuffer_expand_fast_(buf, at_most, MAX_WSABUFS) == -1) 272 goto done; 273 evbuffer_freeze(buf, 0); 274 275 nvecs = evbuffer_read_setup_vecs_(buf, at_most, 276 vecs, MAX_WSABUFS, &chainp, 1); 277 for (i=0;i<nvecs;++i) { 278 WSABUF_FROM_EVBUFFER_IOV( 279 &buf_o->buffers[i], 280 &vecs[i]); 281 } 282 283 buf_o->n_buffers = nvecs; 284 buf_o->first_pinned = chain = *chainp; 285 286 npin=0; 287 for ( ; chain; chain = chain->next) { 288 evbuffer_chain_pin_(chain, EVBUFFER_MEM_PINNED_R); 289 ++npin; 290 } 291 EVUTIL_ASSERT(npin == nvecs); 292 293 evbuffer_incref_(buf); 294 if (WSARecv(buf_o->fd, buf_o->buffers, nvecs, &bytesRead, &flags, 295 &ol->overlapped, NULL)) { 296 int error = WSAGetLastError(); 297 if (error != WSA_IO_PENDING) { 298 /* An actual error. */ 299 pin_release(buf_o, EVBUFFER_MEM_PINNED_R); 300 evbuffer_unfreeze(buf, 0); 301 evbuffer_free(buf); /* decref */ 302 goto done; 303 } 304 } 305 306 buf_o->read_in_progress = 1; 307 r = 0; 308 done: 309 EVBUFFER_UNLOCK(buf); 310 return r; 311 } 312 313 evutil_socket_t 314 evbuffer_overlapped_get_fd_(struct evbuffer *buf) 315 { 316 struct evbuffer_overlapped *buf_o = upcast_evbuffer(buf); 317 return buf_o ? buf_o->fd : -1; 318 } 319 320 void 321 evbuffer_overlapped_set_fd_(struct evbuffer *buf, evutil_socket_t fd) 322 { 323 struct evbuffer_overlapped *buf_o = upcast_evbuffer(buf); 324 EVBUFFER_LOCK(buf); 325 /* XXX is this right?, should it cancel current I/O operations? */ 326 if (buf_o) 327 buf_o->fd = fd; 328 EVBUFFER_UNLOCK(buf); 329 } 330
Indexes created Sat Mar 21 00:23:06 UTC 2026