void
SES_Delete(struct sess *sp, enum sess_close reason, double now)
{
CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
if (reason != SC_NULL)
SES_Close(sp, reason);
assert(sp->fd < 0);
if (isnan(now))
now = VTIM_real();
AZ(isnan(sp->t_open));
if (now < sp->t_open) {
VSL(SLT_Debug, sp->vxid,
"Clock step (now=%f < t_open=%f)",
now, sp->t_open);
if (now + cache_param->clock_step < sp->t_open)
WRONG("Clock step detected");
now = sp->t_open; /* Do not log negatives */
}
if (reason == SC_NULL)
reason = (enum sess_close)-sp->fd;
VSL(SLT_SessClose, sp->vxid, "%s %.3f",
sess_close_2str(reason, 0), now - sp->t_open);
VSL(SLT_End, sp->vxid, "%s", "");
SES_Rel(sp);
}
static void *
wrk_thread_real(void *priv, unsigned thread_workspace)
{
struct worker *w, ww;
unsigned char ws[thread_workspace];
THR_SetName("cache-worker");
w = &ww;
memset(w, 0, sizeof *w);
w->magic = WORKER_MAGIC;
w->lastused = NAN;
AZ(pthread_cond_init(&w->cond, NULL));
WS_Init(w->aws, "wrk", ws, thread_workspace);
VSL(SLT_WorkThread, 0, "%p start", w);
Pool_Work_Thread(priv, w);
AZ(w->pool);
VSL(SLT_WorkThread, 0, "%p end", w);
if (w->vcl != NULL)
VCL_Rel(&w->vcl);
AZ(pthread_cond_destroy(&w->cond));
if (w->nvbo != NULL)
VBO_Free(&w->nvbo);
HSH_Cleanup(w);
WRK_SumStat(w);
return (NULL);
}
Lck__Lock(struct lock *lck, const char *p, const char *f, int l)
{
struct ilck *ilck;
int r;
CAST_OBJ_NOTNULL(ilck, lck->priv, ILCK_MAGIC);
if (!(cache_param->diag_bitmap & 0x18)) {
AZ(pthread_mutex_lock(&ilck->mtx));
AZ(ilck->held);
ilck->stat->locks++;
ilck->owner = pthread_self();
ilck->held = 1;
return;
}
r = pthread_mutex_trylock(&ilck->mtx);
assert(r == 0 || r == EBUSY);
if (r) {
ilck->stat->colls++;
if (cache_param->diag_bitmap & 0x8)
VSL(SLT_Debug, 0, "MTX_CONTEST(%s,%s,%d,%s)",
p, f, l, ilck->w);
AZ(pthread_mutex_lock(&ilck->mtx));
} else if (cache_param->diag_bitmap & 0x8) {
VSL(SLT_Debug, 0, "MTX_LOCK(%s,%s,%d,%s)", p, f, l, ilck->w);
}
AZ(ilck->held);
ilck->stat->locks++;
ilck->owner = pthread_self();
ilck->held = 1;
}
void
SES_Delete(struct sess *sp, enum sess_close reason, double now)
{
struct sesspool *pp;
CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
pp = sp->sesspool;
CHECK_OBJ_NOTNULL(pp, SESSPOOL_MAGIC);
AN(pp->pool);
if (reason != SC_NULL)
SES_Close(sp, reason);
assert(sp->fd < 0);
if (isnan(now))
now = VTIM_real();
AZ(isnan(sp->t_open));
VSL(SLT_SessClose, sp->vxid, "%s %.3f",
sess_close_2str(sp->reason, 0), now - sp->t_open);
VSL(SLT_End, sp->vxid, "%s", "");
Lck_Delete(&sp->mtx);
MPL_Free(pp->mpl_sess, sp);
}
vmod_geoip2__init(VRT_CTX, struct vmod_geoip2_geoip2 **vpp,
const char *vcl_name, VCL_STRING filename)
{
struct vmod_geoip2_geoip2 *vp;
MMDB_s mmdb;
int error;
(void)vcl_name;
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
AN(vpp);
AZ(*vpp);
VSL(SLT_Debug, 0, "geoip2.geoip2: Using maxminddb %s",
MMDB_lib_version());
error = MMDB_open(filename, MMDB_MODE_MMAP, &mmdb);
if (error != MMDB_SUCCESS) {
VSL(SLT_Error, 0, "geoip2.geoip2: %s",
MMDB_strerror(error));
return;
}
ALLOC_OBJ(vp, VMOD_GEOIP2_MAGIC);
AN(vp);
*vpp = vp;
vp->mmdb = mmdb;
}
int vmod_clientip(struct sess *sp, const char *ipstring) {
struct addrinfo hints;
struct addrinfo *rp;
int s;
AN(sp);
AN(ipstring);
memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family = AF_UNSPEC;
// Don't attempt DNS resolution.
hints.ai_flags = AI_NUMERICHOST;
s = getaddrinfo(ipstring, NULL, &hints, &rp);
if (s != 0) {
VSL(SLT_VCL_Log, 0, "ipcast: Unable to decode IP address '%s'",
ipstring);
VSL(SLT_VCL_Log, 0, "ipcast: getaddrinfo(): %s", gai_strerror(s));
return(s);
}
AN(rp);
sp->sockaddrlen = rp->ai_addrlen;
memcpy(sp->sockaddr, rp->ai_addr, rp->ai_addrlen);
freeaddrinfo(rp);
return(0);
}
static void
ses_vsl_socket(struct sess *sp, const char *lsockname)
{
struct sockaddr_storage ss;
socklen_t sl;
char laddr[ADDR_BUFSIZE];
char lport[PORT_BUFSIZE];
CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
AN(lsockname);
AN(sp->addrs);
sl = sizeof ss;
AZ(getsockname(sp->fd, (void*)&ss, &sl));
AN(VSA_Build(sess_local_addr(sp), &ss, sl));
assert(VSA_Sane(sess_local_addr(sp)));
VTCP_name(sess_remote_addr(sp), laddr, sizeof laddr,
lport, sizeof lport);
sp->client_addr_str = WS_Copy(sp->ws, laddr, -1);
sp->client_port_str = WS_Copy(sp->ws, lport, -1);
VTCP_name(sess_local_addr(sp), laddr, sizeof laddr,
lport, sizeof lport);
VSL(SLT_Begin, sp->vxid, "sess 0 HTTP/1");
VSL(SLT_SessOpen, sp->vxid, "%s %s %s %s %s %.6f %d",
sp->client_addr_str, sp->client_port_str, lsockname, laddr, lport,
sp->t_open, sp->fd);
}
void
SES_Delete(struct sess *sp, enum sess_close reason, double now)
{
struct acct *b;
struct sesspool *pp;
CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
pp = sp->sesspool;
CHECK_OBJ_NOTNULL(pp, SESSPOOL_MAGIC);
AN(pp->pool);
if (reason != SC_NULL)
SES_Close(sp, reason);
assert(sp->fd < 0);
if (isnan(now))
now = VTIM_real();
assert(!isnan(sp->t_open));
b = &sp->acct_ses;
VSL(SLT_SessClose, sp->vxid, "%s %.3f %ju %ju %ju %ju %ju %ju",
sess_close_2str(sp->reason, 0), now - sp->t_open, b->req,
b->pipe, b->pass, b->fetch, b->hdrbytes, b->bodybytes);
VSL(SLT_End, sp->vxid, "%s", "");
Lck_Delete(&sp->mtx);
MPL_Free(pp->mpl_sess, sp);
}
void
EXP_Rearm(struct objcore *oc, double now, double ttl, double grace, double keep)
{
double when;
CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
assert(oc->refcnt > 0);
if (!(oc->exp_flags & OC_EF_REFD))
return;
if (!isnan(ttl))
oc->ttl = now + ttl - oc->t_origin;
if (!isnan(grace))
oc->grace = grace;
if (!isnan(keep))
oc->keep = keep;
when = EXP_WHEN(oc);
VSL(SLT_ExpKill, 0, "EXP_Rearm p=%p E=%.9f e=%.9f f=0x%x", oc,
oc->timer_when, when, oc->flags);
if (when < oc->t_origin || when < oc->timer_when)
exp_mail_it(oc, OC_EF_MOVE);
}
static void
vwp_extend_pollspace(struct vwp *vwp)
{
size_t inc;
if (vwp->npoll < (1<<12))
inc = (1<<10);
else if (vwp->npoll < (1<<14))
inc = (1<<12);
else if (vwp->npoll < (1<<16))
inc = (1<<14);
else
inc = (1<<16);
VSL(SLT_Debug, 0, "Acceptor poll space increased by %zu to %zu",
inc, vwp->npoll + inc);
vwp->pollfd = realloc(vwp->pollfd,
(vwp->npoll + inc) * sizeof(*vwp->pollfd));
AN(vwp->pollfd);
memset(vwp->pollfd + vwp->npoll, 0, inc * sizeof(*vwp->pollfd));
vwp->idx = realloc(vwp->idx, (vwp->npoll + inc) * sizeof(*vwp->idx));
AN(vwp->idx);
memset(vwp->idx + vwp->npoll, 0, inc * sizeof(*vwp->idx));
for (; inc > 0; inc--)
vwp->pollfd[vwp->npoll++].fd = -1;
}
static void
vwk_sess_ev(struct vwk *vwk, const struct kevent *kp, double now)
{
struct sess *sp;
AN(kp->udata);
assert(kp->udata != vwk->pipes);
CAST_OBJ_NOTNULL(sp, kp->udata, SESS_MAGIC);
DSL(DBG_WAITER, sp->vxid, "KQ: sp %p kev data %lu flags 0x%x%s",
sp, (unsigned long)kp->data, kp->flags,
(kp->flags & EV_EOF) ? " EOF" : "");
if (kp->data > 0) {
VTAILQ_REMOVE(&vwk->sesshead, sp, list);
SES_Handle(sp, now);
return;
} else if (kp->flags & EV_EOF) {
VTAILQ_REMOVE(&vwk->sesshead, sp, list);
SES_Delete(sp, SC_REM_CLOSE, now);
return;
} else {
VSL(SLT_Debug, sp->vxid,
"KQ: sp %p kev data %lu flags 0x%x%s",
sp, (unsigned long)kp->data, kp->flags,
(kp->flags & EV_EOF) ? " EOF" : "");
}
}
static void
child_malloc_fail(void *p, const char *s)
{
VSL(SLT_Error, 0, "MALLOC ERROR: %s (%p)", s, p);
fprintf(stderr, "MALLOC ERROR: %s (%p)\n", s, p);
WRONG("Malloc Error");
}
vmod_log(VRT_CTX, const char *fmt, ...)
{
const char *p;
va_list ap;
uintptr_t sn;
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
sn = WS_Snapshot(ctx->ws);
va_start(ap, fmt);
p = VRT_String(ctx->ws, NULL, fmt, ap);
va_end(ap);
if (p == NULL) {
WS_MarkOverflow(ctx->ws);
WS_Reset(ctx->ws, sn);
return;
}
AN(p);
if (ctx->vsl != NULL)
VSLb(ctx->vsl, SLT_VCL_Log, "%s", p);
else
VSL(SLT_VCL_Log, 0, "%s", p);
WS_Reset(ctx->ws, sn);
}
static void
vbp_has_poked(struct vbp_target *vt)
{
unsigned i, j;
uint64_t u;
const char *logmsg;
char bits[10];
CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);
/* Calculate exponential average */
if (vt->happy & 1) {
if (vt->rate < AVG_RATE)
vt->rate += 1.0;
vt->avg += (vt->last - vt->avg) / vt->rate;
}
i = 0;
#define BITMAP(n, c, t, b) bits[i++] = (vt->n & 1) ? c : '-';
#include "tbl/backend_poll.h"
#undef BITMAP
bits[i] = '\0';
u = vt->happy;
for (i = j = 0; i < vt->probe.window; i++) {
if (u & 1)
j++;
u >>= 1;
}
vt->good = j;
Lck_Lock(&vt->mtx);
if (vt->backend != NULL) {
if (vt->good >= vt->probe.threshold) {
if (vt->backend->healthy)
logmsg = "Still healthy";
else {
logmsg = "Back healthy";
vt->backend->health_changed = VTIM_real();
}
vt->backend->healthy = 1;
} else {
if (vt->backend->healthy) {
logmsg = "Went sick";
vt->backend->health_changed = VTIM_real();
} else
logmsg = "Still sick";
vt->backend->healthy = 0;
}
VSL(SLT_Backend_health, 0, "%s %s %s %u %u %u %.6f %.6f %s",
vt->backend->display_name, logmsg, bits,
vt->good, vt->probe.threshold, vt->probe.window,
vt->last, vt->avg, vt->resp_buf);
if (!vt->disable) {
AN(vt->backend->vsc);
vt->backend->vsc->happy = vt->happy;
}
}
Lck_Unlock(&vt->mtx);
}
int
VGZ_Gunzip(struct vgz *vg, const void **pptr, size_t *plen)
{
int i;
ssize_t l;
const uint8_t *before;
CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
*pptr = NULL;
*plen = 0;
AN(vg->vz.next_out);
AN(vg->vz.avail_out);
before = vg->vz.next_out;
i = inflate(&vg->vz, 0);
if (i == Z_OK || i == Z_STREAM_END) {
*pptr = before;
l = (const uint8_t *)vg->vz.next_out - before;
*plen = l;
if (vg->st_obuf != NULL)
vg->st_obuf->len += l;
}
vg->last_i = i;
if (i == Z_OK)
return (VGZ_OK);
if (i == Z_STREAM_END)
return (VGZ_END);
if (i == Z_BUF_ERROR)
return (VGZ_STUCK);
VSL(SLT_Debug, 0, "Unknown INFLATE=%d (%s)\n", i, vg->vz.msg);
return (VGZ_ERROR);
}
static void *
wrk_thread_real(void *priv, unsigned shm_workspace, unsigned sess_workspace,
uint16_t nhttp, unsigned http_space, unsigned siov)
{
struct worker *w, ww;
uint32_t wlog[shm_workspace / 4];
/* XXX: can we trust these to be properly aligned ? */
unsigned char ws[sess_workspace];
unsigned char http0[http_space];
unsigned char http1[http_space];
unsigned char http2[http_space];
struct iovec iov[siov];
struct SHA256Context sha256;
THR_SetName("cache-worker");
w = &ww;
memset(w, 0, sizeof *w);
w->magic = WORKER_MAGIC;
w->lastused = NAN;
w->wlb = w->wlp = wlog;
w->wle = wlog + (sizeof wlog) / 4;
w->sha256ctx = &sha256;
w->bereq = HTTP_create(http0, nhttp);
w->beresp = HTTP_create(http1, nhttp);
w->resp = HTTP_create(http2, nhttp);
w->wrw.iov = iov;
w->wrw.siov = siov;
w->wrw.ciov = siov;
AZ(pthread_cond_init(&w->cond, NULL));
WS_Init(w->ws, "wrk", ws, sess_workspace);
VSL(SLT_WorkThread, 0, "%p start", w);
Pool_Work_Thread(priv, w);
AZ(w->pool);
VSL(SLT_WorkThread, 0, "%p end", w);
if (w->vcl != NULL)
VCL_Rel(&w->vcl);
AZ(pthread_cond_destroy(&w->cond));
HSH_Cleanup(w);
WRK_SumStat(w);
return (NULL);
}
static void
cli_cb_after(const struct cli *cli)
{
ASSERT_CLI();
Lck_Unlock(&cli_mtx);
VSL(SLT_CLI, 0, "Wr %03u %u %s",
cli->result, vsb_len(cli->sb), vsb_data(cli->sb));
}
static void *
vwp_main(void *priv)
{
int v;
struct vwp *vwp;
struct waiter *w;
struct waited *wp;
double now, then;
int i;
THR_SetName("cache-poll");
CAST_OBJ_NOTNULL(vwp, priv, VWP_MAGIC);
w = vwp->waiter;
while (1) {
then = Wait_HeapDue(w, &wp);
if (wp == NULL)
i = -1;
else
i = (int)floor(1e3 * (then - VTIM_real()));
assert(vwp->hpoll > 0);
AN(vwp->pollfd);
v = poll(vwp->pollfd, vwp->hpoll, i);
assert(v >= 0);
now = VTIM_real();
if (vwp->pollfd[0].revents)
v--;
for (i = 1; i < vwp->hpoll;) {
VSL(SLT_Debug, vwp->pollfd[i].fd, "POLL loop i=%d revents=0x%x", i, vwp->pollfd[i].revents);
assert(vwp->pollfd[i].fd != vwp->pipes[0]);
wp = vwp->idx[i];
CHECK_OBJ_NOTNULL(wp, WAITED_MAGIC);
if (v == 0 && Wait_HeapDue(w, NULL) > now)
break;
if (vwp->pollfd[i].revents)
v--;
then = Wait_When(wp);
if (then <= now) {
Wait_HeapDelete(w, wp);
Wait_Call(w, wp, WAITER_TIMEOUT, now);
vwp_del(vwp, i);
} else if (vwp->pollfd[i].revents & POLLIN) {
assert(wp->fd > 0);
assert(wp->fd == vwp->pollfd[i].fd);
Wait_HeapDelete(w, wp);
Wait_Call(w, wp, WAITER_ACTION, now);
vwp_del(vwp, i);
} else {
i++;
}
}
if (vwp->pollfd[0].revents)
vwp_dopipe(vwp);
}
NEEDLESS_RETURN(NULL);
}
vmod_register_exp_callback(VRT_CTX, struct vmod_priv *priv)
{
struct priv_vcl *priv_vcl;
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
AZ(priv_vcl->exp_cb);
priv_vcl->exp_cb = EXP_Register_Callback(exp_cb, priv_vcl);
VSL(SLT_Debug, 0, "exp_cb: registered");
}
static void
cli_cb_before(const struct cli *cli)
{
ASSERT_CLI();
VSL(SLT_CLI, 0, "Rd %s", cli->cmd);
VCL_Poll();
VBE_Poll();
Lck_Lock(&cli_mtx);
}
void
SES_Delete(struct sess *sp)
{
struct acct *b = &sp->acct_ses;
struct sessmem *sm;
static char noaddr[] = "-";
CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
sm = sp->mem;
CHECK_OBJ_NOTNULL(sm, SESSMEM_MAGIC);
AZ(sp->obj);
AZ(sp->vcl);
assert(!isnan(b->first));
assert(!isnan(sp->t_end));
if (sp->addr == NULL)
sp->addr = noaddr;
if (sp->port == NULL)
sp->port = noaddr;
VSL(SLT_StatSess, sp->id, "%s %s %.0f %ju %ju %ju %ju %ju %ju %ju",
sp->addr, sp->port, sp->t_end - b->first,
b->sess, b->req, b->pipe, b->pass,
b->fetch, b->hdrbytes, b->bodybytes);
if (sm->workspace != params->sess_workspace) {
free(sm);
sm = NULL;
} else {
/* Clean and prepare for reuse */
ses_setup(sm);
Lck_Lock(&ses_mem_mtx);
VTAILQ_INSERT_HEAD(&ses_free_mem[1 - ses_qp], sm, list);
Lck_Unlock(&ses_mem_mtx);
}
SES_ClearReqBodyCache(sp);
/* Update statistics */
Lck_Lock(&stat_mtx);
if (sm == NULL)
VSC_C_main->n_sess_mem--;
n_sess_rel++;
VSC_C_main->n_sess = n_sess_grab - n_sess_rel;
Lck_Unlock(&stat_mtx);
/* Try to precreate some ses-mem so the acceptor will not have to */
if (VSC_C_main->n_sess_mem < VSC_C_main->n_sess + 10) {
sm = ses_sm_alloc();
if (sm != NULL) {
ses_setup(sm);
Lck_Lock(&ses_mem_mtx);
VTAILQ_INSERT_HEAD(&ses_free_mem[1 - ses_qp], sm, list);
Lck_Unlock(&ses_mem_mtx);
}
}
}
vmod_register_obj_events(VRT_CTX, struct vmod_priv *priv)
{
struct priv_vcl *priv_vcl;
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
AZ(priv_vcl->obj_cb);
priv_vcl->obj_cb = ObjSubscribeEvents(obj_cb, priv_vcl,
OEV_INSERT|OEV_REMOVE);
VSL(SLT_Debug, 0, "Subscribed to Object Events");
}
static int
http1_dissect(struct worker *wrk, struct req *req)
{
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);
/* Allocate a new vxid now that we know we'll need it. */
AZ(req->vsl->wid);
req->vsl->wid = VXID_Get(wrk, VSL_CLIENTMARKER);
VSLb(req->vsl, SLT_Begin, "req %u rxreq", VXID(req->sp->vxid));
VSL(SLT_Link, req->sp->vxid, "req %u rxreq", VXID(req->vsl->wid));
AZ(isnan(req->t_first)); /* First byte timestamp set by http1_wait */
AZ(isnan(req->t_req)); /* Complete req rcvd set by http1_wait */
req->t_prev = req->t_first;
VSLb_ts_req(req, "Start", req->t_first);
VSLb_ts_req(req, "Req", req->t_req);
HTTP_Setup(req->http, req->ws, req->vsl, SLT_ReqMethod);
req->err_code = HTTP1_DissectRequest(req->htc, req->http);
/* If we could not even parse the request, just close */
if (req->err_code != 0) {
VSLb(req->vsl, SLT_HttpGarbage, "%.*s",
(int)(req->htc->rxbuf_e - req->htc->rxbuf_b),
req->htc->rxbuf_b);
wrk->stats->client_req_400++;
req->doclose = SC_RX_JUNK;
http1_abort(req, 400);
return (-1);
}
assert (req->req_body_status == REQ_BODY_INIT);
switch (req->htc->body_status) {
case BS_CHUNKED:
req->req_body_status = REQ_BODY_WITHOUT_LEN;
break;
case BS_LENGTH:
req->req_body_status = REQ_BODY_WITH_LEN;
break;
case BS_NONE:
req->req_body_status = REQ_BODY_NONE;
break;
case BS_EOF:
req->req_body_status = REQ_BODY_WITHOUT_LEN;
break;
default:
WRONG("Unknown req_body_status situation");
}
return (0);
}
void
SES_Close(struct sess *sp, const char *reason)
{
int i;
assert(sp->fd >= 0);
VSL(SLT_SessionClose, sp->vsl_id, "%s", reason);
i = close(sp->fd);
assert(i == 0 || errno != EBADF); /* XXX EINVAL seen */
sp->fd = -1;
}
void
VRT_acl_log(VRT_CTX, const char *msg)
{
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
AN(msg);
if (ctx->vsl != NULL)
VSLb(ctx->vsl, SLT_VCL_acl, "%s", msg);
else
VSL(SLT_VCL_acl, 0, "%s", msg);
}
void
WRK_Thread(struct pool *qp, size_t stacksize, unsigned thread_workspace)
{
struct worker *w, ww;
unsigned char ws[thread_workspace];
uintptr_t u;
AN(qp);
AN(stacksize);
AN(thread_workspace);
THR_SetName("cache-worker");
w = &ww;
INIT_OBJ(w, WORKER_MAGIC);
w->lastused = NAN;
AZ(pthread_cond_init(&w->cond, NULL));
WS_Init(w->aws, "wrk", ws, thread_workspace);
u = getpagesize();
AN(u);
u -= 1U;
w->stack_start = (((uintptr_t)&qp) + u) & ~u;
/* XXX: assuming stack grows down. */
w->stack_end = w->stack_start - stacksize;
VSL(SLT_WorkThread, 0, "%p start", w);
Pool_Work_Thread(qp, w);
AZ(w->pool);
VSL(SLT_WorkThread, 0, "%p end", w);
if (w->vcl != NULL)
VCL_Rel(&w->vcl);
AZ(pthread_cond_destroy(&w->cond));
if (w->nbo != NULL)
VBO_Free(&w->nbo);
HSH_Cleanup(w);
Pool_Sumstat(w);
}
Lck__Unlock(struct lock *lck, const char *p, const char *f, int l)
{
struct ilck *ilck;
CAST_OBJ_NOTNULL(ilck, lck->priv, ILCK_MAGIC);
assert(pthread_equal(ilck->owner, pthread_self()));
AN(ilck->held);
ilck->held = 0;
AZ(pthread_mutex_unlock(&ilck->mtx));
if (params->diag_bitmap & 0x8)
VSL(SLT_Debug, 0, "MTX_UNLOCK(%s,%s,%d,%s)", p, f, l, ilck->w);
}
static void
vca_kev(const struct kevent *kp)
{
int i, j;
struct sess *sp;
struct sess *ss[NKEV];
AN(kp->udata);
if (kp->udata == vca_pipes) {
j = 0;
i = read(vca_pipes[0], ss, sizeof ss);
if (i == -1 && errno == EAGAIN)
return;
while (i >= sizeof ss[0]) {
CHECK_OBJ_NOTNULL(ss[j], SESS_MAGIC);
assert(ss[j]->sp_fd >= 0);
AZ(ss[j]->obj);
VTAILQ_INSERT_TAIL(&sesshead, ss[j], list);
vca_kq_sess(ss[j], EV_ADD | EV_ONESHOT);
j++;
i -= sizeof ss[0];
}
assert(i == 0);
return;
}
CAST_OBJ_NOTNULL(sp, kp->udata, SESS_MAGIC);
DSL(0x04, SLT_Debug, sp->id, "KQ: sp %p kev data %lu flags 0x%x%s",
sp, (unsigned long)kp->data, kp->flags,
(kp->flags & EV_EOF) ? " EOF" : "");
assert(sp->id == kp->ident);
assert(sp->sp_fd == sp->id);
if (kp->data > 0) {
i = HTC_Rx(sp->htc);
if (i == 0) {
vca_kq_sess(sp, EV_ADD | EV_ONESHOT);
return; /* more needed */
}
VTAILQ_REMOVE(&sesshead, sp, list);
vca_handover(sp, i);
return;
} else if (kp->flags & EV_EOF) {
VTAILQ_REMOVE(&sesshead, sp, list);
vca_close_session(sp, "EOF");
SES_Delete(sp);
return;
} else {
VSL(SLT_Debug, sp->id, "KQ: sp %p kev data %lu flags 0x%x%s",
sp, (unsigned long)kp->data, kp->flags,
(kp->flags & EV_EOF) ? " EOF" : "");
}
}
static void
cnt_diag(struct sess *sp, const char *state)
{
if (sp->wrk != NULL) {
WSP(sp, SLT_Debug, "thr %p STP_%s sp %p obj %p vcl %p",
pthread_self(), state, sp, sp->wrk->obj, sp->vcl);
WSL_Flush(sp->wrk, 0);
} else {
VSL(SLT_Debug, sp->vsl_id,
"thr %p STP_%s sp %p obj %p vcl %p",
pthread_self(), state, sp, sp->wrk->obj, sp->vcl);
}
}
static void
vwp_del(struct vwp *vwp, int n)
{
vwp->hpoll--;
if (n != vwp->hpoll) {
vwp->pollfd[n] = vwp->pollfd[vwp->hpoll];
vwp->idx[n] = vwp->idx[vwp->hpoll];
}
VSL(SLT_Debug, vwp->pollfd[vwp->hpoll].fd, "DEL");
memset(&vwp->pollfd[vwp->hpoll], 0, sizeof(*vwp->pollfd));
vwp->pollfd[vwp->hpoll].fd = -1;
vwp->idx[vwp->hpoll] = NULL;
}
