void SES_Init() { Lck_New(&stat_mtx, lck_stat); Lck_New(&ses_mem_mtx, lck_sessmem); }
void Pool_Init(void) { Lck_New(&wstat_mtx, lck_wstat); Lck_New(&pool_mtx, lck_wq); AZ(pthread_create(&thr_pool_herder, NULL, pool_poolherder, NULL)); }
static struct sess * ses_new(struct sesspool *pp) { struct sess *sp; unsigned sz; char *p, *e; CHECK_OBJ_NOTNULL(pp, SESSPOOL_MAGIC); sp = MPL_Get(pp->mpl_sess, &sz); sp->magic = SESS_MAGIC; sp->sesspool = pp; e = (char*)sp + sz; p = (char*)(sp + 1); p = (void*)PRNDUP(p); assert(p < e); WS_Init(sp->ws, "ses", p, e - p); sp->addrs = (void*)WS_Alloc(sp->ws, vsa_suckaddr_len * 2); sp->t_open = NAN; sp->t_idle = NAN; Lck_New(&sp->mtx, lck_sess); CHECK_OBJ_NOTNULL(sp, SESS_MAGIC); return (sp); }
struct sess * SES_New(struct pool *pp) { struct sess *sp; unsigned sz; char *p, *e; CHECK_OBJ_NOTNULL(pp, POOL_MAGIC); sp = MPL_Get(pp->mpl_sess, &sz); sp->magic = SESS_MAGIC; sp->pool = pp; sp->refcnt = 1; memset(sp->sattr, 0xff, sizeof sp->sattr); e = (char*)sp + sz; p = (char*)(sp + 1); p = (void*)PRNDUP(p); assert(p < e); WS_Init(sp->ws, "ses", p, e - p); sp->t_open = NAN; sp->t_idle = NAN; Lck_New(&sp->mtx, lck_sess); CHECK_OBJ_NOTNULL(sp, SESS_MAGIC); return (sp); }
/* Precreate an objhead and object for later use */ static void hsh_prealloc(struct worker *wrk) { struct objhead *oh; struct waitinglist *wl; CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC); if (wrk->nobjcore == NULL) wrk->nobjcore = HSH_NewObjCore(wrk); CHECK_OBJ_NOTNULL(wrk->nobjcore, OBJCORE_MAGIC); if (wrk->nobjhead == NULL) { ALLOC_OBJ(oh, OBJHEAD_MAGIC); XXXAN(oh); oh->refcnt = 1; VTAILQ_INIT(&oh->objcs); Lck_New(&oh->mtx, lck_objhdr); wrk->nobjhead = oh; wrk->stats.n_objecthead++; } CHECK_OBJ_NOTNULL(wrk->nobjhead, OBJHEAD_MAGIC); if (wrk->nwaitinglist == NULL) { ALLOC_OBJ(wl, WAITINGLIST_MAGIC); XXXAN(wl); VTAILQ_INIT(&wl->list); wrk->nwaitinglist = wl; wrk->stats.n_waitinglist++; } CHECK_OBJ_NOTNULL(wrk->nwaitinglist, WAITINGLIST_MAGIC); if (hash->prep != NULL) hash->prep(wrk); }
static struct pool * pool_mkpool(unsigned pool_no) { struct pool *pp; ALLOC_OBJ(pp, POOL_MAGIC); if (pp == NULL) return (NULL); pp->a_stat = calloc(1, sizeof *pp->a_stat); AN(pp->a_stat); pp->b_stat = calloc(1, sizeof *pp->b_stat); AN(pp->b_stat); Lck_New(&pp->mtx, lck_wq); VTAILQ_INIT(&pp->idle_queue); VTAILQ_INIT(&pp->front_queue); VTAILQ_INIT(&pp->back_queue); AZ(pthread_cond_init(&pp->herder_cond, NULL)); AZ(pthread_create(&pp->herder_thr, NULL, pool_herder, pp)); while (VTAILQ_EMPTY(&pp->idle_queue)) (void)usleep(10000); pp->sesspool = SES_NewPool(pp, pool_no); AN(pp->sesspool); return (pp); }
static struct sess * ses_new(struct sesspool *pp) { struct sess *sp; char *s; unsigned sz; CHECK_OBJ_NOTNULL(pp, SESSPOOL_MAGIC); sp = MPL_Get(pp->mpl_sess, &sz); sp->magic = SESS_MAGIC; sp->sesspool = pp; s = (char *)sp; s += sizeof *sp; memset(s, 0, vsa_suckaddr_len); sp->local_addr = (void*)s; s += vsa_suckaddr_len; memset(s, 0, vsa_suckaddr_len); sp->remote_addr = (void*)s; s += vsa_suckaddr_len; assert((char *)sp + sz == s); sp->t_open = NAN; sp->t_idle = NAN; Lck_New(&sp->mtx, lck_sess); CHECK_OBJ_NOTNULL(sp, SESS_MAGIC); return (sp); }
void VBP_Init(void) { pthread_t thr; Lck_New(&vbp_mtx, lck_backend); vbp_heap = binheap_new(NULL, vbp_cmp, vbp_update); AN(vbp_heap); AZ(pthread_cond_init(&vbp_cond, NULL)); WRK_BgThread(&thr, "backend-poller", vbp_thread, NULL); }
static struct boc * obj_newboc(void) { struct boc *boc; ALLOC_OBJ(boc, BOC_MAGIC); AN(boc); Lck_New(&boc->mtx, lck_busyobj); AZ(pthread_cond_init(&boc->cond, NULL)); boc->refcount = 1; return (boc); }
static struct objhead * hsh_newobjhead(void) { struct objhead *oh; ALLOC_OBJ(oh, OBJHEAD_MAGIC); XXXAN(oh); oh->refcnt = 1; VTAILQ_INIT(&oh->objcs); Lck_New(&oh->mtx, lck_objhdr); return (oh); }
void CLI_Init(void) { Lck_New(&cli_mtx); cli_thread = pthread_self(); cls = CLS_New(cli_cb_before, cli_cb_after, params->cli_buffer); AN(cls); CLI_AddFuncs(master_cmds); }
struct sesspool * SES_NewPool(struct pool *pp) { struct sesspool *sp; ALLOC_OBJ(sp, SESSPOOL_MAGIC); AN(sp); sp->pool = pp; VTAILQ_INIT(&sp->freelist); Lck_New(&sp->mtx, lck_sessmem); return (sp); }
static void sma_open(const struct stevedore *st) { struct sma_sc *sma_sc; CAST_OBJ_NOTNULL(sma_sc, st->priv, SMA_SC_MAGIC); Lck_New(&sma_sc->sma_mtx, lck_sma); sma_sc->stats = VSM_Alloc(sizeof *sma_sc->stats, VSC_CLASS, VSC_TYPE_SMA, st->ident); memset(sma_sc->stats, 0, sizeof *sma_sc->stats); if (sma_sc->sma_max != SIZE_MAX) sma_sc->stats->g_space = sma_sc->sma_max; }
void CLI_Init(void) { Lck_New(&cli_mtx, lck_cli); cli_thread = pthread_self(); cls = VCLS_New(cli_cb_before, cli_cb_after, &cache_param->cli_buffer, &cache_param->cli_limit); AN(cls); CLI_AddFuncs(master_cmds); }
static struct busyobj * vbo_New(void) { struct busyobj *bo; unsigned sz; bo = MPL_Get(vbopool, &sz); XXXAN(bo); bo->magic = BUSYOBJ_MAGIC; bo->end = (char *)bo + sz; Lck_New(&bo->mtx, lck_busyobj); AZ(pthread_cond_init(&bo->cond, NULL)); return (bo); }
void EXP_Init(void) { struct exp_priv *ep; pthread_t pt; ALLOC_OBJ(ep, EXP_PRIV_MAGIC); AN(ep); Lck_New(&ep->mtx, lck_exp); AZ(pthread_cond_init(&ep->condvar, NULL)); VSTAILQ_INIT(&ep->inbox); exphdl = ep; WRK_BgThread(&pt, "cache-exp", exp_thread, ep); }
struct sesspool * SES_NewPool(struct pool *wp, unsigned pool_no) { struct sesspool *pp; char nb[8]; ALLOC_OBJ(pp, SESSPOOL_MAGIC); AN(pp); pp->pool = wp; VTAILQ_INIT(&pp->freelist); Lck_New(&pp->mtx, lck_sessmem); bprintf(nb, "req%u", pool_no); pp->req_size = sizeof (struct req); pp->mpl_req = MPL_New(nb, &cache_param->req_pool, &pp->req_size); return (pp); }
static void sma_open(const struct stevedore *st) { struct sma_sc *sma_sc; ASSERT_CLI(); if (lck_sma == NULL) lck_sma = Lck_CreateClass("sma"); CAST_OBJ_NOTNULL(sma_sc, st->priv, SMA_SC_MAGIC); Lck_New(&sma_sc->sma_mtx, lck_sma); sma_sc->stats = VSM_Alloc(sizeof *sma_sc->stats, VSC_CLASS, VSC_type_sma, st->ident); memset(sma_sc->stats, 0, sizeof *sma_sc->stats); if (sma_sc->sma_max != SIZE_MAX) sma_sc->stats->g_space = sma_sc->sma_max; }
static struct objcore * hsh_NewObjCore(struct worker *wrk, int boc) { struct objcore *oc; ALLOC_OBJ(oc, OBJCORE_MAGIC); AN(oc); wrk->stats->n_objectcore++; oc->flags |= OC_F_BUSY | OC_F_INCOMPLETE; if (boc) { ALLOC_OBJ(oc->boc, BOC_MAGIC); AN(oc->boc); Lck_New(&oc->boc->mtx, lck_busyobj); AZ(pthread_cond_init(&oc->boc->cond, NULL)); oc->boc->refcount = 1; } return (oc); }
/* Precreate an objhead and object for later use */ void HSH_Prealloc(const struct sess *sp) { struct worker *wrk; struct objhead *oh; struct objcore *oc; struct waitinglist *wl; CHECK_OBJ_NOTNULL(sp, SESS_MAGIC); CHECK_OBJ_NOTNULL(sp->wrk, WORKER_MAGIC); wrk = sp->wrk; if (wrk->nobjcore == NULL) { ALLOC_OBJ(oc, OBJCORE_MAGIC); XXXAN(oc); wrk->nobjcore = oc; wrk->stats.n_objectcore++; oc->flags |= OC_F_BUSY; } CHECK_OBJ_NOTNULL(wrk->nobjcore, OBJCORE_MAGIC); if (wrk->nobjhead == NULL) { ALLOC_OBJ(oh, OBJHEAD_MAGIC); XXXAN(oh); oh->refcnt = 1; VTAILQ_INIT(&oh->objcs); Lck_New(&oh->mtx, lck_objhdr); wrk->nobjhead = oh; wrk->stats.n_objecthead++; } CHECK_OBJ_NOTNULL(wrk->nobjhead, OBJHEAD_MAGIC); if (wrk->nwaitinglist == NULL) { ALLOC_OBJ(wl, WAITINGLIST_MAGIC); XXXAN(wl); VTAILQ_INIT(&wl->list); wrk->nwaitinglist = wl; wrk->stats.n_waitinglist++; } CHECK_OBJ_NOTNULL(wrk->nwaitinglist, WAITINGLIST_MAGIC); if (hash->prep != NULL) hash->prep(sp); }
vwe_init(struct waiter *w) { struct vwe *vwe; struct epoll_event ee; CHECK_OBJ_NOTNULL(w, WAITER_MAGIC); vwe = w->priv; INIT_OBJ(vwe, VWE_MAGIC); vwe->waiter = w; vwe->epfd = epoll_create(1); assert(vwe->epfd >= 0); Lck_New(&vwe->mtx, lck_waiter); AZ(pipe(vwe->pipe)); ee.events = EPOLLIN | EPOLLRDHUP; ee.data.ptr = vwe; AZ(epoll_ctl(vwe->epfd, EPOLL_CTL_ADD, vwe->pipe[0], &ee)); AZ(pthread_create(&vwe->thread, NULL, vwe_thread, vwe)); }
struct mempool * MPL_New(const char *name, volatile struct poolparam *pp, volatile unsigned *cur_size) { struct mempool *mpl; ALLOC_OBJ(mpl, MEMPOOL_MAGIC); AN(mpl); bprintf(mpl->name, "%s", name); mpl->param = pp; mpl->cur_size = cur_size; VTAILQ_INIT(&mpl->list); VTAILQ_INIT(&mpl->surplus); Lck_New(&mpl->mtx, lck_mempool); /* XXX: prealloc min_pool */ mpl->vsc = VSM_Alloc(sizeof *mpl->vsc, VSC_CLASS, VSC_type_mempool, mpl->name); AN(mpl->vsc); AZ(pthread_create(&mpl->thread, NULL, mpl_guard, mpl)); AZ(pthread_detach(mpl->thread)); return (mpl); }
void VBP_Insert(struct backend *b, const struct vrt_backend_probe *p, const char *hosthdr) { struct vbp_target *vt; unsigned u; ASSERT_CLI(); CHECK_OBJ_NOTNULL(b, BACKEND_MAGIC); CHECK_OBJ_NOTNULL(p, VRT_BACKEND_PROBE_MAGIC); AZ(b->probe); ALLOC_OBJ(vt, VBP_TARGET_MAGIC); XXXAN(vt); VTAILQ_INSERT_TAIL(&vbp_list, vt, list); Lck_New(&vt->mtx, lck_backend); vt->disable = -1; vt->tcp_pool = VBT_Ref(b->ipv4, b->ipv6); AN(vt->tcp_pool); vt->probe = *p; vbp_set_defaults(vt); vbp_build_req(vt, hosthdr); for (u = 0; u < vt->probe.initial; u++) { if (u) vbp_has_poked(vt); vbp_start_poke(vt); vt->happy |= 1; vbp_has_poked(vt); } vt->backend = b; b->probe = vt; vbp_has_poked(vt); }
void child_main(void) { setbuf(stdout, NULL); setbuf(stderr, NULL); printf("Child starts\n"); cache_param = heritage.param; AZ(pthread_key_create(&req_key, NULL)); AZ(pthread_key_create(&bo_key, NULL)); AZ(pthread_key_create(&name_key, NULL)); THR_SetName("cache-main"); VSM_Init(); /* First, LCK needs it. */ LCK_Init(); /* Second, locking */ Lck_New(&vxid_lock, lck_vxid); CLI_Init(); PAN_Init(); VFP_Init(); VCL_Init(); HTTP_Init(); VBO_Init(); VBP_Init(); VBE_InitCfg(); Pool_Init(); V1P_Init(); EXP_Init(); HSH_Init(heritage.hash); BAN_Init(); VCA_Init(); SMP_Init(); STV_open(); VMOD_Init(); BAN_Compile(); VRND_Seed(); srand48(random()); CLI_AddFuncs(debug_cmds); /* Wait for persistent storage to load if asked to */ if (FEATURE(FEATURE_WAIT_SILO)) SMP_Ready(); CLI_Run(); BAN_Shutdown(); STV_close(); printf("Child dies\n"); }
void V1P_Init(void) { Lck_New(&pipestat_mtx, lck_pipestat); }
void WRK_Init(void) { Lck_New(&wstat_mtx, lck_wstat); }