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

Merge branch 'timers' into merge-timers

Browse Source
This commit is contained in:
Willy Tarreau 2007-05-13 16:10:04 +02:00
commit aff694f3b6
8 changed files with 119 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
include/common/time.h
View File

@ -157,46 +157,53 @@ REGPRM2 static inline int __tv_cmp(const struct timeval *tv1, const struct timev
}
/* tv_iseq: compares <tv1> and <tv2> : returns 1 if tv1 == tv2, otherwise 0 */
#define tv_iseq __tv_iseq
REGPRM2 static inline int __tv_iseq(const struct timeval *tv1, const struct timeval *tv2)
{
return ((unsigned)tv1->tv_sec == (unsigned)tv2->tv_sec) &&
((unsigned)tv1->tv_usec == (unsigned)tv2->tv_usec);
return ((unsigned)tv1->tv_sec == (unsigned)tv2->tv_sec) &&
((unsigned)tv1->tv_usec == (unsigned)tv2->tv_usec);
}
/* tv_isgt: compares <tv1> and <tv2> : returns 1 if tv1 > tv2, otherwise 0 */
#define tv_isgt _tv_isgt
REGPRM2 int _tv_isgt(const struct timeval *tv1, const struct timeval *tv2);
REGPRM2 static inline int __tv_isgt(const struct timeval *tv1, const struct timeval *tv2)
{
return
((unsigned)tv1->tv_sec == (unsigned)tv2->tv_sec) ?
((unsigned)tv1->tv_usec > (unsigned)tv2->tv_usec) :
((unsigned)tv1->tv_sec > (unsigned)tv2->tv_sec);
return
((unsigned)tv1->tv_sec == (unsigned)tv2->tv_sec) ?
((unsigned)tv1->tv_usec > (unsigned)tv2->tv_usec) :
((unsigned)tv1->tv_sec > (unsigned)tv2->tv_sec);
}
/* tv_isge: compares <tv1> and <tv2> : returns 1 if tv1 >= tv2, otherwise 0 */
#define tv_isge __tv_isge
REGPRM2 static inline int __tv_isge(const struct timeval *tv1, const struct timeval *tv2)
{
return
((unsigned)tv1->tv_sec == (unsigned)tv2->tv_sec) ?
((unsigned)tv1->tv_usec >= (unsigned)tv2->tv_usec) :
((unsigned)tv1->tv_sec > (unsigned)tv2->tv_sec);
return
((unsigned)tv1->tv_sec == (unsigned)tv2->tv_sec) ?
((unsigned)tv1->tv_usec >= (unsigned)tv2->tv_usec) :
((unsigned)tv1->tv_sec > (unsigned)tv2->tv_sec);
}
/* tv_islt: compares <tv1> and <tv2> : returns 1 if tv1 < tv2, otherwise 0 */
#define tv_islt __tv_islt
REGPRM2 static inline int __tv_islt(const struct timeval *tv1, const struct timeval *tv2)
{
return
((unsigned)tv1->tv_sec == (unsigned)tv2->tv_sec) ?
((unsigned)tv1->tv_usec < (unsigned)tv2->tv_usec) :
((unsigned)tv1->tv_sec < (unsigned)tv2->tv_sec);
return
((unsigned)tv1->tv_sec == (unsigned)tv2->tv_sec) ?
((unsigned)tv1->tv_usec < (unsigned)tv2->tv_usec) :
((unsigned)tv1->tv_sec < (unsigned)tv2->tv_sec);
}
/* tv_isle: compares <tv1> and <tv2> : returns 1 if tv1 <= tv2, otherwise 0 */
#define tv_isle _tv_isle
REGPRM2 int _tv_isle(const struct timeval *tv1, const struct timeval *tv2);
REGPRM2 static inline int __tv_isle(const struct timeval *tv1, const struct timeval *tv2)
{
return
((unsigned)tv1->tv_sec == (unsigned)tv2->tv_sec) ?
((unsigned)tv1->tv_usec <= (unsigned)tv2->tv_usec) :
((unsigned)tv1->tv_sec < (unsigned)tv2->tv_sec);
return
((unsigned)tv1->tv_sec == (unsigned)tv2->tv_sec) ?
((unsigned)tv1->tv_usec <= (unsigned)tv2->tv_usec) :
((unsigned)tv1->tv_sec < (unsigned)tv2->tv_sec);
}
/*
@ -328,7 +335,7 @@ REGPRM2 static inline unsigned long __tv_ms_remain2(const struct timeval *tv1, c
/*
* adds <inc> to <from>, set the result to <tv> and returns a pointer <tv>
*/
#define tv_add __tv_add
#define tv_add _tv_add
REGPRM3 struct timeval *_tv_add(struct timeval *tv, const struct timeval *from, const struct timeval *inc);
REGPRM3 static inline struct timeval *__tv_add(struct timeval *tv, const struct timeval *from, const struct timeval *inc)
{
@ -342,6 +349,25 @@ REGPRM3 static inline struct timeval *__tv_add(struct timeval *tv, const struct
}
/*
* If <inc> is set, then add it to <from> and set the result to <tv>, then
* return 1, otherwise return 0. It is meant to be used in if conditions.
*/
#define tv_add_ifset _tv_add_ifset
REGPRM3 int _tv_add_ifset(struct timeval *tv, const struct timeval *from, const struct timeval *inc);
REGPRM3 static inline int __tv_add_ifset(struct timeval *tv, const struct timeval *from, const struct timeval *inc)
{
if (tv_iseternity(inc))
return 0;
tv->tv_usec = from->tv_usec + inc->tv_usec;
tv->tv_sec = from->tv_sec + inc->tv_sec;
if (tv->tv_usec >= 1000000) {
tv->tv_usec -= 1000000;
tv->tv_sec++;
}
return 1;
}
/*
* adds <inc> to <tv> and returns a pointer <tv>
*/

4
src/appsession.c
View File

@ -143,7 +143,7 @@ void appsession_refresh(struct task *t, struct timeval *next)
for (element = list_head(&htbl->table[i]);
element != NULL; element = list_next(element)) {
asession = (appsess *)list_data(element);
if (__tv_isle(&asession->expire, &now)) {
if (tv_isle(&asession->expire, &now)) {
if ((global.mode & MODE_DEBUG) &&
(!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE))) {
int len;
@ -165,7 +165,7 @@ void appsession_refresh(struct task *t, struct timeval *next)
}
else
element = last;
}/* end if (__tv_isle(&asession->expire, &now)) */
}/* end if (tv_isle(&asession->expire, &now)) */
else
last = element;
}/* end for (element = list_head(&htbl->table[i]); element != NULL; element = list_next(element)) */

