blob: 1fea1ab1c4330c8d7c53c1a31aef18fc5fb69f0c [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 Tarreau73b65ac2015-04-08 18:26:29 +020039struct stream *stream_new(struct session *sess, struct task *t, enum obj_type *origin);
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
Willy Tarreaua68f7622015-09-21 17:48:24 +020091 * ensuring that the pointer is valid first. We must be extremely careful not
92 * to touch the entries we inherited from the session.
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +020093 */
Willy Tarreau87b09662015-04-03 00:22:06 +020094static inline void stream_store_counters(struct stream *s)
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +020095{
Willy Tarreauf059a0f2010-08-03 16:29:52 +020096 void *ptr;
Willy Tarreau20d46a52012-12-09 15:55:40 +010097 int i;
Willy Tarreauf059a0f2010-08-03 16:29:52 +020098
Willy Tarreaub4c84932013-07-23 19:15:30 +020099 for (i = 0; i < MAX_SESS_STKCTR; i++) {
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100100 if (!stkctr_entry(&s->stkctr[i]))
Willy Tarreau20d46a52012-12-09 15:55:40 +0100101 continue;
Willy Tarreaua68f7622015-09-21 17:48:24 +0200102
103 if (stkctr_entry(&s->sess->stkctr[i]))
104 continue;
105
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100106 ptr = stktable_data_ptr(s->stkctr[i].table, stkctr_entry(&s->stkctr[i]), STKTABLE_DT_CONN_CUR);
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200107 if (ptr)
108 stktable_data_cast(ptr, conn_cur)--;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100109 stkctr_entry(&s->stkctr[i])->ref_cnt--;
110 stksess_kill_if_expired(s->stkctr[i].table, stkctr_entry(&s->stkctr[i]));
111 stkctr_set_entry(&s->stkctr[i], NULL);
Willy Tarreau38285c12010-06-18 16:35:43 +0200112 }
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +0200113}
114
Willy Tarreau87b09662015-04-03 00:22:06 +0200115/* Remove the refcount from the stream counters tracked at the content level if
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200116 * any, and clear the pointer to ensure this is only performed once. The caller
Willy Tarreaua68f7622015-09-21 17:48:24 +0200117 * is responsible for ensuring that the pointer is valid first. We must be
118 * extremely careful not to touch the entries we inherited from the session.
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +0200119 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200120static inline void stream_stop_content_counters(struct stream *s)
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +0200121{
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200122 void *ptr;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100123 int i;
Willy Tarreaue3487932010-06-18 21:03:20 +0200124
Willy Tarreaub4c84932013-07-23 19:15:30 +0200125 for (i = 0; i < MAX_SESS_STKCTR; i++) {
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100126 if (!stkctr_entry(&s->stkctr[i]))
Willy Tarreau20d46a52012-12-09 15:55:40 +0100127 continue;
Willy Tarreau0a4838c2010-08-06 20:11:05 +0200128
Willy Tarreaua68f7622015-09-21 17:48:24 +0200129 if (stkctr_entry(&s->sess->stkctr[i]))
130 continue;
131
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100132 if (!(stkctr_flags(&s->stkctr[i]) & STKCTR_TRACK_CONTENT))
Willy Tarreau20d46a52012-12-09 15:55:40 +0100133 continue;
134
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100135 ptr = stktable_data_ptr(s->stkctr[i].table, stkctr_entry(&s->stkctr[i]), STKTABLE_DT_CONN_CUR);
Willy Tarreau0a4838c2010-08-06 20:11:05 +0200136 if (ptr)
137 stktable_data_cast(ptr, conn_cur)--;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100138 stkctr_entry(&s->stkctr[i])->ref_cnt--;
139 stksess_kill_if_expired(s->stkctr[i].table, stkctr_entry(&s->stkctr[i]));
140 stkctr_set_entry(&s->stkctr[i], NULL);
Willy Tarreau0a4838c2010-08-06 20:11:05 +0200141 }
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200142}
Willy Tarreaue3487932010-06-18 21:03:20 +0200143
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200144/* Increase total and concurrent connection count for stick entry <ts> of table
145 * <t>. The caller is responsible for ensuring that <t> and <ts> are valid
146 * pointers, and for calling this only once per connection.
147 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200148static inline void stream_start_counters(struct stktable *t, struct stksess *ts)
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200149{
150 void *ptr;
Willy Tarreau91c43d72010-06-20 11:19:22 +0200151
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200152 ptr = stktable_data_ptr(t, ts, STKTABLE_DT_CONN_CUR);
153 if (ptr)
154 stktable_data_cast(ptr, conn_cur)++;
155
156 ptr = stktable_data_ptr(t, ts, STKTABLE_DT_CONN_CNT);
157 if (ptr)
158 stktable_data_cast(ptr, conn_cnt)++;
159
160 ptr = stktable_data_ptr(t, ts, STKTABLE_DT_CONN_RATE);
161 if (ptr)
162 update_freq_ctr_period(&stktable_data_cast(ptr, conn_rate),
163 t->data_arg[STKTABLE_DT_CONN_RATE].u, 1);
164 if (tick_isset(t->expire))
165 ts->expire = tick_add(now_ms, MS_TO_TICKS(t->expire));
166}
167
Willy Tarreau87b09662015-04-03 00:22:06 +0200168/* Enable tracking of stream counters as <stkctr> on stksess <ts>. The caller is
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200169 * responsible for ensuring that <t> and <ts> are valid pointers. Some controls
170 * are performed to ensure the state can still change.
171 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200172static inline void stream_track_stkctr(struct stkctr *ctr, struct stktable *t, struct stksess *ts)
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200173{
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100174 if (stkctr_entry(ctr))
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200175 return;
176
177 ts->ref_cnt++;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100178 ctr->table = t;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100179 stkctr_set_entry(ctr, ts);
Willy Tarreau87b09662015-04-03 00:22:06 +0200180 stream_start_counters(t, ts);
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200181}
182
Willy Tarreauda7ff642010-06-23 11:44:09 +0200183/* Increase the number of cumulated HTTP requests in the tracked counters */
Willy Tarreau87b09662015-04-03 00:22:06 +0200184static void inline stream_inc_http_req_ctr(struct stream *s)
Willy Tarreauda7ff642010-06-23 11:44:09 +0200185{
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200186 void *ptr;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100187 int i;
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200188
Willy Tarreaub4c84932013-07-23 19:15:30 +0200189 for (i = 0; i < MAX_SESS_STKCTR; i++) {
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200190 struct stkctr *stkctr = &s->stkctr[i];
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200191
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200192 if (!stkctr_entry(stkctr)) {
193 stkctr = &s->sess->stkctr[i];
194 if (!stkctr_entry(stkctr))
195 continue;
196 }
197
198 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_REQ_CNT);
Willy Tarreauda7ff642010-06-23 11:44:09 +0200199 if (ptr)
200 stktable_data_cast(ptr, http_req_cnt)++;
201
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200202 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_REQ_RATE);
Willy Tarreauda7ff642010-06-23 11:44:09 +0200203 if (ptr)
204 update_freq_ctr_period(&stktable_data_cast(ptr, http_req_rate),
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200205 stkctr->table->data_arg[STKTABLE_DT_HTTP_REQ_RATE].u, 1);
Willy Tarreauda7ff642010-06-23 11:44:09 +0200206 }
207}
208
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200209/* Increase the number of cumulated HTTP requests in the backend's tracked
210 * counters. We don't look up the session since it cannot happen in the bakcend.
211 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200212static void inline stream_inc_be_http_req_ctr(struct stream *s)
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100213{
214 void *ptr;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100215 int i;
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100216
Willy Tarreaub4c84932013-07-23 19:15:30 +0200217 for (i = 0; i < MAX_SESS_STKCTR; i++) {
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200218 struct stkctr *stkctr = &s->stkctr[i];
219
220 if (!stkctr_entry(stkctr))
Willy Tarreau20d46a52012-12-09 15:55:40 +0100221 continue;
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100222
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100223 if (!(stkctr_flags(&s->stkctr[i]) & STKCTR_TRACK_BACKEND))
Willy Tarreau20d46a52012-12-09 15:55:40 +0100224 continue;
225
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200226 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_REQ_CNT);
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100227 if (ptr)
228 stktable_data_cast(ptr, http_req_cnt)++;
229
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200230 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_REQ_RATE);
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100231 if (ptr)
232 update_freq_ctr_period(&stktable_data_cast(ptr, http_req_rate),
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200233 stkctr->table->data_arg[STKTABLE_DT_HTTP_REQ_RATE].u, 1);
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100234 }
235}
236
Willy Tarreauda7ff642010-06-23 11:44:09 +0200237/* Increase the number of cumulated failed HTTP requests in the tracked
238 * counters. Only 4xx requests should be counted here so that we can
239 * distinguish between errors caused by client behaviour and other ones.
240 * Note that even 404 are interesting because they're generally caused by
241 * vulnerability scans.
242 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200243static void inline stream_inc_http_err_ctr(struct stream *s)
Willy Tarreauda7ff642010-06-23 11:44:09 +0200244{
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200245 void *ptr;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100246 int i;
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200247
Willy Tarreaub4c84932013-07-23 19:15:30 +0200248 for (i = 0; i < MAX_SESS_STKCTR; i++) {
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200249 struct stkctr *stkctr = &s->stkctr[i];
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200250
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200251 if (!stkctr_entry(stkctr)) {
252 stkctr = &s->sess->stkctr[i];
253 if (!stkctr_entry(stkctr))
254 continue;
255 }
256
257 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_ERR_CNT);
Willy Tarreauda7ff642010-06-23 11:44:09 +0200258 if (ptr)
259 stktable_data_cast(ptr, http_err_cnt)++;
260
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200261 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_ERR_RATE);
Willy Tarreauda7ff642010-06-23 11:44:09 +0200262 if (ptr)
263 update_freq_ctr_period(&stktable_data_cast(ptr, http_err_rate),
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200264 stkctr->table->data_arg[STKTABLE_DT_HTTP_ERR_RATE].u, 1);
Willy Tarreauda7ff642010-06-23 11:44:09 +0200265 }
266}
267
Willy Tarreau87b09662015-04-03 00:22:06 +0200268static void inline stream_add_srv_conn(struct stream *sess, struct server *srv)
Simon Hormanaf514952011-06-21 14:34:57 +0900269{
270 sess->srv_conn = srv;
271 LIST_ADD(&srv->actconns, &sess->by_srv);
272}
273
Willy Tarreau87b09662015-04-03 00:22:06 +0200274static void inline stream_del_srv_conn(struct stream *sess)
Simon Hormanaf514952011-06-21 14:34:57 +0900275{
276 if (!sess->srv_conn)
277 return;
278
279 sess->srv_conn = NULL;
280 LIST_DEL(&sess->by_srv);
281}
282
Willy Tarreau87b09662015-04-03 00:22:06 +0200283static void inline stream_init_srv_conn(struct stream *sess)
Willy Tarreau9bd0d742011-07-20 00:17:39 +0200284{
285 sess->srv_conn = NULL;
286 LIST_INIT(&sess->by_srv);
287}
288
Willy Tarreau87b09662015-04-03 00:22:06 +0200289static inline void stream_offer_buffers()
Willy Tarreaua24adf02014-11-27 01:11:56 +0100290{
291 int avail;
292
293 if (LIST_ISEMPTY(&buffer_wq))
294 return;
295
Willy Tarreau87b09662015-04-03 00:22:06 +0200296 /* all streams will need 1 buffer, so we can stop waking up streams
Willy Tarreaua24adf02014-11-27 01:11:56 +0100297 * once we have enough of them to eat all the buffers. Note that we
Willy Tarreau87b09662015-04-03 00:22:06 +0200298 * don't really know if they are streams or just other tasks, but
Willy Tarreaua24adf02014-11-27 01:11:56 +0100299 * that's a rough estimate. Similarly, for each cached event we'll need
300 * 1 buffer. If no buffer is currently used, always wake up the number
301 * of tasks we can offer a buffer based on what is allocated, and in
302 * any case at least one task per two reserved buffers.
303 */
304 avail = pool2_buffer->allocated - pool2_buffer->used - global.tune.reserved_bufs / 2;
305
306 if (avail > (int)run_queue)
Willy Tarreau87b09662015-04-03 00:22:06 +0200307 __stream_offer_buffers(avail);
Willy Tarreaua24adf02014-11-27 01:11:56 +0100308}
309
Willy Tarreau87b09662015-04-03 00:22:06 +0200310#endif /* _PROTO_STREAM_H */
Willy TARREAU3dc06442006-06-15 21:48:13 +0200311
Willy Tarreaubaaee002006-06-26 02:48:02 +0200312/*
313 * Local variables:
314 * c-indent-level: 8
315 * c-basic-offset: 8
316 * End:
317 */