From tfheen at varnish-cache.org  Mon Jun  4 06:40:17 2012
From: tfheen at varnish-cache.org (Tollef Fog Heen)
Date: Mon, 04 Jun 2012 08:40:17 +0200
Subject: [3.0] 0f72c5a Release 3.0.3 rc 1
Message-ID: <E1SbQxd-0006VG-5t@project.varnish-software.com>

commit 0f72c5aefcaa0d918f69f6b4d254bb4e59269632
Author: Tollef Fog Heen <tfheen at varnish-software.com>
Date:   Fri May 25 09:21:44 2012 +0200

    Release 3.0.3 rc 1

diff --git a/configure.ac b/configure.ac
index 0fbb620..67c5c41 100644
--- a/configure.ac
+++ b/configure.ac
@@ -2,7 +2,7 @@ AC_PREREQ(2.59)
 AC_COPYRIGHT([Copyright (c) 2006 Verdens Gang AS
 Copyright (c) 2006-2011 Varnish Software AS])
 AC_REVISION([$Id$])
-AC_INIT([Varnish], [3.0.2], [varnish-dev at varnish-cache.org])
+AC_INIT([Varnish], [3.0.3-rc1], [varnish-dev at varnish-cache.org])
 AC_CONFIG_SRCDIR(include/varnishapi.h)
 AM_CONFIG_HEADER(config.h)
 
diff --git a/redhat/varnish.spec b/redhat/varnish.spec
index 144ace4..bc1cc85 100644
--- a/redhat/varnish.spec
+++ b/redhat/varnish.spec
@@ -1,8 +1,8 @@
-#% define v_rc ""
+%define v_rc rc1
 Summary: High-performance HTTP accelerator
 Name: varnish
-Version: 3.0.2
-Release: 1%{?dist}
+Version: 3.0.3
+Release: 0.rc1%{?dist}
 License: BSD
 Group: System Environment/Daemons
 URL: http://www.varnish-cache.org/



From tfheen at varnish-cache.org  Mon Jun  4 07:00:14 2012
From: tfheen at varnish-cache.org (Tollef Fog Heen)
Date: Mon, 04 Jun 2012 09:00:14 +0200
Subject: [master] 6945ed5 Add missing "}".
Message-ID: <E1SbRGw-0003tO-12@project.varnish-software.com>

commit 6945ed579e532ab8274979715c436c371a8b8e32
Author: Thomas Tourlourat <thomas at tourlourat.com>
Date:   Fri Jun 1 11:53:16 2012 +0300

    Add missing "}".

diff --git a/doc/sphinx/tutorial/cookies.rst b/doc/sphinx/tutorial/cookies.rst
index 88e9d07..deda74c 100644
--- a/doc/sphinx/tutorial/cookies.rst
+++ b/doc/sphinx/tutorial/cookies.rst
@@ -62,6 +62,7 @@ cookies named COOKIE1 and COOKIE2 and you can marvel at it::
       if (req.http.Cookie == "") {
           remove req.http.Cookie;
       }
+    }
   }
 
 A somewhat simpler example that can accomplish almost the same can be



From tfheen at varnish-cache.org  Mon Jun  4 07:00:14 2012
From: tfheen at varnish-cache.org (Tollef Fog Heen)
Date: Mon, 04 Jun 2012 09:00:14 +0200
Subject: [master] ecb8b09 Wrong description for regsuball.
Message-ID: <E1SbRGw-0003tT-2Z@project.varnish-software.com>

commit ecb8b09793b8ae6ca1c0ef6b272a9da581248904
Author: Thomas Tourlourat <thomas at tourlourat.com>
Date:   Fri Jun 1 11:55:11 2012 +0300

    Wrong description for regsuball.

diff --git a/doc/sphinx/reference/vcl.rst b/doc/sphinx/reference/vcl.rst
index ed970e2..736c7c0 100644
--- a/doc/sphinx/reference/vcl.rst
+++ b/doc/sphinx/reference/vcl.rst
@@ -426,7 +426,7 @@ regsub(str, regex, sub)
   matched string.
 
 regsuball(str, regex, sub)
-  As regsuball() but this replaces all occurrences.
+  As regsub() but this replaces all occurrences.
 
 ban(ban expression)
 



From phk at varnish-cache.org  Mon Jun  4 09:20:20 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Mon, 04 Jun 2012 11:20:20 +0200
Subject: [master] 344a709 std.fileread() should not blindly return whatever
	file it returned last without checking if the filename changed.
Message-ID: <E1SbTSW-0002pZ-Tw@project.varnish-software.com>

commit 344a709ccf9559f3d8e5d7a0a9a35c6e94705f0f
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Mon Jun 4 09:18:31 2012 +0000

    std.fileread() should not blindly return whatever file it returned
    last without checking if the filename changed.
    
    Fixes		#1145
    Testcase by:	tobixen

diff --git a/bin/varnishtest/tests/r01145.vtc b/bin/varnishtest/tests/r01145.vtc
new file mode 100644
index 0000000..2a2502e
--- /dev/null
+++ b/bin/varnishtest/tests/r01145.vtc
@@ -0,0 +1,43 @@
+varnishtest "Test fileread for std VMOD"
+
+shell {
+	printf "File One" > "${tmpdir}/one"
+	printf "File Two" > "${tmpdir}/two"
+	printf "File Three" > "${tmpdir}/three"
+}
+
+server s1 {
+	loop 3 {
+		rxreq
+		txresp
+	}
+} -start
+
+
+varnish v1 -vcl+backend {
+	import std from "${topbuild}/lib/libvmod_std/.libs/libvmod_std.so" ;
+
+	sub vcl_deliver {
+            set resp.http.foo = std.fileread("${tmpdir}" + req.url);
+	}
+} -start
+
+
+client c1 {
+	txreq -url "/one"
+	rxresp
+	expect resp.http.foo == "File One"
+
+	txreq -url "/two"
+	rxresp
+	expect resp.http.foo == "File Two"
+
+	txreq -url "/three"
+	rxresp
+	expect resp.http.foo == "File Three"
+} -run
+
+client c1 -run
+client c1 -run
+
+
diff --git a/lib/libvmod_std/vmod_std_fileread.c b/lib/libvmod_std/vmod_std_fileread.c
index 154d8ca..7012b66 100644
--- a/lib/libvmod_std/vmod_std_fileread.c
+++ b/lib/libvmod_std/vmod_std_fileread.c
@@ -85,17 +85,21 @@ free_frfile(void *ptr)
 const char *
 vmod_fileread(struct sess *sp, struct vmod_priv *priv, const char *file_name)
 {
-	struct frfile *frf;
+	struct frfile *frf = NULL;
 	char *s;
 
 	(void)sp;
 	AN(priv);
+
 	if (priv->priv != NULL) {
 		CAST_OBJ_NOTNULL(frf, priv->priv, CACHED_FILE_MAGIC);
-		return (frf->contents);
+		if (!strcmp(file_name, frf->file_name))
+			return (frf->contents);
 	}
 
 	AZ(pthread_mutex_lock(&frmtx));
+	if (frf != NULL)
+		frf->refcount--;
 	VTAILQ_FOREACH(frf, &frlist, list) {
 		if (!strcmp(file_name, frf->file_name)) {
 			frf->refcount++;



From phk at varnish-cache.org  Mon Jun  4 09:33:24 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Mon, 04 Jun 2012 11:33:24 +0200
Subject: [master] 5011af2 Add some asserts to narrow #1147 and #1148 down
Message-ID: <E1SbTfA-0003Sx-RE@project.varnish-software.com>

commit 5011af25e862e25cdd86c046b7a0c9ed77df115c
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Mon Jun 4 09:33:06 2012 +0000

    Add some asserts to narrow #1147 and #1148 down

diff --git a/bin/varnishd/cache/cache_center.c b/bin/varnishd/cache/cache_center.c
index 21f5939..5ec3752 100644
--- a/bin/varnishd/cache/cache_center.c
+++ b/bin/varnishd/cache/cache_center.c
@@ -116,6 +116,7 @@ cnt_wait(struct sess *sp, struct worker *wrk, struct req *req)
 		SES_GetReq(sp);
 		req = sp->req;
 		CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+		assert(req->sp == sp);
 		HTC_Init(req->htc, req->ws, sp->fd, sp->req->vsl,
 		    cache_param->http_req_size,
 		    cache_param->http_req_hdr_len);
@@ -928,6 +929,7 @@ DOT first -> wait [style=bold,color=green]
 static int
 cnt_first(struct sess *sp, struct worker *wrk)
 {
+	struct req *req;
 	char laddr[ADDR_BUFSIZE];
 	char lport[PORT_BUFSIZE];
 
@@ -936,8 +938,10 @@ cnt_first(struct sess *sp, struct worker *wrk)
 
 	/* Allocate a request already now, so we can VSL to it */
 	SES_GetReq(sp);
-	CHECK_OBJ_NOTNULL(sp->req, REQ_MAGIC);
-	HTC_Init(sp->req->htc, sp->req->ws, sp->fd, sp->req->vsl,
+	req = sp->req;
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	assert(req->sp == sp);
+	HTC_Init(req->htc, req->ws, sp->fd, req->vsl,
 	    cache_param->http_req_size,
 	    cache_param->http_req_hdr_len);
 
@@ -949,11 +953,11 @@ cnt_first(struct sess *sp, struct worker *wrk)
 		VTCP_name(&sp->mysockaddr, sp->mysockaddrlen,
 		    laddr, sizeof laddr, lport, sizeof lport);
 		/* XXX: have no req yet */
-		VSLb(sp->req->vsl, SLT_SessionOpen, "%s %s %s %s",
+		VSLb(req->vsl, SLT_SessionOpen, "%s %s %s %s",
 		    sp->addr, sp->port, laddr, lport);
 	} else {
 		/* XXX: have no req yet */
-		VSLb(sp->req->vsl, SLT_SessionOpen, "%s %s %s",
+		VSLb(req->vsl, SLT_SessionOpen, "%s %s %s",
 		    sp->addr, sp->port, sp->mylsock->name);
 	}
 
diff --git a/bin/varnishd/cache/cache_vcl.c b/bin/varnishd/cache/cache_vcl.c
index 43ef3cd..9cdf427 100644
--- a/bin/varnishd/cache/cache_vcl.c
+++ b/bin/varnishd/cache/cache_vcl.c
@@ -338,6 +338,8 @@ void									\
 VCL_##func##_method(struct req *req)					\
 {									\
 									\
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);				\
+	CHECK_OBJ_NOTNULL(req->sp, SESS_MAGIC);				\
 	req->handling = 0;						\
 	req->cur_method = VCL_MET_ ## upper;				\
 	VSLb(req->vsl, SLT_VCL_call, "%s", #func);			\



From phk at varnish-cache.org  Mon Jun  4 11:38:57 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Mon, 04 Jun 2012 13:38:57 +0200
Subject: [master] a9e5d35 Increase the id field in VSM to 128 bytes to make
	space for 64 backend VCL name + IPv4, IPv6 and portnumber.
Message-ID: <E1SbVcf-0003bR-Hl@project.varnish-software.com>

commit a9e5d3503f8fea332c01cdf6576a980947b39b07
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Mon Jun 4 11:38:01 2012 +0000

    Increase the id field in VSM to 128 bytes to make space for
    64 backend VCL name + IPv4, IPv6 and portnumber.
    
    Fixes	#1144

diff --git a/bin/varnishtest/tests/r01144.vtc b/bin/varnishtest/tests/r01144.vtc
new file mode 100644
index 0000000..b08060d
--- /dev/null
+++ b/bin/varnishtest/tests/r01144.vtc
@@ -0,0 +1,38 @@
+varnishtest "very long backend names"
+
+server s1 {
+	rxreq
+	txresp
+} -start
+
+varnish v1 -vcl+backend {
+	backend fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210
+	{
+		.host = "127.0.0.1";
+		.port = "54321";
+	}
+	sub vcl_recv {
+		if (req.url == "never") {
+			set req.backend = fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210;
+		}
+	}
+} -start
+
+client c1 {
+	txreq
+	rxresp
+	expect resp.status == 200
+} -run
+
+varnish v1 -badvcl {
+	backend 0fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210
+	{
+		.host = "127.0.0.1";
+		.port = "54321";
+	}
+	sub vcl_recv {
+		if (req.url == "never") {
+			set req.backend = fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210;
+		}
+	}
+}
diff --git a/include/vapi/vsm_int.h b/include/vapi/vsm_int.h
index 4272aef..7e44604 100644
--- a/include/vapi/vsm_int.h
+++ b/include/vapi/vsm_int.h
@@ -104,7 +104,7 @@ struct VSM_chunk {
 	ssize_t			next;		/* Offset in shmem */
 	char			class[8];
 	char			type[8];
-	char			ident[64];
+	char			ident[128];
 };
 
 struct VSM_head {
diff --git a/lib/libvcl/vcc_backend.c b/lib/libvcl/vcc_backend.c
index fb160e7..76ef874 100644
--- a/lib/libvcl/vcc_backend.c
+++ b/lib/libvcl/vcc_backend.c
@@ -706,6 +706,13 @@ vcc_ParseDirector(struct vcc *tl)
 
 	vcc_ExpectCid(tl);		/* ID: name */
 	ERRCHK(tl);
+	if (tl->t->e - tl->t->b > 64) {
+		VSB_printf(tl->sb,
+		    "Name of %.*s too long (max 64, is %zd):\n",
+		    PF(t_first), (tl->t->e - tl->t->b));
+		vcc_ErrWhere(tl, tl->t);
+		return;
+	}
 	tl->t_dir = tl->t;
 	vcc_NextToken(tl);
 



From tfheen at varnish-cache.org  Mon Jun  4 12:09:09 2012
From: tfheen at varnish-cache.org (Tollef Fog Heen)
Date: Mon, 04 Jun 2012 14:09:09 +0200
Subject: [master] e75cd2e Typo
Message-ID: <E1SbW5t-0005Ve-AH@project.varnish-software.com>

commit e75cd2e61ac9383a89a2366074f58587d8c7f7e5
Author: Tollef Fog Heen <tfheen at varnish-software.com>
Date:   Mon Jun 4 14:08:38 2012 +0200

    Typo

diff --git a/bin/varnishd/mgt/mgt_param.c b/bin/varnishd/mgt/mgt_param.c
index c8f62bb..c7834a7 100644
--- a/bin/varnishd/mgt/mgt_param.c
+++ b/bin/varnishd/mgt/mgt_param.c
@@ -765,7 +765,7 @@ static const struct parspec input_parspec[] = {
 		"Maximum number of HTTP headers we will deal with in "
 		"client request or backend reponses.  "
 		"Note that the first line occupies five header fields.\n"
-		"This paramter does not influence storage consumption, "
+		"This parameter does not influence storage consumption, "
 		"objects allocate exact space for the headers they store.\n",
 		0,
 		"64", "header lines" },



From tfheen at varnish-cache.org  Wed Jun  6 11:09:19 2012
From: tfheen at varnish-cache.org (Tollef Fog Heen)
Date: Wed, 06 Jun 2012 13:09:19 +0200
Subject: [3.0] 10e4f97 Add a set of VFP method functions which can do various
	sanity asserts for us in a single place.
Message-ID: <E1ScE75-0004bN-Hp@project.varnish-software.com>

commit 10e4f9727fe0c04a895d3e1dc6c8b56605d53ac2
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Wed Jun 6 10:49:38 2012 +0200

    Add a set of VFP method functions which can do various sanity asserts for us in a single place.
    
    Conflicts:
    
    	bin/varnishd/cache/cache_esi_fetch.c
    	bin/varnishd/cache_fetch.c
    	bin/varnishd/cache_gzip.c

diff --git a/bin/varnishd/cache_esi_fetch.c b/bin/varnishd/cache_esi_fetch.c
index 7e636c8..ab86ac8 100644
--- a/bin/varnishd/cache_esi_fetch.c
+++ b/bin/varnishd/cache_esi_fetch.c
@@ -335,7 +335,6 @@ vfp_esi_bytes(struct sess *sp, struct http_conn *htc, ssize_t bytes)
 	int i;
 
 	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	AZ(sp->wrk->fetch_failed);
 	AN(sp->wrk->vep);
 	assert(sp->wrk->htc == htc);
 	if (sp->wrk->is_gzip && sp->wrk->do_gunzip)
diff --git a/bin/varnishd/cache_fetch.c b/bin/varnishd/cache_fetch.c
index cdc2fd8..460cce9 100644
--- a/bin/varnishd/cache_fetch.c
+++ b/bin/varnishd/cache_fetch.c
@@ -77,6 +77,40 @@ FetchError(const struct sess *sp, const char *error)
 }
 
 /*--------------------------------------------------------------------
+ * VFP method functions
+ */
+
+static void
+VFP_Begin(struct sess *sp, size_t estimate)
+{
+	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	AN(sp->wrk->vfp);
+
+	sp->wrk->vfp->begin(sp, estimate);
+}
+
+static int
+VFP_Bytes(struct sess *sp, struct http_conn *htc, ssize_t sz)
+{
+	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	AN(sp->wrk->vfp);
+	CHECK_OBJ_NOTNULL(htc, HTTP_CONN_MAGIC);
+	AZ(sp->wrk->fetch_failed);
+
+	return (sp->wrk->vfp->bytes(sp, htc, sz));
+}
+
+static int
+VFP_End(struct sess *sp)
+{
+	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	AN(sp->wrk->vfp);
+
+	return (sp->wrk->vfp->end(sp));
+}
+
+
+/*--------------------------------------------------------------------
  * VFP_NOP
  *
  * This fetch-processor does nothing but store the object.
@@ -237,7 +271,7 @@ fetch_straight(struct sess *sp, struct http_conn *htc, ssize_t cl)
 	} else if (cl == 0)
 		return (0);
 
-	i = sp->wrk->vfp->bytes(sp, htc, cl);
+	i = VFP_Bytes(sp, htc, cl);
 	if (i <= 0) {
 		return (FetchError(sp, "straight insufficient bytes"));
 	}
@@ -296,7 +330,7 @@ fetch_chunked(struct sess *sp, struct http_conn *htc)
 		if (cl < 0)
 			return (FetchError(sp,"chunked header number syntax"));
 
-		if (cl > 0 && sp->wrk->vfp->bytes(sp, htc, cl) <= 0)
+		if (cl > 0 && VFP_Bytes(sp, htc, cl) <= 0)
 			return (-1);
 
 		i = HTC_Read(sp->wrk, htc, buf, 1);
@@ -318,7 +352,7 @@ fetch_eof(struct sess *sp, struct http_conn *htc)
 	int i;
 
 	assert(sp->wrk->body_status == BS_EOF);
-	i = sp->wrk->vfp->bytes(sp, htc, SSIZE_MAX);
+	i = VFP_Bytes(sp, htc, SSIZE_MAX);
 	if (i < 0) 
 		return (-1);
 	return (0);
@@ -521,24 +555,24 @@ FetchBody(struct sess *sp)
 		break;
 	case BS_LENGTH:
 		cl = fetch_number(sp->wrk->h_content_length, 10);
-		w->vfp->begin(sp, cl > 0 ? cl : 0);
+		VFP_Begin(sp, cl > 0 ? cl : 0);
 		cls = fetch_straight(sp, w->htc, cl);
 		mklen = 1;
-		if (w->vfp->end(sp))
+		if (VFP_End(sp))
 			cls = -1;
 		break;
 	case BS_CHUNKED:
-		w->vfp->begin(sp, cl);
+		VFP_Begin(sp, cl);
 		cls = fetch_chunked(sp, w->htc);
 		mklen = 1;
-		if (w->vfp->end(sp))
+		if (VFP_End(sp))
 			cls = -1;
 		break;
 	case BS_EOF:
-		w->vfp->begin(sp, cl);
+		VFP_Begin(sp, cl);
 		cls = fetch_eof(sp, w->htc);
 		mklen = 1;
-		if (w->vfp->end(sp))
+		if (VFP_End(sp))
 			cls = -1;
 		break;
 	case BS_ERROR:
diff --git a/bin/varnishd/cache_gzip.c b/bin/varnishd/cache_gzip.c
index 3087a6b..07bdcac 100644
--- a/bin/varnishd/cache_gzip.c
+++ b/bin/varnishd/cache_gzip.c
@@ -465,7 +465,6 @@ vfp_gunzip_bytes(struct sess *sp, struct http_conn *htc, ssize_t bytes)
 	size_t dl;
 	const void *dp;
 
-	AZ(sp->wrk->fetch_failed);
 	vg = sp->wrk->vgz_rx;
 	CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
 	AZ(vg->vz.avail_in);
@@ -543,7 +542,6 @@ vfp_gzip_bytes(struct sess *sp, struct http_conn *htc, ssize_t bytes)
 	size_t dl;
 	const void *dp;
 
-	AZ(sp->wrk->fetch_failed);
 	vg = sp->wrk->vgz_rx;
 	CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
 	AZ(vg->vz.avail_in);
@@ -632,7 +630,6 @@ vfp_testgzip_bytes(struct sess *sp, struct http_conn *htc, ssize_t bytes)
 	const void *dp;
 	struct storage *st;
 
-	AZ(sp->wrk->fetch_failed);
 	vg = sp->wrk->vgz_rx;
 	CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
 	AZ(vg->vz.avail_in);



From tfheen at varnish-cache.org  Wed Jun  6 11:09:19 2012
From: tfheen at varnish-cache.org (Tollef Fog Heen)
Date: Wed, 06 Jun 2012 13:09:19 +0200
Subject: [3.0] 82c4b09 Don't assert if we fail to get storage in VFP_Begin()
Message-ID: <E1ScE75-0004bT-J9@project.varnish-software.com>

commit 82c4b095509e46acdb8a5b24099527a7497084d7
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Wed Jun 6 10:49:39 2012 +0200

    Don't assert if we fail to get storage in VFP_Begin()
    
    Fixes	#1100
    
    Conflicts:
    
    	bin/varnishd/cache_fetch.c
    	bin/varnishd/cache_panic.c

diff --git a/bin/varnishd/cache_fetch.c b/bin/varnishd/cache_fetch.c
index 460cce9..de54da3 100644
--- a/bin/varnishd/cache_fetch.c
+++ b/bin/varnishd/cache_fetch.c
@@ -80,13 +80,16 @@ FetchError(const struct sess *sp, const char *error)
  * VFP method functions
  */
 
-static void
+static int
 VFP_Begin(struct sess *sp, size_t estimate)
 {
 	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 	AN(sp->wrk->vfp);
 
 	sp->wrk->vfp->begin(sp, estimate);
+	if (sp->wrk->fetch_failed)
+		return (-1);
+	return (0);
 }
 
 static int
@@ -150,7 +153,6 @@ vfp_nop_bytes(struct sess *sp, struct http_conn *htc, ssize_t bytes)
 	ssize_t l, w;
 	struct storage *st;
 
-	AZ(sp->wrk->fetch_failed);
 	while (bytes > 0) {
 		st = FetchStorage(sp, 0);
 		if (st == NULL)
@@ -555,22 +557,25 @@ FetchBody(struct sess *sp)
 		break;
 	case BS_LENGTH:
 		cl = fetch_number(sp->wrk->h_content_length, 10);
-		VFP_Begin(sp, cl > 0 ? cl : 0);
-		cls = fetch_straight(sp, w->htc, cl);
+		cls = VFP_Begin(sp, cl > 0 ? cl : 0);
+		if (!cls)
+			cls = fetch_straight(sp, w->htc, cl);
 		mklen = 1;
 		if (VFP_End(sp))
 			cls = -1;
 		break;
 	case BS_CHUNKED:
-		VFP_Begin(sp, cl);
-		cls = fetch_chunked(sp, w->htc);
+		cls = VFP_Begin(sp, cl);
+		if (!cls)
+			cls = fetch_chunked(sp, w->htc);
 		mklen = 1;
 		if (VFP_End(sp))
 			cls = -1;
 		break;
 	case BS_EOF:
-		VFP_Begin(sp, cl);
-		cls = fetch_eof(sp, w->htc);
+		cls = VFP_Begin(sp, cl);
+		if (!cls)
+			cls = fetch_eof(sp, w->htc);
 		mklen = 1;
 		if (VFP_End(sp))
 			cls = -1;



From phk at varnish-cache.org  Tue Jun 12 07:58:51 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Tue, 12 Jun 2012 09:58:51 +0200
Subject: [master] 6094581 Add more asserts to nail #1147
Message-ID: <E1SeM03-0008CC-Ht@project.varnish-software.com>

commit 60945816067b3928a73e8f2257e26ab8289ecb97
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Tue Jun 12 07:58:34 2012 +0000

    Add more asserts to nail #1147

diff --git a/bin/varnishd/cache/cache_center.c b/bin/varnishd/cache/cache_center.c
index 5ec3752..e524421 100644
--- a/bin/varnishd/cache/cache_center.c
+++ b/bin/varnishd/cache/cache_center.c
@@ -268,7 +268,9 @@ cnt_prepresp(struct sess *sp, struct worker *wrk, struct req *req)
 	HTTP_Setup(req->resp, req->ws, req->vsl, HTTP_Resp);
 	RES_BuildHttp(sp);
 
+	assert(req->sp == sp);
 	VCL_deliver_method(req);
+	assert(req->sp == sp);
 	switch (req->handling) {
 	case VCL_RET_DELIVER:
 		break;
@@ -523,7 +525,9 @@ cnt_error(struct sess *sp, struct worker *wrk, struct req *req)
 		http_PutResponse(h, req->err_reason);
 	else
 		http_PutResponse(h, http_StatusMessage(req->err_code));
+	assert(req->sp == sp);
 	VCL_error_method(req);
+	assert(req->sp == sp);
 
 	if (req->handling == VCL_RET_RESTART &&
 	    req->restarts <  cache_param->max_restarts) {
@@ -632,7 +636,9 @@ cnt_fetch(struct sess *sp, struct worker *wrk, struct req *req)
 		AZ(bo->do_esi);
 		AZ(bo->do_pass);
 
+		assert(req->sp == sp);
 		VCL_fetch_method(req);
+		assert(req->sp == sp);
 
 		if (bo->do_pass)
 			req->objcore->flags |= OC_F_PASS;
@@ -1001,7 +1007,9 @@ cnt_hit(struct sess *sp, struct worker *wrk, struct req *req)
 
 	assert(!(req->obj->objcore->flags & OC_F_PASS));
 
+	assert(req->sp == sp);
 	VCL_hit_method(req);
+	assert(req->sp == sp);
 
 	if (req->handling == VCL_RET_DELIVER) {
 		//AZ(req->busyobj->bereq->ws);
@@ -1175,7 +1183,9 @@ cnt_miss(struct sess *sp, struct worker *wrk, struct req *req)
 		http_SetHeader(bo->bereq, "Accept-Encoding: gzip");
 	}
 
+	assert(req->sp == sp);
 	VCL_miss_method(req);
+	assert(req->sp == sp);
 
 	if (req->handling == VCL_RET_FETCH) {
 		CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
@@ -1241,7 +1251,9 @@ cnt_pass(struct sess *sp, struct worker *wrk, struct req *req)
 	HTTP_Setup(bo->bereq, bo->ws, bo->vsl, HTTP_Bereq);
 	http_FilterReq(sp, HTTPH_R_PASS);
 
+	assert(req->sp == sp);
 	VCL_pass_method(req);
+	assert(req->sp == sp);
 
 	if (req->handling == VCL_RET_ERROR) {
 		http_Teardown(bo->bereq);
@@ -1301,7 +1313,9 @@ cnt_pipe(struct sess *sp, struct worker *wrk, struct req *req)
 	HTTP_Setup(bo->bereq, bo->ws, bo->vsl, HTTP_Bereq);
 	http_FilterReq(sp, 0);
 
+	assert(req->sp == sp);
 	VCL_pipe_method(req);
+	assert(req->sp == sp);
 
 	if (req->handling == VCL_RET_ERROR)
 		INCOMPL();
@@ -1399,7 +1413,9 @@ cnt_recv(struct sess *sp, const struct worker *wrk, struct req *req)
 
 	http_CollectHdr(req->http, H_Cache_Control);
 
+	assert(req->sp == sp);
 	VCL_recv_method(req);
+	assert(req->sp == sp);
 	recv_handling = req->handling;
 
 	if (cache_param->http_gzip_support &&
@@ -1415,7 +1431,9 @@ cnt_recv(struct sess *sp, const struct worker *wrk, struct req *req)
 
 	req->sha256ctx = &sha256ctx;	/* so HSH_AddString() can find it */
 	SHA256_Init(req->sha256ctx);
+	assert(req->sp == sp);
 	VCL_hash_method(req);
+	assert(req->sp == sp);
 	assert(req->handling == VCL_RET_HASH);
 	SHA256_Final(req->digest, req->sha256ctx);
 	req->sha256ctx = NULL;
@@ -1616,6 +1634,12 @@ CNT_Session(struct sess *sp)
 		CHECK_OBJ_ORNULL(wrk->nobjhead, OBJHEAD_MAGIC);
 		WS_Assert(wrk->aws);
 
+		if (sp->req != NULL) {
+			CHECK_OBJ_NOTNULL(sp->req, REQ_MAGIC);
+			AN(sp->req->sp);
+			assert(sp->req->sp == sp);
+		}
+
 		switch (sp->step) {
 #define STEP(l,u,arg) \
 		    case STP_##u: \
diff --git a/bin/varnishd/cache/cache_session.c b/bin/varnishd/cache/cache_session.c
index 3a85baf..b5226d7 100644
--- a/bin/varnishd/cache/cache_session.c
+++ b/bin/varnishd/cache/cache_session.c
@@ -352,6 +352,8 @@ SES_ReleaseReq(struct sess *sp)
 	CHECK_OBJ_NOTNULL(pp, SESSPOOL_MAGIC);
 	AN(pp->pool);
 	CHECK_OBJ_NOTNULL(sp->req, REQ_MAGIC);
+	AN(sp->req->sp);
+	assert(sp->req->sp == sp);
 	MPL_AssertSane(sp->req);
 	VSL_Flush(sp->req->vsl, 0);
 	MPL_Free(pp->mpl_req, sp->req);
diff --git a/bin/varnishd/cache/cache_vcl.c b/bin/varnishd/cache/cache_vcl.c
index 9cdf427..527c591 100644
--- a/bin/varnishd/cache/cache_vcl.c
+++ b/bin/varnishd/cache/cache_vcl.c
@@ -340,6 +340,7 @@ VCL_##func##_method(struct req *req)					\
 									\
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);				\
 	CHECK_OBJ_NOTNULL(req->sp, SESS_MAGIC);				\
+	AN(req->sp);							\
 	req->handling = 0;						\
 	req->cur_method = VCL_MET_ ## upper;				\
 	VSLb(req->vsl, SLT_VCL_call, "%s", #func);			\



From phk at varnish-cache.org  Wed Jun 13 07:59:11 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Wed, 13 Jun 2012 09:59:11 +0200
Subject: [master] 94fe4da Try to create a file in our workdir early on and
	give a suggestion if it fails.
Message-ID: <E1SeiTv-0007bP-CR@project.varnish-software.com>

commit 94fe4daba6b51a2e97eee5f9d4719a4123179d86
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Wed Jun 13 07:58:43 2012 +0000

    Try to create a file in our workdir early on and give a suggestion
    if it fails.

diff --git a/bin/varnishd/mgt/mgt_main.c b/bin/varnishd/mgt/mgt_main.c
index 13799f9..88f8253 100644
--- a/bin/varnishd/mgt/mgt_main.c
+++ b/bin/varnishd/mgt/mgt_main.c
@@ -275,7 +275,7 @@ cli_stdin_close(void *priv)
 int
 main(int argc, char * const *argv)
 {
-	int o;
+	int o, fd;
 	unsigned C_flag = 0;
 	unsigned F_flag = 0;
 	const char *b_arg = NULL;
@@ -530,7 +530,7 @@ main(int argc, char * const *argv)
 	}
 
 	if (n_arg != NULL)
-		openlog(n_arg, LOG_PID, LOG_LOCAL0);
+		openlog(n_arg, LOG_PID, LOG_LOCAL0);	/* XXX: i_arg ? */
 	else
 		openlog("varnishd", LOG_PID, LOG_LOCAL0);
 
@@ -546,6 +546,17 @@ main(int argc, char * const *argv)
 		exit(1);
 	}
 
+	fd = open("_.testfile", O_RDWR|O_CREAT|O_EXCL, 0600);
+	if (fd < 0) {
+		fprintf(stderr, "Cannot create test-file in %s (%s)\n",
+		    dirname, strerror(errno));
+		fprintf(stderr,
+		    "Check permissions (or delete old directory)\n");
+		exit(1);
+	}
+	AZ(close(fd));
+	AZ(unlink("_.testfile"));
+
 	/* XXX: should this be relative to the -n arg ? */
 	if (P_arg && (pfh = VPF_Open(P_arg, 0644, NULL)) == NULL) {
 		perror(P_arg);



From phk at varnish-cache.org  Wed Jun 13 08:03:48 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Wed, 13 Jun 2012 10:03:48 +0200
Subject: [master] b7175b3 Priv-sep vcc and cc also.
Message-ID: <E1SeiYO-0007xL-8O@project.varnish-software.com>

commit b7175b38ad96ae57888e930a12cb88e33005178e
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Wed Jun 13 08:03:22 2012 +0000

    Priv-sep vcc and cc also.
    
    Fixes	#1153

diff --git a/bin/varnishd/mgt/mgt_vcc.c b/bin/varnishd/mgt/mgt_vcc.c
index 9b46da3..6f4642d 100644
--- a/bin/varnishd/mgt/mgt_vcc.c
+++ b/bin/varnishd/mgt/mgt_vcc.c
@@ -39,6 +39,7 @@
 #include <unistd.h>
 #include <sys/stat.h>
 
+#include "common/params.h"
 #include "mgt/mgt.h"
 
 #include "libvcl.h"
@@ -136,6 +137,7 @@ run_vcc(void *priv)
 	int fd, i, l;
 
 	CAST_OBJ_NOTNULL(vp, priv, VCC_PRIV_MAGIC);
+	mgt_sandbox();
 	sb = VSB_new_auto();
 	XXXAN(sb);
 	VCC_VCL_dir(vcc, mgt_vcl_dir);
@@ -174,6 +176,7 @@ run_vcc(void *priv)
 static void
 run_cc(void *priv)
 {
+	mgt_sandbox();
 	(void)execl("/bin/sh", "/bin/sh", "-c", priv, NULL);
 }
 
@@ -241,8 +244,10 @@ mgt_run_cc(const char *vcl, struct vsb *sb, int C_flag)
 		VSB_printf(sb, "Failed to create %s: %s", sf, strerror(errno));
 		return (NULL);
 	}
+	(void)fchown(sfd, mgt_param.uid, mgt_param.gid);
 	AZ(close(sfd));
 
+
 	/* Run the VCC compiler in a sub-process */
 	memset(&vp, 0, sizeof vp);
 	vp.magic = VCC_PRIV_MAGIC;
@@ -267,6 +272,16 @@ mgt_run_cc(const char *vcl, struct vsb *sb, int C_flag)
 	of[sizeof sf - 1] = 'o';
 	of[sizeof sf] = '\0';
 
+	i = open(of, O_WRONLY|O_CREAT|O_TRUNC, 0600);
+	if (i < 0) {
+		VSB_printf(sb, "Failed to create %s: %s",
+		    of, strerror(errno));
+		(void)unlink(sf);
+		return (NULL);
+	}
+	(void)fchown(i, mgt_param.uid, mgt_param.gid);
+	AZ(close(i));
+
 	/* Build the C-compiler command line */
 	cmdsb = mgt_make_cc_cmd(sf, of);
 
@@ -284,7 +299,7 @@ mgt_run_cc(const char *vcl, struct vsb *sb, int C_flag)
 		i = chmod(of, 0755);
 		if (i)
 			VSB_printf(sb, "Failed to set permissions on %s: %s",
-				   of, strerror(errno));
+			    of, strerror(errno));
 	}
 
 	if (i) {



From phk at varnish-cache.org  Wed Jun 13 08:39:41 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Wed, 13 Jun 2012 10:39:41 +0200
Subject: [master] 45a408b update -r description
Message-ID: <E1Sej77-0002PI-Ds@project.varnish-software.com>

commit 45a408b8185b3be93a9fd53ca543d1fbbda5592f
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Wed Jun 13 08:39:27 2012 +0000

    update -r description

diff --git a/doc/sphinx/reference/varnishd.rst b/doc/sphinx/reference/varnishd.rst
index 805e012..48ebdc8 100644
--- a/doc/sphinx/reference/varnishd.rst
+++ b/doc/sphinx/reference/varnishd.rst
@@ -110,14 +110,13 @@ OPTIONS
             documents.  This is a shortcut for specifying the
             default_ttl run-time parameter.
 
--r param[,param...]  
-            Specifies a list of parameters that are read only. This
-            gives the system administrator a way to limit what someone
-            with access to the Varnish CLI can do. In a very secure
-            environment you want to consider setting parameters such
-            as *user*, *group*, *cc_command*, *vcc_allow_inline_c* to
-            read only as these can potentially be used to escalate
-            privileges.
+-r param[,param...]
+            Make the listed parameters read only. This gives the
+            system administrator a way to limit what the Varnish CLI can do.
+            Consider making parameters such as *user*, *group*, *cc_command*,
+            *vcc_allow_inline_c* read only as these can potentially be used
+            to escalate privileges from the CLI.
+            Protecting *listen_address* may also be a good idea.
 
 -u user     Specifies the name of an unprivileged user to which the child
             process should switch before it starts accepting



From tfheen at varnish-cache.org  Wed Jun 13 11:24:42 2012
From: tfheen at varnish-cache.org (Tollef Fog Heen)
Date: Wed, 13 Jun 2012 13:24:42 +0200
Subject: [master] caac740 Move disable static libraries, we do not use it
Message-ID: <E1Selgo-0006iv-Ch@project.varnish-software.com>

commit caac7404d31e19cd5e2cf7154327c4115e55a4fc
Author: Tollef Fog Heen <tfheen at varnish-software.com>
Date:   Wed Jun 13 13:24:38 2012 +0200

    Move disable static libraries, we do not use it

diff --git a/configure.ac b/configure.ac
index 20134a7..8193874 100644
--- a/configure.ac
+++ b/configure.ac
@@ -13,6 +13,7 @@ AC_CANONICAL_SYSTEM
 AC_LANG(C)
 
 AM_INIT_AUTOMAKE([foreign])
+LT_INIT([disable-static])
 
 # Checks for programs.
 AC_GNU_SOURCE
@@ -43,7 +44,6 @@ CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
 CC="$PTHREAD_CC"
 
 AC_PROG_INSTALL
-AC_PROG_LIBTOOL
 AC_PROG_MAKE_SET
 AC_ARG_WITH([rst2man],
                AS_HELP_STRING([--with-rst2man=PATH],



From phk at varnish-cache.org  Wed Jun 13 12:00:49 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Wed, 13 Jun 2012 14:00:49 +0200
Subject: [master] dc5b18b Improve "waiter" parameter description as discussed
	in param-audit.
Message-ID: <E1SemFl-0000gR-V5@project.varnish-software.com>

commit dc5b18b8e095592c107b16ff911d8e05a6872efb
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Wed Jun 13 12:00:33 2012 +0000

    Improve "waiter" parameter description as discussed in param-audit.

diff --git a/bin/varnishd/mgt/mgt_param.c b/bin/varnishd/mgt/mgt_param.c
index c7834a7..8e3e56d 100644
--- a/bin/varnishd/mgt/mgt_param.c
+++ b/bin/varnishd/mgt/mgt_param.c
@@ -1052,8 +1052,8 @@ static const struct parspec input_parspec[] = {
 		"off", "bool" },
 	{ "waiter", tweak_waiter, NULL, 0, 0,
 		"Select the waiter kernel interface.\n",
-		EXPERIMENTAL | MUST_RESTART,
-		"default", NULL },
+		WIZARD | MUST_RESTART,
+		WAITER_DEFAULT, NULL },
 	{ "diag_bitmap", tweak_diag_bitmap, 0, 0, 0,
 		"Bitmap controlling diagnostics code:\n"
 		"  0x00000001 - CNT_Session states.\n"
diff --git a/bin/varnishd/waiter/mgt_waiter.c b/bin/varnishd/waiter/mgt_waiter.c
index d2816a8..94d90ea 100644
--- a/bin/varnishd/waiter/mgt_waiter.c
+++ b/bin/varnishd/waiter/mgt_waiter.c
@@ -68,14 +68,14 @@ WAIT_tweak_waiter(struct cli *cli, const char *arg)
 		else
 			VCLI_Out(cli, "%s", waiter->name);
 
-		VCLI_Out(cli, " (");
+		VCLI_Out(cli, " (possible values: ");
 		for (i = 0; vca_waiters[i] != NULL; i++)
 			VCLI_Out(cli, "%s%s", i == 0 ? "" : ", ",
 			    vca_waiters[i]->name);
 		VCLI_Out(cli, ")");
 		return;
 	}
-	if (!strcmp(arg, "default")) {
+	if (!strcmp(arg, WAITER_DEFAULT)) {
 		waiter = vca_waiters[0];
 		return;
 	}
diff --git a/bin/varnishd/waiter/waiter.h b/bin/varnishd/waiter/waiter.h
index 9f48884..9f9f795 100644
--- a/bin/varnishd/waiter/waiter.h
+++ b/bin/varnishd/waiter/waiter.h
@@ -33,6 +33,8 @@ struct sess;
 typedef void* waiter_init_f(void);
 typedef void waiter_pass_f(void *priv, const struct sess *);
 
+#define WAITER_DEFAULT		"platform dependent"
+
 struct waiter {
 	const char		*name;
 	waiter_init_f		*init;
diff --git a/bin/varnishtest/tests/b00008.vtc b/bin/varnishtest/tests/b00008.vtc
index cee8d4c..5d447b2 100644
--- a/bin/varnishtest/tests/b00008.vtc
+++ b/bin/varnishtest/tests/b00008.vtc
@@ -30,7 +30,7 @@ varnish v1 -start
 
 varnish v1 -cliok "help"
 
-varnish v1 -cliok "param.set waiter default"
+varnish v1 -cliok "param.set waiter poll"
 
 varnish v1 -clierr 106 "param.set waiter HASH(0x8839c4c)"
 



From phk at varnish-cache.org  Wed Jun 13 12:15:13 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Wed, 13 Jun 2012 14:15:13 +0200
Subject: [master] 65fe9ad Don't modify req after we freed it.
Message-ID: <E1SemTh-0001bV-54@project.varnish-software.com>

commit 65fe9ad8a6459d329f4c6b562642d4711793ad9d
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Wed Jun 13 12:14:41 2012 +0000

    Don't modify req after we freed it.
    
    Fixes	#1147 and #1148

diff --git a/bin/varnishd/cache/cache_center.c b/bin/varnishd/cache/cache_center.c
index e524421..32f67e5 100644
--- a/bin/varnishd/cache/cache_center.c
+++ b/bin/varnishd/cache/cache_center.c
@@ -120,6 +120,8 @@ cnt_wait(struct sess *sp, struct worker *wrk, struct req *req)
 		HTC_Init(req->htc, req->ws, sp->fd, sp->req->vsl,
 		    cache_param->http_req_size,
 		    cache_param->http_req_hdr_len);
+	} else {
+		assert(req->sp == sp);
 	}
 
 	AZ(req->vcl);
@@ -943,6 +945,7 @@ cnt_first(struct sess *sp, struct worker *wrk)
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
 
 	/* Allocate a request already now, so we can VSL to it */
+	AZ(sp->req);
 	SES_GetReq(sp);
 	req = sp->req;
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
@@ -1493,6 +1496,7 @@ cnt_start(struct sess *sp, struct worker *wrk, struct req *req)
 	AZ(req->vcl);
 	AZ(req->esi_level);
 	assert(!isnan(sp->t_req));
+	assert(req->sp == sp);
 
 	/* Update stats of various sorts */
 	wrk->stats.client_req++;
diff --git a/bin/varnishd/cache/cache_session.c b/bin/varnishd/cache/cache_session.c
index b5226d7..e3ec28a 100644
--- a/bin/varnishd/cache/cache_session.c
+++ b/bin/varnishd/cache/cache_session.c
@@ -356,8 +356,8 @@ SES_ReleaseReq(struct sess *sp)
 	assert(sp->req->sp == sp);
 	MPL_AssertSane(sp->req);
 	VSL_Flush(sp->req->vsl, 0);
-	MPL_Free(pp->mpl_req, sp->req);
 	sp->req->sp = NULL;
+	MPL_Free(pp->mpl_req, sp->req);
 	sp->req = NULL;
 }
 



From phk at varnish-cache.org  Wed Jun 13 12:49:58 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Wed, 13 Jun 2012 14:49:58 +0200
Subject: [master] 380a5b2 Remove the gzip_window param, it is useless.
Message-ID: <E1Sen1K-0003kp-Fo@project.varnish-software.com>

commit 380a5b23a66673ee6c62a6dc1a26f69c34d40747
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Wed Jun 13 12:49:45 2012 +0000

    Remove the gzip_window param, it is useless.

diff --git a/bin/varnishd/cache/cache_gzip.c b/bin/varnishd/cache/cache_gzip.c
index f7dba8e..80ce07b 100644
--- a/bin/varnishd/cache/cache_gzip.c
+++ b/bin/varnishd/cache/cache_gzip.c
@@ -128,7 +128,7 @@ VGZ_NewGzip(struct vsl_log *vsl, const char *id)
 	i = deflateInit2(&vg->vz,
 	    cache_param->gzip_level,		/* Level */
 	    Z_DEFLATED,				/* Method */
-	    16 + cache_param->gzip_window,	/* Window bits (16=gzip + 15) */
+	    16 + 15,				/* Window bits (16=gzip) */
 	    cache_param->gzip_memlevel,		/* memLevel */
 	    Z_DEFAULT_STRATEGY);
 	assert(Z_OK == i);
diff --git a/bin/varnishd/common/params.h b/bin/varnishd/common/params.h
index 1e13657..2e8bf37 100644
--- a/bin/varnishd/common/params.h
+++ b/bin/varnishd/common/params.h
@@ -185,7 +185,6 @@ struct params {
 	unsigned		http_gzip_support;
 	unsigned		gzip_buffer;
 	unsigned		gzip_level;
-	unsigned		gzip_window;
 	unsigned		gzip_memlevel;
 
 	unsigned		obj_readonly;
diff --git a/bin/varnishd/mgt/mgt_param.c b/bin/varnishd/mgt/mgt_param.c
index 8e3e56d..c425882 100644
--- a/bin/varnishd/mgt/mgt_param.c
+++ b/bin/varnishd/mgt/mgt_param.c
@@ -1125,11 +1125,6 @@ static const struct parspec input_parspec[] = {
 		"Gzip compression level: 0=debug, 1=fast, 9=best",
 		0,
 		"6", ""},
-	{ "gzip_window", tweak_uint, &mgt_param.gzip_window, 8, 15,
-		"Gzip window size 8=least, 15=most compression.\n"
-		"Memory impact is 8=1k, 9=2k, ... 15=128k.",
-		0,
-		"15", ""},
 	{ "gzip_memlevel", tweak_uint, &mgt_param.gzip_memlevel, 1, 9,
 		"Gzip memory level 1=slow/least, 9=fast/most compression.\n"
 		"Memory impact is 1=1k, 2=2k, ... 9=256k.",
diff --git a/bin/varnishtest/tests/e00022.vtc b/bin/varnishtest/tests/e00022.vtc
index 1f13cd3..b4b3572 100644
--- a/bin/varnishtest/tests/e00022.vtc
+++ b/bin/varnishtest/tests/e00022.vtc
@@ -25,7 +25,6 @@ varnish v1 -arg "-p thread_pool_stack=262144" -vcl+backend {
 
 varnish v1 -cliok "param.set esi_syntax 0xc"
 varnish v1 -cliok "param.set http_gzip_support true"
-varnish v1 -cliok "param.set gzip_window 8"
 varnish v1 -cliok "param.set gzip_memlevel 1"
 
 client c1 {



From phk at varnish-cache.org  Thu Jun 14 08:28:39 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Thu, 14 Jun 2012 10:28:39 +0200
Subject: [master] 14b7e6e Move t_req from sp to req,
	and give sp a t_rx for the handover from acceptor to center.
Message-ID: <E1Sf5Pz-0001xJ-BY@project.varnish-software.com>

commit 14b7e6e94ab1acbfa1768d96fa52633b163a64e9
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Thu Jun 14 08:27:57 2012 +0000

    Move t_req from sp to req, and give sp a t_rx for the handover from
    acceptor to center.

diff --git a/bin/varnishd/cache/cache.h b/bin/varnishd/cache/cache.h
index cdd85be..4319b70 100644
--- a/bin/varnishd/cache/cache.h
+++ b/bin/varnishd/cache/cache.h
@@ -590,6 +590,7 @@ struct req {
 	uint64_t		req_bodybytes;
 	char			*ws_req;	/* WS above request data */
 
+	double			t_req;
 	double			t_resp;
 
 	struct http_conn	htc[1];
@@ -673,7 +674,7 @@ struct sess {
 	/* Timestamps, all on TIM_real() timescale */
 	double			t_open;		/* fd accepted */
 	double			t_idle;		/* fd accepted or resp sent */
-	double			t_req;
+	double			t_rx;
 
 #if defined(HAVE_EPOLL_CTL)
 	struct epoll_event ev;
diff --git a/bin/varnishd/cache/cache_backend.c b/bin/varnishd/cache/cache_backend.c
index 6f2ce1f..fb116bf 100644
--- a/bin/varnishd/cache/cache_backend.c
+++ b/bin/varnishd/cache/cache_backend.c
@@ -271,7 +271,7 @@ vbe_Healthy(const struct vdi_simple *vs, const struct sess *sp)
 	if (threshold == 0 || VTAILQ_EMPTY(&backend->troublelist))
 		return (1);
 
-	now = sp->t_req;
+	now = sp->req->t_req;
 
 	old = NULL;
 	retval = 1;
diff --git a/bin/varnishd/cache/cache_center.c b/bin/varnishd/cache/cache_center.c
index 32f67e5..d063466 100644
--- a/bin/varnishd/cache/cache_center.c
+++ b/bin/varnishd/cache/cache_center.c
@@ -83,11 +83,6 @@ static unsigned xids;
  * WAIT
  * Collect the request from the client.
  *
- * We "abuse" sp->t_req a bit here:  On input it means "request reception
- * started at xxx" and is used to trigger timeouts.  On return it means
- * "we had full request headers by xxx" and is used for reporting by
- * later steps.
- *
 DOT subgraph xcluster_wait {
 DOT	wait [
 DOT		shape=box
@@ -112,6 +107,8 @@ cnt_wait(struct sess *sp, struct worker *wrk, struct req *req)
 	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
 
+	assert(!isnan(sp->t_rx));
+
 	if (req == NULL) {
 		SES_GetReq(sp);
 		req = sp->req;
@@ -128,9 +125,9 @@ cnt_wait(struct sess *sp, struct worker *wrk, struct req *req)
 	AZ(req->obj);
 	AZ(req->esi_level);
 	assert(req->xid == 0);
+	req->t_req = sp->t_rx;
 	req->t_resp = NAN;
 
-	assert(!isnan(sp->t_req));
 	tmo = (int)(1e3 * cache_param->timeout_linger);
 	while (1) {
 		pfd[0].fd = sp->fd;
@@ -145,7 +142,7 @@ cnt_wait(struct sess *sp, struct worker *wrk, struct req *req)
 			i = HTC_Complete(req->htc);
 		if (i == 1) {
 			/* Got it, run with it */
-			sp->t_req = now;
+			req->t_req = now;
 			sp->step = STP_START;
 			return (0);
 		} else if (i == -1) {
@@ -164,7 +161,7 @@ cnt_wait(struct sess *sp, struct worker *wrk, struct req *req)
 			when = sp->t_idle + cache_param->timeout_linger;
 			tmo = (int)(1e3 * (when - now));
 			if (when < now || tmo == 0) {
-				sp->t_req = NAN;
+				sp->t_rx = NAN;
 				wrk->stats.sess_herd++;
 				SES_Charge(sp);
 				SES_ReleaseReq(sp);
@@ -173,7 +170,7 @@ cnt_wait(struct sess *sp, struct worker *wrk, struct req *req)
 			}
 		} else {
 			/* Working on it */
-			when = sp->t_req + cache_param->timeout_req;
+			when = sp->t_rx + cache_param->timeout_req;
 			tmo = (int)(1e3 * (when - now));
 			if (when < now || tmo == 0) {
 				why = "req timeout";
@@ -404,9 +401,9 @@ cnt_done(struct sess *sp, struct worker *wrk, struct req *req)
 	if (req->xid == 0) {
 		req->t_resp = sp->t_idle;
 	} else {
-		dp = req->t_resp - sp->t_req;
+		dp = req->t_resp - req->t_req;
 		da = sp->t_idle - req->t_resp;
-		dh = sp->t_req - sp->t_open;
+		dh = req->t_req - sp->t_open;
 		/* XXX: Add StatReq == StatSess */
 		/* XXX: Workaround for pipe */
 		if (sp->fd >= 0) {
@@ -414,12 +411,12 @@ cnt_done(struct sess *sp, struct worker *wrk, struct req *req)
 			    (uintmax_t)req->req_bodybytes);
 		}
 		VSLb(sp->req->vsl, SLT_ReqEnd, "%u %.9f %.9f %.9f %.9f %.9f",
-		    req->xid, sp->t_req, sp->t_idle, dh, dp, da);
+		    req->xid, req->t_req, sp->t_idle, dh, dp, da);
 	}
 	req->xid = 0;
 	VSL_Flush(sp->req->vsl, 0);
 
-	sp->t_req = NAN;
+	req->t_req = NAN;
 	req->t_resp = NAN;
 
 	req->req_bodybytes = 0;
@@ -448,12 +445,14 @@ cnt_done(struct sess *sp, struct worker *wrk, struct req *req)
 	WS_Reset(req->ws, NULL);
 	WS_Reset(wrk->aws, NULL);
 
-	sp->t_req = sp->t_idle;
 	i = HTC_Reinit(req->htc);
 	if (i == 1) {
+		req->t_req = sp->t_idle;
 		wrk->stats.sess_pipeline++;
 		sp->step = STP_START;
 	} else {
+		sp->t_rx = sp->t_idle;
+		req->t_req = NAN;
 		if (Tlen(req->htc->rxbuf))
 			wrk->stats.sess_readahead++;
 		sp->step = STP_WAIT;
@@ -510,7 +509,7 @@ cnt_error(struct sess *sp, struct worker *wrk, struct req *req)
 	}
 	CHECK_OBJ_NOTNULL(req->obj, OBJECT_MAGIC);
 	req->obj->xid = req->xid;
-	req->obj->exp.entered = sp->t_req;
+	req->obj->exp.entered = req->t_req;
 
 	h = req->obj->http;
 
@@ -972,7 +971,7 @@ cnt_first(struct sess *sp, struct worker *wrk)
 
 	wrk->acct_tmp.sess++;
 
-	sp->t_req = sp->t_open;
+	sp->t_rx = sp->t_open;
 	sp->t_idle = sp->t_open;
 	sp->step = STP_WAIT;
 	return (0);
@@ -1495,7 +1494,7 @@ cnt_start(struct sess *sp, struct worker *wrk, struct req *req)
 	AZ(req->obj);
 	AZ(req->vcl);
 	AZ(req->esi_level);
-	assert(!isnan(sp->t_req));
+	assert(!isnan(req->t_req));
 	assert(req->sp == sp);
 
 	/* Update stats of various sorts */
diff --git a/bin/varnishd/cache/cache_dir_dns.c b/bin/varnishd/cache/cache_dir_dns.c
index ee411dc..068c2b9 100644
--- a/bin/varnishd/cache/cache_dir_dns.c
+++ b/bin/varnishd/cache/cache_dir_dns.c
@@ -203,7 +203,7 @@ vdi_dns_cache_has(const struct sess *sp,
 	struct vdi_dns_hostgroup *hostgr2;
 	VTAILQ_FOREACH_SAFE(hostgr, &vs->cachelist, list, hostgr2) {
 		CHECK_OBJ_NOTNULL(hostgr, VDI_DNSDIR_MAGIC);
-		if (hostgr->ttl <= sp->t_req) {
+		if (hostgr->ttl <= sp->req->t_req) {
 			if (rwlock)
 				vdi_dns_pop_cache(vs, hostgr);
 			return (0);
@@ -233,7 +233,7 @@ vdi_dns_cache_list_add(const struct sess *sp,
 	}
 	CHECK_OBJ_NOTNULL(new, VDI_DNSDIR_MAGIC);
 	assert(new->hostname != 0);
-	new->ttl = sp->t_req + vs->ttl;
+	new->ttl = sp->req->t_req + vs->ttl;
 	VTAILQ_INSERT_HEAD(&vs->cachelist, new, list);
 	vs->ncachelist++;
 }
diff --git a/bin/varnishd/cache/cache_fetch.c b/bin/varnishd/cache/cache_fetch.c
index bc0e52c..7ccba0a 100644
--- a/bin/varnishd/cache/cache_fetch.c
+++ b/bin/varnishd/cache/cache_fetch.c
@@ -476,7 +476,7 @@ FetchHdr(struct sess *sp, int need_host_hdr, int sendbody)
 		VDI_AddHostHeader(bo->bereq, vc);
 
 	(void)VTCP_blocking(vc->fd);	/* XXX: we should timeout instead */
-	WRW_Reserve(wrk, &vc->fd, bo->vsl, sp->t_req);	/* XXX t_resp ? */
+	WRW_Reserve(wrk, &vc->fd, bo->vsl, req->t_req);	/* XXX t_resp ? */
 	(void)http_Write(wrk, hp, 0);	/* XXX: stats ? */
 
 	/* Deal with any message-body the request might have */
diff --git a/bin/varnishd/cache/cache_hash.c b/bin/varnishd/cache/cache_hash.c
index bc94352..79efc69 100644
--- a/bin/varnishd/cache/cache_hash.c
+++ b/bin/varnishd/cache/cache_hash.c
@@ -363,14 +363,14 @@ HSH_Lookup(struct sess *sp)
 			continue;
 
 		/* If still valid, use it */
-		if (EXP_Ttl(req, o) >= sp->t_req)
+		if (EXP_Ttl(req, o) >= req->t_req)
 			break;
 
 		/*
 		 * Remember any matching objects inside their grace period
 		 * and if there are several, use the least expired one.
 		 */
-		if (EXP_Grace(req, o) >= sp->t_req) {
+		if (EXP_Grace(req, o) >= req->t_req) {
 			if (grace_oc == NULL ||
 			    grace_ttl < o->exp.entered + o->exp.ttl) {
 				grace_oc = oc;
diff --git a/bin/varnishd/cache/cache_pipe.c b/bin/varnishd/cache/cache_pipe.c
index c486a23..fda21f4 100644
--- a/bin/varnishd/cache/cache_pipe.c
+++ b/bin/varnishd/cache/cache_pipe.c
@@ -80,7 +80,7 @@ PipeSession(struct sess *sp)
 	bo->vbc = vc;		/* For panic dumping */
 	(void)VTCP_blocking(vc->fd);
 
-	WRW_Reserve(wrk, &vc->fd, bo->vsl, sp->t_req);
+	WRW_Reserve(wrk, &vc->fd, bo->vsl, sp->req->t_req);
 	sp->wrk->acct_tmp.hdrbytes +=
 	    http_Write(wrk, bo->bereq, 0);
 
diff --git a/bin/varnishd/cache/cache_rfc2616.c b/bin/varnishd/cache/cache_rfc2616.c
index 60bb6a9..ece413d 100644
--- a/bin/varnishd/cache/cache_rfc2616.c
+++ b/bin/varnishd/cache/cache_rfc2616.c
@@ -323,7 +323,7 @@ RFC2616_Do_Cond(const struct sess *sp)
 		if (!sp->req->obj->last_modified)
 			return (0);
 		ims = VTIM_parse(p);
-		if (ims > sp->t_req)	/* [RFC2616 14.25] */
+		if (ims > sp->req->t_req)	/* [RFC2616 14.25] */
 			return (0);
 		if (sp->req->obj->last_modified > ims)
 			return (0);
diff --git a/bin/varnishd/cache/cache_session.c b/bin/varnishd/cache/cache_session.c
index e3ec28a..f236389 100644
--- a/bin/varnishd/cache/cache_session.c
+++ b/bin/varnishd/cache/cache_session.c
@@ -90,7 +90,7 @@ ses_setup(struct sess *sp)
 	sp->sockaddr.ss_family = sp->mysockaddr.ss_family = PF_UNSPEC;
 	sp->t_open = NAN;
 	sp->t_idle = NAN;
-	sp->t_req = NAN;
+	sp->t_rx = NAN;
 }
 
 /*--------------------------------------------------------------------
@@ -208,7 +208,7 @@ SES_Handle(struct sess *sp, double now)
 {
 
 	sp->step = STP_WAIT;
-	sp->t_req = now;
+	sp->t_rx = now;
 	(void)SES_Schedule(sp);
 }
 
diff --git a/bin/varnishd/cache/cache_vrt_var.c b/bin/varnishd/cache/cache_vrt_var.c
index 37fb7a0..7a88447 100644
--- a/bin/varnishd/cache/cache_vrt_var.c
+++ b/bin/varnishd/cache/cache_vrt_var.c
@@ -153,7 +153,7 @@ VRT_l_beresp_saintmode(const struct sess *sp, double a)
 	ALLOC_OBJ(new, TROUBLE_MAGIC);
 	AN(new);
 	memcpy(new->digest, sp->req->digest, sizeof new->digest);
-	new->timeout = sp->t_req + a;
+	new->timeout = sp->req->t_req + a;
 
 	/* Insert the new item on the list before the first item with a
 	 * timeout at a later date (ie: sort by which entry will time out
@@ -396,8 +396,8 @@ static void
 vrt_wsp_exp(const struct sess *sp, unsigned xid, const struct exp *e)
 {
 	VSLb(sp->req->vsl, SLT_TTL, "%u VCL %.0f %.0f %.0f %.0f %.0f",
-	    xid, e->ttl - (sp->t_req - e->entered), e->grace, e->keep,
-	    sp->t_req, e->age + (sp->t_req - e->entered));
+	    xid, e->ttl - (sp->req->t_req - e->entered), e->grace, e->keep,
+	    sp->req->t_req, e->age + (sp->req->t_req - e->entered));
 }
 
 VRT_DO_EXP(req, sp->req->exp, ttl, 0, )
@@ -407,7 +407,8 @@ VRT_DO_EXP(req, sp->req->exp, keep, 0, )
 VRT_DO_EXP(obj, sp->req->obj->exp, grace, 0,
    EXP_Rearm(sp->req->obj);
    vrt_wsp_exp(sp, sp->req->obj->xid, &sp->req->obj->exp);)
-VRT_DO_EXP(obj, sp->req->obj->exp, ttl, (sp->t_req - sp->req->obj->exp.entered),
+VRT_DO_EXP(obj, sp->req->obj->exp, ttl,
+   (sp->req->t_req - sp->req->obj->exp.entered),
    EXP_Rearm(sp->req->obj);
    vrt_wsp_exp(sp, sp->req->obj->xid, &sp->req->obj->exp);)
 VRT_DO_EXP(obj, sp->req->obj->exp, keep, 0,



From phk at varnish-cache.org  Thu Jun 14 08:43:23 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Thu, 14 Jun 2012 10:43:23 +0200
Subject: [master] 3cea894 Reduce RFC2616_Do_Cond() arg from sp to req
Message-ID: <E1Sf5eF-0002vQ-UA@project.varnish-software.com>

commit 3cea89452d8c9b908eaf0cc4defe2a0c7c4f39fd
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Thu Jun 14 08:43:06 2012 +0000

    Reduce RFC2616_Do_Cond() arg from sp to req

diff --git a/bin/varnishd/cache/cache.h b/bin/varnishd/cache/cache.h
index 4319b70..03c3edf 100644
--- a/bin/varnishd/cache/cache.h
+++ b/bin/varnishd/cache/cache.h
@@ -1015,7 +1015,7 @@ char *WS_Snapshot(struct ws *ws);
 void RFC2616_Ttl(struct busyobj *, unsigned xid);
 enum body_status RFC2616_Body(struct busyobj *, struct dstat *);
 unsigned RFC2616_Req_Gzip(const struct http *);
-int RFC2616_Do_Cond(const struct sess *sp);
+int RFC2616_Do_Cond(const struct req *sp);
 
 /* stevedore.c */
 struct object *STV_NewObject(struct busyobj *, struct objcore **,
diff --git a/bin/varnishd/cache/cache_center.c b/bin/varnishd/cache/cache_center.c
index d063466..729b91b 100644
--- a/bin/varnishd/cache/cache_center.c
+++ b/bin/varnishd/cache/cache_center.c
@@ -880,7 +880,7 @@ cnt_fetchbody(struct sess *sp, struct worker *wrk, struct req *req)
 	 */
 	if (req->obj->response == 200 &&
 	    req->http->conds &&
-	    RFC2616_Do_Cond(sp))
+	    RFC2616_Do_Cond(req))
 		bo->do_stream = 0;
 
 	/*
diff --git a/bin/varnishd/cache/cache_response.c b/bin/varnishd/cache/cache_response.c
index 82cdafc..700e791 100644
--- a/bin/varnishd/cache/cache_response.c
+++ b/bin/varnishd/cache/cache_response.c
@@ -128,7 +128,7 @@ RES_BuildHttp(const struct sess *sp)
 		http_Unset(req->resp, H_Content_Encoding);
 
 	if (req->obj->response == 200
-	    && req->http->conds && RFC2616_Do_Cond(sp)) {
+	    && req->http->conds && RFC2616_Do_Cond(req)) {
 		req->wantbody = 0;
 		http_SetResp(req->resp, "HTTP/1.1", 304, "Not Modified");
 		http_Unset(req->resp, H_Content_Length);
diff --git a/bin/varnishd/cache/cache_rfc2616.c b/bin/varnishd/cache/cache_rfc2616.c
index ece413d..905b744 100644
--- a/bin/varnishd/cache/cache_rfc2616.c
+++ b/bin/varnishd/cache/cache_rfc2616.c
@@ -310,7 +310,7 @@ RFC2616_Req_Gzip(const struct http *hp)
 /*--------------------------------------------------------------------*/
 
 int
-RFC2616_Do_Cond(const struct sess *sp)
+RFC2616_Do_Cond(const struct req *req)
 {
 	char *p, *e;
 	double ims;
@@ -319,19 +319,19 @@ RFC2616_Do_Cond(const struct sess *sp)
 	/* RFC 2616 13.3.4 states we need to match both ETag
 	   and If-Modified-Since if present*/
 
-	if (http_GetHdr(sp->req->http, H_If_Modified_Since, &p) ) {
-		if (!sp->req->obj->last_modified)
+	if (http_GetHdr(req->http, H_If_Modified_Since, &p) ) {
+		if (!req->obj->last_modified)
 			return (0);
 		ims = VTIM_parse(p);
-		if (ims > sp->req->t_req)	/* [RFC2616 14.25] */
+		if (ims > req->t_req)	/* [RFC2616 14.25] */
 			return (0);
-		if (sp->req->obj->last_modified > ims)
+		if (req->obj->last_modified > ims)
 			return (0);
 		do_cond = 1;
 	}
 
-	if (http_GetHdr(sp->req->http, H_If_None_Match, &p) &&
-	    http_GetHdr(sp->req->obj->http, H_ETag, &e)) {
+	if (http_GetHdr(req->http, H_If_None_Match, &p) &&
+	    http_GetHdr(req->obj->http, H_ETag, &e)) {
 		if (strcmp(p,e) != 0)
 			return (0);
 		do_cond = 1;



From phk at varnish-cache.org  Thu Jun 14 13:19:56 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Thu, 14 Jun 2012 15:19:56 +0200
Subject: [master] 967af89 Pass struct req into VCL methods
Message-ID: <E1Sf9xs-00073a-4r@project.varnish-software.com>

commit 967af895463e08ffa7fb69041f6872608fba4d5c
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Thu Jun 14 12:25:52 2012 +0000

    Pass struct req into VCL methods

diff --git a/bin/varnishd/cache/cache_vcl.c b/bin/varnishd/cache/cache_vcl.c
index 527c591..b909a0e 100644
--- a/bin/varnishd/cache/cache_vcl.c
+++ b/bin/varnishd/cache/cache_vcl.c
@@ -191,7 +191,7 @@ VCL_Load(const char *fn, const char *name, struct cli *cli)
 	REPLACE(vcl->name, name);
 	VCLI_Out(cli, "Loaded \"%s\" as \"%s\"", fn , name);
 	VTAILQ_INSERT_TAIL(&vcl_head, vcl, list);
-	(void)vcl->conf->init_func(NULL);
+	(void)vcl->conf->init_func(NULL, NULL);
 	Lck_Lock(&vcl_mtx);
 	if (vcl_active == NULL)
 		vcl_active = vcl;
@@ -215,7 +215,7 @@ VCL_Nuke(struct vcls *vcl)
 	assert(vcl->conf->discard);
 	assert(vcl->conf->busy == 0);
 	VTAILQ_REMOVE(&vcl_head, vcl, list);
-	(void)vcl->conf->fini_func(NULL);
+	(void)vcl->conf->fini_func(NULL, NULL);
 	vcl->conf->fini_vcl(NULL);
 	free(vcl->name);
 	(void)dlclose(vcl->dlh);
@@ -344,7 +344,7 @@ VCL_##func##_method(struct req *req)					\
 	req->handling = 0;						\
 	req->cur_method = VCL_MET_ ## upper;				\
 	VSLb(req->vsl, SLT_VCL_call, "%s", #func);			\
-	(void)req->vcl->func##_func(req->sp);				\
+	(void)req->vcl->func##_func(req->sp, req);			\
 	VSLb(req->vsl, SLT_VCL_return, "%s",				\
 	    VCL_Return_Name(req->handling));				\
 	req->cur_method = 0;						\
diff --git a/lib/libvcl/generate.py b/lib/libvcl/generate.py
index 1d397c8..0f7b360 100755
--- a/lib/libvcl/generate.py
+++ b/lib/libvcl/generate.py
@@ -716,11 +716,12 @@ file_header(fo)
 
 fo.write("""
 struct sess;
+struct req;
 struct cli;
 
 typedef int vcl_init_f(struct cli *);
 typedef void vcl_fini_f(struct cli *);
-typedef int vcl_func_f(struct sess *sp);
+typedef int vcl_func_f(struct sess *sp, struct req *req);
 """)
 
 
diff --git a/lib/libvcl/vcc_compile.c b/lib/libvcl/vcc_compile.c
index c9fe573..db8b37a 100644
--- a/lib/libvcl/vcc_compile.c
+++ b/lib/libvcl/vcc_compile.c
@@ -670,7 +670,7 @@ vcc_CompileSource(const struct vcc *tl0, struct vsb *sb, struct source *sp)
 	/* Emit method functions */
 	for (i = 0; i < VCL_MET_MAX; i++) {
 		Fc(tl, 1, "\nstatic int\n");
-		Fc(tl, 1, "VGC_function_%s (struct sess *sp)\n",
+		Fc(tl, 1, "VGC_function_%s(struct sess *sp, struct req *req)\n",
 		    method_tab[i].name);
 		AZ(VSB_finish(tl->fm[i]));
 		Fc(tl, 1, "{\n");
diff --git a/lib/libvcl/vcc_parse.c b/lib/libvcl/vcc_parse.c
index 1b7ee88..1d37dd5 100644
--- a/lib/libvcl/vcc_parse.c
+++ b/lib/libvcl/vcc_parse.c
@@ -224,10 +224,13 @@ vcc_Function(struct vcc *tl)
 			return;
 		}
 		tl->curproc = vcc_AddProc(tl, tl->t);
-		Fh(tl, 0, "static int VGC_function_%.*s (struct sess *sp);\n",
+		Fh(tl, 0, "static int VGC_function_%.*s "
+		    "(struct sess *, struct req *);\n",
 		    PF(tl->t));
 		Fc(tl, 1, "\nstatic int\n");
-		Fc(tl, 1, "VGC_function_%.*s (struct sess *sp)\n", PF(tl->t));
+		Fc(tl, 1, "VGC_function_%.*s"
+		    "(struct sess *sp, struct req *req)\n",
+		    PF(tl->t));
 	}
 	vcc_NextToken(tl);
 	tl->indent += INDENT;



From phk at varnish-cache.org  Thu Jun 14 13:19:56 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Thu, 14 Jun 2012 15:19:56 +0200
Subject: [master] f80c6e3 Remember to pass req also when we call user defined
	functions
Message-ID: <E1Sf9xs-00073f-67@project.varnish-software.com>

commit f80c6e358422d0f3534340abca48cfb7f05b398a
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Thu Jun 14 12:28:13 2012 +0000

    Remember to pass req also when we call user defined functions

diff --git a/lib/libvcl/vcc_action.c b/lib/libvcl/vcc_action.c
index b4713e6..e725c6d 100644
--- a/lib/libvcl/vcc_action.c
+++ b/lib/libvcl/vcc_action.c
@@ -44,7 +44,7 @@ parse_call(struct vcc *tl)
 	ExpectErr(tl, ID);
 	vcc_AddCall(tl, tl->t);
 	vcc_AddRef(tl, tl->t, SYM_SUB);
-	Fb(tl, 1, "if (VGC_function_%.*s(sp))\n", PF(tl->t));
+	Fb(tl, 1, "if (VGC_function_%.*s(sp, req))\n", PF(tl->t));
 	Fb(tl, 1, "\treturn (1);\n");
 	vcc_NextToken(tl);
 	return;



From phk at varnish-cache.org  Thu Jun 14 13:19:56 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Thu, 14 Jun 2012 15:19:56 +0200
Subject: [master] 7d90d62 Move VRT_count() from sess to req
Message-ID: <E1Sf9xs-00073l-7J@project.varnish-software.com>

commit 7d90d625b2191cab73c1393230582c5b8a4b9b94
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Thu Jun 14 12:33:10 2012 +0000

    Move VRT_count() from sess to req

diff --git a/bin/varnishd/cache/cache_vrt.c b/bin/varnishd/cache/cache_vrt.c
index 10658cd..a7d68ad 100644
--- a/bin/varnishd/cache/cache_vrt.c
+++ b/bin/varnishd/cache/cache_vrt.c
@@ -70,15 +70,15 @@ VRT_error(const struct sess *sp, unsigned code, const char *reason)
 /*--------------------------------------------------------------------*/
 
 void
-VRT_count(const struct sess *sp, unsigned u)
+VRT_count(struct req *req, unsigned u)
 {
 
-	if (sp == NULL)
+	if (req == NULL)
 		return;
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	if (cache_param->vcl_trace)
-		VSLb(sp->req->vsl, SLT_VCL_trace, "%u %u.%u", u,
-		    sp->req->vcl->ref[u].line, sp->req->vcl->ref[u].pos);
+		VSLb(req->vsl, SLT_VCL_trace, "%u %u.%u", u,
+		    req->vcl->ref[u].line, req->vcl->ref[u].pos);
 }
 
 /*--------------------------------------------------------------------*/
diff --git a/include/vrt.h b/include/vrt.h
index bbf16ac..0b122ec 100644
--- a/include/vrt.h
+++ b/include/vrt.h
@@ -32,6 +32,7 @@
  */
 
 struct sess;
+struct req;
 struct vsb;
 struct cli;
 struct director;
@@ -154,7 +155,7 @@ void VRT_ban(struct sess *sp, char *, ...);
 void VRT_ban_string(struct sess *sp, const char *);
 void VRT_purge(const struct sess *sp, double ttl, double grace);
 
-void VRT_count(const struct sess *, unsigned);
+void VRT_count(struct req *, unsigned);
 int VRT_rewrite(const char *, const char *);
 void VRT_error(const struct sess *, unsigned, const char *);
 int VRT_switch_config(const char *);
diff --git a/lib/libvcl/vcc_parse.c b/lib/libvcl/vcc_parse.c
index 1d37dd5..369aca8 100644
--- a/lib/libvcl/vcc_parse.c
+++ b/lib/libvcl/vcc_parse.c
@@ -47,7 +47,7 @@ static void vcc_Compound(struct vcc *tl);
 } while (0)
 
 #define C(tl, sep)	do {					\
-	Fb(tl, 1, "VRT_count(sp, %u)%s\n", ++tl->cnt, sep);	\
+	Fb(tl, 1, "VRT_count(req, %u)%s\n", ++tl->cnt, sep);	\
 	tl->t->cnt = tl->cnt;					\
 } while (0)
 



From phk at varnish-cache.org  Thu Jun 14 13:19:56 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Thu, 14 Jun 2012 15:19:56 +0200
Subject: [master] 931ef7d Emit __match_proto__() for compiled functions
Message-ID: <E1Sf9xs-00073s-8e@project.varnish-software.com>

commit 931ef7d8c4a3c24574c5411ef69c1fb76efb3ae6
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Thu Jun 14 12:49:04 2012 +0000

    Emit __match_proto__() for compiled functions

diff --git a/lib/libvcl/vcc_compile.c b/lib/libvcl/vcc_compile.c
index db8b37a..a16fbed 100644
--- a/lib/libvcl/vcc_compile.c
+++ b/lib/libvcl/vcc_compile.c
@@ -609,6 +609,8 @@ vcc_CompileSource(const struct vcc *tl0, struct vsb *sb, struct source *sp)
 	/* Macro for accessing directors */
 	Fh(tl, 0, "#define VGCDIR(n) VCL_conf.director[VGC_backend_##n]\n");
 
+	Fh(tl, 0, "#define __match_proto__(xxx)		/*lint -e{818} */\n");
+
 	/* Register and lex the main source */
 	VTAILQ_INSERT_TAIL(&tl->sources, sp, list);
 	sp->idx = tl->nsources++;
@@ -669,7 +671,7 @@ vcc_CompileSource(const struct vcc *tl0, struct vsb *sb, struct source *sp)
 
 	/* Emit method functions */
 	for (i = 0; i < VCL_MET_MAX; i++) {
-		Fc(tl, 1, "\nstatic int\n");
+		Fc(tl, 1, "\nstatic int __match_proto__(vcl_func_f)\n");
 		Fc(tl, 1, "VGC_function_%s(struct sess *sp, struct req *req)\n",
 		    method_tab[i].name);
 		AZ(VSB_finish(tl->fm[i]));
diff --git a/lib/libvcl/vcc_parse.c b/lib/libvcl/vcc_parse.c
index 369aca8..1a6bbf3 100644
--- a/lib/libvcl/vcc_parse.c
+++ b/lib/libvcl/vcc_parse.c
@@ -227,7 +227,7 @@ vcc_Function(struct vcc *tl)
 		Fh(tl, 0, "static int VGC_function_%.*s "
 		    "(struct sess *, struct req *);\n",
 		    PF(tl->t));
-		Fc(tl, 1, "\nstatic int\n");
+		Fc(tl, 1, "\nstatic int __match_proto__(vcl_func_t)\n");
 		Fc(tl, 1, "VGC_function_%.*s"
 		    "(struct sess *sp, struct req *req)\n",
 		    PF(tl->t));



From phk at varnish-cache.org  Thu Jun 14 14:27:15 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Thu, 14 Jun 2012 16:27:15 +0200
Subject: [master] 30ecc41 Downgrade all the VRT-var functions from sp to req
Message-ID: <E1SfB11-00035U-0U@project.varnish-software.com>

commit 30ecc418275ca0aacfd47b91a2b4c8eef5960df8
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Thu Jun 14 14:26:52 2012 +0000

    Downgrade all the VRT-var functions from sp to req

diff --git a/bin/varnishd/cache/cache_vrt.c b/bin/varnishd/cache/cache_vrt.c
index a7d68ad..524a9b2 100644
--- a/bin/varnishd/cache/cache_vrt.c
+++ b/bin/varnishd/cache/cache_vrt.c
@@ -277,10 +277,10 @@ VRT_hashdata(const struct sess *sp, const char *str, ...)
 /*--------------------------------------------------------------------*/
 
 double
-VRT_r_now(const struct sess *sp)
+VRT_r_now(const struct req *req)
 {
 
-	(void)sp;
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	return (VTIM_real());
 }
 
diff --git a/bin/varnishd/cache/cache_vrt_var.c b/bin/varnishd/cache/cache_vrt_var.c
index 7a88447..8d325ca 100644
--- a/bin/varnishd/cache/cache_vrt_var.c
+++ b/bin/varnishd/cache/cache_vrt_var.c
@@ -63,59 +63,60 @@ vrt_do_string(const struct http *hp, int fld,
 
 #define VRT_DO_HDR(obj, hdr, http, fld)				\
 void								\
-VRT_l_##obj##_##hdr(const struct sess *sp, const char *p, ...)	\
+VRT_l_##obj##_##hdr(const struct req *req, const char *p, ...)	\
 {								\
 	va_list ap;						\
 								\
-	(void)sp;						\
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);			\
 	va_start(ap, p);					\
 	vrt_do_string(http, fld, #obj "." #hdr, p, ap);		\
 	va_end(ap);						\
 }								\
 								\
 const char *							\
-VRT_r_##obj##_##hdr(const struct sess *sp)			\
+VRT_r_##obj##_##hdr(const struct req *req)			\
 {								\
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);			\
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);			\
 	CHECK_OBJ_NOTNULL(http, HTTP_MAGIC);			\
 	return (http->hd[fld].b);				\
 }
 
-VRT_DO_HDR(req,   request,	sp->req->http,		HTTP_HDR_REQ)
-VRT_DO_HDR(req,   url,		sp->req->http,		HTTP_HDR_URL)
-VRT_DO_HDR(req,   proto,	sp->req->http,		HTTP_HDR_PROTO)
-VRT_DO_HDR(bereq, request,	sp->req->busyobj->bereq,	HTTP_HDR_REQ)
-VRT_DO_HDR(bereq, url,		sp->req->busyobj->bereq,	HTTP_HDR_URL)
-VRT_DO_HDR(bereq, proto,	sp->req->busyobj->bereq,	HTTP_HDR_PROTO)
-VRT_DO_HDR(obj,   proto,	sp->req->obj->http,	HTTP_HDR_PROTO)
-VRT_DO_HDR(obj,   response,	sp->req->obj->http,	HTTP_HDR_RESPONSE)
-VRT_DO_HDR(resp,  proto,	sp->req->resp,		HTTP_HDR_PROTO)
-VRT_DO_HDR(resp,  response,	sp->req->resp,		HTTP_HDR_RESPONSE)
-VRT_DO_HDR(beresp,  proto,	sp->req->busyobj->beresp,	HTTP_HDR_PROTO)
-VRT_DO_HDR(beresp,  response,	sp->req->busyobj->beresp, HTTP_HDR_RESPONSE)
+VRT_DO_HDR(req,   request,	req->http,		HTTP_HDR_REQ)
+VRT_DO_HDR(req,   url,		req->http,		HTTP_HDR_URL)
+VRT_DO_HDR(req,   proto,	req->http,		HTTP_HDR_PROTO)
+VRT_DO_HDR(bereq, request,	req->busyobj->bereq,	HTTP_HDR_REQ)
+VRT_DO_HDR(bereq, url,		req->busyobj->bereq,	HTTP_HDR_URL)
+VRT_DO_HDR(bereq, proto,	req->busyobj->bereq,	HTTP_HDR_PROTO)
+VRT_DO_HDR(obj,   proto,	req->obj->http,		HTTP_HDR_PROTO)
+VRT_DO_HDR(obj,   response,	req->obj->http,		HTTP_HDR_RESPONSE)
+VRT_DO_HDR(resp,  proto,	req->resp,		HTTP_HDR_PROTO)
+VRT_DO_HDR(resp,  response,	req->resp,		HTTP_HDR_RESPONSE)
+VRT_DO_HDR(beresp,  proto,	req->busyobj->beresp,	HTTP_HDR_PROTO)
+VRT_DO_HDR(beresp,  response,	req->busyobj->beresp,	HTTP_HDR_RESPONSE)
 
 /*--------------------------------------------------------------------*/
 
 #define VRT_DO_STATUS(obj, http)				\
 void								\
-VRT_l_##obj##_status(const struct sess *sp, int num)		\
+VRT_l_##obj##_status(const struct req *req, int num)		\
 {								\
 								\
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);			\
 	assert(num >= 100 && num <= 999);			\
 	http->status = (uint16_t)num;				\
 }								\
 								\
 int								\
-VRT_r_##obj##_status(const struct sess *sp)			\
+VRT_r_##obj##_status(const struct req *req)			\
 {								\
 								\
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);			\
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);			\
 	return(http->status);					\
 }
 
-VRT_DO_STATUS(obj, sp->req->obj->http)
-VRT_DO_STATUS(beresp, sp->req->busyobj->beresp)
-VRT_DO_STATUS(resp, sp->req->resp)
+VRT_DO_STATUS(obj, req->obj->http)
+VRT_DO_STATUS(beresp, req->busyobj->beresp)
+VRT_DO_STATUS(resp, req->resp)
 
 /*--------------------------------------------------------------------*/
 
@@ -125,25 +126,25 @@ VRT_DO_STATUS(resp, sp->req->resp)
  * is no object.
  */
 void
-VRT_l_beresp_saintmode(const struct sess *sp, double a)
+VRT_l_beresp_saintmode(const struct req *req, double a)
 {
 	struct trouble *new;
 	struct trouble *tr;
 	struct trouble *tr2;
 	struct vbc *vbc;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	CHECK_OBJ_NOTNULL(sp->req->busyobj, BUSYOBJ_MAGIC);
-	vbc = sp->req->busyobj->vbc;
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	CHECK_OBJ_NOTNULL(req->busyobj, BUSYOBJ_MAGIC);
+	vbc = req->busyobj->vbc;
 	if (!vbc)
 		return;
 	CHECK_OBJ_NOTNULL(vbc, VBC_MAGIC);
 	if (!vbc->backend)
 		return;
 	CHECK_OBJ_NOTNULL(vbc->backend, BACKEND_MAGIC);
-	if (!sp->req->objcore->objhead)
+	if (!req->objcore->objhead)
 		return;
-	CHECK_OBJ_NOTNULL(sp->req->objcore, OBJCORE_MAGIC);
+	CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);
 
 	/* Setting a negative holdoff period is a mistake. Detecting this
 	 * when compiling the VCL would be better.
@@ -152,8 +153,8 @@ VRT_l_beresp_saintmode(const struct sess *sp, double a)
 
 	ALLOC_OBJ(new, TROUBLE_MAGIC);
 	AN(new);
-	memcpy(new->digest, sp->req->digest, sizeof new->digest);
-	new->timeout = sp->req->t_req + a;
+	memcpy(new->digest, req->digest, sizeof new->digest);
+	new->timeout = req->t_req + a;
 
 	/* Insert the new item on the list before the first item with a
 	 * timeout at a later date (ie: sort by which entry will time out
@@ -181,17 +182,17 @@ VRT_l_beresp_saintmode(const struct sess *sp, double a)
 
 #define VBERESP(dir, type, onm, field)					\
 void									\
-VRT_l_##dir##_##onm(const struct sess *sp, type a)			\
+VRT_l_##dir##_##onm(const struct req *req, type a)			\
 {									\
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);				\
-	sp->req->field = a;						\
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);				\
+	req->field = a;							\
 }									\
 									\
 type									\
-VRT_r_##dir##_##onm(const struct sess *sp)				\
+VRT_r_##dir##_##onm(const struct req *req)				\
 {									\
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);				\
-	return (sp->req->field);					\
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);				\
+	return (req->field);						\
 }
 
 VBERESP(beresp, unsigned, do_esi, busyobj->do_esi)
@@ -203,46 +204,47 @@ VBERESP(beresp, unsigned, do_pass, busyobj->do_pass)
 /*--------------------------------------------------------------------*/
 
 const char *
-VRT_r_client_identity(const struct sess *sp)
+VRT_r_client_identity(struct req *req)
 {
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	if (sp->req->client_identity != NULL)
-		return (sp->req->client_identity);
+
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	if (req->client_identity != NULL)
+		return (req->client_identity);
 	else
-		return (sp->addr);
+		return (req->sp->addr);
 }
 
 void
-VRT_l_client_identity(const struct sess *sp, const char *str, ...)
+VRT_l_client_identity(struct req *req, const char *str, ...)
 {
 	va_list ap;
 	char *b;
 
 	va_start(ap, str);
-	b = VRT_String(sp->req->http->ws, NULL, str, ap);
+	b = VRT_String(req->http->ws, NULL, str, ap);
 	va_end(ap);
-	sp->req->client_identity = b;
+	req->client_identity = b;
 }
 
 /*--------------------------------------------------------------------*/
 
 #define BEREQ_TIMEOUT(which)					\
 void __match_proto__()						\
-VRT_l_bereq_##which(struct sess *sp, double num)		\
+VRT_l_bereq_##which(struct req *req, double num)		\
 {								\
 								\
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);			\
-	CHECK_OBJ_NOTNULL(sp->req->busyobj, BUSYOBJ_MAGIC);	\
-	sp->req->busyobj->which = (num > 0.0 ? num : 0.0);	\
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);			\
+	CHECK_OBJ_NOTNULL(req->busyobj, BUSYOBJ_MAGIC);		\
+	req->busyobj->which = (num > 0.0 ? num : 0.0);		\
 }								\
 								\
 double __match_proto__()					\
-VRT_r_bereq_##which(struct sess *sp)				\
+VRT_r_bereq_##which(struct req *req)				\
 {								\
 								\
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);			\
-	CHECK_OBJ_NOTNULL(sp->req->busyobj, BUSYOBJ_MAGIC);	\
-	return(sp->req->busyobj->which);			\
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);			\
+	CHECK_OBJ_NOTNULL(req->busyobj, BUSYOBJ_MAGIC);		\
+	return(req->busyobj->which);				\
 }
 
 BEREQ_TIMEOUT(connect_timeout)
@@ -252,118 +254,121 @@ BEREQ_TIMEOUT(between_bytes_timeout)
 /*--------------------------------------------------------------------*/
 
 const char *
-VRT_r_beresp_backend_name(const struct sess *sp)
+VRT_r_beresp_backend_name(const struct req *req)
 {
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	CHECK_OBJ_NOTNULL(sp->req->busyobj->vbc, VBC_MAGIC);
-	return(sp->req->busyobj->vbc->backend->vcl_name);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	CHECK_OBJ_NOTNULL(req->busyobj->vbc, VBC_MAGIC);
+	return(req->busyobj->vbc->backend->vcl_name);
 }
 
 struct sockaddr_storage *
-VRT_r_beresp_backend_ip(const struct sess *sp)
+VRT_r_beresp_backend_ip(const struct req *req)
 {
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	CHECK_OBJ_NOTNULL(sp->req->busyobj->vbc, VBC_MAGIC);
-	return(sp->req->busyobj->vbc->addr);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	CHECK_OBJ_NOTNULL(req->busyobj->vbc, VBC_MAGIC);
+	return(req->busyobj->vbc->addr);
 }
 
 int
-VRT_r_beresp_backend_port(const struct sess *sp)
+VRT_r_beresp_backend_port(const struct req *req)
 {
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	CHECK_OBJ_NOTNULL(sp->req->busyobj->vbc, VBC_MAGIC);
-	return (VTCP_port(sp->req->busyobj->vbc->addr));
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	CHECK_OBJ_NOTNULL(req->busyobj->vbc, VBC_MAGIC);
+	return (VTCP_port(req->busyobj->vbc->addr));
 }
 
 const char * __match_proto__()
-VRT_r_beresp_storage(struct sess *sp)
+VRT_r_beresp_storage(struct req *req)
 {
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	if (sp->req->storage_hint != NULL)
-		return (sp->req->storage_hint);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	if (req->storage_hint != NULL)
+		return (req->storage_hint);
 	else
 		return (NULL);
 }
 
 void __match_proto__()
-VRT_l_beresp_storage(struct sess *sp, const char *str, ...)
+VRT_l_beresp_storage(struct req *req, const char *str, ...)
 {
 	va_list ap;
 	char *b;
 
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	va_start(ap, str);
-	b = VRT_String(sp->req->busyobj->ws, NULL, str, ap);
+	b = VRT_String(req->busyobj->ws, NULL, str, ap);
 	va_end(ap);
-	sp->req->storage_hint = b;
+	req->storage_hint = b;
 }
 
 /*--------------------------------------------------------------------*/
 
 void
-VRT_l_req_backend(const struct sess *sp, struct director *be)
+VRT_l_req_backend(struct req *req, struct director *be)
 {
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	sp->req->director = be;
+
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	req->director = be;
 }
 
 struct director *
-VRT_r_req_backend(const struct sess *sp)
+VRT_r_req_backend(struct req *req)
 {
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	return (sp->req->director);
+
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	return (req->director);
 }
 
 /*--------------------------------------------------------------------*/
 
 void
-VRT_l_req_esi(const struct sess *sp, unsigned process_esi)
+VRT_l_req_esi(struct req *req, unsigned process_esi)
 {
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	/*
 	 * Only allow you to turn of esi in the main request
 	 * else everything gets confused
 	 */
-	if(sp->req->esi_level == 0)
-		sp->req->disable_esi = !process_esi;
+	if(req->esi_level == 0)
+		req->disable_esi = !process_esi;
 }
 
 unsigned
-VRT_r_req_esi(const struct sess *sp)
+VRT_r_req_esi(struct req *req)
 {
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	return (!sp->req->disable_esi);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	return (!req->disable_esi);
 }
 
 int
-VRT_r_req_esi_level(const struct sess *sp)
+VRT_r_req_esi_level(const struct req *req)
 {
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	return(sp->req->esi_level);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	return(req->esi_level);
 }
 
 /*--------------------------------------------------------------------*/
 
 unsigned __match_proto__()
-VRT_r_req_can_gzip(struct sess *sp)
+VRT_r_req_can_gzip(struct req *req)
 {
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	return (RFC2616_Req_Gzip(sp->req->http));
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	return (RFC2616_Req_Gzip(req->http));
 }
 
 
 /*--------------------------------------------------------------------*/
 
 int
-VRT_r_req_restarts(const struct sess *sp)
+VRT_r_req_restarts(const struct req *req)
 {
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	return (sp->req->restarts);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	return (req->restarts);
 }
 
 /*--------------------------------------------------------------------
@@ -374,10 +379,10 @@ VRT_r_req_restarts(const struct sess *sp)
 #define VRT_DO_EXP(which, exp, fld, offset, extra)		\
 								\
 void __match_proto__()						\
-VRT_l_##which##_##fld(struct sess *sp, double a)		\
+VRT_l_##which##_##fld(struct req *req, double a)		\
 {								\
 								\
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);			\
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);			\
 	if (a > 0.)						\
 		a += offset;					\
 	EXP_Set_##fld(&exp, a);					\
@@ -385,57 +390,58 @@ VRT_l_##which##_##fld(struct sess *sp, double a)		\
 }								\
 								\
 double __match_proto__()					\
-VRT_r_##which##_##fld(struct sess *sp)				\
+VRT_r_##which##_##fld(struct req *req)				\
 {								\
 								\
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);			\
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);			\
 	return(EXP_Get_##fld(&exp) - offset);			\
 }
 
 static void
-vrt_wsp_exp(const struct sess *sp, unsigned xid, const struct exp *e)
+vrt_wsp_exp(struct req *req, unsigned xid, const struct exp *e)
 {
-	VSLb(sp->req->vsl, SLT_TTL, "%u VCL %.0f %.0f %.0f %.0f %.0f",
-	    xid, e->ttl - (sp->req->t_req - e->entered), e->grace, e->keep,
-	    sp->req->t_req, e->age + (sp->req->t_req - e->entered));
-}
-
-VRT_DO_EXP(req, sp->req->exp, ttl, 0, )
-VRT_DO_EXP(req, sp->req->exp, grace, 0, )
-VRT_DO_EXP(req, sp->req->exp, keep, 0, )
-
-VRT_DO_EXP(obj, sp->req->obj->exp, grace, 0,
-   EXP_Rearm(sp->req->obj);
-   vrt_wsp_exp(sp, sp->req->obj->xid, &sp->req->obj->exp);)
-VRT_DO_EXP(obj, sp->req->obj->exp, ttl,
-   (sp->req->t_req - sp->req->obj->exp.entered),
-   EXP_Rearm(sp->req->obj);
-   vrt_wsp_exp(sp, sp->req->obj->xid, &sp->req->obj->exp);)
-VRT_DO_EXP(obj, sp->req->obj->exp, keep, 0,
-   EXP_Rearm(sp->req->obj);
-   vrt_wsp_exp(sp, sp->req->obj->xid, &sp->req->obj->exp);)
-
-VRT_DO_EXP(beresp, sp->req->busyobj->exp, grace, 0,
-   vrt_wsp_exp(sp, sp->req->xid, &sp->req->busyobj->exp);)
-VRT_DO_EXP(beresp, sp->req->busyobj->exp, ttl, 0,
-   vrt_wsp_exp(sp, sp->req->xid, &sp->req->busyobj->exp);)
-VRT_DO_EXP(beresp, sp->req->busyobj->exp, keep, 0,
-   vrt_wsp_exp(sp, sp->req->xid, &sp->req->busyobj->exp);)
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	VSLb(req->vsl, SLT_TTL, "%u VCL %.0f %.0f %.0f %.0f %.0f",
+	    xid, e->ttl - (req->t_req - e->entered), e->grace, e->keep,
+	    req->t_req, e->age + (req->t_req - e->entered));
+}
+
+VRT_DO_EXP(req, req->exp, ttl, 0, )
+VRT_DO_EXP(req, req->exp, grace, 0, )
+VRT_DO_EXP(req, req->exp, keep, 0, )
+
+VRT_DO_EXP(obj, req->obj->exp, grace, 0,
+   EXP_Rearm(req->obj);
+   vrt_wsp_exp(req, req->obj->xid, &req->obj->exp);)
+VRT_DO_EXP(obj, req->obj->exp, ttl,
+   (req->t_req - req->obj->exp.entered),
+   EXP_Rearm(req->obj);
+   vrt_wsp_exp(req, req->obj->xid, &req->obj->exp);)
+VRT_DO_EXP(obj, req->obj->exp, keep, 0,
+   EXP_Rearm(req->obj);
+   vrt_wsp_exp(req, req->obj->xid, &req->obj->exp);)
+
+VRT_DO_EXP(beresp, req->busyobj->exp, grace, 0,
+   vrt_wsp_exp(req, req->xid, &req->busyobj->exp);)
+VRT_DO_EXP(beresp, req->busyobj->exp, ttl, 0,
+   vrt_wsp_exp(req, req->xid, &req->busyobj->exp);)
+VRT_DO_EXP(beresp, req->busyobj->exp, keep, 0,
+   vrt_wsp_exp(req, req->xid, &req->busyobj->exp);)
 
 /*--------------------------------------------------------------------
  * req.xid
  */
 
 const char * __match_proto__()
-VRT_r_req_xid(struct sess *sp)
+VRT_r_req_xid(struct req *req)
 {
 	char *p;
 	int size;
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 
-	size = snprintf(NULL, 0, "%u", sp->req->xid) + 1;
-	AN(p = WS_Alloc(sp->req->http->ws, size));
-	assert(snprintf(p, size, "%u", sp->req->xid) < size);
+	size = snprintf(NULL, 0, "%u", req->xid) + 1;
+	AN(p = WS_Alloc(req->http->ws, size));
+	assert(snprintf(p, size, "%u", req->xid) < size);
 	return (p);
 }
 
@@ -443,19 +449,19 @@ VRT_r_req_xid(struct sess *sp)
 
 #define REQ_BOOL(hash_var)					\
 void __match_proto__()						\
-VRT_l_req_##hash_var(struct sess *sp, unsigned val)		\
+VRT_l_req_##hash_var(struct req *req, unsigned val)		\
 {								\
 								\
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);			\
-	sp->req->hash_var = val ? 1 : 0;				\
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);			\
+	req->hash_var = val ? 1 : 0;				\
 }								\
 								\
 unsigned __match_proto__()					\
-VRT_r_req_##hash_var(struct sess *sp)				\
+VRT_r_req_##hash_var(struct req *req)				\
 {								\
 								\
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);			\
-	return(sp->req->hash_var);					\
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);			\
+	return(req->hash_var);					\
 }
 
 REQ_BOOL(hash_ignore_busy)
@@ -464,46 +470,46 @@ REQ_BOOL(hash_always_miss)
 /*--------------------------------------------------------------------*/
 
 struct sockaddr_storage *
-VRT_r_client_ip(struct sess *sp)
+VRT_r_client_ip(struct req *req)
 {
 
-	return (&sp->sockaddr);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	return (&req->sp->sockaddr);
 }
 
 struct sockaddr_storage *
-VRT_r_server_ip(struct sess *sp)
+VRT_r_server_ip(struct req *req)
 {
 	int i;
 
-	if (sp->mysockaddr.ss_family == AF_UNSPEC) {
-		i = getsockname(sp->fd,
-		    (void*)&sp->mysockaddr, &sp->mysockaddrlen);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	if (req->sp->mysockaddr.ss_family == AF_UNSPEC) {
+		i = getsockname(req->sp->fd,
+		    (void*)&req->sp->mysockaddr, &req->sp->mysockaddrlen);
 		assert(VTCP_Check(i));
 	}
 
-	return (&sp->mysockaddr);
+	return (&req->sp->mysockaddr);
 }
 
 const char*
-VRT_r_server_identity(struct sess *sp)
+VRT_r_server_identity(struct req *req)
 {
-	(void)sp;
 
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	if (heritage.identity[0] != '\0')
 		return (heritage.identity);
 	else
 		return (heritage.name);
 }
 
-
 const char*
-VRT_r_server_hostname(struct sess *sp)
+VRT_r_server_hostname(struct req *req)
 {
-	(void)sp;
 
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	if (vrt_hostname[0] == '\0')
 		AZ(gethostname(vrt_hostname, sizeof(vrt_hostname)));
-
 	return (vrt_hostname);
 }
 
@@ -512,43 +518,44 @@ VRT_r_server_hostname(struct sess *sp)
  */
 
 int
-VRT_r_server_port(struct sess *sp)
+VRT_r_server_port(struct req *req)
 {
 	int i;
 
-	if (sp->mysockaddr.ss_family == AF_UNSPEC) {
-		i = getsockname(sp->fd,
-		    (void*)&sp->mysockaddr, &sp->mysockaddrlen);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	if (req->sp->mysockaddr.ss_family == AF_UNSPEC) {
+		i = getsockname(req->sp->fd,
+		    (void*)&req->sp->mysockaddr, &req->sp->mysockaddrlen);
 		assert(VTCP_Check(i));
 	}
-	return (VTCP_port(&sp->mysockaddr));
+	return (VTCP_port(&req->sp->mysockaddr));
 }
 
 /*--------------------------------------------------------------------*/
 
 int
-VRT_r_obj_hits(const struct sess *sp)
+VRT_r_obj_hits(const struct req *req)
 {
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	CHECK_OBJ_NOTNULL(sp->req->obj, OBJECT_MAGIC);	/* XXX */
-	return (sp->req->obj->hits);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	CHECK_OBJ_NOTNULL(req->obj, OBJECT_MAGIC);	/* XXX */
+	return (req->obj->hits);
 }
 
 double
-VRT_r_obj_lastuse(const struct sess *sp)
+VRT_r_obj_lastuse(const struct req *req)
 {
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	CHECK_OBJ_NOTNULL(sp->req->obj, OBJECT_MAGIC);	/* XXX */
-	return (VTIM_real() - sp->req->obj->last_use);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	CHECK_OBJ_NOTNULL(req->obj, OBJECT_MAGIC);	/* XXX */
+	return (VTIM_real() - req->obj->last_use);
 }
 
 unsigned
-VRT_r_req_backend_healthy(const struct sess *sp)
+VRT_r_req_backend_healthy(struct req *req)
 {
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	CHECK_OBJ_NOTNULL(sp->req->director, DIRECTOR_MAGIC);
-	return (VDI_Healthy(sp->req->director, sp));
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	CHECK_OBJ_NOTNULL(req->director, DIRECTOR_MAGIC);
+	return (VDI_Healthy(req->director, req->sp));
 }
 
diff --git a/lib/libvcl/generate.py b/lib/libvcl/generate.py
index 0f7b360..0c1c02e 100755
--- a/lib/libvcl/generate.py
+++ b/lib/libvcl/generate.py
@@ -107,361 +107,361 @@ sp_variables = (
 		'IP',
 		( 'proc',),
 		( ),
-		'struct sess *'
+		'struct req *'
 	),
 	('client.identity',
 		'STRING',
 		( 'proc',),
 		( 'proc',),
-		'const struct sess *'
+		'struct req *'
 	),
 	('server.ip',
 		'IP',
 		( 'proc',),
 		( ),
-		'struct sess *'
+		'struct req *'
 	),
 	('server.hostname',
 		'STRING',
 		( 'proc',),
 		( ),
-		'struct sess *'
+		'struct req *'
 	),
 	('server.identity',
 		'STRING',
 		( 'proc',),
 		( ),
-		'struct sess *'
+		'struct req *'
 	),
 	('server.port',
 		'INT',
 		( 'proc',),
 		( ),
-		'struct sess *'
+		'struct req *'
 	),
 	('req.request',
 		'STRING',
 		( 'proc',),
 		( 'proc',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('req.url',
 		'STRING',
 		( 'proc',),
 		( 'proc',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('req.proto',
 		'STRING',
 		( 'proc',),
 		( 'proc',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('req.http.',
 		'HDR_REQ',
 		( 'proc',),
 		( 'proc',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('req.backend',
 		'BACKEND',
 		( 'proc',),
 		( 'proc',),
-		'const struct sess *'
+		'struct req *'
 	),
 	('req.restarts',
 		'INT',
 		( 'proc',),
 		( ),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('req.esi_level',
 		'INT',
 		( 'proc',),
 		( ),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('req.ttl',
 		'DURATION',
 		( 'proc',),
 		( 'proc',),
-		'struct sess *'
+		'struct req *'
 	),
 	('req.grace',
 		'DURATION',
 		( 'proc',),
 		( 'proc',),
-		'struct sess *'
+		'struct req *'
 	),
 	('req.keep',
 		'DURATION',
 		( 'proc',),
 		( 'proc',),
-		'struct sess *'
+		'struct req *'
 	),
 	('req.xid',
 		'STRING',
 		( 'proc',),
 		( ),
-		'struct sess *'
+		'struct req *'
 	),
 	('req.esi',
 		'BOOL',
 		( 'recv', 'fetch', 'deliver', 'error',),
 		( 'recv', 'fetch', 'deliver', 'error',),
-		'const struct sess *'
+		'struct req *'
 	),
 	('req.can_gzip',
 		'BOOL',
 		( 'proc',),
 		( ),
-		'struct sess *'
+		'struct req *'
 	),
 	('req.backend.healthy',
 		'BOOL',
 		( 'proc',),
 		( ),
-		'const struct sess *'
+		'struct req *'
 	),
 	('req.hash_ignore_busy',
 		'BOOL',
 		( 'recv',),
 		( 'recv',),
-		'struct sess *'
+		'struct req *'
 	),
 	('req.hash_always_miss',
 		'BOOL',
 		( 'recv',),
 		( 'recv',),
-		'struct sess *'
+		'struct req *'
 	),
 	('bereq.request',
 		'STRING',
 		( 'pipe', 'pass', 'miss', 'fetch',),
 		( 'pipe', 'pass', 'miss', 'fetch',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('bereq.url',
 		'STRING',
 		( 'pipe', 'pass', 'miss', 'fetch',),
 		( 'pipe', 'pass', 'miss', 'fetch',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('bereq.proto',
 		'STRING',
 		( 'pipe', 'pass', 'miss', 'fetch',),
 		( 'pipe', 'pass', 'miss', 'fetch',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('bereq.http.',
 		'HDR_BEREQ',
 		( 'pipe', 'pass', 'miss', 'fetch',),
 		( 'pipe', 'pass', 'miss', 'fetch',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('bereq.connect_timeout',
 		'DURATION',
 		( 'pipe', 'pass', 'miss',),
 		( 'pipe', 'pass', 'miss',),
-		'struct sess *'
+		'struct req *'
 	),
 	('bereq.first_byte_timeout',
 		'DURATION',
 		( 'pass', 'miss',),
 		( 'pass', 'miss',),
-		'struct sess *'
+		'struct req *'
 	),
 	('bereq.between_bytes_timeout',
 		'DURATION',
 		( 'pass', 'miss',),
 		( 'pass', 'miss',),
-		'struct sess *'
+		'struct req *'
 	),
 	('beresp.proto',
 		'STRING',
 		( 'fetch',),
 		( 'fetch',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('beresp.saintmode',
 		'DURATION',
 		( ),
 		( 'fetch',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('beresp.status',
 		'INT',
 		( 'fetch',),
 		( 'fetch',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('beresp.response',
 		'STRING',
 		( 'fetch',),
 		( 'fetch',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('beresp.http.',
 		'HDR_BERESP',
 		( 'fetch',),
 		( 'fetch',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('beresp.do_esi',
 		'BOOL',
 		( 'fetch',),
 		( 'fetch',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('beresp.do_stream',
 		'BOOL',
 		( 'fetch',),
 		( 'fetch',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('beresp.do_gzip',
 		'BOOL',
 		( 'fetch',),
 		( 'fetch',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('beresp.do_gunzip',
 		'BOOL',
 		( 'fetch',),
 		( 'fetch',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('beresp.do_pass',
 		'BOOL',
 		( 'fetch',),
 		( 'fetch',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('beresp.ttl',
 		'DURATION',
 		( 'fetch',),
 		( 'fetch',),
-		'struct sess *'
+		'struct req *'
 	),
 	('beresp.grace',
 		'DURATION',
 		( 'fetch',),
 		( 'fetch',),
-		'struct sess *'
+		'struct req *'
 	),
 	('beresp.keep',
 		'DURATION',
 		( 'fetch',),
 		( 'fetch',),
-		'struct sess *'
+		'struct req *'
 	),
 	('beresp.backend.name',
 		'STRING',
 		( 'fetch',),
 		( ),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('beresp.backend.ip',
 		'IP',
 		( 'fetch',),
 		( ),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('beresp.backend.port',
 		'INT',
 		( 'fetch',),
 		( ),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('beresp.storage',
 		'STRING',
 		( 'fetch',),
 		( 'fetch',),
-		'struct sess *'
+		'struct req *'
 	),
 	('obj.proto',
 		'STRING',
 		( 'hit', 'error',),
 		( 'hit', 'error',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('obj.status',
 		'INT',
 		( 'error',),
 		( 'error',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('obj.response',
 		'STRING',
 		( 'error',),
 		( 'error',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('obj.hits',
 		'INT',
 		( 'hit', 'deliver',),
 		( ),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('obj.http.',
 		'HDR_OBJ',
 		( 'hit', 'error',),
 		( 'error',),		# XXX ?
-		'const struct sess *'
+		'const struct req *'
 	),
 	('obj.ttl',
 		'DURATION',
 		( 'hit', 'error',),
 		( 'hit', 'error',),
-		'struct sess *'
+		'struct req *'
 	),
 	('obj.grace',
 		'DURATION',
 		( 'hit', 'error',),
 		( 'hit', 'error',),
-		'struct sess *'
+		'struct req *'
 	),
 	('obj.keep',
 		'DURATION',
 		( 'hit', 'error',),
 		( 'hit', 'error',),
-		'struct sess *'
+		'struct req *'
 	),
 	('obj.lastuse',
 		'DURATION',
 		( 'hit', 'deliver', 'error',),
 		( ),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('resp.proto',
 		'STRING',
 		( 'deliver',),
 		( 'deliver',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('resp.status',
 		'INT',
 		( 'deliver',),
 		( 'deliver',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('resp.response',
 		'STRING',
 		( 'deliver',),
 		( 'deliver',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('resp.http.',
 		'HDR_RESP',
 		( 'deliver',),
 		( 'deliver',),
-		'const struct sess *'
+		'const struct req *'
 	),
 	('now',
 		'TIME',
 		( 'all',),
 		( ),
-		'const struct sess *'
+		'const struct req *'
 	),
 )
 
@@ -831,7 +831,7 @@ for i in sp_variables:
 	fo.write("\t{ \"%s\", %s, %d,\n" % (i[0], typ, len(i[0])))
 
 	if len(i[2]) > 0:
-		fo.write('\t    "VRT_r_%s(sp)",\n' % cnam)
+		fo.write('\t    "VRT_r_%s(req)",\n' % cnam)
 		if typ != "HEADER":
 			fh.write(ctyp + " VRT_r_%s(%s);\n" % (cnam, i[4]))
 	else:
@@ -839,7 +839,7 @@ for i in sp_variables:
 	restrict(fo, i[2])
 
 	if len(i[3]) > 0:
-		fo.write('\t    "VRT_l_%s(sp, ",\n' % cnam)
+		fo.write('\t    "VRT_l_%s(req, ",\n' % cnam)
 		if typ != "HEADER":
 			fh.write("void VRT_l_%s(%s, " % (cnam, i[4]))
 			if typ != "STRING":



From phk at varnish-cache.org  Mon Jun 18 08:31:33 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Mon, 18 Jun 2012 10:31:33 +0200
Subject: [master] b4d76fe Move more of the VRT interface from 'sp' to 'req'
Message-ID: <E1SgXMz-0008ET-4Z@project.varnish-software.com>

commit b4d76fea32541ffa008e6187faa1ffd21919a5e5
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Mon Jun 18 08:31:14 2012 +0000

    Move more of the VRT interface from 'sp' to 'req'

diff --git a/bin/varnishd/cache/cache_hash.c b/bin/varnishd/cache/cache_hash.c
index 79efc69..d288e3d 100644
--- a/bin/varnishd/cache/cache_hash.c
+++ b/bin/varnishd/cache/cache_hash.c
@@ -156,20 +156,21 @@ HSH_DeleteObjHead(struct dstat *ds, struct objhead *oh)
 }
 
 void
-HSH_AddString(const struct sess *sp, const char *str)
+HSH_AddString(struct req *req, const char *str)
 {
 	int l;
 
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	if (str == NULL)
 		str = "";
 	l = strlen(str);
 
-	AN(sp->req->sha256ctx);
-	SHA256_Update(sp->req->sha256ctx, str, l);
-	SHA256_Update(sp->req->sha256ctx, "#", 1);
+	AN(req->sha256ctx);
+	SHA256_Update(req->sha256ctx, str, l);
+	SHA256_Update(req->sha256ctx, "#", 1);
 
 	if (cache_param->log_hash)
-		VSLb(sp->req->vsl, SLT_Hash, "%s", str);
+		VSLb(req->vsl, SLT_Hash, "%s", str);
 }
 
 /*---------------------------------------------------------------------
diff --git a/bin/varnishd/cache/cache_vrt.c b/bin/varnishd/cache/cache_vrt.c
index 524a9b2..f1b1f3c 100644
--- a/bin/varnishd/cache/cache_vrt.c
+++ b/bin/varnishd/cache/cache_vrt.c
@@ -93,27 +93,27 @@ VRT_acl_log(const struct sess *sp, const char *msg)
 /*--------------------------------------------------------------------*/
 
 static struct http *
-vrt_selecthttp(const struct sess *sp, enum gethdr_e where)
+vrt_selecthttp(const struct req *req, enum gethdr_e where)
 {
 	struct http *hp;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	switch (where) {
 	case HDR_REQ:
-		hp = sp->req->http;
+		hp = req->http;
 		break;
 	case HDR_BEREQ:
-		hp = sp->req->busyobj->bereq;
+		hp = req->busyobj->bereq;
 		break;
 	case HDR_BERESP:
-		hp = sp->req->busyobj->beresp;
+		hp = req->busyobj->beresp;
 		break;
 	case HDR_RESP:
-		hp = sp->req->resp;
+		hp = req->resp;
 		break;
 	case HDR_OBJ:
-		CHECK_OBJ_NOTNULL(sp->req->obj, OBJECT_MAGIC);
-		hp = sp->req->obj->http;
+		CHECK_OBJ_NOTNULL(req->obj, OBJECT_MAGIC);
+		hp = req->obj->http;
 		break;
 	default:
 		INCOMPL();
@@ -123,13 +123,13 @@ vrt_selecthttp(const struct sess *sp, enum gethdr_e where)
 }
 
 char *
-VRT_GetHdr(const struct sess *sp, enum gethdr_e where, const char *n)
+VRT_GetHdr(const struct req *req, enum gethdr_e where, const char *n)
 {
 	char *p;
 	struct http *hp;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	hp = vrt_selecthttp(sp, where);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	hp = vrt_selecthttp(req, where);
 	if (!http_GetHdr(hp, n, &p))
 		return (NULL);
 	return (p);
@@ -215,22 +215,22 @@ VRT_WrkString(const struct sess *sp, const char *p, ...)
 /*--------------------------------------------------------------------*/
 
 void
-VRT_SetHdr(const struct sess *sp , enum gethdr_e where, const char *hdr,
+VRT_SetHdr(struct req *req , enum gethdr_e where, const char *hdr,
     const char *p, ...)
 {
 	struct http *hp;
 	va_list ap;
 	char *b;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	hp = vrt_selecthttp(sp, where);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	hp = vrt_selecthttp(req, where);
 	va_start(ap, p);
 	if (p == NULL) {
 		http_Unset(hp, hdr);
 	} else {
 		b = VRT_String(hp->ws, hdr + 1, p, ap);
 		if (b == NULL) {
-			VSLb(sp->req->vsl, SLT_LostHeader, "%s", hdr + 1);
+			VSLb(req->vsl, SLT_LostHeader, "%s", hdr + 1);
 		} else {
 			http_Unset(hp, hdr);
 			http_SetHeader(hp, b);
@@ -242,16 +242,16 @@ VRT_SetHdr(const struct sess *sp , enum gethdr_e where, const char *hdr,
 /*--------------------------------------------------------------------*/
 
 void
-VRT_handling(const struct sess *sp, unsigned hand)
+VRT_handling(struct req *req, unsigned hand)
 {
 
-	if (sp == NULL) {
+	if (req == NULL) {
 		assert(hand == VCL_RET_OK);
 		return;
 	}
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	assert(hand < VCL_RET_MAX);
-	sp->req->handling = hand;
+	req->handling = hand;
 }
 
 /*--------------------------------------------------------------------
@@ -259,18 +259,18 @@ VRT_handling(const struct sess *sp, unsigned hand)
  */
 
 void
-VRT_hashdata(const struct sess *sp, const char *str, ...)
+VRT_hashdata(struct req *req, const char *str, ...)
 {
 	va_list ap;
 	const char *p;
 
-	HSH_AddString(sp, str);
+	HSH_AddString(req, str);
 	va_start(ap, str);
 	while (1) {
 		p = va_arg(ap, const char *);
 		if (p == vrt_magic_string_end)
 			break;
-		HSH_AddString(sp, p);
+		HSH_AddString(req, p);
 	}
 }
 
diff --git a/bin/varnishd/hash/hash_slinger.h b/bin/varnishd/hash/hash_slinger.h
index cbf62ba..7eb1b14 100644
--- a/bin/varnishd/hash/hash_slinger.h
+++ b/bin/varnishd/hash/hash_slinger.h
@@ -29,6 +29,7 @@
  */
 
 struct sess;
+struct req;
 struct worker;
 struct object;
 
@@ -56,7 +57,7 @@ struct objcore *HSH_Lookup(struct sess *sp);
 void HSH_Ref(struct objcore *o);
 void HSH_Drop(struct worker *, struct object **);
 void HSH_Init(const struct hash_slinger *slinger);
-void HSH_AddString(const struct sess *sp, const char *str);
+void HSH_AddString(struct req *, const char *str);
 void HSH_Insert(struct worker *, const void *hash, struct objcore *);
 void HSH_Purge(const struct sess *, struct objhead *, double ttl, double grace);
 void HSH_config(const char *h_arg);
diff --git a/include/vrt.h b/include/vrt.h
index 0b122ec..dc5ba13 100644
--- a/include/vrt.h
+++ b/include/vrt.h
@@ -161,12 +161,12 @@ void VRT_error(const struct sess *, unsigned, const char *);
 int VRT_switch_config(const char *);
 
 enum gethdr_e { HDR_REQ, HDR_RESP, HDR_OBJ, HDR_BEREQ, HDR_BERESP };
-char *VRT_GetHdr(const struct sess *, enum gethdr_e where, const char *);
-void VRT_SetHdr(const struct sess *, enum gethdr_e where, const char *,
+char *VRT_GetHdr(const struct req *, enum gethdr_e where, const char *);
+void VRT_SetHdr(struct req *, enum gethdr_e where, const char *,
     const char *, ...);
-void VRT_handling(const struct sess *sp, unsigned hand);
+void VRT_handling(struct req *, unsigned hand);
 
-void VRT_hashdata(const struct sess *sp, const char *str, ...);
+void VRT_hashdata(struct req *, const char *str, ...);
 
 /* Simple stuff */
 int VRT_strcmp(const char *s1, const char *s2);
@@ -217,9 +217,9 @@ char *VRT_time_string(const struct sess *sp, double);
 const char *VRT_bool_string(const struct sess *sp, unsigned);
 const char *VRT_backend_string(const struct sess *sp, const struct director *d);
 
-#define VRT_done(sp, hand)			\
+#define VRT_done(req, hand)			\
 	do {					\
-		VRT_handling(sp, hand);		\
+		VRT_handling(req, hand);	\
 		return (1);			\
 	} while (0)
 
diff --git a/lib/libvcl/vcc_action.c b/lib/libvcl/vcc_action.c
index e725c6d..31a940b 100644
--- a/lib/libvcl/vcc_action.c
+++ b/lib/libvcl/vcc_action.c
@@ -77,7 +77,7 @@ parse_error(struct vcc *tl)
 			Fb(tl, 1, ", 0\n");
 	}
 	Fb(tl, 1, ");\n");
-	Fb(tl, 1, "VRT_done(sp, VCL_RET_ERROR);\n");
+	Fb(tl, 1, "VRT_done(req, VCL_RET_ERROR);\n");
 }
 
 /*--------------------------------------------------------------------*/
@@ -224,7 +224,7 @@ parse_hash_data(struct vcc *tl)
 	vcc_NextToken(tl);
 	SkipToken(tl, '(');
 
-	Fb(tl, 1, "VRT_hashdata(sp, ");
+	Fb(tl, 1, "VRT_hashdata(req, ");
 	vcc_Expr(tl, STRING_LIST);
 	ERRCHK(tl);
 	Fb(tl, 0, ");\n");
@@ -259,7 +259,7 @@ parse_return(struct vcc *tl)
 #define VCL_RET_MAC(l, U, B)						\
 	do {								\
 		if (vcc_IdIs(tl->t, #l)) {				\
-			Fb(tl, 1, "VRT_done(sp, VCL_RET_" #U ");\n");	\
+			Fb(tl, 1, "VRT_done(req, VCL_RET_" #U ");\n");	\
 			vcc_ProcAction(tl->curproc, VCL_RET_##U, tl->t);\
 			retval = 1;					\
 		}							\
diff --git a/lib/libvcl/vcc_var.c b/lib/libvcl/vcc_var.c
index 1bbac15..aa728e6 100644
--- a/lib/libvcl/vcc_var.c
+++ b/lib/libvcl/vcc_var.c
@@ -59,10 +59,10 @@ vcc_Var_Wildcard(struct vcc *tl, const struct token *t, const struct symbol *wc)
 
 	bprintf(buf, "\\%03o%s:", (unsigned)l, v->name + vh->len);
 	v->hdr = TlDup(tl, buf);
-	bprintf(buf, "VRT_GetHdr(sp, %s, \"%s\")", v->http, v->hdr);
+	bprintf(buf, "VRT_GetHdr(req, %s, \"%s\")", v->http, v->hdr);
 	v->rname = TlDup(tl, buf);
 
-	bprintf(buf, "VRT_SetHdr(sp, %s, \"%s\", ", v->http, v->hdr);
+	bprintf(buf, "VRT_SetHdr(req, %s, \"%s\", ", v->http, v->hdr);
 	v->lname = TlDup(tl, buf);
 
 	sym = VCC_AddSymbolTok(tl, t, SYM_VAR);



From phk at varnish-cache.org  Mon Jun 18 08:49:12 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Mon, 18 Jun 2012 10:49:12 +0200
Subject: [master] 56ce6e3 More VRT sp->req work
Message-ID: <E1SgXe4-000149-Pc@project.varnish-software.com>

commit 56ce6e353960411f281a5114993ef2e7f51cf3dd
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Mon Jun 18 08:48:53 2012 +0000

    More VRT sp->req work

diff --git a/bin/varnishd/cache/cache_vrt.c b/bin/varnishd/cache/cache_vrt.c
index f1b1f3c..5675311 100644
--- a/bin/varnishd/cache/cache_vrt.c
+++ b/bin/varnishd/cache/cache_vrt.c
@@ -54,17 +54,16 @@ const void * const vrt_magic_string_end = &vrt_magic_string_end;
 /*--------------------------------------------------------------------*/
 
 void
-VRT_error(const struct sess *sp, unsigned code, const char *reason)
+VRT_error(struct req *req, unsigned code, const char *reason)
 {
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	VSLb(sp->req->vsl, SLT_Debug, "VCL_error(%u, %s)", code, reason ?
-	    reason : "(null)");
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	VSLb(req->vsl, SLT_Debug, "VCL_error(%u, %s)", code,
+	    reason ?  reason : "(null)");
 	if (code < 100 || code > 999)
 		code = 503;
-	sp->req->err_code = (uint16_t)code;
-	sp->req->err_reason =
-	    reason ? reason : http_StatusMessage(sp->req->err_code);
+	req->err_code = (uint16_t)code;
+	req->err_reason = reason ? reason : http_StatusMessage(req->err_code);
 }
 
 /*--------------------------------------------------------------------*/
@@ -196,18 +195,18 @@ VRT_String(struct ws *ws, const char *h, const char *p, va_list ap)
 }
 
 /*--------------------------------------------------------------------
- * Build a string on the worker threads workspace
+ * Build a string on the request workspace
  */
 
 const char *
-VRT_WrkString(const struct sess *sp, const char *p, ...)
+VRT_ReqString(struct req *req, const char *p, ...)
 {
 	va_list ap;
 	char *b;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	va_start(ap, p);
-	b = VRT_String(sp->wrk->aws, NULL, p, ap);
+	b = VRT_String(req->ws, NULL, p, ap);
 	va_end(ap);
 	return (b);
 }
@@ -287,7 +286,7 @@ VRT_r_now(const struct req *req)
 /*--------------------------------------------------------------------*/
 
 char *
-VRT_IP_string(const struct sess *sp, const struct sockaddr_storage *sa)
+VRT_IP_string(struct req *req, const struct sockaddr_storage *sa)
 {
 	char *p;
 	const struct sockaddr_in *si4;
@@ -295,6 +294,7 @@ VRT_IP_string(const struct sess *sp, const struct sockaddr_storage *sa)
 	const void *addr;
 	int len;
 
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	switch (sa->ss_family) {
 	case AF_INET:
 		len = INET_ADDRSTRLEN;
@@ -310,61 +310,65 @@ VRT_IP_string(const struct sess *sp, const struct sockaddr_storage *sa)
 		INCOMPL();
 	}
 	XXXAN(len);
-	AN(p = WS_Alloc(sp->req->http->ws, len));
+	AN(p = WS_Alloc(req->http->ws, len));
 	AN(inet_ntop(sa->ss_family, addr, p, len));
 	return (p);
 }
 
 char *
-VRT_int_string(const struct sess *sp, int num)
+VRT_int_string(struct req *req, int num)
 {
 	char *p;
 	int size;
 
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	size = snprintf(NULL, 0, "%d", num) + 1;
-	AN(p = WS_Alloc(sp->req->http->ws, size));
+	AN(p = WS_Alloc(req->http->ws, size));
 	assert(snprintf(p, size, "%d", num) < size);
 	return (p);
 }
 
 char *
-VRT_double_string(const struct sess *sp, double num)
+VRT_double_string(struct req *req, double num)
 {
 	char *p;
 	int size;
 
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	size = snprintf(NULL, 0, "%.3f", num) + 1;
-	AN(p = WS_Alloc(sp->req->http->ws, size));
+	AN(p = WS_Alloc(req->http->ws, size));
 	assert(snprintf(p, size, "%.3f", num) < size);
 	return (p);
 }
 
 char *
-VRT_time_string(const struct sess *sp, double t)
+VRT_time_string(struct req *req, double t)
 {
 	char *p;
 
-	AN(p = WS_Alloc(sp->req->http->ws, VTIM_FORMAT_SIZE));
-	VTIM_format(t, p);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	p = WS_Alloc(req->http->ws, VTIM_FORMAT_SIZE);
+	if (p != NULL)
+		VTIM_format(t, p);
 	return (p);
 }
 
 const char *
-VRT_backend_string(const struct sess *sp, const struct director *d)
+VRT_backend_string(const struct req *req, const struct director *d)
 {
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	if (d == NULL)
-		d = sp->req->director;
+		d = req->director;
 	if (d == NULL)
 		return (NULL);
 	return (d->vcl_name);
 }
 
 const char *
-VRT_bool_string(const struct sess *sp, unsigned val)
+VRT_bool_string(const struct req *req, unsigned val)
 {
 
-	(void)sp;
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	return (val ? "true" : "false");
 }
 
@@ -395,16 +399,16 @@ VRT_panic(const struct sess *sp, const char *str, ...)
 /*--------------------------------------------------------------------*/
 
 void
-VRT_synth_page(const struct sess *sp, unsigned flags, const char *str, ...)
+VRT_synth_page(struct req *req, unsigned flags, const char *str, ...)
 {
 	va_list ap;
 	const char *p;
 	struct vsb *vsb;
 
 	(void)flags;
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	CHECK_OBJ_NOTNULL(sp->req->obj, OBJECT_MAGIC);
-	vsb = SMS_Makesynth(sp->req->obj);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	CHECK_OBJ_NOTNULL(req->obj, OBJECT_MAGIC);
+	vsb = SMS_Makesynth(req->obj);
 	AN(vsb);
 
 	VSB_cat(vsb, str);
@@ -417,10 +421,9 @@ VRT_synth_page(const struct sess *sp, unsigned flags, const char *str, ...)
 		p = va_arg(ap, const char *);
 	}
 	va_end(ap);
-	SMS_Finish(sp->req->obj);
-	http_Unset(sp->req->obj->http, H_Content_Length);
-	http_PrintfHeader(sp->req->obj->http,
-	    "Content-Length: %zd", sp->req->obj->len);
+	SMS_Finish(req->obj);
+	http_Unset(req->obj->http, H_Content_Length);
+	http_PrintfHeader(req->obj->http, "Content-Length: %zd", req->obj->len);
 }
 
 /*--------------------------------------------------------------------*/
diff --git a/include/vrt.h b/include/vrt.h
index dc5ba13..a6a2642 100644
--- a/include/vrt.h
+++ b/include/vrt.h
@@ -157,7 +157,7 @@ void VRT_purge(const struct sess *sp, double ttl, double grace);
 
 void VRT_count(struct req *, unsigned);
 int VRT_rewrite(const char *, const char *);
-void VRT_error(const struct sess *, unsigned, const char *);
+void VRT_error(struct req *, unsigned, const char *);
 int VRT_switch_config(const char *);
 
 enum gethdr_e { HDR_REQ, HDR_RESP, HDR_OBJ, HDR_BEREQ, HDR_BERESP };
@@ -176,7 +176,7 @@ void VRT_ESI(const struct sess *sp);
 void VRT_Rollback(const struct sess *sp);
 
 /* Synthetic pages */
-void VRT_synth_page(const struct sess *sp, unsigned flags, const char *, ...);
+void VRT_synth_page(struct req *sp, unsigned flags, const char *, ...);
 
 /* Backend related */
 void VRT_init_dir(struct cli *, struct director **, const char *name,
@@ -210,12 +210,12 @@ int VRT_Stv(const char *nm);
 
 /* Convert things to string */
 
-char *VRT_IP_string(const struct sess *sp, const struct sockaddr_storage *sa);
-char *VRT_int_string(const struct sess *sp, int);
-char *VRT_double_string(const struct sess *sp, double);
-char *VRT_time_string(const struct sess *sp, double);
-const char *VRT_bool_string(const struct sess *sp, unsigned);
-const char *VRT_backend_string(const struct sess *sp, const struct director *d);
+char *VRT_IP_string(struct req *, const struct sockaddr_storage *sa);
+char *VRT_int_string(struct req *, int);
+char *VRT_double_string(struct req *, double);
+char *VRT_time_string(struct req *, double);
+const char *VRT_bool_string(const struct req *, unsigned);
+const char *VRT_backend_string(const struct req *, const struct director *d);
 
 #define VRT_done(req, hand)			\
 	do {					\
@@ -223,4 +223,4 @@ const char *VRT_backend_string(const struct sess *sp, const struct director *d);
 		return (1);			\
 	} while (0)
 
-const char *VRT_WrkString(const struct sess *sp, const char *p, ...);
+const char *VRT_ReqString(struct req *, const char *p, ...);
diff --git a/lib/libvcl/vcc_action.c b/lib/libvcl/vcc_action.c
index 31a940b..31b2bad 100644
--- a/lib/libvcl/vcc_action.c
+++ b/lib/libvcl/vcc_action.c
@@ -57,7 +57,7 @@ parse_error(struct vcc *tl)
 {
 
 	vcc_NextToken(tl);
-	Fb(tl, 1, "VRT_error(sp,\n");
+	Fb(tl, 1, "VRT_error(req,\n");
 	if (tl->t->tok == '(') {
 		vcc_NextToken(tl);
 		vcc_Expr(tl, INT);
@@ -303,7 +303,7 @@ parse_synthetic(struct vcc *tl)
 {
 	vcc_NextToken(tl);
 
-	Fb(tl, 1, "VRT_synth_page(sp, 0, ");
+	Fb(tl, 1, "VRT_synth_page(req, 0, ");
 	vcc_Expr(tl, STRING_LIST);
 	ERRCHK(tl);
 	Fb(tl, 0, ");\n");
diff --git a/lib/libvcl/vcc_expr.c b/lib/libvcl/vcc_expr.c
index 19a455c..d964ff1 100644
--- a/lib/libvcl/vcc_expr.c
+++ b/lib/libvcl/vcc_expr.c
@@ -423,15 +423,15 @@ vcc_expr_tostring(struct expr **e, enum var_type fmt)
 
 	p = NULL;
 	switch((*e)->fmt) {
-	case BACKEND:	p = "VRT_backend_string(sp, \v1)"; break;
-	case BOOL:	p = "VRT_bool_string(sp, \v1)"; break;
-	case DURATION:	p = "VRT_double_string(sp, \v1)"; break;
+	case BACKEND:	p = "VRT_backend_string(req, \v1)"; break;
+	case BOOL:	p = "VRT_bool_string(req, \v1)"; break;
+	case DURATION:	p = "VRT_double_string(req, \v1)"; break;
 			 /* XXX: should DURATION insist on "s" suffix ? */
-	case INT:	p = "VRT_int_string(sp, \v1)"; break;
-	case IP:	p = "VRT_IP_string(sp, \v1)"; break;
-	case BYTES:	p = "VRT_double_string(sp, \v1)"; break; /* XXX */
-	case REAL:	p = "VRT_double_string(sp, \v1)"; break;
-	case TIME:	p = "VRT_time_string(sp, \v1)"; break;
+	case INT:	p = "VRT_int_string(req, \v1)"; break;
+	case IP:	p = "VRT_IP_string(req, \v1)"; break;
+	case BYTES:	p = "VRT_double_string(req, \v1)"; break; /* XXX */
+	case REAL:	p = "VRT_double_string(req, \v1)"; break;
+	case TIME:	p = "VRT_time_string(req, \v1)"; break;
 	default:	break;
 	}
 	if (p != NULL) {
@@ -819,7 +819,7 @@ vcc_expr_add(struct vcc *tl, struct expr **e, enum var_type fmt)
 	}
 	if (fmt != STRING_LIST && (*e)->fmt == STRING_LIST)
 		*e = vcc_expr_edit(STRING,
-		    "\v+VRT_WrkString(sp,\n\v1,\nvrt_magic_string_end)",
+		    "\v+VRT_ReqString(req,\n\v1,\nvrt_magic_string_end)",
 		    *e, NULL);
 	if (fmt == STRING_LIST && (*e)->fmt == STRING)
 		(*e)->fmt = STRING_LIST;



From tfheen at varnish-cache.org  Mon Jun 18 09:13:32 2012
From: tfheen at varnish-cache.org (Tollef Fog Heen)
Date: Mon, 18 Jun 2012 11:13:32 +0200
Subject: [master] 48345b6 Use older libtool invocation to please EL5 users.
	Welcome to 2005.
Message-ID: <E1SgY1c-0002Kl-Ho@project.varnish-software.com>

commit 48345b63af6a00b79f20b873280e87dd75d4253e
Author: Tollef Fog Heen <tfheen at varnish-software.com>
Date:   Mon Jun 18 11:13:17 2012 +0200

    Use older libtool invocation to please EL5 users. Welcome to 2005.

diff --git a/configure.ac b/configure.ac
index 8193874..3df1e7d 100644
--- a/configure.ac
+++ b/configure.ac
@@ -13,7 +13,8 @@ AC_CANONICAL_SYSTEM
 AC_LANG(C)
 
 AM_INIT_AUTOMAKE([foreign])
-LT_INIT([disable-static])
+AC_DISABLE_STATIC
+AC_PROG_LIBTOOL
 
 # Checks for programs.
 AC_GNU_SOURCE



From phk at varnish-cache.org  Mon Jun 18 09:13:41 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Mon, 18 Jun 2012 11:13:41 +0200
Subject: [master] acab05e More VRT sp->req movements
Message-ID: <E1SgY1l-0002PP-R0@project.varnish-software.com>

commit acab05e046bad0f194a699d229b981ee8d5ffecc
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Mon Jun 18 09:13:27 2012 +0000

    More VRT sp->req movements

diff --git a/bin/varnishd/cache/cache_vrt.c b/bin/varnishd/cache/cache_vrt.c
index 5675311..d227949 100644
--- a/bin/varnishd/cache/cache_vrt.c
+++ b/bin/varnishd/cache/cache_vrt.c
@@ -83,10 +83,10 @@ VRT_count(struct req *req, unsigned u)
 /*--------------------------------------------------------------------*/
 
 void
-VRT_acl_log(const struct sess *sp, const char *msg)
+VRT_acl_log(struct req *req, const char *msg)
 {
 
-	VSLb(sp->req->vsl, SLT_VCL_acl, "%s", msg);
+	VSLb(req->vsl, SLT_VCL_acl, "%s", msg);
 }
 
 /*--------------------------------------------------------------------*/
@@ -385,13 +385,14 @@ VRT_Rollback(const struct sess *sp)
 /*--------------------------------------------------------------------*/
 
 void
-VRT_panic(const struct sess *sp, const char *str, ...)
+VRT_panic(struct req *req, const char *str, ...)
 {
 	va_list ap;
 	char *b;
 
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	va_start(ap, str);
-	b = VRT_String(sp->req->http->ws, "PANIC: ", str, ap);
+	b = VRT_String(req->http->ws, "PANIC: ", str, ap);
 	va_end(ap);
 	VAS_Fail("VCL", "", 0, b, 0, 2);
 }
diff --git a/bin/varnishd/cache/cache_vrt_re.c b/bin/varnishd/cache/cache_vrt_re.c
index 765cd27..e4b9750 100644
--- a/bin/varnishd/cache/cache_vrt_re.c
+++ b/bin/varnishd/cache/cache_vrt_re.c
@@ -62,11 +62,12 @@ VRT_re_fini(void *rep)
 }
 
 int
-VRT_re_match(const struct sess *sp, const char *s, void *re)
+VRT_re_match(struct req *req, const char *s, void *re)
 {
 	vre_t *t;
 	int i;
 
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	if (s == NULL)
 		s = "";
 	AN(re);
@@ -75,13 +76,12 @@ VRT_re_match(const struct sess *sp, const char *s, void *re)
 	if (i >= 0)
 		return (1);
 	if (i < VRE_ERROR_NOMATCH )
-		VSLb(sp->req->vsl, SLT_VCL_Error,
-		    "Regexp matching returned %d", i);
+		VSLb(req->vsl, SLT_VCL_Error, "Regexp matching returned %d", i);
 	return (0);
 }
 
 const char *
-VRT_regsub(const struct sess *sp, int all, const char *str, void *re,
+VRT_regsub(struct req *req, int all, const char *str, void *re,
     const char *sub)
 {
 	int ovector[30];
@@ -94,6 +94,7 @@ VRT_regsub(const struct sess *sp, int all, const char *str, void *re,
 	int options = 0;
 	size_t len;
 
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	AN(re);
 	if (str == NULL)
 		str = "";
@@ -109,13 +110,12 @@ VRT_regsub(const struct sess *sp, int all, const char *str, void *re,
 	if (i == VRE_ERROR_NOMATCH)
 		return(str);
 	if (i < VRE_ERROR_NOMATCH ) {
-		VSLb(sp->req->vsl, SLT_VCL_Error,
-		    "Regexp matching returned %d", i);
+		VSLb(req->vsl, SLT_VCL_Error, "Regexp matching returned %d", i);
 		return(str);
 	}
 
-	u = WS_Reserve(sp->req->http->ws, 0);
-	res.e = res.b = b0 = sp->req->http->ws->f;
+	u = WS_Reserve(req->http->ws, 0);
+	res.e = res.b = b0 = req->http->ws->f;
 	res.e += u;
 
 	do {
@@ -147,8 +147,8 @@ VRT_regsub(const struct sess *sp, int all, const char *str, void *re,
 		i = VRE_exec(t, str, len, 0, options, ovector, 30,
 		    &cache_param->vre_limits);
 		if (i < VRE_ERROR_NOMATCH ) {
-			WS_Release(sp->req->http->ws, 0);
-			VSLb(sp->req->vsl, SLT_VCL_Error,
+			WS_Release(req->http->ws, 0);
+			VSLb(req->vsl, SLT_VCL_Error,
 			    "Regexp matching returned %d", i);
 			return(str);
 		}
@@ -157,10 +157,10 @@ VRT_regsub(const struct sess *sp, int all, const char *str, void *re,
 	/* Copy suffix to match */
 	Tadd(&res, str, len+1);
 	if (res.b >= res.e) {
-		WS_Release(sp->req->http->ws, 0);
+		WS_Release(req->http->ws, 0);
 		return (str);
 	}
 	Tcheck(res);
-	WS_ReleaseP(sp->req->http->ws, res.b);
+	WS_ReleaseP(req->http->ws, res.b);
 	return (b0);
 }
diff --git a/include/vrt.h b/include/vrt.h
index a6a2642..50d4d8b 100644
--- a/include/vrt.h
+++ b/include/vrt.h
@@ -141,16 +141,16 @@ struct vrt_ref {
 /* ACL related */
 #define VRT_ACL_MAXADDR		16	/* max(IPv4, IPv6) */
 
-void VRT_acl_log(const struct sess *, const char *msg);
+void VRT_acl_log(struct req *, const char *msg);
 
 /* Regexp related */
 void VRT_re_init(void **, const char *);
 void VRT_re_fini(void *);
-int VRT_re_match(const struct sess *sp, const char *, void *re);
-const char *VRT_regsub(const struct sess *sp, int all, const char *,
+int VRT_re_match(struct req *, const char *, void *re);
+const char *VRT_regsub(struct req *, int all, const char *,
     void *, const char *);
 
-void VRT_panic(const struct sess *sp, const char *, ...);
+void VRT_panic(struct req *req, const char *, ...);
 void VRT_ban(struct sess *sp, char *, ...);
 void VRT_ban_string(struct sess *sp, const char *);
 void VRT_purge(const struct sess *sp, double ttl, double grace);
diff --git a/lib/libvcl/vcc_acl.c b/lib/libvcl/vcc_acl.c
index 9535f59..3e037ec 100644
--- a/lib/libvcl/vcc_acl.c
+++ b/lib/libvcl/vcc_acl.c
@@ -357,7 +357,7 @@ vcc_acl_emit(const struct vcc *tl, const char *acln, int anon)
 	const char *oc;
 
 	Fh(tl, 0, "\nstatic int\n");
-	Fh(tl, 0, "match_acl_%s_%s(const struct sess *sp, const void *p)\n",
+	Fh(tl, 0, "match_acl_%s_%s(struct req *req, const void *p)\n",
 	    anon ? "anon" : "named", acln);
 	Fh(tl, 0, "{\n");
 	Fh(tl, 0, "\tconst unsigned char *a;\n");
@@ -372,7 +372,7 @@ vcc_acl_emit(const struct vcc *tl, const char *acln, int anon)
 	Fh(tl, 0, "\telse if (fam == %d)\n", PF_INET6);
 	Fh(tl, 0, "\t\ta += %zd;\n", offsetof(struct sockaddr_in6, sin6_addr));
 	Fh(tl, 0, "\telse {\n");
-	Fh(tl, 0, "\t\tVRT_acl_log(sp, \"NO_FAM %s\");\n", acln);
+	Fh(tl, 0, "\t\tVRT_acl_log(req, \"NO_FAM %s\");\n", acln);
 	Fh(tl, 0, "\t\treturn(0);\n");
 	Fh(tl, 0, "\t}\n\n");
 	depth = -1;
@@ -424,7 +424,7 @@ vcc_acl_emit(const struct vcc *tl, const char *acln, int anon)
 		i = (ae->mask + 7) / 8;
 
 		if (!anon) {
-			Fh(tl, 0, "\t%*sVRT_acl_log(sp, \"%sMATCH %s \" ",
+			Fh(tl, 0, "\t%*sVRT_acl_log(req, \"%sMATCH %s \" ",
 			    -i, "", ae->not ? "NEG_" : "", acln);
 			EncToken(tl->fh, ae->t_addr);
 			if (ae->t_mask != NULL)
@@ -441,7 +441,7 @@ vcc_acl_emit(const struct vcc *tl, const char *acln, int anon)
 
 	/* Deny by default */
 	if (!anon)
-		Fh(tl, 0, "\tVRT_acl_log(sp, \"NO_MATCH %s\");\n", acln);
+		Fh(tl, 0, "\tVRT_acl_log(req, \"NO_MATCH %s\");\n", acln);
 	Fh(tl, 0, "\treturn (0);\n}\n");
 }
 
@@ -457,7 +457,7 @@ vcc_Acl_Hack(struct vcc *tl, char *b)
 	bprintf(acln, "%u", tl->unique++);
 	vcc_acl_entry(tl);
 	vcc_acl_emit(tl, acln, 1);
-	sprintf(b, "%smatch_acl_anon_%s(sp, \v1)",
+	sprintf(b, "%smatch_acl_anon_%s(req, \v1)",
 	    (tcond == T_NEQ ? "!" : ""), acln);
 }
 
diff --git a/lib/libvcl/vcc_action.c b/lib/libvcl/vcc_action.c
index 31b2bad..d60b885 100644
--- a/lib/libvcl/vcc_action.c
+++ b/lib/libvcl/vcc_action.c
@@ -238,7 +238,7 @@ parse_panic(struct vcc *tl)
 {
 	vcc_NextToken(tl);
 
-	Fb(tl, 1, "VRT_panic(sp, ");
+	Fb(tl, 1, "VRT_panic(req, ");
 	vcc_Expr(tl, STRING);
 	ERRCHK(tl);
 	Fb(tl, 0, ", vrt_magic_string_end);\n");
diff --git a/lib/libvcl/vcc_expr.c b/lib/libvcl/vcc_expr.c
index d964ff1..a3ef4b6 100644
--- a/lib/libvcl/vcc_expr.c
+++ b/lib/libvcl/vcc_expr.c
@@ -466,7 +466,7 @@ vcc_Eval_Regsub(struct vcc *tl, struct expr **e, const struct symbol *sym)
 	p = vcc_regexp(tl);
 	vcc_NextToken(tl);
 
-	bprintf(buf, "VRT_regsub(sp, %d,\n\v1,\n%s\n", all, p);
+	bprintf(buf, "VRT_regsub(req, %d,\n\v1,\n%s\n", all, p);
 	*e = vcc_expr_edit(STRING, buf, e2, *e);
 
 	SkipToken(tl, ',');
@@ -947,7 +947,7 @@ vcc_expr_cmp(struct vcc *tl, struct expr **e, enum var_type fmt)
 		re = vcc_regexp(tl);
 		ERRCHK(tl);
 		vcc_NextToken(tl);
-		bprintf(buf, "%sVRT_re_match(sp, \v1, %s)", not, re);
+		bprintf(buf, "%sVRT_re_match(req, \v1, %s)", not, re);
 		*e = vcc_expr_edit(BOOL, buf, *e, NULL);
 		return;
 	}
@@ -957,7 +957,8 @@ vcc_expr_cmp(struct vcc *tl, struct expr **e, enum var_type fmt)
 		vcc_NextToken(tl);
 		ExpectErr(tl, ID);
 		vcc_AddRef(tl, tl->t, SYM_ACL);
-		bprintf(buf, "%smatch_acl_named_%.*s(sp, \v1)", not, PF(tl->t));
+		bprintf(buf, "%smatch_acl_named_%.*s(req, \v1)",
+		    not, PF(tl->t));
 		vcc_NextToken(tl);
 		*e = vcc_expr_edit(BOOL, buf, *e, NULL);
 		return;



From phk at varnish-cache.org  Mon Jun 18 09:13:41 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Mon, 18 Jun 2012 11:13:41 +0200
Subject: [master] a15dd15 Merge branch 'master' of
	ssh://git.varnish-cache.org/git/varnish-cache
Message-ID: <E1SgY1l-0002PV-SI@project.varnish-software.com>

commit a15dd15d81397489f2b3ac0ad4a1ef835f07b3d2
Merge: acab05e 48345b6
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Mon Jun 18 09:13:38 2012 +0000

    Merge branch 'master' of ssh://git.varnish-cache.org/git/varnish-cache



From phk at varnish-cache.org  Mon Jun 18 09:51:11 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Mon, 18 Jun 2012 11:51:11 +0200
Subject: [master] a20b6af Add a new VMOD.debug and move the stuff varnishtest
	uses to get out into the obscure corners over there,
	making vmod.std a better copy& paste example and removing things like
	"panic" from the VCC.
Message-ID: <E1SgYc3-0004jo-73@project.varnish-software.com>

commit a20b6af4f1d5353132d07d4baae6d9e9c822f896
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Mon Jun 18 09:50:18 2012 +0000

    Add a new VMOD.debug and move the stuff varnishtest uses to get out
    into the obscure corners over there, making vmod.std a better copy&
    paste example and removing things like "panic" from the VCC.

diff --git a/bin/varnishd/cache/cache_vrt.c b/bin/varnishd/cache/cache_vrt.c
index d227949..f172769 100644
--- a/bin/varnishd/cache/cache_vrt.c
+++ b/bin/varnishd/cache/cache_vrt.c
@@ -385,21 +385,6 @@ VRT_Rollback(const struct sess *sp)
 /*--------------------------------------------------------------------*/
 
 void
-VRT_panic(struct req *req, const char *str, ...)
-{
-	va_list ap;
-	char *b;
-
-	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
-	va_start(ap, str);
-	b = VRT_String(req->http->ws, "PANIC: ", str, ap);
-	va_end(ap);
-	VAS_Fail("VCL", "", 0, b, 0, 2);
-}
-
-/*--------------------------------------------------------------------*/
-
-void
 VRT_synth_page(struct req *req, unsigned flags, const char *str, ...)
 {
 	va_list ap;
diff --git a/bin/varnishd/flint.sh b/bin/varnishd/flint.sh
index 9067263..c32c01b 100755
--- a/bin/varnishd/flint.sh
+++ b/bin/varnishd/flint.sh
@@ -25,6 +25,7 @@ flexelint \
 	../../lib/libvarnishcompat/execinfo.c \
 	../../lib/libvcl/*.c \
 	../../lib/libvmod_std/*.c \
+	../../lib/libvmod_debug/*.c \
 	2>&1 | tee _.fl
 
 if [ -f _.fl.old ] ; then
diff --git a/bin/varnishtest/tests/m00000.vtc b/bin/varnishtest/tests/m00000.vtc
index 7fe2b8c..504601b 100644
--- a/bin/varnishtest/tests/m00000.vtc
+++ b/bin/varnishtest/tests/m00000.vtc
@@ -1,4 +1,4 @@
-varnishtest "Test std vmod"
+varnishtest "Test std & debug vmod"
 
 server s1 {
 	rxreq 
@@ -7,11 +7,14 @@ server s1 {
 
 varnish v1 -vcl+backend {
 	import std from "${topbuild}/lib/libvmod_std/.libs/libvmod_std.so" ;
+	import debug from "${topbuild}/lib/libvmod_debug/.libs/libvmod_debug.so" ;
 
 	sub vcl_deliver {
 		set resp.http.foo = std.toupper(resp.http.foo);
 		set resp.http.bar = std.tolower(resp.http.bar);
-		set resp.http.who = std.author(phk);
+		set resp.http.who = debug.author(phk);
+		debug.test_priv_call();
+		debug.test_priv_vcl();
 		std.log("VCL initiated log");
 		std.syslog(8 + 7, "Somebody runs varnishtest");
 	}
@@ -27,9 +30,9 @@ client c1 {
 } -run
 
 varnish v1 -badvcl {
-	import std from "${topbuild}/lib/libvmod_std/.libs/libvmod_std.so.1" ;
+	import debug from "${topbuild}/lib/libvmod_debug/.libs/libvmod_debug.so.1" ;
 	sub vcl_deliver {
-		set resp.http.who = std.author(jfk);
+		set resp.http.who = debug.author(jfk);
 	}
 }
 
diff --git a/bin/varnishtest/tests/r00878.vtc b/bin/varnishtest/tests/r00878.vtc
index 6997189..55106c9 100644
--- a/bin/varnishtest/tests/r00878.vtc
+++ b/bin/varnishtest/tests/r00878.vtc
@@ -6,9 +6,9 @@ server s1 {
 } -start
 
 varnish v1 -vcl+backend {
-        import std from "${topbuild}/lib/libvmod_std/.libs/libvmod_std.so" ;
+        import debug from "${topbuild}/lib/libvmod_debug/.libs/libvmod_debug.so" ;
 	sub vcl_deliver {
-		set resp.http.who = std.author(phk);
+		set resp.http.who = debug.author(phk);
 	}
 } -start
 
@@ -18,9 +18,9 @@ client c1 {
 	rxresp
 } -run
 varnish v1 -vcl+backend {
-        import std from "${topbuild}/lib/libvmod_std/.libs/libvmod_std.so" ;
+        import debug from "${topbuild}/lib/libvmod_debug/.libs/libvmod_debug.so" ;
 	sub vcl_deliver {
-		set resp.http.who = std.author(des);
+		set resp.http.who = debug.author(des);
 	}
 }
 
@@ -30,9 +30,9 @@ client c1 {
 } -run
 
 varnish v1 -vcl+backend {
-        import std from "${topbuild}/lib/libvmod_std/.libs/libvmod_std.so" ;
+        import debug from "${topbuild}/lib/libvmod_debug/.libs/libvmod_debug.so" ;
 	sub vcl_deliver {
-		set resp.http.who = std.author(kristian);
+		set resp.http.who = debug.author(kristian);
 	}
 }
 
diff --git a/bin/varnishtest/tests/v00010.vtc b/bin/varnishtest/tests/v00010.vtc
index b44fc13..46d778c 100644
--- a/bin/varnishtest/tests/v00010.vtc
+++ b/bin/varnishtest/tests/v00010.vtc
@@ -15,9 +15,11 @@ server s1 {
 
 varnish v1 -storage "-smalloc,1m" -vcl+backend {
 
+	import debug from "${topbuild}/lib/libvmod_debug/.libs/libvmod_debug.so";
+
 	sub vcl_deliver {
 		if (resp.http.panic) {
-			panic "Had Panic header: " + resp.http.panic;
+			debug.panic("Had Panic header: " + resp.http.panic);
 		}
 	}
 } -start
diff --git a/bin/varnishtest/tests/v00018.vtc b/bin/varnishtest/tests/v00018.vtc
index 2c129d7..d1c0d5f 100644
--- a/bin/varnishtest/tests/v00018.vtc
+++ b/bin/varnishtest/tests/v00018.vtc
@@ -101,11 +101,6 @@ varnish v1 -vcl {
 
 varnish v1 -badvcl {
 	backend b { .host = "127.0.0.1"; }
-	sub vcl_recv { panic if; }
-}
-
-varnish v1 -badvcl {
-	backend b { .host = "127.0.0.1"; }
 	sub vcl_recv { kluf ; }
 }
 
diff --git a/configure.ac b/configure.ac
index 3df1e7d..2791fd9 100644
--- a/configure.ac
+++ b/configure.ac
@@ -550,6 +550,7 @@ AC_CONFIG_FILES([
     lib/libvarnishcompat/Makefile
     lib/libvcl/Makefile
     lib/libvgz/Makefile
+    lib/libvmod_debug/Makefile
     lib/libvmod_std/Makefile
     lib/libjemalloc/Makefile
     man/Makefile
diff --git a/include/vrt.h b/include/vrt.h
index 50d4d8b..834f972 100644
--- a/include/vrt.h
+++ b/include/vrt.h
@@ -150,7 +150,6 @@ int VRT_re_match(struct req *, const char *, void *re);
 const char *VRT_regsub(struct req *, int all, const char *,
     void *, const char *);
 
-void VRT_panic(struct req *req, const char *, ...);
 void VRT_ban(struct sess *sp, char *, ...);
 void VRT_ban_string(struct sess *sp, const char *);
 void VRT_purge(const struct sess *sp, double ttl, double grace);
diff --git a/lib/Makefile.am b/lib/Makefile.am
index 21146dc..72bc0f8 100644
--- a/lib/Makefile.am
+++ b/lib/Makefile.am
@@ -6,6 +6,7 @@ SUBDIRS = \
 	libvarnishapi \
 	libvcl \
 	libvgz \
+	libvmod_debug \
 	libvmod_std \
 	@JEMALLOC_SUBDIR@
 
diff --git a/lib/libvcl/vcc_action.c b/lib/libvcl/vcc_action.c
index d60b885..81cf597 100644
--- a/lib/libvcl/vcc_action.c
+++ b/lib/libvcl/vcc_action.c
@@ -234,19 +234,6 @@ parse_hash_data(struct vcc *tl)
 /*--------------------------------------------------------------------*/
 
 static void
-parse_panic(struct vcc *tl)
-{
-	vcc_NextToken(tl);
-
-	Fb(tl, 1, "VRT_panic(req, ");
-	vcc_Expr(tl, STRING);
-	ERRCHK(tl);
-	Fb(tl, 0, ", vrt_magic_string_end);\n");
-}
-
-/*--------------------------------------------------------------------*/
-
-static void
 parse_return(struct vcc *tl)
 {
 	int retval = 0;
@@ -331,7 +318,6 @@ static struct action_table {
 	/* Keep list sorted from here */
 	{ "call",		parse_call },
 	{ "hash_data",		parse_hash_data, VCL_MET_HASH },
-	{ "panic",		parse_panic },
 	{ "ban",		parse_ban },
 	{ "ban_url",		parse_ban_url },
 	{ "remove",		parse_unset }, /* backward compatibility */
diff --git a/lib/libvmod_debug/Makefile.am b/lib/libvmod_debug/Makefile.am
new file mode 100644
index 0000000..3a342b5
--- /dev/null
+++ b/lib/libvmod_debug/Makefile.am
@@ -0,0 +1,25 @@
+#
+
+INCLUDES = \
+	-I$(top_srcdir)/include \
+	-I$(top_srcdir)/bin/varnishd \
+	-I$(top_builddir)/include
+
+vmoddir = $(pkglibdir)/vmods
+vmod_srcdir = $(top_srcdir)/lib/libvmod_debug
+vmodtool = $(top_srcdir)/lib/libvcl/vmodtool.py
+vmod_LTLIBRARIES = libvmod_debug.la
+
+libvmod_debug_la_LDFLAGS = -module -export-dynamic -avoid-version
+
+libvmod_debug_la_SOURCES = \
+	vcc_if.c \
+	vcc_if.h \
+	vmod_debug.c
+
+vcc_if.c vcc_if.h: $(vmodtool) $(vmod_srcdir)/vmod.vcc
+	@PYTHON@ $(vmodtool) $(vmod_srcdir)/vmod.vcc
+
+EXTRA_DIST = vmod.vcc
+
+CLEANFILES = $(builddir)/vcc_if.c $(builddir)/vcc_if.h
diff --git a/lib/libvmod_debug/vmod.vcc b/lib/libvmod_debug/vmod.vcc
new file mode 100644
index 0000000..2e3c33e
--- /dev/null
+++ b/lib/libvmod_debug/vmod.vcc
@@ -0,0 +1,33 @@
+#-
+# Copyright (c) 2010-2011 Varnish Software AS
+# All rights reserved.
+#
+# Author: Poul-Henning Kamp <phk at FreeBSD.org>
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+# SUCH DAMAGE.
+
+Module debug
+Init init_function
+Function VOID panic(STRING_LIST)
+Function STRING author(ENUM { phk, des, kristian, mithrandir })
+Function VOID test_priv_call(PRIV_CALL)
+Function VOID test_priv_vcl(PRIV_VCL)
diff --git a/lib/libvmod_debug/vmod_debug.c b/lib/libvmod_debug/vmod_debug.c
new file mode 100644
index 0000000..309664a
--- /dev/null
+++ b/lib/libvmod_debug/vmod_debug.c
@@ -0,0 +1,97 @@
+/*-
+ * Copyright (c) 2012 Varnish Software AS
+ * All rights reserved.
+ *
+ * Author: Poul-Henning Kamp <phk at FreeBSD.org>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+
+#include "cache/cache.h"
+
+#include "vrt.h"
+#include "vcc_if.h"
+
+void
+vmod_panic(struct sess *sp, const char *str, ...)
+{
+	va_list ap;
+	char *b;
+
+	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	va_start(ap, str);
+	b = VRT_String(sp->req->http->ws, "PANIC: ", str, ap);
+	va_end(ap);
+	VAS_Fail("VCL", "", 0, b, 0, 2);
+}
+
+const char * __match_proto__()
+vmod_author(struct sess *sp, const char *id)
+{
+
+	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	if (!strcmp(id, "phk"))
+		return ("Poul-Henning");
+	if (!strcmp(id, "des"))
+		return ("Dag-Erling");
+	if (!strcmp(id, "kristian"))
+		return ("Kristian");
+	if (!strcmp(id, "mithrandir"))
+		return ("Tollef");
+	WRONG("Illegal VMOD enum");
+}
+
+int
+init_function(struct vmod_priv *priv, const struct VCL_conf *cfg)
+{
+	(void)cfg;
+
+	priv->priv = strdup("FOO");
+	priv->free = free;
+	return (0);
+}
+
+void
+vmod_test_priv_call(struct sess *sp, struct vmod_priv *priv)
+{
+
+	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	if (priv->priv == NULL) {
+		priv->priv = strdup("BAR");
+		priv->free = free;
+	} else {
+		assert(!strcmp(priv->priv, "BAR"));
+	}
+}
+
+void
+vmod_test_priv_vcl(struct sess *sp, struct vmod_priv *priv)
+{
+
+        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+        assert(!strcmp(priv->priv, "FOO"));
+}
+
diff --git a/lib/libvmod_std/vmod.vcc b/lib/libvmod_std/vmod.vcc
index 0a71e5b..3238164 100644
--- a/lib/libvmod_std/vmod.vcc
+++ b/lib/libvmod_std/vmod.vcc
@@ -26,15 +26,13 @@
 # SUCH DAMAGE.
 
 Module std
-Init init_function
-Function STRING toupper(PRIV_CALL, STRING_LIST)
-Function STRING tolower(PRIV_VCL, STRING_LIST)
+Function STRING toupper(STRING_LIST)
+Function STRING tolower(STRING_LIST)
 Function VOID set_ip_tos(INT)
 Function REAL random(REAL, REAL)
 Function VOID log(STRING_LIST)
 Function VOID syslog(INT, STRING_LIST)
 Function STRING fileread(PRIV_CALL, STRING)
-Function STRING author(ENUM { phk, des, kristian, mithrandir })
 Function DURATION duration(STRING, DURATION)
 Function INT integer(STRING, INT)
 Function VOID collect(HEADER)
diff --git a/lib/libvmod_std/vmod_std.c b/lib/libvmod_std/vmod_std.c
index 8ae9ec1..c8937f6 100644
--- a/lib/libvmod_std/vmod_std.c
+++ b/lib/libvmod_std/vmod_std.c
@@ -89,18 +89,12 @@ vmod_updown(struct sess *sp, int up, const char *s, va_list ap)
 }
 
 const char * __match_proto__()
-vmod_toupper(struct sess *sp, struct vmod_priv *priv, const char *s, ...)
+vmod_toupper(struct sess *sp, const char *s, ...)
 {
 	const char *p;
 	va_list ap;
 
 	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	if (priv->priv == NULL) {
-		priv->priv = strdup("BAR");
-		priv->free = free;
-	} else {
-		assert(!strcmp(priv->priv, "BAR"));
-	}
 	va_start(ap, s);
 	p = vmod_updown(sp, 1, s, ap);
 	va_end(ap);
@@ -108,29 +102,18 @@ vmod_toupper(struct sess *sp, struct vmod_priv *priv, const char *s, ...)
 }
 
 const char * __match_proto__()
-vmod_tolower(struct sess *sp, struct vmod_priv *priv, const char *s, ...)
+vmod_tolower(struct sess *sp, const char *s, ...)
 {
 	const char *p;
 	va_list ap;
 
 	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	assert(!strcmp(priv->priv, "FOO"));
 	va_start(ap, s);
 	p = vmod_updown(sp, 0, s, ap);
 	va_end(ap);
 	return (p);
 }
 
-int
-init_function(struct vmod_priv *priv, const struct VCL_conf *cfg)
-{
-	(void)cfg;
-
-	priv->priv = strdup("FOO");
-	priv->free = free;
-	return (0);
-}
-
 double
 vmod_random(struct sess *sp, double lo, double hi)
 {
@@ -181,21 +164,6 @@ vmod_syslog(struct sess *sp, int fac, const char *fmt, ...)
 	WS_Release(sp->req->ws, 0);
 }
 
-const char * __match_proto__()
-vmod_author(struct sess *sp, const char *id)
-{
-	(void)sp;
-	if (!strcmp(id, "phk"))
-		return ("Poul-Henning");
-	if (!strcmp(id, "des"))
-		return ("Dag-Erling");
-	if (!strcmp(id, "kristian"))
-		return ("Kristian");
-	if (!strcmp(id, "mithrandir"))
-		return ("Tollef");
-	WRONG("Illegal VMOD enum");
-}
-
 void __match_proto__()
 vmod_collect(struct sess *sp, enum gethdr_e e, const char *h)
 {



From daghf at varnish-cache.org  Mon Jun 18 11:07:40 2012
From: daghf at varnish-cache.org (Dag Haavi Finstad)
Date: Mon, 18 Jun 2012 13:07:40 +0200
Subject: [master] e9e4aa4 Fix for an off-by-one issue in do_once_cb().
Message-ID: <E1SgZo4-0001p9-Ej@project.varnish-software.com>

commit e9e4aa46214c17eab5839f7305626d85551f5702
Author: Dag Haavi Finstad <daghf at varnish-software.com>
Date:   Mon Jun 18 12:58:08 2012 +0200

    Fix for an off-by-one issue in do_once_cb().
    
    Fixes: #1133

diff --git a/bin/varnishstat/varnishstat.c b/bin/varnishstat/varnishstat.c
index 859c379..47cee40 100644
--- a/bin/varnishstat/varnishstat.c
+++ b/bin/varnishstat/varnishstat.c
@@ -168,7 +168,7 @@ do_once_cb(void *priv, const struct VSC_point * const pt)
 	if (strcmp(pt->ident, ""))
 		i += printf("%s.", pt->ident);
 	i += printf("%s", pt->desc->name);
-	if (i > op->pad)
+	if (i >= op->pad)
 		op->pad = i + 1;
 	printf("%*.*s", op->pad - i, op->pad - i, "");
 	if (pt->desc->flag == 'a' || pt->desc->flag == 'c')



From tfheen at varnish-cache.org  Mon Jun 18 12:12:38 2012
From: tfheen at varnish-cache.org (Tollef Fog Heen)
Date: Mon, 18 Jun 2012 14:12:38 +0200
Subject: [master] b16e50d Add libvmod_debug to DIST_SUBDIRS too
Message-ID: <E1Sgaow-0007s5-Nr@project.varnish-software.com>

commit b16e50df0ecb9366226e2387e987e11fcacef9fd
Author: Tollef Fog Heen <tfheen at varnish-software.com>
Date:   Mon Jun 18 14:12:29 2012 +0200

    Add libvmod_debug to DIST_SUBDIRS too

diff --git a/lib/Makefile.am b/lib/Makefile.am
index 72bc0f8..4fcc0ff 100644
--- a/lib/Makefile.am
+++ b/lib/Makefile.am
@@ -16,5 +16,6 @@ DIST_SUBDIRS = 	\
 	libvarnishapi \
 	libvcl \
 	libvgz \
+	libvmod_debug \
 	libvmod_std \
 	libjemalloc



From tfheen at varnish-cache.org  Mon Jun 18 12:25:10 2012
From: tfheen at varnish-cache.org (Tollef Fog Heen)
Date: Mon, 18 Jun 2012 14:25:10 +0200
Subject: [master] e113b7f Don't install the debug vmod,
	it's just there for test purposes
Message-ID: <E1Sgb14-0000bS-Tl@project.varnish-software.com>

commit e113b7fcc4d1085659ec31923ce0a9e101fe0cad
Author: Tollef Fog Heen <tfheen at varnish-software.com>
Date:   Mon Jun 18 14:25:08 2012 +0200

    Don't install the debug vmod, it's just there for test purposes

diff --git a/lib/libvmod_debug/Makefile.am b/lib/libvmod_debug/Makefile.am
index 3a342b5..ada2a56 100644
--- a/lib/libvmod_debug/Makefile.am
+++ b/lib/libvmod_debug/Makefile.am
@@ -8,7 +8,7 @@ INCLUDES = \
 vmoddir = $(pkglibdir)/vmods
 vmod_srcdir = $(top_srcdir)/lib/libvmod_debug
 vmodtool = $(top_srcdir)/lib/libvcl/vmodtool.py
-vmod_LTLIBRARIES = libvmod_debug.la
+noinst_LTLIBRARIES = libvmod_debug.la
 
 libvmod_debug_la_LDFLAGS = -module -export-dynamic -avoid-version
 



From phk at varnish-cache.org  Mon Jun 18 12:27:31 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Mon, 18 Jun 2012 14:27:31 +0200
Subject: [master] 14b48c8 More VRT sess->req changes
Message-ID: <E1Sgb3L-0000nD-KP@project.varnish-software.com>

commit 14b48c8f8a9222689cef12d5fe9f19dc87a5eaa6
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Mon Jun 18 12:27:22 2012 +0000

    More VRT sess->req changes

diff --git a/bin/varnishd/cache/cache_hash.c b/bin/varnishd/cache/cache_hash.c
index d288e3d..bfb030d 100644
--- a/bin/varnishd/cache/cache_hash.c
+++ b/bin/varnishd/cache/cache_hash.c
@@ -506,15 +506,16 @@ hsh_rush(struct dstat *ds, struct objhead *oh)
  */
 
 void
-HSH_Purge(const struct sess *sp, struct objhead *oh, double ttl, double grace)
+HSH_Purge(struct req *req, struct objhead *oh, double ttl, double grace)
 {
 	struct objcore *oc, **ocp;
 	unsigned spc, nobj, n;
 	struct object *o;
 
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	CHECK_OBJ_NOTNULL(oh, OBJHEAD_MAGIC);
-	spc = WS_Reserve(sp->req->ws, 0);
-	ocp = (void*)sp->req->ws->f;
+	spc = WS_Reserve(req->ws, 0);
+	ocp = (void*)req->ws->f;
 	Lck_Lock(&oh->mtx);
 	assert(oh->refcnt > 0);
 	nobj = 0;
@@ -531,7 +532,8 @@ HSH_Purge(const struct sess *sp, struct objhead *oh, double ttl, double grace)
 			continue;
 		}
 
-		(void)oc_getobj(&sp->wrk->stats, oc); /* XXX: still needed ? */
+		(void)oc_getobj(&req->sp->wrk->stats, oc);
+		    /* XXX: still needed ? */
 
 		xxxassert(spc >= sizeof *ocp);
 		oc->refcnt++;
@@ -548,16 +550,16 @@ HSH_Purge(const struct sess *sp, struct objhead *oh, double ttl, double grace)
 	for (n = 0; n < nobj; n++) {
 		oc = ocp[n];
 		CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
-		o = oc_getobj(&sp->wrk->stats, oc);
+		o = oc_getobj(&req->sp->wrk->stats, oc);
 		if (o == NULL)
 			continue;
 		CHECK_OBJ_NOTNULL(o, OBJECT_MAGIC);
 		o->exp.ttl = ttl;
 		o->exp.grace = grace;
 		EXP_Rearm(o);
-		(void)HSH_Deref(&sp->wrk->stats, NULL, &o);
+		(void)HSH_Deref(&req->sp->wrk->stats, NULL, &o);
 	}
-	WS_Release(sp->req->ws, 0);
+	WS_Release(req->ws, 0);
 }
 
 
diff --git a/bin/varnishd/cache/cache_vcl.c b/bin/varnishd/cache/cache_vcl.c
index b909a0e..07c1687 100644
--- a/bin/varnishd/cache/cache_vcl.c
+++ b/bin/varnishd/cache/cache_vcl.c
@@ -191,7 +191,7 @@ VCL_Load(const char *fn, const char *name, struct cli *cli)
 	REPLACE(vcl->name, name);
 	VCLI_Out(cli, "Loaded \"%s\" as \"%s\"", fn , name);
 	VTAILQ_INSERT_TAIL(&vcl_head, vcl, list);
-	(void)vcl->conf->init_func(NULL, NULL);
+	(void)vcl->conf->init_func(NULL);
 	Lck_Lock(&vcl_mtx);
 	if (vcl_active == NULL)
 		vcl_active = vcl;
@@ -215,7 +215,7 @@ VCL_Nuke(struct vcls *vcl)
 	assert(vcl->conf->discard);
 	assert(vcl->conf->busy == 0);
 	VTAILQ_REMOVE(&vcl_head, vcl, list);
-	(void)vcl->conf->fini_func(NULL, NULL);
+	(void)vcl->conf->fini_func(NULL);
 	vcl->conf->fini_vcl(NULL);
 	free(vcl->name);
 	(void)dlclose(vcl->dlh);
@@ -344,7 +344,7 @@ VCL_##func##_method(struct req *req)					\
 	req->handling = 0;						\
 	req->cur_method = VCL_MET_ ## upper;				\
 	VSLb(req->vsl, SLT_VCL_call, "%s", #func);			\
-	(void)req->vcl->func##_func(req->sp, req);			\
+	(void)req->vcl->func##_func(req);				\
 	VSLb(req->vsl, SLT_VCL_return, "%s",				\
 	    VCL_Return_Name(req->handling));				\
 	req->cur_method = 0;						\
diff --git a/bin/varnishd/cache/cache_vrt.c b/bin/varnishd/cache/cache_vrt.c
index f172769..8cc2920 100644
--- a/bin/varnishd/cache/cache_vrt.c
+++ b/bin/varnishd/cache/cache_vrt.c
@@ -286,7 +286,7 @@ VRT_r_now(const struct req *req)
 /*--------------------------------------------------------------------*/
 
 char *
-VRT_IP_string(struct req *req, const struct sockaddr_storage *sa)
+VRT_IP_string(const struct req *req, const struct sockaddr_storage *sa)
 {
 	char *p;
 	const struct sockaddr_in *si4;
@@ -316,7 +316,7 @@ VRT_IP_string(struct req *req, const struct sockaddr_storage *sa)
 }
 
 char *
-VRT_int_string(struct req *req, int num)
+VRT_int_string(const struct req *req, int num)
 {
 	char *p;
 	int size;
@@ -329,7 +329,7 @@ VRT_int_string(struct req *req, int num)
 }
 
 char *
-VRT_double_string(struct req *req, double num)
+VRT_double_string(const struct req *req, double num)
 {
 	char *p;
 	int size;
@@ -342,7 +342,7 @@ VRT_double_string(struct req *req, double num)
 }
 
 char *
-VRT_time_string(struct req *req, double t)
+VRT_time_string(const struct req *req, double t)
 {
 	char *p;
 
@@ -375,17 +375,18 @@ VRT_bool_string(const struct req *req, unsigned val)
 /*--------------------------------------------------------------------*/
 
 void
-VRT_Rollback(const struct sess *sp)
+VRT_Rollback(struct req *req)
 {
 
-	HTTP_Copy(sp->req->http, sp->req->http0);
-	WS_Reset(sp->req->ws, sp->req->ws_req);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	HTTP_Copy(req->http, req->http0);
+	WS_Reset(req->ws, req->ws_req);
 }
 
 /*--------------------------------------------------------------------*/
 
 void
-VRT_synth_page(struct req *req, unsigned flags, const char *str, ...)
+VRT_synth_page(const struct req *req, unsigned flags, const char *str, ...)
 {
 	va_list ap;
 	const char *p;
@@ -415,14 +416,14 @@ VRT_synth_page(struct req *req, unsigned flags, const char *str, ...)
 /*--------------------------------------------------------------------*/
 
 void
-VRT_ban(struct sess *sp, char *cmds, ...)
+VRT_ban(const struct req *req, char *cmds, ...)
 {
 	char *a1, *a2, *a3;
 	va_list ap;
 	struct ban *b;
 	int good;
 
-	(void)sp;
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	b = BAN_New();
 	va_start(ap, cmds);
 	a1 = cmds;
@@ -450,7 +451,7 @@ VRT_ban(struct sess *sp, char *cmds, ...)
 /*--------------------------------------------------------------------*/
 
 void
-VRT_ban_string(struct sess *sp, const char *str)
+VRT_ban_string(const struct req *req, const char *str)
 {
 	char *a1, *a2, *a3;
 	char **av;
@@ -458,7 +459,7 @@ VRT_ban_string(struct sess *sp, const char *str)
 	int good;
 	int i;
 
-	(void)sp;
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	av = VAV_Parse(str, NULL, ARGV_NOESC);
 	if (av[0] != NULL) {
 		/* XXX: report error how ? */
@@ -500,12 +501,14 @@ VRT_ban_string(struct sess *sp, const char *str)
  */
 
 void
-VRT_purge(const struct sess *sp, double ttl, double grace)
+VRT_purge(struct req *req, double ttl, double grace)
 {
-	if (sp->req->cur_method == VCL_MET_HIT)
-		HSH_Purge(sp, sp->req->obj->objcore->objhead, ttl, grace);
-	else if (sp->req->cur_method == VCL_MET_MISS)
-		HSH_Purge(sp, sp->req->objcore->objhead, ttl, grace);
+
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	if (req->cur_method == VCL_MET_HIT)
+		HSH_Purge(req, req->obj->objcore->objhead, ttl, grace);
+	else if (req->cur_method == VCL_MET_MISS)
+		HSH_Purge(req, req->objcore->objhead, ttl, grace);
 }
 
 /*--------------------------------------------------------------------
diff --git a/bin/varnishd/flint.lnt b/bin/varnishd/flint.lnt
index 1569271..5ddd6ce 100644
--- a/bin/varnishd/flint.lnt
+++ b/bin/varnishd/flint.lnt
@@ -155,6 +155,16 @@
 
 -e441	//  for clause irregularity: loop variable '___' not found in 2nd for expression
 
+// Vmod instantiation symbols are defined in all vmods
+
+-esym(14, Vmod_Name)
+-esym(14, Vmod_Func)
+-esym(14, Vmod_Len)
+-esym(14, Vmod_Proto)
+-esym(14, Vmod_Spec)
+-esym(14, Vmod_Varnish_ABI)
+-esym(14, Vmod_Id)
+
 // Review all below this line ///////////////////////////////////////////////
 
 -e732   // 183 Loss of sign (___) (___ to ___)
diff --git a/bin/varnishd/hash/hash_slinger.h b/bin/varnishd/hash/hash_slinger.h
index 7eb1b14..fe0fb9f 100644
--- a/bin/varnishd/hash/hash_slinger.h
+++ b/bin/varnishd/hash/hash_slinger.h
@@ -59,7 +59,7 @@ void HSH_Drop(struct worker *, struct object **);
 void HSH_Init(const struct hash_slinger *slinger);
 void HSH_AddString(struct req *, const char *str);
 void HSH_Insert(struct worker *, const void *hash, struct objcore *);
-void HSH_Purge(const struct sess *, struct objhead *, double ttl, double grace);
+void HSH_Purge(struct req *, struct objhead *, double ttl, double grace);
 void HSH_config(const char *h_arg);
 struct objcore *HSH_NewObjCore(struct worker *wrk);
 
diff --git a/bin/varnishtest/tests/c00033.vtc b/bin/varnishtest/tests/c00033.vtc
index d93a6d0..d4289e3 100644
--- a/bin/varnishtest/tests/c00033.vtc
+++ b/bin/varnishtest/tests/c00033.vtc
@@ -25,13 +25,13 @@ varnish v1 -vcl+backend {
 
 	sub vcl_hit {
 		if (req.request == "PURGE") {
-			C{ VRT_purge(sp, 0, 0); }C
+			C{ VRT_purge(req, 0, 0); }C
 			error 456 "got it";
 		}
 	}
 	sub vcl_miss {
 		if (req.request == "PURGE") {
-			C{ VRT_purge(sp, 0, 0); }C
+			C{ VRT_purge(req, 0, 0); }C
 			error 456 "got it";
 		}
 	}
diff --git a/include/vrt.h b/include/vrt.h
index 834f972..20545fc 100644
--- a/include/vrt.h
+++ b/include/vrt.h
@@ -31,7 +31,6 @@
  * XXX: When this file is changed, lib/libvcl/generate.py *MUST* be rerun.
  */
 
-struct sess;
 struct req;
 struct vsb;
 struct cli;
@@ -150,9 +149,9 @@ int VRT_re_match(struct req *, const char *, void *re);
 const char *VRT_regsub(struct req *, int all, const char *,
     void *, const char *);
 
-void VRT_ban(struct sess *sp, char *, ...);
-void VRT_ban_string(struct sess *sp, const char *);
-void VRT_purge(const struct sess *sp, double ttl, double grace);
+void VRT_ban(const struct req *, char *, ...);
+void VRT_ban_string(const struct req *, const char *);
+void VRT_purge(struct req *, double ttl, double grace);
 
 void VRT_count(struct req *, unsigned);
 int VRT_rewrite(const char *, const char *);
@@ -171,11 +170,10 @@ void VRT_hashdata(struct req *, const char *str, ...);
 int VRT_strcmp(const char *s1, const char *s2);
 void VRT_memmove(void *dst, const void *src, unsigned len);
 
-void VRT_ESI(const struct sess *sp);
-void VRT_Rollback(const struct sess *sp);
+void VRT_Rollback(struct req *);
 
 /* Synthetic pages */
-void VRT_synth_page(struct req *sp, unsigned flags, const char *, ...);
+void VRT_synth_page(const struct req *, unsigned flags, const char *, ...);
 
 /* Backend related */
 void VRT_init_dir(struct cli *, struct director **, const char *name,
@@ -209,10 +207,10 @@ int VRT_Stv(const char *nm);
 
 /* Convert things to string */
 
-char *VRT_IP_string(struct req *, const struct sockaddr_storage *sa);
-char *VRT_int_string(struct req *, int);
-char *VRT_double_string(struct req *, double);
-char *VRT_time_string(struct req *, double);
+char *VRT_IP_string(const struct req *, const struct sockaddr_storage *sa);
+char *VRT_int_string(const struct req *, int);
+char *VRT_double_string(const struct req *, double);
+char *VRT_time_string(const struct req *, double);
 const char *VRT_bool_string(const struct req *, unsigned);
 const char *VRT_backend_string(const struct req *, const struct director *d);
 
diff --git a/lib/libvcl/generate.py b/lib/libvcl/generate.py
index 0c1c02e..c999186 100755
--- a/lib/libvcl/generate.py
+++ b/lib/libvcl/generate.py
@@ -721,7 +721,7 @@ struct cli;
 
 typedef int vcl_init_f(struct cli *);
 typedef void vcl_fini_f(struct cli *);
-typedef int vcl_func_f(struct sess *sp, struct req *req);
+typedef int vcl_func_f(struct req *req);
 """)
 
 
diff --git a/lib/libvcl/vcc_action.c b/lib/libvcl/vcc_action.c
index 81cf597..7eecc33 100644
--- a/lib/libvcl/vcc_action.c
+++ b/lib/libvcl/vcc_action.c
@@ -44,7 +44,7 @@ parse_call(struct vcc *tl)
 	ExpectErr(tl, ID);
 	vcc_AddCall(tl, tl->t);
 	vcc_AddRef(tl, tl->t, SYM_SUB);
-	Fb(tl, 1, "if (VGC_function_%.*s(sp, req))\n", PF(tl->t));
+	Fb(tl, 1, "if (VGC_function_%.*s(req))\n", PF(tl->t));
 	Fb(tl, 1, "\treturn (1);\n");
 	vcc_NextToken(tl);
 	return;
@@ -178,7 +178,7 @@ parse_ban(struct vcc *tl)
 	ExpectErr(tl, '(');
 	vcc_NextToken(tl);
 
-	Fb(tl, 1, "VRT_ban_string(sp, ");
+	Fb(tl, 1, "VRT_ban_string(req, ");
 	vcc_Expr(tl, STRING);
 	ERRCHK(tl);
 	Fb(tl, 0, ");\n");
@@ -197,7 +197,7 @@ parse_ban_url(struct vcc *tl)
 	ExpectErr(tl, '(');
 	vcc_NextToken(tl);
 
-	Fb(tl, 1, "VRT_ban(sp, \"req.url\", \"~\", ");
+	Fb(tl, 1, "VRT_ban(req, \"req.url\", \"~\", ");
 	vcc_Expr(tl, STRING);
 	ERRCHK(tl);
 	ExpectErr(tl, ')');
@@ -270,7 +270,7 @@ parse_rollback(struct vcc *tl)
 {
 
 	vcc_NextToken(tl);
-	Fb(tl, 1, "VRT_Rollback(sp);\n");
+	Fb(tl, 1, "VRT_Rollback(req);\n");
 }
 
 /*--------------------------------------------------------------------*/
@@ -280,7 +280,7 @@ parse_purge(struct vcc *tl)
 {
 
 	vcc_NextToken(tl);
-	Fb(tl, 1, "VRT_purge(sp, 0, 0);\n");
+	Fb(tl, 1, "VRT_purge(req, 0, 0);\n");
 }
 
 /*--------------------------------------------------------------------*/
diff --git a/lib/libvcl/vcc_compile.c b/lib/libvcl/vcc_compile.c
index a16fbed..30f2a24 100644
--- a/lib/libvcl/vcc_compile.c
+++ b/lib/libvcl/vcc_compile.c
@@ -672,7 +672,7 @@ vcc_CompileSource(const struct vcc *tl0, struct vsb *sb, struct source *sp)
 	/* Emit method functions */
 	for (i = 0; i < VCL_MET_MAX; i++) {
 		Fc(tl, 1, "\nstatic int __match_proto__(vcl_func_f)\n");
-		Fc(tl, 1, "VGC_function_%s(struct sess *sp, struct req *req)\n",
+		Fc(tl, 1, "VGC_function_%s(struct req *req)\n",
 		    method_tab[i].name);
 		AZ(VSB_finish(tl->fm[i]));
 		Fc(tl, 1, "{\n");
diff --git a/lib/libvcl/vcc_expr.c b/lib/libvcl/vcc_expr.c
index a3ef4b6..8fbaa04 100644
--- a/lib/libvcl/vcc_expr.c
+++ b/lib/libvcl/vcc_expr.c
@@ -539,7 +539,7 @@ vcc_Eval_Func(struct vcc *tl, struct expr **e, const struct symbol *sym)
 	SkipToken(tl, ID);
 	SkipToken(tl, '(');
 	p = sym->args;
-	e2 = vcc_mk_expr(vcc_arg_type(&p), "%s(sp\v+", sym->cfunc);
+	e2 = vcc_mk_expr(vcc_arg_type(&p), "%s(req\v+", sym->cfunc);
 	while (*p != '\0') {
 		e1 = NULL;
 		fmt = vcc_arg_type(&p);
diff --git a/lib/libvcl/vcc_parse.c b/lib/libvcl/vcc_parse.c
index 1a6bbf3..10170b3 100644
--- a/lib/libvcl/vcc_parse.c
+++ b/lib/libvcl/vcc_parse.c
@@ -225,11 +225,9 @@ vcc_Function(struct vcc *tl)
 		}
 		tl->curproc = vcc_AddProc(tl, tl->t);
 		Fh(tl, 0, "static int VGC_function_%.*s "
-		    "(struct sess *, struct req *);\n",
-		    PF(tl->t));
+		    "(struct req *);\n", PF(tl->t));
 		Fc(tl, 1, "\nstatic int __match_proto__(vcl_func_t)\n");
-		Fc(tl, 1, "VGC_function_%.*s"
-		    "(struct sess *sp, struct req *req)\n",
+		Fc(tl, 1, "VGC_function_%.*s(struct req *req)\n",
 		    PF(tl->t));
 	}
 	vcc_NextToken(tl);
diff --git a/lib/libvcl/vmodtool.py b/lib/libvcl/vmodtool.py
index 041edcb..e2cf8b5 100755
--- a/lib/libvcl/vmodtool.py
+++ b/lib/libvcl/vmodtool.py
@@ -81,7 +81,7 @@ def do_func(fname, rval, args, vargs):
 	#print(fname, rval, args)
 
 	# C argument list
-	cargs = "(struct sess *"
+	cargs = "(struct req *"
 	for i in args:
 		cargs += ", " + i
 	cargs += ")"
@@ -273,7 +273,7 @@ fh = open("vcc_if.h", "w")
 file_header(fc)
 file_header(fh)
 
-fh.write('struct sess;\n')
+fh.write('struct req;\n')
 fh.write('struct VCL_conf;\n')
 fh.write('struct vmod_priv;\n')
 fh.write("\n");
diff --git a/lib/libvmod_debug/vmod_debug.c b/lib/libvmod_debug/vmod_debug.c
index 309664a..fd65fd2 100644
--- a/lib/libvmod_debug/vmod_debug.c
+++ b/lib/libvmod_debug/vmod_debug.c
@@ -35,24 +35,24 @@
 #include "vrt.h"
 #include "vcc_if.h"
 
-void
-vmod_panic(struct sess *sp, const char *str, ...)
+void __match_proto__(td_debug_panic)
+vmod_panic(struct req *req, const char *str, ...)
 {
 	va_list ap;
 	char *b;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	va_start(ap, str);
-	b = VRT_String(sp->req->http->ws, "PANIC: ", str, ap);
+	b = VRT_String(req->http->ws, "PANIC: ", str, ap);
 	va_end(ap);
 	VAS_Fail("VCL", "", 0, b, 0, 2);
 }
 
-const char * __match_proto__()
-vmod_author(struct sess *sp, const char *id)
+const char * __match_proto__(td_debug_author)
+vmod_author(struct req *req, const char *id)
 {
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	if (!strcmp(id, "phk"))
 		return ("Poul-Henning");
 	if (!strcmp(id, "des"))
@@ -74,11 +74,11 @@ init_function(struct vmod_priv *priv, const struct VCL_conf *cfg)
 	return (0);
 }
 
-void
-vmod_test_priv_call(struct sess *sp, struct vmod_priv *priv)
+void __match_proto__(td_debug_test_priv_call)
+vmod_test_priv_call(struct req *req, struct vmod_priv *priv)
 {
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	if (priv->priv == NULL) {
 		priv->priv = strdup("BAR");
 		priv->free = free;
@@ -87,11 +87,11 @@ vmod_test_priv_call(struct sess *sp, struct vmod_priv *priv)
 	}
 }
 
-void
-vmod_test_priv_vcl(struct sess *sp, struct vmod_priv *priv)
+void __match_proto__(td_debug_test_priv_vcl)
+vmod_test_priv_vcl(struct req *req, struct vmod_priv *priv)
 {
 
-        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
         assert(!strcmp(priv->priv, "FOO"));
 }
 
diff --git a/lib/libvmod_std/vmod_std.c b/lib/libvmod_std/vmod_std.c
index c8937f6..4265cf1 100644
--- a/lib/libvmod_std/vmod_std.c
+++ b/lib/libvmod_std/vmod_std.c
@@ -45,23 +45,25 @@
 
 #include "vcc_if.h"
 
-void __match_proto__()
-vmod_set_ip_tos(struct sess *sp, int tos)
+void __match_proto__(td_std_set_ip_tos)
+vmod_set_ip_tos(struct req *req, int tos)
 {
 
-	VTCP_Assert(setsockopt(sp->fd, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)));
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	VTCP_Assert(setsockopt(req->sp->fd,
+	    IPPROTO_IP, IP_TOS, &tos, sizeof(tos)));
 }
 
-static const char * __match_proto__()
-vmod_updown(struct sess *sp, int up, const char *s, va_list ap)
+static const char *
+vmod_updown(struct req *req, int up, const char *s, va_list ap)
 {
 	unsigned u;
 	char *b, *e;
 	const char *p;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	u = WS_Reserve(sp->req->ws, 0);
-	e = b = sp->req->ws->f;
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	u = WS_Reserve(req->ws, 0);
+	e = b = req->ws->f;
 	e += u;
 	p = s;
 	while (p != vrt_magic_string_end && b < e) {
@@ -78,101 +80,101 @@ vmod_updown(struct sess *sp, int up, const char *s, va_list ap)
 		*b = '\0';
 	b++;
 	if (b > e) {
-		WS_Release(sp->req->ws, 0);
+		WS_Release(req->ws, 0);
 		return (NULL);
 	} else {
 		e = b;
-		b = sp->req->ws->f;
-		WS_Release(sp->req->ws, e - b);
+		b = req->ws->f;
+		WS_Release(req->ws, e - b);
 		return (b);
 	}
 }
 
-const char * __match_proto__()
-vmod_toupper(struct sess *sp, const char *s, ...)
+const char * __match_proto__(td_std_toupper)
+vmod_toupper(struct req *req, const char *s, ...)
 {
 	const char *p;
 	va_list ap;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	va_start(ap, s);
-	p = vmod_updown(sp, 1, s, ap);
+	p = vmod_updown(req, 1, s, ap);
 	va_end(ap);
 	return (p);
 }
 
-const char * __match_proto__()
-vmod_tolower(struct sess *sp, const char *s, ...)
+const char * __match_proto__(td_std_tolower)
+vmod_tolower(struct req *req, const char *s, ...)
 {
 	const char *p;
 	va_list ap;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	va_start(ap, s);
-	p = vmod_updown(sp, 0, s, ap);
+	p = vmod_updown(req, 0, s, ap);
 	va_end(ap);
 	return (p);
 }
 
-double
-vmod_random(struct sess *sp, double lo, double hi)
+double __match_proto__(td_std_random)
+vmod_random(struct req *req, double lo, double hi)
 {
 	double a;
 
-	(void)sp;
-
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	a = drand48();
 	a *= hi - lo;
 	a += lo;
 	return (a);
 }
 
-void __match_proto__()
-vmod_log(struct sess *sp, const char *fmt, ...)
+void __match_proto__(td_std_log)
+vmod_log(struct req *req, const char *fmt, ...)
 {
 	unsigned u;
 	va_list ap;
 	txt t;
 
-	u = WS_Reserve(sp->req->ws, 0);
-	t.b = sp->req->ws->f;
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	u = WS_Reserve(req->ws, 0);
+	t.b = req->ws->f;
 	va_start(ap, fmt);
 	t.e = VRT_StringList(t.b, u, fmt, ap);
 	va_end(ap);
 	if (t.e != NULL) {
 		assert(t.e > t.b);
 		t.e--;
-		VSLbt(sp->req->vsl, SLT_VCL_Log, t);
+		VSLbt(req->vsl, SLT_VCL_Log, t);
 	}
-	WS_Release(sp->req->ws, 0);
+	WS_Release(req->ws, 0);
 }
 
-void __match_proto__()
-vmod_syslog(struct sess *sp, int fac, const char *fmt, ...)
+void __match_proto__(td_std_syslog)
+vmod_syslog(struct req *req, int fac, const char *fmt, ...)
 {
 	char *p;
 	unsigned u;
 	va_list ap;
 
-	u = WS_Reserve(sp->req->ws, 0);
-	p = sp->req->ws->f;
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	u = WS_Reserve(req->ws, 0);
+	p = req->ws->f;
 	va_start(ap, fmt);
 	p = VRT_StringList(p, u, fmt, ap);
 	va_end(ap);
 	if (p != NULL)
 		syslog(fac, "%s", p);
-	WS_Release(sp->req->ws, 0);
+	WS_Release(req->ws, 0);
 }
 
-void __match_proto__()
-vmod_collect(struct sess *sp, enum gethdr_e e, const char *h)
+void __match_proto__(td_std_collect)
+vmod_collect(struct req *req, enum gethdr_e e, const char *h)
 {
-	(void)e;
-	(void)sp;
-	(void)h;
+
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	if (e == HDR_REQ)
-		http_CollectHdr(sp->req->http, h);
-	else if (e == HDR_BERESP && sp->req->busyobj != NULL)
-		http_CollectHdr(sp->req->busyobj->beresp, h);
+		http_CollectHdr(req->http, h);
+	else if (e == HDR_BERESP && req->busyobj != NULL)
+		http_CollectHdr(req->busyobj->beresp, h);
 }
 
diff --git a/lib/libvmod_std/vmod_std_conversions.c b/lib/libvmod_std/vmod_std_conversions.c
index 149be81..45cc7a1 100644
--- a/lib/libvmod_std/vmod_std_conversions.c
+++ b/lib/libvmod_std/vmod_std_conversions.c
@@ -39,12 +39,12 @@
 #include "vcc_if.h"
 
 double __match_proto__()
-vmod_duration(struct sess *sp, const char *p, double d)
+vmod_duration(struct req *req, const char *p, double d)
 {
 	char *e;
 	double r;
 
-	(void)sp;
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 
 	if (p == NULL)
 		return (d);
@@ -89,12 +89,12 @@ vmod_duration(struct sess *sp, const char *p, double d)
 }
 
 int __match_proto__()
-vmod_integer(struct sess *sp, const char *p, int i)
+vmod_integer(struct req *req, const char *p, int i)
 {
 	char *e;
 	int r;
 
-	(void)sp;
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 
 	if (p == NULL)
 		return (i);
diff --git a/lib/libvmod_std/vmod_std_fileread.c b/lib/libvmod_std/vmod_std_fileread.c
index 7012b66..d424d75 100644
--- a/lib/libvmod_std/vmod_std_fileread.c
+++ b/lib/libvmod_std/vmod_std_fileread.c
@@ -82,13 +82,13 @@ free_frfile(void *ptr)
 	}
 }
 
-const char *
-vmod_fileread(struct sess *sp, struct vmod_priv *priv, const char *file_name)
+const char * __match_proto__(td_std_fileread)
+vmod_fileread(struct req *req, struct vmod_priv *priv, const char *file_name)
 {
 	struct frfile *frf = NULL;
 	char *s;
 
-	(void)sp;
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	AN(priv);
 
 	if (priv->priv != NULL) {



From phk at varnish-cache.org  Mon Jun 18 12:57:56 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Mon, 18 Jun 2012 14:57:56 +0200
Subject: [master] b71cb6a All the _r_ object accessor functions should by
	definition be able to take a "const struct req *" so enforce this.
Message-ID: <E1SgbWm-00039U-5p@project.varnish-software.com>

commit b71cb6a8ea5b9f4d3788c5e2c535dca9bcd3c5f1
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Mon Jun 18 12:57:25 2012 +0000

    All the _r_ object accessor functions should by definition be able to
    take a "const struct req *" so enforce this.

diff --git a/bin/varnishd/cache/cache_vrt_var.c b/bin/varnishd/cache/cache_vrt_var.c
index 8d325ca..36ff4c6 100644
--- a/bin/varnishd/cache/cache_vrt_var.c
+++ b/bin/varnishd/cache/cache_vrt_var.c
@@ -204,7 +204,7 @@ VBERESP(beresp, unsigned, do_pass, busyobj->do_pass)
 /*--------------------------------------------------------------------*/
 
 const char *
-VRT_r_client_identity(struct req *req)
+VRT_r_client_identity(const struct req *req)
 {
 
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
@@ -238,8 +238,8 @@ VRT_l_bereq_##which(struct req *req, double num)		\
 	req->busyobj->which = (num > 0.0 ? num : 0.0);		\
 }								\
 								\
-double __match_proto__()					\
-VRT_r_bereq_##which(struct req *req)				\
+double								\
+VRT_r_bereq_##which(const struct req *req)			\
 {								\
 								\
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);			\
@@ -280,8 +280,8 @@ VRT_r_beresp_backend_port(const struct req *req)
 	return (VTCP_port(req->busyobj->vbc->addr));
 }
 
-const char * __match_proto__()
-VRT_r_beresp_storage(struct req *req)
+const char *
+VRT_r_beresp_storage(const struct req *req)
 {
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	if (req->storage_hint != NULL)
@@ -290,7 +290,7 @@ VRT_r_beresp_storage(struct req *req)
 		return (NULL);
 }
 
-void __match_proto__()
+void
 VRT_l_beresp_storage(struct req *req, const char *str, ...)
 {
 	va_list ap;
@@ -314,7 +314,7 @@ VRT_l_req_backend(struct req *req, struct director *be)
 }
 
 struct director *
-VRT_r_req_backend(struct req *req)
+VRT_r_req_backend(const struct req *req)
 {
 
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
@@ -336,7 +336,7 @@ VRT_l_req_esi(struct req *req, unsigned process_esi)
 }
 
 unsigned
-VRT_r_req_esi(struct req *req)
+VRT_r_req_esi(const struct req *req)
 {
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	return (!req->disable_esi);
@@ -352,8 +352,8 @@ VRT_r_req_esi_level(const struct req *req)
 
 /*--------------------------------------------------------------------*/
 
-unsigned __match_proto__()
-VRT_r_req_can_gzip(struct req *req)
+unsigned
+VRT_r_req_can_gzip(const struct req *req)
 {
 
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
@@ -378,7 +378,7 @@ VRT_r_req_restarts(const struct req *req)
 
 #define VRT_DO_EXP(which, exp, fld, offset, extra)		\
 								\
-void __match_proto__()						\
+void								\
 VRT_l_##which##_##fld(struct req *req, double a)		\
 {								\
 								\
@@ -389,8 +389,8 @@ VRT_l_##which##_##fld(struct req *req, double a)		\
 	extra;							\
 }								\
 								\
-double __match_proto__()					\
-VRT_r_##which##_##fld(struct req *req)				\
+double								\
+VRT_r_##which##_##fld(const struct req *req)			\
 {								\
 								\
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);			\
@@ -432,8 +432,8 @@ VRT_DO_EXP(beresp, req->busyobj->exp, keep, 0,
  * req.xid
  */
 
-const char * __match_proto__()
-VRT_r_req_xid(struct req *req)
+const char *
+VRT_r_req_xid(const struct req *req)
 {
 	char *p;
 	int size;
@@ -448,7 +448,7 @@ VRT_r_req_xid(struct req *req)
 /*--------------------------------------------------------------------*/
 
 #define REQ_BOOL(hash_var)					\
-void __match_proto__()						\
+void								\
 VRT_l_req_##hash_var(struct req *req, unsigned val)		\
 {								\
 								\
@@ -456,8 +456,8 @@ VRT_l_req_##hash_var(struct req *req, unsigned val)		\
 	req->hash_var = val ? 1 : 0;				\
 }								\
 								\
-unsigned __match_proto__()					\
-VRT_r_req_##hash_var(struct req *req)				\
+unsigned							\
+VRT_r_req_##hash_var(const struct req *req)			\
 {								\
 								\
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);			\
@@ -470,7 +470,7 @@ REQ_BOOL(hash_always_miss)
 /*--------------------------------------------------------------------*/
 
 struct sockaddr_storage *
-VRT_r_client_ip(struct req *req)
+VRT_r_client_ip(const struct req *req)
 {
 
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
@@ -478,7 +478,7 @@ VRT_r_client_ip(struct req *req)
 }
 
 struct sockaddr_storage *
-VRT_r_server_ip(struct req *req)
+VRT_r_server_ip(const struct req *req)
 {
 	int i;
 
@@ -493,7 +493,7 @@ VRT_r_server_ip(struct req *req)
 }
 
 const char*
-VRT_r_server_identity(struct req *req)
+VRT_r_server_identity(const struct req *req)
 {
 
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
@@ -504,7 +504,7 @@ VRT_r_server_identity(struct req *req)
 }
 
 const char*
-VRT_r_server_hostname(struct req *req)
+VRT_r_server_hostname(const struct req *req)
 {
 
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
@@ -518,7 +518,7 @@ VRT_r_server_hostname(struct req *req)
  */
 
 int
-VRT_r_server_port(struct req *req)
+VRT_r_server_port(const struct req *req)
 {
 	int i;
 
@@ -552,7 +552,7 @@ VRT_r_obj_lastuse(const struct req *req)
 }
 
 unsigned
-VRT_r_req_backend_healthy(struct req *req)
+VRT_r_req_backend_healthy(const struct req *req)
 {
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	CHECK_OBJ_NOTNULL(req->director, DIRECTOR_MAGIC);
diff --git a/lib/libvcl/generate.py b/lib/libvcl/generate.py
index c999186..3a1daa1 100755
--- a/lib/libvcl/generate.py
+++ b/lib/libvcl/generate.py
@@ -833,7 +833,7 @@ for i in sp_variables:
 	if len(i[2]) > 0:
 		fo.write('\t    "VRT_r_%s(req)",\n' % cnam)
 		if typ != "HEADER":
-			fh.write(ctyp + " VRT_r_%s(%s);\n" % (cnam, i[4]))
+			fh.write(ctyp + " VRT_r_%s(const %s);\n" % (cnam, i[4]))
 	else:
 		fo.write('\t    NULL,\t/* No reads allowed */\n')
 	restrict(fo, i[2])



From tfheen at varnish-cache.org  Mon Jun 18 12:59:01 2012
From: tfheen at varnish-cache.org (Tollef Fog Heen)
Date: Mon, 18 Jun 2012 14:59:01 +0200
Subject: [master] c74b02a Add -rpath to libvmod_debug_la_LDFLAGS,
	which forces creation of a .so
Message-ID: <E1SgbXp-0003H3-Gc@project.varnish-software.com>

commit c74b02adcdb7bdcaa53b5cd45de64e2295798251
Author: Tollef Fog Heen <tfheen at varnish-software.com>
Date:   Mon Jun 18 14:58:22 2012 +0200

    Add -rpath to libvmod_debug_la_LDFLAGS, which forces creation of a .so

diff --git a/lib/libvmod_debug/Makefile.am b/lib/libvmod_debug/Makefile.am
index ada2a56..23a6d53 100644
--- a/lib/libvmod_debug/Makefile.am
+++ b/lib/libvmod_debug/Makefile.am
@@ -10,7 +10,7 @@ vmod_srcdir = $(top_srcdir)/lib/libvmod_debug
 vmodtool = $(top_srcdir)/lib/libvcl/vmodtool.py
 noinst_LTLIBRARIES = libvmod_debug.la
 
-libvmod_debug_la_LDFLAGS = -module -export-dynamic -avoid-version
+libvmod_debug_la_LDFLAGS = -module -export-dynamic -avoid-version -rpath /nowhere
 
 libvmod_debug_la_SOURCES = \
 	vcc_if.c \



From perbu at varnish-cache.org  Tue Jun 19 07:27:00 2012
From: perbu at varnish-cache.org (Per Buer)
Date: Tue, 19 Jun 2012 09:27:00 +0200
Subject: [master] 4264387 reference VCL for naming storage
Message-ID: <E1Sgsq4-00014Z-Ft@project.varnish-software.com>

commit 42643875f383db925e4b96aeb09a097f5d1c3b2f
Author: Per Buer <perbu at varnish-software.com>
Date:   Tue Jun 19 09:11:21 2012 +0200

    reference VCL for naming storage

diff --git a/doc/sphinx/reference/varnishd.rst b/doc/sphinx/reference/varnishd.rst
index 48ebdc8..17e6c03 100644
--- a/doc/sphinx/reference/varnishd.rst
+++ b/doc/sphinx/reference/varnishd.rst
@@ -93,7 +93,8 @@ OPTIONS
             Use the specified storage backend.  See Storage Types for a list of supported storage
             types.  This option can be used multiple times to specify multiple storage files. You
  	    can name the different backends. Varnish will then reference that backend with the 
-	    given name in logs, statistics, etc.
+	    given name in logs, statistics, etc. You will also be able to ask Varnish to use
+            these named backends specifically through VCL by setting backend.storage in vcl_fetch.
 
 -T address[:port]
             Offer a management interface on the specified address and port.  See Management



From perbu at varnish-cache.org  Tue Jun 19 07:27:00 2012
From: perbu at varnish-cache.org (Per Buer)
Date: Tue, 19 Jun 2012 09:27:00 +0200
Subject: [master] 820aa11 document a couple of tags
Message-ID: <E1Sgsq4-00014e-Gx@project.varnish-software.com>

commit 820aa1126aa841b11828af934f6f72a880f9779c
Author: Per Buer <perbu at varnish-software.com>
Date:   Tue Jun 19 09:26:30 2012 +0200

    document a couple of tags

diff --git a/include/tbl/vsl_tags.h b/include/tbl/vsl_tags.h
index 1c404cf..fce1429 100644
--- a/include/tbl/vsl_tags.h
+++ b/include/tbl/vsl_tags.h
@@ -45,9 +45,25 @@ SLTM(Debug, "", "")
 SLTM(Error, "", "")
 SLTM(CLI, "CLI communication", "CLI communication between master and child process.")
 SLTM(StatSess, "Session statistics", "")
-SLTM(ReqEnd, "Client request end", "")
+SLTM(ReqEnd, "Client request end", "Client request end. The first number is the XID. \n"
+"The second is the time when processing of the request started.\n"
+"The third is the time the request completed.\n"
+"The forth is is the time elapsed between the request actually being accepted and\n"
+"the start of the request processing.\n" 
+"The fifth number is the time elapsed from the start of the request processing \n"
+"until we start delivering the object to the client.\n" 
+"The sixth and last number is the time from we start delivering the object\n" 
+"until the request completes. ")
 SLTM(SessionOpen, "Client connection opened", "")
-SLTM(SessionClose, "Client connection closed", "")
+SLTM(SessionClose, "Client connection closed", "SessionClose tells you why HTTP\n"
+"client-connections are closed. These can be:\n"
+"timeout - No keep-alive was received within sess_timeout\n"
+"Connection: close - The client specifed that keepalive should be disabled by sending a 'Connection: close' header.\n"
+"no request - No initial request was received within sess_timeout.\n"
+"EOF - ???\n"
+"remote closed - ???\n"
+"error - Processing reached vcl_error even if the status code indicates success\n"
+"blast - ???")
 SLTM(BackendOpen, "Backend connection opened", "")
 SLTM(BackendXID, "The unique ID of the backend transaction", "")
 SLTM(BackendReuse, "Backend connection reused", "")



From phk at varnish-cache.org  Tue Jun 19 08:52:41 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Tue, 19 Jun 2012 10:52:41 +0200
Subject: [master] c0cf227 Another big wash of s/sp/req/ changes
Message-ID: <E1SguAz-0000OF-5f@project.varnish-software.com>

commit c0cf227af98f8c74a26aee28f5d316cacaf11679
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Tue Jun 19 08:52:22 2012 +0000

    Another big wash of s/sp/req/ changes

diff --git a/bin/varnishd/cache/cache.h b/bin/varnishd/cache/cache.h
index 03c3edf..845fac6 100644
--- a/bin/varnishd/cache/cache.h
+++ b/bin/varnishd/cache/cache.h
@@ -695,8 +695,8 @@ void VBE_UseHealth(const struct director *vdi);
 void VBE_DiscardHealth(const struct director *vdi);
 
 
-struct vbc *VDI_GetFd(const struct director *, struct sess *sp);
-int VDI_Healthy(const struct director *, const struct sess *sp);
+struct vbc *VDI_GetFd(const struct director *, struct req *);
+int VDI_Healthy(const struct director *, const struct req *);
 void VDI_CloseFd(struct vbc **vbp);
 void VDI_RecycleFd(struct vbc **vbp);
 void VDI_AddHostHeader(struct http *to, const struct vbc *vbc);
@@ -719,7 +719,7 @@ void BAN_Insert(struct ban *b);
 void BAN_Init(void);
 void BAN_NewObjCore(struct objcore *oc);
 void BAN_DestroyObj(struct objcore *oc);
-int BAN_CheckObject(struct object *o, const struct sess *sp);
+int BAN_CheckObject(struct object *o, struct req *sp);
 void BAN_Reload(const uint8_t *ban, unsigned len);
 struct ban *BAN_TailRef(void);
 void BAN_Compile(void);
@@ -766,9 +766,9 @@ int EXP_NukeOne(struct busyobj *, struct lru *lru);
 struct storage *FetchStorage(struct busyobj *, ssize_t sz);
 int FetchError(struct busyobj *, const char *error);
 int FetchError2(struct busyobj *, const char *error, const char *more);
-int FetchHdr(struct sess *sp, int need_host_hdr, int sendbody);
+int FetchHdr(struct req *req, int need_host_hdr, int sendbody);
 void FetchBody(struct worker *w, void *bo);
-int FetchReqBody(const struct sess *sp, int sendbody);
+int FetchReqBody(struct req *, int sendbody);
 void Fetch_Init(void);
 
 /* cache_gzip.c */
@@ -809,7 +809,7 @@ void http_ClrHeader(struct http *to);
 unsigned http_Write(const struct worker *w, const struct http *hp, int resp);
 void http_SetResp(struct http *to, const char *proto, uint16_t status,
     const char *response);
-void http_FilterReq(const struct sess *sp, unsigned how);
+void http_FilterReq(const struct req *, unsigned how);
 void http_FilterResp(const struct http *fm, struct http *to, unsigned how);
 void http_PutProtocol(const struct http *to, const char *protocol);
 void http_PutStatus(struct http *to, uint16_t status);
@@ -830,7 +830,7 @@ double http_GetHdrQ(const struct http *hp, const char *hdr, const char *field);
 uint16_t http_GetStatus(const struct http *hp);
 const char *http_GetReq(const struct http *hp);
 int http_HdrIs(const struct http *hp, const char *hdr, const char *val);
-uint16_t http_DissectRequest(const struct sess *sp);
+uint16_t http_DissectRequest(struct req *);
 uint16_t http_DissectResponse(struct http *sp, const struct http_conn *htc);
 const char *http_DoConnection(const struct http *hp);
 void http_CopyHome(const struct http *hp);
@@ -954,8 +954,8 @@ void VSL_Flush(struct vsl_log *, int overflow);
 #endif
 
 /* cache_response.c */
-void RES_BuildHttp(const struct sess *sp);
-void RES_WriteObj(struct sess *sp);
+void RES_BuildHttp(struct req *);
+void RES_WriteObj(struct req *);
 
 /* cache_vary.c */
 struct vsb *VRY_Create(struct req *sp, const struct http *hp);
@@ -979,7 +979,7 @@ const char *VCL_Return_Name(unsigned method);
 char *VRT_String(struct ws *ws, const char *h, const char *p, va_list ap);
 char *VRT_StringList(char *d, unsigned dl, const char *p, va_list ap);
 
-void ESI_Deliver(struct sess *);
+void ESI_Deliver(struct req *);
 void ESI_DeliverChild(const struct sess *);
 
 /* cache_vrt_vmod.c */
diff --git a/bin/varnishd/cache/cache_backend.c b/bin/varnishd/cache/cache_backend.c
index fb116bf..e640a30 100644
--- a/bin/varnishd/cache/cache_backend.c
+++ b/bin/varnishd/cache/cache_backend.c
@@ -452,32 +452,32 @@ VBE_DiscardHealth(const struct director *vdi)
  */
 
 static struct vbc * __match_proto__(vdi_getfd_f)
-vdi_simple_getfd(const struct director *d, struct sess *sp)
+vdi_simple_getfd(const struct director *d, struct req *req)
 {
 	struct vdi_simple *vs;
 	struct vbc *vc;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
 	CAST_OBJ_NOTNULL(vs, d->priv, VDI_SIMPLE_MAGIC);
-	vc = vbe_GetVbe(sp, vs);
+	vc = vbe_GetVbe(req->sp, vs);
 	if (vc != NULL) {
 		FIND_TMO(first_byte_timeout,
-		    vc->first_byte_timeout, sp, vs->vrt);
+		    vc->first_byte_timeout, req->sp, vs->vrt);
 		FIND_TMO(between_bytes_timeout,
-		    vc->between_bytes_timeout, sp, vs->vrt);
+		    vc->between_bytes_timeout, req->sp, vs->vrt);
 	}
 	return (vc);
 }
 
 static unsigned
-vdi_simple_healthy(const struct director *d, const struct sess *sp)
+vdi_simple_healthy(const struct director *d, const struct req *req)
 {
 	struct vdi_simple *vs;
 
 	CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
 	CAST_OBJ_NOTNULL(vs, d->priv, VDI_SIMPLE_MAGIC);
-	return (vbe_Healthy(vs, sp));
+	return (vbe_Healthy(vs, req->sp));
 }
 
 static void
diff --git a/bin/varnishd/cache/cache_backend.h b/bin/varnishd/cache/cache_backend.h
index 96f0a63..3baa0ca 100644
--- a/bin/varnishd/cache/cache_backend.h
+++ b/bin/varnishd/cache/cache_backend.h
@@ -75,9 +75,9 @@ struct vrt_backend_probe;
  * backends to use.
  */
 
-typedef struct vbc *vdi_getfd_f(const struct director *, struct sess *sp);
+typedef struct vbc *vdi_getfd_f(const struct director *, struct req *);
 typedef void vdi_fini_f(const struct director *);
-typedef unsigned vdi_healthy(const struct director *, const struct sess *sp);
+typedef unsigned vdi_healthy(const struct director *, const struct req *);
 
 struct director {
 	unsigned		magic;
diff --git a/bin/varnishd/cache/cache_ban.c b/bin/varnishd/cache/cache_ban.c
index 6986d21..be8af1a 100644
--- a/bin/varnishd/cache/cache_ban.c
+++ b/bin/varnishd/cache/cache_ban.c
@@ -765,10 +765,10 @@ ban_check_object(struct object *o, struct vsl_log *vsl,
 }
 
 int
-BAN_CheckObject(struct object *o, const struct sess *sp)
+BAN_CheckObject(struct object *o, struct req *req)
 {
 
-	return (ban_check_object(o, sp->req->vsl, sp->req->http) > 0);
+	return (ban_check_object(o, req->vsl, req->http) > 0);
 }
 
 static struct ban *
diff --git a/bin/varnishd/cache/cache_center.c b/bin/varnishd/cache/cache_center.c
index 729b91b..240d0d0 100644
--- a/bin/varnishd/cache/cache_center.c
+++ b/bin/varnishd/cache/cache_center.c
@@ -265,7 +265,7 @@ cnt_prepresp(struct sess *sp, struct worker *wrk, struct req *req)
 			req->obj->last_use = req->t_resp; /* XXX: locking ? */
 	}
 	HTTP_Setup(req->resp, req->ws, req->vsl, HTTP_Resp);
-	RES_BuildHttp(sp);
+	RES_BuildHttp(req);
 
 	assert(req->sp == sp);
 	VCL_deliver_method(req);
@@ -340,7 +340,7 @@ cnt_deliver(struct sess *sp, struct worker *wrk, struct req *req)
 	req->director = NULL;
 	req->restarts = 0;
 
-	RES_WriteObj(sp);
+	RES_WriteObj(req);
 
 	/* No point in saving the body if it is hit-for-pass */
 	if (req->obj->objcore->flags & OC_F_PASS)
@@ -591,7 +591,7 @@ cnt_fetch(struct sess *sp, struct worker *wrk, struct req *req)
 
 	wrk->acct_tmp.fetch++;
 
-	i = FetchHdr(sp, need_host_hdr, req->objcore->objhead == NULL);
+	i = FetchHdr(req, need_host_hdr, req->objcore->objhead == NULL);
 	/*
 	 * If we recycle a backend connection, there is a finite chance
 	 * that the backend closed it before we get a request to it.
@@ -599,7 +599,7 @@ cnt_fetch(struct sess *sp, struct worker *wrk, struct req *req)
 	 */
 	if (i == 1) {
 		VSC_C_main->backend_retry++;
-		i = FetchHdr(sp, need_host_hdr, req->objcore->objhead == NULL);
+		i = FetchHdr(req, need_host_hdr, req->objcore->objhead == NULL);
 	}
 
 	if (i) {
@@ -1016,7 +1016,7 @@ cnt_hit(struct sess *sp, struct worker *wrk, struct req *req)
 	if (req->handling == VCL_RET_DELIVER) {
 		//AZ(req->busyobj->bereq->ws);
 		//AZ(req->busyobj->beresp->ws);
-		(void)FetchReqBody(sp, 0);
+		(void)FetchReqBody(req, 0);
 		sp->step = STP_PREPRESP;
 		return (0);
 	}
@@ -1173,7 +1173,7 @@ cnt_miss(struct sess *sp, struct worker *wrk, struct req *req)
 	AZ(req->obj);
 
 	HTTP_Setup(bo->bereq, bo->ws, bo->vsl, HTTP_Bereq);
-	http_FilterReq(sp, HTTPH_R_FETCH);
+	http_FilterReq(req, HTTPH_R_FETCH);
 	http_ForceGet(bo->bereq);
 	if (cache_param->http_gzip_support) {
 		/*
@@ -1251,7 +1251,7 @@ cnt_pass(struct sess *sp, struct worker *wrk, struct req *req)
 	bo->vsl->wid = sp->vsl_id;
 	bo->refcount = 2;
 	HTTP_Setup(bo->bereq, bo->ws, bo->vsl, HTTP_Bereq);
-	http_FilterReq(sp, HTTPH_R_PASS);
+	http_FilterReq(req, HTTPH_R_PASS);
 
 	assert(req->sp == sp);
 	VCL_pass_method(req);
@@ -1313,7 +1313,7 @@ cnt_pipe(struct sess *sp, struct worker *wrk, struct req *req)
 	bo = req->busyobj;
 	bo->vsl->wid = sp->vsl_id;
 	HTTP_Setup(bo->bereq, bo->ws, bo->vsl, HTTP_Bereq);
-	http_FilterReq(sp, 0);
+	http_FilterReq(req, 0);
 
 	assert(req->sp == sp);
 	VCL_pipe_method(req);
@@ -1514,7 +1514,7 @@ cnt_start(struct sess *sp, struct worker *wrk, struct req *req)
 	EXP_Clr(&req->exp);
 
 	HTTP_Setup(req->http, req->ws, req->vsl, HTTP_Req);
-	req->err_code = http_DissectRequest(sp);
+	req->err_code = http_DissectRequest(req);
 
 	/* If we could not even parse the request, just close */
 	if (req->err_code == 400) {
diff --git a/bin/varnishd/cache/cache_dir.c b/bin/varnishd/cache/cache_dir.c
index 6dda80d..528a57c 100644
--- a/bin/varnishd/cache/cache_dir.c
+++ b/bin/varnishd/cache/cache_dir.c
@@ -105,17 +105,17 @@ VDI_RecycleFd(struct vbc **vbp)
 /* Get a connection --------------------------------------------------*/
 
 struct vbc *
-VDI_GetFd(const struct director *d, struct sess *sp)
+VDI_GetFd(const struct director *d, struct req *req)
 {
 	struct vbc *vc;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	if (d == NULL)
-		d = sp->req->director;
+		d = req->director;
 	CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
-	vc = d->getfd(d, sp);
+	vc = d->getfd(d, req);
 	if (vc != NULL) {
-		vc->vsl = sp->req->busyobj->vsl;
+		vc->vsl = req->busyobj->vsl;
 		vc->orig_vsl_id = vc->vsl->wid;
 		vc->vsl->wid = vc->vsl_id;
 	}
@@ -130,10 +130,10 @@ VDI_GetFd(const struct director *d, struct sess *sp)
  */
 
 int
-VDI_Healthy(const struct director *d, const struct sess *sp)
+VDI_Healthy(const struct director *d, const struct req *req)
 {
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
-	return (d->healthy(d, sp));
+	return (d->healthy(d, req));
 }
diff --git a/bin/varnishd/cache/cache_dir_dns.c b/bin/varnishd/cache/cache_dir_dns.c
index 068c2b9..e947f61 100644
--- a/bin/varnishd/cache/cache_dir_dns.c
+++ b/bin/varnishd/cache/cache_dir_dns.c
@@ -150,7 +150,7 @@ vdi_dns_pick_host(const struct sess *sp, struct vdi_dns_hostgroup *group) {
 			current = i + initial - nhosts;
 		else
 			current = i + initial;
-		if (VDI_Healthy(group->hosts[current], sp)) {
+		if (VDI_Healthy(group->hosts[current], sp->req)) {
 			group->next_host = current+1;
 			return (group->hosts[current]);
 		}
@@ -372,31 +372,31 @@ vdi_dns_find_backend(const struct sess *sp, struct vdi_dns *vs)
 }
 
 static struct vbc *
-vdi_dns_getfd(const struct director *director, struct sess *sp)
+vdi_dns_getfd(const struct director *director, struct req *req)
 {
 	struct vdi_dns *vs;
 	struct director *dir;
 	struct vbc *vbe;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	CHECK_OBJ_NOTNULL(director, DIRECTOR_MAGIC);
 	CAST_OBJ_NOTNULL(vs, director->priv, VDI_DNS_MAGIC);
 
-	dir = vdi_dns_find_backend(sp, vs);
-	if (!dir || !VDI_Healthy(dir, sp))
+	dir = vdi_dns_find_backend(req->sp, vs);
+	if (!dir || !VDI_Healthy(dir, req))
 		return (NULL);
 
-	vbe = VDI_GetFd(dir, sp);
+	vbe = VDI_GetFd(dir, req);
 	return (vbe);
 }
 
 static unsigned
-vdi_dns_healthy(const struct director *dir, const struct sess *sp)
+vdi_dns_healthy(const struct director *dir, const struct req *req)
 {
 	/* XXX: Fooling -Werror for a bit until it's actually implemented.
 	 */
 	(void)dir;
-	(void)sp;
+	(void)req;
 	return (1);
 
 	/*
@@ -404,11 +404,11 @@ vdi_dns_healthy(const struct director *dir, const struct sess *sp)
 	struct director *dir;
 	int i;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	CHECK_OBJ_NOTNULL(sp->req->director, DIRECTOR_MAGIC);
-	CAST_OBJ_NOTNULL(vs, sp->req->director->priv, VDI_DNS_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	CHECK_OBJ_NOTNULL(req->director, DIRECTOR_MAGIC);
+	CAST_OBJ_NOTNULL(vs, req->director->priv, VDI_DNS_MAGIC);
 
-	dir = vdi_dns_find_backend(sp, vs);
+	dir = vdi_dns_find_backend(req->sp, vs);
 
 	if (dir)
 		return (1);
diff --git a/bin/varnishd/cache/cache_dir_random.c b/bin/varnishd/cache/cache_dir_random.c
index 8a0bcd2..c291fe0 100644
--- a/bin/varnishd/cache/cache_dir_random.c
+++ b/bin/varnishd/cache/cache_dir_random.c
@@ -98,22 +98,22 @@ vdi_random_sha(const char *input, ssize_t len)
  * Sets up the initial seed for picking a backend according to policy.
  */
 static double
-vdi_random_init_seed(const struct vdi_random *vs, const struct sess *sp)
+vdi_random_init_seed(const struct vdi_random *vs, const struct req *req)
 {
 	const char *p;
 	double retval;
 
 	switch (vs->criteria) {
 	case c_client:
-		if (sp->req->client_identity != NULL)
-			p = sp->req->client_identity;
+		if (req->client_identity != NULL)
+			p = req->client_identity;
 		else
-			p = sp->addr;
+			p = req->sp->addr;
 		retval = vdi_random_sha(p, strlen(p));
 		break;
 	case c_hash:
-		AN(sp->req->digest);
-		retval = scalbn(vle32dec(sp->req->digest), -32);
+		AN(req->digest);
+		retval = scalbn(vle32dec(req->digest), -32);
 		break;
 	case c_random:
 	default:
@@ -127,7 +127,7 @@ vdi_random_init_seed(const struct vdi_random *vs, const struct sess *sp)
  * Find the healthy backend corresponding to the weight r [0...1[
  */
 static struct vbc *
-vdi_random_pick_one(struct sess *sp, const struct vdi_random *vs, double r,
+vdi_random_pick_one(struct req *req, const struct vdi_random *vs, double r,
     int retries)
 {
 	double w[vs->nhosts];
@@ -154,9 +154,9 @@ vdi_random_pick_one(struct sess *sp, const struct vdi_random *vs, double r,
 			s2 += w[i];
 			if (r >= s2)
 				continue;
-			if (!VDI_Healthy(vs->hosts[i].backend, sp))
+			if (!VDI_Healthy(vs->hosts[i].backend, req))
 				break;
-			vbc = VDI_GetFd(vs->hosts[i].backend, sp);
+			vbc = VDI_GetFd(vs->hosts[i].backend, req);
 			if (vbc == NULL)
 				break;
 			return (vbc);
@@ -181,18 +181,18 @@ vdi_random_pick_one(struct sess *sp, const struct vdi_random *vs, double r,
  * random by rehashing the key.
  */
 static struct vbc *
-vdi_random_getfd(const struct director *d, struct sess *sp)
+vdi_random_getfd(const struct director *d, struct req *req)
 {
 	struct vdi_random *vs;
 	double r;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
 	CAST_OBJ_NOTNULL(vs, d->priv, VDI_RANDOM_MAGIC);
 
-	r = vdi_random_init_seed(vs, sp);
+	r = vdi_random_init_seed(vs, req);
 
-	return (vdi_random_pick_one(sp, vs, r, vs->retries));
+	return (vdi_random_pick_one(req, vs, r, vs->retries));
 }
 
 /*
@@ -200,7 +200,7 @@ vdi_random_getfd(const struct director *d, struct sess *sp)
  * XXX: we should really have a weight param/criteria here
  */
 static unsigned
-vdi_random_healthy(const struct director *d, const struct sess *sp)
+vdi_random_healthy(const struct director *d, const struct req *req)
 {
 	struct vdi_random *vs;
 	int i;
@@ -209,7 +209,7 @@ vdi_random_healthy(const struct director *d, const struct sess *sp)
 	CAST_OBJ_NOTNULL(vs, d->priv, VDI_RANDOM_MAGIC);
 
 	for (i = 0; i < vs->nhosts; i++) {
-		if (VDI_Healthy(vs->hosts[i].backend, sp))
+		if (VDI_Healthy(vs->hosts[i].backend, req))
 			return (1);
 	}
 	return (0);
diff --git a/bin/varnishd/cache/cache_dir_round_robin.c b/bin/varnishd/cache/cache_dir_round_robin.c
index 350f18c..68e7071 100644
--- a/bin/varnishd/cache/cache_dir_round_robin.c
+++ b/bin/varnishd/cache/cache_dir_round_robin.c
@@ -55,14 +55,14 @@ struct vdi_round_robin {
 };
 
 static struct vbc *
-vdi_round_robin_getfd(const struct director *d, struct sess *sp)
+vdi_round_robin_getfd(const struct director *d, struct req *req)
 {
 	int i;
 	struct vdi_round_robin *vs;
 	struct director *backend;
 	struct vbc *vbe;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
 	CAST_OBJ_NOTNULL(vs, d->priv, VDI_ROUND_ROBIN_MAGIC);
 
@@ -77,9 +77,9 @@ vdi_round_robin_getfd(const struct director *d, struct sess *sp)
 		} else /* m_fallback */ {
 			backend = vs->hosts[i].backend;
 		}
-		if (!VDI_Healthy(backend, sp))
+		if (!VDI_Healthy(backend, req))
 			continue;
-		vbe = VDI_GetFd(backend, sp);
+		vbe = VDI_GetFd(backend, req);
 		if (vbe != NULL)
 			return (vbe);
 	}
@@ -88,7 +88,7 @@ vdi_round_robin_getfd(const struct director *d, struct sess *sp)
 }
 
 static unsigned
-vdi_round_robin_healthy(const struct director *d, const struct sess *sp)
+vdi_round_robin_healthy(const struct director *d, const struct req *req)
 {
 	struct vdi_round_robin *vs;
 	struct director *backend;
@@ -99,7 +99,7 @@ vdi_round_robin_healthy(const struct director *d, const struct sess *sp)
 
 	for (i = 0; i < vs->nhosts; i++) {
 		backend = vs->hosts[i].backend;
-		if (VDI_Healthy(backend, sp))
+		if (VDI_Healthy(backend, req))
 			return (1);
 	}
 	return (0);
diff --git a/bin/varnishd/cache/cache_esi_deliver.c b/bin/varnishd/cache/cache_esi_deliver.c
index 73aac72..9199d67 100644
--- a/bin/varnishd/cache/cache_esi_deliver.c
+++ b/bin/varnishd/cache/cache_esi_deliver.c
@@ -42,7 +42,7 @@
 /*--------------------------------------------------------------------*/
 
 static void
-ved_include(struct sess *sp, const char *src, const char *host)
+ved_include(struct req *req, const char *src, const char *host)
 {
 	struct object *obj;
 	struct worker *wrk;
@@ -50,71 +50,71 @@ ved_include(struct sess *sp, const char *src, const char *host)
 	char *wrk_ws_wm;
 	unsigned sxid, res_mode;
 
-	wrk = sp->wrk;
+	wrk = req->sp->wrk;
 
-	if (sp->req->esi_level >= cache_param->max_esi_depth)
+	if (req->esi_level >= cache_param->max_esi_depth)
 		return;
-	sp->req->esi_level++;
+	req->esi_level++;
 
 	(void)WRW_FlushRelease(wrk);
 
-	obj = sp->req->obj;
-	sp->req->obj = NULL;
-	res_mode = sp->req->res_mode;
+	obj = req->obj;
+	req->obj = NULL;
+	res_mode = req->res_mode;
 
 	/* Reset request to status before we started messing with it */
-	HTTP_Copy(sp->req->http, sp->req->http0);
+	HTTP_Copy(req->http, req->http0);
 
 	/* Take a workspace snapshot */
-	sp_ws_wm = WS_Snapshot(sp->req->ws);
+	sp_ws_wm = WS_Snapshot(req->ws);
 	wrk_ws_wm = WS_Snapshot(wrk->aws); /* XXX ? */
 
-	http_SetH(sp->req->http, HTTP_HDR_URL, src);
+	http_SetH(req->http, HTTP_HDR_URL, src);
 	if (host != NULL && *host != '\0')  {
-		http_Unset(sp->req->http, H_Host);
-		http_Unset(sp->req->http, H_If_Modified_Since);
-		http_SetHeader(sp->req->http, host);
+		http_Unset(req->http, H_Host);
+		http_Unset(req->http, H_If_Modified_Since);
+		http_SetHeader(req->http, host);
 	}
 	/*
 	 * XXX: We should decide if we should cache the director
 	 * XXX: or not (for session/backend coupling).  Until then
 	 * XXX: make sure we don't trip up the check in vcl_recv.
 	 */
-	sp->req->director = NULL;
-	sp->step = STP_RECV;
-	http_ForceGet(sp->req->http);
+	req->director = NULL;
+	req->sp->step = STP_RECV;
+	http_ForceGet(req->http);
 
 	/* Don't do conditionals */
-	sp->req->http->conds = 0;
-	http_Unset(sp->req->http, H_If_Modified_Since);
+	req->http->conds = 0;
+	http_Unset(req->http, H_If_Modified_Since);
 
 	/* Client content already taken care of */
-	http_Unset(sp->req->http, H_Content_Length);
+	http_Unset(req->http, H_Content_Length);
 
-	sxid = sp->req->xid;
+	sxid = req->xid;
 	while (1) {
-		sp->wrk = wrk;
-		CNT_Session(sp);
-		if (sp->step == STP_DONE)
+		req->sp->wrk = wrk;
+		CNT_Session(req->sp);
+		if (req->sp->step == STP_DONE)
 			break;
-		AZ(sp->wrk);
-		DSL(0x20, SLT_Debug, sp->vsl_id, "loop waiting for ESI");
+		AZ(req->sp->wrk);
+		DSL(0x20, SLT_Debug, req->sp->vsl_id, "loop waiting for ESI");
 		(void)usleep(10000);
 	}
-	sp->req->xid = sxid;
-	AN(sp->wrk);
-	assert(sp->step == STP_DONE);
-	sp->req->esi_level--;
-	sp->req->obj = obj;
-	sp->req->res_mode = res_mode;
+	req->xid = sxid;
+	AN(req->sp->wrk);
+	assert(req->sp->step == STP_DONE);
+	req->esi_level--;
+	req->obj = obj;
+	req->res_mode = res_mode;
 
 	/* Reset the workspace */
-	WS_Reset(sp->req->ws, sp_ws_wm);
+	WS_Reset(req->ws, sp_ws_wm);
 	WS_Reset(wrk->aws, wrk_ws_wm);	/* XXX ? */
 
-	WRW_Reserve(sp->wrk, &sp->fd, sp->req->vsl, sp->req->t_resp);
-	if (sp->req->res_mode & RES_CHUNKED)
-		WRW_Chunked(sp->wrk);
+	WRW_Reserve(req->sp->wrk, &req->sp->fd, req->vsl, req->t_resp);
+	if (req->res_mode & RES_CHUNKED)
+		WRW_Chunked(req->sp->wrk);
 }
 
 /*--------------------------------------------------------------------*/
@@ -171,7 +171,7 @@ ved_decode_len(uint8_t **pp)
  */
 
 static void
-ved_pretend_gzip(const struct sess *sp, const uint8_t *p, ssize_t l)
+ved_pretend_gzip(struct req *req, const uint8_t *p, ssize_t l)
 {
 	uint8_t buf1[5], buf2[5];
 	uint16_t lx;
@@ -184,22 +184,22 @@ ved_pretend_gzip(const struct sess *sp, const uint8_t *p, ssize_t l)
 	while (l > 0) {
 		if (l >= 65535) {
 			lx = 65535;
-			(void)WRW_Write(sp->wrk, buf1, sizeof buf1);
+			(void)WRW_Write(req->sp->wrk, buf1, sizeof buf1);
 		} else {
 			lx = (uint16_t)l;
 			buf2[0] = 0;
 			vle16enc(buf2 + 1, lx);
 			vle16enc(buf2 + 3, ~lx);
-			(void)WRW_Write(sp->wrk, buf2, sizeof buf2);
+			(void)WRW_Write(req->sp->wrk, buf2, sizeof buf2);
 		}
-		(void)WRW_Write(sp->wrk, p, lx);
-		sp->req->crc = crc32(sp->req->crc, p, lx);
-		sp->req->l_crc += lx;
+		(void)WRW_Write(req->sp->wrk, p, lx);
+		req->crc = crc32(req->crc, p, lx);
+		req->l_crc += lx;
 		l -= lx;
 		p += lx;
 	}
 	/* buf2 is local, have to flush */
-	(void)WRW_Flush(sp->wrk);
+	(void)WRW_Flush(req->sp->wrk);
 }
 
 /*---------------------------------------------------------------------
@@ -213,7 +213,7 @@ static const uint8_t gzip_hdr[] = {
 };
 
 void
-ESI_Deliver(struct sess *sp)
+ESI_Deliver(struct req *req)
 {
 	struct storage *st;
 	uint8_t *p, *e, *q, *r;
@@ -227,8 +227,8 @@ ESI_Deliver(struct sess *sp)
 	const void *dp;
 	int i;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	st = sp->req->obj->esidata;
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	st = req->obj->esidata;
 	AN(st);
 
 	p = st->ptr;
@@ -241,23 +241,23 @@ ESI_Deliver(struct sess *sp)
 		isgzip = 0;
 	}
 
-	if (sp->req->esi_level == 0) {
+	if (req->esi_level == 0) {
 		/*
 		 * Only the top level document gets to decide this.
 		 */
-		sp->req->gzip_resp = 0;
-		if (isgzip && !(sp->req->res_mode & RES_GUNZIP)) {
+		req->gzip_resp = 0;
+		if (isgzip && !(req->res_mode & RES_GUNZIP)) {
 			assert(sizeof gzip_hdr == 10);
 			/* Send out the gzip header */
-			(void)WRW_Write(sp->wrk, gzip_hdr, 10);
-			sp->req->l_crc = 0;
-			sp->req->gzip_resp = 1;
-			sp->req->crc = crc32(0L, Z_NULL, 0);
+			(void)WRW_Write(req->sp->wrk, gzip_hdr, 10);
+			req->l_crc = 0;
+			req->gzip_resp = 1;
+			req->crc = crc32(0L, Z_NULL, 0);
 		}
 	}
 
-	if (isgzip && !sp->req->gzip_resp) {
-		vgz = VGZ_NewUngzip(sp->req->vsl, "U D E");
+	if (isgzip && !req->gzip_resp) {
+		vgz = VGZ_NewUngzip(req->vsl, "U D E");
 		AZ(VGZ_WrwInit(vgz));
 
 		/* Feed a gzip header to gunzip to make it happy */
@@ -268,7 +268,7 @@ ESI_Deliver(struct sess *sp)
 		assert(dl == 0);
 	}
 
-	st = VTAILQ_FIRST(&sp->req->obj->store);
+	st = VTAILQ_FIRST(&req->obj->store);
 	off = 0;
 
 	while (p < e) {
@@ -283,10 +283,10 @@ ESI_Deliver(struct sess *sp)
 				l_icrc = ved_decode_len(&p);
 				icrc = vbe32dec(p);
 				p += 4;
-				if (sp->req->gzip_resp) {
-					sp->req->crc = crc32_combine(
-					    sp->req->crc, icrc, l_icrc);
-					sp->req->l_crc += l_icrc;
+				if (req->gzip_resp) {
+					req->crc = crc32_combine(
+					    req->crc, icrc, l_icrc);
+					req->l_crc += l_icrc;
 				}
 			}
 			/*
@@ -300,29 +300,31 @@ ESI_Deliver(struct sess *sp)
 					l2 = st->len - off;
 				l -= l2;
 
-				if (sp->req->gzip_resp && isgzip) {
+				if (req->gzip_resp && isgzip) {
 					/*
 					 * We have a gzip'ed VEC and delivers
 					 * a gzip'ed ESI response.
 					 */
-					(void)WRW_Write(sp->wrk,
+					(void)WRW_Write(req->sp->wrk,
 					    st->ptr + off, l2);
-				} else if (sp->req->gzip_resp) {
+				} else if (req->gzip_resp) {
 					/*
 					 * A gzip'ed ESI response, but the VEC
 					 * was not gzip'ed.
 					 */
-					ved_pretend_gzip(sp, st->ptr + off, l2);
+					ved_pretend_gzip(req,
+					    st->ptr + off, l2);
 				} else if (isgzip) {
 					/*
 					 * A gzip'ed VEC, but ungzip'ed ESI
 					 * response
 					 */
 					AN(vgz);
-					i = VGZ_WrwGunzip(sp->wrk, vgz,
+					i = VGZ_WrwGunzip(req->sp->wrk, vgz,
 						st->ptr + off, l2);
-					if (WRW_Error(sp->wrk)) {
-						SES_Close(sp, "remote closed");
+					if (WRW_Error(req->sp->wrk)) {
+						SES_Close(req->sp,
+						    "remote closed");
 						p = e;
 						break;
 					}
@@ -331,7 +333,7 @@ ESI_Deliver(struct sess *sp)
 					/*
 					 * Ungzip'ed VEC, ungzip'ed ESI response
 					 */
-					(void)WRW_Write(sp->wrk,
+					(void)WRW_Write(req->sp->wrk,
 					    st->ptr + off, l2);
 				}
 				off += l2;
@@ -371,14 +373,14 @@ ESI_Deliver(struct sess *sp)
 			r = (void*)strchr((const char*)q, '\0');
 			AN(r);
 			if (vgz != NULL)
-				VGZ_WrwFlush(sp->wrk, vgz);
-			if (WRW_Flush(sp->wrk)) {
-				SES_Close(sp, "remote closed");
+				VGZ_WrwFlush(req->sp->wrk, vgz);
+			if (WRW_Flush(req->sp->wrk)) {
+				SES_Close(req->sp, "remote closed");
 				p = e;
 				break;
 			}
 			Debug("INCL [%s][%s] BEGIN\n", q, p);
-			ved_include(sp, (const char*)q, (const char*)p);
+			ved_include(req, (const char*)q, (const char*)p);
 			Debug("INCL [%s][%s] END\n", q, p);
 			p = r + 1;
 			break;
@@ -388,10 +390,10 @@ ESI_Deliver(struct sess *sp)
 		}
 	}
 	if (vgz != NULL) {
-		VGZ_WrwFlush(sp->wrk, vgz);
+		VGZ_WrwFlush(req->sp->wrk, vgz);
 		(void)VGZ_Destroy(&vgz);
 	}
-	if (sp->req->gzip_resp && sp->req->esi_level == 0) {
+	if (req->gzip_resp && req->esi_level == 0) {
 		/* Emit a gzip literal block with finish bit set */
 		tailbuf[0] = 0x01;
 		tailbuf[1] = 0x00;
@@ -400,14 +402,14 @@ ESI_Deliver(struct sess *sp)
 		tailbuf[4] = 0xff;
 
 		/* Emit CRC32 */
-		vle32enc(tailbuf + 5, sp->req->crc);
+		vle32enc(tailbuf + 5, req->crc);
 
 		/* MOD(2^32) length */
-		vle32enc(tailbuf + 9, sp->req->l_crc);
+		vle32enc(tailbuf + 9, req->l_crc);
 
-		(void)WRW_Write(sp->wrk, tailbuf, 13);
+		(void)WRW_Write(req->sp->wrk, tailbuf, 13);
 	}
-	(void)WRW_Flush(sp->wrk);
+	(void)WRW_Flush(req->sp->wrk);
 }
 
 /*---------------------------------------------------------------------
@@ -464,7 +466,7 @@ ESI_DeliverChild(const struct sess *sp)
 
 	if (!sp->req->obj->gziped) {
 		VTAILQ_FOREACH(st, &sp->req->obj->store, list)
-			ved_pretend_gzip(sp, st->ptr, st->len);
+			ved_pretend_gzip(sp->req, st->ptr, st->len);
 		return;
 	}
 	/*
diff --git a/bin/varnishd/cache/cache_fetch.c b/bin/varnishd/cache/cache_fetch.c
index 7ccba0a..129a0a7 100644
--- a/bin/varnishd/cache/cache_fetch.c
+++ b/bin/varnishd/cache/cache_fetch.c
@@ -378,20 +378,20 @@ fetch_eof(struct busyobj *bo, struct http_conn *htc)
  */
 
 int
-FetchReqBody(const struct sess *sp, int sendbody)
+FetchReqBody(struct req *req, int sendbody)
 {
 	unsigned long content_length;
 	char buf[8192];
 	char *ptr, *endp;
 	int rdcnt;
 
-	if (sp->req->reqbodydone) {
+	if (req->reqbodydone) {
 		AZ(sendbody);
 		return (0);
 	}
 
-	if (http_GetHdr(sp->req->http, H_Content_Length, &ptr)) {
-		sp->req->reqbodydone = 1;
+	if (http_GetHdr(req->http, H_Content_Length, &ptr)) {
+		req->reqbodydone = 1;
 
 		content_length = strtoul(ptr, &endp, 10);
 		/* XXX should check result of conversion */
@@ -400,21 +400,21 @@ FetchReqBody(const struct sess *sp, int sendbody)
 				rdcnt = sizeof buf;
 			else
 				rdcnt = content_length;
-			rdcnt = HTC_Read(sp->req->htc, buf, rdcnt);
+			rdcnt = HTC_Read(req->htc, buf, rdcnt);
 			if (rdcnt <= 0)
 				return (1);
 			content_length -= rdcnt;
 			if (sendbody) {
 				/* XXX: stats ? */
-				(void)WRW_Write(sp->wrk, buf, rdcnt);
-				if (WRW_Flush(sp->wrk))
+				(void)WRW_Write(req->sp->wrk, buf, rdcnt);
+				if (WRW_Flush(req->sp->wrk))
 					return (2);
 			}
 		}
 	}
-	if (http_GetHdr(sp->req->http, H_Transfer_Encoding, NULL)) {
+	if (http_GetHdr(req->http, H_Transfer_Encoding, NULL)) {
 		/* XXX: Handle chunked encoding. */
-		VSLb(sp->req->vsl, SLT_Debug, "Transfer-Encoding in request");
+		VSLb(req->vsl, SLT_Debug, "Transfer-Encoding in request");
 		return (1);
 	}
 	return (0);
@@ -431,20 +431,18 @@ FetchReqBody(const struct sess *sp, int sendbody)
  */
 
 int
-FetchHdr(struct sess *sp, int need_host_hdr, int sendbody)
+FetchHdr(struct req *req, int need_host_hdr, int sendbody)
 {
 	struct vbc *vc;
 	struct worker *wrk;
-	struct req *req;
 	struct busyobj *bo;
 	struct http *hp;
 	int retry = -1;
 	int i;
 	struct http_conn *htc;
 
-	wrk = sp->wrk;
+	wrk = req->sp->wrk;
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
-	req = sp->req;
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	bo = req->busyobj;
 	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
@@ -458,7 +456,7 @@ FetchHdr(struct sess *sp, int need_host_hdr, int sendbody)
 
 	hp = bo->bereq;
 
-	bo->vbc = VDI_GetFd(NULL, sp);
+	bo->vbc = VDI_GetFd(NULL, req);
 	if (bo->vbc == NULL) {
 		VSLb(req->vsl, SLT_FetchError, "no backend connection");
 		return (-1);
@@ -480,7 +478,7 @@ FetchHdr(struct sess *sp, int need_host_hdr, int sendbody)
 	(void)http_Write(wrk, hp, 0);	/* XXX: stats ? */
 
 	/* Deal with any message-body the request might have */
-	i = FetchReqBody(sp, sendbody);
+	i = FetchReqBody(req, sendbody);
 	if (WRW_FlushRelease(wrk) || i > 0) {
 		VSLb(req->vsl, SLT_FetchError,
 		    "backend write error: %d (%s)",
diff --git a/bin/varnishd/cache/cache_hash.c b/bin/varnishd/cache/cache_hash.c
index bfb030d..f2d5be3 100644
--- a/bin/varnishd/cache/cache_hash.c
+++ b/bin/varnishd/cache/cache_hash.c
@@ -358,7 +358,7 @@ HSH_Lookup(struct sess *sp)
 
 		if (o->exp.ttl <= 0.)
 			continue;
-		if (BAN_CheckObject(o, sp))
+		if (BAN_CheckObject(o, req))
 			continue;
 		if (o->vary != NULL && !VRY_Match(req, o->vary))
 			continue;
@@ -391,7 +391,7 @@ HSH_Lookup(struct sess *sp)
 	if (oc == NULL			/* We found no live object */
 	    && grace_oc != NULL		/* There is a grace candidate */
 	    && (busy_found		/* Somebody else is already busy */
-	    || !VDI_Healthy(req->director, sp))) {
+	    || !VDI_Healthy(req->director, req))) {
 					/* Or it is impossible to fetch */
 		o = oc_getobj(&wrk->stats, grace_oc);
 		CHECK_OBJ_NOTNULL(o, OBJECT_MAGIC);
diff --git a/bin/varnishd/cache/cache_http.c b/bin/varnishd/cache/cache_http.c
index 0380469..411b2d3 100644
--- a/bin/varnishd/cache/cache_http.c
+++ b/bin/varnishd/cache/cache_http.c
@@ -651,22 +651,22 @@ http_ProtoVer(struct http *hp)
 /*--------------------------------------------------------------------*/
 
 uint16_t
-http_DissectRequest(const struct sess *sp)
+http_DissectRequest(struct req *req)
 {
 	struct http_conn *htc;
 	struct http *hp;
 	uint16_t retval;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	htc = sp->req->htc;
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	htc = req->htc;
 	CHECK_OBJ_NOTNULL(htc, HTTP_CONN_MAGIC);
-	hp = sp->req->http;
+	hp = req->http;
 	CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
 
 	retval = http_splitline(hp, htc,
 	    HTTP_HDR_REQ, HTTP_HDR_URL, HTTP_HDR_PROTO);
 	if (retval != 0) {
-		VSLbt(sp->req->vsl, SLT_HttpGarbage, htc->rxbuf);
+		VSLbt(req->vsl, SLT_HttpGarbage, htc->rxbuf);
 		return (retval);
 	}
 	http_ProtoVer(hp);
@@ -838,21 +838,21 @@ http_filterfields(struct http *to, const struct http *fm, unsigned how)
 /*--------------------------------------------------------------------*/
 
 void
-http_FilterReq(const struct sess *sp, unsigned how)
+http_FilterReq(const struct req *req, unsigned how)
 {
 	struct http *hp;
 
-	hp = sp->req->busyobj->bereq;
+	hp = req->busyobj->bereq;
 	CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
 
-	http_linkh(hp, sp->req->http, HTTP_HDR_REQ);
-	http_linkh(hp, sp->req->http, HTTP_HDR_URL);
+	http_linkh(hp, req->http, HTTP_HDR_REQ);
+	http_linkh(hp, req->http, HTTP_HDR_URL);
 	if (how == HTTPH_R_FETCH)
 		http_SetH(hp, HTTP_HDR_PROTO, "HTTP/1.1");
 	else
-		http_linkh(hp, sp->req->http, HTTP_HDR_PROTO);
-	http_filterfields(hp, sp->req->http, how);
-	http_PrintfHeader(hp, "X-Varnish: %u", sp->req->xid);
+		http_linkh(hp, req->http, HTTP_HDR_PROTO);
+	http_filterfields(hp, req->http, how);
+	http_PrintfHeader(hp, "X-Varnish: %u", req->xid);
 }
 
 /*--------------------------------------------------------------------*/
diff --git a/bin/varnishd/cache/cache_pipe.c b/bin/varnishd/cache/cache_pipe.c
index fda21f4..77ffcda 100644
--- a/bin/varnishd/cache/cache_pipe.c
+++ b/bin/varnishd/cache/cache_pipe.c
@@ -74,7 +74,7 @@ PipeSession(struct sess *sp)
 	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
 	wrk = sp->wrk;
 
-	vc = VDI_GetFd(NULL, sp);
+	vc = VDI_GetFd(NULL, sp->req);
 	if (vc == NULL)
 		return;
 	bo->vbc = vc;		/* For panic dumping */
diff --git a/bin/varnishd/cache/cache_response.c b/bin/varnishd/cache/cache_response.c
index 700e791..59aa6cb 100644
--- a/bin/varnishd/cache/cache_response.c
+++ b/bin/varnishd/cache/cache_response.c
@@ -37,12 +37,10 @@
 /*--------------------------------------------------------------------*/
 
 static void
-res_dorange(const struct sess *sp, const char *r, ssize_t *plow, ssize_t *phigh)
+res_dorange(const struct req *req, const char *r, ssize_t *plow, ssize_t *phigh)
 {
 	ssize_t low, high, has_low;
-	struct req *req;
 
-	req = sp->req;
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	assert(req->obj->response == 200);
 	if (strncmp(r, "bytes=", 6))
@@ -105,13 +103,10 @@ res_dorange(const struct sess *sp, const char *r, ssize_t *plow, ssize_t *phigh)
 /*--------------------------------------------------------------------*/
 
 void
-RES_BuildHttp(const struct sess *sp)
+RES_BuildHttp(struct req *req)
 {
 	char time_str[30];
-	struct req *req;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	req = sp->req;
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 
 	http_ClrHeader(req->resp);
@@ -188,17 +183,17 @@ res_WriteGunzipObj(const struct sess *sp)
 /*--------------------------------------------------------------------*/
 
 static void
-res_WriteDirObj(const struct sess *sp, ssize_t low, ssize_t high)
+res_WriteDirObj(const struct req *req, ssize_t low, ssize_t high)
 {
 	ssize_t u = 0;
 	size_t ptr, off, len;
 	struct storage *st;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 
 	ptr = 0;
-	VTAILQ_FOREACH(st, &sp->req->obj->store, list) {
-		CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	VTAILQ_FOREACH(st, &req->obj->store, list) {
+		CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 		CHECK_OBJ_NOTNULL(st, STORAGE_MAGIC);
 		u += st->len;
 		len = st->len;
@@ -220,10 +215,10 @@ res_WriteDirObj(const struct sess *sp, ssize_t low, ssize_t high)
 
 		ptr += len;
 
-		sp->wrk->acct_tmp.bodybytes += len;
-		(void)WRW_Write(sp->wrk, st->ptr + off, len);
+		req->sp->wrk->acct_tmp.bodybytes += len;
+		(void)WRW_Write(req->sp->wrk, st->ptr + off, len);
 	}
-	assert(u == sp->req->obj->len);
+	assert(u == req->obj->len);
 }
 
 /*--------------------------------------------------------------------
@@ -232,14 +227,11 @@ res_WriteDirObj(const struct sess *sp, ssize_t low, ssize_t high)
  */
 
 void
-RES_WriteObj(struct sess *sp)
+RES_WriteObj(struct req *req)
 {
 	char *r;
 	ssize_t low, high;
-	struct req *req;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	req = sp->req;
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 
 	/*
@@ -254,44 +246,44 @@ RES_WriteObj(struct sess *sp)
 	    cache_param->http_range_support &&
 	    req->obj->response == 200 &&
 	    http_GetHdr(req->http, H_Range, &r))
-		res_dorange(sp, r, &low, &high);
+		res_dorange(req, r, &low, &high);
 
-	WRW_Reserve(sp->wrk, &sp->fd, sp->req->vsl, sp->req->t_resp);
+	WRW_Reserve(req->sp->wrk, &req->sp->fd, req->vsl, req->t_resp);
 
 	/*
 	 * Send HTTP protocol header, unless interior ESI object
 	 */
 	if (!(req->res_mode & RES_ESI_CHILD))
-		sp->wrk->acct_tmp.hdrbytes +=
-		    http_Write(sp->wrk, req->resp, 1);
+		req->sp->wrk->acct_tmp.hdrbytes +=
+		    http_Write(req->sp->wrk, req->resp, 1);
 
 	if (!req->wantbody)
 		req->res_mode &= ~RES_CHUNKED;
 
 	if (req->res_mode & RES_CHUNKED)
-		WRW_Chunked(sp->wrk);
+		WRW_Chunked(req->sp->wrk);
 
 	if (!req->wantbody) {
 		/* This was a HEAD or conditional request */
 	} else if (req->obj->len == 0) {
 		/* Nothing to do here */
 	} else if (req->res_mode & RES_ESI) {
-		ESI_Deliver(sp);
+		ESI_Deliver(req);
 	} else if (req->res_mode & RES_ESI_CHILD && req->gzip_resp) {
-		ESI_DeliverChild(sp);
+		ESI_DeliverChild(req->sp);
 	} else if (req->res_mode & RES_ESI_CHILD &&
 	    !req->gzip_resp && req->obj->gziped) {
-		res_WriteGunzipObj(sp);
+		res_WriteGunzipObj(req->sp);
 	} else if (req->res_mode & RES_GUNZIP) {
-		res_WriteGunzipObj(sp);
+		res_WriteGunzipObj(req->sp);
 	} else {
-		res_WriteDirObj(sp, low, high);
+		res_WriteDirObj(req, low, high);
 	}
 
 	if (req->res_mode & RES_CHUNKED &&
 	    !(req->res_mode & RES_ESI_CHILD))
-		WRW_EndChunk(sp->wrk);
+		WRW_EndChunk(req->sp->wrk);
 
-	if (WRW_FlushRelease(sp->wrk) && sp->fd >= 0)
-		SES_Close(sp, "remote closed");
+	if (WRW_FlushRelease(req->sp->wrk) && req->sp->fd >= 0)
+		SES_Close(req->sp, "remote closed");
 }
diff --git a/bin/varnishd/cache/cache_vrt_var.c b/bin/varnishd/cache/cache_vrt_var.c
index 36ff4c6..aedbc98 100644
--- a/bin/varnishd/cache/cache_vrt_var.c
+++ b/bin/varnishd/cache/cache_vrt_var.c
@@ -556,6 +556,6 @@ VRT_r_req_backend_healthy(const struct req *req)
 {
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	CHECK_OBJ_NOTNULL(req->director, DIRECTOR_MAGIC);
-	return (VDI_Healthy(req->director, req->sp));
+	return (VDI_Healthy(req->director, req));
 }
 



From phk at varnish-cache.org  Tue Jun 19 09:22:58 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Tue, 19 Jun 2012 11:22:58 +0200
Subject: [master] 7ac1238 More s/sp/req/ work
Message-ID: <E1SgueI-0003wO-4V@project.varnish-software.com>

commit 7ac1238ef00a50511456c6c7cfb9b7d3b71f7ec5
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Tue Jun 19 09:22:45 2012 +0000

    More s/sp/req/ work

diff --git a/bin/varnishd/cache/cache.h b/bin/varnishd/cache/cache.h
index 845fac6..5823943 100644
--- a/bin/varnishd/cache/cache.h
+++ b/bin/varnishd/cache/cache.h
@@ -893,7 +893,7 @@ void MPL_Free(struct mempool *mpl, void *item);
 void PAN_Init(void);
 
 /* cache_pipe.c */
-void PipeSession(struct sess *sp);
+void PipeRequest(struct req *req);
 
 /* cache_pool.c */
 void Pool_Init(void);
@@ -980,7 +980,7 @@ char *VRT_String(struct ws *ws, const char *h, const char *p, va_list ap);
 char *VRT_StringList(char *d, unsigned dl, const char *p, va_list ap);
 
 void ESI_Deliver(struct req *);
-void ESI_DeliverChild(const struct sess *);
+void ESI_DeliverChild(struct req *);
 
 /* cache_vrt_vmod.c */
 void VMOD_Init(void);
diff --git a/bin/varnishd/cache/cache_backend.c b/bin/varnishd/cache/cache_backend.c
index e640a30..7b3101b 100644
--- a/bin/varnishd/cache/cache_backend.c
+++ b/bin/varnishd/cache/cache_backend.c
@@ -87,10 +87,10 @@ VBE_ReleaseConn(struct vbc *vc)
 	MPL_Free(vbcpool, vc);
 }
 
-#define FIND_TMO(tmx, dst, sp, be)					\
+#define FIND_TMO(tmx, dst, req, be)					\
 	do {								\
-		CHECK_OBJ_NOTNULL(sp->req->busyobj, BUSYOBJ_MAGIC);	\
-		dst = sp->req->busyobj->tmx;				\
+		CHECK_OBJ_NOTNULL(req->busyobj, BUSYOBJ_MAGIC);		\
+		dst = req->busyobj->tmx;				\
 		if (dst == 0.0)						\
 			dst = be->tmx;					\
 		if (dst == 0.0)						\
@@ -107,20 +107,20 @@ VBE_ReleaseConn(struct vbc *vc)
  */
 
 static int
-vbe_TryConnect(const struct sess *sp, int pf, const struct sockaddr_storage *sa,
+vbe_TryConnect(const struct req *req, int pf, const struct sockaddr_storage *sa,
     socklen_t salen, const struct vdi_simple *vs)
 {
 	int s, i, tmo;
 	double tmod;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	CHECK_OBJ_NOTNULL(vs, VDI_SIMPLE_MAGIC);
 
 	s = socket(pf, SOCK_STREAM, 0);
 	if (s < 0)
 		return (s);
 
-	FIND_TMO(connect_timeout, tmod, sp, vs->vrt);
+	FIND_TMO(connect_timeout, tmod, req, vs->vrt);
 
 	tmo = (int)(tmod * 1000.0);
 
@@ -137,7 +137,7 @@ vbe_TryConnect(const struct sess *sp, int pf, const struct sockaddr_storage *sa,
 /*--------------------------------------------------------------------*/
 
 static void
-bes_conn_try(const struct sess *sp, struct vbc *vc, const struct vdi_simple *vs)
+bes_conn_try(struct req *req, struct vbc *vc, const struct vdi_simple *vs)
 {
 	int s;
 	struct backend *bp = vs->backend;
@@ -157,17 +157,17 @@ bes_conn_try(const struct sess *sp, struct vbc *vc, const struct vdi_simple *vs)
 	/* release lock during stuff that can take a long time */
 
 	if (cache_param->prefer_ipv6 && bp->ipv6 != NULL) {
-		s = vbe_TryConnect(sp, PF_INET6, bp->ipv6, bp->ipv6len, vs);
+		s = vbe_TryConnect(req, PF_INET6, bp->ipv6, bp->ipv6len, vs);
 		vc->addr = bp->ipv6;
 		vc->addrlen = bp->ipv6len;
 	}
 	if (s == -1 && bp->ipv4 != NULL) {
-		s = vbe_TryConnect(sp, PF_INET, bp->ipv4, bp->ipv4len, vs);
+		s = vbe_TryConnect(req, PF_INET, bp->ipv4, bp->ipv4len, vs);
 		vc->addr = bp->ipv4;
 		vc->addrlen = bp->ipv4len;
 	}
 	if (s == -1 && !cache_param->prefer_ipv6 && bp->ipv6 != NULL) {
-		s = vbe_TryConnect(sp, PF_INET6, bp->ipv6, bp->ipv6len, vs);
+		s = vbe_TryConnect(req, PF_INET6, bp->ipv6, bp->ipv6len, vs);
 		vc->addr = bp->ipv6;
 		vc->addrlen = bp->ipv6len;
 	}
@@ -183,7 +183,7 @@ bes_conn_try(const struct sess *sp, struct vbc *vc, const struct vdi_simple *vs)
 	} else {
 		vc->vsl_id = s | VSL_BACKENDMARKER;
 		VTCP_myname(s, abuf1, sizeof abuf1, pbuf1, sizeof pbuf1);
-		VSLb(sp->req->vsl, SLT_BackendOpen, "%d %s %s %s ",
+		VSLb(req->vsl, SLT_BackendOpen, "%d %s %s %s ",
 		    vc->fd, vs->backend->display_name, abuf1, pbuf1);
 	}
 
@@ -226,7 +226,7 @@ vbe_NewConn(void)
 
 /*--------------------------------------------------------------------
  * It evaluates if a backend is healthy _for_a_specific_object_.
- * That means that it relies on sp->req->objcore->objhead. This is mainly for
+ * That means that it relies on req->objcore->objhead. This is mainly for
  * saint-mode, but also takes backend->healthy into account. If
  * cache_param->saintmode_threshold is 0, this is basically just a test of
  * backend->healthy.
@@ -236,7 +236,7 @@ vbe_NewConn(void)
  */
 
 static unsigned int
-vbe_Healthy(const struct vdi_simple *vs, const struct sess *sp)
+vbe_Healthy(const struct vdi_simple *vs, const struct req *req)
 {
 	struct trouble *tr;
 	struct trouble *tr2;
@@ -246,7 +246,7 @@ vbe_Healthy(const struct vdi_simple *vs, const struct sess *sp)
 	struct backend *backend;
 	double now;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	CHECK_OBJ_NOTNULL(vs, VDI_SIMPLE_MAGIC);
 	backend = vs->backend;
 	CHECK_OBJ_NOTNULL(backend, BACKEND_MAGIC);
@@ -271,7 +271,7 @@ vbe_Healthy(const struct vdi_simple *vs, const struct sess *sp)
 	if (threshold == 0 || VTAILQ_EMPTY(&backend->troublelist))
 		return (1);
 
-	now = sp->req->t_req;
+	now = req->t_req;
 
 	old = NULL;
 	retval = 1;
@@ -286,7 +286,7 @@ vbe_Healthy(const struct vdi_simple *vs, const struct sess *sp)
 			break;
 		}
 
-		if (!memcmp(tr->digest, sp->req->digest, sizeof tr->digest)) {
+		if (!memcmp(tr->digest, req->digest, sizeof tr->digest)) {
 			retval = 0;
 			break;
 		}
@@ -313,12 +313,12 @@ vbe_Healthy(const struct vdi_simple *vs, const struct sess *sp)
  */
 
 static struct vbc *
-vbe_GetVbe(const struct sess *sp, struct vdi_simple *vs)
+vbe_GetVbe(struct req *req, struct vdi_simple *vs)
 {
 	struct vbc *vc;
 	struct backend *bp;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	CHECK_OBJ_NOTNULL(vs, VDI_SIMPLE_MAGIC);
 	bp = vs->backend;
 	CHECK_OBJ_NOTNULL(bp, BACKEND_MAGIC);
@@ -340,20 +340,20 @@ vbe_GetVbe(const struct sess *sp, struct vdi_simple *vs)
 		if (vbe_CheckFd(vc->fd)) {
 			/* XXX locking of stats */
 			VSC_C_main->backend_reuse += 1;
-			VSLb(sp->req->vsl, SLT_Backend, "%d %s %s",
-			    vc->fd, sp->req->director->vcl_name,
+			VSLb(req->vsl, SLT_Backend, "%d %s %s",
+			    vc->fd, req->director->vcl_name,
 			    bp->display_name);
 			vc->vdis = vs;
 			vc->recycled = 1;
 			return (vc);
 		}
 		VSC_C_main->backend_toolate++;
-		VSLb(sp->req->vsl, SLT_BackendClose, "%d %s toolate",
+		VSLb(req->vsl, SLT_BackendClose, "%d %s toolate",
 		    vc->fd, bp->display_name);
 
 		/* Checkpoint log to flush all info related to this connection
 		   before the OS reuses the FD */
-		VSL_Flush(sp->req->vsl, 0);
+		VSL_Flush(req->vsl, 0);
 
 		VTCP_close(&vc->fd);
 		VBE_DropRefConn(bp);
@@ -361,7 +361,7 @@ vbe_GetVbe(const struct sess *sp, struct vdi_simple *vs)
 		VBE_ReleaseConn(vc);
 	}
 
-	if (!vbe_Healthy(vs, sp)) {
+	if (!vbe_Healthy(vs, req)) {
 		VSC_C_main->backend_unhealthy++;
 		return (NULL);
 	}
@@ -375,7 +375,7 @@ vbe_GetVbe(const struct sess *sp, struct vdi_simple *vs)
 	vc = vbe_NewConn();
 	assert(vc->fd == -1);
 	AZ(vc->backend);
-	bes_conn_try(sp, vc, vs);
+	bes_conn_try(req, vc, vs);
 	if (vc->fd < 0) {
 		VBE_ReleaseConn(vc);
 		VSC_C_main->backend_fail++;
@@ -383,8 +383,8 @@ vbe_GetVbe(const struct sess *sp, struct vdi_simple *vs)
 	}
 	vc->backend = bp;
 	VSC_C_main->backend_conn++;
-	VSLb(sp->req->vsl, SLT_Backend, "%d %s %s",
-	    vc->fd, sp->req->director->vcl_name, bp->display_name);
+	VSLb(req->vsl, SLT_Backend, "%d %s %s",
+	    vc->fd, req->director->vcl_name, bp->display_name);
 	vc->vdis = vs;
 	return (vc);
 }
@@ -460,12 +460,12 @@ vdi_simple_getfd(const struct director *d, struct req *req)
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
 	CAST_OBJ_NOTNULL(vs, d->priv, VDI_SIMPLE_MAGIC);
-	vc = vbe_GetVbe(req->sp, vs);
+	vc = vbe_GetVbe(req, vs);
 	if (vc != NULL) {
 		FIND_TMO(first_byte_timeout,
-		    vc->first_byte_timeout, req->sp, vs->vrt);
+		    vc->first_byte_timeout, req, vs->vrt);
 		FIND_TMO(between_bytes_timeout,
-		    vc->between_bytes_timeout, req->sp, vs->vrt);
+		    vc->between_bytes_timeout, req, vs->vrt);
 	}
 	return (vc);
 }
@@ -477,7 +477,7 @@ vdi_simple_healthy(const struct director *d, const struct req *req)
 
 	CHECK_OBJ_NOTNULL(d, DIRECTOR_MAGIC);
 	CAST_OBJ_NOTNULL(vs, d->priv, VDI_SIMPLE_MAGIC);
-	return (vbe_Healthy(vs, req->sp));
+	return (vbe_Healthy(vs, req));
 }
 
 static void
diff --git a/bin/varnishd/cache/cache_center.c b/bin/varnishd/cache/cache_center.c
index 240d0d0..88c269b 100644
--- a/bin/varnishd/cache/cache_center.c
+++ b/bin/varnishd/cache/cache_center.c
@@ -407,14 +407,14 @@ cnt_done(struct sess *sp, struct worker *wrk, struct req *req)
 		/* XXX: Add StatReq == StatSess */
 		/* XXX: Workaround for pipe */
 		if (sp->fd >= 0) {
-			VSLb(sp->req->vsl, SLT_Length, "%ju",
+			VSLb(req->vsl, SLT_Length, "%ju",
 			    (uintmax_t)req->req_bodybytes);
 		}
-		VSLb(sp->req->vsl, SLT_ReqEnd, "%u %.9f %.9f %.9f %.9f %.9f",
+		VSLb(req->vsl, SLT_ReqEnd, "%u %.9f %.9f %.9f %.9f %.9f",
 		    req->xid, req->t_req, sp->t_idle, dh, dp, da);
 	}
 	req->xid = 0;
-	VSL_Flush(sp->req->vsl, 0);
+	VSL_Flush(req->vsl, 0);
 
 	req->t_req = NAN;
 	req->t_resp = NAN;
@@ -532,7 +532,7 @@ cnt_error(struct sess *sp, struct worker *wrk, struct req *req)
 
 	if (req->handling == VCL_RET_RESTART &&
 	    req->restarts <  cache_param->max_restarts) {
-		HSH_Drop(wrk, &sp->req->obj);
+		HSH_Drop(wrk, &req->obj);
 		VBO_DerefBusyObj(wrk, &req->busyobj);
 		sp->step = STP_RESTART;
 		return (0);
@@ -628,7 +628,7 @@ cnt_fetch(struct sess *sp, struct worker *wrk, struct req *req)
 		 */
 		EXP_Clr(&bo->exp);
 		bo->exp.entered = W_TIM_real(wrk);
-		RFC2616_Ttl(bo, sp->req->xid);
+		RFC2616_Ttl(bo, req->xid);
 
 		/* pass from vclrecv{} has negative TTL */
 		if (req->objcore->objhead == NULL)
@@ -1077,7 +1077,7 @@ cnt_lookup(struct sess *sp, struct worker *wrk, struct req *req)
 	VRY_Prep(req);
 
 	AZ(req->objcore);
-	oc = HSH_Lookup(sp);
+	oc = HSH_Lookup(req);
 	if (oc == NULL) {
 		/*
 		 * We lost the session to a busy object, disembark the
@@ -1131,7 +1131,7 @@ cnt_lookup(struct sess *sp, struct worker *wrk, struct req *req)
 
 	if (oc->flags & OC_F_PASS) {
 		wrk->stats.cache_hitpass++;
-		VSLb(sp->req->vsl, SLT_HitPass, "%u", req->obj->xid);
+		VSLb(req->vsl, SLT_HitPass, "%u", req->obj->xid);
 		(void)HSH_Deref(&wrk->stats, NULL, &req->obj);
 		AZ(req->objcore);
 		sp->step = STP_PASS;
@@ -1139,7 +1139,7 @@ cnt_lookup(struct sess *sp, struct worker *wrk, struct req *req)
 	}
 
 	wrk->stats.cache_hit++;
-	VSLb(sp->req->vsl, SLT_Hit, "%u", req->obj->xid);
+	VSLb(req->vsl, SLT_Hit, "%u", req->obj->xid);
 	sp->step = STP_HIT;
 	return (0);
 }
@@ -1323,7 +1323,7 @@ cnt_pipe(struct sess *sp, struct worker *wrk, struct req *req)
 		INCOMPL();
 	assert(req->handling == VCL_RET_PIPE);
 
-	PipeSession(sp);
+	PipeRequest(req);
 	assert(WRW_IsReleased(wrk));
 	http_Teardown(bo->bereq);
 	VBO_DerefBusyObj(wrk, &req->busyobj);
@@ -1503,7 +1503,7 @@ cnt_start(struct sess *sp, struct worker *wrk, struct req *req)
 
 	/* Assign XID and log */
 	req->xid = ++xids;				/* XXX not locked */
-	VSLb(sp->req->vsl, SLT_ReqStart, "%s %s %u",
+	VSLb(req->vsl, SLT_ReqStart, "%s %s %u",
 	    sp->addr, sp->port,  req->xid);
 
 	/* Borrow VCL reference from worker thread */
diff --git a/bin/varnishd/cache/cache_dir_dns.c b/bin/varnishd/cache/cache_dir_dns.c
index e947f61..d4f6772 100644
--- a/bin/varnishd/cache/cache_dir_dns.c
+++ b/bin/varnishd/cache/cache_dir_dns.c
@@ -135,8 +135,10 @@ vdi_dns_comp_addrinfo(const struct director *dir,
  * healthy ones.
  */
 static struct director *
-vdi_dns_pick_host(const struct sess *sp, struct vdi_dns_hostgroup *group) {
+vdi_dns_pick_host(const struct req *req, struct vdi_dns_hostgroup *group)
+{
 	int initial, i, nhosts, current;
+
 	if (group->nhosts == 0)
 		return (NULL); // In case of error.
 	if (group->next_host >= group->nhosts)
@@ -150,7 +152,7 @@ vdi_dns_pick_host(const struct sess *sp, struct vdi_dns_hostgroup *group) {
 			current = i + initial - nhosts;
 		else
 			current = i + initial;
-		if (VDI_Healthy(group->hosts[current], sp->req)) {
+		if (VDI_Healthy(group->hosts[current], req)) {
 			group->next_host = current+1;
 			return (group->hosts[current]);
 		}
@@ -192,24 +194,22 @@ vdi_dns_groupmatch(const struct vdi_dns_hostgroup *group, const char *hostname)
  * and freed.
  */
 static int
-vdi_dns_cache_has(const struct sess *sp,
-		  struct vdi_dns *vs,
-		  const char *hostname,
-		  struct director **backend,
-		  int rwlock)
+vdi_dns_cache_has(const struct req *req, struct vdi_dns *vs,
+    const char *hostname, struct director **backend, int rwlock)
 {
 	struct director *ret;
 	struct vdi_dns_hostgroup *hostgr;
 	struct vdi_dns_hostgroup *hostgr2;
+
 	VTAILQ_FOREACH_SAFE(hostgr, &vs->cachelist, list, hostgr2) {
 		CHECK_OBJ_NOTNULL(hostgr, VDI_DNSDIR_MAGIC);
-		if (hostgr->ttl <= sp->req->t_req) {
+		if (hostgr->ttl <= req->t_req) {
 			if (rwlock)
 				vdi_dns_pop_cache(vs, hostgr);
 			return (0);
 		}
 		if (vdi_dns_groupmatch(hostgr, hostname)) {
-			ret = (vdi_dns_pick_host(sp, hostgr));
+			ret = (vdi_dns_pick_host(req, hostgr));
 			*backend = ret;
 			if (*backend != NULL)
 				CHECK_OBJ_NOTNULL(*backend, DIRECTOR_MAGIC);
@@ -223,17 +223,17 @@ vdi_dns_cache_has(const struct sess *sp,
  * (Sorry for the list_add/_add confusion...)
  */
 static void
-vdi_dns_cache_list_add(const struct sess *sp,
-		       struct vdi_dns *vs,
-		       struct vdi_dns_hostgroup *new)
+vdi_dns_cache_list_add(const struct req *req, struct vdi_dns *vs,
+    struct vdi_dns_hostgroup *new)
 {
+
 	if (vs->ncachelist >= VDI_DNS_MAX_CACHE) {
 		VSC_C_main->dir_dns_cache_full++;
 		vdi_dns_pop_cache(vs, NULL);
 	}
 	CHECK_OBJ_NOTNULL(new, VDI_DNSDIR_MAGIC);
 	assert(new->hostname != 0);
-	new->ttl = sp->req->t_req + vs->ttl;
+	new->ttl = req->t_req + vs->ttl;
 	VTAILQ_INSERT_HEAD(&vs->cachelist, new, list);
 	vs->ncachelist++;
 }
@@ -243,10 +243,8 @@ vdi_dns_cache_list_add(const struct sess *sp,
  * cache_has() afterwards to do multiple dns lookups in parallel...
  */
 static int
-vdi_dns_cache_add(const struct sess *sp,
-		  struct vdi_dns *vs,
-		  const char *hostname,
-		  struct director **backend)
+vdi_dns_cache_add(const struct req *req, struct vdi_dns *vs,
+    const char *hostname, struct director **backend)
 {
 	int error, i, host = 0;
 	struct addrinfo *res0, *res, hint;
@@ -258,7 +256,7 @@ vdi_dns_cache_add(const struct sess *sp,
 	 * unique names or something equally troublesome).
 	 */
 
-	if (vdi_dns_cache_has(sp, vs, hostname, backend, 1))
+	if (vdi_dns_cache_has(req, vs, hostname, backend, 1))
 		return (1);
 
 	memset(&hint, 0, sizeof hint);
@@ -273,7 +271,7 @@ vdi_dns_cache_add(const struct sess *sp,
 	error = getaddrinfo(hostname, "80", &hint, &res0);
 	VSC_C_main->dir_dns_lookups++;
 	if (error) {
-		vdi_dns_cache_list_add(sp, vs, new);
+		vdi_dns_cache_list_add(req, vs, new);
 		VSC_C_main->dir_dns_failed++;
 		return (0);
 	}
@@ -297,8 +295,8 @@ vdi_dns_cache_add(const struct sess *sp,
 	freeaddrinfo(res0);
 
 	new->nhosts = host;
-	vdi_dns_cache_list_add(sp, vs, new);
-	*backend = vdi_dns_pick_host(sp, new);
+	vdi_dns_cache_list_add(req, vs, new);
+	*backend = vdi_dns_pick_host(req, new);
 	return (1);
 }
 
@@ -308,15 +306,14 @@ vdi_dns_cache_add(const struct sess *sp,
  * Returns a backend or NULL.
  */
 static struct director *
-vdi_dns_walk_cache(const struct sess *sp,
-		   struct vdi_dns *vs,
-		   const char *hostname)
+vdi_dns_walk_cache(const struct req *req, struct vdi_dns *vs,
+    const char *hostname)
 {
 	struct director *backend = NULL;
 	int ret;
 
 	AZ(pthread_rwlock_rdlock(&vs->rwlock));
-	ret = vdi_dns_cache_has(sp, vs, hostname, &backend, 0);
+	ret = vdi_dns_cache_has(req, vs, hostname, &backend, 0);
 	AZ(pthread_rwlock_unlock(&vs->rwlock));
 	if (!ret) {
 		/*
@@ -325,7 +322,7 @@ vdi_dns_walk_cache(const struct sess *sp,
 		 * XXX: Should 'ret' be checked for that ?
 		 */
 		AZ(pthread_rwlock_wrlock(&vs->rwlock));
-		ret = vdi_dns_cache_add(sp, vs, hostname, &backend);
+		ret = vdi_dns_cache_add(req, vs, hostname, &backend);
 		AZ(pthread_rwlock_unlock(&vs->rwlock));
 	} else
 		VSC_C_main->dir_dns_hit++;
@@ -339,7 +336,7 @@ vdi_dns_walk_cache(const struct sess *sp,
 /* Parses the Host:-header and heads out to find a backend.
  */
 static struct director *
-vdi_dns_find_backend(const struct sess *sp, struct vdi_dns *vs)
+vdi_dns_find_backend(const struct req *req, struct vdi_dns *vs)
 {
 	struct director *ret;
 	struct http *hp;
@@ -349,10 +346,10 @@ vdi_dns_find_backend(const struct sess *sp, struct vdi_dns *vs)
 	/* bereq is only present after recv et. al, otherwise use req (ie:
 	 * use req for health checks in vcl_recv and such).
 	 */
-	if (sp->req->busyobj != NULL && sp->req->busyobj->bereq)
-		hp = sp->req->busyobj->bereq;
+	if (req->busyobj != NULL && req->busyobj->bereq)
+		hp = req->busyobj->bereq;
 	else
-		hp = sp->req->http;
+		hp = req->http;
 
 
 	CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
@@ -367,7 +364,7 @@ vdi_dns_find_backend(const struct sess *sp, struct vdi_dns *vs)
 	bprintf(hostname, "%.*s%s", (int)(q - p), p,
 	    vs->suffix ? vs->suffix : "");
 
-	ret = vdi_dns_walk_cache(sp, vs, hostname);
+	ret = vdi_dns_walk_cache(req, vs, hostname);
 	return (ret);
 }
 
@@ -382,7 +379,7 @@ vdi_dns_getfd(const struct director *director, struct req *req)
 	CHECK_OBJ_NOTNULL(director, DIRECTOR_MAGIC);
 	CAST_OBJ_NOTNULL(vs, director->priv, VDI_DNS_MAGIC);
 
-	dir = vdi_dns_find_backend(req->sp, vs);
+	dir = vdi_dns_find_backend(req, vs);
 	if (!dir || !VDI_Healthy(dir, req))
 		return (NULL);
 
@@ -408,7 +405,7 @@ vdi_dns_healthy(const struct director *dir, const struct req *req)
 	CHECK_OBJ_NOTNULL(req->director, DIRECTOR_MAGIC);
 	CAST_OBJ_NOTNULL(vs, req->director->priv, VDI_DNS_MAGIC);
 
-	dir = vdi_dns_find_backend(req->sp, vs);
+	dir = vdi_dns_find_backend(req, vs);
 
 	if (dir)
 		return (1);
diff --git a/bin/varnishd/cache/cache_esi_deliver.c b/bin/varnishd/cache/cache_esi_deliver.c
index 9199d67..6aed2c3 100644
--- a/bin/varnishd/cache/cache_esi_deliver.c
+++ b/bin/varnishd/cache/cache_esi_deliver.c
@@ -417,14 +417,14 @@ ESI_Deliver(struct req *req)
  */
 
 static uint8_t
-ved_deliver_byterange(const struct sess *sp, ssize_t low, ssize_t high)
+ved_deliver_byterange(const struct req *req, ssize_t low, ssize_t high)
 {
 	struct storage *st;
 	ssize_t l, lx;
 	u_char *p;
 
 	lx = 0;
-	VTAILQ_FOREACH(st, &sp->req->obj->store, list) {
+	VTAILQ_FOREACH(st, &req->obj->store, list) {
 		p = st->ptr;
 		l = st->len;
 		if (lx + l < low) {
@@ -443,7 +443,7 @@ ved_deliver_byterange(const struct sess *sp, ssize_t low, ssize_t high)
 			l = high - lx;
 		assert(lx >= low && lx + l <= high);
 		if (l != 0)
-			(void)WRW_Write(sp->wrk, p, l);
+			(void)WRW_Write(req->sp->wrk, p, l);
 		if (p + l < st->ptr + st->len)
 			return(p[l]);
 		lx += l;
@@ -452,7 +452,7 @@ ved_deliver_byterange(const struct sess *sp, ssize_t low, ssize_t high)
 }
 
 void
-ESI_DeliverChild(const struct sess *sp)
+ESI_DeliverChild(struct req *req)
 {
 	struct storage *st;
 	struct object *obj;
@@ -464,9 +464,10 @@ ESI_DeliverChild(const struct sess *sp)
 	int i, j;
 	uint8_t tailbuf[8];
 
-	if (!sp->req->obj->gziped) {
-		VTAILQ_FOREACH(st, &sp->req->obj->store, list)
-			ved_pretend_gzip(sp->req, st->ptr, st->len);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	if (!req->obj->gziped) {
+		VTAILQ_FOREACH(st, &req->obj->store, list)
+			ved_pretend_gzip(req, st->ptr, st->len);
 		return;
 	}
 	/*
@@ -475,9 +476,9 @@ ESI_DeliverChild(const struct sess *sp)
 	 * padding it, as necessary, to a byte boundary.
 	 */
 
-	dbits = (void*)WS_Alloc(sp->req->ws, 8);
+	dbits = (void*)WS_Alloc(req->ws, 8);
 	AN(dbits);
-	obj = sp->req->obj;
+	obj = req->obj;
 	CHECK_OBJ_NOTNULL(obj, OBJECT_MAGIC);
 	start = obj->gzip_start;
 	last = obj->gzip_last;
@@ -495,10 +496,10 @@ ESI_DeliverChild(const struct sess *sp)
 	 * XXX: optimize for the case where the 'last'
 	 * XXX: bit is in a empty copy block
 	 */
-	*dbits = ved_deliver_byterange(sp, start/8, last/8);
+	*dbits = ved_deliver_byterange(req, start/8, last/8);
 	*dbits &= ~(1U << (last & 7));
-	(void)WRW_Write(sp->wrk, dbits, 1);
-	cc = ved_deliver_byterange(sp, 1 + last/8, stop/8);
+	(void)WRW_Write(req->sp->wrk, dbits, 1);
+	cc = ved_deliver_byterange(req, 1 + last/8, stop/8);
 	switch((int)(stop & 7)) {
 	case 0: /* xxxxxxxx */
 		/* I think we have an off by one here, but that's OK */
@@ -541,10 +542,10 @@ ESI_DeliverChild(const struct sess *sp)
 		INCOMPL();
 	}
 	if (lpad > 0)
-		(void)WRW_Write(sp->wrk, dbits + 1, lpad);
+		(void)WRW_Write(req->sp->wrk, dbits + 1, lpad);
 
 	/* We need the entire tail, but it may not be in one storage segment */
-	st = VTAILQ_LAST(&sp->req->obj->store, storagehead);
+	st = VTAILQ_LAST(&req->obj->store, storagehead);
 	for (i = sizeof tailbuf; i > 0; i -= j) {
 		j = st->len;
 		if (j > i)
@@ -556,6 +557,6 @@ ESI_DeliverChild(const struct sess *sp)
 
 	icrc = vle32dec(tailbuf);
 	ilen = vle32dec(tailbuf + 4);
-	sp->req->crc = crc32_combine(sp->req->crc, icrc, ilen);
-	sp->req->l_crc += ilen;
+	req->crc = crc32_combine(req->crc, icrc, ilen);
+	req->l_crc += ilen;
 }
diff --git a/bin/varnishd/cache/cache_fetch.c b/bin/varnishd/cache/cache_fetch.c
index 129a0a7..0e2fa5f 100644
--- a/bin/varnishd/cache/cache_fetch.c
+++ b/bin/varnishd/cache/cache_fetch.c
@@ -48,7 +48,7 @@ static unsigned fetchfrag;
  * We want to issue the first error we encounter on fetching and
  * supress the rest.  This function does that.
  *
- * Other code is allowed to look at sp->req->busyobj->fetch_failed to bail out
+ * Other code is allowed to look at busyobj->fetch_failed to bail out
  *
  * For convenience, always return -1
  */
diff --git a/bin/varnishd/cache/cache_gzip.c b/bin/varnishd/cache/cache_gzip.c
index 80ce07b..e29593d 100644
--- a/bin/varnishd/cache/cache_gzip.c
+++ b/bin/varnishd/cache/cache_gzip.c
@@ -198,8 +198,7 @@ VGZ_ObufFull(const struct vgz *vg)
 }
 
 /*--------------------------------------------------------------------
- * Keep the outbuffer supplied with storage and file it under the
- * sp->req->obj as it fills.
+ * Keep the outbuffer supplied with storage 
  */
 
 int
diff --git a/bin/varnishd/cache/cache_hash.c b/bin/varnishd/cache/cache_hash.c
index f2d5be3..68e4cda 100644
--- a/bin/varnishd/cache/cache_hash.c
+++ b/bin/varnishd/cache/cache_hash.c
@@ -288,22 +288,19 @@ HSH_Insert(struct worker *wrk, const void *digest, struct objcore *oc)
  */
 
 struct objcore *
-HSH_Lookup(struct sess *sp)
+HSH_Lookup(struct req *req)
 {
 	struct worker *wrk;
 	struct objhead *oh;
 	struct objcore *oc;
 	struct objcore *grace_oc;
 	struct object *o;
-	struct req *req;
 	double grace_ttl;
 	int busy_found;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	wrk = sp->wrk;
-	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
-	req = sp->req;
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	wrk = req->sp->wrk;
+	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
 	CHECK_OBJ_NOTNULL(req->http, HTTP_MAGIC);
 	AN(req->director);
 	AN(hash);
@@ -421,19 +418,20 @@ HSH_Lookup(struct sess *sp)
 				oh->waitinglist = wrk->nwaitinglist;
 				wrk->nwaitinglist = NULL;
 			}
-			VTAILQ_INSERT_TAIL(&oh->waitinglist->list, sp, list);
+			VTAILQ_INSERT_TAIL(&oh->waitinglist->list,
+			    req->sp, list);
 		}
 		if (cache_param->diag_bitmap & 0x20)
 			VSLb(req->vsl, SLT_Debug,
 				"on waiting list <%p>", oh);
-		SES_Charge(sp);
+		SES_Charge(req->sp);
 		/*
 		 * The objhead reference transfers to the sess, we get it
 		 * back when the sess comes off the waiting list and
 		 * calls us again
 		 */
 		req->hash_objhead = oh;
-		sp->wrk = NULL;
+		req->sp->wrk = NULL;
 		Lck_Unlock(&oh->mtx);
 		return (NULL);
 	}
@@ -450,7 +448,7 @@ HSH_Lookup(struct sess *sp)
 
 	AZ(req->busyobj);
 	req->busyobj = VBO_GetBusyObj(wrk);
-	req->busyobj->vsl->wid = sp->vsl_id;
+	req->busyobj->vsl->wid = req->sp->vsl_id;
 	req->busyobj->refcount = 2;	/* One for req, one for FetchBody */
 
 	VRY_Validate(req->vary_b);
diff --git a/bin/varnishd/cache/cache_pipe.c b/bin/varnishd/cache/cache_pipe.c
index 77ffcda..13a8c10 100644
--- a/bin/varnishd/cache/cache_pipe.c
+++ b/bin/varnishd/cache/cache_pipe.c
@@ -60,7 +60,7 @@ rdf(int fd0, int fd1)
 }
 
 void
-PipeSession(struct sess *sp)
+PipeRequest(struct req *req)
 {
 	struct vbc *vc;
 	struct worker *wrk;
@@ -68,36 +68,36 @@ PipeSession(struct sess *sp)
 	struct busyobj *bo;
 	int i;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	CHECK_OBJ_NOTNULL(sp->wrk, WORKER_MAGIC);
-	bo = sp->req->busyobj;
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	CHECK_OBJ_NOTNULL(req->sp, SESS_MAGIC);
+	wrk = req->sp->wrk;
+	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
+	bo = req->busyobj;
 	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
-	wrk = sp->wrk;
 
-	vc = VDI_GetFd(NULL, sp->req);
+	vc = VDI_GetFd(NULL, req);
 	if (vc == NULL)
 		return;
 	bo->vbc = vc;		/* For panic dumping */
 	(void)VTCP_blocking(vc->fd);
 
-	WRW_Reserve(wrk, &vc->fd, bo->vsl, sp->req->t_req);
-	sp->wrk->acct_tmp.hdrbytes +=
-	    http_Write(wrk, bo->bereq, 0);
+	WRW_Reserve(wrk, &vc->fd, bo->vsl, req->t_req);
+	wrk->acct_tmp.hdrbytes += http_Write(wrk, bo->bereq, 0);
 
-	if (sp->req->htc->pipeline.b != NULL)
-		sp->wrk->acct_tmp.bodybytes +=
-		    WRW_Write(wrk, sp->req->htc->pipeline.b,
-		    Tlen(sp->req->htc->pipeline));
+	if (req->htc->pipeline.b != NULL)
+		wrk->acct_tmp.bodybytes +=
+		    WRW_Write(wrk, req->htc->pipeline.b,
+		    Tlen(req->htc->pipeline));
 
 	i = WRW_FlushRelease(wrk);
 
 	if (i) {
-		SES_Close(sp, "pipe");
+		SES_Close(req->sp, "pipe");
 		VDI_CloseFd(&vc);
 		return;
 	}
 
-	sp->req->t_resp = VTIM_real();
+	req->t_resp = VTIM_real();
 
 	memset(fds, 0, sizeof fds);
 
@@ -105,8 +105,8 @@ PipeSession(struct sess *sp)
 	fds[0].fd = vc->fd;
 	fds[0].events = POLLIN | POLLERR;
 
-	// XXX: not yet (void)VTCP_linger(sp->fd, 0);
-	fds[1].fd = sp->fd;
+	// XXX: not yet (void)VTCP_linger(req->sp->fd, 0);
+	fds[1].fd = req->sp->fd;
 	fds[1].events = POLLIN | POLLERR;
 
 	while (fds[0].fd > -1 || fds[1].fd > -1) {
@@ -115,24 +115,24 @@ PipeSession(struct sess *sp)
 		i = poll(fds, 2, cache_param->pipe_timeout * 1000);
 		if (i < 1)
 			break;
-		if (fds[0].revents && rdf(vc->fd, sp->fd)) {
+		if (fds[0].revents && rdf(vc->fd, req->sp->fd)) {
 			if (fds[1].fd == -1)
 				break;
 			(void)shutdown(vc->fd, SHUT_RD);
-			(void)shutdown(sp->fd, SHUT_WR);
+			(void)shutdown(req->sp->fd, SHUT_WR);
 			fds[0].events = 0;
 			fds[0].fd = -1;
 		}
-		if (fds[1].revents && rdf(sp->fd, vc->fd)) {
+		if (fds[1].revents && rdf(req->sp->fd, vc->fd)) {
 			if (fds[0].fd == -1)
 				break;
-			(void)shutdown(sp->fd, SHUT_RD);
+			(void)shutdown(req->sp->fd, SHUT_RD);
 			(void)shutdown(vc->fd, SHUT_WR);
 			fds[1].events = 0;
 			fds[1].fd = -1;
 		}
 	}
-	SES_Close(sp, "pipe");
+	SES_Close(req->sp, "pipe");
 	VDI_CloseFd(&vc);
 	bo->vbc = NULL;
 }
diff --git a/bin/varnishd/cache/cache_response.c b/bin/varnishd/cache/cache_response.c
index 59aa6cb..85c8233 100644
--- a/bin/varnishd/cache/cache_response.c
+++ b/bin/varnishd/cache/cache_response.c
@@ -154,30 +154,30 @@ RES_BuildHttp(struct req *req)
  */
 
 static void
-res_WriteGunzipObj(const struct sess *sp)
+res_WriteGunzipObj(struct req *req)
 {
 	struct storage *st;
 	unsigned u = 0;
 	struct vgz *vg;
 	int i;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 
-	vg = VGZ_NewUngzip(sp->req->vsl, "U D -");
+	vg = VGZ_NewUngzip(req->vsl, "U D -");
 	AZ(VGZ_WrwInit(vg));
 
-	VTAILQ_FOREACH(st, &sp->req->obj->store, list) {
-		CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	VTAILQ_FOREACH(st, &req->obj->store, list) {
+		CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 		CHECK_OBJ_NOTNULL(st, STORAGE_MAGIC);
 		u += st->len;
 
-		i = VGZ_WrwGunzip(sp->wrk, vg, st->ptr, st->len);
+		i = VGZ_WrwGunzip(req->sp->wrk, vg, st->ptr, st->len);
 		/* XXX: error check */
 		(void)i;
 	}
-	VGZ_WrwFlush(sp->wrk, vg);
+	VGZ_WrwFlush(req->sp->wrk, vg);
 	(void)VGZ_Destroy(&vg);
-	assert(u == sp->req->obj->len);
+	assert(u == req->obj->len);
 }
 
 /*--------------------------------------------------------------------*/
@@ -270,12 +270,12 @@ RES_WriteObj(struct req *req)
 	} else if (req->res_mode & RES_ESI) {
 		ESI_Deliver(req);
 	} else if (req->res_mode & RES_ESI_CHILD && req->gzip_resp) {
-		ESI_DeliverChild(req->sp);
+		ESI_DeliverChild(req);
 	} else if (req->res_mode & RES_ESI_CHILD &&
 	    !req->gzip_resp && req->obj->gziped) {
-		res_WriteGunzipObj(req->sp);
+		res_WriteGunzipObj(req);
 	} else if (req->res_mode & RES_GUNZIP) {
-		res_WriteGunzipObj(req->sp);
+		res_WriteGunzipObj(req);
 	} else {
 		res_WriteDirObj(req, low, high);
 	}
diff --git a/bin/varnishd/hash/hash_slinger.h b/bin/varnishd/hash/hash_slinger.h
index fe0fb9f..5e05748 100644
--- a/bin/varnishd/hash/hash_slinger.h
+++ b/bin/varnishd/hash/hash_slinger.h
@@ -53,7 +53,7 @@ struct hash_slinger {
 
 /* cache_hash.c */
 void HSH_Cleanup(struct worker *w);
-struct objcore *HSH_Lookup(struct sess *sp);
+struct objcore *HSH_Lookup(struct req *);
 void HSH_Ref(struct objcore *o);
 void HSH_Drop(struct worker *, struct object **);
 void HSH_Init(const struct hash_slinger *slinger);



From phk at varnish-cache.org  Tue Jun 19 09:45:48 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Tue, 19 Jun 2012 11:45:48 +0200
Subject: [master] 611815f Tag threads separately with request and session.
Message-ID: <E1Sgv0O-0005ei-4N@project.varnish-software.com>

commit 611815fad3537b2815bc6fc6028abc40f53f2477
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Tue Jun 19 09:45:09 2012 +0000

    Tag threads separately with request and session.

diff --git a/bin/varnishd/cache/cache.h b/bin/varnishd/cache/cache.h
index 5823943..6ee34ec 100644
--- a/bin/varnishd/cache/cache.h
+++ b/bin/varnishd/cache/cache.h
@@ -854,7 +854,9 @@ uint32_t VXID_Get(struct vxid *v);
 extern volatile struct params * cache_param;
 void THR_SetName(const char *name);
 const char* THR_GetName(void);
-void THR_SetSession(const struct sess *sp);
+void THR_SetRequest(const struct req *);
+const struct req * THR_GetRequest(void);
+void THR_SetSession(const struct sess *);
 const struct sess * THR_GetSession(void);
 
 /* cache_lck.c */
diff --git a/bin/varnishd/cache/cache_gzip.c b/bin/varnishd/cache/cache_gzip.c
index e29593d..9078834 100644
--- a/bin/varnishd/cache/cache_gzip.c
+++ b/bin/varnishd/cache/cache_gzip.c
@@ -198,7 +198,7 @@ VGZ_ObufFull(const struct vgz *vg)
 }
 
 /*--------------------------------------------------------------------
- * Keep the outbuffer supplied with storage 
+ * Keep the outbuffer supplied with storage
  */
 
 int
diff --git a/bin/varnishd/cache/cache_main.c b/bin/varnishd/cache/cache_main.c
index f038c9e..041578b 100644
--- a/bin/varnishd/cache/cache_main.c
+++ b/bin/varnishd/cache/cache_main.c
@@ -46,6 +46,7 @@ volatile struct params	*cache_param;
  */
 
 static pthread_key_t sp_key;
+static pthread_key_t req_key;
 
 void
 THR_SetSession(const struct sess *sp)
@@ -61,6 +62,20 @@ THR_GetSession(void)
 	return (pthread_getspecific(sp_key));
 }
 
+void
+THR_SetRequest(const struct req *req)
+{
+
+	AZ(pthread_setspecific(req_key, req));
+}
+
+const struct req *
+THR_GetRequest(void)
+{
+
+	return (pthread_getspecific(req_key));
+}
+
 /*--------------------------------------------------------------------
  * Name threads if our pthreads implementation supports it.
  */
@@ -126,6 +141,7 @@ child_main(void)
 	cache_param = heritage.param;
 
 	AZ(pthread_key_create(&sp_key, NULL));
+	AZ(pthread_key_create(&req_key, NULL));
 	AZ(pthread_key_create(&name_key, NULL));
 
 	THR_SetName("cache-main");
diff --git a/bin/varnishd/cache/cache_panic.c b/bin/varnishd/cache/cache_panic.c
index c5f49de..af8bf6f 100644
--- a/bin/varnishd/cache/cache_panic.c
+++ b/bin/varnishd/cache/cache_panic.c
@@ -228,14 +228,52 @@ pan_busyobj(const struct busyobj *bo)
 /*--------------------------------------------------------------------*/
 
 static void
+pan_req(const struct req *req)
+{
+	const char *hand;
+
+	VSB_printf(pan_vsp, "req = %p {\n", req);
+	VSB_printf(pan_vsp, "  sp = %p, xid = %u,\n", req->sp, req->xid);
+	hand = VCL_Return_Name(req->handling);
+	if (hand != NULL)
+		VSB_printf(pan_vsp, "  handling = %s,\n", hand);
+	else
+		VSB_printf(pan_vsp, "  handling = 0x%x,\n", req->handling);
+	if (req->err_code)
+		VSB_printf(pan_vsp,
+		    "  err_code = %d, err_reason = %s,\n", req->err_code,
+		    req->err_reason ? req->err_reason : "(null)");
+
+	VSB_printf(pan_vsp, "  restarts = %d, esi_level = %d\n",
+	    req->restarts, req->esi_level);
+
+	if (req->busyobj != NULL)
+		pan_busyobj(req->busyobj);
+
+	pan_ws(req->ws, 2);
+	pan_http("req", req->http, 2);
+	if (req->resp->ws != NULL)
+		pan_http("resp", req->resp, 4);
+
+	if (VALID_OBJ(req->vcl, VCL_CONF_MAGIC))
+		pan_vcl(req->vcl);
+
+	if (VALID_OBJ(req->obj, OBJECT_MAGIC))
+		pan_object(req->obj);
+
+	VSB_printf(pan_vsp, "},\n");
+}
+
+/*--------------------------------------------------------------------*/
+
+static void
 pan_sess(const struct sess *sp)
 {
-	const char *stp, *hand;
+	const char *stp;
 
 	VSB_printf(pan_vsp, "sp = %p {\n", sp);
-	VSB_printf(pan_vsp,
-	    "  fd = %d, id = %u, xid = %u,\n",
-	    sp->fd, sp->vsl_id & VSL_IDENTMASK, sp->req->xid);
+	VSB_printf(pan_vsp, "  fd = %d, id = %u,\n",
+	    sp->fd, sp->vsl_id & VSL_IDENTMASK);
 	VSB_printf(pan_vsp, "  client = %s %s,\n",
 	    sp->addr ? sp->addr : "?.?.?.?",
 	    sp->port ? sp->port : "?");
@@ -245,40 +283,14 @@ pan_sess(const struct sess *sp)
 #undef STEP
 		default: stp = NULL;
 	}
-	hand = VCL_Return_Name(sp->req->handling);
 	if (stp != NULL)
 		VSB_printf(pan_vsp, "  step = %s,\n", stp);
 	else
 		VSB_printf(pan_vsp, "  step = 0x%x,\n", sp->step);
-	if (hand != NULL)
-		VSB_printf(pan_vsp, "  handling = %s,\n", hand);
-	else
-		VSB_printf(pan_vsp, "  handling = 0x%x,\n", sp->req->handling);
-	if (sp->req->err_code)
-		VSB_printf(pan_vsp,
-		    "  err_code = %d, err_reason = %s,\n", sp->req->err_code,
-		    sp->req->err_reason ? sp->req->err_reason : "(null)");
-
-	VSB_printf(pan_vsp, "  restarts = %d, esi_level = %d\n",
-	    sp->req->restarts, sp->req->esi_level);
-
-	if (sp->req->busyobj != NULL)
-		pan_busyobj(sp->req->busyobj);
-
-	pan_ws(sp->req->ws, 2);
-	pan_http("req", sp->req->http, 2);
-	if (sp->req->resp->ws != NULL)
-		pan_http("resp", sp->req->resp, 4);
 
 	if (sp->wrk != NULL)
 		pan_wrk(sp->wrk);
 
-	if (VALID_OBJ(sp->req->vcl, VCL_CONF_MAGIC))
-		pan_vcl(sp->req->vcl);
-
-	if (VALID_OBJ(sp->req->obj, OBJECT_MAGIC))
-		pan_object(sp->req->obj);
-
 	VSB_printf(pan_vsp, "},\n");
 }
 
@@ -318,6 +330,7 @@ pan_ic(const char *func, const char *file, int line, const char *cond,
 {
 	const char *q;
 	const struct sess *sp;
+	const struct req *req;
 
 	AZ(pthread_mutex_lock(&panicstr_mtx)); /* Won't be released,
 						  we're going to die
@@ -361,6 +374,9 @@ pan_ic(const char *func, const char *file, int line, const char *cond,
 		sp = THR_GetSession();
 		if (sp != NULL)
 			pan_sess(sp);
+		req = THR_GetRequest();
+		if (req != NULL)
+			pan_req(req);
 	}
 	VSB_printf(pan_vsp, "\n");
 	VSB_bcat(pan_vsp, "", 1);	/* NUL termination */
diff --git a/bin/varnishd/cache/cache_session.c b/bin/varnishd/cache/cache_session.c
index f236389..df268f1 100644
--- a/bin/varnishd/cache/cache_session.c
+++ b/bin/varnishd/cache/cache_session.c
@@ -307,6 +307,7 @@ SES_GetReq(struct sess *sp)
 	req->magic = REQ_MAGIC;
 	sp->req = req;
 	req->sp = sp;
+	THR_SetRequest(req);
 
 	e = (char*)req + sz;
 	p = (char*)(req + 1);
@@ -359,6 +360,7 @@ SES_ReleaseReq(struct sess *sp)
 	sp->req->sp = NULL;
 	MPL_Free(pp->mpl_req, sp->req);
 	sp->req = NULL;
+	THR_SetRequest(NULL);
 }
 
 /*--------------------------------------------------------------------



From phk at varnish-cache.org  Tue Jun 19 10:53:47 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Tue, 19 Jun 2012 12:53:47 +0200
Subject: [master] 1c14a9d Make the waitinglist hold req instead of sp
Message-ID: <E1Sgw4B-0001tW-Cd@project.varnish-software.com>

commit 1c14a9d49f30093fe58c6986b68456d9e300cd16
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Tue Jun 19 10:53:32 2012 +0000

    Make the waitinglist hold req instead of sp

diff --git a/bin/varnishd/cache/cache.h b/bin/varnishd/cache/cache.h
index 6ee34ec..f013084 100644
--- a/bin/varnishd/cache/cache.h
+++ b/bin/varnishd/cache/cache.h
@@ -562,6 +562,7 @@ struct req {
 	uint8_t			hash_always_miss;
 
 	struct sess		*sp;
+	VTAILQ_ENTRY(req)	w_list;
 
 	/* The busy objhead we sleep on */
 	struct objhead		*hash_objhead;
diff --git a/bin/varnishd/cache/cache_hash.c b/bin/varnishd/cache/cache_hash.c
index 68e4cda..e7c2a49 100644
--- a/bin/varnishd/cache/cache_hash.c
+++ b/bin/varnishd/cache/cache_hash.c
@@ -419,7 +419,7 @@ HSH_Lookup(struct req *req)
 				wrk->nwaitinglist = NULL;
 			}
 			VTAILQ_INSERT_TAIL(&oh->waitinglist->list,
-			    req->sp, list);
+			    req, w_list);
 		}
 		if (cache_param->diag_bitmap & 0x20)
 			VSLb(req->vsl, SLT_Debug,
@@ -469,6 +469,7 @@ static void
 hsh_rush(struct dstat *ds, struct objhead *oh)
 {
 	unsigned u;
+	struct req *req;
 	struct sess *sp;
 	struct waitinglist *wl;
 
@@ -477,12 +478,14 @@ hsh_rush(struct dstat *ds, struct objhead *oh)
 	wl = oh->waitinglist;
 	CHECK_OBJ_NOTNULL(wl, WAITINGLIST_MAGIC);
 	for (u = 0; u < cache_param->rush_exponent; u++) {
-		sp = VTAILQ_FIRST(&wl->list);
-		if (sp == NULL)
+		req = VTAILQ_FIRST(&wl->list);
+		if (req == NULL)
 			break;
+		CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+		sp = req->sp;
 		CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 		AZ(sp->wrk);
-		VTAILQ_REMOVE(&wl->list, sp, list);
+		VTAILQ_REMOVE(&wl->list, req, w_list);
 		DSL(0x20, SLT_Debug, sp->vsl_id, "off waiting list");
 		if (SES_Schedule(sp)) {
 			/*
diff --git a/bin/varnishd/hash/hash_slinger.h b/bin/varnishd/hash/hash_slinger.h
index 5e05748..c385ea6 100644
--- a/bin/varnishd/hash/hash_slinger.h
+++ b/bin/varnishd/hash/hash_slinger.h
@@ -68,7 +68,7 @@ struct objcore *HSH_NewObjCore(struct worker *wrk);
 struct waitinglist {
 	unsigned		magic;
 #define WAITINGLIST_MAGIC	0x063a477a
-	VTAILQ_HEAD(, sess)	list;
+	VTAILQ_HEAD(, req)	list;
 };
 
 struct objhead {



From phk at varnish-cache.org  Tue Jun 19 11:14:07 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Tue, 19 Jun 2012 13:14:07 +0200
Subject: [master] 47c7bc1 Rename STEP to SESS_STEP
Message-ID: <E1SgwNr-000484-0Q@project.varnish-software.com>

commit 47c7bc1150dbee8048d62daef7456df60e07e923
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Tue Jun 19 11:13:51 2012 +0000

    Rename STEP to SESS_STEP

diff --git a/bin/varnishd/cache/cache.h b/bin/varnishd/cache/cache.h
index f013084..7090654 100644
--- a/bin/varnishd/cache/cache.h
+++ b/bin/varnishd/cache/cache.h
@@ -123,9 +123,9 @@ typedef struct {
 /*--------------------------------------------------------------------*/
 
 enum step {
-#define STEP(l, u, arg)	STP_##u,
+#define SESS_STEP(l, u, arg)	STP_##u,
 #include "tbl/steps.h"
-#undef STEP
+#undef SESS_STEP
 };
 
 /*--------------------------------------------------------------------*/
diff --git a/bin/varnishd/cache/cache_center.c b/bin/varnishd/cache/cache_center.c
index 88c269b..a925f1a 100644
--- a/bin/varnishd/cache/cache_center.c
+++ b/bin/varnishd/cache/cache_center.c
@@ -1644,14 +1644,14 @@ CNT_Session(struct sess *sp)
 		}
 
 		switch (sp->step) {
-#define STEP(l,u,arg) \
+#define SESS_STEP(l,u,arg) \
 		    case STP_##u: \
 			if (cache_param->diag_bitmap & 0x01) \
 				cnt_diag(sp, #u); \
 			done = cnt_##l arg; \
 		        break;
 #include "tbl/steps.h"
-#undef STEP
+#undef SESS_STEP
 		default:
 			WRONG("State engine misfire");
 		}
diff --git a/bin/varnishd/cache/cache_panic.c b/bin/varnishd/cache/cache_panic.c
index af8bf6f..ce2b393 100644
--- a/bin/varnishd/cache/cache_panic.c
+++ b/bin/varnishd/cache/cache_panic.c
@@ -278,9 +278,9 @@ pan_sess(const struct sess *sp)
 	    sp->addr ? sp->addr : "?.?.?.?",
 	    sp->port ? sp->port : "?");
 	switch (sp->step) {
-#define STEP(l, u, arg) case STP_##u: stp = "STP_" #u; break;
+#define SESS_STEP(l, u, arg) case STP_##u: stp = "STP_" #u; break;
 #include "tbl/steps.h"
-#undef STEP
+#undef SESS_STEP
 		default: stp = NULL;
 	}
 	if (stp != NULL)
diff --git a/include/tbl/steps.h b/include/tbl/steps.h
index 15fd811..ba4133c 100644
--- a/include/tbl/steps.h
+++ b/include/tbl/steps.h
@@ -29,20 +29,20 @@
  */
 
 /*lint -save -e525 -e539 */
-STEP(wait,		WAIT,		(sp, sp->wrk, sp->req))
-STEP(first,		FIRST,		(sp, sp->wrk))
-STEP(restart,		RESTART,	(sp, sp->wrk, sp->req))
-STEP(recv,		RECV,		(sp, sp->wrk, sp->req))
-STEP(start,		START,		(sp, sp->wrk, sp->req))
-STEP(pipe,		PIPE,		(sp, sp->wrk, sp->req))
-STEP(pass,		PASS,		(sp, sp->wrk, sp->req))
-STEP(lookup,		LOOKUP,		(sp, sp->wrk, sp->req))
-STEP(miss,		MISS,		(sp, sp->wrk, sp->req))
-STEP(hit,		HIT,		(sp, sp->wrk, sp->req))
-STEP(fetch,		FETCH,		(sp, sp->wrk, sp->req))
-STEP(fetchbody,		FETCHBODY,	(sp, sp->wrk, sp->req))
-STEP(prepresp,		PREPRESP,	(sp, sp->wrk, sp->req))
-STEP(deliver,		DELIVER,	(sp, sp->wrk, sp->req))
-STEP(error,		ERROR,		(sp, sp->wrk, sp->req))
-STEP(done,		DONE,		(sp, sp->wrk, sp->req))
+SESS_STEP(wait,		WAIT,		(sp, sp->wrk, sp->req))
+SESS_STEP(first,		FIRST,		(sp, sp->wrk))
+SESS_STEP(restart,		RESTART,	(sp, sp->wrk, sp->req))
+SESS_STEP(recv,		RECV,		(sp, sp->wrk, sp->req))
+SESS_STEP(start,		START,		(sp, sp->wrk, sp->req))
+SESS_STEP(pipe,		PIPE,		(sp, sp->wrk, sp->req))
+SESS_STEP(pass,		PASS,		(sp, sp->wrk, sp->req))
+SESS_STEP(lookup,		LOOKUP,		(sp, sp->wrk, sp->req))
+SESS_STEP(miss,		MISS,		(sp, sp->wrk, sp->req))
+SESS_STEP(hit,		HIT,		(sp, sp->wrk, sp->req))
+SESS_STEP(fetch,		FETCH,		(sp, sp->wrk, sp->req))
+SESS_STEP(fetchbody,		FETCHBODY,	(sp, sp->wrk, sp->req))
+SESS_STEP(prepresp,		PREPRESP,	(sp, sp->wrk, sp->req))
+SESS_STEP(deliver,		DELIVER,	(sp, sp->wrk, sp->req))
+SESS_STEP(error,		ERROR,		(sp, sp->wrk, sp->req))
+SESS_STEP(done,		DONE,		(sp, sp->wrk, sp->req))
 /*lint -restore */



From phk at varnish-cache.org  Tue Jun 19 11:23:28 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Tue, 19 Jun 2012 13:23:28 +0200
Subject: [master] 99d6751 Make HTC_Init() part of getting a request
Message-ID: <E1SgwWu-0004hC-3u@project.varnish-software.com>

commit 99d6751242eb14a2f93e1c38a502fc208a2b02bb
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Tue Jun 19 11:23:12 2012 +0000

    Make HTC_Init() part of getting a request

diff --git a/bin/varnishd/cache/cache.h b/bin/varnishd/cache/cache.h
index 7090654..8d45641 100644
--- a/bin/varnishd/cache/cache.h
+++ b/bin/varnishd/cache/cache.h
@@ -921,7 +921,7 @@ struct sesspool *SES_NewPool(struct pool *pp, unsigned pool_no);
 void SES_DeletePool(struct sesspool *sp);
 int SES_Schedule(struct sess *sp);
 void SES_Handle(struct sess *sp, double now);
-void SES_GetReq(struct sess *sp);
+struct req *SES_GetReq(struct sess *sp);
 void SES_ReleaseReq(struct sess *sp);
 pool_func_t SES_pool_accept_task;
 
diff --git a/bin/varnishd/cache/cache_center.c b/bin/varnishd/cache/cache_center.c
index a925f1a..372d0c4 100644
--- a/bin/varnishd/cache/cache_center.c
+++ b/bin/varnishd/cache/cache_center.c
@@ -110,16 +110,10 @@ cnt_wait(struct sess *sp, struct worker *wrk, struct req *req)
 	assert(!isnan(sp->t_rx));
 
 	if (req == NULL) {
-		SES_GetReq(sp);
-		req = sp->req;
+		req = SES_GetReq(sp);
 		CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
-		assert(req->sp == sp);
-		HTC_Init(req->htc, req->ws, sp->fd, sp->req->vsl,
-		    cache_param->http_req_size,
-		    cache_param->http_req_hdr_len);
-	} else {
-		assert(req->sp == sp);
 	}
+	assert(req->sp == sp);
 
 	AZ(req->vcl);
 	AZ(req->obj);
@@ -945,13 +939,9 @@ cnt_first(struct sess *sp, struct worker *wrk)
 
 	/* Allocate a request already now, so we can VSL to it */
 	AZ(sp->req);
-	SES_GetReq(sp);
-	req = sp->req;
+	req = SES_GetReq(sp);
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	assert(req->sp == sp);
-	HTC_Init(req->htc, req->ws, sp->fd, req->vsl,
-	    cache_param->http_req_size,
-	    cache_param->http_req_hdr_len);
 
 	VTCP_name(&sp->sockaddr, sp->sockaddrlen,
 	    sp->addr, sizeof sp->addr, sp->port, sizeof sp->port);
diff --git a/bin/varnishd/cache/cache_session.c b/bin/varnishd/cache/cache_session.c
index df268f1..08f77f2 100644
--- a/bin/varnishd/cache/cache_session.c
+++ b/bin/varnishd/cache/cache_session.c
@@ -287,7 +287,7 @@ SES_Delete(struct sess *sp, const char *reason, double now)
  * Alloc/Free sp->req
  */
 
-void
+struct req *
 SES_GetReq(struct sess *sp)
 {
 	struct sesspool *pp;
@@ -341,6 +341,12 @@ SES_GetReq(struct sess *sp)
 	assert(p < e);
 
 	WS_Init(req->ws, "req", p, e - p);
+
+	HTC_Init(req->htc, req->ws, sp->fd, req->vsl,
+	    cache_param->http_req_size,
+	    cache_param->http_req_hdr_len);
+
+	return (req);
 }
 
 void



From tfheen at varnish-cache.org  Tue Jun 19 11:33:34 2012
From: tfheen at varnish-cache.org (Tollef Fog Heen)
Date: Tue, 19 Jun 2012 13:33:34 +0200
Subject: [master] 04fa5d7 Use automake's support for parallel tests
Message-ID: <E1Sgwgg-0004Gs-1x@project.varnish-software.com>

commit 04fa5d7498f1b0b2bbf01ae877cac252ecdc6a5d
Author: Tollef Fog Heen <tfheen at varnish-software.com>
Date:   Tue Jun 19 13:30:18 2012 +0200

    Use automake's support for parallel tests
    
    In current automake, there's no way to have the list of tests be
    dynamic, so generate that when running configure as well as a local
    hook to update the list if it's changed.
    
    Also enable colourised test output.

diff --git a/bin/varnishtest/Makefile.am b/bin/varnishtest/Makefile.am
index 4562dc5..ec68889 100644
--- a/bin/varnishtest/Makefile.am
+++ b/bin/varnishtest/Makefile.am
@@ -1,11 +1,16 @@
 #
 
-TESTS_PARALLELISM = 3
-check: varnishtest
-	./varnishtest -i -j$(TESTS_PARALLELISM) $(srcdir)/tests/*.vtc
-	@echo "==================="
-	@echo "All tests succeeded"
-	@echo "==================="
+VTC_LOG_COMPILER = ./varnishtest -v -i
+TEST_EXTENSIONS = .vtc
+TESTS = @VTC_TESTS@
+
+# Make sure we run check-local first
+check: check-local check-am
+# See if list of checks have changed, recheck
+check-local:
+	if [ "$$(cd $(srcdir) && echo tests/*.vtc)" != "@VTC_TESTS@" ]; then \
+		cd $(top_builddir) && ./config.status --recheck ; \
+	fi
 
 DISTCLEANFILES = _.ok
 
diff --git a/configure.ac b/configure.ac
index 2791fd9..e1311f0 100644
--- a/configure.ac
+++ b/configure.ac
@@ -12,7 +12,7 @@ OCFLAGS="$CFLAGS"
 AC_CANONICAL_SYSTEM
 AC_LANG(C)
 
-AM_INIT_AUTOMAKE([foreign])
+AM_INIT_AUTOMAKE([foreign color-tests parallel-tests])
 AC_DISABLE_STATIC
 AC_PROG_LIBTOOL
 
@@ -526,6 +526,10 @@ fi
 
 AC_DEFINE_UNQUOTED([VCC_CC],"$VCC_CC",[C compiler command line for VCL code])
 
+# Stupid automake needs this
+VTC_TESTS="$(cd $srcdir/bin/varnishtest && echo tests/*.vtc)"
+AC_SUBST(VTC_TESTS)
+
 # Generate output
 AC_CONFIG_FILES([
     Makefile



From phk at varnish-cache.org  Tue Jun 19 11:34:06 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Tue, 19 Jun 2012 13:34:06 +0200
Subject: [master] 4f15e16 Move cnt_first{} up above cnt_wait{},
	this is a more logical order and will make subsequent diffs clearer.
Message-ID: <E1SgwhC-0004NZ-EL@project.varnish-software.com>

commit 4f15e168abc9cf3a38fb8d096354e508a84d2e82
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Tue Jun 19 11:33:33 2012 +0000

    Move cnt_first{} up above cnt_wait{}, this is a more logical order
    and will make subsequent diffs clearer.

diff --git a/bin/varnishd/cache/cache_center.c b/bin/varnishd/cache/cache_center.c
index 372d0c4..0d4e93b 100644
--- a/bin/varnishd/cache/cache_center.c
+++ b/bin/varnishd/cache/cache_center.c
@@ -80,6 +80,58 @@ DOT acceptor -> first [style=bold,color=green]
 static unsigned xids;
 
 /*--------------------------------------------------------------------
+ * A freshly accepted socket
+ *
+DOT subgraph xcluster_first {
+DOT	first [
+DOT		shape=box
+DOT		label="cnt_first:\nrender\naddresses"
+DOT	]
+DOT }
+DOT first -> wait [style=bold,color=green]
+ */
+
+static int
+cnt_first(struct sess *sp, struct worker *wrk)
+{
+	struct req *req;
+	char laddr[ADDR_BUFSIZE];
+	char lport[PORT_BUFSIZE];
+
+	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
+
+	/* Allocate a request already now, so we can VSL to it */
+	AZ(sp->req);
+	req = SES_GetReq(sp);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	assert(req->sp == sp);
+
+	VTCP_name(&sp->sockaddr, sp->sockaddrlen,
+	    sp->addr, sizeof sp->addr, sp->port, sizeof sp->port);
+	if (cache_param->log_local_addr) {
+		AZ(getsockname(sp->fd, (void*)&sp->mysockaddr,
+		    &sp->mysockaddrlen));
+		VTCP_name(&sp->mysockaddr, sp->mysockaddrlen,
+		    laddr, sizeof laddr, lport, sizeof lport);
+		/* XXX: have no req yet */
+		VSLb(req->vsl, SLT_SessionOpen, "%s %s %s %s",
+		    sp->addr, sp->port, laddr, lport);
+	} else {
+		/* XXX: have no req yet */
+		VSLb(req->vsl, SLT_SessionOpen, "%s %s %s",
+		    sp->addr, sp->port, sp->mylsock->name);
+	}
+
+	wrk->acct_tmp.sess++;
+
+	sp->t_rx = sp->t_open;
+	sp->t_idle = sp->t_open;
+	sp->step = STP_WAIT;
+	return (0);
+}
+
+/*--------------------------------------------------------------------
  * WAIT
  * Collect the request from the client.
  *
@@ -916,58 +968,6 @@ cnt_fetchbody(struct sess *sp, struct worker *wrk, struct req *req)
 }
 
 /*--------------------------------------------------------------------
- * A freshly accepted socket
- *
-DOT subgraph xcluster_first {
-DOT	first [
-DOT		shape=box
-DOT		label="cnt_first:\nrender\naddresses"
-DOT	]
-DOT }
-DOT first -> wait [style=bold,color=green]
- */
-
-static int
-cnt_first(struct sess *sp, struct worker *wrk)
-{
-	struct req *req;
-	char laddr[ADDR_BUFSIZE];
-	char lport[PORT_BUFSIZE];
-
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
-
-	/* Allocate a request already now, so we can VSL to it */
-	AZ(sp->req);
-	req = SES_GetReq(sp);
-	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
-	assert(req->sp == sp);
-
-	VTCP_name(&sp->sockaddr, sp->sockaddrlen,
-	    sp->addr, sizeof sp->addr, sp->port, sizeof sp->port);
-	if (cache_param->log_local_addr) {
-		AZ(getsockname(sp->fd, (void*)&sp->mysockaddr,
-		    &sp->mysockaddrlen));
-		VTCP_name(&sp->mysockaddr, sp->mysockaddrlen,
-		    laddr, sizeof laddr, lport, sizeof lport);
-		/* XXX: have no req yet */
-		VSLb(req->vsl, SLT_SessionOpen, "%s %s %s %s",
-		    sp->addr, sp->port, laddr, lport);
-	} else {
-		/* XXX: have no req yet */
-		VSLb(req->vsl, SLT_SessionOpen, "%s %s %s",
-		    sp->addr, sp->port, sp->mylsock->name);
-	}
-
-	wrk->acct_tmp.sess++;
-
-	sp->t_rx = sp->t_open;
-	sp->t_idle = sp->t_open;
-	sp->step = STP_WAIT;
-	return (0);
-}
-
-/*--------------------------------------------------------------------
  * HIT
  * We had a cache hit.  Ask VCL, then march off as instructed.
  *



From phk at varnish-cache.org  Tue Jun 19 11:34:06 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Tue, 19 Jun 2012 13:34:06 +0200
Subject: [master] cbe58e7 Merge branch 'master' of
	ssh://git.varnish-cache.org/git/varnish-cache
Message-ID: <E1SgwhC-0004Ne-FO@project.varnish-software.com>

commit cbe58e70c2dc7d8c1769dba2df5e3a16a0c4025e
Merge: 4f15e16 04fa5d7
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Tue Jun 19 11:34:03 2012 +0000

    Merge branch 'master' of ssh://git.varnish-cache.org/git/varnish-cache



From phk at varnish-cache.org  Tue Jun 19 11:46:41 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Tue, 19 Jun 2012 13:46:41 +0200
Subject: [master] 7d9ca7d Eliminate the "first" step, merge it with "wait"
Message-ID: <E1SgwtN-0005SV-A4@project.varnish-software.com>

commit 7d9ca7de9a3b7fe44c92431c7a22038897e6acde
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Tue Jun 19 11:46:24 2012 +0000

    Eliminate the "first" step, merge it with "wait"

diff --git a/bin/varnishd/cache/cache.h b/bin/varnishd/cache/cache.h
index 8d45641..5c2c923 100644
--- a/bin/varnishd/cache/cache.h
+++ b/bin/varnishd/cache/cache.h
@@ -665,6 +665,7 @@ struct sess {
 	struct sockaddr_storage	sockaddr;
 	struct sockaddr_storage	mysockaddr;
 	struct listen_sock	*mylsock;
+	int			init_done;
 
 	/* formatted ascii client address */
 	char			addr[ADDR_BUFSIZE];
diff --git a/bin/varnishd/cache/cache_center.c b/bin/varnishd/cache/cache_center.c
index 0d4e93b..4f97c60 100644
--- a/bin/varnishd/cache/cache_center.c
+++ b/bin/varnishd/cache/cache_center.c
@@ -80,58 +80,6 @@ DOT acceptor -> first [style=bold,color=green]
 static unsigned xids;
 
 /*--------------------------------------------------------------------
- * A freshly accepted socket
- *
-DOT subgraph xcluster_first {
-DOT	first [
-DOT		shape=box
-DOT		label="cnt_first:\nrender\naddresses"
-DOT	]
-DOT }
-DOT first -> wait [style=bold,color=green]
- */
-
-static int
-cnt_first(struct sess *sp, struct worker *wrk)
-{
-	struct req *req;
-	char laddr[ADDR_BUFSIZE];
-	char lport[PORT_BUFSIZE];
-
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
-
-	/* Allocate a request already now, so we can VSL to it */
-	AZ(sp->req);
-	req = SES_GetReq(sp);
-	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
-	assert(req->sp == sp);
-
-	VTCP_name(&sp->sockaddr, sp->sockaddrlen,
-	    sp->addr, sizeof sp->addr, sp->port, sizeof sp->port);
-	if (cache_param->log_local_addr) {
-		AZ(getsockname(sp->fd, (void*)&sp->mysockaddr,
-		    &sp->mysockaddrlen));
-		VTCP_name(&sp->mysockaddr, sp->mysockaddrlen,
-		    laddr, sizeof laddr, lport, sizeof lport);
-		/* XXX: have no req yet */
-		VSLb(req->vsl, SLT_SessionOpen, "%s %s %s %s",
-		    sp->addr, sp->port, laddr, lport);
-	} else {
-		/* XXX: have no req yet */
-		VSLb(req->vsl, SLT_SessionOpen, "%s %s %s",
-		    sp->addr, sp->port, sp->mylsock->name);
-	}
-
-	wrk->acct_tmp.sess++;
-
-	sp->t_rx = sp->t_open;
-	sp->t_idle = sp->t_open;
-	sp->step = STP_WAIT;
-	return (0);
-}
-
-/*--------------------------------------------------------------------
  * WAIT
  * Collect the request from the client.
  *
@@ -155,18 +103,44 @@ cnt_wait(struct sess *sp, struct worker *wrk, struct req *req)
 	struct pollfd pfd[1];
 	double now, when;
 	const char *why = NULL;
+	char laddr[ADDR_BUFSIZE];
+	char lport[PORT_BUFSIZE];
 
 	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
 
-	assert(!isnan(sp->t_rx));
-
 	if (req == NULL) {
 		req = SES_GetReq(sp);
 		CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	}
 	assert(req->sp == sp);
 
+	if (!sp->init_done) {
+		VTCP_name(&sp->sockaddr, sp->sockaddrlen,
+		    sp->addr, sizeof sp->addr, sp->port, sizeof sp->port);
+		if (cache_param->log_local_addr) {
+			AZ(getsockname(sp->fd, (void*)&sp->mysockaddr,
+			    &sp->mysockaddrlen));
+			VTCP_name(&sp->mysockaddr, sp->mysockaddrlen,
+			    laddr, sizeof laddr, lport, sizeof lport);
+			/* XXX: have no req yet */
+			VSLb(req->vsl, SLT_SessionOpen, "%s %s %s %s",
+			    sp->addr, sp->port, laddr, lport);
+		} else {
+			/* XXX: have no req yet */
+			VSLb(req->vsl, SLT_SessionOpen, "%s %s %s",
+			    sp->addr, sp->port, sp->mylsock->name);
+		}
+
+		wrk->acct_tmp.sess++;
+
+		sp->t_rx = sp->t_open;
+		sp->t_idle = sp->t_open;
+		sp->init_done = 1;
+	}
+
+	assert(!isnan(sp->t_rx));
+
 	AZ(req->vcl);
 	AZ(req->obj);
 	AZ(req->esi_level);
@@ -1591,7 +1565,6 @@ CNT_Session(struct sess *sp)
 	 * Possible entrance states
 	 */
 	assert(
-	    sp->step == STP_FIRST ||
 	    sp->step == STP_WAIT ||
 	    sp->step == STP_LOOKUP ||
 	    sp->step == STP_RECV);
@@ -1604,7 +1577,7 @@ CNT_Session(struct sess *sp)
 	 * rather do the syscall in the worker thread.
 	 * On systems which return errors for ioctl, we close early
 	 */
-	if ((sp->step == STP_FIRST || sp->step == STP_START) &&
+	if ((sp->step == STP_WAIT || sp->step == STP_START) &&
 	    VTCP_blocking(sp->fd)) {
 		if (errno == ECONNRESET)
 			SES_Close(sp, "remote closed");
diff --git a/bin/varnishd/cache/cache_session.c b/bin/varnishd/cache/cache_session.c
index 08f77f2..34dad47 100644
--- a/bin/varnishd/cache/cache_session.c
+++ b/bin/varnishd/cache/cache_session.c
@@ -159,7 +159,7 @@ SES_pool_accept_task(struct worker *wrk, void *arg)
 		VCA_FailSess(wrk);
 	} else {
 		VCA_SetupSess(wrk, sp);
-		sp->step = STP_FIRST;
+		sp->step = STP_WAIT;
 		ses_pool_task(wrk, sp);
 	}
 }
diff --git a/include/tbl/steps.h b/include/tbl/steps.h
index ba4133c..6750cd3 100644
--- a/include/tbl/steps.h
+++ b/include/tbl/steps.h
@@ -30,19 +30,18 @@
 
 /*lint -save -e525 -e539 */
 SESS_STEP(wait,		WAIT,		(sp, sp->wrk, sp->req))
-SESS_STEP(first,		FIRST,		(sp, sp->wrk))
-SESS_STEP(restart,		RESTART,	(sp, sp->wrk, sp->req))
+SESS_STEP(restart,	RESTART,	(sp, sp->wrk, sp->req))
 SESS_STEP(recv,		RECV,		(sp, sp->wrk, sp->req))
-SESS_STEP(start,		START,		(sp, sp->wrk, sp->req))
+SESS_STEP(start,	START,		(sp, sp->wrk, sp->req))
 SESS_STEP(pipe,		PIPE,		(sp, sp->wrk, sp->req))
 SESS_STEP(pass,		PASS,		(sp, sp->wrk, sp->req))
-SESS_STEP(lookup,		LOOKUP,		(sp, sp->wrk, sp->req))
+SESS_STEP(lookup,	LOOKUP,		(sp, sp->wrk, sp->req))
 SESS_STEP(miss,		MISS,		(sp, sp->wrk, sp->req))
 SESS_STEP(hit,		HIT,		(sp, sp->wrk, sp->req))
-SESS_STEP(fetch,		FETCH,		(sp, sp->wrk, sp->req))
-SESS_STEP(fetchbody,		FETCHBODY,	(sp, sp->wrk, sp->req))
-SESS_STEP(prepresp,		PREPRESP,	(sp, sp->wrk, sp->req))
-SESS_STEP(deliver,		DELIVER,	(sp, sp->wrk, sp->req))
-SESS_STEP(error,		ERROR,		(sp, sp->wrk, sp->req))
+SESS_STEP(fetch,	FETCH,		(sp, sp->wrk, sp->req))
+SESS_STEP(fetchbody,	FETCHBODY,	(sp, sp->wrk, sp->req))
+SESS_STEP(prepresp,	PREPRESP,	(sp, sp->wrk, sp->req))
+SESS_STEP(deliver,	DELIVER,	(sp, sp->wrk, sp->req))
+SESS_STEP(error,	ERROR,		(sp, sp->wrk, sp->req))
 SESS_STEP(done,		DONE,		(sp, sp->wrk, sp->req))
 /*lint -restore */



From phk at varnish-cache.org  Wed Jun 20 08:11:39 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Wed, 20 Jun 2012 10:11:39 +0200
Subject: [master] a1e3ed9 Apply the "alexandrian solution" to cache_center.c
	and split the state engine into two separate state engines,
	one for session and one for requests.
Message-ID: <E1ShG0p-0008Pu-Ed@project.varnish-software.com>

commit a1e3ed99866c3a9d7954a943462900ba5f9f6316
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Wed Jun 20 08:08:38 2012 +0000

    Apply the "alexandrian solution" to cache_center.c and split the
    state engine into two separate state engines, one for session
    and one for requests.
    
    Next comes the cleanup of all the bits and pieces...

diff --git a/bin/varnishd/cache/cache.h b/bin/varnishd/cache/cache.h
index 5c2c923..299dc93 100644
--- a/bin/varnishd/cache/cache.h
+++ b/bin/varnishd/cache/cache.h
@@ -736,7 +736,8 @@ void VBO_DerefBusyObj(struct worker *wrk, struct busyobj **busyobj);
 void VBO_Free(struct busyobj **vbo);
 
 /* cache_center.c [CNT] */
-void CNT_Session(struct sess *sp);
+int CNT_Request(struct req *);
+void CNT_Session(struct sess *);
 void CNT_Init(void);
 
 /* cache_cli.c [CLI] */
diff --git a/bin/varnishd/cache/cache_center.c b/bin/varnishd/cache/cache_center.c
index 4f97c60..612dbfe 100644
--- a/bin/varnishd/cache/cache_center.c
+++ b/bin/varnishd/cache/cache_center.c
@@ -26,12 +26,21 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * This file contains the central state machine for pushing requests.
+ * This file contains the two central state machine for pushing 
+ * sessions and requests.
  *
- * We cannot just use direct calls because it is possible to kick a
- * request back to the lookup stage (usually after a rewrite).  The
- * state engine also allows us to break the processing up into some
- * logical chunks which improves readability a little bit.
+ * The first part of the file, entrypoint CNT_Session() and down to
+ * the ==== separator, is concerned with sessions.  When a session has
+ * a request to deal with, it calls into the second half of the file.
+ * This part is for all practical purposes HTTP/1.x specific.
+ *
+ * The second part of the file, entrypoint CNT_Request() and below the
+ * ==== separator, is intended to (over time) be(ome) protocol agnostic.
+ * We already use this now with ESI:includes, which are for all relevant
+ * purposes a different "protocol"
+ *
+ * A special complication is the fact that we can suspend processing of
+ * a request when hash-lookup finds a busy objhdr.
  *
  * Since the states are rather nasty in detail, I have decided to embedd
  * a dot(1) graph in the source code comments.  So to see the big picture,
@@ -204,6 +213,175 @@ cnt_wait(struct sess *sp, struct worker *wrk, struct req *req)
 }
 
 /*--------------------------------------------------------------------
+ * This is the final state, figure out if we should close or recycle
+ * the client connection
+ *
+DOT	DONE [
+DOT		shape=record
+DOT		label="{cnt_done:|Request completed}"
+DOT	]
+DOT	ESI_RESP [ shape=hexagon ]
+DOT	DONE -> start [label="full pipeline"]
+DOT	DONE -> wait
+DOT	DONE -> ESI_RESP
+ */
+
+static int
+cnt_done(struct sess *sp, struct worker *wrk, struct req *req)
+{
+	double dh, dp, da;
+	int i;
+
+	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	CHECK_OBJ_ORNULL(req->vcl, VCL_CONF_MAGIC);
+
+	AZ(req->obj);
+	AZ(req->busyobj);
+	req->director = NULL;
+	req->restarts = 0;
+
+	/* If we did an ESI include, don't mess up our state */
+	if (req->esi_level > 0)
+		return (1);
+
+	if (req->vcl != NULL) {
+		if (wrk->vcl != NULL)
+			VCL_Rel(&wrk->vcl);
+		wrk->vcl = req->vcl;
+		req->vcl = NULL;
+	}
+
+
+	sp->t_idle = W_TIM_real(wrk);
+	if (req->xid == 0) {
+		req->t_resp = sp->t_idle;
+	} else {
+		dp = req->t_resp - req->t_req;
+		da = sp->t_idle - req->t_resp;
+		dh = req->t_req - sp->t_open;
+		/* XXX: Add StatReq == StatSess */
+		/* XXX: Workaround for pipe */
+		if (sp->fd >= 0) {
+			VSLb(req->vsl, SLT_Length, "%ju",
+			    (uintmax_t)req->req_bodybytes);
+		}
+		VSLb(req->vsl, SLT_ReqEnd, "%u %.9f %.9f %.9f %.9f %.9f",
+		    req->xid, req->t_req, sp->t_idle, dh, dp, da);
+	}
+	req->xid = 0;
+	VSL_Flush(req->vsl, 0);
+
+	req->t_req = NAN;
+	req->t_resp = NAN;
+
+	req->req_bodybytes = 0;
+
+	req->hash_always_miss = 0;
+	req->hash_ignore_busy = 0;
+
+	if (sp->fd >= 0 && req->doclose != NULL) {
+		/*
+		 * This is an orderly close of the connection; ditch nolinger
+		 * before we close, to get queued data transmitted.
+		 */
+		// XXX: not yet (void)VTCP_linger(sp->fd, 0);
+		SES_Close(sp, req->doclose);
+	}
+
+	if (sp->fd < 0) {
+		wrk->stats.sess_closed++;
+		SES_Delete(sp, NULL, NAN);
+		return (1);
+	}
+
+	if (wrk->stats.client_req >= cache_param->wthread_stats_rate)
+		WRK_SumStat(wrk);
+
+	WS_Reset(req->ws, NULL);
+	WS_Reset(wrk->aws, NULL);
+
+	i = HTC_Reinit(req->htc);
+	if (i == 1) {
+		req->t_req = sp->t_idle;
+		wrk->stats.sess_pipeline++;
+		sp->step = STP_START;
+	} else {
+		sp->t_rx = sp->t_idle;
+		req->t_req = NAN;
+		if (Tlen(req->htc->rxbuf))
+			wrk->stats.sess_readahead++;
+		sp->step = STP_WAIT;
+	}
+	return (0);
+}
+
+/*--------------------------------------------------------------------
+ */
+
+void
+CNT_Session(struct sess *sp)
+{
+	int done;
+	struct worker *wrk;
+
+	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	wrk = sp->wrk;
+	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
+
+	/*
+	 * Whenever we come in from the acceptor or waiter, we need to set
+	 * blocking mode, but there is no point in setting it when we come from
+	 * ESI or when a parked sessions returns.
+	 * It would be simpler to do this in the acceptor or waiter, but we'd
+	 * rather do the syscall in the worker thread.
+	 * On systems which return errors for ioctl, we close early
+	 */
+	if (sp->step == STP_WAIT && VTCP_blocking(sp->fd)) {
+		if (errno == ECONNRESET)
+			SES_Close(sp, "remote closed");
+		else
+			SES_Close(sp, "error");
+		assert(cnt_done(sp, wrk, sp->req) == 1);
+		return;
+	}
+
+	while (1) {
+		/*
+		 * Possible entrance states
+		 */
+		assert(
+		    sp->step == STP_WAIT ||
+		    sp->step == STP_LOOKUP ||
+		    sp->step == STP_START ||
+		    sp->step == STP_RECV);
+
+		if (sp->step != STP_WAIT) {
+			done = CNT_Request(sp->req);
+			if (done == 2)
+				return;
+			assert(done == 1);
+		}
+
+		if (sp->step == STP_DONE) {
+			done = cnt_done(sp, wrk, sp->req);
+			if (done)
+				return;
+		}
+
+		if (sp->step == STP_WAIT) {
+			done = cnt_wait(sp, wrk, sp->req);
+			if (done)
+				return;
+		}
+	}
+}
+
+/*====================================================================*/
+
+
+/*--------------------------------------------------------------------
  * We have a refcounted object on the session, and possibly the busyobj
  * which is fetching it, prepare a response.
  *
@@ -370,116 +548,8 @@ cnt_deliver(struct sess *sp, struct worker *wrk, struct req *req)
 	(void)HSH_Deref(&wrk->stats, NULL, &req->obj);
 	http_Teardown(req->resp);
 	sp->step = STP_DONE;
-	return (0);
-}
-
-/*--------------------------------------------------------------------
- * This is the final state, figure out if we should close or recycle
- * the client connection
- *
-DOT	DONE [
-DOT		shape=record
-DOT		label="{cnt_done:|Request completed}"
-DOT	]
-DOT	ESI_RESP [ shape=hexagon ]
-DOT	DONE -> start [label="full pipeline"]
-DOT	DONE -> wait
-DOT	DONE -> ESI_RESP
- */
-
-static int
-cnt_done(struct sess *sp, struct worker *wrk, struct req *req)
-{
-	double dh, dp, da;
-	int i;
-
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
-	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
-	CHECK_OBJ_ORNULL(req->vcl, VCL_CONF_MAGIC);
-
-	AZ(req->obj);
-	AZ(req->busyobj);
-	req->director = NULL;
-	req->restarts = 0;
-
-	SES_Charge(sp);
-
-	/* If we did an ESI include, don't mess up our state */
-	if (req->esi_level > 0)
-		return (1);
-
-	if (req->vcl != NULL) {
-		if (wrk->vcl != NULL)
-			VCL_Rel(&wrk->vcl);
-		wrk->vcl = req->vcl;
-		req->vcl = NULL;
-	}
-
-
-	sp->t_idle = W_TIM_real(wrk);
-	if (req->xid == 0) {
-		req->t_resp = sp->t_idle;
-	} else {
-		dp = req->t_resp - req->t_req;
-		da = sp->t_idle - req->t_resp;
-		dh = req->t_req - sp->t_open;
-		/* XXX: Add StatReq == StatSess */
-		/* XXX: Workaround for pipe */
-		if (sp->fd >= 0) {
-			VSLb(req->vsl, SLT_Length, "%ju",
-			    (uintmax_t)req->req_bodybytes);
-		}
-		VSLb(req->vsl, SLT_ReqEnd, "%u %.9f %.9f %.9f %.9f %.9f",
-		    req->xid, req->t_req, sp->t_idle, dh, dp, da);
-	}
-	req->xid = 0;
-	VSL_Flush(req->vsl, 0);
-
-	req->t_req = NAN;
-	req->t_resp = NAN;
-
-	req->req_bodybytes = 0;
-
-	req->hash_always_miss = 0;
-	req->hash_ignore_busy = 0;
-
-	if (sp->fd >= 0 && req->doclose != NULL) {
-		/*
-		 * This is an orderly close of the connection; ditch nolinger
-		 * before we close, to get queued data transmitted.
-		 */
-		// XXX: not yet (void)VTCP_linger(sp->fd, 0);
-		SES_Close(sp, req->doclose);
-	}
-
-	if (sp->fd < 0) {
-		wrk->stats.sess_closed++;
-		SES_Delete(sp, NULL, NAN);
-		return (1);
-	}
-
-	if (wrk->stats.client_req >= cache_param->wthread_stats_rate)
-		WRK_SumStat(wrk);
-
-	WS_Reset(req->ws, NULL);
-	WS_Reset(wrk->aws, NULL);
-
-	i = HTC_Reinit(req->htc);
-	if (i == 1) {
-		req->t_req = sp->t_idle;
-		wrk->stats.sess_pipeline++;
-		sp->step = STP_START;
-	} else {
-		sp->t_rx = sp->t_idle;
-		req->t_req = NAN;
-		if (Tlen(req->htc->rxbuf))
-			wrk->stats.sess_readahead++;
-		sp->step = STP_WAIT;
-	}
-	return (0);
+	return (1);
 }
-
 /*--------------------------------------------------------------------
  * Emit an error
  *
@@ -525,7 +595,7 @@ cnt_error(struct sess *sp, struct worker *wrk, struct req *req)
 		http_Teardown(bo->beresp);
 		http_Teardown(bo->bereq);
 		sp->step = STP_DONE;
-		return(0);
+		return(1);
 	}
 	CHECK_OBJ_NOTNULL(req->obj, OBJECT_MAGIC);
 	req->obj->xid = req->xid;
@@ -1050,7 +1120,7 @@ cnt_lookup(struct sess *sp, struct worker *wrk, struct req *req)
 		 * around to do the lookup with.
 		 * NB:  Do not access sp any more !
 		 */
-		return (1);
+		return (2);
 	}
 	AZ(req->objcore);
 
@@ -1292,7 +1362,7 @@ cnt_pipe(struct sess *sp, struct worker *wrk, struct req *req)
 	http_Teardown(bo->bereq);
 	VBO_DerefBusyObj(wrk, &req->busyobj);
 	sp->step = STP_DONE;
-	return (0);
+	return (1);
 }
 
 /*--------------------------------------------------------------------
@@ -1484,7 +1554,7 @@ cnt_start(struct sess *sp, struct worker *wrk, struct req *req)
 	if (req->err_code == 400) {
 		sp->step = STP_DONE;
 		SES_Close(sp, "junk");
-		return (0);
+		return (1);
 	}
 
 	req->ws_req = WS_Snapshot(req->ws);
@@ -1501,7 +1571,7 @@ cnt_start(struct sess *sp, struct worker *wrk, struct req *req)
 		} else if (strlen(r) != write(sp->fd, r, strlen(r))) {
 			sp->step = STP_DONE;
 			SES_Close(sp, "remote closed");
-			return (0);
+			return (1);
 		}
 	}
 	http_Unset(req->http, H_Expect);
@@ -1551,12 +1621,15 @@ cnt_diag(struct sess *sp, const char *state)
 	}
 }
 
-void
-CNT_Session(struct sess *sp)
+int
+CNT_Request(struct req *req)
 {
 	int done;
 	struct worker *wrk;
+	struct sess *sp;
 
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	sp = req->sp;
 	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 	wrk = sp->wrk;
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
@@ -1565,30 +1638,10 @@ CNT_Session(struct sess *sp)
 	 * Possible entrance states
 	 */
 	assert(
-	    sp->step == STP_WAIT ||
 	    sp->step == STP_LOOKUP ||
+	    sp->step == STP_START ||
 	    sp->step == STP_RECV);
 
-	/*
-	 * Whenever we come in from the acceptor or waiter, we need to set
-	 * blocking mode, but there is no point in setting it when we come from
-	 * ESI or when a parked sessions returns.
-	 * It would be simpler to do this in the acceptor or waiter, but we'd
-	 * rather do the syscall in the worker thread.
-	 * On systems which return errors for ioctl, we close early
-	 */
-	if ((sp->step == STP_WAIT || sp->step == STP_START) &&
-	    VTCP_blocking(sp->fd)) {
-		if (errno == ECONNRESET)
-			SES_Close(sp, "remote closed");
-		else
-			SES_Close(sp, "error");
-		sp->step = STP_DONE;
-	}
-
-	/*
-	 * NB: Once done is set, we can no longer touch sp!
-	 */
 	for (done = 0; !done; ) {
 		assert(sp->wrk == wrk);
 		/*
@@ -1599,12 +1652,12 @@ CNT_Session(struct sess *sp)
 		CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
 		CHECK_OBJ_ORNULL(wrk->nobjhead, OBJHEAD_MAGIC);
 		WS_Assert(wrk->aws);
+		CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+		AN(req->sp);
+		assert(req->sp == sp);
 
-		if (sp->req != NULL) {
-			CHECK_OBJ_NOTNULL(sp->req, REQ_MAGIC);
-			AN(sp->req->sp);
-			assert(sp->req->sp == sp);
-		}
+		assert(sp->step != STP_WAIT);
+		assert(sp->step != STP_DONE);
 
 		switch (sp->step) {
 #define SESS_STEP(l,u,arg) \
@@ -1621,10 +1674,11 @@ CNT_Session(struct sess *sp)
 		WS_Assert(wrk->aws);
 		CHECK_OBJ_ORNULL(wrk->nobjhead, OBJHEAD_MAGIC);
 	}
-#define ACCT(foo)	AZ(wrk->acct_tmp.foo);
-#include "tbl/acct_fields.h"
-#undef ACCT
+	if (done == 1)
+		SES_Charge(sp);
+
 	assert(WRW_IsReleased(wrk));
+	return (done);
 }
 
 /*
diff --git a/bin/varnishd/cache/cache_esi_deliver.c b/bin/varnishd/cache/cache_esi_deliver.c
index 6aed2c3..6af4b70 100644
--- a/bin/varnishd/cache/cache_esi_deliver.c
+++ b/bin/varnishd/cache/cache_esi_deliver.c
@@ -49,6 +49,7 @@ ved_include(struct req *req, const char *src, const char *host)
 	char *sp_ws_wm;
 	char *wrk_ws_wm;
 	unsigned sxid, res_mode;
+	int i;
 
 	wrk = req->sp->wrk;
 
@@ -94,9 +95,12 @@ ved_include(struct req *req, const char *src, const char *host)
 	sxid = req->xid;
 	while (1) {
 		req->sp->wrk = wrk;
-		CNT_Session(req->sp);
-		if (req->sp->step == STP_DONE)
+		i = CNT_Request(req);
+		if (req->sp->step == STP_DONE) {
+			assert(i == 1);
 			break;
+		}
+		assert(i == 2);
 		AZ(req->sp->wrk);
 		DSL(0x20, SLT_Debug, req->sp->vsl_id, "loop waiting for ESI");
 		(void)usleep(10000);



From phk at varnish-cache.org  Wed Jun 20 08:40:41 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Wed, 20 Jun 2012 10:40:41 +0200
Subject: [master] c6b0aaa Eliminate the "DONE" state,
	it is now a session state.
Message-ID: <E1ShGSv-0002lp-BM@project.varnish-software.com>

commit c6b0aaa1a255aecd7d380759444f731cabb54b13
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Wed Jun 20 08:40:22 2012 +0000

    Eliminate the "DONE" state, it is now a session state.

diff --git a/bin/varnishd/cache/cache_center.c b/bin/varnishd/cache/cache_center.c
index 612dbfe..cff480d 100644
--- a/bin/varnishd/cache/cache_center.c
+++ b/bin/varnishd/cache/cache_center.c
@@ -227,7 +227,7 @@ DOT	DONE -> ESI_RESP
  */
 
 static int
-cnt_done(struct sess *sp, struct worker *wrk, struct req *req)
+cnt_sess_done(struct sess *sp, struct worker *wrk, struct req *req)
 {
 	double dh, dp, da;
 	int i;
@@ -242,9 +242,7 @@ cnt_done(struct sess *sp, struct worker *wrk, struct req *req)
 	req->director = NULL;
 	req->restarts = 0;
 
-	/* If we did an ESI include, don't mess up our state */
-	if (req->esi_level > 0)
-		return (1);
+	AZ(req->esi_level);
 
 	if (req->vcl != NULL) {
 		if (wrk->vcl != NULL)
@@ -343,7 +341,7 @@ CNT_Session(struct sess *sp)
 			SES_Close(sp, "remote closed");
 		else
 			SES_Close(sp, "error");
-		assert(cnt_done(sp, wrk, sp->req) == 1);
+		assert(cnt_sess_done(sp, wrk, sp->req) == 1);
 		return;
 	}
 
@@ -362,10 +360,7 @@ CNT_Session(struct sess *sp)
 			if (done == 2)
 				return;
 			assert(done == 1);
-		}
-
-		if (sp->step == STP_DONE) {
-			done = cnt_done(sp, wrk, sp->req);
+			done = cnt_sess_done(sp, wrk, sp->req);
 			if (done)
 				return;
 		}
@@ -547,7 +542,6 @@ cnt_deliver(struct sess *sp, struct worker *wrk, struct req *req)
 	assert(WRW_IsReleased(wrk));
 	(void)HSH_Deref(&wrk->stats, NULL, &req->obj);
 	http_Teardown(req->resp);
-	sp->step = STP_DONE;
 	return (1);
 }
 /*--------------------------------------------------------------------
@@ -594,7 +588,6 @@ cnt_error(struct sess *sp, struct worker *wrk, struct req *req)
 		req->director = NULL;
 		http_Teardown(bo->beresp);
 		http_Teardown(bo->bereq);
-		sp->step = STP_DONE;
 		return(1);
 	}
 	CHECK_OBJ_NOTNULL(req->obj, OBJECT_MAGIC);
@@ -1361,7 +1354,6 @@ cnt_pipe(struct sess *sp, struct worker *wrk, struct req *req)
 	assert(WRW_IsReleased(wrk));
 	http_Teardown(bo->bereq);
 	VBO_DerefBusyObj(wrk, &req->busyobj);
-	sp->step = STP_DONE;
 	return (1);
 }
 
@@ -1487,7 +1479,6 @@ cnt_recv(struct sess *sp, const struct worker *wrk, struct req *req)
 		if (req->esi_level > 0) {
 			/* XXX: VSL something */
 			INCOMPL();
-			/* sp->step = STP_DONE; */
 			return (1);
 		}
 		sp->step = STP_PIPE;
@@ -1552,7 +1543,6 @@ cnt_start(struct sess *sp, struct worker *wrk, struct req *req)
 
 	/* If we could not even parse the request, just close */
 	if (req->err_code == 400) {
-		sp->step = STP_DONE;
 		SES_Close(sp, "junk");
 		return (1);
 	}
@@ -1569,7 +1559,6 @@ cnt_start(struct sess *sp, struct worker *wrk, struct req *req)
 		if (strcasecmp(p, "100-continue")) {
 			req->err_code = 417;
 		} else if (strlen(r) != write(sp->fd, r, strlen(r))) {
-			sp->step = STP_DONE;
 			SES_Close(sp, "remote closed");
 			return (1);
 		}
@@ -1657,7 +1646,6 @@ CNT_Request(struct req *req)
 		assert(req->sp == sp);
 
 		assert(sp->step != STP_WAIT);
-		assert(sp->step != STP_DONE);
 
 		switch (sp->step) {
 #define SESS_STEP(l,u,arg) \
diff --git a/bin/varnishd/cache/cache_esi_deliver.c b/bin/varnishd/cache/cache_esi_deliver.c
index 6af4b70..d346006 100644
--- a/bin/varnishd/cache/cache_esi_deliver.c
+++ b/bin/varnishd/cache/cache_esi_deliver.c
@@ -96,10 +96,8 @@ ved_include(struct req *req, const char *src, const char *host)
 	while (1) {
 		req->sp->wrk = wrk;
 		i = CNT_Request(req);
-		if (req->sp->step == STP_DONE) {
-			assert(i == 1);
+		if (i == 1)
 			break;
-		}
 		assert(i == 2);
 		AZ(req->sp->wrk);
 		DSL(0x20, SLT_Debug, req->sp->vsl_id, "loop waiting for ESI");
@@ -107,7 +105,6 @@ ved_include(struct req *req, const char *src, const char *host)
 	}
 	req->xid = sxid;
 	AN(req->sp->wrk);
-	assert(req->sp->step == STP_DONE);
 	req->esi_level--;
 	req->obj = obj;
 	req->res_mode = res_mode;
diff --git a/include/tbl/steps.h b/include/tbl/steps.h
index 6750cd3..e429631 100644
--- a/include/tbl/steps.h
+++ b/include/tbl/steps.h
@@ -43,5 +43,4 @@ SESS_STEP(fetchbody,	FETCHBODY,	(sp, sp->wrk, sp->req))
 SESS_STEP(prepresp,	PREPRESP,	(sp, sp->wrk, sp->req))
 SESS_STEP(deliver,	DELIVER,	(sp, sp->wrk, sp->req))
 SESS_STEP(error,	ERROR,		(sp, sp->wrk, sp->req))
-SESS_STEP(done,		DONE,		(sp, sp->wrk, sp->req))
 /*lint -restore */



From phk at varnish-cache.org  Wed Jun 20 09:27:09 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Wed, 20 Jun 2012 11:27:09 +0200
Subject: [master] 42780ae move the STP_ values out of the session state
	functions
Message-ID: <E1ShHBt-0006uo-Dr@project.varnish-software.com>

commit 42780ae2f6ef3ae1503256ba85f186c0db6b6ebb
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Wed Jun 20 09:26:50 2012 +0000

    move the STP_ values out of the session state functions

diff --git a/bin/varnishd/cache/cache_center.c b/bin/varnishd/cache/cache_center.c
index cff480d..eadbd3a 100644
--- a/bin/varnishd/cache/cache_center.c
+++ b/bin/varnishd/cache/cache_center.c
@@ -172,7 +172,6 @@ cnt_wait(struct sess *sp, struct worker *wrk, struct req *req)
 		if (i == 1) {
 			/* Got it, run with it */
 			req->t_req = now;
-			sp->step = STP_START;
 			return (0);
 		} else if (i == -1) {
 			why = "EOF";
@@ -226,7 +225,13 @@ DOT	DONE -> wait
 DOT	DONE -> ESI_RESP
  */
 
-static int
+enum cnt_sess_done_ret {
+	SESS_DONE_RET_GONE,
+	SESS_DONE_RET_WAIT,
+	SESS_DONE_RET_START,
+};
+
+static enum cnt_sess_done_ret
 cnt_sess_done(struct sess *sp, struct worker *wrk, struct req *req)
 {
 	double dh, dp, da;
@@ -291,7 +296,7 @@ cnt_sess_done(struct sess *sp, struct worker *wrk, struct req *req)
 	if (sp->fd < 0) {
 		wrk->stats.sess_closed++;
 		SES_Delete(sp, NULL, NAN);
-		return (1);
+		return (SESS_DONE_RET_GONE);
 	}
 
 	if (wrk->stats.client_req >= cache_param->wthread_stats_rate)
@@ -304,15 +309,14 @@ cnt_sess_done(struct sess *sp, struct worker *wrk, struct req *req)
 	if (i == 1) {
 		req->t_req = sp->t_idle;
 		wrk->stats.sess_pipeline++;
-		sp->step = STP_START;
+		return (SESS_DONE_RET_START);
 	} else {
 		sp->t_rx = sp->t_idle;
 		req->t_req = NAN;
 		if (Tlen(req->htc->rxbuf))
 			wrk->stats.sess_readahead++;
-		sp->step = STP_WAIT;
+		return (SESS_DONE_RET_WAIT);
 	}
-	return (0);
 }
 
 /*--------------------------------------------------------------------
@@ -322,6 +326,7 @@ void
 CNT_Session(struct sess *sp)
 {
 	int done;
+	enum cnt_sess_done_ret sdr;
 	struct worker *wrk;
 
 	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
@@ -341,7 +346,8 @@ CNT_Session(struct sess *sp)
 			SES_Close(sp, "remote closed");
 		else
 			SES_Close(sp, "error");
-		assert(cnt_sess_done(sp, wrk, sp->req) == 1);
+		sdr = cnt_sess_done(sp, wrk, sp->req);
+		assert(sdr == SESS_DONE_RET_GONE);
 		return;
 	}
 
@@ -352,23 +358,33 @@ CNT_Session(struct sess *sp)
 		assert(
 		    sp->step == STP_WAIT ||
 		    sp->step == STP_LOOKUP ||
-		    sp->step == STP_START ||
-		    sp->step == STP_RECV);
+		    sp->step == STP_START);
 
 		if (sp->step != STP_WAIT) {
 			done = CNT_Request(sp->req);
 			if (done == 2)
 				return;
 			assert(done == 1);
-			done = cnt_sess_done(sp, wrk, sp->req);
-			if (done)
+			sdr = cnt_sess_done(sp, wrk, sp->req);
+			switch (sdr) {
+			case SESS_DONE_RET_GONE:
 				return;
+			case SESS_DONE_RET_WAIT:
+				sp->step = STP_WAIT;	
+				break;
+			case SESS_DONE_RET_START:
+				sp->step = STP_START;	
+				break;
+			default:
+				WRONG("Illegal enum cnt_sess_done_ret");
+			}
 		}
 
 		if (sp->step == STP_WAIT) {
 			done = cnt_wait(sp, wrk, sp->req);
 			if (done)
 				return;
+			sp->step = STP_START;
 		}
 	}
 }



From phk at varnish-cache.org  Wed Jun 20 09:54:40 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Wed, 20 Jun 2012 11:54:40 +0200
Subject: [master] 3325c6c Eliminate the "sp" argument to the request state
	engine states.
Message-ID: <E1ShHcW-0000vZ-KM@project.varnish-software.com>

commit 3325c6c752c6c9b870f5aa600c113627112e0bf2
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Wed Jun 20 09:54:22 2012 +0000

    Eliminate the "sp" argument to the request state engine states.

diff --git a/bin/varnishd/cache/cache_center.c b/bin/varnishd/cache/cache_center.c
index eadbd3a..6e394e4 100644
--- a/bin/varnishd/cache/cache_center.c
+++ b/bin/varnishd/cache/cache_center.c
@@ -26,7 +26,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * This file contains the two central state machine for pushing 
+ * This file contains the two central state machine for pushing
  * sessions and requests.
  *
  * The first part of the file, entrypoint CNT_Session() and down to
@@ -370,10 +370,10 @@ CNT_Session(struct sess *sp)
 			case SESS_DONE_RET_GONE:
 				return;
 			case SESS_DONE_RET_WAIT:
-				sp->step = STP_WAIT;	
+				sp->step = STP_WAIT;
 				break;
 			case SESS_DONE_RET_START:
-				sp->step = STP_START;	
+				sp->step = STP_START;
 				break;
 			default:
 				WRONG("Illegal enum cnt_sess_done_ret");
@@ -409,11 +409,10 @@ DOT }
  */
 
 static int
-cnt_prepresp(struct sess *sp, struct worker *wrk, struct req *req)
+cnt_prepresp(struct worker *wrk, struct req *req)
 {
 	struct busyobj *bo;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	bo = req->busyobj;
@@ -476,9 +475,7 @@ cnt_prepresp(struct sess *sp, struct worker *wrk, struct req *req)
 	HTTP_Setup(req->resp, req->ws, req->vsl, HTTP_Resp);
 	RES_BuildHttp(req);
 
-	assert(req->sp == sp);
 	VCL_deliver_method(req);
-	assert(req->sp == sp);
 	switch (req->handling) {
 	case VCL_RET_DELIVER:
 		break;
@@ -494,12 +491,12 @@ cnt_prepresp(struct sess *sp, struct worker *wrk, struct req *req)
 		}
 		AZ(req->obj);
 		http_Teardown(req->resp);
-		sp->step = STP_RESTART;
+		req->sp->step = STP_RESTART;
 		return (0);
 	default:
 		WRONG("Illegal action in vcl_deliver{}");
 	}
-	sp->step = STP_DELIVER;
+	req->sp->step = STP_DELIVER;
 	return (0);
 }
 
@@ -519,11 +516,10 @@ DOT deliver -> DONE [style=bold,color=blue]
  */
 
 static int
-cnt_deliver(struct sess *sp, struct worker *wrk, struct req *req)
+cnt_deliver(struct worker *wrk, struct req *req)
 {
 	struct busyobj *bo;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	CHECK_OBJ_NOTNULL(req->obj, OBJECT_MAGIC);
@@ -539,7 +535,7 @@ cnt_deliver(struct sess *sp, struct worker *wrk, struct req *req)
 			HSH_Deref(&wrk->stats, NULL, &req->obj);
 			VBO_DerefBusyObj(wrk, &req->busyobj);
 			req->err_code = 503;
-			sp->step = STP_ERROR;
+			req->sp->step = STP_ERROR;
 			return (0);
 		}
 		VBO_DerefBusyObj(wrk, &req->busyobj);
@@ -576,13 +572,12 @@ DOT rsterr [label="RESTART",shape=plaintext]
  */
 
 static int
-cnt_error(struct sess *sp, struct worker *wrk, struct req *req)
+cnt_error(struct worker *wrk, struct req *req)
 {
 	struct http *h;
 	struct busyobj *bo;
 	char date[40];
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	AZ(req->objcore);
@@ -591,7 +586,7 @@ cnt_error(struct sess *sp, struct worker *wrk, struct req *req)
 
 	bo = VBO_GetBusyObj(wrk);
 	req->busyobj = bo;
-	bo->vsl->wid = sp->vsl_id;
+	bo->vsl->wid = req->sp->vsl_id;
 	AZ(bo->stats);
 	bo->stats = &wrk->stats;
 	req->objcore = HSH_NewObjCore(wrk);
@@ -625,15 +620,13 @@ cnt_error(struct sess *sp, struct worker *wrk, struct req *req)
 		http_PutResponse(h, req->err_reason);
 	else
 		http_PutResponse(h, http_StatusMessage(req->err_code));
-	assert(req->sp == sp);
 	VCL_error_method(req);
-	assert(req->sp == sp);
 
 	if (req->handling == VCL_RET_RESTART &&
 	    req->restarts <  cache_param->max_restarts) {
 		HSH_Drop(wrk, &req->obj);
 		VBO_DerefBusyObj(wrk, &req->busyobj);
-		sp->step = STP_RESTART;
+		req->sp->step = STP_RESTART;
 		return (0);
 	} else if (req->handling == VCL_RET_RESTART)
 		req->handling = VCL_RET_DELIVER;
@@ -648,7 +641,7 @@ cnt_error(struct sess *sp, struct worker *wrk, struct req *req)
 	req->err_reason = NULL;
 	http_Teardown(bo->bereq);
 	VBO_DerefBusyObj(wrk, &req->busyobj);
-	sp->step = STP_PREPRESP;
+	req->sp->step = STP_PREPRESP;
 	return (0);
 }
 
@@ -666,12 +659,11 @@ DOT fetch -> fetchbody [style=bold,color=blue]
  */
 
 static int
-cnt_fetch(struct sess *sp, struct worker *wrk, struct req *req)
+cnt_fetch(struct worker *wrk, struct req *req)
 {
 	int i, need_host_hdr;
 	struct busyobj *bo;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 
@@ -736,16 +728,14 @@ cnt_fetch(struct sess *sp, struct worker *wrk, struct req *req)
 		AZ(bo->do_esi);
 		AZ(bo->do_pass);
 
-		assert(req->sp == sp);
 		VCL_fetch_method(req);
-		assert(req->sp == sp);
 
 		if (bo->do_pass)
 			req->objcore->flags |= OC_F_PASS;
 
 		switch (req->handling) {
 		case VCL_RET_DELIVER:
-			sp->step = STP_FETCHBODY;
+			req->sp->step = STP_FETCHBODY;
 			return (0);
 		default:
 			break;
@@ -771,10 +761,10 @@ cnt_fetch(struct sess *sp, struct worker *wrk, struct req *req)
 
 	switch (req->handling) {
 	case VCL_RET_RESTART:
-		sp->step = STP_RESTART;
+		req->sp->step = STP_RESTART;
 		return (0);
 	case VCL_RET_ERROR:
-		sp->step = STP_ERROR;
+		req->sp->step = STP_ERROR;
 		return (0);
 	default:
 		WRONG("Illegal action in vcl_fetch{}");
@@ -795,7 +785,7 @@ DOT fetchbody:out -> prepresp [style=bold,color=blue]
  */
 
 static int
-cnt_fetchbody(struct sess *sp, struct worker *wrk, struct req *req)
+cnt_fetchbody(struct worker *wrk, struct req *req)
 {
 	struct http *hp, *hp2;
 	char *b;
@@ -805,7 +795,6 @@ cnt_fetchbody(struct sess *sp, struct worker *wrk, struct req *req)
 	int varyl = 0, pass;
 	struct busyobj *bo;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	bo = req->busyobj;
@@ -930,7 +919,7 @@ cnt_fetchbody(struct sess *sp, struct worker *wrk, struct req *req)
 	bo->stats = NULL;
 	if (req->obj == NULL) {
 		req->err_code = 503;
-		sp->step = STP_ERROR;
+		req->sp->step = STP_ERROR;
 		VDI_CloseFd(&bo->vbc);
 		VBO_DerefBusyObj(wrk, &req->busyobj);
 		return (0);
@@ -1011,12 +1000,12 @@ cnt_fetchbody(struct sess *sp, struct worker *wrk, struct req *req)
 		HSH_Deref(&wrk->stats, NULL, &req->obj);
 		VBO_DerefBusyObj(wrk, &req->busyobj);
 		req->err_code = 503;
-		sp->step = STP_ERROR;
+		req->sp->step = STP_ERROR;
 		return (0);
 	}
 
 	assert(WRW_IsReleased(wrk));
-	sp->step = STP_PREPRESP;
+	req->sp->step = STP_PREPRESP;
 	return (0);
 }
 
@@ -1039,9 +1028,8 @@ DOT hit:del -> prepresp [label="deliver",style=bold,color=green]
  */
 
 static int
-cnt_hit(struct sess *sp, struct worker *wrk, struct req *req)
+cnt_hit(struct worker *wrk, struct req *req)
 {
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 
@@ -1052,15 +1040,13 @@ cnt_hit(struct sess *sp, struct worker *wrk, struct req *req)
 
 	assert(!(req->obj->objcore->flags & OC_F_PASS));
 
-	assert(req->sp == sp);
 	VCL_hit_method(req);
-	assert(req->sp == sp);
 
 	if (req->handling == VCL_RET_DELIVER) {
 		//AZ(req->busyobj->bereq->ws);
 		//AZ(req->busyobj->beresp->ws);
 		(void)FetchReqBody(req, 0);
-		sp->step = STP_PREPRESP;
+		req->sp->step = STP_PREPRESP;
 		return (0);
 	}
 
@@ -1070,13 +1056,13 @@ cnt_hit(struct sess *sp, struct worker *wrk, struct req *req)
 
 	switch(req->handling) {
 	case VCL_RET_PASS:
-		sp->step = STP_PASS;
+		req->sp->step = STP_PASS;
 		return (0);
 	case VCL_RET_ERROR:
-		sp->step = STP_ERROR;
+		req->sp->step = STP_ERROR;
 		return (0);
 	case VCL_RET_RESTART:
-		sp->step = STP_RESTART;
+		req->sp->step = STP_RESTART;
 		return (0);
 	default:
 		WRONG("Illegal action in vcl_hit{}");
@@ -1103,13 +1089,12 @@ DOT lookup:yes -> pass [style=bold,color=red]
  */
 
 static int
-cnt_lookup(struct sess *sp, struct worker *wrk, struct req *req)
+cnt_lookup(struct worker *wrk, struct req *req)
 {
 	struct objcore *oc;
 	struct object *o;
 	struct objhead *oh;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	AZ(req->objcore);
@@ -1127,7 +1112,6 @@ cnt_lookup(struct sess *sp, struct worker *wrk, struct req *req)
 		 * worker thread.   We return to STP_LOOKUP when the busy
 		 * object has been unbusied, and still have the hash digest
 		 * around to do the lookup with.
-		 * NB:  Do not access sp any more !
 		 */
 		return (2);
 	}
@@ -1156,7 +1140,7 @@ cnt_lookup(struct sess *sp, struct worker *wrk, struct req *req)
 		req->vary_e = NULL;
 
 		req->objcore = oc;
-		sp->step = STP_MISS;
+		req->sp->step = STP_MISS;
 		return (0);
 	}
 
@@ -1177,13 +1161,13 @@ cnt_lookup(struct sess *sp, struct worker *wrk, struct req *req)
 		VSLb(req->vsl, SLT_HitPass, "%u", req->obj->xid);
 		(void)HSH_Deref(&wrk->stats, NULL, &req->obj);
 		AZ(req->objcore);
-		sp->step = STP_PASS;
+		req->sp->step = STP_PASS;
 		return (0);
 	}
 
 	wrk->stats.cache_hit++;
 	VSLb(req->vsl, SLT_Hit, "%u", req->obj->xid);
-	sp->step = STP_HIT;
+	req->sp->step = STP_HIT;
 	return (0);
 }
 
@@ -1202,11 +1186,10 @@ DOT
  */
 
 static int
-cnt_miss(struct sess *sp, struct worker *wrk, struct req *req)
+cnt_miss(struct worker *wrk, struct req *req)
 {
 	struct busyobj *bo;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	CHECK_OBJ_NOTNULL(req->vcl, VCL_CONF_MAGIC);
@@ -1228,13 +1211,11 @@ cnt_miss(struct sess *sp, struct worker *wrk, struct req *req)
 		http_SetHeader(bo->bereq, "Accept-Encoding: gzip");
 	}
 
-	assert(req->sp == sp);
 	VCL_miss_method(req);
-	assert(req->sp == sp);
 
 	if (req->handling == VCL_RET_FETCH) {
 		CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
-		sp->step = STP_FETCH;
+		req->sp->step = STP_FETCH;
 		return (0);
 	}
 
@@ -1245,13 +1226,13 @@ cnt_miss(struct sess *sp, struct worker *wrk, struct req *req)
 
 	switch(req->handling) {
 	case VCL_RET_ERROR:
-		sp->step = STP_ERROR;
+		req->sp->step = STP_ERROR;
 		break;
 	case VCL_RET_PASS:
-		sp->step = STP_PASS;
+		req->sp->step = STP_PASS;
 		break;
 	case VCL_RET_RESTART:
-		sp->step = STP_RESTART;
+		req->sp->step = STP_RESTART;
 		break;
 	default:
 		WRONG("Illegal action in vcl_miss{}");
@@ -1277,11 +1258,10 @@ XDOT err_pass [label="ERROR",shape=plaintext]
  */
 
 static int
-cnt_pass(struct sess *sp, struct worker *wrk, struct req *req)
+cnt_pass(struct worker *wrk, struct req *req)
 {
 	struct busyobj *bo;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	CHECK_OBJ_NOTNULL(req->vcl, VCL_CONF_MAGIC);
@@ -1291,24 +1271,22 @@ cnt_pass(struct sess *sp, struct worker *wrk, struct req *req)
 
 	req->busyobj = VBO_GetBusyObj(wrk);
 	bo = req->busyobj;
-	bo->vsl->wid = sp->vsl_id;
+	bo->vsl->wid = req->sp->vsl_id;
 	bo->refcount = 2;
 	HTTP_Setup(bo->bereq, bo->ws, bo->vsl, HTTP_Bereq);
 	http_FilterReq(req, HTTPH_R_PASS);
 
-	assert(req->sp == sp);
 	VCL_pass_method(req);
-	assert(req->sp == sp);
 
 	if (req->handling == VCL_RET_ERROR) {
 		http_Teardown(bo->bereq);
 		VBO_DerefBusyObj(wrk, &req->busyobj);
-		sp->step = STP_ERROR;
+		req->sp->step = STP_ERROR;
 		return (0);
 	}
 	assert(req->handling == VCL_RET_PASS);
 	wrk->acct_tmp.pass++;
-	sp->step = STP_FETCH;
+	req->sp->step = STP_FETCH;
 
 	req->objcore = HSH_NewObjCore(wrk);
 	req->objcore->busyobj = bo;
@@ -1341,11 +1319,10 @@ DOT err_pipe [label="ERROR",shape=plaintext]
  */
 
 static int
-cnt_pipe(struct sess *sp, struct worker *wrk, struct req *req)
+cnt_pipe(struct worker *wrk, struct req *req)
 {
 	struct busyobj *bo;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	CHECK_OBJ_NOTNULL(req->vcl, VCL_CONF_MAGIC);
@@ -1354,13 +1331,11 @@ cnt_pipe(struct sess *sp, struct worker *wrk, struct req *req)
 	wrk->acct_tmp.pipe++;
 	req->busyobj = VBO_GetBusyObj(wrk);
 	bo = req->busyobj;
-	bo->vsl->wid = sp->vsl_id;
+	bo->vsl->wid = req->sp->vsl_id;
 	HTTP_Setup(bo->bereq, bo->ws, bo->vsl, HTTP_Bereq);
 	http_FilterReq(req, 0);
 
-	assert(req->sp == sp);
 	VCL_pipe_method(req);
-	assert(req->sp == sp);
 
 	if (req->handling == VCL_RET_ERROR)
 		INCOMPL();
@@ -1386,20 +1361,19 @@ DOT restart -> recv [color=purple]
  */
 
 static int
-cnt_restart(struct sess *sp, const struct worker *wrk, struct req *req)
+cnt_restart(const struct worker *wrk, struct req *req)
 {
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 
 	req->director = NULL;
 	if (++req->restarts >= cache_param->max_restarts) {
 		req->err_code = 503;
-		sp->step = STP_ERROR;
+		req->sp->step = STP_ERROR;
 	} else {
 		req->err_code = 0;
-		sp->step = STP_RECV;
+		req->sp->step = STP_RECV;
 	}
 	return (0);
 }
@@ -1433,12 +1407,11 @@ DOT hash -> lookup [label="hash",style=bold,color=green]
  */
 
 static int
-cnt_recv(struct sess *sp, const struct worker *wrk, struct req *req)
+cnt_recv(const struct worker *wrk, struct req *req)
 {
 	unsigned recv_handling;
 	struct SHA256Context sha256ctx;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	CHECK_OBJ_NOTNULL(req->vcl, VCL_CONF_MAGIC);
@@ -1457,9 +1430,7 @@ cnt_recv(struct sess *sp, const struct worker *wrk, struct req *req)
 
 	http_CollectHdr(req->http, H_Cache_Control);
 
-	assert(req->sp == sp);
 	VCL_recv_method(req);
-	assert(req->sp == sp);
 	recv_handling = req->handling;
 
 	if (cache_param->http_gzip_support &&
@@ -1475,9 +1446,7 @@ cnt_recv(struct sess *sp, const struct worker *wrk, struct req *req)
 
 	req->sha256ctx = &sha256ctx;	/* so HSH_AddString() can find it */
 	SHA256_Init(req->sha256ctx);
-	assert(req->sp == sp);
 	VCL_hash_method(req);
-	assert(req->sp == sp);
 	assert(req->handling == VCL_RET_HASH);
 	SHA256_Final(req->digest, req->sha256ctx);
 	req->sha256ctx = NULL;
@@ -1489,7 +1458,7 @@ cnt_recv(struct sess *sp, const struct worker *wrk, struct req *req)
 
 	switch(recv_handling) {
 	case VCL_RET_LOOKUP:
-		sp->step = STP_LOOKUP;
+		req->sp->step = STP_LOOKUP;
 		return (0);
 	case VCL_RET_PIPE:
 		if (req->esi_level > 0) {
@@ -1497,13 +1466,13 @@ cnt_recv(struct sess *sp, const struct worker *wrk, struct req *req)
 			INCOMPL();
 			return (1);
 		}
-		sp->step = STP_PIPE;
+		req->sp->step = STP_PIPE;
 		return (0);
 	case VCL_RET_PASS:
-		sp->step = STP_PASS;
+		req->sp->step = STP_PASS;
 		return (0);
 	case VCL_RET_ERROR:
-		sp->step = STP_ERROR;
+		req->sp->step = STP_ERROR;
 		return (0);
 	default:
 		WRONG("Illegal action in vcl_recv{}");
@@ -1523,12 +1492,11 @@ DOT start -> DONE [label=errors]
  */
 
 static int
-cnt_start(struct sess *sp, struct worker *wrk, struct req *req)
+cnt_start(struct worker *wrk, struct req *req)
 {
 	char *p;
 	const char *r = "HTTP/1.1 100 Continue\r\n\r\n";
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	AZ(req->restarts);
@@ -1536,7 +1504,6 @@ cnt_start(struct sess *sp, struct worker *wrk, struct req *req)
 	AZ(req->vcl);
 	AZ(req->esi_level);
 	assert(!isnan(req->t_req));
-	assert(req->sp == sp);
 
 	/* Update stats of various sorts */
 	wrk->stats.client_req++;
@@ -1545,7 +1512,7 @@ cnt_start(struct sess *sp, struct worker *wrk, struct req *req)
 	/* Assign XID and log */
 	req->xid = ++xids;				/* XXX not locked */
 	VSLb(req->vsl, SLT_ReqStart, "%s %s %u",
-	    sp->addr, sp->port,  req->xid);
+	    req->sp->addr, req->sp->port, req->xid);
 
 	/* Borrow VCL reference from worker thread */
 	VCL_Refresh(&wrk->vcl);
@@ -1559,7 +1526,7 @@ cnt_start(struct sess *sp, struct worker *wrk, struct req *req)
 
 	/* If we could not even parse the request, just close */
 	if (req->err_code == 400) {
-		SES_Close(sp, "junk");
+		SES_Close(req->sp, "junk");
 		return (1);
 	}
 
@@ -1574,8 +1541,8 @@ cnt_start(struct sess *sp, struct worker *wrk, struct req *req)
 	if (req->err_code == 0 && http_GetHdr(req->http, H_Expect, &p)) {
 		if (strcasecmp(p, "100-continue")) {
 			req->err_code = 417;
-		} else if (strlen(r) != write(sp->fd, r, strlen(r))) {
-			SES_Close(sp, "remote closed");
+		} else if (strlen(r) != write(req->sp->fd, r, strlen(r))) {
+			SES_Close(req->sp, "remote closed");
 			return (1);
 		}
 	}
@@ -1587,9 +1554,9 @@ cnt_start(struct sess *sp, struct worker *wrk, struct req *req)
 	HTTP_Copy(req->http0, req->http);	/* Copy for restart/ESI use */
 
 	if (req->err_code)
-		sp->step = STP_ERROR;
+		req->sp->step = STP_ERROR;
 	else
-		sp->step = STP_RECV;
+		req->sp->step = STP_RECV;
 	return (0);
 }
 
diff --git a/include/tbl/steps.h b/include/tbl/steps.h
index e429631..703c418 100644
--- a/include/tbl/steps.h
+++ b/include/tbl/steps.h
@@ -30,17 +30,17 @@
 
 /*lint -save -e525 -e539 */
 SESS_STEP(wait,		WAIT,		(sp, sp->wrk, sp->req))
-SESS_STEP(restart,	RESTART,	(sp, sp->wrk, sp->req))
-SESS_STEP(recv,		RECV,		(sp, sp->wrk, sp->req))
-SESS_STEP(start,	START,		(sp, sp->wrk, sp->req))
-SESS_STEP(pipe,		PIPE,		(sp, sp->wrk, sp->req))
-SESS_STEP(pass,		PASS,		(sp, sp->wrk, sp->req))
-SESS_STEP(lookup,	LOOKUP,		(sp, sp->wrk, sp->req))
-SESS_STEP(miss,		MISS,		(sp, sp->wrk, sp->req))
-SESS_STEP(hit,		HIT,		(sp, sp->wrk, sp->req))
-SESS_STEP(fetch,	FETCH,		(sp, sp->wrk, sp->req))
-SESS_STEP(fetchbody,	FETCHBODY,	(sp, sp->wrk, sp->req))
-SESS_STEP(prepresp,	PREPRESP,	(sp, sp->wrk, sp->req))
-SESS_STEP(deliver,	DELIVER,	(sp, sp->wrk, sp->req))
-SESS_STEP(error,	ERROR,		(sp, sp->wrk, sp->req))
+SESS_STEP(restart,	RESTART,	(wrk, req))
+SESS_STEP(recv,		RECV,		(wrk, req))
+SESS_STEP(start,	START,		(wrk, req))
+SESS_STEP(pipe,		PIPE,		(wrk, req))
+SESS_STEP(pass,		PASS,		(wrk, req))
+SESS_STEP(lookup,	LOOKUP,		(wrk, req))
+SESS_STEP(miss,		MISS,		(wrk, req))
+SESS_STEP(hit,		HIT,		(wrk, req))
+SESS_STEP(fetch,	FETCH,		(wrk, req))
+SESS_STEP(fetchbody,	FETCHBODY,	(wrk, req))
+SESS_STEP(prepresp,	PREPRESP,	(wrk, req))
+SESS_STEP(deliver,	DELIVER,	(wrk, req))
+SESS_STEP(error,	ERROR,		(wrk, req))
 /*lint -restore */



From phk at varnish-cache.org  Wed Jun 20 10:26:24 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Wed, 20 Jun 2012 12:26:24 +0200
Subject: [master] 8e253db More firmly split session and request states.
Message-ID: <E1ShI7E-0004OI-Em@project.varnish-software.com>

commit 8e253dbe9a05cb32bea186d8927b5899a1268e16
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Wed Jun 20 10:25:25 2012 +0000

    More firmly split session and request states.

diff --git a/bin/varnishd/cache/cache.h b/bin/varnishd/cache/cache.h
index 299dc93..ed8e9f9 100644
--- a/bin/varnishd/cache/cache.h
+++ b/bin/varnishd/cache/cache.h
@@ -122,12 +122,18 @@ typedef struct {
 
 /*--------------------------------------------------------------------*/
 
-enum step {
-#define SESS_STEP(l, u, arg)	STP_##u,
+enum sess_step {
+#define SESS_STEP(l, u)		S_STP_##u,
 #include "tbl/steps.h"
 #undef SESS_STEP
 };
 
+enum req_step {
+#define REQ_STEP(l, u, arg)	R_STP_##u,
+#include "tbl/steps.h"
+#undef REQ_STEP
+};
+
 /*--------------------------------------------------------------------*/
 struct lock { void *priv; };	// Opaque
 
@@ -562,6 +568,7 @@ struct req {
 	uint8_t			hash_always_miss;
 
 	struct sess		*sp;
+	enum req_step		req_step;
 	VTAILQ_ENTRY(req)	w_list;
 
 	/* The busy objhead we sleep on */
@@ -643,7 +650,7 @@ struct sess {
 	unsigned		magic;
 #define SESS_MAGIC		0x2c2f9c5a
 
-	enum step		step;
+	enum sess_step		sess_step;
 	int			fd;
 	unsigned		vsl_id;
 	uint32_t		vxid;
diff --git a/bin/varnishd/cache/cache_center.c b/bin/varnishd/cache/cache_center.c
index 6e394e4..fff81b4 100644
--- a/bin/varnishd/cache/cache_center.c
+++ b/bin/varnishd/cache/cache_center.c
@@ -341,7 +341,7 @@ CNT_Session(struct sess *sp)
 	 * rather do the syscall in the worker thread.
 	 * On systems which return errors for ioctl, we close early
 	 */
-	if (sp->step == STP_WAIT && VTCP_blocking(sp->fd)) {
+	if (sp->sess_step == S_STP_NEWREQ && VTCP_blocking(sp->fd)) {
 		if (errno == ECONNRESET)
 			SES_Close(sp, "remote closed");
 		else
@@ -356,11 +356,12 @@ CNT_Session(struct sess *sp)
 		 * Possible entrance states
 		 */
 		assert(
-		    sp->step == STP_WAIT ||
-		    sp->step == STP_LOOKUP ||
-		    sp->step == STP_START);
+		    sp->sess_step == S_STP_NEWREQ ||
+		    (sp->req != NULL &&
+		    (sp->req->req_step == R_STP_LOOKUP ||
+		    sp->req->req_step == R_STP_START)));
 
-		if (sp->step != STP_WAIT) {
+		if (sp->sess_step == S_STP_WORKING) {
 			done = CNT_Request(sp->req);
 			if (done == 2)
 				return;
@@ -370,21 +371,24 @@ CNT_Session(struct sess *sp)
 			case SESS_DONE_RET_GONE:
 				return;
 			case SESS_DONE_RET_WAIT:
-				sp->step = STP_WAIT;
+				sp->sess_step = S_STP_NEWREQ;
 				break;
 			case SESS_DONE_RET_START:
-				sp->step = STP_START;
+				sp->sess_step = S_STP_WORKING;
+				sp->req->req_step = R_STP_START;
 				break;
 			default:
 				WRONG("Illegal enum cnt_sess_done_ret");
 			}
 		}
 
-		if (sp->step == STP_WAIT) {
+		if (sp->sess_step == S_STP_NEWREQ) {
 			done = cnt_wait(sp, wrk, sp->req);
-			if (done)
+			if (done) {
 				return;
-			sp->step = STP_START;
+			}
+			sp->sess_step = S_STP_WORKING;
+			sp->req->req_step = R_STP_START;
 		}
 	}
 }
@@ -491,12 +495,12 @@ cnt_prepresp(struct worker *wrk, struct req *req)
 		}
 		AZ(req->obj);
 		http_Teardown(req->resp);
-		req->sp->step = STP_RESTART;
+		req->req_step = R_STP_RESTART;
 		return (0);
 	default:
 		WRONG("Illegal action in vcl_deliver{}");
 	}
-	req->sp->step = STP_DELIVER;
+	req->req_step = R_STP_DELIVER;
 	return (0);
 }
 
@@ -535,7 +539,7 @@ cnt_deliver(struct worker *wrk, struct req *req)
 			HSH_Deref(&wrk->stats, NULL, &req->obj);
 			VBO_DerefBusyObj(wrk, &req->busyobj);
 			req->err_code = 503;
-			req->sp->step = STP_ERROR;
+			req->req_step = R_STP_ERROR;
 			return (0);
 		}
 		VBO_DerefBusyObj(wrk, &req->busyobj);
@@ -626,7 +630,7 @@ cnt_error(struct worker *wrk, struct req *req)
 	    req->restarts <  cache_param->max_restarts) {
 		HSH_Drop(wrk, &req->obj);
 		VBO_DerefBusyObj(wrk, &req->busyobj);
-		req->sp->step = STP_RESTART;
+		req->req_step = R_STP_RESTART;
 		return (0);
 	} else if (req->handling == VCL_RET_RESTART)
 		req->handling = VCL_RET_DELIVER;
@@ -641,7 +645,7 @@ cnt_error(struct worker *wrk, struct req *req)
 	req->err_reason = NULL;
 	http_Teardown(bo->bereq);
 	VBO_DerefBusyObj(wrk, &req->busyobj);
-	req->sp->step = STP_PREPRESP;
+	req->req_step = R_STP_PREPRESP;
 	return (0);
 }
 
@@ -735,7 +739,7 @@ cnt_fetch(struct worker *wrk, struct req *req)
 
 		switch (req->handling) {
 		case VCL_RET_DELIVER:
-			req->sp->step = STP_FETCHBODY;
+			req->req_step = R_STP_FETCHBODY;
 			return (0);
 		default:
 			break;
@@ -761,10 +765,10 @@ cnt_fetch(struct worker *wrk, struct req *req)
 
 	switch (req->handling) {
 	case VCL_RET_RESTART:
-		req->sp->step = STP_RESTART;
+		req->req_step = R_STP_RESTART;
 		return (0);
 	case VCL_RET_ERROR:
-		req->sp->step = STP_ERROR;
+		req->req_step = R_STP_ERROR;
 		return (0);
 	default:
 		WRONG("Illegal action in vcl_fetch{}");
@@ -919,7 +923,7 @@ cnt_fetchbody(struct worker *wrk, struct req *req)
 	bo->stats = NULL;
 	if (req->obj == NULL) {
 		req->err_code = 503;
-		req->sp->step = STP_ERROR;
+		req->req_step = R_STP_ERROR;
 		VDI_CloseFd(&bo->vbc);
 		VBO_DerefBusyObj(wrk, &req->busyobj);
 		return (0);
@@ -1000,12 +1004,12 @@ cnt_fetchbody(struct worker *wrk, struct req *req)
 		HSH_Deref(&wrk->stats, NULL, &req->obj);
 		VBO_DerefBusyObj(wrk, &req->busyobj);
 		req->err_code = 503;
-		req->sp->step = STP_ERROR;
+		req->req_step = R_STP_ERROR;
 		return (0);
 	}
 
 	assert(WRW_IsReleased(wrk));
-	req->sp->step = STP_PREPRESP;
+	req->req_step = R_STP_PREPRESP;
 	return (0);
 }
 
@@ -1046,7 +1050,7 @@ cnt_hit(struct worker *wrk, struct req *req)
 		//AZ(req->busyobj->bereq->ws);
 		//AZ(req->busyobj->beresp->ws);
 		(void)FetchReqBody(req, 0);
-		req->sp->step = STP_PREPRESP;
+		req->req_step = R_STP_PREPRESP;
 		return (0);
 	}
 
@@ -1056,13 +1060,13 @@ cnt_hit(struct worker *wrk, struct req *req)
 
 	switch(req->handling) {
 	case VCL_RET_PASS:
-		req->sp->step = STP_PASS;
+		req->req_step = R_STP_PASS;
 		return (0);
 	case VCL_RET_ERROR:
-		req->sp->step = STP_ERROR;
+		req->req_step = R_STP_ERROR;
 		return (0);
 	case VCL_RET_RESTART:
-		req->sp->step = STP_RESTART;
+		req->req_step = R_STP_RESTART;
 		return (0);
 	default:
 		WRONG("Illegal action in vcl_hit{}");
@@ -1140,7 +1144,7 @@ cnt_lookup(struct worker *wrk, struct req *req)
 		req->vary_e = NULL;
 
 		req->objcore = oc;
-		req->sp->step = STP_MISS;
+		req->req_step = R_STP_MISS;
 		return (0);
 	}
 
@@ -1161,13 +1165,13 @@ cnt_lookup(struct worker *wrk, struct req *req)
 		VSLb(req->vsl, SLT_HitPass, "%u", req->obj->xid);
 		(void)HSH_Deref(&wrk->stats, NULL, &req->obj);
 		AZ(req->objcore);
-		req->sp->step = STP_PASS;
+		req->req_step = R_STP_PASS;
 		return (0);
 	}
 
 	wrk->stats.cache_hit++;
 	VSLb(req->vsl, SLT_Hit, "%u", req->obj->xid);
-	req->sp->step = STP_HIT;
+	req->req_step = R_STP_HIT;
 	return (0);
 }
 
@@ -1215,7 +1219,7 @@ cnt_miss(struct worker *wrk, struct req *req)
 
 	if (req->handling == VCL_RET_FETCH) {
 		CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
-		req->sp->step = STP_FETCH;
+		req->req_step = R_STP_FETCH;
 		return (0);
 	}
 
@@ -1226,13 +1230,13 @@ cnt_miss(struct worker *wrk, struct req *req)
 
 	switch(req->handling) {
 	case VCL_RET_ERROR:
-		req->sp->step = STP_ERROR;
+		req->req_step = R_STP_ERROR;
 		break;
 	case VCL_RET_PASS:
-		req->sp->step = STP_PASS;
+		req->req_step = R_STP_PASS;
 		break;
 	case VCL_RET_RESTART:
-		req->sp->step = STP_RESTART;
+		req->req_step = R_STP_RESTART;
 		break;
 	default:
 		WRONG("Illegal action in vcl_miss{}");
@@ -1281,12 +1285,12 @@ cnt_pass(struct worker *wrk, struct req *req)
 	if (req->handling == VCL_RET_ERROR) {
 		http_Teardown(bo->bereq);
 		VBO_DerefBusyObj(wrk, &req->busyobj);
-		req->sp->step = STP_ERROR;
+		req->req_step = R_STP_ERROR;
 		return (0);
 	}
 	assert(req->handling == VCL_RET_PASS);
 	wrk->acct_tmp.pass++;
-	req->sp->step = STP_FETCH;
+	req->req_step = R_STP_FETCH;
 
 	req->objcore = HSH_NewObjCore(wrk);
 	req->objcore->busyobj = bo;
@@ -1370,10 +1374,10 @@ cnt_restart(const struct worker *wrk, struct req *req)
 	req->director = NULL;
 	if (++req->restarts >= cache_param->max_restarts) {
 		req->err_code = 503;
-		req->sp->step = STP_ERROR;
+		req->req_step = R_STP_ERROR;
 	} else {
 		req->err_code = 0;
-		req->sp->step = STP_RECV;
+		req->req_step = R_STP_RECV;
 	}
 	return (0);
 }
@@ -1458,7 +1462,7 @@ cnt_recv(const struct worker *wrk, struct req *req)
 
 	switch(recv_handling) {
 	case VCL_RET_LOOKUP:
-		req->sp->step = STP_LOOKUP;
+		req->req_step = R_STP_LOOKUP;
 		return (0);
 	case VCL_RET_PIPE:
 		if (req->esi_level > 0) {
@@ -1466,13 +1470,13 @@ cnt_recv(const struct worker *wrk, struct req *req)
 			INCOMPL();
 			return (1);
 		}
-		req->sp->step = STP_PIPE;
+		req->req_step = R_STP_PIPE;
 		return (0);
 	case VCL_RET_PASS:
-		req->sp->step = STP_PASS;
+		req->req_step = R_STP_PASS;
 		return (0);
 	case VCL_RET_ERROR:
-		req->sp->step = STP_ERROR;
+		req->req_step = R_STP_ERROR;
 		return (0);
 	default:
 		WRONG("Illegal action in vcl_recv{}");
@@ -1554,9 +1558,9 @@ cnt_start(struct worker *wrk, struct req *req)
 	HTTP_Copy(req->http0, req->http);	/* Copy for restart/ESI use */
 
 	if (req->err_code)
-		req->sp->step = STP_ERROR;
+		req->req_step = R_STP_ERROR;
 	else
-		req->sp->step = STP_RECV;
+		req->req_step = R_STP_RECV;
 	return (0);
 }
 
@@ -1610,9 +1614,9 @@ CNT_Request(struct req *req)
 	 * Possible entrance states
 	 */
 	assert(
-	    sp->step == STP_LOOKUP ||
-	    sp->step == STP_START ||
-	    sp->step == STP_RECV);
+	    req->req_step == R_STP_LOOKUP ||
+	    req->req_step == R_STP_START ||
+	    req->req_step == R_STP_RECV);
 
 	for (done = 0; !done; ) {
 		assert(sp->wrk == wrk);
@@ -1628,17 +1632,15 @@ CNT_Request(struct req *req)
 		AN(req->sp);
 		assert(req->sp == sp);
 
-		assert(sp->step != STP_WAIT);
-
-		switch (sp->step) {
-#define SESS_STEP(l,u,arg) \
-		    case STP_##u: \
+		switch (req->req_step) {
+#define REQ_STEP(l,u,arg) \
+		    case R_STP_##u: \
 			if (cache_param->diag_bitmap & 0x01) \
 				cnt_diag(sp, #u); \
 			done = cnt_##l arg; \
 		        break;
 #include "tbl/steps.h"
-#undef SESS_STEP
+#undef REQ_STEP
 		default:
 			WRONG("State engine misfire");
 		}
diff --git a/bin/varnishd/cache/cache_esi_deliver.c b/bin/varnishd/cache/cache_esi_deliver.c
index d346006..9075a77 100644
--- a/bin/varnishd/cache/cache_esi_deliver.c
+++ b/bin/varnishd/cache/cache_esi_deliver.c
@@ -82,7 +82,7 @@ ved_include(struct req *req, const char *src, const char *host)
 	 * XXX: make sure we don't trip up the check in vcl_recv.
 	 */
 	req->director = NULL;
-	req->sp->step = STP_RECV;
+	req->req_step = R_STP_RECV;
 	http_ForceGet(req->http);
 
 	/* Don't do conditionals */
diff --git a/bin/varnishd/cache/cache_panic.c b/bin/varnishd/cache/cache_panic.c
index ce2b393..c4511e8 100644
--- a/bin/varnishd/cache/cache_panic.c
+++ b/bin/varnishd/cache/cache_panic.c
@@ -230,10 +230,24 @@ pan_busyobj(const struct busyobj *bo)
 static void
 pan_req(const struct req *req)
 {
-	const char *hand;
+	const char *hand, *stp;
 
 	VSB_printf(pan_vsp, "req = %p {\n", req);
-	VSB_printf(pan_vsp, "  sp = %p, xid = %u,\n", req->sp, req->xid);
+
+	VSB_printf(pan_vsp, "  sp = %p, xid = %u,",
+	    req->sp, req->xid);
+
+	switch (req->req_step) {
+#define REQ_STEP(l, u, arg) case R_STP_##u: stp = "R_STP_" #u; break;
+#include "tbl/steps.h"
+#undef REQ_STEP
+		default: stp = NULL;
+	}
+	if (stp != NULL)
+		VSB_printf(pan_vsp, "  step = %s,\n", stp);
+	else
+		VSB_printf(pan_vsp, "  step = 0x%x,\n", req->req_step);
+
 	hand = VCL_Return_Name(req->handling);
 	if (hand != NULL)
 		VSB_printf(pan_vsp, "  handling = %s,\n", hand);
@@ -277,8 +291,8 @@ pan_sess(const struct sess *sp)
 	VSB_printf(pan_vsp, "  client = %s %s,\n",
 	    sp->addr ? sp->addr : "?.?.?.?",
 	    sp->port ? sp->port : "?");
-	switch (sp->step) {
-#define SESS_STEP(l, u, arg) case STP_##u: stp = "STP_" #u; break;
+	switch (sp->sess_step) {
+#define SESS_STEP(l, u) case S_STP_##u: stp = "S_STP_" #u; break;
 #include "tbl/steps.h"
 #undef SESS_STEP
 		default: stp = NULL;
@@ -286,7 +300,7 @@ pan_sess(const struct sess *sp)
 	if (stp != NULL)
 		VSB_printf(pan_vsp, "  step = %s,\n", stp);
 	else
-		VSB_printf(pan_vsp, "  step = 0x%x,\n", sp->step);
+		VSB_printf(pan_vsp, "  step = 0x%x,\n", sp->sess_step);
 
 	if (sp->wrk != NULL)
 		pan_wrk(sp->wrk);
diff --git a/bin/varnishd/cache/cache_session.c b/bin/varnishd/cache/cache_session.c
index 34dad47..aee58b0 100644
--- a/bin/varnishd/cache/cache_session.c
+++ b/bin/varnishd/cache/cache_session.c
@@ -159,7 +159,7 @@ SES_pool_accept_task(struct worker *wrk, void *arg)
 		VCA_FailSess(wrk);
 	} else {
 		VCA_SetupSess(wrk, sp);
-		sp->step = STP_WAIT;
+		sp->sess_step = S_STP_NEWREQ;
 		ses_pool_task(wrk, sp);
 	}
 }
@@ -207,7 +207,7 @@ void
 SES_Handle(struct sess *sp, double now)
 {
 
-	sp->step = STP_WAIT;
+	sp->sess_step = S_STP_NEWREQ;
 	sp->t_rx = now;
 	(void)SES_Schedule(sp);
 }
diff --git a/include/tbl/steps.h b/include/tbl/steps.h
index 703c418..cef939b 100644
--- a/include/tbl/steps.h
+++ b/include/tbl/steps.h
@@ -29,18 +29,25 @@
  */
 
 /*lint -save -e525 -e539 */
-SESS_STEP(wait,		WAIT,		(sp, sp->wrk, sp->req))
-SESS_STEP(restart,	RESTART,	(wrk, req))
-SESS_STEP(recv,		RECV,		(wrk, req))
-SESS_STEP(start,	START,		(wrk, req))
-SESS_STEP(pipe,		PIPE,		(wrk, req))
-SESS_STEP(pass,		PASS,		(wrk, req))
-SESS_STEP(lookup,	LOOKUP,		(wrk, req))
-SESS_STEP(miss,		MISS,		(wrk, req))
-SESS_STEP(hit,		HIT,		(wrk, req))
-SESS_STEP(fetch,	FETCH,		(wrk, req))
-SESS_STEP(fetchbody,	FETCHBODY,	(wrk, req))
-SESS_STEP(prepresp,	PREPRESP,	(wrk, req))
-SESS_STEP(deliver,	DELIVER,	(wrk, req))
-SESS_STEP(error,	ERROR,		(wrk, req))
+
+#ifdef SESS_STEP
+SESS_STEP(newreq,	NEWREQ)
+SESS_STEP(working,	WORKING)
+#endif
+
+#ifdef REQ_STEP
+REQ_STEP(restart,	RESTART,	(wrk, req))
+REQ_STEP(recv,		RECV,		(wrk, req))
+REQ_STEP(start,		START,		(wrk, req))
+REQ_STEP(pipe,		PIPE,		(wrk, req))
+REQ_STEP(pass,		PASS,		(wrk, req))
+REQ_STEP(lookup,	LOOKUP,		(wrk, req))
+REQ_STEP(miss,		MISS,		(wrk, req))
+REQ_STEP(hit,		HIT,		(wrk, req))
+REQ_STEP(fetch,		FETCH,		(wrk, req))
+REQ_STEP(fetchbody,	FETCHBODY,	(wrk, req))
+REQ_STEP(prepresp,	PREPRESP,	(wrk, req))
+REQ_STEP(deliver,	DELIVER,	(wrk, req))
+REQ_STEP(error,		ERROR,		(wrk, req))
+#endif
 /*lint -restore */



From martin at varnish-cache.org  Wed Jun 20 11:58:09 2012
From: martin at varnish-cache.org (Martin Blix Grydeland)
Date: Wed, 20 Jun 2012 13:58:09 +0200
Subject: [3.0] 8c821b7 Don't consider pass an error when doing streaming fetch.
Message-ID: <E1ShJY1-0003lr-S7@project.varnish-software.com>

commit 8c821b77b3ecda5ced37a35ab64bddd1b7f1caf2
Author: Martin Blix Grydeland <martin at varnish-software.com>
Date:   Wed Jun 20 13:56:57 2012 +0200

    Don't consider pass an error when doing streaming fetch.
    
    Patch by: tnt

diff --git a/bin/varnishd/cache_center.c b/bin/varnishd/cache_center.c
index 23183ed..ea0a961 100644
--- a/bin/varnishd/cache_center.c
+++ b/bin/varnishd/cache_center.c
@@ -930,13 +930,13 @@ cnt_streambody(struct sess *sp)
 	AZ(sp->vbc);
 	AN(sp->director);
 
-	if (!i && sp->obj->objcore != NULL) {
+	if (i)
+		sp->doclose = "Stream error";
+	else if (sp->obj->objcore != NULL) {
 		EXP_Insert(sp->obj);
 		AN(sp->obj->objcore);
 		AN(sp->obj->objcore->ban);
 		HSH_Unbusy(sp);
-	} else {
-		sp->doclose = "Stream error";
 	}
 	sp->wrk->acct_tmp.fetch++;
 	sp->director = NULL;
diff --git a/bin/varnishtest/tests/r01157.vtc b/bin/varnishtest/tests/r01157.vtc
new file mode 100644
index 0000000..9cecd9a
--- /dev/null
+++ b/bin/varnishtest/tests/r01157.vtc
@@ -0,0 +1,26 @@
+varnishtest "#1157 - Connection close on pass and do_stream"
+
+server s1 {
+	rxreq
+	txresp
+	expect req.url == "/"
+
+	rxreq
+	txresp
+	expect req.url == "/"
+} -start
+
+varnish v1 -vcl+backend {
+	sub vcl_recv { return (pass); }
+	sub vcl_fetch {	set beresp.do_stream = true; }
+} -start
+
+client c1 {
+	txreq -url /
+	rxresp
+	expect resp.status == 200
+
+	txreq -url /
+	rxresp
+	expect resp.status == 200
+} -run



From martin at varnish-cache.org  Wed Jun 20 12:51:58 2012
From: martin at varnish-cache.org (Martin Blix Grydeland)
Date: Wed, 20 Jun 2012 14:51:58 +0200
Subject: [master] c4d56d7 Add test case for v-c.org ticket #1157 (connection
	close on pass and do_stream)
Message-ID: <E1ShKO6-0000Ii-O2@project.varnish-software.com>

commit c4d56d7670512c41c54d3b66283f42c2230e6e20
Author: Martin Blix Grydeland <martin at varnish-software.com>
Date:   Wed Jun 20 14:49:44 2012 +0200

    Add test case for v-c.org ticket #1157 (connection close on pass and
    do_stream)
    
    Bug fix itself is not applicable to trunk, but has been pushed on 3.0.

diff --git a/bin/varnishtest/tests/r01157.vtc b/bin/varnishtest/tests/r01157.vtc
new file mode 100644
index 0000000..9cecd9a
--- /dev/null
+++ b/bin/varnishtest/tests/r01157.vtc
@@ -0,0 +1,26 @@
+varnishtest "#1157 - Connection close on pass and do_stream"
+
+server s1 {
+	rxreq
+	txresp
+	expect req.url == "/"
+
+	rxreq
+	txresp
+	expect req.url == "/"
+} -start
+
+varnish v1 -vcl+backend {
+	sub vcl_recv { return (pass); }
+	sub vcl_fetch {	set beresp.do_stream = true; }
+} -start
+
+client c1 {
+	txreq -url /
+	rxresp
+	expect resp.status == 200
+
+	txreq -url /
+	rxresp
+	expect resp.status == 200
+} -run



From phk at varnish-cache.org  Mon Jun 25 07:14:47 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Mon, 25 Jun 2012 09:14:47 +0200
Subject: [master] 78ad7c4 Continue the move towards multiple concurrent
	requests per session
Message-ID: <E1Sj3VX-00053d-8z@project.varnish-software.com>

commit 78ad7c4cae8493cffa5caa414e504ee1fe871e34
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Mon Jun 25 07:14:13 2012 +0000

    Continue the move towards multiple concurrent requests per session

diff --git a/bin/varnishd/cache/cache.h b/bin/varnishd/cache/cache.h
index ed8e9f9..3673823 100644
--- a/bin/varnishd/cache/cache.h
+++ b/bin/varnishd/cache/cache.h
@@ -743,7 +743,7 @@ void VBO_DerefBusyObj(struct worker *wrk, struct busyobj **busyobj);
 void VBO_Free(struct busyobj **vbo);
 
 /* cache_center.c [CNT] */
-int CNT_Request(struct req *);
+int CNT_Request(struct worker *, struct req *);
 void CNT_Session(struct sess *);
 void CNT_Init(void);
 
diff --git a/bin/varnishd/cache/cache_center.c b/bin/varnishd/cache/cache_center.c
index fff81b4..24e6e37 100644
--- a/bin/varnishd/cache/cache_center.c
+++ b/bin/varnishd/cache/cache_center.c
@@ -362,7 +362,7 @@ CNT_Session(struct sess *sp)
 		    sp->req->req_step == R_STP_START)));
 
 		if (sp->sess_step == S_STP_WORKING) {
-			done = CNT_Request(sp->req);
+			done = CNT_Request(sp->wrk, sp->req);
 			if (done == 2)
 				return;
 			assert(done == 1);
@@ -1572,43 +1572,23 @@ cnt_start(struct worker *wrk, struct req *req)
  */
 
 static void
-cnt_diag(struct sess *sp, const char *state)
+cnt_diag(struct req *req, const char *state)
 {
-	void *vcl;
-	void *obj;
 
-	if (sp->req == NULL) {
-		vcl = NULL;
-		obj = NULL;
-	} else {
-		vcl = sp->req->vcl;
-		obj = sp->req->obj;
-	}
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 
-	if (sp->req != NULL) {
-		VSLb(sp->req->vsl,  SLT_Debug,
-		    "vsl_id %u STP_%s sp %p obj %p vcl %p",
-		    sp->vsl_id, state, sp, obj, vcl);
-		VSL_Flush(sp->req->vsl, 0);
-	} else {
-		VSL(SLT_Debug, sp->vsl_id,
-		    "vsl_id %u STP_%s sp %p obj %p vcl %p",
-		    sp->vsl_id, state, sp, obj, vcl);
-	}
+	VSLb(req->vsl,  SLT_Debug, "vsl_id %u STP_%s sp %p obj %p vcl %p",
+	    req->sp->vsl_id, state, req->sp, req->obj, req->vcl);
+	VSL_Flush(req->vsl, 0);
 }
 
 int
-CNT_Request(struct req *req)
+CNT_Request(struct worker *wrk, struct req *req)
 {
 	int done;
-	struct worker *wrk;
-	struct sess *sp;
 
-	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
-	sp = req->sp;
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	wrk = sp->wrk;
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 
 	/*
 	 * Possible entrance states
@@ -1619,24 +1599,20 @@ CNT_Request(struct req *req)
 	    req->req_step == R_STP_RECV);
 
 	for (done = 0; !done; ) {
-		assert(sp->wrk == wrk);
 		/*
 		 * This is a good place to be paranoid about the various
 		 * pointers still pointing to the things we expect.
 		 */
-		CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 		CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
 		CHECK_OBJ_ORNULL(wrk->nobjhead, OBJHEAD_MAGIC);
 		WS_Assert(wrk->aws);
 		CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
-		AN(req->sp);
-		assert(req->sp == sp);
 
 		switch (req->req_step) {
 #define REQ_STEP(l,u,arg) \
 		    case R_STP_##u: \
 			if (cache_param->diag_bitmap & 0x01) \
-				cnt_diag(sp, #u); \
+				cnt_diag(req, #u); \
 			done = cnt_##l arg; \
 		        break;
 #include "tbl/steps.h"
@@ -1648,7 +1624,7 @@ CNT_Request(struct req *req)
 		CHECK_OBJ_ORNULL(wrk->nobjhead, OBJHEAD_MAGIC);
 	}
 	if (done == 1)
-		SES_Charge(sp);
+		SES_Charge(req->sp);
 
 	assert(WRW_IsReleased(wrk));
 	return (done);
diff --git a/bin/varnishd/cache/cache_esi_deliver.c b/bin/varnishd/cache/cache_esi_deliver.c
index 9075a77..7f06dd4 100644
--- a/bin/varnishd/cache/cache_esi_deliver.c
+++ b/bin/varnishd/cache/cache_esi_deliver.c
@@ -95,7 +95,7 @@ ved_include(struct req *req, const char *src, const char *host)
 	sxid = req->xid;
 	while (1) {
 		req->sp->wrk = wrk;
-		i = CNT_Request(req);
+		i = CNT_Request(wrk, req);
 		if (i == 1)
 			break;
 		assert(i == 2);



From phk at varnish-cache.org  Mon Jun 25 08:00:06 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Mon, 25 Jun 2012 10:00:06 +0200
Subject: [master] 09bf441 Mostly move sp->wrk to req->wrk
Message-ID: <E1Sj4DO-0002AP-Ju@project.varnish-software.com>

commit 09bf441ebdd412d0b77001343273699c2391e54f
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Mon Jun 25 07:59:54 2012 +0000

    Mostly move sp->wrk to req->wrk

diff --git a/bin/varnishd/cache/cache.h b/bin/varnishd/cache/cache.h
index 3673823..3a8559f 100644
--- a/bin/varnishd/cache/cache.h
+++ b/bin/varnishd/cache/cache.h
@@ -568,6 +568,7 @@ struct req {
 	uint8_t			hash_always_miss;
 
 	struct sess		*sp;
+	struct worker		*wrk;
 	enum req_step		req_step;
 	VTAILQ_ENTRY(req)	w_list;
 
@@ -744,7 +745,7 @@ void VBO_Free(struct busyobj **vbo);
 
 /* cache_center.c [CNT] */
 int CNT_Request(struct worker *, struct req *);
-void CNT_Session(struct sess *);
+void CNT_Session(struct worker *, struct sess *);
 void CNT_Init(void);
 
 /* cache_cli.c [CLI] */
diff --git a/bin/varnishd/cache/cache_center.c b/bin/varnishd/cache/cache_center.c
index 24e6e37..1eb397e 100644
--- a/bin/varnishd/cache/cache_center.c
+++ b/bin/varnishd/cache/cache_center.c
@@ -323,15 +323,13 @@ cnt_sess_done(struct sess *sp, struct worker *wrk, struct req *req)
  */
 
 void
-CNT_Session(struct sess *sp)
+CNT_Session(struct worker *wrk, struct sess *sp)
 {
 	int done;
 	enum cnt_sess_done_ret sdr;
-	struct worker *wrk;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	wrk = sp->wrk;
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
+	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 
 	/*
 	 * Whenever we come in from the acceptor or waiter, we need to set
@@ -363,8 +361,10 @@ CNT_Session(struct sess *sp)
 
 		if (sp->sess_step == S_STP_WORKING) {
 			done = CNT_Request(sp->wrk, sp->req);
-			if (done == 2)
+			if (done == 2) {
+				sp->wrk = NULL;
 				return;
+			}
 			assert(done == 1);
 			sdr = cnt_sess_done(sp, wrk, sp->req);
 			switch (sdr) {
@@ -1598,6 +1598,8 @@ CNT_Request(struct worker *wrk, struct req *req)
 	    req->req_step == R_STP_START ||
 	    req->req_step == R_STP_RECV);
 
+	req->wrk = wrk;
+
 	for (done = 0; !done; ) {
 		/*
 		 * This is a good place to be paranoid about the various
@@ -1626,6 +1628,8 @@ CNT_Request(struct worker *wrk, struct req *req)
 	if (done == 1)
 		SES_Charge(req->sp);
 
+	req->wrk = NULL;
+
 	assert(WRW_IsReleased(wrk));
 	return (done);
 }
diff --git a/bin/varnishd/cache/cache_esi_deliver.c b/bin/varnishd/cache/cache_esi_deliver.c
index 7f06dd4..7e4305e 100644
--- a/bin/varnishd/cache/cache_esi_deliver.c
+++ b/bin/varnishd/cache/cache_esi_deliver.c
@@ -51,7 +51,7 @@ ved_include(struct req *req, const char *src, const char *host)
 	unsigned sxid, res_mode;
 	int i;
 
-	wrk = req->sp->wrk;
+	wrk = req->wrk;
 
 	if (req->esi_level >= cache_param->max_esi_depth)
 		return;
@@ -94,17 +94,17 @@ ved_include(struct req *req, const char *src, const char *host)
 
 	sxid = req->xid;
 	while (1) {
-		req->sp->wrk = wrk;
+		req->wrk = wrk;
 		i = CNT_Request(wrk, req);
 		if (i == 1)
 			break;
 		assert(i == 2);
-		AZ(req->sp->wrk);
+		AZ(req->wrk);
 		DSL(0x20, SLT_Debug, req->sp->vsl_id, "loop waiting for ESI");
 		(void)usleep(10000);
 	}
 	req->xid = sxid;
-	AN(req->sp->wrk);
+	req->wrk = wrk;
 	req->esi_level--;
 	req->obj = obj;
 	req->res_mode = res_mode;
@@ -113,9 +113,9 @@ ved_include(struct req *req, const char *src, const char *host)
 	WS_Reset(req->ws, sp_ws_wm);
 	WS_Reset(wrk->aws, wrk_ws_wm);	/* XXX ? */
 
-	WRW_Reserve(req->sp->wrk, &req->sp->fd, req->vsl, req->t_resp);
+	WRW_Reserve(req->wrk, &req->sp->fd, req->vsl, req->t_resp);
 	if (req->res_mode & RES_CHUNKED)
-		WRW_Chunked(req->sp->wrk);
+		WRW_Chunked(req->wrk);
 }
 
 /*--------------------------------------------------------------------*/
@@ -185,22 +185,22 @@ ved_pretend_gzip(struct req *req, const uint8_t *p, ssize_t l)
 	while (l > 0) {
 		if (l >= 65535) {
 			lx = 65535;
-			(void)WRW_Write(req->sp->wrk, buf1, sizeof buf1);
+			(void)WRW_Write(req->wrk, buf1, sizeof buf1);
 		} else {
 			lx = (uint16_t)l;
 			buf2[0] = 0;
 			vle16enc(buf2 + 1, lx);
 			vle16enc(buf2 + 3, ~lx);
-			(void)WRW_Write(req->sp->wrk, buf2, sizeof buf2);
+			(void)WRW_Write(req->wrk, buf2, sizeof buf2);
 		}
-		(void)WRW_Write(req->sp->wrk, p, lx);
+		(void)WRW_Write(req->wrk, p, lx);
 		req->crc = crc32(req->crc, p, lx);
 		req->l_crc += lx;
 		l -= lx;
 		p += lx;
 	}
 	/* buf2 is local, have to flush */
-	(void)WRW_Flush(req->sp->wrk);
+	(void)WRW_Flush(req->wrk);
 }
 
 /*---------------------------------------------------------------------
@@ -250,7 +250,7 @@ ESI_Deliver(struct req *req)
 		if (isgzip && !(req->res_mode & RES_GUNZIP)) {
 			assert(sizeof gzip_hdr == 10);
 			/* Send out the gzip header */
-			(void)WRW_Write(req->sp->wrk, gzip_hdr, 10);
+			(void)WRW_Write(req->wrk, gzip_hdr, 10);
 			req->l_crc = 0;
 			req->gzip_resp = 1;
 			req->crc = crc32(0L, Z_NULL, 0);
@@ -306,7 +306,7 @@ ESI_Deliver(struct req *req)
 					 * We have a gzip'ed VEC and delivers
 					 * a gzip'ed ESI response.
 					 */
-					(void)WRW_Write(req->sp->wrk,
+					(void)WRW_Write(req->wrk,
 					    st->ptr + off, l2);
 				} else if (req->gzip_resp) {
 					/*
@@ -321,9 +321,9 @@ ESI_Deliver(struct req *req)
 					 * response
 					 */
 					AN(vgz);
-					i = VGZ_WrwGunzip(req->sp->wrk, vgz,
+					i = VGZ_WrwGunzip(req->wrk, vgz,
 						st->ptr + off, l2);
-					if (WRW_Error(req->sp->wrk)) {
+					if (WRW_Error(req->wrk)) {
 						SES_Close(req->sp,
 						    "remote closed");
 						p = e;
@@ -334,7 +334,7 @@ ESI_Deliver(struct req *req)
 					/*
 					 * Ungzip'ed VEC, ungzip'ed ESI response
 					 */
-					(void)WRW_Write(req->sp->wrk,
+					(void)WRW_Write(req->wrk,
 					    st->ptr + off, l2);
 				}
 				off += l2;
@@ -374,8 +374,8 @@ ESI_Deliver(struct req *req)
 			r = (void*)strchr((const char*)q, '\0');
 			AN(r);
 			if (vgz != NULL)
-				VGZ_WrwFlush(req->sp->wrk, vgz);
-			if (WRW_Flush(req->sp->wrk)) {
+				VGZ_WrwFlush(req->wrk, vgz);
+			if (WRW_Flush(req->wrk)) {
 				SES_Close(req->sp, "remote closed");
 				p = e;
 				break;
@@ -391,7 +391,7 @@ ESI_Deliver(struct req *req)
 		}
 	}
 	if (vgz != NULL) {
-		VGZ_WrwFlush(req->sp->wrk, vgz);
+		VGZ_WrwFlush(req->wrk, vgz);
 		(void)VGZ_Destroy(&vgz);
 	}
 	if (req->gzip_resp && req->esi_level == 0) {
@@ -408,9 +408,9 @@ ESI_Deliver(struct req *req)
 		/* MOD(2^32) length */
 		vle32enc(tailbuf + 9, req->l_crc);
 
-		(void)WRW_Write(req->sp->wrk, tailbuf, 13);
+		(void)WRW_Write(req->wrk, tailbuf, 13);
 	}
-	(void)WRW_Flush(req->sp->wrk);
+	(void)WRW_Flush(req->wrk);
 }
 
 /*---------------------------------------------------------------------
@@ -444,7 +444,7 @@ ved_deliver_byterange(const struct req *req, ssize_t low, ssize_t high)
 			l = high - lx;
 		assert(lx >= low && lx + l <= high);
 		if (l != 0)
-			(void)WRW_Write(req->sp->wrk, p, l);
+			(void)WRW_Write(req->wrk, p, l);
 		if (p + l < st->ptr + st->len)
 			return(p[l]);
 		lx += l;
@@ -499,7 +499,7 @@ ESI_DeliverChild(struct req *req)
 	 */
 	*dbits = ved_deliver_byterange(req, start/8, last/8);
 	*dbits &= ~(1U << (last & 7));
-	(void)WRW_Write(req->sp->wrk, dbits, 1);
+	(void)WRW_Write(req->wrk, dbits, 1);
 	cc = ved_deliver_byterange(req, 1 + last/8, stop/8);
 	switch((int)(stop & 7)) {
 	case 0: /* xxxxxxxx */
@@ -543,7 +543,7 @@ ESI_DeliverChild(struct req *req)
 		INCOMPL();
 	}
 	if (lpad > 0)
-		(void)WRW_Write(req->sp->wrk, dbits + 1, lpad);
+		(void)WRW_Write(req->wrk, dbits + 1, lpad);
 
 	/* We need the entire tail, but it may not be in one storage segment */
 	st = VTAILQ_LAST(&req->obj->store, storagehead);
diff --git a/bin/varnishd/cache/cache_fetch.c b/bin/varnishd/cache/cache_fetch.c
index 0e2fa5f..ab2aabc 100644
--- a/bin/varnishd/cache/cache_fetch.c
+++ b/bin/varnishd/cache/cache_fetch.c
@@ -406,8 +406,8 @@ FetchReqBody(struct req *req, int sendbody)
 			content_length -= rdcnt;
 			if (sendbody) {
 				/* XXX: stats ? */
-				(void)WRW_Write(req->sp->wrk, buf, rdcnt);
-				if (WRW_Flush(req->sp->wrk))
+				(void)WRW_Write(req->wrk, buf, rdcnt);
+				if (WRW_Flush(req->wrk))
 					return (2);
 			}
 		}
@@ -441,7 +441,7 @@ FetchHdr(struct req *req, int need_host_hdr, int sendbody)
 	int i;
 	struct http_conn *htc;
 
-	wrk = req->sp->wrk;
+	wrk = req->wrk;
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	bo = req->busyobj;
diff --git a/bin/varnishd/cache/cache_hash.c b/bin/varnishd/cache/cache_hash.c
index e7c2a49..c6f56e3 100644
--- a/bin/varnishd/cache/cache_hash.c
+++ b/bin/varnishd/cache/cache_hash.c
@@ -299,7 +299,7 @@ HSH_Lookup(struct req *req)
 	int busy_found;
 
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
-	wrk = req->sp->wrk;
+	wrk = req->wrk;
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
 	CHECK_OBJ_NOTNULL(req->http, HTTP_MAGIC);
 	AN(req->director);
@@ -431,7 +431,6 @@ HSH_Lookup(struct req *req)
 		 * calls us again
 		 */
 		req->hash_objhead = oh;
-		req->sp->wrk = NULL;
 		Lck_Unlock(&oh->mtx);
 		return (NULL);
 	}
@@ -482,9 +481,9 @@ hsh_rush(struct dstat *ds, struct objhead *oh)
 		if (req == NULL)
 			break;
 		CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+		AZ(req->wrk);
 		sp = req->sp;
 		CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-		AZ(sp->wrk);
 		VTAILQ_REMOVE(&wl->list, req, w_list);
 		DSL(0x20, SLT_Debug, sp->vsl_id, "off waiting list");
 		if (SES_Schedule(sp)) {
@@ -533,7 +532,7 @@ HSH_Purge(struct req *req, struct objhead *oh, double ttl, double grace)
 			continue;
 		}
 
-		(void)oc_getobj(&req->sp->wrk->stats, oc);
+		(void)oc_getobj(&req->wrk->stats, oc);
 		    /* XXX: still needed ? */
 
 		xxxassert(spc >= sizeof *ocp);
@@ -551,14 +550,14 @@ HSH_Purge(struct req *req, struct objhead *oh, double ttl, double grace)
 	for (n = 0; n < nobj; n++) {
 		oc = ocp[n];
 		CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
-		o = oc_getobj(&req->sp->wrk->stats, oc);
+		o = oc_getobj(&req->wrk->stats, oc);
 		if (o == NULL)
 			continue;
 		CHECK_OBJ_NOTNULL(o, OBJECT_MAGIC);
 		o->exp.ttl = ttl;
 		o->exp.grace = grace;
 		EXP_Rearm(o);
-		(void)HSH_Deref(&req->sp->wrk->stats, NULL, &o);
+		(void)HSH_Deref(&req->wrk->stats, NULL, &o);
 	}
 	WS_Release(req->ws, 0);
 }
diff --git a/bin/varnishd/cache/cache_panic.c b/bin/varnishd/cache/cache_panic.c
index c4511e8..411b8e9 100644
--- a/bin/varnishd/cache/cache_panic.c
+++ b/bin/varnishd/cache/cache_panic.c
@@ -261,8 +261,8 @@ pan_req(const struct req *req)
 	VSB_printf(pan_vsp, "  restarts = %d, esi_level = %d\n",
 	    req->restarts, req->esi_level);
 
-	if (req->busyobj != NULL)
-		pan_busyobj(req->busyobj);
+	if (req->wrk != NULL)
+		pan_wrk(req->wrk);
 
 	pan_ws(req->ws, 2);
 	pan_http("req", req->http, 2);
@@ -272,6 +272,9 @@ pan_req(const struct req *req)
 	if (VALID_OBJ(req->vcl, VCL_CONF_MAGIC))
 		pan_vcl(req->vcl);
 
+	if (req->busyobj != NULL)
+		pan_busyobj(req->busyobj);
+
 	if (VALID_OBJ(req->obj, OBJECT_MAGIC))
 		pan_object(req->obj);
 
@@ -302,9 +305,6 @@ pan_sess(const struct sess *sp)
 	else
 		VSB_printf(pan_vsp, "  step = 0x%x,\n", sp->sess_step);
 
-	if (sp->wrk != NULL)
-		pan_wrk(sp->wrk);
-
 	VSB_printf(pan_vsp, "},\n");
 }
 
diff --git a/bin/varnishd/cache/cache_pipe.c b/bin/varnishd/cache/cache_pipe.c
index 13a8c10..8fa9e3c 100644
--- a/bin/varnishd/cache/cache_pipe.c
+++ b/bin/varnishd/cache/cache_pipe.c
@@ -70,7 +70,7 @@ PipeRequest(struct req *req)
 
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	CHECK_OBJ_NOTNULL(req->sp, SESS_MAGIC);
-	wrk = req->sp->wrk;
+	wrk = req->wrk;
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
 	bo = req->busyobj;
 	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
diff --git a/bin/varnishd/cache/cache_response.c b/bin/varnishd/cache/cache_response.c
index 85c8233..cdad653 100644
--- a/bin/varnishd/cache/cache_response.c
+++ b/bin/varnishd/cache/cache_response.c
@@ -171,11 +171,11 @@ res_WriteGunzipObj(struct req *req)
 		CHECK_OBJ_NOTNULL(st, STORAGE_MAGIC);
 		u += st->len;
 
-		i = VGZ_WrwGunzip(req->sp->wrk, vg, st->ptr, st->len);
+		i = VGZ_WrwGunzip(req->wrk, vg, st->ptr, st->len);
 		/* XXX: error check */
 		(void)i;
 	}
-	VGZ_WrwFlush(req->sp->wrk, vg);
+	VGZ_WrwFlush(req->wrk, vg);
 	(void)VGZ_Destroy(&vg);
 	assert(u == req->obj->len);
 }
@@ -215,8 +215,8 @@ res_WriteDirObj(const struct req *req, ssize_t low, ssize_t high)
 
 		ptr += len;
 
-		req->sp->wrk->acct_tmp.bodybytes += len;
-		(void)WRW_Write(req->sp->wrk, st->ptr + off, len);
+		req->wrk->acct_tmp.bodybytes += len;
+		(void)WRW_Write(req->wrk, st->ptr + off, len);
 	}
 	assert(u == req->obj->len);
 }
@@ -248,20 +248,20 @@ RES_WriteObj(struct req *req)
 	    http_GetHdr(req->http, H_Range, &r))
 		res_dorange(req, r, &low, &high);
 
-	WRW_Reserve(req->sp->wrk, &req->sp->fd, req->vsl, req->t_resp);
+	WRW_Reserve(req->wrk, &req->sp->fd, req->vsl, req->t_resp);
 
 	/*
 	 * Send HTTP protocol header, unless interior ESI object
 	 */
 	if (!(req->res_mode & RES_ESI_CHILD))
-		req->sp->wrk->acct_tmp.hdrbytes +=
-		    http_Write(req->sp->wrk, req->resp, 1);
+		req->wrk->acct_tmp.hdrbytes +=
+		    http_Write(req->wrk, req->resp, 1);
 
 	if (!req->wantbody)
 		req->res_mode &= ~RES_CHUNKED;
 
 	if (req->res_mode & RES_CHUNKED)
-		WRW_Chunked(req->sp->wrk);
+		WRW_Chunked(req->wrk);
 
 	if (!req->wantbody) {
 		/* This was a HEAD or conditional request */
@@ -282,8 +282,8 @@ RES_WriteObj(struct req *req)
 
 	if (req->res_mode & RES_CHUNKED &&
 	    !(req->res_mode & RES_ESI_CHILD))
-		WRW_EndChunk(req->sp->wrk);
+		WRW_EndChunk(req->wrk);
 
-	if (WRW_FlushRelease(req->sp->wrk) && req->sp->fd >= 0)
+	if (WRW_FlushRelease(req->wrk) && req->sp->fd >= 0)
 		SES_Close(req->sp, "remote closed");
 }
diff --git a/bin/varnishd/cache/cache_session.c b/bin/varnishd/cache/cache_session.c
index aee58b0..01b0b18 100644
--- a/bin/varnishd/cache/cache_session.c
+++ b/bin/varnishd/cache/cache_session.c
@@ -128,7 +128,7 @@ ses_pool_task(struct worker *wrk, void *arg)
 	THR_SetSession(sp);
 	AZ(sp->wrk);
 	sp->wrk = wrk;
-	CNT_Session(sp);
+	CNT_Session(wrk, sp);
 	sp = NULL;			/* Cannot access sp any longer */
 	THR_SetSession(NULL);
 	WS_Assert(wrk->aws);



From phk at varnish-cache.org  Mon Jun 25 08:13:09 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Mon, 25 Jun 2012 10:13:09 +0200
Subject: [master] 6dfad3d Totally eliminate sp->wrk
Message-ID: <E1Sj4Q1-0003fc-6x@project.varnish-software.com>

commit 6dfad3d42c9c919d9a82cd5065880e48215e646d
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Mon Jun 25 08:13:01 2012 +0000

    Totally eliminate sp->wrk

diff --git a/bin/varnishd/cache/cache.h b/bin/varnishd/cache/cache.h
index 3a8559f..8499a12 100644
--- a/bin/varnishd/cache/cache.h
+++ b/bin/varnishd/cache/cache.h
@@ -660,7 +660,6 @@ struct sess {
 	/* Cross references ------------------------------------------*/
 
 	struct sesspool		*sesspool;
-	struct worker		*wrk;
 	struct req		*req;
 
 	struct pool_task	task;
@@ -926,7 +925,7 @@ unsigned WRW_WriteH(const struct worker *w, const txt *hh, const char *suf);
 /* cache_session.c [SES] */
 void SES_Close(struct sess *sp, const char *reason);
 void SES_Delete(struct sess *sp, const char *reason, double now);
-void SES_Charge(struct sess *sp);
+void SES_Charge(struct worker *, struct sess *);
 struct sesspool *SES_NewPool(struct pool *pp, unsigned pool_no);
 void SES_DeletePool(struct sesspool *sp);
 int SES_Schedule(struct sess *sp);
diff --git a/bin/varnishd/cache/cache_center.c b/bin/varnishd/cache/cache_center.c
index 1eb397e..bd28916 100644
--- a/bin/varnishd/cache/cache_center.c
+++ b/bin/varnishd/cache/cache_center.c
@@ -191,7 +191,7 @@ cnt_wait(struct sess *sp, struct worker *wrk, struct req *req)
 			if (when < now || tmo == 0) {
 				sp->t_rx = NAN;
 				wrk->stats.sess_herd++;
-				SES_Charge(sp);
+				SES_Charge(wrk, sp);
 				SES_ReleaseReq(sp);
 				WAIT_Enter(sp);
 				return (1);
@@ -206,7 +206,7 @@ cnt_wait(struct sess *sp, struct worker *wrk, struct req *req)
 			}
 		}
 	}
-	SES_Charge(sp);
+	SES_Charge(wrk, sp);
 	SES_Delete(sp, why, now);
 	return (1);
 }
@@ -360,11 +360,9 @@ CNT_Session(struct worker *wrk, struct sess *sp)
 		    sp->req->req_step == R_STP_START)));
 
 		if (sp->sess_step == S_STP_WORKING) {
-			done = CNT_Request(sp->wrk, sp->req);
-			if (done == 2) {
-				sp->wrk = NULL;
+			done = CNT_Request(wrk, sp->req);
+			if (done == 2)
 				return;
-			}
 			assert(done == 1);
 			sdr = cnt_sess_done(sp, wrk, sp->req);
 			switch (sdr) {
@@ -1626,7 +1624,7 @@ CNT_Request(struct worker *wrk, struct req *req)
 		CHECK_OBJ_ORNULL(wrk->nobjhead, OBJHEAD_MAGIC);
 	}
 	if (done == 1)
-		SES_Charge(req->sp);
+		SES_Charge(wrk, req->sp);
 
 	req->wrk = NULL;
 
diff --git a/bin/varnishd/cache/cache_hash.c b/bin/varnishd/cache/cache_hash.c
index c6f56e3..d3976d8 100644
--- a/bin/varnishd/cache/cache_hash.c
+++ b/bin/varnishd/cache/cache_hash.c
@@ -424,7 +424,7 @@ HSH_Lookup(struct req *req)
 		if (cache_param->diag_bitmap & 0x20)
 			VSLb(req->vsl, SLT_Debug,
 				"on waiting list <%p>", oh);
-		SES_Charge(req->sp);
+		SES_Charge(req->wrk, req->sp);
 		/*
 		 * The objhead reference transfers to the sess, we get it
 		 * back when the sess comes off the waiting list and
diff --git a/bin/varnishd/cache/cache_session.c b/bin/varnishd/cache/cache_session.c
index 01b0b18..57ad270 100644
--- a/bin/varnishd/cache/cache_session.c
+++ b/bin/varnishd/cache/cache_session.c
@@ -61,15 +61,19 @@ struct sesspool {
  */
 
 void
-SES_Charge(struct sess *sp)
+SES_Charge(struct worker *wrk, struct sess *sp)
 {
-	struct acct *a = &sp->wrk->acct_tmp;
+	struct acct *a;
 
+	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
 	CHECK_OBJ_NOTNULL(sp->req, REQ_MAGIC);
+
+	a = &wrk->acct_tmp;
 	sp->req->req_bodybytes += a->bodybytes;
 
 #define ACCT(foo)				\
-	sp->wrk->stats.s_##foo += a->foo;	\
+	wrk->stats.s_##foo += a->foo;		\
 	sp->acct_ses.foo += a->foo;		\
 	a->foo = 0;
 #include "tbl/acct_fields.h"
@@ -126,8 +130,6 @@ ses_pool_task(struct worker *wrk, void *arg)
 	AZ(wrk->aws->r);
 	wrk->lastused = NAN;
 	THR_SetSession(sp);
-	AZ(sp->wrk);
-	sp->wrk = wrk;
 	CNT_Session(wrk, sp);
 	sp = NULL;			/* Cannot access sp any longer */
 	THR_SetSession(NULL);
@@ -174,12 +176,10 @@ SES_Schedule(struct sess *sp)
 	struct sesspool *pp;
 
 	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	AZ(sp->wrk);
 	pp = sp->sesspool;
 	CHECK_OBJ_NOTNULL(pp, SESSPOOL_MAGIC);
 	AN(pp->pool);
 
-	AZ(sp->wrk);
 	sp->task.func = ses_pool_task;
 	sp->task.priv = sp;
 
@@ -243,7 +243,6 @@ void
 SES_Delete(struct sess *sp, const char *reason, double now)
 {
 	struct acct *b;
-	struct worker *wrk;
 	struct sesspool *pp;
 
 	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
@@ -251,9 +250,6 @@ SES_Delete(struct sess *sp, const char *reason, double now)
 	CHECK_OBJ_NOTNULL(pp, SESSPOOL_MAGIC);
 	AN(pp->pool);
 
-	wrk = sp->wrk;
-	CHECK_OBJ_ORNULL(wrk, WORKER_MAGIC);
-
 	if (reason != NULL)
 		SES_Close(sp, reason);
 	if (isnan(now))
diff --git a/bin/varnishd/waiter/cache_waiter.c b/bin/varnishd/waiter/cache_waiter.c
index b0f461a..3816a26 100644
--- a/bin/varnishd/waiter/cache_waiter.c
+++ b/bin/varnishd/waiter/cache_waiter.c
@@ -67,10 +67,8 @@ WAIT_Enter(struct sess *sp)
 {
 
 	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	CHECK_OBJ_NOTNULL(sp->wrk, WORKER_MAGIC);
 	AZ(sp->req);
 	assert(sp->fd >= 0);
-	sp->wrk = NULL;
 
 	/*
 	* Set nonblocking in the worker-thread, before passing to the



From phk at varnish-cache.org  Mon Jun 25 08:35:11 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Mon, 25 Jun 2012 10:35:11 +0200
Subject: [master] 94d7a68 Make SES_Charge() and SES_ReleaseReq() take struct
	req* argument instead of struct sess*
Message-ID: <E1Sj4lL-0005j6-DD@project.varnish-software.com>

commit 94d7a686b0e553be881d378b6e5f4060123b56d4
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Mon Jun 25 08:34:37 2012 +0000

    Make SES_Charge() and SES_ReleaseReq() take struct req* argument
    instead of struct sess*

diff --git a/bin/varnishd/cache/cache.h b/bin/varnishd/cache/cache.h
index 8499a12..436bd20 100644
--- a/bin/varnishd/cache/cache.h
+++ b/bin/varnishd/cache/cache.h
@@ -925,13 +925,13 @@ unsigned WRW_WriteH(const struct worker *w, const txt *hh, const char *suf);
 /* cache_session.c [SES] */
 void SES_Close(struct sess *sp, const char *reason);
 void SES_Delete(struct sess *sp, const char *reason, double now);
-void SES_Charge(struct worker *, struct sess *);
+void SES_Charge(struct worker *, struct req *);
 struct sesspool *SES_NewPool(struct pool *pp, unsigned pool_no);
 void SES_DeletePool(struct sesspool *sp);
 int SES_Schedule(struct sess *sp);
 void SES_Handle(struct sess *sp, double now);
 struct req *SES_GetReq(struct sess *sp);
-void SES_ReleaseReq(struct sess *sp);
+void SES_ReleaseReq(struct req *);
 pool_func_t SES_pool_accept_task;
 
 /* cache_shmlog.c */
diff --git a/bin/varnishd/cache/cache_center.c b/bin/varnishd/cache/cache_center.c
index bd28916..5ea1f48 100644
--- a/bin/varnishd/cache/cache_center.c
+++ b/bin/varnishd/cache/cache_center.c
@@ -191,8 +191,8 @@ cnt_wait(struct sess *sp, struct worker *wrk, struct req *req)
 			if (when < now || tmo == 0) {
 				sp->t_rx = NAN;
 				wrk->stats.sess_herd++;
-				SES_Charge(wrk, sp);
-				SES_ReleaseReq(sp);
+				SES_Charge(wrk, req);
+				SES_ReleaseReq(req);
 				WAIT_Enter(sp);
 				return (1);
 			}
@@ -206,7 +206,7 @@ cnt_wait(struct sess *sp, struct worker *wrk, struct req *req)
 			}
 		}
 	}
-	SES_Charge(wrk, sp);
+	SES_Charge(wrk, req);
 	SES_Delete(sp, why, now);
 	return (1);
 }
@@ -1624,7 +1624,7 @@ CNT_Request(struct worker *wrk, struct req *req)
 		CHECK_OBJ_ORNULL(wrk->nobjhead, OBJHEAD_MAGIC);
 	}
 	if (done == 1)
-		SES_Charge(wrk, req->sp);
+		SES_Charge(wrk, req);
 
 	req->wrk = NULL;
 
diff --git a/bin/varnishd/cache/cache_hash.c b/bin/varnishd/cache/cache_hash.c
index d3976d8..a2710dd 100644
--- a/bin/varnishd/cache/cache_hash.c
+++ b/bin/varnishd/cache/cache_hash.c
@@ -424,7 +424,7 @@ HSH_Lookup(struct req *req)
 		if (cache_param->diag_bitmap & 0x20)
 			VSLb(req->vsl, SLT_Debug,
 				"on waiting list <%p>", oh);
-		SES_Charge(req->wrk, req->sp);
+		SES_Charge(req->wrk, req);
 		/*
 		 * The objhead reference transfers to the sess, we get it
 		 * back when the sess comes off the waiting list and
diff --git a/bin/varnishd/cache/cache_session.c b/bin/varnishd/cache/cache_session.c
index 57ad270..49bd3bb 100644
--- a/bin/varnishd/cache/cache_session.c
+++ b/bin/varnishd/cache/cache_session.c
@@ -61,16 +61,18 @@ struct sesspool {
  */
 
 void
-SES_Charge(struct worker *wrk, struct sess *sp)
+SES_Charge(struct worker *wrk, struct req *req)
 {
+	struct sess *sp;
 	struct acct *a;
 
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
-	CHECK_OBJ_NOTNULL(sp->req, REQ_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	sp = req->sp;
+	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 
 	a = &wrk->acct_tmp;
-	sp->req->req_bodybytes += a->bodybytes;
+	req->req_bodybytes += a->bodybytes;
 
 #define ACCT(foo)				\
 	wrk->stats.s_##foo += a->foo;		\
@@ -259,7 +261,7 @@ SES_Delete(struct sess *sp, const char *reason, double now)
 
 	if (sp->req != NULL) {
 		AZ(sp->req->vcl);
-		SES_ReleaseReq(sp);
+		SES_ReleaseReq(sp->req);
 	}
 
 	if (*sp->addr == '\0')
@@ -346,21 +348,23 @@ SES_GetReq(struct sess *sp)
 }
 
 void
-SES_ReleaseReq(struct sess *sp)
+SES_ReleaseReq(struct req *req)
 {
+	struct sess *sp;
 	struct sesspool *pp;
 
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	sp = req->sp;
 	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	assert(sp->req == req);
 	pp = sp->sesspool;
 	CHECK_OBJ_NOTNULL(pp, SESSPOOL_MAGIC);
 	AN(pp->pool);
-	CHECK_OBJ_NOTNULL(sp->req, REQ_MAGIC);
-	AN(sp->req->sp);
-	assert(sp->req->sp == sp);
-	MPL_AssertSane(sp->req);
-	VSL_Flush(sp->req->vsl, 0);
-	sp->req->sp = NULL;
-	MPL_Free(pp->mpl_req, sp->req);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	MPL_AssertSane(req);
+	VSL_Flush(req->vsl, 0);
+	req->sp = NULL;
+	MPL_Free(pp->mpl_req, req);
 	sp->req = NULL;
 	THR_SetRequest(NULL);
 }



From phk at varnish-cache.org  Mon Jun 25 08:49:34 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Mon, 25 Jun 2012 10:49:34 +0200
Subject: [master] 87f32cb Always release req before calling SES_Delete()
Message-ID: <E1Sj4zG-0006uT-Ah@project.varnish-software.com>

commit 87f32cb739e7cb89babfae5f5943719aa3b1fed4
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Mon Jun 25 08:48:04 2012 +0000

    Always release req before calling SES_Delete()
    
    Split SES_Handle() and SES_ScheduleReq().

diff --git a/bin/varnishd/cache/cache.h b/bin/varnishd/cache/cache.h
index 436bd20..646ee9d 100644
--- a/bin/varnishd/cache/cache.h
+++ b/bin/varnishd/cache/cache.h
@@ -928,7 +928,7 @@ void SES_Delete(struct sess *sp, const char *reason, double now);
 void SES_Charge(struct worker *, struct req *);
 struct sesspool *SES_NewPool(struct pool *pp, unsigned pool_no);
 void SES_DeletePool(struct sesspool *sp);
-int SES_Schedule(struct sess *sp);
+int SES_ScheduleReq(struct req *);
 void SES_Handle(struct sess *sp, double now);
 struct req *SES_GetReq(struct sess *sp);
 void SES_ReleaseReq(struct req *);
diff --git a/bin/varnishd/cache/cache_center.c b/bin/varnishd/cache/cache_center.c
index 5ea1f48..88eef23 100644
--- a/bin/varnishd/cache/cache_center.c
+++ b/bin/varnishd/cache/cache_center.c
@@ -207,6 +207,8 @@ cnt_wait(struct sess *sp, struct worker *wrk, struct req *req)
 		}
 	}
 	SES_Charge(wrk, req);
+	AZ(req->vcl);
+	SES_ReleaseReq(req);
 	SES_Delete(sp, why, now);
 	return (1);
 }
@@ -295,6 +297,8 @@ cnt_sess_done(struct sess *sp, struct worker *wrk, struct req *req)
 
 	if (sp->fd < 0) {
 		wrk->stats.sess_closed++;
+		AZ(req->vcl);
+		SES_ReleaseReq(req);
 		SES_Delete(sp, NULL, NAN);
 		return (SESS_DONE_RET_GONE);
 	}
diff --git a/bin/varnishd/cache/cache_hash.c b/bin/varnishd/cache/cache_hash.c
index a2710dd..abcb4c0 100644
--- a/bin/varnishd/cache/cache_hash.c
+++ b/bin/varnishd/cache/cache_hash.c
@@ -469,7 +469,6 @@ hsh_rush(struct dstat *ds, struct objhead *oh)
 {
 	unsigned u;
 	struct req *req;
-	struct sess *sp;
 	struct waitinglist *wl;
 
 	CHECK_OBJ_NOTNULL(oh, OBJHEAD_MAGIC);
@@ -482,11 +481,9 @@ hsh_rush(struct dstat *ds, struct objhead *oh)
 			break;
 		CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 		AZ(req->wrk);
-		sp = req->sp;
-		CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 		VTAILQ_REMOVE(&wl->list, req, w_list);
-		DSL(0x20, SLT_Debug, sp->vsl_id, "off waiting list");
-		if (SES_Schedule(sp)) {
+		DSL(0x20, SLT_Debug, req->sp->vsl_id, "off waiting list");
+		if (SES_ScheduleReq(req)) {
 			/*
 			 * We could not schedule the session, leave the
 			 * rest on the busy list.
diff --git a/bin/varnishd/cache/cache_session.c b/bin/varnishd/cache/cache_session.c
index 49bd3bb..9bf3382 100644
--- a/bin/varnishd/cache/cache_session.c
+++ b/bin/varnishd/cache/cache_session.c
@@ -169,14 +169,17 @@ SES_pool_accept_task(struct worker *wrk, void *arg)
 }
 
 /*--------------------------------------------------------------------
- * Schedule a session back on a work-thread from its pool
+ * Schedule a request back on a work-thread from its sessions pool
  */
 
 int
-SES_Schedule(struct sess *sp)
+SES_ScheduleReq(struct req *req)
 {
+	struct sess *sp;
 	struct sesspool *pp;
 
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	sp = req->sp;
 	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 	pp = sp->sesspool;
 	CHECK_OBJ_NOTNULL(pp, SESSPOOL_MAGIC);
@@ -188,13 +191,8 @@ SES_Schedule(struct sess *sp)
 	if (Pool_Task(pp->pool, &sp->task, POOL_QUEUE_FRONT)) {
 		VSC_C_main->client_drop_late++;
 		sp->t_idle = VTIM_real();
-		if (sp->req != NULL && sp->req->vcl != NULL) {
-			/*
-			 * A session parked on a busy object can come here
-			 * after it wakes up.  Loose the VCL reference.
-			 */
-			VCL_Rel(&sp->req->vcl);
-		}
+		AN (req->vcl);
+		VCL_Rel(&req->vcl);
 		SES_Delete(sp, "dropped", sp->t_idle);
 		return (1);
 	}
@@ -208,10 +206,22 @@ SES_Schedule(struct sess *sp)
 void
 SES_Handle(struct sess *sp, double now)
 {
+	struct sesspool *pp;
 
+	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	pp = sp->sesspool;
+	CHECK_OBJ_NOTNULL(pp, SESSPOOL_MAGIC);
+	AN(pp->pool);
+	AZ(sp->req);
+	sp->task.func = ses_pool_task;
+	sp->task.priv = sp;
 	sp->sess_step = S_STP_NEWREQ;
 	sp->t_rx = now;
-	(void)SES_Schedule(sp);
+	if (Pool_Task(pp->pool, &sp->task, POOL_QUEUE_FRONT)) {
+		VSC_C_main->client_drop_late++;
+		sp->t_idle = VTIM_real();
+		SES_Delete(sp, "dropped", sp->t_idle);
+	}
 }
 
 /*--------------------------------------------------------------------
@@ -248,6 +258,7 @@ SES_Delete(struct sess *sp, const char *reason, double now)
 	struct sesspool *pp;
 
 	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	AZ(sp->req);
 	pp = sp->sesspool;
 	CHECK_OBJ_NOTNULL(pp, SESSPOOL_MAGIC);
 	AN(pp->pool);
@@ -259,11 +270,6 @@ SES_Delete(struct sess *sp, const char *reason, double now)
 	assert(!isnan(sp->t_open));
 	assert(sp->fd < 0);
 
-	if (sp->req != NULL) {
-		AZ(sp->req->vcl);
-		SES_ReleaseReq(sp->req);
-	}
-
 	if (*sp->addr == '\0')
 		strcpy(sp->addr, "-");
 	if (*sp->port == '\0')



From phk at varnish-cache.org  Mon Jun 25 09:03:43 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Mon, 25 Jun 2012 11:03:43 +0200
Subject: [master] 5894995 Always allocate a request before calling
	CNT_Session()
Message-ID: <E1Sj5Cx-0007oF-5d@project.varnish-software.com>

commit 5894995f139a4cf9b131978d83508450dbe836e4
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Mon Jun 25 09:03:12 2012 +0000

    Always allocate a request before calling CNT_Session()

diff --git a/bin/varnishd/cache/cache.h b/bin/varnishd/cache/cache.h
index 646ee9d..1d83dab 100644
--- a/bin/varnishd/cache/cache.h
+++ b/bin/varnishd/cache/cache.h
@@ -744,7 +744,7 @@ void VBO_Free(struct busyobj **vbo);
 
 /* cache_center.c [CNT] */
 int CNT_Request(struct worker *, struct req *);
-void CNT_Session(struct worker *, struct sess *);
+void CNT_Session(struct worker *, struct req *);
 void CNT_Init(void);
 
 /* cache_cli.c [CLI] */
diff --git a/bin/varnishd/cache/cache_center.c b/bin/varnishd/cache/cache_center.c
index 88eef23..5c76ac9 100644
--- a/bin/varnishd/cache/cache_center.c
+++ b/bin/varnishd/cache/cache_center.c
@@ -117,11 +117,8 @@ cnt_wait(struct sess *sp, struct worker *wrk, struct req *req)
 
 	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 
-	if (req == NULL) {
-		req = SES_GetReq(sp);
-		CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
-	}
 	assert(req->sp == sp);
 
 	if (!sp->init_done) {
@@ -327,13 +324,17 @@ cnt_sess_done(struct sess *sp, struct worker *wrk, struct req *req)
  */
 
 void
-CNT_Session(struct worker *wrk, struct sess *sp)
+CNT_Session(struct worker *wrk, struct req *req)
 {
 	int done;
+	struct sess *sp;
 	enum cnt_sess_done_ret sdr;
 
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	sp = req->sp;
 	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	assert(sp->req == req);
 
 	/*
 	 * Whenever we come in from the acceptor or waiter, we need to set
@@ -348,7 +349,7 @@ CNT_Session(struct worker *wrk, struct sess *sp)
 			SES_Close(sp, "remote closed");
 		else
 			SES_Close(sp, "error");
-		sdr = cnt_sess_done(sp, wrk, sp->req);
+		sdr = cnt_sess_done(sp, wrk, req);
 		assert(sdr == SESS_DONE_RET_GONE);
 		return;
 	}
@@ -357,18 +358,19 @@ CNT_Session(struct worker *wrk, struct sess *sp)
 		/*
 		 * Possible entrance states
 		 */
+		assert(sp->req == req);
+
 		assert(
 		    sp->sess_step == S_STP_NEWREQ ||
-		    (sp->req != NULL &&
-		    (sp->req->req_step == R_STP_LOOKUP ||
-		    sp->req->req_step == R_STP_START)));
+		    req->req_step == R_STP_LOOKUP ||
+		    req->req_step == R_STP_START);
 
 		if (sp->sess_step == S_STP_WORKING) {
-			done = CNT_Request(wrk, sp->req);
+			done = CNT_Request(wrk, req);
 			if (done == 2)
 				return;
 			assert(done == 1);
-			sdr = cnt_sess_done(sp, wrk, sp->req);
+			sdr = cnt_sess_done(sp, wrk, req);
 			switch (sdr) {
 			case SESS_DONE_RET_GONE:
 				return;
@@ -377,7 +379,7 @@ CNT_Session(struct worker *wrk, struct sess *sp)
 				break;
 			case SESS_DONE_RET_START:
 				sp->sess_step = S_STP_WORKING;
-				sp->req->req_step = R_STP_START;
+				req->req_step = R_STP_START;
 				break;
 			default:
 				WRONG("Illegal enum cnt_sess_done_ret");
@@ -385,12 +387,11 @@ CNT_Session(struct worker *wrk, struct sess *sp)
 		}
 
 		if (sp->sess_step == S_STP_NEWREQ) {
-			done = cnt_wait(sp, wrk, sp->req);
-			if (done) {
+			done = cnt_wait(sp, wrk, req);
+			if (done)
 				return;
-			}
 			sp->sess_step = S_STP_WORKING;
-			sp->req->req_step = R_STP_START;
+			req->req_step = R_STP_START;
 		}
 	}
 }
diff --git a/bin/varnishd/cache/cache_session.c b/bin/varnishd/cache/cache_session.c
index 9bf3382..2b384f6 100644
--- a/bin/varnishd/cache/cache_session.c
+++ b/bin/varnishd/cache/cache_session.c
@@ -124,16 +124,18 @@ ses_new(struct sesspool *pp)
 static void
 ses_pool_task(struct worker *wrk, void *arg)
 {
+	struct req *req;
 	struct sess *sp;
 
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
-	CAST_OBJ_NOTNULL(sp, arg, SESS_MAGIC);
+	CAST_OBJ_NOTNULL(req, arg, REQ_MAGIC);
+	sp = req->sp;
+	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 
 	AZ(wrk->aws->r);
 	wrk->lastused = NAN;
 	THR_SetSession(sp);
-	CNT_Session(wrk, sp);
-	sp = NULL;			/* Cannot access sp any longer */
+	CNT_Session(wrk, req);
 	THR_SetSession(NULL);
 	WS_Assert(wrk->aws);
 	AZ(wrk->wrw);
@@ -151,6 +153,7 @@ void
 SES_pool_accept_task(struct worker *wrk, void *arg)
 {
 	struct sesspool *pp;
+	struct req *req;
 	struct sess *sp;
 
 	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
@@ -161,11 +164,13 @@ SES_pool_accept_task(struct worker *wrk, void *arg)
 	sp = ses_new(pp);
 	if (sp == NULL) {
 		VCA_FailSess(wrk);
-	} else {
-		VCA_SetupSess(wrk, sp);
-		sp->sess_step = S_STP_NEWREQ;
-		ses_pool_task(wrk, sp);
-	}
+		return;
+	} 
+	VCA_SetupSess(wrk, sp);
+	sp->sess_step = S_STP_NEWREQ;
+	req = SES_GetReq(sp);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	ses_pool_task(wrk, req);
 }
 
 /*--------------------------------------------------------------------
@@ -186,7 +191,7 @@ SES_ScheduleReq(struct req *req)
 	AN(pp->pool);
 
 	sp->task.func = ses_pool_task;
-	sp->task.priv = sp;
+	sp->task.priv = req;
 
 	if (Pool_Task(pp->pool, &sp->task, POOL_QUEUE_FRONT)) {
 		VSC_C_main->client_drop_late++;
@@ -206,6 +211,7 @@ SES_ScheduleReq(struct req *req)
 void
 SES_Handle(struct sess *sp, double now)
 {
+	struct req *req;
 	struct sesspool *pp;
 
 	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
@@ -213,8 +219,10 @@ SES_Handle(struct sess *sp, double now)
 	CHECK_OBJ_NOTNULL(pp, SESSPOOL_MAGIC);
 	AN(pp->pool);
 	AZ(sp->req);
+	req = SES_GetReq(sp);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	sp->task.func = ses_pool_task;
-	sp->task.priv = sp;
+	sp->task.priv = req;
 	sp->sess_step = S_STP_NEWREQ;
 	sp->t_rx = now;
 	if (Pool_Task(pp->pool, &sp->task, POOL_QUEUE_FRONT)) {



From phk at varnish-cache.org  Mon Jun 25 09:14:36 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Mon, 25 Jun 2012 11:14:36 +0200
Subject: [master] 90846c4 Remove sp->req,
	sessions can now (almost) have more than one request at a time,
	paving the way for a lot of future fun...
Message-ID: <E1Sj5NU-0000Fb-7y@project.varnish-software.com>

commit 90846c4aa1c7be8bc9abbb7b78a2f589fc5638fd
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Mon Jun 25 09:13:29 2012 +0000

    Remove sp->req, sessions can now (almost) have more than one request
    at a time, paving the way for a lot of future fun...
    
    It's painfully obvious that I set about doing this the wrong way:
    I should have renamed sess to req and made a new sess structure,
    that would have been much simpler.

diff --git a/bin/varnishd/cache/cache.h b/bin/varnishd/cache/cache.h
index 1d83dab..1d991f1 100644
--- a/bin/varnishd/cache/cache.h
+++ b/bin/varnishd/cache/cache.h
@@ -660,7 +660,6 @@ struct sess {
 	/* Cross references ------------------------------------------*/
 
 	struct sesspool		*sesspool;
-	struct req		*req;
 
 	struct pool_task	task;
 	VTAILQ_ENTRY(sess)	list;
@@ -866,8 +865,6 @@ void THR_SetName(const char *name);
 const char* THR_GetName(void);
 void THR_SetRequest(const struct req *);
 const struct req * THR_GetRequest(void);
-void THR_SetSession(const struct sess *);
-const struct sess * THR_GetSession(void);
 
 /* cache_lck.c */
 
@@ -930,7 +927,6 @@ struct sesspool *SES_NewPool(struct pool *pp, unsigned pool_no);
 void SES_DeletePool(struct sesspool *sp);
 int SES_ScheduleReq(struct req *);
 void SES_Handle(struct sess *sp, double now);
-struct req *SES_GetReq(struct sess *sp);
 void SES_ReleaseReq(struct req *);
 pool_func_t SES_pool_accept_task;
 
diff --git a/bin/varnishd/cache/cache_center.c b/bin/varnishd/cache/cache_center.c
index 5c76ac9..004f815 100644
--- a/bin/varnishd/cache/cache_center.c
+++ b/bin/varnishd/cache/cache_center.c
@@ -334,7 +334,6 @@ CNT_Session(struct worker *wrk, struct req *req)
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	sp = req->sp;
 	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	assert(sp->req == req);
 
 	/*
 	 * Whenever we come in from the acceptor or waiter, we need to set
@@ -358,7 +357,6 @@ CNT_Session(struct worker *wrk, struct req *req)
 		/*
 		 * Possible entrance states
 		 */
-		assert(sp->req == req);
 
 		assert(
 		    sp->sess_step == S_STP_NEWREQ ||
diff --git a/bin/varnishd/cache/cache_main.c b/bin/varnishd/cache/cache_main.c
index 041578b..20d12bc 100644
--- a/bin/varnishd/cache/cache_main.c
+++ b/bin/varnishd/cache/cache_main.c
@@ -49,20 +49,6 @@ static pthread_key_t sp_key;
 static pthread_key_t req_key;
 
 void
-THR_SetSession(const struct sess *sp)
-{
-
-	AZ(pthread_setspecific(sp_key, sp));
-}
-
-const struct sess *
-THR_GetSession(void)
-{
-
-	return (pthread_getspecific(sp_key));
-}
-
-void
 THR_SetRequest(const struct req *req)
 {
 
diff --git a/bin/varnishd/cache/cache_panic.c b/bin/varnishd/cache/cache_panic.c
index 411b8e9..94b2aee 100644
--- a/bin/varnishd/cache/cache_panic.c
+++ b/bin/varnishd/cache/cache_panic.c
@@ -57,6 +57,8 @@
 static struct vsb pan_vsp_storage, *pan_vsp;
 static pthread_mutex_t panicstr_mtx = PTHREAD_MUTEX_INITIALIZER;
 
+static void pan_sess(const struct sess *sp);
+
 /*--------------------------------------------------------------------*/
 
 static void
@@ -261,6 +263,9 @@ pan_req(const struct req *req)
 	VSB_printf(pan_vsp, "  restarts = %d, esi_level = %d\n",
 	    req->restarts, req->esi_level);
 
+	if (req->sp != NULL)
+		pan_sess(req->sp);
+
 	if (req->wrk != NULL)
 		pan_wrk(req->wrk);
 
@@ -343,7 +348,6 @@ pan_ic(const char *func, const char *file, int line, const char *cond,
     int err, int xxx)
 {
 	const char *q;
-	const struct sess *sp;
 	const struct req *req;
 
 	AZ(pthread_mutex_lock(&panicstr_mtx)); /* Won't be released,
@@ -385,9 +389,6 @@ pan_ic(const char *func, const char *file, int line, const char *cond,
 	pan_backtrace();
 
 	if (!(cache_param->diag_bitmap & 0x2000)) {
-		sp = THR_GetSession();
-		if (sp != NULL)
-			pan_sess(sp);
 		req = THR_GetRequest();
 		if (req != NULL)
 			pan_req(req);
diff --git a/bin/varnishd/cache/cache_session.c b/bin/varnishd/cache/cache_session.c
index 2b384f6..15b2d9a 100644
--- a/bin/varnishd/cache/cache_session.c
+++ b/bin/varnishd/cache/cache_session.c
@@ -46,6 +46,8 @@
 
 static unsigned ses_size = sizeof (struct sess);
 
+static struct req * ses_GetReq(struct sess *sp);
+
 /*--------------------------------------------------------------------*/
 
 struct sesspool {
@@ -134,9 +136,7 @@ ses_pool_task(struct worker *wrk, void *arg)
 
 	AZ(wrk->aws->r);
 	wrk->lastused = NAN;
-	THR_SetSession(sp);
 	CNT_Session(wrk, req);
-	THR_SetSession(NULL);
 	WS_Assert(wrk->aws);
 	AZ(wrk->wrw);
 	if (cache_param->diag_bitmap & 0x00040000) {
@@ -168,7 +168,7 @@ SES_pool_accept_task(struct worker *wrk, void *arg)
 	} 
 	VCA_SetupSess(wrk, sp);
 	sp->sess_step = S_STP_NEWREQ;
-	req = SES_GetReq(sp);
+	req = ses_GetReq(sp);
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	ses_pool_task(wrk, req);
 }
@@ -218,8 +218,7 @@ SES_Handle(struct sess *sp, double now)
 	pp = sp->sesspool;
 	CHECK_OBJ_NOTNULL(pp, SESSPOOL_MAGIC);
 	AN(pp->pool);
-	AZ(sp->req);
-	req = SES_GetReq(sp);
+	req = ses_GetReq(sp);
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	sp->task.func = ses_pool_task;
 	sp->task.priv = req;
@@ -266,7 +265,6 @@ SES_Delete(struct sess *sp, const char *reason, double now)
 	struct sesspool *pp;
 
 	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	AZ(sp->req);
 	pp = sp->sesspool;
 	CHECK_OBJ_NOTNULL(pp, SESSPOOL_MAGIC);
 	AN(pp->pool);
@@ -296,11 +294,11 @@ SES_Delete(struct sess *sp, const char *reason, double now)
 }
 
 /*--------------------------------------------------------------------
- * Alloc/Free sp->req
+ * Alloc/Free a request
  */
 
-struct req *
-SES_GetReq(struct sess *sp)
+static struct req *
+ses_GetReq(struct sess *sp)
 {
 	struct sesspool *pp;
 	struct req *req;
@@ -313,11 +311,9 @@ SES_GetReq(struct sess *sp)
 	CHECK_OBJ_NOTNULL(pp, SESSPOOL_MAGIC);
 	AN(pp->pool);
 
-	AZ(sp->req);
 	req = MPL_Get(pp->mpl_req, &sz);
 	AN(req);
 	req->magic = REQ_MAGIC;
-	sp->req = req;
 	req->sp = sp;
 	THR_SetRequest(req);
 
@@ -370,7 +366,6 @@ SES_ReleaseReq(struct req *req)
 	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	sp = req->sp;
 	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	assert(sp->req == req);
 	pp = sp->sesspool;
 	CHECK_OBJ_NOTNULL(pp, SESSPOOL_MAGIC);
 	AN(pp->pool);
@@ -379,7 +374,6 @@ SES_ReleaseReq(struct req *req)
 	VSL_Flush(req->vsl, 0);
 	req->sp = NULL;
 	MPL_Free(pp->mpl_req, req);
-	sp->req = NULL;
 	THR_SetRequest(NULL);
 }
 
diff --git a/bin/varnishd/waiter/cache_waiter.c b/bin/varnishd/waiter/cache_waiter.c
index 3816a26..e89d550 100644
--- a/bin/varnishd/waiter/cache_waiter.c
+++ b/bin/varnishd/waiter/cache_waiter.c
@@ -67,7 +67,6 @@ WAIT_Enter(struct sess *sp)
 {
 
 	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	AZ(sp->req);
 	assert(sp->fd >= 0);
 
 	/*



From phk at varnish-cache.org  Mon Jun 25 10:11:25 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Mon, 25 Jun 2012 12:11:25 +0200
Subject: [master] 1c82be0 Fix a regression in panic output.
Message-ID: <E1Sj6GT-0004UE-NX@project.varnish-software.com>

commit 1c82be0c4664a0311a5c5207764bae9d25fd1023
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Mon Jun 25 10:11:03 2012 +0000

    Fix a regression in panic output.
    
    Update test-case to exercise more of the panic formatter.

diff --git a/bin/varnishd/cache/cache_main.c b/bin/varnishd/cache/cache_main.c
index 20d12bc..dcb3cb1 100644
--- a/bin/varnishd/cache/cache_main.c
+++ b/bin/varnishd/cache/cache_main.c
@@ -45,7 +45,6 @@ volatile struct params	*cache_param;
  * the thread.  This is used for panic messages.
  */
 
-static pthread_key_t sp_key;
 static pthread_key_t req_key;
 
 void
@@ -126,7 +125,6 @@ child_main(void)
 
 	cache_param = heritage.param;
 
-	AZ(pthread_key_create(&sp_key, NULL));
 	AZ(pthread_key_create(&req_key, NULL));
 	AZ(pthread_key_create(&name_key, NULL));
 
diff --git a/bin/varnishd/cache/cache_panic.c b/bin/varnishd/cache/cache_panic.c
index 94b2aee..ff9a65b 100644
--- a/bin/varnishd/cache/cache_panic.c
+++ b/bin/varnishd/cache/cache_panic.c
@@ -182,12 +182,12 @@ pan_vcl(const struct VCL_conf *vcl)
 {
 	int i;
 
-	VSB_printf(pan_vsp, "    vcl = {\n");
-	VSB_printf(pan_vsp, "      srcname = {\n");
+	VSB_printf(pan_vsp, "  vcl = {\n");
+	VSB_printf(pan_vsp, "    srcname = {\n");
 	for (i = 0; i < vcl->nsrc; ++i)
-		VSB_printf(pan_vsp, "        \"%s\",\n", vcl->srcname[i]);
-	VSB_printf(pan_vsp, "      },\n");
+		VSB_printf(pan_vsp, "      \"%s\",\n", vcl->srcname[i]);
 	VSB_printf(pan_vsp, "    },\n");
+	VSB_printf(pan_vsp, "  },\n");
 }
 
 
@@ -224,7 +224,7 @@ pan_busyobj(const struct busyobj *bo)
 		pan_http("bereq", bo->bereq, 4);
 	if (bo->beresp->ws != NULL)
 		pan_http("beresp", bo->beresp, 4);
-
+	VSB_printf(pan_vsp, "  }\n");
 }
 
 /*--------------------------------------------------------------------*/
@@ -272,7 +272,7 @@ pan_req(const struct req *req)
 	pan_ws(req->ws, 2);
 	pan_http("req", req->http, 2);
 	if (req->resp->ws != NULL)
-		pan_http("resp", req->resp, 4);
+		pan_http("resp", req->resp, 2);
 
 	if (VALID_OBJ(req->vcl, VCL_CONF_MAGIC))
 		pan_vcl(req->vcl);
@@ -293,10 +293,10 @@ pan_sess(const struct sess *sp)
 {
 	const char *stp;
 
-	VSB_printf(pan_vsp, "sp = %p {\n", sp);
-	VSB_printf(pan_vsp, "  fd = %d, id = %u,\n",
+	VSB_printf(pan_vsp, "  sp = %p {\n", sp);
+	VSB_printf(pan_vsp, "    fd = %d, id = %u,\n",
 	    sp->fd, sp->vsl_id & VSL_IDENTMASK);
-	VSB_printf(pan_vsp, "  client = %s %s,\n",
+	VSB_printf(pan_vsp, "    client = %s %s,\n",
 	    sp->addr ? sp->addr : "?.?.?.?",
 	    sp->port ? sp->port : "?");
 	switch (sp->sess_step) {
@@ -306,11 +306,11 @@ pan_sess(const struct sess *sp)
 		default: stp = NULL;
 	}
 	if (stp != NULL)
-		VSB_printf(pan_vsp, "  step = %s,\n", stp);
+		VSB_printf(pan_vsp, "    step = %s,\n", stp);
 	else
-		VSB_printf(pan_vsp, "  step = 0x%x,\n", sp->sess_step);
+		VSB_printf(pan_vsp, "    step = 0x%x,\n", sp->sess_step);
 
-	VSB_printf(pan_vsp, "},\n");
+	VSB_printf(pan_vsp, "  },\n");
 }
 
 /*--------------------------------------------------------------------*/
diff --git a/bin/varnishd/cache/cache_session.c b/bin/varnishd/cache/cache_session.c
index 15b2d9a..e8a1ac1 100644
--- a/bin/varnishd/cache/cache_session.c
+++ b/bin/varnishd/cache/cache_session.c
@@ -134,6 +134,7 @@ ses_pool_task(struct worker *wrk, void *arg)
 	sp = req->sp;
 	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
 
+	THR_SetRequest(req);
 	AZ(wrk->aws->r);
 	wrk->lastused = NAN;
 	CNT_Session(wrk, req);
@@ -143,6 +144,7 @@ ses_pool_task(struct worker *wrk, void *arg)
 		if (wrk->vcl != NULL)
 			VCL_Rel(&wrk->vcl);
 	}
+	THR_SetRequest(NULL);
 }
 
 /*--------------------------------------------------------------------
@@ -315,7 +317,6 @@ ses_GetReq(struct sess *sp)
 	AN(req);
 	req->magic = REQ_MAGIC;
 	req->sp = sp;
-	THR_SetRequest(req);
 
 	e = (char*)req + sz;
 	p = (char*)(req + 1);
@@ -374,7 +375,6 @@ SES_ReleaseReq(struct req *req)
 	VSL_Flush(req->vsl, 0);
 	req->sp = NULL;
 	MPL_Free(pp->mpl_req, req);
-	THR_SetRequest(NULL);
 }
 
 /*--------------------------------------------------------------------
diff --git a/bin/varnishtest/tests/v00010.vtc b/bin/varnishtest/tests/v00010.vtc
index 46d778c..2e9a385 100644
--- a/bin/varnishtest/tests/v00010.vtc
+++ b/bin/varnishtest/tests/v00010.vtc
@@ -4,7 +4,15 @@ server s1 {
 	rxreq
 	txresp -hdr "Foo: bar" -body "abcdef\n"
 	rxreq
-	txresp -hdr "Panic: please" -body "012345\n"
+	txresp -hdr "Panic: fetch" -body "012345\n"
+	close
+
+	sema r1 sync 2
+	accept
+	rxreq
+	txresp -hdr "Foo: bar" -body "abcdef\n"
+	rxreq
+	txresp -hdr "Panic: deliver" -body "012345\n"
 	close
 
 	sema r1 sync 2
@@ -17,8 +25,13 @@ varnish v1 -storage "-smalloc,1m" -vcl+backend {
 
 	import debug from "${topbuild}/lib/libvmod_debug/.libs/libvmod_debug.so";
 
+	sub vcl_fetch {
+		if (beresp.http.panic == "fetch") {
+			debug.panic("Had Panic header: " + beresp.http.panic);
+		}
+	}
 	sub vcl_deliver {
-		if (resp.http.panic) {
+		if (resp.http.panic == "deliver") {
 			debug.panic("Had Panic header: " + resp.http.panic);
 		}
 	}
@@ -49,5 +62,22 @@ delay 0.5
 client c1 {
 	txreq -url "/"
 	rxresp
+	txreq -url "/foo"
+	# Don't expect answer, the server crashed.
+} -run
+
+varnish v1 -wait-stopped
+varnish v1 -cliok "panic.show"
+varnish v1 -cliok "panic.clear"
+varnish v1 -clierr 300 "panic.clear"
+varnish v1 -cliok "start"
+varnish v1 -wait-running
+sema r1 sync 2
+
+delay 0.5
+
+client c1 {
+	txreq -url "/"
+	rxresp
 	expect resp.http.foo == "foo"
 } -run



From phk at varnish-cache.org  Tue Jun 26 09:24:21 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Tue, 26 Jun 2012 11:24:21 +0200
Subject: [master] ea1df10 Compress this eyesore using CPP
Message-ID: <E1SjS0T-0008M5-ST@project.varnish-software.com>

commit ea1df10930ec15629c386dc692cb6c08d3d82392
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Tue Jun 26 09:24:11 2012 +0000

    Compress this eyesore using CPP

diff --git a/lib/libvarnishcompat/execinfo.c b/lib/libvarnishcompat/execinfo.c
index b1a17cf..113ae32 100644
--- a/lib/libvarnishcompat/execinfo.c
+++ b/lib/libvarnishcompat/execinfo.c
@@ -126,278 +126,37 @@ backtrace_symbols(void *const *buffer, int size)
 	return (rval);
 }
 
+/* Binary expansion */
+#define L1(x)	L0(x); L0(x + 0x01);
+#define L2(x)	L1(x); L1(x + 0x02);
+#define L3(x)	L2(x); L2(x + 0x04);
+#define L4(x)	L3(x); L3(x + 0x08);
+#define L5(x)	L4(x); L4(x + 0x10);
+#define L6(x)	L5(x); L5(x + 0x20);
+#define L7(x)	L6(x); L6(x + 0x40);
+
 static void *
 getreturnaddr(int level)
 {
 
-    switch(level) {
-    case 0: return __builtin_return_address(1);
-    case 1: return __builtin_return_address(2);
-    case 2: return __builtin_return_address(3);
-    case 3: return __builtin_return_address(4);
-    case 4: return __builtin_return_address(5);
-    case 5: return __builtin_return_address(6);
-    case 6: return __builtin_return_address(7);
-    case 7: return __builtin_return_address(8);
-    case 8: return __builtin_return_address(9);
-    case 9: return __builtin_return_address(10);
-    case 10: return __builtin_return_address(11);
-    case 11: return __builtin_return_address(12);
-    case 12: return __builtin_return_address(13);
-    case 13: return __builtin_return_address(14);
-    case 14: return __builtin_return_address(15);
-    case 15: return __builtin_return_address(16);
-    case 16: return __builtin_return_address(17);
-    case 17: return __builtin_return_address(18);
-    case 18: return __builtin_return_address(19);
-    case 19: return __builtin_return_address(20);
-    case 20: return __builtin_return_address(21);
-    case 21: return __builtin_return_address(22);
-    case 22: return __builtin_return_address(23);
-    case 23: return __builtin_return_address(24);
-    case 24: return __builtin_return_address(25);
-    case 25: return __builtin_return_address(26);
-    case 26: return __builtin_return_address(27);
-    case 27: return __builtin_return_address(28);
-    case 28: return __builtin_return_address(29);
-    case 29: return __builtin_return_address(30);
-    case 30: return __builtin_return_address(31);
-    case 31: return __builtin_return_address(32);
-    case 32: return __builtin_return_address(33);
-    case 33: return __builtin_return_address(34);
-    case 34: return __builtin_return_address(35);
-    case 35: return __builtin_return_address(36);
-    case 36: return __builtin_return_address(37);
-    case 37: return __builtin_return_address(38);
-    case 38: return __builtin_return_address(39);
-    case 39: return __builtin_return_address(40);
-    case 40: return __builtin_return_address(41);
-    case 41: return __builtin_return_address(42);
-    case 42: return __builtin_return_address(43);
-    case 43: return __builtin_return_address(44);
-    case 44: return __builtin_return_address(45);
-    case 45: return __builtin_return_address(46);
-    case 46: return __builtin_return_address(47);
-    case 47: return __builtin_return_address(48);
-    case 48: return __builtin_return_address(49);
-    case 49: return __builtin_return_address(50);
-    case 50: return __builtin_return_address(51);
-    case 51: return __builtin_return_address(52);
-    case 52: return __builtin_return_address(53);
-    case 53: return __builtin_return_address(54);
-    case 54: return __builtin_return_address(55);
-    case 55: return __builtin_return_address(56);
-    case 56: return __builtin_return_address(57);
-    case 57: return __builtin_return_address(58);
-    case 58: return __builtin_return_address(59);
-    case 59: return __builtin_return_address(60);
-    case 60: return __builtin_return_address(61);
-    case 61: return __builtin_return_address(62);
-    case 62: return __builtin_return_address(63);
-    case 63: return __builtin_return_address(64);
-    case 64: return __builtin_return_address(65);
-    case 65: return __builtin_return_address(66);
-    case 66: return __builtin_return_address(67);
-    case 67: return __builtin_return_address(68);
-    case 68: return __builtin_return_address(69);
-    case 69: return __builtin_return_address(70);
-    case 70: return __builtin_return_address(71);
-    case 71: return __builtin_return_address(72);
-    case 72: return __builtin_return_address(73);
-    case 73: return __builtin_return_address(74);
-    case 74: return __builtin_return_address(75);
-    case 75: return __builtin_return_address(76);
-    case 76: return __builtin_return_address(77);
-    case 77: return __builtin_return_address(78);
-    case 78: return __builtin_return_address(79);
-    case 79: return __builtin_return_address(80);
-    case 80: return __builtin_return_address(81);
-    case 81: return __builtin_return_address(82);
-    case 82: return __builtin_return_address(83);
-    case 83: return __builtin_return_address(84);
-    case 84: return __builtin_return_address(85);
-    case 85: return __builtin_return_address(86);
-    case 86: return __builtin_return_address(87);
-    case 87: return __builtin_return_address(88);
-    case 88: return __builtin_return_address(89);
-    case 89: return __builtin_return_address(90);
-    case 90: return __builtin_return_address(91);
-    case 91: return __builtin_return_address(92);
-    case 92: return __builtin_return_address(93);
-    case 93: return __builtin_return_address(94);
-    case 94: return __builtin_return_address(95);
-    case 95: return __builtin_return_address(96);
-    case 96: return __builtin_return_address(97);
-    case 97: return __builtin_return_address(98);
-    case 98: return __builtin_return_address(99);
-    case 99: return __builtin_return_address(100);
-    case 100: return __builtin_return_address(101);
-    case 101: return __builtin_return_address(102);
-    case 102: return __builtin_return_address(103);
-    case 103: return __builtin_return_address(104);
-    case 104: return __builtin_return_address(105);
-    case 105: return __builtin_return_address(106);
-    case 106: return __builtin_return_address(107);
-    case 107: return __builtin_return_address(108);
-    case 108: return __builtin_return_address(109);
-    case 109: return __builtin_return_address(110);
-    case 110: return __builtin_return_address(111);
-    case 111: return __builtin_return_address(112);
-    case 112: return __builtin_return_address(113);
-    case 113: return __builtin_return_address(114);
-    case 114: return __builtin_return_address(115);
-    case 115: return __builtin_return_address(116);
-    case 116: return __builtin_return_address(117);
-    case 117: return __builtin_return_address(118);
-    case 118: return __builtin_return_address(119);
-    case 119: return __builtin_return_address(120);
-    case 120: return __builtin_return_address(121);
-    case 121: return __builtin_return_address(122);
-    case 122: return __builtin_return_address(123);
-    case 123: return __builtin_return_address(124);
-    case 124: return __builtin_return_address(125);
-    case 125: return __builtin_return_address(126);
-    case 126: return __builtin_return_address(127);
-    case 127: return __builtin_return_address(128);
-    default: return NULL;
-    }
+	switch(level) {
+#define L0(x)	case x: return __builtin_return_address(x + 1);
+	L7(0)
+#undef L0
+	default: return NULL;
+	}
 }
 
 static void *
 getframeaddr(int level)
 {
 
-    switch(level) {
-    case 0: return __builtin_frame_address(1);
-    case 1: return __builtin_frame_address(2);
-    case 2: return __builtin_frame_address(3);
-    case 3: return __builtin_frame_address(4);
-    case 4: return __builtin_frame_address(5);
-    case 5: return __builtin_frame_address(6);
-    case 6: return __builtin_frame_address(7);
-    case 7: return __builtin_frame_address(8);
-    case 8: return __builtin_frame_address(9);
-    case 9: return __builtin_frame_address(10);
-    case 10: return __builtin_frame_address(11);
-    case 11: return __builtin_frame_address(12);
-    case 12: return __builtin_frame_address(13);
-    case 13: return __builtin_frame_address(14);
-    case 14: return __builtin_frame_address(15);
-    case 15: return __builtin_frame_address(16);
-    case 16: return __builtin_frame_address(17);
-    case 17: return __builtin_frame_address(18);
-    case 18: return __builtin_frame_address(19);
-    case 19: return __builtin_frame_address(20);
-    case 20: return __builtin_frame_address(21);
-    case 21: return __builtin_frame_address(22);
-    case 22: return __builtin_frame_address(23);
-    case 23: return __builtin_frame_address(24);
-    case 24: return __builtin_frame_address(25);
-    case 25: return __builtin_frame_address(26);
-    case 26: return __builtin_frame_address(27);
-    case 27: return __builtin_frame_address(28);
-    case 28: return __builtin_frame_address(29);
-    case 29: return __builtin_frame_address(30);
-    case 30: return __builtin_frame_address(31);
-    case 31: return __builtin_frame_address(32);
-    case 32: return __builtin_frame_address(33);
-    case 33: return __builtin_frame_address(34);
-    case 34: return __builtin_frame_address(35);
-    case 35: return __builtin_frame_address(36);
-    case 36: return __builtin_frame_address(37);
-    case 37: return __builtin_frame_address(38);
-    case 38: return __builtin_frame_address(39);
-    case 39: return __builtin_frame_address(40);
-    case 40: return __builtin_frame_address(41);
-    case 41: return __builtin_frame_address(42);
-    case 42: return __builtin_frame_address(43);
-    case 43: return __builtin_frame_address(44);
-    case 44: return __builtin_frame_address(45);
-    case 45: return __builtin_frame_address(46);
-    case 46: return __builtin_frame_address(47);
-    case 47: return __builtin_frame_address(48);
-    case 48: return __builtin_frame_address(49);
-    case 49: return __builtin_frame_address(50);
-    case 50: return __builtin_frame_address(51);
-    case 51: return __builtin_frame_address(52);
-    case 52: return __builtin_frame_address(53);
-    case 53: return __builtin_frame_address(54);
-    case 54: return __builtin_frame_address(55);
-    case 55: return __builtin_frame_address(56);
-    case 56: return __builtin_frame_address(57);
-    case 57: return __builtin_frame_address(58);
-    case 58: return __builtin_frame_address(59);
-    case 59: return __builtin_frame_address(60);
-    case 60: return __builtin_frame_address(61);
-    case 61: return __builtin_frame_address(62);
-    case 62: return __builtin_frame_address(63);
-    case 63: return __builtin_frame_address(64);
-    case 64: return __builtin_frame_address(65);
-    case 65: return __builtin_frame_address(66);
-    case 66: return __builtin_frame_address(67);
-    case 67: return __builtin_frame_address(68);
-    case 68: return __builtin_frame_address(69);
-    case 69: return __builtin_frame_address(70);
-    case 70: return __builtin_frame_address(71);
-    case 71: return __builtin_frame_address(72);
-    case 72: return __builtin_frame_address(73);
-    case 73: return __builtin_frame_address(74);
-    case 74: return __builtin_frame_address(75);
-    case 75: return __builtin_frame_address(76);
-    case 76: return __builtin_frame_address(77);
-    case 77: return __builtin_frame_address(78);
-    case 78: return __builtin_frame_address(79);
-    case 79: return __builtin_frame_address(80);
-    case 80: return __builtin_frame_address(81);
-    case 81: return __builtin_frame_address(82);
-    case 82: return __builtin_frame_address(83);
-    case 83: return __builtin_frame_address(84);
-    case 84: return __builtin_frame_address(85);
-    case 85: return __builtin_frame_address(86);
-    case 86: return __builtin_frame_address(87);
-    case 87: return __builtin_frame_address(88);
-    case 88: return __builtin_frame_address(89);
-    case 89: return __builtin_frame_address(90);
-    case 90: return __builtin_frame_address(91);
-    case 91: return __builtin_frame_address(92);
-    case 92: return __builtin_frame_address(93);
-    case 93: return __builtin_frame_address(94);
-    case 94: return __builtin_frame_address(95);
-    case 95: return __builtin_frame_address(96);
-    case 96: return __builtin_frame_address(97);
-    case 97: return __builtin_frame_address(98);
-    case 98: return __builtin_frame_address(99);
-    case 99: return __builtin_frame_address(100);
-    case 100: return __builtin_frame_address(101);
-    case 101: return __builtin_frame_address(102);
-    case 102: return __builtin_frame_address(103);
-    case 103: return __builtin_frame_address(104);
-    case 104: return __builtin_frame_address(105);
-    case 105: return __builtin_frame_address(106);
-    case 106: return __builtin_frame_address(107);
-    case 107: return __builtin_frame_address(108);
-    case 108: return __builtin_frame_address(109);
-    case 109: return __builtin_frame_address(110);
-    case 110: return __builtin_frame_address(111);
-    case 111: return __builtin_frame_address(112);
-    case 112: return __builtin_frame_address(113);
-    case 113: return __builtin_frame_address(114);
-    case 114: return __builtin_frame_address(115);
-    case 115: return __builtin_frame_address(116);
-    case 116: return __builtin_frame_address(117);
-    case 117: return __builtin_frame_address(118);
-    case 118: return __builtin_frame_address(119);
-    case 119: return __builtin_frame_address(120);
-    case 120: return __builtin_frame_address(121);
-    case 121: return __builtin_frame_address(122);
-    case 122: return __builtin_frame_address(123);
-    case 123: return __builtin_frame_address(124);
-    case 124: return __builtin_frame_address(125);
-    case 125: return __builtin_frame_address(126);
-    case 126: return __builtin_frame_address(127);
-    case 127: return __builtin_frame_address(128);
-    default: return NULL;
-    }
+	switch(level) {
+#define L0(x)	case x: return __builtin_frame_address(x + 1);
+	L7(0)
+#undef L0
+	default: return NULL;
+	}
 }
 
 #else



From phk at varnish-cache.org  Tue Jun 26 10:07:03 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Tue, 26 Jun 2012 12:07:03 +0200
Subject: [master] c477891 White-space cleanup
Message-ID: <E1SjSfn-0002Mn-Ve@project.varnish-software.com>

commit c4778915db1fa39e96e8a77ad47608a7285951da
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Tue Jun 26 10:06:53 2012 +0000

    White-space cleanup

diff --git a/bin/varnishd/cache/cache_dir_round_robin.c b/bin/varnishd/cache/cache_dir_round_robin.c
index 68e7071..b3a57f2 100644
--- a/bin/varnishd/cache/cache_dir_round_robin.c
+++ b/bin/varnishd/cache/cache_dir_round_robin.c
@@ -173,4 +173,3 @@ VRT_init_dir_fallback(struct cli *cli, struct director **bp, int idx,
 {
 	vrt_init_dir(cli, bp, idx, priv, m_fallback);
 }
-
diff --git a/bin/varnishd/cache/cache_esi.h b/bin/varnishd/cache/cache_esi.h
index c6c2376..9903bd8 100644
--- a/bin/varnishd/cache/cache_esi.h
+++ b/bin/varnishd/cache/cache_esi.h
@@ -44,5 +44,3 @@ typedef ssize_t vep_callback_t(struct busyobj *, ssize_t l, enum vgz_flag flg);
 void VEP_Init(struct busyobj *, vep_callback_t *cb);
 void VEP_Parse(const struct busyobj *, const char *p, size_t l);
 struct vsb *VEP_Finish(struct busyobj *);
-
-
diff --git a/bin/varnishd/cache/cache_session.c b/bin/varnishd/cache/cache_session.c
index e8a1ac1..25dc687 100644
--- a/bin/varnishd/cache/cache_session.c
+++ b/bin/varnishd/cache/cache_session.c
@@ -167,7 +167,7 @@ SES_pool_accept_task(struct worker *wrk, void *arg)
 	if (sp == NULL) {
 		VCA_FailSess(wrk);
 		return;
-	} 
+	}
 	VCA_SetupSess(wrk, sp);
 	sp->sess_step = S_STP_NEWREQ;
 	req = ses_GetReq(sp);
diff --git a/bin/varnishd/cache/cache_shmlog.c b/bin/varnishd/cache/cache_shmlog.c
index f977400..85a603f 100644
--- a/bin/varnishd/cache/cache_shmlog.c
+++ b/bin/varnishd/cache/cache_shmlog.c
@@ -241,7 +241,8 @@ wsl(struct vsl_log *, enum VSL_tag_e tag, int id, const char *fmt, va_list ap)
     __printflike(4, 0);
 
 static void
-wsl(struct vsl_log *vsl, enum VSL_tag_e tag, int id, const char *fmt, va_list ap)
+wsl(struct vsl_log *vsl, enum VSL_tag_e tag, int id, const char *fmt,
+    va_list ap)
 {
 	char *p;
 	unsigned n, mlen;
diff --git a/bin/varnishd/cache/cache_vrt_var.c b/bin/varnishd/cache/cache_vrt_var.c
index aedbc98..7563184 100644
--- a/bin/varnishd/cache/cache_vrt_var.c
+++ b/bin/varnishd/cache/cache_vrt_var.c
@@ -558,4 +558,3 @@ VRT_r_req_backend_healthy(const struct req *req)
 	CHECK_OBJ_NOTNULL(req->director, DIRECTOR_MAGIC);
 	return (VDI_Healthy(req->director, req));
 }
-
diff --git a/bin/varnishd/cache/cache_wrw.c b/bin/varnishd/cache/cache_wrw.c
index 3a38305..2324318 100644
--- a/bin/varnishd/cache/cache_wrw.c
+++ b/bin/varnishd/cache/cache_wrw.c
@@ -311,6 +311,3 @@ WRW_EndChunk(const struct worker *wrk)
 	wrw->cliov = 0;
 	(void)WRW_Write(wrk, "0\r\n\r\n", -1);
 }
-
-
-
diff --git a/bin/varnishd/hash/hash_mgt.c b/bin/varnishd/hash/hash_mgt.c
index ffbba29..30460b3 100644
--- a/bin/varnishd/hash/hash_mgt.c
+++ b/bin/varnishd/hash/hash_mgt.c
@@ -81,4 +81,3 @@ HSH_config(const char *h_arg)
 		ARGV_ERR("Hash method \"%s\" takes no arguments\n",
 		    hp->name);
 }
-
diff --git a/include/vcli_serve.h b/include/vcli_serve.h
index 7e4e6e4..fe240c1 100644
--- a/include/vcli_serve.h
+++ b/include/vcli_serve.h
@@ -43,4 +43,3 @@ void VCLS_Destroy(struct VCLS **);
 cli_func_t	VCLS_func_close;
 cli_func_t	VCLS_func_help;
 cli_func_t	VCLS_func_ping;
-
diff --git a/lib/libvarnish/cli_serve.c b/lib/libvarnish/cli_serve.c
index 0de26b1..43c4ecf 100644
--- a/lib/libvarnish/cli_serve.c
+++ b/lib/libvarnish/cli_serve.c
@@ -577,4 +577,3 @@ VCLS_Destroy(struct VCLS **csp)
 	}
 	FREE_OBJ(cs);
 }
-
diff --git a/lib/libvarnish/vsha256.c b/lib/libvarnish/vsha256.c
index 0a521b2..a2208cf 100644
--- a/lib/libvarnish/vsha256.c
+++ b/lib/libvarnish/vsha256.c
@@ -332,4 +332,3 @@ SHA256_Test(void)
 		assert(!memcmp(o, p->output, 32));
 	}
 }
-
diff --git a/lib/libvarnishapi/vsc.c b/lib/libvarnishapi/vsc.c
index 5f992cf..67f0690 100644
--- a/lib/libvarnishapi/vsc.c
+++ b/lib/libvarnishapi/vsc.c
@@ -409,5 +409,3 @@ VSC_Iter(struct VSM_data *vd, VSC_iter_f *func, void *priv)
 #undef VSC_F
 #undef VSC_DO
 #undef VSC_DONE
-
-
diff --git a/lib/libvarnishapi/vsl_api.h b/lib/libvarnishapi/vsl_api.h
index 0b38539..b203ae8 100644
--- a/lib/libvarnishapi/vsl_api.h
+++ b/lib/libvarnishapi/vsl_api.h
@@ -89,4 +89,3 @@ struct vsl {
 };
 
 struct vsl *vsl_Setup(struct VSM_data *vd);
-
diff --git a/lib/libvcl/vmodtool.py b/lib/libvcl/vmodtool.py
index e2cf8b5..d32eb4a 100755
--- a/lib/libvcl/vmodtool.py
+++ b/lib/libvcl/vmodtool.py
@@ -318,4 +318,3 @@ fh.write('extern const void * const Vmod_Id;\n')
 fc.write('const void * const Vmod_Id = &Vmod_Id;\n')
 
 fc.write("\n")
-
diff --git a/lib/libvmod_debug/vmod_debug.c b/lib/libvmod_debug/vmod_debug.c
index fd65fd2..cd23473 100644
--- a/lib/libvmod_debug/vmod_debug.c
+++ b/lib/libvmod_debug/vmod_debug.c
@@ -94,4 +94,3 @@ vmod_test_priv_vcl(struct req *req, struct vmod_priv *priv)
         CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
         assert(!strcmp(priv->priv, "FOO"));
 }
-
diff --git a/lib/libvmod_std/vmod_std.c b/lib/libvmod_std/vmod_std.c
index 4265cf1..037ffdd 100644
--- a/lib/libvmod_std/vmod_std.c
+++ b/lib/libvmod_std/vmod_std.c
@@ -177,4 +177,3 @@ vmod_collect(struct req *req, enum gethdr_e e, const char *h)
 	else if (e == HDR_BERESP && req->busyobj != NULL)
 		http_CollectHdr(req->busyobj->beresp, h);
 }
-



From phk at varnish-cache.org  Wed Jun 27 08:39:05 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Wed, 27 Jun 2012 10:39:05 +0200
Subject: [master] 590299e Make Flexelint hate me less
Message-ID: <E1SjnmD-0004He-CX@project.varnish-software.com>

commit 590299ee7c4b6cc4a25375db0d37fe600d6ff95a
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Wed Jun 27 08:38:51 2012 +0000

    Make Flexelint hate me less

diff --git a/lib/libvarnishcompat/execinfo.c b/lib/libvarnishcompat/execinfo.c
index 113ae32..7babdd4 100644
--- a/lib/libvarnishcompat/execinfo.c
+++ b/lib/libvarnishcompat/execinfo.c
@@ -127,22 +127,22 @@ backtrace_symbols(void *const *buffer, int size)
 }
 
 /* Binary expansion */
-#define L1(x)	L0(x); L0(x + 0x01);
-#define L2(x)	L1(x); L1(x + 0x02);
-#define L3(x)	L2(x); L2(x + 0x04);
-#define L4(x)	L3(x); L3(x + 0x08);
-#define L5(x)	L4(x); L4(x + 0x10);
-#define L6(x)	L5(x); L5(x + 0x20);
-#define L7(x)	L6(x); L6(x + 0x40);
+#define DO_P2_TIMES_1(x)	DO_P2_TIMES_0(x); DO_P2_TIMES_0((x) + (1<<0))
+#define DO_P2_TIMES_2(x)	DO_P2_TIMES_1(x); DO_P2_TIMES_1((x) + (1<<1))
+#define DO_P2_TIMES_3(x)	DO_P2_TIMES_2(x); DO_P2_TIMES_2((x) + (1<<2))
+#define DO_P2_TIMES_4(x)	DO_P2_TIMES_3(x); DO_P2_TIMES_3((x) + (1<<3))
+#define DO_P2_TIMES_5(x)	DO_P2_TIMES_4(x); DO_P2_TIMES_4((x) + (1<<4))
+#define DO_P2_TIMES_6(x)	DO_P2_TIMES_5(x); DO_P2_TIMES_5((x) + (1<<5))
+#define DO_P2_TIMES_7(x)	DO_P2_TIMES_6(x); DO_P2_TIMES_6((x) + (1<<6))
 
 static void *
 getreturnaddr(int level)
 {
 
 	switch(level) {
-#define L0(x)	case x: return __builtin_return_address(x + 1);
-	L7(0)
-#undef L0
+#define DO_P2_TIMES_0(x)	case (x): return __builtin_return_address((x) + 1)
+	DO_P2_TIMES_7(0);
+#undef DO_P2_TIMES_0
 	default: return NULL;
 	}
 }
@@ -152,9 +152,9 @@ getframeaddr(int level)
 {
 
 	switch(level) {
-#define L0(x)	case x: return __builtin_frame_address(x + 1);
-	L7(0)
-#undef L0
+#define DO_P2_TIMES_0(x)	case (x): return __builtin_frame_address((x) + 1)
+	DO_P2_TIMES_7(0);
+#undef DO_P2_TIMES_0
 	default: return NULL;
 	}
 }



From phk at varnish-cache.org  Wed Jun 27 09:54:59 2012
From: phk at varnish-cache.org (Poul-Henning Kamp)
Date: Wed, 27 Jun 2012 11:54:59 +0200
Subject: [master] 7e25234 Overhaul the thread-pool herding code.
Message-ID: <E1Sjoxf-00070I-5n@project.varnish-software.com>

commit 7e25234d6f25cf1dd622e4d17e70902c99e63b8b
Author: Poul-Henning Kamp <phk at FreeBSD.org>
Date:   Wed Jun 27 09:51:12 2012 +0000

    Overhaul the thread-pool herding code.
    
    NB: Changes to parameter defaults & units included in this commit!
    
    I tried to apply some queuing theory to this problem and as much as
    I admire Agner Krarup Erlang, his math isn't much help when you don't
    know any of the relevant metrics for your queue.
    
    Instead I took a much simpler approach:  "If we fail to get a thread,
    we probably need more threads", and have rewritten the herder to to
    react faster and more reliably to such events.
    
    I went over the parameters for thread-pools and normalized timeouts
    to seconds rather than milliseconds (beware!) and polished descriptions
    etc.

diff --git a/bin/varnishd/cache/cache_pool.c b/bin/varnishd/cache/cache_pool.c
index a723a9e..fa1f401 100644
--- a/bin/varnishd/cache/cache_pool.c
+++ b/bin/varnishd/cache/cache_pool.c
@@ -31,13 +31,6 @@
  * Pools can be added on the fly, as a means to mitigate lock contention,
  * but can only be removed again by a restart. (XXX: we could fix that)
  *
- * Two threads herd the pools, one eliminates idle threads and aggregates
- * statistics for all the pools, the other thread creates new threads
- * on demand, subject to various numerical constraints.
- *
- * The algorithm for when to create threads needs to be reactive enough
- * to handle startup spikes, but sufficiently attenuated to not cause
- * thread pileups.  This remains subject for improvement.
  */
 
 #include "config.h"
@@ -50,36 +43,6 @@
 
 #include "vtim.h"
 
-/*--------------------------------------------------------------------
- * MAC OS/X is incredibly moronic when it comes to time and such...
- */
-
-#ifndef CLOCK_MONOTONIC
-#define CLOCK_MONOTONIC	0
-
-#include <sys/time.h>
-
-static int
-clock_gettime(int foo, struct timespec *ts)
-{
-	struct timeval tv;
-
-	(void)foo;
-	gettimeofday(&tv, NULL);
-	ts->tv_sec = tv.tv_sec;
-	ts->tv_nsec = tv.tv_usec * 1000;
-	return (0);
-}
-
-static int
-pthread_condattr_setclock(pthread_condattr_t *attr, int foo)
-{
-	(void)attr;
-	(void)foo;
-	return (0);
-}
-#endif /* !CLOCK_MONOTONIC */
-
 VTAILQ_HEAD(taskhead, pool_task);
 
 struct poolsock {
@@ -97,7 +60,6 @@ struct pool {
 	VTAILQ_ENTRY(pool)		list;
 
 	pthread_cond_t			herder_cond;
-	struct lock			herder_mtx;
 	pthread_t			herder_thr;
 
 	struct vxid			vxid;
@@ -107,8 +69,8 @@ struct pool {
 	struct taskhead			front_queue;
 	struct taskhead			back_queue;
 	unsigned			nthr;
+	unsigned			dry;
 	unsigned			lqueue;
-	unsigned			last_lqueue;
 	uintmax_t			ndropped;
 	uintmax_t			nqueued;
 	struct sesspool			*sesspool;
@@ -121,19 +83,21 @@ static pthread_t		thr_pool_herder;
  */
 
 static struct worker *
-pool_getidleworker(const struct pool *pp, int back)
+pool_getidleworker(struct pool *pp)
 {
 	struct pool_task *pt;
 	struct worker *wrk;
 
 	CHECK_OBJ_NOTNULL(pp, POOL_MAGIC);
 	Lck_AssertHeld(&pp->mtx);
-	if (back)
-		pt = VTAILQ_LAST(&pp->idle_queue, taskhead);
-	else
-		pt = VTAILQ_FIRST(&pp->idle_queue);
-	if (pt == NULL)
+	pt = VTAILQ_FIRST(&pp->idle_queue);
+	if (pt == NULL) {
+		if (pp->nthr < cache_param->wthread_max) {
+			pp->dry++;
+			AZ(pthread_cond_signal(&pp->herder_cond));
+		}
 		return (NULL);
+	}
 	AZ(pt->func);
 	CAST_OBJ_NOTNULL(wrk, pt->priv, WORKER_MAGIC);
 	return (wrk);
@@ -185,7 +149,7 @@ pool_accept(struct worker *wrk, void *arg)
 
 		Lck_Lock(&pp->mtx);
 		wa->vxid = VXID_Get(&pp->vxid);
-		wrk2 = pool_getidleworker(pp, 0);
+		wrk2 = pool_getidleworker(pp);
 		if (wrk2 == NULL) {
 			/* No idle threads, do it ourselves */
 			Lck_Unlock(&pp->mtx);
@@ -225,7 +189,7 @@ Pool_Task(struct pool *pp, struct pool_task *task, enum pool_how how)
 	 * The common case first:  Take an idle thread, do it.
 	 */
 
-	wrk = pool_getidleworker(pp, 0);
+	wrk = pool_getidleworker(pp);
 	if (wrk != NULL) {
 		VTAILQ_REMOVE(&pp->idle_queue, &wrk->task, list);
 		AZ(wrk->task.func);
@@ -242,7 +206,7 @@ Pool_Task(struct pool *pp, struct pool_task *task, enum pool_how how)
 		break;
 	case POOL_QUEUE_FRONT:
 		/* If we have too much in the queue already, refuse. */
-		if (pp->lqueue > (cache_param->queue_max * pp->nthr) / 100) {
+		if (pp->lqueue > cache_param->wthread_queue_limit) {
 			pp->ndropped++;
 			retval = -1;
 		} else {
@@ -258,8 +222,6 @@ Pool_Task(struct pool *pp, struct pool_task *task, enum pool_how how)
 		WRONG("Unknown enum pool_how");
 	}
 	Lck_Unlock(&pp->mtx);
-	if (retval)
-		AZ(pthread_cond_signal(&pp->herder_cond));
 	return (retval);
 }
 
@@ -320,7 +282,7 @@ Pool_Work_Thread(void *priv, struct worker *wrk)
 }
 
 /*--------------------------------------------------------------------
- * Create another thread, if necessary & possible
+ * Create another thread.
  */
 
 static void
@@ -328,35 +290,23 @@ pool_breed(struct pool *qp, const pthread_attr_t *tp_attr)
 {
 	pthread_t tp;
 
-	/*
-	 * If we need more threads, and have space, create
-	 * one more thread.
-	 */
-	if (qp->nthr < cache_param->wthread_min || /* Not enough threads yet */
-	    (qp->lqueue > cache_param->wthread_add_threshold && /* need more  */
-	    qp->lqueue > qp->last_lqueue)) { /* not getting better since last */
-		if (qp->nthr > cache_param->wthread_max) {
-			Lck_Lock(&pool_mtx);
-			VSC_C_main->threads_limited++;
-			Lck_Unlock(&pool_mtx);
-		} else if (pthread_create(&tp, tp_attr, WRK_thread, qp)) {
-			VSL(SLT_Debug, 0, "Create worker thread failed %d %s",
-			    errno, strerror(errno));
-			Lck_Lock(&pool_mtx);
-			VSC_C_main->threads_failed++;
-			Lck_Unlock(&pool_mtx);
-			VTIM_sleep(cache_param->wthread_fail_delay * 1e-3);
-		} else {
-			AZ(pthread_detach(tp));
-			VTIM_sleep(cache_param->wthread_add_delay * 1e-3);
-			qp->nthr++;
-			Lck_Lock(&pool_mtx);
-			VSC_C_main->threads++;
-			VSC_C_main->threads_created++;
-			Lck_Unlock(&pool_mtx);
-		}
+	if (pthread_create(&tp, tp_attr, WRK_thread, qp)) {
+		VSL(SLT_Debug, 0, "Create worker thread failed %d %s",
+		    errno, strerror(errno));
+		Lck_Lock(&pool_mtx);
+		VSC_C_main->threads_failed++;
+		Lck_Unlock(&pool_mtx);
+		VTIM_sleep(cache_param->wthread_fail_delay);
+	} else {
+		AZ(pthread_detach(tp));
+		qp->dry = 0;
+		qp->nthr++;
+		Lck_Lock(&pool_mtx);
+		VSC_C_main->threads++;
+		VSC_C_main->threads_created++;
+		Lck_Unlock(&pool_mtx);
+		VTIM_sleep(cache_param->wthread_add_delay);
 	}
-	qp->last_lqueue = qp->lqueue;
 }
 
 /*--------------------------------------------------------------------
@@ -378,11 +328,10 @@ static void*
 pool_herder(void *priv)
 {
 	struct pool *pp;
+	struct pool_task *pt;
 	pthread_attr_t tp_attr;
-	struct timespec ts;
 	double t_idle;
 	struct worker *wrk;
-	int i;
 
 	CAST_OBJ_NOTNULL(pp, priv, POOL_MAGIC);
 	AZ(pthread_attr_init(&tp_attr));
@@ -397,55 +346,56 @@ pool_herder(void *priv)
 			AZ(pthread_attr_init(&tp_attr));
 		}
 
-		pool_breed(pp, &tp_attr);
-
-		if (pp->nthr < cache_param->wthread_min)
+		/* Make more threads if needed and allowed */
+		if (pp->nthr < cache_param->wthread_min ||
+		    (pp->dry && pp->nthr < cache_param->wthread_max)) {
+			pool_breed(pp, &tp_attr);
 			continue;
-
-		AZ(clock_gettime(CLOCK_MONOTONIC, &ts));
-		ts.tv_sec += cache_param->wthread_purge_delay / 1000;
-		ts.tv_nsec +=
-		    (cache_param->wthread_purge_delay % 1000) * 1000000;
-		if (ts.tv_nsec >= 1000000000) {
-			ts.tv_sec++;
-			ts.tv_nsec -= 1000000000;
 		}
 
-		Lck_Lock(&pp->herder_mtx);
-		i = Lck_CondWait(&pp->herder_cond, &pp->herder_mtx, &ts);
-		Lck_Unlock(&pp->herder_mtx);
-		if (!i)
-			continue;
+		if (pp->nthr > cache_param->wthread_min) {
 
-		if (pp->nthr <= cache_param->wthread_min)
-			continue;
+			t_idle = VTIM_real() - cache_param->wthread_timeout;
 
-		t_idle = VTIM_real() - cache_param->wthread_timeout;
+			Lck_Lock(&pp->mtx);
+			/* XXX: unsafe counters */
+			VSC_C_main->sess_queued += pp->nqueued;
+			VSC_C_main->sess_dropped += pp->ndropped;
+			pp->nqueued = pp->ndropped = 0;
 
-		Lck_Lock(&pp->mtx);
-		VSC_C_main->sess_queued += pp->nqueued;
-		VSC_C_main->sess_dropped += pp->ndropped;
-		pp->nqueued = pp->ndropped = 0;
-		wrk = pool_getidleworker(pp, 1);
-		if (wrk != NULL && (wrk->lastused < t_idle ||
-		    pp->nthr > cache_param->wthread_max)) {
-			VTAILQ_REMOVE(&pp->idle_queue, &wrk->task, list);
-			AZ(wrk->task.func);
-		} else
 			wrk = NULL;
-		Lck_Unlock(&pp->mtx);
+			pt = VTAILQ_LAST(&pp->idle_queue, taskhead);
+			if (pt != NULL) {
+				AZ(pt->func);
+				CAST_OBJ_NOTNULL(wrk, pt->priv, WORKER_MAGIC);
+
+				if (wrk->lastused < t_idle ||
+				    pp->nthr > cache_param->wthread_max)
+					VTAILQ_REMOVE(&pp->idle_queue,
+					    &wrk->task, list);
+				else
+					wrk = NULL;
+			}
+			Lck_Unlock(&pp->mtx);
 
-		/* And give it a kiss on the cheek... */
-		if (wrk != NULL) {
-			pp->nthr--;
-			Lck_Lock(&pool_mtx);
-			VSC_C_main->threads--;
-			VSC_C_main->threads_destroyed++;
-			Lck_Unlock(&pool_mtx);
-			wrk->task.func = NULL;
-			wrk->task.priv = NULL;
-			AZ(pthread_cond_signal(&wrk->cond));
+			/* And give it a kiss on the cheek... */
+			if (wrk != NULL) {
+				pp->nthr--;
+				Lck_Lock(&pool_mtx);
+				VSC_C_main->threads--;
+				VSC_C_main->threads_destroyed++;
+				Lck_Unlock(&pool_mtx);
+				wrk->task.func = NULL;
+				wrk->task.priv = NULL;
+				VTIM_sleep(cache_param->wthread_destroy_delay);
+				continue;
+			}
 		}
+
+		Lck_Lock(&pp->mtx);
+		if (!pp->dry)
+			(void)Lck_CondWait(&pp->herder_cond, &pp->mtx, NULL);
+		Lck_Unlock(&pp->mtx);
 	}
 	NEEDLESS_RETURN(NULL);
 }
@@ -460,10 +410,10 @@ pool_mkpool(unsigned pool_no)
 	struct pool *pp;
 	struct listen_sock *ls;
 	struct poolsock *ps;
-	pthread_condattr_t cv_attr;
 
 	ALLOC_OBJ(pp, POOL_MAGIC);
-	XXXAN(pp);
+	if (pp == NULL)
+		return (NULL);
 	Lck_New(&pp->mtx, lck_wq);
 
 	VTAILQ_INIT(&pp->idle_queue);
@@ -483,11 +433,7 @@ pool_mkpool(unsigned pool_no)
 		AZ(Pool_Task(pp, &ps->task, POOL_QUEUE_BACK));
 	}
 
-	AZ(pthread_condattr_init(&cv_attr));
-	AZ(pthread_condattr_setclock(&cv_attr, CLOCK_MONOTONIC));
-	AZ(pthread_cond_init(&pp->herder_cond, &cv_attr));
-	AZ(pthread_condattr_destroy(&cv_attr));
-	Lck_New(&pp->herder_mtx, lck_herder);
+	AZ(pthread_cond_init(&pp->herder_cond, NULL));
 	AZ(pthread_create(&pp->herder_thr, NULL, pool_herder, pp));
 
 	return (pp);
diff --git a/bin/varnishd/common/params.h b/bin/varnishd/common/params.h
index 2e8bf37..a66bcf8 100644
--- a/bin/varnishd/common/params.h
+++ b/bin/varnishd/common/params.h
@@ -62,16 +62,15 @@ struct params {
 	/* Worker threads and pool */
 	unsigned		wthread_min;
 	unsigned		wthread_max;
-	unsigned		wthread_timeout;
+	double			wthread_timeout;
 	unsigned		wthread_pools;
 	unsigned		wthread_add_threshold;
-	unsigned		wthread_add_delay;
-	unsigned		wthread_fail_delay;
-	unsigned		wthread_purge_delay;
-	unsigned		wthread_stats_rate;
+	double			wthread_add_delay;
+	double			wthread_fail_delay;
+	double			wthread_destroy_delay;
+	double			wthread_stats_rate;
 	ssize_t			wthread_stacksize;
-
-	unsigned		queue_max;
+	unsigned		wthread_queue_limit;
 
 	/* Memory allocation hints */
 	unsigned		workspace_client;
diff --git a/bin/varnishd/mgt/mgt_param.c b/bin/varnishd/mgt/mgt_param.c
index c425882..859ef14 100644
--- a/bin/varnishd/mgt/mgt_param.c
+++ b/bin/varnishd/mgt/mgt_param.c
@@ -93,7 +93,7 @@ tweak_generic_timeout(struct cli *cli, volatile unsigned *dst, const char *arg)
 
 /*--------------------------------------------------------------------*/
 
-void
+static void
 tweak_timeout(struct cli *cli, const struct parspec *par, const char *arg)
 {
 	volatile unsigned *dest;
@@ -137,7 +137,7 @@ tweak_generic_timeout_double(struct cli *cli, volatile double *dest,
 	return (0);
 }
 
-static void
+void
 tweak_timeout_double(struct cli *cli, const struct parspec *par,
     const char *arg)
 {
diff --git a/bin/varnishd/mgt/mgt_param.h b/bin/varnishd/mgt/mgt_param.h
index b4538d2..ee1ad52 100644
--- a/bin/varnishd/mgt/mgt_param.h
+++ b/bin/varnishd/mgt/mgt_param.h
@@ -53,7 +53,7 @@ struct parspec {
 int tweak_generic_uint(struct cli *cli,
     volatile unsigned *dest, const char *arg, unsigned min, unsigned max);
 void tweak_uint(struct cli *cli, const struct parspec *par, const char *arg);
-void tweak_timeout(struct cli *cli,
+void tweak_timeout_double(struct cli *cli,
     const struct parspec *par, const char *arg);
 void tweak_bytes(struct cli *cli, const struct parspec *par, const char *arg);
 
diff --git a/bin/varnishd/mgt/mgt_pool.c b/bin/varnishd/mgt/mgt_pool.c
index 986d405..385a500 100644
--- a/bin/varnishd/mgt/mgt_pool.c
+++ b/bin/varnishd/mgt/mgt_pool.c
@@ -97,7 +97,8 @@ tweak_thread_pool_max(struct cli *cli, const struct parspec *par,
 /*--------------------------------------------------------------------*/
 
 const struct parspec WRK_parspec[] = {
-	{ "thread_pools", tweak_uint, &mgt_param.wthread_pools, 1, UINT_MAX,
+	{ "thread_pools", tweak_uint, &mgt_param.wthread_pools,
+		1, UINT_MAX,
 		"Number of worker thread pools.\n"
 		"\n"
 		"Increasing number of worker pools decreases lock "
@@ -110,71 +111,69 @@ const struct parspec WRK_parspec[] = {
 		"restart to take effect.",
 		EXPERIMENTAL | DELAYED_EFFECT,
 		"2", "pools" },
-	{ "thread_pool_max", tweak_thread_pool_max, NULL, 1, 0,
+	{ "thread_pool_max", tweak_thread_pool_max, NULL, 10, 0,
 		"The maximum number of worker threads in each pool.\n"
 		"\n"
 		"Do not set this higher than you have to, since excess "
 		"worker threads soak up RAM and CPU and generally just get "
-		"in the way of getting work done.\n",
-		EXPERIMENTAL | DELAYED_EFFECT,
-		"500", "threads" },
-	{ "thread_pool_min", tweak_thread_pool_min, NULL, 2, 0,
+		"in the way of getting work done.\n"
+		"\n"
+		"Minimum is 10 threads.",
+		DELAYED_EFFECT,
+		"5000", "threads" },
+	{ "thread_pool_min", tweak_thread_pool_min, NULL, 10, 0,
 		"The minimum number of worker threads in each pool.\n"
 		"\n"
 		"Increasing this may help ramp up faster from low load "
-		"situations where threads have expired.\n"
-		"\n"
-		"Minimum is 2 threads.",
-		EXPERIMENTAL | DELAYED_EFFECT,
-		"5", "threads" },
-	{ "thread_pool_timeout", tweak_timeout, &mgt_param.wthread_timeout,
-		1, 0,
+		"situations or when threads have expired.\n"
+		"\n"
+		"Minimum is 10 threads.",
+		DELAYED_EFFECT,
+		"100", "threads" },
+	{ "thread_pool_timeout",
+		tweak_timeout_double, &mgt_param.wthread_timeout,
+		10, UINT_MAX,
 		"Thread idle threshold.\n"
 		"\n"
 		"Threads in excess of thread_pool_min, which have been idle "
-		"for at least this long are candidates for purging.\n"
+		"for at least this long, will be destroyed.\n"
 		"\n"
-		"Minimum is 1 second.",
+		"Minimum is 10 seconds.",
 		EXPERIMENTAL | DELAYED_EFFECT,
 		"300", "seconds" },
-	{ "thread_pool_purge_delay",
-		tweak_timeout, &mgt_param.wthread_purge_delay, 100, 0,
-		"Wait this long between purging threads.\n"
+	{ "thread_pool_destroy_delay",
+		tweak_timeout_double, &mgt_param.wthread_destroy_delay,
+		0.01, UINT_MAX,
+		"Wait this long after destroying a thread.\n"
 		"\n"
 		"This controls the decay of thread pools when idle(-ish).\n"
 		"\n"
-		"Minimum is 100 milliseconds.",
+		"Minimum is 0.01 second.",
 		EXPERIMENTAL | DELAYED_EFFECT,
-		"1000", "milliseconds" },
-	{ "thread_pool_add_threshold",
-		tweak_uint, &mgt_param.wthread_add_threshold, 0, UINT_MAX,
-		"Overflow threshold for worker thread creation.\n"
-		"\n"
-		"Setting this too low, will result in excess worker threads, "
-		"which is generally a bad idea.\n"
-		"\n"
-		"Setting it too high results in insuffient worker threads.\n",
-		EXPERIMENTAL,
-		"2", "requests" },
+		"1", "seconds" },
 	{ "thread_pool_add_delay",
-		tweak_timeout, &mgt_param.wthread_add_delay, 0, UINT_MAX,
-		"Wait at least this long between creating threads.\n"
+		tweak_timeout_double, &mgt_param.wthread_add_delay,
+		0, UINT_MAX,
+		"Wait at least this long after creating a thread.\n"
 		"\n"
-		"Setting this too long results in insuffient worker threads.\n"
+		"Some (buggy) systems may need a short (sub-second) "
+		"delay between creating threads.\n"
+		"Set this to a few milliseconds if you see the "
+		"'threads_failed' counter grow too much.\n"
 		"\n"
-		"Setting this too short increases the risk of worker "
-		"thread pile-up.\n",
-		0,
-		"2", "milliseconds" },
+		"Setting this too high results in insuffient worker threads.\n",
+		EXPERIMENTAL,
+		"0", "seconds" },
 	{ "thread_pool_fail_delay",
-		tweak_timeout, &mgt_param.wthread_fail_delay, 100, UINT_MAX,
+		tweak_timeout_double, &mgt_param.wthread_fail_delay,
+		10e-3, UINT_MAX,
 		"Wait at least this long after a failed thread creation "
 		"before trying to create another thread.\n"
 		"\n"
 		"Failure to create a worker thread is often a sign that "
 		" the end is near, because the process is running out of "
-		"RAM resources for thread stacks.\n"
-		"This delay tries to not rush it on needlessly.\n"
+		"some resource.  "
+		"This delay tries to not rush the end on needlessly.\n"
 		"\n"
 		"If thread creation failures are a problem, check that "
 		"thread_pool_max is not too high.\n"
@@ -183,7 +182,7 @@ const struct parspec WRK_parspec[] = {
 		"thread_pool_min, to reduce the rate at which treads are "
 		"destroyed and later recreated.\n",
 		EXPERIMENTAL,
-		"200", "milliseconds" },
+		"0.2", "seconds" },
 	{ "thread_stats_rate",
 		tweak_uint, &mgt_param.wthread_stats_rate, 0, UINT_MAX,
 		"Worker threads accumulate statistics, and dump these into "
@@ -194,13 +193,15 @@ const struct parspec WRK_parspec[] = {
 		"its accumulated stats into the global counters.\n",
 		EXPERIMENTAL,
 		"10", "requests" },
-	{ "queue_max", tweak_uint, &mgt_param.queue_max, 0, UINT_MAX,
-		"Percentage permitted queue length.\n"
+	{ "thread_queue_limit", tweak_uint, &mgt_param.wthread_queue_limit,
+		0, UINT_MAX,
+		"Permitted queue length per thread-pool.\n"
 		"\n"
-		"This sets the ratio of queued requests to worker threads, "
-		"above which sessions will be dropped instead of queued.\n",
+		"This sets the number of requests we will queue, waiting "
+		"for an available thread.  Above this limit sessions will "
+		"be dropped instead of queued.\n",
 		EXPERIMENTAL,
-		"100", "%" },
+		"20", "" },
 	{ "rush_exponent", tweak_uint, &mgt_param.rush_exponent, 2, UINT_MAX,
 		"How many parked request we start for each completed "
 		"request on the object.\n"
diff --git a/bin/varnishtest/tests/c00002.vtc b/bin/varnishtest/tests/c00002.vtc
index 6914736..5351fec 100644
--- a/bin/varnishtest/tests/c00002.vtc
+++ b/bin/varnishtest/tests/c00002.vtc
@@ -5,7 +5,7 @@ server s1 {
 	txresp -hdr "Connection: close" -body "012345\n"
 } -start
 
-varnish v1 -arg "-p thread_pool_min=2 -p thread_pool_max=8 -p thread_pools=4 -p thread_pool_purge_delay=100 -p thread_pool_timeout=1 -p thread_pool_add_delay=100"
+varnish v1 -arg "-p thread_pool_min=10 -p thread_pool_max=10 -p thread_pools=2"
 
 varnish v1 -vcl+backend {} -start
 
@@ -16,4 +16,4 @@ client c1 {
 	expect resp.status == 200
 } -run
 
-varnish v1 -expect threads == 8
+varnish v1 -expect threads == 20