net/tls: Add support for async encryption of records for performance

In current implementation, tls records are encrypted & transmitted
serially. Till the time the previously submitted user data is encrypted,
the implementation waits and on finish starts transmitting the record.
This approach of encrypt-one record at a time is inefficient when
asynchronous crypto accelerators are used. For each record, there are
overheads of interrupts, driver softIRQ scheduling etc. Also the crypto
accelerator sits idle most of time while an encrypted record's pages are
handed over to tcp stack for transmission.

This patch enables encryption of multiple records in parallel when an
async capable crypto accelerator is present in system. This is achieved
by allowing the user space application to send more data using sendmsg()
even while previously issued data is being processed by crypto
accelerator. This requires returning the control back to user space
application after submitting encryption request to accelerator. This
also means that zero-copy mode of encryption cannot be used with async
accelerator as we must be done with user space application buffer before
returning from sendmsg().

There can be multiple records in flight to/from the accelerator. Each of
the record is represented by 'struct tls_rec'. This is used to store the
memory pages for the record.

After the records are encrypted, they are added in a linked list called
tx_ready_list which contains encrypted tls records sorted as per tls
sequence number. The records from tx_ready_list are transmitted using a
newly introduced function called tls_tx_records(). The tx_ready_list is
polled for any record ready to be transmitted in sendmsg(), sendpage()
after initiating encryption of new tls records. This achieves parallel
encryption and transmission of records when async accelerator is
present.

There could be situation when crypto accelerator completes encryption
later than polling of tx_ready_list by sendmsg()/sendpage(). Therefore
we need a deferred work context to be able to transmit records from
tx_ready_list. The deferred work context gets scheduled if applications
are not sending much data through the socket. If the applications issue
sendmsg()/sendpage() in quick succession, then the scheduling of
tx_work_handler gets cancelled as the tx_ready_list would be polled from
application's context itself. This saves scheduling overhead of deferred
work.

The patch also brings some side benefit. We are able to get rid of the
concept of CLOSED record. This is because the records once closed are
either encrypted and then placed into tx_ready_list or if encryption
fails, the socket error is set. This simplifies the kernel tls
sendpath. However since tls_device.c is still using macros, accessory
functions for CLOSED records have been retained.

Signed-off-by: Vakul Garg <vakul.garg@nxp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 21 insertions, 33 deletions

diff --git a/net/tls/tls_main.c b/net/tls/tls_main.c
index 523622dc74f8..06094de7a3d9 100644
--- a/net/tls/tls_main.c
+++ b/net/tls/tls_main.c
@@ -141,7 +141,6 @@ retry:
                 size = sg->length;
         }
 
-        clear_bit(TLS_PENDING_CLOSED_RECORD, &ctx->flags);
         ctx->in_tcp_sendpages = false;
         ctx->sk_write_space(sk);
 
@@ -193,15 +192,12 @@ int tls_proccess_cmsg(struct sock *sk, struct msghdr *msg,
         return rc;
 }
 
-int tls_push_pending_closed_record(struct sock *sk, struct tls_context *ctx,
-                                   int flags, long *timeo)
+int tls_push_partial_record(struct sock *sk, struct tls_context *ctx,
+                            int flags)
 {
         struct scatterlist *sg;
         u16 offset;
 
-        if (!tls_is_partially_sent_record(ctx))
-                return ctx->push_pending_record(sk, flags);
-
         sg = ctx->partially_sent_record;
         offset = ctx->partially_sent_offset;
 
@@ -209,9 +205,23 @@ int tls_push_pending_closed_record(struct sock *sk, struct tls_context *ctx,
         return tls_push_sg(sk, ctx, sg, offset, flags);
 }
 
+int tls_push_pending_closed_record(struct sock *sk,
+                                   struct tls_context *tls_ctx,
+                                   int flags, long *timeo)
+{
+        struct tls_sw_context_tx *ctx = tls_sw_ctx_tx(tls_ctx);
+
+        if (tls_is_partially_sent_record(tls_ctx) ||
+            !list_empty(&ctx->tx_ready_list))
+                return tls_tx_records(sk, flags);
+        else
+                return tls_ctx->push_pending_record(sk, flags);
+}
+
 static void tls_write_space(struct sock *sk)
 {
         struct tls_context *ctx = tls_get_ctx(sk);
+        struct tls_sw_context_tx *tx_ctx = tls_sw_ctx_tx(ctx);
 
         /* If in_tcp_sendpages call lower protocol write space handler
          * to ensure we wake up any waiting operations there. For example
@@ -222,20 +232,11 @@ static void tls_write_space(struct sock *sk)
                 return;
         }
 
-        if (!sk->sk_write_pending && tls_is_pending_closed_record(ctx)) {
-                gfp_t sk_allocation = sk->sk_allocation;
-                int rc;
-                long timeo = 0;
-
-                sk->sk_allocation = GFP_ATOMIC;
-                rc = tls_push_pending_closed_record(sk, ctx,
-                                                    MSG_DONTWAIT |
-                                                    MSG_NOSIGNAL,
-                                                    &timeo);
-                sk->sk_allocation = sk_allocation;
-
-                if (rc < 0)
-                        return;
+        /* Schedule the transmission if tx list is ready */
+        if (is_tx_ready(ctx, tx_ctx) && !sk->sk_write_pending) {
+                /* Schedule the transmission */
+                if (!test_and_set_bit(BIT_TX_SCHEDULED, &tx_ctx->tx_bitmask))
+                        schedule_delayed_work(&tx_ctx->tx_work.work, 0);
         }
 
         ctx->sk_write_space(sk);
@@ -270,19 +271,6 @@ static void tls_sk_proto_close(struct sock *sk, long timeout)
         if (!tls_complete_pending_work(sk, ctx, 0, &timeo))
                 tls_handle_open_record(sk, 0);
 
-        if (ctx->partially_sent_record) {
-                struct scatterlist *sg = ctx->partially_sent_record;
-
-                while (1) {
-                        put_page(sg_page(sg));
-                        sk_mem_uncharge(sk, sg->length);
-
-                        if (sg_is_last(sg))
-                                break;
-                        sg++;
-                }
-        }
-
         /* We need these for tls_sw_fallback handling of other packets */
         if (ctx->tx_conf == TLS_SW) {
                 kfree(ctx->tx.rec_seq);