blob: 6ff3404413890ac5db068b808080683f80f20111 [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
2 * Queue management functions.
3 *
Willy Tarreauac68c5d2009-10-04 23:12:44 +02004 * Copyright 2000-2009 Willy Tarreau <w@1wt.eu>
Willy Tarreaubaaee002006-06-26 02:48:02 +02005 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Willy Tarreau6bdd05c2018-07-25 15:21:00 +020013/* Short explanation on the locking, which is far from being trivial : a
14 * pendconn is a list element which necessarily is associated with an existing
15 * stream. It has pendconn->strm always valid. A pendconn may only be in one of
16 * these three states :
17 * - unlinked : in this case it is an empty list head ;
18 * - linked into the server's queue ;
19 * - linked into the proxy's queue.
20 *
21 * A stream does not necessarily have such a pendconn. Thus the pendconn is
22 * designated by the stream->pend_pos pointer. This results in some properties :
23 * - pendconn->strm->pend_pos is never NULL for any valid pendconn
Patrick Hemmer0355dab2018-05-11 12:52:31 -040024 * - if p->node.node.leaf_p is NULL, the element is unlinked,
Willy Tarreau6bdd05c2018-07-25 15:21:00 +020025 * otherwise it necessarily belongs to one of the other lists ; this may
26 * not be atomically checked under threads though ;
27 * - pendconn->px is never NULL if pendconn->list is not empty
Willy Tarreau88930dd2018-07-26 07:38:54 +020028 * - pendconn->srv is never NULL if pendconn->list is in the server's queue,
Willy Tarreau6bdd05c2018-07-25 15:21:00 +020029 * and is always NULL if pendconn->list is in the backend's queue or empty.
Willy Tarreau88930dd2018-07-26 07:38:54 +020030 * - pendconn->target is NULL while the element is queued, and points to the
31 * assigned server when the pendconn is picked.
Willy Tarreau6bdd05c2018-07-25 15:21:00 +020032 *
33 * Threads complicate the design a little bit but rules remain simple :
Willy Tarreau6bdd05c2018-07-25 15:21:00 +020034 * - the server's queue lock must be held at least when manipulating the
35 * server's queue, which is when adding a pendconn to the queue and when
36 * removing a pendconn from the queue. It protects the queue's integrity.
37 *
38 * - the proxy's queue lock must be held at least when manipulating the
39 * proxy's queue, which is when adding a pendconn to the queue and when
40 * removing a pendconn from the queue. It protects the queue's integrity.
41 *
Willy Tarreau3201e4e2018-07-26 08:23:24 +020042 * - both locks are compatible and may be held at the same time.
Willy Tarreau6bdd05c2018-07-25 15:21:00 +020043 *
44 * - a pendconn_add() is only performed by the stream which will own the
45 * pendconn ; the pendconn is allocated at this moment and returned ; it is
46 * added to either the server or the proxy's queue while holding this
Willy Tarreau49801602020-06-04 22:50:02 +020047s * queue's lock.
Willy Tarreau6bdd05c2018-07-25 15:21:00 +020048 *
49 * - the pendconn is then met by a thread walking over the proxy or server's
50 * queue with the respective lock held. This lock is exclusive and the
51 * pendconn can only appear in one queue so by definition a single thread
52 * may find this pendconn at a time.
53 *
54 * - the pendconn is unlinked either by its own stream upon success/abort/
55 * free, or by another one offering it its server slot. This is achieved by
56 * pendconn_process_next_strm() under either the server or proxy's lock,
57 * pendconn_redistribute() under the server's lock, pendconn_grab_from_px()
58 * under the proxy's lock, or pendconn_unlink() under either the proxy's or
59 * the server's lock depending on the queue the pendconn is attached to.
60 *
61 * - no single operation except the pendconn initialisation prior to the
Willy Tarreau3201e4e2018-07-26 08:23:24 +020062 * insertion are performed without eithre a queue lock held or the element
63 * being unlinked and visible exclusively to its stream.
Willy Tarreau6bdd05c2018-07-25 15:21:00 +020064 *
Willy Tarreau88930dd2018-07-26 07:38:54 +020065 * - pendconn_grab_from_px() and pendconn_process_next_strm() assign ->target
66 * so that the stream knows what server to work with (via
67 * pendconn_dequeue() which sets it on strm->target).
Willy Tarreau6bdd05c2018-07-25 15:21:00 +020068 *
69 * - a pendconn doesn't switch between queues, it stays where it is.
Willy Tarreau6bdd05c2018-07-25 15:21:00 +020070 */
71
Willy Tarreaudfd3de82020-06-04 23:46:14 +020072#include <import/eb32tree.h>
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020073#include <haproxy/api.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020074#include <haproxy/backend.h>
Willy Tarreauc761f842020-06-04 11:40:28 +020075#include <haproxy/http_rules.h>
Willy Tarreaud0ef4392020-06-02 09:38:52 +020076#include <haproxy/pool.h>
Willy Tarreaua55c4542020-06-04 22:59:39 +020077#include <haproxy/queue.h>
Willy Tarreaue6ce10b2020-06-04 15:33:47 +020078#include <haproxy/sample.h>
Willy Tarreau1e56f922020-06-04 23:20:13 +020079#include <haproxy/server-t.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020080#include <haproxy/stream.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020081#include <haproxy/stream_interface.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020082#include <haproxy/task.h>
Willy Tarreau8b550af2020-06-04 17:42:48 +020083#include <haproxy/tcp_rules.h>
Willy Tarreau3f567e42020-05-28 15:29:19 +020084#include <haproxy/thread.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020085#include <haproxy/time.h>
Willy Tarreauc1a689f2021-05-08 13:59:05 +020086#include <haproxy/tools.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020087
88
Patrick Hemmer248cb4c2018-05-11 12:52:31 -040089#define NOW_OFFSET_BOUNDARY() ((now_ms - (TIMER_LOOK_BACK >> 12)) & 0xfffff)
90#define KEY_CLASS(key) ((u32)key & 0xfff00000)
91#define KEY_OFFSET(key) ((u32)key & 0x000fffff)
92#define KEY_CLASS_OFFSET_BOUNDARY(key) (KEY_CLASS(key) | NOW_OFFSET_BOUNDARY())
93#define MAKE_KEY(class, offset) (((u32)(class + 0x7ff) << 20) | ((u32)(now_ms + offset) & 0xfffff))
94
Willy Tarreau8ceae722018-11-26 11:58:30 +010095DECLARE_POOL(pool_head_pendconn, "pendconn", sizeof(struct pendconn));
Willy Tarreaubaaee002006-06-26 02:48:02 +020096
97/* returns the effective dynamic maxconn for a server, considering the minconn
Willy Tarreau86034312006-12-29 00:10:33 +010098 * and the proxy's usage relative to its dynamic connections limit. It is
Willy Tarreau9909fc12007-11-30 17:42:05 +010099 * expected that 0 < s->minconn <= s->maxconn when this is called. If the
100 * server is currently warming up, the slowstart is also applied to the
101 * resulting value, which can be lower than minconn in this case, but never
102 * less than 1.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200103 */
Willy Tarreaub17916e2006-10-15 15:17:57 +0200104unsigned int srv_dynamic_maxconn(const struct server *s)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200105{
Willy Tarreau9909fc12007-11-30 17:42:05 +0100106 unsigned int max;
107
Willy Tarreau86034312006-12-29 00:10:33 +0100108 if (s->proxy->beconn >= s->proxy->fullconn)
109 /* no fullconn or proxy is full */
Willy Tarreau9909fc12007-11-30 17:42:05 +0100110 max = s->maxconn;
111 else if (s->minconn == s->maxconn)
Willy Tarreau86034312006-12-29 00:10:33 +0100112 /* static limit */
Willy Tarreau9909fc12007-11-30 17:42:05 +0100113 max = s->maxconn;
114 else max = MAX(s->minconn,
115 s->proxy->beconn * s->maxconn / s->proxy->fullconn);
Willy Tarreau86034312006-12-29 00:10:33 +0100116
Emeric Brun52a91d32017-08-31 14:41:55 +0200117 if ((s->cur_state == SRV_ST_STARTING) &&
Willy Tarreau9909fc12007-11-30 17:42:05 +0100118 now.tv_sec < s->last_change + s->slowstart &&
119 now.tv_sec >= s->last_change) {
120 unsigned int ratio;
Willy Tarreau28a9e522008-09-14 17:43:27 +0200121 ratio = 100 * (now.tv_sec - s->last_change) / s->slowstart;
122 max = MAX(1, max * ratio / 100);
Willy Tarreau9909fc12007-11-30 17:42:05 +0100123 }
124 return max;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200125}
126
Willy Tarreau3e3ae252020-10-21 11:20:07 +0200127/* Remove the pendconn from the server's queue. At this stage, the connection
Willy Tarreau96bca332020-10-21 12:01:28 +0200128 * is not really dequeued. It will be done during the process_stream. It is
129 * up to the caller to atomically decrement the pending counts.
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100130 *
Willy Tarreau3e3ae252020-10-21 11:20:07 +0200131 * The caller must own the lock on the server queue. The pendconn must still be
132 * queued (p->node.leaf_p != NULL) and must be in a server (p->srv != NULL).
Christopher Fauletf3a55db2017-06-09 14:26:38 +0200133 */
Willy Tarreau3e3ae252020-10-21 11:20:07 +0200134static void __pendconn_unlink_srv(struct pendconn *p)
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100135{
Willy Tarreau3e3ae252020-10-21 11:20:07 +0200136 p->strm->logs.srv_queue_pos += p->srv->queue_idx - p->queue_idx;
Willy Tarreau3e3ae252020-10-21 11:20:07 +0200137 eb32_delete(&p->node);
138}
139
140/* Remove the pendconn from the proxy's queue. At this stage, the connection
Willy Tarreau96bca332020-10-21 12:01:28 +0200141 * is not really dequeued. It will be done during the process_stream. It is
142 * up to the caller to atomically decrement the pending counts.
Willy Tarreau3e3ae252020-10-21 11:20:07 +0200143 *
144 * The caller must own the lock on the proxy queue. The pendconn must still be
145 * queued (p->node.leaf_p != NULL) and must be in the proxy (p->srv == NULL).
146 */
147static void __pendconn_unlink_prx(struct pendconn *p)
148{
149 p->strm->logs.prx_queue_pos += p->px->queue_idx - p->queue_idx;
Patrick Hemmer0355dab2018-05-11 12:52:31 -0400150 eb32_delete(&p->node);
Christopher Fauletf3a55db2017-06-09 14:26:38 +0200151}
152
Willy Tarreau7c6f8a22018-07-26 08:03:14 +0200153/* Locks the queue the pendconn element belongs to. This relies on both p->px
154 * and p->srv to be properly initialized (which is always the case once the
155 * element has been added).
156 */
157static inline void pendconn_queue_lock(struct pendconn *p)
158{
159 if (p->srv)
160 HA_SPIN_LOCK(SERVER_LOCK, &p->srv->lock);
161 else
Willy Tarreauac66d6b2020-10-20 17:24:27 +0200162 HA_RWLOCK_WRLOCK(PROXY_LOCK, &p->px->lock);
Willy Tarreau7c6f8a22018-07-26 08:03:14 +0200163}
164
165/* Unlocks the queue the pendconn element belongs to. This relies on both p->px
166 * and p->srv to be properly initialized (which is always the case once the
167 * element has been added).
168 */
169static inline void pendconn_queue_unlock(struct pendconn *p)
170{
171 if (p->srv)
172 HA_SPIN_UNLOCK(SERVER_LOCK, &p->srv->lock);
173 else
Willy Tarreauac66d6b2020-10-20 17:24:27 +0200174 HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &p->px->lock);
Willy Tarreau7c6f8a22018-07-26 08:03:14 +0200175}
176
Willy Tarreau9624fae2018-07-25 08:04:20 +0200177/* Removes the pendconn from the server/proxy queue. At this stage, the
178 * connection is not really dequeued. It will be done during process_stream().
Willy Tarreau9ada0302019-11-14 14:58:39 +0100179 * This function takes all the required locks for the operation. The pendconn
180 * must be valid, though it doesn't matter if it was already unlinked. Prefer
181 * pendconn_cond_unlink() to first check <p>. When the locks are already held,
Willy Tarreau3e3ae252020-10-21 11:20:07 +0200182 * please use __pendconn_unlink_{srv,prx}() instead.
Willy Tarreau9624fae2018-07-25 08:04:20 +0200183 */
184void pendconn_unlink(struct pendconn *p)
185{
Willy Tarreau96bca332020-10-21 12:01:28 +0200186 int done = 0;
187
Willy Tarreau3e3ae252020-10-21 11:20:07 +0200188 if (p->srv) {
189 /* queued in the server */
190 HA_SPIN_LOCK(SERVER_LOCK, &p->srv->lock);
Willy Tarreau96bca332020-10-21 12:01:28 +0200191 if (p->node.node.leaf_p) {
Willy Tarreau3e3ae252020-10-21 11:20:07 +0200192 __pendconn_unlink_srv(p);
Willy Tarreau96bca332020-10-21 12:01:28 +0200193 done = 1;
194 }
Willy Tarreau3e3ae252020-10-21 11:20:07 +0200195 HA_SPIN_UNLOCK(SERVER_LOCK, &p->srv->lock);
Willy Tarreau96bca332020-10-21 12:01:28 +0200196 if (done) {
Willy Tarreau4781b152021-04-06 13:53:36 +0200197 _HA_ATOMIC_DEC(&p->srv->nbpend);
198 _HA_ATOMIC_DEC(&p->px->totpend);
Willy Tarreau96bca332020-10-21 12:01:28 +0200199 }
Willy Tarreau3e3ae252020-10-21 11:20:07 +0200200 }
201 else {
202 /* queued in the proxy */
203 HA_RWLOCK_WRLOCK(PROXY_LOCK, &p->px->lock);
Willy Tarreau96bca332020-10-21 12:01:28 +0200204 if (p->node.node.leaf_p) {
Willy Tarreau3e3ae252020-10-21 11:20:07 +0200205 __pendconn_unlink_prx(p);
Willy Tarreau96bca332020-10-21 12:01:28 +0200206 done = 1;
207 }
Willy Tarreau3e3ae252020-10-21 11:20:07 +0200208 HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &p->px->lock);
Willy Tarreau96bca332020-10-21 12:01:28 +0200209 if (done) {
Willy Tarreau4781b152021-04-06 13:53:36 +0200210 _HA_ATOMIC_DEC(&p->px->nbpend);
211 _HA_ATOMIC_DEC(&p->px->totpend);
Willy Tarreau96bca332020-10-21 12:01:28 +0200212 }
Willy Tarreau3e3ae252020-10-21 11:20:07 +0200213 }
Willy Tarreau9624fae2018-07-25 08:04:20 +0200214}
215
Patrick Hemmer248cb4c2018-05-11 12:52:31 -0400216/* Retrieve the first pendconn from tree <pendconns>. Classes are always
217 * considered first, then the time offset. The time does wrap, so the
218 * lookup is performed twice, one to retrieve the first class and a second
219 * time to retrieve the earliest time in this class.
220 */
221static struct pendconn *pendconn_first(struct eb_root *pendconns)
222{
223 struct eb32_node *node, *node2 = NULL;
224 u32 key;
225
226 node = eb32_first(pendconns);
227 if (!node)
228 return NULL;
229
230 key = KEY_CLASS_OFFSET_BOUNDARY(node->key);
231 node2 = eb32_lookup_ge(pendconns, key);
232
233 if (!node2 ||
234 KEY_CLASS(node2->key) != KEY_CLASS(node->key)) {
235 /* no other key in the tree, or in this class */
236 return eb32_entry(node, struct pendconn, node);
237 }
238
239 /* found a better key */
240 return eb32_entry(node2, struct pendconn, node);
241}
242
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100243/* Process the next pending connection from either a server or a proxy, and
Christopher Fauletfd83f0b2018-03-19 15:22:09 +0100244 * returns a strictly positive value on success (see below). If no pending
245 * connection is found, 0 is returned. Note that neither <srv> nor <px> may be
246 * NULL. Priority is given to the oldest request in the queue if both <srv> and
247 * <px> have pending requests. This ensures that no request will be left
248 * unserved. The <px> queue is not considered if the server (or a tracked
249 * server) is not RUNNING, is disabled, or has a null weight (server going
250 * down). The <srv> queue is still considered in this case, because if some
251 * connections remain there, it means that some requests have been forced there
252 * after it was seen down (eg: due to option persist). The stream is
253 * immediately marked as "assigned", and both its <srv> and <srv_conn> are set
254 * to <srv>.
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100255 *
256 * This function must only be called if the server queue _AND_ the proxy queue
Christopher Fauletfd83f0b2018-03-19 15:22:09 +0100257 * are locked. Today it is only called by process_srv_queue. When a pending
258 * connection is dequeued, this function returns 1 if the pending connection can
259 * be handled by the current thread, else it returns 2.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200260 */
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100261static int pendconn_process_next_strm(struct server *srv, struct proxy *px)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200262{
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100263 struct pendconn *p = NULL;
Patrick Hemmerda282f42018-05-11 12:52:31 -0400264 struct pendconn *pp = NULL;
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100265 struct server *rsrv;
Patrick Hemmer248cb4c2018-05-11 12:52:31 -0400266 u32 pkey, ppkey;
Willy Tarreaud132f742010-08-06 10:08:23 +0200267
Willy Tarreau44267702011-10-28 15:35:33 +0200268 rsrv = srv->track;
Willy Tarreaud132f742010-08-06 10:08:23 +0200269 if (!rsrv)
270 rsrv = srv;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200271
Willy Tarreau3201e4e2018-07-26 08:23:24 +0200272 p = NULL;
Patrick Hemmer248cb4c2018-05-11 12:52:31 -0400273 if (srv->nbpend)
274 p = pendconn_first(&srv->pendconns);
Willy Tarreau7c669d72008-06-20 15:04:11 +0200275
Patrick Hemmer248cb4c2018-05-11 12:52:31 -0400276 pp = NULL;
Willy Tarreaua8694652018-08-07 10:44:58 +0200277 if (srv_currently_usable(rsrv) && px->nbpend &&
278 (!(srv->flags & SRV_F_BACKUP) ||
279 (!px->srv_act &&
Patrick Hemmer248cb4c2018-05-11 12:52:31 -0400280 (srv == px->lbprm.fbck || (px->options & PR_O_USE_ALL_BK)))))
281 pp = pendconn_first(&px->pendconns);
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100282
Patrick Hemmer248cb4c2018-05-11 12:52:31 -0400283 if (!p && !pp)
284 return 0;
Christopher Fauletcd7126b2021-02-11 11:13:33 +0100285 else if (!pp)
286 goto use_p; /* p != NULL */
287 else if (!p)
288 goto use_pp; /* pp != NULL */
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100289
Christopher Fauletcd7126b2021-02-11 11:13:33 +0100290 /* p != NULL && pp != NULL*/
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100291
Patrick Hemmer248cb4c2018-05-11 12:52:31 -0400292 if (KEY_CLASS(p->node.key) < KEY_CLASS(pp->node.key))
293 goto use_p;
294
295 if (KEY_CLASS(pp->node.key) < KEY_CLASS(p->node.key))
296 goto use_pp;
297
298 pkey = KEY_OFFSET(p->node.key);
299 ppkey = KEY_OFFSET(pp->node.key);
300
301 if (pkey < NOW_OFFSET_BOUNDARY())
302 pkey += 0x100000; // key in the future
303
304 if (ppkey < NOW_OFFSET_BOUNDARY())
305 ppkey += 0x100000; // key in the future
306
307 if (pkey <= ppkey)
308 goto use_p;
309
310 use_pp:
311 /* Let's switch from the server pendconn to the proxy pendconn */
Willy Tarreau3e3ae252020-10-21 11:20:07 +0200312 __pendconn_unlink_prx(pp);
Willy Tarreau4781b152021-04-06 13:53:36 +0200313 _HA_ATOMIC_DEC(&px->nbpend);
314 _HA_ATOMIC_DEC(&px->totpend);
Willy Tarreau3e3ae252020-10-21 11:20:07 +0200315 px->queue_idx++;
Patrick Hemmer248cb4c2018-05-11 12:52:31 -0400316 p = pp;
Willy Tarreau3e3ae252020-10-21 11:20:07 +0200317 goto unlinked;
Patrick Hemmer248cb4c2018-05-11 12:52:31 -0400318 use_p:
Willy Tarreau3e3ae252020-10-21 11:20:07 +0200319 __pendconn_unlink_srv(p);
Willy Tarreau4781b152021-04-06 13:53:36 +0200320 _HA_ATOMIC_DEC(&srv->nbpend);
321 _HA_ATOMIC_DEC(&px->totpend);
Willy Tarreau3e3ae252020-10-21 11:20:07 +0200322 srv->queue_idx++;
323 unlinked:
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100324 p->strm_flags |= SF_ASSIGNED;
Willy Tarreau88930dd2018-07-26 07:38:54 +0200325 p->target = srv;
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100326
Willy Tarreau4781b152021-04-06 13:53:36 +0200327 _HA_ATOMIC_INC(&srv->served);
328 _HA_ATOMIC_INC(&srv->proxy->served);
Olivier Houchardb4df4922019-03-08 18:54:16 +0100329 __ha_barrier_atomic_store();
Willy Tarreau7c669d72008-06-20 15:04:11 +0200330 if (px->lbprm.server_take_conn)
Willy Tarreau59b0fec2021-02-17 16:01:37 +0100331 px->lbprm.server_take_conn(srv, 1);
Willy Tarreau751153e2021-02-17 13:33:24 +0100332 stream_add_srv_conn(p->strm, srv);
Willy Tarreau7c669d72008-06-20 15:04:11 +0200333
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100334 task_wakeup(p->strm->task, TASK_WOKEN_RES);
Christopher Fauletfd83f0b2018-03-19 15:22:09 +0100335
Olivier Houchardecfe6732018-07-26 18:47:27 +0200336 return 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200337}
338
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100339/* Manages a server's connection queue. This function will try to dequeue as
Christopher Faulet87566c92017-06-06 10:34:51 +0200340 * many pending streams as possible, and wake them up.
341 */
342void process_srv_queue(struct server *s)
343{
344 struct proxy *p = s->proxy;
Olivier Houchardecfe6732018-07-26 18:47:27 +0200345 int maxconn;
Christopher Faulet87566c92017-06-06 10:34:51 +0200346
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100347 HA_SPIN_LOCK(SERVER_LOCK, &s->lock);
Willy Tarreauac66d6b2020-10-20 17:24:27 +0200348 HA_RWLOCK_WRLOCK(PROXY_LOCK, &p->lock);
Christopher Faulet87566c92017-06-06 10:34:51 +0200349 maxconn = srv_dynamic_maxconn(s);
350 while (s->served < maxconn) {
Christopher Fauletfd83f0b2018-03-19 15:22:09 +0100351 int ret = pendconn_process_next_strm(s, p);
352 if (!ret)
Christopher Faulet87566c92017-06-06 10:34:51 +0200353 break;
Christopher Faulet87566c92017-06-06 10:34:51 +0200354 }
Willy Tarreauac66d6b2020-10-20 17:24:27 +0200355 HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &p->lock);
Willy Tarreau5e83d992019-07-30 11:59:34 +0200356 HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
Christopher Faulet87566c92017-06-06 10:34:51 +0200357}
358
Patrick Hemmer248cb4c2018-05-11 12:52:31 -0400359/* Adds the stream <strm> to the pending connection queue of server <strm>->srv
Willy Tarreau87b09662015-04-03 00:22:06 +0200360 * or to the one of <strm>->proxy if srv is NULL. All counters and back pointers
Willy Tarreaubaaee002006-06-26 02:48:02 +0200361 * are updated accordingly. Returns NULL if no memory is available, otherwise the
Willy Tarreau87b09662015-04-03 00:22:06 +0200362 * pendconn itself. If the stream was already marked as served, its flag is
363 * cleared. It is illegal to call this function with a non-NULL strm->srv_conn.
Patrick Hemmerda282f42018-05-11 12:52:31 -0400364 * The stream's queue position is counted with an offset of -1 because we want
365 * to make sure that being at the first position in the queue reports 1.
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100366 *
Patrick Hemmer248cb4c2018-05-11 12:52:31 -0400367 * The queue is sorted by the composition of the priority_class, and the current
368 * timestamp offset by strm->priority_offset. The timestamp is in milliseconds
369 * and truncated to 20 bits, so will wrap every 17m28s575ms.
370 * The offset can be positive or negative, and an offset of 0 puts it in the
371 * middle of this range (~ 8 min). Note that this also means if the adjusted
372 * timestamp wraps around, the request will be misinterpreted as being of
Joseph Herlantd8499ec2018-11-25 11:26:48 -0800373 * the highest priority for that priority class.
Patrick Hemmer248cb4c2018-05-11 12:52:31 -0400374 *
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100375 * This function must be called by the stream itself, so in the context of
376 * process_stream.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200377 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200378struct pendconn *pendconn_add(struct stream *strm)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200379{
380 struct pendconn *p;
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100381 struct proxy *px;
382 struct server *srv;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200383
Willy Tarreaubafbe012017-11-24 17:34:44 +0100384 p = pool_alloc(pool_head_pendconn);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200385 if (!p)
386 return NULL;
387
Willy Tarreau7c6f8a22018-07-26 08:03:14 +0200388 if (strm->flags & SF_ASSIGNED)
389 srv = objt_server(strm->target);
390 else
391 srv = NULL;
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100392
Willy Tarreau7c6f8a22018-07-26 08:03:14 +0200393 px = strm->be;
Willy Tarreau88930dd2018-07-26 07:38:54 +0200394 p->target = NULL;
Willy Tarreau7c6f8a22018-07-26 08:03:14 +0200395 p->srv = srv;
Patrick Hemmer248cb4c2018-05-11 12:52:31 -0400396 p->node.key = MAKE_KEY(strm->priority_class, strm->priority_offset);
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100397 p->px = px;
398 p->strm = strm;
399 p->strm_flags = strm->flags;
Willy Tarreau7c669d72008-06-20 15:04:11 +0200400
Willy Tarreau7c6f8a22018-07-26 08:03:14 +0200401 if (srv) {
Willy Tarreau56c1cfb2020-10-21 11:45:44 +0200402 unsigned int old_max, new_max;
403
Willy Tarreau1db42732021-04-06 11:44:07 +0200404 new_max = _HA_ATOMIC_ADD_FETCH(&srv->nbpend, 1);
Willy Tarreau56c1cfb2020-10-21 11:45:44 +0200405 old_max = srv->counters.nbpend_max;
406 while (new_max > old_max) {
407 if (likely(_HA_ATOMIC_CAS(&srv->counters.nbpend_max, &old_max, new_max)))
408 break;
409 }
410 __ha_barrier_atomic_store();
411
Willy Tarreauc7eedf72020-10-21 11:31:12 +0200412 HA_SPIN_LOCK(SERVER_LOCK, &p->srv->lock);
Patrick Hemmerda282f42018-05-11 12:52:31 -0400413 p->queue_idx = srv->queue_idx - 1; // for increment
Patrick Hemmer0355dab2018-05-11 12:52:31 -0400414 eb32_insert(&srv->pendconns, &p->node);
Willy Tarreauc7eedf72020-10-21 11:31:12 +0200415 HA_SPIN_UNLOCK(SERVER_LOCK, &p->srv->lock);
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100416 }
417 else {
Willy Tarreau56c1cfb2020-10-21 11:45:44 +0200418 unsigned int old_max, new_max;
419
Willy Tarreau1db42732021-04-06 11:44:07 +0200420 new_max = _HA_ATOMIC_ADD_FETCH(&px->nbpend, 1);
Willy Tarreau56c1cfb2020-10-21 11:45:44 +0200421 old_max = px->be_counters.nbpend_max;
422 while (new_max > old_max) {
423 if (likely(_HA_ATOMIC_CAS(&px->be_counters.nbpend_max, &old_max, new_max)))
424 break;
425 }
426 __ha_barrier_atomic_store();
427
Willy Tarreauc7eedf72020-10-21 11:31:12 +0200428 HA_RWLOCK_WRLOCK(PROXY_LOCK, &p->px->lock);
Patrick Hemmerda282f42018-05-11 12:52:31 -0400429 p->queue_idx = px->queue_idx - 1; // for increment
Patrick Hemmer0355dab2018-05-11 12:52:31 -0400430 eb32_insert(&px->pendconns, &p->node);
Willy Tarreauc7eedf72020-10-21 11:31:12 +0200431 HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &p->px->lock);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200432 }
Willy Tarreau7c6f8a22018-07-26 08:03:14 +0200433 strm->pend_pos = p;
434
Willy Tarreau4781b152021-04-06 13:53:36 +0200435 _HA_ATOMIC_INC(&px->totpend);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200436 return p;
437}
438
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200439/* Redistribute pending connections when a server goes down. The number of
Willy Tarreaudeca26c2018-08-21 18:11:03 +0200440 * connections redistributed is returned. It must be called with the server
441 * lock held.
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200442 */
443int pendconn_redistribute(struct server *s)
444{
Patrick Hemmer0355dab2018-05-11 12:52:31 -0400445 struct pendconn *p;
Willy Tarreaubff005a2019-05-27 08:10:11 +0200446 struct eb32_node *node, *nodeb;
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200447 int xferred = 0;
448
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100449 /* The REDISP option was specified. We will ignore cookie and force to
450 * balance or use the dispatcher. */
451 if ((s->proxy->options & (PR_O_REDISP|PR_O_PERSIST)) != PR_O_REDISP)
452 return 0;
453
Willy Tarreaubff005a2019-05-27 08:10:11 +0200454 for (node = eb32_first(&s->pendconns); node; node = nodeb) {
455 nodeb = eb32_next(node);
456
457 p = eb32_entry(node, struct pendconn, node);
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100458 if (p->strm_flags & SF_FORCE_PRST)
459 continue;
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200460
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100461 /* it's left to the dispatcher to choose a server */
Willy Tarreau3e3ae252020-10-21 11:20:07 +0200462 __pendconn_unlink_srv(p);
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100463 p->strm_flags &= ~(SF_DIRECT | SF_ASSIGNED | SF_ADDR_SET);
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200464
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100465 task_wakeup(p->strm->task, TASK_WOKEN_RES);
Willy Tarreauef71f012020-10-21 11:54:38 +0200466 xferred++;
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200467 }
Willy Tarreau96bca332020-10-21 12:01:28 +0200468 if (xferred) {
Willy Tarreau5472aa52020-10-24 12:57:41 +0200469 _HA_ATOMIC_SUB(&s->nbpend, xferred);
470 _HA_ATOMIC_SUB(&s->proxy->totpend, xferred);
Willy Tarreau96bca332020-10-21 12:01:28 +0200471 }
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200472 return xferred;
473}
474
475/* Check for pending connections at the backend, and assign some of them to
476 * the server coming up. The server's weight is checked before being assigned
477 * connections it may not be able to handle. The total number of transferred
Willy Tarreau5e83d992019-07-30 11:59:34 +0200478 * connections is returned. It must be called with the server lock held, and
479 * will take the proxy's lock.
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200480 */
481int pendconn_grab_from_px(struct server *s)
482{
Patrick Hemmer0355dab2018-05-11 12:52:31 -0400483 struct pendconn *p;
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100484 int maxconn, xferred = 0;
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200485
Emeric Brun52a91d32017-08-31 14:41:55 +0200486 if (!srv_currently_usable(s))
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200487 return 0;
488
Willy Tarreaua8694652018-08-07 10:44:58 +0200489 /* if this is a backup server and there are active servers or at
490 * least another backup server was elected, then this one must
491 * not dequeue requests from the proxy.
492 */
493 if ((s->flags & SRV_F_BACKUP) &&
494 (s->proxy->srv_act ||
495 ((s != s->proxy->lbprm.fbck) && !(s->proxy->options & PR_O_USE_ALL_BK))))
496 return 0;
497
Willy Tarreauac66d6b2020-10-20 17:24:27 +0200498 HA_RWLOCK_WRLOCK(PROXY_LOCK, &s->proxy->lock);
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100499 maxconn = srv_dynamic_maxconn(s);
Patrick Hemmer248cb4c2018-05-11 12:52:31 -0400500 while ((p = pendconn_first(&s->proxy->pendconns))) {
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100501 if (s->maxconn && s->served + xferred >= maxconn)
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200502 break;
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100503
Willy Tarreau3e3ae252020-10-21 11:20:07 +0200504 __pendconn_unlink_prx(p);
Willy Tarreau88930dd2018-07-26 07:38:54 +0200505 p->target = s;
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100506
507 task_wakeup(p->strm->task, TASK_WOKEN_RES);
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100508 xferred++;
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200509 }
Willy Tarreauac66d6b2020-10-20 17:24:27 +0200510 HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &s->proxy->lock);
Willy Tarreau96bca332020-10-21 12:01:28 +0200511 if (xferred) {
Willy Tarreau5472aa52020-10-24 12:57:41 +0200512 _HA_ATOMIC_SUB(&s->proxy->nbpend, xferred);
513 _HA_ATOMIC_SUB(&s->proxy->totpend, xferred);
Willy Tarreau96bca332020-10-21 12:01:28 +0200514 }
Willy Tarreau4aac7db2014-05-16 11:48:10 +0200515 return xferred;
516}
517
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100518/* Try to dequeue pending connection attached to the stream <strm>. It must
519 * always exists here. If the pendconn is still linked to the server or the
520 * proxy queue, nothing is done and the function returns 1. Otherwise,
521 * <strm>->flags and <strm>->target are updated, the pendconn is released and 0
522 * is returned.
523 *
524 * This function must be called by the stream itself, so in the context of
525 * process_stream.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200526 */
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100527int pendconn_dequeue(struct stream *strm)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200528{
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100529 struct pendconn *p;
Willy Tarreau3201e4e2018-07-26 08:23:24 +0200530 int is_unlinked;
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100531
532 if (unlikely(!strm->pend_pos)) {
533 /* unexpected case because it is called by the stream itself and
534 * only the stream can release a pendconn. So it is only
535 * possible if a pendconn is released by someone else or if the
536 * stream is supposed to be queued but without its associated
537 * pendconn. In both cases it is a bug! */
538 abort();
Christopher Faulet8ba59142017-06-27 15:43:53 +0200539 }
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100540 p = strm->pend_pos;
Willy Tarreau3201e4e2018-07-26 08:23:24 +0200541
542 /* note below : we need to grab the queue's lock to check for emptiness
543 * because we don't want a partial _grab_from_px() or _redistribute()
544 * to be called in parallel and show an empty list without having the
545 * time to finish. With this we know that if we see the element
546 * unlinked, these functions were completely done.
547 */
548 pendconn_queue_lock(p);
Patrick Hemmer0355dab2018-05-11 12:52:31 -0400549 is_unlinked = !p->node.node.leaf_p;
Willy Tarreau3201e4e2018-07-26 08:23:24 +0200550 pendconn_queue_unlock(p);
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100551
Willy Tarreau3201e4e2018-07-26 08:23:24 +0200552 if (!is_unlinked)
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100553 return 1;
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100554
Willy Tarreau3201e4e2018-07-26 08:23:24 +0200555 /* the pendconn is not queued anymore and will not be so we're safe
556 * to proceed.
557 */
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100558 strm->flags &= ~(SF_DIRECT | SF_ASSIGNED | SF_ADDR_SET);
559 strm->flags |= p->strm_flags & (SF_DIRECT | SF_ASSIGNED | SF_ADDR_SET);
Willy Tarreaua6cce192021-06-16 08:42:23 +0200560
561 if (p->target) {
562 /* a server picked this pendconn, it must skip LB */
563 strm->target = &p->target->obj_type;
564 strm->flags |= SF_ASSIGNED;
565 }
566
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100567 strm->pend_pos = NULL;
Willy Tarreaubafbe012017-11-24 17:34:44 +0100568 pool_free(pool_head_pendconn, p);
Christopher Faulet5cd4bbd2018-03-14 16:18:06 +0100569 return 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200570}
571
Patrick Hemmer268a7072018-05-11 12:52:31 -0400572static enum act_return action_set_priority_class(struct act_rule *rule, struct proxy *px,
573 struct session *sess, struct stream *s, int flags)
574{
575 struct sample *smp;
576
577 smp = sample_fetch_as_type(px, sess, s, SMP_OPT_DIR_REQ|SMP_OPT_FINAL, rule->arg.expr, SMP_T_SINT);
578 if (!smp)
579 return ACT_RET_CONT;
580
581 s->priority_class = queue_limit_class(smp->data.u.sint);
582 return ACT_RET_CONT;
583}
584
585static enum act_return action_set_priority_offset(struct act_rule *rule, struct proxy *px,
586 struct session *sess, struct stream *s, int flags)
587{
588 struct sample *smp;
589
590 smp = sample_fetch_as_type(px, sess, s, SMP_OPT_DIR_REQ|SMP_OPT_FINAL, rule->arg.expr, SMP_T_SINT);
591 if (!smp)
592 return ACT_RET_CONT;
593
594 s->priority_offset = queue_limit_offset(smp->data.u.sint);
595
596 return ACT_RET_CONT;
597}
598
599static enum act_parse_ret parse_set_priority_class(const char **args, int *arg, struct proxy *px,
600 struct act_rule *rule, char **err)
601{
602 unsigned int where = 0;
603
604 rule->arg.expr = sample_parse_expr((char **)args, arg, px->conf.args.file,
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100605 px->conf.args.line, err, &px->conf.args, NULL);
Patrick Hemmer268a7072018-05-11 12:52:31 -0400606 if (!rule->arg.expr)
607 return ACT_RET_PRS_ERR;
608
609 if (px->cap & PR_CAP_FE)
610 where |= SMP_VAL_FE_HRQ_HDR;
611 if (px->cap & PR_CAP_BE)
612 where |= SMP_VAL_BE_HRQ_HDR;
613
614 if (!(rule->arg.expr->fetch->val & where)) {
615 memprintf(err,
616 "fetch method '%s' extracts information from '%s', none of which is available here",
617 args[0], sample_src_names(rule->arg.expr->fetch->use));
618 free(rule->arg.expr);
619 return ACT_RET_PRS_ERR;
620 }
621
622 rule->action = ACT_CUSTOM;
623 rule->action_ptr = action_set_priority_class;
624 return ACT_RET_PRS_OK;
625}
626
627static enum act_parse_ret parse_set_priority_offset(const char **args, int *arg, struct proxy *px,
628 struct act_rule *rule, char **err)
629{
630 unsigned int where = 0;
631
632 rule->arg.expr = sample_parse_expr((char **)args, arg, px->conf.args.file,
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100633 px->conf.args.line, err, &px->conf.args, NULL);
Patrick Hemmer268a7072018-05-11 12:52:31 -0400634 if (!rule->arg.expr)
635 return ACT_RET_PRS_ERR;
636
637 if (px->cap & PR_CAP_FE)
638 where |= SMP_VAL_FE_HRQ_HDR;
639 if (px->cap & PR_CAP_BE)
640 where |= SMP_VAL_BE_HRQ_HDR;
641
642 if (!(rule->arg.expr->fetch->val & where)) {
643 memprintf(err,
644 "fetch method '%s' extracts information from '%s', none of which is available here",
645 args[0], sample_src_names(rule->arg.expr->fetch->use));
646 free(rule->arg.expr);
647 return ACT_RET_PRS_ERR;
648 }
649
650 rule->action = ACT_CUSTOM;
651 rule->action_ptr = action_set_priority_offset;
652 return ACT_RET_PRS_OK;
653}
654
655static struct action_kw_list tcp_cont_kws = {ILH, {
656 { "set-priority-class", parse_set_priority_class },
657 { "set-priority-offset", parse_set_priority_offset },
658 { /* END */ }
659}};
660
Willy Tarreau0108d902018-11-25 19:14:37 +0100661INITCALL1(STG_REGISTER, tcp_req_cont_keywords_register, &tcp_cont_kws);
662
Patrick Hemmer268a7072018-05-11 12:52:31 -0400663static struct action_kw_list http_req_kws = {ILH, {
664 { "set-priority-class", parse_set_priority_class },
665 { "set-priority-offset", parse_set_priority_offset },
666 { /* END */ }
667}};
668
Willy Tarreau0108d902018-11-25 19:14:37 +0100669INITCALL1(STG_REGISTER, http_req_keywords_register, &http_req_kws);
670
Patrick Hemmer268a7072018-05-11 12:52:31 -0400671static int
672smp_fetch_priority_class(const struct arg *args, struct sample *smp, const char *kw, void *private)
673{
674 if (!smp->strm)
675 return 0;
676
677 smp->data.type = SMP_T_SINT;
678 smp->data.u.sint = smp->strm->priority_class;
679
680 return 1;
681}
682
683static int
684smp_fetch_priority_offset(const struct arg *args, struct sample *smp, const char *kw, void *private)
685{
686 if (!smp->strm)
687 return 0;
688
689 smp->data.type = SMP_T_SINT;
690 smp->data.u.sint = smp->strm->priority_offset;
691
692 return 1;
693}
694
695
696static struct sample_fetch_kw_list smp_kws = {ILH, {
697 { "prio_class", smp_fetch_priority_class, 0, NULL, SMP_T_SINT, SMP_USE_INTRN, },
698 { "prio_offset", smp_fetch_priority_offset, 0, NULL, SMP_T_SINT, SMP_USE_INTRN, },
699 { /* END */},
700}};
701
Willy Tarreau0108d902018-11-25 19:14:37 +0100702INITCALL1(STG_REGISTER, sample_register_fetches, &smp_kws);
Patrick Hemmer268a7072018-05-11 12:52:31 -0400703
Willy Tarreaubaaee002006-06-26 02:48:02 +0200704/*
705 * Local variables:
706 * c-indent-level: 8
707 * c-basic-offset: 8
708 * End:
709 */