blob: d99079ff90ca56cdbb0433716bbfcadf290e2df3 [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 Tarreau61c112a2018-10-02 16:43:32 +020027#include <types/action.h>
Willy Tarreau87b09662015-04-03 00:22:06 +020028#include <types/stream.h>
Willy Tarreaua24adf02014-11-27 01:11:56 +010029#include <proto/fd.h>
Willy Tarreau91c43d72010-06-20 11:19:22 +020030#include <proto/freq_ctr.h>
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +020031#include <proto/stick_table.h>
Willy Tarreaua24adf02014-11-27 01:11:56 +010032#include <proto/task.h>
Willy TARREAU3dc06442006-06-15 21:48:13 +020033
Willy Tarreaubafbe012017-11-24 17:34:44 +010034extern struct pool_head *pool_head_stream;
Willy Tarreau87b09662015-04-03 00:22:06 +020035extern struct list streams;
Willy Tarreauc6ca1a02007-05-13 19:43:47 +020036
Willy Tarreaubc174aa2012-11-19 16:10:32 +010037extern struct data_cb sess_conn_cb;
38
Willy Tarreau87787ac2017-08-28 16:22:54 +020039struct stream *stream_new(struct session *sess, enum obj_type *origin);
Olivier Houchard9aaf7782017-09-13 18:30:23 +020040int stream_create_from_cs(struct conn_stream *cs);
Willy Tarreaubaaee002006-06-26 02:48:02 +020041
Willy Tarreaue7dff022015-04-03 01:14:29 +020042/* kill a stream and set the termination flags to <why> (one of SF_ERR_*) */
Willy Tarreau87b09662015-04-03 00:22:06 +020043void stream_shutdown(struct stream *stream, int why);
Simon Hormandec5be42011-06-08 09:19:07 +090044
Willy Tarreau87b09662015-04-03 00:22:06 +020045void stream_process_counters(struct stream *s);
46void sess_change_server(struct stream *sess, struct server *newsrv);
Olivier Houchard9f6af332018-05-25 14:04:04 +020047struct task *process_stream(struct task *t, void *context, unsigned short state);
Willy Tarreau87b09662015-04-03 00:22:06 +020048void default_srv_error(struct stream *s, struct stream_interface *si);
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +020049int parse_track_counters(char **args, int *arg,
50 int section_type, struct proxy *curpx,
51 struct track_ctr_prm *prm,
Willy Tarreau0a3dd742012-05-08 19:47:01 +020052 struct proxy *defpx, char **err);
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +020053
Willy Tarreau87b09662015-04-03 00:22:06 +020054/* Update the stream's backend and server time stats */
55void stream_update_time_stats(struct stream *s);
Willy Tarreau87b09662015-04-03 00:22:06 +020056void stream_release_buffers(struct stream *s);
Willy Tarreaub882dd82018-11-06 15:50:21 +010057int stream_buf_available(void *arg);
Willy Tarreau4bfc5802014-06-17 12:19:18 +020058
Willy Tarreaub1ec8c42015-04-03 13:53:24 +020059/* returns the session this stream belongs to */
60static inline struct session *strm_sess(const struct stream *strm)
61{
62 return strm->sess;
63}
64
Willy Tarreaud0d8da92015-04-04 02:10:38 +020065/* returns the frontend this stream was initiated from */
66static inline struct proxy *strm_fe(const struct stream *strm)
67{
68 return strm->sess->fe;
69}
70
71/* returns the listener this stream was initiated from */
72static inline struct listener *strm_li(const struct stream *strm)
73{
74 return strm->sess->listener;
75}
76
77/* returns a pointer to the origin of the session which created this stream */
78static inline enum obj_type *strm_orig(const struct stream *strm)
79{
80 return strm->sess->origin;
81}
82
Willy Tarreau87b09662015-04-03 00:22:06 +020083/* Remove the refcount from the stream to the tracked counters, and clear the
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +020084 * pointer to ensure this is only performed once. The caller is responsible for
Willy Tarreaua68f7622015-09-21 17:48:24 +020085 * ensuring that the pointer is valid first. We must be extremely careful not
86 * to touch the entries we inherited from the session.
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +020087 */
Willy Tarreau87b09662015-04-03 00:22:06 +020088static inline void stream_store_counters(struct stream *s)
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +020089{
Willy Tarreauf059a0f2010-08-03 16:29:52 +020090 void *ptr;
Willy Tarreau20d46a52012-12-09 15:55:40 +010091 int i;
Emeric Brun819fc6f2017-06-13 19:37:32 +020092 struct stksess *ts;
Willy Tarreauf059a0f2010-08-03 16:29:52 +020093
Willy Tarreaub4c84932013-07-23 19:15:30 +020094 for (i = 0; i < MAX_SESS_STKCTR; i++) {
Emeric Brun819fc6f2017-06-13 19:37:32 +020095 ts = stkctr_entry(&s->stkctr[i]);
96 if (!ts)
Willy Tarreau20d46a52012-12-09 15:55:40 +010097 continue;
Willy Tarreaua68f7622015-09-21 17:48:24 +020098
99 if (stkctr_entry(&s->sess->stkctr[i]))
100 continue;
101
Emeric Brun819fc6f2017-06-13 19:37:32 +0200102 ptr = stktable_data_ptr(s->stkctr[i].table, ts, STKTABLE_DT_CONN_CUR);
103 if (ptr) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100104 HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brun819fc6f2017-06-13 19:37:32 +0200105
Tim Duesterhus8b87c012019-01-04 00:11:59 +0100106 if (stktable_data_cast(ptr, conn_cur) > 0)
107 stktable_data_cast(ptr, conn_cur)--;
Emeric Brun819fc6f2017-06-13 19:37:32 +0200108
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100109 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brun0fed0b02017-11-29 16:15:07 +0100110
111 /* If data was modified, we need to touch to re-schedule sync */
112 stktable_touch_local(s->stkctr[i].table, ts, 0);
Emeric Brun819fc6f2017-06-13 19:37:32 +0200113 }
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100114 stkctr_set_entry(&s->stkctr[i], NULL);
Emeric Brun819fc6f2017-06-13 19:37:32 +0200115 stksess_kill_if_expired(s->stkctr[i].table, ts, 1);
Willy Tarreau38285c12010-06-18 16:35:43 +0200116 }
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +0200117}
118
Willy Tarreau87b09662015-04-03 00:22:06 +0200119/* Remove the refcount from the stream counters tracked at the content level if
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200120 * any, and clear the pointer to ensure this is only performed once. The caller
Willy Tarreaua68f7622015-09-21 17:48:24 +0200121 * is responsible for ensuring that the pointer is valid first. We must be
122 * extremely careful not to touch the entries we inherited from the session.
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +0200123 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200124static inline void stream_stop_content_counters(struct stream *s)
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +0200125{
Emeric Brun819fc6f2017-06-13 19:37:32 +0200126 struct stksess *ts;
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200127 void *ptr;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100128 int i;
Willy Tarreaue3487932010-06-18 21:03:20 +0200129
Willy Tarreaub4c84932013-07-23 19:15:30 +0200130 for (i = 0; i < MAX_SESS_STKCTR; i++) {
Emeric Brun819fc6f2017-06-13 19:37:32 +0200131 ts = stkctr_entry(&s->stkctr[i]);
132 if (!ts)
Willy Tarreau20d46a52012-12-09 15:55:40 +0100133 continue;
Willy Tarreau0a4838c2010-08-06 20:11:05 +0200134
Willy Tarreaua68f7622015-09-21 17:48:24 +0200135 if (stkctr_entry(&s->sess->stkctr[i]))
136 continue;
137
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100138 if (!(stkctr_flags(&s->stkctr[i]) & STKCTR_TRACK_CONTENT))
Willy Tarreau20d46a52012-12-09 15:55:40 +0100139 continue;
140
Emeric Brun819fc6f2017-06-13 19:37:32 +0200141 ptr = stktable_data_ptr(s->stkctr[i].table, ts, STKTABLE_DT_CONN_CUR);
142 if (ptr) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100143 HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brun819fc6f2017-06-13 19:37:32 +0200144
Tim Duesterhus8b87c012019-01-04 00:11:59 +0100145 if (stktable_data_cast(ptr, conn_cur) > 0)
146 stktable_data_cast(ptr, conn_cur)--;
Emeric Brun819fc6f2017-06-13 19:37:32 +0200147
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100148 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brun0fed0b02017-11-29 16:15:07 +0100149
150 /* If data was modified, we need to touch to re-schedule sync */
151 stktable_touch_local(s->stkctr[i].table, ts, 0);
Emeric Brun819fc6f2017-06-13 19:37:32 +0200152 }
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100153 stkctr_set_entry(&s->stkctr[i], NULL);
Emeric Brun819fc6f2017-06-13 19:37:32 +0200154 stksess_kill_if_expired(s->stkctr[i].table, ts, 1);
Willy Tarreau0a4838c2010-08-06 20:11:05 +0200155 }
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200156}
Willy Tarreaue3487932010-06-18 21:03:20 +0200157
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200158/* Increase total and concurrent connection count for stick entry <ts> of table
159 * <t>. The caller is responsible for ensuring that <t> and <ts> are valid
160 * pointers, and for calling this only once per connection.
161 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200162static inline void stream_start_counters(struct stktable *t, struct stksess *ts)
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200163{
164 void *ptr;
Willy Tarreau91c43d72010-06-20 11:19:22 +0200165
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100166 HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brun819fc6f2017-06-13 19:37:32 +0200167
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200168 ptr = stktable_data_ptr(t, ts, STKTABLE_DT_CONN_CUR);
169 if (ptr)
170 stktable_data_cast(ptr, conn_cur)++;
171
172 ptr = stktable_data_ptr(t, ts, STKTABLE_DT_CONN_CNT);
173 if (ptr)
174 stktable_data_cast(ptr, conn_cnt)++;
175
176 ptr = stktable_data_ptr(t, ts, STKTABLE_DT_CONN_RATE);
177 if (ptr)
178 update_freq_ctr_period(&stktable_data_cast(ptr, conn_rate),
179 t->data_arg[STKTABLE_DT_CONN_RATE].u, 1);
180 if (tick_isset(t->expire))
181 ts->expire = tick_add(now_ms, MS_TO_TICKS(t->expire));
Emeric Brun819fc6f2017-06-13 19:37:32 +0200182
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100183 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brun0fed0b02017-11-29 16:15:07 +0100184
185 /* If data was modified, we need to touch to re-schedule sync */
186 stktable_touch_local(t, ts, 0);
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200187}
188
Willy Tarreau87b09662015-04-03 00:22:06 +0200189/* Enable tracking of stream counters as <stkctr> on stksess <ts>. The caller is
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200190 * responsible for ensuring that <t> and <ts> are valid pointers. Some controls
191 * are performed to ensure the state can still change.
192 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200193static inline void stream_track_stkctr(struct stkctr *ctr, struct stktable *t, struct stksess *ts)
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200194{
Emeric Brun819fc6f2017-06-13 19:37:32 +0200195 /* Why this test ???? */
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100196 if (stkctr_entry(ctr))
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200197 return;
198
Willy Tarreau20d46a52012-12-09 15:55:40 +0100199 ctr->table = t;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100200 stkctr_set_entry(ctr, ts);
Willy Tarreau87b09662015-04-03 00:22:06 +0200201 stream_start_counters(t, ts);
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200202}
203
Willy Tarreauda7ff642010-06-23 11:44:09 +0200204/* Increase the number of cumulated HTTP requests in the tracked counters */
Willy Tarreau0e492e22019-04-15 21:25:03 +0200205static inline void stream_inc_http_req_ctr(struct stream *s)
Willy Tarreauda7ff642010-06-23 11:44:09 +0200206{
Emeric Brun819fc6f2017-06-13 19:37:32 +0200207 struct stksess *ts;
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200208 void *ptr;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100209 int i;
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200210
Willy Tarreaub4c84932013-07-23 19:15:30 +0200211 for (i = 0; i < MAX_SESS_STKCTR; i++) {
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200212 struct stkctr *stkctr = &s->stkctr[i];
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200213
Emeric Brun819fc6f2017-06-13 19:37:32 +0200214 ts = stkctr_entry(stkctr);
215 if (!ts) {
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200216 stkctr = &s->sess->stkctr[i];
Emeric Brun819fc6f2017-06-13 19:37:32 +0200217 ts = stkctr_entry(stkctr);
218 if (!ts)
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200219 continue;
220 }
221
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100222 HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brun819fc6f2017-06-13 19:37:32 +0200223
224 ptr = stktable_data_ptr(stkctr->table, ts, STKTABLE_DT_HTTP_REQ_CNT);
Willy Tarreauda7ff642010-06-23 11:44:09 +0200225 if (ptr)
226 stktable_data_cast(ptr, http_req_cnt)++;
227
Emeric Brun819fc6f2017-06-13 19:37:32 +0200228 ptr = stktable_data_ptr(stkctr->table, ts, STKTABLE_DT_HTTP_REQ_RATE);
Willy Tarreauda7ff642010-06-23 11:44:09 +0200229 if (ptr)
230 update_freq_ctr_period(&stktable_data_cast(ptr, http_req_rate),
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200231 stkctr->table->data_arg[STKTABLE_DT_HTTP_REQ_RATE].u, 1);
Emeric Brun819fc6f2017-06-13 19:37:32 +0200232
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100233 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brun0fed0b02017-11-29 16:15:07 +0100234
235 /* If data was modified, we need to touch to re-schedule sync */
236 stktable_touch_local(stkctr->table, ts, 0);
Willy Tarreauda7ff642010-06-23 11:44:09 +0200237 }
238}
239
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200240/* Increase the number of cumulated HTTP requests in the backend's tracked
241 * counters. We don't look up the session since it cannot happen in the bakcend.
242 */
Willy Tarreau0e492e22019-04-15 21:25:03 +0200243static inline void stream_inc_be_http_req_ctr(struct stream *s)
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100244{
Emeric Brun819fc6f2017-06-13 19:37:32 +0200245 struct stksess *ts;
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100246 void *ptr;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100247 int i;
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100248
Willy Tarreaub4c84932013-07-23 19:15:30 +0200249 for (i = 0; i < MAX_SESS_STKCTR; i++) {
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200250 struct stkctr *stkctr = &s->stkctr[i];
251
Emeric Brun819fc6f2017-06-13 19:37:32 +0200252 ts = stkctr_entry(stkctr);
253 if (!ts)
Willy Tarreau20d46a52012-12-09 15:55:40 +0100254 continue;
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100255
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100256 if (!(stkctr_flags(&s->stkctr[i]) & STKCTR_TRACK_BACKEND))
Willy Tarreau20d46a52012-12-09 15:55:40 +0100257 continue;
258
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100259 HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brun819fc6f2017-06-13 19:37:32 +0200260
261 ptr = stktable_data_ptr(stkctr->table, ts, STKTABLE_DT_HTTP_REQ_CNT);
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100262 if (ptr)
263 stktable_data_cast(ptr, http_req_cnt)++;
264
Emeric Brun819fc6f2017-06-13 19:37:32 +0200265 ptr = stktable_data_ptr(stkctr->table, ts, STKTABLE_DT_HTTP_REQ_RATE);
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100266 if (ptr)
267 update_freq_ctr_period(&stktable_data_cast(ptr, http_req_rate),
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200268 stkctr->table->data_arg[STKTABLE_DT_HTTP_REQ_RATE].u, 1);
Emeric Brun819fc6f2017-06-13 19:37:32 +0200269
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100270 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brun0fed0b02017-11-29 16:15:07 +0100271
272 /* If data was modified, we need to touch to re-schedule sync */
273 stktable_touch_local(stkctr->table, ts, 0);
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100274 }
275}
276
Willy Tarreauda7ff642010-06-23 11:44:09 +0200277/* Increase the number of cumulated failed HTTP requests in the tracked
278 * counters. Only 4xx requests should be counted here so that we can
279 * distinguish between errors caused by client behaviour and other ones.
280 * Note that even 404 are interesting because they're generally caused by
281 * vulnerability scans.
282 */
Willy Tarreau0e492e22019-04-15 21:25:03 +0200283static inline void stream_inc_http_err_ctr(struct stream *s)
Willy Tarreauda7ff642010-06-23 11:44:09 +0200284{
Emeric Brun819fc6f2017-06-13 19:37:32 +0200285 struct stksess *ts;
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200286 void *ptr;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100287 int i;
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200288
Willy Tarreaub4c84932013-07-23 19:15:30 +0200289 for (i = 0; i < MAX_SESS_STKCTR; i++) {
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200290 struct stkctr *stkctr = &s->stkctr[i];
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200291
Emeric Brun819fc6f2017-06-13 19:37:32 +0200292 ts = stkctr_entry(stkctr);
293 if (!ts) {
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200294 stkctr = &s->sess->stkctr[i];
Emeric Brun819fc6f2017-06-13 19:37:32 +0200295 ts = stkctr_entry(stkctr);
296 if (!ts)
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200297 continue;
298 }
299
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100300 HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brun819fc6f2017-06-13 19:37:32 +0200301
302 ptr = stktable_data_ptr(stkctr->table, ts, STKTABLE_DT_HTTP_ERR_CNT);
Willy Tarreauda7ff642010-06-23 11:44:09 +0200303 if (ptr)
304 stktable_data_cast(ptr, http_err_cnt)++;
305
Emeric Brun819fc6f2017-06-13 19:37:32 +0200306 ptr = stktable_data_ptr(stkctr->table, ts, STKTABLE_DT_HTTP_ERR_RATE);
Willy Tarreauda7ff642010-06-23 11:44:09 +0200307 if (ptr)
308 update_freq_ctr_period(&stktable_data_cast(ptr, http_err_rate),
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200309 stkctr->table->data_arg[STKTABLE_DT_HTTP_ERR_RATE].u, 1);
Emeric Brun819fc6f2017-06-13 19:37:32 +0200310
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100311 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
Emeric Brun0fed0b02017-11-29 16:15:07 +0100312
313 /* If data was modified, we need to touch to re-schedule sync */
314 stktable_touch_local(stkctr->table, ts, 0);
Willy Tarreauda7ff642010-06-23 11:44:09 +0200315 }
316}
317
Willy Tarreau0e492e22019-04-15 21:25:03 +0200318static inline void __stream_add_srv_conn(struct stream *sess, struct server *srv)
Simon Hormanaf514952011-06-21 14:34:57 +0900319{
320 sess->srv_conn = srv;
321 LIST_ADD(&srv->actconns, &sess->by_srv);
Willy Tarreau103e5662017-11-26 18:48:14 +0100322}
323
Willy Tarreau0e492e22019-04-15 21:25:03 +0200324static inline void stream_add_srv_conn(struct stream *sess, struct server *srv)
Willy Tarreau103e5662017-11-26 18:48:14 +0100325{
326 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
327 __stream_add_srv_conn(sess, srv);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100328 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Simon Hormanaf514952011-06-21 14:34:57 +0900329}
330
Willy Tarreau0e492e22019-04-15 21:25:03 +0200331static inline void stream_del_srv_conn(struct stream *sess)
Simon Hormanaf514952011-06-21 14:34:57 +0900332{
Christopher Faulet29f77e82017-06-08 14:04:45 +0200333 struct server *srv = sess->srv_conn;
334
335 if (!srv)
Simon Hormanaf514952011-06-21 14:34:57 +0900336 return;
337
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100338 HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
Simon Hormanaf514952011-06-21 14:34:57 +0900339 sess->srv_conn = NULL;
340 LIST_DEL(&sess->by_srv);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100341 HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
Simon Hormanaf514952011-06-21 14:34:57 +0900342}
343
Willy Tarreau0e492e22019-04-15 21:25:03 +0200344static inline void stream_init_srv_conn(struct stream *sess)
Willy Tarreau9bd0d742011-07-20 00:17:39 +0200345{
346 sess->srv_conn = NULL;
347 LIST_INIT(&sess->by_srv);
348}
349
Thierry FOURNIER5a363e72015-09-27 19:29:33 +0200350void service_keywords_register(struct action_kw_list *kw_list);
Willy Tarreau679bba12019-03-19 08:08:10 +0100351void list_services(FILE *out);
Thierry FOURNIER5a363e72015-09-27 19:29:33 +0200352
Willy Tarreau87b09662015-04-03 00:22:06 +0200353#endif /* _PROTO_STREAM_H */
Willy TARREAU3dc06442006-06-15 21:48:13 +0200354
Willy Tarreaubaaee002006-06-26 02:48:02 +0200355/*
356 * Local variables:
357 * c-indent-level: 8
358 * c-basic-offset: 8
359 * End:
360 */