Use INIT_OBJ()

bin/varnishd/cache/cache_backend.c

@@ -362,8 +362,7 @@ vbe_dir_getfd(const struct director *d, struct busyobj *bo)
 	if (bo->htc == NULL)
 		bo->htc = WS_Alloc(bo->ws, sizeof *bo->htc);
 	AN(bo->htc);
-	memset(bo->htc, 0, sizeof *bo->htc);
-	bo->htc->magic = HTTP_CONN_MAGIC;
+	INIT_OBJ(bo->htc, HTTP_CONN_MAGIC);
 	bo->htc->vbc = vc;
 	FIND_TMO(first_byte_timeout, vc->first_byte_timeout, bo, vs->vrt);
 	FIND_TMO(between_bytes_timeout, vc->between_bytes_timeout, bo, vs->vrt);

bin/varnishd/cache/cache_deliver_proc.c

@@ -60,8 +60,7 @@ VDP_push(struct req *req, vdp_bytes *func, void *priv)
 
 	vdp = WS_Alloc(req->ws, sizeof *vdp);
 	AN(vdp);
-	memset(vdp, 0, sizeof *vdp);
-	vdp->magic = VDP_ENTRY_MAGIC;
+	INIT_OBJ(vdp, VDP_ENTRY_MAGIC);
 	vdp->func = func;
 	vdp->priv = priv;
 	VTAILQ_INSERT_HEAD(&req->vdp, vdp, list);

bin/varnishd/cache/cache_esi_parse.c

