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; }