8
src/backend.c
View File

@ -550,9 +550,7 @@ int connect_server(struct session *s)
s->srv->cur_sess_max = s->srv->cur_sess;
}
if (tv_isset(&s->be->contimeout))
tv_add(&s->req->cex, &now, &s->be->contimeout);
else
if (!tv_add_ifset(&s->req->cex, &now, &s->be->contimeout))
tv_eternity(&s->req->cex);
return SN_ERR_NONE; /* connection is OK */
}
@ -680,9 +678,7 @@ int srv_redispatch_connect(struct session *t)
case SRV_STATUS_QUEUED:
/* FIXME-20060503 : we should use the queue timeout instead */
if (tv_isset(&t->be->contimeout))
tv_add(&t->req->cex, &now, &t->be->contimeout);
else
if (!tv_add_ifset(&t->req->cex, &now, &t->be->contimeout))
tv_eternity(&t->req->cex);
t->srv_state = SV_STIDLE;
/* do nothing else and do not wake any other session up */

14
src/checks.c
View File

@ -288,7 +288,7 @@ void process_chk(struct task *t, struct timeval *next)
fd = s->curfd;
if (fd < 0) { /* no check currently running */
//fprintf(stderr, "process_chk: 2\n");
if (!__tv_isle(&t->expire, &now)) { /* not good time yet */
if (!tv_isle(&t->expire, &now)) { /* not good time yet */
task_queue(t); /* restore t to its place in the task list */
*next = t->expire;
goto out;
@ -298,7 +298,7 @@ void process_chk(struct task *t, struct timeval *next)
* the server should not be checked.
*/
if (!(s->state & SRV_CHECKED) || s->proxy->state == PR_STSTOPPED) {
while (__tv_isle(&t->expire, &now))
while (tv_isle(&t->expire, &now))
tv_ms_add(&t->expire, &t->expire, s->inter);
task_queue(t); /* restore t to its place in the task list */
*next = t->expire;
@ -421,7 +421,7 @@ void process_chk(struct task *t, struct timeval *next)
if (!s->result) { /* nothing done */
//fprintf(stderr, "process_chk: 6\n");
while (__tv_isle(&t->expire, &now))
while (tv_isle(&t->expire, &now))
tv_ms_add(&t->expire, &t->expire, s->inter);
goto new_chk; /* may be we should initialize a new check */
}
@ -436,7 +436,7 @@ void process_chk(struct task *t, struct timeval *next)
//fprintf(stderr, "process_chk: 7\n");
/* FIXME: we allow up to <inter> for a connection to establish, but we should use another parameter */
while (__tv_isle(&t->expire, &now))
while (tv_isle(&t->expire, &now))
tv_ms_add(&t->expire, &t->expire, s->inter);
goto new_chk;
}
@ -487,11 +487,11 @@ void process_chk(struct task *t, struct timeval *next)
}
s->curfd = -1; /* no check running anymore */
fd_delete(fd);
while (__tv_isle(&t->expire, &now))
while (tv_isle(&t->expire, &now))
tv_ms_add(&t->expire, &t->expire, s->inter);
goto new_chk;
}
else if (s->result < 0 || __tv_isle(&t->expire, &now)) {
else if (s->result < 0 || tv_isle(&t->expire, &now)) {
//fprintf(stderr, "process_chk: 10\n");
/* failure or timeout detected */
if (s->health > s->rise) {
@ -502,7 +502,7 @@ void process_chk(struct task *t, struct timeval *next)
set_server_down(s);
s->curfd = -1;
fd_delete(fd);
while (__tv_isle(&t->expire, &now))
while (tv_isle(&t->expire, &now))
tv_ms_add(&t->expire, &t->expire, s->inter);
goto new_chk;
}

99
src/proto_http.c
View File

@ -442,9 +442,7 @@ void client_retnclose(struct session *s, const struct chunk *msg)
EV_FD_CLR(s->cli_fd, DIR_RD);
EV_FD_SET(s->cli_fd, DIR_WR);
tv_eternity(&s->req->rex);
if (tv_isset(&s->fe->clitimeout))
tv_add(&s->rep->wex, &now, &s->fe->clitimeout);
else
if (!tv_add_ifset(&s->rep->wex, &now, &s->fe->clitimeout))
tv_eternity(&s->rep->wex);
s->cli_state = CL_STSHUTR;
buffer_flush(s->rep);
@ -1529,7 +1527,7 @@ int process_cli(struct session *t)
}
/* 3: has the read timeout expired ? */
else if (unlikely(__tv_isle(&req->rex, &now))) {
else if (unlikely(tv_isle(&req->rex, &now))) {
/* read timeout : give up with an error message. */
txn->status = 408;
client_retnclose(t, error_message(t, HTTP_ERR_408));
@ -1547,9 +1545,7 @@ int process_cli(struct session *t)
* full. We cannot loop here since stream_sock_read will disable it only if
* req->l == rlim-data
*/
if (tv_isset(&t->fe->clitimeout))
tv_add(&req->rex, &now, &t->fe->clitimeout);
else
if (!tv_add_ifset(&req->rex, &now, &t->fe->clitimeout))
tv_eternity(&req->rex);
}
return t->cli_state != CL_STHEADERS;
@ -1936,9 +1932,7 @@ int process_cli(struct session *t)
/* flush the request so that we can drop the connection early
* if the client closes first.
*/
if (tv_isset(&t->be->contimeout))
tv_add(&req->cex, &now, &t->be->contimeout);
else
if (!tv_add_ifset(&req->cex, &now, &t->be->contimeout))
req->cex = now;
}
@ -1998,14 +1992,13 @@ int process_cli(struct session *t)
/* We must ensure that the read part is still alive when switching
* to shutw */
EV_FD_SET(t->cli_fd, DIR_RD);
if (tv_isset(&t->fe->clitimeout))
tv_add(&req->rex, &now, &t->fe->clitimeout);
tv_add_ifset(&req->rex, &now, &t->fe->clitimeout);
t->cli_state = CL_STSHUTW;
//fprintf(stderr,"%p:%s(%d), c=%d, s=%d\n", t, __FUNCTION__, __LINE__, t->cli_state, t->cli_state);
return 1;
}
/* read timeout */
else if (__tv_isle(&req->rex, &now)) {
else if (tv_isle(&req->rex, &now)) {
EV_FD_CLR(t->cli_fd, DIR_RD);
tv_eternity(&req->rex);
t->cli_state = CL_STSHUTR;
@ -2022,15 +2015,14 @@ int process_cli(struct session *t)
return 1;
}
/* write timeout */
else if (__tv_isle(&rep->wex, &now)) {
else if (tv_isle(&rep->wex, &now)) {
EV_FD_CLR(t->cli_fd, DIR_WR);
tv_eternity(&rep->wex);
shutdown(t->cli_fd, SHUT_WR);
/* We must ensure that the read part is still alive when switching
* to shutw */
EV_FD_SET(t->cli_fd, DIR_RD);
if (tv_isset(&t->fe->clitimeout))
tv_add(&req->rex, &now, &t->fe->clitimeout);
tv_add_ifset(&req->rex, &now, &t->fe->clitimeout);
t->cli_state = CL_STSHUTW;
if (!(t->flags & SN_ERR_MASK))
@ -2078,8 +2070,7 @@ int process_cli(struct session *t)
/* buffer not empty */
if (EV_FD_COND_S(t->cli_fd, DIR_WR)) {
/* restart writing */
if (tv_isset(&t->fe->clitimeout)) {
tv_add(&rep->wex, &now, &t->fe->clitimeout);
if (tv_add_ifset(&rep->wex, &now, &t->fe->clitimeout)) {
/* FIXME: to prevent the client from expiring read timeouts during writes,
* we refresh it. */
req->rex = rep->wex;
@ -2114,7 +2105,7 @@ int process_cli(struct session *t)
t->cli_state = CL_STCLOSE;
return 1;
}
else if (__tv_isle(&rep->wex, &now)) {
else if (tv_isle(&rep->wex, &now)) {
tv_eternity(&rep->wex);
fd_delete(t->cli_fd);
t->cli_state = CL_STCLOSE;
@ -2151,8 +2142,7 @@ int process_cli(struct session *t)
/* buffer not empty */
if (EV_FD_COND_S(t->cli_fd, DIR_WR)) {
/* restart writing */
if (tv_isset(&t->fe->clitimeout)) {
tv_add(&rep->wex, &now, &t->fe->clitimeout);
if (tv_add_ifset(&rep->wex, &now, &t->fe->clitimeout)) {
/* FIXME: to prevent the client from expiring read timeouts during writes,
* we refresh it. */
req->rex = rep->wex;
@ -2186,7 +2176,7 @@ int process_cli(struct session *t)
t->cli_state = CL_STCLOSE;
return 1;
}
else if (__tv_isle(&req->rex, &now)) {
else if (tv_isle(&req->rex, &now)) {
tv_eternity(&req->rex);
fd_delete(t->cli_fd);
t->cli_state = CL_STCLOSE;
@ -2217,9 +2207,7 @@ int process_cli(struct session *t)
} else {
/* there's still some space in the buffer */
if (EV_FD_COND_S(t->cli_fd, DIR_RD)) {
if (tv_isset(&t->fe->clitimeout))
tv_add(&req->rex, &now, &t->fe->clitimeout);
else
if (!tv_add_ifset(&req->rex, &now, &t->fe->clitimeout))
tv_eternity(&req->rex);
//fprintf(stderr,"%p:%s(%d), c=%d, s=%d\n", t, __FUNCTION__, __LINE__, t->cli_state, t->cli_state);
}
@ -2283,7 +2271,7 @@ int process_srv(struct session *t)
* already set the connect expiration date to the right
* timeout. We just have to check that it has not expired.
*/
if (!__tv_isle(&req->cex, &now))
if (!tv_isle(&req->cex, &now))
return 0;
/* We will set the queue timer to the time spent, just for
@ -2305,7 +2293,7 @@ int process_srv(struct session *t)
* to any other session to release it and wake us up again.
*/
if (t->pend_pos) {
if (!__tv_isle(&req->cex, &now))
if (!tv_isle(&req->cex, &now))
return 0;
else {
/* we've been waiting too long here */
@ -2351,7 +2339,7 @@ int process_srv(struct session *t)
srv_close_with_err(t, SN_ERR_CLICL, SN_FINST_C, 0, NULL);
return 1;
}
if (!(req->flags & BF_WRITE_STATUS) && !__tv_isle(&req->cex, &now)) {
if (!(req->flags & BF_WRITE_STATUS) && !tv_isle(&req->cex, &now)) {
//fprintf(stderr,"1: c=%d, s=%d, now=%d.%06d, exp=%d.%06d\n", c, s, now.tv_sec, now.tv_usec, req->cex.tv_sec, req->cex.tv_usec);
return 0; /* nothing changed */
}
@ -2418,8 +2406,7 @@ int process_srv(struct session *t)
tv_eternity(&req->wex);
} else /* need the right to write */ {
EV_FD_SET(t->srv_fd, DIR_WR);
if (tv_isset(&t->be->srvtimeout)) {
tv_add(&req->wex, &now, &t->be->srvtimeout);
if (tv_add_ifset(&req->wex, &now, &t->be->srvtimeout)) {
/* FIXME: to prevent the server from expiring read timeouts during writes,
* we refresh it. */
rep->rex = req->wex;
@ -2430,9 +2417,7 @@ int process_srv(struct session *t)
if (t->be->mode == PR_MODE_TCP) { /* let's allow immediate data connection in this case */
EV_FD_SET(t->srv_fd, DIR_RD);
if (tv_isset(&t->be->srvtimeout))
tv_add(&rep->rex, &now, &t->be->srvtimeout);
else
if (!tv_add_ifset(&rep->rex, &now, &t->be->srvtimeout))
tv_eternity(&rep->rex);
t->srv_state = SV_STDATA;
@ -2519,9 +2504,7 @@ int process_srv(struct session *t)
* full. We cannot loop here since stream_sock_read will disable it only if
* rep->l == rlim-data
*/
if (tv_isset(&t->be->srvtimeout))
tv_add(&rep->rex, &now, &t->be->srvtimeout);
else
if (!tv_add_ifset(&rep->rex, &now, &t->be->srvtimeout))
tv_eternity(&rep->rex);
}
@ -2586,7 +2569,7 @@ int process_srv(struct session *t)
/* read timeout : return a 504 to the client.
*/
else if (unlikely(EV_FD_ISSET(t->srv_fd, DIR_RD) &&
__tv_isle(&rep->rex, &now))) {
tv_isle(&rep->rex, &now))) {
tv_eternity(&rep->rex);
tv_eternity(&req->wex);
fd_delete(t->srv_fd);
@ -2626,8 +2609,7 @@ int process_srv(struct session *t)
/* We must ensure that the read part is still
* alive when switching to shutw */
EV_FD_SET(t->srv_fd, DIR_RD);
if (tv_isset(&t->be->srvtimeout))
tv_add(&rep->rex, &now, &t->be->srvtimeout);
tv_add_ifset(&rep->rex, &now, &t->be->srvtimeout);
shutdown(t->srv_fd, SHUT_WR);
t->srv_state = SV_STSHUTW;
@ -2640,15 +2622,14 @@ int process_srv(struct session *t)
* some work to do on the headers.
*/
else if (unlikely(EV_FD_ISSET(t->srv_fd, DIR_WR) &&
__tv_isle(&req->wex, &now))) {
tv_isle(&req->wex, &now))) {
EV_FD_CLR(t->srv_fd, DIR_WR);
tv_eternity(&req->wex);
shutdown(t->srv_fd, SHUT_WR);
/* We must ensure that the read part is still alive
* when switching to shutw */
EV_FD_SET(t->srv_fd, DIR_RD);
if (tv_isset(&t->be->srvtimeout))
tv_add(&rep->rex, &now, &t->be->srvtimeout);
tv_add_ifset(&rep->rex, &now, &t->be->srvtimeout);
t->srv_state = SV_STSHUTW;
if (!(t->flags & SN_ERR_MASK))
@ -2669,8 +2650,7 @@ int process_srv(struct session *t)
else if (likely(req->l)) {
if (EV_FD_COND_S(t->srv_fd, DIR_WR)) {
/* restart writing */
if (tv_isset(&t->be->srvtimeout)) {
tv_add(&req->wex, &now, &t->be->srvtimeout);
if (tv_add_ifset(&req->wex, &now, &t->be->srvtimeout)) {
/* FIXME: to prevent the server from expiring read timeouts during writes,
* we refresh it. */
rep->rex = req->wex;
@ -2966,8 +2946,7 @@ int process_srv(struct session *t)
/* We must ensure that the read part is still alive when switching
* to shutw */
EV_FD_SET(t->srv_fd, DIR_RD);
if (tv_isset(&t->be->srvtimeout))
tv_add(&rep->rex, &now, &t->be->srvtimeout);
tv_add_ifset(&rep->rex, &now, &t->be->srvtimeout);
shutdown(t->srv_fd, SHUT_WR);
t->srv_state = SV_STSHUTW;
@ -3036,14 +3015,13 @@ int process_srv(struct session *t)
/* We must ensure that the read part is still alive when switching
* to shutw */
EV_FD_SET(t->srv_fd, DIR_RD);
if (tv_isset(&t->be->srvtimeout))
tv_add(&rep->rex, &now, &t->be->srvtimeout);
tv_add_ifset(&rep->rex, &now, &t->be->srvtimeout);
t->srv_state = SV_STSHUTW;
return 1;
}
/* read timeout */
else if (__tv_isle(&rep->rex, &now)) {
else if (tv_isle(&rep->rex, &now)) {
EV_FD_CLR(t->srv_fd, DIR_RD);
tv_eternity(&rep->rex);
t->srv_state = SV_STSHUTR;
@ -3054,15 +3032,14 @@ int process_srv(struct session *t)
return 1;
}
/* write timeout */
else if (__tv_isle(&req->wex, &now)) {
else if (tv_isle(&req->wex, &now)) {
EV_FD_CLR(t->srv_fd, DIR_WR);
tv_eternity(&req->wex);
shutdown(t->srv_fd, SHUT_WR);
/* We must ensure that the read part is still alive when switching
* to shutw */
EV_FD_SET(t->srv_fd, DIR_RD);
if (tv_isset(&t->be->srvtimeout))
tv_add(&rep->rex, &now, &t->be->srvtimeout);
tv_add_ifset(&rep->rex, &now, &t->be->srvtimeout);
t->srv_state = SV_STSHUTW;
if (!(t->flags & SN_ERR_MASK))
t->flags |= SN_ERR_SRVTO;
@ -3081,8 +3058,7 @@ int process_srv(struct session *t)
else { /* buffer not empty, there are still data to be transferred */
if (EV_FD_COND_S(t->srv_fd, DIR_WR)) {
/* restart writing */
if (tv_isset(&t->be->srvtimeout)) {
tv_add(&req->wex, &now, &t->be->srvtimeout);
if (tv_add_ifset(&req->wex, &now, &t->be->srvtimeout)) {
/* FIXME: to prevent the server from expiring read timeouts during writes,
* we refresh it. */
rep->rex = req->wex;
@ -3100,9 +3076,7 @@ int process_srv(struct session *t)
}
else {
if (EV_FD_COND_S(t->srv_fd, DIR_RD)) {
if (tv_isset(&t->be->srvtimeout))
tv_add(&rep->rex, &now, &t->be->srvtimeout);
else
if (!tv_add_ifset(&rep->rex, &now, &t->be->srvtimeout))
tv_eternity(&rep->rex);
}
}
@ -3149,7 +3123,7 @@ int process_srv(struct session *t)
return 1;
}
else if (__tv_isle(&req->wex, &now)) {
else if (tv_isle(&req->wex, &now)) {
//EV_FD_CLR(t->srv_fd, DIR_WR);
tv_eternity(&req->wex);
fd_delete(t->srv_fd);
@ -3178,8 +3152,7 @@ int process_srv(struct session *t)
else { /* buffer not empty */
if (EV_FD_COND_S(t->srv_fd, DIR_WR)) {
/* restart writing */
if (tv_isset(&t->be->srvtimeout)) {
tv_add(&req->wex, &now, &t->be->srvtimeout);
if (tv_add_ifset(&req->wex, &now, &t->be->srvtimeout)) {
/* FIXME: to prevent the server from expiring read timeouts during writes,
* we refresh it. */
rep->rex = req->wex;
@ -3230,7 +3203,7 @@ int process_srv(struct session *t)
return 1;
}
else if (__tv_isle(&rep->rex, &now)) {
else if (tv_isle(&rep->rex, &now)) {
//EV_FD_CLR(t->srv_fd, DIR_RD);
tv_eternity(&rep->rex);
fd_delete(t->srv_fd);
@ -3257,9 +3230,7 @@ int process_srv(struct session *t)
}
else {
if (EV_FD_COND_S(t->srv_fd, DIR_RD)) {
if (tv_isset(&t->be->srvtimeout))
tv_add(&rep->rex, &now, &t->be->srvtimeout);
else
if (!tv_add_ifset(&rep->rex, &now, &t->be->srvtimeout))
tv_eternity(&rep->rex);
}
}

7
src/stream_sock.c
View File

@ -165,10 +165,8 @@ int stream_sock_read(int fd) {
*/
if (b->flags & BF_PARTIAL_READ) {
if (tv_isset(&b->rto)) {
tv_add(&b->rex, &now, &b->rto);
if (tv_add_ifset(&b->rex, &now, &b->rto))
goto out_wakeup;
}
out_eternity:
tv_eternity(&b->rex);
}
@ -315,8 +313,7 @@ int stream_sock_write(int fd) {
*/
if (b->flags & BF_PARTIAL_WRITE) {
if (tv_isset(&b->wto)) {
tv_add(&b->wex, &now, &b->wto);
if (tv_add_ifset(&b->wex, &now, &b->wto)) {
/* FIXME: to prevent the client from expiring read timeouts during writes,
* we refresh it. A solution would be to merge read+write timeouts into a
* unique one, although that needs some study particularly on full-duplex

12
src/task.c
View File

@ -84,7 +84,6 @@ struct task *task_queue(struct task *task)
*/
void wake_expired_tasks(struct timeval *next)
{
__label__ out;
int slen;
struct task *task;
void *data;
@ -96,9 +95,9 @@ void wake_expired_tasks(struct timeval *next)
if (likely(timer_wq.data != NULL)) {
task = LIST_ELEM(timer_wq.data, struct task *, qlist);
if (likely(__tv_isge(&task->expire, &now) > 0)) {
__tv_remain(&now, &task->expire, next);
goto out;
if (likely(tv_isgt(&task->expire, &now))) {
tv_remain(&now, &task->expire, next);
return;
}
}
@ -108,8 +107,8 @@ void wake_expired_tasks(struct timeval *next)
tree64_foreach(&timer_wq, data, stack, slen) {
task = LIST_ELEM(data, struct task *, qlist);
if (__tv_isgt(&task->expire, &now)) {
__tv_remain2(&now, &task->expire, next);
if (tv_isgt(&task->expire, &now)) {
tv_remain(&now, &task->expire, next);
break;
}
@ -125,7 +124,6 @@ void wake_expired_tasks(struct timeval *next)
task->state = TASK_RUNNING;
}
}
out:
return;
}

21
src/time.c
View File

@ -102,6 +102,15 @@ REGPRM3 struct timeval *_tv_add(struct timeval *tv, const struct timeval *from,
return __tv_add(tv, from, inc);
}
/*
* If <inc> is set, then add it to <from> and set the result to <tv>, then
* return 1, otherwise return 0. It is meant to be used in if conditions.
*/
REGPRM3 int _tv_add_ifset(struct timeval *tv, const struct timeval *from, const struct timeval *inc)
{
return __tv_add_ifset(tv, from, inc);
}
/*
* Computes the remaining time between tv1=now and event=tv2. if tv2 is passed,
* 0 is returned. The result is stored into tv.
@ -121,6 +130,18 @@ REGPRM3 struct timeval *_tv_remain2(const struct timeval *tv1, const struct time
return __tv_remain2(tv1, tv2, tv);
}
/* tv_isle: compares <tv1> and <tv2> : returns 1 if tv1 <= tv2, otherwise 0 */
REGPRM2 int _tv_isle(const struct timeval *tv1, const struct timeval *tv2)
{
return __tv_isle(tv1, tv2);
}
/* tv_isgt: compares <tv1> and <tv2> : returns 1 if tv1 > tv2, otherwise 0 */
REGPRM2 int _tv_isgt(const struct timeval *tv1, const struct timeval *tv2)
{
return __tv_isgt(tv1, tv2);
}
/*
* Local variables:
* c-indent-level: 8