MINOR: stream-int/conn-stream: Move stream_int_notify() in the conn-stream scope
stream_int_notify() is renamed cs_notify() and is updated to manipulate a
conn-stream instead of a stream-interface.
diff --git a/src/stream_interface.c b/src/stream_interface.c
index f5b7b77..ed0f7ca 100644
--- a/src/stream_interface.c
+++ b/src/stream_interface.c
@@ -45,7 +45,7 @@
static void cs_conn_read0(struct conn_stream *cs);
/* post-IO notification callback */
-static void stream_int_notify(struct stream_interface *si);
+static void cs_notify(struct conn_stream *cs);
struct data_cb si_conn_cb = {
.wake = si_cs_process,
@@ -92,20 +92,20 @@
* It should not be called from within the stream itself, cs_update()
* is designed for this.
*/
-static void stream_int_notify(struct stream_interface *si)
+static void cs_notify(struct conn_stream *cs)
{
- struct channel *ic = si_ic(si);
- struct channel *oc = si_oc(si);
- struct stream_interface *sio = si_opposite(si);
- struct task *task = si_task(si);
+ struct channel *ic = cs_ic(cs);
+ struct channel *oc = cs_oc(cs);
+ struct conn_stream *cso = cs_opposite(cs);
+ struct task *task = cs_strm_task(cs);
/* process consumer side */
if (channel_is_empty(oc)) {
- struct connection *conn = cs_conn(si->cs);
+ struct connection *conn = cs_conn(cs);
if (((oc->flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW) &&
- (si->cs->state == CS_ST_EST) && (!conn || !(conn->flags & (CO_FL_WAIT_XPRT | CO_FL_EARLY_SSL_HS))))
- cs_shutw(si->cs);
+ (cs->state == CS_ST_EST) && (!conn || !(conn->flags & (CO_FL_WAIT_XPRT | CO_FL_EARLY_SSL_HS))))
+ cs_shutw(cs);
oc->wex = TICK_ETERNITY;
}
@@ -113,9 +113,9 @@
* we're about to close and can't expect more data if SHUTW_NOW is there.
*/
if (!(oc->flags & (CF_SHUTW|CF_SHUTW_NOW)))
- si->flags |= SI_FL_WAIT_DATA;
+ cs->si->flags |= SI_FL_WAIT_DATA;
else if ((oc->flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW)
- si->flags &= ~SI_FL_WAIT_DATA;
+ cs->si->flags &= ~SI_FL_WAIT_DATA;
/* update OC timeouts and wake the other side up if it's waiting for room */
if (oc->flags & CF_WRITE_ACTIVITY) {
@@ -124,15 +124,15 @@
if (tick_isset(oc->wex))
oc->wex = tick_add_ifset(now_ms, oc->wto);
- if (!(si->cs->flags & CS_FL_INDEP_STR))
+ if (!(cs->flags & CS_FL_INDEP_STR))
if (tick_isset(ic->rex))
ic->rex = tick_add_ifset(now_ms, ic->rto);
}
if (oc->flags & CF_DONT_READ)
- si_rx_chan_blk(sio);
+ si_rx_chan_blk(cso->si);
else
- si_rx_chan_rdy(sio);
+ si_rx_chan_rdy(cso->si);
/* Notify the other side when we've injected data into the IC that
* needs to be forwarded. We can do fast-forwarding as soon as there
@@ -146,7 +146,7 @@
* an HTTP parser might need more data to complete the parsing.
*/
if (!channel_is_empty(ic) &&
- (sio->flags & SI_FL_WAIT_DATA) &&
+ (cso->si->flags & SI_FL_WAIT_DATA) &&
(!(ic->flags & CF_EXPECT_MORE) || c_full(ic) || ci_data(ic) == 0 || ic->pipe)) {
int new_len, last_len;
@@ -154,7 +154,7 @@
if (ic->pipe)
last_len += ic->pipe->data;
- cs_chk_snd(sio->cs);
+ cs_chk_snd(cso);
new_len = co_data(ic);
if (ic->pipe)
@@ -164,16 +164,16 @@
* buffer or in the pipe.
*/
if (new_len < last_len)
- si_rx_room_rdy(si);
+ si_rx_room_rdy(cs->si);
}
if (!(ic->flags & CF_DONT_READ))
- si_rx_chan_rdy(si);
+ si_rx_chan_rdy(cs->si);
- cs_chk_rcv(si->cs);
- cs_chk_rcv(sio->cs);
+ cs_chk_rcv(cs);
+ cs_chk_rcv(cso);
- if (si_rx_blocked(si)) {
+ if (si_rx_blocked(cs->si)) {
ic->rex = TICK_ETERNITY;
}
else if ((ic->flags & (CF_SHUTR|CF_READ_PARTIAL)) == CF_READ_PARTIAL) {
@@ -185,10 +185,10 @@
/* wake the task up only when needed */
if (/* changes on the production side */
(ic->flags & (CF_READ_NULL|CF_READ_ERROR)) ||
- !cs_state_in(si->cs->state, CS_SB_CON|CS_SB_RDY|CS_SB_EST) ||
- (si->cs->endp->flags & CS_EP_ERROR) ||
+ !cs_state_in(cs->state, CS_SB_CON|CS_SB_RDY|CS_SB_EST) ||
+ (cs->endp->flags & CS_EP_ERROR) ||
((ic->flags & CF_READ_PARTIAL) &&
- ((ic->flags & CF_EOI) || !ic->to_forward || sio->cs->state != CS_ST_EST)) ||
+ ((ic->flags & CF_EOI) || !ic->to_forward || cso->state != CS_ST_EST)) ||
/* changes on the consumption side */
(oc->flags & (CF_WRITE_NULL|CF_WRITE_ERROR)) ||
@@ -196,7 +196,7 @@
((oc->flags & CF_SHUTW) ||
(((oc->flags & CF_WAKE_WRITE) ||
!(oc->flags & (CF_AUTO_CLOSE|CF_SHUTW_NOW|CF_SHUTW))) &&
- (sio->cs->state != CS_ST_EST ||
+ (cso->state != CS_ST_EST ||
(channel_is_empty(oc) && !oc->to_forward)))))) {
task_wakeup(task, TASK_WOKEN_IO);
}
@@ -208,7 +208,7 @@
task->expire = tick_first(task->expire, ic->analyse_exp);
task->expire = tick_first(task->expire, oc->analyse_exp);
- task->expire = tick_first(task->expire, __cs_strm(si->cs)->conn_exp);
+ task->expire = tick_first(task->expire, __cs_strm(cs)->conn_exp);
task_queue(task);
}
@@ -301,7 +301,7 @@
* pending data, then possibly wake the stream up based on the new
* stream-int status.
*/
- stream_int_notify(si);
+ cs_notify(cs);
stream_release_buffers(si_strm(si));
return 0;
}
@@ -931,10 +931,10 @@
si_rx_endp_more(cs->si);
/* update the stream-int, channels, and possibly wake the stream up */
- stream_int_notify(cs->si);
+ cs_notify(cs);
stream_release_buffers(__cs_strm(cs));
- /* stream_int_notify may have passed through chk_snd and released some
+ /* cs_notify may have passed through chk_snd and released some
* RXBLK flags. Process_stream will consider those flags to wake up the
* appctx but in the case the task is not in runqueue we may have to
* wakeup the appctx immediately.