blob: 02992fd51e9ffaaef9d466b2aa0fde3696485d44 [file] [log] [blame]
Willy TARREAU3dc06442006-06-15 21:48:13 +02001/*
Willy Tarreau87b09662015-04-03 00:22:06 +02002 * include/proto/stream.h
3 * This file defines everything related to streams.
Willy Tarreau81f9aa32010-06-01 17:45:26 +02004 *
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 TARREAU3dc06442006-06-15 21:48:13 +020021
Willy Tarreau87b09662015-04-03 00:22:06 +020022#ifndef _PROTO_STREAM_H
23#define _PROTO_STREAM_H
Willy Tarreaubaaee002006-06-26 02:48:02 +020024
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020025#include <common/config.h>
Willy Tarreauc6ca1a02007-05-13 19:43:47 +020026#include <common/memory.h>
Willy Tarreau87b09662015-04-03 00:22:06 +020027#include <types/stream.h>
Willy Tarreaua24adf02014-11-27 01:11:56 +010028#include <proto/fd.h>
Willy Tarreau91c43d72010-06-20 11:19:22 +020029#include <proto/freq_ctr.h>
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +020030#include <proto/stick_table.h>
Willy Tarreaua24adf02014-11-27 01:11:56 +010031#include <proto/task.h>
Willy TARREAU3dc06442006-06-15 21:48:13 +020032
Willy Tarreau87b09662015-04-03 00:22:06 +020033extern struct pool_head *pool2_stream;
34extern struct list streams;
Willy Tarreaubf883e02014-11-25 21:10:35 +010035extern struct list buffer_wq;
Willy Tarreauc6ca1a02007-05-13 19:43:47 +020036
Willy Tarreaubc174aa2012-11-19 16:10:32 +010037extern struct data_cb sess_conn_cb;
38
Willy Tarreau9903f0e2015-04-04 18:50:31 +020039int stream_accept_session(struct session *sess, struct task *t);
Willy Tarreaubaaee002006-06-26 02:48:02 +020040
Willy Tarreauc6ca1a02007-05-13 19:43:47 +020041/* perform minimal intializations, report 0 in case of error, 1 if OK. */
Willy Tarreau87b09662015-04-03 00:22:06 +020042int init_stream();
Willy Tarreaubaaee002006-06-26 02:48:02 +020043
Willy Tarreaue7dff022015-04-03 01:14:29 +020044/* kill a stream and set the termination flags to <why> (one of SF_ERR_*) */
Willy Tarreau87b09662015-04-03 00:22:06 +020045void stream_shutdown(struct stream *stream, int why);
Simon Hormandec5be42011-06-08 09:19:07 +090046
Willy Tarreau87b09662015-04-03 00:22:06 +020047void stream_process_counters(struct stream *s);
48void sess_change_server(struct stream *sess, struct server *newsrv);
49struct task *process_stream(struct task *t);
50void default_srv_error(struct stream *s, struct stream_interface *si);
Willy Tarreau192252e2015-04-04 01:47:55 +020051struct stkctr *smp_fetch_sc_stkctr(struct session *sess, struct stream *strm, const struct arg *args, const char *kw);
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +020052int parse_track_counters(char **args, int *arg,
53 int section_type, struct proxy *curpx,
54 struct track_ctr_prm *prm,
Willy Tarreau0a3dd742012-05-08 19:47:01 +020055 struct proxy *defpx, char **err);
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +020056
Willy Tarreau87b09662015-04-03 00:22:06 +020057/* Update the stream's backend and server time stats */
58void stream_update_time_stats(struct stream *s);
59void __stream_offer_buffers(int rqlimit);
60static inline void stream_offer_buffers();
61int stream_alloc_work_buffer(struct stream *s);
62void stream_release_buffers(struct stream *s);
63int stream_alloc_recv_buffer(struct channel *chn);
Willy Tarreau4bfc5802014-06-17 12:19:18 +020064
Willy Tarreaub1ec8c42015-04-03 13:53:24 +020065/* returns the session this stream belongs to */
66static inline struct session *strm_sess(const struct stream *strm)
67{
68 return strm->sess;
69}
70
Willy Tarreaud0d8da92015-04-04 02:10:38 +020071/* returns the frontend this stream was initiated from */
72static 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 */
78static 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 */
84static inline enum obj_type *strm_orig(const struct stream *strm)
85{
86 return strm->sess->origin;
87}
88
Willy Tarreau87b09662015-04-03 00:22:06 +020089/* Remove the refcount from the stream to the tracked counters, and clear the
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +020090 * pointer to ensure this is only performed once. The caller is responsible for
91 * ensuring that the pointer is valid first.
92 */
Willy Tarreau87b09662015-04-03 00:22:06 +020093static inline void stream_store_counters(struct stream *s)
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +020094{
Willy Tarreauf059a0f2010-08-03 16:29:52 +020095 void *ptr;
Willy Tarreau20d46a52012-12-09 15:55:40 +010096 int i;
Willy Tarreauf059a0f2010-08-03 16:29:52 +020097
Willy Tarreaub4c84932013-07-23 19:15:30 +020098 for (i = 0; i < MAX_SESS_STKCTR; i++) {
Willy Tarreaucc08d2c2014-01-28 23:18:23 +010099 if (!stkctr_entry(&s->stkctr[i]))
Willy Tarreau20d46a52012-12-09 15:55:40 +0100100 continue;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100101 ptr = stktable_data_ptr(s->stkctr[i].table, stkctr_entry(&s->stkctr[i]), STKTABLE_DT_CONN_CUR);
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200102 if (ptr)
103 stktable_data_cast(ptr, conn_cur)--;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100104 stkctr_entry(&s->stkctr[i])->ref_cnt--;
105 stksess_kill_if_expired(s->stkctr[i].table, stkctr_entry(&s->stkctr[i]));
106 stkctr_set_entry(&s->stkctr[i], NULL);
Willy Tarreau38285c12010-06-18 16:35:43 +0200107 }
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +0200108}
109
Willy Tarreau87b09662015-04-03 00:22:06 +0200110/* Remove the refcount from the stream counters tracked at the content level if
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200111 * any, and clear the pointer to ensure this is only performed once. The caller
112 * is responsible for ensuring that the pointer is valid first.
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +0200113 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200114static inline void stream_stop_content_counters(struct stream *s)
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +0200115{
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200116 void *ptr;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100117 int i;
Willy Tarreaue3487932010-06-18 21:03:20 +0200118
Willy Tarreaub4c84932013-07-23 19:15:30 +0200119 for (i = 0; i < MAX_SESS_STKCTR; i++) {
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100120 if (!stkctr_entry(&s->stkctr[i]))
Willy Tarreau20d46a52012-12-09 15:55:40 +0100121 continue;
Willy Tarreau0a4838c2010-08-06 20:11:05 +0200122
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100123 if (!(stkctr_flags(&s->stkctr[i]) & STKCTR_TRACK_CONTENT))
Willy Tarreau20d46a52012-12-09 15:55:40 +0100124 continue;
125
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100126 ptr = stktable_data_ptr(s->stkctr[i].table, stkctr_entry(&s->stkctr[i]), STKTABLE_DT_CONN_CUR);
Willy Tarreau0a4838c2010-08-06 20:11:05 +0200127 if (ptr)
128 stktable_data_cast(ptr, conn_cur)--;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100129 stkctr_entry(&s->stkctr[i])->ref_cnt--;
130 stksess_kill_if_expired(s->stkctr[i].table, stkctr_entry(&s->stkctr[i]));
131 stkctr_set_entry(&s->stkctr[i], NULL);
Willy Tarreau0a4838c2010-08-06 20:11:05 +0200132 }
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200133}
Willy Tarreaue3487932010-06-18 21:03:20 +0200134
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200135/* Increase total and concurrent connection count for stick entry <ts> of table
136 * <t>. The caller is responsible for ensuring that <t> and <ts> are valid
137 * pointers, and for calling this only once per connection.
138 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200139static inline void stream_start_counters(struct stktable *t, struct stksess *ts)
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200140{
141 void *ptr;
Willy Tarreau91c43d72010-06-20 11:19:22 +0200142
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200143 ptr = stktable_data_ptr(t, ts, STKTABLE_DT_CONN_CUR);
144 if (ptr)
145 stktable_data_cast(ptr, conn_cur)++;
146
147 ptr = stktable_data_ptr(t, ts, STKTABLE_DT_CONN_CNT);
148 if (ptr)
149 stktable_data_cast(ptr, conn_cnt)++;
150
151 ptr = stktable_data_ptr(t, ts, STKTABLE_DT_CONN_RATE);
152 if (ptr)
153 update_freq_ctr_period(&stktable_data_cast(ptr, conn_rate),
154 t->data_arg[STKTABLE_DT_CONN_RATE].u, 1);
155 if (tick_isset(t->expire))
156 ts->expire = tick_add(now_ms, MS_TO_TICKS(t->expire));
157}
158
Willy Tarreau87b09662015-04-03 00:22:06 +0200159/* Enable tracking of stream counters as <stkctr> on stksess <ts>. The caller is
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200160 * responsible for ensuring that <t> and <ts> are valid pointers. Some controls
161 * are performed to ensure the state can still change.
162 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200163static inline void stream_track_stkctr(struct stkctr *ctr, struct stktable *t, struct stksess *ts)
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200164{
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100165 if (stkctr_entry(ctr))
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200166 return;
167
168 ts->ref_cnt++;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100169 ctr->table = t;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100170 stkctr_set_entry(ctr, ts);
Willy Tarreau87b09662015-04-03 00:22:06 +0200171 stream_start_counters(t, ts);
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200172}
173
Willy Tarreauda7ff642010-06-23 11:44:09 +0200174/* Increase the number of cumulated HTTP requests in the tracked counters */
Willy Tarreau87b09662015-04-03 00:22:06 +0200175static void inline stream_inc_http_req_ctr(struct stream *s)
Willy Tarreauda7ff642010-06-23 11:44:09 +0200176{
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200177 void *ptr;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100178 int i;
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200179
Willy Tarreaub4c84932013-07-23 19:15:30 +0200180 for (i = 0; i < MAX_SESS_STKCTR; i++) {
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200181 struct stkctr *stkctr = &s->stkctr[i];
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200182
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200183 if (!stkctr_entry(stkctr)) {
184 stkctr = &s->sess->stkctr[i];
185 if (!stkctr_entry(stkctr))
186 continue;
187 }
188
189 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_REQ_CNT);
Willy Tarreauda7ff642010-06-23 11:44:09 +0200190 if (ptr)
191 stktable_data_cast(ptr, http_req_cnt)++;
192
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200193 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_REQ_RATE);
Willy Tarreauda7ff642010-06-23 11:44:09 +0200194 if (ptr)
195 update_freq_ctr_period(&stktable_data_cast(ptr, http_req_rate),
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200196 stkctr->table->data_arg[STKTABLE_DT_HTTP_REQ_RATE].u, 1);
Willy Tarreauda7ff642010-06-23 11:44:09 +0200197 }
198}
199
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200200/* Increase the number of cumulated HTTP requests in the backend's tracked
201 * counters. We don't look up the session since it cannot happen in the bakcend.
202 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200203static void inline stream_inc_be_http_req_ctr(struct stream *s)
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100204{
205 void *ptr;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100206 int i;
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100207
Willy Tarreaub4c84932013-07-23 19:15:30 +0200208 for (i = 0; i < MAX_SESS_STKCTR; i++) {
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200209 struct stkctr *stkctr = &s->stkctr[i];
210
211 if (!stkctr_entry(stkctr))
Willy Tarreau20d46a52012-12-09 15:55:40 +0100212 continue;
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100213
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100214 if (!(stkctr_flags(&s->stkctr[i]) & STKCTR_TRACK_BACKEND))
Willy Tarreau20d46a52012-12-09 15:55:40 +0100215 continue;
216
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200217 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_REQ_CNT);
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100218 if (ptr)
219 stktable_data_cast(ptr, http_req_cnt)++;
220
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200221 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_REQ_RATE);
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100222 if (ptr)
223 update_freq_ctr_period(&stktable_data_cast(ptr, http_req_rate),
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200224 stkctr->table->data_arg[STKTABLE_DT_HTTP_REQ_RATE].u, 1);
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100225 }
226}
227
Willy Tarreauda7ff642010-06-23 11:44:09 +0200228/* Increase the number of cumulated failed HTTP requests in the tracked
229 * counters. Only 4xx requests should be counted here so that we can
230 * distinguish between errors caused by client behaviour and other ones.
231 * Note that even 404 are interesting because they're generally caused by
232 * vulnerability scans.
233 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200234static void inline stream_inc_http_err_ctr(struct stream *s)
Willy Tarreauda7ff642010-06-23 11:44:09 +0200235{
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200236 void *ptr;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100237 int i;
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200238
Willy Tarreaub4c84932013-07-23 19:15:30 +0200239 for (i = 0; i < MAX_SESS_STKCTR; i++) {
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200240 struct stkctr *stkctr = &s->stkctr[i];
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200241
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200242 if (!stkctr_entry(stkctr)) {
243 stkctr = &s->sess->stkctr[i];
244 if (!stkctr_entry(stkctr))
245 continue;
246 }
247
248 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_ERR_CNT);
Willy Tarreauda7ff642010-06-23 11:44:09 +0200249 if (ptr)
250 stktable_data_cast(ptr, http_err_cnt)++;
251
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200252 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_ERR_RATE);
Willy Tarreauda7ff642010-06-23 11:44:09 +0200253 if (ptr)
254 update_freq_ctr_period(&stktable_data_cast(ptr, http_err_rate),
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200255 stkctr->table->data_arg[STKTABLE_DT_HTTP_ERR_RATE].u, 1);
Willy Tarreauda7ff642010-06-23 11:44:09 +0200256 }
257}
258
Willy Tarreau87b09662015-04-03 00:22:06 +0200259static void inline stream_add_srv_conn(struct stream *sess, struct server *srv)
Simon Hormanaf514952011-06-21 14:34:57 +0900260{
261 sess->srv_conn = srv;
262 LIST_ADD(&srv->actconns, &sess->by_srv);
263}
264
Willy Tarreau87b09662015-04-03 00:22:06 +0200265static void inline stream_del_srv_conn(struct stream *sess)
Simon Hormanaf514952011-06-21 14:34:57 +0900266{
267 if (!sess->srv_conn)
268 return;
269
270 sess->srv_conn = NULL;
271 LIST_DEL(&sess->by_srv);
272}
273
Willy Tarreau87b09662015-04-03 00:22:06 +0200274static void inline stream_init_srv_conn(struct stream *sess)
Willy Tarreau9bd0d742011-07-20 00:17:39 +0200275{
276 sess->srv_conn = NULL;
277 LIST_INIT(&sess->by_srv);
278}
279
Willy Tarreau87b09662015-04-03 00:22:06 +0200280static inline void stream_offer_buffers()
Willy Tarreaua24adf02014-11-27 01:11:56 +0100281{
282 int avail;
283
284 if (LIST_ISEMPTY(&buffer_wq))
285 return;
286
Willy Tarreau87b09662015-04-03 00:22:06 +0200287 /* all streams will need 1 buffer, so we can stop waking up streams
Willy Tarreaua24adf02014-11-27 01:11:56 +0100288 * once we have enough of them to eat all the buffers. Note that we
Willy Tarreau87b09662015-04-03 00:22:06 +0200289 * don't really know if they are streams or just other tasks, but
Willy Tarreaua24adf02014-11-27 01:11:56 +0100290 * that's a rough estimate. Similarly, for each cached event we'll need
291 * 1 buffer. If no buffer is currently used, always wake up the number
292 * of tasks we can offer a buffer based on what is allocated, and in
293 * any case at least one task per two reserved buffers.
294 */
295 avail = pool2_buffer->allocated - pool2_buffer->used - global.tune.reserved_bufs / 2;
296
297 if (avail > (int)run_queue)
Willy Tarreau87b09662015-04-03 00:22:06 +0200298 __stream_offer_buffers(avail);
Willy Tarreaua24adf02014-11-27 01:11:56 +0100299}
300
Willy Tarreau87b09662015-04-03 00:22:06 +0200301#endif /* _PROTO_STREAM_H */
Willy TARREAU3dc06442006-06-15 21:48:13 +0200302
Willy Tarreaubaaee002006-06-26 02:48:02 +0200303/*
304 * Local variables:
305 * c-indent-level: 8
306 * c-basic-offset: 8
307 * End:
308 */