Further dismemberments of h2_task into the h2_conn_ctx_t.

 * placed all task input chunking related items in the context of the
   filter handling function.

Author: Stefan Eissing

mod_http2/h2_config.c

@@ -423,18 +423,11 @@ static void h2_config_seti64(h2_dir_config *dconf, h2_config *conf, h2_config_va
 
 static const h2_config *h2_config_get(conn_rec *c)
 {
-    h2_conn_ctx_t *ctx = h2_conn_ctx_get(c);
+    h2_conn_ctx_t *conn_ctx = h2_conn_ctx_get(c);
 
-    if (ctx) {
-        if (ctx->config) {
-            return ctx->config;
-        }
-        else if (ctx->server) {
-            ctx->config = h2_config_sget(ctx->server);
-            return ctx->config;
-        }
+    if (conn_ctx && conn_ctx->server) {
+        return h2_config_sget(conn_ctx->server);
     }
-    
     return h2_config_sget(c->base_server);
 }
 

mod_http2/h2_ctx.c

@@ -20,43 +20,67 @@
 #include <httpd.h>
 #include <http_core.h>
 #include <http_config.h>
+#include <http_log.h>
 
 #include "h2_private.h"
 #include "h2_session.h"
+#include "h2_bucket_beam.h"
 #include "h2_task.h"
 #include "h2_stream.h"
 #include "h2_ctx.h"
 
 
-static h2_conn_ctx_t *ctx_create(const conn_rec *c, const char *id)
+void h2_conn_ctx_detach(conn_rec *c)
 {
-    h2_conn_ctx_t *ctx = apr_pcalloc(c->pool, sizeof(*ctx));
-    ctx->id = id;
-    ctx->server = c->base_server;
-    ap_set_module_config(c->conn_config, &http2_module, ctx);
-    return ctx;
+    h2_conn_ctx_t *conn_ctx = h2_conn_ctx_get(c);
+
+    if (conn_ctx && conn_ctx->task && conn_ctx->task->output.beam) {
+        h2_beam_log(conn_ctx->task->output.beam, c, APLOG_TRACE2, "task_destroy");
+        h2_beam_destroy(conn_ctx->task->output.beam);
+        conn_ctx->task->output.beam = NULL;
+    }
+    ap_set_module_config(c->conn_config, &http2_module, NULL);
+}
+
+static h2_conn_ctx_t *ctx_create(apr_pool_t *pool, conn_rec *c, const char *id)
+{
+    h2_conn_ctx_t *conn_ctx = apr_pcalloc(pool, sizeof(*conn_ctx));
+    conn_ctx->id = id;
+    conn_ctx->pool = pool;
+    conn_ctx->server = c->base_server;
+    conn_ctx->started_at = apr_time_now();
+    ap_set_module_config(c->conn_config, &http2_module, conn_ctx);
+    return conn_ctx;
 }
 
-h2_conn_ctx_t *h2_conn_ctx_create(const conn_rec *c)
+void h2_conn_ctx_destroy(h2_conn_ctx_t *conn_ctx)
 {
-    return ctx_create(c, apr_psprintf(c->pool, "%ld", c->id));
+    apr_pool_destroy(conn_ctx->pool);
 }
 
-h2_conn_ctx_t *h2_conn_ctx_create_secondary(const conn_rec *c, struct h2_stream *stream)
+h2_conn_ctx_t *h2_conn_ctx_create(conn_rec *c)
 {
+    return ctx_create(c->pool, c, apr_psprintf(c->pool, "%ld", c->id));
+}
+
+h2_conn_ctx_t *h2_conn_ctx_create_secondary(conn_rec *c, struct h2_stream *stream)
+{
+    const char *id;
+    h2_conn_ctx_t *ctx;
+    apr_pool_t *pool;
+
     /* there is sth fishy going on in some mpms that change the id of
      * a connection when they process it in another thread. stick to
      * the id the session was initialized with. */
-    h2_conn_ctx_t *ctx = ctx_create(c, apr_psprintf(
-        c->pool, "%ld-%d", stream->session->id, stream->id));
+    apr_pool_create(&pool, c->pool);
+    apr_pool_tag(pool, "h2_secondary");
+    id = apr_psprintf(pool, "%ld-%d", stream->session->id, stream->id);
+    ctx = ctx_create(pool, c, id);
     ctx->mplx = stream->session->mplx;
-    return ctx;
-}
+    ctx->stream_id = stream->id;
+    ctx->request = stream->request;
 
-void h2_conn_ctx_clear(const conn_rec *c)
-{
-    ap_assert(c);
-    ap_set_module_config(c->conn_config, &http2_module, NULL);
+    return ctx;
 }
 
 h2_session *h2_conn_ctx_get_session(conn_rec *c)

mod_http2/h2_ctx.h

@@ -21,7 +21,6 @@ struct h2_session;
 struct h2_stream;
 struct h2_mplx;
 struct h2_task;
-struct h2_config;
 
 /**
  * The h2 module context associated with a connection. 
@@ -33,12 +32,20 @@ struct h2_config;
  */
 struct h2_conn_ctx_t {
     const char *id;                 /* our identifier of this connection */
-    const char *protocol;           /* the protocol negotiated */
+    apr_pool_t *pool;               /* main: session pool, secondary: task pool */
     server_rec *server;             /* httpd server selected. */
+    const char *protocol;           /* the protocol negotiated */
     struct h2_session *session;     /* on main: the session established */
+
     struct h2_mplx *mplx;           /* on secondary: the multiplexer */
+    int stream_id;                  /* on main: 0, on secondary: stream id */
+    const struct h2_request *request; /* on secondary: the request to process */
     struct h2_task *task;           /* on secondary: the task processed */
-    const struct h2_config *config; /* effective config in this context */
+    int filters_set;                 /* protocol filters have been set up */
+
+    volatile int done;               /* processing has finished */
+    apr_time_t started_at;           /* when processing started */
+    apr_time_t done_at;              /* when processing was done */
 };
 typedef struct h2_conn_ctx_t h2_conn_ctx_t;
 
@@ -48,18 +55,23 @@ typedef struct h2_conn_ctx_t h2_conn_ctx_t;
  * @return h2 context of this connection
  */
 #define h2_conn_ctx_get(c) \
-    ((h2_conn_ctx_t*)ap_get_module_config((c)->conn_config, &http2_module))
+    ((c)? (h2_conn_ctx_t*)ap_get_module_config((c)->conn_config, &http2_module) : NULL)
 
 /**
  * Create the h2 connection context.
  * @param c the connection to create it at
  * @return created h2 context of this connection
  */
-h2_conn_ctx_t *h2_conn_ctx_create(const conn_rec *c);
+h2_conn_ctx_t *h2_conn_ctx_create(conn_rec *c);
 
-h2_conn_ctx_t *h2_conn_ctx_create_secondary(const conn_rec *c, struct h2_stream *stream);
+h2_conn_ctx_t *h2_conn_ctx_create_secondary(conn_rec *c, struct h2_stream *stream);
 
-void h2_conn_ctx_clear(const conn_rec *c);
+void h2_conn_ctx_detach(conn_rec *c);
+
+/**
+ * Distach from the connection and destroy all resources, e.g. the pool.
+ */
+void h2_conn_ctx_destroy(h2_conn_ctx_t *conn_ctx);
 
 /**
  * Get the session instance if `c` is a HTTP/2 master connection.

mod_http2/h2_filter.c

@@ -430,10 +430,10 @@ static void add_stats(apr_bucket_brigade *bb, h2_session *s,
     bbout(bb, "  }%s\n", last? "" : ",");
 }
 
-static apr_status_t h2_status_insert(h2_task *task, apr_bucket *b)
+static apr_status_t h2_status_insert(h2_conn_ctx_t *conn_ctx, apr_bucket *b)
 {
-    h2_mplx *m = task->mplx;
-    h2_stream *stream = h2_mplx_t_stream_get(m, task);
+    h2_mplx *m = conn_ctx->mplx;
+    h2_stream *stream = h2_mplx_t_stream_get(m, conn_ctx->stream_id);
     h2_session *s;
     conn_rec *c;
 
@@ -487,7 +487,7 @@ static apr_status_t status_event(void *userdata, h2_bucket_event event,
                       "status_event(%s): %d", ctx->id, event);
         switch (event) {
             case H2_BUCKET_EV_BEFORE_MASTER_SEND:
-                h2_status_insert(ctx->task, b);
+                h2_status_insert(ctx, b);
                 break;
             default:
                 break;
@@ -545,7 +545,7 @@ static apr_status_t discard_body(request_rec *r, apr_off_t maxlen)
 int h2_filter_h2_status_handler(request_rec *r)
 {
     conn_rec *c = r->connection;
-    h2_task *task;
+    h2_conn_ctx_t *conn_ctx = h2_conn_ctx_get(c);
     apr_bucket_brigade *bb;
     apr_bucket *b;
     apr_status_t status;
@@ -557,8 +557,7 @@ int h2_filter_h2_status_handler(request_rec *r)
         return DECLINED;
     }
 
-    task = h2_conn_ctx_get_task(r->connection);
-    if (task) {
+    if (conn_ctx && conn_ctx->stream_id) {
         /* In this handler, we do some special sauce to send footers back,
          * IFF we received footers in the request. This is used in our test
          * cases, since CGI has no way of handling those. */
@@ -588,11 +587,11 @@ int h2_filter_h2_status_handler(request_rec *r)
 
         ap_log_rerror(APLOG_MARK, APLOG_TRACE2, 0, r,
                       "status_handler(%s): checking for incoming trailers", 
-                      task->id);
+                      conn_ctx->id);
         if (r->trailers_in && !apr_is_empty_table(r->trailers_in)) {
             ap_log_rerror(APLOG_MARK, APLOG_TRACE2, 0, r,
                           "status_handler(%s): seeing incoming trailers", 
-                          task->id);
+                          conn_ctx->id);
             apr_table_setn(r->trailers_out, "h2-trailers-in", 
                            apr_itoa(r->pool, 1));
         }
@@ -607,7 +606,7 @@ int h2_filter_h2_status_handler(request_rec *r)
             /* no way to know what type of error occurred */
             ap_log_rerror(APLOG_MARK, APLOG_TRACE1, status, r,
                           "status_handler(%s): ap_pass_brigade failed", 
-                          task->id);
+                          conn_ctx->id);
             return AP_FILTER_ERROR;
         }
     }