upstream/haproxy
1
0
Fork 0
mirror of https://github.com/haproxy/haproxy.git synced 2026-02-03 20:39:41 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions 3
haproxy/src/protocol.c

310 lines
8.8 KiB
C
Raw Permalink Normal View History

REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
/*
* Protocol registration functions.
*
* Copyright 2000-2012 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.
*
*/
BUILD: protocol: fix some build errors on OpenBSD Building 1.6 and above on OpenBSD 5.2 fails due to protocol.c not including sys/types.h before sys/socket.h : In file included from src/protocol.c:14: /usr/include/sys/socket.h:162: error: expected specifier-qualifier-list before 'u_int8_t' This fix needs to be backported to 1.6.
2016-08-10 12:24:48 -04:00
#include <sys/types.h>
MEDIUM: protocol: use a family array to index the protocol handlers Instead of walking over a list, we now have a direct mapping between protocol families and their respective handlers. This will allow fast lookups.
2015-02-20 10:53:25 -05:00
#include <sys/socket.h>
REORG: include: update all files to use haproxy/api.h or api-t.h if needed All files that were including one of the following include files have been updated to only include haproxy/api.h or haproxy/api-t.h once instead: - common/config.h - common/compat.h - common/compiler.h - common/defaults.h - common/initcall.h - common/tools.h The choice is simple: if the file only requires type definitions, it includes api-t.h, otherwise it includes the full api.h. In addition, in these files, explicit includes for inttypes.h and limits.h were dropped since these are now covered by api.h and api-t.h. No other change was performed, given that this patch is large and affects 201 files. At least one (tools.h) was already freestanding and didn't get the new one added.
2020-05-27 06:58:42 -04:00
#include <haproxy/api.h>
REORG: include: move base64.h, errors.h and hash.h from common to to haproxy/ These ones do not depend on any other file. One used to include haproxy/api.h but that was solely for stddef.h.
2020-05-27 10:10:29 -04:00
#include <haproxy/errors.h>
MINOR: quic: Add "no-quic" global option Add "no-quic" to "global" section to disable the use of QUIC transport protocol by all configured QUIC listeners. This is listeners with QUIC addresses on their "bind" lines. Internally, the socket addresses binding is skipped by protocol_bind_all() for receivers with <proto_quic4> or <proto_quic6> as protocol (see protocol struct). Add information about "no-quic" global option to the documentation. Must be backported to 2.7.
2023-01-12 09:23:54 -05:00
#include <haproxy/global.h>
REORG: include: split mini-clist into haproxy/list and list-t.h Half of the users of this include only need the type definitions and not the manipulation macros nor the inline functions. Moves the various types into mini-clist-t.h makes the files cleaner. The other one had all its includes grouped at the top. A few files continued to reference it without using it and were cleaned. In addition it was about time that we'd rename that file, it's not "mini" anymore and contains a bit more than just circular lists.
2020-05-27 12:01:47 -04:00
#include <haproxy/list.h>
MINOR: protocol: do not call proto->bind_all() anymore All protocols only iterate over their own listeners list and start the listeners using a direct call to their ->bind() function. This code duplication doesn't make sense and prevents us from centralizing the startup error handling. Worse, it's not even symmetric because there's an unbind_all_listeners() function common to all protocols without any equivalent for binding. Let's start by directly calling each protocol's bind() function from protocol_bind_all().
2020-09-01 12:48:35 -04:00
#include <haproxy/listener.h>
MINOR: quic: Add "no-quic" global option Add "no-quic" to "global" section to disable the use of QUIC transport protocol by all configured QUIC listeners. This is listeners with QUIC addresses on their "bind" lines. Internally, the socket addresses binding is skipped by protocol_bind_all() for receivers with <proto_quic4> or <proto_quic6> as protocol (see protocol struct). Add information about "no-quic" global option to the documentation. Must be backported to 2.7.
2023-01-12 09:23:54 -05:00
#include <haproxy/proto_quic.h>
CLEANUP: include: tree-wide alphabetical sort of include files This patch fixes all the leftovers from the include cleanup campaign. There were not that many (~400 entries in ~150 files) but it was definitely worth doing it as it revealed a few duplicates.
2020-06-09 03:07:15 -04:00
#include <haproxy/protocol.h>
MAJOR: init: start all listeners via protocols and not via proxies anymore Ever since the protocols were added in 1.3.13, listeners used to be started twice: - once by start_proxies(), which iteratees over all proxies then all listeners ; - once by protocol_bind_all() which iterates over all protocols then all listeners ; It's a real mess because error reporting is not even consistent, and more importantly now that some protocols do not appear in regular proxies (peers, logs), there is no way to retry their binding should it fail on the last step. What this patch does is to make sure that listeners are exclusively started by protocols. The failure to start a listener now causes the emission of an error indicating the proxy's name (as it used to be the case per proxy), and retryable failures are silently ignored during all but last attempts. The start_proxies() function was kept solely for setting the proxy's state to READY and emitting the "Proxy started" message and log that some have likely got used to seeking in their logs.
2020-09-02 05:11:43 -04:00
#include <haproxy/proxy.h>
MINOR: protocol: perform a live check for SO_REUSEPORT support When testing if a protocol supports SO_REUSEPORT, we're now able to verify if the OS does really support it. While it may be supported at build time, it may possibly have been blocked in a container for example so we'd rather know what it's like.
2023-04-22 12:26:56 -04:00
#include <haproxy/sock.h>
REORG: tools: split common/standard.h into haproxy/tools{,-t}.h And also rename standard.c to tools.c. The original split between tools.h and standard.h dates from version 1.3-dev and was mostly an accident. This patch moves the files back to what they were expected to be, and takes care of not changing anything else. However this time tools.h was split between functions and types, because it contains a small number of commonly used macros and structures (e.g. name_desc) which in turn cause the massive list of includes of tools.h to conflict with the callers. They remain the ugliest files of the whole project and definitely need to be cleaned and split apart. A few types are defined there only for functions provided there, and some parts are even OS-specific and should move somewhere else, such as the symbol resolution code.
2020-06-03 12:09:46 -04:00
#include <haproxy/tools.h>
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
/* List head of all registered protocols */
static struct list protocols = LIST_HEAD_INIT(protocols);
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 11:28:55 -04:00
struct protocol *__protocol_by_family[AF_CUST_MAX][PROTO_NUM_TYPES][2] __read_mostly = { };
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
BUG/MEDIUM: protocols: add a global lock for the init/deinit stuff Dragan Dosen found that the listeners lock is not sufficient to protect the listeners list when proxies are stopping because the listeners are also unlinked from the protocol list, and under certain situations like bombing with soft-stop signals or shutting down many frontends in parallel from multiple CLI connections, it could be possible to provoke multiple instances of delete_listener() to be called in parallel for different listeners, thus corrupting the protocol lists. Such operations are pretty rare, they are performed once per proxy upon startup and once per proxy on shut down. Thus there is no point trying to optimize anything and we can use a global lock to protect the protocol lists during these manipulations. This fix (or a variant) will have to be backported as far as 1.8.
2019-07-24 10:45:02 -04:00
/* This is the global spinlock we may need to register/unregister listeners or
* protocols. Its main purpose is in fact to serialize the rare stop/deinit()
* phases.
*/
__decl_spinlock(proto_lock);
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
/* Registers the protocol <proto> */
void protocol_register(struct protocol *proto)
{
DEBUG: protocol: yell loudly during registration of invalid sock_domain The test on the sock_domain is a bit useless because the protocols are registered at boot time, and the test silently fails and returns no error. Use a BUG_ON() instead to make sure to catch such bugs in the code if any.
2021-10-27 09:06:35 -04:00
int sock_domain = proto->fam->sock_domain;
BUG_ON(sock_domain < 0 || sock_domain >= AF_CUST_MAX);
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 11:28:55 -04:00
BUG_ON(proto->proto_type >= PROTO_NUM_TYPES);
DEBUG: protocol: yell loudly during registration of invalid sock_domain The test on the sock_domain is a bit useless because the protocols are registered at boot time, and the test silently fails and returns no error. Use a BUG_ON() instead to make sure to catch such bugs in the code if any.
2021-10-27 09:06:35 -04:00
BUG/MEDIUM: protocols: add a global lock for the init/deinit stuff Dragan Dosen found that the listeners lock is not sufficient to protect the listeners list when proxies are stopping because the listeners are also unlinked from the protocol list, and under certain situations like bombing with soft-stop signals or shutting down many frontends in parallel from multiple CLI connections, it could be possible to provoke multiple instances of delete_listener() to be called in parallel for different listeners, thus corrupting the protocol lists. Such operations are pretty rare, they are performed once per proxy upon startup and once per proxy on shut down. Thus there is no point trying to optimize anything and we can use a global lock to protect the protocol lists during these manipulations. This fix (or a variant) will have to be backported as far as 1.8.
2019-07-24 10:45:02 -04:00
HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
CLEANUP: lists/tree-wide: rename some list operations to avoid some confusion The current "ADD" vs "ADDQ" is confusing because when thinking in terms of appending at the end of a list, "ADD" naturally comes to mind, but here it does the opposite, it inserts. Several times already it's been incorrectly used where ADDQ was expected, the latest of which was a fortunate accident explained in 6fa922562 ("CLEANUP: stream: explain why we queue the stream at the head of the server list"). Let's use more explicit (but slightly longer) names now: LIST_ADD -> LIST_INSERT LIST_ADDQ -> LIST_APPEND LIST_ADDED -> LIST_INLIST LIST_DEL -> LIST_DELETE The same is true for MT_LISTs, including their "TRY" variant. LIST_DEL_INIT keeps its short name to encourage to use it instead of the lazier LIST_DELETE which is often less safe. The change is large (~674 non-comment entries) but is mechanical enough to remain safe. No permutation was performed, so any out-of-tree code can easily map older names to new ones. The list doc was updated.
2021-04-21 01:32:39 -04:00
LIST_APPEND(&protocols, &proto->list);
DEBUG: protocol: yell loudly during registration of invalid sock_domain The test on the sock_domain is a bit useless because the protocols are registered at boot time, and the test silently fails and returns no error. Use a BUG_ON() instead to make sure to catch such bugs in the code if any.
2021-10-27 09:06:35 -04:00
__protocol_by_family[sock_domain]
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 11:28:55 -04:00
[proto->proto_type]
MINOR: protocol: replace ctrl_type with xprt_type and clarify it There's been some great confusion between proto_type, ctrl_type and sock_type. It turns out that ctrl_type was improperly chosen because it's not the control layer that is of this or that type, but the transport layer, and it turns out that the transport layer doesn't (normally) denaturate the underlying control layer, except for QUIC which turns dgrams to streams. The fact that the SOCK_{DGRAM|STREAM} set of values was used added to the confusion. Let's replace it with xprt_type which reuses the later introduced PROTO_TYPE_* values, and update the comments to explain which one works at what level.
2022-05-20 10:36:46 -04:00
[proto->xprt_type == PROTO_TYPE_DGRAM] = proto;
BUG/MEDIUM: protocols: add a global lock for the init/deinit stuff Dragan Dosen found that the listeners lock is not sufficient to protect the listeners list when proxies are stopping because the listeners are also unlinked from the protocol list, and under certain situations like bombing with soft-stop signals or shutting down many frontends in parallel from multiple CLI connections, it could be possible to provoke multiple instances of delete_listener() to be called in parallel for different listeners, thus corrupting the protocol lists. Such operations are pretty rare, they are performed once per proxy upon startup and once per proxy on shut down. Thus there is no point trying to optimize anything and we can use a global lock to protect the protocol lists during these manipulations. This fix (or a variant) will have to be backported as far as 1.8.
2019-07-24 10:45:02 -04:00
HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
}
/* Unregisters the protocol <proto>. Note that all listeners must have
* previously been unbound.
*/
void protocol_unregister(struct protocol *proto)
{
BUG/MEDIUM: protocols: add a global lock for the init/deinit stuff Dragan Dosen found that the listeners lock is not sufficient to protect the listeners list when proxies are stopping because the listeners are also unlinked from the protocol list, and under certain situations like bombing with soft-stop signals or shutting down many frontends in parallel from multiple CLI connections, it could be possible to provoke multiple instances of delete_listener() to be called in parallel for different listeners, thus corrupting the protocol lists. Such operations are pretty rare, they are performed once per proxy upon startup and once per proxy on shut down. Thus there is no point trying to optimize anything and we can use a global lock to protect the protocol lists during these manipulations. This fix (or a variant) will have to be backported as far as 1.8.
2019-07-24 10:45:02 -04:00
HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
CLEANUP: lists/tree-wide: rename some list operations to avoid some confusion The current "ADD" vs "ADDQ" is confusing because when thinking in terms of appending at the end of a list, "ADD" naturally comes to mind, but here it does the opposite, it inserts. Several times already it's been incorrectly used where ADDQ was expected, the latest of which was a fortunate accident explained in 6fa922562 ("CLEANUP: stream: explain why we queue the stream at the head of the server list"). Let's use more explicit (but slightly longer) names now: LIST_ADD -> LIST_INSERT LIST_ADDQ -> LIST_APPEND LIST_ADDED -> LIST_INLIST LIST_DEL -> LIST_DELETE The same is true for MT_LISTs, including their "TRY" variant. LIST_DEL_INIT keeps its short name to encourage to use it instead of the lazier LIST_DELETE which is often less safe. The change is large (~674 non-comment entries) but is mechanical enough to remain safe. No permutation was performed, so any out-of-tree code can easily map older names to new ones. The list doc was updated.
2021-04-21 01:32:39 -04:00
LIST_DELETE(&proto->list);
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
LIST_INIT(&proto->list);
BUG/MEDIUM: protocols: add a global lock for the init/deinit stuff Dragan Dosen found that the listeners lock is not sufficient to protect the listeners list when proxies are stopping because the listeners are also unlinked from the protocol list, and under certain situations like bombing with soft-stop signals or shutting down many frontends in parallel from multiple CLI connections, it could be possible to provoke multiple instances of delete_listener() to be called in parallel for different listeners, thus corrupting the protocol lists. Such operations are pretty rare, they are performed once per proxy upon startup and once per proxy on shut down. Thus there is no point trying to optimize anything and we can use a global lock to protect the protocol lists during these manipulations. This fix (or a variant) will have to be backported as far as 1.8.
2019-07-24 10:45:02 -04:00
HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
}
MINOR: protocol: add a flags field to store info about protocols We'll use these flags to know if some protocols are supported, and if so, with what options/extensions. Reuseport will move there for example. Two functions were added to globally set/clear a flag.
2023-04-22 09:02:35 -04:00
/* clears flag <flag> on all protocols. */
void protocol_clrf_all(uint flag)
{
struct protocol *proto;
HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
list_for_each_entry(proto, &protocols, list)
proto->flags &= ~flag;
HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
}
/* sets flag <flag> on all protocols. */
void protocol_setf_all(uint flag)
{
struct protocol *proto;
HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
list_for_each_entry(proto, &protocols, list)
proto->flags |= flag;
HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
}
MINOR: protocol: add a function to check if some features are supported The new function protocol_supports_flag() checks the protocol flags to verify if some features are supported, but will support being extended to refine the tests. Let's use it to check for REUSEPORT.
2023-04-22 11:39:30 -04:00
/* Checks if protocol <proto> supports PROTO_F flag <flag>. Returns zero if not,
* non-zero if supported. It may return a cached value from a previous test,
* and may run live tests then update the proto's flags to cache a result. It's
* better to call it only if needed so that it doesn't result in modules being
* loaded in case of a live test. It is only supposed to be used during boot.
*/
int protocol_supports_flag(struct protocol *proto, uint flag)
{
if (flag == PROTO_F_REUSEPORT_SUPPORTED) {
MINOR: protocol: perform a live check for SO_REUSEPORT support When testing if a protocol supports SO_REUSEPORT, we're now able to verify if the OS does really support it. While it may be supported at build time, it may possibly have been blocked in a container for example so we'd rather know what it's like.
2023-04-22 12:26:56 -04:00
int ret = 0;
MINOR: protocol: add a function to check if some features are supported The new function protocol_supports_flag() checks the protocol flags to verify if some features are supported, but will support being extended to refine the tests. Let's use it to check for REUSEPORT.
2023-04-22 11:39:30 -04:00
/* check if the protocol supports SO_REUSEPORT */
if (!(_HA_ATOMIC_LOAD(&proto->flags) & PROTO_F_REUSEPORT_SUPPORTED))
return 0;
MINOR: protocol: perform a live check for SO_REUSEPORT support When testing if a protocol supports SO_REUSEPORT, we're now able to verify if the OS does really support it. While it may be supported at build time, it may possibly have been blocked in a container for example so we'd rather know what it's like.
2023-04-22 12:26:56 -04:00
/* at least nobody said it was not supported */
if (_HA_ATOMIC_LOAD(&proto->flags) & PROTO_F_REUSEPORT_TESTED)
return 1;
/* run a live check */
ret = _sock_supports_reuseport(proto->fam, proto->sock_type, proto->sock_prot);
if (!ret)
_HA_ATOMIC_AND(&proto->flags, ~PROTO_F_REUSEPORT_SUPPORTED);
_HA_ATOMIC_OR(&proto->flags, PROTO_F_REUSEPORT_TESTED);
return ret;
MINOR: protocol: add a function to check if some features are supported The new function protocol_supports_flag() checks the protocol flags to verify if some features are supported, but will support being extended to refine the tests. Let's use it to check for REUSEPORT.
2023-04-22 11:39:30 -04:00
}
return 0;
}
MINOR: quic: Add "limited-quic" new tuning setting This setting which may be used into a "global" section, enables the QUIC listener bindings when haproxy is compiled with the OpenSSL wrapper. It has no effect when haproxy is compiled against a TLS stack with QUIC support, typically quictls.
2023-07-21 12:22:38 -04:00
#ifdef USE_QUIC
/* Return 1 if QUIC protocol may be bound, 0 if no, depending on the tuning
* parameters.
*/
MINOR: quic: Warning for OpenSSL wrapper QUIC bindings without "limited-quic" If the "limited-quic" globale option wa not set, the QUIC listener bindings were not bound, this is ok, but silently ignored. Add a warning in these cases to ask the user to explicitely enable the QUIC bindings when building QUIC support against a TLS/SSL library without QUIC support (OpenSSL).
2023-08-08 05:41:13 -04:00
static inline int protocol_may_bind_quic(struct listener *l)
MINOR: quic: Add "limited-quic" new tuning setting This setting which may be used into a "global" section, enables the QUIC listener bindings when haproxy is compiled with the OpenSSL wrapper. It has no effect when haproxy is compiled against a TLS stack with QUIC support, typically quictls.
2023-07-21 12:22:38 -04:00
{
if (global.tune.options & GTUNE_NO_QUIC)
return 0;
return 1;
}
#endif
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
/* binds all listeners of all registered protocols. Returns a composition
* of ERR_NONE, ERR_RETRYABLE, ERR_FATAL.
*/
MAJOR: init: start all listeners via protocols and not via proxies anymore Ever since the protocols were added in 1.3.13, listeners used to be started twice: - once by start_proxies(), which iteratees over all proxies then all listeners ; - once by protocol_bind_all() which iterates over all protocols then all listeners ; It's a real mess because error reporting is not even consistent, and more importantly now that some protocols do not appear in regular proxies (peers, logs), there is no way to retry their binding should it fail on the last step. What this patch does is to make sure that listeners are exclusively started by protocols. The failure to start a listener now causes the emission of an error indicating the proxy's name (as it used to be the case per proxy), and retryable failures are silently ignored during all but last attempts. The start_proxies() function was kept solely for setting the proxy's state to READY and emitting the "Proxy started" message and log that some have likely got used to seeking in their logs.
2020-09-02 05:11:43 -04:00
int protocol_bind_all(int verbose)
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
{
struct protocol *proto;
MINOR: protocol: do not call proto->bind_all() anymore All protocols only iterate over their own listeners list and start the listeners using a direct call to their ->bind() function. This code duplication doesn't make sense and prevents us from centralizing the startup error handling. Worse, it's not even symmetric because there's an unbind_all_listeners() function common to all protocols without any equivalent for binding. Let's start by directly calling each protocol's bind() function from protocol_bind_all().
2020-09-01 12:48:35 -04:00
struct listener *listener;
MEDIUM: protocol: explicitly start the receiver before the listener Now protocol_bind_all() starts the receivers before their respective listeners so that ultimately we won't need the listeners for non- connected protocols. We still have to resort to an ugly trick to set the I/O handler in case of syslog over UDP because for now it's still not set in the receiver, so we hard-code it.
2020-09-02 12:22:11 -04:00
struct receiver *receiver;
MINOR: proto_tcp: use chunk_appendf() to ouput socket setup errors Right now only the last warning or error is reported from tcp_bind_listener(), but it is useful to report all warnings and no only the last one, so we now emit them delimited by commas. Previously we used a fixed buffer of 100 bytes, which was too small to store more than one message, so let's extend it. Signed-off-by: Bjoern Jacke <bjacke@samba.org>
2021-01-12 13:24:43 -05:00
char msg[1000];
MEDIUM: protocol: explicitly start the receiver before the listener Now protocol_bind_all() starts the receivers before their respective listeners so that ultimately we won't need the listeners for non- connected protocols. We still have to resort to an ugly trick to set the I/O handler in case of syslog over UDP because for now it's still not set in the receiver, so we hard-code it.
2020-09-02 12:22:11 -04:00
char *errmsg;
MAJOR: init: start all listeners via protocols and not via proxies anymore Ever since the protocols were added in 1.3.13, listeners used to be started twice: - once by start_proxies(), which iteratees over all proxies then all listeners ; - once by protocol_bind_all() which iterates over all protocols then all listeners ; It's a real mess because error reporting is not even consistent, and more importantly now that some protocols do not appear in regular proxies (peers, logs), there is no way to retry their binding should it fail on the last step. What this patch does is to make sure that listeners are exclusively started by protocols. The failure to start a listener now causes the emission of an error indicating the proxy's name (as it used to be the case per proxy), and retryable failures are silently ignored during all but last attempts. The start_proxies() function was kept solely for setting the proxy's state to READY and emitting the "Proxy started" message and log that some have likely got used to seeking in their logs.
2020-09-02 05:11:43 -04:00
int err, lerr;
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
err = 0;
BUG/MEDIUM: protocols: add a global lock for the init/deinit stuff Dragan Dosen found that the listeners lock is not sufficient to protect the listeners list when proxies are stopping because the listeners are also unlinked from the protocol list, and under certain situations like bombing with soft-stop signals or shutting down many frontends in parallel from multiple CLI connections, it could be possible to provoke multiple instances of delete_listener() to be called in parallel for different listeners, thus corrupting the protocol lists. Such operations are pretty rare, they are performed once per proxy upon startup and once per proxy on shut down. Thus there is no point trying to optimize anything and we can use a global lock to protect the protocol lists during these manipulations. This fix (or a variant) will have to be backported as far as 1.8.
2019-07-24 10:45:02 -04:00
HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
list_for_each_entry(proto, &protocols, list) {
MINOR: protocol: rename the ->listeners field to ->receivers Since the listeners were split into receiver+listener, this field ought to have been renamed because it's confusing. It really links receivers and not listeners, as most of the time it's used via rx.proto_list! The nb_listeners field was updated accordingly.
2020-09-25 11:01:43 -04:00
list_for_each_entry(receiver, &proto->receivers, proto_list) {
MINOR: quic: Warning for OpenSSL wrapper QUIC bindings without "limited-quic" If the "limited-quic" globale option wa not set, the QUIC listener bindings were not bound, this is ok, but silently ignored. Add a warning in these cases to ask the user to explicitely enable the QUIC bindings when building QUIC support against a TLS/SSL library without QUIC support (OpenSSL).
2023-08-08 05:41:13 -04:00
listener = LIST_ELEM(receiver, struct listener *, rx);
MINOR: quic: Add "no-quic" global option Add "no-quic" to "global" section to disable the use of QUIC transport protocol by all configured QUIC listeners. This is listeners with QUIC addresses on their "bind" lines. Internally, the socket addresses binding is skipped by protocol_bind_all() for receivers with <proto_quic4> or <proto_quic6> as protocol (see protocol struct). Add information about "no-quic" global option to the documentation. Must be backported to 2.7.
2023-01-12 09:23:54 -05:00
#ifdef USE_QUIC
MINOR: quic: Add "limited-quic" new tuning setting This setting which may be used into a "global" section, enables the QUIC listener bindings when haproxy is compiled with the OpenSSL wrapper. It has no effect when haproxy is compiled against a TLS stack with QUIC support, typically quictls.
2023-07-21 12:22:38 -04:00
if ((proto == &proto_quic4 || proto == &proto_quic6) &&
MINOR: quic: Warning for OpenSSL wrapper QUIC bindings without "limited-quic" If the "limited-quic" globale option wa not set, the QUIC listener bindings were not bound, this is ok, but silently ignored. Add a warning in these cases to ask the user to explicitely enable the QUIC bindings when building QUIC support against a TLS/SSL library without QUIC support (OpenSSL).
2023-08-08 05:41:13 -04:00
!protocol_may_bind_quic(listener))
MINOR: quic: Add "no-quic" global option Add "no-quic" to "global" section to disable the use of QUIC transport protocol by all configured QUIC listeners. This is listeners with QUIC addresses on their "bind" lines. Internally, the socket addresses binding is skipped by protocol_bind_all() for receivers with <proto_quic4> or <proto_quic6> as protocol (see protocol struct). Add information about "no-quic" global option to the documentation. Must be backported to 2.7.
2023-01-12 09:23:54 -05:00
continue;
#endif
MEDIUM: protocol: explicitly start the receiver before the listener Now protocol_bind_all() starts the receivers before their respective listeners so that ultimately we won't need the listeners for non- connected protocols. We still have to resort to an ugly trick to set the I/O handler in case of syslog over UDP because for now it's still not set in the receiver, so we hard-code it.
2020-09-02 12:22:11 -04:00
CLEANUP: protocol: remove the now unused <handler> field of proto_fam->bind() We don't need to specify the handler anymore since it's set in the receiver. Let's remove this argument from the function and clean up the remains of code that were still setting it.
2020-10-15 15:45:15 -04:00
lerr = proto->fam->bind(receiver, &errmsg);
MEDIUM: protocol: explicitly start the receiver before the listener Now protocol_bind_all() starts the receivers before their respective listeners so that ultimately we won't need the listeners for non- connected protocols. We still have to resort to an ugly trick to set the I/O handler in case of syslog over UDP because for now it's still not set in the receiver, so we hard-code it.
2020-09-02 12:22:11 -04:00
err |= lerr;
MAJOR: init: start all listeners via protocols and not via proxies anymore Ever since the protocols were added in 1.3.13, listeners used to be started twice: - once by start_proxies(), which iteratees over all proxies then all listeners ; - once by protocol_bind_all() which iterates over all protocols then all listeners ; It's a real mess because error reporting is not even consistent, and more importantly now that some protocols do not appear in regular proxies (peers, logs), there is no way to retry their binding should it fail on the last step. What this patch does is to make sure that listeners are exclusively started by protocols. The failure to start a listener now causes the emission of an error indicating the proxy's name (as it used to be the case per proxy), and retryable failures are silently ignored during all but last attempts. The start_proxies() function was kept solely for setting the proxy's state to READY and emitting the "Proxy started" message and log that some have likely got used to seeking in their logs.
2020-09-02 05:11:43 -04:00
/* errors are reported if <verbose> is set or if they are fatal */
if (verbose || (lerr & (ERR_FATAL | ERR_ABORT))) {
struct proxy *px = listener->bind_conf->frontend;
if (lerr & ERR_ALERT)
MINOR: protocol: report the file and line number for binding/listening errors Binding errors and late socket errors provide no information about the file and line where the problem occurs. These are all done by protocol_bind_all() and they only report "Starting proxy blah". Let's change this a little bit so that: - the file name and line number of the faulty bind line is alwas mentioned - early binding errors are indicated with "Binding" instead of "Starting". Now we can for example have this: [WARNING] (18580) : Binding [binderr.cfg:10] for proxy http: cannot bind receiver to device 'eth2' (No such device) [0.0.0.0:1080]
2021-10-14 05:55:48 -04:00
ha_alert("Binding [%s:%d] for %s %s: %s\n",
listener->bind_conf->file, listener->bind_conf->line,
MEDIUM: protocol: explicitly start the receiver before the listener Now protocol_bind_all() starts the receivers before their respective listeners so that ultimately we won't need the listeners for non- connected protocols. We still have to resort to an ugly trick to set the I/O handler in case of syslog over UDP because for now it's still not set in the receiver, so we hard-code it.
2020-09-02 12:22:11 -04:00
proxy_type_str(px), px->id, errmsg);
MAJOR: init: start all listeners via protocols and not via proxies anymore Ever since the protocols were added in 1.3.13, listeners used to be started twice: - once by start_proxies(), which iteratees over all proxies then all listeners ; - once by protocol_bind_all() which iterates over all protocols then all listeners ; It's a real mess because error reporting is not even consistent, and more importantly now that some protocols do not appear in regular proxies (peers, logs), there is no way to retry their binding should it fail on the last step. What this patch does is to make sure that listeners are exclusively started by protocols. The failure to start a listener now causes the emission of an error indicating the proxy's name (as it used to be the case per proxy), and retryable failures are silently ignored during all but last attempts. The start_proxies() function was kept solely for setting the proxy's state to READY and emitting the "Proxy started" message and log that some have likely got used to seeking in their logs.
2020-09-02 05:11:43 -04:00
else if (lerr & ERR_WARN)
MINOR: protocol: report the file and line number for binding/listening errors Binding errors and late socket errors provide no information about the file and line where the problem occurs. These are all done by protocol_bind_all() and they only report "Starting proxy blah". Let's change this a little bit so that: - the file name and line number of the faulty bind line is alwas mentioned - early binding errors are indicated with "Binding" instead of "Starting". Now we can for example have this: [WARNING] (18580) : Binding [binderr.cfg:10] for proxy http: cannot bind receiver to device 'eth2' (No such device) [0.0.0.0:1080]
2021-10-14 05:55:48 -04:00
ha_warning("Binding [%s:%d] for %s %s: %s\n",
listener->bind_conf->file, listener->bind_conf->line,
MEDIUM: protocol: explicitly start the receiver before the listener Now protocol_bind_all() starts the receivers before their respective listeners so that ultimately we won't need the listeners for non- connected protocols. We still have to resort to an ugly trick to set the I/O handler in case of syslog over UDP because for now it's still not set in the receiver, so we hard-code it.
2020-09-02 12:22:11 -04:00
proxy_type_str(px), px->id, errmsg);
MAJOR: init: start all listeners via protocols and not via proxies anymore Ever since the protocols were added in 1.3.13, listeners used to be started twice: - once by start_proxies(), which iteratees over all proxies then all listeners ; - once by protocol_bind_all() which iterates over all protocols then all listeners ; It's a real mess because error reporting is not even consistent, and more importantly now that some protocols do not appear in regular proxies (peers, logs), there is no way to retry their binding should it fail on the last step. What this patch does is to make sure that listeners are exclusively started by protocols. The failure to start a listener now causes the emission of an error indicating the proxy's name (as it used to be the case per proxy), and retryable failures are silently ignored during all but last attempts. The start_proxies() function was kept solely for setting the proxy's state to READY and emitting the "Proxy started" message and log that some have likely got used to seeking in their logs.
2020-09-02 05:11:43 -04:00
}
BUG/MINOR: protocol: fix minor memory leak in protocol_bind_all() In protocol_bind_all() (involved in startup sequence): We only free errmsg (set by fam->bind() attempt) when we make use of it. But this could lead to some memory leaks because there are some cases where we ignore the error message (e.g: verbose=0 with ERR_WARN messages). As long as errmsg is set, we should always free it. As mentioned earlier, this really is a minor leak because it can only occur on specific conditions (error paths) during the startup phase. This may be backported up to 2.4. -- Backport notes: -> 2.4 only: Replace this: | ha_warning("Binding [%s:%d] for %s %s: %s\n", | listener->bind_conf->file, listener->bind_conf->line, | proxy_type_str(px), px->id, errmsg); By this: | else if (lerr & ERR_WARN) | ha_warning("Starting %s %s: %s\n", | proxy_type_str(px), px->id, errmsg);
2023-02-07 09:51:58 -05:00
if (lerr != ERR_NONE)
ha_free(&errmsg);
MEDIUM: protocol: explicitly start the receiver before the listener Now protocol_bind_all() starts the receivers before their respective listeners so that ultimately we won't need the listeners for non- connected protocols. We still have to resort to an ugly trick to set the I/O handler in case of syslog over UDP because for now it's still not set in the receiver, so we hard-code it.
2020-09-02 12:22:11 -04:00
if (lerr & ERR_ABORT)
break;
MAJOR: init: start all listeners via protocols and not via proxies anymore Ever since the protocols were added in 1.3.13, listeners used to be started twice: - once by start_proxies(), which iteratees over all proxies then all listeners ; - once by protocol_bind_all() which iterates over all protocols then all listeners ; It's a real mess because error reporting is not even consistent, and more importantly now that some protocols do not appear in regular proxies (peers, logs), there is no way to retry their binding should it fail on the last step. What this patch does is to make sure that listeners are exclusively started by protocols. The failure to start a listener now causes the emission of an error indicating the proxy's name (as it used to be the case per proxy), and retryable failures are silently ignored during all but last attempts. The start_proxies() function was kept solely for setting the proxy's state to READY and emitting the "Proxy started" message and log that some have likely got used to seeking in their logs.
2020-09-02 05:11:43 -04:00
MEDIUM: protocol: explicitly start the receiver before the listener Now protocol_bind_all() starts the receivers before their respective listeners so that ultimately we won't need the listeners for non- connected protocols. We still have to resort to an ugly trick to set the I/O handler in case of syslog over UDP because for now it's still not set in the receiver, so we hard-code it.
2020-09-02 12:22:11 -04:00
if (lerr & ~ERR_WARN)
continue;
/* for now there's still always a listening function */
BUG_ON(!proto->listen);
lerr = proto->listen(listener, msg, sizeof(msg));
MAJOR: init: start all listeners via protocols and not via proxies anymore Ever since the protocols were added in 1.3.13, listeners used to be started twice: - once by start_proxies(), which iteratees over all proxies then all listeners ; - once by protocol_bind_all() which iterates over all protocols then all listeners ; It's a real mess because error reporting is not even consistent, and more importantly now that some protocols do not appear in regular proxies (peers, logs), there is no way to retry their binding should it fail on the last step. What this patch does is to make sure that listeners are exclusively started by protocols. The failure to start a listener now causes the emission of an error indicating the proxy's name (as it used to be the case per proxy), and retryable failures are silently ignored during all but last attempts. The start_proxies() function was kept solely for setting the proxy's state to READY and emitting the "Proxy started" message and log that some have likely got used to seeking in their logs.
2020-09-02 05:11:43 -04:00
err |= lerr;
MEDIUM: protocol: explicitly start the receiver before the listener Now protocol_bind_all() starts the receivers before their respective listeners so that ultimately we won't need the listeners for non- connected protocols. We still have to resort to an ugly trick to set the I/O handler in case of syslog over UDP because for now it's still not set in the receiver, so we hard-code it.
2020-09-02 12:22:11 -04:00
if (verbose || (lerr & (ERR_FATAL | ERR_ABORT))) {
struct proxy *px = listener->bind_conf->frontend;
if (lerr & ERR_ALERT)
MINOR: protocol: report the file and line number for binding/listening errors Binding errors and late socket errors provide no information about the file and line where the problem occurs. These are all done by protocol_bind_all() and they only report "Starting proxy blah". Let's change this a little bit so that: - the file name and line number of the faulty bind line is alwas mentioned - early binding errors are indicated with "Binding" instead of "Starting". Now we can for example have this: [WARNING] (18580) : Binding [binderr.cfg:10] for proxy http: cannot bind receiver to device 'eth2' (No such device) [0.0.0.0:1080]
2021-10-14 05:55:48 -04:00
ha_alert("Starting [%s:%d] for %s %s: %s\n",
listener->bind_conf->file, listener->bind_conf->line,
MEDIUM: protocol: explicitly start the receiver before the listener Now protocol_bind_all() starts the receivers before their respective listeners so that ultimately we won't need the listeners for non- connected protocols. We still have to resort to an ugly trick to set the I/O handler in case of syslog over UDP because for now it's still not set in the receiver, so we hard-code it.
2020-09-02 12:22:11 -04:00
proxy_type_str(px), px->id, msg);
else if (lerr & ERR_WARN)
MINOR: protocol: report the file and line number for binding/listening errors Binding errors and late socket errors provide no information about the file and line where the problem occurs. These are all done by protocol_bind_all() and they only report "Starting proxy blah". Let's change this a little bit so that: - the file name and line number of the faulty bind line is alwas mentioned - early binding errors are indicated with "Binding" instead of "Starting". Now we can for example have this: [WARNING] (18580) : Binding [binderr.cfg:10] for proxy http: cannot bind receiver to device 'eth2' (No such device) [0.0.0.0:1080]
2021-10-14 05:55:48 -04:00
ha_warning("Starting [%s:%d] for %s %s: %s\n",
listener->bind_conf->file, listener->bind_conf->line,
MEDIUM: protocol: explicitly start the receiver before the listener Now protocol_bind_all() starts the receivers before their respective listeners so that ultimately we won't need the listeners for non- connected protocols. We still have to resort to an ugly trick to set the I/O handler in case of syslog over UDP because for now it's still not set in the receiver, so we hard-code it.
2020-09-02 12:22:11 -04:00
proxy_type_str(px), px->id, msg);
}
MAJOR: init: start all listeners via protocols and not via proxies anymore Ever since the protocols were added in 1.3.13, listeners used to be started twice: - once by start_proxies(), which iteratees over all proxies then all listeners ; - once by protocol_bind_all() which iterates over all protocols then all listeners ; It's a real mess because error reporting is not even consistent, and more importantly now that some protocols do not appear in regular proxies (peers, logs), there is no way to retry their binding should it fail on the last step. What this patch does is to make sure that listeners are exclusively started by protocols. The failure to start a listener now causes the emission of an error indicating the proxy's name (as it used to be the case per proxy), and retryable failures are silently ignored during all but last attempts. The start_proxies() function was kept solely for setting the proxy's state to READY and emitting the "Proxy started" message and log that some have likely got used to seeking in their logs.
2020-09-02 05:11:43 -04:00
if (lerr & ERR_ABORT)
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
break;
}
MAJOR: init: start all listeners via protocols and not via proxies anymore Ever since the protocols were added in 1.3.13, listeners used to be started twice: - once by start_proxies(), which iteratees over all proxies then all listeners ; - once by protocol_bind_all() which iterates over all protocols then all listeners ; It's a real mess because error reporting is not even consistent, and more importantly now that some protocols do not appear in regular proxies (peers, logs), there is no way to retry their binding should it fail on the last step. What this patch does is to make sure that listeners are exclusively started by protocols. The failure to start a listener now causes the emission of an error indicating the proxy's name (as it used to be the case per proxy), and retryable failures are silently ignored during all but last attempts. The start_proxies() function was kept solely for setting the proxy's state to READY and emitting the "Proxy started" message and log that some have likely got used to seeking in their logs.
2020-09-02 05:11:43 -04:00
if (err & ERR_ABORT)
break;
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
}
BUG/MEDIUM: protocols: add a global lock for the init/deinit stuff Dragan Dosen found that the listeners lock is not sufficient to protect the listeners list when proxies are stopping because the listeners are also unlinked from the protocol list, and under certain situations like bombing with soft-stop signals or shutting down many frontends in parallel from multiple CLI connections, it could be possible to provoke multiple instances of delete_listener() to be called in parallel for different listeners, thus corrupting the protocol lists. Such operations are pretty rare, they are performed once per proxy upon startup and once per proxy on shut down. Thus there is no point trying to optimize anything and we can use a global lock to protect the protocol lists during these manipulations. This fix (or a variant) will have to be backported as far as 1.8.
2019-07-24 10:45:02 -04:00
HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
return err;
}
/* unbinds all listeners of all registered protocols. They are also closed.
* This must be performed before calling exit() in order to get a chance to
* remove file-system based sockets and pipes.
* Returns a composition of ERR_NONE, ERR_RETRYABLE, ERR_FATAL, ERR_ABORT.
*/
int protocol_unbind_all(void)
{
struct protocol *proto;
MINOR: protocol: do not call proto->unbind_all() anymore Similarly to previous commit about ->bind_all(), we have the same construct for ->unbind_all() which ought not to be used either. Let's make protocol_unbind_all() iterate over all listeners and directly call unbind_listener() instead. It's worth noting that for uxst there was originally a specific ->unbind_all() function but the simplifications that came over the years have resulted in a locally reimplemented version of the same function: the test on (state > LI_ASSIGNED) there is equivalent to the one on (state >= LI_PAUSED) that is used in do_unbind_listener(), and it seems these have been equivalent since at least commit dabf2e264 ("[MAJOR] added a new state to listeners")) (1.3.14).
2020-09-02 04:31:31 -04:00
struct listener *listener;
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
int err;
err = 0;
BUG/MEDIUM: protocols: add a global lock for the init/deinit stuff Dragan Dosen found that the listeners lock is not sufficient to protect the listeners list when proxies are stopping because the listeners are also unlinked from the protocol list, and under certain situations like bombing with soft-stop signals or shutting down many frontends in parallel from multiple CLI connections, it could be possible to provoke multiple instances of delete_listener() to be called in parallel for different listeners, thus corrupting the protocol lists. Such operations are pretty rare, they are performed once per proxy upon startup and once per proxy on shut down. Thus there is no point trying to optimize anything and we can use a global lock to protect the protocol lists during these manipulations. This fix (or a variant) will have to be backported as far as 1.8.
2019-07-24 10:45:02 -04:00
HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
list_for_each_entry(proto, &protocols, list) {
MINOR: protocol: rename the ->listeners field to ->receivers Since the listeners were split into receiver+listener, this field ought to have been renamed because it's confusing. It really links receivers and not listeners, as most of the time it's used via rx.proto_list! The nb_listeners field was updated accordingly.
2020-09-25 11:01:43 -04:00
list_for_each_entry(listener, &proto->receivers, rx.proto_list)
MINOR: protocol: do not call proto->unbind_all() anymore Similarly to previous commit about ->bind_all(), we have the same construct for ->unbind_all() which ought not to be used either. Let's make protocol_unbind_all() iterate over all listeners and directly call unbind_listener() instead. It's worth noting that for uxst there was originally a specific ->unbind_all() function but the simplifications that came over the years have resulted in a locally reimplemented version of the same function: the test on (state > LI_ASSIGNED) there is equivalent to the one on (state >= LI_PAUSED) that is used in do_unbind_listener(), and it seems these have been equivalent since at least commit dabf2e264 ("[MAJOR] added a new state to listeners")) (1.3.14).
2020-09-02 04:31:31 -04:00
unbind_listener(listener);
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
}
BUG/MEDIUM: protocols: add a global lock for the init/deinit stuff Dragan Dosen found that the listeners lock is not sufficient to protect the listeners list when proxies are stopping because the listeners are also unlinked from the protocol list, and under certain situations like bombing with soft-stop signals or shutting down many frontends in parallel from multiple CLI connections, it could be possible to provoke multiple instances of delete_listener() to be called in parallel for different listeners, thus corrupting the protocol lists. Such operations are pretty rare, they are performed once per proxy upon startup and once per proxy on shut down. Thus there is no point trying to optimize anything and we can use a global lock to protect the protocol lists during these manipulations. This fix (or a variant) will have to be backported as far as 1.8.
2019-07-24 10:45:02 -04:00
HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
return err;
}
MEDIUM: proxy: remove the deprecated "grace" keyword Commit ab0a5192a ("MEDIUM: config: mark "grace" as deprecated") marked the "grace" keyword as deprecated in 2.3, tentative removal for 2.4 with a hard deadline in 2.5, so let's remove it and return an error now. This old and outdated feature was incompatible with soft-stop, reload and socket transfers, and keeping it forced ugly hacks in the lower layers of the protocol stack.
2021-06-11 10:27:10 -04:00
/* stops all listeners of all registered protocols. This will normally catch
* every single listener, all protocols included. This is to be used during
* soft_stop() only. It does not return any error.
MINOR: protocol: add protocol_stop_now() to instant-stop listeners This will instantly stop all listeners except those which belong to a proxy configured with a grace time. This means that UDP listeners, and peers will also be stopped when called this way.
2020-10-07 10:50:49 -04:00
*/
void protocol_stop_now(void)
{
struct protocol *proto;
struct listener *listener, *lback;
HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
list_for_each_entry(proto, &protocols, list) {
list_for_each_entry_safe(listener, lback, &proto->receivers, rx.proto_list)
MINOR: listener/api: add lli hint to listener functions Add listener lock hint (AKA lli) to (stop/resume/pause)_listener() functions. All these functions implicitely take the listener lock when they are called: It could be useful to be able to call them while already holding the lock, so we're adding lli hint to make them take the lock only when it is missing. This should only be backported if explicitly required by another commit -- -> 2.4 and 2.5 common backport notes: These 2 commits need to be backported first: - 187396e34 "CLEANUP: listener: function comment typo in stop_listener()" - a57786e87 "BUG/MINOR: listener: null pointer dereference suspected by coverity" -> 2.4 special backport notes: In addition to the previously mentionned dependencies, the patch needs to be slightly adapted to match the corresponding contextual lines: Replace this: |@@ -471,7 +474,8 @@ int pause_listener(struct listener *l, int lpx) | if (!lpx && px) | HA_RWLOCK_WRLOCK(PROXY_LOCK, &px->lock); | |- HA_RWLOCK_WRLOCK(LISTENER_LOCK, &l->lock); |+ if (!lli) |+ HA_RWLOCK_WRLOCK(LISTENER_LOCK, &l->lock); | | if (l->state <= LI_PAUSED) | goto end; By this: |@@ -471,7 +474,8 @@ int pause_listener(struct listener *l, int lpx) | if (!lpx && px) | HA_RWLOCK_WRLOCK(PROXY_LOCK, &px->lock); | |- HA_RWLOCK_WRLOCK(LISTENER_LOCK, &l->lock); |+ if (!lli) |+ HA_RWLOCK_WRLOCK(LISTENER_LOCK, &l->lock); | | if ((global.mode & (MODE_DAEMON | MODE_MWORKER)) && | !(proc_mask(l->rx.settings->bind_proc) & pid_bit)) Replace this: |@@ -169,7 +169,7 @@ void protocol_stop_now(void) | HA_SPIN_LOCK(PROTO_LOCK, &proto_lock); | list_for_each_entry(proto, &protocols, list) { | list_for_each_entry_safe(listener, lback, &proto->receivers, rx.proto_list) |- stop_listener(listener, 0, 1); |+ stop_listener(listener, 0, 1, 0); | } | HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock); | } By this: |@@ -169,7 +169,7 @@ void protocol_stop_now(void) | HA_SPIN_LOCK(PROTO_LOCK, &proto_lock); | list_for_each_entry(proto, &protocols, list) { | list_for_each_entry_safe(listener, lback, &proto->receivers, rx.proto_list) | if (!listener->bind_conf->frontend->grace) |- stop_listener(listener, 0, 1); |+ stop_listener(listener, 0, 1, 0); | } | HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock); Replace this: |@@ -2315,7 +2315,7 @@ void stop_proxy(struct proxy *p) | HA_RWLOCK_WRLOCK(PROXY_LOCK, &p->lock); | | list_for_each_entry(l, &p->conf.listeners, by_fe) |- stop_listener(l, 1, 0); |+ stop_listener(l, 1, 0, 0); | | if (!(p->flags & (PR_FL_DISABLED|PR_FL_STOPPED)) && !p->li_ready) { | /* might be just a backend */ By this: |@@ -2315,7 +2315,7 @@ void stop_proxy(struct proxy *p) | HA_RWLOCK_WRLOCK(PROXY_LOCK, &p->lock); | | list_for_each_entry(l, &p->conf.listeners, by_fe) |- stop_listener(l, 1, 0); |+ stop_listener(l, 1, 0, 0); | | if (!p->disabled && !p->li_ready) { | /* might be just a backend */
2023-02-06 11:06:03 -05:00
stop_listener(listener, 0, 1, 0);
MINOR: protocol: add protocol_stop_now() to instant-stop listeners This will instantly stop all listeners except those which belong to a proxy configured with a grace time. This means that UDP listeners, and peers will also be stopped when called this way.
2020-10-07 10:50:49 -04:00
}
HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
}
MINOR: listener: pause_listener() becomes suspend_listener() We are simply renaming pause_listener() to suspend_listener() to prevent confusion around listener pausing. A suspended listener can be in two differents valid states: - LI_PAUSED: the listener is effectively paused, it will unpause on resume_listener() - LI_ASSIGNED (not bound): the listener does not support the LI_PAUSED state, so it was unbound to satisfy the suspend request, it will correcly re-bind on resume_listener() Besides that, we add the LI_F_SUSPENDED flag to mark suspended listeners in suspend_listener() and unmark them in resume_listener(). We're also adding li_suspend proxy variable to track the number of currently suspended listeners: That is, the number of listeners that were suspended through suspend_listener() and that are either in LI_PAUSED or LI_ASSIGNED state. Counter is increased on successful suspend in suspend_listener() and it is decreased on successful resume in resume_listener() -- Backport notes: -> 2.4 only, as "MINOR: proxy/listener: support for additional PAUSED state" was not backported: Replace this: | /* PROXY_LOCK is require | proxy_cond_resume(px); By this: | ha_warning("Resumed %s %s.\n", proxy_cap_str(px->cap), px->id); | send_log(px, LOG_WARNING, "Resumed %s %s.\n", proxy_cap_str(px->cap), px->id); -> 2.6 and 2.7 only, as "MINOR: listener: make sure we don't pause/resume" was custom patched: Replace this: |@@ -253,6 +253,7 @@ struct listener { | | /* listener flags (16 bits) */ | #define LI_F_FINALIZED 0x0001 /* listener made it to the READY||LIMITED||FULL state at least once, may be suspended/resumed safely */ |+#define LI_F_SUSPENDED 0x0002 /* listener has been suspended using suspend_listener(), it is either is LI_PAUSED or LI_ASSIGNED state */ | | /* Descriptor for a "bind" keyword. The ->parse() function returns 0 in case of | * success, or a combination of ERR_* flags if an error is encountered. The By this: |@@ -222,6 +222,7 @@ struct li_per_thread { | | #define LI_F_QUIC_LISTENER 0x00000001 /* listener uses proto quic */ | #define LI_F_FINALIZED 0x00000002 /* listener made it to the READY||LIMITED||FULL state at least once, may be suspended/resumed safely */ |+#define LI_F_SUSPENDED 0x00000004 /* listener has been suspended using suspend_listener(), it is either is LI_PAUSED or LI_ASSIGNED state */ | | /* The listener will be directly referenced by the fdtab[] which holds its | * socket. The listener provides the protocol-specific accept() function to
2023-02-13 11:45:08 -05:00
/* suspends all listeners of all registered protocols. This is typically
MINOR: protocol: introduce protocol_{pause,resume}_all() These two functions are used to pause and resume all listeners of all protocols. They use the standard listener functions for this so they're supposed to handle the situation gracefully regardless of the upper proxies' states, and they will report completion on proxies once the switch is performed. It might be nice to define a particular "failed" state for listeners that cannot resume and to count them on proxies in order to mention that they're definitely stuck. On the other hand, the current situation is retryable which is quite appreciable as well.
2020-09-24 10:26:50 -04:00
* used on SIG_TTOU to release all listening sockets for the time needed to
MINOR: listener: pause_listener() becomes suspend_listener() We are simply renaming pause_listener() to suspend_listener() to prevent confusion around listener pausing. A suspended listener can be in two differents valid states: - LI_PAUSED: the listener is effectively paused, it will unpause on resume_listener() - LI_ASSIGNED (not bound): the listener does not support the LI_PAUSED state, so it was unbound to satisfy the suspend request, it will correcly re-bind on resume_listener() Besides that, we add the LI_F_SUSPENDED flag to mark suspended listeners in suspend_listener() and unmark them in resume_listener(). We're also adding li_suspend proxy variable to track the number of currently suspended listeners: That is, the number of listeners that were suspended through suspend_listener() and that are either in LI_PAUSED or LI_ASSIGNED state. Counter is increased on successful suspend in suspend_listener() and it is decreased on successful resume in resume_listener() -- Backport notes: -> 2.4 only, as "MINOR: proxy/listener: support for additional PAUSED state" was not backported: Replace this: | /* PROXY_LOCK is require | proxy_cond_resume(px); By this: | ha_warning("Resumed %s %s.\n", proxy_cap_str(px->cap), px->id); | send_log(px, LOG_WARNING, "Resumed %s %s.\n", proxy_cap_str(px->cap), px->id); -> 2.6 and 2.7 only, as "MINOR: listener: make sure we don't pause/resume" was custom patched: Replace this: |@@ -253,6 +253,7 @@ struct listener { | | /* listener flags (16 bits) */ | #define LI_F_FINALIZED 0x0001 /* listener made it to the READY||LIMITED||FULL state at least once, may be suspended/resumed safely */ |+#define LI_F_SUSPENDED 0x0002 /* listener has been suspended using suspend_listener(), it is either is LI_PAUSED or LI_ASSIGNED state */ | | /* Descriptor for a "bind" keyword. The ->parse() function returns 0 in case of | * success, or a combination of ERR_* flags if an error is encountered. The By this: |@@ -222,6 +222,7 @@ struct li_per_thread { | | #define LI_F_QUIC_LISTENER 0x00000001 /* listener uses proto quic */ | #define LI_F_FINALIZED 0x00000002 /* listener made it to the READY||LIMITED||FULL state at least once, may be suspended/resumed safely */ |+#define LI_F_SUSPENDED 0x00000004 /* listener has been suspended using suspend_listener(), it is either is LI_PAUSED or LI_ASSIGNED state */ | | /* The listener will be directly referenced by the fdtab[] which holds its | * socket. The listener provides the protocol-specific accept() function to
2023-02-13 11:45:08 -05:00
* try to bind a new process. The listeners enter LI_PAUSED or LI_ASSIGNED.
* It returns ERR_NONE, with ERR_FATAL on failure.
MINOR: protocol: introduce protocol_{pause,resume}_all() These two functions are used to pause and resume all listeners of all protocols. They use the standard listener functions for this so they're supposed to handle the situation gracefully regardless of the upper proxies' states, and they will report completion on proxies once the switch is performed. It might be nice to define a particular "failed" state for listeners that cannot resume and to count them on proxies in order to mention that they're definitely stuck. On the other hand, the current situation is retryable which is quite appreciable as well.
2020-09-24 10:26:50 -04:00
*/
int protocol_pause_all(void)
{
struct protocol *proto;
struct listener *listener;
int err;
err = 0;
HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
list_for_each_entry(proto, &protocols, list) {
MINOR: protocol: rename the ->listeners field to ->receivers Since the listeners were split into receiver+listener, this field ought to have been renamed because it's confusing. It really links receivers and not listeners, as most of the time it's used via rx.proto_list! The nb_listeners field was updated accordingly.
2020-09-25 11:01:43 -04:00
list_for_each_entry(listener, &proto->receivers, rx.proto_list)
MINOR: listener: pause_listener() becomes suspend_listener() We are simply renaming pause_listener() to suspend_listener() to prevent confusion around listener pausing. A suspended listener can be in two differents valid states: - LI_PAUSED: the listener is effectively paused, it will unpause on resume_listener() - LI_ASSIGNED (not bound): the listener does not support the LI_PAUSED state, so it was unbound to satisfy the suspend request, it will correcly re-bind on resume_listener() Besides that, we add the LI_F_SUSPENDED flag to mark suspended listeners in suspend_listener() and unmark them in resume_listener(). We're also adding li_suspend proxy variable to track the number of currently suspended listeners: That is, the number of listeners that were suspended through suspend_listener() and that are either in LI_PAUSED or LI_ASSIGNED state. Counter is increased on successful suspend in suspend_listener() and it is decreased on successful resume in resume_listener() -- Backport notes: -> 2.4 only, as "MINOR: proxy/listener: support for additional PAUSED state" was not backported: Replace this: | /* PROXY_LOCK is require | proxy_cond_resume(px); By this: | ha_warning("Resumed %s %s.\n", proxy_cap_str(px->cap), px->id); | send_log(px, LOG_WARNING, "Resumed %s %s.\n", proxy_cap_str(px->cap), px->id); -> 2.6 and 2.7 only, as "MINOR: listener: make sure we don't pause/resume" was custom patched: Replace this: |@@ -253,6 +253,7 @@ struct listener { | | /* listener flags (16 bits) */ | #define LI_F_FINALIZED 0x0001 /* listener made it to the READY||LIMITED||FULL state at least once, may be suspended/resumed safely */ |+#define LI_F_SUSPENDED 0x0002 /* listener has been suspended using suspend_listener(), it is either is LI_PAUSED or LI_ASSIGNED state */ | | /* Descriptor for a "bind" keyword. The ->parse() function returns 0 in case of | * success, or a combination of ERR_* flags if an error is encountered. The By this: |@@ -222,6 +222,7 @@ struct li_per_thread { | | #define LI_F_QUIC_LISTENER 0x00000001 /* listener uses proto quic */ | #define LI_F_FINALIZED 0x00000002 /* listener made it to the READY||LIMITED||FULL state at least once, may be suspended/resumed safely */ |+#define LI_F_SUSPENDED 0x00000004 /* listener has been suspended using suspend_listener(), it is either is LI_PAUSED or LI_ASSIGNED state */ | | /* The listener will be directly referenced by the fdtab[] which holds its | * socket. The listener provides the protocol-specific accept() function to
2023-02-13 11:45:08 -05:00
if (!suspend_listener(listener, 0, 0))
MINOR: protocol: introduce protocol_{pause,resume}_all() These two functions are used to pause and resume all listeners of all protocols. They use the standard listener functions for this so they're supposed to handle the situation gracefully regardless of the upper proxies' states, and they will report completion on proxies once the switch is performed. It might be nice to define a particular "failed" state for listeners that cannot resume and to count them on proxies in order to mention that they're definitely stuck. On the other hand, the current situation is retryable which is quite appreciable as well.
2020-09-24 10:26:50 -04:00
err |= ERR_FATAL;
}
HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
return err;
}
/* resumes all listeners of all registered protocols. This is typically used on
* SIG_TTIN to re-enable listening sockets after a new process failed to bind.
* The listeners switch to LI_READY/LI_FULL. It returns ERR_NONE, with ERR_FATAL
* on failure.
*/
int protocol_resume_all(void)
{
struct protocol *proto;
struct listener *listener;
int err;
err = 0;
HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
list_for_each_entry(proto, &protocols, list) {
MINOR: protocol: rename the ->listeners field to ->receivers Since the listeners were split into receiver+listener, this field ought to have been renamed because it's confusing. It really links receivers and not listeners, as most of the time it's used via rx.proto_list! The nb_listeners field was updated accordingly.
2020-09-25 11:01:43 -04:00
list_for_each_entry(listener, &proto->receivers, rx.proto_list)
MINOR: listener/api: add lli hint to listener functions Add listener lock hint (AKA lli) to (stop/resume/pause)_listener() functions. All these functions implicitely take the listener lock when they are called: It could be useful to be able to call them while already holding the lock, so we're adding lli hint to make them take the lock only when it is missing. This should only be backported if explicitly required by another commit -- -> 2.4 and 2.5 common backport notes: These 2 commits need to be backported first: - 187396e34 "CLEANUP: listener: function comment typo in stop_listener()" - a57786e87 "BUG/MINOR: listener: null pointer dereference suspected by coverity" -> 2.4 special backport notes: In addition to the previously mentionned dependencies, the patch needs to be slightly adapted to match the corresponding contextual lines: Replace this: |@@ -471,7 +474,8 @@ int pause_listener(struct listener *l, int lpx) | if (!lpx && px) | HA_RWLOCK_WRLOCK(PROXY_LOCK, &px->lock); | |- HA_RWLOCK_WRLOCK(LISTENER_LOCK, &l->lock); |+ if (!lli) |+ HA_RWLOCK_WRLOCK(LISTENER_LOCK, &l->lock); | | if (l->state <= LI_PAUSED) | goto end; By this: |@@ -471,7 +474,8 @@ int pause_listener(struct listener *l, int lpx) | if (!lpx && px) | HA_RWLOCK_WRLOCK(PROXY_LOCK, &px->lock); | |- HA_RWLOCK_WRLOCK(LISTENER_LOCK, &l->lock); |+ if (!lli) |+ HA_RWLOCK_WRLOCK(LISTENER_LOCK, &l->lock); | | if ((global.mode & (MODE_DAEMON | MODE_MWORKER)) && | !(proc_mask(l->rx.settings->bind_proc) & pid_bit)) Replace this: |@@ -169,7 +169,7 @@ void protocol_stop_now(void) | HA_SPIN_LOCK(PROTO_LOCK, &proto_lock); | list_for_each_entry(proto, &protocols, list) { | list_for_each_entry_safe(listener, lback, &proto->receivers, rx.proto_list) |- stop_listener(listener, 0, 1); |+ stop_listener(listener, 0, 1, 0); | } | HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock); | } By this: |@@ -169,7 +169,7 @@ void protocol_stop_now(void) | HA_SPIN_LOCK(PROTO_LOCK, &proto_lock); | list_for_each_entry(proto, &protocols, list) { | list_for_each_entry_safe(listener, lback, &proto->receivers, rx.proto_list) | if (!listener->bind_conf->frontend->grace) |- stop_listener(listener, 0, 1); |+ stop_listener(listener, 0, 1, 0); | } | HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock); Replace this: |@@ -2315,7 +2315,7 @@ void stop_proxy(struct proxy *p) | HA_RWLOCK_WRLOCK(PROXY_LOCK, &p->lock); | | list_for_each_entry(l, &p->conf.listeners, by_fe) |- stop_listener(l, 1, 0); |+ stop_listener(l, 1, 0, 0); | | if (!(p->flags & (PR_FL_DISABLED|PR_FL_STOPPED)) && !p->li_ready) { | /* might be just a backend */ By this: |@@ -2315,7 +2315,7 @@ void stop_proxy(struct proxy *p) | HA_RWLOCK_WRLOCK(PROXY_LOCK, &p->lock); | | list_for_each_entry(l, &p->conf.listeners, by_fe) |- stop_listener(l, 1, 0); |+ stop_listener(l, 1, 0, 0); | | if (!p->disabled && !p->li_ready) { | /* might be just a backend */
2023-02-06 11:06:03 -05:00
if (!resume_listener(listener, 0, 0))
MINOR: protocol: introduce protocol_{pause,resume}_all() These two functions are used to pause and resume all listeners of all protocols. They use the standard listener functions for this so they're supposed to handle the situation gracefully regardless of the upper proxies' states, and they will report completion on proxies once the switch is performed. It might be nice to define a particular "failed" state for listeners that cannot resume and to count them on proxies in order to mention that they're definitely stuck. On the other hand, the current situation is retryable which is quite appreciable as well.
2020-09-24 10:26:50 -04:00
err |= ERR_FATAL;
}
HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
return err;
}
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
/* enables all listeners of all registered protocols. This is intended to be
MINOR: protocol: directly call enable_listener() from protocol_enable_all() protocol_enable_all() calls proto->enable_all() for all protocols, which is always equal to enable_all_listeners() which in turn simply is a generic loop calling enable_listener() always returning ERR_NONE. Let's clean this madness by first calling enable_listener() directly from protocol_enable_all().
2020-09-25 10:41:05 -04:00
* used after a fork() to enable reading on all file descriptors. Returns
* composition of ERR_NONE.
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
*/
int protocol_enable_all(void)
{
struct protocol *proto;
MINOR: protocol: directly call enable_listener() from protocol_enable_all() protocol_enable_all() calls proto->enable_all() for all protocols, which is always equal to enable_all_listeners() which in turn simply is a generic loop calling enable_listener() always returning ERR_NONE. Let's clean this madness by first calling enable_listener() directly from protocol_enable_all().
2020-09-25 10:41:05 -04:00
struct listener *listener;
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
BUG/MEDIUM: protocols: add a global lock for the init/deinit stuff Dragan Dosen found that the listeners lock is not sufficient to protect the listeners list when proxies are stopping because the listeners are also unlinked from the protocol list, and under certain situations like bombing with soft-stop signals or shutting down many frontends in parallel from multiple CLI connections, it could be possible to provoke multiple instances of delete_listener() to be called in parallel for different listeners, thus corrupting the protocol lists. Such operations are pretty rare, they are performed once per proxy upon startup and once per proxy on shut down. Thus there is no point trying to optimize anything and we can use a global lock to protect the protocol lists during these manipulations. This fix (or a variant) will have to be backported as far as 1.8.
2019-07-24 10:45:02 -04:00
HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
list_for_each_entry(proto, &protocols, list) {
MINOR: protocol: rename the ->listeners field to ->receivers Since the listeners were split into receiver+listener, this field ought to have been renamed because it's confusing. It really links receivers and not listeners, as most of the time it's used via rx.proto_list! The nb_listeners field was updated accordingly.
2020-09-25 11:01:43 -04:00
list_for_each_entry(listener, &proto->receivers, rx.proto_list)
MINOR: protocol: directly call enable_listener() from protocol_enable_all() protocol_enable_all() calls proto->enable_all() for all protocols, which is always equal to enable_all_listeners() which in turn simply is a generic loop calling enable_listener() always returning ERR_NONE. Let's clean this madness by first calling enable_listener() directly from protocol_enable_all().
2020-09-25 10:41:05 -04:00
enable_listener(listener);
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
}
BUG/MEDIUM: protocols: add a global lock for the init/deinit stuff Dragan Dosen found that the listeners lock is not sufficient to protect the listeners list when proxies are stopping because the listeners are also unlinked from the protocol list, and under certain situations like bombing with soft-stop signals or shutting down many frontends in parallel from multiple CLI connections, it could be possible to provoke multiple instances of delete_listener() to be called in parallel for different listeners, thus corrupting the protocol lists. Such operations are pretty rare, they are performed once per proxy upon startup and once per proxy on shut down. Thus there is no point trying to optimize anything and we can use a global lock to protect the protocol lists during these manipulations. This fix (or a variant) will have to be backported as far as 1.8.
2019-07-24 10:45:02 -04:00
HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
MINOR: protocol: directly call enable_listener() from protocol_enable_all() protocol_enable_all() calls proto->enable_all() for all protocols, which is always equal to enable_all_listeners() which in turn simply is a generic loop calling enable_listener() always returning ERR_NONE. Let's clean this madness by first calling enable_listener() directly from protocol_enable_all().
2020-09-25 10:41:05 -04:00
return ERR_NONE;
REORG: split "protocols" files into protocol and listener It was becoming confusing to have protocols and listeners in the same files, split them.
2012-09-12 16:58:11 -04:00
}
/*
* Local variables:
* c-indent-level: 8
* c-basic-offset: 8
* End:
*/
Reference in a new issue Copy permalink