blob: 409e5f821054b7b4a73443c731682e844b4e4720 [file] [log] [blame]
Willy Tarreauf89c1872009-10-01 11:19:37 +02001/*
2 * Fast Weighted Least Connection load balancing algorithm.
3 *
4 * Copyright 2000-2009 Willy Tarreau <w@1wt.eu>
5 *
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
13#include <common/compat.h>
14#include <common/config.h>
15#include <common/debug.h>
Willy Tarreau8d2b7772020-05-27 10:58:19 +020016#include <import/eb32tree.h>
Willy Tarreauf89c1872009-10-01 11:19:37 +020017
18#include <types/global.h>
19#include <types/server.h>
20
21#include <proto/backend.h>
22#include <proto/queue.h>
23
24
25/* Remove a server from a tree. It must have previously been dequeued. This
26 * function is meant to be called when a server is going down or has its
27 * weight disabled.
Willy Tarreau1b877482018-08-21 19:44:53 +020028 *
29 * The server's lock and the lbprm's lock must be held.
Willy Tarreauf89c1872009-10-01 11:19:37 +020030 */
31static inline void fwlc_remove_from_tree(struct server *s)
32{
33 s->lb_tree = NULL;
34}
35
Willy Tarreau1b877482018-08-21 19:44:53 +020036/* simply removes a server from a tree.
37 *
38 * The server's lock and the lbprm's lock must be held.
39 */
Willy Tarreauf89c1872009-10-01 11:19:37 +020040static inline void fwlc_dequeue_srv(struct server *s)
41{
42 eb32_delete(&s->lb_node);
43}
44
45/* Queue a server in its associated tree, assuming the weight is >0.
Willy Tarreau1eb6c552018-12-14 08:33:28 +010046 * Servers are sorted by (#conns+1)/weight. To ensure maximum accuracy,
47 * we use (#conns+1)*SRV_EWGHT_MAX/eweight as the sorting key. The reason
48 * for using #conns+1 is to sort by weights in case the server is picked
49 * and not before it is picked. This provides a better load accuracy for
50 * low connection counts when weights differ and makes sure the round-robin
Willy Tarreaued5ac9c2019-09-06 17:04:04 +020051 * applies between servers of highest weight first. However servers with no
52 * connection are always picked first so that under low loads, it's not
53 * always the single server with the highest weight that gets picked.
Willy Tarreau1b877482018-08-21 19:44:53 +020054 *
55 * The server's lock and the lbprm's lock must be held.
Willy Tarreauf89c1872009-10-01 11:19:37 +020056 */
57static inline void fwlc_queue_srv(struct server *s)
58{
Willy Tarreaued5ac9c2019-09-06 17:04:04 +020059 s->lb_node.key = s->served ? (s->served + 1) * SRV_EWGHT_MAX / s->next_eweight : 0;
Willy Tarreauf89c1872009-10-01 11:19:37 +020060 eb32_insert(s->lb_tree, &s->lb_node);
61}
62
63/* Re-position the server in the FWLC tree after it has been assigned one
64 * connection or after it has released one. Note that it is possible that
65 * the server has been moved out of the tree due to failed health-checks.
Willy Tarreau1b877482018-08-21 19:44:53 +020066 *
67 * The server's lock must be held. The lbprm's lock will be used.
Willy Tarreauf89c1872009-10-01 11:19:37 +020068 */
69static void fwlc_srv_reposition(struct server *s)
70{
Christopher Faulet2a944ee2017-11-07 10:42:54 +010071 HA_SPIN_LOCK(LBPRM_LOCK, &s->proxy->lbprm.lock);
Christopher Faulet1ae2a882019-06-19 10:50:38 +020072 if (s->lb_tree) {
73 fwlc_dequeue_srv(s);
74 fwlc_queue_srv(s);
75 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +010076 HA_SPIN_UNLOCK(LBPRM_LOCK, &s->proxy->lbprm.lock);
Willy Tarreauf89c1872009-10-01 11:19:37 +020077}
78
79/* This function updates the server trees according to server <srv>'s new
80 * state. It should be called when server <srv>'s status changes to down.
81 * It is not important whether the server was already down or not. It is not
82 * important either that the new state is completely down (the caller may not
83 * know all the variables of a server's state).
Willy Tarreau1b877482018-08-21 19:44:53 +020084 *
85 * The server's lock must be held. The lbprm's lock will be used.
Willy Tarreauf89c1872009-10-01 11:19:37 +020086 */
87static void fwlc_set_server_status_down(struct server *srv)
88{
89 struct proxy *p = srv->proxy;
90
Willy Tarreauc5150da2014-05-13 19:27:31 +020091 if (!srv_lb_status_changed(srv))
Willy Tarreauf89c1872009-10-01 11:19:37 +020092 return;
93
Emeric Brun52a91d32017-08-31 14:41:55 +020094 if (srv_willbe_usable(srv))
Willy Tarreauf89c1872009-10-01 11:19:37 +020095 goto out_update_state;
Willy Tarreau1b877482018-08-21 19:44:53 +020096 HA_SPIN_LOCK(LBPRM_LOCK, &p->lbprm.lock);
97
Willy Tarreauf89c1872009-10-01 11:19:37 +020098
Emeric Brun52a91d32017-08-31 14:41:55 +020099 if (!srv_currently_usable(srv))
Willy Tarreauf89c1872009-10-01 11:19:37 +0200100 /* server was already down */
101 goto out_update_backend;
102
Willy Tarreauc93cd162014-05-13 15:54:22 +0200103 if (srv->flags & SRV_F_BACKUP) {
Emeric Brun52a91d32017-08-31 14:41:55 +0200104 p->lbprm.tot_wbck -= srv->cur_eweight;
Willy Tarreauf89c1872009-10-01 11:19:37 +0200105 p->srv_bck--;
106
107 if (srv == p->lbprm.fbck) {
108 /* we lost the first backup server in a single-backup
109 * configuration, we must search another one.
110 */
111 struct server *srv2 = p->lbprm.fbck;
112 do {
113 srv2 = srv2->next;
114 } while (srv2 &&
Willy Tarreauc93cd162014-05-13 15:54:22 +0200115 !((srv2->flags & SRV_F_BACKUP) &&
Emeric Brun52a91d32017-08-31 14:41:55 +0200116 srv_willbe_usable(srv2)));
Willy Tarreauf89c1872009-10-01 11:19:37 +0200117 p->lbprm.fbck = srv2;
118 }
119 } else {
Emeric Brun52a91d32017-08-31 14:41:55 +0200120 p->lbprm.tot_wact -= srv->cur_eweight;
Willy Tarreauf89c1872009-10-01 11:19:37 +0200121 p->srv_act--;
122 }
123
124 fwlc_dequeue_srv(srv);
125 fwlc_remove_from_tree(srv);
126
127out_update_backend:
128 /* check/update tot_used, tot_weight */
129 update_backend_weight(p);
Willy Tarreau1b877482018-08-21 19:44:53 +0200130 HA_SPIN_UNLOCK(LBPRM_LOCK, &p->lbprm.lock);
131
Willy Tarreauf89c1872009-10-01 11:19:37 +0200132 out_update_state:
Willy Tarreauc5150da2014-05-13 19:27:31 +0200133 srv_lb_commit_status(srv);
Willy Tarreauf89c1872009-10-01 11:19:37 +0200134}
135
136/* This function updates the server trees according to server <srv>'s new
137 * state. It should be called when server <srv>'s status changes to up.
138 * It is not important whether the server was already down or not. It is not
139 * important either that the new state is completely UP (the caller may not
140 * know all the variables of a server's state). This function will not change
141 * the weight of a server which was already up.
Willy Tarreau1b877482018-08-21 19:44:53 +0200142 *
143 * The server's lock must be held. The lbprm's lock will be used.
Willy Tarreauf89c1872009-10-01 11:19:37 +0200144 */
145static void fwlc_set_server_status_up(struct server *srv)
146{
147 struct proxy *p = srv->proxy;
148
Willy Tarreauc5150da2014-05-13 19:27:31 +0200149 if (!srv_lb_status_changed(srv))
Willy Tarreauf89c1872009-10-01 11:19:37 +0200150 return;
151
Emeric Brun52a91d32017-08-31 14:41:55 +0200152 if (!srv_willbe_usable(srv))
Willy Tarreauf89c1872009-10-01 11:19:37 +0200153 goto out_update_state;
154
Willy Tarreau1b877482018-08-21 19:44:53 +0200155 HA_SPIN_LOCK(LBPRM_LOCK, &p->lbprm.lock);
156
Emeric Brun52a91d32017-08-31 14:41:55 +0200157 if (srv_currently_usable(srv))
Willy Tarreauf89c1872009-10-01 11:19:37 +0200158 /* server was already up */
159 goto out_update_backend;
160
Willy Tarreauc93cd162014-05-13 15:54:22 +0200161 if (srv->flags & SRV_F_BACKUP) {
Willy Tarreauf89c1872009-10-01 11:19:37 +0200162 srv->lb_tree = &p->lbprm.fwlc.bck;
Emeric Brun52a91d32017-08-31 14:41:55 +0200163 p->lbprm.tot_wbck += srv->next_eweight;
Willy Tarreauf89c1872009-10-01 11:19:37 +0200164 p->srv_bck++;
165
166 if (!(p->options & PR_O_USE_ALL_BK)) {
167 if (!p->lbprm.fbck) {
168 /* there was no backup server anymore */
169 p->lbprm.fbck = srv;
170 } else {
171 /* we may have restored a backup server prior to fbck,
172 * in which case it should replace it.
173 */
174 struct server *srv2 = srv;
175 do {
176 srv2 = srv2->next;
177 } while (srv2 && (srv2 != p->lbprm.fbck));
178 if (srv2)
179 p->lbprm.fbck = srv;
180 }
181 }
182 } else {
183 srv->lb_tree = &p->lbprm.fwlc.act;
Emeric Brun52a91d32017-08-31 14:41:55 +0200184 p->lbprm.tot_wact += srv->next_eweight;
Willy Tarreauf89c1872009-10-01 11:19:37 +0200185 p->srv_act++;
186 }
187
188 /* note that eweight cannot be 0 here */
189 fwlc_queue_srv(srv);
190
191 out_update_backend:
192 /* check/update tot_used, tot_weight */
193 update_backend_weight(p);
Willy Tarreau1b877482018-08-21 19:44:53 +0200194 HA_SPIN_UNLOCK(LBPRM_LOCK, &p->lbprm.lock);
195
Willy Tarreauf89c1872009-10-01 11:19:37 +0200196 out_update_state:
Willy Tarreauc5150da2014-05-13 19:27:31 +0200197 srv_lb_commit_status(srv);
Willy Tarreauf89c1872009-10-01 11:19:37 +0200198}
199
200/* This function must be called after an update to server <srv>'s effective
201 * weight. It may be called after a state change too.
Willy Tarreau1b877482018-08-21 19:44:53 +0200202 *
203 * The server's lock must be held. The lbprm's lock will be used.
Willy Tarreauf89c1872009-10-01 11:19:37 +0200204 */
205static void fwlc_update_server_weight(struct server *srv)
206{
207 int old_state, new_state;
208 struct proxy *p = srv->proxy;
209
Willy Tarreauc5150da2014-05-13 19:27:31 +0200210 if (!srv_lb_status_changed(srv))
Willy Tarreauf89c1872009-10-01 11:19:37 +0200211 return;
212
213 /* If changing the server's weight changes its state, we simply apply
214 * the procedures we already have for status change. If the state
215 * remains down, the server is not in any tree, so it's as easy as
216 * updating its values. If the state remains up with different weights,
217 * there are some computations to perform to find a new place and
218 * possibly a new tree for this server.
219 */
220
Emeric Brun52a91d32017-08-31 14:41:55 +0200221 old_state = srv_currently_usable(srv);
222 new_state = srv_willbe_usable(srv);
Willy Tarreauf89c1872009-10-01 11:19:37 +0200223
224 if (!old_state && !new_state) {
Willy Tarreauc5150da2014-05-13 19:27:31 +0200225 srv_lb_commit_status(srv);
Willy Tarreauf89c1872009-10-01 11:19:37 +0200226 return;
227 }
228 else if (!old_state && new_state) {
229 fwlc_set_server_status_up(srv);
230 return;
231 }
232 else if (old_state && !new_state) {
233 fwlc_set_server_status_down(srv);
234 return;
235 }
236
Willy Tarreau1b877482018-08-21 19:44:53 +0200237 HA_SPIN_LOCK(LBPRM_LOCK, &p->lbprm.lock);
238
Willy Tarreauf89c1872009-10-01 11:19:37 +0200239 if (srv->lb_tree)
240 fwlc_dequeue_srv(srv);
241
Willy Tarreauc93cd162014-05-13 15:54:22 +0200242 if (srv->flags & SRV_F_BACKUP) {
Emeric Brun52a91d32017-08-31 14:41:55 +0200243 p->lbprm.tot_wbck += srv->next_eweight - srv->cur_eweight;
Willy Tarreauf89c1872009-10-01 11:19:37 +0200244 srv->lb_tree = &p->lbprm.fwlc.bck;
245 } else {
Emeric Brun52a91d32017-08-31 14:41:55 +0200246 p->lbprm.tot_wact += srv->next_eweight - srv->cur_eweight;
Willy Tarreauf89c1872009-10-01 11:19:37 +0200247 srv->lb_tree = &p->lbprm.fwlc.act;
248 }
249
250 fwlc_queue_srv(srv);
251
252 update_backend_weight(p);
Willy Tarreau1b877482018-08-21 19:44:53 +0200253 HA_SPIN_UNLOCK(LBPRM_LOCK, &p->lbprm.lock);
254
Willy Tarreauc5150da2014-05-13 19:27:31 +0200255 srv_lb_commit_status(srv);
Willy Tarreauf89c1872009-10-01 11:19:37 +0200256}
257
258/* This function is responsible for building the trees in case of fast
259 * weighted least-conns. It also sets p->lbprm.wdiv to the eweight to
260 * uweight ratio. Both active and backup groups are initialized.
261 */
262void fwlc_init_server_tree(struct proxy *p)
263{
264 struct server *srv;
265 struct eb_root init_head = EB_ROOT;
266
267 p->lbprm.set_server_status_up = fwlc_set_server_status_up;
268 p->lbprm.set_server_status_down = fwlc_set_server_status_down;
269 p->lbprm.update_server_eweight = fwlc_update_server_weight;
270 p->lbprm.server_take_conn = fwlc_srv_reposition;
271 p->lbprm.server_drop_conn = fwlc_srv_reposition;
272
273 p->lbprm.wdiv = BE_WEIGHT_SCALE;
274 for (srv = p->srv; srv; srv = srv->next) {
Emeric Brun52a91d32017-08-31 14:41:55 +0200275 srv->next_eweight = (srv->uweight * p->lbprm.wdiv + p->lbprm.wmult - 1) / p->lbprm.wmult;
Willy Tarreauc5150da2014-05-13 19:27:31 +0200276 srv_lb_commit_status(srv);
Willy Tarreauf89c1872009-10-01 11:19:37 +0200277 }
278
279 recount_servers(p);
280 update_backend_weight(p);
281
282 p->lbprm.fwlc.act = init_head;
283 p->lbprm.fwlc.bck = init_head;
284
285 /* queue active and backup servers in two distinct groups */
286 for (srv = p->srv; srv; srv = srv->next) {
Emeric Brun52a91d32017-08-31 14:41:55 +0200287 if (!srv_currently_usable(srv))
Willy Tarreauf89c1872009-10-01 11:19:37 +0200288 continue;
Willy Tarreauc93cd162014-05-13 15:54:22 +0200289 srv->lb_tree = (srv->flags & SRV_F_BACKUP) ? &p->lbprm.fwlc.bck : &p->lbprm.fwlc.act;
Willy Tarreauf89c1872009-10-01 11:19:37 +0200290 fwlc_queue_srv(srv);
291 }
292}
293
294/* Return next server from the FWLC tree in backend <p>. If the tree is empty,
295 * return NULL. Saturated servers are skipped.
Willy Tarreau1b877482018-08-21 19:44:53 +0200296 *
297 * The server's lock must be held. The lbprm's lock will be used.
Willy Tarreauf89c1872009-10-01 11:19:37 +0200298 */
299struct server *fwlc_get_next_server(struct proxy *p, struct server *srvtoavoid)
300{
301 struct server *srv, *avoided;
302 struct eb32_node *node;
303
304 srv = avoided = NULL;
305
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100306 HA_SPIN_LOCK(LBPRM_LOCK, &p->lbprm.lock);
Willy Tarreauf89c1872009-10-01 11:19:37 +0200307 if (p->srv_act)
308 node = eb32_first(&p->lbprm.fwlc.act);
Christopher Faulet5b517552017-06-09 14:17:53 +0200309 else if (p->lbprm.fbck) {
310 srv = p->lbprm.fbck;
311 goto out;
312 }
Willy Tarreauf89c1872009-10-01 11:19:37 +0200313 else if (p->srv_bck)
314 node = eb32_first(&p->lbprm.fwlc.bck);
Christopher Faulet5b517552017-06-09 14:17:53 +0200315 else {
316 srv = NULL;
317 goto out;
318 }
Willy Tarreauf89c1872009-10-01 11:19:37 +0200319
320 while (node) {
321 /* OK, we have a server. However, it may be saturated, in which
322 * case we don't want to reconsider it for now, so we'll simply
323 * skip it. Same if it's the server we try to avoid, in which
324 * case we simply remember it for later use if needed.
325 */
326 struct server *s;
327
328 s = eb32_entry(node, struct server, lb_node);
329 if (!s->maxconn || (!s->nbpend && s->served < srv_dynamic_maxconn(s))) {
330 if (s != srvtoavoid) {
331 srv = s;
332 break;
333 }
334 avoided = s;
335 }
336 node = eb32_next(node);
337 }
338
339 if (!srv)
340 srv = avoided;
Christopher Faulet5b517552017-06-09 14:17:53 +0200341 out:
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100342 HA_SPIN_UNLOCK(LBPRM_LOCK, &p->lbprm.lock);
Willy Tarreauf89c1872009-10-01 11:19:37 +0200343 return srv;
344}
345
346
347/*
348 * Local variables:
349 * c-indent-level: 8
350 * c-basic-offset: 8
351 * End:
352 */