RepoMirrors/haproxy
1
0
Fork 0
mirror of http://git.haproxy.org/git/haproxy.git/ synced 2024-12-13 06:54:37 +00:00
Code Issues Packages Projects Releases Wiki Activity
609aad9e73
haproxy/include/proto/queue.h

120 lines
3.5 KiB
C
Raw Normal View History

[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-26 00:48:02 +00:00
/*
BUG/MEDIUM: zero-weight servers must not dequeue requests from the backend It was reported that a server configured with a zero weight would sometimes still take connections from the backend queue. This issue is real, it happens this way : 1) the disabled server accepts a request with a cookie 2) many cookie-less requests accumulate in the backend queue 3) when the disabled server completes its request, it checks its own queue and the backend's queue 4) the server takes a pending request from the backend queue and processes it. In response, the server's cookie is assigned to the client, which ensures that some requests will continue to be served by this server, leading back to point 1 above. The fix consists in preventing a zero-weight server from dequeuing pending requests from the backend. Making use of srv_is_usable() in such tests makes the tests more robust against future changes. This fix must be backported to 1.4 and 1.3.
2012-01-20 14:57:05 +00:00
* include/proto/queue.h
* This file defines everything related to queues.
*
* Copyright (C) 2000-2012 Willy Tarreau - w@1wt.eu
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation, version 2.1
* exclusively.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-26 00:48:02 +00:00
#ifndef _PROTO_QUEUE_H
#define _PROTO_QUEUE_H
[CLEANUP] included common/version.h everywhere
2006-06-29 16:54:54 +00:00
#include <common/config.h>
[CLEANUP] renamed include/haproxy to include/common
2006-06-29 15:53:05 +00:00
#include <common/memory.h>
#include <common/mini-clist.h>
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-26 00:48:02 +00:00
#include <types/proxy.h>
#include <types/queue.h>
REORG/MAJOR: session: rename the "session" entity to "stream" With HTTP/2, we'll have to support multiplexed streams. A stream is in fact the largest part of what we currently call a session, it has buffers, logs, etc. In order to catch any error, this commit removes any reference to the struct session and tries to rename most "session" occurrences in function names to "stream" and "sess" to "strm" when that's related to a session. The files stream.{c,h} were added and session.{c,h} removed. The session will be reintroduced later and a few parts of the stream will progressively be moved overthere. It will more or less contain only what we need in an embryonic session. Sample fetch functions and converters will have to change a bit so that they'll use an L5 (session) instead of what's currently called "L4" which is in fact L6 for now. Once all changes are completed, we should see approximately this : L7 - http_txn L6 - stream L5 - session L4 - connection | applet There will be at most one http_txn per stream, and a same session will possibly be referenced by multiple streams. A connection will point to a session and to a stream. The session will hold all the information we need to keep even when we don't yet have a stream. Some more cleanup is needed because some code was already far from being clean. The server queue management still refers to sessions at many places while comments talk about connections. This will have to be cleaned up once we have a server-side connection pool manager. Stream flags "SN_*" still need to be renamed, it doesn't seem like any of them will need to move to the session.
2015-04-02 22:22:06 +00:00
#include <types/stream.h>
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-26 00:48:02 +00:00
#include <types/server.h>
#include <types/task.h>
BUG/MEDIUM: zero-weight servers must not dequeue requests from the backend It was reported that a server configured with a zero weight would sometimes still take connections from the backend queue. This issue is real, it happens this way : 1) the disabled server accepts a request with a cookie 2) many cookie-less requests accumulate in the backend queue 3) when the disabled server completes its request, it checks its own queue and the backend's queue 4) the server takes a pending request from the backend queue and processes it. In response, the server's cookie is assigned to the client, which ensures that some requests will continue to be served by this server, leading back to point 1 above. The fix consists in preventing a zero-weight server from dequeuing pending requests from the backend. Making use of srv_is_usable() in such tests makes the tests more robust against future changes. This fix must be backported to 1.4 and 1.3.
2012-01-20 14:57:05 +00:00
#include <proto/backend.h>
CLEANUP: pools: rename all pool functions and pointers to remove this "2" During the migration to the second version of the pools, the new functions and pool pointers were all called "pool_something2()" and "pool2_something". Now there's no more pool v1 code and it's a real pain to still have to deal with this. Let's clean this up now by removing the "2" everywhere, and by renaming the pool heads "pool_head_something".
2017-11-24 16:34:44 +00:00
extern struct pool_head *pool_head_pendconn;
[MAJOR] ported pendconn to mempools v2 A pool_destroy() was also missing in deinit()
2007-05-13 18:19:55 +00:00
int init_pendconn();
REORG/MAJOR: session: rename the "session" entity to "stream" With HTTP/2, we'll have to support multiplexed streams. A stream is in fact the largest part of what we currently call a session, it has buffers, logs, etc. In order to catch any error, this commit removes any reference to the struct session and tries to rename most "session" occurrences in function names to "stream" and "sess" to "strm" when that's related to a session. The files stream.{c,h} were added and session.{c,h} removed. The session will be reintroduced later and a few parts of the stream will progressively be moved overthere. It will more or less contain only what we need in an embryonic session. Sample fetch functions and converters will have to change a bit so that they'll use an L5 (session) instead of what's currently called "L4" which is in fact L6 for now. Once all changes are completed, we should see approximately this : L7 - http_txn L6 - stream L5 - session L4 - connection | applet There will be at most one http_txn per stream, and a same session will possibly be referenced by multiple streams. A connection will point to a session and to a stream. The session will hold all the information we need to keep even when we don't yet have a stream. Some more cleanup is needed because some code was already far from being clean. The server queue management still refers to sessions at many places while comments talk about connections. This will have to be cleaned up once we have a server-side connection pool manager. Stream flags "SN_*" still need to be renamed, it doesn't seem like any of them will need to move to the session.
2015-04-02 22:22:06 +00:00
struct pendconn *pendconn_add(struct stream *strm);
BUG/MAJOR: threads/queue: Fix thread-safety issues on the queues management The management of the servers and the proxies queues was not thread-safe at all. First, the accesses to <strm>->pend_pos were not protected. So it was possible to release it on a thread (for instance because the stream is released) and to use it in same time on another one (because we redispatch pending connections for a server). Then, the accesses to stream's information (flags and target) from anywhere is forbidden. To be safe, The stream's state must always be updated in the context of process_stream. So to fix these issues, the queue module has been refactored. A lock has been added in the pendconn structure. And now, when we try to dequeue a pending connection, we start by unlinking it from the server/proxy queue and we wake up the stream. Then, it is the stream reponsibility to really dequeue it (or release it). This way, we are sure that only the stream can create and release its <pend_pos> field. However, be careful. This new implementation should be thread-safe (hopefully...). But it is not optimal and in some situations, it could be really slower in multi-threaded mode than in single-threaded one. The problem is that, when we try to dequeue pending connections, we process it from the older one to the newer one independently to the thread's affinity. So we need to wait the other threads' wakeup to really process them. If threads are blocked in the poller, this will add a significant latency. This problem happens when maxconn values are very low. This patch must be backported in 1.8.
2018-03-14 15:18:06 +00:00
int pendconn_dequeue(struct stream *strm);
[BUG] fix the dequeuing logic to ensure that all requests get served The dequeuing logic was completely wrong. First, a task was assigned to all servers to process the queue, but this task was never scheduled and was only woken up on session free. Second, there was no reservation of server entries when a task was assigned a server. This means that as long as the task was not connected to the server, its presence was not accounted for. This was causing trouble when detecting whether or not a server had reached maxconn. Third, during a redispatch, a session could lose its place at the server's and get blocked because another session at the same moment would have stolen the entry. Fourth, the redispatch option did not work when maxqueue was reached for a server, and it was not possible to do so without indefinitely hanging a session. The root cause of all those problems was the lack of pre-reservation of connections at the server's, and the lack of tracking of servers during a redispatch. Everything relied on combinations of flags which could appear similarly in quite distinct situations. This patch is a major rework but there was no other solution, as the internal logic was deeply flawed. The resulting code is cleaner, more understandable, uses less magics and is overall more robust. As an added bonus, "option redispatch" now works when maxqueue has been reached on a server.
2008-06-20 13:04:11 +00:00
void process_srv_queue(struct server *s);
[CLEANUP] add a few "const char *" where appropriate As suggested by Markus Elfring, a few "const char *" have replaced some "char *" declarations where a function is not expected to modify a value. It does not change the code but it helps detecting coding errors.
2006-10-15 13:17:57 +00:00
unsigned int srv_dynamic_maxconn(const struct server *s);
REORG: checks: put the functions in the appropriate files ! Checks.c has become a total mess. A number of proxy or server maintenance and queue management functions were put there probably because they were used there, but that makes the code untouchable. And that's without saying that their names does not always relate to what they really do! So let's do a first pass by moving these ones : - set_backend_down() => backend.c - redistribute_pending() => queue.c:pendconn_redistribute() - check_for_pending() => queue.c:pendconn_grab_from_px() - shutdown_sessions => server.c:srv_shutdown_sessions() - shutdown_backup_sessions => server.c:srv_shutdown_backup_sessions() All of them were moved at once.
2014-05-16 09:48:10 +00:00
int pendconn_redistribute(struct server *s);
int pendconn_grab_from_px(struct server *s);
MINOR: queue: centralize dequeuing code a bit better For now the pendconns may be dequeued at two places : - pendconn_unlink(), which operates on a locked queue - pendconn_free(), which operates on an unlocked queue and frees everything. Some changes are coming to the queue and we'll need to be able to be a bit stricter regarding the places where we dequeue to keep the accounting accurate. This first step renames the locked function __pendconn_unlink() as it's for use by those aware of it, and introduces a new general purpose pendconn_unlink() function which automatically grabs the necessary locks before calling the former, and pendconn_cond_unlink() which additionally checks the pointer and the presence in the queue.
2018-07-25 06:04:20 +00:00
void pendconn_unlink(struct pendconn *p);
/* Removes the pendconn from the server/proxy queue. It supports being called
* with NULL for pendconn and with a pendconn not in the list. It is the
* function to be used by default when unsure. Do not call it with server
* or proxy locks held however.
*/
static inline void pendconn_cond_unlink(struct pendconn *p)
{
MINOR: queue: replace the linked list with a tree We'll need trees to manage the queues by priorities. This change replaces the list with a tree based on a single key. It's effectively a list but allows us to get rid of the list management right now.
2018-05-11 16:52:31 +00:00
if (p && p->node.node.leaf_p)
MINOR: queue: centralize dequeuing code a bit better For now the pendconns may be dequeued at two places : - pendconn_unlink(), which operates on a locked queue - pendconn_free(), which operates on an unlocked queue and frees everything. Some changes are coming to the queue and we'll need to be able to be a bit stricter regarding the places where we dequeue to keep the accounting accurate. This first step renames the locked function __pendconn_unlink() as it's for use by those aware of it, and introduces a new general purpose pendconn_unlink() function which automatically grabs the necessary locks before calling the former, and pendconn_cond_unlink() which additionally checks the pointer and the presence in the queue.
2018-07-25 06:04:20 +00:00
pendconn_unlink(p);
}
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-26 00:48:02 +00:00
MEDIUM: queue: make pendconn_free() work on the stream instead Now pendconn_free() takes a stream, checks that pend_pos is set, clears it, and uses pendconn_unlink() to complete the job. It's cleaner and centralizes all the bookkeeping work in pendconn_unlink() only and ensures that there's a single place where the stream's position in the queue is manipulated.
2018-07-25 09:13:53 +00:00
/* Releases the pendconn associated to stream <s> if it has any, and decreases
* the pending count if needed. The connection might have been queued to a
* specific server as well as to the proxy. The stream also gets marked
* unqueued.
*
* This function must be called by the stream itself, so in the context of
* process_stream, without any lock held among the pendconn, the server's queue
* nor the proxy's queue.
*/
static inline void pendconn_free(struct stream *s)
{
struct pendconn *p = s->pend_pos;
if (p) {
pendconn_cond_unlink(p);
s->pend_pos = NULL;
pool_free(pool_head_pendconn, p);
}
}
MINOR: http: implement the max-keep-alive-queue setting Finn Arne Gangstad suggested that we should have the ability to break keep-alive when the target server has reached its maxconn and that a number of connections are present in the queue. After some discussion around his proposed patch, the following solution was suggested : have a per-proxy setting to fix a limit to the number of queued connections on a server after which we break keep-alive. This ensures that even in high latency networks where keep-alive is beneficial, we try to find a different server. This patch is partially based on his original proposal and implements this configurable threshold.
2014-04-25 11:58:37 +00:00
/* Returns 0 if all slots are full on a server, or 1 if there are slots available. */
static inline int server_has_room(const struct server *s) {
return !s->maxconn || s->cur_sess < srv_dynamic_maxconn(s);
}
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-26 00:48:02 +00:00
/* returns 0 if nothing has to be done for server <s> regarding queued connections,
[BUG] do not dequeue the backend's pending connections on a dead server Kai Krueger found that previous patch was incomplete, because there is an unconditionnal call to process_srv_queue() in session_free() which still causes a dead server to consume pending connections from the backend. This call was made unconditionnal so that we don't leave unserved connections in the server queue, for instance connections coming in with "option persist" which can bypass the server status check. However, the server must not touch the backend's queue if it is down. Another fear was that some connections might remain unserved when the server is using a dynamic maxconn if the number of connections to the backend is too low. Right now, srv_dynamic_maxconn() ensures this cannot happen, so the call can remain conditionnal. The fix consists in allowing a server to process it own queue whatever its state, but not to touch the backend's queue if it is down. Its queue should normally be empty when the server is down because it is redistributed when the server goes down. The only remaining cases are precisely the persistent connections with "option persist" set, coming in after the queue has been redispatched. Those ones must still be processed when a connection terminates. (cherry picked from commit cd485c44807bfcdb4928dd83c1907636b4e1b6f3)
2008-12-04 08:33:58 +00:00
* and non-zero otherwise. If the server is down, we only check its own queue. Suited
* for and if/else usage.
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-26 00:48:02 +00:00
*/
[CLEANUP] add a few "const char *" where appropriate As suggested by Markus Elfring, a few "const char *" have replaced some "char *" declarations where a function is not expected to modify a value. It does not change the code but it helps detecting coding errors.
2006-10-15 13:17:57 +00:00
static inline int may_dequeue_tasks(const struct server *s, const struct proxy *p) {
MEDIUM: check: server states and weight propagation re-work The server state and weight was reworked to handle "pending" values updated by checks/CLI/LUA/agent. These values are commited to be propagated to the LB stack. In further dev related to multi-thread, the commit will be handled into a sync point. Pending values are named using the prefix 'next_' Current values used by the LB stack are named 'cur_'
2017-08-31 12:41:55 +00:00
return (s && (s->nbpend || (p->nbpend && srv_currently_usable(s))) &&
[BUG] fix the dequeuing logic to ensure that all requests get served The dequeuing logic was completely wrong. First, a task was assigned to all servers to process the queue, but this task was never scheduled and was only woken up on session free. Second, there was no reservation of server entries when a task was assigned a server. This means that as long as the task was not connected to the server, its presence was not accounted for. This was causing trouble when detecting whether or not a server had reached maxconn. Third, during a redispatch, a session could lose its place at the server's and get blocked because another session at the same moment would have stolen the entry. Fourth, the redispatch option did not work when maxqueue was reached for a server, and it was not possible to do so without indefinitely hanging a session. The root cause of all those problems was the lack of pre-reservation of connections at the server's, and the lack of tracking of servers during a redispatch. Everything relied on combinations of flags which could appear similarly in quite distinct situations. This patch is a major rework but there was no other solution, as the internal logic was deeply flawed. The resulting code is cleaner, more understandable, uses less magics and is overall more robust. As an added bonus, "option redispatch" now works when maxqueue has been reached on a server.
2008-06-20 13:04:11 +00:00
(!s->maxconn || s->cur_sess < srv_dynamic_maxconn(s)));
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-26 00:48:02 +00:00
}
MEDIUM: add set-priority-class and set-priority-offset This adds the set-priority-class and set-priority-offset actions to http-request and tcp-request content. At this point they are not used yet, which is the purpose of the next commit, but all the logic to set and clear the values is there.
2018-05-11 16:52:31 +00:00
static inline int queue_limit_class(int class)
{
if (class < -0x7ff)
return -0x7ff;
if (class > 0x7ff)
return 0x7ff;
return class;
}
static inline int queue_limit_offset(int offset)
{
if (offset < -0x7ffff)
return -0x7ffff;
if (offset > 0x7ffff)
return 0x7ffff;
return offset;
}
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-26 00:48:02 +00:00
#endif /* _PROTO_QUEUE_H */
/*
* Local variables:
* c-indent-level: 8
* c-basic-offset: 8
* End:
*/
Reference in New Issue Copy Permalink