blob: e30606507c14bc4bc068738d5991094373d3102c [file] [log] [blame]
Willy Tarreauf09c6602012-02-13 17:12:08 +01001/*
2 * First Available Server load balancing algorithm.
3 *
Willy Tarreau64559c52012-04-07 09:08:45 +02004 * This file implements an algorithm which emerged during a discussion with
5 * Steen Larsen, initially inspired from Anshul Gandhi et.al.'s work now
6 * described as "packing" in section 3.5:
7 *
8 * http://reports-archive.adm.cs.cmu.edu/anon/2012/CMU-CS-12-109.pdf
9 *
Willy Tarreauf09c6602012-02-13 17:12:08 +010010 * Copyright 2000-2012 Willy Tarreau <w@1wt.eu>
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
16 *
17 */
18
Willy Tarreau1e56f922020-06-04 23:20:13 +020019#include <import/eb32tree.h>
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020020#include <haproxy/api.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020021#include <haproxy/backend.h>
Willy Tarreaua55c4542020-06-04 22:59:39 +020022#include <haproxy/queue.h>
Willy Tarreau1e56f922020-06-04 23:20:13 +020023#include <haproxy/server-t.h>
Willy Tarreauf09c6602012-02-13 17:12:08 +010024
25
26/* Remove a server from a tree. It must have previously been dequeued. This
27 * function is meant to be called when a server is going down or has its
28 * weight disabled.
Willy Tarreau1b877482018-08-21 19:44:53 +020029 *
30 * The server's lock and the lbprm's lock must be held.
Willy Tarreauf09c6602012-02-13 17:12:08 +010031 */
32static inline void fas_remove_from_tree(struct server *s)
33{
34 s->lb_tree = NULL;
35}
36
Willy Tarreau1b877482018-08-21 19:44:53 +020037/* simply removes a server from a tree.
38 *
39 * The server's lock and the lbprm's lock must be held.
40 */
Willy Tarreauf09c6602012-02-13 17:12:08 +010041static inline void fas_dequeue_srv(struct server *s)
42{
43 eb32_delete(&s->lb_node);
44}
45
46/* Queue a server in its associated tree, assuming the weight is >0.
47 * Servers are sorted by unique ID so that we send all connections to the first
48 * available server in declaration order (or ID order) until its maxconn is
49 * reached. It is important to understand that the server weight is not used
50 * here.
Willy Tarreau1b877482018-08-21 19:44:53 +020051 *
52 * The server's lock and the lbprm's lock must be held.
Willy Tarreauf09c6602012-02-13 17:12:08 +010053 */
54static inline void fas_queue_srv(struct server *s)
55{
56 s->lb_node.key = s->puid;
57 eb32_insert(s->lb_tree, &s->lb_node);
58}
59
60/* Re-position the server in the FS tree after it has been assigned one
61 * connection or after it has released one. Note that it is possible that
62 * the server has been moved out of the tree due to failed health-checks.
Willy Tarreau1b877482018-08-21 19:44:53 +020063 *
64 * The server's lock must be held. The lbprm's lock will be used.
Willy Tarreauf09c6602012-02-13 17:12:08 +010065 */
66static void fas_srv_reposition(struct server *s)
67{
Willy Tarreaucd10def2020-10-17 18:48:47 +020068 HA_RWLOCK_WRLOCK(LBPRM_LOCK, &s->proxy->lbprm.lock);
Christopher Faulet16b2be92019-07-04 11:59:42 +020069 if (s->lb_tree) {
70 fas_dequeue_srv(s);
71 fas_queue_srv(s);
72 }
Willy Tarreaucd10def2020-10-17 18:48:47 +020073 HA_RWLOCK_WRUNLOCK(LBPRM_LOCK, &s->proxy->lbprm.lock);
Willy Tarreauf09c6602012-02-13 17:12:08 +010074}
75
76/* This function updates the server trees according to server <srv>'s new
77 * state. It should be called when server <srv>'s status changes to down.
78 * It is not important whether the server was already down or not. It is not
79 * important either that the new state is completely down (the caller may not
80 * know all the variables of a server's state).
Willy Tarreau1b877482018-08-21 19:44:53 +020081 *
82 * The server's lock must be held. The lbprm's lock will be used.
Willy Tarreauf09c6602012-02-13 17:12:08 +010083 */
84static void fas_set_server_status_down(struct server *srv)
85{
86 struct proxy *p = srv->proxy;
87
Willy Tarreauc5150da2014-05-13 19:27:31 +020088 if (!srv_lb_status_changed(srv))
Willy Tarreauf09c6602012-02-13 17:12:08 +010089 return;
90
Emeric Brun52a91d32017-08-31 14:41:55 +020091 if (srv_willbe_usable(srv))
Willy Tarreauf09c6602012-02-13 17:12:08 +010092 goto out_update_state;
93
Willy Tarreaucd10def2020-10-17 18:48:47 +020094 HA_RWLOCK_WRLOCK(LBPRM_LOCK, &p->lbprm.lock);
Willy Tarreau1b877482018-08-21 19:44:53 +020095
Emeric Brun52a91d32017-08-31 14:41:55 +020096 if (!srv_currently_usable(srv))
Willy Tarreauf09c6602012-02-13 17:12:08 +010097 /* server was already down */
98 goto out_update_backend;
99
Willy Tarreauc93cd162014-05-13 15:54:22 +0200100 if (srv->flags & SRV_F_BACKUP) {
Emeric Brun52a91d32017-08-31 14:41:55 +0200101 p->lbprm.tot_wbck -= srv->cur_eweight;
Willy Tarreauf09c6602012-02-13 17:12:08 +0100102 p->srv_bck--;
103
104 if (srv == p->lbprm.fbck) {
105 /* we lost the first backup server in a single-backup
106 * configuration, we must search another one.
107 */
108 struct server *srv2 = p->lbprm.fbck;
109 do {
110 srv2 = srv2->next;
111 } while (srv2 &&
Willy Tarreauc93cd162014-05-13 15:54:22 +0200112 !((srv2->flags & SRV_F_BACKUP) &&
Emeric Brun52a91d32017-08-31 14:41:55 +0200113 srv_willbe_usable(srv2)));
Willy Tarreauf09c6602012-02-13 17:12:08 +0100114 p->lbprm.fbck = srv2;
115 }
116 } else {
Emeric Brun52a91d32017-08-31 14:41:55 +0200117 p->lbprm.tot_wact -= srv->cur_eweight;
Willy Tarreauf09c6602012-02-13 17:12:08 +0100118 p->srv_act--;
119 }
120
121 fas_dequeue_srv(srv);
122 fas_remove_from_tree(srv);
123
Christopher Faulet5b517552017-06-09 14:17:53 +0200124 out_update_backend:
Willy Tarreauf09c6602012-02-13 17:12:08 +0100125 /* check/update tot_used, tot_weight */
126 update_backend_weight(p);
Willy Tarreaucd10def2020-10-17 18:48:47 +0200127 HA_RWLOCK_WRUNLOCK(LBPRM_LOCK, &p->lbprm.lock);
Willy Tarreau1b877482018-08-21 19:44:53 +0200128
Willy Tarreauf09c6602012-02-13 17:12:08 +0100129 out_update_state:
Willy Tarreauc5150da2014-05-13 19:27:31 +0200130 srv_lb_commit_status(srv);
Willy Tarreauf09c6602012-02-13 17:12:08 +0100131}
132
133/* This function updates the server trees according to server <srv>'s new
134 * state. It should be called when server <srv>'s status changes to up.
135 * It is not important whether the server was already down or not. It is not
136 * important either that the new state is completely UP (the caller may not
137 * know all the variables of a server's state). This function will not change
138 * the weight of a server which was already up.
Willy Tarreau1b877482018-08-21 19:44:53 +0200139 *
140 * The server's lock must be held. The lbprm's lock will be used.
Willy Tarreauf09c6602012-02-13 17:12:08 +0100141 */
142static void fas_set_server_status_up(struct server *srv)
143{
144 struct proxy *p = srv->proxy;
145
Willy Tarreauc5150da2014-05-13 19:27:31 +0200146 if (!srv_lb_status_changed(srv))
Willy Tarreauf09c6602012-02-13 17:12:08 +0100147 return;
148
Emeric Brun52a91d32017-08-31 14:41:55 +0200149 if (!srv_willbe_usable(srv))
Willy Tarreauf09c6602012-02-13 17:12:08 +0100150 goto out_update_state;
151
Willy Tarreaucd10def2020-10-17 18:48:47 +0200152 HA_RWLOCK_WRLOCK(LBPRM_LOCK, &p->lbprm.lock);
Willy Tarreau1b877482018-08-21 19:44:53 +0200153
Emeric Brun52a91d32017-08-31 14:41:55 +0200154 if (srv_currently_usable(srv))
Willy Tarreauf09c6602012-02-13 17:12:08 +0100155 /* server was already up */
156 goto out_update_backend;
157
Willy Tarreauc93cd162014-05-13 15:54:22 +0200158 if (srv->flags & SRV_F_BACKUP) {
Willy Tarreauf09c6602012-02-13 17:12:08 +0100159 srv->lb_tree = &p->lbprm.fas.bck;
Emeric Brun52a91d32017-08-31 14:41:55 +0200160 p->lbprm.tot_wbck += srv->next_eweight;
Willy Tarreauf09c6602012-02-13 17:12:08 +0100161 p->srv_bck++;
162
163 if (!(p->options & PR_O_USE_ALL_BK)) {
164 if (!p->lbprm.fbck) {
165 /* there was no backup server anymore */
166 p->lbprm.fbck = srv;
167 } else {
168 /* we may have restored a backup server prior to fbck,
169 * in which case it should replace it.
170 */
171 struct server *srv2 = srv;
172 do {
173 srv2 = srv2->next;
174 } while (srv2 && (srv2 != p->lbprm.fbck));
175 if (srv2)
176 p->lbprm.fbck = srv;
177 }
178 }
179 } else {
180 srv->lb_tree = &p->lbprm.fas.act;
Emeric Brun52a91d32017-08-31 14:41:55 +0200181 p->lbprm.tot_wact += srv->next_eweight;
Willy Tarreauf09c6602012-02-13 17:12:08 +0100182 p->srv_act++;
183 }
184
185 /* note that eweight cannot be 0 here */
186 fas_queue_srv(srv);
187
188 out_update_backend:
189 /* check/update tot_used, tot_weight */
190 update_backend_weight(p);
Willy Tarreaucd10def2020-10-17 18:48:47 +0200191 HA_RWLOCK_WRUNLOCK(LBPRM_LOCK, &p->lbprm.lock);
Willy Tarreau1b877482018-08-21 19:44:53 +0200192
Willy Tarreauf09c6602012-02-13 17:12:08 +0100193 out_update_state:
Willy Tarreauc5150da2014-05-13 19:27:31 +0200194 srv_lb_commit_status(srv);
Willy Tarreauf09c6602012-02-13 17:12:08 +0100195}
196
197/* This function must be called after an update to server <srv>'s effective
198 * weight. It may be called after a state change too.
Willy Tarreau1b877482018-08-21 19:44:53 +0200199 *
200 * The server's lock must be held. The lbprm's lock will be used.
Willy Tarreauf09c6602012-02-13 17:12:08 +0100201 */
202static void fas_update_server_weight(struct server *srv)
203{
204 int old_state, new_state;
205 struct proxy *p = srv->proxy;
206
Willy Tarreauc5150da2014-05-13 19:27:31 +0200207 if (!srv_lb_status_changed(srv))
Willy Tarreauf09c6602012-02-13 17:12:08 +0100208 return;
209
210 /* If changing the server's weight changes its state, we simply apply
211 * the procedures we already have for status change. If the state
212 * remains down, the server is not in any tree, so it's as easy as
213 * updating its values. If the state remains up with different weights,
214 * there are some computations to perform to find a new place and
215 * possibly a new tree for this server.
216 */
217
Emeric Brun52a91d32017-08-31 14:41:55 +0200218 old_state = srv_currently_usable(srv);
219 new_state = srv_willbe_usable(srv);
Willy Tarreauf09c6602012-02-13 17:12:08 +0100220
221 if (!old_state && !new_state) {
Willy Tarreauc5150da2014-05-13 19:27:31 +0200222 srv_lb_commit_status(srv);
Willy Tarreauf09c6602012-02-13 17:12:08 +0100223 return;
224 }
225 else if (!old_state && new_state) {
226 fas_set_server_status_up(srv);
227 return;
228 }
229 else if (old_state && !new_state) {
230 fas_set_server_status_down(srv);
231 return;
232 }
233
Willy Tarreaucd10def2020-10-17 18:48:47 +0200234 HA_RWLOCK_WRLOCK(LBPRM_LOCK, &p->lbprm.lock);
Willy Tarreau1b877482018-08-21 19:44:53 +0200235
Willy Tarreauf09c6602012-02-13 17:12:08 +0100236 if (srv->lb_tree)
237 fas_dequeue_srv(srv);
238
Willy Tarreauc93cd162014-05-13 15:54:22 +0200239 if (srv->flags & SRV_F_BACKUP) {
Emeric Brun52a91d32017-08-31 14:41:55 +0200240 p->lbprm.tot_wbck += srv->next_eweight - srv->cur_eweight;
Willy Tarreauf09c6602012-02-13 17:12:08 +0100241 srv->lb_tree = &p->lbprm.fas.bck;
242 } else {
Emeric Brun52a91d32017-08-31 14:41:55 +0200243 p->lbprm.tot_wact += srv->next_eweight - srv->cur_eweight;
Willy Tarreauf09c6602012-02-13 17:12:08 +0100244 srv->lb_tree = &p->lbprm.fas.act;
245 }
246
247 fas_queue_srv(srv);
248
249 update_backend_weight(p);
Willy Tarreaucd10def2020-10-17 18:48:47 +0200250 HA_RWLOCK_WRUNLOCK(LBPRM_LOCK, &p->lbprm.lock);
Willy Tarreau1b877482018-08-21 19:44:53 +0200251
Willy Tarreauc5150da2014-05-13 19:27:31 +0200252 srv_lb_commit_status(srv);
Willy Tarreauf09c6602012-02-13 17:12:08 +0100253}
254
255/* This function is responsible for building the trees in case of fast
256 * weighted least-conns. It also sets p->lbprm.wdiv to the eweight to
257 * uweight ratio. Both active and backup groups are initialized.
258 */
259void fas_init_server_tree(struct proxy *p)
260{
261 struct server *srv;
262 struct eb_root init_head = EB_ROOT;
263
264 p->lbprm.set_server_status_up = fas_set_server_status_up;
265 p->lbprm.set_server_status_down = fas_set_server_status_down;
266 p->lbprm.update_server_eweight = fas_update_server_weight;
267 p->lbprm.server_take_conn = fas_srv_reposition;
268 p->lbprm.server_drop_conn = fas_srv_reposition;
269
270 p->lbprm.wdiv = BE_WEIGHT_SCALE;
271 for (srv = p->srv; srv; srv = srv->next) {
Emeric Brun52a91d32017-08-31 14:41:55 +0200272 srv->next_eweight = (srv->uweight * p->lbprm.wdiv + p->lbprm.wmult - 1) / p->lbprm.wmult;
Willy Tarreauc5150da2014-05-13 19:27:31 +0200273 srv_lb_commit_status(srv);
Willy Tarreauf09c6602012-02-13 17:12:08 +0100274 }
275
276 recount_servers(p);
277 update_backend_weight(p);
278
279 p->lbprm.fas.act = init_head;
280 p->lbprm.fas.bck = init_head;
281
282 /* queue active and backup servers in two distinct groups */
283 for (srv = p->srv; srv; srv = srv->next) {
Emeric Brun52a91d32017-08-31 14:41:55 +0200284 if (!srv_currently_usable(srv))
Willy Tarreauf09c6602012-02-13 17:12:08 +0100285 continue;
Willy Tarreauc93cd162014-05-13 15:54:22 +0200286 srv->lb_tree = (srv->flags & SRV_F_BACKUP) ? &p->lbprm.fas.bck : &p->lbprm.fas.act;
Willy Tarreauf09c6602012-02-13 17:12:08 +0100287 fas_queue_srv(srv);
288 }
289}
290
291/* Return next server from the FS tree in backend <p>. If the tree is empty,
292 * return NULL. Saturated servers are skipped.
Willy Tarreau1b877482018-08-21 19:44:53 +0200293 *
294 * The server's lock must be held. The lbprm's lock will be used.
Willy Tarreauf09c6602012-02-13 17:12:08 +0100295 */
296struct server *fas_get_next_server(struct proxy *p, struct server *srvtoavoid)
297{
298 struct server *srv, *avoided;
299 struct eb32_node *node;
300
301 srv = avoided = NULL;
302
Willy Tarreauf76a21f2020-10-17 19:45:42 +0200303 HA_RWLOCK_RDLOCK(LBPRM_LOCK, &p->lbprm.lock);
Willy Tarreauf09c6602012-02-13 17:12:08 +0100304 if (p->srv_act)
305 node = eb32_first(&p->lbprm.fas.act);
Christopher Faulet5b517552017-06-09 14:17:53 +0200306 else if (p->lbprm.fbck) {
307 srv = p->lbprm.fbck;
308 goto out;
309 }
Willy Tarreauf09c6602012-02-13 17:12:08 +0100310 else if (p->srv_bck)
311 node = eb32_first(&p->lbprm.fas.bck);
Christopher Faulet5b517552017-06-09 14:17:53 +0200312 else {
313 srv = NULL;
314 goto out;
315 }
Willy Tarreauf09c6602012-02-13 17:12:08 +0100316
317 while (node) {
318 /* OK, we have a server. However, it may be saturated, in which
319 * case we don't want to reconsider it for now, so we'll simply
320 * skip it. Same if it's the server we try to avoid, in which
321 * case we simply remember it for later use if needed.
322 */
323 struct server *s;
324
325 s = eb32_entry(node, struct server, lb_node);
326 if (!s->maxconn || (!s->nbpend && s->served < srv_dynamic_maxconn(s))) {
327 if (s != srvtoavoid) {
328 srv = s;
329 break;
330 }
331 avoided = s;
332 }
333 node = eb32_next(node);
334 }
335
336 if (!srv)
337 srv = avoided;
Christopher Faulet5b517552017-06-09 14:17:53 +0200338 out:
Willy Tarreauf76a21f2020-10-17 19:45:42 +0200339 HA_RWLOCK_RDUNLOCK(LBPRM_LOCK, &p->lbprm.lock);
Willy Tarreauf09c6602012-02-13 17:12:08 +0100340 return srv;
341}
342
343
344/*
345 * Local variables:
346 * c-indent-level: 8
347 * c-basic-offset: 8
348 * End:
349 */