mirror of
http://git.haproxy.org/git/haproxy.git/
synced 2024-12-11 14:05:12 +00:00
037d2c1f8f
At the moment sepoll is not 100% event-driven, because a call to fd_set() on an event which is already being polled will not change its state. This causes issues with OpenSSL because if some I/O processing is interrupted after clearing the I/O event (eg: read all data from a socket, can't put it all into the buffer), then there is no way to call the SSL_read() again once the buffer releases some space. The only real solution is to go 100% event-driven. The principle is to use the spec list as an event cache and that each time an I/O event is reported by epoll_wait(), this event is automatically scheduled for addition to the spec list for future calls until the consumer explicitly asks for polling or stopping. Doing this is a bit tricky because sepoll used to provide a substantial number of optimizations such as event merging. These optimizations have been maintained : a dedicated update list is affected when events change, but not the event list, so that updates may cancel themselves without any side effect such as displacing events. A specific case was considered for handling newly created FDs as soon as they are detected from within the poll loop. This ensures that their read or write operation will always be attempted as soon as possible, thus reducing the number of poll loops and process_session wakeups. This is especially true for newly accepted fds which immediately perform their first recv() call. Two new flags were added to the fdtab[] struct to tag the fact that a file descriptor already exists in the update list. One flag indicates that a file descriptor is new and has just been created (fdtab[].new) and the other one indicates that a file descriptor is already referenced by the update list (fdtab[].updated). Even if the FD state changes during operations or if the fd is closed and replaced, it's not an issue because the update flag remains and is easily spotted during list walks. The flag must absolutely reflect the presence of the fd in the update list in order to avoid overflowing the update list with more events than there are distinct fds. Note that this change also recovers the small performance loss introduced by its connection counter-part and goes even beyond.
129 lines
2.8 KiB
C
129 lines
2.8 KiB
C
/*
|
|
* include/proto/fd.h
|
|
* File descriptors states.
|
|
*
|
|
* Copyright (C) 2000-2012 Willy Tarreau - w@1wt.eu
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation, version 2.1
|
|
* exclusively.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#ifndef _PROTO_FD_H
|
|
#define _PROTO_FD_H
|
|
|
|
#include <stdio.h>
|
|
#include <sys/time.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
|
|
#include <common/config.h>
|
|
#include <types/fd.h>
|
|
|
|
/* Deletes an FD from the fdsets, and recomputes the maxfd limit.
|
|
* The file descriptor is also closed.
|
|
*/
|
|
void fd_delete(int fd);
|
|
|
|
/* disable the specified poller */
|
|
void disable_poller(const char *poller_name);
|
|
|
|
/*
|
|
* Initialize the pollers till the best one is found.
|
|
* If none works, returns 0, otherwise 1.
|
|
* The pollers register themselves just before main() is called.
|
|
*/
|
|
int init_pollers();
|
|
|
|
/*
|
|
* Deinitialize the pollers.
|
|
*/
|
|
void deinit_pollers();
|
|
|
|
/*
|
|
* Some pollers may lose their connection after a fork(). It may be necessary
|
|
* to create initialize part of them again. Returns 0 in case of failure,
|
|
* otherwise 1. The fork() function may be NULL if unused. In case of error,
|
|
* the the current poller is destroyed and the caller is responsible for trying
|
|
* another one by calling init_pollers() again.
|
|
*/
|
|
int fork_poller();
|
|
|
|
/*
|
|
* Lists the known pollers on <out>.
|
|
* Should be performed only before initialization.
|
|
*/
|
|
int list_pollers(FILE *out);
|
|
|
|
/*
|
|
* Runs the polling loop
|
|
*/
|
|
void run_poller();
|
|
|
|
#define EV_FD_ISSET(fd, ev) (cur_poller.is_set((fd), (ev)))
|
|
|
|
/* event manipulation primitives for use by I/O callbacks */
|
|
static inline void fd_want_recv(int fd)
|
|
{
|
|
cur_poller.set(fd, DIR_RD);
|
|
}
|
|
|
|
static inline void fd_stop_recv(int fd)
|
|
{
|
|
cur_poller.clr(fd, DIR_RD);
|
|
}
|
|
|
|
static inline void fd_poll_recv(int fd)
|
|
{
|
|
cur_poller.wai(fd, DIR_RD);
|
|
}
|
|
|
|
static inline void fd_want_send(int fd)
|
|
{
|
|
cur_poller.set(fd, DIR_WR);
|
|
}
|
|
|
|
static inline void fd_stop_send(int fd)
|
|
{
|
|
cur_poller.clr(fd, DIR_WR);
|
|
}
|
|
|
|
static inline void fd_poll_send(int fd)
|
|
{
|
|
cur_poller.wai(fd, DIR_WR);
|
|
}
|
|
|
|
static inline void fd_stop_both(int fd)
|
|
{
|
|
cur_poller.rem(fd);
|
|
}
|
|
|
|
/* Prepares <fd> for being polled */
|
|
static inline void fd_insert(int fd)
|
|
{
|
|
fdtab[fd].ev = 0;
|
|
fdtab[fd].new = 1;
|
|
if (fd + 1 > maxfd)
|
|
maxfd = fd + 1;
|
|
}
|
|
|
|
|
|
#endif /* _PROTO_FD_H */
|
|
|
|
/*
|
|
* Local variables:
|
|
* c-indent-level: 8
|
|
* c-basic-offset: 8
|
|
* End:
|
|
*/
|