ext/kgio/autopush.c

   1 /*
   2  * We use a very basic strategy to use TCP_CORK semantics optimally
   3  * in most TCP servers:  On corked sockets, we will uncork on recv()
   4  * if there was a previous send().  Otherwise we do not fiddle
   5  * with TCP_CORK at all.
   6  *
   7  * Under Linux, we can rely on TCP_CORK being inherited in an
   8  * accept()-ed client socket so we can avoid syscalls for each
   9  * accept()-ed client if we know the accept() socket corks.
  10  *
  11  * This module does NOTHING for client TCP sockets, we only deal
  12  * with accept()-ed sockets right now.
  13  */
  14
  15 #include "kgio.h"
  16 #include <netinet/tcp.h>
  17
  18 /*
  19  * As of FreeBSD 4.5, TCP_NOPUSH == TCP_CORK
  20  * ref: http://dotat.at/writing/nopush.html
  21  * We won't care for older FreeBSD since nobody runs Ruby on them...
  22  */
  23 #ifdef TCP_CORK
  24 #  define KGIO_NOPUSH TCP_CORK
  25 #elif defined(TCP_NOPUSH)
  26 #  define KGIO_NOPUSH TCP_NOPUSH
  27 #endif
  28
  29 #ifdef KGIO_NOPUSH
  30 static ID id_autopush_state;
  31 static int enabled = 1;
  32
  33 enum autopush_state {
  34         AUTOPUSH_STATE_ACCEPTOR_IGNORE = -1,
  35         AUTOPUSH_STATE_IGNORE = 0,
  36         AUTOPUSH_STATE_WRITER = 1,
  37         AUTOPUSH_STATE_WRITTEN = 2,
  38         AUTOPUSH_STATE_ACCEPTOR = 3
  39 };
  40
  41 #if defined(R_CAST) && \
  42     defined(HAVE_TYPE_STRUCT_RFILE) && \
  43     defined(HAVE_TYPE_STRUCT_ROBJECT) && \
  44     ((SIZEOF_STRUCT_RFILE + SIZEOF_INT) <= (SIZEOF_STRUCT_ROBJECT))
  45
  46 struct AutopushSocket {
  47         struct RFile rfile;
  48         enum autopush_state autopush_state;
  49 };
  50
  51 static enum autopush_state state_get(VALUE io)
  52 {
  53         return ((struct AutopushSocket *)(io))->autopush_state;
  54 }
  55
  56 static void state_set(VALUE io, enum autopush_state state)
  57 {
  58         ((struct AutopushSocket *)(io))->autopush_state = state;
  59 }
  60 #else
  61 static enum autopush_state state_get(VALUE io)
  62 {
  63         VALUE val;
  64
  65         if (rb_ivar_defined(io, id_autopush_state) == Qfalse)
  66                 return AUTOPUSH_STATE_IGNORE;
  67         val = rb_ivar_get(io, id_autopush_state);
  68
  69         return (enum autopush_state)NUM2INT(val);
  70 }
  71
  72 static void state_set(VALUE io, enum autopush_state state)
  73 {
  74         rb_ivar_set(io, id_autopush_state, INT2NUM(state));
  75 }
  76 #endif /* IVAR fallback */
  77
  78 static enum autopush_state detect_acceptor_state(VALUE io);
  79 static void push_pending_data(VALUE io);
  80
  81 /*
  82  * call-seq:
  83  *      Kgio.autopush? -> true or false
  84  *
  85  * Returns whether or not autopush is enabled.
  86  *
  87  * Only available on systems with TCP_CORK (Linux) or
  88  * TCP_NOPUSH (FreeBSD, and maybe other *BSDs).
  89  */
  90 static VALUE s_get_autopush(VALUE self)
  91 {
  92         return enabled ? Qtrue : Qfalse;
  93 }
  94
  95 /*
  96  * call-seq:
  97  *      Kgio.autopush = true
  98  *      Kgio.autopush = false
  99  *
 100  * Enables or disables autopush for sockets created with kgio_accept
 101  * and kgio_tryaccept methods.  Autopush relies on TCP_CORK/TCP_NOPUSH
 102  * being enabled on the listen socket.
 103  *
 104  * Only available on systems with TCP_CORK (Linux) or
 105  * TCP_NOPUSH (FreeBSD, and maybe other *BSDs).
 106  */
 107 static VALUE s_set_autopush(VALUE self, VALUE val)
 108 {
 109         enabled = RTEST(val);
 110
 111         return val;
 112 }
 113
 114 /*
 115  * call-seq:
 116  *
 117  *      io.kgio_autopush?  -> true or false
 118  *
 119  * Returns the current autopush state of the Kgio::SocketMethods-enabled
 120  * socket.
 121  *
 122  * Only available on systems with TCP_CORK (Linux) or
 123  * TCP_NOPUSH (FreeBSD, and maybe other *BSDs).
 124  */
 125 static VALUE autopush_get(VALUE io)
 126 {
 127         return state_get(io) <= 0 ? Qfalse : Qtrue;
 128 }
 129
 130 /*
 131  * call-seq:
 132  *
 133  *      io.kgio_autopush = true
 134  *      io.kgio_autopush = false
 135  *
 136  * Enables or disables autopush on any given Kgio::SocketMethods-capable
 137  * IO object.  This does NOT enable or disable TCP_NOPUSH/TCP_CORK right
 138  * away, that must be done with IO.setsockopt
 139  *
 140  * Only available on systems with TCP_CORK (Linux) or
 141  * TCP_NOPUSH (FreeBSD, and maybe other *BSDs).
 142  */
 143 static VALUE autopush_set(VALUE io, VALUE vbool)
 144 {
 145         int fd = my_fileno(io);
 146         int val;
 147         socklen_t len = sizeof(val);
 148
 149         if (RTEST(vbool))
 150                 state_set(io, AUTOPUSH_STATE_WRITER);
 151         else
 152                 state_set(io, AUTOPUSH_STATE_IGNORE);
 153         return vbool;
 154 }
 155
 156 void init_kgio_autopush(void)
 157 {
 158         VALUE mKgio = rb_define_module("Kgio");
 159         VALUE tmp;
 160
 161         rb_define_singleton_method(mKgio, "autopush?", s_get_autopush, 0);
 162         rb_define_singleton_method(mKgio, "autopush=", s_set_autopush, 1);
 163
 164         tmp = rb_define_module_under(mKgio, "SocketMethods");
 165         rb_define_method(tmp, "kgio_autopush=", autopush_set, 1);
 166         rb_define_method(tmp, "kgio_autopush?", autopush_get, 0);
 167
 168         id_autopush_state = rb_intern("@kgio_autopush_state");
 169 }
 170
 171 /*
 172  * called after a successful write, just mark that we've put something
 173  * in the skb and will need to uncork on the next write.
 174  */
 175 void kgio_autopush_send(VALUE io)
 176 {
 177         if (state_get(io) == AUTOPUSH_STATE_WRITER)
 178                 state_set(io, AUTOPUSH_STATE_WRITTEN);
 179 }
 180
 181 /* called on successful accept() */
 182 void kgio_autopush_accept(VALUE accept_io, VALUE client_io)
 183 {
 184         enum autopush_state acceptor_state;
 185
 186         if (!enabled)
 187                 return;
 188         acceptor_state = state_get(accept_io);
 189         if (acceptor_state == AUTOPUSH_STATE_IGNORE)
 190                 acceptor_state = detect_acceptor_state(accept_io);
 191         if (acceptor_state == AUTOPUSH_STATE_ACCEPTOR)
 192                 state_set(client_io, AUTOPUSH_STATE_WRITER);
 193         else
 194                 state_set(client_io, AUTOPUSH_STATE_IGNORE);
 195 }
 196
 197 void kgio_autopush_recv(VALUE io)
 198 {
 199         if (enabled && (state_get(io) == AUTOPUSH_STATE_WRITTEN)) {
 200                 push_pending_data(io);
 201                 state_set(io, AUTOPUSH_STATE_WRITER);
 202         }
 203 }
 204
 205 static enum autopush_state detect_acceptor_state(VALUE io)
 206 {
 207         int corked = 0;
 208         int fd = my_fileno(io);
 209         socklen_t optlen = sizeof(int);
 210         enum autopush_state state;
 211
 212         if (getsockopt(fd, IPPROTO_TCP, KGIO_NOPUSH, &corked, &optlen) != 0) {
 213                 if (errno != EOPNOTSUPP)
 214                         rb_sys_fail("getsockopt(TCP_CORK/TCP_NOPUSH)");
 215                 errno = 0;
 216                 state = AUTOPUSH_STATE_ACCEPTOR_IGNORE;
 217         } else if (corked) {
 218                 state = AUTOPUSH_STATE_ACCEPTOR;
 219         } else {
 220                 state = AUTOPUSH_STATE_ACCEPTOR_IGNORE;
 221         }
 222         state_set(io, state);
 223
 224         return state;
 225 }
 226
 227 /*
 228  * checks to see if we've written anything since the last recv()
 229  * If we have, uncork the socket and immediately recork it.
 230  */
 231 static void push_pending_data(VALUE io)
 232 {
 233         int optval = 0;
 234         const socklen_t optlen = sizeof(int);
 235         const int fd = my_fileno(io);
 236
 237         if (setsockopt(fd, IPPROTO_TCP, KGIO_NOPUSH, &optval, optlen) != 0)
 238                 rb_sys_fail("setsockopt(TCP_CORK/TCP_NOPUSH, 0)");
 239         /* immediately recork */
 240         optval = 1;
 241         if (setsockopt(fd, IPPROTO_TCP, KGIO_NOPUSH, &optval, optlen) != 0)
 242                 rb_sys_fail("setsockopt(TCP_CORK/TCP_NOPUSH, 1)");
 243 }
 244 #else /* !KGIO_NOPUSH */
 245 void kgio_autopush_recv(VALUE io){}
 246 void init_kgio_autopush(void)
 247 {
 248 }
 249 #endif /* ! KGIO_NOPUSH */