Unify the H1/H2 reembark code.

bin/varnishd/cache/cache_req_fsm.c

@@ -50,6 +50,34 @@
 #include "vsha256.h"
 #include "vtim.h"
 
+/*--------------------------------------------------------------------
+ * Reschedule a request from the waiting list
+ */
+
+int
+CNT_Reembark(struct worker *wrk, struct req *req)
+{
+
+	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+
+	if (!DO_DEBUG(DBG_FAILRESCHED) &&
+	    !SES_Reschedule_Req(req, TASK_QUEUE_REQ))
+		return (0);
+
+	/* Couldn't schedule, ditch */
+	wrk->stats->busy_wakeup--;
+	wrk->stats->busy_killed++;
+	VSLb(req->vsl, SLT_Error, "Fail to reschedule req from waiting list");
+
+	AN(req->ws->r);
+	WS_Release(req->ws, 0);
+	AN(req->hash_objhead);
+	(void)HSH_DerefObjHead(wrk, &req->hash_objhead);
+	AZ(req->hash_objhead);
+	return(-1);
+}
+
 /*--------------------------------------------------------------------
  * Handle "Expect:" and "Connection:" on incoming request
  */

bin/varnishd/cache/cache_varnishd.h

@@ -335,6 +335,7 @@ enum req_fsm_nxt {
 };
 
 enum req_fsm_nxt CNT_Request(struct worker *, struct req *);
+int CNT_Reembark(struct worker *, struct req *);
 
 /* cache_session.c */
 void SES_NewPool(struct pool *, unsigned pool_no);

bin/varnishd/http1/cache_http1_fsm.c

@@ -47,7 +47,6 @@
 
 static const char H1NEWREQ[] = "HTTP1::NewReq";
 static const char H1PROC[] = "HTTP1::Proc";
-static const char H1BUSY[] = "HTTP1::Busy";
 static const char H1CLEANUP[] = "HTTP1::Cleanup";
 
 static void HTTP1_Session(struct worker *, struct req *);
@@ -206,42 +205,19 @@ http1_req_cleanup(struct sess *sp, struct worker *wrk, struct req *req)
  * Clean up a req from waiting list which cannot complete
  */
 
-static void
-http1_cleanup_waiting(struct worker *wrk, struct req *req,
-    enum sess_close reason)
-{
-	struct sess *sp;
-
-	sp = req->sp;
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-	AN(req->ws->r);
-	WS_Release(req->ws, 0);
-	AN(req->hash_objhead);
-	(void)HSH_DerefObjHead(wrk, &req->hash_objhead);
-	AZ(req->hash_objhead);
-	SES_Close(sp, reason);
-	AN(http1_req_cleanup(sp, wrk, req));
-}
-
 static void v_matchproto_(vtr_reembark_f)
 http1_reembark(struct worker *wrk, struct req *req)
 {
-	struct sess *sp;
 
-	sp = req->sp;
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
-
-	http1_setstate(sp, H1BUSY);
+	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
+	assert(req->transport == &HTTP1_transport);
 
-	if (!DO_DEBUG(DBG_FAILRESCHED) &&
-	    !SES_Reschedule_Req(req, TASK_QUEUE_REQ))
+	if (!CNT_Reembark(wrk, req))
 		return;
 
-	/* Couldn't schedule, ditch */
-	wrk->stats->busy_wakeup--;
-	wrk->stats->busy_killed++;
-	VSLb(req->vsl, SLT_Error, "Fail to reschedule req from waiting list");
-	http1_cleanup_waiting(wrk, req, SC_OVERLOAD);
+	SES_Close(req->sp, SC_OVERLOAD);
+	AN(http1_req_cleanup(req->sp, wrk, req));
 }
 
 static int v_matchproto_(vtr_minimal_response_f)
@@ -489,17 +465,6 @@ HTTP1_Session(struct worker *wrk, struct req *req)
 			}
 			req->req_step = R_STP_TRANSPORT;
 			http1_setstate(sp, H1PROC);
-		} else if (st == H1BUSY) {
-			CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);
-			/*
-			 * Return from waitinglist.
-			 * Check to see if the remote has left.
-			 */
-			if (VTCP_check_hup(sp->fd)) {
-				http1_cleanup_waiting(wrk, req, SC_REM_CLOSE);
-				return;
-			}
-			http1_setstate(sp, H1PROC);
 		} else if (st == H1PROC) {
 			req->task.func = http1_req;
 			req->task.priv = req;

bin/varnishd/http2/cache_http2.h

@@ -233,7 +233,6 @@ void h2_kill_req(struct worker *, const struct h2_sess *,
 int h2_rxframe(struct worker *, struct h2_sess *);
 h2_error h2_set_setting(struct h2_sess *, const uint8_t *);
 void h2_req_body(struct req*);
-void h2_cleanup_waiting(struct worker *wrk, struct h2_req *r2);
 task_func_t h2_do_req;
 #ifdef TRANSPORT_MAGIC
 vtr_req_fail_f h2_req_fail;

bin/varnishd/http2/cache_http2_proto.c

@@ -1149,21 +1149,3 @@ h2_rxframe(struct worker *wrk, struct h2_sess *h2)
 	}
 	return (h2e ? 0 : 1);
 }
-
-void
-h2_cleanup_waiting(struct worker *wrk, struct h2_req *r2)
-{
-	CHECK_OBJ_NOTNULL(r2, H2_REQ_MAGIC);
-	CHECK_OBJ_NOTNULL(r2->req, REQ_MAGIC);
-	CHECK_OBJ_NOTNULL(r2->h2sess, H2_SESS_MAGIC);
-
-	AN(r2->req->ws->r);
-	WS_Release(r2->req->ws, 0);
-	AN(r2->req->hash_objhead);
-	(void)HSH_DerefObjHead(wrk, &r2->req->hash_objhead);
-	AZ(r2->req->hash_objhead);
-	assert(r2->state == H2_S_CLOS_REM);
-	AN(r2->scheduled);
-	r2->scheduled = 0;
-	r2->h2sess->do_sweep = 1;
-}

bin/varnishd/http2/cache_http2_session.c

@@ -437,26 +437,22 @@ h2_new_session(struct worker *wrk, void *arg)
 static void v_matchproto_(vtr_reembark_f)
 h2_reembark(struct worker *wrk, struct req *req)
 {
-	struct sess *sp;
 	struct h2_req *r2;
 
-	sp = req->sp;
-	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
+	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
+	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
 	assert(req->transport == &H2_transport);
 
-	if (!DO_DEBUG(DBG_FAILRESCHED) &&
-	    !SES_Reschedule_Req(req, TASK_QUEUE_STR))
+	if (!CNT_Reembark(wrk, req))
 		return;
 
-	/* Couldn't schedule, ditch */
-	wrk->stats->busy_wakeup--;
-	wrk->stats->busy_killed++;
 	CAST_OBJ_NOTNULL(r2, req->transport_priv, H2_REQ_MAGIC);
-	VSLb(req->vsl, SLT_Error, "Fail to reschedule req from waiting list");
-	h2_cleanup_waiting(wrk, r2);
+	assert(r2->state == H2_S_CLOS_REM);
+	AN(r2->scheduled);
+	r2->scheduled = 0;
+	r2->h2sess->do_sweep = 1;
 }
 
-
 struct transport H2_transport = {
 	.name =			"H2",
 	.magic =		TRANSPORT_MAGIC,