Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 1 | /* |
| 2 | * Functions operating on SOCK_STREAM and buffers. |
| 3 | * |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 4 | * Copyright 2000-2009 Willy Tarreau <w@1wt.eu> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 5 | * |
| 6 | * This program is free software; you can redistribute it and/or |
| 7 | * modify it under the terms of the GNU General Public License |
| 8 | * as published by the Free Software Foundation; either version |
| 9 | * 2 of the License, or (at your option) any later version. |
| 10 | * |
| 11 | */ |
| 12 | |
Willy Tarreau | 6b4aad4 | 2009-01-18 21:59:13 +0100 | [diff] [blame] | 13 | #define _GNU_SOURCE |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 14 | #include <errno.h> |
| 15 | #include <fcntl.h> |
| 16 | #include <stdio.h> |
| 17 | #include <stdlib.h> |
| 18 | |
Willy Tarreau | fb14edc | 2009-06-14 15:24:37 +0200 | [diff] [blame] | 19 | #include <netinet/tcp.h> |
| 20 | |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 21 | #include <sys/socket.h> |
| 22 | #include <sys/stat.h> |
| 23 | #include <sys/types.h> |
| 24 | |
Willy Tarreau | 2dd0d47 | 2006-06-29 17:53:05 +0200 | [diff] [blame] | 25 | #include <common/compat.h> |
Willy Tarreau | e3ba5f0 | 2006-06-29 18:54:54 +0200 | [diff] [blame] | 26 | #include <common/config.h> |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 27 | #include <common/debug.h> |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 28 | #include <common/standard.h> |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 29 | #include <common/ticks.h> |
Willy Tarreau | 2dd0d47 | 2006-06-29 17:53:05 +0200 | [diff] [blame] | 30 | #include <common/time.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 31 | |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 32 | #include <proto/buffers.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 33 | #include <proto/client.h> |
| 34 | #include <proto/fd.h> |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 35 | #include <proto/pipe.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 36 | #include <proto/stream_sock.h> |
| 37 | #include <proto/task.h> |
| 38 | |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 39 | #include <types/global.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 40 | |
Willy Tarreau | 6b4aad4 | 2009-01-18 21:59:13 +0100 | [diff] [blame] | 41 | /* On recent Linux kernels, the splice() syscall may be used for faster data copy. |
| 42 | * But it's not always defined on some OS versions, and it even happens that some |
| 43 | * definitions are wrong with some glibc due to an offset bug in syscall(). |
| 44 | */ |
| 45 | |
| 46 | #if defined(CONFIG_HAP_LINUX_SPLICE) |
| 47 | #include <unistd.h> |
| 48 | #include <sys/syscall.h> |
| 49 | |
| 50 | #ifndef SPLICE_F_MOVE |
| 51 | #define SPLICE_F_MOVE 0x1 |
| 52 | #endif |
| 53 | |
| 54 | #ifndef SPLICE_F_NONBLOCK |
| 55 | #define SPLICE_F_NONBLOCK 0x2 |
| 56 | #endif |
| 57 | |
| 58 | #ifndef SPLICE_F_MORE |
| 59 | #define SPLICE_F_MORE 0x4 |
| 60 | #endif |
| 61 | |
| 62 | #ifndef __NR_splice |
| 63 | #if defined(__powerpc__) || defined(__powerpc64__) |
| 64 | #define __NR_splice 283 |
| 65 | #elif defined(__sparc__) || defined(__sparc64__) |
| 66 | #define __NR_splice 232 |
| 67 | #elif defined(__x86_64__) |
| 68 | #define __NR_splice 275 |
| 69 | #elif defined(__alpha__) |
| 70 | #define __NR_splice 468 |
| 71 | #elif defined (__i386__) |
| 72 | #define __NR_splice 313 |
| 73 | #else |
| 74 | #warning unsupported architecture, guessing __NR_splice=313 like x86... |
| 75 | #define __NR_splice 313 |
| 76 | #endif /* $arch */ |
| 77 | |
| 78 | _syscall6(int, splice, int, fdin, loff_t *, off_in, int, fdout, loff_t *, off_out, size_t, len, unsigned long, flags) |
| 79 | |
| 80 | #endif /* __NR_splice */ |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 81 | |
| 82 | /* A pipe contains 16 segments max, and it's common to see segments of 1448 bytes |
| 83 | * because of timestamps. Use this as a hint for not looping on splice(). |
| 84 | */ |
| 85 | #define SPLICE_FULL_HINT 16*1448 |
| 86 | |
| 87 | /* Returns : |
| 88 | * -1 if splice is not possible or not possible anymore and we must switch to |
| 89 | * user-land copy (eg: to_forward reached) |
| 90 | * 0 when we know that polling is required to get more data (EAGAIN) |
| 91 | * 1 for all other cases (we can safely try again, or if an activity has been |
| 92 | * detected (DATA/NULL/ERR)) |
| 93 | * Sets : |
| 94 | * BF_READ_NULL |
| 95 | * BF_READ_PARTIAL |
| 96 | * BF_WRITE_PARTIAL (during copy) |
| 97 | * BF_EMPTY (during copy) |
| 98 | * SI_FL_ERR |
| 99 | * SI_FL_WAIT_ROOM |
| 100 | * (SI_FL_WAIT_RECV) |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 101 | * |
| 102 | * This function automatically allocates a pipe from the pipe pool. It also |
| 103 | * carefully ensures to clear b->pipe whenever it leaves the pipe empty. |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 104 | */ |
| 105 | static int stream_sock_splice_in(struct buffer *b, struct stream_interface *si) |
| 106 | { |
| 107 | int fd = si->fd; |
| 108 | int ret, max, total = 0; |
| 109 | int retval = 1; |
| 110 | |
| 111 | if (!b->to_forward) |
| 112 | return -1; |
| 113 | |
| 114 | if (!(b->flags & BF_KERN_SPLICING)) |
| 115 | return -1; |
| 116 | |
| 117 | if (b->l) { |
| 118 | /* We're embarrassed, there are already data pending in |
| 119 | * the buffer and we don't want to have them at two |
| 120 | * locations at a time. Let's indicate we need some |
| 121 | * place and ask the consumer to hurry. |
| 122 | */ |
| 123 | si->flags |= SI_FL_WAIT_ROOM; |
| 124 | EV_FD_CLR(fd, DIR_RD); |
| 125 | b->rex = TICK_ETERNITY; |
| 126 | b->cons->chk_snd(b->cons); |
| 127 | return 1; |
| 128 | } |
| 129 | |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 130 | if (unlikely(b->pipe == NULL)) { |
| 131 | if (pipes_used >= global.maxpipes || !(b->pipe = get_pipe())) { |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 132 | b->flags &= ~BF_KERN_SPLICING; |
| 133 | return -1; |
| 134 | } |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 135 | } |
| 136 | |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 137 | /* At this point, b->pipe is valid */ |
| 138 | |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 139 | while (1) { |
| 140 | max = b->to_forward; |
| 141 | if (max <= 0) { |
| 142 | /* It looks like the buffer + the pipe already contain |
| 143 | * the maximum amount of data to be transferred. Try to |
| 144 | * send those data immediately on the other side if it |
| 145 | * is currently waiting. |
| 146 | */ |
| 147 | retval = -1; /* end of forwarding */ |
| 148 | break; |
| 149 | } |
| 150 | |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 151 | ret = splice(fd, NULL, b->pipe->prod, NULL, max, |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 152 | SPLICE_F_MOVE|SPLICE_F_NONBLOCK); |
| 153 | |
| 154 | if (ret <= 0) { |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 155 | if (ret == 0) { |
Willy Tarreau | 98b306b | 2009-01-25 11:11:32 +0100 | [diff] [blame] | 156 | /* connection closed. This is only detected by |
| 157 | * recent kernels (>= 2.6.27.13). |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 158 | */ |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 159 | b->flags |= BF_READ_NULL; |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 160 | retval = 1; /* no need for further polling */ |
| 161 | break; |
| 162 | } |
| 163 | |
| 164 | if (errno == EAGAIN) { |
| 165 | /* there are two reasons for EAGAIN : |
| 166 | * - nothing in the socket buffer (standard) |
| 167 | * - pipe is full |
Willy Tarreau | 98b306b | 2009-01-25 11:11:32 +0100 | [diff] [blame] | 168 | * - the connection is closed (kernel < 2.6.27.13) |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 169 | * Since we don't know if pipe is full, we'll |
| 170 | * stop if the pipe is not empty. Anyway, we |
| 171 | * will almost always fill/empty the pipe. |
| 172 | */ |
| 173 | |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 174 | if (b->pipe->data) { |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 175 | si->flags |= SI_FL_WAIT_ROOM; |
| 176 | retval = 1; |
| 177 | break; |
| 178 | } |
| 179 | |
Willy Tarreau | 98b306b | 2009-01-25 11:11:32 +0100 | [diff] [blame] | 180 | /* We don't know if the connection was closed. |
| 181 | * But if we're called upon POLLIN with an empty |
| 182 | * pipe and get EAGAIN, it is suspect enought to |
| 183 | * try to fall back to the normal recv scheme |
| 184 | * which will be able to deal with the situation. |
| 185 | */ |
| 186 | retval = -1; |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 187 | break; |
| 188 | } |
Willy Tarreau | dc340a9 | 2009-06-28 23:10:19 +0200 | [diff] [blame] | 189 | |
| 190 | if (errno == ENOSYS) { |
| 191 | /* splice not supported on this end, disable it */ |
| 192 | b->flags &= ~BF_KERN_SPLICING; |
| 193 | si->flags &= ~SI_FL_CAP_SPLICE; |
| 194 | put_pipe(b->pipe); |
| 195 | b->pipe = NULL; |
| 196 | return -1; |
| 197 | } |
| 198 | |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 199 | /* here we have another error */ |
| 200 | si->flags |= SI_FL_ERR; |
| 201 | retval = 1; |
| 202 | break; |
| 203 | } /* ret <= 0 */ |
| 204 | |
| 205 | b->to_forward -= ret; |
| 206 | total += ret; |
| 207 | b->total += ret; |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 208 | b->pipe->data += ret; |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 209 | b->flags |= BF_READ_PARTIAL; |
| 210 | b->flags &= ~BF_EMPTY; /* to prevent shutdowns */ |
| 211 | |
Willy Tarreau | 6f4a82c | 2009-03-21 20:43:57 +0100 | [diff] [blame] | 212 | if (b->pipe->data >= SPLICE_FULL_HINT || |
| 213 | ret >= global.tune.recv_enough) { |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 214 | /* We've read enough of it for this time. */ |
| 215 | retval = 1; |
| 216 | break; |
| 217 | } |
| 218 | } /* while */ |
| 219 | |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 220 | if (unlikely(!b->pipe->data)) { |
| 221 | put_pipe(b->pipe); |
| 222 | b->pipe = NULL; |
| 223 | } |
| 224 | |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 225 | return retval; |
| 226 | } |
| 227 | |
Willy Tarreau | 6b4aad4 | 2009-01-18 21:59:13 +0100 | [diff] [blame] | 228 | #endif /* CONFIG_HAP_LINUX_SPLICE */ |
| 229 | |
| 230 | |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 231 | /* |
Willy Tarreau | d797128 | 2006-07-29 18:36:34 +0200 | [diff] [blame] | 232 | * this function is called on a read event from a stream socket. |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 233 | * It returns 0 if we have a high confidence that we will not be |
| 234 | * able to read more data without polling first. Returns non-zero |
| 235 | * otherwise. |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 236 | */ |
Willy Tarreau | d797128 | 2006-07-29 18:36:34 +0200 | [diff] [blame] | 237 | int stream_sock_read(int fd) { |
Willy Tarreau | e5ed406 | 2008-08-30 03:17:31 +0200 | [diff] [blame] | 238 | struct stream_interface *si = fdtab[fd].owner; |
Willy Tarreau | 48adac5 | 2008-08-30 04:58:38 +0200 | [diff] [blame] | 239 | struct buffer *b = si->ib; |
Willy Tarreau | 8a7af60 | 2008-05-03 23:07:14 +0200 | [diff] [blame] | 240 | int ret, max, retval, cur_read; |
Willy Tarreau | b8949f1 | 2007-03-23 22:39:59 +0100 | [diff] [blame] | 241 | int read_poll = MAX_READ_POLL_LOOPS; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 242 | |
| 243 | #ifdef DEBUG_FULL |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 244 | fprintf(stderr,"stream_sock_read : fd=%d, ev=0x%02x, owner=%p\n", fd, fdtab[fd].ev, fdtab[fd].owner); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 245 | #endif |
| 246 | |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 247 | retval = 1; |
| 248 | |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 249 | /* stop immediately on errors */ |
| 250 | if (fdtab[fd].state == FD_STERROR || (fdtab[fd].ev & FD_POLL_ERR)) |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 251 | goto out_error; |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 252 | |
| 253 | /* stop here if we reached the end of data */ |
| 254 | if ((fdtab[fd].ev & (FD_POLL_IN|FD_POLL_HUP)) == FD_POLL_HUP) |
| 255 | goto out_shutdown_r; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 256 | |
Willy Tarreau | d06e711 | 2009-03-29 10:18:41 +0200 | [diff] [blame] | 257 | /* maybe we were called immediately after an asynchronous shutr */ |
| 258 | if (b->flags & BF_SHUTR) |
| 259 | goto out_wakeup; |
| 260 | |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 261 | #if defined(CONFIG_HAP_LINUX_SPLICE) |
| 262 | if (b->to_forward && b->flags & BF_KERN_SPLICING) { |
Willy Tarreau | 98b306b | 2009-01-25 11:11:32 +0100 | [diff] [blame] | 263 | |
| 264 | /* Under Linux, if FD_POLL_HUP is set, we have reached the end. |
| 265 | * Since older splice() implementations were buggy and returned |
| 266 | * EAGAIN on end of read, let's bypass the call to splice() now. |
| 267 | */ |
| 268 | if (fdtab[fd].ev & FD_POLL_HUP) |
| 269 | goto out_shutdown_r; |
| 270 | |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 271 | retval = stream_sock_splice_in(b, si); |
| 272 | |
| 273 | if (retval >= 0) { |
| 274 | if (si->flags & SI_FL_ERR) |
| 275 | goto out_error; |
| 276 | if (b->flags & BF_READ_NULL) |
| 277 | goto out_shutdown_r; |
| 278 | goto out_wakeup; |
| 279 | } |
| 280 | /* splice not possible (anymore), let's go on on standard copy */ |
| 281 | } |
| 282 | #endif |
Willy Tarreau | 8a7af60 | 2008-05-03 23:07:14 +0200 | [diff] [blame] | 283 | cur_read = 0; |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 284 | while (1) { |
| 285 | /* |
| 286 | * 1. compute the maximum block size we can read at once. |
| 287 | */ |
Willy Tarreau | 03d60bb | 2009-01-09 11:13:00 +0100 | [diff] [blame] | 288 | if (b->l == 0) { |
| 289 | /* let's realign the buffer to optimize I/O */ |
| 290 | b->r = b->w = b->lr = b->data; |
| 291 | max = b->max_len; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 292 | } |
| 293 | else if (b->r > b->w) { |
Willy Tarreau | 03d60bb | 2009-01-09 11:13:00 +0100 | [diff] [blame] | 294 | max = b->data + b->max_len - b->r; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 295 | } |
| 296 | else { |
| 297 | max = b->w - b->r; |
Willy Tarreau | 03d60bb | 2009-01-09 11:13:00 +0100 | [diff] [blame] | 298 | if (max > b->max_len) |
| 299 | max = b->max_len; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 300 | } |
Willy Tarreau | 74ab2ac | 2008-11-23 17:23:07 +0100 | [diff] [blame] | 301 | |
Willy Tarreau | 9c0fe59 | 2009-01-18 16:25:31 +0100 | [diff] [blame] | 302 | if (max == 0) { |
| 303 | b->flags |= BF_FULL; |
Willy Tarreau | a456f2a | 2009-01-18 17:38:44 +0100 | [diff] [blame] | 304 | si->flags |= SI_FL_WAIT_ROOM; |
Willy Tarreau | 9c0fe59 | 2009-01-18 16:25:31 +0100 | [diff] [blame] | 305 | break; |
| 306 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 307 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 308 | /* |
| 309 | * 2. read the largest possible block |
| 310 | */ |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 311 | #ifndef MSG_NOSIGNAL |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 312 | { |
| 313 | int skerr; |
| 314 | socklen_t lskerr = sizeof(skerr); |
| 315 | |
| 316 | ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr); |
| 317 | if (ret == -1 || skerr) |
| 318 | ret = -1; |
| 319 | else |
| 320 | ret = recv(fd, b->r, max, 0); |
| 321 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 322 | #else |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 323 | ret = recv(fd, b->r, max, MSG_NOSIGNAL); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 324 | #endif |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 325 | if (ret > 0) { |
| 326 | b->r += ret; |
| 327 | b->l += ret; |
Willy Tarreau | 8a7af60 | 2008-05-03 23:07:14 +0200 | [diff] [blame] | 328 | cur_read += ret; |
Willy Tarreau | b38903c | 2008-11-23 21:33:29 +0100 | [diff] [blame] | 329 | |
Willy Tarreau | 0abebcc | 2009-01-08 00:09:41 +0100 | [diff] [blame] | 330 | /* if we're allowed to directly forward data, we must update send_max */ |
| 331 | if (b->to_forward > 0) { |
| 332 | int fwd = MIN(b->to_forward, ret); |
| 333 | b->send_max += fwd; |
| 334 | b->to_forward -= fwd; |
| 335 | } |
Willy Tarreau | f890dc9 | 2008-12-13 21:12:26 +0100 | [diff] [blame] | 336 | |
Willy Tarreau | b38903c | 2008-11-23 21:33:29 +0100 | [diff] [blame] | 337 | if (fdtab[fd].state == FD_STCONN) |
| 338 | fdtab[fd].state = FD_STREADY; |
| 339 | |
Willy Tarreau | 3da77c5 | 2008-08-29 09:58:42 +0200 | [diff] [blame] | 340 | b->flags |= BF_READ_PARTIAL; |
Willy Tarreau | e393fe2 | 2008-08-16 22:18:07 +0200 | [diff] [blame] | 341 | b->flags &= ~BF_EMPTY; |
Willy Tarreau | 74ab2ac | 2008-11-23 17:23:07 +0100 | [diff] [blame] | 342 | |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 343 | if (b->r == b->data + BUFSIZE) { |
| 344 | b->r = b->data; /* wrap around the buffer */ |
| 345 | } |
Willy Tarreau | 9641e8f | 2007-03-23 23:02:09 +0100 | [diff] [blame] | 346 | |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 347 | b->total += ret; |
Willy Tarreau | 9641e8f | 2007-03-23 23:02:09 +0100 | [diff] [blame] | 348 | |
Willy Tarreau | 03d60bb | 2009-01-09 11:13:00 +0100 | [diff] [blame] | 349 | if (b->l >= b->max_len) { |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 350 | /* The buffer is now full, there's no point in going through |
| 351 | * the loop again. |
| 352 | */ |
Willy Tarreau | 8a7af60 | 2008-05-03 23:07:14 +0200 | [diff] [blame] | 353 | if (!(b->flags & BF_STREAMER_FAST) && (cur_read == b->l)) { |
| 354 | b->xfer_small = 0; |
| 355 | b->xfer_large++; |
| 356 | if (b->xfer_large >= 3) { |
| 357 | /* we call this buffer a fast streamer if it manages |
| 358 | * to be filled in one call 3 consecutive times. |
| 359 | */ |
| 360 | b->flags |= (BF_STREAMER | BF_STREAMER_FAST); |
| 361 | //fputc('+', stderr); |
| 362 | } |
| 363 | } |
| 364 | else if ((b->flags & (BF_STREAMER | BF_STREAMER_FAST)) && |
| 365 | (cur_read <= BUFSIZE / 2)) { |
| 366 | b->xfer_large = 0; |
| 367 | b->xfer_small++; |
| 368 | if (b->xfer_small >= 2) { |
| 369 | /* if the buffer has been at least half full twice, |
| 370 | * we receive faster than we send, so at least it |
| 371 | * is not a "fast streamer". |
| 372 | */ |
| 373 | b->flags &= ~BF_STREAMER_FAST; |
| 374 | //fputc('-', stderr); |
| 375 | } |
| 376 | } |
| 377 | else { |
| 378 | b->xfer_small = 0; |
| 379 | b->xfer_large = 0; |
| 380 | } |
Willy Tarreau | 9c0fe59 | 2009-01-18 16:25:31 +0100 | [diff] [blame] | 381 | |
| 382 | b->flags |= BF_FULL; |
Willy Tarreau | a456f2a | 2009-01-18 17:38:44 +0100 | [diff] [blame] | 383 | si->flags |= SI_FL_WAIT_ROOM; |
Willy Tarreau | 9c0fe59 | 2009-01-18 16:25:31 +0100 | [diff] [blame] | 384 | break; |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 385 | } |
| 386 | |
Willy Tarreau | ab3e1d3 | 2007-06-03 14:10:36 +0200 | [diff] [blame] | 387 | /* if too many bytes were missing from last read, it means that |
| 388 | * it's pointless trying to read again because the system does |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 389 | * not have them in buffers. BTW, if FD_POLL_HUP was present, |
| 390 | * it means that we have reached the end and that the connection |
| 391 | * is closed. |
Willy Tarreau | ab3e1d3 | 2007-06-03 14:10:36 +0200 | [diff] [blame] | 392 | */ |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 393 | if (ret < max) { |
Willy Tarreau | 8a7af60 | 2008-05-03 23:07:14 +0200 | [diff] [blame] | 394 | if ((b->flags & (BF_STREAMER | BF_STREAMER_FAST)) && |
| 395 | (cur_read <= BUFSIZE / 2)) { |
| 396 | b->xfer_large = 0; |
| 397 | b->xfer_small++; |
| 398 | if (b->xfer_small >= 3) { |
| 399 | /* we have read less than half of the buffer in |
| 400 | * one pass, and this happened at least 3 times. |
| 401 | * This is definitely not a streamer. |
| 402 | */ |
| 403 | b->flags &= ~(BF_STREAMER | BF_STREAMER_FAST); |
| 404 | //fputc('!', stderr); |
| 405 | } |
| 406 | } |
Willy Tarreau | 2bea3a1 | 2008-08-28 09:47:43 +0200 | [diff] [blame] | 407 | /* unfortunately, on level-triggered events, POLL_HUP |
| 408 | * is generally delivered AFTER the system buffer is |
| 409 | * empty, so this one might never match. |
| 410 | */ |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 411 | if (fdtab[fd].ev & FD_POLL_HUP) |
| 412 | goto out_shutdown_r; |
Willy Tarreau | 2bea3a1 | 2008-08-28 09:47:43 +0200 | [diff] [blame] | 413 | |
| 414 | /* if a streamer has read few data, it may be because we |
| 415 | * have exhausted system buffers. It's not worth trying |
| 416 | * again. |
| 417 | */ |
| 418 | if (b->flags & BF_STREAMER) |
| 419 | break; |
Willy Tarreau | ab3e1d3 | 2007-06-03 14:10:36 +0200 | [diff] [blame] | 420 | |
Willy Tarreau | 6f4a82c | 2009-03-21 20:43:57 +0100 | [diff] [blame] | 421 | /* generally if we read something smaller than 1 or 2 MSS, |
| 422 | * it means that either we have exhausted the system's |
| 423 | * buffers (streamer or question-response protocol) or |
| 424 | * that the connection will be closed. Streamers are |
| 425 | * easily detected so we return early. For other cases, |
| 426 | * it's still better to perform a last read to be sure, |
| 427 | * because it may save one complete poll/read/wakeup cycle |
| 428 | * in case of shutdown. |
| 429 | */ |
| 430 | if (ret < MIN_RET_FOR_READ_LOOP && b->flags & BF_STREAMER) |
| 431 | break; |
| 432 | |
| 433 | /* if we read a large block smaller than what we requested, |
| 434 | * it's almost certain we'll never get anything more. |
| 435 | */ |
| 436 | if (ret >= global.tune.recv_enough) |
| 437 | break; |
| 438 | } |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 439 | |
Willy Tarreau | 1b194fe | 2009-03-21 21:10:04 +0100 | [diff] [blame] | 440 | if ((b->flags & BF_READ_DONTWAIT) || --read_poll <= 0) |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 441 | break; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 442 | } |
| 443 | else if (ret == 0) { |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 444 | /* connection closed */ |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 445 | goto out_shutdown_r; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 446 | } |
Willy Tarreau | 9f19529 | 2007-04-15 21:26:58 +0200 | [diff] [blame] | 447 | else if (errno == EAGAIN) { |
| 448 | /* Ignore EAGAIN but inform the poller that there is |
Willy Tarreau | af78d0f | 2009-01-08 10:09:08 +0100 | [diff] [blame] | 449 | * nothing to read left if we did not read much, ie |
| 450 | * less than what we were still expecting to read. |
| 451 | * But we may have done some work justifying to notify |
| 452 | * the task. |
Willy Tarreau | 9f19529 | 2007-04-15 21:26:58 +0200 | [diff] [blame] | 453 | */ |
Willy Tarreau | af78d0f | 2009-01-08 10:09:08 +0100 | [diff] [blame] | 454 | if (cur_read < MIN_RET_FOR_READ_LOOP) |
| 455 | retval = 0; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 456 | break; |
| 457 | } |
| 458 | else { |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 459 | goto out_error; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 460 | } |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 461 | } /* while (1) */ |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 462 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 463 | out_wakeup: |
Willy Tarreau | 9c0fe59 | 2009-01-18 16:25:31 +0100 | [diff] [blame] | 464 | /* We might have some data the consumer is waiting for */ |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 465 | if ((b->send_max || b->pipe) && (b->cons->flags & SI_FL_WAIT_DATA)) { |
| 466 | int last_len = b->pipe ? b->pipe->data : 0; |
Willy Tarreau | a456f2a | 2009-01-18 17:38:44 +0100 | [diff] [blame] | 467 | |
Willy Tarreau | 3ffeba1 | 2008-12-14 14:42:35 +0100 | [diff] [blame] | 468 | b->cons->chk_snd(b->cons); |
| 469 | |
Willy Tarreau | a456f2a | 2009-01-18 17:38:44 +0100 | [diff] [blame] | 470 | /* check if the consumer has freed some space */ |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 471 | if (!(b->flags & BF_FULL) && |
| 472 | (!last_len || !b->pipe || b->pipe->data < last_len)) |
Willy Tarreau | a456f2a | 2009-01-18 17:38:44 +0100 | [diff] [blame] | 473 | si->flags &= ~SI_FL_WAIT_ROOM; |
| 474 | } |
| 475 | |
| 476 | if (si->flags & SI_FL_WAIT_ROOM) { |
Willy Tarreau | 9c0fe59 | 2009-01-18 16:25:31 +0100 | [diff] [blame] | 477 | EV_FD_CLR(fd, DIR_RD); |
| 478 | b->rex = TICK_ETERNITY; |
| 479 | } |
Willy Tarreau | d06e711 | 2009-03-29 10:18:41 +0200 | [diff] [blame] | 480 | else if ((b->flags & (BF_SHUTR|BF_READ_PARTIAL|BF_FULL|BF_READ_NOEXP)) == BF_READ_PARTIAL) |
Willy Tarreau | a456f2a | 2009-01-18 17:38:44 +0100 | [diff] [blame] | 481 | b->rex = tick_add_ifset(now_ms, b->rto); |
Willy Tarreau | 9c0fe59 | 2009-01-18 16:25:31 +0100 | [diff] [blame] | 482 | |
Willy Tarreau | 6b66f3e | 2008-12-14 17:31:54 +0100 | [diff] [blame] | 483 | /* we have to wake up if there is a special event or if we don't have |
| 484 | * any more data to forward. |
| 485 | */ |
Willy Tarreau | 1b194fe | 2009-03-21 21:10:04 +0100 | [diff] [blame] | 486 | if ((b->flags & (BF_READ_NULL|BF_READ_ERROR|BF_SHUTR|BF_READ_DONTWAIT)) || |
Willy Tarreau | a456f2a | 2009-01-18 17:38:44 +0100 | [diff] [blame] | 487 | !b->to_forward || |
| 488 | si->state != SI_ST_EST || |
| 489 | b->cons->state != SI_ST_EST || |
| 490 | (si->flags & SI_FL_ERR)) |
Willy Tarreau | 6b66f3e | 2008-12-14 17:31:54 +0100 | [diff] [blame] | 491 | task_wakeup(si->owner, TASK_WOKEN_IO); |
Willy Tarreau | a456f2a | 2009-01-18 17:38:44 +0100 | [diff] [blame] | 492 | |
Willy Tarreau | 1b194fe | 2009-03-21 21:10:04 +0100 | [diff] [blame] | 493 | b->flags &= ~BF_READ_DONTWAIT; |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 494 | fdtab[fd].ev &= ~FD_POLL_IN; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 495 | return retval; |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 496 | |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 497 | out_shutdown_r: |
Willy Tarreau | e5ed406 | 2008-08-30 03:17:31 +0200 | [diff] [blame] | 498 | /* we received a shutdown */ |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 499 | fdtab[fd].ev &= ~FD_POLL_HUP; |
| 500 | b->flags |= BF_READ_NULL; |
Willy Tarreau | 99126c3 | 2008-11-27 10:30:51 +0100 | [diff] [blame] | 501 | stream_sock_shutr(si); |
Willy Tarreau | 0c303ee | 2008-07-07 00:09:58 +0200 | [diff] [blame] | 502 | goto out_wakeup; |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 503 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 504 | out_error: |
Willy Tarreau | cff6411 | 2008-11-03 06:26:53 +0100 | [diff] [blame] | 505 | /* Read error on the file descriptor. We mark the FD as STERROR so |
| 506 | * that we don't use it anymore. The error is reported to the stream |
| 507 | * interface which will take proper action. We must not perturbate the |
| 508 | * buffer because the stream interface wants to ensure transparent |
| 509 | * connection retries. |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 510 | */ |
Willy Tarreau | cff6411 | 2008-11-03 06:26:53 +0100 | [diff] [blame] | 511 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 512 | fdtab[fd].state = FD_STERROR; |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 513 | fdtab[fd].ev &= ~FD_POLL_STICKY; |
Willy Tarreau | 1714e0f | 2009-03-28 20:54:53 +0100 | [diff] [blame] | 514 | EV_FD_REM(fd); |
Willy Tarreau | cff6411 | 2008-11-03 06:26:53 +0100 | [diff] [blame] | 515 | si->flags |= SI_FL_ERR; |
Willy Tarreau | 9c0fe59 | 2009-01-18 16:25:31 +0100 | [diff] [blame] | 516 | retval = 1; |
| 517 | goto out_wakeup; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 518 | } |
| 519 | |
| 520 | |
| 521 | /* |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 522 | * This function is called to send buffer data to a stream socket. |
| 523 | * It returns -1 in case of unrecoverable error, 0 if the caller needs to poll |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 524 | * before calling it again, otherwise 1. If a pipe was associated with the |
| 525 | * buffer and it empties it, it releases it as well. |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 526 | */ |
Willy Tarreau | a456f2a | 2009-01-18 17:38:44 +0100 | [diff] [blame] | 527 | static int stream_sock_write_loop(struct stream_interface *si, struct buffer *b) |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 528 | { |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 529 | int write_poll = MAX_WRITE_POLL_LOOPS; |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 530 | int retval = 1; |
| 531 | int ret, max; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 532 | |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 533 | #if defined(CONFIG_HAP_LINUX_SPLICE) |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 534 | while (b->pipe) { |
| 535 | ret = splice(b->pipe->cons, NULL, si->fd, NULL, b->pipe->data, |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 536 | SPLICE_F_MOVE|SPLICE_F_NONBLOCK); |
| 537 | if (ret <= 0) { |
| 538 | if (ret == 0 || errno == EAGAIN) { |
| 539 | retval = 0; |
| 540 | return retval; |
| 541 | } |
| 542 | /* here we have another error */ |
| 543 | retval = -1; |
| 544 | return retval; |
| 545 | } |
| 546 | |
| 547 | b->flags |= BF_WRITE_PARTIAL; |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 548 | b->pipe->data -= ret; |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 549 | |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 550 | if (!b->pipe->data) { |
| 551 | put_pipe(b->pipe); |
| 552 | b->pipe = NULL; |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 553 | break; |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 554 | } |
Willy Tarreau | 5bd8c37 | 2009-01-19 00:32:22 +0100 | [diff] [blame] | 555 | |
| 556 | if (--write_poll <= 0) |
| 557 | return retval; |
| 558 | } |
| 559 | |
| 560 | /* At this point, the pipe is empty, but we may still have data pending |
| 561 | * in the normal buffer. |
| 562 | */ |
| 563 | if (!b->l) { |
| 564 | b->flags |= BF_EMPTY; |
| 565 | return retval; |
| 566 | } |
| 567 | #endif |
Willy Tarreau | d2def0f | 2009-01-18 17:37:33 +0100 | [diff] [blame] | 568 | if (!b->send_max) |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 569 | return retval; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 570 | |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 571 | /* when we're in this loop, we already know that there is no spliced |
| 572 | * data left, and that there are sendable buffered data. |
| 573 | */ |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 574 | while (1) { |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 575 | if (b->r > b->w) |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 576 | max = b->r - b->w; |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 577 | else |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 578 | max = b->data + BUFSIZE - b->w; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 579 | |
Willy Tarreau | f890dc9 | 2008-12-13 21:12:26 +0100 | [diff] [blame] | 580 | /* limit the amount of outgoing data if required */ |
| 581 | if (max > b->send_max) |
| 582 | max = b->send_max; |
| 583 | |
Willy Tarreau | fb14edc | 2009-06-14 15:24:37 +0200 | [diff] [blame] | 584 | |
| 585 | #ifdef TCP_CORK |
| 586 | /* |
| 587 | * Check if we want to cork output before sending. This typically occurs |
| 588 | * when there are data left in the buffer, or when we reached the end of |
| 589 | * buffer but we know we will close, so we try to merge the ongoing FIN |
| 590 | * with the last data segment. |
| 591 | */ |
Willy Tarreau | 5d707e1 | 2009-06-28 11:09:07 +0200 | [diff] [blame] | 592 | if ((fdtab[si->fd].flags & (FD_FL_TCP|FD_FL_TCP_NOLING|FD_FL_TCP_CORK)) == FD_FL_TCP) { |
Willy Tarreau | fb14edc | 2009-06-14 15:24:37 +0200 | [diff] [blame] | 593 | if (unlikely((b->send_max == b->l && |
| 594 | (b->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_HIJACK|BF_WRITE_ENA|BF_SHUTR)) == |
| 595 | (BF_WRITE_ENA|BF_SHUTR)))) { |
| 596 | /* we have to unconditionally reset TCP_NODELAY for CORK */ |
| 597 | setsockopt(si->fd, IPPROTO_TCP, TCP_NODELAY, (char *) &zero, sizeof(zero)); |
| 598 | setsockopt(si->fd, SOL_TCP, TCP_CORK, (char *) &one, sizeof(one)); |
| 599 | fdtab[si->fd].flags = (fdtab[si->fd].flags & ~FD_FL_TCP_NODELAY) | FD_FL_TCP_CORK; |
| 600 | } |
| 601 | } |
| 602 | #endif |
| 603 | |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 604 | #ifndef MSG_NOSIGNAL |
| 605 | { |
| 606 | int skerr; |
| 607 | socklen_t lskerr = sizeof(skerr); |
| 608 | |
Willy Tarreau | 87bed62 | 2009-03-08 22:25:28 +0100 | [diff] [blame] | 609 | ret = getsockopt(si->fd, SOL_SOCKET, SO_ERROR, &skerr, &lskerr); |
Willy Tarreau | c642348 | 2006-10-15 14:59:03 +0200 | [diff] [blame] | 610 | if (ret == -1 || skerr) |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 611 | ret = -1; |
| 612 | else |
Willy Tarreau | 87bed62 | 2009-03-08 22:25:28 +0100 | [diff] [blame] | 613 | ret = send(si->fd, b->w, max, MSG_DONTWAIT); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 614 | } |
| 615 | #else |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 616 | ret = send(si->fd, b->w, max, MSG_DONTWAIT | MSG_NOSIGNAL); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 617 | #endif |
| 618 | |
| 619 | if (ret > 0) { |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 620 | if (fdtab[si->fd].state == FD_STCONN) |
| 621 | fdtab[si->fd].state = FD_STREADY; |
Willy Tarreau | b38903c | 2008-11-23 21:33:29 +0100 | [diff] [blame] | 622 | |
Willy Tarreau | 3da77c5 | 2008-08-29 09:58:42 +0200 | [diff] [blame] | 623 | b->flags |= BF_WRITE_PARTIAL; |
Willy Tarreau | e393fe2 | 2008-08-16 22:18:07 +0200 | [diff] [blame] | 624 | |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 625 | b->w += ret; |
| 626 | if (b->w == b->data + BUFSIZE) |
| 627 | b->w = b->data; /* wrap around the buffer */ |
| 628 | |
| 629 | b->l -= ret; |
| 630 | if (likely(b->l < b->max_len)) |
Willy Tarreau | e393fe2 | 2008-08-16 22:18:07 +0200 | [diff] [blame] | 631 | b->flags &= ~BF_FULL; |
Willy Tarreau | 74ab2ac | 2008-11-23 17:23:07 +0100 | [diff] [blame] | 632 | |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 633 | if (likely(!b->l)) { |
| 634 | /* optimize data alignment in the buffer */ |
| 635 | b->r = b->w = b->lr = b->data; |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 636 | if (likely(!b->pipe)) |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 637 | b->flags |= BF_EMPTY; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 638 | } |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 639 | |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 640 | b->send_max -= ret; |
| 641 | if (!b->send_max || !b->l) |
| 642 | break; |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 643 | |
Willy Tarreau | ab3e1d3 | 2007-06-03 14:10:36 +0200 | [diff] [blame] | 644 | /* if the system buffer is full, don't insist */ |
| 645 | if (ret < max) |
| 646 | break; |
| 647 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 648 | if (--write_poll <= 0) |
| 649 | break; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 650 | } |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 651 | else if (ret == 0 || errno == EAGAIN) { |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 652 | /* nothing written, we need to poll for write first */ |
Willy Tarreau | 8374918 | 2007-04-15 20:56:27 +0200 | [diff] [blame] | 653 | retval = 0; |
| 654 | break; |
| 655 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 656 | else { |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 657 | /* bad, we got an error */ |
| 658 | retval = -1; |
| 659 | break; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 660 | } |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 661 | } /* while (1) */ |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 662 | |
Willy Tarreau | fb14edc | 2009-06-14 15:24:37 +0200 | [diff] [blame] | 663 | /* check if we need to uncork the output, for instance when the |
| 664 | * output buffer is empty but not shutr(). |
| 665 | */ |
| 666 | if (unlikely((fdtab[si->fd].flags & (FD_FL_TCP|FD_FL_TCP_NODELAY)) == FD_FL_TCP && (b->flags & BF_EMPTY))) { |
| 667 | if ((b->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_HIJACK|BF_WRITE_ENA|BF_SHUTR)) != (BF_WRITE_ENA|BF_SHUTR)) { |
| 668 | #ifdef TCP_CORK |
| 669 | if (fdtab[si->fd].flags & FD_FL_TCP_CORK) |
| 670 | setsockopt(si->fd, SOL_TCP, TCP_CORK, (char *) &zero, sizeof(zero)); |
| 671 | #endif |
| 672 | setsockopt(si->fd, IPPROTO_TCP, TCP_NODELAY, (char *) &one, sizeof(one)); |
| 673 | fdtab[si->fd].flags = (fdtab[si->fd].flags & ~FD_FL_TCP_CORK) | FD_FL_TCP_NODELAY; |
| 674 | } |
| 675 | } |
| 676 | |
| 677 | |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 678 | return retval; |
| 679 | } |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 680 | |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 681 | |
| 682 | /* |
| 683 | * This function is called on a write event from a stream socket. |
| 684 | * It returns 0 if the caller needs to poll before calling it again, otherwise |
| 685 | * non-zero. |
| 686 | */ |
| 687 | int stream_sock_write(int fd) |
| 688 | { |
| 689 | struct stream_interface *si = fdtab[fd].owner; |
| 690 | struct buffer *b = si->ob; |
| 691 | int retval = 1; |
| 692 | |
| 693 | #ifdef DEBUG_FULL |
| 694 | fprintf(stderr,"stream_sock_write : fd=%d, owner=%p\n", fd, fdtab[fd].owner); |
| 695 | #endif |
| 696 | |
| 697 | retval = 1; |
| 698 | if (fdtab[fd].state == FD_STERROR || (fdtab[fd].ev & FD_POLL_ERR)) |
| 699 | goto out_error; |
| 700 | |
Willy Tarreau | d06e711 | 2009-03-29 10:18:41 +0200 | [diff] [blame] | 701 | /* we might have been called just after an asynchronous shutw */ |
| 702 | if (b->flags & BF_SHUTW) |
| 703 | goto out_wakeup; |
| 704 | |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 705 | if (likely(!(b->flags & BF_EMPTY))) { |
| 706 | /* OK there are data waiting to be sent */ |
| 707 | retval = stream_sock_write_loop(si, b); |
| 708 | if (retval < 0) |
| 709 | goto out_error; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 710 | } |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 711 | else { |
| 712 | /* may be we have received a connection acknowledgement in TCP mode without data */ |
| 713 | if (likely(fdtab[fd].state == FD_STCONN)) { |
| 714 | /* We have no data to send to check the connection, and |
| 715 | * getsockopt() will not inform us whether the connection |
| 716 | * is still pending. So we'll reuse connect() to check the |
| 717 | * state of the socket. This has the advantage of givig us |
| 718 | * the following info : |
| 719 | * - error |
| 720 | * - connecting (EALREADY, EINPROGRESS) |
| 721 | * - connected (EISCONN, 0) |
| 722 | */ |
| 723 | if ((connect(fd, fdtab[fd].peeraddr, fdtab[fd].peerlen) == 0)) |
| 724 | errno = 0; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 725 | |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 726 | if (errno == EALREADY || errno == EINPROGRESS) { |
| 727 | retval = 0; |
| 728 | goto out_may_wakeup; |
| 729 | } |
Willy Tarreau | 3ffeba1 | 2008-12-14 14:42:35 +0100 | [diff] [blame] | 730 | |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 731 | if (errno && errno != EISCONN) |
| 732 | goto out_error; |
Willy Tarreau | fa7e102 | 2008-10-19 07:30:41 +0200 | [diff] [blame] | 733 | |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 734 | /* OK we just need to indicate that we got a connection |
| 735 | * and that we wrote nothing. |
| 736 | */ |
| 737 | b->flags |= BF_WRITE_NULL; |
| 738 | fdtab[fd].state = FD_STREADY; |
| 739 | } |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 740 | |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 741 | /* Funny, we were called to write something but there wasn't |
| 742 | * anything. We can get there, for example if we were woken up |
| 743 | * on a write event to finish the splice, but the send_max is 0 |
| 744 | * so we cannot write anything from the buffer. Let's disable |
| 745 | * the write event and pretend we never came there. |
| 746 | */ |
| 747 | } |
| 748 | |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 749 | if (!b->pipe && !b->send_max) { |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 750 | /* the connection is established but we can't write. Either the |
| 751 | * buffer is empty, or we just refrain from sending because the |
| 752 | * send_max limit was reached. Maybe we just wrote the last |
| 753 | * chunk and need to close. |
| 754 | */ |
| 755 | if (((b->flags & (BF_SHUTW|BF_EMPTY|BF_HIJACK|BF_WRITE_ENA|BF_SHUTR)) == |
| 756 | (BF_EMPTY|BF_WRITE_ENA|BF_SHUTR)) && |
| 757 | (si->state == SI_ST_EST)) { |
| 758 | stream_sock_shutw(si); |
| 759 | goto out_wakeup; |
| 760 | } |
| 761 | |
Willy Tarreau | d06e711 | 2009-03-29 10:18:41 +0200 | [diff] [blame] | 762 | if ((b->flags & (BF_EMPTY|BF_SHUTW)) == BF_EMPTY) |
Willy Tarreau | ac128fe | 2009-01-09 13:05:19 +0100 | [diff] [blame] | 763 | si->flags |= SI_FL_WAIT_DATA; |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 764 | |
Willy Tarreau | ac128fe | 2009-01-09 13:05:19 +0100 | [diff] [blame] | 765 | EV_FD_CLR(fd, DIR_WR); |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 766 | b->wex = TICK_ETERNITY; |
Willy Tarreau | ac128fe | 2009-01-09 13:05:19 +0100 | [diff] [blame] | 767 | } |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 768 | |
| 769 | out_may_wakeup: |
| 770 | if (b->flags & BF_WRITE_ACTIVITY) { |
| 771 | /* update timeout if we have written something */ |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 772 | if ((b->send_max || b->pipe) && |
Willy Tarreau | d2def0f | 2009-01-18 17:37:33 +0100 | [diff] [blame] | 773 | (b->flags & (BF_SHUTW|BF_WRITE_PARTIAL)) == BF_WRITE_PARTIAL) |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 774 | b->wex = tick_add_ifset(now_ms, b->wto); |
| 775 | |
| 776 | out_wakeup: |
| 777 | if (tick_isset(si->ib->rex)) { |
| 778 | /* Note: to prevent the client from expiring read timeouts |
| 779 | * during writes, we refresh it. A better solution would be |
| 780 | * to merge read+write timeouts into a unique one, although |
| 781 | * that needs some study particularly on full-duplex TCP |
| 782 | * connections. |
| 783 | */ |
| 784 | si->ib->rex = tick_add_ifset(now_ms, si->ib->rto); |
| 785 | } |
| 786 | |
| 787 | /* the producer might be waiting for more room to store data */ |
Willy Tarreau | d06e711 | 2009-03-29 10:18:41 +0200 | [diff] [blame] | 788 | if (likely((b->flags & (BF_SHUTW|BF_WRITE_PARTIAL|BF_FULL)) == BF_WRITE_PARTIAL && |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 789 | (b->prod->flags & SI_FL_WAIT_ROOM))) |
| 790 | b->prod->chk_rcv(b->prod); |
| 791 | |
| 792 | /* we have to wake up if there is a special event or if we don't have |
| 793 | * any more data to forward and it's not planned to send any more. |
| 794 | */ |
| 795 | if (likely((b->flags & (BF_WRITE_NULL|BF_WRITE_ERROR|BF_SHUTW)) || |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 796 | (!b->to_forward && !b->send_max && !b->pipe) || |
Willy Tarreau | 0c2fc1f | 2009-01-18 15:30:37 +0100 | [diff] [blame] | 797 | si->state != SI_ST_EST || |
| 798 | b->prod->state != SI_ST_EST)) |
| 799 | task_wakeup(si->owner, TASK_WOKEN_IO); |
| 800 | } |
| 801 | |
| 802 | fdtab[fd].ev &= ~FD_POLL_OUT; |
| 803 | return retval; |
Willy Tarreau | ac128fe | 2009-01-09 13:05:19 +0100 | [diff] [blame] | 804 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 805 | out_error: |
Willy Tarreau | cff6411 | 2008-11-03 06:26:53 +0100 | [diff] [blame] | 806 | /* Write error on the file descriptor. We mark the FD as STERROR so |
| 807 | * that we don't use it anymore. The error is reported to the stream |
| 808 | * interface which will take proper action. We must not perturbate the |
| 809 | * buffer because the stream interface wants to ensure transparent |
| 810 | * connection retries. |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 811 | */ |
Willy Tarreau | cff6411 | 2008-11-03 06:26:53 +0100 | [diff] [blame] | 812 | |
Willy Tarreau | 6996e15 | 2007-04-30 14:37:43 +0200 | [diff] [blame] | 813 | fdtab[fd].state = FD_STERROR; |
Willy Tarreau | d6f087e | 2008-01-18 17:20:13 +0100 | [diff] [blame] | 814 | fdtab[fd].ev &= ~FD_POLL_STICKY; |
Willy Tarreau | 1714e0f | 2009-03-28 20:54:53 +0100 | [diff] [blame] | 815 | EV_FD_REM(fd); |
Willy Tarreau | cff6411 | 2008-11-03 06:26:53 +0100 | [diff] [blame] | 816 | si->flags |= SI_FL_ERR; |
Willy Tarreau | e5ed406 | 2008-08-30 03:17:31 +0200 | [diff] [blame] | 817 | task_wakeup(si->owner, TASK_WOKEN_IO); |
| 818 | return 1; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 819 | } |
| 820 | |
Willy Tarreau | 48adac5 | 2008-08-30 04:58:38 +0200 | [diff] [blame] | 821 | /* |
Willy Tarreau | 3c6ab2e | 2008-09-04 11:19:41 +0200 | [diff] [blame] | 822 | * This function performs a shutdown-write on a stream interface in a connected or |
| 823 | * init state (it does nothing for other states). It either shuts the write side |
Willy Tarreau | 99126c3 | 2008-11-27 10:30:51 +0100 | [diff] [blame] | 824 | * or closes the file descriptor and marks itself as closed. The buffer flags are |
| 825 | * updated to reflect the new state. |
Willy Tarreau | 48adac5 | 2008-08-30 04:58:38 +0200 | [diff] [blame] | 826 | */ |
Willy Tarreau | 0a5d5dd | 2008-11-23 19:31:35 +0100 | [diff] [blame] | 827 | void stream_sock_shutw(struct stream_interface *si) |
Willy Tarreau | 48adac5 | 2008-08-30 04:58:38 +0200 | [diff] [blame] | 828 | { |
Willy Tarreau | 99126c3 | 2008-11-27 10:30:51 +0100 | [diff] [blame] | 829 | if (si->ob->flags & BF_SHUTW) |
| 830 | return; |
| 831 | si->ob->flags |= BF_SHUTW; |
| 832 | si->ob->wex = TICK_ETERNITY; |
Willy Tarreau | b0ef735 | 2008-12-14 13:26:20 +0100 | [diff] [blame] | 833 | si->flags &= ~SI_FL_WAIT_DATA; |
Willy Tarreau | 99126c3 | 2008-11-27 10:30:51 +0100 | [diff] [blame] | 834 | |
Willy Tarreau | b38903c | 2008-11-23 21:33:29 +0100 | [diff] [blame] | 835 | switch (si->state) { |
Willy Tarreau | b38903c | 2008-11-23 21:33:29 +0100 | [diff] [blame] | 836 | case SI_ST_EST: |
Willy Tarreau | 720058c | 2009-07-14 19:21:50 +0200 | [diff] [blame^] | 837 | /* we have to shut before closing, otherwise some short messages |
| 838 | * may never leave the system, especially when there are remaining |
| 839 | * unread data in the socket input buffer, or when nolinger is set. |
| 840 | */ |
| 841 | EV_FD_CLR(si->fd, DIR_WR); |
| 842 | shutdown(si->fd, SHUT_WR); |
| 843 | |
| 844 | if (!(si->ib->flags & BF_SHUTR)) |
Willy Tarreau | b38903c | 2008-11-23 21:33:29 +0100 | [diff] [blame] | 845 | return; |
Willy Tarreau | 5d707e1 | 2009-06-28 11:09:07 +0200 | [diff] [blame] | 846 | |
Willy Tarreau | b38903c | 2008-11-23 21:33:29 +0100 | [diff] [blame] | 847 | /* fall through */ |
| 848 | case SI_ST_CON: |
Willy Tarreau | 8bfa426 | 2008-11-27 09:25:45 +0100 | [diff] [blame] | 849 | /* we may have to close a pending connection, and mark the |
| 850 | * response buffer as shutr |
| 851 | */ |
Willy Tarreau | 48adac5 | 2008-08-30 04:58:38 +0200 | [diff] [blame] | 852 | fd_delete(si->fd); |
Willy Tarreau | fe3718a | 2008-11-30 18:14:12 +0100 | [diff] [blame] | 853 | /* fall through */ |
| 854 | case SI_ST_CER: |
Willy Tarreau | 7f00651 | 2008-12-07 14:04:04 +0100 | [diff] [blame] | 855 | si->state = SI_ST_DIS; |
| 856 | default: |
Willy Tarreau | d06e711 | 2009-03-29 10:18:41 +0200 | [diff] [blame] | 857 | si->flags &= ~SI_FL_WAIT_ROOM; |
Willy Tarreau | 99126c3 | 2008-11-27 10:30:51 +0100 | [diff] [blame] | 858 | si->ib->flags |= BF_SHUTR; |
Willy Tarreau | fe3718a | 2008-11-30 18:14:12 +0100 | [diff] [blame] | 859 | si->ib->rex = TICK_ETERNITY; |
Willy Tarreau | 127334e | 2009-03-28 10:47:26 +0100 | [diff] [blame] | 860 | si->exp = TICK_ETERNITY; |
Willy Tarreau | 0a5d5dd | 2008-11-23 19:31:35 +0100 | [diff] [blame] | 861 | return; |
Willy Tarreau | 48adac5 | 2008-08-30 04:58:38 +0200 | [diff] [blame] | 862 | } |
Willy Tarreau | 48adac5 | 2008-08-30 04:58:38 +0200 | [diff] [blame] | 863 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 864 | |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 865 | /* |
Willy Tarreau | 3c6ab2e | 2008-09-04 11:19:41 +0200 | [diff] [blame] | 866 | * This function performs a shutdown-read on a stream interface in a connected or |
Willy Tarreau | 0a5d5dd | 2008-11-23 19:31:35 +0100 | [diff] [blame] | 867 | * init state (it does nothing for other states). It either shuts the read side |
Willy Tarreau | 99126c3 | 2008-11-27 10:30:51 +0100 | [diff] [blame] | 868 | * or closes the file descriptor and marks itself as closed. The buffer flags are |
| 869 | * updated to reflect the new state. |
Willy Tarreau | 3c6ab2e | 2008-09-04 11:19:41 +0200 | [diff] [blame] | 870 | */ |
Willy Tarreau | 0a5d5dd | 2008-11-23 19:31:35 +0100 | [diff] [blame] | 871 | void stream_sock_shutr(struct stream_interface *si) |
Willy Tarreau | 3c6ab2e | 2008-09-04 11:19:41 +0200 | [diff] [blame] | 872 | { |
Willy Tarreau | 99126c3 | 2008-11-27 10:30:51 +0100 | [diff] [blame] | 873 | if (si->ib->flags & BF_SHUTR) |
| 874 | return; |
| 875 | si->ib->flags |= BF_SHUTR; |
| 876 | si->ib->rex = TICK_ETERNITY; |
Willy Tarreau | b0ef735 | 2008-12-14 13:26:20 +0100 | [diff] [blame] | 877 | si->flags &= ~SI_FL_WAIT_ROOM; |
Willy Tarreau | 99126c3 | 2008-11-27 10:30:51 +0100 | [diff] [blame] | 878 | |
Willy Tarreau | 8bfa426 | 2008-11-27 09:25:45 +0100 | [diff] [blame] | 879 | if (si->state != SI_ST_EST && si->state != SI_ST_CON) |
Willy Tarreau | 0a5d5dd | 2008-11-23 19:31:35 +0100 | [diff] [blame] | 880 | return; |
Willy Tarreau | 3c6ab2e | 2008-09-04 11:19:41 +0200 | [diff] [blame] | 881 | |
Willy Tarreau | cff6411 | 2008-11-03 06:26:53 +0100 | [diff] [blame] | 882 | if (si->ob->flags & BF_SHUTW) { |
Willy Tarreau | 3c6ab2e | 2008-09-04 11:19:41 +0200 | [diff] [blame] | 883 | fd_delete(si->fd); |
Willy Tarreau | 74ab2ac | 2008-11-23 17:23:07 +0100 | [diff] [blame] | 884 | si->state = SI_ST_DIS; |
Willy Tarreau | 127334e | 2009-03-28 10:47:26 +0100 | [diff] [blame] | 885 | si->exp = TICK_ETERNITY; |
Willy Tarreau | 0a5d5dd | 2008-11-23 19:31:35 +0100 | [diff] [blame] | 886 | return; |
Willy Tarreau | 3c6ab2e | 2008-09-04 11:19:41 +0200 | [diff] [blame] | 887 | } |
| 888 | EV_FD_CLR(si->fd, DIR_RD); |
Willy Tarreau | 0a5d5dd | 2008-11-23 19:31:35 +0100 | [diff] [blame] | 889 | return; |
Willy Tarreau | 3c6ab2e | 2008-09-04 11:19:41 +0200 | [diff] [blame] | 890 | } |
| 891 | |
| 892 | /* |
Willy Tarreau | 3a16b2c | 2008-08-28 08:54:27 +0200 | [diff] [blame] | 893 | * Updates a connected stream_sock file descriptor status and timeouts |
| 894 | * according to the buffers' flags. It should only be called once after the |
| 895 | * buffer flags have settled down, and before they are cleared. It doesn't |
| 896 | * harm to call it as often as desired (it just slightly hurts performance). |
| 897 | */ |
Willy Tarreau | b025325 | 2008-11-30 21:37:12 +0100 | [diff] [blame] | 898 | void stream_sock_data_finish(struct stream_interface *si) |
Willy Tarreau | 3a16b2c | 2008-08-28 08:54:27 +0200 | [diff] [blame] | 899 | { |
Willy Tarreau | b025325 | 2008-11-30 21:37:12 +0100 | [diff] [blame] | 900 | struct buffer *ib = si->ib; |
| 901 | struct buffer *ob = si->ob; |
| 902 | int fd = si->fd; |
Willy Tarreau | 3a16b2c | 2008-08-28 08:54:27 +0200 | [diff] [blame] | 903 | |
Willy Tarreau | e5ed406 | 2008-08-30 03:17:31 +0200 | [diff] [blame] | 904 | DPRINTF(stderr,"[%u] %s: fd=%d owner=%p ib=%p, ob=%p, exp(r,w)=%u,%u ibf=%08x obf=%08x ibl=%d obl=%d si=%d\n", |
Willy Tarreau | 3a16b2c | 2008-08-28 08:54:27 +0200 | [diff] [blame] | 905 | now_ms, __FUNCTION__, |
| 906 | fd, fdtab[fd].owner, |
| 907 | ib, ob, |
| 908 | ib->rex, ob->wex, |
| 909 | ib->flags, ob->flags, |
Willy Tarreau | b025325 | 2008-11-30 21:37:12 +0100 | [diff] [blame] | 910 | ib->l, ob->l, si->state); |
Willy Tarreau | 3a16b2c | 2008-08-28 08:54:27 +0200 | [diff] [blame] | 911 | |
| 912 | /* Check if we need to close the read side */ |
| 913 | if (!(ib->flags & BF_SHUTR)) { |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 914 | /* Read not closed, update FD status and timeout for reads */ |
Willy Tarreau | 3a16b2c | 2008-08-28 08:54:27 +0200 | [diff] [blame] | 915 | if (ib->flags & (BF_FULL|BF_HIJACK)) { |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 916 | /* stop reading */ |
Willy Tarreau | b0ef735 | 2008-12-14 13:26:20 +0100 | [diff] [blame] | 917 | if ((ib->flags & (BF_FULL|BF_HIJACK)) == BF_FULL) |
| 918 | si->flags |= SI_FL_WAIT_ROOM; |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 919 | EV_FD_COND_C(fd, DIR_RD); |
| 920 | ib->rex = TICK_ETERNITY; |
| 921 | } |
| 922 | else { |
| 923 | /* (re)start reading and update timeout. Note: we don't recompute the timeout |
| 924 | * everytime we get here, otherwise it would risk never to expire. We only |
| 925 | * update it if is was not yet set, or if we already got some read status. |
| 926 | */ |
Willy Tarreau | b0ef735 | 2008-12-14 13:26:20 +0100 | [diff] [blame] | 927 | si->flags &= ~SI_FL_WAIT_ROOM; |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 928 | EV_FD_COND_S(fd, DIR_RD); |
Willy Tarreau | 86491c3 | 2008-12-14 09:04:47 +0100 | [diff] [blame] | 929 | if (!(ib->flags & BF_READ_NOEXP) && |
| 930 | (!tick_isset(ib->rex) || ib->flags & BF_READ_ACTIVITY)) |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 931 | ib->rex = tick_add_ifset(now_ms, ib->rto); |
| 932 | } |
| 933 | } |
| 934 | |
| 935 | /* Check if we need to close the write side */ |
| 936 | if (!(ob->flags & BF_SHUTW)) { |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 937 | /* Write not closed, update FD status and timeout for writes */ |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 938 | if ((ob->send_max == 0 && !ob->pipe) || |
Willy Tarreau | 3ffeba1 | 2008-12-14 14:42:35 +0100 | [diff] [blame] | 939 | (ob->flags & BF_EMPTY) || |
Willy Tarreau | 3da77c5 | 2008-08-29 09:58:42 +0200 | [diff] [blame] | 940 | (ob->flags & (BF_HIJACK|BF_WRITE_ENA)) == 0) { |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 941 | /* stop writing */ |
Willy Tarreau | b0ef735 | 2008-12-14 13:26:20 +0100 | [diff] [blame] | 942 | if ((ob->flags & (BF_EMPTY|BF_HIJACK|BF_WRITE_ENA)) == (BF_EMPTY|BF_WRITE_ENA)) |
| 943 | si->flags |= SI_FL_WAIT_DATA; |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 944 | EV_FD_COND_C(fd, DIR_WR); |
| 945 | ob->wex = TICK_ETERNITY; |
| 946 | } |
| 947 | else { |
| 948 | /* (re)start writing and update timeout. Note: we don't recompute the timeout |
| 949 | * everytime we get here, otherwise it would risk never to expire. We only |
| 950 | * update it if is was not yet set, or if we already got some write status. |
| 951 | */ |
Willy Tarreau | b0ef735 | 2008-12-14 13:26:20 +0100 | [diff] [blame] | 952 | si->flags &= ~SI_FL_WAIT_DATA; |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 953 | EV_FD_COND_S(fd, DIR_WR); |
Willy Tarreau | 3da77c5 | 2008-08-29 09:58:42 +0200 | [diff] [blame] | 954 | if (!tick_isset(ob->wex) || ob->flags & BF_WRITE_ACTIVITY) { |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 955 | ob->wex = tick_add_ifset(now_ms, ob->wto); |
Willy Tarreau | d06e711 | 2009-03-29 10:18:41 +0200 | [diff] [blame] | 956 | if (tick_isset(ib->rex)) { |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 957 | /* Note: depending on the protocol, we don't know if we're waiting |
| 958 | * for incoming data or not. So in order to prevent the socket from |
| 959 | * expiring read timeouts during writes, we refresh the read timeout, |
| 960 | * except if it was already infinite. |
| 961 | */ |
Willy Tarreau | d06e711 | 2009-03-29 10:18:41 +0200 | [diff] [blame] | 962 | ib->rex = tick_add_ifset(now_ms, ib->rto); |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 963 | } |
| 964 | } |
| 965 | } |
| 966 | } |
Willy Tarreau | 2d21279 | 2008-08-27 21:41:35 +0200 | [diff] [blame] | 967 | } |
| 968 | |
Willy Tarreau | 3ffeba1 | 2008-12-14 14:42:35 +0100 | [diff] [blame] | 969 | /* This function is used for inter-stream-interface calls. It is called by the |
| 970 | * consumer to inform the producer side that it may be interested in checking |
| 971 | * for free space in the buffer. Note that it intentionally does not update |
| 972 | * timeouts, so that we can still check them later at wake-up. |
| 973 | */ |
| 974 | void stream_sock_chk_rcv(struct stream_interface *si) |
| 975 | { |
| 976 | struct buffer *ib = si->ib; |
| 977 | |
| 978 | DPRINTF(stderr,"[%u] %s: fd=%d owner=%p ib=%p, ob=%p, exp(r,w)=%u,%u ibf=%08x obf=%08x ibl=%d obl=%d si=%d\n", |
| 979 | now_ms, __FUNCTION__, |
Vincenzo Farruggia | 9b97cff | 2009-01-30 16:49:10 +0000 | [diff] [blame] | 980 | si->fd, fdtab[si->fd].owner, |
| 981 | ib, si->ob, |
| 982 | ib->rex, si->ob->wex, |
| 983 | ib->flags, si->ob->flags, |
| 984 | ib->l, si->ob->l, si->state); |
Willy Tarreau | 3ffeba1 | 2008-12-14 14:42:35 +0100 | [diff] [blame] | 985 | |
| 986 | if (unlikely(si->state != SI_ST_EST || (ib->flags & BF_SHUTR))) |
| 987 | return; |
| 988 | |
| 989 | if (ib->flags & (BF_FULL|BF_HIJACK)) { |
| 990 | /* stop reading */ |
| 991 | if ((ib->flags & (BF_FULL|BF_HIJACK)) == BF_FULL) |
| 992 | si->flags |= SI_FL_WAIT_ROOM; |
| 993 | EV_FD_COND_C(si->fd, DIR_RD); |
| 994 | } |
| 995 | else { |
| 996 | /* (re)start reading */ |
| 997 | si->flags &= ~SI_FL_WAIT_ROOM; |
| 998 | EV_FD_COND_S(si->fd, DIR_RD); |
| 999 | } |
| 1000 | } |
| 1001 | |
| 1002 | |
| 1003 | /* This function is used for inter-stream-interface calls. It is called by the |
| 1004 | * producer to inform the consumer side that it may be interested in checking |
| 1005 | * for data in the buffer. Note that it intentionally does not update timeouts, |
| 1006 | * so that we can still check them later at wake-up. |
| 1007 | */ |
| 1008 | void stream_sock_chk_snd(struct stream_interface *si) |
| 1009 | { |
| 1010 | struct buffer *ob = si->ob; |
Willy Tarreau | a456f2a | 2009-01-18 17:38:44 +0100 | [diff] [blame] | 1011 | int retval; |
Willy Tarreau | 3ffeba1 | 2008-12-14 14:42:35 +0100 | [diff] [blame] | 1012 | |
| 1013 | DPRINTF(stderr,"[%u] %s: fd=%d owner=%p ib=%p, ob=%p, exp(r,w)=%u,%u ibf=%08x obf=%08x ibl=%d obl=%d si=%d\n", |
| 1014 | now_ms, __FUNCTION__, |
Vincenzo Farruggia | 9b97cff | 2009-01-30 16:49:10 +0000 | [diff] [blame] | 1015 | si->fd, fdtab[si->fd].owner, |
| 1016 | si->ib, ob, |
| 1017 | si->ib->rex, ob->wex, |
| 1018 | si->ib->flags, ob->flags, |
| 1019 | si->ib->l, ob->l, si->state); |
Willy Tarreau | 3ffeba1 | 2008-12-14 14:42:35 +0100 | [diff] [blame] | 1020 | |
| 1021 | if (unlikely(si->state != SI_ST_EST || (ob->flags & BF_SHUTW))) |
| 1022 | return; |
| 1023 | |
Willy Tarreau | a456f2a | 2009-01-18 17:38:44 +0100 | [diff] [blame] | 1024 | if (!(si->flags & SI_FL_WAIT_DATA) || /* not waiting for data */ |
| 1025 | (fdtab[si->fd].ev & FD_POLL_OUT) || /* we'll be called anyway */ |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 1026 | !(ob->send_max || ob->pipe) || /* called with nothing to send ! */ |
Willy Tarreau | a456f2a | 2009-01-18 17:38:44 +0100 | [diff] [blame] | 1027 | !(ob->flags & (BF_HIJACK|BF_WRITE_ENA))) /* we may not write */ |
| 1028 | return; |
| 1029 | |
| 1030 | retval = stream_sock_write_loop(si, ob); |
| 1031 | if (retval < 0) { |
| 1032 | /* Write error on the file descriptor. We mark the FD as STERROR so |
| 1033 | * that we don't use it anymore and we notify the task. |
| 1034 | */ |
| 1035 | fdtab[si->fd].state = FD_STERROR; |
| 1036 | fdtab[si->fd].ev &= ~FD_POLL_STICKY; |
Willy Tarreau | 1714e0f | 2009-03-28 20:54:53 +0100 | [diff] [blame] | 1037 | EV_FD_REM(si->fd); |
Willy Tarreau | a456f2a | 2009-01-18 17:38:44 +0100 | [diff] [blame] | 1038 | si->flags |= SI_FL_ERR; |
| 1039 | goto out_wakeup; |
| 1040 | } |
| 1041 | |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 1042 | if (retval > 0 || (ob->send_max == 0 && !ob->pipe)) { |
Willy Tarreau | a456f2a | 2009-01-18 17:38:44 +0100 | [diff] [blame] | 1043 | /* the connection is established but we can't write. Either the |
| 1044 | * buffer is empty, or we just refrain from sending because the |
| 1045 | * send_max limit was reached. Maybe we just wrote the last |
| 1046 | * chunk and need to close. |
| 1047 | */ |
| 1048 | if (((ob->flags & (BF_SHUTW|BF_EMPTY|BF_HIJACK|BF_WRITE_ENA|BF_SHUTR)) == |
| 1049 | (BF_EMPTY|BF_WRITE_ENA|BF_SHUTR)) && |
| 1050 | (si->state == SI_ST_EST)) { |
| 1051 | stream_sock_shutw(si); |
| 1052 | goto out_wakeup; |
| 1053 | } |
Willy Tarreau | d06e711 | 2009-03-29 10:18:41 +0200 | [diff] [blame] | 1054 | |
| 1055 | if ((ob->flags & (BF_SHUTW|BF_EMPTY|BF_HIJACK|BF_WRITE_ENA)) == (BF_EMPTY|BF_WRITE_ENA)) |
Willy Tarreau | 3ffeba1 | 2008-12-14 14:42:35 +0100 | [diff] [blame] | 1056 | si->flags |= SI_FL_WAIT_DATA; |
Willy Tarreau | a456f2a | 2009-01-18 17:38:44 +0100 | [diff] [blame] | 1057 | ob->wex = TICK_ETERNITY; |
Willy Tarreau | 3ffeba1 | 2008-12-14 14:42:35 +0100 | [diff] [blame] | 1058 | } |
| 1059 | else { |
| 1060 | /* (re)start writing. */ |
| 1061 | si->flags &= ~SI_FL_WAIT_DATA; |
| 1062 | EV_FD_COND_S(si->fd, DIR_WR); |
| 1063 | } |
Willy Tarreau | a456f2a | 2009-01-18 17:38:44 +0100 | [diff] [blame] | 1064 | |
Willy Tarreau | c961946 | 2009-03-09 22:40:57 +0100 | [diff] [blame] | 1065 | if (likely(ob->flags & BF_WRITE_ACTIVITY)) { |
| 1066 | /* update timeout if we have written something */ |
| 1067 | if ((ob->send_max || ob->pipe) && |
| 1068 | (ob->flags & (BF_SHUTW|BF_WRITE_PARTIAL)) == BF_WRITE_PARTIAL) |
| 1069 | ob->wex = tick_add_ifset(now_ms, ob->wto); |
| 1070 | |
| 1071 | if (tick_isset(si->ib->rex)) { |
| 1072 | /* Note: to prevent the client from expiring read timeouts |
| 1073 | * during writes, we refresh it. A better solution would be |
| 1074 | * to merge read+write timeouts into a unique one, although |
| 1075 | * that needs some study particularly on full-duplex TCP |
| 1076 | * connections. |
| 1077 | */ |
| 1078 | si->ib->rex = tick_add_ifset(now_ms, si->ib->rto); |
| 1079 | } |
| 1080 | } |
| 1081 | |
Willy Tarreau | a456f2a | 2009-01-18 17:38:44 +0100 | [diff] [blame] | 1082 | /* in case of special condition (error, shutdown, end of write...), we |
| 1083 | * have to notify the task. |
| 1084 | */ |
| 1085 | if (likely((ob->flags & (BF_WRITE_NULL|BF_WRITE_ERROR|BF_SHUTW)) || |
Willy Tarreau | 3eba98a | 2009-01-25 13:56:13 +0100 | [diff] [blame] | 1086 | (!ob->to_forward && !ob->send_max && !ob->pipe) || |
Willy Tarreau | a456f2a | 2009-01-18 17:38:44 +0100 | [diff] [blame] | 1087 | si->state != SI_ST_EST)) { |
| 1088 | out_wakeup: |
| 1089 | task_wakeup(si->owner, TASK_WOKEN_IO); |
| 1090 | } |
Willy Tarreau | 3ffeba1 | 2008-12-14 14:42:35 +0100 | [diff] [blame] | 1091 | } |
| 1092 | |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 1093 | |
| 1094 | /* |
| 1095 | * Local variables: |
| 1096 | * c-indent-level: 8 |
| 1097 | * c-basic-offset: 8 |
| 1098 | * End: |
| 1099 | */ |