mirrors/haproxy
1
0
Fork 0
mirror of https://git.haproxy.org/git/haproxy.git/ synced 2025-09-23 06:41:32 +02:00
Code Issues Projects Releases Wiki Activity

MAJOR: buffer rework: replace ->send_max with ->o

Browse Source 
This is the first minor step of the buffer rework. It's only renaming,
it should have no impact.
This commit is contained in:
Willy Tarreau 2012-03-01 16:08:30 +01:00
parent 1122d9c03c
commit 2e046c6017
7 changed files with 107 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
include/proto/buffers.h
View File

@ -54,7 +54,7 @@ unsigned long long buffer_forward(struct buffer *buf, unsigned long long bytes);
/* Initialize all fields in the buffer. The BF_OUT_EMPTY flags is set. */
static inline void buffer_init(struct buffer *buf)
{
buf->send_max = 0;
buf->o = 0;
buf->to_forward = 0;
buf->l = buf->total = 0;
buf->pipe = NULL;
@ -75,7 +75,7 @@ static inline void buffer_init(struct buffer *buf)
*/
static inline int buffer_reserved(const struct buffer *buf)
{
int ret = global.tune.maxrewrite - buf->to_forward - buf->send_max;
int ret = global.tune.maxrewrite - buf->to_forward - buf->o;
if (buf->to_forward == BUF_INFINITE_FORWARD)
return 0;
@ -213,13 +213,13 @@ static inline int buffer_count(const struct buffer *buf, const char *from, const
*/
static inline int buffer_pending(const struct buffer *buf)
{
return buf->l - buf->send_max;
return buf->l - buf->o;
}
/* Returns the size of the working area which the caller knows ends at <end>.
* If <end> equals buf->r (modulo size), then it means that the free area which
* follows is part of the working area. Otherwise, the working area stops at
* <end>. It always starts at buf->w+send_max. The work area includes the
* <end>. It always starts at buf->w+o. The work area includes the
* reserved area.
*/
static inline int buffer_work_area(const struct buffer *buf, const char *end)
@ -227,7 +227,7 @@ static inline int buffer_work_area(const struct buffer *buf, const char *end)
end = buffer_pointer(buf, end);
if (end == buf->r) /* pointer exactly at end, lets push forwards */
end = buf->w;
return buffer_count(buf, buffer_pointer(buf, buf->w + buf->send_max), end);
return buffer_count(buf, buffer_pointer(buf, buf->w + buf->o), end);
}
/* Return 1 if the buffer has less than 1/4 of its capacity free, otherwise 0 */
@ -242,13 +242,13 @@ static inline int buffer_almost_full(const struct buffer *buf)
* Return the max amount of bytes that can be read from the buffer at once.
* Note that this may be lower than the actual buffer length when the data
* wrap after the end, so it's preferable to call this function again after
* reading. Also note that this function respects the send_max limit.
* reading. Also note that this function respects the ->o limit.
*/
static inline int buffer_contig_data(struct buffer *buf)
{
int ret;
if (!buf->send_max || !buf->l)
if (!buf->o || !buf->l)
return 0;
if (buf->r > buf->w)
@ -257,8 +257,8 @@ static inline int buffer_contig_data(struct buffer *buf)
ret = buf->data + buf->size - buf->w;
/* limit the amount of outgoing data if required */
if (ret > buf->send_max)
ret = buf->send_max;
if (ret > buf->o)
ret = buf->o;
return ret;
}
@ -296,15 +296,15 @@ static inline void buffer_check_timeouts(struct buffer *b)
b->flags |= BF_ANA_TIMEOUT;
}
/* Schedule all remaining buffer data to be sent. send_max is not touched if it
/* Schedule all remaining buffer data to be sent. ->o is not touched if it
* already covers those data. That permits doing a flush even after a forward,
* although not recommended.
*/
static inline void buffer_flush(struct buffer *buf)
{
if (buf->send_max < buf->l)
buf->send_max = buf->l;
if (buf->send_max)
if (buf->o < buf->l)
buf->o = buf->l;
if (buf->o)
buf->flags &= ~BF_OUT_EMPTY;
}
@ -314,7 +314,7 @@ static inline void buffer_flush(struct buffer *buf)
*/
static inline void buffer_erase(struct buffer *buf)
{
buf->send_max = 0;
buf->o = 0;
buf->to_forward = 0;
buf->r = buf->lr = buf->w = buf->data;
buf->l = 0;
@ -330,14 +330,14 @@ static inline void buffer_erase(struct buffer *buf)
*/
static inline void buffer_cut_tail(struct buffer *buf)
{
if (!buf->send_max)
if (!buf->o)
return buffer_erase(buf);
buf->to_forward = 0;
if (buf->l == buf->send_max)
if (buf->l == buf->o)
return;
buf->l = buf->send_max;
buf->l = buf->o;
buf->r = buf->w + buf->l;
if (buf->r >= buf->data + buf->size)
buf->r -= buf->size;
@ -456,7 +456,7 @@ static inline int buffer_realign(struct buffer *buf)
* Advance the buffer's read pointer by <len> bytes. This is useful when data
* have been read directly from the buffer. It is illegal to call this function
* with <len> causing a wrapping at the end of the buffer. It's the caller's
* responsibility to ensure that <len> is never larger than buf->send_max.
* responsibility to ensure that <len> is never larger than buf->o.
*/
static inline void buffer_skip(struct buffer *buf, int len)
{
@ -471,8 +471,8 @@ static inline void buffer_skip(struct buffer *buf, int len)
if (buf->l < buffer_max_len(buf))
buf->flags &= ~BF_FULL;
buf->send_max -= len;
if (!buf->send_max && !buf->pipe)
buf->o -= len;
if (!buf->o && !buf->pipe)
buf->flags |= BF_OUT_EMPTY;
/* notify that some data was written to the SI from the buffer */
@ -496,7 +496,7 @@ static inline int buffer_write_chunk(struct buffer *buf, struct chunk *chunk)
}
/* Tries to copy chunk <chunk> into buffer <buf> after length controls.
* The send_max and to_forward pointers are updated. If the buffer's input is
* The ->o and to_forward pointers are updated. If the buffer's input is
* closed, -2 is returned. If the block is too large for this buffer, -3 is
* returned. If there is not enough room left in the buffer, -1 is returned.
* Otherwise the number of bytes copied is returned (0 being a valid number).
@ -514,7 +514,7 @@ static inline int buffer_put_chunk(struct buffer *buf, struct chunk *chunk)
}
/* Tries to copy string <str> at once into buffer <buf> after length controls.
* The send_max and to_forward pointers are updated. If the buffer's input is
* The ->o and to_forward pointers are updated. If the buffer's input is
* closed, -2 is returned. If the block is too large for this buffer, -3 is
* returned. If there is not enough room left in the buffer, -1 is returned.
* Otherwise the number of bytes copied is returned (0 being a valid number).
@ -530,7 +530,7 @@ static inline int buffer_put_string(struct buffer *buf, const char *str)
* Return one char from the buffer. If the buffer is empty and closed, return -2.
* If the buffer is just empty, return -1. The buffer's pointer is not advanced,
* it's up to the caller to call buffer_skip(buf, 1) when it has consumed the char.
* Also note that this function respects the send_max limit.
* Also note that this function respects the ->o limit.
*/
static inline int buffer_get_char(struct buffer *buf)
{
@ -579,7 +579,7 @@ static inline int buffer_feed(struct buffer *buf, const char *str)
* buffer <b>, and moves <end> just after the end of <str>. <b>'s parameters
* (l, r, lr) are updated to be valid after the shift. the shift value
* (positive or negative) is returned. If there's no space left, the move is
* not done. The function does not adjust ->send_max nor BF_OUT_EMPTY because
* not done. The function does not adjust ->o nor BF_OUT_EMPTY because
* it does not make sense to use it on data scheduled to be sent.
*/
static inline int buffer_replace(struct buffer *b, char *pos, char *end, const char *str)

30
include/types/buffers.h
View File

@ -68,7 +68,7 @@
#define BF_WRITE_ERROR 0x000800 /* unrecoverable error on consumer side */
#define BF_WRITE_ACTIVITY (BF_WRITE_NULL|BF_WRITE_PARTIAL|BF_WRITE_ERROR)
#define BF_OUT_EMPTY 0x001000 /* send_max and pipe are empty. Set by last change. */
#define BF_OUT_EMPTY 0x001000 /* out and pipe are empty. Set by last change. */
#define BF_SHUTW 0x002000 /* consumer has already shut down */
#define BF_SHUTW_NOW 0x004000 /* the consumer must shut down for writes ASAP */
#define BF_AUTO_CLOSE 0x008000 /* producer can forward shutdown to other side */
@ -183,8 +183,8 @@ struct buffer {
unsigned int l; /* data length */
char *r, *w, *lr; /* read ptr, write ptr, last read */
unsigned int size; /* buffer size in bytes */
unsigned int send_max; /* number of bytes the sender can consume om this buffer, <= l */
unsigned int to_forward; /* number of bytes to forward after send_max without a wake-up */
unsigned int o; /* number of out bytes the sender can consume from this buffer */
unsigned int to_forward; /* number of bytes to forward after out without a wake-up */
unsigned int analysers; /* bit field indicating what to do on the buffer */
int analyse_exp; /* expiration date for current analysers (if set) */
void (*hijacker)(struct session *, struct buffer *); /* alternative content producer */
@ -201,7 +201,7 @@ struct buffer {
/* Note about the buffer structure
The buffer contains two length indicators, one to_forward counter and one
send_max limit. First, it must be understood that the buffer is in fact
->o limit. First, it must be understood that the buffer is in fact
split in two parts :
- the visible data (->data, for ->l bytes)
- the invisible data, typically in kernel buffers forwarded directly from
@ -224,18 +224,18 @@ struct buffer {
ensure strict ordering of data between buffers.
The producer is responsible for decreasing ->to_forward and increasing
->send_max. The ->to_forward parameter indicates how many bytes may be fed
->o. The ->to_forward parameter indicates how many bytes may be fed
into either data buffer without waking the parent up. The special value
BUF_INFINITE_FORWARD is never decreased nor increased. The ->send_max
BUF_INFINITE_FORWARD is never decreased nor increased. The ->o
parameter says how many bytes may be consumed from the visible buffer. Thus
it may never exceed ->l. This parameter is updated by any buffer_write() as
well as any data forwarded through the visible buffer. Since the ->to_forward
attribute applies to data after ->w+send_max, an analyser will not see a
buffer which has a non-null to_forward with send_max < l. A producer is
responsible for raising ->send_max by min(to_forward, l-send_max) when it
attribute applies to data after ->w+o, an analyser will not see a
buffer which has a non-null to_forward with o < l. A producer is
responsible for raising ->o by min(to_forward, l-o) when it
injects data into the buffer.
The consumer is responsible for decreasing ->send_max when it sends data
The consumer is responsible for decreasing ->o when it sends data
from the visible buffer, and ->pipe->data when it sends data from the
invisible buffer.
@ -243,11 +243,11 @@ struct buffer {
buffer to be forwarded. We know the header length (300) and the amount of
data to forward (content-length=9000). The buffer already contains 1000
bytes of data after the 300 bytes of headers. Thus the caller will set
->send_max to 300 indicating that it explicitly wants to send those data,
->o to 300 indicating that it explicitly wants to send those data,
and set ->to_forward to 9000 (content-length). This value must be normalised
immediately after updating ->to_forward : since there are already 1300 bytes
in the buffer, 300 of which are already counted in ->send_max, and that size
is smaller than ->to_forward, we must update ->send_max to 1300 to flush the
in the buffer, 300 of which are already counted in ->o, and that size
is smaller than ->to_forward, we must update ->o to 1300 to flush the
whole buffer, and reduce ->to_forward to 8000. After that, the producer may
try to feed the additional data through the invisible buffer using a
platform-specific method such as splice().
@ -272,9 +272,9 @@ struct buffer {
A buffer may contain up to 5 areas :
- the data waiting to be sent. These data are located between ->w and
->w+send_max ;
->w+o ;
- the data to process and possibly transform. These data start at
->w+send_max and may be up to r-w bytes long. Generally ->lr remains in
->w+o and may be up to r-w bytes long. Generally ->lr remains in
this area ;
- the data to preserve. They start at the end of the previous one and stop
at ->r. The limit between the two solely depends on the protocol being

30
src/buffers.c
View File

@ -35,7 +35,7 @@ int init_buffer()
* in the limit of the number of bytes to forward. This must be the only method
* to use to schedule bytes to be sent. If the requested number is too large, it
* is automatically adjusted. The number of bytes taken into account is returned.
* Directly touching ->to_forward will cause lockups when send_max goes down to
* Directly touching ->to_forward will cause lockups when ->o goes down to
* zero if nobody is ready to push the remaining data.
*/
unsigned long long buffer_forward(struct buffer *buf, unsigned long long bytes)
@ -45,15 +45,15 @@ unsigned long long buffer_forward(struct buffer *buf, unsigned long long bytes)
if (!bytes)
return 0;
data_left = buf->l - buf->send_max;
data_left = buf->l - buf->o;
if (bytes <= (unsigned long long)data_left) {
buf->send_max += bytes;
buf->o += bytes;
buf->flags &= ~BF_OUT_EMPTY;
return bytes;
}
buf->send_max += data_left;
if (buf->send_max)
buf->o += data_left;
if (buf->o)
buf->flags &= ~BF_OUT_EMPTY;
if (buf->l < buffer_max_len(buf))
@ -115,7 +115,7 @@ int buffer_write(struct buffer *buf, const char *msg, int len)
memcpy(buf->r, msg, len);
buf->l += len;
buf->send_max += len;
buf->o += len;
buf->r += len;
buf->total += len;
if (buf->r == buf->data + buf->size)
@ -129,7 +129,7 @@ int buffer_write(struct buffer *buf, const char *msg, int len)
}
/* Tries to copy character <c> into buffer <buf> after length controls. The
* send_max and to_forward pointers are updated. If the buffer's input is
* ->o and to_forward pointers are updated. If the buffer's input is
* closed, -2 is returned. If there is not enough room left in the buffer, -1
* is returned. Otherwise the number of bytes copied is returned (1). Buffer
* flags FULL, EMPTY and READ_PARTIAL are updated if some data can be
@ -157,7 +157,7 @@ int buffer_put_char(struct buffer *buf, char c)
if (buf->to_forward >= 1) {
if (buf->to_forward != BUF_INFINITE_FORWARD)
buf->to_forward--;
buf->send_max++;
buf->o++;
buf->flags &= ~BF_OUT_EMPTY;
}
@ -166,7 +166,7 @@ int buffer_put_char(struct buffer *buf, char c)
}
/* Tries to copy block <blk> at once into buffer <buf> after length controls.
* The send_max and to_forward pointers are updated. If the buffer's input is
* The ->o and to_forward pointers are updated. If the buffer's input is
* closed, -2 is returned. If the block is too large for this buffer, -3 is
* returned. If there is not enough room left in the buffer, -1 is returned.
* Otherwise the number of bytes copied is returned (0 being a valid number).
@ -211,7 +211,7 @@ int buffer_put_block(struct buffer *buf, const char *blk, int len)
fwd = buf->to_forward;
buf->to_forward -= fwd;
}
buf->send_max += fwd;
buf->o += fwd;
buf->flags &= ~BF_OUT_EMPTY;
}
@ -254,8 +254,8 @@ int buffer_get_line(struct buffer *buf, char *str, int len)
p = buf->w;
if (max > buf->send_max) {
max = buf->send_max;
if (max > buf->o) {
max = buf->o;
str[max-1] = 0;
}
while (max) {
@ -269,7 +269,7 @@ int buffer_get_line(struct buffer *buf, char *str, int len)
if (p == buf->data + buf->size)
p = buf->data;
}
if (ret > 0 && ret < len && ret < buf->send_max &&
if (ret > 0 && ret < len && ret < buf->o &&
*(str-1) != '\n' &&
!(buf->flags & (BF_SHUTW|BF_SHUTW_NOW)))
ret = 0;
@ -294,7 +294,7 @@ int buffer_get_block(struct buffer *buf, char *blk, int len, int offset)
if (buf->flags & BF_SHUTW)
return -1;
if (len + offset > buf->send_max) {
if (len + offset > buf->o) {
if (buf->flags & (BF_SHUTW|BF_SHUTW_NOW))
return -1;
return 0;
@ -320,7 +320,7 @@ int buffer_get_block(struct buffer *buf, char *blk, int len, int offset)
* buffer <b>, and moves <end> just after the end of <str>. <b>'s parameters
* (l, r, lr) are updated to be valid after the shift. the shift value
* (positive or negative) is returned. If there's no space left, the move is
* not done. The function does not adjust ->send_max nor BF_OUT_EMPTY because
* not done. The function does not adjust ->o nor BF_OUT_EMPTY because
* it does not make sense to use it on data scheduled to be sent. The string
* length is taken from parameter <len>. If <len> is null, the <str> pointer
* is allowed to be null.

12
src/dumpstats.c
View File

@ -1500,7 +1500,7 @@ static void cli_io_handler(struct stream_interface *si)
* buffer is empty. This still allows pipelined requests
* to be sent in non-interactive mode.
*/
if ((res->flags & (BF_SHUTW|BF_SHUTW_NOW)) || (!si->applet.st1 && !req->send_max)) {
if ((res->flags & (BF_SHUTW|BF_SHUTW_NOW)) || (!si->applet.st1 && !req->o)) {
si->applet.st0 = STAT_CLI_END;
continue;
}
@ -1542,7 +1542,7 @@ static void cli_io_handler(struct stream_interface *si)
out:
DPRINTF(stderr, "%s@%d: st=%d, rqf=%x, rpf=%x, rql=%d, rqs=%d, rl=%d, rs=%d\n",
__FUNCTION__, __LINE__,
si->state, req->flags, res->flags, req->l, req->send_max, res->l, res->send_max);
si->state, req->flags, res->flags, req->l, req->o, res->l, res->o);
if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO)) {
/* check that we have released everything then unregister */
@ -3370,11 +3370,11 @@ static int stats_dump_full_sess_to_buffer(struct stream_interface *si)
chunk_printf(&msg,
" req=%p (f=0x%06x an=0x%x l=%d sndmx=%d pipe=%d fwd=%d)\n"
" req=%p (f=0x%06x an=0x%x l=%d o=%d pipe=%d fwd=%d)\n"
" an_exp=%s",
sess->req,
sess->req->flags, sess->req->analysers,
sess->req->l, sess->req->send_max,
sess->req->l, sess->req->o,
sess->req->pipe ? sess->req->pipe->data : 0,
sess->req->to_forward,
sess->req->analyse_exp ?
@ -3400,11 +3400,11 @@ static int stats_dump_full_sess_to_buffer(struct stream_interface *si)
sess->req->total);
chunk_printf(&msg,
" res=%p (f=0x%06x an=0x%x l=%d sndmx=%d pipe=%d fwd=%d)\n"
" res=%p (f=0x%06x an=0x%x l=%d o=%d pipe=%d fwd=%d)\n"
" an_exp=%s",
sess->rep,
sess->rep->flags, sess->rep->analysers,
sess->rep->l, sess->rep->send_max,
sess->rep->l, sess->rep->o,
sess->rep->pipe ? sess->rep->pipe->data : 0,
sess->rep->to_forward,
sess->rep->analyse_exp ?

66
src/proto_http.c
View File

@ -393,14 +393,14 @@ static void http_silent_debug(int line, struct session *s)
"[%04d] req: p=%d(%d) s=%d bf=%08x an=%08x data=%p size=%d l=%d w=%p r=%p lr=%p sm=%d fw=%ld tf=%08x\n",
line,
s->si[0].state, s->si[0].fd, s->txn.req.msg_state, s->req->flags, s->req->analysers,
s->req->data, s->req->size, s->req->l, s->req->w, s->req->r, s->req->lr, s->req->send_max, s->req->to_forward, s->txn.flags);
s->req->data, s->req->size, s->req->l, s->req->w, s->req->r, s->req->lr, s->req->o, s->req->to_forward, s->txn.flags);
write(-1, trash, size);
size = 0;
size += snprintf(trash + size, sizeof(trash) - size,
" %04d rep: p=%d(%d) s=%d bf=%08x an=%08x data=%p size=%d l=%d w=%p r=%p lr=%p sm=%d fw=%ld\n",
line,
s->si[1].state, s->si[1].fd, s->txn.rsp.msg_state, s->rep->flags, s->rep->analysers,
s->rep->data, s->rep->size, s->rep->l, s->rep->w, s->rep->r, s->rep->lr, s->rep->send_max, s->rep->to_forward);
s->rep->data, s->rep->size, s->rep->l, s->rep->w, s->rep->r, s->rep->lr, s->rep->o, s->rep->to_forward);
write(-1, trash, size);
}
@ -1295,13 +1295,13 @@ void http_msg_analyzer(struct buffer *buf, struct http_msg *msg, struct hdr_idx
if (likely(HTTP_IS_TOKEN(*ptr))) {
/* we have a start of message, but we have to check
* first if we need to remove some CRLF. We can only
* do this when send_max=0.
* do this when o=0.
*/
char *beg = buf->w + buf->send_max;
char *beg = buf->w + buf->o;
if (beg >= buf->data + buf->size)
beg -= buf->size;
if (unlikely(ptr != beg)) {
if (buf->send_max)
if (buf->o)
goto http_msg_ood;
/* Remove empty leading lines, as recommended by RFC2616. */
buffer_ignore(buf, ptr - beg);
@ -1364,13 +1364,13 @@ void http_msg_analyzer(struct buffer *buf, struct http_msg *msg, struct hdr_idx
if (likely(HTTP_IS_TOKEN(*ptr))) {
/* we have a start of message, but we have to check
* first if we need to remove some CRLF. We can only
* do this when send_max=0.
* do this when o=0.
*/
char *beg = buf->w + buf->send_max;
char *beg = buf->w + buf->o;
if (beg >= buf->data + buf->size)
beg -= buf->size;
if (likely(ptr != beg)) {
if (buf->send_max)
if (buf->o)
goto http_msg_ood;
/* Remove empty leading lines, as recommended by RFC2616. */
buffer_ignore(buf, ptr - beg);
@ -1944,7 +1944,7 @@ int http_skip_chunk_crlf(struct buffer *buf, struct http_msg *msg)
ptr = buf->data;
}
if (bytes > buf->l - buf->send_max)
if (bytes > buf->l - buf->o)
return 0;
if (*ptr != '\n') {
@ -2069,7 +2069,7 @@ int http_wait_for_request(struct session *s, struct buffer *req, int an_bit)
unlikely((req->flags & BF_FULL) ||
req->r < req->lr ||
req->r > req->data + req->size - global.tune.maxrewrite)) {
if (req->send_max) {
if (req->o) {
if (req->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_WRITE_ERROR|BF_WRITE_TIMEOUT))
goto failed_keep_alive;
/* some data has still not left the buffer, wake us once that's done */
@ -2092,7 +2092,7 @@ int http_wait_for_request(struct session *s, struct buffer *req, int an_bit)
unlikely((s->rep->flags & BF_FULL) ||
s->rep->r < s->rep->lr ||
s->rep->r > s->rep->data + s->rep->size - global.tune.maxrewrite)) {
if (s->rep->send_max) {
if (s->rep->o) {
if (s->rep->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_WRITE_ERROR|BF_WRITE_TIMEOUT))
goto failed_keep_alive;
/* don't let a connection request be initiated */
@ -3755,8 +3755,8 @@ void http_end_txn_clean_session(struct session *s)
}
/* don't count other requests' data */
s->logs.bytes_in -= s->req->l - s->req->send_max;
s->logs.bytes_out -= s->rep->l - s->rep->send_max;
s->logs.bytes_in -= s->req->l - s->req->o;
s->logs.bytes_out -= s->rep->l - s->rep->o;
/* let's do a final log if we need it */
if (s->logs.logwait &&
@ -3775,8 +3775,8 @@ void http_end_txn_clean_session(struct session *s)
s->logs.prx_queue_size = 0; /* we get the number of pending conns before us */
s->logs.srv_queue_size = 0; /* we will get this number soon */
s->logs.bytes_in = s->req->total = s->req->l - s->req->send_max;
s->logs.bytes_out = s->rep->total = s->rep->l - s->rep->send_max;
s->logs.bytes_in = s->req->total = s->req->l - s->req->o;
s->logs.bytes_out = s->rep->total = s->rep->l - s->rep->o;
if (s->pend_pos)
pendconn_free(s->pend_pos);
@ -3821,8 +3821,8 @@ void http_end_txn_clean_session(struct session *s)
* because the request will wait for it to flush a little
* bit before proceeding.
*/
if (s->req->l > s->req->send_max) {
if (s->rep->send_max &&
if (s->req->l > s->req->o) {
if (s->rep->o &&
!(s->rep->flags & BF_FULL) &&
s->rep->r <= s->rep->data + s->rep->size - global.tune.maxrewrite)
s->rep->flags |= BF_EXPECT_MORE;
@ -3835,10 +3835,10 @@ void http_end_txn_clean_session(struct session *s)
buffer_auto_close(s->rep);
/* make ->lr point to the first non-forwarded byte */
s->req->lr = s->req->w + s->req->send_max;
s->req->lr = s->req->w + s->req->o;
if (s->req->lr >= s->req->data + s->req->size)
s->req->lr -= s->req->size;
s->rep->lr = s->rep->w + s->rep->send_max;
s->rep->lr = s->rep->w + s->rep->o;
if (s->rep->lr >= s->rep->data + s->rep->size)
s->rep->lr -= s->req->size;
@ -4087,7 +4087,7 @@ int http_sync_res_state(struct session *s)
if (txn->rsp.msg_state == HTTP_MSG_CLOSED) {
http_msg_closed:
/* drop any pending data */
buffer_ignore(buf, buf->l - buf->send_max);
buffer_ignore(buf, buf->l - buf->o);
buffer_auto_close(buf);
buffer_auto_read(buf);
goto wait_other_side;
@ -4153,7 +4153,7 @@ int http_resync_states(struct session *s)
buffer_abort(s->req);
buffer_auto_close(s->req);
buffer_auto_read(s->req);
buffer_ignore(s->req, s->req->l - s->req->send_max);
buffer_ignore(s->req, s->req->l - s->req->o);
}
else if (txn->req.msg_state == HTTP_MSG_CLOSED &&
txn->rsp.msg_state == HTTP_MSG_DONE &&
@ -4189,7 +4189,7 @@ int http_request_forward_body(struct session *s, struct buffer *req, int an_bit)
return 0;
if ((req->flags & (BF_READ_ERROR|BF_READ_TIMEOUT|BF_WRITE_ERROR|BF_WRITE_TIMEOUT)) ||
((req->flags & BF_SHUTW) && (req->to_forward || req->send_max))) {
((req->flags & BF_SHUTW) && (req->to_forward || req->o))) {
/* Output closed while we were sending data. We must abort and
* wake the other side up.
*/
@ -4267,7 +4267,7 @@ int http_request_forward_body(struct session *s, struct buffer *req, int an_bit)
/* we want the CRLF after the data */
int ret;
req->lr = req->w + req->send_max;
req->lr = req->w + req->o;
if (req->lr >= req->data + req->size)
req->lr -= req->size;
@ -4494,7 +4494,7 @@ int http_wait_for_response(struct session *s, struct buffer *rep, int an_bit)
if (unlikely((rep->flags & BF_FULL) ||
rep->r < rep->lr ||
rep->r > rep->data + rep->size - global.tune.maxrewrite)) {
if (rep->send_max) {
if (rep->o) {
/* some data has still not left the buffer, wake us once that's done */
if (rep->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_WRITE_ERROR|BF_WRITE_TIMEOUT))
goto abort_response;
@ -4565,7 +4565,7 @@ int http_wait_for_response(struct session *s, struct buffer *rep, int an_bit)
rep->analysers = 0;
txn->status = 502;
rep->prod->flags |= SI_FL_NOLINGER;
buffer_ignore(rep, rep->l - rep->send_max);
buffer_ignore(rep, rep->l - rep->o);
stream_int_retnclose(rep->cons, error_message(s, HTTP_ERR_502));
if (!(s->flags & SN_ERR_MASK))
@ -4598,7 +4598,7 @@ int http_wait_for_response(struct session *s, struct buffer *rep, int an_bit)
rep->analysers = 0;
txn->status = 502;
rep->prod->flags |= SI_FL_NOLINGER;
buffer_ignore(rep, rep->l - rep->send_max);
buffer_ignore(rep, rep->l - rep->o);
stream_int_retnclose(rep->cons, error_message(s, HTTP_ERR_502));
if (!(s->flags & SN_ERR_MASK))
@ -4623,7 +4623,7 @@ int http_wait_for_response(struct session *s, struct buffer *rep, int an_bit)
rep->analysers = 0;
txn->status = 504;
rep->prod->flags |= SI_FL_NOLINGER;
buffer_ignore(rep, rep->l - rep->send_max);
buffer_ignore(rep, rep->l - rep->o);
stream_int_retnclose(rep->cons, error_message(s, HTTP_ERR_504));
if (!(s->flags & SN_ERR_MASK))
@ -4648,7 +4648,7 @@ int http_wait_for_response(struct session *s, struct buffer *rep, int an_bit)
rep->analysers = 0;
txn->status = 502;
rep->prod->flags |= SI_FL_NOLINGER;
buffer_ignore(rep, rep->l - rep->send_max);
buffer_ignore(rep, rep->l - rep->o);
stream_int_retnclose(rep->cons, error_message(s, HTTP_ERR_502));
if (!(s->flags & SN_ERR_MASK))
@ -4998,7 +4998,7 @@ int http_process_res_common(struct session *t, struct buffer *rep, int an_bit, s
rep->analysers = 0;
txn->status = 502;
rep->prod->flags |= SI_FL_NOLINGER;
buffer_ignore(rep, rep->l - rep->send_max);
buffer_ignore(rep, rep->l - rep->o);
stream_int_retnclose(rep->cons, error_message(t, HTTP_ERR_502));
if (!(t->flags & SN_ERR_MASK))
t->flags |= SN_ERR_PRXCOND;
@ -5259,7 +5259,7 @@ int http_response_forward_body(struct session *s, struct buffer *res, int an_bit
return 0;
if ((res->flags & (BF_READ_ERROR|BF_READ_TIMEOUT|BF_WRITE_ERROR|BF_WRITE_TIMEOUT)) ||
((res->flags & BF_SHUTW) && (res->to_forward || res->send_max)) ||
((res->flags & BF_SHUTW) && (res->to_forward || res->o)) ||
!s->req->analysers) {
/* Output closed while we were sending data. We must abort and
* wake the other side up.
@ -5331,7 +5331,7 @@ int http_response_forward_body(struct session *s, struct buffer *res, int an_bit
/* we want the CRLF after the data */
int ret;
res->lr = res->w + res->send_max;
res->lr = res->w + res->o;
if (res->lr >= res->data + res->size)
res->lr -= res->size;
@ -7456,8 +7456,8 @@ void http_reset_txn(struct session *s)
* a HEAD with some data, or sending more than the advertised
* content-length.
*/
if (unlikely(s->rep->l > s->rep->send_max)) {
s->rep->l = s->rep->send_max;
if (unlikely(s->rep->l > s->rep->o)) {
s->rep->l = s->rep->o;
s->rep->r = s->rep->w + s->rep->l;
if (s->rep->r >= s->rep->data + s->rep->size)
s->rep->r -= s->rep->size;

2
src/proto_tcp.c
View File

@ -393,7 +393,7 @@ int tcp_connect_server(struct stream_interface *si)
* machine with the first ACK. We only do this if there are pending
* data in the buffer.
*/
if ((be->options2 & PR_O2_SMARTCON) && si->ob->send_max)
if ((be->options2 & PR_O2_SMARTCON) && si->ob->o)
setsockopt(fd, IPPROTO_TCP, TCP_QUICKACK, &zero, sizeof(zero));
#endif

26
src/stream_sock.c
View File

@ -301,7 +301,7 @@ int stream_sock_read(int fd) {
b->l += ret;
cur_read += ret;
/* if we're allowed to directly forward data, we must update send_max */
/* if we're allowed to directly forward data, we must update ->o */
if (b->to_forward && !(b->flags & (BF_SHUTW|BF_SHUTW_NOW))) {
unsigned long fwd = ret;
if (b->to_forward != BUF_INFINITE_FORWARD) {
@ -309,7 +309,7 @@ int stream_sock_read(int fd) {
fwd = b->to_forward;
b->to_forward -= fwd;
}
b->send_max += fwd;
b->o += fwd;
b->flags &= ~BF_OUT_EMPTY;
}
@ -446,7 +446,7 @@ int stream_sock_read(int fd) {
* HTTP chunking).
*/
if (b->pipe || /* always try to send spliced data */
(b->send_max == b->l && (b->cons->flags & SI_FL_WAIT_DATA))) {
(b->o == b->l && (b->cons->flags & SI_FL_WAIT_DATA))) {
int last_len = b->pipe ? b->pipe->data : 0;
b->cons->chk_snd(b->cons);
@ -588,7 +588,7 @@ static int stream_sock_write_loop(struct stream_interface *si, struct buffer *b)
* in the normal buffer.
*/
#endif
if (!b->send_max) {
if (!b->o) {
b->flags |= BF_OUT_EMPTY;
return retval;
}
@ -603,8 +603,8 @@ static int stream_sock_write_loop(struct stream_interface *si, struct buffer *b)
max = b->data + b->size - b->w;
/* limit the amount of outgoing data if required */
if (max > b->send_max)
max = b->send_max;
if (max > b->o)
max = b->o;
/* check if we want to inform the kernel that we're interested in
* sending more data after this call. We want this if :
@ -623,8 +623,8 @@ static int stream_sock_write_loop(struct stream_interface *si, struct buffer *b)
if ((!(b->flags & BF_NEVER_WAIT) &&
((b->to_forward && b->to_forward != BUF_INFINITE_FORWARD) ||
(b->flags & BF_EXPECT_MORE))) ||
((b->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_HIJACK)) == BF_SHUTW_NOW && (max == b->send_max)) ||
(max != b->l && max != b->send_max)) {
((b->flags & (BF_SHUTW|BF_SHUTW_NOW|BF_HIJACK)) == BF_SHUTW_NOW && (max == b->o)) ||
(max != b->l && max != b->o)) {
send_flag |= MSG_MORE;
}
@ -662,8 +662,8 @@ static int stream_sock_write_loop(struct stream_interface *si, struct buffer *b)
/* optimize data alignment in the buffer */
b->r = b->w = b->lr = b->data;
b->send_max -= ret;
if (!b->send_max) {
b->o -= ret;
if (!b->o) {
/* Always clear both flags once everything has been sent, they're one-shot */
b->flags &= ~(BF_EXPECT_MORE | BF_SEND_DONTWAIT);
if (likely(!b->pipe))
@ -757,7 +757,7 @@ int stream_sock_write(int fd)
/* Funny, we were called to write something but there wasn't
* anything. We can get there, for example if we were woken up
* on a write event to finish the splice, but the send_max is 0
* on a write event to finish the splice, but the ->o is 0
* so we cannot write anything from the buffer. Let's disable
* the write event and pretend we never came there.
*/
@ -766,7 +766,7 @@ int stream_sock_write(int fd)
if (b->flags & BF_OUT_EMPTY) {
/* the connection is established but we can't write. Either the
* buffer is empty, or we just refrain from sending because the
* send_max limit was reached. Maybe we just wrote the last
* ->o limit was reached. Maybe we just wrote the last
* chunk and need to close.
*/
if (((b->flags & (BF_SHUTW|BF_HIJACK|BF_SHUTW_NOW)) == BF_SHUTW_NOW) &&
@ -1097,7 +1097,7 @@ void stream_sock_chk_snd(struct stream_interface *si)
if (ob->flags & BF_OUT_EMPTY) {
/* the connection is established but we can't write. Either the
* buffer is empty, or we just refrain from sending because the
* send_max limit was reached. Maybe we just wrote the last
* ->o limit was reached. Maybe we just wrote the last
* chunk and need to close.
*/
if (((ob->flags & (BF_SHUTW|BF_HIJACK|BF_AUTO_CLOSE|BF_SHUTW_NOW)) ==