@@ -1048,8 +1048,7 @@ VEP_Init(struct vfp_ctx *vc, const struct http *req, vep_callback_t *cb,
 	vep = WS_Alloc(vc->http->ws, sizeof *vep);
 	AN(vep);
 
-	memset(vep, 0, sizeof *vep);
-	vep->magic = VEP_MAGIC;
+	INIT_OBJ(vep, VEP_MAGIC);
 	vep->url = req->hd[HTTP_HDR_URL].b;
 	vep->vc = vc;
 	vep->vsb = VSB_new_auto();

bin/varnishd/cache/cache_fetch_proc.c

@@ -106,8 +106,8 @@ VFP_GetStorage(struct vfp_ctx *vc, ssize_t *sz, uint8_t **ptr)
 void
 VFP_Setup(struct vfp_ctx *vc)
 {
-	memset(vc, 0, sizeof *vc);
-	vc->magic = VFP_CTX_MAGIC;
+
+	INIT_OBJ(vc, VFP_CTX_MAGIC);
 	VTAILQ_INIT(&vc->vfp);
 }
 
@@ -204,7 +204,7 @@ VFP_Push(struct vfp_ctx *vc, const struct vfp *vfp, int top)
 	CHECK_OBJ_NOTNULL(vc->http, HTTP_MAGIC);
 	vfe = WS_Alloc(vc->http->ws, sizeof *vfe);
 	AN(vfe);
-	vfe->magic = VFP_ENTRY_MAGIC;
+	INIT_OBJ(vfe, VFP_ENTRY_MAGIC);
 	vfe->vfp = vfp;
 	vfe->closed = VFP_OK;
 	if (top)

bin/varnishd/cache/cache_pool.c

@@ -212,8 +212,7 @@ pool_accept(struct worker *wrk, void *arg)
 		VTIM_sleep(.1);
 
 	while (1) {
-		memset(wa, 0, sizeof *wa);
-		wa->magic = WRK_ACCEPT_MAGIC;
+		INIT_OBJ(wa, WRK_ACCEPT_MAGIC);
 
 		if (ps->lsock->sock < 0) {
 			/* Socket Shutdown */

bin/varnishd/cache/cache_vcl.c

@@ -212,8 +212,7 @@ VCL_Load(const char *fn, const char *name, struct cli *cli)
 		return (1);
 	}
 
-	memset(&ctx, 0, sizeof ctx);
-	ctx.magic = VRT_CTX_MAGIC;
+	INIT_OBJ(&ctx, VRT_CTX_MAGIC);
 	ctx.method = VCL_MET_INIT;
 	ctx.handling = &hand;
 	ctx.cli = cli;
@@ -259,8 +258,7 @@ VCL_Nuke(struct vcls *vcl)
 	struct vrt_ctx ctx;
 	unsigned hand = 0;
 
-	memset(&ctx, 0, sizeof ctx);
-	ctx.magic = VRT_CTX_MAGIC;
+	INIT_OBJ(&ctx, VRT_CTX_MAGIC);
 	ASSERT_CLI();
 	assert(vcl != vcl_active);
 	assert(vcl->conf->discard);
@@ -436,8 +434,7 @@ vcl_call_method(struct worker *wrk, struct req *req, struct busyobj *bo,
 	struct vrt_ctx ctx;
 
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
-	memset(&ctx, 0, sizeof ctx);
-	ctx.magic = VRT_CTX_MAGIC;
+	INIT_OBJ(&ctx, VRT_CTX_MAGIC);
 	if (req != NULL) {
 		CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 		CHECK_OBJ_NOTNULL(req->sp, SESS_MAGIC);

bin/varnishd/cache/cache_wrk.c

@@ -59,8 +59,7 @@ wrk_bgthread(void *arg)
 
 	CAST_OBJ_NOTNULL(bt, arg, BGTHREAD_MAGIC);
 	THR_SetName(bt->name);
-	memset(&wrk, 0, sizeof wrk);
-	wrk.magic = WORKER_MAGIC;
+	INIT_OBJ(&wrk, WORKER_MAGIC);
 
 	(void)bt->func(&wrk, bt->priv);
 
@@ -98,8 +97,7 @@ WRK_Thread(struct pool *qp, size_t stacksize, unsigned thread_workspace)
 
 	THR_SetName("cache-worker");
 	w = &ww;
-	memset(w, 0, sizeof *w);
-	w->magic = WORKER_MAGIC;
+	INIT_OBJ(w, WORKER_MAGIC);
 	w->lastused = NAN;
 	AZ(pthread_cond_init(&w->cond, NULL));
 

bin/varnishd/cache/cache_wrw.c

@@ -74,8 +74,7 @@ WRW_Reserve(struct worker *wrk, int *fd, struct vsl_log *vsl, double t0)
 	AZ(wrk->wrw);
 	wrw = WS_Alloc(wrk->aws, sizeof *wrw);
 	AN(wrw);
-	memset(wrw, 0, sizeof *wrw);
-	wrw->magic = WRW_MAGIC;
+	INIT_OBJ(wrw, WRW_MAGIC);
 	u = WS_Reserve(wrk->aws, 0);
 	u = PRNDDN(u);
 	u /= sizeof(struct iovec);

bin/varnishd/cache/cache_ws.c

@@ -72,8 +72,7 @@ WS_Init(struct ws *ws, const char *id, void *space, unsigned len)
 	DSL(DBG_WORKSPACE, 0,
 	    "WS_Init(%p, \"%s\", %p, %u)", ws, id, space, len);
 	assert(space != NULL);
-	memset(ws, 0, sizeof *ws);
-	ws->magic = WS_MAGIC;
+	INIT_OBJ(ws, WS_MAGIC);
 	ws->s = space;
 	assert(PAOK(space));
 	len = PRNDDN(len - 1);

bin/varnishd/http1/cache_http1_deliver.c

@@ -181,8 +181,7 @@ v1d_dorange(struct req *req, struct busyobj *bo, const char *r)
 
 	v1rp = WS_Alloc(req->ws, sizeof *v1rp);
 	XXXAN(v1rp);
-	memset(v1rp, 0, sizeof *v1rp);
-	v1rp->magic = V1RP_MAGIC;
+	INIT_OBJ(v1rp, V1RP_MAGIC);
 	v1rp->range_off = 0;
 	v1rp->range_low = low;
 	v1rp->range_high = high + 1;

bin/varnishd/mgt/mgt_main.c

@@ -450,8 +450,7 @@ main(int argc, char * const *argv)
 	 */
 	SHA256_Test();
 
-	memset(cli, 0, sizeof cli);
-	cli[0].magic = CLI_MAGIC;
+	INIT_OBJ(cli, CLI_MAGIC);
 	cli[0].sb = VSB_new_auto();
 	XXXAN(cli[0].sb);
 	cli[0].result = CLIS_OK;

bin/varnishd/mgt/mgt_vcc.c

@@ -256,8 +256,7 @@ mgt_run_cc(const char *vcl, struct vsb *sb, int C_flag, unsigned *status)
 
 
 	/* Run the VCC compiler in a sub-process */
-	memset(&vp, 0, sizeof vp);
-	vp.magic = VCC_PRIV_MAGIC;
+	INIT_OBJ(&vp, VCC_PRIV_MAGIC);
 	vp.sf = sf;
 	vp.vcl = vcl;
 	subs = VSUB_run(sb, run_vcc, &vp, "VCC-compiler", -1);

bin/varnishd/storage/stevedore.c

@@ -200,8 +200,7 @@ STV_MkObject(struct stevedore *stv, struct objcore *oc, void *ptr)
 	assert(PAOK(ptr));
 
 	o = ptr;
-	memset(o, 0, sizeof *o);
-	o->magic = OBJECT_MAGIC;
+	INIT_OBJ(o, OBJECT_MAGIC);
 
 	VTAILQ_INIT(&o->list);
 

bin/varnishd/storage/storage_file.c

@@ -342,9 +342,8 @@ new_smf(struct smf_sc *sc, unsigned char *ptr, off_t off, size_t len)
 	struct smf *sp, *sp2;
 
 	AZ(len % sc->pagesize);
-	sp = calloc(sizeof *sp, 1);
+	ALLOC_OBJ(sp, SMF_MAGIC);
 	XXXAN(sp);
-	sp->magic = SMF_MAGIC;
 	sp->s.magic = STORAGE_MAGIC;
 	sc->stats->g_smf++;
 

bin/varnishd/storage/storage_persistent.c

@@ -489,8 +489,7 @@ smp_allocx(struct stevedore *st, size_t min_size, size_t max_size,
 	assert(max_size >= min_size);
 
 	/* Fill the storage structure */
-	memset(ss, 0, sizeof *ss);
-	ss->magic = STORAGE_MAGIC;
+	INIT_OBJ(ss, STORAGE_MAGIC);
 	ss->ptr = PRNUP(sc, ss + 1);
 	ss->space = max_size;
 	ss->priv = sc;

bin/varnishd/storage/storage_persistent_silo.c

@@ -188,8 +188,7 @@ smp_new_seg(struct smp_sc *sc)
 
 	/* XXX: find where it goes in silo */
 
-	memset(&tmpsg, 0, sizeof tmpsg);
-	tmpsg.magic = SMP_SEG_MAGIC;
+	INIT_OBJ(&tmpsg, SMP_SEG_MAGIC);
 	tmpsg.sc = sc;
 	tmpsg.p.offset = sc->free_offset;
 	/* XXX: align */