Skip to content

V
varnish-cache
Commit 41608b69 authored by Poul-Henning Kamp's avatar Poul-Henning Kamp
Browse files
Options

Always call struct worker variables "wrk" to ease grep'ing

parent 2955f0ba
Hide whitespace changes
Inline Side-by-side
Showing with 157 additions and 155 deletions
bin/varnishd/cache/cache_acceptor.c
View file @ 41608b69
......@@ -220,15 +220,15 @@ VCA_Accept(struct listen_sock *ls, struct wrk_accept *wa)
*/
void
VCA_FailSess(struct worker *w)
VCA_FailSess(struct worker *wrk)
{
struct wrk_accept *wa;
CHECK_OBJ_NOTNULL(w, WORKER_MAGIC);
CAST_OBJ_NOTNULL(wa, (void*)w->ws->f, WRK_ACCEPT_MAGIC);
AZ(w->sp);
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CAST_OBJ_NOTNULL(wa, (void*)wrk->ws->f, WRK_ACCEPT_MAGIC);
AZ(wrk->sp);
AZ(close(wa->acceptsock));
w->stats.sess_drop++;
wrk->stats.sess_drop++;
vca_pace_bad();
}
......@@ -237,14 +237,14 @@ VCA_FailSess(struct worker *w)
*/
void
VCA_SetupSess(struct worker *w)
VCA_SetupSess(struct worker *wrk)
{
struct sess *sp;
struct wrk_accept *wa;
CHECK_OBJ_NOTNULL(w, WORKER_MAGIC);
CAST_OBJ_NOTNULL(wa, (void*)w->ws->f, WRK_ACCEPT_MAGIC);
sp = w->sp;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CAST_OBJ_NOTNULL(wa, (void*)wrk->ws->f, WRK_ACCEPT_MAGIC);
sp = wrk->sp;
CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
sp->fd = wa->acceptsock;
sp->vsl_id = wa->acceptsock | VSL_CLIENTMARKER ;
......@@ -258,7 +258,7 @@ VCA_SetupSess(struct worker *w)
memcpy(&sp->sockaddr, &wa->acceptaddr, wa->acceptaddrlen);
sp->sockaddrlen = wa->acceptaddrlen;
vca_pace_good();
w->stats.sess_conn++;
wrk->stats.sess_conn++;
if (need_test)
sock_test(sp->fd);
......
bin/varnishd/cache/cache_cli.c
View file @ 41608b69
......@@ -127,6 +127,7 @@ cli_debug_sizeof(struct cli *cli, const char * const *av, void *priv)
SZOF(struct http_conn);
SZOF(struct acct);
SZOF(struct worker);
SZOF(struct wrk_accept);
SZOF(struct storage);
SZOF(struct object);
SZOF(struct objcore);
......
bin/varnishd/cache/cache_pool.c
View file @ 41608b69
......@@ -129,20 +129,20 @@ static pthread_t thr_pool_herder;
*/
static int
pool_accept(struct pool *pp, struct worker *w, const struct poolsock *ps)
pool_accept(struct pool *pp, struct worker *wrk, const struct poolsock *ps)
{
struct worker *w2;
struct worker *wrk2;
struct wrk_accept *wa, *wa2;
CHECK_OBJ_NOTNULL(pp, POOL_MAGIC);
CHECK_OBJ_NOTNULL(w, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(ps, POOLSOCK_MAGIC);
CHECK_OBJ_NOTNULL(ps->lsock, LISTEN_SOCK_MAGIC);
Lck_AssertHeld(&pp->mtx);
Lck_Unlock(&pp->mtx);
assert(sizeof *wa == WS_Reserve(w->ws, sizeof *wa));
wa = (void*)w->ws->f;
assert(sizeof *wa == WS_Reserve(wrk->ws, sizeof *wa));
wa = (void*)wrk->ws->f;
while (1) {
memset(wa, 0, sizeof *wa);
wa->magic = WRK_ACCEPT_MAGIC;
......@@ -153,23 +153,23 @@ pool_accept(struct pool *pp, struct worker *w, const struct poolsock *ps)
return (-1);
}
if (VCA_Accept(ps->lsock, wa) < 0) {
w->stats.sess_fail++;
wrk->stats.sess_fail++;
/* We're going to pace in vca anyway... */
(void)WRK_TrySumStat(w);
(void)WRK_TrySumStat(wrk);
continue;
}
Lck_Lock(&pp->mtx);
if (VTAILQ_EMPTY(&pp->idle))
return (0);
w2 = VTAILQ_FIRST(&pp->idle);
VTAILQ_REMOVE(&pp->idle, w2, list);
wrk2 = VTAILQ_FIRST(&pp->idle);
VTAILQ_REMOVE(&pp->idle, wrk2, list);
Lck_Unlock(&pp->mtx);
assert(sizeof *wa2 == WS_Reserve(w2->ws, sizeof *wa2));
wa2 = (void*)w2->ws->f;
assert(sizeof *wa2 == WS_Reserve(wrk2->ws, sizeof *wa2));
wa2 = (void*)wrk2->ws->f;
memcpy(wa2, wa, sizeof *wa);
w2->do_what = pool_do_accept;
AZ(pthread_cond_signal(&w2->cond));
wrk2->do_what = pool_do_accept;
AZ(pthread_cond_signal(&wrk2->cond));
}
}
......@@ -178,111 +178,111 @@ pool_accept(struct pool *pp, struct worker *w, const struct poolsock *ps)
*/
void
Pool_Work_Thread(void *priv, struct worker *w)
Pool_Work_Thread(void *priv, struct worker *wrk)
{
struct pool *pp;
int stats_clean, i;
struct poolsock *ps;
CAST_OBJ_NOTNULL(pp, priv, POOL_MAGIC);
w->pool = pp;
wrk->pool = pp;
Lck_Lock(&pp->mtx);
stats_clean = 1;
while (1) {
Lck_AssertHeld(&pp->mtx);
w->do_what = pool_do_inval;
wrk->do_what = pool_do_inval;
CHECK_OBJ_NOTNULL(w, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
WS_Reset(w->ws, NULL);
WS_Reset(wrk->ws, NULL);
w->sp = VTAILQ_FIRST(&pp->queue);
if (w->sp != NULL) {
wrk->sp = VTAILQ_FIRST(&pp->queue);
if (wrk->sp != NULL) {
/* Process queued requests, if any */
assert(pp->lqueue > 0);
VTAILQ_REMOVE(&pp->queue, w->sp, poollist);
w->do_what = pool_do_sess;
VTAILQ_REMOVE(&pp->queue, wrk->sp, poollist);
wrk->do_what = pool_do_sess;
pp->lqueue--;
} else if (!VTAILQ_EMPTY(&pp->socks)) {
/* Accept on a socket */
ps = VTAILQ_FIRST(&pp->socks);
VTAILQ_REMOVE(&pp->socks, ps, list);
i = pool_accept(pp, w, ps);
i = pool_accept(pp, wrk, ps);
Lck_AssertHeld(&pp->mtx);
if (i < 0) {
/* Socket Shutdown */
FREE_OBJ(ps);
WS_Release(w->ws, 0);
WS_Release(wrk->ws, 0);
continue;
}
VTAILQ_INSERT_TAIL(&pp->socks, ps, list);
w->do_what = pool_do_accept;
wrk->do_what = pool_do_accept;
} else if (VTAILQ_EMPTY(&pp->socks)) {
/* Nothing to do: To sleep, perchance to dream ... */
if (isnan(w->lastused))
w->lastused = VTIM_real();
VTAILQ_INSERT_HEAD(&pp->idle, w, list);
if (isnan(wrk->lastused))
wrk->lastused = VTIM_real();
VTAILQ_INSERT_HEAD(&pp->idle, wrk, list);
if (!stats_clean)
WRK_SumStat(w);
(void)Lck_CondWait(&w->cond, &pp->mtx, NULL);
WRK_SumStat(wrk);
(void)Lck_CondWait(&wrk->cond, &pp->mtx, NULL);
}
if (w->do_what == pool_do_die)
if (wrk->do_what == pool_do_die)
break;
Lck_Unlock(&pp->mtx);
if (w->do_what == pool_do_accept) {
if (wrk->do_what == pool_do_accept) {
/* Turn accepted socket into a session */
AZ(w->sp);
AN(w->ws->r);
w->sp = SES_New(pp->sesspool);
if (w->sp == NULL) {
VCA_FailSess(w);
w->do_what = pool_do_nothing;
AZ(wrk->sp);
AN(wrk->ws->r);
wrk->sp = SES_New(pp->sesspool);
if (wrk->sp == NULL) {
VCA_FailSess(wrk);
wrk->do_what = pool_do_nothing;
} else {
VCA_SetupSess(w);
w->sp->step = STP_FIRST;
w->do_what = pool_do_sess;
VCA_SetupSess(wrk);
wrk->sp->step = STP_FIRST;
wrk->do_what = pool_do_sess;
}
WS_Release(w->ws, 0);
WS_Release(wrk->ws, 0);
}
if (w->do_what == pool_do_sess) {
CHECK_OBJ_NOTNULL(w->sp, SESS_MAGIC);
AZ(w->ws->r);
if (wrk->do_what == pool_do_sess) {
CHECK_OBJ_NOTNULL(wrk->sp, SESS_MAGIC);
AZ(wrk->ws->r);
stats_clean = 0;
w->lastused = NAN;
w->storage_hint = NULL;
wrk->lastused = NAN;
wrk->storage_hint = NULL;
AZ(w->sp->wrk);
THR_SetSession(w->sp);
w->sp->wrk = w;
CNT_Session(w->sp);
AZ(wrk->sp->wrk);
THR_SetSession(wrk->sp);
wrk->sp->wrk = wrk;
CNT_Session(wrk->sp);
THR_SetSession(NULL);
w->sp = NULL;
wrk->sp = NULL;
WS_Assert(w->ws);
AZ(w->busyobj);
AZ(w->wrw.wfd);
AZ(w->storage_hint);
assert(w->wlp == w->wlb);
WS_Assert(wrk->ws);
AZ(wrk->busyobj);
AZ(wrk->wrw.wfd);
AZ(wrk->storage_hint);
assert(wrk->wlp == wrk->wlb);
if (cache_param->diag_bitmap & 0x00040000) {
if (w->vcl != NULL)
VCL_Rel(&w->vcl);
if (wrk->vcl != NULL)
VCL_Rel(&wrk->vcl);
}
} else if (w->do_what == pool_do_nothing) {
} else if (wrk->do_what == pool_do_nothing) {
/* we already did */
} else {
WRONG("Invalid w->do_what");
WRONG("Invalid wrk->do_what");
}
stats_clean = WRK_TrySumStat(w);
stats_clean = WRK_TrySumStat(wrk);
Lck_Lock(&pp->mtx);
}
Lck_Unlock(&pp->mtx);
w->pool = NULL;
wrk->pool = NULL;
}
/*--------------------------------------------------------------------
......@@ -294,18 +294,18 @@ Pool_Work_Thread(void *priv, struct worker *w)
static int
pool_queue(struct pool *pp, struct sess *sp)
{
struct worker *w;
struct worker *wrk;
Lck_Lock(&pp->mtx);
/* If there are idle threads, we tickle the first one into action */
w = VTAILQ_FIRST(&pp->idle);
if (w != NULL) {
VTAILQ_REMOVE(&pp->idle, w, list);
wrk = VTAILQ_FIRST(&pp->idle);
if (wrk != NULL) {
VTAILQ_REMOVE(&pp->idle, wrk, list);
Lck_Unlock(&pp->mtx);
w->sp = sp;
w->do_what = pool_do_sess;
AZ(pthread_cond_signal(&w->cond));
wrk->sp = sp;
wrk->do_what = pool_do_sess;
AZ(pthread_cond_signal(&wrk->cond));
return (0);
}
......@@ -397,7 +397,7 @@ pool_herder(void *priv)
pthread_attr_t tp_attr;
struct timespec ts;
double t_idle;
struct worker *w;
struct worker *wrk;
int i;
CAST_OBJ_NOTNULL(pp, priv, POOL_MAGIC);
......@@ -442,25 +442,25 @@ pool_herder(void *priv)
VSC_C_main->sess_queued += pp->nqueued;
VSC_C_main->sess_dropped += pp->ndropped;
pp->nqueued = pp->ndropped = 0;
w = VTAILQ_LAST(&pp->idle, workerhead);
if (w != NULL &&
(w->lastused < t_idle ||
wrk = VTAILQ_LAST(&pp->idle, workerhead);
if (wrk != NULL &&
(wrk->lastused < t_idle ||
pp->nthr > cache_param->wthread_max)) {
VTAILQ_REMOVE(&pp->idle, w, list);
VTAILQ_REMOVE(&pp->idle, wrk, list);
} else
w = NULL;
wrk = NULL;
Lck_Unlock(&pp->mtx);
/* And give it a kiss on the cheek... */
if (w != NULL) {
if (wrk != NULL) {
pp->nthr--;
Lck_Lock(&pool_mtx);
VSC_C_main->threads--;
VSC_C_main->threads_destroyed++;
Lck_Unlock(&pool_mtx);
AZ(w->sp);
w->do_what = pool_do_die;
AZ(pthread_cond_signal(&w->cond));
AZ(wrk->sp);
wrk->do_what = pool_do_die;
AZ(pthread_cond_signal(&wrk->cond));
}
}
NEEDLESS_RETURN(NULL);
......
bin/varnishd/cache/cache_response.c
View file @ 41608b69
......@@ -359,52 +359,52 @@ RES_StreamStart(struct sess *sp)
}
void
RES_StreamPoll(struct worker *w)
RES_StreamPoll(struct worker *wrk)
{
struct stream_ctx *sctx;
struct storage *st;
ssize_t l, l2;
void *ptr;
CHECK_OBJ_NOTNULL(w, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(w->busyobj->fetch_obj, OBJECT_MAGIC);
sctx = w->sctx;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(wrk->busyobj->fetch_obj, OBJECT_MAGIC);
sctx = wrk->sctx;
CHECK_OBJ_NOTNULL(sctx, STREAM_CTX_MAGIC);
if (w->busyobj->fetch_obj->len == sctx->stream_next)
if (wrk->busyobj->fetch_obj->len == sctx->stream_next)
return;
assert(w->busyobj->fetch_obj->len > sctx->stream_next);
assert(wrk->busyobj->fetch_obj->len > sctx->stream_next);
l = sctx->stream_front;
VTAILQ_FOREACH(st, &w->busyobj->fetch_obj->store, list) {
VTAILQ_FOREACH(st, &wrk->busyobj->fetch_obj->store, list) {
if (st->len + l <= sctx->stream_next) {
l += st->len;
continue;
}
l2 = st->len + l - sctx->stream_next;
ptr = st->ptr + (sctx->stream_next - l);
if (w->res_mode & RES_GUNZIP) {
(void)VGZ_WrwGunzip(w, sctx->vgz, ptr, l2,
if (wrk->res_mode & RES_GUNZIP) {
(void)VGZ_WrwGunzip(wrk, sctx->vgz, ptr, l2,
sctx->obuf, sctx->obuf_len, &sctx->obuf_ptr);
} else {
(void)WRW_Write(w, ptr, l2);
(void)WRW_Write(wrk, ptr, l2);
}
l += st->len;
sctx->stream_next += l2;
}
if (!(w->res_mode & RES_GUNZIP))
(void)WRW_Flush(w);
if (!(wrk->res_mode & RES_GUNZIP))
(void)WRW_Flush(wrk);
if (w->busyobj->fetch_obj->objcore == NULL ||
(w->busyobj->fetch_obj->objcore->flags & OC_F_PASS)) {
if (wrk->busyobj->fetch_obj->objcore == NULL ||
(wrk->busyobj->fetch_obj->objcore->flags & OC_F_PASS)) {
/*
* This is a pass object, release storage as soon as we
* have delivered it.
*/
while (1) {
st = VTAILQ_FIRST(&w->busyobj->fetch_obj->store);
st = VTAILQ_FIRST(&wrk->busyobj->fetch_obj->store);
if (st == NULL ||
sctx->stream_front + st->len > sctx->stream_next)
break;
VTAILQ_REMOVE(&w->busyobj->fetch_obj->store, st, list);
VTAILQ_REMOVE(&wrk->busyobj->fetch_obj->store, st, list);
sctx->stream_front += st->len;
STV_free(st);
}
......
bin/varnishd/cache/cache_shmlog.c
View file @ 41608b69
......@@ -35,7 +35,7 @@
#include "cache.h"
#include "common/heritage.h"
#include "cache_backend.h" // For w->vbc
#include "cache_backend.h" // For wrk->vbc
#include "vmb.h"
#include "vtim.h"
......@@ -180,30 +180,30 @@ VSL(enum VSL_tag_e tag, int id, const char *fmt, ...)
/*--------------------------------------------------------------------*/
void
WSL_Flush(struct worker *w, int overflow)
WSL_Flush(struct worker *wrk, int overflow)
{
uint32_t *p;
unsigned l;
l = pdiff(w->wlb, w->wlp);
l = pdiff(wrk->wlb, wrk->wlp);
if (l == 0)
return;
assert(l >= 8);
p = vsl_get(l - 8, w->wlr, overflow);
p = vsl_get(l - 8, wrk->wlr, overflow);
memcpy(p + 1, w->wlb + 1, l - 4);
memcpy(p + 1, wrk->wlb + 1, l - 4);
VWMB();
p[0] = w->wlb[0];
w->wlp = w->wlb;
w->wlr = 0;
p[0] = wrk->wlb[0];
wrk->wlp = wrk->wlb;
wrk->wlr = 0;
}
/*--------------------------------------------------------------------*/
void
WSLR(struct worker *w, enum VSL_tag_e tag, int id, txt t)
WSLR(struct worker *wrk, enum VSL_tag_e tag, int id, txt t)
{
unsigned l, mlen;
......@@ -217,25 +217,25 @@ WSLR(struct worker *w, enum VSL_tag_e tag, int id, txt t)
t.e = t.b + l;
}
assert(w->wlp < w->wle);
assert(wrk->wlp < wrk->wle);
/* Wrap if necessary */
if (VSL_END(w->wlp, l) >= w->wle)
WSL_Flush(w, 1);
assert (VSL_END(w->wlp, l) < w->wle);
memcpy(VSL_DATA(w->wlp), t.b, l);
vsl_hdr(tag, w->wlp, l, id);
w->wlp = VSL_END(w->wlp, l);
assert(w->wlp < w->wle);
w->wlr++;
if (VSL_END(wrk->wlp, l) >= wrk->wle)
WSL_Flush(wrk, 1);
assert (VSL_END(wrk->wlp, l) < wrk->wle);
memcpy(VSL_DATA(wrk->wlp), t.b, l);
vsl_hdr(tag, wrk->wlp, l, id);
wrk->wlp = VSL_END(wrk->wlp, l);
assert(wrk->wlp < wrk->wle);
wrk->wlr++;
if (cache_param->diag_bitmap & 0x10000)
WSL_Flush(w, 0);
WSL_Flush(wrk, 0);
}
/*--------------------------------------------------------------------*/
static void
wsl(struct worker *w, enum VSL_tag_e tag, int id, const char *fmt, va_list ap)
wsl(struct worker *wrk, enum VSL_tag_e tag, int id, const char *fmt, va_list ap)
{
char *p;
unsigned n, mlen;
......@@ -247,38 +247,38 @@ wsl(struct worker *w, enum VSL_tag_e tag, int id, const char *fmt, va_list ap)
if (strchr(fmt, '%') == NULL) {
t.b = TRUST_ME(fmt);
t.e = strchr(t.b, '\0');
WSLR(w, tag, id, t);
WSLR(wrk, tag, id, t);
} else {
assert(w->wlp < w->wle);
assert(wrk->wlp < wrk->wle);
/* Wrap if we cannot fit a full size record */
if (VSL_END(w->wlp, mlen) >= w->wle)
WSL_Flush(w, 1);
if (VSL_END(wrk->wlp, mlen) >= wrk->wle)
WSL_Flush(wrk, 1);
p = VSL_DATA(w->wlp);
p = VSL_DATA(wrk->wlp);
n = vsnprintf(p, mlen, fmt, ap);
if (n > mlen)
n = mlen; /* we truncate long fields */
vsl_hdr(tag, w->wlp, n, id);
w->wlp = VSL_END(w->wlp, n);
assert(w->wlp < w->wle);
w->wlr++;
vsl_hdr(tag, wrk->wlp, n, id);
wrk->wlp = VSL_END(wrk->wlp, n);
assert(wrk->wlp < wrk->wle);
wrk->wlr++;
}
if (cache_param->diag_bitmap & 0x10000)
WSL_Flush(w, 0);
WSL_Flush(wrk, 0);
}
/*--------------------------------------------------------------------*/
void
WSL(struct worker *w, enum VSL_tag_e tag, int id, const char *fmt, ...)
WSL(struct worker *wrk, enum VSL_tag_e tag, int id, const char *fmt, ...)
{
va_list ap;
CHECK_OBJ_NOTNULL(w, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
AN(fmt);
va_start(ap, fmt);
wsl(w, tag, id, fmt, ap);
wsl(wrk, tag, id, fmt, ap);
va_end(ap);
}
......@@ -286,16 +286,16 @@ WSL(struct worker *w, enum VSL_tag_e tag, int id, const char *fmt, ...)
/*--------------------------------------------------------------------*/
void
WSLB(struct worker *w, enum VSL_tag_e tag, const char *fmt, ...)
WSLB(struct worker *wrk, enum VSL_tag_e tag, const char *fmt, ...)
{
va_list ap;
CHECK_OBJ_NOTNULL(w, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(w->busyobj, BUSYOBJ_MAGIC);
CHECK_OBJ_NOTNULL(w->busyobj->vbc, VBC_MAGIC);
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(wrk->busyobj, BUSYOBJ_MAGIC);
CHECK_OBJ_NOTNULL(wrk->busyobj->vbc, VBC_MAGIC);
AN(fmt);
va_start(ap, fmt);
wsl(w, tag, w->busyobj->vbc->vsl_id, fmt, ap);
wsl(wrk, tag, wrk->busyobj->vbc->vsl_id, fmt, ap);
va_end(ap);
}
......
bin/varnishd/cache/cache_wrk.c
View file @ 41608b69
......@@ -94,7 +94,7 @@ static void *
wrk_bgthread(void *arg)
{
struct bgthread *bt;
struct worker ww;
struct worker wrk;
struct sess *sp;
uint32_t logbuf[1024]; /* XXX: size ? */
......@@ -102,11 +102,11 @@ wrk_bgthread(void *arg)
THR_SetName(bt->name);
sp = SES_Alloc();
XXXAN(sp);
memset(&ww, 0, sizeof ww);
sp->wrk = &ww;
ww.magic = WORKER_MAGIC;
ww.wlp = ww.wlb = logbuf;
ww.wle = logbuf + (sizeof logbuf) / 4;
memset(&wrk, 0, sizeof wrk);
sp->wrk = &wrk;
wrk.magic = WORKER_MAGIC;
wrk.wlp = wrk.wlb = logbuf;
wrk.wle = logbuf + (sizeof logbuf) / 4;
(void)bt->func(sp, bt->priv);
......
bin/varnishd/hash/hash_critbit.c
View file @ 41608b69
......@@ -348,11 +348,11 @@ static void *
hcb_cleaner(void *priv)
{
struct hcb_y *y, *y2;
struct worker ww;
struct worker wrk;
struct objhead *oh, *oh2;
memset(&ww, 0, sizeof ww);
ww.magic = WORKER_MAGIC;
memset(&wrk, 0, sizeof wrk);
wrk.magic = WORKER_MAGIC;
THR_SetName("hcb_cleaner");
(void)priv;
......@@ -363,13 +363,13 @@ hcb_cleaner(void *priv)
}
VTAILQ_FOREACH_SAFE(oh, &dead_h, hoh_list, oh2) {
VTAILQ_REMOVE(&dead_h, oh, hoh_list);
HSH_DeleteObjHead(&ww, oh);
HSH_DeleteObjHead(&wrk, oh);
}
Lck_Lock(&hcb_mtx);
VSTAILQ_CONCAT(&dead_y, &cool_y);
VTAILQ_CONCAT(&dead_h, &cool_h, hoh_list);
Lck_Unlock(&hcb_mtx);
WRK_SumStat(&ww);
WRK_SumStat(&wrk);
VTIM_sleep(cache_param->critbit_cooloff);
}
NEEDLESS_RETURN(NULL);
......@@ -386,6 +386,7 @@ hcb_start(void)
(void)oh;
CLI_AddFuncs(hcb_cmds);
Lck_New(&hcb_mtx, lck_hcb);
/* XXX: use WRK_BgThread */
AZ(pthread_create(&tp, NULL, hcb_cleaner, NULL));
memset(&hcb_root, 0, sizeof hcb_root);
hcb_build_bittbl();
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment