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 | e3ba5f0 | 2006-06-29 18:54:54 +0200 | [diff] [blame] | 25 | #include <common/config.h> |
Willy Tarreau | c6ca1a0 | 2007-05-13 19:43:47 +0200 | [diff] [blame] | 26 | #include <common/memory.h> |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 27 | #include <types/stream.h> |
Willy Tarreau | a24adf0 | 2014-11-27 01:11:56 +0100 | [diff] [blame] | 28 | #include <proto/fd.h> |
Willy Tarreau | 91c43d7 | 2010-06-20 11:19:22 +0200 | [diff] [blame] | 29 | #include <proto/freq_ctr.h> |
Willy Tarreau | 9ba2dcc | 2010-06-14 21:04:55 +0200 | [diff] [blame] | 30 | #include <proto/stick_table.h> |
Willy Tarreau | a24adf0 | 2014-11-27 01:11:56 +0100 | [diff] [blame] | 31 | #include <proto/task.h> |
Willy TARREAU | 3dc0644 | 2006-06-15 21:48:13 +0200 | [diff] [blame] | 32 | |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 33 | extern struct pool_head *pool2_stream; |
| 34 | extern struct list streams; |
Willy Tarreau | bf883e0 | 2014-11-25 21:10:35 +0100 | [diff] [blame] | 35 | extern struct list buffer_wq; |
Willy Tarreau | c6ca1a0 | 2007-05-13 19:43:47 +0200 | [diff] [blame] | 36 | |
Willy Tarreau | bc174aa | 2012-11-19 16:10:32 +0100 | [diff] [blame] | 37 | extern struct data_cb sess_conn_cb; |
| 38 | |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 39 | int stream_accept(struct listener *l, int cfd, struct sockaddr_storage *addr); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 40 | |
Willy Tarreau | c6ca1a0 | 2007-05-13 19:43:47 +0200 | [diff] [blame] | 41 | /* perform minimal intializations, report 0 in case of error, 1 if OK. */ |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 42 | int init_stream(); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 43 | |
Willy Tarreau | e7dff02 | 2015-04-03 01:14:29 +0200 | [diff] [blame] | 44 | /* 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] | 45 | void stream_shutdown(struct stream *stream, int why); |
Simon Horman | dec5be4 | 2011-06-08 09:19:07 +0900 | [diff] [blame] | 46 | |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 47 | void stream_process_counters(struct stream *s); |
| 48 | void sess_change_server(struct stream *sess, struct server *newsrv); |
| 49 | struct task *process_stream(struct task *t); |
| 50 | void default_srv_error(struct stream *s, struct stream_interface *si); |
Willy Tarreau | 192252e | 2015-04-04 01:47:55 +0200 | [diff] [blame] | 51 | struct stkctr *smp_fetch_sc_stkctr(struct session *sess, struct stream *strm, const struct arg *args, const char *kw); |
Willy Tarreau | 9ba2dcc | 2010-06-14 21:04:55 +0200 | [diff] [blame] | 52 | int parse_track_counters(char **args, int *arg, |
| 53 | int section_type, struct proxy *curpx, |
| 54 | struct track_ctr_prm *prm, |
Willy Tarreau | 0a3dd74 | 2012-05-08 19:47:01 +0200 | [diff] [blame] | 55 | struct proxy *defpx, char **err); |
Willy Tarreau | 9ba2dcc | 2010-06-14 21:04:55 +0200 | [diff] [blame] | 56 | |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 57 | /* Update the stream's backend and server time stats */ |
| 58 | void stream_update_time_stats(struct stream *s); |
| 59 | void __stream_offer_buffers(int rqlimit); |
| 60 | static inline void stream_offer_buffers(); |
| 61 | int stream_alloc_work_buffer(struct stream *s); |
| 62 | void stream_release_buffers(struct stream *s); |
| 63 | int stream_alloc_recv_buffer(struct channel *chn); |
Willy Tarreau | 4bfc580 | 2014-06-17 12:19:18 +0200 | [diff] [blame] | 64 | |
Willy Tarreau | b1ec8c4 | 2015-04-03 13:53:24 +0200 | [diff] [blame] | 65 | /* returns the session this stream belongs to */ |
| 66 | static inline struct session *strm_sess(const struct stream *strm) |
| 67 | { |
| 68 | return strm->sess; |
| 69 | } |
| 70 | |
Willy Tarreau | d0d8da9 | 2015-04-04 02:10:38 +0200 | [diff] [blame] | 71 | /* returns the frontend this stream was initiated from */ |
| 72 | static inline struct proxy *strm_fe(const struct stream *strm) |
| 73 | { |
| 74 | return strm->sess->fe; |
| 75 | } |
| 76 | |
| 77 | /* returns the listener this stream was initiated from */ |
| 78 | static inline struct listener *strm_li(const struct stream *strm) |
| 79 | { |
| 80 | return strm->sess->listener; |
| 81 | } |
| 82 | |
| 83 | /* returns a pointer to the origin of the session which created this stream */ |
| 84 | static inline enum obj_type *strm_orig(const struct stream *strm) |
| 85 | { |
| 86 | return strm->sess->origin; |
| 87 | } |
| 88 | |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 89 | /* sets the stick counter's entry pointer */ |
| 90 | static inline void stkctr_set_entry(struct stkctr *stkctr, struct stksess *entry) |
| 91 | { |
| 92 | stkctr->entry = caddr_from_ptr(entry, 0); |
| 93 | } |
| 94 | |
| 95 | /* returns the entry pointer from a stick counter */ |
| 96 | static inline struct stksess *stkctr_entry(struct stkctr *stkctr) |
| 97 | { |
| 98 | return caddr_to_ptr(stkctr->entry); |
| 99 | } |
| 100 | |
| 101 | /* returns the two flags from a stick counter */ |
| 102 | static inline unsigned int stkctr_flags(struct stkctr *stkctr) |
| 103 | { |
| 104 | return caddr_to_data(stkctr->entry); |
| 105 | } |
| 106 | |
| 107 | /* sets up to two flags at a time on a composite address */ |
| 108 | static inline void stkctr_set_flags(struct stkctr *stkctr, unsigned int flags) |
| 109 | { |
| 110 | stkctr->entry = caddr_set_flags(stkctr->entry, flags); |
| 111 | } |
| 112 | |
| 113 | /* returns the two flags from a stick counter */ |
| 114 | static inline void stkctr_clr_flags(struct stkctr *stkctr, unsigned int flags) |
| 115 | { |
| 116 | stkctr->entry = caddr_clr_flags(stkctr->entry, flags); |
| 117 | } |
| 118 | |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 119 | /* 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] | 120 | * pointer to ensure this is only performed once. The caller is responsible for |
| 121 | * ensuring that the pointer is valid first. |
| 122 | */ |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 123 | static inline void stream_store_counters(struct stream *s) |
Willy Tarreau | 9ba2dcc | 2010-06-14 21:04:55 +0200 | [diff] [blame] | 124 | { |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 125 | void *ptr; |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 126 | int i; |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 127 | |
Willy Tarreau | b4c8493 | 2013-07-23 19:15:30 +0200 | [diff] [blame] | 128 | for (i = 0; i < MAX_SESS_STKCTR; i++) { |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 129 | if (!stkctr_entry(&s->stkctr[i])) |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 130 | continue; |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 131 | ptr = stktable_data_ptr(s->stkctr[i].table, stkctr_entry(&s->stkctr[i]), STKTABLE_DT_CONN_CUR); |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 132 | if (ptr) |
| 133 | stktable_data_cast(ptr, conn_cur)--; |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 134 | stkctr_entry(&s->stkctr[i])->ref_cnt--; |
| 135 | stksess_kill_if_expired(s->stkctr[i].table, stkctr_entry(&s->stkctr[i])); |
| 136 | stkctr_set_entry(&s->stkctr[i], NULL); |
Willy Tarreau | 38285c1 | 2010-06-18 16:35:43 +0200 | [diff] [blame] | 137 | } |
Willy Tarreau | 9ba2dcc | 2010-06-14 21:04:55 +0200 | [diff] [blame] | 138 | } |
| 139 | |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 140 | /* 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] | 141 | * any, and clear the pointer to ensure this is only performed once. The caller |
| 142 | * is responsible for ensuring that the pointer is valid first. |
Willy Tarreau | 9ba2dcc | 2010-06-14 21:04:55 +0200 | [diff] [blame] | 143 | */ |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 144 | static inline void stream_stop_content_counters(struct stream *s) |
Willy Tarreau | 9ba2dcc | 2010-06-14 21:04:55 +0200 | [diff] [blame] | 145 | { |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 146 | void *ptr; |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 147 | int i; |
Willy Tarreau | e348793 | 2010-06-18 21:03:20 +0200 | [diff] [blame] | 148 | |
Willy Tarreau | b4c8493 | 2013-07-23 19:15:30 +0200 | [diff] [blame] | 149 | for (i = 0; i < MAX_SESS_STKCTR; i++) { |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 150 | if (!stkctr_entry(&s->stkctr[i])) |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 151 | continue; |
Willy Tarreau | 0a4838c | 2010-08-06 20:11:05 +0200 | [diff] [blame] | 152 | |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 153 | if (!(stkctr_flags(&s->stkctr[i]) & STKCTR_TRACK_CONTENT)) |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 154 | continue; |
| 155 | |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 156 | ptr = stktable_data_ptr(s->stkctr[i].table, stkctr_entry(&s->stkctr[i]), STKTABLE_DT_CONN_CUR); |
Willy Tarreau | 0a4838c | 2010-08-06 20:11:05 +0200 | [diff] [blame] | 157 | if (ptr) |
| 158 | stktable_data_cast(ptr, conn_cur)--; |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 159 | stkctr_entry(&s->stkctr[i])->ref_cnt--; |
| 160 | stksess_kill_if_expired(s->stkctr[i].table, stkctr_entry(&s->stkctr[i])); |
| 161 | stkctr_set_entry(&s->stkctr[i], NULL); |
Willy Tarreau | 0a4838c | 2010-08-06 20:11:05 +0200 | [diff] [blame] | 162 | } |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 163 | } |
Willy Tarreau | e348793 | 2010-06-18 21:03:20 +0200 | [diff] [blame] | 164 | |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 165 | /* Increase total and concurrent connection count for stick entry <ts> of table |
| 166 | * <t>. The caller is responsible for ensuring that <t> and <ts> are valid |
| 167 | * pointers, and for calling this only once per connection. |
| 168 | */ |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 169 | static inline void stream_start_counters(struct stktable *t, struct stksess *ts) |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 170 | { |
| 171 | void *ptr; |
Willy Tarreau | 91c43d7 | 2010-06-20 11:19:22 +0200 | [diff] [blame] | 172 | |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 173 | ptr = stktable_data_ptr(t, ts, STKTABLE_DT_CONN_CUR); |
| 174 | if (ptr) |
| 175 | stktable_data_cast(ptr, conn_cur)++; |
| 176 | |
| 177 | ptr = stktable_data_ptr(t, ts, STKTABLE_DT_CONN_CNT); |
| 178 | if (ptr) |
| 179 | stktable_data_cast(ptr, conn_cnt)++; |
| 180 | |
| 181 | ptr = stktable_data_ptr(t, ts, STKTABLE_DT_CONN_RATE); |
| 182 | if (ptr) |
| 183 | update_freq_ctr_period(&stktable_data_cast(ptr, conn_rate), |
| 184 | t->data_arg[STKTABLE_DT_CONN_RATE].u, 1); |
| 185 | if (tick_isset(t->expire)) |
| 186 | ts->expire = tick_add(now_ms, MS_TO_TICKS(t->expire)); |
| 187 | } |
| 188 | |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 189 | /* 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] | 190 | * responsible for ensuring that <t> and <ts> are valid pointers. Some controls |
| 191 | * are performed to ensure the state can still change. |
| 192 | */ |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 193 | 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] | 194 | { |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 195 | if (stkctr_entry(ctr)) |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 196 | return; |
| 197 | |
| 198 | ts->ref_cnt++; |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 199 | ctr->table = t; |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 200 | stkctr_set_entry(ctr, ts); |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 201 | stream_start_counters(t, ts); |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 202 | } |
| 203 | |
Willy Tarreau | da7ff64 | 2010-06-23 11:44:09 +0200 | [diff] [blame] | 204 | /* Increase the number of cumulated HTTP requests in the tracked counters */ |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 205 | static void inline stream_inc_http_req_ctr(struct stream *s) |
Willy Tarreau | da7ff64 | 2010-06-23 11:44:09 +0200 | [diff] [blame] | 206 | { |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 207 | void *ptr; |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 208 | int i; |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 209 | |
Willy Tarreau | b4c8493 | 2013-07-23 19:15:30 +0200 | [diff] [blame] | 210 | for (i = 0; i < MAX_SESS_STKCTR; i++) { |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 211 | if (!stkctr_entry(&s->stkctr[i])) |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 212 | continue; |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 213 | |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 214 | ptr = stktable_data_ptr(s->stkctr[i].table, stkctr_entry(&s->stkctr[i]), STKTABLE_DT_HTTP_REQ_CNT); |
Willy Tarreau | da7ff64 | 2010-06-23 11:44:09 +0200 | [diff] [blame] | 215 | if (ptr) |
| 216 | stktable_data_cast(ptr, http_req_cnt)++; |
| 217 | |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 218 | ptr = stktable_data_ptr(s->stkctr[i].table, stkctr_entry(&s->stkctr[i]), STKTABLE_DT_HTTP_REQ_RATE); |
Willy Tarreau | da7ff64 | 2010-06-23 11:44:09 +0200 | [diff] [blame] | 219 | if (ptr) |
| 220 | update_freq_ctr_period(&stktable_data_cast(ptr, http_req_rate), |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 221 | s->stkctr[i].table->data_arg[STKTABLE_DT_HTTP_REQ_RATE].u, 1); |
Willy Tarreau | da7ff64 | 2010-06-23 11:44:09 +0200 | [diff] [blame] | 222 | } |
| 223 | } |
| 224 | |
Willy Tarreau | 5d5b5d8 | 2012-12-09 12:00:04 +0100 | [diff] [blame] | 225 | /* Increase the number of cumulated HTTP requests in the backend's tracked counters */ |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 226 | static void inline stream_inc_be_http_req_ctr(struct stream *s) |
Willy Tarreau | 5d5b5d8 | 2012-12-09 12:00:04 +0100 | [diff] [blame] | 227 | { |
| 228 | void *ptr; |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 229 | int i; |
Willy Tarreau | 5d5b5d8 | 2012-12-09 12:00:04 +0100 | [diff] [blame] | 230 | |
Willy Tarreau | b4c8493 | 2013-07-23 19:15:30 +0200 | [diff] [blame] | 231 | for (i = 0; i < MAX_SESS_STKCTR; i++) { |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 232 | if (!stkctr_entry(&s->stkctr[i])) |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 233 | continue; |
Willy Tarreau | 5d5b5d8 | 2012-12-09 12:00:04 +0100 | [diff] [blame] | 234 | |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 235 | if (!(stkctr_flags(&s->stkctr[i]) & STKCTR_TRACK_BACKEND)) |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 236 | continue; |
| 237 | |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 238 | ptr = stktable_data_ptr(s->stkctr[i].table, stkctr_entry(&s->stkctr[i]), STKTABLE_DT_HTTP_REQ_CNT); |
Willy Tarreau | 5d5b5d8 | 2012-12-09 12:00:04 +0100 | [diff] [blame] | 239 | if (ptr) |
| 240 | stktable_data_cast(ptr, http_req_cnt)++; |
| 241 | |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 242 | ptr = stktable_data_ptr(s->stkctr[i].table, stkctr_entry(&s->stkctr[i]), STKTABLE_DT_HTTP_REQ_RATE); |
Willy Tarreau | 5d5b5d8 | 2012-12-09 12:00:04 +0100 | [diff] [blame] | 243 | if (ptr) |
| 244 | update_freq_ctr_period(&stktable_data_cast(ptr, http_req_rate), |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 245 | s->stkctr[i].table->data_arg[STKTABLE_DT_HTTP_REQ_RATE].u, 1); |
Willy Tarreau | 5d5b5d8 | 2012-12-09 12:00:04 +0100 | [diff] [blame] | 246 | } |
| 247 | } |
| 248 | |
Willy Tarreau | da7ff64 | 2010-06-23 11:44:09 +0200 | [diff] [blame] | 249 | /* Increase the number of cumulated failed HTTP requests in the tracked |
| 250 | * counters. Only 4xx requests should be counted here so that we can |
| 251 | * distinguish between errors caused by client behaviour and other ones. |
| 252 | * Note that even 404 are interesting because they're generally caused by |
| 253 | * vulnerability scans. |
| 254 | */ |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 255 | static void inline stream_inc_http_err_ctr(struct stream *s) |
Willy Tarreau | da7ff64 | 2010-06-23 11:44:09 +0200 | [diff] [blame] | 256 | { |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 257 | void *ptr; |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 258 | int i; |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 259 | |
Willy Tarreau | b4c8493 | 2013-07-23 19:15:30 +0200 | [diff] [blame] | 260 | for (i = 0; i < MAX_SESS_STKCTR; i++) { |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 261 | if (!stkctr_entry(&s->stkctr[i])) |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 262 | continue; |
Willy Tarreau | f059a0f | 2010-08-03 16:29:52 +0200 | [diff] [blame] | 263 | |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 264 | ptr = stktable_data_ptr(s->stkctr[i].table, stkctr_entry(&s->stkctr[i]), STKTABLE_DT_HTTP_ERR_CNT); |
Willy Tarreau | da7ff64 | 2010-06-23 11:44:09 +0200 | [diff] [blame] | 265 | if (ptr) |
| 266 | stktable_data_cast(ptr, http_err_cnt)++; |
| 267 | |
Willy Tarreau | cc08d2c | 2014-01-28 23:18:23 +0100 | [diff] [blame] | 268 | ptr = stktable_data_ptr(s->stkctr[i].table, stkctr_entry(&s->stkctr[i]), STKTABLE_DT_HTTP_ERR_RATE); |
Willy Tarreau | da7ff64 | 2010-06-23 11:44:09 +0200 | [diff] [blame] | 269 | if (ptr) |
| 270 | update_freq_ctr_period(&stktable_data_cast(ptr, http_err_rate), |
Willy Tarreau | 20d46a5 | 2012-12-09 15:55:40 +0100 | [diff] [blame] | 271 | s->stkctr[i].table->data_arg[STKTABLE_DT_HTTP_ERR_RATE].u, 1); |
Willy Tarreau | da7ff64 | 2010-06-23 11:44:09 +0200 | [diff] [blame] | 272 | } |
| 273 | } |
| 274 | |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 275 | static void inline stream_add_srv_conn(struct stream *sess, struct server *srv) |
Simon Horman | af51495 | 2011-06-21 14:34:57 +0900 | [diff] [blame] | 276 | { |
| 277 | sess->srv_conn = srv; |
| 278 | LIST_ADD(&srv->actconns, &sess->by_srv); |
| 279 | } |
| 280 | |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 281 | static void inline stream_del_srv_conn(struct stream *sess) |
Simon Horman | af51495 | 2011-06-21 14:34:57 +0900 | [diff] [blame] | 282 | { |
| 283 | if (!sess->srv_conn) |
| 284 | return; |
| 285 | |
| 286 | sess->srv_conn = NULL; |
| 287 | LIST_DEL(&sess->by_srv); |
| 288 | } |
| 289 | |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 290 | static void inline stream_init_srv_conn(struct stream *sess) |
Willy Tarreau | 9bd0d74 | 2011-07-20 00:17:39 +0200 | [diff] [blame] | 291 | { |
| 292 | sess->srv_conn = NULL; |
| 293 | LIST_INIT(&sess->by_srv); |
| 294 | } |
| 295 | |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 296 | static inline void stream_offer_buffers() |
Willy Tarreau | a24adf0 | 2014-11-27 01:11:56 +0100 | [diff] [blame] | 297 | { |
| 298 | int avail; |
| 299 | |
| 300 | if (LIST_ISEMPTY(&buffer_wq)) |
| 301 | return; |
| 302 | |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 303 | /* all streams will need 1 buffer, so we can stop waking up streams |
Willy Tarreau | a24adf0 | 2014-11-27 01:11:56 +0100 | [diff] [blame] | 304 | * once we have enough of them to eat all the buffers. Note that we |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 305 | * don't really know if they are streams or just other tasks, but |
Willy Tarreau | a24adf0 | 2014-11-27 01:11:56 +0100 | [diff] [blame] | 306 | * that's a rough estimate. Similarly, for each cached event we'll need |
| 307 | * 1 buffer. If no buffer is currently used, always wake up the number |
| 308 | * of tasks we can offer a buffer based on what is allocated, and in |
| 309 | * any case at least one task per two reserved buffers. |
| 310 | */ |
| 311 | avail = pool2_buffer->allocated - pool2_buffer->used - global.tune.reserved_bufs / 2; |
| 312 | |
| 313 | if (avail > (int)run_queue) |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 314 | __stream_offer_buffers(avail); |
Willy Tarreau | a24adf0 | 2014-11-27 01:11:56 +0100 | [diff] [blame] | 315 | } |
| 316 | |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 317 | #endif /* _PROTO_STREAM_H */ |
Willy TARREAU | 3dc0644 | 2006-06-15 21:48:13 +0200 | [diff] [blame] | 318 | |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 319 | /* |
| 320 | * Local variables: |
| 321 | * c-indent-level: 8 |
| 322 | * c-basic-offset: 8 |
| 323 | * End: |
| 324 | */ |