blob: 5df0b45dfdc7b05b7383338a25556cf445e00e2e [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
2 * File descriptors management functions.
3 *
Willy Tarreau7be79a42012-11-11 15:02:54 +01004 * Copyright 2000-2012 Willy Tarreau <w@1wt.eu>
Willy Tarreaubaaee002006-06-26 02:48:02 +02005 *
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 *
Willy Tarreau7be79a42012-11-11 15:02:54 +010011 * This code implements "speculative I/O". The principle is to try to perform
12 * expected I/O before registering the events in the poller. Each time this
13 * succeeds, it saves a possibly expensive system call to set the event. It
14 * generally succeeds for all reads after an accept(), and for writes after a
15 * connect(). It also improves performance for streaming connections because
16 * even if only one side is polled, the other one may react accordingly
17 * depending on the fill level of the buffer. This behaviour is also the only
18 * one compatible with event-based pollers (eg: EPOLL_ET).
19 *
20 * More importantly, it enables I/O operations that are backed by invisible
21 * buffers. For example, SSL is able to read a whole socket buffer and not
22 * deliver it to the application buffer because it's full. Unfortunately, it
23 * won't be reported by a poller anymore until some new activity happens. The
24 * only way to call it again thus is to perform speculative I/O as soon as
25 * reading on the FD is enabled again.
26 *
27 * The speculative I/O uses a list of expected events and a list of updates.
28 * Expected events are events that are expected to come and that we must report
29 * to the application until it asks to stop or to poll. Updates are new requests
30 * for changing an FD state. Updates are the only way to create new events. This
31 * is important because it means that the number of speculative events cannot
32 * increase between updates and will only grow one at a time while processing
33 * updates. All updates must always be processed, though events might be
34 * processed by small batches if required.
35 *
36 * There is no direct link between the FD and the updates list. There is only a
37 * bit in the fdtab[] to indicate than a file descriptor is already present in
38 * the updates list. Once an fd is present in the updates list, it will have to
39 * be considered even if its changes are reverted in the middle or if the fd is
40 * replaced.
41 *
42 * It is important to understand that as long as all expected events are
43 * processed, they might starve the polled events, especially because polled
44 * I/O starvation quickly induces more speculative I/O. One solution to this
45 * consists in only processing a part of the events at once, but one drawback
46 * is that unhandled events will still wake the poller up. Using an event-driven
47 * poller such as EPOLL_ET will solve this issue though.
48 *
49 * A file descriptor has a distinct state for each direction. This state is a
50 * combination of two bits :
51 * bit 0 = active Y/N : is set if the FD is active, which means that its
52 * handler will be called without prior polling ;
53 * bit 1 = polled Y/N : is set if the FD was subscribed to polling
54 *
55 * It is perfectly valid to have both bits set at a time, which generally means
56 * that the FD was reported by polling, was marked active and not yet unpolled.
57 * Such a state must not last long to avoid unneeded wakeups.
58 *
59 * The state of the FD as of last change is preserved in two other bits. These
60 * ones are useful to save a significant amount of system calls during state
61 * changes, because there is no need to update the FD status in the system until
62 * we're about to call the poller.
63 *
64 * Since we do not want to scan all the FD list to find speculative I/O events,
65 * we store them in a list consisting in a linear array holding only the FD
66 * indexes right now. Note that a closed FD cannot exist in the spec list,
67 * because it is closed by fd_delete() which in turn calls __fd_clo() which
68 * always removes it from the list.
69 *
70 * For efficiency reasons, we will store the Read and Write bits interlaced to
71 * form a 4-bit field, so that we can simply shift the value right by 0/1 and
72 * get what we want :
73 * 3 2 1 0
74 * Wp Rp Wa Ra
75 *
76 * The FD array has to hold a back reference to the speculative list. This
77 * reference is always valid unless the FD if currently being polled and not
78 * updated (in which case the reference points to index 0).
79 *
80 * We store the FD state in the 4 lower bits of fdtab[fd].spec_e, and save the
81 * previous state upon changes in the 4 higher bits, so that changes are easy
82 * to spot.
Willy Tarreaubaaee002006-06-26 02:48:02 +020083 */
84
Willy Tarreau2ff76222007-04-09 19:29:56 +020085#include <stdio.h>
Willy Tarreau4f60f162007-04-08 16:39:58 +020086#include <string.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020087#include <unistd.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020088#include <sys/types.h>
89
Willy Tarreau2dd0d472006-06-29 17:53:05 +020090#include <common/compat.h>
91#include <common/config.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020092
Willy Tarreau7be79a42012-11-11 15:02:54 +010093#include <types/global.h>
94
Willy Tarreau2a429502006-10-15 14:52:29 +020095#include <proto/fd.h>
Willy Tarreauc6f4ce82009-06-10 11:09:37 +020096#include <proto/port_range.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020097
98struct fdtab *fdtab = NULL; /* array of all the file descriptors */
Willy Tarreau8d5d77e2009-10-18 07:25:52 +020099struct fdinfo *fdinfo = NULL; /* less-often used infos for file descriptors */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200100int maxfd; /* # of the highest fd + 1 */
101int totalconn; /* total # of terminated sessions */
102int actconn; /* # of active sessions */
103
Willy Tarreau4f60f162007-04-08 16:39:58 +0200104struct poller pollers[MAX_POLLERS];
105struct poller cur_poller;
106int nbpollers = 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200107
Willy Tarreau7be79a42012-11-11 15:02:54 +0100108/* FD status is defined by the poller's status and by the speculative I/O list */
109int fd_nbspec = 0; // number of speculative events in the list
110int fd_nbupdt = 0; // number of updates in the list
111unsigned int *fd_spec = NULL; // speculative I/O list
112unsigned int *fd_updt = NULL; // FD updates list
Willy Tarreaubaaee002006-06-26 02:48:02 +0200113
Willy Tarreau4f60f162007-04-08 16:39:58 +0200114/* Deletes an FD from the fdsets, and recomputes the maxfd limit.
115 * The file descriptor is also closed.
116 */
117void fd_delete(int fd)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200118{
Willy Tarreau6ea20b12012-11-11 16:05:19 +0100119 if (cur_poller.clo)
120 cur_poller.clo(fd);
121
122 release_spec_entry(fd);
123 fdtab[fd].spec_e &= ~(FD_EV_CURR_MASK | FD_EV_PREV_MASK);
124
Willy Tarreau8d5d77e2009-10-18 07:25:52 +0200125 port_range_release_port(fdinfo[fd].port_range, fdinfo[fd].local_port);
126 fdinfo[fd].port_range = NULL;
Willy Tarreau4f60f162007-04-08 16:39:58 +0200127 close(fd);
Willy Tarreaudb3b3262012-07-05 23:19:22 +0200128 fdtab[fd].owner = NULL;
Willy Tarreau1720abd2012-11-11 17:08:32 +0100129 fdtab[fd].new = 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200130
Willy Tarreaudb3b3262012-07-05 23:19:22 +0200131 while ((maxfd-1 >= 0) && !fdtab[maxfd-1].owner)
Willy Tarreau4f60f162007-04-08 16:39:58 +0200132 maxfd--;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200133}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200134
Willy Tarreau09f24562012-11-11 16:43:45 +0100135/* Scan and process the speculative events. This should be called right after
136 * the poller.
137 */
138void fd_process_spec_events()
139{
140 int fd, spec_idx, e;
141
142 /* now process speculative events if any */
143
144 for (spec_idx = 0; spec_idx < fd_nbspec; ) {
145 fd = fd_spec[spec_idx];
146 e = fdtab[fd].spec_e;
147
148 /*
149 * Process the speculative events.
150 *
151 * Principle: events which are marked FD_EV_ACTIVE are processed
152 * with their usual I/O callback. The callback may remove the
153 * events from the list or tag them for polling. Changes will be
154 * applied on next round.
155 */
156
157 fdtab[fd].ev &= FD_POLL_STICKY;
158
Willy Tarreau70d0ad52012-11-12 01:57:14 +0100159 if (e & FD_EV_ACTIVE_R)
Willy Tarreau09f24562012-11-11 16:43:45 +0100160 fdtab[fd].ev |= FD_POLL_IN;
161
Willy Tarreau70d0ad52012-11-12 01:57:14 +0100162 if (e & FD_EV_ACTIVE_W)
Willy Tarreau09f24562012-11-11 16:43:45 +0100163 fdtab[fd].ev |= FD_POLL_OUT;
164
165 if (fdtab[fd].iocb && fdtab[fd].owner && fdtab[fd].ev)
166 fdtab[fd].iocb(fd);
167
168 /* if the fd was removed from the spec list, it has been
169 * replaced by the next one that we don't want to skip !
170 */
171 if (spec_idx < fd_nbspec && fd_spec[spec_idx] != fd)
172 continue;
173
174 spec_idx++;
175 }
176}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200177
Willy Tarreau4f60f162007-04-08 16:39:58 +0200178/* disable the specified poller */
179void disable_poller(const char *poller_name)
180{
181 int p;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200182
Willy Tarreau4f60f162007-04-08 16:39:58 +0200183 for (p = 0; p < nbpollers; p++)
184 if (strcmp(pollers[p].name, poller_name) == 0)
185 pollers[p].pref = 0;
186}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200187
188/*
Willy Tarreau4f60f162007-04-08 16:39:58 +0200189 * Initialize the pollers till the best one is found.
190 * If none works, returns 0, otherwise 1.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200191 */
Willy Tarreau4f60f162007-04-08 16:39:58 +0200192int init_pollers()
Willy Tarreaubaaee002006-06-26 02:48:02 +0200193{
Willy Tarreau4f60f162007-04-08 16:39:58 +0200194 int p;
195 struct poller *bp;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200196
Willy Tarreau7be79a42012-11-11 15:02:54 +0100197 if ((fd_spec = (uint32_t *)calloc(1, sizeof(uint32_t) * global.maxsock)) == NULL)
198 goto fail_spec;
199
200 if ((fd_updt = (uint32_t *)calloc(1, sizeof(uint32_t) * global.maxsock)) == NULL)
201 goto fail_updt;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200202
Willy Tarreau4f60f162007-04-08 16:39:58 +0200203 do {
204 bp = NULL;
205 for (p = 0; p < nbpollers; p++)
206 if (!bp || (pollers[p].pref > bp->pref))
207 bp = &pollers[p];
Willy Tarreaubaaee002006-06-26 02:48:02 +0200208
Willy Tarreau4f60f162007-04-08 16:39:58 +0200209 if (!bp || bp->pref == 0)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200210 break;
211
Willy Tarreau4f60f162007-04-08 16:39:58 +0200212 if (bp->init(bp)) {
213 memcpy(&cur_poller, bp, sizeof(*bp));
214 return 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200215 }
Willy Tarreau4f60f162007-04-08 16:39:58 +0200216 } while (!bp || bp->pref == 0);
217 return 0;
Willy Tarreau7be79a42012-11-11 15:02:54 +0100218
219 fail_updt:
220 free(fd_spec);
221 fail_spec:
222 return 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200223}
224
Willy Tarreaubaaee002006-06-26 02:48:02 +0200225/*
Krzysztof Piotr Oledzkia643baf2008-05-29 23:53:44 +0200226 * Deinitialize the pollers.
227 */
228void deinit_pollers() {
229
230 struct poller *bp;
231 int p;
232
233 for (p = 0; p < nbpollers; p++) {
234 bp = &pollers[p];
235
236 if (bp && bp->pref)
237 bp->term(bp);
238 }
Willy Tarreau7be79a42012-11-11 15:02:54 +0100239
240 free(fd_updt);
241 free(fd_spec);
242 fd_updt = NULL;
243 fd_spec = NULL;
Krzysztof Piotr Oledzkia643baf2008-05-29 23:53:44 +0200244}
245
246/*
Willy Tarreau2ff76222007-04-09 19:29:56 +0200247 * Lists the known pollers on <out>.
248 * Should be performed only before initialization.
249 */
250int list_pollers(FILE *out)
251{
252 int p;
253 int last, next;
254 int usable;
255 struct poller *bp;
256
257 fprintf(out, "Available polling systems :\n");
258
259 usable = 0;
260 bp = NULL;
261 last = next = -1;
262 while (1) {
263 for (p = 0; p < nbpollers; p++) {
Willy Tarreau2ff76222007-04-09 19:29:56 +0200264 if ((next < 0 || pollers[p].pref > next)
Willy Tarreaue79c3b22010-11-19 10:20:36 +0100265 && (last < 0 || pollers[p].pref < last)) {
Willy Tarreau2ff76222007-04-09 19:29:56 +0200266 next = pollers[p].pref;
Willy Tarreaue79c3b22010-11-19 10:20:36 +0100267 if (!bp || (pollers[p].pref > bp->pref))
268 bp = &pollers[p];
269 }
Willy Tarreau2ff76222007-04-09 19:29:56 +0200270 }
271
272 if (next == -1)
273 break;
274
275 for (p = 0; p < nbpollers; p++) {
276 if (pollers[p].pref == next) {
277 fprintf(out, " %10s : ", pollers[p].name);
278 if (pollers[p].pref == 0)
279 fprintf(out, "disabled, ");
280 else
281 fprintf(out, "pref=%3d, ", pollers[p].pref);
282 if (pollers[p].test(&pollers[p])) {
283 fprintf(out, " test result OK");
284 if (next > 0)
285 usable++;
Willy Tarreaue79c3b22010-11-19 10:20:36 +0100286 } else {
Willy Tarreau2ff76222007-04-09 19:29:56 +0200287 fprintf(out, " test result FAILED");
Willy Tarreaue79c3b22010-11-19 10:20:36 +0100288 if (bp == &pollers[p])
289 bp = NULL;
290 }
Willy Tarreau2ff76222007-04-09 19:29:56 +0200291 fprintf(out, "\n");
292 }
293 }
294 last = next;
295 next = -1;
296 };
297 fprintf(out, "Total: %d (%d usable), will use %s.\n", nbpollers, usable, bp ? bp->name : "none");
298 return 0;
299}
300
301/*
302 * Some pollers may lose their connection after a fork(). It may be necessary
303 * to create initialize part of them again. Returns 0 in case of failure,
304 * otherwise 1. The fork() function may be NULL if unused. In case of error,
305 * the the current poller is destroyed and the caller is responsible for trying
306 * another one by calling init_pollers() again.
307 */
308int fork_poller()
309{
310 if (cur_poller.fork) {
311 if (cur_poller.fork(&cur_poller))
312 return 1;
313 cur_poller.term(&cur_poller);
314 return 0;
315 }
316 return 1;
317}
318
319/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200320 * Local variables:
321 * c-indent-level: 8
322 * c-basic-offset: 8
323 * End:
324 */