RepoMirrors/haproxy
1
0
Fork 0
mirror of http://git.haproxy.org/git/haproxy.git/ synced 2025-01-03 02:32:03 +00:00
Code Issues Packages Projects Releases Wiki Activity
efc46dede9
haproxy/src/sock.c

1063 lines
29 KiB
C
Raw Normal View History

REORG: sock: start to move some generic socket code to sock.c The new file sock.c will contain generic code for standard sockets relying on file descriptors. We currently have way too much duplication between proto_uxst, proto_tcp, proto_sockpair and proto_udp. For now only get_src, get_dst and sock_create_server_socket were moved, and are used where appropriate.
2020-08-28 10:07:22 +00:00
/*
* Generic code for native (BSD-compatible) sockets
*
* Copyright 2000-2020 Willy Tarreau <w@1wt.eu>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.
*
*/
MINOR: sock: implement sock_accept_conn() to accept a connection The socket-specific accept() code in listener_accept() has nothing to do there. Let's move it to sock.c where it can be significantly cleaned up. It will now directly return an accepted connection and provide a status code instead of letting listener_accept() deal with various errno values. Note that this doesn't support the sockpair specific code. The function is now responsible for dealing with its own receiver's polling state and calling fd_cant_recv() when facing EAGAIN. One tiny change from the previous implementation is that the connection's sockaddr is now allocated before trying accept(), which saves a memcpy() of the resulting address for each accept at the expense of a cheap pool_alloc/pool_free on the final accept returning EAGAIN. This still apparently slightly improves accept performance in microbencharks.
2020-10-15 07:21:31 +00:00
#define _GNU_SOURCE
REORG: sock: start to move some generic socket code to sock.c The new file sock.c will contain generic code for standard sockets relying on file descriptors. We currently have way too much duplication between proto_uxst, proto_tcp, proto_sockpair and proto_udp. For now only get_src, get_dst and sock_create_server_socket were moved, and are used where appropriate.
2020-08-28 10:07:22 +00:00
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <sys/param.h>
#include <sys/socket.h>
#include <sys/types.h>
REORG: sock: move get_old_sockets() from haproxy.c The new function was called sock_get_old_sockets() and was left as-is except a minimum amount of style lifting to make it more readable. It will never be awesome anyway since it's used very early in the boot sequence and needs to perform socket I/O without any external help.
2020-08-28 16:42:45 +00:00
#include <net/if.h>
REORG: sock: start to move some generic socket code to sock.c The new file sock.c will contain generic code for standard sockets relying on file descriptors. We currently have way too much duplication between proto_uxst, proto_tcp, proto_sockpair and proto_udp. For now only get_src, get_dst and sock_create_server_socket were moved, and are used where appropriate.
2020-08-28 10:07:22 +00:00
#include <haproxy/api.h>
BUILD: tree-wide: add several missing activity.h A number of files currently access activity counters but rely on their definitions to be inherited from other files (task.c, backend.c hlua.c, sock.c, pool.c, stats.c, fd.c).
2021-10-06 17:54:09 +00:00
#include <haproxy/activity.h>
REORG: sock: start to move some generic socket code to sock.c The new file sock.c will contain generic code for standard sockets relying on file descriptors. We currently have way too much duplication between proto_uxst, proto_tcp, proto_sockpair and proto_udp. For now only get_src, get_dst and sock_create_server_socket were moved, and are used where appropriate.
2020-08-28 10:07:22 +00:00
#include <haproxy/connection.h>
MINOR: protocol: register the receiver's I/O handler and not the protocol's Now we define a new sock_accept_iocb() for socket-based stream protocols and use it as a wrapper for listener_accept() which now takes a listener and not an FD anymore. This will allow the receiver's I/O cb to be redefined during registration, and more specifically to get rid of the hard-coded hacks in protocol_bind_all() made for syslog. The previous ->accept() callback in the protocol was removed since it doesn't have anything to do with accept() anymore but is more generic. A few places where listener_accept() was compared against the FD's IO callback for debugging purposes on the CLI were updated.
2020-10-15 19:29:49 +00:00
#include <haproxy/listener.h>
MINOR: sock: implement sock_accept_conn() to accept a connection The socket-specific accept() code in listener_accept() has nothing to do there. Let's move it to sock.c where it can be significantly cleaned up. It will now directly return an accepted connection and provide a status code instead of letting listener_accept() deal with various errno values. Note that this doesn't support the sockpair specific code. The function is now responsible for dealing with its own receiver's polling state and calling fd_cant_recv() when facing EAGAIN. One tiny change from the previous implementation is that the connection's sockaddr is now allocated before trying accept(), which saves a memcpy() of the resulting address for each accept at the expense of a cheap pool_alloc/pool_free on the final accept returning EAGAIN. This still apparently slightly improves accept performance in microbencharks.
2020-10-15 07:21:31 +00:00
#include <haproxy/log.h>
REORG: sock: start to move some generic socket code to sock.c The new file sock.c will contain generic code for standard sockets relying on file descriptors. We currently have way too much duplication between proto_uxst, proto_tcp, proto_sockpair and proto_udp. For now only get_src, get_dst and sock_create_server_socket were moved, and are used where appropriate.
2020-08-28 10:07:22 +00:00
#include <haproxy/namespace.h>
MEDIUM: mworker: seamless reload use the internal sockpairs With the master worker, the seamless reload was still requiring an external stats socket to the previous process, which is a pain to configure. This patch implements a way to use the internal socketpair between the master and the workers to transfer the sockets during the reload. This way, the master will always try to transfer the socket, even without any configuration. The master will still reload with the -x argument, followed by the sockpair@ syntax. ( ex -x sockpair@4 ). Which use the FD of internal CLI to the worker.
2021-11-24 17:45:37 +00:00
#include <haproxy/proto_sockpair.h>
REORG: sock: start to move some generic socket code to sock.c The new file sock.c will contain generic code for standard sockets relying on file descriptors. We currently have way too much duplication between proto_uxst, proto_tcp, proto_sockpair and proto_udp. For now only get_src, get_dst and sock_create_server_socket were moved, and are used where appropriate.
2020-08-28 10:07:22 +00:00
#include <haproxy/sock.h>
MINOR: sock: implement sock_find_compatible_fd() This is essentially a merge from tcp_find_compatible_fd() and uxst_find_compatible_fd() that relies on a listener's address and compare function and still checks for other variations. For AF_INET6 it compares a few of the listener's bind options. A minor change for UNIX sockets is that transparent mode, interface and namespace used to be ignored when trying to pick a previous socket while now if they are changed, the socket will not be reused. This could be refined but it's still better this way as there is no more risk of using a differently bound socket by accident. Eventually we should not pass a listener there but a set of binding parameters (address, interface, namespace etc...) which ultimately will be grouped into a receiver. For now this still doesn't exist so let's stick to the listener to break dependencies in the rest of the code.
2020-08-28 14:49:41 +00:00
#include <haproxy/sock_inet.h>
REORG: sock: start to move some generic socket code to sock.c The new file sock.c will contain generic code for standard sockets relying on file descriptors. We currently have way too much duplication between proto_uxst, proto_tcp, proto_sockpair and proto_udp. For now only get_src, get_dst and sock_create_server_socket were moved, and are used where appropriate.
2020-08-28 10:07:22 +00:00
#include <haproxy/tools.h>
MINOR: sock: move the unused socket cleaning code into its own function The startup code used to scan the list of unused sockets retrieved from an older process, and to close them one by one. This also required that the knowledge of the internal storage of these temporary sockets was known from outside sock.c and that the code was copy-pasted at every call place. This patch moves this into sock.c under the name sock_drop_unused_old_sockets(), and removes the xfer_sock_list definition from sock.h since the rest of the code doesn't need to know this. This cleanup is minimal and preliminary to a future fix that will need to be backported to all versions featuring FD transfers over the CLI.
2022-01-28 17:28:18 +00:00
#define SOCK_XFER_OPT_FOREIGN 0x000000001
#define SOCK_XFER_OPT_V6ONLY 0x000000002
#define SOCK_XFER_OPT_DGRAM 0x000000004
REORG: listener: move xfer_sock_list to sock.{c,h}. This will be used for receivers as well thus it is not specific to listeners but to sockets.
2020-08-28 14:29:53 +00:00
/* the list of remaining sockets transferred from an older process */
MINOR: sock: move the unused socket cleaning code into its own function The startup code used to scan the list of unused sockets retrieved from an older process, and to close them one by one. This also required that the knowledge of the internal storage of these temporary sockets was known from outside sock.c and that the code was copy-pasted at every call place. This patch moves this into sock.c under the name sock_drop_unused_old_sockets(), and removes the xfer_sock_list definition from sock.h since the rest of the code doesn't need to know this. This cleanup is minimal and preliminary to a future fix that will need to be backported to all versions featuring FD transfers over the CLI.
2022-01-28 17:28:18 +00:00
struct xfer_sock_list {
int fd;
int options; /* socket options as SOCK_XFER_OPT_* */
char *iface;
char *namespace;
int if_namelen;
int ns_namelen;
struct xfer_sock_list *prev;
struct xfer_sock_list *next;
struct sockaddr_storage addr;
};
static struct xfer_sock_list *xfer_sock_list;
REORG: sock: start to move some generic socket code to sock.c The new file sock.c will contain generic code for standard sockets relying on file descriptors. We currently have way too much duplication between proto_uxst, proto_tcp, proto_sockpair and proto_udp. For now only get_src, get_dst and sock_create_server_socket were moved, and are used where appropriate.
2020-08-28 10:07:22 +00:00
MINOR: sock: implement sock_accept_conn() to accept a connection The socket-specific accept() code in listener_accept() has nothing to do there. Let's move it to sock.c where it can be significantly cleaned up. It will now directly return an accepted connection and provide a status code instead of letting listener_accept() deal with various errno values. Note that this doesn't support the sockpair specific code. The function is now responsible for dealing with its own receiver's polling state and calling fd_cant_recv() when facing EAGAIN. One tiny change from the previous implementation is that the connection's sockaddr is now allocated before trying accept(), which saves a memcpy() of the resulting address for each accept at the expense of a cheap pool_alloc/pool_free on the final accept returning EAGAIN. This still apparently slightly improves accept performance in microbencharks.
2020-10-15 07:21:31 +00:00
/* Accept an incoming connection from listener <l>, and return it, as well as
* a CO_AC_* status code into <status> if not null. Null is returned on error.
* <l> must be a valid listener with a valid frontend.
*/
struct connection *sock_accept_conn(struct listener *l, int *status)
{
#ifdef USE_ACCEPT4
static int accept4_broken;
#endif
struct proxy *p = l->bind_conf->frontend;
MINOR: sockpair: implement sockpair_accept_conn() to accept a connection This is the same as previous commit, but this time for the sockpair- specific stuff, relying on recv_fd_uxst() instead of accept(), so the code is simpler. The various errno cases are handled like for regular sockets, though some of them will probably never happen, but this does not hurt.
2020-10-15 07:43:31 +00:00
struct connection *conn = NULL;
struct sockaddr_storage *addr = NULL;
MINOR: sock: implement sock_accept_conn() to accept a connection The socket-specific accept() code in listener_accept() has nothing to do there. Let's move it to sock.c where it can be significantly cleaned up. It will now directly return an accepted connection and provide a status code instead of letting listener_accept() deal with various errno values. Note that this doesn't support the sockpair specific code. The function is now responsible for dealing with its own receiver's polling state and calling fd_cant_recv() when facing EAGAIN. One tiny change from the previous implementation is that the connection's sockaddr is now allocated before trying accept(), which saves a memcpy() of the resulting address for each accept at the expense of a cheap pool_alloc/pool_free on the final accept returning EAGAIN. This still apparently slightly improves accept performance in microbencharks.
2020-10-15 07:21:31 +00:00
socklen_t laddr;
int ret;
int cfd;
MINOR: sockpair: implement sockpair_accept_conn() to accept a connection This is the same as previous commit, but this time for the sockpair- specific stuff, relying on recv_fd_uxst() instead of accept(), so the code is simpler. The various errno cases are handled like for regular sockets, though some of them will probably never happen, but this does not hurt.
2020-10-15 07:43:31 +00:00
if (!sockaddr_alloc(&addr, NULL, 0))
MINOR: sock: implement sock_accept_conn() to accept a connection The socket-specific accept() code in listener_accept() has nothing to do there. Let's move it to sock.c where it can be significantly cleaned up. It will now directly return an accepted connection and provide a status code instead of letting listener_accept() deal with various errno values. Note that this doesn't support the sockpair specific code. The function is now responsible for dealing with its own receiver's polling state and calling fd_cant_recv() when facing EAGAIN. One tiny change from the previous implementation is that the connection's sockaddr is now allocated before trying accept(), which saves a memcpy() of the resulting address for each accept at the expense of a cheap pool_alloc/pool_free on the final accept returning EAGAIN. This still apparently slightly improves accept performance in microbencharks.
2020-10-15 07:21:31 +00:00
goto fail_addr;
/* accept() will mark all accepted FDs O_NONBLOCK and the ones accepted
* in the master process as FD_CLOEXEC. It's not done for workers
* because 1) workers are not supposed to execute anything so there's
* no reason for uselessly slowing down everything, and 2) that would
* prevent us from implementing fd passing in the future.
*/
#ifdef USE_ACCEPT4
laddr = sizeof(*conn->src);
/* only call accept4() if it's known to be safe, otherwise fallback to
* the legacy accept() + fcntl().
*/
if (unlikely(accept4_broken) ||
MINOR: sockpair: implement sockpair_accept_conn() to accept a connection This is the same as previous commit, but this time for the sockpair- specific stuff, relying on recv_fd_uxst() instead of accept(), so the code is simpler. The various errno cases are handled like for regular sockets, though some of them will probably never happen, but this does not hurt.
2020-10-15 07:43:31 +00:00
(((cfd = accept4(l->rx.fd, (struct sockaddr*)addr, &laddr,
MINOR: sock: implement sock_accept_conn() to accept a connection The socket-specific accept() code in listener_accept() has nothing to do there. Let's move it to sock.c where it can be significantly cleaned up. It will now directly return an accepted connection and provide a status code instead of letting listener_accept() deal with various errno values. Note that this doesn't support the sockpair specific code. The function is now responsible for dealing with its own receiver's polling state and calling fd_cant_recv() when facing EAGAIN. One tiny change from the previous implementation is that the connection's sockaddr is now allocated before trying accept(), which saves a memcpy() of the resulting address for each accept at the expense of a cheap pool_alloc/pool_free on the final accept returning EAGAIN. This still apparently slightly improves accept performance in microbencharks.
2020-10-15 07:21:31 +00:00
SOCK_NONBLOCK | (master ? SOCK_CLOEXEC : 0))) == -1) &&
(errno == ENOSYS || errno == EINVAL || errno == EBADF) &&
CLEANUP: sock: Wrap `accept4_broken = 1` into additional parenthesis This makes it clear to static analysis tools that this assignment is intentional and not a mistyped comparison.
2021-11-20 13:39:47 +00:00
((accept4_broken = 1))))
MINOR: sock: implement sock_accept_conn() to accept a connection The socket-specific accept() code in listener_accept() has nothing to do there. Let's move it to sock.c where it can be significantly cleaned up. It will now directly return an accepted connection and provide a status code instead of letting listener_accept() deal with various errno values. Note that this doesn't support the sockpair specific code. The function is now responsible for dealing with its own receiver's polling state and calling fd_cant_recv() when facing EAGAIN. One tiny change from the previous implementation is that the connection's sockaddr is now allocated before trying accept(), which saves a memcpy() of the resulting address for each accept at the expense of a cheap pool_alloc/pool_free on the final accept returning EAGAIN. This still apparently slightly improves accept performance in microbencharks.
2020-10-15 07:21:31 +00:00
#endif
{
laddr = sizeof(*conn->src);
MINOR: sockpair: implement sockpair_accept_conn() to accept a connection This is the same as previous commit, but this time for the sockpair- specific stuff, relying on recv_fd_uxst() instead of accept(), so the code is simpler. The various errno cases are handled like for regular sockets, though some of them will probably never happen, but this does not hurt.
2020-10-15 07:43:31 +00:00
if ((cfd = accept(l->rx.fd, (struct sockaddr*)addr, &laddr)) != -1) {
CLEANUP: tree-wide: use fd_set_nonblock() and fd_set_cloexec() This gets rid of most open-coded fcntl() calls, some of which were passed through DISGUISE() to avoid a useless test. The FD_CLOEXEC was most often set without preserving previous flags, which could become a problem once new flags are created. Now this will not happen anymore.
2022-04-26 08:24:14 +00:00
fd_set_nonblock(cfd);
MINOR: sock: implement sock_accept_conn() to accept a connection The socket-specific accept() code in listener_accept() has nothing to do there. Let's move it to sock.c where it can be significantly cleaned up. It will now directly return an accepted connection and provide a status code instead of letting listener_accept() deal with various errno values. Note that this doesn't support the sockpair specific code. The function is now responsible for dealing with its own receiver's polling state and calling fd_cant_recv() when facing EAGAIN. One tiny change from the previous implementation is that the connection's sockaddr is now allocated before trying accept(), which saves a memcpy() of the resulting address for each accept at the expense of a cheap pool_alloc/pool_free on the final accept returning EAGAIN. This still apparently slightly improves accept performance in microbencharks.
2020-10-15 07:21:31 +00:00
if (master)
CLEANUP: tree-wide: use fd_set_nonblock() and fd_set_cloexec() This gets rid of most open-coded fcntl() calls, some of which were passed through DISGUISE() to avoid a useless test. The FD_CLOEXEC was most often set without preserving previous flags, which could become a problem once new flags are created. Now this will not happen anymore.
2022-04-26 08:24:14 +00:00
fd_set_cloexec(cfd);
MINOR: sock: implement sock_accept_conn() to accept a connection The socket-specific accept() code in listener_accept() has nothing to do there. Let's move it to sock.c where it can be significantly cleaned up. It will now directly return an accepted connection and provide a status code instead of letting listener_accept() deal with various errno values. Note that this doesn't support the sockpair specific code. The function is now responsible for dealing with its own receiver's polling state and calling fd_cant_recv() when facing EAGAIN. One tiny change from the previous implementation is that the connection's sockaddr is now allocated before trying accept(), which saves a memcpy() of the resulting address for each accept at the expense of a cheap pool_alloc/pool_free on the final accept returning EAGAIN. This still apparently slightly improves accept performance in microbencharks.
2020-10-15 07:21:31 +00:00
}
}
if (likely(cfd != -1)) {
MINOR: sock: check configured limits at the sock layer, not the listener's listener_accept() used to continue to enforce the FD limits relative to global.maxsock by itself while it's the last FD-specific test in the whole file. This test has nothing to do there, it ought to be placed in sock_accept_conn() which is the one in charge of FD allocation and tests. Similar tests are already located there by the way. The only tiny difference is that listener_accept() used to pause for one second when this limit was reached, while other similar conditions were pausing only 100ms, so now the same 100ms will apply. But that's not important and could even be considered as an improvement.
2022-04-11 13:01:37 +00:00
if (unlikely(cfd >= global.maxsock)) {
send_log(p, LOG_EMERG,
"Proxy %s reached the configured maximum connection limit. Please check the global 'maxconn' value.\n",
p->id);
goto fail_conn;
}
MINOR: sock: implement sock_accept_conn() to accept a connection The socket-specific accept() code in listener_accept() has nothing to do there. Let's move it to sock.c where it can be significantly cleaned up. It will now directly return an accepted connection and provide a status code instead of letting listener_accept() deal with various errno values. Note that this doesn't support the sockpair specific code. The function is now responsible for dealing with its own receiver's polling state and calling fd_cant_recv() when facing EAGAIN. One tiny change from the previous implementation is that the connection's sockaddr is now allocated before trying accept(), which saves a memcpy() of the resulting address for each accept at the expense of a cheap pool_alloc/pool_free on the final accept returning EAGAIN. This still apparently slightly improves accept performance in microbencharks.
2020-10-15 07:21:31 +00:00
/* Perfect, the connection was accepted */
MINOR: sockpair: implement sockpair_accept_conn() to accept a connection This is the same as previous commit, but this time for the sockpair- specific stuff, relying on recv_fd_uxst() instead of accept(), so the code is simpler. The various errno cases are handled like for regular sockets, though some of them will probably never happen, but this does not hurt.
2020-10-15 07:43:31 +00:00
conn = conn_new(&l->obj_type);
if (!conn)
goto fail_conn;
conn->src = addr;
MINOR: sock: implement sock_accept_conn() to accept a connection The socket-specific accept() code in listener_accept() has nothing to do there. Let's move it to sock.c where it can be significantly cleaned up. It will now directly return an accepted connection and provide a status code instead of letting listener_accept() deal with various errno values. Note that this doesn't support the sockpair specific code. The function is now responsible for dealing with its own receiver's polling state and calling fd_cant_recv() when facing EAGAIN. One tiny change from the previous implementation is that the connection's sockaddr is now allocated before trying accept(), which saves a memcpy() of the resulting address for each accept at the expense of a cheap pool_alloc/pool_free on the final accept returning EAGAIN. This still apparently slightly improves accept performance in microbencharks.
2020-10-15 07:21:31 +00:00
conn->handle.fd = cfd;
ret = CO_AC_DONE;
goto done;
}
/* error conditions below */
MINOR: sockpair: implement sockpair_accept_conn() to accept a connection This is the same as previous commit, but this time for the sockpair- specific stuff, relying on recv_fd_uxst() instead of accept(), so the code is simpler. The various errno cases are handled like for regular sockets, though some of them will probably never happen, but this does not hurt.
2020-10-15 07:43:31 +00:00
sockaddr_free(&addr);
MINOR: sock: implement sock_accept_conn() to accept a connection The socket-specific accept() code in listener_accept() has nothing to do there. Let's move it to sock.c where it can be significantly cleaned up. It will now directly return an accepted connection and provide a status code instead of letting listener_accept() deal with various errno values. Note that this doesn't support the sockpair specific code. The function is now responsible for dealing with its own receiver's polling state and calling fd_cant_recv() when facing EAGAIN. One tiny change from the previous implementation is that the connection's sockaddr is now allocated before trying accept(), which saves a memcpy() of the resulting address for each accept at the expense of a cheap pool_alloc/pool_free on the final accept returning EAGAIN. This still apparently slightly improves accept performance in microbencharks.
2020-10-15 07:21:31 +00:00
switch (errno) {
MINOR: tree-wide: always consider EWOULDBLOCK in addition to EAGAIN Some older systems may routinely return EWOULDBLOCK for some syscalls while we tend to check only for EAGAIN nowadays. Modern systems define EWOULDBLOCK as EAGAIN so that solves it, but on a few older ones (AIX, VMS etc) both are different, and for portability we'd need to test for both or we never know if we risk to confuse some status codes with plain errors. There were few entries, the most annoying ones are the switch/case because they require to only add the entry when it differs, but the other ones are really trivial.
2022-04-25 18:32:15 +00:00
#if defined(EWOULDBLOCK) && defined(EAGAIN) && EWOULDBLOCK != EAGAIN
case EWOULDBLOCK:
#endif
MINOR: sock: implement sock_accept_conn() to accept a connection The socket-specific accept() code in listener_accept() has nothing to do there. Let's move it to sock.c where it can be significantly cleaned up. It will now directly return an accepted connection and provide a status code instead of letting listener_accept() deal with various errno values. Note that this doesn't support the sockpair specific code. The function is now responsible for dealing with its own receiver's polling state and calling fd_cant_recv() when facing EAGAIN. One tiny change from the previous implementation is that the connection's sockaddr is now allocated before trying accept(), which saves a memcpy() of the resulting address for each accept at the expense of a cheap pool_alloc/pool_free on the final accept returning EAGAIN. This still apparently slightly improves accept performance in microbencharks.
2020-10-15 07:21:31 +00:00
case EAGAIN:
ret = CO_AC_DONE; /* nothing more to accept */
MEDIUM: fd: merge fdtab[].ev and state for FD_EV_* and FD_POLL_* into state For a long time we've had fdtab[].ev and fdtab[].state which contain two arbitrary sets of information, one is mostly the configuration plus some shutdown reports and the other one is the latest polling status report which also contains some sticky error and shutdown reports. These ones used to be stored into distinct chars, complicating certain operations and not even allowing to clearly see concurrent accesses (e.g. fd_delete_orphan() would set the state to zero while fd_insert() would only set the event to zero). This patch creates a single uint with the two sets in it, still delimited at the byte level for better readability. The original FD_EV_* values remained at the lowest bit levels as they are also known by their bit value. The next step will consist in merging the remaining bits into it. The whole bits are now cleared both in fd_insert() and _fd_delete_orphan() because after a complete check, it is certain that in both cases these functions are the only ones touching these areas. Indeed, for _fd_delete_orphan(), the thread_mask has already been zeroed before a poller can call fd_update_event() which would touch the state, so it is certain that _fd_delete_orphan() is alone. Regarding fd_insert(), only one thread will get an FD at any moment, and it as this FD has already been released by _fd_delete_orphan() by definition it is certain that previous users have definitely stopped touching it. Strictly speaking there's no need for clearing the state again in fd_insert() but it's cheap and will remove some doubts during some troubleshooting sessions.
2021-04-06 15:23:40 +00:00
if (fdtab[l->rx.fd].state & (FD_POLL_HUP|FD_POLL_ERR)) {
MINOR: sock: implement sock_accept_conn() to accept a connection The socket-specific accept() code in listener_accept() has nothing to do there. Let's move it to sock.c where it can be significantly cleaned up. It will now directly return an accepted connection and provide a status code instead of letting listener_accept() deal with various errno values. Note that this doesn't support the sockpair specific code. The function is now responsible for dealing with its own receiver's polling state and calling fd_cant_recv() when facing EAGAIN. One tiny change from the previous implementation is that the connection's sockaddr is now allocated before trying accept(), which saves a memcpy() of the resulting address for each accept at the expense of a cheap pool_alloc/pool_free on the final accept returning EAGAIN. This still apparently slightly improves accept performance in microbencharks.
2020-10-15 07:21:31 +00:00
/* the listening socket might have been disabled in a shared
* process and we're a collateral victim. We'll just pause for
* a while in case it comes back. In the mean time, we need to
* clear this sticky flag.
*/
MEDIUM: fd: merge fdtab[].ev and state for FD_EV_* and FD_POLL_* into state For a long time we've had fdtab[].ev and fdtab[].state which contain two arbitrary sets of information, one is mostly the configuration plus some shutdown reports and the other one is the latest polling status report which also contains some sticky error and shutdown reports. These ones used to be stored into distinct chars, complicating certain operations and not even allowing to clearly see concurrent accesses (e.g. fd_delete_orphan() would set the state to zero while fd_insert() would only set the event to zero). This patch creates a single uint with the two sets in it, still delimited at the byte level for better readability. The original FD_EV_* values remained at the lowest bit levels as they are also known by their bit value. The next step will consist in merging the remaining bits into it. The whole bits are now cleared both in fd_insert() and _fd_delete_orphan() because after a complete check, it is certain that in both cases these functions are the only ones touching these areas. Indeed, for _fd_delete_orphan(), the thread_mask has already been zeroed before a poller can call fd_update_event() which would touch the state, so it is certain that _fd_delete_orphan() is alone. Regarding fd_insert(), only one thread will get an FD at any moment, and it as this FD has already been released by _fd_delete_orphan() by definition it is certain that previous users have definitely stopped touching it. Strictly speaking there's no need for clearing the state again in fd_insert() but it's cheap and will remove some doubts during some troubleshooting sessions.
2021-04-06 15:23:40 +00:00
_HA_ATOMIC_AND(&fdtab[l->rx.fd].state, ~(FD_POLL_HUP|FD_POLL_ERR));
MINOR: sock: implement sock_accept_conn() to accept a connection The socket-specific accept() code in listener_accept() has nothing to do there. Let's move it to sock.c where it can be significantly cleaned up. It will now directly return an accepted connection and provide a status code instead of letting listener_accept() deal with various errno values. Note that this doesn't support the sockpair specific code. The function is now responsible for dealing with its own receiver's polling state and calling fd_cant_recv() when facing EAGAIN. One tiny change from the previous implementation is that the connection's sockaddr is now allocated before trying accept(), which saves a memcpy() of the resulting address for each accept at the expense of a cheap pool_alloc/pool_free on the final accept returning EAGAIN. This still apparently slightly improves accept performance in microbencharks.
2020-10-15 07:21:31 +00:00
ret = CO_AC_PAUSE;
}
fd_cant_recv(l->rx.fd);
break;
case EINVAL:
/* might be trying to accept on a shut fd (eg: soft stop) */
ret = CO_AC_PAUSE;
break;
case EINTR:
case ECONNABORTED:
ret = CO_AC_RETRY;
break;
case ENFILE:
if (p)
send_log(p, LOG_EMERG,
"Proxy %s reached system FD limit (maxsock=%d). Please check system tunables.\n",
p->id, global.maxsock);
ret = CO_AC_PAUSE;
break;
case EMFILE:
if (p)
send_log(p, LOG_EMERG,
"Proxy %s reached process FD limit (maxsock=%d). Please check 'ulimit-n' and restart.\n",
p->id, global.maxsock);
ret = CO_AC_PAUSE;
break;
case ENOBUFS:
case ENOMEM:
if (p)
send_log(p, LOG_EMERG,
"Proxy %s reached system memory limit (maxsock=%d). Please check system tunables.\n",
p->id, global.maxsock);
ret = CO_AC_PAUSE;
break;
default:
/* unexpected result, let's give up and let other tasks run */
ret = CO_AC_YIELD;
}
done:
if (status)
*status = ret;
return conn;
fail_conn:
MINOR: sockpair: implement sockpair_accept_conn() to accept a connection This is the same as previous commit, but this time for the sockpair- specific stuff, relying on recv_fd_uxst() instead of accept(), so the code is simpler. The various errno cases are handled like for regular sockets, though some of them will probably never happen, but this does not hurt.
2020-10-15 07:43:31 +00:00
sockaddr_free(&addr);
BUG/MINOR: sock: Unclosed fd in case of connection allocation failure If allocating a connection object failed right after a successful accept on a listener, the new file descriptor was not properly closed. This fixes GitHub issue #905. It can be backported to 2.3.
2021-01-14 14:26:24 +00:00
/* The accept call already succeeded by the time we try to allocate the connection,
* we need to close it in case of failure. */
close(cfd);
MINOR: sockpair: implement sockpair_accept_conn() to accept a connection This is the same as previous commit, but this time for the sockpair- specific stuff, relying on recv_fd_uxst() instead of accept(), so the code is simpler. The various errno cases are handled like for regular sockets, though some of them will probably never happen, but this does not hurt.
2020-10-15 07:43:31 +00:00
fail_addr:
MINOR: sock: implement sock_accept_conn() to accept a connection The socket-specific accept() code in listener_accept() has nothing to do there. Let's move it to sock.c where it can be significantly cleaned up. It will now directly return an accepted connection and provide a status code instead of letting listener_accept() deal with various errno values. Note that this doesn't support the sockpair specific code. The function is now responsible for dealing with its own receiver's polling state and calling fd_cant_recv() when facing EAGAIN. One tiny change from the previous implementation is that the connection's sockaddr is now allocated before trying accept(), which saves a memcpy() of the resulting address for each accept at the expense of a cheap pool_alloc/pool_free on the final accept returning EAGAIN. This still apparently slightly improves accept performance in microbencharks.
2020-10-15 07:21:31 +00:00
ret = CO_AC_PAUSE;
goto done;
}
REORG: sock: start to move some generic socket code to sock.c The new file sock.c will contain generic code for standard sockets relying on file descriptors. We currently have way too much duplication between proto_uxst, proto_tcp, proto_sockpair and proto_udp. For now only get_src, get_dst and sock_create_server_socket were moved, and are used where appropriate.
2020-08-28 10:07:22 +00:00
/* Create a socket to connect to the server in conn->dst (which MUST be valid),
* using the configured namespace if needed, or the one passed by the proxy
* protocol if required to do so. It ultimately calls socket() or socketat()
* and returns the FD or error code.
*/
int sock_create_server_socket(struct connection *conn)
{
const struct netns_entry *ns = NULL;
#ifdef USE_NS
if (objt_server(conn->target)) {
if (__objt_server(conn->target)->flags & SRV_F_USE_NS_FROM_PP)
ns = conn->proxy_netns;
else
ns = __objt_server(conn->target)->netns;
}
#endif
return my_socketat(ns, conn->dst->ss_family, SOCK_STREAM, 0);
}
MEDIUM: listeners: make use of fd_want_recv_safe() to enable early receivers We used to refrain from calling fd_want_recv() if fd_updt was not allocated but it's not the right solution as this does not allow the FD to be set. Instead, let's use the new fd_want_recv_safe() which will update the FD and create an update entry only if possible. In addition, the equivalent test before calling fd_stop_recv() was removed as totally useless since there's not fd_updt creation in this case.
2020-11-04 12:59:04 +00:00
/* Enables receiving on receiver <rx> once already bound. */
MINOR: sock: provide a set of generic enable/disable functions These will be used on receivers, to enable or disable receiving on a listener, which most of the time just consists in enabling/disabling the file descriptor. We have to take care of the existence of fd_updt to know if we may or not call fd_{want,stop}_recv() since it's not permitted in very early boot.
2020-09-25 17:00:01 +00:00
void sock_enable(struct receiver *rx)
{
MEDIUM: listeners: make use of fd_want_recv_safe() to enable early receivers We used to refrain from calling fd_want_recv() if fd_updt was not allocated but it's not the right solution as this does not allow the FD to be set. Instead, let's use the new fd_want_recv_safe() which will update the FD and create an update entry only if possible. In addition, the equivalent test before calling fd_stop_recv() was removed as totally useless since there's not fd_updt creation in this case.
2020-11-04 12:59:04 +00:00
if (rx->flags & RX_F_BOUND)
fd_want_recv_safe(rx->fd);
MINOR: sock: provide a set of generic enable/disable functions These will be used on receivers, to enable or disable receiving on a listener, which most of the time just consists in enabling/disabling the file descriptor. We have to take care of the existence of fd_updt to know if we may or not call fd_{want,stop}_recv() since it's not permitted in very early boot.
2020-09-25 17:00:01 +00:00
}
MEDIUM: listeners: make use of fd_want_recv_safe() to enable early receivers We used to refrain from calling fd_want_recv() if fd_updt was not allocated but it's not the right solution as this does not allow the FD to be set. Instead, let's use the new fd_want_recv_safe() which will update the FD and create an update entry only if possible. In addition, the equivalent test before calling fd_stop_recv() was removed as totally useless since there's not fd_updt creation in this case.
2020-11-04 12:59:04 +00:00
/* Disables receiving on receiver <rx> once already bound. */
MINOR: sock: provide a set of generic enable/disable functions These will be used on receivers, to enable or disable receiving on a listener, which most of the time just consists in enabling/disabling the file descriptor. We have to take care of the existence of fd_updt to know if we may or not call fd_{want,stop}_recv() since it's not permitted in very early boot.
2020-09-25 17:00:01 +00:00
void sock_disable(struct receiver *rx)
{
MEDIUM: listeners: make use of fd_want_recv_safe() to enable early receivers We used to refrain from calling fd_want_recv() if fd_updt was not allocated but it's not the right solution as this does not allow the FD to be set. Instead, let's use the new fd_want_recv_safe() which will update the FD and create an update entry only if possible. In addition, the equivalent test before calling fd_stop_recv() was removed as totally useless since there's not fd_updt creation in this case.
2020-11-04 12:59:04 +00:00
if (rx->flags & RX_F_BOUND)
MINOR: sock: provide a set of generic enable/disable functions These will be used on receivers, to enable or disable receiving on a listener, which most of the time just consists in enabling/disabling the file descriptor. We have to take care of the existence of fd_updt to know if we may or not call fd_{want,stop}_recv() since it's not permitted in very early boot.
2020-09-25 17:00:01 +00:00
fd_stop_recv(rx->fd);
}
MEDIUM: receivers: add an rx_unbind() method in the protocols This is used as a generic way to unbind a receiver at the end of do_unbind_listener(). This allows to considerably simplify that function since we can now let the protocol perform the cleanup. The generic code was moved to sock.c, along with the conditional rx_disable() call. Now the code also supports that the ->disable() function of the protocol which acts on the listener performs the close itself and adjusts the RX_F_BUOND flag accordingly.
2020-10-09 14:32:08 +00:00
/* stops, unbinds and possibly closes the FD associated with receiver rx */
void sock_unbind(struct receiver *rx)
{
/* There are a number of situations where we prefer to keep the FD and
* not to close it (unless we're stopping, of course):
* - worker process unbinding from a worker's FD with socket transfer enabled => keep
* - master process unbinding from a master's inherited FD => keep
* - master process unbinding from a master's FD => close
BUG/MEDIUM: listener: make the master also keep workers' inherited FDs In commit 374e9af35 ("MEDIUM: listener: let do_unbind_listener() decide whether to close or not") it didn't appear necessary to have the master process keep open the workers' inherited FDs. But this is actually necessary to handle the reload on "bind fd@foo" situations, otherwise the FD may be reassigned and the new socket cannot be set up, sometimes causing "socket operation on non-socket" or other types of errors. William found that this was the cause for the consistent failures of the abns regtest, which already used to fail very often before this and was as such marked as broken. Interestingly I didn't have this issue with my test configs because the FD number I used was higher and within the range of other listening sockets. But this means that one of these wouldn't work as expected. No backport is needed, this was introduced as part of the listeners rework in 2.3.
2020-11-03 17:38:05 +00:00
* - master process unbinding from a worker's inherited FD => keep
MEDIUM: receivers: add an rx_unbind() method in the protocols This is used as a generic way to unbind a receiver at the end of do_unbind_listener(). This allows to considerably simplify that function since we can now let the protocol perform the cleanup. The generic code was moved to sock.c, along with the conditional rx_disable() call. Now the code also supports that the ->disable() function of the protocol which acts on the listener performs the close itself and adjusts the RX_F_BUOND flag accordingly.
2020-10-09 14:32:08 +00:00
* - master process unbinding from a worker's FD => close
* - worker process unbinding from a master's FD => close
* - worker process unbinding from a worker's FD => close
*/
if (rx->flags & RX_F_BOUND)
rx->proto->rx_disable(rx);
if (!stopping && !master &&
!(rx->flags & RX_F_MWORKER) &&
(global.tune.options & GTUNE_SOCKET_TRANSFER))
return;
if (!stopping && master &&
rx->flags & RX_F_INHERITED)
return;
rx->flags &= ~RX_F_BOUND;
if (rx->fd != -1)
fd_delete(rx->fd);
rx->fd = -1;
}
REORG: sock: start to move some generic socket code to sock.c The new file sock.c will contain generic code for standard sockets relying on file descriptors. We currently have way too much duplication between proto_uxst, proto_tcp, proto_sockpair and proto_udp. For now only get_src, get_dst and sock_create_server_socket were moved, and are used where appropriate.
2020-08-28 10:07:22 +00:00
/*
* Retrieves the source address for the socket <fd>, with <dir> indicating
* if we're a listener (=0) or an initiator (!=0). It returns 0 in case of
* success, -1 in case of error. The socket's source address is stored in
* <sa> for <salen> bytes.
*/
int sock_get_src(int fd, struct sockaddr *sa, socklen_t salen, int dir)
{
if (dir)
return getsockname(fd, sa, &salen);
else
return getpeername(fd, sa, &salen);
}
/*
* Retrieves the original destination address for the socket <fd>, with <dir>
* indicating if we're a listener (=0) or an initiator (!=0). It returns 0 in
* case of success, -1 in case of error. The socket's source address is stored
* in <sa> for <salen> bytes.
*/
int sock_get_dst(int fd, struct sockaddr *sa, socklen_t salen, int dir)
{
if (dir)
return getpeername(fd, sa, &salen);
else
return getsockname(fd, sa, &salen);
}
REORG: sock: move get_old_sockets() from haproxy.c The new function was called sock_get_old_sockets() and was left as-is except a minimum amount of style lifting to make it more readable. It will never be awesome anyway since it's used very early in the boot sequence and needs to perform socket I/O without any external help.
2020-08-28 16:42:45 +00:00
/* Try to retrieve exported sockets from worker at CLI <unixsocket>. These
* ones will be placed into the xfer_sock_list for later use by function
* sock_find_compatible_fd(). Returns 0 on success, -1 on failure.
*/
int sock_get_old_sockets(const char *unixsocket)
{
char *cmsgbuf = NULL, *tmpbuf = NULL;
int *tmpfd = NULL;
struct sockaddr_un addr;
struct cmsghdr *cmsg;
struct msghdr msghdr;
struct iovec iov;
struct xfer_sock_list *xfer_sock = NULL;
struct timeval tv = { .tv_sec = 1, .tv_usec = 0 };
int sock = -1;
int ret = -1;
int ret2 = -1;
int fd_nb;
int got_fd = 0;
int cur_fd = 0;
size_t maxoff = 0, curoff = 0;
MEDIUM: mworker: seamless reload use the internal sockpairs With the master worker, the seamless reload was still requiring an external stats socket to the previous process, which is a pain to configure. This patch implements a way to use the internal socketpair between the master and the workers to transfer the sockets during the reload. This way, the master will always try to transfer the socket, even without any configuration. The master will still reload with the -x argument, followed by the sockpair@ syntax. ( ex -x sockpair@4 ). Which use the FD of internal CLI to the worker.
2021-11-24 17:45:37 +00:00
if (strncmp("sockpair@", unixsocket, strlen("sockpair@")) == 0) {
/* sockpair for master-worker usage */
int sv[2];
int dst_fd;
dst_fd = strtoll(unixsocket + strlen("sockpair@"), NULL, 0);
if (socketpair(PF_UNIX, SOCK_STREAM, 0, sv) == -1) {
ha_warning("socketpair(): Cannot create socketpair. Giving up.\n");
}
if (send_fd_uxst(dst_fd, sv[0]) == -1) {
MINOR: sockpair: move send_fd_uxst() error message in caller Move the ha_alert() in send_fd_uxst() in the callers and add the FD numbers in the message.
2022-07-25 14:04:38 +00:00
ha_alert("socketpair: Cannot transfer the fd %d over sockpair@%d. Giving up.\n", sv[0], dst_fd);
MEDIUM: mworker: seamless reload use the internal sockpairs With the master worker, the seamless reload was still requiring an external stats socket to the previous process, which is a pain to configure. This patch implements a way to use the internal socketpair between the master and the workers to transfer the sockets during the reload. This way, the master will always try to transfer the socket, even without any configuration. The master will still reload with the -x argument, followed by the sockpair@ syntax. ( ex -x sockpair@4 ). Which use the FD of internal CLI to the worker.
2021-11-24 17:45:37 +00:00
close(sv[0]);
close(sv[1]);
goto out;
}
close(sv[0]); /* we don't need this side anymore */
sock = sv[1];
} else {
/* Unix socket */
sock = socket(PF_UNIX, SOCK_STREAM, 0);
if (sock < 0) {
ha_warning("Failed to connect to the old process socket '%s'\n", unixsocket);
goto out;
}
strncpy(addr.sun_path, unixsocket, sizeof(addr.sun_path) - 1);
addr.sun_path[sizeof(addr.sun_path) - 1] = 0;
addr.sun_family = PF_UNIX;
ret = connect(sock, (struct sockaddr *)&addr, sizeof(addr));
if (ret < 0) {
ha_warning("Failed to connect to the old process socket '%s'\n", unixsocket);
goto out;
}
}
REORG: sock: move get_old_sockets() from haproxy.c The new function was called sock_get_old_sockets() and was left as-is except a minimum amount of style lifting to make it more readable. It will never be awesome anyway since it's used very early in the boot sequence and needs to perform socket I/O without any external help.
2020-08-28 16:42:45 +00:00
memset(&msghdr, 0, sizeof(msghdr));
cmsgbuf = malloc(CMSG_SPACE(sizeof(int)) * MAX_SEND_FD);
if (!cmsgbuf) {
ha_warning("Failed to allocate memory to send sockets\n");
goto out;
}
setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (void *)&tv, sizeof(tv));
iov.iov_base = &fd_nb;
iov.iov_len = sizeof(fd_nb);
msghdr.msg_iov = &iov;
msghdr.msg_iovlen = 1;
if (send(sock, "_getsocks\n", strlen("_getsocks\n"), 0) != strlen("_getsocks\n")) {
ha_warning("Failed to get the number of sockets to be transferred !\n");
goto out;
}
/* First, get the number of file descriptors to be received */
if (recvmsg(sock, &msghdr, MSG_WAITALL) != sizeof(fd_nb)) {
ha_warning("Failed to get the number of sockets to be transferred !\n");
goto out;
}
if (fd_nb == 0) {
ret2 = 0;
goto out;
}
tmpbuf = malloc(fd_nb * (1 + MAXPATHLEN + 1 + IFNAMSIZ + sizeof(int)));
if (tmpbuf == NULL) {
ha_warning("Failed to allocate memory while receiving sockets\n");
goto out;
}
tmpfd = malloc(fd_nb * sizeof(int));
if (tmpfd == NULL) {
ha_warning("Failed to allocate memory while receiving sockets\n");
goto out;
}
msghdr.msg_control = cmsgbuf;
msghdr.msg_controllen = CMSG_SPACE(sizeof(int)) * MAX_SEND_FD;
iov.iov_len = MAX_SEND_FD * (1 + MAXPATHLEN + 1 + IFNAMSIZ + sizeof(int));
do {
int ret3;
iov.iov_base = tmpbuf + curoff;
ret = recvmsg(sock, &msghdr, 0);
if (ret == -1 && errno == EINTR)
continue;
if (ret <= 0)
break;
/* Send an ack to let the sender know we got the sockets
* and it can send some more
*/
do {
ret3 = send(sock, &got_fd, sizeof(got_fd), 0);
} while (ret3 == -1 && errno == EINTR);
for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg != NULL; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
size_t totlen = cmsg->cmsg_len - CMSG_LEN(0);
if (totlen / sizeof(int) + got_fd > fd_nb) {
ha_warning("Got to many sockets !\n");
goto out;
}
/*
* Be paranoid and use memcpy() to avoid any
* potential alignment issue.
*/
memcpy(&tmpfd[got_fd], CMSG_DATA(cmsg), totlen);
got_fd += totlen / sizeof(int);
}
}
curoff += ret;
} while (got_fd < fd_nb);
if (got_fd != fd_nb) {
ha_warning("We didn't get the expected number of sockets (expecting %d got %d)\n",
fd_nb, got_fd);
goto out;
}
maxoff = curoff;
curoff = 0;
for (cur_fd = 0; cur_fd < got_fd; cur_fd++) {
int fd = tmpfd[cur_fd];
socklen_t socklen;
int val;
int len;
xfer_sock = calloc(1, sizeof(*xfer_sock));
if (!xfer_sock) {
ha_warning("Failed to allocate memory in get_old_sockets() !\n");
break;
}
xfer_sock->fd = -1;
socklen = sizeof(xfer_sock->addr);
if (getsockname(fd, (struct sockaddr *)&xfer_sock->addr, &socklen) != 0) {
ha_warning("Failed to get socket address\n");
CLEANUP: tree-wide: replace free(x);x=NULL with ha_free(&x) This makes the code more readable and less prone to copy-paste errors. In addition, it allows to place some __builtin_constant_p() predicates to trigger a link-time error in case the compiler knows that the freed area is constant. It will also produce compile-time error if trying to free something that is not a regular pointer (e.g. a function). The DEBUG_MEM_STATS macro now also defines an instance for ha_free() so that all these calls can be checked. 178 occurrences were converted. The vast majority of them were handled by the following Coccinelle script, some slightly refined to better deal with "&*x" or with long lines: @ rule @ expression E; @@ - free(E); - E = NULL; + ha_free(&E); It was verified that the resulting code is the same, more or less a handful of cases where the compiler optimized slightly differently the temporary variable that holds the copy of the pointer. A non-negligible amount of {free(str);str=NULL;str_len=0;} are still present in the config part (mostly header names in proxies). These ones should also be cleaned for the same reasons, and probably be turned into ist strings.
2021-02-20 09:46:51 +00:00
ha_free(&xfer_sock);
REORG: sock: move get_old_sockets() from haproxy.c The new function was called sock_get_old_sockets() and was left as-is except a minimum amount of style lifting to make it more readable. It will never be awesome anyway since it's used very early in the boot sequence and needs to perform socket I/O without any external help.
2020-08-28 16:42:45 +00:00
continue;
}
if (curoff >= maxoff) {
ha_warning("Inconsistency while transferring sockets\n");
goto out;
}
len = tmpbuf[curoff++];
if (len > 0) {
/* We have a namespace */
if (curoff + len > maxoff) {
ha_warning("Inconsistency while transferring sockets\n");
goto out;
}
xfer_sock->namespace = malloc(len + 1);
if (!xfer_sock->namespace) {
ha_warning("Failed to allocate memory while transferring sockets\n");
goto out;
}
memcpy(xfer_sock->namespace, &tmpbuf[curoff], len);
xfer_sock->namespace[len] = 0;
xfer_sock->ns_namelen = len;
curoff += len;
}
if (curoff >= maxoff) {
ha_warning("Inconsistency while transferring sockets\n");
goto out;
}
len = tmpbuf[curoff++];
if (len > 0) {
/* We have an interface */
if (curoff + len > maxoff) {
ha_warning("Inconsistency while transferring sockets\n");
goto out;
}
xfer_sock->iface = malloc(len + 1);
if (!xfer_sock->iface) {
ha_warning("Failed to allocate memory while transferring sockets\n");
goto out;
}
memcpy(xfer_sock->iface, &tmpbuf[curoff], len);
xfer_sock->iface[len] = 0;
xfer_sock->if_namelen = len;
curoff += len;
}
if (curoff + sizeof(int) > maxoff) {
ha_warning("Inconsistency while transferring sockets\n");
goto out;
}
/* we used to have 32 bits of listener options here but we don't
* use them anymore.
*/
curoff += sizeof(int);
/* determine the foreign status directly from the socket itself */
if (sock_inet_is_foreign(fd, xfer_sock->addr.ss_family))
MINOR: sock: do not use LI_O_* in xfer_sock_list anymore We'll want to store more info there and some info that are not represented in listener options at the moment (such as dgram vs stream) so let's get rid of these and instead use a new set of options (SOCK_XFER_OPT_*).
2020-08-28 17:09:19 +00:00
xfer_sock->options |= SOCK_XFER_OPT_FOREIGN;
REORG: sock: move get_old_sockets() from haproxy.c The new function was called sock_get_old_sockets() and was left as-is except a minimum amount of style lifting to make it more readable. It will never be awesome anyway since it's used very early in the boot sequence and needs to perform socket I/O without any external help.
2020-08-28 16:42:45 +00:00
MINOR: sock: distinguish dgram from stream types when retrieving old sockets For now we still don't retrieve dgram sockets, but the code must be able to distinguish them before we switch to receivers. This adds a new flag to the xfer_sock_list indicating that a socket is of type SOCK_DGRAM. The way to set the flag for now is by looking at the dummy address family which equals AF_CUST_UDP{4,6} in this case (given that other dgram sockets are not yet supported).
2020-08-28 17:20:23 +00:00
socklen = sizeof(val);
if (getsockopt(fd, SOL_SOCKET, SO_TYPE, &val, &socklen) == 0 && val == SOCK_DGRAM)
xfer_sock->options |= SOCK_XFER_OPT_DGRAM;
REORG: sock: move get_old_sockets() from haproxy.c The new function was called sock_get_old_sockets() and was left as-is except a minimum amount of style lifting to make it more readable. It will never be awesome anyway since it's used very early in the boot sequence and needs to perform socket I/O without any external help.
2020-08-28 16:42:45 +00:00
#if defined(IPV6_V6ONLY)
/* keep only the v6only flag depending on what's currently
* active on the socket, and always drop the v4v6 one.
*/
socklen = sizeof(val);
if (xfer_sock->addr.ss_family == AF_INET6 &&
getsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &val, &socklen) == 0 && val > 0)
MINOR: sock: do not use LI_O_* in xfer_sock_list anymore We'll want to store more info there and some info that are not represented in listener options at the moment (such as dgram vs stream) so let's get rid of these and instead use a new set of options (SOCK_XFER_OPT_*).
2020-08-28 17:09:19 +00:00
xfer_sock->options |= SOCK_XFER_OPT_V6ONLY;
REORG: sock: move get_old_sockets() from haproxy.c The new function was called sock_get_old_sockets() and was left as-is except a minimum amount of style lifting to make it more readable. It will never be awesome anyway since it's used very early in the boot sequence and needs to perform socket I/O without any external help.
2020-08-28 16:42:45 +00:00
#endif
xfer_sock->fd = fd;
if (xfer_sock_list)
xfer_sock_list->prev = xfer_sock;
xfer_sock->next = xfer_sock_list;
xfer_sock->prev = NULL;
xfer_sock_list = xfer_sock;
xfer_sock = NULL;
}
ret2 = 0;
out:
/* If we failed midway make sure to close the remaining
* file descriptors
*/
if (tmpfd != NULL && cur_fd < got_fd) {
for (; cur_fd < got_fd; cur_fd++) {
close(tmpfd[cur_fd]);
}
}
free(tmpbuf);
free(tmpfd);
free(cmsgbuf);
if (sock != -1)
close(sock);
if (xfer_sock) {
free(xfer_sock->namespace);
free(xfer_sock->iface);
if (xfer_sock->fd != -1)
close(xfer_sock->fd);
free(xfer_sock);
}
return (ret2);
}
MINOR: sock: make sock_find_compatible_fd() only take a receiver We don't need to have a listener anymore to find an fd, a receiver with its settings properly set is enough now.
2020-09-01 13:20:52 +00:00
/* When binding the receivers, check if a socket has been sent to us by the
MINOR: sock: implement sock_find_compatible_fd() This is essentially a merge from tcp_find_compatible_fd() and uxst_find_compatible_fd() that relies on a listener's address and compare function and still checks for other variations. For AF_INET6 it compares a few of the listener's bind options. A minor change for UNIX sockets is that transparent mode, interface and namespace used to be ignored when trying to pick a previous socket while now if they are changed, the socket will not be reused. This could be refined but it's still better this way as there is no more risk of using a differently bound socket by accident. Eventually we should not pass a listener there but a set of binding parameters (address, interface, namespace etc...) which ultimately will be grouped into a receiver. For now this still doesn't exist so let's stick to the listener to break dependencies in the rest of the code.
2020-08-28 14:49:41 +00:00
* previous process that we could reuse, instead of creating a new one. Note
* that some address family-specific options are checked on the listener and
* on the socket. Typically for AF_INET and AF_INET6, we check for transparent
* mode, and for AF_INET6 we also check for "v4v6" or "v6only". The reused
* socket is automatically removed from the list so that it's not proposed
* anymore.
*/
MINOR: sock: make sock_find_compatible_fd() only take a receiver We don't need to have a listener anymore to find an fd, a receiver with its settings properly set is enough now.
2020-09-01 13:20:52 +00:00
int sock_find_compatible_fd(const struct receiver *rx)
MINOR: sock: implement sock_find_compatible_fd() This is essentially a merge from tcp_find_compatible_fd() and uxst_find_compatible_fd() that relies on a listener's address and compare function and still checks for other variations. For AF_INET6 it compares a few of the listener's bind options. A minor change for UNIX sockets is that transparent mode, interface and namespace used to be ignored when trying to pick a previous socket while now if they are changed, the socket will not be reused. This could be refined but it's still better this way as there is no more risk of using a differently bound socket by accident. Eventually we should not pass a listener there but a set of binding parameters (address, interface, namespace etc...) which ultimately will be grouped into a receiver. For now this still doesn't exist so let's stick to the listener to break dependencies in the rest of the code.
2020-08-28 14:49:41 +00:00
{
struct xfer_sock_list *xfer_sock = xfer_sock_list;
MINOR: sock: do not use LI_O_* in xfer_sock_list anymore We'll want to store more info there and some info that are not represented in listener options at the moment (such as dgram vs stream) so let's get rid of these and instead use a new set of options (SOCK_XFER_OPT_*).
2020-08-28 17:09:19 +00:00
int options = 0;
MINOR: sock: implement sock_find_compatible_fd() This is essentially a merge from tcp_find_compatible_fd() and uxst_find_compatible_fd() that relies on a listener's address and compare function and still checks for other variations. For AF_INET6 it compares a few of the listener's bind options. A minor change for UNIX sockets is that transparent mode, interface and namespace used to be ignored when trying to pick a previous socket while now if they are changed, the socket will not be reused. This could be refined but it's still better this way as there is no more risk of using a differently bound socket by accident. Eventually we should not pass a listener there but a set of binding parameters (address, interface, namespace etc...) which ultimately will be grouped into a receiver. For now this still doesn't exist so let's stick to the listener to break dependencies in the rest of the code.
2020-08-28 14:49:41 +00:00
int if_namelen = 0;
int ns_namelen = 0;
int ret = -1;
MINOR: protocol: retrieve the family-specific fields from the family We now take care of retrieving sock_family, l3_addrlen, bind(), addrcmp(), get_src() and get_dst() from the protocol family and not just the protocol itself. There are very few places, this was only seldom used. Interestingly in sock_inet.c used to rely on ->sock_family instead of ->sock_domain, and sock_unix.c used to hard-code PF_UNIX instead of using ->sock_domain. Also it appears obvious we have something wrong it the protocol selection algorithm because sock_domain is the one set to the custom protocols while it ought to be sock_family instead, which would avoid having to hard-code some conversions for UDP namely.
2020-09-04 06:15:31 +00:00
if (!rx->proto->fam->addrcmp)
MINOR: sock: implement sock_find_compatible_fd() This is essentially a merge from tcp_find_compatible_fd() and uxst_find_compatible_fd() that relies on a listener's address and compare function and still checks for other variations. For AF_INET6 it compares a few of the listener's bind options. A minor change for UNIX sockets is that transparent mode, interface and namespace used to be ignored when trying to pick a previous socket while now if they are changed, the socket will not be reused. This could be refined but it's still better this way as there is no more risk of using a differently bound socket by accident. Eventually we should not pass a listener there but a set of binding parameters (address, interface, namespace etc...) which ultimately will be grouped into a receiver. For now this still doesn't exist so let's stick to the listener to break dependencies in the rest of the code.
2020-08-28 14:49:41 +00:00
return -1;
MINOR: protocols: make use of the protocol type to select the protocol Instead of using sock_type and ctrl_type to select a protocol, let's make use of the new protocol type. For now they always match so there is no change. This is applied to address parsing and to socket retrieval from older processes.
2021-10-27 15:28:55 +00:00
if (rx->proto->proto_type == PROTO_TYPE_DGRAM)
MINOR: sock: distinguish dgram from stream types when retrieving old sockets For now we still don't retrieve dgram sockets, but the code must be able to distinguish them before we switch to receivers. This adds a new flag to the xfer_sock_list indicating that a socket is of type SOCK_DGRAM. The way to set the flag for now is by looking at the dummy address family which equals AF_CUST_UDP{4,6} in this case (given that other dgram sockets are not yet supported).
2020-08-28 17:20:23 +00:00
options |= SOCK_XFER_OPT_DGRAM;
MINOR: sock: make sock_find_compatible_fd() only take a receiver We don't need to have a listener anymore to find an fd, a receiver with its settings properly set is enough now.
2020-09-01 13:20:52 +00:00
if (rx->settings->options & RX_O_FOREIGN)
MINOR: sock: do not use LI_O_* in xfer_sock_list anymore We'll want to store more info there and some info that are not represented in listener options at the moment (such as dgram vs stream) so let's get rid of these and instead use a new set of options (SOCK_XFER_OPT_*).
2020-08-28 17:09:19 +00:00
options |= SOCK_XFER_OPT_FOREIGN;
MINOR: sock: make sock_find_compatible_fd() only take a receiver We don't need to have a listener anymore to find an fd, a receiver with its settings properly set is enough now.
2020-09-01 13:20:52 +00:00
if (rx->addr.ss_family == AF_INET6) {
MINOR: sock: implement sock_find_compatible_fd() This is essentially a merge from tcp_find_compatible_fd() and uxst_find_compatible_fd() that relies on a listener's address and compare function and still checks for other variations. For AF_INET6 it compares a few of the listener's bind options. A minor change for UNIX sockets is that transparent mode, interface and namespace used to be ignored when trying to pick a previous socket while now if they are changed, the socket will not be reused. This could be refined but it's still better this way as there is no more risk of using a differently bound socket by accident. Eventually we should not pass a listener there but a set of binding parameters (address, interface, namespace etc...) which ultimately will be grouped into a receiver. For now this still doesn't exist so let's stick to the listener to break dependencies in the rest of the code.
2020-08-28 14:49:41 +00:00
/* Prepare to match the v6only option against what we really want. Note
* that sadly the two options are not exclusive to each other and that
* v6only is stronger than v4v6.
*/
MINOR: sock: make sock_find_compatible_fd() only take a receiver We don't need to have a listener anymore to find an fd, a receiver with its settings properly set is enough now.
2020-09-01 13:20:52 +00:00
if ((rx->settings->options & RX_O_V6ONLY) ||
(sock_inet6_v6only_default && !(rx->settings->options & RX_O_V4V6)))
MINOR: sock: do not use LI_O_* in xfer_sock_list anymore We'll want to store more info there and some info that are not represented in listener options at the moment (such as dgram vs stream) so let's get rid of these and instead use a new set of options (SOCK_XFER_OPT_*).
2020-08-28 17:09:19 +00:00
options |= SOCK_XFER_OPT_V6ONLY;
MINOR: sock: implement sock_find_compatible_fd() This is essentially a merge from tcp_find_compatible_fd() and uxst_find_compatible_fd() that relies on a listener's address and compare function and still checks for other variations. For AF_INET6 it compares a few of the listener's bind options. A minor change for UNIX sockets is that transparent mode, interface and namespace used to be ignored when trying to pick a previous socket while now if they are changed, the socket will not be reused. This could be refined but it's still better this way as there is no more risk of using a differently bound socket by accident. Eventually we should not pass a listener there but a set of binding parameters (address, interface, namespace etc...) which ultimately will be grouped into a receiver. For now this still doesn't exist so let's stick to the listener to break dependencies in the rest of the code.
2020-08-28 14:49:41 +00:00
}
MINOR: sock: make sock_find_compatible_fd() only take a receiver We don't need to have a listener anymore to find an fd, a receiver with its settings properly set is enough now.
2020-09-01 13:20:52 +00:00
if (rx->settings->interface)
if_namelen = strlen(rx->settings->interface);
MINOR: sock: implement sock_find_compatible_fd() This is essentially a merge from tcp_find_compatible_fd() and uxst_find_compatible_fd() that relies on a listener's address and compare function and still checks for other variations. For AF_INET6 it compares a few of the listener's bind options. A minor change for UNIX sockets is that transparent mode, interface and namespace used to be ignored when trying to pick a previous socket while now if they are changed, the socket will not be reused. This could be refined but it's still better this way as there is no more risk of using a differently bound socket by accident. Eventually we should not pass a listener there but a set of binding parameters (address, interface, namespace etc...) which ultimately will be grouped into a receiver. For now this still doesn't exist so let's stick to the listener to break dependencies in the rest of the code.
2020-08-28 14:49:41 +00:00
#ifdef USE_NS
MINOR: sock: make sock_find_compatible_fd() only take a receiver We don't need to have a listener anymore to find an fd, a receiver with its settings properly set is enough now.
2020-09-01 13:20:52 +00:00
if (rx->settings->netns)
ns_namelen = rx->settings->netns->name_len;
MINOR: sock: implement sock_find_compatible_fd() This is essentially a merge from tcp_find_compatible_fd() and uxst_find_compatible_fd() that relies on a listener's address and compare function and still checks for other variations. For AF_INET6 it compares a few of the listener's bind options. A minor change for UNIX sockets is that transparent mode, interface and namespace used to be ignored when trying to pick a previous socket while now if they are changed, the socket will not be reused. This could be refined but it's still better this way as there is no more risk of using a differently bound socket by accident. Eventually we should not pass a listener there but a set of binding parameters (address, interface, namespace etc...) which ultimately will be grouped into a receiver. For now this still doesn't exist so let's stick to the listener to break dependencies in the rest of the code.
2020-08-28 14:49:41 +00:00
#endif
while (xfer_sock) {
MINOR: sock: do not use LI_O_* in xfer_sock_list anymore We'll want to store more info there and some info that are not represented in listener options at the moment (such as dgram vs stream) so let's get rid of these and instead use a new set of options (SOCK_XFER_OPT_*).
2020-08-28 17:09:19 +00:00
if ((options == xfer_sock->options) &&
MINOR: sock: implement sock_find_compatible_fd() This is essentially a merge from tcp_find_compatible_fd() and uxst_find_compatible_fd() that relies on a listener's address and compare function and still checks for other variations. For AF_INET6 it compares a few of the listener's bind options. A minor change for UNIX sockets is that transparent mode, interface and namespace used to be ignored when trying to pick a previous socket while now if they are changed, the socket will not be reused. This could be refined but it's still better this way as there is no more risk of using a differently bound socket by accident. Eventually we should not pass a listener there but a set of binding parameters (address, interface, namespace etc...) which ultimately will be grouped into a receiver. For now this still doesn't exist so let's stick to the listener to break dependencies in the rest of the code.
2020-08-28 14:49:41 +00:00
(if_namelen == xfer_sock->if_namelen) &&
(ns_namelen == xfer_sock->ns_namelen) &&
MINOR: sock: make sock_find_compatible_fd() only take a receiver We don't need to have a listener anymore to find an fd, a receiver with its settings properly set is enough now.
2020-09-01 13:20:52 +00:00
(!if_namelen || strcmp(rx->settings->interface, xfer_sock->iface) == 0) &&
MINOR: sock: implement sock_find_compatible_fd() This is essentially a merge from tcp_find_compatible_fd() and uxst_find_compatible_fd() that relies on a listener's address and compare function and still checks for other variations. For AF_INET6 it compares a few of the listener's bind options. A minor change for UNIX sockets is that transparent mode, interface and namespace used to be ignored when trying to pick a previous socket while now if they are changed, the socket will not be reused. This could be refined but it's still better this way as there is no more risk of using a differently bound socket by accident. Eventually we should not pass a listener there but a set of binding parameters (address, interface, namespace etc...) which ultimately will be grouped into a receiver. For now this still doesn't exist so let's stick to the listener to break dependencies in the rest of the code.
2020-08-28 14:49:41 +00:00
#ifdef USE_NS
MINOR: sock: make sock_find_compatible_fd() only take a receiver We don't need to have a listener anymore to find an fd, a receiver with its settings properly set is enough now.
2020-09-01 13:20:52 +00:00
(!ns_namelen || strcmp(rx->settings->netns->node.key, xfer_sock->namespace) == 0) &&
MINOR: sock: implement sock_find_compatible_fd() This is essentially a merge from tcp_find_compatible_fd() and uxst_find_compatible_fd() that relies on a listener's address and compare function and still checks for other variations. For AF_INET6 it compares a few of the listener's bind options. A minor change for UNIX sockets is that transparent mode, interface and namespace used to be ignored when trying to pick a previous socket while now if they are changed, the socket will not be reused. This could be refined but it's still better this way as there is no more risk of using a differently bound socket by accident. Eventually we should not pass a listener there but a set of binding parameters (address, interface, namespace etc...) which ultimately will be grouped into a receiver. For now this still doesn't exist so let's stick to the listener to break dependencies in the rest of the code.
2020-08-28 14:49:41 +00:00
#endif
MINOR: protocol: retrieve the family-specific fields from the family We now take care of retrieving sock_family, l3_addrlen, bind(), addrcmp(), get_src() and get_dst() from the protocol family and not just the protocol itself. There are very few places, this was only seldom used. Interestingly in sock_inet.c used to rely on ->sock_family instead of ->sock_domain, and sock_unix.c used to hard-code PF_UNIX instead of using ->sock_domain. Also it appears obvious we have something wrong it the protocol selection algorithm because sock_domain is the one set to the custom protocols while it ought to be sock_family instead, which would avoid having to hard-code some conversions for UDP namely.
2020-09-04 06:15:31 +00:00
rx->proto->fam->addrcmp(&xfer_sock->addr, &rx->addr) == 0)
MINOR: sock: implement sock_find_compatible_fd() This is essentially a merge from tcp_find_compatible_fd() and uxst_find_compatible_fd() that relies on a listener's address and compare function and still checks for other variations. For AF_INET6 it compares a few of the listener's bind options. A minor change for UNIX sockets is that transparent mode, interface and namespace used to be ignored when trying to pick a previous socket while now if they are changed, the socket will not be reused. This could be refined but it's still better this way as there is no more risk of using a differently bound socket by accident. Eventually we should not pass a listener there but a set of binding parameters (address, interface, namespace etc...) which ultimately will be grouped into a receiver. For now this still doesn't exist so let's stick to the listener to break dependencies in the rest of the code.
2020-08-28 14:49:41 +00:00
break;
xfer_sock = xfer_sock->next;
}
if (xfer_sock != NULL) {
ret = xfer_sock->fd;
if (xfer_sock == xfer_sock_list)
xfer_sock_list = xfer_sock->next;
if (xfer_sock->prev)
xfer_sock->prev->next = xfer_sock->next;
if (xfer_sock->next)
xfer_sock->next->prev = xfer_sock->prev;
free(xfer_sock->iface);
free(xfer_sock->namespace);
free(xfer_sock);
}
return ret;
}
MINOR: sock: move the unused socket cleaning code into its own function The startup code used to scan the list of unused sockets retrieved from an older process, and to close them one by one. This also required that the knowledge of the internal storage of these temporary sockets was known from outside sock.c and that the code was copy-pasted at every call place. This patch moves this into sock.c under the name sock_drop_unused_old_sockets(), and removes the xfer_sock_list definition from sock.h since the rest of the code doesn't need to know this. This cleanup is minimal and preliminary to a future fix that will need to be backported to all versions featuring FD transfers over the CLI.
2022-01-28 17:28:18 +00:00
/* After all protocols are bound, there may remain some old sockets that have
* been removed between the previous config and the new one. These ones must
* be dropped, otherwise they will remain open and may prevent a service from
* restarting.
*/
void sock_drop_unused_old_sockets()
{
while (xfer_sock_list != NULL) {
struct xfer_sock_list *tmpxfer = xfer_sock_list->next;
close(xfer_sock_list->fd);
free(xfer_sock_list->iface);
free(xfer_sock_list->namespace);
free(xfer_sock_list);
xfer_sock_list = tmpxfer;
}
}
MINOR: sock: add sock_accept_conn() to test a listening socket At several places we need to check if a socket is still valid and still willing to accept connections. Instead of open-coding this, each time, let's add a new function for this.
2020-10-13 15:06:12 +00:00
/* Tests if the receiver supports accepting connections. Returns positive on
* success, 0 if not possible, negative if the socket is non-recoverable. The
* rationale behind this is that inherited FDs may be broken and that shared
* FDs might have been paused by another process.
*/
MINOR: sock: rename sock_accept_conn() to sock_accepting_conn() This call was introduced by commit 5ced3e887 ("MINOR: sock: add sock_accept_conn() to test a listening socket") but is actually quite confusing because it makes one think the socket will accept a connection (which is what we want to have in a new function) while it only tells whether it's configured to accept connections. Let's call it sock_accepting_conn() instead. The same change was applied to sockpair which had the same issue.
2020-10-15 07:19:43 +00:00
int sock_accepting_conn(const struct receiver *rx)
MINOR: sock: add sock_accept_conn() to test a listening socket At several places we need to check if a socket is still valid and still willing to accept connections. Instead of open-coding this, each time, let's add a new function for this.
2020-10-13 15:06:12 +00:00
{
int opt_val = 0;
socklen_t opt_len = sizeof(opt_val);
if (getsockopt(rx->fd, SOL_SOCKET, SO_ACCEPTCONN, &opt_val, &opt_len) == -1)
return -1;
return opt_val;
}
MINOR: protocol: register the receiver's I/O handler and not the protocol's Now we define a new sock_accept_iocb() for socket-based stream protocols and use it as a wrapper for listener_accept() which now takes a listener and not an FD anymore. This will allow the receiver's I/O cb to be redefined during registration, and more specifically to get rid of the hard-coded hacks in protocol_bind_all() made for syslog. The previous ->accept() callback in the protocol was removed since it doesn't have anything to do with accept() anymore but is more generic. A few places where listener_accept() was compared against the FD's IO callback for debugging purposes on the CLI were updated.
2020-10-15 19:29:49 +00:00
/* This is the FD handler IO callback for stream sockets configured for
* accepting incoming connections. It's a pass-through to listener_accept()
* which will iterate over the listener protocol's accept_conn() function.
* The FD's owner must be a listener.
*/
void sock_accept_iocb(int fd)
{
struct listener *l = fdtab[fd].owner;
if (!l)
return;
MINOR: sock: add a check against cross worker<->master socket activities Given that the previous issues caused spurious worker socket wakeups in the master for inherited FDs that couldn't be closed, let's add a strict test in the I/O callback to make sure that an accept() event is always caught by the appropriate type of process (master for master listeners, worker for worker listeners).
2020-11-04 13:58:36 +00:00
BUG_ON(!!master != !!(l->rx.flags & RX_F_MWORKER));
MINOR: protocol: register the receiver's I/O handler and not the protocol's Now we define a new sock_accept_iocb() for socket-based stream protocols and use it as a wrapper for listener_accept() which now takes a listener and not an FD anymore. This will allow the receiver's I/O cb to be redefined during registration, and more specifically to get rid of the hard-coded hacks in protocol_bind_all() made for syslog. The previous ->accept() callback in the protocol was removed since it doesn't have anything to do with accept() anymore but is more generic. A few places where listener_accept() was compared against the FD's IO callback for debugging purposes on the CLI were updated.
2020-10-15 19:29:49 +00:00
listener_accept(l);
}
MINOR: protocol: add a set of ctrl_init/ctrl_close methods for setup/teardown Currnetly conn_ctrl_init() does an fd_insert() and conn_ctrl_close() does an fd_delete(). These are the two only short-term obstacles against using a non-fd handle to set up a connection. Let's have pur these into the protocol layer, along with the other connection-level stuff so that the generic connection code uses them instead. This will allow to define new ones for other protocols (e.g. QUIC). Since we only support regular sockets at the moment, the code was placed into sock.c and shared with proto_tcp, proto_uxst and proto_sockpair.
2020-12-08 14:50:56 +00:00
/* This completes the initialization of connection <conn> by inserting its FD
* into the fdtab, associating it with the regular connection handler. It will
* be bound to the current thread only. This call cannot fail.
*/
void sock_conn_ctrl_init(struct connection *conn)
{
MEDIUM: connection: panic when calling FD-specific functions on FD-less conns Certain functions cannot be called on an FD-less conn because they are normally called as part of the protocol-specific setup/teardown sequence. Better place a few BUG_ON() to make sure none of them is called in other situations. If any of them would trigger in ambiguous conditions, it would always be possible to replace it with an error.
2022-04-11 16:07:03 +00:00
BUG_ON(conn->flags & CO_FL_FDLESS);
MEDIUM: fd: make fd_insert() take local thread masks fd_insert() was already given a thread group ID and a global thread mask. Now we're changing the few callers to take the group-local thread mask instead. It's passed directly into the FD's thread mask. Just like for previous commit, it must not change anything when a single group is configured.
2022-07-07 06:29:00 +00:00
fd_insert(conn->handle.fd, conn, sock_conn_iocb, tgid, ti->ltid_bit);
MINOR: protocol: add a set of ctrl_init/ctrl_close methods for setup/teardown Currnetly conn_ctrl_init() does an fd_insert() and conn_ctrl_close() does an fd_delete(). These are the two only short-term obstacles against using a non-fd handle to set up a connection. Let's have pur these into the protocol layer, along with the other connection-level stuff so that the generic connection code uses them instead. This will allow to define new ones for other protocols (e.g. QUIC). Since we only support regular sockets at the moment, the code was placed into sock.c and shared with proto_tcp, proto_uxst and proto_sockpair.
2020-12-08 14:50:56 +00:00
}
/* This completes the release of connection <conn> by removing its FD from the
* fdtab and deleting it. The connection must not use the FD anymore past this
* point. The FD may be modified in the connection.
*/
void sock_conn_ctrl_close(struct connection *conn)
{
MEDIUM: connection: panic when calling FD-specific functions on FD-less conns Certain functions cannot be called on an FD-less conn because they are normally called as part of the protocol-specific setup/teardown sequence. Better place a few BUG_ON() to make sure none of them is called in other situations. If any of them would trigger in ambiguous conditions, it would always be possible to replace it with an error.
2022-04-11 16:07:03 +00:00
BUG_ON(conn->flags & CO_FL_FDLESS);
MINOR: protocol: add a set of ctrl_init/ctrl_close methods for setup/teardown Currnetly conn_ctrl_init() does an fd_insert() and conn_ctrl_close() does an fd_delete(). These are the two only short-term obstacles against using a non-fd handle to set up a connection. Let's have pur these into the protocol layer, along with the other connection-level stuff so that the generic connection code uses them instead. This will allow to define new ones for other protocols (e.g. QUIC). Since we only support regular sockets at the moment, the code was placed into sock.c and shared with proto_tcp, proto_uxst and proto_sockpair.
2020-12-08 14:50:56 +00:00
fd_delete(conn->handle.fd);
conn->handle.fd = DEAD_FD_MAGIC;
}
REORG: connection: move the socket iocb (conn_fd_handler) to sock.c conn_fd_handler() is 100% specific to socket code. It's about time it moves to sock.c which manipulates socket FDs. With it comes conn_fd_check() which tests for the socket's readiness. The ugly connection status check at the end of the iocb was moved to an inlined function in connection.h so that if we need it for other socket layers it's not too hard to reuse. The code was really only moved and not changed at all.
2020-12-11 14:54:36 +00:00
/* This is the callback which is set when a connection establishment is pending
* and we have nothing to send. It may update the FD polling status to indicate
* !READY. It returns 0 if it fails in a fatal way or needs to poll to go
* further, otherwise it returns non-zero and removes the CO_FL_WAIT_L4_CONN
* flag from the connection's flags. In case of error, it sets CO_FL_ERROR and
* leaves the error code in errno.
*/
int sock_conn_check(struct connection *conn)
{
struct sockaddr_storage *addr;
int fd = conn->handle.fd;
if (conn->flags & CO_FL_ERROR)
return 0;
if (!conn_ctrl_ready(conn))
return 0;
if (!(conn->flags & CO_FL_WAIT_L4_CONN))
return 1; /* strange we were called while ready */
MEDIUM: connection: panic when calling FD-specific functions on FD-less conns Certain functions cannot be called on an FD-less conn because they are normally called as part of the protocol-specific setup/teardown sequence. Better place a few BUG_ON() to make sure none of them is called in other situations. If any of them would trigger in ambiguous conditions, it would always be possible to replace it with an error.
2022-04-11 16:07:03 +00:00
BUG_ON(conn->flags & CO_FL_FDLESS);
BUG/MEDIUM: sock: make sure to never miss early connection failures As shown in issue #1251, it is possible for a connect() to report an error directly via the poller without ever reporting send readiness, but currentlt sock_conn_check() manages to ignore that situation, leading to high CPU usage as poll() wakes up on these FDs. The bug was apparently introduced in 1.5-dev22 with commit fd803bb4d ("MEDIUM: connection: add check for readiness in I/O handlers"), but was likely only woken up by recent changes to conn_fd_handler() that made use of wakeups instead of direct calls between 1.8 and 1.9, voiding any chance to catch such errors in the early recv() callback. The exact sequence that leads to this situation remains obscure though because the poller does not report send readiness nor does it report an error. Only HUP and IN are reported on the FD. It is also possible that some recent kernel updates made this condition appear while it never used to previously. This needs to be backported to all stable branches, at least as far as 2.0. Before 2.2 the code was in tcp_connect_probe() in proto_tcp.c.
2021-07-06 06:29:20 +00:00
if (!fd_send_ready(fd) && !(fdtab[fd].state & (FD_POLL_ERR|FD_POLL_HUP)))
REORG: connection: move the socket iocb (conn_fd_handler) to sock.c conn_fd_handler() is 100% specific to socket code. It's about time it moves to sock.c which manipulates socket FDs. With it comes conn_fd_check() which tests for the socket's readiness. The ugly connection status check at the end of the iocb was moved to an inlined function in connection.h so that if we need it for other socket layers it's not too hard to reuse. The code was really only moved and not changed at all.
2020-12-11 14:54:36 +00:00
return 0;
/* Here we have 2 cases :
* - modern pollers, able to report ERR/HUP. If these ones return any
* of these flags then it's likely a failure, otherwise it possibly
* is a success (i.e. there may have been data received just before
* the error was reported).
* - select, which doesn't report these and with which it's always
* necessary either to try connect() again or to check for SO_ERROR.
* In order to simplify everything, we double-check using connect() as
* soon as we meet either of these delicate situations. Note that
* SO_ERROR would clear the error after reporting it!
*/
if (cur_poller.flags & HAP_POLL_F_ERRHUP) {
/* modern poller, able to report ERR/HUP */
MEDIUM: fd: merge fdtab[].ev and state for FD_EV_* and FD_POLL_* into state For a long time we've had fdtab[].ev and fdtab[].state which contain two arbitrary sets of information, one is mostly the configuration plus some shutdown reports and the other one is the latest polling status report which also contains some sticky error and shutdown reports. These ones used to be stored into distinct chars, complicating certain operations and not even allowing to clearly see concurrent accesses (e.g. fd_delete_orphan() would set the state to zero while fd_insert() would only set the event to zero). This patch creates a single uint with the two sets in it, still delimited at the byte level for better readability. The original FD_EV_* values remained at the lowest bit levels as they are also known by their bit value. The next step will consist in merging the remaining bits into it. The whole bits are now cleared both in fd_insert() and _fd_delete_orphan() because after a complete check, it is certain that in both cases these functions are the only ones touching these areas. Indeed, for _fd_delete_orphan(), the thread_mask has already been zeroed before a poller can call fd_update_event() which would touch the state, so it is certain that _fd_delete_orphan() is alone. Regarding fd_insert(), only one thread will get an FD at any moment, and it as this FD has already been released by _fd_delete_orphan() by definition it is certain that previous users have definitely stopped touching it. Strictly speaking there's no need for clearing the state again in fd_insert() but it's cheap and will remove some doubts during some troubleshooting sessions.
2021-04-06 15:23:40 +00:00
if ((fdtab[fd].state & (FD_POLL_IN|FD_POLL_ERR|FD_POLL_HUP)) == FD_POLL_IN)
REORG: connection: move the socket iocb (conn_fd_handler) to sock.c conn_fd_handler() is 100% specific to socket code. It's about time it moves to sock.c which manipulates socket FDs. With it comes conn_fd_check() which tests for the socket's readiness. The ugly connection status check at the end of the iocb was moved to an inlined function in connection.h so that if we need it for other socket layers it's not too hard to reuse. The code was really only moved and not changed at all.
2020-12-11 14:54:36 +00:00
goto done;
MEDIUM: fd: merge fdtab[].ev and state for FD_EV_* and FD_POLL_* into state For a long time we've had fdtab[].ev and fdtab[].state which contain two arbitrary sets of information, one is mostly the configuration plus some shutdown reports and the other one is the latest polling status report which also contains some sticky error and shutdown reports. These ones used to be stored into distinct chars, complicating certain operations and not even allowing to clearly see concurrent accesses (e.g. fd_delete_orphan() would set the state to zero while fd_insert() would only set the event to zero). This patch creates a single uint with the two sets in it, still delimited at the byte level for better readability. The original FD_EV_* values remained at the lowest bit levels as they are also known by their bit value. The next step will consist in merging the remaining bits into it. The whole bits are now cleared both in fd_insert() and _fd_delete_orphan() because after a complete check, it is certain that in both cases these functions are the only ones touching these areas. Indeed, for _fd_delete_orphan(), the thread_mask has already been zeroed before a poller can call fd_update_event() which would touch the state, so it is certain that _fd_delete_orphan() is alone. Regarding fd_insert(), only one thread will get an FD at any moment, and it as this FD has already been released by _fd_delete_orphan() by definition it is certain that previous users have definitely stopped touching it. Strictly speaking there's no need for clearing the state again in fd_insert() but it's cheap and will remove some doubts during some troubleshooting sessions.
2021-04-06 15:23:40 +00:00
if ((fdtab[fd].state & (FD_POLL_OUT|FD_POLL_ERR|FD_POLL_HUP)) == FD_POLL_OUT)
REORG: connection: move the socket iocb (conn_fd_handler) to sock.c conn_fd_handler() is 100% specific to socket code. It's about time it moves to sock.c which manipulates socket FDs. With it comes conn_fd_check() which tests for the socket's readiness. The ugly connection status check at the end of the iocb was moved to an inlined function in connection.h so that if we need it for other socket layers it's not too hard to reuse. The code was really only moved and not changed at all.
2020-12-11 14:54:36 +00:00
goto done;
MEDIUM: fd: merge fdtab[].ev and state for FD_EV_* and FD_POLL_* into state For a long time we've had fdtab[].ev and fdtab[].state which contain two arbitrary sets of information, one is mostly the configuration plus some shutdown reports and the other one is the latest polling status report which also contains some sticky error and shutdown reports. These ones used to be stored into distinct chars, complicating certain operations and not even allowing to clearly see concurrent accesses (e.g. fd_delete_orphan() would set the state to zero while fd_insert() would only set the event to zero). This patch creates a single uint with the two sets in it, still delimited at the byte level for better readability. The original FD_EV_* values remained at the lowest bit levels as they are also known by their bit value. The next step will consist in merging the remaining bits into it. The whole bits are now cleared both in fd_insert() and _fd_delete_orphan() because after a complete check, it is certain that in both cases these functions are the only ones touching these areas. Indeed, for _fd_delete_orphan(), the thread_mask has already been zeroed before a poller can call fd_update_event() which would touch the state, so it is certain that _fd_delete_orphan() is alone. Regarding fd_insert(), only one thread will get an FD at any moment, and it as this FD has already been released by _fd_delete_orphan() by definition it is certain that previous users have definitely stopped touching it. Strictly speaking there's no need for clearing the state again in fd_insert() but it's cheap and will remove some doubts during some troubleshooting sessions.
2021-04-06 15:23:40 +00:00
if (!(fdtab[fd].state & (FD_POLL_ERR|FD_POLL_HUP)))
REORG: connection: move the socket iocb (conn_fd_handler) to sock.c conn_fd_handler() is 100% specific to socket code. It's about time it moves to sock.c which manipulates socket FDs. With it comes conn_fd_check() which tests for the socket's readiness. The ugly connection status check at the end of the iocb was moved to an inlined function in connection.h so that if we need it for other socket layers it's not too hard to reuse. The code was really only moved and not changed at all.
2020-12-11 14:54:36 +00:00
goto wait;
/* error present, fall through common error check path */
}
/* Use connect() to check the state of the socket. This has the double
* advantage of *not* clearing the error (so that health checks can
* still use getsockopt(SO_ERROR)) and giving us the following info :
* - error
* - connecting (EALREADY, EINPROGRESS)
* - connected (EISCONN, 0)
*/
addr = conn->dst;
if ((conn->flags & CO_FL_SOCKS4) && obj_type(conn->target) == OBJ_TYPE_SERVER)
addr = &objt_server(conn->target)->socks4_addr;
if (connect(fd, (const struct sockaddr *)addr, get_addr_len(addr)) == -1) {
if (errno == EALREADY || errno == EINPROGRESS)
goto wait;
if (errno && errno != EISCONN)
goto out_error;
}
done:
/* The FD is ready now, we'll mark the connection as complete and
* forward the event to the transport layer which will notify the
* data layer.
*/
conn->flags &= ~CO_FL_WAIT_L4_CONN;
fd_may_send(fd);
fd_cond_recv(fd);
errno = 0; // make health checks happy
return 1;
out_error:
/* Write error on the file descriptor. Report it to the connection
* and disable polling on this FD.
*/
conn->flags |= CO_FL_ERROR | CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH;
MINOR: fd: move .linger_risk into fdtab[].state No need to keep this flag apart any more, let's merge it into the global state. The CLI's output state was extended to 6 digits and the linger/cloned flags moved inside the parenthesis.
2021-04-06 15:49:19 +00:00
HA_ATOMIC_AND(&fdtab[fd].state, ~FD_LINGER_RISK);
REORG: connection: move the socket iocb (conn_fd_handler) to sock.c conn_fd_handler() is 100% specific to socket code. It's about time it moves to sock.c which manipulates socket FDs. With it comes conn_fd_check() which tests for the socket's readiness. The ugly connection status check at the end of the iocb was moved to an inlined function in connection.h so that if we need it for other socket layers it's not too hard to reuse. The code was really only moved and not changed at all.
2020-12-11 14:54:36 +00:00
fd_stop_both(fd);
return 0;
wait:
fd_cant_send(fd);
fd_want_send(fd);
return 0;
}
/* I/O callback for fd-based connections. It calls the read/write handlers
* provided by the connection's sock_ops, which must be valid.
*/
void sock_conn_iocb(int fd)
{
struct connection *conn = fdtab[fd].owner;
unsigned int flags;
int need_wake = 0;
CLEANUP: sock: always perform last connection updates before wakeup Normally the task_wakeup() in sock_conn_io_cb() is expected to happen on the same thread the FD is attached to. But due to the way the code was arranged in the past (with synchronous callbacks) we continue to update connections after the wakeup, which always makes the reader have to think deeply whether it's possible or not to call another thread there. Let's just move the tasklet_wakeup() at the end to make sure there's no problem with that.
2023-03-02 14:07:51 +00:00
struct tasklet *t;
REORG: connection: move the socket iocb (conn_fd_handler) to sock.c conn_fd_handler() is 100% specific to socket code. It's about time it moves to sock.c which manipulates socket FDs. With it comes conn_fd_check() which tests for the socket's readiness. The ugly connection status check at the end of the iocb was moved to an inlined function in connection.h so that if we need it for other socket layers it's not too hard to reuse. The code was really only moved and not changed at all.
2020-12-11 14:54:36 +00:00
if (unlikely(!conn)) {
activity[tid].conn_dead++;
return;
}
flags = conn->flags & ~CO_FL_ERROR; /* ensure to call the wake handler upon error */
if (unlikely(conn->flags & CO_FL_WAIT_L4_CONN) &&
((fd_send_ready(fd) && fd_send_active(fd)) ||
(fd_recv_ready(fd) && fd_recv_active(fd)))) {
/* Still waiting for a connection to establish and nothing was
* attempted yet to probe the connection. this will clear the
* CO_FL_WAIT_L4_CONN flag on success.
*/
if (!sock_conn_check(conn))
goto leave;
need_wake = 1;
}
if (fd_send_ready(fd) && fd_send_active(fd)) {
/* force reporting of activity by clearing the previous flags :
* we'll have at least ERROR or CONNECTED at the end of an I/O,
* both of which will be detected below.
*/
flags = 0;
if (conn->subs && conn->subs->events & SUB_RETRY_SEND) {
CLEANUP: sock: always perform last connection updates before wakeup Normally the task_wakeup() in sock_conn_io_cb() is expected to happen on the same thread the FD is attached to. But due to the way the code was arranged in the past (with synchronous callbacks) we continue to update connections after the wakeup, which always makes the reader have to think deeply whether it's possible or not to call another thread there. Let's just move the tasklet_wakeup() at the end to make sure there's no problem with that.
2023-03-02 14:07:51 +00:00
t = conn->subs->tasklet;
REORG: connection: move the socket iocb (conn_fd_handler) to sock.c conn_fd_handler() is 100% specific to socket code. It's about time it moves to sock.c which manipulates socket FDs. With it comes conn_fd_check() which tests for the socket's readiness. The ugly connection status check at the end of the iocb was moved to an inlined function in connection.h so that if we need it for other socket layers it's not too hard to reuse. The code was really only moved and not changed at all.
2020-12-11 14:54:36 +00:00
need_wake = 0; // wake will be called after this I/O
conn->subs->events &= ~SUB_RETRY_SEND;
if (!conn->subs->events)
conn->subs = NULL;
CLEANUP: sock: always perform last connection updates before wakeup Normally the task_wakeup() in sock_conn_io_cb() is expected to happen on the same thread the FD is attached to. But due to the way the code was arranged in the past (with synchronous callbacks) we continue to update connections after the wakeup, which always makes the reader have to think deeply whether it's possible or not to call another thread there. Let's just move the tasklet_wakeup() at the end to make sure there's no problem with that.
2023-03-02 14:07:51 +00:00
tasklet_wakeup(t);
REORG: connection: move the socket iocb (conn_fd_handler) to sock.c conn_fd_handler() is 100% specific to socket code. It's about time it moves to sock.c which manipulates socket FDs. With it comes conn_fd_check() which tests for the socket's readiness. The ugly connection status check at the end of the iocb was moved to an inlined function in connection.h so that if we need it for other socket layers it's not too hard to reuse. The code was really only moved and not changed at all.
2020-12-11 14:54:36 +00:00
}
fd_stop_send(fd);
}
/* The data transfer starts here and stops on error and handshakes. Note
* that we must absolutely test conn->xprt at each step in case it suddenly
* changes due to a quick unexpected close().
*/
if (fd_recv_ready(fd) && fd_recv_active(fd)) {
/* force reporting of activity by clearing the previous flags :
* we'll have at least ERROR or CONNECTED at the end of an I/O,
* both of which will be detected below.
*/
flags = 0;
if (conn->subs && conn->subs->events & SUB_RETRY_RECV) {
CLEANUP: sock: always perform last connection updates before wakeup Normally the task_wakeup() in sock_conn_io_cb() is expected to happen on the same thread the FD is attached to. But due to the way the code was arranged in the past (with synchronous callbacks) we continue to update connections after the wakeup, which always makes the reader have to think deeply whether it's possible or not to call another thread there. Let's just move the tasklet_wakeup() at the end to make sure there's no problem with that.
2023-03-02 14:07:51 +00:00
t = conn->subs->tasklet;
REORG: connection: move the socket iocb (conn_fd_handler) to sock.c conn_fd_handler() is 100% specific to socket code. It's about time it moves to sock.c which manipulates socket FDs. With it comes conn_fd_check() which tests for the socket's readiness. The ugly connection status check at the end of the iocb was moved to an inlined function in connection.h so that if we need it for other socket layers it's not too hard to reuse. The code was really only moved and not changed at all.
2020-12-11 14:54:36 +00:00
need_wake = 0; // wake will be called after this I/O
conn->subs->events &= ~SUB_RETRY_RECV;
if (!conn->subs->events)
conn->subs = NULL;
CLEANUP: sock: always perform last connection updates before wakeup Normally the task_wakeup() in sock_conn_io_cb() is expected to happen on the same thread the FD is attached to. But due to the way the code was arranged in the past (with synchronous callbacks) we continue to update connections after the wakeup, which always makes the reader have to think deeply whether it's possible or not to call another thread there. Let's just move the tasklet_wakeup() at the end to make sure there's no problem with that.
2023-03-02 14:07:51 +00:00
tasklet_wakeup(t);
REORG: connection: move the socket iocb (conn_fd_handler) to sock.c conn_fd_handler() is 100% specific to socket code. It's about time it moves to sock.c which manipulates socket FDs. With it comes conn_fd_check() which tests for the socket's readiness. The ugly connection status check at the end of the iocb was moved to an inlined function in connection.h so that if we need it for other socket layers it's not too hard to reuse. The code was really only moved and not changed at all.
2020-12-11 14:54:36 +00:00
}
fd_stop_recv(fd);
}
leave:
/* we may have to finish to install a mux or to wake it up based on
* what was just done above. It may kill the connection so we have to
* be prpared not to use it anymore.
*/
if (conn_notify_mux(conn, flags, need_wake) < 0)
return;
/* commit polling changes in case of error.
* WT: it seems that the last case where this could still be relevant
* is if a mux wake function above report a connection error but does
* not stop polling. Shouldn't we enforce this into the mux instead of
* having to deal with this ?
*/
if (unlikely(conn->flags & CO_FL_ERROR)) {
if (conn_ctrl_ready(conn))
fd_stop_both(fd);
}
}
MINOR: protocol: add a ->drain() function at the connection control layer This is what we need to drain pending incoming data from an connection. The code was taken from conn_sock_drain() without the connection-specific stuff. It still takes a connection for now for API simplicity.
2020-12-11 15:19:12 +00:00
/* Drains possibly pending incoming data on the file descriptor attached to the
* connection. This is used to know whether we need to disable lingering on
* close. Returns non-zero if it is safe to close without disabling lingering,
* otherwise zero.
*/
int sock_drain(struct connection *conn)
{
int turns = 2;
int fd = conn->handle.fd;
int len;
MEDIUM: connection: panic when calling FD-specific functions on FD-less conns Certain functions cannot be called on an FD-less conn because they are normally called as part of the protocol-specific setup/teardown sequence. Better place a few BUG_ON() to make sure none of them is called in other situations. If any of them would trigger in ambiguous conditions, it would always be possible to replace it with an error.
2022-04-11 16:07:03 +00:00
BUG_ON(conn->flags & CO_FL_FDLESS);
MEDIUM: fd: merge fdtab[].ev and state for FD_EV_* and FD_POLL_* into state For a long time we've had fdtab[].ev and fdtab[].state which contain two arbitrary sets of information, one is mostly the configuration plus some shutdown reports and the other one is the latest polling status report which also contains some sticky error and shutdown reports. These ones used to be stored into distinct chars, complicating certain operations and not even allowing to clearly see concurrent accesses (e.g. fd_delete_orphan() would set the state to zero while fd_insert() would only set the event to zero). This patch creates a single uint with the two sets in it, still delimited at the byte level for better readability. The original FD_EV_* values remained at the lowest bit levels as they are also known by their bit value. The next step will consist in merging the remaining bits into it. The whole bits are now cleared both in fd_insert() and _fd_delete_orphan() because after a complete check, it is certain that in both cases these functions are the only ones touching these areas. Indeed, for _fd_delete_orphan(), the thread_mask has already been zeroed before a poller can call fd_update_event() which would touch the state, so it is certain that _fd_delete_orphan() is alone. Regarding fd_insert(), only one thread will get an FD at any moment, and it as this FD has already been released by _fd_delete_orphan() by definition it is certain that previous users have definitely stopped touching it. Strictly speaking there's no need for clearing the state again in fd_insert() but it's cheap and will remove some doubts during some troubleshooting sessions.
2021-04-06 15:23:40 +00:00
if (fdtab[fd].state & (FD_POLL_ERR|FD_POLL_HUP))
MINOR: protocol: add a ->drain() function at the connection control layer This is what we need to drain pending incoming data from an connection. The code was taken from conn_sock_drain() without the connection-specific stuff. It still takes a connection for now for API simplicity.
2020-12-11 15:19:12 +00:00
goto shut;
MINOR: connection: add a new CO_FL_WANT_DRAIN flag to force drain on close Sometimes we'd like to do our best to drain pending data before closing in order to save the peer from risking to receive an RST on close. This adds a new connection flag CO_FL_WANT_DRAIN that is used to trigger a call to conn_ctrl_drain() from conn_ctrl_close(), and the sock_drain() function ignores fd_recv_ready() if this flag is set, in order to catch latest data. It's not used for now.
2021-10-21 19:31:42 +00:00
if (!(conn->flags & CO_FL_WANT_DRAIN) && !fd_recv_ready(fd))
MINOR: protocol: add a ->drain() function at the connection control layer This is what we need to drain pending incoming data from an connection. The code was taken from conn_sock_drain() without the connection-specific stuff. It still takes a connection for now for API simplicity.
2020-12-11 15:19:12 +00:00
return 0;
/* no drain function defined, use the generic one */
while (turns) {
#ifdef MSG_TRUNC_CLEARS_INPUT
len = recv(fd, NULL, INT_MAX, MSG_DONTWAIT | MSG_NOSIGNAL | MSG_TRUNC);
if (len == -1 && errno == EFAULT)
#endif
len = recv(fd, trash.area, trash.size, MSG_DONTWAIT | MSG_NOSIGNAL);
if (len == 0)
goto shut;
if (len < 0) {
MINOR: tree-wide: always consider EWOULDBLOCK in addition to EAGAIN Some older systems may routinely return EWOULDBLOCK for some syscalls while we tend to check only for EAGAIN nowadays. Modern systems define EWOULDBLOCK as EAGAIN so that solves it, but on a few older ones (AIX, VMS etc) both are different, and for portability we'd need to test for both or we never know if we risk to confuse some status codes with plain errors. There were few entries, the most annoying ones are the switch/case because they require to only add the entry when it differs, but the other ones are really trivial.
2022-04-25 18:32:15 +00:00
if (errno == EAGAIN || errno == EWOULDBLOCK) {
MINOR: protocol: add a ->drain() function at the connection control layer This is what we need to drain pending incoming data from an connection. The code was taken from conn_sock_drain() without the connection-specific stuff. It still takes a connection for now for API simplicity.
2020-12-11 15:19:12 +00:00
/* connection not closed yet */
fd_cant_recv(fd);
break;
}
if (errno == EINTR) /* oops, try again */
continue;
/* other errors indicate a dead connection, fine. */
goto shut;
}
/* OK we read some data, let's try again once */
turns--;
}
/* some data are still present, give up */
return 0;
shut:
/* we're certain the connection was shut down */
MINOR: fd: move .linger_risk into fdtab[].state No need to keep this flag apart any more, let's merge it into the global state. The CLI's output state was extended to 6 digits and the linger/cloned flags moved inside the parenthesis.
2021-04-06 15:49:19 +00:00
HA_ATOMIC_AND(&fdtab[fd].state, ~FD_LINGER_RISK);
MINOR: protocol: add a ->drain() function at the connection control layer This is what we need to drain pending incoming data from an connection. The code was taken from conn_sock_drain() without the connection-specific stuff. It still takes a connection for now for API simplicity.
2020-12-11 15:19:12 +00:00
return 1;
}
MINOR: protocol: add a pair of check_events/ignore_events functions at the ctrl layer Right now the connection subscribe/unsubscribe code needs to manipulate FDs, which is not compatible with QUIC. In practice what we need there is to be able to either subscribe or wake up depending on readiness at the moment of subscription. This commit introduces two new functions at the control layer, which are provided by the socket code, to check for FD readiness or subscribe to it at the control layer. For now it's not used.
2020-12-11 16:02:50 +00:00
/* Checks the connection's FD for readiness of events <event_type>, which may
* only be a combination of SUB_RETRY_RECV and SUB_RETRY_SEND. Those which are
* ready are returned. The ones that are not ready are enabled. The caller is
* expected to do what is needed to handle ready events and to deal with
* subsequent wakeups caused by the requested events' readiness.
*/
int sock_check_events(struct connection *conn, int event_type)
{
int ret = 0;
MEDIUM: connection: panic when calling FD-specific functions on FD-less conns Certain functions cannot be called on an FD-less conn because they are normally called as part of the protocol-specific setup/teardown sequence. Better place a few BUG_ON() to make sure none of them is called in other situations. If any of them would trigger in ambiguous conditions, it would always be possible to replace it with an error.
2022-04-11 16:07:03 +00:00
BUG_ON(conn->flags & CO_FL_FDLESS);
MINOR: protocol: add a pair of check_events/ignore_events functions at the ctrl layer Right now the connection subscribe/unsubscribe code needs to manipulate FDs, which is not compatible with QUIC. In practice what we need there is to be able to either subscribe or wake up depending on readiness at the moment of subscription. This commit introduces two new functions at the control layer, which are provided by the socket code, to check for FD readiness or subscribe to it at the control layer. For now it's not used.
2020-12-11 16:02:50 +00:00
if (event_type & SUB_RETRY_RECV) {
if (fd_recv_ready(conn->handle.fd))
ret |= SUB_RETRY_RECV;
else
fd_want_recv(conn->handle.fd);
}
if (event_type & SUB_RETRY_SEND) {
if (fd_send_ready(conn->handle.fd))
ret |= SUB_RETRY_SEND;
else
fd_want_send(conn->handle.fd);
}
return ret;
}
/* Ignore readiness events from connection's FD for events of types <event_type>
* which may only be a combination of SUB_RETRY_RECV and SUB_RETRY_SEND.
*/
void sock_ignore_events(struct connection *conn, int event_type)
{
MEDIUM: connection: panic when calling FD-specific functions on FD-less conns Certain functions cannot be called on an FD-less conn because they are normally called as part of the protocol-specific setup/teardown sequence. Better place a few BUG_ON() to make sure none of them is called in other situations. If any of them would trigger in ambiguous conditions, it would always be possible to replace it with an error.
2022-04-11 16:07:03 +00:00
BUG_ON(conn->flags & CO_FL_FDLESS);
MINOR: protocol: add a pair of check_events/ignore_events functions at the ctrl layer Right now the connection subscribe/unsubscribe code needs to manipulate FDs, which is not compatible with QUIC. In practice what we need there is to be able to either subscribe or wake up depending on readiness at the moment of subscription. This commit introduces two new functions at the control layer, which are provided by the socket code, to check for FD readiness or subscribe to it at the control layer. For now it's not used.
2020-12-11 16:02:50 +00:00
if (event_type & SUB_RETRY_RECV)
fd_stop_recv(conn->handle.fd);
if (event_type & SUB_RETRY_SEND)
fd_stop_send(conn->handle.fd);
}
MINOR: sock: add a function to check for SO_REUSEPORT support at runtime The new function _sock_supports_reuseport() will be used to check if a protocol type supports SO_REUSEPORT or not. This will be useful to verify that shards can really work.
2023-04-22 16:25:09 +00:00
/* Live check to see if a socket type supports SO_REUSEPORT for the specified
* family and socket() settings. Returns non-zero on success, 0 on failure. Use
* protocol_supports_flag() instead, which checks cached flags.
*/
int _sock_supports_reuseport(const struct proto_fam *fam, int type, int protocol)
{
int ret = 0;
#ifdef SO_REUSEPORT
struct sockaddr_storage ss;
socklen_t sl = sizeof(ss);
int fd1, fd2;
/* for the check, we'll need two sockets */
fd1 = fd2 = -1;
/* ignore custom sockets */
if (!fam || fam->sock_domain >= AF_MAX)
goto leave;
fd1 = socket(fam->sock_domain, type, protocol);
if (fd1 < 0)
goto leave;
if (setsockopt(fd1, SOL_SOCKET, SO_REUSEPORT, &one, sizeof(one)) < 0)
goto leave;
/* bind to any address assigned by the kernel, we'll then try to do it twice */
memset(&ss, 0, sizeof(ss));
ss.ss_family = fam->sock_family;
if (bind(fd1, (struct sockaddr *)&ss, fam->sock_addrlen) < 0)
goto leave;
if (getsockname(fd1, (struct sockaddr *)&ss, &sl) < 0)
goto leave;
fd2 = socket(fam->sock_domain, type, protocol);
if (fd2 < 0)
goto leave;
if (setsockopt(fd2, SOL_SOCKET, SO_REUSEPORT, &one, sizeof(one)) < 0)
goto leave;
if (bind(fd2, (struct sockaddr *)&ss, sl) < 0)
goto leave;
/* OK we could bind twice to the same address:port, REUSEPORT
* is supported for this protocol.
*/
ret = 1;
leave:
if (fd2 >= 0)
close(fd2);
if (fd1 >= 0)
close(fd1);
#endif
return ret;
}
REORG: sock: start to move some generic socket code to sock.c The new file sock.c will contain generic code for standard sockets relying on file descriptors. We currently have way too much duplication between proto_uxst, proto_tcp, proto_sockpair and proto_udp. For now only get_src, get_dst and sock_create_server_socket were moved, and are used where appropriate.
2020-08-28 10:07:22 +00:00
/*
* Local variables:
* c-indent-level: 8
* c-basic-offset: 8
* End:
*/
Reference in New Issue Copy Permalink