upstream/haproxy
1
0
Fork 0
mirror of https://github.com/haproxy/haproxy.git synced 2026-02-17 17:47:56 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions 4
haproxy/src/stream_interface.c

1379 lines
43 KiB
C
Raw Normal View History

[MAJOR] add a connection error state to the stream_interface Tracking connection status changes was hard, and some code was redundant. A new SI_ST_CER state was added to the stream interface to indicate a past connection error, and an SI_FL_ERR flag was added to report past I/O error. The stream_sock code does not set the connection to SI_ST_CLO anymore in case of I/O error, it's the upper layer which does it. This makes it possible to know exactly when the file descriptors are allocated. The new SI_ST_CER state permitted to split tcp_connection_status() in two parts, one processing SI_ST_CON and the other one SI_ST_CER. Synchronous connection errors now make use of this last state, hence eliminating duplicate code. Some ib<->ob copy paste errors were found and fixed, and all entities setting SI_ST_CLO also shut the buffers down. Some of these stream_interface specific functions and structures have migrated to a new stream_interface.c file. Some types of errors are still not detected by the buffers. For instance, let's assume the following scenario in one single pass of process_session: a connection sits in SI_ST_TAR state during a retry. At TAR expiration, a new connection attempt is made, the connection is obtained and srv->cur_sess is increased. Then the buffer timeout is fires and everything is cleared, the new state becomes SI_ST_CLO. The cleaning code checks that previous state was either SI_ST_CON or SI_ST_EST to release the connection. But that's wrong because last state is still SI_ST_TAR. So the server's connection count does not get decreased. This means that prev_state must not be used, and must be replaced by some transition detection instead of level detection. The following debugging line was useful to track state changes : fprintf(stderr, "%s:%d: cs=%d ss=%d(%d) rqf=0x%08x rpf=0x%08x\n", __FUNCTION__, __LINE__, s->si[0].state, s->si[1].state, s->si[1].err_type, s->req->flags, s-> rep->flags);
2008-11-03 00:26:53 -05:00
/*
* Functions managing stream_interface structures
*
CLEANUP: stream_interface: stop exporting socket layer functions Similarly to the previous patch, we don't need the socket-layer functions outside of stream_interface. They could even move to a file dedicated to applets, though that does not seem particularly useful at the moment.
2012-05-11 11:47:17 -04:00
* Copyright 2000-2012 Willy Tarreau <w@1wt.eu>
[MAJOR] add a connection error state to the stream_interface Tracking connection status changes was hard, and some code was redundant. A new SI_ST_CER state was added to the stream interface to indicate a past connection error, and an SI_FL_ERR flag was added to report past I/O error. The stream_sock code does not set the connection to SI_ST_CLO anymore in case of I/O error, it's the upper layer which does it. This makes it possible to know exactly when the file descriptors are allocated. The new SI_ST_CER state permitted to split tcp_connection_status() in two parts, one processing SI_ST_CON and the other one SI_ST_CER. Synchronous connection errors now make use of this last state, hence eliminating duplicate code. Some ib<->ob copy paste errors were found and fixed, and all entities setting SI_ST_CLO also shut the buffers down. Some of these stream_interface specific functions and structures have migrated to a new stream_interface.c file. Some types of errors are still not detected by the buffers. For instance, let's assume the following scenario in one single pass of process_session: a connection sits in SI_ST_TAR state during a retry. At TAR expiration, a new connection attempt is made, the connection is obtained and srv->cur_sess is increased. Then the buffer timeout is fires and everything is cleared, the new state becomes SI_ST_CLO. The cleaning code checks that previous state was either SI_ST_CON or SI_ST_EST to release the connection. But that's wrong because last state is still SI_ST_TAR. So the server's connection count does not get decreased. This means that prev_state must not be used, and must be replaced by some transition detection instead of level detection. The following debugging line was useful to track state changes : fprintf(stderr, "%s:%d: cs=%d ss=%d(%d) rqf=0x%08x rpf=0x%08x\n", __FUNCTION__, __LINE__, s->si[0].state, s->si[1].state, s->si[1].err_type, s->req->flags, s-> rep->flags);
2008-11-03 00:26:53 -05:00
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.
*
*/
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <common/compat.h>
#include <common/config.h>
#include <common/debug.h>
#include <common/standard.h>
#include <common/ticks.h>
#include <common/time.h>
REORG: buffers: split buffers into chunk,buffer,channel Many parts of the channel definition still make use of the "buffer" word.
2012-08-24 13:22:53 -04:00
#include <proto/channel.h>
REORG: connection: replace si_data_close() with conn_data_close() This close function only applies to connection-specific parts and the stream-interface entry may soon disappear. Move this to the connection instead.
2012-08-06 09:06:49 -04:00
#include <proto/connection.h>
[MAJOR] add a connection error state to the stream_interface Tracking connection status changes was hard, and some code was redundant. A new SI_ST_CER state was added to the stream interface to indicate a past connection error, and an SI_FL_ERR flag was added to report past I/O error. The stream_sock code does not set the connection to SI_ST_CLO anymore in case of I/O error, it's the upper layer which does it. This makes it possible to know exactly when the file descriptors are allocated. The new SI_ST_CER state permitted to split tcp_connection_status() in two parts, one processing SI_ST_CON and the other one SI_ST_CER. Synchronous connection errors now make use of this last state, hence eliminating duplicate code. Some ib<->ob copy paste errors were found and fixed, and all entities setting SI_ST_CLO also shut the buffers down. Some of these stream_interface specific functions and structures have migrated to a new stream_interface.c file. Some types of errors are still not detected by the buffers. For instance, let's assume the following scenario in one single pass of process_session: a connection sits in SI_ST_TAR state during a retry. At TAR expiration, a new connection attempt is made, the connection is obtained and srv->cur_sess is increased. Then the buffer timeout is fires and everything is cleared, the new state becomes SI_ST_CLO. The cleaning code checks that previous state was either SI_ST_CON or SI_ST_EST to release the connection. But that's wrong because last state is still SI_ST_TAR. So the server's connection count does not get decreased. This means that prev_state must not be used, and must be replaced by some transition detection instead of level detection. The following debugging line was useful to track state changes : fprintf(stderr, "%s:%d: cs=%d ss=%d(%d) rqf=0x%08x rpf=0x%08x\n", __FUNCTION__, __LINE__, s->si[0].state, s->si[1].state, s->si[1].err_type, s->req->flags, s-> rep->flags);
2008-11-03 00:26:53 -05:00
#include <proto/fd.h>
MAJOR: stream-interface: restore splicing mechanism The splicing is now provided by the data-layer rcv_pipe/snd_pipe functions which in turn are called by the stream interface's recv and send callbacks. The presence of the rcv_pipe/snd_pipe functions is used to attest support for splicing at the data layer. It looks like the stream-interface's SI_FL_CAP_SPLICE flag does not make sense anymore as it's used as a proxy for the pointers above. It also appears that we call chk_snd() from the recv callback and then try to call it again in update_conn(). It is very likely that this last function will progressively slip into the recv/send callbacks in order to avoid duplicate check code. The code works right now with and without splicing. Only raw_sock provides support for it and it is automatically selected when the various splice options are set. However it looks like splice-auto doesn't enable it, which possibly means that the streamer detection code does not work anymore, or that it's only called at a time where it's too late to enable splicing (in process_session).
2012-08-23 18:46:52 -04:00
#include <proto/pipe.h>
[BUILD] stream_interface: fix conflicting declaration stream_int_check_timeouts was declared void while it's an int.
2009-09-20 14:14:49 -04:00
#include <proto/stream_interface.h>
[MAJOR] add a connection error state to the stream_interface Tracking connection status changes was hard, and some code was redundant. A new SI_ST_CER state was added to the stream interface to indicate a past connection error, and an SI_FL_ERR flag was added to report past I/O error. The stream_sock code does not set the connection to SI_ST_CLO anymore in case of I/O error, it's the upper layer which does it. This makes it possible to know exactly when the file descriptors are allocated. The new SI_ST_CER state permitted to split tcp_connection_status() in two parts, one processing SI_ST_CON and the other one SI_ST_CER. Synchronous connection errors now make use of this last state, hence eliminating duplicate code. Some ib<->ob copy paste errors were found and fixed, and all entities setting SI_ST_CLO also shut the buffers down. Some of these stream_interface specific functions and structures have migrated to a new stream_interface.c file. Some types of errors are still not detected by the buffers. For instance, let's assume the following scenario in one single pass of process_session: a connection sits in SI_ST_TAR state during a retry. At TAR expiration, a new connection attempt is made, the connection is obtained and srv->cur_sess is increased. Then the buffer timeout is fires and everything is cleared, the new state becomes SI_ST_CLO. The cleaning code checks that previous state was either SI_ST_CON or SI_ST_EST to release the connection. But that's wrong because last state is still SI_ST_TAR. So the server's connection count does not get decreased. This means that prev_state must not be used, and must be replaced by some transition detection instead of level detection. The following debugging line was useful to track state changes : fprintf(stderr, "%s:%d: cs=%d ss=%d(%d) rqf=0x%08x rpf=0x%08x\n", __FUNCTION__, __LINE__, s->si[0].state, s->si[1].state, s->si[1].err_type, s->req->flags, s-> rep->flags);
2008-11-03 00:26:53 -05:00
#include <proto/task.h>
MAJOR: remove the stream interface and task management code from sock_* The socket data layer code must only focus on moving data between a socket and a buffer. We need a special stream interface handler to update the stream interface and the file descriptor status. At the moment the code works but suffers from a race condition caused by its API : the read/write callbacks still make use of the fd instead of using the connection. And when a double shutdown is performed, a call to ->write() after ->read() processed an error results in dereferencing a NULL fdtab[]->owner. This is only a temporary issue which doesn't need to be fixed now since this will automatically go away when the functions change to use the connection instead.
2012-07-23 12:24:25 -04:00
#include <types/pipe.h>
CLEANUP: stream_interface: stop exporting socket layer functions Similarly to the previous patch, we don't need the socket-layer functions outside of stream_interface. They could even move to a file dedicated to applets, though that does not seem particularly useful at the moment.
2012-05-11 11:47:17 -04:00
/* socket functions used when running a stream interface as a task */
static void stream_int_update_embedded(struct stream_interface *si);
MINOR: stream-int: make the shutr/shutw functions void This is to be more consistent with the other functions. The only reason why these functions used to return a value was to let the caller adjust polling by itself, but now their only callers were the si_shutr()/si_shutw() inline functions. Now these functions do not depend anymore on the connection. These connection variant of these functions now call conn_data_stop_recv()/conn_data_stop_send() before returning order not to require a return code anymore. The applet version does not need this at all.
2013-09-29 09:16:03 -04:00
static void stream_int_shutr(struct stream_interface *si);
static void stream_int_shutw(struct stream_interface *si);
CLEANUP: stream_interface: stop exporting socket layer functions Similarly to the previous patch, we don't need the socket-layer functions outside of stream_interface. They could even move to a file dedicated to applets, though that does not seem particularly useful at the moment.
2012-05-11 11:47:17 -04:00
static void stream_int_chk_rcv(struct stream_interface *si);
static void stream_int_chk_snd(struct stream_interface *si);
CLEANUP: connection: split sock_ops into data_ops, app_cp and si_ops Some parts of the sock_ops structure were only used by the stream interface and have been moved into si_ops. Some of them were callbacks to the stream interface from the connection and have been moved into app_cp as they're the application seen from the connection (later, health-checks will need to use them). The rest has moved to data_ops. Normally at this point the connection could live without knowing about stream interfaces at all.
2012-08-24 12:12:41 -04:00
static void stream_int_update_conn(struct stream_interface *si);
MINOR: stream-int: make the shutr/shutw functions void This is to be more consistent with the other functions. The only reason why these functions used to return a value was to let the caller adjust polling by itself, but now their only callers were the si_shutr()/si_shutw() inline functions. Now these functions do not depend anymore on the connection. These connection variant of these functions now call conn_data_stop_recv()/conn_data_stop_send() before returning order not to require a return code anymore. The applet version does not need this at all.
2013-09-29 09:16:03 -04:00
static void stream_int_shutr_conn(struct stream_interface *si);
static void stream_int_shutw_conn(struct stream_interface *si);
CLEANUP: connection: split sock_ops into data_ops, app_cp and si_ops Some parts of the sock_ops structure were only used by the stream interface and have been moved into si_ops. Some of them were callbacks to the stream interface from the connection and have been moved into app_cp as they're the application seen from the connection (later, health-checks will need to use them). The rest has moved to data_ops. Normally at this point the connection could live without knowing about stream interfaces at all.
2012-08-24 12:12:41 -04:00
static void stream_int_chk_rcv_conn(struct stream_interface *si);
static void stream_int_chk_snd_conn(struct stream_interface *si);
MINOR: connection: provide a generic data layer wakeup callback Instead of calling conn_notify_si() from the connection handler, we now call data->wake(), which will allow us to use a different callback with health checks. Note that we still rely on a flag in order to decide whether or not to call this function. The reason is that with embryonic sessions, the callback is already initialized to si_conn_cb without the flag, and we can't call the SI notify function in the leave path before the stream interface is initialized. This issue should be addressed by involving a different data_cb for embryonic sessions and for stream interfaces, that would be changed during session_complete() for the final data_cb.
2012-10-02 14:07:22 -04:00
static void si_conn_recv_cb(struct connection *conn);
static void si_conn_send_cb(struct connection *conn);
MEDIUM: connection: make it possible for data->wake to return an error Just like ->init(), ->wake() may now be used to return an error and abort the connection. Currently this is not used but will be with embryonic sessions.
2012-10-03 15:12:16 -04:00
static int si_conn_wake_cb(struct connection *conn);
MEDIUM: stream-int: implement a very simplistic idle connection manager Idle connections are not monitored right now. So if a server closes after a response without advertising it, it won't be detected until a next request wants to use the connection. This is a bit problematic because it unnecessarily maintains file descriptors and sockets in an idle state. This patch implements a very simple idle connection manager for the stream interface. It presents itself as an I/O callback. The HTTP engine enables it when it recycles a connection. If a close or an error is detected on the underlying socket, it tries to drain as much data as possible from the socket, detect the close and responds with a close as well, then detaches from the stream interface.
2013-12-16 18:00:28 -05:00
static int si_idle_conn_wake_cb(struct connection *conn);
static void si_idle_conn_null_cb(struct connection *conn);
CLEANUP: stream_interface: stop exporting socket layer functions Similarly to the previous patch, we don't need the socket-layer functions outside of stream_interface. They could even move to a file dedicated to applets, though that does not seem particularly useful at the moment.
2012-05-11 11:47:17 -04:00
CLEANUP: connection: split sock_ops into data_ops, app_cp and si_ops Some parts of the sock_ops structure were only used by the stream interface and have been moved into si_ops. Some of them were callbacks to the stream interface from the connection and have been moved into app_cp as they're the application seen from the connection (later, health-checks will need to use them). The rest has moved to data_ops. Normally at this point the connection could live without knowing about stream interfaces at all.
2012-08-24 12:12:41 -04:00
/* stream-interface operations for embedded tasks */
struct si_ops si_embedded_ops = {
REORG/MEDIUM: stream_interface: initialize socket ops from descriptors
2012-05-07 11:15:39 -04:00
.update = stream_int_update_embedded,
.chk_rcv = stream_int_chk_rcv,
.chk_snd = stream_int_chk_snd,
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
.shutr = stream_int_shutr,
.shutw = stream_int_shutw,
REORG/MEDIUM: stream_interface: initialize socket ops from descriptors
2012-05-07 11:15:39 -04:00
};
CLEANUP: connection: split sock_ops into data_ops, app_cp and si_ops Some parts of the sock_ops structure were only used by the stream interface and have been moved into si_ops. Some of them were callbacks to the stream interface from the connection and have been moved into app_cp as they're the application seen from the connection (later, health-checks will need to use them). The rest has moved to data_ops. Normally at this point the connection could live without knowing about stream interfaces at all.
2012-08-24 12:12:41 -04:00
/* stream-interface operations for connections */
struct si_ops si_conn_ops = {
.update = stream_int_update_conn,
.chk_rcv = stream_int_chk_rcv_conn,
.chk_snd = stream_int_chk_snd_conn,
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
.shutr = stream_int_shutr_conn,
.shutw = stream_int_shutw_conn,
CLEANUP: connection: split sock_ops into data_ops, app_cp and si_ops Some parts of the sock_ops structure were only used by the stream interface and have been moved into si_ops. Some of them were callbacks to the stream interface from the connection and have been moved into app_cp as they're the application seen from the connection (later, health-checks will need to use them). The rest has moved to data_ops. Normally at this point the connection could live without knowing about stream interfaces at all.
2012-08-24 12:12:41 -04:00
};
REORG: connection: rename app_cb "data" Now conn->data will designate the data layer which is the client for the transport layer. In practice it's the stream interface and will soon also be the health checks.
2012-10-02 18:41:04 -04:00
struct data_cb si_conn_cb = {
CLEANUP: connection: split sock_ops into data_ops, app_cp and si_ops Some parts of the sock_ops structure were only used by the stream interface and have been moved into si_ops. Some of them were callbacks to the stream interface from the connection and have been moved into app_cp as they're the application seen from the connection (later, health-checks will need to use them). The rest has moved to data_ops. Normally at this point the connection could live without knowing about stream interfaces at all.
2012-08-24 12:12:41 -04:00
.recv = si_conn_recv_cb,
.send = si_conn_send_cb,
MINOR: connection: provide a generic data layer wakeup callback Instead of calling conn_notify_si() from the connection handler, we now call data->wake(), which will allow us to use a different callback with health checks. Note that we still rely on a flag in order to decide whether or not to call this function. The reason is that with embryonic sessions, the callback is already initialized to si_conn_cb without the flag, and we can't call the SI notify function in the leave path before the stream interface is initialized. This issue should be addressed by involving a different data_cb for embryonic sessions and for stream interfaces, that would be changed during session_complete() for the final data_cb.
2012-10-02 14:07:22 -04:00
.wake = si_conn_wake_cb,
REORG/MEDIUM: stream_interface: initialize socket ops from descriptors
2012-05-07 11:15:39 -04:00
};
MEDIUM: stream-int: implement a very simplistic idle connection manager Idle connections are not monitored right now. So if a server closes after a response without advertising it, it won't be detected until a next request wants to use the connection. This is a bit problematic because it unnecessarily maintains file descriptors and sockets in an idle state. This patch implements a very simple idle connection manager for the stream interface. It presents itself as an I/O callback. The HTTP engine enables it when it recycles a connection. If a close or an error is detected on the underlying socket, it tries to drain as much data as possible from the socket, detect the close and responds with a close as well, then detaches from the stream interface.
2013-12-16 18:00:28 -05:00
struct data_cb si_idle_conn_cb = {
.recv = si_idle_conn_null_cb,
.send = si_idle_conn_null_cb,
.wake = si_idle_conn_wake_cb,
};
[MAJOR] add a connection error state to the stream_interface Tracking connection status changes was hard, and some code was redundant. A new SI_ST_CER state was added to the stream interface to indicate a past connection error, and an SI_FL_ERR flag was added to report past I/O error. The stream_sock code does not set the connection to SI_ST_CLO anymore in case of I/O error, it's the upper layer which does it. This makes it possible to know exactly when the file descriptors are allocated. The new SI_ST_CER state permitted to split tcp_connection_status() in two parts, one processing SI_ST_CON and the other one SI_ST_CER. Synchronous connection errors now make use of this last state, hence eliminating duplicate code. Some ib<->ob copy paste errors were found and fixed, and all entities setting SI_ST_CLO also shut the buffers down. Some of these stream_interface specific functions and structures have migrated to a new stream_interface.c file. Some types of errors are still not detected by the buffers. For instance, let's assume the following scenario in one single pass of process_session: a connection sits in SI_ST_TAR state during a retry. At TAR expiration, a new connection attempt is made, the connection is obtained and srv->cur_sess is increased. Then the buffer timeout is fires and everything is cleared, the new state becomes SI_ST_CLO. The cleaning code checks that previous state was either SI_ST_CON or SI_ST_EST to release the connection. But that's wrong because last state is still SI_ST_TAR. So the server's connection count does not get decreased. This means that prev_state must not be used, and must be replaced by some transition detection instead of level detection. The following debugging line was useful to track state changes : fprintf(stderr, "%s:%d: cs=%d ss=%d(%d) rqf=0x%08x rpf=0x%08x\n", __FUNCTION__, __LINE__, s->si[0].state, s->si[1].state, s->si[1].err_type, s->req->flags, s-> rep->flags);
2008-11-03 00:26:53 -05:00
/*
* This function only has to be called once after a wakeup event in case of
* suspected timeout. It controls the stream interface timeouts and sets
* si->flags accordingly. It does NOT close anything, as this timeout may
* be used for any purpose. It returns 1 if the timeout fired, otherwise
* zero.
*/
int stream_int_check_timeouts(struct stream_interface *si)
{
if (tick_is_expired(si->exp, now_ms)) {
si->flags |= SI_FL_EXP;
return 1;
}
return 0;
}
[MAJOR] complete layer4/7 separation All the processing has now completely been split in layers. As of now, everything is still in process_session() which is not the right place, but the code sequence works. Timeouts, retries, errors, all work. The shutdown sequence has been strictly applied: BF_SHUTR/BF_SHUTW are only assigned by lower layers. Upper layers can only indicate their wish to close using BF_SHUTR_NOW and BF_SHUTW_NOW. When a shutdown is performed on a stream interface, the buffer flags are updated accordingly and re-checked by upper layers. A lot of care has been taken to ensure that aborts during intermediate connection setups are correctly handled and shutdowns correctly propagated to both buffers. A future evolution would consist in ensuring that BF_SHUT?_NOW may be set at any time, and applies only when the buffer is empty. This might help with error messages, but might complicate the processing of data remaining in buffers. Some useless buffer flag combinations have been removed. Stat counters are still broken (eg: per-server total number of sessions). Error messages should be delayed to the close instant and be produced by protocol. Many functions must now move to proper locations.
2008-11-30 12:14:12 -05:00
/* to be called only when in SI_ST_DIS with SI_FL_ERR */
[MAJOR] add a connection error state to the stream_interface Tracking connection status changes was hard, and some code was redundant. A new SI_ST_CER state was added to the stream interface to indicate a past connection error, and an SI_FL_ERR flag was added to report past I/O error. The stream_sock code does not set the connection to SI_ST_CLO anymore in case of I/O error, it's the upper layer which does it. This makes it possible to know exactly when the file descriptors are allocated. The new SI_ST_CER state permitted to split tcp_connection_status() in two parts, one processing SI_ST_CON and the other one SI_ST_CER. Synchronous connection errors now make use of this last state, hence eliminating duplicate code. Some ib<->ob copy paste errors were found and fixed, and all entities setting SI_ST_CLO also shut the buffers down. Some of these stream_interface specific functions and structures have migrated to a new stream_interface.c file. Some types of errors are still not detected by the buffers. For instance, let's assume the following scenario in one single pass of process_session: a connection sits in SI_ST_TAR state during a retry. At TAR expiration, a new connection attempt is made, the connection is obtained and srv->cur_sess is increased. Then the buffer timeout is fires and everything is cleared, the new state becomes SI_ST_CLO. The cleaning code checks that previous state was either SI_ST_CON or SI_ST_EST to release the connection. But that's wrong because last state is still SI_ST_TAR. So the server's connection count does not get decreased. This means that prev_state must not be used, and must be replaced by some transition detection instead of level detection. The following debugging line was useful to track state changes : fprintf(stderr, "%s:%d: cs=%d ss=%d(%d) rqf=0x%08x rpf=0x%08x\n", __FUNCTION__, __LINE__, s->si[0].state, s->si[1].state, s->si[1].err_type, s->req->flags, s-> rep->flags);
2008-11-03 00:26:53 -05:00
void stream_int_report_error(struct stream_interface *si)
{
if (!si->err_type)
si->err_type = SI_ET_DATA_ERR;
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
si->ob->flags |= CF_WRITE_ERROR;
si->ib->flags |= CF_READ_ERROR;
[MAJOR] add a connection error state to the stream_interface Tracking connection status changes was hard, and some code was redundant. A new SI_ST_CER state was added to the stream interface to indicate a past connection error, and an SI_FL_ERR flag was added to report past I/O error. The stream_sock code does not set the connection to SI_ST_CLO anymore in case of I/O error, it's the upper layer which does it. This makes it possible to know exactly when the file descriptors are allocated. The new SI_ST_CER state permitted to split tcp_connection_status() in two parts, one processing SI_ST_CON and the other one SI_ST_CER. Synchronous connection errors now make use of this last state, hence eliminating duplicate code. Some ib<->ob copy paste errors were found and fixed, and all entities setting SI_ST_CLO also shut the buffers down. Some of these stream_interface specific functions and structures have migrated to a new stream_interface.c file. Some types of errors are still not detected by the buffers. For instance, let's assume the following scenario in one single pass of process_session: a connection sits in SI_ST_TAR state during a retry. At TAR expiration, a new connection attempt is made, the connection is obtained and srv->cur_sess is increased. Then the buffer timeout is fires and everything is cleared, the new state becomes SI_ST_CLO. The cleaning code checks that previous state was either SI_ST_CON or SI_ST_EST to release the connection. But that's wrong because last state is still SI_ST_TAR. So the server's connection count does not get decreased. This means that prev_state must not be used, and must be replaced by some transition detection instead of level detection. The following debugging line was useful to track state changes : fprintf(stderr, "%s:%d: cs=%d ss=%d(%d) rqf=0x%08x rpf=0x%08x\n", __FUNCTION__, __LINE__, s->si[0].state, s->si[1].state, s->si[1].err_type, s->req->flags, s-> rep->flags);
2008-11-03 00:26:53 -05:00
}
[MINOR] replace client_retnclose() with stream_int_retnclose() This makes more sense to return a message to a stream interface than to a session. senddata.{c,h} have been removed.
2008-11-30 13:48:07 -05:00
/*
* Returns a message to the client ; the connection is shut down for read,
* and the request is cleared so that no server connection can be initiated.
* The buffer is marked for read shutdown on the other side to protect the
* message, and the buffer write is enabled. The message is contained in a
[BUG] stream_interface: fix retnclose and remove cond_close The stream_int_cond_close() function was added to preserve the contents of the response buffer because stream_int_retnclose() was buggy. It flushed the response instead of flushing the request. This caused issues with pipelined redirects followed by error messages which ate the previous response. This might even have caused object truncation on pipelined requests followed by an error or by a server redirection. Now that this is fixed, simply get rid of the now useless function.
2010-01-10 04:21:21 -05:00
* "chunk". If it is null, then an empty message is used. The reply buffer does
* not need to be empty before this, and its contents will not be overwritten.
* The primary goal of this function is to return error messages to a client.
[MINOR] replace client_retnclose() with stream_int_retnclose() This makes more sense to return a message to a stream interface than to a session. senddata.{c,h} have been removed.
2008-11-30 13:48:07 -05:00
*/
void stream_int_retnclose(struct stream_interface *si, const struct chunk *msg)
{
CLEANUP: channel: use "channel" instead of "buffer" in function names This is a massive rename of most functions which should make use of the word "channel" instead of the word "buffer" in their names. In concerns the following ones (new names) : unsigned long long channel_forward(struct channel *buf, unsigned long long bytes); static inline void channel_init(struct channel *buf) static inline int channel_input_closed(struct channel *buf) static inline int channel_output_closed(struct channel *buf) static inline void channel_check_timeouts(struct channel *b) static inline void channel_erase(struct channel *buf) static inline void channel_shutr_now(struct channel *buf) static inline void channel_shutw_now(struct channel *buf) static inline void channel_abort(struct channel *buf) static inline void channel_stop_hijacker(struct channel *buf) static inline void channel_auto_connect(struct channel *buf) static inline void channel_dont_connect(struct channel *buf) static inline void channel_auto_close(struct channel *buf) static inline void channel_dont_close(struct channel *buf) static inline void channel_auto_read(struct channel *buf) static inline void channel_dont_read(struct channel *buf) unsigned long long channel_forward(struct channel *buf, unsigned long long bytes) Some functions provided by channel.[ch] have kept their "buffer" name because they are really designed to act on the buffer according to some information gathered from the channel. They have been moved together to the same place in the file for better readability but they were not changed at all. The "buffer" memory pool was also renamed "channel".
2012-08-27 18:06:31 -04:00
channel_auto_read(si->ib);
channel_abort(si->ib);
channel_auto_close(si->ib);
channel_erase(si->ib);
[BUG] stream_interface: truncate buffers when sending error messages When an error message is returned to a client, all buffer contents were left intact. Since the analysers were removed, the potentially invalid data that were read had a chance to be sent too. Now we ensure we only keep the already scheduled data in the buffer and we truncate it after that. That means that responses with data that must be blocked will really be blocked, and that incorrectly chunked data will be stopped at the point where the chunking fails.
2010-12-12 07:06:00 -05:00
MEDIUM: buffers: rename a number of buffer management functions The following renaming took place : 1) buffer input functions buffer_put_block => bi_putblk buffer_put_char => bi_putchr buffer_put_string => bi_putstr buffer_put_chunk => bi_putchk buffer_feed => bi_putstr buffer_feed_chunk => bi_putchk buffer_cut_tail => bi_erase buffer_ignore => bi_fast_delete 2) buffer output functions buffer_get_char => bo_getchr buffer_get_line => bo_getline buffer_get_block => bo_getblk buffer_skip => bo_skip buffer_write => bo_inject 3) buffer input avail/full functions were introduced : bi_avail bi_full
2012-05-07 05:56:55 -04:00
bi_erase(si->ob);
[BUG] stream_interface: fix retnclose and remove cond_close The stream_int_cond_close() function was added to preserve the contents of the response buffer because stream_int_retnclose() was buggy. It flushed the response instead of flushing the request. This caused issues with pipelined redirects followed by error messages which ate the previous response. This might even have caused object truncation on pipelined requests followed by an error or by a server redirection. Now that this is fixed, simply get rid of the now useless function.
2010-01-10 04:21:21 -05:00
if (likely(msg && msg->len))
MEDIUM: buffers: rename a number of buffer management functions The following renaming took place : 1) buffer input functions buffer_put_block => bi_putblk buffer_put_char => bi_putchr buffer_put_string => bi_putstr buffer_put_chunk => bi_putchk buffer_feed => bi_putstr buffer_feed_chunk => bi_putchk buffer_cut_tail => bi_erase buffer_ignore => bi_fast_delete 2) buffer output functions buffer_get_char => bo_getchr buffer_get_line => bo_getline buffer_get_block => bo_getblk buffer_skip => bo_skip buffer_write => bo_inject 3) buffer input avail/full functions were introduced : bi_avail bi_full
2012-05-07 05:56:55 -04:00
bo_inject(si->ob, msg->str, msg->len);
[MINOR] replace client_retnclose() with stream_int_retnclose() This makes more sense to return a message to a stream interface than to a session. senddata.{c,h} have been removed.
2008-11-30 13:48:07 -05:00
si->ob->wex = tick_add_ifset(now_ms, si->ob->wto);
CLEANUP: channel: use "channel" instead of "buffer" in function names This is a massive rename of most functions which should make use of the word "channel" instead of the word "buffer" in their names. In concerns the following ones (new names) : unsigned long long channel_forward(struct channel *buf, unsigned long long bytes); static inline void channel_init(struct channel *buf) static inline int channel_input_closed(struct channel *buf) static inline int channel_output_closed(struct channel *buf) static inline void channel_check_timeouts(struct channel *b) static inline void channel_erase(struct channel *buf) static inline void channel_shutr_now(struct channel *buf) static inline void channel_shutw_now(struct channel *buf) static inline void channel_abort(struct channel *buf) static inline void channel_stop_hijacker(struct channel *buf) static inline void channel_auto_connect(struct channel *buf) static inline void channel_dont_connect(struct channel *buf) static inline void channel_auto_close(struct channel *buf) static inline void channel_dont_close(struct channel *buf) static inline void channel_auto_read(struct channel *buf) static inline void channel_dont_read(struct channel *buf) unsigned long long channel_forward(struct channel *buf, unsigned long long bytes) Some functions provided by channel.[ch] have kept their "buffer" name because they are really designed to act on the buffer according to some information gathered from the channel. They have been moved together to the same place in the file for better readability but they were not changed at all. The "buffer" memory pool was also renamed "channel".
2012-08-27 18:06:31 -04:00
channel_auto_read(si->ob);
channel_auto_close(si->ob);
channel_shutr_now(si->ob);
[MINOR] new function stream_int_cond_close() This one will be used to conditionally send a message upon a close on a stream interface. It will not overwrite any existing data.
2009-12-27 16:51:06 -05:00
}
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
/* default update function for embedded tasks, to be used at the end of the i/o handler */
CLEANUP: stream_interface: stop exporting socket layer functions Similarly to the previous patch, we don't need the socket-layer functions outside of stream_interface. They could even move to a file dedicated to applets, though that does not seem particularly useful at the moment.
2012-05-11 11:47:17 -04:00
static void stream_int_update_embedded(struct stream_interface *si)
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
{
[MAJOR] stream_interface: fix the wakeup conditions for embedded iohandlers Now we stop relying on BF_READ_DONTWAIT, which is unrelated to the wakeups, and only consider activity to decide whether to wake the task up instead of considering the other side's activity. It is worth noting that the local stream interface's flags were not updated consecutively to a call to chk_snd(), which could possibly result in hung tasks from time to time. This fix will avoid possible loops and uncaught events.
2010-08-09 10:24:56 -04:00
int old_flags = si->flags;
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
DPRINTF(stderr, "%s: si=%p, si->state=%d ib->flags=%08x ob->flags=%08x\n",
__FUNCTION__,
si, si->state, si->ib->flags, si->ob->flags);
if (si->state != SI_ST_EST)
return;
CLEANUP: channel: remove any reference of the hijackers Hijackers were functions designed to inject data into channels in the distant past. They became unused around 1.3.16, and since there has not been any user of this mechanism to date, it's uncertain whether the mechanism still works (and it's not really useful anymore). So better remove it as well as the pointer it uses in the channel struct.
2012-11-11 17:05:39 -05:00
if ((si->ob->flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW &&
MAJOR: channel: remove the BF_OUT_EMPTY flag This flag was very problematic because it was composite in that both changes to the pipe or to the buffer had to cause this flag to be updated, which is not always simple (eg: there may not even be a channel attached to a buffer at all). There were not that many users of this flags, mostly setters. So the flag got replaced with a macro which reports whether the channel is empty or not, by checking both the pipe and the buffer. One part of the change is sensible : the flag was also part of BF_MASK_STATIC, which is used by process_session() to rescan all analysers in case the flag's status changes. At first glance, none of the analysers seems to change its mind base on this flag when it is subject to change, so it seems fine not to add variation checks here. Otherwise it's possible that checking the buffer's output size is more useful than checking the flag's replacement.
2012-08-24 16:40:29 -04:00
channel_is_empty(si->ob))
MINOR: stream_interface: introduce a new "struct connection" type We start to move everything needed to manage a connection to a special entity "struct connection". We have the data layer operations and the control operations there. We'll also have more info in the future such as file descriptors and applet contexts, so that in the end it becomes detachable from the stream interface, which will allow connections to be reused between sessions. For now on, we start with minimal changes.
2012-05-21 10:31:45 -04:00
si_shutw(si);
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
CLEANUP: channel: remove any reference of the hijackers Hijackers were functions designed to inject data into channels in the distant past. They became unused around 1.3.16, and since there has not been any user of this mechanism to date, it's uncertain whether the mechanism still works (and it's not really useful anymore). So better remove it as well as the pointer it uses in the channel struct.
2012-11-11 17:05:39 -05:00
if ((si->ob->flags & (CF_SHUTW|CF_SHUTW_NOW)) == 0 && !channel_full(si->ob))
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
si->flags |= SI_FL_WAIT_DATA;
[MEDIUM] stream_int: adjust WAIT_ROOM handling When applets write data, they generall cannot fill the buffer, so as soon as we find a non-empty buffer, we're sure we're missing some room.
2009-10-04 11:18:35 -04:00
/* we're almost sure that we need some space if the buffer is not
* empty, even if it's not full, because the applets can't fill it.
*/
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
if ((si->ib->flags & (CF_SHUTR|CF_DONT_READ)) == 0 && !channel_is_empty(si->ib))
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
si->flags |= SI_FL_WAIT_ROOM;
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
if (si->ob->flags & CF_WRITE_ACTIVITY) {
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
if (tick_isset(si->ob->wex))
si->ob->wex = tick_add_ifset(now_ms, si->ob->wto);
}
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
if (si->ib->flags & CF_READ_ACTIVITY ||
(si->ob->flags & CF_WRITE_ACTIVITY && !(si->flags & SI_FL_INDEP_STR))) {
[MEDIUM] new option "independant-streams" to stop updating read timeout on writes By default, when data is sent over a socket, both the write timeout and the read timeout for that socket are refreshed, because we consider that there is activity on that socket, and we have no other means of guessing if we should receive data or not. While this default behaviour is desirable for almost all applications, there exists a situation where it is desirable to disable it, and only refresh the read timeout if there are incoming data. This happens on sessions with large timeouts and low amounts of exchanged data such as telnet session. If the server suddenly disappears, the output data accumulates in the system's socket buffers, both timeouts are correctly refreshed, and there is no way to know the server does not receive them, so we don't timeout. However, when the underlying protocol always echoes sent data, it would be enough by itself to detect the issue using the read timeout. Note that this problem does not happen with more verbose protocols because data won't accumulate long in the socket buffers. When this option is set on the frontend, it will disable read timeout updates on data sent to the client. There probably is little use of this case. When the option is set on the backend, it will disable read timeout updates on data sent to the server. Doing so will typically break large HTTP posts from slow lines, so use it with caution.
2009-10-03 16:01:18 -04:00
if (tick_isset(si->ib->rex))
si->ib->rex = tick_add_ifset(now_ms, si->ib->rto);
}
[MAJOR] stream_interface: fix the wakeup conditions for embedded iohandlers Now we stop relying on BF_READ_DONTWAIT, which is unrelated to the wakeups, and only consider activity to decide whether to wake the task up instead of considering the other side's activity. It is worth noting that the local stream interface's flags were not updated consecutively to a call to chk_snd(), which could possibly result in hung tasks from time to time. This fix will avoid possible loops and uncaught events.
2010-08-09 10:24:56 -04:00
/* save flags to detect changes */
old_flags = si->flags;
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
if (likely((si->ob->flags & (CF_SHUTW|CF_WRITE_PARTIAL|CF_DONT_READ)) == CF_WRITE_PARTIAL &&
MAJOR: channel: stop relying on BF_FULL to take action This flag is quite complex to get right and updating it everywhere is a major pain, especially since the buffer/channel split. This is the first step of getting rid of it. Instead now it's dynamically computed whenever needed.
2012-08-27 14:46:07 -04:00
!channel_full(si->ob) &&
[MEDIUM] stream_int: adjust WAIT_ROOM handling When applets write data, they generall cannot fill the buffer, so as soon as we find a non-empty buffer, we're sure we're missing some room.
2009-10-04 11:18:35 -04:00
(si->ob->prod->flags & SI_FL_WAIT_ROOM)))
MINOR: stream_interface: introduce a new "struct connection" type We start to move everything needed to manage a connection to a special entity "struct connection". We have the data layer operations and the control operations there. We'll also have more info in the future such as file descriptors and applet contexts, so that in the end it becomes detachable from the stream interface, which will allow connections to be reused between sessions. For now on, we start with minimal changes.
2012-05-21 10:31:45 -04:00
si_chk_rcv(si->ob->prod);
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
if (((si->ib->flags & CF_READ_PARTIAL) && !channel_is_empty(si->ib)) &&
[MAJOR] stream_interface: fix the wakeup conditions for embedded iohandlers Now we stop relying on BF_READ_DONTWAIT, which is unrelated to the wakeups, and only consider activity to decide whether to wake the task up instead of considering the other side's activity. It is worth noting that the local stream interface's flags were not updated consecutively to a call to chk_snd(), which could possibly result in hung tasks from time to time. This fix will avoid possible loops and uncaught events.
2010-08-09 10:24:56 -04:00
(si->ib->cons->flags & SI_FL_WAIT_DATA)) {
MINOR: stream_interface: introduce a new "struct connection" type We start to move everything needed to manage a connection to a special entity "struct connection". We have the data layer operations and the control operations there. We'll also have more info in the future such as file descriptors and applet contexts, so that in the end it becomes detachable from the stream interface, which will allow connections to be reused between sessions. For now on, we start with minimal changes.
2012-05-21 10:31:45 -04:00
si_chk_snd(si->ib->cons);
[MAJOR] stream_interface: fix the wakeup conditions for embedded iohandlers Now we stop relying on BF_READ_DONTWAIT, which is unrelated to the wakeups, and only consider activity to decide whether to wake the task up instead of considering the other side's activity. It is worth noting that the local stream interface's flags were not updated consecutively to a call to chk_snd(), which could possibly result in hung tasks from time to time. This fix will avoid possible loops and uncaught events.
2010-08-09 10:24:56 -04:00
/* check if the consumer has freed some space */
MAJOR: channel: stop relying on BF_FULL to take action This flag is quite complex to get right and updating it everywhere is a major pain, especially since the buffer/channel split. This is the first step of getting rid of it. Instead now it's dynamically computed whenever needed.
2012-08-27 14:46:07 -04:00
if (!channel_full(si->ib))
[MAJOR] stream_interface: fix the wakeup conditions for embedded iohandlers Now we stop relying on BF_READ_DONTWAIT, which is unrelated to the wakeups, and only consider activity to decide whether to wake the task up instead of considering the other side's activity. It is worth noting that the local stream interface's flags were not updated consecutively to a call to chk_snd(), which could possibly result in hung tasks from time to time. This fix will avoid possible loops and uncaught events.
2010-08-09 10:24:56 -04:00
si->flags &= ~SI_FL_WAIT_ROOM;
}
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
/* Note that we're trying to wake up in two conditions here :
* - special event, which needs the holder task attention
* - status indicating that the applet can go on working. This
* is rather hard because we might be blocking on output and
* don't want to wake up on input and vice-versa. The idea is
[MAJOR] stream_interface: fix the wakeup conditions for embedded iohandlers Now we stop relying on BF_READ_DONTWAIT, which is unrelated to the wakeups, and only consider activity to decide whether to wake the task up instead of considering the other side's activity. It is worth noting that the local stream interface's flags were not updated consecutively to a call to chk_snd(), which could possibly result in hung tasks from time to time. This fix will avoid possible loops and uncaught events.
2010-08-09 10:24:56 -04:00
* to only rely on the changes the chk_* might have performed.
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
*/
if (/* check stream interface changes */
[MAJOR] stream_interface: fix the wakeup conditions for embedded iohandlers Now we stop relying on BF_READ_DONTWAIT, which is unrelated to the wakeups, and only consider activity to decide whether to wake the task up instead of considering the other side's activity. It is worth noting that the local stream interface's flags were not updated consecutively to a call to chk_snd(), which could possibly result in hung tasks from time to time. This fix will avoid possible loops and uncaught events.
2010-08-09 10:24:56 -04:00
((old_flags & ~si->flags) & (SI_FL_WAIT_ROOM|SI_FL_WAIT_DATA)) ||
/* changes on the production side */
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
(si->ib->flags & (CF_READ_NULL|CF_READ_ERROR)) ||
[MAJOR] stream_interface: fix the wakeup conditions for embedded iohandlers Now we stop relying on BF_READ_DONTWAIT, which is unrelated to the wakeups, and only consider activity to decide whether to wake the task up instead of considering the other side's activity. It is worth noting that the local stream interface's flags were not updated consecutively to a call to chk_snd(), which could possibly result in hung tasks from time to time. This fix will avoid possible loops and uncaught events.
2010-08-09 10:24:56 -04:00
si->state != SI_ST_EST ||
(si->flags & SI_FL_ERR) ||
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
((si->ib->flags & CF_READ_PARTIAL) &&
[MAJOR] stream_interface: fix the wakeup conditions for embedded iohandlers Now we stop relying on BF_READ_DONTWAIT, which is unrelated to the wakeups, and only consider activity to decide whether to wake the task up instead of considering the other side's activity. It is worth noting that the local stream interface's flags were not updated consecutively to a call to chk_snd(), which could possibly result in hung tasks from time to time. This fix will avoid possible loops and uncaught events.
2010-08-09 10:24:56 -04:00
(!si->ib->to_forward || si->ib->cons->state != SI_ST_EST)) ||
/* changes on the consumption side */
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
(si->ob->flags & (CF_WRITE_NULL|CF_WRITE_ERROR)) ||
((si->ob->flags & CF_WRITE_ACTIVITY) &&
BUG/MEDIUM: stream-interface: don't wake the task up before end of transfer Recent commit d7ad9f5 ("MAJOR: channel: add a new flag CF_WAKE_WRITE to notify the task of writes") was not correct. It used to wake up the task as soon as there was some write activity and the flag was set, even if there were still some data to be forwarded. This resulted in process_session() being called a lot when transfering chunk-encoded HTTP responses made of very large chunks. The purpose of the flag is to wake up only a task waiting for some room and not the other ones, so it's totally counter-productive to wake it up as long as there are data to forward because the task will not be allowed to write anyway. Also, the commit above was taking some risks by not considering certain events anymore (eg: state != SI_ST_EST). While such events are not used at the moment, if some new features were developped in the future relying on these, it would be better that they could be notified when subscribing to the WAKE_WRITE event, so let's restore the condition.
2014-01-24 20:33:21 -05:00
((si->ob->flags & CF_SHUTW) ||
((si->ob->flags & CF_WAKE_WRITE) &&
(si->ob->prod->state != SI_ST_EST ||
(channel_is_empty(si->ob) && !si->ob->to_forward)))))) {
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
if (!(si->flags & SI_FL_DONT_WAKE) && si->owner)
task_wakeup(si->owner, TASK_WOKEN_IO);
}
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
if (si->ib->flags & CF_READ_ACTIVITY)
si->ib->flags &= ~CF_READ_DONTWAIT;
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
}
MAJOR: stream_int: use a common stream_int_shut*() functions regardless of the data layer Up to now, we had to use a shutr/shutw interface per data layer, which basically means 3 distinct functions when we include SSL : - generic stream_interface - sock_raw - sock_ssl With this change, the code located in the stream_interface manages all the stream_interface and buffer updates, and calls the data layer hooks when needed. At the moment, the socket layer hook had been implicitly considered as being a regular socket, so the si_shut*() functions call the normal shutdown() and EV_FD_CLR() functions on the fd if a socket layer is defined. This may change in the future. The stream_int_shut*() functions don't call EV_FD_CLR() so that they can later be embedded in lower layers. Thus, the si->data->shutr() is not called anymore and si->data->shutw() is called to close the data layer only (eg: only for SSL). Proceeding like this is very important because it's the only way to be able not to rely on these functions when called from the connection handlers, and call the data layers' instead.
2012-08-06 13:31:45 -04:00
/*
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
* This function performs a shutdown-read on a stream interface attached to an
* applet in a connected or init state (it does nothing for other states). It
* either shuts the read side or marks itself as closed. The buffer flags are
* updated to reflect the new state. If the stream interface has SI_FL_NOHALF,
* we also forward the close to the write side. The owner task is woken up if
MINOR: stream-int: make the shutr/shutw functions void This is to be more consistent with the other functions. The only reason why these functions used to return a value was to let the caller adjust polling by itself, but now their only callers were the si_shutr()/si_shutw() inline functions. Now these functions do not depend anymore on the connection. These connection variant of these functions now call conn_data_stop_recv()/conn_data_stop_send() before returning order not to require a return code anymore. The applet version does not need this at all.
2013-09-29 09:16:03 -04:00
* it exists.
MAJOR: stream_int: use a common stream_int_shut*() functions regardless of the data layer Up to now, we had to use a shutr/shutw interface per data layer, which basically means 3 distinct functions when we include SSL : - generic stream_interface - sock_raw - sock_ssl With this change, the code located in the stream_interface manages all the stream_interface and buffer updates, and calls the data layer hooks when needed. At the moment, the socket layer hook had been implicitly considered as being a regular socket, so the si_shut*() functions call the normal shutdown() and EV_FD_CLR() functions on the fd if a socket layer is defined. This may change in the future. The stream_int_shut*() functions don't call EV_FD_CLR() so that they can later be embedded in lower layers. Thus, the si->data->shutr() is not called anymore and si->data->shutw() is called to close the data layer only (eg: only for SSL). Proceeding like this is very important because it's the only way to be able not to rely on these functions when called from the connection handlers, and call the data layers' instead.
2012-08-06 13:31:45 -04:00
*/
MINOR: stream-int: make the shutr/shutw functions void This is to be more consistent with the other functions. The only reason why these functions used to return a value was to let the caller adjust polling by itself, but now their only callers were the si_shutr()/si_shutw() inline functions. Now these functions do not depend anymore on the connection. These connection variant of these functions now call conn_data_stop_recv()/conn_data_stop_send() before returning order not to require a return code anymore. The applet version does not need this at all.
2013-09-29 09:16:03 -04:00
static void stream_int_shutr(struct stream_interface *si)
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
{
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
si->ib->flags &= ~CF_SHUTR_NOW;
if (si->ib->flags & CF_SHUTR)
MINOR: stream-int: make the shutr/shutw functions void This is to be more consistent with the other functions. The only reason why these functions used to return a value was to let the caller adjust polling by itself, but now their only callers were the si_shutr()/si_shutw() inline functions. Now these functions do not depend anymore on the connection. These connection variant of these functions now call conn_data_stop_recv()/conn_data_stop_send() before returning order not to require a return code anymore. The applet version does not need this at all.
2013-09-29 09:16:03 -04:00
return;
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
si->ib->flags |= CF_SHUTR;
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
si->ib->rex = TICK_ETERNITY;
si->flags &= ~SI_FL_WAIT_ROOM;
if (si->state != SI_ST_EST && si->state != SI_ST_CON)
MINOR: stream-int: make the shutr/shutw functions void This is to be more consistent with the other functions. The only reason why these functions used to return a value was to let the caller adjust polling by itself, but now their only callers were the si_shutr()/si_shutw() inline functions. Now these functions do not depend anymore on the connection. These connection variant of these functions now call conn_data_stop_recv()/conn_data_stop_send() before returning order not to require a return code anymore. The applet version does not need this at all.
2013-09-29 09:16:03 -04:00
return;
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
if (si->ob->flags & CF_SHUTW) {
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
si->state = SI_ST_DIS;
si->exp = TICK_ETERNITY;
MAJOR: stream interface: remove the ->release function pointer Since last commit, we now have a pointer to the applet in the applet context. So we don't need the si->release function pointer anymore, it can be extracted from applet->applet.release. At many places, the ->release function was still tested for real connections while it is only limited to applets, so most of them were simply removed. For the remaining valid uses, a new inline function si_applet_release() was added to simplify the check and the call.
2013-10-24 14:10:45 -04:00
si_applet_release(si);
[BUG] stream_interface: only call si->release when both dirs are closed si->release() was called each time we closed one direction of a stream interface, while it should only have been called when both sides are closed. This bug is specific to 1.5 and only affects embedded tasks.
2010-09-07 10:16:50 -04:00
}
MAJOR: stream_int: use a common stream_int_shut*() functions regardless of the data layer Up to now, we had to use a shutr/shutw interface per data layer, which basically means 3 distinct functions when we include SSL : - generic stream_interface - sock_raw - sock_ssl With this change, the code located in the stream_interface manages all the stream_interface and buffer updates, and calls the data layer hooks when needed. At the moment, the socket layer hook had been implicitly considered as being a regular socket, so the si_shut*() functions call the normal shutdown() and EV_FD_CLR() functions on the fd if a socket layer is defined. This may change in the future. The stream_int_shut*() functions don't call EV_FD_CLR() so that they can later be embedded in lower layers. Thus, the si->data->shutr() is not called anymore and si->data->shutw() is called to close the data layer only (eg: only for SSL). Proceeding like this is very important because it's the only way to be able not to rely on these functions when called from the connection handlers, and call the data layers' instead.
2012-08-06 13:31:45 -04:00
else if (si->flags & SI_FL_NOHALF) {
/* we want to immediately forward this close to the write side */
return stream_int_shutw(si);
}
[MEDIUM] stream-interface: add a ->release callback When a connection is closed on a stream interface, some iohandlers will need to be informed in order to release some resources. This normally happens upon a shutr+shutw. It is the equivalent of the fd_delete() call which is done for real sockets, except that this time we release internal resources. It can also be used with real sockets because it does not cost anything else and might one day be useful.
2010-07-02 05:18:03 -04:00
MAJOR: stream_int: use a common stream_int_shut*() functions regardless of the data layer Up to now, we had to use a shutr/shutw interface per data layer, which basically means 3 distinct functions when we include SSL : - generic stream_interface - sock_raw - sock_ssl With this change, the code located in the stream_interface manages all the stream_interface and buffer updates, and calls the data layer hooks when needed. At the moment, the socket layer hook had been implicitly considered as being a regular socket, so the si_shut*() functions call the normal shutdown() and EV_FD_CLR() functions on the fd if a socket layer is defined. This may change in the future. The stream_int_shut*() functions don't call EV_FD_CLR() so that they can later be embedded in lower layers. Thus, the si->data->shutr() is not called anymore and si->data->shutw() is called to close the data layer only (eg: only for SSL). Proceeding like this is very important because it's the only way to be able not to rely on these functions when called from the connection handlers, and call the data layers' instead.
2012-08-06 13:31:45 -04:00
/* note that if the task exists, it must unregister itself once it runs */
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
if (!(si->flags & SI_FL_DONT_WAKE) && si->owner)
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
task_wakeup(si->owner, TASK_WOKEN_IO);
}
MAJOR: stream_int: use a common stream_int_shut*() functions regardless of the data layer Up to now, we had to use a shutr/shutw interface per data layer, which basically means 3 distinct functions when we include SSL : - generic stream_interface - sock_raw - sock_ssl With this change, the code located in the stream_interface manages all the stream_interface and buffer updates, and calls the data layer hooks when needed. At the moment, the socket layer hook had been implicitly considered as being a regular socket, so the si_shut*() functions call the normal shutdown() and EV_FD_CLR() functions on the fd if a socket layer is defined. This may change in the future. The stream_int_shut*() functions don't call EV_FD_CLR() so that they can later be embedded in lower layers. Thus, the si->data->shutr() is not called anymore and si->data->shutw() is called to close the data layer only (eg: only for SSL). Proceeding like this is very important because it's the only way to be able not to rely on these functions when called from the connection handlers, and call the data layers' instead.
2012-08-06 13:31:45 -04:00
/*
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
* This function performs a shutdown-write on a stream interface attached to an
* applet in a connected or init state (it does nothing for other states). It
* either shuts the write side or marks itself as closed. The buffer flags are
* updated to reflect the new state. It does also close everything if the SI
* was marked as being in error state. The owner task is woken up if it exists.
MAJOR: stream_int: use a common stream_int_shut*() functions regardless of the data layer Up to now, we had to use a shutr/shutw interface per data layer, which basically means 3 distinct functions when we include SSL : - generic stream_interface - sock_raw - sock_ssl With this change, the code located in the stream_interface manages all the stream_interface and buffer updates, and calls the data layer hooks when needed. At the moment, the socket layer hook had been implicitly considered as being a regular socket, so the si_shut*() functions call the normal shutdown() and EV_FD_CLR() functions on the fd if a socket layer is defined. This may change in the future. The stream_int_shut*() functions don't call EV_FD_CLR() so that they can later be embedded in lower layers. Thus, the si->data->shutr() is not called anymore and si->data->shutw() is called to close the data layer only (eg: only for SSL). Proceeding like this is very important because it's the only way to be able not to rely on these functions when called from the connection handlers, and call the data layers' instead.
2012-08-06 13:31:45 -04:00
*/
MINOR: stream-int: make the shutr/shutw functions void This is to be more consistent with the other functions. The only reason why these functions used to return a value was to let the caller adjust polling by itself, but now their only callers were the si_shutr()/si_shutw() inline functions. Now these functions do not depend anymore on the connection. These connection variant of these functions now call conn_data_stop_recv()/conn_data_stop_send() before returning order not to require a return code anymore. The applet version does not need this at all.
2013-09-29 09:16:03 -04:00
static void stream_int_shutw(struct stream_interface *si)
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
{
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
si->ob->flags &= ~CF_SHUTW_NOW;
if (si->ob->flags & CF_SHUTW)
MINOR: stream-int: make the shutr/shutw functions void This is to be more consistent with the other functions. The only reason why these functions used to return a value was to let the caller adjust polling by itself, but now their only callers were the si_shutr()/si_shutw() inline functions. Now these functions do not depend anymore on the connection. These connection variant of these functions now call conn_data_stop_recv()/conn_data_stop_send() before returning order not to require a return code anymore. The applet version does not need this at all.
2013-09-29 09:16:03 -04:00
return;
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
si->ob->flags |= CF_SHUTW;
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
si->ob->wex = TICK_ETERNITY;
si->flags &= ~SI_FL_WAIT_DATA;
switch (si->state) {
case SI_ST_EST:
MAJOR: stream_int: use a common stream_int_shut*() functions regardless of the data layer Up to now, we had to use a shutr/shutw interface per data layer, which basically means 3 distinct functions when we include SSL : - generic stream_interface - sock_raw - sock_ssl With this change, the code located in the stream_interface manages all the stream_interface and buffer updates, and calls the data layer hooks when needed. At the moment, the socket layer hook had been implicitly considered as being a regular socket, so the si_shut*() functions call the normal shutdown() and EV_FD_CLR() functions on the fd if a socket layer is defined. This may change in the future. The stream_int_shut*() functions don't call EV_FD_CLR() so that they can later be embedded in lower layers. Thus, the si->data->shutr() is not called anymore and si->data->shutw() is called to close the data layer only (eg: only for SSL). Proceeding like this is very important because it's the only way to be able not to rely on these functions when called from the connection handlers, and call the data layers' instead.
2012-08-06 13:31:45 -04:00
/* we have to shut before closing, otherwise some short messages
* may never leave the system, especially when there are remaining
* unread data in the socket input buffer, or when nolinger is set.
* However, if SI_FL_NOLINGER is explicitly set, we know there is
* no risk so we close both sides immediately.
*/
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
if (!(si->flags & (SI_FL_ERR | SI_FL_NOLINGER)) &&
!(si->ib->flags & (CF_SHUTR|CF_DONT_READ)))
MINOR: stream-int: make the shutr/shutw functions void This is to be more consistent with the other functions. The only reason why these functions used to return a value was to let the caller adjust polling by itself, but now their only callers were the si_shutr()/si_shutw() inline functions. Now these functions do not depend anymore on the connection. These connection variant of these functions now call conn_data_stop_recv()/conn_data_stop_send() before returning order not to require a return code anymore. The applet version does not need this at all.
2013-09-29 09:16:03 -04:00
return;
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
/* fall through */
case SI_ST_CON:
case SI_ST_CER:
[CRITICAL] session: correctly leave turn-around and queue states on abort When a client connection aborts while the server-side connection is in turn-around after a failed connection attempt, the turn-around timeout is reset in shutw() but the state is not changed. The session then remains stuck in this state forever. Change the QUE and TAR states to DIS just as we do for CER to fix this. This patch should be backported to 1.4.
2010-12-29 08:03:02 -05:00
case SI_ST_QUE:
case SI_ST_TAR:
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
/* Note that none of these states may happen with applets */
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
si->state = SI_ST_DIS;
MAJOR: stream interface: remove the ->release function pointer Since last commit, we now have a pointer to the applet in the applet context. So we don't need the si->release function pointer anymore, it can be extracted from applet->applet.release. At many places, the ->release function was still tested for real connections while it is only limited to applets, so most of them were simply removed. For the remaining valid uses, a new inline function si_applet_release() was added to simplify the check and the call.
2013-10-24 14:10:45 -04:00
si_applet_release(si);
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
default:
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
si->flags &= ~(SI_FL_WAIT_ROOM | SI_FL_NOLINGER);
si->ib->flags &= ~CF_SHUTR_NOW;
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
si->ib->flags |= CF_SHUTR;
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
si->ib->rex = TICK_ETERNITY;
si->exp = TICK_ETERNITY;
}
MAJOR: stream_int: use a common stream_int_shut*() functions regardless of the data layer Up to now, we had to use a shutr/shutw interface per data layer, which basically means 3 distinct functions when we include SSL : - generic stream_interface - sock_raw - sock_ssl With this change, the code located in the stream_interface manages all the stream_interface and buffer updates, and calls the data layer hooks when needed. At the moment, the socket layer hook had been implicitly considered as being a regular socket, so the si_shut*() functions call the normal shutdown() and EV_FD_CLR() functions on the fd if a socket layer is defined. This may change in the future. The stream_int_shut*() functions don't call EV_FD_CLR() so that they can later be embedded in lower layers. Thus, the si->data->shutr() is not called anymore and si->data->shutw() is called to close the data layer only (eg: only for SSL). Proceeding like this is very important because it's the only way to be able not to rely on these functions when called from the connection handlers, and call the data layers' instead.
2012-08-06 13:31:45 -04:00
/* note that if the task exists, it must unregister itself once it runs */
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
if (!(si->flags & SI_FL_DONT_WAKE) && si->owner)
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
task_wakeup(si->owner, TASK_WOKEN_IO);
}
/* default chk_rcv function for scheduled tasks */
CLEANUP: stream_interface: stop exporting socket layer functions Similarly to the previous patch, we don't need the socket-layer functions outside of stream_interface. They could even move to a file dedicated to applets, though that does not seem particularly useful at the moment.
2012-05-11 11:47:17 -04:00
static void stream_int_chk_rcv(struct stream_interface *si)
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
{
REORG/MAJOR: use "struct channel" instead of "struct buffer" This is a massive rename. We'll then split channel and buffer. This change needs a lot of cleanups. At many locations, the parameter or variable is still called "buf" which will become ambiguous. Also, the "struct channel" is still defined in buffers.h.
2012-07-02 09:11:27 -04:00
struct channel *ib = si->ib;
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
DPRINTF(stderr, "%s: si=%p, si->state=%d ib->flags=%08x ob->flags=%08x\n",
__FUNCTION__,
si, si->state, si->ib->flags, si->ob->flags);
CLEANUP: channel: remove any reference of the hijackers Hijackers were functions designed to inject data into channels in the distant past. They became unused around 1.3.16, and since there has not been any user of this mechanism to date, it's uncertain whether the mechanism still works (and it's not really useful anymore). So better remove it as well as the pointer it uses in the channel struct.
2012-11-11 17:05:39 -05:00
if (unlikely(si->state != SI_ST_EST || (ib->flags & (CF_SHUTR|CF_DONT_READ))))
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
return;
MAJOR: channel: stop relying on BF_FULL to take action This flag is quite complex to get right and updating it everywhere is a major pain, especially since the buffer/channel split. This is the first step of getting rid of it. Instead now it's dynamically computed whenever needed.
2012-08-27 14:46:07 -04:00
if (channel_full(ib)) {
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
/* stop reading */
MAJOR: channel: stop relying on BF_FULL to take action This flag is quite complex to get right and updating it everywhere is a major pain, especially since the buffer/channel split. This is the first step of getting rid of it. Instead now it's dynamically computed whenever needed.
2012-08-27 14:46:07 -04:00
si->flags |= SI_FL_WAIT_ROOM;
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
}
else {
/* (re)start reading */
si->flags &= ~SI_FL_WAIT_ROOM;
if (!(si->flags & SI_FL_DONT_WAKE) && si->owner)
task_wakeup(si->owner, TASK_WOKEN_IO);
}
}
/* default chk_snd function for scheduled tasks */
CLEANUP: stream_interface: stop exporting socket layer functions Similarly to the previous patch, we don't need the socket-layer functions outside of stream_interface. They could even move to a file dedicated to applets, though that does not seem particularly useful at the moment.
2012-05-11 11:47:17 -04:00
static void stream_int_chk_snd(struct stream_interface *si)
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
{
REORG/MAJOR: use "struct channel" instead of "struct buffer" This is a massive rename. We'll then split channel and buffer. This change needs a lot of cleanups. At many locations, the parameter or variable is still called "buf" which will become ambiguous. Also, the "struct channel" is still defined in buffers.h.
2012-07-02 09:11:27 -04:00
struct channel *ob = si->ob;
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
DPRINTF(stderr, "%s: si=%p, si->state=%d ib->flags=%08x ob->flags=%08x\n",
__FUNCTION__,
si, si->state, si->ib->flags, si->ob->flags);
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
if (unlikely(si->state != SI_ST_EST || (si->ob->flags & CF_SHUTW)))
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
return;
if (!(si->flags & SI_FL_WAIT_DATA) || /* not waiting for data */
MAJOR: channel: remove the BF_OUT_EMPTY flag This flag was very problematic because it was composite in that both changes to the pipe or to the buffer had to cause this flag to be updated, which is not always simple (eg: there may not even be a channel attached to a buffer at all). There were not that many users of this flags, mostly setters. So the flag got replaced with a macro which reports whether the channel is empty or not, by checking both the pipe and the buffer. One part of the change is sensible : the flag was also part of BF_MASK_STATIC, which is used by process_session() to rescan all analysers in case the flag's status changes. At first glance, none of the analysers seems to change its mind base on this flag when it is subject to change, so it seems fine not to add variation checks here. Otherwise it's possible that checking the buffer's output size is more useful than checking the flag's replacement.
2012-08-24 16:40:29 -04:00
channel_is_empty(ob)) /* called with nothing to send ! */
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
return;
/* Otherwise there are remaining data to be sent in the buffer,
* so we tell the handler.
*/
si->flags &= ~SI_FL_WAIT_DATA;
if (!tick_isset(ob->wex))
ob->wex = tick_add_ifset(now_ms, ob->wto);
if (!(si->flags & SI_FL_DONT_WAKE) && si->owner)
task_wakeup(si->owner, TASK_WOKEN_IO);
}
MEDIUM: stream-int: return the allocated appctx in stream_int_register_handler() The task returned by stream_int_register_handler() is never used, however we always need to access the appctx afterwards. So make it return the appctx instead. We already plan for it to fail, which is the reason for the addition of a few tests and the possibility for the HTTP analyser to return a status code 500.
2013-12-01 03:35:41 -05:00
/* Register an applet to handle a stream_interface as part of the
* stream interface's owner task. The SI will wake it up everytime it
* is solicited. The task's processing function must call the applet's
* function before returning. It must be deleted by the task handler
* using stream_int_unregister_handler(), possibly from within the
* function itself. It also pre-initializes the applet's context and
* returns it (or NULL in case it could not be allocated).
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
*/
MEDIUM: stream-int: return the allocated appctx in stream_int_register_handler() The task returned by stream_int_register_handler() is never used, however we always need to access the appctx afterwards. So make it return the appctx instead. We already plan for it to fail, which is the reason for the addition of a few tests and the possibility for the HTTP analyser to return a status code 500.
2013-12-01 03:35:41 -05:00
struct appctx *stream_int_register_handler(struct stream_interface *si, struct si_applet *app)
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
{
MAJOR: stream-interface: dynamically allocate the applet context From now on, a call to stream_int_register_handler() causes a call to si_alloc_appctx() and returns an initialized appctx for the current stream interface. If one was previously allocated, it is released. If the stream interface was attached to a connection, it is released as well. The appctx are allocated from the same pools as the connections, because they're substantially smaller in size, and we can't have both a connection and an appctx on an interface at any moment. In case of memory shortage, the call may return NULL, which is already handled by all consumers of stream_int_register_handler(). The field appctx was removed from the stream interface since we only rely on the endpoint now. On 32-bit, the stream_interface size went down from 108 to 44 bytes. On 64-bit, it went down from 144 to 64 bytes. This represents a memory saving of 160 bytes per session. It seems that a later improvement could be to move the call to stream_int_register_handler() to session.c for most cases.
2013-12-01 05:31:38 -05:00
struct appctx *appctx;
[MINOR] Fix build error in stream_int_register_handler() There is no parameter or variable fct in stream_int_register_handler() so the build fails when DPRINTF is active.
2011-08-12 19:03:51 -04:00
DPRINTF(stderr, "registering handler %p for si %p (was %p)\n", app, si, si->owner);
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
MAJOR: stream-interface: dynamically allocate the applet context From now on, a call to stream_int_register_handler() causes a call to si_alloc_appctx() and returns an initialized appctx for the current stream interface. If one was previously allocated, it is released. If the stream interface was attached to a connection, it is released as well. The appctx are allocated from the same pools as the connections, because they're substantially smaller in size, and we can't have both a connection and an appctx on an interface at any moment. In case of memory shortage, the call may return NULL, which is already handled by all consumers of stream_int_register_handler(). The field appctx was removed from the stream interface since we only rely on the endpoint now. On 32-bit, the stream_interface size went down from 108 to 44 bytes. On 64-bit, it went down from 144 to 64 bytes. This represents a memory saving of 160 bytes per session. It seems that a later improvement could be to move the call to stream_int_register_handler() to session.c for most cases.
2013-12-01 05:31:38 -05:00
appctx = si_alloc_appctx(si);
if (!si)
return NULL;
appctx_set_applet(appctx, app);
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
si->flags |= SI_FL_WAIT_DATA;
MEDIUM: stream-int: return the allocated appctx in stream_int_register_handler() The task returned by stream_int_register_handler() is never used, however we always need to access the appctx afterwards. So make it return the appctx instead. We already plan for it to fail, which is the reason for the addition of a few tests and the possibility for the HTTP analyser to return a status code 500.
2013-12-01 03:35:41 -05:00
return si_appctx(si);
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
}
/* Unregister a stream interface handler. This must be called by the handler task
CLEANUP: stream_interface: remove the external task type target Before connections were introduced, it was possible to connect an external task to a stream interface. However it was left as an exercise for the brave implementer to find how that ought to be done. The feature was broken since the introduction of connections and was never fixed since due to lack of users. Better remove this dead code now.
2012-11-11 17:14:16 -05:00
* itself when it detects that it is in the SI_ST_DIS state.
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
*/
void stream_int_unregister_handler(struct stream_interface *si)
{
MAJOR: stream interface: dynamically allocate the outgoing connection The outgoing connection is now allocated dynamically upon the first attempt to touch the connection's source or destination address. If this allocation fails, we fail on SN_ERR_RESOURCE. As we didn't use si->conn anymore, it was removed. The endpoints are released upon session_free(), on the error path, and upon a new transaction. That way we are able to carry the existing server's address across retries. The stream interfaces are not initialized anymore before session_complete(), so we could even think about allocating them dynamically as well, though that would not provide much savings. The session initialization now makes use of conn_new()/conn_free(). This slightly simplifies the code and makes it more logical. The connection initialization code is now shorter by about 120 bytes because it's done at once, allowing the compiler to remove all redundant initializations. The si_attach_applet() function now takes care of first detaching the existing endpoint, and it is called from stream_int_register_handler(), so we can safely remove the calls to si_release_endpoint() in the application code around this call. A call to si_detach() was made upon stream_int_unregister_handler() to ensure we always free the allocated connection if one was allocated in parallel to setting an applet (eg: detect HTTP proxy while proceeding with stats maybe).
2013-10-11 13:34:20 -04:00
si_detach(si);
[MINOR] stream_interface: add functions to support running as internal/external tasks It will soon be necessary to have stream interfaces running as part of the current task, or as independant tasks. For instance when we want to implement compression or SSL. It will also be used for applets running as stream interfaces. These new functions are used to perform exactly that. Note that it's still not easy to write a simple echo applet and more functions will likely be needed.
2009-09-05 14:57:35 -04:00
}
MEDIUM: connection: extract the send_proxy callback from proto_tcp This handshake handler must be independant, so move it away from proto_tcp. It has a dedicated connection flag. It is tested before I/O handlers and automatically removes the CO_FL_WAIT_L4_CONN flag upon success. It also sets the BF_WRITE_NULL flag on the stream interface and stops the SI timeout. However it does not perform the task_wakeup(), and relies on the data handler to do so for now. The SI wakeup will have to be moved elsewhere anyway.
2012-07-06 11:12:34 -04:00
/* This callback is used to send a valid PROXY protocol line to a socket being
MAJOR: make use of conn_{data|sock}_{poll|stop|want}* in connection handlers This is a second attempt at getting rid of FD_WAIT_*. Now the situation is much better since native I/O handlers can directly manipulate the FD using fd_{poll|want|stop}_* and the connection handlers manipulate connection-level flags using the conn_{data|sock}_* equivalent. Proceeding this way ensures that the connection flags always reflect the reality even after data<->handshake switches.
2012-08-09 08:45:22 -04:00
* established. It returns 0 if it fails in a fatal way or needs to poll to go
* further, otherwise it returns non-zero and removes itself from the connection's
MEDIUM: proxy-proto: don't use buffer flags in conn_si_send_proxy() These ones should only be handled by the stream interface at the end of the handshake now. Similarly a number of information are now taken at the connection level rather than at the data level (eg: shutdown). Fast polling updates have been used instead of slow ones since the function is only called by the connection handler.
2012-08-24 06:14:49 -04:00
* flags (the bit is provided in <flag> by the caller). It is designed to be
* called by the connection handler and relies on it to commit polling changes.
MEDIUM: connection: merge the send_proxy and local_send_proxy calls We used to have two very similar functions for sending a PROXY protocol line header. The reason is that the default one relies on the stream interface to retrieve the other end's address, while the "local" one performs a local address lookup and sends that instead (used by health checks). Now that the send_proxy_ofs is stored in the connection and not the stream interface, we can make the local_send_proxy rely on it and support partial sends. This also simplifies the code by removing the local_send_proxy function, making health checks use send_proxy_ofs, resulting in the removal of the CO_FL_LOCAL_SPROXY flag, and the associated test in the connection handler. The other flag, CO_FL_SI_SEND_PROXY was renamed without the "SI" part so that it is clear that it is not dedicated anymore to a usage with a stream interface.
2013-10-24 16:01:26 -04:00
* Note that it can emit a PROXY line by relying on the other end's address
* when the connection is attached to a stream interface, or by resolving the
* local address otherwise (also called a LOCAL line).
MEDIUM: connection: extract the send_proxy callback from proto_tcp This handshake handler must be independant, so move it away from proto_tcp. It has a dedicated connection flag. It is tested before I/O handlers and automatically removes the CO_FL_WAIT_L4_CONN flag upon success. It also sets the BF_WRITE_NULL flag on the stream interface and stops the SI timeout. However it does not perform the task_wakeup(), and relies on the data handler to do so for now. The SI wakeup will have to be moved elsewhere anyway.
2012-07-06 11:12:34 -04:00
*/
int conn_si_send_proxy(struct connection *conn, unsigned int flag)
{
/* we might have been called just after an asynchronous shutw */
MEDIUM: proxy-proto: don't use buffer flags in conn_si_send_proxy() These ones should only be handled by the stream interface at the end of the handshake now. Similarly a number of information are now taken at the connection level rather than at the data level (eg: shutdown). Fast polling updates have been used instead of slow ones since the function is only called by the connection handler.
2012-08-24 06:14:49 -04:00
if (conn->flags & CO_FL_SOCK_WR_SH)
MEDIUM: connection: extract the send_proxy callback from proto_tcp This handshake handler must be independant, so move it away from proto_tcp. It has a dedicated connection flag. It is tested before I/O handlers and automatically removes the CO_FL_WAIT_L4_CONN flag upon success. It also sets the BF_WRITE_NULL flag on the stream interface and stops the SI timeout. However it does not perform the task_wakeup(), and relies on the data handler to do so for now. The SI wakeup will have to be moved elsewhere anyway.
2012-07-06 11:12:34 -04:00
goto out_error;
MINOR: connection: add simple functions to report connection readiness conn_xprt_ready() reports if the transport layer is ready. conn_ctrl_ready() reports if the control layer is ready. The stream interface uses si_conn_ready() to report that the underlying connection is ready. This will be used for connection reuse in keep-alive mode.
2013-12-15 04:23:20 -05:00
if (!conn_ctrl_ready(conn))
MAJOR: connection: add two new flags to indicate readiness of control/transport Currently the control and transport layers of a connection are supposed to be initialized when their respective pointers are not NULL. This will not work anymore when we plan to reuse connections, because there is an asymmetry between the accept() side and the connect() side : - on accept() side, the fd is set first, then the ctrl layer then the transport layer ; upon error, they must be undone in the reverse order, then the FD must be closed. The FD must not be deleted if the control layer was not yet initialized ; - on the connect() side, the fd is set last and there is no reliable way to know if it has been initialized or not. In practice it's initialized to -1 first but this is hackish and supposes that local FDs only will be used forever. Also, there are even less solutions for keeping trace of the transport layer's state. Also it is possible to support delayed close() when something (eg: logs) tracks some information requiring the transport and/or control layers, making it even more difficult to clean them. So the proposed solution is to add two flags to the connection : - CO_FL_CTRL_READY is set when the control layer is initialized (fd_insert) and cleared after it's released (fd_delete). - CO_FL_XPRT_READY is set when the control layer is initialized (xprt->init) and cleared after it's released (xprt->close). The functions have been adapted to rely on this and not on the pointers anymore. conn_xprt_close() was unused and dangerous : it did not close the control layer (eg: the socket itself) but still marks the transport layer as closed, preventing any future call to conn_full_close() from finishing the job. The problem comes from conn_full_close() in fact. It needs to close the xprt and ctrl layers independantly. After that we're still having an issue : we don't know based on ->ctrl alone whether the fd was registered or not. For this we use the two new flags CO_FL_XPRT_READY and CO_FL_CTRL_READY. We now rely on this and not on conn->xprt nor conn->ctrl anymore to decide what remains to be done on the connection. In order not to miss some flag assignments, we introduce conn_ctrl_init() to initialize the control layer, register the fd using fd_insert() and set the flag, and conn_ctrl_close() which unregisters the fd and removes the flag, but only if the transport layer was closed. Similarly, at the transport layer, conn_xprt_init() calls ->init and sets the flag, while conn_xprt_close() checks the flag, calls ->close and clears the flag, regardless xprt_ctx or xprt_st. This also ensures that the ->init and the ->close functions are called only once each and in the correct order. Note that conn_xprt_close() does nothing if the transport layer is still tracked. conn_full_close() now simply calls conn_xprt_close() then conn_full_close() in turn, which do nothing if CO_FL_XPRT_TRACKED is set. In order to handle the error path, we also provide conn_force_close() which ignores CO_FL_XPRT_TRACKED and closes the transport and the control layers in turns. All relevant instances of fd_delete() have been replaced with conn_force_close(). Now we always know what state the connection is in and we can expect to split its initialization.
2013-10-21 10:30:56 -04:00
goto out_error;
MEDIUM: connection: add check for readiness in I/O handlers The recv/send callbacks must check for readiness themselves instead of having their callers do it. This will strengthen the test and will also ensure we never refrain from calling a handshake handler because a direction is being polled while the other one is ready.
2014-01-20 09:13:07 -05:00
if (!fd_send_ready(conn->t.sock.fd))
goto out_wait;
MEDIUM: connection: extract the send_proxy callback from proto_tcp This handshake handler must be independant, so move it away from proto_tcp. It has a dedicated connection flag. It is tested before I/O handlers and automatically removes the CO_FL_WAIT_L4_CONN flag upon success. It also sets the BF_WRITE_NULL flag on the stream interface and stops the SI timeout. However it does not perform the task_wakeup(), and relies on the data handler to do so for now. The SI wakeup will have to be moved elsewhere anyway.
2012-07-06 11:12:34 -04:00
/* If we have a PROXY line to send, we'll use this to validate the
* connection, in which case the connection is validated only once
* we've sent the whole proxy line. Otherwise we use connect().
*/
MEDIUM: connection: move the send_proxy offset to the connection Till now the send_proxy_ofs field remained in the stream interface, but since the dynamic allocation of the connection, it makes a lot of sense to move that into the connection instead of the stream interface, since it will not be statically allocated for each session. Also, it turns out that moving it to the connection fils an alignment hole on 64 bit architectures so it does not consume more memory, and removing it from the stream interface was an opportunity to correctly reorder fields and reduce the stream interface's size from 160 to 144 bytes (-10%). This is 32 bytes saved per session.
2013-10-24 15:10:08 -04:00
while (conn->send_proxy_ofs) {
MEDIUM: connection: extract the send_proxy callback from proto_tcp This handshake handler must be independant, so move it away from proto_tcp. It has a dedicated connection flag. It is tested before I/O handlers and automatically removes the CO_FL_WAIT_L4_CONN flag upon success. It also sets the BF_WRITE_NULL flag on the stream interface and stops the SI timeout. However it does not perform the task_wakeup(), and relies on the data handler to do so for now. The SI wakeup will have to be moved elsewhere anyway.
2012-07-06 11:12:34 -04:00
int ret;
/* The target server expects a PROXY line to be sent first.
* If the send_proxy_ofs is negative, it corresponds to the
* offset to start sending from then end of the proxy string
* (which is recomputed every time since it's constant). If
* it is positive, it means we have to send from the start.
MEDIUM: connection: merge the send_proxy and local_send_proxy calls We used to have two very similar functions for sending a PROXY protocol line header. The reason is that the default one relies on the stream interface to retrieve the other end's address, while the "local" one performs a local address lookup and sends that instead (used by health checks). Now that the send_proxy_ofs is stored in the connection and not the stream interface, we can make the local_send_proxy rely on it and support partial sends. This also simplifies the code by removing the local_send_proxy function, making health checks use send_proxy_ofs, resulting in the removal of the CO_FL_LOCAL_SPROXY flag, and the associated test in the connection handler. The other flag, CO_FL_SI_SEND_PROXY was renamed without the "SI" part so that it is clear that it is not dedicated anymore to a usage with a stream interface.
2013-10-24 16:01:26 -04:00
* We can only send a "normal" PROXY line when the connection
* is attached to a stream interface. Otherwise we can only
* send a LOCAL line (eg: for use with health checks).
MEDIUM: connection: extract the send_proxy callback from proto_tcp This handshake handler must be independant, so move it away from proto_tcp. It has a dedicated connection flag. It is tested before I/O handlers and automatically removes the CO_FL_WAIT_L4_CONN flag upon success. It also sets the BF_WRITE_NULL flag on the stream interface and stops the SI timeout. However it does not perform the task_wakeup(), and relies on the data handler to do so for now. The SI wakeup will have to be moved elsewhere anyway.
2012-07-06 11:12:34 -04:00
*/
MEDIUM: connection: merge the send_proxy and local_send_proxy calls We used to have two very similar functions for sending a PROXY protocol line header. The reason is that the default one relies on the stream interface to retrieve the other end's address, while the "local" one performs a local address lookup and sends that instead (used by health checks). Now that the send_proxy_ofs is stored in the connection and not the stream interface, we can make the local_send_proxy rely on it and support partial sends. This also simplifies the code by removing the local_send_proxy function, making health checks use send_proxy_ofs, resulting in the removal of the CO_FL_LOCAL_SPROXY flag, and the associated test in the connection handler. The other flag, CO_FL_SI_SEND_PROXY was renamed without the "SI" part so that it is clear that it is not dedicated anymore to a usage with a stream interface.
2013-10-24 16:01:26 -04:00
if (conn->data == &si_conn_cb) {
struct stream_interface *si = conn->owner;
struct connection *remote = objt_conn(si->ob->prod->end);
if (remote)
ret = make_proxy_line(trash.str, trash.size, &remote->addr.from, &remote->addr.to);
else
ret = make_proxy_line(trash.str, trash.size, NULL, NULL);
}
else {
/* The target server expects a LOCAL line to be sent first. Retrieving
* local or remote addresses may fail until the connection is established.
*/
conn_get_from_addr(conn);
if (!(conn->flags & CO_FL_ADDR_FROM_SET))
goto out_wait;
conn_get_to_addr(conn);
if (!(conn->flags & CO_FL_ADDR_TO_SET))
goto out_wait;
ret = make_proxy_line(trash.str, trash.size, &conn->addr.from, &conn->addr.to);
}
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
MEDIUM: connection: extract the send_proxy callback from proto_tcp This handshake handler must be independant, so move it away from proto_tcp. It has a dedicated connection flag. It is tested before I/O handlers and automatically removes the CO_FL_WAIT_L4_CONN flag upon success. It also sets the BF_WRITE_NULL flag on the stream interface and stops the SI timeout. However it does not perform the task_wakeup(), and relies on the data handler to do so for now. The SI wakeup will have to be moved elsewhere anyway.
2012-07-06 11:12:34 -04:00
if (!ret)
goto out_error;
MEDIUM: connection: move the send_proxy offset to the connection Till now the send_proxy_ofs field remained in the stream interface, but since the dynamic allocation of the connection, it makes a lot of sense to move that into the connection instead of the stream interface, since it will not be statically allocated for each session. Also, it turns out that moving it to the connection fils an alignment hole on 64 bit architectures so it does not consume more memory, and removing it from the stream interface was an opportunity to correctly reorder fields and reduce the stream interface's size from 160 to 144 bytes (-10%). This is 32 bytes saved per session.
2013-10-24 15:10:08 -04:00
if (conn->send_proxy_ofs > 0)
conn->send_proxy_ofs = -ret; /* first call */
MEDIUM: connection: extract the send_proxy callback from proto_tcp This handshake handler must be independant, so move it away from proto_tcp. It has a dedicated connection flag. It is tested before I/O handlers and automatically removes the CO_FL_WAIT_L4_CONN flag upon success. It also sets the BF_WRITE_NULL flag on the stream interface and stops the SI timeout. However it does not perform the task_wakeup(), and relies on the data handler to do so for now. The SI wakeup will have to be moved elsewhere anyway.
2012-07-06 11:12:34 -04:00
MEDIUM: proxy-proto: don't use buffer flags in conn_si_send_proxy() These ones should only be handled by the stream interface at the end of the handshake now. Similarly a number of information are now taken at the connection level rather than at the data level (eg: shutdown). Fast polling updates have been used instead of slow ones since the function is only called by the connection handler.
2012-08-24 06:14:49 -04:00
/* we have to send trash from (ret+sp for -sp bytes). If the
* data layer has a pending write, we'll also set MSG_MORE.
*/
MEDIUM: connection: move the send_proxy offset to the connection Till now the send_proxy_ofs field remained in the stream interface, but since the dynamic allocation of the connection, it makes a lot of sense to move that into the connection instead of the stream interface, since it will not be statically allocated for each session. Also, it turns out that moving it to the connection fils an alignment hole on 64 bit architectures so it does not consume more memory, and removing it from the stream interface was an opportunity to correctly reorder fields and reduce the stream interface's size from 160 to 144 bytes (-10%). This is 32 bytes saved per session.
2013-10-24 15:10:08 -04:00
ret = send(conn->t.sock.fd, trash.str + ret + conn->send_proxy_ofs, -conn->send_proxy_ofs,
MEDIUM: proxy-proto: don't use buffer flags in conn_si_send_proxy() These ones should only be handled by the stream interface at the end of the handshake now. Similarly a number of information are now taken at the connection level rather than at the data level (eg: shutdown). Fast polling updates have been used instead of slow ones since the function is only called by the connection handler.
2012-08-24 06:14:49 -04:00
(conn->flags & CO_FL_DATA_WR_ENA) ? MSG_MORE : 0);
MEDIUM: connection: extract the send_proxy callback from proto_tcp This handshake handler must be independant, so move it away from proto_tcp. It has a dedicated connection flag. It is tested before I/O handlers and automatically removes the CO_FL_WAIT_L4_CONN flag upon success. It also sets the BF_WRITE_NULL flag on the stream interface and stops the SI timeout. However it does not perform the task_wakeup(), and relies on the data handler to do so for now. The SI wakeup will have to be moved elsewhere anyway.
2012-07-06 11:12:34 -04:00
if (ret == 0)
goto out_wait;
if (ret < 0) {
BUG/MEDIUM: fix broken send_proxy on FreeBSD David Berard reported that send-proxy was broken on FreeBSD and tracked the issue to be an error returned by send(). We already had the same issue in the past in another area which was addressed by the following commit : 0ea0cf6 BUG: raw_sock: also consider ENOTCONN in addition to EAGAIN In fact, on Linux send() returns EAGAIN when the connection is not yet established while other OSes return ENOTCONN. Let's consider ENOTCONN for send-proxy there as the same as EAGAIN. David confirmed that this change properly fixed the issue. Another place was affected as well (health checks with send-proxy), and was fixed. This fix does not need any backport since it only affects 1.5.
2013-09-03 03:02:11 -04:00
if (errno == EAGAIN || errno == ENOTCONN)
MEDIUM: connection: extract the send_proxy callback from proto_tcp This handshake handler must be independant, so move it away from proto_tcp. It has a dedicated connection flag. It is tested before I/O handlers and automatically removes the CO_FL_WAIT_L4_CONN flag upon success. It also sets the BF_WRITE_NULL flag on the stream interface and stops the SI timeout. However it does not perform the task_wakeup(), and relies on the data handler to do so for now. The SI wakeup will have to be moved elsewhere anyway.
2012-07-06 11:12:34 -04:00
goto out_wait;
BUG/MINOR: connection: check EINTR when sending a PROXY header PROXY protocol header was not tolerant to signals, so it might cause a connection to report an error if a signal comes in at the exact same moment the send is done. This is 1.5-specific and does not need any backport.
2013-12-04 17:37:56 -05:00
if (errno == EINTR)
continue;
MEDIUM: connection: set the socket shutdown flags on socket errors When we get a hard error from a syscall indicating the socket is dead, it makes sense to set the CO_FL_SOCK_WR_SH and CO_FL_SOCK_RD_SH flags to indicate that the socket may not be used anymore. It will ease the error processing in health checks where the state of socket is very important. We'll also be able to avoid some setsockopt(nolinger) after an error. For now, the rest of the code is not impacted because CO_FL_ERROR is always tested prior to these flags.
2013-12-04 17:44:10 -05:00
conn->flags |= CO_FL_SOCK_RD_SH | CO_FL_SOCK_WR_SH;
MEDIUM: connection: extract the send_proxy callback from proto_tcp This handshake handler must be independant, so move it away from proto_tcp. It has a dedicated connection flag. It is tested before I/O handlers and automatically removes the CO_FL_WAIT_L4_CONN flag upon success. It also sets the BF_WRITE_NULL flag on the stream interface and stops the SI timeout. However it does not perform the task_wakeup(), and relies on the data handler to do so for now. The SI wakeup will have to be moved elsewhere anyway.
2012-07-06 11:12:34 -04:00
goto out_error;
}
MEDIUM: connection: move the send_proxy offset to the connection Till now the send_proxy_ofs field remained in the stream interface, but since the dynamic allocation of the connection, it makes a lot of sense to move that into the connection instead of the stream interface, since it will not be statically allocated for each session. Also, it turns out that moving it to the connection fils an alignment hole on 64 bit architectures so it does not consume more memory, and removing it from the stream interface was an opportunity to correctly reorder fields and reduce the stream interface's size from 160 to 144 bytes (-10%). This is 32 bytes saved per session.
2013-10-24 15:10:08 -04:00
conn->send_proxy_ofs += ret; /* becomes zero once complete */
if (conn->send_proxy_ofs != 0)
MEDIUM: connection: extract the send_proxy callback from proto_tcp This handshake handler must be independant, so move it away from proto_tcp. It has a dedicated connection flag. It is tested before I/O handlers and automatically removes the CO_FL_WAIT_L4_CONN flag upon success. It also sets the BF_WRITE_NULL flag on the stream interface and stops the SI timeout. However it does not perform the task_wakeup(), and relies on the data handler to do so for now. The SI wakeup will have to be moved elsewhere anyway.
2012-07-06 11:12:34 -04:00
goto out_wait;
/* OK we've sent the whole line, we're connected */
BUG/MINOR: connection: check EINTR when sending a PROXY header PROXY protocol header was not tolerant to signals, so it might cause a connection to report an error if a signal comes in at the exact same moment the send is done. This is 1.5-specific and does not need any backport.
2013-12-04 17:37:56 -05:00
break;
MEDIUM: connection: extract the send_proxy callback from proto_tcp This handshake handler must be independant, so move it away from proto_tcp. It has a dedicated connection flag. It is tested before I/O handlers and automatically removes the CO_FL_WAIT_L4_CONN flag upon success. It also sets the BF_WRITE_NULL flag on the stream interface and stops the SI timeout. However it does not perform the task_wakeup(), and relies on the data handler to do so for now. The SI wakeup will have to be moved elsewhere anyway.
2012-07-06 11:12:34 -04:00
}
MEDIUM: proxy-proto: don't use buffer flags in conn_si_send_proxy() These ones should only be handled by the stream interface at the end of the handshake now. Similarly a number of information are now taken at the connection level rather than at the data level (eg: shutdown). Fast polling updates have been used instead of slow ones since the function is only called by the connection handler.
2012-08-24 06:14:49 -04:00
/* The connection is ready now, simply return and let the connection
* handler notify upper layers if needed.
MEDIUM: connection: extract the send_proxy callback from proto_tcp This handshake handler must be independant, so move it away from proto_tcp. It has a dedicated connection flag. It is tested before I/O handlers and automatically removes the CO_FL_WAIT_L4_CONN flag upon success. It also sets the BF_WRITE_NULL flag on the stream interface and stops the SI timeout. However it does not perform the task_wakeup(), and relies on the data handler to do so for now. The SI wakeup will have to be moved elsewhere anyway.
2012-07-06 11:12:34 -04:00
*/
if (conn->flags & CO_FL_WAIT_L4_CONN)
conn->flags &= ~CO_FL_WAIT_L4_CONN;
conn->flags &= ~flag;
MAJOR: make use of conn_{data|sock}_{poll|stop|want}* in connection handlers This is a second attempt at getting rid of FD_WAIT_*. Now the situation is much better since native I/O handlers can directly manipulate the FD using fd_{poll|want|stop}_* and the connection handlers manipulate connection-level flags using the conn_{data|sock}_* equivalent. Proceeding this way ensures that the connection flags always reflect the reality even after data<->handshake switches.
2012-08-09 08:45:22 -04:00
return 1;
MEDIUM: connection: extract the send_proxy callback from proto_tcp This handshake handler must be independant, so move it away from proto_tcp. It has a dedicated connection flag. It is tested before I/O handlers and automatically removes the CO_FL_WAIT_L4_CONN flag upon success. It also sets the BF_WRITE_NULL flag on the stream interface and stops the SI timeout. However it does not perform the task_wakeup(), and relies on the data handler to do so for now. The SI wakeup will have to be moved elsewhere anyway.
2012-07-06 11:12:34 -04:00
out_error:
MAJOR: make use of conn_{data|sock}_{poll|stop|want}* in connection handlers This is a second attempt at getting rid of FD_WAIT_*. Now the situation is much better since native I/O handlers can directly manipulate the FD using fd_{poll|want|stop}_* and the connection handlers manipulate connection-level flags using the conn_{data|sock}_* equivalent. Proceeding this way ensures that the connection flags always reflect the reality even after data<->handshake switches.
2012-08-09 08:45:22 -04:00
/* Write error on the file descriptor */
MEDIUM: connection: extract the send_proxy callback from proto_tcp This handshake handler must be independant, so move it away from proto_tcp. It has a dedicated connection flag. It is tested before I/O handlers and automatically removes the CO_FL_WAIT_L4_CONN flag upon success. It also sets the BF_WRITE_NULL flag on the stream interface and stops the SI timeout. However it does not perform the task_wakeup(), and relies on the data handler to do so for now. The SI wakeup will have to be moved elsewhere anyway.
2012-07-06 11:12:34 -04:00
conn->flags |= CO_FL_ERROR;
MAJOR: make use of conn_{data|sock}_{poll|stop|want}* in connection handlers This is a second attempt at getting rid of FD_WAIT_*. Now the situation is much better since native I/O handlers can directly manipulate the FD using fd_{poll|want|stop}_* and the connection handlers manipulate connection-level flags using the conn_{data|sock}_* equivalent. Proceeding this way ensures that the connection flags always reflect the reality even after data<->handshake switches.
2012-08-09 08:45:22 -04:00
return 0;
MEDIUM: connection: extract the send_proxy callback from proto_tcp This handshake handler must be independant, so move it away from proto_tcp. It has a dedicated connection flag. It is tested before I/O handlers and automatically removes the CO_FL_WAIT_L4_CONN flag upon success. It also sets the BF_WRITE_NULL flag on the stream interface and stops the SI timeout. However it does not perform the task_wakeup(), and relies on the data handler to do so for now. The SI wakeup will have to be moved elsewhere anyway.
2012-07-06 11:12:34 -04:00
out_wait:
MEDIUM: proxy-proto: don't use buffer flags in conn_si_send_proxy() These ones should only be handled by the stream interface at the end of the handshake now. Similarly a number of information are now taken at the connection level rather than at the data level (eg: shutdown). Fast polling updates have been used instead of slow ones since the function is only called by the connection handler.
2012-08-24 06:14:49 -04:00
__conn_sock_stop_recv(conn);
MEDIUM: connection: remove conn_{data,sock}_poll_{recv,send} We simply remove these functions and replace their calls with the appropriate ones : - if we're in the data phase, we can simply report wait on the FD - if we're in the socket phase, we may also have to signal the desire to read/write on the socket because it might not be active yet.
2014-01-22 14:02:06 -05:00
fd_cant_send(conn->t.sock.fd);
MAJOR: make use of conn_{data|sock}_{poll|stop|want}* in connection handlers This is a second attempt at getting rid of FD_WAIT_*. Now the situation is much better since native I/O handlers can directly manipulate the FD using fd_{poll|want|stop}_* and the connection handlers manipulate connection-level flags using the conn_{data|sock}_* equivalent. Proceeding this way ensures that the connection flags always reflect the reality even after data<->handshake switches.
2012-08-09 08:45:22 -04:00
return 0;
MEDIUM: connection: extract the send_proxy callback from proto_tcp This handshake handler must be independant, so move it away from proto_tcp. It has a dedicated connection flag. It is tested before I/O handlers and automatically removes the CO_FL_WAIT_L4_CONN flag upon success. It also sets the BF_WRITE_NULL flag on the stream interface and stops the SI timeout. However it does not perform the task_wakeup(), and relies on the data handler to do so for now. The SI wakeup will have to be moved elsewhere anyway.
2012-07-06 11:12:34 -04:00
}
MEDIUM: stream-int: implement a very simplistic idle connection manager Idle connections are not monitored right now. So if a server closes after a response without advertising it, it won't be detected until a next request wants to use the connection. This is a bit problematic because it unnecessarily maintains file descriptors and sockets in an idle state. This patch implements a very simple idle connection manager for the stream interface. It presents itself as an I/O callback. The HTTP engine enables it when it recycles a connection. If a close or an error is detected on the underlying socket, it tries to drain as much data as possible from the socket, detect the close and responds with a close as well, then detaches from the stream interface.
2013-12-16 18:00:28 -05:00
/* Tiny I/O callback called on recv/send I/O events on idle connections.
* It simply sets the CO_FL_SOCK_RD_SH flag so that si_idle_conn_wake_cb()
* is notified and can kill the connection.
*/
static void si_idle_conn_null_cb(struct connection *conn)
{
if (conn->flags & (CO_FL_ERROR | CO_FL_SOCK_RD_SH))
return;
MEDIUM: connection: update callers of ctrl->drain() to use conn_drain() Now we can more safely rely on the connection state to decide how to drain and what to do when data are drained. Callers don't need to manipulate the file descriptor's state anymore. Note that it also removes the need for the fix ea90063 ("BUG/MEDIUM: stream-int: fix the keep-alive idle connection handler") since conn_drain() correctly sets the polling flags.
2014-01-20 06:10:52 -05:00
if (fdtab[conn->t.sock.fd].ev & (FD_POLL_ERR|FD_POLL_HUP)) {
fdtab[conn->t.sock.fd].linger_risk = 0;
MEDIUM: stream-int: implement a very simplistic idle connection manager Idle connections are not monitored right now. So if a server closes after a response without advertising it, it won't be detected until a next request wants to use the connection. This is a bit problematic because it unnecessarily maintains file descriptors and sockets in an idle state. This patch implements a very simple idle connection manager for the stream interface. It presents itself as an I/O callback. The HTTP engine enables it when it recycles a connection. If a close or an error is detected on the underlying socket, it tries to drain as much data as possible from the socket, detect the close and responds with a close as well, then detaches from the stream interface.
2013-12-16 18:00:28 -05:00
conn->flags |= CO_FL_SOCK_RD_SH;
MEDIUM: connection: update callers of ctrl->drain() to use conn_drain() Now we can more safely rely on the connection state to decide how to drain and what to do when data are drained. Callers don't need to manipulate the file descriptor's state anymore. Note that it also removes the need for the fix ea90063 ("BUG/MEDIUM: stream-int: fix the keep-alive idle connection handler") since conn_drain() correctly sets the polling flags.
2014-01-20 06:10:52 -05:00
}
else {
conn_drain(conn);
}
MEDIUM: stream-int: implement a very simplistic idle connection manager Idle connections are not monitored right now. So if a server closes after a response without advertising it, it won't be detected until a next request wants to use the connection. This is a bit problematic because it unnecessarily maintains file descriptors and sockets in an idle state. This patch implements a very simple idle connection manager for the stream interface. It presents itself as an I/O callback. The HTTP engine enables it when it recycles a connection. If a close or an error is detected on the underlying socket, it tries to drain as much data as possible from the socket, detect the close and responds with a close as well, then detaches from the stream interface.
2013-12-16 18:00:28 -05:00
/* disable draining if we were called and have no drain function */
if (!conn->ctrl->drain)
__conn_data_stop_recv(conn);
}
/* Callback to be used by connection I/O handlers when some activity is detected
* on an idle server connection. Its main purpose is to kill the connection once
* a close was detected on it. It returns 0 if it did nothing serious, or -1 if
* it killed the connection.
*/
static int si_idle_conn_wake_cb(struct connection *conn)
{
struct stream_interface *si = conn->owner;
if (!conn_ctrl_ready(conn))
return 0;
if (conn->flags & (CO_FL_ERROR | CO_FL_SOCK_RD_SH)) {
/* warning, we can't do anything on <conn> after this call ! */
conn_force_close(conn);
conn_free(conn);
si->end = NULL;
return -1;
}
return 0;
}
MEDIUM: stream_interface: offer a generic function for connection updates We need to have a generic function to be called by upper layers when buffer flags have been updated (the si->update function). At the moment, both sock_raw and sock_ssl had their own which basically was a copy-paste. Since these functions are only used to update stream interface flags, it is logical to have them handled by the stream interface code. This allowed us to remove the stream_interface-specific update function from sock_raw and sock_ssl which now use the generic code. The stream_sock_update_conn callback has also been more appropriately renamed conn_notify_si() since it's meant to be called by lower layers to notify the SI and possibly upper layers about incoming changes.
2012-08-20 06:06:26 -04:00
/* Callback to be used by connection I/O handlers upon completion. It differs from
MINOR: connection: provide a generic data layer wakeup callback Instead of calling conn_notify_si() from the connection handler, we now call data->wake(), which will allow us to use a different callback with health checks. Note that we still rely on a flag in order to decide whether or not to call this function. The reason is that with embryonic sessions, the callback is already initialized to si_conn_cb without the flag, and we can't call the SI notify function in the leave path before the stream interface is initialized. This issue should be addressed by involving a different data_cb for embryonic sessions and for stream interfaces, that would be changed during session_complete() for the final data_cb.
2012-10-02 14:07:22 -04:00
* the update function in that it is designed to be called by lower layers after I/O
MEDIUM: stream_interface: offer a generic function for connection updates We need to have a generic function to be called by upper layers when buffer flags have been updated (the si->update function). At the moment, both sock_raw and sock_ssl had their own which basically was a copy-paste. Since these functions are only used to update stream interface flags, it is logical to have them handled by the stream interface code. This allowed us to remove the stream_interface-specific update function from sock_raw and sock_ssl which now use the generic code. The stream_sock_update_conn callback has also been more appropriately renamed conn_notify_si() since it's meant to be called by lower layers to notify the SI and possibly upper layers about incoming changes.
2012-08-20 06:06:26 -04:00
* events have been completed. It will also try to wake the associated task up if
MAJOR: stream-interface: don't commit polling changes in every callback It's more efficient to centralize polling changes, which is already done in the connection handler. So now all I/O callbacks just change flags and rely on the connection handler for the commit. The special case of the send loop is handled by the chk_snd() function which does an update at the end.
2012-08-24 06:52:22 -04:00
* an important event requires special handling. It relies on the connection handler
MEDIUM: connection: make it possible for data->wake to return an error Just like ->init(), ->wake() may now be used to return an error and abort the connection. Currently this is not used but will be with embryonic sessions.
2012-10-03 15:12:16 -04:00
* to commit any polling updates. The function always returns 0.
MEDIUM: stream_interface: offer a generic function for connection updates We need to have a generic function to be called by upper layers when buffer flags have been updated (the si->update function). At the moment, both sock_raw and sock_ssl had their own which basically was a copy-paste. Since these functions are only used to update stream interface flags, it is logical to have them handled by the stream interface code. This allowed us to remove the stream_interface-specific update function from sock_raw and sock_ssl which now use the generic code. The stream_sock_update_conn callback has also been more appropriately renamed conn_notify_si() since it's meant to be called by lower layers to notify the SI and possibly upper layers about incoming changes.
2012-08-20 06:06:26 -04:00
*/
MEDIUM: connection: make it possible for data->wake to return an error Just like ->init(), ->wake() may now be used to return an error and abort the connection. Currently this is not used but will be with embryonic sessions.
2012-10-03 15:12:16 -04:00
static int si_conn_wake_cb(struct connection *conn)
MAJOR: remove the stream interface and task management code from sock_* The socket data layer code must only focus on moving data between a socket and a buffer. We need a special stream interface handler to update the stream interface and the file descriptor status. At the moment the code works but suffers from a race condition caused by its API : the read/write callbacks still make use of the fd instead of using the connection. And when a double shutdown is performed, a call to ->write() after ->read() processed an error results in dereferencing a NULL fdtab[]->owner. This is only a temporary issue which doesn't need to be fixed now since this will automatically go away when the functions change to use the connection instead.
2012-07-23 12:24:25 -04:00
{
MEDIUM: connection: make use of the owner instead of container_of This way the connection can become independant on the stream interface.
2012-09-27 16:20:41 -04:00
struct stream_interface *si = conn->owner;
MAJOR: remove the stream interface and task management code from sock_* The socket data layer code must only focus on moving data between a socket and a buffer. We need a special stream interface handler to update the stream interface and the file descriptor status. At the moment the code works but suffers from a race condition caused by its API : the read/write callbacks still make use of the fd instead of using the connection. And when a double shutdown is performed, a call to ->write() after ->read() processed an error results in dereferencing a NULL fdtab[]->owner. This is only a temporary issue which doesn't need to be fixed now since this will automatically go away when the functions change to use the connection instead.
2012-07-23 12:24:25 -04:00
DPRINTF(stderr, "%s: si=%p, si->state=%d ib->flags=%08x ob->flags=%08x\n",
__FUNCTION__,
si, si->state, si->ib->flags, si->ob->flags);
MEDIUM: stream_interface: centralize the SI_FL_ERR management It's better to have only stream_sock_update_conn() handle the conversion of the CO_FL_ERROR flag to SI_FL_ERR than having it in each and every I/O callback.
2012-07-23 13:19:51 -04:00
if (conn->flags & CO_FL_ERROR)
si->flags |= SI_FL_ERR;
MAJOR: connection: add a new CO_FL_CONNECTED flag This new flag is used to indicate that the connection was already connected. It can be used by I/O handlers to know that a connection has just completed. It is used by stream_sock_update_conn(), allowing the sock_opt handlers not to manipulate the SI timeout nor the BF_WRITE_NULL flag anymore.
2012-07-23 13:45:44 -04:00
/* check for recent connection establishment */
MAJOR: connection: call data layer handshakes from the handler Handshakes is not called anymore from the data handlers, they're only called from the connection handler when their flag is set. Also, this move has uncovered an issue with the stream interface notifier : it doesn't consider the FD_WAIT_* flags possibly set by the handshake handlers. This will result in a stuck handshake when no data is in the output buffer. In order to cover this, for now we'll perform the EV_FD_SET in the SSL handshake function, but this needs to be addressed separately from the stream interface operations.
2012-07-12 09:32:13 -04:00
if (unlikely(!(conn->flags & (CO_FL_WAIT_L4_CONN | CO_FL_WAIT_L6_CONN | CO_FL_CONNECTED)))) {
MAJOR: connection: add a new CO_FL_CONNECTED flag This new flag is used to indicate that the connection was already connected. It can be used by I/O handlers to know that a connection has just completed. It is used by stream_sock_update_conn(), allowing the sock_opt handlers not to manipulate the SI timeout nor the BF_WRITE_NULL flag anymore.
2012-07-23 13:45:44 -04:00
si->exp = TICK_ETERNITY;
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
si->ob->flags |= CF_WRITE_NULL;
MAJOR: connection: add a new CO_FL_CONNECTED flag This new flag is used to indicate that the connection was already connected. It can be used by I/O handlers to know that a connection has just completed. It is used by stream_sock_update_conn(), allowing the sock_opt handlers not to manipulate the SI timeout nor the BF_WRITE_NULL flag anymore.
2012-07-23 13:45:44 -04:00
}
MAJOR: stream-interface: make conn_notify_si() more robust This function was relying on the result of file descriptor polling which is inappropriate as it may be subject to race conditions during handshakes. Make it more robust by relying solely on buffer activity.
2012-08-24 06:12:53 -04:00
/* process consumer side */
MAJOR: channel: remove the BF_OUT_EMPTY flag This flag was very problematic because it was composite in that both changes to the pipe or to the buffer had to cause this flag to be updated, which is not always simple (eg: there may not even be a channel attached to a buffer at all). There were not that many users of this flags, mostly setters. So the flag got replaced with a macro which reports whether the channel is empty or not, by checking both the pipe and the buffer. One part of the change is sensible : the flag was also part of BF_MASK_STATIC, which is used by process_session() to rescan all analysers in case the flag's status changes. At first glance, none of the analysers seems to change its mind base on this flag when it is subject to change, so it seems fine not to add variation checks here. Otherwise it's possible that checking the buffer's output size is more useful than checking the flag's replacement.
2012-08-24 16:40:29 -04:00
if (channel_is_empty(si->ob)) {
CLEANUP: channel: remove any reference of the hijackers Hijackers were functions designed to inject data into channels in the distant past. They became unused around 1.3.16, and since there has not been any user of this mechanism to date, it's uncertain whether the mechanism still works (and it's not really useful anymore). So better remove it as well as the pointer it uses in the channel struct.
2012-11-11 17:05:39 -05:00
if (((si->ob->flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW) &&
MAJOR: stream-interface: make conn_notify_si() more robust This function was relying on the result of file descriptor polling which is inappropriate as it may be subject to race conditions during handshakes. Make it more robust by relying solely on buffer activity.
2012-08-24 06:12:53 -04:00
(si->state == SI_ST_EST))
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
stream_int_shutw_conn(si);
MAJOR: stream-interface: don't commit polling changes in every callback It's more efficient to centralize polling changes, which is already done in the connection handler. So now all I/O callbacks just change flags and rely on the connection handler for the commit. The special case of the send loop is handled by the chk_snd() function which does an update at the end.
2012-08-24 06:52:22 -04:00
__conn_data_stop_send(conn);
MAJOR: stream-interface: make conn_notify_si() more robust This function was relying on the result of file descriptor polling which is inappropriate as it may be subject to race conditions during handshakes. Make it more robust by relying solely on buffer activity.
2012-08-24 06:12:53 -04:00
si->ob->wex = TICK_ETERNITY;
}
MAJOR: remove the stream interface and task management code from sock_* The socket data layer code must only focus on moving data between a socket and a buffer. We need a special stream interface handler to update the stream interface and the file descriptor status. At the moment the code works but suffers from a race condition caused by its API : the read/write callbacks still make use of the fd instead of using the connection. And when a double shutdown is performed, a call to ->write() after ->read() processed an error results in dereferencing a NULL fdtab[]->owner. This is only a temporary issue which doesn't need to be fixed now since this will automatically go away when the functions change to use the connection instead.
2012-07-23 12:24:25 -04:00
CLEANUP: channel: remove any reference of the hijackers Hijackers were functions designed to inject data into channels in the distant past. They became unused around 1.3.16, and since there has not been any user of this mechanism to date, it's uncertain whether the mechanism still works (and it's not really useful anymore). So better remove it as well as the pointer it uses in the channel struct.
2012-11-11 17:05:39 -05:00
if ((si->ob->flags & (CF_SHUTW|CF_SHUTW_NOW)) == 0 && !channel_full(si->ob))
MAJOR: stream-interface: make conn_notify_si() more robust This function was relying on the result of file descriptor polling which is inappropriate as it may be subject to race conditions during handshakes. Make it more robust by relying solely on buffer activity.
2012-08-24 06:12:53 -04:00
si->flags |= SI_FL_WAIT_DATA;
MAJOR: remove the stream interface and task management code from sock_* The socket data layer code must only focus on moving data between a socket and a buffer. We need a special stream interface handler to update the stream interface and the file descriptor status. At the moment the code works but suffers from a race condition caused by its API : the read/write callbacks still make use of the fd instead of using the connection. And when a double shutdown is performed, a call to ->write() after ->read() processed an error results in dereferencing a NULL fdtab[]->owner. This is only a temporary issue which doesn't need to be fixed now since this will automatically go away when the functions change to use the connection instead.
2012-07-23 12:24:25 -04:00
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
if (si->ob->flags & CF_WRITE_ACTIVITY) {
MAJOR: stream-interface: make conn_notify_si() more robust This function was relying on the result of file descriptor polling which is inappropriate as it may be subject to race conditions during handshakes. Make it more robust by relying solely on buffer activity.
2012-08-24 06:12:53 -04:00
/* update timeouts if we have written something */
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
if ((si->ob->flags & (CF_SHUTW|CF_WRITE_PARTIAL)) == CF_WRITE_PARTIAL &&
MAJOR: channel: remove the BF_OUT_EMPTY flag This flag was very problematic because it was composite in that both changes to the pipe or to the buffer had to cause this flag to be updated, which is not always simple (eg: there may not even be a channel attached to a buffer at all). There were not that many users of this flags, mostly setters. So the flag got replaced with a macro which reports whether the channel is empty or not, by checking both the pipe and the buffer. One part of the change is sensible : the flag was also part of BF_MASK_STATIC, which is used by process_session() to rescan all analysers in case the flag's status changes. At first glance, none of the analysers seems to change its mind base on this flag when it is subject to change, so it seems fine not to add variation checks here. Otherwise it's possible that checking the buffer's output size is more useful than checking the flag's replacement.
2012-08-24 16:40:29 -04:00
!channel_is_empty(si->ob))
MAJOR: stream-interface: make conn_notify_si() more robust This function was relying on the result of file descriptor polling which is inappropriate as it may be subject to race conditions during handshakes. Make it more robust by relying solely on buffer activity.
2012-08-24 06:12:53 -04:00
if (tick_isset(si->ob->wex))
si->ob->wex = tick_add_ifset(now_ms, si->ob->wto);
MAJOR: remove the stream interface and task management code from sock_* The socket data layer code must only focus on moving data between a socket and a buffer. We need a special stream interface handler to update the stream interface and the file descriptor status. At the moment the code works but suffers from a race condition caused by its API : the read/write callbacks still make use of the fd instead of using the connection. And when a double shutdown is performed, a call to ->write() after ->read() processed an error results in dereferencing a NULL fdtab[]->owner. This is only a temporary issue which doesn't need to be fixed now since this will automatically go away when the functions change to use the connection instead.
2012-07-23 12:24:25 -04:00
MAJOR: stream-interface: make conn_notify_si() more robust This function was relying on the result of file descriptor polling which is inappropriate as it may be subject to race conditions during handshakes. Make it more robust by relying solely on buffer activity.
2012-08-24 06:12:53 -04:00
if (!(si->flags & SI_FL_INDEP_STR))
if (tick_isset(si->ib->rex))
si->ib->rex = tick_add_ifset(now_ms, si->ib->rto);
MAJOR: remove the stream interface and task management code from sock_* The socket data layer code must only focus on moving data between a socket and a buffer. We need a special stream interface handler to update the stream interface and the file descriptor status. At the moment the code works but suffers from a race condition caused by its API : the read/write callbacks still make use of the fd instead of using the connection. And when a double shutdown is performed, a call to ->write() after ->read() processed an error results in dereferencing a NULL fdtab[]->owner. This is only a temporary issue which doesn't need to be fixed now since this will automatically go away when the functions change to use the connection instead.
2012-07-23 12:24:25 -04:00
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
if (likely((si->ob->flags & (CF_SHUTW|CF_WRITE_PARTIAL|CF_DONT_READ)) == CF_WRITE_PARTIAL &&
MAJOR: channel: stop relying on BF_FULL to take action This flag is quite complex to get right and updating it everywhere is a major pain, especially since the buffer/channel split. This is the first step of getting rid of it. Instead now it's dynamically computed whenever needed.
2012-08-27 14:46:07 -04:00
!channel_full(si->ob) &&
MAJOR: stream-interface: make conn_notify_si() more robust This function was relying on the result of file descriptor polling which is inappropriate as it may be subject to race conditions during handshakes. Make it more robust by relying solely on buffer activity.
2012-08-24 06:12:53 -04:00
(si->ob->prod->flags & SI_FL_WAIT_ROOM)))
si_chk_rcv(si->ob->prod);
MAJOR: remove the stream interface and task management code from sock_* The socket data layer code must only focus on moving data between a socket and a buffer. We need a special stream interface handler to update the stream interface and the file descriptor status. At the moment the code works but suffers from a race condition caused by its API : the read/write callbacks still make use of the fd instead of using the connection. And when a double shutdown is performed, a call to ->write() after ->read() processed an error results in dereferencing a NULL fdtab[]->owner. This is only a temporary issue which doesn't need to be fixed now since this will automatically go away when the functions change to use the connection instead.
2012-07-23 12:24:25 -04:00
}
MAJOR: stream-interface: make conn_notify_si() more robust This function was relying on the result of file descriptor polling which is inappropriate as it may be subject to race conditions during handshakes. Make it more robust by relying solely on buffer activity.
2012-08-24 06:12:53 -04:00
/* process producer side.
* We might have some data the consumer is waiting for.
* We can do fast-forwarding, but we avoid doing this for partial
* buffers, because it is very likely that it will be done again
* immediately afterwards once the following data is parsed (eg:
* HTTP chunking).
*/
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
if (((si->ib->flags & CF_READ_PARTIAL) && !channel_is_empty(si->ib)) &&
MAJOR: stream-interface: make conn_notify_si() more robust This function was relying on the result of file descriptor polling which is inappropriate as it may be subject to race conditions during handshakes. Make it more robust by relying solely on buffer activity.
2012-08-24 06:12:53 -04:00
(si->ib->pipe /* always try to send spliced data */ ||
MAJOR: channel: replace the struct buffer with a pointer to a buffer With this commit, we now separate the channel from the buffer. This will allow us to replace buffers on the fly without touching the channel. Since nobody is supposed to keep a reference to a buffer anymore, doing so is not a problem and will also permit some copy-less data manipulation. Interestingly, these changes have shown a 2% performance increase on some workloads, probably due to a better cache placement of data.
2012-10-12 17:49:43 -04:00
(si->ib->buf->i == 0 && (si->ib->cons->flags & SI_FL_WAIT_DATA)))) {
MAJOR: stream-interface: make conn_notify_si() more robust This function was relying on the result of file descriptor polling which is inappropriate as it may be subject to race conditions during handshakes. Make it more robust by relying solely on buffer activity.
2012-08-24 06:12:53 -04:00
int last_len = si->ib->pipe ? si->ib->pipe->data : 0;
MAJOR: remove the stream interface and task management code from sock_* The socket data layer code must only focus on moving data between a socket and a buffer. We need a special stream interface handler to update the stream interface and the file descriptor status. At the moment the code works but suffers from a race condition caused by its API : the read/write callbacks still make use of the fd instead of using the connection. And when a double shutdown is performed, a call to ->write() after ->read() processed an error results in dereferencing a NULL fdtab[]->owner. This is only a temporary issue which doesn't need to be fixed now since this will automatically go away when the functions change to use the connection instead.
2012-07-23 12:24:25 -04:00
MAJOR: stream-interface: make conn_notify_si() more robust This function was relying on the result of file descriptor polling which is inappropriate as it may be subject to race conditions during handshakes. Make it more robust by relying solely on buffer activity.
2012-08-24 06:12:53 -04:00
si_chk_snd(si->ib->cons);
MAJOR: remove the stream interface and task management code from sock_* The socket data layer code must only focus on moving data between a socket and a buffer. We need a special stream interface handler to update the stream interface and the file descriptor status. At the moment the code works but suffers from a race condition caused by its API : the read/write callbacks still make use of the fd instead of using the connection. And when a double shutdown is performed, a call to ->write() after ->read() processed an error results in dereferencing a NULL fdtab[]->owner. This is only a temporary issue which doesn't need to be fixed now since this will automatically go away when the functions change to use the connection instead.
2012-07-23 12:24:25 -04:00
MAJOR: stream-interface: make conn_notify_si() more robust This function was relying on the result of file descriptor polling which is inappropriate as it may be subject to race conditions during handshakes. Make it more robust by relying solely on buffer activity.
2012-08-24 06:12:53 -04:00
/* check if the consumer has freed some space either in the
* buffer or in the pipe.
*/
MAJOR: channel: stop relying on BF_FULL to take action This flag is quite complex to get right and updating it everywhere is a major pain, especially since the buffer/channel split. This is the first step of getting rid of it. Instead now it's dynamically computed whenever needed.
2012-08-27 14:46:07 -04:00
if (!channel_full(si->ib) &&
MAJOR: stream-interface: make conn_notify_si() more robust This function was relying on the result of file descriptor polling which is inappropriate as it may be subject to race conditions during handshakes. Make it more robust by relying solely on buffer activity.
2012-08-24 06:12:53 -04:00
(!last_len || !si->ib->pipe || si->ib->pipe->data < last_len))
si->flags &= ~SI_FL_WAIT_ROOM;
}
MAJOR: remove the stream interface and task management code from sock_* The socket data layer code must only focus on moving data between a socket and a buffer. We need a special stream interface handler to update the stream interface and the file descriptor status. At the moment the code works but suffers from a race condition caused by its API : the read/write callbacks still make use of the fd instead of using the connection. And when a double shutdown is performed, a call to ->write() after ->read() processed an error results in dereferencing a NULL fdtab[]->owner. This is only a temporary issue which doesn't need to be fixed now since this will automatically go away when the functions change to use the connection instead.
2012-07-23 12:24:25 -04:00
MAJOR: stream-interface: make conn_notify_si() more robust This function was relying on the result of file descriptor polling which is inappropriate as it may be subject to race conditions during handshakes. Make it more robust by relying solely on buffer activity.
2012-08-24 06:12:53 -04:00
if (si->flags & SI_FL_WAIT_ROOM) {
MAJOR: stream-interface: don't commit polling changes in every callback It's more efficient to centralize polling changes, which is already done in the connection handler. So now all I/O callbacks just change flags and rely on the connection handler for the commit. The special case of the send loop is handled by the chk_snd() function which does an update at the end.
2012-08-24 06:52:22 -04:00
__conn_data_stop_recv(conn);
MAJOR: stream-interface: make conn_notify_si() more robust This function was relying on the result of file descriptor polling which is inappropriate as it may be subject to race conditions during handshakes. Make it more robust by relying solely on buffer activity.
2012-08-24 06:12:53 -04:00
si->ib->rex = TICK_ETERNITY;
}
BUG/MAJOR: stream_interface: fix occasional data transfer freezes Since the changes in connection management, it became necessary to re-enable polling after a fast-forward transfer would complete. One such issue was addressed after dev12 by commit 9f7c6a18 (BUG/MAJOR: stream_interface: certain workloads could cause get stuck) but unfortunately, it was incomplete as very subtle cases would occasionally remain unaddressed when a buffer was marked with the NOEXP flag, which is used during POST uploads. The wake up must be performed even when the flag is there, the flag is used only to refresh the timeout. Too many conditions need to be hit together for the situation to be reproducible, but it systematically appears for some users. It is particularly important to credit Sander Klein and John Rood from Picturae ICT ( http://picturae.com/ ) for reporting this bug on the mailing list, providing configs and countless traces showing the bug in action, and for their patience testing litteraly tens of snapshots and versions of supposed fixes during a full week to narrow the commit range until the bug was really knocked down! As a side effect of their numerous tests, several other bugs were fixed.
2012-12-19 11:34:17 -05:00
else if ((si->ib->flags & (CF_SHUTR|CF_READ_PARTIAL|CF_DONT_READ)) == CF_READ_PARTIAL &&
MAJOR: channel: stop relying on BF_FULL to take action This flag is quite complex to get right and updating it everywhere is a major pain, especially since the buffer/channel split. This is the first step of getting rid of it. Instead now it's dynamically computed whenever needed.
2012-08-27 14:46:07 -04:00
!channel_full(si->ib)) {
BUG/MAJOR: stream_interface: certain workloads could cause get stuck Some very specifically scheduled workloads could sometimes get stuck when data receive was disabled due to buffer full then re-enabled due to a full send(). A conn_data_want_recv() had to be set again in this specific case. This bug was introduced with connection rework and polling changes in dev12.
2012-11-19 10:43:14 -05:00
/* we must re-enable reading if si_chk_snd() has freed some space */
__conn_data_want_recv(conn);
BUG/MAJOR: stream_interface: fix occasional data transfer freezes Since the changes in connection management, it became necessary to re-enable polling after a fast-forward transfer would complete. One such issue was addressed after dev12 by commit 9f7c6a18 (BUG/MAJOR: stream_interface: certain workloads could cause get stuck) but unfortunately, it was incomplete as very subtle cases would occasionally remain unaddressed when a buffer was marked with the NOEXP flag, which is used during POST uploads. The wake up must be performed even when the flag is there, the flag is used only to refresh the timeout. Too many conditions need to be hit together for the situation to be reproducible, but it systematically appears for some users. It is particularly important to credit Sander Klein and John Rood from Picturae ICT ( http://picturae.com/ ) for reporting this bug on the mailing list, providing configs and countless traces showing the bug in action, and for their patience testing litteraly tens of snapshots and versions of supposed fixes during a full week to narrow the commit range until the bug was really knocked down! As a side effect of their numerous tests, several other bugs were fixed.
2012-12-19 11:34:17 -05:00
if (!(si->ib->flags & CF_READ_NOEXP) && tick_isset(si->ib->rex))
MAJOR: stream-interface: make conn_notify_si() more robust This function was relying on the result of file descriptor polling which is inappropriate as it may be subject to race conditions during handshakes. Make it more robust by relying solely on buffer activity.
2012-08-24 06:12:53 -04:00
si->ib->rex = tick_add_ifset(now_ms, si->ib->rto);
MAJOR: remove the stream interface and task management code from sock_* The socket data layer code must only focus on moving data between a socket and a buffer. We need a special stream interface handler to update the stream interface and the file descriptor status. At the moment the code works but suffers from a race condition caused by its API : the read/write callbacks still make use of the fd instead of using the connection. And when a double shutdown is performed, a call to ->write() after ->read() processed an error results in dereferencing a NULL fdtab[]->owner. This is only a temporary issue which doesn't need to be fixed now since this will automatically go away when the functions change to use the connection instead.
2012-07-23 12:24:25 -04:00
}
/* wake the task up only when needed */
if (/* changes on the production side */
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
(si->ib->flags & (CF_READ_NULL|CF_READ_ERROR)) ||
MAJOR: remove the stream interface and task management code from sock_* The socket data layer code must only focus on moving data between a socket and a buffer. We need a special stream interface handler to update the stream interface and the file descriptor status. At the moment the code works but suffers from a race condition caused by its API : the read/write callbacks still make use of the fd instead of using the connection. And when a double shutdown is performed, a call to ->write() after ->read() processed an error results in dereferencing a NULL fdtab[]->owner. This is only a temporary issue which doesn't need to be fixed now since this will automatically go away when the functions change to use the connection instead.
2012-07-23 12:24:25 -04:00
si->state != SI_ST_EST ||
(si->flags & SI_FL_ERR) ||
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
((si->ib->flags & CF_READ_PARTIAL) &&
MAJOR: remove the stream interface and task management code from sock_* The socket data layer code must only focus on moving data between a socket and a buffer. We need a special stream interface handler to update the stream interface and the file descriptor status. At the moment the code works but suffers from a race condition caused by its API : the read/write callbacks still make use of the fd instead of using the connection. And when a double shutdown is performed, a call to ->write() after ->read() processed an error results in dereferencing a NULL fdtab[]->owner. This is only a temporary issue which doesn't need to be fixed now since this will automatically go away when the functions change to use the connection instead.
2012-07-23 12:24:25 -04:00
(!si->ib->to_forward || si->ib->cons->state != SI_ST_EST)) ||
/* changes on the consumption side */
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
(si->ob->flags & (CF_WRITE_NULL|CF_WRITE_ERROR)) ||
((si->ob->flags & CF_WRITE_ACTIVITY) &&
BUG/MEDIUM: stream-interface: don't wake the task up before end of transfer Recent commit d7ad9f5 ("MAJOR: channel: add a new flag CF_WAKE_WRITE to notify the task of writes") was not correct. It used to wake up the task as soon as there was some write activity and the flag was set, even if there were still some data to be forwarded. This resulted in process_session() being called a lot when transfering chunk-encoded HTTP responses made of very large chunks. The purpose of the flag is to wake up only a task waiting for some room and not the other ones, so it's totally counter-productive to wake it up as long as there are data to forward because the task will not be allowed to write anyway. Also, the commit above was taking some risks by not considering certain events anymore (eg: state != SI_ST_EST). While such events are not used at the moment, if some new features were developped in the future relying on these, it would be better that they could be notified when subscribing to the WAKE_WRITE event, so let's restore the condition.
2014-01-24 20:33:21 -05:00
((si->ob->flags & CF_SHUTW) ||
((si->ob->flags & CF_WAKE_WRITE) &&
(si->ob->prod->state != SI_ST_EST ||
(channel_is_empty(si->ob) && !si->ob->to_forward)))))) {
MAJOR: remove the stream interface and task management code from sock_* The socket data layer code must only focus on moving data between a socket and a buffer. We need a special stream interface handler to update the stream interface and the file descriptor status. At the moment the code works but suffers from a race condition caused by its API : the read/write callbacks still make use of the fd instead of using the connection. And when a double shutdown is performed, a call to ->write() after ->read() processed an error results in dereferencing a NULL fdtab[]->owner. This is only a temporary issue which doesn't need to be fixed now since this will automatically go away when the functions change to use the connection instead.
2012-07-23 12:24:25 -04:00
task_wakeup(si->owner, TASK_WOKEN_IO);
}
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
if (si->ib->flags & CF_READ_ACTIVITY)
si->ib->flags &= ~CF_READ_DONTWAIT;
MEDIUM: connection: make it possible for data->wake to return an error Just like ->init(), ->wake() may now be used to return an error and abort the connection. Currently this is not used but will be with embryonic sessions.
2012-10-03 15:12:16 -04:00
return 0;
MAJOR: remove the stream interface and task management code from sock_* The socket data layer code must only focus on moving data between a socket and a buffer. We need a special stream interface handler to update the stream interface and the file descriptor status. At the moment the code works but suffers from a race condition caused by its API : the read/write callbacks still make use of the fd instead of using the connection. And when a double shutdown is performed, a call to ->write() after ->read() processed an error results in dereferencing a NULL fdtab[]->owner. This is only a temporary issue which doesn't need to be fixed now since this will automatically go away when the functions change to use the connection instead.
2012-07-23 12:24:25 -04:00
}
MEDIUM: connection: extract the send_proxy callback from proto_tcp This handshake handler must be independant, so move it away from proto_tcp. It has a dedicated connection flag. It is tested before I/O handlers and automatically removes the CO_FL_WAIT_L4_CONN flag upon success. It also sets the BF_WRITE_NULL flag on the stream interface and stops the SI timeout. However it does not perform the task_wakeup(), and relies on the data handler to do so for now. The SI wakeup will have to be moved elsewhere anyway.
2012-07-06 11:12:34 -04:00
MAJOR: connection: split the send call into connection and stream interface Similar to what was done on the receive path, the data layer now provides only an snd_buf() callback that is iterated over by the stream interface's si_conn_send_loop() function. The data layer now has no knowledge about channels nor stream interfaces. The splice() code still need to be ported as it currently is disabled.
2012-08-21 12:22:06 -04:00
/*
* This function is called to send buffer data to a stream socket.
CLEANUP: stream_interface: cleanup loop information in si_conn_send_loop() Though si_conn_send_loop() does not loop over ->snd_buf() after commit ed7f836, there is still some codes left which use `while` but only execute once. This commit does the cleanup job and rename si_conn_send_loop() to si_conn_send(). Signed-off-by: Godbach <nylzhaowei@gmail.com>
2013-10-11 03:48:29 -04:00
* It calls the transport layer's snd_buf function. It relies on the
OPTIM: stream_interface: return directly if the connection flag CO_FL_ERROR has been set The connection flag CO_FL_ERROR will be tested in the functions both si_conn_recv_cb() and si_conn_send_cb(). If CO_FL_ERROR has been set, out_error branch will be executed. But the only job of out_error branch is to set CO_FL_ERROR on connection flag. So it's better return directly than goto out_error branch under such conditions. As a result, out_error branch becomes needless and can be removed. In addition, the return type of si_conn_send_loop() is also changed to void. The caller should check conn->flags for errors just like stream_int_chk_snd_conn() does as below: static void stream_int_chk_snd_conn(struct stream_interface *si) { ... conn_refresh_polling_flags(si->conn); - if (si_conn_send(si->conn) < 0) { + si_conn_send(si->conn); + if (si->conn->flags & CO_FL_ERROR) { ... } Signed-off-by: Godbach <nylzhaowei@gmail.com>
2013-12-04 04:24:06 -05:00
* caller to commit polling changes. The caller should check conn->flags
* for errors.
MAJOR: connection: split the send call into connection and stream interface Similar to what was done on the receive path, the data layer now provides only an snd_buf() callback that is iterated over by the stream interface's si_conn_send_loop() function. The data layer now has no knowledge about channels nor stream interfaces. The splice() code still need to be ported as it currently is disabled.
2012-08-21 12:22:06 -04:00
*/
OPTIM: stream_interface: return directly if the connection flag CO_FL_ERROR has been set The connection flag CO_FL_ERROR will be tested in the functions both si_conn_recv_cb() and si_conn_send_cb(). If CO_FL_ERROR has been set, out_error branch will be executed. But the only job of out_error branch is to set CO_FL_ERROR on connection flag. So it's better return directly than goto out_error branch under such conditions. As a result, out_error branch becomes needless and can be removed. In addition, the return type of si_conn_send_loop() is also changed to void. The caller should check conn->flags for errors just like stream_int_chk_snd_conn() does as below: static void stream_int_chk_snd_conn(struct stream_interface *si) { ... conn_refresh_polling_flags(si->conn); - if (si_conn_send(si->conn) < 0) { + si_conn_send(si->conn); + if (si->conn->flags & CO_FL_ERROR) { ... } Signed-off-by: Godbach <nylzhaowei@gmail.com>
2013-12-04 04:24:06 -05:00
static void si_conn_send(struct connection *conn)
MAJOR: connection: split the send call into connection and stream interface Similar to what was done on the receive path, the data layer now provides only an snd_buf() callback that is iterated over by the stream interface's si_conn_send_loop() function. The data layer now has no knowledge about channels nor stream interfaces. The splice() code still need to be ported as it currently is disabled.
2012-08-21 12:22:06 -04:00
{
MEDIUM: connection: make use of the owner instead of container_of This way the connection can become independant on the stream interface.
2012-09-27 16:20:41 -04:00
struct stream_interface *si = conn->owner;
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
struct channel *chn = si->ob;
MAJOR: connection: split the send call into connection and stream interface Similar to what was done on the receive path, the data layer now provides only an snd_buf() callback that is iterated over by the stream interface's si_conn_send_loop() function. The data layer now has no knowledge about channels nor stream interfaces. The splice() code still need to be ported as it currently is disabled.
2012-08-21 12:22:06 -04:00
int ret;
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
if (chn->pipe && conn->xprt->snd_pipe) {
ret = conn->xprt->snd_pipe(conn, chn->pipe);
MAJOR: stream-interface: restore splicing mechanism The splicing is now provided by the data-layer rcv_pipe/snd_pipe functions which in turn are called by the stream interface's recv and send callbacks. The presence of the rcv_pipe/snd_pipe functions is used to attest support for splicing at the data layer. It looks like the stream-interface's SI_FL_CAP_SPLICE flag does not make sense anymore as it's used as a proxy for the pointers above. It also appears that we call chk_snd() from the recv callback and then try to call it again in update_conn(). It is very likely that this last function will progressively slip into the recv/send callbacks in order to avoid duplicate check code. The code works right now with and without splicing. Only raw_sock provides support for it and it is automatically selected when the various splice options are set. However it looks like splice-auto doesn't enable it, which possibly means that the streamer detection code does not work anymore, or that it's only called at a time where it's too late to enable splicing (in process_session).
2012-08-23 18:46:52 -04:00
if (ret > 0)
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
chn->flags |= CF_WRITE_PARTIAL;
MAJOR: connection: split the send call into connection and stream interface Similar to what was done on the receive path, the data layer now provides only an snd_buf() callback that is iterated over by the stream interface's si_conn_send_loop() function. The data layer now has no knowledge about channels nor stream interfaces. The splice() code still need to be ported as it currently is disabled.
2012-08-21 12:22:06 -04:00
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
if (!chn->pipe->data) {
put_pipe(chn->pipe);
chn->pipe = NULL;
MAJOR: connection: split the send call into connection and stream interface Similar to what was done on the receive path, the data layer now provides only an snd_buf() callback that is iterated over by the stream interface's si_conn_send_loop() function. The data layer now has no knowledge about channels nor stream interfaces. The splice() code still need to be ported as it currently is disabled.
2012-08-21 12:22:06 -04:00
}
MAJOR: stream-interface: restore splicing mechanism The splicing is now provided by the data-layer rcv_pipe/snd_pipe functions which in turn are called by the stream interface's recv and send callbacks. The presence of the rcv_pipe/snd_pipe functions is used to attest support for splicing at the data layer. It looks like the stream-interface's SI_FL_CAP_SPLICE flag does not make sense anymore as it's used as a proxy for the pointers above. It also appears that we call chk_snd() from the recv callback and then try to call it again in update_conn(). It is very likely that this last function will progressively slip into the recv/send callbacks in order to avoid duplicate check code. The code works right now with and without splicing. Only raw_sock provides support for it and it is automatically selected when the various splice options are set. However it looks like splice-auto doesn't enable it, which possibly means that the streamer detection code does not work anymore, or that it's only called at a time where it's too late to enable splicing (in process_session).
2012-08-23 18:46:52 -04:00
if (conn->flags & CO_FL_ERROR)
OPTIM: stream_interface: return directly if the connection flag CO_FL_ERROR has been set The connection flag CO_FL_ERROR will be tested in the functions both si_conn_recv_cb() and si_conn_send_cb(). If CO_FL_ERROR has been set, out_error branch will be executed. But the only job of out_error branch is to set CO_FL_ERROR on connection flag. So it's better return directly than goto out_error branch under such conditions. As a result, out_error branch becomes needless and can be removed. In addition, the return type of si_conn_send_loop() is also changed to void. The caller should check conn->flags for errors just like stream_int_chk_snd_conn() does as below: static void stream_int_chk_snd_conn(struct stream_interface *si) { ... conn_refresh_polling_flags(si->conn); - if (si_conn_send(si->conn) < 0) { + si_conn_send(si->conn); + if (si->conn->flags & CO_FL_ERROR) { ... } Signed-off-by: Godbach <nylzhaowei@gmail.com>
2013-12-04 04:24:06 -05:00
return;
MAJOR: connection: split the send call into connection and stream interface Similar to what was done on the receive path, the data layer now provides only an snd_buf() callback that is iterated over by the stream interface's si_conn_send_loop() function. The data layer now has no knowledge about channels nor stream interfaces. The splice() code still need to be ported as it currently is disabled.
2012-08-21 12:22:06 -04:00
}
/* At this point, the pipe is empty, but we may still have data pending
* in the normal buffer.
*/
MAJOR: channel: replace the struct buffer with a pointer to a buffer With this commit, we now separate the channel from the buffer. This will allow us to replace buffers on the fly without touching the channel. Since nobody is supposed to keep a reference to a buffer anymore, doing so is not a problem and will also permit some copy-less data manipulation. Interestingly, these changes have shown a 2% performance increase on some workloads, probably due to a better cache placement of data.
2012-10-12 17:49:43 -04:00
if (!chn->buf->o)
OPTIM: stream_interface: return directly if the connection flag CO_FL_ERROR has been set The connection flag CO_FL_ERROR will be tested in the functions both si_conn_recv_cb() and si_conn_send_cb(). If CO_FL_ERROR has been set, out_error branch will be executed. But the only job of out_error branch is to set CO_FL_ERROR on connection flag. So it's better return directly than goto out_error branch under such conditions. As a result, out_error branch becomes needless and can be removed. In addition, the return type of si_conn_send_loop() is also changed to void. The caller should check conn->flags for errors just like stream_int_chk_snd_conn() does as below: static void stream_int_chk_snd_conn(struct stream_interface *si) { ... conn_refresh_polling_flags(si->conn); - if (si_conn_send(si->conn) < 0) { + si_conn_send(si->conn); + if (si->conn->flags & CO_FL_ERROR) { ... } Signed-off-by: Godbach <nylzhaowei@gmail.com>
2013-12-04 04:24:06 -05:00
return;
MAJOR: connection: split the send call into connection and stream interface Similar to what was done on the receive path, the data layer now provides only an snd_buf() callback that is iterated over by the stream interface's si_conn_send_loop() function. The data layer now has no knowledge about channels nor stream interfaces. The splice() code still need to be ported as it currently is disabled.
2012-08-21 12:22:06 -04:00
CLEANUP: stream_interface: cleanup loop information in si_conn_send_loop() Though si_conn_send_loop() does not loop over ->snd_buf() after commit ed7f836, there is still some codes left which use `while` but only execute once. This commit does the cleanup job and rename si_conn_send_loop() to si_conn_send(). Signed-off-by: Godbach <nylzhaowei@gmail.com>
2013-10-11 03:48:29 -04:00
/* when we're here, we already know that there is no spliced
MAJOR: connection: split the send call into connection and stream interface Similar to what was done on the receive path, the data layer now provides only an snd_buf() callback that is iterated over by the stream interface's si_conn_send_loop() function. The data layer now has no knowledge about channels nor stream interfaces. The splice() code still need to be ported as it currently is disabled.
2012-08-21 12:22:06 -04:00
* data left, and that there are sendable buffered data.
*/
MAJOR: connection: remove the CO_FL_WAIT_{RD,WR} flags These flags were used to report the readiness of the file descriptor. Now this readiness is directly checked at the file descriptor itself. This removes the need for constantly synchronizing updates between the file descriptor and the connection and ensures that all layers share the same level of information. For now, the readiness is updated in conn_{sock,data}_poll_* by directly touching the file descriptor. This must move to the lower layers instead so that these functions can disappear as well. In this state, the change works but is incomplete. It's sensible enough to avoid making it more complex. Now the sock/data updates become much simpler because they just have to enable/disable access to a file descriptor and not to care anymore about its readiness.
2014-01-22 13:46:33 -05:00
if (!(conn->flags & (CO_FL_ERROR | CO_FL_SOCK_WR_SH | CO_FL_DATA_WR_SH | CO_FL_WAIT_DATA | CO_FL_HANDSHAKE))) {
MAJOR: connection: split the send call into connection and stream interface Similar to what was done on the receive path, the data layer now provides only an snd_buf() callback that is iterated over by the stream interface's si_conn_send_loop() function. The data layer now has no knowledge about channels nor stream interfaces. The splice() code still need to be ported as it currently is disabled.
2012-08-21 12:22:06 -04:00
/* check if we want to inform the kernel that we're interested in
* sending more data after this call. We want this if :
* - we're about to close after this last send and want to merge
* the ongoing FIN with the last segment.
* - we know we can't send everything at once and must get back
* here because of unaligned data
* - there is still a finite amount of data to forward
* The test is arranged so that the most common case does only 2
* tests.
*/
unsigned int send_flag = MSG_DONTWAIT | MSG_NOSIGNAL;
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
if ((!(chn->flags & (CF_NEVER_WAIT|CF_SEND_DONTWAIT)) &&
((chn->to_forward && chn->to_forward != CHN_INFINITE_FORWARD) ||
(chn->flags & CF_EXPECT_MORE))) ||
CLEANUP: channel: remove any reference of the hijackers Hijackers were functions designed to inject data into channels in the distant past. They became unused around 1.3.16, and since there has not been any user of this mechanism to date, it's uncertain whether the mechanism still works (and it's not really useful anymore). So better remove it as well as the pointer it uses in the channel struct.
2012-11-11 17:05:39 -05:00
((chn->flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW))
MAJOR: connection: split the send call into connection and stream interface Similar to what was done on the receive path, the data layer now provides only an snd_buf() callback that is iterated over by the stream interface's si_conn_send_loop() function. The data layer now has no knowledge about channels nor stream interfaces. The splice() code still need to be ported as it currently is disabled.
2012-08-21 12:22:06 -04:00
send_flag |= MSG_MORE;
MAJOR: channel: replace the struct buffer with a pointer to a buffer With this commit, we now separate the channel from the buffer. This will allow us to replace buffers on the fly without touching the channel. Since nobody is supposed to keep a reference to a buffer anymore, doing so is not a problem and will also permit some copy-less data manipulation. Interestingly, these changes have shown a 2% performance increase on some workloads, probably due to a better cache placement of data.
2012-10-12 17:49:43 -04:00
ret = conn->xprt->snd_buf(conn, chn->buf, send_flag);
CLEANUP: stream_interface: cleanup loop information in si_conn_send_loop() Though si_conn_send_loop() does not loop over ->snd_buf() after commit ed7f836, there is still some codes left which use `while` but only execute once. This commit does the cleanup job and rename si_conn_send_loop() to si_conn_send(). Signed-off-by: Godbach <nylzhaowei@gmail.com>
2013-10-11 03:48:29 -04:00
if (ret > 0) {
chn->flags |= CF_WRITE_PARTIAL;
MAJOR: connection: split the send call into connection and stream interface Similar to what was done on the receive path, the data layer now provides only an snd_buf() callback that is iterated over by the stream interface's si_conn_send_loop() function. The data layer now has no knowledge about channels nor stream interfaces. The splice() code still need to be ported as it currently is disabled.
2012-08-21 12:22:06 -04:00
CLEANUP: stream_interface: cleanup loop information in si_conn_send_loop() Though si_conn_send_loop() does not loop over ->snd_buf() after commit ed7f836, there is still some codes left which use `while` but only execute once. This commit does the cleanup job and rename si_conn_send_loop() to si_conn_send(). Signed-off-by: Godbach <nylzhaowei@gmail.com>
2013-10-11 03:48:29 -04:00
if (!chn->buf->o) {
/* Always clear both flags once everything has been sent, they're one-shot */
chn->flags &= ~(CF_EXPECT_MORE | CF_SEND_DONTWAIT);
}
MAJOR: connection: split the send call into connection and stream interface Similar to what was done on the receive path, the data layer now provides only an snd_buf() callback that is iterated over by the stream interface's si_conn_send_loop() function. The data layer now has no knowledge about channels nor stream interfaces. The splice() code still need to be ported as it currently is disabled.
2012-08-21 12:22:06 -04:00
CLEANUP: stream_interface: cleanup loop information in si_conn_send_loop() Though si_conn_send_loop() does not loop over ->snd_buf() after commit ed7f836, there is still some codes left which use `while` but only execute once. This commit does the cleanup job and rename si_conn_send_loop() to si_conn_send(). Signed-off-by: Godbach <nylzhaowei@gmail.com>
2013-10-11 03:48:29 -04:00
/* if some data remain in the buffer, it's only because the
* system buffers are full, we will try next time.
*/
MAJOR: connection: split the send call into connection and stream interface Similar to what was done on the receive path, the data layer now provides only an snd_buf() callback that is iterated over by the stream interface's si_conn_send_loop() function. The data layer now has no knowledge about channels nor stream interfaces. The splice() code still need to be ported as it currently is disabled.
2012-08-21 12:22:06 -04:00
}
CLEANUP: stream_interface: cleanup loop information in si_conn_send_loop() Though si_conn_send_loop() does not loop over ->snd_buf() after commit ed7f836, there is still some codes left which use `while` but only execute once. This commit does the cleanup job and rename si_conn_send_loop() to si_conn_send(). Signed-off-by: Godbach <nylzhaowei@gmail.com>
2013-10-11 03:48:29 -04:00
}
MAJOR: connection: split the send call into connection and stream interface Similar to what was done on the receive path, the data layer now provides only an snd_buf() callback that is iterated over by the stream interface's si_conn_send_loop() function. The data layer now has no knowledge about channels nor stream interfaces. The splice() code still need to be ported as it currently is disabled.
2012-08-21 12:22:06 -04:00
OPTIM: stream_interface: return directly if the connection flag CO_FL_ERROR has been set The connection flag CO_FL_ERROR will be tested in the functions both si_conn_recv_cb() and si_conn_send_cb(). If CO_FL_ERROR has been set, out_error branch will be executed. But the only job of out_error branch is to set CO_FL_ERROR on connection flag. So it's better return directly than goto out_error branch under such conditions. As a result, out_error branch becomes needless and can be removed. In addition, the return type of si_conn_send_loop() is also changed to void. The caller should check conn->flags for errors just like stream_int_chk_snd_conn() does as below: static void stream_int_chk_snd_conn(struct stream_interface *si) { ... conn_refresh_polling_flags(si->conn); - if (si_conn_send(si->conn) < 0) { + si_conn_send(si->conn); + if (si->conn->flags & CO_FL_ERROR) { ... } Signed-off-by: Godbach <nylzhaowei@gmail.com>
2013-12-04 04:24:06 -05:00
return;
MAJOR: connection: split the send call into connection and stream interface Similar to what was done on the receive path, the data layer now provides only an snd_buf() callback that is iterated over by the stream interface's si_conn_send_loop() function. The data layer now has no knowledge about channels nor stream interfaces. The splice() code still need to be ported as it currently is disabled.
2012-08-21 12:22:06 -04:00
}
MEDIUM: stream_interface: offer a generic function for connection updates We need to have a generic function to be called by upper layers when buffer flags have been updated (the si->update function). At the moment, both sock_raw and sock_ssl had their own which basically was a copy-paste. Since these functions are only used to update stream interface flags, it is logical to have them handled by the stream interface code. This allowed us to remove the stream_interface-specific update function from sock_raw and sock_ssl which now use the generic code. The stream_sock_update_conn callback has also been more appropriately renamed conn_notify_si() since it's meant to be called by lower layers to notify the SI and possibly upper layers about incoming changes.
2012-08-20 06:06:26 -04:00
/* Updates the timers and flags of a stream interface attached to a connection,
* depending on the buffers' flags. It should only be called once after the
* buffer flags have settled down, and before they are cleared. It doesn't
* harm to call it as often as desired (it just slightly hurts performance).
* It is only meant to be called by upper layers after buffer flags have been
* manipulated by analysers.
*/
void stream_int_update_conn(struct stream_interface *si)
{
REORG/MAJOR: use "struct channel" instead of "struct buffer" This is a massive rename. We'll then split channel and buffer. This change needs a lot of cleanups. At many locations, the parameter or variable is still called "buf" which will become ambiguous. Also, the "struct channel" is still defined in buffers.h.
2012-07-02 09:11:27 -04:00
struct channel *ib = si->ib;
struct channel *ob = si->ob;
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
struct connection *conn = __objt_conn(si->end);
MEDIUM: stream_interface: offer a generic function for connection updates We need to have a generic function to be called by upper layers when buffer flags have been updated (the si->update function). At the moment, both sock_raw and sock_ssl had their own which basically was a copy-paste. Since these functions are only used to update stream interface flags, it is logical to have them handled by the stream interface code. This allowed us to remove the stream_interface-specific update function from sock_raw and sock_ssl which now use the generic code. The stream_sock_update_conn callback has also been more appropriately renamed conn_notify_si() since it's meant to be called by lower layers to notify the SI and possibly upper layers about incoming changes.
2012-08-20 06:06:26 -04:00
/* Check if we need to close the read side */
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
if (!(ib->flags & CF_SHUTR)) {
MEDIUM: stream_interface: offer a generic function for connection updates We need to have a generic function to be called by upper layers when buffer flags have been updated (the si->update function). At the moment, both sock_raw and sock_ssl had their own which basically was a copy-paste. Since these functions are only used to update stream interface flags, it is logical to have them handled by the stream interface code. This allowed us to remove the stream_interface-specific update function from sock_raw and sock_ssl which now use the generic code. The stream_sock_update_conn callback has also been more appropriately renamed conn_notify_si() since it's meant to be called by lower layers to notify the SI and possibly upper layers about incoming changes.
2012-08-20 06:06:26 -04:00
/* Read not closed, update FD status and timeout for reads */
CLEANUP: channel: remove any reference of the hijackers Hijackers were functions designed to inject data into channels in the distant past. They became unused around 1.3.16, and since there has not been any user of this mechanism to date, it's uncertain whether the mechanism still works (and it's not really useful anymore). So better remove it as well as the pointer it uses in the channel struct.
2012-11-11 17:05:39 -05:00
if ((ib->flags & CF_DONT_READ) || channel_full(ib)) {
MEDIUM: stream_interface: offer a generic function for connection updates We need to have a generic function to be called by upper layers when buffer flags have been updated (the si->update function). At the moment, both sock_raw and sock_ssl had their own which basically was a copy-paste. Since these functions are only used to update stream interface flags, it is logical to have them handled by the stream interface code. This allowed us to remove the stream_interface-specific update function from sock_raw and sock_ssl which now use the generic code. The stream_sock_update_conn callback has also been more appropriately renamed conn_notify_si() since it's meant to be called by lower layers to notify the SI and possibly upper layers about incoming changes.
2012-08-20 06:06:26 -04:00
/* stop reading */
if (!(si->flags & SI_FL_WAIT_ROOM)) {
CLEANUP: channel: remove any reference of the hijackers Hijackers were functions designed to inject data into channels in the distant past. They became unused around 1.3.16, and since there has not been any user of this mechanism to date, it's uncertain whether the mechanism still works (and it's not really useful anymore). So better remove it as well as the pointer it uses in the channel struct.
2012-11-11 17:05:39 -05:00
if (!(ib->flags & CF_DONT_READ)) /* full */
MEDIUM: stream_interface: offer a generic function for connection updates We need to have a generic function to be called by upper layers when buffer flags have been updated (the si->update function). At the moment, both sock_raw and sock_ssl had their own which basically was a copy-paste. Since these functions are only used to update stream interface flags, it is logical to have them handled by the stream interface code. This allowed us to remove the stream_interface-specific update function from sock_raw and sock_ssl which now use the generic code. The stream_sock_update_conn callback has also been more appropriately renamed conn_notify_si() since it's meant to be called by lower layers to notify the SI and possibly upper layers about incoming changes.
2012-08-20 06:06:26 -04:00
si->flags |= SI_FL_WAIT_ROOM;
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
conn_data_stop_recv(conn);
MEDIUM: stream_interface: offer a generic function for connection updates We need to have a generic function to be called by upper layers when buffer flags have been updated (the si->update function). At the moment, both sock_raw and sock_ssl had their own which basically was a copy-paste. Since these functions are only used to update stream interface flags, it is logical to have them handled by the stream interface code. This allowed us to remove the stream_interface-specific update function from sock_raw and sock_ssl which now use the generic code. The stream_sock_update_conn callback has also been more appropriately renamed conn_notify_si() since it's meant to be called by lower layers to notify the SI and possibly upper layers about incoming changes.
2012-08-20 06:06:26 -04:00
ib->rex = TICK_ETERNITY;
}
}
else {
/* (re)start reading and update timeout. Note: we don't recompute the timeout
* everytime we get here, otherwise it would risk never to expire. We only
* update it if is was not yet set. The stream socket handler will already
* have updated it if there has been a completed I/O.
*/
si->flags &= ~SI_FL_WAIT_ROOM;
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
conn_data_want_recv(conn);
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
if (!(ib->flags & (CF_READ_NOEXP|CF_DONT_READ)) && !tick_isset(ib->rex))
MEDIUM: stream_interface: offer a generic function for connection updates We need to have a generic function to be called by upper layers when buffer flags have been updated (the si->update function). At the moment, both sock_raw and sock_ssl had their own which basically was a copy-paste. Since these functions are only used to update stream interface flags, it is logical to have them handled by the stream interface code. This allowed us to remove the stream_interface-specific update function from sock_raw and sock_ssl which now use the generic code. The stream_sock_update_conn callback has also been more appropriately renamed conn_notify_si() since it's meant to be called by lower layers to notify the SI and possibly upper layers about incoming changes.
2012-08-20 06:06:26 -04:00
ib->rex = tick_add_ifset(now_ms, ib->rto);
}
}
/* Check if we need to close the write side */
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
if (!(ob->flags & CF_SHUTW)) {
MEDIUM: stream_interface: offer a generic function for connection updates We need to have a generic function to be called by upper layers when buffer flags have been updated (the si->update function). At the moment, both sock_raw and sock_ssl had their own which basically was a copy-paste. Since these functions are only used to update stream interface flags, it is logical to have them handled by the stream interface code. This allowed us to remove the stream_interface-specific update function from sock_raw and sock_ssl which now use the generic code. The stream_sock_update_conn callback has also been more appropriately renamed conn_notify_si() since it's meant to be called by lower layers to notify the SI and possibly upper layers about incoming changes.
2012-08-20 06:06:26 -04:00
/* Write not closed, update FD status and timeout for writes */
MAJOR: channel: remove the BF_OUT_EMPTY flag This flag was very problematic because it was composite in that both changes to the pipe or to the buffer had to cause this flag to be updated, which is not always simple (eg: there may not even be a channel attached to a buffer at all). There were not that many users of this flags, mostly setters. So the flag got replaced with a macro which reports whether the channel is empty or not, by checking both the pipe and the buffer. One part of the change is sensible : the flag was also part of BF_MASK_STATIC, which is used by process_session() to rescan all analysers in case the flag's status changes. At first glance, none of the analysers seems to change its mind base on this flag when it is subject to change, so it seems fine not to add variation checks here. Otherwise it's possible that checking the buffer's output size is more useful than checking the flag's replacement.
2012-08-24 16:40:29 -04:00
if (channel_is_empty(ob)) {
MEDIUM: stream_interface: offer a generic function for connection updates We need to have a generic function to be called by upper layers when buffer flags have been updated (the si->update function). At the moment, both sock_raw and sock_ssl had their own which basically was a copy-paste. Since these functions are only used to update stream interface flags, it is logical to have them handled by the stream interface code. This allowed us to remove the stream_interface-specific update function from sock_raw and sock_ssl which now use the generic code. The stream_sock_update_conn callback has also been more appropriately renamed conn_notify_si() since it's meant to be called by lower layers to notify the SI and possibly upper layers about incoming changes.
2012-08-20 06:06:26 -04:00
/* stop writing */
if (!(si->flags & SI_FL_WAIT_DATA)) {
CLEANUP: channel: remove any reference of the hijackers Hijackers were functions designed to inject data into channels in the distant past. They became unused around 1.3.16, and since there has not been any user of this mechanism to date, it's uncertain whether the mechanism still works (and it's not really useful anymore). So better remove it as well as the pointer it uses in the channel struct.
2012-11-11 17:05:39 -05:00
if ((ob->flags & CF_SHUTW_NOW) == 0)
MEDIUM: stream_interface: offer a generic function for connection updates We need to have a generic function to be called by upper layers when buffer flags have been updated (the si->update function). At the moment, both sock_raw and sock_ssl had their own which basically was a copy-paste. Since these functions are only used to update stream interface flags, it is logical to have them handled by the stream interface code. This allowed us to remove the stream_interface-specific update function from sock_raw and sock_ssl which now use the generic code. The stream_sock_update_conn callback has also been more appropriately renamed conn_notify_si() since it's meant to be called by lower layers to notify the SI and possibly upper layers about incoming changes.
2012-08-20 06:06:26 -04:00
si->flags |= SI_FL_WAIT_DATA;
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
conn_data_stop_send(conn);
MEDIUM: stream_interface: offer a generic function for connection updates We need to have a generic function to be called by upper layers when buffer flags have been updated (the si->update function). At the moment, both sock_raw and sock_ssl had their own which basically was a copy-paste. Since these functions are only used to update stream interface flags, it is logical to have them handled by the stream interface code. This allowed us to remove the stream_interface-specific update function from sock_raw and sock_ssl which now use the generic code. The stream_sock_update_conn callback has also been more appropriately renamed conn_notify_si() since it's meant to be called by lower layers to notify the SI and possibly upper layers about incoming changes.
2012-08-20 06:06:26 -04:00
ob->wex = TICK_ETERNITY;
}
}
else {
/* (re)start writing and update timeout. Note: we don't recompute the timeout
* everytime we get here, otherwise it would risk never to expire. We only
* update it if is was not yet set. The stream socket handler will already
* have updated it if there has been a completed I/O.
*/
si->flags &= ~SI_FL_WAIT_DATA;
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
conn_data_want_send(conn);
MEDIUM: stream_interface: offer a generic function for connection updates We need to have a generic function to be called by upper layers when buffer flags have been updated (the si->update function). At the moment, both sock_raw and sock_ssl had their own which basically was a copy-paste. Since these functions are only used to update stream interface flags, it is logical to have them handled by the stream interface code. This allowed us to remove the stream_interface-specific update function from sock_raw and sock_ssl which now use the generic code. The stream_sock_update_conn callback has also been more appropriately renamed conn_notify_si() since it's meant to be called by lower layers to notify the SI and possibly upper layers about incoming changes.
2012-08-20 06:06:26 -04:00
if (!tick_isset(ob->wex)) {
ob->wex = tick_add_ifset(now_ms, ob->wto);
if (tick_isset(ib->rex) && !(si->flags & SI_FL_INDEP_STR)) {
/* Note: depending on the protocol, we don't know if we're waiting
* for incoming data or not. So in order to prevent the socket from
* expiring read timeouts during writes, we refresh the read timeout,
* except if it was already infinite or if we have explicitly setup
* independent streams.
*/
ib->rex = tick_add_ifset(now_ms, ib->rto);
}
}
}
}
}
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
/*
* This function performs a shutdown-read on a stream interface attached to
* a connection in a connected or init state (it does nothing for other
* states). It either shuts the read side or marks itself as closed. The buffer
* flags are updated to reflect the new state. If the stream interface has
* SI_FL_NOHALF, we also forward the close to the write side. If a control
* layer is defined, then it is supposed to be a socket layer and file
MINOR: stream-int: make the shutr/shutw functions void This is to be more consistent with the other functions. The only reason why these functions used to return a value was to let the caller adjust polling by itself, but now their only callers were the si_shutr()/si_shutw() inline functions. Now these functions do not depend anymore on the connection. These connection variant of these functions now call conn_data_stop_recv()/conn_data_stop_send() before returning order not to require a return code anymore. The applet version does not need this at all.
2013-09-29 09:16:03 -04:00
* descriptors are then shutdown or closed accordingly. The function
* automatically disables polling if needed.
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
*/
MINOR: stream-int: make the shutr/shutw functions void This is to be more consistent with the other functions. The only reason why these functions used to return a value was to let the caller adjust polling by itself, but now their only callers were the si_shutr()/si_shutw() inline functions. Now these functions do not depend anymore on the connection. These connection variant of these functions now call conn_data_stop_recv()/conn_data_stop_send() before returning order not to require a return code anymore. The applet version does not need this at all.
2013-09-29 09:16:03 -04:00
static void stream_int_shutr_conn(struct stream_interface *si)
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
{
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
struct connection *conn = __objt_conn(si->end);
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
si->ib->flags &= ~CF_SHUTR_NOW;
if (si->ib->flags & CF_SHUTR)
MINOR: stream-int: make the shutr/shutw functions void This is to be more consistent with the other functions. The only reason why these functions used to return a value was to let the caller adjust polling by itself, but now their only callers were the si_shutr()/si_shutw() inline functions. Now these functions do not depend anymore on the connection. These connection variant of these functions now call conn_data_stop_recv()/conn_data_stop_send() before returning order not to require a return code anymore. The applet version does not need this at all.
2013-09-29 09:16:03 -04:00
return;
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
si->ib->flags |= CF_SHUTR;
si->ib->rex = TICK_ETERNITY;
si->flags &= ~SI_FL_WAIT_ROOM;
if (si->state != SI_ST_EST && si->state != SI_ST_CON)
MINOR: stream-int: make the shutr/shutw functions void This is to be more consistent with the other functions. The only reason why these functions used to return a value was to let the caller adjust polling by itself, but now their only callers were the si_shutr()/si_shutw() inline functions. Now these functions do not depend anymore on the connection. These connection variant of these functions now call conn_data_stop_recv()/conn_data_stop_send() before returning order not to require a return code anymore. The applet version does not need this at all.
2013-09-29 09:16:03 -04:00
return;
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
if (si->ob->flags & CF_SHUTW) {
MINOR: stream-int: make the shutr/shutw functions void This is to be more consistent with the other functions. The only reason why these functions used to return a value was to let the caller adjust polling by itself, but now their only callers were the si_shutr()/si_shutw() inline functions. Now these functions do not depend anymore on the connection. These connection variant of these functions now call conn_data_stop_recv()/conn_data_stop_send() before returning order not to require a return code anymore. The applet version does not need this at all.
2013-09-29 09:16:03 -04:00
conn_full_close(conn);
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
si->state = SI_ST_DIS;
si->exp = TICK_ETERNITY;
}
else if (si->flags & SI_FL_NOHALF) {
/* we want to immediately forward this close to the write side */
return stream_int_shutw_conn(si);
}
else if (conn->ctrl) {
/* we want the caller to disable polling on this FD */
MINOR: stream-int: make the shutr/shutw functions void This is to be more consistent with the other functions. The only reason why these functions used to return a value was to let the caller adjust polling by itself, but now their only callers were the si_shutr()/si_shutw() inline functions. Now these functions do not depend anymore on the connection. These connection variant of these functions now call conn_data_stop_recv()/conn_data_stop_send() before returning order not to require a return code anymore. The applet version does not need this at all.
2013-09-29 09:16:03 -04:00
conn_data_stop_recv(conn);
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
}
}
/*
* This function performs a shutdown-write on a stream interface attached to
* a connection in a connected or init state (it does nothing for other
* states). It either shuts the write side or marks itself as closed. The
* buffer flags are updated to reflect the new state. It does also close
* everything if the SI was marked as being in error state. If there is a
* data-layer shutdown, it is called. If a control layer is defined, then it is
* supposed to be a socket layer and file descriptors are then shutdown or
MINOR: stream-int: make the shutr/shutw functions void This is to be more consistent with the other functions. The only reason why these functions used to return a value was to let the caller adjust polling by itself, but now their only callers were the si_shutr()/si_shutw() inline functions. Now these functions do not depend anymore on the connection. These connection variant of these functions now call conn_data_stop_recv()/conn_data_stop_send() before returning order not to require a return code anymore. The applet version does not need this at all.
2013-09-29 09:16:03 -04:00
* closed accordingly. The function automatically disables polling if needed.
* Note: at the moment, we continue to check conn->ctrl eventhough we *know* it
* is valid. This will help selecting the proper shutdown() and setsockopt()
* calls if/when we implement remote sockets later.
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
*/
MINOR: stream-int: make the shutr/shutw functions void This is to be more consistent with the other functions. The only reason why these functions used to return a value was to let the caller adjust polling by itself, but now their only callers were the si_shutr()/si_shutw() inline functions. Now these functions do not depend anymore on the connection. These connection variant of these functions now call conn_data_stop_recv()/conn_data_stop_send() before returning order not to require a return code anymore. The applet version does not need this at all.
2013-09-29 09:16:03 -04:00
static void stream_int_shutw_conn(struct stream_interface *si)
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
{
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
struct connection *conn = __objt_conn(si->end);
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
si->ob->flags &= ~CF_SHUTW_NOW;
if (si->ob->flags & CF_SHUTW)
MINOR: stream-int: make the shutr/shutw functions void This is to be more consistent with the other functions. The only reason why these functions used to return a value was to let the caller adjust polling by itself, but now their only callers were the si_shutr()/si_shutw() inline functions. Now these functions do not depend anymore on the connection. These connection variant of these functions now call conn_data_stop_recv()/conn_data_stop_send() before returning order not to require a return code anymore. The applet version does not need this at all.
2013-09-29 09:16:03 -04:00
return;
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
si->ob->flags |= CF_SHUTW;
si->ob->wex = TICK_ETERNITY;
si->flags &= ~SI_FL_WAIT_DATA;
switch (si->state) {
case SI_ST_EST:
/* we have to shut before closing, otherwise some short messages
* may never leave the system, especially when there are remaining
* unread data in the socket input buffer, or when nolinger is set.
* However, if SI_FL_NOLINGER is explicitly set, we know there is
* no risk so we close both sides immediately.
*/
if (si->flags & SI_FL_ERR) {
/* quick close, the socket is alredy shut anyway */
}
else if (si->flags & SI_FL_NOLINGER) {
/* unclean data-layer shutdown */
if (conn->xprt && conn->xprt->shutw)
conn->xprt->shutw(conn, 0);
}
else {
/* clean data-layer shutdown */
if (conn->xprt && conn->xprt->shutw)
conn->xprt->shutw(conn, 1);
/* If the stream interface is configured to disable half-open
* connections, we'll skip the shutdown(), but only if the
* read size is already closed. Otherwise we can't support
* closed write with pending read (eg: abortonclose while
* waiting for the server).
*/
if (!(si->flags & SI_FL_NOHALF) || !(si->ib->flags & (CF_SHUTR|CF_DONT_READ))) {
/* We shutdown transport layer */
MINOR: connection: add simple functions to report connection readiness conn_xprt_ready() reports if the transport layer is ready. conn_ctrl_ready() reports if the control layer is ready. The stream interface uses si_conn_ready() to report that the underlying connection is ready. This will be used for connection reuse in keep-alive mode.
2013-12-15 04:23:20 -05:00
if (conn_ctrl_ready(conn))
MINOR: stream-int: make the shutr/shutw functions void This is to be more consistent with the other functions. The only reason why these functions used to return a value was to let the caller adjust polling by itself, but now their only callers were the si_shutr()/si_shutw() inline functions. Now these functions do not depend anymore on the connection. These connection variant of these functions now call conn_data_stop_recv()/conn_data_stop_send() before returning order not to require a return code anymore. The applet version does not need this at all.
2013-09-29 09:16:03 -04:00
shutdown(conn->t.sock.fd, SHUT_WR);
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
if (!(si->ib->flags & (CF_SHUTR|CF_DONT_READ))) {
/* OK just a shutw, but we want the caller
* to disable polling on this FD if exists.
*/
MINOR: stream-int: make the shutr/shutw functions void This is to be more consistent with the other functions. The only reason why these functions used to return a value was to let the caller adjust polling by itself, but now their only callers were the si_shutr()/si_shutw() inline functions. Now these functions do not depend anymore on the connection. These connection variant of these functions now call conn_data_stop_recv()/conn_data_stop_send() before returning order not to require a return code anymore. The applet version does not need this at all.
2013-09-29 09:16:03 -04:00
if (conn->ctrl)
conn_data_stop_send(conn);
return;
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
}
}
}
/* fall through */
case SI_ST_CON:
/* we may have to close a pending connection, and mark the
* response buffer as shutr
*/
MINOR: stream-int: make the shutr/shutw functions void This is to be more consistent with the other functions. The only reason why these functions used to return a value was to let the caller adjust polling by itself, but now their only callers were the si_shutr()/si_shutw() inline functions. Now these functions do not depend anymore on the connection. These connection variant of these functions now call conn_data_stop_recv()/conn_data_stop_send() before returning order not to require a return code anymore. The applet version does not need this at all.
2013-09-29 09:16:03 -04:00
conn_full_close(conn);
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
/* fall through */
case SI_ST_CER:
case SI_ST_QUE:
case SI_ST_TAR:
si->state = SI_ST_DIS;
MAJOR: stream interface: remove the ->release function pointer Since last commit, we now have a pointer to the applet in the applet context. So we don't need the si->release function pointer anymore, it can be extracted from applet->applet.release. At many places, the ->release function was still tested for real connections while it is only limited to applets, so most of them were simply removed. For the remaining valid uses, a new inline function si_applet_release() was added to simplify the check and the call.
2013-10-24 14:10:45 -04:00
/* fall through */
MEDIUM: stream-int: split the shutr/shutw functions between applet and conn These functions induce a lot of ifs everywhere because they consider two different cases, one which is where the connection exists and has a file descriptor, and the other one which is the default case where at most an applet has to be notified. Let's have them in si_ops and automatically decide which one to use. The connection shutdown sequence has been slightly simplified, and we now clear the flags at the end. Also we remove SHUTR_NOW after a shutw with nolinger, as it's cleaner not to keep it.
2013-09-29 08:51:58 -04:00
default:
si->flags &= ~(SI_FL_WAIT_ROOM | SI_FL_NOLINGER);
si->ib->flags &= ~CF_SHUTR_NOW;
si->ib->flags |= CF_SHUTR;
si->ib->rex = TICK_ETERNITY;
si->exp = TICK_ETERNITY;
}
}
MEDIUM: stream-interface: offer a generic chk_rcv function for connections sock_raw and sock_ssl use a pretty generic chk_rcv function, so let's move this function to the stream_interface and remove specific functions. Later we might have a single chk_rcv function.
2012-08-20 06:38:36 -04:00
/* This function is used for inter-stream-interface calls. It is called by the
* consumer to inform the producer side that it may be interested in checking
* for free space in the buffer. Note that it intentionally does not update
* timeouts, so that we can still check them later at wake-up. This function is
* dedicated to connection-based stream interfaces.
*/
CLEANUP: connection: split sock_ops into data_ops, app_cp and si_ops Some parts of the sock_ops structure were only used by the stream interface and have been moved into si_ops. Some of them were callbacks to the stream interface from the connection and have been moved into app_cp as they're the application seen from the connection (later, health-checks will need to use them). The rest has moved to data_ops. Normally at this point the connection could live without knowing about stream interfaces at all.
2012-08-24 12:12:41 -04:00
static void stream_int_chk_rcv_conn(struct stream_interface *si)
MEDIUM: stream-interface: offer a generic chk_rcv function for connections sock_raw and sock_ssl use a pretty generic chk_rcv function, so let's move this function to the stream_interface and remove specific functions. Later we might have a single chk_rcv function.
2012-08-20 06:38:36 -04:00
{
REORG/MAJOR: use "struct channel" instead of "struct buffer" This is a massive rename. We'll then split channel and buffer. This change needs a lot of cleanups. At many locations, the parameter or variable is still called "buf" which will become ambiguous. Also, the "struct channel" is still defined in buffers.h.
2012-07-02 09:11:27 -04:00
struct channel *ib = si->ib;
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
struct connection *conn = __objt_conn(si->end);
MEDIUM: stream-interface: offer a generic chk_rcv function for connections sock_raw and sock_ssl use a pretty generic chk_rcv function, so let's move this function to the stream_interface and remove specific functions. Later we might have a single chk_rcv function.
2012-08-20 06:38:36 -04:00
MAJOR: stream_interface: continue to update data polling flags during handshakes Since data and socket polling flags were split, it became possible to update data flags even during handshakes. In fact this is very important otherwise it is not possible to poll for writes if some data are to be forwarded during a handshake (eg: data received during an SSL connect).
2012-09-03 10:51:27 -04:00
if (unlikely(si->state > SI_ST_EST || (ib->flags & CF_SHUTR)))
MEDIUM: stream-interface: offer a generic chk_rcv function for connections sock_raw and sock_ssl use a pretty generic chk_rcv function, so let's move this function to the stream_interface and remove specific functions. Later we might have a single chk_rcv function.
2012-08-20 06:38:36 -04:00
return;
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
conn_refresh_polling_flags(conn);
BUG/MEDIUM: connection: always update connection flags prior to computing polling stream_int_chk_rcv_conn() did not clear connection flags before updating them. It is unsure whether this could have caused the stalled transfers that have been reported since dev15. In order to avoid such further issues, we now use a simple inline function to do all the job.
2012-12-16 13:19:13 -05:00
CLEANUP: channel: remove any reference of the hijackers Hijackers were functions designed to inject data into channels in the distant past. They became unused around 1.3.16, and since there has not been any user of this mechanism to date, it's uncertain whether the mechanism still works (and it's not really useful anymore). So better remove it as well as the pointer it uses in the channel struct.
2012-11-11 17:05:39 -05:00
if ((ib->flags & CF_DONT_READ) || channel_full(ib)) {
MEDIUM: stream-interface: offer a generic chk_rcv function for connections sock_raw and sock_ssl use a pretty generic chk_rcv function, so let's move this function to the stream_interface and remove specific functions. Later we might have a single chk_rcv function.
2012-08-20 06:38:36 -04:00
/* stop reading */
CLEANUP: channel: remove any reference of the hijackers Hijackers were functions designed to inject data into channels in the distant past. They became unused around 1.3.16, and since there has not been any user of this mechanism to date, it's uncertain whether the mechanism still works (and it's not really useful anymore). So better remove it as well as the pointer it uses in the channel struct.
2012-11-11 17:05:39 -05:00
if (!(ib->flags & CF_DONT_READ)) /* full */
MEDIUM: stream-interface: offer a generic chk_rcv function for connections sock_raw and sock_ssl use a pretty generic chk_rcv function, so let's move this function to the stream_interface and remove specific functions. Later we might have a single chk_rcv function.
2012-08-20 06:38:36 -04:00
si->flags |= SI_FL_WAIT_ROOM;
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
__conn_data_stop_recv(conn);
MEDIUM: stream-interface: offer a generic chk_rcv function for connections sock_raw and sock_ssl use a pretty generic chk_rcv function, so let's move this function to the stream_interface and remove specific functions. Later we might have a single chk_rcv function.
2012-08-20 06:38:36 -04:00
}
else {
/* (re)start reading */
si->flags &= ~SI_FL_WAIT_ROOM;
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
__conn_data_want_recv(conn);
MEDIUM: stream-interface: offer a generic chk_rcv function for connections sock_raw and sock_ssl use a pretty generic chk_rcv function, so let's move this function to the stream_interface and remove specific functions. Later we might have a single chk_rcv function.
2012-08-20 06:38:36 -04:00
}
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
conn_cond_update_data_polling(conn);
MEDIUM: stream-interface: offer a generic chk_rcv function for connections sock_raw and sock_ssl use a pretty generic chk_rcv function, so let's move this function to the stream_interface and remove specific functions. Later we might have a single chk_rcv function.
2012-08-20 06:38:36 -04:00
}
MEDIUM: stream-interface: provide a generic stream_int_chk_snd_conn() function This one can be used by both sock_raw and sock_ssl instead of each having their own.
2012-08-20 09:01:10 -04:00
/* This function is used for inter-stream-interface calls. It is called by the
* producer to inform the consumer side that it may be interested in checking
* for data in the buffer. Note that it intentionally does not update timeouts,
* so that we can still check them later at wake-up.
*/
CLEANUP: connection: split sock_ops into data_ops, app_cp and si_ops Some parts of the sock_ops structure were only used by the stream interface and have been moved into si_ops. Some of them were callbacks to the stream interface from the connection and have been moved into app_cp as they're the application seen from the connection (later, health-checks will need to use them). The rest has moved to data_ops. Normally at this point the connection could live without knowing about stream interfaces at all.
2012-08-24 12:12:41 -04:00
static void stream_int_chk_snd_conn(struct stream_interface *si)
MEDIUM: stream-interface: provide a generic stream_int_chk_snd_conn() function This one can be used by both sock_raw and sock_ssl instead of each having their own.
2012-08-20 09:01:10 -04:00
{
REORG/MAJOR: use "struct channel" instead of "struct buffer" This is a massive rename. We'll then split channel and buffer. This change needs a lot of cleanups. At many locations, the parameter or variable is still called "buf" which will become ambiguous. Also, the "struct channel" is still defined in buffers.h.
2012-07-02 09:11:27 -04:00
struct channel *ob = si->ob;
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
struct connection *conn = __objt_conn(si->end);
MEDIUM: stream-interface: provide a generic stream_int_chk_snd_conn() function This one can be used by both sock_raw and sock_ssl instead of each having their own.
2012-08-20 09:01:10 -04:00
MAJOR: stream_interface: continue to update data polling flags during handshakes Since data and socket polling flags were split, it became possible to update data flags even during handshakes. In fact this is very important otherwise it is not possible to poll for writes if some data are to be forwarded during a handshake (eg: data received during an SSL connect).
2012-09-03 10:51:27 -04:00
if (unlikely(si->state > SI_ST_EST || (ob->flags & CF_SHUTW)))
MEDIUM: stream-interface: provide a generic stream_int_chk_snd_conn() function This one can be used by both sock_raw and sock_ssl instead of each having their own.
2012-08-20 09:01:10 -04:00
return;
MAJOR: channel: remove the BF_OUT_EMPTY flag This flag was very problematic because it was composite in that both changes to the pipe or to the buffer had to cause this flag to be updated, which is not always simple (eg: there may not even be a channel attached to a buffer at all). There were not that many users of this flags, mostly setters. So the flag got replaced with a macro which reports whether the channel is empty or not, by checking both the pipe and the buffer. One part of the change is sensible : the flag was also part of BF_MASK_STATIC, which is used by process_session() to rescan all analysers in case the flag's status changes. At first glance, none of the analysers seems to change its mind base on this flag when it is subject to change, so it seems fine not to add variation checks here. Otherwise it's possible that checking the buffer's output size is more useful than checking the flag's replacement.
2012-08-24 16:40:29 -04:00
if (unlikely(channel_is_empty(ob))) /* called with nothing to send ! */
MEDIUM: stream-interface: provide a generic stream_int_chk_snd_conn() function This one can be used by both sock_raw and sock_ssl instead of each having their own.
2012-08-20 09:01:10 -04:00
return;
if (!ob->pipe && /* spliced data wants to be forwarded ASAP */
BUG/MINOR: stream_interface: don't return when the fd is already set Back in the days where polling was made with select() where all FDs were checked at once, stream_int_chk_snd_conn() used to check whether the file descriptor it was passed was ready or not, so that it did not perform the work for nothing. Right now FDs are checked just before calling the I/O handler so this test never matches at best, or may return false information at worst. Since conn_fd_handler() always clears the flags upon exit, it looks like a missed event cannot happen right now. Still, better remove this outdated check than wait for it to cause issues.
2012-12-15 04:12:39 -05:00
!(si->flags & SI_FL_WAIT_DATA)) /* not waiting for data */
MEDIUM: stream-interface: provide a generic stream_int_chk_snd_conn() function This one can be used by both sock_raw and sock_ssl instead of each having their own.
2012-08-20 09:01:10 -04:00
return;
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
if (conn->flags & (CO_FL_DATA_WR_ENA|CO_FL_CURR_WR_ENA)) {
BUG/MINOR: stream_interface: don't call chk_snd() on polled events As explained in previous patch, we incorrectly call chk_snd() when performing a read even if the write event is already subscribed to poll(). This is counter-productive because we're almost sure to get an EAGAIN. A quick test shows that this fix halves the number of failed splice() calls without adding any extra work on other syscalls. This could have been tagged as an improvement, but since this behaviour made the analysis of previous bug more complex, it still qualifies as a fix.
2013-07-18 16:09:48 -04:00
/* already subscribed to write notifications, will be called
* anyway, so let's avoid calling it especially if the reader
* is not ready.
*/
return;
}
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
if (!(conn->flags & (CO_FL_HANDSHAKE|CO_FL_WAIT_L4_CONN|CO_FL_WAIT_L6_CONN))) {
BUG/MAJOR: connection: always recompute polling status upon I/O Bryan Berry and Baptiste Assmann both reported some occasional CPU spinning loops where haproxy was still processing I/O but burning CPU for apparently uncaught events. What happens is the following sequence : - proxy is in TCP mode - a connection from a client initiates a connection to a server - the connection to the server does not immediately happen and is polled for - in the mean time, the client speaks and the stream interface calls ->chk_snd() on the peer connection to send the new data - chk_snd() calls send_loop() to send the data. This last one makes the connection succeed and empties the buffer, so it disables polling on the connection and on the FD by creating an update entry. - before the update is processed, poll() succeeds and reports a write event for this fd. The poller does fd_ev_set() on the FD to switch it to speculative mode - the IO handler is called with a connection which has no write flag but an FD which is enabled in speculative mode. - the connection does nothing useful. - conn_update_polling() at the end of conn_fd_handler() cannot disable the FD because there were no changes on this FD. - the handler is left with speculative polling still enabled on the FD, and will be called over and over until a poll event is needed to transfer data. There is no perfectly elegant solution to this. At least we should update the flags indicating the current polling status to reflect what is being done at the FD level. This will allow to detect that the FD needs to be disabled upon exit. chk_snd() also needs minor changes to correctly switch to speculative polling before calling send_loop(), and to reflect this in the connection flags. This is needed so that no event remains stuck there without any polling. In fact, chk_snd() and chk_rcv() should perform the same number of preparations and cleanups as conn_fd_handler().
2012-12-10 10:33:38 -05:00
/* Before calling the data-level operations, we have to prepare
* the polling flags to ensure we properly detect changes.
MEDIUM: stream-interface: provide a generic stream_int_chk_snd_conn() function This one can be used by both sock_raw and sock_ssl instead of each having their own.
2012-08-20 09:01:10 -04:00
*/
MINOR: connection: add simple functions to report connection readiness conn_xprt_ready() reports if the transport layer is ready. conn_ctrl_ready() reports if the control layer is ready. The stream interface uses si_conn_ready() to report that the underlying connection is ready. This will be used for connection reuse in keep-alive mode.
2013-12-15 04:23:20 -05:00
if (conn_ctrl_ready(conn))
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
fd_want_send(conn->t.sock.fd);
BUG/MEDIUM: connection: always update connection flags prior to computing polling stream_int_chk_rcv_conn() did not clear connection flags before updating them. It is unsure whether this could have caused the stalled transfers that have been reported since dev15. In order to avoid such further issues, we now use a simple inline function to do all the job.
2012-12-16 13:19:13 -05:00
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
conn_refresh_polling_flags(conn);
BUG/MAJOR: connection: always recompute polling status upon I/O Bryan Berry and Baptiste Assmann both reported some occasional CPU spinning loops where haproxy was still processing I/O but burning CPU for apparently uncaught events. What happens is the following sequence : - proxy is in TCP mode - a connection from a client initiates a connection to a server - the connection to the server does not immediately happen and is polled for - in the mean time, the client speaks and the stream interface calls ->chk_snd() on the peer connection to send the new data - chk_snd() calls send_loop() to send the data. This last one makes the connection succeed and empties the buffer, so it disables polling on the connection and on the FD by creating an update entry. - before the update is processed, poll() succeeds and reports a write event for this fd. The poller does fd_ev_set() on the FD to switch it to speculative mode - the IO handler is called with a connection which has no write flag but an FD which is enabled in speculative mode. - the connection does nothing useful. - conn_update_polling() at the end of conn_fd_handler() cannot disable the FD because there were no changes on this FD. - the handler is left with speculative polling still enabled on the FD, and will be called over and over until a poll event is needed to transfer data. There is no perfectly elegant solution to this. At least we should update the flags indicating the current polling status to reflect what is being done at the FD level. This will allow to detect that the FD needs to be disabled upon exit. chk_snd() also needs minor changes to correctly switch to speculative polling before calling send_loop(), and to reflect this in the connection flags. This is needed so that no event remains stuck there without any polling. In fact, chk_snd() and chk_rcv() should perform the same number of preparations and cleanups as conn_fd_handler().
2012-12-10 10:33:38 -05:00
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
si_conn_send(conn);
MINOR: connection: add simple functions to report connection readiness conn_xprt_ready() reports if the transport layer is ready. conn_ctrl_ready() reports if the control layer is ready. The stream interface uses si_conn_ready() to report that the underlying connection is ready. This will be used for connection reuse in keep-alive mode.
2013-12-15 04:23:20 -05:00
if (conn_ctrl_ready(conn) && (conn->flags & CO_FL_ERROR)) {
BUG/MAJOR: connection: always recompute polling status upon I/O Bryan Berry and Baptiste Assmann both reported some occasional CPU spinning loops where haproxy was still processing I/O but burning CPU for apparently uncaught events. What happens is the following sequence : - proxy is in TCP mode - a connection from a client initiates a connection to a server - the connection to the server does not immediately happen and is polled for - in the mean time, the client speaks and the stream interface calls ->chk_snd() on the peer connection to send the new data - chk_snd() calls send_loop() to send the data. This last one makes the connection succeed and empties the buffer, so it disables polling on the connection and on the FD by creating an update entry. - before the update is processed, poll() succeeds and reports a write event for this fd. The poller does fd_ev_set() on the FD to switch it to speculative mode - the IO handler is called with a connection which has no write flag but an FD which is enabled in speculative mode. - the connection does nothing useful. - conn_update_polling() at the end of conn_fd_handler() cannot disable the FD because there were no changes on this FD. - the handler is left with speculative polling still enabled on the FD, and will be called over and over until a poll event is needed to transfer data. There is no perfectly elegant solution to this. At least we should update the flags indicating the current polling status to reflect what is being done at the FD level. This will allow to detect that the FD needs to be disabled upon exit. chk_snd() also needs minor changes to correctly switch to speculative polling before calling send_loop(), and to reflect this in the connection flags. This is needed so that no event remains stuck there without any polling. In fact, chk_snd() and chk_rcv() should perform the same number of preparations and cleanups as conn_fd_handler().
2012-12-10 10:33:38 -05:00
/* Write error on the file descriptor */
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
fd_stop_both(conn->t.sock.fd);
__conn_data_stop_both(conn);
BUG/MAJOR: connection: always recompute polling status upon I/O Bryan Berry and Baptiste Assmann both reported some occasional CPU spinning loops where haproxy was still processing I/O but burning CPU for apparently uncaught events. What happens is the following sequence : - proxy is in TCP mode - a connection from a client initiates a connection to a server - the connection to the server does not immediately happen and is polled for - in the mean time, the client speaks and the stream interface calls ->chk_snd() on the peer connection to send the new data - chk_snd() calls send_loop() to send the data. This last one makes the connection succeed and empties the buffer, so it disables polling on the connection and on the FD by creating an update entry. - before the update is processed, poll() succeeds and reports a write event for this fd. The poller does fd_ev_set() on the FD to switch it to speculative mode - the IO handler is called with a connection which has no write flag but an FD which is enabled in speculative mode. - the connection does nothing useful. - conn_update_polling() at the end of conn_fd_handler() cannot disable the FD because there were no changes on this FD. - the handler is left with speculative polling still enabled on the FD, and will be called over and over until a poll event is needed to transfer data. There is no perfectly elegant solution to this. At least we should update the flags indicating the current polling status to reflect what is being done at the FD level. This will allow to detect that the FD needs to be disabled upon exit. chk_snd() also needs minor changes to correctly switch to speculative polling before calling send_loop(), and to reflect this in the connection flags. This is needed so that no event remains stuck there without any polling. In fact, chk_snd() and chk_rcv() should perform the same number of preparations and cleanups as conn_fd_handler().
2012-12-10 10:33:38 -05:00
si->flags |= SI_FL_ERR;
goto out_wakeup;
}
MEDIUM: stream-interface: provide a generic stream_int_chk_snd_conn() function This one can be used by both sock_raw and sock_ssl instead of each having their own.
2012-08-20 09:01:10 -04:00
}
/* OK, so now we know that some data might have been sent, and that we may
* have to poll first. We have to do that too if the buffer is not empty.
*/
MAJOR: channel: remove the BF_OUT_EMPTY flag This flag was very problematic because it was composite in that both changes to the pipe or to the buffer had to cause this flag to be updated, which is not always simple (eg: there may not even be a channel attached to a buffer at all). There were not that many users of this flags, mostly setters. So the flag got replaced with a macro which reports whether the channel is empty or not, by checking both the pipe and the buffer. One part of the change is sensible : the flag was also part of BF_MASK_STATIC, which is used by process_session() to rescan all analysers in case the flag's status changes. At first glance, none of the analysers seems to change its mind base on this flag when it is subject to change, so it seems fine not to add variation checks here. Otherwise it's possible that checking the buffer's output size is more useful than checking the flag's replacement.
2012-08-24 16:40:29 -04:00
if (channel_is_empty(ob)) {
MEDIUM: stream-interface: provide a generic stream_int_chk_snd_conn() function This one can be used by both sock_raw and sock_ssl instead of each having their own.
2012-08-20 09:01:10 -04:00
/* the connection is established but we can't write. Either the
* buffer is empty, or we just refrain from sending because the
* ->o limit was reached. Maybe we just wrote the last
* chunk and need to close.
*/
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
__conn_data_stop_send(conn);
CLEANUP: channel: remove any reference of the hijackers Hijackers were functions designed to inject data into channels in the distant past. They became unused around 1.3.16, and since there has not been any user of this mechanism to date, it's uncertain whether the mechanism still works (and it's not really useful anymore). So better remove it as well as the pointer it uses in the channel struct.
2012-11-11 17:05:39 -05:00
if (((ob->flags & (CF_SHUTW|CF_AUTO_CLOSE|CF_SHUTW_NOW)) ==
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
(CF_AUTO_CLOSE|CF_SHUTW_NOW)) &&
MEDIUM: stream-interface: provide a generic stream_int_chk_snd_conn() function This one can be used by both sock_raw and sock_ssl instead of each having their own.
2012-08-20 09:01:10 -04:00
(si->state == SI_ST_EST)) {
si_shutw(si);
goto out_wakeup;
}
CLEANUP: channel: remove any reference of the hijackers Hijackers were functions designed to inject data into channels in the distant past. They became unused around 1.3.16, and since there has not been any user of this mechanism to date, it's uncertain whether the mechanism still works (and it's not really useful anymore). So better remove it as well as the pointer it uses in the channel struct.
2012-11-11 17:05:39 -05:00
if ((ob->flags & (CF_SHUTW|CF_SHUTW_NOW)) == 0)
MEDIUM: stream-interface: provide a generic stream_int_chk_snd_conn() function This one can be used by both sock_raw and sock_ssl instead of each having their own.
2012-08-20 09:01:10 -04:00
si->flags |= SI_FL_WAIT_DATA;
ob->wex = TICK_ETERNITY;
}
else {
/* Otherwise there are remaining data to be sent in the buffer,
* which means we have to poll before doing so.
*/
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
__conn_data_want_send(conn);
MEDIUM: stream-interface: provide a generic stream_int_chk_snd_conn() function This one can be used by both sock_raw and sock_ssl instead of each having their own.
2012-08-20 09:01:10 -04:00
si->flags &= ~SI_FL_WAIT_DATA;
if (!tick_isset(ob->wex))
ob->wex = tick_add_ifset(now_ms, ob->wto);
}
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
if (likely(ob->flags & CF_WRITE_ACTIVITY)) {
MEDIUM: stream-interface: provide a generic stream_int_chk_snd_conn() function This one can be used by both sock_raw and sock_ssl instead of each having their own.
2012-08-20 09:01:10 -04:00
/* update timeout if we have written something */
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
if ((ob->flags & (CF_SHUTW|CF_WRITE_PARTIAL)) == CF_WRITE_PARTIAL &&
MAJOR: channel: remove the BF_OUT_EMPTY flag This flag was very problematic because it was composite in that both changes to the pipe or to the buffer had to cause this flag to be updated, which is not always simple (eg: there may not even be a channel attached to a buffer at all). There were not that many users of this flags, mostly setters. So the flag got replaced with a macro which reports whether the channel is empty or not, by checking both the pipe and the buffer. One part of the change is sensible : the flag was also part of BF_MASK_STATIC, which is used by process_session() to rescan all analysers in case the flag's status changes. At first glance, none of the analysers seems to change its mind base on this flag when it is subject to change, so it seems fine not to add variation checks here. Otherwise it's possible that checking the buffer's output size is more useful than checking the flag's replacement.
2012-08-24 16:40:29 -04:00
!channel_is_empty(ob))
MEDIUM: stream-interface: provide a generic stream_int_chk_snd_conn() function This one can be used by both sock_raw and sock_ssl instead of each having their own.
2012-08-20 09:01:10 -04:00
ob->wex = tick_add_ifset(now_ms, ob->wto);
if (tick_isset(si->ib->rex) && !(si->flags & SI_FL_INDEP_STR)) {
/* Note: to prevent the client from expiring read timeouts
* during writes, we refresh it. We only do this if the
* interface is not configured for "independent streams",
* because for some applications it's better not to do this,
* for instance when continuously exchanging small amounts
* of data which can full the socket buffers long before a
* write timeout is detected.
*/
si->ib->rex = tick_add_ifset(now_ms, si->ib->rto);
}
}
/* in case of special condition (error, shutdown, end of write...), we
* have to notify the task.
*/
BUG/MEDIUM: stream-interface: don't wake the task up before end of transfer Recent commit d7ad9f5 ("MAJOR: channel: add a new flag CF_WAKE_WRITE to notify the task of writes") was not correct. It used to wake up the task as soon as there was some write activity and the flag was set, even if there were still some data to be forwarded. This resulted in process_session() being called a lot when transfering chunk-encoded HTTP responses made of very large chunks. The purpose of the flag is to wake up only a task waiting for some room and not the other ones, so it's totally counter-productive to wake it up as long as there are data to forward because the task will not be allowed to write anyway. Also, the commit above was taking some risks by not considering certain events anymore (eg: state != SI_ST_EST). While such events are not used at the moment, if some new features were developped in the future relying on these, it would be better that they could be notified when subscribing to the WAKE_WRITE event, so let's restore the condition.
2014-01-24 20:33:21 -05:00
if (likely((ob->flags & (CF_WRITE_NULL|CF_WRITE_ERROR|CF_SHUTW)) ||
((ob->flags & CF_WAKE_WRITE) &&
((channel_is_empty(si->ob) && !ob->to_forward) ||
si->state != SI_ST_EST)))) {
MEDIUM: stream-interface: provide a generic stream_int_chk_snd_conn() function This one can be used by both sock_raw and sock_ssl instead of each having their own.
2012-08-20 09:01:10 -04:00
out_wakeup:
if (!(si->flags & SI_FL_DONT_WAKE) && si->owner)
task_wakeup(si->owner, TASK_WOKEN_IO);
}
MAJOR: stream-interface: don't commit polling changes in every callback It's more efficient to centralize polling changes, which is already done in the connection handler. So now all I/O callbacks just change flags and rely on the connection handler for the commit. The special case of the send loop is handled by the chk_snd() function which does an update at the end.
2012-08-24 06:52:22 -04:00
/* commit possible polling changes */
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
conn_cond_update_polling(conn);
MEDIUM: stream-interface: provide a generic stream_int_chk_snd_conn() function This one can be used by both sock_raw and sock_ssl instead of each having their own.
2012-08-20 09:01:10 -04:00
}
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
/*
* This is the callback which is called by the connection layer to receive data
REORG: connection: rename the data layer the "transport layer" While working on the changes required to make the health checks use the new connections, it started to become obvious that some naming was not logical at all in the connections. Specifically, it is not logical to call the "data layer" the layer which is in charge for all the handshake and which does not yet provide a data layer once established until a session has allocated all the required buffers. In fact, it's more a transport layer, which makes much more sense. The transport layer offers a medium on which data can transit, and it offers the functions to move these data when the upper layer requests this. And it is the upper layer which iterates over the transport layer's functions to move data which should be called the data layer. The use case where it's obvious is with embryonic sessions : an incoming SSL connection is accepted. Only the connection is allocated, not the buffers nor stream interface, etc... The connection handles the SSL handshake by itself. Once this handshake is complete, we can't use the data functions because the buffers and stream interface are not there yet. Hence we have to first call a specific function to complete the session initialization, after which we'll be able to use the data functions. This clearly proves that SSL here is only a transport layer and that the stream interface constitutes the data layer. A similar change will be performed to rename app_cb => data, but the two could not be in the same commit for obvious reasons.
2012-10-02 18:19:48 -04:00
* into the buffer from the connection. It iterates over the transport layer's
* rcv_buf function.
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
*/
MINOR: connection: provide a generic data layer wakeup callback Instead of calling conn_notify_si() from the connection handler, we now call data->wake(), which will allow us to use a different callback with health checks. Note that we still rely on a flag in order to decide whether or not to call this function. The reason is that with embryonic sessions, the callback is already initialized to si_conn_cb without the flag, and we can't call the SI notify function in the leave path before the stream interface is initialized. This issue should be addressed by involving a different data_cb for embryonic sessions and for stream interfaces, that would be changed during session_complete() for the final data_cb.
2012-10-02 14:07:22 -04:00
static void si_conn_recv_cb(struct connection *conn)
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
{
MEDIUM: connection: make use of the owner instead of container_of This way the connection can become independant on the stream interface.
2012-09-27 16:20:41 -04:00
struct stream_interface *si = conn->owner;
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
struct channel *chn = si->ib;
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
int ret, max, cur_read;
int read_poll = MAX_READ_POLL_LOOPS;
/* stop immediately on errors. Note that we DON'T want to stop on
* POLL_ERR, as the poller might report a write error while there
* are still data available in the recv buffer. This typically
* happens when we send too large a request to a backend server
* which rejects it before reading it all.
*/
if (conn->flags & CO_FL_ERROR)
OPTIM: stream_interface: return directly if the connection flag CO_FL_ERROR has been set The connection flag CO_FL_ERROR will be tested in the functions both si_conn_recv_cb() and si_conn_send_cb(). If CO_FL_ERROR has been set, out_error branch will be executed. But the only job of out_error branch is to set CO_FL_ERROR on connection flag. So it's better return directly than goto out_error branch under such conditions. As a result, out_error branch becomes needless and can be removed. In addition, the return type of si_conn_send_loop() is also changed to void. The caller should check conn->flags for errors just like stream_int_chk_snd_conn() does as below: static void stream_int_chk_snd_conn(struct stream_interface *si) { ... conn_refresh_polling_flags(si->conn); - if (si_conn_send(si->conn) < 0) { + si_conn_send(si->conn); + if (si->conn->flags & CO_FL_ERROR) { ... } Signed-off-by: Godbach <nylzhaowei@gmail.com>
2013-12-04 04:24:06 -05:00
return;
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
/* stop here if we reached the end of data */
if (conn_data_read0_pending(conn))
goto out_shutdown_r;
/* maybe we were called immediately after an asynchronous shutr */
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
if (chn->flags & CF_SHUTR)
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
return;
MAJOR: stream-interface: restore splicing mechanism The splicing is now provided by the data-layer rcv_pipe/snd_pipe functions which in turn are called by the stream interface's recv and send callbacks. The presence of the rcv_pipe/snd_pipe functions is used to attest support for splicing at the data layer. It looks like the stream-interface's SI_FL_CAP_SPLICE flag does not make sense anymore as it's used as a proxy for the pointers above. It also appears that we call chk_snd() from the recv callback and then try to call it again in update_conn(). It is very likely that this last function will progressively slip into the recv/send callbacks in order to avoid duplicate check code. The code works right now with and without splicing. Only raw_sock provides support for it and it is automatically selected when the various splice options are set. However it looks like splice-auto doesn't enable it, which possibly means that the streamer detection code does not work anymore, or that it's only called at a time where it's too late to enable splicing (in process_session).
2012-08-23 18:46:52 -04:00
cur_read = 0;
/* First, let's see if we may splice data across the channel without
* using a buffer.
*/
REORG: connection: rename the data layer the "transport layer" While working on the changes required to make the health checks use the new connections, it started to become obvious that some naming was not logical at all in the connections. Specifically, it is not logical to call the "data layer" the layer which is in charge for all the handshake and which does not yet provide a data layer once established until a session has allocated all the required buffers. In fact, it's more a transport layer, which makes much more sense. The transport layer offers a medium on which data can transit, and it offers the functions to move these data when the upper layer requests this. And it is the upper layer which iterates over the transport layer's functions to move data which should be called the data layer. The use case where it's obvious is with embryonic sessions : an incoming SSL connection is accepted. Only the connection is allocated, not the buffers nor stream interface, etc... The connection handles the SSL handshake by itself. Once this handshake is complete, we can't use the data functions because the buffers and stream interface are not there yet. Hence we have to first call a specific function to complete the session initialization, after which we'll be able to use the data functions. This clearly proves that SSL here is only a transport layer and that the stream interface constitutes the data layer. A similar change will be performed to rename app_cb => data, but the two could not be in the same commit for obvious reasons.
2012-10-02 18:19:48 -04:00
if (conn->xprt->rcv_pipe &&
OPTIM: splicing: use splice() for the last block when relevant Splicing is avoided for small transfers because it's generally cheaper to perform a couple of recv+send calls than pipe+splice+splice. This has the consequence that the last chunk of a large transfer may be transferred using recv+send if it's less than 4 kB. But when the pipe is already set up, it's better to use splice() to read the pending data, since they will get merged with the pending ones. This is what now happens everytime the reader is slower than the writer. Note that this change alone could have fixed most of the CPU hog bug, except at the end when only the close was pending.
2013-07-18 16:21:54 -04:00
(chn->pipe || chn->to_forward >= MIN_SPLICE_FORWARD) &&
chn->flags & CF_KERN_SPLICING) {
MAJOR: channel: replace the struct buffer with a pointer to a buffer With this commit, we now separate the channel from the buffer. This will allow us to replace buffers on the fly without touching the channel. Since nobody is supposed to keep a reference to a buffer anymore, doing so is not a problem and will also permit some copy-less data manipulation. Interestingly, these changes have shown a 2% performance increase on some workloads, probably due to a better cache placement of data.
2012-10-12 17:49:43 -04:00
if (buffer_not_empty(chn->buf)) {
MAJOR: stream-interface: restore splicing mechanism The splicing is now provided by the data-layer rcv_pipe/snd_pipe functions which in turn are called by the stream interface's recv and send callbacks. The presence of the rcv_pipe/snd_pipe functions is used to attest support for splicing at the data layer. It looks like the stream-interface's SI_FL_CAP_SPLICE flag does not make sense anymore as it's used as a proxy for the pointers above. It also appears that we call chk_snd() from the recv callback and then try to call it again in update_conn(). It is very likely that this last function will progressively slip into the recv/send callbacks in order to avoid duplicate check code. The code works right now with and without splicing. Only raw_sock provides support for it and it is automatically selected when the various splice options are set. However it looks like splice-auto doesn't enable it, which possibly means that the streamer detection code does not work anymore, or that it's only called at a time where it's too late to enable splicing (in process_session).
2012-08-23 18:46:52 -04:00
/* We're embarrassed, there are already data pending in
* the buffer and we don't want to have them at two
* locations at a time. Let's indicate we need some
* place and ask the consumer to hurry.
*/
goto abort_splice;
}
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
if (unlikely(chn->pipe == NULL)) {
if (pipes_used >= global.maxpipes || !(chn->pipe = get_pipe())) {
chn->flags &= ~CF_KERN_SPLICING;
MAJOR: stream-interface: restore splicing mechanism The splicing is now provided by the data-layer rcv_pipe/snd_pipe functions which in turn are called by the stream interface's recv and send callbacks. The presence of the rcv_pipe/snd_pipe functions is used to attest support for splicing at the data layer. It looks like the stream-interface's SI_FL_CAP_SPLICE flag does not make sense anymore as it's used as a proxy for the pointers above. It also appears that we call chk_snd() from the recv callback and then try to call it again in update_conn(). It is very likely that this last function will progressively slip into the recv/send callbacks in order to avoid duplicate check code. The code works right now with and without splicing. Only raw_sock provides support for it and it is automatically selected when the various splice options are set. However it looks like splice-auto doesn't enable it, which possibly means that the streamer detection code does not work anymore, or that it's only called at a time where it's too late to enable splicing (in process_session).
2012-08-23 18:46:52 -04:00
goto abort_splice;
}
}
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
ret = conn->xprt->rcv_pipe(conn, chn->pipe, chn->to_forward);
MAJOR: stream-interface: restore splicing mechanism The splicing is now provided by the data-layer rcv_pipe/snd_pipe functions which in turn are called by the stream interface's recv and send callbacks. The presence of the rcv_pipe/snd_pipe functions is used to attest support for splicing at the data layer. It looks like the stream-interface's SI_FL_CAP_SPLICE flag does not make sense anymore as it's used as a proxy for the pointers above. It also appears that we call chk_snd() from the recv callback and then try to call it again in update_conn(). It is very likely that this last function will progressively slip into the recv/send callbacks in order to avoid duplicate check code. The code works right now with and without splicing. Only raw_sock provides support for it and it is automatically selected when the various splice options are set. However it looks like splice-auto doesn't enable it, which possibly means that the streamer detection code does not work anymore, or that it's only called at a time where it's too late to enable splicing (in process_session).
2012-08-23 18:46:52 -04:00
if (ret < 0) {
/* splice not supported on this end, let's disable it */
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
chn->flags &= ~CF_KERN_SPLICING;
MAJOR: stream-interface: restore splicing mechanism The splicing is now provided by the data-layer rcv_pipe/snd_pipe functions which in turn are called by the stream interface's recv and send callbacks. The presence of the rcv_pipe/snd_pipe functions is used to attest support for splicing at the data layer. It looks like the stream-interface's SI_FL_CAP_SPLICE flag does not make sense anymore as it's used as a proxy for the pointers above. It also appears that we call chk_snd() from the recv callback and then try to call it again in update_conn(). It is very likely that this last function will progressively slip into the recv/send callbacks in order to avoid duplicate check code. The code works right now with and without splicing. Only raw_sock provides support for it and it is automatically selected when the various splice options are set. However it looks like splice-auto doesn't enable it, which possibly means that the streamer detection code does not work anymore, or that it's only called at a time where it's too late to enable splicing (in process_session).
2012-08-23 18:46:52 -04:00
goto abort_splice;
}
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
MAJOR: stream-interface: restore splicing mechanism The splicing is now provided by the data-layer rcv_pipe/snd_pipe functions which in turn are called by the stream interface's recv and send callbacks. The presence of the rcv_pipe/snd_pipe functions is used to attest support for splicing at the data layer. It looks like the stream-interface's SI_FL_CAP_SPLICE flag does not make sense anymore as it's used as a proxy for the pointers above. It also appears that we call chk_snd() from the recv callback and then try to call it again in update_conn(). It is very likely that this last function will progressively slip into the recv/send callbacks in order to avoid duplicate check code. The code works right now with and without splicing. Only raw_sock provides support for it and it is automatically selected when the various splice options are set. However it looks like splice-auto doesn't enable it, which possibly means that the streamer detection code does not work anymore, or that it's only called at a time where it's too late to enable splicing (in process_session).
2012-08-23 18:46:52 -04:00
if (ret > 0) {
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
if (chn->to_forward != CHN_INFINITE_FORWARD)
chn->to_forward -= ret;
chn->total += ret;
MAJOR: stream-interface: restore splicing mechanism The splicing is now provided by the data-layer rcv_pipe/snd_pipe functions which in turn are called by the stream interface's recv and send callbacks. The presence of the rcv_pipe/snd_pipe functions is used to attest support for splicing at the data layer. It looks like the stream-interface's SI_FL_CAP_SPLICE flag does not make sense anymore as it's used as a proxy for the pointers above. It also appears that we call chk_snd() from the recv callback and then try to call it again in update_conn(). It is very likely that this last function will progressively slip into the recv/send callbacks in order to avoid duplicate check code. The code works right now with and without splicing. Only raw_sock provides support for it and it is automatically selected when the various splice options are set. However it looks like splice-auto doesn't enable it, which possibly means that the streamer detection code does not work anymore, or that it's only called at a time where it's too late to enable splicing (in process_session).
2012-08-23 18:46:52 -04:00
cur_read += ret;
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
chn->flags |= CF_READ_PARTIAL;
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
}
MAJOR: stream-interface: restore splicing mechanism The splicing is now provided by the data-layer rcv_pipe/snd_pipe functions which in turn are called by the stream interface's recv and send callbacks. The presence of the rcv_pipe/snd_pipe functions is used to attest support for splicing at the data layer. It looks like the stream-interface's SI_FL_CAP_SPLICE flag does not make sense anymore as it's used as a proxy for the pointers above. It also appears that we call chk_snd() from the recv callback and then try to call it again in update_conn(). It is very likely that this last function will progressively slip into the recv/send callbacks in order to avoid duplicate check code. The code works right now with and without splicing. Only raw_sock provides support for it and it is automatically selected when the various splice options are set. However it looks like splice-auto doesn't enable it, which possibly means that the streamer detection code does not work anymore, or that it's only called at a time where it's too late to enable splicing (in process_session).
2012-08-23 18:46:52 -04:00
if (conn_data_read0_pending(conn))
goto out_shutdown_r;
if (conn->flags & CO_FL_ERROR)
OPTIM: stream_interface: return directly if the connection flag CO_FL_ERROR has been set The connection flag CO_FL_ERROR will be tested in the functions both si_conn_recv_cb() and si_conn_send_cb(). If CO_FL_ERROR has been set, out_error branch will be executed. But the only job of out_error branch is to set CO_FL_ERROR on connection flag. So it's better return directly than goto out_error branch under such conditions. As a result, out_error branch becomes needless and can be removed. In addition, the return type of si_conn_send_loop() is also changed to void. The caller should check conn->flags for errors just like stream_int_chk_snd_conn() does as below: static void stream_int_chk_snd_conn(struct stream_interface *si) { ... conn_refresh_polling_flags(si->conn); - if (si_conn_send(si->conn) < 0) { + si_conn_send(si->conn); + if (si->conn->flags & CO_FL_ERROR) { ... } Signed-off-by: Godbach <nylzhaowei@gmail.com>
2013-12-04 04:24:06 -05:00
return;
MAJOR: stream-interface: restore splicing mechanism The splicing is now provided by the data-layer rcv_pipe/snd_pipe functions which in turn are called by the stream interface's recv and send callbacks. The presence of the rcv_pipe/snd_pipe functions is used to attest support for splicing at the data layer. It looks like the stream-interface's SI_FL_CAP_SPLICE flag does not make sense anymore as it's used as a proxy for the pointers above. It also appears that we call chk_snd() from the recv callback and then try to call it again in update_conn(). It is very likely that this last function will progressively slip into the recv/send callbacks in order to avoid duplicate check code. The code works right now with and without splicing. Only raw_sock provides support for it and it is automatically selected when the various splice options are set. However it looks like splice-auto doesn't enable it, which possibly means that the streamer detection code does not work anymore, or that it's only called at a time where it's too late to enable splicing (in process_session).
2012-08-23 18:46:52 -04:00
BUG/MEDIUM: splicing: fix abnormal CPU usage with splicing Mark Janssen reported an issue in 1.5-dev19 which was introduced in 1.5-dev12 by commit 96199b10. From time to time, randomly, the CPU usage spikes to 100% for seconds to minutes. A deep analysis of the traces provided shows that it happens when waiting for the response to a second pipelined HTTP request, or when trying to handle the received shutdown advertised by epoll() after the last block of data. Each time, splice() was involved with data pending in the pipe. The cause of this was that such events could not be taken into account by splice nor by recv and were left pending : - the transfer of the last block of data, optionally with a shutdown was not handled by splice() because of the validation that to_forward is higher than MIN_SPLICE_FORWARD ; - the next recv() call was inhibited because of the test on presence of data in the pipe. This is also what prevented the recv() call from handling a response to a pipelined request until the client had ACKed the previous response. No less than 4 different methods were experimented to fix this, and the current one was finally chosen. The principle is that if an event is not caught by splice(), then it MUST be caught by recv(). So we remove the condition on the pipe's emptiness to perform an recv(), and in order to prevent recv() from being used in the middle of a transfer, we mark supposedly full pipes with CO_FL_WAIT_ROOM, which makes sense because the reason for stopping a splice()-based receive is that the pipe is supposed to be full. The net effect is that we don't wake up and sleep in loops during these transient states. This happened much more often than expected, sometimes for a few cycles at end of transfers, but rarely long enough to be noticed, unless a client timed out with data pending in the pipe. The effect on CPU usage is visible even when transfering 1MB objects in pipeline, where the CPU usage drops from 10 to 6% on a small machine at medium bandwidth. Some further improvements are needed : - the last chunk of a splice() transfer is never done using splice due to the test on to_forward. This is wrong and should be performed with splice if the pipe has not yet been emptied ; - si_chk_snd() should not be called when the write event is already being polled, otherwise we're almost certain to get EAGAIN. Many thanks to Mark for all the traces he cared to provide, they were essential for understanding this issue which was not reproducible without. Only 1.5-dev is affected, no backport is needed.
2013-07-18 15:49:32 -04:00
if (conn->flags & CO_FL_WAIT_ROOM) {
/* the pipe is full or we have read enough data that it
* could soon be full. Let's stop before needing to poll.
*/
MEDIUM: connection: complete the polling cleanups I/O handlers now all use __conn_{sock,data}_{stop,poll,want}_* instead of returning dummy flags. The code has become slightly simpler because some tricks such as the MIN_RET_FOR_READ_LOOP are not needed anymore, and the data handlers which switch to a handshake handler do not need to disable themselves anymore.
2012-09-02 12:34:44 -04:00
si->flags |= SI_FL_WAIT_ROOM;
BUG/MEDIUM: splicing: fix abnormal CPU usage with splicing Mark Janssen reported an issue in 1.5-dev19 which was introduced in 1.5-dev12 by commit 96199b10. From time to time, randomly, the CPU usage spikes to 100% for seconds to minutes. A deep analysis of the traces provided shows that it happens when waiting for the response to a second pipelined HTTP request, or when trying to handle the received shutdown advertised by epoll() after the last block of data. Each time, splice() was involved with data pending in the pipe. The cause of this was that such events could not be taken into account by splice nor by recv and were left pending : - the transfer of the last block of data, optionally with a shutdown was not handled by splice() because of the validation that to_forward is higher than MIN_SPLICE_FORWARD ; - the next recv() call was inhibited because of the test on presence of data in the pipe. This is also what prevented the recv() call from handling a response to a pipelined request until the client had ACKed the previous response. No less than 4 different methods were experimented to fix this, and the current one was finally chosen. The principle is that if an event is not caught by splice(), then it MUST be caught by recv(). So we remove the condition on the pipe's emptiness to perform an recv(), and in order to prevent recv() from being used in the middle of a transfer, we mark supposedly full pipes with CO_FL_WAIT_ROOM, which makes sense because the reason for stopping a splice()-based receive is that the pipe is supposed to be full. The net effect is that we don't wake up and sleep in loops during these transient states. This happened much more often than expected, sometimes for a few cycles at end of transfers, but rarely long enough to be noticed, unless a client timed out with data pending in the pipe. The effect on CPU usage is visible even when transfering 1MB objects in pipeline, where the CPU usage drops from 10 to 6% on a small machine at medium bandwidth. Some further improvements are needed : - the last chunk of a splice() transfer is never done using splice due to the test on to_forward. This is wrong and should be performed with splice if the pipe has not yet been emptied ; - si_chk_snd() should not be called when the write event is already being polled, otherwise we're almost certain to get EAGAIN. Many thanks to Mark for all the traces he cared to provide, they were essential for understanding this issue which was not reproducible without. Only 1.5-dev is affected, no backport is needed.
2013-07-18 15:49:32 -04:00
__conn_data_stop_recv(conn);
}
MEDIUM: connection: complete the polling cleanups I/O handlers now all use __conn_{sock,data}_{stop,poll,want}_* instead of returning dummy flags. The code has become slightly simpler because some tricks such as the MIN_RET_FOR_READ_LOOP are not needed anymore, and the data handlers which switch to a handshake handler do not need to disable themselves anymore.
2012-09-02 12:34:44 -04:00
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
/* splice not possible (anymore), let's go on on standard copy */
}
MAJOR: stream-interface: restore splicing mechanism The splicing is now provided by the data-layer rcv_pipe/snd_pipe functions which in turn are called by the stream interface's recv and send callbacks. The presence of the rcv_pipe/snd_pipe functions is used to attest support for splicing at the data layer. It looks like the stream-interface's SI_FL_CAP_SPLICE flag does not make sense anymore as it's used as a proxy for the pointers above. It also appears that we call chk_snd() from the recv callback and then try to call it again in update_conn(). It is very likely that this last function will progressively slip into the recv/send callbacks in order to avoid duplicate check code. The code works right now with and without splicing. Only raw_sock provides support for it and it is automatically selected when the various splice options are set. However it looks like splice-auto doesn't enable it, which possibly means that the streamer detection code does not work anymore, or that it's only called at a time where it's too late to enable splicing (in process_session).
2012-08-23 18:46:52 -04:00
abort_splice:
BUG/MEDIUM: splicing: fix abnormal CPU usage with splicing Mark Janssen reported an issue in 1.5-dev19 which was introduced in 1.5-dev12 by commit 96199b10. From time to time, randomly, the CPU usage spikes to 100% for seconds to minutes. A deep analysis of the traces provided shows that it happens when waiting for the response to a second pipelined HTTP request, or when trying to handle the received shutdown advertised by epoll() after the last block of data. Each time, splice() was involved with data pending in the pipe. The cause of this was that such events could not be taken into account by splice nor by recv and were left pending : - the transfer of the last block of data, optionally with a shutdown was not handled by splice() because of the validation that to_forward is higher than MIN_SPLICE_FORWARD ; - the next recv() call was inhibited because of the test on presence of data in the pipe. This is also what prevented the recv() call from handling a response to a pipelined request until the client had ACKed the previous response. No less than 4 different methods were experimented to fix this, and the current one was finally chosen. The principle is that if an event is not caught by splice(), then it MUST be caught by recv(). So we remove the condition on the pipe's emptiness to perform an recv(), and in order to prevent recv() from being used in the middle of a transfer, we mark supposedly full pipes with CO_FL_WAIT_ROOM, which makes sense because the reason for stopping a splice()-based receive is that the pipe is supposed to be full. The net effect is that we don't wake up and sleep in loops during these transient states. This happened much more often than expected, sometimes for a few cycles at end of transfers, but rarely long enough to be noticed, unless a client timed out with data pending in the pipe. The effect on CPU usage is visible even when transfering 1MB objects in pipeline, where the CPU usage drops from 10 to 6% on a small machine at medium bandwidth. Some further improvements are needed : - the last chunk of a splice() transfer is never done using splice due to the test on to_forward. This is wrong and should be performed with splice if the pipe has not yet been emptied ; - si_chk_snd() should not be called when the write event is already being polled, otherwise we're almost certain to get EAGAIN. Many thanks to Mark for all the traces he cared to provide, they were essential for understanding this issue which was not reproducible without. Only 1.5-dev is affected, no backport is needed.
2013-07-18 15:49:32 -04:00
if (chn->pipe && unlikely(!chn->pipe->data)) {
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
put_pipe(chn->pipe);
chn->pipe = NULL;
MAJOR: stream-interface: restore splicing mechanism The splicing is now provided by the data-layer rcv_pipe/snd_pipe functions which in turn are called by the stream interface's recv and send callbacks. The presence of the rcv_pipe/snd_pipe functions is used to attest support for splicing at the data layer. It looks like the stream-interface's SI_FL_CAP_SPLICE flag does not make sense anymore as it's used as a proxy for the pointers above. It also appears that we call chk_snd() from the recv callback and then try to call it again in update_conn(). It is very likely that this last function will progressively slip into the recv/send callbacks in order to avoid duplicate check code. The code works right now with and without splicing. Only raw_sock provides support for it and it is automatically selected when the various splice options are set. However it looks like splice-auto doesn't enable it, which possibly means that the streamer detection code does not work anymore, or that it's only called at a time where it's too late to enable splicing (in process_session).
2012-08-23 18:46:52 -04:00
}
BUG/MEDIUM: splicing: fix abnormal CPU usage with splicing Mark Janssen reported an issue in 1.5-dev19 which was introduced in 1.5-dev12 by commit 96199b10. From time to time, randomly, the CPU usage spikes to 100% for seconds to minutes. A deep analysis of the traces provided shows that it happens when waiting for the response to a second pipelined HTTP request, or when trying to handle the received shutdown advertised by epoll() after the last block of data. Each time, splice() was involved with data pending in the pipe. The cause of this was that such events could not be taken into account by splice nor by recv and were left pending : - the transfer of the last block of data, optionally with a shutdown was not handled by splice() because of the validation that to_forward is higher than MIN_SPLICE_FORWARD ; - the next recv() call was inhibited because of the test on presence of data in the pipe. This is also what prevented the recv() call from handling a response to a pipelined request until the client had ACKed the previous response. No less than 4 different methods were experimented to fix this, and the current one was finally chosen. The principle is that if an event is not caught by splice(), then it MUST be caught by recv(). So we remove the condition on the pipe's emptiness to perform an recv(), and in order to prevent recv() from being used in the middle of a transfer, we mark supposedly full pipes with CO_FL_WAIT_ROOM, which makes sense because the reason for stopping a splice()-based receive is that the pipe is supposed to be full. The net effect is that we don't wake up and sleep in loops during these transient states. This happened much more often than expected, sometimes for a few cycles at end of transfers, but rarely long enough to be noticed, unless a client timed out with data pending in the pipe. The effect on CPU usage is visible even when transfering 1MB objects in pipeline, where the CPU usage drops from 10 to 6% on a small machine at medium bandwidth. Some further improvements are needed : - the last chunk of a splice() transfer is never done using splice due to the test on to_forward. This is wrong and should be performed with splice if the pipe has not yet been emptied ; - si_chk_snd() should not be called when the write event is already being polled, otherwise we're almost certain to get EAGAIN. Many thanks to Mark for all the traces he cared to provide, they were essential for understanding this issue which was not reproducible without. Only 1.5-dev is affected, no backport is needed.
2013-07-18 15:49:32 -04:00
/* Important note : if we're called with POLL_IN|POLL_HUP, it means the read polling
* was enabled, which implies that the recv buffer was not full. So we have a guarantee
* that if such an event is not handled above in splice, it will be handled here by
* recv().
*/
MAJOR: connection: remove the CO_FL_WAIT_{RD,WR} flags These flags were used to report the readiness of the file descriptor. Now this readiness is directly checked at the file descriptor itself. This removes the need for constantly synchronizing updates between the file descriptor and the connection and ensures that all layers share the same level of information. For now, the readiness is updated in conn_{sock,data}_poll_* by directly touching the file descriptor. This must move to the lower layers instead so that these functions can disappear as well. In this state, the change works but is incomplete. It's sensible enough to avoid making it more complex. Now the sock/data updates become much simpler because they just have to enable/disable access to a file descriptor and not to care anymore about its readiness.
2014-01-22 13:46:33 -05:00
while (!(conn->flags & (CO_FL_ERROR | CO_FL_SOCK_RD_SH | CO_FL_DATA_RD_SH | CO_FL_WAIT_ROOM | CO_FL_HANDSHAKE))) {
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
max = bi_avail(chn);
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
if (!max) {
MEDIUM: connection: complete the polling cleanups I/O handlers now all use __conn_{sock,data}_{stop,poll,want}_* instead of returning dummy flags. The code has become slightly simpler because some tricks such as the MIN_RET_FOR_READ_LOOP are not needed anymore, and the data handlers which switch to a handshake handler do not need to disable themselves anymore.
2012-09-02 12:34:44 -04:00
si->flags |= SI_FL_WAIT_ROOM;
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
break;
}
MAJOR: channel: replace the struct buffer with a pointer to a buffer With this commit, we now separate the channel from the buffer. This will allow us to replace buffers on the fly without touching the channel. Since nobody is supposed to keep a reference to a buffer anymore, doing so is not a problem and will also permit some copy-less data manipulation. Interestingly, these changes have shown a 2% performance increase on some workloads, probably due to a better cache placement of data.
2012-10-12 17:49:43 -04:00
ret = conn->xprt->rcv_buf(conn, chn->buf, max);
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
if (ret <= 0)
break;
cur_read += ret;
/* if we're allowed to directly forward data, we must update ->o */
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
if (chn->to_forward && !(chn->flags & (CF_SHUTW|CF_SHUTW_NOW))) {
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
unsigned long fwd = ret;
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
if (chn->to_forward != CHN_INFINITE_FORWARD) {
if (fwd > chn->to_forward)
fwd = chn->to_forward;
chn->to_forward -= fwd;
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
}
MAJOR: channel: replace the struct buffer with a pointer to a buffer With this commit, we now separate the channel from the buffer. This will allow us to replace buffers on the fly without touching the channel. Since nobody is supposed to keep a reference to a buffer anymore, doing so is not a problem and will also permit some copy-less data manipulation. Interestingly, these changes have shown a 2% performance increase on some workloads, probably due to a better cache placement of data.
2012-10-12 17:49:43 -04:00
b_adv(chn->buf, fwd);
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
}
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
chn->flags |= CF_READ_PARTIAL;
chn->total += ret;
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
if (channel_full(chn)) {
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
/* The buffer is now full, there's no point in going through
* the loop again.
*/
MAJOR: channel: replace the struct buffer with a pointer to a buffer With this commit, we now separate the channel from the buffer. This will allow us to replace buffers on the fly without touching the channel. Since nobody is supposed to keep a reference to a buffer anymore, doing so is not a problem and will also permit some copy-less data manipulation. Interestingly, these changes have shown a 2% performance increase on some workloads, probably due to a better cache placement of data.
2012-10-12 17:49:43 -04:00
if (!(chn->flags & CF_STREAMER_FAST) && (cur_read == buffer_len(chn->buf))) {
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
chn->xfer_small = 0;
chn->xfer_large++;
if (chn->xfer_large >= 3) {
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
/* we call this buffer a fast streamer if it manages
* to be filled in one call 3 consecutive times.
*/
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
chn->flags |= (CF_STREAMER | CF_STREAMER_FAST);
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
//fputc('+', stderr);
}
}
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
else if ((chn->flags & (CF_STREAMER | CF_STREAMER_FAST)) &&
MAJOR: channel: replace the struct buffer with a pointer to a buffer With this commit, we now separate the channel from the buffer. This will allow us to replace buffers on the fly without touching the channel. Since nobody is supposed to keep a reference to a buffer anymore, doing so is not a problem and will also permit some copy-less data manipulation. Interestingly, these changes have shown a 2% performance increase on some workloads, probably due to a better cache placement of data.
2012-10-12 17:49:43 -04:00
(cur_read <= chn->buf->size / 2)) {
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
chn->xfer_large = 0;
chn->xfer_small++;
if (chn->xfer_small >= 2) {
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
/* if the buffer has been at least half full twice,
* we receive faster than we send, so at least it
* is not a "fast streamer".
*/
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
chn->flags &= ~CF_STREAMER_FAST;
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
//fputc('-', stderr);
}
}
else {
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
chn->xfer_small = 0;
chn->xfer_large = 0;
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
}
si->flags |= SI_FL_WAIT_ROOM;
break;
}
OPTIM: stream_interface: disable reading when CF_READ_DONTWAIT is set CF_READ_DONTWAIT was designed to avoid getting an EAGAIN upon recv() when very few data are expected. It prevents the reader from looping over recv(). Unfortunately with speculative I/O, it is very common that the same event has the time to be called twice before the task handles the data and disables the recv(). This is because not all tasks are always processed at once. Instead of leaving the buffer free-wheeling and doing an EAGAIN, we disable reading as soon as the first recv() succeeds. This way we're sure that only the next wakeup of the task will re-enable it if needed. Doing so has totally removed the EAGAIN we were seeing till now (30% of recv).
2012-11-09 12:27:26 -05:00
if ((chn->flags & CF_READ_DONTWAIT) || --read_poll <= 0) {
BUG/MEDIUM: stream_interface: fix another case where the reader might not be woken up The code review during the chase for the POST freeze uncovered another possible issue which might appear when we perform an incomplete read and want to stop because of READ_DONTWAIT or because we reached the maximum read_poll limit. Reading is disabled but SI_FL_WAIT_ROOM was not set, possibly causing some cases where a send() on the other side would not wake the reader up until another activity on the same side calls the update function which fixes its status.
2012-12-19 12:01:02 -05:00
si->flags |= SI_FL_WAIT_ROOM;
BUG/MINOR: connection: remove a few synchronous calls to polling updates There were a few synchronous calls to polling updates in some functions called from the connection handler. These ones are not needed and should be replaced by more efficient and more debugable asynchronous calls.
2012-12-10 11:03:52 -05:00
__conn_data_stop_recv(conn);
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
break;
OPTIM: stream_interface: disable reading when CF_READ_DONTWAIT is set CF_READ_DONTWAIT was designed to avoid getting an EAGAIN upon recv() when very few data are expected. It prevents the reader from looping over recv(). Unfortunately with speculative I/O, it is very common that the same event has the time to be called twice before the task handles the data and disables the recv(). This is because not all tasks are always processed at once. Instead of leaving the buffer free-wheeling and doing an EAGAIN, we disable reading as soon as the first recv() succeeds. This way we're sure that only the next wakeup of the task will re-enable it if needed. Doing so has totally removed the EAGAIN we were seeing till now (30% of recv).
2012-11-09 12:27:26 -05:00
}
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
/* if too many bytes were missing from last read, it means that
* it's pointless trying to read again because the system does
* not have them in buffers.
*/
if (ret < max) {
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
if ((chn->flags & (CF_STREAMER | CF_STREAMER_FAST)) &&
MAJOR: channel: replace the struct buffer with a pointer to a buffer With this commit, we now separate the channel from the buffer. This will allow us to replace buffers on the fly without touching the channel. Since nobody is supposed to keep a reference to a buffer anymore, doing so is not a problem and will also permit some copy-less data manipulation. Interestingly, these changes have shown a 2% performance increase on some workloads, probably due to a better cache placement of data.
2012-10-12 17:49:43 -04:00
(cur_read <= chn->buf->size / 2)) {
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
chn->xfer_large = 0;
chn->xfer_small++;
if (chn->xfer_small >= 3) {
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
/* we have read less than half of the buffer in
* one pass, and this happened at least 3 times.
* This is definitely not a streamer.
*/
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
chn->flags &= ~(CF_STREAMER | CF_STREAMER_FAST);
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
//fputc('!', stderr);
}
}
/* if a streamer has read few data, it may be because we
* have exhausted system buffers. It's not worth trying
* again.
*/
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
if (chn->flags & CF_STREAMER)
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
break;
/* if we read a large block smaller than what we requested,
* it's almost certain we'll never get anything more.
*/
if (ret >= global.tune.recv_enough)
break;
}
} /* while !flags */
MAJOR: stream-interface: restore splicing mechanism The splicing is now provided by the data-layer rcv_pipe/snd_pipe functions which in turn are called by the stream interface's recv and send callbacks. The presence of the rcv_pipe/snd_pipe functions is used to attest support for splicing at the data layer. It looks like the stream-interface's SI_FL_CAP_SPLICE flag does not make sense anymore as it's used as a proxy for the pointers above. It also appears that we call chk_snd() from the recv callback and then try to call it again in update_conn(). It is very likely that this last function will progressively slip into the recv/send callbacks in order to avoid duplicate check code. The code works right now with and without splicing. Only raw_sock provides support for it and it is automatically selected when the various splice options are set. However it looks like splice-auto doesn't enable it, which possibly means that the streamer detection code does not work anymore, or that it's only called at a time where it's too late to enable splicing (in process_session).
2012-08-23 18:46:52 -04:00
if (conn->flags & CO_FL_ERROR)
OPTIM: stream_interface: return directly if the connection flag CO_FL_ERROR has been set The connection flag CO_FL_ERROR will be tested in the functions both si_conn_recv_cb() and si_conn_send_cb(). If CO_FL_ERROR has been set, out_error branch will be executed. But the only job of out_error branch is to set CO_FL_ERROR on connection flag. So it's better return directly than goto out_error branch under such conditions. As a result, out_error branch becomes needless and can be removed. In addition, the return type of si_conn_send_loop() is also changed to void. The caller should check conn->flags for errors just like stream_int_chk_snd_conn() does as below: static void stream_int_chk_snd_conn(struct stream_interface *si) { ... conn_refresh_polling_flags(si->conn); - if (si_conn_send(si->conn) < 0) { + si_conn_send(si->conn); + if (si->conn->flags & CO_FL_ERROR) { ... } Signed-off-by: Godbach <nylzhaowei@gmail.com>
2013-12-04 04:24:06 -05:00
return;
MAJOR: stream-interface: restore splicing mechanism The splicing is now provided by the data-layer rcv_pipe/snd_pipe functions which in turn are called by the stream interface's recv and send callbacks. The presence of the rcv_pipe/snd_pipe functions is used to attest support for splicing at the data layer. It looks like the stream-interface's SI_FL_CAP_SPLICE flag does not make sense anymore as it's used as a proxy for the pointers above. It also appears that we call chk_snd() from the recv callback and then try to call it again in update_conn(). It is very likely that this last function will progressively slip into the recv/send callbacks in order to avoid duplicate check code. The code works right now with and without splicing. Only raw_sock provides support for it and it is automatically selected when the various splice options are set. However it looks like splice-auto doesn't enable it, which possibly means that the streamer detection code does not work anymore, or that it's only called at a time where it's too late to enable splicing (in process_session).
2012-08-23 18:46:52 -04:00
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
if (conn_data_read0_pending(conn))
/* connection closed */
goto out_shutdown_r;
return;
out_shutdown_r:
/* we received a shutdown */
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
chn->flags |= CF_READ_NULL;
if (chn->flags & CF_AUTO_CLOSE)
channel_shutw_now(chn);
REORG: stream-interface: move sock_raw_read() to si_conn_recv_cb() The recv function is now generic and is usable to iterate any connection-to-buf reading function from a stream interface. So let's move it to stream-interface.
2012-08-20 15:41:06 -04:00
stream_sock_read0(si);
conn_data_read0(conn);
return;
}
MEDIUM: stream-interface: provide a generic si_conn_send_cb callback The connection send() callback is supposed to be generic for a stream-interface, and consists in calling the lower layer snd_buf function. Move this function to the stream interface and remove the sock-raw and sock-ssl clones.
2012-08-20 09:09:53 -04:00
/*
* This is the callback which is called by the connection layer to send data
REORG: connection: rename the data layer the "transport layer" While working on the changes required to make the health checks use the new connections, it started to become obvious that some naming was not logical at all in the connections. Specifically, it is not logical to call the "data layer" the layer which is in charge for all the handshake and which does not yet provide a data layer once established until a session has allocated all the required buffers. In fact, it's more a transport layer, which makes much more sense. The transport layer offers a medium on which data can transit, and it offers the functions to move these data when the upper layer requests this. And it is the upper layer which iterates over the transport layer's functions to move data which should be called the data layer. The use case where it's obvious is with embryonic sessions : an incoming SSL connection is accepted. Only the connection is allocated, not the buffers nor stream interface, etc... The connection handles the SSL handshake by itself. Once this handshake is complete, we can't use the data functions because the buffers and stream interface are not there yet. Hence we have to first call a specific function to complete the session initialization, after which we'll be able to use the data functions. This clearly proves that SSL here is only a transport layer and that the stream interface constitutes the data layer. A similar change will be performed to rename app_cb => data, but the two could not be in the same commit for obvious reasons.
2012-10-02 18:19:48 -04:00
* from the buffer to the connection. It iterates over the transport layer's
* snd_buf function.
MEDIUM: stream-interface: provide a generic si_conn_send_cb callback The connection send() callback is supposed to be generic for a stream-interface, and consists in calling the lower layer snd_buf function. Move this function to the stream interface and remove the sock-raw and sock-ssl clones.
2012-08-20 09:09:53 -04:00
*/
MINOR: connection: provide a generic data layer wakeup callback Instead of calling conn_notify_si() from the connection handler, we now call data->wake(), which will allow us to use a different callback with health checks. Note that we still rely on a flag in order to decide whether or not to call this function. The reason is that with embryonic sessions, the callback is already initialized to si_conn_cb without the flag, and we can't call the SI notify function in the leave path before the stream interface is initialized. This issue should be addressed by involving a different data_cb for embryonic sessions and for stream interfaces, that would be changed during session_complete() for the final data_cb.
2012-10-02 14:07:22 -04:00
static void si_conn_send_cb(struct connection *conn)
MEDIUM: stream-interface: provide a generic si_conn_send_cb callback The connection send() callback is supposed to be generic for a stream-interface, and consists in calling the lower layer snd_buf function. Move this function to the stream interface and remove the sock-raw and sock-ssl clones.
2012-08-20 09:09:53 -04:00
{
MEDIUM: connection: make use of the owner instead of container_of This way the connection can become independant on the stream interface.
2012-09-27 16:20:41 -04:00
struct stream_interface *si = conn->owner;
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
struct channel *chn = si->ob;
MEDIUM: stream-interface: provide a generic si_conn_send_cb callback The connection send() callback is supposed to be generic for a stream-interface, and consists in calling the lower layer snd_buf function. Move this function to the stream interface and remove the sock-raw and sock-ssl clones.
2012-08-20 09:09:53 -04:00
if (conn->flags & CO_FL_ERROR)
OPTIM: stream_interface: return directly if the connection flag CO_FL_ERROR has been set The connection flag CO_FL_ERROR will be tested in the functions both si_conn_recv_cb() and si_conn_send_cb(). If CO_FL_ERROR has been set, out_error branch will be executed. But the only job of out_error branch is to set CO_FL_ERROR on connection flag. So it's better return directly than goto out_error branch under such conditions. As a result, out_error branch becomes needless and can be removed. In addition, the return type of si_conn_send_loop() is also changed to void. The caller should check conn->flags for errors just like stream_int_chk_snd_conn() does as below: static void stream_int_chk_snd_conn(struct stream_interface *si) { ... conn_refresh_polling_flags(si->conn); - if (si_conn_send(si->conn) < 0) { + si_conn_send(si->conn); + if (si->conn->flags & CO_FL_ERROR) { ... } Signed-off-by: Godbach <nylzhaowei@gmail.com>
2013-12-04 04:24:06 -05:00
return;
MEDIUM: stream-interface: provide a generic si_conn_send_cb callback The connection send() callback is supposed to be generic for a stream-interface, and consists in calling the lower layer snd_buf function. Move this function to the stream interface and remove the sock-raw and sock-ssl clones.
2012-08-20 09:09:53 -04:00
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
if (conn->flags & CO_FL_HANDSHAKE)
MEDIUM: stream-interface: provide a generic si_conn_send_cb callback The connection send() callback is supposed to be generic for a stream-interface, and consists in calling the lower layer snd_buf function. Move this function to the stream interface and remove the sock-raw and sock-ssl clones.
2012-08-20 09:09:53 -04:00
/* a handshake was requested */
return;
/* we might have been called just after an asynchronous shutw */
CLEANUP: stream_interface: use 'chn' instead of 'b' to name channel pointers As with previous patches, this naming is confusing.
2012-10-12 17:56:57 -04:00
if (chn->flags & CF_SHUTW)
MEDIUM: stream-interface: provide a generic si_conn_send_cb callback The connection send() callback is supposed to be generic for a stream-interface, and consists in calling the lower layer snd_buf function. Move this function to the stream interface and remove the sock-raw and sock-ssl clones.
2012-08-20 09:09:53 -04:00
return;
/* OK there are data waiting to be sent */
OPTIM: stream_interface: return directly if the connection flag CO_FL_ERROR has been set The connection flag CO_FL_ERROR will be tested in the functions both si_conn_recv_cb() and si_conn_send_cb(). If CO_FL_ERROR has been set, out_error branch will be executed. But the only job of out_error branch is to set CO_FL_ERROR on connection flag. So it's better return directly than goto out_error branch under such conditions. As a result, out_error branch becomes needless and can be removed. In addition, the return type of si_conn_send_loop() is also changed to void. The caller should check conn->flags for errors just like stream_int_chk_snd_conn() does as below: static void stream_int_chk_snd_conn(struct stream_interface *si) { ... conn_refresh_polling_flags(si->conn); - if (si_conn_send(si->conn) < 0) { + si_conn_send(si->conn); + if (si->conn->flags & CO_FL_ERROR) { ... } Signed-off-by: Godbach <nylzhaowei@gmail.com>
2013-12-04 04:24:06 -05:00
si_conn_send(conn);
MEDIUM: stream-interface: provide a generic si_conn_send_cb callback The connection send() callback is supposed to be generic for a stream-interface, and consists in calling the lower layer snd_buf function. Move this function to the stream interface and remove the sock-raw and sock-ssl clones.
2012-08-20 09:09:53 -04:00
/* OK all done */
return;
}
MEDIUM: stream-interface: provide a generic stream_sock_read0() function This function is used by the data layer when a zero has been read over a connection. At the moment it only handles sockets and nothing else. Once the complete split is done between buffers and stream interfaces, it should become possible to work regardless on the connection type.
2012-08-20 09:38:41 -04:00
/*
* This function propagates a null read received on a socket-based connection.
* It updates the stream interface. If the stream interface has SI_FL_NOHALF,
* the close is also forwarded to the write side as an abort. This function is
* still socket-specific as it handles a setsockopt() call to set the SO_LINGER
* state on the socket.
*/
void stream_sock_read0(struct stream_interface *si)
{
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
struct connection *conn = __objt_conn(si->end);
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
si->ib->flags &= ~CF_SHUTR_NOW;
if (si->ib->flags & CF_SHUTR)
MEDIUM: stream-interface: provide a generic stream_sock_read0() function This function is used by the data layer when a zero has been read over a connection. At the moment it only handles sockets and nothing else. Once the complete split is done between buffers and stream interfaces, it should become possible to work regardless on the connection type.
2012-08-20 09:38:41 -04:00
return;
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
si->ib->flags |= CF_SHUTR;
MEDIUM: stream-interface: provide a generic stream_sock_read0() function This function is used by the data layer when a zero has been read over a connection. At the moment it only handles sockets and nothing else. Once the complete split is done between buffers and stream interfaces, it should become possible to work regardless on the connection type.
2012-08-20 09:38:41 -04:00
si->ib->rex = TICK_ETERNITY;
si->flags &= ~SI_FL_WAIT_ROOM;
if (si->state != SI_ST_EST && si->state != SI_ST_CON)
return;
CLEANUP: channel: usr CF_/CHN_ prefixes instead of BF_/BUF_ Get rid of these confusing BF_* flags. Now channel naming should clearly be used everywhere appropriate. No code was changed, only a renaming was performed. The comments about channel operations was updated.
2012-08-27 17:14:58 -04:00
if (si->ob->flags & CF_SHUTW)
MEDIUM: stream-interface: provide a generic stream_sock_read0() function This function is used by the data layer when a zero has been read over a connection. At the moment it only handles sockets and nothing else. Once the complete split is done between buffers and stream interfaces, it should become possible to work regardless on the connection type.
2012-08-20 09:38:41 -04:00
goto do_close;
if (si->flags & SI_FL_NOHALF) {
/* we want to immediately forward this close to the write side */
/* force flag on ssl to keep session in cache */
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
if (conn->xprt->shutw)
conn->xprt->shutw(conn, 0);
MEDIUM: stream-interface: provide a generic stream_sock_read0() function This function is used by the data layer when a zero has been read over a connection. At the moment it only handles sockets and nothing else. Once the complete split is done between buffers and stream interfaces, it should become possible to work regardless on the connection type.
2012-08-20 09:38:41 -04:00
goto do_close;
}
/* otherwise that's just a normal read shutdown */
MEDIUM: connection: centralize handling of nolinger in fd management Right now we see many places doing their own setsockopt(SO_LINGER). Better only do it just before the close() in fd_delete(). For this we add a new flag on the file descriptor, indicating if it's safe or not to linger. If not (eg: after a connect()), then the setsockopt() call is automatically performed before a close(). The flag automatically turns to safe when receiving a read0.
2013-12-15 08:19:38 -05:00
if (conn_ctrl_ready(conn))
fdtab[conn->t.sock.fd].linger_risk = 0;
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
__conn_data_stop_recv(conn);
MEDIUM: stream-interface: provide a generic stream_sock_read0() function This function is used by the data layer when a zero has been read over a connection. At the moment it only handles sockets and nothing else. Once the complete split is done between buffers and stream interfaces, it should become possible to work regardless on the connection type.
2012-08-20 09:38:41 -04:00
return;
do_close:
BUG/MAJOR: stream_interface: read0 not always handled since dev12 The connection handling changed introduced in 1.5-dev12 introduced a regression with commit 9bf9c14c. The issue is that the stream_sock_read0() callback must update the channel flags to indicate that the side is closed so that when process_session() is called, it can propagate the close to the other side and terminate the session. The issue only appears in HTTP tunnel mode. It's a bit tricky to trigger the issue, it requires that the request channel is full with data flowing from the client to the server and that both the response and the read0() are received at once so that the flags are not updated, and that the HTTP analyser switches to tunnel mode without being informed that the request write side is closed. After that, process_session() does not know that the connection has to be aborted either, and no more event appears on this side where the connection stays here forever. Many thanks to Igor at owind for testing several snapshots and for providing valuable traces to reproduce and diagnose the issue!
2012-11-21 15:51:53 -05:00
/* OK we completely close the socket here just as if we went through si_shut[rw]() */
MAJOR: stream-int: stop using si->conn and use si->end instead The connection will only remain there as a pre-allocated entity whose goal is to be placed in ->end when establishing an outgoing connection. All connection initialization can be made on this connection, but all information retrieved should be applied to the end point only. This change is huge because there were many users of si->conn. Now the only users are those who initialize the new connection. The difficulty appears in a few places such as backend.c, proto_http.c, peers.c where si->conn is used to hold the connection's target address before assigning the connection to the stream interface. This is why we have to keep si->conn for now. A future improvement might consist in dynamically allocating the connection when it is needed.
2013-10-01 04:45:07 -04:00
conn_full_close(conn);
BUG/MAJOR: stream_interface: read0 not always handled since dev12 The connection handling changed introduced in 1.5-dev12 introduced a regression with commit 9bf9c14c. The issue is that the stream_sock_read0() callback must update the channel flags to indicate that the side is closed so that when process_session() is called, it can propagate the close to the other side and terminate the session. The issue only appears in HTTP tunnel mode. It's a bit tricky to trigger the issue, it requires that the request channel is full with data flowing from the client to the server and that both the response and the read0() are received at once so that the flags are not updated, and that the HTTP analyser switches to tunnel mode without being informed that the request write side is closed. After that, process_session() does not know that the connection has to be aborted either, and no more event appears on this side where the connection stays here forever. Many thanks to Igor at owind for testing several snapshots and for providing valuable traces to reproduce and diagnose the issue!
2012-11-21 15:51:53 -05:00
si->ib->flags &= ~CF_SHUTR_NOW;
si->ib->flags |= CF_SHUTR;
si->ib->rex = TICK_ETERNITY;
si->ob->flags &= ~CF_SHUTW_NOW;
si->ob->flags |= CF_SHUTW;
si->ob->wex = TICK_ETERNITY;
si->flags &= ~(SI_FL_WAIT_DATA | SI_FL_WAIT_ROOM);
MEDIUM: stream-interface: provide a generic stream_sock_read0() function This function is used by the data layer when a zero has been read over a connection. At the moment it only handles sockets and nothing else. Once the complete split is done between buffers and stream interfaces, it should become possible to work regardless on the connection type.
2012-08-20 09:38:41 -04:00
si->state = SI_ST_DIS;
si->exp = TICK_ETERNITY;
return;
}
[MAJOR] add a connection error state to the stream_interface Tracking connection status changes was hard, and some code was redundant. A new SI_ST_CER state was added to the stream interface to indicate a past connection error, and an SI_FL_ERR flag was added to report past I/O error. The stream_sock code does not set the connection to SI_ST_CLO anymore in case of I/O error, it's the upper layer which does it. This makes it possible to know exactly when the file descriptors are allocated. The new SI_ST_CER state permitted to split tcp_connection_status() in two parts, one processing SI_ST_CON and the other one SI_ST_CER. Synchronous connection errors now make use of this last state, hence eliminating duplicate code. Some ib<->ob copy paste errors were found and fixed, and all entities setting SI_ST_CLO also shut the buffers down. Some of these stream_interface specific functions and structures have migrated to a new stream_interface.c file. Some types of errors are still not detected by the buffers. For instance, let's assume the following scenario in one single pass of process_session: a connection sits in SI_ST_TAR state during a retry. At TAR expiration, a new connection attempt is made, the connection is obtained and srv->cur_sess is increased. Then the buffer timeout is fires and everything is cleared, the new state becomes SI_ST_CLO. The cleaning code checks that previous state was either SI_ST_CON or SI_ST_EST to release the connection. But that's wrong because last state is still SI_ST_TAR. So the server's connection count does not get decreased. This means that prev_state must not be used, and must be replaced by some transition detection instead of level detection. The following debugging line was useful to track state changes : fprintf(stderr, "%s:%d: cs=%d ss=%d(%d) rqf=0x%08x rpf=0x%08x\n", __FUNCTION__, __LINE__, s->si[0].state, s->si[1].state, s->si[1].err_type, s->req->flags, s-> rep->flags);
2008-11-03 00:26:53 -05:00
/*
* Local variables:
* c-indent-level: 8
* c-basic-offset: 8
* End:
*/
Reference in a new issue Copy permalink