hash: New HSH_WalkAway() function

When there's no rush, a request can simply walk away from the queue.

The concept is simple: when a factor (pun intended) other than the
backend fetch requires the request to leave the queue, it can just
walk away. It short-circuits the usual rush exit.

We can repurpose the dead counter busy_killed to count those events,
and get rid of the dead enum entry HSH_CONTINUE.

Author: dridi

bin/varnishd/cache/cache_hash.c

@@ -464,6 +464,12 @@ HSH_Lookup(struct req *req, struct objcore **ocp, struct objcore **bocp)
 	CHECK_OBJ_NOTNULL(oh, OBJHEAD_MAGIC);
 	Lck_AssertHeld(&oh->mtx);
 
+	if (req->walkaway) {
+		assert(oh->refcnt > 0);
+		(void)hsh_deref_objhead_unlock(wrk, &oh, 0);
+		return (HSH_WALKAWAY);
+	}
+
 	if (req->hash_always_miss) {
 		/* XXX: should we do predictive Vary in this case ? */
 		/* Insert new objcore in objecthead and release mutex */
@@ -699,6 +705,42 @@ hsh_rush2(struct worker *wrk, struct rush *r)
 	}
 }
 
+void
+HSH_WalkAway(struct worker *wrk, struct objhead **ohp, struct req *req)
+{
+	struct objhead *oh;
+	struct rush r[1];
+
+	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	TAKE_OBJ_NOTNULL(oh, ohp, OBJHEAD_MAGIC);
+
+	INIT_OBJ(r, RUSH_MAGIC);
+	VTAILQ_INIT(&r->reqs);
+
+	if (DO_DEBUG(DBG_WAITINGLIST))
+		VSLb(req->vsl, SLT_Debug, "walking away <%p>", oh);
+
+	Lck_Lock(&oh->mtx);
+	if (req->waitinglist) {
+		assert(oh == req->hash_objhead);
+		assert(oh->refcnt > 1);
+		oh->refcnt--;
+		VTAILQ_REMOVE(&oh->waitinglist, req, w_list);
+		VTAILQ_INSERT_TAIL(&r->reqs, req, w_list);
+		Lck_Unlock(&oh->mtx);
+
+		wrk->stats->busy_killed++;
+		AZ(req->walkaway);
+		req->walkaway = 1;
+		hsh_rush2(wrk, r);
+	} else {
+		AZ(req->hash_objhead);
+		assert(oh->refcnt > 0);
+		(void)hsh_deref_objhead_unlock(wrk, &oh, 0);
+	}
+}
+
 /*---------------------------------------------------------------------
  * Purge an entire objhead
  */

bin/varnishd/cache/cache_objhead.h

@@ -76,3 +76,4 @@ unsigned HSH_Purge(struct worker *, struct objhead *, vtim_real ttl_now,
     vtim_dur ttl, vtim_dur grace, vtim_dur keep);
 struct objcore *HSH_Private(const struct worker *wrk);
 void HSH_Cancel(struct worker *, struct objcore *, struct boc *);
+void HSH_WalkAway(struct worker *wrk, struct objhead **ohp, struct req *req);

bin/varnishd/cache/cache_req_fsm.c

@@ -561,6 +561,21 @@ cnt_lookup(struct worker *wrk, struct req *req)
 		had_objhead = 1;
 	wrk->strangelove = 0;
 	lr = HSH_Lookup(req, &oc, &busy);
+	if (lr == HSH_WALKAWAY) {
+		VRY_Finish(req, DISCARD);
+		AZ(req->objcore);
+		AZ(req->stale_oc);
+		VSLb_ts_req(req, "Waitinglist", W_TIM_real(wrk));
+		VSLb(req->vsl, SLT_Error, "The client is going away");
+		if (req->esi_level > 0) {
+			/* NB: Interrupt delivery upwards to avoid engaging
+			 * new sub-request tasks.
+			 */
+			req->req_step = R_STP_VCLFAIL;
+			return (REQ_FSM_MORE);
+		}
+		return (REQ_FSM_DONE);
+	}
 	if (lr == HSH_BUSY) {
 		/*
 		 * We lost the session to a busy object, disembark the

bin/varnishd/hash/hash_slinger.h

@@ -52,7 +52,7 @@ struct hash_slinger {
 };
 
 enum lookup_e {
-	HSH_CONTINUE,
+	HSH_WALKAWAY,
 	HSH_MISS,
 	HSH_BUSY,
 	HSH_HIT,

include/tbl/req_flags.h

@@ -42,6 +42,7 @@ REQ_FLAG(is_hitpass,		1, 0, "")
 REQ_FLAG(waitinglist,		0, 0, "")
 REQ_FLAG(want100cont,		0, 0, "")
 REQ_FLAG(late100cont,		0, 0, "")
+REQ_FLAG(walkaway,		0, 0, "")
 #undef REQ_FLAG
 
 /*lint -restore */

lib/libvsc/VSC_main.vsc

@@ -319,10 +319,11 @@
 	Number of requests taken off the busy object sleep list and rescheduled.
 
 .. varnish_vsc:: busy_killed
+	:group: wrk
 	:oneliner:	Number of requests killed after sleep on busy objhdr
 
 	Number of requests killed from the busy object sleep list due to
-	lack of resources.
+	the client going away.
 
 .. varnish_vsc:: sess_queued
 	:oneliner:	Sessions queued for thread