Make http2 context in TfwH2Conn pointer.

In previous commit we decide to allocate 2 pages
after http2 connection and use free space after
http2 connection structure for stream schedulers.
But for negotiable (which can be http1 or http2)
we use http2 connection structure also. So for
such connections (if it is http1 connection) we
allocate 2 pages for stream schedulers which
are not used in fact. Now allocation strategy
was changed: we allocate 2 pages for http2
context, which now is a pointer in http2 connection,
so we don't allocate extra memory for http1 negotiable
connection.

Author: EvgeniiMekhanik

fw/connection.h

@@ -269,7 +269,7 @@ enum {
 /**
  * TLS hardened connection.
  */
-typedef struct {
+typedef struct tfw_tls_conn_t {
 	TfwCliConn	cli_conn;
 	TlsCtx		tls;
 } TfwTlsConn;
@@ -279,9 +279,9 @@ typedef struct {
 /**
  * HTTP/2 connection.
  */
-typedef struct {
+typedef struct tfw_h2_conn_t {
 	TfwTlsConn	tls_conn;
-	TfwH2Ctx	h2;
+	TfwH2Ctx	*h2;
 } TfwH2Conn;
 
 /*
@@ -291,9 +291,7 @@ typedef struct {
  * accessing http2 context, when we are sure and not sure that tls handskare
  * was finished.
  */
-#define tfw_h2_context_unsafe(conn)	((TfwH2Ctx *)(&((TfwH2Conn *)conn)->h2))
-#define tfw_h2_context_safe(conn)	\
-	ttls_hs_done(tfw_tls_context(conn)) ? tfw_h2_context_unsafe(conn) : NULL
+#define tfw_h2_context(conn)	((TfwH2Conn *)conn)->h2
 
 
 /* Callbacks used by l5-l7 protocols to operate on connection level. */

fw/hpack.c

@@ -3564,7 +3564,7 @@ __tfw_hpack_encode(TfwHttpResp *__restrict resp, TfwStr *__restrict hdr,
 	bool st_full_index;
 	unsigned short st_index, index = 0;
 	TfwConn *conn = resp->req->conn;
-	TfwH2Ctx *ctx = tfw_h2_context_unsafe(conn);
+	TfwH2Ctx *ctx = tfw_h2_context(conn);
 	TfwHPackETbl *tbl = &ctx->hpack.enc_tbl;
 	int r = HPACK_IDX_ST_NOT_FOUND;
 	bool name_indexed = true;

fw/http.c

@@ -3037,7 +3037,7 @@ tfw_http_conn_drop(TfwConn *conn)
 
 	if (TFW_CONN_TYPE(conn) & Conn_Clnt) {
 		if (h2_mode) {
-			TfwH2Ctx *ctx = tfw_h2_context_safe(conn);
+			TfwH2Ctx *ctx = tfw_h2_context(conn);
 
 			if (ctx)
 				tfw_h2_conn_streams_cleanup(ctx);
@@ -5305,7 +5305,7 @@ ALLOW_ERROR_INJECTION(tfw_h2_append_predefined_body, ERRNO);
 int
 tfw_http_on_send_resp(void *conn, struct sk_buff **skb_head)
 {
-	TfwH2Ctx *ctx = tfw_h2_context_unsafe((TfwConn *)conn);
+	TfwH2Ctx *ctx = tfw_h2_context((TfwConn *)conn);
 	struct tfw_skb_cb *tfw_cb = TFW_SKB_CB(*skb_head);
 	TfwStream *stream;
 
@@ -5440,7 +5440,7 @@ tfw_h2_error_resp(TfwHttpReq *req, int status, bool reply, ErrorType type,
 {
 	TfwStream *stream;
 	TfwConn *conn = READ_ONCE(req->conn);
-	TfwH2Ctx *ctx = tfw_h2_context_unsafe(conn);
+	TfwH2Ctx *ctx = tfw_h2_context(conn);
 	bool close_after_send = (type == TFW_ERROR_TYPE_ATTACK ||
 		type == TFW_ERROR_TYPE_BAD);
 
@@ -6493,7 +6493,7 @@ tfw_http_req_process(TfwConn *conn, TfwStream *stream, struct sk_buff *skb,
 					HTTP2_ECODE_PROTO);
 		}
 		if (TFW_MSG_H2(req)) {
-			TfwH2Ctx *ctx = tfw_h2_context_unsafe(conn);
+			TfwH2Ctx *ctx = tfw_h2_context(conn);
 
 			/* Do not check the request validity until
 			 * it has been fully parsed.

fw/http2.c

@@ -40,7 +40,7 @@
 static void
 tfw_h2_apply_wnd_sz_change(TfwH2Ctx *ctx, long int delta)
 {
-	TfwH2Conn *conn = container_of(ctx, TfwH2Conn, h2);
+	TfwH2Conn *conn = ctx->conn;
 	TfwStream *stream, *next;
 
 	/*
@@ -71,7 +71,7 @@ static void
 tfw_h2_apply_settings_entry(TfwH2Ctx *ctx, unsigned short id,
 			    unsigned int val)
 {
-	TfwH2Conn *conn = container_of(ctx, TfwH2Conn, h2);
+	TfwH2Conn *conn = ctx->conn;
 	TfwSettings *dest = &ctx->rsettings;
 	long int delta;
 
@@ -120,7 +120,7 @@ tfw_h2_apply_settings_entry(TfwH2Ctx *ctx, unsigned short id,
 int
 tfw_h2_check_settings_entry(TfwH2Ctx *ctx, unsigned short id, unsigned int val)
 {
-	TfwH2Conn *conn = container_of(ctx, TfwH2Conn, h2);
+	TfwH2Conn *conn = ctx->conn;
 
 	assert_spin_locked(&((TfwConn *)conn)->sk->sk_lock.slock);
 
@@ -163,7 +163,7 @@ tfw_h2_check_settings_entry(TfwH2Ctx *ctx, unsigned short id, unsigned int val)
 void
 tfw_h2_save_settings_entry(TfwH2Ctx *ctx, unsigned short id, unsigned int val)
 {
-	TfwH2Conn *conn = container_of(ctx, TfwH2Conn, h2);
+	TfwH2Conn *conn = ctx->conn;
 
 	assert_spin_locked(&((TfwConn *)conn)->sk->sk_lock.slock);
 
@@ -178,7 +178,7 @@ tfw_h2_save_settings_entry(TfwH2Ctx *ctx, unsigned short id, unsigned int val)
 void
 tfw_h2_apply_new_settings(TfwH2Ctx *ctx)
 {
-	TfwH2Conn *conn = container_of(ctx, TfwH2Conn, h2);
+	TfwH2Conn *conn = ctx->conn;
 	unsigned int id;
 
 	assert_spin_locked(&((TfwConn *)conn)->sk->sk_lock.slock);
@@ -204,14 +204,27 @@ tfw_h2_cleanup(void)
 	tfw_h2_stream_cache_destroy();
 }
 
+TfwH2Ctx *
+tfw_h2_context_alloc(void)
+{
+	return (TfwH2Ctx *)kzalloc(sizeof(TfwH2Ctx), GFP_ATOMIC);
+}
+
+void
+tfw_h2_context_free(TfwH2Ctx *ctx)
+{
+	kfree(ctx);
+}
+
 int
-tfw_h2_context_init(TfwH2Ctx *ctx)
+tfw_h2_context_init(TfwH2Ctx *ctx, TfwH2Conn *conn)
 {
 	TfwStreamQueue *closed_streams = &ctx->closed_streams;
 	TfwStreamQueue *idle_streams = &ctx->idle_streams;
 	TfwSettings *lset = &ctx->lsettings;
 	TfwSettings *rset = &ctx->rsettings;
 
+	BUG_ON(!conn || conn->h2 != ctx);
 	bzero_fast(ctx, sizeof(*ctx));
 
 	ctx->state = HTTP2_RECV_CLI_START_SEQ;
@@ -235,6 +248,7 @@ tfw_h2_context_init(TfwH2Ctx *ctx)
 
 	lset->wnd_sz = DEF_WND_SIZE;
 	rset->wnd_sz = DEF_WND_SIZE;
+	ctx->conn = conn;
 
 	return tfw_hpack_init(&ctx->hpack, HPACK_TABLE_DEF_SIZE);
 }
@@ -255,7 +269,7 @@ void
 tfw_h2_conn_terminate_close(TfwH2Ctx *ctx, TfwH2Err err_code, bool close,
 			    bool attack)
 {
-	TfwH2Conn *conn = container_of(ctx, TfwH2Conn, h2);
+	TfwH2Conn *conn = ctx->conn;
 
 	if (tfw_h2_send_goaway(ctx, err_code, attack) && close)
 		tfw_connection_close((TfwConn *)conn, true);
@@ -291,7 +305,7 @@ void
 tfw_h2_conn_streams_cleanup(TfwH2Ctx *ctx)
 {
 	TfwStream *cur, *next;
-	TfwH2Conn *conn = container_of(ctx, TfwH2Conn, h2);
+	TfwH2Conn *conn = ctx->conn;
 	TfwStreamSched *sched = &ctx->sched;
 
 	WARN_ON_ONCE(((TfwConn *)conn)->stream.msg);
@@ -413,7 +427,7 @@ void
 tfw_h2_req_unlink_stream(TfwHttpReq *req)
 {
 	TfwStream *stream;
-	TfwH2Ctx *ctx = tfw_h2_context_unsafe(req->conn);
+	TfwH2Ctx *ctx = tfw_h2_context(req->conn);
 
 	spin_lock(&ctx->lock);
 
@@ -437,7 +451,7 @@ void
 tfw_h2_req_unlink_and_close_stream(TfwHttpReq *req)
 {
 	TfwStream *stream;
-	TfwH2Ctx *ctx = tfw_h2_context_unsafe(req->conn);
+	TfwH2Ctx *ctx = tfw_h2_context(req->conn);
 
 	spin_lock(&ctx->lock);
 

fw/http2.h

@@ -39,14 +39,16 @@
  *                        to accept;
  */
 typedef struct {
-        unsigned int hdr_tbl_sz;
-        unsigned int push;
-        unsigned int max_streams;
-        unsigned int wnd_sz;
-        unsigned int max_frame_sz;
-        unsigned int max_lhdr_sz;
+	unsigned int hdr_tbl_sz;
+	unsigned int push;
+	unsigned int max_streams;
+	unsigned int wnd_sz;
+	unsigned int max_frame_sz;
+	unsigned int max_lhdr_sz;
 } TfwSettings;
 
+typedef struct tfw_conn_t TfwConn;
+
 /**
  * Context for HTTP/2 frames processing.
  *
@@ -80,6 +82,7 @@ typedef struct {
  *                        to save what @new_settings should be applyed. bits
  *                        from _HTTP2_SETTINGS_MAX are used to save what
  *                        settings we sent to the client;
+ * @conn		- pointer to h2 connection of this context;
  * @__off               - offset to reinitialize processing context;
  * @skb_head            - collected list of processed skbs containing HTTP/2
  *                        frames;
@@ -108,59 +111,62 @@ typedef struct {
  * stream (RFC 7540, sections 6.2, 6.10, 8.1).
  */
 typedef struct tfw_h2_ctx_t {
-        spinlock_t      lock;
-        TfwSettings     lsettings;
-        TfwSettings     rsettings;
-        unsigned int    lstream_id;
-        unsigned long   streams_num;
-        TfwStreamSched  sched;
-        TfwStreamQueue  closed_streams;
-        TfwStreamQueue  idle_streams;
-        long int        loc_wnd;
-        long int        rem_wnd;
-        TfwHPack        hpack;
-        TfwStream       *cur_send_headers;
-        TfwStream       *cur_recv_headers;
-        TfwStream       *error;
-        unsigned int    new_settings[_HTTP2_SETTINGS_MAX - 1];
-        DECLARE_BITMAP  (settings_to_apply, 2 * _HTTP2_SETTINGS_MAX - 1);
-        char            __off[0];
-        struct sk_buff  *skb_head;
-        TfwStream       *cur_stream;
-        TfwFramePri     priority;
-        TfwFrameHdr     hdr;
-        unsigned int    plen;
-        int             state;
-        int             to_read;
-        int             rlen;
-        unsigned char   rbuf[FRAME_HEADER_SIZE];
-        unsigned char   padlen;
-        unsigned char   data_off;
+	spinlock_t      lock;
+	TfwSettings     lsettings;
+	TfwSettings     rsettings;
+	unsigned int    lstream_id;
+	unsigned long   streams_num;
+	TfwStreamSched  sched;
+	TfwStreamQueue  closed_streams;
+	TfwStreamQueue  idle_streams;
+	long int        loc_wnd;
+	long int        rem_wnd;
+	TfwHPack        hpack;
+	TfwStream       *cur_send_headers;
+	TfwStream       *cur_recv_headers;
+	TfwStream       *error;
+	unsigned int    new_settings[_HTTP2_SETTINGS_MAX - 1];
+	DECLARE_BITMAP  (settings_to_apply, 2 * _HTTP2_SETTINGS_MAX - 1);
+	TfwH2Conn	*conn;
+	char            __off[0];
+	struct sk_buff  *skb_head;
+	TfwStream       *cur_stream;
+	TfwFramePri     priority;
+	TfwFrameHdr     hdr;
+	unsigned int    plen;
+	int             state;
+	int             to_read;
+	int             rlen;
+	unsigned char   rbuf[FRAME_HEADER_SIZE];
+	unsigned char   padlen;
+	unsigned char   data_off;
 } TfwH2Ctx;
 
 int tfw_h2_init(void);
 void tfw_h2_cleanup(void);
-int tfw_h2_context_init(TfwH2Ctx *ctx);
+TfwH2Ctx *tfw_h2_context_alloc(void);
+void tfw_h2_context_free(TfwH2Ctx *ctx);
+int tfw_h2_context_init(TfwH2Ctx *ctx, TfwH2Conn *conn);
 void tfw_h2_context_clear(TfwH2Ctx *ctx);
 int tfw_h2_check_settings_entry(TfwH2Ctx *ctx, unsigned short id,
-                                unsigned int val);
+				unsigned int val);
 void tfw_h2_save_settings_entry(TfwH2Ctx *ctx, unsigned short id,
-                                unsigned int val);
+				unsigned int val);
 void tfw_h2_apply_new_settings(TfwH2Ctx *ctx);
 void tfw_h2_conn_terminate_close(TfwH2Ctx *ctx, TfwH2Err err_code, bool close,
-                                 bool attack);
+				 bool attack);
 void tfw_h2_conn_streams_cleanup(TfwH2Ctx *ctx);
 void tfw_h2_current_stream_remove(TfwH2Ctx *ctx);
 int tfw_h2_current_stream_send_rst(TfwH2Ctx *ctx, int err_code);
 void tfw_h2_remove_idle_streams(TfwH2Ctx *ctx, unsigned int id);
 void tfw_h2_closed_streams_shrink(TfwH2Ctx *ctx);
 void tfw_h2_check_current_stream_is_closed(TfwH2Ctx *ctx);
 TfwStream *tfw_h2_find_not_closed_stream(TfwH2Ctx *ctx, unsigned int id,
-                                         bool recv);
+					 bool recv);
 void tfw_h2_req_unlink_stream(TfwHttpReq *req);
 void tfw_h2_req_unlink_and_close_stream(TfwHttpReq *req);
 int tfw_h2_stream_xmit_prepare_resp(TfwStream *stream);
 int tfw_h2_entail_stream_skb(struct sock *sk, TfwH2Ctx *ctx, TfwStream *stream,
-                             unsigned int *len, bool should_split);
+			     unsigned int *len, bool should_split);
 
 #endif /* __HTTP2__ */

fw/http_frame.c

@@ -195,7 +195,7 @@ ctx_new_settings_flags[] = {
 static void
 tfw_h2_on_tcp_entail_ack(void *conn, struct sk_buff *skb_head)
 {
-	TfwH2Ctx *ctx = tfw_h2_context_unsafe((TfwConn *)conn);
+	TfwH2Ctx *ctx = tfw_h2_context((TfwConn *)conn);
 
 	if (test_bit(HTTP2_SETTINGS_NEED_TO_APPLY, ctx->settings_to_apply))
 		tfw_h2_apply_new_settings(ctx);
@@ -204,7 +204,7 @@ tfw_h2_on_tcp_entail_ack(void *conn, struct sk_buff *skb_head)
 static int
 tfw_h2_on_send_goaway(void *conn, struct sk_buff **skb_head)
 {
-	TfwH2Ctx *ctx = tfw_h2_context_unsafe((TfwConn *)conn);
+	TfwH2Ctx *ctx = tfw_h2_context((TfwConn *)conn);
 
 	if (ctx->error && ctx->error->xmit.skb_head) {
 		ss_skb_queue_splice(&ctx->error->xmit.skb_head, skb_head);
@@ -224,7 +224,7 @@ tfw_h2_on_send_goaway(void *conn, struct sk_buff **skb_head)
 static int
 tfw_h2_on_send_rst_stream(void *conn, struct sk_buff **skb_head)
 {
-	TfwH2Ctx *ctx = tfw_h2_context_unsafe((TfwConn *)conn);
+	TfwH2Ctx *ctx = tfw_h2_context((TfwConn *)conn);
 	unsigned int stream_id = TFW_SKB_CB(*skb_head)->stream_id;
 	TfwStream *stream;
 
@@ -249,7 +249,7 @@ tfw_h2_on_send_rst_stream(void *conn, struct sk_buff **skb_head)
 static int
 tfw_h2_on_send_dflt(void *conn, struct sk_buff **skb_head)
 {
-	TfwH2Ctx *ctx = tfw_h2_context_unsafe((TfwConn *)conn);
+	TfwH2Ctx *ctx = tfw_h2_context((TfwConn *)conn);
 
 	if (ctx->cur_send_headers) {
 		ss_skb_queue_splice(&ctx->cur_send_headers->xmit.postponed,
@@ -277,7 +277,7 @@ __tfw_h2_send_frame(TfwH2Ctx *ctx, TfwFrameHdr *hdr, TfwStr *data,
 	TfwMsg msg = {};
 	unsigned char buf[FRAME_HEADER_SIZE];
 	TfwStr *hdr_str = TFW_STR_CHUNK(data, 0);
-	TfwH2Conn *conn = container_of(ctx, TfwH2Conn, h2);
+	TfwH2Conn *conn = ctx->conn;
 
 	BUG_ON(hdr_str->data);
 	hdr_str->data = buf;
@@ -682,7 +682,7 @@ tfw_h2_wnd_update_process(TfwH2Ctx *ctx)
 
 	wnd_incr = ntohl(*(unsigned int *)ctx->rbuf) & ((1U << 31) - 1);
 	if (wnd_incr) {
-		TfwH2Conn *conn = container_of(ctx, TfwH2Conn, h2);
+		TfwH2Conn *conn = ctx->conn;
 		long int *window = ctx->cur_stream ?
 			&ctx->cur_stream->rem_wnd : &ctx->rem_wnd;
 
@@ -1685,7 +1685,7 @@ tfw_h2_frame_process(TfwConn *c, struct sk_buff *skb, struct sk_buff **next)
 	int r;
 	bool postponed;
 	unsigned int parsed, unused;
-	TfwH2Ctx *h2 = tfw_h2_context_unsafe(c);
+	TfwH2Ctx *h2 = tfw_h2_context(c);
 	struct sk_buff *nskb = NULL;
 
 next_msg:

fw/http_frame.h

@@ -153,7 +153,7 @@ typedef enum {
 #define MAX_WND_SIZE			((1U << 31) - 1)
 #define DEF_WND_SIZE			((1U << 16) - 1)
 
-typedef struct tfw_conn_t TfwConn;
+typedef struct tfw_h2_conn_t TfwH2Conn;
 
 int tfw_h2_frame_process(TfwConn *c, struct sk_buff *skb,
 			 struct sk_buff **next);