Willy TARREAU | 3dc0644 | 2006-06-15 21:48:13 +0200 | [diff] [blame] | 1 | /* |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 2 | * include/proto/stream.h |
| 3 | * This file defines everything related to streams. |
Willy Tarreau | 81f9aa3 | 2010-06-01 17:45:26 +0200 | [diff] [blame] | 4 | * |
| 5 | * Copyright (C) 2000-2010 Willy Tarreau - w@1wt.eu |
| 6 | * |
| 7 | * This library is free software; you can redistribute it and/or |
| 8 | * modify it under the terms of the GNU Lesser General Public |
| 9 | * License as published by the Free Software Foundation, version 2.1 |
| 10 | * exclusively. |
| 11 | * |
| 12 | * This library is distributed in the hope that it will be useful, |
| 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 15 | * Lesser General Public License for more details. |
| 16 | * |
| 17 | * You should have received a copy of the GNU Lesser General Public |
| 18 | * License along with this library; if not, write to the Free Software |
| 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| 20 | */ |
Willy TARREAU | 3dc0644 | 2006-06-15 21:48:13 +0200 | [diff] [blame] | 21 | |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 22 | #ifndef _PROTO_STREAM_H |
| 23 | #define _PROTO_STREAM_H |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 24 | |
Willy Tarreau | 122eba9 | 2020-06-04 10:15:32 +0200 | [diff] [blame^] | 25 | #include <haproxy/action-t.h> |
Willy Tarreau | 4c7e4b7 | 2020-05-27 12:58:42 +0200 | [diff] [blame] | 26 | #include <haproxy/api.h> |
Willy Tarreau | d0ef439 | 2020-06-02 09:38:52 +0200 | [diff] [blame] | 27 | #include <haproxy/pool.h> |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 28 | #include <types/stream.h> |
Willy Tarreau | 0f6ffd6 | 2020-06-03 19:33:00 +0200 | [diff] [blame] | 29 | #include <haproxy/fd.h> |
Willy Tarreau | 6634794 | 2020-06-01 12:18:08 +0200 | [diff] [blame] | 30 | #include <haproxy/freq_ctr.h> |
Olivier Houchard | 4bd5867 | 2019-07-12 16:16:59 +0200 | [diff] [blame] | 31 | #include <proto/obj_type.h> |
| 32 | #include <proto/queue.h> |
Willy Tarreau | 9ba2dcc | 2010-06-14 21:04:55 +0200 | [diff] [blame] | 33 | #include <proto/stick_table.h> |
Willy Tarreau | a24adf0 | 2014-11-27 01:11:56 +0100 | [diff] [blame] | 34 | #include <proto/task.h> |
Christopher Faulet | eea8fc7 | 2019-11-05 16:18:10 +0100 | [diff] [blame] | 35 | #include <proto/trace.h> |
| 36 | |
| 37 | extern struct trace_source trace_strm; |
| 38 | |
| 39 | /* Details about these events are defined in <src/stream.c> */ |
| 40 | #define STRM_EV_STRM_NEW (1ULL << 0) |
| 41 | #define STRM_EV_STRM_FREE (1ULL << 1) |
| 42 | #define STRM_EV_STRM_ERR (1ULL << 2) |
| 43 | #define STRM_EV_STRM_ANA (1ULL << 3) |
| 44 | #define STRM_EV_STRM_PROC (1ULL << 4) |
| 45 | #define STRM_EV_SI_ST (1ULL << 5) |
| 46 | #define STRM_EV_HTTP_ANA (1ULL << 6) |
| 47 | #define STRM_EV_HTTP_ERR (1ULL << 7) |
| 48 | #define STRM_EV_TCP_ANA (1ULL << 8) |
| 49 | #define STRM_EV_TCP_ERR (1ULL << 9) |
| 50 | #define STRM_EV_FLT_ANA (1ULL << 10) |
| 51 | #define STRM_EV_FLT_ERR (1ULL << 11) |
Willy TARREAU | 3dc0644 | 2006-06-15 21:48:13 +0200 | [diff] [blame] | 52 | |
Christopher Faulet | c8b246f | 2019-05-14 22:05:28 +0200 | [diff] [blame] | 53 | #define IS_HTX_STRM(strm) ((strm)->flags & SF_HTX) |
| 54 | |
Willy Tarreau | bafbe01 | 2017-11-24 17:34:44 +0100 | [diff] [blame] | 55 | extern struct pool_head *pool_head_stream; |
Tim Duesterhus | 127a74d | 2020-02-28 15:13:33 +0100 | [diff] [blame] | 56 | extern struct pool_head *pool_head_uniqueid; |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 57 | extern struct list streams; |
Willy Tarreau | c6ca1a0 | 2007-05-13 19:43:47 +0200 | [diff] [blame] | 58 | |
Willy Tarreau | bc174aa | 2012-11-19 16:10:32 +0100 | [diff] [blame] | 59 | extern struct data_cb sess_conn_cb; |
| 60 | |
Willy Tarreau | 87787ac | 2017-08-28 16:22:54 +0200 | [diff] [blame] | 61 | struct stream *stream_new(struct session *sess, enum obj_type *origin); |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 62 | int stream_create_from_cs(struct conn_stream *cs); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 63 | |
Willy Tarreau | e7dff02 | 2015-04-03 01:14:29 +0200 | [diff] [blame] | 64 | /* kill a stream and set the termination flags to <why> (one of SF_ERR_*) */ |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 65 | void stream_shutdown(struct stream *stream, int why); |
Willy Tarreau | 5484d58 | 2019-05-22 09:33:03 +0200 | [diff] [blame] | 66 | void stream_dump(struct buffer *buf, const struct stream *s, const char *pfx, char eol); |
Willy Tarreau | 71c07ac | 2019-04-25 19:08:48 +0200 | [diff] [blame] | 67 | void stream_dump_and_crash(enum obj_type *obj, int rate); |
Simon Horman | dec5be4 | 2011-06-08 09:19:07 +0900 | [diff] [blame] | 68 | |
Tim Duesterhus | a17e662 | 2020-03-05 20:19:02 +0100 | [diff] [blame] | 69 | struct ist stream_generate_unique_id(struct stream *strm, struct list *format); |
Tim Duesterhus | 127a74d | 2020-02-28 15:13:33 +0100 | [diff] [blame] | 70 | |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 71 | void stream_process_counters(struct stream *s); |
| 72 | void sess_change_server(struct stream *sess, struct server *newsrv); |
Olivier Houchard | 9f6af33 | 2018-05-25 14:04:04 +0200 | [diff] [blame] | 73 | struct task *process_stream(struct task *t, void *context, unsigned short state); |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 74 | void default_srv_error(struct stream *s, struct stream_interface *si); |
Willy Tarreau | 9ba2dcc | 2010-06-14 21:04:55 +0200 | [diff] [blame] | 75 | int parse_track_counters(char **args, int *arg, |
| 76 | int section_type, struct proxy *curpx, |
| 77 | struct track_ctr_prm *prm, |
Willy Tarreau | 0a3dd74 | 2012-05-08 19:47:01 +0200 | [diff] [blame] | 78 | struct proxy *defpx, char **err); |
Willy Tarreau | 9ba2dcc | 2010-06-14 21:04:55 +0200 | [diff] [blame] | 79 | |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 80 | /* Update the stream's backend and server time stats */ |
| 81 | void stream_update_time_stats(struct stream *s); |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 82 | void stream_release_buffers(struct stream *s); |
Willy Tarreau | b882dd8 | 2018-11-06 15:50:21 +0100 | [diff] [blame] | 83 | int stream_buf_available(void *arg); |
Willy Tarreau | 4bfc580 | 2014-06-17 12:19:18 +0200 | [diff] [blame] | 84 | |
Willy Tarreau | b1ec8c4 | 2015-04-03 13:53:24 +0200 | [diff] [blame] | 85 | /* returns the session this stream belongs to */ |
| 86 | static inline struct session *strm_sess(const struct stream *strm) |
| 87 | { |
| 88 | return strm->sess; |
| 89 | } |
| 90 | |
Willy Tarreau | d0d8da9 | 2015-04-04 02:10:38 +0200 | [diff] [blame] | 91 | /* returns the frontend this stream was initiated from */ |
| 92 | static inline struct proxy *strm_fe(const struct stream *strm) |
| 93 | { |
| 94 | return strm->sess->fe; |
| 95 | } |
| 96 | |
| 97 | /* returns the listener this stream was initiated from */ |
| 98 | static inline struct listener *strm_li(const struct stream *strm) |
| 99 | { |
| 100 | return strm->sess->listener; |
| 101 | } |
| 102 | |
| 103 | /* returns a pointer to the origin of the session which created this stream */ |
| 104 | static inline enum obj_type *strm_orig(const struct stream *strm) |
| 105 | { |
| 106 | return strm->sess->origin; |
| 107 | } |
| 108 | |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 109 | /* Remove the refcount from the stream to the tracked counters, and clear the |
Willy Tarreau | 9ba2dcc | 2010-06-14 21:04:55 +0200 | [diff] [blame] | 110 | * pointer to ensure this is only performed once. The caller is responsible for |
Willy Tarreau | a68f762 | 2015-09-21 17:48:24 +0200 | [diff] [blame] | 111 | * ensuring that the pointer is valid first. We must be extremely careful not |
| 112 | * to touch the entries we inherited from the session. |
Willy Tarreau | 9ba2dcc | 2010-06-14 21:04:55 +0200 | [diff] [blame] | 113 | */ |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 114 | static inline void stream_store_counters(struct stream *s) |
Willy Tarreau | 9ba2dcc | 2010-06-14 21:04:55 +0200 | [diff] [blame] | 115 | { |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 116 | void *ptr; |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 117 | int i; |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 118 | struct stksess *ts; |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 119 | |
Willy Tarreau | b4c8493 | 2013-07-23 19:15:30 +0200 | [diff] [blame] | 120 | for (i = 0; i < MAX_SESS_STKCTR; i++) { |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 121 | ts = stkctr_entry(&s->stkctr[i]); |
| 122 | if (!ts) |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 123 | continue; |
Willy Tarreau | a68f762 | 2015-09-21 17:48:24 +0200 | [diff] [blame] | 124 | |
| 125 | if (stkctr_entry(&s->sess->stkctr[i])) |
| 126 | continue; |
| 127 | |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 128 | ptr = stktable_data_ptr(s->stkctr[i].table, ts, STKTABLE_DT_CONN_CUR); |
| 129 | if (ptr) { |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 130 | HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock); |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 131 | |
Tim Duesterhus | 8b87c01 | 2019-01-04 00:11:59 +0100 | [diff] [blame] | 132 | if (stktable_data_cast(ptr, conn_cur) > 0) |
| 133 | stktable_data_cast(ptr, conn_cur)--; |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 134 | |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 135 | HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock); |
Emeric Brun | 0fed0b0 | 2017-11-29 16:15:07 +0100 | [diff] [blame] | 136 | |
| 137 | /* If data was modified, we need to touch to re-schedule sync */ |
| 138 | stktable_touch_local(s->stkctr[i].table, ts, 0); |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 139 | } |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 140 | stkctr_set_entry(&s->stkctr[i], NULL); |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 141 | stksess_kill_if_expired(s->stkctr[i].table, ts, 1); |
Willy Tarreau | 38285c1 | 2010-06-18 16:35:43 +0200 | [diff] [blame] | 142 | } |
Willy Tarreau | 9ba2dcc | 2010-06-14 21:04:55 +0200 | [diff] [blame] | 143 | } |
| 144 | |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 145 | /* Remove the refcount from the stream counters tracked at the content level if |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 146 | * any, and clear the pointer to ensure this is only performed once. The caller |
Willy Tarreau | a68f762 | 2015-09-21 17:48:24 +0200 | [diff] [blame] | 147 | * is responsible for ensuring that the pointer is valid first. We must be |
| 148 | * extremely careful not to touch the entries we inherited from the session. |
Willy Tarreau | 9ba2dcc | 2010-06-14 21:04:55 +0200 | [diff] [blame] | 149 | */ |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 150 | static inline void stream_stop_content_counters(struct stream *s) |
Willy Tarreau | 9ba2dcc | 2010-06-14 21:04:55 +0200 | [diff] [blame] | 151 | { |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 152 | struct stksess *ts; |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 153 | void *ptr; |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 154 | int i; |
Willy Tarreau | e348793 | 2010-06-18 21:03:20 +0200 | [diff] [blame] | 155 | |
Willy Tarreau | b4c8493 | 2013-07-23 19:15:30 +0200 | [diff] [blame] | 156 | for (i = 0; i < MAX_SESS_STKCTR; i++) { |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 157 | ts = stkctr_entry(&s->stkctr[i]); |
| 158 | if (!ts) |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 159 | continue; |
Willy Tarreau | 0a4838c | 2010-08-06 20:11:05 +0200 | [diff] [blame] | 160 | |
Willy Tarreau | a68f762 | 2015-09-21 17:48:24 +0200 | [diff] [blame] | 161 | if (stkctr_entry(&s->sess->stkctr[i])) |
| 162 | continue; |
| 163 | |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 164 | if (!(stkctr_flags(&s->stkctr[i]) & STKCTR_TRACK_CONTENT)) |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 165 | continue; |
| 166 | |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 167 | ptr = stktable_data_ptr(s->stkctr[i].table, ts, STKTABLE_DT_CONN_CUR); |
| 168 | if (ptr) { |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 169 | HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock); |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 170 | |
Tim Duesterhus | 8b87c01 | 2019-01-04 00:11:59 +0100 | [diff] [blame] | 171 | if (stktable_data_cast(ptr, conn_cur) > 0) |
| 172 | stktable_data_cast(ptr, conn_cur)--; |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 173 | |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 174 | HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock); |
Emeric Brun | 0fed0b0 | 2017-11-29 16:15:07 +0100 | [diff] [blame] | 175 | |
| 176 | /* If data was modified, we need to touch to re-schedule sync */ |
| 177 | stktable_touch_local(s->stkctr[i].table, ts, 0); |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 178 | } |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 179 | stkctr_set_entry(&s->stkctr[i], NULL); |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 180 | stksess_kill_if_expired(s->stkctr[i].table, ts, 1); |
Willy Tarreau | 0a4838c | 2010-08-06 20:11:05 +0200 | [diff] [blame] | 181 | } |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 182 | } |
Willy Tarreau | e348793 | 2010-06-18 21:03:20 +0200 | [diff] [blame] | 183 | |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 184 | /* Increase total and concurrent connection count for stick entry <ts> of table |
| 185 | * <t>. The caller is responsible for ensuring that <t> and <ts> are valid |
| 186 | * pointers, and for calling this only once per connection. |
| 187 | */ |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 188 | static inline void stream_start_counters(struct stktable *t, struct stksess *ts) |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 189 | { |
| 190 | void *ptr; |
Willy Tarreau | 91c43d7 | 2010-06-20 11:19:22 +0200 | [diff] [blame] | 191 | |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 192 | HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock); |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 193 | |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 194 | ptr = stktable_data_ptr(t, ts, STKTABLE_DT_CONN_CUR); |
| 195 | if (ptr) |
| 196 | stktable_data_cast(ptr, conn_cur)++; |
| 197 | |
| 198 | ptr = stktable_data_ptr(t, ts, STKTABLE_DT_CONN_CNT); |
| 199 | if (ptr) |
| 200 | stktable_data_cast(ptr, conn_cnt)++; |
| 201 | |
| 202 | ptr = stktable_data_ptr(t, ts, STKTABLE_DT_CONN_RATE); |
| 203 | if (ptr) |
| 204 | update_freq_ctr_period(&stktable_data_cast(ptr, conn_rate), |
| 205 | t->data_arg[STKTABLE_DT_CONN_RATE].u, 1); |
| 206 | if (tick_isset(t->expire)) |
| 207 | ts->expire = tick_add(now_ms, MS_TO_TICKS(t->expire)); |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 208 | |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 209 | HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock); |
Emeric Brun | 0fed0b0 | 2017-11-29 16:15:07 +0100 | [diff] [blame] | 210 | |
| 211 | /* If data was modified, we need to touch to re-schedule sync */ |
| 212 | stktable_touch_local(t, ts, 0); |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 213 | } |
| 214 | |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 215 | /* Enable tracking of stream counters as <stkctr> on stksess <ts>. The caller is |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 216 | * responsible for ensuring that <t> and <ts> are valid pointers. Some controls |
| 217 | * are performed to ensure the state can still change. |
| 218 | */ |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 219 | static inline void stream_track_stkctr(struct stkctr *ctr, struct stktable *t, struct stksess *ts) |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 220 | { |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 221 | /* Why this test ???? */ |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 222 | if (stkctr_entry(ctr)) |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 223 | return; |
| 224 | |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 225 | ctr->table = t; |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 226 | stkctr_set_entry(ctr, ts); |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 227 | stream_start_counters(t, ts); |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 228 | } |
| 229 | |
Willy Tarreau | da7ff64 | 2010-06-23 11:44:09 +0200 | [diff] [blame] | 230 | /* Increase the number of cumulated HTTP requests in the tracked counters */ |
Willy Tarreau | 0e492e2 | 2019-04-15 21:25:03 +0200 | [diff] [blame] | 231 | static inline void stream_inc_http_req_ctr(struct stream *s) |
Willy Tarreau | da7ff64 | 2010-06-23 11:44:09 +0200 | [diff] [blame] | 232 | { |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 233 | struct stksess *ts; |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 234 | void *ptr; |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 235 | int i; |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 236 | |
Willy Tarreau | b4c8493 | 2013-07-23 19:15:30 +0200 | [diff] [blame] | 237 | for (i = 0; i < MAX_SESS_STKCTR; i++) { |
Willy Tarreau | 8b7f868 | 2015-04-04 16:29:12 +0200 | [diff] [blame] | 238 | struct stkctr *stkctr = &s->stkctr[i]; |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 239 | |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 240 | ts = stkctr_entry(stkctr); |
| 241 | if (!ts) { |
Willy Tarreau | 8b7f868 | 2015-04-04 16:29:12 +0200 | [diff] [blame] | 242 | stkctr = &s->sess->stkctr[i]; |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 243 | ts = stkctr_entry(stkctr); |
| 244 | if (!ts) |
Willy Tarreau | 8b7f868 | 2015-04-04 16:29:12 +0200 | [diff] [blame] | 245 | continue; |
| 246 | } |
| 247 | |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 248 | HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock); |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 249 | |
| 250 | ptr = stktable_data_ptr(stkctr->table, ts, STKTABLE_DT_HTTP_REQ_CNT); |
Willy Tarreau | da7ff64 | 2010-06-23 11:44:09 +0200 | [diff] [blame] | 251 | if (ptr) |
| 252 | stktable_data_cast(ptr, http_req_cnt)++; |
| 253 | |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 254 | ptr = stktable_data_ptr(stkctr->table, ts, STKTABLE_DT_HTTP_REQ_RATE); |
Willy Tarreau | da7ff64 | 2010-06-23 11:44:09 +0200 | [diff] [blame] | 255 | if (ptr) |
| 256 | update_freq_ctr_period(&stktable_data_cast(ptr, http_req_rate), |
Willy Tarreau | 8b7f868 | 2015-04-04 16:29:12 +0200 | [diff] [blame] | 257 | stkctr->table->data_arg[STKTABLE_DT_HTTP_REQ_RATE].u, 1); |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 258 | |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 259 | HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock); |
Emeric Brun | 0fed0b0 | 2017-11-29 16:15:07 +0100 | [diff] [blame] | 260 | |
| 261 | /* If data was modified, we need to touch to re-schedule sync */ |
| 262 | stktable_touch_local(stkctr->table, ts, 0); |
Willy Tarreau | da7ff64 | 2010-06-23 11:44:09 +0200 | [diff] [blame] | 263 | } |
| 264 | } |
| 265 | |
Willy Tarreau | 8b7f868 | 2015-04-04 16:29:12 +0200 | [diff] [blame] | 266 | /* Increase the number of cumulated HTTP requests in the backend's tracked |
| 267 | * counters. We don't look up the session since it cannot happen in the bakcend. |
| 268 | */ |
Willy Tarreau | 0e492e2 | 2019-04-15 21:25:03 +0200 | [diff] [blame] | 269 | static inline void stream_inc_be_http_req_ctr(struct stream *s) |
Willy Tarreau | 5d5b5d8 | 2012-12-09 12:00:04 +0100 | [diff] [blame] | 270 | { |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 271 | struct stksess *ts; |
Willy Tarreau | 5d5b5d8 | 2012-12-09 12:00:04 +0100 | [diff] [blame] | 272 | void *ptr; |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 273 | int i; |
Willy Tarreau | 5d5b5d8 | 2012-12-09 12:00:04 +0100 | [diff] [blame] | 274 | |
Willy Tarreau | b4c8493 | 2013-07-23 19:15:30 +0200 | [diff] [blame] | 275 | for (i = 0; i < MAX_SESS_STKCTR; i++) { |
Willy Tarreau | 8b7f868 | 2015-04-04 16:29:12 +0200 | [diff] [blame] | 276 | struct stkctr *stkctr = &s->stkctr[i]; |
| 277 | |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 278 | ts = stkctr_entry(stkctr); |
| 279 | if (!ts) |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 280 | continue; |
Willy Tarreau | 5d5b5d8 | 2012-12-09 12:00:04 +0100 | [diff] [blame] | 281 | |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 282 | if (!(stkctr_flags(&s->stkctr[i]) & STKCTR_TRACK_BACKEND)) |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 283 | continue; |
| 284 | |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 285 | HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock); |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 286 | |
| 287 | ptr = stktable_data_ptr(stkctr->table, ts, STKTABLE_DT_HTTP_REQ_CNT); |
Willy Tarreau | 5d5b5d8 | 2012-12-09 12:00:04 +0100 | [diff] [blame] | 288 | if (ptr) |
| 289 | stktable_data_cast(ptr, http_req_cnt)++; |
| 290 | |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 291 | ptr = stktable_data_ptr(stkctr->table, ts, STKTABLE_DT_HTTP_REQ_RATE); |
Willy Tarreau | 5d5b5d8 | 2012-12-09 12:00:04 +0100 | [diff] [blame] | 292 | if (ptr) |
| 293 | update_freq_ctr_period(&stktable_data_cast(ptr, http_req_rate), |
Willy Tarreau | 8b7f868 | 2015-04-04 16:29:12 +0200 | [diff] [blame] | 294 | stkctr->table->data_arg[STKTABLE_DT_HTTP_REQ_RATE].u, 1); |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 295 | |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 296 | HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock); |
Emeric Brun | 0fed0b0 | 2017-11-29 16:15:07 +0100 | [diff] [blame] | 297 | |
| 298 | /* If data was modified, we need to touch to re-schedule sync */ |
| 299 | stktable_touch_local(stkctr->table, ts, 0); |
Willy Tarreau | 5d5b5d8 | 2012-12-09 12:00:04 +0100 | [diff] [blame] | 300 | } |
| 301 | } |
| 302 | |
Willy Tarreau | da7ff64 | 2010-06-23 11:44:09 +0200 | [diff] [blame] | 303 | /* Increase the number of cumulated failed HTTP requests in the tracked |
| 304 | * counters. Only 4xx requests should be counted here so that we can |
| 305 | * distinguish between errors caused by client behaviour and other ones. |
| 306 | * Note that even 404 are interesting because they're generally caused by |
| 307 | * vulnerability scans. |
| 308 | */ |
Willy Tarreau | 0e492e2 | 2019-04-15 21:25:03 +0200 | [diff] [blame] | 309 | static inline void stream_inc_http_err_ctr(struct stream *s) |
Willy Tarreau | da7ff64 | 2010-06-23 11:44:09 +0200 | [diff] [blame] | 310 | { |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 311 | struct stksess *ts; |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 312 | void *ptr; |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 313 | int i; |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 314 | |
Willy Tarreau | b4c8493 | 2013-07-23 19:15:30 +0200 | [diff] [blame] | 315 | for (i = 0; i < MAX_SESS_STKCTR; i++) { |
Willy Tarreau | 8b7f868 | 2015-04-04 16:29:12 +0200 | [diff] [blame] | 316 | struct stkctr *stkctr = &s->stkctr[i]; |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 317 | |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 318 | ts = stkctr_entry(stkctr); |
| 319 | if (!ts) { |
Willy Tarreau | 8b7f868 | 2015-04-04 16:29:12 +0200 | [diff] [blame] | 320 | stkctr = &s->sess->stkctr[i]; |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 321 | ts = stkctr_entry(stkctr); |
| 322 | if (!ts) |
Willy Tarreau | 8b7f868 | 2015-04-04 16:29:12 +0200 | [diff] [blame] | 323 | continue; |
| 324 | } |
| 325 | |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 326 | HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock); |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 327 | |
| 328 | ptr = stktable_data_ptr(stkctr->table, ts, STKTABLE_DT_HTTP_ERR_CNT); |
Willy Tarreau | da7ff64 | 2010-06-23 11:44:09 +0200 | [diff] [blame] | 329 | if (ptr) |
| 330 | stktable_data_cast(ptr, http_err_cnt)++; |
| 331 | |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 332 | ptr = stktable_data_ptr(stkctr->table, ts, STKTABLE_DT_HTTP_ERR_RATE); |
Willy Tarreau | da7ff64 | 2010-06-23 11:44:09 +0200 | [diff] [blame] | 333 | if (ptr) |
| 334 | update_freq_ctr_period(&stktable_data_cast(ptr, http_err_rate), |
Willy Tarreau | 8b7f868 | 2015-04-04 16:29:12 +0200 | [diff] [blame] | 335 | stkctr->table->data_arg[STKTABLE_DT_HTTP_ERR_RATE].u, 1); |
Emeric Brun | 819fc6f | 2017-06-13 19:37:32 +0200 | [diff] [blame] | 336 | |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 337 | HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock); |
Emeric Brun | 0fed0b0 | 2017-11-29 16:15:07 +0100 | [diff] [blame] | 338 | |
| 339 | /* If data was modified, we need to touch to re-schedule sync */ |
| 340 | stktable_touch_local(stkctr->table, ts, 0); |
Willy Tarreau | da7ff64 | 2010-06-23 11:44:09 +0200 | [diff] [blame] | 341 | } |
| 342 | } |
| 343 | |
Willy Tarreau | 0e492e2 | 2019-04-15 21:25:03 +0200 | [diff] [blame] | 344 | static inline void __stream_add_srv_conn(struct stream *sess, struct server *srv) |
Simon Horman | af51495 | 2011-06-21 14:34:57 +0900 | [diff] [blame] | 345 | { |
| 346 | sess->srv_conn = srv; |
| 347 | LIST_ADD(&srv->actconns, &sess->by_srv); |
Willy Tarreau | 103e566 | 2017-11-26 18:48:14 +0100 | [diff] [blame] | 348 | } |
| 349 | |
Willy Tarreau | 0e492e2 | 2019-04-15 21:25:03 +0200 | [diff] [blame] | 350 | static inline void stream_add_srv_conn(struct stream *sess, struct server *srv) |
Willy Tarreau | 103e566 | 2017-11-26 18:48:14 +0100 | [diff] [blame] | 351 | { |
| 352 | HA_SPIN_LOCK(SERVER_LOCK, &srv->lock); |
| 353 | __stream_add_srv_conn(sess, srv); |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 354 | HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock); |
Simon Horman | af51495 | 2011-06-21 14:34:57 +0900 | [diff] [blame] | 355 | } |
| 356 | |
Willy Tarreau | 0e492e2 | 2019-04-15 21:25:03 +0200 | [diff] [blame] | 357 | static inline void stream_del_srv_conn(struct stream *sess) |
Simon Horman | af51495 | 2011-06-21 14:34:57 +0900 | [diff] [blame] | 358 | { |
Christopher Faulet | 29f77e8 | 2017-06-08 14:04:45 +0200 | [diff] [blame] | 359 | struct server *srv = sess->srv_conn; |
| 360 | |
| 361 | if (!srv) |
Simon Horman | af51495 | 2011-06-21 14:34:57 +0900 | [diff] [blame] | 362 | return; |
| 363 | |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 364 | HA_SPIN_LOCK(SERVER_LOCK, &srv->lock); |
Simon Horman | af51495 | 2011-06-21 14:34:57 +0900 | [diff] [blame] | 365 | sess->srv_conn = NULL; |
| 366 | LIST_DEL(&sess->by_srv); |
Christopher Faulet | 2a944ee | 2017-11-07 10:42:54 +0100 | [diff] [blame] | 367 | HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock); |
Simon Horman | af51495 | 2011-06-21 14:34:57 +0900 | [diff] [blame] | 368 | } |
| 369 | |
Willy Tarreau | 0e492e2 | 2019-04-15 21:25:03 +0200 | [diff] [blame] | 370 | static inline void stream_init_srv_conn(struct stream *sess) |
Willy Tarreau | 9bd0d74 | 2011-07-20 00:17:39 +0200 | [diff] [blame] | 371 | { |
| 372 | sess->srv_conn = NULL; |
| 373 | LIST_INIT(&sess->by_srv); |
| 374 | } |
| 375 | |
Olivier Houchard | 4bd5867 | 2019-07-12 16:16:59 +0200 | [diff] [blame] | 376 | static inline void stream_choose_redispatch(struct stream *s) |
| 377 | { |
| 378 | struct stream_interface *si = &s->si[1]; |
| 379 | |
| 380 | /* If the "redispatch" option is set on the backend, we are allowed to |
| 381 | * retry on another server. By default this redispatch occurs on the |
| 382 | * last retry, but if configured we allow redispatches to occur on |
| 383 | * configurable intervals, e.g. on every retry. In order to achieve this, |
| 384 | * we must mark the stream unassigned, and eventually clear the DIRECT |
| 385 | * bit to ignore any persistence cookie. We won't count a retry nor a |
| 386 | * redispatch yet, because this will depend on what server is selected. |
| 387 | * If the connection is not persistent, the balancing algorithm is not |
| 388 | * determinist (round robin) and there is more than one active server, |
| 389 | * we accept to perform an immediate redispatch without waiting since |
| 390 | * we don't care about this particular server. |
| 391 | */ |
| 392 | if (objt_server(s->target) && |
| 393 | (s->be->options & PR_O_REDISP) && !(s->flags & SF_FORCE_PRST) && |
| 394 | ((__objt_server(s->target)->cur_state < SRV_ST_RUNNING) || |
| 395 | (((s->be->redispatch_after > 0) && |
| 396 | ((s->be->conn_retries - si->conn_retries) % |
| 397 | s->be->redispatch_after == 0)) || |
| 398 | ((s->be->redispatch_after < 0) && |
| 399 | ((s->be->conn_retries - si->conn_retries) % |
| 400 | (s->be->conn_retries + 1 + s->be->redispatch_after) == 0))) || |
| 401 | (!(s->flags & SF_DIRECT) && s->be->srv_act > 1 && |
| 402 | ((s->be->lbprm.algo & BE_LB_KIND) == BE_LB_KIND_RR)))) { |
| 403 | sess_change_server(s, NULL); |
| 404 | if (may_dequeue_tasks(objt_server(s->target), s->be)) |
| 405 | process_srv_queue(objt_server(s->target)); |
| 406 | |
| 407 | s->flags &= ~(SF_DIRECT | SF_ASSIGNED | SF_ADDR_SET); |
| 408 | si->state = SI_ST_REQ; |
| 409 | } else { |
| 410 | if (objt_server(s->target)) |
| 411 | _HA_ATOMIC_ADD(&__objt_server(s->target)->counters.retries, 1); |
| 412 | _HA_ATOMIC_ADD(&s->be->be_counters.retries, 1); |
| 413 | si->state = SI_ST_ASS; |
| 414 | } |
| 415 | |
| 416 | } |
| 417 | |
Thierry FOURNIER | 5a363e7 | 2015-09-27 19:29:33 +0200 | [diff] [blame] | 418 | void service_keywords_register(struct action_kw_list *kw_list); |
Willy Tarreau | 679bba1 | 2019-03-19 08:08:10 +0100 | [diff] [blame] | 419 | void list_services(FILE *out); |
Thierry FOURNIER | 5a363e7 | 2015-09-27 19:29:33 +0200 | [diff] [blame] | 420 | |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 421 | #endif /* _PROTO_STREAM_H */ |
Willy TARREAU | 3dc0644 | 2006-06-15 21:48:13 +0200 | [diff] [blame] | 422 | |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 423 | /* |
| 424 | * Local variables: |
| 425 | * c-indent-level: 8 |
| 426 | * c-basic-offset: 8 |
| 427 | * End: |
| 428 | */ |