static void
vbf_fetch_thread(struct worker *wrk, void *priv)
{
struct busyobj *bo;
enum fetch_step stp;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CAST_OBJ_NOTNULL(bo, priv, BUSYOBJ_MAGIC);
CHECK_OBJ_NOTNULL(bo->req, REQ_MAGIC);
THR_SetBusyobj(bo);
stp = F_STP_MKBEREQ;
while (stp != F_STP_DONE) {
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
bo->step = stp;
switch(stp) {
#define FETCH_STEP(l, U, arg) \
case F_STP_##U: \
stp = vbf_stp_##l arg; \
break;
#include "tbl/steps.h"
#undef FETCH_STEP
default:
WRONG("Illegal fetch_step");
}
if (stp != F_STP_DONE)
VSLb(bo->vsl, SLT_Debug, "%s -> %s",
vbf_step_name(bo->step), vbf_step_name(stp));
}
assert(WRW_IsReleased(wrk));
THR_SetBusyobj(NULL);
}
static enum req_fsm_nxt
cnt_pipe(struct worker *wrk, struct req *req)
{
struct busyobj *bo;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
AN(req->vcl);
wrk->stats->s_pipe++;
bo = VBO_GetBusyObj(wrk, req);
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
VSLb(bo->vsl, SLT_Begin, "bereq %u pipe", VXID(req->vsl->wid));
VSLb(req->vsl, SLT_Link, "bereq %u pipe", VXID(bo->vsl->wid));
THR_SetBusyobj(bo);
HTTP_Setup(bo->bereq, bo->ws, bo->vsl, SLT_BereqMethod);
http_FilterReq(bo->bereq, req->http, 0); // XXX: 0 ?
http_PrintfHeader(bo->bereq, "X-Varnish: %u", VXID(req->vsl->wid));
http_SetHeader(bo->bereq, "Connection: close");
VCL_pipe_method(req->vcl, wrk, req, bo, NULL);
if (wrk->handling == VCL_RET_SYNTH)
INCOMPL();
assert(wrk->handling == VCL_RET_PIPE);
SES_Close(req->sp, VDI_Http1Pipe(req, bo));
http_Teardown(bo->bereq);
VBO_ReleaseBusyObj(wrk, &bo);
THR_SetBusyobj(NULL);
return (REQ_FSM_DONE);
}
static void
vbf_fetch_thread(struct worker *wrk, void *priv)
{
struct busyobj *bo;
enum fetch_step stp;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CAST_OBJ_NOTNULL(bo, priv, BUSYOBJ_MAGIC);
CHECK_OBJ_NOTNULL(bo->req, REQ_MAGIC);
CHECK_OBJ_NOTNULL(bo->fetch_objcore, OBJCORE_MAGIC);
THR_SetBusyobj(bo);
stp = F_STP_MKBEREQ;
assert(bo->doclose == SC_NULL);
assert(isnan(bo->t_first));
assert(isnan(bo->t_prev));
VSLb_ts_busyobj(bo, "Start", W_TIM_real(wrk));
bo->wrk = wrk;
wrk->vsl = bo->vsl;
while (stp != F_STP_DONE) {
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
assert(bo->refcount >= 1);
switch(stp) {
#define FETCH_STEP(l, U, arg) \
case F_STP_##U: \
stp = vbf_stp_##l arg; \
break;
#include "tbl/steps.h"
#undef FETCH_STEP
default:
WRONG("Illegal fetch_step");
}
}
assert(WRW_IsReleased(wrk));
assert(bo->director_state == DIR_S_NULL);
http_Teardown(bo->bereq);
http_Teardown(bo->beresp);
if (bo->state == BOS_FINISHED) {
AZ(bo->fetch_objcore->flags & OC_F_FAILED);
HSH_Complete(bo->fetch_objcore);
VSLb(bo->vsl, SLT_Length, "%ju",
(uintmax_t)ObjGetLen(bo->wrk, bo->fetch_objcore));
}
AZ(bo->fetch_objcore->busyobj);
if (bo->ims_oc != NULL)
(void)HSH_DerefObjCore(wrk, &bo->ims_oc);
wrk->vsl = NULL;
VBO_DerefBusyObj(wrk, &bo);
THR_SetBusyobj(NULL);
}
static void
vbf_fetch_thread(struct worker *wrk, void *priv)
{
struct busyobj *bo;
enum fetch_step stp;
double t_hdr, t_body;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CAST_OBJ_NOTNULL(bo, priv, BUSYOBJ_MAGIC);
CHECK_OBJ_NOTNULL(bo->req, REQ_MAGIC);
THR_SetBusyobj(bo);
stp = F_STP_MKBEREQ;
bo->t_start = VTIM_real();
bo->t_send = NAN;
bo->t_sent = NAN;
bo->t_hdr = NAN;
bo->t_body = NAN;
while (stp != F_STP_DONE) {
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
bo->step = stp;
switch(stp) {
#define FETCH_STEP(l, U, arg) \
case F_STP_##U: \
stp = vbf_stp_##l arg; \
break;
#include "tbl/steps.h"
#undef FETCH_STEP
default:
WRONG("Illegal fetch_step");
}
VSLb(bo->vsl, SLT_Debug, "%s -> %s",
vbf_step_name(bo->step), vbf_step_name(stp));
}
assert(WRW_IsReleased(wrk));
if (bo->state == BOS_FAILED)
assert(bo->fetch_objcore->flags & OC_F_FAILED);
if (bo->ims_obj != NULL)
(void)HSH_DerefObj(&wrk->stats, &bo->ims_obj);
t_hdr = bo->t_hdr - bo->t_sent;
t_body = bo->t_body - bo->t_hdr;
VSLb(bo->vsl, SLT_BereqEnd, "%.9f %.9f %.9f %.9f %.9f %.9f",
bo->t_start,
VTIM_real(),
bo->t_sent - bo->t_send,
t_hdr, t_body, t_hdr + t_body);
VBO_DerefBusyObj(wrk, &bo);
THR_SetBusyobj(NULL);
}
void
VBF_Fetch(struct worker *wrk, struct req *req, struct objcore *oc,
struct objcore *oldoc, enum vbf_fetch_mode_e mode)
{
struct boc *boc;
struct busyobj *bo;
const char *how;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
AN(oc->flags & OC_F_BUSY);
CHECK_OBJ_ORNULL(oldoc, OBJCORE_MAGIC);
bo = VBO_GetBusyObj(wrk, req);
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
boc = HSH_RefBoc(oc);
CHECK_OBJ_NOTNULL(boc, BOC_MAGIC);
switch (mode) {
case VBF_PASS:
how = "pass";
bo->do_pass = 1;
break;
case VBF_NORMAL:
how = "fetch";
break;
case VBF_BACKGROUND:
how = "bgfetch";
bo->is_bgfetch = 1;
break;
default:
WRONG("Wrong fetch mode");
}
VSLb(bo->vsl, SLT_Begin, "bereq %u %s", VXID(req->vsl->wid), how);
VSLb(req->vsl, SLT_Link, "bereq %u %s", VXID(bo->vsl->wid), how);
THR_SetBusyobj(bo);
bo->sp = req->sp;
SES_Ref(bo->sp);
AN(bo->vcl);
oc->boc->vary = req->vary_b;
req->vary_b = NULL;
HSH_Ref(oc);
AZ(bo->fetch_objcore);
bo->fetch_objcore = oc;
AZ(bo->stale_oc);
if (oldoc != NULL) {
assert(oldoc->refcnt > 0);
HSH_Ref(oldoc);
bo->stale_oc = oldoc;
}
AZ(bo->req);
bo->req = req;
bo->fetch_task.priv = bo;
bo->fetch_task.func = vbf_fetch_thread;
if (Pool_Task(wrk->pool, &bo->fetch_task, TASK_QUEUE_BO)) {
wrk->stats->fetch_no_thread++;
(void)vbf_stp_fail(req->wrk, bo);
if (bo->stale_oc != NULL)
(void)HSH_DerefObjCore(wrk, &bo->stale_oc, 0);
HSH_DerefBoc(wrk, oc);
SES_Rel(bo->sp);
VBO_ReleaseBusyObj(wrk, &bo);
} else {
bo = NULL; /* ref transferred to fetch thread */
if (mode == VBF_BACKGROUND) {
ObjWaitState(oc, BOS_REQ_DONE);
(void)VRB_Ignore(req);
} else {
ObjWaitState(oc, BOS_STREAM);
if (oc->boc->state == BOS_FAILED) {
AN((oc->flags & OC_F_FAILED));
} else {
AZ(oc->flags & OC_F_BUSY);
}
}
}
AZ(bo);
VSLb_ts_req(req, "Fetch", W_TIM_real(wrk));
assert(oc->boc == boc);
HSH_DerefBoc(wrk, oc);
if (mode == VBF_BACKGROUND)
(void)HSH_DerefObjCore(wrk, &oc, HSH_RUSH_POLICY);
THR_SetBusyobj(NULL);
}
vbf_fetch_thread(struct worker *wrk, void *priv)
{
struct busyobj *bo;
enum fetch_step stp;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CAST_OBJ_NOTNULL(bo, priv, BUSYOBJ_MAGIC);
CHECK_OBJ_NOTNULL(bo->req, REQ_MAGIC);
CHECK_OBJ_NOTNULL(bo->fetch_objcore, OBJCORE_MAGIC);
THR_SetBusyobj(bo);
stp = F_STP_MKBEREQ;
assert(isnan(bo->t_first));
assert(isnan(bo->t_prev));
VSLb_ts_busyobj(bo, "Start", W_TIM_real(wrk));
bo->wrk = wrk;
wrk->vsl = bo->vsl;
#if 0
if (bo->stale_oc != NULL) {
CHECK_OBJ_NOTNULL(bo->stale_oc, OBJCORE_MAGIC);
/* We don't want the oc/stevedore ops in fetching thread */
if (!ObjCheckFlag(wrk, bo->stale_oc, OF_IMSCAND))
(void)HSH_DerefObjCore(wrk, &bo->stale_oc, 0);
}
#endif
while (stp != F_STP_DONE) {
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
assert(bo->fetch_objcore->boc->refcount >= 1);
switch (stp) {
#define FETCH_STEP(l, U, arg) \
case F_STP_##U: \
stp = vbf_stp_##l arg; \
break;
#include "tbl/steps.h"
default:
WRONG("Illegal fetch_step");
}
}
assert(bo->director_state == DIR_S_NULL);
http_Teardown(bo->bereq);
http_Teardown(bo->beresp);
if (bo->fetch_objcore->boc->state == BOS_FINISHED) {
AZ(bo->fetch_objcore->flags & OC_F_FAILED);
VSLb(bo->vsl, SLT_Length, "%ju",
(uintmax_t)ObjGetLen(bo->wrk, bo->fetch_objcore));
}
// AZ(bo->fetch_objcore->boc); // XXX
if (bo->stale_oc != NULL)
(void)HSH_DerefObjCore(wrk, &bo->stale_oc, 0);
wrk->vsl = NULL;
HSH_DerefBoc(wrk, bo->fetch_objcore);
SES_Rel(bo->sp);
VBO_ReleaseBusyObj(wrk, &bo);
THR_SetBusyobj(NULL);
}
void
VBF_Fetch(struct worker *wrk, struct req *req, struct objcore *oc,
struct object *oldobj, enum vbf_fetch_mode_e mode)
{
struct busyobj *bo;
const char *how;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
CHECK_OBJ_ORNULL(oldobj, OBJECT_MAGIC);
switch(mode) {
case VBF_PASS: how = "pass"; break;
case VBF_NORMAL: how = "fetch"; break;
case VBF_BACKGROUND: how = "bgfetch"; break;
default: WRONG("Wrong fetch mode");
}
bo = VBO_GetBusyObj(wrk, req);
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
VSLb(bo->vsl, SLT_Begin, "bereq %u %s ", VXID(req->vsl->wid), how);
VSLb(req->vsl, SLT_Link, "bereq %u %s ", VXID(bo->vsl->wid), how);
THR_SetBusyobj(bo);
bo->refcount = 2;
oc->busyobj = bo;
CHECK_OBJ_NOTNULL(bo->vcl, VCL_CONF_MAGIC);
if (mode == VBF_PASS)
bo->do_pass = 1;
bo->vary = req->vary_b;
req->vary_b = NULL;
if (mode != VBF_BACKGROUND)
HSH_Ref(oc);
bo->fetch_objcore = oc;
AZ(bo->ims_obj);
if (oldobj != NULL) {
if (http_GetHdr(oldobj->http, H_Last_Modified, NULL) ||
http_GetHdr(oldobj->http, H_ETag, NULL)) {
assert(oldobj->objcore->refcnt > 0);
HSH_Ref(oldobj->objcore);
bo->ims_obj = oldobj;
}
}
AZ(bo->req);
bo->req = req;
bo->fetch_task.priv = bo;
bo->fetch_task.func = vbf_fetch_thread;
if (Pool_Task(wrk->pool, &bo->fetch_task, POOL_QUEUE_FRONT))
vbf_fetch_thread(wrk, bo);
if (mode == VBF_BACKGROUND) {
VBO_waitstate(bo, BOS_REQ_DONE);
} else {
VBO_waitstate(bo, BOS_STREAM);
if (bo->state == BOS_FAILED) {
AN((oc->flags & OC_F_FAILED));
} else {
AZ(bo->fetch_objcore->flags & OC_F_BUSY);
}
}
VSLb_ts_req(req, "Fetch", W_TIM_real(wrk));
THR_SetBusyobj(NULL);
VBO_DerefBusyObj(wrk, &bo);
}
static void
vbf_fetch_thread(struct worker *wrk, void *priv)
{
struct busyobj *bo;
enum fetch_step stp;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CAST_OBJ_NOTNULL(bo, priv, BUSYOBJ_MAGIC);
CHECK_OBJ_NOTNULL(bo->req, REQ_MAGIC);
CHECK_OBJ_NOTNULL(bo->fetch_objcore, OBJCORE_MAGIC);
THR_SetBusyobj(bo);
stp = F_STP_MKBEREQ;
assert(bo->doclose == SC_NULL);
assert(isnan(bo->t_first));
assert(isnan(bo->t_prev));
VSLb_ts_busyobj(bo, "Start", W_TIM_real(wrk));
bo->stats = &wrk->stats;
while (stp != F_STP_DONE) {
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
assert(bo->refcount >= 1);
switch(stp) {
#define FETCH_STEP(l, U, arg) \
case F_STP_##U: \
stp = vbf_stp_##l arg; \
break;
#include "tbl/steps.h"
#undef FETCH_STEP
default:
WRONG("Illegal fetch_step");
}
}
assert(WRW_IsReleased(wrk));
bo->stats = NULL;
if (bo->vbc != NULL) {
if (bo->doclose != SC_NULL)
VDI_CloseFd(&bo->vbc, &bo->acct);
else
VDI_RecycleFd(&bo->vbc, &bo->acct);
AZ(bo->vbc);
}
http_Teardown(bo->bereq);
http_Teardown(bo->beresp);
if (bo->state == BOS_FINISHED) {
AZ(bo->fetch_objcore->flags & OC_F_FAILED);
HSH_Complete(bo->fetch_objcore);
VSLb(bo->vsl, SLT_Length, "%zd", bo->fetch_obj->len);
{
/* Sanity check fetch methods accounting */
ssize_t uu;
struct storage *st;
uu = 0;
VTAILQ_FOREACH(st, &bo->fetch_obj->body->list, list)
uu += st->len;
if (bo->do_stream)
/* Streaming might have started freeing stuff */
assert(uu <= bo->fetch_obj->len);
else
assert(uu == bo->fetch_obj->len);
}
}
AZ(bo->fetch_objcore->busyobj);
if (bo->ims_obj != NULL)
(void)HSH_DerefObj(&wrk->stats, &bo->ims_obj);
VBO_DerefBusyObj(wrk, &bo);
THR_SetBusyobj(NULL);
}
