Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 1 | /* |
| 2 | * Queue management functions. |
| 3 | * |
Willy Tarreau | ac68c5d | 2009-10-04 23:12:44 +0200 | [diff] [blame] | 4 | * Copyright 2000-2009 Willy Tarreau <w@1wt.eu> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 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 | |
Willy Tarreau | 6bdd05c | 2018-07-25 15:21:00 +0200 | [diff] [blame] | 13 | /* 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 Hemmer | 0355dab | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 24 | * - if p->node.node.leaf_p is NULL, the element is unlinked, |
Willy Tarreau | 6bdd05c | 2018-07-25 15:21:00 +0200 | [diff] [blame] | 25 | * 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 Tarreau | 88930dd | 2018-07-26 07:38:54 +0200 | [diff] [blame] | 28 | * - pendconn->srv is never NULL if pendconn->list is in the server's queue, |
Willy Tarreau | 6bdd05c | 2018-07-25 15:21:00 +0200 | [diff] [blame] | 29 | * and is always NULL if pendconn->list is in the backend's queue or empty. |
Willy Tarreau | 88930dd | 2018-07-26 07:38:54 +0200 | [diff] [blame] | 30 | * - pendconn->target is NULL while the element is queued, and points to the |
| 31 | * assigned server when the pendconn is picked. |
Willy Tarreau | 6bdd05c | 2018-07-25 15:21:00 +0200 | [diff] [blame] | 32 | * |
| 33 | * Threads complicate the design a little bit but rules remain simple : |
Willy Tarreau | 6bdd05c | 2018-07-25 15:21:00 +0200 | [diff] [blame] | 34 | * - 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 Tarreau | 3201e4e | 2018-07-26 08:23:24 +0200 | [diff] [blame] | 42 | * - both locks are compatible and may be held at the same time. |
Willy Tarreau | 6bdd05c | 2018-07-25 15:21:00 +0200 | [diff] [blame] | 43 | * |
| 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 Tarreau | 3201e4e | 2018-07-26 08:23:24 +0200 | [diff] [blame] | 47 | * queue's lock. |
Willy Tarreau | 6bdd05c | 2018-07-25 15:21:00 +0200 | [diff] [blame] | 48 | * |
| 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 Tarreau | 3201e4e | 2018-07-26 08:23:24 +0200 | [diff] [blame] | 62 | * insertion are performed without eithre a queue lock held or the element |
| 63 | * being unlinked and visible exclusively to its stream. |
Willy Tarreau | 6bdd05c | 2018-07-25 15:21:00 +0200 | [diff] [blame] | 64 | * |
Willy Tarreau | 88930dd | 2018-07-26 07:38:54 +0200 | [diff] [blame] | 65 | * - 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 Tarreau | 6bdd05c | 2018-07-25 15:21:00 +0200 | [diff] [blame] | 68 | * |
| 69 | * - a pendconn doesn't switch between queues, it stays where it is. |
Willy Tarreau | 6bdd05c | 2018-07-25 15:21:00 +0200 | [diff] [blame] | 70 | */ |
| 71 | |
Willy Tarreau | 4c7e4b7 | 2020-05-27 12:58:42 +0200 | [diff] [blame] | 72 | #include <haproxy/api.h> |
Willy Tarreau | c761f84 | 2020-06-04 11:40:28 +0200 | [diff] [blame] | 73 | #include <haproxy/http_rules.h> |
Willy Tarreau | d0ef439 | 2020-06-02 09:38:52 +0200 | [diff] [blame] | 74 | #include <haproxy/pool.h> |
Willy Tarreau | e6ce10b | 2020-06-04 15:33:47 +0200 | [diff] [blame] | 75 | #include <haproxy/sample.h> |
Willy Tarreau | cea0e1b | 2020-06-04 17:25:40 +0200 | [diff] [blame] | 76 | #include <haproxy/task.h> |
Willy Tarreau | 92b4f13 | 2020-06-01 11:05:15 +0200 | [diff] [blame] | 77 | #include <haproxy/time.h> |
Willy Tarreau | 3f567e4 | 2020-05-28 15:29:19 +0200 | [diff] [blame] | 78 | #include <haproxy/thread.h> |
Willy Tarreau | 8d2b777 | 2020-05-27 10:58:19 +0200 | [diff] [blame] | 79 | #include <import/eb32tree.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 80 | |
Christopher Faulet | fc9cfe4 | 2019-07-16 14:54:53 +0200 | [diff] [blame] | 81 | #include <proto/http_ana.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 82 | #include <proto/queue.h> |
| 83 | #include <proto/server.h> |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 84 | #include <proto/stream.h> |
Willy Tarreau | 9e000c6 | 2011-03-10 14:03:36 +0100 | [diff] [blame] | 85 | #include <proto/stream_interface.h> |
Patrick Hemmer | 268a707 | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 86 | #include <proto/tcp_rules.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 87 | |
| 88 | |
Patrick Hemmer | 248cb4c | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 89 | #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 Tarreau | 8ceae72 | 2018-11-26 11:58:30 +0100 | [diff] [blame] | 95 | DECLARE_POOL(pool_head_pendconn, "pendconn", sizeof(struct pendconn)); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 96 | |
| 97 | /* returns the effective dynamic maxconn for a server, considering the minconn |
Willy Tarreau | 8603431 | 2006-12-29 00:10:33 +0100 | [diff] [blame] | 98 | * and the proxy's usage relative to its dynamic connections limit. It is |
Willy Tarreau | 9909fc1 | 2007-11-30 17:42:05 +0100 | [diff] [blame] | 99 | * 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 Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 103 | */ |
Willy Tarreau | b17916e | 2006-10-15 15:17:57 +0200 | [diff] [blame] | 104 | unsigned int srv_dynamic_maxconn(const struct server *s) |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 105 | { |
Willy Tarreau | 9909fc1 | 2007-11-30 17:42:05 +0100 | [diff] [blame] | 106 | unsigned int max; |
| 107 | |
Willy Tarreau | 8603431 | 2006-12-29 00:10:33 +0100 | [diff] [blame] | 108 | if (s->proxy->beconn >= s->proxy->fullconn) |
| 109 | /* no fullconn or proxy is full */ |
Willy Tarreau | 9909fc1 | 2007-11-30 17:42:05 +0100 | [diff] [blame] | 110 | max = s->maxconn; |
| 111 | else if (s->minconn == s->maxconn) |
Willy Tarreau | 8603431 | 2006-12-29 00:10:33 +0100 | [diff] [blame] | 112 | /* static limit */ |
Willy Tarreau | 9909fc1 | 2007-11-30 17:42:05 +0100 | [diff] [blame] | 113 | max = s->maxconn; |
| 114 | else max = MAX(s->minconn, |
| 115 | s->proxy->beconn * s->maxconn / s->proxy->fullconn); |
Willy Tarreau | 8603431 | 2006-12-29 00:10:33 +0100 | [diff] [blame] | 116 | |
Emeric Brun | 52a91d3 | 2017-08-31 14:41:55 +0200 | [diff] [blame] | 117 | if ((s->cur_state == SRV_ST_STARTING) && |
Willy Tarreau | 9909fc1 | 2007-11-30 17:42:05 +0100 | [diff] [blame] | 118 | now.tv_sec < s->last_change + s->slowstart && |
| 119 | now.tv_sec >= s->last_change) { |
| 120 | unsigned int ratio; |
Willy Tarreau | 28a9e52 | 2008-09-14 17:43:27 +0200 | [diff] [blame] | 121 | ratio = 100 * (now.tv_sec - s->last_change) / s->slowstart; |
| 122 | max = MAX(1, max * ratio / 100); |
Willy Tarreau | 9909fc1 | 2007-11-30 17:42:05 +0100 | [diff] [blame] | 123 | } |
| 124 | return max; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 125 | } |
| 126 | |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 127 | /* Remove the pendconn from the server/proxy queue. At this stage, the |
| 128 | * connection is not really dequeued. It will be done during the |
Willy Tarreau | 3201e4e | 2018-07-26 08:23:24 +0200 | [diff] [blame] | 129 | * process_stream. It also decreases the pending count. |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 130 | * |
Willy Tarreau | 3201e4e | 2018-07-26 08:23:24 +0200 | [diff] [blame] | 131 | * The caller must own the lock on the queue containing the pendconn. The |
| 132 | * pendconn must still be queued. |
Christopher Faulet | f3a55db | 2017-06-09 14:26:38 +0200 | [diff] [blame] | 133 | */ |
Willy Tarreau | 9624fae | 2018-07-25 08:04:20 +0200 | [diff] [blame] | 134 | static void __pendconn_unlink(struct pendconn *p) |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 135 | { |
Patrick Hemmer | da282f4 | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 136 | if (p->srv) { |
| 137 | p->strm->logs.srv_queue_pos += p->srv->queue_idx - p->queue_idx; |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 138 | p->srv->nbpend--; |
Patrick Hemmer | da282f4 | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 139 | } else { |
| 140 | p->strm->logs.prx_queue_pos += p->px->queue_idx - p->queue_idx; |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 141 | p->px->nbpend--; |
Patrick Hemmer | da282f4 | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 142 | } |
Olivier Houchard | b4df492 | 2019-03-08 18:54:16 +0100 | [diff] [blame] | 143 | _HA_ATOMIC_SUB(&p->px->totpend, 1); |
Patrick Hemmer | 0355dab | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 144 | eb32_delete(&p->node); |
Christopher Faulet | f3a55db | 2017-06-09 14:26:38 +0200 | [diff] [blame] | 145 | } |
| 146 | |
Willy Tarreau | 7c6f8a2 | 2018-07-26 08:03:14 +0200 | [diff] [blame] | 147 | /* Locks the queue the pendconn element belongs to. This relies on both p->px |
| 148 | * and p->srv to be properly initialized (which is always the case once the |
| 149 | * element has been added). |
| 150 | */ |
| 151 | static inline void pendconn_queue_lock(struct pendconn *p) |
| 152 | { |
| 153 | if (p->srv) |
| 154 | HA_SPIN_LOCK(SERVER_LOCK, &p->srv->lock); |
| 155 | else |
| 156 | HA_SPIN_LOCK(PROXY_LOCK, &p->px->lock); |
| 157 | } |
| 158 | |
| 159 | /* Unlocks the queue the pendconn element belongs to. This relies on both p->px |
| 160 | * and p->srv to be properly initialized (which is always the case once the |
| 161 | * element has been added). |
| 162 | */ |
| 163 | static inline void pendconn_queue_unlock(struct pendconn *p) |
| 164 | { |
| 165 | if (p->srv) |
| 166 | HA_SPIN_UNLOCK(SERVER_LOCK, &p->srv->lock); |
| 167 | else |
| 168 | HA_SPIN_UNLOCK(PROXY_LOCK, &p->px->lock); |
| 169 | } |
| 170 | |
Willy Tarreau | 9624fae | 2018-07-25 08:04:20 +0200 | [diff] [blame] | 171 | /* Removes the pendconn from the server/proxy queue. At this stage, the |
| 172 | * connection is not really dequeued. It will be done during process_stream(). |
Willy Tarreau | 9ada030 | 2019-11-14 14:58:39 +0100 | [diff] [blame] | 173 | * This function takes all the required locks for the operation. The pendconn |
| 174 | * must be valid, though it doesn't matter if it was already unlinked. Prefer |
| 175 | * pendconn_cond_unlink() to first check <p>. When the locks are already held, |
| 176 | * please use __pendconn_unlink() instead. |
Willy Tarreau | 9624fae | 2018-07-25 08:04:20 +0200 | [diff] [blame] | 177 | */ |
| 178 | void pendconn_unlink(struct pendconn *p) |
| 179 | { |
Willy Tarreau | 7c6f8a2 | 2018-07-26 08:03:14 +0200 | [diff] [blame] | 180 | pendconn_queue_lock(p); |
Willy Tarreau | 9624fae | 2018-07-25 08:04:20 +0200 | [diff] [blame] | 181 | |
Willy Tarreau | 9ada030 | 2019-11-14 14:58:39 +0100 | [diff] [blame] | 182 | if (p->node.node.leaf_p) |
| 183 | __pendconn_unlink(p); |
Willy Tarreau | 9624fae | 2018-07-25 08:04:20 +0200 | [diff] [blame] | 184 | |
Willy Tarreau | 7c6f8a2 | 2018-07-26 08:03:14 +0200 | [diff] [blame] | 185 | pendconn_queue_unlock(p); |
Willy Tarreau | 9624fae | 2018-07-25 08:04:20 +0200 | [diff] [blame] | 186 | } |
| 187 | |
Patrick Hemmer | 248cb4c | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 188 | /* Retrieve the first pendconn from tree <pendconns>. Classes are always |
| 189 | * considered first, then the time offset. The time does wrap, so the |
| 190 | * lookup is performed twice, one to retrieve the first class and a second |
| 191 | * time to retrieve the earliest time in this class. |
| 192 | */ |
| 193 | static struct pendconn *pendconn_first(struct eb_root *pendconns) |
| 194 | { |
| 195 | struct eb32_node *node, *node2 = NULL; |
| 196 | u32 key; |
| 197 | |
| 198 | node = eb32_first(pendconns); |
| 199 | if (!node) |
| 200 | return NULL; |
| 201 | |
| 202 | key = KEY_CLASS_OFFSET_BOUNDARY(node->key); |
| 203 | node2 = eb32_lookup_ge(pendconns, key); |
| 204 | |
| 205 | if (!node2 || |
| 206 | KEY_CLASS(node2->key) != KEY_CLASS(node->key)) { |
| 207 | /* no other key in the tree, or in this class */ |
| 208 | return eb32_entry(node, struct pendconn, node); |
| 209 | } |
| 210 | |
| 211 | /* found a better key */ |
| 212 | return eb32_entry(node2, struct pendconn, node); |
| 213 | } |
| 214 | |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 215 | /* Process the next pending connection from either a server or a proxy, and |
Christopher Faulet | fd83f0b | 2018-03-19 15:22:09 +0100 | [diff] [blame] | 216 | * returns a strictly positive value on success (see below). If no pending |
| 217 | * connection is found, 0 is returned. Note that neither <srv> nor <px> may be |
| 218 | * NULL. Priority is given to the oldest request in the queue if both <srv> and |
| 219 | * <px> have pending requests. This ensures that no request will be left |
| 220 | * unserved. The <px> queue is not considered if the server (or a tracked |
| 221 | * server) is not RUNNING, is disabled, or has a null weight (server going |
| 222 | * down). The <srv> queue is still considered in this case, because if some |
| 223 | * connections remain there, it means that some requests have been forced there |
| 224 | * after it was seen down (eg: due to option persist). The stream is |
| 225 | * immediately marked as "assigned", and both its <srv> and <srv_conn> are set |
| 226 | * to <srv>. |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 227 | * |
| 228 | * This function must only be called if the server queue _AND_ the proxy queue |
Christopher Faulet | fd83f0b | 2018-03-19 15:22:09 +0100 | [diff] [blame] | 229 | * are locked. Today it is only called by process_srv_queue. When a pending |
| 230 | * connection is dequeued, this function returns 1 if the pending connection can |
| 231 | * be handled by the current thread, else it returns 2. |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 232 | */ |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 233 | static int pendconn_process_next_strm(struct server *srv, struct proxy *px) |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 234 | { |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 235 | struct pendconn *p = NULL; |
Patrick Hemmer | da282f4 | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 236 | struct pendconn *pp = NULL; |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 237 | struct server *rsrv; |
Patrick Hemmer | 248cb4c | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 238 | u32 pkey, ppkey; |
Willy Tarreau | d132f74 | 2010-08-06 10:08:23 +0200 | [diff] [blame] | 239 | |
Willy Tarreau | 4426770 | 2011-10-28 15:35:33 +0200 | [diff] [blame] | 240 | rsrv = srv->track; |
Willy Tarreau | d132f74 | 2010-08-06 10:08:23 +0200 | [diff] [blame] | 241 | if (!rsrv) |
| 242 | rsrv = srv; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 243 | |
Willy Tarreau | 3201e4e | 2018-07-26 08:23:24 +0200 | [diff] [blame] | 244 | p = NULL; |
Patrick Hemmer | 248cb4c | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 245 | if (srv->nbpend) |
| 246 | p = pendconn_first(&srv->pendconns); |
Willy Tarreau | 7c669d7 | 2008-06-20 15:04:11 +0200 | [diff] [blame] | 247 | |
Patrick Hemmer | 248cb4c | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 248 | pp = NULL; |
Willy Tarreau | a869465 | 2018-08-07 10:44:58 +0200 | [diff] [blame] | 249 | if (srv_currently_usable(rsrv) && px->nbpend && |
| 250 | (!(srv->flags & SRV_F_BACKUP) || |
| 251 | (!px->srv_act && |
Patrick Hemmer | 248cb4c | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 252 | (srv == px->lbprm.fbck || (px->options & PR_O_USE_ALL_BK))))) |
| 253 | pp = pendconn_first(&px->pendconns); |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 254 | |
Patrick Hemmer | 248cb4c | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 255 | if (!p && !pp) |
| 256 | return 0; |
Willy Tarreau | 3201e4e | 2018-07-26 08:23:24 +0200 | [diff] [blame] | 257 | |
Patrick Hemmer | 248cb4c | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 258 | if (p && !pp) |
| 259 | goto use_p; |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 260 | |
Patrick Hemmer | 248cb4c | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 261 | if (pp && !p) |
| 262 | goto use_pp; |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 263 | |
Patrick Hemmer | 248cb4c | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 264 | if (KEY_CLASS(p->node.key) < KEY_CLASS(pp->node.key)) |
| 265 | goto use_p; |
| 266 | |
| 267 | if (KEY_CLASS(pp->node.key) < KEY_CLASS(p->node.key)) |
| 268 | goto use_pp; |
| 269 | |
| 270 | pkey = KEY_OFFSET(p->node.key); |
| 271 | ppkey = KEY_OFFSET(pp->node.key); |
| 272 | |
| 273 | if (pkey < NOW_OFFSET_BOUNDARY()) |
| 274 | pkey += 0x100000; // key in the future |
| 275 | |
| 276 | if (ppkey < NOW_OFFSET_BOUNDARY()) |
| 277 | ppkey += 0x100000; // key in the future |
| 278 | |
| 279 | if (pkey <= ppkey) |
| 280 | goto use_p; |
| 281 | |
| 282 | use_pp: |
| 283 | /* Let's switch from the server pendconn to the proxy pendconn */ |
| 284 | p = pp; |
| 285 | use_p: |
Willy Tarreau | 9624fae | 2018-07-25 08:04:20 +0200 | [diff] [blame] | 286 | __pendconn_unlink(p); |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 287 | p->strm_flags |= SF_ASSIGNED; |
Willy Tarreau | 88930dd | 2018-07-26 07:38:54 +0200 | [diff] [blame] | 288 | p->target = srv; |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 289 | |
Patrick Hemmer | da282f4 | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 290 | if (p != pp) |
| 291 | srv->queue_idx++; |
| 292 | else |
| 293 | px->queue_idx++; |
| 294 | |
Olivier Houchard | b4df492 | 2019-03-08 18:54:16 +0100 | [diff] [blame] | 295 | _HA_ATOMIC_ADD(&srv->served, 1); |
| 296 | _HA_ATOMIC_ADD(&srv->proxy->served, 1); |
| 297 | __ha_barrier_atomic_store(); |
Willy Tarreau | 7c669d7 | 2008-06-20 15:04:11 +0200 | [diff] [blame] | 298 | if (px->lbprm.server_take_conn) |
| 299 | px->lbprm.server_take_conn(srv); |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 300 | __stream_add_srv_conn(p->strm, srv); |
Willy Tarreau | 7c669d7 | 2008-06-20 15:04:11 +0200 | [diff] [blame] | 301 | |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 302 | task_wakeup(p->strm->task, TASK_WOKEN_RES); |
Christopher Faulet | fd83f0b | 2018-03-19 15:22:09 +0100 | [diff] [blame] | 303 | |
Olivier Houchard | ecfe673 | 2018-07-26 18:47:27 +0200 | [diff] [blame] | 304 | return 1; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 305 | } |
| 306 | |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 307 | /* Manages a server's connection queue. This function will try to dequeue as |
Christopher Faulet | 87566c9 | 2017-06-06 10:34:51 +0200 | [diff] [blame] | 308 | * many pending streams as possible, and wake them up. |
| 309 | */ |
| 310 | void process_srv_queue(struct server *s) |
| 311 | { |
| 312 | struct proxy *p = s->proxy; |
Olivier Houchard | ecfe673 | 2018-07-26 18:47:27 +0200 | [diff] [blame] | 313 | int maxconn; |
Christopher Faulet | 87566c9 | 2017-06-06 10:34:51 +0200 | [diff] [blame] | 314 | |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 315 | HA_SPIN_LOCK(SERVER_LOCK, &s->lock); |
Willy Tarreau | 5e83d99 | 2019-07-30 11:59:34 +0200 | [diff] [blame] | 316 | HA_SPIN_LOCK(PROXY_LOCK, &p->lock); |
Christopher Faulet | 87566c9 | 2017-06-06 10:34:51 +0200 | [diff] [blame] | 317 | maxconn = srv_dynamic_maxconn(s); |
| 318 | while (s->served < maxconn) { |
Christopher Faulet | fd83f0b | 2018-03-19 15:22:09 +0100 | [diff] [blame] | 319 | int ret = pendconn_process_next_strm(s, p); |
| 320 | if (!ret) |
Christopher Faulet | 87566c9 | 2017-06-06 10:34:51 +0200 | [diff] [blame] | 321 | break; |
Christopher Faulet | 87566c9 | 2017-06-06 10:34:51 +0200 | [diff] [blame] | 322 | } |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 323 | HA_SPIN_UNLOCK(PROXY_LOCK, &p->lock); |
Willy Tarreau | 5e83d99 | 2019-07-30 11:59:34 +0200 | [diff] [blame] | 324 | HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock); |
Christopher Faulet | 87566c9 | 2017-06-06 10:34:51 +0200 | [diff] [blame] | 325 | } |
| 326 | |
Patrick Hemmer | 248cb4c | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 327 | /* Adds the stream <strm> to the pending connection queue of server <strm>->srv |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 328 | * or to the one of <strm>->proxy if srv is NULL. All counters and back pointers |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 329 | * are updated accordingly. Returns NULL if no memory is available, otherwise the |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 330 | * pendconn itself. If the stream was already marked as served, its flag is |
| 331 | * cleared. It is illegal to call this function with a non-NULL strm->srv_conn. |
Patrick Hemmer | da282f4 | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 332 | * The stream's queue position is counted with an offset of -1 because we want |
| 333 | * to make sure that being at the first position in the queue reports 1. |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 334 | * |
Patrick Hemmer | 248cb4c | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 335 | * The queue is sorted by the composition of the priority_class, and the current |
| 336 | * timestamp offset by strm->priority_offset. The timestamp is in milliseconds |
| 337 | * and truncated to 20 bits, so will wrap every 17m28s575ms. |
| 338 | * The offset can be positive or negative, and an offset of 0 puts it in the |
| 339 | * middle of this range (~ 8 min). Note that this also means if the adjusted |
| 340 | * timestamp wraps around, the request will be misinterpreted as being of |
Joseph Herlant | d8499ec | 2018-11-25 11:26:48 -0800 | [diff] [blame] | 341 | * the highest priority for that priority class. |
Patrick Hemmer | 248cb4c | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 342 | * |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 343 | * This function must be called by the stream itself, so in the context of |
| 344 | * process_stream. |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 345 | */ |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 346 | struct pendconn *pendconn_add(struct stream *strm) |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 347 | { |
| 348 | struct pendconn *p; |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 349 | struct proxy *px; |
| 350 | struct server *srv; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 351 | |
Willy Tarreau | bafbe01 | 2017-11-24 17:34:44 +0100 | [diff] [blame] | 352 | p = pool_alloc(pool_head_pendconn); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 353 | if (!p) |
| 354 | return NULL; |
| 355 | |
Willy Tarreau | 7c6f8a2 | 2018-07-26 08:03:14 +0200 | [diff] [blame] | 356 | if (strm->flags & SF_ASSIGNED) |
| 357 | srv = objt_server(strm->target); |
| 358 | else |
| 359 | srv = NULL; |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 360 | |
Willy Tarreau | 7c6f8a2 | 2018-07-26 08:03:14 +0200 | [diff] [blame] | 361 | px = strm->be; |
Willy Tarreau | 88930dd | 2018-07-26 07:38:54 +0200 | [diff] [blame] | 362 | p->target = NULL; |
Willy Tarreau | 7c6f8a2 | 2018-07-26 08:03:14 +0200 | [diff] [blame] | 363 | p->srv = srv; |
Patrick Hemmer | 248cb4c | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 364 | p->node.key = MAKE_KEY(strm->priority_class, strm->priority_offset); |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 365 | p->px = px; |
| 366 | p->strm = strm; |
| 367 | p->strm_flags = strm->flags; |
Willy Tarreau | 7c669d7 | 2008-06-20 15:04:11 +0200 | [diff] [blame] | 368 | |
Willy Tarreau | 7c6f8a2 | 2018-07-26 08:03:14 +0200 | [diff] [blame] | 369 | pendconn_queue_lock(p); |
| 370 | |
| 371 | if (srv) { |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 372 | srv->nbpend++; |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 373 | if (srv->nbpend > srv->counters.nbpend_max) |
| 374 | srv->counters.nbpend_max = srv->nbpend; |
Patrick Hemmer | da282f4 | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 375 | p->queue_idx = srv->queue_idx - 1; // for increment |
Patrick Hemmer | 0355dab | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 376 | eb32_insert(&srv->pendconns, &p->node); |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 377 | } |
| 378 | else { |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 379 | px->nbpend++; |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 380 | if (px->nbpend > px->be_counters.nbpend_max) |
| 381 | px->be_counters.nbpend_max = px->nbpend; |
Patrick Hemmer | da282f4 | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 382 | p->queue_idx = px->queue_idx - 1; // for increment |
Patrick Hemmer | 0355dab | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 383 | eb32_insert(&px->pendconns, &p->node); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 384 | } |
Willy Tarreau | 7c6f8a2 | 2018-07-26 08:03:14 +0200 | [diff] [blame] | 385 | strm->pend_pos = p; |
| 386 | |
| 387 | pendconn_queue_unlock(p); |
| 388 | |
Olivier Houchard | b4df492 | 2019-03-08 18:54:16 +0100 | [diff] [blame] | 389 | _HA_ATOMIC_ADD(&px->totpend, 1); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 390 | return p; |
| 391 | } |
| 392 | |
Willy Tarreau | 4aac7db | 2014-05-16 11:48:10 +0200 | [diff] [blame] | 393 | /* Redistribute pending connections when a server goes down. The number of |
Willy Tarreau | deca26c | 2018-08-21 18:11:03 +0200 | [diff] [blame] | 394 | * connections redistributed is returned. It must be called with the server |
| 395 | * lock held. |
Willy Tarreau | 4aac7db | 2014-05-16 11:48:10 +0200 | [diff] [blame] | 396 | */ |
| 397 | int pendconn_redistribute(struct server *s) |
| 398 | { |
Patrick Hemmer | 0355dab | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 399 | struct pendconn *p; |
Willy Tarreau | bff005a | 2019-05-27 08:10:11 +0200 | [diff] [blame] | 400 | struct eb32_node *node, *nodeb; |
Willy Tarreau | 4aac7db | 2014-05-16 11:48:10 +0200 | [diff] [blame] | 401 | int xferred = 0; |
| 402 | |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 403 | /* The REDISP option was specified. We will ignore cookie and force to |
| 404 | * balance or use the dispatcher. */ |
| 405 | if ((s->proxy->options & (PR_O_REDISP|PR_O_PERSIST)) != PR_O_REDISP) |
| 406 | return 0; |
| 407 | |
Willy Tarreau | bff005a | 2019-05-27 08:10:11 +0200 | [diff] [blame] | 408 | for (node = eb32_first(&s->pendconns); node; node = nodeb) { |
| 409 | nodeb = eb32_next(node); |
| 410 | |
| 411 | p = eb32_entry(node, struct pendconn, node); |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 412 | if (p->strm_flags & SF_FORCE_PRST) |
| 413 | continue; |
Willy Tarreau | 4aac7db | 2014-05-16 11:48:10 +0200 | [diff] [blame] | 414 | |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 415 | /* it's left to the dispatcher to choose a server */ |
Willy Tarreau | 9624fae | 2018-07-25 08:04:20 +0200 | [diff] [blame] | 416 | __pendconn_unlink(p); |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 417 | p->strm_flags &= ~(SF_DIRECT | SF_ASSIGNED | SF_ADDR_SET); |
Willy Tarreau | 4aac7db | 2014-05-16 11:48:10 +0200 | [diff] [blame] | 418 | |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 419 | task_wakeup(p->strm->task, TASK_WOKEN_RES); |
Willy Tarreau | 4aac7db | 2014-05-16 11:48:10 +0200 | [diff] [blame] | 420 | } |
| 421 | return xferred; |
| 422 | } |
| 423 | |
| 424 | /* Check for pending connections at the backend, and assign some of them to |
| 425 | * the server coming up. The server's weight is checked before being assigned |
| 426 | * connections it may not be able to handle. The total number of transferred |
Willy Tarreau | 5e83d99 | 2019-07-30 11:59:34 +0200 | [diff] [blame] | 427 | * connections is returned. It must be called with the server lock held, and |
| 428 | * will take the proxy's lock. |
Willy Tarreau | 4aac7db | 2014-05-16 11:48:10 +0200 | [diff] [blame] | 429 | */ |
| 430 | int pendconn_grab_from_px(struct server *s) |
| 431 | { |
Patrick Hemmer | 0355dab | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 432 | struct pendconn *p; |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 433 | int maxconn, xferred = 0; |
Willy Tarreau | 4aac7db | 2014-05-16 11:48:10 +0200 | [diff] [blame] | 434 | |
Emeric Brun | 52a91d3 | 2017-08-31 14:41:55 +0200 | [diff] [blame] | 435 | if (!srv_currently_usable(s)) |
Willy Tarreau | 4aac7db | 2014-05-16 11:48:10 +0200 | [diff] [blame] | 436 | return 0; |
| 437 | |
Willy Tarreau | a869465 | 2018-08-07 10:44:58 +0200 | [diff] [blame] | 438 | /* if this is a backup server and there are active servers or at |
| 439 | * least another backup server was elected, then this one must |
| 440 | * not dequeue requests from the proxy. |
| 441 | */ |
| 442 | if ((s->flags & SRV_F_BACKUP) && |
| 443 | (s->proxy->srv_act || |
| 444 | ((s != s->proxy->lbprm.fbck) && !(s->proxy->options & PR_O_USE_ALL_BK)))) |
| 445 | return 0; |
| 446 | |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 447 | HA_SPIN_LOCK(PROXY_LOCK, &s->proxy->lock); |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 448 | maxconn = srv_dynamic_maxconn(s); |
Patrick Hemmer | 248cb4c | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 449 | while ((p = pendconn_first(&s->proxy->pendconns))) { |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 450 | if (s->maxconn && s->served + xferred >= maxconn) |
Willy Tarreau | 4aac7db | 2014-05-16 11:48:10 +0200 | [diff] [blame] | 451 | break; |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 452 | |
Willy Tarreau | 9624fae | 2018-07-25 08:04:20 +0200 | [diff] [blame] | 453 | __pendconn_unlink(p); |
Willy Tarreau | 88930dd | 2018-07-26 07:38:54 +0200 | [diff] [blame] | 454 | p->target = s; |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 455 | |
| 456 | task_wakeup(p->strm->task, TASK_WOKEN_RES); |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 457 | xferred++; |
Willy Tarreau | 4aac7db | 2014-05-16 11:48:10 +0200 | [diff] [blame] | 458 | } |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 459 | HA_SPIN_UNLOCK(PROXY_LOCK, &s->proxy->lock); |
Willy Tarreau | 4aac7db | 2014-05-16 11:48:10 +0200 | [diff] [blame] | 460 | return xferred; |
| 461 | } |
| 462 | |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 463 | /* Try to dequeue pending connection attached to the stream <strm>. It must |
| 464 | * always exists here. If the pendconn is still linked to the server or the |
| 465 | * proxy queue, nothing is done and the function returns 1. Otherwise, |
| 466 | * <strm>->flags and <strm>->target are updated, the pendconn is released and 0 |
| 467 | * is returned. |
| 468 | * |
| 469 | * This function must be called by the stream itself, so in the context of |
| 470 | * process_stream. |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 471 | */ |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 472 | int pendconn_dequeue(struct stream *strm) |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 473 | { |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 474 | struct pendconn *p; |
Willy Tarreau | 3201e4e | 2018-07-26 08:23:24 +0200 | [diff] [blame] | 475 | int is_unlinked; |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 476 | |
| 477 | if (unlikely(!strm->pend_pos)) { |
| 478 | /* unexpected case because it is called by the stream itself and |
| 479 | * only the stream can release a pendconn. So it is only |
| 480 | * possible if a pendconn is released by someone else or if the |
| 481 | * stream is supposed to be queued but without its associated |
| 482 | * pendconn. In both cases it is a bug! */ |
| 483 | abort(); |
Christopher Faulet | 8ba5914 | 2017-06-27 15:43:53 +0200 | [diff] [blame] | 484 | } |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 485 | p = strm->pend_pos; |
Willy Tarreau | 3201e4e | 2018-07-26 08:23:24 +0200 | [diff] [blame] | 486 | |
| 487 | /* note below : we need to grab the queue's lock to check for emptiness |
| 488 | * because we don't want a partial _grab_from_px() or _redistribute() |
| 489 | * to be called in parallel and show an empty list without having the |
| 490 | * time to finish. With this we know that if we see the element |
| 491 | * unlinked, these functions were completely done. |
| 492 | */ |
| 493 | pendconn_queue_lock(p); |
Patrick Hemmer | 0355dab | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 494 | is_unlinked = !p->node.node.leaf_p; |
Willy Tarreau | 3201e4e | 2018-07-26 08:23:24 +0200 | [diff] [blame] | 495 | pendconn_queue_unlock(p); |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 496 | |
Willy Tarreau | 3201e4e | 2018-07-26 08:23:24 +0200 | [diff] [blame] | 497 | if (!is_unlinked) |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 498 | return 1; |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 499 | |
Willy Tarreau | 3201e4e | 2018-07-26 08:23:24 +0200 | [diff] [blame] | 500 | /* the pendconn is not queued anymore and will not be so we're safe |
| 501 | * to proceed. |
| 502 | */ |
Willy Tarreau | 88930dd | 2018-07-26 07:38:54 +0200 | [diff] [blame] | 503 | if (p->target) |
| 504 | strm->target = &p->target->obj_type; |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 505 | |
| 506 | strm->flags &= ~(SF_DIRECT | SF_ASSIGNED | SF_ADDR_SET); |
| 507 | strm->flags |= p->strm_flags & (SF_DIRECT | SF_ASSIGNED | SF_ADDR_SET); |
| 508 | strm->pend_pos = NULL; |
Willy Tarreau | bafbe01 | 2017-11-24 17:34:44 +0100 | [diff] [blame] | 509 | pool_free(pool_head_pendconn, p); |
Christopher Faulet | 5cd4bbd | 2018-03-14 16:18:06 +0100 | [diff] [blame] | 510 | return 0; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 511 | } |
| 512 | |
Patrick Hemmer | 268a707 | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 513 | static enum act_return action_set_priority_class(struct act_rule *rule, struct proxy *px, |
| 514 | struct session *sess, struct stream *s, int flags) |
| 515 | { |
| 516 | struct sample *smp; |
| 517 | |
| 518 | smp = sample_fetch_as_type(px, sess, s, SMP_OPT_DIR_REQ|SMP_OPT_FINAL, rule->arg.expr, SMP_T_SINT); |
| 519 | if (!smp) |
| 520 | return ACT_RET_CONT; |
| 521 | |
| 522 | s->priority_class = queue_limit_class(smp->data.u.sint); |
| 523 | return ACT_RET_CONT; |
| 524 | } |
| 525 | |
| 526 | static enum act_return action_set_priority_offset(struct act_rule *rule, struct proxy *px, |
| 527 | struct session *sess, struct stream *s, int flags) |
| 528 | { |
| 529 | struct sample *smp; |
| 530 | |
| 531 | smp = sample_fetch_as_type(px, sess, s, SMP_OPT_DIR_REQ|SMP_OPT_FINAL, rule->arg.expr, SMP_T_SINT); |
| 532 | if (!smp) |
| 533 | return ACT_RET_CONT; |
| 534 | |
| 535 | s->priority_offset = queue_limit_offset(smp->data.u.sint); |
| 536 | |
| 537 | return ACT_RET_CONT; |
| 538 | } |
| 539 | |
| 540 | static enum act_parse_ret parse_set_priority_class(const char **args, int *arg, struct proxy *px, |
| 541 | struct act_rule *rule, char **err) |
| 542 | { |
| 543 | unsigned int where = 0; |
| 544 | |
| 545 | rule->arg.expr = sample_parse_expr((char **)args, arg, px->conf.args.file, |
Willy Tarreau | e3b57bf | 2020-02-14 16:50:14 +0100 | [diff] [blame] | 546 | px->conf.args.line, err, &px->conf.args, NULL); |
Patrick Hemmer | 268a707 | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 547 | if (!rule->arg.expr) |
| 548 | return ACT_RET_PRS_ERR; |
| 549 | |
| 550 | if (px->cap & PR_CAP_FE) |
| 551 | where |= SMP_VAL_FE_HRQ_HDR; |
| 552 | if (px->cap & PR_CAP_BE) |
| 553 | where |= SMP_VAL_BE_HRQ_HDR; |
| 554 | |
| 555 | if (!(rule->arg.expr->fetch->val & where)) { |
| 556 | memprintf(err, |
| 557 | "fetch method '%s' extracts information from '%s', none of which is available here", |
| 558 | args[0], sample_src_names(rule->arg.expr->fetch->use)); |
| 559 | free(rule->arg.expr); |
| 560 | return ACT_RET_PRS_ERR; |
| 561 | } |
| 562 | |
| 563 | rule->action = ACT_CUSTOM; |
| 564 | rule->action_ptr = action_set_priority_class; |
| 565 | return ACT_RET_PRS_OK; |
| 566 | } |
| 567 | |
| 568 | static enum act_parse_ret parse_set_priority_offset(const char **args, int *arg, struct proxy *px, |
| 569 | struct act_rule *rule, char **err) |
| 570 | { |
| 571 | unsigned int where = 0; |
| 572 | |
| 573 | rule->arg.expr = sample_parse_expr((char **)args, arg, px->conf.args.file, |
Willy Tarreau | e3b57bf | 2020-02-14 16:50:14 +0100 | [diff] [blame] | 574 | px->conf.args.line, err, &px->conf.args, NULL); |
Patrick Hemmer | 268a707 | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 575 | if (!rule->arg.expr) |
| 576 | return ACT_RET_PRS_ERR; |
| 577 | |
| 578 | if (px->cap & PR_CAP_FE) |
| 579 | where |= SMP_VAL_FE_HRQ_HDR; |
| 580 | if (px->cap & PR_CAP_BE) |
| 581 | where |= SMP_VAL_BE_HRQ_HDR; |
| 582 | |
| 583 | if (!(rule->arg.expr->fetch->val & where)) { |
| 584 | memprintf(err, |
| 585 | "fetch method '%s' extracts information from '%s', none of which is available here", |
| 586 | args[0], sample_src_names(rule->arg.expr->fetch->use)); |
| 587 | free(rule->arg.expr); |
| 588 | return ACT_RET_PRS_ERR; |
| 589 | } |
| 590 | |
| 591 | rule->action = ACT_CUSTOM; |
| 592 | rule->action_ptr = action_set_priority_offset; |
| 593 | return ACT_RET_PRS_OK; |
| 594 | } |
| 595 | |
| 596 | static struct action_kw_list tcp_cont_kws = {ILH, { |
| 597 | { "set-priority-class", parse_set_priority_class }, |
| 598 | { "set-priority-offset", parse_set_priority_offset }, |
| 599 | { /* END */ } |
| 600 | }}; |
| 601 | |
Willy Tarreau | 0108d90 | 2018-11-25 19:14:37 +0100 | [diff] [blame] | 602 | INITCALL1(STG_REGISTER, tcp_req_cont_keywords_register, &tcp_cont_kws); |
| 603 | |
Patrick Hemmer | 268a707 | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 604 | static struct action_kw_list http_req_kws = {ILH, { |
| 605 | { "set-priority-class", parse_set_priority_class }, |
| 606 | { "set-priority-offset", parse_set_priority_offset }, |
| 607 | { /* END */ } |
| 608 | }}; |
| 609 | |
Willy Tarreau | 0108d90 | 2018-11-25 19:14:37 +0100 | [diff] [blame] | 610 | INITCALL1(STG_REGISTER, http_req_keywords_register, &http_req_kws); |
| 611 | |
Patrick Hemmer | 268a707 | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 612 | static int |
| 613 | smp_fetch_priority_class(const struct arg *args, struct sample *smp, const char *kw, void *private) |
| 614 | { |
| 615 | if (!smp->strm) |
| 616 | return 0; |
| 617 | |
| 618 | smp->data.type = SMP_T_SINT; |
| 619 | smp->data.u.sint = smp->strm->priority_class; |
| 620 | |
| 621 | return 1; |
| 622 | } |
| 623 | |
| 624 | static int |
| 625 | smp_fetch_priority_offset(const struct arg *args, struct sample *smp, const char *kw, void *private) |
| 626 | { |
| 627 | if (!smp->strm) |
| 628 | return 0; |
| 629 | |
| 630 | smp->data.type = SMP_T_SINT; |
| 631 | smp->data.u.sint = smp->strm->priority_offset; |
| 632 | |
| 633 | return 1; |
| 634 | } |
| 635 | |
| 636 | |
| 637 | static struct sample_fetch_kw_list smp_kws = {ILH, { |
| 638 | { "prio_class", smp_fetch_priority_class, 0, NULL, SMP_T_SINT, SMP_USE_INTRN, }, |
| 639 | { "prio_offset", smp_fetch_priority_offset, 0, NULL, SMP_T_SINT, SMP_USE_INTRN, }, |
| 640 | { /* END */}, |
| 641 | }}; |
| 642 | |
Willy Tarreau | 0108d90 | 2018-11-25 19:14:37 +0100 | [diff] [blame] | 643 | INITCALL1(STG_REGISTER, sample_register_fetches, &smp_kws); |
Patrick Hemmer | 268a707 | 2018-05-11 12:52:31 -0400 | [diff] [blame] | 644 | |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 645 | /* |
| 646 | * Local variables: |
| 647 | * c-indent-level: 8 |
| 648 | * c-basic-offset: 8 |
| 649 | * End: |
| 650 | */ |