granicus.if.org Git - libevent/blob - iocp-internal.h

   1 /*
   2  * Copyright (c) 2009-2012 Niels Provos and Nick Mathewson
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  * 3. The name of the author may not be used to endorse or promote products
  13  *    derived from this software without specific prior written permission.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #ifndef IOCP_INTERNAL_H_INCLUDED_
  28 #define IOCP_INTERNAL_H_INCLUDED_
  29
  30 #ifdef __cplusplus
  31 extern "C" {
  32 #endif
  33
  34 struct event_overlapped;
  35 struct event_iocp_port;
  36 struct evbuffer;
  37 typedef void (*iocp_callback)(struct event_overlapped *, ev_uintptr_t, ev_ssize_t, int success);
  38
  39 /* This whole file is actually win32 only. We wrap the structures in a win32
  40  * ifdef so that we can test-compile code that uses these interfaces on
  41  * non-win32 platforms. */
  42 #ifdef _WIN32
  43
  44 /**
  45    Internal use only.  Wraps an OVERLAPPED that we're using for libevent
  46    functionality.  Whenever an event_iocp_port gets an event for a given
  47    OVERLAPPED*, it upcasts the pointer to an event_overlapped, and calls the
  48    iocp_callback function with the event_overlapped, the iocp key, and the
  49    number of bytes transferred as arguments.
  50  */
  51 struct event_overlapped {
  52         OVERLAPPED overlapped;
  53         iocp_callback cb;
  54 };
  55
  56 /* Mingw's headers don't define LPFN_ACCEPTEX. */
  57
  58 typedef BOOL (WINAPI *AcceptExPtr)(SOCKET, SOCKET, PVOID, DWORD, DWORD, DWORD, LPDWORD, LPOVERLAPPED);
  59 typedef BOOL (WINAPI *ConnectExPtr)(SOCKET, const struct sockaddr *, int, PVOID, DWORD, LPDWORD, LPOVERLAPPED);
  60 typedef void (WINAPI *GetAcceptExSockaddrsPtr)(PVOID, DWORD, DWORD, DWORD, LPSOCKADDR *, LPINT, LPSOCKADDR *, LPINT);
  61
  62 /** Internal use only. Holds pointers to functions that only some versions of
  63     Windows provide.
  64  */
  65 struct win32_extension_fns {
  66         AcceptExPtr AcceptEx;
  67         ConnectExPtr ConnectEx;
  68         GetAcceptExSockaddrsPtr GetAcceptExSockaddrs;
  69 };
  70
  71 /**
  72     Internal use only. Stores a Windows IO Completion port, along with
  73     related data.
  74  */
  75 struct event_iocp_port {
  76         /** The port itself */
  77         HANDLE port;
  78         /* A lock to cover internal structures. */
  79         CRITICAL_SECTION lock;
  80         /** Number of threads ever open on the port. */
  81         short n_threads;
  82         /** True iff we're shutting down all the threads on this port */
  83         short shutdown;
  84         /** How often the threads on this port check for shutdown and other
  85          * conditions */
  86         long ms;
  87         /* The threads that are waiting for events. */
  88         HANDLE *threads;
  89         /** Number of threads currently open on this port. */
  90         short n_live_threads;
  91         /** A semaphore to signal when we are done shutting down. */
  92         HANDLE *shutdownSemaphore;
  93 };
  94
  95 EVENT2_EXPORT_SYMBOL
  96 const struct win32_extension_fns *event_get_win32_extension_fns_(void);
  97 #else
  98 /* Dummy definition so we can test-compile more things on unix. */
  99 struct event_overlapped {
 100         iocp_callback cb;
 101 };
 102 #endif
 103
 104 /** Initialize the fields in an event_overlapped.
 105
 106     @param overlapped The struct event_overlapped to initialize
 107     @param cb The callback that should be invoked once the IO operation has
 108         finished.
 109  */
 110 EVENT2_EXPORT_SYMBOL
 111 void event_overlapped_init_(struct event_overlapped *, iocp_callback cb);
 112
 113 /** Allocate and return a new evbuffer that supports overlapped IO on a given
 114     socket.  The socket must be associated with an IO completion port using
 115     event_iocp_port_associate_.
 116 */
 117 EVENT2_EXPORT_SYMBOL
 118 struct evbuffer *evbuffer_overlapped_new_(evutil_socket_t fd);
 119
 120 /** XXXX Document (nickm) */
 121 evutil_socket_t evbuffer_overlapped_get_fd_(struct evbuffer *buf);
 122
 123 void evbuffer_overlapped_set_fd_(struct evbuffer *buf, evutil_socket_t fd);
 124
 125 /** Start reading data onto the end of an overlapped evbuffer.
 126
 127     An evbuffer can only have one read pending at a time.  While the read
 128     is in progress, no other data may be added to the end of the buffer.
 129     The buffer must be created with event_overlapped_init_().
 130     evbuffer_commit_read_() must be called in the completion callback.
 131
 132     @param buf The buffer to read onto
 133     @param n The number of bytes to try to read.
 134     @param ol Overlapped object with associated completion callback.
 135     @return 0 on success, -1 on error.
 136  */
 137 EVENT2_EXPORT_SYMBOL
 138 int evbuffer_launch_read_(struct evbuffer *buf, size_t n, struct event_overlapped *ol);
 139
 140 /** Start writing data from the start of an evbuffer.
 141
 142     An evbuffer can only have one write pending at a time.  While the write is
 143     in progress, no other data may be removed from the front of the buffer.
 144     The buffer must be created with event_overlapped_init_().
 145     evbuffer_commit_write_() must be called in the completion callback.
 146
 147     @param buf The buffer to read onto
 148     @param n The number of bytes to try to read.
 149     @param ol Overlapped object with associated completion callback.
 150     @return 0 on success, -1 on error.
 151  */
 152 EVENT2_EXPORT_SYMBOL
 153 int evbuffer_launch_write_(struct evbuffer *buf, ev_ssize_t n, struct event_overlapped *ol);
 154
 155 /** XXX document */
 156 EVENT2_EXPORT_SYMBOL
 157 void evbuffer_commit_read_(struct evbuffer *, ev_ssize_t);
 158 EVENT2_EXPORT_SYMBOL
 159 void evbuffer_commit_write_(struct evbuffer *, ev_ssize_t);
 160
 161 /** Create an IOCP, and launch its worker threads.  Internal use only.
 162
 163     This interface is unstable, and will change.
 164  */
 165 EVENT2_EXPORT_SYMBOL
 166 struct event_iocp_port *event_iocp_port_launch_(int n_cpus);
 167
 168 /** Associate a file descriptor with an iocp, such that overlapped IO on the
 169     fd will happen on one of the iocp's worker threads.
 170 */
 171 EVENT2_EXPORT_SYMBOL
 172 int event_iocp_port_associate_(struct event_iocp_port *port, evutil_socket_t fd,
 173     ev_uintptr_t key);
 174
 175 /** Tell all threads serving an iocp to stop.  Wait for up to waitMsec for all
 176     the threads to finish whatever they're doing.  If waitMsec is -1, wait
 177     as long as required.  If all the threads are done, free the port and return
 178     0. Otherwise, return -1.  If you get a -1 return value, it is safe to call
 179     this function again.
 180 */
 181 EVENT2_EXPORT_SYMBOL
 182 int event_iocp_shutdown_(struct event_iocp_port *port, long waitMsec);
 183
 184 /* FIXME document. */
 185 EVENT2_EXPORT_SYMBOL
 186 int event_iocp_activate_overlapped_(struct event_iocp_port *port,
 187     struct event_overlapped *o,
 188     ev_uintptr_t key, ev_uint32_t n_bytes);
 189
 190 struct event_base;
 191 /* FIXME document. */
 192 EVENT2_EXPORT_SYMBOL
 193 struct event_iocp_port *event_base_get_iocp_(struct event_base *base);
 194
 195 /* FIXME document. */
 196 EVENT2_EXPORT_SYMBOL
 197 int event_base_start_iocp_(struct event_base *base, int n_cpus);
 198 void event_base_stop_iocp_(struct event_base *base);
 199
 200 /* FIXME document. */
 201 EVENT2_EXPORT_SYMBOL
 202 struct bufferevent *bufferevent_async_new_(struct event_base *base,
 203     evutil_socket_t fd, int options);
 204
 205 /* FIXME document. */
 206 void bufferevent_async_set_connected_(struct bufferevent *bev);
 207 int bufferevent_async_can_connect_(struct bufferevent *bev);
 208 int bufferevent_async_connect_(struct bufferevent *bev, evutil_socket_t fd,
 209         const struct sockaddr *sa, int socklen);
 210
 211 #ifdef __cplusplus
 212 }
 213 #endif
 214
 215 #endif