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